From ccd61cfc548da55ed21048b7684d686a592c97a3 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 04:19:13 -0700 Subject: [PATCH 01/17] demo update v0 --- run_mujoco_simulation.py | 63 +++++++++++++ utils/fluidize_demo.ipynb | 191 ++++---------------------------------- 2 files changed, 81 insertions(+), 173 deletions(-) create mode 100644 run_mujoco_simulation.py diff --git a/run_mujoco_simulation.py b/run_mujoco_simulation.py new file mode 100644 index 0000000..ef69f00 --- /dev/null +++ b/run_mujoco_simulation.py @@ -0,0 +1,63 @@ +""" +Script to run the MuJoCo simulation using FluidizeClient. + +This script demonstrates how to use the fluidize client to execute +the cartpole parameter tuning simulation. +""" + +from fluidize import FluidizeClient +from fluidize.core.types.runs import RunFlowPayload + + +def main(): + """Run the MuJoCo cartpole simulation.""" + print("šŸš€ Starting MuJoCo Simulation via Fluidize Client") + print("=" * 60) + + try: + # Initialize client in local mode + print("šŸ“¦ Initializing FluidizeClient in local mode...") + client = FluidizeClient(mode="local") + print(f"āœ… Client initialized: {client}") + + # Get the MUJOCO project + print("\nšŸ“ Getting MUJOCO project...") + project = client.projects.get("MUJOCO") + print(f"āœ… Project found: {project}") + + # Create run payload + payload = RunFlowPayload( + name="MuJoCo Cartpole Parameter Tuning Demo", + description="Cartpole balancing simulation testing different control gain parameters to demonstrate parameter tuning effects", + tags=["mujoco", "cartpole", "parameter-tuning", "control-systems", "demo"], + ) + print(f"\nšŸŽÆ Payload created: {payload.name}") + + # Run the flow + print("\nšŸƒ Starting simulation flow...") + result = project.runs.run_flow(payload) + print(f"āœ… Flow execution result: {result}") + + print("\n" + "=" * 60) + print("šŸŽ‰ MuJoCo simulation flow started successfully!") + print(f"šŸ“Š Flow Status: {result.get('flow_status', 'Unknown')}") + print(f"šŸ”¢ Run Number: {result.get('run_number', 'Unknown')}") + print("\nšŸ’” The simulation will:") + print(" ā€¢ Test 4 different control gain values (5.0, 10.0, 20.0, 50.0)") + print(" ā€¢ Generate MP4 videos showing cartpole behavior for each gain") + print(" ā€¢ Create comparison plots showing performance vs parameters") + print(" ā€¢ Save structured results to JSON") + print("\nšŸ“ Check the output directory for results:") + print(f" {project._project_summary.location}/Mujoco-Simulation/source/outputs/") + + except Exception as e: + print(f"āŒ Error running simulation: {e}") + print("\nšŸ” Troubleshooting tips:") + print(" ā€¢ Ensure Docker is running and accessible") + print(" ā€¢ Check that the MUJOCO project exists in ~/.fluidize/projects/") + print(" ā€¢ Verify the project structure is correct") + raise + + +if __name__ == "__main__": + main() diff --git a/utils/fluidize_demo.ipynb b/utils/fluidize_demo.ipynb index 9dc1946..bf82abc 100644 --- a/utils/fluidize_demo.ipynb +++ b/utils/fluidize_demo.ipynb @@ -170,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -178,7 +178,7 @@ "output_type": "stream", "text": [ "\ud83c\udfaf Working with project: MUJOCO DEMO\n", - "\ud83d\udcca Current graph state: 0 nodes, 0 edges\n" + "\ud83d\udcca Current graph state: 1 nodes, 0 edges\n" ] } ], @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -251,7 +251,7 @@ "# 2. Create nodeProperties (container and execution configuration)\n", "mujoco_properties = nodeProperties_simulation(\n", " # Required fields\n", - " container_image=\"nvidia/cuda:11.8-devel-ubuntu20.04\", # Docker image with CUDA support\n", + " container_image=\"\", # Docker image with CUDA support\n", " simulation_mount_path=\"source\", # Mount path inside container\n", " source_output_folder=\"source/outputs\", # Where outputs are stored\n", ")\n", @@ -314,137 +314,6 @@ "print(f\" Simulation ID: {created_node.data.simulation_id}\")\n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Minimal Node Creation Example\n", - "\n", - "For simpler use cases, here's a minimal example with only required fields:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Minimal node creation with only required fields\n", - "minimal_node = GraphNode(\n", - " id=\"simple-physics-sim\",\n", - " position=Position(x=300.0, y=100.0),\n", - " data=graphNodeData(label=\"Simple Physics Sim\", simulation_id=\"simple-physics\"),\n", - " type=\"basic-simulation\",\n", - ")\n", - "\n", - "minimal_properties = nodeProperties_simulation(\n", - " container_image=\"python:3.9\", # Required\n", - " simulation_mount_path=\"/app\", # Required\n", - ")\n", - "\n", - "minimal_metadata = nodeMetadata_simulation(\n", - " name=\"Simple Physics Simulation\",\n", - " id=\"simple-physics\",\n", - " description=\"A basic physics simulation for testing\",\n", - " version=\"1.0\",\n", - " date=datetime.date.today(), # Required despite Optional type\n", - " code_url=\"https://github.com/example/simple-sim\", # Required despite Optional type\n", - " paper_url=\"https://doi.org/10.1000/example.paper\", # Required despite Optional type\n", - " authors=[author(name=\"Demo User\", institution=\"Example University\")],\n", - " tags=[], # Empty list is fine\n", - ")\n", - "\n", - "# Create the minimal node\n", - "simple_node = project.graph.add_node_from_scratch(\n", - " node=minimal_node, node_properties=minimal_properties, node_metadata=minimal_metadata\n", - ")\n", - "\n", - "print(\"\u2705 Minimal node created!\")\n", - "print(f\" ID: {simple_node.id}\")\n", - "print(f\" Label: {simple_node.data.label}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Verify Node Creation\n", - "\n", - "Let's check that our nodes were created successfully and explore what files were generated:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Check the updated graph state\n", - "updated_graph = project.graph.get()\n", - "\n", - "print(\"\ud83d\udcca Updated Graph State:\")\n", - "print(f\" Nodes: {len(updated_graph.nodes)}\")\n", - "print(f\" Edges: {len(updated_graph.edges)}\")\n", - "print()\n", - "\n", - "print(\"\ud83d\udd0d Created Nodes:\")\n", - "for i, node in enumerate(updated_graph.nodes, 1):\n", - " print(f\" {i}. {node.id}\")\n", - " print(f\" Label: {node.data.label}\")\n", - " print(f\" Type: {node.type}\")\n", - " print(f\" Position: ({node.position.x}, {node.position.y})\")\n", - " print(f\" Simulation ID: {node.data.simulation_id}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Let's also check what files were created for our nodes\n", - "\n", - "print(\"\ud83d\udcc1 Node Directory Structure:\")\n", - "print()\n", - "\n", - "# Check the project directory structure\n", - "project_path = client.config.local_projects_path / project.id\n", - "nodes_to_check = [\"mujoco-humanoid-sim-001\", \"simple-physics-sim\"]\n", - "\n", - "for node_id in nodes_to_check:\n", - " node_path = project_path / \"nodes\" / node_id\n", - " if node_path.exists():\n", - " print(f\"\ud83d\udcc2 Node: {node_id}\")\n", - " for file in sorted(node_path.iterdir()):\n", - " if file.is_file():\n", - " size = file.stat().st_size\n", - " print(f\" \ud83d\udcc4 {file.name} ({size} bytes)\")\n", - " elif file.is_dir():\n", - " print(f\" \ud83d\udcc1 {file.name}/ (directory)\")\n", - " # Show a few files in subdirectories\n", - " try:\n", - " subfiles = list(file.iterdir())[:3] # First 3 files\n", - " for subfile in subfiles:\n", - " if subfile.is_file():\n", - " print(f\" \ud83d\udcc4 {subfile.name}\")\n", - " if len(list(file.iterdir())) > 3:\n", - " print(f\" ... and {len(list(file.iterdir())) - 3} more files\")\n", - " except:\n", - " pass\n", - " print()\n", - " else:\n", - " print(f\"\u274c Node directory not found: {node_path}\")\n", - " print()\n", - "\n", - "print(\"\ud83c\udf89 Node creation from scratch is complete!\")\n", - "print(\"Each node now has its own directory with:\")\n", - "print(\" \u2022 properties.yaml - Container and execution settings\")\n", - "print(\" \u2022 metadata.yaml - Rich metadata with authors and tags\")\n", - "print(\" \u2022 source/ - Directory for simulation code (cloned if repo provided)\")\n", - "print(\" \u2022 Complete graph entry in project's graph.json\")" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -456,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -488,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 17, "metadata": { "scrolled": true }, @@ -497,23 +366,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "No start node provided, using first node: node-1754038461760\n", - "BFS traversal starting from node 'node-1754038461760':\n", - " - Adding node to traversal: node-1754038461760, previous node: None\n", - " - Adding neighbor to queue: node-1754038465820, will follow node-1754038461760\n", - " - Adding node to traversal: node-1754038465820, previous node: node-1754038461760\n", - "Nodes to run: ['node-1754038461760', 'node-1754038465820']\n", - "Created project run folder: /Users/henrybae/.fluidize/projects/project-1754038373536/runs/run_6\n", - "Created run environment with number: 6\n" + "No start node provided, using first node: Mujoco-Simulation\n", + "BFS traversal starting from node 'Mujoco-Simulation':\n", + " - Adding node to traversal: Mujoco-Simulation, previous node: None\n", + "Nodes to run: ['Mujoco-Simulation']\n", + "Created project run folder: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_9\n", + "Created run environment with number: 9\n" ] }, { "data": { "text/plain": [ - "{'flow_status': 'running', 'run_number': 6}" + "{'flow_status': 'running', 'run_number': 9}" ] }, - "execution_count": 7, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -521,43 +388,21 @@ "name": "stderr", "output_type": "stream", "text": [ - "No parameters.json found for node node-1754038461760\n" + "No parameters.json found for node Mujoco-Simulation\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Executing node node-1754038461760 in run 6\n", - "\n", - "=== Starting run for node: node-1754038461760 ===\n", - "1. Preparing environment...\n", - "\ud83d\udd27 [Environment] Processing 0 targeted files (vs exhaustive search)\n", - "2. Executing simulation...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No parameters.json found for node node-1754038465820\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3. Handling files...\n", - "=== Run completed for node: node-1754038461760 with result: True ===\n", - "\n", - "Executing node node-1754038465820 in run 6\n", + "Executing node Mujoco-Simulation in run 9\n", "\n", - "=== Starting run for node: node-1754038465820 ===\n", + "=== Starting run for node: Mujoco-Simulation ===\n", "1. Preparing environment...\n", "\ud83d\udd27 [Environment] Processing 0 targeted files (vs exhaustive search)\n", "2. Executing simulation...\n", "3. Handling files...\n", - "=== Run completed for node: node-1754038465820 with result: True ===\n", + "=== Run completed for node: Mujoco-Simulation with result: False ===\n", "\n" ] } From e8ca80b6095ef253262031768059491e3dfcb847 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 14:30:49 -0700 Subject: [PATCH 02/17] parameter edit and checking --- fluidize/adapters/local/graph.py | 75 ++++++ .../core/modules/execute/docker_client.py | 16 +- fluidize/managers/project_graph.py | 39 +++ pyproject.toml | 1 + tests/unit/backends/local/test_graph.py | 142 +++++++++++ tests/unit/managers/test_project_graph.py | 117 +++++++++ utils/demo.ipynb | 232 ++++++++++++++++++ utils/fluidize_demo.ipynb | 36 ++- 8 files changed, 643 insertions(+), 15 deletions(-) create mode 100644 utils/demo.ipynb diff --git a/fluidize/adapters/local/graph.py b/fluidize/adapters/local/graph.py index 1f79a20..d07a213 100644 --- a/fluidize/adapters/local/graph.py +++ b/fluidize/adapters/local/graph.py @@ -7,10 +7,15 @@ from typing import Optional +from fluidize.core.modules.graph.parameters import parse_parameters_from_json from fluidize.core.modules.graph.processor import GraphProcessor from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation +from fluidize.core.types.parameters import Parameter from fluidize.core.types.project import ProjectSummary +from fluidize.core.utils.dataloader.data_loader import DataLoader +from fluidize.core.utils.dataloader.data_writer import DataWriter +from fluidize.core.utils.pathfinder.path_finder import PathFinder class GraphHandler: @@ -154,3 +159,73 @@ def show_graph_ascii(self, project: ProjectSummary) -> str: graph = Graph(nodes=graph_data.nodes, edges=graph_data.edges) return graph.to_ascii() + + def get_parameters(self, project: ProjectSummary, node_id: str) -> list[Parameter]: + """ + Get the parameters for a specific node in the project graph. + + Args: + project: The project containing the graph + node_id: ID of the node to retrieve parameters for + + Returns: + A list of Parameter objects for the node + """ + parameters_path = PathFinder.get_node_parameters_path(project, node_id) + data = DataLoader.load_json(parameters_path) + return parse_parameters_from_json(data) + + def upsert_parameter(self, project: ProjectSummary, node_id: str, parameter: Parameter) -> Parameter: + """ + Upsert a parameter for a specific node in the project graph. + + Args: + project: The project containing the graph + node_id: ID of the node to update parameters for + parameter: The parameter to upsert + + Returns: + The upserted parameter + """ + parameters_path = PathFinder.get_node_parameters_path(project, node_id) + data = DataLoader.load_json(parameters_path) + params = parse_parameters_from_json(data) + + # Check if parameter with same name exists + for p in params: + if p.name == parameter.name: + # Extend the location if it exists + if parameter.location: + if p.location: + p.location.extend(parameter.location) + else: + p.location = parameter.location + break + else: + # Parameter doesn't exist, add it + params.append(parameter) + + # Write updated parameters back + DataWriter.write_json( + filepath=parameters_path, + data={"parameters": [p.model_dump() for p in params]}, + ) + return parameter + + def set_parameters(self, project: ProjectSummary, node_id: str, parameters: list[Parameter]) -> list[Parameter]: + """ + Set all parameters for a specific node in the project graph, replacing existing ones. + + Args: + project: The project containing the graph + node_id: ID of the node to set parameters for + parameters: List of parameters to set + + Returns: + The list of parameters that were set + """ + parameters_path = PathFinder.get_node_parameters_path(project, node_id) + data = {"parameters": [p.model_dump() for p in parameters]} + + DataWriter.write_json(filepath=parameters_path, data=data) + return parameters diff --git a/fluidize/core/modules/execute/docker_client.py b/fluidize/core/modules/execute/docker_client.py index fbcb76f..1f37572 100644 --- a/fluidize/core/modules/execute/docker_client.py +++ b/fluidize/core/modules/execute/docker_client.py @@ -74,10 +74,19 @@ def pull_image(self, image: str) -> bool: Returns: True if successful, False otherwise """ + # First check if image exists locally + try: + self.client.images.get(image) + except ImageNotFound: + pass # Image not local, continue to pull + else: + logger.info(f"Image {image} already exists locally") + return True + + # Image not local, try to pull it try: logger.info(f"Pulling Docker image: {image}") self.client.images.pull(image) - logger.info(f"Successfully pulled image: {image}") except ImageNotFound: logger.exception(f"Image not found: {image}") return False @@ -85,6 +94,7 @@ def pull_image(self, image: str) -> bool: logger.exception(f"Failed to pull image {image}") return False else: + logger.info(f"Successfully pulled image: {image}") return True def run_container(self, container_spec: ContainerSpec, volumes: list[Volume], **kwargs: str) -> ContainerResult: @@ -154,8 +164,8 @@ def run_container(self, container_spec: ContainerSpec, volumes: list[Volume], ** logger.exception("Container execution failed") return ContainerResult( exit_code=e.exit_status, - stdout=e.stdout.decode("utf-8") if e.stdout else "", - stderr=e.stderr.decode("utf-8") if e.stderr else str(e), + stdout="", # ContainerError doesn't have stdout + stderr=e.stderr.decode("utf-8") if hasattr(e, "stderr") and e.stderr else str(e), success=False, ) except DockerException as e: diff --git a/fluidize/managers/project_graph.py b/fluidize/managers/project_graph.py index 58ab900..0983e9d 100644 --- a/fluidize/managers/project_graph.py +++ b/fluidize/managers/project_graph.py @@ -6,6 +6,7 @@ from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation +from fluidize.core.types.parameters import Parameter from fluidize.core.types.project import ProjectSummary @@ -127,3 +128,41 @@ def show(self) -> str: ASCII string representation of the graph structure """ return self.adapter.graph.show_graph_ascii(self.project) # type: ignore[no-any-return] + + def get_parameters(self, node_id: str) -> list[Parameter]: + """ + Get the parameters for a specific node in this project's graph. + + Args: + node_id: ID of the node to retrieve parameters for + + Returns: + A list of Parameter objects for the node + """ + return self.adapter.graph.get_parameters(self.project, node_id) # type: ignore[no-any-return] + + def upsert_parameter(self, node_id: str, parameter: Parameter) -> Parameter: + """ + Upsert a parameter for a specific node in this project's graph. + + Args: + node_id: ID of the node to update parameters for + parameter: The parameter to upsert + + Returns: + The upserted parameter + """ + return self.adapter.graph.upsert_parameter(self.project, node_id, parameter) # type: ignore[no-any-return] + + def set_parameters(self, node_id: str, parameters: list[Parameter]) -> list[Parameter]: + """ + Set all parameters for a specific node in this project's graph, replacing existing ones. + + Args: + node_id: ID of the node to set parameters for + parameters: List of parameters to set + + Returns: + The list of parameters that were set + """ + return self.adapter.graph.set_parameters(self.project, node_id, parameters) # type: ignore[no-any-return] diff --git a/pyproject.toml b/pyproject.toml index 26cd95d..155c9c7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -77,6 +77,7 @@ fix = true exclude = [ "tests/fixtures/", "utils/fluidize_demo.ipynb", + "utils/demo.ipynb", ] [tool.ruff.lint] diff --git a/tests/unit/backends/local/test_graph.py b/tests/unit/backends/local/test_graph.py index ea77c65..46f2b62 100644 --- a/tests/unit/backends/local/test_graph.py +++ b/tests/unit/backends/local/test_graph.py @@ -6,6 +6,7 @@ from fluidize.adapters.local.graph import GraphHandler from fluidize.core.types.graph import GraphData +from fluidize.core.types.parameters import Parameter from tests.fixtures.sample_graphs import SampleGraphs from tests.fixtures.sample_projects import SampleProjects @@ -308,3 +309,144 @@ def test_individual_operations(self, sample_project, operation, method_name, arg processor_method.assert_called_once_with(*args) else: processor_method.assert_called_once() + + @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.PathFinder") + def test_get_parameters_success(self, mock_pathfinder, mock_dataloader, sample_project): + """Test successful parameter retrieval.""" + # Mock setup + mock_parameters_path = Mock() + mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path + mock_dataloader.load_json.return_value = { + "parameters": [ + { + "name": "test_param", + "value": "test_value", + "type": "text", + "label": "Test Parameter", + "description": "A test parameter", + } + ] + } + + handler = GraphHandler() + result = handler.get_parameters(sample_project, "test-node-id") + + # Verify calls + mock_pathfinder.get_node_parameters_path.assert_called_once_with(sample_project, "test-node-id") + mock_dataloader.load_json.assert_called_once_with(mock_parameters_path) + + # Verify result + assert len(result) == 1 + assert isinstance(result[0], Parameter) + assert result[0].name == "test_param" + assert result[0].value == "test_value" + + @patch("fluidize.adapters.local.graph.DataWriter") + @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.PathFinder") + def test_upsert_parameter_new_parameter(self, mock_pathfinder, mock_dataloader, mock_datawriter, sample_project): + """Test upserting a new parameter.""" + # Mock setup + mock_parameters_path = Mock() + mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path + mock_dataloader.load_json.return_value = {"parameters": []} + mock_datawriter.write_json.return_value = True + + new_parameter = Parameter( + name="new_param", value="new_value", type="text", label="New Parameter", description="A new parameter" + ) + + handler = GraphHandler() + result = handler.upsert_parameter(sample_project, "test-node-id", new_parameter) + + # Verify calls + mock_pathfinder.get_node_parameters_path.assert_called_once_with(sample_project, "test-node-id") + mock_dataloader.load_json.assert_called_once_with(mock_parameters_path) + mock_datawriter.write_json.assert_called_once() + + # Verify the written data contains the new parameter + written_data = mock_datawriter.write_json.call_args[1]["data"] + assert len(written_data["parameters"]) == 1 + assert written_data["parameters"][0]["name"] == "new_param" + + # Verify result + assert result == new_parameter + + @patch("fluidize.adapters.local.graph.DataWriter") + @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.PathFinder") + def test_upsert_parameter_existing_parameter( + self, mock_pathfinder, mock_dataloader, mock_datawriter, sample_project + ): + """Test upserting an existing parameter extends locations.""" + # Mock setup with existing parameter + mock_parameters_path = Mock() + mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path + mock_dataloader.load_json.return_value = { + "parameters": [ + { + "name": "existing_param", + "value": "existing_value", + "type": "text", + "label": "Existing Parameter", + "description": "An existing parameter", + "location": ["file1.py"], + } + ] + } + mock_datawriter.write_json.return_value = True + + update_parameter = Parameter( + name="existing_param", + value="updated_value", + type="text", + label="Updated Parameter", + description="An updated parameter", + location=["file2.py"], + ) + + handler = GraphHandler() + result = handler.upsert_parameter(sample_project, "test-node-id", update_parameter) + + # Verify the written data extends the location + written_data = mock_datawriter.write_json.call_args[1]["data"] + assert len(written_data["parameters"]) == 1 + param_data = written_data["parameters"][0] + assert param_data["name"] == "existing_param" + assert param_data["location"] == ["file1.py", "file2.py"] + + # Verify result + assert result == update_parameter + + @patch("fluidize.adapters.local.graph.DataWriter") + @patch("fluidize.adapters.local.graph.PathFinder") + def test_set_parameters_success(self, mock_pathfinder, mock_datawriter, sample_project): + """Test setting parameters replaces all existing parameters.""" + # Mock setup + mock_parameters_path = Mock() + mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path + mock_datawriter.write_json.return_value = True + + parameters = [ + Parameter(name="param1", value="value1", type="text", label="Parameter 1", description="First parameter"), + Parameter( + name="param2", value="value2", type="number", label="Parameter 2", description="Second parameter" + ), + ] + + handler = GraphHandler() + result = handler.set_parameters(sample_project, "test-node-id", parameters) + + # Verify calls + mock_pathfinder.get_node_parameters_path.assert_called_once_with(sample_project, "test-node-id") + mock_datawriter.write_json.assert_called_once() + + # Verify the written data + written_data = mock_datawriter.write_json.call_args[1]["data"] + assert len(written_data["parameters"]) == 2 + assert written_data["parameters"][0]["name"] == "param1" + assert written_data["parameters"][1]["name"] == "param2" + + # Verify result + assert result == parameters diff --git a/tests/unit/managers/test_project_graph.py b/tests/unit/managers/test_project_graph.py index c9b9bdc..da2c63d 100644 --- a/tests/unit/managers/test_project_graph.py +++ b/tests/unit/managers/test_project_graph.py @@ -6,6 +6,7 @@ import pytest from fluidize.core.types.node import author, nodeMetadata_simulation, nodeProperties_simulation, tag +from fluidize.core.types.parameters import Parameter from fluidize.core.types.runs import RunStatus from fluidize.managers.project_graph import ProjectGraph from tests.fixtures.sample_graphs import SampleGraphs @@ -382,3 +383,119 @@ def test_project_context_consistency(self, project_graph, mock_adapter): for call_list in all_calls: if call_list: # If method was called assert call_list[0][0][0] == project + + def test_get_parameters_success(self, project_graph, mock_adapter): + """Test successful parameter retrieval through ProjectGraph.""" + node_id = "test-node-id" + expected_parameters = [ + Parameter( + name="test_param", + value="test_value", + type="text", + label="Test Parameter", + description="A test parameter", + ) + ] + + mock_adapter.graph.get_parameters.return_value = expected_parameters + + result = project_graph.get_parameters(node_id) + + assert result == expected_parameters + mock_adapter.graph.get_parameters.assert_called_once_with(project_graph.project, node_id) + + def test_upsert_parameter_success(self, project_graph, mock_adapter): + """Test successful parameter upsert through ProjectGraph.""" + node_id = "test-node-id" + parameter = Parameter( + name="new_param", value="new_value", type="text", label="New Parameter", description="A new parameter" + ) + + mock_adapter.graph.upsert_parameter.return_value = parameter + + result = project_graph.upsert_parameter(node_id, parameter) + + assert result == parameter + mock_adapter.graph.upsert_parameter.assert_called_once_with(project_graph.project, node_id, parameter) + + def test_set_parameters_success(self, project_graph, mock_adapter): + """Test successful parameters setting through ProjectGraph.""" + node_id = "test-node-id" + parameters = [ + Parameter(name="param1", value="value1", type="text", label="Parameter 1", description="First parameter"), + Parameter( + name="param2", value="value2", type="number", label="Parameter 2", description="Second parameter" + ), + ] + + mock_adapter.graph.set_parameters.return_value = parameters + + result = project_graph.set_parameters(node_id, parameters) + + assert result == parameters + mock_adapter.graph.set_parameters.assert_called_once_with(project_graph.project, node_id, parameters) + + def test_parameter_methods_error_propagation(self, project_graph, mock_adapter): + """Test that parameter method errors are propagated.""" + node_id = "test-node-id" + parameter = Parameter( + name="test_param", value="test_value", type="text", label="Test Parameter", description="A test parameter" + ) + + # Test get_parameters error propagation + mock_adapter.graph.get_parameters.side_effect = FileNotFoundError("Parameters file not found") + with pytest.raises(FileNotFoundError, match="Parameters file not found"): + project_graph.get_parameters(node_id) + + # Test upsert_parameter error propagation + mock_adapter.graph.upsert_parameter.side_effect = ValueError("Invalid parameter data") + with pytest.raises(ValueError, match="Invalid parameter data"): + project_graph.upsert_parameter(node_id, parameter) + + # Test set_parameters error propagation + mock_adapter.graph.set_parameters.side_effect = PermissionError("Cannot write to parameters file") + with pytest.raises(PermissionError, match="Cannot write to parameters file"): + project_graph.set_parameters(node_id, [parameter]) + + def test_parameter_methods_use_correct_project_context(self, mock_adapter): + """Test that parameter methods use correct project context.""" + project1 = SampleProjects.standard_project() + project2 = SampleProjects.minimal_project() + + graph1 = ProjectGraph(mock_adapter, project1) + graph2 = ProjectGraph(mock_adapter, project2) + + parameter = Parameter( + name="test_param", value="test_value", type="text", label="Test Parameter", description="A test parameter" + ) + + mock_adapter.graph.get_parameters.return_value = [parameter] + mock_adapter.graph.upsert_parameter.return_value = parameter + mock_adapter.graph.set_parameters.return_value = [parameter] + + # Call parameter methods on different project graphs + graph1.get_parameters("node1") + graph2.get_parameters("node2") + + graph1.upsert_parameter("node1", parameter) + graph2.upsert_parameter("node2", parameter) + + graph1.set_parameters("node1", [parameter]) + graph2.set_parameters("node2", [parameter]) + + # Verify correct project contexts were used + get_calls = mock_adapter.graph.get_parameters.call_args_list + upsert_calls = mock_adapter.graph.upsert_parameter.call_args_list + set_calls = mock_adapter.graph.set_parameters.call_args_list + + assert len(get_calls) == 2 + assert get_calls[0][0][0] == project1 + assert get_calls[1][0][0] == project2 + + assert len(upsert_calls) == 2 + assert upsert_calls[0][0][0] == project1 + assert upsert_calls[1][0][0] == project2 + + assert len(set_calls) == 2 + assert set_calls[0][0][0] == project1 + assert set_calls[1][0][0] == project2 diff --git a/utils/demo.ipynb b/utils/demo.ipynb new file mode 100644 index 0000000..d848b57 --- /dev/null +++ b/utils/demo.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fluidize-Python Interactive Demo\n", + "\n", + "This notebook demonstrates the fluidize-python library for managing scientific computing projects.\n", + "\n", + "## Setup\n", + "\n", + "First, let's import the client and see where our projects will be stored:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83d\udcc1 Projects will be stored in: /Users/henrybae/.fluidize/projects\n", + "\ud83d\udcc1 Base directory: /Users/henrybae/.fluidize\n", + "\ud83d\ude80 Client ready in 'local' mode!\n" + ] + } + ], + "source": [ + "# Import the fluidize client - handlers auto-register!\n", + "from fluidize.client import FluidizeClient\n", + "\n", + "# Create client and config\n", + "client = FluidizeClient(mode=\"local\")\n", + "\n", + "print(f\"\ud83d\udcc1 Projects will be stored in: {client.config.local_projects_path}\")\n", + "print(f\"\ud83d\udcc1 Base directory: {client.config.local_base_path}\")\n", + "print(f\"\ud83d\ude80 Client ready in '{client.mode}' mode!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83c\udfaf Working with project: MUJOCO DEMO\n", + "\ud83d\udcca Current graph state: 1 nodes, 0 edges\n" + ] + } + ], + "source": [ + "# Get our MUJOCO project for node creation\n", + "project = client.projects.get(\"MUJOCO\")\n", + "\n", + "print(f\"\ud83c\udfaf Working with project: {project.label}\")\n", + "print(f\"\ud83d\udcca Current graph state: {len(project.graph.get().nodes)} nodes, {len(project.graph.get().edges)} edges\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Parameter(value='20.0', description='Control signal strength for bat motor (higher = faster swing, more collision force)', type='text', label='Motor Strength', name='motor_strength', latex=None, location=['source/pinata_simulation.py'], options=None, scope='simulation')]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's now get the list of parameters:\n", + "\n", + "project.graph.get_parameters(\"Mujoco-Simulation\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Run" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83d\udcca Project Details:\n", + " ID: MUJOCO\n", + " Label: MUJOCO DEMO\n", + " Description: A MuJoCo simulation project\n", + " Status: active\n", + " Location: \n", + " Metadata Version: 1.0\n" + ] + } + ], + "source": [ + "# Get project details\n", + "project = client.projects.get(\"MUJOCO\")\n", + "\n", + "print(\"\ud83d\udcca Project Details:\")\n", + "print(f\" ID: {project.id}\")\n", + "print(f\" Label: {project.label}\")\n", + "print(f\" Description: {project.description}\")\n", + "print(f\" Status: {project.status}\")\n", + "print(f\" Location: {project.location}\")\n", + "print(f\" Metadata Version: {project.metadata_version}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No start node provided, using first node: Mujoco-Simulation\n", + "BFS traversal starting from node 'Mujoco-Simulation':\n", + " - Adding node to traversal: Mujoco-Simulation, previous node: None\n", + "Nodes to run: ['Mujoco-Simulation']\n", + "Created project run folder: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10\n", + "Created run environment with number: 10\n" + ] + }, + { + "data": { + "text/plain": [ + "{'flow_status': 'running', 'run_number': 10}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No parameters.json found for node Mujoco-Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node Mujoco-Simulation in run 10\n", + "\n", + "=== Starting run for node: Mujoco-Simulation ===\n", + "1. Preparing environment...\n", + "\ud83d\udd0d [Environment] DEBUG: Attempting to load parameters from /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation\n", + "\ud83d\udd0d [Environment] DEBUG: Loaded param_data = {'metadata': {'description': 'Parameter tuning for pinata motor strength', 'version': '1.0'}, 'parameters': [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]}\n", + "\ud83d\udd0d [Environment] DEBUG: all_params = [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]\n", + "\ud83d\udd0d [Environment] DEBUG: Found 1 simulation params, 0 properties params\n", + "\ud83d\udd0d [Environment] DEBUG: simulation_params = [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]\n", + "\ud83d\udd0d [Environment] DEBUG: properties_params = []\n", + "\ud83d\udd0d [Environment] DEBUG: context = {'motor_strength': '20.0'}\n", + "\ud83d\udd0d [Environment] DEBUG: param_locations = {'motor_strength': ['source/pinata_simulation.py']}\n", + "\ud83d\udd0d [Environment] DEBUG: node_run_folder = /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation\n", + "\ud83d\udd0d [Environment] DEBUG: checking location_path = /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation/source/pinata_simulation.py, exists = True\n", + "\ud83d\udd27 [Environment] Processing 1 targeted files (vs exhaustive search)\n", + "\ud83d\udd0d [Environment] DEBUG: files_to_process = [PosixUPath('/Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation/source/pinata_simulation.py')]\n", + "\ud83d\udcdd [Environment] Updated parameters in: source/pinata_simulation.py\n", + "2. Executing simulation...\n", + "3. Handling files...\n", + "=== Run completed for node: Mujoco-Simulation with result: True ===\n", + "\n" + ] + } + ], + "source": [ + "from fluidize.core.types.runs import RunFlowPayload\n", + "\n", + "payload = RunFlowPayload(\n", + " name=\"simulation-run-1\", description=\"Running simulation flow\", tags=[\"simulation\", \"analysis\"]\n", + ")\n", + "\n", + "\n", + "project.runs.run_flow(payload)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Updating Projects\n", + "\n", + "Modify existing projects:" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fluidize-python", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/utils/fluidize_demo.ipynb b/utils/fluidize_demo.ipynb index bf82abc..7547dff 100644 --- a/utils/fluidize_demo.ipynb +++ b/utils/fluidize_demo.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -325,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -357,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "scrolled": true }, @@ -370,17 +370,17 @@ "BFS traversal starting from node 'Mujoco-Simulation':\n", " - Adding node to traversal: Mujoco-Simulation, previous node: None\n", "Nodes to run: ['Mujoco-Simulation']\n", - "Created project run folder: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_9\n", - "Created run environment with number: 9\n" + "Created project run folder: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10\n", + "Created run environment with number: 10\n" ] }, { "data": { "text/plain": [ - "{'flow_status': 'running', 'run_number': 9}" + "{'flow_status': 'running', 'run_number': 10}" ] }, - "execution_count": 17, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, @@ -395,14 +395,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Executing node Mujoco-Simulation in run 9\n", + "Executing node Mujoco-Simulation in run 10\n", "\n", "=== Starting run for node: Mujoco-Simulation ===\n", "1. Preparing environment...\n", - "\ud83d\udd27 [Environment] Processing 0 targeted files (vs exhaustive search)\n", + "\ud83d\udd0d [Environment] DEBUG: Attempting to load parameters from /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation\n", + "\ud83d\udd0d [Environment] DEBUG: Loaded param_data = {'metadata': {'description': 'Parameter tuning for pinata motor strength', 'version': '1.0'}, 'parameters': [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]}\n", + "\ud83d\udd0d [Environment] DEBUG: all_params = [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]\n", + "\ud83d\udd0d [Environment] DEBUG: Found 1 simulation params, 0 properties params\n", + "\ud83d\udd0d [Environment] DEBUG: simulation_params = [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]\n", + "\ud83d\udd0d [Environment] DEBUG: properties_params = []\n", + "\ud83d\udd0d [Environment] DEBUG: context = {'motor_strength': '20.0'}\n", + "\ud83d\udd0d [Environment] DEBUG: param_locations = {'motor_strength': ['source/pinata_simulation.py']}\n", + "\ud83d\udd0d [Environment] DEBUG: node_run_folder = /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation\n", + "\ud83d\udd0d [Environment] DEBUG: checking location_path = /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation/source/pinata_simulation.py, exists = True\n", + "\ud83d\udd27 [Environment] Processing 1 targeted files (vs exhaustive search)\n", + "\ud83d\udd0d [Environment] DEBUG: files_to_process = [PosixUPath('/Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation/source/pinata_simulation.py')]\n", + "\ud83d\udcdd [Environment] Updated parameters in: source/pinata_simulation.py\n", "2. Executing simulation...\n", "3. Handling files...\n", - "=== Run completed for node: Mujoco-Simulation with result: False ===\n", + "=== Run completed for node: Mujoco-Simulation with result: True ===\n", "\n" ] } From 21d6bbe84f5d89cb00ac81e3bf066362445d77c1 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 14:35:49 -0700 Subject: [PATCH 03/17] Parameter shows things in a nice neat way --- fluidize/adapters/local/graph.py | 42 +++++++++++++++++++ fluidize/managers/project_graph.py | 12 ++++++ tests/unit/backends/local/test_graph.py | 49 +++++++++++++++++++++++ tests/unit/managers/test_project_graph.py | 12 ++++++ utils/demo.ipynb | 26 +++++++----- 5 files changed, 131 insertions(+), 10 deletions(-) diff --git a/fluidize/adapters/local/graph.py b/fluidize/adapters/local/graph.py index d07a213..436a801 100644 --- a/fluidize/adapters/local/graph.py +++ b/fluidize/adapters/local/graph.py @@ -229,3 +229,45 @@ def set_parameters(self, project: ProjectSummary, node_id: str, parameters: list DataWriter.write_json(filepath=parameters_path, data=data) return parameters + + def show_parameters(self, project: ProjectSummary, node_id: str) -> str: + """ + Get a nicely formatted string display of parameters for a specific node. + + Args: + project: The project containing the graph + node_id: ID of the node to retrieve parameters for + + Returns: + A formatted string displaying the parameters + """ + parameters = self.get_parameters(project, node_id) + + if not parameters: + return f"No parameters found for node '{node_id}'" + + output = f"Parameters for node '{node_id}':\n\n" + + for i, param in enumerate(parameters, 1): + output += f"Parameter {i}:\n" + output += f" Name: {param.name}\n" + output += f" Value: {param.value}\n" + output += f" Description: {param.description}\n" + output += f" Type: {param.type}\n" + output += f" Label: {param.label}\n" + + if param.scope: + output += f" Scope: {param.scope}\n" + + if param.location: + output += f" Location: {', '.join(param.location)}\n" + + if param.latex: + output += f" LaTeX: {param.latex}\n" + + if param.options: + output += f" Options: {[f'{opt.label} ({opt.value})' for opt in param.options]}\n" + + output += "\n" + + return output.rstrip() diff --git a/fluidize/managers/project_graph.py b/fluidize/managers/project_graph.py index 0983e9d..18be2c7 100644 --- a/fluidize/managers/project_graph.py +++ b/fluidize/managers/project_graph.py @@ -166,3 +166,15 @@ def set_parameters(self, node_id: str, parameters: list[Parameter]) -> list[Para The list of parameters that were set """ return self.adapter.graph.set_parameters(self.project, node_id, parameters) # type: ignore[no-any-return] + + def show_parameters(self, node_id: str) -> str: + """ + Get a nicely formatted string display of parameters for a specific node in this project's graph. + + Args: + node_id: ID of the node to retrieve parameters for + + Returns: + A formatted string displaying the parameters + """ + return self.adapter.graph.show_parameters(self.project, node_id) # type: ignore[no-any-return] diff --git a/tests/unit/backends/local/test_graph.py b/tests/unit/backends/local/test_graph.py index 46f2b62..dfb197b 100644 --- a/tests/unit/backends/local/test_graph.py +++ b/tests/unit/backends/local/test_graph.py @@ -450,3 +450,52 @@ def test_set_parameters_success(self, mock_pathfinder, mock_datawriter, sample_p # Verify result assert result == parameters + + @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.PathFinder") + def test_show_parameters_success(self, mock_pathfinder, mock_dataloader, sample_project): + """Test showing parameters in nice format.""" + # Mock setup + mock_parameters_path = Mock() + mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path + mock_dataloader.load_json.return_value = { + "parameters": [ + { + "name": "motor_strength", + "value": "20.0", + "type": "text", + "label": "Motor Strength", + "description": "Control signal strength for bat motor", + "scope": "simulation", + "location": ["source/pinata_simulation.py"], + } + ] + } + + handler = GraphHandler() + result = handler.show_parameters(sample_project, "test-node-id") + + # Verify the formatted output contains expected content + assert "Parameters for node 'test-node-id':" in result + assert "Name: motor_strength" in result + assert "Value: 20.0" in result + assert "Description: Control signal strength for bat motor" in result + assert "Type: text" in result + assert "Label: Motor Strength" in result + assert "Scope: simulation" in result + assert "Location: source/pinata_simulation.py" in result + + @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.PathFinder") + def test_show_parameters_no_parameters(self, mock_pathfinder, mock_dataloader, sample_project): + """Test showing parameters when none exist.""" + # Mock setup for empty parameters + mock_parameters_path = Mock() + mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path + mock_dataloader.load_json.return_value = {"parameters": []} + + handler = GraphHandler() + result = handler.show_parameters(sample_project, "empty-node-id") + + # Verify the no parameters message + assert result == "No parameters found for node 'empty-node-id'" diff --git a/tests/unit/managers/test_project_graph.py b/tests/unit/managers/test_project_graph.py index da2c63d..5f3f864 100644 --- a/tests/unit/managers/test_project_graph.py +++ b/tests/unit/managers/test_project_graph.py @@ -499,3 +499,15 @@ def test_parameter_methods_use_correct_project_context(self, mock_adapter): assert len(set_calls) == 2 assert set_calls[0][0][0] == project1 assert set_calls[1][0][0] == project2 + + def test_show_parameters_success(self, project_graph, mock_adapter): + """Test successful parameter display through ProjectGraph.""" + node_id = "test-node-id" + expected_output = "Parameters for node 'test-node-id':\n\nParameter 1:\n Name: test_param\n Value: test_value" + + mock_adapter.graph.show_parameters.return_value = expected_output + + result = project_graph.show_parameters(node_id) + + assert result == expected_output + mock_adapter.graph.show_parameters.assert_called_once_with(project_graph.project, node_id) diff --git a/utils/demo.ipynb b/utils/demo.ipynb index d848b57..533d50c 100644 --- a/utils/demo.ipynb +++ b/utils/demo.ipynb @@ -64,24 +64,30 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "[Parameter(value='20.0', description='Control signal strength for bat motor (higher = faster swing, more collision force)', type='text', label='Motor Strength', name='motor_strength', latex=None, location=['source/pinata_simulation.py'], options=None, scope='simulation')]" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameters for node 'Mujoco-Simulation':\n", + "\n", + "Parameter 1:\n", + " Name: motor_strength\n", + " Value: 20.0\n", + " Description: Control signal strength for bat motor (higher = faster swing, more collision force)\n", + " Type: text\n", + " Label: Motor Strength\n", + " Scope: simulation\n", + " Location: source/pinata_simulation.py\n" + ] } ], "source": [ "# Let's now get the list of parameters:\n", "\n", - "project.graph.get_parameters(\"Mujoco-Simulation\")\n" + "print(project.graph.show_parameters(\"Mujoco-Simulation\"))\n" ] }, { From 206ca158d46162cba498ae4ba97f8cc441eae99b Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 15:17:12 -0700 Subject: [PATCH 04/17] List Files Done, Demo Ready --- fluidize/adapters/local/graph.py | 8 + fluidize/adapters/local/runs.py | 48 +++ fluidize/backends/local/graph.py | 156 ++++++++++ fluidize/core/utils/dataloader/data_loader.py | 4 + .../utils/dataloader/loader/loader_base.py | 8 + .../core/utils/pathfinder/methods/base.py | 14 + fluidize/core/utils/pathfinder/path_finder.py | 15 + fluidize/managers/project_runs.py | 30 +- tests/unit/test_run_flow_direct.py | 50 ++++ utils/demo.ipynb | 283 +++++++++++++----- 10 files changed, 533 insertions(+), 83 deletions(-) create mode 100644 fluidize/backends/local/graph.py diff --git a/fluidize/adapters/local/graph.py b/fluidize/adapters/local/graph.py index 436a801..0f5aedc 100644 --- a/fluidize/adapters/local/graph.py +++ b/fluidize/adapters/local/graph.py @@ -194,6 +194,14 @@ def upsert_parameter(self, project: ProjectSummary, node_id: str, parameter: Par # Check if parameter with same name exists for p in params: if p.name == parameter.name: + # Update the existing parameter with new values + p.value = parameter.value + p.description = parameter.description + p.type = parameter.type + p.label = parameter.label + p.latex = parameter.latex + p.options = parameter.options + p.scope = parameter.scope # Extend the location if it exists if parameter.location: if p.location: diff --git a/fluidize/adapters/local/runs.py b/fluidize/adapters/local/runs.py index 5fcca20..2f37883 100644 --- a/fluidize/adapters/local/runs.py +++ b/fluidize/adapters/local/runs.py @@ -6,6 +6,7 @@ from typing import Any import networkx as nx +from upath import UPath from fluidize.core.constants import FileConstants from fluidize.core.modules.graph.process import ProcessGraph @@ -13,6 +14,7 @@ from fluidize.core.types.project import ProjectSummary from fluidize.core.types.runs import RunFlowPayload from fluidize.core.utils.dataloader.data_loader import DataLoader +from fluidize.core.utils.pathfinder.path_finder import PathFinder class RunsHandler: @@ -122,3 +124,49 @@ def get_run_status(self, project: ProjectSummary, run_number: int) -> dict[str, # This would load run metadata and return status # Implementation depends on how run status is stored return {"run_number": run_number, "status": "unknown"} + + def list_node_outputs(self, project: ProjectSummary, run_number: int, node_id: str) -> list[str]: + """ + List all output files for a specific node in a run, including files in subdirectories (1 level deep). + + Args: + project: The project containing the run + run_number: The run number + node_id: The node ID to list outputs for + + Returns: + List of relative file paths within the node's output directory (including subdirectories) + """ + output_path = PathFinder.get_node_output_path(project, run_number, node_id) + + if not DataLoader.check_file_exists(output_path) and not output_path.exists(): + return [] + + all_files = [] + + # Get files in the root output directory + files = DataLoader.list_files(output_path) + all_files.extend([file.name for file in files]) + + # Get files in subdirectories (1 level deep) + subdirs = DataLoader.list_directories(output_path) + for subdir in subdirs: + subdir_files = DataLoader.list_files(subdir) + # Include the subdirectory name in the relative path + all_files.extend([f"{subdir.name}/{file.name}" for file in subdir_files]) + + return all_files + + def get_output_path(self, project: ProjectSummary, run_number: int, node_id: str) -> UPath: + """ + Get the full path to a node's output directory. + + Args: + project: The project containing the run + run_number: The run number + node_id: The node ID + + Returns: + UPath to the node's output directory + """ + return PathFinder.get_node_output_path(project, run_number, node_id) diff --git a/fluidize/backends/local/graph.py b/fluidize/backends/local/graph.py new file mode 100644 index 0000000..196b1cc --- /dev/null +++ b/fluidize/backends/local/graph.py @@ -0,0 +1,156 @@ +""" +Local filesystem-based graph backend interface. + +This module provides the local backend interface for graph operations, +wrapping the core GraphProcessor with backend-specific functionality. +""" + +from typing import Optional + +from fluidize.core.modules.graph.processor import GraphProcessor +from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode +from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation +from fluidize.core.types.project import ProjectSummary + + +class GraphHandler: + """ + Local filesystem-based graph processor backend. + + This class provides a clean interface for graph operations using the local backend, + wrapping the core GraphProcessor functionality. + """ + + def __init__(self) -> None: + """Initialize the local graph processor.""" + pass + + def get_graph(self, project: ProjectSummary) -> GraphData: + """ + Get the complete graph for a project. + + Args: + project: The project to get the graph for + + Returns: + GraphData containing all nodes and edges + """ + processor = GraphProcessor(project) + return processor.get_graph() + + def insert_node(self, project: ProjectSummary, node: GraphNode, sim_global: bool = True) -> GraphNode: + """ + Insert a new node into the project graph. + + Args: + project: The project to add the node to + node: The node to insert + sim_global: Whether to use global simulations (placeholder for future) + + Returns: + The inserted node + """ + processor = GraphProcessor(project) + return processor.insert_node(node, sim_global) + + def insert_node_from_scratch( + self, + project: ProjectSummary, + GraphNode: GraphNode, + nodeProperties: nodeProperties_simulation, + nodeMetadata: nodeMetadata_simulation, + repo_link: Optional[str] = None, + ) -> GraphNode: + """ + Insert a new node into the project graph from scratch. + + Args: + project: The project to add the node to + nodeProperties: The properties of the node to insert + sim_global: Whether to use global simulations (placeholder for future) + + Returns: + The inserted node + """ + processor = GraphProcessor(project) + return processor.insert_node_from_scratch(GraphNode, nodeProperties, nodeMetadata, repo_link) + + def update_node_position(self, project: ProjectSummary, node: GraphNode) -> GraphNode: + """ + Update a node's position in the graph. + + Args: + project: The project containing the node + node: The node with updated position + + Returns: + The updated node + """ + processor = GraphProcessor(project) + return processor.update_node_position(node) + + def delete_node(self, project: ProjectSummary, node_id: str) -> None: + """ + Delete a node from the project graph. + + Args: + project: The project containing the node + node_id: ID of the node to delete + """ + processor = GraphProcessor(project) + processor.delete_node(node_id) + + def upsert_edge(self, project: ProjectSummary, edge: GraphEdge) -> GraphEdge: + """ + Add or update an edge in the project graph. + + Args: + project: The project containing the graph + edge: The edge to upsewrt + + Returns: + The upserted edge + """ + processor = GraphProcessor(project) + return processor.upsert_edge(edge) + + def delete_edge(self, project: ProjectSummary, edge_id: str) -> None: + """ + Delete an edge from the project graph. + + Args: + project: The project containing the edge + edge_id: ID of the edge to delete + """ + processor = GraphProcessor(project) + processor.delete_edge(edge_id) + + def ensure_graph_initialized(self, project: ProjectSummary) -> None: + """ + Ensure the project has a graph.json file initialized. + + Args: + project: The project to initialize the graph for + """ + processor = GraphProcessor(project) + processor._ensure_graph_file_exists() + + def show_graph_ascii(self, project: ProjectSummary) -> str: + """ + Get ASCII representation of the project graph. + + Args: + project: The project to visualize + + Returns: + ASCII string representation of the graph + """ + processor = GraphProcessor(project) + graph_data = processor.get_graph() + + # Create Graph model from the data to use ASCII visualization + from fluidize.core.modules.graph.model import Graph + + graph = Graph(nodes=graph_data.nodes, edges=graph_data.edges) + + return graph.to_ascii() diff --git a/fluidize/core/utils/dataloader/data_loader.py b/fluidize/core/utils/dataloader/data_loader.py index 548cb73..fc871cc 100644 --- a/fluidize/core/utils/dataloader/data_loader.py +++ b/fluidize/core/utils/dataloader/data_loader.py @@ -20,6 +20,10 @@ def _get_handler(cls) -> Any: def list_directories(cls, path: UPath) -> list[UPath]: return list(cls._get_handler().list_directories(path)) + @classmethod + def list_files(cls, path: UPath) -> list[UPath]: + return list(cls._get_handler().list_files(path)) + @classmethod def copy_directory(cls, source: UPath, destination: UPath) -> None: cls._get_handler().copy_directory(source, destination) diff --git a/fluidize/core/utils/dataloader/loader/loader_base.py b/fluidize/core/utils/dataloader/loader/loader_base.py index 192e4b6..1e23c51 100644 --- a/fluidize/core/utils/dataloader/loader/loader_base.py +++ b/fluidize/core/utils/dataloader/loader/loader_base.py @@ -80,6 +80,14 @@ def list_directories(self, path: UPath) -> list[UPath]: """ return [item for item in self._list_directory(path) if self._is_directory(item)] + def list_files(self, path: UPath) -> list[UPath]: + """ + List all files within a given directory (non-recursive) + """ + if not self._directory_exists(path): + return [] + return [item for item in self._list_directory(path) if not self._is_directory(item)] + def load_json(self, filepath: UPath) -> dict: """ Loads JSON from the appropriate path. diff --git a/fluidize/core/utils/pathfinder/methods/base.py b/fluidize/core/utils/pathfinder/methods/base.py index 33ef8d4..b7b758d 100644 --- a/fluidize/core/utils/pathfinder/methods/base.py +++ b/fluidize/core/utils/pathfinder/methods/base.py @@ -65,6 +65,20 @@ def get_node_parameters_path( def get_properties_path(self, project: ProjectSummary, node_id: str, run_number: Optional[int] = None) -> UPath: return self.get_node_path(project, node_id, run_number) / "properties.yaml" + def get_node_output_path(self, project: ProjectSummary, run_number: int, node_id: str) -> UPath: + """ + Get the path to the output directory for a specific node in a run. + + Args: + project: The project containing the run + run_number: The run number + node_id: ID of the node + + Returns: + Path to the node's output directory: {project_path}/runs/run_{run_number}/outputs/{node_id}/ + """ + return self.get_run_path(project, run_number) / FileConstants.OUTPUTS_DIR / node_id + @abstractmethod def get_mlflow_tracking_uri(self) -> str: """Get the MLFlow tracking URI for this storage backend""" diff --git a/fluidize/core/utils/pathfinder/path_finder.py b/fluidize/core/utils/pathfinder/path_finder.py index 7b69d7a..fd00b5a 100644 --- a/fluidize/core/utils/pathfinder/path_finder.py +++ b/fluidize/core/utils/pathfinder/path_finder.py @@ -61,6 +61,21 @@ def get_properties_path(cls, project: ProjectSummary, node_id: str, run_number: """ return cls._get_handler().get_properties_path(project, node_id, run_number) # type: ignore[no-any-return] + @classmethod + def get_node_output_path(cls, project: ProjectSummary, run_number: int, node_id: str) -> UPath: + """ + Get the path to the output directory for a specific node in a run. + + Args: + project: The project containing the run + run_number: The run number + node_id: ID of the node + + Returns: + Path to the node's output directory: {project_path}/runs/run_{run_number}/outputs/{node_id}/ + """ + return cls._get_handler().get_node_output_path(project, run_number, node_id) # type: ignore[no-any-return] + @classmethod def infer_cloud_bucket_and_path(cls, path: UPath) -> tuple[str, UPath]: """ diff --git a/fluidize/managers/project_runs.py b/fluidize/managers/project_runs.py index d3a50d7..703da6c 100644 --- a/fluidize/managers/project_runs.py +++ b/fluidize/managers/project_runs.py @@ -4,6 +4,8 @@ from typing import Any +from upath import UPath + from fluidize.core.types.project import ProjectSummary from fluidize.core.types.runs import RunFlowPayload @@ -39,7 +41,7 @@ def run_flow(self, payload: RunFlowPayload) -> dict[str, Any]: """ return self.adapter.runs.run_flow(self.project, payload) # type: ignore[no-any-return] - def list(self) -> list[str]: + def list_runs(self) -> list[str]: """ List all runs for this project. @@ -59,3 +61,29 @@ def get_status(self, run_number: int) -> dict[str, Any]: Dictionary with run status information """ return self.adapter.runs.get_run_status(self.project, run_number) # type: ignore[no-any-return] + + def list_node_outputs(self, run_number: int, node_id: str) -> list[str]: + """ + List all output files for a specific node in a run for this project. + + Args: + run_number: The run number + node_id: The node ID to list outputs for + + Returns: + List of relative file paths within the node's output directory + """ + return self.adapter.runs.list_node_outputs(self.project, run_number, node_id) # type: ignore[no-any-return] + + def get_output_path(self, run_number: int, node_id: str) -> UPath: + """ + Get the full path to a node's output directory for this project. + + Args: + run_number: The run number + node_id: The node ID + + Returns: + UPath to the node's output directory + """ + return self.adapter.runs.get_output_path(self.project, run_number, node_id) # type: ignore[no-any-return] diff --git a/tests/unit/test_run_flow_direct.py b/tests/unit/test_run_flow_direct.py index 00052c8..a4d65ca 100644 --- a/tests/unit/test_run_flow_direct.py +++ b/tests/unit/test_run_flow_direct.py @@ -167,6 +167,56 @@ def test_run_flow_basic_functionality(self, project_manager, test_config): config.local_projects_path = original_projects_path config.local_simulations_path = original_simulations_path + def test_list_node_outputs_and_get_output_path(self, project_manager, test_config): + """Test listing node outputs and getting output paths.""" + from fluidize.config import config + + # Store original values + original_mode = config.mode + original_base_path = config.local_base_path + original_projects_path = config.local_projects_path + original_simulations_path = config.local_simulations_path + + # Configure global config + config.mode = test_config.mode + config.local_base_path = test_config.local_base_path + config.local_projects_path = test_config.local_projects_path + config.local_simulations_path = test_config.local_simulations_path + + try: + # Create a fake output directory with some files + run_dir = test_config.local_projects_path / "project-1754038373536" / "runs" / "run_1" + outputs_dir = run_dir / "outputs" / "node-1754038461760" + outputs_dir.mkdir(parents=True, exist_ok=True) + + # Create some test output files + (outputs_dir / "output.txt").write_text("CANDY") + (outputs_dir / "plot.png").write_bytes(b"fake image data") + (outputs_dir / "results.json").write_text('{"result": "success"}') + + # Test listing node outputs + files = project_manager.runs.list_node_outputs(1, "node-1754038461760") + assert isinstance(files, list) + assert "output.txt" in files + assert "plot.png" in files + assert "results.json" in files + + # Test getting output path + output_path = project_manager.runs.get_output_path(1, "node-1754038461760") + assert output_path.exists() + assert (output_path / "output.txt").exists() + + # Test with non-existent node + empty_files = project_manager.runs.list_node_outputs(1, "non-existent-node") + assert empty_files == [] + + finally: + # Restore original values + config.mode = original_mode + config.local_base_path = original_base_path + config.local_projects_path = original_projects_path + config.local_simulations_path = original_simulations_path + def test_run_flow_payload_variations(self, project_manager, test_config): """Test run_flow with different payload configurations.""" diff --git a/utils/demo.ipynb b/utils/demo.ipynb index 533d50c..85017e5 100644 --- a/utils/demo.ipynb +++ b/utils/demo.ipynb @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -80,14 +80,14 @@ " Type: text\n", " Label: Motor Strength\n", " Scope: simulation\n", - " Location: source/pinata_simulation.py\n" + " Location: source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py\n" ] } ], "source": [ "# Let's now get the list of parameters:\n", "\n", - "print(project.graph.show_parameters(\"Mujoco-Simulation\"))\n" + "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" ] }, { @@ -99,118 +99,237 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from fluidize.core.types.runs import RunFlowPayload\n", + "\n", + "# Just providing information about what the run is \n", + "payload = RunFlowPayload(\n", + " name=\"simulation-run-1\", description=\"Running with Velocity 20\", tags=[\"simulation\", \"analysis\"]\n", + ")\n", + "\n", + "\n", + "project.runs.run_flow(payload)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Looking at Results" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\ud83d\udcca Project Details:\n", - " ID: MUJOCO\n", - " Label: MUJOCO DEMO\n", - " Description: A MuJoCo simulation project\n", - " Status: active\n", - " Location: \n", - " Metadata Version: 1.0\n" + "\ud83d\udcc2 Output files from run 11:\n", + " - videos/pinata_simulation_20250813_215249.mp4\n", + " - logs/simulation_log_20250813_215249.txt\n", + " - data/sensor_data_20250813_215249.csv\n", + " - data/simulation_data_20250813_215249.npz\n", + " - plots/comprehensive_analysis_20250813_215249.png\n", + "\n", + "\ud83d\udcc1 Output directory: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_11/outputs/Mujoco-Simulation\n", + "Directory exists: True\n" ] } ], "source": [ - "# Get project details\n", - "project = client.projects.get(\"MUJOCO\")\n", + "# List all output files from the latest run\n", + "run_number = 1 # Using the last run\n", + "node_id = \"Mujoco-Simulation\"\n", "\n", - "print(\"\ud83d\udcca Project Details:\")\n", - "print(f\" ID: {project.id}\")\n", - "print(f\" Label: {project.label}\")\n", - "print(f\" Description: {project.description}\")\n", - "print(f\" Status: {project.status}\")\n", - "print(f\" Location: {project.location}\")\n", - "print(f\" Metadata Version: {project.metadata_version}\")" + "# Get list of output files\n", + "output_files = project.runs.list_node_outputs(run_number, node_id)\n", + "print(f\"\ud83d\udcc2 Output files from run {run_number}:\")\n", + "for file in output_files:\n", + " print(f\" - {file}\")\n", + "\n", + "# Get the output path\n", + "output_path = project.runs.get_output_path(run_number, node_id)\n", + "print(f\"\\n\ud83d\udcc1 Output directory: {output_path}\")\n", + "print(f\"Directory exists: {output_path.exists()}\")" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, + "execution_count": 6, + "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "No start node provided, using first node: Mujoco-Simulation\n", - "BFS traversal starting from node 'Mujoco-Simulation':\n", - " - Adding node to traversal: Mujoco-Simulation, previous node: None\n", - "Nodes to run: ['Mujoco-Simulation']\n", - "Created project run folder: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10\n", - "Created run environment with number: 10\n" - ] - }, - { - "data": { - "text/plain": [ - "{'flow_status': 'running', 'run_number': 10}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No parameters.json found for node Mujoco-Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node Mujoco-Simulation in run 10\n", - "\n", - "=== Starting run for node: Mujoco-Simulation ===\n", - "1. Preparing environment...\n", - "\ud83d\udd0d [Environment] DEBUG: Attempting to load parameters from /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation\n", - "\ud83d\udd0d [Environment] DEBUG: Loaded param_data = {'metadata': {'description': 'Parameter tuning for pinata motor strength', 'version': '1.0'}, 'parameters': [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]}\n", - "\ud83d\udd0d [Environment] DEBUG: all_params = [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]\n", - "\ud83d\udd0d [Environment] DEBUG: Found 1 simulation params, 0 properties params\n", - "\ud83d\udd0d [Environment] DEBUG: simulation_params = [{'name': 'motor_strength', 'value': '20.0', 'type': 'text', 'label': 'Motor Strength', 'description': 'Control signal strength for bat motor (higher = faster swing, more collision force)', 'scope': 'simulation', 'location': ['source/pinata_simulation.py']}]\n", - "\ud83d\udd0d [Environment] DEBUG: properties_params = []\n", - "\ud83d\udd0d [Environment] DEBUG: context = {'motor_strength': '20.0'}\n", - "\ud83d\udd0d [Environment] DEBUG: param_locations = {'motor_strength': ['source/pinata_simulation.py']}\n", - "\ud83d\udd0d [Environment] DEBUG: node_run_folder = /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation\n", - "\ud83d\udd0d [Environment] DEBUG: checking location_path = /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation/source/pinata_simulation.py, exists = True\n", - "\ud83d\udd27 [Environment] Processing 1 targeted files (vs exhaustive search)\n", - "\ud83d\udd0d [Environment] DEBUG: files_to_process = [PosixUPath('/Users/henrybae/.fluidize/projects/MUJOCO/runs/run_10/Mujoco-Simulation/source/pinata_simulation.py')]\n", - "\ud83d\udcdd [Environment] Updated parameters in: source/pinata_simulation.py\n", - "2. Executing simulation...\n", - "3. Handling files...\n", - "=== Run completed for node: Mujoco-Simulation with result: True ===\n", - "\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Create a reusable visualization function\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mIPython\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdisplay\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Image, Video, display\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mvisualize_run_results\u001b[39m(project, run_number, node_id):\n\u001b[1;32m 5\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Display all output files from a run\"\"\"\u001b[39;00m\n", + "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Create a reusable visualization function\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mIPython\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdisplay\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Image, Video, display\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mvisualize_run_results\u001b[39m(project, run_number, node_id):\n\u001b[1;32m 5\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Display all output files from a run\"\"\"\u001b[39;00m\n", + "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_frame.py:768\u001b[0m, in \u001b[0;36mPyDBFrame.trace_dispatch\u001b[0;34m(self, frame, event, arg)\u001b[0m\n\u001b[1;32m 766\u001b[0m \u001b[38;5;66;03m# if thread has a suspend flag, we suspend with a busy wait\u001b[39;00m\n\u001b[1;32m 767\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m info\u001b[38;5;241m.\u001b[39mpydev_state \u001b[38;5;241m==\u001b[39m STATE_SUSPEND:\n\u001b[0;32m--> 768\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdo_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 769\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrace_dispatch\n\u001b[1;32m 770\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_frame.py:172\u001b[0m, in \u001b[0;36mPyDBFrame.do_wait_suspend\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdo_wait_suspend\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m--> 172\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_args\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdo_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/pydevd.py:2188\u001b[0m, in \u001b[0;36mPyDB.do_wait_suspend\u001b[0;34m(self, thread, frame, event, arg, exception_type)\u001b[0m\n\u001b[1;32m 2185\u001b[0m from_this_thread\u001b[38;5;241m.\u001b[39mappend(frame_custom_thread_id)\n\u001b[1;32m 2187\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_threads_suspended_single_notification\u001b[38;5;241m.\u001b[39mnotify_thread_suspended(thread_id, thread, stop_reason):\n\u001b[0;32m-> 2188\u001b[0m keep_suspended \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_do_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace_suspend_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrom_this_thread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframes_tracker\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2190\u001b[0m frames_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 2192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m keep_suspended:\n\u001b[1;32m 2193\u001b[0m \u001b[38;5;66;03m# This means that we should pause again after a set next statement.\u001b[39;00m\n", + "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/pydevd.py:2257\u001b[0m, in \u001b[0;36mPyDB._do_wait_suspend\u001b[0;34m(self, thread, frame, event, arg, trace_suspend_type, from_this_thread, frames_tracker)\u001b[0m\n\u001b[1;32m 2254\u001b[0m queue\u001b[38;5;241m.\u001b[39mput(internal_cmd)\n\u001b[1;32m 2255\u001b[0m wait_timeout \u001b[38;5;241m=\u001b[39m TIMEOUT_FAST\n\u001b[0;32m-> 2257\u001b[0m \u001b[43mnotify_event\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwait_timeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2258\u001b[0m notify_event\u001b[38;5;241m.\u001b[39mclear()\n\u001b[1;32m 2260\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n", + "File \u001b[0;32m~/.pyenv/versions/3.10.18/lib/python3.10/threading.py:607\u001b[0m, in \u001b[0;36mEvent.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 605\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_flag\n\u001b[1;32m 606\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m signaled:\n\u001b[0;32m--> 607\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cond\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m signaled\n", + "File \u001b[0;32m~/.pyenv/versions/3.10.18/lib/python3.10/threading.py:324\u001b[0m, in \u001b[0;36mCondition.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 323\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 324\u001b[0m gotit \u001b[38;5;241m=\u001b[39m \u001b[43mwaiter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 326\u001b[0m gotit \u001b[38;5;241m=\u001b[39m waiter\u001b[38;5;241m.\u001b[39macquire(\u001b[38;5;28;01mFalse\u001b[39;00m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ + "# Create a reusable visualization function\n", + "from IPython.display import Image, Video, display\n", + "\n", + "def visualize_run_results(project, run_number, node_id):\n", + " \"\"\"Display all output files from a run\"\"\"\n", + " print(f\"\ud83d\udcca Results from Run {run_number} - Node: {node_id}\")\n", + " \n", + " # Get list of output files\n", + " output_files = project.runs.list_node_outputs(run_number, node_id)\n", + " print(f\"\ud83d\udcc2 Output files:\")\n", + " for file in output_files:\n", + " print(f\" - {file}\")\n", + "\n", + " # Get the output path\n", + " output_path = project.runs.get_output_path(run_number, node_id)\n", + " print(f\"\\n\ud83d\udcc1 Output directory: {output_path}\")\n", + " print(f\"Directory exists: {output_path.exists()}\")\n", + " \n", + " if not output_files:\n", + " print(\"\u274c No output files found!\")\n", + " return\n", + " \n", + " # Look for images and videos\n", + " image_files = [f for f in output_files if f.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.svg'))]\n", + " video_files = [f for f in output_files if f.lower().endswith(('.mp4', '.avi', '.mov', '.webm'))]\n", + "\n", + " print(\"\\n\ud83d\uddbc\ufe0f Displaying images:\")\n", + " for img_file in image_files:\n", + " img_path = output_path / img_file\n", + " if img_path.exists():\n", + " print(f\"\ud83d\udcf7 {img_file}:\")\n", + " display(Image(str(img_path)))\n", + " else:\n", + " print(f\"\u274c {img_file} not found\")\n", + "\n", + " print(\"\\n\ud83c\udfa5 Displaying videos:\")\n", + " for vid_file in video_files:\n", + " vid_path = output_path / vid_file\n", + " if vid_path.exists():\n", + " print(f\"\ud83c\udfac {vid_file}:\")\n", + " print(f\" File size: {vid_path.stat().st_size / 1024 / 1024:.2f} MB\")\n", + " display(Video(str(vid_path.absolute()), width=600, height=400, embed=True))\n", + " else:\n", + " print(f\"\u274c {vid_file} not found\")\n", + "\n", + " if not image_files and not video_files:\n", + " print(\"\ud83d\udcdd No image or video files found. Available files:\")\n", + " for file in output_files:\n", + " file_path = output_path / file\n", + " if file_path.exists():\n", + " print(f\" \ud83d\udcc4 {file} ({file_path.stat().st_size} bytes)\")\n", + "\n", + "# Test the function with the previous run\n", + "visualize_run_results(project, 11, \"Mujoco-Simulation\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Parameter Experiment - Change Motor Strength and Compare Results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 1: Change the motor strength parameter from 20.0 to 35.0\n", + "from fluidize.core.types.parameters import Parameter\n", + "\n", + "print(\"\ud83d\udd27 Updating motor strength parameter from 20.0 to 35.0...\")\n", + "\n", + "# Create updated parameter\n", + "new_motor_strength = Parameter(\n", + " name=\"motor_strength\",\n", + " value=\"35.0\", # Increased from 20.0 to 35.0\n", + " type=\"text\",\n", + " label=\"Motor Strength\", \n", + " description=\"Control signal strength for bat motor (higher = faster swing, more collision force)\",\n", + " scope=\"simulation\",\n", + " location=[\"source/pinata_simulation.py\"]\n", + ")\n", + "\n", + "# Update the parameter\n", + "project.graph.upsert_parameter(\"Mujoco-Simulation\", new_motor_strength)\n", + "\n", + "# Show the updated parameters\n", + "print(\"\\n\u2705 Parameters updated!\")\n", + "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 2: Run a new simulation with the updated parameters\n", "from fluidize.core.types.runs import RunFlowPayload\n", "\n", + "print(\"\ud83d\ude80 Starting new simulation with motor strength = 35.0...\")\n", + "\n", "payload = RunFlowPayload(\n", - " name=\"simulation-run-1\", description=\"Running simulation flow\", tags=[\"simulation\", \"analysis\"]\n", + " name=\"high-motor-experiment\", \n", + " description=\"Testing increased motor strength (35.0 vs 20.0)\", \n", + " tags=[\"experiment\", \"parameter-study\", \"high-power\"]\n", ")\n", "\n", + "result = project.runs.run_flow(payload)\n", + "new_run_number = result['run_number']\n", "\n", - "project.runs.run_flow(payload)" + "print(f\"\u2705 Simulation started! Run number: {new_run_number}\")\n", + "print(f\"Status: {result['flow_status']}\")\n", + "print(\"\\n\u23f3 Wait a moment for simulation to complete, then run the next cell...\")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 3: Visualize the new results using our reusable function\n", + "print(\"\ud83d\udcca Results from the HIGH motor strength simulation (35.0):\")\n", + "print(\"=\"*60)\n", + "\n", + "# Use the new_run_number from the previous cell\n", + "visualize_run_results(project, new_run_number, \"Mujoco-Simulation\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## 4. Updating Projects\n", + "# Step 4: Compare with the previous results (motor strength = 20.0)\n", + "print(\"\ud83d\udcca COMPARISON - Results from the NORMAL motor strength simulation (20.0):\")\n", + "print(\"=\"*60)\n", "\n", - "Modify existing projects:" + "# Show the previous run results for comparison\n", + "visualize_run_results(project, 11, \"Mujoco-Simulation\") # Run 11 was with motor_strength=20.0" ] } ], From ad7d2f1c1f835fccc258c97757d4a644e2dc335b Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 15:35:46 -0700 Subject: [PATCH 05/17] Demo Updated, Moved the utils folder to be ignored by mypy --- pyproject.toml | 3 ++ utils/demo.ipynb | 127 +++++++++++++++-------------------------------- 2 files changed, 44 insertions(+), 86 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 155c9c7..ddf5fb2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -134,3 +134,6 @@ skip_empty = true [tool.coverage.run] branch = true source = ["fluidize"] + +[tool.deptry] +extend_exclude = ["utils"] diff --git a/utils/demo.ipynb b/utils/demo.ipynb index 85017e5..c512c27 100644 --- a/utils/demo.ipynb +++ b/utils/demo.ipynb @@ -15,19 +15,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\ud83d\udcc1 Projects will be stored in: /Users/henrybae/.fluidize/projects\n", - "\ud83d\udcc1 Base directory: /Users/henrybae/.fluidize\n", - "\ud83d\ude80 Client ready in 'local' mode!\n" - ] - } - ], + "outputs": [], "source": [ "# Import the fluidize client - handlers auto-register!\n", "from fluidize.client import FluidizeClient\n", @@ -40,20 +30,18 @@ "print(f\"\ud83d\ude80 Client ready in '{client.mode}' mode!\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now load a project. This contains everything we need to run a simulation pipeline!" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\ud83c\udfaf Working with project: MUJOCO DEMO\n", - "\ud83d\udcca Current graph state: 1 nodes, 0 edges\n" - ] - } - ], + "outputs": [], "source": [ "# Get our MUJOCO project for node creation\n", "project = client.projects.get(\"MUJOCO\")\n", @@ -62,31 +50,19 @@ "print(f\"\ud83d\udcca Current graph state: {len(project.graph.get().nodes)} nodes, {len(project.graph.get().edges)} edges\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now list the parameters that we can tune for this simulation. Here to make it simple, we just have one, which will see in a bit!" + ] + }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameters for node 'Mujoco-Simulation':\n", - "\n", - "Parameter 1:\n", - " Name: motor_strength\n", - " Value: 20.0\n", - " Description: Control signal strength for bat motor (higher = faster swing, more collision force)\n", - " Type: text\n", - " Label: Motor Strength\n", - " Scope: simulation\n", - " Location: source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py\n" - ] - } - ], + "outputs": [], "source": [ - "# Let's now get the list of parameters:\n", - "\n", "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" ] }, @@ -97,6 +73,13 @@ "## Example Run" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now run the simulation. The payload here is for you to describe what this run was. All the things like parameters and your source code is automatically tracked for each run. " + ] + }, { "cell_type": "code", "execution_count": null, @@ -113,7 +96,8 @@ ")\n", "\n", "\n", - "project.runs.run_flow(payload)" + "result = project.runs.run_flow(payload)\n", + "run_number = result['run_number']" ] }, { @@ -127,26 +111,9 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\ud83d\udcc2 Output files from run 11:\n", - " - videos/pinata_simulation_20250813_215249.mp4\n", - " - logs/simulation_log_20250813_215249.txt\n", - " - data/sensor_data_20250813_215249.csv\n", - " - data/simulation_data_20250813_215249.npz\n", - " - plots/comprehensive_analysis_20250813_215249.png\n", - "\n", - "\ud83d\udcc1 Output directory: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_11/outputs/Mujoco-Simulation\n", - "Directory exists: True\n" - ] - } - ], + "outputs": [], "source": [ "# List all output files from the latest run\n", - "run_number = 1 # Using the last run\n", "node_id = \"Mujoco-Simulation\"\n", "\n", "# Get list of output files\n", @@ -163,28 +130,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Create a reusable visualization function\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mIPython\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdisplay\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Image, Video, display\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mvisualize_run_results\u001b[39m(project, run_number, node_id):\n\u001b[1;32m 5\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Display all output files from a run\"\"\"\u001b[39;00m\n", - "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Create a reusable visualization function\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mIPython\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdisplay\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Image, Video, display\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mvisualize_run_results\u001b[39m(project, run_number, node_id):\n\u001b[1;32m 5\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Display all output files from a run\"\"\"\u001b[39;00m\n", - "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_frame.py:768\u001b[0m, in \u001b[0;36mPyDBFrame.trace_dispatch\u001b[0;34m(self, frame, event, arg)\u001b[0m\n\u001b[1;32m 766\u001b[0m \u001b[38;5;66;03m# if thread has a suspend flag, we suspend with a busy wait\u001b[39;00m\n\u001b[1;32m 767\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m info\u001b[38;5;241m.\u001b[39mpydev_state \u001b[38;5;241m==\u001b[39m STATE_SUSPEND:\n\u001b[0;32m--> 768\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdo_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 769\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrace_dispatch\n\u001b[1;32m 770\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_frame.py:172\u001b[0m, in \u001b[0;36mPyDBFrame.do_wait_suspend\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdo_wait_suspend\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m--> 172\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_args\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdo_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/pydevd.py:2188\u001b[0m, in \u001b[0;36mPyDB.do_wait_suspend\u001b[0;34m(self, thread, frame, event, arg, exception_type)\u001b[0m\n\u001b[1;32m 2185\u001b[0m from_this_thread\u001b[38;5;241m.\u001b[39mappend(frame_custom_thread_id)\n\u001b[1;32m 2187\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_threads_suspended_single_notification\u001b[38;5;241m.\u001b[39mnotify_thread_suspended(thread_id, thread, stop_reason):\n\u001b[0;32m-> 2188\u001b[0m keep_suspended \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_do_wait_suspend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mthread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframe\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrace_suspend_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfrom_this_thread\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframes_tracker\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2190\u001b[0m frames_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 2192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m keep_suspended:\n\u001b[1;32m 2193\u001b[0m \u001b[38;5;66;03m# This means that we should pause again after a set next statement.\u001b[39;00m\n", - "File \u001b[0;32m~/Files/GitHub/fluidize-python/.venv/lib/python3.10/site-packages/debugpy/_vendored/pydevd/pydevd.py:2257\u001b[0m, in \u001b[0;36mPyDB._do_wait_suspend\u001b[0;34m(self, thread, frame, event, arg, trace_suspend_type, from_this_thread, frames_tracker)\u001b[0m\n\u001b[1;32m 2254\u001b[0m queue\u001b[38;5;241m.\u001b[39mput(internal_cmd)\n\u001b[1;32m 2255\u001b[0m wait_timeout \u001b[38;5;241m=\u001b[39m TIMEOUT_FAST\n\u001b[0;32m-> 2257\u001b[0m \u001b[43mnotify_event\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwait_timeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2258\u001b[0m notify_event\u001b[38;5;241m.\u001b[39mclear()\n\u001b[1;32m 2260\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n", - "File \u001b[0;32m~/.pyenv/versions/3.10.18/lib/python3.10/threading.py:607\u001b[0m, in \u001b[0;36mEvent.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 605\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_flag\n\u001b[1;32m 606\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m signaled:\n\u001b[0;32m--> 607\u001b[0m signaled \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cond\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m signaled\n", - "File \u001b[0;32m~/.pyenv/versions/3.10.18/lib/python3.10/threading.py:324\u001b[0m, in \u001b[0;36mCondition.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 323\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 324\u001b[0m gotit \u001b[38;5;241m=\u001b[39m \u001b[43mwaiter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 326\u001b[0m gotit \u001b[38;5;241m=\u001b[39m waiter\u001b[38;5;241m.\u001b[39macquire(\u001b[38;5;28;01mFalse\u001b[39;00m)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "# Create a reusable visualization function\n", "from IPython.display import Image, Video, display\n", @@ -217,7 +165,7 @@ " img_path = output_path / img_file\n", " if img_path.exists():\n", " print(f\"\ud83d\udcf7 {img_file}:\")\n", - " display(Image(str(img_path)))\n", + " display(Image(str(img_path), width=800, height=600))\n", " else:\n", " print(f\"\u274c {img_file} not found\")\n", "\n", @@ -239,7 +187,7 @@ " print(f\" \ud83d\udcc4 {file} ({file_path.stat().st_size} bytes)\")\n", "\n", "# Test the function with the previous run\n", - "visualize_run_results(project, 11, \"Mujoco-Simulation\")" + "visualize_run_results(project, run_number, \"Mujoco-Simulation\")" ] }, { @@ -331,6 +279,13 @@ "# Show the previous run results for comparison\n", "visualize_run_results(project, 11, \"Mujoco-Simulation\") # Run 11 was with motor_strength=20.0" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 373d001afe9c7d1091c3a8dab85eb85d12869691 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 20:58:00 -0700 Subject: [PATCH 06/17] Example Added, Demo Added --- examples/demo.ipynb | 519 ++++++++++++++++++ examples/example-projects/MUJOCO.zip | Bin 0 -> 48014 bytes .../MUJOCO/Mujoco-Simulation/Dockerfile | 32 ++ .../MUJOCO/Mujoco-Simulation/README.md | 123 +++++ .../MUJOCO/Mujoco-Simulation/cloudbuild.yaml | 14 + .../MUJOCO/Mujoco-Simulation/main.sh | 58 ++ .../MUJOCO/Mujoco-Simulation/metadata.yaml | 12 + .../MUJOCO/Mujoco-Simulation/parameters.json | 20 + .../MUJOCO/Mujoco-Simulation/properties.yaml | 10 + .../source/debug_tutorial.py | 105 ++++ .../source/pinata_simulation.py | 488 ++++++++++++++++ .../Mujoco-Simulation/source/test_pinata.py | 146 +++++ .../Mujoco-Simulation/source/test_simple.py | 31 ++ examples/example-projects/MUJOCO/graph.json | 17 + .../example-projects/MUJOCO/metadata.yaml | 7 + .../example-projects/MUJOCO/parameters.json | 4 + .../core/modules/execute/docker_client.py | 7 + pyproject.toml | 6 +- utils/demo.ipynb | 312 ----------- ...e_demo.ipynb => interactive-testing.ipynb} | 6 +- 20 files changed, 1599 insertions(+), 318 deletions(-) create mode 100644 examples/demo.ipynb create mode 100644 examples/example-projects/MUJOCO.zip create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/Dockerfile create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/README.md create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/cloudbuild.yaml create mode 100755 examples/example-projects/MUJOCO/Mujoco-Simulation/main.sh create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/metadata.yaml create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/properties.yaml create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/source/debug_tutorial.py create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/source/pinata_simulation.py create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_pinata.py create mode 100644 examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_simple.py create mode 100644 examples/example-projects/MUJOCO/graph.json create mode 100644 examples/example-projects/MUJOCO/metadata.yaml create mode 100644 examples/example-projects/MUJOCO/parameters.json delete mode 100644 utils/demo.ipynb rename utils/{fluidize_demo.ipynb => interactive-testing.ipynb} (99%) diff --git a/examples/demo.ipynb b/examples/demo.ipynb new file mode 100644 index 0000000..0a15616 --- /dev/null +++ b/examples/demo.ipynb @@ -0,0 +1,519 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fluidize-Python Interactive Demo\n", + "\n", + "This notebook demonstrates the fluidize-python library for managing scientific computing projects.\n", + "\n", + "## Setup\n", + "\n", + "First, let's import the client and see where our projects will be stored:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83d\udcc1 Projects will be stored in: /Users/henrybae/.fluidize/projects\n", + "\ud83d\udcc1 Base directory: /Users/henrybae/.fluidize\n", + "\ud83d\ude80 Client ready in 'local' mode!\n" + ] + } + ], + "source": [ + "# Import the fluidize client - handlers auto-register!\n", + "from fluidize.client import FluidizeClient\n", + "\n", + "# Create client and config\n", + "client = FluidizeClient(mode=\"local\")\n", + "\n", + "print(f\"\ud83d\udcc1 Projects will be stored in: {client.config.local_projects_path}\")\n", + "print(f\"\ud83d\udcc1 Base directory: {client.config.local_base_path}\")\n", + "print(f\"\ud83d\ude80 Client ready in '{client.mode}' mode!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83d\udce5 Downloading MUJOCO example...\n", + "\u2705 Example Project Downloaded at: /Users/henrybae/.fluidize/projects/MUJOCO\n" + ] + } + ], + "source": [ + "# Download MUJOCO example from Google Cloud Storage\n", + "import urllib.request\n", + "import zipfile\n", + "from pathlib import Path\n", + "\n", + "# Skip if already exists\n", + "destination = client.config.local_projects_path / \"MUJOCO\"\n", + "if destination.exists():\n", + " print(f\"\u2705 MUJOCO already exists at: {destination}\")\n", + "else:\n", + " print(\"\ud83d\udce5 Downloading MUJOCO example...\")\n", + "\n", + " # Download and extract\n", + " urllib.request.urlretrieve(\"https://storage.googleapis.com/fluidize-examples/MUJOCO.zip\", \"MUJOCO.zip\")\n", + " with zipfile.ZipFile(\"MUJOCO.zip\", \"r\") as zip_ref:\n", + " zip_ref.extractall(client.config.local_projects_path)\n", + " Path(\"MUJOCO.zip\").unlink() # Clean up\n", + "\n", + " print(f\"\u2705 Example Project Downloaded at: {destination}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now load a project. This contains everything we need to run a simulation pipeline!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83c\udfaf Working with project: MUJOCO DEMO\n", + "\ud83d\udcca Current graph state: 1 nodes, 0 edges\n" + ] + } + ], + "source": [ + "# Get our MUJOCO project for node creation\n", + "project = client.projects.get(\"MUJOCO\")\n", + "\n", + "print(f\"\ud83c\udfaf Working with project: {project.label}\")\n", + "print(f\"\ud83d\udcca Current graph state: {len(project.graph.get().nodes)} nodes, {len(project.graph.get().edges)} edges\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now list the parameters that we can tune for this simulation. Here to make it simple, we just have one, which will see in a bit!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameters for node 'Mujoco-Simulation':\n", + "\n", + "Parameter 1:\n", + " Name: motor_strength\n", + " Value: 20.0\n", + " Description: Control signal strength for bat motor (higher = faster swing, more collision force)\n", + " Type: text\n", + " Label: Motor Strength\n", + " Scope: simulation\n", + " Location: source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py, source/pinata_simulation.py\n" + ] + } + ], + "source": [ + "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Run" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now run the simulation. The payload here is for you to describe what this run was. All the things like parameters and your source code is automatically tracked for each run. This takes a few minutes at first because the Docker image needs to be installed on your local machine (for the local version)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No start node provided, using first node: Mujoco-Simulation\n", + "BFS traversal starting from node 'Mujoco-Simulation':\n", + " - Adding node to traversal: Mujoco-Simulation, previous node: None\n", + "Nodes to run: ['Mujoco-Simulation']\n", + "Created project run folder: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_1\n", + "Created run environment with number: 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No parameters.json found for node Mujoco-Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node Mujoco-Simulation in run 1\n", + "\n", + "=== Starting run for node: Mujoco-Simulation ===\n", + "1. Preparing environment...\n", + "\ud83d\udd27 [Environment] Processing 1 targeted files (vs exhaustive search)\n", + "\ud83d\udcdd [Environment] Updated parameters in: source/pinata_simulation.py\n", + "2. Executing simulation...\n", + "3. Handling files...\n", + "=== Run completed for node: Mujoco-Simulation with result: True ===\n", + "\n" + ] + } + ], + "source": [ + "from fluidize.core.types.runs import RunFlowPayload\n", + "\n", + "# Just providing information about what the run is\n", + "payload = RunFlowPayload(\n", + " name=\"simulation-run-1\", description=\"Running with Velocity 20\", tags=[\"simulation\", \"analysis\"]\n", + ")\n", + "\n", + "\n", + "result = project.runs.run_flow(payload)\n", + "run_number = result[\"run_number\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Looking at Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now list the location of the node output. The nice thing about this configuration is that there is no guesswork involved in figuring out where your files are saved. In this case we want to see the output for the example Mujoco simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83d\udcc2 Output files from run 1:\n", + " - videos/pinata_simulation_20250814_034824.mp4\n", + " - logs/simulation_log_20250814_034824.txt\n", + " - data/sensor_data_20250814_034824.csv\n", + " - data/simulation_data_20250814_034824.npz\n", + " - plots/comprehensive_analysis_20250814_034824.png\n", + "\n", + "\ud83d\udcc1 Output directory: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_1/outputs/Mujoco-Simulation\n", + "Directory exists: True\n" + ] + } + ], + "source": [ + "# List all output files from the latest run\n", + "node_id = \"Mujoco-Simulation\"\n", + "\n", + "# Get list of output files\n", + "output_files = project.runs.list_node_outputs(run_number, node_id)\n", + "print(f\"\ud83d\udcc2 Output files from run {run_number}:\")\n", + "for file in output_files:\n", + " print(f\" - {file}\")\n", + "\n", + "# Get the output path\n", + "output_path = project.runs.get_output_path(run_number, node_id)\n", + "print(f\"\\n\ud83d\udcc1 Output directory: {output_path}\")\n", + "print(f\"Directory exists: {output_path.exists()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is just code for visualizing your results. The files are all there, so you can use any tool you like in Python (or anywhere else by making another Fluidize node) to view the results of your simulation run. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\ud83d\udcca Results from Run 1 - Node: Mujoco-Simulation\n", + "\ud83d\udcc2 Output files:\n", + " - videos/pinata_simulation_20250814_034824.mp4\n", + " - logs/simulation_log_20250814_034824.txt\n", + " - data/sensor_data_20250814_034824.csv\n", + " - data/simulation_data_20250814_034824.npz\n", + " - plots/comprehensive_analysis_20250814_034824.png\n", + "\n", + "\ud83d\udcc1 Output directory: /Users/henrybae/.fluidize/projects/MUJOCO/runs/run_1/outputs/Mujoco-Simulation\n", + "Directory exists: True\n", + "\n", + "\ud83d\uddbc\ufe0f Displaying images:\n", + "\ud83d\udcf7 plots/comprehensive_analysis_20250814_034824.png:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAEGEAAAz/CAYAAACIPBYvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAC4jAAAuIwF4pT92AAEAAElEQVR4nOzdd3RU1ff38U8qEBICoZfQe+9SpHdQRBBRmgXB8gVBQEXAgoBUC4iogIggKoJgqKIgvffeaxIglBBIIX2eP3zgZwFyz2Qmk8D7tZZraWafs3cmd+7cGe/Zx81ms9kEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwkHN3dQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpAU0YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEmSp6sLAAAAAAAAANKjzz//XFOmTLEcv3r1ahUqVMiJFQFIL8qUKWM59sknn9TYsWOdWA3Ss23btqlnz56W48eMGaOOHTs6saKHG+/tANIK1wrpX0hIiJo1a2Y5vm/fvurXr58TKwIAAAAAAAAAAAAAAOkJTRgAAAAAAAAAAAAAAAAAAA+UpKQkXbhwQSEhIbp27Zpu3LihuLg4JSQkyN3dXd7e3vL19VWOHDmUL18+FS5cWL6+vq4uGwBSFB4ervPnz+vy5cuKiIhQTEyM4uPjZbPZ5O3trcyZMyt79uzKnTu3AgMDlSdPHrm5ubm6bAAAAAAAAADIUGjCAAAAAAAAAABId+Lj47Vv3z7t2bNHJ06c0Pnz53XlyhVFREQoPj5eSUlJypw5szJlyqQsWbIoa9asypMnj/Lmzau8efMqf/78KlGihEqXLq1s2bK5+tcBADzgtmzZop07d9o1tlKlSmrcuLFjCwIAOM2tW7d0+PBhnT17VufPn1dISIiCg4N148YNxcTEKCYmRrdu3VKmTJnk5+d3559ixYqpYsWKqlChgsqVK6dMmTK59PeIjY3V7t27tW3btjufua5evapbt24pISFBWbJkka+vrwoWLKgiRYqoWrVqeuSRR1SkSJE0rzUsLExHjhzR+fPn7zznFy5cUHR09J3nOyEhQVmzZr3zfOfIkUNly5ZVxYoVVbFiRRUuXJjFp3bKSMdKcnKytm/frnXr1mnXrl06evSo4uLijOYoWLCgqlSpokcffVRNmjRRQECAk6q9t5iYGB06dEgHDx5UVFSU5XHlypVT8+bNnViZfY4ePao//vjDeFzBggXVsWNHJ1SUPkVFRWnHjh3avn27Tp8+rbNnz95ZXJ+cnKwsWbIoW7ZsKlSokIoWLarq1aurTp06ypcvX5rVmJCQoDNnzuj48eM6deqULl26pMuXLyssLEw3b95UbGysYmNjFR8fL09PT3l5ecnPz0/+/v7KmzevChYsqJIlS6pcuXKqXLmyvL2906x2qyIjI/Xdd9/JZrMZj+3Xr58TKvrL+fPn9eeff2rLli06ePCgrl69ajTez89P5cuXV506ddS0aVOVLVvWSZX+H5vNptOnT+v48eMKDg5WSEjIne94b18zxcTEyGaz/eOaKU+ePKpQocKd66bcuXM7vVZ7hIaGauHChcbj/Pz89Pzzzzu+IAAAAAAAAAAORxMGAAAAAAAAOEXTpk0VGhrq0Dk9PT3l7e2trFmzKleuXMqXL5+KFy+ucuXKqVatWml6wykA59iyZYsWLFigP//8UzExMfeNvX2j7vXr1yVJJ06cuGtc3rx5Vbp0aVWpUkU1atRQlSpVlDVrVofXDgB4eE2YMEGHDh2ya2yRIkVowgAA6VhYWJg2bdqkvXv3av/+/Tp+/LiSkpJSHHf780pYWJgkac+ePXcW6mXJkkWtW7fWU089pZo1azq1/n87ePCgfvjhB61YseK+n7mioqIUFRWlS5cuadeuXXdqL1eunDp16qSnnnpKWbJkcXh9NptNBw4c0NatW3XgwAHt27fvznOYkhs3bujGjRt3/nvz5s13/r1w4cLq1KmTnnzySeXNm9ehNYeEhKhZs2YOndPEsWPHnDJvej9W/l3DnDlz9OOPP1o+Xu4lNDRUoaGhWr58uby8vNS0aVO9/PLLqlChgoOq/afk5GSdPHlS+/bt0/79+7Vv3z6dPHnS0nnm35588sl014QhPj5egwYN0smTJ43H1q5d+6FowrB161b99NNPWr16teLj4+8ZFxkZqcjISIWGhmrbtm2aN2+eJKlGjRp66qmn1L59e3l6OvZ20GvXrmnHjh3auXOndu7cqZMnTyohIcHS2ISEBCUkJNx5Lzx+/Pg/Hs+cObMeeeQRtWvXTq1bt3Z5c6Lbxo4dqwULFtg11hlNGNasWaNvvvlGO3bsSNU8kZGR2rZtm7Zt26ZJkyapdOnSev755/XEE0847LiJi4vT9u3btXPnTu3fv18HDhxQZGSkpbHh4eEKDw+/899//vnnnX+vVq2aOnfurDZt2sjHx8chtTrC8OHD/3GtYVXBggVpwgAAAAAAAABkEDRhAAAAAAAAQIaRmJioxMRExcTE6MqVKzpy5IjWrFlz5/FSpUqpbdu26ty5c7rdHQmucfPmTX333XeW42vXrq1HHnnEiRXh33bt2qWPPvpIBw8edPjcYWFhCgsL04YNGyRJHh4eKleunEaNGqVy5co5PB+Aezty5IhWrVplOf7JJ59UoUKFnFgRkHonT560uwGDJJ07d0579uxRtWrVHFgVACA1Dh06pN9//13r1q3TkSNHHD7/rVu3tGjRIi1atEilS5fW+++/7/RmDCEhIRo/frxWrlyZqnmOHDmiUaNG6euvv9brr7+up59+OtW1JSQk6I8//tD69eu1fv16Xbt2LdVz/tv58+f16aefavLkyWrfvr3efvtt5ciRw+F5HgTp+Vi5m6CgII0ZM+ZOg0ZHSkhI0MqVK7Vy5Up16NBB77zzjrJnz56qOcPDw7Vr1y7t27dP+/bt08GDB1NsQpmRTZ061a4GDA+Do0ePasyYMdq6dWuq5tm1a5d27dqlr776SoMHD1bLli0dUl9YWJgaNmzokLnuJjY2VuvWrdO6des0btw49erVSz179pSXl5fTcqZk8+bNdjdgcLQzZ87o3XffTXXzhXs5fvy4hg4dqm+++UYjR45UjRo17JonPDxcK1eu1Lp167R161bdunXLwZX+1chqz549Gj16tF5++WX16tXL4Q1HTM2fP9+uBgwAAAAAAAAAMhaaMAAAAAAAAOCBceLECU2aNElffvmlOnbsqP79+ysgIMDVZSEduHnzpqZMmWI5vm/fvjRhSCMJCQn65JNP9O2338pms6VJzqSkJB08eFCXLl2iCQOQxo4cOWJ0Pq5duzZNGJDuBQUFOWQOmjAAQPoxduxYbd++PU1yHT9+XN27d9fTTz+tt956S76+vg7P8euvv2rkyJGKiopy2JxXrlzRu+++q5UrV2rcuHHKlSuX3XOFhYXpjTfecFht95OUlKRFixZp3bp1GjZsmB577LE0yZtRpPdj5e+SkpL0/vvva/78+Q6ZLyW//vqrdu7cqa+//lolS5a0e54vv/xSs2fPdmBl6dfRo0c1Y8YMV5eRLs2YMUOfffaZEhISHDbnuXPn1K9fP7Vv317vv/9+qt9P0up7Okm6du2axo8fr0WLFmnSpEkqUaJEmuW+LSYmRu+++26a572bNWvWaNCgQYqOjnZ6rlOnTqlnz55655131L17d+Pxa9eu1QcffOD4wu4iOjpan3zyiZYvX65Ro0apUqVKaZL338LCwjRu3DiX5AYAAAAAAACQttxdXQAAAAAAAADgaPHx8frpp5/UqlUr/fbbb64uB8A9xMbG6rXXXtPMmTPT9MZuAAAcxWazacmSJameZ8WKFYqPj3dARQCAjMhms2nevHl69tlnFRYW5tC5P/30U7399tsOXVT/dxs3blSXLl105swZp8zvLOHh4Ro0aJDGjh3L59H/L6MdK0OGDEmzBgy3hYSE6LnnntP58+fTNG9GlJiYqKFDhzq0ycCDIDExUUOGDNGECROc9twsXrxYPXv21NWrV50yvzOdOHFCXbp00Z49e9I89yeffKKQkJA0z/tv69atU79+/dKkAcNtiYmJGjlypL7//vs0y5kaR48e1bPPPqsVK1a4JP8HH3ygyMhIl+QGAAAAAAAAkLZowgAAAAAAAIAH1s2bN9W/f399+umnri4FwL/YbDYNHjxY69evd3UpAADYbdu2bbp48WKq54mIiOA9EQCg48eP64UXXtCNGzccMt/48eP11VdfOWSu+wkJCVH37t0VHBzs9FyO9u233+rjjz92dRkul9GOlTlz5mjx4sUOqsrM1atX1b9/fyUmJrokf0bxzTff6NChQ64uI12x2Wx68803tWjRIqfnOnTokHr06KGIiAin53K0yMhIvfLKKwoNDU2znLt27dLcuXPTLN+9XLhwQYMHD3ZZ85IxY8Zo7969LsltKiEhQYMGDdLatWvTNO/SpUv1559/pmlOAAAAAAAAAK5DEwYAAAAAAAA88L766isaMQDpzLfffqs//vjD1WUAAJAqQUFB6XIuAEDGderUKb399tupnueHH37QN99844CKrLl69ap69+6tmzdvpllOR5k+fbpWrlzp6jJcJqMdK9euXXP593yHDx/WDz/84NIa0rNTp05pypQpri4j3Zk4caKWL1+eZvlOnz6t1157zWUL+lMjIiJC7733XprkiouL07Bhw5ScnJwm+e5nwoQJLn0fTUxM1IcffiibzeayGkwkJSVp4MCBCgkJSZN84eHhGjVqVJrkAgAAAAAAAJA+0IQBAAAAAAAAD4WvvvoqTW9yBXBvYWFhmjx5sqvLAAAgVWJjY/X77787bL61a9c6bOdzAEDGtmbNmlR9h3Hs2DGNGTPGgRVZc+bMGY0YMSLN8zrCBx98oKioKFeXkeYy4rHy448/Kjo62sEVmZs1a1a6WLSd3iQnJ2vYsGGKj493dSnpyoYNG9K02cltu3btyrANMTZu3KgdO3Y4Pc/nn3+uM2fOOD1PSoKDg/Xbb7+5ugwdOnRIW7dudXUZlkVHR+uDDz5Ik1wjR47U9evX0yQXAAAAAAAAgPTB09UFAAAAAAAAAGllxIgRqlOnjgICAlKM7devn/r165cGVQEPn2+++Ua3bt1ydRl2O3bsmKtLAGAH3tvhaKtXr3boYs34+HitWLFCzzzzjMPmBHB3hQoV4poODpEtWzaVL19eRYsWVfbs2SX9tXv38ePHdeDAgVTtPj5p0iS1adNGbm5uRuOSk5P19ttvGy+Adnd3V506dVS0aFH5+fnpwoUL2r17t0JDQ43mWbp0qdq0aaPmzZsbjbOqSJEiKlWqlAoVKiRfX1/FxMTo2rVr2rt3r86dO2f3vOHh4fr+++/1yiuvOLDa9C2jHivLli0zipckDw8PtW/fXu3atVO5cuXk7++vuLg4hYSEaOPGjZozZ44uXbpkNGdoaKj27dunatWqGdfzIJszZ4727Nnj6jLSlejoaA0dOlQ2m81onLe3t+rVq6fAwEBlzpxZoaGh2rZtm65du2Y0z/Tp09WiRQtVrFjRaFxK/Pz8VLJkSQUGBsrX11d+fn7y8vJSdHS0Ll++rBMnTujEiRPGv/ff/fLLL6pVq5YDq/6ngwcPaubMmU6b38SKFSvsauxSoUIFPfvss6pVq5by5s0rDw+PO++L8+fP16ZNm+yqpW7dusbj7sfDw0NlypRRiRIllCdPHmXJkkU3b97UxYsXtWvXLoWHh9s994YNG7R7925Vr17dgRX/06pVq2jyDQAAAAAAADyEaMIAAAAAAACAh0ZERISmT5+ut99+29WlAA+thIQEBQUFGY8rVKiQWrZsqRo1aqhw4cJ3btZ1d3dXZGSkbty4oRs3bujMmTM6fPiwjh49qsOHDz+UO5kCANKGPe9nVuakCQMApG+FCxdW27Zt1aJFC5UvX17u7u53jYuMjNQPP/ygr7/+WtHR0cZ5zp49q23btqlOnTpG4xYuXKgjR44YjWnSpImGDRumwMDAf/w8KSlJy5cv1/vvv2/0O0yYMEGNGjWSl5eXUR134+7urrp166pNmzZq1KiR8uTJc8/Yo0ePaurUqVq5cqVduX7++We9/PLLxo0vMqqMeKxcvXpVp0+fNqrZz89PX3/9tWrUqPGPn3t5eals2bIqW7asnnnmGfXv318bN240mnvHjh0Ob8KQNWtWVahQQVWqVJGXl5emTp3q0PmdKTg4WJ999pmry0h3ZsyYocuXLxuN6dixowYOHKjcuXP/4+fx8fGaN2+exo0bZ7nRT1JSksaNG6c5c+YY1fBvefPmVf369dWgQQNVr15d+fLlS3HMxYsXtWDBAs2cOVMxMTHGOU1fkyYSEhI0dOhQJSUlOS2Hie3btxuPeemllzRo0KD/XIvkz59f+fPnV5s2bfTjjz/qgw8+cHotd5MlSxY1b95crVu3Vp06deTr63vXOJvNprVr12ry5Mk6fPiwXbnmzZvntCYMN2/eNH4OAQAAAAAAADwYaMIAAAAAAACAdOHJJ5/U2LFj7/qYzWZTVFSULl++rL1792rx4sXaunWrXXl++uknvf7668qSJUtqygVgp+3btysiIsJyfObMmTV8+HB17NhRHh4ed40JCAhQQECAJKlq1ap68sknJf11k/nu3bv1559/as2aNTpz5kyq6wcAQJKuXbtm146iKdm9e7eCg4P/s7ARAOB6jRs3Vs+ePVWvXj1Li/T9/Pz08ssvq2XLlnr11Vft+jyyatUqoyYMiYmJmjJlilGOdu3aacKECXf9vOXh4aHHH39cxYoVU48ePSwvoD179qwWLVqkp59+2qiWv/P19dWzzz6rZ555RoUKFbI0pmzZspo8ebIWLFig9957z3hhbWhoqI4cOaLy5cvbU3KKChYsqD///NMpc5vKqMfKqVOnjGqWpFGjRv2nAcO/+fr6avLkyWrdurXRYnnThhD/5unpqVKlSqly5cp3/ilZsuSdBdXbtm3LUE0Yhg8fbtdC+wdZRESEZs2aZTSmV69eeuutt+76mLe3t3r06KHChQvr1VdftXye2759uzZt2qT69esb1eLj46O2bdvqqaeesqvhSP78+dWvXz916NBBL730ks6ePWs0/sqVKwoPD7/zvZ8jff311zp27JjD57WX6fmkcePGevPNN1OMe/bZZ3Xq1CmjJhzBwcFKTEyUp6d9txcXKlRIL7zwgjp06HDPxgt/5+bmpiZNmqh+/foaNWqU5s2bZ5xzzZo1Sk5OvmdzrNQYM2aMrly54vB5AQAAAAAAAKR/NGEAAAAAAABAuufm5iY/Pz/5+fmpRIkS6tSpkzZu3Kg333xT4eHhRnPFxMRozZo1atu2rZOqRXx8vC5fvqywsDBdvnxZMTExio2NVVxcnBISEuTl5SVvb2/5+/srICBABQoUUGBgoN03dT4IYmNjFRYWprCwMF29elUxMTGKi4tTbGysEhMT5e3tLW9vb2XPnl0BAQEqVKiQChYs6JSbSp1t9+7dRvEff/yxmjdvblcuDw8P1apVS7Vq1dLbb7+tEydOaN68eQoKCtLNmzftmhPISKKjo++cW65du6Zbt27dObckJyffObfkyJFDuXLlUmBgoKWdLAFIS5cuVWJiolPmDgoKUt++fZ0y94MoMTFRV65cuXPtGRUVdefaMz4+Xp6envL29pafn59y5syp/Pnzq3DhwvL29nZ16Q+96OhoBQcHKzQ0VBEREYqMjFR8fLykvxpxZcmSRT4+PsqbN6/y58+vPHnyWN4pPT2z2Wy6cOGCQkJCdPXqVUVERNy57vfy8rrzu2fPnv3OLsb+/v6uLvuh1qRJEw0YMEBly5a1a3yxYsU0ffp0Pf3008bfYZh+fvr999918eJFy/G5cuXSiBEj7tnw7raKFSuqX79+GjdunOW558yZY1cTBh8fH/Xq1UvPPfec/Pz8jMdL0lNPPaW4uDh9+OGHxmN37drltCYM6UlGPVauXbtmeV5JKlKkiFq3bm0pNmvWrOratas+++wzy/Obvqalv5pHFihQQJUqVVLFihWVOXNm4znSo3nz5qXYNLd+/fpOaWSWns2fP9+oMUXp0qU1cODAFOMaNWqkZ599Vt9//73luWfPnm3UhCEgIEAbN25U1qxZLY+5l8DAQH399dfq0KGDbt26ZTT20qVLDm/CcPz4cX311Vf3jSlVqpQiIiLSbPG96fmtd+/elmNfeukloyYMiYmJunnzpvHzXrBgQb3++ut67LHH7Pqu39vbWyNGjNCNGzf022+/GY29ceOGTpw4oTJlyhjnvZ+NGzdq4cKF9415GM9tAAAAAAAAwMPi4b2rGQAAAAAAABnao48+qunTp6t79+7GN25u2bLlgWjCkJSUpC1btmj9+vU6dOiQzp07d2dheUBAgAICAlSyZEk1bNhQ9evXV44cORyaPzk5WceOHdPBgwd14sQJnTx5UidOnNCVK1dks9mM5vLy8lLp0qVVvXp1NWnSRHXq1Enxxv6MKCEhQYcPH9ahQ4fuPF8nT56066b9TJkyqXz58qpRo4aaNWumatWqWdqN1dVOnDhhObZixYp2N2C4m1KlSmn48OEaNGiQli1b9sAuNr/dbGbdunU6cuSILl26pJiYGGXJkkW5cuVS+fLlVbduXbVu3dp4UVNUVJRWr16tTZs26fDhwwoLC1NMTIyyZcumgIAA5cuXT3Xr1lWjRo1UqlQpJ/2G+LfY2FgdOHBAR44c0YkTJ3TixAmdOnXKrmYjPj4+qlSpkmrVqqUWLVrYvdgQd3f9+nVt27btznvnxYsXdeXKlTsLxj09PZU5c2Zlz55d+fLlU9GiRVWxYkXVqFFDJUqUcHX59xQVFaW1a9dq06ZNOnbsmEJDQxUdHS1vb28FBAQoV65cqlSpkho2bKjatWsrU6ZMri451YKCgizH5siRQ/7+/pZ3fV2yZEm6bMJgs9m0a9curVu3TgcOHNCZM2d048YNJSYmKkeOHMqZM6eKFCmiBg0aqEGDBsqbN6/D858+fVoHDhz4x7XnxYsXlZycbDSXh4eHihcvrurVq6thw4Zq2LAhTRnSQHx8vNavX6+1a9dqx44dOnfunNHnBnd3dxUqVEjlypVTmTJlVK5cOVWrVs3hn3OcITg4WCtWrNDmzZt14MABRUVFGY339fVV6dKlVbZsWZUrV04VK1ZU2bJlM2RTtoykTJkyGj58uGrXrp3quQIDA9W/f3+9//77RuPOnDljFP/TTz8Zxf/vf/+z/JmgZ8+emjNnji5cuGAp/vjx49q5c6dq1qxpKd7NzU1PPfWUBgwYoFy5clkacz/dunXTkiVLtGfPHqNxpjuRZ1QZ9VhJSEiwNOdttWrVcmq8PU252rVrZzwmvbt06ZLGjx9/35i8efPqrbfe0hNPPJFGVaUP8+bNM4ofPHiw5cXr/fv31y+//GL5u/H169frwoULKlCggKX4240bHaVo0aJ67LHHNH/+fKNxJk0srEhKStLQoUPvez7x8PDQRx99pAEDBjg09/2YnN+8vb1VrVo1y/H58uVTYGCggoODnVKPj4+P/ve//6lnz56pPmbc3Nz0/vvva8OGDYqOjjYae/r0aYc2YYiOjtZ777133xgfHx+NHDlSTZs2dVheAAAAAAAAAOkHTRgAAAAAAACQYVWsWFHPPfdcirtW/dvevXtTjPn88881ZcoUy3OuXr1ahQoVshQ7ZMgQLVq0yPLcx44d+8d/x8fH6/vvv9fs2bPvuWvhxYsXdfHiRR06dEhBQUHy8vJSt27d9Nprr6V6F9Vff/31zkIG0xsh7yUhIUGHDh3SoUOHNGfOHOXKlUtdu3ZVjx49lC1bNqO5mjZtqtDQ0FTVM2XKFKO//5NPPqmxY8fe8/FZs2Zp1apVOnDggGJjY1NV221xcXHas2eP9uzZoxkzZqhQoUJ67rnn1KVLl3S9uNXqIgxJRjcTm8iSJYueeuopu8eb3Myb0rHxd9u2bVPPnj0tz923b1/169fvzn/HxcVpxowZmj17tiIiIv4THxkZqcjISJ05c0bLli3TqFGj1LNnT7388svy9fW9b67IyMg7c9/t5vfw8HCFh4fr5MmT2rhxoyZMmKCaNWtqyJAhqlSpkuXf6d9CQkLUrFkzy/H/fk7SSw5n+eSTT7R161YdPnzYeDHSvcTExGjbtm3atm2bpkyZotKlS+vFF19U+/btjZrjmD6v92LympCkMWPGqGPHjnd9zJnv7fcTGxurZcuW6ZdfftGePXvuu1g8KSlJcXFxunHjhs6dO6dt27bdWbQTGBioxx57TF26dFH+/PlTXZdk9p5Zu3bt/+ycee3aNX355Zf65Zdf7npuSEhIuLPT/Z49ezR79mwFBASob9++6tKli107Y6YHp06d0qFDhyzHt2zZUjlz5tTUqVMtxZ89e1Z79+5V1apV7azwn1J77CcnJ2vhwoX65ptv7rkw9fLly7p8+bKOHDmi3377TW5uburQoYPeeOONVDdjWLdunX788Uft2bPnru9v9khKSrrTtGbevHny8/NT586d9cILLyhPnjwOyeEIs2bNUmRkpKXY/Pnzp+r65rYzZ85o6dKlluNbt26dYuOl2NhYzZo1S999951dzcduS05O1vnz53X+/HmtXLlS0l+LtEqVKqXatWurefPmqlu3rqW50ur9f9++fZo8ebI2btxoPPbvoqKitHv3bu3evfvOz/z8/FSzZk3Vrl1bnTt3Nm6uhft7+eWXVadOHYe+V3Xq1EkTJkwwasIRExOjmzdvWvpcHB4erh07dlie28vLS+3bt7cc7+npqccff1xff/215TG//fabpYX1fn5++umnnxz23ndbz549jZswhIWFObSG9CijHysmTBt65MyZ0yiec+9f3n///RTPbSNHjkzxu4cHzcGDB40WvefJk0cNGjSwHJ8tWzY1a9bM8rVbcnKyfv/9dz3//POWczhanTp1jJswZM2a1aE1zJo1SwcOHLhvzPPPP6/KlSs7NG9K/Pz8LH/eyZ49u3ED41y5chkdj1a/ky9fvrxWrFjh0Ga3AQEBat++vX788UejcY5+D//4449T/M5k8ODBKliwoEPzAgAAAAAAAEg/MuadTQAAAAAAAMD/16VLF+MmDCY3G6Y3u3fv1ttvv63z588bjUtISNCsWbP066+/6osvvrC8E+Xd/P7776leRJSSq1evavLkyZo7d66GDx+utm3bOjWfsy1atEhHjx51ao6QkBCNHj1as2fP1siRIy0vQEtrJguOMmfO7MRKHiyHDx/WG2+8YXmXdemvBZHTpk3TihUrNGnSJFWoUOGucVu2bNGQIUN06dIlo5p27typzp07q1evXnrzzTeNxsKaH374wfLiXHsdP35cQ4YM0XfffaePPvpI5cuXd2q+B0l8fLx+/PFHffnll7p+/Xqq5wsODtaXX36padOm6amnnlLfvn1dulj8559/1rhx44x3cw8PD9eHH36on3/+WdOnT09XC96tCgoKMopv06aNAgICLDdhuJ3D0QtR7XHq1Cm9+eabRk0nJMlms2nRokX67bffNHbsWLVu3druGjZu3Kg1a9bYPd6KyMhIzZw5U/PmzdOAAQOMG8A4y4ULF/Tdd99ZivXy8lLTpk0VEBCQqpw//fSTZs2aZTlnt27d7htz/Phxvfbaa077DGaz2XT8+HEdP35cISEh6eYa2GazacKECZo5c6ZsNptTckRGRmrNmjVas2aNatWqlarGV/ivRx991OFzenl56ZFHHtHq1auNxt26dcvSQsjVq1fft9nTv1WvXt14QXTDhg2NFtavWrVKw4cPTzHO39/fKe979evXNx5jdUf5jCwjHyum145xcXFOjU9ts6kHQVBQkNauXXvfmCeeeEKNGjVSSEhI2hSVTqxatcoo/tFHH5W7u7vRmAYNGhg10HJ1E4bs2bMbj8mRI4fD8p89e1aTJ0++b0zRokXVv39/h+W0Kk+ePJabMMTHxxvPb9IYOFu2bMqSJYul2LJlyxrXYsWjjz5q3ITBke/hO3fu1A8//HDfmNq1a6tr164OywkAAAAAAAAg/TH71h4AAAAAAABIZwoUKGC8G/StW7ecvmjVGWbNmqUePXoYN2D4u4iICL300kvasGGDAytznmvXrumNN97QuHHjXF1KhhEcHKxevXpZXrCX1kwWehw5csSJlTw41qxZo65duxo1YPi74OBgde/e/R87K982b9489erVy7gBw202m00zZszQu+++a/S3R/pz5MgRPfvss1qxYoWrS8kQjh8/rs6dO+ujjz5ySAOGv0tKStK8efPUrl07LV682KFzWxEfH69Bgwbp3XffNW7A8HdHjx5Vt27dMtxCLJvNpiVLlliOz5kzp2rXrq0yZcqoRIkSlsctX75cCQkJ9pToMMuXL1enTp2MGzD83a1btzRw4EAtXLjQgZU5T3R0tEaPHq2BAwcqMTHR1eWoW7ducnNzsxSbkJCgRYsWpSqfzWbTypUrLcc3adLkvk0f9u3bpx49emToJnj2SEpK0pAhQ/TNN984rQEDMq4CBQoYj/Hy8rIUt3XrVqN5q1evblxLxYoV5elpfb+Xixcvpuo7jNTy9/c3bh7g7e3tpGrSj4x8rJQpU0aZMmWyPO/Jkyctx0p/NaAykR6aZrnStWvX9NFHH903Jnfu3Bo6dGgaVZS+pMVrrVq1akbx+/fvN1qM72jh4eFG8QEBAcqXL59DcttsNg0fPvy+v7+7u7s++ugjo/OMo5g01IqIiNDVq1ctxycmJurcuXOW49PDuc2eayZHvYfHxsZq2LBh972Wz5Ili0aPHm358xoAAAAAAACAjIkmDAAAAAAAAMjwcufObTwmJibGCZU4z8SJEzVmzBiHLAa7deuWXn/9dYWGhjqgsrQxc+ZMffLJJ64uI8NISkrSRx99pHnz5rm6lP+wsoPrbZs2bdKWLVucWE3Gt2nTJr3++uup3uktJiZGL7/8si5cuHDnZ/PmzdN7772npKSk1Japn3/+2fKu2ki/YmNjNXjwYK1bt87VpaRrq1atUufOnXX06FGn5rl586befPNNjR49Os2anNy6dUu9e/c22mn1fs6fP69+/fqli8XuVm3fvv0f58qUtGjRQh4eHpKk1q1bWx4XERHh0tfa3LlzNXDgQIfsJJqUlKThw4dr//79DqgsbSxbtkxvv/22q8tQkSJF1LBhQ8vx8+fPT1W+vXv36uLFi5bjO3bseM/Hbty4oVdffdXybr4PkmnTpunXX391dRlIp7JmzWoU7+bmZvkz1N2aqt1PmTJljOIlKXPmzCpSpIjRGNO6HM3Hx8co3uQza0aVkY8VLy8v1a1b1/Kc27dvN1qovHz5csuxmTJlMqrlQTRixIgU3+vff/99Zc+ePU3qSU/i4+ONm5nZ81orXLiwsmTJYjk+ISFBBw4cMM7jKKaNKWrVquWw3D/88IN27Nhx35hu3bqpRo0aDstpwuS6XzI7X61du9bo/4c0btzYqBZnMH3/lhz3Hj5p0qQUm90OGDBAhQsXdkg+AAAAAAAAAOkXTRgAAAAAAACQ4T3ou6tPmTJF06dPd+icMTExeu+99xw6p7NNmzaNhb+GRo0a5fRFwKZMbry32Wx67bXXNHfuXJfvBp4eBQcH64033lB8fLxD5rt58+adBacbN27UiBEjHDLvbZMmTTLadQ/pU2Jiot566y2FhYW5upR0afHixerXr1+a7iw6e/ZsvfPOO07fbT0hIUF9+/Y1XjSTksOHD2vGjBkOndOZgoKCjOLbtm17599NmjBIfx1PrvDrr79q5MiRDj2mkpKSNHToUIe9Z6WFpUuX6ocffnB1Gerevbvl2DNnzmjnzp1251qxYoXl2Ny5c6tBgwb3fHzixIm6du2a3bVkVMHBwfryyy9dXQbSMdMdwIsUKSJPT09L85o0CZKkYsWKGcXbO+7gwYN25XGE5ORk42YwJUqUcE4x+mtR9h9//KGJEyfqueeeU+vWrVW3bl1VrFhRFStWVI0aNdS8eXN17dpVQ4cO1ezZs3X06FGHvic/CMfKs88+a3nOuLg4ffjhh5aew9WrV2vVqlWW537ssceUI0cOy/EPmt9//10rV668b0ybNm3UokWLNKoofTl27Jjxta89rzU3NzcVLVrUaIyrzsvnz583ut6UpM6dOzskd2hoqCZOnHjfmMDAQA0cONAh+ezRrFkzo2bTU6dOVXBwcIpxERERGj9+vOV5/fz81KFDB8vxzmJ6zSQ55j18//79+u677+4bU61aNfXs2TPVuQAAAAAAAACkfzRhAAAAAAAAQIZnsqPdbfbspOQqn3/+uVPm3bhxo9avX++UuZ3BZrNp5MiRGWrxnqvFx8frww8/dHUZ/2B6Y3hMTIw+/PBDNWnSRB999JG2bt2apoub07OgoCDduHHDoXNu375d8+fP19tvv62kpCSHzh0bG6vPPvvMoXPCNSIiIjRhwgRXl5HubN68WUOHDnVJc6hff/1VH3/8sVNz7NmzRxs3bnTK3FOnTnX4+cwZ4uLiUlxo9ne5c+f+x86tpUuXVsmSJS2PX7NmjW7evGlUoyN8/vnnTmnqceLECf3yyy8On9eZPvnkE12/ft2lNTRo0MDo+unnn3+2K4/NZjM6vtu3b3/PheEREREZ7m/tKHPmzFFcXJyry0A6ZrrwtWLFipbiTp8+bVxL/vz5jcfYM86e2hzl+PHjxt8hVKpUyUnVSFeuXFHfvn01ffp0bd26VWfOnFF4eLgSEhKUkJCgqKgoBQcHa9euXfrll180evRoPfHEE2rQoIHGjRunM2fOpLqGB+FYady4serUqWN53pUrV+rVV19VaGjoXR+Pj4/Xd999pwEDBlieM1u2bOrfv7/l+AfNjRs3Uvy+KUeOHBmuAawjmb7WfH195efnZ1eufPnyGcW74rwcGhqq1157TTExMZbHVKtWTY8++qhD8r/33nv3ze3m5qZRo0a59P8ZeHl5afDgwZbjr1+/rm7dumnt2rX3jNm7d6+6du1q1BT1jTfeUNasWS3HO4vpNZOnp6fKlSuXqpwJCQkaNmzYfb8T9fb21ujRo+Xuzq3XAAAAAAAAwMOAbwIBAAAAAACQoYWEhOjSpUtGY7JkyWL3Ta0Pmvnz57u6BCPBwcHGO1A/7Hbt2qUtW7a4uow7HnnkEbvGXblyRd99952ee+451axZU08//bRGjhypRYsW6eTJky5Z9PygGj58uF3Nbaz4448/XL6YFY6xdOlSnT171tVlpBtXrlzR4MGDlZCQ4LIaZsyYoXXr1rksf2rExcVp8eLFri4jRatXr1ZUVJTl+JYtW/5nYUbr1q0tj4+PjzfeKTa9y2jXnpGRkSnugupsbm5u6tatm+X4lStX2tW8Y8+ePUafqzp16nTPx9asWePwZk4ZxerVq11dAtKx4OBgHT582GhMs2bNLMWZLs739vaWv7+/0ZjbcuXKZRTviMYB9vr999+N4rNly/aPBkrpxZUrVzRz5ky1a9dOb775psLCwuye60E5VkaPHq2cOXNajl+zZo1atGihrl27atSoUfr88881ceJE9e/fX40aNdJHH31kuWGHh4eHRo0apbx581rO/6D56KOPdOXKlfvGvPvuuwoICEijitIf09da7ty57c5lOjYtz8vnzp3TZ599pvbt2+vEiROWx2XNmlVjxoyRm5tbqmv45ZdfUmwo+PTTTxs1d3GWDh06qE2bNpbjw8LC9PLLL6t58+YaMmSIPv30U02aNEnvvfee2rdvry5duujUqVOW57t9nkwPTN/D69WrpyxZsqQq55dffqnjx4/fN6Zfv34qUaJEqvIAAAAAAAAAyDjuvjUFAAAAAAAAkEH89NNPxmMCAwOdUEnaKlSokGrXrq08efIoOjpaBw8e1J49e4znWbNmjcLDw1N9U3S2bNlUs2ZNlSxZUiVKlFDx4sWVPXt2+fj4KGvWrPL29lZsbKxiYmJ04cIFnTlzRtu2bdPvv/9utJhR+mt3386dO6eq3vQgV65cqlGjxp3nrGjRosqWLZuyZs2qrFmzytPTU7du3VJ0dLRCQkJ08uRJbdu2TatWrTLeXXfevHmqW7euk34TM7Vr15aXl1eqFionJCRo37592rdv352f+fj4qEKFCqpataqqV6+u2rVry9fX1xElZyilS5dWtWrVlDNnTkVERGjz5s0OWyjv4+Ojhg0bqlChQrLZbDpy5Ii2bdtmtMgyISFBQUFBev755x1SE/6rYMGCqlatmkqUKKESJUqoSJEi8vX1vXNucXd3V2xsrG7cuKHQ0FAdO3ZMmzZt0oYNG5SYmGg5j81m0/z58/Xmm2868bfJOD766CNdu3bNrrGVK1dW2bJllTNnzju7H2/ZssX4XG+z2fTuu+9q5cqVqV54YKJy5coqV66cAgICFB4erq1btxrtsnnbggUL1KNHDydU6DimjaDutnimTZs2mjJlilHOLl26GOV1hty5c6tOnTrKly+fEhISdPz4cW3dutW4CdKhQ4d09OhRlS1bNlX1+Pj4qHr16ipdurSKFy+uEiVKKCAg4M65LnPmzIqLi1NMTIwuXryoc+fOaefOnVq5cqXxa3XBggXq16+fPDw8UlVzanTs2FGffvqppZ2DY2NjtWTJEqPGDZKMGn5UqVLlvguPTBqAeXl5qU2bNmrSpInKli2rPHnyKHPmzEpISFBkZKQiIyN1+fJlHTt2TMePH9fRo0d15MiRdNmAKzg4WCEhIZbjixYtqk6dOqlmzZoqVKiQ/P395enpqaioKN28eVM3b97U6dOndfz4cZ04cUL79u1TeHi4E38DONvMmTON4v38/NSkSRNLsaaL8rNnz24Un5qxly9fls1mc8hCWhMxMTH68ccfjca0bt1a3t7eTqoo9ZKSkrR48WKtWbPmzgJbUw/KsVKoUCHNnDlTzz//vOVGf0lJSdq1a5d27dplVNffeXl5adSoUWrVqpXdc2R069ev16+//nrfmGbNmqldu3ZpU1A6lZ5fa6lp5HLb3LlzdePGjX/8zGazKTY29h/fZYaGhhrP7ePjo+nTp6tYsWKprvPy5csaO3bsfWPy58+vt956K9W5HGX8+PGKjY3VmjVrLI8JDg5WcHBwqvI2adJEn3zySZq/X9/N/v37tWPHDqMx9rwn/t3Ro0c1bdq0+8ZUqFBBvXr1SlUeAAAAAAAAABkLTRgAAAAAAACQYe3fv19z5swxHle1alXHF5NGChYsqA8++EANGjT4zw2R+/bt08CBA40W/iQkJGjXrl1q0aKFcS158uTRE088oUaNGqlatWry9Lz/1423F8Xlzp1bVapUUYcOHTR8+HBNmjTJaIfh/fv3Kyws7J47Dr744ov/2f03MjLSaMHLI488YrT7mdWFhEWKFFH79u3VqFEjVaxYMcWbWn19feXr66u8efOqRo0a6tKli8LDwzV69GgtXbrUcn3r1q1TfHx8ulhM4u/vrw4dOjh8J+yYmBjt2LHjzg26Xl5eql69ulq1aqW2bdsqR44cDs2X3hQoUEBjx47VI4888o+fJycna+rUqfr8889TNf8LL7yg119/XT4+Pv/4+f79+9W7d29FRERYnmvbtm00YXCwcuXK6bHHHlOjRo1UqlSpFONvn1sKFiyo2rVrq0ePHrpw4YKGDh1qtHB21apV92zC4O/vr/79+//n50eOHDHazbBTp04qVKiQ5fjy5ctbjnWUPXv2aPny5cbjmjRpomHDht21OVRUVJRmzJih6dOnGzXHCAsL0zfffKO+ffsa12OqVq1aGjFixH8WYttsNv3666/68MMPLS0Yv+3o0aOKiIhI1eIjZ7p27VqKu6f+XZ48eVSjRo3//LxkyZIqWbKkTp48aWme3bt3Kzg42GVNxLJnz653331Xbdq0+U8TgjNnzmjgwIHGu7pv3brVriYM/v7+d66jHnnkkRSva7JkyaIsWbIoZ86cqlixotq1a6d33nlHs2bN0qRJkyy/tq5cuaJ9+/apevXqxjU7iq+vr5588knNnTvXUvz8+fONmjDYbDbjc/P9XL582dI8Pj4++u6771S5cuX/PObp6aksWbIoT548KlGixD8ait24cUNbtmzR5s2b9eeff6a4E3daMVnQ+Pjjj2vMmDHy8vL6z2P+/v53dp2vUKHCnZ/fboK1ceNGbdy4UTt27EiXzShwd0eOHNG8efOMxjz//POWGyuZNpjx8/Mzik/N2MTEREVERKT5Z7LJkycbNS7x9PRU7969nViR40RGRurNN9/UiRMnNGjQIKOxD9KxUrZsWQUFBWnQoEHGi3XtUaRIEU2cOPGu71sPi6ioKL333nv3jfH399cHH3yQNgWlY+n5tXb16lW7c902a9YsnT9/PtXz/FuFChU0YcKE+zb8MjFixIj/fE/8bx9++GG6auTq7e2tqVOnaurUqfryyy+NvhOwN9/rr7+ul156KV00YEhKStLIkSONxhQpUuSuTRBNcg4bNuy+TYO9vLw0ZswYlzbnAwAAAAAAAJD2aMIAAAAAAACADGndunV6++23FRsbazz27wt4MpLSpUtr7ty5ypYt210fr1KlimbNmqVOnTr9Zyey+zl48KBRE4by5curdevWatOmzV0XDZnImjWrhg4dKjc3N82aNcvyuC1btqhDhw53fax79+7/+VlISIhRE4ZatWrptddesxxvZb7+/furSZMmqb6ZNSAgQB9//LHi4+MtL5aLiYnRvn37VKtWrVTldpQ+ffro119/ve+NramVkJCgbdu2adu2bRo7dqxatmypPn36qEyZMk7L6Sr58uXTzz//rNy5c//nMXd3d/Xt21d79uwxWjz8d2+99dY9d3mrXLmyRo8erf/973+W5zt06JBddeC/mjdvro4dO6p27dqpnqtAgQKaPn26unXrpn379lkac/bsWV24cEEFChT4z2N+fn53PY8uXLjQaKHvE0888Z/mIunNN998Yzymd+/eGjx48D0f9/X11YABA1StWjW99tprRosuvv/+e/Xu3VuZMmUyrsuqDh06aMyYMXJ3d//PY25ubnryySfl5+dndG6QpMOHD6tevXqOKtOhli1bZvR3aNWq1V2fH0lq06aN5eY4NptNixcvNn4uHSFv3rz66aef7voal6RixYpp1qxZ6tixo1ETsIMHDxrVUaRIEb3//vt68sknLS9Gvhdvb2/16dNHmTNn1ujRoy2P27x5s0ubMEhSt27d9MMPP8hms6UYe+TIER04cECVKlWyNPfu3bt16dIlS7GZM2dW27Zt7xtjddHhM888Y9dCVn9/f7Vu3VqtW7fW+++/r40bNyooKEhJSUnGczmS1d/by8tL7777rvFnKTc3N5UvX17ly5dXnz59dOnSJS1evFhBQUH2lIs0FBUVpTfeeMPoGM2dO7dR47Lr168b1ZQ5c2aj+NSODQ8PT9MmDBs2bDD6jkGSOnfurMKFCzunICeZNm2abDbbfa8r/+1BO1by5s2rOXPmaMWKFfr88891+vRp45wpKViwoHr16qWnn3461d+DZXQTJkzQxYsX7xvzzjvvKE+ePGlUUfpl+lpLzXWu6WstJiZGcXFxTv3MaKpUqVJ66aWX9Pjjjztskfvy5cu1atWq+8Z07NhRDRs2dEg+R7r9fV7btm01adIk/f777w5vvpUpUyY9/vjj6tu3r/Lnz+/QuVNj8uTJ2r9/v9GYAQMGpNgg+n6++eabFD+nvvLKKw/k98oAAAAAAAAA7u/ud/4AAAAAAAAA6YjNZlNUVJROnTqlX375RT179lSfPn2Mb2aV/tpttUmTJk6o0rn8/Pw0ffr0ezZguC0wMNB4h3nTBdF9+/ZV+/btHXrj+WuvvZbibsZ/Z7p4z9WGDx+upk2bOnQ3sQEDBhjFp6eF74ULF9abb76ZZvni4+O1dOlSPfHEExoyZIjRbqgZwcSJE+/agOHvOnbsaNfcDRo0uGcDhtuaN2+uIkWKWJ4zLCzMIbsuQho7dqxDGjDc5uXlZbzQOz2dW1zh8uXL+vPPP43GNGnSxPJCuUaNGhmfL69fv66VK1cajTFRtWpVjRo16p4NBm5r3ry5ceOr9Pz+brrIuXXr1vd8zHSHzsWLFxvFO4Knp6e++uqrezZguM3f31+vv/660dym543u3bura9euqW7A8HfdunVL8b3z79LDua5EiRJGTUrmz59vOfa3336zHNuiRYsUd1u22rDE5PrhXjw8PNSoUSN98skn+uSTT1I9X2pYXWCfPXt2+fv7pzpfvnz51KdPHy1btkzly5dP9XxwjoSEBPXv319nzpwxGjdixAijXblNG1SmZuGtPWPj4uLszmfq2LFjeuONNyw1rbmtUKFCRo0M0pPp06cbXSs8iMeKm5ub2rZtqxUrVmjatGnKmzev8Rx34+XlpcGDB2vVqlXq1q3bQ9+AYfv27Zo3b959Yxo2bKgnn3wyjSpK30xfaybfi/6bPa81exobO0PBggX1zTffaOnSperQoYPDGjCEh4dr5MiR943JkyeP3nnnHYfkc5bixYtr0qRJWrNmjZo2beqweR999FGtXr1ao0ePTlcNGBYtWqSvvvrKaEzLli1TbBJ3P2fOnNGUKVPuG1OmTBm9/PLLducAAAAAAAAAkHHRhAEAAAAAAADpwqJFi1SmTJm7/lO2bFnVqFFDbdu21dChQ7Vt2za78zzzzDMOXcCVVl599VXly5fPUqzpDZlhYWH2lORQ/v7+Klq0qOX4kydPOq+YDKJEiRLKmjWr5fgTJ044sRpzzz33XJrfmG+z2bRo0SI9/vjjqTqPpCePPvqoatWqlWJclSpV7JrfarOP+vXrG81rdbdtpD3TYyW9nVvS2qpVq4x2tfby8tKQIUOMcnTv3l3FihUzrssZ3NzcNGzYMMsL0DLiNcndnDp1yqhBRL58+VSjRo17Pl6iRAmVLl3a8nxnz57Vvn37LMc7QpcuXSwv6jb9O6eH9wAPDw9VrFjRcnx6ufbs3r275dilS5cqJiYmxTibzWbUuKVTp04pxmTPnt3SXI4+rh21aM9eVn/va9euKTg42KG5Xf274+7i4+PVv39/bdy40Wjciy++qGbNmhmNSUhIMIpPqZnS/dhzvMXHx9udz8Tx48f1wgsvKDIy0vKYTJky6dNPPzVqepHejBgxQpcvX7YU+6AeKwcOHNCAAQP0+uuvO+yaMiEhQRMnTlSbNm00a9asNG0mkt7ExsZq+PDh921u4uvrm+Ki94eJ6bGcmteaPWPT6rycktDQUPXu3Vs9evTQ2rVrHTbv6NGjU2zC+sEHH6TY8NjVbty4ocmTJ6tr167GDSDvZ+PGjWrZsqWGDh2q8+fPO2ze1FiyZImGDRtmNKZIkSIaPXq03TltNpuGDRt23/O7p6enxowZ89A34gEAAAAAAAAeVp6uLgAAAAAAAABIK9mzZ1fv3r1dXYYxHx8fde3a1XJ88eLF5eHhYXlRqMniBGeyumhJSr+LNNNa9uzZFR0dbSk2PT5nY8aMUZ48efT111+nad6rV6+qV69emjZtmtGO0umRlYWQ0l87C3p5eRktuCldurTlBaolSpSwPK+Ufs47+C+Tc7GUPs8tacl0UeWjjz5q1HRI+uuG/2eeeUZjxoyxPGbTpk1KTk5O1UKeu6ldu7YqV65sOb5UqVJG86fXc4PJ7tKS1KpVK7m5uaUYc/z4cctzBgUF2d1Qx5Sbm5t69eplOd7Pz0/58+fXxYsXLcXHxMQoKSnJ5YvGTc53Vhe2Olvjxo1VqFAhhYSEpBgbHR2t5cuX66mnnrpv3K5duyyfywsWLKg6deqkGJcrVy5L8y1atEhFixbV888/n6qd1tOLnDlzWopLTk7W//73P40fP15ly5Z1clVpY+HChQ7fSfrYsWMOnS+tRUdHq1+/ftq0aZPRuMaNG2vw4MHG+dJyYX1K73F3Y1qfPfbs2aNXXnlFERERlse4ublpzJgxRtc39vD09FTRokVVokQJZc+eXdmyZZO3t7du3rypy5cva//+/ZbfR+8mKipKn376qaXrxQftWAkLC9OIESO0evVq41xWnT17VmPGjNE333yjoUOHqk2bNk7LlV599tlnOnfu3H1j3nrrLcsNZB8GiYmJRvFp3YQhLc7LViUnJ2v79u3avn27KleurLFjxxp/z/R3f/75p5YuXXrfmMcee8y44VFaSk5O1owZMzRt2jSnfU6OiYnRL7/8oqCgIHXp0kVvvvmmy5pX//DDDxo5cqSSk5Mtj/H399eXX36ZqkYa33//vXbt2nXfmF69eqlChQp25wAAAAAAAACQsdGEAQAAAAAAAA+Nd999VwEBAa4uw1jTpk2NboD09vZWQECArly5YineUTdyRkVFac+ePTpy5IjOnDmj0NBQXb16VTdu3FB0dLQSExMddoNvSjuZZRTh4eHau3evjhw5onPnzik0NFTXrl3TjRs3dOvWLSUkJBjftH2/XOmNm5ubBg4cqEqVKmnMmDEKDQ1Ns9wJCQl64403tGDBAgUGBqZZXkfy9PRUgwYNLMW6ubkpZ86cRruPN2rUyHJs3rx5LcdKf50v4DxhYWHau3evjh49qvPnzys0NFTh4eG6ceOGYmNjlZCQYLlRT0rS47klLe3fv98ovnXr1nblad26tVEThqioKJ0+fVolS5a0K9+9tGvXzije9NyQHpsw2Gw2LVmyxGiMlYV5bdq00eeff255zuXLl+udd95Jk903q1atqoIFCxqNyZs3r9Hi0aioKPn7+5uW9g+xsbHat2+fjhw5opMnT+rChQu6fPmybty4oaioKCUkJDjs2jM2NlZRUVEu3yXd3d1d3bp107hx4yzFL1iwIMUmDL/99pvl/B06dLC0oLZq1ar6/fffU4yz2Wz65JNPNG3aNNWpU0eVKlVS0aJF7/yTOXNmy7WlByVLlpSfn5+lc9mxY8f0xBNPqGzZsqpZs6ZKly6twoULq3jx4sbnTqQ/4eHh6t27tw4ePGg0rmrVqvrss8/salJj+v5gssjx32w2m/EYZ79/rV27VgMGDNCtW7eMxg0ZMsT4+sYKDw8PValSRY0aNdKjjz6q0qVLy9vb+75jTp06pblz5+rnn3+26/1ryZIl6t+/f4qL4B+kY2X9+vV68803jRpvpMbly5c1YMAAbdmyRe+99548PR+O2+727dun77777r4xdevWVZcuXdKooozB9PhIzWvNnrFp8bnCHvv371enTp00cuRIPf7448bjIyMj9f777983JmfOnBo2bJi9JTrdtWvXNGDAAG3fvj1N8iUmJmru3LnaunWrpkyZouLFi6dJ3tsmT56sL774wmhMlixZNHXq1FQ16wgJCdEnn3xy35gSJUqob9++ducAAAAAAAAAkPE9HP83CAAAAAAAAA+93r1767HHHnN1GXapVauW8RhfX1/LTRiio6ON578tKipKixcv1rJly7R3716HNQxIienCivTk6tWr+vXXX7V8+XIdPnzYrkUJ9kjPz1mLFi3UsGFDffvtt5o9e7auXbuWJnkjIiI0bNgwzZ49O03yOVrhwoXl5+dnOT5btmxGTRhMdnkz3SkvNecd3F1ISIgWLVqkFStW6NSpU2mWNz2fW5wtPDzc8nvtbVWrVrUrV758+ZQ/f36jRe7Hjx93eBMG02sSk3OUlD7PDTt27DBqElSgQAFLf+cSJUqodOnSOn78uKV5r1+/rvXr16fJbq32XnuaiI6OtqsJQ1xcnFasWKElS5Zo+/btio+PN57DXrGxsS5vwiBJnTp10uTJky2df/fs2aMTJ06oVKlSd33cZrNp5cqVlvK6ubnpySeftBRbv359S3G3RUVFadWqVVq1atU/8uXPn19FihRRiRIlVLZsWVWoUEFlypSxa4F6WvDw8FCdOnX0xx9/WB5z9OhRHT169B8/8/HxudOIonTp0ipbtqyqVKmSIRsKPoyCg4P10ksv6ezZs0bjypcvr+nTp9u9A7XpYtrUNOSy53N/Sg0IUmPhwoV69913jevq16+fnn/+eYfWUq5cOT311FN67LHHlD17dqOxJUqU0Hvvvaenn35aAwcONL6mT0hI0OLFi9WnT5/7xj0ox8q6dev0v//9z2ENl0zMmzdP0dHRmjBhgtzd3dM8f1qKj4/X0KFD77vI38fHR6NGjUrDqjIG0/Neal5r9ox15nk5tW7duqW33npLkowbMYwdO1aXL1++b0x6btR848YNvfDCCzp27Fia5z516pSee+45zZ07V4ULF3Z6vuTkZH3wwQeaN2+e0Thvb29NmTJFNWvWTFX+d999VzExMfd83N3dXWPGjEnXrxUAAAAAAAAAzkcTBgAAAAAAADzwevfurcGDB7u6DLuVKVPGeIyPj4/lWHuaAMTHx2vatGmaNWuWS3atTssFd44SGRmpyZMna968eYqLi0vz/On9OcuUKZNeeeUV9erVS6tXr9b8+fO1bds2py+o2LZtm3bv3q3q1as7NY8zmO5MZ7qgq1ixYpZj03I3VfzTlStXNHHiRC1ZsiRVizbsld7PLc504cIFo/jMmTOnaiFDqVKljJowmDQOsCJz5swqWrSo0RjT805aNSYyERQUZBTfqlUrubm5WYpt06aN5SYMt2tJiyYMzr72lMzfB5KTk/Xjjz9q6tSpunr1qtFYR0kv5zt/f3+1b9/e8mKl+fPna+jQoXd9bNeuXSkuUrutVq1aCgwMtBRbtmxZ1a5dO1W799psNl24cEEXLlzQli1b7vzcx8dHtWvXVqNGjdS6det0t4CuR48eRk0Y7iYmJkaHDx/W4cOHtXz58js/L1GihOrXr69WrVqpRo0als81SDtHjx7VSy+9ZNykqXz58vr222+VLVs2u3NnypTJKD41n0ntGWtan1XTpk3Txx9/bDyub9++Dt3ZOnv27Fq4cKFRI7t7KVu2rGbPnq2uXbvq3LlzRmN///33FJswPAjHypkzZ/T6668bfV/g4+Ojzp07q3HjxipdurT8/f0VFxenS5cuaefOnfrpp5905MgRy/MtXbpUxYoVe+B3SJ86dapOnjx535iBAweqUKFCaVRRxpGWr7XY2FjjMZkzZ7Y7X1pITk7WO++8o9KlS1v+fLJ582YtWLDgvjEtW7ZUmzZtHFGiUwwYMMC4AUP9+vXVoUMHVa1aVTlz5pSXl5euX7+ugwcPauXKlVq2bJnlpjiXL1/WK6+8ol9//dWpzQfi4uI0aNAg4+tmb29vffHFF3r00UdTlX/+/PnavHnzfWOee+45ValSJVV5AAAAAAAAAGR8NGEAAAAAAADAA8vPz08jRoxQu3btXF1KqhQoUMB4jKen8776O3funP73v//pxIkTTsuRkvS4SPN+9u/fr379+unSpUsuqyGjPGdeXl5q3bq1WrdurejoaO3YsUObNm3S9u3bdfz4cacs3p89e3aGbMKQO3duo3jT80KePHmM4pH21q1bp8GDB+vmzZsuqyGjnFucwXSBZe7cuVO1U26+fPmM4k3rs5LftH7TBi3pTVxcnFauXGk0xmRBT+vWrTVp0iTL8WvWrNHNmzdTtUjXivR27Xnt2jW9/vrr2rlzp9NyWJGeGgh169bNchOGoKAgDR48+K6LqH777TfLOTt16mQ5VpIGDRqkrl27OrxBUExMjNauXau1a9dq9OjRatmypV5++WWVLVvWoXns9cgjj6hRo0Zat26dw+c+deqUTp06pdmzZyswMFDPPfecunTpwu686cT27dv12muvGTcprFatmqZNm5bqc7tpQ5Jbt27ZncuesY5umGKz2TRmzBh99913xmMHDRqUYqMCU76+vg5pwHBbrly59PHHH6tz585G19tHjhxRTEzMfZsjPQjHyrBhw4wWnVerVk2TJ0/+z2dcLy8vlSxZUiVLltQzzzyjmTNnasKECZbf87/66iu1atVKpUqVslxLRnL06FHNmDHjvjE1a9ZU9+7d06iijCUtX2umTRh8fHxS3RznbovnExMTdevWLUVHRyskJERnzpzRjh07tH79el2/ft04R0JCgoYOHaoFCxak2HwqJiZGw4cPv29M9uzZ9f777xvXkVasNAb4O19fX02YMEFNmzb9z2N58+ZV3rx51axZM73wwgv63//+Z7lR46lTp/TFF1/ojTfesFyLicjISL366qvasWOH0TgfHx9NnTpVdevWTVX+sLAwjRs37r4xRYoU0YABA1KVBwAAAAAAAMCDwf47vQAAAAAAAIB0ysvLS08//bR+++23DN+AQfrrhkpTzloId/bsWXXt2tWlDRgymj179ui5555zaQOGjCpr1qxq3Lixhg0bpqCgIO3YsUOzZs3SgAED1LhxY4ctQt26dWuGXEhuuuu4h4eHUbzpDvZIW7///rteffVVlzZgeNiZLpLJmjVrqvKZjk/NIh5H5JecuzA/LaxevdpoMW3BggWNdsosXry45V1dJSk+Pt5o0by90tO157Vr19StWzeXN2BIb8qUKaPatWtbio2IiLjrIrnk5GTLTUayZs2qVq1aGdVYtWpVvffee0ZjTCUmJmr58uXq2LGjxo8fb3mHX2ebMGGCSpYs6dQcwcHBGjVqlB5//HEdOnTIqbmQspUrV6pXr17GDRjq16+vmTNnOuRzTc6cOY3iTWv9O9PrT09PT2XPnt3ufP+WkJCgwYMHGzdgcHd31wcffODwBgzOUqlSJbVs2dJoTGJioo4fP37fmIx+rGzZskW7du2yPGfx4sU1Y8YMS00GX3zxRfXr18/y3AkJCZo2bZrl+Izm66+/VkJCwj0fz5w5s0aPHp3i4viHVXp+rZnWZpWnp6f8/PyUL18+1axZU507d9b48eO1YcMGjRw50riZqCQdPHhQmzZtSjEuKCgoxSYDQ4cOVa5cuYxrSAvJycn68ssvLce7u7vrs88+u2sDhn8rV66cpk+fbvQ94uzZs1N1TN7L5cuX1a1bN+MGDNmzZ9e3336b6gYMkjRnzpz7/m5ubm766KOPlDlz5lTnAgAAAAAAAJDx0YQBAAAAAAAAD4ySJUuqX79+Wr16tUaOHJlub6o0ZbrQWpJTboCOi4tT3759dfXqVYfP/aAKDw9Xv379FBMT4+pSHgi+vr6qW7euXn31VX399dfatm2bFixYoH79+qVq58nr169nyMYizr4Z+GG52TgjNuA4ffq03nrrLYfvLg4z8fHxRvGpfU2ZjjetLyXp5XokLS1evNgo3nSRuiS1adPGKD4oKMg4hyl7mvA4429ts9k0ePBgnTlzxuFzPwh69OhhOfbnn3/+z892796ty5cvWxrfpk0bu46LZ555Rh9++GGqd1pOSVJSkr755pt0s7Oxv7+/vv32W1WvXt3puc6ePavnnntOx44dc3ou3N2PP/6oAQMGGL/vtmvXTl999ZVd7693kzdvXqP4Gzdu2J3LdGzu3Lkd9j4RHR2tV155RUuXLjUa5+3trU8//VTPPvusQ+pIKy1atDAeExISct/HM/qxMm/ePKM533nnHaMGU3369FHBggUtx//222+KiIgwqimjiIuLu+/jr7/+uooWLZo2xWRApq+11BxHpq8109pS63bD5F9++UXly5c3Hm/ldZ/S8dq4cWM98cQTxrnTyoYNG1JsIvF3rVu3VoMGDSzHlyhRQj179rQcHxMTY/x5OCVnzpzRM888Y3zdmi9fPs2dO1dVq1Z1SB0pHStdu3ZVzZo1HZILAAAAAAAAQMaXsbefAQAAAAAAwEPFw8ND3t7eypo1q3LmzKn8+fOrePHiKlu2rGrXrq38+fO7ukSnsGexgru74/uvfvvttxlyoborffrpp7py5Yqry3hgubu7q1KlSqpUqZL69u2rLVu2aNy4cTpy5IjxXGfOnFHp0qWdUKXzOHtxc0ZcPJ2cnGw8JiM2SRk1apRu3brl6jIeet7e3kbxsbGxqcpnOt60vpSkl+uRtBIeHq4NGzYYjZk5c6ZmzpzppIr+smvXLoWEhKhQoUJOy5Fe/tZLly7V5s2bHT7vg6JZs2YqUKCALly4kGLstm3bFBwcrMDAwDs/W7FiheVcHTt2tKtGSerSpYvq1aunyZMna/ny5UpMTLR7rpQsWLBAZcqUMVpg5ix58uTR3LlztWjRIn311Vc6f/6803JFRkaqT58+WrFihcMW9MOaKVOm6PPPPzce9/zzz2vIkCEOvd4uVqyYUXxCQoLCw8MVEBBgnMtqA5fbTGu7l/DwcPXp00cHDhwwGufn56epU6eqdu3aDqkjLdmz4DSlxpkZ+Vix2WxG1wb58uVTw4YNjWrw9PRUhw4d9MUXX1iKj4+P186dO9W8eXOjPA+C8ePHa/z48U7NsX37dpUpU+aujz355JMaO3asU/OnhmmDitR8f+iq87KpvHnzasqUKXriiScUGRlpedy2bdtks9lS9b65du3aex5LjnSvHAULFtSff/55z3GbNm0yytO5c2ejeEl66qmn9NVXX1mO37x5s7p162ac527279+vl19+WeHh4UbjSpcurenTpytfvnwOqcOKuXPnau7cuU7NERoaes9jpXbt2pozZ45T8wMAAAAAAACwjiYMAAAAAAAASBfS+42zD7v4+HjNmjXLeFzp0qXVvn17Va9eXUWKFJGvr+89d/Lu0aOHtm/fnspK049r165p0aJFxuOqVaumxx57TJUqVVJgYKB8fX3vuZC2adOmRrukPejq1q2r+fPn65VXXtHGjRuNxqZmd0+kH/Ys7IyKinJCJc5z+PBh45vzJalBgwZq1aqVypcvr4IFCypr1qzy8vK6a2xaLEx4EJjuCh8dHZ2qfKbj7dm1Hv9n2bJlTl0sbi+bzabFixfrtddec3UpTjd9+nTjMYGBgXriiSdUu3ZtFS1aVNmyZbvna2HIkCF2XaulFx4eHnr22Wf18ccfpxhrs9k0f/58DRw4UNJfTYtWrlxpKU/RokVVo0aNVNUaGBioCRMm6K233tLSpUu1atUq7d271ymvsalTp6pTp07KmjWrw+c25e7urk6dOunJJ5/Uli1btGLFCq1du9YpTdouXbqk77//Xn369HH43Piv5ORkjRgxQj/99JPRODc3N7311lt68cUXHV5T8eLFjcdcuHDBroX1ly5dMoq3p7Z/CwkJUa9evXT27FmjcXnz5tX06dMz7PWtPX+flBp3ZeRj5cyZM0af3atXr26U/7Zq1aoZxe/bt++hbMKA+zN9rcXExOj69evKkSOHcS5XnJftVbBgQT355JOaPXu25TE3btzQmTNnXFq3s+3bt89yrLu7u/F5Svrrmjx37tyWr0VNarqfjRs3ql+/fsZNUGvXrq0vvvhC2bJlc0gdAAAAAAAAAGAPmjAAAAAAAAAASNHmzZt1/fp1y/EeHh4aOnSounXrZnmXsoSEBHvLS5d+++03o98pS5YsGjt2rFq3bm15zIP2nDmCl5eXPvroIzVt2tRoYV9ERITzikKaiY+PNx5juljB1ZYsWWIUnyNHDk2ePNnyzr+cV6zLlSuXUfyVK1eUnJwsd3d3u/KZHqu5c+e2Kw/+EhQU5OoS7ikoKOiBb8Jw4sQJHTt2zGjMK6+8or59+96zwcy/PQjnu6eeekpTpkxRXFxcirELFy7U66+/Lk9PT+3atcvy4qtOnTqltsw7cufOrRdeeEEvvPCCYmJitG/fPh06dEjHjx/X2bNndf78eaPPHHdz/fp1LV68WM8++6yDqk49d3d31a9fX/Xr15f01yLi/fv368iRIzp16pTOnz+v0NDQVB+Ts2fPpglDGoiPj9fgwYMtNzK5zcvLS2PHjtVjjz3mlLoCAgKUP39+Xbx40fKYc+fOqWLFisa5zpw5YxRvT46/O3r0qF566SXjBiYlS5bUjBkzlD9//lTld6XU7Pp+Lxn5WDGpWfqrCYc9TK+jTevCw6FMmTLy8vIyen8/d+6ccROG5ORk4wY1qT0vp1bjxo2NmjBIUlhY2APdhOHChQuWY+/XaC4lJk0Yrly5osTERHl62n+L8ZIlS/TOO+8YX+e2bt1aEyZMuGdjYgAAAAAAAABIKzRhAAAAAAAAAJCibdu2GcW//PLL6t69u9GY1C64Sm9Mn7Phw4cbNWCQHrznzFHy5s2rSpUqac+ePZbH2Gw2J1YEe5kuOrp165ZxjqNHjxqPcSXTc8unn35quQGDxHnFRMGCBY3iY2Njdf78eRUtWtSufCdOnDCKL1CggF15IJ0+fVoHDhxwdRn3dPbsWe3fv1+VK1d2dSlOY3que+KJJ/TGG28YjXkQGjAFBASoXbt2WrhwYYqxV65c0dq1a9W8eXOtWLHC0vweHh564oknUlvmXfn4+Khu3bqqW7fuP34eFRWlkJAQnT59WkeOHNGOHTu0d+9eo2u1LVu2pKsmDP9WrFgxFStW7B/PbXJyssLCwnT27FmdOnVK+/bt04YNG4zel69cuaLjx4+rdOnSzij7vjp27KiOHTumed60FhkZqddee03bt283Gufr66spU6b853h3tBo1amjp0qWW448ePap27doZ5YiKitL58+eNxlSvXt0o/u927NihV199VZGRkUbjatasqalTp8rf39/u3OnBtWvXjMf4+PikGJNRj5UbN24YzZcpUyaj+NsyZ85sFG9aFx4OmTJlUsWKFY2+mzp69KiqVq1qlOf06dNGDSm9vLxc/jkiX758xmMehGv3+7l586bl2NQ0JjA9L964cUM5c+a0K9esWbM0duxY4+9ce/TooaFDh9rdwBIAAAAAAAAAHIlvKgEAAAAAAACkyGThp5ubm3r06GE0f3R0tEJDQ03LStdMnjN/f3/jBW5nzpzJkDs4Jycnp0ke0x0vTRdZIG1YWUD0dyY3rd+2c+dO4zGuYrPZdPr0acvxpUuXNl7sd/z4cdOyHloBAQHGu+Tu3bvXrlxhYWHGO+yWKVPGrlyQgoKCXF1CijJCjalh2nSkZ8+exjmOHTtmPCY9Mrnunj9/vpKTk/X7779biq9fv77du4jby9fXV2XLllXbtm01aNAg/fTTT1q+fLnKly9veY7du3c7sULncHd3V/78+VW3bl11795dEyZM0IYNGzRkyBCjplQZ8XfPKC5fvqzu3bsbN2DInTu35s6d6/QGDJJUp04do3h7jpf9+/cbfabLly+fihQpYpxHkv744w+9+OKLxg0YWrVqpZkzZ2b4BgySfdeOuXLlSjEmox4riYmJRjXY2xzB9HNlUlKSXXnw4HvkkUeM4u15rZk0eZCkSpUqufw7sOjoaOMxpq//jMbk97Pnuy97x9r7vE+cOFFjxowxasDg5uamwYMHa/jw4TRgAAAAAAAAAJBu8G0lAAAAAAAAgBSFhYVZjg0ICFBAQIDR/Js2bXJqQwEPDw+jeEfc2GvynBUpUkReXl5G869du9awovTh+++/13vvvWe8mNiU6Q55pgupkTZ8fX2N4k1ed5IUGhpqvGDBlW7cuKFbt25Zji9RooRxDmefW0xvpE/vC5oqVapkFP/bb7/ZlcfqrvW3Zc2aVcWLF7cr18POZrNpyZIlri4jRcuWLcuQzZisMj2flyxZ0ij+0KFDunLlitGY9Kp8+fKWd5nfsGGDli1bZvl379ixY2pKc5jixYtr0qRJlpsRXLt2Lc0afzmTl5eXXnjhBbVv397ymAfluE5vzp49q2effVZHjx41Gle8eHHNmzdPZcuWdVJl/9S0aVOja629e/caL1Jft26dUXyLFi2M4m+bN2+e+vfvb7S7uyR169ZNn332mfFO3/ZKTk526sLglStXGo+x0vQiox4rWbJkMZrz5MmTRvG3mTaDMq0LD4/mzZsbxW/cuNH4M7Dpa61ly5ZG8c5gz2sza9asTqgk/TBpjBEbG6vg4GDjHHFxcTp//rzRGNPmqImJiXrnnXc0ffp0o3FeXl4aN26cevfubTQOAAAAAAAAAJyNJgwAAAAAAAAAUhQbG2s51p4FCNOmTTMeY8K0wUF4eHiqczrzOYuPj9esWbMMK0ofEhISNG/ePLVs2VLDhg3TqVOnHJ4jMjLSeMfQggULOrwOpJ6Xl5fRjegnTpwwWnT57bffGu3K52om5xXJ/Nxy7do1LViwwGiMKW9vb6P4a9euOakSx3j00UeN4jdu3KizZ88ajUlMTNRPP/1kNKZ+/frsHGmnnTt3KjQ01NVlpOj69evasGGDq8twGmef777++muj+PSuR48eluKSkpI0YsQIS7HZs2dXs2bNUlOWQxUuXFg5c+a0FJucnGz37ufpUbVq1SzHmjYiQ8oOHDigZ599ViEhIUbjqlWrph9//DFNP2fkzJlTNWvWtByfmJioX3/91XJ8fHy8li5dalRTq1atjOIlacqUKXrvvfeMFyIPHDhQ7733XppeA0VFRal9+/bGi6Ct2L9/v1atWmU0JnPmzCpdunSKcRn1WDFtnrhv3z67zoum11h58uQxzoGHQ6VKlVSoUCHL8deuXdOaNWuM4k0aKbq5uVlqwuDs70kWLVpkPKZAgQJOqCT9MD2/rV+/3jjH1q1bjRr5+fj4yM/Pz3L8rVu31LdvXy1cuNCorqxZs+rrr7/WE088YTQOAAAAAAAAANICd18BAAAAAAAASJHJrn43btwwWlg/Y8YMHThwwJ6yLMuWLZtR/M6dO1Od0+Q5O3HihCIjIy3HjxkzRpcuXbKnrHQjPj5eCxYsULt27dSrVy/99ttvDtvRe8yYMUaLNz09PS0tVIFr5MuXz3JsZGSktm/fbin26NGj+vHHH+0tyyVMd1jdu3ev5aYUNptNw4YN061bt+wpzTKTG/glaceOHU6qxDGaN29utNAvISFBY8eONcrx/fff68yZM8Z1wT5BQUGuLsGyjFSrKdPz3e7duy3Hrlixwq6dxdOzFi1aWF4AavWa87HHHjNunHPb9u3b9eWXX+rq1at2jb+b+Ph4o+vl+Ph4h+U2MX78eG3cuNGhixdNGhLFxcU5LC+kTZs2qWfPnsZN+po1a6ZZs2Ype/bszinsPp599lmj+C+//NJy05Lp06cbva5LlSqlWrVqWY5PTk7WBx98oM8//9zyGOn/ds9++eWXjcY5yqlTp9SnTx9169ZNW7Zsccicly9f1sCBA43PJTVr1rTchDIjHitFixa1PKf013vBt99+azTmzJkz+uOPP4zGmNaFh0uXLl2M4j/55BPL3499/PHHRt+lNWzY0FJzoGPHjql79+5atWqVUaNLK3766SfL39vc5uXl9cC/zkx/v1mzZhld99lsNs2YMcMoR5EiRSzHRkRE6IUXXjBqIiL91Xzi+++/V/369Y3GAQAAAAAAAEBaoQkDAAAAAAAAgBRZ3XX2ts8++8zSYoEFCxbok08+sbcsy7y9vY0WwJw+fVrTpk1L1eIpk+csISFBU6ZMsRQ7ZcoU/fDDD/aWle7YbDZt3LhR/fv316OPPqp33nlHa9asUXR0tPFc165d06BBg/TLL78YjStfvrzxYk+knQoVKhjFjx49OsVGAhcuXFCfPn2Md053NX9/f8uLqiTpypUr+v7771OMS0xM1HvvvWd8s7w9THeJ/fXXX7V161YnVZN6efPmVZMmTYzGrFmzRhMnTrQUu379esuxt2XPnl2tW7c2GoO/xMXF6bfffnN1GZatWbPGaFF6RmJ67fnFF19YWnS/bt06DR061N6y0i0vLy8988wzDp2zY8eOdo8NDw/XZ599psaNG2vgwIHasGFDqpsizJ0712ihma+vb6ry2Wv9+vXq1auXWrdurZkzZyo4ODhV8924ccPo2ta02RHubdmyZXr55ZcVExNjNK5Lly76/PPPlTlzZidVdn8tW7Y0amJ2/fp1vfvuuyleF+/evVvTpk0zqqV79+6WY+Pj4zVgwADjJmk+Pj768ssv1aFDB6NxzrBz5049//zz6tixoxYtWmR3c7MjR46oZ8+edp0/2rVrZzk2Ix4r2bNnN16oPH36dK1bt85S7M2bN/XGG28Yf06sVq2aUTweLp07dzb6zunUqVOaMGFCinG///67Fi5caFRLjx49LMXZbDbt2LFD//vf/9SqVSt98803qb6mSU5O1owZMzRixAjjsVWrVnXZ+2paMT2PnD9/XsOHD1dSUpKl+ClTphg3v7Ba08WLF9WtWzft2bPHaP6iRYvqxx9/VPny5Y3GAQAAAAAAAEBa8nR1AQAAAAAAAADSv0KFChnF//7773rzzTc1dOhQBQQE/OfxsLAwffbZZ8Y3C6dGsWLFjG4G/fjjj/XTTz+pRo0ayp8/vzJlyiQ3N7f/xJUvX16NGzf+z88LFSqkc+fOWc43a9Ysubm5qV+/fsqaNet/Hr99E3ZaLJJ2lYiICC1cuFALFy6Ul5eXKlWqpIoVK6pcuXIqXLiw8ufPL39/f2XJkkVJSUmKiYnRpUuXdPz4cW3cuFF//PGH8SIp6a/do5F+VahQQcuWLbMcf/z4cb344ouaOHHif3Z4TEpK0vLlyzVq1ChFREQ4uNK0UbBgQZ09e9Zy/NixYxUfH6+ePXvedUfz/fv3a8yYMUa7yKdG0aJF5e7ubnk3zbi4OD333HOqUKGCKlasqBw5cihTpkx3jW3evLlKly7tyHIt6dWrl1avXm00Zvr06Tp16pSGDh2qwMDA/zweHR2tGTNmaNq0acaLwLp3737P5wj39+effxo1NfDw8ND69euVK1cuh+SPjY1V3bp1Lb+X3W4a0blzZ4fkT09Mrz337t2rV155RaNGjVKBAgX+83hERIS+/vprfffdd5YXKmU0Xbp00Zdffmm0G/K9lClTxrgJ0t0kJCRo2bJlWrZsmXx8fFSnTh01atRIlStXVvHixS0tpgsPD9fMmTM1c+ZMy3kDAgLuej2dls6ePatx48Zp3LhxKlGihBo1aqQ6deqoTJkylhc9b968WaNHj9aFCxcs5zV97eDeTHcXv23evHmaN2+eQ2sZM2aM5cYonp6e6tu3r4YPH255/pUrV+rVV1/Vu+++q8KFC//jscTERC1ZskQjRoxQbGys5TmLFCmiTp06WY7fs2ePVq5caTn+tpiYGL300kvG41Jy7Ngxu8ceOnRIQ4YM0YcffqjmzZurSZMmqlOnzl2/G/m7U6dO6fvvv9f8+fPtOvYCAgKMGnFl1GOlcePGmjVrluX4pKQkvfrqq3r55Zf1/PPPy9/f/65x69at0+jRo42+x5H+2sXd9D0zNDRUQUFBlmJDQkKM5j527JimTp1qKbZAgQL3bWBidR4TISEhatasmeX42rVra86cOQ6vIy3lyJFDzz33nL766ivLY7777jvduHFDgwcPVu7cuf/xWGxsrH744QdNnDjRqHlsrVq11KBBA8vxt50/f17jx4/X+PHjVaFCBbVo0UI1atRQ+fLlLTW9Cg8P1+rVqzVr1iydPHnSOL8ktWnTJsWY559/Xs8//7xd899P06ZNFRoaajne3vePRo0aGTcqXrx4scLCwvT222/f8zwUEhKizz77TEuWLDGu6W7fd9/NggUL7Prbnj17Vs2bNzcedz9WzhnDhg3TsGHDHJpX+uszlFUFCxbUn3/+6fAaAAAAAAAAADgeTRgAAAAAAAAApKhevXr6+eefjcYsWbJEK1euVJ06dVSyZEn5+PgoIiJCR44c0d69e9N8AVzlypWNd+QKDQ1N8Ubbp5566q43pdarV0+bNm0yyvftt9/q559/Vt26dVWsWDF5e3vr2rVrOnDggA4dOmQ0V0aXkJCg3bt3O31huLe3d7rYNRX3VqdOHeMxu3fvVsuWLVWvXj2VLFlSnp6eunjxorZs2aKrV686ocq0U69ePaMmDElJSZowYYJmzJihunXrKjAwUO7u7rp27Zp27dqlU6dOOa/Yu8iUKZPKlCmjI0eOGI07dOhQiufBggULuqQJQ40aNdSqVSvjhYN//vmn1qxZoypVqqhMmTLKmTOnoqKiFBwcrM2bNxvt+H5b7ty59eKLLxqPw1+sLoa7rXbt2g5rwCBJmTNnVtOmTbV06VLLY4KCgh7IJgz16tXTp59+ajRm06ZNat68uWrWrKmyZcvKz89PN2/e1KlTp7R9+3aHNCdIz3LlyqU2bdpo8eLFqZ7L6mJvEzExMfrzzz/vLDZyd3dXYGCgihUrJn9/f/n6+srX11fe3t6Ki4vT1atXdfLkSR06dMj4c0OVKlUcXn9qnDp1SqdOnbrTSMLX11elSpVS3rx55efnJ19fX2XNmlXJycmKiopSSEiI9u/fb9c1S9WqVR1cPTKijh07as6cOUYLQdevX69WrVqpTp06KlasmPz8/BQaGqpdu3YZNQK5bfDgwfLy8jIe9yCJiYnR4sWL75yXAwMDVbJkSRUqVEi+vr5yd3fXzZs3deXKFe3bt08XL15MVb6XX35ZPj4+RmMy4rHy5JNPGjVhkP76TDR16lTNnDlTVatWValSpeTv76/Y2FiFhYXZXbskPf744/Lw8DAaExISokmTJtmVLyWHDx/W4cOHLcXWrl2b70PSSO/evfXLL7/oypUrlsf8+uuvWr58uerVq6fChQsrU6ZMCg0N1datWxUeHm6U393dXW+99ZZp2f/x98/lbm5uKlKkiIoXL67s2bMrW7Zs8vPzU3x8vGJiYhQWFqZTp07pzJkzlpsw3o2/v7+eeOKJVNee3pUtW1YVKlQw/v5327Zt6tixo0qWLKkqVaooV65c8vDwUEREhA4dOqSDBw/a9R187ty5Vb9+feNxAAAAAAAAAPCgoQkDAAAAAAAAgBTVr19fXl5exovX4uPjtX79eq1fv95JlVnXoEEDfffdd2mWr3HjxpowYYLxuOjoaK1atcoJFeFunnrqKeXJk8fVZeA+KlSooLJly+ro0aNG4xITE9PN+ceRGjdurB9++MF43PXr17V8+XInVGSuQYMGxk0Y0rthw4Zp+/btun79utE4m82mvXv3au/evQ6p48MPP3T57u8ZVXh4uDZu3Gg0pl27dg6vo23btkZNGHbu3KnQ0FAVLFjQ4bW4UqVKlZQ7d26jhWrSX4sst23bpm3btjmpsvStR48eqW7C4OXlpfbt2zuoontLTk7WuXPnjHcct6JFixYOn9ORoqKijJvDWVGwYEGVL1/e4fMi4/Hw8NC4cePUuXNno8/wycnJ2rx5szZv3pyq/O3atVPLli1TNceDKDg4WMHBwU6Zu0KFCurevbvxuIx4rJQtW1ZNmza1awfx2NhYbd26VVu3bjUeezeZM2fWCy+84JC58GDz9fXV6NGj1adPH6Nx8fHxWrt2barzv/TSS6pcuXKq5/k7m82ms2fPGjWJtEf//v3l6+vr1Bzpxauvvqq+ffvaNfbkyZM6efKkw2rp3bu3PD25tRgAAAAAAAAA3F1dAAAAAAAAAID0L1u2bHrmmWecNn+hQoWcvmCobt26ypcvn1Nz/F3JkiXVpEkTp81fpUoV5c2b12nzPwxy5cqlAQMGuLoMWPAg7vJur4YNG6ps2bJOmz8tFsx16NBBbm5uTs+TlvLmzavx48e7dJHCiy++qKZNm7osf0a3fPlyo8WHXl5eTlno3aBBA/n5+VmOt9lsqV50nx65ubmpV69eTps/W7ZsqlOnjtPmd5XKlSuneoFd48aNFRAQ4KCK0l7u3LnVtm1bV5fhEj179nzg3l9hv3LlymnIkCFpnrdo0aJ6//330zzvwyx79uz69NNP7b4OzYjHytChQ+Xj4+Pgisy9/vrrNHWEZY0aNdKLL76Y5nmrVaumfv36pXleR2jUqJG6du3q6jLSTIsWLdSoUSNXl6Hy5cs/VM87AAAAAAAAANwPTRgAAAAAAAAAWPLqq686ZecxT09PTZgwwem7mnl6eurVV191ao5/GzhwoFMW5Pr6+mrixInsSJYKXl5emjRpkvz9/V1dCix4+umnVbx4cafM/corrzhlXmdxc3PToEGDnDJ3vnz5NHLkSKfM/XclSpR4IBfINmzYUKNHj3bJAtjHHntMb731VprnfZAEBQUZxderV0/Zs2d3eB3e3t5q3ry50RjT2jOKbt26qWDBgk6Ze8SIEcqfP79T5nY1e3ZC/7uOHTs6qBLXGDJkiLJkyeLqMtJc6dKlWSyH/+jevbteeOGFNMsXEBCg6dOn8xkrDfn5+emrr75SkSJFUjVPRjtWAgMD9dFHH7m08UyzZs3S9DnDg+HNN99Uq1at0ixf0aJF9eWXX8rb2zvNcjpKlSpV9PHHHz90DabGjBmjwMBAl+XPnj27PvnkE3l5ebmsBgAAAAAAAABIT2jCAAAAAAAAAMCSnDlz6uOPP5a7u2O/Vhw1apSqV6/u0DnvpUuXLmrQoEGa5JL+Wgw1fPhwh87p5eWlzz//XIULF3bovA8Tb29vTZo0STVr1nR1KbDI29tbH330kUPPP25ubnrnnXfUuXNnh82ZVho2bKjevXs7dE4/Pz9NmzbNKYvK72bYsGEP5ALoDh066LPPPlOmTJnSLGe3bt00YcKEh25xiiOdOXNG+/fvNxrjzEYibdq0MYq3p/6MwNvbW5MnT3b4gvp+/fo9kI1gbmvTpo1y5cpl19jcuXOrYcOGDq4o7Tz//PN67LHHXF1GmsuVK5c+//zzDLnAEs739ttvO/y68W4KFiyo77//ns+paahAgQKaPXu2qlWr5pD5Mtqx0qZNG40cOVIeHh4Oqsy6hg0bOuX7MTz43N3d9fHHH6t9+/ZOz1W2bFnNmTNHOXLkcHouR2vatKlmzpwpPz8/V5eS5nLmzKmZM2e65P00R44cmj59uooVK5bmuQEAAAAAAAAgveL/BgEAAAAAAACwrHHjxnr33XcdcqO5u7u73nvvPT355JMOqMwaNzc3ff7553riiSfSLOezzz6rPn36OGSuTJky6bPPPlO9evUcMp8rlCpVKtW7dKZGYGCg5s6dq2bNmrmsBtinWrVq+vDDDx2yyCZTpkyaMGGCnn/++dQX5iKDBg1y2ELT7Nmza9q0aSpTpoxD5rMiZ86cmjNnjipWrJhmOdNK69at9fPPP6t06dJOzePr66uxY8fqvffeYwFYKgUFBRnFe3t7q3nz5k6qRqpXr55xQ5TFixc7pxgXq1ixoiZOnOiwxeV9+vRR3759HTJXeuXt7a2nn37arrHt27eXp6engytyPjc3N/Xt21fvvPOOq0tJc8WKFdOcOXNUtGhRV5eCdMrNzU2DBw/WmDFjlDVrVqfkqFevnn766SeVKFHCKfOnZx4eHvLx8UnzvK1bt9aiRYtUvnx5h82ZEY+Vzp0765tvvlHevHkdMl9K3N3d1bt3b3355ZcObxKFh4eXl5fGjx+vQYMGycvLyyk52rVrp7lz5ypPnjxOmd9ZsmXLpvfff19Tp06Vr6+vq8txmcKFC2vevHlq0qRJmuWsWrWq5s+fr8qVK6dZTgAAAAAAAADICLgjCwAAAAAAAICRrl276uuvv07Vbuk5c+bU1KlT1a1bN8cVZlGWLFk0fvx4ffrpp2m2+HfQoEEaN26cMmfObPccgYGBmj17tlMXfaaFhg0b6vfff1dQUJD+97//qVSpUmmS19fXV/369dOSJUu4oTgD69y5sz755JNULXgpU6aMFixYoMcff9yBlaU9Nzc3ffzxxxo0aFCqGlOUL19eP/74o6pXr+7A6qwJDAzUjz/+qEGDBqlAgQJpnt+ZypYtq19++UVvv/12qt4v78bDw0OdOnXS8uXL07SR0YPKZrMZNzBo2LChUxcFeXl5qUWLFkZjli1bpsTERCdV5FrNmzfXDz/8oIIFC9o9h4+Pj0aPHq1BgwY5sLL065lnnrGrmUKnTp0ckr9YsWKqX7++MmXK5JD57qdcuXL6/vvv1a9fP6fnsqJFixYKDAx0ep5MmTLppZde0sKFC1W8eHGn50PG17FjRwUFBTn082SuXLn0wQcfaObMmRluoa+jZM2aVZs3b9bEiRPVuHFjpy2ovq1atWr69ttvNWnSJIdfY96W0Y6VunXraunSperdu7dTGyM88sgj+vnnnzV48OAM2bAI6Yubm5v69Omj+fPnq3bt2g6bNzAwUJMmTdInn3ySqs8r/v7+Kl++vNzc3BxWW0r5XnnlFa1cuVJdu3ZNs7zpWUBAgL766it99tlnKlasmNPy5M6dWx988IF++OGHNLmGBQAAAAAAAICMhv8rBAAAAAAAAMBYw4YNtXTpUk2fPl0///yzbt26ZWlclixZ1LlzZ7366qsKCAj4x2NeXl4O2+XYirZt26pt27Y6cuSItm3bpgMHDujEiRO6ceOGoqKiFBMTo+TkZIfl69Chg6pXr64vv/xSixcvtrxQMnv27OrWrZteeuml/+ywafKcOXsxiKmyZcuqbNmyev311xUaGqqdO3dq165d2rNnj06cOCGbzZbqHB4eHqpevbratGmjJ5544qHeRe9B0rp1a1WrVk2fffaZfv31V8uv0yJFiqhXr1566qmnUtW0IL3p06ePGjRooC+++EKrVq2y/NrJmzevXnzxRXXv3v0/i4hMzsWpPbd4e3urT58+6tWrl7Zu3ao9e/bo4MGDOnfunCIjIxUdHa2YmJhU5XAVb29vvfjii3rmmWe0dOlSLVy4UPv27bP7vaVQoUJ67LHH9PTTT6dqMTr+adeuXQoNDTUa065dOydV83/atm2r+fPnW44PDw/X+vXr1bRpUydW5TqVKlVSUFCQvvvuO82ePVs3btywNM7Ly0uPPfaY+vXr95/Xjaenp9H5LiMtBsubN69atmyp5cuXWx5TpUoVh+1MXqZMGc2cOVNxcXHasWOHNm/erH379unw4cMOOadnyZJFDRs2VKdOndSoUSMHVOw4/fv3V//+/RUcHKwNGzZox44dOnjwoIKDgx1yfVuiRIk77wW5cuVyQMV4mAQGBuqLL77QgQMH9MMPP+i3336z6zVZpkwZderUSZ07d/7PZ9SHUZYsWfT444/r8ccf1/Xr17Vx40Zt375d27dv19mzZ1M9f86cOdWiRQt16NBB1apVS33BFmS0YyVbtmwaPHiw+vTpo0WLFmnFihWpuu6+LU+ePGrWrJk6d+6sChUqOKha4P+UK1dOc+bM0ZYtW/Tjjz/qzz//VEJCgvE81apVU+fOndW+fXuHfP9XoEABLVq0SFevXtWGDRu0adMm7d+/X+fPn3fI9Ywk5ciRQ/Xq1VOLFi3UrFmzNP1OOCNp06aNWrdurfXr1ysoKEjr1q1TVFRUqub09vZW3bp19fjjj6tVq1Y89wAAAAAAAABwH242R30zDgAAAAAAAOChdP36dW3YsEFbtmzR4cOHde3aNUVERMjNzU2+vr4qUKCASpcurXr16qlRo0bKli2bq0t2ubCwMK1fv15btmzRiRMnFB4erhs3bsjDw0O+vr4KDAxUmTJl9Oijj+rRRx916m6O6dHNmzd14sQJBQcH69y5czp//rxCQ0MVGRmpmJgYxcTEKDo6WklJSfL09FTmzJmVPXt25cyZU4UKFVKxYsVUqVIlVatWTX5+fq7+deBEly9f1oYNG7RhwwadOXNG4eHhun79utzd3ZUtWzYVK1ZMFStWVOPGjVW7du0MtYDWHufOnbtzPj59+rSuX7+uyMhIeXt7y9fXV0WLFlXZsmXVsGFD1alTJ901Z3kYhIeHa+vWrTp48KBOnjypixcv6sqVK7p165bi4+Pl4eFx55yWP39+FS1aVOXLl1fNmjVVqlQpV5cPpAtRUVHatGmTtmzZov3799+59kxKSlLWrFmVL18+lSpVSo888oiaNGny0C5U37Vrl7p27Wo5fsSIEXrmmWecWJGUnJysM2fO6PDhw3eu70JDQxUWFqaYmBjdunVLt27dunON5+PjI39/f+XOnVuBgYEqVaqUKlWqpKpVq2a4xWI3b97UoUOHdPLkyTu/d2hoqCIiIu783rGxsfLw8JC3t7f8/PyUI0cOFShQ4M57QfXq1WnCA4e6deuWdu7cqZ07d+rYsWM6f/68rl27ppiYGCUlJSlz5szKmjWrChYsqGLFiqly5cp65JFHVLx4cVeXnmFcvnxZhw8f1tmzZ+98tr18+bKio6PvNBtLTEyUt7e3smTJooCAAOXJk0fFihVT6dKlVb16dZUuXdrln2My4rFy/fp17d27VwcPHtTZs2cVEhJy55ohLi5OCQkJ8vDwkJeXl3x9fZUjRw7lzZtXRYsWVZkyZVS1alWVLFnS5c89Hi43b97U9u3btWvXLp08eVLnz5/X9evX7zSKzZIli/z8/BQYGKiiRYuqWrVqqlOnjgoUKJAm9UVGRurgwYM6fvy4QkNDdfHiRV24cEHXr1+/cy0TGxsrNzc3eXl5KXPmzPL391eOHDmUL18+FS5cWCVKlFClSpVUrFgxubu7p0ndD5KEhAQdOXJEe/fuvXOMXLlyReHh4YqJiVFCQoJsNpu8vLyUJUuWO9+XFi5cWMWLF1flypVVpUqVh+67ZgAAAAAAAACwF00YAAAAAAAAAAAAAAB4wLRs2VLnzp1LMS5z5szauHEjzasAAAAAAAAAAAAAAAD+P9oJAwAAAAAAAAAAAADwAImMjNSFCxcsxTZv3pwGDAAAAAAAAAAAAAAAAH9DEwYAAAAAAAAAAAAAAB4gK1asUEJCgqXYTp06ObkaAAAAAAAAAAAAAACAjIUmDAAAAAAAAAAAAAAAPCDi4+P1zTffWIotUqSI6tat6+SKAAAAAAAAAAAAAAAAMhaaMAAAAAAAAAAAAAAA8ACw2WwaNWqUzp49aym+a9eucnNzc25RAAAAAAAAAAAAAAAAGYybzWazuboIAAAAAAAAAAAAAABgxmazKTY2VmFhYdq7d69++ukn7dmzx9JYHx8frV+/Xn5+fk6uEgAAAAAAAAAAAAAAIGPxdHUBAAAAAAAAAAAAAAAgZSEhIWrWrJlD5nrxxRdpwAAAAAAAAAAAAAAAAHAX7q4uAAAAAAAAAAAAAAAApJ2cOXPqxRdfdHUZAAAAAAAAAAAAAAAA6RJNGAAAAAAAAAAAAAAAeIi88847ypo1q6vLAAAAAAAAAAAAAAAASJc8XV0AAAAAAAAAAAAAAABIGx06dNDjjz/u6jIAAAAcYuHChXrnnXdcXYaOHTvm6hIAAAAAAAAAAIADubu6AAAAAAAAAAAAAAAA4Hx16tTRBx984OoyAAAAAAAAAAAAAAAA0jWaMAAAAAAAAAAAAAAA8IBr1aqVvv76a2XJksXVpQAAAAAAAAAAAAAAAKRrnq4uAAAAAAAAAAAAAAAAOEexYsX0+uuvq23btq4uBQAAAAAAAAAAAAAAIEOgCQMAAAAAAAAAAAAAABmcm5ubfHx8lC1bNhUuXFhVqlRRgwYNVLt2bVeXBgAAAAAAAAAAAAAAkKHQhAEAAAAAAAAAAAAAgAygUKFCOnbsmKvLAAAAAAAAAAAAAAAAeKC52Ww2m6uLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcDV3VxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHtCEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQDRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEk0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEEwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQRBMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEQTBgAAAAAAAAAAgP/H3p1HW13X++N/nnMYDyCTgALiLE6J4oR101IUyWs5lopaaXUtLVPrXqe618y0W3pNcUhNzXkWVDIKREsZFOcJB8xUkEGZ5+n8/ugX30A557MP+3AYHo+1WqvP/rzer/dr77M/5+y15PPcAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkSZo09gAAAAAAAAAAsL564IEHcs4559RZ161btzz22GNrYCIAAAAAAAAAAGpT2dgDAAAAAAAAAAAAAAAAAAAAAKwNmjT2AAAAAAAAAFCKs88+Ow8++GCh2osvvjhHHHFEodr9998/EyZMKHme6667Lvvtt1/J6z7NWWedlUceeaTkdaeddlq+//3vF6o94YQT8vTTTxeqveWWW7L33nuXPE+S9OzZs3DtG2+8Ua891qR77703559/fklrmjZtmr/+9a9p3759A00FAIwZMyYnnnhiSWuqqqpSWVmZpk2bpnnz5qmurk6rVq3Srl27tG/fPp07d07Xrl2zxRZbZNttt81mm23WQNMDAAAAAAAAayMhDAAAAAAAALAabr/99rKEMEyZMiVDhw4tw0Q0hMGDB5e8ZvHixRkyZEiOP/74BpgIgPoaM2ZMoUCibt26FQ5zYt2ydOnSLF26NIsXL868efMyffr0WuvbtWuXvffeO/369cv++++fli1brqFJ1w5XXnllobrDDz883bt3b+BpAAAAAAAAoOEJYQAAAAAAAIDV8Ne//jXvvfdeevTosVp97r777ixevLhMU1FOH3zwQcaOHVuvtYMGDRLCALCWefrppzNw4MA66/baay8hDCRJZsyYkaFDh2bo0KGprq7OEUccke985zvp0qVLY4+2RhS5XpJ/XDNCGAAAAAAAAFgfVDb2AAAAAAAAALAuW7ZsWe64447V6rF48eLcfffdZZqIchs8eHBqamrqtfbll1/O+PHjyzwRANBY5s2bl9tuuy19+/bNr3/96yxatKixRwIAAAAAAADKTAgDAAAAAAAArKYHHngg8+fPr/f6P/7xj5k6dWoZJ6KcHnroodVaP3jw4DJNAgCsLRYtWpTrr78+hx12WMaNG9fY4wAAAAAAAABlJIQBAAAAAAAAVtPMmTPz8MMP13v97bffXsZpKKfnn38+77777mr1ePjhh1NTU1OegQCAtcr48eNz7LHH5oknnmjsUQAAAAAAAIAyEcIAAAAAAAAAZVDfIIVXXnklzz//fJmnoVwGDRq02j0mTpyY0aNHr/4wAMBaad68efnud7+boUOHNvYoAAAAAAAAQBkIYQAAAAAAAIAyGDduXMaOHVvyuttuu60BpqEcFi1alD/+8Y9l6fXQQw+VpQ8AsHZaunRpzjrrLMFLAAAAAAAAsB5o0tgDAAAAAAAAwPritttuyx577FG4ftq0aRkyZEgDTsTqePzxxzNjxoyy9Bo6dGh++tOfpmXLlmXpBwCUbq+99sqtt966wmNz5szJjBkzMmvWrLz55pt57rnn8swzz+Sdd94puf/ixYtz5plnZtCgQencuXO5xgYAAAAAAADWsMrGHgAAAAAAAADWF8OGDcuUKVMK199zzz1ZtGhRA07E6hg0aFDZes2dOzd//vOfy9YPACiP1q1bp3v37tlxxx1z2GGH5Wc/+1keffTR/P73v89+++1Xcr+PP/445513XgNMCgAAAAAAAKwpTRp7AAAAAAAAAFhfLF68OHfddVd+8IMf1Fm7dOnS3HXXXWtgKupj+vTp+ctf/lKodocddsjrr79eZ93gwYPz5S9/eXVHq9PChQvzzDPP5IUXXsi4ceMyYcKETJkyJfPmzcvChQvTpEmTVFdXp23btunRo0c233zz7Lzzzundu3d69OhR1lkmT56cUaNG5ZVXXsn48ePz4Ycf5uOPP86CBQuydOnStGjRItXV1encuXN69OiRrbfeOr169cpuu+2WNm3alG2OuXPnZtSoUXnxxRfz+uuv58MPP8xHH32U+fPnZ8mSJWnevHnatWuXbt26Zfvtt0/v3r2z7777pnXr1mWbYU16//33M3LkyOWv+6RJkzJjxowsXLgwFRUVadmyZTp37pzNNtssn/nMZ9KnT5/stttuqaxs/O9xGDt2bIYPH56XXnop7777bmbPnp2FCxemadOm6dmzZ+6///6Se86YMSMjR47MSy+9lDfffDMTJ07MtGnTMn/+/CxdujTNmzdPmzZtsskmm6RHjx7Zeeeds/fee2eHHXZogGdYmmnTpuUPf/hD/vrXv+bNN9/MtGnTsmzZsrRt2zbbbrtt9tprrxx66KHp3r17oX5z5szJsGHDMmLEiLz++uuZOnVqFi9enA4dOqRjx47ZZZddsu++++bzn/98mjVr1mDPa01ek+PGjcsbb7yxwmMrH6/KRx99lMGDBxeq/dznPpeNN9645PmS5K233sro0aPzyiuv5N13382kSZMya9asLFy4MFVVVamurk6XLl2yxRZb5DOf+Uw+97nPZccdd6zXXuW0bNmyPPnkkxkxYkReffXVvP/++5k9e3YWL16cFi1aZN99982VV17Z2GPWW58+fdKnT5/8+c9/zjnnnJPZs2cXXvuXv/wlw4cPzwEHHFDyvosWLcq7776bt99+O2+//XYmTpyYKVOmZMqUKct/ly9YsCBLlixJ06ZN06JFi7Rv3z6dO3fO5ptvnp49e6Z3797ZcccdU1FRUfL+Rd/zn2bkyJGZNGlSnXUbb7xxPve5z9VZt2zZskyYMCFvv/123nrrrXzwwQeZMmVKJk+enI8//nj5a7Fo0aJUVVWlWbNmadeuXTbeeOP06NEj22yzTXbdddf07t27QX+nAQAAAAAAsP6pqKmpqWnsIQAAAAAAAKCos88+Ow8++GCh2osvvjhHHHFEodr9998/EyZMqLOuuro68+bNW+X5Tp06ZcSIEWnatGmtfYYOHVprWENFRUWaN2+eBQsW1DnTaaedlu9///t11iXJCSeckKeffrpQ7S233JK99967UO3KevbsWbi26M2wa9Jtt92WCy+8sM669u3bZ+DAgRkwYECdtVVVVXn88cfTuXPncoz4CaNHj84999yT4cOHF3rffJpu3bqlb9++Oeqoo7LddtvVq8e8efMyaNCg3H///XnllVfq1aOysjK9e/fOgQcemK9+9auprq6uV59Ro0bljjvuyIgRI7J48eKS1jZt2jQHHXRQTj755Oy000712j9JHnjggZxzzjl11nXr1i2PPfZYvfeZN29eHnjggdx999158803S17fuXPnHHvssRkwYEDatm1b7zmK/o5Z+ffW6NGjc8kll9QaaNKmTZuMHTu20Bw1NTUZPnx47rzzzowaNSpLly4ttO5fde3aNUcddVSOPfbYdOjQoeT1/1T078u//s2aP39+Bg4cmNtvvz3z58+vdV1VVVWOPPLI/OhHP1rlz27x4sW56aabcsMNN2TmzJl1ztKtW7ecccYZOfTQQ+usLUVjXJNXXnllBg4cWOqoJSv1b+b06dNzzz335N577837779f8n6bb755jj/++Hz1q19NixYtSl7/T/V5fybJH//4x1x22WX5+9//vso122+//Wrd0F/UmDFjcuKJJxaq3WuvvXLrrbeWvMd7772X448/PpMnTy68pmfPnnnooYcK1f71r3/NyJEj89xzz+XVV18t+fr4NJtsskkOPfTQnHDCCenSpUvhdaV8hquv2n4O48aNy/Dhw/Pcc8/lhRdeyJw5c1Z7v1atWqVv37458cQTs/POO692PwAAAAAAANZ/jf81FgAAAAAAALAO6d+/f6qqqlZ5furUqRk6dGidfW677bZaz3/uc59Lx44dS56P8hg0aFChugMPPDC77757Nt100zprly5dWvhmzFK8/PLLOe644/L1r389Q4YMqXcAQ5JMmDAhv//973PvvfeWvHbZsmW57bbb0rdv31xwwQX1DmD4Z6+xY8fm4osvrvUG31V54403csIJJ+Qb3/hG/vSnP9XrZtbFixdnyJAhOfLII3P22WcXunG9sdx777058MADc+GFF9YrgCFJpkyZkt/85jc56KCD6vXzr6+amppcdtll+cY3vlFrAEMpnn322Rx55JE59dRT8+STT9YrgCFJJk6cmCuuuCJ9+/bNtddemyVLlpRlvrq88847Oeyww3LDDTfUGcCQ/ON3yz333JPDDjss48aN+8T5999/P0cffXQuvfTSwu/jCRMm5Ec/+lHOP//8LFu2rOTnsLIN7ZqszZIlS3Ldddelb9++ueyyy+oVwJAkf//733PRRRelf//+GTZsWJmnXLVFixbl7LPPzumnn16v38/rqh49emTgwIFp1qxZ4TVvvPFGRo4cWaj2oosuyo033pgXXnihLAEMSTJp0qRcf/31OfDAA3PllVeusd9hq+uOO+7IFVdckSeffLIsAQxJMnfu3AwePDhHHnlkzjzzzEybNq0sfQEAAAAAAFh/CWEAAAAAAACAEmy66abp27dvrTW33357reffeOONOr8p/oQTTih5Nspj/PjxefnllwvV9u/fPxUVFenXr1+h+nJ+I/iyZcty+eWX52tf+1qeffbZsvWtj0mTJuW4447LhRdemI8//rhRZ7nlllty5JFH1nmNFVVTU5MHH3wwhx12WF599dWy9CyXmTNn5tvf/nbOP//8fPTRR2XpOWPGjJx//vk5/fTTVyvQo6if/vSn+e1vf5uamprV7lVTU5PLL788xx9/fFl/VnPnzs3//d//5ZhjjsmHH35Ytr6fZty4cTn22GPz7rvvlrx24sSJ+cY3vpF33nln+WNvvPFGjjnmmHoHXNx7770577zz6rX2nzaka7IuH374YY455phceumlZbu5fOLEiTn11FPz85//vN6BI0UtWbIkp556ah588MEG3Wdttcsuu+Sss84qaU05/+7X18KFCzNw4MB885vfLNv7bl02ZMiQHH744XnrrbcaexQAAAAAAADWYkIYAAAAAAAAoEQDBgyo9fxzzz1X6w2vt912W63re/TokX333bdes7H6HnrooUJ1HTp0yN57750kOfjggwutefPNN+t9M/S/WrRoUU477bRcc801DX7TbV1ef/31HHXUUXn++ecbdY4kufDCC3PRRReV7VvE/9XEiRNzwgkn5Jlnnil77/qYNGlSjjnmmPzlL39pkP5//OMf881vfjNz585tkP5J8tvf/jb33HNPWXotXbo0Z555Zq655posW7asLD1X9vLLL+erX/1q3n777QbpP3Xq1HzrW9/KjBkz6t1j+vTpOeOMM7Jo0aJMnDgx3/rWt1Y7oOOBBx7In//853qt3ZCuybq88cYbOfroowuH/JTq1ltvzRlnnJElS5Y0SP8k+dnPftZgv3PWFccee2w23njjwvWPPfZYg/5MSvH000/ne9/7XqN/blgbTJo0Kd/85jczefLkxh4FAAAAAACAtZQQBgAAAAAAACjR3nvvne22267WmlUFLcycOTMPP/xwrWuPO+64VFb6T3mNoaampnAIw4EHHpiqqqokya677ppNN9200LpBgwbVd7wk/7jZ/PTTT8/w4cNXq085jB8/Pt/85jczderUxh4l//u//1tnwMnqmjt3br773e822E34RU2fPj3f/OY388477zToPs8991xOP/30Brlh98UXX8wVV1xRtn7nn39+/vCHP5St36pMmTIlJ598ciZNmlT23ldddVVZrqVx48bljjvuyJlnnpkpU6aUYbLkggsuKDlIYUO6Juvy/vvv5+STT27w35VDhw7NBRdc0CC9//SnP+Xuu+9ukN7rkubNm+fEE08sXD9r1qyyhC+Vy5gxY3L99dc39hhrhalTp+acc85p7DEAAAAAAABYS/mXWwAAAAAAAFAPAwYMqPX8I488kpkzZ37i8fvvvz/z589f5bqWLVvmyCOPXO35qJ8xY8Zk4sSJhWr79++//P9XVFSkX79+hdY98sgjq3VT+xVXXJHHHnus3uvLZe7cuTn11FMzffr0xh4ljz76aH73u9+tkb1mz56d008/PQsXLlwj+62spqYmZ599doMHMPzTX//611xzzTUN0rdc3w5/zz335IEHHihLryImTZqUs846q+zhFOV8T/3yl7/M888/X7Z+U6dOzbBhwwrXb0jXZF0WLVqUH/zgB2ssrOaee+5Z7bCfTzNixIiy91xX7bfffiXVv/jiiw00Sf389re/zbRp0xp7jLXCU089lSeeeKKxxwAAAAAAAGAt1KSxBwAAAAAAAIB10Ze//OVceumlmTVr1qeeX7BgQe67776cfPLJyx9btmxZbr/99jr7brTRRmWdleIGDx5cqG7jjTfOXnvttcJj/fv3z80331zn2o8++ihPPvlkyTdxJslLL72U6667ruR17du3T58+fdKzZ8+0b98+lZWVmTZtWiZMmJBnnnkmf/vb30ruedlll9Vr3bbbbps+ffpk0003Tbt27TJv3rxMnz4948aNy7PPPpsZM2aU1G/GjBn5n//5n5LWbL311vn85z+fHj16pFmzZpk8eXJGjhyZZ599ttD6t99+O1dffXXOOOOMkvYth0GDBuXxxx8vXF9VVZXPfvaz6d27dzp16pRFixblnXfeybBhwzJp0qRCPa655pr0798/W2+9dT2nbjhTpkzJxRdfXNKaTTbZJH379s3mm2+eli1bZsqUKRk9enTGjh2bZcuWFeoxduzY3HHHHTnhhBPqM3Yhu+++e/bdd99svPHGmTFjRoYPH57nnnuu0NpPex4bbbRR+vfvn+222y5NmjTJa6+9lsGDB2fBggWFet5///0rhM+syoZ2Tdbluuuuy2uvvVa4vnnz5tl3332zyy67pEOHDpk/f37eeOONDBs2rHDozc9//vPsu+++6dChQ33HphY9e/ZMu3btCv+9Gj9+fL32qaqqSo8ePbLddttliy22SOvWrdOqVatUV1dn4cKFmTNnTj744IO8+uqreeWVVwr//po3b17uvffe/Md//Ee95mosm2yySbbddttss802adu27fLXY+nSpZk3b14+/PDDvPXWWxk7dmzh32tJcsstt9TrMxkAAAAAAADrNyEMAAAAAAAAUA/V1dU54ogjar3p/s4778w3v/nNVFZWJkkef/zxfPDBB7X2HTBgQDnHpATz58/P0KFDC9UeeOCBqaqqWuGxXr16pWvXrpk4cWKd6wcNGlSvG/5+8YtfFL7JMkk23XTT/OAHP8hXvvKVT8z7ryZMmJA777wz9913X6GbfMePH58777yz8BxJsu++++bMM8/MDjvssMqampqajBo1KrfddltGjBhR6Llec801hW+Ebd++fX72s5/lwAMPTEVFxQrnTjvttIwePTpnnXVWPvroozp73XzzzRkwYEA6d+5caO9yWLRoUS699NLC9X369MnPf/7zbLbZZp8491//9V+5+uqrc80119TZZ8mSJbnsssty1VVXlTRvKVq3bp2jjz46X/jCF7LlllumQ4cOWbhwYSZMmJBXXnklTzzxRMaOHfuJdQMHDsy8efMK7dG0adOceeaZ+frXv/6J6+HUU0/Nyy+/nB//+MeFw0UGDhyYI488MtXV1YXqi9poo43yq1/9Kl/4whdWePxb3/pWLr300noFsfzbv/1bfv3rX6d9+/YrPH7cccdlwIABmTNnTp09nn/++dTU1Hzi2lnZ2nZNfv/738/3v//9FR678sorM3DgwDp77rXXXrn11lsLPJNPN3Xq1Fx//fWF6w855JCce+652XjjjT9x7uyzz87FF1+c++67r84+s2fPzrXXXptzzz23pHlLsfHGG+erX/1q9t1332y22WZp27ZtFixYkPfeey8vvPBCRowYkWnTpjXY/o2poqIiO++8c5588slC9UU+F/xTu3btsv/+++eAAw7I5z73ubRs2bLQusmTJ2fgwIG55557CtX/4Q9/WGUIwxtvvPGJx3r27Fmo7y233JK99967UG1dmjZtmn/7t3/LAQcckP333z8dO3YstG7evHm56667cvnll2fhwoV11o8cOTIzZsxIu3btVnNiAAAAAAAA1ieVjT0AAAAAAAAArKsGDBiwPGDh07z//vt54oknlh/fdttttfbba6+9Ct/kRvn9+c9/zty5cwvVftq3wVdUVKRfv36F1g8fPrzQTc//6tlnn83zzz9fuH633XbLAw88kCOOOKLWAIYk6datW370ox9l2LBh+frXv54mTWrP87/pppuydOnSwrP88Ic/zPXXX19rAEPyj9fws5/9bK6++urcd9996dWrV631c+bMyb333ltohvbt2+euu+7KQQcdtMqbyPv06ZNbb701rVq1qrPfggULSg6iWF0PP/xwpk6dWqi2b9++uemmmz41gCFJmjVrlh/+8Ic588wzC/V77LHH8t577xWetRT77bdfhg4dmrPPPjt9+vRJly5d0rRp07Ru3To9e/bMkUcemSuuuCJDhgxZYd306dMzePDgwvtcfPHFOemkk1Z5PXzmM5/JLbfckm7duhXqN2PGjDz44IOF9y+isrIyl19++ScCGP7p+9///ieCFOqyww475KqrrvrUddtvv32+853vFOozZ86cOgMqNrRrsi533nlnFixYUKj2hBNOyGWXXfapAQzJP4JKLrroonzta18r1O/ee+8t+e9MUUcccUSGDh2a008/Pbvttls23njjNG3aNG3atMlOO+2UAQMG5IYbbsjvfve7Btl/bVDKdVgkRKRbt24577zz8vjjj+fiiy9O3759CwcwJEmXLl1y4YUXfiJwZFXGjRu31oZktG7dOieddFKGDx+ea6+9NkcffXThAIbkH0FpJ510Uq677rpaP6f/07JlyzJ69OjVGRkAAAAAAID1kBAGAAAAAAAAqKcePXrk85//fK01/wxeeOeddzJy5MhaawcMGFC22Shd0Zu5O3XqlD333PNTz31aOMOnWbhwYR599NHCsyXJ/fffX7i2W7duue6669KhQ4eS9mjdunXOPffc/PCHP1xlzcKFCz9xM3xtvv71r+e73/1uSXMkyU477ZS77747W2+99Sprhg4dWjg444ILLsgWW2xRZ91WW22V008/vVDPQYMGFaorl6I3/Hfq1Cm//OUvC918+p3vfCc77rhjnXXLli1rkOf7hS98IVddddUqbzz/Vyvf9Dx06NDCN7h/6UtfyqGHHlpnXefOnfPf//3fhXom/wjGKKdDDz00n/vc51Z5vlmzZiV/y/z555+fFi1arPL8IYccUrjX22+/Xev5De2arEvRebbffvucc845hWrPO++8dOrUqc66efPmZejQoYV6luJrX/taLr744rRu3brO2lIDQ9Yl7dq1K1w7f/78OmtuuOGGnHjiiSUFL3yaU045pfDf/ldffXW19mooP/7xj/Nf//Vf6dKly2r16dOnTw444IBCtWvrawEAAAAAAEDjEcIAAAAAAAAAq+H444+v9fxTTz2Vd999N7fffntqampWWbfJJpukb9++5R6PgqZMmZJRo0YVqj3ooINWeXN7r1690rVr10J9ioY+JElNTU0ee+yxwvUXXXRRNtpoo8L1K2vevPkqzz311FOZN29eoT6bbbZZfvSjH9V7joqKijRr1myV54cPH16oT8+ePdOvX7/C+371q1+tdd9/mjhxYsaNG1e47+qYPn16nn322UK1J598cqEbpJN/vMbHHXdcodpS3oNFtGvXLr/4xS/StGnTeq0fMWJE4drTTjutcO1+++2XnXfeuVDtiy++WNZvkz/ppJPqrNluu+0K99t5552zxx571FrTvXv3tG3btlC/WbNm1Xp+Q7om6/L6669nwoQJhWpPPfXUVFVVFapt3rx5jjrqqEK15b5mt9hii5x33nll7bmuatWqVeHaRYsW1VlTUVGxOuMs16RJk/Tq1atQ7bvvvluWPcutXK9Fkuy+++6F6tbW1wIAAAAAAIDGI4QBAAAAAAAAVsPnP//5Wr/Ju6amJtddd12d32B/zDHHpEmTJmWejqIefvjhLF26tFBt//79az1/8MEHF+ozduzYfPDBB4Vq33nnnUyfPr1Q7U477ZR99tmnUG19FA0CSJJvfOMbhW6crq/nnnuuUN2///u/l9S3ZcuW2Wmnnco6w+p68cUXs2zZskK1pT7fPffcs1DdG2+8kblz55bUuzYnnHBCOnbsWO/1L7zwQqG67bbbLltvvXVJvQ855JBCdcuWLcuLL75YUu9V6datW7bffvs66zp16lS45xe/+MVCdZtuummhutmzZ9d6fkO6JutSdI5WrVrlC1/4Qkm9i16zzz//fEl96/Ld73631pCeDUld18K/WtOvWbt27QrVTZkypWEHWQsUDZjZEF4LAAAAAAAASuNfcQEAAAAAAMBq+Oe3yP/iF79YZc39999fa49mzZrla1/7WrlHowSDBw8uVNe5c+c6v1X54IMPzo033lhnr5qamgwePDinnnpqnbWvvfZaofn+uX9Dev311wvXNuQskyZNKhxMsdtuu5Xcv0uXLoXqxo0bV3Lv+ij6HujevXtJN+knxZ/rsmXL8uabb9br9fw0RxxxRL3Xfvjhh5kxY0ah2qLfhF7fNa+//nrhsIPafOYznylU16FDh7L3rK6uLlRXWwjHhnZN1qXoNbvzzjuXHFZT9LX4+OOPM2XKlHTu3Lmk/p+muro6/fr1W+0+64uZM2cWrm3ZsmXJ/WtqavLWW2/lueeey5tvvpn33nsvkyZNyowZMzJ37twsWrQoS5YsKbnvv5ozZ85qrV+TJk2alGeeeSbjxo3L3/72t0yaNCnTpk3LrFmzlr8WNTU19e6/Lr0WAAAAAAAArBlCGAAAAAAAAGA1HXHEEbn88sszb968eq3v379/STfVUl6vv/563njjjUK1/fr1S2VlZa01vXr1Srdu3TJhwoQ6+z300EOFQhg++OCDQvMl9bvhvBRFZ9l8882z8cYbN/ocSXL88cc32BxFfs5rcp8PPvggPXv2bNA5yhHC0L1793Tt2nW15ihq2223Lbn/NttsU7h24sSJJff/NFtttVWhuqZNmxbuueWWWxaqa9Kk2D8fqe0m5w3tmqxL0TnGjBnT4NdsOUIYPvOZz9QrTGB99fHHHxeuLeVv4fvvv5877rgjQ4YMyeTJk+szWmELFixo0P6ra86cObn33nszaNCgBg9XWdtfCwAAAAAAANa82v91EAAAAAAAAFCnNm3a5Ctf+Uq91zfkzajUbdCgQYVrDz744EJ1Rb8t/N13383zzz9fZ10pN3t27969cG19FJ2loeeYNm1ag/Yv6qOPPloj+5TyHmhI5Xq+O+2002qtL+Xn36lTp5L7t2rVKtXV1YVqy/WzadeuXaG6Zs2alb1nOWxo12Rd1pZrtlxzrO41uz5ZunRpXn755cL13bp1q7Nm8eLFueSSS3LwwQfnxhtvbPAAhqT2UJXGdv/99+eAAw7IJZdc0uABDMna/VoAAAAAAADQOIQwAAAAAAAAQBnUN0hhl112yS677FLmaVat6LedJ/+4ybA+Fi9eXLi2lG90bwhLly7NI488Uqi2S5cu2X333QvV9u/fv/AMRUIgSvmG5oa+6broLG3btl0r5mhoa2qOhQsXrpF96lKu59uxY8c1NkfRMIWVtWrVqlBduX42ReesrCz+Tz3q+9zrY0O7Juuytlyz8+fPL0uf1b1m1yevv/565syZU7h+q622qvX87Nmz861vfSs33XRTlixZsrrjrdNqamryy1/+Mueee25mzJjR2OMAAAAAAACwASv+L6wAAAAAAACAVdpmm23Sp0+fjB49uqR19Q1vqK/mzZsXrp03b1699ihlXSnzNIQnn3yy8Lemb7bZZnnooYcK966uri70Wjz66KM577zzSvp2e9YepYSOrA/KdYNwmzZtytKniIqKigbtX65vUK+qqipLn39VSvDO+mJDuybrsi5es2u7ESNGlFS/66671nr+Bz/4QcmfH9dX1157bW688cbGHgMAAAAAAACEMAAAAAAAAEC5HH/88SXdRNexY8f079+/ASf6pFJuoizlW57ru66xb+ocPHhw4dqxY8dm7NixZZ9h5syZefzxx3PQQQetsqZFixaF+82YMSNdunQpx2irnKXIz3jmzJkNNkOStGzZskH7r21KeQ80pHIFDjRt2nS11pfyesydO7deexRdt7b8bBrbhnZN1mVteV+sLdfs+mLevHm57bbbCte3a9cuPXv2XOX5++67LyNHjizHaOu88ePH5+qrr27sMQAAAAAAACCJEAYAAAAAAAAom/333z9du3bNxIkTC9V/9atfTbNmzRp4qhV16tSpcO17771Xrz1KWde5c+d67VEOc+bMyfDhwxtt/381aNCgWkMYOnToULjXhAkTGjSEoUOHDoVCGCZMmNBgMyRJ+/btG7T/2mZDe751KeX1+Oijj0ruP2/evMybN69QbSnX5/rMe3RFXo/106233poZM2YUrv/iF7+YJk1W/c+zrr/++sK9tthiixx99NHZc889s9lmm6V169af+jny7LPPzoMPPli479ri5ptvzqJFiwrVtmvXLkceeWQ+//nPZ6uttkrbtm0/NfjkgQceyDnnnFPuUQEAAAAAANgACGEAAAAAAACAMqmqqsqxxx6bSy+9tM7aJk2a5Nhjj10DU61os802K1z79ttv12uPUtaVMk+5Pfroo1mwYEGj7f+v/vKXv2T69OmrvGm3e/fuhXs9++yz6d27d7lG+9RZigRtvPvuu/n444/TsWPHBpmjW7duhWufeOKJbLLJJg0yx5pS9Pnus88+ufnmmxt2mLVAKT//t956q+T+pfwe69q1a8n910cb2jVZl6Kvx1FHHZWLLrqogaehHMaOHZsrr7yypDVf+cpXVnlu3Lhxeffddwv1Oeqoo3LBBRfUGujwT/Pnzy863lpj6dKlGTZsWKHanXfeOddff32hAJx18bUAAAAAAABg7VDZ2AMAAAAAAADA+uSoo45K8+bN66zr27dvunTpsgYmWlHPnj0L144ePTpLliwpeY+//OUvDTJPuQ0ePLjR9l7Z4sWLM2TIkFWe32GHHQr3Gjp0aDlGWqXtt9++cO0f//jHBptj0003Tbt27QrVvvjiiw02x5pS9HV/7bXX6nXdrms23XTTtG3btlDts88+W3L/UtaUck2sz9ala7KioqLB9yj6vnjppZcaeBLK4e23387pp5+exYsXF16z/fbbZ5999lnl+aK/Zzp37pz/+Z//KRTAkCQffPBBobq1yTvvvJNp06YVqr3kkksKBTAk6+ZrAQAAAAAAwNpBCAMAAAAAAACUUYcOHXLIIYfUWXf88cevgWk+accddywUEpEkM2fOzOOPP15S/8mTJ2f06NGF63fbbbeS+pfLBx98kLFjxzbK3qsyaNCgVZ7bZpttCt/c/PLLL2fMmDHlGepT7L777oVrf//735d0w2qpdt1110J1tb2264pdd9210I3jM2fOzIgRI9bARI2roqIivXr1KlT7xhtvZPz48SX1ry0UZeU5ir4PNwTryjVZ9O/gggUL6r1H0b9vb775Zl577bV670PDe+SRR3L00Ufno48+KmndD3/4w1rPT5kypVCf3r17p2nTpoVqp0yZ0iDvpxYtWhSqq+81M3Xq1EJ1HTp0yLbbblu4bynBYAAAAAAAAPCvhDAAAAAAAABAmdUVsNCzZ8/sueeea2iaFbVo0aKkvS+77LIsXLiwcP2vf/3rLFq0qFBtq1atGu3m5cGDB6empqZR9l6Vl19+eZU3ildUVGT//fcv3Ov888/PnDlz6j3L/PnzV3nu3/7t31JdXV2oz9///vdcdtll9Z5j2bJltb7/DjjggEJ9RowYUdZgismTJ+fSSy/NsGHDytazLh07dix8vZR63dZlzJgxOeWUU8rWr1y++MUvFq4dOHBg4donnngiL7/8cqHaXXbZJR07dizce323rlyTrVu3LlT37rvvZunSpfWaaeedd06XLl0K1V5yySVl+5u0bNmyDB8+PP/5n/9Zln4bsqeeeionnXRSzjrrrMybN6+ktfvtt1+dv6OmT59eqFcpYUYDBw7MsmXLCtcXVfSaeeedd+rVf9q0aYXqSnkthgwZkrfffrte8wAAAAAAAIAQBgAAAAAAACiznXbaKUcffXT22WefT/3f9773vUad75BDDilcO378+Hzve9/LrFmzaq1bsmRJ/vd//zcPPfRQ4d79+vUr/M3O5VbKnGvS4MGDV3nuiCOOKNznvffey3/8x38UvsHznxYuXJhf/epXueKKK1ZZ06JFixx88MGFe95000257rrrSpoj+cd777jjjqv1hs5+/fqlZcuWdfaqqanJmWeemXHjxpU8x7/2GDt2bH784x/ngAMOyHXXXVfndVFuhx12WKG6d955J2eccUbhQJRPM2fOnDz44IM5/PDDc+KJJ2bEiBH17tVQDj744DRv3rxQ7R/+8Ic8/PDDddZNmTIlF1xwQeEZvvzlLxeu3RCsK9dk27ZtC9XNmjUrDzzwQL3mq6ioyFe+8pVCtWPGjMkFF1ywWkEM06ZNy+23357+/fvne9/7XsaOHVvvXhuaOXPmZMKECXnttdcyaNCg/OQnP0m/fv1y0kkn5amnniq5X8eOHXPRRRfVWdeiRYtC/Z5++unMnDmzzroHHnggd999d6GepSp6zdxzzz2ZO3duyf2LvhazZ8/O6NGj66wbN25cfvrTn5Y8BwAAAAAAAPxTk8YeAAAAAAAAANZHP//5zxt7hFU6+OCDc8kllxS6oS9JnnzyyRx44IE57rjjsu+++2bzzTdPmzZtMm/evEyaNCmjR4/OXXfdVfK3Hx977LH1GX+1vfDCC3n33XcL1R511FGFbqSsTU1NTfbbb79Mnjy5ztqHH344Z5xxRioqKj5xbs8990yvXr3y4osvFtp37NixOfLII/ODH/wghx56aKqqqlZZO23atNx999254447MmXKlJx44om19j755JMzaNCgQt+2XVNTk0svvTTPPfdcfvjDH2b77bevtf6ll17KLbfckj/+8Y91fuN127Ztc+SRR+a2226rc46PPvooxxxzTL797W9nwIABadeuXZ1r5syZk5deeinDhg3Ln/70p0ydOrXONQ3psMMOy29+85tC3xg+fPjwHHbYYfnxj3+cfffdt9af/z9NmDAhY8aMydChQ/PUU0+V9I3jjaFDhw75yle+knvuuadQ/TnnnJOPPvooJ5544qe+Hi+//HL+8z//MxMmTCjUr23btjn88MNLmnl9t65ck9ttt13h2p/85CcZNmxYdt9993To0OFTw4N69+6dzTbb7BOPH3/88bn55psLBaLceeedGTduXM4666zsueeeddbX1NTk73//e5566qkMHTo0Y8eOzdKlS4s9qQ3Y008/nZ49ezZY/6ZNm+ayyy5Lp06d6qzdeOONC/WcPXt2Tj/99Pzyl79Mly5dPnF+zpw5ufrqq3PjjTeWPG9R2267bcaPH19n3TvvvJMvfelLOfDAA7PVVlulurr6E59pWrVqlb59+67wWNHXIknOPvvsXHHFFdlll10+cW7ZsmUZNGhQLrzwwsybN69wTwAAAAAAAFiZEAYAAAAAAADYwFRXV+db3/pWLr300sJrZsyYkauvvjpXX311WWb44he/+Kk3z60JgwYNKlz7pS99abX3q6ioSL9+/XLLLbfUWTtx4sSMGTMmffr0+dTz5557bo455pjC35Y+YcKE/Nd//Vd++ctfZp999sl2222X9u3bp7KyMtOnT8+kSZPy7LPP5s033ywUqPBP22yzTb72ta/lzjvvLLxmxIgRGTFiRLbbbrvsvffe6dq1a9q2bZv58+dn+vTpGT9+fMaOHVvyTdWnnnpqHnroocyaNavO2vnz5+eKK67INddckz322CM77LBDNt1007Ru3TqLFi3KrFmzMnPmzEycODGvvfZa/v73v6/WN9OXW4sWLXLGGWfkJz/5SaH68ePH55RTTkmnTp2yxx57ZLvttku7du3SsmXLzJkzJzNnzsyMGTPyzjvv5NVXX82MGTMa9gk0gNNOOy2PPPJIoZttFy9enEsuuSS///3v07dv32y++eZp0aJFpk6dmlGjRmXs2LElXQennnpqWrVqtTrjr5fWhWvynzeHF3nf1NTU5PHHH8/jjz++ypqLL774U0MYunTpkpNOOinXXnttobmef/75HH/88enWrVt23333bLvtttloo43SrFmzzJ49O7Nmzcr06dPz5ptv5vXXX8+cOXMK9WXNqKqqyqWXXrrKv+Er+8xnPlO496hRo3LAAQekX79+2XrrrdO5c+fMmTMnr7/+eh5//PEG//2900475Y9//GOh2kmTJuXWW29d5flu3bp9IoShZ8+ead68eRYuXFhn/w8//DBHH310PvvZz6ZXr17p2rVrFi9enHfffTePP/543nvvvUJzAgAAAAAAQG2EMAAAAAAAAMAG6Bvf+EYeeuihvPXWW2t87+rq6px77rlrfN8kWbRoUR599NFCtR06dCh8I2Vd+vfvXyiEIUkGDx68yn133XXXnHzyybnhhhtK2n/atGkZMmRIhgwZUtK62vzoRz/KqFGj8u6775a07s0338ybb75Ztjk6dOiQn/zkJ/nxj39ceM3ixYszatSojBo1qmxzrClHHXVUhg4dmieffLLwmqlTp+bRRx8t/N5fl3Tp0iU//vGPc8EFFxRe8+GHH9Z6g3ARu+22WwYMGLBaPdZX68I1WVlZmX333bfwTeWr47vf/W4ee+yxkn7vTZgwIRMmTGjAqSi36urqXH755dlvv/0Kr9ljjz3Spk2bzJ49u1D94sWL88gjj9R3xNWy//77lxTeVaqWLVumT58+eeKJJwqvGTlyZEaOHNlgMwEAAAAAALBhq2zsAQAAAAAAAIA1r1mzZvn1r3/dKN/i/t///d/p0aPHGt83SUnfFn3QQQelqqqqLPvutttu2WSTTQrVDh06NPPnz1/l+TPPPLOkmzwbSuvWrTNw4MC0a9eusUfJl7/85Xz9619v7DHWiMrKyvzqV7/KFlts0dijrDWOO+64fOUrX1lj+3Xq1CmXXXZZmjTxvRersi5ck8ccc8wa2adFixa58sor06FDhzWyH2veNttskzvvvLPkv81NmzbNiSeeWNZZNt544+y7775l7Zn84znuscceZe/7r0466aSy9qusrMzhhx9e1p4AAAAAAABsOIQwAAAAAAAAwAZq++23z1VXXZXq6uo1tud//ud/5rDDDltj+61s0KBBhWu/9KUvlW3fioqK9OvXr1Dt3Llz8+c//3mV56uqqnLllVfmC1/4Qpmmq79tt902v/vd79KxY8fGHiXnnHNOBgwY0NhjrBEdOnTIzTffnC233LKxR1lr/OIXvyh8ja2OTp065cYbb0zXrl0bfK913dp+Te6zzz5r5D2TJFtssUVuuummdOrUaY3sx5rRvHnznHLKKXnwwQez/fbb16vHySefXLbfJ02aNMmvfvWrBvubfO6556Zp06YN0jtJ+vTpkwMPPLBs/U499dTstddeZesHAAAAAADAhkUIAwAAAAAAAGzA9tlnn9x6663p1q1bg+5TXV2dX//61zn55JMbdJ/aTJ8+PX/5y18K1Xbq1Cl77rlnWfc/+OCDC9cOHjy41vPNmzfPNddck+985zuprGzc/+y7884757777kuvXr0adY6Kior89Kc/zU9/+tM0b968UWdZEzbddNPcc889+eIXv9jYo6wVmjRpkssvvzzf+c53UlFR0SB77LTTTrn77ruz3XbbNUj/9c26cE3+/Oc/X2O/u7bffvvcd9992W233dbIfjScVq1a5cQTT8ywYcNyxhlnpFmzZqvV67e//W3atGmzWjNVVlbmoosuymc/+9nV6lObnXbaKRdeeGGDBjFccskl2WGHHVa7z9FHH53TTjutDBMBAAAAAACwoRLCAAAAAAAAABu4nXfeOQ8//HC+8Y1vrNaNhKvSt2/fPPzwwzn00EPL3rsUQ4YMyeLFiwvVHnzwwWUPN9htt92yySabFKodNWpUpkyZUmtNZWVlzjrrrNx1113ZddddyzBh/XXt2jV33nlnzj333LRv375RZxkwYEAGDx6cfffdt0H6N2vWLAcddFAGDhyYf//3f2+QPYraaKONcu211+ZXv/pVgwWpdOnSJSeddFKdwSBrg39eE7feemu9v5X+01RXV+f73/9+7r777gYPrFkfrc3X5EYbbZTbb789p5xySjbaaKMGme9fbbLJJrnjjjty3nnnNdjvyi222CLf//73c/PNNzdI/w1V+/btc/DBB+f//u//MnLkyJx33nnp3LlzWXpvt912ufnmm9O9e/d6rW/VqlWuvPLKHHbYYWWZpzaHH3547rjjjvTu3btB+rdu3To33nhj9tlnn3qtr6ioyCmnnJILL7ywzJMBAAAAAACwoWnS2AMAAAAAAAAAja9Vq1Y555xzctJJJ+Xuu+/OQw89lPfff7/e/dq1a5eDDz44xxxzTFm+0bgcSrmJvH///mXfv6KiIv369cvvf//7OmuXLl2ahx56KN/61rfqrO3Vq1fuvvvujBw5MnfffXdGjBiRhQsX1mvGTTfdNAceeGCOPvroktdWVVXl61//eo466qg8+OCDeeCBB/Lqq6/Wa47Kysrsuuuu6devX3r06FHy+i233DLXX399Xnrppdx5550ZOnRo5s6dW69Zkn8EEfTp0yef/exns//++6+Rm7VL8eUvfzkHH3xwhgwZkvvuuy/PPvtsampq6tWrsrIyO+64Y/r06ZPPf/7z2WuvvcoeSNLQ9txzzwwaNCh//vOfc+edd2b06NFZtmxZyX023XTTHHnkkTnuuOPSsWPHBph0w7E2X5NNmzbNGWeckVNOOSXDhg3L888/n9deey2TJ0/O7NmzM3fu3Hq9f1alsrIyJ554Yo488sjV/l35z/l32WWX7LPPPtlvv/2yyy67lG3W9VlFRUWqqqrStGnTNG/ePNXV1WnVqlXatm2bjh07pnPnzunatWu22GKLbLfddvUOSChq5513zoMPPpjf/OY3ue+++7JgwYI611RWVubAAw/M2Wefna5duzbofP9ql112yZ133plx48bl8ccfzyuvvJK33347s2bNypw5c+r9GeSfOnTokBtvvDG33HJLbrjhhkydOrXQup133jnnnHNO9thjj9XaHwAAAAAAAJKkoqa+//ICAAAAAAAAWK+NHz8+zzzzTF5//fX87W9/y+TJkzN9+vTMnz8/ixcvTpMmTdK8efO0bds2nTt3zuabb56ePXumd+/e+cxnPpOqqqrGfgobpAULFuTpp5/OCy+8kDfeeCMTJkzIlClTMnfu3CxatChNmjRJdXV12rVrl+7du6dHjx7Zeeed07t372y55ZZlnWXSpEkZOXJkXn311bz99tuZNGlSPv744yxYsCBLly5NixYtUl1dnU6dOmWzzTbLVlttld122y277bZb2rZtW7Y5Fi9enOeeey7PPfdcxo0bl/fffz9TpkzJnDlzsmjRolRVVaVVq1bLb8Dt0aNHttpqq2y11VbZaaedyv66NLRp06Zl5MiReeWVV/LWW2/lww8/zEcffZT58+dnyZIladGixfLn26lTp2y55ZbLn+9uu+221oVMrK7p06fnqaeeyksvvZQ333wzH3744Qrvw+bNm6d169bZZJNNsvnmm2ennXbK3nvvnZ122qmxR19vbWjXZF1q+125bNmytGzZcvnr0aVLl+XX7DbbbJNevXqlurq6sZ8CZTRt2rQMHTo0Y8aMyeuvv54ZM2Zk9uzZad68eTp06JCtt946e+yxRw4++OBPDSqaOXNm5s+fX+c+LVu2LOvf2oawaNGiDBs2LKNHj84LL7yQjz/+ODNnzkxVVVXatGmTLbfcMrvssksOOOCA9O7d+xPr58+fn5kzZ9a5T1VVVTp16tQQTwEAAAAAAIB1lBAGAAAAAAAAAAAAAAAAAAAAgCSVjT0AAAAAAAAAAAAAAAAAAAAAwNpACAMAAAAAAAAAAAAAAAAAAABAhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAABAEiEMAAAAAAAAAAAAAAAAAAAAAEmEMAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAkEQIAwAAAAAAAAAAAAAAAAAAAEASIQwAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAACQRwgAAAAAAAAAAAAAAAAAAAACQRAgDAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAABJhDAAAAAAAAAAAAAAAAAAAAAAJBHCAAAAAAAAAAAAAAAAAAAAAJAkadLYA0BDWbhwYZ577rm88847mTVrVpo2bZpNNtkkvXr1ymabbVbWvd5777289NJLmTRpUhYvXpyNNtooW221VXr37p3mzZuXdS8AAAAAAAAAAAAAAAAAAAAahhAG1pjJkyfnpZdeyosvvpiXXnopr7zySubOnbv8fLdu3fLYY4+t9j7Tpk3LwIED8+CDD2bevHmfWrPTTjvle9/7Xvr27btaew0bNixXX311Xn311U89X11dnSOOOCKnnnpqOnTosFp7AQAAAAAAAAAAAAAAAAAA0LAqampqahp7CNZfzz77bG666aa8+OKLmTJlSq215QhhGDNmTE4//fRMnz69UP1hhx2WCy+8MM2aNStpn0WLFuXcc8/Nww8/XKi+Q4cOueKKK7LnnnuWtA8AAAAAAAAAAAAAAAAAAABrTmVjD8D67eWXX86f//znOgMYymHs2LH5zne+84kAho022ig77rhjunXrlqqqqhXODRo0KGeddVZKySJZtmxZfvjDH34igKGqqirdu3fPDjvskDZt2qxwbtq0afn2t7+d559/vsRnBQAAAAAAAAAAAAAAAAAAwJoihIFGU11dXbZeM2fOzBlnnJEFCxYsf6xbt2656qqr8vTTT+fBBx/MY489lsceeyxf+9rXVlj7pz/9KTfffHPhvW644YYMHz58hceOOeaYjBgxIsOHD8+gQYPy9NNPZ+DAgenatevymvnz5+eHP/xhZs+eXb8nCQAAAAAAAAAAAAAAAAAAQIMSwsAa0apVq+y11145+eST85vf/CaPPfZYrr322rL1/93vfpcpU6YsP+7evXvuvPPO9O3bNxUVFcsf32STTfKzn/0sZ5xxxgrrr7rqqsycObPOfaZPn/6Juc8666xccMEF6dKly/LHKisrc+CBB+auu+5Kt27dlj8+adKk3HTTTSU/PwAAAAAAAAAAAAAAAAAAABpeRU1NTU1jD8H667333suiRYuy1VZbpbJyxcyPMWPG5MQTT1x+3K1btzz22GMl7zFt2rQccMABmTdv3vLHbr755uyzzz6rXFNTU5MTTjghzzzzzPLHTjnllE+EM6zsV7/6VW644Yblx3vuuWduvfXWFYIeVjZq1Kh84xvfWH7cqlWrDB8+PO3bt691rzVh6tTZjT0CrKBZs6oVjhctWtpIkwAA1I/PMwDAusxnGQBgXefzDACwrvN5BgBYl/ksAwCs63yeYV3TqVObxh4B1muVdZdA/fXo0SPbbLPNJwIYymnIkCErBDDsueeetQYwJElFRUVOPfXUFR67//77U1smybJly/LAAw+s8Nhpp51WawBDkuyzzz7ZY489lh/PnTs3jz76aK1rAAAAAAAAAAAAAAAAAAAAWPOEMLDOGz58+ArHRx11VKF1ffr0Sffu3ZcfT506NS+88MIq65977rlMmzZt+fFmm22Wvffeu9BeK8+08swAAAAAAAAAAAAAAAAAAAA0PiEMrNPmzp2bsWPHrvDY5z73uUJrKyoq8tnPfnaFxx5//PFV1j/xxBMrHH/2s59NRUVFob1W3mfMmDGZN29eobUAAAAAAAAAAAAAAAAAAACsGUIYWKe9/fbbWbx48fLj7t27p1OnToXX9+7de4Xj119/fZW1K59beW1tunTpkm7dui0/Xrx4cd5+++3C6wEAAAAAAAAAAAAAAAAAAGh4QhhYp40fP36F42222aak9VtvvXWt/f7VO++8U+vauqw828r9AAAAAAAAAAAAAAAAAAAAaFxCGFin/e1vf1vheJNNNilp/aabbrrC8cSJE7Nw4cJP1C1YsCATJ06sdW1dVp5t5dkBAAAAAAAAAAAAAAAAAABoXE0aewBYHR9//PEKx6WGMGy88cZp0qRJlixZkiRZtmxZZsyYkS5duqxQN3369NTU1Cw/btq0aTp27FjSXiv3XHn2xtCsWVVjjwAraNLEexIAWLf5PAMArMt8lgEA1nU+zwAA6zqfZwCAdZnPMgDAus7nGQD+VWVjDwCrY968eSsct2zZsqT1FRUVad68+QqPzZ07t859WrRokYqKipL2qq6urrUnAAAAAAAAAAAAAAAAAAAAjUsIA+u0lYMMVg5UKKJFixa19kw+GcxQn31WXiOEAQAAAAAAAAAAAAAAAAAAYO0ihIF12sKFC1c4btq0ack9mjVrtsLxggULPlGzaNGiNbIPAAAAAAAAAAAAAAAAAAAAjadJYw8Aq6N58+YrHC9evLjkHisHLKzcM/lkgEJD7bOmLVq0tLFHgFp5jwIA6zqfZwCAdZnPMgDAus7nGQBgXefzDACwLvNZBgBY1/k8A7Bhq2zsAWB1VFdXr3C8cOHCknssWLCg1p5J0qpVq9XeZ+U1n7YPAAAAAAAAAAAAAAAAAAAAjUcIA+u0lYMM5s+fX9L6mpqaT4QjrBy48Gn7LFiwIDU1NSXtNW/evFp7AgAAAAAAAAAAAAAAAAAA0LiEMLBO69ix4wrHkyZNKmn9Rx99lCVLliw/rqysTPv27T9R1759+1RUVCw/Xrx4cT7++OOS9po8efIKxyvPDgAAAAAAAAAAAAAAAAAAQOMSwsA6bcstt1zh+MMPPyxp/cr1Xbt2TfPmzT9R16JFi3Tt2nWFxyZOnLhae2211VYlrQcAAAAAAAAAAAAAAAAAAKBhCWFgnbZykMHbb79d0vrx48fX2u9frRz4sPLacu4FAAAAAAAAAAAAAAAAAADAmieEgXXaNttsk6ZNmy4/njBhQqZMmVJ4/XPPPbfC8Q477LDK2pXPPf/884X3mTJlSiZMmLD8uGnTptl6660LrwcAAAAAAAAAAAAAAAAAAKDhCWFgnda6devsscceKzw2cuTIQmtramo+UfvFL35xlfVf+MIXPrFPTU1Nob2eeuqpFY733nvvtGrVqtBaAAAAAAAAAAAAAAAAAAAA1gwhDKzz9t9//xWO77vvvkLrRo8enQ8++GD58cYbb5xevXqtsr53795p37798uP3338/Y8aMKbTXyjOtPDMAAAAAAAAAAAAAAAAAAACNTwgD67xDDjkk1dXVy4+feeaZjBo1qtY1NTU1ueqqq1Z47Igjjkhl5aovicrKyhx++OErPHbVVVelpqam1r1GjRqVsWPHLj9u1apV+vfvX+saAAAAAAAAAAAAAAAAAAAA1jwhDKzzOnbsmAEDBqzw2Pnnn5/Jkyevcs1vf/vbPPPMM8uP27Rpk5NPPrnOvb797W+vEPjw9NNP5/rrr19l/eTJk3Peeeet8NiJJ56YDh061LkXbOgmT07efLMy06c39iQAAAAAAAAAAAAAAAAAAGwomjT2AKz/nn322SxcuPATj48bN26F44ULF2bkyJGf2qNz587ZZpttVrnHt771rQwaNChTp05NknzwwQc59thjc95552X//fdPRUVFkmTSpEm5+uqrc/fdd6+w/pRTTkm7du3qfC4dOnTIKaeckssuu2z5Y5deemkmTpyY7373u+nSpUuSZNmyZXnsscdy0UUXZeLEiSs8j5NOOqnOfWBDNnFiRa68sklGjapMTU1SVZV8/vNLcsYZi/IvGSgAAAAAAAAAAAAAAAAAAFB2FTU1NTWNPQTrt/333z8TJkxYrR6HH354LrnkklprnnnmmZx88smfCHzYaKON0r1798yaNSsffvhhli5dusL5Aw44IFddddXyoIa6LFu2LN/73vcyYsSIFR6vqqpK165d06ZNm3zwwQeZNWvWCudbtGiRG2+8MbvvvnuhfdaEqVNnN/YIsIKamqp8+9vN8t57Ff//8f87t9tuS3PxxQtTVdVIwwEAFNCs2YofVhYtWrqKSgCAtY/PMgDAus7nGQBgXefzDACwLvNZBgBY1/k8w7qmU6c2jT0CrNcqG3sAKJc999wzv/3tb9OuXbsVHp81a1Zee+21fPDBB58IYPj3f//3XH755YUDGJKksrIyv/nNb3LIIYes8PjSpUvz/vvv57XXXvtEAEO7du1y3XXXrVUBDLA2Gjy4ankAw8qef74qr7zizxYAAAAAAAAAAAAAAAAAAA3H3aysV/bZZ58MGTIkxx57bFq2bLnKuh133DFXXnllLr300jRr1qzkfZo3b57LLrssV1xxRXbYYYdV1lVXV+e4447LH/7wh+y9994l7wMbmrfeqv3P0jPPVNV6HgAAAAAAAAAAAAAAAAAAVkdFTU1NTWMPAQ1hwYIFef755zN+/PjMmjUrTZs2TZcuXdKrV69svvnmZd3r73//e1588cVMnjw5ixcvzkYbbZStt946vXv3TvPmzcu6VzlNnTq7sUeAFZx/fos8/fT/C2JY+S/UAQcsydlnL1rDUwEAFNes2YqhUYsWLW2kSQAASuezDACwrvN5BgBY1/k8AwCsy3yWAQDWdT7PsK7p1KlNY48A67UmjT0ANJQWLVpkn332yT777NPge22++eZlD3aADVGbOj73zZ5dsWYGAQAAAAAAAAAAAAAAAABgg1RZdwkArBlt2tTUen7OHCEMAAAAAAAAAAAAAAAAAAA0HCEMAKw1Wreu/fzs2WtmDgAAAAAAAAAAAAAAAAAANkxCGABYa7RpU1Pr+dmzK9bQJAAAAAAAAAAAAAAAAAAAbIiEMACw1mjTpvbzc+ZUpKb2nAYAAAAAAAAAAAAAAAAAAKg3IQwArDVat649YWHJkmThwjU0DAAAAAAAAAAAAMD/x959h0dR7X8c/8xueiOhhlBDlyKCqKBcLIhdr11REHtDvXakFwXBAlcFFWyoqKigeAVRFEVFuoj0HnpN72V35/cHP1aWkN1Nsskm2ffrefLcnDNnZr4bvNnZyTmfAQAAAAAAQMAhhAEAUGXExLgPYZCkrCyjEioBAAAAAAAAAAAAAAAAAAAAAAAAAABAICKEAQBQZURFeR6TnV3xdQAAAAAAAAAAAAAAAAAAAAAAAAAAACAwEcIAAKgyoqNNj2Oys41KqAQAAAAAAAAAAAAAAAAAAAAAAAAAAACBiBAGAECVER3teQwhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgohDAAAKqM8HDJ4uGdKSurcmoBAAAAAAAAAAAAAAAAAAAAAAAAAABA4CGEAQBQZRiGFB3tfkxWllE5xQAAAAAAAAAAAAAAAAAAAAAAAAAAACDgBPm7AAAAThQVZSojo+SghexsQhgAAAAAAAAAAAAAAAAAAAAAAAAAIFCMHTtK8+fPdba//PJ/atgwwY8VAajpLP4uAACAE0VFud+elVU5dQAAAAAAAAAAAAAAAAAAAAAAAAAAACDwBPm7AAAAThQTY0oyStyenV3yNgAAAAAAAAAAAAAAAAAAAAAAAACoaEePHlG/fjcpJyfH2TdixPO65JLLS32srVs36777Bshut0uSDMPQ5MnT1LlzF5/VCwAoHYu/CwAA4ETR0e63E8IAAAAAAAAAAAAAAAAAAAAAAAAAwJ/q1auvgQMfd+l77bVXlJaWWqrj2Gw2vfjiGGcAgyRdd92NBDAAgJ8RwgAAqFKioky327OyCGEAAAAAAAAAAAAAAAAAAAAAAAAA4F/XXHOdzjzzLGc7IyNDEye+VKpjzJgxXdu2bXW24+Mb6sEHH/VZjQCAsiGEAQBQpURHu9+enV05dQAAAAAAAAAAAAAAAAAAAAAAAACAO4MGDVN4eLiz/csvP+nXX3/xat+dO3foww/fO+l4QxUREeHTGmuCoUNHafHiVc6vhg0T/F0SgBqOEAYAQJUSFWW63Z6dbVRSJQAAAAAAAAAAAAAAAAAAAAAAAABQsoSERrrvvodd+iZOHK/MzEy3+9ntdr344hgVFRU5+6688hqddVb3CqkTAFA6hDAAAKqU6Gj327OyCGEAAAAAAAAAAAAAAAAAAAAAAAAAUDXceOMt6tTpdGc7JSVFr7/+qtt9Zs6coU2bNjjbdevW06OPPllhNQIASocQBgBAlRIdbbrdXlQkFRZWUjEAAAAAAAAAAAAAAAAAAAAAAAAA4IbFYtFzz41QSEios+/77+dp2bIlpxy/Z89uvffeNJe+p59+TlFRURVaJwDAe0H+LgAAgBNFR3sek5VlqE4d92ENAAAAAAAAAAAAAAAAAAAAAAAAAFAZmjVrrrvuuk9Tp0529r300ljNmPGFIiIinX2maWr8+OdVWFjg7Lv44kvVs+f5lVJnVlaWdu7cob17dykzM0s2W5GioqIVFxen007roPj4hpVSR2XKzc3R1q1btGfPbmVnZ6mwsFBhYWGKjo5Rw4YJat48UbVr1/F3mQCqGEIYAABVSnS053CFrCypDte1AAAAAAAAAAAAAAAAAAAACAC5udK33wZpzx6LrFapd2+bTj/dIcPwd2UAAAA4Ud++/fTLLz9p69bNkqQjRw7rzTdf19NPD3aOmTXrc61du8bZjo2N0+OPP1OhdW3dulk//bRAK1cu0/bt22SaJa/fSkhopJtu6qtrrrlWoaFhbo9rs9n08MP3auPG9c6+q6++ToMGDfWqrkOHDuquu25XVlams2/kyBfUp89lxcaOHTtK8+fPdba//PJ/atgwwe3xt2zZrA8/fE9Lly5WUVGR27ENGzbSueeep2uvvVGJiS28qh9AzUYIg44lBx06dEgHDx5UTk6O8vLyZLPZFB4ervDwcNWpU0cJCQmKjIz0fDAAQLlERXkek51tSPIc1gAAAAAAAAAAAAAAAAAAAABUZ3v3GnriiTBlZPyTuDB/fpCuvNKm//ynkCAGAACAKiQoKEiDB4/QfffdIZvNJkn65puvdNFFfdS1azft379P06ZNcdnniSeeUWxsbIXVNHv255o06WWvxx84sF+vvfaKvvnmK40f/6oaN25S4tigoCCNGjVWd999u7KzsyVJ3377tbp1O0u9e1/i9jw2m02jRg11CWC48sprThnAUBYffzxd77zzphwOh1fjDx7cr9mzv1BkZJTuv/9hn9QAoHoLyBCGLVu2aMWKFVq3bp3WrVunvXv3ym63e9yvVq1aateunTp16qTOnTure/fuivJmtTAAwGvR0Z7DFY6FMAAAAAAAAAAAAAAAAAAAAAA1l8MhjRoV6hLAcNy8eUFq29ahyy+3+aEyAADgDSM7S0Zysr/LqDHMunVlRkX7uwyPWrduo3797tT06e9KOvYQ8QkTXtD06Z/ppZfGKi8vzzn2X/+6wGNYQXkVFBQW64uIiFTdunUVGRklu92u9PQ0HTly2GXMrl07NXDgvZo+/TPFxdUu8fgJCY00aNAwDR/+nLPvpZfGql279mrUqHGJ+73zzltav36ts928eaKeeOLZ0ry0Es2dO0dTp04u1h8REamGDRsqLCxcBQUFyszM0NGjR2SaPCwYQHEBE8KwYsUKzZ07V7/++quOHDni7C/NL8f09HQtX75cy5cvlyRZrVZ16dJFvXv31jXXXKPatUt+IwEAeCciQrJYjt00Lsn/B6MBAAAAAAAAAAAAAAAAAAAANdbOnYb27LGUuP3nn62EMAAAUAVZ169TxBsTZd2509+l1CyGZE9sodzHnpK9Q0d/V+PWgAH36Ndff1ZS0rH/Bvbv36eHHrpH27dvdY6Jjo7RU089V9IhfCokJEQ9e56vc8/tqTPOOFPx8fHFxmRkpOuXX37S9OnvKTn5qCQpJSVFEya8oPHjJ7o9/oUXXqxrr71Bc+bMliTl5ORo5Mgheuut9xQcHFxs/IoVy/Tppx+dUF+oRo9+UWFhYeV5mZKkwsJCvfnmGy59F1xwkfr1u0tt27aTYbgGnOXm5mjTpo1auvQPLVgwv9znB1BzGGYNjmhJTk7WZ599pq+//loHDx6UVDx04eRfmJ6UtL/ValXPnj1166236oILLih70UAlOno0y98lAC5CQqySpKuvDlVWllTSO9TDDxfquuu4YQwAAKqe49czxxUW2v1UCQAAQOlxLQMAAKo7rmcAAEB1x/UMAAA42eefB+ndd0Pcjvnxx9xKqsY9rmUAADgm6M+Viho2SLLxXlhhgqzKfmGCbGee5dPD+vp6ZuPG9XrooXtkt5/6OEOGjNQVV1xdrnN4Y+fOHYqLi1NcnHcPIc/MzNQTTwzUli2bnH0ff/yFEhNbuN2voKBA998/QDt2bHf23XLLbXr00SddxqWmpujOO29TamqKs+/ppwfr2mtvcHv8sWNHaf78uc72l1/+Tw0bJhQbt3TpYj3zzOPO9mWXXalhw0a7PfZxRUVFOnLksBo1auzVeH+rVy/a3yUANVrJkYjV2Pbt2zV48GBddNFFevPNN3XgwAGZpinTNGUYhsvX8X5vv07eXzoWzGCz2fTrr7/qoYce0mWXXaaZM2eqqKjIzz8JAKieoqPd5wNlZZUuQAcAAAAAAAAAAAAAAAAAAACoblatsnock1s1MhgAAIAkmabC33+HAIaKZrMr/IN3S376axXRvn1H3XRT31NuO/vsHpUSwCBJLVq09DqAQZJiYmI0atRYWSz/LD+eP/9bj/uFhoZqzJjxCg8Pd/Z9/vmn+uOP351th8OhMWOGuwQwXHBBb48BDKWxd+8el/Z1193k9b7BwcHVJoABQMUL8ncBvrR371699tprmj9/vhwOh8z/fxM9HpYgydknHful3rJlSyUkJCg+Pl716tVTWFiYwsLCZLVaVVBQoPz8fGVkZOjQoUM6fPiwdu7cqaNHj7qc9+Tj79q1S6NHj9bUqVM1cOBAXX/99S5vOAAA96I9hHBlZ1dOHQAAAAAAAAAAAAAAAAAAAIC/xMR4XliYkWEoIqJqL0AEACBQGDnZsm7d4u8yAoJ1y2YZOdkyozwsQvKzvn376YsvPpXD4XD2hYeH69lnh/qxKs+aNGmq007roA0b1kmS1q1b69V+zZo11xNPPKtx40Y7+8aNG6Xp0z9TvXr1NWPGdK1atcK5rWHDBD333HCf1l5QUODSDgqqUcuoAVSiGvHbIysrS6+99ppmzpwpu90u0zRlGIYzHOF48EJCQoLOOeccnXPOOerUqZMSExPLFI6QlpamzZs3a9WqVVq+fLn+/vtvFRUVSZLLOQ8ePKjhw4frvffe09ChQ9WzZ08fvWIAqNmio01JRonbs7JK3gYAAAAAAAAAAAAAAAAAAADUBDExnsekphpq2JAQBgAAgKronXfecglgkI6FBKSkJCs+Pt5PVXmnYcMEZwjDtm3eh4tcccXV+vPPFfrhh/mSpIyMDI0ePUz33vug3ntvqnNcUFCQRo0ap6ioKJ/WXbduPZf2ggXfqW3bdj49B4DAUO1DGGbNmqVJkyYpNTXVJXzhePBCy5Ytdemll+rSSy9V27ZtfXLOuLg49ejRQz169NCjjz6qnJwcLVq0SD/88IN+++035efnu4QxJCUl6b777tPFF1+sIUOGqGHDhj6pAwBqqmgPIXTZ2YQwAAAAAAAAAAAAAAAAAAAAoGaLifEcrpCRwbxaAACqCjMySvY2bWXd6v2CdZSNvW07mZG+XbzvaytXLtfcud8U63c4HJow4Xm9//4nCgqq3CW+qakp+vnnH7Vhw3rt2LFNaWlpysnJUWFhgdv98vPzVVCQr9DQMK/O89RTg7Vhwwbt27dHkrRmzWo98cRA2e1255j77ntIHTp0LPuLKUHXrt1ktVqd5/r8809VUFCovn37qVGjxj4/H4Caq9qHMAwbNswZeHA8fCE8PFyXXXaZbr75ZnXp0qXCa4iMjNSVV16pK6+8UtnZ2ZozZ46+/PJLbdmyxaWun376SW3bttUjjzxS4TUBQHUWFeX+hnF2diUVAgAAAAAAAAAAAAAAAAAAAPhJeLjnEIbUVEIYAACoMgxDeXffp6hhgySb3fN4lE2QVXl33ycZVfc6KDc3Vy+9NNalLygoSDabTZK0c+cOffTR+7r77vvdHicpaaeSk496dc7ExJaqW7fuKbelp6frzTdf0w8/fOcShFAaWVnZXocwREREaMyYcXrwwbtVWFgoSSoqKnJuP/vsHrrttjvKVIcnDRrE64orrtG3337t7JszZ5bmzJmltm1PU7duZ+uMM7qoQ4dOiompVSE1AKgZqn0Iw3GmaapWrVrq37+/+vfvr1q1/PPLLyoqSv369VO/fv20dOlSTZs2TUuXLvVLLQBQXUVHu9+elVV1PyQBAAAAAAAAAAAAAAAAAAAAvuBweB6TkcG8WgAAqhLbmWcp65XXFfH6q7Im7ZQ8ZyrBW4ZkT2yh3Meekr1DR39X49bUqZN18OABZ7tt29N011336rnnnnL2ffzxB7rwwouVmNiixON8+ulHmj9/rlfnHDJkpK644upi/fv379Ojjz6gI0cOl+IVFFdUVFiq8W3atNPAgf/RpEkvu/TXqVNXw4ePdj6cvSI8/vjTSk1N1h9//O7Sv2XLJm3ZskmffPKhDMNQq1at1b37eerT5zK1aNGywuoBUD3ViBCG6Oho3X///br99tsVHh7u73KcevTooR49emjdunWaOHEiYQwA4KXoaPefMDMzuVkMAAAAAAAAAAAAAAAAAACAms1u9zxnNjWVebUAAFQ19g4dlTX1AxnZWTKSk/1dTo1h1q0rM8rDk1+rgL//XqOvvvrS2Q4KCtJzzw1X69ZtdMkll2vBgvmSpKKiIo0f/7zeeus9WSyWCqmlqKhITz/9WLEAhsaNm6pLl65q0qSZ6tWrp/DwcIWGhkr659rys88+1ooVy8p1/tzcvGJ9iYktFBsbV67jehIaGqrx4yfqp59+0KeffqRt27YWG2OaprZt26pt27bq448/0Lnn9tRjjz2lxo2bVGhtAKqPah/CcPfdd+vBBx9UTEyMv0spUadOnfTBBx9oyZIlysjI8Hc5AFDl1arlfntmpiHTlCow8AwAAAAAAAAAAAAAAAAAAADwK4fD8xiWKAAAUHWZUdHVIjQAvlNQUKDx48fINP95QO3ttw9Q69ZtJEmPPfaUVqxYpvT0NEnShg3rNGvW57r55r4VUs+cObO1d+8eZ7t27ToaMmSkunc/1+O+c+d+U65zr1+/Vu+++1ax/lWrVujzzz/Rrbf2K9fxPTEMQ336XKY+fS5TUtJOrVy5XH/99afWrVuj9PT0YuOXLFmsNWv+0ssv/1edO3ep0NoAVA/VPoTh2Wef9XcJXjv3XM9vTAAAqVYt0+12u13KzZUiIyupIAAAAAAAAAAAAAAAAAAAAKCS2e2ex6Sl8VQzAACAquLdd992CT1o3ryF7rzzXmc7NjZW//nPUxo9epiz75133lSvXhcoPr5hseMNHTpKQ4eOKnM9CxcucGmPG/eyOnY83at9s7Iyy3zerKwsjRo1VPYSLminTp2iM844U+3anVbmc5RGYmILJSa20M0395Vpmtq9e5dWrFimRYsWau3aNc5xubk5GjZskD7/fI4iIiIqpTYAVZfF3wUAAHAyTyEMkpSZyQ1jAAAAAAAAAAAAAAAAAAAA1Fym5ym1Sk9nTi0AAEBVsGnTBn3xxafOtsVi0XPPDVdwcLDLuD59LtO55/7L2c7Ly9NLL431eT0Oh0ObNm1wtlu3buN1AIMkJSXtLPO5J0x4XocOHXS2u3c/1yWMoqioSKNGDVFubk6Zz1FWhmGoefNE3XxzX7355ruaMuUdxcbGOrenpaXqhx++q/S6AFQ9hDAAAKqcmBjPYwhhAAAAAAAAAAAAAAAAAAAAQE1WwoODXaSlMacWAADA34qKivTii2NkP+EC7qabblXHjp1OOf6ZZwYrMjLS2V6xYpnmz5/r05oyMjJc6mnatJnX++7Zs1tHjx4p03m//nqWFi362dmuU6euhg4drbvuuk9nnNHV2b9v31698sr4Mp3Dlzp37qIHH3zEpW/t2jX+KQZAlUIIAwCgyqlVy3Nsb0ZGJRQCAAAAAAAAAAAAAAAAAAAA+Ik3IQxZWYZstoqvBQAAACX78MP3tHPnDmc7IaGR7rvv4RLH16tXXw899JhL3xtvTFJaWqoPq3Jdn1VU5P1F49dfzyrTGXfs2K433pjkbFssFo0Y8bzi4uJktVo1YsTzqlWrlnP7ggXz9d1335bpXL7UqdMZLu2MjHS/1AGgaiGEAQBQ5URHS4aHUN7MTFJ7AQAAAAAAAAAAAAAAAAAAUHM5HN6Ny8hgXi0AAIC/bNu2VTNmTHfpGzRomMLCwtzu9+9/X68uXc50tjMzMzRx4ks+qysmppasVquzvWHDOtm8SO/atm2Lvv76y1KfLz8/XyNHDlZhYYGzr1+/O3XmmWc52/XrN9DgwSNd9ps06SXt2bOr1OfzpfT0dJd2dHS0fwoBUKUQwgAAqHIslmNBDO5wsxgAAAAAAAAAAAAAAAAAAAA1mcPh3XzZk9aMAQAAoJLYbDa9+OIYl3CDq6++ziV4oCSGYWjQoGEKDQ119v3yy0/6/fdFPqnNarWqffuOznZKSrJmzpzhdp99+/bqueee8iqs4WQTJ07Qrl1JznanTp11zz0PFBvXs2cv3Xjjrc52Xl6eRo4cosLCwlKf81Teeect/fDDd16/BtM0i/1c2rY9zSe1AKjeCGEAAFRJMTGm2+2ZmYQwAAAAAAAAAAAAAAAAAAAAoOZyOLwbl5bGvFoAAAB/+Oyzj7V162Znu169+ho48D9e79+4cZNiQQWvvjpB2dnZPqnvssuudGlPnTpFkyf/V2lpqS796enp+uyzGbr33v46fPiQDMNQ06bNvD7Pjz9+r++++9bZjo6O0ciRY2W1Wk85/uGHH1ObNm2d7W3btmrKlP96fT53du7cruefH6HrrrtCr7zyopYtW6KMjPRi4xwOh/7+e42eeGKgS/BFWFiY+vS5zCe1AKjegvxdgK9t3rxZ33zzjZKSkhQREaELL7xQV1xxRYm/rE90+eWXa9euXTIMQxs3bqyEagEAJalVS9q7t+TthDAAAAAAAAAAAAAAAAAAAACgJrPbvRuXns68WgAAgMq2e/cuffDBOy59Tz89WFFRUaU6zi233K6ff/5JmzcfW9OanHxUU6a8pkGDhpa7xiuvvEZz5szStm1bJUmmaWrmzBn64otP1bhxE0VFRSszM0MHDx6Q/YSLz3797lRy8lHt2bPb4zn279+nl19+0aXvueeGKz4+vsR9QkJCNGrUON1zT3/l5eVKkmbP/kJnnXWOevY8vywvtZi0tFTNmTNbc+bMliTVqVNXsbGxCgsLV35+ng4cOOA894keeeRx1atX3yc1AKjeLP4uwJdef/113XDDDZo+fbp+/fVXzZ8/X88++6yuvPJKrVq1yqtjmKYp03T/9HUAQMWrVcv97+LMzEoqBAAAAAAAAAAAAAAAAAAAAPADh8O7cWlphDAAAABUJofDoRdfHKPCwkJnX58+l+m88/5V6mNZrVY999xwBQX988z1uXPnaPVq79bEuhMUFKQXX5yoxo2buvQ7HA7t2bNbGzeu1759e10CGG655Xbdf//DXh2/qKhII0cOUW5ujrPvuutu0vnnX+hx36ZNm+nJJ5916Rs3boyOHDns1blLKyUlWTt2bNeGDeu0Y8f2YgEMoaGhevrpwbr22hsr5PwAqp8aE8Lw4Ycf6s0333T5ZS8dC1XYtWuXBgwYoDfffNNP1QEASstTCENGBjeLAQAAAAAAAAAAAAAAAAAAUHOdtDyiROnpzKsFAACoTLNmzdT69Wud7djYOP3nP0+X+XitWrXW7bcPcLZN09RLL41VQUF+ueqUpPj4eL377ke64YabFRISWuK4Dh06aeLEyXr00SdkGN5dX7799hvavHmjs92yZWs98sjjXtd2+eVX6dJLr3C2MzMzNHr0sGLrhEvj2WeHafDgEbrggotUu3Ydj+NjYmrp2mtv0CefzNK1195Q5vMCqHkM0zTdr3KtBpKTk9WnTx/l5+fr+MupXbu2srKyVFRUJMMwZJqmDMPQlVdeqQkTJshqtRY7zuWXX66kpCQZhqFNmzZV9ssAKt3Ro1n+LgFwERLyz+/mt98O0mefFf9dfVxiokPTppX/gwQAAIAvnXg9I0mFhWW/AQgAAFDZuJYBAADVHdczAACguuN6BgAAnGz8+BAtXBjkcVyfPjY9+2yhx3EViWsZAABQ3QXC9Uxubq7+/vsv7d+/V9nZ2QoNDVP9+g3UoUMnxcfH+7u8CnHgwH7t2bNbhw4dVE5OtoqKihQREaHY2Di1aNFKzZsnKijI8zV3VVSvXrS/SwBqtOr5m+Ekc+bMUV5engzDUJcuXfTCCy+oZcuWys3N1UcffaS3335bBQUFMk1T8+bNU3Z2tl5//XWFhIT4u3QAQAliYtxnBGVmktgLAAAAAAAAAAAAAAAAAACAmsvbBwCnpzOvFgAAAJ5FRESoR4/z/F1GpUpIaKSEhEb+LgNANWTxdwG+sGTJEklSQkKC3n//fbVs2VLSsTeEBx98ULNmzVLz5s0lSaZp6tdff9UjjzyioqIif5UMAPCgVi332zMyDJnucxoAAAAAAAAAAAAAAAAAAACAasvbEIa0NEIYAAAAAADwpRoRwrBt2zYZhqE77rhD4eHhxba3atVKX375pc4991xn3++//64nn3xSJit4AaBKiolx//vZZpPy8iqpGAAAAAAAAAAAAAAAAAAAAKCSORzehSukpxPCAAAAAACAL9WIEIaMjAxJ0plnnlnimKioKE2bNk1XXHGFM3jhp59+0qhRoyqjRABAKdWq5TkkJzOTG8YAAAAAAAAAAAAAAAAAAAComex278alpxvi+ZQAAAAAAPhOjQhhOB6qEBMT43ZcUFCQXn31VV1//fUyTVOmaeqLL77QlClTKqNMAEApePiVLokQBgAAAAAAAAAAAAAAAAAAANRc3gYr2GxSdnbF1gIAAAAAQCCpESEMx8MX0tPTPY41DEPjxo3TDTfcIOlYgMPkyZP19ddfV2SJAIBSio31fNc4I6MSCgEAAAAAAAAAAAAAAAAAAAD8wG73fmxaGg83AwAAAADAV2pECEOjRo0kSZs3b/Z6n7Fjx+rf//63sz18+HAdPnzY57UBAMomOtrzmKwsbhYDAAAAAAAAAAAAAAAAAACgZiKEAQAAAAAA/6gRIQytWrWSaZpavHhxqfZ78cUX1adPH5mmKZvNpry8vAqqEABQWlarFB1tuh2TkcHNYgAAAAAAAAAAAAAAAAAAANRMDof3Y1NSmFcLAAAAAICv1IgQhk6dOkmSfvvtN2VnZ3u9n8Vi0cSJE3XeeedVVGkAgHLwFMKQmcnNYgAAAAAAAAAAAAAAAAAAANRMpvuptC6Sk5lXCwAAAACAr9SIEIazzz5bklRQUKAvvviiVPsGBwdrypQpOuOMM2SW5g4FAKDC1arlfntGBjeLAQAAAAAAAAAAAAAAAAAAUDPZ7d6PTUlhXi0AAAAAAL4S5O8CfKFly5Z66qmnZLPZVMvTit1TCAsL07vvvqtXXnlFBQUFFVAhAKAsatVyH46TlVVJhQAAAAAAAAAAAAAAAAAAAACVzG73PlghNZUQBgAAAAAAfKVGhDBI0n333Veu/aOiojRq1CjfFAMA8InoaPchDBkZ3CwGAAAAAAAAAAAAAAAAAABAzeRweD82JYV5tQAAAAAA+IrF3wUAAFCSWrXchzBkZnKzGAAAAAAAAAAAAAAAAAAAADWT3e79WEIYAAAAAADwHUIYAABVVkyM+xCGjAxuFgMAAAAAAAAAAAAAAAAAAKBmMt1PpXWRkmKUajwAAAAAACgZIQwAgCorJsb9dkIYAAAAAAAAAAAAAAAAAAAAUFPZ7d6PLSgwlJNTcbUAAAAAABBIgvxdQHWSnp6u33//XVu2bFFWVpZq166tdu3a6cILL1RISIi/ywOAGicmxn0cb1GRlJ8vhYVVUkEAAAAAAAAAAAAAAAAAAABAJSlNCIMkpaQYiopyP/8WAAAAAAB4FnAhDElJSS7tJk2aKCjI849h6tSpevvtt5Wfn19sW3R0tAYNGqQbbrjBZ3UCAKRatTzfBE5PNxQfz81iAAAAAAAAAAAAAAAAAAAA1CwOR+nGp6QYataMebUAAAAAAJRXQIUwrF69Wrfffruz3aBBA/38888e9xs9erRmzpwp0zz1zYjMzEwNGzZM27dv16BBg3xWLwAEuthYQhgAAAAAAAAAAAAAAAAAAAAQmBwOo1TjU1NLNx4AAAAAAJyaxd8FVKYffvhBpmk6wxRuvvlmWSzufwQLFizQZ599JkkyDKPEL9M0NX36dH399dcV/joAIFDExXkXwgAAAAAAAAAAAAAAAAAAAADUNA5H6cYnJzOvFgAAAAAAXwioEIbly5fLMP65qXDppZe6HW+apiZNmlSs7+QvSc4ghldeeUXZ2dm+Lx4AAlBUlGS1uh+TlsbNYgAAAAAAAAAAAAAAAAAAANQ8dnvpxqemMq8WAAAAAABfCJgQhtzcXG3bts3ZbtSokVq2bOl2n99++01JSUnOgAVJ6tWrl+bMmaO1a9dq4cKFuuOOO5zbJCk1NVWzZs2qmBcBAAHGMKTYWNPtmLS0SioGAAAAAAAAAAAAAAAAAAAAqESlDWFISSGEAQAAAAAAXwiYEIZdu3bJ/v93IAzDUKdOnTzuM2/ePOf3x/d5++231a5dO4WEhKhRo0YaMmSI7rnnHpmm6QxrmDt3boW9DgAINJ5CGNLTuVkMAAAAAAAAAAAAAAAAAACAmsfhKN14QhgAAAAAAPCNgAlh2L9/v0u7VatWHvf59ddfncEKkjRw4EBZLMV/ZAMHDlR0dLSzvWHDBmVnZ5ezYgCAJNWu7T6EIS2Nm8UAAAAAAAAAAAAAAAAAAACoeUz302iLSUkJmCUiAAAAAABUqID5hH306FFJIctwcAABAABJREFUcgYq1K9f3+34zZs3KyMjw9mOi4tTr169Tjk2IiJCPXv2dB5bkrZs2VLekgEAkmrVIoQBAAAAAAAAAAAAAAAAAAAAgcduL934lBSj1MENAAAAAACguIAJYcjPz3dpR0ZGuh3/559/Or83DEO9evWSYZS80Ld9+/Yu7T179pShSgDAyWrXdn8nOD2dEAYAAAAAAAAAAAAAAAAAAADUPKUNYSgqkrKzK6YWAAAAAAACSZC/C6gsBQUFLu2gIPcvff369ZIk0zRlGIbOPvtst+Pj4+Nd2llZWWWoEtVRQUGBVq9erZ07dyozM1PBwcGKj49X586d1aRJE3+XB1R7sbHuQxjS0ghhAAAAAAAAAAAAAAAAAAAAQM3jcJR+nmxysqHoaPfzbwEAAAAAgHsBE8IQFhbm0s7NzXU7fvXq1TIMQ6Z57OZDt27d3I4PDQ2VJBmG4dXx4VtvvPGGJk+eXOb9r7vuOo0fP75U+6Smpmry5Mn6+uuvS/z37tChgx5++GFdfPHFZa4NCHRxce5vAmdlGbLbJau1kgoCAAAAAAAAAAAAAAAAAAAAKoHDUfp9UlMNJSYSwgAAAAAAQHlY/F1AZYmKipL0T0jC/v37Sxx7+PBh7d6929mOjY1V06ZN3R7/5EX4QUEBk28RkJYvX64rrrhCn3zyidvAjQ0bNmjgwIEaNGiQCgsLK7FCoOaIjXV/E9g0pYyMSioGAAAAAAAAAAAAAAAAAAAAqCRlCWFITjZ8XwgAAAAAAAEmYEIYEhISXNrr1q0rcewvv/zi/N4wDHXp0sXj8bOysiRJpnlssXBkZGRZykQ1sGrVKt1///1KS0tz6Y+JiVH79u3VqFEjWa1Wl21z5szRU0895fzvA4D34uI8//8mLY2bxQAAAAAAAAAAAAAAAAAAAKg5HI5jDysrrZQU5tUCAAAAAFBeQf4uoLK0a9fO+b1pmlq+fLnS0tIUFxdXbOycOXOc4wzD0Nlnn+3x+Pv27XNp16tXr3wFo1wGDRrk8m/uSf369b0al5GRoSeeeEL5+fnOvkaNGmnIkCHq3bu3DOPYDatDhw7pzTff1Oeff+4ct2DBAk2fPl133XWX13UBkGJjPY85FsJAyAkAAAAAAAAAAAAAAAAAAABqBoejbPsdORIwz+oEAABADTV27CjNnz/X2f7yy/+pYcMEN3sAgO8FTAhDnTp11KpVK+3YsUOSlJ+frwkTJmj8+PEu43788UetWbNGhmHI/P/YyF69enk8/saNG13ajRs39lHlKIsOHTronHPO8flx33vvPR05csTZbty4sT799FM1aNDAZVx8fLzGjBmjhIQETZo0ydk/ZcoUXX/99apVq5bPawNqqthYU4bhPsk3PZ3EXgAAAAAAAAAAAAAAAAAAANQcZQ9hYF4tAAAAAADlFVARh1dddZVM03QGLHzzzTe6++67NW/ePP3xxx96/fXX9cwzzzi3G4ahDh06qEWLFm6Pa7PZtHHjRhnGsZsVVqtVzZs3r4RXhMqUmpqqjz/+2KXvhRdeKBbAcKIHHnhAZ511lrOdlZWl999/v8JqBGoiq1WKjnaTwCApLY2bxQAAAAAAAAAAAAAAAAAAAKg57Pay7UcIAwAAQMVyOBx66KG71bNnN+fXmDHDy3XM1atX6V//Ost5vAsv7KEdO7b7qGIAQFkEVAjD7bffrtq1a0uSM2hh6dKlevrpp3XvvffqrbfeUn5+vss+9957r8fjLl++XDk5Oc52mzZtFBYW5tvi4Xfz5s1Tbm6us33WWWepR48ebvcxDEMDBw506Zs9e7ZM0/2CcgCu4uLc/38mPZ2bxQAAAAAAAAAAAAAAAAAAAKg5HI6y7XfkiCGmqwMAAFQci8WiwYNHKCQk1Nm3YMF8/fHH72U6Xn5+vsaPf95lzeGAAfeoZctW5a4VAFB2ARXCEB0dreHD/0kUOh7EcOKXYRjObeeee64uu+wyj8ddsGCBJDn379KlS8W8APjVwoULXdo33nijV/t1795djRs3draPHj2qNWvW+LI0oMaLjXV/JzgtjRAGAAAAAAAAAAAAAAAAAAAA1BxlDWHIyzN0wjMmAQAAUAGaNm2ue+99wKXv5ZfHKSsrq9THmjp1ig4c2O9st27dRv363VneEgEA5RRQIQySdPnll2vMmDEKDg52hiac+HU8jKFTp0569dVXPR4vJydH8+bNc4Y3SNJ5551XkS8BfpCTk6NVq1a59Hn773w80ONEixYt8lVpQECIi3MfwpCeTggDAAAAAAAAAAAAAAAAAAAAag67vez7HjnC3FoAAICKdsstt6t9+47OdnLyUb3xxsRSHWPdur81e/bnznZQUJCGDBmpoKAgn9VZHQ0dOkqLF69yfjVsmODvkgAEoIALYZCkm266Sd98841uuOEGxcbGOoMXJKldu3YaMmSIZsyYodjYWI/Hmj17trKzs537h4aGEsJQA23fvl1FRUXOduPGjVWvXj2v9+/atatLe9OmTT6rDQgEsbHuQxhSU7lRDAAAAAAAAAAAAAAAAAAAgJrD4Sj7vkeOBORSEQAAgEpltVo1ePAIhYSEOPu+++5bLV++1Kv9CwoKNH7883KccOHXv/9dat26rc9rBQCUXsDG4SQmJmrs2LGSpJycHOXk5Cg2NtblDc8bnTp10uTJk53t6OhohYaG+rRWlE1hYaH27t2rtLQ0BQcHKzY2VvXr11d4eHipj7Vjxw6XdqtWrUq1f8uWLd0eD4B7cXHuQxgyMghhAAAAAAAAAAAAAAAAAAAAQM1ht5d9fuzRo8ytBQAAqAyJiS101133aerUKc6+l14aq48//lwREZFu933//WnavXuXs92yZSvdccfdFVUqAKCUAjaE4USRkZGKjHT/hlaSLl26+Lga+MKYMWO0d+9eFRQUuPQHBQWpQ4cO6tWrl2677TbVrl3bq+MlJSW5tOPj40tVT8OGDV3aBw4cUEFBAYEdgJdiY91vT083ZJqSwf1iAAAAAAAAAAAAAAAAAAAA1AAnPBC51I4cYVItAABAZenbt78WLfpZW7ZskiQdPnxIU6a8pmeeGVLiPps3b9LMmTOcbavVqsGDRyo4OLjC6wUAeIcQBtRI27dvP2W/zWbT33//rb///lvvvPOO7r77bj3yyCOyWq1uj5eSkuLSLm0IQ926dRUUFCSbzSZJcjgcSk9PV4MGDUp1HF8LCXH/uoHKFhR06v8m69Uz3AYs2O1SQYFVMTEVVBgAAICXSrqeAQAAqA64lgEAANUd1zMAAKC643oGAACcyGp1P3/WnZQUq0JCypHiUAZcywAAgOqurNczISFWjRw5WgMG3K6ioiJJ0v/+97UuueRSnXXW2cXG22xFGj9+jOx2u7Ovf/8BOv30jmUr3I2srCzt2LFdu3fvUlZWloqKihQdHa24uDi1b99BDRsm+Pyc/paTk6MtWzZrz57dysrKUmFhocLCwhQTE6OGDROUmNhCderU8XeZAKqBGhPCcN111+niiy9W79691a5dO3+Xg2ogPz9fb775platWqW3335bkZGRJY7Nzc11aYeHh5fqXIZhKDQ01BnCIB17Mwfgndq1TY9j0tIMxcR4HgcAAAAAAAAAAAAAAAAAAABUdSesySu1I0fKmN4AAACAMmnVqrXuvvteTZ36liTJNE2NHTtGn332ZbG1iB988L62b9/mbCcmttC99z7gs1q2bNmsBQt+0PLlS7Vt21aZZsnrrRo1aqxbb+2rf//7eoWFhbk9rs1WpPvvv0fr169z9l177fUaMmS4V3UdPHhA/fv3VWZmprPv+efH6dJLLy82dvToEZo371tne86ceUpIcB8YsXnzJr3//rv644/fnWEYJUlIaKTzzuupG264SS1atPSqfgCBx+LvAnxl06ZNmjx5sq677jpddNFFeuGFF7Rs2TI5HJWb3gj/MQxDXbp00RNPPKEPPvhAv/32m/7++2+tW7dOv/32m95++23dcsstCg0NddlvxYoVevLJJ12So052cgjDycfwxskXIScfE0DJYmM9j0lLq/AyAAAAAAAAAAAAAAAAAAAAgEpRnqUQhw8TwgAAAFDZBgy4S23atHW2DxzYr8mTX3MZs2PHdk2f/p6zbbVaNWLEaIWEhPikhi++mKn+/fvq44+na+vWLW4DGCRp//59evXVlzVgwO3au3eP27FBQcF6/vkXFRUV5eybM+cr/fjjDx7rstlsGjZssEsAw9VX//uUAQxl8eGH7+vOO/tp0aKfPQYwSMf+bb788nP98MP3Pjk/gJopyN8F+Jppmjpw4IA++eQTffLJJ4qJiVGvXr3Uu3dv9erVSxEREf4uERXgvPPO01VXXaXExMRTbm/QoIEaNGigCy+8UA8//LCeeOIJrV692rl90aJF+vTTT9W/f/9T7l9QUODSDg4OLnWNJ18I5efnl/oYQKCqXdv9Bb8kpaYakjyPAwAAAAAAAAAAAAAAAAAAAKo6D+vl3EpOPhbiYKkxj+0EAKB6yirMUkpesr/LqDHqhNdVdEi0v8soUVBQsEaMGK0BA/rJbrdJkmbN+kIXX3yJunTpKrvdrjFjRrqEBPTt208dOnT0WQ2FhYXF+iIjI1W3bj1FRUXJbrcrLS1Nhw8fchmTlLRT999/jz755HPVrl27xOM3atRIQ4eO0ODBzzr7xo17Qe3bd1CjRo1L3O/tt6do3bq1znZiYqKeeWZQaV5aib755mtNmfJGsf7IyEg1bJigsLAwFRQUKDMzU0eOHPYYTAEAx9W4EAbDOJbYePwXYUZGhubOnau5c+cqODhY3bt3V+/evXXRRRepXr16/iwVPtS1a1evx8bHx2v69OkaMGCA/vrrL2f/W2+9pRtvvFHh4eHF9gkNDXVpe5OGdLKTL2BOPqY/FBba/V0C4Nbx/0YNQwoPN5WbW3Iq7+HDJv9NAwCAKofrEwAAUJ1xLQMAAKo7rmcAAEB1x/UMAACBLS/PKHMQg80mHTzoUL16/ltgxrUMACCQrU9epzdWT9TOjJ3+LqVGMSQl1mqhx7o+pQ51fRdcUJKyXM80b95K/fvfqenT35V0bJ3r88+P1ocffqovv5ypTZs2Osc2bdpMd911v0+vm2w2h0JCQtSz5/k699yeOuOMMxUfH19sXEZGun755SdNn/6ekpOPSpJSUpL1wgujNX78RLfn+Ne/LtK1196gOXNmS5JycrI1ePAgvfXWe6d8+PWKFcv08ccfOtshIaEaNepFWSwhJb52h8P1OraoyH7KsYWFhXrjjddc+i644CL163eX2rZt51xvfFxubo42bdqopUv/0IIF82W3O7huBVCiGpNr+Nprr+nqq69WTEyMM4DBMAyXUIbCwkL9/vvvGjVqlM4//3zdfPPNmjZtmnbs2OHP0uEHoaGhmjBhgoKC/skhSUlJ0R9//HHK8RERES7tgoKCUp8zPz/f7TEBuFenjvubwKmpJQc0AAAAAAAAAAAAAAAAAAAAANWJw1G+ubFHjjC3FgAAf/jz8Eo98+t/CGCoAKaknRk79fSvj+nPwyv9XU6JBgy4Ry1btnK29+3bo7FjR+v9999x9lksFg0ePMLnD3ru3v1czZ49V2PGvKjLLrvylAEMklSrVqyuvfZGffTR52rb9jRn/+LFvykpyfN/u48++qTLa9y8eaPefvuNYuNSU1P0wgsjnWt+Jemxx1z3LY8//1yhzMwMZ/uyy67UCy+8pHbtTisWwCBJERGROvPMs/TII49r9uy5uvLKa3xSB4CaqcaEMFx66aV66aWXtGTJEk2fPl39+/dXQkKCTNOUaZrFAhkcDofWrVunSZMm6aqrrtKll16qCRMmaNWqVS6/0FFzNWvWTBdddJFL3+LFi0859uTAhLy8vFKdyzTNYsENkZGRpToGEOg8hTAkJ3OjGAAAAAAAAAAAAAAAAAAAADWDw1G+/Y8eZW4tAACVzTRNvb/uHdkcdn+XUqPZHHZ9sP7dKrsONDg4WIMHj5TVanX2/fzzjyos/Gd94U033apOnTr7/NwtWrRUXFxtr8fHxMRo1Kixslj+WWo8f/63HvcLDQ3VmDHjFR4e7uz7/PNP9ccfvzvbDodDY8YMV2pqirPvggt669prb/C6Pk/27t3j0r7uupu83jc4OFiNGjX2WS0Aap4aE8JwnNVqVffu3TV06FAtXLhQc+bM0SOPPKLTTjvNGcggySWQwTRN7d692xnecN5552nIkCFauHBhsYXzqFm6d+/u0k5KSjrluDp16ri0Dx06VKrzJCcny2azOdsWi0VxcXGlOgYQ6AhhAAAAAAAAAAAAAAAAAAAAQKCwl3Pt5pEjzK0FAKCy5RRla2vaFn+XERC2pG5WTlG2v8soUbt2p+m22+445bbGjZvo/vsfruSKStakSVOddloHZ3vdurVe7desWXM98cSzLn3jxo3S0aNHJEkzZkzXqlUrnNsaNkzQc88N90HF/zh5/W9QUJBPjw8gsNW4EIaTtWvXTo888oi++uor/fLLLxo2bJh69Oghq9XqEshgGIYzkCE1NVVff/21HnnkEXXv3l0DBw7UV199pdTUVD+/Gvhaw4YNXdol/RsnJia6tA8ePFiq85w8PiEhQaGhoaU6BhDo6tZ1H8KQksKNYgAAAAAAAAAAAAAAAAAAANQMDkf59ieEAQAAwL/uuus+NW/ewqXPMAwNHjxCoaFhfqrq1Bo2THB+v22b90EiV1xxtS699HJnOyMjQ6NHD9OaNav13ntTnf1BQUEaNWqcoqKifFPw/6tbt55Le8GC73x6fACBLaBiXRo2bKh+/fqpX79+ysrK0qJFi7Rw4UL9/vvvysnJkXTsTew40zSVl5enn3/+WT///LMsFovOOOMM9e7dWxdffLGaNm3qr5cCHzk52chms51yXIsWrhc727dvL9V5duzY4fZ4ADzzJoTBNCWD+8UAAAAAAAAAAAAAAAAAAACo5sobwnD4cI1/ZicAAFVOZHCU2sS11dY07xexo2za1m6nyGDfLuj3tZCQEN1yy22aMOEFZ1/Hjqerc+culXL+1NQU/fzzj9qwYb127NimtLQ05eTkqLCwwO1++fn5KijI9zoo4qmnBmvDhg3at2+PJGnNmtV64omBstvtzjH33feQOnToWPYXU4KuXbvJarU6z/X555+qoKBQffv2U6NGjX1+PgCBJaBCGE4UHR2tq6++WldffbUKCwu1bNkyLVy4UD///LOOHj0qqXggg91u1+rVq7V69Wq9/PLLatmypXr37q3evXvr9NNP99dLQTkkJye7tGvXrn3Kca1atVJwcLCKiookSfv379eRI0dUv359r86zevVql/Zpp51WhmqBwFanjvsQhvx8Q7m5UmRkJRUEAAAAAAAAAAAAAAAAAAAAVJAT1qyVyeHDPNkMAIDKZhiG7u50n4YtHiSbo5xv5ihRkMWquzve57L+s6qyWq1u2ydKStqp5OSjXh03MbGl6tate8pt6enpevPN1/TDD9+5BCGURlZWttchDBERERozZpwefPBuFRYWSpJzHaYknX12D9122x1lqsOTBg3idcUV1+jbb7929s2ZM0tz5sxS27anqVu3s3XGGV3UoUMnxcTUqpAaANRcARvCcKKQkBD16tVLvXr10ujRo7V27VotXLhQCxcu1Pbt253jjr8pm+axhcDbt2/Xjh07NG3aNNWrV08XXnihevfurR49eig4ONgvrwWl8+eff7q04+PjTzkuKipK3bp109KlS519S5Ys0bXXXuvxHKZpasmSJS59F154YemLBQKcpxAGSUpONhQZ6XkcAAAAAAAAAAAAAAAAAAAAUJU5HOXb/+BBQ6YpVYO1iQAA1ChnNjhLr5z/ul5f/aqSMnaKVS6+Y0hKrNVCj3V9Sh3qdvR3OT736acfaf78uV6NHTJkpK644upi/fv379Ojjz6gI0cOl6uWoqLCUo1v06adBg78jyZNetmlv06duho+fHSFBmY8/vjTSk1N1h9//O7Sv2XLJm3ZskmffPKhDMNQq1at1b37eerT5zK1aNGywuoBUHMQwnAKp59+uk4//XQ98cQT2rNnj3766SctXLhQf/31lxz/fyfj5ECGI0eO6IsvvtAXX3yhiIgI9ezZUxdffLEuuOACRUdH++21oGSZmZlasGCBS1+PHj1KHH/RRRe5hDDMmjXLqxCGZcuWad++fc523bp11blz59IXDAQ4b0IYUlIMNWvGx1MAAAAAAAAAAAAAAAAAAABUb2V8aLFTfr6h9HQpLs4n5QAAgFLoULejpl7ygbILs5Scl+zvcmqMuuF1FRXCWs2SFBUV6emnHysWwNC4cVN16dJVTZo0U7169RQeHq7Q0FAdi7U45rPPPtaKFcvKdf7c3LxifYmJLRQbW7EXpKGhoRo/fqJ++ukHffrpR9q2bWuxMaZpatu2rdq2bas+/vgDnXtuTz322FNq3LhJhdYGoHojhMGDpk2b6u6779bdd9+t1NRU/fLLL1q4cKGWLFmi/Px8SXJJ4TFNUzk5OVqwYIEWLFggq9Wqbt266eKLL1a/fv389TJwChMmTFBmZqazHRwcrF69epU4/sorr9SkSZOUm5srSVq5cqWWLl3qNrjBNE1NmTLFpe/666+XxWIpZ/VA4Kld27sQBgAAAAAAAAAAAAAAAAAAAKC6czjKPy/2wAGL4uIcPqgGAACURVRINKEBqDRz5szW3r17nO3atetoyJCR6t79XI/7zp37TbnOvX79Wr377lvF+letWqHPP/9Et95asWtrDcNQnz6XqU+fy5SUtFMrVy7XX3/9qXXr1ig9Pb3Y+CVLFmvNmr/08sv/VefOXSq0NgDVFyEMpVC7dm3dcMMNuuGGG5Sfn6/Fixdr4cKFWrRokdLS0iQVD2Sw2WxatmyZli9fTghDBZk2bZrOPfdcdezY0avxNptNr7zyimbNmuXSf+utt6p+/fol7lenTh3dfvvteuedd5x9w4YN06effqoGDRqccp+pU6dq5cqVznZ0dLTuuecer+oE4Co4WIqNNZWeXvINZUIYAAAAAAAAAAAAAAAAAAAAUBM4fJCdcOiQoQ4dyn8cAAAAVLyhQ0dp6NBRZd5/4cIFLu1x415Wx46ne7VvVlam50El7pulUaOGym63n3L71KlTdMYZZ6pdu9PKfI7SSExsocTEFrr55r4yTVO7d+/SihXLtGjRQq1du8Y5Ljc3R8OGDdLnn89RREREpdQGoHqx+LuA6iosLEwXX3yxXnzxRf3xxx+aMWOG7rrrLjVp0kSmaco0jz2x/cRQBlSM33//XTfccINuvfVWffjhh9q6datsNluxcVlZWZo7d65uvPFGffDBBy7bmjZtqoEDB3o817333qt69eo52/v27VPfvn21cOFC57+5JB06dEgjRozQpEmTXPZ/8MEHFRsbW8pXCOC4OnVMt9uTk/mdCwAAAAAAAAAAAAAAAAAAgOqvhDVsLiIj3c+tPXiQJSMAAACBwOFwaNOmDc5269ZtvA5gkKSkpJ1lPveECc/r0KGDznb37ufqzjvvdbaLioo0atQQ5ebmlPkcZWUYhpo3T9TNN/fVm2++qylT3nFZ35mWlqoffviu0usCUD0E+buAmsBisahbt27q1q2bBg0apG3btmnhwoX66aeftGHDBs8HgE/89ddf+uuvvyRJISEhio+PV3R0tCwWi9LT07V//345ThEHWq9ePb3zzjuKi4vzeI7Y2FhNmjRJ99xzjwoKCiRJ+/fv18MPP6yYmBg1btxYmZmZOnjwYLHkpt69e+uee+7xwSsFAlfduqZ27Ch5e0oKN4oBAAAAAAAAAAAAAAAAAABQ/Z1i6nsxjRqZ2rq15IeYHTzIA84AAAACQUZGhst6xqZNm3m97549u3X06JEynffrr2dp0aKfne06depq6NDRiomJ0Zo1q7VmzWpJ0r59e/XKK+M1YsTzZTqPr3Tu3EUPPviIxo9/wdm3du0aXXfdjX6sCkBVxWrVCtC6dWs9+OCDmjVrlhYtWqQRI0bovPPO83dZAaWwsFB79uzRhg0btG7dOu3du/eUAQznn3++vvnmGzVv3tzrY5911lmaOnWqS+KRJGVmZmrjxo3at29fsQCGq666Sv/9739lGNzEAsqjTh33ab0pKfx/DAAAAAAAAAAAAAAAAAAAANWfpxAGw5ASEtwPOnSIubUAAACBwXXNVVGRzes9v/56VpnOuGPHdr3xxiRn22KxaMSI5xUXFyer1aoRI55XrVq1nNsXLJiv7777tkzn8qVOnc5waWdkpPulDgBVHyEMFaxBgwa67bbb9O677/q7lBrrwQcf1K233qrWrVvLarV6HB8REaHLLrtMM2bM0LRp01SnTp1Sn7NHjx6aN2+e+vbtq/Dw8BLHtW/fXm+88YZeffVVhYSElPo8AFx5CmFITuZGMQAAAAAAAAAAAAAAAAAAAKq/k54LWIzFIjVs6H5u7YEDLBkBAAAIBDExtVzWVm7YsE42m+cghm3btujrr78s9fny8/M1cuRgFRYWOPv69btTZ555lrNdv34DDR480mW/SZNe0p49u0p9Pl9KT093aUdHR/unEABVXpC/CwDK67zzztN5550nScrLy9P27du1f/9+HT16VLm5uXI4HIqJiVFMTIxatWqlNm3aeBXW4EndunU1atQoPffcc/rrr7+0Y8cOZWZmKjg4WA0aNFDnzp3VrFmzcp8HwD88hTCkphpyOI7dVAYAAAAAAAAAAAAAAAAAAACqK4fD/XZvQhhSUgwVFko8TxAAAKBms1qtat++o9at+1uSlJKSrJkzZ6hfvztL3Gffvr167rmnvAprONnEiRO0a1eSs92pU2fdc88Dxcb17NlLN954q2bNminp2PrPkSOHaOrU6T556PU777ylpk2bqXfvSxQU5Hm5tGmamjlzhktf27anlbsOADUTIQyoUcLDw9WpUyd16tSp0s4ZFhamHj16qEePHpV2TiBQeQphsNuljAwpLq6SCgIAAAAAAAAAAAAAAAAAAAAqgOcQBlMNG7ofZJrSoUOGmjZ1PwcXAAAA1d9ll13pDGGQpKlTpyg9PV23336H4uJqO/vT09M1f/5cffjhu8rOzpZhGGrSpKn27Nnt1Xl+/PF7fffdt852dHSMRo4cW+KDsx9++DGtXfuXtm7dIknatm2rpkz5r5544tmyvEwXO3du14cfvqfJk/+r88+/UD17nq/TTmuvWrViXcY5HA6tW7dWH3wwTatWrXD2h4WFqU+fy8pdB4CaiRAGAEC1Ua+eh7vJOpbYGxfHjWIAAAAAAAAAAAAAAAAAAABUX3a74Xa71So1bOh5zuzBgxY1bWr3VVkAAACooq688hrNmTNL27ZtlSSZpqmZM2foiy8+VePGTRQVFa3MzAwdPHhAdvs/14f9+t2p5OSjXoUw7N+/Ty+//KJL33PPDVd8fHyJ+4SEhGjUqHG6557+ysvLlSTNnv2FzjrrHPXseX5ZXmoxaWmpmjNntubMmS1JqlOnrmJjYxUWFq78/DwdOHDAee4TPfLI46pXr75PagBQ8wR8CMPhw4e1ePFibdy4UUlJScrMzFRWVpZsNluZj2kYhn766ScfVgkAkKTatT3fKE5OtqhVK24UAwAAAAAAAAAAAAAAAAAAoPpyeHh2mdUq1atnKihIcrf84dAh92EOAAAAqBmCgoL04osT9fjjD2vfvj3OfofDUWLAwi233K77739Y48aN9nj8oqIijRw5RLm5Oc6+6667Seeff6HHfZs2baYnn3xWY8eOcvaNGzdG06d/qvr1G3jcv7RSUpKVkpJc4vbQ0FA9+uiTuvbaG3x+bgA1R8CGMKxdu1avv/66li5dKscJdydMs/xPTzcMblIAQEWoVUsebxSnpPA7GAAAAAAAAAAAAAAAAAAAANWbpxAGw5AsFqlBA4f277eUOO7AAebWAgAABIr4+Hi9++5HeuedN/Xtt9+osLDglOM6dOike+55QGef3d3rY7/99hvavHmjs92yZWs98sjjXu9/+eVXadWqFfrhh+8kSZmZGRo9ephef/1tWa1Wr49zomefHaaePc/X0qWLtXbt30pNTXE7Piamli666GL163en4uMblumcAAKHYfoidaCaeemll/Thhx/K4XAUC10ob4CCaZoyDEObNm0q13GAynD0aJa/SwBchIS4XjAXFtqLjbn99nAdOVLy7+r+/Yt0xx1FPq8NAADAG95czwAAAFRVXMsAAIDqjusZAABQ3XE9AwAATvTVV0F6662QErfHxpr68ss8DR4cqlWrSl601qOHXWPGnHrxnS9xLQMAAKq7mnY9k5ubq7///kv79+9Vdna2QkPDVL9+A3Xo0Enx8fH+Lq9CHDiwX3v27NahQweVk5OtoqIiRUREKDY2Ti1atFLz5okKCqo5z7avVy/a3yUANVrN+W3hpdGjR2vmzJnO8IWTQxcCMJMCAKqVOnVMtyEMR4+S1gsAAAAAAAAAAAAAAAAAAIDqzeFwv/34w4IbNnS/BuLQIebWAgAABKKIiAj16HGev8uoVAkJjZSQ0MjfZQCoIQIqhOGXX37RZ599JsMwXMIXTNNUcHCwEhMT1ahRI0VGRio4ONiPlQIASlK3rkOSpcTthw9zoxgAAAAAAAAAAAAAAAAAAADVm93Dg5ePhzDEx7tPa9i/3yKHQ7KUPP0WAAAAAACcJKBCGCZOnOj83jSPpT22atVKDz/8sC666CKFhYX5qzQAgJcaNHCf1nvkCCEMAAAAAAAAAAAAAAAAAAAAqN5M91NmnaEKCQnuBxYWSkePGh7n4AIAAAAAgH8ETAjD7t27tW3bNhmGIdM0ZRiGLr74Yk2cOFHBwcH+Lg8A4CXPIQyk9QIAAAAAAAAAAAAAAAAAAKB6s9vdP5jMYjk2p7ZxY4fHY+3bRwgDAAAAAAClETBLVNeuXevSrlOnjsaPH08AAwBUM55uABcVSenplVMLAAAAAAAAAAAAAAAAAAAAUBHsdvfbjz+wLCHB9Pjwsn37AmbpCAAAAAAAPhEwn6RTUlKc3xuGoSuuuEKRkZF+rAgAUBb163tO6z18OGDe3gAAAAAAAAAAAAAAAAAAAFADOTxMmbVaj/1vSIjUoIH7wXv2MLcWAAAAAIDSCJhP0oWFhZIk0zz2BPV27dr5sxwAQBk1aGB6HHP4sFEJlQAAAAAAAAAAAAAAAAAAAAAVw9sQBklq0sT9/Np9+5hbCwAAAABAaQRMCEOtWrVc2hEREX6qBABQHlFRUkSE+xvFhDAAAAAAAAAAAAAAAAAAAACgOrPb3W83Tpgu27ix+8SGffsCZukIAAAAAAA+ETCfpFu2bClJMv7/TkNqaqo/ywEAlEODBu5DGI4cCZi3NwAAAAAAAAAAAAAAAAAAANRADve5CrJa//m+SRNPc2sN5ef7oCgAAAAAAAJEwKxSPf300xUREeFsb9y40Y/VAADKw3MIg+F2OwAAAAAAAAAAAAAAAAAAAFCVeQphsJywGqRJEw+DJe3fz/xaAAAAAAC8FTAhDCEhIbr88stlmqZM09SiRYtUWFjo77IAAGVQv777EIbDh7lJDAAAAAAAAAAAAAAAAAAAgOrLbne/3Wr9Zz5t48bu59ZK0t69AbN8BAAAAACAcguoT9EPPfSQwsLCZBiGUlJSNH36dH+XBAAog/r13af1EsIAAAAAAAAAAAAAAAAAAACA6szhcD8f1mr95/vatU2Fh7sPYti3L6CWjwAAAAAAUC4B9Sm6cePGGjJkiEzz2M2F119/XYsWLfJvUQCAUmvQwP1N4txcQ9nZlVQMAAAAAAAAAAAAAAAAAAAA4GMO988sk2G4ft+kiacQBh5yBgAAAACAtwIqhEGSbr75Zj366KMyTVN2u12PPPKIJk+erPz8fH+XBgDwkqcQBkk6fJgbxQAAAAAAAAAAAAAAAAAAAKie7Hb32y0nrQZp0sR9asPevQG3fAQAAAAAgDIL8ncB/jBw4EA1adJEI0eOVF5enqZMmaKPP/5YV1xxhbp166amTZuqVq1aCgoq+48nISHBhxUDAE7UoIGHaF9JR45Y1LKlh7vPAAAAAAAAAAAAAAAAAAAAQBXk8DBd1mp1bTdp4v4hZ3v3GjJNyeA5ZwAAAAAAeBSQIQySdM0116hjx47q37+/UlJSlJGRoZkzZ2rmzJnlPrZhGNq4caMPqgQAnEpsrBQcLBUVlTzm8GHuEAMAAAAAAAAAAAAAAAAAAKB6snt4FtnJIQyNG7tPbcjLM5SSYqhuXfdhDQAAAAAAQLL4uwB/sNvtev/999W3b1+lpqbKMAwZhiHTNH32BQCoOBaLVL+++xvFhDAAAAAAAAAAAAAAAAAAAACguvK0LME4aapskybu59ZK0u7dzK8FAAAAAMAbQf4uoLJlZmbqkUce0cqVK51hCcb/330wTr4LUQYEMABA5ahf39T+/SVvJ4QBAAAAAAAAAAAAAAAAAAAA1ZXd7n671erabtzYlMUiOdxkMSQlWXTmmZ7DGgAAAAAACHQBFcJgt9s1cOBArVy5UpJr6ALhCQBQvTRo4P739uHDlkqqBAAAAAAAAAAAAAAAAAAAAPAtu939A8ksFte5tCEhUkKCQ/v2lTyHNimJ+bUAAAAAAHgjoEIYZsyYoZUrVxYLX7BarerSpYtOO+00NWrUSJGRkQoKCqgfDQBUO55CGA4dcn/jGQAAAAAAAAAAAAAAAAAAAKiqHA73263W4n2JiYQwAAAAAADgCwGTNOBwOPT+++87AxhM89ji3ZtvvlmPPfaY6tat68/yAACl1LCh+zvLmZmGsrKk6OhKKggAAAAAAAAAAAAAAAAAAADwkbKFMJj6/feS99m1yyKHQ7KQxQAAAAAAgFsB89F5/fr1Onz4sKRjAQyGYejJJ5/UmDFjCGAAgGqoUSPT45j9+wPmbQ4AAAAAAAAAAAAAAAAAAAA1iN3ufvv/P5/SRWKi++SGoiLpwIFT7AgAAAAAAFwEzOrUzZs3u7RbtWql+++/30/VAADKq1EjD/G+4iYxAAAAAAAAAAAAAAAAAAAAqieHh6myVmvxPk8hDJKUlBQwy0gAAAAAACizgPn0nJ6eLkkyTVOGYejSSy/1b0EAgHKJjpaio023Y/btC5i3OQAAAAAAAAAAAAAAAAAAANQgnkIYLKeYJtuwoanQUPfzawlhAAAAAADAs4D59Gw56Q5DkyZN/FQJAMBXGjVyf5P4wAGjkioBAAAAAAAAAAAAAAAAAAAAfMdud7/dai3eZ7FIzZoRwgAAAAAAQHkFzKfn2rVru7SDg4P9VAkAwFcaNXIf8bt/f8C8zQEAAAAAAAAAAAAAAAAAAKAGMd1nKchSwjTZxET382uTknjIGQAAAAAAngTM6tQ2bdpIkgzj2A2Do0eP+rMcAIAPJCS4v7u8fz83iQEAAAAAAAAAAAAAAAAAAFD92O3u58FaLKeeR+sphOHAAYvy88tcFgAAAAAAASFgQhg6dOig2rVrO9urVq3yYzUAAF9o3Nj9TeKsLENZWZVUDAAAAAAAAAAAAAAAAAAAAOAjdrv77ZYSVoN4CmEwTWn37oBZSgIAAAAAQJkEzCdnwzB04403yjRNmaapxYsXKzk52d9lAQDKISHh1Am+J9q/P2De6gAAAAAAAAAAAAAAAAAAAFBDONxnKSgo6NT9nkIYJCkpyShDRQAAAAAABI6AWpl63333qV69ejIMQ/n5+XrxxRf9XRIAoBwaNfJ8k3j/fm4SAwAAAAAAAAAAAAAAAAAAoHrxFMJgKWE1SFycFBvr/kFn27ZZy1gVAAAA4F+rV69Sz57dnF/vvTfV3yUBqKECKoQhOjpakyZNUnBwsCTpu+++00svveTnqgAAZRUdLcXEuL9JvH9/QL3VAQAAAAAAAAAAAAAAAAAAoAbwFMJguHlOWcuW7nfeupX5tQAAAAAAuBPk7wIqW7du3TR16lQ99thjysrK0gcffKB169bpqaee0hlnnOHv8gAApZSQYCozs+S7yAcOuLnDDAAAAAAAAAAAAAAAAAAAAFRBdrv77VZrydvatHHozz9LHrBjh0U2mxQUcCtKAAAAfGvs2FGaP39uhR3/9dffVteu3Srs+ACAkgXUR+Y5c+Y4vx8wYICmTZumwsJCrVq1Sn379lViYqK6deumZs2aKSYmRsHBwWU+17XXXlv+ggEAHjVq5NDmzSWn8e7bR1IvAAAAAAAAAAAAAAAAAAAAqhdPIQwWN1Nk27RxuN23qEjavdtQy5ZmGSoDAAAAAKDmC6gQhueee06G4fpEdMMwZJrHbhzs3LlTSUlJPjkXIQwAUDkSEtzf/D1wwHC7HQAAAAAAAAAAAAAAAAAAAKhqHO5zFGS1ljyH1lMIgyRt3WpVy5a20pYFAACASnTyelgAQOUJqBCG446HLhx34hvRydvKgjc2AKg8jRu7v0mclWUoM1OKiamkggAAAAAAAAAAAAAAAAAAAIByMk336xIslpK31atnKjbWVHp6ycfYutWiyy8va3UAAACQpNtuu0OXXFL+i6qDBw/olVdelOOEJK527dqrQ4dO5T52TdO1azctXrzK32UACAABGcLgLiShvAEKvghxAAB4r1Ejz793d++2qFMnz4m+AAAAAAAAAAAAAAAAAAAAQFVgs7nf7i6EwTCkNm0cWrHCWuKYrVvdHAAAAABeSUxsocTEFuU6RkFBgd566w2XAIaYmFp64YUJCgkJKW+JAIAyCrhPzaZpVugXAKByNWniOVxh166Ae7sDAAAAAAAAAAAAAAAAAABANebwMEXWWnK+gqRjIQzu7NxpUWFhKYsCAACAz02a9JK2bt3sbFssFo0Y8bzi4xv6sSoAQJC/C6hMCxcu9HcJAAAfi4iQGjQwdfiwUeIYQhgAAAAAAAAAAAAAAAAAAABQnVR0CIPNdmyOradxAAAAqDhz587R3LnfuPTdeee96t79XD9VBAA4LqBCGBo1auTvEgAAFaBZM4cOHy75TvKuXSUHNAAAAAAAAAAAAMD3Duce1oGsfQqyBKlD3U6yGIRmAwAAAAAAlIanEAaLh9strVt7DlfYupUQBgAAAH/ZsmWzJk582aXvnHPO1Z133lsp57fZbNqzZ5eSkpKUmpqi3NwchYeHKzo6Rs2aNVebNu0UFFSzliA7HA7t2rVT27dvV3p6mnJzcxQcHKzw8AjVr99AjRs3UdOmzWTxdLENICDUrN+AAICA1Ly5QytWuAthsMg0JYMsBgAAAAAAAAAAgApVaC/UlL9e0/e75slhmpKkeuH19PRZz6lrg25+rg4AAAAAAKD6KG8IQ926purUMZWSUvIE2i1bLLrqqjIUBwAAgHLJzMzQsGHPqrCwwNnXsGGCRo58vkIDANLT0/Xzzz9qyZLf9fffa5SXl1vi2PDwcPXufYn69btTjRs38XjsL7+cqddee8XZrlu3nqZP/0yxsbFe1TZ06DP69ddfnO2zz+6hV199XcZJC8JWr16lxx570Nm+6677dM89D7g9dk5OtmbM+FDfffetUlKS3Y6NjIxU585ddemll6t370u8qh1AzUQcCwCg2mve3P1d5sxMQ+nplVMLAAAAAAAAAABAIJvy12v6LmmuM4BBko7mHdXwPwZrQ/J6P1YGAAAAAABQvdjt7rd7szavdWv3c2w3bmRJSWk5TIdWHFyu11dP0rtr39ayA0tknnAvDAAAwBPTNDVmzHAdPHjA2RcSEqLnn5+gmJhaFXbezMxM/fvfl2rixAlatmyJ2wAGScrLy9Pcud/ojjtu0Xfffevx+DfddKv+9a/zne3k5KMaO3akV9dKs2d/4RLAUKdOXQ0fPrpYAENZbNu2VbfffpM+/vgDjwEMkpSTk6MlS37X5Mn/Lfe5AVRvQf4uAACA8mre3PPF+K5dFsXFeYgEBgAAAAAAAAAAQJkdzT2q75LmKmfn6UpbfqXyDyfKElyg6PZLVLv7t3pl1XhN7fO+Qqwh/i4VAAAAAACgyrPb3S84s1g8z59t186hZcusJW7fs8eijAypVsWt9atRCuwFGvL7M1p79G9n3+dbPtPZ8edo5LkvcN8LAFBMdraUnFz+ReQ4pm5dU1FR/q6i/D744B0tW7bEpe/xx59Ru3anVeh5HQ6H7CclfVmtVtWvH6+oqEgFB4coJydbBw8eUGFhoXNMYWGhxo07Fohw+eVXuT3H4MEjtGXLbTpy5LAkaenSP/TZZzN02239S9xn27atmjLlv862xWLR8OFjFBdXuwyv0lVqaooef/whZWRkuPRbrVbFxzdUTEyMJCk7O1uHDx9WYWFBuc8JoOYghAEAUO01aeKQYUjugtF27bKoSxdCGAAAAAAAAAAAACrKuuS/lbX5bB385jFnn6MgQmkrrlTOjs4yBozQZ5tnaECHu/1YJQAAAAAAQPXg8DDtNciL1SAdOtglBbsds3GjVT162N2OwTFvrJ7kEsBw3IpDy/Xppo91Z8d7/FAVAKAqWr/eojfeCNHOnRZ/l1KjGIaUmOjQY48VqkOH6rlGaPnypZo+/V2XviuuuFrXXHNdpdXQrl17nX/+hTr77B5KTGyhkBDXICmbzaY1a1br008/1ooVS539Eye+pK5du6lBg/gSjx0TU0ujRo3Vo48+4Ax8mDZtis44o4vat+9YbHxeXp5GjhzsEvrQr9+d6tbt7PK+TEnSBx+86xLAkJDQSPff/7DOO6+XwsPDXcba7Xbt2bNbK1Ys1aJFC3X48GGf1ACg+uJdHABQ7YWFSQ0buv/wtHs3b3kAAAAAAAAAAAAV6Uhmug7Ne+CU2wpTGiv511s0c/MM7cpIquTKAAAAAAAAqh9PIQwWL6bGtm3rkNXqfsz69cyx9UaRvUi/7VtU4vbPt3yqrMLMyisIAFBl/fmnRc88E0YAQwUwTWnnTouefjpMf/5Z/X6+hw4d1Jgxw+Q44UKvdes2euqp5yrl/OHhYXr77Q/07rsfqX//u9S2bbtiAQySFBQUpG7dztbEiW/o3nsfdPbn5eVq9uwvPJ7n9NPP0D33/PM3Q5vNppEjhyo7O7vY2FdfHa89e3aXuG95LVq00Pl9bGycpk79QBdffGmxAAZJslqtSkxsoVtuuV1vvfW+Jk6c7LM6AFRP1e+dBgCAU2je3HS7PSmJtzwAAAAAAAAAAICKtHNLtExbaInbM9ZcpILscI1aMkyZBRkljgMAAAAAAAh0puk5hMEwPB8nPFxq1cr9gdav95DSAEnS7sxdyrPllbjd5rBpwa7vK7EiAEBVZJrS+++HyGbzdyU1m80mffBBiEz3S4mqlMLCQg0bNkgZGf/8jSwqKlovvPCSQkNL/vuaL4WGhqljx06l2ufOO+9V585dnO358+d6tV+/fneqW7ezne2DB/dr/PjnXcZ8//08ff/9PGc7JqaWRo58QVZPKWJeysrKUlpaqrN9wQUXKS6uttf7N2+e6JM6AFRf1X5F6vbt2/1dgtdsNpt2797teSAAoNSaNXN/g3j3bqNafbgCAAAAAAAAAACobg4fcD9BzLQHK31Nb+3P3qeRS4aq0F5YSZUBAAAAAABUL97MefV2bVrHjna327dutaigwLtjBbKcouJPbj7Z/3bMqfhCAABVWk7OsfdWVLwtWyzKyfF3Fd6bNOllbd680dk2DEPDh49Ro0aN/ViVd/r0ucz5fVpaqvbt2+txH4vFohEjnlft2nWcfYsWLdScObMkSXv27Narr05w2Wfw4OFq0CDeR1VLBSdd5AYFBfns2AACQ7V/R//3v/+tESNG6OjRo/4uxa3vvvtOV1xxhb799lt/lwIANVJiovsQhpwcQ8nJXkT+AgAAAAAAAAAAoExycz2PyVjdR6Y9SOuT1+nllS/KYXp4pCMAAAAAAEAAsrvPTZBUmhAG9/dfbDYWi3oj1+b55teB7P06mH2gEqoBAADVybx5/9O3337t0te//10677x/+ami0klIaOTS3rp1i1f71a5dR8OHj5Zh/LOe6/XXJ2nTpg0aOXKw8vL+ub668cZb9K9/XeCTeo+LjY1VcHCws/3HH4uVne05WAsAjqv20S12u11ffvmlvv32W9188826++671aBBA3+X5fT9999r2rRp2rRpk79LAYAarVkzzxP0kpIM1avnRTQwAAAAAAAAAAAASi0v3/Pfa2w5scradI5iOv6hRXt/VsOoBN3d8b5KqA4AAAAAAKD6cHiRW2nxMjehQwfPiQ7r11vUqRNhme7k2fK8GvfTngXq3/7Oii0GAFBlRUZKbdo4CDiqBG3bOhQZ6e8qPNu6dbNefXWCS1+3bmfr3nsf9FNFx9hsNi1btkQrVy7T9u3bdODAfuXk5CgvL1em6X7tVUZGutfnOeus7urX7059/PEHkqTCwgI9/PC9Kioqco5p06atHn74P2V6He4EBQXpjDO6auXK5ZKkgwf367HHHtADDzyis846RxZvL6gBBKxqH8JwXF5enj766CN9+umn+ve//62+ffuqQ4cOfqklOztb33zzjT7++GPt3r1bkmSapktiDwDAt5o0MWW1uk/+3b7dorPP5gYxAAAAAAAAAABARcjP9+5v4mkrr1B0+yUyLKY+2zRDDSLidWWLqyu4OgAAAAAAgOrD3XzY47xdMxYXJzVq5ND+/SXvsH69VZLNuwMGqNyiXM+DJP20e4H6nTaA9SMAEKAMQ7r77kINGxYmG2+tFSYo6NjPuaq/3WZmZmro0EEqLCxw9tWv30CjRo0rdQBAZmamtmzx7kHh0dExatfutFNuM01T8+Z9o6lT31RaWmqpajguOzurVOPvuecBrVnzp9atWytJLgEM4eERGjVqnEJCQspUiyd33nmv/vxzpRz/n3K2desWPfXUo6pdu47OOaeHunQ5Ux07dlLTps0r5PwAqrdqH8LQtWtXrV692vkBtaioSLNnz9bs2bPVvn173XTTTbrkkktUu3btCq3D4XBo+fLl+vbbbzV//nzl5+c7E3+O1xYWFqb27dtXaB0AEKiCg6WmTR1KSir5Q8iWLdwgBgAAAAAAAAAAqCh5+d6NKzjSTFmbeiimwxJJ0hurJyqxVgu1r+OfBy0AAAAAAABUNQ4vnjlmsbh/QvGJOnZ0H8Kwbp1FdrtktXp9yICTb8/zatyB7P3akLJeHet2quCKAABV1ZlnOvTKK/l6/fUQJSVZZHr/lg0PDENKTHTosccK1aFD1X5Iq2maeuGFETp4cL+zLzg4WM8/P0GxsbGlPt727Vv1xBMDvRp7xhldNXnytGL9DodDY8eO1A8/zC/1+U9UWFhYqvFBQUEaOXKc7rrrNmVlZbpse+qpQWratFm56nGnc+cuGjRomF555UWX8IfU1BTNnz9X8+fPlSTVqVNHZ555ti66qI+6dz9XQUHVfuk1AB+o9r8JPv30U3399dd69dVXlZyc7Aw8ME1TGzZs0MaNG/X888+ra9euuvDCC3X22WerQ4cOPkkVTE5O1vLly7VkyRL9/PPPSk9Pd55bOha+YJqmTNPUJZdcoiFDhig+Pr7c5wUAnFqbNu5DGLZuLV1KHAAAAAAAAAAAALxXmO/93+FTfrtZUW1XyBJkk9106IWlI/V2n/cUE1qrAisEAAAAAACoHrwJYShNYELHjnb98EPJy0fy8gxt3myp8osZ/SnP5l0IgyTN2/k/QhgAIMB16ODQ1Kn5ys6WkpPLv44Rx9Stayoqyt9VeOfDD9/TkiWLXfoeffRJdejQ0U8VSdOnv1ssgCEyMlJdupyptm1PU/36DRQVFa2QkBCXEILt27dpypT/luvcRUWFstlcH6wbHBysTp06l+u43rjyymvUsePpev/9afrtt19cwhiOS0lJ0YIF87VgwXw1bJig++9/WH36XFbhtQGo2qp9CIMkXXfdderTp4+mTZumjz/+WHl5eS5hDHa7XatWrdKqVaskSVFRUWrXrp3atm2rNm3aKCEhQQ0aNFDdunUVERGh0NBQSZLNZlN+fr4yMjJ06NAhHT58WDt37tTWrVu1ZcsW7dmzx1mDeUIk1YnhC507d9aTTz6pc845pxJ/IgAQmNq0ceiHH0renpxsKDVVql278moCAAAAAAAAAAAIFAUF3gdiF2XWVcbqPoo7+9hEr6N5RzV+xQt6oecEWQyCtQEAAAAAQGCz2z2PKU0Iw+mnew5X+PNPKyEMbuQV5Xo99te9v+jhMx5VdEhMBVYEAKgOoqKkqCjT80DUKCtXLtP7709z6bvkkst1/fU3+akiKTU1RZ988qFLX//+d6l//7sUERHhdl+HNwlhbhQVFWnkyCHKy8s9Zf9bb72n4ODgcp3Dk2bNmmv06HHKzMzUypXL9Ndff2rNmr+0e3eSy9pgSTp48IBGjx6mTZs26LHHnqrQugBUbTUihEE6Fqzw5JNPasCAAXrrrbc0e/ZslzAG6Z+ghKysLJdQhlM5HqRQkpO3nRj6YJqm2rdvr4EDB6p3797leVkAEHAcdpt+nztJX/89Q1n2PNULitV15zygM3rdIcPifsJdmzaeL+q3brWqe3cv7kwDAAAAAAAAAACgVEoTwiBJqUuvVUyn32UNz5YkrTy0Ql9vm6Ub2txcEeUBAAAAAABUGw6H5ydme5hW6yIhwVR8vKlDh0o+7urVFt1xh/fHDDR5tjyvxxY5ivTj7h90fWv/LbQEAAD+cejQIY0aNdQluKBly1Z69tmh5Tpu167dtHhxyethPfn9919VUFDgbF9zzXV64IGBXu2bmZlR5vNK0pQpr2nr1s2n3LZ580a9/fZkPfroE+U6h7diYmLUu/cl6t37EklSenq61qz5U4sX/6ZFixYqPz/fOfaLLz5Thw6nq3fvPpVSG4Cqp8Y9PqJOnToaNmyYfvnlF/3nP/9RnTp1nMEIhmE4v6R/AhNO9eVwONxuP/FYJwY2XHDBBfrwww/11VdfEcAAAGUw+bXrNXr1BK2171eSUrXCtlOD/xikeZ8/53HfFi0cHlN9t26tcW99AAAAAAAAAAAAVUJhfikevyjJnh+p5N9cJ6K/v/4d7c/a58uyUA6/7/tVA3+6X5fPvkjXf3OVJv/1mtLyU/1dFgAAAAAANZ43DxsuTQiDJJ15pvuHmG3aZFVOTumOGUjy7N6HMEjSdzvnun0wKAAAqHkKCws1fPizysj4J7QgMjJSL7zwksLCwvxYmbRhwzqX9nXXeR8WlZS0s8znXbz4N82aNdPZDg+P0Lhxryg0NNTZ98UXn2rp0sVlPkd5xMbG6oILemvYsNGaNWuuevQ4z2X7zJkz/FIXgKqhxq5EjY2N1UMPPaRff/1Vb731li699FKFhIQ4QxQkFQtSKM3XiYEMLVq00BNPPKGff/5Zb7/9ts455xw/v3oAqJ6WL5imORlLTrntzZ0faduf37ndPyRESkx0f9d5y5Ya+9YHAAAAAAAAAADgV0UF7kMYrEbx7RlrLlL+oebOdqG9UBP/fEkO04uVBqhQ3yd9pzFLR2hr2hbZHHZlFWbpm+1f6elfH1duUa6/ywMAAAAAoEazu89LkFT6EIauXd0f1OGQ1q4tXchmICnt/ZDdmbu0PnltBVUDAACqotdee0WbNm106RsyZJSaNGnqp4r+kZbmGrLdtGkzr/ddvXpVmc555MhhvfjiaJe+p59+Tr16XaD//OdpZ59pmho7drSSk5PLdB5fiY2N1ciRYxUeHu7s27JlkwoLC/1YFQB/qvErUa1Wqy688EK99tprWrZsmd58803deuutatGiRbEwBW+/YmJi1KtXLw0ePFjff/+95s2bpwceeEANGzb098sFgGpt5cb5JW5zyNSMn17weIy2bd1PyNu61SJCZQEAAAAAAAAAAHyvqDDI7fY64XUVGRx5Uq+hIz8OkOkwnD1rj/6tuTu+qYAK4a3coly9tvrVU27bk7lb766bWskVAQAAAAAQWBxe5FOWNoShSxe7DMP9mFWrCGEoSb4tr9T7zNn+VQVUAgAAqqL58+fqm29c3/tvu+0OnX/+hX6qyJV50mIqm63Iq/22bdui9etLHyxlt9s1ZsxwZWRkOPsuv/wqXXrpFZKka665Thdd1Me5LT09Tc8/P1wOby6EK1BUVJQSE1s62w6HQ5mZmX6sCIA/uZ8BUcOEh4froosu0kUXXSRJysnJ0caNG7Vr1y7t27dPhw8fVnZ2tvLy8uRwOBQaGqqIiAjVrl1bjRo1UpMmTdS2bVs1adLEz68EAGqm1LwUt9uX23Zo26p5at3tyhLHtG7t/mI7Pd3QkSOGGjQgiQEAAAAAAAAAAMBXTNOUzUMIg9WwKD6ioXZn7pLNtDn78w+0VuaGf6lWp9+cfe+vf0f/any+4sJqV1jNKNmaI6tlc9hK3P590jz1bz+Afx8AAAAAACqIN2vPgoJKNxc2OvrYPNutW0tOb1i9usY/57PM8soQwrB4/686nHNIDSLjK6AiAABQVWzbtlWvvPKiS1+XLmfqgQcG+qmi4mrXruPSXrt2jXr06Ol2H7vdrldfnVCm802f/q7WrFntbDdt2kxPPjnIZcyzzw7Vpk0bdfDgfknSn3+u1Ecfva8777y3TOf0lYyMdJd2dHS0fwoB4HcBFcJwssjISJ111lk666yz/F0KAEDSafGdtWjXRrdjPvl5nEa5CWFo187u8Txbt1rUoIHncQAAAAAAAAAAAPBOoaNQjqJQt2MMWWS1WBUf2VD7sve6bEtedIuiWq+SNSxXkpRTlKMP1r+rJ7s9W2E1o2T7s/e53V7kKNLX22fr7o73VVJFAAAAAAAEFrsX01wNo/THPfNMu9sQhn37LDp0yFB8PA87O1lZQhgcpqn/7fha953+UAVUBAAAqoLs7GwNG/asCgoKnH1169bT6NHjZLVa/ViZq06dOuu77751tt9552117dpNoaFhpxxvt9v14otjtH792lKfa/XqVfrww/ec7ZCQEI0ePU7h4eEu46KiojR69Fg9/PC9stmOhYN/8ME76tq1m04//YxSn/dkf/65UitWLNNNN92qunXrebXPr7/+ov37//k7WfPmLRQa6v5voABqLmIKAQBVxr/Ov0dWD29Ny4q2a9uf35W4vVkzU8HB7s+zZQtvfwAAAAAAAAAAAL6Ub8uTWeh+ApLl/1cGRARHqFZorMs2e24tpSy+3qXv+6R52pK62ad1wjs5RTkex3y2aYYW7JqvQnthJVQEAAAAAEBgcTg8j7GUYTpst26e0x2WLKk6iwWrkjxbbpn2+27nXOUWlW1fAABQtZmmqRdeGOGyaF+SrrnmOu3YsV0rVy4v91dS0k6f1Nqr1wWKiIh0trdu3axHH31QGzasdxlns9m0fPlS3X//nfr++3mSpObNE70+T3p6usaMGS7HCRe0Dz/8mFq3bnvK8e3bd9R99/0TWGW32zV69DBlZmZ6fc6S5OTk6JNPPtSNN16tp59+THPnztGePbtlmsUDxw4fPqR3331bI0cOdum/5ppry10HgOoryN8FAABwXHyLM3R5dDfNzVrhdtwHP47S2C6XyTjF3eOgIKllS4c2by75zvK6dVZJReUtFwAAAAAAAAAAAP8vKy9fpul+gr5h/PP3m3rh9ZRTlC2bw+bsS199iWqd/qtC6++VJJmS3lzzuiZdOFkWg5DtyuRNCIMkvbxyvN5f/45uaH2zrmxxjSKCIyq4MgAAAAAAAoM3IQxlebDyaac5FB5uKi/PKHHMkiVWXX+9rcTtgSrPllem/bKLsvXj7u/171bXex4MAACqlcOHD2nx4t+K9b///jSfnePyy6/S0KGjyn2cWrVideed9+jNN1939m3cuF4PPHCnateuowYNGqiwsFCHDh1UTs4/fydq1qy5HnzwET333FMez2GapsaNG6Xk5KPOvn/963zdeOOtbve77bY79Oefq7RixVJJx36uEyY8r7FjXy7tyzwlm82mZcuWaNmyJZKkiIhI1alTR1FR0TJNU8nJR11qPu7008/QDTfc4pMaAFRPzFIAAFQpfa99QRaVfGNXklbbd2vlwpI/kLRr5z6ld8sWi/LKdh8UAAAAAAAAAAAAp5CeXeBxzIlBChbDogYRDVwHmBYd+WmATnz4zMaUDfp5z4++KhNeyrV5F8IgSSl5KZq29i0NmN9Xi/cXn2gIAAAAAABKz253P5dWKlsIQ3CwdOaZ7hMe1q2zKiur9Meu6fJsuWXe94stn6nIzgPkAACoacwT/6hVDdx22x3697+LB0OlpqZo06aN2rFju0sAQ8uWrTRp0hRFRER6dfzPP/9ES5Ysdrbr12+gwYNHeNzPMAwNHz5aderUcfb9+usv+uqrL706b2nl5uZo79492rRpgzZv3njKAIaePXvplVdel7UsF90AagxCGAAAVUrDVl11eXQ3j+PeXT5JtsL8U247/XT3N4ftdmnTJt4CAQAAAAAAAAAAfCU7z/Mk8ksuz3ZpRwZHKTLYddJW3t52yt7c3aVv2tq3lFtU9knuKL2cIu9DGI5LL0jX6CXDNWHF2DLtDwAAAAAA/uFwPxVWkmQp41TY886zeTz38uUsNjtRkb1INof7h8S5cyT3iH7as8CHFQEAAJTNM88M0bBho5WQ0KjEMXFxtXXvvQ/qnXc+Uv36DUocd6LNmzdp6tQpzrbVatXIkS8oJqaWV/vHxdXWsGFjZDnhInfy5P9q+/ZtXu1/Kuee21OTJk3RjTfeqhYtWsow3AedWa1WnXXWOZowYZLGj5+oiIiIMp8bQM1gmNUtbgeAzxw9SkQpqpaQkGM3bA9s+1MDZlwuu9zfQR6YeIeuvu3lYv3p6dJNN7m/0O3bt0h3302iLAAA8K3j1zPHFRaW/Y+vAAAAlY1rGQAAUB4L1mzUffdGux3z5fu19PmH9bR27T/XHYX2Qu3OTNKJExeCotLU/L5nZAn5J5D75ra36r7TH3J7fK5nfOeZX5/QmiOry7x/85hEvXT+RMWF1fZhVQAA1HxczwAAgOM2bLDo8cfD3I755JM81a9f+uUgWVnSjTdGuA166NnTrpEjC0p13Jp8LZNVmKnrv7m6XMeIj4zXB5d9oiBLkI+qAgAAvlaTr2dOZpqmtm3boi1bNis9PV2Sqbi4OCUmtlK7dqfJaq15oVzZ2dlKStqh/fv3KT09Tfn5+QoJCVFUVLQaN26i1q3bKjra/d87q5p69apXvUB1w6c3AECVk9D6TP077jx9lfa723Ef7PxM5+weoPrNOrr0x8ZKzZo5tHt3yRG/69aVMf4XAACgJiosVOh33yr4j8Uy8vNk63S6Cq65To74hv6uDAAAAAAAVBOZuZ7Dr2tFB2vgwEI99FC4c5J/iDVEsWG1lZaf6hxny45Tyh/Xqt6FM519X237UpcnXqXG0U18XjuKyy3KKdf+uzKT9OyvT+qVC/6rWqGxvikKAAAAAIAA4i4g4ThLGafCRkdLnTrZ9fffJS+sW7XKosJCKSSkbOeoaXKLcst9jEM5h/Tznh91SfPLfVARAABA+RiGoTZt2qlNm3b+LqXSREVFqVOnzurUqbO/SwFQTbACFQBQJfXr+19FmcFux+QaRZoy836Zp7jT3Lmz+7vPmzdblZ/vdggAAEBgKCxU9BOPKHzK6wpas1rWzZsU+uXnin74Pll2Jfm7OgAAAAAAUE1k5dg8jomNDFOLFqauucY1sKFOWB1ZDddJ/+mrLldhyj8BkTaHXVPXvumbYuFRTjlDGKRjQQyDfntSWYWZPqgIAAAAAIDA4k0Ig9Vqlvn4557r/qnO+fmG/vyz5j39uKzybHkex1zZ4mqPY2Zs/FBFds9hpgAAAAAA/yOEAQBQJcU2aKZ+zW70OG65bYcW/W98sf7TT3d/c9hmkzZt4m0QAAAg/L1psm7dUqzfyMpS1LBBIrkKAAAAAAB4IzvXfQiDIUMR4YYkacCAIsXG/rNIwGJYVC+8nst402HVkZ8GyDxhLcGyA0u0+vAq3xWNEuUUZfvkODvSd2jEH0NUYC/wyfEAAAAAAAgUdvfTYCVJ1nJkJHgKYZCkn38mhOE4b0IYrm11g+LC4tyOOZhzUHN3fuOrsgAAAAAAFYjVp4CP7NmzR3PnztW7776rt956S5988omWLl2qggImkwBldcWNLyjBjPY47o31b2r/lmUufZ5CGCRp7VpuDgMAgMBmpKQo9H9fl7jdcviwwr74rBIrAgAAAAAA1VVOnvu/zVgMQ2Fhx76PipLuvbfQZXt0aIzCgsJc+nJ3dVTOtm4ufW+tmSy7w4tVCCiXnKIcnx1rffI6vbj8eTlMLx7hCQAAAAAAJEkOLz5GW8qxGiQ+3lSLFu5P8scfQcrx3S2Cai3PlutxTGxorG5u29fjuBkbP1R2YZYvygIAAAAAVCBCGIBy+umnn3T99derT58+euqpp/Tyyy/rv//9r8aMGaM777xT3bt31/PPP6/U1FR/lwpUOyHhURp47hCP43KNIj0/6y7lZiY7++LipKZN3d8cXrOGt0EAABDYQufMkmzun1IZNvMTGYcPV1JFAAAAAACguvIYwmCRgoP/affpY9dpp/3ztxxDhuqHNyi239GF/eQoCnG2d2Umad7O/5W/YJSoyF6kIkeR2zFDzhmhp7oNUmRwpFfH/GP/73pzzRu+KA8AAAAAgIBQ0SEMktSrl/v7OUVF0u+/88AzScqz5XkcExEcqStbXKNaobFux2UWZurzLZ/6qDIAAAAAQEVh9SlQRoWFhXr66ac1cOBAbdiwocRxubm5mvF/7L13vB1Hef//ntly2j3nVl11uci9d5tqiGmmBRJ6QhJIaAkQQvkGSCgpBAglGDDVP1roJqbaNNvYuEtuklUsS7LK1ZVuL6efLTO/P/aU24t0JV1J8/ZrPWVnd0fnnrM7O/M8n+e73+VFL3oR69evP4I9NBiODy79kzfyvOTFs7bbzRDXfe2VqLDhRHjBBTPPQG/ZYpHNHnIXDQaDwWAwGI5NCgViv/z57O18n+QXPze31X2DwWAwGAwGg8FgMBgMJyyF4sxzB3ZsvBCklPD2t3sI0aiL23EybmZcOz/bwfD9LxlX941NX2eoPHhoHTZMS8HPz9omE8vwglNeyNee9y3Wtpw2p/P+fMdN/HLnzw6xdwaDwWAwGAwGg8FgMJwYhKGYtc2hijBcc83MgTsAbrvNPrSLHCeUguKM+6UQONIhYSd43dl/Oev5/u+JG9mX61qo7hkMBoPBYDAYDAaD4TBgRBgMhoNAKcW73vUufvnLX46rtyyLVatWcfbZZ5NOp8ftGxoa4k1vehOPPPLIkeyqwXBc8Oa/+v9o1fFZ291Z2cKXrv8zdNVB8MILZ1boVQrWrTMKvQaDwWAwGE5MYrf8ElEozKmtc/+9pD7+HxDMvvhuMBgMBoPBYDAYDAaD4cSkWNIz7ndik+cVzjhD8cIXjq/vSCxBMt7JYOiBF+OPLKmXC36Br264/hB6a5iJ4ixOBQAppwmAzmQn//3Mz3Jq86lzOvcXH/kcD/c+eEj9MxgMBoPBYDAYDAaD4URgLrEyrEM0gV22THPeeTPb2m7YYNHfP7sgxPFOKSjNuD9hJxFVtdGXnPoylqeWz9jeVz7/89Cn0XrmOTWDwWAwGAwGg8FgMBw9jAiDwXAQ3HDDDdx2223j6l7zmtfwhz/8gdtuu42f/exnrFu3ji9+8YusWLGi3qZUKvGud72LXC53pLtsMBzTNLWv5J2XvmdObX+Ve4CvfenVqDDg0kvDWVV+77vPiDAYDAaDwWA4AVGK2E03zusQ547bSX3s3+a2ym8wGAwGg8FgMBgMBoPhhKM0iwiDG5vaoP+Nb/RIpxvH2tKmLdE+ro0OHfpue/24utv33sZDvesPsreGmSj4swt3Ju1kPZ+JNfPJZ36WVenVsx6ntOY/7/+oifRoMBgMBoPBYDAYDAbDLBwJEQaAa66ZWYRBa7j1VmNrW/RnFq1M2Il63rEc3nj+m2c958b+R/nt7l8fct8MBoPBYDAYDAaDwXB4MCIMBsM8GR4e5itf+cq4uve85z3827/9G0uXLq3XSSl57nOfyw9/+ENWrlxZr+/p6eGb3/zmEeuvwXC88JRr38nLm585p7Y/Hf0jH//sc3DECOefP/Pk8Pr1Fr6/ED00GAwGg8FgOHawHt+KHBiY93HO3X8k8dUvHYYeGQwGg8FgMBgMBoPBYDjWKVVmEWFwp16zyWTgDW8Yv1jTEmvFkfa4usKOS8hvv2Rc3afWf5zh8tBB9NYwEwU/P2ublNM0rtwSb+Xjz/gUrfHWWY/NeTn+9e73k/OyB91Hg8FgMBgMBoPBYDAYjnfCmc1fARDi0K9z9dUBtj1zm5tvdk74mB3lsDzj/sQYwUqAq1c9m7Pazp71vF/b+CX6i/2H1DeDwWAwGAwGg8FgMBwejAiDwTBPbrjhBgqFRuSPyy+/nDe96U3Ttl+6dCkf+9jHxtV961vfYnh4+LD10WA4Xnnjm77NuXLFnNre5W3l3dc9lVNXPDpju1JJsHGjeRwaDAaDwWA4sbA3P3bQx8ZuuhH3Fz9dwN4YDAaDwWAwGAwGg8FgOB4ol2e2+nfj01vqv+hFAWvXNvZLIVmSXDqpXd/v/xrlxevlwdIgH3/gP1D6BPcCWGBmi+wIkHJSk+qWpZbz8Wd8alzkx+nozu/jP+77CKGag0eJwWAwGAwGg8FgMBgMJyCziR5IuTAiDOk0XHXVzO/nvb2CBx6wDv1ixzCzzZdMnA8RQvC2i97BbH+inJfjk+s+Zua3DAaDwWAwGAwGg2ERYrxODYZ5oJTipptuGlf39re/HTHLDNZTnvIULrvssnq5UCjw61//+rD00WA4nnFiST7wl9+nVcdnbww8ySA/7fsLBvqfJAy8advde+8sEr4Gg8FgMBgMxxn2ls2HdHzy+utw/nDbAvXGYDAYDAaDwWAwGAwGw/FAuTTzmmkspqfdJyW84x3j13KanCaanKZxdUGunYE/vmJc3SN9D/Ptzd+YZ28NM1Hw8zPul0IQs2JT7lvbcjr/ctVHkXPwAnmk72G+tOELB9VHg8FgMBgMBoPBYDAYjnfmIsKwUDz3ucGsbX7+8xPb1rYclGbcn7CTaA3lcuNvd077ubx47Z/Oeu4N/Y/ww8e/txDdNBgMBoPBYDAYDAbDAnJivwkbDPPk4YcfZmhoqF5evXo1V1555ZyOfcUrXsGDDz5YL99222287nWvW/A+GgzHOx2rz+Y/X/x1/t+v3khB+LO2t9LdFFIbGe3P02w3kWnqxE2MN9i76y6Lv/s7SMwelMdgMBgMhkWD1o1NqUZay9e2MKztE5P2jW0/Ma0dM7Fu7LVr+Yn9mWlfVBZzPn4u15z+eDHtcYcL2x6/wh0ECxByYAFJpzVnnRly5ubHDu1ESpP6xH9Q0Ar/T567MJ0zGA4WzyP2619hP7YRgOD8C6hc+2Jw3aPcMYPBYDAYDAaDwWA4saiUZ54HicdnnpQ591zFc58b8PvfN8wYOpNLKY4WUTS8DkYefh6Zc+4lvuLJet33t/4va9JruPb0aw+y94axFPzCjPtTTtOMgQquXH4Vb7rgbXx1w5dmvdYvdvyUkzMn85K1L5tvNw0Gg8FgMBgMBoPBYDiuCcOZ9y+kCMOVV4YsWaLp75/+ff+hhyz27ROsWnUYDW8WMaUxIgzKd8k/cRmFHZfgZztQpSYG9Ape8PFkXYDBdaG1VbNs5XvJFzrRyx4ledJmrHhxyvN/e/P/x1ltZ3PJ0sum3G8wGAwGg8FgMBgMhiOPEWEwGObBnXfeOa781Kc+dUbjkoltx/LAAw9QLBZJJpML1j+D4URh7UXP4z9K1/GB295BRcwyyww0rbiHodFTGA5yDI/kcEcsUnaSmJPAtmOUC4J/fNsAL3n+E0eg9waDwXBwrFjZyoVPOQ/bMUP4xYRSkM9DNivI5wXZLOTzgkJB4HlQqUC5LKhUoFIRlMtU66P9YQhhKAiCKB8EVPOiXo7aNOonCiIYFhcTXw8W5d/J93nV8Ev5x47v4crZIxlMi9KkPvkxCm4M/+nPnLFpGEKxuoacTh/8JQ2GiYjhIZo+8i9YW7fU65w7/4B76+/I/9vH0G3tR7F3BoPBYDAYDAaDwXBi4VVmtvyfixj2m97kce+9FoVCNMliS5uORAd9pb5GIy3p+dXfs+Zv/gXpVurVn37wk6xsXsEFnRceVP8NDYrB1M4ANVJOatZz/Pnpr2JPdje/2XXLrG2/+MjnWNW0mouXXjrnPhoMBoPBYDAYDAaDwXC8o9TMNuqWtXBGKZYFL36xzze/OXOwg1/8wubv/372AGrHI6XqfElYTtJ94/so7z993H7fTaHGTJl4HvT2Cnp74+C9lgP3Xw1CkVj1BJlz7yJ99gNIt1xvr7Tm3+/7MJ979vWc3HzKEfk3GQwGg8FgMBgMBoNhZowHl8EwD7Zu3TqufMkll8z52KVLl7Jy5Uq6u7sB8H2fHTt2cMEFFyxoHw2GE4VznvLn/JtX4KN3fYCymNl5sGnl3Qxt/ct62SPEC3IQ5Op1XQ/C7x5cddj6azAYDAuB627kLS/bxT/9y8uR1gJKmRumRGsYGBDs2yfYt0/S3y8YGGhsw8OR8ILBcKwhSiX+b+S5xIXHO5b8YMo2xfe+n8T11yFKpSn311Ga5H//F7mTTkatXjNpt9Zw4402N97oMDIS/V4yGc2qVZrVqxWrVyvWrlWceaYy4gzHEfLJnVh79yACH9WUQafT0dbaik5nZj9BuYwoFdGppig0xAwkvv2NcQIMNazHt5L49jco/tP7xu8Iw+iLac8yJab1ZFUVg8FgMBgMBoPBYDDMiFexZtwfj81+jtZW+Lu/87nuusb7YEu8lUJQpODnG9caXkb/H17H0ud/s14XqID33/n/+MTV/22EGA6RsZ/1VMxFhEEIwTsvfjf7891s7N8wY1ulNR974N/58nNuYElyybz6amigdSTm6/vR5nmiXq6J+zbSSPC3ttWEf5WKIqkKMT6NNj2pTojIUUdKcF2N40TTOY5jplYMBoPBYDAYDAaD4VAJZ4lRJhfYfOzaawP+939dghlMcm+5xeZ1r/NpaVnYax8LFIPIhqb/1r+aJMAAIMX0f5AmN03aT5PzcpS6zqLUdRZ9t/4VmfPupvWKm3FbIwHSgl/gQ/e8n889+0u0J0zQCcORoRZkSAgYKA3wcO96ego9dCaXcvmyK+f0Xdy5U/Dooxb790/9OxgbyKi1VXPeeSEXXKCwJkwpb9ok2bDBoqsrmliyrMb8U21OasUKxcUXh6xdG520UoGNGyVbt1qUSo25KtuG5mbNhReGnHSSrs9V5XKwZYtFf7/AtqP5LMuK5rNsm3F1y5Zp2tsnC97U5tMm9t9gMBgMBoPBcPxhRBgMhnnw5JNPjiuvXbt2XsefdtppdRGG2vmMCIPBcPBcdPVf8elMJx+5+a0MiukdBBMdm3FSB/ALy49g7wwGg2Hh8bw0X/jxBcBPec+H//xod+e4Igxh1y7B1q0WW7dKdu+W7NsnKJWMlajh+EOUo3HTD4av5Y1tPyVllcc3iMfxnvM8VHMLTR/5AKiZIyeIUonMG19P/mP/TXDZ5eNW+b/+dYcbb3TGtc9mBVu2CLZsGb/otnJlJMZw1lmKSy4JWbNGG0PtYwzR30/yf/4bZ/26aduoNSdR+qs34F/97Mk7SyWSX/ki7u23QrkMUhCedgbBRRdTef4LUWtOGn+9fA73d7+Z9lru739L6e/egk5nkHv3kLz+Ouwtm0EpgrPPpfT3byc89bRx/U98/cvYj21ABAHBeRdQ+ts3o1atnv+HYTAYDAaDwWAwGAwnIJ43s8VpIjG3F/0XvjDg1lstNm9unG9Zahl7s3vwVSPS4uij15A6dQNNpz9cryv6Bd73h3fz78/4GFeuuGqe/wJDjYJfmHF/ymma03kcy+HDT/l33n7bW+gp9MzYdrQywsfu/yifftZ12PLEMmXRGgoFGBkRjI5G28iIIJeDUklQKkGhEKXFoqBYbOTL5ZrogsBfZIFIbRscZ6wwg64LNCSTmkQCEglNMtlI4/EoTSY1mYwmk4mM5TMZTTxuhB0MhwmloFRCVMVhRaUMQQhBgAj8SN0kCOv5KA3B9xFh1TttrDdJLT8xnYhloS0LpBV5bdgWupavbtqyQYpG2XHBddBuDO3G6nlcN/rRmR+JwWAwGI4CNTEwpRp66DWBr8YmJoiCNfITRb4aqR7ndClENJZ0nIV3PDcYFitKzbx/oX8Lra1w9dUBt902/Xt5pSL4v/9z+Nu/XWQvoUeAclBCeXFy266Ycr9k5j/I0uQyykG5Pr+lgxijj17D6IZnkz7rAdqfcSNuax89hR7ec8c7+fSzrqMj0bHg/w7DiceuXYKHHrI4cEBy9tkhV14Zkk5Df7/g6193ePRRi4HCCMGShxGXX4/b2VU/1pYW157yEl571l9OKZ6qFHzzmw4//KEzad/MOFx+eci//muFZDI6zw03TLYzm4lXvcrnpS8N+MhHYuzcOfPv7+lPD3n/+yv89Kc23/iGO+2r+lScdJLine/0uOACxd13W3zvew67d0uCoCFM6rpRYKKLL1a86EU+a9dqtIb777fYtEkyMiKIxaI5sFgsmvs655zITm7svVxrKJUgFjMCDwaDwWAwGAyLBaH1fIaPBsOJS7lc5qKLLmLsT+aee+6ho2Pukxsf/vCH+dGPflQvv/Wtb+Wf/umfFrSf86G/P3fUrm0wTIXrjp8t8LxZZHyrDHRt5d+/80qeoH/aNiM7X0zPuvcfUv8MBoNhseC6ebY8cD62c2IZoi4kWsP27ZL777d49FHJE09IKhVjmGY4dCbaNy7GN25rz+5IAhy4ftXHuDS5FYCemM+DrUXya09izTv+i7PbziH+85tIXP/5OZ9brTmJ4tveTnDZFfT2Cl7/+sRBfwbLlmkuvzzkiitCLrooJB4/uPMYDi+yay/Oww/i/vbXWNufmPNxlVe+mtKb3tb40ShF07vfgb1507THlN74Jiqv/ct62X5oPU3vf++M18n/13+jM82k3/uPkbDDWFyX/Cc+TXD+hcg9u0m/+52I7Oi4JjqZJP/xTxOec+6c/20Gg8FwLHOwczMGg8FgMBgMAGe94CFKA53T7n/Fq7N85n1ze7/avVvwtrclxkVeLAdlunJ70TQmG6RTZvVf/DuxpXuBxmumFJJ3XvouXnjyn87/H2LgY/f/G3d03T7t/qtWPJX/eNrH53y+3aO7+Mc//D1Fvzhr25ee9nLeftE/Io5zR+I777S4/Xabbdsko6NixiijhgjHiQQZmps16XSUtrdrOjo0S5ZEW0dHVGeb5ZMTD60RhTyivx85OIDIZpG5LGJ0FJHNInKjyGwWkc9HgguVMqJYQpSKLDoFk4NFCnBctOuC66JjcXQigU6l0IkEJJL1vE4k0clkI001odNpdCaDbm5Gp5qMoMNR5Hicn1FaUfDzFP0ipaCEF3pUVAUvrOCFHuWgjKc8vLBCpVYXlglCn1ArQh2idEioQkIdjilH+wIdoFSIQhGq8Z9XbUwhEFOWa3kpJJa0sYWNLa163pI2trSxhTUmb2NJC0c6uFaMuBUjbieIWXHidoy4lSBux4nbifo+RzrH/fjGsDjROloazuUika+aoFe5HAl6lcuCYrFRLpXGp0EAnieqwl8NATDPi/JBcHTEwKYS/KoJNNTKNQfHsaJfNTGwVCpKm5qicWVLiyaVMuIOhsXHz35mc/317rT7W1o0N944fQCzg2HzZsm73jWzgUYiofne90qk05P3HY9jmRpv+M1fsn1Lgq7vf3jK/e3xdtpnEU2I5rf2MJUpjZAhLZf8jran/gwrUWBl0yo+86zP055oX4DeG45FlILR0ej1LJOZ/Jzyffjudx0eeMCiv19w5pmKP/szn8suayi4/PKX0X0kHPNTXL5c8ba3+Vx3ncvgoKC30MOoF9nLSKfCij//NMmTto67liMdXnnma3jNWX9Bwk7U63/9a5vPfnb6+9RsPPvZAR/8oMctt9j8z/8c/HkON7YNV14Zcs89sysjxOOaf/kXj5/+1Obhh2duv3y54uMfr5BIaL75TZc777TqgcNisWj8kkpF45QobeSjebLoWVCbM6uNacyrh2HeKAXlMqLcECqlXInKtReBmjipH0DgI4KgKlIaVvf71bZBJFw6Vp1tbB4NSiOm218zOB2r0DYmr6UAUb0hTqHmpkV1f63OttC2DZYNtl3NW2Py9qQ2djwSPNWOA7aNl0yjVq4yPy7DomXJkikG5gaDYcEwy44GwxwZHh4eJ8DgOA7t7fOb1Fi6dOm48uDg4IL07WCZONFlMBxtbPvgvpMr1p7HFz7wEN/75tv4bs8tqCmmJ5tPvZnhJ/6cysjph9pNg8FgOOp4XhMP37ORpz/v8qPdlWMK34eHHpLcc4/kvvssBgbG7zdzY4aFYLLx1CJTYVAKvEq9mFcpEJofrxzhc6f1odDodh/9h7/nWWuezXtf9s/YfgX361+d0+mtrj2kP/g+ghe/lJ8vezdw8L+t3l7Br35l86tf2cTj8PSnK57//JBLL1XG+GUxoDXOj36A+9Uvj1n4mPvh8Z/8CCvw8N75TyAl1h134mzZNOM5kt/8OvKM0wmf8lQAnO2Pz/r9im1/HGvjhih63cS2vkfqhq9Q+tJXiX/7BmRudFIbUSrSdMOXKX3hS+ZBYTAYTggOdm7GYDAYDAaDASDwZjY/SDfZc16fPOMM+Ou/DvjGNxrnTDhxljctZ39+f71O+XG6/++9nPTXH8ZuGqnPzWg01z30P+wc2ck7Lv1HXGvxGvAuRkqqOONrcDrWNK+15jOWnMZHn/7vfODO/4fSM4fx/OXOn7Iqs4JXn/3aOZ//WEJruP56m5/8ZPznZ6YdZicIYHBQMDg484clBLS1wapVmlWrFKtWaVav1qxapVmxIopMaDhGyWaRXXuRXV3I7n2I/n5Efx+yrw8x0B+FijwYjpffn9bgVRBj1gAOGinRzc2QaW4IMzS3oNvbUR1L0B0d6CXVtLnFeKwuMIt5fkZpRbYyykhlhOHyMCPl4XH5vJ8n7xcoeHkKfoFCtVyagxDT8Y4UkoSdJB1Lk3HTpN0M6XFplM/EMrTF22hPdNCeaDfjWMMklIJsNhoXDQ0JhoZgaCgaI42ORkILuZwgn4dsNkoPt0jC0RjLhiGEoRijwX7onZASmpupOzC2tFBNNZ2dsHSpprMz2mKxQ76cwTAnhJAz/sZsWyy4LfhFF8F552k2b57+wuWy4Je/dPmbv5kssLCYxzKHiqfKBPlV0+6Xcua/F0TzW0uSnfQV+ybt08pi+MFryT72TNqe9jP0Jb/nv9Z9lOue80WkMGPuE4XhYfi//7O5+25Jd3dD7Ki1FV772oBXvjJEiCgOyQc/6LJhQ+NL9+CDFg8/bPFP/xTwkpeEbNok+MIXovHk2O9mT4/kIx+JHmZ5P1cXYABQfoyBO17Lmr/+8LhjAu3zg8f/l1v3/oY3nP93PP+UFyCFxQ9+4BzSWODuu23y+ZBf/vLQznO4CUO4915rTn2sVAQf/nD0+c7WvqdH8pa3JMhkqNuz1o7xvEj4amRkfh+MbUdjmtZWTVubZunSmngpdHZGIqadnZHAg+E4ovqiIEaGq4KkueqWRWSzkM9F9dkcIp+LRErrYgvlelAvQ8REO+CE1ui2NvzX/gX+K15lJvQNBoPhBMOIMBgMc6RYHL8YFI/H561OnZzwpjLxnAaD4eBx4kn+5m3f5mkP/ZrP/+r/sVkdGLdfCM3SSz7P3tu/cJR6aDAYDAvL/n1DR7sLxwy7dwt+9SuL3//eYnR09vYGw/GMKJfH6UL42ub7q4b5/Noxi7uJSK38jr1/YLA0yGde8zmQMnK2nyP2r37BnuxpCOul6FTqkPtdLsOtt0puvVWybJnm5S8PufbakEzmkE9tOEisu/6I+5UvHdI5nJ/9FGwH7+3vxPndb+d2zI9/WBdhsHZsn7W9ffcfkTt2TLtfbt2CtX4d1t13Td9m02PIXU+iTl07pz4aDMcSngfFYhTRKkobUbAKhVo0rMhAs1KJFvijLTL2aJQbdWEYre0GQZSGoaim1NOgKngfGUnO3MeJ029jy5ZVFa2PhOixrFqdronW1+tqm21HDjeNrVF2nCiaRC1SVm2LxSKDykQiiuyTSETRK6JydJxZXzUYDAaDwXCi44c+ypvZCyWVnJ+x+F/8RcgDD1jjjP7TbpqORAcDpYbCapBrY9+P/pnVr/sYdrIw7hy/3PFzNg9s4sNP+ygnN58yr+ufyBS8/Iz7m5z5z/dcueIq3nbxP3D9w7Ov1X35ketZklzCn5z0nHlfZ7Hz2GNikgCDYWHRGgYHI8fEDRvGf9ZSRs5zp52mOf10VU87Osx73aIiCJC7dyG3b0fueAJr+3bknt2YRZ4jiFKI4WEYHp7dpdW20e3t6Ko4g1q+ArViJXrlyihdutSINBxDFP0i3bl9HCgcoL/YR1+xj/5iH72FXvqLfQyUBmYVVDJMjdKKgp+n4Ofp4cDsB1RJu2naEu1RZO1kBytSK1jWtJzlqeUsa1pGZ3Kpcco8jtAacjno6REcOCDo7RX09ETbwEBDdEGZn+FhQanI8XV4WDCbqENzc+TEuGxZJPgVbYo1a7RZwzYsKLP93g/HMEsIeP3rA97/fmfGdj/+sc3LXhbS0rLwfVisFPwiQXb6AI5zfSa3xlvxQo+RysiU+8NKiv7b/4LspqcT/tn/cMspN3PtqS/EkmY+4XjnwAHBe9/r0N09+Tk0PAxf+pLN6KjgTW8K+N3vrHECDDWUgi9/2eaaa0Juuml2d7HRyuR37XLPqVT61hBfunfSvv5iP//9wMf5/pbvck3mLRw48LxDmlMJArjrLoudO0/ciRnPY1JAsUMhEjKlKmQ6/efa0gIrV0aipatWKVau1PXNjGcWGZ6H6OtD9vYgenqQfb2IwUHE0GAjHR6O/viGOaHQKBGloQBd/alodGReK0XdzFYD8QDcoSHc67+AyGbx/vZNR6fjBoPBYDgqnPAiDD09Pdxzzz1s3ryZXbt2kcvlyOVyBIcw+BBCcOutty5gLw2LgUJhvMFO7CCkbCceY0QYDIaF5/RLr+XzFz+fB37/Nb5133U8ofvr+5JLH6Fp1Z3k9119FHtoMBgMC0M4m7faCY7WsG6d5MYbLR580BidLHp0NHmJ1mitGacScBgR1cVPIeTxE+lqNiZEAtuaDPnB2v5xdToRr+cf69/Ip9Z9kg++5l8Rfb04P71pzpfaMdyGKO9DtLSgOjsXzIq5p0fw5S/bfOtbNn/+5yGvfGVAc/OCnNowEc/DenA98smdyO5usG3UkiUEL3kp7g+/vyCXcH7yY4Jn/wnWYxvn1N7a8CgUCpBKIbdtm7X9TAIM9T587UsEQqPQuHr8M6NWHzx4H96aldFCi9b1tGZsWitLIeubJawolRYCMW8hR4NhPlQqtUhXUWSrXC5Kx+cbaU1g4Vhff52+/zP93hb+tyhlJMaQTEaCDckkdaGGpiZoatKkUuPTpiZIpRppKhUdY24VBoPBYDAYjlVKQQnlzxylN5WYn3mCZcEHP+jzd3/njpvSaE+04yt/nIFwpX81+374fla/9hNYifHruk+O7ORNv34jV695Ni8/489I2kkqYQVf+XihR6CCce9yQggsYWFJC0c6JJ0USTtJ0kmeMJGIC35hxv0pt+mgzvuKM1/F1sEt3L7ntlnb/td9/0lrvI2Ll15yUNdarPziFye8mc5RRanIoeHAAcFddzXmgdra4LzzFOefrzjvPMXpp2ts86c6cuTzWJsew9rwKNbGDcgnth3+kN2GhSMIEL29iN5eACa5hdk2etly1IqVqJNPRp1yKuqUU1AnnwLx+KTTGQ4/Siv25/ezZ3Q3+3Jd7Mvtoyu7l325rnFCV4bFQc7LkfNy7BndPeV+S1h0ppayKr2Kk5pP5uTMKZzcfDInNZ9M2k0f2c4a5oznwb59gr17BXv2CPbulezZI+juFhOXcw2LlNFRGB0VbN8+eVK/uRlWr9acckok+nXaaYq1a7V57B2PaB1FnB4eakSbrkaZJp+PIk8XS1ApRwEzKhVEpRKVK15D0VyFDfVypRBKoaUEy8LufR5y78saC0hSgBtDN7egk4nDpnV15ZWKM87QPPHE9AtXxSJ861s273rXMb7gOEe01pSDEv5MIgzM/Q/SmVqKr/wZ52AqfSex97sf5ePWh/j0uk9yzUnP4fXn/bURGj0GuOsuyfr1koEBwbnnKp7//JCOjtmP+/rX7SkFGMbygx9YvOxlAb/61fSiHMUi3H67xUMPzf6dLAdTDz5KXWdNKcJQY1+ui8/dcSeDI2tpi7fRGm89aLuYP/7R2HceDUZGYGREVEWQx/8NliyBU05RnHqqZu3aaCyzenUU0MJwmCiVkPu6kF17EXv3Irv2Int6EL09iMHBaKxwjKHRlKWmZCnKlqYkFSVLNcq1vNR4UuFJjSc1vtAEY/Ke1PjVsica+UBolIjEFEIRiSkoNIEAVS2Htf2ML+tZbJQn3s+kgjPyMd64p51n/viHeK94FcZo1WAwGE4cTtglw40bN/KFL3yBe++9FzVGJlIvwMDEGNUfn3ieN67sHMQbhOuON8opl8uH1CeDwTA1Qkquev5bufK5b2brAz/j1/d8nT9kH6UofJZd9hl2D55DUFpytLtpMBgMh0QQmNAGU1ETX/jGN2y2bTPjchWGaBWiVDXVIVqpqKxVlNfRpnWI1qBRdQdjxjgaa4iOoab2qqvta//VaOT1hPLY0sG/eWkQelJZjKvX4+uhum+K/BhE1SlTjCk38o0W4/MCWXWuFghkNRVCRvW1fUJW90uklEhhIWVts5FWNZUW0rKR0sayHYSUHIqzaC434d845r0mEJrvrMxhjf0sYjGYoJz/+12/JWHFefub30bzli3IbY/Pet1QS3ZXVkaFkRFkEKBWrFxQv9dSCb77XYv/+z+L170u4NWvDnFPDD+Iw4/n4fzw+7g/+iEUJke+dL9xw4JeLnb9FyCXwxcaS4Oc8EXxhGJzpkxfLCBvh4zc+t/kl7bipzeQb1X4UrO66HDFcIqipbinPc/OlEfZihZnKlIRCFhTcrlsOEkgNPe1F3gyWcGTmlA8DtWv6/KKw0UjSeJK8Ehzid3JSrRj97+ifvyVQ/p3ThRosKWNIx1cO4YrXVzLwZEurhVtjnSIWTFsyyFuxUnYCZJOkoSdIOEkSdoJElUnoEQ9n6g7B5n5qeMD34e+PkFfn6C3tya0IBgejtKhoSh6gdH5PLooFenDRBquY3978/sdSgmpFKTTmuZmyGSiCBPNzZpMplHXSKP9B6EVa1gIlIoMJKubCIPoRxuq6MVkuq069hIT64VAW1Y0FqsaV2LJel6PrbdtcByj2mEwGAwnAlpHz5dyGVEpQ7kCYYAY8wwiDBFhWM9HBvxh1Gbs2nftuTHx+VEtayHAsqPnTHXTtedOvVzNOzbadcGNRc6TUlLyy+hw5vXTptT8o/WtXKn5x3/0+cQnxp97WWoZMD5SW7n3ZLq+/0FWvvLTOJnhce195XPr7t9x6+7fzbsPY4lEGZIknRQpJ0nKaSLlpGhy0zQ5qajspmiOtdSNj9vibbTEW7HlsWOeUZxFhCFpJw/qvEII3nvFP7NjeAd7s3tmbBuogH/54wf44nO/xKktaw/qeouRTZvMGG4xMjQUGfzXjP5jMbjgAsUVV0TbmjXaDL8XEqWQW7dg33cv1gP3RUKqx6AhuWGOBAFiXxfWvi6sdfc36oVAL18RCTKcupbwrLNRZ5+Nbpveqc0wf/zQZ092N08MPcGO4SfYPrydHSM7KPlmQvF4IdQhB/L7OZDfz/oD68bt60h0cHLzKZzWejpntZ/FWe1nszS5zKwfHGGGh+GJJyTbtgm2b5fs3Cno6RGzRrc3HLvUBBo2bWq8A0sJa9Zozj5bce65mvPOi8aYh8uB3rBAlMvI7n2IffuQ+7ujSNMD/ciBAcTAAGJoMFJVOQzU7tThaHGyQFm5Egk9LFmCXN56eK4v4PWvD/jQh2ae6/nFLyxe9rKQk0+ew3g+DBH9fYieHsTIMGJ0tLqNILI5RLkU/dvKNeGKCpRLUfRvVV17qa/BKOo30traiiWjuazaJhv5aI7LQqcz6NZWdEsrurkZ3dpWLbdEda2t06qme6GH0opgJhGGajCY//xPH9+PBPL37hU8/rhk69bx934BrGhaQVeui3IwvT9BkG/hyeu/QHzFDm666HZue/JvecW5L+Mvz3k9LfHD8/c3HDxKwac+ZfPrXzeeAffeK7npJov/+i+fM8+c/rcyOgp33DH7g0EpuPVWa0aRFIA//EEyOjpjEwIVEOqpByWlrrNovWzmudTinnMJdUh/qZ+cn2NF0wocObuPTSWskPNyBCrAljZ33R/ZvZhx6uKhvx/6+yXr1kFNbtGy4OSTNeecozjnHM255ypWrzZzZvPG85C7dyF37EDu3I7cswe5dw+ir+9o92xKNJqipRhyQ4acgGE3ZMQJydkheVuRtxU5OyRXTWvlQlVg4XghFJqt6TLvO6+b920PePGGRwmfaQLDGgwGw4nCsbPKv4Bcd911fP3rXycMw0miC4c6cF8IEQfD4mSigIJ/EKr7E4UcYkfZQtrzTARtw+JmIb6jp136p7zj0j/lLaU8W9bdxMNbfs2Dz/s31j30GgYPXIEOjaeewWA4NvE8zzzLJ7Bjh+BLX3J57LH5G3MvNMmkJpEA142iGcRiY/Ma143qIvt1zdg1QNsGy2rUCXy84gCVQi/l4iCl0gCl8ghFL0vFL1IOC5TDEhVKlFWFEmXKwqMsK5HggVAIoaCWR2MLBUJFIgXVfUKEkTiBUAhUNa+r+2rOYuOFDur1Y8UPqnlBw8GMMe0miyKMF1VoiClMvNbh+VstJjQQVrcaEkFc2yRxaBJxUjJOk5Ug7aRpcppIuWnSiRZSiVaaUq00t6ykpX0VmSUnk2pewitemSKbHfPhjXkn6Y37JKVk7JKsdmNT2rr+fPvP2dy/hY++++2c8d4PI7Izr9LtqSzD02MW1fJ5xIH9qGXLF9xZsFiEG26w+dWvLP7+7z2e8hRzb5wXSmHtfhJr8ybszZui/M6dwKGIpcxM1g757dIsG5pLDLoBg+6TDD8tWpxxleSkoss7di7h8uEkv1g+yudO6xu3KKOf/D66N4VcOd6h5psnDc543b6Yz4MtMzuRHIj5HFg6xfe7VEQrfUjf31ArQo7M4pIUgiY3Q9pJk4llyLgZmtw0GbeZtJsm42ZIu2manAwtsRZaq45Bx5JD0PGC59UicEp6e8UYwQVJX59gaEgYH4QTiDCEbDYyyOruhrmKOLjuWFGGKG1t1bS0aFpaqOdbW6N9icTc+7So3zmUigzvvApUPESl6pxaqdaVKwiv0shXylH7SmX8/kolcmz1KtXzeRD4CL/m3OpHTqxhCH4tH4BaBD9Ox4kcYB0HHYuB46JjbpS6Lrgu2nHRyQQ6kYRkEp1IohMJdDI1LiVZzTc1oVNNGOtfg8FgOESUqkc+FPl8lM/no60wRVp7VlXFFhrREcuL45kzG7ZFKekiKl+gPoYRoEVVQKj6XEm61kGNL/7kT0K2bYObbhpvwLs0uQyJZLjSeD8s961hz7f/jZWv+AzxZbsXfDzthT5eOMpIeRYL5inIuJnq+1cbrbFW2hJtdCSW0Jlcypr0SaxKr14072U5Lz/jZxeXyYMeK9rE+Ncr/4133P7WGZ0MAApegffe/m4++6wvsKJp5UFdbzGRzUbvgIbFT7kcCT6vWxfdvzo7NZdfHvLMZwZceKHCOvrLEMcevo/z4Dqce+7CeeA+xMhIfdcx8KQzHA60hu5uZHc38u6760aMqrOT8MyzCc48i/DscwhOP5N5TWYch8znmTtSHmbT4GNsGtjIpoHH2DmynUAt4vkdw2GlvzhAf3GA9QfW1+uaYy2c1XYWZ7SexVlt53BO+zk0uemj2Mvji2IRtmyRbNlisX27ZMeOKAK2wRCGsGuXYNcui1tuierS6ciJ8eKLQy6+OOSUU04Mu4jFiBgZxtqxHWvXk1jd+5D79iG7u5ADAzMedyTGsUpP/6UQ/f3Igo3nHZ65hMsvDzn5ZItdu6ZfLwhD+OIXLT72sUrj+1ssIp/cidy5A2vHDuTu3cjeHmR/30HPcx3qZy0mpDPiOKiWFnRrG2pJJ6pjCWrJEoqtMSgW8Uda6+Lak68jeMlLAq64YrKPQS4Hd99t85vf2GzZIqvtJSubVtGd20c5nHmOpLz/NHr2n8bgfS/lm8/+Pj99/M94/ikv4CVr/5S1LafP5V92TKC1prfYw57sHjoS7ZycOZUDhf1sHtxE3stxdvu5rE6v5v7997I7u4uM28zVq5+NEJIH9t+Lr3zOaD2T8zoumNIvSGuNr3wc6RwWh//bb7e45ZZo0kCjGS4Pka1keWLI56X/MMhH/2c7Lz3tT3GsyUIFGzZYhHMcut9yi5x13vPBB2df6ysHlWn3FZ68gOyWK/EGV+KPdOJn29Ghg3TLyFgRt7WH/BOXjTlXmd2ju1meWkHKSU173uHyMP2l8c7mgwwiELiWS9yK0+SmZzyH4egQBJGN7o4dFr/4RVSXTkciU+ecozjvvJCzz1YmiNJYymXsbVuxtj8RjTWe3IG1d08kKjSBIz0/ptHkbUVPzKcvHtAbC+iL+Qy4AUNuyLAbCS4MOSGePH7EFObKTL6hXzllgKeHPrHFbE9jMBgMhgVlcazgH0E+97nP8ZWvNCIXTnx5MiIKhulIpca/yFUq0790TsfEY5LJg4sQYjAY5o+baOKiq/+Ki67+K95YrStmR9i/Z9AYdRgMhkVHPhfw8jfPPAkeBifepNZ05PNwww0ut9xiHzYnRSEiI8vOTkVHh2bJEk17e+TMlk5r0uloQjmT0aRSc/dXCrwyA12b6T+wjYGB3fQP76V/6AB9pX56g2GGdJ6smEI1P17dpkECZqR5fKDQFIVPEZ8BiqCItjlowjlasnPvz1ClTixhYQkLR3mkLYmtBDlbkVATFvVmWAXZMbKdt238Vz7yobfy9Ot/grV717Rtd3qrJ9WJXA5p2ajOTiASJPH9hYvy0tMj+PCHY1xzTcA//INH2tiLjUM+uRNrf3d0Q1MKOTiAvXED9oZHoigZ80Cj6YkF9MZ9HCU4Mx/HnsH4Yyzbmsq87/xu+mJTf4k9qdjeVOadF3Zx8UiSR1omR+MSxQLYR9jSXanI+v4YMfZVWpOtjJKtjNKdn/txmVgzbbFGpNaac1BbvI22eDtt8XY6kktocpoOX+ePQ3w/ukd1d0u6uxvp/v2R0IKJdmU4VDwPBgbEnI154/FInCESaRgr2KDp7BR14YbWVl0LbD13asIINTGESnmcCIKoVKoOpRXwKohyORI9qKYN59Pa/pp4QgVRPR+eFzmmHoRI7nGH7yOqn8OCmolJgW5KRxGhMhlUupZvRmcy6HQalWlGNzejWtvQ7e3odGbBxbYMBoNh0aE1YnQEOTCA7O9DDA0hR0cQw8NR/cgwYmQYOTwciRceC+IJC0UQMlrRVSvB6r9bgyCEMERHSqRkUrNHQZuOt7zFZ/9+yf33j38fXJLsxJY2/aX+Rnfyrez934/Q+Zz/JXPh7YvmEZX1smS9LHuyu6fcb2vBJXI1fxVcyAXOmulFk6p1h8uaVWk1a3TsQzWCPrn5FD501b/zoXv+GTXLpO5gaZD33fkuPvOsz7MstfyQrnu0eeIJI3R1rNLXJ7j5Zpubb7bJZDTPeEbIs54VcMEFyuiXzYTWWE9sw/3db3DvuG3e85CGExPZ14fs68O5685qhSA882z8iy4huOhignPPj5TODQD0Fft4tO8hNg08xmMDG9mX6zraXZoRrUH7ccJyElVOEZZTqEqSsNyEKidRfgwdOOgghvJttOeiPCeq89woDS1QAq0EKAlKorWoplE5GoyGkRh9XYBeNcoiREgfYVUQtoeUlTF5D2FXkHYFYfkIy0M6ZaRTQLpFLLeAcItIp4gVKyKcEkJKkAKEjOZHqnktRLUs65uWVZEyq1G3wDM7MzJaGeGBA/fzwIH7gUjU+bSWM7io82Iu6ryE8zouIGEfG2shi4HRUdi0yWLjRsmmTRY7dkgz52+YM7mc4IEHLB54IHrPbWnRXHppyOWXh1xxRWjWuw8TIpfF2roVe8smrO3bsHfuQAzOLPZ/NFHM/MLhDPcDh+ddWUp44xt9PvShmcde69db3PWDHp4/ciPO+gew9u9jrAHXMeea4fvIKAQ81hPbGvVxD3nVXoK+VLT2NU6A1AIBUlh0dk79IEin4dprA669NmDbNskPf+hw992RLc/K9Cr2jO4m0MHs3Rtexv6b3s3IKRv56TX/y81P/pK1LWt55Rmv4U/WPPewCAscKn7ok/Oz7B7dxeNDWxksD2IJi6XJpSSdFF5YoRJW6C32sqHvkWnnzqbjhse+OqnunPZzec9l/8yazEkA7M3u4btbvs3d3X+sizC0J9qrYqltnNR8Ms9c+SxOaz2dol9kpDJMwk6QdjPzEk398Y8b8589hQPkvFy9nO1r4zM//wN3X34HH3nKf/DE8BM82LuOnJfllOZTGdr0amBu7zp79y7MZERlBvEP5cc58It3zOt8Siv257tZlV5Nwk6wZo2ipUXT3x8FpigH5UkCDDU0mkr1uzDqjdLkNLE8tWLSdzrUISPlEXJ+NMdgC5ukkyLlpIhZU39+gQoIdYglrEUjgnu8kMsJ1q2zWLfOAhxiMc2FFyouvTTk0ktD1qw5sUSmxNAg9uZN2Jsew960EWvn9ikFF44UCk1PPKAr4bE36bEv4bEv4dOd8OmL+RQt8/JyMORczSOdHlcd7Y4YDAaD4YhxQo0gN2zYwFe+8pUphRcsy+Kkk05izZo1NDU14TgHbwBiOD6ZKJhQLpfRWs9rsqJYHG+sYkQYDIajSzLTwmnntxztbhgMBsMk8rkAmN65GSAMZ190ORG4/36Lz33OZXBw4WZqW1oidd4zzlCsXh1tK1fqQ7LnKgwfYN/2dezb9xhd/dvoyu6hq9JLtxglnEkO6ASagDYsPL5Q+LKCTwA6iHwgYjDWfEBPEGHQsxjv57wc/7zjM7zlfX/PKwqnErvzD7i//XUkdT2GHZU1Ux4vRoYhkyHRGuNnPytRLsOOHZLHH4+2Rx+1yOUO7Yt/2202Dz9s8YEPVLj4YrNQIPd1kbzus9iPPnzI53qopciPVg3xYGtx3CJMm2fzTzs6eW5fptHYtin93VvwnvcC4v/7bWI//QmeUHzonP3TCjBMZCoBBiByvs3mpt53GJHZUTS6YTRZ38YaVQqO5Zt3Tbhhd3bmcUjCTtCZXEpnspMliU6WJKtbNYLrkmTntIvbxzOeB/v2CXbvluzeLdm7V7J7d2RMYIwuDwM1i61xqW6EB5i4/3BJMB4Vw7HJ/06Brlqxj68f/7lEaWVU09sDvfVjNEI38qARmiiCN4pmp0irm6fNydFi52izs7RaWdrkKK1imDY5QpsaoC0cIBHOQ/nFsHhROorcns1CN8xJ+si2IkGG1jZUWzu6vR3VFm26LapTSzrRra3zVPYwTIfSCi/0CJSPr3x8FRAoHy/0CHWAF/rj9oVVAzONJlRRqnSI0gqldTVVaKI01CFaa8JqG4iieAkhpk4n1UmEENjSxhYWtnSivHRwpI0tbSwRpY60saSNI536/pgVJ27HkeLIf1+0jl5xwsh3vH5LrQ3/xuYn1tX8Z04kg7LjimIRq2c/8sABZF8vcqAfMdBfF12QAwNGBGgGRpl+TkEEAVpK0qmDFw2QEj7wgQrveU+cHTvG3xta4224VowDhf31e5YOHXp/+0YKT15A5/O+hd00ctDXPiKUSuie/Tzkb+UR/Xs+vnkFVw/M4nETi6GamyOhpObmar5lTL45eg63d6DaO+bssFoKSrMOc5MLIM53xfIrefdl/8yn139i1rZ9xT7ed+e7+M+nf5KTMicf8rWPFtu3z/255jjQ3KxJJjWJBCSTmmQSEokojcqRcJrjgOtqHIcxm67Wg23r+vPJsiY/sxp+oY2/vFKRaKBS0bOwlp9YpzWEoSAIoudnpQJBIPC86JbpeWJMfVSuVKBUEpRKUCwKisWoXEtLpShdrGSzDUGG9nZdd6Lp7DzWPIsOI/k8sd/cjPubW7D27D7avVkQFJqK1PhSE9oCZVkEro2yLJQUKKFRQCg0GrCiETEWEgFYSKQGISSWBicEN9TYgUKEClEbfKrwxBJymgtKY23dgrV1C/zgu2DbBOecS3DhxfgXX0p4zrnRze0EwQs9HhvYwPqeB3iwZ/28HdQOB1qDKjXhZzsIC80EhWaCfGs130JYaI62ShJVSqFDMX7uakxe1OaxjiVvTaGQTgHLyWPFh7Djw1ixkWo6jBUfHlM3hBUfRogJ/z7ZcODUlhXlq5uemLft6nd+YZ6VSmueGN7GE8Pb+PG2H2JLi7PazuHCJRdz+bIrObv9nKPybr5YqVRgwwbJ+vUWjzxisWeP+WwMC8fIiOC222xuu83GsuCCC0Ke9rSQpzwlNGPNQ0AMDuI88iD2xg1YWzYfc+PTUM98n7GKh3dd5sorQy6+OOSRR6YZb5VKWP19XP+vwzz9pN/RZmeP5eXyGSlaCuUnUF7VLkKD0NFLsrYUOA5CiDn9Xs88U/GRj1TYtk3yta85bNxo0ZHsoKfQM/f+7LqAPf/fJ2i+5FaCp/ycT4x8jMcGNvKPl7yHUIdsGdzESGWEpJ2kI7GEjkQHKafpoEQaSkGJvJen4Ocp+IXqFuUBmtwmykGZvdnddOe7yfs5cl6WnJcj5+WohPMPfHmobBnczN/+9q/IuBmy3mRBQF/59BR66p/5vfvv5gdbvzvluRJ2goybYUXTSp656tm84JQXTunI3z8YsGFrgbyfr4sJTKTUdTabTrmRV/7yZZP27ft1C8Xh87CExBI2KSdFe6IDKSSloMhQeYhQhdG6BDJa79FhtY9JWmItlIMylbBC9IYKlrCJ23ESdgJLTP4dH46/jUYzUBpgdXo1H/lIhTVrNHfcYfGxj8UYLM9d9Cbv5xkqD9Ke6KjXKa3Yl+sa128Pj2JQZKDUT8pJsSy5HEtG/9ZQBfQUeyn4jXulK12SToqWWAuu1Ziv/pu/8XnVq3w+8xmX2247odzsFpRKZawoA3R0NESmLr885Lhyn1IKuXdPJLiw+THszZuQB/Yfna6g2R/32dFUYWdThe2pCrtSHvsTHv7E90/DIaPa2tEpE8DIYDAYTiROqNHh5z73uXFlrTUdHR38wz/8Ay960YvIZDJTH2gwAK2trQgh0NVFHt/3GRwcpKOjY5YjG/T29o4rt7e3L2gfDQaDwWAwHB9Y9uzD9PAoqqMuBkoluP56l9/+9tBfaVpbNVddFS0annOOorPz0NR3s/172LHpdnbuXscTA1t5otJFr5hi0fM4XXQ0LC6EnNk5ZL4iDAChVnxpwxdZv+wK3vvW99Px6teR/Mx/Y294pN5mZ2X1tMfL7CinXLIEKSGZhAsuUFxwQXRPUwq2bpU88EC0GLNz58EZLg0PC97//jh/8zcer351cOL4+SmFvfkxnDvvwH7i8cgodYH45bJRPn5mD2qKhZkhN+DD5xwgHkqeMRgtMGS/+V3UsijiRumt/4B72+/5dWoPe5PewnTIO/KL9GJ0BDE6MoeGVWEG2fBi0EKOi3RV83LQtbxlNSJgWWOjZSzOh0UpKLEnu3tGA99MrJnORCdLU8voTC5laXJpVbghyjfHWhZlFI654HnQ1SXYsycSW9izR7JnzwkotlAzkK574KjIcVuP9czRoBWimjaOqQoDqJrjv5osBDDVNlZ8wHBE0MAIMEKSXSSBpTO2T8gKLVaWNmuUNitLi52l3Rqt1mVprQk4WKO0WDmkWfA/fgjCRmSomdrZNmpJJ6pzKWrp0igdm1/SuSgimtYECXw1XsjADz0CFRCoAE9FAghRvtou9KcQQIjaNM7VEEsIdIAf+lPuC3VQv+ZYkYVa29mihh8vONIhbsdxRRwraMEOMlh+M8JPI4M0wmtC+mnw01hhChnGEWESEcbQfhzCGNp3UYFL6DsEnkWlIsaJLNS2IGg4mx4KQkQ+MY6jse2a82vDGXbsvkQC4vHIgTaRaKTj62sOt5qmJmhqipxvT5j3nIVEa8TAANb+fZHQwv5uZM8BrAOR8MKcxvuGacmKWeYUlCKTPLRACMkkfOITZd73vji7do3/EaScFGvSJ9FT3E85aLwz5rdfRnHvOXQ840aaL/oDwlqE4rZhgNXdVb8BKaH5+Jk9XD6cIhnO8GOvVJB9fdA3dfS4ieh0uiGW1LEE1d4R5TuXEi5dFr3HJ5N1A/qZSNkLYy37/JOvZbA0wDc33TBr255CD++8/W188MqPcOXyYzPG1BNPzOwkvHKl4r/+q1IVXzja0wJzG2soraoG/mW80MNTHqEKCXWAqgo61cpRGqK0rupZyrqYkxRyjKCTRCuJX0hQyseoFOIU8y7lvEsh71LMO2RHJSMjgv5+wcCAoFA4Oh/W4KDgu991+P73Ha64IuRFLwq44orwhH1OywP7if30/3B/czOiVDra3UE3NaHTGcrNKQaaXQYyNsMpi5wbRazLOYqcDMhZPjnhU5IBZRFSFiGeDihrD0/5VKppfd4PAWi0ClCVGGE5hSonCctNqHIK5cVRvov2Y6hgQuq76CCGDmy0skALpHCRlo20bIS2EdpBaguBhSWi6UJbWthS4kqBLQSuEDhCEBOCuKVJWpqk1DRZiqTQxIWPqyvEVAlXlUiqPCmVJxnkSIVZmoIRkt4ITf4ISX+ElCzjiEX4jJyKIMDeuAF74wbi//stdDqNf/kV+Fc+leDyK9Dp48/+r6dwgPv338v6ngd4tP8RvHCB5tnngfLieEPL8YaWEYwuwR/tIMi242c78Ec70EFsjAjo2Dk/xs/74U+7RCoAoUECQotqGu0ZK38s9Jh89f+1KaaJMslzeZqNbaNFVFOdiUSLMZqn6Hq5sU+jtUR5aZSXxi/MHolcSB872YeT7MVO9eIke3FSvTjJnnpZ2o3x2JSfV+3F07LRth3lbRtt2WBbaMcB2zmoF8dAhWwaeIxNA4/xva3foSXWwpXLn8JTVjyNS5ZeRsJOzPucxzJaR+sB69dbPPigxYYN1tHT5qvPx4eT597HpkqN+c2NFe+dnLeEJul6xC2fhOOTsAPitk/SjspxOyBmBTiWwrY1riuwHXBccGMCxxXRXEdcYrvRJh0LHAcZdyAeQyZiiHgMUUvjLpYtq2Jg0bgw+qeJSeJfY5chGqKZ4wW/fL+WB98X9bznCcrl8aJfhcKxIfoF0VzVI49EYh9f/CKce27INdeEXH11gDF1nwXPw97wCM5D67EffhBr18zi84sdxcz3cinCw3p9IeCtb/V461sTkzSSxPBQtC4AjNLEf/e9gY8vv+6IvMsqIoG0itSUpaJiRXlPKgIRiaMpEc2xBEITiuiYUEAgNbYS2FrgaIGjos3WRPlxdY1y3lb4xc4p+yPCEC0lUkiWLJn73+TMMxWf/nSF++6z+PwX0ozsGqEclOd8vNYWIw89n+zGq2m96pf8Sv2Srtxe+oq9Uwo6xKwYrfFW4laC1ngr5y+5kEs6L+OOrtvZk91FKSjhK5+Mm+Gs9nMo+SUe7nuQvdk9c+7TYmMqAYb5UgpKlIISvcVeHul7mG9uvoH3XfZ+OlPVdVOt2Ty4mc/e+CD7C2+e8Vz5x6+k45k3TqrXSlDefxoQ2WWF2sOreBSCAk1OmqFZxAu80GO0MjJjm5STwpY2paBEoAIEoi7iMB1pN03STjFQ6p+17VhKQZGm5gqrV0c3jtWrFYEKxokhzIXh8jCt8TYuvEDz2GMWfcXeGYUjCn6B7vw+VqfXoFDsy3dRmfD+5Knosx2pDNORWEJbvA2I5uUcB1asmPwWURM3t4R1xO1cMhnNS14SUChAoSCqG+TzgpERweiomBg7aVExMCD47W9tfvtbG8eBSy8NeeYzA666KiQ9iwbxosPzsLdtxdq8CXvTRuwtmxG5Ix9ESKHZlfLYlCmxNV2OhBdSFUrWETJYmhS8qPomPqasxyrYw5gX2zG/HzGxPHEfE17YxxXG7NOzthW196Bx70gT35P0FMdOwHFQ7R1YLe2c3nrm9O0MBoPBcNxxwogwZLNZ1q1bV3eiF0Jw7rnn8o1vfIPm5uaj3T3DMUA8HmfFihV0d3fX6/bv3z8vEYYDBw6MK5966qkL1j+DwWAwGAzHD5Fa8cxGIeEJ5eE3niefFHzsYzH27j14K8ZVqxTPfGbIU58acvrp6pAMIgf3bWPzw7/gsd1381huG7sZHt9gca/dG45zhDWzIZ4OJzg/OHOPSLm+Zx1v/t0b+derPsJF//1Z3Jt/QfJrX4ZymR3e9CIMolDglFOmFqSTEs49V3HuuYo3vtFn3z7BrbdGCzEDA/P7MSkF3/iGS1+f5J3v9BarL/vCoDXubb8j/u1vIHvmHhlhrgw5AZ89vXdKAYZ6F9B85dR+nj6YoviBD9UFGACQEu9pT+NHA48ueN8WJVqDDmHMo3omo9IZGSPSoGUk1IBtRYaVtehX9pi8ZR9tD4062coo2cooO0a2T7k/ZsWqogydLE0uq4o1dFZFGpbRkVhSj05wtFAK9u8X7NoViS3s3h3lu7uPI7GFmvViGEIYoIMgciAIQ7QKo8gttVRHxp1aKXRVdKFmcHwoiDEbWowzoK7aPEd5IcbVS0DqxfF9NzQoqRgltYQD/pJZ2wo0LVYuEmioijO0WDmarTwZmSNjFWi28qRllNbyRrjh4NBV40JfRIaJXnULRC2v8IUmkNTzntQEshbNtWG0GAod5alGeRVj9jNmvwAlIKhGgg3raRe6AmEX6K6oX7X9CAjiLiqZImhKolIpVCpJkEyikgmU66C0RqHqQglKR/eosfVaa5SODKJqhlGhDqv1aly5lur6Oc137HCiQ5uw1ERYTBOWm6J8KY2qplE52iIHtgSqkkT58xXnUECxujUQCCxhYUkrSoWFrOdltd6ut7GFPW+DOq2pOgBMPG7hnltCQCrVEGWItiifTo8vNzVpmpshnY72pVIngICD1oj+fqzdu7D27q6me5B7diOKxdmPNxwUOT27CENz6tCFdpqb4ZOfLPOe98Tp6hr/ZXYtlzXpkxgoDTBUHmpcupKk79a/Znj9C2l/+k9In3MvQi6e+70cHp6kADPihPxs+Qiv29e2YNcRuRxWLgczRP3U6TT9q5uQp3aD40QOfI6Djsejd84qKSe1YP167Vl/SV+xl5uf/OWsbYt+kQ/d/c+885L38OK1L12wPhwptm+f+QZ8zjlqSkPvw4XSitHKCMPlIbLVCJUFv0DOy5L38+T9PAUvR97Pk/NylIIi5bCCF1aoBBXKYZlAHWEr71i0yQ6Ba8VI2AlanSaWhi3IwnIodhLmOqgMLaEw0EG+v5Vsfws6dLCEhS0sLGkveERvpeD++y3uv99i5UrFq18d8JznBDiHpj1zzGA9sY34D76Lc+9dVeHFw49uaSFcsZJcZyvdHS49zTb7U4qemE+vXWKYEkOVYYYrQxT9OUQh1EDVn0T5Lv7oEoLsSoJ8C0G+lbDQTFBoidJ8C2Exg/IWiyPy5HGmJZKTxr31/MQxr7QQSpOwAzLxCplYiWa7SLOVIyPyNDNCsxqmxetjSbmLJYU9LGGAJllcFFORIpfDvf023NtvAykIzrsA/4qr8J/6dNTqNUe7eweF1po92d38setO7uq6kyeGpp5jXfjrQpBvxetbgze4oiq6sBx/aDlBoWV8wzFe0ZYGS/nYYZSXVQEFSwukBkvLKKW6T0fvZrI671crH+toIkfPKI0cY7SI3k5VbZ4ETShswvIa1PAaQqEp1udcGnMkdmIAN92Fm96Lk96Hm9kblVP7I1GxxovnuE9u0qdoRc7w2q6O6SJVwGrZjvbP8tmPVEb47e5f89vdv8aRDlcufwp/suY5XLH8KmLW0RfSPBwoBZs3S+66y+K++2x6ehb4+6l1XRFSVOfmCUNEEEYCC2FYF1sQoWrM4U8zZyXQkfCtHQnjZqw8GZknYxVIWwUyMk/aKpKRBdJWnrQskpRlErIyvQCPAirV7XAQj6PjcXQigU4m0alIOEmn0+hMBpXOoJvSUTmdRmea0U1NqHSGhVIrUwqKRcjlGg6Mo6MwMiLIZht1w8OCwUHB0JCY0R/rcLN5s8XmzRZf+pLLZZeFPPe5AU95SnjCjDdnJZ/HWXcf7j13Y69/4LAJgmk0gYCypShLhS/Hz4uPdfoXiOgZWX8eivpzMqYEcSWJhQJrlvtwqGd+d7Hn4RR9sJx6quYFLwj49a8b8wKyvx8xPDSu3R35y/nxyPN4TdvvZj2nJxSDbshALGDIDRhyQ3J2SN5W5OyQnK0oVPMFKxJZ8KSiIhtiC0cD/8AV0+8MQ6SQdHbO7z1ZCHjqU0MuuCDk79+d4Y8Pl+e9/qr8OIN3vZJS11nol38O6U59A6+Elbo4w+7sLh7pe5jvbP7mlG0f6Xt4nr04cchWRvnQPR+YVD/05F/Peqyfa0Pr8Y8yrSSjG5+F8uOT2nuhx1A4swDDXJmL8GqjU9G3MIZDs5sh7aYZrYwwVB6asxhD8ylPIMRaAFau1OQOQhBD6ZBscZCr14zw4N2tZL3qfafm7D12saP6flIO8oxU9uCrgAqlRltrTCCUquLTQG4/bjZPRjmc/rPvkPrdXk7dcTrWnpdF5xIh/a5P3lZgWQghiVtxmkKLFt/GqgWfqL0jSYmOxdDNLY2+BQGiXAI/oOE4Xv0SxGLoeGLyok0Y1tuetqrCG1482LiGEJHdUHVcry2bQsVitCpY2hjHROKhAwOyLmJ6tMczvt+YP7MsuPDCkGc8I+RpTwtobT16/ZoOMTKMvWUz9qaNkfDCE49DcPifuxMZcQI2Z8psypTYlCmzJVOmYM2xH0JEQYAsGdmW1YIDyVqwoGqQIWE1gg3VggrVAw5VRUlrhu3Hwfv7zES/tcheqfEb11SDKgEvXftyOhJz9yM0GAwGw7HPCSPC8NBDDxGGYd1QKhaL8YUvfMEIMBjmxSmnnDJOhGHnzp1ccMEFcz5+586d48pGhMFgMBgMBsNUzMUQPggXsXztYeSOOyw+9akY3kEEeLFtePazA1784oCzz1YHvS4feGW2rruJdY/9ggcGH2GvGDm4ExkMRwAhZw7FotWYaQFn/hFxRisj/PMf383LTnsFr3nu62g/93ysN//DzI6Xvs/algFg9hAdq1Zp/uZvfP7yL33uvtvixz92ZjVWn8ivfmVzzjkhz33ukV8EOSTyeWQ+h2prj0LnTkWpFEX7+uF3sTc9dkiXK1ghmzNlsnaIpQWnFWKsKjkIBL9aPjonteydqQq7kh4d55w3ad/6Czt58v7DZal1HFML9RMEk5awpn2MVQUZtGU3RBrGRsKq5Y+ywEElrNCV20tXbu+U+6UQtMc7xogzLGNpcllDuCG1bMEibmkdqe/v3i3YvVvWRRf27JEHNeY4EtSchsc6IEdbtU4FqNBHBQFKhWgdoqpCClqPcVBG1Y2CJyIsD2kXkXYJYXkI6UV1loewKtU6P6qTHsKuRGURggyjVCiEDKJU1OpChFTVugAtFEKMvcc0OqMniSyMtUYRaG0hlYUd2tjKxgptrMDBUja2sqJyaCOUjR062KGNFTqIwEWELgQxZOiiQxetXFQYQ4UOSrmEysVXDp52qMzmUGg4KDSC4TDDcJhh1xx/awJN2iqSrhoRN8s8aatAkyySkiWaZImUFeWjcmRQXMs3ySKOCBaFk8h0aCLxg5ytyFYNDvNVg8OiHRl2li1NqWrkWarmK5aiLMfXly1VNUaMhBf0IcumHEkGG/7z/WOqpaw6hLqN1K2VbY5/o4/FiVaSsJBpOKUVmsc4qjUTFpoJCy0E+ZYpjQiPaF/RBDqY17yKFBJb2tjCxpaRs5ota3m7nl9oZ86Z0DqKcpTPw3y/91I2xBrS6UicIZNplDOZqNzUpMlkGvsXpXiD1oi+Pqw9u7H27KqmuyOxhUUQfftEI8fMYyYBpFMLY57Q2gqf/nSZD30ozhNPjP9iCiFYklxCk9tEb2F8ZDR/dAk9N7+NoftfQvvTb6Lp9IcQczVWPIyIwtQR4H60ephXdbdiH0HxMZHLUdrXh+iMIng1AlQJdKoJtWwZSIuU07Rw1xSCd1z8TwyWB7l//72zttfAdQ9/hkD5vOz0P1+wfhxOBgcF995r0ds789/yjDMWzomk4BfoLfbQV+yjr9BDX7GXgfIAQ6VBRirDDJeHyXqjx6wAldKaclCmHJQZLg8DXSAegxTRtqzRNqkEQa4Nf3gZ+YGVVPpOwus9lXBoDZaOVZ/lDra0ccbkbWkflFNwd7fks591+c53HF7xCp8XvjAgsVh89RcYuetJEt/+Bs49dx22a+hMhtxpJ7N7bQe7l8bY3RSyx87T7fXSU9hNwd/caFyubnNAebHIyXxgFf5IJ/7oErzhpQSjS8Y7mx+jhDqMHGPmeFupj3FztXFvGku21sfBjhUJmQCRx3wY4iqfjmSRdjfLEmeEJfSzxN/PsuKTrCw8wUq7jxYrd2TfwZXG3rgBe+MGEjd8lfDkU/CfcTXeM5+FOvmUI9iR+aO0YtvQ49zT/UfuPXA3+3Jdh/d6voM3sIpK3xoq/Wuo9K3B619DWG4ILQkEDpKYglQITqBwfIUTKiwlsLWFdZwIKCwEgsjBFqg6Vh3c56KEJiisIBhcQSCuIJCaktDkJPgyxG7eDa07iTU/SaxlJ7GWJ3FSBxBTCZfWHP2rN8dJPZIS7Krwlus2BLiqKRPec33lc3f3H7m7+48k7ARPXfl0nr36OVy69DJseWybIgcBbNgguftum7vvthgZOcjvdW1NJ/DBb6QEPiII6n+TuRIXFZY7/ayIDbDM6WeJNUK7PUy7PUqbNUq7PUKblcUSR8cZ+WDR5RKqXCIcHSKQkYhrMFfxXdtGtbYgm9uQLe1YbR2IlnZEWwe0taNa29AdHaj2jmg9bBqi+ZFojmT58tmv7fvRuL6vT9DfH6U9PZJ9+wR798qD/87MkyBoOC+2tESO8S96UcCyZcfmuP6QKBZx770L5/ZbcR55aM5OkRpN0YoEAAbdhgBAvjonn7ND8k4tH83PV6SuCi/oGQMXHAyOFsRDSTwUxJQkFUjSgUVTNX1EFRkoBHVBB7sq4lB75si5DvgOkTe8weOeeyyyWYHs60WMjEzZ7n/6/4rf5J7OizJ3kbZHKab7GU0PkMv005ceojvl0x33GHWO/nzMwRAUlk27T2iFLSXt7Qf3HWlqgi99NsZfvi3FI1vn4Sw/huLu8+n6/odY8fLPYaeHAL2ohEiPV7QSBNkORh5+7uxtA5fi7vNBSZQfw04P0/vrv8UbXHUEejoHtI7GMtXxSnKkHysYwrIs2l2XVjfFqKsZoojPzL/jQucdBNlW+p54iN59mxjRTwFvCUJrdE0YwZ4QaKQmVqUUQivQMFzp5sEtb2Bv8VuTxrO6ahOD7yPGiNwOMApMGP+GYTTOrQlhVTnAMKpss+vA9+m2y3RV9jKqnseoE1Ks2kqJoHF8uTJCWWuGNCytODT7DdubUSck54f4pf3IZBPJQNA0WiQRzrC44jiEy1eA4yAH+hH5/Ljx4imDt9O85RszftatwCrbjgQgEglIJKtiV6koXZVAn54kiKUYFB30hEvornTQXWxl32iGfUNN7B+IkyscuUWgMISHH7Z4+GGLL3whEpm65pqApz41JH40lhKVQu7Zjb11C/aWTdibHkN27zsKHYGipXi4pciDrUXWtxbYmZrC3s62o++zVbMHq9qJ2XbDXsyqiigcwXd2rUEHTiSy7yVQlQTKi6MDFx3a6MBBh07UpppG9S4oGdkIaVm1B5Kgq3VqbN4Coas2RzrKo0HWylUbJAEIBeioXiqEDBFWEIkbVlNhBQg5Jj/FJh0PGc+TbPJ5zVl/wevOfv0R+0wNBoPBsDg4tmc+50FfX189L4TgOc95DitWrDiKPTIci5x99tncfffd9fIjjzzCy1/+8jkd29fXN07AwXEc1q5du+B9NBgMBoPBcOwTCYaKGR1kguDYWkQ/VJSCb3/b4fvfn7+MfzyuednLAl7+cp+2gwwcVylmWX/7Ddyz7WbWl7aRF1XHdmNTZFjkCDmzY5FWDQcJ7Rycg6nSmpu238jPd/wfz1z1bJ76p2+GT09u5wtdj3x0Wv4R4Oo5X8O24VnPCrn66pAHHrC44QaHPXvmvvBzxx32sSHCoDX2ow8T/+H3sDc8AqEC2yJcezqqYwn4HnJkBDE6ghwZgcrBixr0uT4bWkpsaI62nanKJIORZt/i2f1p7m2f+wL/fWvgRUsnGx5833osesAdo4b9xxR1o8qGR/OUjyspq6IMTqSSbzeiX9WjYB1FoQalNf2lfvpL/dO2SbvpqijDUtribTTHWmiJtdTTKN9Kc6wZW9poDUNDom4QF4ktRMILudyReahPKZ7AFCIK1S2csj6K2M4Um6hHP1BY7iiWm8OKZbHcUWw3hxUbxXKzWG4OaZeQTjHa7CLSKUR1dlQn5DFw35yGEGYx+ZgbrpKkA8lS3yJVSRCvNBGrJIlXUjiVJLaXxPGSSD+F9BMIPwl+Au0nUEGSkoqTVynyKkEuTFFQCXIqRVEdXQfkYxmNIBumyIYpumfWmpoWW4SkZImELJMQZeLSIy484rJCXFSIS69en5AVYqJCYsy+uPBIyDKu8KvHeMRFhZj0iYsKrvBRQkcGm05ksFmwGwab9UhOTkh2TCSn7Jh6f4GNOI8rlIJKBVEdB427ewsBjot2xwozuGjXqRpcmxe4+aI1qHKKINcWOS7m2gmybQS59vEiC8U0x/Pnq7TCCz08ZlaMkULWHTcd6VTTRtmS1qJwTlIKstkoGtJ8EKIh3jBWnKEm1tAQchgv5rAg4g1KIfv7kLsniC3s3WPEFhYRs4kwSMSCGk+2tUVCDB//eIz77pv87pKwE5zUfDKj5RFyXo5iUKzv8wZXceDn70RYPrElXUi3VDW6C8cZ4Y01vEOGkaGdW0Y4ZaRTQboVhFNBumWseB4ZL2DFC/MTdgjDad/ve2M+f37Vk7R4FpnAIh1IMr5FOrDI+JIW36bds2jzbNo8izbfXhDBhoI9Rf+1RuRzWPsCwtWrSTrJQ77OWCxp8a9XfZQP3f3+OUdavP7Rz3OgcIA3nPd3xO3FNcb2PLjzzsiIePNmyYEDc7sRnn76/Ob9s5VRunJd7Mt3sS+3l325fezP76O32DtFdMMx749Kg1bjymJsJL6J1OsjA/m6ofzYTU4oL4JnXg0hNU7zIE7zIMmTGw77OrSp9K+i3H06pe4zyO87gyDX3jgOsKWDa7k40sGRbiNvObM+1wcGBF/5isv3v+/wutf5vOQlwbRaq8cacl8X8e98E/eO26b8yhwsoYRdZy5n61lL2LbcYXuiyN6gn4HSxqiBBwzNeIpJaCXwh5dR6V9NpX81XjX1RzpZTN/To02oQ8IwHCdeNBGJxLbs6u8h2oZyLrZcjiPXYI2dS4xp8H0Suszy5AgrrF5WBntZWXiCVf5uVjk9rHZ7scXhnX+ydu/C2r2L+P9+C7XmJLyaIMMppy5IFPVDJVQhG/sf5e79d3Fv910MlAaAw9M1P9dKed8ZlLpPp9x9BpXek9A6ekdxLAdXODQrgasg5oe4lQC74jN5lk0AR1fg93hHaoGrxTSjawcKZ6H3n4lfFd0sCA1uEad5N7ptO37HE8RbtxFv3Y60Z1lHUgq8CsKrQGGKu6Jt14Uwa3MtNYGGEkVu2/N7btvze9JummeuehYvOOVFnNl6Vj1Q2mLH8yLHr7vusrjvPmv2dYKqU+JUIgsi8KN98xBYqJGUZU5y93OSu5+TnQOsdg9EwgtOP80yf1RuV55Q5JxGNPp8XSxWUbQUlTEisOWac/rYfDX1pK4LLAQSQqHnJ7gwFwrVrbvhoF7bLNtFujFcN4kbS+HGm4glM8RSLbjpNmLxJuJWnJgdw7ViUd6KkXKaSDkpmpwmUk4TTW5U7uhsYtmyqc3u83nYt0+OW4PasUMyMHD4/oAjI4If/tDhRz9yuOyykJe+NOCKK8LFJ6K5kAQB9kMP4t72O9x7757yfTpvhRyI+/TEA3riPr0xnwPxgN64XxVdCKnIw2hzVYvMXos6La3xEaQnRJSuABVgtPZjn+CM3NcfMtI72e4jHUiWlR3kgqyIzU5rK7z97R6feHduWgEGT0YCF39gNb/Ov4aKpdG5MQ1EiB0fxooPYceHsGIj2InBKK3VxYejNrHhSNR9keEXO6fdJ7Sgo6MeJPugaGqC73+1jY9f53Lzb30qlUgEaaZx+kQqvSez6yufi/okQ5zmflJrH6HprHXEl+84JkQZdGgTlpMIqZDxPMFoB5WBVejQwW4aQcaKlLtPxx9eikzkiXXuRXlxKr0no30Xd0kXqbWPYqey487r51qp9JxCUGhB2tGcXrSVcNp6sOLFaXoUERQyFHefhz+6hLCYwR9dgj+0DH9kKVrN/Q/f/eN/PqjP5YgwQcwgVhMPCENEqYRVKtEGtKLZlqlU73GN6PD1QCNaM5j/Ci/+wgcb54p/lmAkmncRNduhMIzW9aSM5h89b5JdkUx3sW7NDuS6IioYPycp5iNwVTv/FAy09PKfFzwJQFAqc2DnFAvRE45XAg7EfQ7EfVwl8Cb+tkqjlIDBJDhK0FKd15UaJNF0iic1oS4jD+wmpi3EFDbBq5zeuf37ggARBIjC9DZeMSLt0jXT7M/areyyT2eHOJ0d6hR2llezM7+MXJgAqxr0pSZ8sYADDqVg3TqLdessEgnNM54R8pznBFx4oTps4xoxPIS97XGsLZuxH9+C9fjWo7beFKLZ2FxifWuR9W0FtqTLhLasrnPHwUk37Lmc6rr3YRaG1xpUJUlYzBCW0oTFNGGpaUw+Xc/XBBe0FyesJCIRhXkgEEghEUIgEAghkNUUJLI611yrE2NSRDRDW5unbbyLjqkXtbKoZRl3lBg7yxvldLW+llfVHixd67AsEyDPOXbtqQwGg8FwcJwwIgwj1Rd+rTVCCC655JKj2yHDMcmznvUsvv71r9fL9957b/07NRv33HPPuPKVV15JKpWaprXBYDAYDIYTmblMHCp14kzieB58+tMuf/jD/F5fLAte+lKf173Op6Vl/tdVYcDGu7/PHx75AXflH6N4HAovWAgS2iZGtLnCxsbCFhaOsOubJawxjiN21XkkinxkV41ObctBCAspBFJYWNKOJkSljZSyuk8ipYVlRRHEon3VspBIy0YKCyGtaKL0MFmUaK1RSqGUj1YhSoWEYRQpXKkgcnRVKirXoonrEBWGdSfYsNrWCyoEysMPA/ywQqgDPOUTKB9fBVSUh69DAhXg6QCfgLL2KeFTJqBymA0MhZzZO1GHY4RNxlgAv+jUl+CFHr/f89s5XyvUij903cb/7czgJy6mo2LhKsGAGzDsBoTVP6et4fsj/8XZW/dyRuuZnNV+Dk1zjJ4oBFx1Vcjll4fcfLPNN77hUCjM/j3Ztu3oW5rI3h7sRx4Gr4Je0onKNCN7e7B6DiD3dyMP7MfasR1RnLCoG4RY2x7H2vb4IV1fo9mSLvOr5aPc31bgQHx2z9VRJ+RnK0bmdZ17TrZ4UfW3q7TiQH4/P9r2fdb3P4RMpqaN7jlfUqFF4QhHK71oNMnr97ZRWzeVurYkUxXVBrSAUIBCR6nQKCKjMiUaqQJ8qalIhV+NUN7YFJ4YX1e2IqO2oqUoWZHDbsk6xIjmSoHnjVsknvRrsqxGFKy6OENDrCFaSD96D8aclyPn5dg5smNcvfJd/KFleEPL65seWY0/vALtJbGERCCj51J1qy3S1RfeRGORroaekNNao9BordGoKK3XKTR6vNiCDuf2F5sorlBzhNEaOzZELDGAHR+IjJESg1jxwWp+CDs+gBUfQTpHxzDzeMOTikFXMegGkKoAI/M6PhlGUYrSvqQ5sFgZStK+Rcq3cMsZrEoTdiWNVWlCVNIorwnlp/G8DKUgzWiYYTRsYjRsIhumGVVNlFTssPxbTyQCbdU/15lQQhPWUtFIwzH39vq9Xowpo9F2BWFVkFYFYZeRVhlheUi7XK2fWB7broIce3x1k7X9dq0+Oof5rY9B64bjABOeULJqqFKL7Og28kf7eXa0mF5goba142fb0IG578wVpRWV0KMSTm3EJxDVCNtO3XkzcuaMUnmYDaYOFa0hlxPkcoL9++d+3FjxhnQaEglNPB6JZsZiEItFdbEYxFxFsjJCYrSH5PB+Yv3duH3dxPu6sbwitghxRIAtQmwRYJPGEQlsEWKJsDo+j0ZcAo1E1e+TAl2vq/WrVlffjrdbQc0hGiYL4tXKC2hznWNmJ3gJC+58nEjARz9a4VvfcvjhD51J/0wBNFeF2mqCaKEOq/0RCCERpbMR5aogrqb+nlVPx43pG2Jp/gSxtLFiazhFdGwUGc9XxRmKWIl8VE7ksWJFZCLK27oHpzyA5Y5O6VzQG4scRuZKJrBor9i0+RatXiTS0O7ZtHk2nRWbjkqUpkI5rQN53p7ByaFcQhQKpOY4lzMfYlaMf3/ax/mXu/8fG/s3zOmYm7bfyH0H7uGfL/8Xzu04b8H7NFcGBwVPPilwXdi/X/Kd7zhTOluVgzKjlRHKYZlQBSScJK2xNuJ2HClh7dqpP/tSUGLX6JPsHNnBzpHt7BreQdfILnLlkXERlUUYRNFflUIqFRmiKwUqrBvAHxHqjkWR45Gu5a2qI5KUjUiFlhXlaxHajuDNWFgB8WW7iS/bTculvwfAz7ZR2nMuhScvpLj7fPxyCl9N/g0KBK7lErMih72Y5eJaMRw5WUg6m43EGH72M4c3vMHjWc86dh3jRC5L/DvfIvaLmyIxj0MgRLOzqcLGVQ6Pn9HBtiWCndYIPgeAAxAAudnOMsV5SynK+0+jtP80yvtPo3xgLaqysMIxJyqKqjjZNONdKSTuGLES13IpC5eCt4onxRrg8sjjwwoQnoeVLbMq1scp+klOLW3hJHtf5IDsHiApywvef7l3D/HvfYf4976DWrkK75nPwn/mswjXnnZE7z1e6PFw30Pcve9O7tt/D1kvO/tB80SHFpW+NXXBhVL36QS5dixhEbNiJKw4ra5F3Ne4lQCZLUHl4KItG44OAoFbFc1IAfgZKFwA+y8grK4v5KyQpvQuRMdWiss3Y7VvIdayE2nNQ9m06shFqXbdMYyZayk4Drf07eWWx37ASc2ncO0Zf8ZzTnsRmVjzwv2jF4hSCR58MBJeuP9+i1JpzL8qDCHwEX4wLiUIEH5VZOEQkChOje3jzNhuzojt5tRYNyc5+1liDx/W25AmEowdckKG3ICRajrshgyPq4sEZY9lkdhojlbTcFUOwCuCNwxTLVFa9nhBV9etps60jm0xK1YVZWiiyWki7aZpqQqCt8RaaTmthfPObeUZ8VaaYy1QaqVrd4xt2yRbt0YibQstDK41rF9vsX69xerVij/7s4DnPjcgdhxN68meA7i3/IrYb25GDw8x4AbsTXrsbffZm/ToTnjsj/v0xgLyUwkLLkgnZHWd1I7eXxwbbTlV0XurGnHaWviI09bUf8icrfCSHhfqQ7s3zYfnj/yYBzzBHVxerwuEZsgNyNnRuveMaIug1EFQ6mj8TqNJOjRi/JhMgBXLYyeHsZJZrOQwdnIUKzGKlRyJ8skR7MQIVmIEaY9x3K6vsdIQHKzVhdE7tAjCen4+78p+cem0+wTQ2XnowhHJJPzHB5r44Ltgxw7JXXdZ/O53Nn0jRYbLQ+OERmdDKwtveBneg9cy/OC1WPECiZM2kVi9jcTK7cQ6dx8xUQatISxm8AZWEuTaIiddoVBBDFVOosopwnIqEtDrOXVeogbTXBGneQBhewgrqIpKt8x6lJUcxW3rQXkxrEQep7UXlEV+xyWExcwh9mmRojUoFc0rjXnXl5ppBV8FghVFh/0JP/od+ePHmG7zk7ju3vF1mb0Ueq6YfC7fR7uxaKw1xe/RbXkSIcDN7KE8dPbB/AtnxU3vq+et+BDCqqDDuT9IJwkwTMCXmv5YQH9s5nt2PBQkQ0k8lNhaIAGZ2Ud33COmJPFQkAgl1mFa18wEw1wYrONC1kUVAnQT9AetbK+cxNbiqTxWOp1N5dMokIrm9WrPRTua66vN+WlrjGDDPAa7pZLgd7+z+d3vbDo6NNdcE/Cc5wScfPJB3qvyeaz93ch9e7F37sB6cifWzh2I4eGDO98CkbdC7msvcPfKgHuXeWTjsjouXRKlh3n9Oiwn8Ec78Uc6CXKt0dpwvrZGHJXH2ZVOQCCwhIWUEktInKptsOVWbYSFhVWzxxISWRdaaNhojRVeWIxM/NpqDXv3wCc/aTEy4vGKVxy5MZjBYDAYjj4njAiDO8Gio+1gQ+AaTmguueQSWltbGa4Ouru6unjggQe46qqrZj32Jz/5ybjyn/zJnxyWPhoMBoPBYDj2EWL26bNQLT6178NBPg//9m8xHn10fgsrF10U8va3e5x00vwnXwe6tvLb33yKW3pvZ1BMZVFy9MnoGC0kaJJxmqwkKTsZRWFw06RiaZLxZlKJZpKpVmKxFPF4hlgiHW3JFtxEhniqGdtdXBHijgdcd/x31fNmXuBXYUC5MEKlMEKlOEqpMEyllKdczlIp5yiXc5QqBYrlUQrlLLnKKHk/T8EvkA+L5FWJHBXyeHhTCDoIa+ZIrVo1Jsv1mPfm5akVvOrM13Jqy1q+vvHLqDkuOqvAZvD+F6NdRdaeZqI51ct6ayP3P/Y1EJFa8emtZ3Jx56Vc3HkJ53acT2waQ4IakchKwFOeEvK5z7msWzfzPaK88PaaM1Mu4zxwH3J/N1ZvD9amx7D27D6iXVBo7m0vcFd7nu3pCl0Jj9xsBieWjU4kIB5HO1VjIymwdu+a83UfTGd5/k+eRdptphQUxxnk6qamBRFhOKUQ4wW9Gb58av8hn2s+XDmU4mmDC+9kcrBoNGWpKdoNgYaiFUUhytkho04UnSjr1PJROlqPXDQHA6SaE0cl+hFNehxKWRVpsMeINYwRaTgMUcdrautBvoUg24Gf7SAYWYKf7cAf7SAYXTKL8cTM98XDTi166EShBa2R0sNO9OIke3BSPTjJXuxUo2wn++ZnIGs46tR+l71TPtZmDt0ptaAplDRVRRxWBxZnBZJkJY5TbsYqtaDLLVBpRlea8SvN+F6Gst9M2c8w4rcwEmYYCpsJ9IkZnbAhgANKghKCUIKSoiqeMF5IoS6ig0aJaWRuxkX0FRPqx+IC6SjwypzsPQVz8oKdYkwWCTh4DaGGuoBDVaTBLiNlBWGVsKwi0skj7RyWlUc6OaRTQDoFLCePdKr7j8d7jVJQKU/9TJNyjIF15DygXRcc99BCVh1lwnKCINceGctk2/Fr4grZ9nq98o8jS+xjAI3GV/6UjpwAlrAmRNqOUsdysMSx+10cK94wrjIIItGUiofwKpE4mFepGnnGgVOr25GnJsoAIISuizuME3gQ48sThRwmCjxEdSAskLbEdkS0uQLLkTiuwLKjOssVOK7EciW2GxmtWTELy7Vw4hI3LnHjglhc4MYEblwSSwriCYETt4glJbGEJJaIHMIjsYtI6MJ1p7d3VGFAqZyjXMlT8QqUK3nKXomKX6DkFSh7RcpBkbJfouwVKPuFaH9QouwXufe2GOye/nO17fJhcSySEt74Rp8LLgj55CdjjI5OYxgsBLawsWcykVjA/mk0YSUkLIeEKiDQAaEKCXSIpwICFUT3hEoxcpQHrNgI8dYnSC1/ACe9r/7dGTdOGOcMpet1QigQiqJQ9AgFqEjUIaEQqTAqV9sIUSKuBG2BoNOzaPcFSzzJEk/S6Qu2xmxCPxm1RyFkME4gIpkvHzbhmLgd5z+e9gk+eu+/8Ejfw3M65kB+P++985384yXv5QWnvPCw9GsqursFt95qc//9Fjt2TP15+MqnFBQpBSVKfglPjX8nzXk58l6eFU0rOO+MJPF4JLjwxP5HeXzXvTzZt4Ud2Z10V3rRExwBYRHHIde6PqcA/pQ/rWl/bjVBSNtuODjV89X5hsM4Ye9khnDOv4vM+XehlaDccyqFHZeQe/xK/OFl9XYaTSWsTIpGKoWsRlOOE7fixK0YjhXNu/b0CD7+8Rg/+YniLW/xuPDCY2idRyncW35F4ptfR2QPzmE8a4dszpTY2Fxi40qbTcskxVQMYhI4eMP3sBKn1HUWpb3nUtxzDpW+NSy6RZ0TBKUV5bBMOZw8IV8b67rSxbFcXNvFjTWxS7ayW5zFH+LXQrmMKJURwyWW6h7W6h2cEdvDabG9nBHbw2qnB7lATsGyex/xH3yX+A++i1q+HP/pz8R7+tWEZ529oNE8axT9Iut7HuDu7j/ywIH7KAULG10zLDVVBRdOp9R9BuUDp0LgErfjxO0knVaceAycso8olhCl0blHizUcc1hakKg6ZzF4BgyeQdO2P6UsFQXbJ9G8E71kK8Vlm4i1byXWvAshD+L7MM1cS1f3Pr625S6+Kf8fz/BX8cLYRVzScTEsW4Fq70C3taFa29BtbUds3iU/EvDArSXuuRPWPRrHK1WqQlYB0g8QtfHVAgtWrY11cU58J2fFdnFWfBenuV3EZhHQPxjKUtEbC+iL+/TEAnqrjuh9MZ/eeEBvzKdkHUPjjiNJGCBKkdDIpNFDbY7QjaFjscg5NOZGY8BShcHS4Jwvk7ATtLS20vrsVi68tgM7exqFrtPo334Sex9fSjkfx5b2grxndXVJrrvO5ZvfdHjpSwNe9jKf5sWnhzIrWmuypWF67v4FPffdzIH9m9mT8Oha69GV9KlMIWK4IAhR/dvHJotz2EdHzFfPsMZTkZpu+yCUyw4C+6H1JL/8ef5fZ4ZHSmczGjZRtBT7Eh5qpo9FCHRNqK8+cSYa2wyEYSthrnVO4mzSKWM1jWAns1ipUazUaDU/gpXMYadGsFJZ7OZRhDN2jipyPicYI24YhtFzorpF+cjRPChML8JgKejsXLhnSSIB55+vOP98xete5/Otb8W45ZbVlPwyA6X+eYkx1AjLKfLbriS/7UoA7KYhms5cR6xzL2EpjZAhVjKL09JPbOkupB2gApsw3xJ9F5VEawFaogMHFbigBcL20YETOfNmOxqR0stNhMVq5PRS0xEWfRb4o0vmfVRYbKZUHHPj3HP0RD8XFKUaoiNSNoQwa9/xKYir8c+l56XvpdnKU1AJtpRP5Ul/xbQrnEvO//8m1bnpvVO0pGoEEtbnSCcSa45sltxM1xERYRACnKb9eKOnHJZrzUTZ0pSt8QvM/33Zej7f8uS4dk2BRSawaPEtmqtbi2/R6ll0Vmw6K041tYmpQxtfCAGdzjCdzjBPa3oUAKUFu70VPFY+ncdKp7OhfCZd+WjebMo7uyUjm7S6KGtNmLUh4ool0VXx1tozYqBf8qMf2vzoRw5nnB7yvOf6PPsZFTJJH1EqIYoFRLGIKOQRI8PIwUHk4ABiaCgKjNTdjRgdOaR//0LSfXIHfzzd5Y/tOR6x+wjdZNWu6vAQllJ4gyvwBlfgjyzFH+msb2F5sv2bAGzpYEubuGVj2RaWsLGkhV1Po+Bsi11Y/nDzne84XHttgInJbDAYDCcOJ4wIw9Kl4196ixMjSxoMc0BKyctf/nK+8Y1v1Ouuv/56rrzyyhmj9N533308+OCD9XIqleLaa689rH01GAwGg8Fw7NKIvDz9wsyJIMKQzcI//3N8WgPWqUgmNW99q88LXhDMy6hbK8WW+2/kl/d9lT+Wt6DQR8VGr1XHWSqb6XTb6UwuZUlmOa2ZFTS3LKO5dSXNHWvIdKzBchY4bKDhqCEtm2Smg2Sm45DOo5WilB8iN9DFSP9eRkf3Mzx6gA+tTzFT7KKxIgxjw1G2J9oRQvCKM17Nqc1r+dT6jzNQGqjvV4FNYefFhPkW7MwgsaW7Key4mL7fvyFqYFWj601BrGUnKIW160l0Oo1KZ9imt7Jt6HF++Pj3cKTDxZ2X8LSVz+QpK55Ka3x6EcUlSzT/+Z8V3vWuOFu2TH+vqFQEWh+BYFaeR+yXPyP+g+/VF3E0mpKlUZYmEUqyTsi+hE/OjqK0yqpyuaUFQkdpXAlWF10SSkYG3VJjazGtwnzRUgw7AY6K2ty5JM8PVw2zJ1mZsn0dy0InkuhkEp1IQsxl8s1Pg+NMUq2fDh1PoLVmtDIyeV86A4MDc48UFIuB500yevuTvgwrBpdTam4nKHUQehms2CippQ8irAp+bhWV0VMJ/SiqfOil0aGL07Sf5NKHsdwchZ7L8LIno4IYOoyjgjha28Qye0gufYh4y3ZKA+dRGT0FrW20stne1cHX8gkUkkBbhFiEWo4pS0Id1dUQY4yCGy674x21xra1UPWovhYKSygsQiyhsAmxRFCvi6L9NvK2CLGr+VYRsKRatmpRgsfst0WAJKDoeuRcj2yswnCswkiswkjMZ9ANGHJDBtyAITdg1JnGAFOp6SOOR/+ohjhDzWGiKtSgpIsmhQ4dlB9HlZOElVSUllOoSpSGxUw9KkWYbyEoNM+otn7UGSesAGMFF4TWCOHhNO3HTXfhNO3DTXfhprtx013Yyb5x3xnDiY0SmqwdkrVDxgeVzgGzi9A4WpAMJO2BxClnsEptiGI7VFpQxXbCSgtBpQ2/3ErZa6FcaaHstVAJUtRkBoQW9Tw6il4tiJ5XU8gQREw7jI7eb7SoBhwSAi1FPWVsubqpqniCRqCERoko1QJUdLaoDbohnkA1QnX9/jqVwt1Uv7Np/0VHkIO7tiIJQTKKEjvLo38Suv6/cRGihOVHwgxuJNAg7TyWncdys1jOKNIexXJGsdwcViyLdLNR3s0incKxdy9TKnL2KU8h0GBZUVRH16mmY6LhyaPn9qi8OH62LRJTqKW5NvxsQ3RB+UZ071gj1GHkpMtkh6yGQEMkzlB3XpPujOtTRx2twfMQ1Y262MLkcf5ioiadUC1M1yi6YdSMBavR3CPDwWrUp1q+ZtQ61th8Kmq2lfMQElRaTb3hT7tPOGWEUwK3hHCKaKeItgvgFJBuGemWEE4FGSshnQrSLSHdyoT6cpS6pShang0j9ooZ++rMIhR5qFx2meKrXy3x1a/G+cMfjr4BoEBgy6rowwxikyPdT9Avo999WGmh0HPFlBHhjjjrxuSFws3soeXUX9J65o2kyof395t0kvzXMz7Flzd8kV/s+OmcjglUyGce/CSPDWzg9ef8DctSyw9L3yoVuPtui1tusdm4cfxYINQhOS9LwS/ghz6BDlB6lnl8rdEqpHtkD5nBe/nHT3yK7fSjwslzJ4v4br+w1AUho+KUcw3VqNu4blU8q+ogt8BikEJqEit2klixk/Zn3Eil7yRyW68iv/Up+Nmp53OVVhSD4jhnmJowQ7wqzLB1W4L3vjfONdcEvPnNHos9hoz12EaS138Oa+fOOR+j0exN+GxsLvFYc4nHMiV2ZQJ0OoPKZCAe52D/VlqDN7iCws6LKey4mFL3GVEEVcOiZrqxroDqGLe6JV3cdCv7rKUcUBdyT6kYOVQMFon7OdbGujg9tpfTY3s4PbaX02JdJOWhqTDLAweI3fgjYjf+CNXRgf/UZ+A/82qC8y88JEGG/mI/63se4L4D9/BQz/ppxdjmi1YCb2hFVXDhdMrdZ+ANLUcgSNgJknaSDscljsYqlxGlIlSGF/X4G8ASIWlZJCHLxEWFuPSIC4+4rBATPrFqXUx42CJEuHYUYTPmIF0Lactoc6JUWzbKcgikg5Y2obBRQqK0RCEItYUfWlSUjRdaVIJqGlp4gUXFl3i+xAskZd+i5NlUfAvQk+dTtI7E5LSqlhVCjZknVirajvLfIK4kcS8G/edA/zmkt/4ZRUtRcCrI9m14SzcTb9tKvH0rbrrrkOd3fOVzu7WL24NdLNv9K158fzMvPtDMskp1fl+AzrSg2lrRza3RWlUyiU6m0KlUvYzjVt+pqk5ZaITng+8jfC9KvWpaKCByWWQuS38f3N11Mn/sOYuHs6cRjnFiPhxPDUuEnBXbxcWJx7kw8QQXJraRsWZapZ0fnlDsS/h0JT32Jjz2JXz2Jj32JbxZIyobDhLfR/g+FAqNUUvNQT8Wg1g8EmeIx6O5gRkoBSVK+RIH8vurNXdCC3A56EsFun81I7vPx9t1OZXus7Fw6g5wtrRxxuTnKtSZzQq++12Hn/zE5iUvCXjFK/xFOe6shBW6c13sy+9jX66Lrtxe9g0/yf69GykMH4jWqG1gzWG4uBCRyEY8Hm2xGLixwyLINBNaSZQXR4f2mM2B0EKFDqWemR3AR+3D7w8hBgZIffw/QUObneU/l3+BN/W8j654wJQmDJYVOdrOQWhhoVB+HDW8bJx43nQI28NOjWJVBRvs5ChWamw+2mdnRpHxQkM7IpfFL3VOe95kKFnScXjs+Vpa4F3v8njxi32+/GWXjRtXM1weor90aIErgnwbIw+9YGE6OQ9sYSOEINSRKICoRkUXIoqMHrNi2NJGa42nPASCuB2teVSCCp7yiFlxBOBVBTCjqOqCcLa5mCoZN4OvAkoHIWax6Bg73hSiIbBQw/fHCxwoBWGAlta0wgcAsTA6R0x4/OyUf6R1gujLhtLp/KX3KrqKY8QKRMiSC75G06o7J53PzUwjwgDRM3e6fjRHAgTTijgsAG66a3y5qfuoiDBMhdu0f1Jd3g7J2yH757AU2OxbdFYcllVsVhddVpVcVpccVhVdllZs5EHMz0ihOTXWzamxbv60+Q4ADvgdrCuex7rieawvnk82HOOdHioIvUlXms+Vdz4BX74Zvi5CnpZ6hBdm7uKpqQ04YpGOhW2b4Myz6DnnZG5dWeE260kez42dW0ss2KXCYhPl3pPxBlfiDazEG4qEF8JiZlJbRzrELRcn5lRF4RvjTktaVbt1w2yUSoJHH7V42tOMwKXBYDCcKAitF/kM+wKxZ88env/859cNkf7hH/6Bt7/97Ue5V4ZjkaGhIa655ppxQh7vec97ePOb3zxl+97eXl772tfS3d1dr3vb297Gu971rsPd1Vnp7z8yCqgGw1yZb+Rog8FgOJ457bydBEy/KPB3f3o7//qxtxzBHh1ZhocjAYZdu+a+uHnOOYoPfrDC0qVzf8VRYcB9v/kCP3j0BnYwMPsBC0CbTrDG6mB10yrWtJ3GyhXnsnz1ebSvPBs3sXgirBsOjsU2nnnOm+9hx31LpzXsalp9B6ue/q8AhKeuBTsyfPrU1f/DRZ2X1NvlvCz/89CnuWvfnZS6T2f/T95LWJ5ByldrRGVqL8CO879Ox3nfHl8Zi6NaWiIn/TFGDVIIzuu4gKetfAbPXn3NtIIM995r8ZGPzKyYf/PNxbE6EwtHoYB99x3sf+A37Ny9jiedHENuQEVqRp2QHU0Vhp35L/gIBB0Vi6yj6pE8bB1FLkqEkpiK8gVL0Z2YoyOLbaM6lqBj8UhlfI6G6bKvFzEyh2h0UhKuPQ1mULsWhTxy//7IGBFQgUtn7xns9FbhZdcgZIDbvIem8x9FL+1AFwNy911IsetC/PwygmInJw2tROKwPVmMnHahsZBcM2ic+J2vGXhIOX2bWrtqG1GLAlDltHxsWiGM4wlZF4KoCTsESBGiLJ/QCvAtH9+OtoodRU8qS01ZQsPKRqC1rJYFKoyhwxg6dNBhDBXGoGbwWIt+Ml3kkyNonDMjeoJR7YSyGFsHSCdPrHk3bvOTxDK7iTXvwknvw0n1HHvOyYbjg7G/qYnpmE2pGGGlhbDSSlBuIyi3EpZbqmkrYbmZoFStK7WglT35GhPzs+0zHJtMEJqJ6jSCEOnmsZxsVahhBOnksdzRulCD5eaQsWw1Xy27OaS18JEADyuWPd7pz606A9acAw4C5bt18aEg3xAgCgvNkchCVWxBVZIL8k8Q1f/XUgTjjGvqe+q/Wz3O12RMzQQatdEy5NStDAuDI52qQIMzRqjBxZb2kTGW0rrhmFBzgqmJLsxRzG1RIgTYdkNQzLajCOy23YjKPtGY9SBRWhHqEKVCQq1QOiTU4/NKVdtU66P84hBplU4FGSuiSxpVmP7+1NY0xMP3X3nY++O6FvfeK/n85216esTR9nWbGaUQO7ezI1WeNmpkPToYjH+PnfiOUs2LmmPgYfqHZ07+LU+94jq+8uHth+X8E/n5jpv44iPXzesYS0hetPZP+dvz3kzSWZhn5oEDgptusrn1Vpt8vvHH8kOPUlii5JfIeTnUDHP646jdO8eImC699LO0nnHTgvT3hMWyqhGKq9GKY7FIeHaBxbO0EhT3nMfoI9eQ33HJQQkA2MImbsdpTtu86i+G+dvXtJOOLa7QaSKfI3HDV3Fv/uWsbctSsTVdHie6UBf1jCdQra3opqYZ5w1nQmso7z+d/ONXkN9xCf7I9NFnDccPkRBZLBJnkC4uFjEvxC1VEMVidB9Fs9rt4YzYHs6M7eLM2B7OiO+mxcof8vV1cwv+056O99RnEFx4UVU8ZHpKQYmtg5t5qHc963se4P9n77zj5DjK/P1Up8mzOSrnbAs5B5wwYAMGk0zmjnxHuB/cwR05Y+DIHOE4MrYBE23A2IAD2MbGOchWzlpJm9Pk6e6q3x89m7Q5SSupHn1aVd1d3V09O9Nd4X2/796evVO+9uAmpiyGyR1eGgguNK0kd3g5shA8LxzTIWbFiCmbqKswciWBwePcDjeFT5XZQ6XVU0q7qTJ7KDNTJIwsSTNNwsiScHLEKyxilQ7higiUlyPLylFlZcGcUbIMlUwOOOVHoqhIJAgLfRzGlzwPslnIZgWZDGQyorQE+Z4eQXe3oLsbenoEXV3BeirVJ/A2SJChtAgpQfrgS4T0+8WIgkjcg9aPQYAGX6hAlMGS5MJpzKpthKu2EK7YTrhqK3bsyLQ/doHg7M4oVx0p46L2OM4MiugoBbuKC7gv8wz+lj6DLfllM3bu0VgR2s+50Sc5O/YU68O7iBiTVUgdjkRxIFpke7zA9kSeXfECByJFWsKeHl2Zy9h2yYk/DCWH/qm2Qf1snPTuTWR2nEFm72nDhMn7Bf8MG7skzGAZFpYYJNQwggOdbcOVV3q84hUutbXH9ruU83K0ZJppzbZyON3EwfRBmlIHaEodpDXbOlDQLWJ0dSF6e2bnuSdEEJggEkFFItP6O42GkgI/mxwiLu+lK/Az5fjZBH4hisxHkYVg8QsRlDe2ncNYUeoBltc+ze13Xj2j9zEE3yf+vndjbX6yf9NjZVleGzmPQ4+9a1hxZdvBmNlJgjB8zGgPVrwby2kjs3P9wDz34HLA4ozDu7+4iBe9dHbrpBQ89JDBV7/qsHlfK73Fntm94BgYBIFF+t5RfWIJjuFgGiaGMDCEiSlMzFLeMZ1ZjaCuUOS9PEW/iK88fNk31upjYBC1YySdZP+8R87LcTh9KBCEOIqKcCWO4dCRa8dTM+foHbWihEqiraZhkXUzQ8QcB25mkKgXDNizDG6UjfSMEASC4oYRtCun2D+oz9uUuyavq/g976i5ccQyf6jr4cN1CTLNZ2GGu4hUbyaUPDhiWTdTy+7fjTz2NT9n0xQZuZ5LnvcaQmX76d1/GYfv++SU7mU85l34IRILBoQjWh59F13bXzEr15oMVqSD5Ve/aNbO70iDxrzN4qzD0nSIpRmHZZkQC3LOtOyjpBJsKyzmwcxp3Jt5Bk/ll89grQcoM9M8O3E/z0vezZrQ3uNqhqASCbx1G/DWradt1WL+GjnMX4/czVPtT85YK14p8NPl5FuWUGhZTKF5MfmWxXipqiHlBIKQ6eCY4VIazB3ahj23hd3nGEd/VEdPuXzqUwXOPVf7OmnmDjU1ieNdBY3mpOaUEWEAuOqqq9i1axcAmzZt4oYbbjjONdKcqHznO9/hy1/+8pBtr3rVq/jXf/1X6uqCyV4pJXfeeSef+cxnOHx4QIGutraWW265hWRyuLLYsUaLMGjmGnPNaVGj0WiOJys37KI4RlP9DS/4Cx/73NuPYY2OHV1d8N73hjlwYOITLtdc4/KGN7j99sjj4btF7v3jl/nZUz9iHxNwLJ4CBoJFVLAqtoQVdaexbOm5LFh5DrGK2YnCppkbzLX2zAve+QCb76kZVbk8Pu9e5l/0fgD8lavoc8P64RXXMz+xYEhZpRTfvec2Pvf+ZfjF8dWYRaEwgiO8z7IXvhQ7OoroiWkGxnVl5YHz2uBdwuDshvN47uIrObv+XGxzwODkkUcM3v/+sQ0gf/ObLImZGmdUCvOJx9j1h+9yV/Pd3FHVTYczx5S1TasUIcgODEocZ+qGzrks5sHxFeVVeQWydnwD6MKROnruuZTs4XW4qUYWyXIOmxmKQvZPGjs1h6h+5i/puPdlFNpK30WlcMwQi8sCtfm9PXtmLHrYeFjCZGliyVAH/FJUK9Ef5WrQdhlMhAslh0Yd8GUpCpYcZmx5oqMAz1C4QuEaCq+U9q27xjTNA0uzW2osR/JRjhlSyZFqMYoj00Scl4aILZTtDfLJvViRdu1nPlj8RBhgCBDGgOjG0UtpP4JSKoaX7TtvfyoGtGQGbe8z8wnONSAOMmeYkaocdX9jphO/4HgTyUfvk4VoyaCwDD+bxM8k8bNl+NlEYGSYTZTWk2MLOGlOboa8PwOH/L7nq1Cy/9EszCKGncJ00oEwg50OBB2cXsz+fKq/jOGkgu12FsPKIczCnBC6sZXAMh1MK46QVaCqUTJYpKxE+lVItww/H8fLJiimEhRSCQrpGF4+hBCiP+LTkJTgWWgM2sagfWMd118ehgktHCtU6e/eZ5CplBp1W5BKpFIoJZGU0mHbg7zh5BBOBqw80swhzSAvLBfDLiAsF2EXMCwXYQXrhuWC4SOEBNNHGB7CkME2ww/yQiJMD4RiSEg3JVAlsanh2w2QJsqzh0WvU76FGrLPRroOqhhGuiFkMYx0w6j+fAjlTV1JTiCwTTtwWBskzuAYNqYxwQEUCNqqnofwPXC9frEF3GKQH8MIfM7TJ7JQWpRtB8apfcILU0QpFRj2Sg9P+fjKw+sz9pUevvLx5IAB8EnjSHN0RLWjaCg/wv33XjTr1egbmykW4Q9/MPnxj026u+dIW1Cp4PdU+g0Z3d1QKNAW8kYdV5iW88JIYnKD+zxHiclNlIvPfj8//t4vj1l00Nv2/pEvP/z5Sf9S6mP1vO+sD3BazcYpX3v7doNf/MLi3nstfF+R9/PkvBx5L0fOy41ooD8uSgVCNUd99kue91pCZfumXFfNGDgOKhwpRbiNQCg0Y867XqqcnicvofvRZ+Nny6Z8nnDdXp7x8ls5Y12S1ZVrWFWxhiVlS4eMgR4zlMK+926i3/gqorNz+G4UR8IeTycDsYXNZTl2xAv4g9viQqBicWRFJUTCTKUjrBQUWheR2nIe6W3n4vZWT+OmhmOKwCHo6FQIA0MIBKVUGKU2eN/2oB0YfIWOkjUrbQuFJaGQxHYkTkhiOz52SOI4PrbjYzk+huWjhIsSHkp4+LhI4aJw+/Oe8vB8H9fzKPguBbdIwfMo+kWKnk/RKwbtS99GenbQ5uxPLZTnoHxroK1ZjEyrfTlXEIigXYtJyJWE8h5OvkjIH+j31FqdrArtY2V4PytD+1gZ2k+9NY3xOtvGW78B98yzcc88G3/RYtoKHezq2sFT7U+yuf1JdnZtn3DU3dFQUuB211FoLokuHFpBoXVh0M8o3XvMjBCXFrEi2AU3EF04xuafCSNDg91Gg91OvdVOvd1OvdVBg91GrdVJuZnCMEHW1CLrG5F1dcjqGmRNLaq6GllTEwhGJ8tOCbFOz+sTZYC2NoO2NkFr6+DFoKNDjD1NoFQgxtDnZNfXR/M88PxB+Znrn+UNSdqSpC2fvKkwnR7CVdsIVw6IM4w63zcBylyTK1qSXHWknOWZcRyQR6HdK+eh7DoeyG7gocwGOvypv4snQsLIcHZsM+dGn+Tc2JPUWN3TOp8rFHtjhX7Bhe2JPDvjBfLGFJ8lgx0zRV/aN4Y+kiD2oGNHfYyoodnB/Ygh82WlArJv7O8k6edOh1A4cPSPRII2qD0xcfzB+IUw6R1nk3r6fLL71034eAH9EY0DgYYBsQbbMrjw0l5edk2O5YsixO0E5hSECJRS5LwcPYVuugvd9BR7gny+i65CJy2ZFlqyzbRkW+gtjOUgrhC5HKKrE5GevojSMEKhQMwnGkNFI1MWBRuMXwjjdtfhdtXhdtcOWupwe6umJNI2JuOKMGzm9jtfMrPXHET4Jz8kfN2P+tf3RQu8edMBUqZP80P/Rc/uq/r3KWfqAsUnBKM4s5sKGvI2cc/kYz+s47zLjk2bu6VF8L73hdi8p4PufBdyhIe5ZVjUReswhYknPTzl0Z3vpignGOij7zzCoixURtyOY/SJK2D0O/P2jY8Ywjgho6j7yqcj10HBzyOVJOEkKHPKhzwf08UUbbm2GbFRWVq2DOuoMXrXd9nbuydY6RuTH6mBWLL/QYjAJqU4yt9SiECo0i2OfJ4JsDjj0ChS3LDo/VRYI/uc9Fo+V16wa+iYwCgoJdjxy7+g/KH2XXHPYH7OoTns0m0PHWsz7DQrXvJ8hOGT71rOvtt+NKG6hyu3ke9cPaGyAIuv+CfCFbv71zt3vJTWR94z4eNni0jNkyy6/NjbCNtKsCjjsDQTYmU6zNpUmFWpEDF/auPUrW4Ff8ucyV2ps3k8twrJzL8rljhNPC95D89N3EetPTv2wIORjfPw1m/oF17oqSvnnsP38teDd/BE22PIabaHlQKvp3qY4MLR44+mMAlbYUJmmJAZImSGsE37hHwWzzXGsp2xbfjJT3JUV+t+j2buoEUYNJrZ5ZQSYfj1r3/Nhz70IQAMw+A3v/kNq1dPvHGt0fQhpeTtb387d91115DtpmnS2NhIIpGgqamJ3t7eIfvD4TA/+MEPOOOMM45ldUdFizBo5hpzzWlRo9FojierNuykMEZL/fXP+zOf/O93HLsKHSPS6UCAYffuiQ202ja8970FLrtsYu8M6Xvc84cvct3m79Mkesc/YBI4ymSt2chpNaezftVlrNh4JZFE5YxeQzP3mWvtmZf/xyM8eGfVqKrmsfoHWXDpvwPgrxzoH//uxbcRsYYKLSgF73tfiH88UqQl0zz+pOwIzheVa26gduO3x6+4EKhkGbKyKvihH0UyVMZzFj2XFy1/CfWxBjZvNvj3fx9bhOGnP81RUzPNIRClsO75G0/d9DW+bz/G5mRueuebJVQiiaytBXPqTkNHYxw6iMhkBq4hTfxCGUpa2LFWVCSCnDd/3Ggh3Y9fRttf/gklg3LVkWoqw1W059rozA836j6ahlgjCScYMD6SOUyqeGz6tTE7zrz4vNm7QH8ErMERr2QpwpUfTIqPFgHrBMIXQ0UZXKGGCDf4c3gOUJgFQn1CC+W7CZXtwSk7ScUWhAh+y6YBhokyjMDpyzDANFBGX94cJLBgIPq2GyNE4BiBwMFWM9eYjAjDZFG+hZdNlMQaRhBqyARCDX4+jswl8PNR5pR4xinMgENRf25g+yCH/gmt951zkECKgP7oj31CRaL0HhTSB6kG9FZgQLRhWA3BMQrYZh7HyGMbBRyjgGMWCBl5HDOPLYqYQmIKiYWHKXwsITHxg3zJ7EcpA6UMhLQwSk71KAMhDYQykdLG9cMUZZiiH6YgQ7gyREGGyMsQORkir8ZwIBAicP62rOB5agapssz+dWX25c2T3inFcSCZVJSVKZLJvgXicUU8rohGIRZTpQWi0YE0Gh3ZrrfoF8m4abJuloybIetlSLtpegu99BZ76C300FvspaeU7yn0kCr2kir2zqn3k5Ki5DQXQRYiyEIMPxcLouXlY6XoeXH8fGk9P2hfPoYcSUBPKQxh4AgLBwsHE0cZONLAkWD4cohjzwkvGCYA2ylFRg9S5TjBF28Svy2pZCCcMFhcoV9QwR8UVc2btvPdCcs4IgxLK/dz592Xz3o1jh6b6e72uekmi1/8wiaTOYbPU9cNjKALBUSxEIhVjuB4DyCFYm+0iGsM36dm0Fl8VI52oup7J4/CxgW/5ebr3oiqnlmH6LG488DtfPGhz03J0P3s+nN42cpXcFrNxgk5FykVCH7e8FOLhx5zyXlZsm6WnJebGdGUERxoonUPs/Cyd0//3DOArQQJ1yThmSQ8g4RnEvcMEp5B3DOJ+AYhXxCWBiEpCPuCkDT605AUWFJgKoGpGEgZWDf6NLlEkEoRfLJBPnDy9wUUDVVaJMXSWELRUBRFkOZNScaUZK3ASTRjSjKW3x/FO21KUrZPl+0fJRBgBFFvw32OcdFpR2qVrk3v5ovpevD5uD01UzqHED6V5/2OyvNvRpgetmGzomIlqyrXsLpyNasq1tAYnzerEetEWxvR//kK9v1/79/Wa/k8ncyxJZlnSyLPlmSeLnt0JzCVTCIrq4N37RTwMkl6n3omvU9eTLGzcXL1L0WGtg275HhoYgkL07CwDBNTBJGhTTHxv7dhQHm5orJyYKmoCNJkMmivJhKQSCgSCUU8fuwC/0olyXt5Mm4maPt6WdLFNKliT78zZF9bt6e03pXrpSdVwC+JMshiGFUM9/fH/WwiaF/mBhaZSwT5fPzY3NhUKL2/bB9CrsTxSwJ5UmCpYKkQGVaH9rO6JMqwMrSPBU4Llhi5/aJQ9Ng+zSGPlrBLS8jjQLTI7liBXWUevXEbwiXn2lBo0uPxSoGXqiR/ZBmFI0vJNy8h37wUWYgOFJISE0Fc2iRcg3jOH7O9NZOYwmeB3cwi50gpPcxC5wgL7WbKzVR/80TW1+MvXIScvxDZ2IjfMA/Z2Iisqx9xfkczMr4P7e2ClhbB4cOCpiaDQ4cMmpoEhw4ZTDh4cUn0q1/4y3P7xfP61gMn+cnhCkWv7dNr+xQGtVmtSEe/QLGT3B+Mnyf3YoYmN3ezJhXmhUfKeXZLgvgojl1ZGWZPYR5P55exOb+Sp/PLOOJO7Z07GeqtDi5JPMjFsYc5LbITU0ytv5c3JDvjBbbH8+xIBOmeeAG3r41imANjQ4PG5zEMVH/eLI3RDxI+7huLNwzm1Fhqn2D5ILFycdR6IGau+ufG+ufAZGn+6yQRMe/HslCRaPDeiEZLbaWJ/828VDm9Wy6g94lLKXbVT78+QpJcex+V591MWV33IKc9h5DpIErR7fsGY30pKcgChVJ0+byfw5PTeCcpiUilMLq6oJCf/v0MPnUkiorHgwAF9tSd4ZVvUuxsoNC6kGLbAgql5eho07POeCIMdY9x+x3XzMqlzd07SbzjrcFvlKBv8MYz9tMUCWxFlBK0Pfk2urZfgzRi02oIC0QgjGYMF0rrWwSDRdKGCqb1iREbQ8SL6c/3XaNvzqJfELgkChzcz9BtQ8SEUah8HtHW2t+XBbClICIFRkms91u/LWPppmMXpLGjQ/D5zzs88qgg52XJeXlcWUQgiFhRkk5yxD5kzsvRnmsj5wU2LwJBWaiMqkg1Bkb/mLpCEbGiJOyEjp5ewpMecogo58Dn0pZrJeNmhh80pLRgRcXKEfd15NrpyLYh3OIYAkmAYRCOllHM9iLHeBaXO2Xkcyny5uTfpyEpWJOFr8z7As+Ibhuz7OdWNnNTY/eEzrv31h9S6F7Rvx72BfNzDpYSSKHYFy1SHNTerFj1C+o2fR0A6YXY8cs7+vcJoLpgEfYNmqLFIR9Z4/kf5fB9nxxy7YhvUFk0ORxxh328K6+5HFFmB20qKclsX0/T3V+Y0D0Zdgbpzk4wgrIlf6Th3Gtn5dxTYUHOYU1vmDWpMKtTYValw0T9yQkqdHkJ7sls4q702TyQ2TDjggwGkjOiW7g0/iDPjD86beE0AEwDf8UqvHXr8dafhrduPaqikoyb4f7D93LXgTt4pOWhKc8NKSlwu+rJtywOBBdaFlFoWTJikIuQGSJiRQhbYcJmBMc88cU25ypj2c686lUub3zjsQkcpdFMFC3CoNHMLqeUCINSile96lU8/vjjCCE4/fTT+clPfoIzxYk/zalNoVDgAx/4ALfccsuEypeXl/P1r3+dc845Z5ZrNnG0CINmrjHXnBY1Go3meLLqtJ0UxhiTe80Vt/GZL77r2FXoGJDLwfvfH2bLlokNrJaVKT7zmQKrVk1s8HLzvT/lu3+7lh20TaeaQ1igyji3ahNnrb+K1We+CCcyhw3QNMeEudaeef0Hn+Bvf6oIDP1HIFr7GAuf9a7Aab8hMGiN2TFuuvqPw8redZfJtdcGjmRKKTJump5iz+gTiEcprocrt7Ho8n8JIslOFCFQZeWBGMMIUUgNITiv8ULONF/H1z78jDFP9cMf5pg/f+pDIObOHbR891q+ov7GI+XZKZ9n1rBtVCSKLCuHyAiOVtNFSmjqJvX0OaQPXUC2ZRPSi6IMg3D9PiouvJX46oeGTUBIz8LPlON219Bx70vJNQ2IfVSGq6iOBA4bnvTY17MXyejP9DKnjLrYgFFRZ76T9tzYz/SyUBk9Y0ZXgfJQOd2F7jHLVIQrqYnMvjHfpOmLfuWXIl35/kDUq6OiYp0Igg0KhWswplDDrCMkTuJAILhQvqeU7saOH54T0dXHw1CCuG8Q84Il7ptEpUnYiRFyotihGOFQHCcSx4mWEYqV4cQqCCUqcJKV2IlKQrEkITOMY9qYpehIpjD7HRYsYWGU0r59UzW6UUohlRyIBt3vvBhsk6XtfcYsvpK40qXoFyj4RYp+YUi+UFqKfoFiqVzez1PwCuT9XMlxKnCeyrpZsl4WT57A0btngdkUYZgsSgpkIVoSZSg5g+TigWNxLhE4F/eJNhRKziOFaHBMITLz0abmAMaQCKwD0Vn7IrIajBW1VfQbIR6dEpylZKgIlM41WEDhuCJlEKnHdaHoBsZnbl96ivyG+4zq+4zvB+UDo3xjIJphnxF+X8RDQ6DEIHGcvoi9gyMfDkn7/yOIXDhCfUZ8OAyUNQxFZdKjosynMulSmfT60/K4SzLqUhYtUh4L8iHTGyRKpRBKDloftKiSU7AqRVbs3x4Y7IsRj1GDjpED7af+SI2qdO/BZyKVJGW49JCnkywdKkOHKKUqQ4dK96cplR/hM2P0bdOl5BwtBuWHR7cv/R367t9n0POy5DxXTA4shSR+sQxZTJTyScx8GUYhiSPFoMXAlnPkmTAafWILoVAQ8XwcsQWlVCCoUGp/jCaq0Ce8oOWjJoDnIrzR+x3nVO7lxrufM+vVGG1sJpWCW26xuO02i0OHZrid4AZRqEU+B/l8MA4zSWch11AcCbtkBxtFCxF8p481Y0XRA9ZUPMSfv3M6/tp1x7BSsLdnD196+PNs7xzb8Hs04nac8xov4GWrXsHSsmXD9vvS57YHDvLd75ns2BIj52ZHjCI5XUShMORdGirfxfyL34cdnblx66OxlKC2YFOft6gpWFQWLSqLJpVuKS2tl7mBMM/JhkKRtiRdtk+37dNte3Q6Ph0hj1bHozXs0VIVprXCpjdioiKRcYVGR72Wb5Laei4d970Yd4rOcaHa/dQ/7zuE6g4M25dwEqyuXMOqyjUsK19OY6yRhvi8YYK6k0ZK3Jt/TueN32Gf2cueWIE98QK7YgWOhCdmUKziCWRVNUzhuaWkQWb3Rno3X0Rm1zNQavTP3xQGjulgGyEc08Y27H7RBdMwp9ReKS9XNDYqGhok9fVB2tCgaGhQVFWpky6Yr1SSVLGX7kI3nbkOOvLtdOQ6aM+1l/KlJd8+xLlS+SZeNomfqsBL9y3leOkK/FLq9lYhC7PjfDJhBvULhPSH9WmMPkEYQAhJNHqYeLyJaOwQTuIAouwgKnmQYqwNrEkY1JtmIPzlOCjb7hfV8/04bqYWr7eWYncDxY75paUxELboeycMatfbEhKuIO6axCbp0DIVqswelocODFkWO0ewxUCfW1ZX4y9fgb94CXLRYvyFi/EXLJyd+QjNEKSEtjbBgQOCvXuN/uXAgUmIMwzG9wfEGdxBabEYiDSM0/wpGopeKxBkKI4yZm+GO3Hih7CirdixZqxIG1akHdPJYFgZDDuDYZfm2pSJUgZIA7OY5LTmRta01lPdU0eHW8W+YiP7i420escu+MECp5lL4w9xSfxB1oT2TloTLWX5geBCIs+2WoPt5T77owXkEEFOE2Va0CfIKU6yl81MoeRQ0fK+OTHPA98Dzwe/by7MD8qfKFgWKhpFRWKBKMMEhWuUgtyBNfQ8/izS288as900MRSJ1Q9Qed7NhGoPTvNcE8D3MHp6EN1dwfzlDKEiEVQiiUokphSoIGxEcVIrcY+sJn9kBZlDC0m31iKkVWpjHj3ePjAOD31DT8PliEuu+/1rSjHEsV8qiUIilUKpIO2bD5PKRypJNt87pgjDsvqHueP2V036nsfF80i8862Yu4PI8D6Kd5/exEMVw+1D3OQyMt0XkD+8gnzzkqBtmClHFgcCaZjCxDZtHMMJ2vCmjSXsYK5xkkJpx41cDvPg8H7aYH51Z4j4stpjVKEApeD++01++1uLxx+f3OdY9IsoJJawJyRcqRmbrJuhKd0UrPQJCik1EOBACJJOkvpYw4jHF/wC+9t3DBFHLV92M5Vrb6Dp7s9R7Fnav70+Uofb00GHM/LzQQBLMiGkUOw/SqBgcBmhAkHM/m2GS9m8u3l5b473O3dRZfWgkmUUnvd8zD27sbZuQaSG+p/0Wj6vPWsfraGxG6eGEmQffiet21+FLQWxkujn4H68RNER8smYklDlds4477+oNlKEn3UVNfc/wl/++H6OdG3AloKob2CVBFBcoehyPAqGoqJiC88999389s8343tRTAUxzyTqB/OgOVPSFvLImcHInxVpY9lrX4dsnB/MtwoD/wnJzt98N9ivBFHPoKZoIVEcjrhDhMniC/5K+uAlY977kM/ByiK96PgFgepn/IDKZ99e+vsNvF2EYtCc0FBx3UDoqiSIVRK7H+gjD7SrZkLsSiBYnHFYmwqzvjfCut4wy9IhzAmOzXR6Sf6cOo8/pS5ga37p+AdMgfXhXVwUf5hzY0+y3DmIMQG7H5VM4q1Zi792Pd76DXgrV0M4eKdl3SwPHLmfvzXdxYNH/jFp0WDpWbgdjRRaFw0RXZDuyMGnwmaIiB0jakWJWBGMk6DfYFngOArbDqbw+vL9cWBEX14N0ZwbvMDQqeTB08BBKobtk7JfsxDXFZT0CnFdMaIm/Ui2M9Go4p//2eXqq72TPYaC5gREizBoNLPLKSXCANDS0sLLX/5yWltbEUJw6aWX8t///d/E49pZSjM1/vSnP/Htb3+brVu3jrg/Go1y9dVX8853vpOqqmOsgDoOWoRBM9eYa06LGo1GczxZc/p2cmMY1bzyubfyuS/92zGs0exSLMKHPxzisccmNqHT0CD57GcLzJs3fnfm4NZ7+eHvP8B97o7pVhOAldRw6YJncc65r6Zx5dwR2NLMDeZae+ZtH9/CbX9IQLE4YgTDSPVTLHr2vyCra1CVQX9lUXIx33vuj4eU6+qCt741Qnf38NHjgl+gI9dO2k0Pr0ApCqYw8yy+4g2EklM03BAGqqIiEGMYweK10N5I84++RmW4kriTCCbopAyiTSqFikT43+/kWbZs8kMgoqMD94ff4Jc7b+SGBZ14x9IJ2zRRoXDJMYz+CMlHG2Ypx5mSMQmAbdisqVrLuuoNrK86jYXJhfzLX940TFyj0LKQQ7/+D7zeyuCz7XfyO/o7oTBjvZhObszoaDWRGirCQw3msm6GI5kj+Gro7yZiRagMVxGzhxrv5rwsB1Njf6cWJBbQkesg640snBE2w9RGazmQGttYYl58HjH7BB87GhwBy/MGHKQ8d8i2ue5bdrQog2soPBFEyAxSNcRIYCysaAuh8t1DBBec5H4M89irlRtKEPMNYr5BxDOI+0GE0T4xhZhvEPcMooO294ktRCPlRCrqiFY1YtfNQ9XWIfuXWlR5xcghwjUAuH4psm1pybk5sl6GnJcj42ZIF1Ok3TRpN02mlE8VU8E+N0WqmKLoj+6gdqIxl0QYpoNSoDx7kDBDZEjeL0RQbgjpOSg3jHSdYN0NoVwH6ZVSN9S/XboOypueE6SBwBg1kpOJeXRqBOngKE+ao1AqEGgoukGbt0+goVicUSNeTYApfGqsLmqtTmqtTmqsLirNbqqtbqrMHiqtHqrMbsrM9ISMmE50ikLSHvJpdzxaQy5Hwi4t4SBK7pGQS3PYI22dmGPcSolBwgxl+MUEfqGMcK6cSLYcJ1uBlQ8EG1ShDLeYoOAmKHhxDBVEP581RhBbkI6Nb1lIZEngaUBYQfaLKvhI5Q3Kn0COGScKY0RmtBS8pnw/n/j75bNejfHGZpSCrVsNtmwxaGsTeJ7oN7wLDO4Yss33AyO8YhHyecjnBYXOHLnOLCpbCIQXZlD0zhOKginxAS8exUskSg4Yfr+AmVR+/3d8VlBqVEFPgLOcndz0lQjuxZfOzvXHQCrJz7Zez4+f/v6Uu68CuGzh5Zw/75l05TvZ2rmFrTvzPPaH8+jZedpMVref5Lp7KXvGHYQSO8k/XEO+czVevoJo7WMk5t2LYeemfY2qosXCrMPCrMP8nE1D3qauJLxQVbQwdFtyQuQNSUvU58CqRvavaODgwjKaQgUOZ4/QnDk84Wi/yjfpefwyOu57MX528lFQhfCpPP9mKs/73YREbSvCFTTEGkmGyihzyigLlZF0yvrFEw0RCLYV/QIZN1NaApHd1tbdtO9+lExhavYjKhJF1tT2G6NPBlkM0/PkRXQ/fCVuz1ABVEMYhMxwKSqzg2M6OIaDaUxtHBQgHFYsXqxYskT2L4sXS8rLp3zKkxqlFD2FblqyLbRmW2jOHKE520xrppnmTDMt2eb+yLmD8XMx3J6aYOmuxeupxu2u7d+m/Ik5mc7QTYwpyDAeZqgbK9KBFe7AsNMYdg7DChYMLxCAVAKFgfItpJvAL8aRxSR+MYGbrUUWJ/YMsKUg4RkkPJPILAovOMJlbXg3G8I7OS2yk3XhXVRavUPKyMZ5+CtW4i1fEQgvLF8RjDFq5hS+D01NQ4UZ9uwxaGmZxju/NI8wINBQHCTUUOyPhN5H3pD0OD49lj/hcfmJYihIeCZJzyTqzX5LZlnoIJfGH+LS+IMsdZom5FCjEgna68vYXm+zrUKyPZZlp9XFYXpRlh14F51knjkRK0LMjhEyw4St0MC72goTLuXDVoRwaZtjOFhGn6CzVcqbIwpAm2JyYkqDRRQ96QXCivksfk8XsrsD2dOJ39OJ6unGTXVRTHdRyPaSxyNvKvKGpFBK86akYCjypiJnStKWj3usx7ZsGxUNBBlUNDqhuV8vXUbP48+i+7HLp9TmPJr4ioepPP8mwvX7pn2uYRTyGF1diFTvzE082A4qmUQmk2CPHIzRMixqo3XUReuoLS0V4Uoisoa23fNo2VvDgT0Jdm13yOXm5u+1tWMvPcXeUfevW/xHbvnD/5vx64av+xHhn/ywf/37i9v57uL2YeWCgB8NDBakFQLObjyX5fF11JtrKXOXQ66S7m6Dri7o7hZ0dQVLXz6VEnN/TqqQx9y/f9TdEaPATXeHUAsWHMNKDaWpSfDEEyaFQmCLd/iwwcMPm7S1zc3v94lMVZVi6dJAyG/ePInvw3XXWTx1ZBfSLQbCQYMRoGyH2ng95aGgbW0YQ51+z13Xw5M7v8hekUAYHokFdxJreAAhgkdnvmMdxdR8ajzFhodfy8OpNeyLFYcIAgiziPId6vIWFW7wLklZPq3xXlx/QEAt7BssyNn4AlpDLlnLp3r1z7h0yY/4t901rEsFZf3lK0h97VuBpzSAlJh7dxP6/c04t/4hcPAH0qbP95Z08GBFhrQlqSyaLK5YzqLG9SxccibzVp5Hw6Euut/9JV6//zMU1OhBdNeE93BR7BGuKf8TMTNP9r8+SPHy5+L84Xf849P38MEjo9vMXhB7nE81fIOokee1+69lV2HhmH9HieK5yXt539eq8S99dn/wCfGzX/Dc95836nEZyydvBHYqV677PH/b9SbSxSpMJYj4or/92m37dDt+/9/IDHXhJJrItW8Ys1591F/5FRJnPz2hspNGyUFBX/ygrd8nejVI8Er4pYHyCYo2RHyD1SVRhvW9QVpVHL9ds7fQyJ9SF3Bb74U0e7Pjc5U0M2yKbOHM6NOcFtnBEucwtiXxly7HW7MOf80avDXrkI3zhrTjM26GB47cx98O/pWHmh+YkPCCUuBnyim0LqTQtiBIWxfhdjSMKaJlGzaxPtEFOzqnRIpME5JJRXm5GpRCPK6IRhXRKP1pJDKwHokEY3K2HeiOzVXzpT6Rhj5xBiFMXFf0v1Mdx6e+/uQTa9WcPGgRBo1mdjnlRBgADh48yFve8hb27duHEIJ58+bxzne+kxe84AVYI0TW1Ggmwv79+3niiSdoaWnBdV2SySTLli1j06ZNhI5HhJIJoEUYNHONuea0qNFoNMeTtadvJzuGgc01l/+R//7qzE+iHQ88Dz75yRD33z+xAcNFiyT//d95KscJdpHtbednN7yTX3f+ddoRyxpUgstqL+SSZ76ZBWsunNa5NCc3c6098++f38WvfxkKJkxGCIcTrtzG4ivegr9kKViB4eOmujP4/EVf7i/T1QX/9V9h9u4dewS54OfpyHUMFWNQCuEXaTznQyQX/hWA6qJFwjXZFytOPpKobSNr61Cxoc7wbk81e//3q0ERw6ZKhilvTweRcAGE4BPve4LWKzz29e6lM9dBd6GLol8MIpoqia8kAkFNtIbGaCMVh9pwtm1jd8vT/KO8l7wxSw46phkY1dhOKbUDg5FIeNai3iScBJcvei4Xz7+UFRUrccyhk5st2Rbe97d3cyR9GAgEGA78+FPTjqRiYBCxA0GF0aLz+dIn46Up+i62YRO1o9jGyEa5Ukn29uzGH8V5yhAGS8uWUfALNKUODvu+CQTz4vOJWBH29Owa9TwCwdKyZadG5Ie+yNCui/AGRcEaZHQ5961fAltqXwTiDLaVozLaRFmsiWS0iVj8IJHEQZzEQYpOjqwlKZZEHbwRhB0UKogUT8l0qKSJIgiiQod8gaMEId/ojxQdKkWLDpWiL0RLYgl9YgqxQWIKffvCUoxsXGiZyJpaZG09srZ2iLiCrKufspODZmYp+kUyJaGGdDFN2k2V0jQZN02q2EvGzZAqpvr3ZdwMKTdFppga9flzPDhZRBhmC0OZxMxKIqqSsCgnQhkhWU5IJLFlAlsmsWQcS8YwZQxTRhFeBOGHUV4Y3zXJ56FQCCbrg2XAqbNYFP3bphTJUDMUKQccBooloQa3GAg0zKCz7MmCKcWf8dcAAQAASURBVHxqzG5q7Q5qrU7qrA5qrE7qrE5q7Q7qrE4qzZ5TQlxhJkmbPs1hj+awS3PIpTnsciji0hRxORQpDo14fxIQiDfEUYUywtlyQrlyRL4cCgkolEExgXIjCC+M9CJ4MoTnhfFkGM8P4fkhXD+MK8P4ykSaJsoyUaaJMgykaSAFJbEF1R8RUH8r5wijiDDYUjAvb/OOZXfz8r+8btarMWtjM1JiP3A/4Z9eh7lta6ADpCxyKkxGhunxE6T8GD0yTsqP0usn6JUxev0YKRmj14/T48dJyRg9fpyiGt8BVTY0BlE8R0GhkCUxBl96JSckb/h6KT8ZRD4/4nZTwcVeGzd8+gCFl79yUuecSe47dC+fffBT5L2R6zkMJRH5PCKbDSwmPRchJVKYdGx5Ix2PvSaIwAxjCE9OHruslYYXf41w3X5QEqO5OXA6mga1BZuV6RDL0yEWl0QXFuYcYtFKZEUFqrwClUigYjFULF5KB+VDYQiHgrEox0Y5oSByu20NvffBn4EQpd6xCsYGikeNGxSLwXqxiCgUENkMIpNBZLOITLo/Tylv9PYierqHRU6cq6iKCtxzzqNwzrmBOEOxhX29e9nXs5d9vXs4mDowqjiDXwjT9cAL6HroeShvdAeD0QjV7qf+ed8hVDe2gOiUUBKjswPR2Tm1zp9lI2tqSs+pyf1evHQ53Y88h+7HnoUsxDCFOeCwaYYJWaFRxwQnimHAkiWStWsla9b4rF4tmTdPG0rPJEop0m6Kw+nDHE4foil9kEPpJppSBzmUahpRuFlJgZeqotjRWFrmUexooNgxDz83y4bCin4nk6kIMswGISlIuCYJzyAkZ+fLWWN1sSG8gw2RnZwW2cHK0AFsMajNFg7jrV6Lt3Yd3roN+GvWoBLTd+TVHD+6u2HHDoMdO0y2bzfYudOgo2OGHC/75g9Kogz98waeS0oV6La9WennGoohAsX2DAn/rQnv4dL4g1wSf5iFTvPQnaU5yWB8vhavupqDVTa7Y3l22Sl2ylZ2pffQnhvukHwiELbClIfKKQ9VUB6u6M+XhcqI2wniTpy4HSduJ4jZMeJOnKgVO/HnyqREdHdhHDmCeeggRlMTZtNBjMNNmAcPBn2FEkUhSdmStClJWT4ZKxBnSFmS9KB8l+PRbft0lZwsu21/8nPgIxEKDYgyRKJjeqtJ1ya15QK6HrqSYse8aV86tuxxKs+7ici8XdM7kVJBf6CrC5EbWTB/0giBiidQZWWoaBSBoC5Wz7z4fBrj8/vFFupi9dRF66kIV2AIg1wOnn7a4PHHTR57zGTXLmMmAoAfE9o69tFd7Bl1/zPP+izX/fAHM3pNo/kIyTe+jr6JiieTOf7lGQeQR48NOw7+wkUw6NlwTsO5XHvJ57AGiadNZGzG96GnhyHCDCOJNXR3B8tx0WAuFjD37Rt196rQPv7ntkbk0mXHrk4TQCk4eFDw8MMmmzebPPywQT5//EUZbDuYxnEcRSwWOPEmEkF+/vyg/+Y4inRaEA7D4sWSujrF/v1B3WMxWLZM0t4eiFKZpmLFColtw1NPmRw6FMy/FYtBWihAWRmsWCHZuNEnFAoe+x0dgvvvN/nLXyz27AmetY2NwbUcB5qbBYcPGyUHXDj/fI9XvtIdMQiMlPBfn/0Stz+axy8m6N175ZD9QhgsrllDLGryjW/kmT9f8fDDJp4XXHPNoz+n9Sdf5fVn7aMwio1SZdHii5vnsTYV4cncCu4truKv5R77Vt2FU/skjek4l209m/ih0znk1hExCjwjso3T4o9zZ6XH93a9j4NdpxMt2aWWmykuiz/AVeV3sCJ8AGtQO8s77XQyH//0qP0Dc9tWYtd+AuPIkSHbvU1nkHnfB1HV1UMPUIrkG17LAzsq+VjzO+j1BwKx1Fsd/L+a67k08dDQz7S6mt7rbgTLQqR6Sb78an7Z/iy+2vZaJAPvxoXOEd5V/TMujD2KEJB/5av59NequL1n7ABbBpJvL/tvFt3yRYgM2DEZhw/xposPc7BYP+bxi5zDfPf1d/Dvv30WT3U0jlrOF4FNygULHiI/fzEPPlCDQmEpgSUFeVOSNSU5U5E3B+Y8Frz5U4TnjS7+ckyRgWADntcv1CBGEmvw/WHjTPV5m/W9Edb1hlnXG2F1KoSjRm7bSCV4IreKW3qfyZ3pc8jKGbSHMYxA4DsUQoVCmNEQC5dbLF0hWLxYUlOjqKlRVFcrrHgXj3c8wN2H/sojzQ8NEV7oCwjh5+P46XK8dAVephyvtwq3q45iZz1uVz3SnVjdA6GzoP19tA3fsSAUCu65b+n7DKqqFJWVirKyYInFTjqNuTGZa3bAGs14aBEGjWZ2OaVEGL7xjW/05zOZDD/96U8pFosopRBCEIlE2LhxI4sWLaKsrGxaggzvfOc7Z6LKGs2sokUYNHMN3VnRaDSaAdZt3EbGG30C+6WX/YEvff09x7BGs4NS8MUvOvz5zxNrey9bJvn85/OUlY1xTin5x5++wbce+QptYuoTuQLBefYKrjr7TZz+zNdiTDHKvObUYq61Zz78lQNcd4PoqwziKEuCUPluFr3uvajKAQXp5yy+gved9QEA2toE731viMOHJ278l/fydOTbybhpogu3UHnhb4jWPkEyVeAjT1Zxya5gNjxl+TxWluWhyiwPl2fZGxs9wuLRqHgCWVvbLxzhZZLs+ca3gp0lwQlLCaoLFoaCLsen+vJ3EdlwAFUxllq2QqTTGO1tQ4xspo0QYFqoWAxZUYpILxVY5hCDhKmiFCjfQpjeiJMdCSfBuQ3ns6ZqLYuSi1lduRbHdJAyMMZrbzdobxe0twva2kQwidzssbVlL03NLoXsUGHBhJ2gOlpDc+bIiJHOAJJOEiEEITNMxIpgGzbGLIhKtOfa6Mx3jrivMlxJdSSIoFfwC7RmW0rOGYqwFaYmUkfYCo97nrJQGXXRsSdWTymGiTR4gfNKydDy6EhYs42BpM7uoMFqp95up9Fuo94K0oXOEarM7jk9CaiSyZIR51HiCqV11ffM0Jy0KKXI+/kB8QY3TeYoIYdUMdUv8hDkU/2iDhk3M6P1OdlFGAwhiNlxYnastCSI23ESTiIwbHDiJPqNjBPEBhkbx504YTPcHwFltpGSIUINfREW8vk+YzFREnQIDMiGijgMFnoY2JbJCLLZIM1kxKmtQyBl0D52jxJncN2TUqDBQFJjdQXiCiWRhVqro19godbqpEoLLBxzFIou2+dgpEhT1KUpUqQpMpCmrJPvuzgiQoDjBA7AjoMKhVCOgzLDKGmjfAslTfBNlLSOWu/bZoIM+lZKleSz+oxFlRhxG/RtL633lek7x5Cy9B+vEAMOe4POq/qcT9XQ7SPVSUkT5VsgS/dQqn///fXdW3+ZQdt9C+XZKM9BeQ7Ss1FuKNg2TeG8iWBgIITAEEZpEQhK+XweM5tDKDAQGCqIqBb1BY7w+eE536D6xi/Neh1nfGxGKez7/074Jz/A3L17eucaRF469Phxuv0E3X6SFq+SB7MbeDy3mnavHAwDf+myGesPKKXwShFi+xfl4Ul3yLY+ZyFRKAxrDJoK5uUcFokefvUffyP39nfNSN2mSlPqIN98/Gs83NxnnK2gUETkMoh8YeDdrmRp8GTo/SglOPLAB4cZxPcjCBx8+sUIRhYoEKZLfNWDRBc/jfItiu3zkHmHSOVTlC25DUOmieZ91rebnN4ToS5v87XlraQn8JxfmHVYk42xwqxjWWQBy8pXkKxdFPQja2pQFRXIikpUsiwQ+jzR8DxETw9GdyeiuxujqxPR3o7R2orR1orR1oLR1obonZ5wxYxiWXinb6R4/oW45z8TVV2NJz2aUgfZ1b2DnV072dG1jV3dO4eIhLg9VbTd8TrSO8+c9CWF8Km84CYqz/0dwpyZ9oHIpDFaW4Oo5pOvEKqyCllROelnVKF9Ht0PPZ/itssIiThhK9I/djhdhAjmkJ7xDJ+NG33Wr5dEo9M+rWaKKKXoLfbQlGo6SpzhIAdTB0eMGuln4xQ65gXCDG0LKLQsotC6cMJOC5NGHh9BhohvEPcMEp6JI2d2jMFAsjK8nw3hQHBhQ3gndVbHkPEeWV+Pt2493tr1+GvXByLdJ+I7RDMp2tsFO3cabN9ulAQaDHp6ZniMqyTy7BWy9BR76PHSeCpwwBIjtMWmgy0FYWkQ8QUR3yDsjyJyfBQGktMjO7io8kkuXrSX2vk2sqoqaFdVVSOra3BrqmlJGBwy0uzt3cPenmDZ17uXoj+Dc4ezhAAqI1XURGqpidZSG62lJlJLbbSO6kgNFeEKykLlo4qln9JIiejowGw6gHHoEOb+fZh792Du3YPoHd0BfthpUPQMEmXotD26nGC9LeTRHvJoDbm0hTx6Jzr2IwQqHIFYDBmNlsS5h3/nlRRk9myk874XkT+yfMJ1Ho3ooqeoOOtWokueRBiT+A17HqK3B6O7O5g7nAEqiTKvfg0NK89mXs1K5icWlIQX5o3orFgswtatgejC448bbNtmHh+n/RmgrXM/3YXuEffFGh7girM+wZeu3Tmj14x96mPYd/8VgIzp89qz9nEkfNTfUgj8BQshPPA8uXLJ83nPGe8jFBpqXzXTdjNKQToNnZ2Cnh5BZ2cgzNCXDhZr6OwUM2f64bqYe/eMuvstVb/mmp9dgb9q9QxdcHbwPLjlFovrr7fp7h76LAmFFIXC9NoIVVWB825ZWRApPZnsy0NZmaKhQTJ/vpqTcQay2UBo4WgXIikDMfVQaJyms1K4b7mGVy34O2nLJ9exhkP3fA4vF9gpVRUtVi2p42Nfj7Nq1XC7ivh//BvWk09wKFzk68vb2JzMkbJ9qgsWi7IOZ3XFuLI5SaU7PRvGw241ewvzqbU7WOIcxhLDf6Opr3wDf/2G8U/meTh/vQNz61YwDIoXX4q/bv2ontrO728m+vUvk5Vh/pY+gx4/zgK7hXNjT2KK4Z9J5qOfxH3mxf3r0S99Hue2P3KwWMfjuVV0+uVsimxhXXh3/xyXKi+n54c38MC//pyP3f3cUatuIPlg3fd4zjUxsu99/7D9P3/Oz/jR9tGDdS1yDvM/Cz5H5H8/x5c+4XLbvWMYtAIhUeTrHzvMHalz+MWXW8dsH/tCEV5YwTdvTuEbeYp+kYKfJ+8VyLhpeos99BR66C320lvoobfYQ3ehm45c+6jvjGNHKfhLnzBDv3BDINaA72G5kpXZCOu7HDa0m6zrCdGYt4e16fPS4a/pM/lj70U8lF03MA8zGqYR2OdZVvBDtmyUUwqM5Dhj/oAVikLp8814mWBcT0iE6WJYHsIqonwL6TolodWpPysFIhA6K9ktmMbs2yVXVSnmzZM0NKjSIqmvVzQ2SsrKTi1xhYky1+yANZrx0CIMGs3sckqJMKxevXpUA8m+j2GmDCi3bt06I+fRaGYTLcKgmWvozopGo9EMsP4ZW0mPMWB+9aW/46v/8x/HsEazw49/bHP99RMzrlu2TPKFL+QZI/gbLXse41u/fAcPeFM3iI4rmxdUX8KVz30vdUs2Tvk8mlOTudae+dy3j/Dt7w+yJvC8QIhBSZQwcKpaWfz2oRNJr1rzWt64/i2k0/Ce94TZt29yhrQrV0quusqldvVOtuX+zsHUARYnl3DJwmdRF6nF3LoF5647cO7485Bod22Oy73VGf5aneLhiiz+eA5ghoGsqUWVlSGLEXZ95XtBhPricCcBgPkXvY/4/H/gz18AkeHWtyKXxWhrg/zIogKTJhRCllcERvAzNNYgXYdC6yLyR5ZQaF5KvnkxXqoK6YZAGQjTxUp0YsV6MEM5ahMV1IeW0hBdQCxiEokEUQI6OwcMDyYS4cOTHkW/GGhJCKvfkEWh6Cl0k3Ez+NInYkcpc8qOqSq3UoqWbDO9xaHG+EknSW20bpjww2jjP1JJmjNHhkVni1pRGuKNmMJk/nyJaQZzcoZBf9401ZB1wxj6Jx9sWzj4q3n0tpLNbykNHGNLc5H9eSnFsG3BcpyifYxEX9TxwRExPW8gItYEHFst4ZM00sTMHEkjTZXVQ6XZQ7XVTZXZTZXV3b9eY3WNOBk/JzCNAYGFmsHiCgPbtDeAZrpIJcm6GdJueoiQQ7qYJu/lyHk5cn6OvJcn52XJe/nS9tK6n+8vl/fyeGqoEd1cmD1wTKc/ImrYihAyQ4TNMGEr3B8htV9YwYoNElkYLLYQ5CNW5JiJKMx1lAoMUTOZPnEG0Z8faVs6LUinIZUK8r29kMudpJ9ln+BQsTAQ2bmUzsXwaAaSaqubWquTmpLIQl1JYKHG6qTO6qDa6tYCCycgvZbP/miRpkiRA9Ei+6NFDkZcDkSLo0bBmtMYRklswQGnJLTgOGA72rprhlC+GYgyeA7CCxGmnBBJHJXAkkkcFceSCUwvgfBi4EbBjSKLYZQbxsuH8V0HL+/gFmzcgkUxb1HIWUGfc5y/k9HZgWgfHgXWEj7/WfsDXrB6J70/+dls3X4/MzY2oxTWQw8S+fH3MXdsn4GaTZyitMi8/d8oPP9FfVUZXK0h9PU5pRxYfF8M2zZ4CfzjxAj7FOlClr/d73Lrd3N4hRyeCGQZbCVIegaGEoREkdvf8CMyH/vUsftQjkZKzF07sf9+D9t23M23Qo/yZLhz3D6nkiaZI+fQe+BZ9O4b3Qh7IoQqd1O26laSK+/GtHtB+oGDYbHI6h6HCzviLMw6LMo6LE+HMAcZ5jaFi3xw/WF2xAec9EPSYA21rK3byNra01m9+FwSi1ajyiv0czKfx2htwTx8CONQE8ahvojFhzBaW45rNHt/zVqKFzwT94JnIucv6N8uleRA7352de9gW+e2QJihayddO9bTdvvrcXtqJn2tUO1+6p/3HUJ1B6ZeYc8NhC1SUxO2UNEYsrYuMFyfIFErRm338+h44Hm0bFtC2IrMmFhrIqE46yyfc87xOessf8z5I83cQSpJa7aFA70HOJjaz8HUAQ6mDnCgd7iDoZICt6eGQmsgyBCki/B6xxJbnkqlZPAc9+WMD4YIIOoNCC8Mjiw7XZJmhg3hnf2iC2vCe4gYgwSvLQtv5Sr8tevw1gbCC6pqhj87zQmJUtDaKtixY6gwQyYzc99PhSLrZkvzSOngdX30hMkQcQbV/04XI2wbhhiasTCwlYEtTGxhYQgT0zBxHMG6FS2ctrGdVWf3Ep7n4IVssm6W7kIXPYVuugpddOY6aM4205ppxldzu8/tmA7z4vOYF1/A/MR85sUX0BhvpC5aT1Wkekj0ec0MoBSiqzMQZNizO0h37cDcvy8Q3Z8GBUPS5ni0hYKl9SiRhraQR5vjDZ83N01UJIqKRlHRGDg2gx0BlYLc/nV03Hc1uYNrplVHAKeimfIz/kRywz0YTn7kQkoi0mlEbw8im53S+zTqGyzIOizMBf2ohVmHxoY11D7vtTgXP3dMx0nPg+3bDZ54IhBeeOopE3dm9B+OO+2dB+gqdA3ZZjo9lC37A9Xrv8+6os1XPjO6MMBksTY/Qfzf/61//fMrm/ltY/ewcqqyClk90K85rWYjn7/oS1iGNafsZpSCXA66ugZsJIbn6c9ns2O8Cz0Pc8/I9mjLQwf4vwWfxP/qF/A3nDZLdzOz+D48/XTw/q+sVCxbJrEsOHhQcM89Jk8/beL7sGiRZONGSXW1wjAUQvQP9eI4YBiKYjEYi6qsVIRC41/7ZMXcvZPEv7yZpnCRT69p5vGyLH4hgXHkTE7fu55XZzrYcEU95sf+a2BAzrIwtzxN+PofYT/04PG+BQDcs84mc+0XZufkUhJ/37uxnnxi7HKhELk3v43C1S8dslmkekm++Z8QnSMHWVFl5aQ/8ZlACOKuu/no2zM8mF0/rNwCp5mP1H2HDTVH6P3+T4YEL+qj+Jd7+c93Srbllwzb9+KyO/h/NTfAa64h/8a38OBdeT76po5Rg5ZEjAIfe8H9bPz6a7nljzZf+1g6sFEbCcNAVlXxqnfEecMbJm8IVPSLdOTaacu10p5roy3bRnPmCIfSTRzJHKYl03w8h9JGIBjILjcTrIkuYa2zkJWheSwxaqghFszRKkVbKsztj9fzp0fr2N8aBWGgDCN4IPUZbU1iDLUvWEbOywY2FV4OOYv9gD7hhb7gELMRyMgwoKFBsnChYuFCWVoUCxZIYrEZv9xJz1xqz2g0E0GLMGg0s8spKcJw9C0PNhiZiY9DCKFFGDQnBFqEQTPX0J0VjUajGWDDM7aSGkOE4aqLb+Z/vvneY1ijmefWWy2+/OWJGerNny/58pfzVFSMvL+YS3PTz9/L9Yd+R3EEdeaJkFQhXj7v+Vx59ceJV9RN6RwazVxrz3zjh1184ZvpUffbZW0s+Zf3DNn2b5vew3PmX80HPxjiyScnFv3IceA1rymyaZNk1So5sTmNfB7nztsJ3fxrzD1DjQJ6LZ+/V6X5c12KByoyyDEcxlQ8jl/TwM4v/yyIUDJKGIPGCz5CcuFdAMj6BlQsBq6HyOcQ6VRgDDJNVCRKPFnDosYNxMvqCJkhKsNVLClbSkW4kryXwzIsaqN11MfqMYSJVD5SydISRKU8kj7E/t59dPQUOfjkMtr3zqNpT5wjTRF8qZBKopREEhinWUafMIJAKr9fKOFkNLIKhRRveYtLQ0OgxH3ttQ6HDxvkvCxZNxDQiFgRonaUZcskX/lKnj//2eIb3xj5ffPP/+zy6le7fP7zDrffYZIppsl5ORSKiBUhbifYtEly7bWFYdEO5iJSBkZGQ5cB4QavX2ReDMoPlOnTSJj4ccODgI4QFLRkgBEYXDjCJZTtIpxuJ5zqIJRqJ9rbQiLXSjzTTHnvIcKp9rnvX2LbyOoaZE0NsqoaVUplTW2Q1tahKicfEVKjOd5YtsCTHq50cf0imXwBXwViPJ50cUv7grw7YDNd+hesDOSVUv37TGFiCgvLMLEMq5QP1gfywXbbsAhbERzTmRUDBM3M4Hn0CzP09gbiDKlUsB4sA/k+4Ya+/AQ0eeYmnlcSGSr2R9cWxWIg0DAL021hUaDK6u4XJKq1OqkdJLRQa3VSbXWPGKVIc/IiUbQ7HgeiRQ5EA1GGgyWhhkNhd8z+06wjBFhWf1Qh5QxKLYvpRAY61bANm2QoSdxOkHASxJ0ECTtBwkkSd+Ik7ARxJ07Mjgd9ICtG1I6WRIeihMzQjAkPKRX0FbJZyOcF2Wwg0JPLDYj2ZLNQvPtB3HseJu1HycgICsF8u4Wryv7GIucIsr6e3utunJE6jcVMjM2YW7cQ+c43sZ5+aqaqNWFkQyP51/8zxcunJxAwHe6+2+Qz7+xC9Iwe7fWu511L4dvfnv3KKBVEUD1yBPuRh7AeeQhz/77AgXzQ406iuHF+F99e2k5xBKEa6YXo3PZKuna+FD9fOZ0KEV/wNypX/ZxI9VP9fdeob7CuN8KGnggXdsRYmxo/srBCsStWoNvxSbomyzIh8l/8Ot5pG6dRv1OQYhGz6UC/Q5yxdw/Wnt2Ijo5jXhV/0WLcC56Je+FF+MtXDDP8dn2XPT27eerIdn51Y4JH/ryWwiQjAwvhU3nBTVSe+zuEOYnnm5SI7i6Mzo6pCYuZZiCIm0wy3vt8Xnw+66rXs6psA5nt5/C3W+aze/fExpknQmWl4uKLPS680GfdOjl2FFLNCUeq2MvB1MFAmKF3PwdKAg2H003IQX0uPxcLBBlaFpNvWUyhZRHFzgZQMzCGUHKGEr4/5X6eIwUxzyDumUR9MSya51RZ7BxiQ2Qnp4V3sCGyk4V28xDBPVVRgbduA15JdMFfsXJSoimaUxsp4fDhocIMO3ca046GDeBLj95iLz3FHor+TIUjHx0z2ktsyZPEVjxCbMnm0Z3G5zhRO8ry8hUsK1/BwsSiQHghsYDqSLUeM50L5HKYe3Zjbd+KuWM71o7tGE0HZlwgTKLodHxaQy6tJaGGtpJQQ/96XFCIhQNhhkhkiChD7uBKOu9/EZm9p0+7LkYoS2LN/STX30u4cSdC+YhMFpFJIzLpCQmxm0rQmLdZWBJZ6BNcWJC1qS5awTvTELjPvIT8S16Ov3bdiOfxfdi92+Dxx/tEF4w5KRpsGFBerqisDJZEQhGLQSymiMcH8tGownHAtoMhNNtW2Haw/stbPsJNu3/bf05hupihrv7uxopshP/5zL6ZqbCUJN75NsydOwDYmsjzxjP2D8z/9OGE8BctgtKzqD5Wzzef9X8kQ0EU+LlmNzMZCoUBQYbu7iDARXc3dHQYdDUXSf/6Djq8Mjq8cvIqRLmZ4tmJ+3lj5W+psFKkP/8lvE1nHu/b0BwnIv/3LUK/HBj/zJqSdsdjfs7GGNQnkA0NGC3N0xbzmS2y73o3xRe+ePYu4LqEr/8xzl23Y7S3I2vr8E7fiL9gYSDeXFOLt3oNqmLkMTzR0UHkuh9i3/1XhOsiy8vxV6/F3biJ4iWX0e9trhTi/R/mJ39awM09l5KWUaqtbq4uu5PXVNyCs2I+2X/7j1HfNShF8ds/4abv9vCn1Pm4ymZF6ACvrriFjaf75P75zXhnnwME76WPvyPFQ39ODXsfzqvO8YkPppn/kmeAELS0CF772ggi1YvR0RHMMQqBCodRiQQqnuCiy+BDHyrOirlJ0S/SnDnC4fQhmtIHOdC7n329e9nXs5ecN0OBi2aIqB1lUXIxCxOLqIvVUxutoyZcS/rwfB68u4b77o6SSo3+IfnKx5c+vvLwpEfBL1L0CxT9IkU5+/0SAUTtGAk7QcyJY4qZG8SyrEAkZ8WKYFm2TLJ0qSQy/rC0ZoKcyO0ZzamJFmHQaGaXU1KEYTZRSmkRBs0JgxZh0Mw1dGdFo9FoBjh90xZ6ivao+59/0U1881vvO4Y1mlkeesjgwx8OT8jWr65O8eUv56mtHbnr8vR9N/K1Oz/KAdE9pbqUqzDXLHwRV1z9UaLJ6imdQ6PpY661Z374sywf/9LoBsdWrJul73znkG2vK/sf7rjhbA4fnthMzvr1Pl/6UmHqEz9KYW1+gtDPbxhR1b3Vcbmtvpc/1PdwIDrKBIhlse2Xf0N5JsIbWQW84dxPU7bktilWcgwME6u8kivWXcOz1r2M1ZVrpjz20Nws2LLFoLVVsHWryaOPGuTzc89YZKa55hqXl73M5b77LL7zHXtEA5lQSPHGN7q8+MXeEPv1zk74+MfDbN069Au4cqXk4x8vUFMTvDv+/neTr3zFoacnODiRULzrXUUuvTT4jRaL8PWvO/zpT0OVFi64wOe97y0Qj8/kHWvGxfMQXYFjgNHZgejsxOjpDgRT0mlEKhUYdKVLSy474AQ72bA24XAwmR2JoqIRVDgSbEskkWXlqLIyZFkZqi+fLENVV6MSSR2JVHNSMtfaMpqTk77IU31CDYF4gyCTGcin0wPr6XRfGuRnwvh/VvA8hBsIMoiiC54bbOtTLlIKA0nCzJI00ySNNEkzQ5UZiCwEaTeVZg9VVg/VVjdR48R0EtAcPzyhOBR2SwINA+IMByNF2kKTj5g0IqYJth0ILdg2qmQRrmwbLFu3kUZAAMlQOeWhcirClZSHyikPVVARrqA8VEF5qJxEKNkvspBwEiWhvROL0C9/TuT/RnfKl9XV9P7s17Nej+m0Z0RXJ5HvfQfnz7MwfjDsYgTCbg3zkI2NeKvW4K1dh1y85LiLuT36qMEH3pxBdLSPWuYPz/gg1k3XIVpbsR9/BKOpKXgPej74wftPmSYqHkfFE6hYvGREXFqPB+sUihjtbUMW0d6G0d6O0daK0d4+qX7e4bDLDxa1c2t9L75QSDdC+si5tD76brzc1CN/C7NI2ZI/Urnq5zjJJhrzDqf1RDitJ8L63jDL06EhxvRTQVVV0fPTXx33v//JgujpDoQZtm/D2roFa+vTiK6u8Q+cIWRdHe4FF+FecCHe+tNG/Lvu2GHw2c8b7Njtkvfz5L08eS+Hp8Z/boVq91P/vO8QqjswdsE+IZOO9qBNOgVUIomsrQVzuEJpyAyxqnI1a6vWsbZqPWur1mF55dx6q8VvfmPT1jYz7YJkUnHRRT6XXuqxfr3UP5NTENd3OZI5HIgzpA5woHd/fz7jZgCQrkOhdSGFlkUUWgNhhkLbApQ/+nzruCg1IMog/VEda8O+QdQXRH2DiG9gqul/96NGnjXhPf2iC+vDu0iamYECoRDeylX4q9fgrVqDv2o1sq5et8c1M4rvw/79gTDDjh0m27cb7NljTPWVAkDey9FT6CFVTCGZmUizwvSIzN9GdMlmYos349QcRBgnlll0MlTGivIVrKhYyfLylSwvX0FDvFGLLZxopNNYW57Genoz1tNPYW3bEnh0zzIKRY/t94sytFY4NC+spqU2RktC0BryaDpUw6G7n0N61xnTuJDqfzc68YOULfgjiQV34ST3IQQYSlDumpS7JtVFi4acTUPBpi5v0ZC3acjb1BSsUftOKhaj+LwXkH/RS1F1QwOnFAqwbZvB5s0mmzcbbN06N0QXwmFFY6OioUHR2ChpaFDU1UmqqgLRhbKy6XfxfvLr9/LTbdeNun9pNsS3PjNOv2CC2H+9k9hnPgEEAiBv3XSAp5LDHXL9BYvo8/I0hcHXLvs2qypX9+8/aeeaslnKX3QlUPopYGCKoe+y9Kc/j3fOucejdpoZQLS2oqJRRjMQMfbvw378UURbK0YqhejtDWwXurswWlsQubnlwD5Veq+/MehbHAuUmt0+jO8TvuEnWLffDq1tUFOFPOMMiudeEAgoTOAhbe7Yjv33exDFAn7jPLyzzkHWNwwrVyjAD76t+MvNRTK9knDU4KqXCl75ZmfYV+rTn3b4299K4yxSDqnHNde4vOlN7jEf+5BK0pZtZW/vXvb17GFvz252dO2gKXXw2FZkEijforj3LNJPX0zvrtNQvugLFYEcFDjiWBO1ooG4tp3ANKYvvGDbsGxZILawfHmQLloktebiLHPStmc0Jy1ahEGjmV1OORGGY4EWYdCcKGgRBs1cQ3dWNBqNZoCNZ2yhuzC6UdAVF/yW//3Ofx7DGs0cu3YJ/v3fwxOaEK2oUHzlK3nmzRvebUm1H+QH1/8Lt2YenlI9QsrkmrorePEr/luLL2hmjLnWnvnVbyX/8ZlDo+43w2mW/b9/6V/vfeoCQvd8jpAZntD5GxslX/5ygaqqmRlaMDc/SeRH38N68olh+xSKx8ty3Di/i7ur08Oiu+749a3I4ugDiXVnfoGKFTfPSD2BYBKwvILnb/onXn36W6iKTM2Qf98+wR13WNx/v8n+/aeWIdXKlZJ3v7vIihUDhgmdnXDHHRZHjhgIAdGoYv58yRlnSKqrR/6eFYtw220WTz4ZHLN+veTKK71hk01SwoEDwbtn4UI1bMJSKdi8OYiWArB6tc9ZZ0lts3qioVTgVFAsIoolwzYhgklrw0AJoz+PbWvnFo3mKOZaW0ajGYliETKZIPp6KiXI54PI7ENTyOUEhUIg2tC37rqBA4HvB20DzxP964O3W9bA66JvMU0wTYUQwf5wGCIRRSgUGNuGQoPXg3wioUgkIJmQJGU38WwbVkcros+xtLsL0d2N6OnGKKUikxn/Q9BopkDWlENEGfaXhBoORF0ylgwcK00TFXzZwbJQljUkxbL6I9yd6tiGTWW4kvJwBRWhCsoGCSz0iysM2ncqOM6Efv0LIv/7zVH3q8pKem787aj7Z4optWc8j9DNvyH8kx8istmZrZBl4i9YiL94KXLxEvwlS/HnLwgMmeeoleTOnQbveG0Bo7l51DI/W/SfLFpqYBxqOoY1mxh56XBd7gK+X7iA3bkluNNxwDM8KpbfxLplP+W8XJEzuiNs6opSO4aA8lQpvOTl5P71neMX1EwNpRCtrVjbAkEG6+mnMHdsOyZRJ1VZOe5551O88GK8Z2wa8tsvFuH6621uvNHuF632pEfeyw0SZsiP6KQqhE/l+TdTce7vMKyjvGGVQqRTpYiKU3T8s21kbR0qFngKGEKwOLmEVZVrWFW5hjWVa1iUXNJvTN7WJrjpJos//MEim53+gJphwJln+lxxhce55/rYM/+z05wEKKXoKnRysPcAB1MHS8IM+2nLttGRb6c3l6XY0UihZTH5QeIMsjj50JACgY2BLQUhD8JFn3DBx5HTleEBR7isDO1nTXgPa8O7WRvew0KnGaM0DyJj8aANsXgp/rLl+GvW4C9aErTbNZpjTLEIe/ca7N5tcOCA4MABg/37A4HxySCVJF1M0VPsmXTEXSveSXjeTiKNuwjP20Wobu/wd+EcpiZSw7KKFawoX9kvulAdqZ71AHOa44DnYe7ehfXUk1ibn8R64jFEOn1cqqISCdwFC3jUWcVP9l7M3/evwDOMQLwOhRKB1pBUEqVkvwgRUiJ8D+F6CM/HIBBbEIChwFKCWquTcyNPcWFkM2dFtlJp9U6qbrKhkcJLXkbhOVdCNIrrBnO6u3YFwi/btpns2DE9AZjpEospliyRLFkSpIsXS+bPl5SXz77+0Q03vZ/rnv7hqPsXZ0P876f2TX/OU0oSb3sj5r69APy+vofPrD4yrJhKJJENjf3rb9rwVl65+jVDypy0c02eR/mVzxqzSOajn8R95sXHqEKaCZHPB6Kf3d2o8nJkbd3QMTnPI/SHm3H+8DvM/fsAkA0NuGedi79mDSoUxty7B/uB+zF3bD8+93AM8ZctJ/W/3z/e1Zh5+lzmjkF7q1gMTFZCodG7bMUifP7zDnffPSB4WVmpeMtbilx++dx6ZqbdNLu7drK9axs7u3awvWsbR9KHj3e1huFn46R3nkF655lk962fniDjFIhYkX7hBcsYLmQ64fNEFMuXD4gtLF8uWbhQ6e7/ceCkbc9oTlq0CINGM7ucUiIMGo1mKFqEQTPX0J0VjUajGWDTmU/TmR/dCPfZ5/+a7/7f+49hjWaG1lbBu94VprNz/AHtRELxpS/lWbJkaJdFScnffvd5vv3Ut+kRkzceFAiuiJ3Ba176RaoXrJn08RrNWMy19swf/2jy9o/uH1XZ2bDzLP/3NwOQ3b+Gphs/wNLkiglNBixbJvnsZ/NUVMxolUEprMceIfLd/8XctXPEIofDLr+e18XNDT2kreAz3nXTzWNGNKx9xv9QufrGmaliLM7ypefybxd+ZEhEh4nS0SG46y6T22+32L375HfEGUxDg+TMMyXnnutpgQONRqOZg8y1toxGc0pSLCJ6ejB6uwOBhlQKkckgsplSmkVk0kO35fNQLCAKhZIQUXFSUcNPGIySsFJJVEkZxhCxJYRBYAFe2te/XYBh9pcN9omhxnZ9kfwU/cZ4QsqB7UPKyKPWg0UctQ4Ejp0z1eg1BMq2wbJLqQmmFeRNC2yrfz+WhYpGUZEIKhoL0kg0iOI1aLtMliGTSbpFjqZ0E4dSTTSlDtCUbqIpdZBD6SY8eeI4skyXpJOkvCSgUBGqoCxcTmWosiSwUNpeSiNWRDvIHEXo5t8Q+cbXRt2vysrp+dUMiiOOwmTbM+b2bUS/8Nl+I+tpYdtDI1IvWYqcvyAQMDmBaG4WvP6lCqNp9Chn/7fgE5wWGXnc5nghleDG7ufy484X0e0PGJsVDEl7yCNlTTzSsqUEp9XeyRuqf8XluTQNYwgmzxSpb3wHf9WxCSyiKZHJYG1+EvvxR7AefxRzz+5Ro9zPFCoSwTvnPIrnX4h7znkQjQKwfbvBF77gjCjSqlAU/WIgyODnyXs5in6xf8zXLmuj5rLria14BCE9RG8vRnfX1NuDQhArr2PhivNYXLmCxWVLWFK2lBUVq4hYwx3Xd+8W/PKXNn/9q4U/A13IqirFVVd5POc5HjU12qRNMz0KfoGOXDud+U7SbppMMUVvIc3hI4rWIyG6WuJ0tSbobknQ3Zok05VAYGCIvsXEEha2YY8cvVLKfjFYUSwG+X71P2/YM8UUPo12G8ucJhY7h1jqNLE4dIil0WbMRBRZW4esb0DMa0Q2NKAaGpFLllBIVh4TZyGNZjpks3DwoMG+fYLDhw3a2gTt7YLW1iAtFEb/Dhf9IqliLyk3RdEvgpCYkRRmNIWd6MCpOoxTdRi76jBO5RGs2OQcvI8njfF5rChfyfKKFSwvD5by8ExPrmpOGKQMRBkefRjricewNz8ZqMkeB/YU5vHjzhfyl9R5SGZ2vrrW6mR56AAL7GYa7VYqrV7KzRQhUcQSHgXpUFQO2WXr6Dn7Upqr19HaZtLSImhpERw6dHwFFxIJxerVktWrJStXSpYskdTWquP2Kr7xdx/hh5v/b9T9C3IO3/3YHqarWmbfezexT3wEgJwheem5e+h0jvpDCIG/eGn/tU6rOZ0vXPzVYeKjJ+1ck1KUX3HpmGJ+mQ98BPeyy6d/Ld/H3LYVc99e5IIFeKvXzlkxz+OO72Pu34uyHWR9A9YjD+Pc81fM3TsxWlsRqaN8JUIh/MVLkNU1iFTviEFiTmW0kMix5cgRwbZtBrGYYsMGSWTyeoHHhVSxl51dO9jWuZWtnVvY1rGF7kL38a5WP7IYJrPnNDK7NpHZtwE/UzYr14lYYeJ2griTwDYm/x5OJNQQsYUVKySNjcODCmmODydte0Zz0qJFGDSa2eXEmu3XaDQajUaj0WhOEcabvPNPQLuzbBY++tHQhAQYbBs++cnCMAGGwzse4Ju/eReP+PuZSliZdUYj73z+F1hy2gxMeGk0JwCOA4Yw8NXIg8BKBsMCyjdp/cs/gzJGNiQ8ilWrJJ/7XJ54fCZrW0IIvE1nkvrm/xH6/U2Ef/DdYVEoG/M279pdy5v2VfPrxi5+tqALYY5toCL90LSrpiJRVsx7Bq+88N2c33jhpCOZHjki+N73bO691+qPbHeictZZPh//eIF9+wzuvdckkxEkk4ryckWxGESaDoUU1dWKqqqBpWRXrtFoNBqNRqMZDcdB1dTg19RM7zx9zkBuEfIFhO+VHIH8IIKd9ANj0dI6vl/aVopyJ8SwRSEGIqr1iR/0DWD0rwerqk/0wDSHCCUoMUgYwTSGnEcZQ8sOEVHQDkezhgAqiFARrmRD9WlD9kklac220Jw5QnuujfZcO225Njpy7bRlW+nIt9Od78JXc6+DYwhB0imjLFReWsooD5WXtpUN2VYeqqQsVDat6EQaAoGTsZBzzEDN8wjf8BPCP/3JmMbzYxIOU7zwIry16/HXrMVfvOSEE1wYiXhcoeyx7yPlx45RbSZGs1vFx5rfzhO5VcP2haTBvJxD3pD0OD4py8cb9FoRQMwzCPsGjhSUKZcv1n+NC6wnoRtg9gUY3Esu0wIMx4NYDO/c8/DOPQ8A0duD9cTj2A89gP3A/YjOzhm/pMjlsP96J/Zf7wTLwlu9Bm/9aazbcDrf+sJ6rvtNOb/4hT1k7FAgCJkhQmaIMgaMxj3p4UoXt1BL4bcforLyEU5f/HkoO0y3bZC2bKRQSMAXQXRjUwlinkHcM4h7JnHfoLpgUZe3qC/Y1NYspfzN7yO57pwxxYZ8H+6/3+Tmmy0ef3xmQvEtXSp52ctcLrnEn67/mEbTT8gM0RifR2N83tAdK0cuXywG4/gdHYLOzoG0p0eRz/vkcpDPC7LZQHct6L44COFgGEGU7Hg8eJcm4opkOE99tJf6ZIbaCpeqZBFDJECtRoU3omJxVCJBOhQa0uc52tAfbeivOQGIRoP5w1WrAIZ/Z4O5I8hmg99QNiv6hw0MA0wzhm3H6DH28lDX7fz98N84mDpwzO9jqhhCsDCxuF9sYUXFSpaVryBmz612s+Y4Yxj4K1bir1hJ4RWvBtfF3L4N+/FHsR57BGvL0xwr9YGloUN8ouHbvKnqt/yk8ypuTV2Ir2amXdfqVdLqVY68UwhUMoksr4DmEPxuRi45ZQwjCD6xZo1kzRqf1asl8+YdP8GFkRDm2P1zT6jgezOdRrRShK//Uf/qr+Z1DRdgAFRFZf91LMPk3We8d9I2Eyc0QgQCuMXi6EVmQBzZOHyI+Af/E+NQU/82f9FiMh/8KHLpstEPLBaDv89c+gLPBJ7XP09gbtuKfd+9GJ0d4LpY27dhtLVOToSwUMDcvg1z+7bZq/OJiGWSe+NbtQDDMaahQdHQcOL19xJOkk11Z7Kp7kwAlFK0ZJvZ0vF0IMzQ8TS7unfgHac5AcPJk1j9IInVD6IUFDsaye1fR/bAWnIHV+Pnpu6oHLEixO0ECScx4Tklw4D58yVLl0qWLZMsWaJYulRSXT232hwajUaj0WhG58S3ANBoNBqNRqPRaE5Cxhtck1M1DD5OSAmf/WxoQhHfhYAPfKDA+vUDVob5dDc33fif/PTIHyiKyQ/OJpXDW1a/mWe9+EMY40xQajQnE6YJpmHijxKCTPkWSkH3o8+m2DEPS1iIcRROGhsln/70LAkwDMYwKLzoJRQvvJjId76Jc9cdw4pEfYPXHazi5YcquCQPY02RKi/cn1+RDrMmFSbmGVhKYKrAADll+TRFXNpCHgVD4hqKmAgxb9FG5q99JmesfDZrKtdOOtppKgW33GJx3XXOWPPxJwTl5UEkute8xsU0YeXKIAKIRqPRaDQajWaOYRgQDqPCYUjMelBnzUmKIQzqYw3UxxpGLaOUIuNlSBV66Sn20FPoIVVKs16WvJcj7xcoeHnyXp6Cnyfn5VFIpAoWhQpSFaSWEUQbtgyrlHeCddMiasWI2VGiVoyoHSVmx/rzfWlZqIyYHT+1jMDnAuOJOs4hNULR1kbs0x8LHFymgIpGKbz4ZRRe8jJUcnaiaB1PolEQ4zhv9Mrj70xWlBa3pi7kDz0Xszm/YtzyYWkQzhvU2lHyEZui8rA8STTvIUovyqiR50uNX+QZ0WNniO+t30D27e86ZtfTjI5KluE+8+LA4aAUpdj+x33Y/7gPc8f2mb+g52E9tRnrqc3w8xuIG4L3zF/Is9eex2eevJq9qSqwrAGhKkCUxLNwXZxigVA+3+8A5Let4fHtP+D5ZXfzocqbmWe3TfzeIxHy//wmCi96STCoPApdXXDbbRa//71NW9vMWImfcYbPy1/usmmT1IbnmuOO48CiRYpFi2aqB2UCFaUl6JedeO41Gs3M4DjBUlbW9/sa7Xe2mNMWvJk3nfZmmjNHeKj5AR5sfoDHWx8l740tyH6scEyHxcklLC9fwfKKlayoWMmSsqWEzOkLwmtOMWwbf/0G/PUb4LX/BLkc1lNPYj/6MNZjj2Du3j3rVVjoNPPh+u/yxqrf8pPOF3JL70W4ahZsaiwLWV6BKisbs715LFi6VLJxo8/GjZING/zZt3uYJuMF0ZCCoI8wDex/3Nf/fcuakhsWjiBIZ5rIygFxjZeseDkLEgundd0TERUKIcYy+pimQYhoayPx/96O6O4est3cv4/Ee95J+iv/g790+aAKKex77yZ83Q8x9+4NnivLV+CedjruRZfirxwuVjknyWQwmw5iHDqIyGQQnodx6BDW05sxd+/UExwzgIpEcM+/ECwL68nHMY4cQcXjeGvW4p3+DIqXPRs1XXFwzSmLEKJ/LumyhUFwtKJfZFf3TraWhBm2dW6hOdN8HOoGoerDhKoPU37GX1AKvHQFxdaF5FsWU2hdiNvZiJeqxM8PH/MWQMSKEnfixO3RhRcsC6qqFNXVgaDT/PlBOm+eZP58RUh3FTQajUajOaHR3kcajUaj0Wg0Gs0cxBBjzx748sSyRPv+923+8Y+JTaS+7W1FnvnMYIJQ+h533fw5frjl+7SLLOP4ho/IlbEzecNrvkWyZtHkD9ZoTnAcB8xxnE68dAUdf38JANY4IiXl5Yprry1QXj5TNRwfVVVF9oMfpXj5c4l94dphk80QGNGvzUGvZ3M4MrLCvfSD2Yz/2lHPiw+Xj39h2yb/kpdReMWrUYnklOq+b5/ghz90eOABc7p2D8cE24bqaklNjaKuTlFZqbBtCIcVjY2KxYuDCaLxgptqNBqNRqPRaDSaUwchBHE7TtyO00Dj8a6O5ngyjhOFmCMdY+vxR4l9+hOInu7JHxwOk7/6pRSueeWUxwpOBAwDYnHImeaojhwp//iKMGzPL+LDze/iYLF+5AKmgYpEIRRCWXYwrmyYqFAIbBsHcEpFJcF4/DM2erzj1a0sNt9BtuUIRnMzRnMpbTmC0doCUxBH9tauw1+5Gjl/PrKsHJHPY7S2oBwHuXAR7nkXnHxRKk8GBkUpzr/unxGdHdgPPoD993uwH3loclE2J4pUGAf2cxr7uY5f8T33pVzf8nwkEx+Mkxj8vucSbum5iMsSD/Ky8j9zenjHmF8x95kXk/3Xd43qbJFOw333mfz1rxaPPjoz45ymCZde6vGyl7ksW6a9aTQajUYzMvWxBq5adjVXLbuaol9kR9d2tnVuYXvntmPixCWAxvh8lpQtHbI0xudp0T/N7BCJ4J11Dt5Z5wAgujqxHns0EGV49GGMtomLbE2WRrud99f9gLdW/Yrf9FzOb7qfRac/fdFBFYujypKoWPy49XsWLJBs3BgIL5x2mn9MbR1mAtMcWyTRFwrhe9PyUQ/96hf9+V/N66LbHt7oV+UV/QKcVZEqXrPmn6ZxxRMYa2ybGuFOQ4RBSmKf+9SINjEAIpsl8bY3IRsa8TadgT9/Ac5tf8Tcv2+gkOtibt2CuXUL4Rt/hnvJZWTe94HAeOh4IyUi1Qv5AmbTAexHH8bcthXz4AFEV9fxrt2cJvtfH8S+9x7s++8dc2xK1tZSuOpqRDqF8H2U7aCqqvBWr8VfvmJg/FapYNHGP5pZxDEd1latY23Vuv5tnfkOtnVsZWvn02zp2MKOrm3HXGhNCLATXdiJLmLLnhiyT7oOXqqSeHEJy6NnsDy5jgXRlZgyTLEIliUJhQqEQhAOQygU2NZVVSnix6+po9FoNBqN5higRRg0Go1Go9FoNJo5yHgiDJK5EzluPG691eIXvxh7UrCPF7/Y5aUv9VBS8uS9N/Ddez7HLtqnJL6wmEr+7bJPs/a8l07+YI3mJMGywBBjO0F03f9CZCEKgGOMPvG6fLnkox8t0NBwfIxivbPPofe7PyL6pc9j/+P+YfvDokjSM8kVJV3OCEYBXpiXHaoYX4DBMik+6znkXv9GVG3tlOv7u99ZfPObzqwF+qyvV6xc6bNihaS2VmFZ0N0taGsTZDKCTAY8L5j0MU3I5SCXE0QiioqKwcuA8EIioSeENBqNRqPRaDQajUYzRcxxjHbngAiDfc/fiF37CfAmWRfLonD1S8i/4tWB08EpQDwOOdseXYRBHnsRBl8Z3J0+g9tSF/C39JkDO0wTFY+jHCfIOyEIhcYd5GhokDz3uT4bNvgsXSpL0U8r8KnA33DaCBXwMdrbMFqaMY4cKaWHA0EPJ4QqL0f09mIcOQxK4q9eS+HKF+CvWj2TH4PmOKEqqyhe8TyKVzwPslnsh0qCDA/cj8hmZ/x6juHx9uobuST+IJ9qfht7i/MndbzE4PbUudyeOpf5djOXJx7g3NgTrAvvwRYeAP6ixeTe+na8s88ZeqyEgwcFTzxh8tBDJg8/bOJ5M3Nf0ajiBS/wuPpqj5oaLb6g0Wg0monjmA7rqzewvnpD/7aufCcHevdzJHOEw5lDHEkf5kjmML3FXrJulqybwZUjCyeZwiAZKqMiVEFZqJyyUDlVkSoaY/OojzXSGG+kNlqHY84Bp1XNKYuqqMS97HLcyy4HpTAONWE/8hDWo49gPf7orLRDK61e3lz1G15f8TtuT5/Lz7uuYEdh8eROEgohk8lAvHAch/XZoL5ecfrpPs94hs/pp0uqq0/sduf4IgxMa8zF2LcX68nHAciYPtcv7ByhkIEcNB7yxvVvIWpHp3zNExnlOGObsE1RsM/Yv4/4+/8Do719/LJHDuPccnhC57X/eicxIPPBj444TmIcOQy5HKqmZvqCo0qB6yLSKcxDTRgHD2IeOhikTQcxjhya/JjcqY6A/KteR/FZz6F4+XMRnR0YbW2oRAIVjeLceTvW1i3geXjrN1B4/gsDI6Fxzyu0cZDmuFAZruL8eRdy/rwLAfClz/7evWzp2MK2zi1s7dxCU+oAUh3bd/e8+HzWV29gXam/MT++ADHkNzJDA2MajUaj0WhOWLQIg0aj0Wg0Go1GMwcZb5x7tpx6Z5onnjD42tcmZphwwQU+b31Ljgf/8j1ufPg7PC0nNmF0NCFl8voFL+FFr/oiljOBiQWN5iTGthXmOCIMvU9d1J8fzZBo0yafa68tjBfUctZR5RVkPvlZQr/7LZHvfGvIBHbICCIK1BVsDCXoCA2dANnQU8V7zGVAevh5Ewm8dRtwL3gm7nnno8rKp1zHQgG+8x2H3/9+Zodc1qyRnHuux8qVkpUrJcmTN+CmRqPRaDQajUaj0WhORMaLnCaPr5G1c8efif73tWNGixsJ99zzyf3rO5GN82apZnOTeFzRalmjOhak5LF1tng0u4bPtLyZQ7IxiKRaHwHTQtk22PakDcevucblDW9wJ+cPZJrIunpkXT2ctnFS19OcZESjuBdfinvxpVAsYj3+GM7f78a+795RI5ZOlbXhvfx44Yf5fudLuK7zBUgmH6Wyya3nR50v4kedLyIkiixOtjPv7AYSm5YS2yaQW4IxzY4OQUuLwd69glxuZp0xamoUL32pyxVXeMSOvYaLRqPRaE5SKsKVVIQrOZ1njFqm6BfJeVkMYWAKC8sIFkPoyM+aEwwhkPMXUJi/gMKLXgK+j7l9G/Zjj2A+vRlry9OITGbGLucYHs9L3suViXvZUVjErakL+XPv+XT6ZSOWV5Fw0FeLxQNRvGNIVZVi40a/tEjq609s0YWjMcYVYVDTcmwP/f7m/vzNDT30WiMEvCivoM9YZF58Ps9a+JwpX++Exx7bBk4Ui5M7XzZL9P++hXPL76dRqbGx/3onyaeeJPvv/4lcsBBZW4e1+QnCP/gu1panS4VsCle+gNwb3gyhEPY/7sN69GGEUngrVuFedPGASIPnIbq6MFqaMQ8ewHr8Eaynn8JobYGT6+c3+xhiYKzStik+69l4a9dj7tqJqqrCPeOsIeKeqrIKv7Kqf73wkpdTONZ11mhmENMwWVq+nKXly3nBshcCQfu9KX2Q/T37OJDaz4He/bRmW2jNttCZH0EoaBLE7BgLk4tYlFzM4uQSFiUXs6x8ORXhypm4HY1Go9FoNCcxWoRBo9FoNBqNRqOZg4xnM+odY7XXqdDUJPjEJ0ITElyfX9/C8oYP8ObP30qzGO4gPVHOsZbx9mu+Rd2SjVM+h0ZzMmHbYIwjwiDdASMI2xg+YdzYKPnUp46/AEM/QlB40UtwT9tI/OMfxjh8CICQGJjMrilalHsmWTNQrIn6Bitf+E+kPv1PGIcPIXp6EJkMKhJBzp8fGA3MgMr7ffeZfPvbDs3N0ztXKKSoq1Mkk4pVqyQXXeSzdu0Jor6j0Wg0Go1Go9FoNJpTEmWMM3BwHFVlnVtvIfqV/56UIbicN5/s2/9tWIT4U4VEQoE1uqNHrx8fusEQ+MtWBKIIlhU4Z7guIp1GpFMY6TTk82NfNBxGVtcga2qQVdX41bVsc5fxq6fW8ZcnG1ALrGlFUTVNWLvW5/Wvd9m4UY+zaGYIx8E7+5zgWfH//gPz6acCQYa/34PR3DwzlzA8/rX6F1wcf4jPtLyV3YUFUzuRYZCrbGRL+Tq27Ddg/4xUb0yWLZNcc43LRRf5xyMIskaj0Wg0OKYzqgi9RnNCY5r4a9fhr10XrEuJsW8v1tNPYW3bgrl7F+b+feBNL3KzELAqvJ9V4f28q/pnPJhdz629F3K/fza9ViUqGkXFYmAeu8be/PmSDRskGzb4bNggqatTJ3VAd3OMvjmAL0BIf2q+79kszl9uA0Ci+OX8ruFlhEBWVPSvvn7dP2OONwZ0EqOcsf8egwOJjIe55Wlin/s0xpGpBSmaDEZ7O/EP/ufoBVyX0O9+S+h3vx22y+H38NUvgmWiIlFEKjWLNT1x8BcvQTbOQyUSqEQCfIm5eyfmzh2IXG70A22b3Fv/lcLVLwWlMFqaEakUfkMjxOOjH6fRnCI4psPSsmUsLVs2bF/RL9KRa6cz30nWy5BxM2TdLBk3jVQSy7AwhYlZSstCZVSEK6kMV1IeqiBs6YBuGo1Go9Fopoae4hpEZ2cnjz76KE8//TRdXV309PSQyWSIxWKUlZVRUVHBunXr2LRpE5WVWu1Ko9FoNBqNRjN7GONMEMpJRmw7ligp6e2VfOiDUXp7JIFehEIpBShQCtfN4xaz5IoZpNOEPPsNXN/ezqih1cahQoV5++n/xoXPfw9ivKh7Gs0phG2DOYlILiMZIb35zS7OHLRNkkuWkvrmd4he+0nshx4kbAzVd7eloEyWJv9DIQpGBIwCcv4CmD9FQ+XR6iLhG99w+P3vpz7MEo0qnvlMn0su8TjtNDknP3ONRqPRaDQajUaj0WhGZTz1RkXQgT7GY3ehm39D5Btfm/gBpkH+1a8n/8rXcCp3zuNxhbKtUYdrU34plL0hKLzsFeRe808QjY59UtdFZNIlYYZAnAHDQFZWIatrIBYDIXBd+MtfLH7xC4tDh0rflykGUq2vV7zkJS5nn+1TW6uwx/GV0GimhWHgbziN3IbTyL3tHZh7dmHfew/23+/G3Lt32qdfG97LTxZ+iN/0PIvvdryM3r7f4XhYJrK8ElVWNv6zeoY4+2yfl7/c5fTT5UntEKfRaDQajUYzZzAM5NJlFJcuo3jVi4JtnodxYD/Wnl0YTU0YLc0Yra0Yrc0Yba3gjyNOZwhUWTl+QyOyoRF/8RI2rFzF2pWr8KMJdu40eOQRg0ceETz9NBMK0DJZkknFsmWS5csla9ZI1q/3GaQHcEpgjCNw4Qs1ZbEN5/Y/9TuL31uV5kh4uICASiT7RTYWJhdxyYJnTelaJw3jiGKIYmHM/X3Yf7uL2Oc+Bd4s/HBmC88/dQQYQiEoDPpbCsAJ4S9egrvpTAovegmqqmrkY6XE2L8vEDBZuAjj8CGcu/+KcagJWVdP4Yrno2prS+cVyPoGqG+Y7TvSaE4KHNOhId5IQ7zxeFdFo9FoNBrNKcYpL8JQLBa5+eabuf7669mxY8eEj1u1ahWve93ruOqqq3BOYeMLjUaj0Wg0Gs3sMJ4Igz9VtYJpIH2P3Y/9iS3bbudAxy6ackdo93pIUyCHhydkyZZacPCvXybbcua45xRmnkUX/zt2tH3K9boqcS7//Lr/JVahJyQ0mqOxbYUhJm5YaxvDJ4w3bpy7k74qniDz6c8T/uF3CX+tOGo5WVExbrDFqeK68LnPOdx999SGWM45x+fyyz3OO88nNEWHAo1Go9FoNBqNRqPRaI47ExFXOMYiDPbPf4r97W9NuLycv4DMBz6Cv3LVLNbqxCCRABWJjLo/JQPBhez/ey/F571gYie1bVR5Bap8ZI+ZbBb+9CeLX/3KprV1+uPf55/v8773FXQQQc3xQQj8ZSvwl60g/09vxDjUhP33e7D/fg/WlqenfFpTSF5e/heenbif/2t/GTf1XIZk5OeqikZRZWWoeIJjoYRg23DZZR4ve5nL4sVzV0hco9FoNBqN5pTBsvqFGYYhJRSLiEIe8gVEMViUZUMohIrFULH4qH14A1i1SrJqleTVr/YoFGDvXoOdOw327xccPmxw+LCgq0uQzY7eFhUiEAGsrQ2WujpJba1iwYJAfKG6Wp3yol7mCIE0BjNlEQalCP3+5v7VGxd0jVhMlpf351+z5nUYkwgCcjKixjPqcMf/W1gPPkDss58cXwhFMy1UPI574UV4p29E1tWD62JteRpz9y5EZ0fwnEuWocrLkeUV+EuX4218RiDKqhQinUKZVrBumhPvVxsGcsnS/lU5fwH5V79ulu5So9FoNBqNRqPRHAtOaRGGO++8k4985CN0dnaWovJOnG3btvHhD3+Yr3zlK3zqU5/i0ksvnaVaajQajUaj0WhORcazRZ5s+3WqKCnZ+sCvufUf3+OBzBZ6xVFOziPML7Q+/o4JCTCAovH8TxCu2Dmlui2jinddfi2rz7l6SsdrNKcClgXmBJ0bbMMaNmEejaq5b6huGOTf9DbElv3wGyMwGBmESpahEkkKhZl/bhaL8PGPh3jooclHkJs3T/Ke9xQ5/XQ9sa7RaDQajUaj0Wg0mpOAiURX9/1gsGK2UQr7uh/j/OB7THQ0wL3kMjLveR9Eo7NatROFeFxBOBIYmheHC1+mZIzCy18xcQGGMejoENx0k8Uf/mCRTk/fu2bZMskrXuFyySX+Ke+so5k7yHnzKVzzKgrXvArR1Yn15BNYm5/EeuoJzD27mfDDqkS5meY/637E1eV38u32V3B/5nQQoMIRVDyBiscDVYRjQG2t4qqrXK680qOs7JhcUqPRaDQajUYzXQwDwmFUOAxlk26ODiMUgtWrJatXD5/7LhYD0b1CQeB5QTczHFaEQkGTVffbxsY0x27X+4DwJy/CYO7cgblvLwA7Y3keKc8OLxSOBAtQHanmovnaV2K8cS3hjh48BMB8ajPxT3xYCzDMJKEQ/qLF+CtWosJhRD6Pt2YdxQsvglhsSFFv00TsGQEhUInkLFRWo9FoNBqNRqPRnIickiIMSik+85nPcMMNNwxxXhOTGMlRSqGUor29nbe//e285jWv4cMf/vBsVFej0Wg0Go1GcwoyXtNUzrIGg5KSv//xq/z8ie+zi/ZSpcY/rnf/5XRtf+WErlGz8dsk5t8z6bpVqQhvWPNGLrv6gxjmKdml0WgmjG2DKSYmEGAbwyMoNDScOJElrLXL8R8TGF1dgSWHEKhEIoj0BhSLM/vgVAq++EVn0gIMa9dKrrzS5bLLfJyxg1ZoNBqNRqPRaDQajUZzwqCMCYowHAOcH3wP+7ofT7h8/p/eSP41r9eeH4NIJIJxFL9xHmbTwWFRNXtql5N787nTukZLi+D6621uv92aUtDOwQgBl1/u8YY3uNTUHBsBY41mqqiKStyLL8W9OHBgEukU5ratmHv3YO7dg3H4EEZLM0Znx6iTQSoSQdbXs2ThYj67qJ3NsRQ/eWgDDzwS4lhoeBsGbNrk88IXepxzjj+usLhGo9FoNBqN5tTFcSjNi+u+2lQwrbFFGKRQKHfynWrnL3/qz/96XvfI5y4v789ftexqLEPbaKnxjDxGELLsQ3R2EP/Yh8YsoyFQdSkUAFDJJP7iJci6elQyEEXwVq3BPe+C4MGSywXpMRIh1Gg0Go1Go9FoNKcmp2Rv+Nprr+X6668HhgsvTDSi8ODjlFLccMMNGIbBBz/4wZmrqEaj0Wg0Go3mlGU8gTBvFucmD2y5h2/d/B4elwcndVy+azlHHvjAhMqWLb2FytU/ndT5w8rilQ3P50XXfI5IonJSx2o0pyq2DcYERRgcc/hkcX39iWMIEQ4DpoWsrhlxfz4/s9f70Y9s7rpr4sMq0aji/e8vct55x8bhRKPRaDQajUaj0Wg0mmOKOb4HrpD+rLtcWDffNCkBhtxb/5XCyycmKnsqEY+XMo6Dv2gxIp1C5HJgWahYjJ6KCBi5SZ83lYLHHzd56CGTv/xl+uILACtXSt7yliIbN+ookpoTExVP4J15Nt6ZZw/dISVksxiZdJAXAmVaqLIyjlZ3XQF86iU+R47k+N3vLP7yF4uenpkVlhECNmzwueQSnwsv9KiomNHTazQajUaj0Wg0mhEwzPGdy6XvTu6knodz5+0AFAzJX+pSw8uYJioRBLywDZvnL71qctc4WbHHFmEQ7uh/i+j/fBXR2zPhS/mrVpN741uQtXVYT21GdHdh9PZgHDqEuX8fxpFDQ4T73Asvwp83j/CNP5vwNY43/uIleJvOxF+6DH/+AuT8+aiycnDdYIlGxz5BLHZM6qnRaDQajUaj0WhObU45EYYbb7yR6667bpiIAsCKFSt47nOfy4YNG1i+fDllZWVEIhFyuRy9vb3s2rWLzZs3c9ttt7Fz587+cwghUEpx3XXXsXz5cq655prjcm8ajUaj0Wg0mpOH8WyWRwl+NC2UlPz+p+/j//b/FI/JGaz6hQSH7vksyg+NWzZS+zj1Z35hwoHlwsriBZXP5MUv/ARV81dNql4azamOZSnMaYkwnDjG644z9oOxWJw5o+Pbbzf56U8nrqS/bJnkgx8ssHDhiSNqodFoNBqNRqPRaDQazaSYSBh0ObvjDNajDxP62pcnXD77rndTfOGLZ7FGJy7x+KAxDNNElZUHRvAl8nnwPLAmYHGSTsP995vcdZfFI4+YM/I1sCy48kqP5z3PZdkyNeGxZo3mhMIwIB5H9quijE9Dg+Jtb3N585tdnnjC4O67LR591ODIkQk8o0cgkVCcfrpk40af88/3qanR45sajUaj0Wg0Gs2xZEIiDF6RybT47Yce6BcDuLs6TcYcHkhCJZIggrM+a9GzKQuVT+IKJy/KGefvUSyOuNm+52/Y9949oWt46zeQ+5d34q9aPXDa+QuGF3RdjENNCN9DJstRNTWgFCpZRuR7/8usK6FOAFldjZy/EH/+fOT8Bch585GJJIRDyNq64Hs2ErYdLBqNRqPRaDQajUYzBzilRBjS6TRf/epXhwkwrFy5ko985COcddZZIx4Xj8eJx+M0NjZy0UUX8Y53vIOHH36YT33qU2zfvh0hRL8Qw1e+8hWe97znEZ/EJKhGo9FoNBqNRnM04xmNqhmeKCnm0nzjf1/Gn7OPTfpYpQSH7/sEbqZh3LJ2/DDzLvwQwhw/xFmtivH8xmdz5VUfJFmzaNL10mg0wZykMUERBtsYLsLQ0DAHZmUnSDg89v5CYWau09Qk+OpXx45u0Ec0qnjzm12e/3xvQr4oGo1Go9FoNBqNRqPRnLBMxBvfH27UP1MYh5qIfepjExN6EJD99/+ieMXzZq0+JzqJxPhjQqkUVFSMvM/zAuGFO+6wePBBkzECQU6a5csl73tfgaVLT5xxK43mWGOasGmTZNOmwAGotVWwfbvBgQMGBw8KOjsFqZQglwse35YViK/U1ChqaxVLlkiWL5c0Nio9rqnRaDQajUaj0RxHTGt8R3TPLTAxC4YA58+39edvqe8ZsYxMDjjHX738JZM4+0mOPfYnLdzhIgwi1Uv0f74yodPnX/Va8v/8pomJndo2cvGSoy4mKFzzKtyzz8X5212Yu3ZgHjiA0Xx4diI+ASpZhrdqFd7GTch581G2g6qqxG+YB9HorFxTo9FoNBqNRqPRaI4lp5QIw49+9CO6urr6BROEELzwhS/ks5/9LKY5MaeUPs4880x+85vf8KEPfYibbrqpX9ihu7ubH/3oR7zzne+cjVvQaDQajUaj0ZwimOOIMPgzOC+S7mrhY/97BU/Lw1M6vn3zm8k0nz1uOWHlmP/M/8IKjTyBBxBTNudG13LJaS/jjEvfiGGeUl0WjWbGsW0wJyjC4JjDJ4vr608cY3bHGbuu+fz0QyJ6HnzucyEKhfHPVVam+Pzn8yxbduJ8hhqNRqPRaDQajUaj0UwVJSZgHO5PQCBhKvg+sc9+CpFOw3hddkOQ+a8P4V727Nmpy0nCRGJOpNOCioqh4x6HDgluvdXiT3+y6O6e/lhMH2Vligsu8LnwQo8zz5TjihhrNP+fvTuPr6us8wf+PffeLE2TNkn3HVqgLGWngIKCuKK44sKM4jiLjjjg+JPfjArjOMowOgsqOs6Mo46j/hgX3BdcEAVHUEBWWYW2UARali7QLcu95/dH2tA0N/fcJDdNk/t+v16Ve855znO+gSaenPM8n4eBZs9OY/bsYkSMXRgOAABQe9WEMBSL1ScfJk8/FQ2/vi4iIh5r7IkbOrYNbtTY2L8KxrL2A2JZ+4FV9z/ZpY0ZcRdlUiibL/tiJBs3Zvbd9bo3xI4//rPslZuqUNpv/9ixe0BDT0/kHnk48o88HMkTT0Ruw5ORNjVF72GHRzQ1RdN3vxX5tQ9GdHdHRBrp9PboOeFZUTzgwCj85sbIbdoYaWtrlNo7Iu3sjFLnjL4/s+cIWgAAACa9uprR9OMf/3hAAMMpp5wS//RP/zTi/vL5fHzkIx+JTZs2xdVXX93f949//GMhDAAAjEqSq/xCpVbDlXds2RQf/I/TRxzAsHX9MfHknW+uqu28E/4hmtrXDNg3LW2MAwvz4rCZh8dhB50ah55wZjQ0eTkDtdLQEP2hgVkKucGPCObOHaPJEWOgqany8Z6evsUwR7Ny22WXNcS992Z3MH16Gh/72I5YtEgAAwAAAHWimkUPimMz+bf5y/8v8vfek92wkI+tF3wgep5zypjUMZm0tWU/03j66SQi0ujujrj22nxccUUhbr11eItfZJk5M42zzuqJ00/vjax5DgAAADDZ5MosprGnUpmJ/0NpuO7avtUnIuJHc5+KUjL49//StOmxK+XyRfu9pOq+60JD5f8eyR7/LZKnn4qmH3wvs9uek54T2996Tk0CGMpqaIjSkv2itGS/soe3/d/3Dnlq7xFHjU1NAAAAE0TdhDCsX78+7rvvvv7JJ42NjfHBD36wJn1/8IMfjBe96EXR3d0dERH3339/rF+/PubMmVOT/gEAqD8ZGQxRrMG83u7tW+LiT70kflt6eNjnzk6nxn5xWPz8po/GrMYZkcvlI0mSSCLZ+R4u2fleqO8LecFz74lXvfTFkcu9NJIkiZaWzpi73xHRNnPR6L8QYEi5XPWhA0mZpSLnzp04IQI7F2KoqLu7unblrFqVxP/8T/YqEw0NER/6UJcABgAAAOpLFSEMSVqKWv+2nP/dvdH8//47u2ESsfVvPhg9Jz2nxhVMTtWEMDz5ZBJf+lJDfPvbhXjqqdpOEli2rBSvfW1PnHJKMRqyH8cAAADApJQvZP9SXCoNI4Thl7/o//zDOU+VbZO2Teu7dpKL0xa9oOq+60HamPHfo7trwGbTd74VsWNH5T7b2mLbO//P2AUwAAAAMCp1E8Jw11139X9OkiROPvnkmoUkzJkzJ57znOfET3/60wHXE8IAAMBI5TJSGErpKJZy3+nfP/2GuLF3TdXtp6WNcfrM58Tzn3tOLFx+Unzg76ZEc0s+mlsqn3fMMcX4uw8fG7ncsaOsGBiJwgh/8+/sTKOpqba1jKXGxuzJAV1dIwthKJUiLr20KUql7LbveU9XHHpoFQ0BAABgMqkihGHXSos1UyxGy798OKKY/Xv49re9QwDDMEydmt3mQx+q/YOjY48txutf3xNHH10y9wAAAIC6l2/I/t272NtdXWfbtkXDTTdGRMSalq5YM7VrUJN0SkvsSkM8ft6zor25o/pi60FDY8XDSc9uz7527Iimb30js8vtb/+LSDtnjLYyAAAAxkjdhDA8+eSTERGRpmkkSRIrV66saf/HHXfcgBCGXdcDAICRyFq5Po3RTfD92bf+Pn649TfV1RJJvHL6c+JNb/xETO2YFxERV16Zj1//Ontg9dy5aVx4YVfm1wOMncbGNFobWmNLz5Yh28xoHvxCd+7cWq9NObaqCYzYsSOJ6dOH/3X96EeFuPvu7B9kr3hFb5xySnHY/QMAAMCElxEqGxFRVbrhMDRe8f3Ir8kOme1+yUuj68zX1/Tak10uFzF1ahpbt+6dJIQjjijGn/xJTxx2mGBLAAAA2CWXK0QkSUQ69DiHYm9PVX013PDriJ6+ttfMKj9+JG1r6//84v1OH0al9SHdGVAxpJ5nAjGafnxFJE9trti8eMih0f3Cl9SiNAAAAMZI3YQwbNiwYcD27Nmza9r/rv6SncsxbNy4sab9AwBQX5KMZb5K6chTDdbe9b/xiTv/PaKK8bPT0qZ4/6kficNP/sP+fU88kcS//VvlZO+IiEIh4gMf2BHTpo24VKAGCoWIloapFUMY2hrbBu2bN29iDXpvbs4OV+iucgGI3W3eHPHZz2a8SI+IRYtK8da3juACAAAAMAmkuezA1ijWMLhwy5aY8oX/ymxWWrQ4tp37rr4JCwxLa2vE1q1j03cuF3HwwaU48shinHRSMQ46qOQ/EQAAAOwhn2Q/bykVqwthaPzlL/o/Xz3z6bJt0tbWiIhobWiN4+eeWFW/daWx8ni5ZNeglFIpmr7xtczudpz1Rs+sAAAA9nF1E8LQtMeSmDt27Khp/11dXRERkaZpJEkSDVlJhwAAUEEuY+W4UjqyFzA9Xdviw996W+xIejPbLkynxcVvvDzm7H9U/740jbj00sbYsiX7+n/+591xwAHDX3EeqK2GhojpjdPj6e6nYnvv9kHH25vaozHfNGj/3LkT6/u3afCXMMjOX92H5bOfbYynn678My+Xi3jve7ujuXn4/QMAAMCkkM+eFJCUahfCMOXLX4pk86bKjXK52PqeC6t7aMAgra1prF9fu4kASRJx+OHFOPXUYpx8cm90dNSsawAAAJiU8rlc3y/U6dDjN4q9VYQwdHdHw/W/ioiIdU09cU/b4HkU6ZQpEYW++Q8nzH9WNOTNhdhTmjU/pKfvv0X+rjsj9+ijFZuWFi+JnhOfXavSAAAAGCN1E8LQ2dkZEc+sKPzwww/XtP89+5sxY0ZN+wcAoL7kc5WPj3S48ne+8texJjZktpuTtsY/nP2tmL1kxYD9v/hFPn796+wB1SeeWIxXvjI76AEYe4VCGkmSi/mtC2LD9idjU9emSCONhlwhpjd1REdz+RHvc+eW9nKlo5Ox4EBERHR1JRFRfbjEnXfm4kc/yn50cuaZPXHQQRPr3xcAAADUVBUhDFGsze/OuXWPRtM3v57ZrufsP4ri8oNrcs161Npam4DOBQtKcfrpvXHaacWYNWtihX4CAADAeMonhYjIWMinmB3C0HDTjRE7F7C8etbTZdukra39n5+z4JTqi6wnDZUHpiTd3RER0fjzqzK72vG6s/pW/AAAAGCfVjchDLNnz+7/nKZp/PznP4/zzjuvZv3/7Gc/iyRJIt2ZNDlr1qya9Q0AQP3ZFR42lFLGC7ZyHnvwjvh/D30r691ctKWN8eHX/8+gAIbt2yM+/ensWc7t7Wn83//bFRlfArCX7AonyCf5mNUyO2a1zO773TWJSCr8QJg/f2INim9uzq63q6v6/orFiE98Ivtn3syZabzpTVWsLAEAAACTWTWDxku1CWFo+ur/RPRWDoBN58yN7jeeXZPr1au2tpGf29AQ8dzn9sZLX9obhx9e8qwYAAAARiCfy2eO8yr2dmf203D9r/o/XzNzS9k2aWvfg4DGfGMcO2dl9UXWk8aGysd7uiOKxWj8xc8rNks7O6P7+S+sYWEAAACMlboJYTjyyCOjsbExenr6Jkbcfffdce2118ZJJ5006r5/9atfxV133dU/Ua6xsTGOOuqoUfcLAED9yucyQhjSiLRUimQYidifvfy82JFUHpwcEfFXJ1wY8w86YdD+r361IR5/PHu07F/+ZXdMn151WcAYK5T5zT8r6CUiYs6ciRXC0NSU3aarq/oR/9/+diFWr87+GfuOd3RHS0vV3QIAAMCklOby2Y2KxVFfJ3n88Wj60RWZ7br//O19yZTdo79mvWptHf6zoUWLSnHGGb3xwhf2jirEAQAAAOhbbCMr2bBYylg0Ik2jcOP1ERGxsaE3bpu+fXCbpuaIhr5FKo6fe2I0F5pHVO9klzZkLORRLEXh5t9EsmlTxWbdz3t+X4IlAAAA+7zqZ2xNcM3NzbFy5cpI0zSSJIk0TeP9739/PPbYY6Pq9/HHH4/3v//9/X0mSRLHHXdcNDd7+AAAwMjlMsMVkkjT6leOu+0XX4pfdN2V2e71nafF8S98+6D9jz6axNe+lv3y59RTe+Pkkw1shn1JuRCGLLlcxKxZEyuEoTHjXXdExI4d1fX1+ONJfOEL2T/zVq4s+pkHAAAAERH57BCGpDT636Gbv/7ViN7KQbOlw1ZE7/OeP+pr1bu2tuqfDU2ZksY73tEdn/3sjnjNawQwAAAAQC3kklxEZCzkk/GcJLf2wcjtnC/x686tUUoG/76ftrb2fz5pwcnDL7ReVBGc0HjljzPbdD/vBbWoBgAAgL2gbkIYIiJe+9rX9n9OkiQeeeSReNOb3hT33nvviPr73e9+F29605vi97///YD9r3vd60ZVJwAA5HIZq7Wnuejtrm42cVoqxRev/Whmu/2iI87+k8+VPfa5zzVET0Zw+rRpaZx7bndVNQF7T2Pj8MMUOjvTyMyC2cckSXYQQ3eVP6L+8z8bYvv2yj+HGxoi/uIvurMWnQAAAID6kPU8MyKiVH2obDnJxg3R9P3vZLbrOucvMleJJFtra3XPlA46qBT/+Z874tWv7p1wz5MAAABgX5ZPClkZDFEsVh7Q1fCbG/o/X9+5rWybUsvUndfLxYnznj28IutIWsXqII0/v6ri8dK8+VE8aHmtSgIAAGCM1dUr8NNPPz1WrFjRv50kSaxduzbOPPPM+Pu///tYtWpVVf2sWrUq/v7v/z5e85rXxNq1ayNJkkjTNJIkiRUrVsRLXvKSsfoSAACoE9khDEkUe6ubTXzHdV+JO0uPZLb7i1P+NhqaWgbtX706iWuuKWSe/8d/3BPTp1dVErAXFbK/fQeZNWv4wQ37gqamynV3dWVPwLjpplxcfXX2v7SzzuqJBQsm5r8nAAAAqLlqHkAUi6O6RNO3v5mZsFg89rgorTh8VNehT2dn9nOPQw8txcc+tiPmzvWMBAAAAGotn8tlBk0WS70VjzfceH1ERJQijRs6tpa5SD5iSnNERBwx66hobWwbWbH1oKFh1F10n3qa8FAAAIAJZARTMSa2D33oQ/HGN74xduzoWzU4SZLo7e2Nyy67LC677LJYunRprFixIpYtWxZtbW0xZcqU2L59ezz99NOxatWquOOOO2L16tUREf3BC7tMmTIlPvShD43L1wUAwOSSy1d+2ZJGEqXerqr6+p9ffiyzzWlTjojDT/7Dsse++MXsFO8DDijFS19a+aUeMD5G8g545szRrUw5XpqaIp5+eujjOx8FDGnLloiPf7wp8zrz5pXirLMqryYBAAAA9SRNqlj/YTQhDL290fTD72c26z77j0Z+DQY48sjKz4fa29P4wAd2RBWLQAIAAAAjkE/yEZERwtBbYexCV1cUbr8tIiLub+2KDY2Dx3alLVP7r3HsnJUjLbUupA2jfwjS/bzn16ASAAAA9pa6C2E49NBD49JLL413vOMdUdw5yCNJkkjTvpUZVq1a1R+yUM6udrvO27WvUCjExz/+8TjkkEPGsHoAAOpFPpcxaDnNRbG38qpvERF3//qbcUtxbcU2TWk+/vT1/1r22H335eLaa/OZ1/mLv+iOrJKB8VHNQpR7mjlzYq5e2NSURqUBCN3dQx9L04hLLmmKdeuyVxw499xuEwwAAABgd/nsZ4hRHHnoY8Ovr4tk48aKbXoPWxGlI48a8TUYaN68NE49tTeuvnrww6V8PuJ97+uKzs5xKAwAAADqRD7JRyQZIQyloRfNKdx2a0RPX0jD9R1by7ZJp07t/3zcXCEMFTWOYBWU3RSX7Bel/ZfWqBgAAAD2hrqcJvXc5z43PvvZz8bs2bP7QxWSJOn/k6bpkH92bxfRF8AwZ86c+NznPhfPfe5zx/PLAgBgEsnlsiYBJ5WTzHf66i8uyWzz8s7nxoyFy8se++IXs18enXJKb6xYMfIB1MDYamwcfqDCRA1haG6ufLyra+hj3/1uIX75y+wJI895Tm8cf7yfeQAAADBAFSEMSTry36cbr/heZpsdf/jmzIkJDM+7390dp546cDLHtGlpXHzxjjjmGM9HAAAAYCzlknyldSgiIqJUGnr8WMNvbuj/fEPntrJt0pa+EIb2pvbYf/qy4RdZR9KG0a3W0Xv8CTWqBAAAgL1lBOthTg4nnnhifOc734lLLrkkvvvd70bXzpkYuwcsDGVXcENTU1O88pWvjPPPPz+mT58+5jUDAFA/crnKg5bTNJcZwvDYA7fH9T2rKrZpTPPx6ld8sOyxBx5I4te/rlxHkkScfXZ2GAQwfqpZiHJPs2ZNzBCGpqbKx4cKYbj55lz8+79nvyxvbk7jnHP8zAMAAIBBqnkA0Tv0yoyV5NY9OmDSQDml+Quid+XxMbqh8OxpypSICy/sjje/uSd+//tcNDWlccQRpSjU7UgTAAAA2HvyuXykSVIxh6FYLA55rHDzbyIiYkeuFLdN3z64QVNz7Pol/9i5KyOX1OX6ntVrHN2Tp56jjq1RIQAAAOwtdf1qvL29PS666KJ497vfHZdffnlcd911cdttt8X27WUeMuzU0tISRxxxRJx88slx5plnRkdHx16sGACAepHLZ8SYp7ko9lZY0j0irrzy45FG5YnUp08/MWYsXF722Le/3VC5hog47bTeWLJkYk7WhnoxknfAM2dOzO/rxsbKdXd1Df7Zunp1Eh/8YFNUGJfQ781v7pmwARUAAAAwpnJVDNIvlUbUdeMPfxAZjzmj66Vn9CXGMiYWLUpj0aIqHp4AAAAANZNP8hEVIxgiSsXyC0kkmzZG/sEHIiLi1vbt0Z0b/FwmndrS//m4OStHXGe9SBtGEcKQz0Xv4UfUrhgAAAD2iroOYdilo6Mj3va2t8Xb3va2KJVKsWbNmti4cWNs3rw5tm7dGlOnTo3p06dHR0dH7L///pGrZgAJAACMQj6ffc851Eu0iIhiT3f8aP3PK76Hy0cSZ77iQ2WPPf10xJVXVv51IZeLeNObrAgP+7qRrEw4UYMGmpsrH+/aI7tm48aIv/mb5ti2LXuSxlFHFePMM0e2YicAAABMekkSkUsiShWeKVSTgLinNI3Gn/ywcptCPrpf9JLh9w0AAACwD8sluczQyVKp/DiGwm9v7/98Y8fWsm3Slqn9n4+efdwIKqwzjdkLGg2l95DDIqZMqWExAAAA7A1CGPaQy+Vi2bJl410GAAB1LslatS3NRbF36ACEm67+r3g82Vaxi5ObDonZS1aUPfaDHxSiu7tyCc97Xm8sXDgxJ2pDPWloGP73aWfnxPzebmysXHdX1zM/W0uliH/6p6Z4/PHsAIb29jTe976uqhb1BAAAgLqVy0WUhg5aSCocG0p+9f2Re+KJim16nv2cSDs6h903AAAAwL4sl+QiF0lUGglRLGaHMNw6ffvgBkkSaXNfKMDS6UtjxpQZoym1LqQNjSM+t/foY2tYCQAAAHuL6QMAALAPyucr36qnGSEMP7rlssxrnL7yj8vuLxYjvvvd7OTu17526OsD+46GYQbxt7en0Tjy98bjqqmp8vGurmc+X355IX7zm3xmn0kS8b73dUWnuRwAAABQWS7j9+xiadhdFm68IbNN18tePux+AQAAACaCfFJ5DFmxVH78VuH2WyIiYkeuFPe07Rh0PG1ujl0rURw1W0BAVUYxmKb36GNqWAgAAAB7ixAGAADYB+UL2bfqpSFeom189P74dc99Fc+dl7bFESf/Ydljv/51PnNl+MMPL8YBB1RecR7YNxQKw2s/c+bE/d6uNoThrrty8fnPV/dy/E//tDuOOWb4k0QAAACg3qT5jBCG0vB/v2648frK12xvj96jDGIHAAAAJqd8xnSP3lJx0L7k6aciv3pVRETcOW1HFJMy40CmtPR/PGLWkaMrsl7kchG5ymPqympqit6DD619PQAAAIw5IQwAALAPymWtGpcm0dvTXfbQr3/x31GKypOoX7rghZHLl5+Z/ZOfZM/YfvWrezPbAPuGxsbhhSpM7BCGyrV3dSXx9NMR//APTVEcPA5hkJe/vDde/3o/7wAAAKAqWSEM1fwyvrutW6Nw528rNuk57vj+VRsBAAAAJptcUvm5R1oaPKahcOcdsWvo2G3Tt5U/b8qU/s+HzVgx8gLrTWPG6iBl9B5+RERDwxgUAwAAwFgzGgEAAPZBuXzGC7TIRanYU/bYtQ9cWbnvSOK0F76r7LGnnoq44YbKg6XnzEnj2c8e5oBpYNxkzX/Y06xZEzmEofLxHTsiPvrRpli/PntlgpUri/EXf9EdyQgWMQAAAIC6lBWGUGZlxkoabr05oliq2KZn5QnD6hMAAABgIslnTPcoFsuEMNx+a//n26ZvH3xSkvSHMCxqWxztzR2jqrGepCMIU+g9/MgxqAQAAIC9IXuJWwAAYK/LZw1YTpOyL9G2PPlw3NL7YMVTVxaWxoyFy8seu/rqQvRmLPp+xhk9w57UDYyfxsbhtZ85s/Lkhn1ZU1PlAIkHH8zFg5V/REZEXxDF+97X5WcdAAAADEfGM82kOMwQhhuvr9wgieg9buWw+gQAAACYSPJJRghDOvh5S+G2W/uORRq/LRfC0NQUkesbELFi5uGjrrGujCSE4YCDxqAQAAAA9oYJH8LwyCOPlN0/f/78qtuOhXLXBwCAauXyWSEMuSiVegbtvvF/vxDFqDwJ+TkHvGTIY1deWflXhCSJeP7zhzdYGhhfhWH+5j9rVuWfIfuypqbR95HLRVx4YVe0tY2+LwAAAKgrWWmGpWEEP6ZpFDJCGIrLD4l02vTq+wQAAACYYPJJ5ectxdIeq+1s3x75+38XERH3tXbFtvzg5zHplJb+z4fPPGL0RdaRtLExkmGeUzxICAMAAMBENeFDGE477bRIkoG/yiZJEnfddVdVbcfCUNcHAIBqFQpZy68nUSwODmH45X0/qnhWLpI4/rl/VPbYQw8lcc89lcMfjj66OKEnaEM9amgY3vfsjBkT93u8FiEMb3lLdxx22DAmhQAAAAAREZHmcpUHoff2Vjo6QG7tg5F77LGKbXpWnlB1fwAAAAATUT6pPJarmA5cTKdw370Rpb5xH7e2byt7zu4hDCuEMAxPQ+OwmpdmzYq0vWOMigEAAGCsTfgQhoiINK1+gshw2gIAwHhJslaNS5Po7R0YwrDtqSfixq77o9JI5yPzi2LarCVlj115ZfavBy98YfUDpYF9Q0PD8NpP5KCV5ubR1X7MMcV4wxv8nAMAAIARyXymWf3v7YXbb8ts03Pc8VX3BwAAADAR5ZLKz1uKpYEhDPm7n1lI8rbp28uek06ZEhERnc2dMXfqvFFWWF/SxuENwikeuHyMKgEAAGBvmBQhDEnyzCyzrJCF3duOBSEPAADUQj5fOcU8jVyUSt0D9t127f9Ed1Ic4ow+Jy95/pDHrruu8ku75uY0Tjqpcv/Avme4IQwzZkzc32sbh7fgwAAdHWm8971dkav84xcAAAAYSq7y88WkWP2zxcKdt1c8nra1RfHgQ6ruDwAAAGAiymeEMKR7hDAUdgthuHPajsEnNDb2B2kePvPIMZ9bMek0DG9gSvEgIQwAAAAT2aQIYRhO8IGQBAAAJoJ8IWvVuCRKxZ4Bu26+76rMfk84+Y/K7n/44SQefLDyzOPnPKcYO4PQgQlkOCEMra1ptLSMXS1jralpZOflchHvfW9XdHTUth4AAACoK/mMZ5rDCmG4o+Lx3hVHhCRFAAAAYLLLJ5Wff/SmvQO2C/f0hTA82dgbjzX1DGqfNjf3fz5s5ooaVFhf0mGuDtJ7oBAGAACAiWzChzB8+MMfHpO2AAAwnnJZA5bTXBSLA1+i3fLUXREVwskPTebGzEXlV4e77rqM60XE857Xm9kG2PcUCtWHEc6YMbGDC5ubR1b/n/1ZdxxzTKnG1QAAAEB9SbNCEUrV/e6dPP545Natq9imd8Xh1ZYFAAAAMGHlk8pjuoqlZ0Ivk8cfj+TJJyMi4u62HWXbp83PrMBzyIzDalBhnRnOSigRUTzwwDEqBAAAgL1hwocwvPrVrx6TtgAAMJ7y+coDltNIBoQwPPbgHfH75KmK5xw/54Qhj/3qV5Vf2LW0pHHUUSYow0Q0nPe/s2dP7BCGYS44EBERL3pRb7z2tUJmAAAAYNQKGUGvxWLl47u6ueP2zDa9hwlhAAAAACa/XFYIQ/rM85bCPXf1f75nyBCG5oiIyCe5WDp9WQ0qrC9pQ/UDU0ozZ0ba0TmG1QAAADDWMpaiAAAAxkMuF5FUapAmUSx292/ecfO3M/s84tAXl92/eXPEnXdWfmF3/PHF4QZ5A/uIwjDiF2fNmtghDE1Nw6v/0ENL8Zd/2R1JxR+4AAAAQFWSysMPklKVIQx33lG5QUNDFA88qNqqAAAAACasQq7ymK5SqXwIw93lQhiSJKKpKSIi9pu+NBrzI1jpot4NYwBd8QDPrwAAACY6IQwAADARpbko7vYS7dYHflmxeXNaiAOPOb3sseuvz0epVPlyz3pWdQOkgX3PcAJUJnoIw9y5aeSqfNIxe3Yaf/d3O6LRmAIAAACojXzlSQFRrDKE4Y7bKx7vPeTQ8As9AAAAUA/ySeXnLcX0mect+XvujoiINNKyIQxpc3N/iObBnYfUsMr6kQ7jmVTxoOVjWAkAAAB7gxAGAADYB+VyEUkMvTR7GrnoLXb3fS6V4pat91bs74iGxdHQ1FL22HXXFSqem89HHH+8EAaYqBoaqg9WmDUrI5FlH9fSErFiRfbPq6amND70oR3R0bEXigIAAIA6kWaFMJSqeEaxdWvk16yq2KT30BXDqAoAAABg4kqqDWEoFqNw7z0REfFYU29saOwd3Lh5Sv/HAzsEBIzIMFZCKR5w4BgWAgAAwN4ghAEAAPZBydD5C33SJEqlvpdlj95/YzyebKvY/Kh5K8vu7+2NuPnmyr8WHHFEMVpbM+oB9lnDeP8bs2dXH9iwr/o//6c7pkwZ+utoaUnj7/6uK5Ytm/hfKwAAAOxTskIYitnBiYW778wMa+hdccRwqgIAAACYsPK5ys9bSjtDGPIPrI7o6oqIiLvbdpRtmzY3939e3nFwjSqsL2lDY9VtiwsXjWElAAAA7A2Vl7ydZN73vvf1f54/f36cd955Nev7k5/8ZDzyyCMREZEkSfzDP/xDzfoGAKD+JEkalXMYkijuDGG47ZbvZfZ3+GEvKbv/3ntzsX175Ss9+9nZg6OBfddwQhhmzZr4wQQLF6bx6U/viP/6r4a48858bN6cxLRpaXR0pHHUUcV46Ut7Y+HCif91AgAAwD4nyVgDolRFCMOdd2RcI6J46KHDKAoAAABg4irkKk/3KKZ94x/y997bvy8rhKEh1xD7Td+/RhXWmcYqB+HkkijNnTe2tQAAADDm6iqE4Vvf+lYkO5cUPvjgg2sawnDVVVfFvffeG2maCmEAAGDUcrmIJJKIGGKicJqL0s6V427//a8q9tWaNsSyo15U9tgtt2SsThcRJ54ohAEmssIwfvOfDCEMERHz5qVx4YXd410GAAAA1Jd85RCGpJj9nDF/790Vjxf32z/StmnDKgsAAABgosollcd2FdO+5y35++/r33f3tDIhDPlC/yoey9oPyAx3oLy0obGqdqV5C4a3agoAAAD7pIylKCanNB2bSSVj1S8AAPVnZ3bYkNI0id5ST0RE3LX9gYptj2xaGrl8+Rdnt9xS+VeCefNKMXeu+1yYyBoaqvsenjYtjaamMS4GAAAAmLzyGYGvpVLl42kahXvvqdikeOiKYRYFAAAAMHHlM8ISemNnCMOqvhCGNNK4p21wCEPa3BQRfQPSDuo8uLZF1pMqgxWKCxeOcSEAAADsDXUZwjBWkqyZcgAAUKUk2fXaa8gWUSwVY9O61bE+2VKx5ZHzVpbd39UVcdddlQdGH3VUxsBoYJ9XbbD+7NkCVwAAAICRS7NCGHp7Kx7OrV8XyVNPVe5i+SHDLQsAAABgwspnPG8ppqWIUikKq+6PiIhHm3vjqUJxcMOm5v6PB3Usr2mN9SRtbKyqXWnBojGuBAAAgL1BCAMAAOyDcrmIijEMaRKlUm/cf+fPM/s66MDnlN1/5525rHHPcfTRZV7KARNKofKiCP1mzRLCAAAAAIxCkjH8IK0c+Jq/5+7MSxSXmyQAAAAA1I9cUnnQRyktRe73D/WtxhMRq6Z2lW2XNjX1fxbCMApVroRSXLR4jAsBAABgbxDCUCPF4jOT0wrVznABAIAhJEnFCIaISKJY6o37Hvh1xVa5SGL/w08re+zWWzNWpouIo44SwgATnRAGAAAAYK/IeAiRFCuHMBR+d0/l/hsbo7hk/+FWBQAAADBh5XOVx3cVI43Cfff2b69qHSqEoTkiIgq5QixqExAwUmljY1XtSgsXjnElAAAA7A3SAmpk06ZN/Z9bWlrGrxAAACaFvhCGoWMY0jQXxVIxVm2qPDB5acyIppZpZY9lhTAsWVKKjo7sWoF9Wy7XNweit7dyu9mzK0+EAAAAAKgol7EGRLFy4Gv+3srPOnsPPCginx0sCwAAADBZ5POVp3sUc2nk730mhOH+qWVCGHK5iMaGiIhYMm1JFHKmkIxYQ3UhDMUFi8a4EAAAAPaGjFEQVGPDhg3x+OOP92+3t7ePXzEAAEwKydD5C33SJIql3ri3+/cVmy1vXVp2/9atEffeW/nXgaOOqjwoGpg4sgIYIiJmz07HvhAAAABg8hpNCEOpFPn7flf59OWHjKAoAAAAgIkrl2SEMERE/t67+7dXlQlhSJuaI3YuBrTf9PJjyahOujPMoqLm5khnzhz7YgAAABhzQhhq4L//+7/7PydJEkuXejgBAMDoJMmuV19DycW6rY/ExmRHxVYHzjuq7P677spFKWPR+6OPzmgATCqzZglhAAAAAEYuzeczGgz9vDG39sFItm+veHrv8uUjKQsAAABgwsrnM0IYkjQKO0MYupNSPNjSPbhRU1P/x/2nmecwKg2NmU2K8+ZVsQITAAAAE0Hl38onmBtvvLHqttu2bRtW+90Vi8XYtm1bPPTQQ/GLX/wirrvuukiSJNI0jSRJYsWKFSPqFwAAdulbNG7olzFpmsRd2x/ISmqIAw96Ttn9d99deUB0kkQccUSFlemASUcIAwAAADAquYw1IIpDP28s/O6ezO6LBx083IoAAAAAJrRCLiuEISKKfcGXD0ztjlIyeOxH2tzc/3n/6ctqWl+9SasIYSjNmbsXKgEAAGBvmFQhDGeffXYkGamBadr3YGHt2rXx5je/uSbX3RW+sMvLXvaymvQLAED9yuWi7x5zyDnRSTyWbK3YR2OajyWHPrfssXvuqTwgev/9S9HWVkWhwKQxc6YQBgAAAGAU8hnBrxVCGPL33lvx3HTq1CjNXzCisgAAAAAmqlw+K4ThmbEeq6Z2lW2TNjX1f17aLoRhVBobMpuUZgthAAAAmCwmVQjDLruCFkbbplq7AhiSJIkzzjgj9ttvv5r1DQBA/aoYL5ZmrCoXEQfkZkWhsXnQ/jTNDmE4+OBSZv/A5JIxTwIAAACgsqyHC8WhnzkWfndP5VMPWt6XXAsAAABQR3K56kMY7m8tE8KQJBGNfSEMbY1tMaN5Rk3rqzfJjh2ZbUqzZ++FSgAAANgbJmUIw65QhD3tHrwwVJuR2NXvs571rPjABz5Qs34BAKhfWeOJ0ypCGA6adkDZ/Q8/nMTTT1e+Hz7kkKFXpQMAAAAA2FOaywhhSIcIYSgWI7/q/oqn9i4/eIRVAQAAAExc+XxWCMMzn1dNLRPC0NjUF8QQEftPX1rTORT1qNSZHWJRXLpsL1QCAADA3jDpQhh2D1qoRbssbW1tcdRRR8WZZ54ZL37xiz2YAACgJnK5NJIY3b3lQQuOLrv/nnuyAxwOPnjoVekAAAAAAAbJSpbt7S1/2u8fiujpqXhq8cDlI60KAAAAYMLK5xsqHi8mz8yJKBfCkDY19X/ef7pwgNEqLl4SkUsiSkPMRWlsjN7DDt+7RQEAADBmJlUIwxe/+MUhj6VpGn/0R38USZJEmqaxZMmSuOiii0Z0nXw+H1OnTo3p06fHvHnzRlouAAAMKTPbK80OUlh6wEll9999d+UV6Vpa0li8uDahZcC+4bjjivGb3wz9vf+KV5SfBAEAAABQtXzl545JqXzwa37V/ZldFw84cEQlAQAAAExk+VxWCEPfPzcXivF40+CxHwNDGJbWtLa61NISPceujIYbbyh7uPs5p0S0tOzlogAAABgrkyqE4fjjj6+qXZIk0dLSUnV7AADY25IkIokKSQwZIQy5SGL+ASvLHrvnnsrnLl9eyly0DphYVqwoVQxhOOUUIQwAAADAKOUzHioWi2V3F1bdV/G0dMqUKM21OAIAAABQf3KFyiEMvUnfQjurWrvKN2h8JoRh6fRlNaurnm07/70x7S/eGsmTTw7YX1yyX2z/83eMU1UAAACMhUkVwlCNNLWiL7W3ZcuWuPnmm+OBBx6ILVu2RHNzc8yfPz+OPvromDNnzniXBwBMQEnSFx4WQ9y+ppUCGiJiQTotGqe0Dtrf1RWxalXlwdAHH1x+RTpg4nrpS3vi+98vxBNPDP7ZcdhhxVixwvc9AAAAMDppfugAyIiIKJUPYcivur/iacVlB4TUWAAAAKAe5XKVn7eUdg4DWd1SPoQhbWrs/7xk2n61KquupTNmxObPfjGav/G1KNz524je3ug54VnR/dIzIm2bNt7lAQAAUEN1FcJw7rnn9n+eOXPmOFZCrb33ve+Nb33rWyM+/9xzz43zzjtv2Oc99NBD8YlPfCJ++MMfRk9Pz6DjSZLEypUr453vfGesXFl+JWoAgHKSyhkLEWnlQceLm+aW3X///bmhFpzrd8ghJmPDZNPREXHRRTviox9tivvue+bnx/HHF+N97+syjwEAAAAYvSTjAUOpzHPHNI38/VkhDAeOoigAAACAiSufb6x4vJj0rfCztqW73MkRhb7pInOnzo2Whpaa11e3Wltjxx/9yXhXAQAAwBir2xAGGK0rrrgiLrjggti+ffuQbdI0jRtuuCHOPvvs+LM/+7M4//zz+1a0BgDIkMtFJFHhviGtfE+xZPr+Zfffc0/2TOuDD85IaQAmpAMOSONTn9oRv/tdLrZsiZg3L43589PxLgsAAACYLAqVhx8kxcEhDMmGDZFs3lTxvOIBQhgAAACA+pQvNFQ8XimEIW1sitg5/mxR2+Ka1wYAAACTXV2FMECt/PCHP4zzzz8/Snus1tLZ2Rnz5s2LJ598MtavXx9p2vdgK03T+MxnPhPd3d1xwQUXjEfJAMAEkyRRKYIhso4unn1w2f333185hGHu3DQ6OirXBkxcSRKxfHmZVScBAAAARiuXEQBbHBz+ml91f2a3xWUHjLQiAAAAgAktn6883aO4cwjZA2VCGKKxsf/jorYltSwLAAAA6oIQBialf/7nf46ZM2dW3X7RokVVt127dm1ccMEFAwIYDj744Hjf+94XJ554Yv++1atXx8c+9rH4yU9+0r/vC1/4Qhx33HHxohe9qOrrAQD1KUl2/U95aVo5hGHhkqPL7l+zpvJA6OXLBw+EBgAAAADIkubzlRuUyoUw3Ff5nHwuikv2G3lRAAAAABNYLt9Q8XgxSaMrV4r1zb2DjqVNTf2fF7ZVP1YeAAAA6COEgUnpmGOOiYULF45J35deemls27atf/vwww+P//7v/47W1tYB7ZYuXRqf+MQn4gMf+EB89atf7d//z//8z3HaaadFoeDbDwAYWi4XkUSloIXKIQwLDjh+0L7e3ogHH6wcwrB0aanicQAAAACAsnKVnz1GafCzx8Kq+yueUly8ZMCqjQAAAAD1JF9FCMPaKd2RRjr44G7PVBYJYQAAAIBhyxgFAezuvvvuiyuuuKJ/u6GhIf7xH/9xUADDLkmSxIUXXhj77bdf/761a9fGN7/5zbEuFQCY4JIkomLQQjr0rfzctDWmtHUO2r92bRK9g0PPB1i6tMwLOQAAAACALFkhDMXioF35+++rfMrSA0ZTEQAAAMCElitkhTBEPNjSXfZY2tTU/3lR25Ka1gUAAAD1oDDeBewrHnzwwbj11lvj0Ucfjaeeeiq2bNkSPT09I+orSZL4h3/4hxpXyL7gG9/4RpR2W6HlZS97WSxbtqziOU1NTfHWt741Lrzwwv59l19+ebz+9a8fszoBgIkvl9sVxDCEdOiDSxrmlN2/enV2BtvSpYNXowMAAAAAyJTPVzyc7BnCsG1b5B75fcVzigceNNqqAAAAACasfD4rhCGNteVCGPKFvj8RMaUwJTqbBy/oAwAAAFRW1yEMjz32WFx22WXxjW98I5588sma9JmmqRCGSexnP/vZgO3Xvva1VZ330pe+NC6++OLYtm1bRET89re/jfXr18ecOeUnSAIA9Bk6aCGtcGxR2+Ky+9esqRzC0NaWxqxZaXWlAQAAAADsLiOEIYoDA2DzDz4QkfE4srjsgNHVBAAAADCB5fMNfSv5pOUfohSTiAfLhDCkjY39nxe1LY6k4mpAAAAAQDnZS+FOUl/+8pfjhS98Yfznf/5nPPHEE5Gm6aj/MLmtXr06Hnzwwf7tlpaWOProo6s6d8+2aZrGNddcU/MaAYDJI0kqRTBERDr0rfziWcvL7l+1qvLt//77l8L7NgAAAABgJNJcRghDukcIwwNrMvssLl02mpIAAAAAJrR8Unm8VzFJy4YwRFNT/8dF08ov6AMAAABUVpchDB/84AfjQx/6UHR1dUWappEkyaj+UB/uueeeAduHH354FAqFqs8/5phjBmzffffdNakLAJiccrmofK9ZIYRh0aIjy+7PCmFYurRU8TgAAAAAwJByGcMPensHbObXrK7YPO3sjHTa9NFWBQAAADBh5ZNCVFpVpzdJY22ZEIa0sbH/86JWIQwAAAAwEtXPIJ8kLrvssvjyl78cEc9MatsVxDBjxozYtGlTFIvF/n3z5s2Lrq6u2Lx5c/TuNihk9wlxU6ZMiY6Ojr37hZBp27Zt8fDDD8fmzZujqakp2tvbY86cOdG420Ol4Vi1atWA7QMOOGBY5y9bNnCVlj37AwDYXS6XRsTIAr8WHXjCoH0bN0Zs2lS5v2XLhDAAAAAAACOUz1c8nJQGPn/MCmEo7r901CUBAAAATGS5JFcxhCEiYlu+zJiv3UMYpglhAAAAgJGoqxCGjRs3xr/8y78MCF9obW2N//N//k+88pWvjNbW1njVq14V9957b/85P/vZz/o/r1u3Lm655Zb44Q9/GFdddVUUi8WIiOjp6YnXve51cc455+zdL4ghnXPOObF69eoBwRkREU1NTXHkkUfGaaedFq973euitbW16j7XrFkzYHvu3LnDqmnevHkV+wMA2F2SDAz+2lOall9VblraFK0zFgzav3p1xip0EbH//mn1BQIAAAAA7C6f8Qxy5/v1/uYPZIQw7Lf/aCsCAAAAmNDyucqhl0NJdwthWNi2qFblAAAAQF2pqxCGL33pS7F9+/ZIkiTSNI22trb4f//v/8Xy5curOn/u3Llx+umnx+mnnx5r166NCy64IH7zm99EsViMT3ziE/Hggw/GRz7ykTH+KqjG7373u7L7u7q64oYbbogbbrghPvWpT8W73vWueNOb3lRVn08++eSA7eGGMMyZM2fA9saNG4d1/lhobBzZgzkYK4WCv5MAuzQ05CKJSinm5Qc0L8i1l/3/+AcfzFcMRc/lIg46KHF/AKPkfgYAmMjcywAAo1Foaqi8MGNa6n/+mGzcELnNm6LSI9DkwAOH/bzS/QwAMNG5nwEAdtfU0BCVH7iUkctF0tAQEX2LAO3fsSQa99I9hnsZAGCicz8DwO6yl8OdRL7//e/3BzAkSRLvete7qg5g2NPixYvjS1/6Urz2ta+NNE0jTdP4zne+E5deemmNq2asPP3003HRRRfFu9/97ujt7c1sv23btgHbLS0tw7relClTBmz39PREd3f3sPoAAOpHLheVX6Cl5Y/NbZ5Vdv+qVZVv/RcuTKOpqdrqAAAAAAD2kMsYflAqRaRpX9PVqzO7Ky1dWouqAAAAACasQq4w/BCGxsb+j3Omzo2mgkFhAAAAMBKF8S5gb3niiSdi7dq1kex8CNHW1havf/3rR9VnkiRx0UUXxSOPPBLXXXddpGkan/nMZ+IlL3nJiMMdGLlCoRDHH398nHLKKXHYYYfF/vvvH9OmTYtSqRQbNmyI3/72t/GTn/wkfvSjHw0IXfjBD34QbW1t8cEPfrBi/3uGMDTu9oCqGs3NzYP2bd26ddj9AAD1IUkikgrLwKVp+QHN81rnl93/wAOVX8YdcEBafXEAAAAAAHtI81UMP0jTiCSJ3OpVldslSZT22782hQEAAABMUPkkH1FhDFlZu41NXzxtSW0LAgAAgDqSsRTF5HHHHXf0f06SJE4++eRoaGgYdb9JksTf/M3fRKFQiCRJolgsxuc+97lR98vwvPzlL4+rrroqPv/5z8db3vKWWLlyZcycOTMaGxujubk55s+fHy9+8YvjkksuiW9/+9txwAEHDDj/K1/5SvzsZz+reI2urq4B28P9+1MubGHPPgEAdsnlskLMyx+c3bFo0L5SKeKhhyq/jNt//9IwqgMAAAAA2EOuiuEHO8Pyc2vWVGyWLlgY0WSVRgAAAKC+5XP5YWcwpLuNWV/YuqDGFQEAAED9qGIpisnhySefHLB98MEHV3VeV1dXNGUM7li6dGkce+yxcf3110dExJVXXhk9PT01CXnY11188cXxxS9+ccyvc+6558Z555035PGTTjqp6r4OPPDA+NKXvhRnnXVWPPjgg/37P/axj8Xznve8SIaY7bjn34Oenp6qrxkR0d3dPWhfuWCGvam7uziu14cs/o4C9axvLHKFN2hp+WOzZhww6OfnY48lsX175evNn1/0cxfGgO8rAGAicy8DAAxHQ5pEmlZu072jJyLy0XT//RXb9izZvyb3Iu5nAICJzv0MANS3Ym8aw01hSBsa+5+7zGqeO673E+5lAICJzv0MQH2rYimKyeGpp56KiIh05xOF2bNnl21XKAzMpSg3cb6c3UMAduzYEb/97W9HUiZ7SWdnZ1x00UUD9v3ud7+Le+65Z8hzWlpaBmxX+3djlx07dgzaN3Xq1GH1AQDUj75cqEov0MoPaJ4976BB+37/++wXcYsWlaquDQAAAABgT2kun92oWIwolSL/4AOVm+2/tDZFAQAAAExg+aSwayBZ1dKGZxYJnN+6oNYlAQAAQN2omxCGPSfMDzX5vbW1tT+oISJiw4YNVfW/Z6jDmjVrhlkhe9sJJ5wQhx122IB9v/zlL4dsv2cIw7Zt24Z1ve17LD9dKBSiqalpWH0AAPUjl4tIMl+gDT4+a9GKQfseeqjybX8uFzF/fsYSdQAAAAAAleSzhx8kpWLk1q+LKBNgv7vifvvXqioAAACACSufy1dex6ecxob+j3OnzqttQQAAAFBHCuNdwN6yZ+jCjiEGdezZ7tFHH40lS5Zk9r9rMv2uiXIbN24cSZkTzqmnnhodHR1jfp2VK1eOSb8nnnhi3Hnnnf3blcIzZsyYMWB73bp1w7rW+vXrB2zvjX9vAMDElSQRyTDfoHWkzdHc2j5o/9q1lQc/z5lTisbGik0AAAAAACrLVbEGRLEY+TWrs5vtv7QGBQEAAABMbPkkH2kyjFFkhUJELt+/KYQBAAAARq5uQhja29sHbG/durVsu7lz5w7Y/t3vfhcnnnhiZv9PPPFERESkaRpJkkSxWBxZoRPMSSedFCeddNJ4lzFi8+YNfLC0YcOGIdvuv//A1VYeffTRYV3rkUceGbC9dKmBQwDA0HK56EtiqCTNRSTP3HfOy7WXbfb731fuZ9GidJjVAQAAAADsIZ/PblMqRe7BByq3aWiI0oKFNSkJAAAAYCLLJ7mIYSzkk+62Ek9Hc0dMKUwZg6oAAACgPlSxFMXksN9++0VERLJzItu6devKtjvooIMGtPvNb35TVf833XTTgO1p06aNpEz2skJhYA5Jb2/vkG33DE24//77h3Wt1asHrugihAEAqCRJnrknHUqaDrydn9s0q2y7hx6qfNu/cGFpeMUBAAAAAOwhzVURwlAsRT4jhKG4ePHOlFoAAACA+pZL8tkL+eyu4ZkQhnlT549BRQAAAFA/6mbkwtKlSwdMYlu1alXZdocddlj/5zRN4+c//3k88cQTFft+5JFH4qqrrhrQ//z5HlpMBHv+t+3s7Byy7cEHHzxg+4477qgY2rCnm2++ecD2IYccUvW5AED9qerdWTqw0Zy2wfeg27dHPP545c4WLUqHUxoAAAAAwGBVBCckpWJ2CMOS/WpTDwAAAMAEl8/lI4aRwZA27hbC0Go+AwAAAIxG3YQwtLS0xEEHHRRpmkaapnHXXXeVbbdixYoBAQq9vb1x4YUXRrFYLNt+69at8e53vzt6enr69+VyuTj22GNr+wUwJm666aYB2/PmzRuy7bJly2Lx4sX929u2bYtbbrmlquvs2TZJkjj11FOHVywAUFeSJAaEfJU38HZ+TvuSQS0eeST7LdzixaXhlAYAAAAAMFg+n92mtzfyax+s2KS0ZP8aFQQAAAAwseWTfAwrhWH3EIapQhgAAABgNOomhCEi4vjjj+///Mgjj8TatWvLtnvFK14RaZpGkiSRpmn84he/iNe//vVx5ZVXxoYNG6JYLMYTTzwR3/72t+M1r3lN3Hbbbf1tkySJk08+OVpbW/fWl8UIPfjgg3HjjTcO2HfiiSdWPOe0004bsP31r3+9qmtdccUVsW3btv7tFStWxJw5c6qsFACoR7lcGpkv0NKBx2fPWjqoydq12bf8CxcKYQAAAAAARqmKEIbcIw9HdHdXbFNcPDhsFgAAAKAe5ZN832o+VUobdg9hGHpxQgAAACBbXYUwnHrqqRHxzIrCv/jFL8q2+7M/+7OYOXNmf9s0TePOO++Md77znXHSSSfFihUr4jnPeU68733viwcffDDSNO0/N0mSOOecc8b2C2HUisVifOhDH4re3t7+fe3t7XHsscdWPO/MM88csCL1D37wg1i1alXFc7q6uuIzn/nMgH2vfe1rR1A1AFBPkiQG3HeUk+4R0jB3waGD2jz0UOVb/qlT0+joGH59AAAAAAC7S3PZww/ya1Zntiku2a8G1QAAAABMfLkkn7mOT78kiWho6N+c17pgbIoCAACAOlFXIQwnnnhidHR0RJqmkaZpXH755WXbtba2xt/93d9FbucgkV2T33adt/ufJEn6jydJEm9/+9vjqKOO2itfD30+9rGPxZo1a6puv3379vjrv/7r+OUvfzlg/znnnBONjY1DnNXnoIMOitNPP71/u6enJ97znvfEli1byrZP0zQuvvjieOCBB/r3LVq0KM4888yq6wUA6lM1IQyRDrydn7nosEFNfv/7yn0sXJgOJywdAAAAAKC8WoQwFPJRmm+CAAAAAEBERCGXj6pTGAqF2H0g2Lyp88emKAAAAKgTdRXCkM/n42//9m/j3HPPjXPPPTde+MIXDjl5/gUveEF85CMfiYaGhgFhC3v+iXgmnOGtb31rvPOd79ybXxIR8b3vfS9e+tKXxp/8yZ/E1772tVizZk2USqVB7TZs2BBf+cpX4hWveEV8//vfH3DsyCOPjD/8wz+s6nrvete7YsqUKf3bv/3tb+ONb3xjXH/99QParVmzJt75znfGV7/61QH7zz///GjYLWUUAKCcvvHKWSEMzxyfkU6Jximtg5qsXVv5ln/hwsH3TQAAAAAAw1YoZDbJCmEoLlwckc/XqiIAAACACS2f5KPaFXbShmcWI2zINURnc+dYlQUAAAB1IXsUxCRz+umnV9325S9/eRx11FHxz//8z3H11VdHd3d32XbHHntsnHfeeXHiiSfWqkyGqVQqxbXXXhvXXnttRES0tLTE7Nmzo7W1NdI0jU2bNsXDDz9c9tylS5fGf/zHf0RjY2PZ43tasmRJXHzxxXH++edHmqYREXHPPffEm9/85ujs7Ix58+bFhg0bYt26df3Hdzn77LOH9XcQAKhfSRL9oV8VWvV/mpvvGHQ0TSMefrhyH4sXC2EAAAAAAGogl70GRH7NqorHS0v2q1ExAAAAABNfLhnGmpu7LRI4r3X+8M4FAAAABqm7EIbhWrRoUXziE5+I7du3x4033hjr1q2LjRs3xpQpU2LWrFlx3HHHxaxZs8a7TPawbdu2eOCBBzLbvfrVr473v//9MXXq1GH1/7KXvSzSNI0LL7wwduzY0b9/w4YNsWHDhrLn/Mmf/En89V//9bCuAwDUr1wuMlPM0/SZF2WzGgeHMGzYkMSOHZX7WLQorXgcAAAAAKAq+Xx2m1Ll55HFxUtqVAwAAADAxJdL8pljyHZJdw9hmDpvrEoCAACAuiGEoUpTpkyJ5z73ueNdBmX89V//dVxzzTVx0003xdq1ayNNKw/cmT59erzgBS+Is88+Ow455JARX/eMM86II488Mj7+8Y/Hj3/84+jp6SnbbuXKlfHOd74zjj/++BFfCwCoP0kSkURWGvkzL9g6m2cOOrpuXfYLuPnzS8MtDQAAAABgkDRXRQhDhuKS/UZfCAAAAMAkUcgVqg5hiMbG/o/zpi4Yo4oAAACgfghhYMJ7yUteEi95yUsiImLLli1x//33xyOPPBKPP/54bN++PZIkiba2tmhvb4/ly5fH0qVLI6n2YVSGRYsWxSWXXBIf/OAH46abbooHHnggtm7dGk1NTTFv3rw49thjY86cOTW5FgBQX5Iksl+gpc+ENHS2zh50uJoQhrlzKwdYAQAAAABUJZ8VKptNCAMAAADAM/JJvuoQhrShof/z3Klzx6okAAAAqBt1E8Lw6KOPxvXXXz9g30tf+tJo3C3xkYmvtbU1jjrqqDjqqKP2+nVPOeWUOOWUU/bqdQGAyStJIjM4Kt09hGHa4Bdnjz5aedDztGlpTJ06svoAAAAAAAbIjTKEIZdEacHC2tQCAAAAMAnkklxEtWsP7hbCMEcIAwAAAIxa3YQwXHPNNfHBD36wf/uggw6KV73qVeNXEAAAVNCXv1DtG7SIjo7Bg5PXrat8/ty56TCrAgAAAAAYQj4/qtNL8xcOmCwAAAAAUO+SJIkkqgi+zBcics88m5k9Zc4YVgUAAAD1YZRLUUwcmzdvjjRNI037Jpqddtpp41wRAAAMLZfre4lWUfrM7XzHjCWDDj/6aOXz580rjag2AAAAAIA9pbnRhTAUl+xXm0IAAAAAJpF8UsWUjz2CLWe3zB6jagAAAKB+1E0Iw54T2ObPnz9OlQAAQLYkyQ5hSHcLYeicu3TQ8fXrK9/uz52bjqw4AAAAAIA95UcZwrB4cNAsAAAAQL3LJ9nPXNLGZ0IYGnINMb2pfQwrAgAAgPpQNyEM06ZNG7Dd2to6TpUAAEC2JNn1PxVbRUREIXLRNmPRgCO9vRGPP175fCEMAAAAAEDN5EY3/KC43361qQMAAABgEqkmhCEanglhmN0yJ3PxHwAAACBb3YQwLF68OCKeWU14w4YN41kOAABUlMtFJEnG7Xrad2/bmU6JZI8Bzo89lkSpVPn0efMyGgAAAAAAVKtQGNXppSX71aYOAAAAgEkkX8U6O2lDY//n2S2zx7AaAAAAqB91E8Jw+OGHRz7/TArkvffeO47VAABAZblcGhEZieS7QhhyrYMOrVuXnWY+d24Vb+gAAAAAAKoxmhUWk4jiwsW1qwUAAABgkih092a2SRsa+j/PbpkzluUAAABA3aibEIa2trY4/vjjI03TSNM0rrnmmigWi+NdFgAADCnJGLSc7gxp6CxMH3Ts0Ucr3+onScTs2UIYAAAAAIAaSZKI3MiCGEpz50c0NdW4IAAAAICJL99bym7U0Nj/UQgDAAAA1EbdhDBERLzlLW+JiL7JbI899lh8+ctfHt+CAABgCEkS2SvHpX238zOaOwcdWreu8rkzZ6axWwA6AAAAAMDo5fIjOq24ZL/a1gEAAAAwSSQdg8eGDVJ45pmMEAYAAACojboKYTjllFPiRS96UaRpGmmaxiWXXBI33XTTeJcFAACD5HJ94WGV9R3vnDp70JGsEIZ586pISAcAAAAAGI7cyIYgFJcsqXEhAAAAAJND0jqt4vF06tTYNY4sImJ2y+CxZAAAAMDw1VUIQ0TERz7ykTj88MMjImL79u3x1re+Nf7nf/5nnKsCAICBMvMXIiLSvkYdbXMHHXr00cq3+nPnpiMpCwAAAABgSGk+n92ojNKS/WpbCAAAAMAkkZ/aFumUliGPp9PbB2zPbpkzxhUBAABAfai7EIaWlpb44he/GGeccUZERGzbti0uuuiiePGLXxyf/vSn49Zbb42urq5xrhIAgHpXzYJxadrXqLNjwaBj69ZVTnEQwgAAAAAA1NwIQxiKi/erbR0AAAAAk0Q+V4jSvPkRTU2DjpVmzYq0tW3Avlkts/dWaQAAADCpFca7gL3p+c9//oDtfD4fpVIp0jSNBx98MD7+8Y9HRESSJNHS0hKtra2RH8EgkSRJ4qc//WktSgYAoE4llTMUdrWKiIiOzsUD9m7bFrF5c+UO5s0rjbAyAAAAAIAh5EYYwrBocXYjAAAAgDqUT3IRhUIUl+wXydNbIunpjjQi0rZpEQ0NA9pOb2qPpvzgsAYAAABg+OoqhOHhhx+OJEkiTdNIdpvVtutzmqb9/9yyZUts2bJlRNdJqpsxBwAAQ6rqljLNRUREx+z9B+xety775Llz05GUBQAAAAAwtNzw35WXZs+OaGkZg2IAAAAAJr5csiv0Mom0rS0qjfqa3TJ7b5QEAAAAdaGuQhh2GSokoRbhCbuCHAAAYDRyuew2afTdv3bMXTZg//r12ScLYQAAAAAAai0tFGK4b92LS/Ybi1IAAAAAJoV8fwhDttktc8awEgAAAKgvdRfCICQBAICJoKp8sLSvUb6hccDuJ56ofHKhENHZ6b4YAAAAAKixatJl91BavGQMCgEAAACYHPK56kMYZk2ZPYaVAAAAQH2pqxCGV7/61eNdAgAAVKW6EIbyA5off7zyybNmlUYyFhoAAAAAoLJ89ZMCdiku3q/2dQAAAABMEvmk+ucts1uEMAAAAECt1FUIw4c//OHxLgEAAKpSTQhDOuIQhnQkJQEAAAAAVDaMlRl3KS1cOAaFAAAAAEwOuWGFMMwZw0oAAACgvlj/FgAA9kHVhDBElG+UFcIwc6YQBgAAAABgDOSHH8JQXLhoDAoBAAAAmBzySfVTPma1zB7DSgAAAKC+CGEAAIB9UG7nnXq+4i17EisL+w/a+8QTlUMYZs0SwgAAAAAA1F6aG94QhHTKlEg7OseoGgAAAICJr5ArVN121hQhDAAAAFArQhgAAGAflMv1BSVMzTUP3SjNxatWvm3grjTi8ccr3+YLYQAAAAAAxkR+eEMQSvMXRCSVQ2UBAAAA6lkuqe55SxIRnc3CLgEAAKBWhDAAAMA+bNrUGUMea0+nxBEnnTVg35YtEd3dlfucOVMIAwAAAAAwBnL5YTUvLVo8RoUAAAAATA65pLrnLe3NHZEf5rMZAAAAYGhCGAAAYB+U23mnPqW1M2Y1Dk4oz0US55z6oWhoahmw//HHs1eNE8IAAAAAAIyJ3PCGIBTnLxijQgAAAAAmh3yVIQwzmmeOcSUAAABQXwrjXcC+ZsuWLbFx48bYuHFjdHV1RUTEypUrx7kqAADqze5jldtnLIqpOzrjqacfi1JaisZCU7RNnxtz9uuNiNKA8x5/PHuQ86xZpcw2AAAAAADDleaHt9piadGiMaoEAAAAYHIo5Kqb8jFzihAGAAAAqCUhDBHx85//PK688sq44YYb4uGHHx5wLEmSuOuuu4Y89/777+8Pa4iImDdvXnR2Dl6pGAAAhiNJBm43NE+NGc37D9iXpr2Dznv88WTQvt0VChHt7aOtDgAAAACgjGGGMBTnLxyjQgAAAAAmh3ySvShPRMQMIQwAAABQU3UdwnDNNdfEv/zLv8T9998fERFpmg67j6985Stx2WWX9W+/7GUvi3/5l3+pWY0AANSnPUMYyimVBu/LCmGYOTONXHXv5QAAAAAAhic3vBCG0kIhDAAAAACV5JLqnrcIYQAAAIDaqsvpV2maxiWXXBJvf/vb4/777480TSNN00iSZMCfarzlLW+JXC7X38dVV10VW7ZsGeOvAACAya6a29FyGWJPPJEVwlAmuQEAAAAAoBZy1b1nj4hI29oinTZ9DIsBAAAAmPhySXVTPmY0C2EAAACAWqrLEIYPfOAD8dnPfjbSnbPWdgUu7ApSSMvNZhvCwoUL49RTT+3f3rFjR/zsZz+rab0AANSfakIYSqXBjR5/PCuEofp7XQAAAACA4UgLharblhYsHMNKAAAAACaHQq665y0zpghhAAAAgFqquxCGyy67LL72ta9FRF/4wq7QhWc961nx3ve+N/71X/81Fi9ePKw+Tz/99P7+IiKuu+662hYNAEDdyY3wTv2JJyqHMMyaJYQBAAAAABgjw3iwWRTCAAAAAJApl+SrajdzyowxrgQAAADqS/XLUEwCmzdvjo997GP9YQlpmsbcuXPjox/9aBxzzDH97f71X/91WP0+73nPi4aGhujt7Y00TeNXv/pVTesGAKD+JJWzFCIiIk0Hbz/+uBAGAAAAAGCc5KqbFBARUVq4aAwLAQAAAJgc8lWGMHQ2C2EAAACAWhrh+roT03/913/Fli1bIqIvgGHmzJnx1a9+dUAAw0hMnTo1DjrooP7txx57LDZs2DCqPgEAqG/VhDCUSgO3t26N2LGj8okzZwphAAAAAADGSL76EIbigoVjWAgAAADA5JDPZU/5KOTyMb2pfeyLAQAAgDpSVyEMP/zhDyNJkkjTNJIkib/7u7+LOXPm1KTvww47LNLdliJevXp1TfoFAKA+VfHubFAIw+OPZyc3zJolhAEAAAAAGCPDCGEoCWEAAAAAyJRPsp+3dDbPiFxSV1NDAAAAYMzVzW/av//972Pt2rX92/vvv3+84AUvqFn/+++//6DrAQDASCXZeQqR7pGnUE0Iw8yZQhgAAAAAgLGRVpMuu1Np3rwxrAQAAABgcshVEcIwY8rMvVAJAAAA1Je6CWG45557+j8nSRLPec5zatp/W1vbgO2tW7fWtH8AAOrLSEIYnnii8u19LhfR2SmEAQAAAAAYI9WGMDQ3R9ralt0OAAAAoM7lqwlhaBbCAAAAALVWNyEMGzZsiIiIdOdMtQMOOKCm/e8KYUh2zpYTwgAAwGgkSXYQQ6k0cPvxxyufMGNGWvUYaAAAAACAYctnTwqIiCjNml1dEi0AAABAncvnsp+3dE6ZsRcqAQAAgPpSN1OwNm3aNGB72rRpNe1/+/btA7YLhUJN+wcAoP5kjUHemS/Wb8OGyifMmpVWPA4AAAAAMCrVhjDMnj3GhQAAAABMDvkk+3nLzOaZe6ESAAAAqC91E8IwZcqUAdt7hiaM1q6Qh3TnTLj29vaa9g8AQP2pdQhDZ6cQBgAAAABgDOWqG4JQmj1njAsBAAAAqB8zpswY7xIAAABg0qmbEIbOzs6IiEh2zmTbsGFDTfu/9957B2wLYQAAYLSEMAAAAAAAE0maL1TVTggDAAAAQHU2d23ObDNzyqy9UAkAAADUl7oJYZg5c+aA7TvvvLOm/V9//fX9AQ8REcuWLatp/wAA1J/hhjBs3CiEAQAAAAAYR7nqhiCUZs0e40IAAAAAJodNXdmLT3Y2z9gLlQAAAEB9qZsQhiOPPDIaGhoiIiJN07j22muju7u7Jn1fffXV8cgjj/Rvz549O5YsWVKTvgEAqF9ZIQyl0jOf0zQ7hKGjQwgDAAAAADCGqg1hmC2EAQAAAKAaG3dszGwzc8rMzDYAAADA8NRNCENzc3Mce+yxke5cLnjz5s3xne98Z9T9dnd3x6WXXhoRfeEOSZLECSecMOp+AQAgl6scmpDudnjLloje3sr9dXYKYQAAAAAAxlAhX1Wz0uw5Y1wIAAAAwORwwrxnZbaZ2tC6FyoBAACA+lI3IQwRES972csiIiJJkkjTNC655JJ47LHHRtXnRRddFHfffXckuy1TfNZZZ42qTwAAiIjY7RazrFLpmQZPPpnROCI6OoQwAAAAAABjJ81VNwShNGv2GFcCAAAAMDkcOevozONJ1kAzAAAAYNjqKoThNa95TSxZsiQi+oIYNm3aFG95y1vikUceGXZfW7ZsifPOOy++/vWv94c6JEkSxx57bBxzzDG1Lh0AgDqUNV453S1TYeNGIQwAAAAAwDjL5TObpO3tEY2NY18LAAAAwCSwtH1ZLJm235DHX7DkRXuvGAAAAKgjdRXCkM/n46/+6q8i3TlbLUmSWL16dZxxxhnxb//2b/HYY49VPL9UKsXtt98el1xySTzvec+Ln/70p/19RUQ0NDTEe97znjH9GgAAqB+1DmFobxfCAAAAAACMoXx2CENp9py9UAgAAADA5JBLcvGBZ18U05vaBx17+bJXxov3O33vFwUAAAB1oDDeBextL3jBC+Id73hH/Nu//VskSRJJksS2bdvik5/8ZHzyk5+M+fPnx8aNGweEK5x11lmxadOmWL9+fezYsSMiYkCQQ5qmkSRJvPe9743DDz98XL4uAADqz+4hDBs2VA5haGtLLS4HAAAAAIwtIQwAAAAANbeobXF88fQvx/dWfTseenptFHKFOG3xC+LwmUdGkmQv3gMAAAAMX92FMEREvPOd74wnnngivva1r/UHMewKVXj44YcHPIhI0zRuu+22AaEMETHoYcVb3/rW+MM//MOxLx4AgLqR9X6sVHrm88aNlRt3dqYVjwMAAAAAjFaay2W2EcIAAAAAMHwtDS3xhoPNVwAAAIC9JXsExCT1oQ99KC6++OJobm6ONE37wxh2hSvsGcSw+/Fdx9I0jYaGhvjIRz4S7373u8fl6wAAYPKqYrxyvyefrBzC0NEhhAEAAAAAGGPVhDDMmrUXCgEAAAAAAAAAGLm6DWGIiDjzzDPj+9//fvzBH/xBNDU1RZqmkabPTE7bM3QhIvrb5HK5ePWrXx1XXHFFvOpVrxqH6gEAmOySyrkKUSo983njxsqNOzuFMAAAAAAAYyvZvj2zTWn2nL1QCQAAAAAAAADAyBXGu4DxtmDBgvjABz4Q5513XlxzzTVxww03xM033xzr16+PHTt29LcrFArR0dERRx55ZDz72c+OU089NebPnz+OlQMAMNnVMoSho0MIAwAAAAAwtnJPPpHZRggDAAAAAAAAALCvq/sQhl06Ozvj1a9+dbz61a/u39fV1RWbN2+O5ubmmDZt2jhWBwBAPcrlKh9Pd8tV2LBBCAMAAAAAML6SqkIYZu+FSgAAAAAAAAAARi5jWld9a2pqitmzZwtgAABgXCSVcxWiVOr7Z29vxFNPVW48Y4YQBgAAAABgbPUec1xmm7S9Yy9UAgAAAAAAAAAwckIYAABgH5XLuFtPd+YqbNqU9H8eSkeHEAYAAAAAYGz1Hn5k5eOHHpb94BMAAAAAAAAAYJwZ3QAAAPuoJKl8fFfwwsaNGQ1DCAMAAAAAMPaKyw6I0rx5Qx7vOe0Fe7EaAAAAAAAAAICREcIAAAD7qCSpHJywK4Rhw4bsEIbOTiEMAAAAAMAYKxRi6wcuinTKlEGHup//guh6+av2fk0AAAAAAAAAAMNUGO8CAACA8pKMbIVdIQwbN1Zul8tFTJtWm5oAAAAAACopLjswnvril6PpG1+L/Nq1EYVCdD//hdFz4rP7HlYCAAAAAAAAAOzjhDAAAMA+KjuEoa/Bhg2VG3Z0pMY2AwAAAAB7TdreETv+9M/HuwwAAAAAAAAAgBGZ8CEM3/72t8e7hLJe9apXjXcJAABMcFnBCaVS3z+rCWEAAAAAAAAAAAAAAAAAINuED2F473vfG0nWEsHjQAgDAACjlRXCkO7MVti4sfL9cGenEAYAAAAAAAAAAAAAAACAakz4EIZd0nTfmVi2L4ZCAAAw+ZRKff/MCmHo6Nh37pUBAAAAAAAAAAAAAAAA9mWTJoRhXwk+2JfCIAAAmNhyucrHd4UwbNgghAEAAAAAAAAAAAAAAACgFiZFCIPgAwAAJqOsEIZdnnqqcghDe7v7ZQAAAAAAAAAAAAAAAIBqTPgQhquuumq8SwAAgHGRphHFYsTTTwthAAAAAAAAAAAAAAAAAKiFCR/CsGDBgvEuAQAAxkRSOVshSqWIp57K7mfaNCEMAAAAAAAAAAAAAAAAANXIjXcBAABAebmMu/U0jdi8OSOpISLa22tTDwAAAAAAAAAAAAAAAMBkJ4QBAAD2UUlGvkKaRjz1VHYIw7RpaY0qAgAAAAAAAAAAAAAAAJjchDAAAMA+Kpdxt14qRWzalB3CMH26EAYAAAAAAAAAAAAAAACAaghhAACAfVSSka+QphGbN1du1NSURnNzDYsCAAAAAAAAAAAAAAAAmMSEMAAAwD4qSdKKx0ul7BCG9vYaFgQAAAAAAAAAAAAAAAAwyRXGu4B9yaOPPhp33XVXbNy4MTZt2hQ7duyIiIhzzz13nCsDAKAe5TIi09I0ic2bKwc1TJtW+TgAAAAAAAAAAAAAAAAAz6j7EIb169fHf//3f8eVV14ZDz/8cNk2lUIYvve978UTTzzRv33sscfGEUccUfM6AQCoP0lS+XiaRmzeXLlRe7sQBgAAAAAAAAAAAAAAAIBq1W0IQ7FYjI9+9KPxpS99KXp6eiJNy09OSzJmvq1fvz4uueSS/u0TTzwxPv/5z9e0VgAA6lMtQhimTRPCAAAAAAAAAAAAAAAAAFCtugxh2LBhQ5x33nlx880394cvlAtbGCqYYXdnnXVWfPrTn44tW7ZEmqZx/fXXx6OPPhrz5s2red0Mz5YtW+Lmm2+OBx54ILZs2RLNzc0xf/78OProo2POnDk1vdZ9990Xd955Zzz22GNRKpWivb09DjzwwDjyyCOjUKjLbzMAoAZqEcIwfboQBgAAAAAAAAAAAAAAAIBq1d3s8O7u7njHO94Rt956a0Q8E76wZ+BCuVCGclpbW+P000+Pr33ta/39/PSnP42zzz67dkVPAg899FDcfvvtcdttt8Xtt98ed999d+zYsaP/+PHHHx9f+tKXanatT3ziE/HDH/4wenp6Bh1PkiRWrlwZ73znO2PlypUjvk6apvGNb3wjPvOZz8QDDzxQtk17e3v8wR/8QbztbW+LlpaWEV8LAKhPWbekpZIQBgAAAAAAAAAAAAAAAIBaqrsQhosvvjhuvfXWAeELHR0d8eY3vzlOPfXUWLBgQbz5zW+Oe++9t+o+d4Uw7OrzuuuuE8IQEVdddVV89atfjdtvvz02bty4V655xRVXxAUXXBDbt28fsk2apnHDDTfE2WefHX/2Z38W559/ftWhG7s89dRT8a53vSuuvfbaiu02bdoU//7v/x7f//7349///d/jwAMPHNZ1AID6lstVPl5dCEMNCwIAAAAAAAAAAAAAAACY5OoqhGH16tXx9a9/PZIkiTRNI0mSOOmkk+LSSy+N1tbWEfd7/PHHR2tra2zdujXSNI0bb7yxhlVPXL/+9a/jmmuu2WvX++EPfxjnn39+lEqlAfs7Oztj3rx58eSTT8b69esjTftWg07TND7zmc9Ed3d3XHDBBVVfZ8eOHfGnf/qncfvttw/Y39DQEAsWLIjGxsb4/e9/H9u2bes/9tBDD8Wb3/zm+MpXvhJLliwZxVcJANSTrBCG7dsjenoqt5k+Pa1dQQAAAAAAAAAAAAAAAACTXMa0rsnlP//zP6NYLEZERJIkcdhhh8WnP/3pUQUwRETk8/k45JBD+if3b926NR555JFR1zuZtbS01LS/tWvXxgUXXDAggOHggw+OL3zhC/GrX/0qvvnNb8Y111wTV1xxRbzoRS8acO4XvvCF+MlPflL1tT784Q8PCGDI5XLxjne8I6699tr48Y9/HN/73vfi+uuvjw9/+MMxfbelpzds2BDvete7+v8OAgBkSZLKxzdtymgQQhgAAAAAAAAAAAAAAAAAhqOuQhiuvvrqSJKkPyzh7//+76NQKNSk7xUrVgzYXr16dU36nQza29vj5JNPjnPOOSf+7d/+LX75y1/G+9///ppe49JLL41t27b1bx9++OFx2WWXxYknnjig3dKlS+MTn/hEvOENbxiw/5//+Z+jt7c38zqrVq2Kyy+/fNC5f/mXfzkgcKGxsTFe85rXxGWXXRbTpk3r33/XXXfFt7/97eF8aQBAHcsKYdi4UQgDAAAAAAAAAAAAAAAAQC3VTQjDXXfdFZs2bYqIiCRJ4thjj42DDz64Zv3PmzdvwPb69etr1vdE9frXvz6uvPLKuP766+Nzn/tcvOtd74rnP//5MWvWrJpe57777osrrriif7uhoSH+8R//MVpbW8u2T5IkLrzwwthvv/36961duza++c1vZl7rk5/8ZBSLxf7tV77ylXHGGWcM2f7AAw+Mv/7rvx6w71Of+lT09PRkXgsAICuEYdOm7BCG9nYhDAAAAAAAAAAAAAAAAADVqpsQhgceeGDA9oknnljT/qdNmzZge8uWLTXtfyI68MADY/HixWN+nW984xtRKpX6t1/2spfFsmXLKp7T1NQUb33rWwfsu/zyyyues3nz5rjyyiv7t5MkifPOOy+zvjPPPDMWLFjQv/3www/Hddddl3keAEBWCMPTT1dukMtFDJFLBQAAAAAAAAAAAAAAAEAZdRPCsHHjxoiISNO+lYAXLlxY0/6nTJkSEX0T8yMitm/fXtP+GdrPfvazAduvfe1rqzrvpS99abS0tPRv//a3v43169cP2f7qq6+O3t7e/u3jjz8+Fi1alHmdXC4Xr3nNawbsu+qqq6qqEQCob7lR3q23taWj7gMAAAAAAAAAAAAAAACgntTNlKwtW7YM2N598n0tPP300xHxTMhDrfunvNWrV8eDDz7Yv93S0hJHH310Vefu2TZN07jmmmuGbL/nsZNPPrnqOp/97GcP2P75z39e9bkAQP3ame81YtOnp7UpBAAAAAAAAAAAAAAAAKBO1E0Iw7Rp0wZs7wpNqJUNGzYM2G5vb69p/5R3zz33DNg+/PDDo1AoVH3+McccM2D77rvvHrLtnseqDXuIiFixYkU0Njb2bz/22GOD/s4AAOwpSUYXotDeLoQBAAAAAAAAAAAAAAAAYDjqJoShs7MzIiKSncsJP/roozXt/7bbbhuw3dHRUdP+KW/VqlUDtg844IBhnb9s2bKK/e3S09MTa9eurXhuJY2NjbF48eKqrgUAsEtulHfre+SQAQAAAAAAAAAAAAAAAJChbkIY5s+fP2D79ttvr1nf3d3dceONN/YHPEREHHbYYTXrn6GtWbNmwPbcuXOHdf68efMq9rfLQw89FL29vf3bzc3N/cEe1dqztqGuBQCwy263lyMyfXpam0IAAAAAAAAAAAAAAAAA6kRhvAvYWw477LCYNm1aPP3005Gmafz617+OjRs3RkdHx6j7/vrXvx5PPfVUfwjDsmXLhj1Bn5F58sknB2wPN4Rhzpw5A7Y3btxYtt2GDRsqnjeSa+1Z+3hobMyPdwkwQKHg7yTA7hoacqMKYujsTPz/Pexl7mcAgInMvQwAMNG5nwEAJjr3MwDAROZeBgCY6NzPALC73HgXsLfkcrl41rOeFWnatxpwT09P/Nd//deo+33sscfiU5/6VCRJEmmaRpIkcfLJJ4+6X6qzbdu2AdstLS3DOn/KlCkDtnt6eqK7u3tQu61bt1Y8rxp71rZn7QAAtdbeno53CQAAAAAAAAAAAAAAAAATSt2EMEREvOENb4iI6A9M+PznPx833njjiPt76qmn4rzzzosnn3yyf18+n4+zzz571LVSnT2DDBobG4d1fnNz86B9ewYulLtOU1PTsK5T7hwhDABAliQZ3fnTpwthAAAAAAAAAAAAAAAAABiOugphePaznx0nnHBCpGkaSZJEb29v/Pmf/3n85Cc/GXZf119/fZx55plx++2394c6JEkSL3vZy2LBggVjUD3ldHV1DdhuaGgY1vnlQhv27LMW1yl3rR07dgy7DwCgvuRGebc+fXpt6gAAAAAAAAAAAAAAAACoF4XxLmBvu+CCC+Kss86KHTt2RJIksW3btvjLv/zLOP744+P1r399HH300YPO6enpiU2bNsUjjzwSN954Y1x55ZVx++23R5r2rSycJEkkSRIzZ86Mv/qrv9rbX9IgF198cXzxi18c8+uce+65cd555435dSppamoasN3T0zOs87u7uwftKxfMMNrrlLvWnn2Oh+7u4niXABX5OwrUuzTNR5qOPIlhypRidHeXalgRMFzuZwCAicy9DAAw0bmfAQAmOvczAMBE5l4GAJjo3M8A1Le6C2FYvnx5XHLJJXHuuedGmqaRJEmkaRo33HBD3HDDDf3tdgUspGkaRxxxxKB+dp2763OhUIiPfexjMXPmzL3zhRARES0tLQO2y4UqVLJjx45B+6ZOnZp5na6urmFdp9w5e/YJAFBr06al410CAAAAAAAAAAAAAAAAwIQy8mV1J7DTTjst/vEf/zGam5sjIgaEKez6s7vd9+/6s/s5U6dOjU9+8pNx3HHH7d0vhEFBBtu2bRvW+du3bx+wXSgUoqmpaVC7PYMZ9jyvGnvWJoQBAMiSG+XdelubEAYAAAAAAAAAAAAAAACA4SiMdwHj5eUvf3kcfPDB8e53vzvuu+++SJKkP1ihWmmaxtKlS+PSSy+NAw88cIwqHb5TTz01Ojo6xvw6K1euHPNrZJkxY8aA7XXr1g3r/PXr1w/YHurfW2dnZ8XzRnKtPWsHANjTaEIYkiRC5hMAAAAAAAAAAAAAAADA8NRtCENExIEHHhjf/e5340c/+lF89rOfjTvvvHNQmyRJIk0HryC8ZMmSOOecc+IVr3hF5Ea7RHGNnXTSSXHSSSeNdxl7xf777z9g+9FHHx3W+Y888siA7aVLl5Ztt2jRoigUCtHb2xsRETt27IgNGzYMCmeoZM/ahroWAMAuw8wIG6C1NR1ViAMAAAAAAAAAAAAAAABAParrEIaIvpCF008/PU4//fR4+OGH48Ybb4ybb7451q1bF5s2bYrNmzdHc3NzdHR0xIwZM+LII4+Mk046KZYtWzbepRODgwzuv//+YZ2/evXqiv3t0tDQEIsWLYo1a9YMuNbxxx9f1XW6u7vjoYcequpaAAC7jCaEoa1tcJAYAAAAAAAAAAAAAAAAAJXVfQjD7hYsWBALFiyIV73qVeNdClU6+OCDB2zfcccd0dvbG4VCdX+1b7755gHbhxxyyJBtDznkkAEhDLfcckvVIQx33HFHdHd392/PmjUrZsyYUdW5AED9Gk0IQ2tr7eoAAAAAAAAAAAAAAAAAqBe58S4ARmPZsmWxePHi/u1t27bFLbfcUtW5e7ZNkiROPfXUIdvveezaa6+tus7rrrtuwPZpp51W9bkAQP1KknTE506bNvJzAQAAAAAAAAAAAAAAAOqVEAYmvD0DDb7+9a9Xdd4VV1wR27Zt699esWJFzJkzZ8j2p5xyShQKhf7tG264IR566KHM66RpGt/85jcH7Hv+859fVY0AQH3LjeJuvbVVCAMAAAAAAAAAAAAAAADAcAlhYMI788wzI0mS/u0f/OAHsWrVqorndHV1xWc+85kB+1772tdWPKe9vX1AeEKapvHJT34ys76vf/3r8fDDD/dvL1iwIJ71rGdlngcAsNstzrC1tdWuDgAAAAAAAAAAAAAAAIB6IYSBCe+ggw6K008/vX+7p6cn3vOe98SWLVvKtk/TNC6++OJ44IEH+vctWrQozjzzzMxrvfOd74zcbktSf+c734nvf//7Q7a///7745/+6Z8G7DvnnHOisbEx81oAALlR3K23taW1KwQAAAAAAAAAAAAAAACgThTGu4C97be//W3s2LGjf3v58uUxbdq0Efe3efPm+N3vfte/3draGocccsioapxMrrvuurL777///gHbmzdvHrLtokWLYtGiRRWv8653vSt+/vOfx/bt2yOi77/zG9/4xrjgggvihBNO6G+3Zs2a+OhHPxo/+clPBpx//vnnR0NDQ+bXc8ABB8TrXve6+OpXv9q/76/+6q9i1apV8Za3vCWmT58eEX1BEN/73vfiIx/5SDz11FP9bZcvXx6vfvWrM68DABARkSQjP1cIAwAAAAAAAAAAAAAAAMDwJWma1s3srPXr18dpp50WpVIpIiLa2tri5z//eUydOnXEfW7ZsiWe97znxZYtWyIiorm5Oa655ppRBTtMJsuXLx91H+eee26cd955me1+8IMfxPnnnx97/pXu7OyMefPmxYYNG2LdunWDjp999tnxN3/zN1XXs3379njTm94Ud9xxx4D9DQ0NsXDhwmhsbIyHHnootm3bNuB4R0dHfPnLX47999+/6muNtccff3q8S4ABGhvzA7a7u4vjVAnAvuEzn2mIr30tOyiqnP/7f7vixS/2cxT2NvczAMBE5l4GAJjo3M8AABOd+xkAYCJzLwMATHTuZ5hoZs1qG+8SYFLLjXcBe9O3vvWtKBaL/ZPwX//6148qgCEiorW1Nd7whjdEmqaRpmns2LEjvvOd79SiXIbpZS97WfzLv/xLNDc3D9i/YcOGuPPOO+PRRx8dFMDwJ3/yJ3HhhRcO6zpTpkyJz33uc3HiiScO2N/T0xNr1qyJe++9d1AAw4IFC+ILX/jCPhXAAADs+3KjuFuXCQYAAAAAAAAAAAAAAAAwfHUVwnD11VdHkiT92y9/+ctr0u8rX/nKiIj+vn/605/WpF+G74wzzojvf//7ccYZZ0RDw9CrRq9cuTK+9KUvxXve854Bfyeq1d7eHp///OfjoosuiiVLllRs9/a3vz2+973vxfLly4d9HQCgvo3gNqVfa2ua3QgAAAAAAAAAAAAAAACAAZI0TetidtaWLVvihBNOiFKpFGmaxuLFi+MnP/lJzfp/yUteEg8++GCkaRqNjY1x4403RlNTU836Z/i2bNkSN910UzzwwAOxdevWaGpqinnz5sWxxx4bc+bMqem17r333rjrrrvi8ccfj2KxGO3t7XHggQfGkUceWTEMYrw9/vjT410CDNDYmB+w3d1dHKdKAPYN//VfDfHlL4/sXuIzn9ke++1XF7f6sE9xPwMATGTuZQCAic79DAAw0bmfAQAmMvcyAMBE536GiWbWrLbxLgEmtcJ4F7C3rFq1KorFYiRJEkmSxJFHHlnT/o866qh44IEHIiKip6cnVq1aFYceemhNr8HwtLa2ximnnBKnnHLKmF9r+fLlsXz58jG/DgBQX3K5kZ/b5ndpAAAAAAAAAAAAAAAAgGEbxbSuiWXNmjUDtg855JCa9r/nBPw9rwcAAMM1uhCGtHaFAAAAAAAAAAAAAAAAANSJuglh2Lx5c0REpGnfZLTOzs6a9t/R0TFge+PGjTXtHwCA+pMkIzuvsbHvDwAAAAAAAAAAAAAAAADDUzchDNu3bx+wPWXKlJr2v6u/ZOdMuW3bttW0fwAA6k9uhHfr06altS0EAAAAAAAAAAAAAAAAoE7UTQjD1KlTB2w/9dRTNe1/V39p2jfhraGhoab9AwBQf5JkZGEKra1CGAAAAAAAAAAAAAAAAABGom5CGNrb2yMiIkmSiIhYv359Tfvfs7+Ojo6a9g8AQP3Zees6bNOmCWEAAAAAAAAAAAAAAAAAGIm6CWGYOXPmgO3rr7++pv3v2V9nZ2dN+wcAoP6MNIRh6tTa1gEAAAAAAAAAAAAAAABQL+omhOHwww+PfD4fERFpmsatt94ajz32WE36Xr9+fdxyyy2R7JwllyRJHHbYYTXpGwCA+jXSEIZp09LaFgIAAAAAAAAAAAAAAABQJ+omhKG1tTUOO+ywSNO+CWm9vb3xr//6rzXp+1Of+lT09vb2bx900EExY8aMmvQNAED9GmkIQ1ubEAYAAAAAAAAAAAAAAACAkaibEIaIiNNOOy0iIpIkiTRN4+tf/3r88Ic/HFWfV1xxRVx++eX9fSZJEs9//vNrUS4AAHUuN8K7dSEMAAAAAAAAAAAAAAAAACNTVyEMb3rTm2LatGkR0RfEUCqV4r3vfW98/etfH1F/l19+ebzvfe8bsG/q1Knx5je/edS1AgBAkozsvLa22tYBAAAAAAAAAAAAAAAAUC/qKoShtbU1/viP/zjStG9l4CRJoqurK97//vfH2972trjhhhuq6ufXv/51vPWtb42//du/ja6uroiISNM0kiSJP/7jP47p06eP2dcAAED9yI3wbr21Na1tIQAAAAAAAAAAAAAAAAB1ojDeBextf/7nfx433HBD/OpXv4okSSJJkkjTNP73f/83/vd//zfmzJkTRx99dBx00EExbdq0mDp1amzdujWeeuqpuPfee+OWW26Jxx57LCKeCV6I6At0eNaznhXnnHPOeH55AABMIiMNYWhrE8IAAAAAAAAAAAAAAAAAMBJ1F8KQy+Xi4x//eJx11lmxZs2aAUEMERHr1q2LH/3oR/GjH/2o7Pm72kVEfwBDmqZx4IEHxqWXXhq5kc6UAwCAGmlrG+8KAAAAAAAAAAAAAAAAACamukwMmD59elx++eVx6qmn9ocq7Apj2BXIMNSfcu1e9KIXxZe//OVoM9sNAIAaGmm+17RpaXYjAAAAAAAAAAAAAAAAAAYpjHcB46W1tTX+4z/+I7785S/HZz7zmXjkkUci4pkwhkp2BTcsWrQo3v72t8eZZ5455vUCAFB/Mm5Lh9TaKoQBAAAAAAAAAAAAAAAAYCTqNoRhlz/4gz+I173udfGDH/wgfvazn8WNN94YGzZsGLL9zJkzY+XKlfHCF74wXvKSl0RupMsTAwBAhpGEMCRJxNSpta8FAAAAAAAAAAAAAAAAoB7UfQhDREShUIhXvvKV8cpXvjIiItauXRtPPPFEbN68ObZs2RKtra3R3t4eM2fOjEWLFo1ztQAA1IuRhDC0tKQhJwwAAAAAAAAAAAAAAABgZIQwlLF48eJYvHjxeJcBAECdy+XSYZ8zdeoYFAIAAAAAAAAAAAAAAABQJ6yRCwAA+6gkGf45U6cOP7gBAAAAAAAAAAAAAAAAgD5CGAAAYB+VG8HdemurEAYAAAAAAAAAAAAAAACAkRLCAAAA+6gkGf45U6fWvg4AAAAAAAAAAAAAAACAeiGEAQAA9lEjC2FIa18IAAAAAAAAAAAAAAAAQJ0ojHcBe1OapvEXf/EXsWXLlv59H/nIR2L+/Pkj7vPhhx+OCy64INK0b7LbrFmz4pJLLhl1rQAAMJIQhpaW2tcBAAAAAAAAAAAAAAAAUC/qKoThF7/4RfzsZz+LZOdstmOOOWZUAQwREQsWLIhisRg33XRTpGkaSZLEH/zBH8Rxxx1Xi5IBAKhjIwlhaG1Na18IAAAAAAAAAAAAAAAAQJ3IjXcBe9P3v//9iIhI076JaW984xtr0u8f/uEf9gcwRER897vfrUm/AADUt9wI7tanThXCAAAAAAAAAAAAAAAAADBSdRXC8Ktf/ao/KKGpqSlOPfXUmvT7vOc9L6ZMmRIRfQEPv/zlL2vSLwAA9W1kIQy1rwMAAAAAAAAAAAAAAACgXtRNCMNDDz0UTzzxREREJEkSRx11VLS0tNSk7ylTpsQxxxwTadq36vCjjz4a69atq0nfAAAwHFOnpuNdAgAAAAAAAAAAAAAAAMCEVTchDKtWrRqwvWLFipr2f+ihh1a8HgAADFduBHfrQhgAAAAAAAAAAAAAAAAARq5uQhgeffTRiIhI075JaYsWLapp/wsXLhyw/fDDD9e0fwAA6s/IQhhqXwcAAAAAAAAAAAAA/5+9+w7Psrr/B/5JgABhBRBBERciIIKCinuh1j3AbR2469b6c9W2329bFatVW22rdRcnCjipWgHrAAEZiqCiLBmyBMIKkJA8vz/8mvowkifhCVmv13VxXZ5zn/vcn8Tk4XCP9w0AANQWtSaEYeXKlUntpk2bpnX+Jk2aRERERkZGRESsWrUqrfMDAFD7/N/SskwaNUqkvxAAAAAAAAAAAAAAAACAWqLWhDAkEskPo61bty6t8xcWFia18/Pz0zo/AACkolGjyq4AAAAAAAAAAAAAAAAAoPqqNSEMzZs3T2ovWbIkrfMvXbo0Iv4b9tC0adO0zg8AQO2TmZkofdB6Gjcu+z4AAAAAAAAAAAAAAAAA/KDWhTBkZGRERMTXX3+d1vnXn2/90AcAACir/1u6piwzM6JBg4qpBQAAAAAAAAAAAAAAAKA2qDUhDDvssEPxfycSiRgxYkRa5//oo4+KAx4iItq2bZvW+QEAqH0yy7hab9QoUebgBgAAAAAAAAAAAAAAAAD+q9aEMHTo0CFatmxZ3F6wYEG8/fbbaZn77bffjvnz5xe3mzRpErvvvnta5gYAoPYqa6BCo0YVUwcAAAAAAAAAAAAAAABAbVFrQhgiIvbbb79IJBKRkZERiUQi7r///li5cuVmzblixYq4//77i+fMyMiI/fbbLzK8ghgAgM1U9hCGRMUUAgAAAAAAAAAAAAAAAFBL1KoQhrPPPjupPXv27LjqqqtizZo15ZpvzZo1ceWVV8asWbOS+s8888xy1wgAAD/KLONqXQgDAAAAAAAAAAAAAAAAwOapVSEMe++9d+yzzz6RSCQiIyMjEolEjBkzJvr06RMTJ04s01yfffZZ9O7dO8aOHVs8V0ZGRuy1115x4IEHVtBXAABAbZKRUbbxjRpVTB0AAAAAAAAAAAAAAAAAtUXdyi5gS7v99tvj7LPPjjVr1hSHJ0yfPj3OPPPM2HvvveOkk06KHj16RPv27TfYd9q0aTF+/Ph47bXXYty4cZFI/PCm4Yz/ezquQYMGcfvtt2/RrwcAgJqr7CEMiYopBAAAAAAAAAAAAAAAAKCWqHUhDJ06dYo777wzfvnLX0ZGRkZxEEMikYixY8fG2LFjIyKiTp060aRJk8jOzo68vLxYsWJFFBYWFs/z0wCGRCIRmZmZcdddd0Xnzp0r5esCAKDmKWsIQ+PGQhgAAAAAAAAAAAAAAAAANketC2GIiDjuuONi+fLlceedd8a6desi4/+ebvsxWCEiYt26dbF06dJYunTpRuf46T5ZWVnxm9/8Jo499tiKLx4AgFqjrCEMjRpVTB0AAAAAAAAAAAAAAAAAtUVmZRdQWc4666zo379/tGnTpjh8ISMjI+U/ET8EMLRr1y6ef/75OP300yvzywEAoAbKLONqvVGjROmDAAAAAAAAAAAAAAAAANikupVdQGXq3r17/Pvf/47BgwfHE088EbNmzdpgTEZGRnFIw0/ttNNOcemll8ZJJ50UdevW6m8jAAAVpOwhDBVTBwAAAAAAAAAAAAAAAEBtUevTA+rVqxdnnnlmnHnmmTF16tQYPXp0fPrpp7F48eLIzc2NVatWRaNGjaJ58+ax1VZbxZ577hk9e/aM9u3bV3bpAADUcBkZZRvfuPGG4WEAAAAAAAAAAAAAAAAApK7WhzD81C677BK77LJL/PznP6/sUgAAoMwhDI0aCWEAAAAAAAAAAAAAAAAA2ByZlV0AAACwcZmZZQtVaNSoggoBAAAAAAAAAAAAAAAAqCWEMKTZxIkT47e//W1llwEAQA2QkVG28Y0alS20AQAAAAAAAAAAAAAAAIBkdSu7gJogNzc3XnvttRg4cGBMnTo1IiJ+//vfV3JVAABUd2UNYWjcWAgDAAAAAAAAAAAAAAAAwOYQwrAZPvzwwxg4cGAMHz481q1bF4nEDw+9ZZT1aTkAANiIsi4rGzWqmDoAAAAAAAAAAAAAAAAAagshDGU0Z86cGDRoULz66qsxf/78iIik8IUf/xsAADZXWUIY6taNyMqquFoAAAAAAAAAAAAAAAAAagMhDCnIz8+Pf//73zFw4MAYM2ZMJBKJpLCFjLK+ohgAAFKQmZn62EaNhIEBAAAAAAAAAAAAAAAAbC4hDCX44osvYuDAgTFkyJBYvnx5RERx+ML6wQs/9m+77bZx4oknbtlCAQCokcqS9dW4sRAGAAAAAAAAAAAAAAAAgM0lhGE9y5cvjzfeeCMGDhwYX331VUT8N2AhIjl84cf+Jk2axDHHHBMnnXRS7LPPPlu2YAAAaqzMzNTHNmpUcXUAAAAAAAAAAAAAAAAA1BZCGP7Pxx9/HAMHDoyhQ4dGfn5+qcELdevWjUMPPTROOumkOPzwwyMrK2uL1wwAQM32k2VoqbKzE6UPAgAAAAAAAAAAAAAAAKBEtTqEYf78+TFo0KAYPHhwfPfddxERmwxf+HFbTk5OXHfddXHsscdGTk7OliwXAIBapmwhDBVXBwAAAAAAAAAAAAAAAEBtUetCGAoKCmLo0KExcODAGDVqVBQVFW0yeOHH/oyMjOL/3mabbeLss8/eskUDAFArlSWEoWHDROmDAAAAAAAAAAAAAAAAAChRrQlhmDJlSgwcODDeeOONWLZsWUQkhyz8VCKRiIyMjNh3332jd+/eceuttyYFMQAAwJaQmZn62EaNKq4OAAAAAAAAAAAAAAAAgNqiRocwrFy5Mt58880YOHBgTJ48OSIiKUjhp+ELP/bvsMMOccopp8TJJ58c2267bURE3HrrrVuwagAAKLvsbIFhAAAAAAAAAAAAAAAAAJurRoYwjBkzJgYOHBjvvvturFmzptTghaZNm8axxx4bp5xySnTv3n2L1wsAABuTmZn6WCEMAAAAAAAAAAAAAAAAAJuvxoQwLFy4MF555ZUYNGhQzJ49OyL+G7Lw0+CFH/vr1KkTBx10UJxyyilxxBFHRFZW1havGQAASpKZmXqwQnZ2BRYCAAAAAAAAAAAAAAAAUEvUmBCGww47LBKJRHHwQkRy+MKP/R07dozevXvHiSeeGC1bttzidQIAQKrWyxIrUcOGqQc2AAAAAAAAAAAAAAAAALBxNSaEoaioKDIyMjYavNCyZcs44YQTonfv3tGpU6fKKhEAAMokMzP1sdnZFVcHAAAAAAAAAAAAAAAAQG1RY0IYfiqRSERmZmb87Gc/i1NOOSUOOeSQqFOnTmWXBQAAZfKTfLFSZWcnKq4QAAAAAAAAAAAAAAAAgFqiDO/WrV4SiURMmTIlpkyZEosWLarscgAAoMzKEsLQsGHF1QEAAAAAAAAAAAAAAABQW9TIEIaMjIxIJBLx7bffxl/+8pfo1atXnH/++fHqq69GXl5eZZcHAAApKUsIQ3Z2ouIKAQAAAAAAAAAAAAAAAKglakwIw7bbbhuJRCISiR8ePsv4vyfWEolEFBUVxSeffBK33XZbHHjggXHzzTfHyJEjK7NcAAAoVdlCGCquDgAAAAAAAAAAAAAAAIDaosaEMAwfPjyeeuqpOO6446JevXrFgQwZGRmRkZFR3F69enW88cYbcfHFF8ehhx4a999/f0ybNq2yywcAgA1klmG1np2dqLhCAAAAAAAAAAAAAAAAAGqJupVdQDrtv//+sf/++8eyZcvi9ddfj0GDBsVXX30VEREZP3mNcCLxwwNqCxYsiMceeywee+yx2G233aJPnz5x3HHHRfPmzSulfgAA+KmfLGFL1bBhxdUBAAAAAAAAAAAAAAAAUFuU4d261UezZs3ivPPOi1dffTUGDRoUZ511VjRu3DgSiUQkEonIyMgo/vNj3+TJk+OOO+6IQw45JK688sp49913Y926dZX9pQAAUIulGsLQoEEiMmvkyh4AAAAAAAAAAAAAAABgy6pb2QVUtC5dukSXLl3itttui7fffjsGDRoUn3zySVIYQ0QUhzEUFBTEe++9F++99140bdo0jjvuuEr+CgAAqK1SDVbIzq7YOgAAAAAAAAAAAAAAAABqixofwvCj+vXrx8knnxwnn3xyzJ49OwYOHBivvPJKLFy4MCKiOIwh4odAhoiIZcuWxYsvvhgZGRnFfbAx33zzTUyePDkWLlwYRUVFkZOTEx06dIg99tgj6tatNb9mAECapRrC0LChtSoAAAAAAAAAAAAAAABAOmQkanG6QFFRUXz44Yfx8ssvx3/+859Yt25dUhhDxA+BDD/2JRKJyMrKiqOOOipOOumkOPjggyMz1SfjarnZs2fHxIkT47PPPouJEyfGl19+GWvWrCne3rNnz3jmmWfKNfecOXPiiCOO2Kz6pkyZUuZ9EolEDBo0KB577LGYOXPmRsfk5OTE2WefHZdddllkV8FXVC9atKKyS4AkWVl1ktr5+YWVVAlA1VBUFHH00aWvITp0KIq//31NqeOAimc9AwBUZ9YyAEB1Zz0DAFR31jMAQHVmLQMAVHfWM1Q3rVo1qewSoEarW9kFVKbMzMw49NBD49BDD40lS5bEK6+8EoMGDYrp06dHRERGRkZSAENERH5+fvzrX/+Kf/3rX9GiRYs47rjj4sQTT4xu3bpV2tdRVQ0bNiwGDBgQEydOjKVLl1Z2OWm1fPnyuP7662PEiBEljsvNzY2HH3443nzzzXj44YejQ4cOW6hCAKAmWC8fbJOys2ttrhoAAAAAAAAAAAAAAABAWmVWdgFVRYsWLeLiiy+Of/3rX/HCCy9Enz59omHDhpFIJCKRSBQHMmRkZBT3LV68OJ599tk488wz45hjjomHH3445syZU9lfSpUxatSoeP/992tcAMOaNWvi4osv3iCAoV69erHjjjvGrrvuGtnZyW+snj17dpx//vnx7bffbslSAYBqLiMjtSCGhg0rvhYAAAAAAAAAAAAAAACA2qBuZRdQFXXv3j26d+8ev/71r2PIkCExaNCg+PTTTyMiioMYfpRI/PDW4ZkzZ8aDDz4YDz74YHTv3j2ef/75yii92sjOzo68vLwKmfuggw6Kiy++uELmjojo169fTJw4sbidmZkZv/jFL6Jv377RrFmziIjIz8+PN998M+6+++5YtmxZREQsWbIkrr/++hg4cGDUqVOnwuoDAGqWjIyI/1tyblKjRqUMAAAAAAAAAAAAAAAAACAlQhhKkJ2dHaeffnqcfvrpMW3atBg4cGC8/vrrsXjx4ojYdCDDhAkTKqXeqionJyd233336Nq1a3Tt2jW6desWH374Ydx2220VcrxWrVrFAQccUCFzT5s2LV5++eWkvnvvvTdOOOGEpL6srKzo06dPdO3aNc4555xYvnx5RER88cUX8eqrr8app55aIfUBADVPZmZEUVHJY7Kzt0wtAAAAAAAAAAAAAAAAADWdEIYUtW/fPm655Za48cYbY/jw4TFo0KD46KOPorCwsDiIISMjoziIgYgzzjgjzjvvvNh+++0ru5S0eeihh6KwsLC4ffLJJ28QwPBTHTp0iJtvvjl+/etfF/f97W9/i5NOOinq1atXobUCALVHw4bWoAAAAAAAAAAAAAAAAADpkFnZBVQ3devWjZ/97Gfxj3/8I4YPHx7XXXddbLfddpFIJAQwrKdDhw41KoBh2bJl8e677xa3MzIy4pprril1v1NPPTXatm1b3J47d26MHDmyQmoEAGqe/8v7KlGjRtahAAAAAAAAAAAAAAAAAOkghGEztG7dOq644op4991345///GeceOKJUb9+/couiwryn//8J9atW1fc7tmzZ7Rr167U/TIzM6NPnz5JfcOGDUt7fQBAzZSZWXrAQsOGW6AQAAAAAAAAAAAAAAAAgFpACEOa7LvvvnHvvffGRx99FL/5zW8quxwqwPvvv5/UPuigg1Le94ADDkhqv/fee2mpCQCo+TJTWLE3bFh6UAMAAAAAAAAAAAAAAAAApRPCkGZNmjSJc845p7LLoAJ8+eWXSe3u3bunvO/uu+8eWVlZxe2FCxfGkiVL0lYbAFBzrVuXUeqYRo22QCEAAAAAAAAAAAAAAAAAtUDdyi4AKsq8efNi0aJFkZ+fH82aNYuWLVtGixYtyjVXQUFBzJo1K6mvffv2Ke+flZUV22+/fUydOrW4b9q0aeWuBwCoPQoKSh/TsGGi4gsBAAAAAAAAAAAAAAAAqAWEMFDjfPTRR3HQQQfFokWLNtjWtm3b2HfffeOMM86I7t27pzzn7NmzY926dcXtBg0alDlAoU2bNkkhDDNmzIh99tmnTHMAAGxMdnZlVwAAAAAAAAAAAAAAAABQMwhhoMbZWPjCj+bOnRuDBw+OwYMHx3777Rf9+vWLbbfdttQ5lyxZktRu3bp1metaf5/FixeXeY50y8qqU9klQJK6df1MAqwvI6P0MTk5mZGVlcJAoMJZzwAA1Zm1DABQ3VnPAADVnfUMAFCdWcsAANWd9QwAP5VZ2QVAZRk1alT07t07Pvnkk1LHrlq1KqndsGHDMh8ve71XVOfl5ZV5DgCAjWnYMFHZJQAAAAAAAAAAAAAAAADUCHUruwBIlzZt2sThhx8e++23X3To0CG23nrraNiwYaxYsSLmzJkTo0ePjhdffDFmz55dvE9ubm5ceeWV8eKLL0b79u03Off6gQn169cvc33r7yOEAQBIl/WyngAAAAAAAAAAAAAAAAAoJyEMVHtNmjSJhx9+OA477LDIzMzcYHvz5s2jefPm0bVr17jwwgvj73//e/z973+PoqKiiIhYvnx53HTTTTFo0KDIyMjY6DHWrl2b1K5Xr16Z68zKykpqr1mzpsxzAABsjBAGAAAAAAAAAAAAAAAAgPQQwlAD3XnnndG/f/8KP87VV18d11xzTYUfpzTNmjWLXr16pTS2Tp06cc0110TTpk3jrrvuKu6fPHly/Pvf/46jjz56o/vVr18/qV1QUFDmOvPz80ucszLk5xdWdglQIj+jABGJROljCgsLo9BHJlRJ1jMAQHVmLQMAVHfWMwBAdWc9AwBUZ9YyAEB1Zz0DULtlVnYBUBkuuOCC6NmzZ1Lfa6+9tsnx2eu9Xnrt2rVlPub6+6w/JwAAAAAAAAAAAAAAAAAAAJVLCAO11oUXXpjUHjVqVKxbt26jYxs1apTUXr16dZmPl5eXl9QWwgAAAAAAAAAAAAAAAAAAAFC11K3sAki/ww47LJo3b17hx9lnn30q/BgVab/99ouMjIxIJBIREbFq1apYtGhRbLPNNhuMbdGiRVJ7wYIFZT7e+vu0bNmyzHMAAAAAAAAAAAAAAAAAAABQcYQw1EAHHnhgHHjggZVdRpWXnZ0dzZo1i9zc3OK+JUuWbDSEoV27dlG3bt1Yt25dRESsWbMmlixZskE4Q0nmzZuX1N55553LVzgAAAAAAAAAAAAAAAAAAAAVIrOyC4DKVLducg7JjyEL66tXr160a9cuqW/q1KkpHyc/Pz9mz56d1CeEAQAAAAAAAAAAAAAAAAAAoGoRwkCttW7dusjNzU3qa9GixSbHd+7cOak9YcKElI81adKkyM/PL263atUqWrZsmfL+AAAAAAAAAAAAAAAAAAAAVDwhDNRan376aaxbt664Xbdu3dhqq602Of6www5Lao8YMSLlY40cOTKp3atXr5T3BQAAAAAAAAAAAAAAAAAAYMsQwkCtNWjQoKT2nnvuGQ0bNtzk+EMPPTTq1q1b3B4zZkzMnj271OMkEokYPHhwUt8RRxxRxmoBAAAAAAAAAAAAAAAAAACoaEIYqJVGjx4dr732WlLfkUceWeI+OTk5SeEJiUQiHnrooVKPNXDgwJg7d25xu23btrH//vuXsWIAoLbafffCErefc07BFqoEAAAAAAAAAAAAAAAAoOYTwkC1NmLEiBg0aFCsW7cu5X0+/vjjuOaaa6Kw8L8PNLZq1SrOOuusUve99tprIzPzv782r732Wrz55pubHD916tS45557kvquuOKKyMrKSrleAKB269KlqMTthx6a+joIAAAAAAAAAAAAAAAAgJLVrewCqNlGjhy50f6pU6cmtZctW7bJse3atYt27dptdNuCBQviV7/6VfzlL3+JY445Jnr16hVdunSJJk2aJI0rLCyMSZMmxfPPPx+vv/56FBX992HGzMzM+J//+Z9o2LBhqV/PLrvsEqeffnoMGDCguO+mm26KadOmRd++faNZs2YREVFQUBBvvPFG3H333bF8+fLisR07dozevXuXehwAgB+dcsq6eOedupGbm7HBtgMOKIyddkpUQlUAAAAAAAAAAAAAAAAANVNGIpHw1BYVpmPHjps9x9VXXx3XXHPNRrcNHjw4brvttg36W7duHc2aNYvs7OxYuXJlfPfdd5GXl7fBuIyMjLj99tvjvPPOS7me1atXx7nnnhuTJk1K6q9Xr15st912kZWVFbNnz97geM2bN48XXnghdtppp5SPVdEWLVpR2SVAkqysOknt/PzCSqoEoGqZMiUz/vKXrPjmm8yIiMjMjDjssHVxww350aBBJRcHJLGeAQCqM2sZAKC6s54BAKo76xkAoDqzlgEAqjvrGaqbVq2alD4IKLe6lV0AVIQFCxbEggULShzTqlWr+OMf/xgHHnhgmeZu2LBhPPHEE3HdddfFqFGjivsLCgpixowZG92nbdu28fDDD1epAAYAoPro2LEo/va3NTFtWkasXp0RrVsnYuutZakBAAAAAAAAAAAAAAAApJsQBqq1/fbbL6655poYPXp0TJ48OVatWlXi+MzMzOjcuXOcccYZcfLJJ0fDhg3LddycnJx46qmnYuDAgfH444/Ht99+u8lxZ511Vlx22WXRqFGjch0LACAiIiMjYpddEhEhfAEAAAAAAAAAAAAAAACgomQkEglPcVEjJBKJmDVrVnz77bcxf/78WL58eaxduzays7OjadOmsc0220S3bt2icePGaT/2lClT4osvvohFixZFYWFh5OTkRIcOHWKPPfaIevXqpf146bJo0YrKLgGSZGXVSWrn5xdWUiUAAOVjPQMAVGfWMgBAdWc9AwBUd9YzAEB1Zi0DAFR31jNUN61aNansEqBGE8IAtZgQBqoa/1gBAKo76xkAoDqzlgEAqjvrGQCgurOeAQCqM2sZAKC6s56huhHCABUrs7ILAAAAAAAAAAAAAAAAAAAAAKgKhDAAAAAAAAAAAAAAAAAAAAAAhBAGAAAAAAAAAAAAAAAAAAAAgIgQwgAAAAAAAAAAAAAAAAAAAAAQEUIYAAAAAAAAAAAAAAAAAAAAACJCCAMAAAAAAAAAAAAAAAAAAABARAhhAAAAAAAAAAAAAAAAAAAAAIgIIQwAAAAAAAAAAAAAAAAAAAAAESGEAQAAAAAAAAAAAAAAAAAAACAihDAAAAAAAAAAAAAAAAAAAAAARIQQBgAAAAAAAAAAAAAAAAAAAICIEMIAAAAAAAAAAAAAAAAAAAAAEBFCGAAAAAAAAAAAAAAAAAAAAAAiQggDAAAAAAAAAAAAAAAAAAAAQEQIYQAAAAAAAAAAAAAAAAAAAACICCEMAAAAAAAAAAAAAAAAAAAAABEhhAEAAAAAAAAAAAAAAAAAAAAgIoQwAAAAAAAAAAAAAAAAAAAAAEREREYikUhUdhEAAAAAAAAAAAAAAAAAAAAAlS2zsgsAAAAAAAAAAAAAAAAAAAAAqAqEMAAAAAAAAAAAAAAAAAAAAACEEAYAAAAAAAAAAAAAAAAAAACAiBDCAAAAAAAAAAAAAAAAAAAAABARQhgAAAAAAAAAAAAAAAAAAAAAIkIIAwAAAAAAAAAAAAAAAAAAAEBECGEAAAAAAAAAAAAAAAAAAAAAiAghDAAAAAAAAAAAAAAAAAAAAAARIYQBAAAAAAAAAAAAAAAAAAAAICKEMAAAAAAAAAAAAAAAAAAAAABEhBAGAAAAAAAAAAAAAAAAAAAAgIgQwgAAAAAAAAAAAAAAAAAAAAAQEUIYAAAAAAAAAAAAAAAAAAAAACJCCAMAAAAAAAAAAAAAAAAAAABARAhhAAAAAAAAAAAAAAAAAAAAAIgIIQwAAAAAAAAAAAAAAAAAAAAAESGEAQAAAAAAAAAAAAAAAAAAACAihDAAAAAAAAAAAAAAAAAAAAAARIQQBgAAAAAAAAAAAAAAAAAAAICIEMIAAAAAAAAAAAAAAAAAAAAAEBFCGAAAAAAAAAAAAAAAAAAAAAAiQggDAAAAAAAAAAAAAAAAAAAAQEQIYQAAAAAAAAAAAAAAAAAAAACICCEMAAAAAAAAAAAAAAAAAAAAABEhhAEAAAAAAAAAAAAAAAAAAAAgIoQwAAAAAAAAAAAAAAAAAAAAAESEEAYAAAAAAAAAAAAAAAAAAACAiBDCAAAAAAAAAAAAAAAAAAAAABARQhgAAAAAAAAAAAAAAAAAAAAAIiKibmUXAED1NWvWrJg4cWLMnz8/CgoKomnTprHzzjtHjx49on79+pVWVyKRiMmTJ8eXX34ZS5YsiYiIli1bRqdOnaJLly6RkZFRabUBAFVHVV3LAABUd87NAAAAADVVIpGIOXPmxNdffx3z58+PFStWRFZWVjRt2jR23HHH6Nq1a5W4zrRu3br47LPP4ptvvonc3NzIzMyMrbfeOrp06RIdOnSo7PIAgEpSXdYyAACbkp+fH9OnT4+5c+fGggULYtWqVbFu3bpo3Lhx5OTkRMeOHaN9+/ZRp06dSq3zm2++icmTJ8fChQujqKgocnJyokOHDrHHHntE3boe6QWoLnxiA1BmQ4cOjb///e8xefLkjW7Pzs6OPn36xFVXXRUtWrTYYnUVFBRE//7945///GcsWLBgo2PatGkTF1xwQZx33nlRr169LVYbAFB1VKW1zHnnnRdjxowp9/79+vWLPn36pLEiAKCqW7BgQUycODE+++yzmDhxYkyaNClWrVpVvL1t27YxfPjwSqnNuRkAAACgJlq2bFkMHTo0Pvzwwxg1alQsXbp0k2Pr1asXhx56aFxwwQXRs2fPLVjlD1atWhWPPvpovPjii5Gbm7vRMTvttFNceuml0adPH2GZAFALVPW1TK9evWLu3Lnl3r9///6x7777prEiAKCqefvtt2PkyJExYcKEmD59eqxbt67E8U2aNInjjz8+zj///Gjfvv0WqvKHwKtBgwbFY489FjNnztzomJycnDj77LPjsssui+zs7C1WGwDlk5FIJBKVXQQA1UN+fn786le/ijfeeCOl8S1atIgHH3ww9tlnnwquLGLevHlx5ZVXxhdffJHS+C5dusTDDz8crVu3ruDKAICqoiquZYQwAACpGDduXDz11FPx2WefxcKFC0scW1khDM7NAACpqmqhUs7PAAAl+d3vfhcvv/xyFBQUlHnfU045JX7zm99E48aNK6CyDU2ZMiWuvPLKmDNnTkrjDzrooPjzn/8cTZo0qeDKAIDKUh3WMkIYAIDSHHLIIZt8GUhJ6tWrF5dffnlcffXVFR5EuXz58rj++utjxIgRKY1v165dPPzww9GhQ4cKrQuAzZNZ2QUAUD0UFRXF9ddfv8FDi3Xq1IntttsuOnfuvMFF2SVLlsSll14aEyZMqNDaFi9eHOeff/4GN/k3aNAgOnToEO3bt4/69esnbZs8eXKcf/75sWTJkgqtDQCoGqryWgYAoDSff/55vPvuu6UGMFQW52YAgNKMGzcurr766jj44IPjkEMOiauvvjoee+yxGD16dFIAAwBAVfPZZ59t9KHFOnXqRJs2baJLly7RsWPHjQYZvPrqq3HhhRdukfXO9OnT44ILLtgggCE7Ozs6duwYO+64Y9SrVy9p20cffRSXXnpprF27tsLrAwAqR3VZywAAlFX9+vVjxx13jK5du0aXLl2ibdu2GwQtFBQUxF//+te4/fbbK7SWNWvWxMUXX7xBAEO9evVixx13jF133TWys7OTts2ePTvOP//8+Pbbbyu0NgA2T93KLgCA6uHxxx+PYcOGJfWdddZZceWVVxa/sbCoqCiGDRsWd911V3z33XcREbF69eq4/vrr480336yw5Pxbb701Zs2aVdyuX79+3HjjjXHGGWdEw4YNIyIiLy8vXnrppbj//vuLLx7PnDkzfvWrX8UjjzxSIXUBAFVHVV7L/NRTTz1VpvG77LJLBVUCAFQX2dnZkZeXV6k1ODcDAJTmx1ApAIDqrGnTpnHCCSfEYYcdFnvttVfSW6ELCwtj7Nix8eCDD8bYsWOL+ydOnBi33XZbPPjggxVW17p16+K6666LpUuXFvfl5OTEbbfdFscff3xx+EJubm489dRT8eijj0ZRUVFEREyYMCHuvffe+PWvf11h9QEAVUNVXcv81FZbbRX33ntvmfbp1KlTBVUDAFQlW2+9dRx22GGx9957R/fu3WO77baLzMzk95MvW7Ys3nnnnfjb3/4W8+fPL+4fNGhQ7LXXXnHqqadWSG39+vWLiRMnFrczMzPjF7/4RfTt2zeaNWsWERH5+fnx5ptvxt133x3Lli2LiB9eFnf99dfHwIEDo06dOhVSGwCbJyORSCQquwgAqralS5fGEUcckZRme+ONN8Zll1220fELFiyIs88+O+bOnVvcd9VVV8W1116b9to++uijuPjii4vb9erVi6eeeir22WefjY4fM2ZMXHTRRUnJvv/85z9jv/32S3ttAEDVUJXXMuedd16MGTOmuD1lypS0HwMAqP6efvrp6NevXzRq1Ci6dOkSXbt2jW7dukXXrl1jzpw5cf755xePbdu2bQwfPnyL1ebcDACQih/XMxuzfqjUll7PrH9+pjwhmVtvvXW6ywIAqog+ffpEbm5uXHHFFXHiiSdGgwYNShxfWFgYv/vd72LAgAFJ/RV5/mPAgAHx29/+trjdrFmzeP755zcZ5v3GG2/E//t//6+4Xbdu3RgyZEjsuOOOFVIfAFB5qsNaplevXsX36Gzp80IAQPXw1VdfRceOHSMjIyOl8cuWLYsLL7wwJk+eXNzXqlWr+OCDDzYIbthc06ZNixNPPDEKCwuL++6777444YQTNjr+m2++iXPOOSeWL19e3HfXXXdVWEAEAJsnvX9rAFAjPf7440kPLe6zzz5x6aWXbnJ869at484770zqe/rpp5MS99PlL3/5S1L70ksv3eRN/hERPXv2jEsuuSSp789//nPa6wIAqo6qvJYBAEhFr169YsiQITF27Nh45pln4uabb45jjjkm2rZtW9mlOTcDAJRJo0aNomfPnnHxxRfHX/7ylxg+fHg88sgjlV1WkgMOOKBMfwQwAEDNdu2118bbb78dp59+eqkPLUZE1KlTJ/7nf/4ndt9996T+l19+uULqy8/Pj4cffjip7+abb95kAENExIknnhgnnXRScXvdunXx0EMPVUh9AEDlquprGQCAVHTq1CnlAIaIHwIq77333qR9Fi1aFOPHj097bQ899FBSAMPJJ5+8yQCGiIgOHTrEzTffnNT3t7/9LellJgBUHUIYAChRUVFRDB48OKnv6quvLvUfMPvvv3/svffexe1Vq1bFW2+9ldbapkyZEhMnTixuZ2dnJ715cVMuueSSyM7OLm5PmDAhpk2bltbaAICqoSqvZQAAUrX99tvHLrvskvY0/s3l3AwAkKqqHCoFAFCSww47LLKyssq0T506dTYIofzoo4/SWVbSvPPmzStut23bNqU3J15zzTVJ18veeeedWLFiRYXUCABUnqq+lgEAqCjt27ePLl26JPWl+96UZcuWxbvvvlvczsjIiGuuuabU/U499dSka2Rz586NkSNHprU2ANKjat2xCUCVM378+FiyZElxu127drHvvvumtO9pp52W1B42bFhaa1t/vmOOOSYaN25c6n6NGzeOY445Jqlv6NChaa0NAKgaqvJaBgCgunNuBgBIVVUNlQIAqCg/DfuOiMjNzY3Vq1en/Tjrn5/p06dPSm+G3H777WOfffYpbhcUFMT777+f9voAgOppS61lAAAq0vbbb5/UXrp0aVrn/89//hPr1q0rbvfs2TPatWtX6n6ZmZnRp0+fpD73KANUTe5wAKBE619gPeCAA1K6WPvj2J8aPXp05OXlVVhtBx10UMr7rl/be++9l5aaAICqpSqvZQAAqjvnZgAAAAA2rlmzZhv0rVixIu3H2ZzzMwceeGBS2/kZAOBHW2otAwBQkdauXZvUbtKkSVrnd98MQM0nhAGAEn355ZdJ7R49eqS8b+vWraNt27bF7YKCgpg6dWpa6kokEjFlypSkvu7du6e8//pfx5QpUyKRSKSlNgCg6qiqaxkAgOrOuRkAAACATVuwYMEGfTk5OWk9xvfffx+LFi0qbmdlZcVuu+2W8v7rn5/56quv0lYbAFC9bYm1DABARUokEvH5558n9e2+++5pPcb69yiX5b6Z3XffPbKysorbCxcujCVLlqStNgDSQwgDACWaPn16Urt9+/Zl2n+XXXYpcb7ymjt3bqxevbq4nZ2dHdtuu23K+7dt2zYaNmxY3M7Ly4t58+alpTYAoOqoqmuZkqxYsSK++uqr+OSTT2Ly5Mkxd+7cKCwsrPDjAgCUhXMzAAAAAJs2duzYpHbbtm2TbqxPh2nTpiW1d9hhhzIdY/3rYN9++22sW7cuLbUBANXblljLlGTJkiXx5ZdfxieffBJffvllzJs3T5g3AFAmAwcOjIULFxa3d9555+jWrVva5i8oKIhZs2Yl9ZXlHuWsrKzYfvvtk/rWP9cDQOWrW9kFAFB1rVmzJr777rukvm222aZMc7Rp0yapPWPGjM2ua2PzrH+cVLRp0yZpnhkzZpTpYQEAoGqrymuZTTnllFNiypQpUVRUlNSfnZ0dPXr0iKOPPjpOOeWULXphGwBgY5ybAQBqshUrVsTcuXNjxYoVkZ2dHTk5OdGmTZuoU6dOZZcGAFQTgwYNSmofcsghaT/G5p6fadGiRdSvXz/Wrl0bET88PDBnzpzYcccd01UiAFBNbYm1zMYsXrw4jjvuuI0+gJiTkxN77bVXnHDCCXH00Uc7TwMAbNIrr7wSv/vd74rbmZmZ8dvf/jYyMjLSdozZs2cnhVk2aNAgWrRoUaY52rRpE1OnTi1uz5gxI/bZZ5+01QjA5hPCAMAmLV26NCk5tl69etGyZcsyzdG6deuk9uLFi9NS2/rzlOdG/9atWyddkE5XbQBA1VCV1zKb8uWXX260Py8vLz766KP46KOP4sEHH4zbb789jj322AqtBQCgJM7NAAA1lZBMAGBzvf/++/HJJ58k9fXp0yftx0nH+Zmtt946Zs+enTSnEAYAqN221FpmY9asWbPJN0Dn5ubGsGHDYtiwYbH99tvHnXfeGT179twidQEAVcuMGTNi3rx5xe2CgoJYvnx5fPPNNzFs2LCkYIN69erFH/7wh9h///3TWsOSJUuS2uvfb5yKLX2PMgBlJ4QBgE3Ky8tLajdo0KDMyW/Z2dklzlle68/TsGHDMs+x/j7pqg0AqBqq8lpmcyxatCiuv/76mDhxYtxyyy2VXQ4AUEs5NwMA1FRCMgGAzZGbmxu//e1vk/qOPPLI6NatW9qP5fwMAJBuW3ItszlmzZoVffv2jVtuuSUuuOCCyi4HANjCnn/++ejfv3+JYzIyMuLggw+OG2+8MTp16pT2GlatWpXULs95map4jzIAyYQwALBJ6/+joH79+mWeY/19KiqEoTy1NWjQoMQ5AYDqrSqvZdY/xgEHHBCHHHJIdO7cOXbYYYdo0qRJ5Ofnx5IlS2LChAkxZMiQeP/99yORSBTv9+STT0bz5s3jsssuS3tNAAClcW4GAKjNhGQCABtTVFQUN910U8yfP7+4r0mTJvHrX/+6Qo7n/AwAkE5bei3zU40bN46DDz44DjrooOjUqVNst9120bhx41izZk0sWLAgJkyYEIMHD45x48YV71NYWBj9+vWLrbbaKo4//vgKrxEAqF6OOeaYOO+88yokgCEiPedltsQ9ygBsHiEMAGxSfn5+UrtevXplniMrKyupvWbNms2q6Udr165Nalel2gCAqqEqr2V+1Ldv3+jRo0c0b958g2316tWLRo0aRbt27eKkk06KsWPHxi9/+ctYsGBB8Zj7778/DjnkkAo7SQwAsCnOzQAANYmQTAAgHe6555744IMPkvp+//vfxzbbbFMhx3N+BgBIpy29lvnRTTfdFIccckg0atRog22NGzeOxo0bR/v27eO0006Ld999N371q1/F8uXLIyIikUjE7bffHj179oxWrVpVaJ0AQPXy1ltvxVtvvRV777133HXXXbHDDjukdX7nZQBqh8zKLgCAqmv9BX1BQUGZ51j/4cfypLttzPrzVKXaAICqoSqvZX50xBFHbDSAYWP23nvveOaZZ5LGJxKJ+POf/5zWmgAAUuHcDABQU/Tt2zfef//9eOSRR+Kcc86J7t27R4sWLTYIyPzHP/4Rzz77bLRu3Tpp//vvvz+++uqrSqoeAKgq+vfvH0899VRS3yWXXBLHHXdchR3T+RkAIF0qYy3zo2OPPXajAQwbc9RRR8Vjjz0WDRo0KO5bvXp1PPLIIxVVHgBQBd1+++0xZcqU4j+fffZZvP/++/GPf/wjTjvttKS1wtixY+O0006Lzz//PK01OC8DUDsIYQBgk9Y/qbl+Ulsq1t8nOzt7s2ra1DzlqW39lLh01QYAVA1VeS1TXjvssEPcfPPNSX3vv/9+5ObmVk5BAECt5dwMAFBTCMkEADbXG2+8EXfddVdSX58+feL//b//V6HHdX4GAEiHylrLlNeee+4Zl1xySVLfm2++GUVFRZVUEQBQ2Ro0aBBt2rSJww47LO688854/fXXo3PnzsXbly9fHldddVUsX748bcdMx3mZqnaPMgAbEsIAwCatv4Bfs2ZNJBKJMs2Rl5dX4pzltf48q1evLvMc6+/jHywAULNU5bXM5jjllFOiRYsWxe2ioqIYOXJkJVYEANRGzs0AALWVkEwA4Kfee++9uPXWW5OuQf3sZz+LO+64IzIyMir02M7PAACbqzLXMpvj/PPPjzp16hS3c3NzY9KkSZVYEQBQleywww7x5JNPxjbbbFPct2DBgnjiiSfSdoz1XxRXnvMyVfEeZQCSCWEAYJOaN2+edBK1oKAgFi9eXKY5FixYkNRu2bJlWmpbf5758+eXeY6Kqg0AqBqq8lpmc2RmZkbPnj2T+mbMmFFJ1QAAtZVzMwBAbSYkEwCIiBg1alRcd911sW7duuK+Aw88MO67776khwIrSjrOzyxcuLDEOQGAmquy1zKbo1mzZrHbbrsl9U2fPr2SqgEAqqIWLVrENddck9Q3ePDgtM7/U+vfA5MK980AVH1CGADYpAYNGsS2226b1Pfdd9+VaY558+YltXfeeefNrisiYqeddkpql+dC8vr7pKs2AKBqqMprmc3103TeiIilS5dWUiUAQG3l3AwAUJsJyQQAPvvss7jiiiti7dq1xX3du3ePv/71r5GVlbVFalj//Mz617VKs3jx4qT669WrF+3atUtLbQBA1VYV1jKby70zAEBpjjrqqKSXuS1cuDDmzp2blrnbtWsXdevWLW6vWbMmlixZUqY5quo9ygD8lxAGAEq0/gXbadOmlWn/9cen6x8Fbdu2jQYNGhS38/LyyvSPoblz58bq1auL29nZ2RuckAUAqr+qupbZXD89cRsRUVBQUEmVAAC1lXMzAEBt50Z/AKi9vvrqq7j00ksjLy+vuG+33XaLxx57LLKzs7dYHetft5o1a1bk5+envP/618G23377Da5BAQA1T1VZy2wu984AAKVp2rRpNGvWLKnv+++/T8vcGwuznDp1asr75+fnx+zZs5P6qso9ygD8lxAGAErUuXPnpPaECRNS3nf9lLh69epF+/bt01JXRkZGdOzYsdy1jR8/PqndsWPHpIQ7AKBmqKprmc21/kngFi1aVFIlAEBt5dwMAFDbudEfAGqn6dOnx0UXXRTLli0r7mvfvn088cQT0aRJky1aS6tWraJVq1bF7fz8/Jg8eXLK+69/fmb962oAQM1TldYym8u9MwBAeaTcK83sAAEAAElEQVQzgHJz7lGeNGlSUphmq1atomXLlmmrDYD0EMIAQIkOO+ywpPbIkSMjkUiktO+IESOS2vvuu280atQoXaVtUNv6xyvJyJEjk9qHH354OkoCAKqYqryW2Rzjxo1LantrNABQGZybAQBqMzf6A0DtM3fu3Ljwwgtj8eLFxX3bbbddPPXUU5W2Fjj00EOT2mU5P7P+WOdnAKBmq4prmfLKz8+Pzz//PKnPvTMAwPpWrlyZFD4VEbHVVlulbf503jfTq1evdJQEQJoJYQCgRD169IjmzZsXt2fPnh2jR49Oad+BAwcmtdP9j4L153v77bdj1apVpe63cuXKePvtt5P6jjjiiLTWBgBUDVV5LVNeY8aMiVmzZiX17b///pVUDQBQmzk3AwDUZkIyAaB2WbhwYfTt2zfmz59f3Ne6det4+umno3Xr1pVW1/rnZwYPHpxSIPmsWbPik08+KW7Xq1dvg0AHAKDmqKprmfIaMmRIrF69uridlZUVPXr0qMSKAICq6P333086T9KiRYto1apV2uY/9NBDo27dusXtMWPGxOzZs0vdL5FIxODBg5P63DcDUDUJYQCgRJmZmdG7d++kvr/97W+lXrD9+OOPY+zYscXtRo0axbHHHpvW2jp16hRdu3Ytbufl5cXjjz9e6n6PP/545OXlFbf33HPP2GWXXdJaGwBQNVTltUx55OXlxR133JHUt+uuu0a7du0qqSIAoDZzbgYAqK2EZAJA7ZKbmxsXXXRR0t//LVq0iKeeeqrSr9EcfPDB0aZNm+L23LlzY9CgQaXu99BDDyVdL/vZz34WTZo0qZAaAYDKVZXXMuWxaNGieOCBB5L6DjzwwGjYsGElVQQAVEVr1qyJBx98MKnvsMMOi8zM9D1Om5OTkxSekEgk4qGHHip1v4EDB8bcuXOL223btnWdCaCKEsIAQKkuvfTSyM7OLm6PGTMmHnvssU2OX7BgQdx+++1Jfeeff360aNGixON07Ngx6U8qb6m+9tprk9qPPfZYUlL/+saMGbPBwwDXX399qccBAKqvqrqWueOOO2LBggUpfAU/WLJkSVxxxRUxZcqUpP7110MAAOXl3AwAQOmEZAJA7bJy5cq45JJL4ptvvinua9q0aTz55JPRvn37tB5rzpw5G5yfmTNnTon7ZGVlxS9+8YukvnvuuSemTp26yX3eeOONeP3114vbderUiWuuuWbzigcAqqSqvJZZuHBhPPjgg7Fs2bIyHeOSSy5Jut8mIyPDWgYAarB77rknJk6cWKZ9cnNz44orroiZM2cW99WpUyf69u1b4n69evVKWssMHjy41GNde+21ScEOr732Wrz55pubHD916tS45557kvquuOKKyMrKKvVYAGx5dSu7AACqvhYtWsQvfvGLuP/++4v77rvvvvjuu+/iiiuuiNatW0dERFFRUQwfPjzuvPPO+O6774rHbr311nHRRRdVSG2HHHJIHHTQQfHRRx9FRERBQUFcfPHFceONN8YZZ5xRnGybl5cXL730Utx///1RUFBQvP+hhx4qMQ4AariqupZ55plnYsCAAXHIIYfE0UcfHT169Ijttttug3Hz5s2LIUOGxNNPPx2LFi1K2nbkkUfGUUcdlfbaAICqZ9y4cbF27doN+r/66quk9tq1a2PkyJEbnWPrrbeOXXbZJa11OTcDAFQlHTt2TGr3798/9t13302Ov+OOO+LSSy8tPj9UmiVLlsQNN9wgJBMAapErrrgiPv/886S+vn37xtKlSzd5DmZTunTpEs2aNUtneRERcdppp8Vzzz1X/HDlsmXL4uc//3ncdtttccIJJ0Tduj/cJpqbmxtPP/10/OMf/0ja/8wzz4yddtop7XUBAJWvKq9l8vPz429/+1s89dRT0atXrzj66KNjjz322Oh5mm+//TYGDx4czz33XKxYsSJp2/nnnx9dunRJW10AQNUyYsSIeOKJJ6Jbt25x3HHHxX777Re77LJL1KtXL2lcIpGI6dOnx9tvvx3PPPNMLF26NGn7BRdcsMF1pHTYZZdd4vTTT48BAwYU9910000xbdq06Nu3b/H6qaCgIN544424++67Y/ny5cVjO3bsGL179057XQCkR0YikUhUdhEAVH1FRUVx5ZVXxnvvvZfUX6dOndh2222jSZMmMWfOnKR/DERENGjQIJ588snYa6+9Sj1GWW+M+9H3338fZ5555gaJuQ0aNIh27dpFIpGI2bNnb/Cgwvbbbx8DBgwo9a3WAED1VxXXMhs7mdu4ceNo1apVNGnSJNatWxfff/99LFy4cKP777333vHEE09EgwYNSq0NAKj+evXqFXPnzt2sOXr37h133333Jrc7NwMAVKSSQqX++Mc/Fre32mqruPfeezc6R2mhUuU5P5OVlbXZIZl/+9vfNnkMAKB6S+fN+aWtTebMmRNHHHFEUt+wYcM2uj5Z37Rp0+Kcc86J3NzcpP7s7OzYfvvtY82aNTF37tykcMyIiG7dusUzzzzjehMA1FBVeS2zsfERETk5OdGyZcto3LhxrFmzJhYtWhRLlizZ6BzHHHNMPPDAA0lvnwYAapaTTz55gxeU1KtXL1q3bh1NmzaNevXqxapVq2LevHmxatWqjc7Ru3fvuOuuu0pdM6x/b06/fv2iT58+pda4evXqOPfcc2PSpEkb1LnddttFVlZWzJ49O/Ly8pK2N2/ePF544QXhmABVWN3KLgCA6iEzMzP+8pe/xG233RZDhgwp7i8sLIzZs2dvdJ+cnJx48MEHU3pocXNstdVW0b9//7jyyiuT/nG1Zs2a4pT/9XXu3DkefvhhN/kDQC1RldcyP7Vy5cpYuXJliWMyMzPjoosuiuuvv36DJF8AgMrg3AwAkIqbbroppVCp77//Pi688MKNbistVKo88vPzY+jQoTF06NCIKHtI5n333ZfWegAAyqN9+/bxz3/+M6688sqkNVdeXt4GDyr86IADDoi//OUvAhgAgColNzd3g2Cp9WVlZcUvf/nL6Nu3b2RkZGyZwgCAKqOgoGCDF4VsTOPGjePGG2+Ms88+u0LXDA0bNownnngirrvuuhg1alRSnTNmzNjoPm3bto2HH35YAANAFSeEAYCU1a9fP+6///44+uij4+GHH44vv/xyo+Oys7PjlFNOiauvvjpatmy5RWpr27ZtvPzyy/HPf/4z+vfvv8mb4bbeeuu44IIL4vzzz4+srKwtUhsAUDVUtbXMH/7whxg1alSMHz8+5s2bV+r4Vq1axbHHHhvnnntu7LDDDhVWFwBAeTg3AwDUFEIyAYDqqlOnTvH666/Ho48+Gi+++GIsW7Zso+N23HHHuOSSS+K0007z0CIAUGm22mqruP3222P06NHx6aefxvfff1/qPm3bto2TTjopzj777GjduvUWqBIAqGz3339/DB8+PEaOHBkTJ04s9RpORkZG7LrrrnHyySdH7969t9jLQXJycuKpp56KgQMHxuOPPx7ffvvtJsedddZZcdlll0WjRo22SG0AlF9GIpFIVHYRAFRP3377bXz22WexYMGCKCgoiKZNm0b79u2jR48eUb9+/Uqrq6ioKCZNmhRTpkyJxYsXR0REy5Yto1OnTtGlS5fIzMystNoAgKqjKq1lli5dGtOmTYvvvvsulixZEqtXr446depE06ZNo3nz5rHbbrtFu3bttmhNAADl5dwMALAxvXr1Snorc3n07t077r777k1u79ixY1K7f//+se+++25y/EsvvSQkEwCokQoKCuKzzz6Lb775JnJzc6NOnTrRqlWr2G233TZYMwEAVAULFy6MGTNmxLx582Lp0qWxevXqqFevXjRr1ixatGgRXbt2FbwAALVcUVFRzJw5M2bNmhXfffddrFy5MtatWxeNGjWKJk2aRNu2baNLly7RuHHjyi41pkyZEl988UUsWrQoCgsLIycnJzp06BB77LGHgG+AakQIAwAAAAAAAABQqwnJBAAAAAAAAAB+JIQBAAAAAAAAAAAAAAAAAAAAICIyK7sAAAAAAAAAAAAAAAAAAAAAgKpACAMAAAAAAAAAAAAAAAAAAABACGEAAAAAAAAAAAAAAAAAAAAAiAghDAAAAAAAAAAAAAAAAAAAAAARIYQBAAAAAAAAAAAAAAAAAAAAICKEMAAAAAAAAAAAAAAAAAAAAABEhBAGAAAAAAAAAAAAAAAAAAAAgIgQwgAAAAAAAAAAAAAAAAAAAAAQEUIYAAAAAAAAAAAAAAAAAAAAACJCCAMAAAAAAAAAAAAAAAAAAABARAhhAAAAAAAAAAAAAAAAAAAAAIgIIQwAAAAAAAAAAAAAAAAAAAAAESGEAQAAAAAAAAAAAAAAAAAAACAihDAAAAAAAAAAAAAAAAAAAAAARIQQBgAAAAAAAAAAAAAAAAAAAICIEMIAAAAAAAAAAAAAAAAAAAAAEBFCGAAAAAAAAAAAAAAAAAAAAAAiQggDAAAAAAAAAAAAAAAAAAAAQEQIYQAAAAAAAAAAAAAAAAAAAACICCEMAAAAAAAAAAAAAAAAAAAAABEhhAEAAAAAAAAAAAAAAAAAAAAgIoQwAAAAAAAAAAAAAAAAAAAAAESEEAYAAAAAAAAAAAAAAAAAAACAiBDCAAAAAAAAAAAAAAAAAAAAABARQhgAAAAAAAAAAAAAAAAAAAAAIkIIAwAAAAAAAAAAAAAAAAAAAEBECGEAAAAAAAAAAAAAAAAAAAAAiAghDAAAAAAAAAAAAAAAAAAAAAARIYQBAAAAAAAAAAAAAAAAAAAAICKEMAAAAAAAAAAAAAAAAAAAAABEhBAGAAAAAAAAAAAAAAAAAAAAgIgQwgAAAAAAAAAAAAAAAAAAAAAQEUIYAAAAAAAAAAAAAAAAAAAAACJCCAMAAAAAAAAAAAAAAAAAAABARAhhAAAAAAAAAAAAAAAAAAAAAIiIiLqVXQAAAACpGzx4cNx2222ljmvbtm0MHz58C1QEUDajR4+O888/P6WxU6ZMqeBqys7nMAAAAAAAAKSmV69eMXfu3FLH9evXL/r06bMFKgK2pOp+fwBQsz300EPx17/+tdRxPXv2jGeeeWYLVAQAQFUjhAEAAAAAAAAAAAAAAKhwc+fOjQ8//DA+//zz+PLLL2Pp0qWxfPnyWL16ddSvXz+ys7OjRYsW0bZt22jbtm106NAhOnfuHB07dowGDRpUdvkAAABALSGEAQAAICJuvfXWeOWVVzZ7noyMjGjUqFE0adIkmjRpEi1btozOnTtH165do2vXrtGuXbs0VAu1x+DBg+O2225Ly1wNGzYs/t1s1qxZdOjQIbp27Rq77757dOzYMTIzM9NyHAAAAAAAANJzDbZOnTpRr169aNiwYTRt2jS22mqr2GabbWLnnXeOTp06xV577RU5OTnpKZgKleqbhtd37LHHxp///Oe01PDRRx/FxRdfXOb92rZtG8OHD09LDVCbjRgxIp588skYOXJkFBUVbXRMXl5e5OXlxffffx9ff/110ra6devG7rvvHvvtt1/87Gc/iy5dumyJssvsxhtvjDfffLPUcdttt10MGzasXMe49NJL44MPPkhp7Icffhhbb711mY/xyCOPxAMPPFDquKZNm8bo0aPdc1GDdOzYMeWxU6ZMqcBKAAAAKpcQBgAAgDRKJBKxcuXKWLlyZcybNy8iIj7++OPi7d26dYszzjgjjjvuuGjUqFFllUmaDR06NL788stSx3Xu3DmOPPLILVARG7N69epYvXp1LFy4MCIixo8fHwMGDIiIH26cOvXUU+O0006L1q1bV2aZlMOXX34ZQ4cOLXVckyZNom/fvhVfEAAAAAAAkBaFhYVRWFgYa9asiaVLl8a3336btD0jIyO6d+8eJ510UpxyyinRsGHDSqq04tXW6yFDhw6NhQsXlusB4vU9++yzaaio+nv66adjxYoVpY478sgjo3PnzlugImq6JUuWxB133BFDhgzZrHnWrVsXn376aXz66aexYMGCuPvuu9NUYXr16NEjpRCGOXPmxIIFC8p8j0JRUVF8+umnKY8fN25cHHvssWU6RkTE2LFjUxq35557CmAA0mb06NExZsyYUse1bds2+vTpswUqAgCgNhPCAAAAsAVNnDgxJk6cGH/605/itttui1NOOaWySyINhg4dmtJbfHr37i2EoYqaO3duPPjgg/G3v/0tLrroorjmmmuifv36lV0WKfryyy9TenNS27Zta9RNhwAAAAAAUNslEokYP358jB8/Ph566KG4+eaba+w12Np6PaSgoCBefPHFuPbaazdrntmzZ8f777+fpqqqt/79+8fcuXNLHde2bVshDGy2+fPnxwUXXBAzZ86s7FK2mL322ivlsePGjYvjjjuuTPN//fXXsXz58jIdo6whDGUJeijL1wtQmjFjxqS05u3Zs6cQBgAAKpzIQQAAgEqQm5sbt9xyS1x22WWxZMmSyi4H+D+FhYXx2GOPxSmnnBJffPFFZZcDAAAAAABAihYvXhy33HJL3HvvvZFIJCq7HNLopZdeioKCgs2a47nnnouioqI0VQSkYuXKlXHeeefVqgCGiIhdd901mjZtmtLY8ePHl3n+cePGlWl8eY7x9ddfx4oVK1IaK4QBAACAmkoIAwAAQCV6//3349xzz43FixdXdinAT0yfPj3OPffcct2MAAAAAAAAQOV5/PHH44EHHqjsMkijRYsWxTvvvFPu/VevXh2DBg1KY0VAKh544IGYNWtWZZexxWVmZkb37t1TGjt27Ngyz1/W+xi++uqrWLVqVZn2SbWuevXqRdeuXcs0NwAAAFQXQhgAAAAq2bRp0+Kqq66KdevWVXYpwE+sWrUqrrzyypg7d25llwIAAAAAAEAZPPHEE/Hll19Wdhmk0bPPPlvufV9//fVYvnx5GqsBSrNgwYJ4/vnnK7uMSrPXXnulNO7rr7+OlStXlmnusoYwFBYWxmeffVamfcaNG5fSuC5dukSDBg3KNDcAAABUF3UruwAAAAAiJkyYEI8//nj84he/KHFcnz59ok+fPluoKmDp0qXxm9/8Jp588snKLqXG2HfffWPKlCmVXUa5+RwGAAAAAICqb926dfHAAw/Eo48+WtmlkCYTJkyIL774Inbbbbcy77s5AQ5snuHDh1d2CVSSt956K4qKilIe37Nnz9h7772jdevWERGxbNmymDdvXkyaNCmmTJkS+fn5FVVqhUg1hKGwsDAmTJgQBx98cErj58+fH999912Z6xk3blwccMABZRqfih49epS4vbrfHwAAAEDtJoQBAACginj00UfjrLPOipycnMouBfiJESNGxIgRI+LAAw+s7FIAAAAAAABqpDPPPHOjD6wWFRXFsmXLYtKkSTFs2LDIy8tLec6RI0fGypUro3HjxukslUr07LPPxl133VWmfUaPHh1ff/11BVUEbMqYMWNSGte0adN45JFHSgwtWLt2bXzwwQfx9ttvx7Bhw2L16tXpKrPCdOvWLbKyslIKjxg7dmzKIQxjx44tVz2phipERMyePTsWLFiQ0thUwyYAAACgOhLCAAAAUEb9+vXb6FvQCwsLY/ny5TFt2rR4//33Y8CAAbFs2bKU5121alW88sorceGFF6azXKg1evfuHXffffcG/YlEIlauXBlz586NUaNGxQsvvBAzZ84s09zPPPOMEAYAAAAAAIAKsueee8bJJ59c4pjFixfHddddF5988klKcxYUFMSIESPi6KOPTkeJVAFDhgyJm2++uUwvNnj22WcrriBgkxYuXJjSuMsuu6zUB/nr168fRx11VBx11FGRm5sbAwYMKFMoT2XIysqK3XffPcaPH1/q2FTGlGfsT3322WdRWFgYderUKXVsWQIbevToUa56AAAAoDrIrOwCAAAAaoo6depE8+bNY++9944bb7wxhgwZEt27dy/THO+8804FVQe1V0ZGRjRp0iQ6deoUffv2jTfeeCPOPPPMMs3x0UcfxapVqyqoQgAAAAAAAErTsmXL+Pvf/16mB/DnzJlTcQWxxa1ZsyYGDhyY8vh58+bFsGHDKrAiYFNWrFiR0rhOnTqVad6cnJy4/PLL44YbbihPWVtUaeESP5o4cWIUFBSkNLYsAQk/lZeXF19++WVKY1MNethpp52iRYsW5aoHqHq+//77GD16dLzzzjvxr3/9Kz744IOYMWNGFBYWVnZpAABQaepWdgEAAAA1VatWreIf//hHnHDCCSkn/E+aNClWr14dDRs23Oj2wYMHx2233VbqPG3bto3hw4eXqd7yWLFiRbzzzjvx0UcfxZQpU2LBggWxdu3aaNq0abRo0SLat28fBx98cPTq1StatmyZtuPOnz8/vvnmm5g2bVp8++23sWDBgli4cGF8//33sXr16sjPz481a9ZEnTp1ol69etGsWbNo2bJltGvXLtq3bx977LFH7LXXXtGoUaMyH3vChAkxa9aspL7Zs2entO/s2bPjtddeS2nsUUcdFdnZ2aWOy83NjalTp8bUqVNjxowZsWDBgliwYEEsWrQo8vLyYs2aNbF27dpIJBKRlZUVjRs3jubNm0fbtm1jp512iq5du8bee+8dW2+9dUp11QRZWVnxu9/9LubNmxcffPBBSvsUFBTEp59+GgceeGC5j7tw4cIYMWJEfP755zF16tSYP39+LFmyJNasWROJRCLq168fzZo1i9atW8fOO+8cXbp0iQMOOCB22mmnch+zJIlEIj777LP45JNPYvr06TFjxozin5u8vLwoKCiI+vXrR3Z2djRt2jS22WabaNOmTWy//fbRqVOn6NixY2yzzTZlPu7o0aPj/PPPT2nslClTNuibPXv2Bjd9fPrppynNl5eXl/LvYI8ePaJdu3Yb9FfG5/A333wTo0aNismTJ8fMmTNj/vz5sXz58li7dm1kZGREgwYNomXLltGmTZvo0KFDdOvWLQ466KAqccPLmjVrYtiwYfHBBx/EF198EfPmzYvVq1dH48aNo0WLFrHDDjvEQQcdFIcffni0bdu2sssFAAAAAKCKa9q0aRx//PHx3HPPpTT++++/L/exKvM6XGVfD6nKXnjhhbjooosiM7P099C98MILVe7BwVWrVsXHH38cn332WXz11Vcxb968WLRoUaxevToKCgqiQYMG0ahRo9h6661j++23j9122y322Wef2GOPPVL6mtc3dOjQDcLm8/LyUtr3008/jTp16pQ6rlGjRnHkkUdudFuvXr1i7ty5pc7Rr1+/6NOnT0p1lWRLf3/T7euvv45///vfMXbs2Jg+fXrk5uZGRESLFi2iZcuW0aNHjzj44IPjgAMOiLp1q/ZjAM2aNUtp3Pr3X9Qke++9dzz22GOljluzZk1Mnjw59txzzxLHrVy5Mr7++utNbm/Tpk3Mnz9/k9vHjRsXu+++e6n1pBr0kErIxObeH5BuS5YsiXfffTdGjBgRX3/9dfHf6YlEInJycuLXv/51nHDCCWWe98dr+pMmTdrgmn6dOnUiOzs7WrduHTvuuGN07do1DjzwwNhtt90q4CusvX56T84333wT8+fPj6VLlxbfk9OwYcPie8e6dOkS++67b/Ts2bNKfJbOnj073nnnnRg9enRMmzYtlixZEuvWrYvmzZtHy5Yto1u3bnHwwQfHwQcfHA0aNEjrsRcuXBgvvvhi/Otf/4oZM2ZsdEzTpk3j4IMPjjPPPDP23XffpG1jx46NF198sdTjtGjRIn71q19t0P/VV19t8Luf6mfB999/n/Ka98ADD4ytttoqpbFlsWDBgnj77bdj1KhRMXXq1Pj++++joKAgcnJyonnz5tG5c+c4+OCD47DDDosmTZqk/fgAAFS8yv8XAwAAQA3WrFmzuPjii6Nfv34pjS8oKIiZM2dG586dK7iyH5T3YeIVK1bE3//+93jxxRc3eoPGkiVLYsmSJTF16tR45513omHDhtG3b9+49NJLyxV88OPFpnHjxsWECRNi6dKlKe1XVFQUBQUFkZeXF/PmzYtJkyYVb6tfv34ccsgh8fOf/zz233//lGsZMGBAvPLKK2X+GiJ+uPA0duzYlMYOGzZsoyEMK1eujCFDhsS4ceNi3LhxZXp7z+rVq2P16tWxaNGi+Prrr+O9996LiIiMjIzYc88946yzzorjjz8+6tWrl/Kc1VVGRkbccMMNKYcwRPxw0bysIQzr1q2LN998M1588cX49NNPI5FIlDh21apV8d1338WECRNi0KBBERHRvn37OOOMM+L0008v1+/P+pYsWRKPPvpovPnmm7Fo0aISx/4YyPD999/H9OnTN9iek5MTe++9d+yzzz6x7777bpHPrk8++SSlz62NWbp0adx8880pje3Xr1+l3nSYm5sbL730Urz88sul3nhUUFAQK1asiJkzZ8aoUaMiIiIzMzP22WefOOecc+JnP/tZuW8aK+9NMWvXro2nnnoqnnrqqeKbw34qNzc3cnNzY/r06fHee+9Fv3794owzzohrrrmmSoRHAAAAAABQdbVv3z7lsam+iT2ial2Hqy3XQzamQYMGxeEWGzNnzpz4z3/+E7169SpxnrVr18ZLL71U4pjs7OyUAwk216hRo+L555+P4cOHl/jG+x+vzy1atCgmT54cb731VkT88PBi796949xzz41tt9025ePeddddKYUgbMyAAQNiwIABpY5r27btJkMYtpTK+v6u77zzzosxY8aUOu7qq6+Oa665prg9efLkuPfee+Pjjz/e6Ph58+YV3/PQv3//2HnnneOmm24q9fegMnXs2DE+++yzUscNGjQofv7zn2+Bira8Hj16REZGRon3Cfxo7NixpYYwjB8/PoqKija5vW/fvvHHP/5xk8cbN25cXHDBBSUeY+nSpTFt2rRS64344evb0sp7/XrVqlXx0EMPxQsvvBBr1qzZ6PilS5eWKbxp6dKlxdf0S3p5S2FhYeTn50dubm5MmTIl3nnnnfjTn/4UO+ywQ5x77rlxxhlnpP3B+tqioKAg3nzzzRgwYECp9+SsWLGi+L6KDz/8MB555JHIycmJU089NS644IJo3bp1ueu49dZbU7qXrHfv3nH33XcXt7/99tv405/+FEOHDt3o7/bChQtj4cKF8eWXX8aAAQOiTZs2cf3118cpp5wSGRkZ5a434oefy3/84x/x6KOPxurVq0scu3z58hgyZEgMGTIkDjrooPjf//3f4vXjrFmz4o033ij1eG3btt1oCMO7774bf/3rX8v1NUyfPj3lNW///v3TGsLw3Xffxf333x9vvfVWrFu3boPtixYtKv53wWuvvRY5OTlxxRVXxM9//vNacV8eAEBNUvmRnQAAADXcwQcfXKbx8+bNq6BK0mP06NFx3HHHxZNPPpnyDSmrV6+Ohx9+OM4555xYvHhxmY/51ltvxb333hvDhw9POYChNGvXro133303+vbtGxdddFGJF0SrkqlTp8Zvf/vbeO2118p041dJEolETJgwIW655ZY44YQTNnljR02z2267lekCW0lvjNiYYcOGxXHHHRe33HJLTJgwIaUbKzZm2rRp0a9fvzjqqKNSusmpJM8991wceeSR8dRTT5UawJCK3NzcGDp0aPED9Gy+wsLCePzxx+PII4+M++67r9xvfikqKorRo0fHddddF6ecckpKN3uly1dffRWnnHJKPPDAAxsNYNiYdevWxfPPPx+nnnpqzJw5s0LrAwAAAACg9mjcuHHKY12HqxpatmxZajD6c889V+o8Q4YMKfHact26deO4444rc31l9c0338QFF1wQF1xwQbzzzjslBgSUZMmSJfHEE0/E0UcfHXfffXepD0zWFtX9+1tYWBgPPPBAnHbaaWX6fJg+fXpcccUVcd9991VgdZvn0EMPTWnc5MmTSw1Mqa6aNm0aHTp0SGnsuHHjNnvM4YcfHrvssssmt48fP77UY4wfPz7lexv22muvlMZVtmnTpsXJJ58cTz311CYDGMpi3bp18eijj8aRRx4Z999/f7nvN/r222/jzjvvjGOPPTaGDh262XXVNkOHDo1jjz02br311nLfk5ObmxtPPPFEHHPMMfHoo49GYWFhBVS6cc8880yccMIJ8e9//7vEcJWfmj9/ftx6661x8803b/TB/1QtW7YsLrjggvjLX/5S5r/vPvroozj11FNjxIgR5T5+dTdw4MA4/vjj44033kj5/0Nubm7069cvLrvssi0WAAYAQHoIYQAAAKhgZX1LwqpVqyqoks03cODAuPDCC2PhwoXl2v+rr76Kc845J1auXJnmyjbPiBEjok+fPlv0IeWqaubMmXHRRRfF008/XdmlbBHbbLNNymNT/d3Mz8+PX//613HllVfGt99+W97SNrB48eL47W9/G5dcckksX768zPvfc8898fvf/75Kf8bUdgsWLIhzzjkn7r333jK9mas0U6ZMiQsuuCDuu+++lC/el9f7778fZ599dkyfPr1c+3/33XdxzjnnxHfffZfmygAAAAAAqClmzJiR8tjtt9++Aispm9p2HW5znHvuuSVuHzFiRKmhzs8++2yJ24844oho06ZNWUsrk+eeey769OkTo0aNStuc+fn58dRTT8Upp5yS9Jb32qi6f39Xr14dV155ZTzyyCPlvob36KOPVtkghsMPPzzlz+B+/frV2J/nHj16pDQulfCDkkIUttpqq9hxxx1LPN6iRYtKDQxIJQzip8er6r7++us4++yz0/Zilnnz5sVZZ50V9913X9ruffruu+/iqquuijvuuGOLhgBUV2vXro1bb701rrrqqrT9f83Ly4v77rsv+vbtm7aXA21KYWFh/PrXv4477rgj8vPzyzXH66+/HjfffHO59l22bFmce+658cknn5Rr/x/n+MUvfhHvv/9+ueeojhKJRPTr1y9uv/32cgcpjBw5Mi655JLNCtEAAGDLEsIAAABQwcqTtF0Vvfzyy3H77bdv9gW/mTNnxj333JOmqtJn+fLlcfnll8dXX31V2aVUuqKioujXr18MHDiwskupcOn+/czLy4uLL744Xn755bTO+1MffvhhnHXWWWUKQ/nXv/4VTzzxRIXVxOabNm1anHHGGfHpp59WyPxFRUXx6KOPxvXXX19hF3Pff//9uOqqqzY7tf/HwBEAAAAAAFjfypUr41//+lfK46vaW7pr03W4zXHooYdGu3btNrk9kUjEc889t8nt48ePj8mTJ5d4jNKCHjbXH//4x/j9739f7gcsSzNz5sw455xzNushyuqsun9/8/Pz44orroj//Oc/mz3X448/XuLD+ZWlTp06KT8knJeXF1dccUV8//33FVzVlrf33nunNC43NzemTZu2ye0FBQXx+eefb3L7j+ELpR2vtJCFVEMYUg2XqEyLFy+OSy+9NJYtW5aW+aZMmRKnn356if8fNsczzzwTN9xwg4ezS7By5cq44IIL4pVXXqmQ+ceMGRPnnHNOuV9OVJpEIhG33XZbWu4pGjJkSAwZMqTMx7/++uvj66+/3uzj5+fnx/XXX19jA3Q25ne/+11awtTGjRsXTz755OYXBADAFiGEAQAAoILNmzevTOMbNWpUQZWU36JFi+J//ud/0jbfSy+9VOpNL5UhLy8vbrzxRhc0/88f/vCH+Pbbbyu7jApVlt/P0n43161bF1dffXWMGTNmc8sq1bRp0+KSSy5J6c0Ka9asiTvvvLPCa6L8FixYEBdffHHMnz+/wo/1zjvvxG9+85sKmfu6666LgoKCtMz14YcfxrvvvpuWuQAAAAAAqBmWLl0a11xzTSxevDil8bvttlt07Nixgqsqn9pwHW5zZGZmxjnnnFPimFdeeWWTwdAlBTREROy6667Rs2fPctdXmr/+9a9b5OG6lStXxi9+8Yta96KBmvD9feaZZ+Ljjz9Oy1xFRUXxu9/9Li1zpdtRRx0V3bt3T2ns3Llz49JLL03pGnh1UpYwoJICEL744otYvXp1qccp7XglHWPNmjUp38tTHUIYbr/99rRdg589e3ZcfPHFsWjRorTMtynvvPNOlf19rmz5+flx+eWXx4QJEyr0ONOnT4/LL788Vq1alfa533nnnXjttdfSNt+dd95ZpjCiZ599NkaOHJm24+fl5aUllKA6GD9+fLzwwgtpm++hhx6qsLAPAADSSwgDAABABXv//ffLNH6bbbapoErKLz8/PwoLC9M2XyKRiAEDBqRtvnSaOnVqvPTSS5VdRpWwZs2aeOCBByq7jAozadKklG/Si4ho06ZNidsfeuihGDFixOaWlbIpU6akFI7y0Ucf1cg3htQUhYWF8ctf/rLMgT2bY/DgwRXyGVzSTT/l8eKLL6Z1PgAAAAAAqq5PP/00XnvttQ3+vPrqq/HPf/4zbrnlljjiiCPK9ODYDTfcUIEVb56afh0uHU499dRo2LDhJrevWLFiow8yLly4MN55550S5z733HM3u75N+fDDD+Ovf/1rhc2/vpUrV8Z1111XIQ+LVkU15fub7utqX331VXz66adpnXNzLV++PK699toyPTD9xRdfxFVXXVWmh4qrum233Tbl+4BKCkgoaVvEf0MR2rZtW+LxSppn4sSJKYfulyVcorK89957aZknPz8/rr322goPYPjRSy+9FK+++uoWOVZ10q9fvxg7duwWOdYXX3wRd9xxR9rnTfdn/+LFi1N+ucXs2bPjvvvuS+vxa5N0v9ApPz/f7zkAQDVRt7ILAAAAqMlyc3PL9AaGunXrxo477lhxBaVJRkZG7LnnnnHQQQdF69atY8WKFTFixIgYMWJEJBKJlOYYMmRI/PrXv46srKxy17HVVltFhw4dYpdddonmzZtH48aNo3HjxlFUVBRr1qyJ+fPnx/Tp0+OTTz6JFStWpDxv//79S32zSlXTuHHj2GWXXaJDhw7RunXraNy4cTRq1Cjq1q0bq1evjiVLlsTMmTNj7NixZUr6//e//x3z588vNYCgukkkEvHnP/+5TPt06NBhk9u++uqrePTRR8s034477hi9evWK7bbbLurWrRvz58+PDz74ICZNmpTyHG+++WYcf/zx0atXr02OGT58eEpzZWZmxj777BN77LFHtGnTJrKzsyM/Pz9WrFgRy5cvj5kzZ8Y333wTs2bNSvvFxdrs+eefL9ONAhkZGdG9e/c44IADonXr1rF27dqYNWtWDBs2LObOnZvyPHfffXccfvjhsfXWW5en7JR06tQpDj/88Nhmm21i9erVMX78+Bg2bFjKPz8jR46MBQsWROvWrSusRgAAAAAAqoYBAwakNUD4oosuikMOOSQtc7kOVzmaNWsWJ554YokB+s8//3ycffbZSX0DBgwo8SHiZs2axUknnZS2On9qzZo18Zvf/Cbla+YREc2bN48jjzwydtlll2jUqFEsWbIkxo4dGx9//HHKD0PPnDkzHnroobj11lvLW3q1UJO/v9nZ2XHkkUdG586do0mTJjFnzpwYMmRIzJ49O+U5Bg8eHHvuuWeF1VgW33zzTVx++eVlun75o1GjRsVNN90UDzzwQGRmpva+yU8//TTOPPPMEscceuihZb6mny577bVXvPnmm6WOKykgYfz48Zvclp2dHbvttltKx5s+fXrk5uZGTk5OmY7/Uw0bNkw6Xk336KOPxhdffJHy+Pr168chhxwS3bp1ixYtWsTq1atjypQpMXTo0Fi6dGlKc9xxxx1xyCGHRIsWLcpbdo0yZsyYeP7558u0zz777BM9e/aM1q1bR1FRUcyaNSuGDx8eM2fOTGn/wYMHxwknnBAHHnhgOSpOTVZWVhx22GHRrVu3yMnJiYULF8bbb78dX3/9dcpzDB48OI4//vhSxz355JNlCoFo0aJFXHjhhdGrV6/Ydttto7CwMGbPnh3vvPNO9O/fP/Ly8lKeqyaqU6dO7LffftGzZ89o2bJlLF26NIYPH16m4KFBgwbFZZddVoFVAgCQDkIYAAAAKsiiRYvimmuuKVMS+u67717i2zyqgm233Tbuueee2GeffZL6L7roovjwww/j2muvTelCy8qVK+Orr76Kbt26pXzszMzM2HfffeOII46II444IrbddtuU9isoKIjXXnst7rnnnli2bFmp42fMmBFffvlldO7ceYNtd999d9x9991Jfbfeemu88sorpc7bu3fvDfbdHLvuumscddRRceSRR5bpAvfHH38cd911V0oX7QoLC+Ptt9+Ovn37bkalVUt+fn7ccccd8eGHH6a8T7169WKPPfbY5PZ77703ioqKUpqrUaNG8Zvf/CZ69+69wbbrrrsuPvroo7j11ltT/uz405/+FIcffnhkZGRsdPucOXNKnWPHHXeMhx9+OHbeeedSx65duzbGjx8fH3/8cYwcOTImTZpUphudNlefPn2iT58+SX2DBw+O2267rdR927Ztm3IoxZaQl5dXpjf17LjjjvHHP/5xozdP3XbbbdG/f//405/+lNINYz8e+/e//31ZSk5JTk5O/OEPf4if/exnSf19+/aNzz//PK644oqUfr6Liopi/Pjxceyxx6a9RgAAAAAAaqbMzMy47LLL4oYbbtiseSr7OlxNuh6yOX7+85+XGMLw9ddfx+jRo2PfffeNiB+uC5cW5tGnT58Kuybfv3//mDdvXsrjL7nkkrj22mujfv36Sf2XX355zJw5M2655Zb49NNPU5rr2WefjfPPP3+Da+gb+1no1atXSg/H9+vXb4Ofw8pUFb+/6XD00UfH7373u2jevHlS/9VXXx133XVXyg8ep/oAfUUbNWpUXH311WV6Ucb63n777WjZsmX89re/TWl8KveBVGbgTaohDHPmzNlkSH1JIQzdunWLunX/+1hIScdLJBIxfvz4jb7oIdWXB3Tt2jXpeNXF3nvvHSeeeGL07NkzWrVqFQ0aNIilS5fG1KlTY/To0fH2229vsM+iRYviscceS/kYxx9/fPzqV7+KrbbaaoNtt956a/Tr1y8GDhxY6jwrVqyIRx55JH71q1+lfOyarCz3WnXu3Dnuvvvu6NSp0wbbbrrppnj++eejX79+Kb084k9/+lOFhTD07Nkz7r777mjbtm1S/5VXXhmPPvpo3H///SnNM378+CgqKioxtGbFihXx6quvplxb9+7d4+9///sGISC77bZb7LbbbnHGGWfEhRdeGN9++23Kc27KNddcE9dcc01S30MPPZTSvTQ9e/aMZ555ZrNrKKtdd901/vSnP0XHjh2T+i+77LJ49dVX41e/+lUUFhaWOs/MmTNjyZIlwlYAAKq41OIhAQAAKFVhYWHk5ubG2LFj47777osTTjihTOnGET9cXK/Kttpqq+jfv/8GAQw/Ovjgg+P2229Peb7JkyenNC4rKytOP/30eOutt+Lpp5+O8847r0w3N9SrVy9OO+20eP755yM7OzulfUaOHJny/FtSRkZGHHTQQfHPf/4z3njjjbj22mvL/IaB/fffPwYMGBC77rprSuM//vjj8pRaZSQSieLQj3/+859x4oknlvlNSgcddFA0btx4o9umTp0aH330UUrz1KtXLx5++OGNBjD89FhPP/10NGvWLKU5p02bFh988MEmty9evLjUOX71q1+lFMAQ8cNbG/bff//45S9/GQMHDoyhQ4fGDTfcEB06dEhpf/7r1Vdfjdzc3JTGtm3bNp555plNvr0mMzMz+vbtW6abD1577bWU37SRquzs7Hjsscc2CGD4UdeuXePee+9Neb5U/54AAAAAAID9998/nn/++XIHMLgOV/V06tRpk9emf/Tcc88V//fbb79dYhB0ZmZm/PznP09bfT+1bt26Mj0I+Mtf/jJuuummDQICfrTjjjvGk08+GV26dElpvoKCgnj22WdTPn51U1O/v8cee2z85S9/2SCAIeKHa8u//e1vo2fPninNNX369Ep/M/nYsWPj8ssv36wAhh8999xz8be//S2lscuXLy91TEUEaKRqr732SnnsxsI0ZsyYUeJ1/x49epTpeBs7RlFRUcqhJGX5eqqChg0bxgMPPBDPPfdcnHXWWbHzzjtHkyZNol69erH11lvHAQccEDfccEO8/fbbG9zL8cILL8SaNWtSOs55550X999//0YDGCIiGjduHHfeeWeceeaZKc338ssvx8qVK1MaW5ONGjUq5fsG9txzz3jxxRc3GsAQ8cM64Nxzz035voovvviiQtZqe++9dzz++OMbBDBE/LAevfzyy+Pkk09Oaa68vLyYMWNGiWPeeOONlP9+aNOmTTz66KMlBgO0bds2nnzyyZTvwatJdt555+jfv/8GAQw/OuWUU+Lyyy9Peb5JkyalqzQAACqIEAYAAIAyuu2226Jjx44b/Nltt91i3333jZ///Ofx6KOPpvxg7Y+ys7NLfDC7Krj99tujXbt2JY456aSTNvmw+vqmTp2a0rgLLrgg7rjjjthxxx1TGr8pu+yyS5xxxhkpja2qD/5269Ytnnjiidhvv/02a57s7Oy4/vrrUxpbVb8X63vllVc2+rvZqVOn2GuvveLkk0+Ou+66K2bOnFnmuc8999xNbnvttddSnqdv377Fb+IpyS677BLXXXddyvO+/vrrm9yWSCRK3X+77bZL+Vgb2/cXv/hFDB48uNxz1FZl+dn53//939h6661LHXfCCSfEMccck9Kca9asiX//+98p15CKK6+8Mrp161bimP333z/l0I9U/54AAAAAAIBly5bFF198Efn5+eXa33W4qqm00IRhw4bF/PnzIyI5kGFjDjnkkFKvd5fXxx9/HAsXLkxp7J577hmXXXZZqeMaNWoU/fr1izp16qQ07xtvvJHStcHqqCZ+f7faaqu44447IiMjY5NjMjIy4uyzz05pvqKiopg+fXq6yiuzadOmxeWXX57yA+upePDBB+Oll14qddzcuXNLHbPLLruko6Ry2XXXXaNp06Ypjd1YQMLG+n5q/VCEXXfdtcSXPmxsvilTpqT8wH91CmGoV69ePPbYY3HccceVOjYjI2OD79urr76a0nE6deoUt912W0pjb7/99mjVqlWp4/Ly8uKdd95Jac6a7JVXXklpXMOGDePPf/5zNGjQoNSxJ554Yhx55JEpzZvqz0Cq6tevH/fee+8mQ4J+VJbQqNLuqxgzZkzKc910000pfV5tt912ZQobqAkyMjLi7rvv3mhw0k+l8/8dAACVTwgDAABAFXHppZeWepK+Mu26664pXZTMysraZKL4+lJ5G0FElHjTQVmlejG4PA/qbwmV8b1YtGhRrU7XP+CAA+Kggw7a5Pb33nsvpXmysrJSutnnR2eddVZKF94jIt5///0oKira6LZUPlfeeuutlOsiPRYvXhyfffZZSmO7desWhxxySMpzX3311SmPTfXnNxU5OTlxwQUXpDS2a9euKY1L9e8JAAAAAAD44osv4ve//32ceOKJKb/N+6dch6uajjrqqGjduvUmt69bty5eeOGFmDRpUkyYMKHEuUoKXt9cZbnmcuWVV6b889axY8eUHxRduHBhjQ32qInf34svvjilF1ykel0tImLFihWbU1K55efnxw033JDy51nDhg1Tnvt///d/49133y1xTCqf+bvuumvKx0y3jIyM6NGjR0pjx44du0FfSSEMderUiT333HOD43Xv3n2T+0yePHmDwKKNHXdjMjMzS5y7qrnkkktin332Kde+X375ZUoBHxERV111VcqBLvXr14/TTjstpbHDhw9PaVxNVVRUlPLn/2mnnRbbbLNNynOnuib4z3/+s8n7ccrj9NNPj2233bbUcZ07d466deumNGdp91WMHz8+pXmaN2+e8ks/In74WlKtsSY47LDDYo899ih13FZbbZXyz6J7YgAAqj4hDAAAAFXAnnvuGZdeemlll1GiE088MeWxqVwsiqicGwBKSvv/qVTfolGd5eTkpDy2Nnw/NiYnJyf+8Ic/bHL7ihUrUk4lP/DAA1N+u0XEDzdLHH300SmNLamOnXbaqdT9H3roobjhhhvivffei6VLl6ZcI+X36aefpvymnFQCcH6qQ4cOKd9EVJ6bUDfl6KOPjqysrJTGVuW/JwAAAAAAqN5mzpwZ559/fgwdOrTSanAdLn3q1q0bZ511VoljXn755XjyySdLHLPjjjuWGLy+uUoLgPhRTk5OHHjggWWa+/jjj095bDqv/VQlNe37m5mZmfJxt9lmm5RDJSrr2tpTTz0VU6ZMSWls375948033ywxXOWnCgsL48Ybb4xPPvlko9sTiUSp4fc5OTnRrl27lI5XUVIN5/n66683CLMo6QHqjh07bjTMo6Tj5efnx8SJE5P6Sgp6+Kldd901pfCQqqBRo0ZlelHG+lJ9cL1Ro0Zx2GGHlWnuVIMhUv3sq6mmTZsWy5YtS2nsCSecUKa5e/TokVJwRm5ubsyYMaNMc5ck1fvvsrKyYquttkppbEkBOAsWLIgFCxakNM8hhxxSplCFli1bphRKUFNUxL2Twtj4/+zdd3gU5frG8XtL2qaHQAihhd5BehEBRQU7KIqCDcVzxIJHQPEgdkRRsXc9qNgV7ApKs9CkCUiRGnpN72V3f3/wMxoku7PJlpTv57q4dGae933vLJkkZGafAQAAVV/taTsGAAAAAFVUcnKyXnzxRQUFBQU6iks9e/Y0XBsZGWmoLi8vr6JxlJaWplWrVmnz5s3avXu3Dh48qLS0NGVlZamwsFDFxcWG3+B8KtXpIkd+fr7WrVun33//Xdu3b9eBAwd0/PhxZWZmKj8/X8XFxZXuyl6dXg9vsdlsevHFF9WwYcNya/744w/Dn2dGb6o4ecy7775rqHbLli2nfON937599cknn7gd/+233+rbb7+VJMXFxalx48Zq1KiRmjZtqiZNmqhly5Zq3rx5lf9aVV1s3brVcG1FPne6du2qbdu2ua1LT0/X4cOHVb9+fY/XOFmvXr0M1/rj+wQAAAAAAAAAoPYqLCzUxIkT9f7776tdu3YVnofrcFXDFVdcoZdeeknFxcWnPJ6amqpvvvnG5RyjRo0y/EZ2T9ntdm3fvt1QbadOnTx+arQn14q2bNni0dzVQU18fZs0aWK4CYHValVYWJih62aBuLaWk5OjN954w1DtmDFjdPfdd0uSXn/9dY0aNcpQ44jCwkLdfPPNeu+999S6desyx1asWKG0tDSX47t37+6z89+orl27GqpzOBxau3atzjjjDEkn7o1JSUkpt768z193n9dr165V9+7dy2wbUZFr14EyZMgQ2Wy2Co/fvHmzoboOHToYfljBn4ye/6mpqTp69Kjq1avn0fw1hdG/g+DgYLVv396juUNCQhQdHe3264d04mt/8+bNPZr/VMLCwtSpUyfD9ZGRkTp8+LDbutzc3HKPedLsq23btoZr/9SmTRvDTVyqO1/cO+nq7w4AAABVA00YAAAAACCATj/9dM2YMUN16tQJdBSXTCaT4aeqS1JoaKihOk+bJBQWFuqLL77Q3LlzPXqKfEUUFBT4bG5vcDqd+vnnn/XRRx/pp59+UlFRkU/XKyws9On8VU3Tpk315JNPqmPHji7r9u/fb3hOT86hP7Vs2dJw7cGDB0+5f9CgQapbt66OHTtmeK60tDSlpaX940kuf1647tmzp8444wx169Yt4DerVFcHDhwwVGcymdSiRQuP5/fk8+3AgQNeacJw8g1Prvjq+wQAAAAAAAAAoHqaPn26hg8ffspjeXl5Sk1N1e+//64vv/xSixYtMjRnfn6+pkyZojlz5shsNhvOwnW4qqdOnToaOnSovvzyywqNt9ls5X5+ecPRo0fLbRBxMk+u//0pPj5esbGxSk9Pd1tb3jXD6qwmvr6eXFeTTlxbM9JgobJNYSpi3rx5ysrKclvXvn173XnnnaXbrVu31ksvvaQbbrjB0NfZ7Oxs3Xjjjfrwww+VlJRUuv/DDz90O7Zv375ua3ytU6dOCg4ONvSxrlmzprQJg7s3N5fX3KFjx44u1/v7vPv27dORI0fc5pKqVxMGT94wfSpGr+mvXLnS43Pa0xy1tQmD0b+DoqIidejQIeA53GnRooVHP5N6476KzMxMw+slJiYarq3MmOooLi5OdevWNVzPPTEAAAA1h/Gf4AEAAAAAXhMZGalHHnlEb775ZpVvwCCduCnFk+7wQUFBXs+wePFinXvuuZo6darWrVvn84sQVfkix86dOzVy5EiNHTtWCxYs8PmNX1JgbtYIBLPZrOuvv15ffPGF2wYMkgzdiPOn+Ph4j/N48vUhNTX1lPvDwsI0fvx4j9c+laKiIq1bt06vvvqqRo0apTPPPFOvvfZaQJ6oUt0ZeZqC5PnX3z958rljNIs7nnyOe/okEAAAAAAAAABA7WWz2dSoUSMNHTpUL7/8sl555RXDv2fevHmz5s2bZ3gtrsNVXVdffXWFx15yySWKiIjwYpqyPLnW4skb+P7O6HWY8q4ZVmc18fX1NKcv7sHwFqNfY8eNG/ePj6Nnz5564oknDL8p+ejRoxozZkzp58Tu3bu1cOFCl2NMJpMGDx5saH5fCg4ONnQPglS2QYK7JgzlNUUIDg5Wp06dyh339/tuPHmKfXVqwtCuXbtKja8qX0+rSo5A8Na9DJV1/Phxr8zj6X1D3vjab6RJzp/Cw8M9nt+XP19VJZ7+3VmtPC8ZAACgpqAJAwAAAAD4Ufv27fXAAw9oyZIlGjFiRKDjGObpRRZPunYb8fbbb2vcuHE6dOiQV+etjlatWqUrr7xSv/32W6Cj1Cj169fXLbfcooULF2ry5MmGO5IXFBQYXqMib6T35GKlq6ckjRgxQmPGjPF4fXcOHjyop556SkOHDvXoxgwYf6pVRT5vJM++bnvyeeytNU0mk1fWBAAAAAAAAADUPoMGDdKkSZMM18+ZM8dQHdfhqrZOnToZfgPzyUaPHu3lNGX5+pqhZPw6jNFrUNVJTXx9A30Phjdt2LDBbU1sbKwGDhx4ymNDhgzRlClTDK+XkpKif/3rX8rNzdVDDz2k4uJil/Xdu3dXQkKC4fl9yWgDg40bN5Y2AVq7dm25dUlJSS4/NlfrZWZmaseOHZKMN2Fo0KCB6tevb6i2KqjIgzL+rqp8Pc3Pzw90hIDx1r0MlRWIeyok/3/tr8h6teXeD0//7iwWi4+SAAAAwN9orwUAAAAAXmQymWSz2RQZGanIyEjFxcWpbdu26tChgzp16qQmTZoEOmKFeNpZ25sXgb788ks9+uijXpuvOktJSdGNN95YZS4yVjehoaGKjIxURESEYmJi1KJFC3Xo0EEdOnRQ27ZtfX4BzNcXHv98SkV57r77bjVp0kQzZ85UZmamV9c+fPiwxo4dq3feeUcdOnTw6ty1XUU/bzwZ5+5zxyhPvldU5RvFAAAAAAAAAABV38iRI/X0008rLy/Pbe3KlStVVFSk4ODgcmu4Dlc9jB49WnfffbdHY/r06aPmzZv7KJHnfH3tx1vXfaqr6vL6evqE7Kp6be3w4cOGrj23aNHC5cc8evRoHTlyRK+99pqhdTds2KDhw4crJSXFbe1VV11laE5/MNqEoaCgQJs2bVLbtm21efPmCs/n7viaNWvUsmVLw00YunbtaqiuqvDkoRdVWUlJSaAj1Hre+jsIxP130dHRhmtzc3M9nj87O9vjMdVRIO+dBAAAQGDRhAEAAAAAPDR9+nQNHz480DFqhbS0NE2bNi3QMaoEp9Ope++9lxu/XBg2bJgee+wxv64ZGhpquLYiFytzcnK8mmXkyJE6//zz9fHHH+vzzz/Xtm3bPM5UntzcXE2YMEHffvstHd0NCAkJMVRXkc8bybPPnbCwsAqtAQAAAAAAAABAoAQHB6tTp05asWKF29ri4mJt375d7du3P+VxrsNVH+edd54ef/xxpaWlGR4zevRoHyY6wdfXDCXj1348yVJd8PpWXenp6Ybq6tWr57ZmwoQJOnbsmD777DNDcxppwJCYmKizzz7b0Hz+0LVrV5nNZjkcDre1q1evVlFRkYqLi8utcddkwd16a9as0TnnnKNdu3a5zWNkvarGVfMlI6rK+V6bm+vwd1B5njRhOHr0qMfzHz582OMxAAAAQHVCEwYAAAAAQJX18ccfKyMjw1BtWFiYLrnkEg0aNEgtWrRQXFycQkND//HEipUrV+qaa67xQVrfWrdunVatWmWo1mQy6cwzz9TQoUPVrl07JSQkyGaznbLLduvWrb0dtVaJjY01XHv8+HGP5/fkBrK4uDhDdZGRkbrhhht0ww03aN++fVqxYoV+++03bdmyRbt37zb0xKjypKSk6Msvv9SwYcMqPEdtYfRzJy8vT/n5+R43SkhNTfV6FgAAAAAAAAAAqpL4+HjDtUePHi23CQPX4aqP4OBgXX755XrllVcM1SclJWnQoEE+TuX7a4aS8Ws/Rq8ZVie8vlWX0aYXRptcPPLIIzp+/Lh+/vnnysQqdeutt3r89HJfioqKUosWLQw9LGHNmjUuGzBI7psiREZGqlWrVtq6dWu5a6xdu9bwG8y7du1qqK6m4Dp64PF3UHl169Y1XPvHH394PP+WLVs8HgMAAABUJzRhAAAAAABUWfPnzzdU17BhQ7311ltq1KiR29rq+gQbo69FUFCQXn75ZfXv399tbX5+fmVj1XpJSUmGa7dv364BAwZ4NL+Rmy/+1KBBA4/mlqRGjRqpUaNGGjFiROm+48ePa9++fdq7d69SUlK0adMmrVq1ynBzhkWLFtGEwQCjnztOp1Pbt29Xp06dPJp/+/btXs8CAAAAAAAAAEBV4sl1v+zs7HKPcR2uernyyiv1xhtvqKSkxG3tyJEjZbFYfJ4pISFBVqvVUCZPruH8KTU11XDz9opcM6zqeH2rruDgYEN1u3btMlRntVr13HPP6ZprrtHGjRsrE01t2rSpktetu3XrZug+gHXr1rlswhAdHa0WLVoYWq+8JgwHDhzQd99953YO6UQDiVatWhmqrSmMXke/7LLLNG3aNB+nqZ2M/h00btxYP/zwg4/TVE8JCQlKTEzUoUOH3NYuXbrUo7nT0tK0fv36ikYDAAAAqoV/tt4FAAAAAKAKyMvL0+bNmw3VTp061VADBknav39/ZWKdkslk8vqcJ1u9erWhuquvvtrQjV+Sb16L2qZVq1aG//7XrFnj8fxr1641XNumTRuP5z+V+Ph4nXbaabr44os1fvx4vfbaa1q2bJnGjh1raLzRJ0V5kz/OQW/z5O/Lk8+DPxn9fIuJiVFiYqLH8wMAAAAAAAAAEGh79+41XGu1lv/MsupyHa46Xg/xhfr16+uss85yWxcSElKmEbkvWSwWQ2+GlqT169cbaibwd55cZ/TWNcOqhNe36qpTp46hun379pXbCOBkNptNr732mpo0aVLhXFarVdOnT/dLExZPdevWzVBdRkaGli9fXu7x0047zdD3he7du7s8brQJQ5cuXWQ21663nhg93zds2ODjJLWX0b+Dffv2GW6mUxt17drVUN2BAwe0YsUKw/N++umnHn/PNYKfeQEAAFCV1K5/CQMAAAAAqo1jx44Zru3Vq5fh2iVLllQgjWshISGG6jx5Gs/JjL4evXv3NjynL16L2iY6OlrNmjUzVPvLL78oKyvL8Nx2u13z5s0zVBsREaGWLVsanttTYWFhmjhxojp27Oi2Nj09XUVFRT7Lcir+OAe9rUuXLoYvHH/77bcezb1jxw5DT0+RpM6dO3s0NwAAAAAAAAAAVcHevXs9euJ9bGxsuceqy3W46ng9xFdGjx7ttub88893+ffubaeddpqhuoyMDC1btsyjub/55hvDtV26dHFbExoaamiuqvS5VJ1e39okMTFRYWFhhmpfeOEFw/PGxcXpzTffVHx8fIVyjR8/Xu3atavQWF9z1xTh7+x2e7nHjDZzcFfnao2KrFeTGP26s23bNsMPmYFnWrZsqYiICLd1TqdTX375pR8SVU+e/Az7+OOPq7i42G3dwYMH9corr1QmVrn4mRcAAABVCU0YAAAAAABVkicdyo1c/JGkdevW6aeffqpopHIZueAnSTt37qzwGkZfD6OvRXZ2tmbNmlXhPPjLoEGDDNUVFRXptddeMzzvRx99ZPimvzPOOKPcp3jk5OTI6XQaXteVRo0aGarLyMjwynpGGT0HU1NTlZ6e7uM0xsTHxxtqaiGdeGLPzz//bHhuT25gMvr5CwAAAAAAAABAVeF0OjV9+nSPrn80bdq03GPV5Tpcdbwe4is9e/ZUq1atXNZcffXVfkpzgifXXF566SXDtdu2bdMPP/xgqLZu3bqGrj8Z/VzatWuXoTp/qE6vb21iNpsNv1H9hx9+0Ny5cw3P3ahRI7322muy2WweZTr33HN10003eTTGnxITE9WgQYNKz2P0yfYJCQlKSkry23o1SYcOHZSQkGCo9rHHHvPafRkOh0MLFy7UXXfd5ZX5qjOLxaKBAwcaqn311Vc9utfMnU2bNmnixIk6fPiw1+YMlPPPP9/w9/7NmzdrwoQJLhscHDx4UGPGjFFubq63IpZhNGtKSorhRjIAAABARdGEAQAAAABQJRl9WoIkQzdFHDp0SP/5z38qE6lc0dHRhuq2bdvm8VM3/mT09TDyWhQVFemOO+5QampqhbKgrIsvvthw7VtvvaVff/3Vbd2OHTv0zDPPGJ73oosuKvfYd999pyFDhuh///tfpS44FxcXa/369YZqPb0RprJiYmIM17711ls+y+GpSy65xHDt/fffr6NHj7qt+/rrr/Xdd98ZmjMkJETnnnuu4QwAAAAAAAAAAATa8ePHNX78eC1atMjwmPr16ysxMbHc49XlOlx1vR7iK+PGjVOfPn1O+WfEiBFq166dX/P07dtXdevWNVS7bt06vfrqq27rcnNzNXnyZMNvMLzwwgtlMpnc1hm9vv3NN98Yuj7lD9Xp9a1tBg8ebLj2vvvu09dff224PiYmRg0bNvQoz65du5SZmenRGH+rbEOD4OBgderUyXB99+7dK7VeUFCQR+vVFCaTyfD9ICtXrtSDDz5YqUYMaWlpeu+99zR06FCNGzdOq1evrvBcNYnR+yrS0tJ08803Kysrq8JrFRQUaP78+br66qs1fPhwffXVVyopKanwfFVFeHi4hg0bZrh+/vz5uuCCC/Tee+8pJSVFBQUFysnJ0ZYtW/TMM8/oggsu0O7du32W1+jPKVlZWR419wEAAAAqwhroAAAAAAAAnEqdOnUM1z722GOqW7euzjjjjFMeX7RokaZOnarjx497K14Z7p6y8nc33XSTzjrrLHXq1EkxMTGyWv/5T/N+/fopPj6+zL46deoYulD4xRdfqHXr1rr66qsVFBT0j+Pbtm3TlClTtGHDBsOZ4VqrVq3Ur18/LV261G1tcXGxbr75Zk2dOrXcC8VLly7V5MmTDd8YkpycrAEDBrisSUlJ0eOPP66ZM2eqa9eu6t+/v/r3769WrVrJbHbfozM9PV3333+/Dhw44LbWZrMZ7krvLc2bN5fZbJbD4XBb+8orr2jNmjXq3bu3EhISFBwc/I+a1q1bq02bNr6IWsYll1yiZ5991tDf9YEDB3TNNdfo8ccfV+fOnf9x3OFwaPbs2XriiScMr3/xxRcrLi7Oo8wAAAAAAAAAAPjCb7/9JovFcspjBQUFOnbsmH7//Xf98ssvKi4u9mjuc845x+Xx6nIdrrpeD/GVoUOHaujQoYGOUSooKEijR4/W008/bah+5syZys7O1m233aaQkJB/HN+zZ4/uvvtubdq0yfD6o0aNMlTbsmVL/fTTT27r0tLSdOGFF+rcc89Vy5YtFRkZecomBJ40ra+o6vT61jYXXnihZs6cqZycHLe1xcXFmjBhgn799Vfdeuutqlev3inrcnJy9P777+u1115Tdna2R3m2b9+uf/3rX5o1a5ZHD//wp+7du3vUjOJkHTp0OOXX9fJ069ZNX3zxRYXXa9++vUJDQys8vjobPXq03nrrLRUVFbmt/eCDD7R161ZNmDBBPXr0cFvvdDq1Z88eLV26VPPnz9fq1asNN4WpSlq3bu21ud555x316tWrzL4/723Ztm2b2/G//fabLrroIt15550aMmSIofPk6NGjWr16tb7//nv9+OOPysvLq3D+quz666/XnDlzDH98+/bt00MPPeTjVKfmyX14U6dO1YIFC9StWzfFxcWd8mf0rl27qlGjRt6MCAAAgFqEJgwAAAAAgCqpbt26atCggQ4ePOi2NisrS2PHjlXnzp3Vq1cvNWjQQJK0f/9+/fTTT4YuxFVG+/btDdcWFxdr3rx5mjdvXrk177zzzj+aMHTq1MlQF3Gn06nHH39cs2fP1uDBg5WUlKTw8HAdPXpUv/76q1auXFmpzvs4tQkTJmj58uWGbnrLycnR3XffrZdffllnnXWWkpKSFBQUpMOHD+vnn3/2+Ma8iRMnGmqkIJ34/Fu5cqVWrlypJ598UqGhoWrevLlatGihxMRERUREKCIiQmFhYSosLNTRo0e1efNmLVu2TAUFBYbW8OYFdqPCw8PVtGlT7dq1y1D9qlWrtGrVqnKP33rrrX656TA8PFzjxo3T9OnTDdXv3r1bV1xxhbp27aq+ffsqISFBRUVF2rt3r3744QdDTTL+ZLPZdOutt1Y0OgAAAAAAAAAAXvXRRx/po48+8vq8VqvV7Runq8t1uOp6PaQ2ueaaa/T+++/ryJEjhupff/11zZkzR4MHD1bz5s0VERGhtLQ0rVmzRkuXLvWo4chVV12lhg0bGqrt0KGD4XkzMjLcnpv+aMIgVZ/Xt7aJiorSmDFj9Nxzzxke89FHH+mzzz5Tr1691K1bN8XHx6ukpESpqalav369Vq9eXak3Qq9bt0633XabXn755VO+ITfQunXr5tfx3bt3r9R6Xbt2rdT46iwhIUFjxozRK6+8Yqh+3bp1Gj16tJKSktStWze1bNlSUVFRCg4OVnZ2trKyspSenq5t27Zpy5YthpqXQJo8ebLGjBljqPbQoUOaNGmSHn74YfXs2VNt2rRRXFycbDab8vLylJmZqczMTKWkpGjTpk06duyYj9NXDUlJSbrrrrv0wAMPBDqKW82aNSv9+3LH6XRqyZIlWrJkSbk106dPpwkDAAAAKowmDAAAAACAKmvgwIF6//33DdevX79e69ev92GiU4uPj1fHjh21ceNGn60xaNAgj55McPDgQb3zzjs+y4Oy2rdvrzFjxuiNN94wPCYlJUVvvvlmpdYdMmSIBg8eXOHxBQUF2rRpk+EnvBjNFAiDBg0yfNNhVTJ69GjNmzdP69atM1TvdDq1Zs0arVmzplLrTpw4UQkJCZWaAwAAAAAAAACAqu6aa65R06ZNXdZUp+tw1fV6SG1hs9n08MMP61//+pfhhhxpaWn6+OOPK7Vu48aNdfvttxuu79u3r0JCQlRYWFipdf2tury+tdHYsWM1b948jx6QUVRUpJ9//lk///yzTzL9/PPPmjx5sp588kmZTCafrFFRLVu2VHR0tDIzMys03tOmCM2aNVNsbKzS09MrtF5lm0ZUdzfffLMWLVrk0ef3gQMHPHqIAlzr16+fRowYoU8++cTwmKysLC1YsEALFizwYbLq5corr9SCBQv0yy+/eGW+4OBgDRs2zOuN1Mxms8444wyXDzgCAAAA/MXYYxIBAAAAAAiAa665Rlard/sHDh8+3Kvz/WnkyJE+mfdPgwcPVpMmTbw6p69ei9rqjjvuUO/evf22XsuWLfXII4/4bT0jYmJidNFFFwVk7SuuuKLK3TxjhNVq1dNPP6169er5bc0LL7zQ7VO/AAAAAAAAAACo7nr27Kn//Oc/buuq03W46no9pDYZMGCAbr75Zr+tFx4ermeffVYRERGGx8TExASssXplVYfXtzYKDg7Wiy++qJiYmEBHKePrr7/WtGnTAh3jH0wmk0477bQKj/W0CUNFxvxdZcbWBKGhoXr++ecVFxcX6Ci12tSpUyt83uAvzzzzjNq0aVPpeaxWq2bMmKEuXbpUPtQp+Po+PAAAAMAomjAAAAAAAKqs5ORkjR492mvzDR8+XJdcconX5vu7Sy65xGcXliQpKChId911l9fma9WqlaZOneq1+XDi7+jFF1/0y1MgkpOT9eabbyoyMtLna3li6tSpAbvxoEmTJrr++usDsnZlJSYmatasWapbt67P1xo8eLCmT5/u83UAAAAAAAAAAAikAQMG6OWXX1ZwcLDb2up0Ha46Xw+pTcaPH69rrrnG5+uEh4frpZdeUrt27Twee8cddyg6OtoHqXyvOry+tVHjxo01a9YsxcbGBjpKGbNnz9aLL74Y6Bj/UNH7Cpo3b16hZhcVXS85OZnmA5KaNm3qt2v6OLWQkBC9/vrrNGKopMjISL3zzjvq2bNnhecIDw/Xc889p6FDh6qwsNDQGE8fwtSnTx+de+65FYkHAAAAeBVNGAAAAAAAVdqkSZN0+umnV3qeM844Qw899JAXEp2a1WrVzJkz1bRpU5+tMXjwYN1+++2VnicpKUmvv/66bDabF1Lh7yIiIvTWW29p2LBhPlujX79++vDDD5WQkOCzNTxlMpk0adIkXXDBBQHNceedd2rQoEEBzVBRLVq00CeffKKOHTv6ZH6TyaQxY8bo+eefV1BQkE/WAAAAAAAAAAAg0GJiYnTffffp1Vdf9ejJ9dXpOlx1vh5Sm0yZMkVTpkzx2XWZRo0a6b333lPv3r0rNL5BgwaaOXOmR+dJVVLVX9/aql27dpo7d6569OjhszU6dOigOXPmePTm3Oeee04ffPCBzzJVREWbIlR0XPfu3Ss0rmvXrhUaVxO1adNGn376KU0AAujPBgKXXXZZoKNUa9HR0Xrrrbc0fvx4hYWFeTS2Z8+emjNnjs466yxJUkZGhqFxoaGhnsbUI488os6dO3s8DgAAAPAmmjAAAAAAAKo0q9Wq559/vlJv7r700kv10ksv+fyNx0lJSZozZ46uvPJKjy9SGXXLLbdo4sSJHncI/1PHjh310UcfqX79+l5Ohj8FBwfrscce0wsvvKCGDRt6bd7Y2Fjdd999evPNNz16soXNZpPZ7LtfATVo0EAvvPCCbrzxRp+tYVRQUJBefvll3XPPPdXyCRSJiYn68MMPNWHCBK/e8NayZUvNmjVLd999t08/FwAAAAAAAAAACASTyaT27dvr3nvv1aJFizRq1CiZTCaP56ku1+Gq+/WQ2uSaa67RnDlzvPqG9KCgIF199dX64osv1LZt20rNdfrpp2vu3Lk644wzKnTOBFpVf31rqwYNGuidd97RhAkTvNqQpmnTppoxY4Y++eQTdejQQU8++aT69OljePxDDz2k7777zmt5Kqtjx44KDg72eFxFmyK0a9euQvexVLTpQ01Vv359vf/++5oyZYpiY2N9skbTpk1122236a233vLJ/NVdcHCwpk2bpjfeeEMtW7b0yRoxMTG68sor9cEHH3j1vp+qxGKxaNy4cfr+++81btw4lw8dioiI0LnnnqtZs2Zp9uzZSk5OLj22b98+Q+vVqVPH44xRUVF677339O9//1tRUVEejwcAAAC8oWK/KQYAAAAABMTw4cM1fPjwQMfwO5vNpqeeekr9+/fXSy+9pD179hgal5ycrIkTJ2rw4ME+TviXiIgIPfDAA7rzzjs1f/58rV+/Xps3b1Zqaqqys7OVl5cnp9NZqTXGjh2rHj166Mknn9SqVasMjYmJidENN9ygMWPGVPjGMXjm7LPP1sCBA/XVV1/po48+0m+//VaheZKTk3X55Zfr8ssvr9Ab888//3z17dtXy5cv17Jly7Rq1Srt2bOn0p+H7du317Bhw3TFFVd4dHNIr1699Mcff1RqbVdMJpOuu+46jRo1SkuWLNHq1au1adMmHTx4UDk5OcrJyZHdbq/w/L7+Omy1WnXTTTdpxIgR+vDDD/Xpp59q//79Hs9jMpnUo0cPXXnllRoyZAjNFwAAAAAAAAAA1ZrValVwcLAiIyMVFxenBg0aKDk5We3bt1ePHj281oygulyH8/X1EHhP69at9e6772rZsmV6//33tWTJEhUXF3s8T2xsrC655BKNGjVKjRo18lq+Jk2a6PXXX9fevXu1YMECbdy4Udu2bVNmZqays7NVUFBQqfkXLVrkpaSnVtVf39rKbDbrpptu0pVXXqmPP/5Y7733ng4cOODxPCEhITrjjDM0fPhwDRw4sMw1z+DgYL344ou69tprtXHjRrdzORwOTZo0SdHR0erbt6/HWbwtODhYnTp10urVqz0aV9GmCEFBQerUqZNWrlzpl/X+5Ov7AwLBbDbrmmuu0aWXXqrPPvtMc+fO1aZNmyo8359/N3369NGAAQPUqVMnL6atufr3769+/fppwYIF+uSTT7Rs2TKVlJRUeL6WLVuqd+/eOv3009WvXz+fP+inqqhXr57Gjx+v8ePH6+jRo9q1a5fS09PldDoVHh6uhg0bqmnTprJYLKccb/Tn5Yp+bw0KCtJ//vMf/fvf/9aCBQu0bt06bd68WUeOHFF2drZyc3PlcDgqNDcAAABghMlZ2TvuAQAAAADwI4fDoR9//FFLly7V2rVrdfToUWVmZkqSIiMj1bhxY3Xo0EGDBg1Snz59/vHG46KiIqWlpRlay9dPqfGGjRs3avHixVq1apX279+vjIwMFRUVKTw8XImJiWrdurX69++vs84665RPmTh8+LChdeLi4ir0FAb85ciRI/rll1+0ceNG7dy5U4cOHVJ6eroKCgrkdDoVEhKiqKgo1a9fX82aNVOHDh3Uu3dvNW/e3OtZcnJytHnzZm3evFn79+/X/v37dfDgQWVkZCg/P1/5+flyOp0KCwtTWFiYIiIi1KhRIzVv3lwtWrRQv379qsX5UVP88ccfWrFihTZv3qzdu3fr8OHDys7OVmFhocxms0JCQhQXF6fExES1bNlSHTt2VP/+/Sv0JAEAAAAAAAAAAHAC1+HgCzk5OVq+fLl+++03/fHHHzp48KCOHz+u/Px8lZSUKDg4WBEREapXr54aNWpU2mikS5cuNN02gNe3anI6ndq2bZvWrFmjNWvWaM+ePcrMzFRmZqZyc3Nls9kUFRWl6OhoNWzYUJ07d1bnzp3VoUMHhYaGBjo+4Nbhw4e1bNkybdq0STt27NDhw4eVmpqqgoICORwOhYWFKTw8XOHh4UpISFBycrKaNWumFi1aqHPnzqf8OQKeyc7O1ooVK7RhwwZt27ZNBw8e1NGjR5Wfn6/i4mKFhIQoIiJC4eHhio2NVXJyspKTk9W8eXN17txZ8fHxgf4Qqp0VK1bo2muvNVT70EMP6YorrvBxIgAAAMD7aMIAAAAAAAAAAAAAAAAAAAAAAAAAADWU3W6XxWKp9DxFRUUaNWqUNmzYYKh+/vz5atq0aaXXBQAAAPyNlp0AAAAAAAAAAAAAAAAAAAAAAAAAUEPNnj1bt99+u+HmCaeSn5+vSZMmGZ6jbdu2NGAAAABAtWUNdAAAAAAAAAAAAAAAAAAAAAAAAAAAgG/Y7XbNnz9f8+fPV/v27TV06FANGTJEjRo1cju2qKhIP/zwg5577jmlpKQYXnPUqFGVSAwAAAAEFk0YAAAAAAAAAAAAAAAAAAAAAAAAAKAW2LRpkzZt2qQnn3xSCQkJateunVq1aqWYmBhFRkZKknJzc3Xs2DFt3bpVGzZsUFZWlkdrNG3aVJdccokP0gMAAAD+QRMGAAAAAAAAAAAAAAAAAAAAAAAAAKhljhw5oiNHjmjx4sVem9NisWjatGkKCgry2pwAAACAv5kDHQAAAAAAAAAAAAAAAAAAAAAAAAAAUP3ddddd6t69e6BjAAAAAJVCEwYAAAAAAAAAAAAAAAAAAAAAAAAAQKVMnDhR1113XaBjAAAAAJVmDXQAAAAAAAAAAAAAAAAAAAAAAAAAAED1FBMTo2nTpmnw4MGBjgIAAAB4BU0YAAAAAAAAAAAAAAAAAAAAAAAAAKCGMplMPpk3KChIl156qcaPH6+4uDifrAEAAAAEgsnpdDoDHQIAAAAAAAAAAAAAAAAAAAAAAAAA4H1FRUVavny5vv/+ey1ZskTHjx+v1HzNmzfXeeedpxEjRighIcFLKQEAAICqgyYMAAAAAAAAAAAAAAAAAAAAAAAAAFBL7NmzR+vWrdPmzZu1f/9+7d+/X2lpacrPz1dBQYGcTqeCg4MVHh6uOnXqqH79+mrWrJnatGmjHj16KCkpKdAfAgAAAOBTNGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQZA50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKqAJgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiCQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkmjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIogkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAJJowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKIJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCSaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiiCQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkmjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIogkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAJJowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASJKsgQ4AIHCOHcsOdIQqLTjYUma7qMgeoCQAfIlzHaj5OM+B2oFzHagdONeBmo/zHKgdONcrpm7dyEBHAADUEtxL4Bo/ywC1A+c6UPNxngO1A+c6UPNxngO1A+c6UPNxnlcM9xEAvmUOdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICqgCYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAogkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAJJowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKIJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCSaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiiCQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkmjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIogkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAJJowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKIJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCSaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiiCQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkmjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIogkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAJJowAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKIJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCSaMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiiCQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkmjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIkqyBDgAAAAAAAFDTFNmL9PP+JVqyf7G2pG5WZmGGShwlCrWGqkVMS3WM76T+DQeqbZ12gY4KAAAAAAAAwBMluQo+8L6CDn4qmcwKsrVVXvIkOUPqBToZAAAAAAAAAADVitPpVFZKpo7/dliHfj2otD9S5XQ4Fde+rk67pbsiGkQGOiKAWszkdDqdgQ4BIDCOHcsOdIQqLTjYUma7qMgeoCQAfIlzHaj5OM+B2qEqnOtOp1O/HPhJc7d/om92famMwgy3YzrGd9bodtdqZJtRCrOG+T4kUM1VhXMdgG9xngO1A+d6xdSty80lAAD/4F4CF+z5iv1tuKxpS8vsdlgildFjvuyRHQIUDIC38e8WoObjPAdqB851oObjPAdqB851oOYoyS/W0fVHdPjXgzqy+pAOrz6k/ON5p6y12qwa/s2Vim9f188pqw/uIwB8iyYMQC3GjROu8Y80oHbgXAdqPs5zoHYI5LmeVZipj/54X7N+f0M7MrZXaI6kiIaa0vt+DW85QmaT2csJgZqD7+tAzcd5DtQOnOsVw80TAAB/4V6C8oVvv1+2lKdPeawkooPSe/0omYP8nAqAL/DvFqDm4zwHagfOdaDm4zwHagfOdaB6cjqdyt6XpSNrTjRbOLL6oI5vPCZHicPwHFFNozVqxRiZzCYfJq2+uI8A8C1roAMAAAAAAABURymZu/Xib8/pkz8+VF5JbqXmOpCzX+MWjNW7m9/WS4NfV4OIJC+lBAAAAAAAAOAtwUe/LPeYNed3BR+fr6J6F/gxEQAAAAAAAAAAVUNxTpGOrj+iI2sO6cjqQzq85pDyj+VVas6slEyl70hTXKs6XkoJAMbRhAEAAAAAAMAD29O36Zk1T2ru9k9kd3q3o/ayg79o0Ed99eyZL2tI8nlenRsAAAAAAABAJTidMheluiwJ3T+LJgwAAAAAAAAAgFoh90iODq08qEMrD+jwygM6/vsxOR1Or6+TvS+LJgwAAoImDAAAAAAAAAbsSN+ux3+dpi93fianvP9L4j+lF6brmu9G6v4+j2hcl9tkMpl8thYAAAAAAAAAg0wm2cNbyZz5a7klwakLZC44KEdoAz8GAwAAAAAAAADAt5xOpzJ2pOvQygM6tOKADq08oKw9mX5Zu16X+n5ZBwBORhMGAAAAAAAAF47mHdWTq6Zr9ua3ZHfa/bbug8vv1f6cvXqk3+OymC1+WxcAAAAAAADAqRXWPV9BLpowmORUUOoiFSaN9mMqAAAAAAAAAAC8y2F3KHXzcR1cvv9E04UV+5V/PN/vOVpf3k5hdcL8vi4ASDRhAAAAAAAAOKW84jy9sv4FPb/uGeUW5wQkw5sbX1N+cb5mDnpeZpM5IBkAAAAAAAAAnFDQYJTCdz4sk7Ok3JrgtCU0YQAAAAAAAAAAVCv2IruO/nZEh1bs18Hl+3X414Mqyi4KaKbkoc014ImzApoBQO1GEwYAAAAAAICTLNgzX5N/mqi92XsqPVfLmFYa0GiQQq1hSsncrZ/2L1FWUabh8e9vnS2L2aonBjxNIwYAAAAAAAAggJwh9VQSP1BBxxaUWxOU9qPkdEomkx+TAQAAAAAAAABgXHFusQ6vPqhDy/fr4MoDOrLmkOwF9oBmCooIUmL3Bkrs0UBNhrZQfIe6Ac0DADRhAAAAAAAA+H8Hcw7o3l8m6+tdX1RqnviwurqqzdUa3mqE2sa1k+lvN1znFefp4z8+0IxVj+p4/jFD883ePEtRwVG6v+/DlcoFAAAAAAAAoHJK6gxy2YTBUnREltytske09WMqAAAAAAAAAADKl388T4d+PahDKw7o0K8HdHzDUTlKHAHNFJ0co/o9Giihe6Ia9W2oOm3jZbaceFhZUVFgG0IAgEQTBgAAAAAAADmdTs3a9IYeXn6/cotzKjxPj/q9NKbDWF3Q/GKFWEJOWWMLsum6Djfo0lYjNPmnifpk24eG5n7xt2fVKKqxxnQYW+F8AAAAAAAAACqnJH6g25qgzFU0YQAAAAAAAAAABITT6VT23iwdXHFAh1bu16GVB5WxPS2gmaw2q+p1qa+EboknGi90S5Strq30eHCwJYDpAODUaMIAAAAAAABqtSN5R3THonFauPeHCs8xpOl5uqPbRHVN6G54TGRwlF4c/Jr6Njhdk366QyWOErdj/vvzJDWKaKSzmw6pcFYAAAAAAAAAFeeI6iRHUJzMxeXfsGrNXCslXePHVAAAAAAAAACA2srpdCprT6YO/LJPB37Zp4PL9yv3UMUfSOYNMS1ildAt8UTThW6JimsbL7PVHNBMAOApmjAAAAAAAIBa67vd3+jOxbcqtSDV47EmmXRR82Ea322COsR3rHCGUe2uUVJkQ10/b7Ryi13/0tvhdOjmBWP1/YglahbdvMJrAgAAAAAAAKggk1n2mG4yHyu/qas1a60fAwEAAAAAAAAAapucg9na//M+HVy6T/t/2auc/dkBy2IJsajeafVVv2cDJfZKUv3uiQqNDQtYHgDwFpowAAAAAACAWqfQXqh7f5mstze9WaHxAxoO0n19H1bH+E5eyTOw0Zn66ILPdMXXw9w2YsgqytSYeVfr2+ELZAuyeWV9AAAAAAAAAMbZo7spyFUThpzfJXuBZAn1YyoAAAAAAAAAQE1lL7Lr4PL9Spm3U3sXpyhzV0bAsoREh6h+ryQ16JWk+r2SVK9zPVlCeKsygJqHr2wAAAAAAKBWOZhzQDfMv1prjqz2eGzbuPa6v+/DOrPxYK/n6pnYSx9cMEcjvxqmvJI8l7WbU3/XpB/v0AtnvSqTyeT1LAAAAAAAAADKZ4/p5vK4yVkia85GlUT38FMiAAAAAAAAAEBNU5hVqL0Ld2v3vJ3auzBFRVmFAclhSwhXgz4NldgrSQ36JCmuTbxMZu5dBVDz0YQBAAAAAADUGssPLtUN86/R8fxjHo2LDI7Sf3tN1XXtb5TFbPFROql3Yh+9cvb/dN28q+RwOlzWfrLtQ/Wo30vXdbjBZ3kAAAAAAAAA/JM9uqvbGmv2ZpowAAAAAAAAAAA8kr0/Synzd2r3dzt1cNl+OUpc30vqC1FNok80XeidpAa9kxSVHMMDwwDUSjRhAAAAAAAAtcKbG1/V1KX3qMRR4tG4YS0u1UP9pishvL6PkpU1JPk8TTt9hu75eaLb2vuW3qO+DU5Xq7jWfkgGAAAAAAAAQJKcofXlCEmUufBQuTWW3C1+TAQAAAAAAAAAqI6cTqeO/35Mu7/boZR5O3X8d88eMuYNcW3qKLF3QzXok6TE3kmKSIz0ewYAqIpowgAAAAAAAGo0h9Oh+5dN0avrX/RoXP3wRD0z6AWd2fhsHyUr3w0db9Lm1N81e/NbLusK7AUat3Csvh2+QMGWYP+EAwAAAAAAACB7ZFuXTRisOTRhAAAAAAAAAAD8k73IroPL9mv3vB1Kmb9LOQey/ba22WpW3c71lNgrSYm9klS/Z5LC6oT5bX0AqE5owgAAAAAAAGqsQnuhbl3wL32xc65H4y5sfomeHPCMYkPjfJTMvWmnz9DGY+v127F1Lus2HPtNT656TP/tfZ+fkgEAAAAAAABwRLaVji8q97gld6sf0wAAAAAAAAAAqrLCzALtXZii3fN2au/C3SrKLvLLulZbkOr3aKDEXg3UoHeS6nVNVJAtyC9rA0B1RxMGAAAAAABQI2UWZuja767SsoO/GB4TERSp6f2f0OWtr5TJZPJhOvdCraF6c8hsDf64v9IL013WPrdups5qco56Jfb2UzoAAADA/44dO6rRo0coNze3dN999z2sc84Z6vFc27Zt1dix18put0uSTCaTXnjhNXXufJrX8gIAgJrNHtHO5XFL4SGZijPkDIrxTyAAAAAAAAAAQJWSvT9Lu+ftVMq8nTq4bL8cJQ6frxkUEawGfZKU1K+RGvRtqPgO9WS2mn2+LgDURDRhAAAAAAAANc6R3MO6/KtLtCVts+ExbeLa6q0h76lZTAsfJvNMo8jGevnsNzXy6+Eu6xxOh25b+C/9OHKFwqxhfkoHAAAA+FfduvV0yy13aMaMaaX7nn32SfXo0UuxsXGG5ykpKdH06Q+VNmCQpGHDLqMBAwAA8Igjsq3bGkvuVpXE0DgVAAAAAAAAAGoDp9Op4xuPljZeOP77MZ+vaQ2zqn7PJDXs30hJ/RqpbucEmi4AgJfQhAEAAAAAANQoB3MO6pIvztPOjB2Gx1zcfLiePvMFRQRF+DBZxZzZeLD+1WmcXt3wksu6lKzdemLVdN3X5yE/JQMAAAD876KLhmnhwu+1Zs0qSVJmZqZmzpyhhx9+zPAc7777lrZv31a6Xb9+ov7979u8nhUAANRs9gj3TRisOZtpwgAAAAAAAAAANZi9yK6Dy/Zr97wdSpm/SzkHsn2+ZkzLOCUPaa4mg5OV0LW+LCG8TRgAfIGvrgAAAAAAoMbYl7VPF805T7szdxmqN5vMurf3g7qly+0ymUw+TldxU3o/oB/3L9bWtC0u617+7Xld0mK4OtXt4p9gAAAAQADcffe9uvbakcrPz5ckLV68QD/+uFgDBgxyO3bXrp16++03T5pvimw2m0+yAgCAGiwoSo7QhjIX7C+3xJLj+vd5AAAAAAAAAIDqpzCzQHsXpmj3vJ3au3C3irKLfLqeyWxS/R4N1HRIcyUPaa6Y5rE+XQ8AcAJNGAAAAAAAQI2wL2ufzv/0XO3N2mOo3ma16Y1z39bgJuf6OFnlhVpD9dLgNzTk00EqcpT/y3q70647Ft+q+ZcuVpAlyI8JAQAAAP9p0CBJY8eO03PPPVW6b+bMx3Taad0UFRVV7ji73a7p0x9ScXFx6b7zz79IPXrwdGoAAFAx9si2LpswWHO3+jENAAAAAAAAAMBXMnala8+C3dozf5cOLt8vR4nDp+tZbVY1GtBEyUNbqMngZIXF82ABAPA3mjAAAAAAAIBq72juEV0y9wLDDRjiw+rq/fM/UZd6XX2czHs6xHfU5F5T9dDyqS7rfj++QS+vf163d73TT8kAAAAA/7vssiu0ePEP2rhxgyQpNTVVzz33lO6998Fyx3z44bvasmVT6XZ8fF3ddhs/NwMAgIpzRLSVjv1Q7nFrzhY/pgEAAAAAAAAAeEtJfrEOLNuvvQt3a8+C3cpKyfT5mmF1bWp6bjMln9tcDc9oLGsYD+MCgECiCQMAAAAAAKjW0gvSNOzLC7UzY4eh+uToZvrwgrlKjm7m42Te9+/Ot+jLHXP127F1LuueWv24hrW8TI0iG/spGQAAAOBfZrNZkyffp+uvH6WiokJJ0rx532jw4HPVu3fff9Tv3btHb775Wpl9EydOVkREhF/yAgCAmske2dblcXPRUZmKUuUMruOnRAAAAAAAAACAiijMKtSR1Yd0+NcDOrzqkA6tOiB7gd3n68a2ilPTIc2VfG5zJXRLlMls8vmaAABjaMIAAAAAAACqrZziHF31zWXafHyT+2JJneuepg8umKP4sHgfJ/MNq9mqpwe9qLM/PUMljpJy6/JL8nX/0in635DZfkwHAAAA+FeTJk11/fVj9eqrL5TumzFjmt5992PZbOGl+5xOpx577OHSZg2SNHjwuTr99AF+zQsAAGoeR2Q7tzXW3K0qDu7nhzQAAAAAAAAAACOcTqey92Xp8K8HdejXgzr86wGlbjkuOX2/tslsUv2eDdT03OZKHtpcMc1ifb8oAKBCaMIAAAAAAACqpRJHiW6af53WHFltqL5bQg99eMEcRYfE+DaYj7WP76DbTrtDT6950mXd17u+0JJ9izSw0Zl+SgYAAAD435VXjtbixQu0bdtWSdLRo0f00kvPaeLEe0prPv30I23Y8FvpdkxMrO64Y5K/owIAgBrIHtHGbY0ld4eKY2nCAAAAAAAAAACBYi+y6/imYzr8/w0XDq86qNzDuX5b32qzqtGAJkoe2kJNBicrLN7mt7UBABVHEwYAAAAAAFDtOJ1O3f3TBC3Y+72h+l6JffT++Z8oMjjKx8n84z/d7tJXO7/QjoztLuv++/MkLbliuYItwX5KBgAAAPiX1WrVPffcp7Fjr1FJSYkk6Ysv5urMM89W167ddeDAfr322otlxvznP5MUExMTgLQAAKDGsUbIHtpQloL95ZZY8nb4MRAAAAAAAAAA1G6FmQU6/vux//9zVMd/P6b0balyFDv8miOsrk1Nz22m5CEt1LB/I1nDgvy6PgCg8mjCAAAAAAAAqp3n1z2t2ZtnGartWb+3PrhgjiKCInycyn9CraF6csCzuuSL81zW7cjYrlc3vKTbTrvDP8EAAACAAGjZspVGj75Ob731hqQTTdsef/wRvfXWB5oxY5ry8/NLa/v3H6izzjonUFEBAEANZLc1d9OEYacf0wAAAAAAAABA7WAvsitjR5rStqYqdctxpW09rtQtx5W9NytgmWJbxanpkOZKHtJcCV0TZTKbApYFAFB5NGEAAAAAAADVypc7PtMjKx4wVNupbhe9f/4nNaoBw5/6Jp2u4S0v09ztn7qse2rV47qs5eVKjGjgp2QAAACBY8rMkPnQoUDHqDEciYlyRscEOoYh1157g378cZF2794lSTpwYL9uvvkG7dixrbQmMjJKEyZMDlREAABQQ9nDmkv6sdzjNGEAAAAAAAAAgIpxOp0qSM1Xxs50ZexKV8bOdGXuTFf6jhP/dZQ4AprPZDapfs8GSh7SXE2HNFdMs9iA5gEAeBdNGAAAAAAAQLWx6fjvun3RzYZqW8W21ocXzFVUSLSPUwXOA32naX7KPOUW55Rbk1eSqweX36tXzv6fH5MBAAD4l3XlCkXefaesm38PdJQaxWkyyd62vbJnPK2Snr0CHceloKAg3XPPfbr55htkt9slqUwDBkm67bb/KD4+PhDxAABADWYPb+HyuCV/l+R0SCaznxIBAAAAAAAAQPXhdDqVdzRXWXuylL03U1l7MpWxK12Zu9KVsSNdhZmFgY5YRnBUiBoNaKwmZzdTk8HJCou3BToSAMBHaMIAAAAAAACqhfSCNF077yrlleS5rW0Y0UifXPiF4sNq9hus6ocnakL3u/XQ8qku6+Zu/1Q3dvy3utfv6adkAAAA/hO0ZJGiR42Qqbg40FFqHJPTKevm3xUz7DxlvveJigeeGehILrVr10EjRlypDz989x/Hevbso/POuzAAqQAAQE1ntzV3edzkKJS5YL8cYY39lAgAAAAAAAAAqgaH3aGC4/nKO5qrvGN5J/57NFe5R3KVtSdTWSkZytqbKXuBPdBRXarTvq4an9VUTQYnK6FboixBlkBHAgD4AU0YAAAAAABAlVfiKNFN31+vvVkpbmujgqP1/gWfKjGige+DVQE3dbpZH2yZre0Z21zW3bf0v/pm+A8ymUx+SgYAAOAHTqfCpz9EAwYfMxUXK/yxh5UxYJBUxX+evPLK0fr44/flcDhK94WFhemuu6YEMBUAAKjJ3DVhkCRL3k6aMAAAAAAAAACokZxOp3IP5Sh9W5rSt6cq7Y80ZWxPVcbODOUfz5PT4Qx0RM+YpDpt41W/Z5ISezZQg34NFZEYGehUAIAAoAkDAAAAAACo8p5Y9ah+3L/YbV2QOUizL3xfbeLa+iFV1RBsCdaj/Z/QiK8udlm3+siv+mrn57qoxTA/JQMAAPA9U1amgtatDXSMWiFo7RqZsjLljI4JdBSXXn/95TINGCSpsLBQqanHVb9+/QClAgAANZk9rKmcMsskR7k1lrwdKq4zyI+pAAAAAAAAAMC7HHaHsvdkKn17mtL+SFX69rQTf7alqTinKNDxKsxqC1JCt/pK7NFA9XsmKaF7okKiQgIdCwBQBdCEAQAAAAAAVGm/HPhJz6x5ylDt82e/pAGNBqqoyO7jVFXLgEaDdGHzS/TVzs9d1j204n6dm3yeQixcIAAAAEDNs2rVSn399Rf/2O9wOPT44w/rf/97T1Yrl0cBAICXmYPlCGssS35KuSWWvJ3+ywMAAAAAAAAAlWAvLFHGrowTDRb+bLawLVUZO9NlL6z+92aGJ0aofs8GSux5oulCfPu6MlvNgY4FAKiCuMsIAAAAAABUWWkFqbplwU1yyum29rZu4zWy7VV+SFU13dfnIc3f/a2KHOV3lN6blaI3N76mcV1u82MyAAAA33FGRav4tK4KWrc20FFqvOKu3eSMig50jHLl5eVpxoxpZfZZrVaVlJRIknbt2ql33vmfxoy5KRDxAABADWe3NacJAwAAAAAAAIBqpSCjQFkpGUrflqa0banK2Jam9O1pykzJkNPu/p7N6iA6OUbxHeqqTod6iu9QV/Ht6yo8MUImkynQ0QAA1QBNGAAAAAAAQJXkdDp1x+JbdSj3oNvaQY3P1P39HvJDqqqrSVRTje10s1787VmXdU+veUIj21yluNA6fkoGAADgQyaTcu+5T9GjRshUXBzoNDWWMyhIuffcJ1XhG1FeffUFHTr0178dWrduq+uvv1GTJ08o3Td79iwNGjRYycnNAhERAADUYHZbcyl1YbnHLXk7/JgGAAAAAAAAgLc47A5lbD/RnCD3SK7yj+XJXmSX0+6U0+mUJcSi4MgQBUcEKzgqWCHRoQqNDVVIbKhCY8MUEhMis8Xs99wlBSXKO5Kr3CO5yjuSo9wjucrek6msvZnK2pul7H1ZKsoq9HsuXwmOClFcmzqKaxOvOm3rKL59PdVpH6/gyJBARwMAVGM0YQAAAAAAAFXS25v+p3m7v3Fb1ziqqf533tuymvk1xx3dJuiDrbOVVpBWbk1mYYaeWvW4pvWf4cdkAAAAvlM88ExlfPatIu/6jyxbNsnkrBlP5KgKnCaT7G3bK3vG0yrp2SvQccq1fv1vmjv3k9Jtq9WqyZOnqmXLVjrnnKH6/vvvJEnFxcV67LGH9fLLb8ps9v+NTgAAoOay25q7PG7J3yM5SiR+hwkAAAAAAABUeQXp+dr51Xbt/HKbDq8+pJK8yj0QICQ65ERThrgwhcb82aDhRJOG0LhQhcSEKig8WGarSWarpfS/JqtJTrtT9iK7HMV22Qvtshc7ZC8oUVF2kQqzClWYUaCi//9vYWah8o7mKu9Irgoza06Dhb+zJYQrpnmsYprHKjo5RnFt41WnbbzCEyNkqsIPFQAAVE9c2QMAAAAAAFXOvuy9enD5VLd1weZgzRryrmJD4/yQquqLDonRpB736J6fJ7mse2vTm7qp8zg1iWrqn2AAAAA+VtKzl9KXLJMpM0PmQ4cCHafGcCQmyhkdE+gYLhUWFuqxxx6S82/NN0aNulYtW7aSJN1++wT9+usKZWSkS5I2bdqoTz/9SJdffmVA8gIAgJqpxNbC5XGTs0Tmgj1yuGnWAAAAAAAAACBw8o7katWTy7Xlg01yFNm9Nm9hZqEKMwuVlZLptTlrstC4UEU1iVZ0s9jShgsxzWMV3SxWwRHBgY4HAKhFaMIAAAAAAACqFKfTqUk/3qHc4hy3tff3fVgd4zv5IVX1cU27MXpz42vakbG93JpiR7Fm/PqoXhz8mh+TAQAA+J4zOkb2Kt40AN71xhuvaN++vaXbTZs203XX3Vi6HRMTo/HjJ+jBB+8t3ff66y/pjDMGqn79RL9mBQAANZfdQHMFa+4OFdGEAQAAAAAAAKhyHHaH1r+0RqueWqGSvOJAx6nZTFJYvE22euEKrx9+otlC0xhFNYlWZONoRTWJptECAKDKoAkDAAAAAACoUj7Z9qEW7V3gtu7sJufqxo7/9kOi6iXIEqT7+jysa74b6bLu020f6dbT7lDbOu38lAwAAADwri1bNunjj98v3TabzZo8eaqCgoLK1J199hD98MN8LVv2syQpPz9fM2ZM08yZL/g1LwAAqLkcoY3lNAXJ5Cz/Bm1z/m4/JgIAAAAAAABgREF6vr4f+432/7TXfTHcMplNimoardhWdRTbMk4xzWMVXj9ctrrhstULV2idMJmt5kDHBADAEJowAAAAAACAKiOzMEMPLJvitq6eLUHPnvmyTCaTH1JVP+c2Hap+Dfpr6cGfy61xyqnpvz6sd4Z+4MdkAAAAgHcUFxdr+vSHZLfbS/eNGDFSHTp0PGX9pEn3aPTotcrNzZUk/frrCn333dcaOvQCv+QFAAA1nNkqe1hjWfN2lltiydvlx0AAAAAAAAAA3Mk9kqOvRsxR2tbUQEepdszBFsU0j1VsqzjFtaqj2FZxim0Zp+hmsbKG8pZVAEDNwHc0AAAAAABQZTy5+nEdzz/utu65M19SfFi8HxJVTyaTSVP7PKghc850WTdv9zdaffhXda/f00/JAAAAAO94++03tWvXX29ybNAgSWPHjiu3vm7derr55tv15JPTS/c9//zT6t27r2Jj43yaFQAA1A72sGaumzDk7/ZjGgAAAAAAAACu5B3N1RfDP1XG9rRAR6nSgsKDFNu6jmJbnmiyENuqjuJaxSmySbTMFnOg4wEA4FM0YQAAAAAAAFXCH2lb9ebGV93WXdH6Kp3Z+Gw/JKreuiZ013nJF+rb3V+5rHt05UOac9FXMplMfkoGAAAAVM727dv07rtvldl39933KjQ01OW4iy8eroULv9e6dWskSVlZmZo5c4YefvgxX0UFAAC1iN3WTHLxwDxL3i7/hQEAAAAAAABQrvzUfH05ggYMfxcWH6bYlnGKaVlHca3jFNuyjmJbxSk8MYJ7CwEAtRZNGAAAAAAAQJVw/7L/qsRR4rImPqyuHur3qJ8SVX/39JqqeSnfyOF0lFvzy4Gf9OP+xRrY6Ew/JgMAAAAqpqSkRNOnP6SSkr/+7XDhhcPUrVsPt2NNJpPuvvteXXvtSBUWFkqSFi9eoJ9/XqL+/Qf6JjAAAKg1HLZmLo9b8lMkp10yWfwTCAAAAAAAAMA/FGQU6KvL5yhti4uOquWw2oIUXj9cwZEhMllMMpmk4rwSFecUqSi7UEVZRXI6nD5IXXl/Zo9qHK3IxtGKahylqCYn/j+6SbRC48ICHREAgCqHJgwAAAAAACDglh9cqkV7F7ite7jfdMWGxvkhUc3QOq6NRrQaqY/+eN9l3aMrHtSAhoPoWA0AAIAq74MPZmvbtq2l23Xr1tMtt4w3PL5hw0a64YZ/6aWXnivd99RTj+u007orIiLCq1kBAEDtYg9Ldnnc5CyWuWC/HGFN/JQIAAAAAAAAwN8VZRfq65FzdXzjUcNjGvRJUqsR7ZTUr5Gimka7vMfO6XCqKLtQBekFKkgvUGF6/t/+v0AF6fkqSCtQYUbZ/y/MLPTo4zAHmRUUHqSQqFAFR4coJCZEIVEhCokJVWhsqGwJEbLVs8mWEK7whAjZEsIVHBHs0RoAAIAmDAAAAAAAIMCcTqemr3zYbV2vxD4a3nKEHxLVLJN63KO52z9RsaO43Jrfjq3T17u+1IXNL/ZjMgAAAMAze/akaNas18vsmzjxHo+bJ1xxxSgtWrRAW7duliQdP35ML774rO6+e4rXsgIAgNrHbmvutsaSt5smDAAAAAAAAEAAFOcU6euRn+no2sOG6qMaR+uMJ85S40FNDa9hMpsUEh2qkOhQRRsfJofdIUexQ84Sh+wlJ/7rKDmxz2Q1yRJkkSXEIkuwReYgi0xmHrYEAIA/mAMdAAAAAAAA1G4/7l+sFYeWuawxm8x6tP8TLrtI49QaRzXRte3HuK17bOXDsjvsfkgEAAAAeM7hcGj69IdUVFRUuu/ss4eoX7/+Hs9lsVg0efJUWa1/9av/+uvPtXbtaq9kBQAAtZM9rLGcbm7FsuTv8lMaAAAAAAAAAH8qzivWN1d/rsOrDhqqr9slQZfOv8qjBgyVYbaYZQ21KigiWKExoQqLtym8foQiG0UpIjFSYfE2BUeGyBJipQEDAAB+RBMGAAAAAAAQME6nU4+tfNht3ai216hjfCc/JKqZ7ug2STZruMua7Rnb9Mm2D/2UCAAAAPDMp59+qN9/31C6HRMTq/HjJ1Z4vhYtWmrUqGtLt51Op2bMmKbCwoJK5QQAALWYOUSO0IYuSyx5NGEAAAAAAAAA/KmkoETfXfulDi7db6g+vmM9XfjxpQqrE+bjZAAAoKozOZ1OZ6BDAAiMY8eyAx2hSgsOtpTZLiriibBATcS5DtR8nOdA1TY/5Ttd/e0VLmtCLCFaOeo3NYhIKreGc9296Ssf0tNrnnRZ0yiysZZdtUYhlhA/pQI8w7kO1Hyc50DtwLleMXXrRgY6AgCgluBeAtdc/SwTveYiBactKXdsYb0LldX5PV9FA+BF/LsFqPk4z4HagXMdqPk4z4HaoaLnur2wRN9d/5X2LthtqD6ubbwunjuCBgxAAPA9vWK4jwDwLXOgAwAAAAAAgNrJ4XTosZWPuK27tv0Ylw0YYMy4LrcrJiTGZc2+7L16d/NbfskDAAAAAAAA1DT2sGYuj1vydvkpCQAAAAAAAFC72Yvt+v6mbww3YIhpGaeLPr2MBgwAAKCUNdABAAAAAABA7fT1zi+0KXWjyxqb1abbut7pp0Q1W3RIjG7reqceXn6fy7qZq5/QyDajFR4U7qdkAAAAAAAAQM1gtyW7PG7J2y05nZLJ5KdEAAAAAAAAQO3jKHFowbjvtPu7nYbqo5NjdPGcy2Sra/NxMgCoXfbu3asNGzbo8OHDKi4uVlRUlJo1a6auXbsqJCQk0PH8Ij09XWvXrtW+ffuUl5cnm82mRo0aqWvXroqNjQ10PLhBEwYAAAAAAOB3doddj/86zW3dDR3/pQRbgh8S1Q43dLhJr65/UUfzjpRbcyz/qN7c+Kpup/kFAAAAAAAA4BG7rZnL4yZHnsxFR+QIqe+nRAAAAAAAAEDt4rA7tOj2+dr5xTZD9VGNo3XR3BEKrx/h42QAUHssWLBAL730kjZt2nTK4zabTcOHD9ctt9yiuLg4P6f7p/z8fF100UXau3dvmf3Dhg3TY489VqE5t27dqmeffVZLliyRw+H4x3GLxaIBAwZo/PjxatOmTYXWgO+ZAx0AAAAAAADUPnO2f6ztGa4vckQEReqW0273U6LawRZk053d73Jb9/y6Z5RZmOH7QACAmqekRMFffaHIG69VXLcOim9aX3VaNlbMOQMUPvUeWX9bG+iEAAAAAOAz9jDXTRgkyZK3yw9JAAAAAAAAgNrH6XBqyYQftO3TLYbqI5IiddHcyxSZFOnjZABQOxQVFWnixIm65ZZbym3AIEl5eXl69913df7552vVqlV+THhqzzzzzD8aMFTG22+/rUsvvVSLFi06ZQMGSbLb7Vq0aJEuvfRSzZ4922trw7towgAAAAAAAPyq2F6sJ1ZNd1v37863KC60jh8S1S6j216rxpFNXNZkFmbopd+e81MiAEBNYV23RrFn9Vf0DVcr9MvPZNm3V6a8PJkzMxT02zrZXn1RsecMVPSIi2VdtybQcQEAAADA6+y2pm5rzDRhAAAAAAAAALzO6XTqp8mLtPX98t/0+3e2hHBdPOcyRTWO9nEyAKgdHA6H7rjjDn311Vdl9lssFjVs2FBt27ZVZGTZpjdpaWkaO3as1q1b58+oZWzYsEHvvPOO1+abNWuWHn30UZWUlJTZX7duXbVv315169Yts7+kpESPPPKIVzPAe2jCAAAAAAAA/OrDP97TnqwUlzUxITH6d+db/BOolgm2BGtSj3vc1r26/mUdzTvqh0QAgJog+MvPFHPBObJucX8zQ/CPixV77iBF3HmblJPjh3QAAAAA4CeWcNmD67suyacJAwAAAAAAAOBNTqdTS6cu0aa31huqD4u36eK5IxTdLNbHyQCg9njjjTe0cOHCMvtGjhypxYsXa+HChfr888/166+/6oUXXlCDBg1Ka/Lz83XHHXcoOzvb35FVVFSkKVOmyOFwSJJsNlul5lu7dq2eeOKJMvt69uypuXPn6pdffin976effqqePXuWqXv88ce1YcOGSq0P76MJAwAAAAAA8Jsie5GeXv2E27pbT/uPokLoMO0rl7W6Qq1iW7usySvJ1XNrn/JTIgBAdRb8/XeKuul6mYqLPRoX9u7bih3cX9bf1vooGQAAAAD4n93WzOVxSx5NGAAAAAAAAABvcTqdWvHwz9rwmrGnqIfGheqiOZcptmWcj5MBQO2Rnp6uV155pcy+CRMm6MEHH1RCQkLpPrPZrLPPPlsffvihkpKSSvcfPnxYs2bN8lveP7366qvatm2bJCkhIUFXXHFFpeabMWOG7HZ76fagQYP05ptvqn379mXqOnbsqDfffFMDBw4s3VdSUqIZM2ZUan14H00YAAAAAACA33z8xwfan7PPZU18WF3d0PEmPyWqnSxmiyb3nOq27q3f39S+7L1+SAQAqK7Me1IUOe4mmf6/G7inrLt2KubCcxXy+RwvJwMAAACAwHDfhGG3n5IAAAAAAAAANd+qGcu17oXVhmpDokN04SeXqU7beB+nAoDa5Y033lBubm7pdo8ePTR27Nhy6xMSEjRt2rQy+9566y2lp6f7LOPJtm/frldffbV0+7777lN4eHiF5/vxxx+1bt1fDYFiYmL06KOPKjg4+JT1wcHBevTRRxUTE1O6b9WqVVq6dGmFM8D7aMIAAAAAAAD8osRRomfXPuW27o6uExQeVPFfYsGY85tdqC51T3NZU+Qo0lOrHvdTIgBAdRQ5cbzMWZmVmsNUWKiom65X2LNPSU6nl5IBAAAAQGA4wpJdHrfk7+LfPgAAAAAAAIAXrJ65QqufWmGoNjgyWBd8fKnqdqzn41QAULs4HA7NnTu3zL5bb71VJpPJ5bg+ffqoe/fupdu5ubn67rvvfJLxZA6HQ1OmTFFxcbEk6eyzz9bgwYMrNeenn35aZnvUqFGKi4tzOaZOnTq66qqryuz75JNPKpUD3kUTBgAAAAAA4Bdztn2sPVkpLmsSwxvomvZj/BOoljOZTPpv7/vd1n34x3vakb7dD4kAANVN0E9LFPzjYq/NFzHtQYXdfotUUuK1OQEAAADA3+y2Zi6Pm0syZSpO81MaAAAAAAAAoGZa9/wq/frYMkO1VluQzv9guBJOq+/jVABQ+6xdu1ZpaX9d92jUqJF69eplaOxll11WZnvhwoVezVaet99+W+vXr5ckRUREaOrUqZWar6ioSL/88kuZfZdeeqmhsSfX/fTTTyoqKqpUHngPTRhQrezdu1dff/213njjDb388st67733tHz5chUWFgY6GgAAAADABbvDrmfXPuW27vau/1GoNdQPiSBJAxoOUr8G/V3WOJwOPf7rND8lAgBUG06nwqc/7PVpg2e/Ldv110j8zhcAAABANeWuCYMkWfJ3+SEJAAAAAAAAUDOtf3Wtlj/8s6Faa5hVF3wwTIk9G/g4FQDUTj/++GOZ7b59+8pkMhka27dv3zLbK1euVF5enteyncq+ffv07LPPlm7feeedSkhIqNScJ+dOTk5WUlKSobENGzZU06ZNS7dzc3O1atWqSuWB91gDHQAwYsGCBXrppZe0adOmUx632WwaPny4brnlFsXFxfklk9Pp1K5du7RhwwZt2LBB69ev17Zt21RcXFxaM2zYMD322GN+yQMAAAAAVdlXOz/XjoztLmvq2RJ0Vdtr/JQIkmQymXRPr/t0wWdnu6z7Yudc3X7sP+pYt7OfkgEAqjrryhUKWuP+Yk/ev8bJlJen0A/elamkxNDcQV99IdtVlytv9geSNaSyUQEAAADAr+xhyW5rLHm7VBLdww9pAAAAAAAAgJpl/etrtXTqEkO1lhCLhr5zsRr0aejbUABQi23ZsqXMdteuXQ2PTUhIUFJSkg4cOCBJKi4u1o4dO9SpUyevZvy7e++9V/n5+ZKk0047TVdddVWl5zz5NTjttNM8Gt+1a1elpKSUma9fv36VzoXKMwc6AOBKUVGRJk6cqFtuuaXcBgySlJeXp3fffVfnn3++z7u8zJkzR9ddd5169Oih8847T5MnT9b777+vTZs2lWnAAAAAAAA4weF06Ok1T7itu6XLeIVZw/yQCH/XM7GXzmkyxG3d9JXef9o5AKD6sr38vNuagiuuUu7DjynnqeeUtnS1inv1MTx/0MIFCr/0YpmyMisTEwAAAAD8zhkUI0eQ6weIWPJ2+ykNAAAAAAAAUHNsfHu9Fk9aaKjWHGTWkFkXqtGAJj5OBQC1265du8psN2/e3KPxLVq0cDmfN33yySdasWKFJCkoKEgPP/ywTCZTpec9OfPJH5M7J79mO3furHQmeIc10AGA8jgcDt1xxx1auLDsD8cWi0WJiYmKjIzU/v37lZ2dXXosLS1NY8eO1axZszzuFmPUwoULtXz5cp/MDQAAAAA10Xe7v9GWtM0ua+qE1tE17a/3UyKcbHKvqfp+zzyXNQv2fq8Vh5ard6LxN9ACAGom84H9Cp7/rcsaZ1iYcu59sHTbkdxMGZ99I9uT0xU+031zJkmyLl+m6EsvUuaHc+WsU6dSmQEAAAAY542bzWqyk1+eU71edlszmTPTyp3Dkr+b1xmo4oyc6wCqN85zoHbgXAdqPs5zoHYwmaStn27V8kd+kS3e5rbebDVr0DPnqPFZyX5IB8Ab+J5ePRUUFOjgwYNl9iUmJno0R/369cts797tm0bWR48e1YwZM0q3b7jhBrVs2dIrc5+c2dPX4OR6X70G8BxNGFBlvfHGG/9owDBy5EiNGzdOCQkJkk40ali4cKEeffTR0i/W+fn5uuOOO/T1118rMjLSr5ltNpvy8vL8uiYAAAAAVGVOp1MzV89wW3dzl9sUHhT+1w6HQ0G//KTgBd/Lsv0PmQoK5IyNU3HnLio69zzZ27T1Yerap0N8Rw1rcak+2zHHZd2jKx7UF5d8xy+3AaCWC/3gXZkcDpc1+ddcL+f//x63lNWqvMlTZW/WQpH/uVWm4mK3awWtX6eYS4Yq49Ov/jkfAAAAAJ+Ij48IdITqL6aVlLm63MOhxSkK5XUGAAAAAAAADOs5pqt6juka6BgAgL9JT0+X0+ks3Q4KClIdDx+2k3DSPWGpqaleyXayBx98UFlZWZKkpk2baty4cV6b++TMJ39M7pxcn5ZWfqPvgHI6pfxDUkm2VJIrOUokq02yhkuh9U78t4ahCQOqpPT0dL3yyitl9k2YMEE33XRTmX1ms1lnn322OnXqpCuvvFIHDhyQJB0+fFizZs3S7bff7rOMdevWVYcOHdSpUyd17NhRHTt21OzZs/XCCy/4bE0AAAAAqG4W7JmvjcfXu6yJCYnR9R1uLN0O+vlHRUy5S9atW/5RG/L1F9K0B1V0+hnKnXK/Srr18Hrm2uqunv/Vlzs/l91pL7dmxaFlWrxvgc5sfLYfkwEAqhS7XaHvz3ZZ4jSblT/25nKPF15+pRwNGynquqtkzshwu6T1j62KGX6+MuZ+QyMGAAAAANVDZAvXx3N2+icHAAAAAAAAAACAj5z8QPPQ0FCPH/Rms9lczukN3377rRYsWFC6/eCDDyokJMRr85+c+eSPyZ2wsDCX8wVEUYZ09GcpbZWUukrK3ibl7ZecJeWPCY6VwpOl2M5SXA8pvpcU28VfiX2CJgyokt544w3l5uaWbvfo0UNjx44ttz4hIUHTpk3TddddV7rvrbfe0tVXX63Y2FivZrvllls0depUJSYmenVeAAAAAKhpnE6nZq6Z4bZubKebFRkcJTmdss2cIduMR2X6W1fUUwn+5ScFDz1LeTfdrNz7HpaCw1zWw73mMS11ZZvRenfL2y7rpq14SAMbnSWzyeynZACAqiTox0Wy7N/nsqZoyPlyNG7isqa47+nK+Pw7xYy4WOZjR92ua92+jUYMAAAAAKoPd00YCo5KxVlSUJR/8gAAAAAAAAAAAHjZ398DLKlCjQ1OHuPtBgTp6el65JFHSreHDx+u3r17e3WNkzMHBwd7ND40NLTM9smvq9/kpEh7PpAOfiOl/ir9/cF+bu7tlyQVpp34k75W2jXrxL6QelKDIVLSxVLSBZK5erU14G55VDkOh0Nz584ts+/WW2912wGnT58+6t69e+l2bm6uvvvuO6/na9++PQ0YAAAAAMCAn/Yv0Zojq13WRARFamzHf0uSbI8/ovDHp7ltwPB3ttdeVvRlF8l09EilsuKECd3vVojF9S9ANx5fr292femnRACAqiZstutmPZJUcPW1huayt2uvjC+/kz2poaH6PxsxmI7wfR8AAABAFRfhpgmDJGXv9H0OAAAAAAAAAAAAHykqKiqzHRQU5PEcJzcsKCgoqFSmkz366KNKTU2VJNWpU0d33323V+eXpMLCwjLbnjZhOLn+5Pl8yl4k7XpLWjBA+qqFtOFe6fhyyVFyovHCn39MJuN//j6u4Ii0+x3pl0ulzxKl1bdJGRv99/FVUvVqGYFaYe3atUpLSyvdbtSokXr16mVo7GWXXabVq/96g8/ChQt11VVXeT0jAAAAAMC9mWtmuK25seO/FBMaq5AP31P4zCcqtE7wimWynjlAuV99K0dyswrNgROSIhvqug436tX1L7qse2zlIxqafIGs1awbKQCgckxHjyp4/rcua+wNG6lo4FmG57Q3b6mMr+Yr+tILZd29y239n40YMud+LUdCfcPrAAAAADDu+PGcQEeo0oKDyz7zpqjI8Y8aU1F91XEzT9bB31XkaOnFZAC8yci5DqB64zwHagfOdaDm4zwHaqZ9i3dr0fjv5Sg2dk73ub+/2ozs4ONUAHyJ7+kVEx8fEdD1T24eUFxc7PEcJzdyCAlx/TA5T/z444/68su/Hjx3zz33KCYmxmvz/ykkJET5+fml2yd/TO748jUoV8FxafuL0vaXpcJjJ/b9+SDFP5sp/J3Rhyy6GluYKm1/6cSfhMFSmzulBudW/GPwA+6UR5Xz448/ltnu27evTCefdOXo27dvme2VK1cqLy9PNpvNa/kAAAAAAO4tP7hUyw8udVljs4brX51vkWXbH4qcPKFS65n371P4hecp55v5cjZpUqm5arvxXSfo3c1vK7e4/Jvtt2ds06fbPtLINqP8mAwAEGihH70vU0mJy5qCK0dLFotH8zoaNlLGl/MVc/klsm7Z5Lbeun2boodfQCMGAAAAwEecRm+iqqVOfnlO9Xo5g+rIYYmU2Z5d7jzmvF281kAVZuRcB1C9cZ4DtQPnOlDzcZ4DNc/u73Zo/o1fG27AcPq0gWp9RXvOf6Ca43t69RQeHl5mu7Cw0OM5Th7jrfcC5+Tk6IEHHijd7t+/vy688EKvzH0ym81WqSYMBQUF/5jPZ4qzpM0zpD+ek+y5p268cPL5FxIn2RpLtoZSWKJksUmWMMlslez5Ukm+VJQm5e2X8g9IuXslp/2v8X9/f/ifcx9ZcOJPXE+p8zSp/pm++5grgSYMqHK2bNlSZrtr166GxyYkJCgpKUkHDhyQdKJzzo4dO9SpUyevZgQAAAAAuPbU6hlua67rcIPqmMIVddOFMuXlVXpN8/59irhwqHLmLZDiEyo9X20VHxavf3Uep5lu/g6fWDVdw1pephCLH7qtAgACz+lU6Htvuy4xmVRw1dUVmz4hQRmff6OYkcNlXbfWbT2NGAAAAABUaSaT7LZmMmevL7fEkrfLj4EAAAAAAACAqm/XN9v1/dhv5Cgx1oCh7wNnqNNY4+87AwB418nNAgoKCuR0Og0/lF2S8k66h9xbDQieeuopHTx4UJIUFhZWpiGDt9lsNqWmppZun/wxufP3Bg5/zud1Dru07Tnp90ek4oyyzRekv7YtIVKd3lLCIKlODymms2Rr4Nla9gIp43cpY7109GfpyGIpb99fx/++ZupKafHZUsKZUrdnpeh2lfowvc0c6ADAyXbtKnuRuXnz5h6Nb9Gihcv5AAAAAAC+tfrwr/pp/2KXNaGWUN3c5TZFPHivrJt/99ra5r17FH7lCCk312tz1kbjOt+mmJAYlzX7svfq3c1v+SUPACDwgpb9IuuunS5ris4cLEdSwwqv4YyNU+5nX6rkNGM3SFi3b1P0sPNlOnKkwmsCAAAAgK84wpJdHrfkcz8LAAAAAAAA8KedX3vWgKHXlNPVZVx3H6cCALgSGxtbpuFCcXFxmWYERhw56d6vOnXqVDrXvn379MEHH5Ru33bbbWrYsOL3tblzcuaTPyZ3fPEalHF4kfRdZ2ndRKko/UTzg783QgiKlpKvls74QrosXRq8WOp4n9RgqOcNGCTJEirV6S41v0Hq85Z0yR7pgj+kzo9Kcd1OrPlnBpPpxP8fXih910VaO0EqzvbmR18pNGFAlVJQUFDaXeZPiYmJHs1Rv37Zp57t3r270rkAAAAAAMY9veYJtzWj212rRj+uVtibr7mtdQYHq/C8C+UMDja0vmX9b4q69V+Sw9jFGPxTVEi0but6p9u6p1bPUE5xjh8SAQACLfTdt93WFIy+rvILxcR61ohhx3bFjLhIJg8v3gEAAACAr9ltzVwet+RxPwsAAAAAAAAgSTu/2qbvx35tuAFDj0l91G18Tx+nAgC4ExoaqgYNyr5J/+T3B7tz6NChMtvNmrm+vmJETk6OnE5n6faMGTPUunVrt39eeOGFMvN89tlnZY53737q5j/JyWUbc3v6Gpxcf/J8lbZosJS15Z/NFxIGSn3fk4Ydlvq8LTW88EQDBV+Iaim1nywNWXWiIUObO6XgOmWbMThKpD+ekbY+45sMFWANdADg79LT08t8cQsKCvK4a0tCQkKZbU8759QmwcGWQEeo0qxWXh+gNuBcB2o+znPAv347uk4/7JnvsibYEqw7G49S5DmXGJoz7/VZKrn4EhX9sVW20VfKsn2b2zEh33ypyGeeUOHk/xpaA/90c9eb9dr6F3Ukr/xurMfzj+mN31/WXb0m+zEZajO+rwMBkpGukK+/cFniqFdPuuB8BQdV7jy1Wi1SfLwKv/pWpovOl2XtGvdjtm5R7OUXK+erb6WY2EqtD8A/+J4OAABqA7dNGAoPSPZ8yRLmp0QAAAAAAABA1bPjy2364V/fyGl3ui+W1HNib3Wb2NvHqQAARiUnJ+vAgQOl2zt37lSnTp0Mj9+5c2eZbW80YfC3kzOf/DG5s2vXLpfzeZXJKiWPktreJUW38d06rkS1lLo+KXWZLu2eLW15Qsr6428Fxn4m8AdzoAMAf5eXl1dmOzQ0VKY/O6sYZLPZXM4JAAAAAPCdJ1fOcFszqs0otbz9HpnT09zWFt58i0ouvkSS5GjdRjkLlqhkwEBDWUIef1SWH5cYqsU/2YJsmmSgucLza57R8bxjfkgEAAiU4E8+lqmw0GVN0airpaAg7y0aE6OCL79RyWldDZVbNm5Q+KWXSFlZ3ssAAAAAAJVgD3P/lCJLforvgwAAAAAAAABV1PbP//CoAUOvSX3UZ8rpHr/XDADgO23bti2zvW7dOsNjjx49WqaBQ1BQkJo3b+61bP7Spk3ZZgZr1671aPzJ9Se/pl5hskgtb5Yu2in1/l/gGjD8nTlIaj5GOn+zdPrHUlRryVl1GjBIkjXQAYC/y83NLbMdEhLi8Rwnj6EJAwAAAAD4x6bjv+vrnV+6rLGYLLp7rU3W5Uvdzmfv1FkFDzxcdmd0tHI/+EThl18q6y8/uRxvcjplG3u9cn5eLmdCfbfr4Z+u6XCdnl/zrPZkpZRbk12UradWPaHpA9w34AAAVE/Bs992W1N89bXeXzgmRrmffaXwYRfKus79hSnrmtUKv3y4cj/9XIqI8H4eAAAAAPCA3eb+KUWWvN2yR/jgRjoAAAAAAACgits+d6sWjPtOTofBBgx39VHve/rRgAEAqpiBAwfq9ddfL91etmyZnE6noa/XS5eWvZ+8V69eCg8Pr3Smxo0ba9asWR6P+/zzz/XFF1+Ubp9++um64YYbSret1lO/Jb9Xr16y2Wyl72VOSUnRgQMHlJSU5HbN/fv3KyUlpXQ7PDxcPXv29Di7S40vkzo/KkW28O683mIyncjYaLi083+Sqk4jBpowoEopKioqsx1UgSenBQcHl9kuKCioVCYAAAAAgDFP/fqE25qRdc5Sq9tfdlvnDA9X3v/elk7VnM9mU+6Hnyji/HNlWf+by3nMR48q7JZ/K++Tz078ggYeCbYE654+U/Tv+WNd1r254XX9u8stahLdxE/JAAD+Yl7/mywb1rusKTn9DDma+agDuaeNGFYsV/iVI5T78VwpLMw3mQAAAGoop9OprP1ZytqXpcLsQhXnFstR4lCQLUhB4UEKrxeumCYxCo4Idj8ZADlCEuU0h8rkKP++FUv+Lj8mAgAAAAAAAKqGbZ9u0cJb5xluwNB7cl/1ntzPx6kAABXRtWtXxcbGKj09XZK0b98+rVy5Ur1793Y79tNPPy2zfeaZZ3olU3h4uPr27evxuDVr1pTZrlu3rqF5QkJC1K9fP/3www+l++bMmaPbb7/d7dg5c+aU2e7fv/8/3iNdaad/7N35fMVkllrcGOgUZdCEAVXKyV8ciouLPZ7j5EYOIad6ww4kSUVF9kBHqFZ4vYDagXMdqPk4zwHf2J6+TZ9tm+Oyxmwy694X18vkcLidL/uxp1TYuJlU3jkbHKaMdz5UzDkDZTly2OVcQQt+kHnWLBWM9sETumuBi5Mv07Nxz2hL2qZya4rsRXpk6UN6cfBrfkwG8H0d8IeId952W5N35WifnY9FRXbJFqnijz9X9GUXK2j9OrdjrD//pLBRI5X59genbugEoMrhezoABMaRjUeUsiRFB1cd1MFVB5W+K12OEve/twmLC1NC5wQ16NFADXs1VPJZyQqJ5Ocu4B9MZtnDmsqau7XcEkveTj8GAgAAAAAAAAJv0zsb9OOkBYYfct3jrj40YACAKsxsNmvYsGH63//+V7rvxRdfVK9evWRy8QC95cuXa/Xq1aXb4eHhGjp0qE+z+tJll11WpgnDe++9p9GjRysuLq7cMampqXr//ff/MQ+qDnOgAwB/Fx4eXma7sLDQ4zlOHmOz2SqVCQAAAADg3rNrn5LTzVWREccS1WbLEbdzFVx2hQqvuMptnSOxgbLe+UBOA90+w6feI/PePW7r8E8Ws0VT+zzgtu7TbR9p0/HffR8IAOA/BQUKmeO6C7YjKlqFF1zs8yjO6BhlfjRXJe06GKoPXrRAUWOvkyrQ6BcAAKAmS/kxRV/96ys93ehpvdrlVc2/Y742vrdRx/84LnuxXU6n0+2fvNQ8pSxO0bIZy/TxpR/rifgn9Pagt7XimRXKPZYb6A8RqFLstmYuj1vyd/spCQAAAAAAABB4619Zox8nGm/A0HNyX/WY2Me3oQAAlTZ27Ngy7+P99ddf9frrr5dbf+TIEU2ZMqXMvmuuucZlwwJJat26dZk/K1eurFxwLxo4cKC6dOlSup2RkaH//ve/5T6ovqioSFOmTFFGRkbpvu7du6t///4+TgpP0IQBVcrJDRMKCgrkdBr8yfr/5eXluZwTAAAAAOBdKZm7NWeb6zdommTSfR8dcDtXSXIz5cyYaXjtktO6KefBaW7rzLk5ihw/TnK4f5oj/umsxueoTwPX3cSdcmraigf8EwgA4Bch334l898u8pxK4fDLpLAwv+RxxtVRxidfqKRVa0P1IfO+UeTNN0olJT5OBgAAULXlHMnRkgeW6NnkZ/XOme9o3RvrlHUgq0xjBZPJ5NGfv4+1F9u156c9+n7C95qZNFMfXPiBtn2zLdAfNlAl2MPcNGHI2+WnJAAAAAAAAEDgOJ1OrZ65Qkvv+9HwmJ739FP3O3v7MBUAwFvi4uL073//u8y+p556Sg888ICOHPnrAX4Oh0MLFizQyJEjdeDAX/eV16tXT2PGjPFbXl+ZNGmSzOa/3ra/ePFijRkzRps2bSpT9/vvv+uGG27Q4sWLS/dZLBZNmjTJb1lhjDXQAYC/i42NLb1hQ5KKi4uVmpqq+Ph4w3P8/YuyJNWpU8erGQEAAAAAZT23dqbsTrvLmku3mtTumOsme86gIGW/NkvOiEiP1i8Yc5NCly9V0Jefu6wLXvqzQv/3mgpu/LfLOvyTyWTS1N4P6ry5g13WLdj7vZYfXOq2YQMAoHoIfW+225qCq672Q5K/OOvWVeacrxR90RBZd7t/s1Lol59JISHKfv4VyUxfagAAULsc23xMy55Ypt8//F32InuZByCYTKYytZ4+HOHk8X/O4Sxxavu327X92+2Kaxmn3v/prdPGnCZLkKViHwRQzdltrpswmPP3So4iyRzsp0QAAAAAAACAfzmdTq2Y9ovWPbfK8JheU05Xt/E9fZgKAOBtY8eO1bp168o0Fvjggw/08ccfq0GDBoqMjNT+/fuVlZVVZlxoaKieeeYZRUVF+Tuy13Xv3l133nmnnnzyydJ9v/76q4YPH6569eqpbt26Onr0qI4dO/aPsZMmTVKXLl38mBZG0IQBVUpoaKgaNGhQpovNwYMHPWrCcOjQoTLbzZq5vqANAAAAAKi4/dn79NEf77utm7LE4bYm994HVdL5NM9DmEzKf/Z5WX5dIfPhwy5Lw6c9pKLzL5IjsYHn69Ry3ev31HnJF+rb3V+5rHto+X36dviCU74ZAwBQfZj37lHwz0tc1pS061Cx792V5Eior8y5Xyvm4qGy7N3jtj70kw/lDAlRzpPP0ogBqKYcDoduueVGbdy4oXTfOecM1X33PVzhOdeuXa3x428ufdNxUFCQ3nhjtpo3b1HpvAAQaOm70rX4vsXa9NEmOR3O0q91f/+3+t+bLlhDrarbtq6im0QrqmGUIhIjFGQLUlBYkMxWs4rzi1WSX6L8tHxl7c9S9oFsHd96XNmHssuse/L8qdtS9e24b/XLo79owP0D1OW6LjKZ+X0Bahe7LdnlcZMcsuTvlT2cn0EAAAAAAABQ8zgdTv1y72JtfOM3w2N633u6ut5OAwYAqG7MZrOeffZZ3XPPPfrmm29K99vtdu3bt++UY2JiYvTcc8+pW7du/orpc2PHjpXFYtGTTz4pu/2vhxwePXpUR48e/Ue9xWLRXXfdpeuuu86PKWEUTRhQ5SQnJ5dpwrBz50516tTJ8PidO3eW2aYJAwAAAAD4zvPrnlaxo9hlzYV/SF1c90ZQ0ZmDlf+vcRXO4YyNU/5zLyr88ktd1plzcxQx5W5l/c/9k73xT//tdZ/mpXwjh7P8phprjqzSt7u/1vnNLvRjMgCAt4V+8K7bmoJRV0sBarrjSGqojDlfKeaiIbIcOui2Puzdt6WQEOU8+kTAMgOoOLPZrHvuuU/XXTdKRUWFkqTvv/9OZ511jvr16+/xfAUFBXrssYfLvAH52mtvoAEDgGqvILNAi+9brDWvrJGjxCGn0ymTyVTaHOHPr3vRjaOVPChZTQc1VYMeDRTfOr5CzRHyUvN0+LfD2vvzXqUsTtH+lftlLzpxI9Hf18zcl6mvxn6lZU8s05Bnh6j5Oc299BEDVZ89zP09K+b83TRhAAAAAAAAQI3jsDu0ZMIP2vr+JsNj+j5whrqM6+7DVAAAXwoJCdHMmTN17rnn6uWXX9aWLVtOWWez2XTJJZfo1ltvVZ06dfyc0vfGjBmjPn366JlnntFPP/0kh+Of912bzWYNGDBAd9xxh9q0aROAlDDC5Pz73UVAFfDkk0/q9ddfL92+4oor9NBDDxkae/ToUfXv/9fNdkFBQVq5cqXCw8O9nvNUnn/+eb3wwgul28OGDdNjjz3ml7Ur4tixbPdFtVhwsKXMdlGRvZxKANUZ5zpQ83GeA75zOPeQerzbSYX2Qpd1v74m9XDx3khH3XpKW7xMznr1Kpzlz3M97LZxCp79ttv6zPc+VtHZQyq8Xm32n8W36r0t77isaRnTSj+OXCGrmf6f8C6+rwN+YrcrrntHWQ7sL7fEGRys1A1/yBnn3Ytgnp7nlp3bFXPRUJmP/bNL+Knk3fYf5U59sML5AHhHRb+nv//+O3rppedKt+Pj62r27I8VGRnp0frPPvuUPvnkg9Ltli1b6fXX35HVWrV/fq1b17OPE0Dtsu5/67TwvwuVdyyvtPmC9Ffjhbpt66rtZW3V7rJ2SuiY4JMMRTlF2vb1Nm2Zs0Xbv92u4vzif+QwmUxqc0kbnfvMuYpuFO2THKg87iVwzaOfZRwlil9UTyZnSbkl2a2fUEHjf3krHgAv4XeRQM3HeQ7UDpzrQM3HeQ5UTfZiuxbeOk87PvvD8JgzHj9LHa7vfMpjnOtAzcd5XjFV/T6CPXv2aP369Tpy5IiKi4sVFRWl5s2bq2vXrgoJCQl0PL9IS0vT2rVrtW/fPuXl5clms6lRo0bq2rWr4uLiAh0PblTtO4lQKw0cOLBME4Zly5aVuUnElaVLl5bZ7tWrl98aMAAAAABAbfPib8+5bcBw7g7XDRgkKeuFVyvVgOHv8qc9JuviRTLv3+eyLuKeSUrrd4Zks3ll3dpkUo97NGfbxyqwF5Rbsz1jmz7a+r5GtbvGj8kAAN4S9NMSlw0YJKlw6AVeb8BQEfbmLZUx5yvFDDtP5tRUt/W255+WIypK+eMn+CEdAG+74opRWrJkkTZv/l2SdPz4MT3//Ez997/3G55j48b1mjPno9Jtq9Wq//73/irfgAEA3Pnyxi9Lr6mbTCY5nU4F2YLU/vL26jq2qxr1aeTzDMERweowsoM6jOygwqxCrX9nvda+sVZHNhwpk2vr51uV0DlBA+4b4PNMQMCZrbKHNpY1f1e5JRYXxwAAAAAAAIDqpjivWN+P/Vp7fthtqN5kNmnQM+eozcj2Pk4GAPC3Jk2aqEmTJoGOEVBxcXEaPHhwoGNUjr1QOr5MSlsrZf0hFWdIRZmSs7gSk5qksxZ6K6HPcDcRqpyuXbsqNjZW6enpkqR9+/Zp5cqV6t27t9uxn376aZntM8880ycZAQAAAKC2O5Z3TO9s+p/buqk/uj6ed8t4FQ86y0upJEVFKf/Z5xV+6SUuyyx79yj86SeUO8X4m7VwQoOIJN3Y6d96Yd0zLutmrHpUw1uNUJg1zD/BAABeE/r+bLc1BVdd7YckxtjbtFXGx18oZvgFMmdmuK2PmPagnBERKriBJ80C1Y3FYtE999ynG24YraKiIknSt99+pbPOOke9evVxO76wsFCPPfZ/7N13eBRVGwXwM9t303uh9947UqQoiAKKigoCoqAoiAKKgoCIIEVFxYKogHQQFUFEBaVL771IL0kIkJ7tO98f+QhEyGzK7uxm9/yeJ4/szDszB+SSzeyd974Ph8ORu61Pn/6oUqWa2zITEclNFEXow/VoNrQZmr7aFPowz/xcrg3WoumQpmg6pCnOrT+HrZO34uzffNCc/JPDUBGQasKQXbDJ6ERERERERERERN7OlGLEb71/QdKehALVK1QKPDCrCyp1rermZERERFRoWReBo5OBC0sBW7rrziuKwP8XGPB2Ck8HIPovhUKBxx57LM+2L7/8EqIoSh63fft27NmzJ/d1QEAAHnroIbdkJCIiIiIi8ndfH/wCRptRsqbdOeC+S/nvtzZoiKxRY12cDLB1eACmR3s4rdPP/ByK85zgXBRDGwxDiDZUsiYh6yq+OzxLnkBEROQyws0b0P6+WrLGXroMrG3ulydQAdnr1EXaDyvgCAwqUH3QqDehXbrIzamIyB0qVKiI/v0H5tk2bdokZGdnOT12zpxvcOHC+dzXlSpVRt++z7s6IhGRx2hDtOg4tSOGXRyGtuPaeqwBw39VaF8Bfdb1wcBdA1GxQ0Wnn/0T+Rq7oaLkfqVEgwYiIiIiIiIiIqKSIvNqBlZ0+6HADRiUWiU6z+vGBgxERETe6NRXwG+1gDPfANa0nMYJd375CTZhIK80cOBAGAyG3Ne7du3Ct99+m299UlIS3nnnnTzb+vbti/DwcMnrVKtWLc/Xzp07ixeciIiIiIjID9w03cCcI/n/jHbLmM3573MEBiH96zmARuPCZLdlvT8FjqBgyRrBYkHghHFuub6vC9WF4dUGw5zWzdg3HammFBkSERGRq+h+XAbh/6vL58f0VC9AqZQpUcHZGjRC2pKfIBoCClQf9PpgaH5d6eZUROQOzzzTB9Wq1ch9nZSUiC+//EzymBMnjmPp0oW5r5VKJUaNehdqtdptOYmI5NTyjZZ47exruO/N+6A2eOe/bfGN49FnXR/0WdsHkTUiPR2HSDZ2fQXJ/crs84BolycMERERERERERGRG9w8dQM/P7wUKSdvFKheZVDj4cWPofwD0g1MiYiIyAOOTgb2vgrYsnIaLgjC3V//bcpQmK8SROXpAET3Eh4ejkGDBmH69Om52z7++GNcvXoVL7/8MmJiYgAADocD69evx6RJk3D16tXc2ujoaDz/vHtWLjKbzdi7d+899126lHeJ1+TkZGzbtu2etZUrV0Z0dLTL8xEREREREbnbN4dmIsuaKVnT8iLQ7lz++zOnTYejgvs+QHHExCJr9DgEjXpDsk67eiXU27bC2rKV27L4qoF1B2H24VlIyLqab02aORWf7/8UY1u8J2MyIiIqMlGEbtEC6RJBgOmZZ2UKVHi2Zs2RtnAZQno9AcFkkqwVHA4ED3oeaQHLYG3fUaaEROQKKpUKo0e/iwED+sBqtQIAVq1agfbtH0CjRk3uqrfZbJg8eQLs9tsPN/bq1RfVq9e4q5aIqKR6YNoDno5QYBU7emZSbVJSEg4dOoSDBw/i0KFDOHLkCLKysnL3lypVCuvXry/SuatVq1asbH///TdKly5drHOQ97IbpP/OC6IFCtNVOPRlZEpERERERERERETkOkl7E7C61wqYU6Q/o79FE6zFw4sfQ1zTeDcnIyIiokJL3gYcGpPza0G4vf1W8wR1MBBQDlAHAYJ3Lg7gSmzCQF5r4MCB2L9/PzZs2JC7bcmSJfjhhx8QHx+PoKAgXL58Genp6XmO0+l0+PTTTxEcLL3iaVElJyejf//+BardunUrtm7des99kydPRo8ePVwZjYiIiIiIyO3SzWn47tAsp3VjNwNCPvtMPZ+B+YmnXBvsXtd57gXoli2C+sB+ybqAMW8jdd0mr1zR25vpVXq82WQUhm98VbLu20Mz8UKdFxEfWEqmZEREVFSqg/uhOn5Ussba+n44ypaTKVHRWFu1QfqcBQju+wwEm02yVrBaEdK/N9KWrYC1eUuZEhKRK1SqVBn9+r2A7777GgAgiiKmTJmI+fOXQq/X56mdP38Ozpw5nfu6fPmK6N9/oKx5iYjIM/bu3Yu5c+fi4MGDuHbtmqfjkJ+yGyo5rVEaz7IJAxERERERERERlTgX15/DH8//Clu29Gfzt+jCdej6w+OIqhvj5mRERERUJPvfzGm4cKsBgygCuiig+gig7BNAoGca7nuKwtMBiPKjUCjw2Wef4eGHH86z3W6349KlSzh27NhdDRhCQ0PxzTffoFGjRnJGJSIiIiIi8huzD3+DdEuaZE3jK0Cnf++9z1ahIjKnfOSGZPegVCLzgw+dlqmPHIJu6SIZAvmep6v3RpXQqpI1JrsJH+2eIlMiIiIqDt2iBU5rTL37yJCk+CwdOyFj5ncQFc4/BhGMRgT3ehKqA/tkSEZErvTss8+hSpXb70cTEq7g668/z1Nz9uy/WLBgbu5rpVKJ0aPHQaPRyJaTiIg85/Dhw1i3bh0bMJBH2fXlIObbsjaHMvusTGmIiIiIiIiIiIhc48SyY1jz7MoCN2AIiA/EoyufYgMGIiIib5V9Bbi+PacBgyjmbIu6D3jkJFBzpN81YAAAlacDEEnRarWYPn06OnXqhJkzZ+L48eP3rDMYDHj00UcxZMgQREREyJySiIiIiIjIP2RaMzHr0JdO68Zuxj2nFItqNTK+mQsxMMj14fJha9wUpsd7QvfTD5J1AR9MgLnboxCDgmVK5htUChVGN38X/f/oLVm3+MQCvFz/VVQJk27YQEREHpSdDe3PyyVLHKGhMD/0iEyBis/cvQeErCwEvT7Yaa0iMwMhT/dA6qo/Ya9aTYZ05C5p5lQkZCV4OobPiAuIQ4g21NMx8qVSqTB69LsYMKAv7HY7AODnn5ejffsHUK9eA9jtdnzwwQRYrdbcY556qhdq1qztqchERORFDAYDsrOzXX7eatWq4e233y7UMVFRUS7PQV5EoYVDVxpK06V8S5TGczIGIiIiIiIiIiIiKjpRFLF72nbs+XhHgY8JqxqOR5Y9jqBS8s0dJCIiokJK/ifva1Uw0PonQBPqkTjegE0YqETo1KkTOnXqhAsXLuDgwYNISkqC1WpFcHAwKlWqhIYNG0Kr1Rb6vCdPniz0MaVLly7ScURERERERCXd90dm46bppmRN3USgaz4/MmW9Mx62eg3ckExa1pjx0K75FYLRmG+NIvkaDJ9+jKyx78mYzDd0qfAIGsU0wd6k3fnWOEQHJu14D98/tEjGZEREVBja31ZBkZEuWWN+vCeg08mUyDVMvfpAyEhH4NhRTmsVN28ipNeTSPn9b4h8CK7E2ZmwA29tHo5jN454OopPESCgRkQtTGvzCZrGNfN0nHuqUqUa+vTpj++//w5AzqSvyZPfx7x5i7F8+VKcOHEst7Zs2XJ44YVBnopKREQeFBAQgFq1aqFOnTqoW7cu6tSpg8uXL6Nv374uv1ZISAhatmzp8vNSyWY3VJRuwpB9VsY0RERERERERERERWM327Bh2Dqc+vHei+zeS0yjODy86FHowvVuTEZERETFZkq8/WtBAMr1BHTRnsvjBdiEgUqUcuXKoVy5cp6OQURERERE5Heyrdn46sAMp3VjNgPCPbZb2neEcZDzVajdwVGqNLKHvI6ADydL1um/nQnjCy/CEV9KpmS+QRAEjG3+Hh5d2UWybs25X7EzYQeaxTWXKRkRERWGbvECpzXGXq5/QE0OxpcGQ8jIQMC0D5zWKi+eR0jfp5H682pAzwkgJcXGS+vR+7cnYXVYPR3F54gQcezGETy2sgsWPbwc95dp7+lI99Sv3wvYsmUjzpz5FwBw+fJFTJr0HrZu3Zxbo1AoMGrUuCI19SYiopKrffv2aNWqFSpWrAiFQpFn3+XLlz2UivyRXV8RwKZ897MJAxEREREREREReTtTihF/PLcKV7dfKfAxZTuUR6fvukIdoHZjMiIiInIJW1bOf0UxpwlDRFPP5vECCuclREREREREROTvFh77HteNyZI1NZKBx+/R4NoRFY30GV8DCs/dhsge/BrsTporCCYTDB9NkSmRb2lZqhU6ln3Qad1728ZAFEUZEhERUWEozp2F5p8tkjXWOvVgr1NXpkSulz3iLWS//GqBatV7dyPo1UGAw+HmVOQKoihi8s4JbMDgZlaHFVN2vu+17+XUajVGjXoXSqUyd9v69etgsZhzXz/55NOoU6eeJ+IREZEHlS1bFpUrV76rAQOR3OyGCpL7lcZzORPaiIiIiIiIiIiIvFDauVT83GVpoRowVH2iBh6a350NGIiIiEoKTWje1+rQe1X5FX7KTERERERERESSzHYzvjjwmdO6dzYDinvME07/YhbE6Gg3JCsEgwFZY99zWqZbvADK06dkCOR73mk+HgIEyZo9Sbuw+uxKmRIREVFB6ZYudFpj6tVHhiRuJAjIGj8Rxj7PFahct2oFAj6Y4N5M5BLpljTsv7bP0zH8wr5re5FuSfN0jHxVr14DvXr1vee+0qXL4MUXX5E5EREREdFtdn1Fyf2CPQuC5ZpMaYiIiIiIiIiIiAouYccV/NRlCVLPpBT4mHqDGqHDF52hVCudFxMREZF3CKqW81/h//PBLTc8l8VLqDwdgIiIiIiIiIi825LjC5GYlSBZU/kG8NTRu7dnD34N1nYd3JSscMw9noT1u1lQ792db43gcCBg8vtIn7NAxmS+oVZkbTxetSd+PLVMsu797e+iU/ku0Cg1MiUjIiJJdjt0SxdLlohaLcyPPylTIDcSBGRO+wRCZgZ0K35yWm6YMR22SpVhfuZZGcIRkSv07z8QW7ZswvnzZ3O3CYKAUaPGQavVeTAZEZH7rXzeC5seCkD32d09nYLIK9gN0k0YAECZfRY2bYwMaYiIiIiIiIiIiArm6PxD2DJqPRxWR4GPaTG2NeoPaQxBkF7Qh4iIiLxMRBNAqQUclpzXqUc8m8cLsAkDEREREREREeXLarfi8/2fOK0btRVQ/edzFmv9BsgaNdZNyYpAEJD17vsI7dZZsky7eiVU+/bA1rCxTMF8x6hmY/HrmV9gtpvzrTmffg7zjs7GwLovy5iMiIjyo9nwF5QJVyVrzA93gxgaJlMiN1MqkfHFN1DcvAnNpg1Oy4NGDoO9eg3YGjSSIRwVRbAmBA2iG2L/tX2ejuLzGkY3QrAmxNMxJGk0Gjz1VC9MnToxd1vt2nVRr14DD6YiIpLHge8PeNWEVlEUIQgCmzAQ/Z9dX95pjdJ4FrawFu4PQ0RERERERERE5ITdasc/YzbiyNyDBT5GqVWiwxedUbl7NTcmIyIiIrdRBwGlugIXf8x5fWU10OgzwIs+h5abwtMBiIiIiIiIiMh7LT+1FJcyLkrWlEsF+vznsxZHQCDSv54DaDTuC1cE1uYtYX6gk9O6gInjAVF0fyAfUyaoLAbUGeS07uM9U5FmTnV/ICIickq3eKHTGlOvPjIkkZFajfTZ82GrXsNpqWA2I/j5PhCSk2UIRkUhCAJGNRsHtULt6Sg+Ta1QY1SzcV71cG9+lEql5GsiIl8niqLHvyjHtWvXcOTIEezevRsnT57EtWvXPB2JPEkVCLsmRrJEmX1WpjBERERERERERET5M17Pxq9P/FioBgy6cB26/fQkGzAQERGVdLXHAoIyp/FC9gXgzHeeTuRRKk8HICIiIiIiIiLvZHPY8Onej5zWvb0VUDvybsucNh2OipXclKx4ska/C81fayFIPBSg2boZ6o3rYW3XQcZkvuH1RiOw+Ph8pJhT8q25abqJGfs+wdgW78mYjIiI/ku4fh2aP9dI1tjLloe1VRuZEslHDA5B2qLlCOvcHopk6YfhlFcuI/jF55C2fCWg4scq3uj+Mu2xovsajNw8DMdvHIUIPvzpKgIE1IiohWltPkHTuGaejkNERAVQ2IY5t5omuKLRDhsw5Dh16hQ6dOiAy5cv37UvKioKTZo0wWOPPYY2bbz3fbZGwyZGUlSqov35iAGVAEtSvvvV5nP8syfyIkUd60RUcnCcE/kHjnUi38dxTuRaSfsTsbrvSmRcSi/wMWGVw9D9h8cRWjHMbbk41ol8H8c5kZcIrZPTiOHw+JxGDPuGA2ENgIjGnk7mEZwtSERERERERET3tOL0jziffk6yplQ60H9/3m2mns/A/OTTbkxWPPZatWF+vCd0Py6TrAuY9B5S72+fcwOJCixEG4rhjUdi7D+jJOu+OfQV+tcegNJBZWRKRkRE/6VbvhSC1SpZY3qmN6BQyJRIXo4yZZG2cBlCH+0CwWiUrNX8swUBE8Yha8IHMqWjwmoa1wwbn9qGNHMqErISPB3HZ8QFxCFEG+rpGEREVAAhZUOK3EghMzETNrMt9/g7mykolApogjTQBGhgybLAkmGBw367G+ed11TpVAiMCSzi78B3pKamIjU19Z77kpOTsWbNGqxZswY1a9bElClTUK0aV4bzF46ACkDKtnz3K7LOypiGiIiIiIiIiIjoNlEUcei7/dj8zkbYLfYCH1eqRWk8suhR6MP1bkxHREREsqozDsi+CJyZA9izgfUdgEYzgIr9PJ1MdmzCQERERERERER3cYgOfLr3I6d1I/8BtHd85mKrUBGZU5wf52lZb70D7cqfJR88VR86AM0fa2B56GEZk/mG/rUHYvbhbySbeJjtZnywcwK+6vitjMmIiCiXKEK3eL50iSDA9FQvmQJ5hq1BI6R/9R1C+vd2Wmv4+gvYGjaC+dHHZUhGRRWiDWXTACIi8kuvn3+90MfYrXasHbEWu7/cDUEQIIoiVFoVqnatiho9aiCuURwiqkTcddyN0zeQsDcBx38+jlO/nspt4GC32FG1W1U8+NGDUKq5WpEzx44dQ8+ePTFlyhQ89NBDno5DMnAYKknuV2RLN8QlIiIiIiIiIiJyB3O6GX+99idOrzhZqOOq96yBjp93hkrLxxOJiIh8TrPvgIAKwOF3AWsGsPN54NhUoGJ/ILo1EFgZ0IQBCt/+XJjvcoiIiIiIiIjoLqvPrMTp1FOSNdGZwMC9t1+LajUyvpkLMTDIzemKz1GuPIz9nofhu1mSdYYPJ8PSuQtQxJUk/ZVGqcGY5uMxYK10x9MfTy3DoHqDUTeqvjzBiIgol2rfHqhOnpCssd7fHo7SZWRK5DmWh7si6423EfDRFKe1gcOHwlqvARwVKsqQjIiIiMh9bCYbFj20CBc2XwCQs8pZnWfq4MGPH0RgbKDksRFVIhBRJQK1n66NzKRMrB2xFocXH4YAAbu/2I1rh66h9++9odL515SUsLAwtGvXDi1atEC1atUQGxuLgIAAZGdn4+rVq9i7dy9++OEHnDhx+324yWTCm2++icjISDRp0sSD6UkOjgDpnyMU1hQIlpsQNeEyJSIiIiIiIiIiIn+XfOQafuu3CqlnUgp+kADc924bNH6tKQTOqyMiIvJdtd8B4h4ENnUFTNeA9BPAwbdddHIBeMbmonO5j3994k1ERERERERETjlEB6bv/dBp3RvbAP0d9z6y3hkPW70GbkzmWtnDRkK/eCGE7Kx8a9RHDkHz+2+wdHlExmS+oWulR9Eopgn2Ju2WrHtv21j82G0VP5AjIpKZbvECpzXG3n1lSOIdst94G6pDB6Bd+4dknSIzA8GDnkfqr2sBjUamdERERESu90u/X3B+03kAgCAI6DS9E5q/3rzQ5wmMCUSPhT1Qqmkp/DnsT4iiiAubL2BF3xV48ocnXZzae3344Yfo3LkzNPd4jxgcHIzg4GBUr14dvXv3xtKlSzFp0iRYLBYAgNVqxYgRI7Bu3TpotVq5o9+TxWL3dIQSpaB/Xg51eRic1NjTTsMW0rj4oYjI5fhvI5Hv4zgn8g8c60S+j+OcqGBEUcSROQew7b3NsJsKPm40QRo8MKsLynWsCKvV4caE0jjWiXwfxzmRF7j4E3BoLGBOvr2goSi65twlZNq4wtMBiIiIiIiIiMi7/Hn+dxy7cUSyJiIbeHnP7deWdh1gHDTYzclcS4yKQvagV5zWBXw4GXB47gOjkkoQBIxvOclp3ZYrm/D3xbUyJCIiolxZWdCu+EmyxBEeDkunLjIF8gIKBTK+/Aa2ipWclqr370PA5PdlCEVERETkHid/PYmjy49CEAQIgoBmrzUrUgOGOzUb2gzNXm8GIGfy7vGfjuPEyhOuiFsidOvW7Z4NGO7l6aefxscffwyF4vaUnaSkJCxatMhd8chL2A0VnNYos8/JkISIiIiIiIiIiPxZVmImVj/1M7aM2lCoBgyhlcLw+B+9UK5jRTemIyIiIo9zWIFtfYB/egIZJ3MaL9xqviAIxf8qQdiEgYiIiIiIiIhyiaKI6XumOa0bth0IzFmsD47IKKR/PgtQlLzbDMaXBsMRFCxZozp6GJrff5MpkW9pFtccXSp0dVo3Yfs42Bw2GRIREREAaH/9BYrMDMka0xNPAV6yCq9cxJBQpH+/GKIhwGmt4cvPoF7/lwypiIiIiFzvn6n/AMi5D6QL06H9pPYuOW/7ie2hD9dDEASIooht07a55Ly+6MEHH0T37t3zbFu5cqWH0pBcRHUYHOowyRql8axMaYiIiIiIiIiIyB+d+fUUlradj0sbLxTquLIdyuPxP55BWJVwNyUjIiIir7HtWeD8otvNF+5snnBrW3G+ShCVpwMQERERERERkfdYf3EdDibvl6wJNQJDdt1+nf7lNxCjo92czD3EsHAYBw5CwHTpxhMBH06G5aGHS2SjCU8b22I81l74XbLJwombx7H0xCI8W7OfjMmIiPyXbvECpzWmXn1lSOJ97NVrIH3GVwgZ4Px7UvCQl3BzwzaIMTEyJCMiIiJyjYyEDFzefhnC/yfJVH+0OtR6tUvOrdarUf2x6tg/O+fe0uUdl5GRkIGguCCXnN/X9O/fHytWrMh9ffLkSVy/fh2RkZEeTEXuZtdXhMK6N9/9ymw2YSAiIiIiIiIiItczpZrwz9iNOLnsWOEOFIAmb7RAo+HNoFBy7hwREZHPO7cQuLj8dtMF4HbjhICyQFh9wFAOUAcBCtd8zuzN2ISBiIiIiIiIiADkrH748R7pZgQAMHQnEGLO+XX24NdgbdfBzcncyzhoMPTffg1FRnq+NapjR6D57VdYunbPt4burVJoFfSt2R9zjnwrWTd11yQ8VuUJBKidrz5ORERFpzxzGpod0isSWxs0hL1mLZkSeR9Lt8dg7LcZ+nmzJesU15MR/NrLSFvyU94PnYiIiIi82NXdVyGKYm4ThtgGsS49f1yDOOzH7QafV3ZdQfXu1V16DV9RrVo1RERE4MaNGwBy7s2dP3+eTRh8nN1QAep0NmEgIiIiIiIiIiJ5iKKIM7+expZR62FMzi7UsfpIPTrO7IIybcu5KR0RERF5naMTb//6VvOFuE5A3feBiMaeyeRBbEFFRERERERERACArVc2Y0/SLsmaQDPw2s6cX1vrN0DWqLEyJHMvMTQMxhdfdloX8NFkwOGQIZHveaPJKASqpVe9TMpOxMwDn8uUiIjIf+kWL3RaY3qmjwxJvFvmhA9gq1HTaZ1m/V/QLZovQyIiIiIi10g5lwIgZ+ItAATGBLr0/IYoAwDkNnlIPZ/q0vP7mtjYvE0wbt686aEkJBe7vqLkfqXxnExJiIiIiIiIiIjI12VezcDvfVdi7YDVhW7AENe8FHqu78MGDERERP4k5RCQfipnQSJRzPlv1SFAu9/9sgEDwCYMRERERERERPR/0/dMc1ozeDcQbgQcAYFI/3oOoNHIkMz9jIMGwxEcIlmjOn4Mmt9WyZTIt0TqI/Faw+FO677Y/xkSsxJkSERE5KdsNmiXLZYsEfV6mHs8IVMgL6bXI33WXIh6vdPSgLGjoLh4QYZQRERERMVnzbLmeW28aXTp+U0pJsnrUV4qlSrPa5vN5qEkJBe7QboJg8JyDYItQ6Y0RERERERERETkixx2Bw7PPoAlrebh/J9nC318g1eboPvPTyIg1rVNfImIiMjLpezL+zqgPNDwY49E8RZswkBERERERERE2JGwHf9c3SJZo7cCw7fn/Dpz2nQ4KlaSIZk8xJBQGF96xWldwEdTAIdDhkS+58V6ryA+oJRkTbYtC5N3vi9TIiIi/6P5ex2U15Ika8yPdIfopDGRv7BXr4HM96c4rVNkZSLotVf4HoGIiIhKBH14TpMpQRAAAMnHk116/lvnE0URAKAL07n0/L7m+vXreV6HhYV5KAnJxVkTBgBQGM/JkISIiIiIiIiIiHzR1e2XsbzjImwZtR7WTEuhjg2IC0S3H59Ai7GtoVDxkUMiIiK/Y7pjbqEgAGV7Agq15/J4Ab4jIiIiIiIiIiJM3zPVac2gPUB0FmB64imYn3xahlTyMr74MhxOHjpVHT8GzZrVMiXyLXqVHm83G+O0bumJRTiUfMD9gYiI/JBu0XynNabefWVIUnKY+jwHU7fHnNZp/tkC/exZMiQiIiIiKp6g+KDcX4uiiOM/Hc9tmFBcoiPnfLcaPPz3epRXYmIirly5kmdbXFych9KQXOx6500YlNlswkBERERERERERIWTcSUDa1/6Db90/wE3jha++W7lx6rhqU19UbpNWTekIyIiohLl1ufHwTU8m8MLsAkDERERERERkZ/bl7QHGy+tl6zR2oA3tgH2cuWROW26TMnkJYaEwjhosNO6gI+n3r65RIXyZNWnUSuijmSNCBHj/hntsgdAiIgoh5CUBM26PyRr7OUrwNriPpkSlRCCgMwPP4E9JtZpacDE8VCeOS1DKCKS0qVLV2zduif364svvvF0JCIirxLfOD5Pk4SMKxnY/vF2l5x7+yfbkX45/fYGASjVtJRLzu2Lfvzxxzyv4+LiUL58ec+EIdmImig4lIGSNcrsszKlISIiIiIiIiKiks6aZcWej3dgyX1z8e+Kk4U+XhOsRceZD+HBWQ9DF6pzQ0IiIiIqMTQReV+r9J7J4UXYhIGIiIiIiIjIz32ydYLTmhf2AXHZSqR/PRtioO+uYGh88WU4QkIla1RHD0Pz5+/yBPIxSoUS41tOdFq37epW/Hb2VxkSERH5D93ypRDsdskaU68+wB0P5FEOMSwcmZ987rROMBoRNPQVwOGQIRURERFR0QTFB6Fsq7IQRRGCIEAURWwYtwEnfy385Nw7nfrtFDaM2ZB7TkEQUPa+sgiK8937SMVx5swZzJkzJ8+2jh07eigNyUoQ4NBXkCxRGtmEgYiIiIiIiIiIpDlsDhyddwiLms3BrqnbYMu2FfocpduWw1Mb+6Dq41zlmoiIiACE1Mz57605hKZrnsviJdiEgYiIiIiIiMiPHU7cjz+TNkrWqO3AW/8A2SNHw9aoiTzBPEQMDoHxpVec1hmmTwVEUYZEvqdtmXboVP4hp3XvbR8Ds90sQyIiIj8gitAtni9dolDA9FQvmQKVPJaOnWB8tp/TOvXundDNm+O0joiIiMiTmr3eLPfXgiDAZrJh+RPLsfG9jbCZCzdR126xY9OETfihxw93Hdt8WHOX5PVmx48fx/fffw+j0VioYwYMGICsrKzcbTqdDgMHDnRHRPJCdkNFyf3K7HMyJSEiIiIiIiIiopJGFEWcWX0aS1vPw6Y3/0L2tSznB/2HNkyHDl90RtcfeiCodLAbUhIREVGJFNEUUN/RZP/6Ds9l8RIqTwcgIiIiIiIiIs+Z8cOLTu8O9DsAxNa8D2lDh8uSydOMAwdBP/MLKDLS861RH9gPzfp1sHR4UMZkvmN8y4n4++I62Bz5P9hxIf08vjs0C4MbDJUxGRGRb1Lt2gnVv6clayztO8IRFy9TopIp671J0GzaAOWli5J1Ae+/C0unh+CILyVTMiIiIqLCqfFYDVTrVg0nV52EIAgQBAF2qx2bJ2zG/u/2o26fuqj+WHXE1ouFUqO863i7xY7Eg4k4seIEDi04hIyrGRBFEYIg5P63WrdqqP5odQ/87u62d+9emM13N3o8ceJEntdmsxnbtm275zmio6NRuXLlu7anp6dj8uTJmDlzJh588EF07NgRderUQXh4eJ46URRx6tQpLF++HMuWLYPFYsmzf/jw4YiJiSnsb41KKKdNGIxnZUpCREREREREREQlhSiKuPDXOez5aDuu7U8q8nmqPF4drd6/H/pIgwvTERERkU9QqIDyzwKnZ+a8vroGsKYDav9t2iSIIpdtJPJXyckZno7g1TT/mVBksdg9lISI3Iljncj3cZwT5e/0pmW476j0CntKB3Di+yCErdwJR6nSMiUrPFePdcOUiQiYPk2yxtqoMVLX/A0IQrGu5a/GbH0L3xyaKVkTpAnGzt4HEKmPlCkVeTt+XycqmsDXB0O/eIFkTdqchbA80k2mRPnz9nGu3roZoT0ecVpn7vww0uct5vsEonx4+1j3VlFRQc6LiIgKKPtGNua3n4+kw0kQ/v+e5db0kVuvFSoFQsqGQBuihSZAA0uWBeY0M9IupsFhc9zzGFEUEVM3Bv3W94M+XC/3b+ue2rdvjytXrhTrHI899himTJly1/adO3eib9++d22PjIxEWFgYAgICkJ2djaSkJKSlpd3z3M8//zzeeuutYuVzNc4lkFbc9zK6y/MQdPxVyZrk9kmA0jvGEJG/4s8tRL6P45zIP3CsE/k+jnPydaIo4sLas9j98Q4kHyh684WgMsFoM60DynWo4MJ08uFYJ/J9HOdFw3kE5HLGBGB1TcD2/8UMqw4FGn3i2Uwe5GStS8qPKIpITExEQkICsrKyYDQaYbPZoNfrodfrERERgfj4eAQEBHg6KhEREREREdFdhPQ0fL7qNaCSdF3vQ0DUu1/C4sUNGNzB+NIr0M/6CoqszHxr1Hv3QL1pA6z3t5cxme8Y0fgt/HByCVLNqfnWZFjSMXXXJHzY1n9v3hERFZeQmQHdLz9L1jgiI2F5sLNMiUo2a6s2yB7wEgzfzZKs0/7xGzSrV8HStbtMyYiIiIgKxxBhQL8N/bDgwQVI2JcAQRDuasZgt9px88xNADlNFu61xodwR9MpURQR3ygevf/o7TUNGDzl+vXruH79umRNYGAg3n33XXTr5vlmaCQvu8H5RHel8QLsgdVlSENERERERERERN5IFEWc//Ms9ny0HcmHrhX5PEqdEg2HNkWDwY2h0qtdmJCIiIh8kj4OaD4b2PpkzutTM4CgykDVwZ7N5SFswlBAJ0+exK5du3D48GEcPnwYly5dgt3uvJtOSEgIqlevjjp16qBevXpo3rw5AgMDZUhMRERERERElL+EsS/ihyrZkjWCCAwP6QZL10flCeVFxLBwmF54EYYZ0yXrAj6eitS27bjKdRGE6cIxsslojN46UrJuwbG5eL72QNSIqClTMiIi36JduQJCdpZkjenJZwCNRqZEJV/W6Heh/fN3KC9dlKwLHPUGUlq3gRgaJlMyIiIiosLRh+sxYMcAbJ64GVsnb4Xdas/TjOG/8tsuiiKUaiVajW6FNu+0gUKlcGdsr1K1alW88cYb2LlzJw4fPozU1FSnx1SsWBGPP/44nnzySYSEhLg/JHkdu6Gi0xql8RybMBARERERERER+SHRIeLsmn+x95OduH646M0XAKBSt6po+W4bBJUJdlE6IiIi8gtlegDN5wE7XwAcVmDvUOD6TqD+B4DBvxZ2FMR7LVVAAIBdu3Zh9erV2LRpE65du/3GtbB/ZHdORFAqlWjQoAE6dOiAbt26ITw83GV5iQorOTnD0xG8mkajzPPaYnHeeIWISh6OdSLfx3FOdDft8qV4be2L+L6BdF3Pc4H44t1TQAloJuiOsS5cv46IxrUhZEs3q0hd8Rus97Uu9vX8kdVuxf3LWuB06inJuvvLtMeyR1bk+7AH+Q9+XycqvNCHH4B6907JmptbdsFezTse7ikp41zz91qEPPOE0zpjn/7I/PgzGRIRlSwlZax7m6ioIE9HICIflnI2Bbu+3IWD8w7CeNN4135BEO45V0Ifrkf95+qj8cuNEV6J8x+uXLmCCxcu4OrVq0hPT4fJZIJWq0VwcDCio6NRt25dhIV5f5MuziWQVuz3MqIDketjIDjM+ZZkVv0AxnJDihKPiFyEP7cQ+T6OcyL/wLFO5Ps4zslX2C12nPrpOPZ/vhup/6YU61zhNSLRetL9KNWqrIvSeR7HOpHv4zgvGs4jIJe7tvn2r2/sBg6NAezmnAULBSUQ0xGIbgMEVQY0YYBCXfRrRbcpfl43YxOG/7h+/TqWLFmCFStWICEhAcDdTRcKO+E/v+OVSiVatWqFp59+Gvfff3/RQxMVESdOSOObNyL/wLFO5Ps4zonyUpw/h9THWqLaC1mwO1mUcGu9Oah6n/OHC72Bu8Z6wPgxMHw1Q7LG0qoN0n5e7ZLr+aN15/9A7zU9ndYtfng5OpbrJEMi8mb8vk5UOMpTJxHeqolkjbVRE6T+/rdMiZwrSeM8aNDz0P38o2SNKAhIXfMXbI2k/z8Q+ZuSNNa9CSdPEJEc7BY7Lu+8jMs7LiNhbwKyrmXBlGqCJcMCTZAGulAdAqIDENcoDqWbl0bpZqWh/M+/61TycS6BNFe8lwnb1gSqrJP57jeWHoDMGtMLfV4ich3+3ELk+zjOifwDxzqR7+M4p5LOmmnBsYWHcWDmXmQlZBbrXIGlgtD0rZao+mQNKJROJgeWMBzrRL6P47xoOI+AXG6xIqfhwn/dek7eZQvqCcAzNhedy31Ung7gLf7991/Mnj0bv/32G6xWa57GCf9tulDYvhX3atogiiJsNhs2bdqETZs2oVy5cnjuuefw+OOPQ60uRucPIiIiIiIiovzYbAh+eQBGN3DegKGro0aJacDgTtmvDIV+zjcQTKZ8azRbN0O9YxuszVvKmMx3dCzXCW1Lt8Omyxsk69795x20Ld0eaiXvmxARFZRu8QKnNabefWVI4psy358KzYa/oUjJfxUSQRQR+NYIpP65AVDy4UQiIiLyfkqNEuVal0O51uU8HYXIp9n1FSWbMCiN52RMQ0REREREREREcjPeMOLwd/txePZ+mFPNxTqXNlSLhq81Q50X6kOl46OCRERE5AL/fY7+1nPyhXy+Pl+u6uXgZn7/zurSpUv47LPP8Pvvv8PhcOQ2WLizccKdTRe0Wi0qVaqE+Ph4xMbGIioqCjqdDjqdDkqlEmazGSaTCWlpaUhMTERSUhLOnj2L5OTkPNf97/nPnz+P9957D7NmzcLgwYPRo0cPKBS+1XWMiIiIiIiIPMvw8VQknt6NuV2c17725Ez3ByoBxOhoGPv2h+Eb6T8Pw8dTkbZ8pUypfIsgCJhw32S0+6ElHKIj37rTqacw7+hsDKg7SMZ0REQlmNUK3Q9LJEtEgwHm7o/JFMj3iFFRyHzvAwQPfVmyTn3oAHTz58LUf4BMyYiIiIiIyNvZDRUl9yuzz8qUhIiIiIiIiIiI5HTz1A0cmrUPJ5cfg91UvFXeVQY16rxQHw1ebQJdqM5FCYmIiIhwu+lCQbcXhqsaOcjAb5swZGRk4LPPPsPSpUtht9shiiIEQchtjnCr8UJ8fDyaNWuGZs2aoU6dOqhQoUKRmiOkpKTgxIkT2LNnD3bu3ImDBw/CarUCQJ5rJiQkYOzYsZg9ezbeeecdtGrVykW/YyIiIiIiIvJnqj27YPjkQ7zdCbA6WYT5gZi2qBvTUJ5gJYBxyOvQz5sDwZx/x3HNpg1Q7dkFW+OmMibzHTUiaqJPzf6Yd3S2ZN2HuyejR9UnEa6LkCkZEVHJpVn3JxTXkyVrzN0egxgULFMi32R+qhcsP/4AzeYNknUBH0yAueujECMjZUpGRERERETezG6oILlfYboIOKyAQi1TIiIiIiIiIiIichdRFHF500UcnLUXF/8+X+zzqQPUqP1CfdR/uTH0EfriByQiIiK6UwlqkuBugij635/Gjz/+iE8++QQ3b97Mbb4A3G68UKlSJXTq1AmdOnVCtWrV3JIhKysLGzduxJ9//onNmzfDZDLdlUMQBHTs2BGjR49GXFycW3KQf0tOzvB0BK+m0eR9Ms1iKV6XQfJfdqsF549uRNLV4xBFB8IjyqF8rfuhDwr3dDQCxzqRP+A4JwKQmYnw9vfh2vVzqPgaYHIyb3dNj7/QOLZkNRNw91gPfHsE9HO+lawxd3wQ6Yt/dOl1/cl143U0W1QfGZZ0ybr+tQdgapvpMqUib8Pv60QFF/xsT2jX/iFZk7LqT9iat5ApUcGUxHGuPPsvwto0h2CxSNYZn3kWmZ99JVMqIu9WEse6N4iKCvJ0BCIi8hOcSyDNFe9l1Nf/Quj+HpI1N+47AIehYqHPTUSuwZ9biHwfxzmRf+BYJ/J9HOfkzczpZpz++QSOzD2Am8dvFPt86kAN6g5sgHovNYQu3L+aL3CsE/k+jvOi4TwCcrmkTfJdK6atfNcqIr9swlC9evXchgdATtMDvV6Pzp07o2fPnmjQoIGseTIzM/HLL79g+fLlOHnyJICcBgy3GkQMHjwYQ4YMkTUT+QdOnJDGN29UXKf3rsE3a8dgpfYMUnV5v92q7MB9aSHoGt0eD3cZjYjS7mn6Q85xrBP5Po5zIiBwxFDoF3yPEQ8C01tK17Yp3Q4/dlspTzAXcvdYV1y5jPCm9SBYrZJ1KWs3wla/oUuv7U++2P8ZJmwfK1mjEBT468ktqB1ZR6ZU5E34fZ2oYBSJCQivXwOCw5Fvja1SZaRs2wvcca/cG5TUcW6Y8j4Cpn/otC5l9TrYmjaTIRGRdyupY93TOHmCiIjkwrkE0lzxXkaRfRYR/9SXrElt8DOskR0LfW4icg3+3ELk+zjOifwDxzqR7+M4J28jiiKubr+M44uO4Ozq07AZbcU+pyYop/lC3ZcaQhfmX80XbuFYJ/J9HOdFw3kERO6l8HQATxJFEcHBwRgyZAg2btyIyZMny96AAQACAwPx7LPPYuXKlZg7dy5atGgBP+yNQUTkM25cPol3pjRF6+1PY17Iv3c1YAAAmxLYFJ6GN2wrUP/nJnh3WksknTsgf1giIiLyeZo/1kC/4HtcCwBmNnFeP6LxSPeHKoEcpUrD9Ewfp3WG6dNkSOO7BtYdhHLB5SVrHKID72wdyXsnREQStD8skWzAACDn+5qXNWAoybKHjoC9TFmndYFvjwBsxZ9kQ0REREREJZtDVwaioJSsURrPypSGiIiIiIiIiIiKKysxE3s/24XFzedi5aPLcWr58WI3YNBH6tFs9H14du8ANH37Pr9twEBERETkKX7bhCEoKAhvvPEGNm7ciCFDhiAkJMTTkQAALVq0wNy5c7F8+XI2YyAiKmHM2en45sueaP5DE3wbfAKOAn6XNauAmYFH0GRVG3z26cMwZ6e7NygRERH5DSE5GUHDhwAAPm4BGNXS9S3i70OL+PtkSFYyZQ8dBlGlkqzR/rEGysOHZErke7RKLca3nOS0bvvVf7DqzAoZEhERlUCiCN3iBdIlSiVMT/WSKZCfMBiQOcl5Myb1kUPQff+dDIGIiIiIiMirKdRw6KQbuSmzz8kUhoiIiIiIiIiIisKaacHJ5cew+umfMb/Bt9g5aSvSzqUW+7xBZYLRenJ79Nk7AI1ebwZdqK74YYmIiIio0KSfHPBRzz//PAYNGoTg4GBPR8lXnTp1MHfuXGzbtg1paWmejkNERBJEhwNrfxqP8We+wJlgG1DEexwmNTAJW/DjZxXwWfOP0LBdf9cGJSIiIv8iiggaPgSK69dx3QB82dT5ISMav+X+XCWYo2w5mHo+A72TB1sDPvkQ6XOkayh/XSo8gtal78eWyxsl68ZvG4OO5TohQB0gTzAiohJCvWMbVGfPSNZYHugEMSZGpkT+w9LpIZgf6ATtuj8l6wKmfgDzY09CjIiQKRkRERFRwVw/cR0Xt17E5R2XkXYxDaZUE8xpZtit9iKdTxAEDD0z1MUpiXyH3VARSmP+jRaU2WdlTENERERERERERAVht9pxedMFnPrxBM798S9s2TaXnTu8RgQavtoUlbpXhVKtdNl5iYiIiKho/LIJw8iRIz0docBatmzp6QhERCTh2PblGPf3MGwOTwdc1NvnZIgVDx99DWOPrMKgV5ZDofTLb9dERERUTLqF86D983cAwKfNgSyNdH3jmKZoXaqtDMlKtuzXRkC3bDEEe/4PH2hXr4Ty+DHYa9SUMZnvEAQBk1pNRbtlLWEX8/9zvpJ5GZ/v/wRvNx0jYzoiIu+nWzTfaY3pmT4yJPFDgoDMiVOh2bwRgtmcb5kiLRUBUycic9onMoYjIiIiyt/xn49j+/TtuLz9cp7toigW67yCIBTreCJfZzdUBG78ne9+pZFNGIiIiIiIiIiIvIHD7kDirqs4s+oU/l15EsbrRpeeP/6+0qj/cmOU61gBgoL3VYmIiIi8hcLTAYiIiEqia+cPYcTkBmi374WcBgwuZlcA45V/o9fkSrh24YjLz09ERES+TXH2DALHjgIApOiAGc2cH/NGk7c4Mb4AHBUqwvx4T6d1hk+myZDGd1UPr4EX6rzotO7L/Z/hQvp59wciIiohhIx0aH/9RbLGERUNS8cH5QnkhxwVKiJ76HCndbr5c6E8dlSGRERERET5s2Ra8NMzP2H5k8txeftliKKY5wvIaaRQlC8ics6uryC5X2k8D4gOecIQEREREREREVEedqsdFzecx8YR6zCvzjf4pfsPODz7gMsaMCjUClR9sgae/PtZPLqiJ8o/WJENGIiIiIi8DJswEBERFYIx4ya+mNENzX5phQUhZyC6+T7H+vAUdFrWCkf+WereCxEREZHvsNkQPPhFCNlZAHIaMGRopQ9pEN0Q7cp0lCGcb8h+/Q2ICulbKtqVK6A8dVKmRL7pzSajEKGLkKwx28149593ZEpEROT9tCt+gmCUnvBheqoXoFbLlMg/ZQ95HfZy5SVrBIcjp2lWMVeXJiIiIioqu8WO+R3n4+gPR/M0XLjTna//25zhXgpSQ0S32Q2VJPcLDjMU5qsypSEiIiIiIiIiInO6Gad/OYl1L6/B97W+xuqnfsaxBYdhvJ7tsmtow3Ro+HpT9Nk7AB2/fAhRdaJddm4iIiIici2VpwMQERGVBKLDgdVLRuK9y7NxMcgu67WvBDrw8J4XMfPSQXR5erKs1yYiIqKSx/DZx1Dv3Q0ASNMCnzZ3fszwxm9xhcJCsFeuAvOjPaD7+cd8awRRhOGTD5Ex8zsZk/mWEG0o3mk+HsM3vipZt+bcr9h4aT3uL9NepmRERN5Lt3i+0xpTrz4yJPFzej0y35+CkL5PS5ZptmyE5o81sDz0sDy5iIiIiO6wZsgaXNl1BYIgQBCE3MYJcQ3jEFElAmfWnoEp1QRRFCEIAur3qw+r0QrjTSNSzqYg5WwKgNuNGkRRhC5Eh2rdq/E+E1EB2fUVndYos8/CoSstQxoiIiIiIiIiIv+Udj4V59eexYU/z+Lq9stw2BxuuU5c81Ko0as2KnWrCrWBCycQERGRjEzXAV2kp1MUnBflFUQuQUDkt5KTMzwdwatpNMo8ry0WeR+8J++xf+P3GLd1FHaGZxX5HB1uhuGddlMRGVsF/2ydi0WXfsHW8PRCn2e0pRVeG7oagpOVl6ngONaJfB/HOfkT1f69CO3SEYI95+/5pNbAmA7Sx9SOrIu/n9xS4ifHyz3WlSeOI6xtcwhSqz8qFEjZtgf2ipXdmsWX2R12dP6pPQ4m75esqxpWDRt6boNayQ8ofR2/rxPlT3n8GMLbSndfsjZtjtTVa2VKVDQ+M85FESFPPgrN5g2SZfbyFXBzyy5Aq5UpGJF38JmxLrOoqCBPRyAiH3H9xHV8VesrAMhtshBbPxaPzn8U0bVyVl2b1WAWkg4l5e4fZx+X5xxZ17JwZNkR7P5iN26cvpF7b6lChwp4cvmT0IXo5P1NkUtxLoE0l72XsZsQuT4GAvK/x5hRYwZMpZ8r2vmJqFj4cwuR7+M4J/IPHOtEvo/jnArLYXfg2r5EnPvzDC6sPYubJ2647VqG6ABUe6omavSqjdBKYW67jj/gWCfyfRznRcN5BFQgy0OBmm8B1YcBSi/+HPf6LuDAm0BMB6DOOOf1MuATnERERPm4emonXp1UG52ODS1yA4ZqaWosi38bi0efQ+37nkZspUZ4vN8X+HnMZayq+AFqpRZugv0Hmq14a2oT2CymIuUhIiIiH2Y0ImjIS7kNGDI0wPQWzg8b0fitEt+AwRPs1WvA3PVRyRrB4YDh04/lCeSjlAolJrWa5rTuVMpJzDnyjQyJiIi8l27xAqc1xt59ZUhCAABBQOb7kyE6aaSpPH8O+u9myRSKiIiIKMc/H/6DO9frCK8Sjr7r++Y2YCiIgOgANHu1GV45+gpaj24N/P/20rm/z+H7tt/DnG52dWwi36PUwaErJV1iPCdTGCIiIiIiIiIi35V+MQ3HFh3G2pd+w7w6s/Dzw0uxf8ZutzRgEJQCyneuhIfmd0ef/QPQYmxrNmAgIiIiz7KmA4fGAKsqAydnADajpxPldWMPsLkHsK4FkLzV02nyYBMGIiKi/8hMScJHn3RC898fwLKwi0U6R5hJwDRFN6wffgntHh0N4R4T7pt3HoK1Iy5gnO1+KB0FP/f3IacxcFptZKdfL1I2IiIi8k0Bk9+H6vSp3NczmwA3DdLH1AiviYcqPOzmZL4re9ibTmu0y5dCcZ4TpYujaVwzPFH1Kad103ZPRnJ2sgyJiIi8kMUC3Y9LJUscAYFOGwiRa9lr1ISp3/NO6wzTp0FI5vcwIiIiks/p1achCAJEUYQgCOj8aWfoQoq24olCpUD7ie3R9duuuduuHb6GFX1XuCoukU+z6ytK7ldmn5UpCRERERERERGR7zDeMOLflSexccQ6LGwyGwsbz8bGYevw74qTMF53z0OHMY3i0HpyO/Q79BK6zO+OCp0rQalWOj+QiIiISC7Gq8C+YcDKcsCRSYAxyXNZRBG4sgZY/wCwthlwZWXONi/DJgxERET/57DbsPz7wbjvu2qYpt0Ok7rw51DZgVcy62Bnr/14btBCqLXSTz6qtQYMGboKv9X6DOUyCn6T5bfwa3hqRh3cvHq68CGJiIjI56h2bId+1pe5r7PUwEctnR83vPFIKATeGigqe63aMHfpKlkj2O0wzJguUyLfNa7FBBhUAZI1GZZ0TNoxXp5AREReRvPnGihuSK/QYX60BxAYKFMiuiVr5DtwhIRK1igy0hEw5X15AhEREZHfu3HqBrKSs3Jfh5QNQeXOlYt93gb9G6DJkCYQRRGiKOLUr6dw6rdTzg8k8nN2QwXJ/WzCQERERERERETknDndjAt/n8M/727CD+0XYG6NmVg78DccW3AY6RfS3Hbd0EphaDKyBXrv6I/Hf38GdV5oAEOUk5WTiIiIiOQWWDGnwYEg5PzXfB04PA5YWRbY2hO4+gfgsMuTJfMscPh9YFUFYHNXIGn9f5ovCECg9OdnclJ5OkBJlJSUhK1bt+LYsWM4d+4c0tPTkZGRAZvNVuRzCoKAv/76y4UpiYioMHatnYmxu8djf5gRkH62K19dbkZhXNevUbHeA4U+tmG7/vi7dnu8PqsDVodfK9AxO8Oz0H1ecyx7fA3iqzYr9DWJiIjIR2RlIXjoIAh33Hz4phGQ7OQ9TdWwanikYnc3h/N92cPfhHbNr5I1uqWLkD3sTTjKlJUple+JDYjD8MYjMXHHu5J1S04sRJ9az6FRTBOZkhEReQfd4gVOa0y9+siQhP5LjIhA9ptvI3DM25J1uoXzYHxuAOx16sqUjIiIiPxV0uHbq5kIgoCKD1Ys0HGiKEIQBMmadhPa4cDcA7BmWQEAOz7ZgaoPVy16WCI/YNdLj0GF8dztSXHkn0QHAIF/B4iIiIiIiIjukHE5HQk7ryBh51Uk7rqCG8evAzItnBxUNhgVu1RBlR7VEFUvxul9UyIiIiKPe/gocGwKcGwqYDfdbsYgWoFLP+V8qUOB0t2A+EeAmPsBbYRrru2wAzd3A4l/5Vwn9VDO9lvPPgjC7TwRTYAmXwHhjVxzbRdgE4ZCOHToEGbMmIHt27fD4XDkbhfF4r9T55tuIiLPOHfoL0xc9TJ+DU8Cwop2jtqpWrxfbzTue2VYsbIER5XDd6NO4KNPO+Mj/a4CHXMyxIpHfumMHx5YgsoNOhfr+kRERFQyBU58F8rz53JfG1XAtPucH/d6ozegVCjdmMw/2OrWh/nBztCu/SPfGsFmg+HzT5A57RMZk/mel+q9gkXH5+FcWv6r/4kQ8dbmEfjz8Q38+01EfkNx9Qo0G/6WrLFVrQZb46YyJaL/MvYfCN33s6H693S+NYIoInDcKKT9vJoP1hAREZFbGW8aAdxuqhBdK/rehf95S2Iz2qA2qCXPrQvRocpDVXB0+VEAwIVNF2BKNUEXqit2biJfZTc4acJgz4RgSYaozWeskm8S7dAm/gjd1YVQp+6E4DDBoQ6DNfQ+mEr1hSWyE392JCIiIiIiIr/hsDtw49h1JO7KabqQsOsKsq5mypohtEo4Kj1SBRUfrozIOtF8BoyIiIhKFqUWqPMuUKEfcHA0cHFZzvZb72lEEbCkAOfm53wBQHBNIKIxEFoXCKkNBJQDDKUAVT4rRYoOwJgAZF8G0k8CaYeBlIPA9R2APev2dW6589oBZYE643Pyedn7LDZhKKBp06Zh3rx5cDgcdzVdKO6bZ1c0cSAiosK5efU0PlvQD98ajsAWXrRzRGULGBPWEz3f/BJKtcYluRRKFUaO+AvVFg7DkJuzYS7Ad+rLgXZ0Xf8UlmV+hbqte7skBxEREZUM6i2boJ/9TZ5t3zUEEoOkj6sYUgmPVn7cjcn8S/bwkZJNGICcFcqzX38DjvhSMqXyPVqlFhPvm4Lea3pK1h1KPoB5x+bg+doDZUpGRORZuqWLINzRNPheTL36et2HE35FrUbWhA8Q0utJyTLNP1ugWfsHLJ0ekikYERER+aNbTRhuMUQa7lmn0qryzGWwGq1OmzAAQOkWpXObMIgOEVd2X0GlByoVIzGRb3PWhAEAlMazsLEJg99QmBIQfKg31Gl78m63pkCbvBra5NWwhLZERq2ZcBgqeCglERERERERkftYMy1I2peIhP83XUjamwBrpkXWDIJCQGyTeJR/sCLKdaqI8KouWgmaiIiIyJMCywP3LQZqjQIOjgGurs5pgnBnQ4Rb0o4C6cfuPofSkNOIQakHBCVgNwF2I2BNB3CPeYz3arxwa7s+Fqj5NlB5EKB0zbOZrsYmDAXw3nvvYenSpbkTDP7bdIFNFIiISg5zdjrmzR2AD81/IM3Jw4n50diAIdbGGPzcPARFlnFtwP/r/uwniFtXDb0Pj0RaARYHuqEX0X3vy1iUcR0tu7zmlkxERETkXYSMdAS9PjjPNrMSmNrK+bGvN3oDKgVvCbiKrWFjWNp3hGb9X/nWCBYL9F98iqwPPpQxme95oHxndCj7AP6+uE6ybvLO99G14qOIMkTJlIyIyEMcDuiWLJQsEVUqmJ58WqZAlB9Lx05O3y8AQMCEsbB0eABQ8b0aERERyUOlv/f7Dm2wNs/rzIRMGCLu3bDhToGxgXlep5xJAR4oej4iX+fQl3dao8w+A1toc/eHIY8TLNcRuqcTlMbzknWa1G0I29kG6XXnwxrRTp5wRERERERERG6SlZiJhF1Xkfj/pgvXj1yDaJf/OS11gBpl2pVH+U6VUK5jBegj9LJnICIiIpJFaB2g7Uog7ThwYjpwflFOMwXg7kYJ/2XLyvkqqHudL7Q2UH04UL43oHC+EIAncRafExs2bMCSJUsgCEKe5guiKEKtVqNChQooVaoUAgICoFZ79/9sIiJ/JjocWLNsNCZc/AbngmxAARob3EuPlHiMfuxblK3Z2rUB76HpA4PwW2gpPLWhD64ESq9oCQBZGqDnv2Px7bJkPPTURLfnIyIiIs8KGD8GyksX82yb2wC4Eix9XNng8ni8Sk83JvNPWSPecvpQpX7B9zC+NgKOmFiZUvmmSa2mYsvSTbA48u9wn2ZOxYTtY/F5h69lTEZEJD/1tq1QXjgvWWN58CGIUWxK4w0yJ0xG2KYNEOz2fGtUp09Bt2g+TP2elzEZERER+ZP/Nlew5LOC3H/r0i6lIbp2tNPz/3dxC1OqqSgxifyGqAqCQxMNheVavjXK7DMyJiKPER0IPtzfaQOGWxS2NIQc6In0eotgiXzQvdmIiIiIiIiIXMRhc+DGsWQk7r6KxN0JSNqTgPSLaR7LE1gqCOU7VUT5Byuh1H2lodTyMTsiIiLyIyE1gGbfAvWn5jRiOLcAuLnn9v47GygU1a3GC5pQoOyTQIW+QNR9xT+vTPju0Inp06fn/vrWZIHKlSvjlVdeQfv27aHTFfEpXiIiks2+DXMx/p93sCM8Ewgq2jkapujxfrP30aTji64N50TVJl2xJmwdnln+EI6F5P+Q2S0WFdA/eQY+nX0NT7/wjQwJiYiIyBPU69dBv+D7PNssSmByK+fHvt5wBNRKNhF0NVuTZrC0vh+aLRvzrRHMZui/nIGsCR/IlssXVQytjCENXsP0vR9K1i07uRi9a/ZD87gWMiUjIpKfbtF8pzWm3n1kSEIFYa9aDcb+A2D4bpZkXcC0D2B+/EmIgUW8kUVEREQkITA2MM9rc7r5nnVhlcLyvL665yqqPFTF6flTz6cCyJlfIQgCBIULJuYQ+Ti7oRKbMBC0CUugubmpUMcIDjOCD/RCer2FsER1dlMyIiIiIiIioqIzXs9G4p4EJO65iqQ9Cbh2IBG2bJvH8qgMasS3LI3SrcuidJuyiKgZmWfBXiIiIiK/pA0Hqr2a85V5FrjyG3D1dyB5C2DLuvcxd76HutVo4b/7g6sDsQ8C8V2A6LaAUuOe/G7EJgwSLly4gNOnT0MQhNwJAh07dsT06dOhVvOBFSIib3fp+FZ88PNA/BR2BQgv2jni2gMqmQABAABJREFUsxQYG/0sHnvpUyiUnvm2GVe5CX7pvwv9vmuF7eGZTusdCmCoeSlufp6Mlwf/BEGhkCElERERyUVIS0XQsFfv2r6gLnAxVPrY0oFl0LPaM+4JRsh+4y3JJgwAoJ83G9mvDuOK5MU0tOEILD+1DJcyLkrWvbVpOP7uuQUqBW+BEZHvEdJSof1tlWSNPSYWlnYdZUpEBZE94m3oli2BIiM93xpF8jXov5yB7LfekTEZERER+YvI6pEAkDuxOOVMyj3rYurG5Kk799c5tB3b1un5z/yZ92FxfYS+yFmJ/IXNUBnq1O357mcTBj/gsCHg7LQiHSqIFgQf6ofUxr/BFtLYxcGIiIiIiIiICk50iLh54joSdl1F4u6cr/TzaR7NpFArENMoLqfpQuuyiG4YC6VG6dFMRERERF4tsOLthgyiCKQfB27sATJOAVnngezLgDUdsGcDDjug0gPKAEAXDQSUyzk+tC4Q0RhQB3v6d1NsnIEu4dChQ3leR0REYMqUKWzAQETk5dKTL+Dz7/thpnYfLGHO6+9FbwVec7TESwMXICDU8w/IhcZWxJKhh/DSjCb4M/xGgY4Zr/wbNz9uh3dGbGAjBiIiIh8SOOZtKBOu5tlmVQCT2jg/9tWGw6ApgR0kSwpri/tgadkKmm1b860RjEYYZn6OrHETZEzmewxqAya1moa+vz8tWXf85lHMPjwLL9UbLFMyIiL5aH/+EYLJJFljfro3oOLHAN5EjIhA9utvIPD9cZJ1hpmfw9TveThi42RKRlRyTJo0Hr//vtpt558x42s0bMiH14jId4VXDodKq4LdYgcAXD9+/Z51pZuXzv21KIq4uPUiEvYnIK5B/u9Pzm86jwubL+QudAEAkdUiXZieyDfZDZUk96uyz+RMcuOqjD5Lm/QzlMZzRT5ecBgRcuAppDRdD4e+nAuTEREREREREeXPmmXFtf0JOU0Xdl1F4p4EWNLNng0lAJG1olCqdVmUblMW8c1KQR3I+XJERERERSIIQEjNnC8/xdmXEm7cuP2QqyAI6NKlCwICAjyYiIiIpJgyU7Fg/kv4yPQHUgLEIp1DEIHeaRUw8qk5iK3UyMUJi8cQHIk5bx7F8I+aYlmY9Iq/t8wI2I+UKQ0x9Y0dUGl0bk5IRERE7qZe/xd0yxbftX1xHeCck+ZTcQHx6FWjj5uS0S3ZI96SbMIAAPo53yJ76DCIoUXsGEYAgM4VuuDBcp2x9sIfknVTd32A7pV7IDaAD7ESkW/RLV7gtMb4zLMyJKHCMg4cBP3cb6G8fCnfGiE7G4apk5D5yRcyJiMiIiJ/oFQrUapZKVzYfAEAcGX3lXvWhVUMQ6kmpXB1z9Xcpgo/Pf0T+vzVByFlQu6qTzqchJ+e+QnCHQ+Jq/QqlGpWyj2/ESIf4qwJg2DPgsKcCIeO97d8lS7h7vv+haWwJCNk/xNIbbIOojq0+KGIiIiIiIiI7uCwO5By6iauHUjEtf1JuHYgETeOJMNhc3g0l8qgQkzDOMQ1jUds01KIaRwHbbDWo5mIiIiIyHewCYMEi8UCIGdVB0EQUL16dQ8nIiKie7FbLfhl8XB8kLQIlwLtQBF7DbS9GYLx7T9CrZZPuTagC6m1Bnz29gGEfdQaXwcdLdAxC0LPImVabXz52i7og8LdnJCIiIjcRcjMQNAbr9213S4Ak9o4P/7VBq9Dq+QHTO5mbdUG1qbNod61I98aITsLuvnfwzh0mIzJfNOk1tOw+fJGmOz5rwSfac3A+G3v4OsH5siYjIjIvZRHDkN9cL9kjaVlKzgqSj/IQx6i0yFr1FgED35RumzJQhhffAX2Gv7bSZzIEwSuME1EfqB8u/K5TRhMKSZc3XMV8Y3j76prMKABruy+AkEQIAgCbpy+gZl1ZqJe33oo27os9OF6ZF/Pxpm1Z3B40WHYLfbchg2CIKBe33pQqpVy//aIShxnTRgAQJl9hk0YfJRguQ71zU0uOZcq6ySCD/VBWoOfAAVX+SQiIiIiIqKiEUUR6efT8jRcSD50DbZsq6ejwRAdgNim8YhrVgqxTeMRWTuK9yCJiIiIyG3YhEFCSEje1RsMBoOHkhAR0b2IDgc2rpqCCcc+wdFQMxBYtPNUTVNjfNXX0GHQGAgKhWtDuoFCqcJ7b/6DiBldMUmzpUDHrA6/hvTP6mLuoO0Iiizj5oRERETkDgGT3rvnasnLagOnI6SPjdJHo3fNfm5KRnkIArKGj0To0z0ky/TffQ3joMGAhhNhi6NccHkMbTgc03Z/IFn38+kf8WzN59CqVAE6lhARlQC6JQuc1pieeVaGJFRU5sd7wjrrK6gPHci3RnA4EDBhLNKX/CRfMKISoFevvnjwwYeKfZ6EhKv46KPJcDhur9BUvXpN1KpVp9jnJiLydtUfrY5N723KbTxz4pcT92zC0HBAQ+yZuQdJB5Nyt5nTzdj95W7s/nJ3ntpbjRdu0QZr0WpUKzf9Doh8i91Q0WmNMvsMrOEcU75Im7QSgmiXrMmsMhEK6w0Yzn/i9Hyam5sQeHwYMmt+AbDBGBERERERERVAVmImru1PxLUDSTn/PZgEc0r+C6LIKaxaBOKaxiO2aSnENY1HcPkQNtQmIiIiItmwCYOESpVyOs3feoN+8+ZNT8YhIqI77N/4PSZuHYMt4elAaNHOEWEU8HZQd/Qa/jXU2pLVaEdQKPDa678h7Jt+eNO6AmIB7iVtDk9Hj1mNsLjPRkSV5QqKREREJYlqx3bo5nx713a7AEwswDPlQxq8Dr1K74ZkdC/Wdh1gbdgI6n17861RJiZA+8tPMPd8RsZkvmlIg9fxw8klOJ9+TrLu7c0jsL7nP9Ao2fiCiEo4sxm6H5dJljiCgmHu+qg8eahoFApkvfs+Qh/vKlmm/Xsd1Js3wtrmfnlyEZUAFSpURIUKzh9UlGI2mzFz5ud5GjAEB4dg4sSp0LBRGhH5gdh6sYioEoEbp28AAA7MPYB2E9pBUOT9wEkQBPRY1APz7p+H7OvZuXMnRFG865x37lMoFej+fXeElAm5q46I7kFpgF1bCkrzlfxLjGdkDERy0txYJ7lfFJQwxfeGqA4HRAcMFz5zek791QWwGyrBWGG4q2ISERERERGRjzClGHOaLRxIQvL+RFw7kIisxCxPxwIAKLVKRNePRWyzeMQ1LYXYJnHQhXHOGxERERF5DpswSKhbty4MBgOMRiMA4NixYx5OREREZw+uw5Rfh+CX8AQgvGjn0NiAwZZGGPLcfARFlnFtQJn1fXEewhZF4aWb38CmdF5/MMyE7otb4YdHV6N09ZbuD0hERETFZzIhaPgQCPeY3P5DLeB4lPThkfpI9K3V303h6J4EAdmDX0PIC30lywxffQ7zk09zNbJi0ql0mNLmIzy9+nHJulMpJzHr0Fd4tcHr8gQjInIT7e+roUhJkawxP/YEYChZDSf9kbV1W5g7PgjtX2sl6wLeG4vUdZsAhUKmZES+75NPpuHUqRO5rxUKBcaNex+xsXEeTEVEJK+nVz2NzMTM3Nd2ix0q3d1TSKJqRKHv332xvOdyXD9xHQDyXWlOFEXoQnXosagHqjxUxT3BiXyU3VBJuglD1r8ypiHZiHaoU7ZJlljD74eoiQAAZFV5DwrTJeiSfnZ66sB/x8NuqABLzGMuiUpEREREREQljzXTguTD13Btf2JO44X9iUi/kObpWLkMMQGIbRyHmMbxiG0Sj+h60VBq+ZgbEREREXkPvjuVoNFo8NBDD+Gnn34CAGzcuBEWi4Ur4BAReUDSuQP4ZOkAzAs6BXsRmy8AwBMppTGqxzcoU6OV68J5WNfeHyF4VTT6npsIo9p5/b/BNjzyaxcsz1yEKo0fdn9AIiIiKhbD9GlQ/Xv6ru12AZjQ1vnxg+q9igB1gBuSkRRLl66wly0P5cXz+daojh3JWdm6bTv5gvmo9mUfwMMVu+G3s6sk6z7ePRU9Kj+BUkGlZUpGROR6ukXzndaYej0rQxJyhaxx70Oz/i8IDke+NerDB6H9cRnMPZ+RMRmR71q9+hesXr0yz7bnnhuA5s3ZtJaI/EtktUhEVossUG107Wi8fOhl7Jm1B0eXHsWl7ZcgOvI2DI2oGoFaPWuh+bDm0HN1OqJCsxsqASmb892vzD4jYxqSizLzKBS2VMkac3TX2y8EBTJqfQ2l6QrUaTudnj/4yEtI1ZaCLbRpMZMSERERERGRtxNFEalnUpC4+yqS9iQgcc9VpJy8edd9PE9RqBSIqB2F2MZxiG0Sj9jG8QgsHZRvw1ciIiIiIm8giOI9ltKkXJcvX8YjjzwCs9kMABg2bBhefPFFD6cico3k5AxPR/BqGo0yz2uLxe6hJP7txuWTmLnkRXyj2Q9TARoM5Kf5zUC81+oDNLj/OZdl8zb7NszFM/tfR4quYN/aw0wCljT4FA3b+ffK2BzrRL6P45xKMuXhQwh7sC0E+91/bxfVAZ59XPr4MG0Y9vY5gkBNkJsSeg9vHOu6775G0OiRkjWWdh2QtmyFTIl82+WMS2i1pAmybdmSdV0rPYrZnZw/wEzeyRvHOpGcFJcuIrxxHQgSt/VtNWoiZeN2oIROVvHHcR44Yij0C76XrLGXKo2b2/cBOp08oYjczFNj/eTJE3j55RdgsZhztzVr1hIffvgpFAqFLBmKIyrK93+2I6KSwZJlQcbVDGRfz4YmQIPAuEAERLEJqC/hXAJp7ngvoz//OQJPv5PvflGhxfX2SYDg/e9ZqOD0F75E4KlRkjU3W+6FPaBKnm2C5QbCdrWH0njO6TUc6gikNvkT9oCqxcrqj/zxHgWRv+E4J/IPHOtEvs9fx7k1y4pr+xOQuCchp/HC3gSYbpo8HSuXLkL//2YLcYhtGo+oujFQG4rxMAD5PX8d60T+hOO8aDiPgMi9VJ4O4O1Kly6N0aNHY9y4cRAEATNmzEDVqlVx//33ezoaEZFPS0++gFkLBuIrxQ5kFWPOVpV0NcZUeAmdB02EUAIm0RZHw3b98WtgJJ7c2AcJAfmvnnhLik5Ej4OvYX7GdbTp9qYMCYmIiKhQbDYEvT74ng0Y7AIwoa3zUwyqN8QvGjB4K9PTzyJg2gdQpKbmW6PZ8DeUp0/BXoUTYIurdFAZDG88EhN3jJes+/XML1h/8S+0L9tRnmBERC6kW7JQsgEDAJh69SmxDRj8VfbI0dD9tBxCdla+Ncorl6Gf8y2Mr7wqYzIi35KenoYxY0bmacAQFxePd999v0Q0YCAi8iaaAA0iqkQgokqEp6MQ+Qy7oZLkfsFhhsJ0GQ59WZkSkRzUqTsl99s1MbAbKt+1XdREIK3Bjwjd1QEKW6rkORTWGwjZ2w2pTf6EQ1+uOHGJiIiIiIjIQ0RRRMaldCTuvprTcGFPAq4fTYZo9541eUOrhCOuaTxim8Yjtkk8QiuFQeDn1kRERERUwgmi6GTGJgEAvvzyS3z++ecQBAFKpRKDBg3CgAEDoOOqU1SCcfUKaeyg5RlZKQmYu+AlzLBtQqqu6N+iYrIVeDukB3r2/QJqrcGFCb3fpeNb0XNlN5wJthWoXm0HZkUOwiPPTHNzMu/EsU7k+zjOqaTSz/gEgRPfvee+hXWBPj2kjw/ThmFPn8MI0gS7IZ338daxHjDpPRg++1iyJnvAS8j64EOZEvk2i92Cdsta4nTqKcm6CiEVsempHdCpeF+npPHWsU4kC7sd4U3qQnn5Ur4lolqNG4dOQYwouQ/D+es4N0z7AAEfTZGscYSF4ebuQxCDQ2RKReQ+co91URTx5puvYceObXdk0OCrr2ajevUabr22K3EFCyIikgvnEkhzx3sZZeZJhG9vIlmT2nAlrBHtin0t8h5hW+tDZTyb735TzOPIqDs33/3qm1sQsu9RCKLV6bVs+opIbfInRG1MkbL6I3+9R0HkTzjOifwDxzqR7/PFcW4z2ZB86Nr/Gy5cReLuBGRfy7+hu9y0YTpE149BdINYxDSIRUzjeOgj9J6ORT7OF8c6EeXFcV40nEdA5F5swlAIq1atwrvvvguj0QhBEBAcHIwuXbqgcePGKFu2LEJCQqBSqYp8/vj4eBemJXKOEyek8c2bvIwZN7FowSuYbvwd1/VF/9YUZAaGKe9H/76zERAa5cKEJUvyxWN4ZuH9OBRqKlC9IAIfqh9D3xfnuTmZ9+FYJ/J9HOdUEinPnEbY/S0hmM137bMpgJqDgdNOnq18p9m7eK3RCDcl9D7eOtYVSYkIb1gLgjX/SbCOoGDcPHgcYiBvhLrC5ssb8cSqbk7r3mr6DkY0fkuGRORK3jrWieSg3vA3Qp96TLLG3PVRpM+eL1Mi9/DbcZ6ZifDmDaC8liRZlvX6G8gePU6mUCVTWhqQkKDwdAyfERfnQIgb+n7IPdbnzPkGc+Z8k2fbyJHvoFs36X9XvQ0nTxCRK1zZdQV7vt6T+1pQCnj4y4eh/M+/zeTfOJdAmlveyzjMiPw7BgIc+ZZkVJ8OU5kBxb8WeQXBloHIDaUkazKrToax3GDJGu3VRQg++nKBrmkLrI3Uxr9BVIcVOKc/89t7FER+hOOcyD9wrBP5Pl8Y51mJmUjcndNsIXH3VSQfvgaHl/w+VAY1outFI6p+LKIbxCK6fgyCy4VAEARPRyM/4wtjnYikcZwXDecRELlX0TsG+KFu3bqhdu3a6NOnD27cuIG0tDQsXboUS5cuLfa5BUHAsWPHXJCSiKhksRgzsWzBEHyU9gsSAhxAEZtgqu3Ai8a6GNJrNiJKV3NtyBIoqmxNrHhxL577ugW2hKc7rRcF4A3bCpybdgZjhq2HUq2RISURERHdk8OBwOFD79mAAQAW13HegCFcF44X6rzohnBUWI6YWJgfewK6H5bkW6PISId2+TKY+nMCtSu0KX0/Hq3cA7/8+7Nk3Wd7P8YTVZ9CueDy8gQjIiom3eIFTmuMvfvIkITcIjAQ2W+OQtCbr0uWGWZ9CdPzA+GIjZMnVwmyc6cSb72lxbFjfIDUlQRBRI0aDkybZkLTpvk/EOjNdu7cju+//y7Pti5dupa4BgxERK5yecdlHPj+QO4k6YodK7IBA5E3UGjh0JeF0ng+3xJl9hn58pDbKTOOOK2xBdVzWmOO742s7DMIOPeR01pV5hGE7OuBtIYrIKpDCxKTiIiIiIiIXMxutePG0WQk7slpuJC0JwEZl5zP9ZaDQqNEZK1IRN/RcCG0SjgUSjZAJyIiIiL/xCYMBWS32zFv3jzMmjUL6enpuRMSRLHoq7UTEfkzc3Y6li96DZ+k/IJLgXYgoGjnEUTg6bRyeOOxmShTo5VrQ5ZwQZFlsPC1Q3jls6b4LfxagY75MvAQzk6tga8Gb0VAGCfzExEReYJu6SJotv9zz302BfB+G+fneKX+awjUsLOptzA+P1CyCQMA6Od+C9NzLwDsEu8SE+6bjHUX1iLLmplvjcluwugtb2Jhlx/YnZ+IvJ5w8wa0v6+WrLGXKg1r2/YyJSJ3MPXqA/3XX0B15t98awSjEYaPpiLzo0/lC1YCbNyoRO/eelit/J7uaqIo4NgxJR57zIBFi4y4//6StdJEYmICJkwYA4fjdgOJKlWqYsSItz2YiojIs8wZOY0/RVGEIAgo3668ZwMRUS67oaKTJgz5/6xAJY8q45DTGltQ7QKdK7vSGCiN56FL/NFprTp9L0L2df9/I4bwAp2fiIiIiIiIis54w4ikPVeR8P+GC9f2J8JmtHk6FgSFgLBq4TkNF+rHIrpBDCJqRrFhKxERERHRHdiEoQDS09MxZMgQ7N69O7fpwq3J+a6YpM9GDkTkT4wZN7Fs0VB8lr4aVwIdQGDRz/XgzQiM7vARarZ43HUBfYw+KBzfjjyCNz9qikWh5wt0zO/hyeg6sy4WPrEa8VWbuTcgERER5SFcv46A98bku39hXeDfCOlzROgi8HydgS5ORsVha9gY1gYNod6/L98a1YnjUG/bCut9rWVM5rtiA+LwVtPRGPfPaMm6dRf+xB/n1+ChCg/LlIyIqGh0Py6DYLFI1pie7g0oOSGmRFOrkTV6HEJe6CtZpls0D8aXB8NeqYpMwbybKAKTJ2vZgMHNrFYBU6Zo0bZtdonpG2axWDBmzFtIS0vL3RYYGISJE6dBq9V6MBkRkWeptHmniQSXCfZQEiL6L7uhEnBjfb77ldlnZExD7qbKOCy5364rB1EdWrCTCQpk1PoagjUN2hvrnJar0/cjZG93pDX8BaLGyYcOREREREREVChZiZm4uu0yrm7P+Uo5ddPTkQAAIRVCEd0gBtH1YxFVPwZRdWKgDlB7OhYRERERkVdjEwYn7HY7Bg8ejN27dwPI23SBzROIiAouKzUZSxa/is+y/0CSoXjNF1rcDMSoxqPR/JUhrgvow1QaHT5+ax/CPm6HLwIPFuiYI6FmdFrVCQuazED9ttIT/4mIiMh1Ase/A0VKyj33WRXA+22cn2Nwg9cRqC7Gmy1yC2P/gVDvf1myRj/nWzZhcKEBdQZhyfFFOH7zqGTdmK1voW3pdjCoDTIlIyIqJFGEbtEC6RJBgOmZZ2UKRO5keaS70+ZNgt2OgA/eR/rs+TIm817p6cD+/WxAIod9+5RITwdCQjydpGA++eRDnDhxLPe1IAgYO3YCSpUq7cFURESeZ4jM+/OvKxaeICLXsBsqS+5XGs8DDhug4HQvX6DKOim53xZUp3AnVGiQXm8BQvb1gCZ1m9NydcZBhO7titRGqyBqIgt3LSIiIiIiIsqVcSkdV7ZdxtXtl5Cw/QrSzqV6OhK0IVrENIpDbJN4RDeMRXSDWOhCdZ6ORURERERU4vBTOScWLlyI3bt339V8QalUokGDBqhRowZKlSqFgIAAqFT84yQi+q/MlCQsXPQKPjf9hWSDCBTjuaYGKXqMrj0MbQaNhKBQuC6kH1AoVRj7xiZEfNkD7ynzXz3lTkkGB7odGIIvrxxG114fujkhERERqbdsgu6HJfnuX1APOBsufY5IfRT61x7g4mTkCuZHH4dj/DtQ3My/u71mza9QJFyFIy5exmS+S6VQYWrb6ei2opNk3aWMi/h070cY3XycTMmIiApHdWAfVMelG8pYW98PR9lyMiUitxIEZI15D6GPd5Us0/76C1T798LWoJFMwYhKlt9+W4Vff12RZ1ufPv1xH5ueEREholrOiue35kBkJmV6Mg4R3cFuqCS5XxBtUJguwmGoKFMicidl9hnJ/bbAGkU4qQHp9ZchZG9XqDMOOC1XZR5B6N5HkNpwFURtdOGvR0RERERE5GdEUUTauVRc3X4ZV7ddxtXtl5F5OcPTsRBaJRyxTeIQ2zgesU3iEVYlHIKCzVeJiIiIiIqLXQMkOBwOzJkzJ3fygSiKAICePXti6NChiIxkF3AiovykJp7F/GVDMdO2BTf0xWu+UCtVi7ervIwHB41n84ViEBQKDH71F4TPHojXTcsgFuDemkkNvJA6C8M/3os3h/4BpVrj/qBERET+yGRC4Juv57vbqgAmtnF+miENXkeAOsB1uch1dDqYeveD4fNP8i0R7Hbo5s1B9ttjZAzm25rHtcBT1Xph2cnFknVfHvgMPas9g8phVWRKRkRUcLpFC5zWmHr3kSEJycXaui0s7TpAs+FvybqA999F2k+/An6+enVwMNCggR379ys9HcXnNWxoR3Cwp1M4d+rUCXz88dQ82xo3booBAwZ5KBERkXeJbxwPTYAG1mwrAODSP5fQYlgLD6ciIgCwOWnCAACq7H9hYROGEk+wpkFhvS5Z46wpR35EdQjSGv6M0D2doco65bRelXkMoXseQlqjVXDoShXpmkRERERERL5KFEWknLqZ03BhR07jheykLI9mUhnUiGkU+/+GC3GIaRQHXZjeo5mIiIiIiHyVIN7qLEB3OXToEHr27AlBECCKIgRBwLBhw/Diiy96OhqRSyQne77rojfTaPJO2rVY7B5KAmRlARcvKpCcLCA1VYAo5sytDgoSERUlomxZh9dMfk34dze+/Xk45moOIquYz+tXTlfh7dL98fBTk/nwv4v9/fNEDLg4rVD/jx64GY6vXtyIkOjybsvlCd401onIPTjOqSQwTPsAAR9NyXf/7AbAgO7S54jUR2H3s4f8tglDSRjriosXEN6kLgSJWzGOqGjc2H8M0PD9r6skZyej5ZJGSDOnSta1Ln0/fuy6MrcZJ3mnkjDWiVwqKwsRdatBkZGeb4kjNBQ3Dp0CdDoZg7kPx3kO1eGDCOvQ2mld6tKfYW3fUYZE3m3jRiV699bDauX3cXdRq0UsXmxE27auGZPuGuvp6el44YU+SEi4krstOjoGc+YsQmhoqEuu4UlRUUGejkBEPuKXfr/g4IKDAABtkBavnX8Nek7UpjtwLoE0t/3c4rAhcn00BNGWb0lmtakwln3ZNdcjj1Gl7UPYrvsla1KarIMttFmRr6EwJSBk7yNQZZ8uUL1dVxapjVbCUcTmD76I9yiIfB/HOZF/4Fgn8n2uHOeiQ8SNo8m5DReu7rgC0w1jcSMWS3DZEMQ0iUNck3jENIlHRI1IKFRc1JD8D7+nE/k+jvOi4TwCIvdSeTqANztx4kSe15UrV2YDBiKSxaVLAjZuVGHLFiUOHlTi/HkBoig9gbh0aQdq17ajdWs77r/fjsqVHbIugnd67xrM/HMUlgadgy2weOcqm6HEW9FP47EBn0Cl8Y0HCLxNhx5jsGZHTTy7+QVcCizYDybrwm+i85yGmNdhHqo26ermhERERP5D+e9pGGZMz3e/RQlMbOP8PK82GOa3DRhKCkfZcrA82BnaP3/Pt0aRfA2atX/A8kg3GZP5tihDFEY3G4e3Ng+XrNtyeSNW/vszHq3yuEzJiIic0/76i2QDBgAwPfGUzzRgoNtsderB1OMJ6H7+UbIuYOJ4pN7fHlD490Sr+++3Y8WKbIwcqcPx4wqn91Kp4ARBRI0aDkybZkLTpg5Px5EkiiImThyXpwGDWq3G++9P9YkGDERErnTfW/fh8JLDEO0iLJkWbBi7AV2+6OLpWESkUMGuLw9V9r/5liizz8gYiNylIP8f7YbKxbqGQxeH1MZrELr3EaiyTjrPZLqI0N2dkdbwF9iDahXr2kRERERERCWFw+ZA8uFrOQ0Xtl9G4s4rMKeZPZZHqVUiql4MYpvEI7ZxHGIbx8MQw/lgRERERESewiYMElJTUwHkTNoSBAGdOnXybCAi8mkpKcBPP6nx449q7NundH7Af1y+rMDlywr88YcaAFCjhh2PP27DU09ZEROT/0q7xbV3/Rx8ue0DrA6/BoQW71ylM5UYFtodPV+dAa0h2CX5KH81mvfA73FV0X9hR+wOyy7QMWeCbej0T298dXYoHnpqopsTEhER+QFRROCbr0OwWPItmVcPOB8mfZoofTT61XrexeHIHYzPvyjZhAEA9Au/ZxMGF+tbsz+WHF+AA8n7JevGbRuNjuUeRKCGnYGJyDvoFi9wWmPq1VeGJOQJWW+PhfbXlRCs1nxr1EcOQfvLTzD3eFLGZN6paVMHNm7MRloakJDg300pXCkuzoGQEE+nKJh582Zj27ateba9+upw1KpV20OJiIi8V1TNKLQd1xYbxm2AIAjYM3MPwquEo/lrzT0djcjv2Q2VnDRhyH8flRzO/j86VKEQNRHFvo6ojfl/I4auUGUec57LkoTQPQ8hreHPsIU0Lvb1iYiIiIiIvI3dYse1/Ym4uuMKrm67hMRdV2HNyv+zOHcLiA3Iabjw/6/I2lFQavmYFxERERGRt+C7cwmK/6wcVaZMGQ8lISJfduGCgJkzNVi6VI3sbNet0Hb8uBITJyoxbZoGTzxhxSuvWFG1qmtWKrNbLdiwagq+PD4L/4RnAOHFO1+5DCWGRz6BHs99zOYLMosuVxs/Dj2G4TPuw09hV5wfACBLA/S7MQNvTt+F4a+uhlKtcXNKIiIi36Vdthiaf7bku9+iBCa2cX6eoQ2HwaA2uDAZuYu1bTvYKlaC6mz+K52pN/wNxaWLcJQpK2My36ZUKDG1zXR0/qk9ROTfpC4xKwHTdk/GhPs+kDEdEdG9Kc+chmbHNskaa70GsNeuI1MikpujfAWY+vaHfvY3knUBk9+H+ZHugIb3aAAgJAQICXHNfVAqOXbv3oE5c/KOlQcffAg92KCEiChfbca0QUZCBvbM3AMAWDt8LS5vu4wHPnwAIWVLSAceIh9kN1SS3K/MPitTEnInZXb+94cB538PCkPURCG10WqE7u0GVeYRp/UKWypC9nZDev1lsIa3dlkOIiIiIiIiT7AZrUjal4ir2y7j6o7LSNqTAJvR5pEsCpUCEbWjbjddaByHwFJBEATXPT9ARERERESuxSYMEsLD8z5VrFarPZSEiHzRtWsCpk/XYP58NWw29908sVgELF6c0+Th6aetGDnSgvj4/B86kpJ54wqWL38Ts1L/wNlgW7GbL1RMV2FEzFN49IWPodbyoUFP0QeF48u3D6PyjIcxVbu9wMd9qNuBg1Or4fMX1iEsrrIbExIREfkmITUFge+NkayZWx+4GCp9nhhDLPrWet5lucjNFAqYnn0OgRPG5lsiiCJ0SxYie+RoGYP5vgYxjdCnZn/MPzZHsu7bQzPxdPXeqBlRS6ZkRET3plu80GmNqVcfGZKQJ2UNGwndkkUQsrPyrVFeOA/dgrkwvfCSjMmIvEdiYiLGj38HDsft5huVKlXGyJHveDAVEZF3S7uYBgBo9VYr6MP0+GfqP3DYHTj24zEc//k4KrSvgPLtyiOuYRwCogOgDdZCoVI4Oeu9saEDUeHYDdKfuyqMFwGHBVCwCVtJpjRdlNzvyiYMACBqIpHa6FeE7HsU6oyDTusV9kyE7O+B9LrzYYl6yKVZiIiIiIiI3MmSYcGl7ZdxdftlXN12GUn7E+Gw2D2SRalTIqZRHOJblEZ8i9KIaRQHtYHPJBERERERlSSCKIpFexLXDxw5cgRPPPFEbme5t99+G/369fNwKiLXSU7O8HQEr6bRKPO8trjoBozDAcyfr8aECVpkZsrfuVKvF/HWW2a8+KIVqgK24rl4bAvmrh6F+epDyNAWP0OVdDVGxPdGt6enQaXRFf+E5DK/Ln4TQ5JnwViIe3xlM5T4rvlnqN+2r/uCuZG7xjoReQ+Oc/JWgW8Nh37ud/nuNyuBKkOBS07mqU9qNRUD677s4nQlT0ka60JyMiLqVYNgy7+zvr1UadzccxhQKvOtocJLMd1Ey8WNcMN0Q7KuWVwLrHr0D6424IVK0lgnKhabDeH1a0B5LSnfElGnw43DpyCGhMqXSwYc53czTJ2EgI+nStY4IqNwc9cBiIFBMqUiKh5XjXWLxYLBgwfg+PFjudsCAgLw3XcLUKZM2WJl9EZRURzjROQa7yneu+fPvLemj7js52EBGGcb55pzkaw4l0CaO39uUd/YgNB93SVrbrbcA3tAVZddk+QXvqUWlKZL+e7PqvAmsivn38i3qARrCkL2Pwl12q4C1YuCChm1v4E59gmXZykJeI+CyPdxnBP5B451It8liiLSz6fh+oFEJOy6iqs7r+DGsesQHZ55REplUCOuaTziWpRGqRalEd0gBkot180lchV+TyfyfRznRcN5BETuxXf0EmrVqoXw8HCkpKQAAPbs2cMmDERULGfOCBg+XIft2z33z6/RKGD8eB1WrFDjiy9MqFbNcc860eHArnUz8c3uT7E6LAliYPGvXSNNgxFl+uHhgZOhVHNlDm/UtdeHqLS9OZ7bPADngwr2A8vFIDsePjQEk06sQ7+B8yAoirYSEhERkT9RHToA3bw5kjVzGzhvwBAbEIc+Nfu7MBnJQYyKgqXzw9CuXplvjfLKZWg2/AVLx04yJvN9YbpwjGvxPl7b8Ipk3c6E7Vh2cjGert5bpmRERHlp/lor2YABAMyPdPe5Bgx0b8ZXXoV+3mworl/Pt0ZxPRn6mV8g+81RMiYj8rzPPvsoTwMGABg9erxPNmAgInK1e63Xcav5gqvW8hDA5oZEhWU3VHJao8z6l00YSjLRDoX5qmSJQ1faPZdWhyG14S8IOdgbmpsbnNYLog1Bh1+AYMuAqTQ/iyAiIiIiIs+yGa24djAJSbsTkLjnKhJ3J8B4PdtjeTRBGsQ1L4X4FqUR36I0IutGQ6nmYitERERERL6ETRgkCIKAJ554At988w0AYOvWrbh+/ToiIyM9nIyISqKFC9UYNUoLs9k7JhsdPKjEgw8aMHGiGc8+a8WtBW2yUpOx+ucx+DZxBQ6FmoDw4l+r2c0AvFrtRXR8aSwUSn7r8XY1WzyOP8rVxaA5HbAxPLVAx1iVwEj7SuyYXAsfDfoLgRGl3BuSiIioJHM4EPjWCAiOezfDAgCzEph0vwJA/jUA8FrD4dCpdC4OSHIwPttPsgkDAOgWzGMTBjd4qnovLDw+D7sTd0rWTdg+Fp3Ld0GoLkymZEREt+kWz3daY3qWDYP9hRgUjOxhbyLwnbck6/RffQ7jcwMgRkXJlIzIs37/fTVWrvw5z7Zevfqibdt2HkpERFSy3Gq4UNh9BeWqRg5E/sahKw1RoYXgMOdbo8w+I2MicjWFORGCKL0ggt1NTRgAAKpApNVfhuDDz0ObvNppuQARQcdfg2BNhbH864ALvkcQERERERE5I4oiMi9n/L/ZwlUk7knAjSPJcNik51K5kzZMh/jmpRDfsgziW5ZGRM1IKJRcuI6IiIiI/IDdBFzfDtzcC6SfBKxpgCUNEK3FOKkAdPjbZRHdRRD5ybekjIwMdOnSBdf/v8JUly5d8PHHH3s4FZFrJCdneDqCV9No8naitFikPwTPj9EIjBqlxeLFGlfEcounnrJiUK8VWLZ5AhZrjiJd65rzdr4ZiSHNRqJJhxchKHiTqaSxWUyY/NmD+DzgQKGOq5qmxuwOc1CtaXf3BHMxV411IvJeHOfkbbRLFiL4tVcka75qAgx+WPo8cQHx2Nn7AJsw/F+JG+sOB8Kb1IXy0sV8S0SlEjcOnIAYEyNjMP9w5PphdFzeGg5R+sP552q9gGltP5EpFRVEiRvrREWgSEpEeP0aEOz5//22VaiIlB37ffLBB47zfJjNCL+vMZQXL0iWZQ8chKxJ02QKRVR0xR3rp0+fwqBB/WE23344sUGDRvj006+gVPruKlNRUUGejkBEPuI9xXuyXEcQBIyzj5PlWuRanEsgzd0/t4RtawZV1vF89xtLPY/Mmp+69JokH1XqToTtfkCy5maLnbAH1nBvEIcNQcdegS5haYEPyS7zErKqTQEE333PfSfeoyDyfRznRP6BY53I+4miiMyrmUg+mHT761ASjNeNHs2ljzIgvmVpxDcvjfiWpRFeLQKCwvc+nyUqKfg9ncj3cZwXDecRkFtlXQSOTQHOLwFs6a47ryjmzH18xvvHOZcjdyIoKAiffPIJnn/+eVitVqxZswYxMTEYOXKkp6MRUQlw6ZKA557T4/Dhon0AbTCIaNXKjvvus6FOHQcqVnQgMlKERgPYbMCNGwLOn1fgyBEFtm1TYvNmFdLSCn9zZ9kyNZZtjwWeSgSK2YBB6QB6ppfDKx0nlpiH8OneVBodxr65GXUXDsOrN2bDpC7YcadCrHhwex98dKwPnuj7ORtwEBER3UFITUHg+9ITz00q4IMOGgAWybrXGo1gA4aSTKGA6ZlnETDtg3xLBLsdumWLYBw6XMZg/qF2ZB0MrDMIsw59JVk37+gc9KrRB/WjG8qUjIgI0C5bItmAAQBMvfr4ZAMGkqDVIuvtMQh+ZaBkmf772TAOfBmO8hVkCkYkv8zMTIwZMzJPA4bIyCi8994HPt2AgYjIlbrP5Wd4RN7Mbqgk2YRBaTwjYxpyNaXpstMah66U+4MoVMio9TVEZSD0l78r0CGGS7OgNCcgvfa3gFLv5oBEREREROSLRFFEVsLthgvXDiYh+eA1GK9nezoaAuIDEd+iNEq1LI24FqURWikMAj+TJSIiIiJ/dWY2sG84YMvMaZrwX37yXlkQxXv97um/tm/fjqFDhyIjIwOCIKBx48YYMWIE6tev7+loREXG1SukFbeD1rFjCjz9tB6JiYV/AL1pUxuee86Kzp1tCAws+HFmM/D33yp8/70aGzcWoc9O2Bmg18NA1MlCH6q3As+ZamNg949QunrLwl+bvNrRbcvQb8sgXAwq3DjomVIGUwatRWCEDJNEiojd8oh8H8c5eZPAUW9AP/sbyZrPmyswtLNDsiY+oBR2PnsAWmUxO2j5kJI41hVXryC8YS0Ijvz/f9vLV8DNHfsBNrZyuQxLOlouboyk7ETJugbRDbGmx99QKvhAnzcoiWOdqFBEEWEtG0F15t/8SxQK3DxwHI7YOBmDyYfjXILDgbAOraE6eliyzPR4T2TMLNgDNESeUtSxLooiRo0aga1bN+fZ/vzzL6JOnXouyRYZGYUKFSq65FyuxhUsiIhILpxLIM3dP7cEnBoLw4XP8t1v15bCzTb5N2kg76Y/PwOBp8fku9+hCsGNdpfkCySKCPh3AgznPy7wIdbQFkirvwSiOtyNwTyP9yiIfB/HOZF/4Fgn8qysxExcO3Bnw4UkGJM933ABAILLhSC+RWnEtyyN+BalEVQ2mE0XiLwYv6cT+T6O86LhPAJyi9OzgD2v3G6+cK/3ycVtTSAIwDPeP87ZhMGJX375JffXly9fxjfffAOLxZL7w1WFChXQuHFjlCtXDsHBwVCrC7hM+D08+uijxUxLVDicOCGtOG/eduxQ4tln9UhPL9yNmNatbXj7bTOaNJF+6K4gjh5VYPJkLdauLWQzBsM1oF8HIOZIgcrjsxQYqG2LZ574COHxVYqQlEqKlIR/MXT2A/gz/EahjquQocKs5p+iftu+bkpWPPxBjcj3cZyTt1AePoSwB9pIPnBvUgEVRwUgQZklea6pbaajf+0Bro5YopXUsR7c+0lo1/0pWZO68ndYW9wnUyL/8vPp5Ri07gWndR+2/RT9aj0vQyJypqSOdaKCUu/YhtBunSVrzA92RvrCH2RKJD+Oc2mav9ci5JknJGtEQUDKX1tgr1NXplREhVfUsZ6YmIAnnujqjki5HnroEbzzzni3XqOoOHmCiIjkwrkE0tz9c4vu8jwEHX9Vsia5fSKgNLj0uiSPgBMjYbj0db77bYG1kNJiu4yJcujPfYLAf98tcL0toBrSGvwEh76sG1N5Fu9REPk+jnMi/8CxTiSfrKRMJB+8hmsHEpF86BqSDyQh+5r0HCg5hVYOy2m60KI04lqURlAp3nMnKkn4PZ3I93GcFw3nEZDLpZ0A1tQB8J9nHm61IlAFAAHlAU0IIBT9eXoAQMcNxTteBkVYJt2/vP3223d1sxMEAbd6V5w9exbnzp1zybXYhIHIN/z5pxIDBuhhNhe8AUOpUg5MnWrCAw/Y79kYqChq1XJgwfwsfPvZH5g6sxkyUssX7MDsaOD7DTmNGGIP5VvWOMWAl8s/i84vTIBay8kd/iAsrjLmjTqNr77sgYmKjXAUcDHmc0E2dDk0BGMP/YKXXvkBCiXffhARkR9yOBD09gjJBgwA8PX9wUhQpkvWlAosjV41+rgyHXmQqXc/p00YtEsXsQmDmzxW+QksPDYPW69slqybtGM8HqnYHRH6CJmSEZG/0i2a77TG1Ms7mxySPCztH4ClZStotm3Nt0YQRQROGo+0pT/LmIxIHuwtT0RERP7AbqjktEaZfQ72oFoypCFXU5qvSO6360rJlCQvY4VhEFVBCDwxAgKcv+9WZZ1E2M77kV5vIaxhLWVISERERERE3iQ7KQvXDiUh+eDtr6xE72m4AADhNSJymi60LIP4ZqVgiAnwdCQiIiIiIu936B1AtCP3IVdRBJR6oNqrQPlngZBacNkDsCUAn4IsoP9O6rqzMYMrJnz9t9EDEZVM69cr8fzzelitBR/Tzz9vwZgxZgQGui7H5RPb8MvaKViUvRVngm3AYB2wfiKwfUTBTmCMBOatB/p2BOIO5G5WOoBH00phYMuRaNC2HwRFAZ/CJ5+hUKowZOgqNPp9BgYeHYtrhoJ9D7QpgXfxFzZNroQZz/6K6PJciZGIiPyL9oclUO/eKVljVAFT2gh3NY38r9cbvQGtUuvCdORJlgc6wR4dA+W1pHxrtKt+QeYHHwIB/DDY1QRBwJTWH6PdDy1hdVjzrUs1p2La7kmY2ma6jOmIyN8I6WnQrlohWeOIioblgU4yJSKvJAjIGvseNA91kCzTrP8L6q2bYW3VRqZgRERERETkKgVrwvAvmzCUUApzouR+h9YzTRgAwFRmAERVMIKODoIg2pzWK6zXEbK3KzKrfwxT6efcH5CIiIiIiDwit+HCgSQkH/LOhgvqQDXiGscjrmk8ohrGIrphHHShOk/HIiIiIiIqWWzZwJXf8jZgCKwAtF8HBFb0bDYPYROGApJqklDcBgpctYfIN2zZosRzzxW8AUNoqIivvjKiY0e7S65//dJxrPl9Cn66tg7bwzNz/oUP/v9OtQno9AZQ8S/g54WAsQCrtxojgPnrgBdaIizwX/QXG6Ff96mIq9zEJXmpZGvx0FD8Xb0NXl70CLaGS6/Wfaf14Slo92NrfFVlFNp2f9uNCYmIiLyHkJaKwAnjnNZ99URFJDnOStaUCSqLZ6o/66po5A3Uaph7PgPDF5/mW6LIyoT2t1Uw93xGvlx+pGp4Nbxc71XM2C/dYGHe0TnoV+sF1Izg5HYicg/tip8gGI2SNaaezwBqtUyJyFvZGjWB+eFu0P62SrIu4P1xSP1jg191HiffFxcXj61b93g6BhEREZFbObSxEJUBEOz5P9CizD4jYyJyJYUlWXK/QxstU5J7M8f1hEMTieCDz0Jhz3RaL4hWBB0fClXmYWRWnQIoeN+CiIiIiKgky0rKRPLBa0g+6L0NFwAguHwIYhvHI7ZxHMrcVwYRNSOhUOYsLmixuGZuPhERERGR30neCjgsOfPNRBFQqIA2K/22AQPAJgwFwiYJ3uPixYs4dOgQEhMTYbVaERwcjIoVK6Jhw4bQaj23Eqwoijh69CiOHz+OmzdvAgAiIiJQvXp11KpVq9iNOsj77dypRJ8+ephMBft/XbeuHbNnG1GuXPH+fclKScDaX6fgp4ur8HfoDdgVAMIlDqjyBzCgGbB4NXCjuvMLGCMRsXgrfl9tRPnKUicmfxRToT5+GPkvPpzxED4x7C3wcckGEU9e+QCvTPsVb738K/RB/LtFRES+zTB1EhTXpSdVZuuU+LBuGmCRPtfrjd6ARqlxYTryBqanekk2YQAA3bLFbMLgRsMav4mfTy/H5cxL+dY4RAfGbn0bP3ZbxZ/zicgtdIvnO60x9eojQxIqCbJGj4Pm99UQHI58a9T790GzeiUsXR+VLxgRERERERWfIMBmqAR1xqF8S9iEoeRy2oRB49kmDABgjWiPtMa/I3j/E1Bakgp0jP7St1ClH0R6nTlw6Mu6OSEREREREbnCfxsuXDuQhOwk72u4oDKoEF0/FjGN4xDbOB4xjeJgiDLk7tdolB5MR0RERETkQ7LvmEctCED8w0Bobc/l8QJswuDE33//7ekIBOCvv/7CV199haNHj95zv8FgQI8ePTB48GCEh8v3MK/VasX8+fMxb948JCXd+0PH2NhY9OvXD3369IGaq9T5pH//FdCnjx7Z2QV7CKdzZytmzTJBry/a9TJTkrBl7WdY9e8K/BZ4BSY1pBsv/FfEGWBAC+CH5cC5jk7Lb9yMxsCX7VixIhuBgUXLTL5LpdFh1Bsb0GzFRAw++yFu6AveWOSrwMPY8EVVfNnmC9S+72k3piQiIvIc5fFj0M/9zmnd56+0QJJlq2RN2aByeLpab1dFIy9ir1Yd1oaNoN6Xf2MrzZZNUFy6CEcZTl51hwB1AN5vNQX9/5AeY1uubMLv535Dl4qPyJSMiPyF8thRqPfvk6yxNm0Oe5WqMiUib2evUhWm3n2hX/C9ZF3ABxNg6fwwwHvTREREREQlip1NGHyTPQuCXfqBJm9owgAAtuB6SG36F0L29YAq+3SBjlGn7ULYjlbIqPUVLNG8h0pERERE5E0sGWYkH0xC0r5EXNufiKT9ici6munpWHdRapWIqBWFqLoxiKoXjeh6sQirFg6lmo0WiIiIiIjcznw957+imNOEIaadZ/N4AUEUxeItw07kRhaLBaNHj8avv/5aoPrw8HDMmDEDTZo0cXMyICEhAa+88gqOHTtWoPpatWph5syZiImJcXOygktOzvB0BK/2366YFov9rpobNwQ89JAB588rCnTOZ5+1YNo0M1SFbIGTnnwBf/8+Hb9dXIO1QUk5jReKy6YGflwKnOhRoPL27W1YtMgIJe9hUT6Szu7Hq4u7YWN4WqGOU9mBt+ytMfiVn6DS/I+9+w5zovr6AP6dmfRke4Wls/TeFxGlg6IoIFWxoaBg7wULYnntgCKICFJ+gDRFBCsgSu+997Lssr2kZ2bePyZbAuxkSzLJ7p7P88wzmcnJ5Gy5yWRy77k6P2VXstK0dUJI5UbtnASMKCJs2L3Q/LtRNiyvZiwaPiMizSY/+9WXPb7G/c0f9GWGVUplb+u6eXMQ8uoLsjHmV9+E5cVXFcqo+hFFEfetuQf/Xf5HNq5uaD1sHrULWk6rTGLEQ2Vv64SUxDjpVRhmz5SNyZ0+E/aRVb8gE7Xz0mOvJiOyS1swNptsXN6nU2F76FGFsiKkdKitl09MTEigUyCEBDHewYOrRLP+VbZ8qxvqSyBPiXMZw+n3YDz3WYn3C5pYZNx+2ufPS/yLtZ5H1ObWsjHZHX+HM+IWhTLyjnFkIGz/SKhzdpTpcdba45DfaArAlXOGkiBAn1sIqfqonRNSPVBbJ9UR7+CRcSwd14oVXMg6mQEE2cghVsMhqnk0YtvEIaZNHGLbxCGiaVSZCy5QOyekeqC2TkjVR+28fKgfAfGpY58B+16RbjMM0G0pUGdYYHMKMCrCQIKWIAh46qmnsH79eo/9HMehRo0aCAkJweXLl5GX5/nlv16vx7x589CuXTu/5ZaRkYGRI0fi4sWLHvt1Oh1q164NQRBw+fJl2O12j/vr1auHJUuWIDIy0m+5lQV1nJDn7eTNbgeGDdNj+/bSVVR45hk73nzTAYYp3fNnXD6Bv/74HGuu/omNYZlw+aEPks6mQszK1bh06s5SxT/zjB2TJjl8nwipMninA7NmDsP77EbwpatNUqhTlgFf3bUQDdr09U9yJaAPaoRUfdTOSaBofl+HsAdHeo374LNhmJS/XDambmg9bB21B2qOZjAuSWVv60xWJqJaNQbjKPl8m69XH5k79qPUHypImR3NOIJey7pBEAXZuElJk/FM++cVyooUV9nbOiE3ZbcjqnVjsFlZJYYIphBkHDoJGI0KJhYY1M7Lxvj+uzBM/0I2ho+Nk84hqsH/D6k8qK2XD3WeIITImVZ/Gnp92AutRrUKdCqyci7lYMObGxDVOAq3Tbot0OmQElBfAnlKnMtok/+H0CNPysak97wMURXq8+cm/qPK3omIXX1kYzJv2QPe2EihjEqJtyLk6FPQpch/l3E9lyEReS1mwhXexU+J+Rd9biGk6qN2Tkj1QG2dVHWiKCL3XDZS96UgdW8Kru1NQfrha+DtwfW/zqpZRDWPQUzrWMS2lYouRDaN9kmRTmrnhFQP1NYJqfqonZcP9SMgPnVuEbDNPWkkwwBJPwD1xwQ0pUAr41zshChnzpw5NxRgGDlyJCZMmIC4uDgAUqGG9evX48MPP0RycjIAwGq14rnnnsOvv/6KkBD/vIm89tprHgUYtFotXnzxRQwfPhx6vVTB3WKxYNmyZfjiiy8KizGcP38eb7zxBmbNmuWXvIhyRBF48UVdqQswTJzo8FqAQRQEnNj1C9bvmIc/c3dhR3g+BBaAH2p2JGWaMLrGXRg4/C3on6mNJ590YvVq7wP6pk/Xok0bAXff7fJ9UqRK4NQaTHxmNbpunIfxO1/AhZDSf+jZFWFBz3+G4r0d92LM2LlgOTpNIYQQUonZ7TC9/brXsKzuXTHVtdFr3AsdXqECDFWcGBEJ+4CB0P3yU4kx3PlzUO3YDldSVwUzq16aR7XAQy0exbzDc2TjvtzzKUY0GYU4Y7xCmRFCqjLt72tlCzAAgH3wUBpAT27K8vRz0C2YCzY7u8QY7loqDN/NhOW5l5RLjBBCCCGKy76QjZ8e+AnbPt+G29++HU0GNQl0Sh7ykvOw9bOt2D1rN3g7j9vfuT3QKRES1HhDotcYznIWrtC2/k+G+AzrSPMaI2hiFcikjDg98lrOgcvUEsbT74Ip5fS5KstphO/qB2udJ2BpOAmiijoDE0IIIYSQyotxZkOVfxRc/mGo8o+DtV+VFsc1MLwVgACIAsBqIKijpEUbB97QELyxMXhjE7hMzQFWU6E8bNk2pO65itRdyUjdl4Jr+1Jgz7Z7f6CCWDWLqGbRiGkTV7hENY0Cp6V+wYQQQgghhAS1iHbSumAQrOVK4HIJEowoiqX7VoQQBWVlZaF3794wm82F+1588UWMGzfupvGpqakYNWoUrlwpatQTJ07EM8884/PcNm/ejLFjxxZuq9VqzJs3D506dbpp/M6dO/Hoo4/C6XQW7ps/fz6SkpJ8nltZ0ewV8uQqaH35pQYffaQt1XHGjnXgww/tNy3AYMlNx/b1s/DXidX4gz2Nyyb/VemKN7MYxbTDsN6vIrHdAI/7HA5g9Gg9/v3X+8Uto1HE779b0KSJ/MywhOSmXcCrswdgZUTZT7h6Z0bgy1GrEN+wgx8y80TV8gip+qidk0DQfzUVpilvy8aILIv3fngS756dIRtXL7Q+to7eAxVLX0TKqQptXfP3HwgbPUw2xnr/g8j/8muFMqqeMm0ZSPpfO2Tbs2XjRja9H9N7zVQmKVKoKrR1Qq4XNvxeaP7ZIBuT9dt6uDrc/PpjVUPtvOz033wF07tvysYIIaHI3HkAYlSUQlkRIo/aevnQDBaEEDmT2clgGAaiKIJhGMQ0j0G317qhxfAW4NQVn1GwvNKOpmHbl9twaNEh8A6+ML/b37kdt79NhRiCFfUlkKfEuQzjSEf0pgayMbmt5sEeP9Tnz038R3d5HkKOPVvi/SKjQXrvNMjO8BFgmrTfEHLoMbB82V4neE08zI2nwB4/PKh/vuKq5OcWUQRrTwZruwzWfhUMbwEj2MEINoiMGiKnh8gZAVYPQR0OQRMLQRsLcFQclFRNVbKdE0JuQG2dlBfjSIMm8z+os/6DOmszVOYTFT6myGrhCm0PZ3gXOMO6wBnRFaK65Nn6RFFE9pkspOxKdi9XkXUio8J5+BKrYhHZNAoxbeMQ0zoOsW3jENUsWtGCC9TOCakeqK0TUvVROy8f6kdAfG51A8ByQbod1wfo9Udg8wkwKsJAgtKnn36KOXOKZp3s1KkTFi5cCEbmS7ht27bh4YcfLtw2Go1Yv349IiIifJrbsGHDcPDgwcLtCRMm4NlnS/6CFACmTp2KmTOLBma0a9cOS5cu9Wle5UEdJ+SVdPK2erUKjz+uL9UxRo50YupUG1hW2hYFAaf2rMXm3YuxMWM7NoVkwObHCY11TmBgfgKGNb8ftw18CSqNrsTYvDzgnnsMOHzYeyeshg0F/PWXGSaTL7MlVZEoCFgxfyJezvkfLGUs3htqB94PHYkRj8wCU9CI/IA+qBFS9VE7J0pjUlMR2bU92Hz58+20hx9Es6ZrkWGT/3J0eq+ZGNn0fl+mWCVVibbuciGybTNw11JLDBFMIcg4dJJmQ/ezOQdn4Y3Nr3iN+2PoRrSL83/hMFKkSrR1QophL11EZMdWYGQu07uaNkPWpu2VZoBCRVE7LwebDZFd24O7clk2zDJ+IsxTPlIoKULkUVsvH+o8QQiR83HEx7Dl2AoLMQAAwzDQR+nR9uG2aPdoO0Q3jVYkF6fFiaMrj2Lv7L24tPUSABQWXyjIbcC0AejydBdF8iFlR30J5ClyLiOKiPqnDlhXTokh5oZvwtLgVd8/N/Ebw9lPYDzzfon387payOx+VMGMyofLP47Qgw9AZT5Z5sc6w5OQ3+g9uMIDP3mNN1Xic4sogjMfh/baGqizt0KVsxesK7vsh+GMEDQxELQ1wOtqQdDVBq+rDUFXC7xeWouqUN/nT4ifVYl2Tgjxito6AN4K1pkBxpkJ1pEJRnQAogBABEQeYDUQORNEziC976sjpMIAjP/6bQYlVz40Wf9BnbEBmsxNUJmP+/0pRbBwhXWEI6o3HNF9YFW1wrUDaUjZdbWw8II9y+b3PEqrsOBCm7jCJapZNFS6wE4sQ+2ckCKMIwOc7TIYRxpYZzpYZxYgOMAIDkB0QmR1gLsAn8gZIKijIehqQtDWgKgK7u+hqK0TUvVROy8f6kdAfO74l8DeF6XbrBq46xhgki8cXpVREQYSdARBQLdu3ZCZmVm4b/78+UhK8v7l2/3334/du3cXbr/zzjsYPXq0z3I7ceIEBg0aVLhtMBjw33//weRlJHp+fj66d+8Oi8VSuG/dunVo2LChz3IrD+o4Ie9mJ2979rAYPNgAm817p/fu3V1YssSKrMv7sPm/7/HvlU3YqL6EFKPgr5QBAJwA9M6OwtA6g9Dv7tdgjKhR6sempDAYONCAS5e8XzgdPdqBqVPtFUmVVCNnD/yFp34dg90RFu/B1+mRGY7PhvwPdZp390Nm9EGNkOqA2jlRmum5idAvXigbI4SFY/K88Xjv4MeycfXDGmDLqN1QsYH9srIyqCpt3Tj5LRhmTJONyZ0xG/ZhIxXKqHpy8k70WtYNJ7LkO1V0jOuMtUP+ki0aSXyrqrR1QgoYPv0Ixk/lB8Xnv/chrE88pVBGgUftvHy0S/+H0GeelI0RNRpkbtsLoXYdhbIipGTU1suHOk8QQuRY0i346+W/cGDBgcJ9xYsxAEBM8xg0u68ZGt/VGDXa1/Dp59n8lHyc/fssjq08hjN/noHL5irMoeB5RFFEWJ0w9P+yP5oNbuaz5ya+R30J5Cl1LhO+owfUuXtLvN9WYyTyWs72y3MT/zAdfwn6SyX/zZyh7ZDdZZOCGVUAb0bI8ZegS/5fuR5uj+4PS8NJcIW28XFivlOpP7fwNuiSF0F/6VufzNhcGoIq3F2UoQ54QyPwxsZwGRuDNyRC1EQpkgMhZVWp2zkhpNSqVVsXnFDlHYIqZydUeYfAWc5Ii6PkiSBKIjIcBE0sBE0cBG08eH09CIZ64PX1wevrgdfXBTiDH34IBYkCVHkHpKILGeuhzt4BRnQGNCVLvh5nDjbE6QONcPpAIix5gZugo7DgQts4xLQOnoILN1Ot2jkhbowjHarcfVDn7gNnPg7Ochac5Wy5Cu8VEFShEHR1pM9yxkbgDY3hMjUBb0gMitd8auuEVH3Uzssn2PsRXLx4EQcPHkRKSgqcTidCQ0PRoEEDtG/fHlqtVvF88vPzcfbsWVy5cgVpaWmwWq0AgJCQEMTExKB58+ZISEhQPK+gwjuA39oAee5CzDXuBHqsCWxOAURFGEjQ2b17N+6/v2iW19q1a+Ovv0o3oOGnn37Ca6+9Vrh966234vvvv/dZbt988w2mTSsaDDNkyBB89FHpZg57/fXXsWrVqsLtF154AePHj/dZbuVBHSfkXX/yduaMgP79DUhP916goEZsKgYMG4ztmj04FubwV4oeumaaMDS2L+684zVE1y5/p6XDh1kMHGiA1eq9zX3/vRV33+0q93OR6sXlsGHGN0Pxf6r/wJexQLLBAbyjuwsPjv0BnFrj07zogxohVR+1c6Ik1YF9CO/XQ3Y2awBImTIZLdXTkWHLkI37qtcsjGjqu8JyVVlVaevc8WOIvE1+FkhH9x7IWfmLQhlVX/9c2oDha+71Gjen33wMShzs/4QIgKrT1gkBAAgCIju1BnfpYokholqNjIMnIUZVn47q1M7LiecR0fMWqI4fkw2zDR+FvK+/VSgpQkpGbb18gr3zBCEkOFzadgl/vfQXLm275FH8oEDBPm2oFnVurYMaHWsgrnUcYlvGIrxuOLjrXqNvJj81HxknMpB6KBWpB1Jx8b+LyDhZdJ3r+uIPoihCY9Kg6wtd0e3VblDr1T77eYl/UF8CeUqdy4QcGgtdyvIS73eGdUJ25/V+eW7iHyEHH4Iu9acS77dH90NuuxUKZlRx2qtLYTr2Alg+v1yPd0T2hKXes3BG9gSCrNhtZfzcwrjyoLs8F4YLX4F1XAt0OoUEdZRUlCGkJVym1nCFtILL1BzgdIFOjVRzlbGdE0LKrqq3ddZ6Htq036BJ+00qIiBYFXtuXhMP3tAAgqE+eH0D8Ab3oq8PUR2uWB6lJjihyjsIdfZ2qLN3QJ31H1infL+dQBIF4MrZBJw+0Ain9jdC8rkagFjGzrelxKpYRDaLRkyb2KAvuHAzVb2dE8I4MqSCC3n7ocrdB1XufnC2S4o9vwgGgr4uXMZm4E3N4TI1hcvUDLyhsaKf66pUWxcFsPZkcJbzYK3nwdkugnVmgHFkgHVmgnFmgeEtYAQHINjBCDbpNgCRYQGGBcC6r6WwAMNBBAuwKoBRQ2Q1AKOByKqLtlk1REYDsBqIjFpasxr3/WopnjNAUEdAVIdDVIW7b0dIa1W4NBs6CSxRdP9PWMHwVkCwghEF999YC5HVQOSMAKv8wHZfqFLtXEHB2o/g77//xjfffIMjR47c9H6DwYAhQ4Zg4sSJiIyM9FseVqsVq1atwu7du3HgwAFcuXLF62MSEhIwZMgQPPDAAwgPDy/1c12+fBm9e/euQLbSJPJBIeco8OctgMv9nWHieKDj1+73oOqlWhZhOH36NBITEwOdRqm4XC5cuXIFdevWDXQqivn8888xe3ZR1fcRI0bgvffeK9VjU1NTcdtttxVuq9Vq7Ny5EwaDb6qujRgxAvv37y/c/uKLLzBw4MBSPXbNmjV46aWXCrfbtWuHpUuX+iSv8qKOE/KKn7wlJzMYNEiD06e9dzqCPh14LAmIOuPH7CSdsgy4O6wbBvZ+HrWb3eqz465YocKECXqvceHhIv75x4yaNavdWwmpgEObF2Pif8/geDkKlCRlmvDFwLlIbDfAZ/nQBzVCqj5q50Qxoojwu/tDvXO7bJirUWNMnjoC7++aIhvXIKwhNo/aBRVbOb7QDLSq1NbD+/eAel/JM9yJDIPMvUcgJNRSMKvqacy6Efjj/G+yMXVD62HzqF3QcpXzi4vKpiq1dULUG/5G+MghsjH2u+9F7vcLFMooOFA7Lz/NH78hbMwI2RiRYZC1YQv4Fi0VyoqQm6O2Xj7B2nmCEBKcTv56EhsmbUDqQWm2S7mCDMXpI/UwxZugNqqh1qvBcAxcNhdcVhesmVbkXc2D4BQ8HlPSMUVRhEqnQscnOqL7G91hiA78bGmkdKgvgTylzmUMZz6E8ez/lXi/oI5ERo/zfnlu4h9huwdCk/Vfifdbaz6A/BbfKJiRb3DmUwg5/BjUufvKfQxnSGtYaz8Be9y9gMrku+QqoDJ9bmEcGdBfmgX9xW8rNOupkkSGk2ZVDWkFV4i7MENIK4ia6ECnRqqRytTOCSHlVxXbOmO/Bt3VH6G7ugSq/MOBTuemBHVkYUEGad0AvL4eBG08BG08wHnvo1xuogDWcU2aFT7/CFR5R6DKPwxV3mEwgsV/z+tn5hwDTh9MxKn9jXDmUEPYzOW/zhKeGIHYdvGIax+P2HbxiGoeU2kKLngQ7GBcudCwDqkACW8BIwpw8BzA6qSBqKweojpSGphM/EtwgLVdAmdPlQaQO7PAOrPA8HmA6AIj8oDIA6IAkdNJg4Q5PUTWKA381kRB0MRA1MRAUEdX37+ZKx/qvANQ5eyFKncP1Ll7wVnPBzqrmxLBgjfUB29sBpepqXvdHLwx0S8DwCvrezrjyoMq9wBU+Qehyj0IVd4hcOYTYERlJnv1JZEzFhZkKCjWIKjCIaojIWiiIKqjIGiiIagj3bcjIarCAKYU47CIRHCAs54HZznjXs6CtV8Fa08B67gG1p5aqv8dQRXqfk2NhaCJA2+oB96QCN7QELyhIQRNXNAVRAUqbzsPtGDrR+BwOPDGG29gzZo1pYqPjIzE9OnT0alTJ7/kc+HCBfTr169cj42KisK7775b6sdXqSIMAJCxC/hnIGBPl14zoroAbT8GYrsHOjNFVcsiDC1atMDQoUPx9NNPIyYmJtDplGjdunWYOnUqBg0ahKeeeirQ6Sjmsccew3//FX3h+PHHH+Pee+8t9eN79erlUZFm+fLlaN26dYXzEkUR7dq1g9VaVCF048aNqFmzZqkef+XKFfTq1atw22AwYO/evTft2KIU6jghr+Dk7fx5BoMHa3HuXCkq9bAO4KHeQN3NfsmJEYFbs0Jxd3QP9O/zLGok+ucEAwAmTdJi9myN17ju3V1YvtwKtvoVMiIVYM3LxP/NvAszTWX/AkDjAl5HT4wbvwRqbcU769EHNUKqPmrnRCnan1YgdPyjXuMu/W8R2lx8Gln2LNm4Gb1nY1iTkb5Kr8qrSm1dN/c7hLz2omxM/qR3YX3mBYUyqr7OZp9G96Vd4BScsnFTun2E8W0mKpRV9VaV2johoY+OgfbX1bIx2UtXwtmrr0IZBQdq5xUgiggfNADqHdtkw+x9+yP3fyXPpkuIEqitl0+wdZ4ghFQOp347he1fbMfZ9WcB3FgkQU5pY28WZ4g2oNOETug0sROMMcZy5U4Ch/oSyFPqXEZ79UeEHn5cNia9x3lpMAmpFCK2dYUq/+azfgGApe6zMDeWL+ActAQX9Be+gvHsh2AEe/kPw5lgjxsCW8IYuMI6B7QzeGX43MKZT0J/6VvokheD4c2BTscneG0NuEJagTe1gsvYGLyxMXhjI4iq0ECnRqqgytDOCSEVV2XauuCEJv1P6JIXQZP+BxjRFeiMKkRQhUPQxklFGTQxEFVhEFVhEFSh0m1OX2xmbjXAqAAI7pmf7e6ZwW1gndlgnBlgnRlgHWlgrZfA2S6BEWyB/hH9ShAYXD5VC2cPN8DFE3Vx+XQtOO037/NtiDVKxRbcBRdi28ZBG6bczPUVIjjBWc+BM58EZz4JleUUWNsV90DUVLBO+b5XBUQw7gHCMRC0ceB1daTiIIYGENyFQuh8swwEB1T5R6DK3QdV7gFwltPgrOfB2q6AgeD98aV9moK/mSau2OtFvPt2DXdRlziIXEhQDiT2ShTB2q+Cyz8KVf4x6Xeatx9c/nGf/h4DQSq611AqymBsXDjomzc0gKiOLvffq9K8p/M2qHN2Qp25CZrMTVDl7pGKkFRjAhcCUR0G0f0+L6jCIKrDIKgiIOhqutu0tOZ1NQGuihd0FpzgrBekIgvWM54FF6wXFXkNEDgTeFMzuEytCgtjukJaAFxgv8+pNO08yARTPwJBEPDUU09h/fr1Hvs5jkONGjUQEhKCy5cvIy/P83sovV6PefPmoV27dj7PqaQiDKGhoYiJiYHJZILdbkdaWhoyMjJuiGNZFh988AGGDJGfbAkI8iIMZ8s5EZTlEnDkA4B3f8ZiGCCkERBzm7TWRkqf2cqrwYPlf6xCqmURhqZNm4JhGOh0OgwfPhyPPvoo4uLiAp1Wod9//x2zZ8/GsWPHAAATJ06sVkUYri+isGLFCrRq1arUjx83bhw2bdpUuF3WIg4luf5F0GAwYN++slVwb9u2bbmLOPgDdZyQp1JxmPDoRixf2wO8s5QnkoPHAG0W+TYPHuiRE4m7a/RFn77PI6ZOc58evyROJzB4sB47d3qvIvnRRzaMHSs/KImQm9my9ks8feQ9XDaV/cNRq2wdPu36Mdr3fKRCOdAHNUKqPmrnRBEWCyK7dQR35bJsmL1vf7z3Qhd8uOM92bjE8Eb4b+ROcCxVAC6tqtTWmaxMRLVqDMZRcsViV5OmyPp3R+X8ErGSmbz1LczYP002JkIbgZ0PHECYNlyZpKqxqtTWSfXGXLuGqLZNwbhK7iDHJ9RC5u5DAFe9zgeonVeMaucORNzlvXBH9s/r4LzlVgUyIuTmqK2XTzB1niCEVD7XjlzDvrn7cHjJYeSn5AOA7IQB13clKU0swzJo0LsBWj/YGs3vaw6VtprOVlcFUF8CeUqdy6hy9iBiZ0/ZmKzO6+EK89/kDcS3Ijc1BudIKfH+/EbvwVrvOeUS8gMu/wRCjj4Fdc6OCh+L19WBPfYuOGIHwRneRfFZE4P1cwvjyoMmbS10yUugydwY6HQUw2trgDc0Am9sBN7YGC5DIgRdLQi6BBowR8otWNs5uQneCsaVC0awFQ68ZtwDsVG4LvhuVbxuDTDFPt+IjApg1dKaURUb5C1tFwz4Lry/MJaT7i98nMr339WKYrGfx36Tn7Fgnw0QncX2OdxrJxjx+n0OQHBcN1su414AMAzEgm1WA5HVAqwWonuRbuuK9nF697bePYu5odi23j1wXhNU32NX9rbO5R+F7soi6FJ+BOtIC3Q6JEjxLhZXz9fA5TP1kY9WQGwHmJq3RVz7GjDWMAV00sjSYJzZUqEFyymo3AUXOPNJcNZzihUc4bU1wZuawxXSEi5Tc7hMLcAbGwOsVpHnD1qCE5z5ONS5+9xFF/ZClXekVLOwK0VkDYVFGnht/HXFGgq246Qilkq3BVc+WEcqOFuyVKjCek6a4d56AZz5FFhXtrL5BAFBFQpe38BdCCURrpCW4E0twBsaeP3cH7Tv6YILqrz97qIL/0Kdva3KFwPyN6lYU0GxlVgImoIlRlprYyGqoyGoQqWiAcH2Pic4pWJBtmSp2Ir9CljLOajcxRZY28WgLMwhggFvaCgVxwxp5S7Q0BqCNl6x33HQtvMgF0z9CGbPno3PP//cY9/IkSMxYcKEwvHbgiBg/fr1+PDDD5GcnFwYFx8fj19//RUhIb79eQqKMDRu3Bjdu3dHx44d0bp1a0RHR98Qe+nSJaxatQpz586FzVb0Wq5Wq7F69Wo0bNhQ9rmuH3986623YuzYsWXK95ZbbilTfKktZivelot/f+yr14VRwd/Oq/U33larFQsWLMDixYtxzz33YNSoUWjRokVAcsnPz8fq1auxcOFCXLhwAYDUUSHYP/D6ms1m83jxBIAaNWqU6Rjx8fEe2+fOnatwXjc7zvXPUxrx8fEexzl37lxAizAQebd134rDRwaW4QFTfFaAIcbCoL+jHvo0uBPd+0xASHRtnxy3LNRqYOZMG3r0MCIvT/616P33tejf34VatapdXR9SQd0GPo9/Og/BW9/dhSXhF8r02EPhNgw49iwe3T4Drz2yDOHxDfyUJSGEEOKdYcY0rwUYRJUKV996A99sucfr8V7s+CoVYKjGxIhIOPrdITs7uurEcagOHYCrdVvlEqumnu/wEpYcX4hMW2aJMVn2LEzd8zneuaWSzlJHCFGc7sfFsgUYAMA26oFqV4CBVJyrcxfYBwyE9ve1snHGKW8je9364OuMQAghhBC/iW0Ri/6f90e/T/vh/D/ncXLtSZz+7TTSj6ffEMswzE37Ktxsjg+NSYMGvRsg8c5ENLm7CUzxJr/kT0h1xBvkO/MBAGc+TUUYKgtRBOss+RojAGlASCXHm5ogu9Mf0F5dCtOpt8E6rpX7WJztIgwXv4Hh4jcQ1NFwRPWEI7InnJG3Q9Ar348mkFjrRWgyNkCT8Rc06X9Vy8EcnP0qOPtVIOvfG+4TVKEQtAkQdDXBa2tKsxyrIyFqoqS1OhKCOgqCJhKiKgxgbz5LtN+JojRomreCEazSIHLeJv09C29b3YOmpW0INtmBGSKjAtwDoEXOAJErGAhthKCOgKiOgMiZ6BoQCR6CHawjE4wrq2jtzALjzJRfB+nrngi2WPGGmxVq4NwDFARAFArXjMe2CIi8VFwhiAa0VoQIxqMoQ8FrFFide9tdrIHVFd4u3C58TdMDYAGGBcAUrkWGBSMKYBzpYB3XwDrS3Ot0MK48MHyetHa5C8sxXOEiqkwQ1REQuDAI6nDptjoSoiYagjoGgia6cBHV0VKRnwC9frLWi9CkrYPu6hKoc8s2YSBRhpWvicxr8Ug7q0FWsh5Wsw6iwEIUGWh0DhhCzDCGmREVn4HomukwhFi9H7QCOJWAWolXUCvxCoDNAKQBrK6rbeDKbw3e2FQaVGlIhKiJCcz/tuCQBp+bT4OznAJnOQ3OfBoqy6kKfW7wFc6eDM6eDE3G34X7REYF3tAILlNz8CEt4DK1gMvUDIKujvt1qYoReXDmk1Dl7i0qupB3KGjfhwswggWc9Rw46znIzcEsMhoI2jiIqnAIqhCIBQtXsDa5CxC5CzCxGndhJg6ACEZwAeCl923RBQiuovcdPr/w/Yd15UjvTfZrYASLQr+FyoN15YLN2w913n6P/SJrgMvUzF0IpSX4kJZwmVpAVIcHJE9ZogjOfAyazH+gzvwX6qzNYF25gc6qSmFd2VKREvMxr7EiWIiqUHebltaCKtTdtsPc7dvgbtsagFVBZNRFxdjAouC8nLnuvL3o/F10b4uF+xneDMaVC9aZIxWMc+WAceWAtaeCdVyTHlPJMBChspyGynIaSP2pcL+gjoYrRCrIULDmDYkAW62HJZObyMrKwqxZszz2vfjiixg3bpzHPpZl0bdvX7Ru3RqjRo0qnMw9JSUF8+bNwzPPPOPTvGJiYvDnn3+ibt26XmNr166NZ599Fv369cNDDz2EnJwcAIDT6cRXX32FqVOnlvm5/VZUobxu8n1vqRX/HFGR49zseEGsWr7atW/fHnv37i3sNOB0OrFy5UqsXLkSzZs3x7Bhw9CvXz9ERvr3iy1BELBjxw6sWbMGv/32G2w2W9EMEe7cdDodmjdXZtb7YJCVleXRcUOtViMqKqpMxyioilMgIyPDJ7ldf5zyFGGIi4vzKMLgq9zK6/oKUaTIgpkby1aAocWPQI93KvSc7bL1GGBoh76dHkDb2+4HywX+JbphQ+DLLx147DH5Kp5mM4NXX9Vj2TJ7ZXn/I0EkOqEBZr57FENWTMFzxz/BFZNQpsfPDTuJNYva4cMaj+C+h6aBYct2YVOlotdCQqo6aufE35jkZBi+nuo1zjH+Scyxrke2PVs2rklkUwxvPpyKMJRRVWvrrlGjZYswAIBh5Y+wdeygUEbVV7QmEq90eR2vbXpZNu67QzMxrt141A3zfqGWlF9Va+ukmhJF6BcvkA9hGPAPPVwtr99RO684x7uTofnzNzBCyddY1Ht2w/DHWrgGeS8QRog/UFsnhJDAYVgG9XvVR/1e9dH/8/4wp5mRvCsZybuTkXEyA9nns5F7ORf2XDucFidEXoRKr4LGqIEx1oiwumGIaBCBuNZxqNmpJmJbxIJh6QtCQvxBVIdDUEeDdd5YLKUAZzmtYEakQniz14GVQhUowgAAYFjYa46GI2YgDOc+gf7itxUeVMo606FLWQ5dynIAgEvfAK7wTnCGdoArrCNcIa2qzgy1ogDOcgaqnJ1Q5+yGOnOT1PndH0/FaNyDXjWA4ATDWyrlAGDWlSsNeCnF4AwAEBk1RM7oLlpgkAZbcYbCYgZgOGmgVeFg6qLb0mBpFxjwQMHAK9F9W+Sl4gmCFeBtYARLUWEFd+GFQMx0KTIqaaCxqmjAccHModI6DqImTppRVBsHkQupNB2gSYCIIiBY3YONssE4s8E6M8E4s8AWFk+QbnsUW3BkVrmBiNIgLQcgOsCUrctblcZABASL9Pd2BjgZUQBEKQmGNwP2VJT2yqTIaCBooiBoYiCqo9wFGmLcRRvcxRpUoYWFJVCsII7I6qX3jZsfGRAc7oI7VjC8WZol3XIeqvxDUGf+C5X5uE9+fOIbIqNGntASl881wpEN0Ti9PRQOq65MxwiJyEWtRpdQu9El1G58CTXrJ4Pl/Ds4k3VlQ5O5CZrMTR77pVnoG0LQ1Sg2y3gN6bygYLBqwWBWzuiemf66WXNFvlgRKbs0+NyjgE4mWHsyONsVsLbLYG1XwDpSK92AVEZ0QWU+BpX5GJC6snC/yBnhMjaVijOYmsPlXkRNbOU5j+Jt0s+WdwiqvIPSknuwyr1XF8eIDnC2SwAuBToVchOMYIE6dw/UuXs89vO62lIBlJCWYMJbgw9pCkFXC1CHKZecyIPLPwJ11jaos7dBk/UfWEeacs9PZDEQwLiyAVd2oFOpslhnOjSZG6HJ3Fi4T2R10vtfSCvwxiZS0SJjIgRdXSrOUI3NmTMHZrO5cLtTp054/PHHS4yPi4vDBx98gIcffrhw3w8//IAxY8YgIiLCZ3kZDIZSFWAorlmzZnjhhRfwzjtFY0U3bdoEu90OrbaSX4f21flqRY/jiyIOCqmWr2qLFy/GTz/9hM8//xzp6emFBQ9EUcSRI0dw9OhRTJkyBe3bt0fPnj3RuXNntGjR4qYzPZRVeno6duzYga1bt2LDhg3Izs4ufG5AKr4giiJEUUS/fv3wxhtvlGuwf2VlsXh+aNPpdGX+vRsMBtljltf1x9Hr9WU+xvWP8VVuxPfmrsgrfXCtbcC9DwNs2V78o60MetoT0DPhdvTs+QRqJLYvW5IKue8+Hn/+6cKyZfJvGX/9xWH5cg7Dhyv/ZSGpGvre9xa2pj2MyTMHYW7oyTI9Ns0g4vGcuVj07kp8fu9cJLYf4KcsCSGEkBvpPpwCxipfsV6IikbqsxMwY6X3apavdHmNCjAQuPr2gxAZBTaz5OJ96pXLYZvyIaCqlpd3FPVo68cw+8AsnM0+U2KMg3fg/a3v4rs75imYGSGkMuK2bAZ3Rr7jvKtPX4i1q9eMjsR3hKbN4Lx/DDQL58vG6aa8i/w7B9K5BCGEEFLNGWOMaHRnIzS6s1GgUyGE3ARvTASbLVeEoeTrVSS4sE7vE7UI6rJNVBPsRHUYzI0/gLX2EzCc/Ri65EXSYFUfUFnPQmU9C93VH6XnYtTSTJmmpnAZm7rXTSDo67oHjQUp3gKV+SQ483Go8o9DlXcAqpw90myPPiaowuGIuQOOyNvgCmkDQV9HmuH7hkBpNlfWkQ7WkQbGcc09i2sKONtlsLbLhWtGdPk8TyUworNaDdBgRBcYR1qpBwmJrA6CJg6CNkZaFy/YoImWBiKroyBqpDVYufmGq4iC4huCDRDs7oHTxW4LdmkgqmAHBCcAaYZUxmOmVNHzdvGO5jf0kWWK1gxz4z4v94kMU/p4kXcXDLFKhVh4CyAU3S6YzVkqtpAD1r2ujAVbCCkrRnSAs18FZ78a6FRIANjULZF8tRWObamJg2v1cJgr9l1KXlYoju1sgWM7WwAAtHob6rc4i8Q2p5HY+jTCopWbQV2ahX4fkLevTI8TwbrPrcVKex7oKwxvvulgcUEdCd6QCN5QH7zevRgagNfXh6iJBpiyTTLnk1ydmeAsZ8FZzhQuqvwj4MwnAlIgjChLBANRHS4VnmPUAKuSiqfwZun8rxIU3eBsl8DZLkGb/rvHflEVAl6bAEFXU/rcog6HqIqQ1u6fGawGIquDyGoBViutwQAQ3Ofjxc7bRd59DpwvnQM7M8CZT4Izn4Aq9wBYvgzjiwipBhjBBnXuXqhz93rsFxm19N5naATemAheVweCLgG8rjYEXQJEVXjlKVhEykQQBKxatcpj31NPPeV1XHDXrl3RsWNH7N69GwBgNpvx22+/YfTo0X7LtbTuuusuTJ48GYJ7EhyLxYLk5GTUr18/wJlVQCUqfBBMqm3PusGDB6Nv376YPXs2Fi5cCKvV6lGMged57N69u7ABm0wmNG3aFE2aNEHjxo1Rs2ZNxMXFITo6GgaDobCCicvlgs1mQ05ODlJSUpCamoqzZ8/i5MmTOHHiBC5evFiYg1jsn7Z48YU2bdrghRdeQJcuXRT8jQSH4tVuAJSrMsz1j/FXEYby5KbTeVa9pCIMwcvJl/JL34TtwP13AGqb11CdE+ieF4keUZ1we8dRaJ40GCxXOV6GP/3UgW3bWFy6JH/x57XXNOjVy4roaIUSI1VOWExtfPH2Pgz+9Us8s+9dnAsp24XaTZE56LpxKF74uyuee3IZ9CFVZKYQQgghQYs9chjq/y30Gmd76x18e24xsu1ZsnFNI5vh3kZDfJUeqcw0GjiHDIV2zuwSQ9hr16DauB6uvv0VTKx60nAavNPtPTy09n7ZuOUnlmFC+6fRLi44i+wRQoKDZoH3Yi2OBx9RIBNSldleexPq5T+CsZV83ZI7dRLq/y2E8yH6fyOEEEIIISRYuQyJUGdvL/F+lfmUgtmQimCdmV5jRHXV/H5b0NdGfouvYa33LPTnp0F3danPB+8yohPqvH1QXzeQTGTUxTp61wavqwVBX0ea7dc9g7WgiQY4QwlH9gFRBONMdw98Og1V/nGp6IL5BFjrBb/PBszr68NS7wXYao4E2FL0d2NVENkI8OoI8EaZIk0iD9aeCtY9IIa1XQZnOQ/OcloaqOJI8d0PQRTFCDZwtgvgbBdKFS+owiCqI6XZ4tVRENWREFUmiFwIRJUJAmdyz6Rtcu83AowaIqsGGDXAqNy3NdIaLAqKFTDFB0eJQuGaEV2Fs8hLa7vHbYgOaXCZaC/aJ9jds3UXFU/g4ACK7TO4bO6iCsWLLbgLLPioiAwhhCiF19aEK6wDXMYm4A0NIejqSOc+6kj3azELgAUYVnq9c5mLBp460sA6roFxXANnTwZrvQDOeh6c9YL0mloF8doayFd3w9nDidi9PATJ+51+fT67VYfju5vj+O7mAEREJ6Sh7YBUNGp/GtFhR8AywVfkgCl8PyYlYZ2ZYHN2Qp2z84b7REYNQRsnfRbRxEtrbRwEVThEVag0aFwVCkEVAjCaYudIaogMB0Z0AoKzaC1YwbhywbhywDoL1hlg7VfB2lOK1q6cAPwmiJJEhgNvbAZXSEt3EZAG4A0NwetqQVRFyM9ILzjc/y/J4GzJYK3nobKcAmc+Bc580i8FAn2FceVB5ToOmI8HOhVCSDGM6ITKfAIq8wngJrUgBc4kFU9Rx0B0X5cT1FGFRR85fbh0DUEVAlEbBzA0OK2y2Lt3LzIzi66B165du9Rjo++7777CMdwAsH79+qAowmAymRAZGYn09KJC2VlZWZW3CMM95wKdQaVVOUb/+onJZMILL7yAhx56CDNnzsTKlSs9ijEARYUS8vLyPIoy3ExBIYWSXH9f8aIPoiiiefPmmDhxInr37l2RH6tSczg8v2BTq8teJVmj0Xhs22Q6mZaF3e550SiYciO+17JBCo7s9xJU5z9g9EBAd/Oqdmoe6JQbgm6G5ri9xT3o2OMh6Ezhvk5VEWFhwNSpDgwdqpONy8xk8N57GkyfTpWuScV0v+t5bL71fnw04x7MMByEWIZid04O+JjbhqVT6+H9hhNx18gPwLDKV48lhBBSPejemQTGS1VIvmUrpA2/BzPmt/Z6vFeTXgfHBvGMTERRzhGjZIswAID6xyVUhEEhgxLvQZcaSdhxteRO7wDw1n9vYs3QdV4r+BJCqicmKxPq1T/LxgixsXANuEOZhEiVJSYkwDH+SWinfSkbp/vofTiHjQAMfhxsQgghhBBCCCk33iAzABoAZzkjDYIJwGyapGyYUhRhEDRVswhDAd7YCPktvoYlcRL0F7+F7vL3fh/QwYhO94DB87JxIquXOnurQiFyeoicEYzKCFFlADgjREYNjQCAYSEyHKRB4gwgutyDoBxSYQnB6R7EmOceBJUDxpkBls/36895My5TC1jqvwh77L3yg27Ki+GkTvO6mnDhxg7VjCtXGrhjOQVV/jGo8g6ByzsEzpHq+1xIQLGuHMCVA85KHbkJISSQBM4EZ1Qf2GMGwBl5GwRdrVI/VmQ1EFWhpQgUwNqvgrOeB2s5B8561l1oSrpdmQZ789oEOMO7IE9ogxPbE7D/RxsyjhQMrvJvAYYCEU2iUOvW2ki4tTZq3lILugg9ACDTlQd15iZo0v+EJv0vcPYriuRD/IsRneBsl8HZLgc6FVKJiWDBm5rCFdoOztB2cIW0hSukFcDpy3dAViMVKtTXwQ2lX0QRjCMNKvMJcPlHoTIfB5d/DCrzMbBO+YmoSNnxmngIugT3QPRIqcCdygSR1QGsFiKrldYMC0YsXqSOR1GxOh4Qeff1CQcYwQkU3C4oZFd47cIhFa8Til/TcIB15YJxZoFx5fi9aCSpnlg+H6z5JICTpYp3mZrDUv8l2OPv829ipMI2bdrksX3LLbeUug/tLbfc4rG9Y8cOWCwWGIKgL9P144lDQ0vxuSlYGesGOoNKq1oXYSgQFRWFSZMm4amnnsKSJUvwv//9r7BCyfWNvSxFFq53s2MxDIMePXrgkUceKXV1l6rs+iIFTmfZL2JcX8hBqy1FBe9SuP44wZRbeTkcfECfP5hNmXIvVv5zDK7MZjcPaDcHuPNpQF1USMPgAJLyI3BLSCskNRuIVl1HQB/i+QV5Zf6dd+/OY9gwDsuXyxcgWbiQwwMPiGjblqqdkopRG6Lw9subcef67/H8zldwIqxsr7sXQniMuTYdt787H1P6foWmXe4t1eMqczslhJQOtXPiK+p/NkD9919e4/Imf4gZ+2Yix54tG9c0shnuqDuI/kd9pEr8Hlu3h65BQ6jOnikxRL32V+RmZkM0hSiYWPX1VtIU3PVTX9mYzZf/xdpTa9GvHg2gVkKVaOukWtEvXgzGLj9DkG3E/XCILED/3wConVeEc+JzUP8wD2xOdokxbEoKuG9mwPrMC8olRshNUFsnhBBCCLk53pgoez8jWMDak8s0wIoEBuvI8BojqiIUyCTwBG08zI3egaX+C9CmrIQueQHUOSVPjKQERrCCs10KaA6+4gzrDEv9F+GIHgAEsFiwqAqVZt8O64DiV8MYeypUeYekJV9ac+ZT0szKhBBCCCkTESwc0X1gq/kAHDF3AKyf+6UzrDRAVJcARHS7LhkRjDPTXZjhnFScwVqsQIPjJlMhK4TX1YHL1AKukBbgTS2RZWuOk+vycernE0jbnwpAmUHxoXXCkNC9Nmp1r4Oa3WrBGGe6aZyoCoEj9i44Yu8CRBFc/lF3QYY/oc7ZLg2yJaQSEBmVNJhcFQawGoiMqrCIJMPbwPAWMLwZjGAFw5sDnG1wcukbwBXWHq7Q9nCGdXQXXDAq8+QMA1EbC6c2Fs7I7kX7RRGsI7WwIAOXfxyq/GPgzMfAunKVya0S4/X14Qpp7V5agtfXB6+vA3CBH2jsQRSkQgzObLCubDDOLLDObHeBhuzC20X3ZYJxpIN1ZkgFH4hPiKzW/T9SXyqEqYmDoI1zF+kwQmQNAKeXinMIdqm4hmCX/j6Oa2Ad18DaU6UCpZYz4OzJgf6RykyVfxShhx5FnjMHttpjA50OkXHs2DGP7fbt25f6sXFxcUhISMCVK1LxMafTidOnT6N1a++TH/rT2bNnkZdXNHG3wWBAvXr1ApcQCRgqwlBMeHg4nnzySYwbNw7//vsvfv75Z/zzzz+FFUsYhqnQLIbFizQ0bNgQgwYNwqBBg1CjRo0K515VGI2eHwiurxZTGtc/xldVb64/Tnlys9lsHtvBUJGH3Fx4TAx+/notRr1+EXkXis0qW2sb0ONdqOv/iRa5erRhE9E6qjVaN+2N5l2GQq2t2n/TKVNs2LiRQ3p6ybNoiCKD11/XYe1aC1iabIP4QMfeY/FXl6GYNWc0PmM3w1HGs5dNkTnosetBjN3YFC89tBgRNeQ7KhFCCCGlwvMwTX7La5i9b3+kd26Dbxc+4DX2pY6vgaXZykhxDAP7fSOg+uTDkkOsVmh+/QX2kfcrmFj11blGF9zV4B78ena1bNzkrW+hV52+UPljdjFCSOUlitAtmu81zHr/gwokQ6oDMTwClmdfhOk9+fNWw/QvYXvgIYiRUQplRgghhBBCCCkt3tDIawxnPk1FGCoBxpkpe7+gCgeq2fVEURUCW62HYav1MLj8Y9AlL4L26jJwjtRAp1bpiIwG9vghsNYeD1dYh0CnI0vUxsGpjYMzuk/RTt4CVf5Rd3GGg1DlHwFnPgXW6b14CSGEEFIduQyJsNUcA3uNkRB0QTIOgWEgaqLg0kTBFdbpxvtd+eDsKWAdqWDtKWDtV8HaU8E6UtwDPHPdgz1zwLhywQg2MOLNJ+4SGQ5gtBA5LUTOCEEdDVEjzRouaGIg6OuA19UDr68DQV8XoioE5tR8nPnlJE7/fBIpu9b5+ZchMcQZkXCrVHQhoVtthNYNK/tBGAZ8SAtYQ1rAWv95MM5sqDM3QpOxCersrVCZj/s+8SAlsnq4jI3AGxLds8XHSwNRNTFQ6UIgcnqAM0BkOLjsNkCwSQNSXblg7dfAOtKlgePWi2CtUqEQls/z/sREFq+Jgyu0PXhTM/D6uoWLqImFyJlKXxhOcEqDtx1pYD2Wa+7XjGKvHa5sv/5MgSAyHHhDI7hMzcGbWsAZ1h6u0HYQ1ZHeH6w0hoGgjYegjYczqmfRflEEa092F2c4Di7/KFTmUwEvxBNoLmNjOCNugyOyB5wR3SBqKsl38gwLUR0BUR1RtpKJoii9jzszwDrSwbhywBZ7f2ddOR7FHaS2nQzWy3WzqkxkVOD19cAbGhZbEsEbGkqFrxjOd0/Gm93Fsk5BlXfYXSDzMDibMgWpKsJ4ZgpsNe8HOF2gUyElOHv2rMd2w4YNy/T4xMTEwiIMBccLdBGGmTNnemzffffdUKnKdw3/6tWrSEtLg8PhQFhYGKKiohAZGYTv8+Smqtc3N6XEcRx69uyJnj17wmq1Ytu2bfj333+xa9cunDt3DoJQ9qrLYWFhaNOmDbp164bbb7+dqp6U4PqiBDabDaIolqn4hcVikT2mr3KzWq1lPsb1j6EiDMHt1jsH4WwvC/7++SvsOWRGQvxVNKqfgNgaE1Gj4VxoDaGBTlFxkZHABx/YMX68XjZuzx4Oy5apMHIkVbEjvqEzheO559bhnoN/4/VfxmJDZFaZHi+wwHehx7FiSQe8YboH9z88GyoNfQAjhBBSftrlS6E6ckg2RmRZmN+egm8PfINcR45sbLPIFrir4T2+TJFUEbb7RsAoU4QBAHTLl1IRBgVNSnoHv59fC5dQ8uedU9kn8ePxxbi/OQ2kJoQUUe3ZBdWxo7Ixjltvg9CgbF9CESLHOnYc9HNmgUu+UmIMm5sDw7QvYJ78gYKZEUIIIYSQYFaRCUqqg+t/Pf78fQnGBhDBys4Qr7Kchiu6Z4n3k+DAOeW/4xbVkdW67QkhzWFp8iEsjadAlb0TmmtroL22Bpz1fKBTC2rO8CTY4++DPW4IRG0MAKBS/hepjODDO4EP74Ti0yIxjgxwllPgzCeLLafAWc/RDNCEEAJABAOwWoisBmA0EFlt0Tarca+10n5G7fFIaSUW2xbcM+fabrK2g+Ht0u2yDcMjPiRwIXDED4Et4QG4wroUfjCpNO/96hAI6hAI8F5ozoPIA4ITjOiECBZgtaUuXsbbnLjw13mc/vlfJG+5DFGQ/ucN0f7pv68J06BG5wTU6FILNbsmILR+uO/P8TURcMYPgTN+CACAcaRDnb0N6qwtUGXvhCrvMBih7GMcgomgiYPL2Bj8dYugqwWUMLkNq/HcL6hL8VolimCc6eDMp8GZj0GVd1QaiJp3FKyrbH2UqwtBHQVXWAe4Qtu5l/ayhWDK9N/PaSByNSDqanh/p+FtxQq6FBRouFp02yHtZxzpYCB6O5qieG0NCPp67gHX9SEYGsBlagHe2Eh6fbtOpXmNB6RiPPpacOlrwRXT1/MuVy5Yy1lwlrPgLGekxXwCqryjYARLCQesnHhdLTgjb4czsgeckbdB0NX0uL9S/U3Lg2EATThETTh4Yxn6vvA2dztOBmu7Cs6eDNaeDMbuLsbiuAbWfg2MMyPo2nVpiKwBvK4mBEOD64otNISgq13iuY3P/19UJgihrSCEtio8lwCk6y+qvMPg8g9BlXsQqrxD4MzHwYjBMx6MdWZCk7MTzqjbA50KuQmbzYbk5GSPfWWdtD4+Pt5j+9y5cxXOq7zsdjs+++wz/PLLL4X7IiMj8eyzz5b5WJs3b8att96KtLQbCxIlJCSgS5cuGD58ONq1a1ehnIl/UREGL/R6PXr16oVevXoBAMxmM44ePYrz58/j8uXLSE1NRX5+PqxWKwRBgFarhcFgQGRkJBISElC7dm00adIEtWvXDvBPUjlERESAYRiI7gt7TqcTGRkZiI6OLvUxUlM9q6FHRfmmUtj1x0lJSSnzMfyVG/Eftc6AO0aOxR0jAYeDvrwDgHvvdeHHH13YsEH+LeS997S4804XQqtfrQriR/Vb98GSlufw65JX8MbVOUg1lO1LnSydiJddP+P7z9fhrUZPo8+QtwD4sDogIYSQ6sFqhfH/3vcaZrv/QWTUjcO3i77xGvtSp9fAlvBFIanehHr14eycBPXO7SXGqDf/Czb5CoSaCQpmVn01CE/EIy0ew3eHZsnGfbrrIwxtPBw6FRX/IoRIdIvme42xPfCQApmQakWvh+WVNxDy3ET5sLmzYX38CQi16LsMQgghhBACREebAp0CKWQCTPWA/LMlR4gXYKK/WfA7lyt7N2eIobZXIKYv0KgvIE4Dsg8BKX9Ly7VNAF+1BmeUmcoIxPUC4vsCtQZBbawLNYCq+59jAlAXQB/P3YILsKUA5kuApfhyBbCnS4sjA7BnAIIjEIlXHKsGWB2g0gNMSX20REBwAi4LwFuBSjgQhRAAAKsBtFGAJgrQRsqsIwDOIM18ymqlNact2mY11w3OLTZkqWAQtCgCoktqO4KzlLed7kHgLvd+97r47RL38VJODAuAdefBFu0r3M96/kzsdT+bx+2ifQyjAhhGucF8ovt1h7e6FwvgKuE2b3VvW4riXd5uF3+cFYDgLhRRsC72OqcyAbo4z0UbCahDAXUYoAqRfq+iq3AQP5w5gCMLsGdKa0cmYE8DbGmA/ZoUE2xURiC+D1B7KNjaQ6FTGUDfPpdN3IMR6PxgVR7QZAJq1gMwStoUXEDuCSBrH5C5F8jeD+SeBKwlF+sOCE4HhDQCQhoDoU3c66ZAaBOwmnBoFEskBEB9AMUGjIsiYE0Gsg9Kn0eyDwE5h4GcY4BgL+lAVY8mAojsKC1R0po11IaGYRT8+5TEBCAaQAv5MMEJ2FIB69WixZ4GOPMAZ660uIrfzne//zuKzgMEh/RewnDuRQWwxW6rTIA6RHrfUYcW3dbFuN+f4gF9vHRbnwBOpQcHQC2feRVkAlATwK2eu0VBuuaVdcDd5g4AWQcBc+AG3paZNlr6nB7XC4jvDc7UEBzD0Pt1mRW061byYYJL+sxvS3Wf2+W427DM2pEDCLZi7dp9jl/YxsUbz80ZFgAjv5/VAOpwQBMunX8WriMAQwKgTwD0NQFDAhh1GFRBXXy14PrLwKJdvB3IOQpk7ZeWbPfaKX+N05/CIiMBun4alLKysgrHAgOAWq0u85jZuLg4j+2MjAyf5FaSAwcOwGw2F27b7XZkZGTg8OHD+PPPPz2ePyYmBrNnzy7XOOCbFV8ocOXKFaxatQqrVq1CUlISPvroI9SsWbPEeEWZLxbdZjXS+YyvWFM8r9ka6/ju2H5CRRjKyGg0olOnTujUqVOgU6mSdDodatasiStXij7oJycnl6kIw9WrVz22GzRo4JPc6tev77FdniIM1z/GV7kRoiSGAT74wIbbbjPC6Sz5g0B6Ootp0zR4661K+mUmCVoMy+Lu+z/D7WlP45O5w/Gd6RjEMn4mPR7mwP3XPke3D2fjvR7/hw69HvZLroQQQqom/exvZGcSBgDRYITllTcw6+AM5DnkLzo2j2qJgQ3u9mWKpIqxDRspW4SBEUVoVyyD9ZnnFcyqenuh46tYemKxbPtONl/BvMNz8GTbpxTMjBASrJi8XOh+XikbI0REwH4nnRMQ37MNHwX9zK+gOnG8xBjGbofxkw+RN32mgpkRQgghhBBCSiWksWwRBuSeUC4XUn4OL51GtTSRyw0YBohoLS3NXgB4B5CxA0jfLq0zdkoD76sydRgQ1QWI7gLE9QaiuwJc4Ic8BRyrAgy1pAVdS44TRcBl9izK4MyT9vFmaV245EvrgsHXhQOueffiHlDNMNJgK0Yl5VE4EMt9m9VIg8RVBoDTF62567fdi6rgtq6o6AKrkwZ2lYUoSoMCeav0czhz3YOMiw80dm/brklFLGypUqdnV16F/hyEFGJU7mIKkWVbc/qiIgl+z5EBGLVU6ISUHcNI70OcBkBYYHIoKMbg60kuRNH92lmsKIMt7ebb9jTptdQfhX508UBEGyCiHRDfG4jpLhXhIKS0WBUQ3kJa6j9QtN+ZD+Sflgoy5J2SijJYkwFLsrS2pUjnPD7JQe1+jY92n7PVLlqMtaXiC4bavm/HvsIw0uBZQwJQ846i/YILyDstFWTIPuxeH5J+r2LZJpQLOro4IKKte2kHRHUCjPWVe3/2F1Zd7HMDCUoMC4QkSkudoUX7nbnuIigHixVoOCR9bgs0XZz0/hzTTSq8EN4yeF/PqiJWJQ0E9uVgYHJznBaIbCctBUQRMF/wLMyQewLIP+P/gmbqMCCsqX+fg5SbxeJZOFen04Ep43mEwWCQPaavvf322zh+vOR+VACg1WoxePBgPPvss4iMjPRrPtu3b8fgwYPx9ddfB8e49dX1is4Fw9sCd+zx3bH/uUN6bwcAMMAol++O7SdUhIEEnfr163sUYThz5gxat25d6sefOXPGY9tXhQ4SEhKg0+lgs9kASC/mV65cQUJC6WYavXLlCqxWa+G2wWBAjRo1fJIbIUpr2FDE+PEOfP21/MXd777T4NFHnUhIoErrxPdCY+ri/Vd3YNi/C/Hyfy9hf4TV+4OusyUyD70PTsTgTR9g0uCZaNi2j/cHEUIIqdaY9HQYpn3hNc4y8RlkhGkw+4D3QWwvdXwNLF2IJzLs9wyG6c1XwDhK7sShW7EU1qefq/xfgFYSUfooPNv+Rby//R3ZuGl7P8P9zcYgVBugTkiEkKChXbUCjJcvh2zDRwE6mg+B+IFKBfOb7yLswZGyYdofF8Py5NPgmzVXKDFCCCGEEEJIqYQ2Aa7+XvL9eSeVy4WUn91LEQYNFWHwitMAsd2lpYD1qlSMIfuQNDtfzlEg93jlnKFWEwmEtZCW6C5S8YXQJjSYoyIYBlCbpAX1Ap2NfzGMVMiB00mzbpaFyyIVZCgoymBLlQZiXn/bnk4FG8qF8Zwt1WPNuAeUA8B164KB5jfsK9i+2b7ypsgBKqO7gIjRXSzEULTWhEv/V2r3WnPdWh0uFVNQmei7SuJ/DAPAD/9nDANowqQlJNF7vCi6C/hYpAI4vBXgLYDLWrRd4qBs0V20p1ghHk0EoK9BBReI/6hNRYPsb0YUpGJV188eztuKFaVyLyh23lFYSMpQVFynqr4fsCpp8GdYU6DOfUX7XVbpM0jOYalIQ/4ZIO+MtLaXPPNxQGijAFMjqRBGWPOi/wkazEyCjTpUKnIQ061onyhI1wAslwDLZWltviQVkiksPucuQOfIRoXOjwHptUwXD4Q1k9pLWAsg+hbA1KBqvsYRUhoMA5jqSUvte4v2Cy7AfF4qyJB7QrpenXsCsFyU2qovCjS0eqfs1zuIYsxms8e2Vlv2zzXXP8bfRRi8UavVGDNmDEaMGFGuAgzx8fHo2bMnkpKS0KhRI8TGxkKv1yMvLw+XL1/Gjh07sHTpUly6VFRkODs7GxMmTMDSpUvRsGFDX/445eOLa07ejl1J3lKpCAMJOs2aNcPmzZsLt/ft24fBgweX6rHXrl3zKOCgVqt99qLDMAyaNGmCAwcOeORW2iIMe/fu9dhu0qRJmav6EBJMXnjBgeXL1UhNLfnLXpuNwSefaDFtmk3BzEh10+a2MViXNAxL5z+J93NXIVNf9hO8nyKSsWb9PRj7a3M8PWIOYuu29EOmhBBCqgLj5/8HNl++cxEfGwfLk0/j2wNfIt8pH9siqhXubHCXL1MkVZAYHgFHn/7QrltTYozq+DFwhw+Bb1X6IoakYh5rNR5zDs1CivlqiTGZtkx8c+ArvNZ5koKZEUKCkW7RfK8xtgce9n8ipNpy9L8Dzs5JUO/cXmIMI4owfjgZuQt/VDAzQgghhBBCiFchjeXvN58HeDsN2Ap29nT5+7XRyuRR1ehrALXukZYCAg+Yz0mz/FouSDP0FV+sV+GXjqOlpYuTBnCENncP5HAv2hgayEECQ2UATPWlxRveLr2eFV9sacW209wDN/Okgg3F1/6YMf6m3ANDWa303lh4+7rBopzO+z6vsdobY1iNZ5GFQLi+k7xc8QaGkWaJJoSUDcMA6hBpIaQqYNiiQiSoHehsKheV/saZwgs4c4H8s9KAcetVabC49WrRbXu6+9wpR6ZwSylweqk4kjpM+oykr+le3LeN9YHQRjR4lVRuDAsYEqTFG1GUBn0LNqmYDG+X1oUFG92F0a4vkqYyAKoQaU0FEQkpPVYlFTILSQQSBnreJwqA7RpgdhdksFySij3a0qRrCAVre5r0vnk9XSzQ7nOg/gPK/CykXBzXTTCnVpf9OoNGo/HYLphEPVCcTifmzJmDefPmYfDgwXj99ddhMpm8Pi4kJAQzZ85Ejx49wLI3vpdEREQgIiICrVq1wiOPPIJvvvkG33zzDQRBOhfMzc3Fyy+/jJUrVwZ+3LE/n9+jMGnwoyIMJOj06NED3333XeH21q1bIYpiqV44tmzZ4rHdpUsXGI1Gn+ZWvAjDli1bcNddpRswtXXrVo/tnj17+iwvQgLBZALeeceOCRP0snFLl6owfjyL5s0rcHGIEC9UGh0eeHwe7kp5C1/OfwCzjYfBl/Hah4sDvjUdxYKfb8HjjnZ4YuQsRNdu5p+ECSGEVErcmVPQzZ/rNc7y6pvIUjkw++Asr7Evd3odLF2wJ6VgGzZStggDAOiWL4WZijAoxqA24KWOr+GlTc/Kxs3aPwNjW45HjCFGocwIIcFGdegA1Af2ycY4O3UB36SpQhmRaolhkD9pMiIG9ZcN0/7xG9Tbt8KZdItCiRFCCCGEkGCUnp4f6BSCmkbjeU3X4fDvd+FqsQ7C5AJEAVmXDoE30efKYBZhTQcnc7+ZD4GV2p4PxQPaeEAL4PpxRiIPxpkJ1pEBxpEO1pkh3XZmgOEt7sUMTrQA7tsQBYgCL3UcF3kAgtRJlOEgslr3oGs1RFYLkdUAnBGCOgyiSloETSx4QwMIhvoQVTcZrJkPIN98435CglKYtKgaSj2QS9s9U3CAceWBEWzSgCjRCaZgLTql+0WX1MYYDiJYd2fv6wdHsRAZDmC17vandbc96TYYVak7iVfoPV1wL87rd1bGyYrs3kMIqcSUPn8n/iPwAi6uP4dD3+9H+sFrPj22yqBC7Z71UH9AImp1rw1OS8NsKpPgbecsgERAmyh9NgkvIUwUAd4M1pUjff4QXO5zJQcgOqXPIawKYDQQWbX7s4caoioUoipM+jziTS4gffAgpPIqe1tnARjcSykUnhYHdvZ1QqoeE4DmgKG5fHMUeWhYq3TtwJULUR0BO+MuWkrXTWVFR3svDuBP1xdQcDqdJUSW7PpCDlqtf4tOr1692mM7Pz8f6enpOHjwINasWYN///0XAMDzPFasWIFDhw5h/vz5iIiQL2oVFhaGXr16lSoHjuPw9NNPIzQ0FB9++GHh/iNHjuDPP/9E//7yfbwUUYkKJfgTfTokQad9+/aIiIhAVlYWAODSpUvYsWMHkpKSvD52xYoVHtulfdEqrV69emHatGmF27///jsmTZrktdBDfn4+fv/9d499vXv39mluhATC0KEufP89jz17Su4qIIoM3n9fi8WLrQpmRqqr8PgGmPzqVty/aw3e+mMiNkZml/kYVjUwXb0Pc1Z2wRN8R4wb9S0iazbyfbKEEEIqHeOUd8G4XLIxriZNYRv1AGbu/hD5zjzZ2JbRrXFH/YGyMYQUcPTpByE8HGx2dokx2lXLYX77PUBFl3uUMqrpA/hm/3SczTlTYozFZcbUPZ/ig+6fKJgZISSY6Bb+4DXGOuZhv+dBiCupK+wD7oT293Wyccb33kb22r9o9k1CCCGEkGpMpE5Vsq7/9fj79+UyNPQaw5pPwmVs4tc8SMWwzkzZ+wVVBLU9xbAQ1dEQ1NGATLvRaDz7wjgcvG+env7OpLpi1BDVkco8VynbmdLv6YSQwKC2Xvm5rE4cX3oUB2btQc65bJ8dl9NxqNu7PhIHN0XdPvWhNhTN2Ev/J5VLlWjnnBE8V87JRyvjz0tIOVSJtk4IkcG6CwyFAkgAAIgOnt7nKoHrx9Xa7WUv9nj9YwyGUhbQ8RGTyQSTyYR69eph0KBB2LJlC55//nnk5OQAAE6cOIHXXnsN3377rc+f+6GHHsLff/+NnTt3Fu5bvXp1cBRh8LvK0TeNptskQYdlWQwePNhj34wZM7yeIG/btg27d+8u3DYajbjjjjt8mlvTpk3RqlWrwm2LxYI5c+Z4fdycOXNgsRRVQ2vbti0SExN9mhshgcAwwDvveD85+vtvFTZvlpvTgRDfatzpbix94zwWxTyP+nnlG4Ro0QBf6Hej47IO+PSLfshOOevjLAkhhFQmqu3boF23xmuc+e33kOHMwXeHZnmNfbnT62BoYBspLa0W9nuGyoZw11Kh/vcfZfIhAAA1p8ZrnSd5jfvhyPe4mHtBgYwIIUHHbIZ25XLZECEkFPa771UmH1Ltmd94ByIr/9WQevdOaLwUaiCEEEIIIYQoR9DWhMjKdzjkzKcVyoaUC2+TZjOVIWiiFEqGEEIIIYSQysGWZcWuz7ZhYYc5+PfV9T4pwMCqWNTt1wB9vrkDjxx9EgPmDULioMYeBRgIIYQQQgghpXd9wQSbzVbmQjnFx93e7JhK69atG7799luwxfpY/fPPP9iyZYtfnu+RRx7x2N6+fTtcXiaOrLRcxf7WXGD/zqVFRRhIUHr88cc9Xix37tyJ7777rsT41NRUvPnmmx77HnzwQURGyldObtKkiceyY8cOr7k988wzHtvfffcddu3aVWL8zp07byjU8Nxzz3l9HkIqi6QkHv37e39j//hjDRUgI4piWBb9hk3Gpoln8b44AOG28g1yzdcAn+q2o+OStvj48964duGwjzMlhBAS9EQRpsneB1k7ut8OR5/+mHXga5id+bKxrWPaYkC9O32VIakmbMNGeo3RLV+qQCakuEGJg9Equo1sjFNw4pNdHyqUESEkmGjX/Aw2L1c2xj50GGAs56wmhJQR37QZbCNGe40zfvAuUFW/zCOEEEIIIaSyYVjwhoayIZzllELJkPJgnZleYxSbHZ4QQgghhJAgZ8u0YsdHW7Cww/fY9ck2WNOtFT5mdMsYdHu/Bx48MA4DF92Lxvc1g8ak8UG2hBBCCCGEVG8REREekxI6nU5kZGSU6Ripqake21FRgS9a3K5dOwwaNMhj36pVq/zyXElJSR6/Q7PZjLS0NL88V0CJImC5XLStDglcLmVARRhIUIqMjMQTTzzhse/zzz/Hu+++6/GiKggC/v77b4wcORJXrlwp3B8bG4tHH33UL7nddtttuPXWWwu3nU4nxo4di/nz58NqLbrIY7FY8MMPP+Cxxx6D0+ks3H/77beja9eufsmNkECZNMkOlpWvsLBjhwqbNnEKZURIEZ0pHOMmLsPO0fvwjLkdNOUcP5CrBT7X70KH1bfgjf/rjAuHN/k2UUIIIUFLs+ZnqPeUXHitgPmdKciwZWLOoW+9xr7c6XWPiyWElIarU2fw9erLxmh/+xXIly8CQnyLZVi8mfSO17jlJ5biWMZRBTIihAQT/aL5XmNsYx72fyKEFGN55Q2IWq1sjOrkCeh+XKxQRoQQQgghhBBvXMZGsverLKcVyoSUB1OKIgwCFWEghBBCCCHVnDXDiu0fbMbCDnOw58sdcOY7KnQ8bZgWrce3x/ANYzB8wxi0GdcehpjKMdMqIYQQQgghlYVOp0PNmjU99iUnJ5fpGFevXvXYbtCgQYXz8oW+fft6bO/bt88vz2MwGBAWFuaxLzPT+/cKlc61TQDvHn/NMIChTmDzKSUqwkCC1uOPP46ePXt67FuyZAl69uyJPn36YPDgwejSpQsmTpzo8cKs0+kwdepUhIaG+i23jz/+GLVq1Srcttvt+PDDD5GUlIS77roLAwcORFJSEj766CPY7fbCuDp16uD//u///JYXIYHSpImA0aOdXuM++UQLUb5WAyF+Ex7fAJNe3oTt/X7HyKzyn6jZVcCc0OPo8s/dmPBBcxzdttyHWRJCCAk6DgdM77/rNcx23wi4WrfFN/unw+yUHwDfJqYd+tUd4KMESbXCMLDdN0I+xGKBdu0vCiVECvSs3RvdanaXjREh4qOdUxTKiBASDLgTx6HeuV02xtmmHVyt2iiUESESIaEWrGPHe40zfPIhYK347FKEEEIIIYSQiuMNDWXv58ynFMqElAfr9D7rl6gO/MxehBBCCCGEBII1w4pt7/+HRR3nYO+0nXCavfdHlhPTOhY9p/bDgwfG4dYpPRDdMsZHmRJCCCGEEEJupn59zwnmzpw5U6bHXx8fLEUY6tTxHHuWnp7ut+dSqVQe2y5XOWcgDlZp24BdT0i3CwaXhrcKXD5loPIeQkhgsCyLadOm4fXXX8fatWsL9/M8j0uXLt30MeHh4Zg+fTo6dOjg19yio6OxYMECTJgwAcePHy/cb7PZcOrUzb/YbtasGWbOnInISKpcT6qmV15xYMUKNWy2kmd03r2bw8aNHHr14hXMjBBPtZregulvHsb4rT/ivQ0vY2NkdrmOI7DAiojLWLFvLHqtfwkT2z+HWwc8C4alGleEEFKV6H+YA+78OdkYUauF+fW3kG5Nx/eHZns95sudXgPDlHzORIgc230jYPxMvrifbvmPsI8YrVBGBAAYhsGbSe/gzlV9ZON+P7cWe1J3oUNcJ4UyI4QEkm7RfK8xtgceUiATQm5kefYF6BbNB5ubU2IMdzUZ+jnfwvr0c8olRgghhBBCCLkp3thI9n7WmQHGmQlRTX1SghHj9D5jlaChvx0hhBBCCKlerOkW7P9mNw7NPQCXpWKFF1gVi4b3NEbrx9ohtn089cshhBBCCCFEQc2aNcPmzZsLt/ft24fBgweX6rHXrl3DlStXCrfVajUaNpQvTB0o1xdK8BWXy4Xs7GyPfX4dg7y+V+lj806XLb44kQec+YD5HOB091FjmKIiDDX6l++4CqNRgiSoabVafPHFF5g+fTqaNWtWYpzBYMDo0aOxbt06dOnSRZHcEhISsHz5crz00kuIjY0tMS42NhYvv/wyli1bhho1aiiSGyGBEB8v4qGHvF8E/fRTbeF7JSGB1OKWEVj6xnmsSXwfXbNMFTrWhsgsDD3/Dvp+XAM/L30ZLqfdR1kSQggJJCYnG4bPP/YaZ338SQi16+Cb/dNhcZllY9vFtkffugN8lSKphoQGDeHs2Fk2Rv3fP2CvJiuTECnUMb4zBtQf6DXu/3a8r0A2hJCAs9uhW75ENkQ0GGAfcp9CCRHiSYyIhOWZF7zGGaZ/ASbL+2AhQgghhBBCiH/xhkSvMZz5tAKZkPJgHfKfq0TOCLBahbIhhBBCCCEksCxpFmx9dxMWdpyDfV/vrlABBrVRjTZPdMD9u8ai78w7EdehBhVgIIQQQgghRGE9evTw2N66dSvEUg4e3LJli8d2ly5dYDQafZVahSQne/bFjo6O9svz7N+/Hy6Xq3BbpVL57bkAAKn/ANc2lbwARYUSeLN8rNySthnI2gc4sqXjFf+f0MUBCXf772f0If+U3iDEx/r374/+/fvjwoULOHDgAFJTU+F0OhEaGoqGDRuiffv20GrL/mXkiRMnKpSXRqPB448/jrFjx+Lw4cM4ceIEMjIyAABRUVFo2rQpWrRoAZZmRSfVxFNPObBggRpWa8kXMPfs4bBhA4fevXkFMyPk5hiWRfe7nse6O5/Fpl8+w4f7PsPOCPnBs3IOhlkxLvNbtPp4Hr5sMQmtBz/nu2QJIYQozjD1c7BZWbIxQmQkLM++gDRLGuYemu31mC93ep2+7CUVZhs2EurdO0u8nxFFaFcuh/WpZxXMigDAG13exh/n1kFEyRePN13eiO3JW5FU8xYFMyOEKE27bg3YTPkBFrZ7hkAMCVUoI0JuZH38Cei//xacTPEmNicbhulfwvzOFAUzI4QQQgghhFyvVEUYLKfhCpcv4EoCg3VmyN4vqKMUyoQQQgghhJDAsVwzY9+M3Tgy/wBcFpf3B8gwxBrRelw7tHioNbRhOh9lSAghhBBCCCmP9u3bIyIiAlnufveXLl3Cjh07kJSU5PWxK1as8Nju1auXX3Isjw0bNnhsN2nSxC/Ps3LlSo/ttm3bQq/X++W5FHf9uAlRBBgO6PwdwGkCk1MZUREGUqnUrVsXdevWDXQaN2BZFq1bt0br1q0DnQohARUXJ+Khh5yYNUv+TXDqVA1697YqlBUh3jEsix73voLbB72Ev1Z8iP87MhV7I8r/P3oo0oEBl9/Gx6+vwJjnVwGxsT7MlhBCiBLYSxehnzPLa5zlxVchhoVjxtZJsLgssrHtYzugd51+vkqRVGP2ewbDNOlVMM6SZ4PQLV9KRRgCoGlkMwxvMgo/nlgsG/d/O9/HT/espaIshFRhukXzvcbYHnhIgUwIkaHXw/Ly6wh54Wn5sDmzYH1sPISEWgolRgghhBBCCLmeqA6HoIkB60grMYaznFYwI1IWjFO+UKOgjlQoE0IIIYQQQpRnSTVj39e7cGTBQbisFSu+EN4oEm0ndECT+5qB09JQGEIIIYQQQoIBy7IYPHgw5s6dW7hvxowZ6NKli2w/2W3btmH37t2F20ajEXfccYdfcy2tM2fOYNWqVR77evfu7fPn2bFjB1avXu2xr0+fPj5/npsSS55wrkwxZRHWHOj4FRDX07fH9SNGFH39WyCEVBZpaXmBTiGoaTScx7bDwQcok8rl2jUGnToZYbXKDyb65RcLkpLod0oC72ZtXRQErP/pfXx6fAb2VaAYAwCMOa7DZ0P+B6ZH3wodhxBSfvSeTsoj5MnHoFu5TDbGVb8Bsv7biWuubHRa1ApWl/x7xpKBK9C7LhVh8Jfq1tZDHxoN7W+/ysZkbtgCvmUrhTIiBS7knkfXxe3hEuQ7j6wY9Atuq9VDmaSqkOrW1knlxJ47i6gubWVjXE2bIWvT9hsrPRNq50pzuRBxexJUp07KhllHj0H+1BkKJUWqA2rr5RMTExLoFAghhFQT1JdAXqDOZcJ2DYAme2uJ99tj70VumwWK5ELKJuTwOOiuLi3xfkdkT+R0WF3i/SQw6HMLIVUftXNCqgdq64FjTs3Hvq+k4gu8rWK/9+hWsej4QhfUvyMRDEvfrxFP1M4JqR6orRNS9VE7L59g6UeQmZmJ3r17w2IpmtTwxRdfxLhx424an5qailGjRuHKlSuF+5588kk899xzss/TpEkTj+0FCxagS5cuN43Nz8/HZ599hieeeALx8fGl/EmAkydPYty4cbh69WrhvoSEBKxbtw46ne6mj9myZQtSUlJwzz33QKUqXcG4bdu24dlnn0VOTk7hvpiYGPz111/Q6/WlzrfM/u4BQOZz1bVNUr9GUQRUJiCyQ/meh1UBqhBAEwGEtwKibwGiO5fvWAFE5f8IIYT4VGysiEcfdWLGDI1s3FdfaZCUVLHB7YT4C8Oy6DP0bfQWJmHrb9Mwfd+X2BiZXa5jLWxqQ9rqoViw6yXghTcBjvP+IEIIIQGlOrDPawEGADBPehfQaDBj1zSvBRg6xHVErzpUkIf4jm3YSK9FGHTLl8JMRRgUVze0HkY3fRALjs6Vjfu/He+je8LtslV+CSGVk/5/3ge82B54iAowkOCgUsH85rsIe3i0bJhu6f9gffJp8E2aKpQYIYQQQggh5Hq8IRGQKcLAWU4pmA0pC8aRIXu/oIlSKBNCCCGEEEL8L/9qHvZ9tQtHFx4Cb6/YwLmY1rHo+FJX1OvfgL5bJ4QQQgghJIhFRkbiiSeewBdffFG47/PPP0dycjKefPJJxMXFAQAEQcCGDRvwwQcfIDk5uTA2NjYWjz76qE9zEgQBS5YswYoVK3DrrbdiwIABaN++PWrXrn3D5wuHw4HDhw9j9erVWLlyJZxOZ+F9DMNg0qRJJRZgAKSiEm+88QamTZuGAQMGoFevXmjRogVCQjyLZPA8j8OHD2Px4sX45ZdfIAhC4X0sy+Kdd97xbwEGAOjzj/z9i9mi2yGJQJ+Nfk0n2DGiKIqBToIQEhg0e4U8qqBVfunpDDp0MMJqlb/guXGjGS1aCLIxhPhbadv6wf/+hxmb3sPPEVchluNafreLwM9nuwFf/QDR/eGBEKIMek8nZSKKCBt6NzSb/5UNc3bsjOy1fyHVeg2dF7X2WoRh6V2r0KtOH19mSq5T7dq63Y6oVo3AZmeXGMLHxSNz/zEqAhUAV/Iuo8v/2sIhOGTjlgxcgd51+ymUVdVQ7do6qXycTkS1bQY27VqJIaJWi4yDJyBGRCqYWOVB7TwARBHhA/tCvXunbJh9wEDkLliiUFKkqqO2Xj7BMoMFIaR6sOfaYUm3wJJhgcvqAgDUva1ugLMiSqG+BPICdS6jPz8NplNvlXi/yOqQ3isFYNgSY0hghO/oCXXunhLvt9Yeh/ymnymYESkN+txCSNVH7ZyQ6oHaunLyruRh3/SdOPq/wxAq+HuOaRuHTi91Rd2+9an4AvGK2jkh1QO1dUKqPmrn5RNM/QgEQcCECROwcaPnoH2O41CzZk2EhITg8uXLyM3N9bhfp9Nh7ty56NChg9fnaNKkicf2ggUL0KVLl5vG5ubmolOnTjfsNxqNiImJQUhICERRRH5+Pq5cueJReKEAwzCYMmUKhg0bJpvXqlWr8Prrr9+wPy4uDmFhYTAYDMjPz0dycjIsFstNn+fNN9/EmDFjZJ9HEYvZogmmwtsAd+wNbD4Bpgp0AoQQQqqe6GgR99/vxJw5Gtm4r7/WYOZMm0JZEVIxrbvfj2+7349XD/yFWetexWLjaTjKcCa1pQ4wRNyCtf27wTVrIVxJXf2XLCGEkHLT/P2H1wIMAJD/7gcAw+DrfVO9FmDoENcJPWv39lWKhEi0WtgHDYF+wdwSQ7jUFKj/2wRnj14KJkYAICGkFh5s8QjmHPpWNu7jnR+gV52+1GmEkCpE8+fvsgUYAMA+cBAVYCDBhWFgfmsywu+5QzZM+/taqHZsh6tLkkKJEUIIIURpJ389iWM/HcOFfy4g+3y2550M8Lbr7RIfm3Y0DS6bq3A7rE4YDNEGP2VKSPXEGxJl72cEG1jbZQj6OgplREqLdWbK3i+o6ToBIYQQQgipvPIu5WLPtJ04vuQwBGfFJmaLbR+PTi8loU5vKr5ACCGEEEJIZcOyLKZNm4bXX38da9euLdzP8zwuXbp008eEh4dj+vTppSrA4Ctmsxlms9lrXL169TB58mQkJZW/r1RqaipSU1NlY2JiYvDxxx+jW7du5X4enxPFQGcQNKj0OSGEEL948kkHVCr5N9yff1bhwgW6SEoqlwZt+uKT1/di36DNeNncCeFlqCPyX13gvl7XoB92J3RzZtFJKSGEBBuXC8b3Su5IXsA+cBBcnbsg1ZyC+Ye/9xr/Sqc36Ith4he2YSO9xuhWLlMgE3Izz7Z/ETpOJxuzP20ffj+/TqGMCCFK0C36wWuMbczDfs+DkLJydu0Ge78BXuNMU96m6xmEEEJIFXRq3SnMbD0TS+9ZigM/HEDWuSyIouixwMspwO5Zu/Fdp+8Kl9+f+12Z5AmpRnhjI68xnOW0ApmQsmK8FmGIUigTQgghhBBCfCf90DWsf+p3/K/LXBxdcLBCBRjiOtTAXUsHY+hvo1C3TwPqZ0MIIYQQQkglpdVq8cUXX2D69Olo1qxZiXEGgwGjR4/GunXr0KVLF7/kEhISgkWLFuHxxx9H69atoVarvT5GrVaja9eu+PTTT7FmzZpSF2BISkrC008/jc6dO8NoNHqNZ1kWLVq0wOTJk/HXX38FVwGG0ULRcsfeQGcTcIwoUm85QqqrtLS8QKcQ1DQazmPb4eADlEnl9dRTOixbJn+CMnasAx99ZFcoI0JuVNG2bk6/gtlLn8DH2AShlOWt7j0GLFsO8IOHI+/z6YCBZoIixJ/oPZ2Ulm7BPIS89KxsjKhSIWvzTvANEvHW5tfw7cFvZOM7xXfBr4P/pC+HFVAt27ooIrJzG3AXzpcYIphCkHHkNKDXK5cXKfTOljcx88BXsjHNo1piw/DNYBmqlVoa1bKtk0qDvXwJkR1agpG55O5q0BBZ2/YCdG5QImrngcMdO4qIHl1l/4cBIOeHxXDceZdCWZGqitp6+cTEhAQ6BUJIFSOKIta/sR5bP9lauA3ghmtZoiiCYRi8zZdcwDT7fDa+avQVBF4acKE2qPHi1RehDdH6KXviT9SXQF7AzmUEB6LXx4JByQOb8pp8Clud8crkQ0pHcCFmfaRsSG7L72GvMUyhhEhp0ecWQqo+aueEVA/U1n1L4AVc3HAeB2btwZX/bj6TbVnEd6qJji8loXaPutS3hpQbtXNCqgdq64RUfdTOyyfY+xFcuHABBw4cQGpqKpxOJ0JDQ9GwYUO0b98eWq2y3yM6HA6cPn0aFy9eRFpaGsxmMwCpWENISAgaNGiAxo0bQ6PRVOh5RFHExYsXceHCBaSkpCA3Nxd2ux0GgwGhoaGoUaMGWrduDZPJ5Isfi/iZKtAJEEIIqbqeesrhtQjDkiVqvPaaHWFhCiVFiI8ZoxPw/FNr0OnQKjy+4XFkqJ1eH/NzM+CpO4FZK5dBdewocuYtglC/gQLZEkIIKVF+Powff+A1zPrwWPANEpFqTsH8I3O9xr/S6Q36kpj4D8PANnQYjF98WmIIm58H7Z+/wX7PEAUTIwWebv885h+ZC4vLXGLM0YzD+PXMagxKHKxgZoQQf9AtXuh18Lrt/oeoAAMJWnyz5rAPHwXdj4tl44xT3oajb3+gFNXhCSGEEBLc1j65Fnu/21tYZIFhGIiiiOJzeZT22lZ4vXA0vqsxjq8+DgBwWV048csJtL6/tV9yJ6RaYjUQ9HXBWc+VGMJZTiuYECkNxpXlNUbQyBdpIIQQQgghJNByL+Tg+JLDOP7jUeRfqXjhvvjONdHp5a6odVsd6ldDCCGEEEJIFVa3bl3UrVs30GkAADQaDZo3b47mzZv79XkYhgmqn5tUDE2xRwghxG+aNhUwYID8gHSLhcGiRdRhm1R+t7YagjVjtqEWwksVP7sj8PktgOroYUT06wHN33/4N0FCCCGyDN9MB5t2TTZGCAmF5cXXAAAz9k+HjbfJxneOT8JttXr4KkVCbso+dITXGO3KZQpkQm4mWh+Nca2f9Br3ya4PwQtUtZmQSo3noVuySDZEVKlgGzFaoYQIKR/zq29C9FJlXnXmNHT/W6BQRoQQQgjxl13f7MKe2XsAwKP4QoPeDdD/i/4Y8dMIRDYs26Dg5sObFx4PAM7+dda3SRNC4DI2kr1fZTmlUCaktFhHhtcYUR2lQCaEEEIIIYSUjSXVjMM/HMDqocuxqNP32P3FjgoXYKiRlIBBK+7D4DUjUPv2ulSAgRBCCCGEEEJIUKMiDIQQQvzqmWccXmO+/14Dl0uBZAjxs8TIxvhlzBbU19UsVfwrfYFVzQA2Jxuh9w+H4dOPAEHwc5aEEEKux6amwPDNdK9xlmdfgBgVhTRLGuYf+d5r/Cud36Avi4nf8Y0aw9m6rWyM5u8/wWR67+hL/OPJtk8hRBMqG3My6wRWnVquUEaEEH/QbPwb3JXLsjGOAQMhxsYqlBEh5SPUqg3ro+O8xhk/+RBMfsVnuiKEEEJIYFizrFj/xvrCa1eiKCK0Vige3fwoxvw1BknPJaHpPU2hMWnKdNwmdzcBp+EKj3lu/Tmf505IdccbEmXv58xnFMqElBbrzPQaI6jLVvSGEEIIIYQQf3DmO3DpnwvY/sFmrLxjMX5o/S3+fWU9rvx3qcLHrtmtFu5ZdR/uXT0ctW6rQ/1pCCGEEEIIIYRUCqpAJ0AIIaRq69hRQMeOPHbv5kqMuXyZxbp1KgwaRJUYSOVXK6Q2Vgz7E4NW9sMVS7JsrMgADwwBNs0DOiWLMH76EVT79yJvxmyI4REKZUwIIcTwyYdgLBbZGD6hFqyPS7PZf7N/Oqwuq2x8Uo1b0D3hdp/lSIgc+33DoT64v8T7GZcL2l9+hu3hscolRQpF6CLxRJuJ+HTXR7Jxn+3+PwxudB9ULF2uI6Qy0i1a4DXG+sBDCmRCSMVZnnsRusULweZklxjDpqdBP2M6LK++qVxihBBCCPGZrZ9thT3XDoZhIIoiTHEmjN02FqEJ8kUEvdGYNIhrFYere68CAPKS82BJt8AQbfBF2oQQALyhkez9rO0iwFsBTq9QRsQbhoowEEIIIYSQIOSyOpF+JA1pB1JxbX8q0g6kIutkJkRB9Onz1OpeBx1fSkLNrrV8elxCCCGEEEIIIX5ivui/YzMcoA4F1CH+ew4fo17dhBBC/G78eAd275bv5DFrloaKMJAqo3ZIHay891fc/dMApFmvycZa1cDdo4Ed3wF1cwDtX39A1fd25PywGHyLlgplTAgh1Rd3/Bh0//M+aNL82iRAr0e6NR3zDn/nNf6lTq9R1X6iGPvg+2B8dxIYQSgxRrdyGRVhCKDxrSfgu4MzkW3PLjHmXM5ZrDj5I0Y2vV+5xAghPsGkpkLz52+yMXztOnD26KVQRoRUjBgRCctzL8E0eZJsnGHmV7A9PBZCXLxCmRFCCCHEV44uO1pYgIFhGAycNbDCBRgK1OhQA8l7iopUpx9PR51b6/jk2IQQgDcmyt7PQARnPQfe1FyhjIg3rCND9n6R1QKcUaFsCCGEEEJIdcTbXcg4ll5YbOHa/lRkHk+HyPu24EJxtXvURccXk1CjS4LfnoMQQgghhBBCiB+srgf4fRwEA2jCgbCWQFRnIPY2oOadAMP6+XnLjoowlENKSgq2bNmCI0eO4Ny5c8jLy0NeXh5crvIPHmYYBn///bcPsySEkOAxcKALCQkCrlwp+Y1w924Oe/aw6NCh5IFjhFQmDcITsXzQagz6aQByHTmysakm4K7RwJa5QKgd4C6cR8SdvZH3+XTY7xuhUMaEEFI9Gae8LTtwHQCcLVvDPmwkAODbAzNgcVlk4zvHJ6F7wu0+y5EQb4S4eDhvvR2afzeWGKPesQ3spYsQatOgh0AI1YZhYttn8cGOybJxX+z+BPc1HgEVS5fsCKlM9EsWgvFybdg2egzABt8XBISUxDp2HPTffwvu8qUSYxiLBYZPPkL+59MUzIwQQgghFZV9PhuZZzILC4hGNYlC03ua+uz4UY2jPLazzmVREQZCfIg3NPIaw5lPURGGIMI4M2XvF9SRCnRmJIQQQggh1QXv5JF1PAPX3MUW0g6kIuNoGgSnMn1z6/Spj47Pd0F8p5qKPB8hhBBCCCGEED8Q/Ve0z/0EgD0TSPtPWo5/DugTgEYTgKYvAJzGz89fetSjuwwOHjyIr776Clu3boVQbJCO6IN/KJohlRBSlalUwNixDrz3nk427rvvNOjQwaZQVoT4X/OoFpg3YBFG/DoYLkF+QM7hOGDUUOCXJQAnAozVitAJj8O6eyfy33kf0OsVypoQQqoP9X+boP3rD69x5nffB1gWWbZMzDn0rdf4Fzu+Sp/xiOJs9w2XLcIAANpVy2F99kWFMiLXG9t6PL49OAPp1vQSY87nnsPKk8swouloBTMjhFSIIEC3aL5siMiysI16QKGECPERnQ7m199C6MRx8mH/mw/r+AngGzdRKDFCCCGEVFTK/pTC2wzDIHFAok+Prwv3/D7Qnmv36fEJqe4EbQ2InBEMby4xhrOcVjAj4g3rpQiDqI5UKBNCCCGEEFLVCLyArJOZSDuQimv7U5B2IBXph9PA23lF8+C0HJoMb47W49ojskmU9wcQQgghhBBCCAluSo6FKBifb7kMHHwTuPgjcMtiIKyZcjnIoKm3SmnatGkYPXo0Nm/eDJ7nIYpi4cIwTIUWQgipDsaMccJgkC9a8+uvKqSl0esiqVq617odn91euhkh1zUGXurnuU8/9ztE9LsdqkMH/JAdIYRUY4IA47uTvIbZe/eF87YeAIBvD34DszNfNr5DXEf0qN3LFxkSUiaOgXdD1MkXPdOt+FGByqSkJCa1CU+1e95r3Jd7PvVawIsQEjzU/2wAd/GCbIyjTz8INRMUyogQ37EPHQ5nqzayMYwgwDjlbYUyIoQQQogvmNOkgdsFk03EtIjx6fG1YVoARRNROPIcPj0+IdUew8BlkC+eojKfUigZUhqMM0P2fkFNg9QIIYQQQoh3oigi52wWTq06ji1vb8JPg37EnIYz8OPtC7DhmT9weO4BpO5JUbQAgykhBJ1e7ooxex9Hj8/7UgEGQgghhBBCCKkqRPHGxdv95Y1lmKJFFIGsA8BftwK5wfF9lyrQCVQGU6dOxaxZswq3ry+cINIABkII8SosDBg1yonvv9eUGONwMFiyRI1nnqHOWKRqGd1sDM5mn8H0fV94jZ3aFWiSATyxu2if6sRxhA/oBfMrb8D61HMAx/kvWUIIqSa0K5dB7aXAjciyML89BQCQY8/GdwdnycYDwIsdX6VieyQgxJBQ2PvfCd3qVSXGqE4cB3f4EPhWrRXMjBT3cIux+HrfVKRb00qMOZtzBj+dWoFhTUYqmBkhpLz0C3/wGmMb84j/EyHEH1gW5nemIPy+QbJh2j9+g3rrZjhvuVWhxAghhBBSEdYMq8e2Lly+qGNZOS1Oj21WTXODEOJrvKEh1HklX9/mLKcVzIZ4wzozZe8X1ZEKZUIIIYQQQioTp9mJlN3JuLrtMlL2pCDtQArs2fZApwVWw6HBnYloOqoFat1WByxHn/sJIYQQQgghpEpJmld023weOPoJINikbVEEGBaIbA9EtANM9QF1GMBpAWcuYM8Asg8CGbsAW6r0mIKxFdFdgYaPASIPOLIAawqQsR3I2A0IDs9CDI4s4N9BQP9dgNqk6I9/PSrC4MWBAwcwa9asmxZe4DgOdevWRZ06dWAymaBWqwOUJSGEVA6PP+6QLcIAAPPnqzFxooPGmJMq542kt3E+9xx+OfOT19in7gQSM4E+Z4v2MU4nTB9MhvbP35E3/RvwDRv5MVtCCKnibDYYP5riPWzUA+CbNQcAzD44E3mOXNn4NjHt0LtOP5+kSEh52IcOly3CAAC6lctgpiIMAWNQGzCx7bOYvG2SbNwXez7BkEbDwLH0wYiQYMampkDz+1rZGL5mAhy9+yqUESG+57ytBxy9+kCz4W/ZOOPkScj+fWPRl2aEEEIICVpqo2e/huuLJlRUQZEHURTBMAwMUQafHr8ysdvt2Lt3L86ePYvc3Fyo1WrEx8ejTZs2qF27dqDTI5UYb5T/npCzBMfMQETirQiDQEUYCCGEEEIIAIEXcG1vCs79cQbJWy4h7cA1CC4h0GkBkAov1L69DhoMbIT6AxpCF6kPdEqEEEIIIYQQQvylwUPS+spaYM8zUgEGUQTUIUDzV4H6DwOGmvLHEEUg5S/g2KdAynqpT1n6NkATBXRbAqiKfYdsuwYcnwoc/xwQXUWFGPJOAiemAS3f9NdPWipUhMGLqVOnemyLoojo6GhMnDgRAwcORGhoaGASI4SQSqhBAxE9erjwzz8lv/1cusRi/XoO/frxCmZGiP+xDIuves/C5byL2Httj2wszwL3DQe2zwGapnvep961AxE9u8H8xtuwPv4kqGIJIYSUnf67WeAuX5KNEQ0GWF6VPrDn2nMw++BMr8d9seOrNxTwI0RJjl59IEREgM3KKjFG+9MKmN+aTOcQAfRwy7GYsX8q0q3pJcacyT6Nn06vwH2NRyiYGSGkrHRLFoHh5a9f2EaPAVR0GZ5UbvlvT0HExvVgRLHEGPW+vdCuXgX7vUMVzIwQQggh5WGMMQJA4XUs8zWzT4+feiDVY1sfFTwDM1JTU3Hw4EEcOHAABw8exOHDh2E2F/38CQkJ2LBhQ4WfJzMzE19//TV++uknWCyWm8a0aNECEyZMQJ8+fSr8fKT64Q2JsvezziwwjgyImiiFMiJyGEeG7P2ChoowEEIIIYRUV6IoImVnMo7/eATnfz8La/rNP0MGQmTTKCTcWhsJ3Wqj1m11oAnRBjolQgghhBBCCCFKufon8N8QQHAX9I+5Bbh1OaCvUbrHMwxQo5+0nP0B2DleKrCQ/CuwaRDQ83eAdfer1MUCbT8EEu4C/hkIuHKLCjGcmAY0fQFQBe47Z+r9KSM3Nxc7d+4EwzCFszS0aNECc+fORVhYWKDTI4SQSumRR5yyRRgAYN48Dfr1syqUESHK0av0mH/nUgxY0RNX8i/LxubogIGjgR1zgOjrvlthbDaY3n4D2l9/Qe70mRAaNPRj1oQQUrUwmRkwTPvca5zliacgxEsXCb4/NBs59mzZ+JbRrdG/3h2+SJGQ8tNoYL97MPQL5pYYwl1NhnrrZji7365gYqQ4o9qICW2fxXvb3pKN+2L3JxiceB84lgpmEBKUBAG6RfNlQ0SWhe3+BxVKiBD/4Zu3gG3k/dAvWSQbZ3x/Mux33AVoqSMmIYQQEsxM8SaP7at7rvr0+Oc2nivsYwEAMc1ifHr8stqzZw/mzZuHAwcO4Nq1a35/vh07duDZZ59FlkyRTAA4cuQIJk6ciHvvvRdTpkyBRqPxe26k6uANjbzGcJbTcFERhqDAOjNl7xfVVISBEEIIIaS6EUURp1Ydx56pO5F1Qr5olxJMtUIQ2yYOMW3jpXXrWOgig6eoIiGEEEIIIYQQBdnSga0PSAUYGAaI6AD0/BNQGcp3vAYPA5wB2DJS2r62ETg8BWg92TMu5hag63zg33ul5wUARwaQ8jdQ6+7y/jQVxgbsmSuBPXv2gC82k5lWq8VXX31FBRgIIaQC+vZ1ISFBkI3ZsIHD+fM0izSpmuIMcVh05zIY1SavsWcjgbtGA2b1ze9X79yOiN7dofltrY+zJISQqsvwxSdgc3NkY4SYWFifehYAkO/Iw6wDX3s97osdXy2cPZCQQLLfN9xrjHblMgUyIXIeafkYonTyneBPZ5/C6jOrFMqIEFJW6n82gLt4QTbG0acfhIRaCmVEiH9ZXn0Tok4nG8NdPA/9/O8VyogQQggh5ZXQJQGcRir4J4oizv51FryD9/Ko0jm59iRyLhZdewupGYLIxMAOLj506BD++usvRQow7N69G+PGjbuhAENoaCiaN2+OhIQEcJxnscWff/4ZL774YmHRCkJKgzcmeo3hLKcVyIR4JQpgnPJFWQQqwkAIIYQQUq2kH0nDz/csw99P/haQAgzGeCPqDWiIzq/egoFLBuPhI0/gwb2PY8C8QejwbGfU7lGXCjAQQgghhBBCSHV27BPAnu7eYIEuc8pfgKFA3eFA7aHSbVEEjn0K2NJujKs1CIjrKcUUSPu3Ys9dQVSEQUbxL+EZhkGfPn1Qs2bNAGZECCGVn0oFPPigUzZGFBksWFDCqHNCqoAW0S3xbd/vwcD7YN0dtYARwwBnCWdtrDkfYQ+NguHzjz1PMgkhhNyAPXsG+nlzvMaZX3kDoikEADD38Bxk2eU7SDaLbIE76g/0SY6EVJSzcxL4WrVlY7RrVgM2m0IZkZsxqo14su0zXuO+2P0JeME3A2EIIb6lXzDPa4ztwUcUyIQQZQg1E2AdP9FrnOGLT8DkZPs/IUIIIYSUm1qvRp1b6xQO+rdmWnFg4YEKH5d38Nj41kYAUnEHhmFQr2e9Ch/XnwyGCnYWKiYnJwfPP/88bMWuuSQkJGDGjBnYuXMnfvrpJ2zYsAEbNmzAiBEjPB77559/4ocffvBZLqTqE1Wh4DVxsjEq8ymFsiFyGFc2GMhPUiFSEQZCCCGEkGrBnmvHf29uxPI+i3B1+xVFnlMfrUedPvXR8cUk3LnwHjx0cBweOjgedy64Bx1fTELd3vVhiPHdZ2NCCCGEEEIIIZWcKABn5wIMIy0xtwIRrX1z7CZPS2uGAQQ7cG7hzeMaPVEUBwDp233z/OVERRhkZGdnA0Bh54P27dsHMBtCCKk6Ro92QqWSHyy+dKkaTvlaDYRUav3q3YHJ3T4oVezaxsD4uwG5VmP8+AOYXn4e4GmQHiGElMT0wWQwXk4wXI2bwHb/gwAAs9OMmfunez3uix1fAcvQx2sSJFgW9qHD5UPycqH56w+FEiIlebTV44jUyXewPpl1AmvO/KxMQoSQUmNTU6D5Y51sDF8zAY5efRXKiBBlWJ5+DkJUlGwMm5kJw/QvFcqIEEIIIeXVcmRLANJkFKIoYv1r65F3Na9Cx1z31Dqk7E8BwxQVoO74RMcKHdOXjEYjOnfujLFjx2LatGnYsGEDZs2a5bPjf//99x4TfdSqVQtLlixBnz59PH4n8fHxeO+99/D88897PH7GjBnIycnxWT6k6uMNibL3c5bTCmVC5LCOTK8xgkb+cxYhhBBCCKncRFHE8R+PYnHXeTj03T6IvH8mWtKGa1G7R120f64zBsy7G2P2PY6HjzyBuxYPRudXb0G9/g1hjDf55bkJIYQQQgghhFQRGbsBe7HvNmr0992xY24FOH3RdsrfJcTdVnRbFAFriu9yKAcaJSJDo9F4bEdGUuVxQgjxhbg4EXfd5ZKNSU9n8fffKoUyIiQwxreeiAebP1qq2HntgEm95GP0C+Yi5MmxoAomhBByI9WuHdCu+dlrnPmt9wCVdA7yw+HvkWHLkI1vEtEUdzW8xxcpEuIzNi9FGABAt3KZApkQOSa1CRPaPuM17vPdH0MQ5WfLI4QoS7d4IRgvBfBs9z9YeE5BSFUhhobB/OKrXuP0s78Be+miAhkRQgghpLzaPtIWkYlS/weGYWDJsGBB7wXIuVj2IgD2XDuWDV2Gfd/vKyzqwDAM6txaB7Vvqe3r1MusV69eWLt2LXbv3o2FCxfilVdewYABA5CQkOCz58jMzMTChZ4ztbz//vuIi4sr8THjx49Hp06dCrfz8vIwd+5cn+VEqj7e2Ej2fs58SqFMiBzGWYoiDGrqj0YIIYQQUlWlH7qGn+7+ERue/h3WNIvPjqsyqFGzawLaPNkBfWcPxP07HsWjJybg7mVDkfTGrWgwsBFCEkI8igISQgghhBBCCCFe5RyR1qK7gKChlu+OzbCAvkbR8Que63r6OEBb7LsTZ5bvcigHKsIg4/ovxC0W3138IISQ6u7hh70PEl+8WK1AJoQEDsMw+Kj7p+heq0ep4j+8DZjWRT5G9/MqhEx4HPAyIIgQQqoVUYTp3Ulewxy33ApHvwEAAIvTghn7p3l9zPMdXwbL0EdrElz4ps3gatFKNkbz9x9gsgN7UYoAj7Z8HBHaCNmYE1nHsebMz8okRAjxThCgWzRfNkRkWakIAyFVkO3BR8HXqy8bw9jtMH4wWaGMCCGEEFIeLMei7yd9Ibo7zzAMg/Tj6fim5Tf49/1/kXc1T/bxoiDiyq4r+Pv1vzG17lQc//l44bEAgNNw6Pd5P7/+DKVVp04dJCYmgmX9dw1v7dq1Hv1JOnXqhK5du8o+hmEYTJw40WPfypUrPX6PhMjhDYmy93PWs4BI3xcGGuuUL/QMACIVYSCEEEIIqXLMqfnY+PyfWNZnEVJ2Jlf4eJHNotDi4TboNb0/Rv73EB47MxH3rh6BbpNvR6N7myCsfjgVXCCEEEIIIYQQUnH2dM9txscTUTFcyc9VnKZ4EYZc3+ZQRjQVl4wWLVoAQOFFieTkil8EIYQQIunalUeDBgLOni25w9Pff3NITWUQF0edjUjVpebU+L7ffAz6eQCOZx7zGv/cHUCEDXjwQMkxutWrAJ0OedO+AfzYqZAQQioLzdo1UO/a4TXO/O77gPvz38Kj85BuTZONbxieiHsaDvFJjoT4mm3ocJiOHCrxfsbhgHbNatjGPKxcUuQGJk0Inmz7ND7c8Z5s3Oe7P8bdDe+loi+EBAH1P+vBXbooG+Po2x9CTd/NqktIUNFokD/pXYQ99pBsmG7VclgffwKuDp1k4wghhBASOE3vbYrb3roN/075FwzDgGEYOPId+Oedf/DPO/8grG4YLOkWj6IA39/yPayZVuRdyYPTIhVcL17IQRRFMAyDfl/0Q82ONQPycwXC+vXrPbbvu+++Uj0uKSkJtWrVwuXLlwEAaWlp2L9/P9q1a+fzHEnVwxsbyd7PCHawtksQ9PWUSYjcFOPMlL1fZDiIqjCFsiGEEEIIIf7msjqxf9Ze7J22Ey6L94nKSmKqFYJ6/Rqg1m11UTMpAbpIvQ+zJIQQQgghhBBCSsnq4zH1tpSi23LFBFltsbjATvJNPbdl1K1bF40aFX1puW3btgBmQwghVQvDAKNHy19k5nkGP/4Y2DdKQpQQrovAkoErUdNYukE6j94DrG4iH6P7cTFMr70I0IxJhJDqzumE8f13vIbZhgyDq217AIDVZcVX+6Z6fczzHV4Gx3Je4wgJBPuQ+yB6melCu3KZQtkQOWNbjUOENkI25njmMaw9+4tCGRFC5OgX/OA1hgrckKrOcfe9cHbo6DXO9PYbdF2CEEIICXI9J/dEh3EdbiikIIoiss9nw2ku+i5PFEVc2XEFGScz4DA7CuMKCjgU6PZqN3R6svoUYjKbzdi9e7fHvm7dupXqsQzD4JZbbvHY988///gqNVLF8YZErzGc+ZQCmRA5rDNL9n5RFQFQ4VVCCCGEkErPZXXiwLd7sajTXOz8aEu5CjDoInVo82QHDF//AMbseQy3/V9vNLgzkQowEEIIIYQQQghRjr6GtC74/jd1o++OnbkXcOYVbeviS4515hbdVhl9l0M50Lc4Xjz88MOFnQf27duH48ePBzolQgipMkaMcILj5DtiL16spr7apFpICKmFH+/+CeHacK+xPAuMGAZsrCcfp//hexg+ft8n+RFCSGWlWzAXqrNnZGNEjQbmN94u3F58bAGuWVJlH1M/rAGGNBrmkxwJ8QehZgKc3brLxmi2bgZ75bJCGZGShGhC8USbp7zGfbbrYwiioEBGhJCSsClXofljnWwMXzMBjl59FcqIkABhGOS/+6HXMPWuHdCs+dn/+RBCCCGkQu6adRcGfT8IKr3Ko6hCQWGF4gUWrr+/4D5RFMFpONz7w73o/WHvgPwcgXL69Gk4nUWDa2rVqoWYmJhSP759+/Ye28eOHfNZbqRq4/X1IDLyRYJVltMKZUNKwjoyZO8XNJEKZUIIIYQQQvzBmmHFnmk7sajTXGx56x9YrpnLfAyGY9BmfHs8sGssuk2+HdGtYj0+ixNCCCGEEEIIIYox1i26LYpA6t+A+ZJvjn1mTtFthvF8ruJEAbBfK9rWyxRrUAAVYfBiyJAhaNu2LQCp48C7774Lh8MR2KQIIaSKiIsT0acPLxtz9iyLHTtohmlSPTSJbIqFdy6DjtN5jbWrgEGjgF015eOMX3wK3eKFPsqQEEIqFyY3B8bP/s9rnPWxJyDUkT7E23k7pu/90utjnu/wMlSsqsI5EuJP9qHDvcZoV61QIBPizWOtx3stxnUs8wjWnf1VmYQIITelW7IIDC9/HcN2/4OAis4Rqhqz04yr+ck4l3MWxzKO4njmMaSYr8LqsgY6tYBxdUmC/e57vcaZ3nsHsNn8nxAhhBBCKqTdI+0w4cgEdHyyI1Q6VeFEFQWuL7oAoDCGYf+fvfuOb6L+wwD+XHabLlqgsvfeS0Bky95TZMtQZA9/TlRAhiLKBhVlgyIb2XvI3nvvTWkpHWn2/f6oFKvkLm2T63rer1deNMlz3zwVQ9Pk7nMCyvcsjwEXB6Bc93KpUT9VXb+eeABs4cKFk7R9oUKFJNcjckmlhcOngGREHXtFoTLkimCLkLxf1IYo1ISIiIiIPEUURTw6+gC7hm3Fwgo/4/C4v5I1fAEAclbPhY47uqLG13Wg89d7uCkRERERERFREmWtDuiyvLzutAJH+yHFZ9gOOwBc+zl++MKLtXI2fXU26grgsMR/LQiAMX/KHjuFuDeoDEEQMHXqVHTo0AFPnjzB6dOnMXToUEycOBF+fn6pXY+IKN3r3NmGLVukfxwtWaJFtWrSBzkQZRRVc1TDTw3n4d3NXWTPdByjB5p0BfbOA0qGuc75fTgEjpy5YKtTz8NtiYjSNt+pP0AVLnOWqaAgmIaOSLi+9OIiPIx9ILlN3oD8aFdE/uB2otRmad4Sfh8PhyAxTNKwYhniBg1VrhS9kr8uAO+XG4Bvj4yTzE05MQnNCrbgmU+IUoPDAcPiBZIRUaWKH8JA6dpj02PsvbsLxx8fxemwk7j1/CbCza5fU/pqfFEwqDCKZimG4sElUDG0Mqq8VhU+Gh8FW6eOmJGjoNuyUfK1hvrOLfj88hPiBg5RsBkRERElR1C+IDSb2Qx1R9fFlQ1XcHvPbdzdfxdR96Jgi7Ml5FQaFYzZjMhVNRcKNiiIos2KIjBvYCo2T103b95MdP2115J2JpYcOXIkuv7gwQNYLBbo9Tz4huQ5jEWhMV1zeb869qqCbehVVDJDGJzaYIWaEBEREVFKiE4RYWef4Nama7iy8hKibj9P0Xq+2Y14Y1QtFGlXnJ/9EhERERERUdqh0gC5WwM35r0cmPBwM3CgM1BtPqBOxmeYT/4C9rYE8M9BDiogb/tX558eTHw9qEzSH9ODOITBDaGhoViyZAn69u2LW7duYdeuXWjdujUGDhyI5s2bQ8MzmxERJdtbb9mRLZsTYWEql5k//9Rg/HjA31/BYkSpqEmBZvihznQM3TVANhvuCzTsBuz/Fcjn4rMdwW5HQK9uiPxzCxylSnu4LRFR2qS6ewc+P8+SzZmGfwQxKH5ao9VhxbQTP8huM7TiCGjV2hR3JPI2MTAI1gaNod+wzmVGc/E81BfOw1GylILN6FX6lumHH0/PxHNLpMvMmbBT2HlnG+rna6hcMSICAGj37IT67h3JjLVBIzhz5lKoEXmSxWHBqivLsfzK79h/fx9EuD+522Q34dzTMzj39EzCbXq1Hq+/Vg11876F1oXbIrd/Hm/UTnXOAgUR16cffGdNk8z5Tv4O5k5dIGbNqlAzIiIiSgnfrL4o36M8yvcon3Cb3WxH3LM4aH20MAQZUq9cGhT+ryGwSR3CkDVrVmg0GtjtdgCA0+lEZGQkQkNDPdYxOXQ6dao+flqn0aSR/z7+RYGwjS7v1piu8O8ylant0kMYBH0I/47SsDTzXCcir+HznChzSO5zPS7chPsH7uHW9pu4ueU6Yh/FpriLoBZQ/v2KqPZJDegDOHyPyFP4M50oc+BznSjj4/OcKI0oMwq48wfgML0cxHDnDyD8KFB+QvyQBpUbx1LE3AQufgdcmwOIjpdrCQJQ5APAmO/V293/e7/3F9ms1T31nSULpwfImDFjRsLXdevWxdKlS2G1WnHv3j18+umnGDNmDMqXL498+fIhMDAwRQMZBg4c6InKRETpilYLdOxox8yZOpcZk0nA6tVadO9uc5khymg6l+iG55bn+OrAZ7LZ+wFAm07xgxh87K/OqGKiEdilAyI37YAzR04PtyUiSnuM48dAsFgkM468+RH3bt+E6yuv/IH7Mfckt8ntlwcdi73jkY5ESjC36yg5hAEADKuWI5ZDGFJdgD4Q75ftj4lHx0vmfjj+HerlbcAzohApzGfBPNmMuVtP7xchj7I77Vh6cREmH/9O9nVgUlgcFuy7vwf77u/BmINfoHrOGmhf9G20LdIBRq3RY4+TFpiGfQjDsiVQ/evgw39SRUfB+N14xHwrP/CMiIiI0iaNQQP/HJyW/iomkynRdR8fnyRtLwgC9Hp9whAGAIiNTfmBPZQ5OPyKSt6vsjwCbM8BbaBCjejfBOtTyfudeg6rIyIiIkoLLFEWhF96ivCLT/H4+CPcP3QPz65ID9RKqvwNC6LW13UQXCzEo+sSEREREREReZQxD1BuHHB8aPwQhBfDE2JuAPs7AbosQGh9ILgiYMwf/zmUSgfYowFLOBB5Fnh6CIg4Er/ei2EKL/jmi1//VSzhwMMtLx9TpQOy1/b2dyyJQxhkzJgx45U7tQuCAFEUYTKZcPDgQRw8eDDFj8UhDESUWXXubJMcwgAAy5ZxCANlPh+UH4jnlmf44fh3stmTOYB+zYH5awBXh+OpH9xHQI93ELl2M5DEnQCJiNITzcnjMKz8QzYXO/IrQB9/ZgGH04FpJ+UPChtccTh0aunXLURpifWthnAGBkH1PNJlRr96BWI/+xJQqZQrRq/Ut2w/zD49A9HWKJeZo48O48CDv1AjV00FmxFlbqpHD6Hbukky48iZC9b6DRVqRJ5w6/lN9NvWCyeeHPf6Yx18sB8HH+zH1we/RI9SvdGrdF/k8MsYAxLFwCDE/u8z+H8yQjJnWDgPcb3eg6NYcYWaERERESnj30MY9Pqkn8nUYDAkGrzw7zWJXHEai8lm1LFX4QiqrEAbehXB5npgHQCIWh6AR0RERORNoijCEmVBzMMYxD6KQezjGETdj0Lso1jEPIpB7KNYRN1+juh7rj+fTamQkllRa2wd5KtXwGuPQURERERERORRxQYD5sfA+QkvBzEA8YMRLBHA3RXxFymiGP/nP7f1zQPU3wFoXZwA4OqPgMP88npofddZhXAIg5vEF3/hfxMEIWE4w7/vSw6evZCIMrMiRZx4/XU7jhxx/WPp6FE1bt0SkD9/yv/NJUpPPn59JJ5ZnmHeuV9kswvLA6/fBwYcdZ3RnjoJ/+GDED1rTuJJYkREGYUowjhqpGzMVqkKLK3aJlzfcGMdrkdek9wmpzEX3inRNcUViRRlMMDSohV8Fi9wGVHfvQPNkcOwV6uuYDF6lUB9EHqXfg9TTkySzP1w/DsOYSBSkGHpIggOh2TG3KU7oFYr1IhS6s/razFkZ3/E2KIVfdxISySmnvgeM09NRZcSPTCi8kd4zZhD0Q7eYO7+Lnzm/gzNlcsuM4LDAePokYhaKvPhGxEREVE6Y7FYEl3XarVJXkOnSzz01Ww2u0gSJeb0KyKbUcVc4RCG1CKKEKwyQxh0HMJARERElFKiKCLq9nM8OvEIEZfDEX03ClF3oxBzPwoxj2JhN6XOyb8C8gbi9Q+roWTn0lBpeEIEIiIiIiIiSmfKjQP02YDTn8UPRvj3MAY5/zxmTRSBrNWBN5YAfvldb1N0AFCoz8vrWr9kVfckDmFwk9SQhJQOUPDEEAciovSuSxeb5BAGAFi1Sovhw60KNSJKGwRBwISak/Dc8hyrri6XzQ9tDJR/BNS46zpjWPkH7KXKIG7gEA82JSJKG3SbNkB3cL9sLmb0+IRf7EVRxJQT38tuM7DCEOjVST+THVFqs7TtIDmEAQAMq/5ADIcwpAnvleuPn8/Mgsnu+qyX++7txtFHh1HltaoKNiPKpBwOGJYslIyIKlX8EAZKF5ZeXIShuwakage7044F53/FH5eXom+ZDzCo4lAE6oNStVOKaDSIHTUWgZ07SMb027dCu2sHbHXrK1SMiIiIyPv0+sTvF9psST+4x2pN/Pnnv9dMDVar9CA6Siz1/nsFwanNCpXtqcuEGHWZf5+pRLA9gyBK/7e3qbLw7ycd4d8VUcbH5zlR+iE6RdzffxfX113BzU3XYXoSm9qVEgTkC0SlYVVRtEMJqLVq2J0iwH9fiBTFn+lEmQOf60QZH5/nRGlA8aFAzqbA8SHAo60vhy+4c0z9i6whFCj5MVBsiPx2uqCUtPUKjlV0gyiKXr0QERHQooUdPj7S/yauWKFxa1ASUUajElSYXu9HNMjXSDZrVwOd2gMRPtI549dfQrtzm4caEhGlETYbjGO+kI1ZWrSG/fWXBy7vvLMN556ekdwmq082dCnZI8UViVKDrXoNOF6TPsu2ft1qIBkHCZDnZfXJiu6lesnmphyfpEAbItLt3gH13TuSGWuDRnDmzKVQI0qJDTf+xLBdA1O7RoI4exymnfwB1ZdWwvLLv6frzwus9RvCWruubM5v1OeAgx+SExERUcbh6+ub6LrFYknyGmazWXJNIil2Y1HJ+zWxVxRqQv+msobLZpy6rAo0ISIiIso4RKeI639ewbI6C7Gu3QqcX3AmzQxgyFkjNxrPb4nOh95Fic6lodaqU7sSERERERERUcoFFAXqbgKaXwFKfgQEVwYETfyQBVcXQyiQuzVQ4zeg9Z34YQ7uDG5Ig6RPOU64dOlSalcgIsoU/PyAJk3sWLVK6zJz7Zoap0+rUL68U8FmRGmDVq3FL40WosXqRjgTdkoyey8Q6NsCWPEH4OolqiCKCHivFyI374SjcBGP9yUiSg2GhXOhuXFdMiNqtYgZOSrRbVNOfC+79vtl+8NHIzPhhiitUqthadMevrOnu4yoIiKg270D1gaNFSxGrvQvPwhzz/4Mq9PqMrPt9hacDTuNMtnKKdiMKPMxLJwvmzF3f9f7RSjFzoadxoDtfSEi7Q06eBoXhgE73sPSi4swsfZkFMkifRBVmiQIiBk9Hlnq1YDgdP3enebiBRiWLoK5W0/luhERERF50b8HJsTFxSVpe1EU/zO4wWg0prgXZR4OYxEg8oDL+9UcwpBqBJsbQxi0IQo0ISIiIsoYnl2NwM7Bm/H4+KPUrpLAJ5svirYtjmKdSiFrqWypXYeIiIiIiIjIe/wLAeW/if/aYQGiLgGWcMD6DHBaAG0goMsC+OYBjHlSt6sHcQgDERGlGe3a2SSHMADAihValC+f9DPIEGUEPhofzGu8GA2W10KEOUIyu6ok8HMl4P3jrjOqqOcI6N4JkZt3QgwI9HBbIiJlCc8jYfxugmwurtd7cBYomHD90IMDOPzwoOQ2/roAvFu6T4o7EqUmS7sOkkMYAEC/8g8OYUgjXjPmQOcS3TD//K+SucnHJ2Fu40UKtSLKfFSPHkK3dZNkxpErN6z1GijUiJLrsekxum3sBJPd5PY2WpUWVXNUR+XQ11EkS1Hk8ssNX60vDBof2Jw2PLdE4pk5Ajcir+NSxEWcfXoaV55dTlHP/Q/2od4fNfBFtdHoU7YfVIIqRespzVGyFMxdusNn0XzJnHHC17C0aQfRz1+ZYkRERJnE6YWnU7vCK5XrnrGHB4aEJD6A+tGjpB0M9PTpU9jt9oTrKpUKWbJk8Ug3yhwcvtJD3NSm64DTDqi4i5jSVDbpz3MBQOQQBiIiIiK33Np6A1vfWw+7yS4f9jLfUCPyNyyIgs2KIHetvFBp0td7+UREREREREQpptYDWTL258Av8BM2IiJKM+rUcSAkxInwcNdvSq9apcGoURZo+BOMMqk8/nnxU4N5eHt9GzhF12eWBIBhjYGad4CSYa4zmmtX4f9BH0QtWgao+IEQEaVfvlN/gCpCeodGZ2AQTMP/l+i2KScmya7du/R7CNBzWA2lb/Yy5WAvUhSaq67PfKffvBHRMTGAn5+CzciVgRWGYvHFBbA7Xe9ItP7GWlyKuIjiwSUUbEaUeRiWLoLgcEhmzF26A2q1Qo0oOcx2M3puegcPYu+7lc9hzInBFYehXZGOCDIk7eC3x7GPsO/+Hmy8sR7bbm+GxZH0QaIWhwUj93+CLbc3Y1rdWcjlnzvJa6Sm2I8+h37VCqhiY1xmVE/D4DNtMkyffalgMyIiooxvTc81EAQhtWv8R0YfwlCgQIFE1x8+fJik7f+dz5kzJ/R6fYp7UebhMBaRvF8QbVCZb8PpW0ihRvSCYA2XvF8UNBA1AQq1ISIiIkq/rq27gu39NsJpl95XzltUGhWylcuOPHXzI3+jQshWJjsEVdr7/ZuIiIiIiIiIPI9H2hERUZqh1QKtW0tPKn76VIW9e3lwA2VutfPUxefVRsnm4rRAl3aATeYVn37bFvi6cfZ4IqK0SnXnNnx+niWbMw3/CGKW4ITrZ8JOYeed7ZLb+Gh80LfsBynuSJTqBAGWth2kIyYT9Fs2KlSI5OQNyIcORTvJ5qYe/16BNkSZkMMBw+IFkhFRpYK5czeFClFyiKKIobsG4PjjY27lu5fshYOdT6B3mfeTPIABAEKNr6F90bcxt/EinO95DZPrzEDJkNJJXgcA9t3bjbp/vIFttzYna/vUIoaGIm7IcNmc7+zpUN29o0AjIiKizEcUxTRzyQwKFiyY6Pq1a9eStP3169cl1yOSYzcWlc1oYl0PZiXvUdmeSt7v1IYAaXB4DhEREVFacnn5BWx7b4OiAxiMOfyQt15+vP7JG2i1ugN6XxuAdps64/WP3kD2cqEcwEBERERERESUiXAIAxERpSnt29tkM8uXaxVoQpS2DSg/GPXyviWbO/UaMK6W/HrG77+FbjMPuiSi9Mk4fjQEq1Uy48iXH3G9+ia6beqJH2TX7lqiB7L5ZktRP6K0wiwzhAEA9Cv/UKAJuWtwxWFQCdJv362+tgI3nl+XzBBR0ul274D63l3JjLVhYzhz5lKoESXH1BPfY9XV5W5lJ9T8DpPqTIGv1tcjjx2gD0SXkt2xq+N+rGz5J2rnrpvkNSItkeiysSMmHB4Dh9PhkV5KML0/AI5cuSUzgsUC47jRCjUiIiLKXARBSBOXzKJw4cLQal9+dnn//n08efLE7e1PnDiR6HqJEiU81o0yB6dPPoiCTjKjjr2qUBv6J5U1XPJ+UZdVoSZERERE6dOFRWewY+BmiE7PDvnTZzEguHgIctfOh2IdS6LCoCqo9W19tF7XEb2u9EeP0++h+e9tUXl4NeSqkQdaX+6vSkRERERERJRZaVK7ABER0T9VrOhEgQJO3Lzp+kCjTZs0iIkB/PwULEaUxqgEFabV+xF1l72BsDjpnfnG1RbQ8rKIig+l1/Qf8B4it+yCo3ARDzYlIvIuzYljMKxaIZuL+WI0oNcnXL/67ArWX18rvbZKg/7lB6e4I1Fa4SxQELZKlaE97vps4LpdOyA8fQoxK3cATgsKBRVB68Jtseqq63/nnKIT009MxuS6MxRsRpTxGRbMk82Yu/X0fhFKtvXX12H84TFuZQeUH4LeZd73Sg9BEFAzd23UzF0b++7twbhDo3DiyfEkrTH5+CQce3wMvzScjyyGYK/09CgfH8SOHIWAD/pIxgyrliOubz/YK1VRqBgREVHGJ4qePTCF5Pn5+aFy5co4ePBgwm0HDhxA69atZbcVRREHDhxIdFvdukkf3kWZnKCGw1gYmpgLLiPq2CsKFqIXBJv0EAanNkShJkRERETpz9lfT2Lfp7uSvJ3GV4OQElnhnycQ/rn9Yczpj8Bc/jDm8IMx1A/GUCOcqswzOJCIiIiIiIiIUoZDGIiIKE0RBKBdOxsmTdK7zJhMAjZv1qB9e7uCzYjSnuy+2TGj/k94e30byZxdENG9sy+OTzFBL3HiTFV0FAJ6dkbk5p0Q/fw93JaIyAtEEX5ffS4bs1V+HdYWrRPdNuPkFIiQ3im9Y9F3kMtf+gy+ROmNpW0HySEMgsMB/brVMPfqq2ArkjKk4oeSQxgAYNnlpRhR+WPk9s+jUCuijE318AF02zZLZhy5csNar4FCjSipTj05gQE73PtZ1jBfY4ysNsq7hf5WM3dtbGq3E6uuLseX+z+THar4T/vu7UaTlfWxtNlyFAwq7MWWnmFp0x62ObOhPSE9cMLvy88QuX5r/JuCRERElCJDbg5J7QqZVr169RINYVixYoVbQxgOHTqEe/fuJVzPmjUrypUr542KlME5fItIDmHQmDiEITWorDJDGHQcwkBERET0KidnHMXBMfvczusD9SjZvSwKtSiCrGWyQ6VOfAIwnU6d6LrVKrEDHRERERERERHRP3AIQwpFRETgxIkTOH/+PJ49e4bnz58jNjYWRqMRgYGByJIlC0qVKoWKFSsiODgdnKGKiCgNaN9eeggDAKxcqeUQBiIAdfPWxwflBmH26emSufP+Joxq7o8Ja6Mlc5orl+E/6ANEzV3EAyCIKM3TbVwP7eGDsrmY0eMS/Zt2L/oull/5XXIbAQIGVRya0opEaY65VTsYv/gUgtPpMmNYtZxDGNKQEiEl0bRAC2y8+afLjN1px4yTU/BNre8VbEaUcRmWLoLgkN4Bz9ylO6BWS2YoddyPvoeuG99GnD1ONlsiuCR+bPAr1Crl/i4FQUC7oh3xVr6GmHD4a8w794vscLAXbjy/jiYr62Ne4yV4I9ebXm6aQioVYkZPQJYWDSVj2qOHoftzDawtpQdMEhERkbygfEGpXSHTatasGSZPngyTyQQAOHr0KA4ePIjq1au73EYURcycOTPRbW3btoVKpXKxBZFrdmMRSH26ro7lEIbUoLI9lbxf1HI/MiIiIqJ/EkURx384jCPfHnB7m9K9yqHqpzWgDzR4sRkRERERERERIeYmEHEciLoM2J7HX5y2FCwoANV+9Vg9b+EQhmSwWq1Yu3YtFi9ejCtX3P+gslixYujWrRtatGgBnU7nxYZEROlbwYIiKlVy4Phx1zvA79mjRmQkEBSkWC2iNOuzal9i193tuBRxUTI3sUIsWp/Wouot6Re5+g3r4DPtB8QNGeHJmkREnmW1wjjmC9mYuWUb2KtUTXTbrFPTYHdKD3NqWagNCgUVSVFForRIzJ4dtlp1oNu902VGe+QQVHduw5k3n4LNSMqwSh9KDmEAgCUXF2JYpf8h1PiaQq2IMiiHA4YlCyUjokoFc+duChWipIixRqPLxo54Ynosmw0xhGBR02Xw0/kr0Oy/AvVB+KbW92heqBUG7eiH+zH35DcC8MzyDB3+bIXv60xDp+JdvNwyZexVq8Hcsg0M61ZL5vzGfIWIhk0AA3eSJSIiovQpJCQEXbp0wZw5cxJuGzlyJJYuXYrQ0NBXbvPTTz/h6NGjCdf9/f3Ru3dvr3eljMlhLCp5v8oWAcEaDlEXolAjAgDBGi55v1OXVaEmRERERGmfKIo4PH4/Tkw94vY2VT9/E5WGvO7FVkRERERERESZnC0auDobuP4rEHPNc+uKYvxJNtPBEAaO0E+inTt3om7duvjyyy9x+fJliKLo9uXSpUsYOXIk6tWrh127dqX2t0JElKa1by99kLjdLmDTJs4SIgIAvVqP6fV+hFqQPnOnE0707J0VFjdO8GkcPwbands91JCIyPN8fvkJmps3JDOiVovYkaMS3RZmCsPiCwtk1x9caXhK6hGlaeZ2HWUz+tUrFGhC7iqXvQLq520gmbE4LJh9eoZCjYgyLt2u7VDfuyuZsTZsDGfOXAo1Inc5nA68v60XLoSfk81qVVrMa7IUeQNSf+DQm7lqYc/bB9GhaCe3t7E5bRi88wNMOT4Joih6sV3KxY4cBVFmKLX6zi34/PKTQo2IiIgoMzp+/DgOHDjwn8v58+cT5SwWyytzBw4cwLVr0jsV9enTB9myZUu4fu/ePbzzzjvYsWNHotdsjx49wpdffonJkycn2r5fv34I4vR5SiaHr/QQBgBQm64q0IT+SWWLkLzfqeVQDCIiIiIgfgDD/i92J2kAQ42v63AAAxEREREREZE3PdwKbCgFnP4UiL4aPzjBE5d0RhDT+h56aYQoihg3bhyWLFmS6ANyQRCStMY/t+vSpQtGjhzp0Z5ESREWFp3aFdI0nS7xUcpWqyOVmmROT54IKFvWCKfT9b+z9erZ8fvvcQq2oowoIz3XvzkyFj8cmyibGxlZEV9POSGbcwYF4dnWPXDmL+CJekSpJiM9zymeEBaG4GoVoIqOksyZ+g1E7JjxiW4bd2g0pp74XnK7t/I2xNLmPAA9veFz3X1CdBRCShWGYDa7zNhLlMSzPYcUbEVyjjw8jOarpQcx+GqMON7tHEJ8Mu4O3Hyuk7cFdH8H+s0bJDPPl/wBa4PGCjXKfJL7PB/518f4+cxst7JT687COyW6Jrmbty29uAif7B0Bs8P1z+h/619+ML6q/nWSPqtQmnH0F/CdOVUy4/QPQMThUxCz8kywmQV/pidPtmz+qV2BiChdqlevHu7fv5+iNdq0aYNvvvlGMnP06FH07t0bFosl0e0BAQHInTs3oqKi8PDhQzgciX/u1a9fHzNnzkxTr+m4L4G0tPZaRrBHI+su6WGB0SVnwJyru0KNCE4bsu2Qfo8uqvSvsOTooFAhSo609lwnIs/j85wo9TkdTuz9aAcuLDrr9ja1vq2P0u+WczvP5zpRxsfnOVHmwOc6UcbH53nycD8C8op7fwJ/tQdEe/zgBE9/jvlizXfS/vNcldoF0ovx48dj8eLFEEURgiAkXID44QruXP65nSiKWLJkCcaPHy/zyEREmVP27CLeeEP6B+nevWo8e6ZQIaJ0YHilj1AqpIxs7tvgszhdr6xsThUZicCeXYDYWE/UIyLyGOM3Y2UHMDiDgmAa9mGi255bIjH33BzZ9YdU+lA2Q5Seif4BsDRqKpnRXLwA9Xn5M4mTcl7PURU1ctaUzJjssZhz1r0DkInov1QPH0C3bbNkxpErN6z1pAeikPJ+Pfuz2wMYBlcYniYHMABA5xLdsKHdduQLyO/2NrNOTcPw3YPgcKbdD6RMQ0fAGSJ98JEqOgrG7/h5CREREaVvVapUwU8//YSgoKBEt0dFReHChQu4d+/efwYwNG/eHFOmTElTAxgo/RE1/nDoc0pm1LFXFGpDACDY5HdkcOoy7iBVIiIiInc4bA5s77/J/QEMAlB3asMkDWAgIiIiIiIioiQy3QP2dwKctvjrLz7HFMWXF7UvYMgB+OZN3sWYL/7PdECT2gXSg2XLlmHRokWJPvQWRREAUKRIETRq1AhlypRB4cKFERgYCB8fH8TFxSEqKgrXrl3D2bNnsXnzZly9ejVhjReDGBYtWoTChQujY8eOqfK9ERGlZS1b2vHXX65/VNntAjZt0qBzZ7uCrYjSLp1ah+n1f0SjFXVge/Fi9xVsThvea6PBX+dDoX38WHJNzYVz8B8xCNGzf/X85DIiomRQnz0Dw+L5sjnTiI8hZglOdNu8c78g2io9vKFajjdQNUe1lFQkShcsbTvAsHaVZMawajliS5VWqBG5Y1jl/2H/un2SmV/P/oyB5YfAT8fpxkRJZVi6CIJD+kB2c5fugFotmSFlbb+9BZ//9ZFb2eYFW+Gzal96uVHKlMlaFlva70Kvzd1w4MFfbm2z5OJCPLc8x+wGv0Cv1nu5YdKJgUGI/d9n8P9khGTOsHAe4t7tC0fxEgo1IyIiIvK86tWrY8OGDZgxYwbWrFmDuLi4V+ZKliyJDz74AA0bNlS4IWVUDmMRqC0PXN7PIQzKUtmeymZELYcwEBERUeZlj7NhS5/1uL3tplt5QS3grZlNUKRtcS83IyIiIiIiIsrkznwJOOISD18QBCBvR6BAVyDkdcCQPXU7KkgQX0wToFeKiYlBgwYNEBkZmXCbKIooWrQovvjiC1SpUsXttY4dO4avv/4aly9fThjGIIoismTJgm3btsHPz8/T9YkkhYVFp3aFNE2nS7xDvdWads8ml1GFhQkoU8YIp9P1gd9169qxbNmrd14ickdGfK5/f+xbfHtknGzuu3yDMOK9HyHYXA9seCFmzHjE9RvoiXpEisuIz/NMSxQR2KYZdAekD0azFyqMZ3sOATpdwm0mmwmVFpVCuDlcctvfm69Evbw8u3V6xOd6ElksCCldBKrnkS4jjly5EXH8HKBSKdeLJImiiKar3sLxx0clc19VH4sBFQYr1EpZfK6T1zgcCK5SFup7d11GRJUKEScvwJlD+uyilDJJeZ6feHwMbdc2h8lukl23fLYKWNN6E3y1vinuqASrw4oP9wzB75eWuL1No/xN8EujhWlyEAPsdmSpUx2aK5clY9badfH8jzUcBJkJ8Gd68mTLxkFbRETpidlsxsmTJ3H9+nVERUVBq9UiNDQU5cqVQ758+VK7niTuSyAtLb6W8bs4HD73fnF5v92nIJ69eUq5QpmcNmIfgo43k8yE17wIpyGXQo0oOdLic52IPIvPc6LUYY22YGO3tXhw4J5beZVWhQY/NUOh5kWS9Xh8rhNlfHyeE2UOfK4TZXx8nicP9yMgj3LagBXBgOPv/fFEEdCHALXWANlqpGq11MK96GXMnz8fz549AxC/ozsAtGzZEqtXr07SAAYAqFy5MlatWoXWrVvjn7MvIiMjMX/+fI91JiLKKLJlE1GjhvSL5r171YiIUKgQUToxqMIwlAguJZsb/WA+Ln/9mVtrGkd/Ae1fe1NajYgoRXTr18kOYACA2DHjEw1gAIAlFxfIDmAok7Uc6uZ5K0UdidINvR6Wlq0lI+r796A9ckiZPuQWQRAwrNKHsrkfT8+AxWFRoBFRxqHbtV1yAAMAWBs25gCGNORG5DV02dDBrQEMufxyY1HTZelmAAMA6NQ6TK07CyOrjXJ7my23NqHPlu6wOqzeK5ZcGg1iR42Vjen27IJu62YFChERERF5n8FgQPXq1dG1a1f0798fffv2RcuWLdP8AAZKn+zGopL3q823ASffL1KKYJP+PAIAnNpgBZoQERERpS3miDisa7/C7QEMar0aTRa0TPYABiIiIiIiIiJKgrADgD02/mtRjD+RTs2VmXYAAwBoUrtAWrdlyxYIggBRFCEIAmrXro2JEycmez21Wo1vvvkGkZGR2L17d8LaW7ZswcCBPLs0EdG/tWplx759rn9cORwCNm7UomtXm4KtiNI2nVqHH+pOQ9OVb0GE6DIXY4vG0JxHsKpzV/guXSy5puBwIKBvDzzbthfO3Hk8XZmISJ7ZDL/RI2Vj1rr1YX2rUeLbHFbMPDlNdtuhlUZA4Bl3KROxtO0An0XzJTP6FX/AVu0NZQqRWxrka4wSwaVwMeK8y8xj0yMsu7QU3Uu9q2AzovTNsHC+bMbcnc+ptOKJ6Qk6rm8rO2QLAIxaPyxu+gdCja8p0MyzBEHA4IrDkdc/HwbseA82p/z7Xy8GMfzSaCF0ap1sXknW+g1hrV0Xuj27JHPGLz+FtU49QK9XqBkREVHms7bXWq+tLagF6AP0MAQa4BPsg+ylsyNn5ZzQ+aWt1yZEGY1DZgiDIDqgNt2Ew6+4Qo0yN5VV+vdVUW0E1D4KtSEiIiJKG2IfxeDPjisRcUn+vX0A0Pho0GRhK+SpzUF2RERERERERIqIufHya0EAQusD2WulXp80gEMYJDx+/BhXr15NOAhHp9Nh9OjRHll79OjRaNiwIazW+DNSXbt2DY8fP0ZoaKhH1iciyiiaNrXj449FOByuD4hcu1bDIQxE/1IptAr6lu2Hn8/Mlsxtub0JS9+bgx4XL0B78oRkVhUejoBeXRG5bgtgMHiyLhGRLJ+fZkJ957ZkRlSrEfP1N/G/8P/DiivL8CD2vuS2hYOKoGmBFinuSZSe2KrXgCNHTqgfPnCZ0f+5GjHjJwI6HiiRVsQfkDsMH2zvI5mbcXIKOpfoBo2Kb/8RyVE9fADdts2SGUfuPLDWfUuhRiQlxhqNzhva407ULdmsSlBhTsN5KJW1tPeLeVHrIu0QoA/Au5u7Is4eJ5vffGsj+mztgV8aLkhbgxgEATGjxyNLvRoQnE6XMc3NG/D55SfEDRisYDkiIqLM5dT8U4oOIxVUAkLLhaLS+5VQtktZaH21ij02UWYhN4QBANSxVziEQSEqm/SBhU5tiEJNiIiIiNKGqNvPsa79CkTdfu5WXuevQ9MlrZGzWm4vNyMiIiIiIiKiBJan8X+KYvwxGTkapm6fNECV2gXSsgsXLiR8LQgC3nzzTY8NSQgNDUXNmjUhii/PTv3PxyMionhZs4qoUcMhmfnrLzXCw3nWaqJ/+6TqF8jtl0c29/mRkbj302w4s2aVzWpPnYTfx8PjX1ATESlE9eghjJMnyebievWFo2ixRLc5nA5MO/GD7LaDKw6HWqVOdkeidEmlgqVNe+nIs2fQ7d6hUCFyV6vCbZEvIL9k5lbUTfx5fY0ifYjSO8PSRRAc0u89mLt0B9R8rZDarA4rem3phjNhp9zKj63xDd7K18i7pRRSL28D/NFiLQJ0gW7lN9/cgAHb34PDKf3/ttIcJUvB3P1d2ZzvDxMhPHmiQCMiIqLMTRRFRS5OhxMPTzzEhn4bMDnPZJz7/Vxqf+tEGY5TnxOi2iiZ0ZiuKNSGBOtTyfudOg5hICIioswj7OwTrGz6m9sDGAwhPmi1ugMHMBAREREREREp7l/HivnKH5OW0XEIg4Tw8Pip5C8GJVSpUsWj61euXPmVj0dERIm1amWXvN/hELBxI8/uSvRvflo/fFd7smzuiekxxt39FVG/LIToxkFFPr8thmH+r56oSETkFuO40RBMsZIZZ5YsMH34yX9uX39jLW48vy65bW6/PGhXpGOKOhKlV+Z28v/v61f+oUATSgqNSoOBFYbK5qadmJxoACgRvYLDAcOShZIRUa2GuXM3hQqRK6IoYtiugdh9d6db+f7lB6NP2X5ebqWsqjmqYU3rjcjqk82t/Nrrq/DR3mFp7mdB7Mcj4QwMksyooqNg/OZrZQoRERFlYoIgJPo6pRepdYD413Rxz+Kwqssq/Pn+n6nyPRNlWIIKdt/CkhF1LIcwKEVlk94HTNRyCAMRERFlDvf23sGaVn8gLszkVt74mhGt13ZEtrKeOWkiERERERERESWBIXvi607pYzozAw5hkBAREZHoevbs2V0kk+fFei92OHj27JlH1yciyiiaNrVDrZbeWXzdOg5hIHqV+vkaom2RDrK5eed+wbHCRsSOGuvWun6ffwTN4UMprUdEJEtz8jgMy5bK5mI/+hxiluBEt4miiKknfpDddkCFwdCqtcnuSJSeOUqXgb1oMcmMfvNGICZGoUbkrreLdUZ2X+mdj86Hn8WOO1sVakSUPul2boP63l3JjLVBYzhz5FSoEb2KKIr48sBnWH7ld7fybYt0wJfVx3i5VeoonbUMVrfa4PYghkUX5mPsoVHeLZVEYkgITB9+LJszLFkIzdnTCjQiIiLKfALzBiZcgvIFQaPXJBrcJIpiwkWlUcEnxAf+Of2h89P95/5/8gv1Q2DeQPjn9IfGR5Mo98+BDKIo4uQvJ7F71G4lv22iDM9hLCJ5P4cwKEduCINTxyEMRERElPFdXX0J699ZBVuM1a18QP5AtPmzE4KL8rUSERERERERUaoIKhP/54th/uZHqdcljeARqxL0en2i62az2aPrWywWAEjY4UCr5UE/RESvEhIiomZNB3bvdv1ja/9+NZ4/BwIDFSxGlE6MffNb7L67AxHmCJcZp+jE//YMxaY+O6A5dRIGmTNeC3Y7Anp3Q+T2vXC+lsPTlYmI4oki/EZ+IhuzFy8Bc49e/7l9551tOPf0jOS2WX2yoXOJ7smuSJTuCQIsbTtA843rQUxCXBz0m9bD0qGTgsVIjkFjQL9yAzHm4BeSuaknfsBb+Rop1Ioo/TEsmCubMXfv6f0iJGnSsW/w0+mZbmVr5q6DafVmQyVk3BnUxYKLY3WrDWizthmexoXJ5qefnIxAfRAGVxymQDv3xPV6D4aF86C56vogMEEUYRz5CZ6v2fjygz0iIiLyiKG3hgIAHDYHtgzfgmOzjiUMRzAEGVDq7VIo2rwoclTIAf+c/om2ddgceHL2Ce4duoezS87i7sG7CSee0Pnp0HpBa+R5Iw8AwBpjxb1D93Bl/RWcnHsS1hhrokEMe7/ei4INCiJvjbyKfv9EGZXDt6jk/WrTNUAU+fpaAYLV9eeyAODU8sBCIiIiythO/3QC+7/Y7XY+uHgIWixvB2Oon/dKEREREREREZG0LBUBQyhgeRJ//cleoMSI1O2UyjLuXogeEBwcfxbVFzsM3L9/36Pr/3u9kBB+wEZE5ErLlnbJ++12Adu2cbYQ0atk9cmK0W+Ml82dCjuJBRfnIfr7abCVLiubVz95jIDe3QGre9PKiYiSSv/Hb9AePSybi/n6G0Dz39cBU058L7ttv3ID4KPxSVY/oozC3LaDbEa/arkCTSipepbqhUB9kGTm8MODOPTggDKFiNIZ1d070G3bIplx5M4Da923FGpErzL71Ax8d3SCW9nSWctifuPF0Kl1Xm6V+ooFF8eqVuuR1SerW/mxh77CwvPzvNwqCbRaxI6Rf69Cd3A/dH+u8X4fIiKiTMhutmNxw8U4NusYAEBQCag+vDqG3R2G5rObo2izov8ZwAAAaq0aOSrmQJX+VdBrfy+8u/ddZC2RFaIo4tmNZ1hYfyEurbkEIH4oQ8G3CqLxlMYYensoijYrClEUE9Z6MYiBiDzDYZQewqCyR0FlfaxQm8xNZXsqeb+oc+93OSIiIqL0RnSKODhmb5IGMGSv+Bpar+nIAQxEREREREREqU0QgMLvxQ/1FkXg8Q4gLnN/tsQhDBKyZ8+e8LUoiti1a5dH19+5c2fCgAcAyJYtm0fXJyLKSBo3tkOlEiUzmzZxCAORKx2LvYM3cr4pmxt3aDQeIxpR8xbDmSWLbF579DD8Rn7siYpERIkIzyPhN1r67O4AYGncFLbadf9z+6EHB3D44UHJbQN0gehZqneyOxJlFM78BWCrVEUyo9u9E0KY/Jm2SVl+On/0Lt1XNjfVjaE0RJmRYckCCKL0ew3mLt0BtVqhRvRvC8/Nx1cHPnMrm9c/H35rtgL+ugAvt0o7igeXwMqW6xFicG/A8//2DMW6a6u93Mp91voNYanfQDbnN/oLIC5OgUZERESZy5qea3Brzy2IogiVRoV2v7VDw0kNoTMmbaBV3jfzos/hPshXKx9EUYTdYsfKzivx8OTDRDmfLD545893ULxVcYiimLCvxI1tN/D0kvTBykTkHrvMEAYAUMdeUaAJqazhkvc7tTxRDxEREWU8drMd2/tvxMkZx9zeJmeN3Gi5oj0MwTx5BhEREREREVGaUOJDwDdX/EAGRxxw+pPUbpSqOIRBQrly5aDTvdzB4OLFi9i/f79H1j548CAuXLiQcF2n06F8+fIeWZuIKCPKmlVE1aoOycyOHRruj03kgiAI+LbWD9CopIeVRFuj8NX+z+DMlx9RP86FqJJ/uegz/1cYli7yVFUiIgCA78TxUD2VPuBb1GoRO2rsK++bcmKS7GP0LtMXAfrAZPUjymjM7TtK3i84HNCvSzsHbdJLfcp+AB+N9E5JO+5sw9mnZxRqRJRO2GwwLF4oGRHVapi79lCoEP3bqssrMGT7QLeywYZg/N58FUKNr3m5VdpTIqQklrVY7dbwCREiBux4D4dkhpUpKXbMBIga6fcq1HfvwPfHGQo1IiIiyhyubLiC83+cBxD/+UHtr2qjZPuSyV5PZ9Sh09pO8Av1gyAIsJvt+LPvn6/Mtl7YGj7/OrjmxvYbyX5sInrJ4VsIIgTJDIcwKMBhguCU3nGBQxiIiIgoo4l7asK6ditwddVlt7cp2LwImv/WFjq/pA0DJCIiIiIiIiIv0voDbywFBG389ZsLgfMTUrdTKuIQBgkGgwFVqlRJOAuDKIr44osv8OTJkxStGxYWhi+++CJhTUEQULlyZRgMBg81JyLKmJo2tUvebzIJ2LePZ6ckcqVYcHEMKD9ENrfq6nLsvbcbtrr1EfvZl26t7ffRMGhOHk9pRSIiAID63Fn4/PqzbC6u7wdwFCz8n9vPhJ3CzjvbJbf10figb9n+ye5IlNFYWraFKHOmd8Oq5Qq1oaTI6pMVXUvIHyQ+/cQPCrQhSj90mzdC/eSxZMbapDmcoZnvoP60YMvNzXhvS2+IEGWzvhpfLGq6DIWzFFGgWdpUNlt5LG66DAa1/GcMFocF3Te+jWvPrirQTJ6jSFHE9X5PNuc79XuoHj5QoBEREVHmsP/blyef8HvNDzU+qpHiNQ2BBtT8vCZEMf413KOTj145XEHvr0flfpUT9pUAgNt7b6f48YkIgNoHTkNe6QiHMHidyhoumxF1HMJAREREGUfElXCsbPwbHh11/z3c0r3KoeGcZtAYpIf0EhEREREREVEqyF4TqLkCUOkBUQTOjAT+6gjE3EztZorjEAYZ7du3T/haEAQ8ePAAXbt2xeXL7k/q/KcrV66ga9euuHfvXqLbO3TokKKeRESZQePG0kMYAGDjRr4pTyRlWKX/Ia9/Ptncx3uHw+KwIG7QMFhatJbNC1YrAt7tCiFM+qz1RESyRBH+n4yA4HRKxhzZQ2Ea8dEr75vqxoHGXUv0QFafrMmqSJQRidmywVa7rmRGe/QwVLdvKVOIkuSD8oOgUUn/LrTu+hrceH5doUZEaZ/PgrmymbgevRRoQv+2+85O9FjfBXan/PtAOpUO85ssRZXXqirQLG2rnrMGfm20UPbnAQBEWiLRaUM7PDGlbOC0p5hGfAxncLBkRjCZYBw7SplCREREGVzMoxjc3X8XgiBAEAQUa1UMKo1ndh0p2aFkwroAcGHlhVfmircunvC1KIoIvyx/wDIRucdhlB5QpzGljYFsGZnKJv9vmlPLIQxERESUMdzdcxurmv6OqDvP3d6m6mc1UHNCPajUPIyBiIiIiIiIKM15sjf+og0Ayk0A1Ib4QQx3VwJ/FgV2NgLOjwfuLAce7XiZT84lHeC7FzKaNGmC0qVLJ1wXBAF37txBu3btMHbsWFy/7t7O69evX8fYsWPRtm1b3LlzB4IgJJzZoXTp0mjcuLG3vgUiogwjXz4RpUo5JDNbtmjgkI4QZWq+Wl+MrzlRNnc98hpmnJwCCAKip86EvVhx2W3UD+4j4L2egF3+QBkiIlf0f/wG7ZFDsrnY0eMg+gf85/arz65g/fW1kttqVBr0Lz842R2JMipzW/kBkYbVKxRoQkmV2z8P2hd9WzLjFJ2YeXKqQo2I0jb1jWvQ7d0lmbEXKAhbzdoKNaIX9t7bjU5rO8DsMMtm1YIaPzWchzp56inQLH1okL8xZtT/CQIE2eydqFvouqEDYm2xCjSTJgZlQezHI2VzhuW/Q3P8qAKNiIiIMrb7R+9DFMWE69nLZPfY2n6hfvDN5gsgfrjC/cP3X5l7rfxr0OhfDo8yhZs81oEos7Mbi0rer47lEAZvE6xPZTNOHYdEExERUfp3YdEZrO+0CtYoi1t5QS2g7pSGqDS0asLwPiIiIiIiIiJKY7bXAXbUjb+cHA44LYAgxA9iEB3A4+3AmS+A/Z2AXQ1fZpN8SR/7/XEIgxvGjBkDg8GQcF0QBNjtdixZsgTNmzdHs2bN8PHHH+Pnn3/Gb7/9hjVr1uC3337Dzz//jI8//hjNmjVD8+bNsWTJEtj/dVCij48PxowZo/S3RESUbjVtKn1wd3i4CkeOqBVqQ5Q+NczfBE0KNJfNTTk+CTef34Do54+o+UvgfMXBzv+m278PxtFfeKImEWVCwvNI+Lnxb4j1jTdhcXGw+PSTkyFCfOV9L3Qs+g5y+edOVkeijMzatDlEHx/JjH7lH/FvolGaM6jCMNmDbpddWopHsQ8VakSUdhkWzpfNmLv3AlR8+1xJf93fi24b33ZrAAMATK03C80KtvByq/SnbZEO+LbWD25lT4WdxHtbe8LuTP1hiuZuPWEvUVI25zfyY8DpVKARERFRxhV5MxIAEgYxGLMZPVwDsKkAAQAASURBVLq+b1bfl491K/KVGZVGlShnfubea0AikueQG8JgvgM4OPjEm1S2cMn7RQgQNUHKlCEiIiLyAofNgb9G7sLuEdshOtz77Fjjo0GTBa1QonNp+TARERERERERpT5RTHwRhH8MY/DAReaYj7SCe5G6oWTJkpg6dSrU6pcH9QqCAFEUIYoirl+/jnXr1mHy5MkYM2YMPv30U4wZMwaTJ0/GunXrcP369YTsi8mdoihCo9FgypQpKFGiRGp9a0RE6U6TJvI7hW/cqJHNEGV24978Fr4aX8mMxWHBp/s+hCiKcBQqgujZc9xa2/enmfEHaBIRJZHvxPFQPQ2TzIhqNWImTIr/Bf5f7kbfwYoryyS3FyBgUMWhKalJlGGJfv6wNGoimdFcvgT1+XMKNaKkKJKlKJrKHIxsdVox+9QMhRoRpVFmMwy/L5aMiDodzJ26KFSIAGD//X3osqED4uxxbuW/qfU9OhZ7x8ut0q+epXvjw8qfuJXddnsLPtn7YaKzYacKjQYxX38jG9MePwb9H78pUIiIiCjjssZYE12Pe+beazB3mSNfDlT492P9kyHo5YkwnHYOWSLyFIev9BAGAFCbrinQJPOSHcKgDQJU3KeBiIiI0qe4pyb82XElzvx80u1tfLL6oOXK9sjfsKAXmxERERERERGRR70YuvDi4ur25FzSEQ5hcFOtWrXwyy+/IHv27Ak7IwqCkHB5MWThVZd/5oD4AQyhoaH49ddfUatWrdT8toiI0p1SpZzIm1d6R6xNmzQ8OS+RjNz+efC/Kp/J5nbe2Y4ttzYBAKwNmyD2f5+6tb7/8EFQnz2Too5ElLmoz52Fz68/y+bi+vSDw8UZcmedmiZ7Ft+WhdqgUFCRZHUkygwsbTvKZgwctpRmDak4XDaz4PxcPDNHKNCGKG3Sr18LVYT0c8DSojXEkBCFGtGB+38laQDDyGqj0Kt0Xy+3Sv/+V+VTvFO8q1vZhRfmYtqJH7zcSJ6tVh1YmjSXzfl9/RWEqOcKNCIiIsqYDFnihx+82H8h/Ir0wcJJYYmyIPZxbMJ1nyw+LrN2y8v38TQ+PBiZyFPsRvkhDJrYKwo0ybwEq/S/q04t33MgIiKi9CnszGMsb7gED/bfc3ubLMVC0G5TZ7xWOacXmxERERERERGRR4midy/pCD/JToJq1aph7dq1+P7777Fu3TpYLBYASDRgwZUXgxv0ej1atWqFESNGIDAw0OudiYgyGkEAmjSx46efdC4zd+6ocP68CqVL86w5RFLeK/sB/ri8FBcjLkjmRu7/BLXz1IWPxgemER9Dc+YU9Fs2SW4jxMUh8N2ueLZtN8QswZ6sTUQZkdMJ/08/hOCU/tntyB4K00evHgbzxPQESy4slH2owZXkD1Amysys9d6CMygIqshIlxn96hWI/WI0oOJsz7SmfPaKqJ27Lvbc2+UyY7LH4tezP+PDKu6dIZ0oo/GZ/6tsJq5HbwWaEAAcfLAfnTe0h8lucis/uMJwDHZj4AzFf24xqfZUPIi5L/lz4YVxh0cjt38etCsqP5DJm2JGjYVux1YIVtdnzVaFPYHvpG8RO2a8gs2IiIgyDv+c/glfi6KIy2suo+F3DT2y9uV1l+F0OBP2n/DL4ecya440J3xtCDJ45PGJCBB12eDUBEJldz24TM0hDF6lkhnCIOqyKtSEiIiIyHMuL7+A3SO2wWF2uL1N7tr50OiXZtAH8nc+IiIiIiIionSjvvy+ZpkJ95ZPoqCgIHz99dfYvXs3hg8fjmrVqsFgMEAURZcXHx8fVKtWDR9++CF2796NMWPGcAADEVEKNG0qfYZrANi4kXOGiORo1VpMrD1FNncn6hZmnpwaf0WlQvTMn2EvWEh2O/WdWwh4vxfgcP/DNyLKnAy/LYb28EHZXOyosRD9A15535wzs2F2mF953wtv5W2IMlnLJqsjUaah08HSoo1kRP3gvlvPWUodQyqNkM3MOTMbMbYYBdoQpS3qC+ehPXJIMmMvXgL2qtUUapS5HXpwAO+sd38Aw3tlP8Dn1b7ycquMRavWYm7jRSgVUsat/NBdA3Di8TEvt5LmLFAQce/1l835/PIj1FcuK9CIiIgo48lRMUei689uPMPJuSdTvK7D6sCeMXsgCAJEUYQgCMjp4kyncc/iYHoa/zpQEAQE5uX+E0QeIwhwGItIRtSxVxUqkzmpbNJDGJzaEIWaEBEREaWc3WzHno92YMeAzUkawFCye1k0W9qaAxiIiIiIiIiI0pvQ2spd0gEOYUimLFmy4L333sP8+fNx/PhxbNiwAYsXL8bMmTMxceJEzJw5E4sXL8aGDRtw7NgxzJ8/H3369EGWLFlSuzoRUbr3+usOhIRInyl782YOYSByR9Uc1dC5eDfZ3LQTP+BO1G0AgBgQiKj5SyH6GmW30+3eCeOEr1Pck4gyLiEsDMbRI2Vz1uo1YGn36rPyPrdEYu65ObJrDKn0YZL7EWVGlvbyZ8DWr/hDgSaUHDVy1kSl0MqSmWeWZ1h8Yb4yhYjSEJ+Fc2UzcT16AX+ftZe859CDA+i0vh1M9li38n3L9MPXNb5JOKMyuc9fF4ClzZYjpzGXbNbisKDHps54GPNAgWaumYb/D47Q1yQzgt0Ov88+AkRRoVZEREQZR2CeQOSqEv/a4MXAhC3Dt+De4XvJXlMURazrvQ4R1yIS3V6iXYlX5h+ffpzoenCh4GQ/NhH9l8O3qOT9ahOHMHiTYH0qeb9Ty3/ziIiIKH2IvP4MK5v8hvPzT7u/kQC8Mbo2an9XH2qt2nvliIiIiIiIiIgUwCEMHqBSqVCoUCFUrlwZ9evXR8uWLVG/fn1UrlwZhQoVgkrF/8xERJ6kVgONGtklM+fOqfHwIXfMJ3LHyOqjEagPksyYHWZ8deDzhOuO4iUQNf1Ht9b3nfYDdH+uTUlFIsrA/L74BKrISMmMqFYjZsIklwdEzjv3C6KtUZJrVM9ZA1Vz8KzWRO6wVa0OR07pAzX1f64GrFaFGlFSCIKAwRVHyOZmn5oBi8OiQCOiNCImBvo/fpeMiL6+sHTopFChzCupAxj6lHkfY9/8lgMYUiCHX0781nwlAnTyZ5h+bHqEHpveQZw9ToFmryb6+SP2yzGyOd3eXdBt+FOBRkRERBlP5Q8qQ/x7mJEgCLBEWbC44WIcn3M8yWtF3o7E0qZLcXbp2YTXbIIgILhIMAo1LPTKba5tuQYACR1yvp4zOd8GEblgN0oPYdDEXgVE6ZMeUPKpbNJDGERdNoWaEBERESXflRUX8Uf9xQg/H+b2NlqjFk3mt0T5DyrxPX0iIiIiIiIiyhA4HYCIiNKlJk2khzAAwPbtGgWaEKV/WX2y4pPX5c9Cv+HGOuy+uzPhurVFK5gGD3frMfwHfwD15UvJ7khEGZN21w4YVi2XzcX1eR+OkqVeeZ/JZsJPp2fKrjHEjQOSiehvKhUsbdpLRyIjodu5XaFClFSN8jdBsSzFJTMPYx9g5ZU/FGpElPoMa1ZCFRMtmTG37QAxQP4gdUq+pA5g6FvufYx7cyJ31vSAEiElMa/xYmhVWtnsqbCTGLqzf8JBkanB0v5t2F6XH6Lm99VngMmkQCMiIqKMpXzP8shbI2/iQQzRFmzotwGzSs/Cge8PIOximMvXA+bnZlzbcg1reqzBrJKzcH3r9YTsiz+bzmwKlfrVu6RcWn0p0Wu8fDXzefLbI8r0HDJDGARnHFTmewq1yXxUVukDFZ26rAo1ISIiIko6W4wVu4Ztxfb+m2A32dzeLrBgENpt7owCTQp7sR0RERERERERkbI4hIGIiNKlmjUdMBikdwTftk2tUBui9K9HqV4oGVJaNvf5vo9gdbw863Xsp1/AWqee7Haq2BgE9HgHQtTzFPUkogzEZIL/R8NkY44cOWH66DOX9y+5uADh5nDJNcpmK4+6eeonuSJRZmZu11E2o1/FA/jTKpWgwqCK8v/Gzjg5BU6e9ZAyCcOCubIZc49eCjTJvJI6gKF32b6YWOd7DmDwoJq5a2NKXfkBZgCw+tpKTD3xvZcbSRAExEz4DqLM37/67h34zpyqUCkiIqKMpc3iNgjIHZBwXRAEiKKIsAth2P7RdswuPRsT/CdgZomZ+KXaL5hXax5+qvATJuedjInBE7G06VKcWXwGtjgbRFFM9Lqt5siaKFi/4Csf98aOGwi/Ep4wrCEofxCyl87u3W+WKJORG8IAAOrYywo0yYScdqhsEdIRDmEgIiKiNOrh4ftYVm8RLi45l6Tt8r5VAO23dEZwsRAvNSMiIiIiIiIiSh0cwkBEROmSry/w5psOyczevRrExSlUiCid06g0+KbmJNnc1cgrmHPmx5c3qNWI+vFXOPLKn6VKc+M6/Pv3BZw80I+IAOMPE6G+fUs2FzP+O4j+Aa+8z+qwYubJabJrDKk4nAfvESWRo1Rp2IsVl8zot2yCIHNWeUo9bQq3Rx7/vJKZa5FXseXWJoUaEaUezakT0J4+KZmxla8Ae7kKCjXKfI49OpKkAQy9yvTBd3V/4Gs4L+hQrBOGV/7Irez4w2Ow6eYGLzdyzV6mHMzd5Yej+E6fDNWd2wo0IiIiyliC8gWhx64eCMgdkDAQQRCEhGEMoijCZrLh6eWnuH/kPu7uv4tHpx8h6l5Uwv0vhi/8c5taI2uh7ui6Lh83+kE0Kr1fKeFSZ3QdZb5hokzE4ZMfoiB9wgJN7BWF2mQugswABgBw6rIp0ISIiIjIfQ6LHQe/3oc1rf5A1K2knWCn0vCqaLa4NfSBBi+1IyIiIiIiIiJKPRzCQERE6VaDBnbJ+00mAQcOSO9cQkQvVcv5BtoVkT/r9aRj3+BR7MOE62JwCJ7PWwLRx0d2W/3WzfD9/tsU9SSi9E994Tx8ZskPT7A0bgZrsxYu719xZRkexN6XXKNwUBE0LeB6DSJyQRBgaSf9ukCIi4Nu43qFClFSadVa9C8/WDY3/cTkhINtiDIqw4K5shlzj94KNMmcLkVcROcN7d0ewPBumd6YVG8yVAI/vvCWj6p8hmYFW7qV/WBbH5x/mrSznnlS7Kcj4cySRTIjmM3w++pzhRoRERFlLMGFgvHB2Q9Qvmf5hCEKwMthDP+8SN0uiiICcgegy8YuqDvG9QAGACjXrRyaz26ecCnbtax3v0mizEilg8OngGREzSEMXqGyhslmOISBiIiI0pKn58KwvOFSnJx+FKLT/c8MtX46NJrbAlU/qQFBxYHKRERERERERJmC0wY82Qdcngac+RI4OgA41As4lHH3v+RejERElG7JDWEAgG3bNAo0Ico4vnrjaxi1fpKZWFsMRh/4ItFtjjJlEf3DdLcew/jdBOi28ozLRJmWwwH/D4dAsEv/HHca/RAz4TvXyzgdmHbiB9mHG1xxONQqDmUiSg5zm/ayGcPKPxRoQsn1TvGuCDGESGaOPT6Cww8PKtSISHnC80gYVq+QzDj9A2Bu3U6hRpnLvei7ePvPNoi0RLqV716yF76vN4UDGLxMJagwo/5PKBVSRjZrssei+6ZOeBr3VIFm/yUGhyD2ky9kc/oN66Dds0uBRkRERBmPPkCPVnNboffB3ijbpSzUOnXCQIZ/DmYA8J/bRVFESLEQNJ7SGAMuDEDhxoVT8Tshon9yGItL3q+OvaxQk8xFZZP/3UnUZlWgCREREZE0u9mOw9/sx4pGSxBxMWnv/2Yrmx0dd3RFoeZFvNSOiIiIiIiIiNKU8GPAvvbA8iBgRx3gxDDg/Djg2o/AjfnAzfnS21+aDBwb/PLyYIv3O3tIpjwy9cGDB6+8PWfOnG5nveFVj09ERK7lzi2iRAkHLl50fWDltm0aTJhggcBhy0Ruec2YAyMqf4wxB6UPcFh59Q/0KNUL1XK+kXCbpV1HmE6dgO9Ps2Qfx/+DvojcuguOQvwwjiiz8ZkzG9pjR2Rzpk9Hwpkrt8v7199YixvPr0uukdsvD9oV6ZjkjkQUz5kvP2xVqkJ79LDLjHbvbghPnkDMnl3BZuQuX60v+pTth2+PjJPMTT85OdHrOqKMRL9iGQSTSTJj6dgJMBoVapR5RJjD0fHP1ngY69577N1L9sLE2j9wAINCjFojFjb9DY1W1JEdsHA3+g56be6KFS3XQafWKdTwJXP3d+GzcB40589K5vw+/wjPdh0AtFqFmhEREWUsuavmRu6qudFkRhPc3X8X9w7dw5OzT2AKN8H8zAy7xQ5DoAGGLAYE5AlArtdzIU/1PAgtG5ra1YnoFRzGYkDYepf3aziEwStU1jDZjFPHIQxERESUuu7/dQe7P9yO5zcik7xtmT7l8cZXtaDWZ8pDEIiIiIiIiIgyF1sMcLg3cPfvE2H9Y4B/kmiMwJUZSDjAM/wokLORZzp6mSCKyf2u06/ixYtD+NfRuIIg4MKFC25lvcHV4xN5U1hYdGpXSNN0usQH9lutjlRqQlLGjdNh6lS9ZGbPnliUKOFUqBGlN3yu/5fVYUWdZdVxLfKqZK5kSGls77AXGtU/PlSz2RDYoRV0B/6SfRx7seKI3LQDop9/SisTSeLzPO1Q3biO4LpvQIiLk8zZylVA5OadgPrVg5ZEUUS9P97E+XDpg7Am1PwOvcu8n+y+lL7wue4dhl9/hv+nH0pmYsZ+g7j3+ivUiJLqmTkCFRaWgskeK5nb8/YhlAgpqVCr5ONznZJEFJGldjVoLl2UjEXsOQRHibT//396Ynfa0fHP1vjr/l638v8cwMDnubIOPzyEtmubwea0yWa7lXwX39eZqkCr/9IeOoCglo1lczGjxyPug4EKNKKU4nM9ebJl4/toRESkDO5LIC09vJbRP/gNAeel3x9/WvsGRA4E8CifO7Phd/ljl/c7NUEIr3tHwUaUEunhuU5EKcPnOWU25og4HBi9F5d+O5/kbXUBetSd0hCFmqe/E+7wuU6U8fF5TpQ58LlOlPHxeZ483I+AvCb6OrCnGRB99eXwhVcday+K8be/I/GcdViAtfkBy5OX+WYXgIBiXqnuSZn2lFKiKP7nkpSsNy5ERJR0DRrYZTPbtnHqMlFS6NQ6jHtzomzuQvg5LDg/N/GNWi2i5iyAI2cu2e01ly/Bf3D/5E9CI6L0xemE/7CBsgMYRJUKMd9PdTmAAQB23NkqO4Ahq082dC7RPVlVieglS8s2ECWejwCgX75MoTaUHFkMwehWsodsbuap1DmolsibNIcPyQ5gsFWtzgEMXjD6wMhkDWAg5VXNUQ2Tarv3M2DRhXlYfGGBlxu9mq3aGzC37SCb8/1uAoTHjxVoRERERESUtjmM8jutaWIvK9AkcxGsTyXvd+pCFGpCRERE9JLT4cSFRWewtMb8ZA1geK1KTnTc0TVdDmAgIiIiIiIiomSwPgf2NAeirrwcmiAI8V+LIqAJAIQkHK+p1gP53kl8/Ni9tZ7v7QWZdq9GQRASLknJeuNCRETJV6mSE8HBTsnMtm3SB40R0X/VzVsfzQq2lM19e2QsIszhiW4Ts2VD1LzFEPV62e3169fCZ/rkZPckovTDMG8OdAf3y+bi3usPe9nyLu8XRRGTj0+SXadfuQHw0fgkpSIRvYKYLRusdepJZrSnT0J9hTtsp2XvlxsAjUr6zc5VV5fjXvRdhRoRKcNnwa+ymbgevRRokrmsvPIHfjozy61sx2LvcABDGvBOia54v9wAt7Kf7B2B44+PernRq8V+9TVEX6NkRhUTDb+xXynUiIiIiIgo7bIbi8pm1BzC4HEqmSEMoi6bQk2IiIiI4j088gArGy3F7hHbYQ6XPmnGv6l0alT/oiZar+uIgHyBXmpIRERERERERGnO4d5A1OXEwxcCigPVFwHtw4EOz4DAJJ78Ku/fJ+B5cUz9o+2e7ewlmXbPRlEUEy5JyXrjQkREyadWA/XqOSQzR4+qERGhUCGiDGT0G+NgUBskM5GWSEw6+s1/brdXqISYb39w63GM40ZDuzN9vHgmouRR3b4Fv69HyeYcefMj9uPPJTOHHh7A0UeHJTMBukD0LNU7KRWJSIKlQyfZjH7FMgWaUHLl9s+DNoXbS2bsTjt+Oj1ToUZE3ieEh0P/5xrJjDM4GJbmrZQplEncjb6Dj/YOdyvbIF8jTK4zgwMY0oivqn+Nennfks1ZnVb02twNT0xPFGiVmDNHTsQO/0g2Z1i2FJqj0r8zEBERERFleBo/OAx5JCMcwuB5KmuY5P1ODmEgIiIihcQ+isH2/puwuvnvCDuT9PdzQ0plQ4etnVFhUBWo1Hwfn4iIiIiIiCjTCD8K3F31cvgCABR8F2hyGijQBdBlSd662aoD+pD4r0UReHrg5fppmPQp8DKoCRMmeCVLRESpo2FDO1as0Lq83+kUsHOnBu3b2xVsRZT+5Q3Ih8EVh2Pi0fGSuXnnfkHPUn1QNLhYotvNnbtBc+oEfOZLn31WEEUE9OuFZ1v3wJm/QIp7E1EaI4rwHz4IgilWNho9ZQZglD6z7dQT38uu07tMXwToeRYGIk+xNG4Gp9EPqtgYlxnDimUwfTISUHEHnLRqYIWhWH7ld8nMogsLMLzyR8hiCFaoFZH3GH5fAsFqlcyYO3UFDNKD58h9DqcDA3e8j2hrlGy2ymtVMafhAmjVrt/PIWVpVBr81GAumqysj2uRVyWzD2MfoO/WHljRYp3if4dx7/eHYelCaG5cl8z5ffYRIrfs4msTIiIiIsrUHMaiUJvvurxfE3NJwTaZg8r2VPJ+pzarQk2IiIgos7JEWXBq5jGc/uk47Kak7y8pqARUHPI6Ko+oBrVO7YWGRERERERERJSmXfj25deCALzWCKgmfVyY24IrAQ+3xn/tiANibgD+hTyztpdkyiEMbdq08UqWiIhSR926dqjVIhwOwWVm2zYOYSBKjgEVhuD3y0txJ+qWy4xDdOCrA5/ht+Yr/3NfzNhvoTl/DlqZM1CqIiMR2LMLnm3YJnsANhGlL4aF86Dbt0c2F9ejN2xv1pLMnAk7hZ13tktmfDQ+6Fu2f5I6EpEMX19Ym7eEYdlSlxH1vbvQHjoA2xtvKliMkqJESEk0yNcI225vcZkx2WMx99wcjKj8sYLNiLzA6YRh4VzZmLl7T+93yUR+PjMbBx/sl80VCCyIxU2XwVfrq0ArSopAfRAWN12GRivr4bklUjJ78MF+jD44EmPf/FYy53F6PWLHfYvAd9pLxrSnT8KwdBHMXXsoVIyIiIiIKO2xG4tBF77D5f3q2CsKtskcBGuY5P1OHYcwEBERkXfYzXacm3caJ6YehjnCnKw1spbJjjo/NED2cqEebkdERERERERE6YLTATzaFj98QRQBlQaoMtNz62ep+HIIAwBEXU7zQxh4CiAiIkr3AgOBqlUdkpnduzVwSEeI6BV8ND4Y88Z42dyOO9uw4/bW/96h0yHq14VwZJf/cE5z4Rz8RwyKf6FORBmC6tZNGEeNlM05cudB7FdjZHNTT/wgm+lWsiey+nAnRiJPM3foJJvRL/9dgSaUEoMqDJPN/HLmR5hsJgXaEHmPdt8eaG7ekMxYa9WFo2BhhRplfI9iH+LbI+Nkc0atHxY0+Q1ZDMEKtKLkKBhUGLPfmgMBroedvvDzmdlYfln5n//W+g1hadRENmccNwpC5DMFGhEREWVMNpMN0Q+j8fzO8xRdiCj1OIzFJe9XW+5DsEcr1CZzUFmfSt7v1GVTqAkRERFlFk6HE5d+P4+l1efhwFd7kjWAQeOrwRujaqH9ls4cwEBERERERESUmUUcBWx/f3YkCEBofcCvgOfW98mZ+Lr5oefW9hJNahcgIiLyhAYN7DhwwPWPtWfPBJw+rULFik4FWxFlDE0KNMObuWrhr/t7JXNfHfgctXLXhVatTXS787UciPp1EYLaNoNgs0muYVi1AvbyFRHXb2CKexNRKnM4EDDwfahiY2Sj0d9Pg+jnL5m5+uwK1l9fK5nRqrT4oNygJNUkIvfYatSEI0dOqB8+cJnRr1uDmPHfAT4+CjajpKiaozoqhVbB8cdHXWbCzeH4/fIS9CrdV8FmRJ7ls2CubCauRy8FmmQeXx/8CiZ7rGxuWr3ZKB5cQoFGlBJv5WuEj17/zK3BGiN2D0bx4BIok62cAs1eihkzAbrdOyFYLC4zqvBw+E4cj9jx3ynYjIiIKH2yW+y4uPIirm+5jgfHHyD8SjhEhwcGJgvAl/YvU74OESWL3VhMNqOOvQJ7YCUF2mQCTitUdunhM6KOQ6SJiIjIM5x2J66uvoTjU44g8mpEstfJWy8/ak2sj4C8gR5sR0RERERERETpUsytxNez1/bs+rqgxNdtaX9YuCq1CxC54+rVq1izZg1+/vln/Pjjj/j9999x/Phx2O321K5GRGnEW285ZDM7d3L2EFFyCIKAMTUmyJ4F88qzy1h44dUHO9mrVkPM2G/dejzj6C+g/Ut64AMRpX2+0ydDe+SQbC6uS3fY6taXzU0/ORkipHf87lC0E3L553a7IxElgVoNS7uOkhFVdBT0WzcpVIiSQxAEDKowTDY369R02J18z4XSJ9Wjh9BtWi+ZcWQPhbVxU4UaZXzHHh3B8iu/y+Y6F++GFoVaKdCIPGFYpf+hcX7554nZYca7m7siwhyuQKuXnAUKwtRffgCbz7xfoL5wXoFGRERE6ZMoijj4w0H8kPMHrO62GmcWn0HYhTA47U6Iopjii8zbeUTkZQ5jUdmMOvaSAk0yB5X1qWzGqcumQBMiIiLKyBxWBy4sOYulb8zDjgGbkz2AwS+XPxrOaYZmv7XhAAYiIiIiIiIiimcJi/9T/PuDXl8PH5uh/vtEf8Lfx6c5TJ5d3wt4NCqlWaIoYuXKlZgzZw5u3br1ykxQUBDeeecdvPfee/D19VWsm8PhwNWrV3H69GmcOXMGZ86cwbVr1+B0OhMyAwcOxKBBPAsvkVKKFnUiZ04nHjxwPV9o1y4NPvzQqmArooyjdNYy6FqyBxZdmC+Zm3hkPNoW6YAshuD/3Gfu2Rua0yfhs3SR5BqCw4GAvj3wbNteOHPnSUltIkolmtMn4TtxvGzOkSMnYkfLn133bvQdrLiyTDIjQMCgikPdrUhEyWDu0Am+M6ZIZvTLf4elVVtlClGyNC7QFEWCiuJq5BWXmTtRt/Dn9TVoU6S9gs2IPMOwdBEEh/SgRnPX7oBWq1CjjE0URXx14HPZXN6A/Bj75jcKNCJPUQkqzKj/ExqtrIvrkdcks3eib+P9rb3we/NVUKvUCjUETINHwPDH71Dfv+cyIzgc8Pvsf3i+esPLD++IiIgIAGAz2bC02VLc3ns7fmDC3wQP/cz855pElDpEXQic2qxQ2VwPB9DEXoFFwU4ZmcoaJpvhEAYiIiJKLrvZjotLzuHkjKOIuZ/8s0Sq9WpUGFAZFQa9Dq2Rn5UQERERERER0T/YYxNffzE0wVOsz+L/FMX4fbk0AZ5d3ws4hEHGp59+mvB1zpw5PXpQ/fTp0/HgwQMA8TsyjB8vf5BSZhEVFYWhQ4di//79krnIyEjMnj0b69evx+zZs1GkSBGv9pozZw527dqFCxcuIC4uzquPRURJIwhAvXp2LF6sc5k5flyFyEggKEixWkQZysevj8TqqysRY3P9Qd4zyzN8f+xbjH3z2//eKQiI+eZ7aC6eh/bkCcnHUoWHI+Ddrohctxnw8fCLdiLyLpMJ/h/0gWCXP4N6zPdTIQbIn1Fh1qlpsmdkb1moDQoFeff3AaLMzlGiJGyly0J77ozLjG7ndghPn0LMmlXBZpQUKkGFARWGYOiuAZK56SenoHXhdh47+IZIEQ4HDIvmS0ZElQrmrj0VqZMZHHl0GEcfHZbNfV97Kvx0/go0Ik8K0AdiQePf0GhlXcTaYiSze+7twvjDY/BF9dEKtQNgNCJ21FgE9O0pGdMd+Av6tatgad1OmV5ERETpxLK2y3Brzy0AiQcvcHgCUcZi9ysO3bO/XN6vjr2sYJuMTZAYdvGCU8v3TYmIiChpLFEWXFh4Bqd/PAHTk1j5DSQUaFoYNUbXRkA++f00iIiIiIiIiCgT0ockvm6L9Oz6cQ+lHy8N4hAGGatXr07Y4aB48eIeHcKwY8cOXL58GaIocgjDP5jNZvTu3RtnziQ+qEOr1SJXrlzQ6XS4d+8eTCZTwn13795F9+7d8fvvvyNfvnxe67Z+/XpcunTJa+sTUcrUrevA4sWu73c6Bezbp0GLFvIHhRLRf2X3zY5hlf+Hrw9+KZmbe24OepTqjSJZiv73ToMBUXMXI0uDWlA9ld4RSXv6JPw/GoboabN5tkqidMRvzBfQXLsqm4vr9i6sbzWSzT0xPcGSCwtlc4MrDXerHxGljKVDJ8khDILdDv3alTD3fl/BVpRU7Yp2xDdHxuJR7EOXmXNPz2D33Z2om7e+gs2IUka3YyvU9+9JZqxvNYQzdx6FGmV8P56eIZtpUqA5auepq0Ab8oaiwcUwvd6P6LWlq2x2+snJKJ+9AloUau39Yn+ztGwD64K50P21VzJnHDUSlgaNAaNRoWZERERp29mlZ3F96/VXDl/IUTEHcr2eC1kKZYEh0ACVVpVaNYnIAxzGYgCHMChCZQ2TvF+EAFEbrFAbIiIiSu+i70bhzM8ncGHJOdhirClaK1u5UFT/oiZy18rroXZERERERERElCHps8X/+eJz5Jibnl3/6YHE1w3ZPbu+F3AIg5u8dbYHnkXivyZMmJBoAINKpUK/fv3Qs2dPBAbGT1+1Wq1Yv349vvnmGzx//hwAEBERgaFDh2LFihVQq9WKdlapVNDpdDCbzYo+LhElVquWHWq1CIfD9cHaO3eqOYSBKAXeK/sBFp6fi9tRt1xm7E47vtr/GZY2X/HK+525ciPql4UIbNcCgsMh+XiGZUthK18R5t7vpaQ2ESlEu3MbfObOkc3ZCxREzOhxbq358+lZMDukX2e/lbchymQt69Z6RJQylrbtYRw9EoLT6TJjWP47hzCkcXq1Hu+V7Y8xB7+QzM04NZVDGChdMSyYK5sx9+ytQJPM4ebzG9h440/JjF6tx+g33HvdR2lX80ItMbTih5hyYpJsdsjOASgVUhoFgwor0AyAICBm3ERkqVdD8j0G9YP78J36PUyfSQ+WJCIiyiz2jd+X8PWLfRYKNyqMhj80RLYS2VKrFhF5gcP4iqHp/6A23QQcZkBtUKhRxqWySg+gF7XBgIq76hEREZG0J6ce4dTs47i+7gpER8r2MQ8sEISqn9VAoRZFIah4AhwiIiIiIiIikuFfKPH1fw9NSAlbFBD2V/yAB1EEoAKCK3tufS/hKQtSmcCzOidy/fp1LF++PNFt3333HYYMGZIwgAEAdDod2rZtiyVLliAgICDh9gsXLmDNmjVe75krVy40atQIH374IRYuXIijR4+iSZMmXn9cIpIWGAhUrOj6YDAA2LVLA86/IUo+vVqPr6qPlc1tv7MVO+9sc3m/7Y03EevmAdh+X3wCzaGDbnckotQhPH6MgEEfyOZEtRrRs+YAfn6y2eeWSMw9Jz/UYUilD93qSEQp5wx9DbZadSQz2hPHob52VZlClGw9Sr2LAF2gZGbfvd04/eSkQo2IUkZ15zZ027dKZhx58sJa9y2FGmV8v5z5ESKk32TpUaoX8gcWUKgRedPHr3+OunnkB/PE2KLRZ2tPmO3KDSx2lCiJuF59ZXO+s6ZBfeOaAo2IiIjStud3niPsQhgEQYAoihAEAeV7lEeXTV04gIEoA7Ibi0neL8AJtem6Qm0yNrkhDE5dVoWaEBERUXpjN9txefkFrGr+O1Y0XIprqy+naACDb3Yjak2sj05/9UDhVsU4gIGIiIiIiIiI3BNUBjCExn8tisCTfYDpnmfWvjILsMe+vJ6lHCCzH3NawCEMlKZMnz4djn+crapVq1Zo3ry5y3yRIkXw0UcfJbpt5syZsNlsXuk3atQoHDhwADt37sS0adPQt29fVK1aFX5uHEBGRMqoV88uef+DBypcvswff0Qp0axgC7yR803Z3Jf7P4Pd6fo5Gdf3A5jbdZRdR7DbEdi7G1QPHySpJxEpyOFAQP++UIU9kY2ahv0P9kpV3Fp27tk5iLFFS2aq56yBqjmqubUeEXmGuUMn2Yx+xe8KNKGU8NcFoGep3rK56SeneL8MkQf4LJwHQWbqorlbT0CtVqZQBvfcEoklFxdJZlSCCn3Lyg/povRBrVLjxwa/Il9AftnsuadnMPKvT7xf6h9MH30GZ1bpA5oEqxV+H48AJ7QSEVFmd+9w4p1kjKFGNJ3ZNJXaEJG3OYzFZTOa2MsKNMn4BGuY5P1OHQfdEBERUWKR159h/5d7sKDcz9gxYDMeHUnZvlGGYAOqfv4muhzuhdI9y0Gt5WciRERERERERJRErzX4x/5VTuDs6JSv+fwScH48IAjxawsCkLNZytdVAI9CTUX/HDag0WhSsUna8Pz5c2zb9vKM2YIgYNCgQbLbtWvXDrly5Uq4fv/+fRw4cMArHStUqICQkBCvrE1EnlG3rvQQBgDYtYsfLhClhCAI+LrGBAiQnpJ+5dllLDg/V2ohRH8/DbbSZWUfUxX2BAG9ugEWS1LrEpECfKdMgm7fbtmcrVJlmIb9z601TTYTfj4zSzY3pOIIt9YjIs+xNG0B0dcomTGs+ANwOhVqRMnVt9wH0Kv1kpn1N9bixnOeDZHSOIsFhqULJSOiRoO4d7opVCjjW3RhAUz/nEr9Cs0KtnTrgH1KP7IYgjGv8RL4aHxkswsvzMWqq8sVaBVPDAxC7OejZHO6PbugX7fa+4WIiIjSsNgnL1/HCYKAEu1KQOurTcVGRORNTn0OONX+khk1hzB4hIpDGIiIiMgNthgrrqy4iLXtlmNp9Xk4/eNxWJ6ZU7SmTzZfvDGqFrod64NKQ16H1sjf8YiIiIiIiIgomYoPif/zxcCEG3OB28uSv17MLWBvK8Ae8/I2lQEoOjBFNZXCIQypKDIyMuFrX1/f1CuSRuzevRt2+8uDp19//XXkyZNHdjuVSoW2bdsmum3Hjh0e70dE6UO5ck4EB0sf7LVzJwffEKVUmWzl0LmE/AFME4+Mw3NLpOuAry+i5i+BM0sW2bW0x4/C7/OPk9CSiJSgPfAXfL+bIJsTfX0RPfNnQOveh/1LLi5AuDlcMlM2W3nUzVPfrfWIyIOMRliatZCMqO/chvbIIYUKUXKF+oaiY7HOkhmn6MSsk9MVakSUPPr1a6F6+lQyY23SHGJoqEKNMjabw4Zfzvwom+tXboACbUhppbOWweS6M9zKjtg9BNeeXfVyo5fM73SFrUJF2Zxx5CcQoqMUaERERJQ2WZ7HDzsW/z57SY4KOVKzDhF5myDAYSwqGeEQBs9Q2aTfmxC1POkLERFRZuWwOXBr2w1s67cB80r/iO39N+H+vrspXtcvlz9qTqiHbsd6o3z/ytD66TzQloiIiIiIiIgyteBKQJ428QMYXgxiONgNuPhD/NfucjqAG/OBLZWBmGsv1xIEoFAfwJA+hldzCEMqiYiIQFjYywnoQUFBqVcmjdizZ0+i62+++abb277xxhuJru/atcsjnYgo/VGrgdq1HZKZQ4fUMJkUKkSUgX1S9QsYtX6SmWeWZ5h64gfJjDNvPkT9NA+iSv6lqc/CuTAsXpCknkTkPUJYGPzf7wXBjbPdx4yZAEfBwm6ta3VYMfPkNNnckIojIAiCW2sSkWeZO3SSzeiXp2DqKSmmf/mBECD9b+myy0vwxPREoUZESecz7xfZTNy7fRRokjn8eWMNHsTel8xUCq2CKq9VVagRKa1tkQ54t7T8cyrWFoM+W3sgzh6nQCsAKhViJkyCKPM7gvrxI/hOHK9MJyIiojRI96+DcvSB+lRqQkRKcRiLSd6v4RAGj1BZpYcwOHXpY2dCIiIi8gyn3Yn7++9i7yc7sKDsz9jYZQ2urroMu8kuv7GMgHyBqPNDA3Q53AtlepeHxse9k2EQEREREREREbml4mTAkD3+a0EAnHbg1P+A9cWB898AT/YCTmvibaKuAk8PAbeXAUcHAOsKAod7A5aIlxlBAPyLAuXGKfe9pBCHMKSS+fPnJ3wtCAIKFiyYemXSiIsXLya6XqFCBbe3LV26NHS6lzuLPHnyBBERERJbEFFGVreu9AcVFouAgwfVCrUhyrhCfUMxrNKHsrk5Z2bjTtRtyYytTj3Efj7Krcf1+2QENMePupUlIi9yOhEwoC/Ujx/JRi3NWsLcrafbS6+4skz2wL4iQUXRrGALt9ckIs+y1awNR+hrkhn9utWA2axQI0quQkFF0KxgS8mMxWFx66z3RKlBfe4stEcOSWbsRYrCVqOmQo0yNlEU8eOpGbK5D8oNVKANpaYxNSagbLbysrkL4ecw8q+PvV/ob/aKlWHu9q5szmfOj1CfPaNAIyIiorQnS8Esia7HRSg0MImIUo3dr7jk/WrTNUCUPtEByVNZwyTv5xAGIiKijM8eZ8PNzdexc/AWzC/9I9a2WY5zc0/DHO6Z37uyVwhFw1+ao/PBd1GyaxmoddwHkoiIiIiIiIi8wJgXqLUGUP090F8QAFEEoq8CZz4HdtQFoi7F3wbE/7mhOLCtBnCgM3DtR8B0N/72FyfUEUVAbQRqrgRkTgiclmhSu0BqO3rU/QP4TCZTkvL/5HA4YDKZcPfuXezduxcHDhyAIAgQRRGCIKB06dLJWjejsNlsuHPnTqLbChUq5Pb2Op0OefPmxbVr1xJuu379OoKDgz3WkYjSj7p15XcQ2bVLg/r1uSMJUUq9V7Y/Fp6fhzvRrocsWBwWjD88Bj82+FVyrbiBQ6A5fRKGdaslc4LVioBe3fBs216I2bMnqzcRpZzP9MnQ7d4pm3PkzY/oKTNe/vIsl3c6MO3ED7K5QRWHQSVwriBRqlGrYWnbAb6zp7uMqJ5HQrdtC6wtWilYjJJjUIWhWH9jrWRm3vlfMLjiMPjp/BVqlTY4ncCDBwJu3VLh4UMBMTECYmOBuDgBej1gNIowGkVkzy4if34n8uQRoeXJhhTlM1/69wwAiHu3j9uvRUja4YcHcSrspGQmr38+NOWwrAxPr9ZjTsP5eGt5LURboySziy7MR/WcNdC+6NuKdIv9/EvoN6yFKjzcZUZwOuH/8XBErt8KqPh7BRERZS65q+WGoBKAv/eHeXpJ+sztRJT+OYzFJO8XnBao4m7B6ev+fjr0Lw4TBEesZMSpy6pQGSIiIlKSOdKM29tu4ObGa7iz6xbsJukTSCWZABRoVAjl+ldCjqq5IPDzDiIiIiIiIiJSQtZqQJ2NwP53APPjxMMUXuXft//zPQxRBHxyArXXAoElvdPXSzL9EIZu3brJviEl/v2Xf+fOHXTv3t0jj/ti+MILzZo188i66dXdu3dht79849FgMCR5gMJrr72WaAjDzZs3UaVKFY91JKL0IzRURKlSDpw/73rS865dnAJN5AkGjQFfVh+DPlt7SOZWXV2O98v2R4XQSq5DgoDoKTOhuXIJmksXJddTP3yAgD7d8Xzln+BRbkTK0+7eCeOEr2VzolaLqDnzIAYGub32+htrceP5dclMbr88aFeko9trEpF3mDt0khzCAACG5b9zCEM6UCG0Et7MVQt/3d/rMvPcEomFF+ajf/lBCjZT3t27Ag4fVuPIETWOHlXj2jUVLBb3d2ZTq0UUKuRE5coOVK0afylQQOTx/14iRD2HYcUyyYzo6wtLx3cUapTxzT49QzbTt2w/aFSZ/qOHTKFAYEFMqTsTvbd0k81+uHsoymWrgCJZinq9l5glGDFfjUXA4A8kc9pjR2BYugjmrtLvaRAREWU0vll9UaBeAdzYfgMAcG3TNTT6vlEqtyIib7Ib5V+Ha2Iuw8ohDMmmssoPtBF12RRoQkREREqIeRiNmxuv4+ama3hw4B6cdqfHH0Pjq0HR9iVR/oNKCCqUxePrExERERERERHJCq0DNDkFHHoXeLg5/rak7BD7YjDDaw2A6vMBnxweLuh93BPyb6Kr6RtJzLjrxQAGQRDQvHlz5M+f32Nrp0cRERGJroeGhiZ5jX9vEy5xliuKp9PxIHQpGg3/+6Rnb73llBzCcPWqGk+fapAzp+f+baf0ic/1lGtXoh1+OjMTRx8dkcyNPvQFNrTfLD0AKzgQcUuXwa9OTQhRzyXX0x06gIDRI2GeOCk5tSkT4fPcs4Rbt+D3fi8ITvmdCMyjx0JV9XXo3FxbFEVMPfG9bG5w5aEw+hjcXJUyCz7XU0HF8nCULAX1hfMuI7odW6GPiYQYHKJgMUqOYVWGSw5hAICfz8xE/0r9oVO7+y+753n6uS6KwOnTAtav12DjRjUuXEjZ2dAdDgFXrqhx5YoaS5fG31akiBMtWzrQooUd5cpxIIMn6Vb9AcEkfZZJa8dO0GZN2rBXerXrz65h880NkpkAXQB6lO2Zovcd+TM9fWlXoi0OPz6An0/NlsyZ7LHou7U7tnfaA1+tr9d7id26wf7bYmgO7pfMGb/+CmKrlhBDeEZapfG5TkSUump+VhM3tt+AIAgIvxyOS2suoXjr4qldi4i8xOmTH6JKD8FpcZlRx14G0FS5UhmMyhomm3FyCAMREVG69uxqBG5svIabm67hyYlHXnuc4BIhKNW9HIp2KAF9gN5rj0NERERERERE5BafUKDuRiD8KHDhW+DBBsDh+jOnBCpN/BCH0iOB7LW8XtNbUrZXcQYiCMIrL+5kknMRRRGiKKJatWr46quvUum7TjtiYxPvLO3j45PkNXx9E++4aTKZUtSJiNK3evUcspk9e/hjkMgTBEHA2FoTZHMH7v+FjTekD9gBAGfBQjDNmQvRjaPT9D/Phva3JW71JCIPMJlg7NoJqmcRslFb0+awfjAgSctvvbUF556elcxk882GbqV5plqitMLaSfrs8oLNBu2qlQq1oZSol+8tlM5aRjLzIOYBll9aplAj74qIAGbO1KB6dQPq1PHBpEnaFA9gcOXqVRW+/16LOnV8UKOGAb/+qkF0tFceKnMRReh+nSMbs/bqo0CZzOHHU7MgQnqYZffSPRGgD1CoEaUVX785DhVCK8rmLoRfwEe7RyjQCIAgIO77yRDV0gf6q55FwDDqS2U6ERERpSH56+RHhd4VEk5EsXHARkTdi0rlVkTkNYIaDt8ikhFN7GWFymRMKutT2YxTy0G1RERE6YnoFPH4+EMcHLsPS9+Yh99qzMfhcX95ZQCDWq9G0Q4l0GZ9J7y9uzvK9C7PAQxERERERERElLaEVAFqrgDaRwJv7QbKjQOKfADk7Qi81gDI3RIo1Aso9SlQaw3QLhyotzVdD2AAOIQBABIGIrzq4m4uKRc/Pz/UrFkTU6ZMwdy5c+Hn55dK33na8e+BCXp90t88/Pc2HMJAlLlVreqEwSB9YMCePTzbGpGnVM1ZDa2KtJHNffXXSNgcNtmcvVFjWD4d6dZj+wwbDNWpk25liSgFRBE+QwZAfU56SAIAOPPkhWnWj0jKqb5FUcT3RybK5vpXGAgfTdKHthGRd9javy07OEm77DeF2lBKCIKAIZWHyeamHZ8Cp+hUoJF3XLok4IMPdChe3Aeff67DpUvKvj164YIKI0boULKkDz75RItH3jtRUoan/msf1JcvSWbsVavBWbacQo0ytmfmCCw5v0gyoxbUeK/8Bwo1orREr9FjXtNFCNAFymYXn1+I3y4oM0zRWbIUrP0HyuZ0ixZAfeigAo2IiIjSlmYzmyF/nfwQRRHRD6OxoN4CPDrFX1KIMiq7sajk/WoOYUgRwSY9hEEU1BC1WRRqQ0RERMnlsDlwd/dt7P14BxaW/xkrm/yGk9OOIvLaM688XmilHKg5oS56nH4Pb81sghyv5/zPCQSJiIiIiIiIiNIUtT5+sEKpT4EqM4E3fwfqbYkfvFD1l/jhDLlbAlr/1G7qEZrULpDaFi5c6PI+URTRo0cPCIIAURSRL18+fP3118l6HLVaDaPRiMDAQOTIkSO5dTMsi8WS6LpWq03yGjqdLtF1s9mcok5ElL4ZDED16k7s2uV60MKePSqIYpKODyUiCV/VGI2N19fD5nQ9ZOHas6uYf24u+pZ7X3Y9y4cfQX3qJLQb10vmBLMZxq7vIGbPXxBDsia5NxG5RzdrBnTL/5DNiRoNTHMXAEFJ25lw3729OPLwsGQmQBeIXmX7JmldIvIuMWdO2GvXgXb3LpcZzdEjUN24DmfBQgo2o+RoU7Qdvj4wGneibrvMXI64hM03NqFpoWYKNku5Y8dUmDRJg82b08bbodHRAn78UYv58zV49107hg61ITQ0tVulL7q5v8hmrL35usFT5p+dC5NdeuhtqyJtkDcgr0KNKK3JH5gfMxv+iG7r35HNjtg5FBVCK6J4SAmv9zJ//Bm0q1ZAdf++ZM5n+BDE7D0AaNLGzwkiIiIlqHVqdNnUBet6rcPZ384i4loEfqn2C8p0KYOKfSoi1+u5oFLzvB5EGYXDWEzyfnXsFfDD8+RTWcMk7xe1IYDAf1OJiIjSGlEUEXUzEnf33sG9Pbdxb99dWKMs8humQFDhLCjargSKtC2OwAJBXn0sIiIiIiIiIqI0xR4LiI6X17UBqdfFTZl+b7LXX3/drZwgCPD19XU7n96MGzdOciCFpwwcOBCDBg36z+16vT7RdZtN/gzZ/2a1WiXXpP+yWh3yIUrA/17pT40adskhDA8fqnD+vIiiRdPvWVzJ8/hcT77cvvnRq3Rf/HRmlmTum4Pj0LZQR/jr5F8s26b/iKArdaG5dlUyp7p3F4ae3fF82WoeMEGy+DxPOt2OrTB88Zlb2Zix38JcrhKQxP/O3x2eKJvpVbovfAQ//h2SW/j/iXKEdm9LDmEAANXSpTB/5N6/I5SaBHxQbiA+3fc/ydTko9/jrTyNFeokTe65fu2agHHj9NiwIekDP5VgNguYPVuLBQs0GDbMin79rOBbWvJUjx9B++dayYwzJASxTVom+TUJ/ZfVYcVPp36Uzb1Xpr9Xfv7yZ3r60ShvM7xftr/s+wImuwk91nfF5va7YNQavVtK54Por79FYK+ukjH1hfNQz5qJuH4DvduHXOJznYhIWQvqLUh0XWPQwGFxwGF14PT80zg9/zQ0PhoE5QuCT7APVNrkHTgsCAK67+juicpElEJyQxhUjmioLA/gNORSqFHGorI+lbzfqcumUBMiIiKSExceh3v77uDe3tu4t+cOou9Gef0xA/IHokCTwijStjiylc0OgYOviIiIiIiIiCgz2vYmEHnm7ysC8I49Veu4g0eouUEUxdSukOH5+vomum6xJH2S7L+3+feaRJT51K5tx9ix0kev7Nun5hAGIg8aVvl/+P3yUjy3RLrMhJvDMfPkVHxS9QvZ9UT/AEQt+A1BjepCFRMtmdXt2wPj2FGIHTU2qbWJSIL64gX4930XglP+56W5UxeY3+2T5Mc4/vgo9t3bLZnx1fjivXL9k7w2EXmftVkLiB8NgxAX5zJjWLEMpv99yjPppQPvFO+G745OQIQ5wmXm6KPDOPTwIKrlqK5gs6R5/FjApEk6LF6shcOR9v+/M5nih0UsXarF2LFmNGjAA1GlGBYvgGCXfvPd3Lk7ONHCM9ZeW4VHsQ8lM6+/Vg0VQysr1IjSsi+qj8HRR4dx4slxydzlZ5fw2b7/YWo96YENnmBt1gKW+g2g37FNMuf77XhYWraBMycPOiMioozv1u5brzzoRxCEhP0jbCYbwi6GJfvgIFEUeWARURpi9ysum1HHXuYQhmRSWcMk7+cQBiIiotRjj7Ph4eEHuLvnNu7tvYOnZ58o8rhZy2RHwaaFUaBJIQSXyMrfj4iIiIiIiIiIAODF8frp5K2S5J2uIBMZOHBgwuXtt99O7ToZltGY+GxXcRIHbrhiMpkSXecQBiIqXdqJLFmkB+ns2aNWqA1R5hBsCMGwStJnTgaA2adnyB7E84KjSFFEz/jJrazvrGnQr17hVpaI5AlhYQjs2lF2CAoA2MpXQPTEyck6wHrq8e9lM91K9kRWn6xJXpuIvE/084elSXPJjPrWTWiOHFaoEaWEr9YXvcu8L5ubcWKyAm2Szm4HfvpJi2rVjFiwQOfxAQyBgSJy5nSiYEEncueO/51TrfbcANebN1Xo0sUX/foZEOF6DkbmZrfDsHCeZEQUBMR1f1ehQhmbKIr48fRM2Vy/cgMVaEPpgU6tw88N5yNQHySb/e3SYvx+aYn3SwkCYsZ/B9FgkIypYmNg/PIz7/chIiJKY/59UgpBEBJdiChjcPgWgiizm5gm9rJCbTIe2SEM2hCFmhAREZHT4cTjk49wYtoRrGu3Ar8WnYU/O67EqZnHvDqAQVAJyPlGbtQYWwfdjvdBxx1dUXlENYSUzMbfrYiIiIiIiIiIXkhn75NoUrtAWjdwYObYebROnTrIkiWL1x+nSpUqr7w9ODg40fXHjx8nee1/bxMSwg8wiTI7tRp48007/vxT6zKzf78Gdjug4U9EIo/pXeY9zD37M+5E33aZibPHYeKR8fih7nS31rQ2bY7YYR/COHmSbNZ/2EDYixaHo1RptzsT0SuYzQjs2Rnqu3dko86QEETNXQzIHNT0KhfCz2PzrY2SGZ1Kh/7lByd5bSJSjrljJxhWLZfMGP5Yipiq1RRqRCnRu8x7mHlyKkx2k8vM1tubcTH8AkqElFSwmbSjR1X46CMDzp9P+bA9X18RlSo5UKWKA+XLO1CwoIi8eZ2v/FFnswH37gm4eVOF06fVOHIk/hIdnfw3ilet0mLfPjUmTbKgSRN7Cr6TjEe3ZRPUDx9IZqxvNYQzX35lCmVw++7vwdmnpyUz+QLyo0mBZgo1ovQgb0A+TKs3Gz02vSOb/XjvcJTPXhHFg0t4tZOzQEGYhoyA8dtxkjnDutUw7+wGW723vNqHiIgorXgxgOHfgxiIKANS6eHwLQCN6brLiDqGQxiSS5AbwqDLplATIiKizEcURTy7HI57++7g/r67uH/gHqxRFkUeW21QI0+d/CjQpBDyNywEnxAfRR6XiIiIiIiIiIiUwUNOCQBQo0YN1KhRI9UeP0+ePNBoNLDb43cqN5vNiIiI+M9wBikPHyY+m3bBggU92pGI0qeaNR2SQxiiowWcOqVC5cpOBVsRZWx6tR6fV/sK72/rJZlbemkR3i83AMWCi7u1rumjz6E5cxr6Hdskc4LJhMCenfFs626IWdx/LUFE/+B0wn9of2iPyp+1XlSrETVnAZy58yTroaYelx+u8nbxLsjhlzNZ6xORMmy16sKZLTtUYa7PHqNfswoxY78FfLjzUVoXbAhBlxLdMefsj5K5maemYkb9nxRq5VpUFDB6tB6LFulStE5wsBPNmtnRtKkdb77pgF7v3nZaLVCggIgCBRyoV88BIH4ww/79avz5pwbr12vx7FnSBzKEhanQo4cPuna1Ytw4C586f/OZ94tsxvxuHwWaZA4zT06Vzbxftj/UqpQPP6GMpUmBZuhXbiB+PD1DMhdnj0PfLT2wuf0uGLVGr3YyDRgC/fLfobnh+qAzAPD/ZAQi9h5O1pA5IiKi9CJfrXw8EytRJuQwFpMewhDLIQzJpbJKn1XbqQ9VqAkREVHGJ4oiom4/x/2/7uL+X3dwb99dxIW5HizuafpAPfI1KIgCTQsjb5180Pql7PMpIiIiIiIiIiJKuziEgdIErVaLPHny4ObNmwm3Xbt2Da+//rpb21utVty9ezfRbRzCQEQAUKuW/BlD9+3ToHJlqwJtiDKPVoXbYvap6TgVdtJlxik6MfbQV1jUdJl7i6rViJ79CzQN60B966Z09PYtBHzQB8+XLAfUPBiIKKmMo7+AYdUKt7Ix4ybC9matZD3OjchrWHt9tWRGLagxqMLQZK1PRArSaGBu1xG+P7o+0FIVHQX9pvWwtO2gYDFKrn7lB2LuuTlwiA6XmVVXl+OT10cit3/yBvF4ws6dagwfbsCDB6pkr1Gzph3du9vQuLHd7cELcrRaoE4dB+rUcWDsWAvWrdNg3jwdTpxI+mvTxYt1OH5cjTlzzChaNHMPEFRfuwrd3l2SGUfe/LDW5RnsPeHc07PYdXeHZCZAF4hOJboq1IjSm5HVRuHoo0M4/viYZO7ys0v4ZO8ITK8vPfwnxQwGxEyYhKC320jG1LduwnfKJJg+GendPkRERKmo5+6eqV2BiFKBw1gcCNvo8n4NhzAkj+iUHcIg6rIrVIaIiCjjsZvtCDv9GI+OPsCjYw/x+NhDmJ7EKtrB+JoRBZoURoGmhZHzjdxQa7kvEhEREREREZE77ty5gzNnzuDRo0ew2WwICAhAwYIFUbFiReg9tcNmEsTExODGjRu4f/8+wsLCEBcXBwDw9/dHtmzZULJkSeTKlcvjj3nixAncunULMTExMBgMyJkzJypUqIDQUA5xTus4hIHSjBIlSiQawnDy5Em3hzCcO3cOVuvLA6izZcuGkJAQj3ckovSnQAERefI4cfeu6wNy9u5VY9gwBUsRZQIqQYUv3/gabdc2l8xtubUJBx/sR/WcNdxaVwzKgufzlyJL0/oQTNJT7HU7t8P323Ewffal272JCPCZNR2+s6e7lY3r/R7Mvfom+7GmnZgMpyh9MGmbIu2RP7BAsh+DiJRjfruz5BAGADAsW8ohDOlEHv+8aFukA5Zf+d1lxu6046fTM/H1m98o2Cze8+fA55/rsHhx8t7eVKtFtGljx8CBVpQs6d3BBj4+wNtv29Gxox1//aXGxIk6HD6ctN4XL6rRsKEvfvjBjLZt5YcNZlSGBb/KZuJ69OIgNg+ZdWqabKZHqV7w0/op0IbSI51ah58bzkf9P95EpCVSMrvs8lLUyFUTnYp38WonW936MLdqC8PaVZI53+mTYWnbAY6ixbzah4iIiIhISXZjUcn7VbanEKzhEHXc3yYpBNszCBKDTAHAqcumUBsiIqL0TRRFxNyLxqNjD/D4+EM8OvYQT88+gdOm/JDqoCLBKNCkEAo2LYzs5V+DoBIU70BERERERESUXm3fvh2zZs3C+fPnX3m/r68v2rZtiwEDBiA4ONhrPeLi4rBq1SocO3YMp0+fxv3792W3yZUrF9q2bYuuXbsiKCgo2Y999+5dTJs2DZs2bYLNZvvP/YIgoEqVKhg8eDCqVKmS7Mch70r+KeKIPKxOnTqJru/fv9/tbQ8cOJDoer169TxRiYgyAEEAatWSPkDl6FE1YpUdjk2UKbyZqxbeyttQNjfm4BcQRdHtdR0lSyF66iy3ssYpk6Bbv87ttYkyO/3KP+A36nO3sta69RHzdfIPur0XfRd/XPlNNjek4ohkPwYRKctRqjRspctKZrR7dkH16KFCjSilBlYYKptZdGEBIszh3i/zD9u3q/DGG4ZkD2Bo186GgwdjMWuW2esDGP5JEICaNR1Yty4Oy5aZUKyY9M75/2YyCejXzwfjxungVH5fw9QXGwvDb0skI6JeD3PnbgoVytjuR9/DmmsrJTNalRZ9y/ZTqBGlV3n882J6/Z/cyn68dzguhl/wciMg9usJcPr5S2YEmw1+Hw5B5vwHl4iIiIgyKodRfsiYJvayAk0yFpX1iWzGqeeZrIiIiF7FHmfDg0P3cHLGUWzquQ4Lyv6MRZV+wbb3N+LMzyfx5MQjxQYw6Px1KNC4EGpOqIfOB99F5/09UX1kTYRWzMEBDERERERERERuslqt+PDDDzFgwACXAxgAwGQyYfHixWjWrBmOHj3qtT5PnjzBmDFjsHHjRrcGMADA/fv3MX36dDRt2hRbt25N1uNu3LgRLVq0wLp16145gAGIH0Z55MgRdOvWDZMmTUrScVWknOTtqZzOrVmz5pW3t27d2u2sN7zq8TOT2rVrQ6PRwG6PP1j6yJEjuHv3LvLkySO5nSiKWLUq8Vmr6tev77WeRJT+1KzpwBKJ4zSsVgGHD6tRr17SDoAhInkjq4/GjjvbIML1LwPHHx/D+htr0aJQa7fXtbRqC9Opk/CdOVU26z+oHyKLFIWjWHG31yfKjLR7dsF/8AduZe3FiiNqznxAk/xfKWeemgq7U3pQUrOCLVEsmM9dovTE0qkztCPPuLxfcDqhX74McYOGKleKkq1ESEk0yNcI225vcZkx2WMx9+wcfFjlE6/3iYoCRo3SJXv4Qu3adnz5pQVlyqTuAbWCANSt68DOnSbMnavFxIl6REe7v/Pe1Kl6XLqkxuzZcfDz82LRNMawZiVUUc8lM5aWbSCG8GydnvDTmVmyr9XaF30brxlzKNSI0rNG+Zvgg3KDMPv0dMlcnD0OfbZ0x5YOu+Gn9d4/cM7XcsD08Wfw++JTyZzu0AEYfl/C4S5ERERElGE4jEVlM+rYS7BleUOBNhmHyvJYNuPUZVegCRERUdomiiKibj/H42MP8fj4Qzw69hDh58PgtKfO5zYqrQqvVc6B3LXyIXftvMhe/jWoNDy3IREREREREVFyOZ1ODB06FDt27Eh0u1qtRo4cOeDv74979+4hOjo64b6IiAj07dsX8+bNQ4UKFRTrGhAQgGzZssHPzw8WiwVhYWEID098QrLw8HAMGTIE48aNQ9u2bd1ee9OmTRgxYgSc/zr5S3BwMHLkyIHw8HA8fvw4YeiCKIqYM2cOrFYrPvvss5R/c+RRgpgJx2MUL14cgvDfHZsvXrzodtYbXvX4mc3gwYOxZcvLHftbtWqFiRMnSm6zfPlyjBw5MuF6rly5sHnzZuh0Oq/1fJVPPvkEq1evTrg+cOBADBo0SNEOSRUWFi0fysR0OnWi61YrD9BPr548EVC6tPSO2wMGWPHVVxaFGlFawue69w3Z2R+/XVosmSkQWBB/dToKrVrr/sJ2OwLfbgvdvt3y0UKFEbllF8SAQPfX/z97dx0exdXFAfg36xIHori7BQhOcYfiXpxSnEKFAsULLVCsuBZ39yLFLYK7QxJCEmKbZH2+P/hICZBZye5ksznv8+Qps3Nm7sk2d3d29t5zidOgfm6a6OZ1uLdtAUGyymSsMVcuxB05BWPBQla39zblLapsKAu1Qc0Z90/HM6jgzd/NFJK9UV93DExMDHKVLw5Gn/HEXX3xEog7d/X9THTi8C5HXESbvc04Y3LJciGk1x0oxAq75XH6tBCjR8sQEWH54LeCBY2YOVONhg0d83UhMpLBmDEynDhhWXGJkiUNWL8+FQUL5oDbuywLj8b1IL55nTMs7tA/0FcN4icnJ5agiUfF9aWRrOO+NjzX9apdCmbRe7pz0hl0aLO3GUKiTFeu71S8K/5quNy+383o9fBoWh/iWzc4w4weHnh3IQRsnjz2yyWHor5unTx5XLM6BUIIsUhieCLcAtyyOg1iBRpLwC07X8t4nSsNofp1hvtT8g1GcknucTokPWnkdrjdHsAZE90wBhDwO46JZF527uuEEPNQP7cvXbIOb6+/SSu4EBUcidSYlCzNyatULuT7f9EF/+p5IXah9+ecgPo6Ic6P+jkhOQP1dUKcH/Vz6zjSOIIVK1Zg7ty56R7r2rUrhgwZAh8fHwDvCzWcPHkSv/32GyIiItLifH19cfDgQbi62vb3efHiBZo0aYLixYujTp06qFKlCsqXL4/cuXN/Fvvq1Svs3r0ba9asgVr93zwHsViMffv2oUiRIibbe/nyJdq2bYuUlP/ugZQsWRLjxo1D9erV0x57+vQp5s2bh+PHj6c7ftGiRWjSpIk1v2r2cKQSEH8TYNn348i7OX4/z9ElO1mWTfuxJNYeP+S9ESNGQCD4789y3759OHjwYIbxjx8//qxIw3fffWeyAMPr169RokSJdD+vX2f8JTMhJHvz9mZRujT3m/LZs0LO/YQQ6/1UbTxkQhlnzLOEp1h/d61lJxaJkLhiLQz58psOffIYrsO+BYxZu+oxIY5IeP8e3Dt/bVYBBlahQMLG7ZkqwAAAy28sNlmAoX6+hlSAgZBsiM2dG9pG3Df/RA8fQHQ9lKeMSGYF+dVAFZ9qnDGx6lhsub/BLu2rVMDYsVJ06aKwuACDRMJi7FgNzpxJdtgCDADg58di06ZULFyYCldX8+8T3r8vRIsWCty44fy3eEVhISYLMOjKloe+CvffKjHP33fWmCzA0KRAM7sUYCDOSywUY2WTdfCQepiM3fFwKzbdW2/fhEQiqOYuACvgfg0VxMfDZfJ4++ZCCCGEOBmj3oh7u+9hc8vNWFBoQVanQwj5hEFZgnO/KPk+T5k4D4H2Led+o9iTCjAQQghxeizLIv5pHB5sv4szP57E9oYbsaroX9jXbgcuTz+P50efZEkBBqW/C0p0KY2Gi5uh961B6HqmN2pN+woFGhWmAgyEEEIIIYQQQogNxcXFYdmyZekeGzNmDKZMmZJWgAEABAIBGjdujK1btyIgICDt8Tdv3mDtWgvnFJkhT548OH78OA4cOIAff/wRDRo0+GIBBgDIly8fRo4cia1bt8Ld/b8FYHU6HRYtWmRWewsWLEhXgKFcuXLYtGlTugIMAFC4cGEsXLgQXbp0Sff47NmzoedYCI/wz/lH6HJgGMbslZQ+xNrjh/ynaNGi6NSpU7rHfvjhByxYsAAJCQlpj+l0OuzevRvdu3dHYmJi2uMlSpRAu3bt7JZfQkICLl68+MWf6OjodLGvXr3KMPbj34UQwo+6dbkn3Ny+LUB8PD+5EJLT+LsEYFD5ISbj5gbPQpI20WTcx9hcuZC4bhNYGXeRBwCQHj0MxZ+0cg8hHxM+eQSPDq0hePfOZCwrFCJx9XroA6tmqs14dRzW3l5lMm504A+ZaocQknXUXXqYjJFt28xDJsQWGIbB8MqjTcYtvf4X9Ebb3vi9cEGIr75SYv16ywfB1amjx9mzyfjxRy3kcpumZRcMA3TtqsfJk8moVMn8ghExMQK0bavAqVPOXVhQvtb0tYO674D3TyTJFI1BgxU3l5qMG1ppJA/ZEGeT1zUfFjVcblbsuHNjcSvmpl3z0VesjNR+A03GyXZshfjsv3bNhRBCCHEG0XejcWzMMfwZ8Cd2dNqBR0cegTXQghSEOBq9shTnfqHqHk+ZOA+TRRgk3jxlQgghhPBHq9Li9bmXCJ53BYd67MHaUkuxufpanBx2FHfW3UDMrbdZ8nlAlkuOIm2Ko97sRuh+uS++CRuIhouaoUSn0lD6uPCeDyGEEEIIIYQQklOsWrUKycnJadtVq1bFwIEZj8vx8fHBjBkz0j22bt06xMXF2TQvhUKBAgUKWHRMqVKl8P3336d77MyZM9BoNJzHPXr0CIcPH07bFovF+P333+Hi8uV7EgzDYPz48ShYsGDaYy9fvsTu3bstypfYlyirE8gqLGv+zT1LYknmjRs3Dnfu3MHt27cBAEajEUuWLMHKlSuRN29eSCQSvHr1Kl1FGADw9PTEggULIBLZ78/6/v376Nu3r1mx+/btw759+764b/369QgKCrJlaoQQE+rW1WPZsown7rAsg8uXhWjWzHFXRyUkOxtReTQ23luHd+qMJ3rHpMZg8fWF+LnaBIvOrS9XAUlzFsBt2LcmYxWzZ0JfvgK0TZpb1AYhzkjw4jncO7SBIJp7cOAHSfP+grYh9+r25lh1azlUuiTOmOp+NVHdv2am2yKEZA1t46YwenlxFniR7tkJ1ZTfAKmUx8yItZoWbI7iniXwMO5BhjEvk15g3+Pd6FC8c6bbS0kBpk+XYtUqy4svKJUsJk3SoHdvXbacj1+wIIsDB1IwbZoUy5eb9/unpDDo2VOOefPU6NLF+SogM+9iId27izPG6OoGdftOnDHEPLsebsfblCjOmECfKqjuR9dqxDpNCzbHkIojsOT6Qs44jUGD/kd74USns3CTunPGZkbKuImQHtwP4ZtIzjiXH0Yh7sxlwIwikIQQQkhOolVpcXvrbYStDkP41XAANL6CEEdncDFRhEEbBUb3DqzYi6eMsj+BxlQRBh/O/YQQQoijY40s4p/GISo4Em+uRSAqJBLv7seCNWb9tb9YKYZ/zbzIWyc/AmrnR67SucEIsuEXRIQQQgghhBBCSDZmNBo/KxwwbNgwkwvY16hRA1WqVEFwcDAAIDk5GUeOHEH37t3tlqu5WrVqhSlTpsBoNAIAUlJSEBERgUKFCmV4zK5du9LiAaBly5YoUqQIZztSqRQDBw7E+PHj0x7bsWMHOnfO/FhcYhs5sgjDyZMn7RJLbEMul2P16tUYOXIkLl++nPa4TqfDs2fPvnhMQEAAli5dyvkiRgjJ2YKCDBAKWRgMGV/AXbggoiIMhNiJm9QdowN/wMQL4zjjll3/C33LDICP0tei82s6d0PKjTAoVi7jjGNYFq5DBiH++GkYChe1qA1CnIkg/DU8OrSGMCLcrHjVhMnQdDW9sr3J8+hUWGnGysqjAsdmui1CSBaSSKBp1xHy1SsyDBHExUFy/Ci0rdvymBixloARYGjFkRh5eghn3F9hC9C+WCeTN865nD8vxJgxMjx7JrD42Dp19Jg3T438+bN+0F9mSCTAtGkaBAYaMHKkDKmppp9PvZ7B8OFyvH2rwfDhWh6y5I9syyYwJipIq7t2B5RKnjJyXkbWiMVhC0zGDak4MlP9nJDxQZNwNfIygqOucsY9T3yGkaeHYk3TDXb7m2Nd3aD6bTbc+/XkjBM9ewrF/DlI+dmywpGEEEKIs3p5/iXCVofh7s670KXoAPxXfOHD+zYVYyDEMeldSpqMEanuQ+dJxffMJdByFzM0SvLwlAkhhBBiG6mxqXgbFomo4EhEhb7B27A30CRw36fni1sBd/hU8YNfVX/4VPVHrlK5IRBZ/p0SIYQQQgghhBBCbCc0NBTvPlq4LV++fGYvYN6xY8e0IgzA+/ncjlCEwcXFBV5eXoiJiUl7LC4ujnP+8qlTp9Jtd+zY0ay2WrRogRkzZqQtWn/r1i1ERUXBx4eKPDuCHFmEISAgwC6xxHY8PDywdu1a7Ny5E6tWrcKLFy8yjOvatSsGDRoEJQ20JoRwcHUFKlQwIjRUmGHMhQsZ7yOEZF6fsgOw8tZyvEx8nmFMij4Ff1ybiblfmZ7486nkyTMgun0LkksXOOMEiQlw690d8UdOgnVxtbgdQrI7QdQbuHdoDeHLL19jfyplwLdIHT7aJm3/fXsN4jRxnDEV8lRC/XwNbdIeISTrqLt05yzCAACy7ZupCEM20qF4Z8y6Oh2RyREZxtyJvYXTr06gQf7GFp8/NpbB5MlSbNsmtvhYpZLFpEka9O6tgzPNC//6az0KFUpB795yRESYN4Bw2jQpVCrg55+1zvFcGI2Qr1tlMkzdZwAPyTi/w08P4lH8Q86YQu6F0aJQK54yIs5KLBRjRZO1aLi9tsnPB4ee7sfKm0sxqAJ3IaDM0LZsDU3T5pAeO8IZp1g0D5r2nWAoXsJuuRBCCCGOTBWlwo2/byBsTRjePXo/iOrjQgsfF0368LhIliOHpBDi0AxK00UYhKp7VITBAow2mnO/UUqDJAkhhDgug9aAmNtvERX6BlEhkYgKiUTi84SsTgsAIJKL4F3RBz6BfvCp4g/fKn5QeNM4YUIIIYQQQgghxNGcOXMm3XbNmjXNXnClZs3030dcuXIFKSkpUCgUNsvPWppPFo9yc3PLMPbp06fp5kArFApUqlTJrHY+xF648H4uFMuyOHPmDDp37mxF1sTW6Btv4rAEAgE6d+6Mzp0748GDB7h79y6io6NhMBjg4eGBYsWKoUKFChCLLR+cnzdvXjx48MDi44KCgqw6jhDiGGrW1HMWYbhzR4C4OMDTk8ekCMlBpEIpfgmaiMH/9OeM23Tvb3xbfgiKe1k4qUEsRuLKv+HZuC6EkRlPDgQA0YP7cB05FImr/oZzzE4jxDyCiHC4d2gN0dMnZsWrv26P5GmzbNJP1Ho1lt5YZDJuVOBYWlmZECegr1AJ+pKlILp/L8MYycl/wERHg81DK8FlBxKhBN9WGIrJF8dzxi0KnW9REQaWBbZtE2HyZCnevbN8paI6dfSYN0+N/Pmdc4XVChWMOHYsBX37yhEcbF7hwHnzpEhOZjBtmibbX+pKTp+A8MVzzhhtnXowFCvOT0JOjGVZzA+dYzJucIVhEAqoiCXJvLyu+bCk0Up0O2S64vvkSxNQ2acKqvhWs08yDAPVzDmQnDsLJiU54zCdDi4/jELC3sN0L4EQQkiOwRpZPDz4EGGrw/DoyCOwBjbDwgvA++tKhmFQ8KuCKN+zPEp3LM13yoQQE1iRKwyyfBCqX2UYI0rO+J4e+ZxAE8W53yjx5ikTQgghhBvLskh6mfi+2EJoJKJC3iDm9lsYNIasTg0A4FbQHb5V/OET6Affqn7wKpUbQjHdjyaEEEIIIYQQQhzdvXvpv1eoXLmy2cf6+PggICAA4eHhAACdTofHjx+jfPnyNs3RUk+fPkVSUlLatkKhQMGCBTOMv3//frrtcuXKQSQyf/p+5cqV04owAJ8/pyTrUBEGki2UKFECJUrQ6lKEkMypVcuAv/7KeD/LMrh8WYTmzfX8JUVIDvN10Q5Yev0v3IgOyzDGyBox/cpkrG++xeLzs97eSFy7ER5tmoHRajljpQf2Qr5oPlJHjLa4HUKyI8HLF/Bo3xrCl8/Nitc0a4mkxSsBoW0GNWy8uw5vU7gHIpb0KoXmhVrapD1CSBZjGKg7d4fL1IkZh+j1kO3ejtRvh/KYGMmMb0r3wbyQ2UjQxGcYcyHiHEKjglHZp4rJ892+LcDEiVJcuGD5LUqFgsXUqTr07KmBwPLaDdmKjw+LPXtSMHy4DHv3mleMdMUKCVJSgNmzNbZ6K88SstUrTMak9hnAQybO7/SrE7gZfZ0zJrc8N7qW7MFPQiRHaFigCUZVHmuyAIjeqMfA431wsvM5eMly2SUXY958SP5pPFwm/cIZJ7l0AdKtm6Dp1tMueRBCCCGOIvZhLEJXh+LmhptIjnpfpOhD8YUvFV4AAO8y3ijXsxzK9ygPt7wZrwJDCMl6emVJziIMwmRanMRsrBECXQxnCBVhIIQQklU0iRq8DXuDqNA3iAqJxNvQSKTGpGZ1WgAAkUIMn8q+8KniB99AP/gE+kGeO+tXuCSEEEIIIYQQQojlnj59mm67SJEiFh1ftGjRtCIMH86X1UUYli5dmm67devWnEUVnjxJv0hm0aJFLWrv0+fs0/ORrENFGAghhOQYQUEGCIUsDIaMV6q7cEFIRRgIsSMBI8CvNaaiw/7WnHFHnx3C5chLqO5Xw+I29JWrQPX7n3AdPcxkrPK3KdCXKw9d/YYWt0NIdiJ4+gQeHVpDGP7arHhtg0ZIXLkOEJs30dMUtV6NhWHzTMaNqPw9BIyTz6QlJAfRdOoC5fRJYIzGDGNkWzdTEYZsxEXiir5lBpicLLsobD7WNtuY4f6oKAazZkmwebMYLGv5SuI1ahiwZIkWhQqxMFF3y2lIpcCyZWr4+LBYvlxi1jEbN0qQksJg0SK1rd7SeSV4+gSSk/9wxhh8fKFt1oKnjJzb/JC5JmMGlBsMuUjOQzYkJ/mx2i+49uYKLkSc44wLV73G0BODsKnlDrt9ZkgdOBjSHVshvn2TM85l8nhoGzcDmzu3XfIghBBCsoouRYc72+8gbHUYXl18Pzn7Q4EFIH3xhQ+Pu/q5omy3sijfqzx8K/jymzCxq0+LbZD0Pn16stvzZXApCcRm/JlbpLqX7X6nrMLo3oFhuVcPZ6U+9HxmU9m9rxNCTHOmfm40GBH/MBbRN98i+mYUom++RfyTOOC/S3owYKDIokIH7oU8kKeCN/JU8IF3RV94FPOCQEhjAwg/nKmvE0K+jPo5ITkD9XVCnB/18+xJrVYjIiIi3WN+fn4WncPXN/33jM+ePct0XtbSaDSYM2cO9u/fn/aYl5cXRo4cyXncpzl/+juZ8ulzZrfn4O1Z+5zXXDpV1rZvBSrCQAghJMdwcQEqVjQiJCTjZUAvXMjGS4QSkk3UyVsPDfM3xsmX3BOqplycgMPtT1j14Vnd4xuIwkIhX7+GM44xGuH2bV/EHT8DY8FCFrdDSHYgfPgA7h1aQxj1xqx4be26SFi76f1sTxvZfH8D3iRHcsYUcCuIr4t2sFmbhJCsZ/Txhe6rBpCcOpFhjOjOLQhv34KhbDkeMyOZMaD8YCy9sQgagybDmMNPD+Bx3CMU9SyW7nGVCli5UoKFCyVITrb8Gk8mYzFxog7ffaeHIAeOyxMIgKlTNfD1NWLKFJlZx+zeLUZKCrBihRoy8w5xGPJ1q8F8NOHrS9S9+tisaFROdjniIi5HXuSMcZW4oX+5QTxlRHISkUCEZU3WoOH22nibEsUZe/LlP1gY+idGBY61UzIiqOYugEezBpyvP4K4OLhM+gVJi1fYJw9CCCGEZ68vv0bo6lDc3X4XWtX7Sncfiix86f78h33eZbwx+OZgGgDnpHLndsnqFIg9JVQCXmS8W6B9i9yuGkCai7+csqt404Mg3X0KAl7UpwghhNift48bitehsS+EEEIIIYQQQgjhT1xcXLrC7mKxGLlyWfb9go+PT7rt2NhYm+SWkRs3biA5OTltW6PRIDY2Frdv38bx48fTtZ8nTx6sWLHC5O/0ac6WFmH49DmIi4uz6Hiznfjq84onhFMOHK5MCCEkJ6tZU8+5/+5dAex1nUII+c+E6lPAgPvCPSTqGg4+3c8Zw0U143foqlQzGSeIj4d7355ASorVbRHiqIS3b8Hj6+ZmF2DQVauOhPVbAbntVjjWGDRYGPKnybgRlb+HSEB1AglxNuquPUzGyLZt5iETYiveCm90LdmTM4YFiyXXF6Ztp6QAS5aIUbWqEjNnSq0qwBAYaMCpU8kYOjRnFmD4gGGAoUN1WLIkFSIRd4GCD44eFaNXL3n2utxNToZsy0bOEFYkgrp3P54Scm7zQ+eYjOlXdiDcpR72T4bkSD4KHyxvvAYCxvQL/Kyr03E+3H4V2fWVApHa33TBEdmOrRBzFJoihBBCHF1KTAou/XkJS8oswZpaa3B9zXVokjRgWRYsy4JhmLTiCh8e8yjokbYPAARiARVgICS7ci9jOibhjv3zcAZq7mJyAACZZQMtCSGEEEIIIYQQQgghhJDsIuWTgYkymczi7xAVCgXnOW3t119/Rd++fdN+Bg8ejPHjx2PLli1pxRSkUim6du2K/fv3o3Tp0ibP+WnOn/5Opsg/mb+h0+mg1WotOodFWDbrfrKZHDxkmR/x8fE4cOAA5syZg0mTJmHBggU4duyYfTsAIYSQDNWqZeDcz7IMLl2iCaCE2FuZ3GXRpWR3k3EzLk+GzqCzrhGpFIlrNsDg7WMyVHTnFly/H54tL+gJyYj44nl4tG0OQUyMWfG6ipWQsHkH4GLb1Zi23NuIiORwzpi8LvnQpYTp1wRCSPajadYSRjd3zhjZru2Azsr3e5IlhlQcbnKi7PYHW/A0KgrLl4tRrZoSkyfLEBtr+a1IhYLFpElqHDyYgqJF6Vrtg44d9VizJhUSiXnPyZkzInTrJodKZefEbES2azsECfGcMZrWbWH0oUkMmXXjbRhOveSeSC4XyTGo/BCeMiI5Va2AOhhXbaLJOCNrxLfH+yEqxYyJTlZKGTcRBl8/k3GuY0eCUSXZLQ9CCCHE1liWxaPDj7C9w3b8GfAn/vnhH0Tfi/6s8ALDMGmPSVwkqNSvEvqc6YPhj4dn9a9ACLEVd9ODBakIg5lSzSnCkMf+eRBCCCGEEEIIIYQQQgghWSA5OTndtlQqtfgcnx5j7yIMpojFYvTq1Qv9+/eHl5eXWcd8mrNEIrGoTZlM9tljnz63NsUwWfeTzVARBjM8e/Ys3Y9ez72K+gfLly9H/fr18eOPP2L16tXYvn07li1bhlGjRqF27drYtWuXnTMnhBDyqWrVDBAKuSepXLgg5CkbQnK2n6qOh0z4+QeFjz1NeIIN99ZZ3YbR1w+JqzeAFZkuriLbvQPyZYutbosQRyI5uB/uXdpBkJRoVryuSjUk7NgH1sREaUtpDVosDP3TZNzIwDGQCC270UAIySZkMmjatucMEcREQ0IrSWcrhdwLo3XhrzMOSPSH9tgU1Kvuj4kTZXj71rpbkI0a6XH2bDKGDtVBSB/TPtOsmQGbNqVCoTCvEMOlSyJ06qRAQoKdE8ssloV89QqTYan9vuUhGec3P3SuyZiepXojj4ImjBD7G155NBrlb2IyLjr1LQYf7we90bzvaizFurpBNeMPk3HC16+gnDHFLjkQQgghthT3NA6nJpzC/PzzsaX1Ftzfex8GneGzwgvA+0INYIAijYug/cb2GPNmDNqsaoMCdQpYvGINIcSBiV0AZQHumHgqwmAW9Rvu/dJcgEDMTy6EEEIIIYQQQgghhBBCCM8+XaxeLLb8nvinBQvUanWmcsosnU6HVatWoVmzZhg/fjxUZqx+pdFo0m1b+jx8qWjDp+e0GZbN+p9shJb6NiE0NBQ9evRI2/bx8cGpU6dMHjdlyhRs3br1/SCFL0hMTMSECRPw+PFj/PTTTzbLlxBCCDcXF6BiRSNCQjKewUNFGAjhR4BrXgws/x0Whc3jjJtzbRY6F+8KF4mrVe3og6pDNf13uP48xmSscsoE6EuUhK5BI6vaIsQRyP5eA5efvgdjNJoVr61RC4mbtoN1sa6Pcdl6fxNeq15xxgS45EXXkj04Ywgh2Zu6S3fIN6zljJFt2wxt0+Y8ZURsYXjlUdj3ZHf6B9+UAy6NAW51A4wSWHv718fHiN9+06BVK312LHrLq3r1DNi6NRU9esiRlGT6yQoJEaJ9ewW2b09FrlyOeSNbfPkiRPe4J3roylWAvloQTxk5rwfv7uPQ0/2cMWKBGEMqjuApI5LTCRgB/mq0HI221zX5OeJCxDn8cfU3/FL9V7vkom3VBpomzSA9fpQzTrZmJdRtO0BfvYZd8iCEEEKspVfrcXfnXYStDsOLsy8AIN3YhY8LKnx4PE+pPKjQuwLK9ywPV3/b3ysk2UtMjOnBZDmZRJK+4KRWa979eEfiJi8BSfKLDPdrY24ikf4OTFLEvYKCY79e5I14eh6zLWfo64QQblnVz7VJGrwNi0RUSBSiQiIRfestjFoDL21zUfgqkae8D/JU8EGeCt7IXToPRHIqJkSyP3pPJ8T5UT8nJGegvk6I86N+bp3cuV2ytP1PiwfodDqLz/FpIQepVJqpnEzZt29fum2VSoWYmBjcvHkTBw4cwNmzZwEABoMBO3fuxK1bt/D333/D09Mzw3N+mrOlz8OnzwHw5cIMmVa4t+3P6eSoCIMJx44dSxt0wDAMOnfuDIGAe/W+48ePY8uWLelWjPgSlmWxbt06FC9eHO3atbNp3oQQQjJWq5aeswjD3btCvHsHeHnxmBQhOdSIyqOx8e46xGniMoyJSY3G4usL8VO18Va3o+47AOLroZBt3cQZxxiNcBvUF/FHT8FQtJjV7RGSJVgWirm/Q/nHb2Yfoq1XHwl/bwEUXEMEraM1aLHAjJWVh1ceDanQvjdKCCFZS1+1GvSFi0D09EmGMZLjR8DEvQPrSRfh2UX5PBVRN299nH11GnjSBLg4BnhqevVyLkIhi759dfj5Zw3c3GyUaA5QvboBu3enoHNnBeLiTBdiuHVLiHbt5NixIxU+Po5XiEG2eoXJGHX/QaAKHZm3MPRPkzGdS3RDgGteHrIh5D0vWS6sbLoObfY0g87I/WXk/NA5qOYXhEYFmto+EYaBauYciC+chyA54wlTDMvC9fthiDt1AZDJbJ8HIYQQYoWD3x3Ena13oEl8Xxrv4/EOH3x4TJFLgTJdy6Bi74rwr+LPf7LEYWW04Ah579OnJzs+X3plKUhijme4X6S6ly1/L74JNFGc+41Sb3oeszFn6OuEEG589HOjwYj4J3GIvh6Ft2FvEHE5HLF3o4EsfkkRKUTwrugLn8q+8K7sB59AX7j4fV6MjV77iDOg93RCnB/1c0JyBurrhDg/6ufZk1KpTLet0Vi+fNenxyjsMLeBi4uLC1xcXFCwYEG0adMGFy5cwOjRo5GQkAAAePDgAX7++WcsX748w3N8mvOXiipwUavVnz326XNrE9W5F9Ujn+OuJkBw5cqVdIMRmjblHszHsizmzZv32WOf/gDvBzmwLIs5c+ZApaKq54QQwpdatUxXDr94keoUEcIHd6kHRlf5wWTc0ut/ISr5jfUNMQyS/pgHXcVKJkMFiQlw69UFTHzGhSEIcTg6HVzGjrSoAIOmcVMkbNhmlwIMALD9wRa8SnrJGeOn9EePUt/YpX1CiANhGGi6dOcO0Woh3bOLp4SILWg0QLnXc4GlN4CNxzJdgKFRIz3OnEnBb79RAQZrVKhgxN69KfD2Nq/69/37Qnz9tQIREY5VyEAQGQHpof2cMUZPT6jbdeQpI+f1NP4xdj3azhkjYAQYXmkUPwkR8pFAn6qYXHO6WbHfnRiIpwkZF3rKDGO+/EieMNlknOjxIyjn/m6XHAghhBBrhCwPgSZRkzY24cPiER+2BSIBSrYtiS67u+D7iO/RYlELKsBASA6kdynJuV+giwGjjeEpm+xLoH3Lud8o8eYpE0IIIY5CFZGER3vu48KkM9jbdhtWF12MrbX/xslhR3Fr9XXE3smCAgwM4FkiF0p2K4N6cxqh86leGPB4GL7e2xk1fq2LIq2KfbEAAyGEEEIIIYQQQogpnxYfUKvVFhfQSElJ4Twn32rVqoXly5dDIPhv+v2///6LCxcuZHjMpzl/+juZkpqamm5bJBJBKqWFLh0BFWHgkJKSgkePHqVtBwQEoEiRIpzHnD17Fs+ePUsbxAAAdevWxd69e3Hz5k2cPHkS33zzTboXknfv3mHnzp32+SUIIYR8pmpVA0Qi7gu6ixeFPGVDCOlbdiDyuxbgjEnRJ2P2tVmZa0gmQ+KajTDmymUyVPTkMdwG9QX0+sy1SQgPmIR4uHfrCPmGdWYfo2nZBolrN9ltpVadQYf5oXNNxo2oPBpSId0cICQnUHfqCtbEqvWybZt4yoZkRnw8sGCBBFWqKLF4ciXgbflMna9kSQO2bUvB5s2pKF7cvAIC5MtKlTJi//4UBASY9zw+eSJAmzYKvHjhOIUYZH+vBmPgLpyo7v4NIJfzlJHzmhv8B4ws999K2yLtUNijKE8ZEZLegHKD0brI1ybjEjTx6HOkO1Q6+xS6VvcdAF1QDZNx8r/mQ3Tzul1yIIQQQqz1afEFv8p+aLagGb6P+B5d9nRBya9LQiim78MIyakMSu4iDAAgUt3nIZPsTaCJ5txPRRgIIcS5sSyLhKdxuLf5Nk4OP4qNVVZjfcWV+Ofbw7ixNAQRl8KhS9bxnpc8txwFmxZGtXG10HpHB/R/NBTdzvVGgwVNUeab8shdNg8EIho+TgghhBBCCCGEkMzz9PQE89H4YJ1Oh9jYWIvOERUVlW47lxlzfuytUqVKaNOmTbrHdu/enWH8pzm/eWPZIrSfPgeenp4WHU/sh+6icXj+/DkM/x/0yzAMypUrZ/KYQ4cOpf37wzHLli1DyZIlIZFIEBAQgF9++QX9+/dPW3WCZVkcPHjQbr8HIYSQ9FxcgIoVuScaXLhAg84I4YtUKMW4oIkm4zbd+xuP4h5mqi1j3nxIXLUerNB0H5f8ewrKKRMy1R4h9iZ48RweLRtDcva02cek9uqLxFV/AxKJ3fLa+XAbXiY+54zxVfqhR6nedsuBEOJYjHnzQVe7LmeMOCwUwgc0sNtRvX7NYOJEKSpWdMGMGVJERWXutmKhQkYsWZKK06dTUL8+96R7Yr7ChVns25eC/PnNK8Tw8qUAbdsq8OSJAxRi0GggX7+OM4RlGKT26c9PPk7scdwj7Hq03WTciMpjeMiGkC9jGAbzvlqEQu6FTcbef3cPI05+Z3EVfbMIBEia9xdYE5XlGYMBLqOGATr+B9UTQgghXFiWBSNgUOeXOuh3vh+ChgdBkStrV44hhDgGvbKEyRhh8j0eMsneBNoozv1GqQ9PmRBCCOEDa2QRey8Gt9dcx/FBh/B3+RXYVH0tTo86jgfb7iLxZQLvOQnEAvgE+qH8oEpovLwFel7rjz53BqPFhq9RZXQQ8tUrAKkbLYxACCGEEEIIIYQQ+5DJZPD390/3WEREhEXniIyMTLdduLDp8UJ8aNy4cbrtsLCwDGMLFSqUbvvT38mUT58zR3kOCBVh4BQeHp5uu2hR06t+nTlzJq2wAgAMHToUAsHnT/PQoUPh6uqatn3nzh2oVPZZqYkQQsjnatfmXt3+/n0B4uP5yYUQArQr1hHl81TkjDGwBky/PDnTbelq1YFq+iyzYhXLl0C2eUOm2yTEHkTXrsCzeQOIHj4w+5jkMT9BNWc+YEYhEmvpjXrMC5ltMm54pVGQiWR2y4MQ4njUXbqbjJFt2chDJsQSd+4IMGSIDFWrKrF8uQQpKZmbrJ8vnxHz56fiwoVkdOyot+dbUo6VPz+LAwdSULSoecUtIiIEaNNGgXv3svZWsfTAXghiuFeP1DZtDmOBgvwk5MTmBv8OI8tdqKNpweYok7ssTxkR8mVuUnesbroBMqHpzw0Hn+7DgtC5dsnDULQYkn8YZzJOfPsmFIsX2CUHQgghxBofFoUAC5yfeR5zfOdg/8D9eHH2RVanRghxBCIXGGQFuENUVISBE2sAo43hDDFK8vCUDCGEEHswaPR4ExyB60tDcOSbfVhTaim21VuPsz+fwuO9D5ASlcx7TmIXCfLVL4Bq42qh7d5OGPB4KDoc6Yba0+ujWLuScCvgnm71SUIIIYQQQgghhBB7+7QAwZMnTyw6/tN4RylAkD9//nTbMTEZfyfwac6PHz+2qK2nT59yno9kHSrCwCE6+v2g3w8FFby9vTnj79+/j4SE/yrZenp6om7dL6/yqFAoULt27XQrMz14YP7kKUIIIZlTowb3ZBSWZXD1Ks0GIoQvAkaAX2tMNRl35NlBXIm8nOn21P0GIbVXX7NiXX4YBdHlS5lukxBbku7cBo/2rSDg+CD/MZZhkDRrLlJ+Gg/YecDFzofb8DzxGWeMt8IHPUv3sWsehBDHo2nZBkalC2eMbPsWWkHaQVy6JETXrnLUr6/Ezp1iGAyZe/+Q572PxYtTcelSMrp310MkslGi5Iv8/Fjs3ZuKUqXMK8QQHS1A27YKXL6cdZ+D5atXmIxJ7TeIh0yc26O4h9jzeKfJuB+qmp5wTggfyuYuh5l15pgVO/PKNPzz/Khd8kgdMgK68hVNxinmzILw7h275EAIIYRY6uOJVyzLQpOowfU11/F3/b+xoPAC/Dv5X7x78i4LMySEZDW9S0nO/cLk+zxlkj0x2lgw4C5yaJRwjzUjhBDiWFSRSXhy4CEu/HoGu1pswcoii7G7xVZcnHQGz44+gSZOzXtO8jwKFGldDLVnfIVOJ3qg/8MhaL2tA6qMDkJAzXwQycW850QIIYQQQgghhBDysVKlSqXbDgsLM/vYt2/fIjw8PG1bLBajSJEiNsvNlkQcA19Llkz/ncvt27eh13MvIP2x0NDQdNufPqck61ARBg5qdfobpkqlkjM+JCQk7d8Mw6Bu3bqcFWVLly6dbvvly5dWZEkIIcQaVasaIBCwnDFZOfmEkJyobt6vUD9fQ5NxUy5OSFfIyioMA9XM2dDWqGU6VKeDe78eELyiazXiAPR6KH/9BW5DBoLRaMw6hJVIkLjqb6j7DbRzcoDeqMe8kNkm44ZXGgW5SG73fAghDkaphKbN15whgphoSE4c5ycf8kXXrgnQoYMcbdsqcOqUDSolFD0MfNMQqf1LwbfGSUgkmT8lMY+3N4s9e1JQvrx5hRji4xl07izHoUP8V8gQXQ+FOOQaZ4y+aDHo6n7FT0JObG7wLBhZ7gkizQq1RPk8FflJiBAzdC/VCz1L9TYZx4LF4BMD8Djuke2TEImQNH8xWBNVhBitFm5DBwFare1zIIQQQszUZnUb5KuZDyzLpt1LZxgGDMOkPRb/PB5np53FX8X/wpraaxCyMgTqBP4nlBFCspbBhXsAn0h1j6dMsieB9q3JGKPUh4dMCCGEWMOgNeBNSCRClwTjUN/9WF12GdZXWIlj/Q/ixrIQRAVHwqg17/66LbkX8kDJbmVQf0ETdL/cF31uf4umq1uj/MDKyFPeBwIRDfsmhBBCCCGEEEKIY/nqq6/SbV+8eNHsOT8XLlxItx0UFGRyHjdfIiIi0m3nzp07w9giRYogf/78adspKSlmF6P4NJZhmM+eU5J16G4cB80nk5q4KpUA76uTAEh7gahWrRpnvK+vb7rtpKQkS1MkhBBiJRcXoFw57kkHly7R0qyE8G1ijalgwL3KcnDUVRx+djDzjUkkSFyzEYb8BUyGCmJi4P5NN0Clyny7hFiJiY2Fe5f2UCz7y+xjjO4eSNi6G9rWX9svsY/sfLgNzxKecsbkkXujV+m+vORDCHE86m69TMbINq/nIRPyqZs3BejRQ46WLZU4dy6Tn4WEGqDSamBIGaBnS6DwKYAB5oeYt5I5sR0vL2DXrhRUqWLeQFG1mkG/fjKsWcPvylnyNStNxqT2GwgI6HZ2Zjx4dx97Hu0yGfdD1XE8ZEOI+RiGwcy6cxDoU9VkbJI2Eb2PdEOSNtHmeRjKlkPK8FEm40R3bkExZ5bN2yeEEELMValvJfQ91xfD7g9DzbE1ofRWphVf+FCM4eOCDK8vvcahwYcw128udnbZiYeHHoI1ZrIQMiEkW9ArS3LuF+hiwWijecom+zGnCAMr8eYhE0IIIeZIjlLhycFHuDj5DHa32opVRf/C1oYbcfaX03i05wGSXvM/fpcRMMhdzhvlBlZC09Wt0PvWIPS40g8NFjRFqW5l4VHYk3MhOEIIIYQQQgghhBBHULlyZXh6eqZtv3r1CleuXDHr2J07d6bbbtCggU1zy4xTp06l2y5RogRn/Ke5f/q7ZeTw4cNISUlJ2y5btix8fKjIs6OgUascZDJZuu2P/5C/JDQ0NN0NzypVqnDGS6VSAEg7xtT5CSGE2Fb16tyTUG7cEIBemgnhV9nc5dCpRFeTcdMvT4LOoMt0e2yuXEhYvxVGpYvJWNGdW3Ab9i1g5C7gQog9CG/fgmfTryA596/ZxxgKFET84RPQ1a5rt7w+pjVoMeea6YlGQyuNhEKs4CEjQogj0gdVh75IUc4YyYnjEES94Skj8vw5g/79ZWjUSIl//slk8QX5O6DOdGBUAaDtAMD7brrd58LPIPjN1cy1QSzm7g5s356CWrX0ZsWzLIOff5bht98kMLMYdaYwMTGQ7uH+ssGodIGmS3f7J+Pk5gbPAgvu/6ktCrVGudzlecqIEPNJhVKsbbYRPgpfk7GP4h9i6MlvYWRt//k95fufoC/O/YUqACgW/gnRNfO+TCaEEELsJVfxXGj8R2OMfj0aXXZ3QfFWxcEImLRFJT4txqBX63F3511sbbMVfwb8iWNjjuHNdfp8TogzM7iUMhkjUt3jIZPsSaCJ4tzPgoFRnPGqWIQQQuzHoDMgKuwNbq4MxfFvD2FD4Cr8XW4FjvU7gOtLQvDmagQMavOKF9uSxE2KvHXyo/Koami1tR36PxqCzid7os6M+ijSujiUPqbHrhBCCCGEEEIIIYQ4GoFAgHbt2qV7bPHixWnfS2bk0qVLCA4OTttWKpVo3ry5XXK01JMnT7B79+50jzVs2JDzmA4dOqSbX37o0CE8efKE8xiNRoOVK9MvYtWxY0cLsyX2REUYOLi4vL+h+eEPPzw8PMPYqKgovHjxIm3bw8MD+fPn5zz/p0UXRCJacZ0QQvhkqgiDXs8gNFTIUzaEkA9+rjYBUqGUM+ZJ/GNsumebVbINpcsgaclKsGasHiA9fADKqb/apF1CzCXduwueLRtB+PKF6eD/01UNQtyRUzAUK27HzNLbfG8DXiZx55hbnhu9y/TjKSNCiENiGKi79eIOMRgg3b6Vp4RyLpUKmD5dgtq1lThwQJypcxUsaMTMmWoMXDsTaDgRcM14APr8kDmZaotYx8UF2LQpFfXrm1eIAQDmz5diyBAZ1Go7JgZAtnk9GI2GM0bTpRtYVzf7JuLk7sXexb7He0zG/VB1HA/ZEGIdX6Uf1jbbCIlAYjL26LNDmBv8u+2TkEqRNO8vsALur9cYoxGuw74FkpNtnwMhhBBiIYFQgJJfl0S3/d0w6uUoNJjRAJ5FPNOKL3woxvBxQQZVlApX5l/BisAVWFZhGS79eQmqN6qs/lUIITamV5YAC+7vx4RUhCFDAm00535WnAsQ0FgwQgjhQ0pUMp4eeoSLU85iT+ttWFXkL+xquhnnx/+Lx3seIOlVIu85ieQi+FUPQIXBgWi8rAV6XO6L/o+GoM2ujqj+S23kb1AIElfusTGEEEIIIYQQQggh2cXAgQOhUPy3UOPVq1c/Ky7wsaioKIwfPz7dY9988w28vLw42ylRokS6nytXMl4kRaVSYfLkyXjzxrLC8w8fPkT//v2h0/23cGxAQACaNWvGeVzx4sXTFZHQ6XT46aefoFJ9+XtWlmUxY8YMPH/+PO2xfPnyoUOHDhblS+yLijBw8Pf3T7d969atDGNPnz6d9m+GYVCpUiWT509KSgKAtIouSqXSmjQJIYRYKSjIdEXzy5epCAMhfMvrmg8Dyg02GTf72kyodLYZ9Klt3hIp4yaaFatYshCydatt0i4hnLRaKCf+DLdBfcGkppp9mLp9R8TvOgA2N3+rK6XqU/FnyB8m44ZUHAmlmD73EJLTabp0Ayvkvs6WbdkAmKiAS6zDssDWrSJUr67EwoVSaLWmC1FlJDDQgDVrUnHpUjL699dheNBAkxNjj784ilsxN61uk1hPoQDWr09Fs2Y608H/t2uXGF9/rcCbN9b/nXDS6yE349o6td8g+7Sfg8wJngUW3K+rrQq3RZncZXnKiBDrVPGthll155oVO/vaTBx5dsjmOeirBiF16EiTcaJnT+Ey1bx7DYQQQghfXP1cUWdcHQx/OBx9/u2D8j3LQyQTcRZkiLoVhX9++Afz8s8DAJMr1hBCshGhAkZ5Ac4QUfJ9npLJfgTajAuRAoBR6s1TJoQQkrMYdAa8vRGFW6vD8M/gQ9hQZRXWlVuOo30P4PriYEReCYdBbXpMmK1JXCXI36gQqk+ojfaHuqL/o6Fot78Lak2th2LtS8K9sGe6lRAJIYQQQgghhBBCnImXlxcGD04/D2ju3LmYPHkyoqL+u59uNBpx4sQJdO3aFeHh4WmPe3t7o18/2y72aDQasWXLFjRq1AiDBw/G3r178fLlyy9+36nVahEaGopJkyahffv2iIyMTNvHMAwmTJgAmUxmss1Ro0ZBLpenbd+6dQs9evT4rFjEs2fPMGLECGzbti3d42PGjIFYnLmF1YhtUbltDiVLlkz7N8uyuHLlCuLi4uDp6flZ7N69e9PiGIZBtWrVTJ7/9evX6bbz5MmTuYQJIYRYJHduFsWKGfDoUcYTwKgIAyFZY2Tl77Hp3t+I18RnGBOd+hZLry+y2UqtKSPHQHj/LmS7d5qMdRk3Fob8+aFr0NgmbRPyKcHrV3Ab2BvikGCLjkse8xNSfvwF4Hnwxvo7a/AmOZIzJo/cG/3KDuQpI0KIIzP6+ELbsDGkx49mGCN6/Aiia1ehrxbEY2bO7+lTBmPGyHDhQuZuCTZtqsfQoVoEBRnSveX4Kv3QvVQvrLvDPal+QchcrGr6d6ZyINaRSoHVq9UYOxbYssW8G/WhoUI0bqzAunWpCAw02jQfyfGjEL5+xRmjrfMVDMVL2LTdnObG2zAceLKXM4YBY7PPVoTYW8/SvXEz+rrJ9xsAGHJiII52OIUSXiVNxloi+cdfIDlxHKJ7dzjj5GtXQdO0BXQNGtm0fUIIIcQWCtQtgAJ1C6DFXy1wa/MthK0JQ0RwBACkFWIAkFaMgdWz6R5Tx6kR+ygWuYrlyrLfgRCSeXplSQhTn2e4X6iiIgwZEWjfcu43Snx4yoQQQpwba2QRcycar8+8wKszL/Hmajj0qfqsTguyXHL4Vw+AX4288K+RF7lK54ZASOviEUIIIYQQQgghJOcaOHAgwsLC0i14v2XLFmzfvh3+/v5wdXXF69evkZiYmO44mUyG+fPnw83NzS556XQ6nD59Oi0vpVKJPHnywNXVFSzLQqVSITw8HDrd5wtcMQyDadOmoUGDBma1VaBAAcyYMQNjxoxJK/Zw//59fPPNN/Dy8oKfnx/evXuHN2/efFYMolevXmjevHkmf1tia3THj0OuXLlQtGjRtG21Wo3ff//9s7h//vkH169fT1eltm7duibPf/fu3XTbefPmzUS2hBBCrFG9Onfl8+BgIb5wDUUIsTMPmSdGB/5oMm5x2EJEpXCvMmM2hkHSvMXQVaxkOtRggNuAPhDeuW2btgn5iOSfo/BsWNuiAgysQomE1euR8tN43gswqHQqLAj902Tc6MCxUIgVPGRECMkO1N16mYyRbdnAQyY5g04HLFwoQb16SqsLMIjFLLp10+HcuWRs2JCK6tUNX3zLGVZpFIQMdzG7A0/24lHcQ6vyIJknFgPz56vx/fcas4+JihKgbVsFNm0Sw5aL3spXrzAZk9p/kO0azKGmX55sMqZNkXYolau0/ZMhxEam1/4dQX41TMYl61TodbgLYlNjbZuAVIrExSvAmlF53nXUUDCxNm6fEEIIsSGpmxRVBlfBwKsDMfjGYFQbXg0yT1la8YUPBRkYhkn3WMLLBCwuuRgrq63E1b+uIiUmJat/FUKIFQwupTj3i5LvwaY3A5yIQGOqCAMtxkMIIdZKfJmAuxtv4djAg1hbeil2NNyIS1PP4fWZF1lWgME1nxuKtS+BerMboev53uh7dzCarW2DCoMqI085byrAQAghhBBCCCGEkBxPIBBgwYIFaNmyZbrHDQYDXr16hbt3735WgMHDwwMrVqxAYGAgb3kmJyfj+fPnuHXrFm7fvo3nz59/sQBDwYIFsW7dOnTq1Mmi87ds2RJz5syBTCZL9/i7d+9w584dREZGflaAoV+/fhg/frzlvwyxO4b99P8WSWfZsmWYP39+2oAChmFQo0YNdOjQAR4eHggJCcGaNWug0WjS9pcpUwY7d3KvoKzX6xEUFISUlBSwLAuRSITg4ODPOhYh9hQdnZTVKTg0iST9pBGtlnuyPsmeduwQYehQOWfM0aPJqFzZtqt9EsdBfd1xaQwa1NwciFdJLznj+pTpjz/qzbNZu4LICHg0rQ/hm0iTsYaAvIg/egpGH1+btU9sL9v0c70eylnToVhouqDBxwwFCiJh/VYYSmXNpLmFoX+anNgX4JIXl3uEQSqU8pMUyZGyTV8n72m1yFWxJAQxMRmGGJUuiL31EHBx4TEx53P3rgDDhslw+zZ3YYSMiMUsevbUYeRILfz9zbuNOOLUd9h6fxNnTOcS3fBXw+UW50N93bbWrRPj55+lMBrNL+LUsaMOf/yhznTXFD64D6861ThjDHnz4d3VG4DIuuIhBDj7+l903N+GM4YBg7Ndr6CEV0mesuJG/ZyY623KWzTeUReRyREmY6v5VsfONvshE9n2Oxj5wj/hMn2yyThN46ZI3Lid96J5joz6unXy5HHN6hQIITmEQWvAvT33cH3NdTw9+RSskU23KAWAdAODGIYBI2RQpHERlO9VHiW/LgmRjK7jszMaS8DNma5lpBFb4HbnW86YmLqPwUq9ecoo+/C8GPS+SEUGUgoMR3LxGTxmRGzNmfo6IY5OHZeK8POv8OrMS7w++wKJzxOyNB+hVIg8FXzgW8UPPlX84VvFD0pf+r6KkOyK3tMJcX7UzwnJGaivE+L8qJ9bx1HHERw7dgxLly7FvXtfvo+uUCjw9ddfY9iwYciVK5fZ5y1RokS67fXr1yMoKOiLsSzLIjg4GGfOnMGVK1dw7969LxZb+JhYLEaVKlXQvn17NGvWDBKJxOzcPvXq1SvMnz8fx44dy7DdqlWrYsSIEahWjXssJck6VITBhKSkJDRt2hRxcXEAkFZo4WMfHvvw33nz5qFZs2ac571w4QL69++fdlzp0qWxe/duu/0ehHwJDZzgRhdvOcOrVwwCA7m/JJs8WY0hQ7gvskj2RX3dse18uA1DTgzkjBEyQpzrehVFPYvZrF3RzevwaNMMTIrplbt0FSohfu9hQKm0WfvEtrJDPxeEv4brdwMguXzRouO0XzVA4vI1YD297JQZt0RNAqpsLId4TTxn3J9fLULP0r35SYrkWNmhr5P0lJPGQ7F0EWdM4oIl0HTryVNGzoVlgVWrxJg6VQqNxvIJn0Ihi65ddfj+ey3y5bPs9uHjuEeotaUKWGR8nJAR4nKPMBRwK2jRuamv296RIyJ8+60MarX5fydFixqwcqUaZcpYX7DQZewoyNev4YxRTZiM1BHfW91GTseyLJrtqo+wt6Gcce2KdsDyJmt5yso06ufEEmFRIWiztxk0Bo3J2PbFOmJpo9WffceTKQYDPNo0g/jaFZOhqmkzkfrtUNu1nc1RX7eOow6eIIQ4t4SXCQhbE4br664j4eX7yXAfv59+WowBACQuEpRsVxLle5ZH4UaF+U2Y2ASNJeDmTNcyosTr8LxSlzMmPvAAdF71eMoo+8j1bwEIdHEZ7lcVm4HUgsN5zIjYmjP1dUIcjT5VhzfBkXh99iVenXmB6BtR4PhKwe5c87rCt6o/vCv7wbeKH3KX84ZQYl1xa0KI46H3dEKcH/VzQnIG6uuEOD/q59Zx9HEEL168wI0bNxAVFQWdTgc3NzcUKVIElStXhlTK7wKPWq0Wjx8/xsuXLxEdHY3k5GQAgKurK1xdXVG4cGEUL148U4UXvkSlUiEkJATPnz9HcnIypFIp/Pz8EBgYCB8fH5u2RWyPijCY4ciRI/j++/8G+376lH08wKBmzZpYvXq1yXNOmjQJ27ZtSzu+e/fumDhxoo0yJsQ8NHCCG1285RyVKikRHi7IcH+zZjqsX6/mMSPCJ+rrjs3IGtF4Rz3cirnBGdeycBusbbbRpm1Ljh2B2zddwZhxuaxp0gyJ6zbTCr0OytH7ueTAXriOGQFBfLxFx6UMG4Xk8ZMAYdYN/vj96gzMDf6dM6agWyFc6BYMsVDMU1Ykp3L0vk4+J7x/D151v1x99gNdUA3EHzjGU0bO4+1bBiNHynDypHXXJu3b6/DjjxoULmz9bcOBx/pg3xPugqO9y/TH7HrzLDov9XX7uHpVgN695YiNzfiz8adkMhaTJmnQt68OAvMPAwAwce+Qq2IpMKmpGcawUilir98Ha0GVa5LegSf70P9YL84YkUCE892uobB7EZ6yMo36ObHU1vubMOLUd2bFfl/lR/xcbYJN2xc8fQKvBrVMFnJkxWLEHz4BfYVKNm0/u6K+bh1HHzxBCHFuLMvi6YmnCFsVhvv77sPw/9fujAoyAAAjYPCr/lde8yS2QWMJuDnVtYwhBblP+YHhmPmaVOIPqPMP5jGpbMCgRp5T3pwhiWVXQ+PXiaeEiD04VV8nJItpEtSIvBqByMvhiLwcjrfX38Cos77Ib2YIJELkKe8N3yr+yFsjAH5V/eHi//7zNvVzQpwTvacT4vyonxOSM1BfJ8T5UT+3Do0jIMS+LBwemzM1b94cU6dOhVgsBsuyYBgm3Q/LsmBZFuXKlcPcuXNNni85ORmHDh1KNxihVq1a9vwVCCGEcAgK4r4wv3pVCGPWfO9HSI4nYAT4tcZUk3GHnu7H1UjTq05aQtu0OZKnzzIrVnr8KFzGjny/5DQh5lKp4DJqKNz7f2NRAQZWoUDi8jVI/nVqlhZgiE2NxfIbS0zG/VB1HBVgIIR8kaFkKegCq3DGiK9cgvDJI54ycg5nzgjx1VcKqwowVK5swOHDyVi2TJ2pAgwAMCpwrMmYLfc2IFIVkal2iG1Uq2bEsWMpKF3a/C+u1GoG48bJ0KmTHK9fW7aqvGzjes4CDACg+boDFWDIBL1Rj5lXTH+W6lmqt0MVYCDEGl1L9sDAcuZNCPsz+A9su7/Zpu0bCxeBavIMk3GMTgfXQX3BqGhCIyGEkOyJYRgUaVwEHbd1xJiIMWg6ryl8yvmkjZf4EPPhB0CWrmZMCDGTUAGjvCBniEh1n59cshGBNspkjFHqy0MmhBDimJLfqPBo7wOc/fkktn21HquLL8HhHnsRtuga3lyL4LUAg9LfBUXaFEetqfXQ/nBXDHwyFB0Od0OtqfVQrG2JtAIMhBBCCCGEEEIIIYQQ8ikqwmCmTp06Yd++fejQoQM8PDzSDSQoWbIkfvnlF2zcuBEeHh4mz7Vr1y6oVKq046VSKRVhIISQLFS9Ovckk3fvBHj0iN4yCckq9fLVx1f5GpiMm3pp4merbGVW6sDvkDLgW7Ni5Zs3QDFrmk3bJ85LFBYCz4a1Id+8waLj9CVLIe74GWjadbRTZuZbfH0BVDruyUPFPUugfTFa5YkQkjF1N+4V2gFAtmUTD5lkfywLLFokQZcucsTEWPb5xcfHiL/+SsXhwymoUsU2Ax/L5C6LpgWbc8ZojVosubHIJu2RzMufn8XBgylo1Upn0XHnzolQt64SW7aIzKtJptdDvmaFybDUQeatak++bOv9TXgcz13ERiFSYEyVn3jKiBD7mlxzBurk/cqs2O//HY6L4edt2r66dz9omnK/7wGA6NlTuIwdRUUcCSGEZHtyLzmqj6yOwTcGY+DVgQgcFAiJqyTdOApCSPahdynFuV+UfI+nTLIPgeaNyRgqwkAIySlYlkX8kzjc3XQLJ4cfxcaqq/F3+RX4Z9Ah3F5zA7F3Y3grziWQCOET6IcK31ZGk1Wt8M31geh9fRCarmqFCoMD4VvFH0Kp5UWsCSGEEEIIIYQQQgghORPD0jfgVklOTkZycjI8PDwgkUgsOjYsLAyxsbFp266urggKCrJ1ioSYFB1NK25xkUjSryyt1Zq/GiTJXh48EKBOHSVnzB9/qNGnj2UTUUj2QH09e7gVcxONttcBa+Kb+XXNNqNF4Va2bdxggFvvbpAeP2pWeNLM2VD3N69wgzNhWSA5GXj3jkFcHIPERAYGA2A0vv9hWUCpBFxdWbi4sHB1BTw9WQiFps+dWQ7Vzw0GyBcvgHLWdDB6vUWHqjt3Q9Lvf75/IrNYVPIbVNtUAal67hWsVzddj9ZFvuYnKZLjOVRfJ2ZjkhKRq2wxMKkZv54YfHzxLuwuIKJBcRlRqYBRo2TYv19s8bF9+mgxYYIGbm62zysk6hqa72rIGaMQKRDc6zZyy3ObdU7q6/ZnNAJ//inBH39ILT62SRM9Zs9Ww88v4+t2yYG9cO//Ded5tNVrImG/edff5HPJumTU2FwZb5IjOeNGVR6LX6r/ylNW5qN+TqyVoIlHy92N8TDugclYD6kHDrc/iaKexWzWPhMbC88GtSCMjDAZm/TbH1APGGyztrMj6uvWyZOHVuckhDguXaoOd3fcRdiaMLw4+wIAwDAMfjU43jUnMY3GEnBztmsZ5aPJUDz/M8P9RpEHYr96ATAMj1k5NknUPrjf5C4wG1M/HKyIrt+yM2fr64TYitFgROydaERcDkfk5XBEXglHanRKluSi9FXCp4o/fKv4wbeqP3KX84ZIZv73SdTPCckZqK8T4vyonxOSM1BfJ8T5UT+3Do0jIMS+qAgDITkYDZzgRhdvOQfLAqVKKfHuXcarxbZvr8OyZWoesyJ8ob6efQw9MQg7Hm7ljCnqUQxnu16BSGDjSZoqFTzaNIP49k2ToSzDIHHV39C2/tq2OTiIuDggLEyIR48EePZMgKdP3/+8ecNAq7Vs8J1IxMLXl4W/vxEBASwKFjSiePH3P0WLGiGX2yZnR+nngpcv4DpyCCQXzll0HCuTQTVrLtTdejrMAMex/47C+rtrOGPK5i6PE53OQsBYtho7IdZylL5OLOc67FvItm/hjEnYtB3axs14yih7efqUQZ8+cty/b1llo6JFDfjzTw2qV7dvX+m4vy3Ovj7NGTO80mhMrDHFrPNRX+fPiRNCDBsm4/ys/CUuLizGj9egTx/dFwtuebRuCvGVS5znSFi9AdrWbS1ql/znj6u/YU7wLM4YD6kHrvW8CXepBz9JWYD6OcmMF4nP0XxXA8SkxpiMze9aAAfbH4ev0s9m7Ysvnod7+1ZgjEbOOFYkQsLug9BVr2mztrMb6uvWocEThJDs4t3jdwhdHYqb62/i+/DvszodYgUaS8DN2a5lpJFb4XZ7EGdMTN1HYKU+PGXk+GQvl8H1wY8Z7jcKXRDbwHSBNuLYnK2vE2Itg0aPqLA37wsuXA5H5NUI6FTaLMlF4aNE3rr5ka9eAfjXzAuXAFcwmfgOnfo5ITkD9XVCnB/1c0JyBurrhDg/6ufWoXEEhNgXFWEgJAejgRPc6OItZ/nmGxmOHs141di8eY0IDU3mMSPCF+rr2cerpJeouTkQGoOGM252vfnoXaafzdsXREbAo1kDs1a0ZCUSJGzdDV3tujbPg29PnzI4fVqEkBAhQkOFePqUnwn1DMOiSBEjKlc2onJlA6pUMaBUKSPEli/wnfX9nGUh27AOyknjIUhWWXSovkhRJK5aD0OZsnZKznKP4x6hztZqMLDcz+PGFtvQpGBznrIixAH6OrGa+OJ5eHzdgjNG06I1Etdt4imj7OPaNQF69ZJbNEmeYVgMHarFjz9qIZPZMbn/uxh+Hl/v4/7/qxApEdzrFnLLc5s8H/V1fkVEMBg0SIarVy0vchYYaMCcOWqUKfPfRGTRjTB4Nq7HeZwhbz68u3oDENm4sFoOEaEKR43NlZGqT+WMm1RjOoZWGsFTVpahfk4yK/jNVbTf1wpqg+mCqqW8SmPf10fgIfO0WfuK2TOhnD3TZJwxjzfiTpyF0c/fZm1nJ9TXrUODJwgh2Q1rZMEIHKOwLLEMjSXg5mzXMqLEG/C8UoczJr7yfuhyfcVPQtmA8tEUKJ7PzXC/XlEEcbXCeMyI2IOz9XVCzGU0GBFz6y1en32J1+de4c3VcOhT9VmSi1gphn+tfGmFFzyLe2Wq6MKnqJ8TkjNQXyfE+VE/JyRnoL5OiPOjfm4dGkdAiH1REQZCcjAaOMGNLt5yliVLxJg8mXsG0vXrKvj709ums6G+nr1MvjgBS64v5IzxVvjgco8wuIhdbN6+8P49eLRuCkFCvMlYVqFE/I690FcNsnke9qRWA+fPC3HihAinTonw/Dk/RRfMIZezqFjRgDp1DKhbV49KlcwrypCV/VwQ/hquo4ZCcoZ7BfAvUXfqCtXvc8G6ONaNkX5He+Hg032cMYE+VXC4/UmbDoAhxBR6T8/GWBZeQRUhfP4s4xCRCLE3HoDNk4fHxBzbgQMiDB0qg1pt/mutn58RixerUbs2f/2DZVm03tMUV99c5owbWnEkJtWcZvJ81Nf5p9cDv/8uwYIFUouPFQpZfPedFmPHaqFQAK5DB0G2YyvnMapfpyF12Ehr083xhp4YhB0PuZ9jf2UALvUIhVwk5ykry1A/J7aw//EeDDje26zYqr5B2NF6HxRihW0aNxjg3qE1JBfPmwzVBVZF/N7DgNTy19jsjvq6dWjwBCGEEL7QWAJuTnctY0hF7lN+YGDMMERVYhZS8w/hMSnH5np7MGSRmzPcr/WsjYQqh3nMiNiD0/V1QjLAsizin8Th9ZmXeH3uJSIuvoImnntxDHthhAx8Kvshb738yFe3ALwDfSEUC00faCXq54TkDNTXCXF+1M8JyRmorxPi/KifW4fGERBiX44zo4oQQgjJQkFBpi/Or12z35d6hBDzjKo8Bh5SD86YtylRWHb9L7u0byhZCgkbtoE1Y9loJiUZ7l07QHTzul1ysSWDATh3TojRo6UoW9YF3bsrsGaNxKEKMABAaiqDS5dE+OMPKVq1UqJECRf06iXHqlVivHzpYJP9WRayzRvgWbe6xQUYjG7uSFy2GkmLVzhcAYbgN1dNFmAAgHFBv1IBBkKI+RgG6m49uUP0esh2buMpIce3fLkYAwZYVoChVSsd/v03mdcCDADAMAy+r/KDybi1t1ciOiWah4yIpUQiYPx4LXbuTEFAQMaTMb7EYGDw119S1K2rxMmdSZDu3cUZzyoUUPf8JjPp5mjX34aaLMAAAD9VG++wBRgIsZU2RdthfNAks2KvvbmC/sd6QWfQ2aZxoRBJS1bCmCuXyVBxyDW4/PIDQPXSCSGEEEJIVhLKYZAX5A5JustPLtmEQPuGc79R4sNTJoQQYh1VZBLub7uLk8OOYn3FldhScx3OjTuFZ4cf816AwaOYF8oNqIgWG9qi/8MhaH+oK6r9WBN+1QPsWoCBEEIIIYQQQgghhBBCTGFYlkZ22YJOp0NiYiLi4+ORnJwMpVIJDw8PuLu7QyQSZXV6hHwRrV7BjSpo5SxaLVC0qAvnJKZBg7SYPj1rKr0T+6G+nv0sDluIKZcmcMYoREpc7XkD3gpvu+QgOXwQbv16gjGanoRm9PJC/J7DMJQqbZdcMuPVKwZ//y3G9u1ivHnjWAUXrFG6tAHNmunRvLke5csb8aEGAN/9XBAZAZcxIyA9cdziY3VBNZC4ZCWM+fLbIbPMYVkWX+9rgUsRFzjj6udriG2t9/CUFSH/off07E0QEQ6vymU431v1JUoi7uwVIAcXeWFZYNIkKZYtk5h9jEjEYto0Dfr102XZU8eyLFrsboiQqGDOuO8qDMeUWjM4Y6ivZ63ERGDiRBm2bBFbdXxnbMN8jIIfvjxRIbV3f6hmz8tMijkWy7Jos7cZrkRe4owrl7sC/ul0BgLGca//qZ8TW2FZFqNPD8Pm+xvMim9bpD2WNl4FkcA23+mIz52Be6e2Zt07UE2ajtShI2zSbnZBfd06tIIFIYQQvtBYAm7OeC3jdqMHpG8PZLhf5xaI+CDLik47M89L1SFSZVyYIiX/MCSX+I3HjIg9OGNfJzmXOi4V4RdeI/zcS7w+9xLxj+OyJA9GwCB32Tzwqx4Av6D3PwpvZZbkAlA/JySnoL5OiPOjfk5IzkB9nRDnR/3cOjSOgPBGHQNEHgGi/gXiwgBNDKCJBYxqAAzQTZ/VGdoFFWGwEsuyOHnyJC5cuIDQ0FA8fvwYxi8MpBMIBChWrBgqVaqEWrVqoWHDhrQiLHEYNHCCG1285Txt2shx+XLGg6wrVTLg2LEUHjMifKC+nv2o9WrU3ByI16pXnHF9yw7A73X/tFsesvVr4Tp2pFmxxjzeiN9/BIYixeyWj7lYFjh7VojVq8U4flwEo9E5r039/Y1o1kyPtm31qFMHEHw0x8xu/dxohGzTeiinTIQgMcGiQ1mhECk/jEPKyDGA0DFX8/jn+VH0ONzZZNzJzudRLnd5HjIiJD16T8/+3Lp1gPTkP5wxcYdPQF+lGk8ZORajEfjhByk2bDC/AEOePEasXq1G9epZ3x9OvTyBrgfbc8bIRXJc63mLs5AW9XXHcPSoEGPGyBAdbflEfjck4Df8gsFYBiHS3099d/4aDMVL2CrNHOXAk33of6yXybg9bQ+hVkAdHjKyHvVzYks6gw7dD3XEmdfmTRZrV7QDFjdaabNCDPLFC+EyhbuQ5AcJqzdA27qtTdrNDqivW4cGTxBCCOELjSXg5ozXMorH06F89keG+1mhEjH1wwEHLurHp1z/FoRA9y7D/api05FaMGcVWnNGztjXSc6hjktFxKVwRFx8hfALrxF7NxrIgpHCQqkQ3pV84Vc9AP7V88K3qh8krlL+E8kA9XNCcgbq64Q4P+rnhOQM1NcJcX7Uz61D4wiI3aVEAHd+A56u/X/BBbyfmPQxhgG6cfTZCz2A8I+KgRcfClScaftc7YCKMFjIaDRi/fr1WL9+PSIjIwG8L8hgyofCC/7+/ujduzd69uwJgYC+mCRZiwZOcKOLt5xn+nQJFi7M+Is+kYjF48cqKBQ8JkXsjvp69rT9wRYMO/ktZ4yQEeJ8t6so4mG/wgeK2TOhnG3ehb/BPwDxew/DWLCQ3fLhotcDe/eKsHChBPfvO+Ykf3sJCDCifXsDOnTQo0IFFjqd7fu58NFDuIwdCcmlCxYfayhQEIlLVzn0pGKD0YAG22vh3ruMV3UCgA7FOmNp41U8ZUVIevSenv1JDuyFe/9vOGNSu/eCav5injJyHHo9MGKEDDt3is0+JjDQgDVrUuHn5xi3/liWRYvdjRASdY0zbnCFYZhaK+NVAqmvO47YWAa//CLFnj3m/11+rCquYjm+RSVcBwBov2qAhO17bZdgDpKqT0WdLdXwMukFZ1zzQq3wd/PNPGVlPernxNZUOhU67GuFsLehZsW3L9YJixuugFBgg8/OLAvXQX0h27fbdKhMhvg9h6APrJr5drMB6uvWocEThBBC+EJjCbg547WMJGoP3G/25oyJrXUDRkXWfM/lUIwa5DmZhzMksewqaPxMF7Ymjs0Z+zpxXpoENSIuvkb4hawtuiBxlcC3mj/8queFf1AAvCv5QCi1TbFLe6B+TkjOQH2dEOdH/ZyQnIH6OiHOj/q5dWgcAbGriCPApV6ANi594QXmo8VgWdZ0EYboi8A/tf/blvkA7bJH8W8qwmCBV69eYezYsbh58+ZnhRcYJuMVhL8UW6FCBcyePRv58uWzS66EmIMGTnCji7ec59gxIXr14q6wsHdvCmrWpL8FZ0J9PXsyskY03F4Hd2Jvcca1LNwGa5tttF8iLAuXcWMhX7PSrHCDfwASdh+AoXBR++X0CY0G2L5djIULJXjxwvE/oNhbsWJGfP21Du3b61CkiA0+Cmk0UCyaB8X8OWC0WosPT+3xDZKn/gbW1S3zudjR1vubMOLUd5wxEoEEF7uHIL9bAZ6yIiQ9ek93AhoNclUoAcG7jFeQYxUKxN566PCvm7ak1QLffivDoUPmT3Tv0EGH+fPVkDrOYlIAgNMvT6LLwXacMXKRHFd73oSPwueL+6mvO56TJ4X48UcZXr2y/FpTAANGYCGm4lcYN6+FtlFTO2To/GZdnY4/gzNerRQAxAIxznW9gsIe/H0WsRb1c2IPsamxaLOnKR7FPzQrvkOxzvir4XLbFGJQqeDZshFE97iL2gGA0csL8fuOwlCiZObbdXDU161DgycIIYTwhcYScHPGaxlh8kN4XazCGZNQYQu03i15yshxCVJfItf5spwx8YEHofOqy1NGxF6csa8T56FX6/HmagRen3uJ1+deIvp6FFgj/0OBFd5K+FUPgF/1APgHBcCrdG4IhNlnXAL1c0JyBurrhDg/6ueE5AzU1wlxftTPrUPjCIjdPFkLXB0IsMb32x/m0H9ajMGcIgwAcKwG8O7qf/H1DgP+jj9mlIowmOnBgwfo1asXkpKSwLLsZ0UXuJ7GjGLd3d2xYcMGFC9e3PYJE2IGGjjBjS7ecp7YWAalSrlwxvzyiwajRlk+yZY4Lurr2Zc5k/gAYG/bw6gZUNtknNWMRriMHgb5FvOKPRi8fZCw64DdJ1QYDMCOHSL8/rsU4eG2H+QgELAoXNiIwoVZFCpkROHCRvj6svDyev/j7s5CImEhFP73WUulYpCUxEClev+aGxEhQEQEg/BwAZ49Y/DggRAJCRkXN7O1wEADunXT4euvdXCzYi6v6MpluI4ZDtHDBxYfa/D1g2reImgbNrG8YZ6l6lNRc3MgwlWvOeO+LT8E02rP4ikrQj5H7+nOQTnxZyiWL+GMSfpjHtR9+vOUUdbSaoF+/eQ4ftz8VaJGj9bg55+14KgXmmVYlkWrPU1w7c0Vzjiu9xTq644pORmYPVuK5cvFMBgs/+PLK4zE9FVuaNHSaIfsnNvThCeouyUIWiP3vYpvKwzFtFozecoqc6ifE3t5nfQKrXY3QURyuFnxbYu0x+JGKyARSjLdtuDpE3g2+QqCxASTsQZfP8QfOAZjgYKZbteRUV+3Dg2eIIQQwhcaS8DNKa9ljHrkPu0HxqjJMCS5yASkFP6Rx6Qckyj+CjyvNeaMeVczBAZlMZ4yIvbilH2dZFt6tR5RoZGIuPgaERdf401wBAxq/v8m3Qt5pCu64FbIg3MBM0dH/ZyQnIH6OiHOj/o5ITkD9XVCnB/1c+vQOAJiF2/PAqcaA0Zd+uILYlfApz6gLAS82Apo3ppfhOHBQiBk1H/nKz4CCJxn11/DFqgIgxkiIyPRpUsXvH37Nt0N4w9PnUQiQYkSJVC0aFG4ublBLpcjNTUViYmJePLkCR48eACN5v2XlB+O/3Csr68vtm7dCl9fX55/K0Jo4IQpdPGWM9WsqcDjxxmvcNe4sR6bNqXymBGxN+rr2Vun/W1x5vVpzpjSucriRKezEAnMn7xoMYMBrkMGQLZnl1nhxty5Eb9jPwxluFfJsQbLAidOCDF9uhT37tlgxc7/c3NjUbu2HoGBRgQGGlC+vAEu3HVrLMaywNu3DO7fF+DGDSFCQgQICRHi7Vv7rpQhl7No1UqPbt10qFnTAIGJ5pi4d1DOmAr5+jVWtafu0h2qaTPBenhadTzf5ofMwW9XpnLGuErccLXHDeSS5+IpK0I+R+/pzkH44D686lTjjNGVLY/4k+fgkFUGbEivBwYOlOHQIbFZ8UIhi9mzNejZU2fnzDLnzKvT6HSgLWeMTCjD1Z434Kv0+2wf9XXHduuWAGPHyhAWZt11aLNmOvz2mwZ589Ita3OwLItuhzrg1MsTnHFeMi9c7h4GD1n2uP6kfk7s6eG7B2iztyneqd+ZFV8vb32sbb4JLuLMfwAWn/0X7l3bg9HrTcYaChRE/MHjMPo473dH1NetQ4MnCCGE8IXGEnBz1msZj8t1IE66keF+tU97JJVfx19CDkoStR/uN3tyxsTUfw1WZEUFcOJQnLWvk+xBn6rDm+D/F1249BpRIZEwaPj/G1T6KhFQJz/y1i2AvHXywcXfuT6XUj8nJGegvk6I86N+TkjOQH2dEOdH/dw6NI6A2JxRDxwsAaievR+rzbKAQAyUmwSU/B4Qyt7HHakExN80vwhDSjiwL//7f7Ms4F4GaHnLvr+LDVARBjN8++23OHPmzGcFGKpVq4bu3bujYcOGEIszHhCv0+lw6tQpbNmyBZcvX05XiIFhGNStWxfLly+3++9ByKdo4AQ3unjLmUaOlGHLloxf0z08WNy/rzI5QZdkH9TXs7db0TfQcEcdk3Gz6s5Fv7ID7ZuMTge3Ab0hPXLQrHCjpycStuyCvnIVm6UQGirA1KlSXLxom4ITpUoZ0KSJHg0bGlCligEiO9axyAjLAuHhDK5dE+L8eSHOnBHh5Uv7vQjnz29Et246dOumg7//Jx+VjEbINq2HcsZkCN6ZN2HnYwZvH6jmLoS2aXMbZWt/UclvELSpElL0yZxxvwT9ilGBY3nKipAvo/d05+HRuinEVy5xxsQd/xf6ipV5yoh/BgMwdKgMu3ebV4BBLmexZk0qGjZ0/L97lmXRZm8zXInk/n/cp0x//FHv8wq31Ncdn8EArF0rxm+/SaFSWV4sRaFg8eOPGgwapMuS68/s5NDTA+h7tIfJuJl15qB/uUE8ZGQb1M+Jvd2KvoEO+1sjXhNvVnxl70BsbrUTXrLMF52Tbd4A11FDzYrVFy2GhN0HYfT9vCiRM6C+bh0aPEEIIYQvNJaAm7Ney7je/hayyC0Z7tcrSyKu5lUeM3JMspfL4frghwz3swIFYhpEOn0R2ZzAWfs6cUw6lRaR1yIQeTkcERdfIyrsDYxZ8DcndZfCv1Y+5K2TH3nr5odHUc9042adDfVzQnIG6uuEOD/q54TkDNTXCXF+1M+tQ+MIiM09XgFcHfxRAQYJUO8A4Nc4fZylRRgA4GBJIOnRf8d0SgJECvv8HjZCRRhMuHr1Kr755pt0hRNcXFwwdepUtGjRwuLzHT16FBMnToRKpUo7H8MwWL9+PapWrWrT3AkxhQZOcKOLt5xp0yYxRo+WccacP5+M4sWNPGVE7I36evY35MRA7Hy4jTPGQ+qByz3CbDJhgpNGA/fe3SA5xb0S7QesQoHE1euhbdgkU82+fctg2jQptm0zb6Iml3z5jGjfXof27fUoVcoxX+ueP2dw9qwIp08Lcfq0CCkpth/0IRSyaNpUj759dahTxwDJ9WC4jBsLcVioVedTt+8E1czZYD29bJypfY06NRSb72/gjPFR+OJyjzAoxUqesiLky+g93XlIt22G2/DBnDGpvfpANXchTxnxy2gExoyRYtMmiVnxLi4sNm9ORfXq2edv/uzrf9FxfxvOGJFAhPPdrqGwe5F0j1Nfzz4iIxlMbv8Ye55UtOr4SpUMWLhQjRIlHPOaNKsl65JRe0tVhKtec8aVy10Bxzv+C6FAyBnnSKifEz7cjL6ODvvbIMHMQgzFPUtgS6tdyOeaP9NtK36bCuX8OWbF6gsVfl+IISBvptt1NNTXrUODJwghhPCFxhJwc9ZrGfnzBXB5NDHD/SwjREyDN4BAymNWjkfxeCqUzzK+ptfLCyOu9nX+EiJ246x9nTgGTYL6fcGFS68RcTkc0TeiwBr4H8orlAnhF5QXeevkQ966+ZG7nDcEwpyzMg31c0JyBurrhDg/6ueE5AzU1wlxftTPrUPjCIjNHa0GvAt+/2+GASrMBEr/+HmcNUUYLvQAXmz579xNrwFejr0oX865W2ql9evXp/2bZVm4u7tj3bp1VhVgAIBmzZrh77//hpubW4btEEIIyTpVq5p+w792LftMXCAkJxgfNAkKE5XP4jXxmHVluv2TkUqRsHYTtHXqmRXOpKTArWcXSLdusqo5vR5YsUKMGjWUmSrAIBSyaNlSh127UhAcnIzx47UOW4ABAAoWZPHNNzqsXavG/fsqbNqUgl69tMiTx3Y5GwwMDh8Wo1MnBeoUU2FtswNQhT21/Dx+/khYvxVJy1ZnuwIMN6OvY8v9jSbjfqg6jgowEEJsStOmHYzuHpwx0t07waicbzIAywITJphfgMHDg8XOnSnZqgADANQJqIfqfjU5Y/RGPX7n4/qN2I2fezJ2xtbHQbREATy3+PiwMCEaNVLgr7/EMGSvP3FezAuebbIAAwD8XndutirAQAhfyuepiJ2t98Fd6mFW/MO4B2i6sz6C32R+1d+UnydA3aGzWbGiZ0/h0bYFBC+eZ7pdQgghhBBCTNG7lObcz7AGCJMf8pSN4xJqIjn3G6W+PGVCCMlODDoDIi6/xtVZF7Cr+RasKbEUh3vtw/UlIXgb+oa3AgyMkIFPoB8CRweh7Z5OGPBoKNrs6IDKI6rBu6JvjirAQAghhBBCCCGEEEII+YQ2DogLfV8gAQCkeYASI213fo+y6beTHtnu3HZCd0w56PV6XLp0CQzDgGVZMAyDn3/+GWXLljV9MIfSpUtj3LhxaedkWRYXL16EXq+3UeaEEEKsVbSoEZ6e3F9sXr1KkxcIcSQBrnkxovL3JuPW312L2zG37J+QXI6Ejduhrd/QrHDGYIDbiO+gmDf7/cxLM126JETDhgpMmCBDUhJjVaqenixGj9YgODgZa9eqUaeOIe2zUnYhkwGNGxswd64Gt24l4/DhZAwZooW/v+0KMjxK8sMY/IkAhKM/ViEEpivtsQyD1P6DEHf+KrTNrCvglpVYlsWvF34BC+6/yVJepdG9VC+esiKE5BhyOdSdunCGCJJVkO7ZxVNC/Jk3T4JVq8wrwJA7txF79qSgcmXHLZyUEYZh8FO18Sbj9jzehVvRN3jIiNiDbNtmCOLj0RKHcQdl8BNmQQSdRefQaBhMnSpD69YKPH6czS5U7ehWzE0subHQZFyPUt+gim81HjIiJHuq4F0JO1rvhZvE3az4mNRotNvXErsebs9cwwIBkhYuhaZJM7PChS+fw7NFI4huhGWuXUIIIYQQQkwwuJQxGSNS3eEhE8cm0Lzh3E9FGAghwPvvW+MevcPNVWE43Gsv1pRYir1ttiP4zyuICokEa+S36EKlEVXRamt79H80FB2OdEPQuFoIqJUPQqmIlzwIIYQQQgghhBBCCCHZQMxlgP3/uGSGAfxbAEKp7c4vzZV+Wxtnu3PbCRVh4HDz5k0kJyenbefPnx/t2rWzybm//vprFChQIG07JSUFN2/etMm5CSGEWE8gAKpU4V5i89o1evskxNEMqTgC+d0KcsYYWSPGn/8RrAWFDqwmlyPh7y3QNG1u9iHKmdPgOnIIoFZzxsXHA6NHS9G2rQL37llXFMbb24jJk9UICVFh3DgtAgL4GeBhb+9fw42YPFmD0NBk7N+fgt69tfDyss3vlwoF1qA/qiAENXEBu9Aehi98pNKXKo34Q/9ANXMOWFc3m7TNt0NPD+BixHmTcVNq/QaRgAbmEEJsT92zj8kY2Ya19k+ER5s3izBrlnk3KnPnNmLv3lSUKZP9CjB8UCugDr7K18Bk3PTLk+2fDLE9oxHy5YvTNpVIwSyMQygqoyYuWHy64GAhGjRQYtUqsSV1y5yS3qjH6NPDoDdyF/T1kHpgQvUpPGVFSPZV0bsydrc9gNzy3GbFawwafHdiACZeGAedwbLCMumIxUhc+Te0NWubFS6IfguPti0gOXnc+jYJIYQQQggxwSj1g1HkwRkjUt3lJxkHRkUYCCEZMegMeHnqOf4d8w82VF6FLbXW4fwvp/H82FPoVFpecmAEDLwr+6LS8PRFF2pMqIP8DQpC4mJeIWhCCCGEEEIIIYQQQkgOpI56/98PAzVzVbXt+cUe7//7YfVYXZJtz28HNIuUw5s3/31pxjAMGjdubNPzN2nSJN0kwMjISJuenxBCiHWqVeMuwvD4sRCxsbQCJyGORCaSYWrN30zGXYq4gH2Pd/OQEQCZDImrN0DTqq35h2zdBI92LSCI+nzwFssCBw6IULu2Eps2WTcwwsfHiFmz1AgOTsaQITq4uFh1mmxBIACqVzdg9mwNHjxIxY4danTpoodSaZtZe5dQEx2xC8XxEIswDCoowUqlSP7lV8T9cxb6Ktl3xWGNQYMplyaYjGtSoJlZk2cJIcQahtJloAvkvnEnvh4G0a0bPGVkX8ePCzFmjMysWE9PFjt2pKJ48exbgOGDCdUnm4w5/eokzoeftX8yxKYkx45A9PTJZ4+Xw22cQx2swEB4CBItOqdazeCXX2To1UuOmJic+5l8yfWFuBl93WTc+OqTkUuey2QcIQQon6ciDrQ7hnyu+c0+ZvmNxWi7tznCk15b37BcjsQNW6GrWMmscCYlGW49u0C2ejlyfEUaQgghxEEtWrQIJUqUsPrn559/zupfgeR0DAO9SxnOEGHSHZ6ScVymizD48ZQJIcQR6NV6PDv6BCeHHcW60stwsOtu3N1wC6pw/gYPexb3QrkBFdH87zbo9+A7dDzaHTUmUtEFQgghhBBCCCGEEEKIhdTR6bel5i1sYzb207HPjj8WmoowcIiNjQWAtEIJBQoUsOn58+dPP6Dv3bt3Nj0/IYQQ61Styl2EAQCCg+ktlBBH07xQS9TNW99k3KSL46HS8jTgQSJB4oq1UHfsYvYh4pBgeDSuB1FocNpjkZEM+vSRoX9/Od6+tfz1x9WVxS+/aHD5cjL69dNBZt4cT6chFgONGxuxfLkWDx6kYsGCVAQFca8cbK6nKIIRWIR8okiM7vwcT7v+AEiy90CWlTeX4UXic84YkUCEyTVn8JMQISTHSv2mr8kY2YZ19k/EzoKDBRg4UA6DwfSkcldXFtu3p6BMGce/6WiO8nkq4uui7U3Gzbg8OV0hU+L45EsXZbhPABYDsQrBU3ejY0fLV5E/flyE+vUVOHtWmJkUs6XHcY8w+9pMk3GVvCujZ6nePGREiPMo4lEMB9sdR0mvUmYfExx1FQ131MaBJ3utbpd1dUPCjn3QVQ40K54xGOA67ge4Dh8MpKZa3a69sSzw7h3w6JEAN24IcOmSEKdPC3H2rBAXLwpx5YoQd+8yiIxkoFZndbaEEEIIIeRjBhfua2JR8j2eMnFQRi0EuljuEKkPT8kQQrKKTqXF4/0PcXzQIawttRRHvtmHB9vvQpOg4aV9jyKeKN2rHBotbY7eNweh2/k+qPNbAxRqXhRS9xw2GIAQQgghhBBCCCGEEGI7zCfzlYy2mXeTRvv/71g+jAmWeNn2/HYgyuoEHFnqJwPYXGy8VPCH8zEM88X2CCGEZI2KFQ0QiVjo9RlPgrp6VYimTU0XayCE8IdhGMyo/Tu+2lYDBjbj/hmZHIHZ12ZhSi2eJpCLREj6azmMebyh4JiM9jHhm0h4tGmGxEkzsEoyFFOmypCUZPlqv2Ixi759dRg9WotcuWjiIgC4uADduunRrZseT6/GYeeEu9h8vRwiEJCp88brXbFggyuWbGXRoYMeo0ZpULhw9nvO36a8xbyQ2Sbj+pUdiKKexXjIiBCSk2natINxws8QJCVmGCPduR2qSdMBpZLHzGzn2TMGPXvKkZpq+n1eoWCxZUsKKlRwjgIMH/xcbQIOPNnHef0WEhWMw88OomXh1jxmRqwlCguB5PJFzhiDtw/cerfCkkFqdO2qw48/yvD0qfnFxqKiBOjUSY5hw7T46Sdtdq+BZRYja8Tof4dBY+AeyC1khJhdbz6EgpxXpIKQzPJz8ce+r4+g+6FOCIm6ZtYx79Tv0P/YN2hfrBNm1pkNT5nlXwyy7h5I2LEP7t06Qnz1slnHyLZvgfD+PSSuXAdjocIWt2kriYnA9etC3L8vwMOHAjx+LMCrVwJERTHQas2/j1GhghEdOmjx7bc6MJbf/iCEEEIIITakdynDuV+ofg1GFw9W7MFPQg5GoIkyGWOU+vGQCSGEb5oENZ4ff4qnBx/h5ennMKj5GzPkWdwL/jXywr9WPvjXCIDSx7bjWAkhhBBCCCGEEEIIIQQAIPNOv619Z9vzJz1Kvy3NZdvz2wEVYeDg4eGRbjsmJsam54+NfV+1g2VZMAzzWXuEEEKyhkIBlCtnRFhYxhMWrl6lyQyEOKISXiUxoNy3WH5zCWfciptL0LlEN5TJXZafxAQCJE+ZAaOfH1x+/cWsQx5pC2DQ+Co4A7lVTTZtqsfUqWoUKpT9CgHYGxP3DorFC1Ft1TIEpaRgJoQ4jiZYiYHYjzYwwvrXeJ2OwdatYmzfLkK7dnqMHq1F8eLZZ7Ls1EsTkaTNeLIzAHhIPTCmyk88ZUQIydGUSmg6dIJ83eoMQwSqJMj27Ya6ey8eE7ONhASgVy853r0zPfFcImGxYUMqqlXLPu8p5irsURQ9SvXG+rtrOONmXpmKpgWbQ5KJ92nCD7kZhcfU/QcBUikAoG5dA06fTsbMmVIsXy4Gy5o3+5ZlGSxaJMWlSyKsWpUKf3/nvu5de3slrkReMhk3tOJIlM9T0f4JEeKkPGVe2N32IEac/A77nuw2+7jdj3bgfPhZTK45HR2KdU4rvm0u1tUN8Vt3w71XF0gunDPrGPHN6/BsUBuqmbOh6dIdfFQvePcOOHdOhDNnhAgOFuLBA4HZr9tcbtwQ4MYNGe7eFWLBAjUVYiCEEB7cWH8j7d9yLzmKtypus3M/PPgQqe/+W4CiwjcVbHbu7Oann35CyZIlzY739vY2HUSInelduYswAIBQdQ96zxo8ZON4BJpIkzFGiS8PmRBC+JAak4JnR5/g6aFHeH32JYw6fu7R5yqdG37VA+BfMx/8qwdA4Z09C1ETQgghhBBCCCGEEEKyGWme9//9MHgn/qZtz//2zPtzs/8f76ksYNvz2wEVYeDg5fV+xaIPg+Vu3rTtH8ytW7e+2B4hhJCsV7WqgbMIw82bQuh0gFjMY1KEELOMrfozdj3ajpjUjAtoGVgDfjgzCgfbH4eAMX/F3cxKHTwMRh9fuA77FoxO98UYPYSYizGYhCnQQGZxGwULGjFjhhqNG/O38ka2kZAA6dLFcF28KN2q6iIY0AJH0AJH8Ap5sQKDsBIDEQXrB8kZjQx27RJj924R2rR5X4yhdGnHnjh7OeIitj/YYjLuh6rjrFrdlRBCrJHaqy9nEQYAkG1Yl+2KMOj1wMCBcjx8aLqgAMOwWLxYjTp1nPe9fWzVn7Dj4Rak6lMzjHkY9wCb723AgEoDeMyMWErw6iWkB/ZxxrByOVJ790v3mFwOTJ2qQYsWeowYIcPz5+ZfowcHC9GokQIrVqhRu7Zz9pNHcQ8x9dKvJuOKeBTF2Ko/85ARIc5NLpJjRZO1KHatOOYEzzL7uLcpURhyYiA23F2HGbX/QNnc5Sxr2MUFCVt2wW3oIEgP7DXrEEGyCm4jvoP6xHGoZs0Fmzu3ZW2a4eVLBvv2iXHokAhhYbYpupCRrVvF6NFDh6Ag53w9J4QQR7K3z960cRA+FXxsWoTh9MTTiLr530rxObkIQ5kyZRAUFJTVaRBiEYOylMkYkepOzi3CoI0yGWOUUhEGQrKz5DcqPD30GE8PPULExddgjfYt/soIGOSp4A2/6nnhXyMv/IL8IfO0bqEGQgghhBBCCCGEEEIIyRSvyv8VYGBZIOq07c4dfwuIu/Hf+UWugGcl253fTvibcZYNFS1aNO3fLMvi9OnTUKlUNjm3SqXCqVOn0q2G9HF7hBBCsla1atwDfVNTGdy7R2+jhDgid6kHxgdNNhkXHHUVm+9tsH9Cn9C064iE7Xth9PT8bN8tlEV1XMbP+N3iAgxyOYuff9bg7NlkKsDwCSYmGtLpU+BWvjRks2akK8DwqXx4jWn4FS+RH9vQGfXwb6baZtn3k1W++kqJvn1lePTIMd879EY9fjo7xmRcUY9i6FOGJr8SQvhjKFceuorcN9jEIdcgvHObp4xsY8IEKf7917zaqNOmadC2rd7OGWUtX6UfBpb7zmTcrKvTkajJ+H2cZD35ymVgDNzXouou3cF65frivurVDTh9OhkDBmgtajcmRoCOHeVYuFCSViDZWWgNWnx3YgBnkRIAYMBgXv3FkIksL+RGCPkcwzD4sdovWNF4LRQihUXHXoq4gAbba2HgsT548O6+ZQ3LZEhcuQ4p3w617LD9e+BVuwqk2zbDFi+E0dEMli8Xo3lzBapUccG0aVKEhgrtWoDhg717qX48IYTwibXTBTTLsnY7NyHEvlixOwyyfJwxItUdnrJxPAJNJOd+ViAHK3LjKRtCiK0kvkjA9aUh2N1yK/6usALnxp1C+PlXdivA4FbQHWV6l0ezta3R78F36HisB2pNqYdCzYpQAQZCCCGEEEIIIYQQQkjWkXkDHhX/21Y9Ad6css25b035798MA+SpDfC4qK61HD/DLFSwYEEEBASkbScnJ2P27Nk2Ofeff/6JpKSktO2AgAAULFjQJucmhBCSeZUrm57AHBJietVaQkjW6FaqJ6r4VDMZN+3Sr4hNjeUho/R0teog7ti/0JcqDQDQQowp+BWBCEEIqlh8vnr19Dh7Nhnff6+FjOZcpRGEv4Zy/I9wLVcKsjl/gEmIN/tYCXTojB34F/VxU1kdg6peg0KRuUE2hw6JUaeOAqNHSxERYf+JK5ZYc2sF7r0zPWhyaq3fIBaKeciIEEL+o+7V12SMfOM6+ydiI6tXi7FmjcSs2GHDNBg0SGfnjBzDsEoj4S714IyJSY3GvGtz+EmIWIxJTIBs49+cMSzDIHUw98RipRL47TcNdu5MgY+P0ez2jUYG06dL0aePDIlOVKtjzrVZuBl93WRcv3IDUd0vZ65CSog9fV2sA451/BfFPUtYfOy+J7tRd2sQ+h7tiQvh58yfiCoQIHnaTKimzwIrMP9rPMG7d3AbPhjuHdtCeO+uxfmyLHD1qgDffSdDpUpKTJwoy5L7n0K65UoIIU7h48UoCCHZj96lNOd+oeoeT5k4HoHmDed+o9T3vxWcCCEOi2VZxN6NxrXZl7Ct/gZsrLoaFyedwZtrEYAd6i5I3aUo3KoY6s1phJ7X+qPn1f6oN7sRCrcsBqk7fcFPCCGEEEIIIYQQQghxIHnbvB9IxDDv/xs6CjBmcjG5xyuAV7v/OycAFOyZ6VT5QEUYTGjQoAFYlgXDMGBZFtu3b8eKFSsydc7Vq1dj8+bNaedkGAYNGjSwUcaEEEJsISCANTnZg4owEOK4BIwAs+vNh5Dh7qdxmjhMvTSRp6zSMxYshLhDJ3Cp1ihUQTAmYwp0MG9C5gee7nosWpSK7dtTUaAArSr2gehGGFyHDoJX1fJQrFwGJpV71eCMsCIRUgZ8C7/grZh+qCSuX1dhwgQNfH3Nnwz4KaORwaZNElSvrsSUKVLExVl9KpuJSn6D36/9ZjKuWcEWaFSgKQ8ZEUJIepp2HWBUunDGSHdsA1JSeMrIeqdPCzFhgtSs2A4ddJgwQWvnjByHh8wTwyuNNhm3JOwvvEh4wUNGxFKyjeshUCVxxmibtoChcFGzzle3rgH//puCZs0sK0Ry5IgYzZop8PRp9p/wcDniIhaEzjUZl9clH8YHTeIhI0JyphJeJXG042l0KNbZ4mNZsDj0dD/a7WuJr7bVwF9hC/Ay0bz3sdRBQ5CwbQ+Mnp4WtSk59y8869eEy9hRYN6+NRmv0wFbt4rQsKECrVopsWuXGFpt1r2G+hSMybK2CSGEEELIewYTRRhEqrv/DZDLYcwqwkAIcUiskcWbaxG4OPkMNgWtwbavNuDa7EuIvRNtl/Y8inkhcHQQOhzphr73v0OzNa1R5pvycCvgbpf2CCGEEEIIIYQQQgghxCZKjAQkHv9tJ9wBLnQFjKYXvP6i+wuA4OHpi1grCwMFumQqTb5QEQYTBg4cCLlcDgBpRRPmzZuHkSNH4q0Zg9c+Fh0djdGjR2POnPQr9slkMgwYMMBmORNCCMk8hgEqV+a+OAgNpbdRQhxZmdxlMbD8dybjttzfiMsRF3nIKD21Gpg+3wt1Lv+JWyhv8fHdsBn31IXR99kkMMkqO2SYzej1kO7bDY9WTeDZuB5kO7aC0VtfbU/TojXizl1B8m+zwebKBQDw8ABGjNAiODgZf/2VijJlrPwQCUCtZrB4sQTVqrlg0SIJNBqrT5VpUy5NRJKWe7lomVCGabVn8ZQRIYSkx7q4QtO+E2eMIDEB0n27ecrIOk+fMhg4UA6DwfSkxmrV9Jg/Xw0LFr92CgPLD0aAS17OGI1Bg8nns6aIFuGg00G+cqnJsNQhwy06ba5cLP7+W41Zs9SQycyf3PH4sRDNmytx/nz2LZ6YqEnA0JODwJqx9N6f9RfBReLKQ1aE5FwuYhcsabQSSxutgrvUw6pz3Ht3F1MvTUSVjeXQeEc9TLs0CadenoBKl/Fnel29+oj75yx0ZS27b8AYjZCvXwOv6pWgmPs7kBCPJG0iHsc9woXwc9jzaCcWXVuKThOPolgFNUaMkOP2bQd4zcx9F8lllmR1FoQQQjKJNf53DcsIs39xNEJyIr2JIgwCfTwEmgiesnEsQhNFGAxSP54yIYSYQ6fS4sXJZzjzwwn8XWEFdrfciutLQpD4PMEu7eUumwfVfqqJrud6o/uFPggaVws+gX4QCHPYzX5CCCGEEEIIIYQQQkj2JfEASv34viA3w7z/7+s9wLFqwNvz5p2DZYGIY8CJr4Cw7wGj7r/HGQYoPzV9UQYHJsrqBBydt7c3+vTpg6VLl4JhmLRCDMePH8fp06fRoEEDNG3aFGXLlkW+fPk+O/7Vq1e4ffs2jh07htOnT0Or1YJl2bTzMAyDvn37wtvbOwt+O0IIIVwCA404ciTj/Y8fCxEf/35SLiHEMf1YdRz2Pd6NyGTugWA/nBmFE53PQSo0b2XqzLp6VYBRo2R4/NjyCQ558QpL8R1a4RCgAfDnbMg3/I3kMT9B3b0XIJPZPmEHJnj9CrJtmyHbsA7CiPBMn09bvSZSfvkVuuo1M4yRSIDOnfXo1EmPc+eEWLJEglOnrPtolZDAYNo0KTZsEGPaNDWaNDHw+lnyUsQF7Hy4zWTcyMAxKOBW0P4JEUJIBtS9ekO+YS1njHztSmi69eQpI8uoVECfPnIkJpp+kc+f34h169SQ8nNZ4lDkIjkmVJ+M705wFyvd82gXvo34DtX9a/CUGTFFemAvhOGvOWN0lSpDF2T5/zOGAfr106FGDQMGDZLhwQPzrqHj4hh07izH779r0KuXzuJ2sxLLsvjhzCi8SnppMnZQ+e/wVb4GPGRFCGEYBh2Kd0ZN/9oY/e8wnHp5wupz3YgOw43oMCwKmwcAKOhWCKVylUFh9yLwd/GHnzIAHjIPKEVKuLi6QrFtHZR//g7Jzm1gGUAnAFSS/36SpECCFIhWAtGKj/+bhGjtDET/PQOaDx9b9RLg2nfAhR8Blb8NnhkbKXoYaDMA0ZqmWZ0JIYSQTNIk/VdxVqKUZGEmhBBr6V3KmIwRqe5AKwvgIRvHItBEcu43Sn14yoQQ8iUGrQFRoZF4ffYlws+9QlRIJIx6o13b9An0ReGWxVC4ZTG4F/Kwa1uEEEIIIYQQQgghhBDCi9I/AtHngIgj/xViiAsDTtYDXIsBuWsCqW/eP/7B9V8A7Tsg+QUQcxHQ/39hmg+FF4D3/y3cDyjYjf/fyUpUhMEMw4cPx7179/Dvv/+mK8Sg1Wpx7NgxHDt2DAAgFovh6uoKuVyO1NRUJCUlQaf7b4Av+/8/KOb/fzAMw+Crr77C8OGWrQBHCCGEH4GBplc4Dw0VokED61dCJ4TYl4vEFTNq/4F+x7gnZD6Iu48FIXPxY7Vf7JpPcjIwa5YUK1aIwbKWzbRnYMRQLMZv+AWuSL9KpiD6LVx/HgPFvNlIHTICqd/0BZRKW6buWDQaSI8egmzzBoj/PQWGNX9V5IzoKgci+eeJ0NWrb3ZFPYYB6tY1oG7dVNy8KcCff0pw+LDYqvafPxegVy8FGjTQY/p0NYoWzfzvZIrOoMPPZ8eYjCvoVghDK460ez6EEMJFX6ESdOUqQHzrRoYx4uthEIWFQF8pkMfMTGNZYPRoGe7fNz1x3NWVxcaNqcid2/7vA46qXbGOWHlzKULfhnDG/XLmJ5zo+i8/SRFuLAv50r9MhqUOHpapysWlShlx5EgKxo6VYfdu86659HoGY8bI8PChAJMnayB0gEXezbH2zirsebzLZFxJr1IYX32y/RMihKTj5+KPLS13YcfDrZhycSKiU99m+pzPE5/heeIz7qB8AEZnohEjA9zpApz8DYgvlIkTffHkQK5HQO57QO77gOczwDUCcHkDyOIBcTIgTgVYBjCKAL0MUHsCqV7vH8v94H08AxRws3VuhBBC+KRX65H4KjFtW+qWAysMfkKr1eLVq1eIi4uDWCyGh4cHvL29IZfLszo1QjJkUBYHy4jAsPoMY4Squ0DuJjxm5RgEau6C4EZpzitMQUhWYo0sYu5E/7/owktEXA6HPsXOBVkZwL96AAq3KoZCLYrBNcDVvu0RQgghhBBCCCGEEEII3xgBUGsbcKLe++ILH8Z+siyQ+BBIepQ+nmWBe7+n304710fHetcFqiy2b+42RkUYzCAQCDB//nx89913uHTpUlohBuC/wgrA+y/PY2NjMzwP89EgY5ZlUbNmTcyfPz/d44QQQhxHhQoGCAQsjMaMX6dDQqgIAyGOrmXh1miUvwlOvDzOGbcgdC5aFWmL0rlMr+5jjfPnhRg9WoYXLwQWH1scD7AG/VALFznjhFFv4DLpFygWzIG6V1+k9uwNY4GCVmbsYPR6iC+eh3T/XkgP7IEgLs42py1dFsk/T4C2afNMTQosX/79quV372oxb54E+/eLLC60AQCnTolQt64SgwbpMHasBi4uVqdk0uLrC3Dv3V2TcbPqzoFMJLNfIoQQYg6Ggbp3P4jHcheFka9dhSQHK8KwZIkY+/aZnjAuELBYuTIVJUvad1UuRydgBJhaaxZa7WnMGRcaFYItdzehU7HuPGVGMiK+fBHiG2GcMYa8+aBp/XWm23JxAZYuVSMw0IBJk6TQ68273lq+XIKnTwVYsSLV4WuVhUYFY+L5n03GSQQSLGm0CnIRTdwiJCswDIPOJbqhWcEWmH1tJlbdWg4D68D3CJ/XBY7PASKq2uZ8Ah2Q7yJQ+ASQ9xIQcA2QJZo+Lp1Xnz0iFUrRsXhn2+RICCEkS9zedhtGgzFtTIVXMa+sTilLTZ06Fa9evYJGo0n3uEgkQpkyZVC3bl10794dXl6O9zxJJNmkil0WEYmc/fmRw6gsBqHqXoYRkpS7MOS0vxO9CgJ9PGeIwCUv9R8n4vx9PftJfqPCm5DItJ+osDfQJmrt3q5AJEDeuvlRtHUxFGlZDEpvB7/JSMxG/ZyQnIH6OiHOj/o5ITkD9XVCnB/1c0IcjNgFaHweuPYd8Gz9+/k2HxdU+NSXCi98/HjhvkC1ZYDAuoVPswrDsjZYNjaHYFkWK1euxMKFC6HX660qnsCyLEQiEUaNGoX+/ftTAQaSpaKjk7I6BYf26RfjWq0DD6IldlO/vgJ37mR8Id+woR5btqTymBGxNerrOcPzhGeouzUIaoOaM66Sd2Ucbn8SQoHtPsDHxQHTpkmxcaPE4mMFMOAHzMYkTIEc3Ll/Ccsw0NVviNRv+kHbqAkgsTyHLKXTQXzpwvvCC4f3QxATY7NT60uXRcrose8nAwosL4xhysOHAsybJ8Hu3dYVYwCAfPmM+P13NRo1sv3r0pP4R/hqW01oDBrOuBaFWmNd8002b58Qe6D39BxApUKuCiUhSMp4gh8rkyH2+j2wXrl4TCxj584J0amTnLOw2wczZqgxcKCdV+jKRgYd74O9j3dzxuSW58al7qFwl3rwkxT5IrdvukJ69DBnjGrKb0j9bphN271yRYgBA2SIijL/Wq5SJQM2bkxFnjyOeUv8nToWjbbXxWvV5xOTPzW55gwMqTich6z4R+/pJDt6FPcQs6/9ZvK9i3dxBYEjC4CHbTJ/LlEKUPwgUGY7UOQ4ILPt9wtykRzrm29FvXz1bXpeZ5MnD62wSgixjSmCKWAYBizLwreiL74N/daq87AsC61Ki7incXh0+BHOzzwPXbIOLMuCYRgEjQpC07lNbZy941q0aBH++usvi46RyWTo168fhg0bBqHQcQYXJiSkZHUKDu3TgaB6vfN9bpGH9oYkcmeG+w1u5aGqc4nHjLKeQPUQrmcqccaoavwDg1dNnjIi9pYT+rojS36bjNi70Xh78y3eBEciKjQSSa/5G+smlApRoH5BFG1THIWbF4HMk4qhOiPq54TkDNTXCXF+1M8JyRmorxPi/KifW8fdXZHVKZCc4MV24PY0IOHO+21z5sV/KF3gWhQoNwUo2M1++dkRFWGwQnh4ODZu3Ihdu3YhMfHzgf8fBit8ys3NDR07dkTPnj3h7+/PR6qEcKIiDNxowDcBgDFjpNiwIeNJyx4eLB48UGVm8XSSxaiv5xzzQ+bgtytTTcZNqfkbvquY+QliLAvs3i3CxIlSxMRYPsm/VCkD5v+Ziho3VkA5bRIEyapM5WN0c4e2WQto2nwNbb0GgFSaqfPZi+DFc0hOn4Tk1AmIz5+FQGXb6xV9jZpIHj4a2oZNzPvgl0l37gjw229S/POPyOpztGunw7RpGnh72+ajm5E1ov2+VrgYcZ4zTi6S43y3a8jnmt8m7RJib/SenjMof/kBilXLOWNUk2cgdUjWT0x+/ZpB48YKxMaavg7o1UuLOXM09LniI6+SXqLm5kCTBYP6lxuEmXXm8JQV+ZTw8SN41qoChuMWs9HVDe+u3wXr6mbz9qOiGAwYIMOVK+ZfaxUqZMTWrSkoVMixbosbWSN6HuqMEy+Pm4ytE1APO9rsg4CxfTExR0Dv6SQ7uxt7B3OuzcLhZwdgZI1Zl4heDFwaA5z5FdBncpJIkWNAxXVA8QOANNkm6bmIXeHr4gtvhQ98lb6o7l8DzQu0ho/S1ybnd2ZUhIEQYq6pQu574R+PZ7DlwhEfii98+G+fM32Qv3bOub9oTRGGD6pVq4Zly5ZBqXSMlbWpCAO3nDAQVProD8geTslwPyuQIrHpW0Bg/fcf2Y0w5jRcrrTijEmsfxesogBPGRF7ywl9PasZtAYkvEhA/JM4xD99/xP36B1i78YgJZr/9yKxUoyCjQujaOtiKNSkCCSu2WyRA2Ix6ueE5AzU1wlxftTPCckZqK8T4vyon1uHijAQXoUfAl7tBKLOAMnPM46TegE+DYG8bYH8XQAbLpTLNyrCkAlarRY3b95EaGgo7t69i7i4OCQmJiI5ORlKpRJubm7w8vJC6dKlUalSJZQvXx6S7Lb6MHFqVISBGw34JgCwZYsII0dyD1S+dEmFIkXo7TS7or6ec2gNWjTeUQ/33t3hjJOL5Pi3yyUUci9sdVvPnzP46ScZTp+2fOCZSMRi1CgtRo3S4sOloyD8NVwm/Azpof1W5/Qxo4srdDVrQVenHrR168NQshQvBQk+w7IQPn4E8bUrEF29DPHlixA9fWKXpnSNm0AzeiwMNWtlST+/fFmIqVOlCA627sOjhweLyZPV6NZNn+n/VRvv/o3v/zU9OXlctYkYXeWHzDVGCI/oPT1nED58AK/aVTljDAUL4d3lMECQdZOT1WqgTRsFrl83/bofGGjAvn0poFtGn5txeQoWhM7ljBEwAvzT8QzK5anAU1bkYy6jh0G+aT1nTMp3w5E8ZYbdctBogB9+kGHrVrHZx+TObcTmzamoWDELJ0h/Ym7w7/j9qunnKbc8N052Og8/F+ct8kvv6cQZvEx8gb/vrMHGu+sQp4njt/EXtYGDy4DoMtafQxYHVFoDVFkG5Hps1iEMGOSS54aPwhc+Sh94K3z+x959xzdRv3EA/9xlp3vRQoFC2QiUqeypyN5LlixBFAVFBRURZS+RJVuQoey99wbZZZVN2bTQ0pmdu98f/VEo0uSSZud5v168SnLPJU+h39wl/X4/l/V3Zdbf8/m8+ruPxIfGupUohIEQItQvbO4Lp+3p9UCH/FXy45NTnzilD2eZOXMmZs+ejYoVK6J+/fqoUKECihUrhoCAALAsixcvXuDq1as4cOAANm7cCK02Z/Bg/fr18ccff0Akcv4kJAphMM0bJoKKE7bB50wnkzXpdc+C8yvtoI6cT/JwOZSxA3LdzoNBWtNkgKUP+jyFN4x1e+M5Hto0LVSJmUi9m4IX2WELKUi5/QLpD9LAc86dbyMPViC6aTEUb1kShetHQSz3nnAZQuOcEG9BY50Qz0fjnBDvQGOdEM9H49w6FMJAnEb9BFA9BLRJgO4FIFIAslBAHg74FXfOGiU7oBAGQrwYhTCYRpNACQBcv86iTh3TV5yZNUuNTp0MDuqI2BqNde9yPuEsmq5vZPZqlLUj62Jdqy0WXwFMrwfmzJFi6lQp1GrL3zBUqGDE779rUK7c2/uTnDgGn5E/QBJ73uLHNoULDoahQkUYKlSEPqYijKXLwlg4CpDJbPMEPA/m+XOI4u9AfOM6RFcvQ3zlMsRXL4NNSbHNc7ztaZVKaDp9BMPAz8CVejUJ0FnjnOeBHTvEGDtWips3rZtE27ChAdOmaZA/v3Vv4xIyn6L2yneRqk0xWVcyqBT2dToKmchGPwOEOAAd071HQLsWkB49bLImZeV66Bu+76COcuJ54KuvZPj7b/OTrcPCOOzdq7L6dd3TZejSUePvKkhQPTVZVzX8XWxttxss47zgDW/EPnmM4Krlwej1udbwIhGST18EV7CQXXvheWD2bAlGj5aB54WdhyuVPBYtUqNRI+cfL7be3ow+u7qbrWPAYHXLjahXqIEDunIeOqYTT6I2qLH33m5svrUBe+7thMpgx8WMqmBgzyTgfF/rH8P/AVBzMlB5ISBVAwBkBiB/BoNw1g/5/CKRL38phBYsi3Df/NmhCuE+EQhVhEFswVWQaaxbh0IYCCFC/cL+YvLz7deniVj6Obg5PM/DN8IXHx/4GKGlQm362K7u3LlzCAoKQtGiRc3WPn36FF999RXOnTuX4/4RI0agR48e9mpRMJpLYJo3nMuw6niEHK1gsiat/BJoI9o5qCPnU96ZDJ/bo3PdbpSGI7neTQd2ROzNG8a6OUadEfoMHXTpOugydNCn66DLzLr98v5X27XQJGugfaGGOlkDTZIamhdq8EbX+/zbp4AvopsVR3TzEsj/XiRYMX227K1onBPiHWisE+L5aJwT4h1orBPi+WicW4fmERBiXxTCQIgXo4kTptHJGwEAjgNKlPBFenruE9B699Zh4kRtrtuJa6Ox7n1GHR+BPy7MMFs3pd509Hynt+DHPXOGxdChcsTFWb64Xirl8d13Onz2mQ5ic+sVOA6ytavgM+5XiB4/svi5hOIZBlyBSBiLFAUXHgEuJAR8cAi4oGDwCgUgFgNSKXhWBEavA7RaMBoNmIwMsEnPwSY9B/P8GURPnoC9Fw82M8Nuvb7JWDgK6j79oenWA3xAoMuNc70eWLxYgkmTZEhLs3yCc2AgjwkTNGjb1mBxOGDfXT2x5fZGkzUMGGxpuxvv5n/P4t4IcSZXG+vEfqRbNiKgb0+TNdomzZC2dKWDOspp6VIJvvlGbrZOLOaxfr0a1avTz6op62+uwad7zC8mnd7gD3xUxvwidmI7PqNGQPmH6fNqTdv2SJ+32EEdAbt2ifDppwpkZgo7SRKLefzxhwZt2jgvWPHSs1i03PChoIXZw979EUOrDnNAV85Fx3TiqTL1mTj88CCOPTqMo4+O4GrSZds8MA/gwsfA7imA2rqFrr4+t1EjagIa+S1FQZUO+TOA/OlARAYQqAHefFXl/PxhqFgZhspVoK9cFYbKVcCFR1j0nDTWrUOTJwghQv3C/uKU55X5y1ChewXU/akufMN9ndKDO9Fqtfj4449x/vyr4OWQkBDs27cPCoXCiZ3RXAJzvOJchucQcqAgWGPuv9/JLPoNVMVHOrAp5/KN+wqKh4ty3a73r4SU9w45sCNib54w1nmehyZZA/WzTKieqaB+poI6SQVdmg66dC10GXroM7Q5wxTSddD/P2jBqHW/7zk3oeXCULhRUUQ3L46wmHCbB1ER9+QJ45wQYh6NdUI8H41zQrwDjXVCPB+Nc+vQPAJiUw83AWe/enVb7AM0OQuIzF+YzlNRCEMutFotbt68ieTkZKSnp8PPzw/BwcEoXrw45HLzE+kJcQc0ccI0OnkjL3XooMDhw7mvio6JMWLPHjtexY7YFY1176PSq1B/VQ3Ep901Wecr8cOhLidQyK+wybq0NGDsWBmWLJEIvuru66pUMWL6dA1KluQs21GrhXzV31DOmAbR/XiLn9fT8BIJdE2aQ9O1O3T1GwGiV2PbVcf58+cMxo+XYvly6352WrXSY+JELUJChL2l23xrA/rt/thsXe9y/TCx7m8W90OIs7nqWCd2oNcjuPI7ECU8zbWEZ1kkn74IrpDp47itnTnDonVrJfR686/rY8dq8Mknegd05d54nke7TS1w7PERk3Uh8hAc73oWQfJgB3Xm3ZiUFwiu9I7ZoK0X+47AUD7GQV1luXqVRbduCjx6JOzqdQzD47fftOjWzfHjMUGVgCZrG+BRxkOztQ0KNcI/LdaBZTz/qnx0TCfeIkXzAleTruBq0mXEJV9FfFo8Hmc8xOOMR1Ab1MIe5FlpYOsc4F59q3oIQyJGYRQ+wQJIkLdAGmNEfhhLl4GhVBkYy5SFoVRpGEuVBu/79l/201i3Dk2eIIQIdfCXgya3H/rlEBiGAc/z8I3wRZUBVax6HlbMQuYngzxIjvDy4chXLh9dSdpC9+7dQ7NmzWAwvDoWz549G++//74Tu6K5BOZ4y7lM4KlGkKSeznW7NvRDpFVa48COnMv/fCfInu/Mdbs2rAXSKv7twI6IvbnbWOeMHJKuPMPjE4/w7GICUm4lI+XWC+jSdc5uzSn8iwSgYN0oFKxbGJG1CkER4tyAI+Ka3G2cE0KsQ2OdEM9H45wQ70BjnRDPR+PcOjSPgNhU3FTg/LdZf2cYIKobUHOpc3tyMnPX2fU6u3btwqpVq3D27FnodP/9BYREIkGVKlXQqVMnNG3a1AkdEkIIcbSqVY0mQxiuXGGhVgNOviANIUQgpUSJ3xrMRLtNLUzWZejT8eW+gVjXestbFzrxPLB1qxg//ijD06eWTypVKHj88IMW/frpX88LEE4mg6Znb2i69oBsw1ooZ/wG8fVrVjyQezOULgNN1x7QdOgCPtS6K346S2goj6lTtejZU4/hw+U4e9ayH4TNmyU4cUKEmTM1aNjQ9IdMiapEfHf4K5M1AJDfpwBGVB9lUR+EEOJwEgk0PXrBZ8qEXEsYjoN82RKofnDclfgSExn07asQFMDQvr0e/fpRAIMQDMNgfN0paLi6Fgxc7otDkzRJGHV8BKY3/MOB3XkvxZJFZgMYdPUbOjyAAQDKluWwfbsKXbooEBdn/vyK5xl89ZUcGRnAgAGOG5cagwa9dnQVFMAQ6VsQf7y/0CsCGAjxJoHyINSMrI2akbVz3M/zPDINmcjUZyJTn4FMXQbUBg0YBmAZFixY6LVirFlYDCsWRcAg4NzjTQqo8DV+w3eYBH/YZoGl6OkTiJ4+gfTg/hz3G/MXAFc4CsbCUTBGFYGxcBS4qCJgikSBj4gAZDKbPD8hhJCc6v9c3+T2Q79kXamdYRj4RviarSf2ExUVhYYNG2L37t3Z9x09etTpIQyEAIDBt7zJEAZx+mUHduN8rPaxye2cvICDOiHkFZ7n8exiIq79cxm3Nl6HJlnj7JacRhGmRME6hVGwbmEUrFMYfoX8nd0SIYQQQgghhBBCCCGEuBfjG58xB1dyTh8uhEIY/i8hIQGDBw9GbGwsgKxfULyNTqfDyZMncfLkSSxZsgS///478ufP78hWCSGEOFjlyqYXthoMDC5eFOG99yhljRB3UTuyLnqU7Y1lVxebrDv2+AgWXJyDATGf57j//n0GP/wgx+7d1p1O16tnwKRJGhQt+vZzTouIxdB27AJth86QHDsC+V9/QrZ9Cxi95y7sNBYpCm3rdtC2agNDuQpZCXtuLCaGw7ZtKixZIsGYMTJkZAj/fp49Y9GlixKff67D999rIZX+t4bneXx36Cska5LNPt7Eur/BT0oTkgghrk/ToxeU0yaDMeZ+Dq5Y/hdUQ4c5ZGGfXg988okcT56YXyD9zjtGTJ2qcffDl0OVDi6D/hU+wx8XZpis++facrQr0RH1CjVwUGdeSq2GYr75sAvVl187oJm3y5+fx5YtKvTqpcDRo8LO2X/6SY6MDAZff62z+/jkeA5DDnyGswm5L2R5ScpKsaDxEoQoQuzbFCHEZTAMA1+JL3wlvgDC/7N9/34Rhg2T494964JZupU7h3HJn6Hw43/z2KkwoiePIXryGJJ/T7x1OxccAmP1GkCHLtC1aOWQngghhLyS27wI4ljVq1fPEcJw9+5dJ3ZDyCsGv/Imt4u0j8Dok8FLgh3UkXOJNI9MbjfKIh3UCSGAOkmNG2vjEPf3JSTHJTm7HYdjJSxCy4UhvHJ+5KsUgXyVIxBYLAgMffBOCCGEEEIIIYQQQggh1hMrc95W0O8+KIQBwL1799C7d288efIke5KBqQ/kX9bExsaia9euWLJkCaKiohzSKyGEEMerXJkzW3P2LEshDIS4mZ9r/Iq993bhSabpq9aMOTkK9Qs1Qqng0tDrgblzpZg6VQqVyvIJHKGhHEaP1qJdO4PtF3YxDPS160Jfuy4ynj2D/J/lkK9dCfG1OBs/kXMYihWHrnkraFu39YjghTexLNCnjx5NmxowfLgMO3ZILNp/9mwpTpwQYe5cNYoUyTlxet3N1dh+d4vZx2hZrA2aFG1m0fMSQoizcPkLQNe0BWRbN+Vawz5/Btm2zdC262j3fn79VYYTJ8x/zBYYyGPxYjWUSrOl5A3fVB2G9TfX4GnmE9N1hwbjUOeTUEroH9le5P8sB/v8uckafeUq0Neq46CO3s7fH/jnHzW+/FKODRuEnVtNnChDejqDn3/W2vV089cTI7H+5lpBtVPqT0fViHft1wwhxG08ecLgp59k2LzZsveLL5UsacTkyVrUqFEC4Hfjxb8nIV/zD2SbNoBNS7Vxt8KxyUlgt29FwPatyPzuB6i+Ge60XgghxJtE1Y3KnhMRVDzIyd2QNy/8kZxsPlCXEEcw+JUzWyNOvwx9cF0HdONkRg1YvemF7py8gIOaId6K53g8PHIfcSsu4872W+B03jFHhWEZBEQHIl/FrLCF8EoRCC0XBpGMpr4SQgghhBBCCCGEEEKITSne+F2HUe2cPlwIw3v5pQ2MRiM6deqEK1euWJyE/PKfrmzZslizZg1EIpE9WiTEbp49S3d2Cy5NKs05pnVe8stL8nbVqvmYvLpcq1Z6LFyocWBHxFZorHu33fE70H17Z7N1MWGV8EvBg/h+uA/i4qw75+vWTYeRI7UIcvB8VtGN65Bt3gDZlo0Qx1117JPnAefjC32detA1aARdg0bgihS1+rHccZxv2ybG8OEyJCRYdmVTPz8eU6dq0KaNAQDwNPMJ6qx8D6naFJP7BcoCcaTLKYT7RFjbMiFO545jneSN5MghBLZvabJG/14NpGzZZdc+1q4V47PPFGbrGIbHP/+o0bAh/Wxaa+PNdei/p7fZus8rDsbPNUc7oCMvZDAguHpliO7HmyxL/XO5y1zNnOOAUaNkmDtXKnifnj11mDRJC9a6i8ybND/2D4w4JmyBsbf+LNMxnZCcDAZgwQIJJk2SITPT8oQYuZzH0KE6DByog/RtL4UaDaQH9kG6cxtku7aDdfKizxd7D8NQoaJTe3BlYWF+zm6BEEKIHRw+fBiffPJJ9u3o6Gjs2LHDiR3RXAJzvOZ9iyEDoQciwSD3qWUZJcdDHfW5A5tyDlZ1ByHHKpqsSamyHfrg2o5piDiEK4x1o86Ixyce4t6eO7i74zbSH6Q5vAdHYaUi+EcFIDA6EAFFgxBcJgQhZcMQXDIYYoV1gYSEmOMK45wQYn801gnxfDTOCfEONNYJ8Xw0zq1D8wiITaVcAbaXf3XR1PK/AuV+dG5PTub1ccBLly59awDDy4AFhUIBPz8/pKenQ63OSu14WcswDHieR1xcHP766y/06dPHsc0TQghxmCpVjCZDGM6epSAeQtxR4yJN0bV0D/x9bVnuRaogxC4aiDbn/K16juLFjZg6VYsaNZzzIYCxZCmovhkO1TfDwcbfhfTIIUiOHIT06GGzVzB2JC4gEPpq78JQ7T3o36sBfdV38fbVId6heXMDatY04Pvv5Vi/XvikovR0Bv37K3DsmA6jR2sw9OCXZgMYAGB8nSkUwEAIcTv62nVhKF4C4ls3c62R/HsCosuXYCxX3i49XLrEYuhQuaDa4cN1FMCQR62Lt8PqG39j7709JuvmxM5E2xLtUSGsomMa8yKyzRvMBjAYipeArlkLxzQkAMsCv/6qRUgIj7FjZYL2WbpUCqMRmDrVtkEMm29twE/HvhdU+0HUhxhRfZTtnpwQ4pb+/VeEYcNkuHrVus8eGzY0YMIEDYoUMZHHLpdD17Q5dE2bI8NggOT0v5Du2Abp7h0Q37ltZefWk61bQyEMhBBCvM7zNz6rDw4OdlInhLxB7AujoijE6ju5l6RfcmBDziPSPDJbY5QXMFtDiBDq5yrc2xePe7tv4/6Be9Bn6Jzdks28GbQQUDQQAdGBCCgaCN9IP7AiO6SiEkIIIYQQQgghhBBCCBEm8B1AEQFoErJuJ+yjEAZnN+BMPM9j+fLlOQIYeJ5HaGgo+vXrh8aNG6NAgVe/IHv8+DF2796NhQsX4vnz52AYJjuIYfny5RTCQAghHqxKFaPJRbCPHrF4+pRBRISJCc2EEJc0uvZ4HHl0CA/S7+fcwAOI7QHsngqowix+XKmUx+DBOnz5pQ4yYWu97I4rUhSaIkWh6dEL4DiIrl+DOPY8JLHnIY69APGVS2D+Hzxm1z7C8sHwTjkY3ikPQ9l3YCgfA2PJUrDLpYbdWFAQMHeuBs2aGfDddzIkJwv/9/nrLyn2/5uEB02vAAGma5tHt0K7Eh3z2C0hhDgBw0DTux98fxxmskyxcC4yfp9t86dPTgZ691ZArTZ/ReomTfQYPNhzJso6C8Mw+K3RDNRYVhWZ+sxc6ziew5ADg7Cr/QFIRHSFNJvheShn/m62TP35YJc8rxs8WAdfXx7ffy8sOGXFCik4jsG0aRqbfDvHHh3BZ3s/AW/i6qEvlQ4ug7kfLIKIpcBHQrzVvXsMxo6VYeNG645j4eEcxo7VomVLAxjzpyqviMXQ16gFfY1ayPx1HNiHDyA5ehjSo4chOXIIoiePrerHEoxOa/fnIIQQQlzN2bNnc9yOiKDAXOI6jH7lTYYwiDIuO7Ab52G15kMYOBmFMBDr8DyP5GtJuLfnDuJ33cHTM48h4CMkpxMrxZD6yiDxlUDql/VV5i+DIlQJebAC8iB51tcQBRTBCijz+cCngC8FLRBCCCGEEEIIIYQQQogrK9oLuDoh6+/PjgJp1wH/Uk5tyZkYnufd4CN7+zhx4gR69+6dHaTAMAwqVKiAOXPmmLyyQHJyMj777DNcuHAhx76LFy9G9erVHfgdEJI3z56lO7sFlyaV5pzortPRFUu92blzLJo08TFZs3ixGs2bGxzUEbEVGusEAI4/Ooq2m5q/WhD1rBSwbQ4Q38Cqx6tZ04ApUzQoXtzNTrWNRrBPHkN09w5E8XchunsH7NMnYJOTwCQngU1OBpOaCkavB/S6rK8AeIYBFArwMhl4mRx8UDC40FBwISHgQ0JhjCwEY1QRcEWKwBhVBLy/mVQAG/OEcZ6QwGDoUDl277YwR0/5DOjQBYje/9bNIfIQHO5yCmFKy4NGCHE1njDWieWY1BSExJQGo1LlWsPLZEg6Hwc+NNRmz2swAF26KHD4sPnX5WLFOOzalQl/f5s9vVeTSkWYc342vj/0ndna76r9gG+qDXdAV95Bsn8PAru0N1ljjMiP5NMX4TIpZG+xcqUYQ4bIwXHCViV36aLHtGkaiPKQh3A24TQ6bG6NTH2G2dpQRSi2t9uHIgFFrX9CN0fHdOLNUlOBadNkWLhQAp3OkvSELAzDo08fPb7/Xmv7cw+eh+jubYjPnoHk3BmIz52B+PKl7M8GbCVjzASo+39m08f0JGFhfs5ugRBCiI2lpaWhUaNGSEtLy75v7Nix6NChgxO7orkE5njT+xblnUnwuT0m1+08I8Xzhk8A1rODMBV3f4PvrVG5buckoUiqn3tYBXFP9hzrPM/j2cVE3N50Hbc330Ta/VSbPbY5sgAZZEFySP1kkPpJIfWTQuIjffV339e++r66LfWVQuIng9RXAomPFKyYwhSI+/OmYzoh3ozGOiGej8Y5Id6Bxjohno/GuXVoHgGxOW0ysLUkoHuRdTtfA6DBLsBLLypl4Qoez/Lm1QSCgoLwxx9/mAxgAIDg4GDMmjULrVu3RnJycvb9Z86coRAGQgjxUO+8w0Eq5U1Ofj53jkXz5g5sihBiMzUja2NAzOeYe2YhcOR74OhwgJNa/DhBQTxGjdKgSxcLrzTpKkQicAULgStYCPo69czX8zxgNAIiEdzzG3Yf4eE8li1TY9kyCUaMkEGjEfjvrQoDlu0GGv4I1J4IvLHbpHrTKICBEOLW+IBAaNp3gmLZklxrGK0WiqV/QvW1+UX7Qo0bJxUUwODjw2PJEjUFMNhY/5hPsfbaapxNOGOy7rezk9C4SBNUCKvomMY8nHLm72Zr1J8OcukABgDo0sUAHx8NPv1UDr3e/DnVypUScBwwfbp1QQyXn19Cl63tBQUwKMVKLG+22qsDGAjxVqmpwIIFUsyfL0VKinXvrytUMGLKFA0qVuRs3N3/MQyM0cVhjC4ObccuWfdptRBfvgjx1SsQXY+DOC4OoutxECUmWPUUxsJRUHfvZbueCSGEEDcwceLEHAEMEokEdevWdWJHhORk8CtvcjvD6yDKvAGj3zsO6sg5RNpHJrcb5ZEO6oS4O02KBnErLuPq0otIvZtit+fxifBBxHuRCC4VgqASwfCPCoAynw8UIQqIZF49ZZQQQgghhBBCCCGEEEKIKbJgoPoS4HAbADyQeAA4/lHWfWKlc3tzAq/+RP3y5csAspKlGYbBxx9/jJCQEEH7hoaG4uOPP8Zvv/0G5v8Lzl4+HiGEEM8jkwHly3M4ezb3FRemthFCXF9d3WgsmvcN9M+jrNq/c2c9fv5Zi9BQ3saduTCGAcRe/ZbCoRgG6NlTj2rVjBgwQI5r1wQed3gRsG8C8LA60PZjQJ41obdt8fZoWayN/RomhBAHUfcdYDKEAQDkixdCNWgIILU8ZOlNmzaJMWuWsEXmM2ZoUKqUnRZCejERK8KMD2aj3t+1YOAMudYZOAMG7RuA3R0OQS6WO7BDzyM+/S+kx46YrOECAqHp2csxDeVRy5YG+Pio0auXQlC41erVWUEMM2daFsRw88UNdNrSGqnaFLO1IkaEBY2XoHJ4VeFPQAhxe0lJDObPl2DhQinS060LX/Dx4fH991r06aN3/Ft0mQyGKtVgqFItx91MchLE1+IgunsH7P14iO7FQ3TvHkT374F9lvjWh9KXq4D0mXMBpff9spYQQlxR2sM0pN5PhSZFA02qBpze+ve2MT1jbNiZ65o/fz5q1qyJcuXKCao3GAyYMmUK1q5dm+P+Ll26IF++fPZokRCrGHzN/0yLMy55fAgDq3lscjsnK+CgToi70qRocO73f3F5SSwMqtw/08wLWZAcJduVRqnOZREWE549p5EQQgghhBBCCCGEEEIIsUhkC6DmCuBkL4DTAQ/WAclngfK/AoU7ACLXvliXLXn1iqn4+HgwDAOez1oo16xZM4v2b9q0KX777TcAWUEO8fHxtm6REEKIC6lSxWgyaOHCBVH2BeEJIe4jJQUYNUqGv/+WAgi0eP/ixY2YPFmLWrWMtm6NkLcqU4bDzp0qjBwpw9KlFiwmvt4GWHgS+KgVwgtlYFydKXbrkRBCHMlY9h3o6tSD9MihXGtECU8h27IR2vad8vRcly6xGDxY2GL+wYO1aNnSPpNpCfBOaDkMqToUU05NNFl3LTkOk06Pw8gavzqoM8+k/G2S2Rp1n37gff0c0I1tNGxoxKpVanTtqkBmpvkJ6WvXSsDzwKxZwoIY7qXFo8PmVniufi6on8n1fscHRZoIqiWEuL/YWBZ//inFhg1iQWEwuWnTRo9fftEif37XCoTkg0Ogr1kb+pq1/7tRpYLo8SNIkxLBPn0CGI3gChWGumJVQCJxfLOEEEKy3dl7B+cWnsODYw+Q/jjdZo/rLSEMR44cwdSpU1GpUiU0bdoUNWrUQHR0NMRvpCSlp6fj0KFDWLhwIeLi4nJsK1y4MD7//HNHtk2IWZy8IDhxIFhDSq414vRL0Obv4rimnMBsCIOcQhjI2/Ecj8uLL+DUxOPQpmjt8hwF6xZGme7lEd20GEQyr54OSgghhBBCCCGEEEIIISSv7ix99feSg4BrvwPggIy7wMmewJlBQOh7QFBlQJ4PkPgDjJWfTUf3tEXHduXVn7pnZGRk/93f3x+FChWyaP9ChQohICAAaWlZV5JNT7fdRARCCCGup0oV0wusVSoGt26xdKVbQtzI1q1iDB8uQ2Iia/G+jFiLIV9p8fWXDGTeE+JGXIRSCUyZokXdukZ89ZVc+BVTn5cBFpzCJ1OvIUQRYt8mCSHEgdT9PzMZwgAAivl/QNuuI2Dl1b+ePGHQrZsCKpX5/Rs0MGD4cJ1Vz0OE++bd77D55kbceHHdZN3s89PRpEhzvJv/PQd15lnEF85Btm+PyRpeLoe630AHdWQ7NWoYsXKlGl26CAtiWLfuVRCDqavNP8l4jA6bW+FJpukFGi99U3U4upf9WGjbhBA39egRg40bxVi/XoJLl/KW4hodzWHCBA3q13fDQEilEsbiJWAsWxo5ute54fdCCCEe4mnsU2zsuRGJlxMBIPsiFrbgjVfgPn/+PM6fPw8AkEqliIiIgJ+fH1iWRUpKCh49egSO++/vEsPCwrBgwQIEBQU5umVCTGMYGPzKQfriaK4l4vTLDmzIOUTaRya3c/JIB3VC3Ik6SY19X+zE/b13bf7YPhE+KN21HMp8VA7+UQE2f3xCCCGEEEIIIYQQQgghXupkr7fPtWYYgOcBfSrwdE/Wn7yiEAbX9npogrW/yA4KCsoOYXg91IEQQojnqVjR/ETg8+cphIEQd5CQwOD772XYutXKKywW2wW+2ee4Xq4spNLlALxvIilxDa1aGVCuXCZ695YjLk7g2ztNEMZ/WR2KFC369dNbuxaZEEJciu6DD2EsUhSi+Nwns0rOn4P4zCkYqlm+ED8jA+jeXYGnT80HN0VFcZg7Vw1R3tZWEgHkYjlmNZqHpusawcjn/n6NB49B+/pjf+dj8JX4OrBDz6D8bZLZGk2XbuDDwhzQje29954Rq1ap0KWLEhkZ5k+M1q/Peg+RWxDDo/SHaLupOe6lxQt6/l7v9MW31b63pGVCiJvgeeD6dRYHDoiwc6cYJ07k/VdyMhmPIUN0+PxzHeRyGzRJCCHE611cfhFb+m+BUWsEz/NgGMZmwQm2DHNwVzqdDvfv3zdbV69ePYwfPx4hIRScS1yTwa+8mRCGS1knwJ76CwdOB1aXaLLEKCvgoGaIu0iKe45tXTcg45HtLuoUWCIYRRpHo0jjaERUKwBWbPmFBgghhBBCCCGEEEIIIYQQQd78fS/DvPpdkC1+F+wmv1fy6hAGrVabPYFAoVBY9Rjy12a56XR0hUNCCPFkRYrwCAzkkZKS+0H+wgURunQxOLArQogleB5YuVKMkSPlSE214oTd9wnQZAjwzmqAAbbfvY1ZF6bji0pDbN0qIYJFR/OoO+pHxI0pD1zqLmgfo5HBjz/KcfUqiwkTtJDJ7NwkIYTYG8tC3W8AfEcMN1mmWDAH6RaGMBiNwGefyQVdsVqp5LFkiRp00UrHqZivMoZU+QZTz0w0WRefdhc/HPkWMxrOcVBnnkF0+RJkO7ebrOHFYqi++MpBHdnHu+9yWL1ahc6dlUhPFxbEwPPA7Nk5gxgepj+wKIChU6mPMKHuVK+8OjAhnkinywpduHBBhLNnWRw8KMbjx7ZbENOmjR4//qhFVBQtaCWEEGIb94/ex+a+m2HUZ4XaMQxjcXDC6+ey3h668OmnnyI6Ohpnz57FnTt3YDSaDndXKpWoW7cuunfvjmrVqjmoS0KsY/Atb3I7q38OVpcAThbhoI4ci9U+MVvDySMd0AlxF8nXk7C5/Rqon6vz9DismEWBGgUR1TgaRT4oioBo+uCZEEIIIYQQQgghhBBCiIOYmteY1zmPbvS7Za8OYSCEEEIswTBATIwRhw7lfviMjaXL3RLiqp48YfDVV3Ls32/NKTAHVPsDaDgCUKTm2DL25ChUDKuEOgXr2aZRQiy08+52zIubBLQDUOgEsHMawEkF7btihRQ3b7JYvFiDsDD3eSNLCCFvo/moO5QTxoLNyP3KYrItm5D5+BG4AsInRY8aJcPOnRJBtdOmafDOO5zgxya28VWVb7E7ficuPY81Wbfy2go0KNQIbUt0cFBn7s9n2mSzNZrOXcEVKuyAbuyratWsIIZOnYQFMWzYkPW68DKI4X7aPbTb1AL30+8Jer4W0a3xe4PZYBm6YiEh7shgAG7cYBEbmxW6EBsrwpUrLLRa24eqVKtmxC+/aFC1Kp1jEEIIsR2j3oh1XdfBqDfXBNm6AAEAAElEQVRmBynwPI+yHcoipmcMgksEY3W71Xh+7Tl4ngfDMPjyzpcwqA1QJ6vx4s4LPDjxANc3Xkf6k/Tsx5AHyNFkehNE1Yty5rfnFLVq1UKtWrUAAGq1Grdu3cKjR4/w7NkzqFQqcBwHf39/+Pv7o3jx4ihZsiREIvq9InEPRr9yZmtE6Zc8N4RB89hsDScr4IBOiDtIuf0Cm9uvtTqAQR4sR+FGRVHkw2IoVD8KMn9KUieEEEIIIYQQQgghhBDiYG4UkmBvFMJACCGEWKBSJdMhDJcvs9DpAKmwta+EEAfgeWDDBjGGDZMjNdWKxRAR54CWA4DIM2/dzPEcBuzpjT0dDiPSr2AeuyXEMvGpd/HF/k+zbjAA3v0DyH8OWL0WSBe2wPjUKTEaN1Zi6VI1ypenRT2EEPfF+/lD81E3KBfMzbWGMRqhWLwQmT/+LOgxZ8yQYt48YSf3n3+uQ9u2BkG1xLakIilmNZqHD9bUhY7Tmaz95tAQVA6viij/Io5pzo2JrsVBunWTyRpeJILqy68d1JH9VanCYc2arCCGtDThQQzfjotDp20t8DDjgaDnaVT4A8z9YBHELH08T4g7MBqB27dZXLjAIjZWhAsXRLh8mYVabfvAhdeVLm3Et9/q0KKFIc/h8YQQQsibYpfGIu1hGhiGyQpZYBm0WdwGMT1jsmtE0pwBAYFRgdl/L1SzECp0r4Cm05vi4oqL2PPtHqiT1NCkarC532Y0n9MclftWdtS343IUCgXKly+P8uXLO7sVQmzC4FMaPCMCwxtzrRGnX4Y+9AMHduU4Iu0jszVGufDQV+K5UuNTsKndGqgSMy3aTxGqQHTzEijephTyV48EK6LQTkIIIYQQQgghhBBCCCFO0vqusztwKTTLkxBCCLFATIzpxalaLYNr11hUqECLWAlxBUlJDIYNk2HzZmFXr36dUsnj2+9U2JlvCP5NfHsAw0vP1c/Ra2c3bGqzA0qJ0tp2CbGISq9C3109kapNybmh0ElgQKWsIIb7dQU91qNHLFq2VGLWLA1atKAFxIQQ96XuOwCKhfPAmEhglS/9E5lffQsoTR+z//pLgjFjhF1lrGlTPUaM0FrUK7GtMiFlMey9ERh9YqTJunRdGgbu6YfNbXfSAngzlL9PNjmWAEDbriO4otEO6sgxKlfmsHatCh07KgWFuG3YIMHOu/FQt3wMCLiIbc0CtfFnk+WQiii9kRBX9eQJg7NnRTh3jsXZsyJcvChCZqbjUhDKlzfiq690aNbMAJbW3RBCCLGTs/POAkBWAAPD4N1B7+YIYBCKFbOo+HFFFG9SHP+0+AePzz4GZ+CwdcBWKIIVKNO2jK1bJ4Q4g0gOo7IkxJlxuZaI0y86sCHHYjWPTW7nJEGAiH4/6O3SH6Zhc/u1yHySIXif8CoRiBlYFUWbFoNIIuCDJUIIIYQQQgghhBBCCCHE3nyinN2BS6HpW4QQQogFKlXK/eoeL124QL8cJ8QV7NkjQr16SqsCGOrVM+DQoUx8/hmHhc3+RLgywuw+sc/O44v9n4LjKYSF2B/P8xhy4DNceh779gLfZ0DP94HK8wU/pkrFoE8fBaZNk8LMektCCHFZXHQx6Bo3MVnDvngB+aq/TdZs2CDGd98JC2CoUMGIP/7QQERvA5zus5gv8F7+GmbrziScwpTT4x3QkfsS3b4J2cb1Jmt4hoFqyDcO6sixKlbMCmIIDBR2UqS+0ApYvwIwmn4hqBJeDcubrYJCrLBFm4QQG+A44OJFFn/8IUGfPnJUrOiDmBhf9OmjwKxZMpw4IXZYAEPt2gYsX67C3r0qtGhBAQyEEELsR5epw9PzT8EwWcc4VsKi3sh6eXpM33BfdN/VHSElQsAwDHiOx5Z+W6B6rrJFy4QQF2DwK29yuzjjsoM6cTxW89Dkdk4W6aBOiKvKfJqBTe3WIP1BmqB6nwK+aLKkFdpt/wjFW5WkAAZCCCGEEEIIIYQQQgghxEXRFC5CCCHEAvnz88iXz/QC6wsX6PBKiDNlZABffy1Dt25KJCZaNh4DA3nMmKHG6tVqREVlLbgKV4ZjwYd/CbpS8pbbGzHh3zFW9U2IJaafm4qNt0wvjIRYD3nbIRg8Ih4ikfBUhfHjZRg4UA61Oo9NEkKIk6g/GWi2RjlnJmB8e8Da6tViDBwoB8+bX3CZPz+H5cvV8PGxuE1iByJWhDnvL0SALNBs7bSzU3DwwX77N+WmlL9PBcOZfu+rbd0WxhIlHdSR48XEWBbEgCudTQYxVIt4D6tbboCv1M+GXRJCrHH3LoO//pKgb185ypb1wfvv+2DUKDm2bpXg8WPHfq7n68ujd28dDh/OxPr1ajRubATjmMwHQgghXuzRqUfgjFnn+wzDoGiDolAE5z0oTBGsQNOZTcHzPBiGgSZFg+NTj+f5cQkhrsFcCIMo8yZg9MxfLIi0j01uN8oLOKgT4opUz1TY3GEt0uJTBdUXblgEnff3QHSz4tmBSIQQQgghhBBCCCGEEEIIcU3mV5J5iXv37qFnz55W7fc6ax4DyJrc8Ndff1m1LyGEEMdhmKwrYu7enfuE7AsX6CoFhDjLhQss+vdXID7e8kUTrVrpMXasFuHh/11kVT1/DfxScyx+PDrM7OP8fm4KigUWR+fSXS3ugRAhdsXvwPh/RwuqnVxvGjqXDkGdimr066dASoqwyVzr10sQH8/ir7/Ubx0ThBDiyvR16sFQpizEcVdzrRHF34V0+xboWrbJcf/ixRIMGyYX9DxKJY/ly9WIiKDXSVdS0K8Qfqs/A313mf6MjgePgXv6Ym/HI4j0K+ig7twDe/cOZGtXma1TffWdA7pxrgoVsoIYOnRQCjuPutIZ4BmgfVdA9CropXr+mvi7+RoKYCDESTgu6/OCHTvE2L5djJs3nfvZnVTK44MPDGjXzoD33zdAkfc1r4QQQohF0h+l57hdoJqwxcNGnREiqenjaLHGxRBePhyJlxPB8zxil8Ti/fHvW90rIcR1GPzKmdzOgIM4Iw6GgMoO6shxWM1Dk9s5WaSDOiGuRvNCjS2d1uHFjWRB9UU+jMaHi1qaPZ4SQgghhBBCCCGEEEIIIcQ1UAjD/6nVapw+fdqqfXmez/5qzWO8vBIEIYQQ91CxohG7d+d+CI2LY6FWgyZQE+JAHAfMnSvB2LEy6PWWnVeFh3OYOFGLZs0MJuv6lf8UZxNOY/3NtWYf8+uDXyDKvwiqF6hpUS+EmHM9+RoG7ukHHuYX/HYv83F2GEjdukbs3JmJnj0VuHFD2MSuc+dEaNxYiWXL1KhQwfSVsAkhxKUwDNQDPoffkM9Nliln/Q5di9YAw4DngRkzpBg7ViboKcRiHgsXqlG+PL0+uqKWxdqge5mPsTzOdOBpkiYJ/Xb3xKY2OyEVSR3UnevzmTIBjNFoskbbvBWMZco6qCPnsjiI4WqnrK/tuwEiA2oWqI3lzVfDV+Jr30YJITlwHHDmDItNmyTYulWMJ08sD2u0peBgDvXrG9GggQFNmhgQEODUdgghhHg5dXLWlepfzlMIig56ax0jynn+a9AYBC0aLdGiBBIuJQAAMhMzkXApAeHlw/PYNSHE2Qy+5c3WiDMue2QIg0jzwOR2Tk4hDN5Im6bF1i7rkXTlmaD6Qg2i8OHCFhTAQAghhBBCCCGEEEIIIYS4EQph+L+XQQqOfhwKXyCEEPdTqZLpxShGI4PLl1lUq0YLsuxFpwNu3WLx8CGDhw9ZPHnCQKVioNMBej0gEgGBgTwCA4GwMA7R0RxKluQQGOjszok9JCYy+OILOQ4csPzUtl07PSZM0Aj62WAYBlPrz8T15Ou4knTJZK2e06PHji7Y2Ho73gk1fWUgQoRKVCWi2/ZOyNCnm62tEFYRY+tMynFfdDSP7dtVGDhQgT17hI2XJ09YtGypxKxZGrRsaTqohBBCXImmfScox4+GKOFprjWS8+cgOXEMGVVqY+hQOVavlgh6bIbhMWuWBu+/b/p9AXGu0bUn4OST47iVctNk3dmEMxh1/EeMqzPZQZ25NtH1a5CtXWW2TvX1tw7oxnVUqMBh3ToVWrYRQ5UuIKzlaicADGp9MRfLm6+Aj8TH7j0SQgCeBy5eZLFhgwSbN4vx8KHzghdCQzlUqsShcuWs4IWYGA4iWmdDCCHERWjTtTluS/3eHkon9ZXmmP+gSdVA5m/+fPjNUIdnV55RCAMhHoCX5QMnzQdWl5hrjTj9ogM7chCjGqzO9CJ7o7yQg5ohrkKfqce2rhuQeD5BUH1knUJouqQVRDKaqkkIIYQQQgghhBBCCCGEuBP6ZB8UhEAIIcQyMTHmwxViY0UUwmBDaWnAwYNiHDsmwoULIly5wkKns/z4HRbGoWpVI2rVMqJmTSPKlqX/I3d34IAIgwbJ8eyZZQsrgoM5TJqkRatWli0q95H4YHmzVfhwXQMkqkxPqknVpqDz1rbY2nY3igQUteh5CHlTpj4T3bd1xP20eLO1oYow/NXkbyjEiv9s8/cHli5VY8wYGWbPFnbFb7WaQd++Cnz3nRZDh+pAb58IIW5BJoP6k4HwHfOzybLHk1aja2ZjxMYKXxU5caIW7dpRMI2r85H4YN4Hf6LpukbQcTqTtQsvzUO1iPfQtkQHB3XnupSTx4MxEzKrbdwEhvIxDurIdVwQ/QlV18XA0j2AOsT8Dlc7ImBrS0hb6e3fHCFe7tkzBqtXi/H33xLcvOn4pIPgYA4xMRwqVjRmf82fn6f3ToQQQlyW1Cfn54K88e3vAd4MXEh7kIaAQgFmH18eKAfwah5G+mPzobKEEPdg8CsPadK+XLeL0i87sBvHEGkemq3hKITBqxjUemzvuRFPTz0WVJ//vUg0W9oGYoWwEGBCCCGEEEIIIYQQQgghhLgOrw9h4M1MKiaEEELeFBrKo1AhDg8e5L7o+/x5EQBaaJEXL14A69dLsH27GCdOiGAw5H3m+rNnLHbsYLFjR9YEh/z5ObRpY0S7dkZUrcrR5Hg3YjAAEyZIMWOGgKvQvqFxYwOmTtUgPNy688BIv4JY1nQlWm9sCo1RY7I2UZWAjltaY2u7PQhX0pW+iHUMnAEDdvfGhWfnzdZKWAkWN1mBSL+CudaIRMDPP2tRqpQR33wjFxxqM2mSDNevs5g+XQOlUnD7hBDiNJqPe0M5bTLYzIz/bOPAYAE+wTfHpyADwhdrjhihRa9edJ7vLsqHxeDX2uMx/PBQs7VfHfgC74SUR8ngUg7ozDWJLl2EfPMGs3Wqb4Y7oBvXwfM8fj87BeNPjQbyA+j5PrB0r6Aghu3b5BgwQIS5czWQCsu/IoQIZDBkBTOuWCHB7t1im3xuJIS/P4+YGCMqVjSiYkUOMTFGFCpEgQuEEELcy8uQhJe0adq31inDcn4ImHQzCYVqml9orHmR83Nzg4aCDAnxFOZCGMQZVwCehyedILOaB2ZrjAoKYfAWRq0BO/tswaMj5n8uACBf5Qg0/7sNJD4UwEAIIYQQQgghhBBCCCGEuCOvDmHYty/3XwwSQgghplSsaDQZwnDhQu7bSO54Hjh2TITlyyXYtk0Mrda+E3SePGExZw6LOXMkKFKEQ79+BnTubESA+Qs5ESdKTGQwYIAcx45Zdirr48Nj7FgNPvrIkOe5X5XCq2D2+/PRd1dPs7X30uLReUtbbGqzHQGywLw9MfE6PM9j+OFvsPveTkH1E+v+hvfyVxdU26WLAUWLqtG7txzPnws7bm3aJMG9eyz++kuN/Pkp0I4Q4tr4gEBoevaGcs7MHPf/i3cxFFNxDLUterxfftFg4EAKYHA3vd/ph1NPTmL9zTUm61SGTPTZ1R072u+Dn9TfQd25Fp9JY83WaJu1hKFiZQd04xqMnBHDj3yDv64senVn/gtAz0bA0n2Cghi2bpWge3cGixer4eNjv14J8RZ37zL45x8JVq6U4OlT+37+JpPxKF+eQ5UqRlSqlBW8ULQoBS4QQghxf0HFggAAzP8PapnPMt9al69cvhx1D449QMWPK5p9/CfnngDI+myTYRjI/C0PUyaEuCaDbzmT21lDKljNfXCKKAd1ZH8itenF9jxYcLICDuqGOJNRb8TuAdtxf1+8oPrQcmFosbIdpH50HCSEEEIIIYQQQgghhBDiZCf7vOVOBqi+6L93v7XWHnJ5fhfj1SEMkZGRzm6BWODmzZu4cuUKEhMTwXEcAgMDUaJECcTExEAsds6Pslarxe3bt3Hr1i0kJydDrVbDz88PgYGBKFu2LKKjo53SFyHE/mJiOGzZkvv2W7dYpKcDfn6O68mdcRywfbsY06dLERsr/ErEthQfz2LECCnGjZOgSxc9vvhCh8hIWmDsav79V4R+/eRISLBsoUWNGgbMnKlB4cK2+z9tWawNfnhvJMb9+6vZ2qtJl9FpSxusbrmRghiIRaafm4qlV/8UVNuv/AB0L/uxRY//3ntG7NqlQo8eCly9Kuz198IFERo3VmLpUjUqVeIsej5CCHE0df+BUCyYAxgMOIy6mIqh2IJWFj0Gw/CYMkWLHj0ogMEdMQyDqfVn4MrzS7j+4prJ2hsvrmPgnn74q+k/ELHOeV/iLOKzpyHbtcNkDc8wyPzuBwd15HwqvQqf7u2LnXe3/Xdj/liLghgOHhSjY0clVqxQISjIDs0S4uE4DjhwQIS5c6U4dMh+vwuIiOBQs6YR1aoZUbmyEe+8w0EqtdvTEUIIIU4TWjo0x+3ncc/fWhcRE5H9d57ncW3DNTSd2RRiWe7HY71Kj6trroJhGPB81ufxPuGURkaIpzD4lTdbI06/BJ0HhTCwmvsmt3PyAgArcVA3xFk4I4fdA3fg7vZbguqDSoWg5er2kAfK7dwZIYQQQgghhBBCCCGEECLAnSXIceUZns+6/bYQhDdr7cHU87sYrw5hIK6P53msW7cOCxYsQHx8/FtrAgMD8dFHH6F///5QKpV27+nGjRvYvXs3Tpw4gdjYWOj1uS/CCAkJQYcOHdCtWzeEh4fbvTdCiONUqmQ0uZ3nGVy8KEKtWqbrvB3PAzt2iDF+vBTXr7vGIieVisGff0qxfLkEH3+sx+DBOuTLR2EMzsbzwLx5Evz6qwwGg/CTeZbl8e23OgwZooPIDj9igysPxb20eKyIW2q29nziOXTY3BqrW25AkDzY9s0Qj7Po0jxBIR8AULdgA/xSc5xVz1OoEI+tW1X47DM5du4UNlEwIYFF69ZKzJihQZs2BquelxBC7M1oBC4mFcbhUn9jzZV3EIeyFj+GWMxj1iwN2rWj1zp35iPxwZ9NlqPx2vrI1GeYrN19byfG/fsrfqrxi4O6cw0+E8aYrdG2bQ9j2Xcc0I3zJWuS0H1bZ5xJOJV7kYVBDGfOiNCmjRKrV6sRHk7vMQkRQq0G1qyRYN48CW7etP2bel9fHrVrG1C3rhF16xpRogRn998fEkIIIa7AJ8wHAYUDkPYgDTzPI/FS4lvrCtcuDHmAHNo0LQBAnazG4dGH0XBMw1wfe8fgHVAlqcC8dlAtVKOQbb8BQojTGJUlwLMyMJw21xpx+kXo8rVwYFf2JdI8MLmdkxd0UCfEWXiOx94vd+H62jhB9QFFA9FqbXsoQu0/h40QQgghhBBCCCGEEEIIscjL8AOhtfbgZhO0GJ63178EIXmTlpaGIUOG4NixY4LqCxUqhDlz5qBEiRJ26SchIQH9+vXDjRs3LN7X19cXP/30E9q0aWP7xvLg2bN0Z7fg0qTSnBN7dTpaTE9eSUsDihf3M1kzcqQGgwbR1XJzc/kyi5EjZTh61LUzoZRKHoMG6TBokA5yulCFU2RkAIMHy7Fli2VXkSlYkMOcORq89559X78NnAH9dn2M7Xe3CKovF1oBa1ttQrDc/EItYhvueEz/J245Bh/4TFBt2ZBy2NxmB/xlAXl6To4Dxo2TYsYMmUX7ff21Ft99pwPL5unpCbEKz2cdJ1JTGQD/HesiEaBQZB3P5XJA7NqnHcQKPA9kZgKJiQwSE1nExzO4eZPFtWsi/PuvCGlp1n9QFxzM4c8/NahZ0/WPG94kL8f1zbc2oN/ujwXVzm40Hx1LdbGoN3clOX4UgW2amazhWRYvjp2GsZh9PndzJffT7qHL1na4lXJT2A5PK0Dx9wmo04RNrC9cmMOKFWqUKsXloUvP5o7n78S2kpOBBQukWLJEgqQk277RiIjg0LSpAU2bGlCzphFSqU0fnliAxrp1wsJMfyZNCCFCbey1EbFLYwEADMvg28RvoQhW/Kduc7/NOP/neTAMA57nwTAM3v3yXdT5oQ58wnyy61Lvp2LvsL24svoKAGTXhlcIx4DzAxzzTRGborkEpnnzuUzgyXqQpJ/Pdbs2tCnSKq1yYEf2FXC6KaQpuc9b0kR0RHp5179KE7GORMLiwLd7cXHhBUH1foX80WZzZ/hF0nk7Ie7Cm4/phHgTGuuEeD4a54R4BxrrhHg+GufWoXkERJC/2ZzhBy/DGD56yzh7s9YeTD2/i6HlB8QlaTQa9O3bFxcvXsxxv0QiQWRkJKRSKR4+fAiVSpW97cGDB+jZsydWrlyJqKgom/eUmpqaawCDUqlEWFgYAgICkJ6ejvv378NofPUCkJGRgWHDhuH58+fo16+fzXsjhDievz9QrBiH27dznwgeGysCQCEMb8rIAMaMkWHxYgl43vXTq1QqBpMmybBmjQTjx2vQsKHrn+B5kmvXWPTpI8etW5Zd8bJFCz1++02DwED79PU6MSvG3A8Woeu2Djj66LDZ+svPL6LdppZY03ITwpRh9m+QuJ3Ntzbgq4ODBNUW8InEP83X5jmAAQBYFhgxQoeSJTl8/bUcOp2w1+jffpPhxg0WM2dq4ONjvp4Qa/A8cOsWi2PHRDh3ToRbt7IW2ycnM+A44ecTEgkPX18gOJhHcDCPkBAOISE8QkN5REbyKFyYQ8GCPAoW5KCki1TlGc8DyckMHj1i8Px51v9XSgqDFy+yvmZkMNBqAa0W0OmY/3/N+rteDxgMgF4P6PVM9t+zvjIwGl9ts4cyZYz46y81ihSh7FJP0qp4W/R/ehLzL84xW/v1wS8QHVgMVcKrOaAzJ+J5KCeMMVum6dzVKwIYLj2LxUfbOiBRlSCongGDCZ16oVonHh06cEhONr9Y/P59Fs2aKbFwoRoNGtD7S0Jel5jIYO5cCRYvliIz03bH+IgIDq1bG9C6tR6VK3MUIEcIIYQAKNa4GGKXxoJhGIAHbu+5jXKdy/2nrvb3tXFpxSUYdcbsIIZTM07h9OzTCCkRAkWwAqrnKiTdSALwKnzhpVrDajnseyKEOIbBP8ZkCIM4PdaB3difSPPQ5HZOXthBnRBH43keR346KDiAwSe/L1qt60ABDIQQQgghhBBCCCGEEEJcj09hAALnY1lS6wUYnudpNjlxOT///DNWrlyZfZtlWXz66afo1asXAgKyFpjpdDps3boVEyZMQGpqanZt2bJlsXbtWohEli3WNOfGjRto2bJl9u2SJUuidevWqFGjBsqUKQP2tZmbGRkZ2LRpE2bMmIGUlJQcjzN37lw0aNDApr1Zi65eYRolaBFzBg6UY906Sa7bCxfmcOZMpgM7cn0HD4owdKgcDx7Ybra7VMojf34eYWE8ZDIeYnHWQr7U1KzFfs+e2XZmfZs2ekycqEFQkE0flrzFunViDB0qh0ol/ORdLucxZowWPXro7R689qZ0XRrabmqBi88uCKov4l8UK1uuR3RAMfs2RtzqmL4rfgd67+wGA2cwW+svDcCWtrtQJqSszfs4fZrFxx8r8Py58NfQ8uWNWLZMjQIF6C0msZ379xmsXCnB6tUS3L/v2NVyoaEcihXjUKIEh+LFX30tXJiHjd9uur2kJAbXrrG4do3F9ess7t1j8egRg4cPWYuO466id28dRo3SQvHfC4ASF5DX47rOqEO7TS1w6ulJs7Xhygjs7nAQ+X0LWPQc7kS6dxcCunY0WcNLJEg+cQ5cYduHnrqS/ff3oO+uj5GpzxBUL2ElmNVoHtqW6AAAuHKFRceOws+fRCIe48Zp0bs3hTe+yZ3O34ltPHnCYPZsKZYtk0Ctts25Q0gIh1atDGjTxoD33jNS8IILorFuHbqCBSHEVnQZOkzONxlGbdbrb7HGxdBtR7e31h769RAOjjqYHa7w+hSTl8EMr99+qWSLkuiyqYs92icOQHMJTPPmcxn5g0Xwu/aVyZrndW+Bl+VzUEd2xBsRui8MDJ/772zSy/wOTcE+DmyKOALP8zg14TjOTvtXUL0iVIk2mzshqHiwnTsjhNiaNx/TCfEmNNYJ8Xw0zgnxDjTWCfF8NM6tQ/MICLEvCmEgLuf27dto2bIljMZXB8qpU6eiRYsWb62/efMmunbtirS0tOz7xo0bh/bt29u0r5chDPXr18fAgQNRsWJFs/s8efIE3bt3x8OHr5LxCxcujO3bt0MiyX3htqPQxAnT6OSNmDN/vgQjRshN1ly7lo5g+j07VCpg5EgZli6V5ulxGIZH1aocatUyoGJFDjExRuTPz5ucSJ+WBty8yeLiRRFOnBDh6FGRRYuK3yY8nMP06Ro0bEivC/ag1wOjRsmwYIFlPy9Fi3JYvFiNsmU5O3Vm3jPVM7Te2AS3Um4Kqg9VhGJ5s9WoHF7Vzp15N3c5pm+9vRkD9vSGnjO/EE/CSrCq5QbUjqxrt34ePmTQo4cCV64IX22eLx+Hv/5So0oV541D4hnu3WMwebIMa9eKwXGutYhfJuMRHZ0VyFC6dNafsmWNKFLEO8IZnj9ncO4cizNnRDh3ToS4ONbmoVfOUhAPMLXTUTSY9fbPH4hrsMVxPVGViA/X1sejDNNXMgSAmLBK2NhmO3wkPhY/j8szGhHUsBbEcVdNlql79UXGpGkOaso5Fl2ajx+PfgeOF3YO4yf1x5ImK1CnYL0c99++zaBjRyUePhT+utinjw6//KKFTGZRyx7NXc7fSd49fcrgt9+k+PtvCXS6vJ/zsSyPBg2M6NpVjw8/NECat4+hiJ3RWLcOTZ4ghNjSnu/24PHpxwAAhmXQeWNnyPzefmK67fNtODPnTI6QhdzwPI+oulH4aMtHuT4ecX00l8A0bz6XEaeeQdCphiZrUiqtgz70Awd1ZD+s5iFCjpgOwk6ttBa60MYO6og4yqmJx3FmqvkQVwCQBcnRZkNHhJQNs3NXhBB78OZjOiHehMY6IZ6Pxjkh3oHGOiGej8a5dWgeASH2RSEMxOUMGTIEO3bsyL7dunVrTJo0yeQ+a9aswYgRI7JvR0ZGYteuXTYNOnj+/Dnu37+PypUrW7RfXFwc2rVrB457NYn7zz//RK1atWzWm7Vo4oRpdPJGzPn3XxFatlSarFm5UuX1C/Vv3GDxySdyxMVZvyqxTh0DOnbU44MPjAgJydupC8cBZ8+y2LhRgk2bxEhMtH7RYO/eWYtl5KazOIgFkpIY9Osnx7FjYov2a9pUj5kzNfD3t1NjFkjIfIp2m1rgZsoNQfUKsQLzGy/Bh0Wa2rkz7+UOx/R1N1Zj0L4BMPLme2MZFvM++BOti7eze18ZGcCgQXJs3y78vFom4zFligadO+d+ZShCcqPVAlOmSPHHH1Lo9a4VvmCOXM6jZMmsUIYyZYwoU4ZDmTIcIiJ4CFif4LIePGBw+LAYx46JcOaMCPHxnhG48DoJdBiEWfgFP8MnRIakM5cBHw9ccO8hbHVcv/QsFi03fAiVQWW2tnFUEyxp+jfErGXnqK5OtnIF/L8caLKGl8mQfCoWXP4CDurKsYycESOPfY8Fl+YK3ifCJz/+ab4O74SWe+v2x48ZdOyowM2bwt8DV6pkxPz5akRF0Uf1gHucv5O8SU0FZs2SYv58KdTqvJ8oFS7M4aOP9OjSRY/ISBpH7oLGunVo8gQhxJkuLr+IvcP2Iv1J7r9jlvnJUP2r6qg7oi5Ysed9huBNaC6BaV59LmNUI/RAATAmfp+RWXwkVEW/cWBT9iF+cQJBZz40WZNc4xSMvqUd1BFxhNOTT+D05BOCaqX+MrRe3wFhFcLt3BUhxF68+phOiBehsU6I56NxToh3oLFOiOejcW4dmkdAiH1RCANxKampqahZsyYMhqwFWwzDYM+ePShUqJDJ/TiOw/vvv49Hjx5l3zd//nzUq1fPxF6O079/fxw6dCj7dp8+fTBs2DAndpSFJk6YRidvxByVCihWzBdGY+6TxYcP1+Lrr3UO7Mq1rFolxrBhcqhUlk+o9/Xl8fHHevTsqUPRovY5XdHrgV27pJg7V4xTp6wLiYiJMWLRIjUKF6ZTqry6dIlFr14KPHggfGImy/IYMUKLzz/Xu9QC1wRVAjpsaonrL64JqmcZFiNrjMbAmEGCriRGLOPqx/R/4pZjyIHPwUPY68j0Bn/gozLd7dzVKxwHTJwoxbRpll21rkcPHcaOpaAaItylSywGDcpbcJMrCgzkUbp0VihDVkBDVkhDQICzO3u7lBTg6FExDh8W4dAhMe7e9dwFEyyM6IYV+AU/oyjis+/P+GUc1AMHOa8xYpItj+tbbm9E3109BdV+/E5fTKr7m+ecq6nVCK5RGaLHj0yWqQZ8hszRExzUlGNl6NIxYE8f7Lm3S/A+JYNKYWWL9SjoZ/qzyqQkBh99pMCFC8KPaQEBWUFWrVoZXOq9jTO4+vk7sZ5GA/z5pwTTp8vw4kXeftClUh4tWhjQtasetWsbwXruKYvHorFuHZo8QQhxNs7AIf5QPO7suYO0B2lQPVdB4iOBb35fRNWJQvEmxSEPpA8EPQHNJTDN289lgk7UgDjjSq7btflaIy1mmQM7sg/Zk1Xwv/yJyZpnDZ8AIgp09RRnpp7EqYnHBdWKlRK0WtMeEdU8M7yUEG/h7cd0QrwFjXVCPB+Nc0K8A411QjwfjXPr0DwCQuzLsy7fRtzewYMHswMYAODdd981G8AAACzLol27dpg5c2b2ffv27XOZEIaqVavmCGF4/PixE7shhNiKUgmUKsXh6tXcF1VcuOCdM8CNRmDUKBnmzZNavG9AAI9PP9Whb18dAgNt39vrJBKgXTsj2rUz4sQJFmPGSHDsmGULP2NjRXj/fR/Mnq3GBx/QmzxrbdwoxuDBcouugBkWxmH+fA1q1XK9f/dwZTjWt96GDptbIi75qtl6jucw6viPuJB4FtMazIaPhCZreYsFF+fgx6PCw7nG1Z7k0AAGAGBZ4PvvdShZksOQIXJotcLG6bJlUly4IMLChWq7hekQz2A0Zl0JedIkKfR6z1t1mpLC4ORJMU6ezHl/iRJG1KtnRP36BtSsaYSvr3P60+mAU6dEOHRIhMOHxYiNZcFxnvf/8LogJKMfFuJzzEYU7v9nu2L2dKh79QUUCid0RxypZbE2+KbqcEw5Yz5k4K8ri1DIrzC+rPyVAzqzP8WCuWYDGDhfP6gGu/9VK9/mYfoDdN/eGVeTLgve592I6ljWbCWC5MFma0NCeKxfr0KfPgocPCjsI/jUVAaffKLAhg16TJyoRXg4nT8Rz2E0AmvWiDFxogyPHuXts7LQUA69eunRq5ce+fLROCGEEEIcjRWziG4UjehG0c5uhRDiRAa/GJMhDOL0WAd2Yz+s5qHJ7ZwkmAIYPMjZ3/8VHMAgkovQ/O82FMBACCGEEEIIIYQQQgghhHg471wZSlzW60EFAFC7dm3B+9asWTPH7QMHDtikJ1vw9/fPcTsjI8NJnRBCbK1iRdOLvy256qWnSEsDunVTWBzAIBLx6NdPh3//zcDQofYPYHhTjRoctm7VYvVqFcqWtWxRf0oKg27dlJg6VQqOs1ODHspoBMaOlaJ/f4VFAQzvvWfAvn0qlwxgeClMGYb1rbfhnZDygvfZeGs9mq1rhDupt+3YGXEFHM/h52M/WhTA8ON7P6NfhU/t2JVp7dsbsHGjCvnyCX+hu3RJhA8+8MH27ZT/R97u7l0GrVopMXaszCMDGEy5eVOEhQul6N5diZIlfdGqlQJTp0px6hQLvd5+z8vzwK1bDBYskKBbNwVKlvRFu3ZKTJ8uw/nzIo8NYIiI4NCxox4rlmXgYXRtTMKwtwYwAIAoMQHyv5c6uEPiLN9UG44W0a0F1Y45+TPW3Vht547sj0lOgnLGb2br1F8MAR8a6oCOHOt8wlk0WdfQogCG5tGtsKbVJkEBDC/5+gJ//61G7946i/rbvl2COnV8sGiRBDrLdiXEJR08KELDhkp8+aUiTwEMpUoZMW2aBufOZeK773QUwEAIIYQQQogTGfxjTG4XqePB6F84qBv7EakfmNxulBd2UCfE3s7NOIV/xx0TVMtKRWj6V2tE1jR/USFCCCGEEEIIIYQQQgghxKUc7QzcnAukXXd2J26DQhiIS4mLi8txu1KlSoL3LVeuHKTSVwt+ExMTkZycbLPe8iIhISHH7UBHrywmhNhNxYqmF6I+fcoiIcEzF7K9zcOHDJo1U2L/fssW21avbsChQyqMG6dFsPA1LTbHMED9+kbs3avC6NEa+PpaNqF/4kQZ+vaVg7J2hElNBXr0UGD6dJlF+336qQ7r16sREeH6Cy5CFCHY1GY7akfWFbxPXPJVNF5TH+tvrrFjZ8SZNAYNBuzugzmxMwXv81WVbzC4ylA7diVMlSocdu9WoUIF4QEoaWkMevVSYNQomV0XlhP3wvPA0qUSNGjgg9OnvS+06k0GA4OTJ7OuDt2ihQ9KlfJF9+4KzJsnQWwsm6dFuHo9cPEii0WLJBg4UI4qVXxQs6YvfvxRjj17xFCpPO9cNSyMQ82aBvTsqcPUqRqcPJmB2NhMzJ6twQcf8jB8NdjsYyhn/g5otfZvljgdy7CY2WguyoVWEFT/5f6BOPboiJ27si/ltClg01JN1hjDI6Dq/5mDOnKcrbc3o82mZkhUJZgv/r9+5QdgYeO/oBArLH4+sRiYMEGLsWM1YFnh719SUhh8/70ctWv7YONGMYyumz0HngfS07M+D7hyhUVsLIvLl1ncucPQe2Mvd+cOg5495ejUSYm4OOvP9ypXNmL5chUOH1ahWzc95HIbNkkIIYQQQgixit7f/FwecfpFB3RiXyLN20NcX+LkBR3UCbGn8zNP4+SYo4JqWQmLJn+2ROEGRezbFCGEEEIIIYQQQgghhBBiD/fXAGc+B7aVBTZEAse6AbcWAul0IdncMDzPu/7qNeIV9Ho9KlasCIPBkH3fiRMnEGzBatzmzZvj1q1b2beXL1+OatWq2bRPa/To0QOnTp3Kvj1o0CB88cUXTuwoy7Nn6c5uwaVJpTknB+t0LjzjnTjN+fMsPvzQx2TNihUqfPCB5//8XLvGonNnBZ48EZ7xpFTy+OknLXr31oN1UjSUqbH+9CmDr7+WY+9ey0IlSpc2YskSNaKj6TQrNzdvsujZU4Hbt4X/x/v48JgxQ4OWLQ3mi12M1qjF4P0Dsf7mWov2a1eiAybW/Q0BskD7NOYlXOmY/kKTjF47u+HEY2FX0wGA4e+OwNdVv7NjV5bLzAS+/FKOLVskFu1XpYoRs2fT66O3S0jIOr7u2WPZ8fWlwEAe1asbULYshyJFOAQF8QgIAPz9c4YJGAwc9HpArWag0WR9VamA1FQGyckMnj9/9fXxYxaPHjEwGl0zkEAq5VGmDIfixbO+56go7v/fMw+5nIdez8BgyPrenj1jkJDA4O5dFjdusLh1i4VG4xrfF8Nk/V8FBvIICuLh58dDocj6/mQyQCbjIZUCUikgkfCQSLIWMGd9fXU76z4+e5tUCoSG8ggL45AvHw9fXzONGAwIrlEZonvxJsvSx02Cpt+nNvv+iW3Y67j+JOMxmq5rhMeZj8zW+kn9saH1VlQIq2iT53YkNv4ugmtXA2Mm3SX9t5nQdP/YQV3ZH8dz+O3MJEw6PU7wPizDYkytCehXwTavA3v2iNC/vwKZmZa/JhcuzKF3bx26dtUjKMgm7ZhlMACJiQwePXp1nHz59ckTFsnJDNLSso49po6fSiWPiAgeJUpwKFXKiJIlOVSqlHVMY3LZzZXO34nlMjKAadOkmDdPCp3O+nOQ6tUN+PprHerVM+b6s0LcG41164SF+Tm7BUIIIV6C5hKY5vXnMoYMhB6IBIPcP+vPKDEG6iJfOrAp2ws6VgVi1c1ct6sKD0RmqYkO7IjY2oU/zuD4qMOCalkJiw8XtUTRJsXs3BUhxJG8/phOiJegsU6I56NxToh3oLFOiOejcW4dmkdALPI3m3UF45exAq9PzFJEAuENXv3xiXJOjy6GQhiIy7hz5w6aNm2afVsulyM2Ntaix+jbty+OHn2VTj569Gh06tTJZj1a4/79+2jcuDFeH2pr1qxBhQrCrrBoTzRxwjQ6eSNCaDRAdLQvDIbcZ4N/950W33yTh8sXu4FTp1h0765ESorwWfGVKhkxb54aRYo491TE3FjneWD5cgl++klm0ZWi/fx4TJumQatW7hcYYG+7d4swcKAC6enC/z2LFuWwdKkapUpxduzMvjiew5iTozDr/O8W7RfpWxAzGs5BnYL17NOYF3CVY/qV55fx8c6uuJ8WL3ifn2uMweeVXHOSIscBkydLMXWqzKL9lEoe48dr0KWLgRZTeaEtW8T49lsZkpMtT19q0kSPXr30qFfPCNFbLqac17FuMGQFMD18yOLePQZ37rC4eTMrxOD2bRZ6Pf3AChEVxaF06aywiIIFOURG8ihUKOtrUBD/1v87Z5Av/wt+X5sOR+TC8iHpVCzgYzp0jTiWPY/rV5OuoOWGD5GuSzNbGyIPwea2u1AiqKTNnt8R/Ht1g2z7FpM1hpKl8OLgiazEEw+Qoc/AF/s+xbY7mwXv4yPxxYLGi/F+1Ic27eXWLQZ9+yoQF2fdi6FYzKNGDSOaNjWgRg0jSpXirPpv4jj8P4SIwaNHbI6vDx9mfU1IsG84UVAQjypVjKhWzYiaNY2oXNkIyf/zvVzl/J1YhueBDRvEGDlShsRE65M269Y1YOhQHWrUoP93T0dj3To0eYIQQoij0FwC0+hcBgg6XhXizBu5btdEdEB6+T8d2JGN8RxC94eD4bS5lmSUmgB14c8c2BSxpdi5Z3Fs5CFBtayYRbMlrVC4cbSduyKEOBod0wnxDjTWCfF8NM4J8Q401gnxfDTOrUPzCIhFXoYwvPRmvMDr25RROUMZlJGO6dHFeMZMWuIRkpOTc9wODw+3+DHe3CcpKSlPPdnC1KlTcwQwFC9eHOXLl3diR6+8eXJCchKL6d+HmCeVAmXK8Lh0KfeFCZcuiTx6vB06xKJLFxnUauGLMz77TI9Ro/SQSq2flG8rQsZ6374c6tfX4OOPZbh8WVjP6ekM+vVToHdvPcaN00OhyGun7o/ngalTxRg7VgKeF/7z0qiREYsWaREYyABw57Ekwph6YxEVWBjDD34LIy/sQ4FHGQ/RfnNLdCvbA7/WGYMQRaid+/Q8rnBMX3d9Db7Y8xlUBpXgfSbVn4r+FV37Cuw//WREpUpafPaZFGlpwsa1SsVg8GAF9u0zYPp0ncOu5kycKzUVGDZMipUrLf8Yolw5Dr//rkPVqi+DeN4+pvM61qVSIDo66w/AAzD+/09WQMP9+wyuX2dx8yaDa9dYXLuW9dWSkCZPIhbzKFeOQ7VqHGJiOJQty6NkSQ6+vm+rZv7/x3Vw3buD+20S2IcPcq1hnyXCb8l8aL/6xoGdEXPseVyvmL8Clrf8Bx02tIGe05usTdIkodOW1tjRaS8K+xe2W0+2JDp8yGwAAwBoR42GVGlZyJKrik+9i65bOuPq8yuC9ynoVxArW61FuTDbf35Xtiywb58Ww4ZJsWyZ5cdEg4HBkSNiHDmSta9CwaNMGQ4FC/LIn59HcDAPmQyQSLKOXRkZDDIzgcxMBomJWWFDCQn2D1gQ4sULBnv3irF3b9b34ufHo04dIxo04PDBB0CxYjwFdrmRu3cZDB0qxf791r9GV6lixKhRetSpY/qcj3gOV3ivTgghhBBCrGfwizEZwiBOs+yiK66G1T41GcAAAEZ5Ecc0Q2wudv45wQEMjIhBsz9boniLEjTpmxBCCCGEEEIIIYQQQoj74/lXYQtvTtJ7PZQhMx64uyTrDwD4FssKY8j3/1AGheXrv90RhTAQl5GZmZnjtsKK1apKpTLHbZVK+CI3e9i+fTt27tyZ476vvvoKDM0gJsSjVKzI4dKl3Bfmx8Y6P2jAXg4dYtG5swwajbDXNR8fHnPn6tCypftNTihWjMeePRp8840UK1YIP4VavFiCU6dEWLlSi0KFePM7eKiMDODzz6XYtMmy08/Bg/UYOVLvMlfNtoVPYgagTEhZ9N7eA89UzwTvt+LqMuy4sx2j64xF17Ld6XzCTRg4A3499jNmnP1d8D4sw+L3RrPQs9zH9mvMhlq0MOKdd7KCai5eFH7M27xZjNOnWcyapUOjRpz5HYjb2ruXxeDBUjx6ZNk5Ecvy+PprA777Tg+p1E7NCSQWA9HRPKKjjWja9NX9HAfcu8fgyhUWcXEMrl5lcfUqi1u3nL+41dZ8fHjUqsWhVi0jqlXjULEihzfegrsXqRTar7+B4uvBpsum/w5t735AYKBj+iJOV69Qfcz6YA4G7OpntvZRxiO0Wd8COzvuQT4fF/8w2WiE4odhZssMNWrC0LSZAxqyv0P3D6DX9p54oUk2X/x/lcOr4J9WqxHuE2G3vpRKYOZMHerVM+Lbb6V48cL644VazeDcORHOnbNhg06Sns5g+3Yxtm/Puh0dzaNFCyNatOBQpQo86j2hJ9HrgZkzxZg0SSL4s6E3FS/O4aef9GjVykjBG4QQQoiLe3b1GW7tuoWE2ASonqvAilj4RPggrEwYSrUqhaBoSlslxJsY/CoCT9fkul2kugXGkA5e7J5X4GLV98zWGJVF7N8IsbmLC87h2IiDgmqzAxhalbRvU4QQQgghhBBCCCGEEEKII9ReAyQcABIPAqlXX90vJJQh/RaQcRu4vTDrtl+prDCG8AZAvvqA3DMvOMvwPO+9qwGJS9mxYweGDBmSfTsmJgarV6+26DEmT56MhQsXZt/u3r07fvrpJ1u1aJE7d+6gY8eOyMjIyL6vcePGmDlzplP6eZvUVOeGVLi6N6/EZTC436Jx4hiLFokxdKjplYE3bqiQL5+DGnKQQ4dYdOkig1otbIZ8wYIcVq7Uolw51zr1sGasL10qwjffSKHTCV8dkC8fj5Urtahc2fsWGsfHM+jWTYYrV4QvvpXLecyapUOHDp772vso/RE+3tYNZ56etnjfGgVqYnSdcaiav5odOvM8zjqmx6fGo//OPjj15F/B+yjFSixuvgwfFm1ix87sQ6MBhg+XYMkSicX7du1qwLhxOlrj7GFSUoARI6RYvtzy/MfoaA7z5ulQrZrw46Yrnb9rtcCNGwzi4rJCGeLiWFy5wuDhQ/cJ5xKJeFStyqFePQ716xtRtSrn9DAMm9Pp4Fe1Itj7pidUa74dDu2PzvlsgfyXo8b61FOTMfr4KEG15ULLY2uHHQiUu+6CI8mSP6Ec8oXZuoy9B2Gs6t7nmDzPY96FOfjx8HAYeeE/H61LtMWcxvOhlDguYSYxEfj2W8vD6rxNaCiPJk2MaNnSgIYNOUgsP90kdnD9OoP+/WVWh49GRHAYPlyP7t2NENMQ8EqudP7uTgIC3DkJjRDiCtIfpyPjaQZ4jocyTInAqECz+zyLe4YdX+xA/IF4k3VFGxVF05lNEVrKMyfXeJtnz9Kd3YJLk0pznsvodN53LiNJPozAsy1M1ryouguGoBoO6si2ZI//gf+VASZrnjV4DIh9HdQRsYXzs8/gxC+HBdUyIgZNF7VEyTalsu/zxrFOiKejYzoh3oHGOiGej8Y5Id6Bxjohno/GuXXCwtwzDJm4AM2zrDCGhIP/D2WIe7Utt6vpvBlH8HpdwDtAvv+HMoTXA6SuO6fWEhTCQFzGxo0bMWzYqyvyVa1aFStWrLDoMaZPn44//vgj+3aHDh0wduxYm/UoVEpKCjp37oz4+Pjs+yIiIrBx40YEBbnOiweFMJhGk0CJUGfPsmjUSG6yZvVqDRo39pzF95YGMLz7rhErVmgRFmbnxqxg7Vg/fZpFjx5SPH0qfLGBQsFj7lwdWrf2nteTQ4dY9O4tQ3Ky8MCKggU5LF+uRcWKnn+aqjVoMfzQt1h8aZFV+7cp0Q4ja41CdGAxG3fmWZxxTF99bSW+2f8V0nRpgvcJU4Zhdev1qBRe2Y6d2d/KlSJ8/bUUKpVll7END+cxdaoOLVp4z2ukJ9u1i8VXX0nx+LHli/L69tXj11/18PGxbD93OH9PTQUuXGBx8KAIBw6wiI1lwfOuc8nnkiWzAhcaNOBQq5YR/v7O7sj+JH8vh/Iz05OpeV9fpF+4DD7UBU9mvZCjxjrP8xi6fwj+vLTQfDGAqhHVsK7tJgTIAuzST56kpsKvSgWwz5+bLNN16gL1fOvOS12FxqDB0P1DsOLqMov2+7raNxhR82ewjHPCcjZvFuGnnyS4d899wnqcJTiYR9u2BnTsaMR773G5/q6H2A/PAwsXivHTTxJoNJb/B/j68vjqKz0GDjRASWvJvZo7nL+7IgphIIRYI/VBKo6OP4prG68hMyEzxzZZgAyl25ZGrW9rIbT0f8MTLq+8jE19NsGoNULI1BKRVIT2f7dHmXZlbNY/cQ4KYTCNJoICjD4FoQcLm6zJKDUB6sKfOagj21LeHg+fO+Nz3c5Jw5BU77YDOyJ5dWbavzg1/pigWoZl8P7cZninU9kc93vjWCfE09ExnRDvQGOdEM9H45wQ70BjnRDPR+PcOhTCQGxGk/gqkCHhIJB27dU2i0MZGCCwwv8DGRoA+eoCEvecmE4hDCTb2LFjsXTpUrs/z6BBg/DFF/+98t6OHTswZMiQ7NsxMTFYvXq1RY89efJkLFz4anJ8t27dMHLkSKt7tYZGo0Hv3r1x7ty57PuUSiX++usvVKhQwaG9mEMTJ0yjkzcilEYDREf7wmDIfeL5sGFaDB2qc2BX9nPypAidOysEBzA0bmzA/Plql51Yn5exnpDAoHdvBc6cEZkv/j+G4TF+vBZ9+ugF7+OOeB5YsECCn3+WwWgUviijRg0DFi7UICzMu05Rt9zeiKEHv0SKNsXifSWsBN3K9MQXlb9CIT/Tk928lSOP6S80yfjhyHdYd9Oy89jogGJY2WI9igQUtVNnjnXtGot+/eS4cUP46+NLrVvrMWaMFuHh3vU64ClSUoCffpJj1SrLL1EdHs5h+nQNGja0boy64/l7UhKDo0dFOHRIhMOHxbh/37GLbwMDedSta0D9+kbUr29AwYJeOO6MRgTVqw7xjesmy1SfDkLmr+Mc1BQxxZFj3cgZMXBvX2y8tV5QfZXwaljVYj38XSyIwefnH6GcM9NkDa9UIvn4WXAFIh3Ule3dS4tH3109cfHZBcH7SFkpptSfji6lu9mvMYG0WmDJEgmmTZMiOZnCGIQoXJhD+/Z6dO2qR1SUFx7DnCAhgcHgwXLs3y+2av8uXfT48Uc61ydZ3PH83RXQ5AlCiKUu/HUBO77YAX2mPtcQBYZhIJKK0HRmU1Tu9yog9sa2G1jVZhU4I5ddZ8rLxxdJROi8sTNKNC1ho++COAPNJTCNzmWyBB+tAJE6PtftmvwfIb3cPMc1ZEN+lz+F/MnfuW7XB1RFyrv7HdgRsRbP8zg96QTOTD0pqJ5hGTSa3QQl25ehsU6IF6BxToh3oLFOiOejcU6Id6CxTojno3FuHZpHQOxGnfAqkCHxIJD22lzrt/3u+G2/j86uY4GgSq+FMtQBxBZesdFJaDYncRnKN1bnarVaix/jzX3efEx7MxgMGDJkSI4ABolEgpkzZ7pcAAMhxHbkcqBUKc5kTWysZxxyr1xh0b278ACGzp31WLzYdQMY8io8nMeGDSr07Ck8YIPnGQwfLsdvv0nfen7pCdRq4Isv5BgxQm5RAEPv3jqsXav2ugAGAGhZrA0OdT6JegUbWLyvntNjyZVFeG9FRQzZ/znupNyyQ4fEHJ7nsf7mGtT6p5rFAQx1CzbA9vZ7PSaAAQBKl+awe7cKvXtbHkC0aZMENWv6YP58CQwGOzRH7GbXLhHq1PGxKoChVSs9Dh3KtDqAwV2FhPBo3dqA337T4syZTJw6lYGpUzVo00aPfPlMn19aI18+Ds2a6TFypAbbt2ciLi4DCxdq0L273jsDGABAJELmsB/NlikWLwD78IEDGiKuRMSKMKvRfDQq/IGg+rMJp9F5azukaVPt3Jlwops3oFg412ydatAQtw5g2HdvNz5YU9eiAIZwZQQ2ttnuEgEMACCTAQMG6HHqVCZ+/FGLAgVsfxzwNPfvs5g2TYZ33/VB584KbNkiht6z8w6dautWMerVU1oVwFClihE7d2ZixgwNBTAQQgghDhS7LBab+2yGLkMHnufBMMxb//A8D4PWgK0DtuL6lqyJM+pkNTb33QzOyGXXAVmfg77556WXdUa9EVv6bYE23fLf9xNC3IvBr6LJ7eL0WMc0YgesiXAJADDKoxzTCMkTnudxcuxRywIYZmUFMBBCCCGEEEIIIYQQQgghXk0RDkR1Bt6dA7SIA9o+AWr+DRTvD/iVyApdePkHyApceP0P8FqNEUg+A1ybAhxqDqwNBnbXct73ZgHrLldEiB34+ORMLlGr1RY/hkqlynHbkSEMPM9j2LBhOHDgQPZ9IpEIU6ZMQe3atR3WByHEOWJijLhyJferfV+8aPmVwF3N/fsMunRRIC1N2KL6Tz7RYcwY7VvDrTyJTAZMmaJF7dpGDB0qR3q6sG94wgQZUlIY/PKLZ/0bPXrEoFcvBWJjhf/MSyQ8Jk7Uont3714tk9+3AFa13IBFl+Zh9ImfoTFqLNrfwBnw97VlWHl9BZpHt8In5T/Fe/lrmL06Gcm7+2n3MOzw19h3f4/F+35ecTB+rP4zxKznvTVTKoGJE7Vo1MiAIUPkeP5ceCBRejqDESPkWLFCgokTtahe3bsW5rubFy+AH3+UY+1ay8MX/P15TJigQfv2Bo86HlqrSBEeRYro0aNH1jHx6VMGFy6wuHhRhPh4FvHxLO7dY5CczOQadKRQ8AgLy/pTrBiHEiU4FCvGISbGiIIFefp3fgtd81bQl4+B5FLuk8IZrRY+40cjffZ8B3ZGXIFUJMWiD5ehy9Z2OPnkuNn6l0EMq1qsh78swAEdmsDz8B3+DRgzq9KNkQWh+uxLBzVlW0bOiClnJuC3M5PAQ/jC7sr5qmBJ078R4ZPfjt1Zx98fGDxYh88/12HHDjGWLJHg2DEROM65L+B+fjwiIzkUKJD1NTycR1AQD39/HoGBPAICgIAAHjIZD6ORwYsXQEICi6dPGdy4weL6dRZXr4oEf6ZgCZ5ncOCAGAcOiBEWxuGjj/To1k2PokVpsb8tpKUBP/wgx+rVlp/rhYZy+PlnLTp2NID1jHxSQgghxG2k3k/FtoHbssMX3vT6/a8HLOz4YgdKNi+Jf2f8i8zEzBzbJEoJoupEIbhEMGT+MmhSNUi6loT7x+7DoDHkeJ6Mpxk4MvYI3p/wvgO+W0KIs+j9YyBL3JjrdlHGNcCoAkTul9gvUt8zud2o9JxgbU/F8zyOjzyE2HnnzBcDAAM0nPEhSnagAAZCCCGEEEIIIYQQQggh5D8U4UCRLll/AED9FEg4ACQeBBIOAuk3X9W+HsTw0uuBDbweSBIWoOxsDM976jWYiaWOHTuG2Fj7p9BXq1YN1apV+8/9d+7cQdOmTbNvy+Vyi/vp27cvjh49mn37119/RefOna1v1gI///wzVq5cmX2bYRiMGTMGHTp0cMjzW+PZs3Rnt+DSpNKcC4h1Olr8R3L3558SDB8uN1lz5UoGwsLc87D7/DmDli2VuH1b2Ix5dwpgsOVYj49n0L+/AhcuCA8g+OgjPaZO1UDsAeuvjx8XoV8/yxZah4VxWLxYjXffpau8vi4+9S6GHxmK/ff35ulxyoVWQL/yA9CmeHsoJe43wc1W7HVMz9ClY+b5aZgbOxtqg2UBYkqxEr83mI02JdrbpBdXl5jIYPBgOfbts+7FrkMHPUaM0KJAAfc8jnoqngfWrxfjp59kFr32v1SnjgEzZmgQGWmb/1dvOn/neUClygos0ekAqRQQiwG5nIePz38/syLmSffuQkDXjmbrXuw9DEOFivZviOTKWWM9TZuKdptb4uKzC4Lqq4RXc3oQg2zjOvj37222Lm3uImjbmf/5dzXJmiQM3NMPBx7ss2i/zqW6YnK93yEXm34P70qSkhjs2SPCzp1inDwpQnKybVezK5U8ChR4GbCQ9feXX1+GLvj55f15OA64eZPFmTMinD7N4vhxMeLj7bMyn2F4NG5sxCef6FCnjpGOjVY6dkyEL76Q4+FDy/+fevTQYcQILYKC7NAY8QjedP5uS2FhNnhBJoR4hXUfrcPlVZdzBCPwPA+RRISQkiGQ+cugeq5C8q3k7ECGl187re+EbQO3ITMhM/u+mt/WRJ0f6kDmL/vPc2lSNDj06yGc/P1kjtAGnzAffP34a7AiSmNyRzSXwDQ6l8kieb4Xgefbmax58e4+GAL+O0fIpXFahO7LB8ZE4GN6mZnQFPzYgU0RS/AcjyM/7MflP4XNO2NYBg1+b4zSXd7JcT+NdUI8H41zQrwDjXVCPB+Nc0K8A411QjwfjXPr0DwC4jJUj18FMiQeBNJv5dz++iQ+ns+6/ZHrj3MKYSAuQ6/Xo2LFijAYDNn3nThxAsHBwYIfo1mzZrh9+3b27eXLl7818MHWJk2ahEWLFuW47/vvv0evXr3s/tx5QRMnTKOTN2KJs2dZNG3qY7Lmn39UaNTI/X6OMjKAdu2UgoMF+vXTYexY9whgAGw/1tVq4Isv5Ni8WfgVIlu10uOPPzSQSvP01E7D81lBJD/9JIPBIPw/vlIlIxYvVtOi6lzwPI8ttzfix6PDkKB6mqfH8pX4oU3xduhcuhvejXjvrVc+82S2HucGzoAVcUsx8dRYPFc/s3j/YoHFsaDxXygXWj5PfbgbngeWLJHg119lyMy0/GdQoeAxYIAOgwbp4O9vhwaJReLjGQwbJseBA5YHa/j48Pj5Zy169tTb9IrIdP5O8oTnEdjyQ0hOmU5V1dWqg9T1WynpwomcOdafq5+j9YYmuJlyQ1B9pXyV8U+LdQiWh9i5s/9iMtIRVLMqRE+fmKzTV3sPKVt3u93P9PmEs+i7qyceZjwQvI+IEeGXmmPxSYWBbn0+zPPAgwcMYmNFiItj8fQpgydPWCQkMFCrGej1gFabFc6jVGaF8/j48PDz4xERkfUnPJxHRASH8PCsgIXAQOf9CMTHMzh0SIyDB0U4ckSMtDTbN1KmjBH9++vRrp0eCoXNH94jaTTA+PEyzJ0rAc9b9n9SsqQRU6ZoUb06nYsR0+j83To0eYIQIoT6hRpT808Fp88KP+Z5HmK5GA1+bYAqA6pA5vcqSCEjIQNHxx/FvzP+zT5PLly7MO4dyboCPMMwaDK9Cd4d9K7Z5z35+0ns+npXjkCHj7Z8hBLNStjhuyT2RnMJTKNzmSyM7hlCDxUzWZNeeio0hT5xUEe2Icq8ieDjVUzWpFTZAn1wPQd1RCzBczwOfrMHccsvC6pnRAzen90UJdqV/s82GuuEeD4a54R4BxrrhHg+GueEeAca64R4Phrn1qF5BMRlqR69CmS4twowZr7aRiEMhFinSZMmuHv3bvbtZcuW4d13zU/oAACdTocqVapAp9Nl33f8+HGEhNh3ovvs2bMxY8aMHPd98cUXGDRokF2f1xZo4oRpdPJGLKFWA9HRvjAac5+YPny4Fl9/rct1uysyGoGePRXYs0fYAsu+fXUYN859AhgA+4x1jgMmTJDi99//e0Wo3DRubMDChWrI3edirACyFmZ8950cK1cKD50AgE6d9JgyReN2368zpGlTMfnMBPx5aT70nD7Pj1c0IBqdS3VFm+LtEB1Y3AYduj5bjXO9UY91N1dj+rmpuJ1yy/wOb9GjbC/8Wms8fCSmg3s82YMHDIYOlePgQcsX7wNASAiHoUN16NlT77bhNe5MrwfmzpViyhQp1GrLD/h16xrw228aFC5s+48i6Pyd5JXk5HEEtmpiti512SroPmzqgI7I2zh7rD/JeIy2m5rjTupt88UASgWVxuqWG5Hft4CdO8vJ5+cfoZwz02QNzzBI2XUAhoqVHdRV3vE8j4WX5uKX4z9Bxwl/fx0kC8KCD/9C3YL17dccyTODATh1SoRduyTYtk2E+/dte8XkkBAOPXvq0bu3HhER9GuR3Fy6xGLQIDni4oSFcb5uwAAdfvxRS+/1iSDOPqa7K5o8QQgR4tyic9jyyZZXYQgsg67buqL4h7l/Hnx86nHs+XZPdhDDyxCFwrULo9ehXoKf+8/af+LB8aywNIZhUPv72mg4pmGevh/iHDSXwDQ6l3kl+HAZiLSPct2uKdAN6e/McWBHeSd5vheB59uZrEmqfRGcoohjGiKCcQYO+wfvwo01cYLqWTGLD+Y1Q7GWJd+6ncY6IZ6Pxjkh3oHGOiGej8Y5Id6Bxjohno/GuXVoHgFxSWnXgYQDr0IYtP+/+OnL8AU3CmGw7SxGQvKoTJkyOW6fP39e8L6XL1/OEcAQFhZm9wCGJUuW/CeAoU+fPm4RwEAIsS2FAihVijNZExvrfofdUaNkggMYunVzvwAGe2FZ4IcfdJg6VQOGEbawY/duMbp1UyAz03ytq4iPZ9CypdKiAAaRiMfo0RrMnEkBDEL5ywIwutZ4HO96Fu1KdMjz491NvYMJp8ag+t+VUW9lDUw+PR5xSVdB2Wy50xg0WHx5Iar/XQlf7h9oVQBDkCwIi5uswNT6M7w6gAEAChXisWqVGtOnqxEQYPnPXVISix9+kKN2bR+sWiWGwWCHJslbnTvH4oMPlBg9WmZxAIOvL4+pUzVYs0ZtlwAGQmxBX70mtM1amq3z+WVEViIJ8Ur5fQtgQ+ttiA4wfZXHl66/uIaWGz4UHNpgC6K4q1DM/8NsnaZHb7cKYEjWJKHnji748egwiwIYyofGYFeHgxTA4AbEYqBmTSPGj9cjNlaDo0fVGD5chxIlbPOLlqQkFtOmyVClig+++EKOuDj3+5zGnvR64LffpGjSRGlxAEP+/BzWrFFh9GgKYCCEEEJcwePTj7P/zjAMyn9U3mQAAwDUHFoTETER//mcuMqnpq8E/6aqA6tmPy8APDn3xKL9CSHux+BfyeR2cepZB3ViOyJ1vMntPCMCJyvomGaIYAaNAbv6bBEewCBh8eGiFrkGMBBCCCGEEEIIIYQQQgghRKC0m8Ct+cCxrsCGAsC2ssCZz4EHawBN4qs6N1x0SLMMiUupX79+jtvHjh0TvO/x48dz3G7Y0L5X1FizZg0mTJiQ477OnTtj2LBhdn1eQojriokxHcJw8aLlVxB0piVLJJg3T9glxps00WPyZApgeFOPHnosWKCBRCJssemRI2J07qxAWpqdG7OBrVvFeP99H8TGCv+5Dg7msGqVGgMG6OlnxQpR/kUw94M/sbvDQdSJrGeTx4xLvoLJp8ej3qrqqPlPFYw4Ogz77++B2qC2yeO7uzuptzHq+AhUXFoaww5/jQfp9616nAaFGuFg5xNoHm1+Ya+3YBjgo48MOHIkE82aWbeQOT6exRdfKFCrFoUx2NuLF8Dw4TI0barE1auWn880aGDA4cOZ6NGDXv+J68v8aRR4sekQMvGtm5Av/8tBHRFXZGkQw/30e2i5/kNcfn7Jzp0B4Hn4Dh8Kxmh60ToXEoLMH0favx8bOfH4GBqsqoVd8Tss2q9r6R7Y2m43igQUtVNnxF4YBihXjsfw4QYcParC3r2Z+PRTHcLDTX/2IoRez2DVKgnq1fNB164KHD8ugrdn0sXGZoVtTZggg15v2QlbmzZ6HDyYiXr1XD+VnBBCCPEWCbEJAJAdqFCpr+kF0i/F9Ir5z31FG1p2Lh3dKDr77zzPI/lWskX7E0LcjyHAdMCjKPM6GEO6g7qxDZH6nsntnLwQwAq7kAFxDF2GDtu6bcDdncKCUEUyEZoubY2iTU2HFBFCCCGEEEIIIYQQQggh5C3SbwO3FwHHuwMbCgLbSgOnBwL3VwHqpwDPI3tS3ssFBC/v43lAHgYUbOe8/i1AIQzEpdSrVw/i1xY7nDp1Cg8ePDC7H8/zWL9+fY77GjVqZPP+Xtq2bRtGjhyZ40ogLVu2xKhRo+z2nIQQ11ehgunJ5o8esXj+3D1WHh48KML338sE1VavbsC8eRqYWavmtVq1MmDZMjWUSmErOk6dEqN9eyWSXXReok4HjBghQ58+CqSlCf95LlfOiN27VahblxZl5FXFfJWxrvUWbGm7G40Kf2Czx72dcgvzL85Bl63tUWpRFDpvaYs5F2bhfMJZGDjvWd2eoUvH2hur0HFza1RfUQl/XJiBZI11AzJUEYo57y/Eyhbrkd+3gI079QwRETyWLNHg779VKFLEugV1d+9mhTHUru2DlSvFdHF6GzIagWXLJKhZ0wd//ikFz1t2HuPnx+P339VYuVKNggW9fGUjcRvGYiWg7t3PbJ3P5HFgUlPs3xBxWZYGMTxTJ6LNxmY4+eSEXfuSr1gK6QnzoaaZP/0KPijYrr3YgpEzYsrpCWi7qTmeZD42v8P/yUQyTKs/C783nA2FWGHHDokjMAxQoQKHX3/V4sKFTKxZo0KbNnrBgYem7N0rRps2SjRposSWLWKYyS/xOGo18OuvUnz4oeVhW/7+PP74Q4158zQICrJTg4QQQgixStqjNDD/n8jCsAwKVhd2tfZCNQvluK0IVsA33Nei5/aN8IUi+NU5uDZVa9H+hBD3o/evYnI7Ax7itAuOacZGROp4k9uNiijHNEIE0bxQY3OHtXh0xPz8MgAQK8RotrwNohpRaCchhBBCCCGEEEIIIYQQIkjGXeD2YuB4T2BjYWBrSeBUf+DeP4D68X9DF94MXpCHA1GdgWp/AM2vAO0SgDprnPf9WIBCGIhLCQwMzBGewPM8Zs6caXa/tWvX4tGjR9m3IyMjUaNGDbv0eODAAQwbNgwc92qR2Pvvv48JEyaAZWlIEeLNYmLMz9S/eNH1Xydu3GDRr58CRqP5hZZlyhixbJkaClrTYlLDhkasWaNCQICwBSKxsSK0batEQoJrhXbcv8+gVSsl5s+XWrRfu3Z6bN2qQuHCtADXlt7LXx3/tFiHPR0OoXl0K7CM7V5fNEYNDjzYh5+P/4AP1zVA8YWF0H5zK0w+PR6HHx5Ehj7DZs/lClK1Kdh0az167+yOsouL4bO9n+DQwwN5eswupbvh6Een0b5kp+wJzyR3779vxOHDmRg2TAu53LrXijt3WHz5pQLVqvngjz8kSHevC2u5nLNnWTRtqsTQoXIkJVn++vL++wYcOZKJrl0NoCFA3I3q62Hg/ANM1rDPn0M5aZyDOiKuytIghjRdKjpuboUNN9fapR824Sl8Ro0wW6ev+i40XbrZpQdbepLxGO03t8Sk0+PA8cLDmgr7RWFr293oVranHbsjziISAfXqGTF/vgaxsZn4+WcNoqOtC/N63fnzIvTtq0CNGj5YvFgCtdoGzbq4w4dFqF/fB7NmycBxlp2w1aljwKFDmejQgc71CCGEEFekTXsVfOCb3xdiubAU7eDiOYPa5EFyq54/RwhDGoUwEOLpDP6VzNaI0846oBPbYc2GMBRxSB/EvMyEDGxssxqJ554KqhcrJWj+d1sUqkdBGoQQQgghhBBCCCGEEEJIrjLvAXf+Ak70AjYVAbYUB071A+6tAFQPzYcuKCKBIt2Ad+cDLa4DbR8Dtf4BSnwKBJRx1ndlFYbneVoNR1zKrVu30LJlyxwhB1OnTkWLFi1yrf/oo4+QlpaWfd+YMWPQsWNHk8/z8OHDHIEPALBv3z4ULJj7lUD+/fdffPLJJ9BqX00WqV27NubMmQOp1LIFqa7g2TNamWaKVJrz6m86nZddCo9YTK0GoqN9TYYXfP+9Fl99pXNgV5ZJSwMaN/bBnTvmF1tGRnLYsUOFiAj3PpVw5Fi/fJlFp04KPH8ubDFrdDSHdetUiIx07r8xzwOrVonxww9yZGQIX13BsjxGjtRi4EA9LcpwgHtp8Vh8eSFWxC1FqjbFrs/FgEHxwBIoH1YB5UMr/v9rBQTJXfNqym+O83S1ChefXcChBwdw4ME+nEs4AyNvm7EfE1YJv9YahxoFatnk8bzRvXsMfvpJhp07JXl6HD8/Hj176tG/vw7587v3scqREhMZjBsnxd9/W/f+JjSUw5gxWrRt6/gFeXT+TmxJMXsGfH8xvZidZ1m82HcUxnfKOagrArjmWH+a+QSdtrTBteQ4wft8/+5PGFLlG5uGNfn36QHZ1k0ma3iWxYs9h2EsX8Fmz2sPW25vwreHBiNZk2zRfu8XbozZ78932fNSIoyl45zngePHRfjrLwm2bhXDYMj7uAoJ4dC3rx69e+sREuJZ55JPnjAYOVKGTZssP9+Wy3mMGKFFv356UB4xyStXPKa7g7AwP2e3QAhxA7+KfwX4rAse5HsnHwZeGihoP87AYbR0NBiGAc/ziKgYgQHnBlj8/PMqzUPCxQTwPA+GYTDSONLixyDOR3MJTKNzmZyCjlWGWHUr1+3afG2QFrPUgR3lAc8j5EAkWGPugeQZxX+GuuhQBzZF3ibtXio2d1iLtHupguolvlK0+Kct8r8XKfg5aKwT4vlonBPiHWisE+L5aJwT4h1orBPi+WicW4fmERCbyHwAJB4EEg4ACQcB1b1X216PIHh9zuvr9/tEAfnqZf0Jrwf4Rtu7Y4cRdskDQhyoePHi6NixI1atWpV937fffovbt2+jV69eCAjIuhqlXq/Hli1bMGHChBwBDKVKlULbtm1t3teNGzcwcODAHAEMYWFh6Nq1K86cOWPRY8lkMlSpUsXWLRJCnEyhAEqW5BAXJ8q1JjbWdWeocxzw+ecKQQEMPj48li9Xu30Ag6OVK8dh40Y1OnRQ4OlT8//Od+6waNVKibVrVSha1Dn/1klJDL75RoZt2yxbnBEUxGP+fDXq1aM3vo4S5V8Eo2qOwbfVvsfaG6uw4upfuPDsvF2eiwePmyk3cDPlBta/diXn/D4FUDywBIoFFkfxwBIoHlQCxQJLoKBvIYjY3F8b7Ulj0OBayi1cS47D+YRzOPPkNGITL0DH2TYQJ9K3IH6s/jPalegIlnHd13p3EBXFY+lSDY4d0+OXX2S4cMG6n530dAazZ0sxd64EzZoZ0Lu3HrVqGSkUJheZmcDcuVLMmiVFZqZ1/0jduukwcqQWQUE2bo4QJ1D37Q/F4gUQ3b+Xaw3DcfD94VukbtwOenHxbhE++bGpzQ503dYBZxOEfUY0/tRo3E27gyn1pkMqynuwp3TbFrMBDACg7vOJSwcwpGlT8f2Rb7HmxkqL9mMZFt9UHY6vq35H52JeiGGAWrWMqFXLiMePGSxeLMHSpVK8eGH9a3NSEotJk2SYOVOK3r31GDRIh9BQ9/4MRKcDFiyQYPJkGVQqy/9tKlQwYvZsDUqV4swXE0IIIcSpeI7PDnxjJcLPj1kxnUsTQqxjCKhiMoRBnHbWgd3kDaN7ZjKAAQCMymIO6obkJvnac2zptA6ZTzMF1cuC5GjxT1uEV85v584IIYQQQgghhBBCCCGEEDegepQVtpD4/9CFzLuvtr0ZuvByjjTPv9rmWywrbOFl8IJPYUd17nAMz/PuPXOQeCS1Wo3u3bvj8uXLOe6XSCQoWLAgpFIpHjx4AJVKlWN7UFAQ/vnnHxQtWtTsczx8+BCNGjXKcd++fftQsGDBt9avX78e33//vYXfydtFRkZi//79NnmsvKCrV5hGCVrEGl9+KcfKlbkvVi9YkMO5c8ImAjja5MlSTJ4sM1vHsjyWLVPjgw88Y0w4Y6zfvcugQwclHjwQNqExPJzD2rVqhy902LFDjG+/lSEx0bKJl++8Y8SSJWpERdFpprPFJV3Fqut/Y831lXimTnRaHyJGhHBlBPL7FkCkb8H/f41EsDwEQbIgBMiCECgLRIA8EIGyQEhZqdmrQhs5I9J0qUjRpiBVm4IXmhd4rn6GRxkP8TD9IR5lPMCd1Nu4lxYPjrff2AmRh2BgxS/xSYVPoRAr7PY83orjgM2bxRgzRob79/M+CbxkSSN699ajY0c9/P1t0KAHMBiAlSslmDhRioQE6/6Nixc3YupULWrUcO65AZ2/E1uTbVwH//69zdalzV0EbbuODuiIAK491jP0Gei1oxsOPzwgeJ/akXXx54fLECi3PsGGSU1BUO13IUp4arLOGJEfL46eAu8fYPVz2dORh4fw5f6BeJTx0KL9InzyY877C1Erso6dOiOOZotxrlIBa9dKsGCBBNev5z0QzseHR//+OgwcqENgYJ4fzqFenlOPHSvDvXuWn++xLI8hQ3T4+msdpHnPjCEkmysf010ZXcGCECLEL+wvYBgGPM8jomIEBpwb4JB9X5pXaR4SLiaA57PCIEYaR1r8GMT5aC6BaXQuk5P8/lz4Xf/OZM3zurfAy/I5qCPriV+cQNCZD03WJFc/CqOf64ZceronJx9he4+N0KZqzRcDUIb7oOXq9ggpE2rxc9FYJ8Tz0TgnxDvQWCfE89E4J8Q70FgnxPPROLcOzSMgFvm3P5B4EMi4/eq+N0MX3na/f8lXgQv56gPKAvbu1GWInd0AIW+jUCiwaNEiDB48GCdPnsy+X6/X4+7du2/dJzIyEnPmzBEUwEAIIfYSE2M0GcLw8CGLpCQGISGutTh9926RoAAGAPjlF63HBDA4S9GiPDZvVqF9eyXu3DG/ACIhgUWbNgqsXq1G+fL2D2J49IjBDz/IsGNH7j/LuenRQ4cxY7RQ0Fp0l1AmpCxG1RyDH9/7Gfsf7MWGm2uxO34nMvSOnTxp5I14nPkIjzMf4WzCabP1DBhIRVJIWCmkIgnErARGzgA9Z4CBM8DA6aHjdA7oPHf5fQrg84pfonvZXlBKlE7txZOxLNCmjQFNmxqwZIkE06dL8fy59WEMN26I8P33IoweLUO7dnp06mTAe+8ZvfIC9hwHbN8uxsSJUqsXJkqlPL78UofBg3WQCTuNIMStaFu3g27JIkiPHzVZ5zNqBHSNm4D3pQ+yvZ2vxBcrmq/Gp3v6YtudzYL2OfroMBqvrY8lTf9G2ZB3rHpen19/NhvAAAAZE39zyQAGtUGNcSd/wbyLf1i87wdRH2JGw7kIUYTYoTPizpRKoGdPPXr00OPQIRHmzpVi/37rfx2Smclg2jQZFi2SYuBAHfr318HPDV72jx4V4ddfZbhwwbrzvVKljPj9dw2qVHFsKCQhhBBCCCHEvRj8K5utkaSdhS6sqQO6yRuR+o7ZGqMi2gGdkLe5vfUm9g7cDqNW2HwF/8IBaLm2PQKKBNq3MUIIIYQQQgghhBBCCCHEHdxemBW08GbwwsvbL78GlH0tdKEeoAh3fK8uIu+XEiXETgIDA7F48WKMHj0aUVFRJus+/fRTbNmyBaVKlXJgh4QQ8l8VKpj/ZX9srGsdfu/cYfDZZ8JWzH/8sQ79++vt3JF3iIzksWmTCmXKCJsgkpTEol07Jc6etd/Pj8EAzJ8vQe3aPhYHMCiVPP74Q42pUymAwRVJRBJ8WKQp5n6wCFd738byZqvQpXQ3BMoCnd3aW/HgoTVqkaFPR7ImGYmqBCRpkpCmS4XKkOnUAIYywWUxtf4MnOoei/4xn1EAg4PIZMCAAXqcPp2JUaM0CA3N2yIwlYrB8uVStGqlRPXqPpg6VYoHD7wjiYHjgC1bxGjQQIk+fRRWBzDUqWPA/v0qfPcdBTAQD8YwyBg3GbzI9DgRPX0C5dRJDmqKuDqZSIYFjZegW5megveJT7uLZusaYcPNtRY/n+T4USiWLTZbp2nVFrqmzS1+fHs79eRfvL+6jsUBDBJWgl9rjcPyZqspgIGYxDBA/fpGrFypxsGDmejUSQ+x2PpgzLQ0BhMnylC1qi9mzpQiM9OGzdoIzwP794vQqpUC7doprQpgEIt5DB2qxd69KgpgIIQQQgghhJhl8KsAnjEdfCdOPeugbvJGpLptcrtRGg6IfR3UDXnd5T8vYFffLYIDGIJKhaDt1s4UwEAIIYQQQgghhBBCCCGEvIlhkONKloHlgZKDgDprgXaJQPPLQLXZQFQnrw5gAACG53nXuhQ3Ibm4fv06rl69imfPnsFoNCIwMBAlSpRATEwMJBLLr9RNgGfPHHsVbHcjleacoKzTCftFLvFuKhUQHe0Ljst9IecPP2gxZIhzr+D+UkYG0LSpUtACzBo1DFi7Vg1Pe8l19lhPTgY6d1YiNlbYoggfHx4rVqhRs6bt+uR5YPfurCvD37hh+eKMMmWMWLhQgxIlaGGGu9Eb9Tj55DgOPNiH/ff34mrSZWe35JKkrBQti7X5H3v3HSdVdf5x/Dt1e4fdpSNFOiogCCgg2LAiYkNB7AXrj8RYEo2xYESNEisWLInGRqxBVEQU6UVABKRJWWAX2F6n3d8fxI0D7Ozs7rSd+bxfL17mnDnn3AfCw71775nnalLvazQwd5BMptj4sn4kq6iQXn/dpmeesWv//sAVpxk61KVx41waPdqpzMyALRsR3G7p00+tevJJu9avb1zhBUlq08ajv/ylRmef7VKkpUK4z+mIXkl//IMSZzzvc4xhtaroq+/k7tkrRFHFruaS64Zh6PHlj2rasqkNmnf9MZN13wl/kc3ixw9elZXKGDlU1q2+vxzgSUtX4YJlMnIi50Z4ubNcjyx+QK+snSFDDbs93TH1KM04baaOza7/LZtonoKd53l5Js2YYdcbb9hUUdG0C5oWLTy67TaHrrjCqfj4AAXYSE6n9PnnVk2fbvf7HsORHHusW3/7W7V69eJnfARXczmnR5qWLVPCHQKAZuAB8wMymUwyDEO5x+bq+pXXh2Tur1487kXlr8mXYRgymUy6z31fg9dA+LGXwDeuZQ6Xvni4bGWr6vzckXWKSvrNCmFEjZOyZpLi8+uO05E+RCXHfx7CiGAYhpZM/V4rn1rq95zs43J09ttjFZ/ZtLcHkOtA9CPPgdhArgPRjzwHYgO5DkQ/8rxx2EeABnnL/L/iC4Yhma1Sh0uldhdI2cMke3pYw4tEFGEAYhgbJ3zj4g2NNXx4os8vN551llMzZ1aHMKIjMwzpmmvi9ckn9X+5p3Vrj774olLZ2dF32RAJuV5aKo0fn6ClS32/IeZX8fGGXnutSiNHNi1Ww5C+/96ixx+3a+FC/459qMsvd+ihh2qUmNikUBAh9lbs0Tc7v9Y3O+dq8e5F2l2RF+6Qwmpg7gka02WsxnQdpxYJLcIdDo6gokJ6+22bXnjBrh07AleMwWIxdOKJbp1zjktnnulSixbN9/xXVia99ZZNL73UtD8ju93Q5MkO3XqrQ0lJAQwwgCLhnI7oZCopVubg/jLv3+dznLP/ABV/+qVkafwXX1G/5pbr7238l26fN1lOj9PvOf1zjtcLp76iDqkdfY5Luuf3Snz5xXrXK3vqWVWPn+D38YPt6x1f6nff3K5d5TsbPHds13GaNvwppdhTgxAZIkWo8rykRHr9dbtmzLCpoKBp15KtWnl0++0OXXKJUwlN+35Hg+3aZdI//2nTP/9p0969jf99JCYa+v3va3T99U5ZG3eLAGiQ5nZOjxRsngDgD4owIBDYS+Ab1zKHS15/hxJ2vVLn5x5bhg4M/0URV933EOmLT5KtbHWdn1e1vlzlvZ4LYUSxze10a/6Ur7ThX+v8ntPmxHYa/cZ5sifbm3x8ch2IfuQ5EBvIdSD6kedAbCDXgehHnjcO+wjQIL8twnAYk5TeR8oeLmWPOFiUIS7K3mzZCBRhAGIYGyd84+INjXXLLfF65526Cxu0aePRqlUVIYzoyP7+d7sefDCu3nF2u6GPP65Uv37R+QbESMn1igrpiisS9O23/n3TwWo19Oc/1+jaa50N3qvkcklz5lj1zDN2rVjRuC8Jtmjh0RNP1Gj0aFej5iPyGYahXeU7tXj3Qi3Zs1hL9izUxqIN4Q4rqMwms/plD9DZnc/TeZ3PV5uUtuEOCX5yuaRPPrHq2WftWrMmsF9+NpsNDR3q1ujRLo0a5dJRRzWPH6HXrTPrrbdsevttm8rLm7ap9dRTXXrwwWp16hTZv/dIOacjOsX9659KvfXGeseVTX1c1VdfF4KIYldzzPVFu7/XpNnjVVRT5PecFHuqpg3/m8Z2vfCIn9u+/Ubp486tdx3HScNV8v7HEfEFh/yKvfrzwj/qg03vNnhuqj1Njw57XBd0vUimCPi9ILhCnec1NdIHH1j13HN2/fxz064l09IMXXKJUxMmOHX00cG7j7J3r0mffWbVhx9atWRJ0ysmnHeeUw88UKPWrSP7eg/RpTme0yMBmycA+IMiDAgE9hL4xrXM4eLy/qHUn27yOebA0B/kSewUoogawTCUNa+tzO66//6Xd7lfVUdNCWFQsaumpFpzrv5Uu77d4fecjqd30mkvnS1rfGCqC5LrQPQjz4HYQK4D0Y88B2IDuQ5EP/K8cdhHgAZ56zcv+fl1L+ahJQZq92iapLReB4sy5Iw4+N+4rFBEGVEowgDEMDZO+MbFGxrr5ZdtuueeeJ9jfvihPKwb27/5xqJLLkmQx1P/l1f+9rdqXXaZ/29tbW4iKderq6VrrknQF1/4vynktNNc+stf6v9irGFImzaZ9f77Vr39tk35+Y1/O+Zpp7n05JPVys7mMjLWFFUXau3+NVqzb7V+3L9aa/at1pbizTLUfP8utEtprxHtRmpEu5E6qc1wpcdnhDskNIFhSN9/b9GLL9r1xRcWGUbgv6TZubNHp5zi0siRLg0a5FZiYsAP0Wj795v0739b9a9/2bR2bdOLUfTs6dZ999Vo5MjmcR0cSed0RCGPR+lnnSrbimW+hyWnqGjBUnlatwlRYLGnueb6luJNGv/ZhdpWsrVB8y7uNl6PnPSYUuyptX2m0hJlDB8sS94un3ONhAQVfrNInqPC++UGp9upV358UY8tnapyZ8PvRZ3UdoSmn/wcBbJiSLjy3OORvvzSoqeeimt0wcLf6tHDrTPPdOm001zq08cjaxO+/1FUJK1cadHChRbNnWvVTz8FpvBY584eTZ1arREjmse/pYguzfWcHm5sngDgj98WUrAn29V6QGu/5/7yzS+Nnvur3ct2y1nppAhDM8deAt+4ljmcpXy9MhcN8jmmtM+rqskdF6KIGs5UU6AW33bxOaak7+ty5JwfoohiV8m2Yn12+Ycq3lTo95wel/XW8GmnyGxt/HPwQ5HrQPQjz4HYQK4D0Y88B2IDuQ5EP/K8cdhHgAYpXiflz5MKvpEKvpVq9v/vs9++IOu3ZQd+25/a07soQ3zLYEccdhRhAGIYGyd84+INjbVihVmjRyf5HDNjRpXGjHGFKCJvO3aYdOqpSSoqqv+LqRMnOvT44zUhiCp8Ii3XnU7pxhvj9fHHNr/n2GyGzjzTpXPPdalPH7cyMw25XFJ+vlnr15u1bJlFX35p1Y4dTdtwkpZm6P77a3TZZc5IeJEuIkS5s1zr9v+oTUUbtbl4k7YUb9Lm4k36pWSb3EZknTvT4tLVq0Vv9cseoP45x6t/zgDlJrUKd1gIkh07THrzTZv++U+b9u8P3Ia737LZDB13nFuDBx/8NXCgW8nJQTlUnbZuNWnOHKvmzLFqyRKL3O6m/wPdurVHd91VowsvdMkSmO/3hUSkndMRfaxrflD6aSNk8vh+s3nN6LNV+vpbIYoq9jTnXD9QdUDXfTFJ3+XNb9C81kltNG3433RqxzMkSSm33qj4f/2z3nnl9z+kqsm3NirWQFmYt0B3f/c7rS/8qcFz4y3xum/wX3RVn+tkNgXnXI7IFO48Nwzp668tmjo1TmvWBOZiKDHRUP/+bvXs6VGnTh517OhRZqah1FRDiYmSy3XwfkBpqUn79plUUGDStm1m/fyzWRs3WrRlS2BzICvLoylTHJo40Sm7PaBLA34Ld643V2yeAOCP3xZhMDXwZv5vt480dO6R1qIIQ/PFXgLfuJY5AsOtFvPayuSuqHNIZfvJqug2NYRBNYy1eLEylp3mc0zhCQvkTukboohi057FeZo96SNVF1b7PWfAlBN0/J2Dm3zuOhS5DkQ/8hyIDeQ6EP3IcyA2kOtA9CPPG4d9BGiS4rVS/je/Kcpw4H+f+VWUofvBYgzZIw7+NyEnyAGHHkUYgBjGxgnfuHhDYzkcUpcuyaqurvsB/7XXOvTww6EvblBZKZ19dqJ+/LH+LxH07+/Whx9WKi4uBIGFUSTmussl3XFHvN55x/9CDME2dqxTDzxQo5wcLh3hH6fbqe2lv2hH2XbtLs/T7vI87anYXfu/CyrzVeIokcfw/UXWhmqR0EJtktupTXJbtU1pqw6pHdU7u5e6ZXVXTmKuTCZTROQ5QqemRvr0U6tmzrRp6dImvH7YD2azoa5dPerTx6M+fdzq08ej3r3dSk8PzPoul7Rli1mrVpm1eLFFixZZtW1b4L6Ql5Ji6NZbHbruOocSEgK2bMhE4jkd0SfpvnuU+MIz9Y4rmflPOc46JwQRxZ7mnusuj0sPL35Az/7wdIPnXtD1Ij3mOEWdrryu3rHO/gNU/MkXkjW45766bC3ZoqmLH9RHW2Y1av4xLY/Tc6e8pK4ZRwc4MjQHkZLnhiHNnm3VX/9q1/r1zagylQ8JCYZuuMGhm292KIXnrwizSMn15obNEwD88dsiDOHy2yIQFGFonthL4BvXMkeWtvxM2YsW1Pm5M32wio+fE8KIGiZu9z+Vuu5Gn2P2n5wnw8o1WbBsfPcnzfu/L+XxM6dMZpOG/XWUel0RnMIY5DoQ/chzIDaQ60D0I8+B2ECuA9GPPG8c9hEgoIrWHCzIkP+NtO9bqabwf5/5U5Qh5ej/FWXIGS4lNP+XplKEAYhhbJzwjYs3NMV55yVo0aK6v+zSp49bc+dWhjCig9c3N90Urw8+qP+L/S1bejR3bqVyc6P/MiFSc93jke66K06vvRbeV1J26ODRY49V6+STI+PPBdHFY3hU7ihTUU2RSmqKVVRdpDJHmZwehxxuhxz//a/L45TVbJXVbJPNbJPVbJXNbFOqPVVpcelKj8tQenyG0uxpslkO/zcuUvMcobd+vVnvvGPT++9bVVAQujdqZ2Z61LGjoY4dPWrb1qOsLKP2V1LSweINVqtksUhVVSaVlh58C3JJiUl5eSbt3GnWtm1mbdxoVk1NYN/iJEmpqYauu+5g8YVAFYwIB3IdIVFerszhJ8iyc4fPYe6cXBV9t0RGekaIAosd0ZLrH2/+t279+iZVuup+O+SRtKgy6ZEvDV21SrLU8eOakZCgoq8XyN25awAibZiCygI9ufyveuOnmXJ5XA2eH2eJ05QBf9DkY2874nUdYkOk5bnHI338sVWPPWbX5s3NsxhDfLyhyy936pZbHGrVKvrv9aB5iLRcby7YPAHAH78WYQg3ijA0b+wl8I1rmSNL+vmPStw+vc7PDXOC9p+cJ5nDUzSyPomb/6KkbY/X+bnbnqPC4ZtCGFHsMDyGlj62UCueXOL3HEu8Rae9eJaOGt0laHGR60D0I8+B2ECuA9GPPAdiA7kORD/yvHEifR/Bjh07tGbNGu3du1dOp1Opqanq1KmT+vXrp7gwvDXY6XRq27Zt2rx5s/bv36+KigolJiYqPT1d3bp109FHHy2zOXTfM4h4RasPFmQo+EYq+FZyFP3vM3+KMiR3OViUIWfEwf8mtglywIFHEQYghrFxwjcu3tAUDz1k1/Tpvi8G160rV8uWoTsNv/iiTX/6U3y946xWQ7NmVemEE2Lj73wk57phSA88EKfnngt9IYaUFEO33ebQtdc2z7ehA78VyXmO8HC5pG++seidd2z6/HNrUAobNAfp6Yauv/7gv/WpqeGOpunIdYSKfe4XSrt0XL3jqi+6VGXPvBiCiGJLNOX6hsL1uurzy7W5uOGb94/dIz31uTR8++GflT3ymKqvuSEAEfpvf9V+zVj9nF5a+4IqnOWNWmNg7gn628nPqGvG0QGODs1NpOa5yyV98IFVjz8ep+3bm8eDtuRkQ1dd5dD11ztDeg8K8Eek5nqki/TNEwAiwwPmB8IdQi2KMDRf7CXwjWuZI7Pn/1tpa67wOabwhO/lTukToogaJmXNJMXnz6rzc2f6YBUfPyeEEcUGR1mN5t78ubbN3uL3nLiMeJ355hi1Gtg6iJGR60AsIM+B2ECuA9GPPAdiA7kORD/yvHEidR/BV199peeee07r1q074ueJiYkaO3asJk+erMzMzKDGsnPnTs2ZM0cLFy7UihUrVF1dXefYlJQUnXvuuZo4caI6duzYoOPMmjVLd999d6PjHDhwoN58881Gzw86w5CKf1uU4buGF2VI6iTlDJeyRxwsypDULshBNx1FGIAYxsYJ37h4Q1N8+aVFl12W6HPMs89W6cILG/5m0MZYsMCiCy9MkNtd/5dMp06t1tVXO0MQVWSI9Fw3DOm552x68ME4eTzB/5Kw3W5o0iSn7rjDoawsLhMRHSI9zxFexcXSxx/b9PHHVn3/vcWvc2Vzl5vr0dVXO3XVVQ6lROZ9t0Yh1xFKKTdcpfhZ79c7ruSNf8lxxpkhiCh2RFuuVzgr9KcFd+kf619v1PzTNksPfCOdsOtg23HScJW895EUokrMu8vz9PwPf9ebP72mSldlo9ZIsiXrT4Mf0KReV8tsah5fbEdwRXqeO53Sv/5l05NP2pWXF5l/Zzt29GjCBKcmTHAoPT3c0QBHFum5HqkidfMEgMhSvL043CF4Se+QHu4Q0AjsJfCNa5kjM1ftUNaC3j7HlPWYruq2k0ITUAOlLz5RtrI1dX5e1fpylfd6LoQRRb+iTYWaPeljFW8q9HtOaoc0nfXW+croGtxNuRK5DsQC8hyIDeQ6EP3IcyA2kOtA9CPPGyfS9hE4HA7dc889+uSTT/wan5mZqenTp+v4448PSiyXX365Vq9e3eC5NptNd9xxh6666iqZTP59vyDqizAcyjCkoh8OFmTI/0Yq+FZylvzv83qLMpikS0PzvcqmoAgDEMPYOOEbF29oivJyqVu3ZDmddV9ojR3r1Asv1F09K1B27TLp1FMTdeBA/V8MuPhip6ZPr5af14dRobnk+oIFFl13Xbz27w/OFzwSEw1dcYVTN97oUG4ul4eILs0lzxF+Bw6YNHu2VR9/bNV330VfQYZ+/dy6/nqHzj7bJZst3NEEHrmOUDIVFCjzxAEyFxf7HOfOzlHRt4tlZGaFJrAYEK25/smWD/V/39yqkpriRs0/bbN02+pEHf/aEqldh8AGdwjDMLQif5lm/viyPto8Sw6Po9FrndHxTD1y0jS1TYn8asYIneaS5zU1B4sxzJxp008/WeqfEGRxcYZOPdWlCROcGj7cHapaLECjNZdcjzSRtnkCABC92EvgG9cydTAMZc3vLLNzf51DIraQgeFRi69byeSpqnNIeZf7VXXUlBAGFd22/mez5t78uZzl/t9bajWojc547VwlZCUEMbL/IdeB6EeeA7GBXAeiH3kOxAZyHYh+5HnjRNI+Ao/Ho5tvvllz58716rdYLGrVqpVSUlK0a9culZV5P4dKSEjQzJkzddxxxwU0noqKCvXr1++In8XFxally5bKyMhQVVWVtm/fLqfz8Bcajx8/Xvfff79fx4u5IgyHMgypaNV/CzJ8IxV8d+SiDL+WNDCZpEsjP88pwgDEMDZO+MbFG5rqggsS9N131jo/T0sztG5duez24MVQVSWde26iVq+u/8sAxxzj1scfVyohNPsVIkZzyvWCApP+8pc4vftu4L4527GjR5dddvDtmJnBf1kIEBbNKc8ROQoLpTlzrPryS6u++caq8vLmWZAhJcXQmDFOjR/vVP/+nnCHE1TkOkIt/q03lXL75HrHVY+9UGUvvBKCiGJDNOf6rrKdumXuDfp+93eNXqNLeldd0esqjek6TjmJOQGMTtpbsUcfbZ6ldzf+S2v3N7wy9G8dldZJj5z4mEZ1OC1A0SGaNLc8Nwxp+XKz3njDrv/8x6qystBdN8bHGzrxRLfGjHFq9GiXUiLnmSpQr+aW65EikjZPAACiG3sJfONapm6pqy5S3P7P6/zcldhVRUNXhDAi/5irtitrQR+fY0qOeUuO7LNDFFH08rg9WvbYIq3425IGzTv6wh46+clTZYmrew9GoJHrQPQjz4HYQK4D0Y88B2IDuQ5EP/K8cSJpH8GMGTP0xBNPePVdcskluummm5STc3A/o8fj0dy5c/XII49o9+7dteNyc3P16aefKiWAG6AOLcLQtm1bnX/++RoyZIj69Okj22/ealhdXa05c+bo6aefVl5entc6f/rTn3T55ZfXe7xDizBcffXVOvHEE/2ONzU1Vb179/Z7fMQzPAeLMux4X/r5Wcld8ZvPDIowAIh8bJzwjYs3NNWzz9r0wAPxPse89ValTjklOH+3DEO66aZ4ffBB/V/Yz8ry6MsvK9W2bexdFjTHXF+1yqxHH43TvHmN22CSnm7olFNcGj/eqSFDeDsmol9zzHNEFodDWrbMoq++smruXIs2bAj/m459sVgMnXSSW5de6tQZZ7hipsASuY6QMwylXTRG9vnz6h1a8uo/5Dj73BAEFf2iPdc9hkdv/vSaHlj4J5U7G3/fxmwy66Q2w3XGUWdqeNuR6pzeRSZTw74Y7jE8WnfgR83bMVdf7/hSi3Z/L0NN+5kxwZqgO/r/Xjcee4viLHFNWgvRqznneU2N9N13Fn36qVXz5lm1Z09gf+A2mw317OnR4MFujRrl0uDB7pi51kP0ac65Hk6RtHkCABDd2EvgG9cydUvY9oSSNz/gc8z+4dtk2LNCFJF/bPu/VPqqC3yOKRyyXO6ko0MUUXSq2Fuur26arbwFOxs0b+DdQ9X/9oENvr/VVOQ6EP3IcyA2kOtA9CPPgdhArgPRjzxvnEjZR1BUVKRRo0apouJ/X7SfMmWKrrvuuiOOz8/P16WXXupV8GDy5Mm69dZbAxbTr0UY+vXrp8mTJ2vo0KH13mcuKSnR1VdfrbVr19b2paam6ssvv1R6errPuYcWYZg6darGjh3bpN9Ds+QolgrmS/nzpPxvpJIfpV/3nv5afIEiDACaAzZO+MbFG5pq40azTjopyeeYiy5y6plnqoNy/Mcft+uxx+r/UovFYui996p04omx+Xe8Oef6jh0mvfuuTV9/bdWPP5pVXX3kHwaSkw317u3WoEFujRrl1oABbllD94IQIOyac54jMu3bZ9LixRYtWmTRwoUWrV9vlmGEduPfoVJSDI0a5dLpp7s0apRL9dzjiUrkOsLBnLdLGcNOkLms1Oc4T4sWKpy3SMZ/K/mi8WIl13eX5+kP71+mOZUrA7Jeq6TW6tvyGPXM6qVOaV3UMjFbLRJayGa2y2N45PQ4lF+Zrz3lu7WtZKt+3L9Ga/avVklNcUCOL0ljuozVfYMfVNuUdgFbE9EpWvLcMKRdu0xassSiFSss2rLFrK1bzdq501TvtaPZbKhFC0OdOnnUtatHnTt71LevR8ce61Zycoh+A0CQRUuuh1qkbJ4AAEQ/9hL4xrVM3WyFC5S+4kyfY0qOfUeOlqNDFJF/ErY/q+Sf767zc8Nk1f6R+ZK5/hcg4Mh2fL1Nc2/+XFX7q/yeY4m3aNQzo9Xl3PAUvyDXgehHngOxgVwHoh95DsQGch2IfuR540TKPoJp06bp5Zdfrm0ff/zxevPNN30WPVi0aJEmTZpU205KStLcuXOVkZERkJgcDocWLlyoESNGNGhefn6+zjjjDFVWVtb2Pfjgg7rooot8zovZIgyOEqng24NFFwq+kYrXyKvowqGaWREGvn4HAECQdOvmUbdubm3cWPfbsj/91KqpU6WUAF/zfvCB1a8CDJL05z/XxGwBhuaufXtDv/udQ7/7nUNOp7R1q1mFhSb9ep2flWWoZUtDrVoZMgf25ZsAENNatjR0zjkunXOOS5JUVCT98INFa9datHatWWvXWrR1a3D/4U1JMTRggFuDB7t1wglu9evnlt0e1EMCOAJPm7aqeHCqUm6f7HOcef9+pd52o0reel9cmMEfbcvN+uyvv+iDXOl3p0k705q23p6K3dpTsVtzfpkdmAAb4KQ2w/WnwQ/o2Ox+IT82EE4mk9SunaF27VwaN85V2+9wSMXFJpWWSqWlJjkcJlmthqxWKS5OatHCUGamIUvdt5MAAAAAIGI50/rJMFlkMup+/mwrXhpxRRgsFZt8fu5OOIoCDI3kdrq1dOr3WvXM8gbNS8pN0hmvnaucfq2CFBkAAAAAAAAAIBA8Ho9mzZrl1XfzzTf7LMAgSYMHD9aAAQO0fPnB+8cVFRWaPXu2xo8fH5C47HZ7gwswSFJOTo7GjBmjt956q7ZvwYIF9RZhiBnOsoNFFwq+OVh4oWi1JM/Bz+oqutCMUYQBAIAgOvdcl6ZNq3vXfGWlSf/+t00TJzoDdszFiy267bZ4v8ZecIFT110XuGMjfGy2g4U/AAChl5EhnXyyWyef/L9NpWVl0saNZv3yy/9+7dxp0oEDJhUWHvzl8dR9Q8FkMpSSImVkGGrf3qO2bQ/+t2dPj3r1cqtdO6O5348Aokb1pZfL/ulHivvqC5/j7F9/pYRXXlTVtTeGKDI0W263UiZfJ8uBQl10QDr7Z2naEOmvJ0pVzWivf58Wx+jeE+7Xye1G1fswBYgldruUnW0oO1uqrfgNAAAAANHCkihXSl/ZSlfVOcRasiSEAfnHUrHR5+fupG4hiiS6lGwt0leTZyt/xd4GzWt1Qhud/vLZSsxOClJkAAAAAAAAAIBAWblypQoLC2vb7dq106BBg/yaO27cuNoiDJI0d+7cgBVhaIoBAwZ4FWHYvXt3GKMJM2e5tO87Kf+bg0UXin+Qfi3G7W/Rhd+OS+shZZ8s5ZwcjGgDjiIMAAAE0ZgxLk2bFudzzMsv23T55c6AvBB3zRqzLrssQQ5H/V9w6d3brSeeqOYLnAAABEFKijRggEcDBhy5QI7bLZWUSE6nSW635HId/BUfL6WkGEpKUkCuDQCEgMmk8iemyzbsBJlLin0OTfrLfXIMHSZ3z16hiQ3NUuK0R2T/bv7/2k7p/vnS1aukh0+SXuknOeuu9Rd2x+cO0h39f6dR7U+j+AIAAAAAADHImTbQZxEGW8kKyeOUzJFTbdJa+bPPz91JR4cokuhgeAyte221Fv7lW7kqXQ2a2+eaYzXkgeGy2CL4BhgAAAAAAAAAoNb8+fO92kOGDPF77+CQIUO82kuWLFFlZaUSExMDFl9jpKamerXLysrCFEkYuCqlgu+kgm8OFl0oWtm0ogspXQ8WXMg5WcoeISXkBCPqoKEIAwAAQdS1q0fHH+/WsmV1bxDYsMGiL7+06PTT3XWO8cfPP5t18cUJKiur/0I1K8ujmTOrFOZrUgAAYpbFImVmSrz9GIgOnlatVf7wX5V68/U+x5lqapR649Uq+nyelJAQoujQnNjnfqGkJ6cd8bO2pdLzn0l/+F566GSr3jhWchoN28QeTCPajdTt/X6nwa2HUnwBAAAAAIAY5kofJO18sc7PTZ4qWct/lCv1uBBGVTeTs1Bmxz6fY1xJXUMUTfNXllemebfN0a5vdzRoniXeohGPn6puF/UMUmQAAAAAAAAAgGBYv369V7tfv35+z83JyVGbNm2Ul5cnSXI6ndq8ebP69u0b0BgbKj8/36udkZERpkhCwFUl7Vvwv6ILhSukX/emNqboQvJR/y248N/CC4mtgxJ2qFCEAQCAIJswwaFly3x/werRR+N0yimVsjTyZQ5bt5o0blyCDhyo/5XZcXGGXn+9Sh068KVPAAAAIFBqLrxENXNmK+6TD32Os67/SUkP3qeKR478RXvELvPOHUq56dp6x3Uslp48+e+6/ZxRem3dK3p93SvaX7U/+AEeQao9TZd2v0xX9LpaXTL4MgIAAAAAAJCcaYPqHWMtXhIxRRgsFZvqHeNOOjoEkTRvhmFo47vrteDeeXKU1jRobmqHNJ3+ytlq2bd5vf0KAAAAAAAAACBt3brVq925c+cGze/SpUttEYZf1wt3EYYVK1Z4tTt27Nioddxut3bu3KnCwkKZTCalp6erZcuWSk5ODkCUjeSulvZ9L+V/IxXMkw4slwzn/z4/tPBCfUUXEtsdLLbw66+k9kEJO1wowgAAQJCde65L999vqKio7jeBrltn0Vtv2TRhgrPOMXXPNeuiixK0b1/9BRgk6emnqzVwoKfBxwEAAADgg8mkssefknXFMll25/kcmvjyi3KOPEWOU04PUXCIeDU1Sr1mosxFRfUOrR47TjUXj1eOyaQ/DLxXt/WbotnbPtUHP7+rr3d+JZfHFdRQbWabRrU/Ved3HafTO56pRFtiUI8HAAAAAAg905E2U6HWoX88/Hl5MxLayR3XWpaa3XWOsZcsVY3pxhBGVTdr5c/1jvEkdeP/Zx9Kd5Ro0QPfavfCXbLaLbK28P9+0VFndtGQPw+TPSUuiBE2DrkORD/yHIgN5DoQ/chzIDaQ60D0I8+bp+rqau3e7f08oFWrVg1aIzc316u9bdu2JsfVFOXl5fr888+9+oYNG9bgdV588UU99NBDqqio8Oo3m806+uijNWTIEF1++eVq06ZNk+JtkC+HSYXLJI/jf30NLbqQ0Mq76EJyp+DEGiEowgAAQJAlJkpXX+3Q44/73jTw5z/H6eSTXWrb1vA57rfmzbPouusSVFLi3w8Xd95Zo7Fjg/uFHAAAACBWGRmZKnt2htLGni3ToTclD5Fy640qmrtAnlatQxQdIlny/ffItmplvePcHTqq/LG/ed3kjrfG6/yu43R+13E6UHVAn239WN/s/Frf5c1XSU1xQOLLTszRiHYjNbztyTq1w+lKj88IyLoAAAAAgMjUokUY376D6JA9RNr5fp0fx5UuVVyk/D3b+YvvzxNaKatVCDdANkMtWiSr00eXhjsMAAAAAAAAAECIFRUVyfjNflmbzaasrKwGrZGTk+PVPnDgQEBia6znnntOlZWVte2MjAydfPLJDV7nl19+OWK/x+PRhg0btGHDBr3xxhsaN26c7r77bsXHxzc2ZP/tW3B4X31FF+KzpewR/yu6kHp00MKLRBRhAAAgBK65xqHnnrOrsrLuYgllZSZdeWWC/v3vSiXXs9/E7ZaeecauqVPt8nj8K8Bw+eUOTZniqH8gAAAAgEZzDj1JVbfcocTpT/ocZ96/X6nXXaniWZ9KNluIokMkipv1nhJefanecUZcnEpffVNGalqdY7ISsjSx15Wa2OtKuT1urd63Sqv3/aCfDqzTuv1r9UvpVh2oOiBDRy4SYjfblZvUSu1S2qt3y77q06Kv+rY8Vt0yulNZHAAAAAAA+K+l7yIMqtwhVe6SEtuGLqa6lKz3/Xlq99DEAQAAAAAAAABAM/PbYgWSFB8f3+C9homJiT7XDKWVK1fqtdde8+q78cYblZCQEJTjuVwu/etf/9LKlSv1yiuvKDs7OyjH8VJf0YW4LCl7+P+KLqT1DH5MEYwiDAAAhEBmpnTzzQ499licz3GrV1s0fnyCXnutSpmZRx6zdq1Zd94ZrxUrLH4ff8wYp6ZNqznidRIAAACAwKq48x7Z5s+TbfUqn+NsSxYpaeqDqrjvLyGKDJHG8uNapfzfLX6NLX/0Cbn6HOP/2maL+uUMUL+cAV79bo9bhdWFKqoulCFDFpNFZrNZafZ0ZcZnUmwBAAAAAAA0XYsh9Y/Zt1DqcFHwY6lPyY++P6cIAwAAAAAAAAAAR1RRUeHVjovz/b25Izl0TriKMBw4cED/93//J7fbXdvXp08fXX755Q1ap0ePHhoxYoSOO+44denSRRkZGbLZbCopKdHPP/+s7777Tu+9957Kyspq5/z888+64YYb9I9//OOwohRB8duiC/Z0KXuYlP3fogsZfYN//GaEIgwAAITIjTc69MYbNu3da/Y5bvFiq4YPT9KUKQ6NHu1SVpahwkKTliyx6N13bZozp2Gn71NPdenZZ6tl8b9mAwAAAICmsNtV9sLLyhh1kkz13AxOfOYpOQeeIMcZZ4YoOEQKU+EBpU0aX+/fEUmqvuQyVY+fEJDjWswWtUxsqZaJLQOyHgAAAAAAwGEyjpPMcZKnpu4x+74LfxEGZ5lU8YvvMamx/YYnAAAAAAAAAADq4nA4vNo2m63Ba9jtdq92dXV1k2JqDIfDocmTJ2vPnj21fUlJSXriiSdk8fMLeT179tSsWbPUq1evI37eokULtWjRQkOGDNENN9yge+65R1999VXt5+vWrdP06dN11113Ne03Ux9rstTypIMFF3JOPvhMh5d31YkiDAAAhEhSkvTYY9WaOLH+ilT5+WbdeWe87ryzacccNsyll1+uUiOuYQEAAAA0gbtzV5U//JhS7ri53rEpt9ygornfydO+QwgiQ0RwuZR67SRZdmyvf2iPXip79AlucgMAAAAAQmb//vJwhxDR7HbvovsOhydMkUS2tNR+shUvqvNz1+55Kg7z3zVr8VKl1zOm2NRFrhjOCcMw9MsXW7V82iKV55XVP+EIuow5WoPuHip7anyAowsuch2IfuQ5EBvIdSD6kedAbCDXgehHnjdOixbJYT3+oQUUnE5ng9c4tJBDXFxck2JqKI/Ho9/97ndatWpVbZ/FYtHjjz+uDh3839fbvXt3v8empaXp73//u2677TZ98cUXtf1vvfWWrrzySuXk5Pi9VoOctljK7C+ZedOzvyjCAABACJ1xhlsXX+zUO+8EvyrCWWc59cIL1QrxtScAAACA/6oeP0G2775R/Kz3fY4zlxQr9ZqJKv7kC3EBHxuSHviT7N/Nr3ecJzlFpa++ISXWX8wPAAAAAIBAMQwj3CFEtEP/ePjzOjJHxlCfRRis5eukmv0y7FkhjMqbpWxdvWNcyT1i9v/j/BV7tPCBb7VncV6j5ie0SNTwx09RpzO7SGp+uUKuA9GPPAdiA7kORD/yHIgN5DoQ/cjz5ikpKcmrXVNT0+A1Dp2TGOL9kn/+8581Z86c2rbJZNKDDz6okSNHBvW4ZrNZDz30kBYvXqzS0lJJB/8sZs+erUmTJgXnoC0GBmfdKGaufwgAAAikv/61Wr17u4N6jAkTHHrpJQowAAAAAGFlMqn88afl6tK13qG2H1Yp+b67QxAUwi3u3beV+OKzfo0te/pZuTvX//cHAAAAAAAg0jgzhtY7xla8OASR1M1a7rsIgzuutQxbZoiiiRwlW4s055pP9cHotxtdgKHnhD66dOGk2gIMAAAAAAAAAIDoc2jBhOrq6gYX0KisrPS5ZjA98cQTeuedd7z67rrrLl1wwQUhOX5aWtphx/r+++9Dcmz4hyIMAACEWGKi9OabVWrf3hPwta1WQ3/9a7Uef7xGVmvAlwcAAADQQEZyikpfeVNGQkK9YxNmvqy4t/8RgqgQLtYfViplyq1+ja286VY5zhkT3IAAAAAAAACCxJU2UIbJ4nOMrWhBiKI5Mkv5Tz4/dyf3DFEkkaFyX6W+u/trvX3i69ry8c+NWiOjW5bO//hijXjiVMWnxwc4QgAAAAAAAABAJMnIyJDJZKptO51OHThwoEFr5Ofne7WzsrICElt9ZsyYoRkzZnj1TZ48WZMmTQrJ8X81ePBgr/a2bdtCenz4RhEGAADCoE0bQx98UKmjjgpcIYYOHTz697+rdOWVTv3m+hUAAABAmLl79FTZX5/0a2zK72+XdcWyIEeEcDDv3aPUK8bLVFNT71jHiJGq+NMDIYgKAAAAAAAgOAxrilwpx/ocYysK49ucDEPW8nU+h7iSe4UomPCqKanWsmmL9M+Br2jtKz/I42r4PgZLnEUD7xqii+ZerlYntAlClAAAAAAAAACASBMfH6/WrVt79e3evbtBa+zZs8er3alTpybHVZ9//vOfeuKJJ7z6Jk6cqFtv9e8lW4GUm5vr1S4sLAx5DKgbRRgAAAiTDh0Mff55hUaNcjVpHbPZ0PXXO/TNNxUaNMgdoOgAAAAABFLNJZep6rKJ9Y4zORxKvfJymQ6p7ItmrqJCqZdfLMue+h8uuDsepdIXX5Usvt8UCQAAAAAAEOmcGSf6/NxatkYmZ0mIovFmrtkrs7PI5xhXcs8QRRMe1UVVWvrXhXqz/ytaNm2RnBXORq3T6awuuuS7KzTg/06Qxc49LQAAAAAAAACIJUcddZRXe8uWLQ2af+j4YBdh+PDDD/Xggw969V1wwQW65557gnrculitVq+2y9W07xkisCjCAABAGGVkSG+9VaWnn65STk7D3iZhNhu68EKnvvuuUg8+WKOkpCAFCQAAACAgyh+ZJlfP3vWOs+zdo7SrLpccjhBEhaDzeJR607Wyrfmh3qFGYpJKXn9bRkZm8OMCAAAAAAAIMmfGUJ+fm+SRrXhxiKLxZilfV+8YV0qvEEQSelUHqrT4kQV6s/8rWv7EYjlKaxq1TmaPFjpv1jidMfNcpXVMD2yQAAAAAAAAAIBmoUePHl7tVatW+T23oKBAeXl5tW2bzabOnTsHLLZDzZkzR/fcc48Mw6jtGz16tB566CGZTKagHdeX/fv3e7UzM9k/GkkowgAAQJiZTNKll7q0dGmF/va3ag0Z4pLNZtQx1lD//m798Y81Wrq0Qs8+W62uXRtWvAEAAABAmCQkqPTVN+RJTql3qG3ZEiXfc2cIgkKwJT14v+Jmf+rX2NJnZ8jdI7rfsAgAAAAAAGKHM/0EGfK9adFW/H2IovFmLf/J5+eGySJ3UrcQRRMahRv265spX+qN42Zo5VNL5SxvXBHY+Mx4DXtslC6ae7nanNg+wFECAAAAAAAAAJqTESNGeLUXLlzoVeTAl++/935GMGjQICUF6S3F8+fP15QpU+R2u2v7RowYoWnTpslsDt9X7VesWOHVzs3NDVMkOBJruAMAAAAHJSRIl13m1GWXOVVZKW3ebNb+/SYVF5sUHy+1a+fRUUd5lJwc7kgBAAAANJa7UxeVPf+y0iZcXO/YhDdelatPX1VfcVUIIkMwxP/jdSU++7RfYyum/EGOs84JckQAAAAAAAChY9jS5UrpK1vZ6jrH2IoWhDCi/7GWr/P5uTuxi2SOC1E0wWN4DO2Y94vWvLhSO7/Z3qS1zDaz+lx1rPpPOUHx6fEBihAAAAAAAAAA0Jz169dPGRkZKioqkiTt3LlTS5Ys0QknnFDv3Pfff9+rPXLkyKDEuHTpUt16661yOp21fYMGDdL06dNls9mCckx/uFwuffjhh159gwcPDk8wOCKKMAAAEIESE6W+fT3hDgMAAABAEDhOH62KP9yrpL8+XO/Y5Lt/J/dRneQcNiL4gSGgbAu+VfKdd/g1tuaMs1T5+7uDHBEAAAAAAEDoOTOG+izCYC39QXKVS9bQvo3AWrbW5+eu5F4hiiQ4SrYVa+O7P2njez+pbEdpk9frOrabBt41VGkd05seHAAAAAAAAAAgapjNZp1//vl69dVXa/ueffZZDRo0SCaTqc55ixYt0vLly2vbSUlJGj16dMDjW7t2rW644QZVV1fX9h177LF6/vnnFRcX3mLMM2bM0Pbt3gWUR40aFaZocCTmcAcAAAAAAAAAxJrKO36vmjPPqXecyeVS6lUTZPl5YwiiQqBYflqn1EmXyeRy1TvW2ecYlT7/smTmVi0AAAAAAIg+zowTfX5uMlyylSwJUTT/5a6SpWK97yHJPUMUTOA4yh1a/9aP+ve57+ifg17V8icWN7kAQ5uT2mncl5fp1BfOogADAAAAAAAAAOCIrr32WiUmJta2ly5dqpdeeqnO8fn5+br33nu9+iZOnKjMzEyfx+nWrZvXryVLfD9f2LRpk6655hpVVFTU9vXo0UMvvfSSkpKSfM5tiLfeekuLFi1q0JyZM2dq+vTpXn0jR45U7969AxYXms4a7gAAAAAAAACAmGM2q+yZF2QZvUnWjRt8Dy0tUdplF6po9tcyWrQIUYBoLHPeLqVdeoHMpSX1jnXntlLpP96RAngzHwAAAAAAIJI40wfXO8ZeOF/OrNC92cla/qNMhtvnGFfqsaEJpok8bo/yFuzUxnd+0tbPNslVVX9RUH9k9mihIfefpHYnd/T5pjIAAAAAAAAAADIzM3XDDTfoySefrO174okntHv3bt14443KycmRJHk8Hn399dd6+OGHtXv37tqx2dnZuuqqqwIaU0FBga666ioVFxfX9iUmJuqaa67Rjz/+2OD1hgwZUudna9as0QMPPKDu3btr9OjROumkk9S1a1fZ7XavcVVVVVq0aJFeffVVLVu2zOuz9PR03X333Q2OC8FFEQYAAAAAAAAgDIzkFJW8/rYyTj9Z5pJin2Mt239R2qTxKn7/Yyk+PjQBosFMxUVKu2SsLHt21zvWSExU6T/ekadV6xBEBgAAAAAAEB6GPUuu5J6ylv9U5xjbgXlS19DFZC39od4xztTjgh9IExRvKdKGd9bp5/fWqzyvLGDrZvVsoQFTTlCns7rKZKb4AgAAAAAAAADAP9dee61WrVqlefPm1fa9/fbbevfdd9W6dWulpKRo165dKi0t9ZoXHx+vp556SqmpqQGNZ9u2bSooKPDqq6ys1JQpUxq13saNG+sds2HDBm3YsEF/+9vfZLValZubq5SUFNlsNpWWliovL09Op/OweUlJSXrhhRfUvn37RsWG4KEIAwAAAAAAABAmnk6dVfriK0q7dJxMhuFzrG3pYqXcPlllz78s8fa5yFNdrdSJl8q6cUO9Qw2TSaXPvSxX32ODHxcAAAAAAECYOTKH+y7CULZaJsc+GfaWIYmnviIM7rg2IYulIWpKqrX5w5+14Z11yl++J6Brt+ybrQFTTlDH0ztTfAEAAAAAAAAA0GBms1lPP/207r77bn322We1/W63Wzt37jzinPT0dE2fPl39+/cPVZgh43K5tGvXrnrHHXPMMXr88ccpwBChKMIAAAAAAAAAhJFz5Kmq+PPDSr7/nnrHxs96T+6OR6nyrj+GIDL4ze1W6o3XyL54oV/DK/70FznOPDvIQQEAAAAAAEQGZ+ZIacfzPsfYD3yjmlYXhiQeWz1FGFypx4YkDn+4a1za+c12/fzBBm2bvVnuGndA1289tK2OvXGAOpx6lEwUfgUAAAAAAAAANEFcXJyefPJJnX766Xr++ee1fv36I45LTEzUmDFjdPPNNysrKyvEUQbepZdeqtTUVC1fvlw///yznE6nz/FxcXEaOHCgLrvsMo0YMYL78xHMZBj1vGIPQNTat68s3CFENLvd4tV2OAL7IBtAZCDXgehHngOxgVxHs2cYSv79HUp441W/hpc99jdVT7o6yEFFnojMdcNQ8t2/U8KrL/k1vGrClSp//CmJm+bAEUVkngMIOHK9cVq2TAl3CACAGMFeAt+4lmkEd4VazGsvk1H3psOq1pervNdzIYilWi3mtZbJcNU5pKLzvars9Ifgx1IHt9OtXd/u0OYPN2rb7C1ylNYEdH2z3aKu53fTMdf1U4s+2QFdO5qQ60D0I8+B2ECuA9GPPAdiA7kORD/yvHEifR/B9u3btXr1auXn58vpdCo1NVWdO3dWv379FBcXF+7wgsLhcGjr1q3atWuX8vPzVVFRIZfLpeTkZKWmpuqoo45Sjx49ZLfbwx0q/GANdwAAAAAAAABAzDOZVD51mizbt8k+f169w5PvmiJPy2w5zjonBMHBl8Snn/C7AEPN6aNV/tcnKMAAAAAAAABiiyVJzvQTZC/6rs4h9gNfS4YR9Psm1vIffRZgkCRXyrFBjeFIPC6P8r7fqc0fbdTWzzarpqg64MdIyk1Sj8v6qPekY5SYkxTw9QEAAAAAAAAA+K0OHTqoQ4cO4Q4jpOx2u7p3767u3buHOxQEAEUYAAAAAAAAgEhgs6n05deVfvZpsm7c4HOoyeNR6g1XqeTdD+UcPDREAeJQ8a/MUNIjf/FrrLP/8Sp9caZk5ZYsAAAAAACIPc6sk30WYbDU7Jal4me5k7sFNQ5r6Q/1jnGmHhfUGH7lcXu0Z0meNn/4s7Z+uklV+ysDfgxLvEWdzuyibhf1Utvh7WW2mAN+DAAAAAAAAAAAgGjEjl8AAAAAAAAgQhhp6Sr5x7vKGD1S5v37fY411dQodcIlKv74c7l79gpRhPhV3DtvKeXu3/k11tW5i0r+8a6UmBjkqAAAAAAAACKTI3OkkuS7mKW9cK6qwlyEwR3XWkZcdtCOb3gM7V2+R5s/2qgtH/+syvyKoBwnd2Brdb+4pzqf101xqXFBOQYAAAAAAAAAAEA0owgDAAAAAAAAEEE8HTqq5PW3lT72bJlqanyONZeWKO2SsSr+7Et52rUPUYSwf/aJUm67ya+x7uwclbzzbxlZWUGOCgAAAAAAIHK5Uo+Rx5Yhs7OozjG2A/NU1d6/ey6NZStd7vNzV+qxAT+mx+1R/oq92vrZJm35+GeV55UF/BiSlNw2Rd0u6qluF/VUeqeMoBwDAAAAAAAAAAAgVlCEAQAAAAAAAIgwruMHqfS5l5V6zUSZDMPnWMvePUobd65KPv5cnpzcEEUYu2zffK3U66+UyeOpd6wnOUWlb78vT/sOIYgMAAAAAAAggpkscmSerPj8WXUOsRctkDwOyWwPTgjOYlnK1/sc40o5NiDHclY4tXP+dv0yZ4u2f7lVVfurArLuoayJVnU++2h1u7in2gxtJ5PZFJTjAAAAAAAAAAAAxBqKMAAAAAAAAAARyHHOeSp/9Aml/OH/6h1r3bZVaePOVfGHs2VkZYUguthkXbJYaZPGy+Rw1DvWsNlUOvMfcvU5JgSRAQAAAAAARD5nPUUYTO4K2YqXyJl5UlCOby1ZJpN8Fzx1pg9s9PoV+eXa/sVWbft8i3Z9u0PuGnej16pP66Ft1f3iXup0dlfZk4NTtAIAAAAAAAAAACCWUYQBAAAAAAAAiFDVV14jc/5eJT35WL1jrRs3KO2iMSqZ9YmMtPTgBxdjrMuWKO3SC2SqrKx3rGEyqeyZF+UcfnIIIgMAAAAAAGgeHFn13yux758TtCIMtuLFPj83ZJYrbYDf67lrXNq7Yo92fbtDO+f9ooJV+U0N0afMHi3U5byjdfQFPZTaIS2oxwIAAAAAAAAAAIh1FGEAAAAAAAAAIljlH+6VeV+BEt58rd6xtrWrlXbJBSp570MZySnBDy5GWJcvVdrFY2UuL/NrfPkT01Vz/rggRwUAAAAAANC8eBLay5XYRdbKzXWOse+brYqjHwrK8W0lS31+7k7uJcOaWufnhsfQgXX7tPPbHdr17XbtWZwnV5Ur0GF6Se+aqS7nHa0u53VTZresoB4LAAAAAAAAAAAA/0MRBgAAAAAAACCSmUwq/+uTMu8rUNzn/6l3uG3FMqVOuEQlb70vJSSEIMDoZl2xrGEFGB54RNWXXxHkqAAAAAAAAJonR4tTZd1RdxEGa+UmWSo2y53UJbAH9rhkK1nuc4gzfdBhfaXbS7Tr2+3a+e0O5S3YqeoDVYGN6whSO6apy5hu6nJeN2X1bCGTyRT0YwIAAAAAAAAAAMAbRRgAAAAAAACASGe1qvTFmUq/aIxsSxbVO9z+/XdKm3CJSt54W0pMDEGA0cm6YpnSLjpf5rJSv8ZXTPmDqm68OchRAQAAAAAANF+OFqOVuON5n2Ps+z9XVVJg77FYy9fK5K7wOcaZfoKqDlQpb8EO7fr24K/S7SUBjaMuKe1S1fnco9VlTDe17JtN4QUAAAAAAAAAAIAwowgDAAAAAAAA0BwkJKjkrfeUdsE5sv2wqt7h9m/nKe2yC1Xy5jtScnIIAowu1pXLG1SAofL6m1R55z1BjgoAAAAAAKB5c2YMlceaJrOr7uIG9n3/UVWHABdhKF5S75gPJ+/RtgW+C0QEUlKr5IOFF847Wjn9W1F4AQAAAAAAAAAAIIJQhAEAAAAAAABoJoyUVJW882+ljzlL1vXr6h1v//47pV8yViVvvy8jJTUEEUYH26LvlXrZRTKXl/k1vuqyiar4y1SJjfIAAAAAAAC+mW1yZI1SfP6sOofYihfJ5CySYcsI2GFtxYt9fl5amKJtC1ySgnt/J6Vdqjqe3kmdzz1arQa2kcnM/SQAAAAAAAAAAIBIRBEGAAAAAAAAoBkxMjJV/N5HSh8zWtbNm+odb1u6WGkXjVHJv2bJSEsPfoDNnO3rL5V25eUyVVX5Nb7q0stV/sR0CjAAAAAAAAD4ydFytM8iDCbDLfu+z1XT+tImH6u6qEp7Fu/UMZ6vJHvd43b+3E7BKsCQfVyOOp7eWR1P76ysni1k4j4SAAAAAAAAAABAxKMIAwAAAAAAANDMGNnZKnn/Y6WfO1qWHb/UO962YrnSxp2nkndmycjMCn6AzZT9k4+UesNVMjmdfo2vvuQylf/tGclsDnJkAAAAAAAA0cPR4lQZJotMhrvOMXEFHzWqCEPV/krtXrTr4K+Fu3Rg/X7ldtitgQ+X+py38+f2DT5WXSxxFrU5qb2OOr2zOp7eSUm5yQFbGwAAAAAAAAAAAKFBEQYAAAAAAACgGfK0bqPiDz5W+nmjZdmdV+942+pVSj9vtEr+NUueNm1DEGHzEvfu20q59UaZPB6/xldfdKnKKMAAAAAAAADQYIYtU870wbIXLahzjH3/VzI5S2TY0nyuVZlfobz/FlzYvWiXijYeOGxM595b641p67qj6g/ch/QuGWo7rL3aDuugdsPay5Zsb9J6AAAAAAAAAAAACC+KMAAAAAAAAADNlKdDRxXP+lTpF5wjS96uesdbN25Q+lmnquSdf8vdrXsIImwe4l9+QSn33On3+OoLL1HZ089JFksQowIAAAAAAIheNdnn+izCYDIcsu/7j2paX1rbZ3gMFf18QPkr9yp/xR7tXrhLxVuK6j1Wpz5bfH5eVpSsfbuy/Q9eUmJ20n+LLhz8ldw6pUHzAQAAAAAAAAAAENkowgAAAAAAAAA0Y55OnVX80Wyljz1blh3b6x1v2Z2n9HNOU8k/3pNr4KAQRBjBPB4lPXi/Ep992u8p1eMuVtn05ynAAAAAAAAA0ASO7PNkbPyDTDLqHGPd8YE2rD7+YNGFlXtUsCpfznJHg45jtTnV/ugdPsds/bGTJJPPMbZku9oMbas2J7VXu2HtldEtSyaT7zkAAAAAAAAAAABovijCAAAAAAAAADRznvYdVPzRbKWNPVvWbVvrHW8uLlb6uHNU+tLrcpw+OgQRRqCaGqXcdqPiZ73v95SqiVep/LEnJbM5iIEBAAAAAABEP098KznTh8he/H2dY+yFc/X1Te+opjKh0cdp322HrHa3zzFbf+x8WJ/ZZlZO/1ZqO6y92g7roOzjcmSxUZQTAAAAAAAAAAAgVlCEAQAAAAAAAIgCnjZtVfJrIYbNm+odb6quVuoVl6p86uOqvvKaEEQYOUwlxUq98nLZF3zr95zKG29RxZ8fknjDIQAAAAAAQJMYHkNFmwpVsmuQuiTXXYTBanOr5/HrtWp+v0Yfq1OfLfWO2fpjJ0lSVs8Wajusg9oOb6/Wg9rIlmxv9HEBAAAAAAAAAADQvFGEAQAAAAAAAIgSntxWKv5wttLHnSPrhvX1jjd5PEr5w//J+vMGlT/4qGSN/tuF5rxdShs/Ttb1P/k9p+LOe1Q55Q8UYAAAAAAAAGiEqgNVyl+x5+Cv5XtU8MNeOcocSk436f/+LpnMdc89ZtgPTSjCYKh7/w0+R5RUdNCJT12m1ie0UXxmQiOPAwAAAAAAAAAAgGgT/buqAQAAAAAAgBhiZGer+MP/KO2yi2RbscyvOQmvzJBly2aVvvSajLT04AYYRtalS5Q2abzM+/f5Paf8L4+o6oabgxgVAAAAAABA9PC4PSpcf0B7l+9W/vI92rt8t0q2Fh9xbHlxirZv6KCOPbfXuV6H7juUmbtfhXtbNDiW7HYFympV6HOMrcfZ6tStS4PXBgAAAAAAAAAAQHSjCAMAAAAAAAAQZYzMLBV/8IlSr71CcV/O8WuO/ZuvlT56lErf+JfcXboGOcLQi3/rTSX//naZnE6/xhtms8off1rVl18R5MgAAAAAAACar6r9lcpfube26EL+yr1yVfp3/0WS1nzf12cRBkk6dtgP+vrdUxoUl9lq1vHn7ax3nKPFaQ1aFwAAAAAAAAAAALGBIgwAAAAAAABANEpMVOlrbyllyq2K/9c//Zpi3bxJ6acOV/lTz6jmvLFBDjBEXC4l/fleJc543u8pRmKiSmfMlOO00UEMDAAAAAAAoHlxVTm1b+0+Fazco/xVe1WwYq9Kd5Q0ac11S3pp9MTZssW56hxzzEmrNe+9kTIMc51jzHaLcvrlqvWQtmo9uK1yB7RW9uq3pYq6j+2xZcqZcWJTwgcAAAAAAAAAAECUoggDAAAAAAAAEK1sNpU9/Zw8OblKfPoJv6aYK8qVeu0kVS5drIr7H5Ls9iAHGTzmPbuVcv1Vsi9e6PccT4sWKvnHu3L1GxDEyAAAAAAAsWLHjh1as2aN9u7dK6fTqdTUVHXq1En9+vVTXFxcuMMD6mR4DBVtLlTByr3KX7lXBSv36MBP++VxeQJ6HEdVvH5a2lPHnLSmzjGpmWXqetzP+nll99q+uPQ4ZR+Xq9wBrdV6SFvl9MuVNcFW+7ml4mdZK9b7PHZNy7Mks83nGAAAAAAAAAAAAMQmijAAAAAAAAAA0cxkUsW998udk6PkP94lk8e/jfKJL70g28rlKn3+FXk6HhXkIAPP9vVXSp18rcwHDvg9x3VUJ5W8/YE8nToHMTIAAAAAQCz46quv9Nxzz2ndunVH/DwxMVFjx47V5MmTlZmZGeLogMNV7C1XwQ/5Kli1V/kr9qjgh3w5SmtCcuxV84/zWYRBkoZduFJxx12i7H65yunXSmmd0mUymeocH5f/Yb3HdeSc19BQAQAAAAAAAAAAECNMhmEY4Q4CQHjs21cW7hAimt1u8Wo7HO4wRQIgmMh1IPqR50BsINcB/9i/mqOU666Sudz/ewJGYpLKH5yq6suvkHxsbA8Fv3Ld5VLitEeU+NQTMjXg1qez/wCVvPmujBYtmhomgCbgnA7EBnK9cVq2TAl3CAAAPzgcDt1zzz365JNP/BqfmZmp6dOn6/jjjw9yZP5jL4Fv0XAtU5lfoYI1+dr3Q772rclXwQ/5qsyvCF9AJo9ufXK6MrKLfQ4rGvSdXKnH1L+eYShjYT9ZK7fUOcRjTdOB4Vsks72BwSJWREOuA/CNPAdiA7kORD/yHIgN5DoQ/cjzxmEfARBc1nAHAAAAAAAAACA0HKecruL/fKW0yy+WZccvfs0xVVYoZcqtss/5j8qefEZGdnZwg2wCy4b1SrnlBtlWr2rQvOoxY1X21HNSYmKQIgMAAAAAxAKPx6Pbb79dc+fO9eq3WCxq1aqVUlJStGvXLpWV/a/IQWFhoa699lrNnDlTxx13XKhDRgyo3Fepfav3at/qAu1bna+C1fmq2FMe7rBqxaXFKfu4XBU4z1WG3vA5NmHHsyrrPaPeNW3FC30WYJAkR8vRFGAAAAAAAAAAAABAnSjCAAAAAAAAAMQQd/ceKpozT6lXXib74oV+z4v74nPZhg1U+Z8fVs3F4yWTKYhRNpDbrYRnpyvpsYdlcjgaNLXinvtUeduUyPr9AAAAAACapZdffvmwAgyXXHKJbrrpJuXk5Eg6WKhh7ty5euSRR7R7925JUlVVlW6//XZ9+umnSknhjUVovOriahWs2quCH/K174e9Bwsu7I6cggsmi0ktemcrp3+ucvq1Uk7/VkrrlC6TySSTY4SM796VyVNd5/y4ve+rovOf5Elo5/M48bteqTeWmpzzGxw/AAAAAAAAAAAAYofJMAwj3EEACI99+8rqHxTD7HaLV9vhcIcpEgDBRK4D0Y88B2IDuQ40gsOhpAf+qMSXXmj41MFDVf7Y3+Tu1j0IgdXtSLluXbtayXfeIduK5Q1ay5OUrLLnXpJj9FmBDBFAE3FOB2IDud44LVvypVwAiGRFRUUaNWqUKioqavumTJmi66677ojj8/PzdemllyovL6+2b/Lkybr11luDHmt92EvgW6Rcy7hrXNq/bp/yV+5Vwcq9Kli1V8VbisISS10SWiQqd0Ar5QxopdzjW6vlMTmyJdrqHJ/8021KyJvpc83qVuNV1rvu+1nm6jxlLugjk+Gqc4zHnq0DJ62XzHXHAkRKrgMIHvIciA3kOhD9yHMgNpDrQPQjzxuHfQRAcFGEAYhhbJzwjYs3IDaQ60D0I8+B2ECuA40X99EsJd9+s8wVDXsromGxqHrCJFX8/h4ZLVsGKTpvv811U1GhbA/8WfFvzJTJ42nQOq7OXVT66j/k7tEz0CECaCLO6UBsINcbh80TABDZpk2bppdffrm2ffzxx+vNN9+UyWSqc86iRYs0adKk2nZSUpLmzp2rjIyMYIZaL/YS+BaOaxnDY6h4a5EKVu5V/so9Kli1V/t/3CePs2H3RILJbDUrq2eLgwUXBrRWzoBWSu2Q5jMHDmUp36jMRcf7HGPIpKITvpc7pfcRP0/6+V4lbv+7zzUqO96uiq5/8TsuxCZ+bgGiH3kOxAZyHYh+5DkQG8h1IPqR543DPgIguKzhDgAAAAAAAABA+NScN1aunr2VevUEWTes93ueye1WwmuvKO69d1R1482quvYGGRmZQYz0v8rLFffi84qb/pRMJcUNnl59/gUqf2K6jGQePgAAAAAAAsPj8WjWrFlefTfffHO9Xz4fPHiwBgwYoOXLl0uSKioqNHv2bI0fPz5osSLyGYah8t3l2r8mXwU/5Ct/xR4V/JAvR2lNuEPzktI+VTn9WimnX66y+7VSyz4tZU2wNWlNd3I31WSdqrgDX9Y5xiRDyZvuU0m/WYd/VpOvhJ0v1Xuc6tYTmxQnAAAAAAAAAAAAoh9FGAAAAAAAAIAY5+56tIpmf63k++9VwhuvNmiuuaJcSY8/qoTnn1H1FVep6tob5GnTNuAxmgoPKO7tN2R/5u8yH9jf4PlGXJzKH/qrqideKTXgDYwAAAAAANRn5cqVKiwsrG23a9dOgwYN8mvuuHHjaoswSNLcuXMpwhBDPG6PSrYWa//aAu1bW6D9awu0/8cCVRdWhzs0L/bUOGUfl6uc/rnK6ddK2cflKrFlYlCOVXnU73wWYZAk+4GvZM//txw553v1J23+i0we3392NS3OkDupS5PjBAAAAAAAAAAAQHSjCAMAAAAAAAAAKSlJ5Y8/JccZo5V8+82yFOQ3aLq5olyJz01XwgvPyDHyFFVfdoUco06V4uMbH5PHI+vSJYp/55+K/+Bdmaob9wUEV5euKnvxVbn6HNP4WAAAAAAAqMP8+fO92kOGDJHJzwKAQ4YM8WovWbJElZWVSkwMzhfcET7OCqcKN+7XgXX7tG/tPu1fW6AD6/fJVekKd2hezDazsnq2VE6/XGX3a6Wc/rlK75Qhkzk0RS1dGYNV0/Isxe37zOe4lPW3qyi1vzwJ7SVJtsLvlLD7zXrXr+owOSBxAgAAAAAAAAAAILpRhAEAAAAAAABALccpp6to/mKl/P52xX36UYPnmzwexX31heK++kJGYpIcw0+W45TT5Ow3QO5u3SWr71uS5r17ZF22RPbvv5P9P5/KsndPY38rMkwmVd14iyr+cK+UkNDodQAAAAAA8GX9+vVe7X79+vk9NycnR23atFFeXp4kyel0avPmzerbt29AY0TouGtcKttVpsIN+3Xgp/068NM+Hfhpv0p+KZaMcEfnzWw1K7N7lloem6PsY3LV8phsZfVoIUtceLeUVXT5s+z7ZsskT51jzM4ipf1wsYr7fyqTu1Ipa6+ud11n2iA5M4YFMlQAAAAAAAAAAABEKYowAAAAAAAAAPBiZGWp9JU3FPfxv5X0x7tkyd/bqHVMlRWKm/2p4mZ/enDd+Hi5O3WRJydHnuwcGRaLTB6PVFkpy64dsuzcKfO+goD8HlydOqvs6eflGnRCQNYDAAAAAKAuW7du9Wp37ty5QfO7dOlSW4Th1/UowhDZCjcVatvnW1S0uVBVRdWqKalRTUm1KvaUqzK/ItzhHZHJYlJm9xZqeUy2svvmqOUxOcrq1VLW+MjbPuZO7qbqNlcoIW+mz3HW8nXKWDJcMpyyOOq/f1XR+V7JZApUmAAAAAAAAAAAAIhikfcUDQAAAAAAAED4mUyqOW+sHCePUtLUBxX/6ksyGU17XaOpulrWn36UfvoxQEEezrBaVXXdTaq48x4pMTFoxwEAAAAAQJKqq6u1e/dur75WrVo1aI3c3Fyv9rZt25ocF4LDMAwt/utCLZ76fbhD8c0kZXbPUvaxuco+5r8FF3q2kDXBFu7I/FbR+V7FFXwos7PI5zhL9Q6/1qtpcZqcmcMDERoAAAAAAAAAAABiAEUYAAAAAAAAANTJSE1T+dTHVTV+opIf+JPs384Ld0h1cgw7WeWPPCb30d3CHQoAAAAAIEYUFRXJ+E3RQpvNpqysrAatkZOT49U+cOBAQGJD4G1856eILMCQ3CZF2cflKqdfrrL75apl3xzZk+3hDqtJjLhslXd7TKk/Xtv0tcxxKu/2V8lkCkBkAAAAAAAAAAAAiAUUYQAAAAAAAABQL3efvip570PZ5n2l5Afuk3X9unCHVMvVrbsq7vqTHGeezWZ6AAAAAEBIVVZWerXj4+NlauDPpomJiT7XDDW73RLW40eyda+tDncIsqfalduvlXL6t1Juv1zl9m+lpNzkcIcVFEb7S+Uo+lr2vLebtE519wdlTT86QFEhVlit/FsIRDvyHIgN5DoQ/chzIDaQ60D0I88BRCKKMAAAAAAAAADwj8kk58hTVTRilOxzZivx6cdlW7kibOG4juqkyjvvUc2YCyQLD2EAAAAAAKFXUVHh1Y6Li2vwGofOCXcRBtStZFtxSI9ntpnVsne2cge0Us5/Cy5kdMmUyRwjRShNJlX1mS5z+QZZS1Y1aglnzjlydLwpwIEBAAAAAAAAAAAg2lGEAQAAAAAAAEDDmM1yjD5LjjPOlG3Bt0p49SXZ5/xHJpcrJId3nThMNdffqMpRp0tWbnECAAAAAMLH4XB4tW02W4PXsNvtXu3q6uomxYTgic9MUHVRcP7/safa1bJ3tlr2yVbLvjnK7putzG5ZsthjvPCkJVGVAz9U0qIzZClf36CprowhqjzuVckUI0UrAAAAAAAAAAAAEDDsUAYAAAAAAADQOCaTnCcNl/Ok4TIVFCj+3bcV//47sv70Y8AP5W7TVq5zz5Pj8ony9Op9sNPhDvhxAAAAAABoiEMLKDidzgavcWghh7i4uCbFhODpe9Wx+vbeeU1eJ6lV8sFiC32yld03Wy37ZiutQ7pMZooFHIlhb6GKwV8oYdUVsu3/2q85zpyzVHnsq5IlMcjRAQAAAAAAAAAAIBpRhAEAAAAAAABAkxnZ2aq6+TZV3XybzDt3yP7F57LP/UK2VStkPnCg4evFxcl1bD85Bw1WzRlnytVvgOzxDX+bKAAAAAAAwZSUlOTVrqmpafAah85JTAzvl8YdFD2sU48r+mrXdzu09fMtfo23JliV2T1LWT1bKqtni4P/7dFC8ZkJh411ujyBDjfKpKnm2A8Uv/NlJW2dKrOz8IijPLYWquh8t6rbXi15zBTxRMDwbyMQ/chzIDaQ60D0I8+B2ECuA9GPPAcQCSjCAAAAAAAAACCgPO3aq/rq61R99XWSYci8a6esq3+QZdtWmQv2yrx3r8xFRZLZJJnNMiwWeVpmy9O2ndxt28ndpatcfY6RePMnAAAAACDCHVowobq6WoZhyGQy+b1GZWWlzzUROSx2i855+3xtfH+9di3YqdLtJbIkWBWXFi97Wpzi0uKU3CZFqe1Sldw2VSntUmW2mMMddvQwWVTd/npVt5mguH3/ka3wO1mqfpEkuRPay5kxTDXZZ0kWcggAAAAAAAAAAABNQxEGAAAAAAAAAMFjMsnTrr0c7dqHOxIAAAAAAAIuIyNDJpNJhmFIkpxOpw4cOKAWLVr4vUZ+fr5XOysrK6AxIrBMJpO6X9hT3S/sKYm3cYWFJVE1ueNUkzsu3JEAAAAAAAAAAAAgSlFqHQAAAAAAAAAAAAAAAGiE+Ph4tW7d2qtv9+7dDVpjz549Xu1OnTo1OS4AAAAAAAAAAAAAQONZwx0A4I9NmzZp3bp1KigokMfjUXp6urp27apjjjlGVmt4/hoXFRVp69at2rNnjw4cOKCqqiqZzWalpqYqJydHvXr1UnZ2dlhiAwAAAAAAAAAAAAAAoXHUUUcpLy+vtr1lyxb17dvX7/lbtmzxalOEAQAAAAAAAAAAAADCiyIMiFiGYeiDDz7QSy+9pF9++eWIY9LT03XppZfquuuuU2JiYlDjKSws1EcffaTly5drzZo1KigoqHdO165dNW7cOF188cVKSEgIanwAAAAAAAAAAAAAACD0evTooQULFtS2V61apfPPP9+vuQUFBV4FHGw2mzp37hzwGAEAAAAAAAAAAAAA/jOHOwDgSEpLS3X11Vfr3nvvrbMAgyQVFxfr+eef17nnnqtNmzYFNaYNGzbo0Ucf1VdffeVXAQZJ2rRpk6ZOnaqzzz5by5cvD2p8AAAAAAAAAAAAAAAg9EaMGOHVXrhwoQzD8Gvu999/79UeNGiQkpKSAhUaAAAAAAAAAAAAAKARKMKAiFNdXa2rr776sI0GNptNHTt21NFHH63ExESvz3bu3KmJEydq+/btoQxVkpSRkaGuXbvq2GOPVbdu3ZSWlnbYmF27dumqq67yevMFAAAAAAAAAAAAAABo/vr166eMjIza9s6dO7VkyRK/5r7//vte7ZEjRwY0NgAAAAAAAAAAAABAw1nDHQBwqKlTp2rNmjW1bbPZrBtuuEGTJk2qLXDgcDj06aef6tFHH1VJSYkkqbCwULfffrvef/99WSyWoMRmMpnUt29fDR06VAMGDFCvXr2Unp5+2LhNmzbpnXfe0VtvvSW32y1Jqqmp0ZQpUzR79mxlZmYGJT4AAAAAAAAAAAAAABBaZrNZ559/vl599dXavmeffVaDBg2SyWSqc96iRYu0fPny2nZSUpJGjx4d1FgBAAAAAAAAAAAAAPUzhzsA4Le2bNmi9957z6tv2rRpuu2222oLMEiS3W7X2LFj9c9//lOpqam1/T/99JM+/PDDoMTWvXt3zZ8/X++++65uu+02DR069IgFGCSpa9eu+uMf/6iXXnpJNputtr+4uFivvPJKUOIDAAAAAAAAAAAAAADhce211yoxMbG2vXTpUr300kt1js/Pz9e9997r1Tdx4kRe6gAAAAAAAAAAAAAAEYAiDIgof//73+V2u2vb5513ns4+++w6x3ft2lV33nmnV9+zzz4rp9MZ8NgyMzOVk5PToDlDhw7VlVde6dU3Z86cQIYFAAAAAAAAAAAAAADCLDMzUzfccINX3xNPPKE///nPys/Pr+3zeDz66quvdMkllygvL6+2Pzs7W1dddVXI4gUAAAAAAAAAAAAA1M1kGIYR7iAASSopKdGQIUPkcrkkSSaTSV9++aXatWvnc57H49Epp5zitTlhxowZGj58eFDj9demTZsOKySxdu1a2e32MEX0P/v2lYU7hIhmt1u82g6Hu46RAJozch2IfuQ5EBvIdSA2kOtA9CPPgdhArjdOy5Yp4Q4BAFAPj8ejm266SfPmzfPqt1gsat26tVJSUrRr1y6VlpZ6fR4fH69XX31V/fv3D2W4dWIvgW9cywCxgVwHoh95DsQGch2IfuQ5EBvIdSD6keeNwz4CILjM4Q4A+NU333xTW4BBkgYOHFhvAQZJMpvNGjt2rFff3LlzAx5fY7Vv3/6wvqKiojBEAgAAAAAAAAAAAAAAgsVsNuvpp5/WWWed5dXvdru1c+dO/fTTT4cVYEhPT9eMGTMipgADAAAAAAAAAAAAAIAiDIgg8+fP92qfeOKJfs8dMmSIV/vQt0qEU01NzWF9qampYYgEAAAAAAAAAAAAAAAEU1xcnJ588klNnz5dPXr0qHNcYmKixo8fr//85z8aNGhQCCMEAAAAAAAAAAAAANTHGu4AgF+tX7/eq33cccf5Pbd3796y2+1yOBySpIKCAhUWFiozMzOgMTbG6tWrvdqdOnVSQkJCmKIBAAAAAAAAAAAAAADBdvrpp+v000/X9u3btXr1auXn58vpdCo1NVWdO3dWv379FBcXF+4wAQAAAAAAAAAAAABHQBEGRASn06kdO3Z49XXu3Nnv+Xa7Xe3bt9fmzZtr+7Zs2RL2Igwej0czZszw6jv//PPDFA0AAAAAAAAAAAAAAAilDh06qEOHDuEOAwAAAAAAAAAAAADQAOZwBwBI0s6dO+VyuWrb8fHxDS6gkJub69Xetm1bQGJrrNLSUk2ZMkVLly6t7evUqZMmTpwYxqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHWxhjsAQJIKCwu92jk5OQ1e49A5Bw4caFJM/li6dKlX8Yiqqirt27dPq1ev1pdffqmysrLazzp27KiXX35Z8fHxQY/LX3a7JdwhRDSrlT8fIBaQ60D0I8+B2ECuA7GBXAeiH3kOxAZyHQAAAAAAAAAAAAAAAEAkowgDIkJFRYVXOyEhocFrJCYmerUrKyubFJM/brrpJq9CC0eSkpKi8ePH6/rrr1dSUlLQYwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAANA5FGBARDi2YEBcX1+A1Dp0TiiIM9UlOTtY111yjsWPHUoABAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKcOdwBAJJUU1Pj1bbZbA1ew263e7Wrq6ubFFMglJeX629/+5tGjRqlxx9/XA6HI9whAQAAAAAAAAAAAAAAAAAAAAAAAAAAAADqYA13AIgMDz/8sN54442gH+fmm2/WLbfcclh/XFycV9vpdDZ47UMLHBy6ZjAsX7689n8bhqHy8nLt3btXP/zwg2bNmqWVK1fWxvbSSy9p3bp1euGFF0ISmz8cDne4Q2hW+PMCYgO5DkQ/8hyIDeQ6EBvIdSD6kedAbCDXAQAAAAAAAAAAAAAAAEQSc7gDACQpMTHRq11TU9PgNQ6dc+iawWYymZSSkqKuXbvqwgsv1Ntvv61p06bJbrfXjlm4cKEeffTRkMYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPCPNdwBAJKUlJTk1a6qqmrwGpWVlV7tUBdhOJJzzz1XVqtVd9xxR23f22+/rQkTJqhTp05hjOygli1Twh0CAAAAAAAAAAAAAACIIOwlAAAAAAAAAAAAABDrKMIASdKIESOUkZER9OMcf/zxR+zPzMz0aufn5zd47UPnZGVlNXiNYDjzzDP11ltvadmyZZIkwzD00UcfeRVmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEH0UYIEkaOnSohg4dGrbjt2vXTlarVS6XS5JUXV2twsLCw4oz+LJnzx6vdqdOnQIaY1OceuqptUUYJGnlypVhjAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcCTmcAcASJLNZlO7du28+jZv3uz3fIfDoZ07d3r1RVIRhvbt23u19+/fH6ZIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1oQgDIkaPHj282qtWrfJ77o8//iiHw1HbbtmypbKysgIWW6BZrdZwhwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOARFGBAxRowY4dX+/vvv/Z67cOFCr/bIkSMDEVLA7N6926vdokWLMEUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgLRRgQMYYPHy6r1VrbXrp0qXbu3FnvPMMwNGvWLK++UaNGBTy+pvj666+92t26dQtTJAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAulCEAREjPT3dq3iCYRj6+9//Xu+8999/X3l5ebXtNm3aaPDgwUGJsTEWLVqkBQsWePVFWpEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFGBBhbr31VpnN//tr+dFHH+nTTz+tc/zmzZv12GOPefXdeOONstvtPo+za9cudevWzevXrl276hy/detWPfnkkyouLvbvN/Jfy5Yt06233urVd8wxx2jAgAENWgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEHwUYUBE6dKliy688EKvvt///vd6+umnVVJSUtvndDo1a9YsjR8/XqWlpbX93bp10/nnnx/wuGpqavTiiy9qxIgRuuOOO/T5559rz549RxxbXV2thQsXasqUKZowYYJXfHa7Xffdd59MJlPAYwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAANI3JMAwj3EEAv1VVVaXLL79cP/74o1e/zWZT27ZtZbfbtXPnTlVWVnp9npGRobfffltHHXVUvcfYtWuXRo0a5dU3d+5ctW3b9ojj169frzFjxhzWn5aWpszMTKWkpMjtdqu0tFS7d++W2+0+bKzdbtczzzyj4cOH1xsfAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD0rOEOADhUQkKCXnnlFd12221avHhxbb/T6dS2bduOOKdNmzZ6/vnn/SrAEEglJSUqKSmpd1zv3r310EMPqUePHiGICgAAAAAAAAAAAAAAAAAAAAAAAAAAAADQGBRhQERKT0/XzJkz9f777+vll1/W9u3b6xx3ySWX6LrrrlNSUlLQ4unSpYtefvllzZ8/X0uXLtXmzZvldrt9zomPj9fQoUM1duxYnXzyybJYLEGLDwAAAAAAAAAAAAAAAAAAAAAAAAAAAADQdCbDMIxwBwHUZ+PGjfrpp5+0b98+ud1upaenq2vXrjrmmGNks9lCHk9lZaU2b96snTt36sCBA6qsrJTZbFZycrLS0tLUpUsXdenShcILAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCMUIQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAkjncAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQCijAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIIgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSKMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSIMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkijCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkiDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJIgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSKMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSIMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkijCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkiDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJIgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSKMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgSbKGOwAACJQdO3ZozZo12rt3r5xOp1JTU9WpUyf169dPcXFxYYvLMAytW7dO69evV2FhoSQpKytL3bt3V69evWQymcIWG9AcRWquA4h+nNMBAPDNMAzt2rVLP//8s/bu3auysjLZ7XalpqaqY8eO6tOnT0Rcs7tcLq1evVqbNm1ScXGxzGazsrOz1atXL3Xt2jXc4QERr7nkOoCmcTgc2rp1q/Ly8pSfn6+Kigq5XC4lJycrPT1d3bp1U+fOnWWxWMIa56ZNm7Ru3ToVFBTI4/EoPT1dXbt21THHHCOrlcegAADgoEh9vshzByBwIjXPAcQGzukAAPjWXJ4vspcAaJrmkusAGo99BABiEf9qAGj2vvrqKz333HNat27dET9PTEzU2LFjNXnyZGVmZoYsLqfTqTfeeEOvv/668vPzjzgmNzdXV1xxhSZMmCCbzRay2IDmKJJyfcKECVq6dGmj50+dOlVjx44NYERA85efn681a9Zo9erVWrNmjX788UdVVFTUft6mTRt9/fXXYYmNczoAAHUrKSnRV199pe+++06LFy9WUVFRnWNtNpuGDx+uK664QgMHDgxhlAdVVFRoxowZ+te//qXi4uIjjjnqqKN07bXXauzYsWyKBH4j0nN95MiRysvLa/T8N954Q4MGDQpgREDz9Pnnn2vhwoVatWqVtm7dKpfL5XN8SkqKzjrrLE2cOFGdO3cOUZQHN3B98MEHeumll/TLL78ccUx6erouvfRSXXfddUpMTAxZbAAAILJE0vPF3+K5AxA4kZTn7CMAgoO9BAAANE+R/nzxt9hLADRepOc6ewmApmMfAYBYZzIMwwh3EADQGA6HQ/fcc48++eQTv8ZnZmZq+vTpOv7444McmbRnzx7ddNNN+umnn/wa36tXLz3//PPKyckJcmRA8xOJuc7mCSAwVqxYoZkzZ2r16tUqKCjwOTZcGyc4pwOBE2kbpDifA033wAMP6L333pPT6Wzw3DFjxuhPf/qTkpOTgxDZ4TZu3KibbrpJu3bt8mv8iSeeqKeeekopKSlBjgyIfM0h19k4AQTGsGHD6vzCgC82m03XX3+9br755qBvPCwtLdXtt9+u77//3q/x7dq10/PPP88bqgAAiDGR+HzxVzx3AAIjEvOc5w5A4LCXAIgt7CUAok9zeL74K/YSAI3XHHKdvQRA07GPAECsM4c7AABoDI/Ho9tvv/2wh6kWi0Vt27ZVjx49Dru5UVhYqGuvvVarVq0KamwHDhzQxIkTD3vAEh8fr65du6pz586Ki4vz+mzdunWaOHGiCgsLgxob0NxEcq4DaLq1a9fqyy+/rHfTRLhwTgeabsWKFbr55pt10kknadiwYbr55pv10ksvacmSJV6bJgA0T6tXrz7ig1SLxaLc3Fz16tVL3bp1O+Lmgw8//FBXXnllSP4t2Lp1q6644orDNk0kJiaqW7du6tix42Fvn1qwYIGuvfZa1dTUBD0+INI1l1wHEBxxcXHq2LGj+vTpo169eqlNmzaHbZBwOp165plndO+99wY1lurqal199dWHbZyw2Wzq2LGjjj766MPeVrFz505NnDhR27dvD2psAAAgckTy80WeOwCBEcl5DiAw2EsARD/2EgDRrbk8X2QvAdA0zSXXAQQe+wgAxBJruAMAgMZ4+eWXNXfuXK++Sy65RDfddFNttWiPx6O5c+fqkUce0e7duyVJVVVVuv322/Xpp58GrQLlXXfdpR07dtS24+LiNGXKFF100UVKSEiQJFVWVurdd9/Vk08+WXsT5pdfftE999yjF154IShxAc1RJOf6b82cObNB47t06RKkSIDokZiYqMrKyrDGwDkdaLpfN0gBiH6pqak6++yzNWLECPXv39+rUr3b7dby5cs1ffp0LV++vLZ/zZo1uvvuuzV9+vSgxeVyuXTbbbepqKioti89PV133323zjrrrNoNE8XFxZo5c6ZmzJghj8cjSVq1apWmTZumP/7xj0GLD2huIjXXf6tFixaaNm1ag+Z07949SNEAzU92drZGjBihAQMG6LjjjlPbtm1lNnvXdC8pKdGcOXP07LPPau/evbX9H3zwgfr3768LLrggKLFNnTpVa9asqW2bzWbdcMMNmjRpktLS0iQdfBvup59+qkcffVQlJSWSDn7Z6vbbb9f7778vi8USlNgAAEDkiOTnizx3AAIjkvP8t9hHAAQHewmA6MBeAiB2ROrzRfYSAIEVqbn+W+wlABqPfQQAYpnJMAwj3EEAQEMUFRVp1KhRXlXvpkyZouuuu+6I4/Pz83XppZcqLy+vtm/y5Mm69dZbAx7bggULdPXVV9e2bTabZs6cqeOPP/6I45cuXaqrrrrKqwLg66+/rhNOOCHgsQHNTSTn+oQJE7R06dLa9saNGwN+DCAWvPbaa5o6daqSkpLUq1cv9enTR3379lWfPn20a9cuTZw4sXZsmzZt9PXXX4csNs7pQGD8mudHcugGqVDn+aHn88ZshszOzg50WECzMnbsWBUXF+vGG2/UOeeco/j4eJ/j3W63HnjgAb3zzjte/cE8Z77zzju67777attpaWl666236tzQ/Mknn+h3v/tdbdtqteqzzz5Tx44dgxIf0Bw0h1wfOXJk7f2AUF9TANFkw4YN6tat22FvqKhLSUmJrrzySq1bt662r2XLlvr2228P23DRVFu2bNE555wjt9td2/fEE0/o7LPPPuL4TZs2afz48SotLa3te+SRR4K2sQMAAESGSH6+yHMHIDAiOc/ZRwAEDnsJgOjHXgIgujWH54vsJQCarjnkOnsJgKZjHwGAWBfYf7kAIARefvllr4epxx9/vK699to6x+fk5Ojhhx/26nvttde8KlcGytNPP+3Vvvbaa+t8wCJJAwcO1DXXXOPV99RTTwU8LqA5iuRcBxAYI0eO1Geffably5frzTff1J133qkzzjhDbdq0CXdonNOBAEtKStLAgQN19dVX6+mnn9bXX38dcW94GTJkSIN+sWkCkG699VZ9/vnnuvDCC+t9kCpJFotF999/v3r37u3V/9577wUlPofDoeeff96r78477/T5RrlzzjlH5557bm3b5XLp73//e1DiA5qLSM91AIHTvXt3vzdOSAc3JE6bNs1rzr59+7Ry5cqAx/b3v//da+PEeeedV+fGCUnq2rWr7rzzTq++Z5991usLDwAAIPpE8vNFnjsAgRHJeQ4gcNhLAMQO9hIA0SnSny+ylwAIjEjPdQCBwT4CALGOIgwAmhWPx6NZs2Z59d188831XtANHjxYAwYMqG1XVFRo9uzZAY1t48aNWrNmTW07MTHRq+p1Xa655holJibWtletWqUtW7YENDaguYnkXAcQOO3bt1eXLl0CXtWyqTinA4ETyRukADTdiBEjZLfbGzTHYrEcttlwwYIFgQzLa909e/bUttu0aeNX1epbbrnF62ePOXPmqKysLCgxAs1BpOc6gPDq3LmzevXq5dUX6J+FS0pK9OWXX9a2TSaTbrnllnrnXXDBBV4/e+Tl5WnhwoUBjQ0AAESOSH6+yHMHIDAiOc8BBBZ7CYDox14CILpF+vNF9hIAgRHpuQ4gfNhHACCaRNYdSgCox8qVK1VYWFjbbteunQYNGuTX3HHjxnm1586dG9DYDl3vjDPOUHJycr3zkpOTdcYZZ3j1ffXVVwGNDWhuIjnXAUQ/zulA4ETqBikA4fXbDc+SVFxcrKqqqoAf59Bz+tixY/2qyt2+fXuvt1Y5nU7Nnz8/4PEB0S5UuQ4g/Nq3b+/VDvQbZb/55hu5XK7a9sCBA9WuXbt655nNZo0dO9arj3uFAABEr0h+vshzByAwIjnPAcQGzulA4LCXAMCRsJcAiA3sJQBiA/sIAEQL7lwAaFYOvVExZMgQv256/Dr2t5YsWaLKysqgxXbiiSf6PffQ2ObNmxeQmIDmKpJzHUD045wOAEBwpaWlHdYXjLdDNOWcPnToUK8253Sg4UKV6wDCr6amxqudkpIS0PX5OR0AAPgjkp8vcj0DBEYk5zmA2MA5HQCA4GIvARAb2EsAxAb2EQCIFhRhANCsrF+/3qvdr18/v+fm5OSoTZs2tW2n06nNmzcHJC7DMLRx40avvuOOO87v+Yf+PjZu3CjDMAISG9AcRWquA4h+nNMBAAi+/Pz8w/rS09MDeoz9+/dr3759tW273a6ePXv6Pf/Qc/qGDRsCFhsQK0KR6wDCzzAMrV271quvd+/eAT3GofcKG/Jzeu/evWW322vbBQUFXm/OBQAA0SNSny/y3AEInEjNcwCxgXM6AADBx14CIDawlwCIfuwjABBNKMIAoFnZunWrV7tz584Nmt+lSxef6zVWXl6eqqqqatuJiYlq3bq13/PbtGmjhISE2nZlZaX27NkTkNiA5ihSc92XsrIybdiwQcuWLdO6deuUl5cnt9sd9OMCCCzO6QAABN/y5cu92m3atPF6qBEIW7Zs8Wp36NChQcc49GeK7du3y+VyBSQ2IFaEItd9KSws1Pr167Vs2TKtX79ee/bsYVMzEATvv/++CgoKatudOnVS3759A7a+0+nUjh07vPoacq/Qbrerffv2Xn2HXicAAIDoEKnPF3nuAAROpOa5L+wjAKIH53QAAIKPvQRAbGAvARD92EcAIJpYwx0AAPirurpau3fv9upr1apVg9bIzc31am/btq3JcR1pnUOP44/c3FyvdbZt29agBzVAtIjkXK/LmDFjtHHjRnk8Hq/+xMRE9evXT6effrrGjBkT0htEABqHczoQ28rKypSXl6eysjIlJiYqPT1dubm5slgs4Q4NiCoffPCBV3vYsGEBP0ZTz+mZmZmKi4tTTU2NpIMPbnbt2qWOHTsGKkQg6oUi14/kwIEDOvPMM4/4cDQ9PV39+/fX2WefrdNPP51zPNBE//73v/XAAw/Uts1ms+677z6ZTKaAHWPnzp1emxfj4+OVmZnZoDVyc3O93nC7bds2HX/88QGLEQAAhF8kP1/kuQMQGJGc53VhHwEQXTinA7GNvQRAaLCXAIgN7CUAohv7CABEG4owAGg2ioqKvCrM2Ww2ZWVlNWiNnJwcr/aBAwcCEtuh6zTmIUtOTo7XjZ1AxQY0N5Gc63VZv379EfsrKyu1YMECLViwQNOnT9e9996r0aNHBzUWAE3DOR2IXWyGBEJj/vz5WrZsmVff2LFjA36cQJzTs7OztXPnTq812TgB+CdUuX4k1dXVdVanLy4u1ty5czV37ly1b99eDz/8sAYOHBiSuIDmaNu2bV5vZHQ6nSotLdWmTZs0d+5crw0JNptNDz74oAYPHhzQGAoLC73ah97380eo7xUCAIDQi+Tnizx3AAIjkvO8LuwjAKIL53QgdrGXAAgN9hIAsYG9BEDzxz4CALGGIgwAmo3Kykqvdnx8fIMrYSUmJvpcs7EOXSchIaHBaxw6J1CxAc1NJOd6U+zbt0+333671qxZoz/84Q/hDgdAHTinA7GLzZBA8BUXF+u+++7z6jvllFPUt2/fgB+LczoQPqHM9abYsWOHJk2apD/84Q+64oorwh0OEJHeeustvfHGGz7HmEwmnXTSSZoyZYq6d+8e8BgqKiq82o05p0fivUIAABBYkfx8kXsUQGBEcp43BfsIgOaDczoQu9hLAAQfewmA2MBeAiA6sI8AQKyhCAOAZuPQi6S4uLgGr3HonGBtnGhMbPHx8T7XBGJFJOf6occYMmSIhg0bph49eqhDhw5KSUmRw+FQYWGhVq1apc8++0zz58/3eiPHq6++qoyMDF133XUBjwlA03FOB+ALmyGBxvN4PPr973+vvXv31valpKToj3/8Y1COxzkdCI9Q5/pvJScn66STTtKJJ56o7t27q23btkpOTlZ1dbXy8/O1atUqzZo1SytWrKid43a7NXXqVLVo0UJnnXVW0GMEotEZZ5yhCRMmBGXjhBSYc3oo7hUCAIDwiuTni9yjAAIjkvP80GOwjwCITpzTAfjCXgKg8dhLAMQG9hIAsYV9BACiCUUYADQbDofDq22z2Rq8ht1u92pXV1c3KaZf1dTUeLUjKTaguYnkXP/VpEmT1K9fP2VkZBz2mc1mU1JSktq1a6dzzz1Xy5cv1//93/8pPz+/dsyTTz6pYcOGBe2HSgCNxzkdiC1shgRC57HHHtO3337r1feXv/xFrVq1CsrxOKcD4RHqXP/V73//ew0bNkxJSUmHfZacnKzk5GR17txZ48aN05dffql77rlHpaWlkiTDMHTvvfdq4MCBatmyZVDjBKLR7NmzNXv2bA0YMECPPPKIOnToEND1OacDAAB/RPLzRa5ngMCI5Dz/FfsIgOjGOR2ILewlAEKHvQRAbGAvARBb2EcAIJqYwx0AAPjr0Ascp9PZ4DUOfSjbmGpXR3LoOpEUG9DcRHKu/2rUqFFH3DhxJAMGDNCbb77pNd4wDD311FMBjQlAYHBOB2LHpEmTNH/+fL3wwgsaP368jjvuOGVmZh62EfLFF1/UP/7xD+Xk5HjNf/LJJ7Vhw4YwRQ80L2+88YZmzpzp1XfNNdfozDPPDNoxOacDoReOXP/V6NGjj7hp4khOPfVUvfTSS15vqKmqqtILL7wQrPCAZuvee+/Vxo0ba3+tXr1a8+fP14svvqhx48Z55dHy5cs1btw4rV27NqAxcE4HAAD+iOTni1zPAIERyXn+K/YRANGNczoQO9hLAIQOewmA2MBeAiC6sI8AQKyhCAOAZuPQH34OrVzlj0PnJCYmNimmutZpTGyHVs0KVGxAcxPJud5YHTp00J133unVN3/+fBUXF4cnIAB14pwOxA42QwKh8cknn+iRRx7x6hs7dqx+97vfBfW4nNOB0ApXrjfWscceq2uuucar79NPP5XH4wlTREDzEB8fr9zcXI0YMUIPP/ywPv74Y/Xo0aP289LSUk2ePLn27TCBEIhzeqTdKwQAAIEXyc8XuUcBBEYk53ljsY8AaF44pwOxg70EQGiwlwCIDewlAKIf+wgARDuKMABoNg69oKmurpZhGA1ao7Ky0ueajXXoOlVVVQ1e49A5XMAhVkVyrjfFmDFjlJmZWdv2eDxauHBhGCMCcCSc0wHUhc2QQMPNmzdPd911l9f1/GmnnaaHHnpIJpMpqMfmnA6ETjhzvSkmTpwoi8VS2y4uLtaPP/4YxoiA5qdDhw569dVX1apVq9q+/Px8vfLKKwE7xqFftGrMOT0S7xUCAIDAiuTni9yjAAIjkvO8KdhHADQfnNMB1IW9BEDDsZcAiA3sJQBiE/sIAEQbijAAaDYyMjK8fthyOp06cOBAg9bIz8/3amdlZQUktkPX2bt3b4PXCFZsQHMTybneFGazWQMHDvTq27ZtW5iiAVAXzukAfGEzJOC/xYsX67bbbpPL5artGzp0qJ544gmvB5XBEohzekFBgc81AYQ/15siLS1NPXv29OrbunVrmKIBmq/MzEzdcsstXn2zZs0K6Pq/dejP3P7g53QAAKJfJD9f5LkDEBiRnOdNwT4CoPngnA7AF/YSAP4L9/NF9hIAoRHuXG8K9hIATcc+AgDRhCIMAJqN+Ph4tW7d2qtv9+7dDVpjz549Xu1OnTo1OS5JOuqoo7zajbkhc+icQMUGNDeRnOtN9dtqfpJUVPT/7N13eFTV9v/xTyqpEAKhBaQTkI70Lk1QkCJKL4IiqNgVENErijTBq+C1URRERZDeuyK99w6BkEAIhCSE9GR+f/glPwNJ5kxyUnm/7uNznzmz9t6LZM5Mkr3OOrdzKBMAaeEzHUB6KIYEjDly5IhGjBih2NjY5GN169bVzJkz5ezsnC053P+Zfv/vCNbcunUrRf5OTk4qU6aMKbkB+UVuONczi9/TAXO0b98+xcVQN27cUGBgoClzlylTRo6OjsmPY2JiFBoaatMcufVvhQAAwDy5eX+RfQfAHLn5PM8s/j4B5A18pgNID7UEgDG5YX+RWgIg6+WGcz2z+F0dyDzqCADkFzRhAJCn3P+HjwsXLtg0/v54s35I8vX1lYuLS/LjqKgom344DAwMVHR0dPJjNze3B35xAx4mufVcz6x//6In/XN3DgC5C5/pAKxhgwVI3+nTp/Xiiy8qKioq+dijjz6qH374QW5ubtmWx/2/A1y5ckVxcXGGx9//O8UjjzzywM/zwMMst5zrmcXv6YA5ChYsqEKFCqU4dvPmTVPmTq148fz584bHx8XFKSAgIMWx3PK3QgAAYK7cur/IvgNgntx6nmcWf58A8gY+0wFYQy0BkL7csr9ILQGQtXLLuZ5Z/K4OZB51BADyC5owAMhTqlWrluLxoUOHDI+9v2uWk5OTKlasaEpednZ28vPzy3BuBw8eTPHYz88vRccv4GGTW8/1zLr/l0Zvb+8cygRAWvhMB2ANGyxA2i5evKghQ4YoPDw8+VjFihU1e/ZseXp6ZmsuPj4+8vHxSX4cFxenEydOGB5//2f6/b+jAA+z3HSuZxa/pwNZx8yCw8z8rfD48eMpiid9fHxUpEgR03IDAAC5R27dX2TfATBPbj3PM4u/TwB5A5/pAKyhlgBIW27aX6SWAMg6uelczyx+VweyBnUEAPIimjAAyFNat26d4vHOnTtlsVgMjd2xY0eKx40aNZK7u7tZqT2Q2/3rpWfnzp0pHj/++ONmpATkWbn5XM+MAwcOpHhMR3sgd+IzHUB62GABUhcYGKjnn39et27dSj5WunRpzZ07N8fOk1atWqV4bMtn+v2xfKYD/8iN53pGxcXF6dixYymO8Xs6kDGRkZEpiqkkqWjRoqbNb+bv6W3atDEjJQAAkAvl5v1F9h0Ac+Tm8zwzqCMA8g4+0wGkh1oCIHW5cX+RWgLAfLnxXM8oagkAc1BHACC/oAkDgDylXr16Kly4cPLjgIAA7dmzx9DYxYsXp3hs9g9J98+3bt063b171+q4yMhIrVu3LsWxtm3bmpobkNfk5nM9o/bu3asrV66kONakSZMcygZAevhMB5AeiiGBB924cUODBw/W9evXk48VL15cP/74o4oXL55jed3/mb5kyRJDRdlXrlzRvn37kh87OTk9UIQBPIxy67meUatXr1Z0dHTyY2dnZ9WrVy8HMwLyrj///DPFZ6y3t3eKu0hlVqtWrVLcEWPv3r0KCAiwOs5isWjJkiUpjvF7OgAA+Vdu3l9k3wEwR24+zzOKOgIgb+EzHUB6qCUAHpRb9xepJQDMlVvP9YyilgAwB3UEAPILmjAAyFPs7e3VvXv3FMe+/vprq3/42LVrl/bv35/82N3dXZ06dTI1t6pVq6pmzZrJj6OiojRr1iyr42bNmqWoqKjkx3Xq1FGlSpVMzQ3Ia3LzuZ4RUVFR+vTTT1Mcq1KlisqUKZNDGQFID5/pANJCMSTwoLCwMA0ZMiTFueHt7a25c+fm+M+7LVq0UIkSJZIfBwYG6o8//rA6bsaMGSl+9+jQoYM8PT2zJEcgr8jN53pGhISE6IsvvkhxrFmzZnJ1dc2hjIC8KyYmRl999VWKY61bt5a9vXlbkF5eXimKHiwWi2bMmGF13OLFixUYGJj82NfXl5/fAQDIx3Lz/iL7DoA5cvN5nhHUEQB5D5/pANJCLQHwoNy8v0gtAWCe3HyuZwS1BIA5qCMAkJ/QhAFAnvPiiy/Kzc0t+fHevXv1ww8/pBkfHByssWPHpjg2cOBAeXt7p7uOn59fiv+MdM9/7bXXUjz+4YcfUnS8vN/evXsf2Ih54403rK4DPAxy67n+6aefKjg42MC/4B+hoaEaMWKEzpw5k+L4/e8XALIOn+kAzEAxJPCgyMhIvfDCCzp37lzysYIFC2rOnDmqWLGiqWtdvXr1gc/0q1evpjvG2dlZw4cPT3FsypQpOn/+fJpjVq5cqRUrViQ/dnBw0MiRIzOXPJDH5eZz/caNG/rqq68UHh5u0xovvPBCit/t7ezsONfx0JsyZYqOHj1q05iwsDCNGDFC/v7+ycccHBw0ePDgdMe1adMmxXl+/10mUvPaa6+lKMhYvny5Vq1alWb8+fPnNWXKlBTHRowYIWdnZ6trAQCAvCu37i9K7DsAZsmt5zl1BEDexGc6ADNQSwA8KDfvL0rUEgBmyc3nOrUEgDmoIwAAyTGnEwAAW3l7e2v48OGaPn168rFp06YpKChII0aMUPHixSVJSUlJ2rJliyZMmKCgoKDk2GLFimnIkCFZklvLli3VvHlz/f3335Kk+Ph4DR06VG+//baee+655A54UVFR+v333zV9+nTFx8cnj2/VqhUdtID/k1vP9fnz52vhwoVq2bKlnnjiCdWrV0+lS5d+IO7atWtavXq1fvzxR4WEhKR4rl27dmrfvr3puQF50YEDBxQbG/vA8dOnT6d4HBsbq507d6Y6R7FixUy/SwSf6UDe4ufnl+LxvHnz1KhRozTjP/30U7344ovJP09YExoaqjfffJNiSOA+I0aM0LFjx1IcGzx4sG7fvp3m53ZaqlevrkKFCpmZniSpZ8+eWrBgQfKGb3h4uPr166cxY8aoc+fOcnT858+jYWFh+vHHH/Xdd9+lGN+rVy+VL1/e9LyAvCQ3n+txcXH6+uuvNXfuXLVp00ZPPPGEateunepn/OXLl7VkyRItWLBAd+7cSfHcwIEDVb16ddPyAvKiHTt2aPbs2apVq5aefPJJNW7cWJUqVZKTk1OKOIvFoosXL2rdunWaP3++bt++neL5QYMGPfDzuRkqVaqkZ599VgsXLkw+9u677+rChQsaPHhw8ntLfHy8Vq5cqUmTJikiIiI51s/P74E75gIAgPwnt+4vSuw7AGbJrec5dQSA+aglAGAGagmAnJGb9xfvoZYAyLzcfK5TSwCYgzoCAJDsLBaLJaeTAABbJSUl6eWXX9bWrVtTHHdwcFCpUqXk6empq1evpvjhSJJcXFw0Z84cPfbYY1bXsPWPr/fcvHlTvXr1eqCznouLi8qUKSOLxaKAgIAHNokeeeQRLVy40Gq3feBhkhvP9dR++fPw8JCPj488PT2VkJCgmzdv6saNG6mOr1+/vmbPni0XFxeruQEPgzZt2igwMDBTc3Tv3l2TJk1K83k+04GclV6B1OTJk5MfFy1aVFOnTk11DmsFUhn5PHd2ds50MeTXX3+d5hrAw8DMjRFr5+3Vq1fVtm3bFMc2b96c6rl7vwsXLqhv374KCwtLcdzNzU2PPPKIYmJiFBgYmKIIUpJq1aql+fPn87M7Hnq5+VxPLV6SvLy8VKRIEXl4eCgmJkYhISEKDQ1NdY6OHTvqiy++SNEZH3gYde3a9YGLGJycnFS8eHEVLFhQTk5Ounv3rq5du6a7d++mOkf37t312WefWT2f7v9bwMSJE9WjRw+rOUZHR6t///46fvz4A3mWLl1azs7OCggIUFRUVIrnCxcurF9//ZViSAAAHhK5cX/xHvYdAHPkxvOcOgLAfNQSAPkftQRA/pWb9xf/jVoCIHNy87lOLQFgDuoIAEByzOkEACAj7O3t9eWXX2rMmDFavXp18vHExEQFBASkOsbLy0tfffWVoc3UzChatKjmzZunl19+OcUPmzExMcndMu9XrVo1ffPNN2ywAPfJzef6v0VGRioyMjLdGHt7ew0ZMkRvvPHGA53/AOROfKYD5nj33XcNFUjdvHlTzz//fKrPWSuQyoi4uDht2rRJmzZtkmR7MeS0adNMzQdA1qlYsaJ++uknvfzyyynej6Kioh7YJLqnadOm+vLLLymaAPKosLCwB4ql7ufs7Ky33npLgwcPlp2dXfYkBuQx8fHxD1xMkBoPDw+9/fbb6tOnT5aeT66urpo9e7Zef/117d69O0Wely5dSnWMr6+vvvnmGwonAAB4iOTm/UX2HQBz5Obz/N+oIwDyLz7TAXNQSwAgp1FLADx8qCUAMo86AgAPG5owAMizChQooOnTp+uJJ57QN998o1OnTqUa5+bmpm7duunVV19VkSJFsiU3X19fLVq0SD/99JPmzZuX5h9cixUrpkGDBmngwIFydnbOltyAvCa3neuffPKJdu/erYMHD+ratWtW4318fNSpUyf1799fZcuWzbK8AGQNPtOBhwfFkED+VrVqVa1YsULff/+9fvvtN4WHh6caV65cOb3wwgvq2bMnG6lAHlC0aFGNHTtWe/bs0eHDh3Xz5k2rY3x9ffX000+rT58+Kl68eDZkCeQN06dP15YtW7Rz504dPXrU6s/GdnZ2qlKlirp27aru3btn2wUEXl5emjt3rhYvXqxZs2bp8uXLacb17t1bw4YNk7u7e7bkBgAAco/ctr/4b+w7AObIbec5dQTAw4fPdODhQS0BkL9RSwDkT9QSAOagjgAAJDuLxWLJ6SQAwAyXL1/WkSNHFBwcrPj4eBUsWFAVK1ZUvXr1VKBAgRzLKykpScePH9eZM2d069YtSVKRIkVUtWpVVa9eXfb29jmWG5AX5aZz/fbt27pw4YKCgoIUGhqq6OhoOTg4qGDBgipcuLAeffRRlSlTJltzApB1+EwHMqZNmzaG7l6RHmt3r/Dz80vxeN68eWrUqFGa8b///jvFkMBDLD4+XkeOHNG5c+cUFhYmBwcH+fj46NFHH33g/QRA3nLjxg1dunRJ165d0+3btxUdHS0nJycVKlRI3t7eqlmzJsUSgAFJSUny9/fXlStXFBQUpMjISCUkJMjd3V2enp7y9fVV9erV5eHhkdOp6syZMzp58qRCQkKUmJgoLy8vVa5cWbVr16bYGQAAJMtN+4v/xr4DYJ7cdJ5TRwA8fPhMBzKGWgIAuQ21BED+RS0BkHnUEQB4WNGEAQAAAAAAPLQohgQAAAAAAAAAAAAAAP9GLQEAAAAAAKAJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCT7nE4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgN6AJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJJgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSaMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJJgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSaMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJJgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSaMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJJgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSaMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCJJgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSaMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiSYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmjCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkmDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJowgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBJcszpBAAAAJB1ZsyYoZkzZ1qNa9iwoebPn58NGdlm9OjRWrp0qdW47t27a9KkSdmQER52bdq0UWBgoNW4iRMnqkePHtmQEZD/5PXPLjzohRde0Pbt29N8vmbNmlq8eHE2ZoTM2LZtm1566aU0n7ezs9Nvv/2mOnXqZF9SAAAAAAAAAAAAAICH0p49ezRw4EBDsWfOnMnibB4O1PYAAAAAeFjY53QCAAAAAAAAyJ82b96cbgMGSXrttdeyKRuYoXXr1qpdu3aaz1ssFn3yySdKSkrKxqwAAAAAAAAAAAAAAAAAAAAAwDyOOZ0AAADIPUaPHq2lS5dmeh47Ozu5u7vL09NTnp6eKlKkiKpVq6aaNWuqZs2aKlOmjAnZAsgvrl69qrZt25oyl5OTkwoWLJj8/lO2bFnVrFlTNWrUUI0aNeTi4mLKOkBeNGDAAO3duzfT89jb28vDwyP5PPPx8VH16tVVo0YN1apVS8WLFzchW+QHcXFxmjhxYroxdevWVcuWLdN8fv/+/RowYIChC/rt7e01f/581a9f3+Zc/y0+Pl49e/bU6dOnDcV36NBBM2bMMDy/xWJRv379dODAAUPxdnZ2+uWXX1SvXj3Da6QlNDRUnTp1UlhYmKF4Ly8vrV69WkWLFk1x/LXXXtPQoUPTHHf8+HH98ccfevbZZzOTLgAAAAAAAAAAgKnMqo2yFXdeB3KfXbt2afDgwTaPW758uapWrWp+QgAAAAAAINehCQMAADCdxWJRZGSkIiMjde3aNUn/bFrcU6tWLT333HN68skn5e7unlNpIoM2bdqkU6dOWY2rVq2a2rVrlw0ZAf9ffHy8bt26pVu3bkmSjh07plWrVkmSPDw81LlzZ/Xq1UuPPvpoTqYJ5GlJSUmKiIhQRESEJOn06dPavn27pH8uFm/UqJF69eqldu3aydnZOSdTzTP27NljqEGGr6+vevTokQ0ZmWPOnDkKCAhIN+aVV15J9/n69etr0KBBmjt3rtX1kpKS9P7772v58uVydXW1Kdd/++abbww3YPD29tbHH39s0/x2dnaaMGGCunbtqtjYWKvxFotFH374oZYuXSonJyeb1rrfZ599ZrgBgySNGTPmgQYMktS8eXPVrVtXhw4dSnPstGnT1KlTJ3l4eGQkVQAAAAAAAAAAAADIMsuWLcvQOJowAAAAAADw8KAJAwAAyHZHjx7V0aNH9fnnn2vMmDHq1q1bTqcEG2zatMnQXQG6d+9OEwbkKpGRkfrtt9/022+/6fHHH9fHH3+s4sWL53RaQL5isVi0e/du7d69WyVLltTHH3+sVq1a5XRaud7evXs1c+ZMq3ENGzbMM00YwsPDNWvWrHRjqlSpohYtWlid680339S2bdt06dIlq7GXL1/WtGnT9MEHHxjO9d9Onjyp7777znD8Rx99JG9vb5vXKV++vF599VVNmzbNUPy5c+f0/fffW21akZ6///5bK1euNBzfsmXLdH9OHzx4cLpNGG7fvq25c+dq5MiRtqQJAAAAAAAAAAAAAFkqKipKGzZsyNDYlStX6p133pGDg4PJWQEAAAAAgNzGPqcTAAAAD6+wsDCNGjVKw4YNU2hoaE6nA+AhsnXrVnXu3FmrVq3K6VSAfOvatWsaNmyYxowZo5iYmJxOB9ls9uzZunPnTroxgwYNMjRXgQIFNHnyZMNFLD///LP27NljKPbf4uLiNGrUKCUkJBiKf+qpp9SxY0eb17ln6NChql69uuH4b7/91lAjitRER0frP//5j+F4d3d3jR8/Pt2Y9u3bq3Tp0unG/Pjjj7p9+7bhdQEAAAAAAAAAAAAgq23YsEFRUVEZGhsSEqIdO3aYnBEAAAAAAMiNaMIAAABy3J9//qn+/fvr1q1bOZ0KgIdIRESE3n77bc2fPz+nUwHytSVLlmjo0KGKjo7O6VSQTW7dumX1vbVIkSJ6+umnDc9Zu3ZtDRkyxFCsxWLR+++/r7t37xqeX5K+/vprnT171lBs0aJFNW7cOJvmv5+Dg4M+++wzOTk5GYqPi4vThx9+mKG1ZsyYoYCAAMPx7777rkqWLJlujIODgwYOHJhuTGRkpH744QfD6wIAAAAAAAAAAABAVlu+fHmOjgcAAAAAAHkDTRgAAECucOHCBb3yyiuG7zwMAGb57LPPtHXr1pxOA8jX9u/fr9GjR+d0Gsgm8+bNs3rXkK5du8rZ2dmmeV977TVVrlzZUOzVq1c1ZcoUw3MfP35cs2bNMhw/fvx4FS5c2HB8WqpWraoXXnjBcPzevXu1aNEim9Y4deqUfvrpJ8PxDRs2VO/evQ3FduvWzer38ddff9WdO3cMrw8AAAAAAAAAAAAAWSU4OFi7d+/O1BybNm1SZGSkSRkBAAAAAIDcyjGnEwAAALjn0KFDmjVrloYPH57TqeQbI0eO1MiRI3M6jQybNGmSJk2alNNpIJ9LSkrSBx98oDVr1qhQoUI5nQ6Qb61bt04rV65Uly5dcjoVZKGYmBj99ttvVuOeeeYZm+d2dnbWpEmT1KtXL0ONuxYuXKgnnnhCTZs2TTcuLi5OY8aMMdwMrGvXrmrbtq2hWCNefvllbdy4UefPnzcUP3XqVLVp00ZFihSxGpuUlKRx48YZ/re5uLjok08+kZ2dnaH4QoUKqW3btlq7dm2aMVFRUVq4cKFNzSYAAAAAAAAAAAAAICssX75cSUlJmZojJiZG69atU8+ePU3KCshb8npdKgAAAAAYZZ/TCQAAAPzb999/r7CwsJxOA8BD5ubNm5ozZ05OpwHke1988YXi4+NzOg1koaVLl1r9Wa527dqqVKlShuavUaOGhg0bZijWYrFo7NixVu9AMnPmTJ09e9bQnMWLF9cHH3xgKNYoZ2dnTZgwQfb2xv5MFx4ergkTJhiKnTdvno4dO2Y4l9dee03lypUzHC8Za6jx888/G24EAQAAAAAAAAAAAABZZcWKFabMs3z5clPmAQAAAAAAuZdjTicAAADypokTJ6pHjx4PHE9MTFRERIQuXLigP//8UwsXLlR4eLjhee/evaulS5fq+eefNzNdAPmEr6+vtmzZkupz0dHRCgkJ0aFDh7R48WLt3bvXprl/++03vfrqq3JycjIjVSBPmzdvnho1avTA8YSEBIWHh+vMmTPatGmTlixZoujoaMPzBgYGauvWrerQoYOZ6SIX+eWXX6zGPPXUU5la4+WXX9aWLVt0+vRpq7FBQUGaOHFimk0Ljh49qlmzZhle+5NPPlHBggUNxxtVp04dDRw4UD/++KOh+NWrV6tr165q1apVmjFBQUH68ssvDedQs2ZNDR482HD8PU2bNlXhwoV1+/btNGOuXbumLVu2cO4DAAAAAAAAAIA8I63aKAB514kTJ3Tu3DlT5tq3b5+CgoJUqlQpU+YDAAAAAAC5j7Fb7AEAABjk4OCgwoULq379+nr77be1evVq1a1b16Y51q9fn0XZAcjPXF1d9cgjj6hr166aP3++JkyYIAcHB8Pjw8LCtGfPnizMEMj7HB0dVaRIETVt2lQffvihli5dqnLlytk0B5/z+deJEyd09uxZq3Ht2rXL1DpOTk6aPHmy4aY5ixcv1l9//fXA8bi4OI0ZM0aJiYmG5unZs2e6TQ8y64033lCZMmUMx3/88ceKiopK8/nx48en+/y/OTk56bPPPrPpc/MeBwcHPf7441bjli5davPcAAAAAAAAAAAAQF5mitr8nwABAABJREFUsVh05coVbd++XWvWrNH69eu1a9cuXb9+PadTeygtW7bMtLksFouWL19u2nwAAAAAACD3cczpBAAAQP7m4+Oj7777Tp07d9aNGzcMjTl+/Liio6Pl6uqa4XXPnTun3bt368SJE/L399f169cVERGh2NhY2dnZycXFRUWKFFGJEiVUuXJl1apVS82bN5e3t3eG10xPbGysdu3apWPHjunixYu6dOmSwsPDFRUVpbt370qSXFxckvMqWbKkSpYsqfLly8vPz09+fn7y8vKyed0ZM2Zo5syZVuMaNmyo+fPnP3D80KFDunLlSopjAQEBhtYOCAgwvNHUvn17ubm5PXB89OjRhi7Y6969uyZNmmRorfQkJCTo0KFDOnDggE6ePKmrV68qODhYd+/eVWxsrJycnOTq6qpixYqpVKlSqlq1qurWravGjRvLxcUl0+tnVkhISPJm7dmzZ3Xz5k3Fx8fLy8tLhQsXVrVq1dSiRQu1bt1anp6eOZ1uluvZs6dCQ0M1bdo0w2P27dun5s2bZ1lO+/fv15YtW3T48GFdvnxZ4eHhcnR0lLe3t4oVK6YGDRqoZcuWql+/vuzs7ExZMyYmRhcuXND58+d14cIFXbt2TTdu3FBwcLAiIyMVExOjmJgYJSYmJr/G7+VTvnx5Pfroo3rsscdUsWJFU/K5n8Vi0ZEjR7Rv377k98eQkBBFRUUpKipK8fHxKlCggNzc3FSwYEGVLFlSJUqU0COPPKKqVavKz89PJUuWzJLcbty4oR07dujYsWM6d+6crl+/rtu3bysmJkYWi0Wurq4qUqSIypQpo+rVq6tRo0Zq2LChHB0fnl+1y5cvr1mzZqlz586KiYkxNGbv3r1ZnJVtLBaLjh8/rr179+rkyZO6fPlyivPD0dEx+XtdqlQp+fn5qXbt2mratGmG3ktPnz6tM2fOpDh2/+O03Lx50/Bna7NmzVS0aFGb88sMIwUr1atXl6+vb6bXqlq1ql5++WV9+eWXhuI/+OADrVq1SgULFkw+9tVXX+n8+fOGxpcqVUpjxozJUK5Gubq66pNPPtHgwYMNxQcGBuqrr77S6NGjH3huzZo12rp1q+G1X3rpJVWpUsVw/P3atWunJUuWpBuzfft2hYaGZtnP2wAAAAAAAAAAAA+zmJgYbd68WX/99ZdOnjypa9euKTo6Wh4eHvL29lbZsmXVvHlzPf7446bs16Xl/tqbgIAABQcHKyoqSrGxsXJ2dpanp6dKliypihUrqk6dOmrVqlWW7fvbIjIyUps2bdLff/+tM2fO6Pr167p7964SExNVsGBBvfTSS3rhhRcMzXXq1Cn98ssv2rx5s27dupVqTKlSpdSuXTv169fvgZsfLFy4UPv27bO6ToMGDdSrV68Hjk+dOlWzZs2yOr5z58421dXcr1OnTrp48aLVuC+++EJPPvlkhtcxQ0JCglavXm0otlq1ajp16pTVuOXLl2vEiBGZTS1TEhIS9Oeff+rPP//U8ePHFRgYqMjISLm5ucnb21u+vr5q2rSpHn/8cVNrf8LCwnT+/HmdP39ely5dUnBwsIKDg5NrfmJiYhQbGyuLxSJnZ2d5eHiocOHC8vX1Vfny5VWzZk3Vr19fxYoVMy2njDp//ryeeuopq3EuLi7avn17iroDW3z//feGzrcWLVoYOn+lvFuXakRoaKi2b9+uM2fO6OLFi7py5YoiIyMVFRWl6Oho2dvby9XVVW5ubvLx8VHJkiVVqlQpVaxYUVWrVlXlypVzRU0nAAAAgLzt4bkyBAAA5JhChQpp6NChmjhxoqH4+Ph4+fv7q1q1ajatExYWpt9//12LFi16oHFAamvcuXNH/v7+2r17tyTJ3t5eDRo0UN++fdWhQwfZ29vbtH5qzpw5o2+//Vbbtm2zeifiezmFhITo9OnTDzxfunRpNWzYUA0aNFDjxo1VqlSpTOdnzcKFCzN81+L9+/dr//79hmI3b96cahOG7HLp0iUtWLBAK1asUHh4eJpxsbGxio2NVVhYmM6ePatt27ZJkgoUKKD27dtr4MCBql27dobzyOjmREhIiP773/9q+fLlio+PfyA+JCREISEhOnv2rJYvXy4vLy+NGDFC/fr1M3wX8bxq8ODBmjt3rkJDQw3Fnzt3Lkvy2Lp1q6ZPn57qHeLj4+MVGBiowMBAHTp0SN9//71q1aqlUaNGqX79+hlab+3atdq/f78OHDigs2fPGr7L+79f4xcvXkx+f5SkcuXKqXv37urdu3eGNt/uFxoaqu+//16rVq1SSEhIurH3GjLcvHkz1c17Ly8v1a9fXw0aNFCjRo1s/vz4t/j4eK1atUoLFy7U4cOHZbFY0oy9c+dO8mfJ9u3b9e2338rLy0vPPPOMBg0apOLFi2c4j7ykTJkyevbZZw1vmt64cUN37tzJ8WYwwcHB+uWXX/THH3+k+xqMi4tTXFycwsPDdfHiRf3999+SJCcnJzVv3lz9+/e3qXnLxo0bDb3Xp+bixYt67733DMXOmzcvW5swJCUlac2aNVbjWrVqZdqaw4YN0+bNm3X8+HGrscHBwZowYYImT54sSTpy5IjmzJljaB07OztNmDBBHh4emcrXiCZNmui5557T77//bih+3rx56tKli6pXr558LCIiQp999pnhNatUqaKXXnrJ5lz/rVmzZnJyckr155B74uPjtXbtWvXr1y9TawEAAAAAAAAAAORHe/bs0cCBAw3F/rvJe2xsrObOnau5c+cqLCzsgdiwsLDkGoCtW7dq4sSJeu655zRy5EhTm2dfuHBBv/zyi1auXJlu7c29G0WEhITo6NGjyXVJ9evX1/PPP6927dplOIerV6+qbdu2hmI3b96s0qVLS/pnH2vWrFmaM2eOIiIiUo2PiIhQcHCw1XnDwsL06aefatWqVenWG0hSUFCQ5s2bpwULFqhv37566623kuunDh06pJUrV1pdz9HRMdUmDP369dPcuXOt1ots2LBBt2/fVuHCha2udb/Tp08basBQqFChTH1fzbJ9+/Y0G2L8m6OjoyZNmqRu3bpZ/R5eunRJR44cyVS9WEZft4mJiVq0aJH+97//pfrajIiIUEREhPz9/bVjxw59/vnneuqpp/TWW29lqBFLZGSkVq9erQMHDujAgQO6evWq4bHR0dGKjo5Orl+7d0MBOzs71alTR71799ZTTz2VY3VslSpVUtOmTbVz585042JiYrRixQr1798/Q+usXbvWUNwzzzxjNSav16WmZ8uWLZo7d64OHDhg9T3sXj3PtWvXdPTo0RTPOTg4yM/PTw0aNFDDhg3VsGHDDDfQAAAAAPDwyvyVhQAAAAa0aNHCpvhr164Zjk1MTNSsWbPUrl07TZs2zWoDhrQkJSVpz549ev3119WtW7dM3ak7Li5OH374obp166Y1a9ZY/UO3EVevXtWSJUs0ZswYjRs3LtPzQQoPD9e4ceP01FNPaf78+eluAqcnNjZWq1at0nPPPacRI0bYtMmUWWvXrlWnTp20ePHidC98/LewsDBNnDhRw4YNM+W1mZs5OzurcePGhuOvX79u6vqRkZF66623NHz48FQbMKTl6NGj6t+/v3755ZcMrfvee+/p559/1qlTpww3YLDG399fX3zxhdq1a6cFCxZkaq4FCxaoXbt2mjt3rtUGDEaEhYVp06ZNycUiGbVp0yZ16tRJo0eP1qFDh6xupqeVy+zZs9WxY0d9//33pn39c7uWLVvaFB8UFJRFmVgXExOjzz//XO3bt9e3336b4ddgfHy8tm7dqqFDh6pfv36pblQ/TI4dO6abN29ajWvYsKFpa94rfnF2djYUv2zZMm3ZskWxsbEaPXq04fOzd+/eatq0aWZStcl7771nuIlLYmKixo0bl+LfMnXqVMOvawcHB02YMMHw1zAtLi4uqlWrltW4P//8M1PrAAAAAAAAAAAA4P87ffq0unXrpi+++CLVBgypSUhI0C+//KJnnnlG/v7+mc7h9u3bev/999WlSxf9/PPPGa692b9/v1555RX16dMny26gkZrg4GD16tVL//3vf9NswGDU6dOn1bVrV61cudKmeoPExETNnz9fvXr1Mq3mqFSpUoYaH8TFxWnZsmUZWsPoBeWdO3fO9H6kGYz+Oxs1aqSqVauqbt26ps5rpsDAQPXr108fffSRoeYgkmSxWLRq1Sp1795dhw8ftnnN8+fP68MPP9Ty5ctNe51aLBYdOnRIo0aNUufOnbVr1y5T5s0Io01wjN5Q4X7+/v46efKk1TgvL690m3Lk57rU69evq3///hoxYoT27t2b6ZqrxMREnTx5Uj/99JNeeeUV/fbbbyZlCgAAAOBhQhMGAACQLWztjnv37l1DccHBwerbt6+mTp2qO3fuZCS1VJ05c0aDBg3StGnTlJSUZNPYu3fv6sUXX9TChQttHovss3//fnXu3Fm///67qRdJb9myRV27djV0N/DMmjlzpt54440Mv/Z37typF154QQkJCSZnlruULFnScKzR9x4jrl+/rj59+mj16tUZGm+xWPTxxx/r119/NS0nM9y5c0fjx4/XG2+8Ybjxx79NmTJF48ePN/VrnVn3Lsh+5ZVXFBAQYMqcUVFRmjZtmgYPHqzbt2+bMmdullWf82Y7f/68unXrph9++EGxsbGmzbt//3717NlT8+bNM23OvMbIxfXOzs6GC1WMqly5skaOHGk4/sMPP9SECRMM3ZFF+ueOD++++25G08sQT09Pffzxx4bjT5w4oZ9++knSP6/FRYsWGR47aNAgQ80TjGjQoIHVmD179ph67gEAAAAAAAAAADys/vzzT/Xp08fwvtf9goKC1Ldv30w10N+zZ4+6dOmiP/74w7Tam4MHD6pnz57ZcmF7cHCw+vTpoxMnTmR6rhMnTqhfv36ZuvnH2bNnNWDAANMucB8wYIChuIxeVG60CUOPHj0yNL+ZIiIitHXrVkOxnTp1SvH/1qxZs0ZxcXEZzs1Wx44dU8+ePXXo0KEMjQ8PD9fzzz+v48ePm5xZ5vj7+2vIkCH68ccfc2T9Vq1a6ZFHHrEad+bMmQw1sTCjaUl+rku9cOGCevfurX379uV0KgAAAACQAk0YAABAtsjI3cStuXDhgp577rkM/VHbiKSkJH3//fd64403bLpIfcqUKdq9e3eW5ARzrF+/Xs8//7xu3LiRJfNHRkbqrbfeytJNof/+97+aMWNGpuc5cOCA5syZY0JGuVdWvP9YExISov79++vs2bOZnmvy5MmmNQYw09q1azV27FibxqxZs0azZ8/OoowyJjIyUoMGDdLSpUuzZP69e/eqb9++WfZ+k1vkxHlmq/3796t37966dOlSlswfHx+vCRMm6LPPPsuS+XO7v//+22pM9erV5eLiYvraQ4cOVZ06dQzFhoSEaOHChYZi7ezsNHHiRLm7u2ciu4x5/PHH1blzZ8PxM2bM0KVLlzRu3DjD52PZsmX1+uuvZzTFB9SvX99qTExMjPbu3WvamgAAAAAAAAAAAA+jP//8U6+88kqm74B+69Ytffjhhxkau2rVKg0dOlQhISGZyiE1MTExGjVqVJbW3cTGxmrYsGEKDAzM9FyhoaF66aWXFBkZmem5goKCNHz4cFNubNCgQQNVq1bNatzFixdtvvD5xIkTunz5stU4Pz8/1ahRw6a5s8K6desMNYt3dHRU+/btJUlPPPGE7OzsrI4JCwvTX3/9lekcjTh16pQGDx6s0NDQTM0TFRWlMWPGZOjmK1kpKSlJEydO1OLFi7N9bXt7e/Xr189QrNGag38zekOnZ555Js3n8mtdanx8vN544w1du3Ytp1MBAAAAgAfQhAEAAGQLW/9Aau1it+DgYA0dOjRT3cONWr9+vcaNG2co9vjx4xn6Izuyz86dO/X2229neQdyi8WiiRMnasmSJabPfezYMX3zzTemzTdjxox8fYG4Le8/Zl1o+9VXX5nWOCE6OjrXXtS9fPlyrVy50lBsTEyMJkyYkMUZ2SYuLk4vvfRShu8OYNTFixf10ksvmVIkkVvZeneU7L6o/cyZMxo+fLju3LmT5Wv99NNPpjTJyUvi4uJ08uRJq3FVq1bNkvUdHBw0adIk0xs8DBgwQA0bNjR1TluMHTtW3t7ehmKjoqLUq1cvw3c6srOz06effmrq18zo9zerGqgBAAAAAAAAAAA8LF5//XXTLp7evn27Nm7caNOYzZs367333svyC7gnTpyoFStWZMncU6dO1enTp02Z6z//+Y+pzSjOnTunDRs2mDLXgAEDDMXZWu9m9ILyHj162DRvVlm2bJmhuMaNG8vLy0uSVLx4cdWrV8/U+TPr3XffNaXZhySdPXtWCxYsMGUus33yySeGmnyYrWfPnobqWdauXWvT9+HChQuGbuRTtWpVPfroo6k+l5/rUhcsWGDKjY4AAAAAICvQhAEAAGSLP//806b4kiVLpvlcYmKi3nrrrWztfLtkyRJDf8Revnx5nrgb+MMqODhYb731VrZ28f7Pf/5j2qbtPdHR0abOFxcXl22bgdktLi7Opg7gJUqUMGXdhIQEU+a5588//1RwcLCpc5pl2rRphpqa/P3337p582Y2ZGTcxIkTtX///mxZ6+TJk/r000+zZa2cYOtdHdL7nDfb3bt39dprr2VLA4Z7vv76a23fvj3b1stpp06dMvTZ6ufnl2U5lC9fXm+++aZp85UrV05vv/22afNlhLe3tz744APD8eHh4YZje/XqZXqDCR8fH0NNI44dO2bqugAAAAAAAAAAAA8bs+tGfvvtN8OxV65c0XvvvafExERTc0jLhx9+aLgRuS22bt1qyjxr1qzR+vXrTZkrK3Tu3FmFCxe2Grdhwwab9hvXrVtnNcbJyUlPP/204TmzSkBAgA4ePGgotlOnTiked+zY0dC4bdu2KSwszNbUbGb2uZ9bL+qPiYnRF198ke3renh4qHv37lbjoqOjbWoQs3btWkNx6TUtyc91qUuXLs3pFAAAAAAgTY45nQAAAMj/wsLCNGfOHMPxjo6OKleuXJrP//LLLzZdNGtnZ6e6deuqadOmKl68uGJjY3XlyhVt3rxZgYGBhueZNGmSHn/8cRUrVizNGKMbdG5ubmrevLn8/Pzk4+MjZ2dnRUVFKTIyUrdv39b58+d1/vz5bG008TD49NNPdfv2bcPxBQoUUIsWLVS7dm15e3srIiJCZ8+e1ebNmxUREWFojtjYWI0dO1aLFy+WnZ1dRlNPl4ODgxo3bqyGDRuqSJEiun37trZs2aJDhw4ZnuOPP/7QsGHDsiS/nDR37lybvueVK1fOkjy8vLzUoUMHVapUSS4uLrp06ZJWrVpl+E4IiYmJWrZsmV566aUM5+Dk5KTy5curSpUqKl26tDw8POTh4SEXFxfFxMTozp07CggI0OHDh23qLn7t2jVt2LBBnTt3Tjduy5Ythuazt7dXgwYNVLt2bZUoUUJubm6Ki4vTnTt3FBERIX9/f507d05XrlzJVLOLvXv36pdffrFpTIMGDdSwYUMVL15cSUlJunLlirZs2SJ/f39D45csWaLOnTurWbNmGcg49woICNDixYsNxxcrVkwFCxbMwoxSmjFjhuHvkfTPzyGNGjVSgwYNVLRoUd29e1cXL17U5s2bDTcSsVgsGjdunNatWycXF5cMZp53HD9+3FBclSpVsjSPgQMHauPGjZlurmJvb6+JEyfmiu/dU089pVWrVhl+DzWiZMmSevfdd02b79/8/Py0a9eudGNowgAAAAAAAAAAAPKCMWPGaMyYMZmaw9fX19R9nrRUrVpVjz/+uEqWLKno6GgdPHhQmzdvNrynvnPnTgUHB6t48eJWY8eOHWvTHeCLFCmiVq1ayc/PT56engoLC9OhQ4e0bds2Q43eo6OjNXbsWP3666+G18xO//vf/2yKr1q1qgYMGKAmTZrIx8dHkZGROnPmjJYtW5YlF1kXKFBAvXr10rfffptuXGxsrJYtW6ZBgwZZnfPo0aO6evWq1bjHH3/cUBP3rGb06+rk5KT27dunOPbEE09o4sSJSkpKSndsfHy8Vq9erX79+mUqV1uVK1dObdu2VenSpZWUlKTjx49r7dq1iomJMTT+4sWLOnTokOrWrZvhHDw8PFSpUiVVrlxZxYsXl4eHh9zd3eXo6Kjo6GiFhobK399f+/fv1/Xr1w3Pu2HDBl2/ft20G+oY1b9/fy1YsMDqa2bRokXq27evoTnXrFljNcZa05L8Wpd67do1wze4KlasmJo3b64KFSrIy8tLjo6OunPnju7cuaOQkBCdO3dO58+fz5aGKAAAAAAeHjRhAAAAWSokJEQjR440fKGxJNWoUUOurq6pPhcVFaWZM2canqtcuXKaPHmy6tSp88BzY8aM0bx58/T5558b2tS7t/b48eNTfT4pKUlBQUFW52nbtq0mTZpk6ALU27dva8+ePdq1a5d27NihgIAAq2PMNGnSJE2aNCnFsdGjRxvqPty9e/cHxuakw4cPa8OGDYbjW7ZsqU8//TTVDebIyEhNmDBBS5YsMTTX8ePHtWbNGj311FOG1zeqSpUq+vzzzx+4u/iwYcO0bNkyvf/++4buPuDv76/Q0NBcsflplj/++ENffvmlTWPq169veh59+/bVe++998D72siRIzVq1Cht3LjR0DwHDhywee1ixYqpXbt2ateunRo2bCgnJydD4y5evKjp06cbzm3NmjVWmzAY2YAvV66cvvnmG1WoUMFqbGxsrA4ePKhdu3Zp586dOn78uE3FCLa8P1WrVk2TJk1S1apVH3ju3Xff1S+//KKJEycaKmD5/PPP81UTBn9/f7300kuGN/Clf5pZZJegoCD9/PPPhuNr1aqlSZMmqWLFig8898EHH2jmzJn67rvvDM117do1zZs374EGNyNHjtTIkSNTHJsxY4ahn28aNmyo+fPnG1o/O126dMlQnK+vb5bmca95QteuXRUVFZXheQYPHqx69eqZmFnm/Oc//9G+fft0584dU+b7+OOP5eHhYcpc9ytVqpTVmNDQUEVERGRrMxYAAAAAAAAAAID8yMvLS5988ok6dOiQ4vjgwYN17NgxjRgxwlDNVlJSkg4ePKhOnTqlG7d582bt3bvXUG6Ojo569dVXNWTIEBUoUOCB5wMCAvTOO+/o8OHDVuc6ePCgNm3apHbt2hlaOyOqVq2q7t27q2nTpipWrJjc3d11584dXbx4UXv37k215mjXrl06d+6c4TX69OmjDz74QI6O/79839vbW02aNFGTJk3UtWtXjRgxwqb9dyP69u2rWbNmWa1pWLRokaEmDEYuKJekHj16GIrLasuXLzcU16RJExUqVCjFseLFi6tevXqGbgSwfPnybGvC4OLiotGjR6tPnz4PPDdixAgNHz5cFy9eNDTXgQMHbG7CUKVKFbVv317t2rXTo48+anjcrl279Nlnnxm6OUxiYqLWrVunwYMH25RbZpUvX14tWrTQX3/9lW7cyZMndfToUdWqVSvduDNnzujChQtW123Tpo0KFy6c6nP5sS71HiP1ZJL02muvafjw4XJwcLAaGxAQoF27diXXlNGUAQAAAEBm2Od0AgAAIH9JTExUWFiY9u/fr2nTpqlz5846dOiQTXM88cQTaT63bNkyw38U9fX11fz581NtwCD9c6He4MGDbboQd/ny5bp9+3aqz4WFhVm92N3JyUmTJ082fNFZ4cKF1bFjR3388cfatGmTFi1apAEDBsjHx8dwzvjHjz/+aDi2VatW+uabb9Ls8O/h4aGJEyeqV69ehuecO3eu4VijKlSooHnz5j3QgOGebt266aWXXjI8n9E7medWMTExCggI0IoVKzRw4EDDDSju8fLyUuPGjU3NaejQofroo49SbSzj7u6uadOmqVy5cobmOnHihOF1K1eurEmTJmnr1q366KOP1KxZM8MNGKR/XlszZ840vCG+e/duq13/b926ZXWe999/31ADBumfuzU0adJEb731lhYvXqxNmzbpzTffVOXKlQ3la/TrWadOHf3222+pNmCQ/vks6d+/v+HPkpMnT1q9S3xulpCQoNDQUO3atUvjx49Xt27d5O/vb9Mc6X3Om23BggWGGi1JUvXq1TV37txUGzBIkrOzs9566y29/fbbhtf/+eefDa+flxnZFLe3t1fRokWzPJdHHnlE77zzTobHV6xYUW+88YZ5CZmgePHiGjVqlClzde3aVa1atTJlrtQYuTuSJAUGBmZZDgAAAAAAAAAAAA8DNzc3/fDDDw80YLinZs2amjp1quH5jOyhG619sbe31/Tp0zVixIhUGzBIUpkyZfTTTz+pWrVqhubMirobSXJwcNAHH3ygpUuXavDgwapSpYq8vLzk5OQkb29v1a9fXy+//LKWLVuml19+OcXYhQsXGl7n8ccf10cffZSiAcP9mjZtqsmTJ2f435KW4sWLp/k6+bdz585ZvUGIxWLRunXrrM7l4+OjFi1aGM4xqxw4cEBXrlwxFJtWE5KOHTsaGn/kyBHDNzDIDAcHB02fPj3VBgySVLZsWf3vf/9L97X2b0brZ+zs7NS8eXP99NNPWrlypV577TWbGjBI/zS6WLhwoapUqWIoPqfqawYMGGAo7vfff7cas3btWkNzpVejlZ/rUm/evGk1platWnrllVcMNWCQ/vl8ee655/TFF1/o77//1jfffKMnn3xSLi4umU0XAAAAwEPI2G/XAAAA9xkzZozGjBlj+rxubm7q3r17ms8b7Uwt/XPX4GLFilmN69y5szZu3GhogygmJkYbNmxI9eJ7I3dgL1SokDw9Pa3GpaVWrVpWuyfjQZGRkdq0aZOhWHd3d02cONHQRtTYsWO1fft2Q52mjx07pkuXLql8+fKG8rDGzs5OkyZNSrMD9j39+vXT//73P0Nznj9/Xi1btjQjvSwTGBiYZtOJzOrVq5dNjQqsqVKlitWLtQsUKKBnnnlG06ZNszrfzZs3dfv2bavfc0n6448/ZGdnZzjXtLz77rtauXKl1YvI7969K39//3QbKBh5jyxdurTNOf577PDhwzV8+HCrsUuXLjU0p6urq/773/8a2oTr0qWL1q1bZ+i9ZtmyZWrSpImhHHLKwIEDs2ReX19ftWnTJkvmvp/FYtGKFSsMxTo4OGjSpEny8PCwGvviiy9q06ZNOnLkiNXY4OBg7dmzR82bNzeUR15l5HOwaNGihos8Mqtv377asGGDdu/ebdO4e6+DtArBctKzzz6rNWvWaOfOnRmeo2jRonr//fdNzOpBtjRhMFpQBwAAAAAAAAAAgAe9/PLLVmuImjRpogoVKujixYtW5zt//ny6zwcEBGjfvn2Gcuvbt6+h5vwuLi6aOHGiunXrZjV2//79CggIUJkyZQzlYNSUKVPUuXNnQ7H312vs3bvX0DgnJyeNGzfOUB1Hx44d1axZM+3YscPQ3EYNGDBAa9assRr3+++/67HHHkvz+UOHDunatWtW5+natWu27Q+nx2itoZOTk9q1a5fqc0888YQ+++wzqzcnkf6pB3nzzTdtytFWzz33nNq2bZtuTPny5dWkSRNt377d6nzWzv17atWqpdmzZxuKTY+bm5veeOONB5qapMaWG9aYqUWLFipfvrzVphqrV6/W6NGj0601MdKEwVrTkvxcl5rV9WROTk5q06ZNttUqAQAAAMh/7HM6AQAAgH978cUX07zA+NatW4YueJT++aOwLReTv/rqq4Zjt27dmupxLy8vq5tlN2/eNLwBB/P8/fffhu9E3qdPHxUpUsRQbIECBfTCCy8YziOt105GtG7dWrVr17YaV7RoUZUsWdLQnBEREZlNK88qUqSIhgwZYuqcr776qqEO3DVr1jQ85507dwzFmdGAQZK8vb0NNw7x9/dP93kjzSOMdn/PjKSkJMPnYs+ePQ2fP5LUv39/Q3Hbtm0ztDmfH73++uumNjtJz/Hjx3Xjxg1DsR06dDB8pwU7OztDxQD3mPnen1vdvn3bakxmNvttZWdnl6H1HBwc5O7ungUZmWP8+PFyc3PL8PgPPvhAXl5e5iWUCqNfdyOvGQAAAAAAAAAAAKTOy8tLgwYNMhRrtCbBWs3I5s2bDc3j6Oho035qtWrV0r3o/9+2bNlieF4jnn76acMNGO53+fJl3bp1y1Bsy5Yt5evra3ju3r17Zyin9NSrV081atSwGrdu3bp0XwtG6zp69OhhOLesEhcXZzjfZs2aqWDBgqk+V6xYMdWrV8/QPCtXrjR0UXlGOTo6Gq5zNOvcv8esWiRJhs/5kJAQRUZGmrauUXZ2dhowYIDVuKioKK1atSrN50+dOmW1nkqSunXrlm6NWX6uSzVST7Z7926FhoZmQzYAAAAA8CCaMAAAgFyjTp06evHFF9N8/vDhw4Y3KZ588kmb1q5cubLhiy8PHz6c6nEHBwc98sgjVscPGzZMkydP1oEDBxQTE2NLmsigQ4cOGY619bXTsWNHQxfaS2m/djKiS5cuhmNLlSplKC4nNq1yAzs7O40fP97UC1M9PT31+OOPG4q1ZaPdaBMGMxn9uli72N1IM4cZM2bozTff1NatW7PsAt0LFy4oPDzcUKytxRb16tUz9H4QFhZmtVt+ftShQwd17do129bLyvf+Zs2aqVChQqbnkVdFR0dbjXFxccmGTP6xYsUKbdy40eZxcXFxGjVqlBITE20e26ZNG/n5+WX6v/SUKVNGb7zxhs25SVL79u3VqVOnDI21hdHvs5HXDAAAAAAAAAAAAFL3xBNPyNnZ2VCs0ZoRa/UIBw8eNDRP48aNDd/85J4GDRoYijNz79XOzk6vv/56hscbvZGQJJvvwN6qVSs5OjrampJVRi4qj4mJ0YoVK1J9LikpSevWrbM6R506dVSxYkWb8zPbli1bDDcYsLaXanSvNTAwUPv27TMUmxGNGzdW0aJFDcWade5nBVtqtIzefMNs3bp1M3QTgt9//z3N59asWWNore7du6f7fH6uSzVSTxYaGqru3btr9uzZOnv2bIZqOgAAAAAgo8z/Cw0AAEAGlC9fXl9//XW6d8c+ffq04fmMdkv+t3r16uns2bNW427fvq3r16+rRIkSDzzXpEkTXb58Od3x0dHRmjNnjubMmSN7e3uVKFFCZcqUUdmyZVW2bFmVK1dOfn5+Kl26tKkdpB9mRl87bm5uevTRR22au0iRIipbtqwuXrxoNfbUqVM2zZ2ehg0bGo41elfqu3fvZjSdPG306NFq166dqXPWrl3bcMGDh4eH4XmjoqIylE9iYqJOnjypw4cP69y5cwoICFBwcLDCw8MVGRmphIQEJSQkZGjue6w18WjatKkWLVpkdZ41a9Ykb0J6e3vrkUceUZkyZVSuXDmVLVtWlStXVsWKFdP9vEjPyZMnDcU5OzurevXqNs1doEABFSpUyFD39VOnTuWKooPsUrduXU2ePDlb18zKnxucnJxUq1Ytbd++3Wrs2bNnlZSUJHv7/NsHMzc1Ybhx44YmTJiQ4fHHjh3TDz/8oOHDh5uYlXkGDBigtWvX2lRgVqhQIX300UdZmNX/5+rqaiiOJgwAAAAAAAAAAAAZ16hRI8OxRmtGrNUjGK15qVu3rqG4fytWrJihODPrbho1aqTSpUtneHxISIjh2GrVqtk0d4ECBVS+fHmdO3fO1rTS9eSTT2rq1Km6efNmunG///67+vfv/8DxAwcOGLogvkePHhnO0UzLli0zFOfs7Ky2bdumG9OhQwdNmDBBSUlJhta1pa7LFjlx7qcnOjpahw4d0vHjx3Xu3DkFBgbq5s2bCg8PV3R0tOLj4w19zdKTUzcVcnd3V48ePfTTTz+lG3fixAmdPHky1ZrDtWvXWl2nbt26huqH8mtdaokSJVShQgWrtZfXr1/XlClTNGXKFDk5OcnX11dly5bVI488onLlyqlChQqqUqWK4SYlAAAAAGAUTRgAAECOa968uaZMmWK1C3pgYKCh+ezs7FSpUiWb86hSpYrh2MDAwFSbMDz77LNauHChLBaLoXmSkpIUFBSkoKAg7dmzJ8VzBQsWVO3atdWkSRM9/vjjqlChguH8kJLR107FihUztMFQuXJlQ00Yrl27JovFkulNDG9vb/n4+BiON3rhq9HXbX7h4eGhcePGqVu3bqbPbe1u5v9m9IJVSTZvTJ45c0YLFizQ+vXrFRYWZtNYW1nroP7444/Lx8fHpkKE0NBQhYaG6vDhwymO32uQ0LBhQ7Vs2VKPPfaY4fPK6PtBXFycatSoYThXWxnNIz/o0qWLxo8fLzc3t2xd1+jX2Nvb2+Y7sUj/vPcbacIQHx+vkJAQFS9e3OY18pPs+oz58MMPM/1+N3PmTLVp08amnw2zi729vSZMmKCuXbsqPj7e0JhRo0bZ9HNDZhj9Pj9sP3MAAAAAAAAAAACYyZaaBDNqRpKSknTt2jVD88yYMUMzZswwFGsrs+puJKlBgwaZGh8eHm44tmTJkjbPX7JkSdObMDg7O6t3796aOXNmunFnzpzR4cOHVadOnRTHjVxQ7uLioqeeeiozaZoiNDRUf//9t6HYZs2aWW1YUKxYMT322GPat2+f1fnWr1+vDz/8MEtuVJAV9Ui27t1aLBZt375dCxcu1F9//aW4uDibxtsqNjY2S+dPz4ABAzR//nyr9Vq//fabxo8fn+LYsWPHFBAQYHWNZ555xlAu+bkutVevXpo4caLh+Pj4ePn7+8vf3/+B50qUKKHHHntMTZs2VZs2beTt7W1ipgAAAAAeRvn3NowAACDX8/T01KeffqrZs2cbuvjRyJ3FJcnNzS1DF3racgFmWrnUqFFDXbp0sXnt1ERERGj79u2aMmWKOnXqpJ49e2r16tVctJYBRl87Ge2EbHRcfHy8IiIiMrRGRta7x8nJKdNr5jctW7bU6tWrs6QBgySbLnZ1dDS/N15kZKTee+89de3aVQsXLszyBgyS9U1ZV1dXvf7666asFRcXp0OHDum7775Tv3791KZNG33//feGuvMbfT/IatbuLJEfFCtWTN98840+//zzbG/AIOWe935JunXrVobWyCuMFI9kR2HE0qVLtXXr1kzPEx8fr9GjRyshIcGErMxXsWJFw3cDkmy7G0pmRUdHG4qzpQERAAAAAAAAAABATpg4caLOnDmTqf+2bNmSJbnZslfp7Oyc6fUiIiIMNwjPSrGxsbpz544pc1WvXj1T421pwuDh4WHz/BkZY0Tv3r0N1REtXLgwxePExEStX7/e6rgOHTpkWe62WLVqleHXbKdOnUyNi4yM1KZNmwzF2sqWcz8r6sUuXLig3r1768UXX9SmTZuyvAGDZPsNa8xUpkwZtWrVymrcqlWrHqhZWrNmjdVxrq6uhl9X+bkutW/fvipbtqwpc12/fl2rV6/W2LFj1aJFC73yyisP3PwHAAAAAGxBEwYAAJDtqlevrv/85z/atm2bnn32WcPjjF68l9ELPd3d3Q3HpnfH908++UT169fPUA7pOXbsmN566y317dtXwcHBps+fnxl97djyGsjouPReO1mxnvTPXbPxz3vDc889p0WLFumHH35QiRIlsmwtW75HDg4Opq4dHBysvn37avny5bmuacuzzz6rIUOGmD5vUFCQpk2bpk6dOunAgQPpxppxDpoht+SRFRo2bKipU6dq06ZNatOmTY7lkd/e+3MzIxfUZ/XXIDg4WJ999plp8504cULffvutafM9LLL653UAAAAAAAAAAADYtldpZ2eX6fVy8k709zPaFNwaW27Wk1kZ+R6Y8X1LjY+Pj6GLvteuXavIyMjkx3v37jV0s4kePXpkKj+zLFu2zFCcs7Oz2rZtayi2Q4cOhmuwjK5vq+w+9/9t37596tOnz0N3QfugQYOsxty9e1erV69OcSwrmpbk17pUZ2dnzZo1y6abHhmRkJCgTZs2qVevXho3blyuaCYEAAAAIO8x/5arAADgoWdnZyc3Nzd5enrK09NT3t7eqlatmmrUqKFatWqZ1rU2vfWzelx6Fza7uLho9uzZ+vzzz/Xrr7+afhflgwcPaujQoVqwYIEKFSpk6tzImKza+EyLrZ3KH6YmDE5OTvLw8Eh+/ylbtqxq1KiR/P6TXXfednQ0/quWmd+fuLg4DRkyROfPnzdtTrONGjVKZcuW1fTp0226M4QR169f14svvqh58+apRo0aps5tNrM/G7KTvb293N3d5enpKQ8PDxUrVkyPPvqoatSoodq1a2dpg5PcxKyfG/KDwoULKyQkJN2YiIiILM1h7Nixpq/x7bffqm3btqpWrZqp8+ZnRr8H/AwLAAAAAAAAAACQcbbUjeS3mhGz9to9PT0zNd7Ly8tw7N27d22Kl6Q7d+7YlpANBgwYoBUrVqQbEx0dreXLl6tfv36S/mnKYI2vr68aN25sSo6Zcf78eZ04ccJQbJkyZbR582bDc5csWVKBgYFW43bu3KmQkBDTLyrPqXokf39/vfDCC/n+BhSpadKkiSpXrqxz586lG7dw4cLkG5IdPnzY0OvkmWeesSmX/FyX+sgjj2jRokUaN26ctm/fbvr8v//+u6KjozV16tRsr/UEAAAAkLfRhAEAAGTIxIkTs71zdYECBQzF3b17N0Pz/7t7tzXWLuR2cXHRBx98oEGDBmnBggVatWqV1YsTbXHu3DlNnjzZ1Ds+52cFChQwtOmQHa8dFxeXDK2Bf/j6+mrLli05nUau9c033+TqBgz39O7dW0899ZR+//13LVu2TGfPnjVt7rt37+rtt9/WmjVr5ODg8MDzueUczO0X5c+bN0+NGjXK6TQyJS/93JDXlSpVyup5fOvWLSUkJNhUFGLUokWLDG/Cu7m5qV69evr777+txsbHx2v06NFavHixzQ2QHlbXr183FFeqVKkszgQAAAAAAAAAAABmyS377JJ5e+2Z3f+z5QLlGzdu2NyEwei+W0bUqlVLderU0eHDh9ONW7Rokfr166eEhARt2LDB6rw9evTIFRc3L1++3HDshQsX9N5775meQ2JiolatWqXnn3/e9Lmzm8Vi0QcffPBQNmC4p3///vroo4/SjTl27JhOnz6tqlWras2aNVbnLF26tBo2bGhzLvm5LrVkyZKaNWuW9u/fr19//VVbtmxRVFSUafOvXLlSzZs3V7du3UybEwAAAED+l7/amwIAgHytcOHChuKioqIUHR1t8/y3bt0yPZcyZcpo9OjR2r59uxYvXqxRo0bpySefVIUKFTK9mbds2TIFBARkao6HhdHvly2vgYyMc3JyynQnfSAtcXFx+umnnwzHV69eXePGjdOSJUu0d+9enThxQmfOnHngv4xs+Bnh6empoUOHauXKldq0aZM+/fRT9ezZU9WrV5ebm1um5vb390/zrg1G3w+Q9+WW935J8vb2ztAaeYWvr6/VmKSkJFM3/u8JCgrSpEmTDMe/8847mjZtmuE7jpw+fVpff/11RtN76Ny4ccNQnJHXDAAAAAAAAAAAAHIHT09Pmpbfx+h+oySdOXPGprnj4uJ08eJFW1OyycCBA63GnDp1SkePHtXu3bt1+/btdGPt7OzUvXt3s9LLsKSkJK1cuTKn05D0T21ffnDo0CHt27fPUKydnZ3atm2rzz//XGvWrNGBAwd06tSpVOuR8pKuXbsaaryycOFCWSwWrVu3zmps9+7dM9W0JD/XpdavX1/Tpk3Tnj17NGfOHL3yyitq1aqVSpUqJXv7zF3+NHPmzFx/4xwAAAAAuYv5tx8EAADIIkYv1rJYLDp37pxq1apl0/znzp0zPZd77OzsVLNmTdWsWTP5WGJioq5fv66AgABduXJFFy9e1JEjR3TkyBElJiZanTMxMVHbtm3TgAEDbMrlYeTr66urV69ajTt//rwsFovNGxxGXzslSpTI9EYAkJbt27fr7t27hmJfffVVjRw50lBsRpra2KpMmTIqU6aMnn322eRjN2/eTH5/9Pf314kTJ7Rv3z7DHc63bNmS6ga/0ffvRx55RBs3bjT2D0CuZPR7fevWLYWGhtrcKMHoe7+Tk5OKFStm09x5Tbly5QzFBQYGqmTJkqau/cEHHygyMtJQbOPGjdW3b1/Z2dlp/PjxGjFihKFxP/zwg9q1a6caNWqkGbNlyxZDc+V3gYGBVmO8vLxoiAMAAAAAAAAAAJCH2Nvbq0SJEoYuyp0yZYq6du2aDVnlrDp16hiO3bFjh7p06WI4/q+//lJCQkIGsjLuiSeeULFixaw2Wf/9998NXbDcuHHjXNGIfc+ePbp27VpOpyHpn4b/Z86ckZ+fX06nkinr1683FOfk5KRvvvlGLVq0sBqbHbVIZnJ1dVXPnj01e/bsdONWrlyptm3bKjg4ON04e3t79ejRw5Tc8nNdqrOzs5o1a6ZmzZolH4uLi1NAQICuXr2qy5cv69y5czpw4IAuXLhgaM6AgACdPXs2z5+XAAAAALIPV4ABAIA8o2rVqoZjDx48aPP8Bw4cMBTn5eVlygWEDg4O8vX1VePGjfXcc89p9OjR+vXXX7V161ZDmxGSDHeZNlNmOjDnFKN/NI+KitKpU6dsmjs0NFT+/v6GYm15DQO22r9/v6G4mjVrGm7AYLFYDF1QmxWKFi2qunXrqmvXrnr99df1/fffa+fOnXrxxRcNjU/r/dHoeRgQEKDQ0FDD+SL3sWXD1OjPAPfEx8fr6NGjhmIrV65stQFPXvxs/bf0mhP829mzZ01d99dff9WOHTsMxbq5uWnChAnJX+s2bdoYvhNLQkKCxowZo7i4uAzn+rAw8j02+noBAAAAAAAAAABA7mF0r93oPmpeV6ZMGfn4+BiK3bhxoyIiIgzP/euvv2Y0LcMcHR3Vp08fq3GrV682dAMLsy4oz6xly5bldAop5LZ8MsJoPdKAAQMM1zwauZlSbtOvXz85ODikG3Pnzh198MEHVudq3LixSpUqZVZqD8irdalGODs7q2LFimrVqpUGDhyoTz75RGvWrNGiRYtUpkwZQ3MYfU0DAAAAgEQTBgAAkIfUqVPH8EWKa9assWnu8+fPG74wsHbt2jbNbavixYtr+vTpcnJyshprrRt5VihQoIChuJiYmCzOxLi6desajrX1tbN27VpDHaIl27rgA7YKCQkxFNewYUPDcx47dixXNSJwdXXVO++8k6J7e1pu376d6gXTlStXloeHh9XxFotFK1asyFCeyB3q1atnONbW9/6dO3cqLCzMUKyR9/68+Nn6b48++qgcHR2txpnZhCEgIEBTpkwxHD9q1CiVLl06xbGxY8eqRIkShsafPXtWM2bMsCnHh01wcLBu375tNY4mDAAAAAAAAAAAAHmP0dqbNWvWPDTNzRs1amQoLjIyUl9++aWh2I0bN+rvv//OTFqG9e7dW87OzunGREVFKTw8PN0YDw8PdejQwczUMiQqKkobNmzI6TRSWLlypeG6stzKaD1S48aNDc+5bdu2DGaTc3x9fdW2bVurcdeuXbMak1NNS3J7XWpm1KpVy1ADDOmf2gYAAAAAMIomDAAAIM8oWrSooQtvJenIkSPavn274blnzpxpOPbxxx9P87k7d+4Ynic9BQsWVKFChazGGbnQzWxGLl6WpAsXLmRxJsa1aNHC0OaB9E83+Vu3bhmKjY2N1ezZsw3nkd5rB8gso+8H8fHxhuf86quvMprOAyIjI2WxWEyZy2jn8tQukndwcFDr1q0Njf/uu+9MbUJx4sQJvfPOO7p+/bppcyJtNWrUMHznkfXr1+vcuXOGYi0Wi77++mvDeRh57zf62erv758rCzRcXFzk5+dnNe706dOmrGexWPT+++8rKirKUHyzZs3Uu3fvB457enpqwoQJhtedPXu2jhw5Yjj+YWP0+2tLcywAAAAAAAAAAADkDkYuPpak0NBQff/996atGxUVpQULFti0R5tdUtuDTMvPP/+sWbNmpRuza9cuvffee5lNyzBvb2917tw50/M89dRTcnFxMSGjzNmwYYPhPeTsEhISoh07duR0GplitG7GaD3SnTt3NHfu3MyklGMGDBiQ6Tk8PT3Vvn17m8fl57pUs/5tmaknAwAAAIC00IQBAADkKd26dTMc+9FHHxnqyLtq1SqtXbvW0JwFChTQE088kebz48ePV//+/bVy5cpMdXX39/c31AjA3d09w2tklJE/wkv/3DF6586dWZyNMZ6enmrTpo2h2MjISL3//vtKSEiwGjthwgQFBgYamrd69eqqWLGioVggI4xuaG/bts3QxueMGTNsamZjzdq1a9WxY0fNmTMnU40N4uPjDV8E7ebmlupxo58loaGhGjFihCIiIoym94CYmBitX79eAwYMUI8ePbRy5UpD7y/IPHt7e3Xp0sVQbGJiokaNGqW7d+9ajf3hhx8MvwZ9fHzUpEkTq3FGP1sjIiK0ZMkSQ7HZrUWLFlZjjh8/rpiYmEyv9fPPP2vv3r2GYj08PNJttNC8eXP16tXL0FyJiYkaPXq0YmNjDcU/bA4cOGA1xtnZWQ0bNsyGbAAAAAAAAAAAAGCmcuXKqU6dOoZiv/nmGy1fvjxT6126dEnTp09X69atNX78eAUEBGRqvqzQoEEDVa1a1XD81KlTNWDAAK1Zs0bBwcGKi4tTaGiodu/erTFjxuj555/P9iYCZlxU/swzz5iQSeZl9jWXVXJrXka5uroaitu4caPVmLi4OL3xxhuGb5CU2zRs2NCmcz41GW1akp/rUrt376633npLe/bsydQ8Bw8eNBSXVj0ZAAAAAKTGMacTAAAAsEW3bt305ZdfKjw83GpsYGCgBg4cqMmTJ6t27doPPJ+UlKT58+dr6tSphtfv2rWrvL2903zeYrFo37592rdvnz7++GM1bdpULVq0ULNmzVSqVClDa5w/f15vvvmmoTvGG73Dt5mqVKliOHbYsGFq27atatWqJS8vLzk6PvjjZ7NmzVS0aFEzU0zVoEGDtH79ekOx27Zt08svv6xPPvlExYsXf+D5yMhIffbZZ/rjjz8Mr//8888bjgUyokiRIobirly5otGjR+vDDz9M9cLv0NBQTZkyRUuXLjU7Rfn7+2vy5MmaPn266tWrpxYtWqhFixaqUqWK7O2t9wi8ffu2PvroI0PNT9zc3OTh4ZHqc/fWPHv2rNV5Dh8+rKefflpvvfWWOnbsKGdnZ6tjbty4of3792vDhg36888/c92dFh4m/fr10/z58w01Hjlx4oSef/55TZw4MdWmOXFxcfr666/17bffGl6/f//+cnJyshpny2fruHHjtGnTJj322GPy9vZOdf569eoZ7vBvlpYtW1r92sTHx+vw4cNq3Lhxhte5cuWKpk2bZjh+zJgxKlmyZLoxo0aN0o4dO3T16lWr8128eFH//e9/NWrUKMM5PCyMNMZo0KABBQ0AAAAAAAAAACBPGDNmjMaMGWPKXN27d9ekSZNMmSsnDRkyRK+99prVuISEhOQ9uFdeeUVly5a1OiYuLk5nzpzRn3/+qfXr1xvaz88NXnnlFY0cOdJw/N69ew03nM8Ojz76qOrXr6/9+/dnaHzFihVTrcvLbsHBwdq9e7eh2CZNmujHH3/M9Jq9e/fWoUOHrMZt2rRJkZGRadaw5HZFihQxdPOS5cuXy8/PTwMGDEi1juHs2bMaO3asjh49mhVpZpsBAwZo7NixGR6f0aYl+bkuNS4uTqtXr9bq1atVsmTJ5Hqyxo0bq2DBgobm2LJliyZPnmwoNidqbgEAAADkXTRhAAAAeYq7u7tefvllTZw40VD8pUuX1KtXL9WrV09NmzZV8eLFFRcXpytXrmjjxo2GLuS9x83NTa+++qrh+Dt37mj9+vXJF/57eXmpUqVKqlixonx8fOTh4SEPDw85OjoqKipKQUFBOnz4sA4cOGDoD92S5OfnZzgfs1SvXt1wbHx8vNatW6d169alGTNv3rxsacLw2GOPqW3bttq8ebOh+D///FPt27dXy5YtVbt2bRUuXFiRkZE6c+aMNm3aZGhz6Z7q1avrqaeeymjqgCG1atXSwoULDcWuWrVKW7ZsUadOnVSuXDl5e3srIiJCR44c0V9//ZXlTQPi4+O1Z88e7dmzR59//rlcXFxUsWJFVapUSSVLlkx+f3R1dVVsbKxu3LihkydPaufOnYqJiTG0hrX3x9GjR2vIkCGG5rp27ZreffddffLJJ8ld7b29veXm5qaoqCiFh4crPDxc/v7+OnHihEJCQgzNi6xXunRp9enTR/PmzTMUf+TIET399NNq3LixGjRooCJFiig6OloXL17Uxo0bdfPmTcNrFy9eXIMGDTIUW6FCheTXkzUWi0Xbtm3Ttm3b0oyZOHFitjdhqFOnjgoXLqzbt2+nG7dv374MN2FISkrSmDFjFB0dbSi+VatW6tmzp9U4d3d3ffbZZxo0aJChn8F+/PFHtW/fXvXq1TOUx8MgOjpax48ftxrXunXrrE8GAAAAAAAAAAAAWeKJJ55QvXr1DN1t3GKxaPny5Vq+fLmqV6+umjVrqly5cvLw8JCdnZ0iIiIUHh6ukJAQnT59WmfPnjXUXD+36dChg5588kmtWbMmp1PJsAEDBmS4CUOPHj1MziZjVqxYoaSkJEOxTz75pClrduzY0VAThpiYGK1fvz7DF9/ntFq1aunSpUtW4ywWiyZPnqz58+erXbt28vX1lbu7u27cuKG9e/dqz549hmsic7MuXbro888/t1obkZrKlSurVq1amc4hv9alSv/UaP3+++/6/fffJUklS5ZUxYoVVaFCBXl5eSX/26R/vg6XL1/Wnj17dOHCBcNr5NS/DQAAAEDeRBMGAACQ5/Tv31/r1q0ztIkh/fMH/gMHDujAgQOZWvedd95R8eLFMzw+LCxM+/fvz/CmVWo6depk2lxGFS1aVDVr1tSxY8eyfe3M+vDDD3XgwAGFhYUZio+NjdXGjRu1cePGDK/p5OSkTz/9VPb29hmeAzCidevWsre3N7ypHBUVpT/++COLszImJiZGJ06c0IkTJ0ybs2PHjuk+36xZMz377LNatGiR4TkjIiK0adMmbdq0KbPpIRu9/vrr2rZtm65cuWIoPiEhQX///bf+/vvvTK07fvx4ubq6Goq1t7dXy5Yt021alNs5ODjoySef1IIFC9KN27p1q013gvm3efPmGf45qmDBgvrkk08Mz92oUSP1799f8+fPtxp7rxnEsmXLDH+P87u///7balGco6OjaQVNAAAAAAAAAAAAyBkTJkzQM888Y9PNHcyuB8htPvzwQ+3bt8+0GzaUKVNGlSpV0tatW02Zz5r27durZMmSunbtmk3jHB0d1a1bt6xJykYrVqwwFOfo6Kj27dubsmbHjh01adIkQxe1L1u2LM82YXj88ce1fPlyw/FBQUGGb5SRFxUoUEDPPfecvvvuO5vHZlXTkvxSl5qaa9eu6dq1a5mu4bnHy8srwzcOAQAAAPBw4kowAACQ5zg6OuqLL75QsWLFsm3NLl26qF+/ftm2nhH169dXtWrVcmTt3r1758i6mVWiRAlNnTpVjo7Z14vsww8/1KOPPppt6+HhVbRoUT399NOmzmlWB/bs5uXlZehrMW7cONWtWzcbMkJO8vDw0FdffSV3d/dsW3P48OFq3bq1TWPy6mfrvxkpsDlx4oSuX79u89yXLl3SF198YTh+7NixNjfPevvtt1WuXDlDsf7+/po2bZpN8+dnRprTNG/eXEWLFs2GbAAAAAAAAAAAAJBVKlSooMmTJ8vBwSGnU8k1ChcurB9++EGenp6ZnsvHx0ffffedvLy8Mp+YQQ4ODurbt6/N41q0aJEr9v9OnDihs2fPGopt0qSJChcubMq6JUqUUJ06dQzF7tu3T0FBQaasm93atWunsmXLmjpnVjUjyC59+/a1uf7Q0dHR9LqurJKTdalZLSPfOwAAAAAPN5owAACAPKlkyZKaO3eufHx8snytdu3aaeLEiVm+ji1cXV1zNKdu3boZ3kTKbVq2bKmpU6fKyckpy9d699139dxzz2X5OsA9b7zxhjw8PEyZy93dXdOnT5eLi4sp82WncePGydvb22pcgQIF9MMPP9CI4SFQrVo1ffvtt6adH+np37+/3nzzTZvHNWnSRE888UQWZJR9atWqpYoVK1qNM3LB/r8lJSVpzJgxiomJMRTfpk2bDN1xxdXVVZMmTZK9vbE/l/3888/at2+fzevkNwkJCdq2bZvVuNxyFxwAAAAAAAAAAABkTocOHTRp0qRsqb3JK6pVq6aff/5ZJUqUyPAc5cqV0/z581WxYkXFxsYaGmPWxcTPPfeczfUhzzzzjClrZ9ayZcsMxz755JOmrt2pUydDcRaLRcuXLzd17ezi5OSk9957z7T5qlSponHjxpk2X04oUaKE2rdvb9OYli1b5oqmJdbkdF1qVqpSpYpGjBiR02kAAAAAyGNowgAAAPKsSpUqadGiRapZs2aWzG9nZ6chQ4ZoxowZuWrT0NPTU998840eeeSRHMvB0dFR06dPN3y36NzmySef1OzZs7OsiYebm5umTZumF154IUvmB9JSsmRJzZw5M9PvWQUKFNDMmTNVpUoVkzLLHnZ2dnr33XfVuXNnw2M8PT01b9489ezZMwszQ27QsGFD/fLLL1n22eXk5KTRo0dnqljg008/Ve3atU3MKvv169fPasyqVatsmnP27Nk6dOiQoVgvLy+NHz/epvn/rW7duhoyZIihWIvFojFjxigqKirD6+UHO3bsUFhYWLoxxYsXV7t27bInIQAAAAAAAAAAAGS5p59+WnPnzlXx4sVzOpVco2rVqlq+fLm6dOkiOzs7w+Ps7e3Vq1cv/fHHHypfvrwkWd1/u8esG2t4eXnp6aefNhzv7e2t1q1bm7J2ZiQkJGj16tWGYp2cnEzfs+zYsaPh73VebcIg/XMTq9deey3T8/j6+uqHH36Qm5ubCVnlrIEDB9oUn1ualqQnN9SlZpXKlSvru+++k7Ozc06nAgAAACCPoQkDAADI00qWLKnffvtNb7/9tql3t65cubLmzp2rUaNGGb4bsvTPH6KzUt26dfXrr7+qSZMmWbqOEb6+vvrjjz/Up08fubq65nQ6NmvUqJFWrlypHj162PQ9tqZVq1ZasWKFTReBA2Zq0qSJvv32WxUuXDhD44sWLaoff/xRTZs2NTUvNzc3U8+1+5UqVUozZ87MUPMTZ2dnTZgwQbNmzVLlypWzILt/Chb69OmjX3/9VaVLl86SNWCdn5+fli1bpiFDhpi6sVq3bl39/vvvev755zM1T8GCBbVgwQINHz5cBQsWNCm77NWjRw95eXmlG3Po0CFdvHjR0HwXLlzQV199ZXj9Dz74INNNll5//XVVqlTJUGxAQICmTp2aqfXyuj/++MNqTP/+/XNVUzMAAAAAAAAAAABkXoMGDbR69eos2wuys7NTvXr19J///EejR482ff6s4OXlpc8//1zLli3Ts88+K29v7zRjS5QooX79+mnVqlUaP358itq3gIAAQ+sVKVIk0znfM2DAAMOxTz/9dK7Y/9u+fbtu3bplKLZ58+am78MXL15cdevWNRR76dIlHTlyxNT1s9Mrr7yid955R46OjhkaX7NmTS1cuFAlSpQwObOcUa9ePdWoUcNQbJEiRTLdtCQ/16Vm5b/N3t5eTz/9tH799VeVKlUqy9YBAAAAkH9l7LdgAACAXMTR0VHDhg3Ts88+q99++02LFy/W1atXbZ7Hzs5ODRo0UJ8+fdSxY8cMXSz80Ucf6fnnn9eOHTu0a9cuHTx4UCEhITbP829OTk5q1KiR+vXrpzZt2tg0duTIkRo5cmSm1k+Ph4eH/vOf/+itt97S+vXrdeTIEZ08eVK3bt3SnTt3FBUVJYvFkuH5J02apEmTJpmYcUqFCxfWxIkT9cILL+jnn3/WqlWrFBERYfM8BQoUULt27dS/f3/Vq1cvCzIFbNO8eXMtX75c06ZN0+rVq5WQkGB1jJOTk7p166a33347ww0c0vPUU0+padOm2rVrl3bu3Kl9+/bp8uXLmXqPkKTq1aure/fu6tWrV6Yvqm/RooWaNWumTZs2adGiRdq5c6ehr11aKleurMaNG6t58+Zq1qxZrihAgOTq6qpRo0Zp4MCBWrBggZYtW5ahz2pHR0e1aNFCffr0UatWrUzLz8nJSW+++aaGDx+uTZs26dChQzp58qSCg4N1584d3b17V0lJSaatZzZXV1f17t1b3377bbpxS5Ys0TvvvJNuTGJiokaNGqW4uDhDa3fo0EFdunQxnGtanJ2dNXnyZPXq1cvQe8Cvv/6qDh065IomWdnt9u3b2rJlS7oxbm5u6t27dzZlBAAAAAAAAAAAgOzk6empcePGaejQoVq4cKGWL1+ua9euZXg+Dw8PNWjQQE2aNFHbtm3z7E0Oqlatqk8//VSffPKJrly5osuXLysyMlL29vYqVKiQypUrp5IlS6Y69vr164abMJQpU8a0nKtUqaLGjRtr9+7dVmN79Ohh2rqZsXz5csOxTz75ZJbk0LFjRx08eNBQ7LJly1S7du0sySM7vPjii2rQoIE+//xz7du3z9AYLy8vDR06VEOGDMlwA4fcasCAARo1apTVuKeffjrT//b8XJe6cuVKnThxQjt37tSuXbt07NgxRUZGZmrOggULqnXr1nrhhRfk5+dnSp4AAAAAHk52lsxe8QIAAJALnTlzRrt379bJkyd16dIlXb9+XXfu3FFsbKzs7e1VoEABeXt7q2TJkqpcubJq1qypFi1amNod/J4bN27oxIkTOnv2rK5evarAwEBdu3ZNd+7cUXR0tKKjo2Vvby93d3e5urqqYMGCKleunCpWrKiqVauqWbNmKTqdI+skJCTowIEDOnDggE6dOqWAgAAFBwcrKipKcXFxcnR0lJubm4oWLSpfX19VrVpVdevWVePGjeXq6prT6QOpCgoK0oYNG7Rnzx6dP39eYWFhunv3rlxcXOTj46NKlSqpcePG6tChg4oXL/7A+NDQUEMXQHt4eNj8XhUZGamTJ0/q5MmTunr1qq5evaqgoCCFhYUlvz9aLBa5urrK1dVVHh4eKlOmjCpWrKhKlSqpWbNmWdoh/86dO9q9e7eOHj2qs2fPKigoSDdu3FB0dLTi4+NVoEABeXh4yN3dXYULF1b58uVVvnx5VaxYUbVr11bRokWzLDeYx2Kx6NixY9q7d69Onjwpf39/3bhxQ5GRkYqNjZWDg4NcXV3l7e0tX19f+fn5qVatWmrWrJnpd8nIL27evKl27dopOjo6zRgfHx9t2bIl081TkLPmzp1rtWHWkCFDDBWeAAAAAAAAAAAAIH84ffq09u7dq1OnTunSpUsKDg5WeHi4YmNjJUnu7u5yd3eXh4eHfH19Vb58eVWoUEF+fn6qXr26HBwccvhfkLO++uorff3114Zi161bp/Lly5u29vDhw7V169Z0Y6pXr64lS5aYtibypmPHjmnr1q3at2+frl69qrCwMMXFxcnd3V0lS5aUn5+fWrRoobZt28rNze2B8devXze0jre3d66tK9iwYYOhRgQrV65UlSpVTF8/v9alWiwWXb58WSdOnND58+cVGBiooKAgBQcH6+7du4qOjlZMTIycnZ3l6uqaXM9ZoUIFVahQQTVr1lSDBg3yXdMPAAAAADmDJgwAAAAAAAAw1bRp0/T999+nGzNx4sRcc4cU2C4xMVHt27dXYGBgmjHu7u7avHmzChcunI2ZAQAAAAAAAAAAANkrMTHRlOYRV69eVbdu3XTnzh2rscWLF9dff/2V6TXvuX37tlq0aKH4+Ph04z788EP169fPtHWBvGrkyJHasGFDujE1a9bU4sWLsykjAAAAAIDZ7HM6AQAAAAAAAOQvL7zwgjw9PdON+fHHH7MnGWSJ9evXp9uAQZKef/55GjAAAAAAAAAAAAAg33v33Xc1ceJEBQUFZXiOoKAgDRs2zFADBknq2LFjhtdKzezZs602YHB1dVXnzp1NXRfIi86dO6fNmzdbjXv22WezIRsAAAAAQFahCQMAAAAAAABMVahQIQ0dOjTdmDNnzmjHjh3ZlBHMZq2JRuHChfX8889nTzIAAAAAAAAAAABADrp7965+/PFHtW/fXi+++KKWLFmi8PBwQ2NDQ0M1e/ZsdenSRRcuXDA0xt7eXn369MlMyimsWrVKc+bMsRrXpUsXFSpUyLR1gbwoKChIr7/+uhITE9ONK1iwoLp06ZJNWQEAAAAAsoJjTicAAAAAAACA/GfIkCFavHixrl69mmbMzJkz1axZs2zMCmb466+/dOTIkXRj3nrrLXl4eGRTRgAAAAAAAAAAAEDOS0hI0F9//aW//vpL9vb2KleunB599FGVK1dOBQsWlKenp+Li4hQZGamgoCCdPHlSx48fV3x8vE3rdOvWTeXLl7dpzKFDh3TlypXkxzExMQoKCtKOHTt07NgxQ3P069fPpjWBvOrmzZspbiqRkJCg0NBQHT9+XNu2bVNMTIzVOZ555hm5ubllZZoAAAAAgCxGEwYAAAAAAACYrkCBAhozZoxeeeWVNGMOHjyo7du3q0WLFtmYGTJrxowZ6T5fvXp19ezZM5uyAQAAAAAAAAAAAHKfpKQkXbx4URcvXjR1Xh8fH7333ns2j1u4cKGWLl2a4XWfeOIJVa1aNcPjgbzkwoULGTrP7nFzc9PQoUNNzAgAAAAAkBPsczoBAAAAAAAA5E/t2rVT8+bN04356quvsikbmGHbtm06evRoms/b2dlp3Lhxsrfnz44AAAAAAAAAAACAmQoUKKCZM2eqcOHC2bquk5OT3nrrrWxdE8jLhg4dKh8fn5xOAwAAAACQSY45nQAAAAAAAADyr9mzZ+d0CjBR69atdebMmZxOAwAAAAAAAAAAAHiouLm56X//+5/q1KmT7Wu/9tprKleuXLavC+RFVatW1bBhw3I6DQAAAACACbglHQAAAAAAAAAAAAAAAAAAAAAAuVCVKlW0ePFiNWnSJNvXbtWqlV544YVsXxfIiwoVKqTp06fL2dk5p1MBAAAAAJjAMacTAAAAAAAAAAAAAMwQFxenixcvKjAwUMHBwbp7964SEhLk4eEhLy8v+fn5qWLFinJwcMjRPM+dO6cTJ07oxo0bSkpKkpeXlypXrqzatWvL0ZHtOwAAAAAAACAvsbOzy5J5vby8NGzYMA0cOFBOTk5ZskZ6Wrdura+++kr29tz3EbCmcOHCmjNnjipWrJjTqQAAAAAATEIVFwAAAAAAAAAAAPKsdevWaefOnTp06JAuXryohISEdOM9PT311FNPaeDAgdlaDGmxWPTHH3/ohx9+kL+/f6oxXl5e6tOnj4YNGyY3N7dsyw0AAAAAAABAxk2ePFlbtmzRxo0btWvXLkVFRWV4Lnt7ez322GPq0qWLnn76abm6upqYqTGFChXSyJEj1a9fPxowAFbY29urU6dOev/991W0aNGcTgcAAAAAYCI7i8ViyekkAAAAAAAAAAAAgIxo2bKlgoODbR7n5OSkl156Sa+++mqW3anunoiICL3xxhvasWOHofgyZcrom2++UeXKlbM0LwAAAAAAAADmSkhI0OnTp3X48GGdPXtWgYGBCgwMVEREhKKjoxUTEyMHBwc5OTmpYMGCKlq0qHx9fVWxYkXVqFFD9evXV6FChUzPa/To0Vq6dOkDxx0cHOTp6SkfHx9Vr15dTZs2VceOHVWgQAHTcwDyij179mjgwIGpPufm5iYvLy9VrlxZdevWVZcuXVS6dOlszhAAAAAAkB1owgAAAAAAAAAAAIA8K7UmDAUKFFDJkiXl6emppKQkhYWFKSgoSKltiz3zzDP67LPPsiy/mJgYDRgwQEePHk1x3MnJSb6+vnJ2dtbVq1cfuDuet7e3fvvtN5UtWzbLcgMAAAAAAAAAAAAAAAAAPIgmDAAAAAAAAAAAAMizWrZsKYvFotatW6t+/fqqW7euSpcuLXt7+xRx4eHhWr9+vb7++mtdv349xXOfffaZnnnmmSzJ76OPPtJvv/2W/Nje3l7Dhw/X4MGDk+9oFxcXp1WrVmnSpEkKDw9Pjn300Ue1ePFiOTg4ZEluAAAAAAAAAAAAAAAAAIAH0YQBAAAAAAAAAAAAedbp06fl5+cnOzs7Q/Hh4eF6/vnndeLEieRjPj4++uuvvx5o3JBZFy5cUJcuXZSYmJh8bNq0aercuXOq8efOnVPfvn0VERGRfCwrG0QAAAAAAAAAAAAAAAAAAB5kbiUZAAAAAAAAAAAAkI2qVq1quAGDJBUqVEhTp05NMSYkJEQHDx40PbcZM2akaMDQtWvXNBswSFLlypX13nvvpTj29ddfKz4+3vTcAAAAAAAAAAAAAAAAAACpowkDAAAAAAAAAAAAHioVK1ZU9erVUxy7cOGCqWuEh4dr48aNyY/t7Ow0cuRIq+OeeeYZ+fr6Jj8ODAzUzp07Tc0NAAAAAAAAAAAAAAAAAJA2mjAAAAAAAAAAAADgofPII4+keHz79m1T59+2bZsSEhKSHzds2FBlypSxOs7e3l49evRIcWzz5s2m5gYAAAAAAAAAAAAAAAAASBtNGAAAAAAAAAAAAPDQiY2NTfHY09PT1Pn//PPPFI+bN29ueGzTpk1TPN66daspOQEAAAAAAAAAAAAAAAAArKMJAwAAAAAAAAAAAB4qFotFx44dS3GsRo0apq5x6tSpFI/r1q1reGyNGjXk7Oyc/PjGjRsKDQ01LTcAAAAAAAAAAAAAAAAAQNpowgAAAAAAAAAAAICHyuLFi3Xjxo3kxxUqVFCtWrVMmz8+Pl5XrlxJcaxixYqGxzs7O+uRRx5JcezChQum5AYAAAAAAAAAAAAAAAAASB9NGAAAAAAAAAAAAPDQWLp0qT7++OPkx/b29vrwww9lZ2dn2hoBAQFKSEhIfuzi4iJvb2+b5ihRokSKx5cuXTIlNwAAAAAAAAAAAAAAAABA+hxzOgEAAAAAAAAAAADALJcuXdK1a9eSH8fHxysiIkLnzp3T5s2bdf78+eTnnJyc9Mknn6hJkyam5hAaGpricfHixW2e4/4xt27dylROAAAAAAAAAAAAAAAAAABjaMIAAAAAAAAAAACAfOOXX37RvHnz0o2xs7NTixYt9Pbbb6tq1aqm53D37t0Uj11dXW2ew83NLcXjqKioTOUEAAAAAAAAAAAAAAAAADCGJgzAQywk5I4kydnZIcXxuLjEnEgH+RSvL2QVXlvISry+kFV4bSGr8NpCVuL1hazCawtZhddW3uTj45nTKeQbMdeHZut6LiVmZ+t6ZunYsaMGDBiQJQ0YpAcbJhQoUMDmOe4fQxMGAACQXe7VEiB1/N4JPBw414H8j/MceDhwrgP5H+c58HDgXAfyP87zjKHmCsha9jmdAAAAAAAAAAAAAJCd1q5dq759+6pfv366fPmy6fPHxsameOzk5GTzHM7Ozikex8TEZConAAAAAAAAAAAAAAAAAIAxjjmdAAAAAAAAAAAAAMyRJEtOp5Djxo4dq7FjxyY/jomJUVhYmE6fPq2NGzdq1apVyQ0N9u/fr549e2rOnDmqWbOmaTkUKFAgxeP4+Hib54iLi0t3TgAAAAAAAAAAAAAAAABA1rDP6QQAAAAAAAAAAACArOLi4qISJUqodevWmjBhglasWKFq1aolPx8REaFXXnlFERERpq3p5uaW4nFsbKzNc9w/5v45AQAAAAAAAAAAAAAAAABZgyYMAAAAAAAAAAAA+URSNv8vLypbtqzmzJmjkiVLJh8LDg7W7NmzTVvD3d09xePo6Gib54iKikrxmCYMAAAAAAAAAAAAAAAAAJA9aMIAAAAAAAAAAACAh4q3t7dGjhyZ4tiSJUtMnf/fgoODbZ7j/jFFihTJVE4AAAAAAAAAAAAAAAAAAGNowgAAAAAAAAAAAICHTvv27WVnZ5f8+MaNGwoMDDRl7jJlysjR0TH5cUxMjEJDQ22a49q1aykeV6hQwZTcAAAAAAAAAAAAAAAAAADpowkDAAAAAAAAAABAPmHJ5v/lZQULFlShQoVSHLt586Ypczs5OalMmTIpjp0/f97w+Li4OAUEBKQ4RhMGAAAAAAAAAAAAAAAAAMgeNGEAAAAAAAAAAAAAJDk6Opo2V7Vq1VI8PnTokOGxx48fV1xcXPJjHx8fFSlSxLTcAAAAAAAAAAAAAAAAAABpowkDAAAAAAAAAABAPmHJ5v/lZZGRkQoPD09xrGjRoqbN37p16xSPd+zYYXjszp07Uzxu06aNGSkBAAAAAAAAAAAAAAAAAAygCQMAAAAAAAAAAAAeOn/++acslv/fSMLb21s+Pj6mzd+qVSs5OjomP967d68CAgKsjrNYLFqyZEmKY23btjUtLwAAAAAAAAAAAAAAAABA+mjCAAAAAAAAAAAAkE8kWizZ+l9eFRMTo6+++irFsdatW8ve3rytMy8vrxTNEywWi2bMmGF13OLFixUYGJj82NfXV02aNDEtLwAAAAAAAAAAAAAAAABA+mjCAAAAAAAAAAAAgDxpypQpOnr0qE1jwsLCNGLECPn7+ycfc3Bw0ODBg9Md16ZNG/n5+SX/t2TJEqtrvfbaaykaOyxfvlyrVq1KM/78+fOaMmVKimMjRoyQs7Oz1bUAAAAAAAAAAAAAAAAAAOagCQMAAAAAAAAAAEA+Ycnm/3Lajh079Oyzz+rZZ5/V3LlzderUKcXHxz8QZ7FYdOHCBX399dfq2LGjdu7cmeL5QYMGyc/Pz/T8KlWqpGeffTbFsXfffVdffvmlwsPDk4/Fx8dryZIl6tu3ryIiIpKP+/n5qXv37qbnBQAAAAAAAAAAAAAAAABIm2NOJwAAAAAAAAAAAABkxtGjR3X06FFJkpOTk4oXL66CBQvKyclJd+/e1bVr13T37t1Ux3bv3l3vvvtuluU2ZswYnThxQsePH5ckJSUl6X//+59++OEHlS5dWs7OzgoICFBUVFSKcYULF9aXX34pR0e28wAAAAAAAAAAAAAAAAAgO1G1BQAAAAAAAAAAkE8kyZLTKeS4+Ph4Xb161Wqch4eH3n77bfXp00d2dnZZlo+rq6tmz56t119/Xbt3706R56VLl1Id4+vrq2+++Ubly5fPsrwAAAAAAAAAAAAAAAAAAKmjCQMAAAAAAAAAAADypOnTp2vLli3auXOnjh49qsjIyHTj7ezsVKVKFXXt2lXdu3eXt7d3tuTp5eWluXPnavHixZo1a5YuX76cZlzv3r01bNgwubu7Z0tuAAAAAAAAAAAAAAAAAICU7CwWC7dEAh5SISF3JEnOzg4pjsfFJeZEOsineH0hq/DaQlbi9YWswmsLWYXXFrISry9kFV5byCq8tvImHx/PnE4h37h5rX+2rle05M/Zul56kpKS5O/vrytXrigoKEiRkZFKSEiQu7u7PD095evrq+rVq8vDwyOnU9WZM2d08uRJhYSEKDExUV5eXqpcubJq164tJyennE4PAAA85O7VEiB1/N4JPBw414H8j/MceDhwrgP5H+c58HDgXAfyP87zjKHmCshajjmdAAAAAAAAAID03YmL1c2YKCVakuThVEDFXf+5M/b58FCFxNyVxSIVci6gqoWLKtFi0YnQGwqPi5W9nZ2KuripauGiik5I0IXwUMUkJsjZ3kHlCnqpcAFXxSUmKiI+VrJY5OHkLBdHLvwEgLzMooe397a9vb0qVKigChUq5HQqVvn5+cnPzy+n0wAAAAAAAAAAAAAAAAAApIImDAAAAAAAAEAWiU1MUHRCgpwdHOTq4Cg7OzuFxkTrwM0ghcfGyO7/miRUL+yj02E3tSXwkgIjI5RkscjbxVXVCvvoTlysDt68puiEeFkkOdrZy6uAixKSkhQe988cskgJliTZy+7/Lr61k4O9nSQpPjFRDnb2SrAkydHOTvb29rJYLLK3s1ORAq4Kj4tVkiyyWCQXR0fVKVJCrg5OCo6OVHRCgtydnFS7aAnV9Smp4KhIRcbHycHOXiXcPFTO00t2dnayWP654NfOzi7nvtgAAAAAAAAAAAAAAAAAAAAAYAKaMAAAAAAAAAAZlGhJ0snQEF2LuqNEi0Xujk56tHAxBd6N0NagSzp885oSLRbZ2dmpuIu7HOztFHj3juKTEv+vVYIUnZCgiLgYOds7qHABV3k4OctOdjp5O0R/X7ssO9mpuJu7fN0LSpIuRdyW/50wSZJXgQKqUNBbSRaLzoffUmR8nOxkJ09nZ1Uo6K3YxARdvBup2KRE2UnydnFVOVcv3YyJ0tXICPnfCZOjnb1KexSUVwEXBdyJ0MLbx2WRVNDJWT4u7opPStKfQf6KTkiQq8M/Oer/Gi8ULuAqOzspLvGff0/hAq5qVer/sXff8Z5kdZ3/X+ecqm+6+d7OOU0EhjQzMIQliiw4CMhiWOMiigkQFRZRd9EVXVhxGVAR12UVAwr8MCCgZBgYZpycQ+dwO938zRXO+f3x/d5v39tpume6p8O8n4/HzP3WqVOnPlXf0N3fW+ddG1he6WOy1STxOWUXcfnIUtYNDJF5TytPiYwljq1CG0REzoI8nOsKRERERERERERERERERERERERERC5sCmEQERERERERERFZIPMeCETWAdDMUv790D7+/fA4c0mL2Do2DYzgrOGWQ/vYV68yHyWQBc9suwXAYKHIaLFMZC2NLOOWQ/tIQ07JRWweHKE/LjKXtDlQr5ITyPOATdqMlSrMtFvMJW2KNgIDE60mBeto5zmzSZtKFBMIVJOE7XPT5N7TzDL64gIhBBppyiMzk72wh744xofATNLiwZkJWnlGbC0lG5H6nH31KpOtBs0so+giIFDPUgppm2aa0sxSrDU0soyiyxgtldlVnWFPbQ7ohDssL/exY3aKWw/tIwueobhIf1zEGEi9pxLFZN4TO4vBsHZgkBeu3oA1hnqakGae4WKJq5etYrhQopVnJHlOJYqJnXvCXwciIiIiIiIiIiIiIiIiIvLkYA/sJ/72tyCKSJ7/HwhLlpzrkkREREREROQcUwiDiIiIiIiIiIg8qeTBM9tuk/icchQxGBeppgnfPbiHr+zbzqFGnUBgsFBkWamPbXPTNPIUiyG2Fk/gG+M7aWQJfVGBTYMjlKOYPAQemZmgkaUYY/DtwGixjLOW8cYcGOizMUnwbJ+bYePgMDurM2AMZRd1whOyhG1zU7SyjMgYnLWdor1nX71KAIrOYQwYDEXnmOmGPvTFMQDGGArOUU3bWGN77dYYImOZSVpUoqg3dmwdtSSllWUMxAWsNYAhAAcbNSJrqXTH8CEw2Wow0aoTW0dfHJMHz1y7TZLntPIMQiA2jlqW0B8XaeU5k60GPgSsMazuG6A/LnD74f18fd9ODIaxUpli9xz8yb2egomw3eOPjOWZS1dw5chS2j6nlWXEzrGuf4inji0jsrYbnAHR/PkSEXkSC+e6ABERERERERERERERkQuEmZig/7feTfH/+xSm+3vnUCrR/Kk3U3/3b0KpdI4rFBERERERkXNFIQwiIiIiIiIiInLRCSEw0WrQzDMK1rGkVKGeJdx8cC//tncbBxo1PIHIGIYKJQ426oQQKEURZRdhjGFndYZbD4/jjGV1ZYDllT6MMeypzdLOM4ouopVn7KzOsGVolMOtBvUspRLFBAKJ92yvTjNaLNPOcorOgYFCsCS5Z/vcNFnuKUWdr+gWhicYDAUX944nspZmlgFQjo58pWeMIQ++d8zGmM5jIA8BQ1jUnoew6Od8Zx9yADwBS7evD/ijpvIaDJn3BAKVqFOfM5aUjOl2k764QOwcAJmH3bVZnDGUoxhjIPWe/fUakTVkIVCwDh8Cc0mb1X1FDtSrtPIcj6fkYtYPDJPkOf+4/SH+Lr+PknOMlso4Y8mDp2AjjIHIWIzphDm8bM0mllf6qaZtUu/pi2OuHFnKUFEXx4iIiIiIiIiIiIiIiIiISIfduYPh138fbu+eRe2m1aLyJx8mvuUmZv/us4TBoXNUoYiIiIiIiJxLCmEQEREREREREZELVi1tU0tTImsZLpRIfM4th/bypb3b2FmdwYeANYayi5lLW3gfKMcxQ4Ui1hgmWw1un9iPAQbiAsvKfRScYyZpMZu0KbtOoML+Zo0AjBRLTLQaFKzDWoMzhkaWsrM6Q6NbB6YTVlCwlnaec6BRwxlDN9sAYwyxs9TShNi6Xvv8uswHnDn2WH3wgOkdU6ct4EPAdNtdtz3r3qEjJyxqT/IcQycModQNZ0h9TugWkfq8cwwBEt/pmwXf22fqczzz23kK3cCFdH5/3hNb26stDx5nHN3dE1vLXNam7Tvn23b7NtOUR2YnKVpHOYoI3Vp3VqfxPhAwlJwj9Z5GljFUKHKg0SD1HgOMFMusqPSxfW6a227/NlnwDBdLDMQFfAjEzrG83Efo1lVyEU8ZW8YLV64jspbZpI0zhrFShSXlyuN8VYqInFtHB+iIiIiIiIiIiIiIiIjIUUJg8JfeckwAw0LxbbfS997fpPYHNzyBhYmIiIiIiMj5QiEMIiIiIiIiIiJyXgshkPgcZyyRtWTec/fUAb66bwd3Tx4kC52J+P1RgXqW0MwyylHEcKGEs4Z6mvLw7AR58JRdzHCpRKE7of9As0bBOiJjqGcp26pTbBkc5VCzjgGcNYDBeM/BZo22zwgBbDclwRjTC20wGMr2yNdtxhgshmaeMhAXFx2T7YYmhHDURNnQ+V8eOsdtuukFR7qFRSEMIdDr4wG3YBiDgUBvKm4I0IkzMAv6QNYd3Bjw3c75fPACBt+tBWNIfI41htDtA53z6JkPafCUuvs7XohD5o889oDtFpL5/MhxmU6FzhhqaULBRlSiznm1xjDTbjLdalKKIvriGB8Cs0mLts9o5zl0QyeqSZvhQpEkzxhvVNk2M0XsLCsrAxSc496pQ3z8/tuxxjJULOKMpeAcTxtdxmipTGRsJ8yhUOIZS1eyeWikd1wF63rnXURERERERERERERERERELiyFf/si8c03PWq/0t98gsZb34Ffv+HsFyUiIiIiIiLnFYUwiIiIiIiIiIjIeWl3bZZv7d/FjQd20cxSDIbl5T7qWcrBZg1nLEOFIrF1tH3Gw7MTtPOckosYLAxTcJ1IgvFGFWMMFRuTBs/2uWm2DI5Sz1JyHyh2+xWto5Gl7KnNUU8TYut6tThrybKMyVaDaEE7dIIBvA8EwjHfth0JLOgEGsybD0A42d3K5/vQ/WmMOTa04eiOi5qPBC4cz8I183kC823+OLsA8KEzZlhQd+Z9b9tAJ1jCh84xGwwh0AtYaOfdEIcQyL3vhGoEj6cTGpF4T9w9vYnPu/v0vUCK0N2fMQbXLXr+HM+2W/TFBaLu85l6z7a5aawxFG1EMe4ERhxu1im6iHqWEkIg4IlSy4b+IcYbVf5px0MEAv1xgZFCiQD8zcN3ExuHs52gBmcsV40t54Wr1hFZSyPPcMawotLPmv5BBTSIiIiIiIiIiIiIiIiIiJyvQqDyv37/lLqaPKfyRx+i9v4/PMtFiYiIiIiIyPlGIQwiIiIiIiIiInLONLOUWw+Pc/OhPUy1WkTWsrZ/kNmkze2Hx8lDoC+OKbqIPHj+/fA4zSylHMVsHBimHMUAjDea5D7Q5zpBCzuq02wyIzhjaWQpBeswBgo42nnOntocme8EAswzxhAZy3TShHAkmGBeZC21NCUyi0MYoBMEkIWjowtYMBk/HNV+3GYwYDF4wuL4BDMfcrA4PKFTf4BgsMe0d/az8LHB4PG4Bb0N0Ml2CFhrem0L11tjjqm1dwghLKrNGIPvngtrDbkP3X6QB98JZlgwXJrnnW1NJ6wBOj8z77EY8hDwBByGpNsXIAue2DhCgCTPetvNC90xijbCdY8rtpZqmtDIUvrjIsZ0+tXThPumD2OAoouAQCvLSGNPO8upJm3yEHDWsLZ/EGcN/7ZnK//f9vtxxrKkVCGyFmMMmwZHGC2VKFhHAMZKZa5ZvobNQyOdurvhEwpqEJGz5dg/jURERERERERERERERGSee+B+4rvuOOX+xU/9HbXf/j0olc5iVSIiIiIiInK+UQiDiIiIiIiIiIicdeP1KndNHqCeJUTGsrIywFzS5jM77me63cQaQ8E5QgjcdHAP9SxlIC6waXCEkut8hXWoWSf1nkoUkwXPtrlpNg+OUI5ipttNYusw1lDAkXSDFgbiwjGBCrG1NPKEEKBgFwcqOGNo+6OTETrmwww8HhZFHoA13SCDo1ISnDGYbpBAfNR4zlhCOHZfzlqCP3YKrTOWgD8qOKLT7gmL2mNjMRicMYvaI2NoByg41wsBiKyllWcYDLHrHFdn685E3sjaI0EOGELwgCGaP3fzCQyANfPnZT54ISwKkDiePBwVOEEnqCDQOcthfjgDqc9xxuBDYP5pSn0OplNv6j0F16mrnecYIAs5IXSONwsBHzrnKhAwmE6792TBM1go4owBDAHYV68SG0s5ijFAkufsq1WJraXt805IhPdU0zbrBoYYr1X52r4dhBAYiIuMlEr4EPj7R+4jMpbYOYrOEVvHs5et4oWr1xMbSzNPiaxjVd8Aw0VduCMiIiIiIiIiIiIiIiIicrYU/+WfTqu/rdeIb/o26UtedpYqEhERERERkfORQhhEREREREREROSM8CEw3qjSzFJi61hR7mNvvcpnd9zPXZMHyIInBDDGMJe0qKUJI4US6weGcbYzeX+63STxOSXnaGYpW2en2DI4StE5DjfrOGuwC4IWdtVmWVbuIw+Boj0SjBBbS5JnVAmLAhigE6YQQmei/9EhDKY7mf94gQrz2x4vo8EYiyWQh9CdxN+RE4hsZ38LhRA6YQscCQWYb7fGEFtHFgLxUe0F40iDp2Bc75w7a7HdcIH5fWfBE1nbKX/Bccwfn11wYK7b5rqBDgDWdgIc0uApHHVeW7knMqa3r8hYkpBjjKHQDXEw3fFDd/yFQRDzwQzu6CeGTpgFvS0XnuDOsXrA9SIdOn1Sn/eOZj7UIvO+F0zhF5yCpBvMEIA8eKxx5D6QB4/BkOY5Loq643p86Lx+5sePraOatmnnhoFCobfPeprywNRhjDGUXUQg0MxT+vKYZpZRTxPy4ImsY03/IAT4px0P8rcP301kLKPlChZDOYp55tIVjJbKlKMYi2FJucKzlq2kLy4cc75ERI7n2BgfERERERERERERERERmVf8l38+7W0KX/2SQhhERERERESeZBTCICIiIiIiIiIij0s9TfjuoT38296t7KnNkQWP7U7on0vaFIxjWbmfUndyezVN2F+fw2CYTlqE2gwbB0awxnC42cAAkbU4Y0jyjJ3VGVZW+mn7nOKC0IT5oIW5pH1MYIIxBmMM7TxfFAAwz/ZCAo5NWugELRwbqBC6dfUWuqtCCIQQGIgLtPIMZ6Leusx7hgtlmnlKmufErlN/6j1lF9EXxUy2mxRdBAQS7ym5iOXlvs659B7XPY7+uMCycj+7atMkeU5kLUmeM1Yq0xfF7K1XyfNOGIIPgbV9g1SzhGqSULCWLHictawoDjCTtDAhYIHEeypxgdx7ch9w1nTDBwwumEWBDfPnMnYOM//YOiDtPG/dEIfIWkwAT6Dkol5fa0wn/ADbO5fWGDIfwBhiu/jrytBdbzG9WIZAp+/CoIcjT3znR3506gV0n1OPNRYfQi8YI/E5YDDmyHY+dMIdLJ0gilL3fCQ+74Zm0AvPMMaQ+Zw8BAYLxe456oQ/jNerxNZR7r72kzxnvF7tvLbnx/eeRpqyuq+f8XqNv3/kPgCGC0X642LvfI4WywwWC0TWsazcx3Ur1/K0Jct7xxZb2zvPIiIiIiIiIiIiIiIiIiJyLLt3D9H99572doUv/xv13/n9s1CRiIiIiIiInK8UwiAiIiIiIiIiIqfkcLPO1/fs4K7JA9SzhHIUs75/mDsm93OwUaPgHKOlMpGxNLKUB2cmyIOnaB0DhWIvhGGiWQdjKDqHD4GZdos9Zpal5T7qWdKd1N8JUig4RyNLmUvbnfn1xwlaqGfJces1xhC8JxxvYrqBonNkPuCO5DoQQsBg6I9jmlmGWxD6kHrPQFzAB08z7wZCLJiMv35gmJ3VmV5YRB48Blhe6QMMO6qd8IR5a/oHGYiLBANTzSY5gaJzbBgYpi8uAIad1RlawVN2Mav7Bik4x8rKAHtrczSylIG4yGixjDOWkWKJyVaT4D0jxRLlOKIURbTzrHMsxrC6b4D+qAAEJlpNINAXFdg0OMJMu8W+RhWfe5yxLClVcMZyuNXA5x7fjTsYKZRo5lk3xKATHBFbRyd6wPTOozUGQicsY15kLBmewoLAgNha2jlYjvR1xvYCMnp9Q+fpD50MhiOBGAueu2jB87XgqcbQeZ46oQ4sSm7IfCc0ZGFsQ+rzI/vjSOZG4vNeW949xsx78u7rJvWeYi9ooxPYsPDVFxlLNW3jjKW/UOjVPZe0mWu3MQZKLiIQqGUpA4UiM60WtSxhx9w0ZRexvNLPA1MTfGHnI+TBMxCXqMQRfXGB/7B6Pc9etpLIdt5bA4UiS8qVY86JiFzcPApkEREREREREREREREROZ74pm8/pu2ibVuxB/bjV6w8wxWJiIiIiIjI+UohDCIiIiIiIiIissihZo1dtVmSPGeoXGT9wDCf3X4/X9m7nWaWUXQOZyxJnvG1fdvJQmBZuY/l5X5cd2L8ZKuBAfqimNR7dtZmsMZQcjEzSYvYdPpZY4idZardpOzizmT3o4IWMFBN2osmyc+bnwQ/P0n/6HmnsXPkIfQm7s8LITBULDObtHohCtCZWN8JKxhkR3WaNM+JnSOEAAGWlCr0xQW2zk7R9jmRsaTes7zcT39cYPPgKNvmJqlnKQCrKwMMxkUAVpT7GG/UyL1ntFQm9Z7JVoOijRgqlbDBEFlLNUmopgkhBJ46uowVlX7212vUsoRGnlJ0EW/c8hTGihUempnkQKOKJ3D58FKeu2INzhhuOzzOZKuJNYYrR5ZyyfAYh5p17pg4QDvPWF7p5+lLVuIwbJubYiZpEQwsLVUwxpD3wgQMfVFMNW0TG8dYqcxwscR4vcps0gagEkVsGRrlQKPGXLuFtYYQYLBYxPtA2+cUrCXvpDZQmA9K6D4p8+ENkXG9YAZnLdZYQggUbNR9LYDDkNIJ9ph/zpyxZD7DdF9LLHgZeCA2R0Ic5p97Y+htH+gEKHR+drcLi19tBsi9x4eA6x1Lp0+S51hjCIAPHugEIGTB94IZSt1xEp93Qx1Ct47O0ac+J4TAYKHYa8uyjJ1zMxSsoxzFEDrn8nCrQe49me8EYzSylNVukHaryZ/fdzsfuSujL44ZKhSJXcRTR5dy5dgylpQqWGsYLBS5ZHjsmBALEREREREREREREREREZGLXXzzdx/zttEdt5P8x1efwWpERERERETkfKYQBhERERERERERAeC+6UN8ae9WbpsYJ/Me6EwWn0vaZN6zpn+QVZWB3kT5vbVZAlByjslWg8x7Ng6OEEJgqt3sTvI2xNaR5Bl767OsqgwSAGuPJCI4Y8lCzlzaOm5dzhjaPqdb0DFBC85YIPQCFOb5EBiIC2Te08ozCs712jGGZeU+ImuZaDaIrcUAWfAsLfUxWCiyYWCYHdUZWllGAIYKRUaKZawxbBocZuvsNM08pS8qUI4iZtotEp8zXCgxWICSi8h8zv5mjRBguFjkp9ddyqq+AbbNTnGo1cAaw+q+AZ63Yh2bB0bYXp1motkgD4GhQpHLR5YQWUfmPbW0TRYC/VFMKYpP+lxev+HyE67Lg++es47ZpMV0q4nvHuNosczDs5Nsm52ilWeUXMTSUoV9tTm+fWAPs0mLdQPDFJ0j9Z6pVoNGltIfF0h8Tprn9MUxw8USYNjfmKOepThjWV7uY6RYZtvsFI0sw3RfC6v6B5hqNsh83gn48DmxtSzMQgghYKzBeNMLZoBOyEIbiIztHVdkLWSdF0sh6jzvthv44ANE1vReKwZDCB6MIeqGOMzvNnTXQyfQYb4OulvSfc10+hwpdj5swZojgQsYQ+JzbLeGPAQi0wlg8N1Ahsz7buhHJ9zBE3C2W4ExOAyz7RYl53qvgSTP2VOdo5NXYnAGGllKXxRjyPm33dv45x0PU44ixkoVjIFl5T42D42ydmCQoosYLVV4xtIVlCJ9XSxyMQjHSy0SERERERERERERERER4pu/85i3je68TSEMIiIiIiIiTyK6qlZERERERERE5EnEh8AD04f4xoFd7KpOk/nAaLFEycXcNrGvGzZQotyd4L2/Psdc0sYaw+7aLBsHLP1xkdx7ptoNYutw1mKNZTZpsb9epT8u4EMgtkcm+sfW0c5z6mly3LqshUaWdRaOE7RgjcFiSIMnXhAg4EOg6CL64wKHm3WcicB0J8oHGCtWKDjH1rkpkjwnNpY0eCpRTF/3vxBCJ/gAT9nFrCj3A9AXFVhSqjDVagJQjiIONmu9fT9tbBlXja0gyXN2VWdIvWe4WOJ5K9Zy7bI1lFzEntosjSyl6BwrKwP0xQUAXrZm83HPw5ahMbYMjR3THlnLcLF84if2NCwMYIDO8z1UKC1qu2x4CZcNL1nUds1yeO3mKxe1hRDYWZ3hcLOOD4HBQomhQpGbD+7lvqlDNPOMy4bHqEQxe+tzHGzUqKZthoolqmkbZyx9cUx/XIAQONxs4MmpuIgNgyPMJW0ONI6c80oUExtLNUuwIcLjyYKnYB3WLH7RmG7oQi9swXQep8FTsFEvTCSylnbucZjea8tiCN0XYtHazlgLZjXPj7twnnMI4Uhggw9Hv4TJvCcAzlpyvziwwXbH8t0R0/kQBwyJ98TWEYBW3gkj8UdNsG7nGQXrqMSdr3vz4Bmv13DWEBlLyUUkvvP+KzrHnRMHuPXQOMVuwIaxhpKLWNM/yMbBYfoLRVb29XP1stVU4pMHfoiIiIiIiIiIiIiIiIiIXAjM1CTRQw8+5u3jO24/g9WIiIiIiIjI+U4hDCIiIiIiIiIiF6EQAvsaVWbanQCB0WKZLHj+5P5/Z0d1GoCSizDA1rlJDrfqFKxjTd8QJdf5ysgHz0S7QdFFOGNIfM72uWkuGRqjmadkPlB0nUnrxhgi65hsNyhY152AfmQaujEGDNSybgjDUUEL85PXC9YdE7QQCETGsaRUYV99rrOuG7QQQufYxkoVamlCK88oWkfqPbG1DBWLOGPZNDDCjrlpGlmGs4ZVlQEAsm4gw1CxhOmek8l2o1fT5sERfu4p17BhYJiHZyZpZCmxdazuG+CqseVE1p30edg4OHL6T94FxBjDxsGRY47z9f1X8vqjAhvy4NldnaWeJkTWsnZoiMPNOjeO72ZfbY7cB4o2wnvPg9MTVNMEYwwDhSKtLKXoIgbiArFzJI2cepZgMYyUyqys9LNjboZWlnVeSyYwUizRzFKyEIiAPASMMThjFwU2zIc0FLphCwCxtbTyzku00H2ObTfUwXf7LhwjdMeeDx6Zz0gIdEIvjDEE73t9oTN2HgJ5CDgMeTf2ATrBDMZ0Bpjvn/ocT8AZQxZ8t93QyrPuWL5XR5J78uCxwVGIOvUH75hoNXDGUHQRxcjR9jkzSYsIw3iW8MjMJN+2jrFSGWstBlhe6Wf9wBBDxRJXjC7l2ctWUYr0tbLI+cyf6wJERERERERERERERETOQ9Fddz6+7e+8HULo3AFARERERERELnq6WlZERERERERE5CKSec8th/fy5b3beGhmgjx0pmLmIVBLE2LrWNc/ROw6E7N98Oytz1EwDmMMe+qz5MGzojLATLtF6n0vlKFgHa0850CjRl8Ud2aRHzWZvZ17Gnnam0y+kMUQgMhYsuCJjglasCwpVdi7IGgBwPvASKXE0nIfs0mLWppSco48BKwxjBbLxNayeXCU7dUpakkn6GH1wAAESENO6nNGS2UA+qMCjSylniU4Y1nXP8R/WbOZa5euZiZpMdFq4ENgsFBi0+BIb7L9psHRM/hMPfk4YxeFNRQKjpFSmUtHlgCQJHlvXS1N2F+vkvicShQzWixz58QBbj00zlzS5vKRJVhjmGg22N+oUU0ThopFplqeAPTHBcaKFepZyoFGlXYI3fCMQXKfc7jVxPtOaEGg85rIfN553YaAx2OPCmywxmAx5MH3ghmg83pOQk58VN/UdwIRCt2gkvnXc5gfyxh8CN0GwHeCP0IAH0Ln8YJ3UpLnC3NLCNCr2RqDp7MddEIc5mv13fdJK097j50xnUAKDDPtFrF1VKIYCLTznKl2C0IgDZ69tTnunzrEWKnC53c+AsCKSj9r+gdZVunjOSvWcOXoUpy1iIiIiIiIiIiIiIiIiIicr6J77n5c29uZGezePfi1685QRSIiIiIiInI+UwiDiIiIiIiIiMgFKITAgzMT3DW5n+mkRcE6lpf7uHf6EHdOHsBiGCmWKLiIEAL3TR+ikaVE1rKvblg3MIw1htmkTZLnFJ0DY8i8Z3+jSl9UoJlni/ZpjCG2lpmk1el/FGMMxkDuPcbQm/Ddq5nOXPOxUoUDjWonhGFB0EJ/qcBYqcJ00qKRphSdI8djukELzhg2DY6yY26auaSNJ7Cq0k9kLbn3tPKUwbhIxcUsLfdRT1MOtxpYY1he7ud71mzmuuVrqUQxh1p1kjynEkUsK/f36uwvFFnTP3S2njY5Rf1xgUuGxxa1vWj1Bl60esOithACO6szTLdbAIwUSzTSlG+O72Lr7BQDec7Kvn7AcLhZJ4RA5BzlKKKaJBRc530zGBfYVZ2hkSbd13knrORws0HicyJjSX2OsxYbOgEG8/uff1x0Ue9xbC3tvBM8Mh82YjGEEIBOMINZ+N4IAWM623UaANP54br95oMZ6AYzGDphC71RunkOWd4Js7DWkIeAD4E8ePIQcN3gh/mwhvn3eCfsoXMsPgRaaULJRVSimBACrTznYL1GCAEPHGrU2TE3zUBc5B+3P0RkDOsHh1le6efykSU8b9Vallf6H8MzLyIiIiIiIiIiIiIiIiJydkT33PW4x3CPPKQQBhERERERkScJhTCIiIiIiIiIiJznQncStTOdidt3Te7nk9vuZWd1uhd04ENgst2glWUsKfWxtn+IqDuhezZpkeQ5fVGMBybbTTCwvn+Y6e5juhO9I2tpZ56JVgNnzTG1WGPIgif1eWfGdwi9bRf2GYyLzCZtiu7I108hBIouYkmpwlS7M7m9YB2ezhhjpQqRtWwaGGF7dZpakuAJLC1VKEcx0Al46I8LRNYyXCiR+pyDzRoGw2ChyOs2Xsl/WLmeVZUBJttNWnlGwTpGi+Xe+QBY0zd4Zp8kOSeMMWwcHGHjUe1PGVt2TN8DjRoPTU/QzDIK1lKMIrbPTvOt8V208oyllX4aaYL3gdg6nLEMFUpMtOokIacSxazrH2IubXOwUcMaCwRiaym6IqnPibDd92vnfRktCFtwxmCNIQQodENMnOnEKvjQ2ef8egzdwAaI7eLAkxMGM5jOWzH1OZbF2nnefZt3QxjohDXMjzUf1pB5Txo8hk7b/P7SPMcTeu+9PHjmkjb1pBNakYfAZKvB0nIftxzcy5/deyvDxTIbh4ZZ3TfIdSvX8rQlyxe9B0Xk7PEc++e3iIiIiIiIiIiIiIjIk92jhTC0Xvt6ip/7J0yWnbBP9OCDpC/9njNdmoiIiIiIiJyHFMIgIiIiIiIiInIe8iHw4MxhvrF/J7dPjpN6T2wsI8US22anKTjHklKFqDtBezZpsb9RJbauG3CQsXlwjMhaJlqNXtCCpTMBfKrdZKxUIfUee9RkzchaZpImS4qVY+qan1BesI7YWrLgicyRSeIhBCLrGCoUmUvbvfCI+Qnlo8UKRec6QQtz0zSzDAgMFkr0dYMWnDUsKZUx3VoKLuJAo0boLj93+RpeunoTTxtZxkS7ST1NiKxlaalCqTsGwJLSsfXLk9eKSj8rKv2L2p6/ch0/fOnTaGYp1hjKUcx0u8nNB/aypzrXCTQwhlaWcf/UYWppQmQsfXGBRppSjiLGShWKLmJ3bZZ6mmCNoeQiVvYNc6BeI/MeawyJz4mtIxB676MQAs4aMh8odoMZjAGHIcUTGdsLXDAYfPBgDAXremNAN5gBg8EQun1DCJ14hm7Agln4Pg/zYQ2mk6HiAwFIemENkAePD4FGlhIMmO42kbWkuSfzHm8MA1EBYwytPGN/vdYLWphLEg41awwXy/zLzoeJjGXj0AjrBoZ4xtIVXLtiDf1x4ew82SIiIiIiIiIiIiIiIiLAW97y09x++2295RtvvPUcVnPhecMbrufAgf0ArFixkk9/+p/PcUWPnanOEW3fdtI+2TOvJnrgfqKHHjxhH/fwideJiIiIiIjIxUUhDCIiIiIiIiIi59hc0mZ/o0rqcypRzFChxJ8+8O/cM32QAPRHBYo2opa1eeDgYQAGC0VGi+XeGJOtBtYYYueIgqWWJuyqTbOpf4RGlhKZI3egt8ZAgMlmA0tnAvdCzlqyzBM515nEzbETuK2xLClXGK9XO2Ob+UnfhsFCkcFCiVWVQfbV5/CmMwm8HEUMdCdd98UF1g0Msac2RxY85SjiQLPWnUQeWF7u54e3XMVLVm1kT22OWtbGGcuKcj/LF0ykX1bug3LfGX5G5MkkspaBQrG3PFaq8KoNlx7Tr54m7JyboZ1nFF1EJY6589ABvjm+k7mkzbr+IRKf08oyrDGEAANxkal2EwgMFIqs6R/kYKPOTLtJZByeQNFFRNbjAUcnNMFYg8mhHEW9sIXIWtq5x2F6QQfWGHLfDWZwrvPe7grQDVnoBDNYw5FgBsKiNoAseDwB130vByD1njx02jyQ+UDqc9rdAIfQ3c7SCWbIgyfCUo4iQgjUspRmWiWyFh8CU+0mO+am+frenYQQWNM/yJWjS7lkZIznrlzLcLF05p9gkSchH8yjdxIREREREREREREREXkScQ88cNL1W4HPH9hPoVTiemD1CfqdLKBBRERERERELi4KYRAREREREREROUe2z03xtf07+PaB3dSzhM4N6QO1LIEA6/qHKUdxr/+hZg1nLAXrqKUJW6tTbBkcwwJzSasXtGCMoeAiZpM2jTw9NkSBzoTumbTFaKFMNU2OLc5A2UaUo5hmllJ0na+RQghgoOgcA3GFuSShliYUnSP1vtvemdC+vNyHM4bdtVnyEKi4ApPtJiEE0uCJjOV7127h9RuuYFdtlmraJrKWFZV+rhpdTmQdAJcOj535ky9ymvriAk8ZW7aobePgCK/bckUvyMAYw1SryS0H9nKwWcd7Txo81Xab+6YOU00SKt33VDvP6YtillX6yH1gT22WJM9xxlB2EX2uQDPPcK7zuQBggGLkesEMsbFkeCIM8aMEM4Tuf84Yjo5eMQa8P6oNSPP8qE+OQLvbZq0hD4HMe7KQEwhYY0h9Tik4GllG7j0GQ6VbRyNLOdSod4NbYHqyxY7Zacp7Ij5697+zpn+QZy1dyfqhEa5dsXpROIaIiIiIiIiIiIiIiIhcPN7whus5cGB/b/mGGz7Ks5519Slvn+c5v/d7v80Xv/gvi9pf9arrede7fgPn3BmrVS4O0cPHD084BPwS8PcAf/JhAH4R+CngfwFDR/V3Dz8EIXR+ySoiIiIiIiIXNYUwiIiIiIiIiIicZa08467J/Uy0GgRgMC5STdp8csc9pLlnIC6wsjyAMYZdtRlmkxbOWHbUptk0MELJxSQ+YyZpEVmLMYaijWhmKfvqc6wo9+OBeMEv+ecnXk+1W1hj8cEvqskYQ/CewUKRyXaDEEJvYncIAQI4a1nVN8C22Sky74msJQuegnUMFkpYY9g8OMKO6jSz7TaewIpKP3nwpD5QTRPaPueKkaW8ZOVGDjZrTLdbFJxj48AIL1i5njV9gwBsGhp9Qp4LkbPBLHjvjZbKvHLDJcf0mWm32F3tBC2UnMOHwHcP7uWWg/uAnBV9/dTTFAuUo5jIWA40atTSBGcMA4UiRVdmqtUi954AeDrv9YI7NpghNp1gBmMMFoOfD2awrntBUA7dMQrdAAfTzWEIgMWQB4/thrvMt/sQep8vAHkI+BBwxhBCwAdoZhlZ8Dhr8T6Q5DnGGFLvCSFgraEcRSR5zmzappYmWGOYaDZ4cGqCoWKJj95t2Dw0wrUr1rBucJinL1lOrIvlRE6Jf/QuIiIiIiIiIiIiIiIXrCzLeO97f4Ovfe3Li9pf+9o38Cu/8q5Fv7t7Mrv99lt561vf0lv+qZ96M29608+ew4rOLffQsSEM24EXA3uOas+B/wN8G/g6sDCq31bnsAcP4FesPCt1ioiIiIiIyPlDIQwiIiIiIiIiImdJI0v5/O6H+cr4Nqbbzd7FHrU0YSZpMRSXWN8/TKE7sTgLnpmkScnFWAytLGPb3DSXDI3RyFJ8CL273RtjiK1jJmkyVigfd//WGOaSFiOFEoeadSJ7bJ+yi+jvhkIUXWdydhY8sXNU4pjYOdb1D7G7NkuW5XhgRV9/bxK2D51Qidg4Vlb6qaUJ0+0m1hhWlAd4xZrNPHfZWt3RXp70hoslhoulRW1XLV3Bm658Fq08o2A7QQr3TR7iuwf2cLjR4NKRJcy0m0y2Gr0gg5KLqKUJxsBYqUJfFDNer5LmOYFOUIIzthfAABBbSyv3FIwlspYAGMD7gDEQW9cJSKATwhICxJHD56FXawAchpzAwsvWcu97+zHGQAikPscai6GT95B6jydgMQQDqc9xuaGZZ53gBmPocxF5CDSzjGZWxVnL/nqVfz84zmipTH9c4GlLlvGcFWvZPDzKir7+s/dkiYiIiIiIiIiIiIiIyHkpSRJ+8zffxbe//a1F7T/0Qz/KL/7i289NUXJBiB56YNFyAH6SYwMYFnoAeBvwt0e1u507FMIgIiIiIiLyJKAQBhERERERERGRxymEwIOzE9x6eB9T7SaRsYwWy9w5uZ8d1Rn64gLLywNYY/DBc6hRwwBzaZtH5ibYPDhKycXMtJvkPlB0Fujcsb6Vpxxq1ihHcXdvR6Y/O2PJfE4tS3DGkHfvRk+vZ6dtrFThcKuO95070AP44DsTtV3Euv4hts5O0s5zYmvJvWdZpQ9nOqkNSyv9gGFvfZaYzt3uDzSqBMBiuGx4Ca9edxlXL11NPU1o5imxdQzExV5Yg4gcn7OWPlvoLT996QqevnTFoj71NOHOwweYbDXwPjDRanKgXuXB6Qny4BkoFJluNXHWsqRcoRzF7K3N0sqzzieGgchYImt6QQnOGNLgKdmoF8yQ+E6QgzWd4IZ23tl/CJ3gBWctuc97bXQzGkz3cymEQOg2Lnzr+9AJajAGCJ3wlkaWYozBYvAhkPicdp7jQ8B0QxlCCDSyjP21OQyGR2Ym+cLOrSwt93HZ6BjXLl/DVUuXs7JvQJ81Igt4jpO6JCIiIiIiIiIiIiJygWu3W7z73b/KLbd8d1H7T/7kT/PTP/2W427z0Y/+n0XLSZKftfouRp/+9D+f6xLOGPfwQ4uWvwh86/hdF/kk8B7gqQva7M4d8NznnbniRERERERE5LykEAYRERERERERkcfh3qmD/PW2u9lZncaHgDOWQOBgo0bb54wVKywt9/UmCM8kLbIQKLmIEKCd52yvTnPp4BLa+fwFH0fuKh8Zy1S7yepo/mucAIvuQ29IfM5oscLhZh1nj0y8DAQiYym7iNFimYlWg6KJMMaQ+cCKSqeuoovYMjTG9rkpqmmbyFiKLqKWJng8jTTFWsN/2vwUXrpyM7tqM7TyjJKL2Dw4yqaBkc7EbqAvLtAXFxCRM6cvLvD8VeuOaR+vVTncrJOHQDvP2D03wzf27WIuaTNaqjDVahJby1ChRGQN441a7/0cdT8r5oNbImOgm6tQiWOs6fRJ8hwDRNYtmtbdCWvoBCgsbIPFn1AhgAeiBa2BTqiDxXQ6h0Crux9nDD5AK8vIQyAPHgP0xzEBaKYpu7MZ9lRn+PKu7QwXi1w5uoyXrtvEc1esZqhUfpxnW0RERERERERERERERM43jUaDd77z7dx55+2L2t/yll/kR3/0J89NUXLBMNU53Pi+RW3vPY3t3wf8zYJlt2PbmShLREREREREznMKYRAREREREREROQUTrQbfObCL2ybHqaUpJRcxUChw58R+rLEsKVaIrANgLm2Rh0DROWaSJu3ZjM2DoxRdxFS72b1DfOeu8AXraGYZ00mzdwf5hZyxJCEnDwFrDHn3DvYLeQLLSmUmWnVy73tBDD4EBoslMIa1/UPkITDTbhHojDVa7ExWDt270A/ERZaX+9k8OMJ4o9ZpKxR4+ZrNvGj1Rtb3D5GmnsuGl5zVcy0ip2ZV/wCr+gd6y9etXMvrt1zJbNImDx6L4f6pw3x1z3bG61VWYZhuN4mMpS8ukAXP4UadxHucMZSjqPdZE0InxCUhx1lLuRsE0/Y53nc+rUqRo5V3PrdCCISwIFhhvq0buGB6bd0Ah6NCGQIQG9vrlPi8FwSRe08r74Qy+BAwAfoLBbwPTLdbfGf/Hr6zfw9F57hidCmvvfRyrlu1juFS6ew+ASLnqXDsXydERERERERERERERC5Y1WqVX/3Vt3Lffff02owxvPWtv8J/+k8/dA4rkwuFe+ThRcv3AzefxvafBj4KDM6Pt3PHmSlMREREREREzmsKYRAREREREREROY4QAsYYUp/zt1vv5ivj22nlGQXriIylmWfsrc8CMFaqMFas9LadaDXAQGQczlqaecrO2jSXDi7pTCxeMPnYGIM1hsOtOiOFYycMG2M6t5EPhuFCial2E+fsoj4F66hEBVZWBhivV49sB72gBWssG/qH2WPmmGw3qLiYuaTFbNIiBOiLY1617lJeve5SlpX7e+egWNTXRyIXktg5lpSPfB69qNLHi9ZsIHRnZWfec9fEQb49vouDjTrLyn0catTwQNE65tI21SQB0wlFKEcxPvheMIPBkOMpuYjYWrJgSfK891nmjCENHuiELZjuz3nzYTNmURu444Qy2AWBM/NBEfOhDM00w9MJZbDGUHYRic+58/AB7p86RGwdT1+2ktdecjnPGFtBOYrP6HkWERERERERERERERGRs292doZf/uVf4OGHH+q1WWv5tV/7da6//rXnrjC5oLgd2xctf/Y0t0+BLwOvnx9PIQwiIiIiIiJPCrqKXkRERERERESEzsTku6cO8NXx7TwyO0nqPZUoJvM5B1t1lpb6GCmUe+EG1foszlhia5luN0l9zuaBMayBubRN1L2juzGGoo2opynVtH3MhGToTHRuZRmlSowx9CYV95jOXeSXlvuYSVpkPieyDh8CGBjqhjesKPdjMeyrz5H4nIG4iAGaWUorz2hmKQNxgZ++/NmsrgxwqFUnD4GBuMBVoysYKBQX1WUW1iAiF7T593PsHFcvX8XVy1f11mXec+/kIW47NM50q8l4vcq+2hy573zGTDYb1NKkE3YQdcIOXHc8ZyzQCZepRBGeQJp5QugEKUTGknU/9ebbzIJ6fDewYf7TJoQj4Q3zfPfn/OdiANLgiYzFdXNq2j4n957Q3U9mA9/et4s7Du5nqFDimuWreO2Wy7lkZEyfbSIiIiIiIiIiIiIiIheAqalJ3v72n2f79m29Nucc73nPe3nFK175hNfjvef+++9j69aHmZubpVQqMza2hGc845mMjS05I/uYnp7ivvvuYXJykrm5WcrlMiMjo1xxxVNYtWr1GdnHEy2EwNatj7B7905mZqap1WqUSiVGR8fYsGEjmzZtwTl3VmtwC15DcPohDAD/woIQhqNCHUREREREROTipBAGEREREREREXnSCSHQ9jkhBEouYl9jjg/fdzO7qjMYoC8u4Ixlb32OQ80asXUYDGv7hjBAFjxT7QaRtVhjKVpDLU3YW59ldd8gIQRsN4QBjkw2nmg3KEcxzTw7tiYCsbH0x0WqSZuii3q1AhSsoy8qsL5/iJ21GRKfEQKUo5j+qNAdAypxgdFSmcFCkZKNaeYpAIOFEq9dfwXPX7GOpeW+s3dyReSCE1nLM5au4BlLV/Ta0jznjsMH2DY7xUyrydbZKfbVqxACjSxjqtWk7XNi6yi5TviCsxbbTVHwQMFZCtZRz1K8DwTTCVKY/1yDIwEL87EI86EMthfSEBatnw9pgE44TcDgvceHQGQsgdDZxnvy4JlLWjSTlH+qP8RXdu/gyrElvGzdZl6xfhOFSF+Py8XJo6AREREREREREREREbmwHTp0kLe97efYs2d3ry2OY/77f/9dXvSil57yOG95y09z++239ZZvvPHWE/b9/Of/mfe977295V//9f/Gq151Pd57PvvZT/PXf/0XHDp08JjtjDFcc81z+cVffBubNm055drmee/513/9PJ/5zN/z0EMPLPpd2kIbNmzkR37kx3nlK1+Ntfa4fQBe8IKrj9v+8Y//GR//+J+dcLsbbvgoz3rW4m3f8IbrOXBgPwArVqzk05/+50c7nJ4DBw7wiU/8X775za8zPT11wn4DA4Ncd93z+f7vfz1Pf/ozT3n807EwNGEcuO3EXU/o8xwJk7czM5iZacLwyJkpUERERERERM5LuspURERERERERJ40JloNvn1wF18Z385M0gI64QbT7SYEWN032L2reycUYWctoegirDFMtBrk3rNhYIRmlpL7QNF1+hpjiK1jOmmyvNyPwRxzJ3dnLNU0YUP/EFOtJkff691gsMawqjLA1iwh8RkF68iCp2gdA3ERgJFiBWctO6sztHxG0ToONmv40Km6EsV837rL+MHNT6MSxbS6gQ8lF+nu7yJyymLnuHbFaq5dceSOOrUk4dZD40w0G+yrz/Hg1ARTrQYBmGjWqaUJ1hjKUUTqPQXrsMZgMOR4HJZyFNHIUgKdkBlD55Nw/vOpF7DQ/RmOCmE4OpTBe99bNga8D/je2KY3WAiB2aTFzQf2cevBcT5x/5388OVP44Vr1jNWrpzx8yciIiIiIiIiIiIiIiKPzfj4Pt72tp9n//59vbZCocjv/u77ue665z+htdTrNX7919/JbbfdcsI+IQRuueUmfuZn7uB3f/cDPOc5153y+Hv27OY3f/O/snXrw4/ad+fOHbzvfe/lH//x/+P3f/+DjIycnwEAIQQ+/vE/4xOf+Dhpmj5q/2p1jn/7ty/wb//2hZOGZDweC0MYvvUYxzgAbAPmYzbs3r3kCmEQERERERG5qCmEQUREREREREQuSkme08hTImOpuIivHtjBJ7beRTNLKbuYiosJBLbOTdPIEgrOUXCO5aV+jDHMJi2SPKfoHGAw1jCdtBhoNSg4150BfCTUwGJIA8wmTUouopmnFMyRr16M6Uwe7o+LlKOIVp5RsJ31efBE1lK0Ec5aNg6MsLM6TSvL8ARWlPt7d4+vZwn1NGFt3yCvXncZuffMJC0KzrGmb4jnLFvDUKHU2285ip+gMy4iF7v+QoEXr9nQWw4hsLs6y/1Th5luNblv8hA7qzNk3jObtKkmbQyG2FqMh6JzxNYSGUvicyyGonWk3hO6QTLz5kMZfHfZmk64jedICEMIR9ZD5zPWL9jeYMiDJwmdfc23hQC7q7P8wW3f4aN338rrtlzBGy69UmEMctHIOfHdr0RERERERERERETOd2Z2Brt//7ku46LiV64kDA2f6zJOye7du3j723+eQ4cO9trK5TK///sf5NnPvuYJrSXLMt75zl/mrrvu6LWNjIyydOky8jxnfHwvzWazt67VavEbv/EuPvGJv2PFipWPOv59993Lu971dmZmZha1O+dYuXIVAwODNJtNxsf3kSTtBdvdw1ve8lN89KMfP++CGLIs47//9/fw9a9/5Zh1cRyzbNlyBgeHaLWaHD58mFqt+oTU5XYeCWG48XGMcwtHQhjcvr3kT33a4ylLREREREREznMKYRARERERERGRi4YPgQdnDvP1Azu55fBeMu8xGIyBqXaD0UKFVeWB3uTeWtom8zl9UQEfAvsaVUKAlZUBmnnWHbXT1xqDNYZDrTpr+wa7c4VDb31nci80sowlpQq7a7OL1ofQHQPD+v5hts5NkviMgnXkIbC8VMHZzqTJwbjExoERdtdmsd1JxAeaVUIIVKIC37NmCy9btZkNA8NP0JkVETmWMYb1g8OsHxzutTXSlDsO72ei2eDB6cM8ODVBPU1oZhnT7RaJ91gDzhgK1lFyET5NSL3HGENkLFnoRCmEEBbvMCzet18Y2kDnz4Be1wB+QURDJ5Ah4AmYbv8sBKrtFn95/1388/aHeMHqdfzSM59DX1w4g2dJRERERERERERERERORXTzdxl41zuI7r/3XJdy0QnGkF/xFKrv/0Oya59zrss5oe3bt/HLv/zzTE5O9tr6+/v5wAc+xNOe9vQnvJ6/+qv/x/j4PgBe8Yr/yH/+zz/B5s1beuuTJOFLX/oiN9zwB9TrdQCazQZ//Mc38Nu//XsnHXtycoL/+l/fsSiAYfPmS/ixH/tJnve8F1KpHAkPb7fb3HjjN/nYx/6Iffv2ArBv317e977/zvvf/7971z/M+8M//CMAtm59hD/6o//da//e730Vr3zlq09Y05Ytl5605lPxx3/8oWMCGC655FJ+8id/mmuvvY5yubxo3d69e/jOd27kS1/6Ag88cP/j3v/xmNkZ7ILX1D2PY6xbgB/pPrbd50JEREREREQuXgphEBEREREREZELUgiBepaS+Jyy63zF8acP/jvfPbSXAAzGRSpxTCtPeXh2ikCgmWXE1jJYKAEw2W4SOBKwgIf9zSqDheKxk3+B2FjaeYYnEFlLFgLRggsajOlM8h0pljnQrJH4nIJ10A1SGCmUMcZQiQpsHhxjR3WaRpZiMPRFBVp5RuZzqlmCAb53zSX82CXP4ECzSivPKNqIDQPDDHXrFxE531TimOevWgfA93M5uffcN3WYnXPTbJ2Z4p6Jg8y12yRZxkzSouYTLAZjDAVrKbmIapqQew90gmsCoRO64Dufy/MhCgtDFwyLQxkCYWFmA3nw9EJzumOGEPCACZ7JZpN/3vYQ3xnfw49ecRWv2Xw5pUhfn8uFKWAevZOIiIiIiIiIiIjIeST++lcZ+s//CZOm57qUi5IJgej+exl+3auY/etPkb74pee6pGM88shDfOITH18USjA4OMQHP/gRLr/8inNS0/j4PowxvPOd7+H66197zPpCocCrX/0a1qxZyy/90s/ifScg/Jvf/BrT09OMjIyccOz3ve+3mZ6e6i2/5jWv4x3veBfRcX4/VSwWednLvodrr30u73zn27jnnrsBuOmmb/PNb36dF73oJYv6X3NNJ2jDObeofdWq1b11Z8PNN9/E3//93y5qe8Mbfoi3vvUd2O4NKY62Zs1a3vjGH+aNb/xhbr31lrNSl9uxfdHyV4GHgBu7/30L2HGKYy2s0HUDOkREREREROTipatIRUREREREROSC0sxS/n1iH/+2dyu76rP4ELAGkjynnias7RteNHF2st3AGkPRRiQ+Z1t1ms2DowzGRRpZ2glf6IqsJcs9k+0mReuO2bcxBgyk3jNWLHOwWSdy89OBO8EQkbU4Y9k4MMK2uUnaPicynQsKlpSO3K2i7GKWlvqoZwkryv208ox61iYyjhet2MCLV23k8qElGGNYVu47S2dTROTsctZy1ZLlXLVkOdD5nHxkZpJ7Jw/xyPQk90wcopa0SXxONUlo5hnWGLIQKDhLbCyNPMOHI7EK86EN82E5BhYFMACEbnuYX1iwvLDv/J8AnoAPcKhR50O338zntj/Mrzz7eVy1dPkxdw8SEREREREREREREZEzKAT6fu+3FcDwBDBpSt/v/w4zL3oJnGe///jIR/73ohsljI6O8Yd/+Eds3rzlHFbVCRE4XgDDQk9/+jN5yUtexle+8iUAsizjtttu4eUv/97j9r/33nu4+ebv9Jaf+9zn8Wu/9uuP+jupgYEB/sf/eD8//MM/QKNRB+CTn/yrY0IYzpWPf/zPFi1/z/e8kre//VdPefurr772TJcEHBvCYIEruv+9udt2zze/y80PPcib3/yTJx3rdiAFYsDu23umSxUREREREZHzjEIYREREREREROS85UOgkaVAoORi9tZn+d/33cR4o0psLANxEWcMB1t19jXmiIwlr0+zqX+UgnN4AhOtBs52JuwWXUQ7z9hdm+HK4WWdu6sftc/IWKbaDTYPjGJMZ8LwoosdQqdtSanCZLtJ4nMKNupdEDJcKAHQFxXYMjjGzuo01TSh5CKSPGPKexLfmVC8vNzPr1zyPJ61ZBVtn5PmOeUoIjpOAISIyMXAGMOlI0u4dGQJ0Pmcf2DqMLcfHOeeiYM8ND1B7gOtPKOdZ3gTIHRCEmLrCCHgCZ3PZjqhCs4YfKAX0tALX1i436M+7ef7hKPaAPLgeXh6krd97Qt8/6bL+MVnPYfY6XNZLhz+mL/diIiIiIiIiIiIiJy/zNws8R23n+synjTi22/DzM0ShobPdSmLLAxgAHjrW99xzgMYisUiP/mTbzqlvi996St6IQwADz/84AlDGD71qb9ZtPzWt77jlEPBx8aWcP3138/f/V1njHvuuYupqUlGR8dOafuz5f777+Xee+/uLVcqfbzjHe86hxUdcXQIw9H88DArLr+S77/8SpyL+C//5UdP2LcNPAJciUIYREREREREngwUwiAiIiIiIiIi553DzTrfPribL49vYzZtQwhYY5lLWhhjWNc31LsIwROYS9sUbURsLPU0YWt1kksGxwgEsuCJF4QaFKyjnefMJi1i62hl2aJ9O2Noe48zhv6oQDVLKJrOVyjzF344aym6mA0Dw+yoTtPOO2PEzjHUDWEIoXNX9cFCiS1DY2wZHGOy3cCHwLJSH89bsY5njq3s1VZyESWnr2pE5MnFGsNTxpbxlLFlALSyjNsOjfOd8d3ccWg/h5sN+mNLO8/BdD6jW7nHYLDG4LtBOSF4gEVTz48OYggneHy8QAaAZp7x6Ufu586Jg7z3eS9hw3l2MaKIiIiIiIiIiIiIiMjF6oMffD/r12/kkksuPWc1XH31tQyd4u+Hjq7z4MGDx+3nvefmm2/qLV9xxVNYt27DadV1zTXP7YUwANx11x285CUvP60xzrRbbvnuouVXvvJVDAwMnKNqFnu0EIZ846be46c//RmPOt59dEIY3Pi+x1eYiIiIiIiInPd0Zb+IiIiIiIiInFMhBBKfE1mLxfDV/Tv4y0fupJmnVFxMf1QgENg2N0UtTSg4R2wsKysDGGOopQmtLKPoHAZD0UY0spT9jRrLy33H7G8+vGGi3WCkUGYuaRMIx9wlHQwrKgPU5ibJfE5kHXkIWGMYjIsADMYltgyOsbs2QzVN6LcxB5o15qfy9kUFXrn2En5w01Pp724jIiInVooinr9qHc9ftQ6AvdU5vrVvF1/ds53ts1PkPhBbRyBQsI5mlpL7I/EJDoMHwnykwtHJChwJXZh3nC49WQg8NDXBL33187z3eS/mWctXPd5DFDnrfDi1u2WJiIiIiIiIiIiInA/C4BDpM59FfMft57qUJ4X0Wc8mDA6d6zKO8ZrXvI7Pfe4f8b4TvD03N8sv//LPc8MNf8qmTZvPSU2XX37lKfcdGRldtFyv147bb9u2rdRqR9adzj7mLV++YtHyrl07T3uMM+3uu+9ctHzddc8/N4Uch9u+7aTr841HXl9r1qylr6//hM8fwP3dn3b/OOQ5OHfCviIiIiIiInJhUwiDiIiIiIiIiDzhQghsr07zzQM7uenQHtp5hjGGonWMN6qMFSusKg/0AhMaWUric/qiAj4E9jdreGB1ZYDE5xhDL0TBGENsHFNJg+Xlvt6d0q05MiHRGUM7zxgultjXsGTeE9vOL8Y9AWMgMpZKFLOhf5hdtRlaeUoIgWXl/l7fxOfUs4SRQpnXbbiSpaUKc0mbyDqWV/q4dukahgqlJ/bkiohcRNYMDPLDlz+NH778aVSTNjcf2MsXdjzCPRMHaWYp1hhCgHIU08qyRQEMFoMnAOaUQxeOJwCHG3V+7Rtf4nee/1Ket3rtmTk4EREREREREREREREBY6i/+7cY+s//CZOm57qai1qIY+rv/i0w51+Y78tf/r087WlP533vey8hdH6bMzMzw9vf/vN85CN/yrp1G57wmkZGRk65b7lcXrTcbreP22/Xrh2Llj/72U/x2c9+6vSLW2BubvZxbX8m7Nu3d9HyYwmXOFvcju0nXZ9v3NR7bIzhsssu4/bbbzth//vm+6Yp9vAh/IqVZ6JMEREREREROQ8phEFEREREREREnlCtPOP/PHQb3z64mzx4BqICJRfTzjPunT7U61Owjr64AMBUu0EIYK3BGoMJcKhVY6hQPO5sWmcMbe+ppgnDhRKTrSaRs4v6BDpBC6sqA+yuzWKCJzKW1HuGCkUK3bsVjBQrxNaxszpN2+dg4ECzCnTupn7Z0BL+47pLuWbJ6l5ohIiInHkDhSIvX7eZl67dxGSzwU3793Djvt3cPXGAWppijMEHT2QcefCYbjzPwj8mjl4+ruN0CEAtTfhv3/kqf/DiV3LV0uVn6rBERERERERERERERJ700he/lJnPfp6Bd/4y7oH7MOF0I5XlZIIx5Fc8her7/5Ds2uec63JO6D/+x+8jyzLe//7f7QUxTE1N8ta3/hwf+cjHWLPmiQ3KLhSKj3nbcILX8OzsmQ9MqNVqZ3zM0zU3N9d7bIxhaGj43BWzgKnOYScOn7TPwhAGgEsvvfykIQz3L3hs9+1VCIOIiIiIiMhFTCEMIiIiIiIiInJW5MFz7/Qhvr5/Bw/NTpB6T18U08xSDjbrrKoMUHRHvpqYTVo4YylaR+Jztlan2DI4Sl9UoJVni27G4bphCROtBqPFMiF07nzemW5LLwwh8TljxQqT7SY+BGy33YdA2XZCFpaUKuTBM16vkoWcYGBJsQ/oXBgxl7appQmXDi/hR7c8nVae08xTitaxYWCETQMjCl8QEXkCWWNYWunjNZsv5/pNl7Ftdoqv7t7Bzfv3smtuhlaeYzD4BRe3WcDz2AIYFqomCb/xra/wV69+PYPF0uM8EpGzw6O/l4iIiIiIiIiIiMiFJ7v2OUx//TuY2Rns/v3nupyLil+5knCeTIp/NNdf/1rSNOWDH/yfvbaJicO89a1v4SMf+RirVq0+h9U9frVa9YyPeaLAhydSo1HvPS6VSlhrT9L7ieN27njUPkeHMFx22RUn7f8wkAIxYMf3wbOveewFioiIiIiIyHlNIQwiIiIiIiIicsaNN+b48H03s706DQT6ogLWGHZWZzjYrBFbhzOWNX2DWGPwBCbaDZwxGGMo4EhCzq7aDFcMLT3uPmJrmUlarKr0U7COzHvibrBCRyAQ6I8LjBXLTLQaFG3Uuwv6WLECgMGwojxAwUbsqc/ijKGZJbTylBACQ4USr9t4BS9btYll5f6zfepEROQ0GGPYMjzGluEx/stTn8UdB/fz2W0PcO/EIaZaTUII+BAePXwBTiGhodPlULPO7978LX7/hS9XCI+IiIiIiIiIiIiIyBkWhobJL5DAADk7Xv/6/0SWZdxwwx/02g4dOsjb3vZzfOQjH2P58hXnsLrHp1RaHPL98pd/L69+9Wse15hLlhz/moonUqXSR7U6B0Cr1cJ7f14EMdjdux+1T77h6BCGy07aPwV2ApcAbu/ex1ybiIiIiIiInP8UwiAiIiIiIiIij1mS59w+Oc63D+1molXHGMNIocR9U4doZBnLy/1E3V+sewK767MUXYQzhkOtGnnwbOgfJg+e1OfEphOiMB/E0Mwy5tI2Bes4+uYNFkMaPFkILClV2NeYI8JiMN07PRhi4zAY1vUNATDZapKHTljDcKFzcUPic6bbnfZXrb2EH1j/FCbbDRKf0xfFXDq0hHIUP2HnVEREHpvIWq5ZuZrnr1/HVLPJv2x/mL974F4ONxpkPscC+Yk2Po0bBAXg23t3c//kYZ6yZNnjL1zkDPMoHERERERERERERERELmxvfOMPk2UZf/zHH+q17d8/3gtiOB+CBx6LoaMCRvr7B7jmmuecm2LOoMHBwV4IQwiB2dkZRkZGz3FV4PbsOun6UOkjLFmyqO2SS04ewgCwlU4Igx1XCIOIiIiIiMjFTCEMIiIiIiIiIvKY3HJ4L3+x9Q4Ot+pYDEUXEQh85+Bu2nnOUFxkuFgisgUAamlCK8souk4wQtEaptoN+uNCLxBhofm7i0+2mywtVTjcahAImKMmFoYAS8t9zCQtGllK0Tk8AWsMw4UiANZY1vcPE1vHRKtBf1TgUKvWW3fp0Bjfs2ozz1m2htg6NjJyNk+diIicZaPlMj/2lKfzxsuewk179vBn99zOIzOTeO+B08pcOK4seD5216186GWvevzFioiIiIiIiIiIiIiIyDF+5Ed+jCxL+djH/rjXtnfvHt761rfw4Q//KWNjS06y9flp5crVi5b37dtzjio5s9asWce+fUcCCR588H6uu+4F57CiDrtn90nX5+vWgVl8Dcrq1WuI45g0TY/pHwEbgaS77PbtOzOFioiIiIiIyHlJIQwiIiIiIiIiclLNLOWWib08NDtBI0vpjwrkIfC1/duJrWNleQDb/aV0LU3wIVBxEc08ZWt1ki0DY/RFBdp5hjH0QhSsMVhjOdyqM1os44zthCcsCFlwxtDMUvrjApUoppmnFG3n64xA53fhsbVExrJpYITttWnqSUJOYEmxTMFFhBCoZQnVtE3BOt511Qt46sgyptstAjBcKLGmb7AX+iAiIhePYhTxvNXreO7KNXxz3y7+6v67eWDqMFlYEMPwGBIZAnDX4YPUkoT+QuGM1StyJvhgz3UJIiIiIiIiIiIiIiJnxI//+H8hTVM+/vE/67Xt3r2Lt7/957nhhj9lZOTCusHClVc+hVKpRKvVAuDee++m3W5TLBbP+L6sfeJ+X/D0pz+Dm2/+Tm/5ppu+fV6EMLhHC2FYu+6YtiiKeMlLXoZzEZfu3M7lD9zPZmALsJbFE3DsRRKiISIiIiIiIsenEAYREREREREROa7Me/5x9wP8675HmE1agOmEIuQZh5o1IutYXRlgYXTBZLsBgLMWGwxtn7O9OsUVQ8uAY+e5xsbSzDLqWcposcyhZp3ILb4QINAJbljTN8jWuSkSnxNbS+JzBuMiBesAKLqISwZG2VGboZ1nFJxjX2MOgL6owCtWb+HFKzeyeXAUgNV9Q2f6lImIyHnKWsuL127kRWs28I/bHuTP77mDw836Y8lf6GnnGd8Z38MrNmw+Y3WKiIiIiMjZkyQJ27dvZ9++fRw8eJB6vU6WZfT39zM8PMxll13G5s2bcc6dkf1lWcZdd93FI488wszMDNZali1bxlOe8hQuueSSM7IPERERERGRJ4M3velnybKMT3zi4722HTu28/a3/zwf/vBHGRy8cH73H8cxz3rWNXznO98CoNls8vnP/zOve90bzvi+SqXyouX54Iez4TnPeR4f+9gf95b/9V8/z5vf/PMMDAyctX2eCrf75CEM/jghDAB/9Vd/D0DlD/4nfQ/cf8Lt7b59j704EREREREROe8phEFEREREREREqKVtbp/cz1Q3RGGoUOKOif3cdHgPA3GBleUBjOnELeypz2IxWGBvfY52nrO2bxBjDI0sxXb7GWMoWkfb58ymLSJrIUAgYDjSx5jORNbRYpnDrTp58DjTCWLwIVDo3p1hIC6yaWCEnbVpWlmGJzBWKmOMIQ+emaRFK8/YNDDC255yHbG11LOUyFhWVPoZiM/8nSNEROTCYozhtVuu4JUbtvCHt32Xz217iOwxRjF44O7DBxXCIOedsCgiS0REROTJ7Ytf/CLf+c53uOOOO9i+fTtZlp20/8DAAK9+9av58R//cTZvfmx/16/X63zsYx/jk5/8JDMzM8fts3HjRt785jfz+te/vvedm4iIiIiIiJzYz/7sL5CmKZ/85F/12rZte4S3v/0X+NCH/uScT/Y/HT/yIz/WC2EA+PM//1Ouu+4FrFix4ozuZ3BwcNHy/v1nLzDgsssu56qrnsHdd98JdP5t/MEP/k/+23/7H2dtn48qBOyeTgjDTcCfA5cv+G8DkK9df9Ih8tVrTrreHToI7TYUdT2KiIiIiIjIxcg+ehcRERERERERuVjNtJv8xSN38Lbvfp4/euC7/O32e/jb7ffwP+/+Fp/ZdR+Zz6lEce9i8Mx7ptpNYueIrSO2lsOtOodbdQBCWDztz5hO3MLhVo3+qEBkLXk4arJr6GxXiWKWlvpIvCcPgRACARgtVnpdhwolNg2MUoljBgslmlnKvsYcB5t1RgplfuKSZ/Lbz34ZmwdHWdc/zBXDS7lkaEwBDCIiskgpivmv176A33vhy+mPC49pDANsn506s4WJiIiIiMgZ9b73vY+/+7u/4+GHH37UAAaAarXKJz/5Sb7/+7+fD3/4w4Sjv8d6FA899BCvec1r+OhHP3rCAAaAHTt28Ou//uv89E//NNVq9bT2ISIiIiIi8mT1i7/4dt7whh9a1Pbwww/yjnf8IvV67RxVdfqe8Yxnce211/WWZ2amecc7foFdu3ae8hjee775za/zx398wwn7rFixknL5yPUWt97678zNzT2mmk/FT/3UmxcFDX7pS1/kQx/6g1P+t/Wtt95yRusxszPYaud450MYfg24HrgE6AOu/bM/4ad+6kf5wAd+77hj+FWrH3U/9sD+M1SxiIiIiIiInG+ic12AiIiIiIiIiDwx5pI226tTtPKMkosYiAt89MF/Z0dtmuFCiZXlAYwx5MFzqFnDGcNEu0EjT9k8MErRRbTzjMx7is4B4IwlN4FDrTpLSn1E1tHKF1/QHllLM8+wxjBWLHOgWcM5g8H0ghactRgMq/sGCSFwuN0g957YOoa6AQpJnjGVtPAh8PLVm3nTJc9kJmmT+JySi1nTN0Bk3RN9WkVE5AJljOE/rN3A21tt/sct34T5679O8Sa0AUhzf7bKExERERGRs6RYLLJy5UoGBgbw3jMzM8P4+PiiSSFpmvKRj3yE/fv38773ve+Uxt2+fTs/8RM/wfT09KL2SqXC2rVrabfb7Nu3jzRNe+tuvPFG3vzmN/MXf/EXFHXXTBERERERkUf19rf/KlmW8g//8Jle2wMP3Mev/upb+YM/+AiVSuUkW58/fvM338ub3vRjHDp0EIDdu3fxpjf9KNdf/zpe9arr2bLlkkWBBgBzc3M89NAD3HTTjXz961/l0KGDPOMZzzrhPqy1XH31NXzrW98AoFar8rM/+5O8+tWvYf36DZRK5UX9L7vsCgYHBx/zMV1zzXP4wR/8z3zyk3/Va/vUp/6Wu+66nZ/4iTdx7bXXUS4v3ufevXv4zndu5F//9fM89NAD3HjjrY95/0dze3b3Hj94nPUJ8MD4Ph4Y38fWrQ/za7/27mP6nFIIw8GD+PUbHnuhIiIiIiIict5SCIOIiIiIiIjIRW53bYYvj2/jWwd30chSrDFk3jPVbmCMYWP/yKK7gE+3W+QhUHQRBGhmGdur01w6NIbvzlA1C2aoxsbSznPm0jajxTLVtE3gyBxWgyEQ8CGwrNzPTNKinecUnSMPAWcMg92gBYthbf8QsXUcbtXpiwscatcBiIzliuElvHzVZq5duprIOkZLfU/IORQRkYvT7QfH+aM7bzntAIZ5A4XCo3cSeYL5030hi4iIiFzkli1bxotf/GKuvvpqnvnMZ7JmzRqstYv6zM7O8q//+q/80R/9EQcOHOi1f+Yzn+HZz342P/ADP3DSfWRZxtve9rZFAQzDw8O8+93v5tWvfjVxHAMwMzPDxz/+cT72sY/hfSfU7Y477uADH/gAv/Ebv3GmDllEREREROSi9iu/8l/JsozPfe4fe2333HM373zn2/lf/+sGSqXSOazu1IyMjPKBD3yIX/u1t/WCGFqtFp/61N/yqU/9Lf39/SxZsoxKpUKz2WBubo7JyYnT3s8b3/gj3HjjN3vBg3v27OajH/3IcfvecMNHedazrn7sBwW85S2/yKFDB/nqV7/Ua3v44Yd4z3veSRzHLF++ksHBQVqtJocOHaJWqz6u/Z2M3X3yEIaFtmy59LjtfvnyR9/PwQOP2kdEREREREQuTAphEBEREREREbmI1NOEQ/U6ARguFHlwdoI/euBm6lnKYFxgZbkfYwwTrTrtPMcYwyNzk2zoH2ak2LnjQC1LgG7QgoGidTSylNmkRcl1LhgPhF4QQ+fuC4F6lrC81M8+a8m8J+5ezO5DwALOWKwxbB4cZdvcFM0swxNYXuojto4QAs08YyZpEVnLO576PK5ZspqppIkPgeFiiZXlgWPu9iAiInK6plpNPvXgfXzywXtoZNmRFacRxmCANf2P/W5AIiIiIiJy9n3sYx/jsssue9Tvk4aGhnjjG9/I937v9/JTP/VT3Hfffb11f/iHf8jrXve6Y4IbFvrMZz7Dww8/vGi8v/7rv2bLli2L+g0PD/PLv/zLbNmyhV/91V/ttf/t3/4tP/qjP8qGDRtO8whFRERERESefIwxvPOd7yHLMr74xX/ptd955+28613v4P3v/0OKxeI5rPDUbN68hT//87/id37nt7jllpsWravVatRqtUcdY/nyFSdd/8xnPpu3ve1X+MhH/jfZwt+JnSVRFPHe976PtWvX8dd//ReL9pmmKXv37j7J1meW27Or9/jRQhguueT4IQyhf4BQqWAajRNuaw8phEFERERERORipRAGERERERERkQtcCIFHZif56vh2bjywm2aWAoE8BOaSNgNxgdWVwd7F5gGYbDdx1lC0EYnP2VmbwVnLYFwkD56F16Ub04lbONxqsGVglJLrbFOwbkEVhtwHImtZWR5gT30WEyAylix4RgplbHfQsou5dHCMHbUZWnmGMbC/USUQKLqIF65Yz8tWbeKK4aUALKv0PyHnUUREnhwemZrkg7fexCPTkyR5TidK6CinEMbgjOWaFavPTpEij4M/lRQRERERkSeJyy+//LT6Dw0N8YEPfIBXv/rVvbuEHj58mNtvv52rrz7+3UCTJOFP/uRPFrW9853vPCaAYaHrr7+eb37zm/zTP/0TAFmW8eEPf5g/+IM/OK16RUREREREnqystbz73b9FlmV8+cv/2mu/7bZb+PVf/zV+7/f+F4VC4RxWeGpGRkb44Ac/zF133cHf/M1fcvvtt9JsNk/Y3xjDJZdcyrXXXsf3fM8r2bz5xP/2nPeGN/wQ1133Ar74xX/h7rvvZNeundRqVdrtdu/fvmeSMYY3v/nneNWrrucv/uLP+eY3v06tVj1h/9HRMZ7//Bfymte87ozWYfd0Ah8mgcOP0veE59EY/LLluJ07TryfgwcfW4EiIiIiIiJy3jPhbPzLWUQuCIcPd77QKhTcovYkyc9FOXKR0utLzha9tuRs0utLzha9tuRM8iFgjSEPns/svp9/3PkAefAMFIqUTEQAHp6doJq1KVjHkmIfa/oGscaQ5Dn3zhwkNq4XjNDOMypxzGWDS9hdn2Wi1aDkokX7S0POU4eXM5O02FOfpegcpjvJr5WnrKgMsLoySKATqnCgUcWHAAYuHVzKYFwkhEA1S5hL2oyVyvzSlc/FGUsjS4itY1VlgLFS5RycUTkRfXbJ2aLXlpwtJ3pt7Zqd4Ys7tvKph++jmabkIRwbvnA8J5jPPlws8ZnXvJH+wvl/J6ULwdKlA+e6hIvGV3f94hO6v5eu/8gTuj8RERGRJ8IP/MAPcO+99/aWf/u3f5sf/MEfPG7fr371q/zcz/1cb3n16tV85Stf6QWinsju3bt5xSte0ZvwEscxN910EwMD5/7vxvPXEsjx6TsNkScHvddFLn56n4s8OVxo7/Usy7j//nvZv3+c2dkZms0m5XKZgYFB1q5dx4YNm+jvv7BuZJHnOQ88cB/79u1lZmaaVqtFuVxh6dKlbNy4mfXrNzzqv6Efi8Ef/yGKX/w83wWue5S+X/ziV3nWs44fvjh8/fcS33zTCbdt/vCPUvvQHz/2QuVxu9De5yLy2Oi9LnLx0/v8sdE1VyJnV/ToXURERERERETkXAsh8PDcJN88sJNbJ/bRzjMK1uGMYbxZY0Wlj764Mwk0+EA9S2jnGX1RgRACh1t1ANb2DZIHTwhg7JHxY+uoZyn1LGUgLjLRahAIvZAFA4QAefCMFMscbtVp5RlF57p3Czf0R4Ve35WVAUrOsbs2hzWGWtqmniWEEBiIi1y/7jJesWYLK8oX1sUBIiJyYfrqru18/N47mWo2SPKckoto5BkmBPxpjjV/Cdj1Gy9VAIOcl3w48xcqioiIiDzZrFu3blEIw/T09An7fuUrX1m0/PrXv/6UJo+sW7eOa665hltuuQWANE35xje+wfd93/c9xqpFRERERETkQhdFEVdd9QyuuuoZ57qUM8Y5x1OfehVPfepVT+x+d+8GYPsp9N28ecsJ1+XLVxCfbD8HD5xeYSIiIiIiInLBUAiDiIiIiIiIyHmumrb5kwdu4fbJcQKB/qhAwTnqacqO2jTWGFKfs3FwhKLr/FN/NmkTAIsBY8DCRLvOSLFEbB3GdLIT5i8Ht8aAh5mkycrKALG1ZMETm06ybKA7jDHE1rJpcJRtc5O08hwIlFzEYDcEwofAbNKikWW8eOUGfnDjVcwkTRKfU4liLh9aSn9ceKJPo4iIPMmEEHhkeoqP33kHX9+zE4InDQHDkSAiawy+e9fZ0zEQFXjNJZef0XpFREREROT80W63Fy0PDJz4LkLf+MY3Fi2/4AUvOOX9PP/5z++FMAB87WtfUwiDiIiIiIiIyBlg95xaCMPo6ChDQ8MnXO+XLz/5fg4ePM3KRERERERE5EKhEAYRERERERGR80QIgYfnJrnx4E721ufICYwUSmydm+Jgo8bySj8F63r9p1pNImMpOkctbbN1dpJLhpYQG0vq80VjO2NJvWei1WB9/zAF60i9XzSeAVLvccayrNzPvvoc1gacMWSh0zfu9i+7iEsHl7C3MctEq0HBRhxo1jrHAYwVK7xm3eX8xzWXUo5Odk8AERGRM6+Zpvzpnbdy457d7KtWMQaccSRZSgDaed4JKzIWQ+CkMQzzqUWh8yMylh++4mmsGxx6Ao5E5PR57LkuQUREROSCFkLgnnvuWdT21Kc+9bh9JyYmOHz4cG+5UChw5ZVXnvK+nvWsZy1afvDBB0+jUhERERERERE5HjM7g63OAbDjUfquW7f+pOv98hUnXW8PHjid0kREREREROQCohAGERERERERkfPAzto0/+fh29g6N0UgULAOA9zcrDGXtumLCwxmRQqFTghCHjxTSZPIWowxFF1EI8vYU59hU/8oFnPMPmJrmUlarAmepaU+9tbnCARMt29nMmrn8fJyH+08Y6LVIAc8sLTU11ufB081bVNyMT996dVsGhihmrYxxrC01MfTR1dQdPraQUREnlghBO45dJD3f/dGds7OAoHMe0rOgTFgDM4YQghkIZAFj8OQnzyGAUvnz0JrDFcsWcqPP/UZT8DRiIiIiIjIufDpT3+aQ4cO9ZY3bdrEVVddddy+27ZtW7S8fv16CoXCKe9ry5Yti5Z37dpFlmVEkb5XExEREREREXms7O7dvcfbH6Xv+vUbT7reL1t+0vVmcgKyDPRveRERERERkYuO/qUnIiIiIiIi8gQKIfDQ3AT3Th+ilrUp2YiCdXx+78NUs4SlpQqx7QQtZN6ztz5HyUWkec622hQb+kYYLZbJvCcPvtfXGEPBWWbabVrljGL3l7sLQxYshjR4Uu8ZKZY50KyR+JyijQihM/m01A1OMBjW9Q9TchF763P4EGjlGeONKiEEjDGsKPfz2vVX8OIVGzHm2NAHERGRJ9LuuVn+/K7buPPwASZbTQrW0c5z8uBp5AFD58/hQOfPTdN97Am9kIV5FnqxDAFwxmIIXDIyynuf/xIia5/YgxM5DT7o72UiIiIij9VnP/tZ3vve9/aWrbX81m/91gm/+9qxY/H9NFesOPndMY82OjpKsVik3W4DkKYpe/fuZcOGDadXuIiIiIiIiIj0uL17eo93nKQfwLp164/bHkJgamqKQ40G08BuYM9RP78MXBYC9vAh/MpVZ6J0EREREREROY8ohEFERERERETkCXLbxDif2XUf26vT+ODBdH5pe6BZA2B1eQBnjkzqnElaZMFTdA6DIfU5u+ozlF2EPc6F385YUjKm202WlCqMmznyEIiO07dgHRv7R9henaKdZzhrsMYwUij3+uTeE0Jg48AI37v6EgKBRpbSF8VcPryUq0ZWaBKqiIiccyEEvrZ7Bx+981Zq7TbNPCOylmLkSHyOpfNnXO59J3QhBJzptnWDGKwxuO66AL22EALWGAyGFX19/N4LX86q/oFzerwiIiIiIvLY7dixg/379/eW0zRlbm6ORx55hK985Sts3bq1ty6OY37nd36H66677oTjTU5OLlo+3RAGgGXLlrFnz5HJIZOTk+c8hKFQcOd0/+e7KNL5EXky0Htd5OKn97nIk4Pe609OhYPjACR0AhNOZvPmTcf9d/Du3bu56qorTrrtLuAyoDh1mHz92sdUqzx+ep+LPDnovS5y8dP7XETORwphEBERERERETnDQgg8PDfJ/maVzHsG4iKHmzX+ZsfdACwplYlt58vCyVYDAjhr2Nes0fQZG/pHsMbQzjMADJ0Qhdg6WnnKRLvBqkonsMF3J4fOM0AzT4mtY7RY5lCrgXOdyaOeTt+4G5wwWCiyeXCM3bVpqmlCX1ygmrYhhbbPAVjXN8SbLn02lw8vfaJOn4iIyCkJIXDL/n38w8MPcPP+vaTeY4AkdH5m3uND6PV31uK9xwM2HAlZ8BwJZnDdYIbIGDAGH6DsIraMjPHbL3gJy/v6z9HRioiIiIjImfA3f/M3/OVf/uVJ+xhjeOELX8iv/MqvcPnll5+0b6PRWLRcLpdP0PPEjt7m6DFFREROqlbDHthPKJYIazXxT0RERATA7u1EL+wG/KP0Xb9+/XHbV65cie3+fvFE5gMezIEDp1+kiIiIiIiInPcUwiAiIiIiIiJyhuTBc+PBXfzrvq1sr06DAROgkSdMtpuMxCXW9g/1AhhCgMPtBtYaCjbCh8BUu0nBOtb0DRGOs4/IOKaSJivLA52QhWadqBuqMM93N1xVGaSepdSzlKJzpN4zWjwSAAFQco7hQpmNA6NcMbyU6XYLgJWVfp6/bB1XjizDmcXji4iInGveez5+zx38y/ZHSPKMPAT64pjUe7IsYK3Bh0AeAgZ6gUWRMWQhkAdPZCzOWvCewOILsJxzeO8pRhEv27CJn7nqapZUKufiUEVOW8A8eqeLWAiBvXv38vDDD3PgwAGq1SqFQoHBwUE2bNjA0572NIrF4rkuU0RERM5jr3zlK/mxH/uxRw1ggGMDEx7L3zNKpdJJxxQRETmuPKf4e79L8WMfxczNApA9/4U0f//9+KdddY6LExERETm3zN69AOw4hb4bNmw8bnscx6xYsYLx8fETbrt7fn8HFcIgIiIiIiJyMVIIg4iIiIiIiMhjEEJgb2OOatrGGctYscynd97H1w7sILKWJaVO2EEI8PDsBCEEZtIWzbmMzQOjVKIYHzzNLCXqhhxYY4iN43CrwbJy/zHhCgDOGNo+p+0zRosVDrfq5N53JpHSCXYodEMWImvZMjjGzuo0M2kLHwJlF1HPEnIfqGVtDIanjiznl658LiPF079Tn4iIyBOpnWfctG8Pn3zgXu6bOITFkAWPD4EQwCyYe26NIQTwhN6flcYYTAgEIA8BS+cutxYoRRHtLANrKVhHX7HEO65+Hv9h7fHvfiMi54/Z2Vm+/OUv861vfYvvfve7TE9Pn7BvHMe86EUv4id+4ie49tprn5D6XvrSl7Jv377HvP1f/uVf8pznPOcMViQiIiIn84UvfIEvfOELXH311bzvfe874R0xAdrt9qLlOI5Pe3+FQmHRcqvVOu0xRETkyaf033+T4oc/tKgt+va36PuB76f25W8Q1q07R5WJiIiInHt2XyeEYfuj9bOWNWvWnnD9mjVrTxrCsGd+nAMKYRAREREREbkYKYRBRERERERE5DS0spTvHt7Lv41vZUd1ipwAAepZQivPWdM3wGjxyJ2ym3lKPU8ouxgDtH3OtuoUlw2OYYwlEOhM/exwxpD6nOl2k6G4yDjgQ+jdwdt0f/oQ6I8LLC/3c6BZgwAWAwaGC0funhdby5q+QVzTsLI0gCeQ5DkFF/EfVmzkJSs3cvnQ0t74IiIi56tqu82Hbvsudx86wGSrSWwdBWepJgnWGPL5MAbAhG64ggEfwAOuO44zhiwEDJ32EALOWAKAMYwUS1w2uoSffcbVXDIydo6OVuSx8zy5/l733ve+l0996lOkaXpK/dM05ctf/jJf/vKXee1rX8tv/uZv0t/ff5arFBERkfPFe97zHt7znvf0llutFjMzMzz44IN86Utf4nOf+1wvBOHWW2/lDW94A//3//5fnva0px13vGKxuGj5VP9OslCSJCcd81xIkvxcl3BB0fkSeXI4n97r9uCBYwIYeusOHSL6yA3U/8f/fIKrErnwnU/vcxE5e/Ref3Lo39OJR9jxKP1Wr15DCPaEr4tVq1afdPvd3Z9hfL9eW+cRPRciTw56r4tc/PQ+F5HzgUIYRERERERERE4ghEA9S0l8RtnFtPKM/33/d3hg5jCxc4yVKsTW0cxS9jerBGBnbYZ2nrOi3I8xhlqaEAJY25kMV8TRyjMOtxqsrAxgMXhCJ0CB+btxG2aTFsvL/QzERebSNiUX9WqCzt29DbCqMoAxhgONKqn3lF1E2UVk3tPOM2bTNtYYXrvuSn5sy9OJrFsU6iAiInK+a6Qp3x3fwx/f/u8catYxQJLnxNbS/eMVQzeoKEBGIA+ByBiMMbgAOYHMe1y3zQLlKCIEaOUZBWfxIbBuYIi3Xf1cnr18FZG1J6lKRM4Xd91113EnOzrnWLp0KWNjY2RZxvj4ONVqdVGff/iHf2D79u38v//3/+jr63uiShYREZHzSKlUYsWKFaxYsYIXv/jF/MzP/Axve9vbeOCBBwCYm5vjF37hF/jc5z7H4ODgMdtXKpVFy+12+7RrmA99ONGYIiIiR4u/+fWTri987SvUn5hSRERERM4/WYY9sB+A7Y/Sdf36DSddv2rVmpOu39P9aQ8dOLXaRERERERE5IKiEAYRERERERGRozSylFsm9vKlfVvZXZ/thhbQDWTI2dA/TGxdr/900sJgeuEH440q1hiWl/vxnftq9xhjiIxlst1gRaWfwUKJ6XaTyNlFffJu2MKqygD1uYS2zyhYRxo8Recou7jTF8PqyiAWw3S7yWChyGTSBAIFG/GSlRt50YqNXD60pDM5FRTAICIiF4xt01PccPvN7JqZYarVpOg6fxYaDFkIvYnX8+FE1hhsCHjA+4C1BmsNwQcC4AETQjfUyODxxNayvK+fa1as5i3PuJq+uHDuDljkDPA8ef+uNzg4yPd93/fx4he/mGc/+9n09/f31uV5zq233soNN9zArbfe2mu/++67efe7380NN9zwhNS4ZMkSPvCBD5zWNpdf/v+zd99xdpUF/sc/z3POLdNbJpNk0hsBpBhKaCqgWFBwQdb9YUFkwYZir6xl1+6qqyxWFFzL6oqyKCyoEBGkQ+glpPdkMr3des55fn/cm8tMypRkJpkk3/e+8po5z3navTtyz733PN9n0TjNRkRERHY2a9Ysrr/+ei688EK2bi0s2GhpaeGnP/0pH/7wh3epv3NgQjqdHvWYO7dRCIOIiAyn7PofD3neX7liP81EREREZOKx27ZiogiAtcPUnTlz1pDnp08fOoRhA+AA26IQBhERERERkUORQhhEREREREREBljd28F3n3uAbaleYtajKhbHM4aWdD9bU7341rKmt5M5VXXEi0EMndl0KdjAtxYXObameqlLlGF3swjON5ZsFNKXzzEpUU5nNo3DYQbU3dFfRSzO3Kp61vZ1kgkCIhzTyqqwxuCcIxXk6QmyJDyfL5x4NidMmkZrfz/OQU08QWUssR+eNRERkbGVzue5fc1Kbnj6cVL5HIFzhddKYyByYMAzBmcMQRQRusI5A3gYIhwRDuMK4UbGGGLG4FuPTBhgi+0cjlOnzeDtRx/HkfWT8Kwddm4iMvE0Nzfz3ve+l/POO49kMrnbOp7nsWTJEn7+85/zr//6r/zP//xP6dyf//xnHnzwQU455ZRxn2sikeC0004b93FERERk79XX1/OBD3yAz3zmM6Wym266abchDA0NDYOOt20b/aKL7du3D9mniIjIzmx7+/CVcjmIK2xUREREDj9206bS72uGqTtr1uwhzzc3zxjyfAZoA+pbWkY0NxGRvRaGEAQQi4HuaxARERHZbxTCICIiIiIiIoelVJDn4bZN/G3rWrZn+gGo8GOs7+vCANPKqwoLPYHIOXryhaCDmLH05rOs7ulgQXUDvrUELiqFJsCOkIWAzmyaSr9wg1uEKwUyFBaDQugctfEE1bEE3fksSc/DYIhcRPWA8ITqeIKFVQ2s7eskF4XkopBtqV4iIOn5vKp5Hq+ePp/5NYUbtGPl3n54BkVERMaec46/bVzHb59/hhWd7eTDEM9Y8mGIA/ryucJ2MsWXXUMhjCF0jjCK8K3FGIPvIMQV8xoczjmM9YhZSxAZKuMJahJJ3nrkMbx+3sLSa77IoSByh9ff81VXXcVpp51GfIQLSzzP4/Of/zzPPvsszzzzTKn8xhtv3C8hDCIiInJwOOecc7j66qtxzgGFoITNmzfT3Nw8qN6cOXMGHW/dunVU47S3t5PNZkvHsViMGTOGXuAhIiLi/OFv+zRdXbjJk/fDbEREREQmFm9LIYShG+gYpu7MmbOGPL/z5wC7swWYtL0FokgLo0VkzMVvuZmyG35C7JGHMNksUU0tmbe8ndSHPoqrqz/Q0xMRERE55CmEQURERERERA47D7Zu5IaVj9GZSxMzlqTn44Dl3a2kwzxlXowyP0ZdogyA/iBPJgxIFEMSktanP8ixLd3L9IoaTGF5Z6l/YwzWWNqzKSYnK6mIxUkFORL2xbfhrrCJN9YYZlfVsbq3g758Flvcrbu+OLZzjv4gT1cuw8KaSbxv0clkw7A0nzmVdUyuqtyfT5+IiMi4yIYBP3z8Ee5ctwbnHPkwIuH7GCAbGTwAYwhdNOh1dMdyc0fhddMUX0utcyQ8n3wUEhSDGFJBnrjn89o583nt3AUsrNMOsyIHuzPPPHPUbTzP4/LLL+dDH/pQqezee+8du0mJiIjIQa+6upqamhq6urpKZW1tbbssvpg7d+6g4w0bNpDL5UYcELV69epBxzNnzsQfwcJaERE5zHnDh3Hbrk5ChTCIiIjIYchuKoQwrB1B3VmzZg95vqlp6rB9bAWOCwJMRwdu0qQRjCoiMgLOUXH1Jyj/yY8GFdvuLsp/8J8kbrqR7t/eTHjkUQdogiIiIiKHB31zKyIiIiIiIoesdJDnkfbNPNG+lZ58ljKvsJDzodbNJDyPaWVVpZ2v+/M5giii3IsROsfavk4cUJ8oI4hCjIEdyzyNMcSMR3s2zZSyKir8GF25DL73YqK9xZCLIsDRlKxgTW+OwEX4xhK6CGMg6RXelsesZX5VPVvTvWxL9ZH0fDqy6WKsg6PMi/HqafN548xFTC5T4IKIiBxasmHAn1av5OaVy1nd1Yk1hiCKCF1EmI/wjCkkLJhC8IJnDIFzhM6Vwot8eLGs2K/BkPA8LA7fGaoTSRrLy/nQCadyzOSmA/eARcZZhHZZGokTTzxx0HFXVxfpdJqysrIDNCMRERGZ6HYXjtDY2EhjYyOtra0A5HI5nn32WV760peOqM/HHnts0PGRRx657xMVEZFDnx0+hMF0du6HiYiIiIhMPN7mjQBsGEHdmTNnD3l+0qRJWGuJomiPdbYWf9rtLYQKYRCRMVL+1S/uEsAwkNeyjdo3nUfnHXcTNU/fjzMTERERObwohEFEREREREQOOc45btu0gj9uXE5XLo01Bt9YslHIllQPxhgmJyuoJYlXDFboyKYB8IzFM5CPQjb0dVHhx4Di4s8BPGPIRiHduQwNyXK6chkcjhf346b0W228jKnlAVtTvUTGETlHdTxBmR8rzTcTBhgMr5o2j1dMmU1PPotzjup4ksX1U6lNaDGYiIgcenqyWb7+4N95rr2NVD6HZw1J36c/lyu+qhryUVTIYHCmEIpkDMY5HBBGEZ61pTLfWhyUboTKhgFBFNFQVs5584/gvHkLmVyhQCMRgZqaml3Kent7FcIgIiIiAPT19dHd3T2obNIeFlK84hWv4He/+13p+L777htxCMN999036Piss84a5UxFRORw5LzhQxhsl0IYRERE5PBkt2wGhg9hSCQSNDY2DlnH8zwaGyfT0rJtj3VKIQyt2wk5ehQzFRHZPf/BB6j4zjeHrWfbWqn85Efo+cX/gDHD1hcRERGR0VMIg4iIiIiIiBzUMmGeZW1b2JzuJYhCKvw46/s6ubdlPRWxBFPLqjDFLxm2pnuxGGLGozXTTyYMmFdVj2dsIQRhwHcRMeuRCfO0Z1PUxAsLsSIcthitsKPPXBTSlCijzPdJBwEJz8NgCF1EuR8v1ZtaVkXcemxOdZOLIgywPd1HhCOMHOV+jNdNX8DFc44thTOIiIgcqroyGf6+cR3XP/0Ebel+LIZcFJZeZ3dkHxkDvrEEUURYimUohCEFxSCGyDkMhdfmmPVIeB79+RwV8TieMSysn8RnTnkZk8orDtCjFZGJqKWlZZey2tra/T8RERERmZDuvvtunHsxlbW+vn6PCzPOPvvsQSEMN910E1deeWXpc8E92bBhA4888kjpOBaL8YpXvGIfZy4iIocD49zwdRTCICIiIocpb9MmYPgQhubm6cO+dwdoapoyZAjDluJP29Y6whmKiAzBOSr/9eoRV0/85U/E/3oHuVe+ehwnJSIiInL4UgiDiIiIiIiIHJSyYcAtG5dz59bVdGXTOAoLNlNBns5cmmo/QU28rPSFaeQcbZkUvrV41mKdoTefZVN/D7Mqa3E4dv5q1TOWtkyapmQV5bE4qSBHwg5+K+0AawyzK+tY1dNONgyJF3fhbkyUD6oZ9zwaEhWc0DCVungZvUGOpOczv6qeUybPpDaeHL8nTEREZIJY29XJNY8+yIaebjoyKcr8GJGLCFwEQDYMiZzDQmm3hh2hC2EU4VuLMQZbDGEAiADnHKGLSAcRxhiaKip53bwFXDj/SGIj2B1Q5FDhnHY5GYlHH3100HFzczPxeHy/jd/R0UFLSwt9fX1UVlZSW1vLlClTRnTDp4iIiIyvTCbDNddcM6jszDPPxFq72/ove9nLmDJlCtu2FRZkbN68md///vdcdNFFQ47zn//5n4OCHl796ldTVVW1j7MXEZHDgenrHbaOVQiDiIiIHKbs5o3ASEIYZoyov6ampiHPb90xbuv2EfUnIjKU+NK/EFv26PAVByj70fcVwiAiIiIyThTCIAeVDRs28NRTT7Ft2zby+TzV1dXMnTuXxYsXk0gkDvT0RERERERknGTCgGe7ttOdy2CNocqP8+ctq3iiYyuVfpymsipscbHS893b8YwhFeZZ1dvO7MpaauNl5KOQfBQSt4VFmDt2y+7IpZkaVhL3fHrzuUHjesaSdyGBC2lMlLMunyssCjWmdIN0rHjzdbkfY0F1A+v6uujJZ/GMAQPduQy5KCQXhpT7Md427zjOn7FIi6tEROSw05PN8uc1K7n+6cdJ5wNCFxHh8G0ErhBs5O14fXSOCCCK8IqhC6YYuhC5QnCSNRZwVMbjZMOQfBiS9HyMMbxhwUL++fjF1CSS5HLhgXrIIjKB/f73vx90/PKXv3y/jNve3s65557L6tWrdzlXW1vLCSecwBve8AZe85rX4ClARkREZJ984xvf4LWvfS3HHnvsiNt0dXXx4Q9/mHXr1pXKPM/j0ksv3WObeDzOe97zHr7whS8MGvv4449n/vz5u21zyy238Mc//nHQGB/4wAdGPE8RETm8md6e4et0KoRBREREDkN9fdiuLmD4EIbp06ePqMspU6YOef7FEIbWEfUnIjKU5M9vGHWb+N/+irdmFeHc3X8WKSIiIiJ7TyEMclC48847+f73v8+zzz672/Pl5eVceOGFXHnlldTX1++XOTnnWLNmDU899RRPPfUUTz75JCtWrCCfz5fqXHDBBXzta1/bL/MRERERETkUdecy3LFlFUu3rqEjl8YCBkNbtp9MGNJcXkVVLFEKYOjNZ0kHAQlbWICZi0LW93URr/axxTWdA7MPLIa8i+jIpqmPl9GeSeFwGAqVDOBcYbFnXaKMnnyW9myKhPVLYQw18WSpv6Tn05gsp8KPc0TNJNJBnryLmBZPcsbkmZwyeSa1A+qLiIgcLv6+cT2/fPZJ1nV3kcrnSXo++SDE4UjnA6AQsOAoBCVZY4iKQQw7liB7xhC4F+vhokK9yBFGEVXxBNOra7js+JfyipmzD8jjFJkIQhT2NZy7776bRx55ZFDZhRdeuF/GzmQyuw1ggMKiz6VLl7J06VJmzpzJl7/8ZU4++eT9Mi8REZFD0X333cdPf/pTjj32WM4991xOOeUU5s+fTywWG1Rvx3f/f/rTn/jFL35B506LVt/xjndwxBFHDDnWRRddxK9+9StWrlwJQHd3N29961v59Kc/zRve8AZ8v3B7TldXFz/72c/40Y9+NKj9P/3TPzFnzpx9fcgiInI4cA7T2ztsNdulEAYRERE5/HhbNpd+Hy6Eobl5ZCEMkyc3DXn+xRCG7SPqT0RkT2zLNuJ3/Hmv2iZ//Sv6r/78GM9IRERERBTCIBNaLpfjM5/5DLfccsuQ9VKpFL/85S+57bbbuOaaazjppJPGbU6///3vueWWW3jmmWfoHcEXWiIiIiIiMjLZMGBDfzeZME/c+iSsxw9eeJi1fR1U+AmmJCuxxpAJ82xOdWMwbE710hfkmFNZh2csqbAQimaKSQtx65ENA7Zn+pheXo0xlMITdtSzQF+Qo6mskqTvkw0LIQ4AEQ5jwLcWawyzKmsxxtCe7ifvIuoTZTjnyIR5+vN5MmFAdTzBB486jRMnNR+Q51FERGQiSefz3PD04/zfqhW44nHMenjWgCkEIhljCKNCuELkHJ4plHlA6AoBC561pdftpOfjcGTDEGsM2SikMh7nsmMXc87seTRWVRzYBy0iE1pXVxef+9znBpW96lWvGtUO2fvDhg0buPTSS/nkJz/JO97xjgM9HRERkYPajo0VAGKxGE1NTVRXVxOLxejv72fr1q309/fvtu0FF1zAxz/+8WHHiMVifPe73+Utb3kLXcUdN7u6uvjkJz/Jv/7rvzJz5kwymQybN28etLEDwLHHHssnP/nJfXuQIiJy+MhkMDu9luyOKb4eiYiIiBxO7OZNAOSBLcPUnT59xoj6bGqaMuT5rRSD5hXCICL7KPH7GzFhuFdt43/6P4UwiIiIiIwDhTDIhBVFER/60IdYunTpoHLP85g6dSpVVVVs2rRpUBBCR0cHV1xxBTfccAMvfelLx2VeS5cu5YEHHhiXvkVEREREDkdtmRR/b1nLnVvX0JbpLyzEdBFd2QzWGGZX1lHuv7g7XUc2DRgSnk/kHN25DOv7uphTWUfk3C79+8bSlcswrbyaKj9BTz5LwrMvVjCmGLZgmFFew+reDnJRSNx65F1EdSxBzBb24LbGMLO8Blxhv+7KWKE/g6ExWcGrp83jlMkzqY0nx/tpExERmdCCKOIPK5fzf6tfYNWAXWTzUUQ+isiGBocDYzCAZy0uiogAEzmsNVhjiFwhnCGMIowxuB0hDRgi62gsK2dmdS0fOulUZlbXHKiHKzKhOGcO9BQmrCiK+PjHP862bdtKZVVVVfzLv/zLuI9dWVnJy172Ms444wwWLVrE9OnTqaysJJPJ0NLSwuOPP85NN93EsmXLSm3CMOSrX/0qkyZN4vWvf/24z1FERORwkM/n2bRp07D1Kisr+ehHP8rFF19cCnwdzrx58/iv//ov3ve+97F584s7b6ZSKZYvX77bNqeddhrf/e53SSb1eaKIiIyMGeGmQbarc/hKIiIiIocYrxjCsJlCMMJQmpunj6jP4UIYskAnUNXaOqL+RET2JHH7rXvd1n9hOXbNaqK588ZwRiIiIiKiEAaZsH7yk5/sEsDw//7f/+N973sfTU1NQOGGyaVLl/KVr3yFLVsKeZXpdJoPfehD3HrrrVRVVe3XOZeXl5NKpfbrmCIiIiIiB5MgCunOZ8lHEZV+jC3pXr7z3P20Z1KU+zGmlFVhjaE13Uc6zGONYWVPG7Mq60rBBl25QjgDFEIR4tanK5ehP8jh7eaGaGsMQRTRn88xKVlBTz6Lc65083RhMWchlKE6nmBOVR3r+jpJB3kiHA2JcpxzhMXAh0wYMKuyhg8ffTrTyqtIBXl8ayn3YiO+IVtERORQlsrl+NpD9/LU9m3kwhALlMViZIKAwBTCFZxzhcAF50qv654xBM4VwpEcmGJdi8G3hlwUAZCLQiLnmFJRyT8fewKnNc+gOpE4cA9YRA4a3/jGN7jnnnsGlf3bv/0bU6dOHddxP/7xj/Pyl7+cioqKXc5VVlZSWVnJvHnzuOiii7jjjjv4zGc+Q09PD1B4v3L11Vdz8skn09jYOK7zFBEROdR8+9vf5q9//Sv3338/Tz31FH19fUPWN8awcOFC3vjGN3LBBRdQX18/6jEXLVrEH//4R3784x/zm9/8hu7u7t3Wmz17NpdffjkXXXSRPlMUEZFRsb27f23ZmVEIg4iIiByG7KaNAGwYQd3p00cWwjBlytAhDABbgZrW7SPqT0Rkd0xbG/4jD+1TH4k/3076ve8foxmJiIiICCiEQSaozs5OfvjDHw4q++hHP8q73vWuQWXWWs455xyOPfZYLr744tJuEtu2beOGG27gqquuGrc5NjY28pKXvIRjjz2WY445hmOOOYZf/OIXXHvtteM2poiIiIjIwaot08992zdw55bVdObSOBxRMdQgYX1mVtRgrX2xfi6Fby1x65OLQtb1dTKvqp6qWIJwQIACUFq42Z5N0ZisxMCgkIUdP0PnaEgkqY4l6M4Xxt2hJvbiws3aeJIFVQ2s6+/CYkgHOdJBIRBiankVr542n9Mmz6SmGApRE/fG7XkTERE5mPRks/xtw1p++exTbO3rxTOGXBgCEDnY8eptKL4+OwhxhFGEZ20hdKEYzhAB1jmcc1jPkozFcLk8iZhPRTzGcY1T+diS06iIxQ/QoxWZuCK0iG93fv7zn3PDDTcMKrv88ss599xzx33s173udSOue84559DY2Mg73vEOMpkMUAif/uEPf8hnP/vZ8ZqiiIjIIWnevHnMmzePK664giiKWLduHRs2bGDLli309fURBAEVFRVUVVXR3NzM0UcfTWVl5T6PW1lZyUc+8hE+8IEP8OSTT7Jy5Uq6urrwPI/GxkaOOuoojjjiiDF4hCIicjgyvb0jq9fVNb4TEREREZmAvC2FtQRnANsohDEM/Leurp51s2axadMmpk5tHlGfTU0jC2E4qq0VnAOFLYrIXojf+WdMcWOKve7j7r8qhEFERERkjCmEQSakn/zkJ/T395eOTzrpJK644oo91m9qauLLX/4yl156aansZz/7GW9/+9upq6sb07ldeeWVfPaznx33nbFERERERA5mkXOlBZYPtW7ixysepi+fo8yLURNPYoA1vR105TLErEdIxKyKOnxrSYd50kFA3BbCDeLWIxcGbOrvYVHNJKwxRFHEwLVlnrF05TLMqKilIhanP8gRN4Pf8lpjMBhmV9axtq+DnnwOcHjGUhsvAyB0EV25DOkg4IzJs3jPESfRF+TIhSFJ32d6eQ3+gLAIERERKdjW18u3Hr6ftd1dtKdTJH0fawy5qLAcPHQRkXMAOArXCDteyncELhhjsMbiXIRvDKFzOArXFel8ngiYVVPLPyxYxDmz5xHzFIQkIiNzyy238JWvfGVQ2YUXXsjHPvaxAzSjoR1//PFcfvnlg0Kfb731Vq6++upB4XUiIiIyctZa5s6dy9y5c/fbmLFYjBNPPJETTzxxv40pIiKHvpGGMNiuznGeiYiIiMjEYzdvKvwEmor/ThpwPnPmWfT+6IbdtNyzxsbJGGNwxe86d2crYPJ5TFcnrq5+tNMWESH+t78Oed75PvkzXj5kPf/hhyAIwNdSQREREZGxoisrmXCiKOKmm24aVPb+979/0E63u3Pqqady4okn8uijjwLQ39/P7bffzlve8pYxnd/RRx89pv2JiIiIiBwqOrIpHmjdwF+3rqEjl8ZQCFDYmuqjKpZgallV6bo+GwWkwjzlfgwwdOUyONfJ3Kp6gmKi88D3ADHrkQ7z9AU5qmJx2jKpQW9orTEELiJ0EVPKKlnd20HgQnzjEboIYyiOBb61zKuqZ2u6l23pPhLWpy1TCIGLgKllVZwzex6vnDqXpB9j8n547kRERA5WPdksf9uwlh8/sYyeXBacIx9FxD2PWDFQaUcwE0DoHKFz+MZgjMFzEOKIHNhCPAMGQ5kfIwKyQZ7qRAJrLOfNX8g7j1msQCSRYTi0w9JAd911F5/61KcG3Rz56le/mi996UvDfu9wIF1yySX84Ac/IAxDALq6unjmmWc49thjD/DMRERERERE5EAyPT0jr6edmEVEROQwYzdtHPJ81Dxj1H3GYjEaGhpoa2vbY50tO8ZvayNUCIOIjJZzxO69Z8gq+VPPIHPBRUOGMNi+XvxnniI4fvFYz1BERETksKUQBplwHnvsMTo6OkrHM2bMYMmSJSNqe9FFF5VCGACWLl065iEMIiIiIiIymHOOP29ZyW/WPUU6yJPwfJKeT+Qcz3e3EkQRfUEW3xrq4uUAdOcyOEdpF9eE9enOZ2jPpkphCcV9soEXF2525TI0JMppy6RwxR2zCzVdccmmoTqWZEZ5DRtT3eSigAhHbTxJ0iu8BQ5dRHcuAxgunnMsp02eSXcuC0B9ooxFNY1a3CkiIjICT7Rs40dPPMrG7m56clkSvkc2CADIRxG54sLhHTd6W2OInMMBkXNYY0plBorlEQYIopBcFJHwfObW1vP/jnwJpzXPPBAPU0QOYg8++CAf/OAHCYr/bQI4/fTT+da3voXneQdwZsOrqanhqKOO4umnny6VrVmzRiEMIiIiIiIihznTO8IQhiCAdBrKy8d5RiIiIiIThHN4WzYPWSVsbt6rridPnjJkCMPW4k/bup1wwcK9GkNEDl/eqpV421uGrJN75TnkTz192L5i99+nEAYRERGRMaQQBplw7r777kHHp5122oh3ozrttNMGHT/00EOkUinK9WWSiIiIiMiY6MqleaB1I4+0baI3nyXh+UQuYnl3G7WxBFPLqkrX7x3ZNADlXoyAiHX9nTgH9Yly8lGEG9CvMQZrLK2ZfhZUNeAZQ+gc3oD3AgbIRSEVfpzqWILufJak5wGFuknrlepPSlYQ9zw29HeTCvJYLFtSPaW5TSmr5K3NC3nVtPlY7QAkIiIyKpkg4KYXnuNXzz1FPgzJBiHGgGcsFIMVrDE4YwiiiNA5/OLrrWcMgXOl4AVjCiFKMesR9yzpIMC3hfb1yTLedfyJnDN7HvEJvlhaRCaeJ598kve+971ks9lS2Utf+lKuvfZa4vH4AZzZyE2dOnVQCENnZ+cBnI2IiIiIiIhMBHanEIaVwHIgCZwJxAbW7ekm0n1zIiIicpgwbW2YAd8J7E7UPGOv+p4yZQrPPffMHs8PDGEQERmt2N/vHrZO/mUvJ5o1m3DqNLytW/bc10MPkH7fB8ZyeiIiIiKHNYUwyITz/PPPDzpevHjkKWxNTU00NzezeXMhxTKfz7Nq1SrtDCUiIiIiso+CKOKmDc9y++YVpIIcMevh28JCyU393VhjCFxIeSxOzBQWSbZnU4XFldYQwyMfhWxMdVHpxwvlO40RM5ZMGJCJAuoSZbRlUnieLZ13A9rMrqxlZW8HqSBPzBicczQmK0ohC6GLyEcRkxLlvHbOAuoSZaTCPHHrM7uylmPrmvCtFnOKiIiMhnOOO9au5qYVz/NCRxth5LDWkItCoHC9MJCBUrBSGEV41haCl5zDAVGhU5xzxf7BYKhNlDG3to6rTjyFWTW1+/MhihwSwl2utA8/y5cv54orriCVSpXKjjrqKK677rqDKrTZ9wd/jZfP5w/QTERERERERGSiML29AKSAdwI3Qin4fDrwY+B1O+r29MCUqft7iiIiIiKjdtttt/CVr/xr6fgzn/k855573qj68DZvHLZO2Dx9r+dUXV1NT0/PbuvuCGEwCmEQkb0Qe+j+Ic9HtbUERx8DxpA/9XS8m27cY13/ycfHenoisr84h//ow8QeehDCgHDufHJnvwoqKg70zEREDmsKYZAJZ82aNYOO582bN6r28+fPL4Uw7OhPIQwiIiIiIiPXm8/yYOtGVva0k4nyVPkJNqW6ea5rOzXxJFPLqkphB735bnxriVmPrlyWXNTO/KoGYtYjGwZY82KIgm8s2SikI5cmXgpAeDFaYUefuShkUqKc9myKwEX4A/pIeoW3sb71WFDVwMZUN22ZfgyGfBTSmukncIUFoE3JSt48+yWc3jRrnJ8xERGRQ18+DPnPZQ9x94Z1RC4ico7ymE8QReSNwRqDc4UgpB2v7saY0lLwCLDOFUIYjCVyERWxGNkgJHAh4MiGIVMqK3n/4pM5edp0kr4+vhaR0VuzZg2XXXYZ3d3dpbJ58+bx05/+lKqqqgM4s9Fra2sbdFxfX3+AZiIiIiIiIiIThSku/LuUQgDDQJuAi4D7gOMB0921/yYmIiIicoDZAesH9iRqbh6XsXeEMFiFMIjIXog9+siQ5/OnvQxs4R7K/ElLSA4RwuBt2YxpacE1NY3pHEVkfMUevJ/KT30M/7lnBpVHNbWk//ldpD7yCYjHD9DsREQOb7qLVSaUTCbDli1bBpVNnTq6NO4pU6YMOl67du0+z0tERERE5HCQDQNuXPc0d7WspS+fxRqDxdCdz9CRy1Dm+SQ8n0q/8EFeGEV0ZlP41mKNIWE9UkHAhv4u5lU1lHbd2cEYg2cMbdl+jqhqxLM9hM7hmV136i3340wvr2FjfzfOFOoYoC5eVqpjjaHCj1FRWcepjTPIRSH5KKQ2nuSEhmaOq59CrBT2ICIiInsjGwbctX4dv33+GVZ2tuMZSz4KiZwrvY7veM03BiyGsHjON6bw+g+EzhE5MDhwhesC31pCGxGzMRrKyjiuaSofPGEJlYnEgXzIIgc95+zwlQ5Rmzdv5p3vfCft7e2lsunTp3PDDTccdAEGuVyOp59+elDZaL8vERERERERkUOP6e1lNbsGMOyQAr4HXAeY3t3v1CwiIjIRXHTReWzbtnXIOtZaKioqqaqqYvbsOSxadBRnnfUq5syZu59mKQcTb/PGIc+78nJc3fh8V7CFwjY0trV1XPoXkUOX3bYVb+OGIevkTzm19Htw/EuH7TP25GPkXv26fZ6biOwfyRt+QuWnPopxO991Dba7i4pvf4P4PX+j+79vxNXWHYAZiogc3hTCIBNKZ2cnbsBFQywWo6GhYVR9NO2U2DbwZksZLB4vLEjzfS1Mk/Gjvy8ZL/rbkvGkvy8ZLxPpb6s/n+ORtk1sT/cT4SjzYjy8fSPPdbdSE0/QXFGNKe5o3d6VJm4skXNs7O8mcBHTyqvIExE6R8J6GFNYTBk3lp58lmwUkPQ8+oI8AyMWfGMJXIT1DA2Jcran+/E8Uxyr8F4g4XlYa2gqr8S3lg19XaTCPOVejICIniBLOsgTOcfU8kred9QSjq47vJObJ9Lflhx69Pcl40V/WxNfTzbDNx+6n6dattGZyRD3PBKeT082xBZfu3NRhAMMhYAkawyRczggcq5U5pwj7nuEUVS4FsCQDgKiyHFkYwNvfcmxvGzGLBL+vn9krb8tkcPT9u3bufTSS9m2bVuprKmpiZ/97Ge7fG9wMPi///s/0ul06Tgej7N48eIDOCMRERERERGZCExfD3cNU+fO4k/b3T3e0xERERlXURTR29tDb28PW7Zs5v777+X663/MCSeczMc+9ilmzJh5QOa1desW/vEfzy8dv+51b+Dqq79wQOYyUbz//e/iiSceKx3fe++j+30OdvPmIc+HzdMLqfLjIAX0AonW7ePSv4gcuvxHHh62TualJ7BmzSpSqTSNkyZT6/uYINhzn48rhEHkYBH/4/9S9cmPDFsv9ujDVF/2drr/538hFtsPMxMRkR0UwiATSiqVGnScTCYxo/ywo7y8fMg+RUREREQOZ735LDete5a7tq6hJ5fFUEhi78ym6QtyNCbK8RNlpevw3nyWdJgn4XkYYwijiK3pXsp8n4QtvKUceMXuGUveRbRnUzQkK+jt7dxlDg5wzjGtvIq+IEcqX+g/H0UkPI/K2Iu7X9clykiHeWLWMrOilv4ghzWGo2obOXvaXBZPmkbMaqGliIjIWErn8zywaSPXPPwQ2/r7MEAuCokZix3wyr8jYCEfFYKZbPH6wTOGwDmiYsCSoRDW5BtLMuaRzgdUJxL4nsdr583nfSechGftAXikIoemyI3PDYQTWVdXF5dddhkbNry4S0x9fT033HADM2bMOIAz2zutra38x3/8x6Cy008/nbKysgM0IxEREREREZkoTE8P3xymzroBdUVERA5Fy5Y9zDvf+Ra++MWvc+qppx/o6cgEYTdvGvJ8NK15XMffBsxRCIOIjFLs0T2HMGSBL1jLde94C+0dL25Oe151Nd/u6WH+Htr5Tz0xpnMUkfFhN2+i6iNXjbh+/N57qPj6l+n/ly+M36RERGQXCmGQCaW/v3/QcSKR2EPNPdu5jUIYRERERORwlQryPN25jZ5cFmsMZZ7PzeufZ0VPGzWxBNPKqzDGkAtDtqV6iVtLZy5DX5BjfnUDFbE46TAPUApl8KwlCCNaUn3MqarDGIhwuyzI7M/nmFpWxWbrkY/CUlBC5By22I9nLPOrG1jb00FPPksQRdQnqshFIZGL6MlliZxjVmUdHzv2dKZX1Oz351BERORws76ri28/9ACrOztoS6VIeB6hc5goJMTRH+Rxzg0KTvWMIXSOMIrwrMUYgy3WMUBEIYApiEJyocOzlvn1DfzjUUfxipmzRx3CKiIyUF9fH5dffjkrV64slVVXV3P99dczb968MR1r06ZNvPKVrxxUtnTpUqZPn77b+tu3b+c3v/kN73jHO6ipGdn7mU2bNnHllVfS0tJSKjPG8IEPfGDvJy4iIiIiIiKHDNvbSziCemnAdHeP93RERETGzJVXfoj58xcMKouiiO7ublasWM7SpX+hdcAC90wmw+c+9yl+8IPrd2knB59zzz2Pc889b5/68DZvHPJ8OH18Qpt9YDLQB9jW1nEZQ0QOXf7TT+62vBd4A3BPFMGAAAaAW3p6uAu4FXjF7vp8/rkxnqWIjIfKqz+J7RndZzdl37+GzJsvJlx4xDjNSkREdqYQBplQcrncoONYLDbqPuLx+KDjTCazT3MSERERETnYdGbT3L5xBUu3rKYrn8YUAxJa0n0EUcT0ymoqY4nSgseObBoHJKyPw5GLQlb3drCophHnYOdlkTHr0R/myUcRlX6CviBLwhv89jKisMByRmUNa3s7yLuImLEELmJSshzPFHa7jluPuVX1rOvvIun5lHk+ffks1liOrp/Ma5oXcMKkZuKeN95Pm4iIyGEtiCKWrl3Dfz78EH25QjiScw5rDKGLCsEKxWuHwDki5zAUwpcMlMIWrHNAYcGwZ0wh1CkIAEd5LEbc87j8+BM4/4hF+NYeoEcrcmhzu1zBH9re+9738vTTTw8qu/TSS+ns7OT+++8fVV9HH330iMMSRiKXy/G9732PG264gbPPPpvXvOY1HHfccTQ1Ne1Sd/369dx000386le/ore3d9C5Sy65hKOPPnrM5iUiIiIiIiIHL9Pbw0i+NesEant7xns6IiIiY+aIIxaxePGJuz336le/lne/+0q+//1ruPHGX5fK0+k01177H3znO9/fX9OUCcxu3jzk+ah594HKI3XOOa/lpHyOWX+8mSYo/asDdnzr6dpaKdxsdXh9VyMie8k5/Kd2DWGIgP8H3DNE0z7gPOARYOel2N6mjZjuLlxN7RhNVETGmv/k4yRuu2XU7UwQUPH5z9Dz69+Pw6xERGR3FMIgE8rOAQr5fH7Ufewc5JBIJPZpToeyXG73ueh7KhcZC/r7kvGivy0ZT/r7kvEyFn9b2TBgdW8H6TBPzHrEjcd1qx5hY383lX6cpkQlxhh68lnyYYg1ho19PfTmcsyurMUzlp5cBmOguGSSmPHIhiFt6X58a3Gu8P3gDoZC5b58jkmJcnrzWaLoxR2xI+fwsESRozaWZGZFLRv7u0mFhev7mlgZYRiRi0K68xmCKOLE+mauOuoUKvw42TAgbv0XgxdCyIX63+Fo6L9bMp709yXjRX9bB86yrVv41TNP8nTbdjJBgG8M2TDEAX25HBhwA24W8owpBTFYYwoBDRSuAaIdnTqHM4bARYQuoiaRZF5dPe996YksamgkChy5Ee3Zt+/0tyVyaHv44Yd3Kbvmmmv2qq+f//znLFmyZF+ntItUKsWtt97KrbfeCkBtbS0NDQ1UVlaSyWRobW2lo6Njt21f+9rX8qlPfWrM5yQiIiIiIiIHJ9PbO6IQhg6gbpS7KYqIiExksViMD37wo3R3d/GXv9xeKn/00YdZs2YVc+fOP4CzkwMul8O2bBuySriPIQznnfdG/iFy1Pzx5j3WMek0pr8PV1m1T2OJyOHBrl+H3c37tp8Dt42gfS/wHuCv7LrRlv/cs+RPPX2f5ygi46P8m1/b67aJpXfgP/k4wXEvHcMZiYjIniiEQSaUioqKQcfZbHbUfezcpry8fJ/mJCIiIiIyEbVnU/xt21qWbl1Ne7YfayyBC2nPpPCMZVZlLVWxFwPJ2jMpjDHEPZ/IObpyaTb0GWZX1hLiCsEKRTt2rm7LpphXVY8xELkIawbvVh3hqI0nqY4l6M5nSdjCLV+uWL5DQ6KcuPXY2N+NbyypfI5UPodnPY6onsQrp83jxIZmEl7hLWrMjuTWMREREdlXzjl+t/w5fv3c0wRRRC4MKfNjGAPZKCrczG0MoYtwgIkc1hZCF4xzOCgFMVhjcEC5HyN0EdkwxDOGfBjSWFbO+088hdOnzyi93ouIHM66urro6uoask48HucjH/kIl156aSnwTkRERERERMT09IwohKETMN0KYRARkUPPe97zfu68889EUSkanIcfflAhDIc5u3ULprjDzCVAEpi507/KyU27LFIerahx8rB1zPbtCmEQkRHxn35ql7J+4DOj6ONvwM3ABTuVe889oxAGkQnKrl9H/C9/2qc+yq79Lr3X/WxsJiQiIkPSHa8yoVZKj7oAAQAASURBVOwcmJDJZHDOjeoGw1QqNWSfIiIiIiIHm3wU0pLpIxuGlHk+qSDHd59/gJZMHxV+jCllVVhjaEn3kY8iQhOxqreD6eXVNCYrcM7Rk8/g20KIgjWGuPXpzKWZHFbgG0thGeWLfGPJRSERjppYkq5choQ3OITBo7AIc3ZlHWv7OujN54iI8I1HbbysNPfObJrQOc6dvpB3zF1Mb5AjiCIq/BiNyQotKBIREdnPnHM8sHkjN73wPI9s3QwUwhSCKCKIImL2xdd8Q+E1P8AR4rDFW5M8YwicIyqGMZhiv9YYwBC3Ho3l5RzZ0MhVJ57CJH1GJ7LfhPt8C6GMlUmTJnH11Vfz0EMP8cQTT9DW1jZsm+bmZs4//3wuvvhimpqa9sMsRURERERE5KDhHKa3Z0Q3fXYAprdnvGckIiKy302e3MT8+QtYseKFUtmaNauHbbd+/TpeeGE5ra3tZDJpampqmTSpkWOPPZ7KysrxnPKo9Pb28swzT9Le3kZnZxeJRJza2joWLDiCOXPmjvl4K1eu4IUXnqOzs5NYLEZ9/SSOOeZYpk6dNuZjjafuFctZUVbG+nic26wlAqIoIggCMpkMYRhi3nIRkyc38bWvfYvXv/68vRonamwcto5tbSWaO2+v+heRw4v/9JO7lP0M2DrKfq5h1xAG/7ln925SIjLuyn75X6XwqL2VuOVm+rduITrIrtlERA5GCmGQCaWurg5jDK54MZHP52lvb2fSpEkj7qOlpWXQcUNDw5jOUURERERkf+nIprh3+3ru3LqK1myKyEVEDrpyaRLWZ3ZFLTGvsNeNc9CeTeFbS8x6BFHIxlQ3nrHUxBI4KC2aBIoLJAttqmMJunMZKC2hpBSMEDpHU1klPfks+SgkZj2i4vV6RSwOgG8t86oa2JbuZVu6jzIvRlu2v9APhvnVDZwzdT6nNs7Et5baRNl+ePZERERkd4Io4vqnHmPpurX0ZDJYY0j6Pql8vnR9kA1DACIMnilcF3gOQhxhFOFZizEG6yDmFa4wcmFU/BkSuojZNbW889iXcsq0GZTHYgfuAYvIIe+FF14YvtIYmT59+qjGSyaTXHLJJVxyySUAbN++nbVr17J161Y6OztJp9PEYjFqamqor6/nmGOOUfCCiIiIiIiI7Fl/P8Y5ghFU7QBsd/d4z0hEROSAmDateVAIQ1dX127r5XI5fvvbG7nppt+xadPG3dbxPI/jjz+Byy57F8cdd/yQ41500Xls27br0tjbb7+V22+/dY/tPvOZz3PuuUMv+r/33nv4zW9+ydNPP0lY/K5uZ01NU3jzmy/mggv+kXg8PmR/AI899ihXXfWe0vE733kF//zP7wbgjjv+xA03XMeGDet32/aoo17ClVd+aMjn5Kc//RE33HDdbs+dccaJe2x3/PGLufbaHw8qu+22W/jKV/61dDzcc+ac46mnnuCvf72DRx55qPA4ZswAYHcrB7LZLJ2dnbS0bKOsLLnHfofjJk8eto5t3b7X/YvI4WXnEAYH/Ggv+vkbsBxYNLDvF5bv9bxEZByFIYlf/3LIKs7zyJ98CvEH7ttjHRNFJH/9S1If+cRYz1BERHaiEAaZUJLJJNOmTWPz5s2lsi1btowqhGHr1sEfbs2dO/apnyIiIiIiYy1yjr4gSxBFlPtxVve285/LH6Azl6bMizEpUY5nDOv6OkmFebJRwIq+NuZU1FPux0iHeTJhQKIYyuBbjygK2ZzqoaamkMLuBoQsAHjG0pXNMLWmii2mh9A5vOLiS1fc1dpiqPDjzKmsY21fJ9kwwOGo9BOUe4UFlfkopCuXwRjDZfNP4JTGGfTksxgMDYkyZlfWlUIdRERE5MAIoohnWlv40ePLeLZtO5ZCYII1BmsMOwLWdxznowiHw7gXy8Li9UHkXOmKYkeIAy5PeTxG0ouxpLmZD590GvHidYmI7F/O6dp7opo8eTKTR3CDpoiIiIiIiMju2N4eAHpGULceML0jqSkiInLw8bzBSyB2F1qwZs1qPvWpj7Bly+Zdzu3cdtmyh1m27GHOPfc8PvGJq/H9/bfEorOzg8997tM8/viyYeu2tGzjP//zP7j55t/zzW9eQ3Pz9FGPl8/n+epX/42//OX2Ies999wzXHXVu/nkJ/9l2ACJA+F73/suv/nN0AsYB0okEkyZMoXq6mqqqqr3elxXUYkrK8Ok03usoxAGERkR54g9+cSgooeBp/eyu58BXxtw7K1euZc9ich4it1/L972liHrZF9/PqlP/wt1p52I2XFD124k//sXpD70MbB2rKcpIiIDKIRBJpw5c+YMCmFYvXo1xx577Ijbr169etCxQhhEREREZCLrymV4oHUDd2xdRVumnwhH6CK6cxnKvBjTy6uxxQ/IgiiiO58l6flYDNkwZE1fB/OrGghcVOzxxQVXMWPJRSE9+SwVfoy+fA7Pe/HDNmOKiyiNYVKygm3pPqw1mOIiy5i1JItfXNfEkyysnsTG/m568hli1tKS6SuNOaeyjnObF3L65FkKXBAREZlgurMZvrfsYZ5o2UZLXx8xawsXAmFI5BzpIMA5h8GULiV8YwicI3IOW3xt97FERHilQAZHGEWk8nkwMLO6ln9YsIhz5szD0xd8IiIiIiIiIiIiY8r09gLQPUy9a4E3AmH3cDVFRCam7m7YulXfM4ylqVMjamoO9CzGTnt726Djmp0e3PLlz/HhD7+f3p0CiXzfZ8qUaVRWVtLW1kpbW+ug87fddgvt7e187WvfIhaLjc/kB9i4cQMf+cgH2Lp1cFCEMYYpU6ZSU1NLPp9jy5YtpNOpQe3e/e538v3v/4SZM2eNaswvfenzLF36l9JxVVU1kyc34XkeW7Zspq+vt3QuDEO+/vUvMWfOXI488ui9fJTjI5fL7lJWE4bEg4ANUYQxBt/3dwnUKC8v5zvf+Xeuv/6XJBLJ0Q9sDFHjZLwN6/dYRSEMIjIStmUbdqfXof/eh/7+wOAQBtvejmlvxzU07EOvIjLWEjffNGydzDsuI5y3gNxrXkfiT7ftsZ63YT3+skcITloyllMUEZGdKIRBJpwjjzySe++9t3T8+OOPc8EFF4yo7fbt2wcFOMRiMebNmzfmcxQRERER2VuuuIO0NYbHO7bwgxceojufIeH5VMTiWAwre9rpD7P0B3kCFzGrohbPWrpzGSLniJnCwsm49ciGAVvTvTQmKnaMwI7VkzvCEDpzaSYlKujN5wad38Eaw7SyKnJRSEc2XVx0GdGUqMQfEADRH+SojSe5ZO7xNJVXkQ7yxKzHzIoaFlZPUviCiIjIBOOc49m27fz7g/expa8X5yDCYQ04AxiDV3z9Dp0jwmEiSqFM1jmi4rnCFYHBYCj3Y+SjiHwYUp1IYoALFh7J219yHDHPO2CPV0QKInRdLiIiIiIiInIoMj3dOKBnmHo7lqGa/v5xnpGIyNh66CGPT34ywXPP6buGsWaM48gjI77xjQwnnxwN32ACy2QyPP/8s4PKpk6dVvo9lerns5/91KAAhmQyyRVXvIfzz/8HysoqS+WrVq3kpz/9EX//+99KZQ89dD8/+ckPee97P7DL2J/73BfJZrN0dnbwb//22VL5ySefwsUXv32Pc54zZ9d72TOZDJ/+9EcHBTBMndrM2972Ds4661VUV1eXyoMg4NFHH+bHP/4+K1YsB6Crq5PPf/7T/OhHPyMej+9x7IH+/Ofb2LKlMN6SJafxzndewdFHv6R0v08Yhtx339/59re/XgqoCMOQb3/7G1x33X/t0t9rX/t6jj32eACuvfY7rB6w6/p//Mf39jiPqqrqPZ4bjfLyCs4882xOO+0MTv3+NUz/2118A/jkgDq+71NVVUV9fT1e8XvM9evX8YMfXMuHPvSxvRo3amwcJoShdY/nRER28J9+ctCxoxCksLeWA6uA+QPKvFUrCRTCIDJxhCGJ2/44dJWZs8mf8XIAMm+/dMgQBoDELX9QCIOIyDhTCMMo5XI5nn/+edauXcvmzZvZtm0b/f39pFIpwjCkrKyMsrIy6uvraW5uZvr06SxatIgpU6Yc6KkfNM4880yuu+660vH9999f2IlvBAu67rvvvkHHS5YsoaKiYg+1RURERET2j758lofaNnHX9jVsTfUCDs9YtqV6qfATTC2rKl3v9udzZKOAci+OoxCgEOGYW1lP4IpfhJsXQxZinkdXPk1TshJb3JXaG3DtbI0hF4XUxJMkPZ9MGJDwPMAQRhHlfgxT7Gt2RR3lXozNqR4i5whcxJZUL47CDtizKmq5cObRLGmcsV+fPxERERm9Dd1d/OzpJ3h4y2a6sxli1pINQyLn6HeusES7GA5ljMEaQ+QcIQ5bXMDtWYuLCsu5I8C5CEshlCEXhpTHYsyoqubtLzme06br+kBERERERERERGQ8md5e+il8VjeUHcsazYAds0VEJrq//c3jrW8tI59XyOx4cM7w3HMeF1xQzq9+lebMM8MDPaW99rvf/YZsNjuo7IQTTir9/qMffY+tW7eUjisrK/nBD67jiCMWAZDLvfjY589fwFe/+k1+/OPv8/OfX18q//Wvf8HZZ59TarPDjsCBgf0DNDRM4qRRLn679tr/YN26taXj009/GZ///JcpLy/fpa7v+5xyymksXnwiX/jC1dxzz10ArFy5gv/93xv5p39664jG3BHAcOmll3P55e/Z5bznebz85Wcye/YcLrvsrWQyGQCef/5ZVq5cwYIFCwfVb26eTnPzdACqqqoGnRvt8zFa5557Pu9+95VUVBRCNeo+9xkANuxULwgCOjs76e3tZfr06aXAiltu+V8uu+wKqqtrGK2ocfKQ523r9lH3KSKHH/+pwSEMTwJ7jncZmT8CHxk4xuqVBEtO2cdeRWSs+E88hm1vH7JO9h8uLN0jnjvrVYRTpuJt27rH+olb/0D/v3651EZERMaeQhiGkc/neeSRR7jnnnt4+OGHWbFiBWE4+g+eGhoaOPbYYznjjDN4xSteQXNz8zjM9tCwePFi6urq6OzsBGDjxo089NBDnHLK8Bf/v/vd7wYdn3322eMyRxERERGRkXqobSM/Xfko3fkMCc+nzIvhcKzoaSMfRfQGOYyByckKjDF05gpfYBpjMEDc+nTnsrRnU7vdz9ZiyDvoC7LUxctoz6bwPFs67ygEMVhjmFNVx6qeDrJhSMxYImBScVyA0EUYAzMqajh7yjzKPJ90GFAZi3N07WSOrJmM1Qd1IiIiE94jWzbznUceoC+boz+fI+H5xDxLLiqEKBhTCGNyAMUAJ2MMHoWAhTCKsMUyYwxJz8MYQzoI8K0liCKq4wmuOP4Ezpk7j4rYyHbXEZH9wzlds4uIiIiIiIgcikxvDz3DV2PHUkKTy0EQgK/bREVkYnMOvvrVhAIY9oN83vC1ryV4xStSB+U6rXvvvYef/OSHg8qmTm0uhSP09vbyf/83eHfhf/mXz+8SprCzd73rfaxYsZwHH7wfgCiK+O1vf8VnP/vFsZv8AC0t27jllptLx/PmLeCLX/x6KSBgT+LxOJ/73Bd5+9vfXAqCuPHG33DRRf8Pz/NGNPbLXvaK3QYwDDRz5ize9KZ/4le/+q9S2YMP3r9LCMOBtGjRkYOO7aZNwK4hDDsEQUBLSwszZhSC5bPZLHfe+RcuvPAfRz32sCEMba2j7lNEDj/+c88OOr5lDPq8k8EhDN7KFWPQq4iMlfhf7xy2TuaNF7544Ptkz3sj5df9cI/1vU0b8R9fRrD4xLGYooiI7IY+Xd+DBx98kD/84Q/85S9/IZUqJEI75/a6v7a2Nu666y7uuusuvvjFL7Jw4UIuuOAC3vCGNzBp0qSxmvYhwVrLBRdcwPXXv5go+r3vfY8lS5aUFoftzgMPPMCjjz5aOq6oqOB1r3vduM5VRERERGSHdJDnkfbN3Lt9Ha2ZfowpBCSs7uug0o8ztawKzxbCETpyaZyDcs8ndLA51YNzjinlVeSiYNAX3TsCFFoz/UwtK6bGO1dKLd0R1pCPQiYly+nIpQhdhGdssaoj6RXe+pV5MRZWN7Chv5vObBrPGoIooi3TTz4q7JkzvaKat899KcfVT90/T5yIiIiMmRfa27ht5QpuXb2CfBRigFwUFYKdIr/0+aaBUphCBBjnStcckXM4KJUX2hg8Y/GNpaGsnJnVNVx14hLm1tUfqIcqIiIiIiIiIiJy2LG9vXSPoF71gN9Nqh+3Fzs8i4jsTz098PjjI1tALvvuscc8enqg5iB4eQjDkN7eXl544Xluv/1Wli79yy73819xxXvxi4FDd9zxJzKZTOncMcccx9lnv2pEY33gAx8phTAA/PWvd/LhD3+SysrKMXgkg910042DNoW88soPDhvAsEMymeTNb34L3/3uNwHYtm0ry5c/z9FHv2RE7d/1ritHVO+VrzxnUAjDihXLR9TuQDA93di+XmDPIQwA6XSaWCxOPp8D4Jlnntq7EIZh1n6Y1u2j7lNEDj/e8ucGHQ+3NHvSpEmceuoZg0J8dnYvEAI7rqq81Sv3YYYiMtaGC2EIZ8wkfMkxg8qy510wZAgDQOKWPyiEQURkHCmEYYD+/n5uvPFGfvGLX7BlSyEdcuAHNUMFAIzEwL5eeOEFvv71r/PNb36Ts88+m0svvZTFixfvU/+HkiuuuILf/OY3pQCMhx9+mOuuu453vetdu63f0tLC1VdfPajskksuob5+6BvBjzjiiEHHP//5z1myZMk+zFxEREREDkf3bV/PL9Y8TmcujWcsCc8niELW9nUBjn6/sAN1TTwJQFsxpMEYi2+ACLZmeqmMJQod7pT/FjOWTBjgGUPceuRdRMy8eAOCKzao8OM0l9ewqb8bZwqLKQHq4+Wlur61VMcS1MQTnFA/jXwUEeKYlChnyaQZHF3bhF8MixAREZGDx9K1q/nZU0/Qk80QuojyWKwQwBBFWGPJRSGRc1gohTl5xhA4R+QchsLnn9YYLOB7HrkwAhyBi8gFIQ1l5Vx+3GJOmz6T2mTywD1YERlSIXpFRERERERERA41pqeHnhHUG7im1qTTCmEQEZGDwlVXvWfUbf7pn97Kq1/92tLxE088Nuj8619//oj7mjVrNscccyxPP/0UAPl8nmeffZolS04d9byG8+CD95V+b2ho4MQTTx5V+5NPPmXQ8ZNPPj6iEIZ58+YzZ87cEY0xd+58PM8rhUVs394yqjnuT3bTptLvG4epW11dTXt7GwArVrywV+NFjZOHnk9r6171KyKHkUwGb83q0mE/8MAwTc4557WccsppQ4Yw9AJPAjtWpnkrV+zbPEVkzJjODvzHlw1ZJ3fmK2GntavByUsIm6bgtWzbY7vELX+g/3P/tktbEREZGwphALq7u7nuuuv4zW9+Q39//x6DF3ZOzhytnUMcnHMEQcAdd9zBHXfcwbHHHsuVV17Jy1/+8n0a51BQX1/Pe97zHr797W+Xyr71rW+xZcsW3vve99LU1ARAFEX89a9/5ctf/nIpOANg8uTJXHbZZeMyt2w2y7Jlu7/w2bhx8Ec3ra2t3H///butO3/+fCZPHvpDGBERERGZWHJhyOMdW3iobSMduTS+sYQu4pmuFso8n6llVaXr/pZ0Xyk0IReGrO7tYH5VPdXxJNkwwDMvBh341pINI9qzKRLW3zmDodRn3kVMSlawub8H3ziMMaX3KXFbeHs3OVmBh2FTqptUkCdZDIToymXIhAHOOaaVV/HuhUs4omboZHYRERGZ2JxzbOjp5r+feYq/rF2NiyKCYjyTF0Wl6wRjwMOAc0RQCGawthC6UCyLALvj809jSPo+uDy+jVOZiLOgroFPn/Yy6pJlB+jRioiIiIiIiIiIHN5MTzfdI6hXPfCgv3+cZiMiMnaqq+GlLw15/HFv+MqyzxYvDqmuHr7eRFZWVsb73vdBLrjgokHlzz33zKDjE044aVT9nnDCyaUQBmBcQhh6enpYM2Dh7cKFi7Cj3CylqWnKoOP169eOqN0RRxw54jF836eqqoquri4A+vv7Rtx2f2t59il+X1fH48kkVfE4tZ6HtXa3z+uOAAaA7u6uvRrPDRfC0NcL6TSU6XtVEdk9b9VKTDHkBuA+ID9Mm7POeiXHHffSXcot8FLg5cV/CwaOs34d5PMQi+3rlEVkH8Xv+Rsmioas03HaGcR3LrSW3OvPo+z66/bYztuwDu+5ZwlHEMolIiKjd1iHMKRSKa6//np+9rOfDQpf2LHAyTlXKkskEixcuJBFixaxcOFCpk2bxpQpU2hsbKSsrIxEIoHv+2QyGTKZDN3d3Wzbto2WlhbWrl3L8uXLeeGFF9i27cXkoZ0DHp588kne/e53c8IJJ/DhD3+YE044YT8+GxPPFVdcweOPP85dd91VKvv1r3/Nb3/7W6ZNm0ZVVRWbNm2ip2dwvncymeQ73/kO1eP0CWFrayvvfOc7R1T33nvv5d57793tua9+9atceOGFYzk1ERERERlH925fx6/XPkV7NoUxhpi1ZMOATakeLIbaeJLKWIKE5+MctGX7scZgjCXuWXJhwNq+To6qnbxLyAKAZyyduTRzK+vZnunDObdLkBsUQhb68lm681kS1iNyDs9YauIv7kZdlygjGwUYY5hZUUM2DPGMobm8hjOnzOG4uin4VjcviIiIHMyCKOK/n3mKO9asYktfHzhH3PfJBXlwjnQ+gGIgw47rCmsMkXOEgNlRZi0uivCNIXSOyDkMhnQQEDrHtIoKzl+4iPPmH0G5vpgXERERERERERE5YExPNz3DVxsUwmDS6fGajojImDEGPv3pLG99axn5vHZvHU+xmOPTn84elJvkxuMJFi48gpe//CzOPfc8amtrB513zrF9e0vpuKKigqlTp41qjPnzFww6bhlix+G9tWHD+kEbQz7wwH2cccaJ+9TnzvfS70ldXf2o+k0my4AuoLCJ4USzbdtWvvvdb3Lv3+/GNTYCkBhF+76+3lGPuXLlCrZt2kQ/0LLTv23AO4CPALZ1O9HMWaPuX0QOD/4Lzw86vmsP9QY6/fSXM2nSJGbOnEVT0xROO+0Mzigr49Vf+xJ7WjllggBv3VrCBQv3ec4ism9if71zj+cc8G1r+epnPs5D57ya6uqaQeez518wZAgDQPyvd5JWCIOIyLg4bEMYbrnlFv793/+d1tbW3YYvABx11FGcddZZLFmyhOOPP554fJc8oV2Ul5dTXl5OfX09c+bM2eX8pk2beOihh7j//vu5++676evr22XsRx99lLe97W2ce+65fOITn6CpqWlMHvPBxlrLd7/7XT796U/zf//3f6XyMAzZuHHjbtvU1tZyzTXXHPYBFiIiIiKy94Io4qmubTzZsZWefIaE59OXy/Jwx2aSnk9TWSW2eP2+qb8H31hi1qM7nyHbGzC/qgHPWPJRhGdeTFSPWY9cFNKZyxC3Hv1BbtB5zxiyUYRnDJWxBL35LAnPA0zpPYpvLNYY5lTWs76/i85sisBF1MXLCKKIfBTSl88R4pheUcMHjzyNmRW1+/PpExERkf2gtb+fbz10H0+0bMNgyEchCc8rBEBR+KzRGEMYFUIYCqFNhTIPimELYHGlukk/BgbSuTw1yQTOwZLm6Xzs5NMoH8HnoiIycUQchHfPioiIiIiIiMiwbE/PsCEMSRi0a6JJ9Y/jjERExs6ZZ4b87/+m+MQnkjz/vMU5fc45loxxHHlkxDe+keHkk4fegfdAufLKD+0SguB5HuXl5VRWVjFlylR8f89LH/r6+ogG7C5cXV076jnU1Axu09s7+kX6w+np6R7zPvv7+0ZUbyRrIfZkYHDERPDcc8/wkY+8v7QWY2/k88PtO7+rq656L8uWPbLH8yuLPxXCICJD8ZcPDmF4YJj6Rx55NI3FsJkHH3y89HpoN26g+mtfGrKtt3KFQhhEDjTniN+1dPengPcAP44i6Ozgppt+x6WX/vOgOvklpxJNmoRta9vjEPG77iT9gQ+N3ZxFRKTksAxhePvb386jjz46KHzBOYdzjtmzZ/OmN72J1772tcyYMWPMx54+fTrTp0/nTW96E7lcjvvvv59bbrmFO+64g1wuNyiM4bbbbuOuu+7im9/8JmefffaYz+VgkEgk+Pa3v81rXvMafvCDH/D888/vtl55eTn/8A//wPvf/34aGhr28yxFRERE5FDgnOP+1g3cuP4ZtqV7cRSCEdJhnu2ZfnxjmZysoDaeBAxhFNGRS+HbQjBCwvpkw5B1fZ3MrazH4QYtfdqx+3Rrpo/GRAV9+RyFj88G3zjggOnl1azqbScXhsQ9j8BFxK1HVayQ1+5Zw+yKWixgjaXKj5MNA4wxvKSuiVdOncdL66YR97z98tyJiIjI/tGbzfLrZ59m6brVbO3rw7OWMIoIoojQOSzFq4vi5YVnLS6KiADjHLZ4PRI5hzEQARQ/Fw1dRBBG+J6lsbyCN8w/gn9YuAjP2j3OR0RERERERERERPYf09PDcMs2a3Y6Nun0eE1HRGTMnXxyxN/+lqK7G7Zu1fcTY2nq1IianV8kJpgjjljE4sUn7nX7dDo16LisLDnqPsrKygYdp8YhzKivb+yDHQaGTxwOuru7+PjHP7hLAENjNsvKdJpcLkcQBKX1ITtYa3nZy17O6tWr9nrsxsbJQ55v2TFWa+tejyEihz5v+XOl3wPg0WHqn3HGy0q/Dwwkipqn48rKhnzf561aucdzIrJ/eGtW4W3buttzXwd+POD4V7/6+S4hDHgeuTNfSfJ3/7PHMWIPPYDp68VVVu37hEVEZJDDMoThkUceKe3w5pzDWstrXvMaLr74Yk466aT9No94PM6ZZ57JmWeeSVdXFzfffDO//OUv2bRpU2lu6XSa55577rANYdjhNa95Da95zWtYv349Tz75JC0tLeTzeaqrq5k3bx6LFy8mkUiMut8XXnhh1G2mT5++V+1EREREZOKInOP57u08391KJswT93xa0n3ct30dMc9nclkFnil8ob+2txMPg2csLZk+0mHA3Ko6slFIEEUkikEHxhji1qM/yJMO81gsEQ5vQMiCZwzZMKQ6nsRP95KPImK20N4BFvCtIenFmFfVwNq+DjJBQIijIVlG5CJykaMnlyVwEQtrJvHhI0+nKVlJLgqJ2cIO2CIiInLo2dbXx5fvu5uNPd2k8wG+tSR9n1Q+jy1+1hm5CAeEDvziNYFnDIFzheAFKH0uGrOWmOeRzucx1oKDuOfxpiOO4s1HvoT6nW4yE5GDh3aIExERERERETk0mZ5ueoapU71zm1Rqt/VERCaymhqoqTm8FpXLvisrKx90nE5nRt1HeqdFrOXlFfs0p91JJAaHQyxefCJvf/s796nPqqqdrwAObT//+fV0d78YTTXLWr65bh03ZjLcN0S76dNnkEzu23egIw9h2L5P44jIoc1f/uLmtM8Cw0X+nHDCHta5WUs4dz7+s0/veaxVK0Y/QREZU7EHH9ht+ZPA53Yue/Jxnn76SY455rhB5blXnjNkCIPJ54n9/R5yr3v9Ps5WRER2dliGMEBhl9t4PM4FF1zA5ZdfzowZMw7ofGpra7n00ku55JJLuPXWW/nJT37CihW62N3ZrFmzmDVr1oGehoiIiIgcxB5o3cDNG59jfX8XDodzkAkD2nMpEtZjalkVthickAtDuvJp4p6HNRbPGXryGTb1dzMpsesXraa42LE9m6YukaQtk8LzXtydwWBwRFhjmFFRw9reTgIX4RtLPgqp8OMkbOFtWrkfY0FVA+v6usAUFkV2ZNNYY1lQ3cA5U+dzQkMzSa9QP+Edtm/vREREDmnb+/tZunY1v3r2KXqyWawx5MIQAzhHafcWA3jG4lxEBESRw9pC4IJ1DgdEgCnu+GIweMbgWUtNIkljeTmXH38CpzYf2M9JRUREREREREREZPdMTw/dw9TZeZNzMw47eIuIiExElZWVWGuJokKAR09P16j76O4e3Kaqaux3Eq6trR10HI/HOemkJWM+zqFs6dI7Sr/H4wl+3N3N7EyGbw3Trrl5Oj09w11NDa2xsXHI89uKPxXCICJ71N+Pt35d6bAK+BjwELAM2F2M3uLFJ+6xu2D+giFDGLw1q/dyoiIyVmIP7RrC4ID3A/nd1P/Vr37O1742+Mom94qzccZgiveJ7U586R0KYRARGQeH5Soday1vfOMbueqqq5g6deqBns4g1lrOP/98zj//fP74xz9yzTXXHOgpiYiIiIgclJxzrOptZ2VvO9koJGE9Nqd6WLptNb6xNCYq8G0hIGFlbzs+BgdsSvWQCQNmlNeQCvM4V7hOB4q7Rnt05NLUxcpKix/NgI1mPWPoC7LMraynLZMicg5brBA5hy0ueGxIlBNEEZtS3WTCkAjHpEQhlT8fhXTlMuSjkJc2TOODi04jZi2ZMKDMi1EdS5QCH0REROTQtaK9ne8+8gDb+vroy+Uoj8WInCMfRVgMuSgcFMJgjMHDEOGIcBhXKLPGErmIMt8nFxSuO0Ln6M/nKfN9LjziSM6ZM4/mw2yXHJFDVeT0XkFERERERETkUGS7u+kZps7On/CZnXb0FhEROVQZY5g8uYlt27YC0N/fz9atW5g1a+QB5KtWrRx0PGXK2K8zmDp12qDjTZs2jfkYh7Jt27bR1tZaOl5y8inM+q/rAdgwTNupU6exYsXzw9QaWmPj5CHPtxR/mgFzFBEZyF+xfNDxXODfi78HwDPAXe99P490dfHYY4/S0dHBrFmz99hfOG/ekOPZAYEPInJg+LsJYVgK3LuH+r/73W/53Oe+SHl5eanMTZpEcPxLiT3+2B7Hid915643tYuIyD47LEMYbr75ZhYuXHigpzGs888/n9e97nVs3rz5QE9FREREROSg8kj7Jm7ZtJyVve2lhYmpME97NkWFH6e5rKoUwJAO8/Tls8Q9H2MMkYtozfYTtx4Ju+tbJs9Y8lFIf5CjzI+RDvPEzcB6hsg5yr0YDYly2rIpEtbDGEPoIuoSZXimMHZjsoKk57OhrxtwpMM8W9MBnrHMrqzj1VPns2TSDMr82Hg/ZSIiIjKBdGUy3L5qJf/19ONkg4AwKoQqBFGEofBFmTHgYQidI6IQ9uQZgzEG30GIKwZA7fh+zRC3HliHbyy1iSSTysv5+Cmns7B+0gF9vCIiIiIiIiIiIjI809vNcHs3/xWYB3QDPwBel+of93mJiIhMFEcf/ZJSCAPAsmWPjCqEYdmyR3bq75jd1jPF+352cEPsSLyzyZObmD59Bps2bQRg06YNtLRso6lpyoj7mIh2bHCzg3NuXDaY6exsH3Q8q6EBE4bA8CEM5eXlBEGwT+NPnjx0CEN/8Z/XqhAGEdk9b/mew2B84Hhg+lUf5W0NDQBkMpkh/3sazp479Hgt2yCVggGLuUVk/zEtLfhr1+xS/sUh2vT0dHPrrX/gTW96M57nlcpzZ58zZAiDt3ED3upVhPMX7MuURURkJ4dlCMPBEMCwQywWY/bs2Qd6GiIiIiIiE9bG/m7W9HWQDQMSnsfG/m5u27ICgIZ4GTFb+ABqeU8rPoZsGLC2r5OpZQFNyUr6gxwOSh9UW2PxjWN7pp/p5Tv2inHAix9kW2PpCbI0JipY39816LyjsLDRWMOMihocjo5sGpzDGcOkZAUAQRTRkU2TiwLOaJrF5fNPJB0GBC6iwo/RXFY9Ll9GioiIyMTlnOPvG9fzi6efZGNPN+kgIGE98lEe5xzpIChcU0Dp+sWzliiKiABbvJnJmkIolG9sIYwBh3GGTFC41qhPlHHOnHm8adFRNFVUHuBHLSJjLULvI0REREREREQOOc5henr4T+BzQA9wxh6q7ri1vwMgnd4PkxMREZkYjj/+BJYuvaN0fPvtt3LhhReOqO2GDet4+uknS8fxeJyjjnrJbuuWlSUHHWcymVHNc8mSU0shDAC///1ved/7rhpVHxNNMlk26DiTyVBWVraH2ntv58CLoKsLgAjYuGv1QbZvb9nn8Rsbhw5hAGgBprdu3+exROTQ5A8RwgAQTm7CFQMYAJLJ5BC1IZo1e9gxvfXrCI88akTzE5GxFXv4wV3KngXuGabdtdd+h5NPPoXZs+eUynJnv4qKb3196PH+frdCGERExthhGcIgIiIiIiIHvyc7t3L75hU83bWNqLC9M/35HO25FDWxJM3l1aUAhr4gRyrIE/d8jDEEUcSWdC9x6xfa7sQzlmwUEjqHby1hcWfpHQwQOkdtvIzWbD/9QZ6k5wGGyEXUJgqpwdYYZlXUUenH2ZTqwTeWvnyW/iAHQHNZNedMnc/Lm2aT9GLj/pyJiIjIxJUJAn725OPcumoFDkc6H+B7Ft+zmAAohiuExRCGaMD1iW8MgXOFaxYK4QwGQ8Lz8KwlFQRUxmIYY5hVXcvVZ7yc5qrqoaYjIiIiIiIiIiIiE0l/PyYMmQLs2Cd7OrBpiCZdgEn1j/fMREREJoxXveo1fP/73yVdDCF68snH+dvf7uLMM88atu21135n0PFZZ72Kysrdh5lXVFTieR5hGAKwdeuWUc3zzW9+Czff/PtS+9///n945StfzRFHLBpVPxNJdfXg7x63bt3M3Lnzx3yc+vpJg46feqGwmHk7kB+iXUVFBRs2rNvn8RsbG4et0wLMVAiDiOyBt/KFIc+HRxw5qv7CAQu09zjmurUKYRA5QGIP3b9L2XUjaPeyl71iUAADQLD4RKKaWmx31x7bxe+9h8w7Lx/lLEVEZCgKYRARERERkQlve6aPdX1dZKOAMi/Gur5Obtr4LA6oiyVJeD4OeD67Hc8Y+oMcq3rbmVleQ32inL58FigsSATwrSWKHFszvUxOVOwyXmHhYiG8oT5ezvZMH55noLijrCv24VnD3Mp6Vvd2kApzWAp16oshDKGL6M5lyEYhr5oyjzfPO4b+II/DURtPMjNZi2fsuD9/IiIiMnEFUcTtq1byxxXLWdHZXih0kI/Cwr8wZGBklGctRBERYJzDGlO4dnEOU2hK5BzOOcLIEbkI46AmkeTU6TP45+MXUxGL7/8HKiL7zW5y5kRERERERETkIGd7e3Ypq2XoEIZuwPSnxmlGIiIiE09VVRWvf/35/O53/1Mq+9KXvkBzczMLFizcY7uf/vRH3H//vaVjay3/9E9v2WN93/eZMWMm69atBWDVqhVs3ryJ5ubpI5pnc/N03vCGN/KHP9wEQDab5ROf+BBf/vI3eMlLjh1RHwDLlj3CnXf+hU9+8uoRtxkvc+bMHXR8111LxyWEYcqUKTQ2Tqa1GHLw3Lat3FZZyaS+vj22SSaTTJkyZY/nR6OxcfKwdVoAqxAGEdkDf+WKIc8HRxwxqv6ipim4ZBKTyeyxjrd+7aj6FJGxE3vowUHHOeAXw7RJJpNcddVHdz3heeRPO4PE7bfuebz77oEoAqt700VExopCGEREREREZMJ6vns7f9mykkc7thC4EIOhN5+lM5ehLp6kubyahFd4W9Obz5IJA5LWB2PIRyHr+7vxrVfaMXqgmLFkwwAoLFiMiosYdzBA4CKmlVXRkUuRi0Li1sO5Qt0qPwFA3PNYUN3AtnQv29J9JD2f7myannwW5xxTyir5p2kLeOWUeVSVJQbNIZcLx+/JExERkQkvGwR8+6H7eWTLZnJhiMVQFvPJBgGBM1hjiJwjLAYs7LhW2VEeFcuNKdS1QDIWIxuEhEQYa3DOcer06bz3hJOZWV1TCqUSERERERERERGRg4fp7t6lrGaYNl2AKe4ELiIicrh417vex333/Z2tW7cA0NPTw+WXX8q73vUezjvvH0gmX9ysZc2aVfz0pz/i7rvvGtTHxRe/nYULFw05zkknnVIKYQjDkCuvvILzz7+AefMWUF5exo6NXgDmzJnHpEmTBrW/6qqP8Pzzz7JiRWFH9Pb2Nq688gpe85pzOf/8C1m06Eh8f/BSj1QqxcqVK3jwwfu4++6/smHDeqZMmTq6J2icnHTSEn7wg/8sHf/Xf/2UlpZtLF58IrW1dXieVzpXVVXNokWj2+l9oNe+9vX84hc3lI4/MWUKZ7W3Y7u7iaKoVO77PjU1NdTV1WGtJR6P09AwqfS3sTeqqqpJJBJks9k91mkBbFcX5HIQVzi+iAyQyWA3bhiySjh/z6FBu2Ut4cxZ+MXXk93x1imEQeSA6OvDf+apQUVLgY5hml144T/S1NS023O5l79iyBAG29GB9+wzhMeMPNhLRESGphAGERERERGZELpyGTb0d5GLQso8n3V9nfx63VMELqI2lqTML8fhaM30YQz05LP097Qxp7KO6liS3nzxy63iwsKY9ciGAVvTvVT7cXZebmiMweHIRiFVsQQ9+Wwp0AEKu0h7xpDwfOZU1rG2r5NsGGINWAP1iTKgEMjQF2QxxvDa5oWc2TSHdJjHYmhIlnN0zWR86yEiIiKyQyqf5/5NG/nZk4+zoacLD0MuGhjO5MA5jDGF0AQHIY4wivCsLYQuOEcERIBxDuccxnp4xUCG8liCSeXlvH7+Qt581EsGhU2JiIiIiIiIiIjIwcX09OxSVjtMm27ApPrHYzoiIiITVnl5BV/84tf48IffT29v4fUznU7z3e/+B9/73n8ydeo0KioqaW9vo7V1+y7tlyw5jcsvf8+w41xwwUX84Q83kcsV7ldqa2vl+ut/vNu6n/nM5zn33PMGlSUSSb72tW/z8Y9/kNWrVwGFMIfbbruF2267hbKyMiZPbqKiopJsNkNvby+trdtxbudtaCaGhQsXccIJJ7Fs2SMARFFUeiw7O/74xVx77e6fq5G4+OK38ec/38b27S0A5K3lL42NzJs0iVwuRxRFeJ5HLBYbFFD/wQ9+jDvu+NM+hTAYY5g8uYmNQyyibin+tG2tRNOa93osETn0eGvXYAaExexOuGCUIQxAOHuOQhhEJqDY009iwsGb9f12BO3e/vZL93guf8Yrhm0fv/ce0gphEBEZMwphEBERERGRA2pNbwdLt63m/tYNpMM8BugPcnTlMtTFy2gury6FI/Tks+SiiDLr44C8i1jb18n8qgYCt+uH0zHr0R/kqIsnCwXOlUIaAAyGIIpoSlbSm88SRCG+9XDO4YAqPwFAVSzBgqoGtqR6ac+mqPDjdGTThdB6Bw2Jct44/She17xwUJCDiIiIyM7aUym++/CDrOhopyXVR8Lz8awhl4swjkIYQ/FaxJWCGABXCFywxTJrLS6KSHoe+SgicA6HIxUEWAynz5jJBUccyVGTGgfdXCQih74Ie6CnICIiIiIiIiJjzPZ07VJWM0ybLsCk0+MwGxERkYlt0aKj+N73fsynPvVRtmzZXCoPgmDIxfPnnnsen/jE1fj+8Pf+zJw5i89+9l/5ylf+jXQ6tVfznDy5iR/+8Aa++c2v8Je//GlQwEI6nWb9+nXD9tHUNGWvxh4Pn/3sv/GJT3yYFSuWj+s41dU1fO1r3+JjH/sgHR3tpXJjDIlEYpf6zjmstbzxjRdyxx1/2ufxGxsbRxbC0LpdIQwiMoi3auWwdcL5C0bdbzh7DlDYeGwz8CywDnh38bxVCIPIAeE/tmzQcR64eZg2CxYsZPHiE/d4Plx4BJlJjSxta+W3QJpdgx1i995N+r3vH/2ERURkt7Q6SERERERE9ptUkGdTqptcFJL0fDb0dfOzNcvIRSFVsQRTYpVg4NnOFpyBrnyG/t4ccyrqqYzF6c5lCh0ZgwHixiMbBmxL9+42/MAWVyyGzpH0fHJRSMx4pfMOsMZSFUswo6KGjf3d5MIAYwy+MdQWwxucc4U5+z6vbpjPiQ3NZKMQzximlFVxfN1UhS+IiIjIkHJhyIObN3LNww/TnkoBjrwLsRZs8frEmML1S+QgwhE5h2cMxhg8IHSFMkMhC8oYg+95+LZwTVSbSFIWi/HPxy/mVXPmHcBHKyIiIiIiIiIiImPJ9PTsUjZcCEM3YFL94zIfERGRiW7u3Pn88pc3cvPNN/L739/I5s2bdlvP8zyOP/4ELrvsXRx33PGjGuOss17FMcccz5/+dCuPPbaMdevW0NvbSyaTHhSoMJSysjI++9kvcvHFl/DLX/6MBx+8n76+3iHbzJo1m5NPPpVXvvIcXvKSibPL8aRJjfz4xz/j73//G/fc8zdWrVpBa2sr6XSKcKddoPfVwoWL+OlPf8H1rzub2xIJwt2E0jvnSKVStLW1ccYZLx+zsRsbJw95fmAIg4jIQP6qFUOejyoqiaZMHVFffX29PP74Yyxf/hyrHl/GCxTCF7oH1HkLUAV4GzdAGILn7bYvERkf/uODQxgepBCYOZQ3vvHC3W62k8vluPvuv/LHP97Mn7q7Sv9b94A2YNKAurH774N8HmKxvZ67iIi8SKuE9lFLSwu9vb309vYSBME+9XXSSSeN0axERERERCaWTalu7m5Zy90ta+nOZzAYUkGe7nyG2liS6RU1xG3hA97ufIaciyizPg7IRyFr+jpYUNVA4CJ2/mgpZi09+SxT/HihwLnCCsYihyGMIiYnK9nQ30XkIqyxpS87K/zCh0yTEhXErMfm/h56gyyVfpy2TIrCPtRQE09y0cyX8A8zjiKuD6NFRERkFFa0t/PDxx5hVUcHXZkMCc8jG4ZEzpEJQwiDwhVH8RrGWkMUOSLAOIc1phjO4PCsJXKFc845cmFIGEUkfZ/FU6dx0ZFHc9SkxgP4aEXkQHO7vGsSERERERERkYOd6e7epax2mDZdAOn02E9GRERkDPzud7eM+xjxeJy3ve0S3va2S1i3bi0vvLCc1tZ2stkM1dU1NDZO5thjj6eysnKvx5g0aRJve9ulvO1tl+7TXOfPX8AXvvBloihixYrlbNiwge7uLvr7+0gmk1RWVtHcPJ3Zs+dSV1c3oj4XLz6Re+99dK/ntDf/P/J9n7POehVnnfWqUbU799zzOPfc80bVprGsnG9u2MC/WMsrysrYEIthrSWKIvL5PJlMphT+0Nw8A4Brr/3xPs9pxCEM2xXCICKDeSuHDmEI5y8YdO/rUJ555mne9Kah/7v5HLAEMPk8dstmohkzRzhTERkLsZ1CGP48gjZvfOOFg443bdrIN77xFW6//f/o7u7apX4I/C9wxYAy29+H/+TjBCeePNopi4jIbiiEYZRaWlr4wx/+wD333MPy5cvp7x+bpGhjDM8999yY9CUiIiIiciDlwpCtmV5yYUDC89mc6uG6VY/QH+So9ONMTVaBMTzb1ULoIjrzGVI9eeZU1lHhx+nKZQodGYMBYtYjF4Vsy/RhMeycE2+NxRFiAN9aAhfhm4EhCYWFi5MS5WTCPNsz/XjGgYOYsdTEkoVazmEx1MSTLG6YxjE1U0iHeRKez8yKWk5qaKbMVyqoiIiIjJxzjr+sWc11jy8jkw9IBXl8a4l5hesby45wBUPkIkLn8ItfqHvGEDhH5ArLqY0xGGPwrUfCs6SCgHixr5pEkg8vOZWTpjbvNg1dREREREREREREDm6mt2eXspph2nQDJpUal/mIiIgcbGbPnsPs2XPI5cIDPZUhWWtZtOgoFi066kBPZcLztmwGoDaK2NrfP+TO0tOnTx+zcRsbhw7E31b8aVoVwiAig3mrVw55Ppy/YMR9HXHEomHrPEshhAHAW7dWIQwi+5HZvh1v44ZBZcOFMMyePWeX/22XlZVz442/KQVL7c5vGRzCABC/9x6FMIiIjBGFMIxQX18f3/72t/mf//kfoigCKO2cKyIiIiIi0Jbp5+/b13HntlW0Z1NEzpGPQjpzGWpiSWZU1BCzhXCE7nyGXBRS7sVwQC4KWdPXwYKqBvJROGjf1sJiQ0tXPs3kREWh0LlBib8OiHA0JirYku7Fcw5jDM45DIakV3jrM728hrj12ZruIRMFVMcSdOTSRC4iwlHpJ3jjjCP5x5nHEPcGBjmIiIiIjM7Dmzfxv8uf56EtmwkjhzGFsCqAIIpwA6KlrAGcIcQRRhGetRhjsK5QywGRczjncDiCqPB7VSLJkQ2TeP+JS5haVXVAHqeITDyRvroQEREREREROeTYnl1DGKqHadMHmNTYbDIlIiIiMtHYTRsBSAOtw9Rtbh7LEIbJQ55vKf60CmEQkYGcw1s5diEMdXX1TJ7cxPbtLXus88yA373168i/7BUj7l9E9k3siWWDjluBZbuvWnLWWa/cpayhoYEzzng5d9991x7b3QW0Aw0Dx//7PfChj410uiIiMgSFMIzAtm3buOSSS9i4ceOg4IWx2lVOYQ4iIiIicrAJXURrpp9MGJD0fLZn+vjeigfpyqUp8+JMTlZigOe7WwlcRGc+Taonz9zKOsr9OF25TKEjYzBA3Hpko5Ct6T7sbq6zPWMJoghrLNYUFih6A6IaTPH/ppRVkgrzdOUyxKwlihy+tdTEk0Dh2rvCj1GfKGdmeQ3zqupJhQFl1ueImkZOmTSDqlhiPzyDIiIicqhyzvHrZ5/m5heWk80HOAflMZ8gishHEdYYIueIivEKhsLnjMYADiLAFgOlrLFELqIiFiMXhqUQh3wUMqumlg+efArHN03Ft/YAPmIREREREREREREZb6a7e5eyimHa9AMmnR6X+YiIiIgcaN7mTQBsHEHd6dNnjNm4w4Uw9FIIhrBDLIwWkcOP3d6C7esFCveF/AY4FjgCiBXrBAsWjqrPRYuOGjKE4fkBv3vr1o6qbxHZN/5jgyMX7gCGWz169tnn7Lb8jW+8cMgQhhD4C3DxgLLYIw9CJgPJ5EimKyIiQ1AIwzAymQzveMc72LBhAzA4eEHhCSIiIiJyuOnJZ3iwdSN/2bqSreleQhcVQhayaSpicWaW1RDzCm8zevMZslFAWfE4FwWs7utgQVUDuShkYNaCMYaYtXTlM0yKl+/xgyYH1MfLaM2m8KwBY0rX5QnrYzDMqahji+2hNdNPLgqp88vozmUInSPvQpJejNc3H8FbZh9HwtNbIhERERkbQRTxZMs2/vuZp3l06xZMsSxyxbCFYvjUjtAFHIQ4IufwjMEYg7ejDDDO4RxYY/GsxUYRZbEYjeUVLJ4ylfedeDIVsfgBfcwiMjFFTsEsIiIiIiIiIoca07trCEP5MG3yQNDfNy7zERERETnQ7OZC/MKGEdRtbp4+ZuMOF8IA0AJMa20dszFF5ODnrVxR+n0t8Nbi73HgKOA4YMHjyziyrp6jj34J9fUNu3aykyOOOIJ77tnzwuyVA363CmEQ2a9ijw8OYfjzcPVjMU4//WW7PXfuuW/g4x//EGFx857duZ3BIQwmkyG27BHye+hTRERGTiuOhvGDH/yA9evX7xK+UF1dzZlnnslRRx1Fc3MzFRUV+L6eThERERE5dDjn6MylyYQBcevRlUtzzQsP0JLpI2496uJleMbwQk8bmSggn4tIBwFzKuuo8ON05jLAi0FmceuRjUK2pHsxsEukp8UQuKi4CBEi57ADkxooLFpsLq8mHQb0BTni1iN0ETFrqYknCv0YQ0OinMg5mpKVTC2vIhuGlPsxjqlt4vTGWdQnhrslSURERGTkMkHAdY8v44FNG9ne349nDAnPozeXwxpDLopKwVE7QhisMUSusMOBdYWQBmsNUeRIFK9x8i7CAel8QOQcRzZO4uKjjuHU6TOIe96BfMgiIiIiIiIiIiKyH5nuXUMYKkbQLp1Oj/1kRERERCYAb9MmADooLGLO7aGeMYapU6eN2bgjDWGY3rp9zMYUkYPfwBCGJweU54Aniv/43jWFf8ADDyxj3rwFQ/Y5d+78Ic+voxDOFwO8jetHOWMR2WvO4Q8IYXDAX4ZpcvLJp1BZWbnbc/X1DSxZcir333/vHtv/ieI9aAPKYn+/WyEMIiJjQKkBQwjDkF//+telRWPOOTzP4wMf+ACXXXYZ8bh2mhMRERGRQ08mzPNI+2bu3LqKNX3thM4RRBGduTRJz2dmeS1xr/BWoj/IkQ7zlHsxAHJRwJq+duZXTSIXBRT2ey4wxhCzlu58hvpY2c4ZDMXrbgcGamJJOnMZktYDY0qLFhPWwzOW+VX1rO/voiubJu8iGuLl9OVzBC4iG4XErOXVUxfwjnmLSXp62yMiIiLjwznH822t/MdDD7KmswNjDJkgIOF5FC9fMBRCoiIgdI7QOfzi540eloCI0IHFlQIafGtJWI9UPqAmkcD3LOfMmce7X3oi1mqHexEZ2s7vtURERERERETk4Gd7evgzsBSoBWoYvHBnT9LZLH4YgkJdRURE5BBjNxdCGN4MXARsBzYU/20E1sxfwNojjiSTSROLxcZs3MbGxmHrtAB2e8uYjSkiBz9v9crS78O9l0smk8yaNWfYPufMmTvk+ZBCEMMCwNu4Ydj+RGRs2HVrsV1dpeMXgG3DtDnrrFcOef7ss88ZMoShFVgGnDSgLH7f30kNM66IiAxPq5GGsGzZMnp6ejDFRV/GGL70pS9xwQUXHOipiYiIiIiMmb58jlSYI2Y8UmGOa154gHV9HfjGoyaWxDOWNX3tpMI82ShkRW8bsyvrqPQTdOYKO6fsCC6LW49cFLI51TMogGEHz1iCKMCzFgNEzmHNwHoGg2FGeQ2ZMCATBsSLO0H7xlITT5b6aS6rxmKojSdpSJaTDyPK/Rgn1DdzxuRZTCmrGu+nTkRERA5j2/v7+eGyR3iipYW2VD8xzyOIIiLnyIQh2TAsLYTeEcTgKFz/7LgGMsZgnMEzBocjohDskI8isqHDWsPs2lreuPBIzp49p3TNJSIiIiIiIiIiIocX09PN3cC/j7JdP1CTTsMedlMUEREROVh5mzaWfrfAlOK/k4tlqXPPo/9fvjDm49bU1BKPx8nlcnus0wKFxZe5HGjjTxEB/JUrSr8/O0zdRYuOxPeHX+43d+68YeuspBDCYNvaoL8fKiqGbSMi+8Z/5qlBx3uOTnjRcCEMr3rVq/nSlz4/ZJ3bGBzC4D/2qP53LyIyBhTCMIQNG15M+jLGcNxxxymAQUREREQOCUEU8VTXNpZuXcXTXS2ELiJyER25NJ6xzK6oI+EV3i5kwjz9QY4yL4YB8lHImt4O5lc1kIuCQVELxhhi1tKbz1AXL8MNsQdrVSxBTz5LwnpQDD6DQpBDzHrMr2pgXX8nvbksgYuYlCgnHeQJXEQqDPCM4awpc7li/kmU+WOXVi4iIiIynKe2beObD95PZyZDLgzwjCXheaSjCGOKoQrOERavb3aETlkgohDEYChcO1kMnrGU+T6ZIMAZR5nv41vLW19yHBcuOpKYdqkTERERERERERE5rJmeHrr3ol0KqE2lcAphEBERkUNJFGG3bB6yStg8fVyGNsYwaVIjW4YYv6X407a1Ek1rHpd5iMjBxVu9qvT78mHqHnnk0SPqc/r0GcRiMfL5/B7rrBrwu7dpI+ERi0bUt4jsvdhTTw46Hi6Eoba2lqOPPmbIOkceeRRTp05j69Yte6xzOzAwpsHk88QefpD8MAEPIiIyNIUwDKGjowMo7D5njOHss88+wDMSEREREdk72TCgP8hhjSWKIn6w8kGe7mrBYKiOJYlZy8b+bvqCHJ4xvNDbyuyKOqpjSbryGRwvLh6MWY9cFLIx1Y1v7C5jWWOJKCxANLx4Pb2Do7DocEZFDat62slGIQnrETqHZww1sSRQCGOYU1HHRtNNuRenJp4gdI4qP8lZU5p5+eTZzKqo1Y7QIiIist+80N7GLS+8wB1r15AO8ngYslEIQOiiXcKpPCB0jjCK8KwthC64QkyVA6IoKvzuCsEMkXNUJ5PMqKrm3SecyHFNU/b/gxSRg55D75FEREREREREDjWmp4euvWjXD5hU/xDR+SIiIiIHH9u6HTPEomOAaPr4hDAANDZOHlkIw/YWhTCICKRS2I2FTYIDYMUw1RcuHFlQgu/7zJw5i9WrV+2xzsoBv3sb1yuEQWQ/8J96YtDxcCEMJ598Ctbuej/+QMYYXvWqV/OLX/xsj3UeBtqASQPK4vfeoxAGEZF9pBCGIcRig3fTnT6Ob8RFRERERMaac44VPW38bfsaHmzbSD4KcQ46cyki55hVUU+5X7jmDVxIb5Ah6flYDPkoZE1fB/MqG8iFwaB+jTHErEd/kKMuntztDTuFJT+OyliC3nyWhPXBFOYEhrj1SFif+VUNrO3vpD+fI3SOhkQ5uSgkHebpC3IY4PTGWbxv4RIqY4nxfcJEREREhnD3+nVc99gy+nM5cmFIeSxG5By5fCF8YUeIAhQCFowxWGMK5YAtBlNZWwjFKvdj5KOQbBhiDGTDkOpEkncvPoEzZ82hMh4/kA9XREREREREREREJoogwPb30b0XTVOASafHekYiIiIiB5TdtHHYOuG08QxhaBzyfCmEoXX7uM1BRA4e3prVmOL9JGuBoSNkYMGCBSPue+7ceSMOYbAbh/9vp4jsI+fwn36ydLgVWD1Mk5NPPnVEXZ999jlDhjA44K/AmweUxe69e0R9i4jInimEYQg7vzkOgmAPNUVEREREDrwgCukL8hjAN5afr3mMe1rX4Zyjyk9QHouzPd1Ldz6LZwwre1uZUV5LfaKcrlyG0DkSxgMDcc8nFwZsSHVR6cV2GcuaHTELlBYd7ih7kWFmeQ0retvJRgEJ6xM5h2cMNfEyABKez7zKejb0d+NbS1UsQTYKiFmPs6bM4cymeSysasDs0reIiIjI+Pv/7N13fBx3nf/x1/c7s03dKpZtWXKTSxzb6b0SQhICIVwgcBzcBXIJHD3H5UfoBxxwB0eouQMSuBByBEJISIOQI70RQprtOO69SLJs9e0z3+/vj12tJdvalWytZEuf5+Ox7M7MZ2Y+WkAe7c73/bXWsq5jL79bvZqHN27EYvGtxbcGACd7iaIgd72S2W5xs8taKfxsEEP/l+pKKRytsdk4q9qSUmZXVfHPp57OjIqKMf0ZhRATj7Hy95MQQgghhBBCCDGRqN4eALoOYd8ooGLR0WxHCCGEEGLcOcMIYTBFnICzrm5q3u2t2Wfd3l60HoQQRw93474ohDXDqJ8/f+Gwjz137ry82wfGMzjbtw37uEKIQ6NbdqH37MktPzuMfU499fRhHfvcc8/Ddd2841sfZXAIg7v8VVRPN7aicljnEEIIcSAJYcjjmGOOAfbdQL17tyQRCiGEEEKII8+OaDdP7d7Mk7s3E/NSWKArlSBtfGZGKqkIhgEw1tCVThDUDq7SeNawNdaJUpA2fuZgA8bqBLRD0veIHCSEob/UWEt5IERPOklIu4P2D2qHkBOgubyGzX0dxL00vrVUhyJYa4l6KXq9JNbCyTUNfHzhGVQFw3jW4CotwQtCCCGEGFeeMdz52ms8vGkDbX19WCyRQIBoKoUCUsbHZkMVGBC4YGwmWqE/pKp/XUBrrLV4xoBSJH0PzximlZbxniVLecPsOVSFw+P28wohhBBCCCGEEEIIIY5MqrsbgO5D2DcGqHh8VPsRQgghhBhvelv+gcSmohJbWVW08xcKYWjLPuvdbXnrhBCTg7N+Xe716gK1oVCIpqZZwz727Nlz827fAqSBAKAlhEGIonNXrhi0XCiEIRgMcvzxJwzr2OXlFZx00in85S9/HrLm0f2WlTEE/vwcqYvfPKxzCCGEOJCEMOQxb948Zs2axbbsH+nPP/8811xzzTh3JYQQQgghJjNjLTEvhWctEcflwZ1r+N32VXjGUOIGKXfDdKfjdKXiKKXY2NfB9Eg59eEyer0kKePnwhICyiFtfLZHu6kORQ44V242Z+Oj1L6BhPubWVLJ+t69JI1HSLv4GBQwJZg5ZsQJsKC8li3RTixQGYjQ66VwleLUmkYumDaXYyvrcbUGMn0JIYQQQoyn7d3d/OCFv/BqaytKQdzzCGSvVSyZ6yStFBaFZw2+tbjZ6yRHKTxrMdmABpWtd7UmoDXxdJqyYAhXaxbX1fHZs8+hPBgap59UCDERWSuBdkIIIYQQQgghxESie3sA6DqEfaOAikVHsx0hhBBCiHHnbN+ad7tpbCrq+evq6vJu749eUO0yCagQApwN63Ov1xSonTu3GccZ/j20c+fOy7vdBzYDCyj8u1MIcfjcFa8OWn6mQP3xx59IeAST9pxzznl5Qxg2AluBgVEugWeekhAGIYQ4DBLCUMB73/tevvGNbwDwl7/8he3bt9PY2DjOXQkhhBBCiMmmIxnjz3u28afWDXQkYxgsfekUUS/NtHAZ08Ll2dAES1c0gas0QcfFM4Zd8cxNOY7ODsQZMB7HVZqU8UkZP7PCDt6ulSJtLZWBMF2pRC7Aob80pF3CToDm8mo29XWS8NL4WKoCYRyliftpetIJfGtZUlXPdYvOpioYJmV8wo5LQEvgghBCCCGOHN3JBLe+8gp/3rGd1r4ojlYYY/GNwVhLyvcHXSspBY5V+FiMMWitMwEN1uYCrQxgrcU3Ft94WKWoKS3hojnzuHLxsQRH8OW5EEIIIYQQQgghhBBi8lHd3QB0H8K+MUDF46PajxBCCCHEeCs0m7tf9BCGqXm3dwMJQEsIgxCCwSEMqwvUzp+/YETHLhTCALCBbAjDtvy/O4UQh89duTz3Ogq8UqD+tNPOGNHxzz33fL797f/IW/MocPWA5eAzTyHxnEIIcegkhKGAv/3bv+Wuu+5iw4YNeJ7Hl7/8ZW655RZ0duY7IYQQQgghRpu1lpifJm18wk6AVzp2ccvGvxL1koR1gFI3RMJPszcZBRTbYl1EvRSNJVUkTZqol8qFG7hag4GWeA9Tw6UHnEsphVKKhO+hlcLH4LD/ta6loaSCmJcmaTxC2sWQmdl5SjACQMQJsrC8li3RLlLGozwQojMVx1GKYyqmcuH0Zk6snkHIyfwJ0v8shBBCCHGk2NLZyb8/+wwtvb2kjY9SEHZdkp6HAhylMNZibOY6SNF/LQXYTNiCyoYvKKXQSlEaCJD0fTzfEHZdLJYL58zl2hNPojI0/BRzIYQYCTMwLUYIIYQQQgghhBBHPdXTgw/0HsK+UYBYbHQbEkIIIYQYZ06hEIam8Q1hANgNTNstIQxCTHrW4mZDGCywpkB5c/P8ER2+oWEmgUCAdDo9ZE1/BITe0575+7CkZETnEEIMn7tiXwjDy4BfoP60004f0fFPPPFkSkpKiOX5rGf/EAZ31UpUx15sdc2IziWEECJDRj4VEAwG+d73vsd73/teuru7ee6557jhhhv42te+RigUGu/2hBBCCCHEBBLzUvx17w7+1LqBbdEuDJaE59GdTlAVDDMjXJELA2tP9KGVzgQiWMOeVBSLpSoQxkJu5mXIBDEkfUPM8zIrLINmcNYo0sanKhBmbyqOo3Vuu7GWkHYJ6QDzymvY1NdB0vfwraHUCRLSLknfoyedJG195pVXc93CM6kOl5DyfcKOS6kbHNSPEEIIIcSRZGt3Fw+tX88D69bSm0rhKEXK97FkroW0UpC9ltFKgQWfTBiDkw1ccKzFkAliwNrMA4UFfGMoCwapLyvj3YuP5eJ5zXJtJIQQQgghhBBCCCGEGDbV003PIe4bA1RM5jsUQgghxARibcEQBtNY3BCGqVPrh9wWAaYBfYBulxAGISY73bIr9zfZbqCrQP2CBQtHdHzXdZk1azYbNqwfsmbgFmfHdvwRnkMIMTxqzx6cXTtzyy8MY5+TTz51ROcIBoOcfvqZPPbYI0PWPMYBQwUIPPsMqcsuH9G5hBBCZEgIwzDMmzePW2+9lQ996EPs3r2bBx98kFWrVvGxj32Miy++GMdxxrtFIYQQQghxFIp7aeJ+mqB2aEv08YO1z9Ga6MNVmopACGstO2LdeMaQSvjEvDRzyqrRStGRiuGqTCCDVpogio5UPLduf47SxPwUrlJ41gyqU2QGDE6PlBP1UyR9j5DOzNQMUB3KpN5GnAALy2vZFusm6qUoD4bYm47hKEVjaSVvmj6f02obKXWDmQMHivbWCSGEEEKMipdadvFff32BrkSCmOcRcV1QipQxaDIhDJ4xALmgK60UJhu6oK1FKYXSGoyhxHUz126+DwoSnkfQcbjimGN4S/MCppeXj+ePK4QQQgghhBBCCCGEOArpnm72HuK+UUDF4qPZjhBCCCHEuFJ79qDi+a9v/MZZRe2hoaGBT33q/zFj7Rpm/f4B6skEL0wDytg36NFICIMQk56zfl3u9eph1M+fv2DE55g7d17eEIYNA17rHdskhEGIInFXLh+8DMwBNg9RP2fOXKqra0Z8nnPOOT9vCEMr8Dpw7IB1wWefkhAGIYQ4RBLCMEzHHHMM99xzD1/4whd44okn2LRpE//yL//Cl770JY477jhmzZpFRUUFrnvob+nHPvaxUexYCCGEEEIciTxjWNHVymOtG1jZ1YaPwTOGjmSMsOPSVDKFQDbka08yirVQ4gSxWHq9FBv7OpgZqcC3lpDeF6SglUJZ6EknsdZiswMCB273jKEmVEJ7MoZrde7bHoMloB1CToB5ZTVs6usg4XuZczgO5W6ItPHpTSdJGI/pkXI+vvB06iPlJH2fkONQEyyRGZ2FEEIIcdTY0tXFA+vWcu/aNfjGYIzBsxZcNxdWpSB3feNbi28tbnZZo/CxGAsqG1yllMLRGq0ya6rDEWpKSvjEqaexNM9MKEIIMdos8reZEEIIIYQQQggxkaieHroPcd8Y5GZdFUIIIYSYCJxtWwrW+I1NRe2hrKycz3zmi4Tu/g0Vv39gyDrd1QXJJIRCRe1HCHHkcgaEI6wZRv28efNHfI45c+bm3b5lYD/btpEe8RmEEMOxfwjDJ7OPduCvwAtK8ez5F/DKilfZu3cvJ5xw0iGd59xzzytY8yiDQxgCzzx1SOcSQgghIQwjUlNTw2WXXcbKlSvp6OjAWktfXx/PPfcczz333GEfX0IYhBBCCCEmnqTv0eelUIBvDT9e/wKruttQKCoCIVyt2dC7l6iXJmF84r3tzCmrptQNsicRzQz8U6BQhLRD1EuxJ3nwm2Rc5ZAwHiHHJW0NQeXktikyszfXhEqI+mniXpqQdrBkZniuCZYAEHYCLKyoY0esm65UnAo3RHuyD60UdaFS3jR9PmfWNVEdKin6eyeEEEIIMdqMtdy7ZjX3rV3L7mgU3xjCjkPcWpS1pHyfpPUyxf2BC0phrcVk99dKoZXCWEtAawwW3xgAUr6PZwwVwRBvmb+AS5qbaSivGKefVgghhBBCCCGEEEIIMRGo7m66DnHfKBScKVoIIYQQ4mjibN8GQAo4AWgEmvZ7lFrD9GSSUJHDD8wwwvj1nnZMw8yi9iGEOHK5G9blXq8uUNvY2ERJycjvzW1qmpV3+xbAAJp9v0OFEKPPXbH8oOvrgEuBixYuovPO32GtZdu2rfi+d0jnOfbYpVRXV9PR0TFkzaPAJwb2tm4tqq0NWy8TCQkhxEhJCMMwrVmzhs985jOsXbs2t65/Jjxr7WEfX2YNFkIIIYSYOKy1bOzr4Mm2zTy3ZytJ38Ng2ZuMgYVZpVMoDQQBiHopEr5HiRsAIGV8Nvbupbm8hqTxcAZcJyqlcJWiO51AWfAtOAMuI7VSYKEiEGJPMoa1Nned2T9gMKQDzCurZlNfBzEvjbEGRzlMCUbwraEvnSLmp6gMhLn+mHOYV15D3E8TchzqQqW4el+wgxBCCCHE0aS1r4//+usL/GXnDpRSxNJpAlqjtMaSudbSSmGVwjMG31rcAUEMxlpM9nNARSYky9GaiNYkfJ+I6+JqzYzycj539jk0VVaN288qhJjcRuErCyGEEEIIIYQQQhxBVG8P3Ye4bwxQsYOH/AshhBBCHI30tswA4p3A69nHAS48F4B77/0DZ555dtF6MXVTC9bo9t0SwiDEJOasX597vaZA7fz5Cw7pHI2N+UMYkkArMAPQ27ce0jmEEIW5Kw8ewtDPW3ockLlHbdas2Yd8Hq01Z511Lg88cO+QNU8AHoMHDgeffYrkFVce8nmFEGKykhCGYXj++ef58Ic/TCKRyAUuqP0Gwx2O0QhxEEIIIYQQ4ydtfLpTCTxriDgu9+54nYdb1mOspcwNURmM0Brroc9L4SjNur49NEQqqAuV0pGKAfuuKYPaIWV8tkW7BoUo9HOUJmV8wq5Lwvdw1IGX9OWBEEnj05NOEtIOSik8a6gOleBqDWgWlNfSEu+lPRml1AmyNxVFo6gIhHn7jGM5d+psZpTIrM1CCCGEOPr1pVL8YvmrPL19G7t6enC0xlqLbwy+MaR8n4FXXApwlMK3FmMMWutMQIO1uToDuWMks3XloRBnzWzk/cefQEWRZ1QRQgghhBBCCCGEEEJMHrq7m65D3DcKqHh8FLsRQgghhBhf/bO4D2cu92nTphW1FzN1GCEMu9uK2oMQ4sjmbCx+CENTU/4QBoAtZEIY+n+HCiFGl+rpxt28KW+Nt+y4UTvfOeeclzeEoQd4CThtwLrAs09LCIMQQhwCCWEooK2tjY9//OPE43GUUrlBcBKcIIQQQgghdif6eLZ9K4+0bqArlcBi6UolSBmPaeFypobLUEphrKHLSxDSmdmRPWPYEcvMVZLwvQMCvgLaIeancZTGWIszYFRgf22JEyDhexgsmsHXqEHtMqdsClv6OulJJzPrFVQHIlhrifppetMJAtrhukVncWrNTKJ+mqB2mBouJewExugdFEIIIYQoru3d3fz7s0+zo6cH3xiUUoRdNxO8YAyOUhhr8fuDV8lcbw0MW1DZYCylFFopSgMBUr5PyvcJuS7GWk6Z3sAnTzuNGRUSYiWEGH/GHl5wtBBCCCGEEEIIIY4sqqeH7kPYL0LmBlEVi41yR0IIIYQQ48fJzuI+nGHE06c3FLUXWzUF67oozxuyRre3F7UHIcQRLBrF2bkDgD4K/95qbi5eCMNm4EzA2SYhDEIUg/vayoI13tLRC2E499zzCtY8xuAQhuDTT47a+YUQYjKREIYCvvOd79Db2zsofEEpxXnnncdFF13E4sWLmTFjBqWlpbiuvJ1CCCGEEBOVtZa9yRhxP03IcVnT086tG18i5qUpcQNUBSP0pZP0ppMoYHusm950iqbSKnq9BJ4xhHTmetHVGoxlV7yHsOMccC6dvfYMKE3CeGCB/cbQhByXmlAJexIxgo6DRpG2hogToMQJoJRiXlkN7ck+dsV7CWqXXi9Bn5+kxAnyxmnNnF8/h/kVtUV+54QQQgghxt727m4e2rCe+9euoSeVwkGRMj6WzHWdVjp3edV/7eVbmw3AygQuOICxFgNgLVhLfyyrAUoCQepLS7l4XjPvPnZJ5hpPCCGEEEIIIYQQQgghRpnq7aZrGHWbgNLsIwL0f2KZjEWL1JkQQgghxNjT2VncCw0jrq2tIxKJFLkZjamtw2ltGbqkfXdxexBCHLHcTRtyr9cNo37BgoWHdJ6ysjJqamrYu3fvkDWbs8+6fTfE41Ds349CTDLuilcL1nhLlo7a+ebMmUdDw0x2ZoNeDuYx4LMDlp0tm9Hbt2Eam0atDyGEmAwkNSCPnp4eHnrooUEBDLW1tfzwhz/khBNOGOfuhBBCCCHEWIh6KZ5p28r/taxnW7QLYy0JP01nKk5VMMLMkkoCOhOk0JVOoJUi5GRmRO5MxzFRS6kbyBxsQJCCqx2SvodnLNbaA87bP9OyVgrfGhyVuUWmvzagHerDZWBhbyqGzQ4KrA2WAJDw03SlE2Dh3bOW8ZaGhSR8D0dpasMlVATCxXvThBBCCCHG0Sstu7jphRfoSiSIeR4R10UpRSpl0GTCFtImMxOJYt91V3/ggs6GsPavi7guvjGkfB+lFHHPQynFG+fO5e0LFzG/ujr3+aEQQhwJrJXfSUIIIYQQQgghxESiurvpLlBzIjBnqP3j8VHuSAghhBBinFiLM8wQhpkzZxa/H8BMrc8bwqB2t41JH0KII4+zfl/0wuph1Dc3LzjkczU2NuUNYdgysK+dO/Cb5x/yuYQQB3JXLM+73ZszF1tROWrnU0pxzjnn8etf/3LImmeABDBwxEDwicdI/P37R60PIYSYDCSEIY9XXnmFVCqFUgprLY7jcPPNN7N48eLxbk0IIYQQQhRJRzJGLJlGK0XCS/PjdS+wtbeTgHaoCoRBwevdvfjW0pGKE/VSzC6rJqg13el4LpBBK0VQO/SkE8CBIQv9NZ41mWAFa2G/wXtaKaZHytkZ6wELjtIYa9FKUREIo5WmqayK8mSQHbEeAJLGoyXRQ1A7nFzdwBumzeP4KdNzMzwLIYQQQhytoj1x+rrjhEuDVEwpHRR8YK1lS1cXD6xby/1r1+Ibg28NvrXgurlAq/7QBciEMfjW4maXM+FXmXV6QK2jNQGtscCUSITSQIAPnngS586aPaY/vxBCCCGEEEIIIYQQYnLSvT10FaipyrNNxaKj14wQQgghxDhS7e2oRAIoHMLQ0NBY/IYAU1eXd7tubx+TPoQQR56BIQxrCtROmTKF2traQz5XU9NsXn31lSG3bx7wWm/bKiEMQowy97UVebd7y44f9XOeffa5eUMYEsDzwPkD1gUfe0RCGIQQYoQkhCGPrVu35l4rpXjDG94gAQxCCCGEEBOQbw0ru1p5rG0jr3buIm0NvjHsSUZxlUNjSRXlbgilFHuT0cyMyE4AiyVlfDb17qWhpAJjGRR2oJVCKUXUS2WDFsiM5huw3TeWkOOSMj5BZ9/lubWWgHaoD5dhrKU13kva+hgsdaFSAkqTNj6dqTieNbyhfi7vmX0cnjUoFNXBCLXh0jF8F4UQQgghRt/e3T18+59/yc7NewatD4UDnPXmpVxxzfmUVka4e/Xr/H7dOnZHo/jGEHYcYn4m6Crl+Vg8AKxSKDLXYdZaDORCrrRSGGsJOg4mG8ZgrSXt+3jGEAkEOLdpFm+Zv4AFNTVj/2YIIcQwmfFuQAghhBBCCCGEEKPHWlR3N90FyqrybFPx+Cg2JIQQQggxfpzt+8Z3bC9Q29DQUNxmsmzd1LzbdfvuMelDCHHkcTauz70uFMLQ3Lxg0GQkI9XUNCvv9oEhDM72baQP+UxCiAPEYjjr1uYt8ZYuG/XTnnPOeQVrHmVwCEPg6SfB88CVIcVCCDFc8hszj2g0kwBtrUUpxemnnz7OHQkhhBBCiNEQ9VK0xntJGR9XaR5uWceze7aigMpAmEggwJbeDtLGYJRlY98e6kPlTI9UsCcZy+QoKFAogtohaXzaEn1g7QHnCihNyvgolQl76J+FOXsIUNAQqWBrrIu08QloJxPYAFQHSwDF9EgF5W6QrdEuUtZHK01LogdHaZrLa3jTtPmcWjOTkCOX90IIIYSYGDa8tp1vXvdLkrFUJshqP8lEmsd+9zJ/euI1yv9+PpvSfThKEUunCWiN0hr8TLBqJnABPGtR2cAFIBe6YLLXXopMvaM1Ea1J+D4hxyGgNTUlJXz6zLNZXGAWEyGEEEIIIYQQQgghhBhViQQqnaarQFllnm0qFhvFhoQQQgghxo+zfRuQ+Qp5a/5SGhoai94PgJlan3e73t02Jn0IIY487vp9IQyrC9QuWLDwsM7V2NiUd/s2wCMziLD/d6kQYnS4r7+GMvmny/CWHjfq550+fQbNzfPZsGH9kDWPAv82YFn3dOO+9CLeaTJGVgghhktGaeURiUQGLdfW1o5TJ0IIIYQQYjRsj3bx5O5NPLl7M73pJBZLZypO0vhMD5dTFy7D1RrP+HSlE4QdF0cpPGNoTfaCgqTxBgcpqEwQQ9zPzK5ssGjUoO0ApW6IPi+FYzX9m421OEpRFYyglGJrtJOk72GsJey4VARC+NbQlUqQ8NMsrqznmuaTCTkuvrGUBYI0RCoOK/1WCCGEEOJI8tCvn+e3P3mcdCJ/5r4fUnQcX0Z0Zgivew/BgIvWmes2zxhSxmAHpDcopXAs+FiMsWitMgEN1qKyF2eGTBirMYaUzdSVRYKcNH061554MrUlJcX80YUQQgghhBBCCCGEEOIAqqcHgO4CdVX5jhGLjlY7QgghhBDjSm/LDBzuBvoK1M6cObPo/QCYAkH+ur19TPoQQhxhjMHZtAHIhB8MPUQ6o7l5wWGdbtasWXm3+8BOYBagtxeKsRFCjIS7YnnBmmKEMACcc855B4QwzALeCFyQfewv+PifJIRBCCFGQEIY8mhoaBi0HJNEaCGEEEKIo4ZnDFuiHZngA6XZFu3irm0rSBiPMjfI9Eg5PekErfFelFK0JHrpSseZW1ZNr5fCWEtAZwbk9Ycu7E70AgqNHnQurTJD9xyVCXAIOgdeZk8JRvCMT9J4hLQLCnxrqQ+VorJBDBHHZXu0m24vSYkToCXRg0IxPVLOm6Yv46zaWVQGw8V+64QQQgghxlQ6leZHX7mPP/9pFdZkgxMGhkxZO6g+Ue3SflYVXqnGKlAWTNzDLQ+hjMFRCmMt/TEMikwIg1KAzYRmKdu/TqGVoiQQIOX7pHyfgOPgW8uy+qlcd9rpzJ0yRUKvhBBHFYv8zhJCCCGEEEIIISYK3ZOJX+gqUFeZZ5uS+x6FEEIIMUH0z94+nDncGxrGKoRhat7tursLkkkIhcakHyHEkUHv3IGKxwHYDKQK1M+fP/+wztfUNDv3ujYUYnYyyRxgDjA7+9w/LbGzffthnUsIMZj72oq82/2GmdgiTQx+9tnn8cAD93HOOedyzjnnc/ZZ53DClZfjbhs6bCX4+KPEPvPFovQjhBATkYQw5LFkyRJg3+zFO3bsGM92hBBCCCHEMPR5KZ7ZvZk/ta5nV7wXgJiXoiMVo8wN0VBSQbkbQinFnmQMpRQhx8VaS8L32NjXQbmb+cJj4LAVR2nS1qCsxVcW5yDnDjoucT+NtTZ3DWmzgwZLnADzymvY1NdBwvewZGZdnhKMYKyl10sS9ZLUhkv59NxzmV5SQdr4RJwAM0sqcbU+yBmFEEIIIY5eu3d18t1P38nmtW0HBC0Mkr2uSk5x6J5fQl9zBBPQYCy4mW2eAuV5uV20UmDBw2KsxckGLjjWYgALGGvB7gtqsEBJIEB9aSnnz57DPyw7joBzsKs+IYQQQgghhBBCCCGEGBsqG8LQXaCuKt8x4nHwfZDPO4UQQogJ7etf/zIPPfRgbvmuu+5n+vQZ49jR6HOys7cPZw73sQhhWLt2Da07dtAHtAJt+z1fDVwP6PbdmJmNRe9HCHHkcNavy71eM4z6+fMXHtb5Zs2azRNP/Jmmpiam/vcPKf32fwxZq7cPJ8pGCDFc7orludd7AAMMjGjyli4r2rkvvfStvPWtbxs0wVD6ggtxf/6zIfdxX30FtXcvtqamaH0JIcREIiEMeUyfPp0lS5awatUqAJ566ik+8YlPjHNXQgghhBBioJ2xbnbGe/CNIWk8/rBrLVujnYSdAFPDpSgUr3e3oZUm7qfZ2LuX+nA5NcEIPV6SgM7caKKUIqgdEr435JyhLgoPgzUGlMP+hUHtEHJcOlNxQtpBKUXaGsKOS6kbRCnFgopa2uK9tCWilDgButIJVDpBRSDM22cey3lT5zCjpKK4b5oQQgghxDh6+anV/PQ/fk9fV3zY+/TOCtF5QjnGBesqVNqAys72bgENad+idGZRKYVWCpUNWegPydJaY40h4rp4xpDyfZRSxLMBDmc3NnHFMYs5tq5u0JdTQghxNLFWfn8JIYQQ4tBZa9m9ezfRaJR4PI7v+4TDYSKRCDU1NZSUlIx3i0IIIcSkorq7sUBXgbrKQseJRbHl8j20EEIIIY5u/QOHtxSoC4VC1NVNLVB1+K677iO89NKLQ27flH3Wba0SwiDEJONuXJ97XSiEIRQK0dQ067DOFwgEWLz4WAD8Asdy2lohkYBw+LDOKYQAUinc1atyiz8BvgDMAE7MPo4JR1i4YzsNDTNH/X405yCBm6kL3kQkTwiDspbgk4+RvOLKUe1FCCEmKglhKODqq6/mU5/6FACrVq3i+eef5/TTTx/nroQQQgghJjdrLa907uKR1vWs6GrFWIvB0pbowzeG6ZFyygMhHKXpSsVJGZ+wdkApfGtoTfTiWR9rbWaW5CylFK7SxPw0ypKbFbmfVhqFRaPxrI+rBn9wEXZcpkfKUUBnKo7NDvqrDWduZol6KXrSCQLa5dp5p3LW1CZSxiegHaaHy4m4gaK/d0IIIYQQ48HzPO7870d59O6X8NL+sPaxQLIuQNcxJURnh7GQuTjToKwCYwcXY7EofGtxs9d4DgofiyHzBZIic83naI2rM4kNlZEwJYEAVx9/AhfOnTeaP7YQQgghhBBCHNF6enp48cUXWblyJStXrmTLli20trbi+0P/3VZRUcHMmTNZtGgRS5cu5bjjjuOYY44Zw66FEEKIyUX39pAA0gXqqgpsV1EJYRBCCDG+Wlp2ceWVbyv6eT7wgWv5x3/8UNHPI8aBtTjDDGGYObMRrXXRWyoU9NCafdZtbUXvRQhxZHHWr8u9Xl2gdu7c5oMOpD5Uwwl9cXbtwJ/bPGrnFGKycteuRqX3fWrzSvZ5V/bxIMC9d8O9dzNlyhTe9rYr+M///G5Re0qffQ7WdVHZSYkOJvjYIxLCIIQQwyQhDAVceuml3HfffTz55JMAfPGLX+TOO++kurp6nDsTQgghhJg8+rwUq7pa6fVSOChWdrfyfPtWUIqqYISw49Ia78U3BldpWhO9dKYSzC2rpiOVnWG5fyCe0lgFe5IxjLUHnMtRCi8bwGCsxdkvcVKhmB4pZ2e8B4zB1Tp3nKpgBK00s0unUBkIsT3Wg1KQMh4tiV7Cjst5U+dwfv1cFlXI7MpCCCGEmPg62rq5+ev38/pLW+Eg115DMQ50nFBOtDGEX5K5OUZ7FhNQYBXWBez+12mZhyET2qWUQiuFsZag0vjW4luDBVK+j2cMETfAGTMbedvChRxTWzdaP7YQQowrM/xft0IIIYSYhHbs2MHvf/97nnjiCVauXDkocMEO4++27u5uuru7ef3117nnnnsAqKmp4ZxzzuGNb3wj559/Pq4rt6IIIYQQo0V1d9M1jLrKQseJ9o1CN0IIIcTk9LOf/YRbb70lt/yDH/yYE088eRw7mpxUezsqkQAKhzA0NjYVvR+Aurr6vNv7oxd0W2veOiHExONs3JB7vaZA7fz5C0b13P4wfgfqbdskhEGIUeCuWD5o+eU8tZ2dnSSTieI2BNiyctKnnUHw2aeHrAk+/igYA2MQWiWEEEc7+eZ7GG688Ub+4R/+gddff50dO3Zw1VVX8d3vfpfmZrngFEIIIYQopvZEH39sWcdTuzfT6yXRKHrSSTpTcUrdANMi5YS0g7WWPckortYEtINrNSnjsalvLzo7+G4gRyk8YzHWYrBo9m1XSqFQRFyXuO8RdvZdMvvW4ChNXbgUR2t2xLpJeGkMlopAiLB2SfoeXak4Bssbp83j72Ydh49FK0V1sISqYHjM3j8hhBBCiPHy6nPruf07D9He0g3911r912R5BvVYIFEXYM9p5aSmBMC32IBGedl91IDCgyz3hy741uLkShSu1kS0Ju55RFwXx9FURyL8yxlnsqx+2qj8zEIIIYQQQghxpEqlUjz44IPcc889vPzyy7mwhf1DF0YSHDxw3z179nDvvfdy7733UllZyVve8hbe9a53sXDhwtH5AYQQQohJTHV30z2MuqpCx4lGR6EbIYQQQojx42zbknu9ZciqjMbGWcVsJaeuLn/Qf3/0goQwCDH5OOvX5V7fCqwCVpMJZFgNrHEDRL00MPohDGZGA1ZrlDFD97djO+lRPasQk5O7/JXc605gc4H6pUuXFbWffqk3vDFvCINu3427cjnecSeMST9CCHE0kxCGYSgrK+P222/nhhtu4JFHHmH9+vW84x3v4PLLL+ed73wnS5YsQUvyjxBCCCHEYfGtYXX3brbFukgZn2g6xZO7N9OdjlMRCDM9XI5vDW2JXkLaIW18tkW76EsnmRIsIWV8Qjoz1E4pRVA7JI2PggNCGJRSaK2xxpA2PiFn8GWxAqqCEWwqTtL3COnMdh9LXagErTS1oVJKnADbYl3EvTQRJ8juZB+u1iyumsqF05o5qbqBgHYQQgghhJgMrLXcd+tT/OGO50nE+7+qPcgAniHCGFKVLh0nlpGoC+BHNPiAq0CBDSisPcixDKABC9pRmUAta3GUwmZWY63FNyb7GspCIY6vn8YHTz6Z2pKS0frxhRDiiGEP9rtXCCGEEJNSR0cHd9xxB7/61a/o6OgA9oUnKKUOCF3YP5RhKPn27erq4o477uCOO+7gzDPP5P3vfz/nnHPO4f4oQgghxKSlu7voGkZdZYHtqq9vFLoRQgghDl11dQ3f/e5/Dav2r399njvuuD23PG/efD72seuGte+MGQ2H0p44Cjhbt+RebxmyKqOpqfAs8KNh6tT6vNvbss96d1veOiHExKJ6e3BaW3LLC7OPgXq+9R02X3Ah69atZebMxtFtIBDATJ+Bs3PHkCV6+9bRPacQk5S7cnnu9avDqF+69PhitTJI6g0Xwte+nLcm+PBDEsIghBDDICEMBfzDP/zDoOVgMEg6nSaZTHLXXXdx1113EQ6HaWhooKKiAtc9tLdUKcVtt902Gi0LIYQQQhxVrLU8sXsTD+1ay/ZYFwpF2hp2J/rwraE6GKEyEEYpRUcyjm9tJhRBgbGWvak4qf601gE3fSqlcJUi6fs4Sh0QhqBR2Gy9sTYX1GCtxQKlbpCaUAmbejuIeWksmZrKQJi08elJJ0kaj7ll1Xyo+VSqghF8ayhzQ9SGSkY0Y5gQQgghxNGstyfGT792H68+t2nYA3aAzLVb9tqrd06YzhPL8F2VCV4woIzNXa/Rf9j+S6yBp7GZ9f3XX1opHK0Juy5J38fzfQKOg28tx02r52OnnkZzdbVcrwkhhBBCCCEmrL6+Pm655RZuv/124vH4QYMX9v/7rbKykhkzZlBfX8/UqVMJh8OEw2EcxyGRSJBMJunu7qa1tZW2tjZaWlrwfT+3/8C/sfqP/dxzz/Hcc8+xbNkyrrvuOs4444xi/+hCCCHEhKO6uugeRt0PgDAQBWLZ5/7XnwNOjkoIgxBCiPEVCoU45ZTThlXb3r570HJ5efmw9xUTl7MlM7d0D9BRoLaxcWxCGOrqpubdHgX6gEBb65j0I4Q4MjgbNxSs8ecvZMaMhqKFB5mZjXlDGJzt24tyXiEmFc/DXfVabvHlAuVKKZYsWVLcnrL8JUvxp9bj5AmCCj78ELFPf25M+hFCiKOZhDAU8MILLxz0hmylVO7GgXg8zoYNGw75xm1rrdz0LYQQQohJY3eijxc7dtCZytz4uaq7jfV9eylxAtSFynC1ZlesB4CIdulJJ+nzUswqraIzFc9cN2UvnbRSBLSmJ5046LkcpVHKYLAHveYKKE1VMMLuZJSgdtBK4VlD0HGoDIbQSrOoso6dsR7aE1FKnSC96RRapZkWKeNN0+ZzRm0TlcFwUd8zIYQQQogj0cZVO7j1m79n26b2waEIw2SB6KwwPfPCxBtCWA0YMiEM2WCFg+6kOTCEwVEYAGszwQ42Mw+8tZayUIjaSAkXzpvL3y1dhqv1yJsVQoijiLHyfYMQQggxWfm+z+23386PfvQjenp6BoUvwL5whGAwyHHHHcdpp53G0qVLWbRoEfX1+Wdu3F8ymWTdunWsWbOGl156ib/85S+0tOyb3W3gOZcvX87VV1/N6aefzuc//3mam5tH48cVQgghJgXV3cVpwLNAF9C933NHYyO3bN/O9/Mc4++BU6LR4jYqhBBCCFFk/SEMw5m7faxCGKZOLfx5Siswq23oAZBCiInHWb+uYI3fPL+oPfiNTQT+8uchtzvbtxX1/EJMBs66tajEvjEMrxSonzt3HmVl5cVtqp9SpC5+M5Hbfz5kSWDlcvTOHZiGmWPTkxBCHKUkhGEE9h+4J8EJQgghhBDD15bo5c5tK3hx7w5SxgcsPekk3ekEAe1QHSyhIhDCWNibiuEqjdaaEJq08dka7QJA7zcaz1Ea8PGtOej1mqMUWmlSxiek3dxgPmMNETfEzJJKlFLsTvRhrcUAdeFSPGuJpxP0pZOEtMOnFp3NaTVNJIxHyHGpCZbIAD4hhBBCTEoP/+Z57v2fp4j2pg75GAboOKmM6KwwJntJpVIWNNjs4GHrqIOHO/QHNGS3aZ2pLw0ESPk+Kd/HAjHPQyvFOU1NvG3hIhbX1cnneUIIIYQQQogJ689//jNf//rX2bhx46DwBZsNqquoqOANb3gDF198MWeddRahUOiwzhcKhVi6dClLly7lyiuvBGDLli383//9Hw8//DCrVq3K9QCZ+y3+/Oc/8/a3v533ve99fOxjH6OsrOywehBCCCEmA93VSRVw5hDbE2eczd3Rh+noGHo+6CigJIRBCCGEEEe5/hCGLcOobWqaVdRe+tXV1RWsaQPmtLYUrBNCTBzOxvV5t5vqamxNTVF78Bsb827XO7YX9fxCTAbuilcHLb9coH7ZsuOK1svBFAphAAg+/BCJq68dm4aEEOIoJSEMw9R/k0L/sxBCCCGEGFrK+LzSuZMVXa30pZMkfY8V3a0kjcfUUBk12sXH0p6MEdIuWin2JmNEvRT14TLS/YEJWQHtkPQ9PGMIOc4B53OVxlhD2vgEnQMvcaeGStmTjJEyHkHtYrFYoDZUglKKmZFKyt0Q22NdueN1JuOUuUH+pmkJp1c30VRaVaR3SwghhBDiyJdKpLj9u3/kmYdew/fNIR/HBBSxhiAdS0tJVbmZNAZXgcpmZVm7L2BhqI/h+kMYVCaAoX9Aj6s1SikUMCUSoTQQ4NqTTuacWWNzg40QQogjg7WWHTt2sG7dOlpbW+nt7SUYDFJRUcHs2bNZunTpYQ86HQ2e57F8+XLWr19PV1cXWmumTp3Ksccey/z5xZ35RgghxMT0gQ98IBe6MDB84dRTT+Vd73oXF110EcFgsKg9zJ49mw9+8IN88IMfZMuWLdx5553ce++9dHZ25v528zyP2267jfLycj760Y8WtR8hhBBiIlDdXXm3m6oqIpESYOgQhhigon2j2pcQQghxJEun07z22gpaWnbR09OF42imTKmmsbGJ+fOPQR8BE+/s2rWTzZs30dbWSjTah+M4VFRUUF8/nWOPXUpJScl4t3jE0Vu3AIVDGEKhEHV1U4vdDgBTp9YXrGkF9J528H04yL2PQoiJx12fP4TBn1f87wJNY/57ZXTLLkinIRAoei9CTFTuyuW511FgTYH6JUvGOIThnPOxkQgqHh+yJvTwHySEQQghCpAQhgJOOeWU8W5BCCGEEOKoYa3l0bYN3LvjdfakomAzs1y1xHtIG0PYcXDQzIiU05WK4xtDKBuaoLUiaTx2xnsywVf7TVIc0Jq08Ukbg6sHfxmhlMLRGmMtxlp09mZOkw3QqgiEqQxG2NzXQdJ4ufNGnABRL0VPOgnAG+rn8Y9zTyEQdNBKUREIEXJcUim/yO+cEEIIIcSRqWXbHm7+2n1sfL0FstdYaJUNSRhZWGm63KH9lHJSFQ5+qYPyLRiwbuZ41skmKxxMfzBDP62IOC5pa/CNQQEJLxPaVR4Kcc6sWVy2YCHzqqtH/kMLIcTRzg7xu3QC6+7u5pFHHuHpp5/m+eefp7Ozc8jaQCDAeeedx1VXXcWpp546hl1mRKNRbr75Zn7961/T1dV10Jo5c+Zw7bXXcsUVV+QGrAohhBAj4TgOl112Gddccw3z5s0blx5mz57NDTfcwKc+9Snuu+8+fvazn7F58+bcdpkAQwghhBgePcTfjv1sZVXBQZpRQEWjo9eUEEIIcYTatWsnP/vZj3n66aeIxQ7+b19VVRUXXngx73//tVRVVQ15rJdffpFPfOKfDrptqPX9nnnmxQPWJZNJ/vznZ3jyycd5+eW/snfv3iH3dxyHk046hfe97/2ceOLJec81acTjOK0tQOEQhpkzG8csaKOsrIySktIh//cG0AYoY9B72jH108akLyHE+HLWr8273Zu/oOg9+DMb825XxqB37cTMml30XoSYqAIr9oUwrGDo+Yb6LVs2tiEMRCKkzruA0B9/D0AC8ICyASWBZ55C9fZgyyvGtjchhDiKSAhDAbfffvt4tyCEEEIIccTaEevmmfYtrOttJ+F7tCeitCZ7qQqEmRYqQytNezKKBUqdAL61tCX7SPjpzATGA8YRKKUI4hA36YOeSyuNVioTrGDt4J2BgHKoDIbZk4oR1JkQBc/4lLgBSt0gSikWVdSxLdZNXzpJdaiEPj+Fi+b0mkbeUD+PxZX1uFoTDEritBBCCCEmtxceW8X/fu//6OqIZq679h8AqsisG0YYgx9U9M4J03lcGSaQmY0VR6E8GPLrp4GhCxbQmfM5WqEAA7iOJqQcYp5HRSiEtZYZ5eV8+qyzJXxBCCEmka985SvcddddpNMH/zxhf+l0mkceeYRHHnmEt7/97Xzxi1+krKys8I6jYO3atXzkIx9hx44dees2b97M5z73Of7whz/wve99j/Ly8jHpTwghxNHPcRyuvPJKPvShDzFt2pFxU38gEOCd73wn73jHO3j44Yf5/ve/PyiMQQghhBD5qe6uvNttVRWRSP4QhhgSwiCEEGLi+81v7uBHP/phwc+Ku7q6+O1v7+Shhx7kc5/7V84774Ix6e8jH7mGtWtXD6vW931eeOF5Xnjhea644ko+8Yl/wXUn97APZ+uW3OstQ1ZlNDY2FbOVA9TV1bF169DXWq3ZZ93WKiEMQkwGnoezcUPeEn/+wqK3YZoK/y50tm+TEAYhDpXv465ckVt8eRi7LF26rHj9DGH1SSfz9B9/zx+Bx4H/AD4xYLtKpwk+/BDJd757zHsTQoijxeT+a1wIIYQQQhySrlSc/9n0Ii937sQ3hoB2iHlpWhO9aKWIe2mMsdSFS9mTjKJRKKVwlUJbRbeXRFnQ+w3mU0qhlSZlPHxjcPZLpHaURilF0viEtJubKNm3hspAmKbSKrRS7ElG8a3FApVumLifJuqlSBvDjEg5H176JuaW15A2PhEnQMiRy2IhhBBCCM/zuOeWJ3j4N38l7ZnMykKzb6vsfxwkiMECvfPC9CwsIVXhYAIK5VtwdGaXgDr4bO39oQvZQ2pHYQFXa4y1GDIzpvrW4hmDAsqDQU5tmMk/nngiZcHgIb4DQggxMZjxbmCMLV++/KA31TqOQ11dHTU1NXiex65du+jt7R1Uc++997Jp0yZ+/vOfU1paWtQ+N23axFVXXUVnZ+eg9SUlJTQ2NpJMJtm5c+egn+WZZ57h2muv5bbbbiMUChW1PyGEEEe/iy++mE996lPMmjVrvFs5KKUUl1xyCRdddBF33313JqBPCCGEEPkZg+ruzl9SWUVJSf4Qhiigon2j2JgQQhTfmjXDG6w+2oLBIHPnzhvxfps2bSSVShWho8IWLTpmXM57JLnllh9x220/O2B9WVk506dPxxhDS8suYrFYbls0GuVLX/osn/7053nLW95W9B5TqeQB62pr66ioqCASKSGRiNPW1kpf3+B/s++55y4SiQSf+9y/Fr3HI5mzZV+g45YCtY2NY/vZyNSp9WwdEBKxv7bss25rHbJGCDFxONu2oAoEAvnz5xe9D7+hEcjMfL+NzO/OrUA78Llsjd6xveh9CDFROZs2omL7QpheKVA/c2Yj1dU1xW0KiMViPPfc0zz66J947LFH2Lx506DtDzE4hAEgdP+9EsIghBB5yGgzIYQQQgiRV8L3eLljJ0/s3siueA8p49MS78ViaYhUUhrKDHJbk9xNQGsCysG3hh2JHmLGI+6lCA4IOdBKEUATM2mCOAecL6g0aaVIG/+AEAaAulApHekYSeMR0k5uguSaUAlKKRpLqihzg7Qkegloh6B2SBqfptIqLpw2n1NrGil1ZWCeEEIIIUS/zvYebvm3+3jtlW2HdoD+HIUB42e8kGLPyeXEZ4awvsW4CuVZlAXr2H3hC+rg+wMoR+GoTJiXby0BxyGgNfF0Gqsy2wxw7qxZXH3CiTRWVh5a/0IIISaMiooK3vrWt3L++edz0kknUVZWltvm+z4vvvgiP/jBD3jxxRdz61esWMFnP/tZfvCDHxStL8/z+OQnPzkogKGqqorPfvazvOUtbyEQCACZGdhuvfVWbr75ZozJxGm88sor/Od//idf+MIXitafEEKIieH73//+eLcwLFprrrzyyvFuQwghhDgqqL5elMkft2irqohEInlrMiEMQ8/OLIQQR6Jzzz1tXM67cOEinn76hRHvd9VV72Ht2jVF6Kiw3bt7xuW8R4pnnnnqgACGuXPn8dGPXsfJJ59KJJK5TyydTvPkk0/wve/dyO7dmWHxvu/z7W//OwsXHkNz8+ABsc3NC/jud/8LgD/+8fc8/PAfcts++tHrDqgfjvr6abzhDRdyxhlnsWjRMZSWlg3abq1l48YN3Hvv3TzwwO/wfR+AP/zhAc4661zOO+8NIz7nROFs2TeAcHOeOoCmYcz+Pprq6qbm3d4fvaDb2vLWCSEmBmfduoI13vyFRTv/ihWv8l//9X22bdvGTq1pPcjflJ8CwoCzbWvR+hBionNXvDpo+eUC9UuXHle0Xga67rqPcO+99wy5/QkgDgz8JCn4+COo3h5seUWRuxNCiKOThDAIIYQQQohBrLUkfA+tFGt6dnPLxr+yJxXFVYqwDrAz3kNPOomrNRv69jIzUkFQO8T8NEHtoFC4ykFZw95kFItFMXiGY51dkzY+IWfwJWlmfw0WfGtwlM71BVAZDFMdKmFLtIO4l8a3hrATQCtFZypO3EsT0Jr3zDqev5t1HD7gKoWrDwx8EEIIIYSYzFa/tJlbvnE/e9p6QanCO+SjFFiLF9F0L4zQNztMutwFayGoQCusVmD2S1roX9SZ10opHEfjW4POhixgbeZa0NpMZoNSVIZCVEcivOvYY7mkeT7qcPsXQogJxDL5fic2NDTw4Q9/mMsuu4xwOHzQGsdxOO200/jFL37BV77yFe68887ctocffpjnn3+e008/vSj93X333awbcMNVZWUlv/zlL2lubh5UV1VVxT//8z/T3NzM9ddfn1v/q1/9ive9733Mnj27KP0JIYQQQgghhDgyqa6ugjWmcgolJaV5a2JICIMQQoiJKZFI8K1vfX3QulNOOY1vfvO7BIODJ+kJBAJceOGbOP74k/n4xz/Ixo0bgEw4w9e//q/ceusdg+orKio45ZRMGMiK/QbZLVy4iBNPPHlEvV5//WdZsmQZjjP0PWxKKZqb53P99Z/hvPPO54YbPkUqlQLgf//355M7hGHrFgC6gc68ldDYOLYhDFOnDjeEoTVvnRBiYnDWrc273YZCmKZZRTt/b28vv/vd3XlrtgELAGfH9qL1IcRE5y5/Nfc6BbxWoH7p0mXFbCfnvPMuyBvCkACeBC4ZsE4lkwT/9DDJKyRAWwghDkZCGIQQQgghBAA7Y908tXszT7VvJuaniXtp9iSjlAeCzIxUEXJc4n6ahJ+mxA2gLHjWsDXWRbkbAhgUtuAojVKGtO9jtEFnwxQg84WRqx3SvofBogfsZwFHKWpDpbQno1gFrtKks2ELZW4QpRTzy2rZHusmbT3qQmVYC5WBMJfOWMjZdbOZHsmkMQbG5u0TQgghhDgq+L7P/bc9w+9/+WdSKT8TnjBKAQbxWpe9p5bjlTgYR6GMRfkW6yhs9lLQOgPOZQc+K5STuQ5UKhPa5ShF0HVJeT5p6+NbSyydJuS6vG3hQt44dx6zq6pGpXchhBBHr0984hOceeaZB9xQOxTHcfjXf/1XVq1axWuv7bsV4q677ipKCEMqleJHP/rRoHWf/vSnDwhgGOiyyy7jqaee4v777wfA8zx++MMfcuONN456f0IIIYQQQgghjly6u6tgja2qIhKJ5K2JAiraNzpNCSGEEEeQhx/+Ax0de3PLtbV1fO1r38z7eXFFRQX/8R/f4X3vu5JkMgnA+vXrePHFFzj55FOL1utxx50wovpTTjmd97zn77nttp8BsHr1KjZv3sScOXOL0d4RT2/ZDMBw5mwf6xCGurr8IQxt2WfdKiEMQkwG7oZ1ebf7c5shTyDP4RrO78AtZEIY9PZtRetDiInOXbk893oVkC5Qv2zZcUXtp98FF1xYsOaPDA5hAAjdf6+EMAghxBAkhEEIIYQQYpLqSsWJepmk7MfbNvHH1rV4xlDqBglqh23JTjxr6U4n6fPaaSqpJOansWQGxaEgoBw8Y+hMxwcFKfQLKockHinrEx4QwkD2GAHtkvJ9wo4D2f29bNjCzEglIcelJd5L3E9jsNQES+hOJ4j7HmBZVFnHh+efzqzSKVhrZQZkIYQQQogh9HXHuOXr9/Pq8xszM6Rbuy98YeA1lLUHP8AQLJCsdemdHaanOZwJWTCAq8By4BWiJbNSZV47jkZrhW8NAMaCwmau7bQmoDVGG4JOkIpQkKllZXzqjDNorq45pPdBCCEmA2sn19/G559//oj3cRyHa665huuuuy637plnnhm9pgZ45plnaGlpyS03NDTwjne8o+B+H//4x3nggQew2X+bH374Yb785S9TXl5elD6FEEIIIYQQQhx5VFdXwRpbVUVJSWnemhigotHRaUoIIYQ4gjz44L2Dlv/xHz9EaWlZwf2mT5/BlVe+h//935/n1t1//++KGsJwKC6++M25EAaA115bMWlDGJxsCMOWYdQ2FXGG+YOZOrU+7/ZWMl+T6zYJYRBiMnDWr8273VuwsKjnnzGjAcdx8H1/yJot2Wdn+/ai9iLEhGUM7op9IQwvD2OXZcuOL1o7A02fPoPFi5fw+uuvDVnzEPC9/dYFH/sTqrcHW15RzPaEEOKoJCEMQgghhBCTSNr4vNq5i0fb1rO6Zzdpa+hOJejzktQGS5kWriDkuOxO9mGBEieAtRbPGrZEO3G1PiBswdWapJ8JT9ifVgpXaTxjYXAGAxZLeSCEtZY+L0XQcVAWDJa6UClKK+pCpQSUpj0ZpTIQpiZUQkA7nFBazXn1czi2sh4nG+4gAQxCCCGEEAfa+PoO/vtff0d7aw+gDh68MJBSww5isED3wgg9CyKYgAKtUOnMdZ/NhnaZbBjDoFOgsAqUs68NrRTWQtBxSBuDwWKsJZ728K1henkpl86fz6XzF1BbUnJI74UQQggx0Mknnzxouauri3g8XnD20JF69NFHBy1fccUVw/oMo6mpiVNOOYUXXngBgHQ6zZNPPslb3/rWUe1PCCGEEEIIIcSRazghDKayipICn5lGASSEQQghxAQTi8VYt27fQNdwOMwb33jRsPd/y1veNiiEYfnyV0azvVExfXrDoOWBP++k4vs427YChUMYQqEQdXVTi97SQIXOlwR6gJLdEsIgxIRnLc66dQB4wFXAAmBR9rEAMPMXFLUF13WZMaOB7du3DVmzNfusd+0A3wfHKWpPQkw0estmdG9PbrlQCENtbR319dOK29QAF1xwYd4QhnXAJmBgtJdKJAj+/gGSf/veYrcnhBBHHQlhEEIIIYSYwNLGZ0u0k7ifJmk8fr9rNWt72tFKURUIE/fT7PKSaBR70zG6vASNkSr2JKO5sAWlFAHlkDY+US9NSB/4YVtAa+JeGmMNWg1OW3B0ZqrjlPEI6szlp7UWC0wJhpkSLGF7rIvOZIy0NQS1g7WW3Yk+0sZQHgjyj/NO4fKZx6IlaEEIIYQQYlgeuuM5fnfr0yQSXibpYCTXUQWCGKyG+NQAHUtLSdYFMqVOZh+tFLY/daH/EJnLQZRSuE7mWtE3BksmgEvb7DmxhF2XoDHEfY8p4Qi+tZw4fRr/fMaZVIbDI38jhBBiEhpmls6kV1lZecC63t7eUQ9hePLJJwctn3322cPe96yzzsqFMAA8/vjjEsIghBBCCCGEEJOI7u7Ku92GwxAOU1KS/2/ZGKCifaPXmBBCCHEEWLPm9UGzfC9atLhgMNFAjY1NTJ1az+7dbQDs3buH1tYWpk2bPuq97u/111/j6aefZP36tWzdupW+vl5isWjeWcsBugtcG0xUetdOVDoNFA5hmDmzEa11garRNXVq4dCHFmB+W1vxmxFCjCu9uy03MHszcMd+2xXQ9POf0vzKS8yfv5APfegjNDTMHPU+Zs5szBvCsKW/H89Dt7ZgitCDEBNZYOXyQcuForyWLTtuTCebfOMb38RNN30vb80fgY/sty58168lhEEIIQ5iUoYw3HjjjXzoQx+irKxsvFsp6Pnnn6erq4tLLrlkvFsRQgghxFGkKxXn6fZNPNK2gd2JPizQnuwjbXzqQmVMDZUSdgLsiveilCKUDUdIG5+tsQ58S25dP1dprAXPGIL7fU8RwCGBR8r4hJ3BGxWKqaFS9qbiJI1HUDv4WFylqApEcJWmIVKBozTWWuaV1RDUDuWBECdXz+S0mkbKAqFivl1CCCGEEBNCMpbklq/dz4vPrscYO/LwhWFIlTvsPamMVKWDV+aAD8qCdQGlMEHA7KtXgNYaP5vIYK1FKYXWGmMMrnbwjcEYg1KKtO+TMplgrrrSUi5pbubyRYtwxvhGGSGEEBNf20FudqyqqhrVc+zZs4f29vbccjAYZPHixcPe/8QTTxy0vGbNmlHrTQghhBBCCCHEkU91deXdbiqrACgpKc1bFwVUNDo6TQkhhBBHiLa21kHLzc3zR3yM5uYFuRCG/mMWM4Rh+fJX+M53vsXGjesPaf++vt5R7ujo4GzdkntdAywmM4A4dpDaxsamMelpoKlT6wvWtAALd7dlkrRlIiohJixn3drc69UH2W6BrXv2sPXRP/Hoo3/i6quvLUofjY1N/PnPzw65fcuA1872bRLCIMQIuSv2hTD4wPKhSwFYuvS4ovazv1NOOY3S0jKieQI5DxbCEHjmKfSunZgZDUXtTwghjjaTMoThlltu4be//S0f+chHePe7300wGBzvlg6wZs0abrzxRp555hk++tGPjnc7QgghhDjCdaXirOnZTdxP05WK83DrOrrSCUocl2nhMtqTsWx4gkNHKkZXKs60SAXd6QQB5eSOE9AOSeORNh4h5Qz6wF8phasVaWNyg+cGcrXGAr41OCo7w7E1KBR1oTKqQyXsiHXTm07iWUNVIExHKp6tVxw/ZTr/MPskmkqrxuItE0IIIYSYMHZuaeeHn/8tu7buhf6wgsO9cUOpQVOpGxd6Z4fpXFqKCSiszXw5rIzNJC2goL9cZ8IftCYXnmCNxZLJZ9B2X0BEJOCCtcTSHkHHwQJlwSDvXbaMtyxYQEVIwriEEEIUx4svvjhouaGhYdS/L9q4ceOg5VmzZo3oHM3NzYOWt27diud5uO6k/HpPCCGEEEIIISYd3d1FB/AToBKo2u+5rLQU29dLJBLJexwJYRBCCDER9WZnGu9XmQ0nGon9g3n3P+Zouvfeu7nxxv/ADvgOdqRSqdQodnT0cLZszr3+fPZhgT1kBhJvBlZ97ktsb9nFggULx7y/+vppBWtaAJVOozo6sDU1xW9KCDEuBoYwFIpWD4VCRQuOKXTcLQNe6+3b4PQzi9KHEBOVu+LV3Ou1HDwYaqBly8Y2hCEYDHLuuefz0EMPDlnzKJAEBt6Zp6wl9NvfEP/EPxe7RSGEOKpM2ru0urq6+MY3vsFPfvITPvCBD/Ce97yHkpKS8W6Ll156iZtvvpmnnnpqvFsRQgghxFFgW7STh1vX8tyebSR9D98a2pK9+MZSHYxQ5gZBKfYko7ha4yoHV0Ha+OyIdWGsJeg6g44ZVA5xPNLWJ6QGzzgc1A5pY/CtwR0Q3mABR2mmhsvYnejDt4aAdkhbw5RAhJDjYqxlaqiMgHaYFi6juawWR2umhso4s24Ws0qqDgh2EEIIIYQQQ3vivpf4zU8eo7c3lQk10JrRvpqyCnrmhemdGyE1xcW4oAxYN3MmG1Tg77tRSGuFdjSeMVjIhXdprfGNQZMJYsikOGSSHIwFrRRTIhFmlJfzsVNPpVluPBFCiENmrfxtPRx33333oOVzzz131M+xefPmQcvTphW+EXOg6upqQqEQyWQSgHQ6zY4dO5g9e/ZotSiEEGIC2rVr13i3gNaaSCRCaWmphAcJIYQQh0F1dbEd+NxQBZs2wtwGPvzhj+c9ThRQsSgYsy/IVwghjnBPPfWXcTnvoQa13nbbrybtAPnxEosNHu4WDucPJTqYcDic95ij5eWXXzwggMFxHJYtO57Fi5cwbdp0pkyZQjAYIhAIDNr3n/9ZJnMcGMLQTwF12ceJMxp4w3XXj3VbOaFQiClTptDZ2TlkTf+nNbplF758Fy7EhOVuWJd7XSiEYe7cZhzHKVB1aAqFMLSwb/C1s31bUXoQYsKydlAIw8vD2GXJkmVFa2cob3zjm/KGMMSAx4FL9lsf/u2viX/8usOfAEoIISaQSf1tt7WWPXv28O1vf5sf//jHXH755bz73e9m/vz5Y9pHPB7nwQcf5M4772TVqlW53gAZiCiEEEKIHGstW2OdrOpuI+anaYv38uyeLRhrmRKMMCUQZnu8G1BEHIceL0lvX5KqQISEnybs7Lv0C2gHzzd41uQGxvVTSuEqRcr4hPTgL3UUCldrPGvQaPqH+XnWp8QJ0BCuoMwN0hLvpddLoshMhLwz3o1GUR0q4e0zj+XSGYtw5eYOIYQQQogR8zyPn/37Azz/6Bo8Y3PhC/1ynymNxrnCir0nlROvD4I1WAd0OnN86ww4g6tQWqFV5gGgyQR1GUBnrzeVUoRcFwUkPA+rFCnfx7eWhopyrj7hRE5taKA8FNq/FSGEEGJUPfnkk/z1r38dtO6KK64Y9fPs3bt30PJIQxgApk6dyvbt2wcdU0IYhBBC5HPBBRccUfcZhMNh5syZw8KFCznllFO46KKLKCsrG++2hBBCiKOC6u6kaxh1M2bMyLs9BhhrIR6H0tLRaE0IIYpu0aJjxruFEZk7d954tzDp7D/5YiIRH/ExEolE3mOOlptu+u6gAIYzzzyb66//LFOn1ufdT4I9MvRBQhgG8mfPGaNOhlZfPy1vCENL9tlp3YW/ZOnYNCWEGHPOun0hDKsL1C5YsLBofRQKYbDAdqAZ0BLCIMSI6O3b0AP+zS8UwlBRUcnscbhWueCCCwvW3MeBIQzumtW4L7+Id9IpRelLCCGORpMyhOGrX/0q3/nOd+jq6kIphbWW3t5efvnLX/LLX/6SpUuXcskll3DxxRfT0NBQlB5SqRRPPfUU//d//8djjz1GNBodFLzQ39f555/PO97xjqL0IIQQQoijx2vdrdy3YxWv9+zGYEn5Hu3JzPVDqRsk5DgElKYjFSOgNFppQioTlrAnFeVgQ/EC2iFpPNLWJ6gGXxa62iHpe1gsasB+xlrC2qUiEKIjFc+EMiiFAepCpSilCGuXqkCYikCIU6sbqQmVEHECNJVWceKUBkLOpLwEFUIIIYQ4LG079vJfX7yHzRt27wtdONigmuw6a+0hBzGkyh36ZofomRvGL9FgwDpOJl1LKfCzNwgpcB0NSuEbg8meUymFozWeMSjIrbfWolUm1Cvt+1RFIoRclzObZvLxM05HmSNnkJAQQhzNDv1fgMmhq6uLL33pS4PWXXjhhSxbNvqzT+w/a1okMvKZ2Pbfp1gzsQkhhJhYBg7sGG/xeJzXX3+d1atXc++99/LVr36Vyy+/nOuvv57y8vLxbk8IIYQ4oumurmGFMEyfnj+EATJBDCoaxUoIgxBCiAmivLxi0HJ3d/eIj9HV1ZX3mKNh27atrFu3Nrc8d+48vv71/yQQCOTZK6Onp2fU+zkaOUdJCMOaNUMPud6VfdYtLUPWCCGOfs6GTAiDBdYUqG1uLt7kwYVCGAC2kAlhcAaEwQshCgu88tKg5UIhDMuWHTcuwdkzZzZyzDGLWb369SFr7gP+i8xkSwOFf3ErfRLCIIQQOZNyBNy73vUuLr74Ym688UbuvvtufN/PhR4ArFy5kpUrV/Kf//mfNDc3c+qpp3LqqaeyZMmSQw5liEajrF27lhdffJG//OUvvPzyy7n0zIHhC/3LTU1NfO5zn+P8888//B9YCCGEEEcVzxhW9bTySucuulJx2hJ9vN7TRli7TA2XEtQum/o6cJQiqF1Sxmd7rJs9TgzfGALOvi9oXKVJo0gbH6vtoD/iXaXRKJK+T1DvF8KAwmhN0viEtJMLYjBY6oKlzCippMyNsjvRR6+XJOS4JIxPS6IHV2lOqWnksoZjmF9eOzZvmhBCCCHEBPX8I69xxw/+RGdnLBO+oPf/2mMI2c+6RvoVTnRagI4TyjABhQ1plG9RBnxHgQWrQAU0jqOyp8k+A4bMF8lYmwsZDToO1lrSxgCQ9n2Svo+jNQvrarls0ULOmT0LV2tSKX+E3QohhBAjY4zh//2//0dra2tuXXl5OV/4wheKcr79AxNCodCIjxEOh/MeUwghhDiY8bihLx9rbe6+iEQiwW9+8xsee+wxfvKTn7B48eJx7k4IIY5+zprVBJ9+Ar1zJ/68ZpKXvAVbVzfebYlRoLq7KDSc1HVdamsL//fdBwSjfVimjkpvQgghxHirr582aHnDhnVDVA5t/33q66cfVk8Hs2rVykHLb33r24cVwACwefPGUe/naORs3ZJ3u5k1e0z6yGf//z3urz96Qe/aWfxmhBDjQvX24LRkIlfaoGCg3oIFC4vWy4wZDYPGyB3Mluyz3r61aH0IMRG5L+8LYTDAKwXqly49rqj95HPJJZfmDWFoAV4ETt1vffjeu4l+9RvYyqoidieEEEePSRnCAFBZWclXv/pVrrrqKr7//e/zpz/9CRgchACwfv16NmzYwB133AFAaWkpzc3NNDQ0MHXqVOrq6ohEIoTDYbTWpFIpEokE3d3dtLa20trayubNm9m1a9eg8w+8mB14zqlTp/LhD3+YK6+8EtedtP/1CCGEEJPWX/du5zfbl7Mj1gNY0tanLd6HUhBQDr411IRK6U4nCGTDEYLKwVhLTzpJdtjbIK7SJPHwrE9ADb6+CGiHlPGxMGiAno+lMhBG49CdTqBQmYmPgepQCdYaHKWoCIRpLq/l3KmzCekAJW6AJZX1TI+Mfiq4EEIIIcRk4fs+v/z+wzzx4ArSngGlhh++MJBSMIzZT62CRF2A7uYwsaYQVpG5rHQUeKCwKBRKKxxHY63FWJu7hlRK4WiNNQab3VUPCB0Nuy7a83Adh4jrEnZdrjrhBN56zAL0ETYwSAghJoIjaOLrI863vvUtnnrqqUHrvvrVrzJ9+ujfWAuQTCYHLQ/3xtqBgsHgoOX+gG8hhBCikHw32I6l/pC+gay1tLe3c+211/LrX/+axsbGcepOCCGObrqtldJ//Rzhe347aH3p179Mz4//h/T5F4xTZ2K0qK6uggN3KioqKCsrK3isPqAmGh2NtoQQQogjwqJFi3EcB9/PBL2vWfM6sViMkpKSYe2/Y8d2du9uyy3X1NQybdrBB9LrQ/muNquzs2PQclPTrGHv+/LLLx7yeScK1dmB7u7KW+PPnjM2zeQxbVr+7xlyIQytLXnrhBBHL2f9vmCfNcOob25eULRegsEg06fPYFee4Jf+6AVn5w4w5tDuSxJiEnJf2RfCsAnoKVC/bNn4hTC8+c1v5bvf/Xbemns5MIRBxeOEfvsbEv/4wWK1JoQQR5VJP8p/3rx5/OAHP+D111/n5ptv5k9/+hO+7w+6CWDgzQl9fX0sX76c5cuXD/sc+9/cMPAmg/4ZH2bOnMlVV13Fu971rkOaCUkIIYQQR5+E7/Fy5w6ebd/CnmSUPckYO+JdlLthZoTLCTgOG/r24mqdCVrAsicVoyudwFiDxskdSyuFoyBlDMbaQYPZAtpB+Yqk8QnowZd/jtIENSR9j5Djoth37VITLGNKMMKeZIy2RC9RL0VFIExPOoHBUhcq4+0zj+WN0+ZT5g4eECCEEEIIIUaus72bm754N+tWtez7cvMwQwr2D9vanx9QdJxQSnxqEC+SqdRpi3Gze7kKgg6uVhj2BSuQDWEYeHylFAGdCWnws595+caQsBbPGCrDYZbW1/P3xx3HvOpqCWAQQggxpn7xi19w6623Dlp3zTXXcOmllxbtnPt/35NOp0d8jFQqlfeYQgghxP5OOeWU8W4ByPy7F4/H2bt3L3v27Mmt779fwlpLR0cH3/zmN7npppvGsVMhhDhK+T4V73s3geUHzrenOzqo+OD76Xj6r9j6+nFoTowW3d1FZ4GaiopKSktLCx6rD6iVEAYhhBATSElJCQsWLGL16lVAJsD2scf+xFvfevmw9v/97+8ftHz88ScOWRsORwYtjyQsd/9xBJ43vM+JU6nUAT1ORs6WzQVrjoQQhvoC193903k6Lbvy1gkhjl4DQxhWF6hVSjFvXnNR+2lsbMobwrClv5dUCr27DVMgTEYIAXgegRWv5hZfHsYuy5YdX6xuCjruuBOYPn0GLXmuP+4FvnGQ9ZFf3Eri6msP+95FIYSYCCZ9CEO/xYsX873vfY9du3Zx++2388ADD+RuBNh/VgYY2awRB5vVATKpmKeffjrvec97uPDCCw8rJVMIIYQQRweTnTX4pc4d3L7lJfYmYzhK41vDzngPYEkZn6ifpD5UTm86kQlRQOGg0CiifhprDSHtDrrOcJUmiY9nfYJq8GVeQGs8Y9h/GJ7FUhMqwTOGXi+JQmGxBJRDZSBM0vfwraE2VMqbpjVzSk0jGk1VMMwxFVMJaAchhBBCCHF4Xn12Lbd9+yH27I2C0mOSLm9cRbQhQMdxZfgRDb7FBjTK2/e5FY7CUQpjLb41QPZqUikcrbHGYK3FMDiIIeK6pH2ftDGUBYMkfZ/FdXV87NRTWVBbe9DP2oQQQoyeI2PO6yPLAw88wDe+MfjWgSuuuILrr7++qOfdf8a1ZDI54mPsfzPvcGdxE0IIMXndfvvt493CAWKxGC+++CIPPvggDz74INbaXBDDo48+ytq1a1m4cOF4tynEUcFai+/7pNNpPC9NOp0mnfbwfQ/f93EcB8dx0NrBcfSgZdd1CQYlWH2iCN9x+0EDGPrpri5K/vsHRL/y9THsSowqa1Hd3QVDGKqqqigtLSt4uD5ARftGpTUhhBDiSHHZZW/PhTAA/OxnP+GCC95U8HPU1tYW7rrrV4PWve1tfzNkfUVFxaDllpahB7Xur7q6ZtDyihWvcvbZ5xXc76c//REdHXuHfZ6Jytm4oWDNkRDCMK3A4OU+oBeISAiDEBOWOyCEYU2B2sbGpqJ/59fY2MRf/vLnIbdvGfBab98mIQxCDIOzdg0qFsstFwphKCkpZe7cecVtKg+lFJdccim33vrTIWtWk/mdtWi/9e7qVQSee4b0WecUs0UhhDgqSAjDfmbMmMENN9zA9ddfzzPPPMPvf/97nn76aTo7932d0T8zw3ANDGzQWnPcccdx4YUXctlllxVMPRRCCCHE0S/qpfhrx3YebVvPrkQv3akEe5NRKtwQDSWVRJwAm/o6cJQipANYa0n4HpujHQAEB4QmKKVwlSJhLQaLM2BbQLso3yNpfIJ68GWeqzRKKxLGJ5QNdTDZa5S6UCklTpDOdJydsR4SfpqKUIS2RB8BrTmpuoE3TJ3HCVNmyIA5IYQQQohRYq3l7lse54+/eYGkZzKp0Vpn0gz6P0oqwihaC/Q1hehZFCFdpvFDGuUDrsqcO6hxHI1WirTJBC/o7MCY/SO9tNoX0mCyP5PNho6lraUkGGRKJMIFc+bw3mXLCDgS4CWEEGLsPf7443zmM58Z9F3NRRddxNe+9rWif86x/81T8Xh8xMfYfx8JYRBCCHE0Kikp4dxzz+Xcc8/lb/7mb/jwhz88KJzo8ccflxAGMenddNP32bp1C319vUSjffT19eWe+x+JRJx0eniz5g7FdV1KSkopKSnJPkq57rp/yTvgTByZwr/+ZeGaX91O9DNfgEikYK048qi+XpTvFwxhqKysorS0tODxMiEM0VHpTQghhDhSXHTRm/npT3+cCytob9/Nl770Gf79328kEAgcdJ/e3l4+85l/GRSAu2DBQk466ZQhzzNnztxBy0888RjveMe7h9Xj0qXHDVq+9957eNvbrmDmzMYh97n33rv51a/+d1jHn+gKhTCYKVOwU6rHqJuhTZ06rWBNC9AsIQxCTFjOurW514VCGJqb5xe3GaCxceh/ZwC2DnjtbN+Gd8ppxW1IiAkg8MpLg5ZfGqKu35IlS3HG+X65Sy55S94QBoC7gC8eZH3kxzdJCIMQQiAhDENyHIfzzjuP8847D2stK1eu5IUXXmDlypW89tpr7Nq1a9ANe0MpKytj4cKFLF26lOOOO44zzjiDqqqq4v8AQgghhBg3xlo6U3GSxmN9bzu/2vYq3ekEAa1RaPYk+wBFj5+kt7ed2mAJXal4blCaUoqQcol6KTxrCGt30KAAV2swkDIeEWfwbDUBrUkbg8WiBgQ0GKA+VEbCevSmk5AdKFfqBgkpl550goTv0VhSyeUNxzKnrBpHaWpDpdSHC8+aIYQQQgghhqevJ85/f/G3vPbqVqzOfsnSf63Xf/k2cDzoKAYxeCWajqUlxGaGsD5YV6F8i2MVTjBAGoNWCt9a/OznXv2zkzpKY63JhTHoAdenpcEgnjEkPA+lFEnfJ6g1ly1YwJsXLGBWZaWEeQkhxBiyVn7n9nv++ef55Cc/ied5uXVnnXUWN95445jc7FBTM3iGs9bW1hEfY/fu3XmPKYQQQhxtzjjjDK655hpuuumm3N+KL7zwAv/0T/80zp0JMb7uvfduVqx4tejn8TyPnp5uenq6c+t6enpGfJy+vj4++cmPMG3aNOrrp9PY2EhT0yyammZTW1srnwUVmWprw33xhYJ1uquL0IP3kbzyb8egKzHaVFcXAB0F6qZMmUJJyXBDGPoOuy8hhBDiSBIOh/n0pz/PZz7zqdy6559/jmuvvYqPfvQTnHTSqUDms+B0Os3TTz/J9773HVpbW3L1gUCAz33uy3nPs2DBIqqqqujK/vv8yisv8YlP/BMXXHAh9fXTcN3BgQ+nDBjIOnNmI0uWLOO111YAEItF+ehHr+WTn7yec889H9fdN5xj/fp13H77rTz22J8AmD17Dlu2bB7x+zKROBvX593uzyv+QObhmDZteCEMC7q6IBYDCVwWYsJxNqzLvV5doHb+/AXFbQZobJyVd/tOIAUEAb1je9H7EWIicAeEMFjg5QL1y5YdV6Ci+M466xzKyyvo7R36M+A7OXgIQ+jhh3A2rj9irreEEGK8SAjDMCilWLZsGcuWLcutS6fT7Nq1i9bW1mzafALf9wmHw0QiEWpqapgxY4YELgghhBCTSJ+X5Pm92/hT63p2JXqIekn2JKOEtEtDpIKqYIRd8V4UipCTuQzzrKEl2Yu1lqB1Bg24c5UibS1pawgqZ8B6B4UibQ37z1niKgelFUnjE9KZOmMNGqgNlxJyXLqScXbEu0kbQ4kbpCMdpzIQ5s0zjuGcutnUh8uL/2YJIYQQQkwya1/dyk+/cR+tbb2gNehhDPzsvzY8zCCGdJmme0GE6MwQXqkD1kIAcDVaQaD/xh6vP3BB4RmTObVSA7Ih9l2s+tZmjoPKBDJYS8hxqC0tpTYS4ZNnnMF8GSQqhBBiHC1fvvyAWbZPOOEEbrrpJoLBYJ49R8+cOXMGLbe0tAxReXB79+4d1H8gECg4a40QQghxNLjyyiu56aabgEz43/btcpOvmKCsJfDUE0R+cSvuyuWorqHns6/vG7+B0VO/cAM1Xz3YbbZD2+P7PNDbe9BtpcBsrZmtNXO0ZoHjsEhrFjkOM5SSgIYsGwzhLz6W+D9+iNTFbx7RvqGH/4AaxuRBAMHHH5UQhqOU6s6EpQz9myOjsnIKjuMQiUSIx+ND1mVCGKKj16AQQghxhDj77HO56qp/5LbbfpZbt2HDOv75nz9GeXkF06dPxxhDS8suovv9W6i15vrrP1twRnLXdXnnO/+Wn/70x7l1L7/8Ii+//OJB6595ZvD6j370k3z84x/KBQbv3buHL33pM0QiJTQ2NqKUpr19Nx0de3P7RCIRvvSlf+Pqq983vDdignI2bsy73Z/XPEad5FdfP3QIwxRgOuBnl53WXfhzj4y+hRCjJJXC2bwJyPztVejTzvnzFxa9pcbGprzbDbADmAs427YVvR8hJoLAy/tCGLZRODhz2bLji9nOsASDQS655FLuuuvXQ9asyj6OPci2yE/+m75vfbdY7QkhxFFBQhgOUSAQYNasWcyalT8dTAghhBATl7GWrbFO+rwULfEe7tnxGl3pOCHtUOYEaYl1o9F41rA11kVbso+k7+NqnTuGqzQ+mjhpfAwuA8IWtAPGI2U8AkoPuiEpqDUpY7DYQYPhLJZp4XKSxqM7ncBai8VS4Yax1rInEcWzhiWV07hqzslUB0sIaocpwUguGEIIIYQQQoyeP/7qOe7+n6dIpA0olQlgGInDCGKwQHRmkK5lpZigwmiFMpaQ6+CEXBLZm3ySvp85jVJYmwlicLUmbQwWcusUmbDSiOuS8n2S1scqSHgenjHMrKjgb445hvPnzKFWZu4QQggxjtasWcO1115LLBbLrVu8eDG33HILJWP4b9TcuXMHLW/bto1UKjXsEIiN+91c2tTUNGhWNCGEEOJoVV9fT21tLXv3ZgaXdGcHmQoxkei2Vso/dDXB554ZVn1dkfvJpzwWQw+4dh6O1jzbosAqY1iVDfkcdC5gEXBM9nkJcDwwk0FZ9ZOGs7uN4BOPEf1/nyX2/z477P0Czz097Fp3+SuH0po4AujuLqBwCEP/JFGlpaUSwiCEEGLSuvbaD1NZWcmPfvRD0ul0bn1vb8+Qs/6Wlpbyuc/9K+edd8GwzvH3f/8Btm/fysMPPzTi/pYuPY4bbvgC3/zm13JBDADxeIx169YeUF9eXsHXv/4tFixYNOJzTSjW4m7ckLfEKxCgMVbC4TDXX/8Zqq1h/o3fYjowA5gGB0y0pVtaJIRBiAnG2bwJ5WeiVg78rX6g+fMXFLchGFaw+xayIQw7JIRBiIKiUZw1r+cWG4E1wMsDH6EwXclEruZICGEAuPzyv8kbwgBwFwcPYQjfeQfR6z+LnTq1KL0JIcTRQO7UEkIIIYQYobif5rk9W3mkbR1bo12kjEd7MorFUhMspcIN0ecl8bCEs8EG1lpiXpqU8Sl3Q4OOp7PhCinj4zr7QhgcpXFQ+PbAG5Rc5WC1Iml8gtpBZ+sUUBsqJeS4dKXi7Ix3Y6ylMhghYXzml9fyxvr5nFQ9M9ebEEIIIYQYXclEih/96z288peNGFQmfOFwZvhTjCiEwWiINwTpnR0iPj2I1Zn9VUDjao3rutjsTHn916Je9qZ4q/ZFfKnswwDK2kEBDVoplAfVJSUYaziraRYfPvUUIoHAof+cQgghRoWdlEOX9tm0aRNXX331oMGc8+bN42c/+xnl5eVj2ktdXR11dXW0t7cDkEqlWLVqFSeccMKw9n/55ZcHLR9zzDGj3qMQQggxXqZMmZILYejr6xvnboQYXaqzg8or3oq7ft2w9xnPEIbSQ9hn1yGeqxf4a/YxUDWZMIb+x3FkghomyydNJTd+k+Sll+Efu2RY9e6aNcM+trNhPaqvF1s2tn8PicOnurqAwiEMlZVVAJSUlAF7hqzrA1RM/s0VQggxcb3rXX/HWWedy//8z0946qkniccPHjRWWVnJm950CVdddQ1TpkwZ9vEdx+GLX/w3Lr/8HTzyyMOsXv06LS07icVipFKpgvu/+c1vpbFxFj/+8Q959dWXD1oTDIZ405su5tprP0Jtbe2we5uodGsLKpYJkeoBQtnHQEdSmMGnP/05SCSou/Fbeev0rp1j1JEQYqw4Az4DGs5f7PPnLyxeM1kNDYVDGLZmn/V2CWEQohB35Ypc2AqABhZmH+/Jruv8+f+ysXkBK1YsZ+XK5WMSuDIc55//RioqKunpGToQ+07gXzkwKFfF45T89w+IfvlrxWxRCCGOaDLyTgghhBCiAGstm6Id7Ix305WK83DrOvYk+wg7AWpDpWyOdqCAoHbpSsfpTsexdvAfoUopAkqTxCNpPCLOvluGXK1RPqStwVibGwgHEHRc4n4aH4s74IgGy7RwGRbYm4xhrMHHUumGSPhpOlIxtFKcUzeHD849ndJAkKB2CGgHIYQQQghRHDu3tPP9z95Jy65u0BqUHvMe/IBi70mlJGsD+A4orSgLB7FaEUun8a0llk7jao2FXLCCozWeyVyPKsiuU1hjCbsuqew2ay0Jz8MzhkjAZVZVFW9ZsIDz58xGHU7QhBBCCDEKdu7cyQc+8IHcgE6AmTNncuutt1JdXT0uPZ133nn89re/zS0/++yzww5hePbZZwctv+ENbxjV3oQQQojx5DhOLiCw/1mIiaLk2/8xogAGgPEcXjWWIQxD6QAeyz76hYGTgNOB07LPMznwRuCJQBlD8PFHiQ8nhMHzcDauH/6xrcVduYL0GWcdRodiPOjuLqBwCENVVRWQmc07nz5ARaOH3ZcQQggxFi699DIuvfSyEe/X0DCTL37x30in06xcuZyWll309najtWbKlCk0Nc1i/vxj0PrQv8ddtuz4Q57VeMmSpdx00820tOxi5crl7Nmzh3Q6RVlZOU1Ns1i69DjC4fCgfZ555sVhH//zn/8yn//8lw+ptyORs2Hfde/Xgf8k8zfBvAGPqdu20PTqy8yZMzcXTjWuwmFMTQ16wPcU+9MtLWPYkBBiLLjr1+Zery5QO2XKFGpqaorbEBAKhZg2bTqtrUP/ztmSfXZ2bCdz4/tE/NRFiNEReLnwNZl/wknMqq5h1qzZXHbZ5WPQ1fAEg0EuvfSt/PrXvxyyZg3wKnCwOxkiP/8psY9dh5WQMCHEJCUhDEIIIYQQQ7DW8tzerfxf6zo29O3BWMvuRJSkSRNyXGqCJbhKE/WShBwXhcJRGt8a+vwUwf0G3SmtwYe08QlpNxe2oFAEtUvSeBgsesCtQ47SBLSDZ3zQFlc5GGtQQG2olLB2qXBDtCR6cZVmeqSCMjfIGRWzOXfqHOaX1cpgOCGEEEKIInvy/pe4478fJZbwQStw9gu+Go3BJArIc5h0qSY6M0j34hL8kMZRCuUqXK3Rrsb3M9eQWikskPZ9VPa12u9hAN2fKqYUIdclaC0xz6MyFMIzhimRCNecdCJnzZqFexg3KQkhhBh9k3UM4+7du3n/+99Pa2trbl19fT0///nPqa+vH7e+LrjggkEhDPfccw8f/ehHC35es23bNv76133zAwcCAc4777yi9SmEEEKMta997WvEYgeflVSIo5q1hO+9Z8S7HW0hDGMxZCgBPJt99JsOvJfM4KuJxtm0YXh127agkskRHdt99RUJYTgKqc5OEmT+v5BP/2BDCWEQQggh9gkEApx44skABIODv7tNpfyD7TKmpk+fwfTpM8a7jSOes3HfNfJGMl+Xb88+nujf8JUvAnD22edyzz0Pjml/QzHTZuQPYWgd7Vg7IcR4c9YNP4ShuXnBmN3XPXNm47BCGFQ8jtqzB1tXNyZ9CXE0cl95Ke92f/YcbHXxA1YO1dvffkXeEAaA2zh4CIOKxSj50Q+JfvErRelNCCGOdBLCIIQQQggxwK54D6927aI3neCvHTtY37eHMidITaiEzlQcH0OpE8C30J6M0pboAyC4X3ACWFLWELI2F7bgoHBQ+Fg86xNU+y7FgtohZXw86+MOCG/wraEuWEqpG6Q12UfCT+NZQ7kbojedpNPGCWqHy2Ys5u/nnESZGxybN0oIIYQQYpLzPI//+fcHeO6x1/HRmTR4PcSXpP1fnhZhVKwFepvD9DSHMWGNKnUpDwYw1hJLp0n5Pp4xBLTGkgkaU0rhaI1nDDp7jMw6hTGWoNakjcGYTK1nDGnfRytFWSjEotpa/unUU6gtKRn1n0cIIYQ4FF1dXVx99dVs27Ytt666uppbb72VxsbGcewMzjnnHKZNm5YLh9i5cyd3330373znO/Pu98Mf/nDQrOAXXXQR5eXlRe1VCCHE0W3Dhg00NzePdxvD4nke5eXlLFkyjBnfhTjKqPZ2dPvuEe83nre4H0oIw3gNGWoBesfp3EVnzLDKnLVrCxftx31txYj3EeNPd3XSOYy6qqoqYLghDH2H3ZcQQgghxFhxNq7Pvd5YoHb27DnFbWYE/BkzcFetHHK7s0tCGISYaNw1+6IXCoUwzJ+/oLjNDNDU1MSLL74w5PYtA147O7bhSQiDEEMKFAhhSJ940hh1cmjOOed8pkyZQmfn0J823UEm/DZwkG2Rn/2E+LX/hJk2vVgtCiHEEUtCGIQQQgghgE19Hfxu50pe7dqFbwxd6QQ96SSOUsR1CmMtHakYDgqlNK4Cxyr6TGZbSDvoAeEJCoXFkjIeYWffn6IhJ0DMT+HvNwBPowhoDRZSxiOgndwYvdpQKWVukKB2aU/2UeYGmV9el32u5cza2UwNl43J+ySEEEIIMdntbe3i+5+5k82b94DjgHIK79RPqUMPYthvN6sgUevSeWwJ6akBSsJBjKPwjcXNBiwopXCUwlhL0vdRgFUKBbkH2e06+1opCAcCBI0h5nkEtMa3Fq01ZzU18p5ly1hQUzNmqfxCCCFGztrJ9Tu6r6+Pa665hvXr992MWVFRwf/8z/8wb968UT3Xjh07eOMb3zho3aOPPsrMmTOH3CcYDPJP//RPfPnLX86t+9a3vsXxxx8/5EDZBx54gPvvvz+37DgOH//4xw+veSGEEBPe5Zdfzjve8Q4+/vGPU3cE3yz7hz/8ge9973u87W1v42Mf+9h4tyPEqHM3bShcdBCzgLOBCqA8+yjb73UpECRzE+zBHg7g53mkgOhBHrWH0O94Dhk6bRzPXVTD/NzQWbdmxId2tmwe8T5i/KmOjhGGMOS/ZyATwhA97L6EEEIIIcaKszHz95Xl6AphMNNm5N2uWyWEQYgJxfNwNqwDIA2sz1/NggWLit5Sv8bGWXm3bx3wWm/fBicc2YPIhRgvqr0dZ9vWvDXeEf7/n0AgwOWXX8HPf/6zIWvagYeAtx1km4rFKPnWN+j7zg+L1aIQQhyxJIRBCCGEEJNSbzrJXzq2sb53Dzvi3azoakGjmBEpxw04tCX7iDguGoVnDTsT3XjGUO4Gc8dQSqFR+BiSxifi7AthCDouCT+NZwfPWBLQGuUrfGMyd0Jlpa2hzA3REK6gJdFLXzqJZw0RJ0BPOkGvl6Q8EOI9s47nb2YuGRTsIIQQQgghim/F8xv48b/dS280DVplAhjGyn73XydqXLqOjaDqw/hhTVBrPCCRTgPgW0Mw25+1Fp0NTDDWgrVYsteySmFtNrQhuy33ABylqCkpoTwU5AMnnMhZs5rG6icWQgghhu3DH/4wK1cOnlHq/e9/P52dnTz33HMjOtaxxx5LZWXlaLYHwDvf+U5++ctf5oIiuru7ee9738tnP/tZ3vrWt+K6ma/rurq6+PnPf85PfvKTQfu/+93vZs6cI+cGUiGEEEcm3/e56667eOCBB3jXu97F1VdfTX19/Xi3lfPHP/6Rm2++mdWrC80FJ8TR7dEH72MHMD/7mM3BZw7b38nA00Xsa7SdSyYcYiewDYY1UHy0nH4I+3hABzB1lHsZTcqYwkWAu27tiI8tIQxHJ93VOaz/b1VWVgFwzTUf4l09PVQ/8yRlcNCHlRAGIYQQQhxF3A2Zz9T3AL0Fao+oEIYZBUIYdkkIgxATibNlMyqZBGADmc8g8lm4cGHRe+rX2Jj/Pp8dZPp1AWf79rFoSYijUuCF5wvWpE84eQw6OTzvfvff5Q1hALiNg4cwAITvuJ34Nf+Ev/jYUe9NCCGOZBLCIIQQQohJJel73L1jJY/v3kCvl8JYQ1uiD5MdfJaIpglpF98YAtmgg4BywFhS+MR9j4gTyM386yhN2vqkjU9Yu7n1Qe2Q9NMYa7HW7psp2Ga2OUqR8D1crXFQGCy1wVLK3CB1oTKC2qEmWMIp1Y2UB0JMj1RwSnUjpQNCIIQQQgghRHH5vs89P3mM3//2r/hWgVKZAIbDodSwZ7XLpCUM6CegiC6KkFpWSVlpCN8YTDpN2HXxjEH5CqXAt5ZE2sucKnsIrVQmhEEpDKAHXKNGAgF8Y4h7Hkprkr6PZwzVJRGuWHwM58yazYyK8sP7uYUQQoyZYf4rM2G88MILB6z7wQ9+cEjH+sUvfsFpp43+vLqBQIDvf//7/N3f/R1dXV1AJnDhhhtu4Ctf+QpNTU0kEgl27txJOhuq1G/ZsmXccMMNo97Todq+fTtr1qxh586dtLS00NvbSzweByASiVBeXs706dOZOXMmCxcupLGxcZw7FkKIyScej/OLX/yCO+64g8svv5z3vOc9HHvs+NwQ19fXx3333cftt9/O1q2ZWaIGfWcixAR015OPc+eAZReYw75QhnOBN/3n98ahs9G1/xVqdzzO1o69bOnYy9aODrZkX29ob2drx97M51KjoDIcZsZXvkGv1oWLB3h+8yYu+u8fcMLMRi455ljecuwSls5oGNPfR5H/uQV39aqhC4YZwqB3jHxQhG7fDX19UFY24n3F+FGdHcMKYaiqqgLg7LPPpfT//kjJM08OWZuO9o1Oc0IIIYQQxZZKobMzTm8aRvmsWbOL2s5ImOkFQhh2t4HngStDeYSYCJzVr+dev56nrt/8+WMXwjBzZv7v6XwyQQyzAWf71jHoSIijU6EQBhsI4C1dNkbdHLoTTzyZ5ub5bMgGXR3MA0A7UHeQbcoYyr78ebrv/F3mHkghhJgk5C83IYQQQkxovjWs6m7jmT2b2R7rYl3vHnq8BLXBUqaFytiV6EUpRakTwFqLZwy96ShOdlbg/htvlMrcyJO2hhAWJzsaLqA1CZMZ4OBZkwlsADSKgHJJWQ8zoN5gcZRmfnktXak4e5NRoiYT/JA2Pm3JKLWhUv6m4Vgumr6AsDOcuXGEEEIIIcRo6u2K8sPP/obVr7eA44ByMkkGo3Sz+LApwIIXUnhLytDLauj1Elgs6WSShOehlUIphdN/3UomcMEnGwYGuS89dO7aVmGMyf5ImWvegOOQNj7VkRK0Uhw/bRofPf00KsPhsf2ZhRBCiAlq3rx53HbbbXzkIx9h586dufWxWIw1a9YcdJ8zzzyT73//+4TH8d/jlpYWnnjiCZ5++mleeuklenp6RrR/RUUFJ510EmeffTbnnXceDQ0NRepUCCHEiSeeyMsvv5z7XiOdTnP33Xdz9913s3jxYq688kouuugiqquri9qHMYa//OUvPPDAAzz00EMkEgls9u/p/t7C4TCLFy8uah9CjJdNra2Dlj1gffYB0F43lXOuunqs2yq6ELAg+9hfIpFg06aNbNiwjnXr1rJhwzrWrl3L+vVrSaVSIzrP8aedQeoD14y4v4e/+XUAXtmxnVd2bOff//RHGhpmcvHFb+aSS97CmWeeTTBY3DD84CMP5w9hGOZnj86unYWLDrbfls34S5Ye0r5ifOiOwiEMWmvKyvYF6NrS0rz1Khodhc6EEEIIIYrP2bIZlQ0q2ziM+tmz5xS3oRHwp03Pu10Zg97dhpkhn5cLMRG4a/ZFL6wuUFtSUlIwGGE0NTXNKlizhUwIg96+rcjdCHH0KhTC4C07HiKRsWnmMCilePe7/46vf/0rQ9Z4wGPAu4fYHnziMUL3/47k5VcUo0UhhDgiSQiDEEIIISYkay0b+vbys80vsD3WBUCvl6QrFcfRirZkLx2pGEnjE8gGLCilCCiHuJ/Gs4a0NQSzoQpKKTQKiyVlfCJOZh9HaQI6M2Bt/9tiXK1wCOBZg28NjtKZgW3BEsLaJeK4VIdKqQ2VcMHUZioCYWqCJSyrmk5AO2P1VgkhhBBCiKxVL2zgJ1+/n86eJGgN7n7XZP0JzmMRxmDBWkPtqfX0nlpNt5fCMxbtK8Kui28MyWxwWMLzcNTggGlHKbxsn8baXFiDtZaSQICU55EyPihF0vPwjCHgOMyZMoWLmpt5w9w5uCOcUVAIIYQQ+S1atIj777+fm2++mV//+td0d3cftG727Nlcc801vPOd7xyXmcJjsf/P3n3Hx1Gdaxz/nZnZXXXJknvv3YA7xYBjeiimxbRQQksgCSEhN4WQ5CZAAklIgOSGJDRjAgaDTTEdY1OMMca4994kW7bV25aZOfePXa0l2dpdyar2+81H0c7Mmdl3ZbGanTnnOZXMnTuXN998k+XLl0cHzuo650D11VazXUlJCQsWLGDBggXcf//9nHTSSUydOpWLL76Y1DiDg4QQQjTMiy++yGuvvcYjjzzCwYMHo+/TWmvWrl3LunXruP/++xkzZgzf+MY3mDBhAiNGjGiSvzUHDx7kyy+/ZNGiRcyfP5/i4uLocwPRz6Naa84991zuvfdeunbtetTPK0RbtKUsdmhV/+NwkE04eGUEw4ePqLU+GAyyefMm1qxZxZo1q1m7djVr1qyKvoccydix4xpVw8cff3TYutzcPTzzzJM888yTpKWlc9ZZ53DJJZdy1lnnkpKS0qjniUnFudYWGWAWk9YYe/Ma9fQSwtD+qOIiCuO0yczMxKhxHVenpsU+poQwCCGEEKKdMLduiT6OF8LQoUMHMjOzmrWehkgkXMHI3SMhDEIcI6wNh6IX1sVoBzBw4OBan+GaW48ePeO22Rn5bu7aGbOdEMetqiqsVStiNglNOLllamkC3/rW1fzhD78/7N5/x44dufbaG7jj6yUM/XxhzGOk/urnBCdPQbeh8y8hhGhOEsIghBBCiGPGwUAFiw7u4LOD29nrLyOvqgQTRbfkTDI8XvL9ZSSZFqYywoPVXJuAa2MaXswafQwNpXC0JujaeJQRnlkYhWkY2K6DrWt3gEkyLGzXxdYOXsID9bTWuECflCwsZbA/UE5x0I+pDCzD4ECggh4pGZzTZTCTOvYlxWremVWEEEIIIUT9XvnXPN55ZQm2NsJJBvFueCrVfEEMGpSpGTx1KBVD0liat5dQSTGGgpDjYpkGdo0O2YYKpy841YMjFZg1t0W4NepVSpHs8UAIMpKS0FqT4fPxnTGjOb1vXwlfEEKIdk7rlh+035o2btzYYs/Vs2fPo36+tLQ0fvKTn/DDH/6QlStXsnnzZoqLizFNk06dOjF8+HCGDBnSRBU3TF5eHs899xxz5syhvLwcqD14tnoAbbW6HTOOpOYAYIAVK1awYsUK/vKXv3DFFVdwww030KOHdDQVQoimctlll3HOOefwn//8h+eff56qqqpa78WO47B06VKWLl0KhP8uDR06lCFDhjB48GC6d+9Oly5d6NixIykpKfh8PgBs28bv91NSUsK+ffvIz89n27ZtbNoUns1+165Ds6TpOp8/q8MXTjzxRH7yk58wceLEFvyJCNGy/FVVFMUZSN9vwKAWqqbt83q9jBgxkhEjRnJVZGo1rTV79uxm+fKvWbr0K5YtW8qqVSvw+/0AjB07vsHPU1RUyPLly2K2KS8v44035vDGG3NISUnlvPPO55JLLmfKlLNJbqpZ7OKF3uj4IQyqoAAVDDbq6c0d2xu1n2g9RlEhRXHa1B1sqOOE3amysqMrSgghhBCihZhbNkcfxwth6Nu3X/MW00BuAte8zdw92OPlGokQxwJz46EQhvUx2gEMHtyy9wCTk5Pp1KkzBw7sr7fNjsh3c+eOcF+oVgiIF6It86xYhgqFYrZpTyEM3bv34Mwzv8HHH88H4JRTTuOmm27hm9+8GJ/Ph7lhPXryKagY17nN/fmk/v63lD/yWEuVLYQQrUpCGIQQQgjRrgUcmwo7yDu7N/DO3vUEtINXmezzl4YHminYU1UMVeC4bjTsQCmFpQwCgN8NYSiFGZl9xFQGtnZxtMbRGityQclrmIRcJ9phsLrjokLhNUwsw8Dv2phK4WqNRxmkWV7K7SCplo/eKVlc3H0EHX2pZHh89E/NkQFuQgghhBCtpLKsikd/8TLr1+SCaYEyoSH3EZs6iEFr0lM8XHbHZL5Mq2D9wYNUFRSgtSbV48HVmpAbIuS42G4Ir2lEy1VUB4m5KA2ayEBJFBpNssdDwLZxIjdHQo6D47poIMXj4YSuXbhx9Gi6psWeJU0IIYQQTcfj8TBu3DjGjWvcTL5NKT8/nyeeeILZs2dj23at617VtNZ069aNwYMH079/fzp37kynTp1ISUkhOTk5HHjq91NZWcn+/fvZv39/dHDuvn37DnvO8vJyZsyYwYsvvsgVV1zBHXfcQZcuXVrqJQshxDGtOvDnxhtvjL6/1wxjgENBCWVlZbVCGY6kbghPXXW31Qx90FozfPhwvv/973PWWWcdzcsSol0o2Zsbt03HAQNboJL2SylFr1696dWrN5dcchkAoVCIdevW8PXXSxk3bkKDj/nppx/jxgnHqKmysoLXXpvNa6/NJjU1jfPOu4CpU8OBDNXhNI0S775wAtcazQR+x+rdV0IY2peqKlRVVdwQhqysrFrLOj09ZntVXiaDaoQQQgjRLpjbtkQft7cQBp2egZuZhVFSXG8bY8+elitICNF8AgHMreH3KwfYEKf5kCFDm72kunr37p1QCIPy+zH25+N26doidQnRXlhLFsdtE2pnwUq3334HAwcO4oYbbmbo0GG1tjlDh+G/7kaSn3825jGSn3+W4PkXEDzn/OYsVQgh2gQJYRBCCCFEu+NqzerivSzI38rSgt0cCFRQFKwi2fDQJSkNl3CAQrLpAcId/cqdAK7W2K5bI/igemAahFwH0wyv9xomQdcBNA4uFuH1HmXiUSa2dtHq0Bi9kHZI9/jol9KBomAVef4ybO2S6UmiJBSgZ3Im53QdxMSc3qRZR9ExRwghhBBCHLXt63J57FcvU1DkB9ME6ygujzUmiKFue9elV+9sLvvleaytKubxdeso3x/CUoqQ62IoBTUGvJiR5aDjoogELkCNQAaFCxjVHWl1eJ9Uj4dK2ybJNDEMA22anN67N9eeeAK9MzMPG2gphBCi/WrKjCBxbAsEAvznP//h6aefJhAI1Apf0FrTtWtXpkyZwsSJExk/fjzZ2dmNep6CggK++uorlixZwvz582uFMoRCIV5++WVef/11brnlFm6//fajG9gmhBAiKicnh/vuu48f/OAHzJw5kxdeeIGDBw8CHDFspz6xttV3LKUUkydP5jvf+Q4TJ7avzodCHI3inTvjtunQs2cLVHJs8Xg8nHjiaE48cXSj9q+e1a0xKirKmTPnFebMeYWsrCwuvfQKpk27hrFjxzf8elq8EAY3/oc5Iy+vYc9Za18Z5NWeGMXh+IX4IQwdai3r9IyY7ZXWqIpydFrssAYhhBBCiNZmbdkcfdzeQhgA3B49jxjCUH1/38zd3dIlCSGagbllM8pxANgJ+OO0HzRoSLPXVFevXr3ZsWM7PXM6MXDTBvoCfYC+Nb6qGdu3SwiDEHV44oQw2P36ozt3bqFqmsbZZ5/H2WefV+/2il/9Bt87b2IUFMQ8TvqPvk/hJ4vRnTo1dYlCCNGmSAiDEEIIIdoFrTUHAhUUBiuZtXslG8v2o5TCUIrSoB9vJBxhd1UJIdfBUoc6sYTbGTjaocoJkaa8KKUwDRWOHiUcpODTVni9MjCVga2dwwYumIZBkrKwXSdyQVzhak2mJ4lSO4CNZmBaDlf2OoHB6R1JNj108qWFB88JIYQQQohW88HMRbz89KcEXcLhBKbZesVojUIz6axhXPPj83l14wb+sW4FpYEAFcEQPtOMBogBOFrjq1GvAgwFrqujAQ3h89jwuanPsAi6DjqyvxuZfRQg3ecjOyWZG04azam9e7X4SxdCCCFE23HeeeeRn59fa3BtRkYGF198MVOnTmXUqFFN8jw5OTmcf/75nH/++fzmN79h9erVvPHGG8ydO5eSkhK01vj9fv75z3/y2muvMX9+4wfJCSGEOFxWVhZ33HEHt99+O59++imvv/46H3/8MYFAAAjfQzmaYL6af0cGDBjAJZdcwiWXXEK3bt2OunYh2puSBAbRZPWQ6zEtSWvNggUfNcmxiouLmT79aaZPf5r+/QfwrW9dzZVXXkWfPn0TqyXOe62KXMuLxcjLTei5jsQ8igAH0fJUYSGQSAhDVq1lnRE7hAFAlZVJCIMQQggh2rzqmeUrgb1x2vbp03ZCGPbv38/mzRspNg3ygT1AbuT7HsIDn78AjD0SwiDEscDasC76eF2MdtWGDGn5EIZ//vMpLMuC8nI69e8es625czv2yae0UGVCtAOui2fJl9FFDZwA9AfGAxOAUaPHHHODc3V2DuX/+yAZP/xezHbGwQNk3HErJS/NPrqJsIQQoo2TdzghhBBCtGlVToivCnczL38z2yoKyfeX4XdsUiwPnXyplIT8GErhMcKD0lzt4tchtNZ4DDMaxqAicwO7aELaxatMDML7BV0bULhozEi7FMtDWcjB0S4ajSIyuA3om5qNqRT7/GUUBatIt3x4lEGXpHTO6TqYCdm9yPAktcaPSwghhBBC1BAK2fz7t7NZsmgr2jRBGXCkCedaaspw18VnGVz13clMunQcX+3J5ScffsiukhJ8ponftjENhWUY2K5bK1ihKhTCUCo6M4ZCodGYgAsYOhzIoACfZeHVJpWhEEopHK2xHZdu6WncOHo0J/fqSWaSnK8KIcQxS0sQpEjMvn37ooNuBw0axC233MI3v/lNvF5vsz7vqFGjGDVqFD/72c945513eOaZZ9i0aRNaa/bujdedVgghRGOZpsk3vvENvvGNb1BVVcUXX3zBp59+yldffcX27dtxExj8W1dmZiYnnngip512GmeeeSZ9+/Zt+sKFaEeKEhjkntG7TwtUIqrt2bObAwf2N/lxt23bysMPP8jDDz/IySefyrXXXs8ll1xGSkpK/TsZcT6rJXCN0jyKEAZjb+P3FS3PKA7HL8QLYcjM7FBr2U0gXEGVlYFkJQkhhBCiDVMlxRgHDwCwPYH2ffu2nRCG//53Og899EDcduaePS1QjRCiuVkb1kcfr4/RDsDr9bZKaIxVPTA6LQ23U2eMGNdJzJ07WqYoIdoJc9NGjJLi6PJ2YE3k683qlXNepf+K5YwePZbRo8cwdeoVdOnSpcVrbWqBadcQfPlFvAs/jdnO++kCUn//Gyp+/4cWqkwIIVqehDAIIYQQos2xXYddlcXsqSrh1d2r2B8ox2OYOK5LyHFINi0c7ZJbVULAcUg2PdF9lVIYhAen+Z0QqaYXpRSWMghFohiCro03Etrgi4QwaDS1urVo8BnWoVmEtcbVmmTLQ9AJEdAuHbzJXNd7DOd1G4zPsPAa5lHNFiWEEEIIIZrG3l0H+NtPX2LvgXIwzfhJy0o1bxCD69K1Uxrf++3l9B/Rgw+2bOV/3vuA3NJSiqqqsAyDStfFb9sowNXgMcJpEVprDKVwCIctVK9TSkVDGapDG9A6+jqUUhiGQXaSjySPhzP69OE7Y8fgMc3me51CCCGEaHeGDh3Kj370IyZPntziz+31ern00ku59NJL+fjjj3nsscfYsGFDi9chhBDHo+TkZKZMmcKUKVMAqKioYN26dezYsYM9e/aQn59PeXk5VVVVuK6Lz+cjJSWF7OxsevToQa9evRgyZAi9evVq5VfSMFpr9uzZw6ZNm9i3bx9lZWV4vV4yMjLo27cvo0aNwufzNelzlpeXs2zZMnbs2EF5eTlJSUl0796d0aNHHxMdMUVtxfvzY273AcndY884KJpWr1692bhxJ5999gkffPAu77//Lgcjg7mayuLFi1i8eBH33fcLrrxyGtdf/x1GjBh5eEPjSOmwNSQQhmMcTQhDURFUVUFycqOPIVqOKiwE4ocwZGVl1VrW6YmEMJQ2siohhBBCiJZhbtkcfbw5RrtqbSmEoXv3HjG37wNCgJm7u0XqEUI0L3PjoeiFdXHaDhgw8FAgQitx+vSVEAYhGsCzZHGt5a/qabdt21a2bdvK7NmzmDTpzGPj2r9SlP3lMbKnTEJVVsRsmvKvf+AMGYr/uhtaqDghhGhZEsIghBBCiDajJOTn84PbmZe/mdyqUg4Eygm5DkmmRQdPCkWhSizTwFQGloKQA35s/G54VmBLGeGYBQVKE57xV7t4lInHMPC7KhqmUD1wzVQGyYaHKjeE7bpYZnhe4ZB2SLO8DErvRFGwiryqUgyl6JPagY6+VE7L6cPJHfuQ7Y0xm4kQQgghhGhRH7+2hBf++RF+xwjPLNeQwIHmCGJwHU4c3Zs7fn8FKWnJbC8q4v4FH/N13l58pknQtvGaJl7TJOS60WCFoOPgOA4K0IACTKWwXRdDKVzAiJzPaq1JsSxs16XKtkEpAraN7bokeywm9urNlAH9GN2tG4YEhgkhxHGhGWOFxDHmr3/9K9/85jdbuwwAJk+ezOTJk3nnnXdauxQhhDgupaamMn78eMaPH9/apTS5kpIS5s2bx2effcbixYspKqp/OKvH4+HMM8/kxhtvZMKECUf1vLt37+bxxx/n3XffJRQKHbZdKcX48eO56667jsmf+/GqOM7g/mylUF5vC1UjqqWlpXHBBRdywQUX4jgOy5Yt5f333+W9995m06aNTfY8paUlPPPMkzzzzJOMHTuOb3/7JqZOvZy0tLRIizjX5nQCIQxxgj7i7r83D7f/gKM6hmgZRlFiIQyZmVm1lnV6Rtxjq7KyRlYlhBCirVFlpRAIorOy4ofSC9GOmJs3RR9vitEOwkGTXbt2a96CGiBeLZpwEEOv4mJUeRk6LX6IlhCi7bLWH4peSAY6AfVdHRo0aEhLlBST06cvnqVL6t0uIQxC1FY3hKH+/3rCUlJSGTJkaPMV1MLc/gMo/8OfSL/7+3Hbpt1zF25GJsGLp7ZAZUII0bLkiosQQgghWlXAsdlcfpAdFYW8lruG0pCfNI8vEpQAqaYXR2vy/WUEtUOK6TnUP0WpcOiCBr8TItX0opTCUiYh7QAQch08holC4TNMqpwQdTu4KKVIs3wYWhFwnfBzo/GZFvv8ZVjK4Lxug7mp73hyfBK6IIQQQgjRlti2zb9+M4cln29GWxYoE+JMKtestMY04PLrTuXCGydhmiYr8vby9tdfsTxvLwcrKzENg3IgYNtYSqGUOnSKCxhK4WgdDmHQOhwQAZEQsXAIg+u60e1KKTyRIIfsyEx2PTMyuPPkCQzu2LHlfwZCCCGEaBfaSgBDTW2xJiGEEO3X7373O1555ZUjhiAcSSgUYt68ecybN49LL72UX//61zUGTyfunXfe4d5776WqqqreNlprlixZwvXXX8+tt97KPffcg5LwxHavKDJzfX1yZGBcqzNNk/HjJzJ+/ETuu+9/2bZtC2+//RZz577GihXLm+x5vv56KV9/vZSMjEwuru54bMS5aJlAQKwqKDhsXTHwD+BDYAcwGLgNmHaE/c19eyWEoZ1QxeH4hXghDFlZWbWWdXr8QXyqrLSRVQkhhGgLzM2bSH7yCbwfvIeZlwuA9noJjRlHYNo1+KddAxL8Jdo5a+OG6ON4sWn9+g3AiHeu3YK6d+8Rt80eoBdg5ObiHEMDNYU47lRU1Aot+Gfk6yCwHlgHrDh1Eus9HjZt2sjgwW0jhCEWY8f2lilEiHbC8+UXtZbjhTCceOJJmA2ZNKod8F/zbbwfvo/v7TdjtlOuS8b3bqbUmE7wwotbqDohhGgZcndPCCGEEK2iKFjFx/u38NH+LewPlHMwUIHtungMg5DrUGIHMCMD0iylcDEJOg5+x0ah8JpmtDOaAhytcbTGUgqvYRJywyEMbo35H31GeIZgWzuEXAevaaG1xkXTMymTDCuJvf5Syu0gfVM6MCA9hz4pHTitY196pGS2xo9JCCGEEELUo3B/MX+667/s2VcGlgkeDxB3PrnYlEqos3NUzbauJiPNw52/vowRE8MdmSuCQV5duYp3Nm5GKfDbNl7TxGuahByHYCRQoTIUwhu5AVMdqmAoFQ5aUApXa4xIUIMLpHo8BGyboOOglMJv2zhaYypFx9QUJvfrx0VDh5AmHayEEOK41IC/ZEIIIYQQx7SVK1ceMYDBNE06depETk4Otm2Tl5dHWZ1ZwV9//XW2bdvG9OnTSU1NTfg53333Xe655x5ct/aM9tnZ2XTr1o2CggLy8/PDoYuErwM8+eSTBINB7r333ka8StGWFBUXx9zeQa7VtDn9+w/khz+8mx/+8G527NjOm2++zptvvsaqVSuO+tidOnXm/PNrhIzFGxhW533jSIyCg7WW3wduIjyTbrVdwDxgKfCnuvtHBmqKts8oLMQP+OO0y8zMqr3C60UnJaH89e9p1PmbJ4QQop0IBEh96AGSn/g7qs55gwoG8S5ehHfxIpL/8Shl//cf7LHjW6lQIY6euelQCMOmOG0HDBjYvMU0ULdu3eK22RP5bu7ZJSEMQrRjVo33qpo6AqdHvor/55eETjsd4LDrha3B6dsv5nZzfz5UVkKKTFgohJG/r1bQig18HWef0aPHNmdJrUMpyv76ONbqVZi7dsRuGgqRccv1lD/0CP6bbjm6560xcZUQQrQ2CWEQQgghRIsJujbrSveztfwgc/PWURoKkOVJQrsaDaRaXhztUhiqIuQ6JBkWljZqhC2Ev/tdG49hYEZnAtagIaQdLAwsZeAxDIKug64zDM9UBhkeHyHtUmWHcHDxKJMqJ0TIdRmY1pFLe47g5Jw+Lf3jEUIIIYQQCVj+2TqeuH8ulQ7hjsuWWeuCuwbQdc8Cm5Hj0H9AZ+5++Co6dMoAYHdJCZ9s28G7mzaTW1aKQThcLOg6JJkmmkMDZA2l0FoTsG1MpdCEgyQUgFJYhoHturha1wpoSPZ4QEFmUhKOq0m2LL41cgTnDx5EqnToF0IIIYQQQgghasnIyOCiiy5i8uTJjB07lrS0tOg2x3FYunQpjz/+OEuXLo2uX7VqFb/85S95/PHHE3qOXbt2ce+999bqUD106FB++ctfcvLJJ0fXbdu2jb/97W988MEH0XXPPfcc48aN49xzzz2alylaWWGc2eU7JCW3UCWiMfr27cddd/2Yu+76Mdu2bWXu3NeZPXsWGzasb9Txrr76OjyR4FggfqfheIMxtK4VwlAAXAsU1tP8z8BU4LQa64y8vNjPIdoMVVxEUQLtsrKyoo+11rz33jsoy0MlfsrhsK/vAyPjvFcJIYRoe1RZKRk3XIP388/itrW2bSXrkvMpe/wJAldMa4HqhGh61saN0ccbY7QDGDiwbYUwpKdnkJaWTnl5/cFX1dFoxp499bYRQrR9ZgLXC+whw6KPjXjhjC3A7dM3bhtz106cocPithPiWOdZ+Gmt5bVAVZx9xow5BkMYAN0hm5IZM+nwzbNRlRUx2yrXJf1nP8ZauZzyB//U4FAXY9tWvP/3dzxzZoPWOIOHUP6b+7EnTDyalyCEEEdFQhiEEEII0ezKQgHm79/MvP2b2R8o50CgnJDr4jEMqtwglXYIrwrP/GuqcIhCCIeA66BQ+Ewr2idFAa7W2DocnuA1LKqcUHR9tWTTg61dtNaEtINHmTjaxVDQKyWLkOtyIFBOquXllOw+dE3OYHhGZ4ZldMGQ1DwhhBBCiDbFcRz++8g7fPj2KvB4QBlQfW/ySOdukWCDZjur0xrDdTjtrOHccu8lmKYZ3fTZjh08+/UKAnaIwqoqvIaJ1zQJOA5aa/yOEz4XjuwTDVaAaDhD9ToVWU62LPyOg6s1rtYEHQdHu6Ah2fIwMCebm8eOoU+NDrdCCCGEEEIIIYSAHj16cMcdd3DxxReTlJR0xDamaTJx4kRmzJjB7373O15++eXotvfff5/FixfXClGoz2OPPUZlZWV0edSoUUyfPr1W4ANA//79efzxx/ntb39b67n+/Oc/M2XKFCxLuvK0V0VxOqBmp6W2UCXiaPXvP4Af/ege7rrrJ6xZs4pZs2Yye/YrHDx4IOFjXHfdDbWWdZzBFqrGve4jbi8vQwWD0eU/UX8AQ802b9RYNvZJCEN7YRQWkgW8DxQd4augW3cODhxE166HZlpWSnHrrTcQCoXqPe45wKiy+gcECiGEaIP8fjKvuRLPksUJ76JCIdK/fzva6yN48dRmLE6IZlBRgbF7JxA+74l3Bt6/f9sKYQDo3r07mzbVHx9RHb1g5EoIgxDtmRUnhMHt1BndsWMLVZMYJ5EQhp07JIRBCMBTJwBtSQL7jB59bIYw+P1+nvl4Pjc99Ah97vpeQvskvzADz6KFVDz4MMGzz4u/QzBI8n+eIPVPD6L8/uhqY8liOlx0DiXPvkDwwosb+xKEEOKoyJ1bIYQQQjQL23VZV5bP1vKDvJW3jgPBCrI9ySgNWkOa5UVrTZUTIqhtNGBqAxUZRKcIDzoLuDYew8RSRniWYACtCboOHsPEa5gEtYPtOpg1C9DgNSyyrCSq3BBVTghHu6RbPkpCftItH9N6ncgF3YaS7W1Ywp4QQgghhGgZJYWl/OXuF9i+qxg8Fni9ie/cHEEMrkuK1+TqO8/iG1PHRVeXB4J8lZvLq6vXsP7AQZQCQxmEHIek6MCJcC2mUjha49p2NGRBEe4g60SCymytMSKdrrXWeEwTyzCotG1SLAsXMLTitD69mTZqJINzcqLn0UIIIQRa/iYIIYQQQgDcddddnHrqqXgTvJ5gmia//e1vWbt2LWvWrImuf+WVV+KGMGzevJl33nknuuzxeHj44YcPC2CoppTiV7/6FV9++SU7duwAYNeuXcyZM4dp02S22vaqqEbn0CPpkJ7RQpWIpqKUYtSoExk16kR+85v7+eST+cyaNZN3332bQCBQ736nnz6Z/v0H1F4Zb8ZL141dy8GD0ccaeDVe8cBcYDvQL7Js7t2bwF6iLTCKCvEB59azvers8yh/5LHD1qemplJcXFzvccsBJSEMQgjRfmhN+k9+2KAAhmrKdcm481aK+vXHGTmqGYoTonlYWzdHA8o2JdB+4MBBzVtQI3TtmlgIg7lnd8sUJIRoFtbaNTG320OHt1AliXO7dkP7fKgY1zTMndtbsCIh2i7vwk9rLccLYejYsRM9e/ZqvoJagdaauXNf5/e//w27du1k3/d+wJ8feIi0+36R0P7W9m1kXvstQhNOpuqW2wmedQ46I7NWG2NvHr7X55D8n39ixgioSvv5TyicPAVSJehYCNHyJIRBCCGEEE0q5DrM37+FD/M3kVtVwoFAOQHXxlImlU6QkONgGeG4BKUURmSwmK0dqlxINjwYVAcxgBvZ5lUWHsMk4FQPVtORY0Cq6aHMdXG1JqQdLGUQ0i5eZdAtJYPSoJ9KJ8ig9E6c3rEf2d4UTszqTqrVgEF8QgghhBCixaxavIl//vY1ym0NphkOYGgMpcIJYEfLdenWJY0f/eEqevTvXGvTiry9PLX0a4qqqthfUYmhFB7TxB8KYbsulaEQXtOMnPeGz3NNpXBcjaHC57taa5RS0fNjr1IEXTe63tUa23UxlCIjKYnMpCS+M2Y0E3v1PPrXJoQQQgjRDFatWsX06dP5+uuvKSoqIiMjg5EjRzJt2jSmTJnS2uUJIYQ4TkyePLnB+5imya233srdd98dXbdw4cK4+82ePRu3xgDqCy+8kAEDBsTYA3w+H7fddhu/+tWvouteeeUVCWFoxwqDwZjbs7I6tFAlojl4PB7OPvs8zj77PEpLS5gz51Wef346q1evPKzt9dffePgB4oWourGvYxoHD80BvAbYlkDNGpgJ3Ft9jAP7E9hLtAWquCjmdp2dfcT1qalp8UMYyiWEQQgh2gvfqy+T9OrLjd5fBQJk3HoDRR8tlMFKot0wN26IPk4khGHAgIHNV0wjde/ePeb26uGFRoyBhkKINk5rrHWrYzaxhw1roWIawDBwevfB2lz/O6yxc0fL1SNEG2Xk7sHcUTuQ5Ks4+4wZM/aYmkRp+fKv+c1v7uXLL7+Irnv66X9z02dfMrK0lNQ//SHhY3mWLMazZDHasnAGDsLt2g0cB3PnDsxdOxM6hrk/H2vrZuwTTmroSxFCiKMmIQxHKT8/n7KyMsrKyrBt+6iONX78+CaqSgghhGhZWmu2VxSyvmw/7+5bz87KItJNH1ZkwFia5UVrCGqHoHZwXI2pFKYyUJH/GUBIO3ixsAwD5arwrMBaE3QdvIaFzzCxXQdbu5i69kwhXtOiozeFMjtAlRNCa8jwplAaCjA4vRNndxnEyTl9oqEPQgghhBCi7Zn1j/eZ++pStMcDyjh05SqcwhXWwEwFTXX0QSKNde3HrsvYCX258/5v4fV5opsc12X9gYO8vm49i3buQgM+08TVLkmmFQ1TqA5WCDgOlmGAOhS4YChwtcYwjPD3Gs+dZFl4tabSDmEZBkHHwdGa3pmZXHviKCb26kVWUlLDfhBCCCGOH02QPyRETQsXLuSJJ56ILj/wwAP069ev3vbTp0/nT3/6E1prdOQc5+DBg3zyySd88sknXHjhhfzpT3/CiDcTsBBCCNFKxo0bV2u5uLiYqqoqkpOT691n/vz5tZavvPLKhJ7rm9/8Jg8++CCVlZUArF69mvz8fLp06dLAqkVbUOg4Mbd3yMlpoUpEc8vIyOSmm27hpptuYeXK5cyYMZ05c16hoqKcnJwcLrjgosN3UnHOf+OEyRoFBdHHbzag1poxMkpCGNoNo7Aw5na3nlCX1DgDbMsBVVra2LKEEEK0ICN/H2m//J+jPo61bSupf/4jFf/7QBNUJUTzszZtjD7eGKMdQMeOHdtk2F28EIbcyHdzz+7mL0YI0SyM/H0YBw/GbGOPPKGFqmkYp0/fmCEMdQeeC3E88iz8tNZyBeFQ1FhOOmlMs9XTkvLycnnwwd/xyisvHbYtFArx29/+ihnPzQTHIfWRhxt0bGXbWBvWw4b1japN1bg+KoQQLUlCGBpo//79zJkzh4ULF7J+/frojfCjpZRi3bp1TXIsIYQQoiV9XbSHt/euZ1PZfg4GK6mwA1jKoMIOYmsXg/CMv0qB0uHhb67WVDohUk0vKjIkTkVmKQ65NpbpxatMAq5da7ydQpFieSkPBXAJhzN4lEnQdUkxLbI8yViGSabWnNV5IKM79KCTL5U+KR2OqWRBIYQQQohjib/Sz8M/eI7N2w+CxwM+75Eb1jyda87BpVrjNeBbN5/O+deddtjm9QcO8PyylewsKWZfWTlaayzDoCgYxNEax9Ukew4FNijAUArbdTGUwkVjQvT81GMY2K6LExmkqKPbNF7TolNKCqahuGjIEL41coQMVhRCCCFEi5s9ezZff/01SikGDx4cM4Bh0aJFPPzww9HwhbrX5LTWvP3226SmpvK73/2uWesWQgghGiszM/OwdWVlZfWGMGzbto2dOw/N1pSSksLo0aMTeq7qtp9//jkQ/lv5ySefMG3atEZULlpTKBikKk6bzJyOLVKLaFknnjiaRx4Zze9+9yCvvz6bQCCAz+c7vGG863rajbnZKDg0uGNxA+r7ikNBtcaBAw3YU7QarVHFRTGbuNnZR1yfSAiDUSYhDEII0R6k3v9bjNKSJjlW8r/+gX/aNTjDRzTJ8YRoTubGDdHH9Q8RDhswYFDzFtNIXbvGD2FwASMvFxwHTLNF6hJCNB1rzaq4bewRo1qgkoZz+/SNud3cuaNF6hCiLfN+/lmt5SVA7PhdGDNmbLPV01I2bdrIOeecQVVV/Ve633//Xd56ey4X//xXuJ27kPaLe1BxwmWbgk5OJjR+YrM/jxBCHImEMCSoqqqKRx55hJdeegknklyvW+CPhBBCCNEWFQerWF6cy8KD2/mqaDeWMujgSSLk2qSYXgylCLkuITeEQmGg8JlWdRwDBuEghqBrk2R6MByFq8EAQtolSWt8pomtHWztYtYccafBa1p0SUqlNBig3A6ilCLJSAIFF3QdwpmdBtAnte0lHAshhBBCiEM2rdjOo798mdIQ4U4F3nrCF+qqPjVs6ssytkPH7GTueuBK+g3vedjmfWVlvL1xE+9s3IyrNR4zHDeWZFkopQg6DgpwtKYiGMQb6Sihta41+FARPhc21KEwshSPh5Dr4rdtNFBl2ziuS4fkZE7t05tv9O/H8E6dJFhMCCFEQjTy90I0rcWLDw3xuvDCC2O2/eMf/xg9/9GRkKmOHTtSXl6O3++Prp81axZTp05lzJhjY0YQIYQQx5b8/PzD1mVlZdXbfsOGDbWWR40ahWUl3h1nzJgx0RAGgPXrGzcLlGhdFQWxZz8ESMvOaYFKRGtJS0vj29++sf4G8T6qubFDGFSN37GGTPNzENgF9AGM8jKorISUlAYcQbQ0VVGOCoVittEd6gthSIu5XwWgysoaW5oQQogWYq1YRtKsmXHbOb37Epw8heQZz8Rsp1yX1Pt/Q+nM2U1VohDNxtzUkBCGgc1bTCN17x47hCEEHAC6OA7Gvr24PQ7vnyCEaNvMtWtibteWhTN4SAtV0zCVPXqSC+wAdka+7wBuBM4GzF07w9coZJIYcRzz1Alh+LyedjWddFL7v+89aNBgTjjhJL788ouY7X75y59y+ulnkPWdW3G79yD9B9/FKClu1toq7/gBpMW+7iWEEM1FQhgSUFhYyLe//W22b99eK3ihqTq+S5iDEEKI9mJ/oJw3c9fyReEOCgKVFAYrMZTCUIqCYEVkMFp4sJmhDgUu+F072g4ApVBaE9IuPq3xGiZ+1448S3j2XwNFiuWlPBSASGCDqQxCrkuyaZFseFFeg24pGXyr9wkMTOlI16R00qwjzCoihBBCCCHajNef/Ig5/12E6/OBMqExkzoomiaEQWtwHEaO6sGPHr6apJTDzyW3FRby5vqNfJ2bR25pKRqNZZgE7PD5q6EUXtOMBI6Flx2to6EMusZ6V2t8lknQcXAjgxKrj2EqRbJp0jE1lYDjMLpbV24dN46u6XLzQAghhBCtZ/fu3RQVHZqB9Ywzzqi37eLFi9m8eXP0/tmoUaN45JFH6N27N6FQiBdeeIGHH344un369OkSwiCEEKJNWrp0aa3lHj164I0RHrl169ZaywMHNmwQyIABA2IeT7QPlQcOxG2T0kFC5I9r8QYvxOk/ZhwMhzBUAtsb+NRLCYcwABgH9sed9VK0LlVYGLeNm3Xk95PU1NSY+5UDqlxCGIQQoq1LfeiBuG3c7GyKZ7+J26cvOjOTlL//LWZ730cf4vn8M0Knnd5UZQrR9Px+zB3hs12XREIYBjV7SY3RrVuPuG12A10Ac/cuCWEQoh2y1qyOud0ZPBR8bas/+7e/PY3Vq1exb9/eI3a5GkY4hEH5/Rj783G7dmvhCoVoG4zt2zB376q1Ll4Iw6BBg8k+BgJ4lVLcf/8fOffcyTHb7d+fz29/+ysee+yfBM+7gKKPPiPju9/B8/XSmPs1VuUP7qby5/c1y7GFECIREsIQh23b3HrrrWzbtg2oHbwg4QlCCCGOB452WVeaz7KiXN7dt55yO0CONxW/HcRjmHgNE601ZY6NRlPpBEk2D3VEU5HAhYBrk2p6MZWBq93oDMCO1nhNC1u7hLSDQkUnAVEavKZFZ18alXaAUjuAQpHh8dExKZVzuw3m1E596eBNJhh0WuXnI4QQQggh4rNtm7/84DnWbNgHPi8kJ8ftVBzX0QQxaI3hOlx45Xi+defZRwzarAgGmbd1G6+sXhMNVDCUwmeGL6cFCF8bqrJtbO1iKIUdeU1mJIih+nv1bNAAljKwLIOA4+BqB9t10Vpjuy7pPh/dMzI4d9AApvTvjyWp8kIIIRpBbl2IprR9+6HhXZZlMWhQ/Z1a33nnHSB8juTxeHj88cfp1i3cQcvj8XDTTTexa9cuXnzxRQA++eQT/H4/SUlJzfgKhBBCiIabPbv27LCxQoig9t9LgK5duzbo+ar/XtZ3PNE+VBXFHzSdkpnV/IWINkvHudanXDfmdqMgHMKwkYZfFv0KuKL6OBLC0OYZxUVx2+js7COuT0lJiblfOaDKJIRBCCHaMuurL/HOnxe3Xdkjf4/+Ta/45a/xLPos7qCnlL//jRIJYRBtmLl1S/S8OBeoitN+wICGhSC2lB494ocw7ATGAcaO7XDyqc1ekxCiaVlrVsXcbo8c1UKVJC4/P5+9e/Pq3b6jxmNjxw4JYRDHLe/H82stu8AXcfaZMOHkZqunpZ100hiuuupaXn75xZjtZs78L1OmnM3UqZfj9u5D8dwPSH7qX6T8+SGMstImqcUZMJCyRx4ndOqkJjmeEEI0loQwxPHyyy+zbt26w8IXfD4fZ555JqNGjaJ3796kp6djWfLjbG67du1i1apV7Nu3j1AoREZGBv3792fMmDH4WjEpTmvN2rVrWb9+PYWRNPKcnByGDh3KiBEjjjiYQwgh2jqtNZ8c3MY7e9ezq7KY/f4yQtrFUgbldhEh1yHZ9ACRkCIFSocHnlU5IZJNC6VUdOZfR2sc7eI1TKocN7yP1mg0CkixvJTbAXQksMFSBrZ28RoWHmWQ7kmiT2o21/UZw8C0HLqkpsugNCGEEEKINm7Xljz+dNfzFAc1WBYk1fjsXvOzcmNGizYmhMF1SfeZ3H7fVE46bcgRm+SWlvLp9p18sGULO4uK0YTDF0KOg2UYaBUOCyOyHqUIOS6eyLlpdeCCijz2GAYh18WIhDFowGMYaK2xDIOclGQqgiF6Z2Vy4+iTGNOju5znCiGEEKLNyMsLd8ZSStG9e3dM06y37cKFC6P3Q6ZMmXLYgFKAG264IRrCEAwG2bBhAyeddFLTFy6EEEI00ieffMJXX31Va93ll18ec5+CgoJayw0NYejSpUut5aKi+INvm5vXW//ffAGWdfjPJ1AS/98to3Mn+dkex77Yv48DhC9pupGvmo/7lpUwNsbvh1kc7o+0rhHPvb7GY2/hQQz5PUzIkf5bb5HnLSuO36ZzDuYR/h3T09Nj7lcOGKWl8l4kRERr/XcuRCwp//ln3Dahb14El11KdJokr4n/sX9gnXFqzGAn7/x5JG1ah9sGB4Y2J/lvvf3wbD505roxgfbDhg1pk+c1Xbp0IjU1lYqKinrbVM+v7d2zC90GX0N7I/+dixZVUYG5bWvMJvqEE9rc+1OfPn1YuXJ5vdt31njsy92J4W17g57lv3XREpI+qR3CsBYoibPPKaec0ub+mz8aDzzwIB988B5FcYKH77nnR0yYMIE+ffqA18S560eUX301vj//Ce8LM1CVlY16frdnT0I//in2Td9Bmdahzz1CCNFKJDUgjqeffjraYUxHBgRMmzaNe+65h8zMzNYs7bgyb948/vnPf7J27dojbk9JSeHyyy/n+9//Ptn1JH03h1AoxIwZM3juuefIz88/YpuuXbty4403cv311+PxeFqsNiGEaKySkJ9lRXt4b98G1pbuw2dY+AwTDaRZ4Y8wVXYIl3DYgqt1ZDZghVKgtMbWLq7WeJRB0HUwI4ELIe2SbHpwtEvAtVGEB6cBoDUeZdIpKQ3bcSgIVWEAHX0pDErvyFldBjG2Q89o8IMMTBNCCCGEaLs+eHEhL/x7AY4vCQwz/hWoyPlik9PhwC9sh969MrnnL9eS3SWrnqaaxbt38/TSZVSFbCpDQQylSLIsHNclaNsEHQdHa5I9kcAxrTE4FNJgGgaO1hiRIAatNT7LQtk2oUiHJ8d10VoTchzSfT5SPF7OGziQa086AZ8EfAohhGgCzfEnVRy/anYSjTWYJy8vj7y8vOg9tbPPPvuI7fr27Ut2dnY00Hrbtm0SwiCEEKLNKC4u5je/+U2tdWeffTYnnHBCzP0q63QkjDcLeV3Jycm1lkOhEMFgEK9Xuha2J1UJzFyf2rFjC1Qi2qq/rVzJ2zG2X5ufz9gY21VJuLv3+hht6lNzaIhxYH8jjiBakkogjEd3OHL/uNTU1Jj7lQOUlYYvHsikQkII0eaoXbuw5r4Rs422LPwP/vGw9e7IUQRvuAnf9Gdi7u97/FGq/vP0UdUpRHMx166JPt4Up61hGPTt2695C2okpRS9evVmw4b6z96rBzsbO3e0SE1CiKZjrluLityQdYB9QHeg5icsZ1Ts64mtoVevXjG376jx2Ni+vVlrEaLNCoWwPvuk1qrPE9jt5JNPaZ56WkmnTp158ME/cued343ZrrS0hBtuuJZ33/0wel9Ed+6C/8+P4P/VfXj/+zyeN1/HXPpVzLA4AO3zYZ91Ds6V38K59DKovj9iO03ymoQQ4mhIz+4Ytm3bFu0wVj2L4W233cZPfvKT1i7tuBEMBrn33nuZO3duzHaVlZX897//5Z133uHxxx9n/PjxzV7b3r17ufPOO1m3LnbG/L59+3j44Yd56623eOKJJw6bxUIIIdqKgmAlb+au4fOCHeT7yygO+TGVokKFCDo2plK42ozM9gtKhy8XBdzwNlMpbNeNBi4EXQef6SHkOrjUvriUbHrQGkLaIeS6aBSOdjGUwlQGlmUwJi2bm/uOZ1B6J3yGGe3ALYQQQggh2ibbtnnsnhdYvmI3JPmgzgCCuJo6iEFrVCjE6ZOH8J37ptYbjFji9/Plrj28sW49Gw4eRAMewyDounhqBn8phUk4rKEyFMJSBqFIvap6u2Ggncj5r9boyMtK9ngwbBsNpHq9VIZCdEpLZdqokUzu14+OqQ0bnCGEEEII0VKCwWD0sWnWP3vH8uXhmXOq76edfPLJ9bbt2rVrNIShtLS0iSoVQgghjo7ruvzP//wP+/bti65LT0/nvvvui7tv3RCGhoYnJCUlHbauoqJCQhjamYo4s4IBpOTktEAloq2Kd7/bjXNtVBUXA4nNCFzXVsAFDEDtlxCGtk4Vxn4/0RkZUM/17tTUtJj7lhO+dk1FBaTFbiuEEKLl+Z76d9zBScFv34Dbr/8RtwV+fi/eF55HhUL17u+Z/Qr++36L7t37qGoVojkY6w5N1hjvvLdPn774fL7mLego9OzZU0IYhDhGmatXRR9vBoYBHYCRka9RQL+qSoYVF5GV1aFVajyS3r37xNy+k0PXDowdEsIgjk/mki9RZWW11sULYejYsSMDBgxsvqJayTXXXMesWS/x8ccLYrZbuXIFd975XZ555jmMmn0tszoQ/MFdBH9wF6qwAPPLLzG2bsHYuRNVUQ4eDzo5GXfAQJxhw3FGj4HUVCyr/j4JQgjRWiSEIYa6g+t79uzJXXfd1UrVHH9c1+Xuu+/mo48+qrXeNE26detGeno6e/bsoazGCU5hYSG33XYbzz77LKNHj2622goKCrjhhhvYtWtXrfVJSUn06tUL13XZs2cPgUAgum3t2rXccMMNzJw5k+zsI6eRCyFES9Nas7uqmC8KdjI3by3FIT9ZniSq7CBJpoWlDGzXxY8ODzZzgqSYXlQkUsFQCldrAq6DxzCwCd8EMgBbuyQDSaaHKidEeAjaIaahyLJSSTY87A+Wo9F082UyMrMr3+g8kNEdeuA15EOUEEIIIURbt3/PQe6//WkKAxo8FiQfPnCgWeK06uuT7GqSDJcbf3wup184JuYhvtqTy7NLl1HqD3CwqhKlFD7TJOg4hBwH23FwtMZb4waBoRSO1mg0ikMDDRXguC4pHg+Vto2rw+fQrqvRChw0mb4k0nxeJvXpzXcnjiejDXcKEUIIIYSA2jNzl9XpcFLTkiVLoo979epFp06d6m1bc0BpVVXVUVYohBBCNI0//elPfPrpp7XW/f73v6dbt25x963ZLwCoNwiyPkcKW6h7TNH2lZeUxG2T3LH+cyRx7DOMOFdJ4+TTquIiAHY34rn9wF6gB6D25zfiCKIlqYKCmNt1jEE8aWmpMfctr36OsjK0hDAIIUTbUlGB97npMZtowyBw9z31b+/WjdC0q/G+8Hy9bZTj4H32KQK//X1jKxWi2Zhr10Qfb4rTduDAtj3YsVev2EEn1SMQZKCzEO2PsWZ19HH1u1YR8FnkC4CrvwVA9+7d+fjjhXTu3PoTucYLYQgA+UA3wNi+rSVKEqLNsebPO2xdvBCGCRNOPiYnG1VK8dhj/8fpp59CaWnsa9+vvz6HXr168fvfP3jEn4XOzsG+4JvNVaoQQjQ7CWGIobBGqrRSinPPPRfLkh9ZS3nqqacOC2C4+uqrufPOO+nSJfwhxHVdPvroI/7whz+Ql5cHhDvs3X333bz11lukp6c3S22/+MUvagUw+Hw+7rnnHqZNmxbtkFhZWcmsWbP461//Gu0gsWPHDu69917+9a9/NUtdQgjREGtL9jF371rWlO5lr7+MkOtgKYMy24+tHZK1NzywTIFCYQCO1lQ54Vl/qynA0S5JysKMDEir3qoBr2Gitcbv2rhogm54BmBXazyGhWEoRmV249a+ExmZ2fWY/BAqhBBCCHEs+vSNr3j6kXexk5LBtKDmeIE6s7ZpEgxiUOqwfetVt5lt0zUnhf959Dq69OxY724B22bF3n3MXbeBr3PzUEqRZFmEXBefaWIohaEUKvI96DhorTEjAWSKQ0EMlmEQcl2MSM0aMA2DtEgQg0H4vDfk2CRZHs7s14ezBw5kWKeOmDWTn4UQQogmJddWRNPJysoCwsFTubm52LZ9xHtlCxcuBML308aNGxfzmKWlpdHHNUMehBBCiNYyY8YMnn322Vrrbr31Vr75zcQ6BdadeTMUY9bZIwkGg4etO1IwQ0sKBp1Wff72Jhh0KC8qjtkmBXAsH478bI9bKs5nNUe79f+3pzWquBiAPY18/q2EQxjI3y//jTdSS/3cPAcOxNzu5OTUW4vPlxJz3+pPY3ZhMU5O58aUJ8QxTd4fRWtKmjkTVVIcs03w/AsJdO8FMX5Xne/9kOwYIQwAnhdfoOx/fgXHaZ94+W+9bVJFhRiRsQAA3wXGAhsJBzJsIhwuVq1//4Ft+t+ye/eeMbfvjHw39u0jWFIOcq28SbXl3w3R/qWsXBl9vDpGO4Di4hIyMrLbxO9kt26x35cg/N7UDTC2bmkTNcfTHmoU7UvKR7VDGPYC8eKSxo2beMz+Lnbr1pO//OVRbr/9O3Hb/v3vj+H1JvHzn/+qSWs4Vn+2Qoj25fi8epKgyspK4NCMhgMGDGjlio4fRUVFhwUV3HPPPdx+++211hmGwTnnnMMJJ5zANddcQ25uLgD79u3j2Wef5a677mry2hYuXFhrBgyPx8PTTz/N+PHja7VLSUnhpptuYvjw4dx8883RjhYLFixg8eLFnHzyyU1emxBCxONqzYayfOblb2LBgS1oND7Dg9aaVMuLAirsIBpNlRvEqywsZQLhDtSG1tjaxWOEB6e5hAeguZH1yaaXSieIo12MGt1ITKVItbx09aWxP1BB0HXonpTBSR16cGanAZyU2R2fKaclQgghhBDtweP3PMeSJTvRqSmQWs+sWtXBWjUCFRIOYkiErvE9FGLMmF786C/XYppmzN2+2LWbWavWsL+snPyKCjThIIWCqioc7eK6Lsk1ZqusDlwIuS5e08SJBDKoGufCPsMg4LrhoIbojgpDQU5yCpZp0L9DB354ykS6NFNYpBBCCCFEcxk8eHD0cTAYZNGiRZxxxhm12ixfvpzc3NxouOqECRNiHvPgwYPRx5mZmU1YrRBCCNFwc+fO5Q9/+EOtdZdffjk//elPEz5GSkrtAa9HClWIxe/3H7Yutb5rLqLNqigri7k9ValD18zEcSneZARurGxavx8VDGIT7vydqO7AAGAgUH3mrQoLGnAE0RqMgoOUAv+aCfKRAAEAAElEQVQGciJf2TUep2Z1qHffeBMWlRG5Vl9WGrOdEEKIlpf00gtx21TdfkfcNs6QoQTOPR/fB+/V28bM34f3ow8JnndBg2oUojlZ69fVWr408lXNBdZOf4ENKals3bqFESNGtVxxjdCjR+zBzgVABZAKmLt34Qwe0hJlCSGOluNgrV8bXVwTp/nQoUMx2sgkLb169YrbZgdwMmAUFqIKC9DZOc1dlhBthjpwAGvlilrrPk9gvwkTju2xgZdeegUffzyfF1+MHfQG8MgjD1NRUcH//u8Dbea9TwghmoKMdoyh7k2JujfORfN56qmnqKioiC6PHz+e2267rd72Xbp04cEHH+Smm26Krps+fTrXX389HTrUf+OpMR577LFay7fddtthAQw1TZgwgVtvvZUnnngiuu7RRx/lpZdeatK6hBAiFldrPj24lQ/yN7Kp7AAHAuUoBaYyOOhUogCPYWCq8IcdhYFCE9R2dOBZ9SAzpTUh18FSBkHXQUc6i2gNpqFIMb1U2AEAAq6NgSKES4aZhIOmf1o203qexOROA+J2NBFCCCGEEG1D0YESfnn1PygIaPB5IS3BgQBK1QpiaDKuxnJsLvv2qUy9ZXKcppqNBw7y1vqNfL5zF5Zh4DENlIIk00JFQhZcV2FrTUUwRJIVjlOoDlwAcFwXUykcrTFqvCafZWFpTVUohFIKv2NjOy4+y6JfdgfOHTSQU3r3IqVGuIMQQgjRrJrhT684fg0ePJjMzExKS0vRWvPoo49y8sknR2fndhwnet9Ea41lWUyaNKne4+Xl5VFaemiwTyIdvoQQQojmsmDBAn7xi1+ga3zOP/fcc3nggQcadA+rbl+S6gk/ElVVVVVr2bIsfD5fg44hWl9FeXnM7WnS6fS4Z6jYvwM6xnVUIzIr9l7Cg89iuX3Uifxw9Ur6A0fq6WZICEObZxQUsgf4WX0NFnxE+oCevPXWBwwbNrzWpvT0jJjHdoBKQJVKCIMQQrQl5rYteJYuidnGHjGK0CmnJXS8qu9+P2YIA0DSCzMkhEG0KWaNQc1HYgDdzphM17R0Jk+e0jJFHYWePXvHbbMLGAaYO7dLCIMQ7YS5YxuqxrW/eCEMw4aNaN6CGiA9PYOsrCyKi4vrbbOjxmNz21ZsCWEQxxHvvPdRda7PxQth8Pl8nHjiSc1WU1vx4IN/YvXqVaxevTJu23/96x/s2bObxx77v7jXqYQQor2QEIYY+vTpAxxKIi8qKmrNco4brusyZ86cWut+8IMfxO3kcMoppzBu3DiWLl0KQEVFBe+++y7XXnttk9W2ceNGVq1aFV1OSUnhlltuibvfrbfeynPPPRftbLF8+XK2bt3KgAEDmqw2IYQ4Ett1WVOyl9m5q1hVkofPNPE7ISzDwGdYOK5LFSEUigo7SIrpCb/fahelFFprgtrBwiSoHVAKBTjaJdn0odGE3HA3j+q3aQPwGhadfan4XZsyO0COJ5WxHXpwRsf+jOvQixTL22o/EyGEEEIIkbhP5izmyYffQmdmgOmBxvT/rxHEoIGjiuGyXTJ9Bnc9NI0ho/vGbKq1ZvGuPby9YSObCwo4UBH+TG4ZBgHbBsKhZB4jXFE0fExr/LaNZRg4rltrfbLHQ8C2cVwXDWjCIQ2mAo9p0iUtDb9t0zU9jZvHjuGkbl0xpYO9EEIIIdoxy7K48MILefHFF1FKsX79ei677DIuu+wyLMvivffeY+XKldF7OJMmTaJjx471Hm/58uW1luU+iRBCiNayePFifvSjH2FHrhEAnHbaaTzyyCOYptmgY+Xk1O6MvG/fvgbtn5+fX2u5qSeaEC2jsrIi5vbUBv5eiWOPMmJfGY0VwqAiAyT2JPA8t51+JiNjdIg2CiSEoa1ThQUUxmlTVlZKWlraYeszMuJ3bi8FUsrKGlecEEKIZuGbNTNum6pbv3uog14codNOx+nTF3PnjnrbeD98D5Wfj+7SJdEyhWhW1rrYIQxOn77otPSYbdqSRAKIdxIOYTBi/LcqhGhbrDWro4+rgC1x2g8dOqxZ62moXr36JB7CsHUL9rgJzV2SEG2G7/13D1sXL4ThxBNHHxeByqmpqcyYMZNzz53MgQP747Z/6603WL16Jf/3f08yYcLEFqhQCCGal4QwxHDSSSdhWRaO4wCwadOmVq7o+LBs2TIKCw/dSurVqxcTJyb2R/fKK6+MhjAAfPTRR00awvDRRx/VWj7//POPeEOrrrS0NM4///xa4RLz5s2TzoVCiGYTcGwWHNjCh/kb2Vh+gLKQH1MZlNqaoOvgNUxcrSOhCgqD8IC4SieERx06PVCEB5YZhkK54YFniuoJFTUpppdKHSKobWztgmPj4GIqA5Qi25vCpd1HcW3v0fhMOe0QQgghhGgv5s35kmcf+wCSkyEnO7wyRifgZqU1hGwGD+jITx+9npS05Li77CkpYc6adSzcsQuPaeBqjWUofJaF1pqAHe7UXBkKkWRZmChCkfPj6sAFUylswu2UUriEz49TIkEMAcfB1eC3bWzXJcmySPf5+OaQQVw8dAgZSUnN/ZMRQgghjqyV/mSLY9edd97J3LlzKY/M7rx161YeeeSRWm201hiGwZ133hnzWO+//370ce/evWWQqRBCiFaxcuVK7rjjDgKBQHTd6NGj+cc//oHX2/Ag8X79+tVa3rt3b4P2z8vLq7Xcv3//BtcgWl9FRZwQBkvulR7v4k0+4zZRCEO3vv1ibleFBeFrrgkO4hQtzyg4SCJRGR06ZB+2Lj09/sDEUiC1XEIYhBCizXBdkl55OWYTnZJCYOpliR/TMPBfez2pf7y/3ibKcUh69WWqvn9X4scVohnFC2Gw29Bs8ono0qUrpmlGx6Ecya7Id3PnzpYpSghx1GqGMKwH3Djth7Wx965evXrHnMl+R43H5rZ4ERNCHEP8frwf1x4vWAksP3LrqAkTTm62ktqaHj16MmPGTC677EL8fn/c9jt37uCii87hiiumcc89P2fgwEEtUKUQQjQPucMXQ1paGlOmTOGDDz4A4JNPPol2vBfN55NPPqm1fOqppyb8Mz/11FNrLX/55ZdUVlaSkpLSLLVNmjQp4X1PPfXUWiEMCxYs4Lvf/W6T1CWEENVs12VlSR4v7FrK9opCvIZJVShAkmlhKgO/E0ITDmJwtIvP8IR3VAqlNS6gcVGoSL8LhdYaR7skmxZVdgg3On9x+L3ZMgySjCQ6WMkUBCvxGhYnZnbjtI79ODWnLx19qa314xBCCCGEEA3gOC6ffriWWc99RmmJH1LrnMdVfzZvzjCGmsd2NSoY5LyLT+TbP7047q6u1izLzWPBtu18uWsPBZWVmIaBAoKOg9c0ax3eUApUOETBZ5nRc9/qaxCO6+IzTQKOg9I6OhOdoRRey8Q0DDqmplAeCJKdksxVo0Zyet++pPkaPlhDCCGEEKIt69ixI48++ih33HEHwWDwsHs21edJd911FyeccEK9xyktLeWzzz6L7p9oALcQQoim9/zzz3PZZZclNOHAsWbDhg3cdtttVFZWRtcNHz6cJ598stH9CuqGJmzZ0rAOytu2bYt5PNE+jM3K5NtABVAe+ar5uONxMCOaiM2I0/cp1lVXo7QYgAHAPYTDGKq/cgE70i49PYO07t1jPo9yHFRpCTozK4GqRYvTGqOwIG4Ig8fjIbXuNXwgLYHZoUuBHmWljatPCCFEk/MsXoS5e1fMNoFvXoxO4D2+Jv/V15Hy8IMot/7hob7XZ0sIg2gbXBdr/bqYTezhw1uomKZhWRbdu/dgd4z/vqujF8ydO1qkJiHE0bNWHhqSvTpGu2pDh7at965evXrH3L61xmOzzjVLIY5l3s8/RdW4ZwDwOYeuudXneAphABg7djzTp7/ADTdcQzAYTGif2bNnMXv2LCZNOoOzzjqXUaNOYMyYccfl/SkhRPslIQxx3HnnnXz00Ue4rsvevXuZPXs2V155ZWuXdUxbv359reUxY8YkvG+XLl3o0aMHubm5AIRCIbZs2RKz01+itNZs3Lix1rrRo0cnvH/d17Fx40YJ9RBCNJkKO8inB7fyYf5G1pXmU+kEsQwTR7vY2iVZGxiE33MUCgNwtCbghlCEx7oZSmFoja1dLGUS0g6K6vcojUeZKEtRaYc/MAVdG1A42iXV8mIaBqd07MMtfSfSJ1VmsBNCCCGEaC+qKgLMeelLPn5/NZUVwfghC0cZxlAd6VUvxyUZh+/9+lLGnpnYzciKYJAZy1bw+c5dGCgqQyG8lonXNAk5Lq5t47dtHK1J9niigQtGOH4M23GxlEHIdTAi9blak2KaKCAQmZ0i5Lq4WhNyHFK9XrymyTcG9OOmMaPpkJzcqJ+HEEII0dS0lmvOoumddtppzJ49mz//+c8sWrQI2z7U5aRPnz788Ic/5KKLLop5jJdeeomqqiogHP76jW98o1lrFkIIUb8HH3yQv/71r1x00UVcffXVjBjRtmZkay7btm3j5ptvpqSkJLpuwIABPP300wnNHF6foUOH1lpes2YNtm1jWYl1yVm2bFmt5WHDhjW6FtF6ruvanVtibA+MGYcMeT6+GYYRc7sb43qrKi4GYEzkq9Z+QL5SrHlvPsUlJbgJdGBWBQUSwtBWVVSgAgEK4zTr0CH7iH3O0tMz4j5FKaDKyhpXnxBCiCbnm/1K3Db+q65t8HHdbt0JTjkb37wP6m3jWbkcY9tW3P4DGnx8IZqSsWsnqrIiZht7+MgWqqbp9OzZK2YIQ/UWCWEQop3QulYIw5o4zTt27Ejnzp2bt6YG6tu3b8ztOwgPOrcAc2vDgmaFaM+877972LqPE9hv/Pjjb9KBKVPO4cknn+OWW66v1WcgnoULP2Xhwk8BmDPnLSZNOqO5ShRCiCYnIQxxDB06lNtuu41//etfKKV46KGHOOGEExg8eHBrl3bMqjvLw4ABDbu4N3DgwGgIQ/XxmiKEITc3N9o5ECAlJYXucdLja+rRowfJycnRY1RWVrJ3794GHUMIIepytWZVSR7P7ljCnspiDGUQdG1SLS8KRXkogEZT5YSwlRGdXUNFAhccrbEMA9t1qR4KpwHLMNBuOJAh3NUjvM1E4TUtOnpS8Ls2VU6IXikdmNxxAJM69WdQWkcJlxFCCCGEaCd2btvPS9M/Z+2KXThO9QwojQtWaIgjni1qDSGbbtlJ/OIfN5HTNX6ol6s1G/Yf4JNt2/lwyzaK/VWYhoGlDAKOTbLlqT54+PxXKWzXpSoUwmMY0WAFpVQ4nME0cdC4WqMiSRFKKXyRAROmYZDi9VAeCJKTmsIlw4YypX9/embG79QqhBBCCHEsGDRoEP/5z38oLy9nz549+P1+OnfunPB9ju7du/PLX/4yunzaaac1V6lCCCES4Pf7efXVV3n11VcZOXIk1157Ld/85jfx+XytXVqzyM3N5Tvf+Q4FBYfmFu/ZsyfPPvss2dnZR3XsAQMG0Lt3b3btCg+fqKysZPny5YwfPz7uvtVtqymlmDx58lHVI1qHqog9YEinysxexzsVO5o2ZgiDUVJc/zagS1YW1uix4eNs21pv2+g+hQUy2LKNMgoOAlAQp119f7sSCRUqBVSpxMIIIUSb4Dj43p0bu0m37oQaOUDJf823Y4YwACS9+RqVd/+0UccXoqlYa+LPJ+8Ma38Bkj169Iy5fWfku7FrZ7jPhPS9FaJNM3buwCgqii6vjNN+6NDEJp5pSX379ou53QZ2A/0Aa9sWeW8Sxwet8X7w3mGrF8TZbdiw4eTk5DRPTW3cBRdcyHPPvchtt91EZWVlg/cPBgPNUJUQQjQfCWFIwN13382ePXt46623KC8v54YbbuChhx6SG9/NwO/3k5eXV2tdt27dGnSMrl271lrevn37Udd1pOPUfZ5EdO3atdZxtm/fLiEMQohGqbSDfFG4k/f3bWB58R4CroOlDGztoLXGUiamAhQYGCitCWkXCwONRqNQSqG0Rkc6c7hah0MatAY0KZaXKjtEUNu4WhNwQjiRNkopuiVncEGXoVzSYwSmij1rhxBCCCGEaBu01iz5fDNzZn5B7q5CtFu3QQMOFj13PKqCwB/k1FP7890HpmGaZkK7VQaDPPXVMpbm5hJ0HEoDAbymiWEYVAVD2K6Lq0MkW9ahkLDIuaztupiWiSL886je7qJJ9XioDIVw0KA1jhsOJXO0Jt3jIdXjZUz37nz/5Al0SE4+utcuhBBCCNFOpaWlHTbjdyIuuuiiZqhGCCHE0ai+R7R69WruvfdeHnroIS699FKuuuoq+vfv38rVNZ39+/dz0003sW/fvui6Ll26MH36dLp06dIkzzFlyhSmT58eXX711VcTCmF45513anVSHDlyZJPVJFqWqiiP3SAlpWUKEW2WYcS+p65jXJxVxcWx983MOvQ4gc7fRmG8If6itVT/28T7F+rQ4cghDElJSXi9XoLBYL37lgCqvKyRFQohhGhKnsWLMA4ejNkmcOVVkOA91J07d/D443/l17/+HVlZHQiedS46JRVVWX9gmO/1ORLCIFqdtSb2UGadlITTr/1dp+jVq1fM7dEQhopy1MGD6E6dmr8oIUSjeVYsiz7WwPL6mwLhAdptTb8E3ku3EA5hUJWVGPv24naT8U7i2GYtW4qZl1trXTnwVZz9Tj11UrPV1B6cc875vP76O1x33TQOHNjfoH0DgfqvWwkhRFskIQwJ+vOf/0z37t158sknKS4u5o477mD8+PFMmzaN8ePHy03wJlJUVBTt6AHg8XganAxV99+i5kwWR6PucRoTwtClS5daIQxNVVtjeb3hC7OWldgFWiEaQ36/mpbWms1lB/i/zZ+zs6IIW7s42iXN8qK1JmDbAFQ6QXyGFR4TF5nB19AaR7uYKCKrUYTDF5JND37HrjG7hkKh8JkWpjbI8aZSEvLjQzEhpzdndx3EhJzepHtabzYk+d0SzUl+v0Rzkd8t0Vzkd0vEU1UZYM5LXzLvnVWUl/nDK6tPCqsdZZ5CIqJP57qYoSC3/Pg8zr7y5IT21Vqzo6iYBVu28db6TRRWVpHq8YTPdwFPpPORaShcrdBaUxkKkeLxYKjwshGpwXZdvKZJwHEwIufAWoOpFGkeD1UhG8sycNEEHZcUj4fJA/pxzuABjOjSGStOh2mRGHnvEs1FfreEEEIIIYRITHUwoY6EdpeUlDBjxgxmzJjBhAkTuPbaazn77LMTDk1si4qLi7n55pvZtWtXdF12djbPPvts3MEQDXHFFVfw3HPPRfs7vP3229x+++0MGFD/TPOBQIAnn3yy1rorr7yyyWoSLUvFmfFLp6a2UCWirTKM2DNHujECb1VpSex9s7Kij3VGJto0UY5T//EKC2MeT7QeoyA8EDdej7KsrA71bktPT4/ZJ60UUGWljahOCCFEU/O99UbcNoFLL0/4eH//+6M8//x0PvnkY2bMmMnw4SMInH8BSXNerXcfa90azM2bcAYNTvh5hGhq1qrYIQz28BFgtb9hLz179o65PZfwrPMWYG7fhi0hDEK0adaKQ7ELeUDsGCUYNerEZq2nMXr27I1hGLhu3Vl7DtkKnBN5bG7dIiEM4pjne+O1w9YtJPw3OpbTTjujWeppT046aQwffvgJd955G4sWLUx4v2Aw0IxVCSFE02t/n0Zb2FlnnVVr2bIsbNtGa81XX33FV1+Fs418Ph+ZmZlYjfyAr5Ri3rx5R11ve1dZ56Z0UlLSoRkrE5RSZ/aAusdsrLrHSW7EjJd192mq2oQQx76ga7O0cA/v5a3n0wPb8DshPIZJ0HXCQQqEZ/BVRDrMaU1A2yjCg81QCqUUGo1C4WqNru5YB5jKINXyUGkHcQmHNQScEDYuKaYXr2EyMac3tw6YyMD0jq35oxBCCCGEEA2wN7eImdM/ZcmirTh2/TfQgEMJCc0ZxmDbZHkVv37qZnr1TzzcsKCykicXL2X1vv0UV1VR4g/gMQwqgkGqbBsVCR7zRQZeh89xw+e9ftvGYxgEHAetw+fNjqtJ9oaDFIKR9RodGSihMJSiU2oqChjSqRM/On0iOdJRXgghhBBCCCHEMeIf//gHM2fOZNGiRdHPytWqQwSWLFnCkiVLyMnJYdq0aUybNq1RExW0pvLycm699VY2b94cXZeRkcEzzzwTMxyhMQYPHswFF1zAO++8A0AoFOLnP/8506dPJy0t7bD2WmsefPBBduzYEV3Xq1cvrrjiiiatS7QcVVH/7MIAOvXw3wNxfInX/8mNcV3WKC6Oua/OzKr5ROjsHFSMGeiMVp40RtRPRf5t4sVkZGdn17stLS2REIayRlQnhBCiSbku3rfejNnE6dMXe+QJCR0uLy+Xl176LwC7du3g8ssv5LXX3uHEqVfEDGEA8L0xh8qf/iKxuoVoBtbqVTG32yPb3kDmRPTo0TPmdofwQO7egLltC/aEiS1RlhCikawVy6KPl8doV23EiFHNV0wjeb1eevbsxa5dO+tts7XGY3PrFkKTZKC5OIa5Lr65rx+2+rMEdj311NOavJz2qHv3HsyePZe///1v/OUvDxEMBuPuEwhICIMQon2REIY4cnNzw4NW63Q8qF5Xze/34/f7G/08DQ0aOFZV1Lkp7fM1fIb1uvs0VwhDY2pLSkqKeUwhhDiSA/5yHtv4KevL8qmyg4Rch1TTi4vGr0OAotwO4DM80YFz1X+nXDREoxcAHQ5s8CiDkHaj4+yUAlOZeE0Lr2HiUxYVTpDO3nTO6TqEKV0GMiyjs/y9EkIIIYRoB7TWfPXFFl5+biG7dxYQYwK1wzVHEIProgJBhg3qxH1P3YrH40l4131lZXy6dSevrV1HcZWfrKQkQo6LxzTwmiZa63C4AuGwBY3GNAxwXLTWGErhaI3XUBhuOJTBqPED8VkmlmlQFQyhUAQcB9txSfV6GdQxm3MGD+TkPr1IaoezagghhDh+aS3Xb4QQQggR29lnn83ZZ5/Nrl27mDlzJq+//jpFRUXAob4L1f0hDh48yBNPPMG///1vzjzzTK655hpOP/30Vqu9Ie644w5Wr15da91NN91EUVERixYtatCxRowYQWZmZsw2d999NwsWLKCqqgqA1atXc91113HvvfcyceKhgRTbt2/nr3/9Kx988EGt/e+5554GXTcRbYuqKI+5XUvA53FPKSPmdh3joqwqKYm5r5vVofZyTg5GrBCGQglhaKuMwnD8Qrx/oQ4d6g9hSE/PiLlvKWBICIMQQrQ666slmPn7YrYJXDQ13LEvAf/85+O1BjwVFhZy9dWXM++deaSnZ2CUlda7r/f9dyWEQbQatX9/3P8W7BPaZwhDr169D1tnAn2A/sAADnXRMLdtPaytEKINcRyslSuiiyvqbRjm8XgYMmRoc1bUaH369IsZwrClxmN5bxLHOuvrrzBz9xy2/nfAJcDHwLyevVhUWEhl5aHxjsOHjyQ7O6elymzzTNPk7rt/ytSpl/P73/+Gt9+OHTaXSFCDEEK0JdKDPEFHGnTaVANRdYNGQxzb6v4hbUwHA6/XW2v5aMIxaqqbtNSWahNCHHu01mws28+H+zbxRu4aKu1gePZe18FAhW+uRGbprZ7hN+CEwvuqcOSCIjx2ThHebqrIOgVJpgdTO/gdG9CEHIeQcrG1S4aZRJY3mQtzhnNT/wmkWt76CxVCCCGEEG1GKGQz99WlvP3G15QWVzU+SKH6RPJouS6qsoppN5zKld8/r0G77iwqZvbqdSzbk8fe0jL8to1lGJQHgoQcB69log0z2r76HDlgOyRbVo1z4TDbcUnxWFSGbFztonX4dFoZ4fPqZK+HrmnplAcDDO7UkVsnjGVwpxwJIRNCCCGEEEIIcUzr3bs3P//5z/nxj3/Mu+++y0svvcTy5eF53Gp+JtZa4zgOCxYsYMGCBfTo0YOrr76ayy+/POZM3K1tyZIlh617/PHHG3WsGTNm1ApSOJI+ffrw4IMPcs8990T7gWzYsIEbbriB7OxsunXrRmFhIfv27Tusn8j111/PBRdc0KjaRNug4kzCoVNSWqgS0VYZRuwQBjfGNVlVHnvAvE5Pr32sOJ3AlYQwtFlGwUEgfghDVp3gjZrS6/w+1FUKKAlhEEKIVueLMzAJIHDx1ISOtX//fp5/fvph6/fuzeN7d93Je+d/k5RXXqp3f8/K5Rh5ubjdeyT0fEI0JWvNyrht7FEntEAlTa9Xr9788Ic/pk+fvgx/+j8MXb+WXhx5AI+1dcsR1grRShwHz5LFWKtXgu3g5uQQOv3M4/rvhLllM0aNAM7lcdoPGTLssLFDbUW/fv357LOP691eM3bB3CbvTeLY5nvztSOut4CJka/b//kUVWPHsWLFMj7//DMWLvyMk04a3ZJlthv9+vXn2Wf/y7JlS3nqqX/z5puvHTFwoe74TCGEaOskhCEBEpLQcup+0AiFQg0+Rt0/0D6f76hqqu84bam2xgoGnQatF6IpyO9XfAHH5unti1lUuJ0yO0iVHSLJ9OBoF0e7uCjKbT9e49CfcSMSxKAhOuOvUgqlNUopDMDROjwITYcHo/kMC601KaYXFwi6NgNSc7io6whO69iPLknp4Laff7P2Uqdon+T3SzQX+d0SzUV+t44vBQdKmTl9IUsXbyEUcsMrj/ZSxtEEMdgOyaEAP/3LNQwdNxBI/HeyqKqKhTt28crqNVSFQmT4fDhak+L1YChF0HYIOQ5Bx8Vxg6R4PNFzYSNSdtBx8JomAcdBR86BXa0xDYMUjwe/bWM7DiHXJeS6OK5LZpKPrOQkLh85jHMHDcRnWYd+lqLFyHuXaC7yuyWOO3JLQyTo7rvv5ic/+Qm9ex8+G1dr2LlzJ3/729949NFHW7sUIYQ47ni9XqZOncrUqVPZuHEjM2fOZO7cuVRUhGd2qg5kqO47sWfPHh555BEef/xxzjvvPK6++mrGjh3bavW3JRdeeCFaa371q1/VmpShsLCQwsjs5nXdfPPN/OxnP2upEkUzURUVMbfr1LQWqkS0VfECX90YH+biDZjX6Rm1l+OEMBgFEsLQVqnCAjTxQxhihSBlZGTUuw2gBFAxZkMXQgjRMrwfvhdzu9OjJ/boxD5n/fvf/0dVVdURt3322cc8ccPN3BOvng/ew3/TLQk9nxBNybPqUAiDA9wPDAOGA4MBr2liDxvROsUdpaSkJH79698BkLZiGcnr19bb1pQQBtEWaI3v5RdJffjBw2aG14ZB8MJLKP/fB3B7tY37Si3JWrGs1vKKOO1HteHwmL59+8XcvpVDE9/Ie5M4prkuvjdfj9nE6doNe8JEPIbB+PETGT9+Inff/dOWqa8dGzNmHP/85zjuv/8hPvzwPT7+eD5LliwmN3cPWusjBjMIIURbJiEMcVx22WWtXcJxJTU1tdZyY9KN6u6T0kSzCdQ9TmNqq9nJ4kjHFEIc3woCFXxesI0Zu5ZyMFiBV5kEXScaouACChUdDxdwbUCjI+sOzfYbGYSmIm21JsXy4ndtQq6DQhFyHdzIMZNMDx28yVzUbQQXdxuBIbP9CiGEEEK0C6tX7OTl5xexfUt+Ew62jJxVNiaEIRCgR1YSv3v+hySnJjdo1y0FBczfup1FO3ayp7Qsej5bUFmF1hqPaUTLU5HAMUdrqmwbr2lSZdvhwIXI+iTDwNWakOuC1lTHKZiGwjIMspKSSPJYVASDDMzJYdqokYzu0Q2vaTbwRQshhBBCtF/vvfce8+bN47LLLuOWW26hb9++rVLHjh07eOqpp3j99ddxHAnOEUKI1jZkyBD+93//l5/97Ge88cYbvPzyy2zYsAGoPYC4uqPcW2+9xVtvvcXAgQO55pprmDp16mH3/Y83F110ESeeeCKPPvoo77//fr0TPIwfP5677rqLCRMmtHCFoslpjaqME8Ig/UOOe/Huw8eaIyjegHmdnl5r2a0nhCEEeACjUEIY2irj4EGqgHi90jp0qD+EIS0tvd5tAKWAKilpcG1CCCGajrl1c9xZ7wMXXgwJ9OMrLCzgmWeejNnmt7Nf5iqfj54x+j17339HQhhEq7BWr4o+3gH8rsY2Axhomgz47s0MGTKUwYOHcM4555GZmdWyRTYBp//AmNvN7VvBdcEwWqgiIeoIBEj/wXdJemPOETcr18U393U8nyyg9OkZhM78RgsX2Lo8NUIYSoBtcdqPHDmqWes5GvFCGCqBfUA3wNyxHWwbLBl6KI49noWfYu7Ni9kmcMml8rf5KOTk5HD11ddx9dXXAeGJrfPyckmVwGIhRDsjZ0Jx/PGPf2ztEo4rdUMJ/H5/dBBFoiorK2Mes6lqqy81Npa6+0gIgxACwp3U3tq3jtfzVlMQrKA4WIXXNMODxrSD0gpHu3hUeECYioQruDo8OM7RLpYywusj75laa9zIrL8ABooUw4MfRarpJaQd0JoR6V2Y2n0UE7J7k+FJarWfgRBCCCGESIwdcvjgnRW8Pedriosq62mVYHpCY4IWaj2NDncwL69k0hmD+N4frmnwIUKOw4ebtzJr1RocrQk4IRSQ4rFQKEoDAVytqQiGSPF4DgWPRUIabNfFaxrR9dW3PFytSfZYGLZDwLYBCNgOWmscrTENRYbPx6XDh3H5iOFYptwsEUIIIcTxyXEcXn31VWbPns1ZZ53F1VdfzWmnndYiz/3555/z4osvsmDBArTWDb4fJIQQonmlpKRwzTXXcM0117BixQpefPFF3n//fQKBQDQgEcL3uQA2b97M/fffz1/+8hcuvvhirrnmGoYOHdqaL4GNGze22nP36tWLRx55hN/97nd8/fXX7Nixg4qKCnw+H926dWPs2LF06dKl1eoTTSyBSTx0svQPOd4pI/a5rhvjYq1RVhZz3+oQhm3btrJo0UKKt2yiEMiPfO2LfE+KPFYSwtBmGYUF7E+gXXZ2/SEM6enxQxiMslJwHJBgYiGEaBXeD96P2yZ4/oUJHeuNN16joqI8ZpuKigp+1aMHz+Xm1l/TZ59AeTmkyYAo0bKs1Sujj9fW2eYCm4JBNr37Fu+++xYAixcva6chDANibldVVRh783B79GyhioSowbbJ+M51+OZ9ELepUVpC5vVXUfLiq4QmndECxbUNVo0QhpUx2lUbNerE5ivmKMULYQDYSjiEQdk2xq6duHHew4Roj5JeeiFum8All7dAJccPr9eb0HuQEEK0NRLCINqUDh06RAcPA4RCIQoKCujYsWPCx8jPz6+1nJNz5HT3hqp7nH379jX4GM1VmxCifbJdl9UleTy7cwnryvLxKIOAY2MohYWBjYtCYRDuwBbQNjo85Axq/X/NtYDWpFheqpwQjnYxUDhoQm54Frk0j5dsTyrf7jOWU3PkQ4wQQgghRHtQUlzBC88uZMmizQSD9mHhCeqwpaNJV6g+WoxjOA6qtIzv/fJiJl0yvkFH11qzvaiYz3fs5IPNW8grLUMBXssi6DiYxqGBHEqFz4ddrakMhUi2LIzIdYPq2ATbDQcuVIVs3Mjgvep9kywLDWQnJxN0bPy2w+CcDlw2fDgTevckw+drUO1CCCGEEMeSK6+8kjlz5uC6Llpr5s2bx7x58+jevTsXX3wx5557LsOHD2/S51y7di0ffPABb731Fnl54ZlFqs/fDMPgyiuvbNLnE0II0TROOukkTjrpJO69915mz57NrFmz2LlzJ0CtMAatNZWVlcyaNYtZs2Zx4okncs0113DBBRfg9Xpb8yW0mrS0NM4880zOPPPM1i5FNCPljz+Jh06SQPzjnaFiB8G6uv7rsao8XghDBgBLlizmJz/5Yb3tygCH8EB/0TapwgIS+dfJyupQ77b0yO9DfUqrn6ukGJ0tfdeEEKI1eD98L+Z2NyOT0MRTEjrWt799I/Pmvc+HH8YOdng+L497gBPq2a6CQbwfzyd40SUJPa8QTUGVloRnWY9YHae9z+ejd+++zVpTc3EGDIzbxty6RUIYRKtIfeB/EwpgqKb8fjJuuZ6iBYtwu/doxsraiFAIa82hd6jlCewyfPiI5qvnKCUawjAp8tjatoWghDCIY4wqK8X39psx2zg9emKPa1i/SCGEEMcmCWEQbUpSUhLdu3cnt0baal5eXoNCGPbu3VtruX///k1SW79+tT9sNCaEoe4+TVWbEKL9WVu6j+d2LmFbRQEHAxWYyiCobQLaRmmFo12sSCcMpRSKcKcLF3C0i6mMaGiNUgq35ixxSmEpgzTTS5UbIsnwYEf2GZXZjcu6j2Jch16kWMdnZzchhBBCiPZk0/pcXpi+kC0b9xHug6uPmI1QK5SrIWLlNVSfX9bs/BsMke3V/OaZW+nUI/HP6tVsx+WlVauYt2UbtuNysLIC01B4TJOg7RCw7fDr8IDXNKPlmUrhaE3QdfAYBgHHiZwLQ8hxSLZ84AF/yA4/j3YxXYXtuhhK4TVN0nxeLh42hKnDh2HIDMtCCCGEEDzwwANcddVV/OEPf2D58uXRMITc3Fz+/e9/8+9//5suXbowceJExo8fz8iRIxkwYAAejyeh4weDQbZu3cqaNWtYunQpX375ZTSsWtcZYDZmzBjuvfdeRo4c2bQvUgghRJPKysrilltu4ZZbbuHzzz9n5syZfPzxx9i2feg+FYfe51euXMnKlSv5wx/+wJVXXsl1111H9+7dW6t8IZqNCgTiN5IQhuOeYcQOYag3giEUQlXFDvpw09MB6Ny5c+x2wEGgc1EROA6YZsz2ouUZBQcpTKBddnZ2vdsyMhILYTCKi3AkhEEIIVqcKinGs3hRvdvzgR9nZPCj3bvon8CAR4/Hwz//+SRTpkxi9+5d9bbTWvMQ8GKMY/k+eFdCGESLslavqrW8qp521QYPHopltc/hL07ffmilUDHC18xtWwmdMbnlihIC8Hw8n5R/Pt7g/YyiItJ/8F1KZs891L/oGGVtWFfr2s+KOO379OlLRkZms9Z0NNLS0ujUqTMHDuyvt83WGo/NrVvg7POavzAhWpDvzdfjXm/zT7sa4lzPE0IIcXxon59CxTGtX79+tUIYtm7dygkn1Je9eritW7fWWm6qoIMePXqQlJSE3+8HoLKyktzcXHr0SCy9Lzc3l6oaJ2kpKSl069atSWoTQrQfhcEKXtmzkrf3rcPRLrbrYCiFzzCxtYvi0Ey/Ae2g0WjCIQzVX0B0lF31cpJp4XdsXDRGJMQh5DoYGHTwJpPjTeWWficzOus4SBwVQgghhGjnXNdlwYdreW3WEgoPltfZWn9qQpMGMdRYVoai/+AuTLv+NMZM7E8w6DT4KXJLSvlsxw7e3biZvWXlJFkWyR4PjqvxWSZKKUzDiAaQVdk2KPCYJn7bRmuNoRS245Lq9WC7Lo52UVpFy/WYJgpFyHVI9njwh2xcrendIZOpw4ZySp9edElLa8xPSAghhBDimDVq1ChmzpzJJ598wmOPPca6deui27TW7Nu3jzfffJM33wzPBGKaJt27d6dLly507tyZlJQUfD4fAIFAgIqKCg4cOMC+ffvYu3cvjuPUOh5Qa5DuiBEjuOuuu2R2cCGEaIdOO+00TjvtNPbv388DDzzABx98EH2Pr/5e/d5fUlLCM888w/Tp0zn33HP54Q9/KBMWiGOKW1FBiHAnrPquz2kJYRBxBqXUDSqL7lZeBsB+wAQ6AHW7f+u0cAhDp05d4paRD3TRGlVcjM6RAfhtim2jiospSKBpVlaHeredfPJp/OzW79HtqX+RAYd9ZUXaqeLio6tXCCFEo3gXfISy7Xq3Pw7M3LObVyaN58Ybb+YnP/k5nTp1innMzMws/vznv3H11VfEbPcy8CBQ3/zX3g/fk6Am0aKs5ctqLa+up121tjyzfFw+H26vPpi7dtTbxNy6peXqEQKgqor0n/240bt7F36K77VXCVz+rSYsqu2p+161Ik77UaNObLZamkrfvv1ihjDUfDcyt22tt50Q7ZXv5VjRZGGBq65tgUqEEEK0BxLCINqcYcOGsXDhwujy8uXLueyyyxLad//+/bUCHDweDwMGxE+CTYRSiiFDhrBy5cpatSUawrBsWe0PX0OGDKnV0VAIcWwrDfmZuXsZiwq2s7uqGFdrTEPhd2wU4dAES4W7SlQPPHO1xgVc7WKq8IA0IzLxcXXYQjWvYWEpgyrHxqNMgq6DUooTMrpxeY8TGNehFymWt1VeuxBCCCGESExFhZ8Xpy/k8083EgzY9WQt1D8rQvVWBbGyGo7sCO0tj8GYCf25/vbJdO2e1YCDHVLq9/Ps18tZnreX8kCQoqoqTMMgYNuU+P24WoNSJJlmtA9y9VmuP2ST4vVElxXhmdocV5Pi9VAZDOFoF60jHZQ1hFyHDF8SqV4vnhSDa046gXMGNc11ASGEEEKIY9mZZ57JmWeeyaJFi5gxYwaffvopWuvDBtHats2uXbvYvXt3zOPVHUCmlEIpFV0/efJkbrzxRk455ZRmeDVCCCFaQigU4t133+Wll15i+fLl0ff5mvfAaz7WWuM4Du+99x4ffvghV199NT/96U9JkoHp4hiwYf06ziA8MD4ZSIp8Jdf4/mRREd1br0TRBhgq9sx5bj3rVVk4hOFHwEuEgxhygE41vjKfn87YwgImTTojbh37gBMAo7AAR0IY2hRVVITSOm4IQ0pKajQM70gmTjyZkwcNouNT/4r9fMVFjahSCCHE0fLO+6DebVXAvyOPbdvm6af/w0svvcgPfvAjvve9H5CamlrvvlOmnMN5513A+++/W28bF3gE+Ec9242CAqylX2FPPDneyxCiSXiWfx197Ac2xWk/bFg7DmEAnP79Y4cwbJMQBtGykv/zT8wd24/qGKm//w2BCy6C5OQmqqrtsVYcGgcUBNbGaT9y5Khmracp9O3bj6+++rLe7TVjF8wtm5u/ICFakDp4EO/iRTHbhCacjNN/YAtVJIQQoq2TEAbR5kyePJknn3wyurxo0aLDOmvU5/PPP6+1PHHixJgXHRtTW80Qhs8//5yLLroooX0XLap9kvaNb3yjyeoSQrRdWmu+Lt7DE1s/50CwHK01rqtJ9XixtYvCwSAcuBDQDhqNJhzCUP3lEu6wU70MYCmTUKS9gcLVmqAbDmvo6EulgzeF2/udzOgOPVvnhQshhBBCiIRt25LPC89+yoZ1eUTHqtUboJBoukJDUxiInmympyVzzkUncNEV4/ElefB6Gz7Tyb6ychbv2sUb6zZSUFlJh+QkNGAaBj4rfLyQEz6fDdg2Wmt8phmt2lAKR2scV+M1TQKOgxH54VRvT/V6qAzZKCDkutiuiwKykpOY3L8fZ/TrQ98O9c8GJoQQQhyzGngKIERNp556Kqeeeip5eXnMnTuXt956i82bD3WuSjRcum54g9aaQYMGcdFFF3HxxRfTvbsMQRRCiPZq9+7dvPTSS8yZM4fiyAza1ffz677/W5aFHZnhteY227Z54YUX+PLLL3nmmWfizuoqRFvnLysFwvd1KyJfdWmvBOYf7wwjdghD3SCzaqq8HCA6MN8B9ke+ot56g5LkZKZOvbxW+NmR5Fcft6AABiVSuWgpRmH4X/lgnHbZ2dlxj6Uzs+I/X5GEMAghRIvTGs/H8+vd/AIcFsZTUVHOww8/yLPPPsXPfnYv1157PZZ15O7/9933u5ghDADPAL8lHOR0JL7335EQBtFiag5sXk/4XDeW4cPbeQjDgIEQ4z3A3CohDKLlqOIiUv7x2FEfx8zLJemF5/Df+r0mqKpt8ixdEn28DgjFaT9q1AnNWk9T6Nevf8zttUIYNm1s3mKEaGHWqhVx2/ivvq75CxFCCNFuSAhDEwsEAlRUVJCaGjtxWtRvzJgxdOjQgaLIjZ7du3fz5ZdfcvLJ8S/qvfrqq7WWp0yZ0qS1TZkyhcceO/Rh87333uO+++6LG/RQXl7Oe++9V2vdWWed1aS1CSHaFq01Xxbu5J389XxZuBO/E8IyTAKODWgq7CBWpJOFUuHQBVdrXMDV4TAFpRSGBheNE1lXLdm08GoTvxvCQBFwbTQwNL0T3+o5monZvUmz5O+QEEIIIURbpbXms4/X88oLX1BwsLxpj00kT6GBOQzdenTg8mtO5uTTB8ftEFyfXcXFvLZ2PSv37mNfWTlVoRCmoagMhQg6Dh7TQGsTpQClUDo8QCPoOJhK4TENgk54zjcFBB2HNI8HjSbouGita3QgVphK0T0jnYDt4LNMrj5xFKf37UuaTzq1CyGEEEIcje7du/Pd736X7373u+Tl5bFw4UKWLl3K2rVr2b59O65b3zy9YYZh0K9fP0aMGMG4ceOYNGmSBC8IIUQ7prXmo48+YubMmXzxxRe1Pp/XDV+wLIvzzjuP6667jqFDhzJ37lxefvll1q1bF21f3Xbz5s3ccccdzJo1q9HXIoRoCwLlR4pdqM2bkdEClYi2LF6gWX1n2KqsDIB4w+U7dOiAZVnk5ORw8GD9w/j3Rb5XD/gXbUeiIQw5OR3jH8w0cTMyMUpL6m2iImFKQgghWo65bi3m/vwjbtNArKGw+/fn89Of/oi+fftxxhmTj9hmyJChnH/+hbz33tv1HqcK+DdwXz3bvfPnUfGb38eoRIimofbvx9y9K7q8KoF9hg1r3yEM9oDYM2qbO3dAKAQeT8sUJI5ryf95AqOkOGYbnZyM028A1ro1Mdul/P1R/Nd/B47B8VOqpBhrw/ro8vIE9hk5su2HMPTt2y/m9gKgGMgCzPx9qJLihML+hGgPrLWx39O0aRK45NKWKUYIIUS7ICEMR2H9+vV8/vnnLFu2jHXr1lFUVEQwGIxu93q9dOjQgREjRjB69GgmTZrE0KFDW7Hi9sEwDC677DKeeeaZ6Lr/+7//Y+LEiTFvSH7xxRcsXbo0upyamsoFF1zQpLUNHTqUUaNGsXr1agAqKyt56qmn+NGPfhRzv6eeeorKysro8kknncTAgbEvpAgh2i+/E+I/27/gk4NbcVyXkGOTannRGgLYKBS2drEdF41GEw5hMJSKBjEYhAedhb8UljKwdbi9QXjmCheNpUw6elNJs3zc1GcCkzr2S3g2OiGEEEII0fL8VUFmzfyCBR+sIeC3m/nZFCgdM4jBtAxOGN2Hq2+cRM8+CXTcrMfBikoW797NK6vWUhUKkZWchOO6JHssTMPAdlwCtk3IcdE6RIrHg6HAjpzfVgcuJFsWIcfFjcygqbUGpUiyLAzl4rdtXK0J2A4hx8FrmpiGwZn9e3HBkEH07dCh0a9BCCGEOGZouTYkmlb37t2ZNm0a06ZNAyAYDLJ371727t1LeXk5VVVVACQnJ5Oenk63bt3o2rUrXpntWQgh2r39+/cza9YsXn31VfLzwwOFaoYv1Fzu3LkzV111FVdddRUdOx66xlC9btmyZfzrX//i008/jQY3aK1Zu3Ytb7/9NhdffHELvzohmk6goixum6SMzBaoRLRl8cJm6ruMa5SXAuHBD7FkRH7HOnXqHDOEoXrYp4QwtD0q8u92IE677OzshI6nszpAjBAGozhetIcQQoim5l3wUb3bPgZiDweDoUOHcfrpZ8Zsc9ddP44ZwgDwNHAv4T6KdVnr1mDs24vbtVucaoQ4Op4VX9daXh2nfU5ODp07d26+glqA0z/22AHlOJg7tuMMGtxCFYnjlt9P8vSn4jar+NVv8V99Hdknj8E4WP8nFXNvHr435hCYdk1TVtkmWF8vrbUcL4ShY8eOdG0Hf0PjhTAAbAXGRh6bmzZij5/YrDUJ0VKstbHPOpxBg9FyLVcIIUQNEsLQCB9++CHPPPMMK1asiK47NAvjIYFAgH379pGfn8/8+fN55JFHGDt2LN/5znc466yzWrDi9ue2227jpZdeigYXLFmyhCeffJLbb7/9iO3z8/P51a9+VWvdDTfcEPem05AhQ2otz5gxg4kTY384uOuuu7jtttuiy08++SSnnnoq48ePP2L7JUuW8NRTtT+k3n333TGfQwjRPhUGK/n0wFZezV3B7qoSTBUOW3C0i7bBMkwg3CnNgGjggqtdTBW+pWGgcNE4NdYBJJkWGqi0gxhKEXAdXDQ9k7L4Vs8TOaVjPzr70lr+RQshhBBCiITk5xXz9L8/Ys2q3PCKI1xHSJgiZrDCYY3V4c/nS7I446zhXHHtqaRnJDe6lPX7D/Dx1u18sWs3eWVluFpjKkVhVRWOdkk1vYfKUApDKWzXpSoUwmeakVCGcOCCozUaSPZYVIXCYQvUGNhhKEWqx0O39HSK/FWk+9K4fMRwJvXtTcfU1Ea/BiGEEEII0TBer5c+ffrQp0+f1i5FCCFEM/niiy+YOXMm8+fPx3GcWv0h6oYvjBs3juuuu45zzz0X0zTrPeaYMWP4z3/+w/z58/mf//mfWpMYvPPOOxLCINo1f0VF3DZe6bh73IsXwuDWc81YlYVDPuINl8/KygKgU6curF+/rt52+6qPKyEMbU51MEb9ERphOTmJBSq7WVmYu+rfroqLEytMCCFEk/F+PL/ebfGHwsKtt34v7gRN48ZN4JRTTuOLLz6vt80OYD5wdj3bPR/PJ3D1dQlUJETjWcuX1VpeFaf98OEj2/0EZc6A+BM4mps2SgiDaHa+12djxAjvA7CHDKXq5tvBsqj45a9Jv+eumO2TZzx7TIYweL76stby0nraVRsxYlS7eK/q27d/zO3dgZqRfpaEMIhjiLXu8OizvcAuYDxgDx/R0iUJIYRo4ySEoQFKS0u57777+PDDDwGO2NHgSGq2W7p0KV9//TXnnHMODzzwABkZGc1XcDuWnZ3N9773Pf76179G1z3yyCPk5eVxxx130KVLFwBc12X+/Pk8+OCD5OXlRdt27tyZm2++uVlqO+OMM5g0aRILFy4EIBQKccstt3DPPfcwbdo0kpPDg1cqKyuZNWsWf/3rXwmFQtH9zzzzTE455ZRmqU0I0Xo2lu3n8a2fsr+qjMJgJV5l4jVNyuwACkVIu+EBZmjCk/mGB5FVBzEYkYFnClCocBiD1oRH16nI3MAaj2GS403Ba1hM7TaSS7uPwmvKn3MhhBBCiLbqyy82M/O5z9mfX3po5dEEMAANTGGI7BK+btGpUxpTrzqZyeeMOKqbfiHb4fV163lrwybQmoBto4AUywKlKA8GcFxNhQ6S7PEQfSatMZQi5Lp4TRPTMLBdFyPyM3G0xmeZKBSVoRAawsdWipDrkOH1odFM6tOHG8acRKc0CV8QQgghhBBCCCGaQklJCXPmzOGll15i167wiE1dIxyxmtaa5ORkLr74Yq677rrDJj6IZ8qUKfzsZz/jt7/9LUoptNasW1f/YGEh2oNAjVCRI1GAV/oHHfeUEft6rFvffmVlaKA4zvEzM7OA8KybsVQPszEKJIShrTEKwv869c8vG5aTk5PQ8XRWh9jPVxwv2kMIIUSTqqzE8+WiI24qBV6Ls3uHDh248sqrEnqqO++8K2YIA4RDH+oLYfDO/1BCGESz8yz/utZy7DmpYdiw4c1XTAtxe/VGJyejqqqAcK+PA8A2woM+TcDauJ7ghRJUKZqR1iT/54m4zSp+fh9Y4f7p/quvI+Vvf8bcs7ve9p4lizHXr8M5Bv5brcnz1ZLo4xCwPE77E044qTnLaTI5OTmMHHkCnTp1om/ffgx/dRaDy0oZAPQDUuq0NzduaIUqhWgGFRWYmzcdtvq/wM+ALsC5W7dy1jtvceaZ3yBVJoYSQgiBhDAkbO/evVx33XXs3bv3iB0NoHbYQjWl1GEdErTWfPjhh6xZs4aZM2dGAwVEbbfddhvLly9nwYIF0XUzZ85k1qxZdO/enfT0dPbs2UNpaWmt/ZKSknj00UebNeDi4Ycf5qqrrmLPnj0ABAIB/vCHP/DXv/6VXr16obVm9+7dBAKBWvv17t2bhx56qNnqEkK0LK012ysLeT9/Pa/nrSbg2hgogjh4MbG1wtUuhjIikw9rbMBFY0SGoRkoHDQOGovw3wylNUmRYIUqJxzi4rdDuEqT5Unh/C7DmNxpIAPSEpvdQAghhBBCtKxQyOblFxYx7/01BPx2dL2q+aAZcxjqduVVCgYM7sq1N01iyIiejX5KV2s27D/I/E3b+GjLVg5UVGIqRYrHQ6UdwjSM6DUQhUKpcKhCVShEsseDZSgcV1M931vIdUm2LCpCIdzI9ZJqlmngcQ2ykpMxlKLUH6BnRgYXDhnMpH596JkpMwcKIYQQQgghhBBNYcWKFbz00ku89957BAKBI05GUb2uT58+XHPNNVxxxRWkp6c3+jmvuOIK7r//fhzHAaCoSAaBivbNX1Eec3sSoCzponW8U4YRc3t92b2qrIwywIlz/KzIgPvEQxhiz3oqWp6K/JvE+5fJyUmsr4iblRX7+UqKEzqOEEKIpuFZ/DmqTp/iaq8CVXH2v/7675CSUndI5JGdffa5dOvWnb178+pt8xpQABwp2sf7yQJwHDDNhJ5PiAbTGmvFsujiAWBfnF2GDx/ZrCU1p/LyMr788gt27NhBfmoaO6qq2Eo4fKEi0mY70BcwN8lAZ9G8PIsX4VmzKmab/H79eSMYYP0ffo9hGPTu3Yfzr7uBIQ8/GHO/5BnPUP7HvzRlua3LcbCWLY0urgH8cXYZPXpss5bUVJRSzJ+/MLqcuW1r+O9/PSx5bxLHiKRXX0Y5h19lmxv5ng88v3I5z990LT6fj0mTzuDccy/g3HPPp0ePxve7FEII0b7JHb4ElJaWctttt5GXF74YVTdUASA7O5sBAwaQmZlJcnIyVVVVlJaWsnXrVgoiyeE1Axm01uTl5XHrrbfy4osvHlUHhWOVYRg89thj/PKXv+Ttt9+Orncch927j5yil5WVxeOPP87Ysc374aVjx47MmDGDO++8kw0bDn2g8Pv9bN68+Yj7DBs2jCeeeILs7OxmrU0I0TJcrZmTt5K5eWsoDFUSch1STQ+VTgjQhLTz/+zdd5Qc1Zn38e+t0D15RjMKKOeMhBBZEkqIIMAgsDHBNtE4rAM2zva73mDv2uu8rA02mIxtsslZQgkhARJIKOcsJE3O3V1V9/2jelqTOsxoeoL0fM6Zo66qW1VPS6Pu6up7f5eI64LyQxfMaMCCoTVedH9DKYzoDD8Khas1/kg6hQJMZWAbJnl2BrYyOaNgMLcPP5eioCTqCSGEEEJ0R6Ul1fz13rdZu2Y3nqcbLu1iGjrRJp7vLFUKlE4Y5hAImEybOY5rPj+NgsLju4asCYf5y7vv8/6+gziuS1ldPbZhYBoGNZEwIdf1r28DAczodW7DNa+rNRHPJWCa1HqOf/2rwImGMGTZFnURB0drHM/F9FTs7882DAKmyYyxQ/niWVPJCgSO63kIIYQQJ4XjDXsSQgghxAmvtraWF198kX/84x9s2bIFoNXJKLTWGIbBzJkz+dznPsfMmTM75PyWZTFgwIDY9/6RSKRDjitEVwnVJx4yl9FJdYjuzVCJQxi8OB/mVFUl5SkcPz+/AIDCwtaGUh7TMMBflUsATndjFB+NzYacSLJ/4wY6GswR93wSgiSEEJ0q8PbCuNseTmH/z33uxpTPZZom11//OX73u1/HbRPGn/H3jla2GWVlWB+twTnjrJTPKURbGHt2Y5SWxpYTDwf3jR8/IX0FpdmhQ4e4/vrPJGyzDT+EwdosA51FemU8eF/cbVXAT4F79u0l9JXbmmwzTZPPmya/cV3ixcIFn3yc6v/3H3CCzBxvbt6EUV0VW34vhX1OP31q+gpKI2fsuIQhDObWLZ1YjRDpk/ngX1usOwq800rbUCjEwoVvsnDhm6xa9S5//vP9aa9PCCFE9yQhDCn4+c9/zvbt21t0Nhg6dCif/exnmT9/PgMGDIi7/6FDh3j11Vd56qmn2LVrVyyMQWvN9u3b+dnPfsavfvWrzngqPU4wGOR3v/sdF198Mffccw+bNm1qtV1WVhYLFizg61//OkVFqX3RdLwGDhzIU089xcMPP8wjjzzCkSNHWm3Xt29fbrrpJm688UYCMlhEiB7P05rNVYe5b9cK1lUexFCKkOtgKgMPf2CdwsBQ/nuFxp/RVysDhcJA4aHx0Bix4XeKgGFhKKh3HTT+ILV6HIKGxZT8gVzUbyznFA7FTNIxQwghhBBCdL7Dhyt48N63Wbd277HZylrrLxu9/POvGZNQcY7RvFErQQy5eRlc8qnTuezqM7Ht9s9OorVmW3EJK/bt5Y0tOyitrSU3GMQyDDSagGmilMLSBmHP7yJcEw6THQhgGQYRz4sGjkHE9QjYNpZh4HhetGy/cNMwyLQtwo5LbkaQ2nCEiOfRNzubi8eM4vxhwxhR2KvJfRkhhBBCCCGEEEK034wZM6irq4sFLwBNJpQAyM/P5+qrr+aGG25g8ODBHV5DqjO4CtEThOoShzBkGvIdr4CZY8eS/forGPi3f43oT8PjojgzTavqKlIZKl9QUACkHsLQeNCb6B6M4hJqST6zalFRvCFPTeno70Q8qqI8peMIIYToGIHFi1pdvwtYmmTfc845j+HDR7TpfNdf/4WEIQwA/6D1EAbwQyMkhEGki/1B06HMa5K0V0oxZsy49BWUZkOHDsMwDDzPi9tmK3AhYG7fCo4DlgzzER1PlZcRfPXlVrftAi4FNoP/O9iM67o8DLwBvAyc3soxjKpKgi89T+jaGzqq5C5lv7+qyfL7Sdr37duPAQMGpq+gNHJHj0243dy/D1Vdhc6RyYdFz6UOH8bauL7F+n8C8d+hfRdfPD8tNQkhhOgZ5NNZEps2beLFF19s0uHAsizuuOMObrnlFqwUPuD279+fW2+9lZtuuomHHnqIP/zhDziOEwtieOmll7j11lsZN67n3hxIt4svvpiLL76YPXv2sHbtWg4fPkwkEiEvL4+RI0cydepUgsFgm4/bMKtHewUCAW6//XZuu+021q9fz5YtWygpKQGgqKiIcePGMXHiRAz5Ql2IE0JxqIZ7di1nQ+UhDtdXYRkmWvuBClp71DghNA2DyQw/dCc6uKxhEmSlFEZ0nat17P1FAQHDwtOaTMPGNk36Z+TzpeHncVr+ABlwJoQQQgjRDVVW1PLAvYv54P0duG6jJIRk4Qmqo4MY/EfDhhVx3c3nM/n0ocl2SmpvWTkPrf6Q7SWlVNaHqAyFsA1FRX2IesdBAZYysEwVu1Y18L+QqItEyLZt6qPlG0rhav/6N8u2qI04ONGABq9RSENOMEhuMEheMMglY0fz2UmnYsrnaSGEEKLttNxHEkIIIURitbW1sckjGjSEL4wfP54bbriBK664ol3fwbdF4xAIIXqyuiQhDBnyXa8Azh87nssSbNeGEQtIaExVpRbCkJ+fD5B08poaoA6wy1M5quhMRklxq78DzaU6QZFX0CvhdlUmvwNCCNFZjAP7sba0Prv931LY/7Ofvb7N5xw6dBgzZ85h6dL4s1qvwh90O7yVbYFFb1H73R+2+bxCpMJ+b2WT5Q+TtB81ajTZ2dnpKyjNAoEAQ4YMZffuXXHbNIxoUOEw5p5duCNHd05x4qQSfP6fqFCoxXqXRgEMSRzCDwxZDrQ2+in43DMnbAjDH4HbgfeiP++bJltcN7b99NOn9tj+/u7Y5GPZzG1bcU4/oxOqESI9zF07W13/VLL9TJO5c+d1fEFCCCF6DAlhSOL+++/3Z22MBiYEg0HuuusuZs2a1eZjmabJbbfdxujRo/nGN75BOBwG/I4F999/P7/+deLEUQFDhw5l6NDjH0zS0QzDYPLkyUyePLmrSxFCpIGjPVaW7OaPO5dSHq7zQxW0xlIKF1AozOj7hBcNXGh47zCUwkPjaQ9D+TNXKMBQBrYyCXuOH8iAR40bRqHol5HHRf3GMv+U8eTZGV351IUQQgghRCvq6sI8+fd3WfjmeiIRN/kOLSiiaV0pNU3UzjQNppw5jBtumk7/gYXtqOUYrTU7SktZuWcfL2/eSr3j0jcni7LaOgKmgR2diS3sunieR20kQiY2pqFigRKNAxeCpkm968YGVPjXyAZZtkVdxMFQCsfziERne8gNBpg2ZDCzRgxnXJ/ePfaLSSGEEEIIIYQQoidpmIji4osv5oYbbuCMMzqnI+11111HcXEqQ02F6P5C9Ynnrc8wzE6qRHRryQJn48yKa6QcwlAAQGFh8gH6JcCAstIUjio6kyop5mgK7YqKeqd0PF1QkHC7IUEcQgjRaQKLF8Xd9nSSfYPBIFdeeVW7znvDDZ9PGMIA8ATQWtSCteYDVHkZOkmoj0iTUAh75QrM7VvRBb2ITJuB139AV1fVYez332uynCyEYdKknt8/f9So0QlDGLY2emxu3iwhDCItMp74e6vrTeAfwBXAvhSOUxJt+yHQPB4lsORtVEkJOsXwuO7MfvedJssZwDnRH4DQhZew7//uYe3aj/jww9WMGDGys0vsMM6YsUnbmFs2SwiD6NGMVu6FHQUSXy3D+efPit13E0IIcXKSEIYEtNYsX748FsCglOKOO+5oVwBDYzNnzuSOO+7gV7/6VezYy5Yt66CqhRBCdKSPyg/w+P7VrK04SJ0bxjZM6lwH0FQ7YQxUNHbBny3I0ODihzGY0aFoJgpXaRztYSq/Y4UCMkwLI/o+kGUFCBgmC/pP4tODTiPTtLvsOQshhBBCiNY5EZdXX/mI5575gNraMMSbrTFJcEJDG60hpZiBVo6XmWkz95JJfOa6cwlmHN+1o9aaDw4c5NXN29haXMzhqmocz8MyDCrr63G0R6bV9BZSQ0BCXSRCdjCAbRiEPY+G7uQR1yXDsvC0Jux5aK2j183+EzIMg0G5uYRcF8NQXHPqRGaOGEavzMzjei5CCCGEEEIIIYRIjdaaPn36cO2113LdddfRu3dqAzo7ynXXXdep5xMinepDSUIYTAlhEECy0Nk4IQyqppryJIcOBAJkRu+tphLCUAwMLCvzz5ksHEJ0Dq0xSktIJZ4olX9jAC/JoFkVCkFdHch9eSGESDs7ThDCNmBtkn3nz7+MvLz8dp334osvJSsri9ra2rhtHqf1EAbledhLFxO+on0BEKKdtCbz7v8j667fYpQdC0zShkFowaep/tkv0X36dGGBx09VVWJu2hBbrgG2JNnn1FNPS2tNnWHkyFG89dYbcbc3/juwtm4mfNmn0l+UOKmYO7Zhf/Be3O1TgHfOPJtPK8X7769KerxtwPeBPzVbrxyH4EvPU3/TrcdRbdcz9u7B3J84kiJy1jnk5xcwc+ZsZs6c3TmFpYkuLMLr3QejOH40oLVtK6FOrEmIjmaUlrRY908g2RRcV8j1sBBCnPQkhCGBDRs2UF5eHhtY0LdvX2655ZYOOfbNN9/MI488wuHDhwGoqKjg448/ZtKkSR1yfCGEEMfH0R5P7lvD0wfX4miXejdChmFhKIMQDkoZoP2wBQ14WmMohaEUnvbXNQT4ABgoTGXiag8PjdJQ70ZwtEeBncUZvQbx2UFTGJfbr0uftxBCCCGEaElrzXsrt/PIQ8soK62JZi8kS1lIJpWkhmbNgb5987n2xmmcO3107FqzvbTWHKqs4uUtW1m0fSe2aWIZChRkB2yUUtQ7Dl5EUxdx0EDANDGVIqI1plK4WhNxXQKmScTz8LRGAW70WjjDsjA9zz+OhvqIg+N5BEwTlOKcIYO4dOwYRvfu+Qn4QgghRLdxvJcpQgghhDjhnXnmmdxwww1cdNFFWJZ0GxHieIVC4YTbJYRBAMnDDuKE/qqaGspa3XJMfn5B7H5xKgP0j+IPrFRVlWiZya9bUJUVqEiE+MNdfIZhUFBQkPR4Bw8eoOToETygspWfscBtgFFehichDEIIkV5aE1i2tNVNz6Sw+9VXf7bdp87Ozuaiiy7hueeejdtmLbAZGNfKtsCitySEoZNl/+sPybr3nhbrleeR8exTBJYtofzpF3DHT+iC6jqGtfoDVKMAsrUk/1pj0qTJaa2pM4wcOTrh9j1APZABmFs2dUZJ4iQTfOrxpG3yv3Azz159Dd/73rd4/PG/JW1/N3ALcGbzc/3z6R4fwmC/+07SNpFp0zuhks7jjB1HIEEIg7w2iZ5OlZa2WPdUkn1M02T+/MvTU5AQQogeQ75NT2D//v2xx0opLrroouMe4NDAMAwuvPBCHn300SbnkxAGIYToWq72WHx0O88fWsf6ykOgwQMc7eK4HqYy0GgUCqUUhtZ4gBsNVlBKYaBw8QMaDH3sfSPDtFBAneuQYwXx8Dg1uw9fGzmD0Tl9Ouw9RgghhBBCdJzdu47yl7sXsndPMZ7X+Kv/NoYotKYNh5gwaRA33HQ+I0b1Pb5zAiHHYfWBgyzcvpO1hz6hpKYWw1BYSuHh19Q4TEwphVJQF3EwlMKOBi7oaOBCxPUImhYZlhUNW9ANmRGx4+QFg5ySm0NxbS15wSBXTZzAuUMGc0puznE/HyGEEEIIIYQQQrTNY4891tUlCHFCqQ8lngcwKGEnAn/24kSU1n4QQ/N+AymEMDQelF9YWJi0luKGc5aWSghDN9Ew2+gFwIv4/0bF+IEZDX9+Mn4CbmYmZgrBLv/5nz/l2WfjDyW4HD+EQZWXQ/8Bx1m9EEKIRMwtm+POKp0shCEnJ5fZs+ce1/kXLPhMwhAGgCeAf2tlfWDJ261fn4i0yPj7o60GMDRmHD1Cwac/Rdkbi/EGDe6kyjqW/d7KJssfprDPiRHCMCrhdg3sACYC1pYtnVGSOJloTfCfid91dFYW4U9dSTAY5H//927GjZvAf/7nv+I1Ck1pzXeBt4nNLQP4AQbGoYN4PfizRrIQBp2VjTN5SucU00ncMWPhnWVxt1ubNnZiNUJ0PKOsaQjDYfzXr0TOP38WRUUyuZQQQpzs5Fu+BEpKSoBjM5mPHDmyQ48/alTTD9OlraQqCSGE6Dxhz+X3297m/bI91LoRlAeZdoBaN4KhVXRGXy86MM2f+bdxEIMHmIChFFr7f3oaNBpQOK6Lg8YyDE4J5nJhv7F8euBkLENmPhFCCCGE6G4qK+t48L7FrP5gF5GIm6azKFA6bhBDIGAybeY4Pn/L+WRlBzvkjBV19fx51Xus/+QohoLacISAaRIwTRzPpTYc8StTiqBlHutPo/0vTOsjDtkBG1Mp3Og1sas1ntYETBMF1DoOGgi5LhqN43pkBwI4nseMoUO5ceoU+uRkd8jzEUIIIYQQQgghhBCiq9VHwgm3Z0oIg4DUBi+2MshR1VQnDWHIbxSkYNs2eXn5VFZWxG3fEMJglJeReDiN6Cyq2O+nOCD605qSh/6ON3xESsfLzc1LuL3ht8MoLyNd34AIIYTw2cuXtLp+N/BBkn0vuuhiMjIyjuv8c+fOIzc3j6qqyrhtnqP1EAbzwH7M7dtwR485rhpEcqqkhOx//VFKbY3io+Te8S9UPPU8JAn66o7s91Y1WU4WwjBo0GAKC3v+4MdRo0YnbbMFP4TB3L4VXBdSCN8SIhXmxg1Yu3YmbBO69FPonFzA7zP01a9+ncrKCn73u18l3G8JsBCY12id0prgS89Td/tXj6/wLpQshCFy1tlg251UTedwxk1IuN3ctxdVWYHOy++kioToWKq0pMny3yDpPZErrrgqbfUIIYToOeRbvgSqq6ubLDdODe8IeXn+lx0Ns0LW1NR06PGFEEKkps6N8G7pLh7a8x57a8swlSLs+R+ptBPGHzqmMZSBiR/O46ExojMEm8pAa89fh4qledrKH8xW60YwMTCUQa5pcd2gqVx2ygQKApld9pyFEEIIIUTrnIjLq698xIvPr6Gqsr79B1LEDVdo0bBZEEN+r0w+fe25zL3oVIwO6DQRchzWHDjEwu07WLV3P7WRCJm2RZZtE3ZdMiwTFBiGgaH8wusdB4CAacSeiooGLrhak2lb1IQjeFqjtY4Fj1mGScDw6JebQ8hxqQ6HGdQrj4vHjGb60CEMLpAv4oQQQgghhBBCCCHEiaU+nDiEIeME65Qv2kmlcK9Xt7yprGpqUghhaHrftaioKKUQBlUmEwZ1F0ZJcdI2uk+flI+Xm5ubcHvDMFxVXp7yMYUQQrRPYNnSVtc/m8K+l1++4LjPn5GRwaWXXs4TT/w9bpuPgL3AkFa2BRYvpE5CGNIu8/6/YCQIymgusGwJGQ/+lfrbvpTGqtLAdbFWv99kVbIQhlNPnZy+ejrRKaf0Jysri9ra2rhttkb/VKEQ5q6duCkENwiRiuCLzyVtU//Z65ssK6X4znd+wLJlS3j//VVx9vL9kqYhDACBV1/usSEMxieHkoZWRKbN6KRqOo8z4dSkbcyNG3HOPa8TqhGi4xnNJs5+OEl70zSZP//y9BUkhBCix5AQhgSaf0FVUlISp2X7lJX5X5FprVFKJf3yQwghRMcrDdXwhx1L2Fx1mOJQNRmGCdEQBgOIaI+GIWVG9PXaVAaO9nDRWNHIBQOFh8bVHgoV28fRGgUUBDIZkdWbr42cwbDswi58xkIIIYQQojVaazZvOsijDy1j9+5itJdSgsJxUY0fKRgyrIgbb5vFhFMHddg5Nh05yn3vfcDR6lrqIhFqIxECpoHjeRypqcH1NIZSBE0zVo+K1hNyHGwzgG0ahF0XFf0rcTxNhmWSFbCpizigNRHXQwERz8NQfjRZdiDAJWNG84WppxGU2f6EEEKIzpP+yxghhBBCCCFEI/VOJOH2jICEMAhSm6XY81rMdqtqaogfp+DLzy9oslxYWMSuBANGGob7N+98LrpOshAGHQyis3NSPl7qIQzJIj6EEEIcF9fFXrG81U0vJNk1KyuLuXObD2ltn8svvzJhCENDPV9vZb29eFGPHUTbY9TVkfnAvW3eLednPyU8dx7e8BFpKCo9zI0bMGqOTZIZBj5Oss+kSSdGCINSihEjRrF+/bq4bbY0emxt+FhCGESHCb70fMLtXmEhkRkzW6y3bZu77rqbmTPPJRKJf+9jIbAGmNp433ffQZWWoAuL2ld0F7LffSdpm8h50zuhks7ljh+ftI21cb2EMIgey2gURvoREP8d2TdnzgUUFfW81zAhhBAdT3rAJ1BY6A+SVcofhrBly5ZEzdus+fHkzVkIITpPnRvh3dJd3L1zOSXhGgAiuKDBwECjUcrABFwNGh0LXVAcm9jY0/6gNYUfxJBlBgh7LhHtH8vRLsOzi/jysGmc3msQAUPeeoUQQgghupvKyjoeeXApq97djuN4qe/YcFHYnu3R9YYBZ5wzghtvnUVR744JZww5Dh8eOMTyXXtYtmcPAL2zsqiod7BMAyvaiTfienjKpd5x0FqTYVtYhkHE8zBRuPjhCkHLwvU0rtbo6A+AZRgETAPDMsm0bKrDYTytGZify8VjRjFj2FCGFOTH7qsIIYQQQgghhBBCCHEiqk8wEAEgaAc6qRLRraVyn9Rrdn9aa1RtDcnmRM7Ly2uynKwPWsNwfxmA330kC2Hwinqn9jsU1fx3ornyhvOWlydoJYQQ4nhZ69dhVJS3WF8GtB7NcMwFF1xEVlZWh9Qxc+ZssrKyqK2tjdvmeVoPYQi8sxzCYQjINW26BN58rV3hWKq2lpyf/ojKR59IQ1XpEVixrMnyRiDxpymYNOm0tNXT2UaNShzCsLXRY2v9x4SuvDr9RYkTnrllM9bWxOOgQpd+CuJMrjJy5GhuueWL3HvvPQmPcS/w50bLynUJvPEaoes+18aKu579TuJ3aR0MEjn9jE6qpvPovHzcIUMx9+6JrfMAB2i4CrA2buiK0oToEKr02MTcD6fQ/roe+PolhBAiPWQkaAJDhw6NPdZa89Zbb/H//t//I9ABN5IikQhvvfUWSqnY4IUhQ4Yc93GFEEIkt6e2lP/buZTt1cWUR+rIMCzq3Yg/c6/2QLto/OAFhcJUCk9rf53WKKWwlIGjPTw0Wh+bxdhQCqUgxwzQJ5jD7N6j+cKQs7ANM35BQgghhBCiS2itefONj3nq8VVUV9c3yUtIrStjshSGRgdq3ExDZobFJZedzqevPwfTTGEGtBS4nsfrW7fz+pZtlNTWcbi6Gk9rTMNgT3kFYdclaJpg+HX5/TUVhlKEXDcaqmAS8Tz/uheIuC5ByyTTtqiLODha4+mG7f51clF2FrZh0iszk+unTGLe6JESvCCEEEJ0pSSXJ0IIIYQQQoiOFXLchNszZMCaAD+RNxnd7ANdXR1K66QhDLm5TQfcFyaZabRhuH97BvuJ9FDFRxNu94p6t+l4eXn5CbeX4w+mUeXyOyCEEOlkL1va6vpXgcRXkHDppZd3WB2ZmZnMmjWXV199KW6bxfjvDwXN1qvaGuwP3iMybUaH1SOaCr72Svv3ff1VAm+9TnjexR1YUfrY7zQNYXg/hX0mTz5xQhhGjBiVcHvjEAYzQViDEG0RfPG5pG1Cl1+ZcPs3vnEnDz/8AKFQKG6bvwO/AXIan/vVl3tmCMOyxQm3R844C4LBTqmls5SXl7Fjx3YO5OWzE9iC/5q0Dfgt8C/RdtbG9V1VohDHzSjz74G4+K9ZieTnF3DRRfPTXpMQQoieQUIYEhg7diy9e/empMRPOyorK+Oee+7hjjvuOO5j/+Uvf6GkpCQ2KKF3796MGzfuuI8rhBAiPkd7LDq6hT/vfIdqN0zYc6J9GHQ0cMHAUOBpQGkcrbEUfhADBi4eLhorOpJOoQgYFqAJeS4mUOdGMJXBrN6juLL/JMbl9pMBaEIIIYQQ3dDu3Ue5/9632bnzCK7bcqRiw5qkV3JKtewY22o7/4++ffO44QvTOWfa6LaUm1DIcdh05CjPb9jEx4cOkxMMELRMlIJM00IpRcR1CWtNyPUDxzItC1MZgBerP+y6ZNoWlmHgeG4sZAHANAyyAjZ1EYeAaRJyXRzXwzINsu0AM4YNZdaIYQwv7NVhz0sIIYQQQgghhBDpMX78+LQd2zAMcnJyyMnJIT8/nzFjxjBp0iTOOussxowZk7bzCtGV6lwn4faMYEYnVSK6NSOFfgOe12RR1dQApBDCkNtkOdUQBlVelrwm0SmM4uKE23XvtoUw9OqV+F69xv+9CpaXt+m4Qggh2iawfEmr6+NHIfhM02Tu3HkdWssll1zaaghDdlYW82truZJjs1w3Zy9eJCEM6eI4BN56/bgOkfPtb1C2dCW6V+GxlVpjHNiPqqrCHTwEcnLiH6CzuC72uyuarEoWwtC7d2/69x+Qvpo62ahRifuJFAOlQCFgrf+4M0oSJ4Hgi88n3O4VFBA5f1bCNv369ePaaz/HI488ELdNFfAkcGujdYHFC6G2FrKyUi+4ixl792Dt2pmwTeS86Z1UTee4+OLZfPjhmrjbtzR6bG7e5N+7SCVoUojuxPNQZf59sI3AkSTNFyz4NBkZck9XCCGET0IYkpg1axbPPPMMSim01tx3332MGDGCT33qU+0+5iuvvMKf//zn2DGVUsyalfiDixBCiOOzofIQD+99j7UVBwh5DpYycLSHQlHjRqIhDBowMJQ/2EwDHhoThREdW+cBrtYY0WAFU4GlLDSQb2XQK5DFl4dP45zCYV33ZIUQQgghRFy1NSFeeeUjXn7xI+rqwknba1IJYiDhjNNKwYSJg7j1y7MZMKAwfsM2Kq+r5+0dO1m8Yxd7yyqoCNVjKoOqUBhH+511lamOFaEUhlKEXRdDKWzTQDl+6YZSOJ7nBzTYFrVhjRvt8Ntw78LTmgzLZEh+PqX19fTKyODzU6dw2oBTyDvBEt6FEEIIIYQQQogTmU4lULKdXNeloqKCiooKDhw4wKZNm3j+eb+z92mnncYXvvAFLrvssrSdX4iuEHITz2MclHtnAvx7tMm0CGGoBtIXwmCUliavSXQKoyRxCINX1LYQhvz8gqRtSoEBEsQhhBDpEw5jr3y3xeoI8GqSXc8++1x69eq475UBLrzwkli/9VNO6c/FF1/KJZfMZ8aMWZwy+zysHdvj7htYvJDaH/+0Q+sRPvv9VRjHGYpkHv6EnB/cSdW9D4HrkvnAvWT9/jcYxUdjbZyJk6i77UvUX/c5sLpm+Ii1cT1GRXmTde8l2ef00884oSZBGzlyVNI2G4EZ+P+u6uhRdJ8+aa9LnLjM7duwNm1I2CZ8yWVg20mPdcstX0wYwgBwH01DGFRdHYHFiwhfenkK1XYPgWWtByg1Fpk1pxMq6TzJrjkahzAY1VUY+/biDR2W1pqE6GiqsgIVvYf7UQrtr732+rTWI4QQomeREIYkbr/9dp5//nlc10UpheM4/PCHP2TTpk1885vfbFOyUX19PX/84x958MEHY8cDP7H0i1/8YrqeghBCnNS01rx2eBP371lJvRch5DoETQutQaEwo18suPgBCyoasGBi4CgPT4OhNAqFER1+ZyuDiPZnEHY8jzAeuVaQBQMmcUHfsQzKLOjCZyyEEEIIIeLZvOkg9/1lEQcPlrdpsEHyIAYVbaCbhDHYAZPzZ43j8zedT2ZmvHlD2s5xPbaXlHDfqg/4pKqa7IBN2HUJmia2aeJ6HnVh/0uDOqXItCyMhuegNQoIuy4B08Q2DcKuh2oIIfM0lmmQHbCpCfthZWHXQ6NxPI/8jAw84JIxo/nU+LH0ycnusOclhBBCCCGEEEKIztNZgxga34P56KOPWLt2Lc899xy//OUvKSpKPEhYiJ6irtnA+eZk1jQBUFJTw178fgm62Z8efie+oegmeb+qpgZN8hCGnJymIQzJXl+PRs9tlEkIQ3ehSkoSbm9rCEMqA3fLgEFlEsIghBDpYn24BlVb02L9O0B5kn0vumh+h9fTu3dvfvWr3zN58mmcdtrpGI1msI7MmpMwhMFa+xGqtASdJOhJtJ29ckXSNpEzzsRe/UHCNhnPPYsu6IW5cyeBpW+32G5t+JjcO79B8IV/UvHI49AFn1Hs5cuaLNcC65PsM2XK1LTV0xVGjRqdtM0G/BAG8P/dIrPnprUmcWILvvR80jahT12Z0rEmTjyVqVPPYM2a1XHbrMT/f31q4xpeebFHhTDYzV5DHZoOutNZ2USmntmpNaXbyJGjWLTorbjbNzVbtjZuICwhDKKHMTdvjj1el6RtQUEBZ5xxVnoLEkII0aNICEMSw4YN4zOf+QyPP/44SimUUriuy4MPPsgLL7zAggULuOiiixg3bhyBQMsBFZFIhE2bNvH666/z/PPPU1JSEptBsuHPa665hmHDhnX+kxNCiBPcxxUHeerAR7xTuhNPazw0Lh6uG4lOVqz9MAalMFE42sNFoxrWaYWrNK7WmNGOaArING0Mz8BQiizTZnh2Ed8bcwEDMvK79PkKIYQQQojWhUIR/nrv26xcuR0n4pIwf8G/UGwnP4whK9PmovmTufozZ2MHOu7Wy+Gqalbs2ctb23ayo7iEsOcRNA1qwzYh1yEzOmOFEb1/AX7YggKCpompFG40dMzVfqhChmXhaQfH89Ba40X/chQKyzQZkJuDVlBZV8/wokKunDiOKaf0pyBTOo4LIYQQQpzstNZs3LiRHTt2UFFRQVVVFZ7nsWDBAgYNGtTV5QkhhEiitYDK5sEMiUIsG7dtSzutNcuWLeOaa67hySefpHfvtg0qFaI7qk8awpDZSZWI7uzZd1fwvQTbi4DNzX6XVE0NIfwZsxPJzc1rslyYZIBkBKgCMstlAH53YZQUJ9zutfH9Mj+/IGmbUkA1m41aCCFExwksb30m7ZdT2Peiiy7p2GKibrrp1lbXh2dfQOYD98XdT2lNYNkSQldenZa6TmbW+6sSbneHDqPioX9QeN5UjOqqhG0zH7o/6fkCixeR++2vU3X3fdBJ4YwN7BVNQxg+BNwk+0ydekba6ukKubl5DBo0mP3798Vt0ziYwlovIQzi+ARebBrC8DEwEWiI4fFy8wjPnJPy8T73uZsShjAA/B3478Y1vPEqOA5YPWDomucRWNb0/fsW/HCJ6dGfsyafRv/oZDgnijFjxiXcvhf/HkJD/KO1cT3h+ZeluywhOlTWn/4Qe7w2SduJEyd1Woi1EEKInqEHXMl2vR/+8Ids3LiRdevWxYIYtNYUFxdz//33c//992NZFgMHDiQvL4/MzEzq6uqorKxk//79uK5/i6Ch40HDm7FSismTJ/PDH/6wy56bEEKcqF4+tIFH971PtRPC8zRZlk2tG0GjUBybVcJFY0ZDFxrG2zXMdGwohdYNf/ohDgpFnevgoRmUkc/l/U/lU6ecSrbVcTMbCyGEEEKIjqG1Zs3qXTz04DKKj1YmDl9orh1hDBkZFrMvmMg1155LVlbHXR9qrVm8czd/X7OWkOtQH3ZwtSbTMtFAeX09ruehUGRYVpN7FwaKsOsSME0Cpkmt48TuT7ieh21aZNkWdRGHsOvieB444Gq/s2/E88gJBph/+iRuOH0ytmkSDifrCiGEEEKILtXuQKkTx+HDh1m3bh1r165l3bp1rF+/npqaY7PODRw4kEWLFnVaPV/4whd477332r3/L37xC66+uvt0cN68eTMPPPAACxcupLa2tsX2M844o9UQhvvuu4+dO3cCMGDAAL7xjW+kvVYhhBCt+/rXvx57XFVVxRNPPEEoFAKO9WsoKChgwoQJDBo0iJycHAKBANXV1ZSXl7NlyxZ27dqF4zix+xAAp512GjNmzMBxHCorKykuLmbt2rUcPnwYONZXQmvNwYMH+frXv86jjz6Kbdud+fSF6HB1SW48BiXQVECT2aZb4wG0CGGopjKFY+fm5jZZLipKPmC/GBhaWprC0UXaaZ00hEH37tOmQxYUFCRtUwYYZRLEIYQQ6WIvX9rq+teS7Dd8+AhGjRrd8QUlEJk+A21ZKMeJ28ZevEhCGDqa52F/kPi+cXj6+eh+/aj5t5+R+71vdchpM555ksj086n//E0dcryUuC72uyuarHo/hd2mTDmxQhgAxo4dlzCEYUOjx9b6ZHN1CxGfsXsX9sfHhhofAk4HhuIHC9wE9LnoEggGUz7mVVd9mn/91x9RW1sTt80TwH/hd7sCMMrLsd99h8j5s9r8HDqbuXEDRnHTz2bLgd3AduBhgJUrKBg3jLPOOoezzjqHiy++lPHjJ3R6rR1p7NjEIQwAm4Gzoo+tDesTNRWi2zE/Xkfw9Vdjy8neXSdMmJjegoQQQvQ4EsKQgoyMDP7yl79w4403sm3btiadCBo6IEQiEXbv3g0QG+jQXPMZHkaPHs2f//xngm344CKEECKxbdVHeXL/GhYWbwOtiWgPjaba9WfW0WgMZWACntZowENjojCVgaM9XDREwxcAAoaJhUG955BlBjANg3N6DeWOkbPIseU1XAghhBCiO6qoqOUfj63gnXe2Eom0MTSgIYChURBDw2JrbNvknPNG8bkvTKegV3a7a27ucFU1K/bs5e3tO9laXELANOmdlUVNJIJlKMxop13LUHjaD1sAyLQtbMMg5DgYhsLTEIkGMdiGQcTzotfG0aerFJZpkGFZFGZlUlpXh/IUE/v1Zd7okZw/ciiFWTJbnxBCCCG6t9WrV/Pggw+ydu1ajhw50tXlnJDC4TC/+MUvePzxx4HUZlBvrE+fPvz2t7+Nfc921VVXtRrWIIQQIv0aQhjWr1/P1772NUKhEFprTNPk6quv5jOf+QynnXZawmNUV1fz8ssv8+ijj7J9+3aUUqxdu5ZTTz2VH//4x00GG2/evJn77ruPl19+uUl45Nq1a3nyySf53Oc+l9bnK0S61ScJYcjIzOqkSkR3ZpiJQxg00DxJWNXWphTCkJOT02S5qKgw6T7FwLDy8hSOLtJNVVWiwuGEbbwUgjUas22b7Owcamqq47YpBZQEcQghRHrU1WG/v6rF6oM0neW+NRdddEmnz7yrc/OInHk2gZUr4rYJLF7kX6vIrMAdxtyxHSPJ9Zhz1jkA1N94C4HXXia48M0OOXf2v/2E8LyL8E7p3yHHS8b6eC1GZUWTdYXAOcBHQKiVfYYMGUZRUVH6i+tkY8eOZ2GCf8cmIQwbPk5/QeKEFXzphSbLjwIusBP4V+CnwNwtm7nu+We55JLLUhrTlJOTy4IFV/P3vz8at81OYA3QOEIl8OpLPSKEIbB0cZPlg/gBDM2Vl5fz5puv8+abr2PbgR4fwjBmzNikbTbSKIShUbiHED1B1v/+NvZ4M3A4SfuJEyeltR4hhBA9T+Jvd0RMr169ePrpp/nsZz/rD1SIfunV0EGgtWCGeNu01lx//fU8/fTT9OrVq2uekBBCnGC01rz2yUZ+tvl1lhRvB08TNPysIQO/I5eHxuPY67QZfRtsWKcAExUda6dxogEOntaEtIOhFIOy8vnK8On8eOyFEsAghBBCCNFNvf/eDn7w3X+wZMmmtgcwNGgUwBCPaRpMPHUQ//Wra/naNy/qsACG2nCYv7z7Hj9+9U2eWreeTUeO4nkeYcdlb3kFVaEQjteyOEP5QQwR1yNgGLEBDQqIeB5KKTIti0B0EITreTieh+tpHM8jK+DPOjk4P59/v3AOv738EuaPHS0BDEIIIURPo1Xn/nQTH3/8MW+++aYEMKRJXV0dX/jCF3j88cfbHL7Q4PLLL6ewsDD2XdmLL76YjlKFEEKkaMOGDdx4440cOXIErTXDhg3jmWee4Wc/+1nSAAbwB/xee+21PPfcc3zta1+LvT/87W9/4/vf/36TtuPGjeO3v/0tv//977Ft//5Dw32L+++/H9dt5/0bIboB7XmtDhhqLCAhDAJQKnE3PQ+g2X1fVVOdUghDbm5ek+XCwuSD1YoBo6IcEsx4LTqHajbTamu8dgxATNYvsQz8wZB1dW0+thBCiMTs91e1GrDzRgr7zp17YccXlILI7LkJt5sH9mNu39ZJ1ZwcrNXvJ20TiYYwoBTVf/gTXgeNOzCqKsn65c875FipCLy9sMW6G4GVQCXwAfCb7/+Y66//POPGjUcpxemnT+20+jrTuHHjE24/AhyNPja3bZVrNdFuwZeea7L8t2bbNbBw/Tpuv/1mJk8ew7/+6w9b/f6nuauvviZpmyea1/LaKy1CB7ujwNtvNVmOH010zNlnn5OeYjpRYWERvXv3SdhmY6PH5p7dqPKy9BYlRAdRxcUEXz4WSvOnFPaZMGFi+goSQgjRI1ldXUBPEgwG+c///E+uvPJKHn74YRYuXNikM0DjsIUGjT+ImKbJvHnzuPnmmzn99NM7rW4hhDjRlYRreHjPKl49sglXayKeg6EMwp6LRmNGOzNo7YcruGhM7Q9S87R/I8kDTPyxdgpFlmkT8Txc7WEqA9swuWbgFK4ZeDrZVqALn60QQgghhIinqrKOu//0JuvW7cN1vaQhCknFCWIwDOjbN5+bbp3FlKlDj/MkxxyuqmbNgYO8sGEzn1RVU5iViW2YKKUImv6fyoGI5xKO3o/ItC0swyDserEvLCOuS1bAJmAYhDwPpf0wMvDvXWRYFihFbjBAXcQh5EYImBYD8/O4aPQozh0yiMIs6RguhBBCiBNHVlYWtbW1XV1GzIMPPtim9qNGjUpTJam78847Wbt2bex7MKUU8+bNY/r06fTv358vf/nLSY9hWRbz5s3jySefBGDp0qV89atfTWvdQgghWldXV8c3vvGN2Pvj0KFDeeyxx+jdu22zbIP/+v6Nb3yD3NxcfvnLXwLw8ssvc9ppp/GFL3yhSdv58+dTVVXFT3/609h7yqFDh1i5ciXTp08/zmclRNcIp3CdGcyUkFMBhpk4hEFDi0EpqqYmxRCG3CbL+fkFGIaB53lN1ucAfYDeQEOvB1VRgT4BZxjuSYwSP4RhCbAO6Iv/79TwZxHgFbX9PTo/v4D9+/fF3V7acP4jh/GGDmvz8YUQQsRnv7O01fWvJ9kvIyODc8+d1vEFpSA8aw7ZSQbl20sW4Y4e00kVnfisDesTbvcKCnBHjT623O8UKu/5K/mf+yyqA8IMM556nNrv/xhvwMDjPlYygUVvxd8GTOk/gCHf+QE3Ru8VVFdXUVVVlfa6ukKyEAaADcBsQHke1oaPcc48O91liROMsW8v9prVseXN+J814ikrK2PXrp0pBW5PmzaD3r17U5wgTO5J4H/wu10BmPv3Ya1fhzMpefBrl6muxn73nSar3onTtEEwGGTy5ClpK6kzjR07juLio3G3b2y2bK3/mMiMmektSogOEHz9ldh1kws8lqR9VlYW48ZNSHtdQgghehYJYWiHM844gzPOOIPDhw+zcuVK1qxZw8aNGykrK6OyspKamhqys7PJy8ujsLCQCRMmcPrpp3PeeefRt2/fri5fCCFOGFprFh7dyt/3r2ZPrf/1sIFCR7eFcdGAoz1MFKZSeFpHQxc0JgpLGTjaw0M3GWDXENiQbQUYnlXEF4edx+kFg7riaQohhBBCiCS01ixfuoW//e0dyssbZgFQ0RCF40xiiAYxKEApyMoKsuDTZ3Lp5VMwjMSdZlO1o6SUlzdtYe3BTzhcXUNtOIxlGNSEw0Q8D9NoFPqo/NgwQynCroupFLZpYERnjzSUwvE8PK39sAXHIeS6oDVew3atCZgmRVlZ1EUiDMzP4yvnnsXQggLMDnpOQgghhOg6ybtHndiys7OZOHEikyZNYvLkyUyaNIn9+/dz4403dnVpMdOmdU1H6vZatGgRb7/9duyadOjQofzf//0fY8Y07XCdSue8uXPn8uSTT6K15uOPP6a+vp6MjIy01C2EECK+Bx98kIMHDwL+6/fPf/7zdgUwNHbzzTfz9ttvs2rVKrTW3HXXXVx11VXk5OQ0affZz36WJ554gg0bNsTWvf/++xLCIHqsUHV10jbBLAlhEGAYZsLtHkCz0IRUQxhycpqGMBiGwV//+gi9jh5m+A++Q2/8gfytXXkbZaW4EsLQpYySEgCeAf6vle0K6DV/LjPOn81f//pwysftlWSm7IZ5S43DEsIghBAdLbCsZQiDC7yZZL9zz51GZhcFeDlTpuLlF2BUlMdtE1i8iPovfqXzijrBWZuaD2ltypk0xZ8hopHI3Aup+t+7yf3GV1DH2RdCRSJk3nsPNf+eOHzjeKnKCqwP3kvYJjzngmhfCF9OTm6La9wTxejRY5O2aQhhALA/XC0hDKLNGs/6DvBUCvtcf/0XkjfCD2S9/PIreeih++O22QO8B5zTaF3glZe6dQhDYNkSVDjcZN2SJPtMmTKVYDCYvqI60ZgxY3nnnWVxt7cIYVi3VkIYRPenNVm//01scTNQnmSXSy/9lHx3LYQQogUJYTgO/fr148orr+TKK6/s6lKEEOKkE/Fc7t/zLi8e2oCjXSKeS8Aw0VqjooPSdHTG38ahC6YycLWHBxhao5TCiLa3lEnIc1BAxHPItoPcNvRcLuw7jhzrxLhJIoQQQghxoikrq+GhB5fywfu7cF0v+Q7toBTYlsG5543mxltnkpPTMTfay2rreHfPXp5ctx7H1eQFAziuS6ZtYRoGnqcJOQ6uBwpFpm1hNPQ70BoFhFyXgGkSMA3qHRfVEDqmNZZhkGFZfg6Fgkg0nMH1PAoyM8jPyOCqieM5f8Qw8k6QLwWFEEIIcfKaO3cuM2bMYMSIES3Csvbv399FVZ0Y7r77bsAPP+vduzePPvpou0PHJ02aFHvsui47duxg4sSJHVKnEEKI1D3++OOx8JxTTz2Vs846q0OOe+utt7Jq1SqUUlRXV/PSSy9x3XXXtWj3uc99jh//+MexGj788MMOOb8QXSFSnXx2VjtDQhgEKCNxaJkHKO01njsCVVNNst8wwzDIyspqsf7yy6/A2L2LZPEKqrQ0SQuRbkaJP4PskTjbNVBaVkZNTfLQl8by8wsSbm/4lzcOH2rTcYUQQiSmqquwPlzdYr2HH7bzOvBaZiaH6+patJkzZ17a64vLNInMnE3wxefiNgksXwbhMAQCnVfXCczauD7hdmdC6/dNQ5+9Hl1YSO6/3I5RXn5cNWQ88TdqfvJvYNvHdZxE7GVLYzNQxxOZc0Hazt/dZGdnM2TIMPbu3R23TePfDGtNy9cTIZIJvvh8k+UnkrTPzc3jggsuTPn4CxZ8OmEIA8CzNA1hCL76MrU/+EnK5+hsgbfeaLJcBnyUZJ+zzz43XeV0ujFjxiXcvguoBRruPljr5H6u6P4yHn4As9H77Scp7HP99Z9PWz1CCCF6LglhEEII0eO8W7qLx/Z9wMbKT1AKHO3hoQl5Lhp/0Jmh/Zl7TA0uOha6YCiFRuGhcdEY2u/ooFAEDBNPe+TbmQzPLuKOkbMYmlXYpc9VCCGEEELEt2LFNh68fzFVVaHEDRXQzkkgDKUYPrwPN39xFqNG9Utpdt9EXM9j/SdHWLJzF+/tO8AnlVVoIGAaVNTX43getunfrlHKv6ZVQNh1UUqRYZlYhoHjeRhK4WmN43kETBNPa8Kuh9YaHZv1QmEYisH5+TieR204zOmDBnDlhPGM6VOEbSaefU0IIYQQPdDxTX7VYw0ZMqSrSzghFRcXs2HDhth18B133NHuAAaAoqIiCgsLKY0O9Nq1a5eEMAghRCfbvHkzR44cib22z5o1q8OOPW3aNAKBAJFIBIClS5e2GsJw7rnHOihrrfnkk1S6PwrRPYVTGBQdyGw5QF6cfJSR+F6sBmg2m7GqqaEyyXFzc/Pi3rfWhcn7OxjlEsLQ1RqCMI4made7d582HbdXr14Jt5dF/zQOy/uwEEJ0JHvlilYHnNvA9dGf8j/dx0fDR/D22wt5++2FrFq1gnA4zJwuHogenj03YQiDqq3B/uA9ItNmdF5RJyh15AhGceJ3f2fiqXG3heddTOnKD8n6010En/wHZrP388gZZ1L7jTvJfPh+Am8vjHsco6SEwMI3CV9yadueQBsEFr2VcLs2DMIzZ6ft/N3R+PHjE4YwbGj0uLVQFyESMQ4dxH5/VWx5A01/p1pzySWXtmnm93POOY9+/U7hcILPEi8A/9No2dq4HmP3Lrxhw1M+T6fRmsDCpiEMy0j+lev06SfO++HYsYlDGDSwBTg9umytW5vukoQ4Pp5H9i9/1mRVcQq7nXPOeempRwghRI8mIQxCCCF6lKf3f8jjB9ZQ44bRaDIMG8+NAApDgatBRwMWzGgQQ2w2YDQmClMp0GAqAy8a4KC0R60bJt/O5JYh5zCzzygKbJmRRAghhBCiO6qsrOOPd73Bhg37cd0URhm2YyCiUpCTk8HVnzmLeRdOwraPP6wg5Dg89MGHvLt7LyioC4cxlCJoWXjaoyoUwtMaw1BkWMeCGLT2/ww7DkHTJGCaOJ4X65Drao2lDDIsC4VDyPVwPI3rOTieh2kYhF2Xvjk5zJ96GheMHnncYRJCCCGEEOLksGbNmljAl2VZXHbZZcd9zF69esVCGMrKypK0FkII0dG2bNkC+OEHSikGDhzYYce2bZvevXtz6NAhtNZs3bq11XYDBgwgNzeX6mp/8HplZbIhxkJ0Y2GHU4EQEG72ZwhwgECWfO8sQBmJ78l6AJ7XdJ+aGgrxZw+tbPRT1ahNbm5u3GPq3Dy0aSacebghAEB0HaOyAkgewlBU1LtNx83PL0i4veFf3jx8uE3HFUIIkZi9bGnC7VopnOkzmNirkIkTT+XrX7+Dmpoa3ntvZdIBkOkWnjUnaRt7ySIJYegA1sb1CbdvBJ5c9xE73ltJTk4us2fPYfbsCzAMI9ZGFxZR86//Qc1P/g1zy2aMo0fAdXHHjsMb4H/W1/n5CUMYADKe/Ef6Qhi0JrA48fmd089A9zq5JksbO3Y8r7/+atztG/C7uSjA2rkDVVZ60v0difYLvPxCk+WnUthnwYKr23QO0zS5/PIruP/+e+O22QxsBcY0Whd87WXqvvL1Np2rM5ibNmIePNBk3ZJk+5gmZ599bpJWPceYMcmvQTZyLITB3LEdVV2Fzol/T0KIrmRu3YLR7J5XSZJ9cnJyCQQC6StKCCFEjyUhDEIIIXqErdVH+Pu+D1hasgOlIOL5nQRq3BB+xIIB0YAFLxq60BDEYCoDR3t+pwWtMaOzCQcMEwOTsOeSb2cyLKuQH46ZR7+MvC57nkIIIYQQIj6tNcuXbeXRR5dRWVGf2k6xFANSDmMwLYNJpw7mS1+dS2FhTrvrBXA8jw2fHGHJjl28s3svpXV1ZNoWBRkZVIcj2KaBUv41q2kYaM8j5PjXuhmWhW2YhFwHEwMXTcR1sU2DoGkScl201njRQXFKKZQyKMoM0jsniyPVNZiGwdyRwzln6GBO638Ktnn8YRJCCCGEEOLkcfSoPwxIKcXQoUPJyjr+WZxzco5dY9fW1h738YQQQrRNcXHT+Z6CwWCHHr/xrHklJfG7NRYUFMRCGKqqquK2E6K7G9irgI8TbPeA8lMnE38IvDhZGEbie7OthjDU1nAtcG0rbauBozNnU/LrP8Q/qFLoXr1QxfHn+jPKJRitq6mKcgCOJGnX1hCGXr16Jdze8C9vJJi9VgghRNvZyxOHMDiTTmsxmDo7O5s5cy5IZ1kp8YYMxRkxEmvnjrhtAosXUfujn3ZiVScma+vmVtdXAzcDzwD89S+x9X/+8x+ZMOFU7rrrbiZPntJ0J8PAHT8Bd/yEFseLTJuBM3oM1rbWQxIBAovehLo6yOz48Dhz+zbMfXsTtgl3g9/9zpYscKUUOAQMiC5bH31I5CT8exLtE3zx+dhjDTyZpH1eXj6zZs1t83kuueSyhCEMAM8D32u0HHi1e4YwBN56vcW6xUn2Oe20KeScQAEEffr0oVevXgnD0zc2eqy0xly/Hufc89JfnBDtYBw62GJd/LtjvsJCCTwSQgjROiN5EyGEEKJrLSnexn9teY2VpbtQGgLK75xgoGJj6TQert8tARN/BomGMXYquk5FH/uBDP4AtnrPocDO5LpBZ/Af4y+VAAYhhBBCiG6qrKyGu/73de65+63UAxgaa5gmIAGloFdhNnd+91J++JMrjjuAYXdpGT99bSG/W/IO7+zeQ0ltLaZShB2XAxWV1EciON6xZIiG61VDKUKOi+tpP6QB5c9OCUQ8D6UUQcskGA1UcD2PsOsSdl1cz8M0DeodlzF9evM/l17E16afy5mDBkoAgxBCCCGEaLOGwbHQNDzheDQOXujogb9CCCGSc5vNht48lOF4NT5e83M11jiswZR7FqInC4cTbjYAAnLNI2gya3FrNPiBwo2omprWjwXkAQOLihg+fETC43pJZsxVZaUJt4v0U5UVeCQfDNCnT582HTc/vyDh9oZ/eQlhEEKIjqPKSrHWr0vYJjL9/E6qpu3q6+t5dfQY7gQmAHtaaWN99CGqNNk8wiIZc8f2Futc4FNEAxhasXHjei6//CIWLXoz9RMpRf1nr0/cpLaWwPJkc763T+DVl5O2Cc+dl5Zzd2fjxo1P2mZto8f2h6vTV4w4oajDh7FXrogtbwA2Jdnn0ksvb9fM79OmzSAvLz9hm+ebLdur3k0YEthVgq++1GS5HPgwyT7TpnXf9/P2UEoxZkzigJiNzZbtdcn+loToOkYr16vJrmB7JbmHJoQQ4uRldXUBQgghRDxl4VqePvghTx/8iIjnEtEuCoXneWi0P45OKUytcPHXeWgMpdAaPDQuGisWwKDIsgKEPRcFZJsBRmT35qfjLqYwkN3Fz1YIIYQQQrRGa80H7+/i/r++TXl5XfsOopTfeVXHb2LbJhfMm8hnrzuXrKz2d4p2PI+Nnxzh/X0HeGPrdiKuS7+cHGojYUzDIGD5gwo0fqBCveOggQzLxDINP2Qh2tE24rlkWBYB0yTkuqA1OrpNKRU7Vp+cbCrrQ9Q5EfIzg5wzeBCzRw3ntP6nSPCCEEIIIUQ3VVVVxYEDB6iqqiIrK4uCggJOOeWUbjcINS/vWGhtR81S3nhwbkFBQYccUwghROoaBnAq5adVfvjhh9x4440dcuydO3dSWVkZO3bv3vFn7K5pNLA4Mw2zbQrRaZKEMADodgxmECegJCEMHoDnNVmn6mpbbdtAZ2YlPa0u6JW4rNL4s1yKzqEqKijHH3iZSFFRUZuO26tX4n/7GiAMGJ9ICIMQQnQUe8U7se9644mcP7OTqknNzp07ePvtt1i48E3eeWcZdXXHvpN/HfhSs/ZKawLLlhC68upOrfNEY+7c0XIdcD2wHHDi7FdfX88tt3yel19+i1NPnZTSuUJXX0POf/1HwjaB114lfOElKR2vLZoPbG7OKyjAOf2MDj9vdzd69Fgsy8Jx4v1L+wPA50cfWxLCIFIUfOXFJu9DT6Swz5VXXtWuc9m2zbx5F/Lss083WW8AM4ArgSua7aM8j8CbrxG6/vPtOmc6GAcPYK/+oMm6ZSTsYgbA9Okz0lZTVxkzZhyrVr0bd/vHzZattR+ltR4hjodR0jLwJVkIQ2GhhDAIIYRonYQwCCGE6JY2VB7inl3L2FZzFEe72Mokol0MwNV+AIOLxtR+JzFFdFyd8tAYmErFBqj57TUKheO6eHj0DuRwSb/x3DD4DLJM6fQihBBCCNEd1dWFuefuhXzwwU48L9nXW0lEO/+3mElMKQYPLuSmW2cxceLAdh9ea83iHbt5bcs2DlVU8kl1NY7rYRoG1aFSwp5L0Dp2G0ZFz20oRchxsAyFbRjUQzRsDMKuS9C0CEbDFuodB09rXM/DUIqw45Jl21iGSWFWJmcMGskXzz6DLOnULYQQQpzU1HFeNon0W7BgAVu2bMFrNsAqKyuLqVOncvHFF7NgwYJ2zTzU0RoGz2qt2b9/P+Fw+Ljq2r17N2VlxwZ59e/f/7hrFEII0TannHJK7LHWmiVLllBeXt4hwTjPPfdc7LFSin79+sVt2/j9QDo3ip5MhULJGwXbH/oqThyGmTiEQUMrIQxJgolTCLHxkrzGqnIJYehqRkUFR1Jo17t3nzYdNz+/IGmbMqDPJwfbdFwhhBDx2e8sTbhdmyaRc6d1UjWJaa2ZO3cGGzY0H1J5zGu0DGEAsJe8LSEMx6m1EAbw/75HA58JBimN81mjrq6Ob3zjK7z++tsp3av1Bg8hcupk7PXr4rYJvPEqeL9PGhzWFsbhT7DWfJCwTfiCi6CbBRN3hoyMDEaPHsumTRvitmk8v7y9ZrXf16Wh34sQcQRffC72WANPJmlfUFDAzJlz2n2+Sy65jGeffZqsrGzmzLmAS86fxbU/+T593PgRc8FXX+5WIQyBVsJiFifZxzRNzj773LTU05XGjx+fcPsOoBrIiS5bH61Jd0lCtJtqJYSh5ZqmevWS7ymEEEK07qQMYfjjH//Y6vqvf/3rKbdNh9bOL4QQJxutNW8e3cw9u5ZT44So9xxMZeAov7OBUgoz2k4DHhpDg4GBqzx/TF30PqMRfZBh2oQ8BwsDyzSZkH0KPxpzEf0z81qtQQghhBBCdL21H+3h7rvfoqKiUSdTRfKo8WSUigUxBIMWs+dM4As3zsCy2/fFvuN57C0r558fb+L9ffvJDgRioQnZARulFBHXxXM1dZGIf17LxDCahkKEHZesgE3QMql33NjgSQ0YShG0TDwgwzJxPU3IcfDQZAUCTOrfl9kjhzNlQH+sDuwUIYQQQggh0mPTpk2trq+trWX58uUsX76cu+66i5/85CfMnz+/1bad5dRTT409jkQirFy5kpkz2z9b34svvhh7bNs2U6ZMOZ7yhBBCtMPUqVPJzMykvr4e8Adv/OIXv+B//ud/juu4O3fu5KGHHkJFg9KVUkyfPr3Vtvv27aOurs4PWleKgQPbH4wpRJcLh5M20XbXh2uJrqeM5PegdbMQBpKEMOjMrOTHLOiVcLtRWpr0GCK9VGUFR1NoV1TUu03H7dUr8b89+CEM/crKUJUV6Lz8Nh1fCCFES4F3liXc7kyZis7J7aRqEmv4LJYohGER4NBysEFg8SIZEH486usx9u+Lu3kOsPBb3+Xafz7N1q1bWm2zYcPH3HXX7/jud3+Y0inDF89PGMJgHv4Ea+2HOKefkdLxUhF4/VWUTtzBI3Tp5R12vp5m0qTJCUMY1jd6bBw9grFvL96QoekvTPRY6sgR7BXLY8vrgK1J9rnssiuwbbvd57zgggv529+e5PzzZ5ORkQFA/isvwdK34+4TWLIIamshK/nn2c4QfPnFFuveTLLP5MmnkZt74o1BmDDh1KRt1gMN8RPWtq2oinJ0CgGAQnQ2o7ikxbrfA/vwwxiODBnGgc9eR2lpCWVlpZSUlHLqqZM7u0whhBA9xEkbwqBaufETL4ShtbbpICEMQoiT3aH6Cu7d/Q4rSncR9lwMQKPxtIej/QForvYwUH7oAl4siMFUClP7QQx+GyM2YA1AoSgMZDO7zyhuHXoumWb7bxoJIYQQQoj0qa8Pc/9fl7BixTZc10u+Qzv4HUoK+No3L2b48LbNHNWgqj7Eu3v2sXD7TrYeKaaivh7DUFSGQn5gmCZ2P8GIDihAa+odB0MpLENhKoWnNYZSOJ6HpzUB00RrTch10doPH0MpNGAqxaD8fKqjM14sOHUCs0YMo09Odkf91QghhBDiRKCl4+uJ4OjRo3zrW99i3bp1/OAHP+iyOvr378+oUaPYscOfme2+++5rdwjDkSNHeOyxx2LXyWeccQZBmRVaCCE6XTAYZObMmbz++uuxwIQXXniBoqIivv/977frmLt37+a2224jHA436V8RL0xo3bqmAz9GjRrVrvMK0R2ocOuz0zYRlBAGASqFAF3tOk33qatN3D4zM+kxvSSz+KnysqTHEOmlKtITwpCfwkCYhggOc/cunMlT2nR8IYQQTamjR7E2bUzYJjKj/eGm6TBnzjzeeOO1uNsrgPeAac3Wm/v3Ye7YjjtqdDrLO2GZu3clDScYdva5vHL7V/jyl29l4cLWhwP/7ne/Yv78y5k4Mfmg2fDF88n+beLwxcDrr3RsCEMrs8s3pgMBInMu6LDz9TSTJk3mySf/AUBOZiZT6uo4HWI/E5q1t1e9S0hCGEQCwZdfQDUK9nsyhX2uuOKq4zpnbm4eF154SZN1ofmXEUgQwqDq6ggseovw5Vcc17k7giopwX73nSbrDgHx44l806adn7aautL48c1feVpax7EQBgBrzeqT+rVcdF9GacsQhvHRH4DQhIlUfv/HnVqTEEKInuuknh7RHxTh/7SlbTp+hBDiZLezupgfb3yR98r2EHYdbMPEj05QGErF3rA8/NAFhcbA78SlITqjDhgoLGVgKAONRmlwtMe4nL7814RL+ZfhMySAQQghhBCim9q4YT/f/c4/WLZsS9oCGDKCFp++5mx+/otr2x3AcLCikv9auIRHV39EcU0NIdchaJlk2TZaa2rCEcKOQ9h1AT+MQRENYwBCjoNCEbBMNIDWfuCY588SGbQsAqaFaRhEPJd6x6E2HMEyDEKOw5SB/fnJBbP5zOSJEsAghBBCCNFDBINB5syZw7/927/x+OOP8+6777J+/XrWrFnDW2+9xa9//Wtmz57dIhj8gQce4N577+2iqn3XXHNN7LusDz74gHvuuafNx6iuruab3/wmFRUVsWPddNNNHVqnEEKI1H3jG9/Asvw5OxqCGB588EFuuOGGFgEJidTW1nLfffdx1VVXcejQodixlFJceumljBw5stX9Fi1aBBB7T5gyZcrxPSEhulIonLSJtiWEQYBhmEnbeM3ui6v6+oTtdWbymUN1YeIQBqOsNOF2kX5GZQVHkrTJysoiO7tt3wf06tUraZuGCA5j9642HVsIIURLgRXLkrYJT+9egzbnzJmbtM0bcdbbixd2bDEnEXPnjqRtnBEjycvL57HHnuQrX2l9kkfHcfjJT76f0jgEZ/IU3FP6J2wTfO3VpMdJlaquIrBsSYv1jwB/Aw4A4Zmz0Tm5HXbOnuaii+bz178+zMqVa9i+dS9Ls7K5C7gFmAI0/xRpr1rZ6TWKniX4wj9jjzXwRJL2hYWFzEhDOFD4kkuTtgm+8GyHn7c9Am+8ior27WrwVgr7zZo1Jz0FdbFevQoZMGBgwjbNAyrsNR+kryAhjoMqKU643evdtqBLIYQQJzerqwvoSg0d2VK5+dC801tHkhAGIcTJrNYN8/InG3h47ypq3DBaa1w8XDeCxh+MZmh/wJrWfgCDB7FBbDo6YM0DzOjLqakMbGUS8qBPMIfphSP40vBpEr4ghBBCCNFNhUIRnn7qPV555SNcN4XPyAr/G8M2UAqGDu3N7V+ew8iR/dpcY3ldPe/t3c9b23aw/pPDRFyP3GAAx7NwPI+g6XegtQwjdp1aF/HDFmzTwDIMIp6HoRSu1jjawzYMXNMg7HpNQhqVUiilGJiXS6ZtU1xTS2F+JldOHM/pA/szuCC/zfULIYQQQoiuc/PNNzN16tRWB8DYtk12djaDBw/miiuu4IMPPuDOO+/k8OHDsTa/+93vmDlzJuPGjevMsmNuuOEGHnnkEQ4ePIjWmrvuuosjR45w5513kpubvJPssmXL+O///m92794d+75t0qRJzJ49O82VCyGEiGfUqFHceuut3HvvvbH7EFpr1qxZw7XXXsuoUaOYOXMmEydOZODAgeTk5BAIBKipqaGsrIytW7eydu1a3n77berr62PBCw3y8vL40Y9+1Oq5a2pqWLx4ceychmFw9tlnd9ZTF6LjRZKHMBAMpr8O0e0pI/lcSdprFsJQV5u4fWZG0mN6BYkH4hulEsLQpUIhVF0dR5M0Kypq++CA3Nw8TNPEbTaoqLGGf31z9+42H18IIURT9vLEIQzatomcfW7CNp1t+PCRDBkyjL17d8dt8wbw762sDyxeRP0Xv5Kmyk5s5o7tCbfrzEy8U/rzxON/Y/XqD9i+fWvctitWLOf5559lwYJPJz6pYRC+aD6ZjzwQt4m1cT3G/n14gwYnPlYKAq+8hAq3/Kz0n0BDBMXIjz5k2ne+ybRpM5g+/XxOSRIScaIZPnwEw4ePiC1HzjiLwLLFcdvbq1akvyjRY6nDh7FXLI8tf8ix/2vxXHbZldh2x/er9wYOInLa6dhrP4zbJvjGa1TV1EAbg+Y6WsY/n26xLl74UINgMMg555yXnoK6gfHjJ3Dw4IG425vH91oSwiC6KSNJCINux30WIYQQJ6+TNoShLcEHEpIghBDpURmp5zfb32JdxQFqnBAZpk3Ic9DanyHYwx9b56Ixo0EMXvQ12UNjoTCVgas9DMDF75DgaU29dhmcWcBXR8zg7IIhWCnMKiGEEEIIITrf3j3F/O//vs7Bg2Wk/PG7jR/TAwGTiy+ZzHXXn4dpJu/o2uRUWvPWth08s24DtRGHqvp6Qo5LwDSoCUcora1D44cvWNFBC40HHdQ7DpYZIGCaRDyPhifpehrLMsiwLBQu9Y6D43loxz+np7Uf1uB5zBo5jJvPnEpBCh1qhRBCCCFE93PBBRek3PbMM8/k0Ucf5dprr6WszJ+TVGvNH/7wB/785z+nq8SEbNvmd7/7HTfddBOhUAitNY8//jjPPfccc+fOZeLEibE6lVIsWbKEjRs3smfPHlatWsXevXtj27TW5Ofn89vf/rZLnosQQohjvv3tb/PJJ5/wwgsvNAli0Fqzbds2tm9PPCgEaBIo2bCcl5fHX//6V3rHmUnq2WefpaamJrZ8xhlnpDRTtxDdlQqFEm7XpgmmfFctwEjh98BzHBq3UnV1iXfIzEp+zMLChNtVbQ2EQhIW0kVUZSVACiEMRW0/tlLk5+dTmiBooyz6p7lnV5uPL4QQoin7naUJt0fOOAuykr93dyalFLNnz+WRBAPzV+G/XzT/1Ga/sxzCYQgE0lniCcnclXhotDt8JMo0ueqqz3D33XexefOmhO1/+MPvcN55M+jX79hkFFprjhw5TFVVFQMHDiIzM5PwJYlDGAACb75O/S1fTP3JxJHx7FMt1u2j6aDwHcVH2fHoQzz66EMAjBw5ip/97BfMm3fxcZ+/J4qce17CEAZry2ZUaQm6sO3XheLEF3zpeVSjTldPprDPlVdelbZ6QpdfkTCEQdXWEnzzNULJAmTSSB05gr10cZN1GngzyX7nnDONzMzMdJXV5SZMOJWFC+P/LazD/3tq6Blnr37f7wuXxkmPhWiPZCEMnryfCiGEaIOTMoRh8+bNaWkrhBAiNVprNlQd4jfbFrK3rgwXjYdHrRtGR0fUKRSGMvC01ySIwcTAxV/naY2hFApF0LRRGiLaJd/KYnL+AH4weh5ZltzkF0IIIYTojjzP45/PfsBzz68mHHFbBCvE/WpG0aYQhkGDC/nmHRcxZEjb0osr6+v5YN9BluzYxUeHPiHTsijMyqK4poagZWJFZy1zPI+I61IbjpAVsLEMA9swCLlO9HpW47gelqEIGAZhz4sNaAC/Y4tpGOQGA/TLzaGkpo6Q6zCqsJBZI4czbegQBhfkt6l2IUT3o7VG42Eo0w9aIQJoDPzPrC4hDEwMZUfbuijMJqEuQgiRMsmV7vGGDh3K97///SYziC9ZsoTy8nIKCgq6pKbTTjuN3/3ud9x5552EogMN6+rqeOWVV3jllVdi7bTWPPzww02WgdjA3tzcXO666y4GDz7+2dSEEEIcH6UUv/zlL8nPz+exxx6LrWuQymQVzdsPHjyY3//+95x66qlx95kxYwZPPPFEbLlv377tKV+I7qOV2V2bkEFpIsowkgcEe657bEFrVG1twvY6ycCPp59+gqPvvkMtUAKURv9sePwfwBcBo7wMr98pSesTHc+oLAfgSJJ2vXv3adfxCwp6JQxhaNhi7pYQBiGEOB7GJ4ewtm9L2CYy/fxOqqZtkoUweMAioPkwWaOmGnv1+0TOm57O8k5I5o7EoYfuiJGAP9v6XXfdw/z5F+A2vk5sprS0lO997w4efvgf0fuzD/CHP/yGQ4cOAv516OTJp3HrF27hq5mZWAmCvgJvvHrcIQzq6FHsJW+3WL8kyX47dmwnN/fk7RsROee8pG3s91YRvuTSTqhG9DTBF/4Ze6xJHsLQu3dvpk2bkbZ6QldeTc5//UfCNsF/PtOlIQwZzz+D8rwm6z4GDifZb/bsuWmrqTuYMGFiwu3lwH6g4Vs+o7QUY/cuvOEj0lyZEG3guhgJ7oUAeO0IuxRCCHHyOilDGIQQQnQdR3s8vn81L36yniOhKoKGSZ0bwY9S8G/a+126NIYGA4UXjWbw0JhKoTBwtIeHP0MwQMR1QEGRncMNg8/kslMmEjTkbU4IIYQQojv65JNyfve719i7r4R4/fkbp2a3kEIQQyBgcsWVU/nUFVMJBu2Ua6usr+ef6zexYvdeymrrKK6txVCKuohDcU0trueRGTh2PAUY0QEHdRGHnEAA2zQIuQpi16outmmTYVngOIRcF8fzcDwPA4XjuhRmZeG4Hr2zs/j0pInMHzdaBl8L0ckaZuj2tEOtdwhPhzBUAIVNjbcbV9ejMPFwCLlluPid4B1dT0RX4+o6NC4aN/rYwyWE1gqXCGjwVMTvQI+JRqNVBK01JkG0ctHaBWVg6iCeikSDGYIY2gIFpsrEJguUiakyCVKIpbKi4YRFmASwVQ5ZximgwCIDS2XL64kQQvRACxYs4Ne//nVssIzneaxYsYJLL+26DpZz587lqaee4s4772Tbtm1N3l9aG7TbMKt6w7rRo0dz1113MXz48M4tXAghRFyGYfCTn/yECy+8kH//939n586dQNPX8EQaXvNt2+a6667jzjvvTDoTnLwPiBONShLCoAPBTqpEdHcqhRAG3XgASDT8LGH7zMSzaf/ylz9n7949cbd/0lBbWRlICEOXUBUVABxN0q6oqG1B0w2SBfnFQhh2Jp6RWwghRGL28qWtrv8eUAlcAEydPIXuOLz8/PNnYppmwkH+b9AyhAHAXrxQQhjaIWkIw8hRscdTpkzlttu+xL333pNwn9dee4XvfOebHDx4gEWL3mqyzfM8PvroQ7750Ye83LsPz9fVEe9TSmD5UqipgezslJ5La4Iv/BPVyu/T4iT7ZWZmcvrpU9t93p4ucsZZaMtCOU7cNvbKFRLCIFowPjmEvXJFbHk1kCxi7bLLrsSy0tfH3hs2nMjUM7DXrI7bJrDwDVRlBTqva94dg88+1WLdmynsN2vWnI4vphuZMCF+uG6DdRwLYQCwV79PSEIYRDdiHNiftI3Xu333WYQQQpycZHSqEEKITlPnhPn11oUsKd1O2HVwtUfYOzZ+TimFoRUuHn7XAh0LZ9ANP9FBMQaKoGHh4aE1ZJsBhmUX8R/jLqUw0P4bwEIIIYQQIn0iEZeXX/6Q51/4kNraxp2TW09VSBrE0NCo8WoFgwb14stfvYBRo1LvNFpVH2LT0aM89sFaDldX0zs7C0MpLMPwwxOAOkfjupq6iEOWbWMa/vaI52EAntZEXJeAZRIwDcKuB/pYcJhSiqBpoVHkZQSpi0SocyJYpkmvrEzmjBrO9GFDGJTfHbvfCNGzaO3R8EJR4+0mrP3OzEqb1HmHqdMH8XQYV9cT0VXUeUfwqMclhKf9z5kaD4daPB3GJBMDkwg1aCIoAhgYONT7x8UEwMNFAQoV/RyrG71cadBm9GXL81/jtBF9BXTROrpn9Nz+NoWOtiX6+bjhqA3nQCv8Z2tgYKOjn6gtMjGUjaUyyDCKyFR9CRq9yDWHkWH0Iss8hUyjfTPoCSGESD/DMDj77LN57bXXYut27er6mUlHjx7Nc889x2uvvcYjjzzCunXr4s6U3rB+9OjR3HbbbVxxxRUpzf4rhBCi85199tm88sorvPvuuzz55JOsXLmSsrKyhPuYpsmYMWOYP38+n/nMZygsLOykaoXoZpINlLdTD4gVJzbDNJO28RoNVlN1tUnb64yMhNt79SpMGMJQ0lBbWSnxh12KdGoIYTiSpF3v3u27j1dQ0Cvh9oZ3e/PAflR5GTpJeyGEEK2z31nWYp0GHsF/jb8X4KbrGT9+IjNnzmLGjFmcd9408rpo4Glj+fkFTJ16Ju+/vypum9dp/bv7wOJF1P7op+ks74SjqqswjySeZ90ZMbLJ8ne/+0OefvqJWGBvPI899nDS879efJQvAQ/Rel8MFQoRWLqY8PzLkh4rnoxWBjZD8hCGs846l0Ag0O7z9njZ2TiTT0s4aN1etSLuNnHyCrz0PKrR9zRPpLDPggVXp6+gqNCCTyf8fVbhMIFXXiJ03efSXktzxs4d2Ks/aLH+lST79e7dh4kTk4cU9GSjRo3Gtm0ikUjcNuuAxu8S1poPCH3m2rTXJkSqcn703aRtdGFRJ1QihBDiRCEhDEIIITrF6rK9/Gn7MrZUHcFUCkd7KMDV3rHhJNqfRdjT/k17DzABUxm42m/loqM3ixQ6um+elcG8vmO5Zch55Fgyk4gQQgghRHejtWbXrqPc/8ASduw4QpwxWq3vS4IgBmiS32DbJhfMm8jnvzAdy0reoRVgd2kZS3buZsWuvewpLyfsuJiGQXU4TCjiEGjUMdbAnwXS05raSITsgI1lGijnWCnhaAhDhmWhtUPYdfGiQQxG9Do4wzLpm51NZShEn+wsvnjOmYzt27vJuYQQrXN1HRFdhR97kEGVt4Nabz+uF8aljohXTZW7HZdaXOrwdASNxiBAhEpcXYvCwiQLl1o8/C+ODYJ+EEKj7uZaazQmCpMIVWhcDAIYZOBSj4uDwsYgiEetH5yAjUkQh1rAQ2GhsPGiYQ3+K4kRix4EEw8XYmENBpoIoPzQBoiGKjSELjTUp9CYoP19DSxcnOjz8cMbQtRH0wxNqr390egGIxbWoDCxVS5ZRj/yzBEU2hPJMQaTaRZiqcQz1wohurk2XGuJ7q1///5NlpMNhu0spmly2WWXcdlll1FeXs7q1avZsWMH5eXlVFVVkZGRQa9evRg0aBDnnHMO/fr16+qShRBCpOi8887jvPPOA2Dfvn1s2bKF8vJyKisrCYfD5ObmkpeXR//+/Zk4cSKZmfLZQQgi4YSbdVC+vxZRKuGdbp97bNZbVVeXtLnOzEq4vaCgIOH2hhAGlWRAn0gfo9IPYTiapF1RUftmaJw7dx4DBw6isLaW/s88SSHQCyiM/jT+1Gmt/5jIjJntOo8QQpzsAsuWtli3kZYhO5s2bWDTpg385S93Y5om//d/f+Yz3WDQ4uzZcxOGMOwBtgFjmq23PvoQVVaK7iWhfKkyd+5I2sYdMarJckFBL/7rv37FV7/6xQ6p4RFgJnBbnO2BN19rdwiDsWsndiu/S/uAZM98+vQZ7TrniSRy9nkJB61baz+CmhrIPoEnqqutJfjCPwksfDP2/8UbNJjwrDmEPn0NOr+ga+vrhjKeORZ8ooEnk7Tv06cv5547La01AYSuvJrsf/tJk4CI5jKee6ZLQhgynmn5t1QBtHw3b2rmzNknfNi4bduMGTOODRs+jttmbfN93n8vvUUJ0QaBV14i+ObrSdt5ffp2QjVCCCFOFBLCIIQQIu3ePryV/92+hMpIHWiNaZiAg1L+jJ+e1rGABTQY0dAF8OcGtVBYysDVGlsZONqfT1Qpg8EZefxg9IVMzOufoAIhhBBCCNFVQqEIjzyynGXLtxIOO/EDGJSiTekMTfaFPr1z+dadlzByZOoDvJbu3M0jH3xE2HVj16XZARtQ1Dt+gILreWQZAUylMKJ9ZI1o24jrEbRMbNMg7HrHrm01KKXItC00YCpFxHXxANfzyA4EsEyDKyeOY97okRRlJ+4oK8TJwtF1RHQF4GGSSbW7g0p3G46uiYYvVFPj7ccjgqOrcXQNigCWysShBkf7swNaZEaD/UL43QwMNG40xiAAuIQpBRQW2YDGoQbQmGShMHC0v6yUAm2h8TvAayJ+rgFu9LgOfjygji07NHSWN6LBDg5+xCCAg4dGYaPRaML4AQtmNGyhIUShYV8d29c/TkNbF3QElIkfUujv57dtqEdFf9zYssZD40bDGhQRXUOte4hidy07w89hEiSgCuhljaWXNY4iawJ55gj/70EIIUSns6ymX+MlmnWmqxQUFHDBBRdwwQUXdHUpQgghOtjgwYMZPHhwV5chRLd3z/Ll3AcEgGCjPxseD62q5P91YX2i+zBSCOHV2os9VnW17ABmATmNfrIbPbYeuJevDx3KKae03l+isDDxgMiG6AWjvHsEvp2MVEUFHlCcpF3v3u0LYfjSl/7FP09VJb1bGWjUmPXxOglhEEKIdjD27cXcu7vF+oVJ9nNdl/HjJ6alpraaM+cCfv3rXyRs8wYtQxiU1tjLlhC+4qq01XaiSS2EYWSLdVdffQ2vvPISL774XIfU8R1gPjCglW2BN18Hz4N2DDTOfPShVte/mcK+06fLdUjk3Gnw5z/G3a4cB3vVu0TmzuvEqjpP8OknyPnpjzGKm0WUfbyW4Ksvkf3f/0nND39C/W1fTi3k7iRg7tyOvfr92PJ7wN4k+3zqU1didsIkMV7/AUTOnUbg3XfitrGXLkaVlKCLOnFGetcl4++Ptlj9BuC0bN3EnDknx3dhEyZMTBjC8FGzZevjtaiqSnRuXlrrEiIpxyHnpz9K2szr0xdvwMBOKEgIIcSJQkIYhBBCpE1ZuJan9qzh6QMf4XoeTrTDQL3rD1rxtIeBwlRGbJuLxtJgYuDi+eEM2kNF5wS1lIHGI8fKYEr+IL4xYhZ9gjld9AyFEEIIIUQ8WmuWLdvCk0+9R0lJNZ7X/imZG4YSt8YyDS64cCI33DCNYNBOWtPusnKW79zDkh272VNejmUY9MrMoC7i+AO0o1/U+sEKCg+oC0fICthYhoGhFFr7M9aHXZeAaZJhWXjaIeK5KO2fxz+OwjIMhhcWUO84VIXCnHpKXy6fMI6J/fqSFUhcrxAnEq09XOoBUNqmyttMnbuDiOcHLIS8Mqoiu/EIRQMWqjGwMVQmng7hUA2AQQCNhUsYhcKjDkdXAWCSCSgcatDRIAdDBXB0DRoHjYGFwsOlYZp4NxbUAKCiNUY7FCk/QPBY+IH/edTfx4908IMUHPzgBBUNO/AAM9reiR2/YbuKxjioRmfWTaat13H+bNRW69gLo44G2BjoaMhCQ3sDcBs9bqhNNdvWUImBSy11uo7ayBEORpZjkEG2cQpF1gQGBGZQaI1DqfR3yBBCCOErLm46DCfZACohhBAiFdu3b+e1116LLSuluP322wkEAl1YlRA91+HKCjYn2H5qfUhCGAQAhpH8nornuMcW6uqpBA4k2uGfT3PL9+N3Lu+VZFbqkuifqrQ0YTuRPqqigjKO3amLp70hDA10bh7O8BFYu3bGbWN93Hw+UyGEEKmw31nW6vpFSfYrKipi/PgJHV9QO0yZMpX8/AIqKsrjtnkd+Hor6wOLF0kIQxuYmzcm3O7l5aNbed9XSvGrX/2elStXcPTokeOuowL4V+D+1mo8/AnWuo9wpkxt20FDITL+0XJgM8Brra49JisriylTTm/b+U5AkXPOS9omsHTxiRfC4LrkfP/bcUM8GhiVFeT++PsEVrxD5Z/uhczMzqmvGws+9UST5SfitGvsyiuvTk8xrQgt+HSTEIYDQONhz8pxCD73DPW3fanTagosXoh5YH+L9S8l2c8wDObNuzg9RXUzEydO4qmnHo+7fStQBeRGl5XnYb3/3on32iR6nOBzz2Du3dNkncuxaXMa1H7tDgnzEUII0SYSwpDE+PHjmzx+9tlnO+zYCxYsYMuWLYB/c2TjxsQ3VoQQoic5HKri11vfZHP1YRzPI2iYOK4XG7QGDcM/NIb2h6t40YEiHhpTKdAqOkPosW1hzyXXzuDLw6Yzt89YMk0ZuCaEEEII0Z1ordm7t4S//+Nd1q8/gOMk6zrYSOMRySno0yeX2780h8mThyRtWx0K88B7q1mz/xCO51FcUxMLdiiuqSXkOBiGgW2aGOpY6IMBuFoTdl0yLAvbMAi5LgrwtMbTGtNQZNkWtRGN42nCnovyFI7nYZsGNZEI+RkZfGbyROaPG4PZjhkjhOgptNbUevuo9fbi6TAuIUJeGeXOGhxdTURX41KD0iamkYWr63B0JQAGQRQ2DrUoDFzCOLoWjcYkE4WJSy2aWhQBFFlAJBqqoPBwMDCjIQTKD0vQoHFpCCFwqUPjoqLtNP6M4goDUH5b7eB/Bed/LgUX1eQ2qiYW1NDiRat5mELDsoeOxiQ0bNMt9vEabWv82tn4OLpRO0B7TbY1DXNofIxG+/hxh42WVXS7S8Orn4rGIno4VHg7qQrvYm/4LXKMQfQNnMHwwGVkmL0QQgiRXqtXr26y3L9/67PbCiGEEG2xatUq/vjHP8aCKE877TS+9rWvdXFVQvRckXA44faAKfcChU+l8Lvgucfu2ai62mgsaWLZ2fEnrUg1hMEoL0vhTCIdjMoKjiZvRlHR8YUwADiTTkscwrD2w+M+hxBCnIwCy5a0WOcCi5PsN2PGLIxu8r2xZVmcf/4sXnrp+bht3gbCQPP4vsDiRdHwcBnIlgprw/qE293Ro+P+XRYVFfGXvzzAtddeRSQSOe5aHgX+AxjUyrbAG6+1OYQh+MqLGCUlLda7wFtJ9j3vvOkSDgnooiKcCadibYz/e2IvXdx5BXUGzyP3jn8h48l/pLxL8KXnyauvo/Khv8PJ/HujNRmNQhg84Mkku/TrdwrnpBD20VHqLv0U63/0XV7wPJ4HtgCfAH0atcn4x2OdGsKQ8chDLda5wCtJ9jvzzLMpKipKR0ndzuTJpyXcroGPgPMbrbNXrpAQBtGlVGkJud/9VpN1NfihIY1jniJnn0vdl77aiZUJIYQ4EUgIQxINA4WbP07H8YUQ4kSgtebDiv38ZttCDocqcbQfn+C6nh+oEH3ZM1G4sTlCdXROURUd5AEqOruwQpFlBgh5DhmGxdCsQu4cNZfROX277kkKIYQQQohW1ddH+NvfV/DOO1uprY3QpkQFABQonXQ3w1CcN200t902i6ysYNx2Wmv2lVewet9BXtm8lSNVNRRmZZJhmXhogpaJUgrTUIRcF9fzqA2HyQ4EMJTCVApPa5SCsOsSNC2ClomrPRxPo3XDgGcVPY5J7+wMsgI2R6tryLAszh06mBnDh3LGoAFkBSRATPR8rg4R0RVoXAwsqtxtlDgfEPHKiegqIroKV9dGwxSqiegKAGxyUFhEqIDopz3Hq44GLGREAxbq8KhBYWMQADwc6vHDESLEQhIwgAiaUDSAwe+g5hFCR/PLFQYazw9iwP9s6UcZNOrIjop+AtU0zT3Xx5JYmoQfNO7w5BELamgSktB8e+Pj6EbtvVaOR7P2zR83Plfz8/rLCo2OBk6krum5dXTZD6rwt3uARy3l3jYq63ewJ/QqA+1ZDA7OpcAa1YZzCSE6hXztcEJ477332Lt3b5N1553XeR3jhBBCnLiqqqoA/76JUoqZM2d2cUVC9GyhJCEMQaP5XGviZKXM5L8LWh+7T6Pq6lIMYciOu61Xr8Qhmg1D5FRZaQpnEumgKspTCmHo3btP8kZJOJMmwwv/jLvd2rYV49BBvP4DjvtcQghx0tAa+51lLVZ/CFQk2XXGjO71WWzOnAsShjDUAO8Cs5qtN/fvw9y5HXfk6HSWd8KwNm6IPf4b0B+YDDTELTkTJiXcf8aMmfzpT/fy1a9+Eddtw4QYzSjgcoh+k9pS4PVXqf3+j9t0zIyHH2h1/ftAssivOXMuaNO5TmThmbMThzCsX4cqLkb3Pv6Qru4g67f/06YAhgbBt94g58ffp/o3f+j4onoIa9VKzL27Y8vLgQNJ9rniigVpDwCqq6tj6dLFvP76K7z++qsc9Zr2R3gZuLnRsr3uI6yP1+JMSjzwvyMYhz8h8MarLda/BxQn2feiiy5JS03d0aRJk5O2WUPLEAYhulLO9+9E1dY0WfcT/HCaq4AFwPk5udTcfR9YMpRWCCFE28g7RwpUGtM5VaMZ4YUQoqdztMc/9n3AC598TEm4hoBhEnFdDFSjeTX9cAWj0WCThuEjplKgdXRwh//aqIB6N4JpGFzUbzzXDpxK/4z8Tn9uQgghhBAiPs/zePvtTbzw4hqOHq3C9fxrvvZ93FUk2jknJ8jtX5rDOeckHvS75Ugxz328kU1HiimtraUqFMYyDOoqIzie53/WNxtmfI/+KIWrNfWOQ6ZtEbBM6iIOhvavZR3PwzYNsmyb2ohDxHWJNOrYoLXGMgxcTzO2T2++Ou1sRvU+OVLQxYmpzjtAtbsTjzCOribkFVPhrsPR1Ti6moiuQmFjkoOHh6PL8IMATMBCE8EggELhUI1HBINMTBVAaw8n2q1H46KUidYuftCCg0eYY0EFBh7hRp8ijei2UPTzpBk9jkbjxJb9fY+FNKhoREFrdDQcMH7oQje6f9eotNSqavy8Ej/WNA548Jodw/979/AI6XJ2hl9gT/g1+tlnMjLjKnqZY1BKBpYIIURHqK2t5ec//3mTdWPGjGHw4MFdVJEQQogTidlsEPApp5zSRZUIcWIIJZmBNpjCwHtxckhloIvnNAphqE8thCErK1EIQ2HCfcvw7wAZZcmGxYl0UZUVHEmhXVHR8Q+yS2U2a3vxIkLXf/64zyWEECcLY9dOzIMth7wuTGHf88/vXiEMs2bNSdrmDVqGMID//iEhDMmpinLMfX7wrgvcDtRFtzWEMYzbs4sxTz3OhAmnMnr0GAKBQIvjLFjwaQoKevHVr95GSUlJi+2J2LbNNddcx/eqq5jywnPx2328FmPPbryhw1I6rvnxOgIrlre67fUU9p8zR2ZPbxCZNRv+/Mcm62qBrEbLgeVLCC34dGeWlRb20sVk/eaX7d4/85EHiEybTujqazqwqp4j46nHmyw/HqddY1dccXV6iomqr69n8uSxVFSUx23zAk1DGAAy/vYI1b/8bRori57nsYdRrQTYvJjCvhdeePKEMOTnFzB06DD27NkdW3dKVhZn1NZyBjAVaB4bb3+4GurrISOjEysVwqeOHiXYLEysHvgzfuDU3dGf/EiYC/77P7n00suZO3ceOTm5nV+sEEKIHklCGFIkQQlCCJFYxHX4w87FvH10K/VeBFdrwo3GayilooPXdHQoh8ZAxcIWPDRKHwtnyDRtwp5LwDDJtzK4fdh0Luw7rguemRBCCCGEiMfzNNu2f8Jjj61g5+4jOI6HiiYaKI4zdLAhEDF6DKVg4sRBfOvbl5CTE/8LmyPVNby7ey9Pr9uA1ppemZkcqa4m07awDAMNhEMhPM/zv6i2bZRSmIaB63kYShFxXYKWiW0YhJXC1R5aH7s3oJQiYBpYhkF+RpDKUIiw65IXDDK6dxEXjB7JGYMGkBWw2//8hegEDb/TGpdKdwNlzodEdDkRXUHYKyWsKzCUwtE1RHQ5Go1NLgZBwlRGQw0iRChGaxdFFoay8LSDSw0Kww9hUGb0XAqPEIY28HCiVRi4hECDxkNhoPGiIQwaorF+GtCEORaM0BD115i/riFQoWG/tgUoNA4maFg+Hs2DDhJta37e5nW35zW1+XHacozGQRQavztYAwP/NyfCocgKjkQ+JN8czsSs2ykwR6U11FYIkZySrzPSauzYsU2WH3nkEc4555y47X/+859z++23069fv5SOX1payre//W22bNnSZP03v/nNthebJq7rsn79ejZu3MihQ4eorq6mvr6+zdf/Sin++7//O01VCiGEiKegoKDJcoZ0jBXiuESShDDYEsIgopSR/HfB847df1F1yUMYMjIyWoTrNFZYmDiEQQPlQE5ZadLaRHqoykqOJmmTlZVFVlZWklbJRc4+F52Rgaqvj9smsOgtCWEQQog2CCxf2ur6RUn2GzhwEMOHj+z4go7DkCFDGTlyFDt2bI/b5nXgv1pZH1i8iPrbvpy22k4U1sYNscc7OBbAAHAo+vP60sWwdDEADz74Ny677FOtHmv27Lm8++4a7r77/3j88b/xySeHmmyfPHkK3/zmt/nb3x7h7bcXkp2dw4033sJXvvI1+vcfQOC1VyBBCANA8KUXqPtaavels+76XdxtyUIYBg8ewqhREuLRoGzSFD4yTVa5LquAVcAk4NVGbeyli3t+CENdHbnf+SbqOMfo5PzwO4RnzYX+fTuosB6ivp7g88/GFiPAU0l2GThwEGeddXZay8rIyOC0005n6dK347Z5Hf/1L7PRuuAzT1H9bz+HzMw4e3WAUIjMB+5rsVoDTyfZdfDgIYwbNz4tZXVXN9/8Rerr65g8+TQmT57CkJUryLv95rjtVSiE/dEaIudO67wihYiyV65AeU37kK2H6NRAx1SEQjz77FM8++xTBAIBLrnkMu677yHp4ySEECIpCWEQQghx3LZVH+GuHYvZWPVJdPZgf7ZSV3vRYRoaNBhK4eljQ2AMwFRGtL3frmEuYsd1QcHwrCK+NGw6UwtkljchhBBCiO6kpLSa+x9cwubNh6irCx+7GR39ftRDNx272y7+MbIybG66+XxmzRrf6k1vx/P46MAhFu/YxUf7D3GoqhrQ2KZJZX2IsOOSafu3QBT+damO7lfvOGTaFgHToNbzUNoPDYu4HkHLJCtgUxuO4GgPx/OwtRG95tX0zsoiw7YIWhanD+zPrWdPJT8jQ27Mi27H1SHCugStHTw8atydFDvLCOkjOLqaiFeJUhYmmXiECetSQKOwMHUGLvUYBAGFQw0e5RgEMQn6/5d0FeChVRiNiY4GLGi0v68OoHFjAQsuYcBF4ae2HAtdaNAQHKAbxRYYgBP981ibtv9vay3cAJoGDuAHwChoGvpAo2AHWl2OH7rQECahmy033q9hX9XsOAZNAifUsfqO/S20PW6ieevU920cyBB9PaWOEncj71T9iCJzImMyr6PIPrk6IQghuofVq1cTCjXvTgGbN29ushwKhVixYkWrx+jbty+jRo3qsJoeffRRnnjiCWbOnMnFF1/M1KlTGTRoUIt2hw4d4uWXX+ahhx7i6NGmQ3DmzZvHhRde2GE1tVdVVRV33303L7zwAqWlxzdIS2stIQxCCNFFhg4dChC7f9HWWTOFEE2FnMQhDEFLQhiET6USyNG4w3gKIQzZ2dkJtxcU9Ep6yhIgT0IYuoxRUUGyv/2iot4dc7LMTCLnTSfwdvz52YNvvEp1ZQU6L79jzimEECc4+52WIQxhYFmS/WbMmNktv1OePXtuwhCGNcBRoE+z9fbyZRAOQyCQzvJ6vMCit2KP16XQfsKEiQm3FxT04sc//ik//OH/Y8uWzRw5chjXdRgzZhyDBvn9bU85ZQDnnjuNW275YpNrw/CsOeisbFRtTdzjB196LqUQBnPHNoIv/LPVbWX4IQKJzJ59Qbf8/9CZ3ntvFU888XfWrPmAzZs34rpuk+21NP02O7Dk7ej3xT337y3rD7/G3LP7uI9jlJeT/V//TviPdx9/UT1I4M3XMCorYsuLgOIk+yxY8GkMw0jS6vjNn39pwhCGWmAhcHmjdUZFOcHnnyV03efSVlfwn09jHD3SYv3HwLYk+86bd9FJ9zr1tWav/6mEK9grV0gIg+gS9gfvtVh3OMk+4XCY/v37n3T/t4UQQrSPhDB0ocYdAWV2CSFET7W+4gD/s+0tjoSr8bTGVv7swqbyh9M0hC64aEztDzPxokM7PDQmCjM6aMNSJo52MZVBhmkzp/cY7hgxC9uUtyshhBBCiO6ioqKWtxdv4pXX1lJTE8J1/U6hntfxUy4bymDc+FP4l6/Oo0+fvFbb1EccHnhvNav27MdQipDrYBqKDMvG1ZqqUBjX81BKxYIYzGiIgqEUEdclYJpYhhFbr7WOXccaSpFl29RGIlimQdh1cTyNUv5ghSEFBcwdPYJpw4ZgdcKXlUIkE/EqqPF24eoQjq4h5H1Cqfs+EV2Bo2uI6AoUJrbKB20S5iigQSsc/DAFgwCGstE6QoRyFAYQQCkjOlJf4xFGYdEQluAHBUQAC00kGrgAGhdN48EIKhrSoFGYjdY1muUvFlbQ3teVxl1Qkn1ZZgCNO7GoljkK2g+UaC2+oWWFzc/bdK9jwQuq2VrV6AwqFlhx7BiNAxoa12xCk3atV9VaLcmeSfJ9GmsIV6zjiLuG4ur1DLDPZ0TGZfSyZOYaIUTn+d73vseBAweStisuLuaWW25pddtVV13FL3/5yw6tKxwO89Zbb/HWW34n25ycHPr06UNubi6O41BcXMyRIy07fgGceeaZ/Pa3v+3Qetrjww8/5Otf/zqlpaXoRjNTSccUIYToeSZPnkwgECAS8T+rffzxx11ckRA9W9hxEm4PyHfdIkqp5PePvUaDrVRtbQohDDkJt/fqVZj0nKXAiLKypO1EeqjKCsqTtMnPL+iw84XnXJAwhEHV1RF8+knqb729w84phBAnLK0JLG8Zt7AKf4bvRGbMmJmWko7XnDkXcP/998bdrvEHzl7XbL1RU429+n0i501PZ3k9m9YE//lMbHFzgqYAWVnZDB06LKVDG4bB+PETGD9+QottZ599DmeffU7LnTIzCc27iIw44QkA9uoPMA7sxxvYMlS4yaH+7w8o3fr3ia/SJGq+VXPmXJCkxYlv+/atPProg3G3l+H/zjRE4Jv79mLu2I47qmd+D2tu3ULWH/83aTttmqhmgRStyXzsYdybbsY96+yOKK9HyHj8b02WH09hn6uu+nR6imnmoovm86MffS9hm6dpGsIAkHnvPYSuvSE94SJak3XPH1vdFABuAZ6HuAF5l176qY6vqYfx+p2CM3wE1q6dcdvY7yyDb323E6sSwme/3zLyKVkwDcAPfvD/Or4YIYQQJyT5pq8LNe5QlyyZXAghupuI5/LSJx/z1z3vUu9GiGj/Rpfn+UNlXO35AQvKwNUNgzE0VnTwiBcdUuPpYzOXmkrhYdAnmMPVA6bw6QFTsFLoiCCEEEIIIdLPcVzeXbmdJ59+j7KyGlzXjQ24UkrFBmK1+tV6qmN4G8nJDnLNNWczb95ErGazxTmux/pPDrNkxy7e2b2Xstp6sgI2BZkZVIXC2NEwBFMpLEPhaUU4+sVspm1hmyZhzwPtX5NGPJcMyyLTtqiNOLha4+ljXQFc7ZEdCDCiqBeHq2owFFw+cSxnDx7EyKJCGXgmukzIO0yluwFX1xL2Kqjz9lPl7sJTITxdR1iXARpL5WHpLCJU0vAfMqxL8HAwycBQAbT2cKjGD2Hwbxk2hABoNC51GDqIh4PCRKPxqEcT/cym/ON6OoTGi8btEW3XWsBCY6n+H2rernHoQMvQAx1b33xZRUMVGrZZ+N1/GoIfbMAF7YHSKGz8GEEvegYL3WTZjoZNNF9ueN5WdH8XP0ChIWChIWxBNwtc0C1qbxrC0HhRxZroFoEMzYMsGj9OHsjQ8lW9tXoab2/4/O7h6Xr2h99if3g5fa2pTMj6PHnmYHm9FEKIqOrqaqqrEw+nMgyDW2+9lW9961vYtt1JlbVu27Zt3HbbbdTW1gLNrv/jdK4VQgjRfWVkZDBz5sxYONDSpUupr6+XiSOEaKdQJEkIQxdfy4nuo3fvIj7LsYhNo5XHWY1mj1b19SmEMCTub1ZYmDyEoQQwykp7/Ey6PZWqSCWEIb/Dzhe+6BL46Y8Ttsn6w28IffY6dE5uh51XCCFOROa2ra3OqL0ohX3PP39WxxfUAaZNOx/btmOhfa15nZYhDAD2kkUSwpCAvXwp5t7dseWtSdqPHj0m7TPWhz91ZcIQBoDgyy9Q96V/ibvd3LyJjCf+Hnf7c0lqME2TmTO75/+HzjR16plJ2yzjWAgDQODN16nroSEM2f/2Y1SC1xkAHQhQ/twr6Lx8Ci6dh1FZkbB95ne/TfXby+AkmDzFOLCfwMI3m6z7DXAefhjDYlr2BBgxYiSTJp3WKfUNHjyEU0+dzPr16+K2eQ4IAcFG6+z167BXLCcy/fwOr8levAhr04ZWt40DHgDqho/gpV/+lhdfeoFXX32R4mJ/CHdhYSHTps3o8Jp6osi50xKHMLy3EurrQe4zi84UCmGt+6jF6qNJdsvLyycnJ3G4qRBCCNFAQhi6yPr166mpqYl1PO7bt28XVySEEKmrdyP8aedSlpZsp84JEzAsItrFVAZoHRu64qCxdNNhGh4aUxko7T9uWKdQONpjRFYRPxx9IaNy+sjgDCGEEEKIbmLtur0888/32b27GMdx0drvj6mjAVxxB161I3zBNBUTxg/k9ttn069fy46FO0tKuW/lBxyoqKLecSitqcMyDUKOw/7yChzPI8O0MKNfrBrRgeGGMgi7LgHTxFQKUync6BNxXA8sMA2DbNumOhxGa6h3HBTKD2mwbcrr6xnXtzfXnT6JcX37tO2JCXGc6tx9lLsfEvFKCesK6r191HvFKIUfwqDL0HiYZGLqvGjggoWBgaOrCVOKQQBTZQLg6BrAwyOM0tHQATRg4BHC0BYeYRq6gGuc6CB/TcNge03zWSdU9Diq2Tqv2boGrYcnHGPGAh2OtaFJO4WNhxsLVDAI4OHQEBDQsO+xWhUmGbjUxYIOLDJxqUfjAAYWGTgqDDoM2kCRiUEEjxAKhUkmGheXOkBhEABcXEKAgUEQTRiPCGBiEEATjgYtWNEQi3C0mgD+p+JIdN9A9O/di4Y9ADjR5xeMtvPwgyIc0P5zd5uENDT8/RjN/u4bb0/lxbn5v1m8fRqO6TVqoqJ7RPjEWcnRyrUUWWOZlPVF8qwhKZxbCCFOHD/72c9YuXIla9as4dChQ0nb9+nTh/nz5/P5z3+eoUOHdkKFyf3Hf/wHtbW1/5+9846Tokgb8FPV3ZM2sYBEFQUBUTAnTCRFzOnU88x65nie3ql3nvqZ4+mZ85359MwRUBBUBBVzIikCkoTNO7G76vujZzawuzMD7C6wW8/vt+xO9VvV7wwTunvqfarueq3Wmj322IMxY8YwaNAgSktLTeGuwWAwbGCcdtppvPeevwp2ZWUljzzyCOedd946zspg2DBJ5ViVM2ibqVkGnwH9B/DfHDEVBQVkSpFELEptjvhIJLuEobi4BCklSrW8/vBKQCQSEItBJJJjj4bWRlblljAUF7eehMHrvwWpXYfjzPi4xRhr6RKKT/g91Q88iurZq9X2bTAYDB0N54MpzbbnkjAMGLAFffr0bf2EWoHCwkJ23nlXpk37sMWYCTT+hi9D4P1JRC+7si3T26CJ3H5zo9tzcsQPGDCg7ZJJkxgzFh0KIeLxFmOCr73SsoRBawr/9ldEC+dECeDtHDnsssturXqss6EyaNBgunTpQkVFRYsxU4EzGtwOTHib2Nkb3rUc+9MZBFcRCDRH7ZXX4O60CwA1t91J8RmnZI23vvoS+803cA8+pFXyXJ8JPf0EYpVzvG74z48zgMXAU+MO5PnfljNz5qcAHH7479p1Tv4BBxyUVcJQif95cvAq7eEH72t9CYPWFNx6Y84w96zzGDlqDCNHjeHmm29n+vRpvPHGqxQWFq1zWfr6Qmr4HoSffarF7SIWw/nsE1J77t2OWRk6O9bsWYhkskl7LglDnz592iYhg8FgMHRIzDd964Bly5Zx7bXXAv5ENSEEgwYNWsdZGQwGQ36sTNRw0+yJfFm1iKTy/BVRVcovt9A6vUqDqBMseOi62+mSDITW6bVHBWFpk9KKAjvIDl024aIBo+jihNfdHTQYDAaDwWAwAP756i+/rODNt79ixifzcF2FUgohBEppLEvgeU0Lclv0LuQQMggBxcVhjvvDcEaMGNJom6cUPyz7jZkLf+XtH+eQUopeRYXEUiksKQlYVl2s6yningdCELQtbCn94uW0KCLpeYQdm7BtU5uqP46tz0MQtG02KSkm5qaoiMXpWVjMmIED2K3fJgzaqJuRhRnaFK01UTWfMnc6CbWElK4irn7F1bUIbBQJkroMUEgcLF1AiloEDhIbTYoki/GL/4sQQiC0L1hQpBDaQSDSUgKJxkORIPMCFXVtSXRamOdLGEhLCkjHiXSPhi/sll4bTd8ARJ1goWGMSJ85+kictJDAP5sUOOmYJJl1AiUhNLH0/fGFCAIrLUgASQApbFxdi8ZLb7fTsoNE+jFTSCw8FCDxSPp5CQetBR5xBAJJEIFA4U9EsggDwhdZILEpSj/OCQQ2AVGI0i6KBBYFCAJ4JNB4BCjxZYTEkVjIBrE2BYi0DEOjkRSkJRgeAgeN9h87YaG1n71I77l+/cSMHrGhiGFVUUPLb8y5FQ3NRGjSqyVq0IKMolEjcImyzP2KlVWX0MvZhS1Ch9DVMddDDYY2YzUlWB2JSZPyWWdu7Zg1a9ZqxR999NEcffTRAJSXlzNv3jwWL15MWVkZsVgMy7IoLi6mtLSUrbbaik022aQt0l5jFixYwGeffYYQAq01JSUl/Otf/2LXXXdd16kZDAaDYS3YfvvtOfbYY3nmmWcQQvDAAw8waNAgxo4du65TMxg2OBKem3W7mahvqCOf68oNCmlELEZNjvCCguwr9kkp6dKlC2VlZS3GrMzElpehjIShfUkmEdFoTglDSUnrFibGjj8pq4QBIPDRB3QbNghVWorq1QfVuzde7z6oXr1RvXrjbTGQ1E67QDCYdRyDwWDoyASakTBEgezvsLDHHut3YeKoUWOyShgWA98DW6/Sbn/xOaK8DF3atS3T2yCxp39MYJXHdHaOPv37b9F2CWUoLCQ5el+Cb73eYojzyXTkwgWoTZpK1gNvvUHgg/db7DsZch7Pjht3YF6pdnSklOy663DGj29ZWzGFxgIUZ/o0RGUFuqRLO2TYehTcckPOmNS22xP741l1txOHHkHyuacJTHo3a7/QzTdQc+BBkF60pUPiuoSeeTJrSG/b5tRb7+SUnj355Zf5vPrqSxx44Kq6g7blkEMO55Yc/9fP01TCEBj/FtZPc/Fa8T3QmfwuzmefZI1RpaXEjz627rZt2+y5597saWQCjUjtPTJnjDP1fSNhMLQr1q+Lmm1fkaNf167dWj8Zg8FgMHRYOr2E4fLLL887dvHixasV3xClFNFolIULFzJnzpy6wpXMaqG77bbbGo1rMBgM7clXlYv417wp/BxdgSP8FVBlg5KZjGhB1q1BmvnRWELiaZUunckU90BSeYQsh+M33pmDeg8lYgXa/X4ZDAaDwWAwGBoTiyV56pmPmPn5L1RXx5BCoLU/+TNzHttQwCDqHQdNav4abmuuTQhwHIvhwwdy0ol7UlBQP2FPa83Un+bzzo9zWVRZybKqGjytsKXFnPhKUkoRtOsFDCI9oBSQcF0sKbCEwJICV2mEgJTyCGkbS0oijkM0LWJIuB62FKQ8hWNZJD0PR1rsO2gLzthtJyIBc5xqaH184cLPrHQ/Iqrm46oq4moJiiSSIKBJ6OXp4nsLSSi9zU4LCRRJ/AnUksL0tSaRnnzhoYkjdKhOEuCfj8URBABdJ0LQpPCL9TMIFCkaT+MQ+MX8ORACqS0UCoFM78cfu6FgQRBA18kffKGEwE7LE3xhgP8YkJZEpAULwsLVHuACIQQWFkFcYmlxgYdApB8fUKTQOoXAxiKMRxKPaHq0UrTw8HQMgU1Y9ECj8HQSsH1xgvTHl8LGIoAUYQKyGIuwv28RwhGFWMJ/j5AigCMKQfuPoSVCBEQXPBIoncIWYSwiuNQCCotCNB4eMV/GQAiXGpROIXH8fiTQGlxd4+sXdJKEriClYnjaJUkFCVWO0klSupYUtYDG0yk0KXT6/0E3eoduKGfInMmrJu/h+aEbPVX893dVv63uueXhEmVRagpLUtPZOLA3A0IHUWJtbuQ2BoOh01BaWspOO+20rtNYLT7//HOgXip+zTXXGAGDwWAwdBCuuOIKlixZwuTJk3Fdlz/96U+cfPLJnHfeeYTDRphuMORLooVVXzMEjITBkCGfQqCGF9Nj0TwkDAU5hywt7ZpVwpDZIsrKoO/GuXM0tBqiqgqg3SUMiUMOx7v2Kqzly3LGyvJyZHk5/PBdk21qox5U33wHyYM6/mrDBoPB0ATPw/lwapPmj4BUjq577z2iTVJqLUaOHM3111+TNWY8TSUMQmucD6aQPOTwNsttQyVyzz8b3V5J/TFYS/TvP6DN8mlI4uBDs0oYAEL/fYboJZc1ahMV5RT+7S9Z+72ax/7HjTsgj6jOwfDhe2aVMCwCfgE2S98Wnkdg8nskDjuyHbJrHZzp0whMmZw1pkoI7t9zL9465ghmz/6RZDJBr1592GProZxt22zvtixCtL79BvuN13EPObS1U19vCEyaiLX416wxyf0OQPfsCUC/fptxwQUXt0dqjRg0aDBDhmzND82cR2R4FYgDoQZtQmsit91M9X0Pt04iWlNw03U5w2InnQZ5nF93dlSfvrgDB2HPaVklFJg6megV/2jHrAydHdnCe+JvOfp169a99ZMxGAwGQ4el00sYXn755ZyTfDMFJlVVVbzyyitrtT+9yuqa4H8hZlaUMBgM6zvTy37mjrmTKE9F8bSuK84QkC7Kq5cwqPRqqZkCDwVIrbGFxNOakLRJaUVAWvQIFnHpFvswrKTPOrx3BoPBYDAYDAaAmpo4H340m7fe/oqVZf70Ts9TePhzP1s6fW4iWaBexqAzDdQ3ZuItS7L55htx4gl7MGhQr7rzZK01y6pr+O9X3zLjl0WEHZugZYGAiO0ghCDlecRdRSypEAFwLAsp0oqwdD1w0vOIOA5B28ZLpvz7QGZddoEtJY60KAz6xdM1ySRaa7pGwuzVfzP26t+PQRt1R5riYEMr4AsXfmGl+yE13ixcXe0LF9KF+ULYxNUyNCkEFgIbhes/VylEo/GoQeP5coD0eVimkF4RReqCdH9fYgAJNA66TohAWujQsDhANNqeacuMm3m9+H0BZKN4X+TgUvcCg7QAIdFgNBuBxCOevi3T0gWdbqsXLCjtokmm+wgkDhoXDXikkNpDYgEhFB4utQgEAbqkY6JoNAGKsUQ4LaCwECKAI8I4ooSw6IUtChDCwhHFFMp+6fvlYokghdbmgMDTCaQIYBPZoCQBnk4SU7/h6SRxvZKEV0ZUL6PGW0SNt4CEqsIjisJDo6DuR6bP4xu+i+dCNPq/b/KBANTLHgAsQOGR4JfkRH5NfkB3eyhDIydTZG26QT3OBsP6jFgzo4rB0Cy//VY/RaW4uJj99ttvHWZjMBgMhtbEtm3uvfde7rrrLh555BE8z+Oxxx7jv//9LwcccAC77rorW221Fd26daOwsBDZkVcRNBjWgmROCYORuxrS5PM+quolqCIezylhiEQiOYcszbEa9cr0b1lRTvZns6G1kVUVQG4JQ3Hx2ksYUqkUv/22nGXLlrJ06VJWjhxNxfPPsgSIAdnX0m0e+dtySk49npq/X01sHRR2GQwGw7rE/vJzZFVlk/ZJefTdffe9Wj+hVmTYsG3p1q0bK1eubDFmAtDcO39gymQjYVgF64fvCU54p1HbnDz6DRjQeqvAZyM5dhw6FELE4y3GRO7+J4lDj8AbOMhvUIqiC8/NWgiugNdy7HvIkK3YfPP+q590B2X48N1zxkylXsIAEJjwzgYlYYjcfnPOmPdGjuaye//VqK2srIzvv/+Wh4HjgbuBLi30D910PTUHd1xJWOjxR3LGxE48pR0yyc2hhx6eVcJQjS/1WVWZEXzpBaIXXYI3aPBa5xB44zWcL7/IGqPDYWKnnbnW++ospPYemVXCYH/5BaKyAl3Spf2SMnRqrCWLm23PLWHo1vrJGAwGg6HD0uklDBl0sxOEVz8mFw0nEmfGu/zyy/P6UsxgMBjWBUnl8t9FM3lm0WcklYebXgHZ1Spd4KL9VdBo8P6GX6pjC1kX76ER2i/ncJVCCBhS1JNzNx/BFoUbtf8dMxgMBoPBYDDUoZTi8y9+4dn/fszKFTUkEiksW+J52hdu4Z/DNjwtFoIWb7d09pw5JRZCUFIS4cADt+GA/bfDsvzJp9Fkkk8X/sqkOT/xzZJlVMTjWEIScmw85RfxZs6rpUj/rTWxlIsQvlTBlpKUUkghcD2FsjW2lIQdm1jKRWmNpxRCyrpS4+6RCAnXpTQc5g87DGPkFv2xTWGBYS2JqUWUpaZR6X2dFi4sRekklghjiZB/myQCidIxtPagkXAhlpYRhNI18bquQN4jhtAWihRpNR4aLy0raFjwDppk3d++LI90jL8101Zfdl//CpY4KJJ1bQKBwEGRqJPuSWyUEGidSp8M+sIDqVW6ry9S8AULXjofmR4rgMLFV0MkkdpvtyhBk8KlFgCbQiRBPOIoUkiKsEURUtgERXf/MSWEI4spsYZgi0LAQwqHsOxNSG6ETp+bCpH/a9sWG+b1OksEKLT6AlDC5rDKgptKeyRVFWXut1Sqn6h051HhziNFLaT/P+qfEav+XpWGbfUyxsY0FCs0FoC4JFjmfs6Kqu/pag9i6/CJlDoDV+8OGwwGg6FNsSwL8I/hN9lkEyPMMRgMhg7CkCFDmrT5sj9NTU0NL7zwAi+88MJa70cIwffff7/W4xgM6zPJBkXzzREIGAmDIU0ex9JCN5AwRKNEc8RHIrlX6iwtLc26PVNeKcpzrcdsaG1EpV+8ewuwFF/GkPkpT/9esdVQNt2031rt58UXn+ecc07POvfxQWBNr4YWXnc12A6xc85fwxEMjYjFcL76AmvObERNDToSwes/AHf7HdCFRes6O4PBkKalldyzr+8OQ4ZsTffu6/equ1JKRowYxUsv/a/FmCk0Xb0cIPD+pOyrO3RCIvfc2aSt5dLVevr3H9DquTSHLiomMXZ/Qq+93GKMiMUoOus0Kt6YAKEQBVddQfDtN7KOOwNoviSynnHjDlj9hDsww4ZtSyRSQDRa22LMVODEBrcD700A1wV7/S8Jsr7/rsX3zgzacdjr1jsZdsrxfPPNV83GPAVMw5fBNPcqsb7/DvvdCSRH7LO2Ka93WHPnEHxvYtYYb9N+pEaMaqeMsnPooYdz003XZY35L00lDEIpIrfdSPVD/167BKJRCq+6ImdY7JTT0T17rt2+OhHJvUcRfvShFrcLpXA++pDkAQe1Y1aGzoxsQQq1Ike/rl2NhMFgMBgM+bP+n3G1Ey1NGmv45cPaTizzC1bqxyspKeHyyy/nsMMOW6txDQaDoa1IKY87503mw5XzSCgXR1i42hcoSPyJWJr69VEblmQoQGqNIySe1lhC1q2gGpYOY3sO4dzN98YyxW0Gg8FgMBgM65Qff1zMq69/zg8/LCblemjtH9O5rqpb3FzIpufDmbkTdeKFFubuZU6lpZAoTxMOO+yw/WaceupeFBTUT8tYXFnFPR/OYFFlFVJANJUiaNlYUpB0XWIpFykEtvRlC0L4GjAhBApIuB52QBKwLdykqj9W1b5IwrEslPaFYBpBwvNwPUXIcdDAHptvyphBA9iiu7nAblh9Euo3yt2PqfQ+I6WrSKiluDqGJIykgIReiiKBQOLpGKSldjYFaDSKRHp7IH3eBH6xuvBFDdqGtD4BJKCayBE0opFwob5o3qNxEbyoi68vrhcI7HRsfZsvYUjV7VvgIHHQpOpkDwIHCwdXeKBdpA4hhEASROPiny16aK2QSCTFKFxcahHpx8AWETyieDqJTQRbFGOJAGFrYxyKsEQBtiigyOpPgdwcjwQAAdkFRxTm9X+0OvKFjo4UFiGrlD7WXvTBX20ppaPUekspc79hQeJ9atVCPOJ14o+8aPRB4D+/Wp7WnXn+pWWNRFnufk1Z9RX0sHegf+gAegS2XbM7aDAYWjZiGQxrQO/evev+TiQS6zATg8FgMLQmzRVhClEvv2yNBSoMhs5CTgmD42Tdbug86HyuTzWcpxaLEcsRHomEcw5ZWto16/aMhEGWl+ccy9C6ZCQMh2WJWfHi6+i1XJ2xd+8+OT/bfwKGrsU+Cq75O+5225Pafc+1GKVzY/34A5F77iT4xmuIZoovdSBAcvQ+xM44h9See6+DDA1rTU0N9tzZyCVLkOVliJUrEYk4OhAAJ4AOhVC9eqP69sXruwm6a1dTyL4e4zRTSFwJfJqj3157bRiv35Ejx2SVMMSBD4FVS5ythQuwfpqLN8AItwHkooUEX276OM7J0a979+6UtOMK4okjj84qYQBwvvmKkmMORxcVEZw4PueYzwQCkExmjRk37sDVyrOjY9s2u+yyK++/P6nFmKmr3Jbl5TjTPiS198g2za01CD90X86Y+B9ORG/ajz/96VJOPfX4FuN+AkYBHwDN6cqCd99FtANKGMKPPJAzJn78SbCezMsfMGAgQ4duw7ffft1izGtADFj1zDb0ykvEzjoPd4ed1nj/kbtuw1q0MGuMjhQQPe+iNd5HZyS1x55oKRFZrocFpkwyEgZDuyGXNK99+i1Hv/VdjGYwGAyG9YtOL2Ho06dP1u2LFy+uW/HBsix69OixRvuxbZuCggKKi4sZNGgQ22+/Pfvss48x3hsMhvWWJfFK7pw3mZkVC/C0QqFQWqFF/XqnmfdHqC8FEghUOkIBIr3dFgJXQ7dAhKP67sCRfbbDMkUwBoPBYDAYDOsErTVLllby2hufM236PNyUh6cUtiVRnqqbdO95/pGdVqs38V7KtLArUzOOP0do6637cOzvhzNgQA+EEMRTLl/8uoSp837m418WknBduobDaClRWhO0/GPOgGWRcD201kRTKQqcAJYUOJYk6SmkELhK4WmNLSVB2yKejldK+weq6VT6lBRRGAjwW00tPYoKOWa7oWzdqyfdCzbMFe8N7U9KV1HpfkK5O4OUriShluDqKqQIYVFAQv+GRxSJxCOOS1lauBABIVA6iUcCgV0nqquXFaTQWICNRiGQaBSKBBJ/wn5GoKBIIbAaZObLDsAio8rz0UjsBvF+Ub0vWMiIHPwzuoZtvpTBwiKERzTdJ4AQFlKH8KiFdH7+NguEg9IadBQNOJQgRRhXV6JIYRHGESUIYROU3QlZXbBFIY4spNgeSFgPRqelD44ows5TsGBYexwRoYvdny52f/qHDiWloyxJTmNO/H9E1bL088IXgNT/boxu5pZm1fP+evlCPZnxPFxiLHansaTmU3raOzEofDjd7MFGomEwGAzrkB122KHuOvCvv/6K67rYG8CqWgaDwWDITbZFKNZ2gQowIgdD5yGRS8IQDLZTJob1nnwKYRo8n0QsSjRHeCi09hKGsvRvWV6WNc7Q+oiqypwxurh4rfez2Wab54xZWwmD0JqCv19GxXsfmKLx1aW2lsJr/0Ho8Ufq5lg1h0gmCb7zFsF33iKx3/7U3PJPVO/sc18N6xa5dAmB9ybiTPsQZ8Z0rAXzV6u/6t4dd+g2uMO2JbXjzn7BWzsWZRuyUFOD89knTZo/oLlvTxqz554j2iSl1mZEHquoj6ephAHAeX+SkTCkCT9wD8J1m7TPztGvf/8t2iahFkjuMxZvs82x5v+cNS4wfVpe47nAf3NIGHr16s22226/Oml2CoYP3yOrhGEO8CvQt0Fb8NWX13sJg1i+nNCLz2eN0YEA0Yv+DMABBxzE4MFbMmvWjy3GLwQOAT4GVp3tY0+dgv3NV7jDOo70X1RWEHrumawx2nGIH9uyvGJdcOihh2eVMNQCbwK/a2Zb4aV/omL8ZFiD76Ss2bOI3PuvnHGx089Cm0Ls1UIXl+BuvyPOzJbVU4H3Jtav7mQwtAWpFM4HUwhMfpfAh6sqiiCJL0jLRteuZqEug8FgMORPp58lNWlSyyeqAFtuuWXd3wMHDuTll7ObHg0Gg6EjMLtmOXfNm8Ss6mVIIfDQSCRCkC6oASVUev3U+tIJhf/BIoXE0/5XCjq9qqWnNZtEuvDXLfZlSFGvVpm8ZTAYDAaDwWBYfaLRJM88/zFffLmAivJapKw/onO99Jrn2i+tbg4h6hfjajgXrGG7UhohwLL8Y8hePUs46IDtGDlySF0B19R583nxq++oiMUoj8WpTSWxhWRFNEbSddFAwLLqyshFeidaQ8xNURgI4FgWKU/V7djzFJZtEbRtBIKY6+JqhXZBaYXS4HqKpKfYd9AAjt1hG4pDoVZ+hA0dCaUTVHpfUu5OJ6XLSKilJNRvSGwsCkhRjks1Aomn46SoQOH5wgUEChetaxBYaBFsIFwAjYcijkWogXBBo0gi6wrXBf6r0U3LGWjQrhA4TV6pAgeFR8MzLkkARSotTPCVCb4EIlW3b4GdljV4gIvA9s/btFMnjPBIIrWFxsOhK2DhUoFfah/BoRtapACJLcLYogRHFFJqb0+B1d8XNQAB2YWQ7EkgYDXKPZn01v4/zdAqOCLCpsF92CQwhirvJ2bFn2d56lM8EmREHj4tTwpufkvD1sznT8MpiRL/SoLLUnc6S6u/oIu1GcMiJ9PdHmJkDAZDnpirbobWpGfPnuy+++589NFHxGIxpkyZwpgxY9Z1WgaDwWBoBYwkwWBoHRI5XktBI2EwZMhnjkRDIXI8nlPCEA7nI2Eozbp9Zfq3KDMShvZGVmYvCdCRAnCctd5Pr169CQaDJBKJFmNmDdgC5s1dq/04335NYOI7JMfuv1bjdCbk/J8pOf5o7NmzVqtfcPzbONM+ouam20gc9fs2ys6wRtTUEHrxeYIvPo8z4+OsYo1cyBUrCLw/iUC6GFdLibvtdiRHjiZ5wMG422xnCtvWEYGPP0SkUk3aJ+foJ6Vk+PDd2yapVqZ37z4MGbIVP/zwfYsxE4Bbm2kPTJlM/LQz2yy3DQVRtpLwU/9pdtucHH379x/Q+gllw3Govul2Vvz+CL6k+WLo1WH8Ntvy29dfZY059NDDkflIyjoZw4fvkTNmInByg9vBt16j5ubb16hQvb0I//sRRJZjUYD4kUej+m4M+O+XF174Z8455/Ssfb4GLgAeaW6f991N9f3NbdkwCT39JCJamzUmccjhqJ692imj/Dj44MO4/vprssb8m+bfd5xvviL8+MPETj979XaaSFB01mmILCIYAFVaSvSc81dvbAMAyREjs0oYrAW/YM36EW/LIe2YlaHTUFtLyUl/IDC15aPvb/IYpls3I2AxGAwGQ/6sv2db6xmmWNhgMHQWvqxcxM2zx7M8WYOLh9SC9PrHSC2wkHjUCxb8opzGIgYLf3XWkLTxUASEzXZdNuaSLcfQVRaso3tmMBgMBoPB0Lmpqorx6cyfeemVmZRX1KI1KKWQWuB5GksKEP7fvkQrPW9nlblBLc0VkkKgRcO5PoKioiBjRg/l8EN3xHEsUp7HD8t+Y9LseXz08wJCjk3XSITltVFCto2V/pI96XkopahNpigIOEghsC1J0vN84ZfSeEpjCUHAskh4HlrrxqW9AooCAfp0KWZlbS2xlMtWPXowYovN2K3fJmxUaI5LDY3RWlOrZlPhziChl5NQy4mpBQBIHcSjhhQVCAQeEpdqFCkswggkCg+PGkCkxQYW4AtFhFBoYggK0Hj4heYCRQpBw0m0Ii1KyBSl67S4wd+WaauPttJ96tskDppkgzFs/DM5B0USkAgchJBIHcKrm8qt0vo9Ky1yULi6Nj1CAY4oIaWr8IhhEcIRRUgRpLu1C0HRC0eUYokAQdmDEmtrpDCXHTsCQghK7AHsUng51d4ifkmM55fEO3jE08/lzAeFpKFMIX0VIcfozX2grLpGVJIybzYfVF9DkdyYIeHf0Tcw3FyrNRgMhnbmkksuYcaMGXiex2233cbw4cOJRFZdW8pgMBgMGxLnnXfeuk7BYOgwJHMUVzoBI2EwpMmnyKzB80nEonlIGHIfl5eWds26PSNhkBXlOccytC4ih4RBlZS0yn6klGy6aT/mzGl53e0fR4yi4sbbCD90H4H3JzW7anc+RP55K8l9x5nC8Dywvv+OLr87GLlixRr1l9VVFJ97BrXz5hL969/MY76OkUuXEL73LkLPPIWsrmqTfQilcL74HOeLzyn45214m/YjceAhxI893hS4tTPOlOYLvrIvCQjbbLMtJSVdWj2ftmLEiNFZJQw/4a8wvOqnlfPBVEilWkUktCETeuo/iGjTozkNtPyJ7DNgwBZtktOquK7LZ599wvjxbzNhwtvMARxgLFC8hmN6PXvx9OYDIIeE4YgjjlrDPXRstttuB0KhEPF4vMWYCTSWMMiVK3E++oDUiFFtnd6aEY8T/nduGULszHMb3T7ssCO55ZYbmD//56z9HgWOB0au0h585UVq/351ndhhgyaRIPzgvTnDYmespqygHejffwDbbLMdX3/9ZYsxbwOLgT7NbCu4/v9IjtoHb4uBee+z4KbrcL79Omdc7RVXoXOcLxua5+dttudHYAYwHfgTcMQqMYEJ7xAzx6iGNqDo8kuyChgUcFYe4xgJg8FgMBhWBzMbOg/MChAGg6EzoLTmtaVf858F06lyY3XtDct8vEwJRabGQvgiBimkX8SHRqHr3jdTysO2LA7qM5STN9uVLoGIWdnUYDAYDAaDoZ3RWjPj03m8+PJMVqysIR5PEQxaxGMphBB1czo9pbFWmQOq0wd+UjQvX7AsgVIarf3+/vwuQSBgM2rElozddxh9+pQSTaYY/91c3p/7M4sqKllRG0UKQXUiyW81UZLKI9JgEoYvdBAorYmmUhQGAgQsi6Sn6hJJKY+QbRO0LQDirktKeVieQEhBSimKIyHiqRSl4Qhn7LY1YwdvYQp3DXUk1DIqvM9IqOWk1G9Ue7NQxBDCRuk4Se1PPxbYSBw8EliEEFgoFB7V6ZEyE+k9MkXlihiSAhQeIi1c8IUMXnrMTKRO9yPdLuraBdIX36XPygQCgY3GhXRxu0A2kCsIBBZCCCwdwqM2HeOAEEgdQuHiSxtc0BYahUMJYOFR7Z/fESQgSvHP9hQWEQKiFFsW0sXahi729kgRRGsPWxQSkF1a9z/GsN5SZG3M0Mhp9Avuy5zY/1iSmoFLDPBAZ4Qh/sWCtb+aqtOfQf6VCI8ElepnZtTeQZd4fzYP7sNmgX3MCjkGQ0uYrzQMrcyQIUO46qqr+Mc//sH8+fM588wzufPOO+nWrdu6Ts1gMBgMa4iRMBgMrUcix5yiYCjUTpkY1nvyuY6h6gWVIhYjliUUIBwO5xyya9fsRSU14F9dLC/LnZ+hVRFV2SUMupUkDACbbbZ5VgnD/Pk/kxo5mtTI0YjqKuxvv0Eu/hW5ZAly6WKsJUsITHwHkaUgEMCZ+RnO1PfX3yLA9QTrp7lrJWBoSMEdtyCXLKbmjrvBslohO8PqIMrLiNxxC+H/PJbz9dHaWAt+IXL/3UTuv5vUTrsQP/4k4oceAQVGRN/WBJqRMKwEvszRb889R7RFOm3GyJGjeeCBe+puCyHYZpvt2Ldbdw6aNJHhQKCZfrK2Bmfmp6R2273dcl3vSKUIP/Zws5uWANnXsveLltuKaDTKhAlvM37820yaNJHy8sYirhQwHlgTRYIOhVj20OO8cfwxWeM222xztttuhzXYQ8cnFAoxfPgeTJ78XosxE/ELTBueXQRfe2W9Pf4KvfRCzmOe5N6j8LbaulGbbdtccMHFXHzx+Tn3cSbwNfUzNwCE5xF++AFqr75u9ZNezwi98BzWksVZY1I77YK7/Y7tlNHqcfjhv8sqYVDAk8Bfm9kmorUUn3o85W9PyusYJ/jCc0TuvStnXGrb7Ykff1LOOIPPJ5/MYMaMj/n888+YOfNTli5d0mj7DjSVMAQnvkPsgj+1W46GzoGoqSb46ktZYx4EPstjrF69erdKTgaDwWDoHBgJQw7ee6/+JNbp5FZOg8HQcdFa8/SiT3hp8ZdUpmJIIVC6/st9icRLr0bpr40qUELXiRhAYwmJ0GAJ6W9HU+pEOK3/cA7tu806uV8Gg8FgMBgMnRmtNV9+tYCJk77jm28XoZTG8xRaa+JxjdKkpQv15eCe0g1u+YhVBAwNbyvlHxDati9zcGyLzftvxB9+vxuDBvZGa83SqmoemPYp81asJOI4KK2xpSRoW2gN0VQSVyliqRSRQAAhwBLCLzMXAk9pXKWwhCBgyToRg79vf7JH0LbRQJdwiNpkknjKxbEkGxUWMGZgf3bfbFN6FhW29UNuWI/xdIwq7yuSajkpXUmV9w0JtRQARSItXFAIbCwdxiOGJIjERqNwqcF/ZWSmEikyJ0QeMSwK0oIFAcj03w0FdAL/bMqXJWTkChrQKCQWCheBVRcvcNAk0kXtfpskgIebztUCJBYZuYKHIDOp30r3V/42rQCFQzE2RSRZmc47hCNKEMIiIDYnJPsQEr2wZZig6EmpvT2WyD2R29C5KLI2ZYfCi6nxlvBt9GFWuN/h6iggUXj4U37UKr1W/XTJTqPPobrXiofGo8ybRXl0LnPjbzIkdDS9gztiC1PQYjAYDG3NUUcdRTgc5sorr+TTTz/lwAMP5LjjjmPs2LEMGjTIyM4MBoPBYDB0WpI5tjvBYI4IQ6chn2PmVSQMTddObkwoD8lHly6lOWPKgG6rFOAZ2h5ZWZF1uy5uXQlDNn7++af6/RYVkxq+R7NxBVdeRuTB+7KOFbn/birX0yLA9QFRU03xSX9oFQFDhvCzT4GUvojBnJ+3D0oRevoJCq6/Glm27iU2zmef4Hz2CQV/v4z4cScSO/s8VJ++6zqtDolcugR71o9N2t/Po++ee+7V6vm0Jbvttjv9+m3G8OF7MGrUGPbaayTdu3dH/jKfbjtnnw/qTH63U0sYgm+9jrX412a3zcmjf//+W7RuQg2ora3lzDNPzbpA5evhMEfFcunAGqNDISqfeI6XFy6guroqa+wRRxxlridnYeTIMVklDCvwpS8NNRbBN1+l5qbbYH2rddGacI5jR4DYWec0237IIYdx7713MW/e3Kz9ZwM3AVet0h564nGiF1/aqsfV7Y7nEb77nznDYmec3Q7JrBm/+90xXHfdVXhey4s4Pg78hfqFIxti//gDxRecTdWDj4HdcvmbM2UyRRedmzWXFDAJ2On6m43AbDW44YZrmDbtwxa3T2umzf50BqJsJbqrEbobWg/7i88RWY5RYsA/8hhn4MBBdO/evdXyMhgMBkPHx0gYctC3r7kQaTAYOjY1boIH5k9l/PIfUFrhodDalyj4a7LqunVbM5ddMyIGLfziPlVXOqQRWqGFoGewiHP6j2B0r4Hr7L4ZDAaDwWAwdFZWrKjmiWem8cMPvxKNpdBa4zgWnqeQQtR9oe55Oi1iqKe+3Dvzt0AIXSdekFLU/S2EL2KQ0mKj7kUcf9zubLvNptSmkrw3ex4TZ8/j2yXLiKVcgpYkGQpSEY8TSK/4JQRYUiK0xtWaaCpFgeMQsCySnldne0h6HhHHIWTbaO2S9Dw8rdFaI4QgpTzCjk23gggBy6JnUQFnDd+F/t27YptV0jsdWmtiaj4JvRhPR6nyvqXWnYsrqv3nj16BxkVgY1OMRy0SG0kgLVyoQuNhkxF3aPyCcoFHFIvCJsIFjVu3/0zBuCJZ93dmiy9KsNEkGrSBIAC40Ei44KBJodP7FtgIBIpAur9Mj6/TsggLjcLTMUAjCREQPUhSiatrkTg4ogQpgvSU+1BoDyIouiOFjSNKKJD9EcK8Xgz5U2j1ZtfCK6lWi5gVe4HFyWmQvj5QPz1Cr/IbcgkZmm5RDcaTgEajqFQ/MyN6G6FYV7YKH80mgT1xpFnhy2AwGNqSgw46iG233ZazzjqLefPmcd9993Hfffdh2zYlJSUEV7PAUAjBu+++20bZGgwGg8FgMLQ9yvMaXBVqnkDICC4NafK6Vl1/ZURFo3VXEVsiEonkHLFr1645Y1YC3cvXfRFxZ0NUVmbdrkraT8Iwf/7P1NbWUpBjddnoRZcSfvI/iGjLa3g7UyYjfvsNvdFGa5Rrh0Zrii48t9kC7rUl/PQT6C6l1F51bauPbWiMXLSQovPPIvDRB+s6lSbImmoiD95L+LGHSBx5NNHzLsIbNHhdp9WhcKZMbra9+dZ6bNtml12Gt35CbUgkEuHTT79u0q76bYa7eX/sBgKfVQlMnED08nxK4Dom2YrO8/kE2Hzz/q2XzCpstNFG7Ljjznz22SctxrwVDJLs0ZPAL/PzGtPr0ZOqR5/E3XU3njhobM74I444Kt90OyUjR47OGTOBxhIGWVZG4L2JJMcd0GZ5rQnO1Pexf/gua4y7xUCSo/dtdltxcQnvvfchhx22P19++UXWcW4CTgf6NGiTNdWEnnqC2Dnnr17i6xHB119p8n77KBAFTgRKAG/TfiQOPGQdZJcfPXv2ZJ99xjJ+/NstxszCL+RvXgXnPw5FQlB9/yPNykaCr7xI0flnIVKprLm8DBwDbHrOGZx44ikce+zxbGTOW3Ky4447Z5UwfAFUA0UN2oRSBCa9S+J3x7R1eoZOhFy0MOv2f+PLinJx2WVXtkY6BoPBYOhEGAmDwWAwdGIqUzFum/suMyt+QSuNJSQufmEeWvhCBjIiBtFgBVa/5MESsm79V6n94iLHshlYsBH/t+VBdAsWGGOtwWAwGAwGQztSVlbDq298yUfT5lBRGUUKgev6JnHPU2gNliX8QmvPX1HLUxoh6nwHQNPyWCklSvn9Pc+Pl1IiBPToUcT++23DiL23JBIJ8tWvS3lk+mdUxuO4nkfS9QjbFhooq435cgXbJiQlAuqOFyXgKkVKKRxLYktJSinQGk+ldRBCEHZsNGBJQdJT6LTAoTAQwJGSw4YNYZ+BAyiNmMnNnQVX15JQv6J0kqiaS5X7FTE9D40iqVagiCNwsHU3XGoAkBQgUKQoQ+Ni1QkXqJMeeMSwKKi77QsXFJr6L219CYJICxcaWvIzwoUQihSiQU26xEGRpL5YHSQ2CistcxAILISQSB3Co5b6wnN/qyQMSFyigEISICh6oEng6Thg4cjuWKKAbtYedLOHExAboUUKWxTgiOI2+J8wdEaEEBRbm7Bz4cWUpw7lp8RbLEpORZFs8NrRNP5kaVnIsKqAQTeJUw22SDSamF7B59EH+S76HJuFRrNl6AgCmOe4oZPTsufEYFgrZs6cyU033cRPP/2EaCB3S6VSrFiDFTzNtWODwWAwGAwbOqloNGeMs5qiKkPHJXNlI/O72b/deq1HLI/Vh8Ph3NfBS0vzkzBII2Fod0RVdglDa67YO3Bg9iJsrTXff/8tO++8a/a4bt2InXwakfv+1WKM8DyCb7xK/JQ/rlGuHZnwQ/cRfP2VvONV9+6IlSsRWVYrb0jk3rvw+vYl/sez1jBDQy6CL71A4V8uRuZ4/a5rRCpF6LmnCT33NPFDj6D2in+g2rCouzMRaEHCMClHvx122InCwsIcURsOqZGjs0oYnG+/Ri5aiNp4k3bMav3A/mImThbBQVOtRWP69Ombl2hrbdhvv/2zShhWVlQw8cHHGP3aK4SeeTLr51D8yKOpueYGdI8e/PjjD3zyyfSs+x46dBsGGTlMVrbccgg9e/Zi2bKlLcZMAC5bpS303NPrnYQh/OC9OWNiZ5yTVVgXiUR4+OH/sPfeu2Y9R4oDNwD3rJrDw/cTO/2sZgv313s8j8itNzZqcoGrgUX4z4E/ACceegRbruf379hjT8gqYQC4l5YlDACh117GWraU6tvuwhu8JQCivIzIHbcSyeO5poFbQ2GIx1iwYD7XXXcVN998HQcddAgnn/xHdtttd/O9VQvssstuWbd7wMfAqhqewPi3jYTB0KpYCxe0uO1X4KI8xjjiiKM4+OBDWyslg8FgMHQSzPJ2BoPB0ElZHq/miu9fYXrZz9R6SVwUCe360gXtf8Xf8FKCSosYMmiom2RrIZBSEpQ2u5f25/+G+AIGg8FgMBgMBkP7EIsleWfCN1x6xfOMn/gNZeW1/hdD6S+HLKv+9N/z6gu/W0SATB/6ZSKFEAQCFo5jYVmS4uIwe++1JTddfzQjx2zF50uXcvN7U/nHO++xqKKKkGWR9BRSgCV9qYJjSYQQJD2PWCrlS7xk/VGmAFKeL40IOzZ2OgmlVV1qGrClZItuXeldXEhRKMiI/ptx2Zi9ueXg/Thq26FGwNCB8aUbNSTVCmq8WSyKP8WP0T8zN3YNs2KXMT9xJ+Xehyjt4aooGi8tXLBIsRxFJQIrfW4j00Xi4BFLCxYyzzV/W70swZcfkBYuNEag8SAtYWgor5PYCCT1heMCISwkTroPCBwQAosIpPcBOn2+pbCIYFOEIoGXlkg4oisB0Y2g6EZEbEaJtQPF9hD6BI5g24K72a34RXYoeIDtCu5g89CpFNtDCFndCcveRsBgaDNKnQHsWHg+exffRE97B+y653TmM0g083tVIUNDdDpi1bgM9SUKGo84ZcyKv8Q7lecxveJfRL2VrXK/DAaDweDz1FNPceKJJ/Ltt9/WXRcWQqzxj8FgMBgMBkNHIGkkDIbV4Jdf5mPhr5gUAEJAGCjAXy2yGPhy/s918fFY7udXKJT7WniXLqU5Y8oAUV7e2NZsaHNkZQ4JQ0nrSRiGDds2Z8w33+QqC/WJnn0+2rKyxgRffSmvsToT8qd5FFx/TV6xqR13ouz9j1n5/U+UffE98SOPzns/hVdejpNllVrDGhKPU3jhORSfdVqrCBi04+D16InbfwDeppvh9eqNDoVaIdGmhF59ia577kzBFZci1kCiaWiA1jhT32/SvAT4IUfXPffcqy0yWmckxzS/an1DAjmKbTsq4Yfuz7o916ftkCFbtV4yLbDvvuNyxoz/8ANq/nkP5dM+I3rBxaR23BmvZy+8nr1I7bQL0Qv/TNmHn1J9/yPoHj0A/3rxwQcfhm23vEbocced2Gr3o6MihGDkyNFZYz6E9MyBegIT3l6v3uet2bMIvjsha4wqLSV+9LE5x+rXbzMuueTynHEPAfNXzePXRQRfeTFn3/WR4AvPYc+Z3ajtTXwBA0AUeATY++5/Mm7cKJ577um8ZH7rgn333Y/u3btnjXkBWJxjHGfGx5TuvStd9tmbLgfvR7dtt8xLwADwvuPwWbzx45NKpXj55Rc59ND92WuvXXjppRfyGquzscsu2WV9AB800xac+A7kce3MYMiXbBKGM6HJjL5V6dOnLzfffHur5mQwGAyGzkHLZ7kGg8Fg6LB8X72EO+a+x8/RlVhCggZLCDztly745UE6vdZqQzS2kHhapVdk0OlWgSMsjuq7PcdtsjNBaT5eDAaDwWAwGNoDrTUfTZvNOxO+YcGiMjxPI4Tf7nkKpXRdXMOVapXKxGXGodFtACklWim/fFwptPYFDrYtGb7bQMbttw0bb9KVt36Yzbuz5lEei7G8ugalfenC/PIESU8RbDQRT9T9m/IUtvQIWBaOlCQ9DyEEbnpfQggijkOtTuFpTdx1kQhSyh+zOpmkOBjkyG225sCtBiNNIVeHxtMxqryZrExNIqZ+wdVVpHQZAhtHbITWGkUcQRhQJPUSFKm0gEEANpo4/hlPLH22A/4Zjy9JUCQR6UtlAoFGoEkBDSfKCzQKicWqBeQSG43VQOTgCxWkCOLpKEILhPBXH7AIoXHT4gcPtIXGxSKMRSEu1WjiCCQB0RUpQkAXHLoRtjbFEUUERU+6OjsTlD2bfcxMcaNhXVFqD2D34quochfwTfQxVrrf4xJPb214lWHVSf2rChl03VWHpoIGmsT6kR5xXca8+LssiE+jX2gkAyP7Ushma3GPDAaDwfD+++9z/fXX151XNDy3cByHoqIiQm1UKGAwGAwGg8GwPuPmUSRvGwmDIY3MsrprHSp9bTGVIqZU9lggHM4tYSgoKCAQCJBMtjwVfSUgPA9RXYUubr3Cf0N2RI5CbtWKEoZu3brRt+/G/PrrohZjvvvum7zG0j17ktp7JIHJ77UY43z8EXLpElSv3quda4dEa4ouvQgRj+cMTex/EFUPPgbp82zVpy/V9z9CYv8DKT73DEQikbW/8DyK/3gi5ROmdMoV6NsCsWwZJSf/AWfmp2vUXwcCpPbcm+SeI3B32BF30Jbobt3qZPr1gRqxciXWogVYP3yP8/WX2F/MxP7yC0QenwlZ70MqReSRBwk99wzRiy4hdvZ5G+aK4OsY64fvsZYva9I+OY++e+45ovUTWock9xqJDocRWYp9g+PfIn7aGe2Y1bpHLl2SVUSkyS1h2Gqroa2aU3MMGbIVm2yyKQuzFDKOH/8WV155Dd6AgdT+/eq8xh08eEseffQJli1bxnPPPcWTT/6HBQvm122PRCIcdZRZET0fRo4czX//+0yL21PABOCIBm3CdQm9/AKx089u6/TyIpeQBCB+4qkQieQ13llnncv//vdffvjhuxZjUsC1wKOrtEfuuYvE745p+tm7PpNMUnDbTU2a72kh/PPPZ/L55zP5xz8u580332XgwEFtm99q4jgOv/vd73nggZbuAbjAA8D/5RhLaI3z9ZerncONgwbDd9+2uH327FksXbp0tcftDJSWdmXIkK2zvv6akzCIaJTAexNJHnxo2yVn6FTIRQubbV8MvJVH/wsv/DMlJV1aMyWDwWAwdBJMlazBYDB0Mr6tWsyNs8ezLFGVlin4RQ1K10sXMmUPisZlRQqQWmMhUEBYOCTx6OYUcsImu3BQr6Gm0MdgMBgMBoOhHfA8xZy5y3jhxU+YNXspGnBdD9u28Dz/6E1KvzAqI0+wZP1xWka60BAhBFKAp9J90pN5bFuilMZxLPr1685RR+zM4CF9mLeijJvencq3S5dREgoRsW1fnGBbaZmCIOl6xF0XBIRsG1uKRuufJz1fwhCybTyt8bQG7R+hCvziLsey6BkJ41iSlbUxHEuy86Ybs3f/zdh5074UBAJt/4Ab2p24+pXy1IdUeZ+T0uXE9WLQGptiBEGSVCCQ6EbChXBajmDhkaJeuJARMSh84YKHJoFIyxUy4/hjZKQhftG3L1yQdX9nzpAEEomNIkXD4nBJCI/a9C073RZACxelU6AVpMULkgA2XfCo9A8cBAABAABJREFUwaUWgcQRXbFECIdiQrIPBbI/jizGFl3oYm1LQGZfGcBgWJ8otjdl96KrqPR+Zl78NX5NfohLksZXG2T69qpkrkQIsgsYGsaSHk+D9khRw9zYm/wUe5eNg7szMHQgpdYAc93CYDAY1oAbbrihkditW7dunHzyyYwePZrNN988v2Iyg8FgMGxQpFIp5s2bR3l5ORUVFSTSxX6HHXbYuk3MYFjPyEfC4BgJgyFNPtcklPL82FiUfNaKDIdzFywJISgt7cqyZS0Xk6zMxJaXGwlDOyIqs0sYdHGXVt3fsGHbZJUwfPXVl3mPFT/8d1klDEJrgq+9TOyMc1YnxQ5L6NmnCHwwJWdcauddqXr439DMd1/JQw6nokcvSo4/GplD4CFXrKD4lOOpeO0dyEPWYmgZ++svKT7xWKzFv65239S22xM/5Y8kDjokv/dWIdDdu+N274673Q4kjj3eb66qxJn2EYF3JxB863Xkit9WO5cMsqaawuuuIvS/56i+5U7c3Yav8VidkcCU5nULuSQMwWCQnXbapfUTWpeEwyRHjCb4zpsthjgffeALnoqK2zGxdUvo348gXLfF7b8AVTnG2HrrtpcwCCEYO3Ycjz76UIsxs2fPYtasHxk8eMvVHr9nz55ceOGfOf/8PzFlymSeeOJx3nnnTQ477EiKzbFmXuy996icMa/SWMIAEHz26fVCwiDKVhJ64dmsMdq2iZ16et5jOo7DddfdxJFHHpw17j/A34HNG7TZP3xHYNJEkmPG5r2/dU3oycexFvzSqO0r4N0c/YqKiunff0Cb5bU2nHzyaTz44L11ku/meEAI/qY1rX0lZfrpZzHx4QeyxhQUFHLccSe08p47DrvtNjyrhGE6kIAm/3fB1182EgZDq2EtbF7C8CFNl4FZlYKCQiODMhgMBsMa0yklDCeeeGKTNiEE//nPf/KKbQta2r/BYDC0FlprJv82i7t+fp8aN4GrlV+GlL6Y4aHrShs0jeULEoGiPi5DQrt0DxRy6Rb7sHPXfu14bwwGg8FgMBg6L0uXVfLk0x8x76ffqKqOYlkWyvMLWD1PoVR6NfAGRVLgH/cJ4QsYMkgpGsSDtIQv3bItlFJo5Z+vbrRREccdO5z+g3syfcEi/v3GROatWElVPIElJdXxBEpn5A7+RFKJACGQQML1kEIQsCwcS5L0PAQCT2k85QsiIrZN1HVxta6TM+j0oAHLQmnNoI26cc4euzJwo27t94Ab2hylXaq9r6n2viKpy4h6s0nq35A6hJQBEsqXLAgskqxA4wI2Mv3VnUccX2yQwFfGSTQe1MkVEkgyKzPLdGwKyExizJwBqfQ5kUyr6vznsgAkDookDQvCJUEULqCQBH1xCDaaIIpEemSFL22wCIjueDqOSw0AAVGKJULYFBKR/Siw+hMQXbFEAcXWUAKyaxs+6gZD+yCEoIvdnx0LL6K/eyA/xd/k1+Q0XBKQfn00iG5025dE5itMSPfVqv4m/oeeS4L5icksTHxIF2sA20SOp7szBCmsLOMZDAaDIcOXX37JggUL6o7zBw8ezL///W9KS0vXcWYGg8FgaG0SiQQvvPACEydO5KuvvqoTLzQkm4Th448/prq6uu724MGD6dfPfH9o6NikYrlXNLeDoZwxhs5BPvIynb7WL2KxPCUM+RVXd+2an4RBlpeh+m2W15iGtUdWZS/D1MWtW7Q6dOg2vPNOy2tDfvvt15SXl1FamvvadHL/A9GBACKZbDEm+KqRMIBfQF9w7T9yxnk9elL16BPNChgyuLsNp/Kp5+lyzGFZV58HcL76gsK//5Wa2/+12jkbfJwpkyk56Q+IaG3u4Aakdh1O7V//RmqPvVplxW1dXEJy3AEkxx1Azc2348z4mODzzxJ65UVENJ9Pi6bYP/5A6SH7ETvhZGqvuR5dWLTWeXYGApObL32dlKPfLrvsRijU8Y4JE/sfmFXCIFIpnMnvkTzk8HbMah0SjxP+z2NZQz7LY5ittx7WOvnkYOzY/bNKGABef/0VBg++bI33IaVk1KgxjBo1hmXLlpJKpdZ4rM7GRhttxA477Mjnn89sMeZNSM+cqMf59mvszz/D3WGntk4xK+EnHm9yrLISOBI4E/gd4B12JKp3n9Uad6+9RrDXXiP4IIvcygPuAO5eNad77tpgJAyivIyCW25o0v7PPPqeeOIpWNb6+T14//4D2GefsUycOL7FmN+05rFwmLNzHOuuDrHTzuD/FrUso8tw4omnUFLSpdX229EYPnwPHn/8kRa3J/A/5/ZYpT044R2qo1GI5JZIGgxZ8Tzk4uZfy9Py6H7xxX+h0Jz3GAwGg2EN6ZQShk8++aSRXTxTmJJPbFuQbf8Gg8HQWry57BseXzCd6lQMW1h4pIuJ0oV5fnFDUwGDBn8tWSHxtMaRfgGcIySbF3TnqsEH0Ctk7LQGg8FgMBgMbc2SpRV8OG0Ob0/4mng8hVY6LVZQeJ5CCNFIqqCUXuXc15cuZKQM/m2wLInn+YWwnld/FCiEoEePQsaM2op99xnKikSMW97/kCVV1QSkL1II2Ta2JfGUIpqeaGdJX7YgRP2xpsAXMTiWRdCycT1f8aW1fx8sBJaUBKVFQErCToBoKkXK8ygKBuhTUsSYgQPYZdO+FHfACSqdjZSupNr7GldVE1M/UeV9haeiIAQpXYYiisBCUItWoHGx8L+MUyTRpNKaOAdf8+ECAo2HIp6OzZzZiBaECxqBQmChUWnxgo8ggCYOdcXfAkkQjYvGQ+AAAoFEEkIRQ6PRdWo7CNATUKQoB0BSjCBIQBZSKncmYvUnKHtgEaLIGkxAdm/jR91gWPeU2gPZsfAiBrpH8l3036xwvydFFP+11nBVIFF3fSJ/dP3Lu+6majSmh0uZN4sp1ddQKHoypOB3bBLYA0s4a3O3DAaDocPz3Xf+qjaZ77Kuu+46I2AwGAyGDsgzzzzDPffcQ3m5fx7b3Ip0ueY0zJgxgwcffLDu9qhRo7jvvvtaN1GDYT0jHwmDE2zt9RsNGyr5SBhURjAZjZJPyUm+EoYuXZo/hi8EugEF6duirCyv8QytQCqFiNbyLhAHuqzyUwCoktadi7Pddttn3a6UYurU9zn00FXXVG6KLulCcvQ+BLNIHezPPkGsXInu1rnF2pG770SuXJkzrvqBR1G9eueMc3cbTtWjT1B8/DEIpbLGhp/8N8kRozpPAXQrEnjjNYrPOjWraGRVvD59qbn2RpIHHdoq8oVmsSxSu+9Javc9qb32RoKvvEToycdxvvxijYYLP/lvAlPep+qeB3F3G97KyXYwamtxpn3YpPkX4KccXffYY682SWldk9xnP7QQiCwrmgffeavTvAeFXnoh5/v98z17QRYxVjAYZMCALVo7tWbZY4+9KCnpQmVlRYsxr7/+KpdcsuYShob07NmrVcbpTIwbd2BWCcNK/KLTvVdpDz/6ENXrUsKQSBB65MEmzQ8DU9I/lwKnFBdz3MqVdFvNY8XLLvt7VgkDwKPAVUDDWRiBjz5YLwQV+RC59UZk+hpdhiXAMzn6BYNB/vCH9lmAdk354x/PyiphALihqJhTgkFCFRVrvb/aSy9n6sgxvH3gPlnjbNvmzDONQC4bu+22e86YqTSVMIholMB7E0kefGib5GXoPMilSxCu2+y2j/Pof/bZ57VuQgaDwWDoVOT+dsdgMBgMGzSuVjy5YAb3/jyV8lQUD01Se6h0iZCnFaKZlSUbtvhxaVGD8suKhpX05arBBxoBg8FgMBgMBkMb43mKV9/4ghtve5M33/6SRDxFwLHSAgaB6+k6oYHWGin9Izmtm0r/tNZYVv2lAF/Y4PcJBR0sS+I4NkWFYcaM3Iq/XXkIxUNKuX7yFM5+/jW+WLSE2kSS2pSLqxRWel+WlP5+BMRSLknPQwiBI/3CdiEESmtcpZBSEA7UF7yqdN7gr4neo6iQjSJhuofDjBnYn/t+dwjX7b8P+wwaYAQMGygJtYxa70cq3I/5JX4Ps6KXsjD+EAsTD7E09SJRNReXcjxqUSSwKEDg/18ratNnLpnJOx7gF1crMpPcM5XXMi1KWHXSoU7LEyxWrdKWBNLb6xUMsk7u4KV/y7RwIVzX19+/BhQBuuHQFY8EiiiSIJYIY8tCulp7sbFzMpsHz2fz0JlsFbmewZG/sUnwWHo4Y+jm7GEEDIZOR7G9CcOLr2RU8R1s7OyFRRBf/yjRSBQyLTRZjUmqTQQMPhkVC+nXq//aTVGlf+XTmnsYX3Eh30WfI6VyF80YDBsUup1/DB2ampqaur979uzJsGHtsxKbwWAwGNqHeDzOn//8Z6699lrKysrqrtEIIRr95MOJJ55IIL1ys9aaqVOnUmaKeQ0dHDeeu0zeybNI3tDxyef9VKULqkU8Tj5rm+crYbj44r/w+KNPMAX4Fr+AJw5UA/OBf6TjZEV58wMYWh1RVQXA5cDBwF7AMGAToAhwgP5/Oo877ril1fY5fPge2Hb2NbsmTWp+lffmSOSQNQitCbz/Xt7jdUTkooWEH7w3Z1zshFNI7blqCWXLJPfZj9p/XJtXbNHFFyAX/JL32AYIPfMkxX88cbUEDPHfH0f5BzNIHnxY2wkYVkEXFRM/4WQqxr9Pxatvkxiz7xqNYy2YT5dDx1Fw7VVgVqlvkcCHU5t9TmwCfA7cDuy39VAKCgqbxOy554g2z29doDfaCHenXbLGBN4dDy0Uy3UotCb80P1ZQ2qAN3Mca2299dCcn9WtRSAQYNy4A7LG/PDDd8ydO6dd8jE0Zdy4A3PGvNpMW/DVlxArVrR+QnkS+t9/sZYva9SWAu5pcPtX4LrHHmb77Ydw8cXn88MP3+c9/s4778q+++6XNSa2yv4yRO65K+/9rCusWT8SfvyRJu134z+O2fjd745ho402apO8WouRI0czcOCgrDGLli/j/tPPxu0/YI33o4NBqu5+gNpLLuO666/OGX/kkUfTp0/fNd5fZ6BXr95sttnmWWNa0qOEXv5f6ydk6HTIhQubbY8DuZR0Z555TrsdYxkMBoOhY9KpJQy6QaFHvrFt8WMwGAxtRVK5PDT/Q/7762cklVv3pm+Jeu2Cwi9DaPj1j8YvM7KFTBcsiLryh4Bls3/PrblpyGH0ChW3350xGAwGg8Fg6GTE4yk+nDaHK695iedf/ISylTXE4ik8T5NI+oXoAupECJqMVKEerf15Ppm5PpnbUop0u6jrk0y5OLbF3nsM5OIL92PQ3ptyzXtTeGzGTL5fspy462JLQW0yxbLqahKuh9fgnFYKUXfcmHA9NBCwLQT1qyd66X3ZUhJxHCwp0WgSnkc0mUIphac0JZEwx++8HX8ZvRd9S4qx8lghzLD+oLWLp2JUup8wP34zc+N/YV78SubG/8Zy9wWSeimg8KhBEkISQeGS0ivSwgX/HKRepuCh0uu++W2+GKFeuND4bEaTQmADuoFwTiMIrJKpQOCk5Qxe+nZj4YKmXrigcbEpxmEjNEkUtQhsLFGILSN0sXaiT+BYNg9eRL/QGQwO/x+DwlexSegEegRG083ZnZDs2SaPucGwIVJo92aXoksYXXIHWwQPRxLBf303NCqs5vu/ru8taK42PNOqULhUq8V8G3uetyvO46uaJ4h6625CksFgMKyvdO3aFfDPHXr06LGOszEYDAZDa6K15uKLL+att96qE3kKIdZ4PkPXrl0ZO3Zs/XUgz+O99zp34aWh45OK5S6Tt4NGLGvwESKP6xwZCUMsmqeEIZLXvkeMGMWBBx/GnsUlbA30AoLN5Vhu5DnthUivOl3RwnYPKKuuxvO8VttnUVExO+Uoln3rrTeIxXILZgCSY8ehcxQxBN6bmHd+HZGCm65DxLMLYL2evai96v9We+zY2ecRP+KonHGyqpLis04zxfV5EnzhOYouOhehVhV+N4/q0oXKR5+g+l/3o4vW0Tw6IUgN34OqZ1+kbNJHxHMIUpodQmsid/+TkiMPRi5b2gZJbvgE3pvQbLsEtgcuBp567mVmz/6Ft956lyuu+Ad77z2K7t27s/32O7Rnqu1KYr/sRfyyogJnRj5rE2/YONM+xP7+26wx93XfiGgikTVm//0Pas20cnLIIYfljHn99VfaPA9D8wwevCX9+m2WNeZVmn4fKpJJQk//p63Syo5ShO9tKjp4CV+8sCrxeJynnvoPI0bsxjXXXJn3bi688JKcMXcDtau0Bd58DevHH/LeT7ujFEV/vgCxyjlAOc1LJVblzDPPbZO0WhMhBKeffnbOuDuefYplb04kdtJp6NUUXKV23pXydz8gccwfmDDhHaZN+zBnTuedd9Fq7aOzsttuu2fdPhVo7pMuMP4tRNnKNsnJ0HmwFjYvF/yB3JKa3Xffq9XzMRgMBkPnolOqfHbeeec2iTUYDIb1CVcr/jnvPaasmENUJRsUH2hfupCeRJUhU6SQaVFo7HQZnSMkCiiwghzeZ1uO33gXUwhnMBgMBoPB0IbM+2k5Tzz9EUuWVlBTm8CypC9N8Hx5glIKrUFpjZS+WEE3LDxN3wZ/Qr2UEs/zJwt5nkIIgZSSgGORcj0i4QC9e3fhmKN3IVEoeG3OHD6ev5CAbbNRQZiVtVGCtoWdPgZ0lcJTvjghHHBwpCRgWcRcF4GfV8rzCFgWYccmlnLRWqO0wl/t3C+VLwwG2KxrKcurq3GVZvTA/uy++aZs3asHjmW1++NuWHNcXUml+wll7nsk9XKSajmKKJJCAmxEimo0AkkITZQk5fjP1mAD5ZsmI1zwJQgZwYJEk0JT/0VzRtKgSCKw0HgIZJ00QRLAW+UrFomDIkFGuOCr5wQWYVxq6nJQ6TwsCrAoxKUiLXYIYFOCkJKQGEJE9KfA2hJLBAnJPhTIgflNpDYYDI0osvqyTcHJ9A+NZW58PAsSk0hSk5asNJw21LxWoSUaR2b66mYiPGL6N2YlXuan5AQ2D4xh89AYSuxN1+j+GAzrA8K4nw2tSK9ever+rqmpWYeZGAwGg6G1ufvuu5k0aVIj+YLjOBx66KGMHDmSjTfemD//+c/89NNPeY85btw4Xn/99brV3j/66COOOip3caDBsKGSylFYC2CHjITB4CPzmGOh6iQMsZwSBiEEgcCq4tns6NJSqKpscbssz746s6H1kOn/h1yPeElJSavud9SoMUyfPq3F7ZWVFbz++iscffSxOcfSRcWkdtmNQJaipsDkd325SCecY2TNm0Pwf//NGVf7fzegi3P/PyulGr+PCEH1HXdjzZ6F8+3XWfs6n31C5LYbiV7+j5z76czYb79F5ILcRYEZ3C2HUPnEc6gcKwK3J97QYVQ//G9i55xPwbVXEfhw6mr1D0yfRpcxe1H9yH9I5Siy61RonVMqk9p2e3TPnjjATjvtwk477cJFF12C53lYHfh77+S4A+C6q7LGBN55k9QeHbvwLfzQ/Vm3R4Fb85AcHboGEpW1Ye+9R1FUVEx1dVWLMa+++jJ/+tOl7ZiVIYMQgnHjDuTBB+9tMWYe8DWw7Srt4ccfIXb2+bCa5wtrS2DCO9hz5zRpb6plaEouWVhDdtllV3bddTgzskheyoBHgQsatAmtidx+M9UP/zvvfbUnoScex/lkepP2u4DqHH1Hj96HLbcc0iZ5tTa///1x3HHHLSxduqTFmCVLFjP9u2/Z+9Z/EjvpVCL33EnwjVcRyWSLfZLD9yB21nn+Z5MQ1NbWcvnluYUdRx31ewYP3nKN7ktnY/fd9+S5555ucXsM+BgYuUq7SKUIvvQC8T+e1YbZGTo61qKFzbYvyKPvDjvs2LrJGAwGg6HT0SklDE8++WSbxBoMBsP6QkUqyj/nvce0snlkCg1EehVX8Nd7FA22NMRC4KHRQEr7cR6aIjvImf32ZFzPrZGraZU0GAwGg8FgMOTHTz8v591J3/PxJ/NIJFL+sZinUCqt00qvSpiRKmh84UHDstRMDOg6EYMQIKV/DCelSIsYwPUUfft04YgjdmKpneCxH79hSXU1v9XU+iXqMsWK2lo8pQk79ZcQpKBuMn0slcIKBLEtiXDr70vKUwQsq06mEE25KKVJuC5SSJKeIhIIUBmL07u4mBN23o4dNu7TZo+toXVJqCVUutOJ6fkk1CKi3jxAYosiXF2ORw0CC0UNMSrRaCQFCCQg0DqWPhOJoQmni60zwgUXX8DgkzmXUaTSogW3bgsoBAEgScPiaoGdljO4deMCWETw8IsH60V0CosQFkW4VKNJAZKA6IIkiCP6ERYbU2hvhS2KCIqNKLKGIUX7TlgwGDo6hVYftis4hS1DR/Bd7CmWpD4jrivSr+wsK/5lXsyN/2y0Obu8QaQjFEldzazEq8xJvE2fwC4MCR9OqdW/7jPPYDAYOiM77rgjkUiEaDTKggULqKmpobCwcF2nZTAYDIa1ZNmyZTzyyCN1x7paawYPHsw999zDJptsUhfnOM5qjbvXXnsRCoVIJBJorZkxY0ar5m0wrG94WSb/Z3CMhMGQJp/rC8rLSBii/kIZ+EV7zV3ZCIfDq33NQpWWYv0yv+Ucy8tWazzDmiMqK9FARY644jyK81eHffbZjxtvvDZrzO2338yhhx5BMBjMOV5yzNisEga5ciX2l5/j7rDTaue6oRO56w6EUlljUjvsSOKwI/Mab//9R9OlSyknnHAK++9/oF/UHYlQ9fhTlI7eE5mlgBYgcuftpPYcQWqvEXnfh86E9dGHRE45ocnK0y2RGHcA1fc9jC4syhlbXl7G119/xc8//8TChQsoLy8jHo8Tj8fRWlNSUkKXLqV07dqVzTbbnIEDB9O//4C8XoMt4W6/I5Uvvk5g0kQKrvob9uxZefe1li+j5PADqbn1TuLHn7TGOXQkrNmzsBZmL+9Kjtmn+b4dWMAA4A0chNt/ALGf5jELaO7dPvjGa9T+343+pIUOiPxlPoF33swa80g4zIra7ILbHXfcic3aWeoSDAbZb7/9+V8WadD333/L999/x1Zbbd2OmRkyjBt3QFYJA8CzNJUwWIt/JfjSCyR+f1yb5dYckXvubNL2CX5RdjY23bQf48YdsFr7Ov/8i7JKGABuB84GGl7dCr36EtE/XYq3nj2n5eJfKbi2qdSmivwkFmeeeW6r59RWhEIhLrzwYi6/vHnBy/Dhe3DjjbfVve94Q4dR/cCj1NTcifPBVOxvv0YuWwbKQ3frjjtoMKk99kL16dtonNtuu4lFLRRtZ3Ach7/85YrWuWOdgL3yOJd4l6YSBoDQc88YCYNhrZAtvJ4X5egXCoXo0aNn6ydkMBgMhk5Fp5QwGAwGQ0em1k1w65wJzKxcgKcVUsj0F/J+uVLmqyLtNyG0rhMxZIoVbAQKCAoLF0XvYAkXDhjNzqX92v8OGQwGg8FgMHQCotEkr775Be9P+YF4IkUy6RIKOiSSbno1QlDKlyoopZEN5ido7YsV/OM6/5jOlySkRQ0601dj2zItcbDo2aOEvfYYyA579Oc/n33Jj8tWUBgMIAFLCkK2DRririapPGIpl4jjYEmBJSV4vrBLaXA9j4BtEbQt4q4H2t9fBltaBCxNz6ICoqkUNYkkRcEAO27Sl1FbbM72G/cmaJtLFOsrWmui3lxiagEpVcHKxDSS6lcAFHGSeiXgn3EoXY0ihSSUFi6ASxWg0SSBIH4xdUYLlwQCUHfWItAoFElEo1JqAbgIwjQWLugGwgWvLg/whQsuNelYqy5eEkAQwSOBSwIAh1IsEcEiQkB2pVAOJSC74ohSSuwdcURxqz6mBoOhZUJWCTsWnktSVTMn/gY/Jd4hoasayFp0g98N0M3+mQcNo/33HUWKRckPWZT8lGJrE7aLHE9PZxhSdOzJkgaDwdAckUiEcePG8dJLL+F5Hq+88grHH3/8uk7LYDAYDGvJQw89RDKZRAiB1pp+/frx9NNPr7VoJxAIsOWWW/Lll18CUFFRwfLly+nRo0crZG0wrH/sOGALFOACqVV+kunfhX03XncJGtYrpMxdeKh1umA7Fud44Hj8KxcJfBlDLP07Ciz732urnYMu7Zo9x/Ly1R7TsGaIqkpqyaoeBaCkpEur7nfo0GFsvfUwvvvumxZjfv75J0499XhuuOFWunbtSigUblHMlNxnLFz7j6z7DLw7odNJGOQv8wm+8FzOuNqrr8+rKLmsbCVffPE5AJMnv8eQIVtz8823s9tuu6P6bUbN7XdRfMYpWccQWlN07hmUT56G7tYtvzvSSZBffUnBsUch4vG84qOnn0XttTeBlM1uj8ViTJ36PhMnjmfq1MnMn//zaudkWRZbbrkVw4fvzvDhezB8+J5079599QYRguSYsST3Gknkvn8RueOWvO+j8DyKLj4fufAXopdd2WGL5/Ml8O6EnDHJMWPbIZP1B6UUX3/9JZMnv8cHsRjTgSLgN+q/lc1g/boI+4uZHfazIPzoQwjd8jdTKeC2POZCnHLK6a2YVf4ccsjhWSUMAPfffzd33/1AO2VkaMiuuw6na9eulJW1LEt7DriRpqL6yL/uIHHU76GdZDD2JzNwPpnepD0fgcBpp5252tKaffbZjy23HMKPP/7QYswC4HlgVRVFwa03UvX4U6u1vzZFKYrOP7tZqda/yC1u22ab7Rg5cnRbZNZmHHfcSdx11x0sXbqkrq1Xr95cffV1HH7475oVDurCIpL7H0hy/wNzjj9z5qc88MA9OeNOPvk0Nt3U1EbkS9++G7PFFgOZO3dOizHvAtc10+58/SXWd9/ibT20zfIzdGDiccJP/rvZTbkkDL179zELrxgMBoNhrWn+KqDBYDAYNkh+S1RzxQ+vMKNiPgnl+hM+0l/SeygUGrFqnYJofPHNQ+Oh0WhS2hcwXDF4nBEwGAwGg8FgMLQByaTLG29/yVXXvcwbb31JTW2CRMJFKU0snsJ106teCdFgZUJQWjeasKm0Rlqy7rhOa38ujJSCgGPVyReEEASDDvsfuC2j/7Adn1llnPfSm7w/52dW1tayrLqGFbVRLJG+XCBApvsprYmmUiitcaRsVAabTK8KE7AsgukvRpXWuEqhtSalPIK2RcC2KQgE2XPzfjzy+8O5fJ+92W2zTYyAYT1Da5eEWkLU+5kVqTeZXXMVs2uvYkH0IeZH76HKm05CL8XTMVK6AoGDRQRBEI84miSalD8WHmk1CJoE1N2G+jORJKwiXNC4iLr1CBoKF6y0cEHVjQtgESZTlC3SU3s0AomDJIImhUcMRRxJAZboQkB0IyQ3prs9mh6B/ekdOIItI9ezdeRO+oX+SO/AEXR3RhkBg8GwjgjIIraOHMt+JfewQ+RswqJ73eu7HtmsjyFDRu+Sm7pP0PSPSt9KUu79xJTqG3iz/AJmx97G07lXOTUYDIaOxoUXXkiXLl0AuPvuu/npp5/WbUIGg8FgWGsmTpxYJ2AQQnDdddettYAhw9ChjSfSms8NQ4cmmUTgr6oZAUqA7kBvoB+wBWCHI+suP8N6hWyhWLchykt/JxCL1rUJIAR0BfoCA4FtHIftd9pltXNQpaVZt4vylou7DK2LrKzMWUwFUFJS0qr7FUJwfB4r20+cOJ6dd96GAQM2pm/fbvTp05V33nmrSZy35RC8VVacXZXApIlrnO+GSuRf/0R42RUbiXEHktpt97zGmz698SrPP/zwHYceuj833vh/pFIpEocdSey4E3OOYy1dQtFF5/hfJBoAkHPnUHDkoYiqpkWPzVH7lyuove7mZgUMX331BZdcchHDhg3ihBOO4YknHlsjAQOA53l89903PPLIg5x22okMHboFhxwyjjfffH31BwsEiF50CWVTppPcfc/V6lrwz9soOud0SCRWf78diFzvY6q0tMMKBhpSWVnBs88+xRlnnMxWW/Vn7NiR3HjjtXy4ZDEuUA7MbKFv8LVX2i/R9qSmhtAzT2YNWSklg7fdPmtM//4DOOKIo1ozs7wZNWpMTunT888/y9Sp79fdjkajLQcbWhXbtjnwwEOzxvwCzGiu79w5BN56o03yao7I3Xc0afsVX4KQjYKCQo477oTV3p+UknPOuSBn3M00/So5+OZr2J8296itG8IP3Evgg/ebtK8Absmj/8UX/2WDKzAOhUJceOHFgP88P/fcC5k27TOOOOKotb4vFRXlnHHGKXg5jseLioq56KJL12pfnZG99x6ZdfuntCwOCT39n1bOxtAZkMuW0uXAfbPGZFOO9slxzcJgMBgMhnwwEgaDwWDoICyJV3LD7Hf4rmoJmfI7AVhCNCklWLVAwRICW/i9bGFhIQlJm62Ke3PXsKPYqqh3e94Vg8FgMBgMhg6PUprvvv+VK//vJf730mcsXlKBUgrHttBaI6WsW1BEKY1SqtGXTKvOjfJvayxLpm9rPM8XIOj0GEWFIfbcfRB/vGAUX9jlPP/Nt/xSVkEi5RJ2HBzLIppMEXdd4qkUXnonmf1KfLFC0vMQQhCwrLpDSqV1WvwgCDk2AdsmHHDQGuKuR9L1CDkOG5cUc9quO3DJ6D3pVmAmH69vpHQFK1JvMyf+V+bE/sKs2HnMT9xCeeoDtAZX1QAKSQECmxQrUMTqzjfSmhBAokigcalXdfgnIboZ4QKk0oXVq65wLxHYaeFC/R4aCxfs9F4lEgdBAI2HRxxFDEmIkOhDQHTFEcVExGCKrV3p5uzJgNClbBt5lIHhv7Fp8DR6BQ4jLDdpo0fXYDCsKQFZRP/QWMalZQwlcrP0e4ak/j0Dmr/Une8EjaaTjnWdjEGjcKnWS5gZfYw3ys9jZs1jJLyaNbg3BoPBsGHSs2dP7r//foqKiqisrOTEE0/ko48+WtdpGQwGg2ENmTdvHsuXL6+7vdVWW7Hzzju32vgbb7xxo9tLlixpIdJg2PARbip3kGMEtAaffApJtMpIGGLZ49ZQ7qFLs01LB2kkDO2GyFPCUFzcuhIGgKOOOma1x3Vdl0Ag0HSDEDlXf7e/+ByxYsVq7W9DRv66iNBzuVdWjl56Wd5jTpv2QZM2rTX//OdtHHHEQZSXl1Fz3c24AwflHCs4/m1Cjz2U9747MnLxrxQcdjAyz+dnzfU3E73kMmj0na1mypTJHHnkwey77wieeOIxqqoqWz1XpRTTp09j+fJlaz7G5v2pfOkNaq6+Ht3c67kFQi8+T/Epx0E8vsb73pAR1VU406dljUmOGtNuK82vS5YvX86FF57DK6+8RFlZ88cME1roG3zj1Q4pgAn99xlkjtd86YGH8MxLbzBp0kccccRRzYq5LrroEux1tHBFMBjk4IOzF/lrrTn33DNYuHABP//8EyNHDufqq/+es8DZ0DocfviROWOea6E9cudtoFQLW1sP+8vPCY5/u0n7/YCbo+/vf/+HNT7mPeKIo3IW134DNFWJQeE/Lm+XxyYX9pefU3DDNc1uuwGoztF/yJCtGTfugFbPqz044YRTOOGEk3n//Y+56qprKSwsWusxPc/jggvOZuHCBTlj//73q9loo43Wep+djREjRmfdroDJLWwLPfcMojo/+ZnBAIDn0XWnYTjffNViyI3ASmDp1dcxffrnvPTSG9xzz4P87W9Xceqpp7Pffvu3W7oGg8Fg6LiYb/oMBoOhA7A0UcWVP7zGL7GVuHgILVCZAoKWLl43EDEooZEIBAK0RgrBsOK+XDpwLN2CrbPqjcFgMBgMBoPB56eff+Pl12byw4+LicaSWJbEdX2xQSyerBMqCCEQwpcbKAWWpRGi8eGdZUm89MpYmX5SCkIBh2TKRQpBIGiz6abd2GW/wfxQtZJbpk3DVYpukTAppUCAJf3JQo4lSSqBpzWxZIpIwMGWAplZGRFIeYqgDUHb8kvqPQVao7TGEgKtQQpBvy5dSHgu0WSKvfr34+Ctt2ST0pINzr7ekYmrhVS6H1LjzSSlVxJXvwISS3RFa/CIIggAmoRaiCKFRYF/3lC3Gr3AI4ZVV/ysEVhoPBRJZLq/j0STQuCskklD4UKKhoXUkhAetfhf02UmhFlIAmhSaFw8FCItZAiLjXGpwtO1SIIEZR8cWUoXazhd7N0IyG6t/0AaDIZ2wZZh+of2ZfPgaOYlxjM//i6VagEKD/BAaNANBJRrQcP+soEKRuNSq1cwK/Em8xNT6BvYhS3Dh9DFNgIXw3pGx5vLaljHLF68mJ49e3LnnXdy5ZVX8uuvv/LHP/6R7bffnnHjxrH11lvTtWtXgsHgao/dp0+fNsjYYDAYDNmYO3du3d9CCPbYY49WHb+4uLjR7ZoaIzAzdGBS+UgYVr0WZuisNFdwtyqqTsKQfXVhHQ6vUQ4qh4RBlJev0biG1UdUVeQlYSgpaX0JQ3FxCZdc8lf+8Y8rVqtfJNK8/CM5Zl/CTz7eYj+hNYHJ75I46vertb8Nlcg9dyJyfD4k9t0Pd9i2eY/50UcftrhtxoyPOeywA3j++VewHnyc0nGjEMlk1vEKr/47qd32wNt6aN45dDTEypWUHHUoctHCvOJrrr6e2OlnN2r77rtvueqqvzF1aktlZq3P/vsfuHYDSEnsnPNJjhxN8R9PxJ47J69uwXcnUHLCMVT+51lo4b2go+JMnZLzNZ1LRtNR2GKLgfTtuzG//rqoxZgJwN+babcW/IL99Ze4227fZvm1O0oRfuSBnGHR9HvH0KHDeOCBR7nssr9z333/4tlnnyKRSNC378YcccRRbZ1tVn73u2N46qnsq5MvW7aUfffdm3g8QTRay333/Yvvv/+Whx56nC5dStsp087J8OF70LNnL5YtW9pk20ApOVYp/tBCX+ebrwi++hKJw3/XpjlGbr6+SVsMyP0KgdNPP2uN9xsIBDjrrHNzHtfeABxAY32/M/Mzgi//j8SRR6/x/tcWsWIFxacc3+yx2y/AvXmMcfHFl+Z1rrk+EggEuP32f7XaeFpr/vKXP/HOO81pNxqz4447cdJJp7bavjsTe+yxJ1LKuusXzTEROLyZdllTTejZp4idcU6b5WfoOIiaarruOBSRSOQVH+q/Bf3TPwaDwWAwtDZGwmAwGAwbOPNqf+OGOe/wS2xlXamSlS6Sy6zZ2BwCkELi4a+QrNKRAemwe7f+/HWLsQQs8zFhMBgMBoPB0FqUldXw9oRveHfy96RSHq7rYVmZVbxBSoFS/pdCnqexLH8ivE5bF5TSSNlQuuALF6RMx2hQaASCVFrA0H/ARmy6U2++j5fz3A/fsiIaI+l6WEKwpLqGhOtiS4nW/qItmS8cLeGLGBKuR9ixCViSuOshAaU1nlLYUhKybdAuKaVIKY+UB65SOJZFNJWiZ1EhB+0ymL369zPyhXWM1pqYmkOt+hZXVVDjfU5CL0ZoByFsEnoxGoVA4uolaFwkQQQOQoCrXfzV4GNIIoi6smQJKBQJJA2L7iQaF1+c0MAAB4BACgelU2mhQ6ZHEA8X8Pz9pmUPkhCKGP4zPFU3RkhsjiKOq8vQQEB0AyHpao2kqzOCQjkEITr+qjMGQ2dDCIstQgcwIDiOJamZfBt9jmq1CKUT1CsTVn3fyZ9Ve/lXV8QqEZoE1fyUnMSC5Ef0DexE/+A+9A5ss0b7NBgMhvWd0aNHNzqez5ynfPHFF3zxxRdrPK4Qgu+//741UjQYDAbDapBZsVRrXwLar1+/Vh2/oKAAqF/xPRrNXkhsMGzQpHKt6QnayX+laUPHRog8JAzaX01Y5FptPBRaoxx0afYCOVne/KrWhtZHVlbmJWHo0qVLm+z/tNPO5L//fZbvvvsm7z6hFp53qb1HoB0na5Fy4L0JnULCIFauJPT0Eznjohf/Je8xy8vL+P77b7PG/PDD9xx00FheffVtnKuvo+iK7OOLRILiM0+hfMKUTldQD34xT8mxR2DPmZ1XfPTCPxM75/z629EoN954LQ89dF/d97jtwY477kSvXr1bZSxvq62pGD+ZogvOIfjma3n1CUyZTMnxR1P55H8hfczfGQi8Oz7rdi0EyVH7tFM26xYhBKNGjclarP8xUAUUN7Mt+NorHUrCEJj8Lva8uVljUttsh7vrbo3aNttsc2655Z9ccsnlPPzw/Wy6aT8CgXV7zjB8+B7suONOzJz5Wda4zPWEDO+/P4mxY0fyxBPPseWWQ9oyxU6NZVkceujhPPTQ/QBsvPEmHHbYkRx++JHsMnE8hTddl7V/wQ3/R+LAQ6CNnmf2pzMIvjexSfsz+CuTZ2Pfffdb62LZ448/mTvuuIWKiooWY6YBHwB7r9Je8H//ILnvfuji1hef5SSVovjMU7BaENv8Bciu1YIhQ7bioIMObfXUNkRSqRRXXPEXnnzy3zljLcvi1lvv2mDlFeua4uIStt9+R2bO/LTFmLegySyLDOFHHiR22plgmflchuwUXvon5GrIQr2NzeIpBoPBYGg7THWtwWAwbMAsiJZxw+y3+SW6Ei9dZqDxC+MEIl0okB2JxBL+XwFps3/PrTljsz0JSPMRYTAYDAaDwdAauK7HG29/xdQPZ7N8eaVvO0CnZQsK19VonZYqCIFKH8N5nsaS9V9H+HN4NJblixi0Bq38WEtKQiGbeMIlFHQoLAyyy6iBVJXAxHnzCdoWxaEQy2uihB0bmS6aSrgeKU9RS5KIE0AKgSUESmskgpTnEbRtApaFqzSu8gVemflEQgiElPQsiFAcCrK8uhbHthgzsD+7bbYJQ3v3xDZfWq0TtFbE9S94upq4+olK92MSehFau6T0SjRxfMFBEKU9NBqLMCBQxNGk0iXMNgIJeIBAp4ULfmyGjHAhmI6pPx/x/3bQJPGFDf6TRxBAkKL+azeBQCIJo/CLM3R6n6AIiF4IbFL6NzQeNsUgFGGxMV3tEym2d8QWYSRhpDCrCxoMnQEhJH0CO9Pb2Ykydw7fRJ9hhfsDHg0t+KsnY1j96bIKlxi/JD9kYXI6G9lbs2XoYHo522CZ6yqGdYhov7nfhk5GplgX6gtr27PYwGAwGAytQ1VVVaPbRUVFrTp+RrqQ+dwIBoM5ehgMGzCpXCURgGOuVRl88hIVp6/5E8susNFrWDStSrtm3S4qK8HzTDFEOyDykDBIKSkoKGyT/TuOw8MP/5tx40ZTVVWZV59wuPnnnS4sIrXb7gQ+mNJi38Dk9zrFcyv85OM5JSrJEaNwd9w57zE//nhaXufev/wyn2OOOZzXXn2bwPuTCE54J2u8PXsWhf+4gprb7sw7lw5BPE7xSX/A+TI/qWTsxFOpveIfdbenT/+Yiy46h59+mtdWGbbI/vsf1Krj6aJiqh57kvA9d1Fw3VWIPJ5ngQ+nUnLisVQ+8wJ0huN8zyM4/u2sIe4OO6K7d2+nhNY9I0eOziphcIHJQHMlwcHXX6H271en50ts+ITTBfHZiJ1+Vov3t0ePHvztb1e1dlprhBCC22+/m/32G0kiz9WmM8yf/zP77z+G++57mP33P7CNMjQcddTvUUpx2GG/Y6eddq4rHo9v2o/IPXcha6pb7Gv9Mp/QE48R/+NZrZ+Y1hRcf03TZuDOPLqfccY5a51CYWEhp556BnfccUvWuBtoKmGwliym4P+uav/jIa0p+vMFLR4/TwKez2OYv/3tKqwOfnydDwsXLuC8887k448/yiv+r3/9G0OHDmvjrDo2I0aMzCph+AX4DhjazDZr/s8E3p1Acr/92yo9QwdA/PYbwVdfyjte2zZqs83aLiGDwWAwdHrMTNA2xHVd/ve//zFhwgRmzZpFdXU1Xbt2Zcstt+SQQw7hgAMOWNcpGgyGDZg5Ncv5x6zX+C1RjYtqJF3w0I3sgZmSg0ybTv8oVDpeEJIWR/XZgRM22QVbmosyBoPBYDAYDGtLKuXx3Q+LePq/01m8pAKtNa6nCDgWnusfh0kp8Dz/GE4pjZR+m0pPtNSAJQVe5rYGKf0vwaWkTt4gpCCecCksDLLViM1Y7qR4Y8V8VvwSRQqBFILl1TW4ShOw64/1BP5YntLEUykiAYeAZRFz3bqjS9fzCNgWEccmlnJJeh4p5SFE/f6llMRdj0E9unHWHrvQv1v2iZyGtsPTUarcaZS7E4nrhXi6FleXAQKbUgQSTQqJv0KNJokmBgTqzhnq5QceEAci6TMNme7jNhC+6fSYCo2HxEGRBCwyZx6SAF4T4YKFFGE8XQs4aT2Df5ZiU4SkEJcyNK4vVtBBpHToYh9AkbUdYbkJUoQIit5IYS5vGQydGSEE3ZxBjCi+ikrvF+bFx/NL8n1cHU/rKjNXRSSkr4O0Dpn3QX98pVMsS33FstR3FMk+bBM5hr7BHbBFJ5iIajAYOhVGumAwGAwbPoWFjYs5a2trW3X8VVfGbKsVvA2G9YFsq74DaP+CbztlY1jfyWeVTaX8axciGssap8PhrNtb7FdamnW70BpRWYHu2m2Nxjfkj6jKLWEoLi5u09VZt9hiIE8++RzHH38M1dVVOePDWZ53yTFjs0oYZHk59uef4e686xrlukGQTBJ67OGcYdE//3W1hv344w/zjp0160eOO/4YXnzo3/T96kusZUuzxoefeIzkyNEkDzpktXLaYHFdis86LetztSHxQ4+g5ubb6wqolVL89a9/WicCBoADDji49QcVgtj5F+FttjnF556eUyICEPjgfYrPOZ2qhx7v8GIV+7NPkSt+yxqTHL1vO2WzfrDXXiOQUtYdszTHOzQvYbDm/4z17Td4w7Zps/zaC2vObF8wlAXVfSMShx3ZThmtPVtttTXXXHMDl13259XuW1tbw0knHctf/nIFF1/8F7O6fBuw7bbbs+222zdp1yVdiJ1xNgU5BAQFt95I4rDftbo0JvDm6wSmNT1WeQ/4NkffLbccwt57j2yVPE4//WweeOCeOjHoquwA/LGFvuEnHiNx+JGk9tirVXLJh8jN1xF67ulmt6WA8/MYY7fddmfffce1al4bErfccgOJRIKffprHhAlvk8pxfSbDyJGjueCCi9s4u47P6NFjueOOW7PGvEHzEgaAwIS3jYTBkBXn0xkI1807PjliFLqwdWXTBoPBYDA0xMxSz0FNTQ0PPfRQ3W0hBOecc07O1RqWLFnCGWecwdy5c4H6SWlLly5l2bJlTJkyhWeffZY77riDjTbaqO3ugMFg6JD8WL2UW+aOZ3m8GltIPFS6gE6itH+Bu+FUWN3gt40AIfC0IoCNh6LYiXDCxrtyeO9t81t9wWAwGAwGg8GQlQULV/LEc9P4ZcFKqqvjBAMWiYSLAFKuQilfmpURGHieQmtfxNDweCwjWMiIGbTWKOXP9bHTMgWlNF1KwmwxqCfuwDBfLv8NKyVIeR62FARtG6U1tckkntJEkxAJOAghsKTEVQopBCml8LTGkZKUELhKpUvi/aNJIQQBy0IKQWkkTFU8TtJTFAYDbN2rB6MH9meHjXsTtM2lhvbE1ZVUudOpcKeQ1EtJqF/RpLBFFyxdjMdSIIBE4lGFIg74q+81FLlBCk0cQZj6YmWAJFqH0rGqgXAh1UC44I/mCxkC6bFUXbvAQhJCEcWXM2Se4xIpQkAET8cBF4GFJYqQwiHAFhTIQRRZ22HLCCHZj5Ds3ZYPp8Fg2IARQtDF3owdC89kiDiIudGJ/BSbRFLXpN+T1qxouLHmsrmA9Lj+Bzsal0q1gA9q7iBUU8LQgiPoHxxBQBas0f4NhjXC1MgbWpnDDz98XadgMBgMhlaka1dfnpm5BvXbb9mLilaX7777rtHt0hwFvwbDBk2uSf6BQPvkYdggWC0JQyyHhCG0ZhIGVZpboCzLy/CMhKHNkZX5SBi6tHkew4fvwfjxk/nTn85jxoyPs8aGw5EWtyX3GQtX/y1r/8B7Ezq0hCH42stYS5e0uF0DU7ceyla77b5a455//sUUF5dw1123k0wmc8Z/9tknXHTtlTx670N0OepQRA6ZYtGfzqN8u+1RG2+yWnltcGhN4Z8vIPjW63mFJ0eOpvrehxpJBqSU/POf93DAAftkLUBvCSklG2+8KRtvvDEFBQWEQmGUUlRWVlBeXs78+T9TW1vTbN+BAwexxRYDV3ufAN999y09e/aie5bC2+TBh1LRqxclJ/4euXJlzjGDr79C4V+7UnPrP+skFR2R4Ntv5IxJjDuwHTJZfygt7cr22+/AzJmftRjzBnAfNPvtSui1l6ntABKG8MP354yJnXQq5Kg1WN845ZQ/MnXq+7yV53vlqkyd+j7nnXcRoVColTMzZCN27gWE//No1vdvWV5O4dV/o/qeB1tvx4kEhVf/vdlNd+bR/fTTz261+erdunXjpJNO4f77723Uvvuuu3HlDz+wX1Vl1m98i84/i/J3p7aLjC5yxy0UZCle/yfwfR7jXHnlNZ12vv+yZUu5445bVvt4rGfPXtx778NGFNMK7LjjTnTt2rWJjLchbwCXtbDN/vbrNsnL0HGwv/4i71hVXELt1de3YTYGg8FgMBgJQ04mT57MQw89VHeSstNOO+UUMMRiMU455RTmz59f17ZqEQ3AZ599xh//+EeefvrpJqtNGAwGQ0vMqlnG1bNe57dkDR4KpTPlTdpflYD69WWb+xrNQyN05m9F2HI4q99ejO0xpNNekDEYDAaDwWBoLZYuq2Ty1B95591vSKU8PE+BBtf1j9ukEAghUOnSd09pLOnPTdHa//EXR8tIF/xxpfSP0yxLorz0MaCnQEr6bdeLSP8iPvptGZVz4oRsm8JggJpkkoD0JwZJIbCERAmFqxSxVIqw4xCwLFyl6gpIk55H2LYJOw7RVApXKV8QYflyCFdruoRDFAUDOJZkmz69OHuPXSjcwCYPbMi4upJq7zOS6jei3ixq1dcILZAyTEotRxEDbFxdTpLlCCQW/sTI+iLkFAqJRSj9TJSAQJNEE4RGZxWgSSKw0STq8tAoJAEgmR4jLevAQhJIyx58AYPf7qR/bDRJFAqBxqI7kjCWSGKLIoqt7QnIHoRkX4qt7bHEmk0mNhgMnZsuzqbsVHIawwqP4uua/7IwPp2oWonGI/tVk8bkjGgwVP1c5sz7qiJOOTNrH+eb2ufpHxrJ1pHDCcmSNb1bBoPBsM648cYb13UKBoPBYGhFevbs2ej2N99802pje57HJ598ghCibl7E4MGDW218g2G9I4eEQdtOOyVi2BDIZz6GzkgY4jkkDOE1lDB0yS3GEeXlazS2YfUQVbklDCUl7XMdaYstBvLaa+8wadJEHnvsYaZMmdxssX84y/POGzgIb5NNsRYuaDEm8N67RC+7slVyXu/QmvBD92UNeQE45rtvOeDk47jhhlvo06dvXkP36NGDSy+9nP33P4jTTz+JefPm5uzz8ssvMnTotlx2wcVE7ro9a6ysrKD49JOoeOXtDa5YOG+0puDqvxN+9qm8wlM77kzl4083K1PaYYedOPfcC7n77n/mNdZWWw1l3LgDGDFiFNtssx0FBS3LerXWLFmymO+//5YZM6bz8ccf8fnnn+G6LgcccHBe+1uVRCLB6aefxIoVv/H3v1/D8cef1GLhobvzrlS8Np6SIw7CWrY059jhJx5D9exJ9NLL1yi39R6tCbQgYagCigFvk03xhg5r17TWB0aMGJ1VwrAI+BLYvpltwZdeoPbyK/1JERsooqKc0PPPZo3RjkPs5D+2U0athxCCe+55kD/8YSXTp09brb677jqcZ555wQgY1gG6qJjoxX+h8G9/zRoXev5Z4r8/jtSee7fKfiP33421YH6T9lnAmzn6lpaWcuSRR7dKHhnOO+9CHnnkIVKpFPvttz/nn38xu+yyK6Gn/oO4+Pysfa1FCyk69wyqnn6h7d6ftCZy+80U3HJDiyE/Av/IY6hDDz2CnTuw3CwX//vf86stYCgqKubpp583i+e2EpZlMWbMWF544bkWYz4GVgDNacBENNpWqRk6AqkU9tdf5RWa2GcstX+7Gm/wlm2clMFgMBg6O0bCkIP33nsPSK8+KgS///3vc/a5++67mT9/frPiBaj/Uk1rzezZs7nhhhu44YaWT6gMBoMhw7dVv3LTnPH8lqhBInABOz2Jqb7syadhSYEEhJAonf7CHoEUgu5OIX/eYl92Kd2sne+JwWAwGAwGQ8dCKcVb47/m3fe/Z2VZLZ7n4TgWrushhcB1FVqDQiNpIFkAVPp8M3PeqJTGsqR/jKf925mjO8uSoCEUtCntW0RqixC/6hSJst+ojMdxLAtPa36riZLyPLQNIWkjqF+ERApBylM4lsKWAksIvLQBwvMU2H5MgeNQk0xhW5KE59Xla0lJj6JCxgwawF79++E0WAHG0Pp4uoakWoarK6hwP6DG+xpNFJcaPF0BSAQ2QjkoYkgiCEDhAXE0HooUEgdQ+GcJGeHCqpPHdFq4YKFxqT+j8JAijNJJGp511AsXEjQULkhCaNz0OUoKjUTjYlGEI7rjUoHSSQL0JiD7Erb60dXek4gcZMRwBoOhVQlaxexccjpbh45jbuwt5sUnENW/pd8jM7SsWtDp98wWNtYLGNJN9WoHhX81xn9nTVDND/E3mRufRB9ne3YoPJ4Cy0zwMBgMBoPBYDCsG4YNG0Y4HCYej6O15qOPPqK2tjZrQVi+vPXWW6xYsaLu/H7jjTemV69eaz2uwbC+InJIGHDMtCxDPfmstpkpJBGx7BIGwpHV3v+MGdOZ8+XnJIGVDX7K0r/3Ae4CZHnLK1kaWg9Ruf5IGMCfzzhmzFjGjBlLLBZj3ry5VFVVEotFiUZjxGLRrBIGhCA5Zl/C/360xRDnqy8Qy5ahVxFCdQTsGdNxvmx5pc5K4ELLAs/jrbdeZ8qUyVx22d847bQzse38PiuGDh3GG29M5Nhjj+DLLPvKcN11V7H1k//liB13wslSLA3gzPyMwisvo+aW/MQCGxrhf91B5P6784p1h2xF5TMvQJZj40svvZwJE95m1qwfm90eCAQ45pjjOPnk0xg2bJu88xRC0KdPX/r06cs+++wHQGVlBe+9N5Ftttku73Eacv/9dzN37hwALrnkQp555gluvfVOhg3bttl4b+AgKl99i5IjDsZa/GvO8QtuvRFv4CAShx25Rvmtz1izZ2H//FOz24YDSWBUURG7v/UGe+65FyUlXdozvXXKvvvuxx133JI15nWalzBYCxfgfDKd1G67t0lu7UHo6SdzFo8mDj1ig/28Kyws5NlnX+SCC87m9ddfyavPCSeczA033JpzkUtD2xE78VTCD97frBShIUUXnUv5pA/RxWt3nGnN+pHIbTc1u+2uPPqfdNJpRCKrf06Tjb59+3L77Xeyww47MnToMJJJ//vg+B9OIPji8wQ++iBr/+B7E4ncfB3Ry/PRIKwmrkvhZZcQfuKxFkM84FRosDRK80QiEa65pvOu+K615vnnn1mtPuFwmKeffn6Nj6cMzTN27LisEgYFvAMc38w2EY+3VVqGDRh7+scU3HYTzrQPEK6bM77iuZdIjd6nHTIzGAwGg8FIGHLy+eef1xXDWJbF3ntnt/+Vl5fz7LPPNhEwDBkyhP79+7N8+XJmzpxZJ3XQWvPKK69w4oknsuWWxr5kMBhaZlb1Um6eO4HF8Up0g3IBTysEAp0uDVhVxAD+iayttS9fwF99ubtTwJ8H7svOXTZrz7thMBgMBoPB0KFIJl2+/f5XXn59JvN+/g0A1/XS53v+EZuQIl3HrutFDI3OGX2RuhQClRYvgC9q0BoCAYtk0h/TU4pQ9xADh2/CNzUriMVq2KiwgHjKxRISx0oXfCqNqzySnodGE3YcApZFylN1S3WnXA8n4BB2bKIpF4VGNRAIKiBoWwzcqBtl0RhJ12PUwM0ZPWgAW3TvirUBr06xIRBTP1GRep8qbxquriSlV6JJIinAphSPWiThtDDBw6Mq3dPFv9yTOWMQKGJpQULDMmGFIolA8v/s3Xd8FEXjx/HPzO619NCRKk1UUBAVQRQREMHGDzsqYu/tsfdeUVERe++oFAs27AUrIiBgQxBQOqRe3d35/bF3KZDcXSAJCcz7eeVJbmd2dnLEu73dme+o8ug2FBaSABvf2hVIJJ4KgQvuv78kgMKOhz1YyHjggsSPjzbEWIdFMRIfHtEEU+bQwjiCXLM/Ptk4B55omtb4mMJH94z/o2vgUFZGf2Ze8GVKnBXYxHBf/xIhNe7rpBsik+R9LhHAQFUBDGx0fab86kyMUv6JfcO/G2bRytODPTJPJsdsXSu/o6ZpmqZpmqaly+Px0LdvXz7//HMAQqEQr776KqefvmWrdJaUlDBhwoSycRBCCPr161cLPda0BixVCIPpqZ9+aI1COiEMOPHrCKHkE/vUZqww/PTTjzFt2pRqy3eMfxcbNtS4ba3mZBohDDlbODlucwUCAXpsxsru0cEHJQ1hAPB+9jGR407Y3K41WBlPPJK0/HpgpV0eDFtaWsL111/NG29M4t57H6BXrz3SOk7Tpk2ZMuVdjj76iKSr0IM7ZvWs886k0zMv0ufk0ciS4qT1A889TWyPPbe5fx//88+QdfvNadV1OnSk8PVpqPwmydv0+3nwwUcYMWJIpVWYDcPgpJPGcumlV9KyZe0EkeXm5jFq1NGbte/Spf8wfvy4Stt+/nkWBx10AJdccjmXXHI5Hs+m5yp2py4UvPU+eaMOxVi2NOVxsi88B7vjjlhp/h03Fr73361y+7/AgvjPfy2Yz5OnnIBhGPTu3YeBAwcxcOCB9OmzZ5XP7baid+8+NG/egjVrVldb522qX83d98ZrjTeEwbIIPPNEymqhM8+ph87UnczMTJ566nmmTn2Tu+66jSVLFldZr1ev3lx77U0MHDionnuobcLno+Tm28k9Jfn7uLH0H7KuuITiR58uX8mlpiyL7IvOQUSjmxStB55PsbtpmpxyypZdg6rOmDFjN90oJcX3PUSTQf1Tht1ljr8X1aw5oTNq779hsXYtOeechveLz5LWGwd8m0Z7//vfFeywQ5ta6VtjNG/eHBYuXJC6YlxmZhbPPvsS+zTW950GbNCgwZimiZVksvw0qg5hoIrXD23bIQoLMP78A4TA2r03pBE86Pl0Brknj0ZEkkfR/AYYQOs+e+kABk3TNK1e6RCGJFatWsXq1asRwp2w3KNHD7Kzs5Pu89577xEKhcoGFpimyV133cWhhx5aVmf+/PmceeaZrF/vJocrpXjzzTe57rrr6vT30TSt8fqjZBXX//4266OlODjI+HB+hTtNoOIkgYoD/WVZOdgVpla18OVwXbcR7JKtB/prmqZpmqZtrtVrinnmxS9Z/M9aigpDmB6jfJUqAbbtoJT7XUqBEG7+gYqftJWFLuCev0lDoBJBDY5CKYWUEsdRGIYk0DoDo0OASAC+XLOciGVhSklpJErUtvGaRlnf3HulAgHEbAdT2nikxJACy3HDuyzHwVFgSEmGx0NpLAoKwpaFFIKYbZPh9VAYCtMiK4uje/egX8d29f48bw+UUoSdvym0viToLCDq/EdErYwHF7TAViEUNoIMFDGiLEfhABUH77hn+w4hJBVX56kYuCDiW0Q8ws1CEKDypwiFwEDgQRFDVJhpLEUAR9m4QQ8iXttBYOIVLbFVOB4GITBpipIxskRPmpgHkmX0QgofBgGEMNA0TdsaDOGhja8vrb17si72BwtCk1ltzcHBgrJ4Sxl/jU1D/KVz41DMVDtZhFge+4kVBXNp7enNHpknkGPuUNNfR9M0TdM0TdM228iRI/n888/LxjVMnDiRAw44gC5dumxWe7FYjMsuu4ylS5dWWrDixBOrHGaradsOK3kIg/J666kjWmMg0pjk5CTCnVMMOleBQI2Pn59iUvG6+He5YX2N29ZqKBZDBEtThjDk5m6dEIbNFR2wP8rrrXJCXoL3kxnb3CR/ufQfvO+9U235n0B1EQ1z5/7CsGGDOPXUM7jmmhvIzs5JebysrGxefvkNDj/8YP744/ekdQsLCxh7/dV8esc9tLww9WTC7Csuwd5lV6xtZJVg37TJZF1xSVp1nZYtKZ32Dk6a4Ql77LEn559/MQ89dH/8cR8eeOARunffebP7W9uuu+5KQlVMNrVtm3vvvYsZMz5k4sQn6NZtp03qOB06UvjGNPIOHYZcuybpcUQ4TM6Y4yn46HOcVtvOWERvNSEMM6rYZts2P/30Az/99AP33Xc3b775Nvvvf0Cd9m9rklJy0EEH8/LLL1RbZxZuYEVV04R9b02l5PZ7YDNCpbY235uTUoaTxPbqu02EkgghGDXqaEaOPJIffviO776byX///YthGHTsuCMDBgxk1117bO1uahVERxxK5KCD8X30QdJ6/ilvEtt3f8Injd2s42Tcfw+en2dVWfYkkDxODo44YhStW9fvfVGnU2dKr7yOrJuuTVk369orQSlCZ567xcf1fPUF2eefhbHiv6T1vgPSmUXUuXMXzjrrvC3uV2P2+uuvpl23c+cuPP/8q1We62hbLicnl3799uWrr76ots57QClUGsUGICLhuuyatrUoRcb99xCY+FBZCKDdth0lN99B9LAjku6XdeO1Ka+FAVxI/Hx81o+06NGVdu3a0bZte9q2bUfbtu3Yc8+92H333rXy62iapmlaRXrZyiSWLVtW6XG3bt1S7vPee+8BlK3scMwxx1QKYADYddddue2228rqKKX44IPkH3g1Tdt+/VGyijv/eJ910RJkYtqUqP4GfcVB/yI+fUoi8AoTj5DsmNmcm3Y6VAcwaJqmaZqmbabVa4qY+vYsrrnpTebMW0ZRUQjbcYjFLCwrEcIgys7XEsELFc/fHEeVBTMk6iT285gGXq+BEALTlBhegx32bEmkm59whsDnNXGUQ4bXg99jYkrpTuKPWYRibrq0Id3YrsRX1LJBCPymWTZR1A2AUPH6Ao+UtMrJpnlmBgJBls/HgE4dOW+/fbjzsKE6gKEWuaEL/7Ah9hFroq+xKHQ+i8NXssH6gLDzN2G1FLBwCBJRf+OwAYEPiUTiQWHjBisEcf8VEyu4C1Q8cCFBlP0VxHCzoEX8313E95MITMrj29w/SgN/PKxBUZbhqRQSE4McQGITxCGIwItQHjwin3zzADr4LqdT4Do6+26hs/82mngG45VNMUWWDmDQNK1BkMKguXdnBuZex+CcO9nROwxBJm4AQyLCEhKvidWpLnghvUAGhU2E5bHveLfgcmYWPUbQ1pMctFqi6vlL0zRN07RG5+CDD2aXXXYB3OtRoVCIsWPHMnfu3Bq3tXTpUk488US++OKLsvEPQggOOOCAtMZYaFpjJqLJQxjSWelN236kFcLguB+yUoYw+Hw1Pn66IQxChzDUOVFUBJAyhCEnp3GFMJCZSazfvkmreL/4FGy7njpUPwJPPY5wqg91vQ5I9hsrpZg2bTKxWIr3lAqaNGnKa69NoVmz5inrLljwK//7bibhY0enrCvCYXJOOg6ZYqJgY+D9+EOyzzsToVJfvFK5eZROfgtnx041OsZll13Fbrv14vrrb+Hdd2c0qACGDz54jw8+eC9pnTlzZjNkyH68+upLVZbbnbpQOGkKThrhIMbKFeSccuI2s6qxXPEfntk/V1lWVQhDRX6/n7333qf2O9XADBs2ImWdqmMsQBYV4p3xYe12qD7EYmSOuzNltdCZqUNvGhMpJfvs05+LL76Me+4Zz5133stZZ52nAxgaIiEoufNeVEZGyqpZV/4Pz+ef1vgQ3g/eI/Peu6osiwAPptHG2WdvnRCB0NnnER00OK26WdddRdZVl0IaE4KrItasIeuS88k78rCUAQwbgONJfr4I7ufJ8eMn4tuMz4LbilgsxpQpb6RV9+ijj+PDDz/TAQx1bOjQYUnLQ8D0qgoi28Y5o1ZZ4OEHybz79rIABgBj+TJyzjoFz5efV7ufOXsW5u+/pXWMfyr8vHr1KmbN+om33prCxIkPcvXVlzF5cnqvEZqmaZpWU/puXxL//vsvUB6o0KlT8ouswWCQOXPmlA0sADj55JOrrDto0CA6derE4sWLAVi3bh3//fcfO+ygVzzTNK3cP8F13PDb26yNluDEJ1e5Y5vjN96hbF3axC2jij/b8TUcAWzl0CaQxw3dDqF9RvKb65qmaZqmadqmlFJ8/e2fTHl7FgUFQcKRGH6fSShslZ1zJQZIJj5HJs7MHEdhxEMXlIrPV1MKQ0psxwGlsO34vihilkLmmPg6ZVOao/glvAFRAl7TDWdwlELGB2xKKUAIJG7YgkTgMw1MKYk5DlIIbKWwHQdTSjK8HoLRGAqI2TbCMMra85nuzz13aMn5++1Du/xGNsCvAbNUIY4KEXL+pCD2GSH1O0pZxNRqFFEEJpJMbIIIPEjcVfJsSgALCKMIUB6WYKCwcYjEQxSIhyYkAhfcldDKAxcUEonAQGFRMZdT4sfGBmwE3rKtEi8ONgqFpcKAjcSLVzRDYaOwyZBdyJQ98cgcsozd8Esd1qFpWuPSxNOFvT1d6G4dyh/hj/gn8hVRiuOBN6lVvA5TeWv6HMIsin7MP9Hv2S1jFDsFDsIU2+8AGk3TNE3TNK1+XHPNNYwdOxbbthFCsHbtWo4//nhGjhzJ0UcfTY8e1U+oWLt2LT/++CMzZszgo48+wrbtCtfDIDMzk6uuuqq+fhVN22pen/MLbwNewBP/qvhzq9ISqh41pG2vJOVXeKuiEhO5IxFG4l4Zzoh/BSr8bM6by/6/zqNHj55pHzs/Pz9peSJ6QW7YkHab2uYRRYVA6hCG3NzGd48mOGgwn3/xGZNxJ+FtvMa5LCjAnDdnm1ghHECUFONPshL8j8DrabRz44230aRJ0xodu23bdjzzzIuMGnUolmUlrfvKKy+y9933c97cXzAXLkha11jxHzknHUfBW+9D5sZr1jYOni8/J+eUExFpBFuoQIDSSW/i1OD1NMHv9/Phh59hGA0rgDwYDHLttVekVTccDnPRRefy3XczufPOe8nYaOKu1XN3il58jdxj/y9lQJBn1o9k3nojpbemnqTe0HmrCbBwgI9T7Nuv3774/Ru/+m179t//APx+P+Fw9StZvw2cVU2Z/81JyVdEboC8X3yKsWxp0jrfNWtOp+GH1vAukabVHqdde0qvuJasm65NWk9YFjmnnkTh5LexevdJq21j3lyyzz2j2vLngRUp2ujbt9/WW6FcSooeeYr8Ifth/Ls8ZfXAM0/i+eYrSsY9QGyf/mkdQqxaReDZJ8h47BFEsDRlfQs4FliSRtunnXYm++zTL61+bKs++WQGa9euTVrngAMO5H//u3K7f67qy4gRh3HDDdckrfMGcMxG20Sk+vMHrZGKRskYP67KImFZZDw0nsL9D6iy3Pz5p7QOoYDkZ2LQrp0et6hpmqbVDR3CkERRPHU6IdWNjdmzZ2NZVtnAgm7dutGhQ4dq6/fv35+///677PHvv/+uQxg0TSuzqHQNt/0xnbXREiQCm/jatomgl/iCtkJtGsRgIHBQCASGEAgE3TJbcEP3Q2npS51OrWmapmmappVTSjH31+V8+MmvzJm3DKUUtu2gFIRCMWxHIaVAiETIghuoYBgg44EJ4J6rSSmxbSferrtVCIHfZ2LbDo6j8PpMYm08OK19xPwm4XAEQwq88bCEkmgUpRRSSHymgQBkPNxBCojYFl7DwGcaWFGnLCQw0Q9TSvweE9tR+AyDiG1j2Q5Zfh9t8nIY3LUze3doS5bPu+mTodWIo2KU2rMpsD4l6CzEUhuw1AYEBh7RElsFAQdJFuBgU4QihsCPKgtUs3GH5kZRSASeeOvxDwTEcC/viAqBCw4SgcCMTyIu/7TgBi6U4gYueBDxdiR+HELx6LfyxHGf6IgjotiqGDAIGB0waUqusTe5xj54pA540zRt25BjtmXPrFPZLeNY5ocmsyzyHUG1BgebTa+8pFKz4XWJM4UoRfwUfIFF4S/ol3Umzb161WBtM6X7p6ppmqZp2nZtzz335Prrr+fGG2+MX9cS2LbNlClTmDJlCqbpDidRFVYPHjBgAEVFRZVWak6UJ+5hCiG48847k46V0LRtxfxVK5mcpLxHcbEOYdAqSXXFIBHCICJhPsJdNbJK33/Lg/Pm1DCEIfm13A24k0vFhvVJ62lbTm5jIQxKKX766QemTHmDt6e8yZr49mHAqCrqe778fJsJYfC99jKyuKja8qvTaKN//wEce+zozTr+Pvv05/bb7+HKK/+Xsu5VN15D7yefY8C5ZybtM4Bn7i/knHM6Rc++BA0sYCAV87tvyR1zXMrAAADl8RB88RXsLZik19ACGADefnsqy1JMFN/Yq6++xJw5v/D886/QoUPHSmWx/gMofmAiOeecnrKdjMcnEtunP9FDDqvR8Rsa3zvTqtw+F1idYt+BAw+s7e40SBkZGey//wF89NEH1db5BCgFqopz8X78IWL9OlQNA2i2Js8Xnyctnw/0W7uGnQYP4IwzzuGoo47dJNhE0+pD6Ozz8H7yEeqrL0gW+S5LiskddRhFL75GbMD+Sds0580h98jDKq1uXpEF3J1G384667w0atUd1bQpRU89T97IEWmdK5i//0be4QcT7T+A8HEnEB00BNWyZYUGFXLZUjzfzcT33rt4Z3yQVghUwrXAjDTqtW/fkWuuuTHtdrdVe+yxJ/fcM54ff/yef/5ZQklJCRkZGbRv34E99ujDwQcfQvv2+npkfUo89z//PKvaOtPZ9HxAWBbYdqP7rKFVz/x5VrXvEQCeb76EYBCqODfyzP45rWOsBlLFd7Rrp18DNE3TtLqhQxiSCIUq38rKTJHs+8svvwDlK54OHDgwaf3OnTtXerxmzZpqamqatr35N7SBO/58j2WhDdgVhvsnghUqjaOuEMQA5d9FfDoVCHbMaMY13UboAAZN0zRN07QaCoYiPP/yTOb8upSSkghKOXg8bmCCrDBa0nEUQrghCLaquE2UnaAp5YY1GFLgOApQOPEyy3KwDIXZxk+0jY9CFSNDKgJCEI5ZeKWBFKLsywbC8VVtfKaBxzCIWBYSiaMUMcfGaxgEPCahmIVSyj1m/N6FoxQtsjLJ8noojETYuWULTunbmzZ5uUih12XYXEpZBJ0FFFs/EFH/EbR/xVbFSLKQwoelikhciomqFSiiSALx83YZb0WgiCAwoFLgArhBDB7KJwInAhdAYKCwEciyybwSXzxwIdGGQCARBFDx7QobhQRsvLRECD8xtRpFDEk+CEm2uQvNvEPI9eyJIQJEo+mtDq9pmtYYeWUmvTPHsFvG8fwd+YTfQ+9R4qzEIbGaXOUwho3nuqsaBDBsvK/bssMGZwkfFt3Erv4j2D3jaKSUVeytaZq25caMGVPpsRCC559/PmW92lLd8TRN07T6c+yxx1JYWMgDDzxQNs4hEaoQ22jQuFKqytXmEotUKKUwTZNrr72WoUOH1n3nNa0BsKzkkyu8+vOcthH3Smz1nHgIA6FQ9QEMcTVdZbtJk+QhDA5uKEDWhg01alerOVFYiCJ1CENOTsMOYViwYD5TprzBtGmTWbr0n03KX6XqEAbvF58TujB1aECDZ9tkPPFotcXf4E5ATuWWW+4oO5/aHGPHnsavv87lxRefS1ovHA4z9oZr+Pye8bQ/57SU7fo+mE7WVZdRcs/90EjuHZqzZ5E7+ihEMJiyrhKC4olPoIYcRFFRETk5286YumOPHU1OTi7XXnsF/6ax0nfCggW/Mnz4gTz//KvstVffSmWRI4+h9PffyHzg3pTtZF90Lht22RVnx0417ntDIFetxPPNV1WWpTNRduDAQbXboQZs2LARSUMYIrjP2cgqykQshu+tqYRPSR3u0VB4fvg2afl4fwDCIX7//Tcuu+wibr/9JsaMOZVTTz2D1q31Ao1a/Vmzbh23dunKpK+/5FelaJ6kriwtIfeYkZReeS2h8y+uckK0b8obZF12cdLJtZOAv6stdbVv35Hhww9J51eoU1afvSh6/FlyTj0Rkfj8lYJ35td4Z34NgNO0KU5ePjgOcs2apM9LKiMzMnnB52NlkiA8wzB49NEnycrK2uzjbCtatGjB2LGnMXZs6nNZrf4cdtj/VRvCkId7HlBEFaFMkUiVE/K1xsn75WdJy4VtYyxfht1tp03KzF/SC2FYkkadtm3bpdWWpmmaptWUDmFIwtnog5VlWdXUdM2dO7fS4z59+iStn0irTlxELykpqWkXNU3bBv0XLuCG399haWg9djx0AUDF17VVqIpzrlwCpHIfOPGaCjCFQbesltza/XCaeJMHyWiapmmapmnlSksjfDXzD977cC5r1hUjhSBm2fEVAWM4jsIw3BUCE0kKjuOGLCRO1ZQCKcEwJLbtoFR5WIOQgoDfQyRqYXgMQq0MnOYmZHhZHwphSEFxJMqGUAjbcRAeD954goIUAic+KD5iWZhS4jEkUSu+HYjZDl7DDWcQQhCMxnCUImxZOI57rugohd/rZUSP7gzfuSsenS5dY0opws7fWGoDIecvCq0vsJwNIBxiah2KMGDiEEYpGzcqwV1rwCaMO9U2HA9GMFE4uMNw3e2y0mUb9y9L4GwSuKBwEHhRBONtJPYwkfhxCOFeAkrEtCkEmUiysSkALCR+BD6k8NDUOIQcox9+oyNS+MnwNt2iAYCapmmNkSE8dPUfTGffUFbFfmVO8CUK7WXYRN1Bx/H33IpBCioeeJOOjQMYoHK8g02UueHJrIotYHDuVXhkYIt+H237ot+1tXT98MMPlSbOVnfOV7FebUl2PE3TNK1+nXnmmfTs2ZPLL7+ctWvXbtbrs1KK/Px87r//fvr12/yVhDWtsYlGk4cweHQIg7YRGb+mUB2l3Ou74TRWZQ0EajZZIT8/eQgDwDogW4cw1DlRWEgpyQM5AHJz8+qhN5vvvPPOZP78edWWv487AXfjFZg9P3wLoRAEGvf1Lu+MDzGWLK62/PY02vi//zuS3XbrtUX9EEJwxx3jmDdvDr/8Mjtp3cWL/+bcd9/itYsuJevB+1K2HXj+aVRWFqU33NLggxjM2bPIPfb/0p4IWXL3/URGHskn77/Hueeexcsvv0b//vvWcS/rhxCCESMOZeDAQYwfP45HHnko5djnhLVr1zJq1KE8+OAjjBp1dKWy4FXXYf62EN8H05O2IYsKyTnzFAqmzwCvd7N/j63F99YURDXv1dXHDbiaN2/BLrvsWvudaqAOOujglHWmUXUIA4D/5RcaTwhDaSnmvLnVFq8FXo5FK23bsGEDDz54HxMnPsjhh4/krLPOo3fv5PMKNG1LrFq1ikceeYjnn3+aYDyQ6F7g7hT7Ccsi6/ab8b85ieB5FxEbNBjl92PO+YXA00/ge//dpPtbwK1p9O+CCy7GaCDjkqIjDqV4/MPkXHRujfeV69Yh163b4j7Y7Tuw04uT+Cg/n5NPPp7Z1awEf/XV128SjqRpDclhhx3BzTdfV/Y4JyeXQ/fowwmff8oQoLqzQREJo3QIwzZDhFJFiYI5bw7e99/F+8kMVNNmxPbeh/BxozH++jOtY2wa/bipdu10CIOmaZpWN3QIQxKZmZUnLBcVFVVbVynF7Nmzy1aGEEKwxx57JG1/4w+S0Wi0mpqapm0v1kSKueevD/knuJbE9D0FyKqGTlccmS8AoTCQoMAUEoWiR/YOXNXtYB3AoGmapmmaVgN/LlrFsy9+zeo1RZQGI5iGO9FdCOHOuawUugBSCjfYQJUHMdgV6hiGQMr4Z8XEfkIQiVlYWRKrix/HL2iVm01hOIwhBX7T/bgethSW4xCKWTgK/KaBR0osxwHlnivGbBu/18TvMQnHLJRSOKriRHzwe0x2bJLP+mCIiGXRt0M7DuzWid3btMJn6ksDNeWoGEX2NxTEZhBWi7FVKZZyb7IaZCOUiSKGJMv9NyeGIgIYKLwIJJQFLhAPXKh4zp442bdxL91YJMIZqBS4UD4ASOJB4Y0fR0I8tEPgQWAj8eAQjrcp8NAMKXx4yCYgu5Bj7oMhsgnITnhlq0q/r54cp2na9kwKg9be3Wnl2Y0C6x/mhV5nRWw2Nu5kCPeVeOO0zOSqn2qxMYdV9nzeK7iWYXk34ZfbzmpsmqZpmqZpWsPSr18/PvzwQ1599VVeeOEFVq9eXVZW1XUBVWFSUnZ2NieffDJjx47Vq/Jp252YnXxCow5h0DaW6spBYsGgUDj14PVADSew5+fnp6yzHuiUZBVWrXbIokIK0qiXWOCpoRo16uikIQylwJfA0I22i0gEzw/fEWvkq8UHHp9Ybdks3BCKZEzT5Kqrrq+Vvvh8Pp566gWGDNmPgoKCpHWnT3+b8TfdzhUHH5JyMj1AxsQHUVlZBC+9slb6Whc8380kZ/TRaQcwlF59PeGxp/HFF58xduyJRCIRjjzyCF5++TUGDGjcf5cVZWZmct11N3HooYdz/vln8ccfv6e1XyQS4eyzT2PFihWcd96F5QVSUvTIk+QPPxDz99+StuGZM5uM++4iePUNW/IrbBW+qZOr3F4EfJVi34EDB21X91VbtmxF7957VDtxGOBtIAZ4qijzzP0F85efsXolH2vfEHhmz0IkCTN5AgjbVccrWZbFlClv4vP5dQiDVidWrVrJww8/wPPPP0M4HK5UNsHj4YJYjLZptGP+/hs5F55T4+O/AKR6h2nZshXHHju6xm3XpcjxJ1JkWUy77CKKlOL8+jz2wSMofuhRVF4+rYC33vqASy+9kDfeeK1SvYEDB3H++RfXY880rebat+/AAQccSMuWrTj88JEMHHggmbN+JO/zT5PuJ6LRGoyb0Bo65ds4fnFTOedUDt/yTX+brBuvSfsYqUIYsrNzGnyYpaZpmtZ46ZkWSeTkuINaExfFlixZUm3defPmUVRUVFZ3xx13JDs7O2n7iVCHRGiD3++vhV5rmtZYlVgRbv79XX4vXYWN2mj1w/KPmZVWWUxcs1fuNiu+6q1S0C2rJTfsdAj5OoBB0zRN0zQtLf8sXceMz+bz9bd/EolaCMCyFY6y3YWplLvIi5ASbKcsdKHiQArlJmhVCmZIjEk3DYnX6yFox7Cam0SaGNgZkqgTw7AkS9ZvIGY7eIzygbki/j8pBBHLwhACj5SE3e4giYcwKBOv6U66D8ViKAVR20YKQdS2yfZ5KYnGyM8IcOwePRnYueN2NQBkSzkqQon9MwXWZ0ScJUSc5TgEMcjBpAk2KxF4ERjYhFGEcEMQEhNyE6EYDg7BeOBCeaKawgYsBAaqLHDBQWEh8eKQGNDh/iG6gQtu0IP7V+L+zRgEsLDibUZxEICNQS6myMWmBJQi09gZn2yHX+5IjtkPj0g9+FbTNG17J4Qg39OR/T1XUGKv4vfgh/wV+RiHEO7rfN29rxY4S/mw4CZG5N+BR+hryFoa9IgVrQYqTqJVSVfk1X9YmqZp27rMzExOP/10Tj75ZGbPns0PP/zA7NmzWblyJQUFBRQWFuL3+8nPz6dp06bsvvvu9O/fn7333rvGE4E1bVsRS7GqtCkbxiqfWsORKpYjcd4dCkdSthUI1GzFyPz8JinrrAPEhg01alerOVGYXghDTk7DDmE44oj/49Zbk0+wns6mIQwA3i8/b9QhDMa8uXi/qX469u1ptHHCCSez446daq1P7dt34OGHH+fEE49NWfeW226k96uTGfbvcjzz5qSsn3n37WDbBC+/2r1Z2oB4Pv+U3JOPT2vlVYDghf8jePFlfP/9d5x88vFEIu7rbSgU4rjjjubJJ59n+PBD6rLL9a5Xrz2YMeNL7rjjZh5//JG097v55usoLi7iyiuvLb+vnJVF0dMvkn/QQER8lfXqZDx4P9HBw7D2bjyrd8t/luCZ9WOVZR/jhgkkM2jQ4FrvU0M3bNiIpCEMG4DPgIOqKfe/8CwljSGE4ftvqy2LAtXH8pQ744yaT27XtFSeeuoxbr75+rL3s42FYjGu6tKVl9JcZbymwsBNadQ799wLG9w8mVWrVnH5jA/4QCkMoAdwQB0fU2VkUHrtjYROP7vSOZXf7+fhhx9n1117csst1+M4Du3bd+Txx59B6nBHrRF4/fVplR6nMyGfjUJjtMYt1WeD2pAqhKFt23Z13gdN0zRt+6VDGJLo3Llz2c9KKX744Ydq63700UdlPwsh6NMndVrlxqnDelUITdt+FcVC3PPXh/xeshKJu9JyYt1aZ6NR0xsPdTUQKOFuNxGAYPecNlzdbYQOYNA0TdM0TUuDbTt8+PGvvPvhXILBCOGIhd9nEo7EkFK4IVhKoQBHgRQKISgLWBCiPHQhQUqBUiAlKMeJT50XlBIj2MmDv4mfJhleVpcECXhMpJTEbBvLcbAcdyKnzzQwZPymW3zgZcS28BhefIZBqMJKCm6/wGsaOI4iy+fDVjal0RiGkOzYtAnDundl7w5tyQs0rBubDZFSFkHnV6LOciLOPxTaX+OoKAIflirAphiBiU0RFutRKAwyE5EZuH8tNg4hJAHKwxhkWeCCO9zWitcHhxgCTzxYAdwgBQeJSSKUgfj5PoAkww1VwMHBQQKKKAYBvLQhxlpsSjAI4BFN8MnW5HuGkmP0xRD6+oOmadqWyDJa0id7DDtnHMLf4S/4PfQeIQpIZ+Z7shrJygqcpXxd9DCDci+rYW81TdOq99tvyVctrGk9TdM0bdvg8XjYe++92Xvvvbd2VzStwbOsqle7TfAaOoRBq0wkbi5Uw3HcQN9gNJ0Qhppd68/NzUMIkTRgbR24K8lHo+D11qh9LX2iqCCtEIbc3IYdwtC+fQe6d9+Z335bWG2d6cADVWz3fPEZXH9zXXWtzmU8+Wi1ZX8C01Lsb5omF154SW12CYCDDhrORRddyoMP3pe0nmVZnHHB2Xz2ypt0PeFojBX/pWw78967EAUbKL3tbvcGaAPgm/QK2f+7ABFLNTXeFTzjbEqvvZE5c39h9OijCG40USgajXLqqScyceITjBp1dF10easJBALceutd7LffQM4//6xNxi5X5/7776G4uIhbb72rbBKo3W0nisc9QM55ZybdVzgOOeedwYbPvkFlJV/QrqHwvTW12rL3UuwrhODAA6uKndm2jRhxGHfddVvSOm+SJIRhypuU3nw7Kjun1vtWm5KFMLwJpHoV3Xff/ejRo2et9knTADp23LHaAIaEl//6k3MOHMq+n86o9eM/CixLUSc/P5+TThpb68feXEoppk2bzFVXXcqGeACdDRxtGPxk23Soo+NGDziQ4nEP4HToWGW5EIJzz72A7t2787//XcgLL7xKkyZN66g3mla3lDd1CINI8dqlNS7eLz+v82NUHZVWrn379nXeB03TNG371TCuhjZQXbt2xTTLcyoWLlzIL7/8skm9cDjM1KlTK92o6ts3dXrrokWLKj1u06bNlnVY07RGyXJs7v7rQ34q+AcLh1h8lVsLFZ+85aouR7w8pEHhoOia2YKruw2nqQ5g0DRN0zRNS0opxbc/LOKWu9/h5de/o6AwSCgcw7EdQuEYtu2mLAghEPEwBKXcwANRIZFcKYWUAhmv4zgKx3GDGjweA9NnYuUZlHb2ULCLl1iORBlQGo25k/elRACGEO6xBIQti6htYwiBIQQKkEJgOwrbUXgNA79hxIMhFI5yyo4tBORnBMjx+9mlZQsmHHUI940czkHdu+gAhmoopbBUARH7P9bFprEkfDn/Ru5kVfQp1lqvEFX/YLMWm3U4FCMJIPECHhQWbuBCJH7+nghLkPFAhfLV8ET8rN4hiojnYqp4CTgIPJQHLiTqCyQZZXVU2aUchcSDR7RE4sGhFIWFQQ5IiyyjFx19N7JzxiR2yniCHf13km8O1gEMmqZptSjDaEqPzFEc1uQh9sg4mSzZCsGWTrCpfiW5ZbEf+Cfy/Ra2r2matqmHH36Yhx9+mIkTJ7J8+fKt3R1N0zRN07RGI2oln/TpMfSwLK2yVH8RynHAsgjHwxiSCQQyanZsKcnLy0taZ138u0hzcq62eURR0TYRwgAwZMiwpOV/AX9Usd0z9xfEmjV10qe6JlatwjfljWrLHyR1VOsxxxxPu3Z1M0HkyiuvZd9990tZb+XKFZx547VseP4VnDQnyGc89TjZ550JW3vClFJk3H07ORecnXYAQ+iksZTedjcLf1vIMceMpLi4qMp6tm1zzjmn89JLz9dmjxuMgw4azscff0WvXr3T3ufJJx/jqqsurRTiEzn6OEInnZJyX+OfJWRef/Vm9XVr8E2bXOV2ReoQhj322JOmTbe/ybI77dSdrl27Ja0zjYp3zCsTwVJ8b75e292qXZaF+WPVizgqqg4b2thZZ51Xmz3StDKDBx9E7957pKx3UWEBJWNPq9VjrwJuNj0p651//iUNZqHStWvXcvrpJ3PWWaeWBTCUldk2Q/ObsMKT+neqiViP3Sh4bQqFk6ZWG8BQ0YEHDuX7739hl112rdV+aFq98qcxPnFrf6bQakckQs4JR2Mu+LXODmEBVwHVL6ntatu2XZ31QdM0TdP03b4kfD4fAwYMQMUn3SiluOKKK1i2rDyzz3Ecbr75ZtatW1dpv4EDB6Zsf8GCBZUm7rRrp9/0NW17E3Esxv/9MT8ULMGqNNHKVfGmXGLtXEhM6ao8KN/EoEd2W+7YeSRNvQ3jgpWmaZqmaVpDVVQU4oFHPubpF75k0eLVOErh9biTJqUhSXxUcxTYjrNR6AIIQVkdpSoEMQiBYUiUUiilCHoc1rSHSGcfqqkHDIHHkIQti3XBEJF42AK4wQ6J87xEEANC4DXdsIXE6li2cvvjiwcxmFJiO4pwzCIYi+E1Dfweg0N23YlrDzqArs2b1dOz2vjYKkiR9TnLItexOHQei8JjWRG9h6AzB5SBRTHgwSALgYlDIRAB3AFdouyMXaKI4ubjEy9LBC7EID4hV5XVtQGTioEL7j4gCcRrOmX7CYx4QINbZhPGIYTAi1R+PKIpWXJ32njPo73/Sjr4bmJH/23kew7EI3ORwlfpb1jTNE2rXV6ZwS4Zh3FY3oPsmXkKebIDcjPCGFTi/6r6wo3f/KnkpaQrVmoaUP3fUV19aY1eIoDh4YcfrnQPTNM0TdM0TUsuZttJyz1yS4P6tG3NLn4/PYHdgF7AHkAfYC+gL9DMH4BwmGD1TZQJBAI1Pn5+fpOk5evj3+WG9UnraVtGFhamDGGQUpKZ2fDH/gwZUt3a5uWmV7Pd+/kntduZehJ45nFENFpl2Qbg2RT7Sym58MJLar1fCaZp8thjz9CiRcuUdb/66nPu/OA9il5+HZXORCnAP/l18kYOR65Ite573RAlxWSffSqZ992d9j7hI4+h5J7x/L14EUcffcQmky43ppTif/+7gNmzZ21pdxuk9u078PbbHzJq1FFp7/Pcc09z883XV7o2XXL73Vjdd065b+DlF/C+X90rQcNh/PkHnl/nVlk2B1iRYv90Xg+3RUIIDj308KR11gBfJSkPvPBs2ViIhshcOB9ZWlJl2XekXpW5Q4eODB2aPLRI0zaXEIIbbrg1Zb1Zs37koS7dKLnuJpRRO59Tpw8cRJFdXcSKq1Wr1px22pm1crwt9emnM9h//715551p1db5c8N6BrVrz6Jjj0d5vVt0vOiBQyh85Q0KPv6S2IFDygeZpcHn823RsTVta1Np/A2LSLgeeqLVtezLLsI348M6PcbtuXmk8+mvbdu6CTrUNE3TNNAhDCkdeeSRZT8LIVi6dCkjRozgtNNO49JLL2XYsGFMmzatLKRBCMFBBx2UMrFv/fr1/PXXX2WPs7KyaNu2bZ39HpqmNTxKKZ5dOpPP1/6BoxwcpeLjllWlsIVK+1T4npigZyAxhGSnrJZc3fVg8rw1W+1A0zRN0zRte1JSGmHyW7O45pYp/DDrb0LhGNGohW07hMIxHEdB/LPdJiELFU7OlAJDln+kdhzl7ivA4zFQmQbhdl6KO3sINAvQvmU+SoDPMPAYBl7DwIgfIBSziFg2UghMKXFwJ/Ar5Q7i9UiJ13C3KxU/DsQn1QtaZ2fRqVkeuX4fPVu35Ibhg7jn8GEc27snLbIz6+eJbSSUsii1f2ZV9BmWh2/hr9Bo/o3cTdj+C0eFcQgi8KOwibIERTGUTaKVbgAHAgiisFDxM3R3m8IhSuIsvjxwwYq3UVXggo/y2YsyvoeJwB/f10ERxSHs1hbt8YgmGGTiFzuSbwymqWc4HfzX0yXwEC28x5Jj9iXD6KpDFzRN07YCQ5rsFBjOIfn3sU/WeeQbOyIqhDEkG0LoKECJ6ue1xzeUqFWsjNXdKgKapm2/dMCLpmmapmlazcWsFCEMpllPPdEai6+67cRc3Mmcs4FZwE+4q/l9BxzacUdENLLVQhgSSxCJFBOUtS0jiotShjDk5OQgZcMf2rnXXn3JyclNWqfaEIZPZtR+h+paaSmB556utvhJSPnf72GHjaRTpy612q2NtWzZkieffA4jjUmW48ePY25ePoXPvYxKc+Vnz6yfyB+yP57vZm5pV2vE+HUeeUMH4p86Oe19wkceQ/GEx1j2378ceeThrF69Kq39Lr74Mnr37rO5XW3w/H4/jz76NJdddlXa+zzyyEPcVzH8wu+n6JGn0vq7yb70AkSFhe4aIt+UN6otSydCYnsNYQA49NCRKeu8maTMnD8P8+efaq0/tc38/ttqyx5MY/8zzjg7rddjTdtc++67H8OHH5qy3u133MzvI4+k4J0PsTvuuNnHc3JyKXz6RQ574y0++uhz+vTZs9q6l156JRkZDWNMe2ZmdsogJoDf/17EgC8+5+MXJlF8131EB+yPSuOzvQoEiA7Yn5Lb7uLPT75m6ePPEB0yDBrBOb2m1TblTSOEoZpgO63xEMVFSc+ha8ND19/CTYUFadXVi2JrmqZpdUmf1acwdOhQ9txzz0qDz2KxGDNnzuS9995j2bJllcoMw+Dcc89N2e4nn3yC48RXvReC3XbbrfY7r2lag6WU4rV/f2TaytmEnJg7oS4+mt79OV6PykEMFX924lOyADpmNOWW7ofTyp9T953XNE3TNE1rhJRSLPxjBbfe/TbvfjiXdetKkEJgSIkQAsMo/3hsOyoeulB+9qWceDBDWXuAAMMQSCnwmAZKKaKZgtUtHTZ0NAi2lDheQVQ5LFq7nmA0Vnb+BsTbc8MeIpaF5Th4TaPsAAKI2Q5CCPymid80EICtHCKWRdiysB0HWyksW3HQzl255/+G0b9TBzK2MJF9W6GUIuIsodSey9roK/wdPp9/I3dTYE2nwP6YmFqNQykxVhFlBeBBYCLxUR6RVorCpnJYggIiiLQCFxQChcTLxtNqJV5EWRCDiJ/hu/W97IBXtCTxCcEUTRDCQ545hM6Be+me8RztA1fSyncymcbOCKEv8WiapjUUQgg6+QcyIm8c+2dfRq7RHoGsdF2n4rUfWyXeLSrbJJBBATj8Gf6sLruvbQNEPX9p2wYd4qVpmqZpmlZzlpMihEFPttI2lmoCjlKISHohDH5/zUMYmjRJL4RBblhf47a19InCwpQhDLm5efXQky3n8XgYNGhw0jpfAsVVbPd+9AGUVL2yeEPln/QKsprJezFgQhptnHPO+bXap+r067cv11xzY9I6gUCAhx56lJ133oXYgUMpeuwZVJoTBeWa1eSOHEHmzddDuI5XsbVtAo9PJH/4gZiL/kpdPy500ikUT3yCVevWcuSRh/Hvv8vT2u+MM87m6quv39zeNhpCCK644homTHgs7Qni99xzB0888UjZY7tHT0qvSv1cybVrybr2is3ua51zHPyvv1pt8Xspdm/RoiU9e+5eu31qRHr06EnHFBO6p1BxuYJNBZ56vFb7VJs8339X5fZlJA+XAMjKyub440+s9T5p2sZuvPEWPClCcYLBIOeeewah3Xuz/rOZlF51HU5+ftrHUEIQPupYNnz5HdHDjgBg9917M336x4wf/zBNmzatVH/HHTsxevRJNf9l6kjfvvtw0023pVV35coVjDjxaG5YuYIVL73O2kX/smHGFxRNeIySG2+j9IprKL3sKorvuIeiJ55l/WczWbvoX/56/FluKSykz8gR3Hzztn8uoWnV8qcOYajzzxBanTN//B4Ri9VZ+8/l5nHRrTekXb9tWx3CoGmaptUdPUI/DePGjaNVq1aostVQ45MsNnoMcOmll9KxY8eUbb7//vtlbQDstddetd9xTdMarI/WLODVf3/EdtwJVe4quO5rycZDXTcOYjCFRAIeDEwh6ZbVkpt3OowmXr3KsaZpmqZpWlWWLF3LI099xt33v8fS5euJRKLYjoNlO4QjMZwqQhds2/2sltiUmPwo42ENCuL7uXWkKQk3NynpaGI289G6VS6mKcn0evCZBoYUOEoRillE4qujmVK653rKbS9mOxhC4DVkWUiXoxL9EJiGgc80aZOXS4bXixSCzs2acNwePbl75DDO3b8vWb40bmJsBxwVptD6jGWRa1gavoqlkatYGXuYkPMrjgpiqxJAIckEfPHwhBiKSFn4gjsMxA1TcNj4xo/EHU5HWR03kEEhcJB42HgNc4EPgSde14Cy83+JJBODHByiOJQiMBGYGCJAU/MougQm0i3jKboFHqGN72wduqBpmtZICCFo59ubQ/PuZ0D2pQREc6gQtuAQD3ZKMo29LACK8h9Wx37TK9ZrmqZpmqZpmqY1AFEreQiDmcZqmdp2JtV1XceBcJhQGk35/f4aHz4vL/kkq0T0gg5hqFuyqGibCWGA1Ku/x4AZVWyXJcX4p6aavtqAOA6BxydWWzwZSDXFf6+9+rLHHtWvFl3bzj//Ig4++JAqyzp37sIHH3zGsceOLtsWPewIip5+EZVm2LtwHDImPkj+4AF4vptZK33emDn3F/IOPpCs669GRCJp7xc861xK7n2AdRs2cNRRh7NkyeK09jvhhDHceutd21VY5bHHjuaZZ17Cm+a/+/XXX817771b9jh07gVE++2bcj//lDfwfpAqzmDr8HzzFcaypVWWrQOqnoJfbvDgocjteKVzIQSHHnpE0jorgWSvEr63piBX/Fer/aoVSuH5/tsqiyYCyT8NwOjRJ5KdrRdW0+pep05dOP30s1PW++GH77j99pshM5Pg/65g3az5FN85jljffqhqAnmszl0Inn8x67/9meJHnsTZoU2lciklJ5wwhpkzZzF27Gll76G33npnymCI+nbmmedy1FHHplXXsiweeOBe9tyzB3c/dD/zvD7CxxxP6LwLCV52FcErriF8+tks678fk//8nTPOOZ3evXdm3Lg7KS4u4qWXnmfmzK/r+DfStIZJeVOPX6zJub3WMMnVq+usbQu4pYYBDx06JA8F0zRN07Qtoe/2paF169a8/PLLXH311fzwww+VyhKDXf1+P5dccgknn3xyyvYWLVrEzJkzEUKU7T9w4MDa77imaQ3SzHWLePyfLym2wwhEPOG3fOB8InSh4lD6yqsjuns4KFr5crih2yG08ufWR9c1TdM0TdMalZhl89En83nn/TmEw1HCkRg+r0nMcuKBeomJj26ggpQgpcBx3I2OUkgpse34GZsCKdw6QgikgLBhE8s3COaDHZB4DANlCtaWuutUJW4uuvUFCAhbFkKAx5BELPf4UkDMtvGZJn7TBCwito2jFLbjIIUgZtlkeN0blLkBP0f12pWj9+iJKSVe7/a9oppSFkFnHkXWl0TUEkLOnzgqiEE2BtnxYAM/ILAoQBFG4I2fewsUDu5ZuIVDCIPECmKibLtCxeuqssAFsJB4cQhXOqN3AxeseLiDJBG55vbBAQwUERxsQOARLdzQBbLwy07kGPtiylwyZHc8sll9PY2apmlaHRFC0MG3D+28e7EwOJ3ZoUnYuIMKUkUpbHx9SAARVYpNDJP0BsVq2yGd0aFpmqZpmqZp9SLmJJ925TH0sCxtI6km9SoHEYkQTNFMwOfbrMmeTZo0SVq+Lv5dbNhQ47a19ImiwjRCGBrPOKDBgw+qNA6yKtOBUVVs9z/3NOETT07930YD4P3wfczFf1dZpoDxabRx9tnn1WqfUhFCMGHCowwevD9Lly4p237EEaMYP34CWVnZm+wTPeQwCl95k9wxxyOCpWkdx/zzD/IOP5jIIYdTesU12DvvssV9l8uWknHf3fhfexnhODXat/SaGwhedCmFRYUcc8xIfv/9t7T2O+qoo7n33ge3y8n0w4cfwssvv8HJJx9PMJj8XUgpxTnnnMZbb71Pr157gGFQPOEx8g/ojywpTrpv1uUXs6Fff1QDC5rxv/JitWUfAqn+AlOF0WwPDjvsCB5++IGkdd4ABlRTJiyLwFOPU3r9zbXdtS0il/6DsXLFJtuDwBMp9hVCcNppZ9VJvzStKldccQ3Tp7/N0qX/JK33yCMP0atXb0aOPBKysgifdhbh086CUAjzrz8Qa1YjbBsnJw+7cxdUs/TGrOTnN+Gee8Zz4okn8847b3HQQcNr49eqVUII7rvvIZYsWcxPP/2Qegdg7dq13Hff3dx3393k5ubRseOOZGRkEImE+e+//1hZxWtEwqWXXshnn83crAA9TWvU0lhESkR1CEOjZttkXX15nTX/LbA4zc+jAL169aZp06Z11h9N0zRN03f70tSmTRteeOEFZs2axSeffMLy5cspLS0lLy+P3XbbjREjRtC8efO02nrzzTfJzi6/gN2sWTN23nnnuuq6pmkNyO8lqxi/+GOKYu5KugJ3Opaz0cjojW9LyvhkLwUYCBSC9oEmOoBB0zRN0zStCkopvv1hER98/CuLFq9BOQpHOTiOIhyxUEqhFBiGKAtZUMoNYth0VROFYcTroHCU276UgpKmgmATD9IUmH4DjyHwGgaW4xCKxeKT7gU+00AKd9VrGT/Ri1g2Hp+Bx5BEbQeh3HNARzmYUuI3TZQC05DYShGxbZSCbL+PAZ06sF/njnRr0XS7WoWlIqUUEbWEqLOciPMPhfYn2E4xQkhiaj2KIGBiswGLNYBAkrjB4/5bKGJAGEGA8mmtAoih8FK+9rjAHVpjIYQXpSIVyhQCLxClfJ0LgUAgycSmGJAoYihMFFEM8jHIx2Y9YOGTHfHKNmTKnuSY++KVLer2ydM0TdO2GikMds08nNbe3nxUeBNhVZj2vhUDOx3seICQpmmapmmaptWen3/+ma+//pr58+ezePFiiouLKS4uxrZTre1ZPSEECxYsqMVealrDEksxKdTr0cOytI2kmtirFCISTh3C4A+kqFG1/Pz0QhjkhvWb1b6WHlFUxNFAZ6Cgiq/1zZrTrl37rdO5zdCsWTP22KMPs2b9VG2d93DvtGz8X4Bn3hzMX37G6t2nLrtYKwKPTqi27Fsg1TS+du3aM3z4obXap3Tk5ubxzDMvcMghQ3Ech5tvvp3TTjsr6T3G2P4HUDDlHXKPPxJZg1AW3/S38U1/m8jQYYTHnEp08FAwa/Be6Dh4vv8W/3NP4XvnLYRlpb8voHw+iic8RmTkkZSUFDN69NHMmzcnrX1HjDiURx99EqW2vwCGhIEDB/HKK29y3HGjCIfDSeuGQiFOOOEYPvjgU9q1a4/TvgMld44j54Lkq7Abq1aSeeO1lDwwsTa7vkVEUSG+6W9XW/5uiv1N02TgwEG126lGqFevPWjbth3Lly+rts4k4D6qn7jgf+FZSi+5HLKy6qKLm8Xz3cwqt78IpHp1HDZsODvu2KnW+6Rp1cnMzOS++x7i6KOPSFn3vPPOJC8vnwMOOLB8YyCA1XP3Le7Hbrv1Yrfdem1xO3UlEAjw2muTOeqow/nll9k12rewsIA5c9LfZ9Giv3jggXu56qrratpNTWvcpER5vYhotPo6Kc43tYZJrFlD1i3X45/0Sp0e5+ca1BVCcOmlV9VZXzRN0zQNdAhDjfXp04c+fbbsov+VV17JlVdeWUs90jStsVgWXM/df73P+lgJQoBQCiXik72Uik/jElUuVKdQFcIaBM28mVzdbTgdM/WquJqmaZqmaRUVF4d45qVvmPvrMmIxG9u28fs8hEJ2fNUSRWJcrOMopHQX11HK/ZISpBQ4jhvUgAIR32aaEhtFKANCzQRWhiTgNWmSk8HaYBCv4YYteKSMhy4owvHBQV5DYgiBo9ygB0cpLMeJhy1YxBwnHg4RPxsUbkBEu7xcwlYMRwlG7b4LQ3bqTLY/dVr0tsh9fixKnJ8otD4i7PyGQ5iYWo0bhuBDKD+KMJJM3HNrC4V700YRReCNT1p149AU0SoDFxQxBB4UEcCIl9kI/EAURfn5u0BikIFNSfw4Il5mI/Fj0gqbdTiUIvBhiEw8MpvmxkhyzAF4Zcv6ePo0TdO0BmJ17A++L36OsCotiwBKh6rwXSgTE2/ddFDbNlS/8KSmaZqmadomPvroIx588EH+/rt8ZedkK1lrmlYuVQiDWZOJp9p2QaUIYRCOA+FIyhCGzV1JNd0QBlGDSddaDTkOoqiQYcCwaqoU3XIHkaOOrc9ebbEhQ4YlDWFYCcwGqhp16X/+GUoaeAiDOXsW3mom4gKMT6ON008/e6u9L+y2Wy8efPAR2rfvwJ577p3WPtYee7Lhg8/IHTsac2HNQrV8Mz7EN+NDnCZNiA4aQmzA/sR264XTsSMqO6e8YjiMsWQx5oJf8cz8Bu+MDzBW/FejYyU4zZpR+PyrWHv1pbS0lNGjj+bHH79Pa98DDxzMs8++gMfjIRrd/ACybUH//gN47rmXOemk44jFYknrrlmzmpNOOo733vvYXRH8mOOJvPsWvg/fT7pf4JUXiRwxitigwbXZ9c3mmzoZUc0kwCgwPcX+ffv2IydHL6IlhOCQQw7n8cerD9hYBXxC9e9/srCAwCsvEDrz3Lro4mbxfPvNJtsU8GAa+57ZgH4PbfsxcOAgTjhhDC+//ELSerFYjLFjT+DZZ19iUAN5Pa5POTm5TJo0laOOOiLtwKbNNWHCeEaOPJLu3fWCrdr2RXl9SUMYkgY0aA2PbZMx7g4y7x9XL4ebbZhgpw7ly8jIZNy48QwbNrweeqVpmqZtz7bf2FZN07R6VGJFuP2v91gWWk+lUdDK/T9ZYUNVg+8V7lQwgaCpN5Nrug6na6ZeIVfTNE3TNC0hFIoy+a1ZXHPLVL77cRHhiEU4YuE4EArHcJQ7eFwIgZTuGZdSbhBDxZVe3GAGgRGv4yiFbTs4SlGSD+s6SkrbmMSyJabXwDEEK4tLiFg2MbvygFuBQAiIWBYO4DWM+Omfez5o2Q5CCAIeE59hIITActzghtJoFIEiatt0bdGcywcP4P9232W7C2BQyiFkL2B19BGWhM/gr9BIlkcuo8T+CpTEVoUITASZANisiwcrJAZIJf5NBA6hCtvdbW7cWRSBQfl5ukBhI8vCGVSFPSRS+HHPzhXlAQ0SgReDHBQWNkEcwhhkIoTCLzvQwnMSnQMP0ylwP53842nmPVIHMGiapm1H1sT+YmbRk3xUcAfr7MXxUCBZ47nyCsiQ+QihL+1rmqZpmqZpW8a2ba644gouuugi/v7777KA0MQ1tC390rTtQcxOPlHTY3rqqSdao5Hq9dFxEJEwoRTNBAKBzTp8fn5+0vIS3Amncv26pPW0zSdKSxApwo5UbuObzDt0aHVTastVN5HZP/VNRGFBrfantgUenVBt2VJgSor9MzOzOOGEk2q1TzU1atTRaQcwJDg7dmLD9I8JH/5/m3VMuX49/smvk33J+TQZPIBmndvSrENLmnZrT7OOrWjevgVN9u9LztmnEXjhmc0OYIju058Nn3yNtVdfgsEgJ510LN8lCc2oqF+/fXnppdfw+bave7DJHHjgUJ544jkMw0hZd8GCX7n11hvcB0JQcs94nDQCCbIvvRBRUrylXd1yShF49qlqiz8DilI0MXjwQbXapcbsiCNSv1a8l6I88PCDDWplbO/MrzfZNgNYmGK/XXbpwb777lcnfdK0VG699U66dOmasl4wWMro0UfxzDNPbpdhnPn5TXjrrfcZPvzQOj1OLBbj0ksvxEkR4qhp25xUYxwjDef9XquasehPAo9PJG/I/jRvnb9FAQylV1zDho+/xG7bLq36s3ypFyUZNmw4Cxf+zdFHH7fZ/dI0TdO0dOmRmpqmaXUsZEe5d9EHLC5djay4wm7Fe+sVflYVht9LBAYi/l2S78ngf52Hsntueh9ANE3TNE3TtgeLFq/mlnveYfpHc1i7vhghBIYhEQIMQ5SNaXQctUnoglLumMeKwQxKKYhv8/pMHL+kqINBcTOB9Ejycvz4vSaZPg9+08AQAqXc8IRQzEIIgcdwJ1VKBAqI2jYeQ+KREgf3GInzvkQwRK7fR4cmeWR5vTTLyODYPXbjumEHcO1BA9mtTav6fVK3opizhkLrI9bGXmJJ+EyWh6+kKPY5lrMWi4J4YEKUGH+jKImHMAgEkkRggkMwHriQOLd2y9zAhYqXQgSKGOChcuCCG7Ag8FIe5CDj/+9FCA9gxAMXojiEkfjxiBZ4RFM8ojn55sE094xhB985dAo8QGvf2WQau+CTbZBCD+TSNE3bHiiliDpBfgt9zDfFj7EsNjse9GNAxWtENSJo5dm1lnuqbXNUPX9pmqZpmtYoXXfddbz99ttVBi9UDGTY3C9N2x7EUvytm56ts+K51oDJFEP1lEJEwgRTNBPIyNisw+fnN0lZZz0g1q3drPa11ERhYco6TnbjC2Ho2XN3WrZMfi+ruhAGEQrhe3NS7Xeqlsi/F+F7e1q15Y9SfiepOieccBI5aUxMb5Cysih+8jlKbrwN5dnycCERCiELChDBVK90qSkhKL34MgqnvIvTegdCoRBjxhzP119/mdb+vXr1ZtKkN8nYzNfUbdkhhxzGuHEPpKzXp8+enH/+xWWPndY7UHrz7Sn3M5YvI/PWG7egh7XD/P47zAW/Vls+NY02Row4pPY61Mj16bMXHTvuuMn2/Px8Tj75NN5++wPG7dIjaRvGyhX4X32prrpYI/K/fzGWLN5k+wNp7HvmmefocEJtq8nKyuaZZ15K6/3Ntm2uuupSjj56JHPmzK5UVlRUyNKl/9RVNxuErKwsnn32JS677Cpkqs9qW+DHH79n+vR36qx9TWto3n57KsOKi9kf6AvsDnQHOgKtgT0AEYluvQ5qABi/LSTzuivJG7I/uSNHEHjsYQgGEevWkX3WKTTp14es66/GM/eXLTqOk51D8KJLsXbrRfj4E1PWDwELQ6niSeGpp17Y7JBSTdM0TaspfbdP0zStjj265HO+37AYK37LzR2bXOH2m8LNZIjP+ao4TMNBIXBXUQ4YHs7teAB98ze9UK1pmqZpmrY9+nfFBt79YC7f/fQ3oVAUKQWW7SBwvztKIRTxweMKpdwgBsNwAxYcxz3zUsp97A4Qd+soAbFsSVETCGVKMIU7NtI0KIhFy0IWyqZPCoEUgqhtYwiBxzCI2U58ALu7IprfNAl4TIRlEbFsbMchZjsIAZbjkOXzErFsOjVrwtkD9qZTs9SDIbcFSjk4BIk4yyiKfUBQzcJRYSy1BodIPGShFIcwAi8Cd4CXIoI7rK0UyIqfYwvcsAQHFd+3nBu4IMigPHAh8d1AYMYDGQSJf1mJHxsHiKFIBGc4CAy8oiMWQWy1AYEHj2iJT7Yi1xxMjrkPpsirh2dP0zRNa4gsFeG/6Hz+jsxkTexPgo67emSFGKgKtUX8HSn1JDWFQGCwU2BwLfdY0zRN0zRN2958+eWXTJ06daOwUvectEmTJuy66660b9+erKwsPLUw2U7TtlWxFCtZek3934+2kVQTexwF4UgaIQyZm3X4Jk1S33dYBzRbu2az2tdSE0Wp1lQHldv4JusLIRgy5CBefvmFauv8CKwGWlRRFnj+GcKnngkNcMJqxoP3Iap5vQ8BT6bYXwjB6aefXev9qldCEDrvQqIHDiH7wnPwbDRJc2uwO3Sk+L6HiO1/AADBYJBTTjmBL7/8LK39d955VyZNmkpOTk4d9rJxO/HEk1m8+G8mTBhfZfnYsadx66134fNVDp8Pjz4J39TJeFP8WwSefYrIEaOI9R9Qa32uqcCzT1Rb5gBvpdh/p52606lTl1rtU2MmhODII4/hvvvuxu/3c/DBIzjyyGMZNGgwXq+7mnH43Avwnn9W0nYyHrqf8AljwJt6BeS65Jn59Sbb5gHvp9ivadOmjBp1dJ30SdPS1b37ztx774Oce+4ZadX/8svPGDr0M3bZpQfdu3dnw4YNfP/9t+yzT39ee21KHfd265JScsUV1zBs2HAuvfQi5m7hZOON7bzzrlx77Q0MHXpwrbaraQ3Z8uXL+TgSqbZcAiISrr8OaZU5Dhn33EHGA/dW+qzrnfk1GQ+55/6yFq8LRYcOg/g9hvDok8gcd2fS+vMBO0Xw7WuvTd7kc4imaZqm1SUdwqBpmlZHlFJMWzmbGWsXYCm7bGqXXXFQfWLOV2L+l4ivr6sSmwQSQYbh5YwO+zG4eff6/0U0TdM0TdMaGNtx+OKb33lz2iyCwQihSAyvx8Rx4iv24QYruHUVhgQpRNnFWcdRGFKi4sEM7gBzgZQCFJg+k3XNHKLZ7gma4RF4vSY+0w1WiFgWtuOgFPg9JqaURB3HXaEKiNg2mYYHjyGJ2g4ifm6nlEIKgc80UUCWz0vUsolYNn6Pye5tWjNkp870atsan7ntf1yPOasptr+h2PqYmFpFTK0EFCbNUNgobAyy4qfLQSAaP5M246fRCoEEbNxhbokL624Qgxu44KFy4IITr5EIXCgf8CoJ4OCgsCoEPYDEiAc3mNgUAw6SHBxs/LItucZYcs2BmCIHIeouGV/TNE1rHArtlXxf8iJF9iqEEkRVCQKJRBKjPK3ffXcqf48qv1qkqDjUXJXVdrc2MXakidmxrn8NTdO2Y3fffXe9TUAQQvD888/Xy7E0TdO0yh5++OGynxPhC127duXyyy9nwIABdbr6n6ZtS2IpBgSbW3nimNYQpZhgrhxEJFxnIQz5+emFMNTmYHutsrRCGBrppPAhQ4YlDWFQuBNXT66izPxtIeb332Ht06+uurdZ5NJ/8L/xWrXlr+H+N5PMwQcfUuXK8I2RvfMuFLz3MRkPP0DG+HGIcP1PnFKmSfD8iwlecjnEVz0tKirkxBOP5bvvZqbVRufOXXjjjbfSek3c3l177Y38888S3n57atk2v9/PPfeM57jjTqh6JyEovv8hmuy/DyJYmrT97IvPY/3n30Iaq7XXNrFqFb533662/HtgZYo2Row4tFb7tC047rgT6NChI4ccchjZ2Zu+n0X+7yjsu2/HWLa02jaMf5fjf+VFwmNPq8uupuT59ptNtl2Txn4nn3wafr+/9jukaTV01FHHsmzZUu6889a091mw4FcWLPi17PGnn37MvHlz6dlzt7roYoOy++69+eCDT3n99VeZOPFB/vzzjy1qb//9B3H66WcxdOgwDMOopV5qWuOQanJ8BECHMGwdpaU06d8HY8V/VRbX9vUgp1kz97Nb4nGbtkQOG4nvnWnV7rMgjXZ79uy1xX3TNE3TtJrY9md11DGlFL/99hvz589nw4YNFBYWUlpaSmZmJrm5ueTn59OjRw922mmnSqtIaJq27ftq/V+8uPxbYo5NYsi8vdGqhgJQFYMY4htFWQFIITl2hz05tGXPeuq5pmmapmlaw6SUYvbcpbw3Yx4L/1iBYyuUUjiOIhK1UMoNVTCkG6jg2ApFIohBIATx0AV3Ar8hZVmYguMoYl5FNFcSbKqwPQJTCDJ8XqLKwWu4A8+loCzoIWrbAPhNA0l8CqUQOEphOwq/aaKURcxx3H7GQxgcpTClpGlGBuGYRYemeVw4sB8tsrO21lNbL5SKEXR+IWIvIeT8SqkzC5SBJEAM9wK+wMRiHYoI4CkLJnPKQhRiKEIIAvFWE898DIGX8sCFsqNWE7jgx8bGDWUwEPHJrQI/ijAgcAiVlZvkIoTEQzMyZB+yjD0xZQ4BuTNS6NXsNE3TtmdKKdbb/7Am9hfF9jqWRL/HVlFyZWssESZoxTDwonBw32tEPGwIBBJV8YJQ/Ht1U3gkXvbOGqOvM2uaVmeUUvz+++/1diz9eqZpmrZ1rFu3jnnz5iGEKHs9HjBgABMnTixbnVTTtPREq1kZPcFj6muH2kZkinNgx0FEIhViHKsWCGzexL68vPyUddYDsqAAotGtvgL1tkgWFaSs01hDGAYOPACPx0MsFqu2znSqDmEACDzzOMUNLIQh46HxCMuqskwBE9Jo4/TTk6/43hi8/fZU+vTZizZt2oLHQ/CSywkffRyZd9yC/81J9daPyEEHU3rdzdjddy7btmbNGo47bhTz5s1Jq4327Tvy5ptv06JFi7rq5jZFSsmECY+xbNk/zJ79M+3bd+TZZ19KORnXad+BkutvJvvqy5LWM5YsJvOOmym97e7a7HZaAi88g0jyejW12pJyI0YcVnsd2kZ06NCRDh06Vl/B4yF44f/IvvzipO1kjruT8FHHQtbWG0Ph+earSo8XAu+m2sfj4ZRTTq+zPmlaTV188WWsW7eWJ554dLPbmDjxAR577Jla7FXDZZomo0efxHHHncCnn85g6tTJfPrpDNatSxW75e7bu3cfRow4jEMOOWybCeHStM2RKowoDIhItH46o5UxZ88i94Rj6jV4s2DKdOydKi9CG7zg4qQhDPOzsqGkuNryZs2a0bx589rqoqZpmqalRYcwbKaZM2fy0ksv8f333xMMpsofh4yMDPr168eJJ57IPvvsUw893Lb8+eefzJ8/n9WrV+M4Dnl5eXTt2pXdd98dcztYIVZrfJaF1vPg3zMotiLxFXo3ngzmSkwlUxstcajiJV5pMLx5D0a33VsPSNU0TdM0bbsWCsd45Y3v+fbHv4hGLWzbweczCYdiSCEgHrAAbqCClJQFHiTyrqSU2LY7KFYpENINTTB8kuIWglAGKFPgmOCVAo/XJGhZblADioDHUxbAIHD3jdo2HkPiMQwito2Id8JWDh5hEvCYCMsmZttYjsJyLCzbIcvvI8fv5/CeO3JA1x3J9idPgG6sHBXGVsUUW19RZH2CzRpsSrDVBtxn0cBBoLAwyIhvi8TPh2PxQAQ/5WfOiSAGd+CnqrRauB0PXLBIhDO45b74tsSAaPe4ggCK0vhk2ChgoLDw0AIpAvE+SvxyJ3yyDZnGnmQZe2OIzVthTNM0Tdv2rIwuZGF4BuutZYBDqb0BiwgCg5gKY+CuauJObqsYs2DEgxjcYIaqrhlVJhBIdgkcTEtP9xR1NU3TNE3TNC25n3/+uVIYTnZ2Nvfcc48OYNC0zRBTyT/Pebw6hEHbiJTJyx0HIhFSjUQLBAIpalQtMzMTr9dLNFr9ZIfE9CK5fh1Oq9abdRyteqKoKGm5khKV2ThDu7Oystlnn3356qvPq60zA7CBqtYC9r09jeCVf2J37lon/asp+e9y/K++WG35TGB2ija6d9+ZAQP2r9V+1bcXX3yOSy+9kNatd+DVVyezyy67AuC0bUfxI08SvPB/ZEwYj2/KG4h4gH1tUkIQHXIQwUsux9pz70plixb9yQknHMPffy9Kq6127dozdeq7bpiElrZAIMDTT7/I7bffzB133EN+fpO09gufcjq+t6bg/W5m8vaffIzooUcQ26d/bXQ3PaWlBJ5+vNpiReoQhjZt2rLbbr1qs1fbjfBxJ5AxfhzGf/9WW0euWU3GoxMIXn51PfaswvFXrsDc6LXl7TT2O/zw/6Nly1Z10ylN2wxCCG655U4cx+Gpp6p/3Utm2rQpXHXV9dtVqICUkiFDhjFkyDBs22bhwgX8+efvLFr0Fxs2rCcWiyGEoHnzFrRq1ZqddupOz567p5x4rmnbi1TXmSOAiITrpzMaAObPP5F79EhkcfJrErWp4I23KgXoJVi99iB85DH4J79e5X6/tmkDv/9Wbbtdu+5Ua33UNE3TtHTp2es1NH/+fK655hr++OMPwF2pJx2lpaV88sknfPLJJ3Tv3p3bb7+dXXbZpS672ugppZg8eTJPPvkkS5YsqbJOXl4exx9/PGeeeSYZGRn11jfbtvnzzz+ZM2cOc+fOZe7cufz11184FVY5OP/887ngggvqrU9aw7E6UsTtf0ynyApXuXbhpmvzljMQOCKxLqJkQJMunN1xfx3AoGmapmnadisatfj4i4V8/PkCVqwsQEiBFXNDEUKhWDxwQSCFQAqw46ELjlJIKRF2/LGjMCQYhhvEoJTCchSRLEGolcDyguEIPF4DZQoCHvfjsmU7OEIQsx2UipHh9WBKScxxygaIxWwHv2ngKEXMcdt2HPcsTwiBEIKW2Zlk+XxsCIXpkJ/H6D13o8cOLfFtg6FySlmEnF8psj4j6PxMzFmFQzECHybNsSlB4I8HJtg4uMnFDlEkvgoTUiWKKIKKA5UF4KCIIfCgiJEIXAAHgTe+Lf78IxCYSAI4BKFCZINAIcjEpDkWq1EEEQSQ+PHK1uSaJ5Nt9MMUefXwrGmapmmNReJ68JLID8wOTgYgIPNQ2JTY6/DgRwiJg0VEuWE/Bl4EkorvQ5VVFcRQvk0g2cHTkz0yj9PXiLS06L8SbUuke99L0zRNa7zWrl1b9rMQgqFDh5Kfn3pldK3mIpEIP//8M3///TdFRUV4PB5atWrF7rvvTrt27bZ297RaUP3ayS6PR4ebaJUpo6qp5+WEbSMiEUIp2vH7Ny+EQQhBfn4TVq1aWW2dRAiDWLMGdAhDrROFhUnLVXZO6rCOBmzo0IOShjAUAD8BfasoE45DYMIDlDwwsS66VmMZDz+AiFX/Sj8hjTZOO+2sRn0979lnn+LKK/8HwIoV/3H44Qfz/POvsO+++5XVsbvvTPHEJyi99kb8r7+K77WXN5m4vDnsHdoQGXkkoTGn4HTqvEn5l19+zmmnjaGwsCCt9tq0acvkye/Qrl37Le7b9qht23Y8+uhTNdtJSkoeeJj8A/ojwtVPshNKkXXRuWz4bCbU0xhg/6svItevr7Z8AfBXijaGDz+kUf/3vVX5fAQvuITsqy9LWi1j4kOExpyKatmynjpWzjPz6022bbqlMikll1xyed10SNO2gJSS22+/hw4dOnLDDdfU+B6A4zg88shD3HPP+DrqYcNmGAY9evSkR4+eW7srmtZopAoksQAryfmhVrvMWT+Se8z/1WsAA4DTpGm1ZSXjxiP/+xfvt99U2h4acyq/ff1FpW0ej4eBAwcxd+4cVq9eRbdueuESTdM0rf5te7M96tCzzz7L/fffj2VZZR9Aa3IRLbHPwoULOfbYY7n00ksZO3ZsXXS10SsqKuLiiy/mm2++SVqvoKCARx99lHfffZdHH32Url3rNgn7ySef5LPPPmPBggWEQqlueWrbI6UU9y76iL9Da3DiK+26Ky+XX7RKrOFb1WUsJ15TItg5qxVXdB6G19Av1ZqmaZqmbZ/+W1nAE899wdLl6wlHYijAYxhYloMhZNk5lht4oJBCIuJbVfz/pBTYTrymAoQCUxBtbhLMVkR9oAyBAIQpiSgbDwYO7tT+xEc+KQSW4xCxLLymQSzqxFcMhJhj4xcmAdNEWBYR28ZRiqhl46CwnfgZoBCM2KUbx++5GwHPtrUCmqU2UGr/SMxZQbH9BTFnJZIMHGLYBBHxcIUYy1DYCBKrOCWC7ASKMKrS2keJwIVo2Yrh5dtjSDKwKw1zVgjM+LHCJIIcXB4EnnhIQzQe9KAwaYIQAr/oSpbck2xzf0yRg0e0RAh9Hq5pmqa5ok6Qf2NzWRz5nlJ7PVEVpNRei1/mkG20RAqDYmsDCoUQ7nuPxMTBQBHDUlFM4UMqDzZRJBI2em8T5WcxFR6DiYeWnl0ZlHMxhn5v0jStjgkhOPXUU+nSpcvW7oqmaZpWhwrjkz/da1uC3XfffSv3qP6sWrWKuXPnli228Ouvv1JaWlpW3qZNGz799NMtPs769et5+OGHmTp1KsFg1evZ77rrrpx77rkMGTJki4+nbT2xFJNXPF5fPfVEayyO+GU2iyF+hdr9XvHni35byDldupJqKsKWrLCan5+fVgiDXLuG2l/TXks16UHl5tZTT+rGkCHDuOGGa5LWmUHVIQwAvremUnLXfbCVVxGWy5bif/G5astXApNTtJGbm8dRRx1bm92qV0899RjXXHNFpW1FRYUcc8xIbrnlDk499cxKY2edHdoQvPgyghddivH7b3hnfIj3my8x5/6CrBACVh2VkUlsjz7E+u1LdOCBWHvuVWUgiVKKZ555kuuuuxLbTu9VqnXrHZg8+Z3tagXvhsLu1IXSK68j6+brktYzF/9N5p23UHrrXXXfqViMjEcfTlplahrNDB9+aO30ZzsVPmEMGRMfxFi+rNo6IlhK1s3XUfzIk/XYM5dnZuWx6w6QfDQ7HHbYSLp10yszaw2TEIKzzjqPLl26ctFF57F69aoa7f/qqy9x2WVX06JFizrqoaZp2xJvGtfDotVcM9Vql/nTD+QeO6reAxgAVNPqQxhUVjaF097DO+MDzDm/gG0RHTaCku67sGTH1pimycCBgzjiiFEcfPAIHnzwfj7++CMAunXrVk+/gaZpmqaV06M20/T0008zbty4sscVLyCnkwiYWP00IRaLcffdd+M4DqeeemrtdraRC4fDnHbaacydO7fSdo/HQ5s2bfB6vSxfvrzSYIVly5YxZswYXnvtNTp06FBnfXv33Xf57bff6qx9rXFTSvHEP1/yS+FSVIUwBYXaJHRh4yCGRD3pTv+ja2ZLrut2iA5g0DRN0zRtu7RmXTHTP5zL19/9RUlpGCkEMctGIAg7MRxHIQz3c5aUbgiD44AwFEIKlOOeZSkFUgqkAEcpHKWwTShuI7EzFFggpMBjSAI+L45yiEWjbniCo8jwejClJGo7EA9ciNo2XsPAa7jbhYqHbimFFAK/xwMImmYFCMUswjGLDk1yOaJnd/bZsT3NszK36nNbW5RSKMJEnZUUWu9R6nyPo4JYag0OEQQmDqU4RBF4kXgAhU0YUDgEkWRQfmYsAQeHMKJSEINEEUMQoHxducSZtInAjJcTb0Mg8eNgoXBQxOKBCxaSACYtUCKIQpEp98Avu+CT7cgy9kKKzVs5TNM0Tdu2LYvM5pfgNCKqBEN4MJSXkFOIjUXQKSCsiskxWmKr6Cb7SgxsLGyimHgx8ODE35sEEhUPWyjnvsdJTMBBYNLZvz97ZZ6ER+r3Ka0GaraIkaZVMmDAAPr167e1u6FpmqbVoY0n7uY28smeqcyaNYtnn32WOXPmsHr16jo/3vfff89FF13Ehg0bktabP38+5513HiNHjuTWW2/F6/XWed+02rfpJ8HKTO+2FcarbbkloRB/JCkvikUhHE4ZwuDzbX7AR35+k6TliXXB5do1m30MrXoiHoZUHZWdU089qRudO3ehTZu2/Pvv8mrrzACqm44tS0vwfvYJ0eGH1En/0pV5zx2IaPWv8i2B6bv14sG27fjgg+k4jrNJneOPP5HMzMZ5X/Cxxx6uNkwjFotx9dWX88MP33HffRPIysqqXEEI7O47E+q+M6ELLnZD81etRC5bilzxH7K4GKJRMAycvDxUfhPsTp1xdmhTno5fDdu2OfPMU3jnnWlp/y6tW+/AlCnv0KlT57T30WpX6Ozz8L07Dc+sn5LWCzzxKNFDDie2T/867Y9v6psYy5YmrfOa1wfRSLXleXl59Ou3b213bfvi91N61XXknH9W8mpvTiI8+iRiA/avp465PDO/qvR4IZD8Ex4MHDiozvqjabVl8OCD+OabH7n55ut5+eUX0poDAxCJROIBTTfUcQ81TdsWpHPNIhIKsV1fNQuF8M74AM93MzH++8/9HLVjJ2L99yW63wGwBdd9Esw5s7deAIPXi9OseaVtq1at4vXXX+XTT2fQtGkz+vbdh1NOOQPzoOFldUrWruX++ycwfPghZdevxo27k4kTHyyr07WrDr3SNE3T6p+e3ZuGjz/+mHvvvbdSiAK4k05yc3M58MAD6dmzJ126dCEnJ4eMjAyCwSDFxcX89ddfzJs3j08//ZSCgoKyNoQQKKW49957ad++vV7doII777yzUgCDlJKzzz6bsWPHlg0AiUajvPvuu9x1111lK3WsX7+eiy++mDfffBPDMKpsu65IKfF6vYTDqW6Datuy91bPY/rquThlEQzuur1QPu65YvBCVZeuFNDEm8H13Q6lhS+7jnusaZqmaZrWsCil+H7WYl5543uKikOEwlE8pntu7wYuCJx4wIJjK6SRCMiLb3MUhiHLfnZUPORKgJUliDUxKc1WKANQAtMrMAxBwOtBCje0QSAQAmylCMZiZHg8SMrXpHaUwnIc/KYJWERtG6XAdhRCJkIaJF7DwG96GLhbR0bvuTueev6MUlccFaTU/p4iawYR5y9iagWKGJJ8BB4UFgZZ8XW8Q0AsfnZsVJhkauAGLoQQ+Kh8tmwDXjY+c3YnqhqAFS9LxC5k4FCKigc0iPjRBB48tEIRwmI9Ag+maI5XtibPHEqWsQ+myKvz50vTNE1rfEJOIYX2CmwVY521mD/DX2IIL1myOUIIYiqMbbuhCkJIHGwKrf8w2PQmuMDEnZLjYKsYhvBiKh8W4XhIEEhMDExsrHiIkEQg8Yls9sw6gU6+AZtcl9Y0TdM0TdO0LdGmTZtKj4uK6n8QZn2aN28eM2bMqJdj/fTTT5x55pmbjBvIycmhbdu2FBYWsnLlykqrNk+bNo1gMMhDDz2kz/0boViKco8O19A2kuo/c8d2EJFIGiEM/hQ1qpcqhGFd/Hs6K9drNSdSvO86jTwcSQjBAQccyMsvv1BtnZlAMVDdqCjf21O3agiDsWA+vtdfTVpHAHvfdhfP7dOfZcuW8txzT/PSS8+VhTAJITj11DPqobe1b8KEB7j11tQTLKdOncwvv8xm/PiH6d9/QPUVhcBp1RqnVest7pthGLRt2y7t+p06deaNN96iXbv2W3xsbQsYBsUPPUb+gfsiItUHGwilyL7wHDZ8+jUqq47GTUajZN5zZ9IqvwLzkwQwABx00HBMUw+/31KRo47FevRhzPnzktbLuuISNnw2s1YmI6ZDrFqF+deflbZ9VU3divr21cG2WuOQm5vH/fdP4Oyzz+eZZ55g0qRXKS0tSbpPnz570bt3n3rqoaZpjd3GIcBViYS30xAGxyHw9ONkjLsTWVCwafnDD+A0bUrojHMInXYmKjdvsw4j1q0j5+TRWyWAAXADtCpcF/333+UcfvjBLKsQhvb221OZOnUykyZNITseSNmsWTNGjz6prM7EiQ8xblzl8/du3XQIg6Zpmlb/9FWgFKLRKHfccQdKqbIb3kopmjVrxmWXXcaIESOSrkiw1157cfzxxxOLxZg+fTr33Xcfa9asQQiBEALHcbjjjjvYf//99coGwKJFi3jjjTcqbRs3bhyHHnpopW1er5dRo0bRs2dPRo8eXTYwZMGCBUybNo0jjzyyTvvZpk0bevToQc+ePdltt93Yddddue2225g6dWqdHldruBaXruXJpV8StKNlAQxVSazzu3ENFV/7MN+TydVdRtDa37hvqmqapmmaptXUgt/+470Z85jz6zJiljsI2XEU0ZiNUsoNSBAghYiHXrnlUrrblUp8KaR0Q+9QYElFUWuBlSFRUoEEA4HXaxJTDpbjUBqNkeH1IIUom94vhMB23MAFr2kQtmxEPAHeVgqvEPhNM17P7VHIsnEcRV5GBn07tmO/zh3ZtXWLRj94Our8R9iZS8RZTLH1CY4KI8nAYi0KG4EPRREOEQRG/NxWxv+V3GAFhyCSjAqtSsCOnxsnzpAT31W8HSter3LgghvEkPj8LBCYCLw4mDiEAAeJu7KQR7aiqXEsOeYgPKIpAl+j//fQNE3T6sY66x8WR75leXQutoriKJsSZy0SSabRDEfEMPASc4Lue51wg58kBo6AqApWCBxyCSGRysQhio27vxQeTCWwiAB2WZSnxETh4COT5t6u9Mo4imaeTvX/RGjbBJHewkWapmmapm2nevbsCVB2jWT58upXqt7WJRbYqA2FhYVccskllQIY2rRpwzXXXMPgwYPLnu+VK1fyyCOPMGnSpLJ6H330Ec899xynnHJKrfRFqx92LJZkZIDLrKeJYlrjIePXE6qjlAORcBohDJv/t9WkSbohDGs2+xha9URRYdJylZNTTz2pOwMHDkoawmABXwCHVlPue/9dSoqLUNlb57nIvPWGsnuC1Yn2H0Bsn/4AtGvXnuuvv5nLLruKqVPf5KmnHmeHHXagY8cd66O7tSoajfL++++mXX/x4r8ZOXIEJ510CtdffxN5efl12DvXtdfeyLfffs0vv8xOWm/XXXsyadJUWrRoUed90lKzu3aj9MrryLrl+qT1jCWLybr6coonPFYn/fC//ALG0iVJ6+zQqjX3XnwZU9+ZxsyZX1e5Svyhhx5RJ/3b7khJyY23knfMyKTVzL/+JPPOWym96bZ66Zb326832bbplsqaNGlCly5d66ZDmlZHunXbibvuuo/rr7+FmTO/YtasH1myZAmlpSUYhkmrVq3o0WM39ttvIB06dNza3dU0rRFJZ15cNBSqh540LKKkmOxzz8D3wXtJ68l168i86zYCj0yg9KprCZ9yBtRkATDHIefc0zH++3cLe7z5Sv93ZdnPsViM0aOPrhTAkPDTTz8wceJDXHXVdZuUPfPMk9x8c+Xtu+zSg9atd6j9DmuapmlaCjqEIYVXXnmF//77DyFE2cW0ffbZh4cffpisrKy02/F4PIwcOZIhQ4Zw4YUXMnPmzLKb7CtWrODVV1/l5JNPrpPfoTGZMGFCpVUfjjjiiE0CGCrq2rUrV1xxBdddV35yNXHiRA4//HA8ntrPRrvpppto3749TZs2rfW2tcZrTaSYO/+aTtCOUjZprMJrhkBUGnxR8WcjXiYArzQ5t+MB9M7V6duapmmapm0/YpbN1Hd+5uMvFhKOxIhZNj6fSSRixcPr3HAFKA9dkFLgOKoseMGQ0g1CiD8WgDIF0TxJaTOJbSikLRASDFOS6fciACcawxECRymC8SAGjyGJ2g6Jy9ZR2ybT48FRiqjtuIEQTvw8T7iRDa1zczClJByzOKDrjhzVe1eaZGZU8ds2HkpZhJ0/KbLeIejMxlGlWGoNCgeBiU0hiiiCzArnu2HABkpRZFEerCDi2y0om5waDznEQuBBEYWyZ10h8KMoBZx4XXdVcEEgvh0U4XjgAxiiOTJ+nIDclWxjH0zRhAxjdwzRuP8tNE3TtLq3OPI9v5ROxcHCJ7LwyxxKnLXue48wKLHXEnIKyDPa4uBssr/EQCJwcFDKKQtocMt8OFioCmVSmJhKYBPFL7KxiWGrKDnGDvTNGkMrz65IUYOb6JqmaZqmaZpWA61ataJXr1788ssvCCH46quvuOSSS7Z2t+pcZmYmu+66a9lCCz179mT58uWMGTOmVtp/+umnWb16ddnjtm3b8sorr9CyZctK9Vq1asUtt9zCDjvswPjx48u2T5w4kVGjRpHbyFdA357E0gjw8Hh1CINWmUwREuw4DiISIfn62+DzpV5VsjrJJknnAIH4z0KHMNQJWVTIImA1kAvkxb9nEL+/ldP43wf22++ASuOmqjKD6kMYRDCIb9oUwieNrYvuJeX96H18n8xIWa/0mhs32RYIBBg9+iSOP/7ElKtJN1Rer5c333ybs846hQ8/fD/t/V588VneeWcqF154KWPHnlajcbWb08fHHnuGwYP3q/Z57t9/AM8//wq5m7lqrFa7LMvCNE1C55yPb/pbeGb9lLS+f9IrRAcNJjLq6NrtSDBIxv33pKzmPecCxpx6BmNOPYMVK/7jrbemMHXqm8ye/TPgriA/aNDg2u3bdix2wIFEDj4E3wfTk9YLPDqB6OChxPYbWOd98nzx2SbbUoUw7L13P70YhNZoZWZmMnTowQwdevDW7oqmaduIdK5ZhCOprnxsW8SG9eSNPARz4fy095FFhWRfcwX+Sa9SMm48Vq890tov4+7b8H72yeZ2dbNcCUwDmgC5HXYk+7mnyH9rMnl5+Uya9ApLl/5T7b73338P559/caXPka+99jJXXXXpJnXPPvs8fc6laZqmbRU6hCGFd98tT/YVQrD77rvzxBNPpJXOVZWsrCwee+wxxowZUzaoQSnFO++8s92HMBQWFjJjRvlNDCEEF1xwQcr9jjzySB599FH+/ddN6vr333+ZOXMmAwfW/sW23r1713qbWuOmlOKhxR+zJLQWGwcRX7w3MRnMvZ2Y+HnTE34nXsMrPYxqvQeDmnWvv85rmqZpmqZtRbbj8M13f/L+J/NZsnQtArDiIQehcAzluGdPQkqkFNi2G7LgBjFIys60lEIJN4jBsh1soShuLohmS2yvQJkKlECZoAQIFJbj4JGSxPVYGQ9iCMVi+E2TWLwfUghsx12d2m+aSGETtmwcFGHLwlYKFDhK0TI7ixG7dmNA5w6N9kKvpTZQan9LsTWDqPMPMbUSEBi0wKEUMJBkAAqHYtzVu0O4QzITYQkCN2yh4jpd7naHGO5liETggkDhIPGjiJEINHNjzEwkGfHjChJnzgILST4G+VisQWBhirZ4ZFuyjf5kG/vikc3q4+nSNE3TGilbWayMLWRFbAFhp5iQU8BaaxF+kUeW0RxwV50MOQUIpBuwIAxsFaPAXk5A5lZxhQcEJhDBJoahvGXnA0IIhPIiUThYoBQCiY2FR/jxygwkBm28vdg9cxQesfmTKDRNa1yUUsyfP5+FCxeyfv16AJo2bUr37t3ZddddG+3nCk3TNK1xOO2007jgggtQSrFw4UJ++OEH9t57763drTpx4IEHMmDAADp16hS/rlhu+fLltXKM9evX8+KLL1badtttt20SwFDRWWedxddff82PP/4IQHFxMc8888x2EYixrYiWlqas4/HpEAatslSn+Y7jIMLhSlfYq+L3b/7f1mGHHUHXrt3Y4eUXaPXDdzQFmgL5QMXlbqQOYagToqiQR4H7Ntpu4oYx5H4wnV5nn8Zjjz1d/52rJU2bNqVnz92ZO/eXaut8lKIN/ysv1H8IQzhM1rVXpqwWGX4o1t59qy0XQpCVlV2bPatXGRkZPPvsy1x55f948cXn0t6voKCAW265noceuo8xY05l9OgT6dSpS530sVOnzowbN55zzz1jk7ITTzyZu+66b7PH92q1a8aMD7j66st58cVJ7LzzLhQ/9Bj5B+6LSDHpLuvyS4j12QunFldez5gwHmPVyqR1nGbNCFV47WndegfOPvt8zj77fP7+exFTp74JgE+f49WqkjvuwfvlZ4gkIWdCKbLPP4sNH3+Fat687jqjFN6NQhiWAdVPG3T17duvzrqkaZqmaY1NOudKkUiqKx/bEKXIOfu0GgUwVOSZM5u8YYMIn3oGpVdfnzS8MfDEI2SOv3dze7pZFgCVos7+Wex+1UCnTjvQv/8A9t57H/beuy/ffPMVUkocx10kxTRNrr/+Fo477oRa67emaZqm1YQOYUhi/fr1zJ8/vywowTRN7rjjji2+QOv1ern99ts54ogjsG0bgAULFrB+/XqaNGlSG11vlD7//HMsyyp7vPfee9OuXbuU+0kpGTVqFBMmTCjb9sknn9RJCIOmVaSUYtJ/P/BjwWJUfBKguwpwPMldgFAV1/9VZUEMMv5IIpFCMLBpN8a07b91fhFN0zRN07R6VlIS5vEXvmTh7ysIR2IopfB6PVh21B0IrRQO8Sn5joMRD0xQyv0ChWHIsmAGpQAJVqYg2NrE8io3B0AKDAUBvwdDSoqjUWylCEZjBDwmHmkQtR2oELgAAq9hELFthEpEarlBDR7DQClolZNFMBYjatv07diOQ3bdiV1at8DcaBB3Q6eUIuL8TlT9Q9CeQ6k9ExQIYRBTq3DPbiU2K1FEAT+iLChB4QYpRFHxeq5EFFkUgReFVWG7Hd+WCFwAN6rMROLHIRivmWjLQODFIBebUtxgBxOTTAzpJ9c4nhxzCD7ZsW6fKE3TNG2boJRiWfRnFoQ+pNRxJzsLJSlyVuFgExUhoqqUHKMVChtHWUiMsv0N4cFSUaJOKN6egxCyQrmJUhYCiYOFVGZ5EAOQabTAL7MJ2QWEnA0YwkNTsyNtvb1p79uTbKP6yVmaptXcqlWrmDt3LnPmzGHu3Ln8+uuvlFaYJNemTRs+/fTTrdK3WCzGCy+8wPPPP8+qVauqrNOqVStOPvlkTjrpJDweT5V1NE3TNG1LDB06lAMOOIDPP/8cgJtuuonXXnuNnJycrduxOtC+ffs6P8b06dMJVpgwtNdee9GvX/JJOEIIzjvvPMaOHVu2bfLkyVx88cU6jKmRsMOhlHVMr56gp1UmRfL7CMpxIBJJGcKQzqqS1enduw+9e/cha+4vBH74rtp6OoShboiiIgqr2G4B64B1RUW0TjFJuDEYOHBQ0hCG34AlQMdqyj2zfsL4dR52j5613rfqZEx8EOOfJUnrKCkpvfbG+unQVmSaJvfe+yDt23fgjjtuQSmVeqe4goICHnrofh566H523703gwcPYe+9+9Gjx240b9680nmOUoo1a9aglEPLlq1q1MejjjqWL774jEmTXgHcc6ubbrpdr4zaQBQUbOC6667i9ddfBeDCC8/h/fc/ga7dKL3yOrJuuT7p/rK4iJyzTqHgrQ+gFgIPjL//ImPC+JT1ghdfBhVW4K2oU6fOXHpp6qAWLX1LlizmlVdeRErJzZddnfLvwljxH7mnnEDB5Hdq5e+iymP8/RfG8mWVtn2Txn59++5TJ/3RNE3TtMYonRCGaCj1dbVthXf6O3g/+2SL2hBKEXj6CbzvvEXpzbcTGXkkGOXjWYhEyLj/7rQDGJwmTZDxRQK2xCygtmbtzZz5NTNnfl322OPx8L//XUHnzl0YPHgoeXn5tXQkTdM0Tas5HcKQxLx581BKuauVCUHfvn3p1KlTrbTduXNn+vbtyzffuJdnlFLMmzdvuw4O+OKLLyo9HjBgQNr79u/fv1IIw2effZaktqbVju8LFjPpvx9w10J2bzY5qPJ5Z/GFgBNBDBWpCpPOuma24pJOQ/FIA03TNE3TtG1ZaTDCJ18u5KNP57N2fQlSSmIxC4EgFI7iOApDuoNkpATHUSgFTvxzWWKAj+MoDEMgpcBWinA2hPIE0SwJhnvyJUwBBvhME49puG3ghikoIByzCHg8GELgKFU27T/m2PhN97wsYtsopbBsB6QgajtuEAPQJDOD4/vsxv5dOja6gTyOE6PU/pYi+z2izt/YqgSLdQgEYIIChYNBhlu/LDQhHD/NTUwCE4DEDWKoOOBTAE68LHFyDG7gggF4USRWN5HxPXwILBQOCguFDVhIMhFk4hVZeGQbcsyD8YpW+GRHDFF9qrOmaZqmAcScMGGnmKhtsTwyhwXhjzCESaZsihCSsFMECjzKDyhCTiGWipBjJAb8Vn6PN4RJVIUwhQ9bRTGoPHFCIMkxWlHirMFWMYSS8cBO8IlsYioCQtLU04W+WSfR1OxQL8+Dpm0vZs2axbPPPsucOXNYvXr11u5OlVasWMG5557LggULktZbuXIld999N++++y6PPvpo0lW0NU3TNG1z3XvvvRx//PH8+eefLF68mDPOOIOHHnpIv+9shk8+qTyI9qijjkprv3322Ye2bduyfPlyANasWcMvv/xC7969a72PWu2LpTFY3OPf/Iny2rYp1f0E5TiISDiNEIYtn3joNEu+irRcu3aLj6FtShQWUpCiTk6SVS0biwMOOJAJKSY8vw+ck6Q899QT2fDOR6h6ODcxfltIxvhxKeuFR5+E3W2nOu9PQyCE4KKLLqVXrz0455zTWLsZrwlz5sxmzpzZZY8DgQDNmjXH4/EQjUZZv349wWApo0efxAMPTKxx+3feeS8//fQDRUVFPPzw4wwaNLjGbWi178MP3+eyyy5iVYVAmTlzZvPEE49y7rkXEDrnfLwzPsD7bfKp7Z6fZ5F19WWU3PcQbMn9eKXIuuoyRDSatJrdth2hk0/b/ONoaYlGo3zwwXReeOE5vvzSHeedkZHBWT/MpdPk1zHnz0u6v+eH78j+3wUUT3gM6mCRDM/nmwb3fl1FvYoCgQC77dar1vuiaZqmaY2VN41Q0kgomLLONsFxyBx3R601Z6xeRc45p2PfcQvRwUOxO3VGrliBb9pkjBX/pdVGZMhBlN56J0369anRsVVGBqEzziHjwfvcx8AJQGnSvTZfLBbjzDPP0eELmqZpWoOgQxiSWL9RslP//rW7Sn3//v3LQhgA1q1bV6vtNzYLFy6s9LgmAwt69OiB1+slGr9Qunr1atavX0+TJk1qtY+allAYC/Lwko8psSMVAhU2UjGIIfEYhYoP4JdC0saXx1VdhuOV+uVY0zRN07Rt278rNvDYs1+wYlUBpcEohpRIKbCEQAhILKBiVwhiSEzeV45CSjd0IRHMgAJlQGkrAytL4jgKIQFHYBoC6ZFEbZuwbeMAPtNAJgIXhBveEHNsfKZBKGaVhTQ4jkKYAr/HREiB7TiYhiRq2SgU7fJzOLznzvTt2JYmmRlb58msIaUUUbWYEusLSuxviTnLsClA4MekGTZFSHwIPDjEUJQAEkUsHrhQHqjghidsHB6mEGXnuYmTYBXf7kERpTyQQSDxY6OASLymHa9v4KU9SgRxVAkGLQjIXfAZXcg298crGl/ghaZpmrZ1rI8tY3H4R/4JzSKmwkSdMEFnA36RTZbRHBEPTwg7xW54k3Dfo0zhJabClNircd/3nHiAkEsgEVh4hB9bRXCUjRRuucIBBD6ZhU9mEXIKCDobiKkwHhEgoorJNJrSyXsQ7Xx7EJDb3grDWgOS/uKE25R58+YxY8aMrd2Naq1bt44xY8awdOnSStv9fj/t2rXDcRyWL19OJBIpK5s/fz5jxozh1Vdf1fc7NE3TtFqXlZXFiy++yHnnncesWbOYO3cuhx9+OGPGjOHoo4+mRYsWW7uLjUJpaSk//fRTpW377rtvWvsKIejfvz+vv/562bbPP/9chzA0EtFg6hAG06dDGLTKUl3jdpSCUChlCIO/FgI+UocwrHFv3ujr8rVKFhdRmKJOTk7jv2609977kJmZRWlpSaXtOTm5HHDAgQzedz9G3nwdBKufeGMsWUyTffek+JEniB40vO46a1lkX3h2ygnaTk4upVffUHf9aKAGDhzExx9/xRlnjOXHH7/forZCoRDLli3dZHvF1U5rIisri+eff5W8vHx97toAbNiwnuuuu4o33nityvK7776NESMOpWPHHSl+5EnyD+iPLCxI2mbgpeexeu5O+JTTN7tf/ldexFvFxPqNlV5+NdRCyJFWtUWL/uSll15g0qSXNwl1CQaDvDTpFS5+9CnyDxqICCc/E/K/8RrK56Pk3gdrPYjB+8WmCwBeAvTCDWP4WkoWOU6l8j322BOv11ur/dA0TdO0xszvT31OFQ2luvKxbfC9NQVzYfJw/s1hLFtK4Lmna7yf3bYdxQ8/jsrLRwUCiDRCZosefwanZStie+wJXi/+V15ErlnN78Dvm9H3dHXvvrMOYNA0TdMaDD3rN4lEKIKKr7pa2ys+JNpL3GDbOPRhexKLxTYZeNi5c+e09/d6vbRv356//vqrbNuiRYv0oEStToTtGOP++oA1kWKgfJpZJeXzzsofC9zVhZW7xnCG9HJVl+G0DegPB5qmaZqmbbvWrC3m069+48NPfyUYiiKEwLJs97xIlH/ekkLgxE+eHEchJWWhCYlTKikFSilsDxTlQqiZgWOCcBQY7mcrv9fE6zWJWlZZu1HbRgjwGAZhy0LFgxgs28FvmvhMg4hluwENqnzGmlLQPCsTU0pMQ3LSXr0Y2HXHRhEEYKtSQvZsLLWaYusLos4iwAvEsChAYKKIEWMpCgtBNkCFMAVwCCLJrNBq4iQ3hhuqUDGcwULgxSHi/tvGSQI4OChilIc3CCQmYCLIwqEAhY2BO6gwU+5JjjmETGMvhPDU3ZOkaZqmbXOUclgY/oQ/wh/j/D979x0fR3H+cfwzs3tFp27L3cYYbIzpmGqaKaETeiCBhA4hBFKBX0IJoYQWAoFQQiDUQAgl4NBDx/ROMMamGePeVa/t7szvjz3Jki3dSfJJLnrevIS0u7O7j86Sbm9v5jsERHUpCV1NKpiFQpG1TSz1myjR1VQ6gwnw2jxvATgqQtYmiagEnk2ycvgQOEQo1QNoNIvC6wocDD5RXYajIlhriapSjAoYEtmEzRMHEVPllDsDcZTckhdidUgkEiTzDOzoDb/5zW/avA8Si8X49a9/zVFHHUVJSQkQdjh+8MEHufbaa1vCGL755hvOO+88/vrXv66WuoUQQqybfvvb37Z8PXToUKZMmUI2m6Wuro4bb7yRG2+8kfXWW4+RI0dSWVmJ63bvOlYpxeWXF2+mrzXRl19+ied5LcvDhw9nwID8A5tbGz9+fJsQhhUnrxBrrsFVlUwjvFuazX1e8euNRo1afQWKNZIu8P6CNQayWWYDaSCT+9z6o26PvRi33Q6rXEuhEAaVSkFTE5SVrfK5RE42i0qlqC3QrLKysjeq6VGxWIxdd53IM888yaabbs5ee+3Nd76zD9tssx2RSPjeT9n/PoL77sl7HF1fR8VxP6D2safxd5zQI7UmbriWyEcfFmzX9JvzsV14jl+XDB06jEmTnubWW2/m6qv/QKoTA3W64ptvZjBv3lyGDBna5X032mhsUWsR3dPY2Mgee+zM3LlzOmyTSqU455xf8OCDj2GGDafh2r9QefKPCh677LdnY4YMJbvfAV2uy/l8OmXnn1uwnbfZFmS+9/0uH190zldffcGEAjMt//3vt3L66T+l8aJLKf/tOQWPWfKPu1HpNA3X3Vi88AzPI/La5JVWb5j7OAXI7H8QX1x5DW+//Wbu4y0mTOhcCJ8QQgjRV8Q6EUqaSRf3NcUaKQhI/PGKzjUdPARn/rweLcfGYtTffje2X38A/LEbF3wtnNnvADKHHdlmXcNV11Jx8o/41PbszBDbbbdjjx5fCCGE6Arp8ZmH47TtYOv7flGPHwQBsHzQ0Yrn60tmzZrV5vGNx+NdDlAYPHhwmxCGGTNmsN122xWtRiGaPbbgA96v/4ZwTuVQuy8hVKuNtvnL8Iu4jnDCiJ3YuHxIT5YqhBBCCLFaTflsNnfd/wZLa5tIprLEoi6eF6CUQqkwbMHaVqELWoXrCGd7crTGNrexoDQ0DtZkKzTWURgnjMNSGqwTXnL5WCK0mk0qF7iQ8QMS0Qia5SFaFgisJea6OFqTzIadpTO+T2At2DC4Ybv1hrH3uNFsNLBmNTyKnWetwTeLWZZ5ijrvJQJbj28XY0iicFFEciEJUTQRwBLk5tMyNOUCF5ofHQ0EufY6N7t37jy5wAXbZi4uiyKGwsMS5C6Fw4AGRQJLY24m8SwGA1hc+qNVCZpBlDo7U+ZMwNVVRNSQtSLoQgghxOoXWJ/53jRq/bn4NstSfwYL/S8oc/oTdcIBzZ7J4NkkDhGUCp/TkmYZAMqu/HzTHMoQPv+Fz69KtZ1JSSlNqe6PVi5NZjGBzWII0Lg0BkuwBERUjNHxXdkscQARJTOfit6lera/wxqvtLSUTTfdlM0335wtttiCzTffnNmzZ3Pcccettppee+01Xn311ZblSCTC3//+95Xew0gkEpxwwglssskmnHTSSS0DOl966SXeeustdtyx5zqb2B7uKCOEEGLN8uijj7Z7/0Up1fKcMHPmzJUmUuiK5n4Q63oIw1dffdVmefTo0V3af8XJKVY8nlhzRYFCwz6XVvcj6I1ixFqj0L1vYw06m2FYnjbJseNoGjZ8lWspFMIAoBcvwkgIQ9Go+noA6gq0Ky+v6PliesGFF17MVVf9qcOB9eljj6OkQAgDgDKGskt/R+2TzxW7RCKvvkzi6sLXKv64TUmfcErRz782cV2Xn/70ZxxwwEGcffbPmTz5laIe/803X+fww79X1GOK3lNWVsZhhx3JTTddn7fdK6+8xIMP/pOjjz6G7HcPIfWjEyi59668+yhjqDjtBGofnNS1MJbGRipOOxHViWDWxquvhW4Gz4nCNtxwDDvsMIG3336zwzZz587hiScmcdhJpxF9+UVizz5d8Ljxh/+FymSov/1uKEL/Avf999CNDXnbZHffk0GDBnPwwYdx8MGHAXJfVQghhFhRNBot2CaTzYIxoHXBtmur6EvP4375RcF2S998n2DUhkSf/A9lF/8O59tvil6L1Zr6W+/EH7/t8nW5MIZ8vO1Xvv7OHnQw9Xf/k/m/PRvmzC5qna1tv/2qB5AKIYQQxSJ3jfKorg5np29+A2z+/PlFPf6Kx2s+X1+0dOnSNsuDBg3q8jFW3GfJkiWrVFNfEI2GwR+u23cDQLpqasNcHpj7Dr4N52l2UAS5YIXmgXwrUaBbEhkUGs1+gzbjyPW2wVHr7gvHZvLzJXqK/GyJniQ/X6Kn9JWfrW++XcwzL37KS69Oww8MxliMMaTSXssb0FprtFYEgWkJYnC0xjbHVtnwzWpHa/zAkCmF5EBFEFNgAGVRgKs18ZhLyvewFnxjSGazlEQira7AQoExlEQjJLNhHS1vhitwtCbmugyrqqDJy2ItHLT5WA7cbCyDKtbcDobGpmjy32Vx6jlS/jSywRwMHg79CLsBZ3FUGWGmRArI5h5jJ+yHYCF8hAyGFIpIq6NrwAfihPO2LW+rcLFoaAlnUCil0ZRibGNuvcVisHg4lBLRg/HtMiAg7owl4YylLDKeMndbtCrp6YdKrIK+8rdL9D752RLdZWzA58nX+Tw5mcZgKRZLYD2SZjEaTYBHhaoh7lTgkw7vzajw503hoJQiZWuJqbKWgWGtKRwCspQ4FaRMPW5LgEN47RDRMRxHU+70I2HKqfXnUqLLGRgdQ1SX0C8ykvViW1HirBsd5oVYW+y5557ssssubLDBBugVOuzMnt1zHUA64/rr23ZAP/XUU/OGSG+//faccsop3HLLLS3r/vznP/PAAw/0SH0vvPBCy9ddmblbCCHE2q/5/ljra+LWX3d3MElfCticMWNGm+XBgwd3af8hQ9qG9s+dO5dMJkOsWLO5ip7jeYXbRCKF24g+ZcXXKiuyxqLSmfxt4sUJe7QDCgdP68WLMOuPKsr5BKj6MH6htkC7ysrKHq+lN4wZs1He7f4225HZa29iLxQOV4i8+zbO59MJNioUf9N5es5sKk4/CWVM3nZWKRr++GcZoJ0zatQGPPzwf3jyyce5/PKL+bITg4o6480335AQhrXcueeex1NPPc6MGV/nbfe73/2WPffcmwEDBtB4yRVE3nsH97OpefdR6TRV3z+curvvx5u4R+FislkqT/oh7tQpBZumfnQC/rbbFz6mWCU//vFP84YwANxww3UceugRNNx8G84B38GdPq3gcWOPP0bskQfJHHn0KtcYfeXFgm2y7fz89aXXv0IIIURnaK2Jui7ZPJMgZwCSSViHgx/j991bsE3Tby4g2HAMANnvHsrSvfYhcf01JG68HtWZe4+d1PDnm8gecFCbddnd9iD64vN59/N2aH+CgNnjt+WOgYN6OISh5yYnEEIIIbpK7gznsWJHs1dffZXTTz+9aMefPHlym+WamjV7VtWe1NTU1Ga5pKTrA3ASiUSb5WQnEmyF6IpaL8kV056kyc+0dLoPWsUu5OuCZAgHCSpgXPkQfjbmO30igEEIIYQQfc9Lk6fx4KT3qKtP4fmGeNwhlfRQSqFUGGAMYeiC1uE6a3MfWLSjw2AGwuurdKUiWeHgJRTWya10FGhwtaIkFsHRCvwwUcBRisBYsn5AxNFkgwBtw+swLzDEIy6JaIS052OsxQsCwOIFBkdpfGMYUVXJ8RO2ZusR7c/Ms7plg29JBVPJBF9T7z2PsSm0iuOZxRg8FC6GZVgyNL/sXz6LoQJ8DEm0bX7dpQkf2ABFtNV1beuYsebAhdbhYgkMydx+uc7EVqOIoFU5xgYYmgCFo6pxVCn9ogdQGd2TmDOiBx8hIYQQ66LA+vg2A1bxQcMkZqTfxVUxypz+aKWp9+ejcXBVFM+mWeLNpsoOzj11tb1ro3LPfRaTe440qBXv0yiocodifUvGNIBVYBWOihDXZRgbkDL1BNZjRHxLdqo8jpgu7a2HQwjRjvXWW291l9Cu6dOn87///a9lOZFIcPLJJxfc75RTTuHuu+9uea/jww8/5KuvvlpptuxiGDYs3zy7Qggh1mWFBovIYJLCVpwcoqshDDU1Nbiui5/rlGyMoba2tlsTVxRT84QOon2u66Bt/kG7AJHSOI48lqIVrfP/XbXWorL5QxicRElxfkeHFP57Fa1diu7DP8PFDpF1Uo0A1BVoV11d1Wf+Dmeuv5HIXruhFywo2Lb0oftJX3xZUc6rli6h9AdHoBcvLtg2e8aZ6F12ovBcrn3L4YcfxsEHf5eHHvoXf/nL9Uyd+ukqHe/tt99YLT/3EhZdPNFoGddffyMHH3xA3nbLli3joot+w+233wXRClL3/4uy3XdF1dXm3U8lm6g89nuk/vwXvGN+2HHDVIrET04m8nLhAfWmfw3exZf0mb+5q9MhhxzMeuuN5NtvZ3bY5tNPP+Gll55jv/32J/XAQ5TuORG9bGmH7ZuVPP0E9phj8rbpzO96bPLLebcH64/C3Wh0weMIIVYPeU4XYs0Si0TyhjCkgZiXwka7FkK4tvyuq8WLiD77VN42pl9//J+e2fZaNFqOf9HFNH7/B5T86he4r0/u+ACdYKNRUtfdgD32Ryu/pt16y/z7xuPobbdpU9/MmTM58shD+eKLz1eprkL6969ho41Gy/sTfdTa8nsuhOhbJIQhjy222ALHcTDGYK3lo48+YsqUKWy22WarfOypU6fywQcftAyEcRyHrbbaatWLXkutGJjQnVkdVtxHQhhEMVlruX3Gq8xOL8NiUajc5/zhC83bFaDRDIlX8Zux++NKAIMQQggh1iHWWqZ/MZ/Hn/0fb7//NVjw/TBIIZ2ymNwM00optA4DGIyxKBUmHwdB2FnVGIvjKBxH4xlDwxCFV0bL2H9lQKFwXY2HwQBN2SyJaARXK7JB2FArhRcEJGJRfJM7f65Oa8F1NHFc/MBQmYjTlMkScRy2X384h241jq2GDyHirFk38qy1pPxPqPX+Q8r/CEMSzywMB4/iomwEQxpFAq001noYm0YpH2gCSll+ZaqAIPdBq/UGi4/CwRIQBi+E2zUlucAF03IMpRy0DddbFIFNoQiACJoyHO0S1VtQHT2QuLsBUT0ER8ngVCGEEJ1nrWGhN4MZqXeZnfmEwAakgnqytolyZyBxXZ573jOkTC1aOaAULhECG1Drz6fMqc4dy7Z5g1bjkjVJIroEzyZxbLTVdotGo5VDP3c4KVNHY7CEjG0iqipoDJYClkp3MGNKdmH9km1wlcxSK4Ro3wsvvNBmeb/99qOsE7O6lJWVsd9++/Hvf/+7Zd3zzz/fIyEMQggh+p6hQ9fM8NG10Yr9Ero64YRSilgs1hLCACtPYiHWUNlswSbWjfRCIWJtUqjzuLEGlU7nbWPjRboHUVGBjUZReX6W1eJFxTmXCNXXkSY342celZVVvVDMmsEOH07TQ49SeuSh6IUL87aNXX8d0b/fRvakU8ic9XPsgIHdO2ltLYnvHY4z7bOCTf0NR/O9GTPY7obrOP74k6is7NoAoXWd67r84AfH8v3vH8Orr77M/fffx+OPT+pWv81p0z5j8eJF1NQMKNxYrLF2220ixx13Avfcc1fedg8//BBHHfV99tlnP8yoDUj+/U4S3zscZfP1xASVzZI448dkX32F9CWXYQe2DS5T335L4oQf4n7wfqfqTd1yK7Zf/061FavGcRxOO+10Lrjgt3nb/elPV7PvvrmfiwceovSIQ1CNjXn30dOnrXqBtbU477+Xt4m/x56rfh4hhBCij4jFYjSkUh1uzwCqqSnvOJy1mfvE46g8IRQA2R//BMrL291mxm5M0xNPE/nnfcQvPB+9pHCA4IqCTTYlefOtmK22bn/7LrthRqyHnvVt+/Ud+yPIjdHzPI8LLzyPv/715i7XAbD99jtwzDE/5KqrLmfevHkF22+99dYSwCCEEGKNIiEMeZSXl7PVVlvx/vvvo5TCGMP555/Pfffd16kOch1JJpOcf/75GGNaBiJtueWWq3TMtV0m0/btpUik629ER6Nts7nSBd6UFKIrXlw8jf8u/DQcuAfQ5v/kDWNovvyPOy7nbLQv6yX69WSpQgghhBC9ylrLQ4+9x4uTp7F0WRNYiEZd/CCLVmBywQfhwEfQSmFyV07GWLQOZ34yJmznRSFdDslqFxNR0NzRQikcBaXxGBaLn/VwlMJYSzLrEXddVGBaBlgaIDCGRMQl5fkExrTUC+AHhrJ4lJJohJqyBKftuh3bjRy+Oh7CDvlmGY3+a9RnnyNjZuCZ+YAmogbj2wYUDlolsNZgaCAMSHCwNo5tFZYAHtC6E2UYuGDwUESweC1tLQZNDEuS8Ao3DGhQKpILXGgiDGcwWKuwBEQYAKoEQx2aOCXueEqc0VREdibubCQ3xIUQQnRL1qR4q/4B5qQ/xWKJ6VIiyqXWNmGsoT5YQJNZSj93OI5yMQToVre7HeXgW0M6SKHQueCi5SFLSmnAp9zpT13gE9hsSxCDxRDX5S3torqMmMkwOD6WcYk9cVSEEl1Bv8h6YfCDEGuadbW3ylrqlVdeabO8yy67dHrfnXbaqU0Iw0svvcSPf/zjotUmhBCi73rxxcKzworOKcaEE/F4vE3wgkw4sZbwvMJtutH3RazbtM4/YYc1BjIF+jvF4sUpRinsgAGoOXM6bKIXSQhDManaOuo60a6ysqLHa1mTmC22pPGVN6gYV3h2cdXYSOyGP+M+8TiNL02GykqoXUbsjttxPvgAHAdvn33xvn8MtBO4rmd8TeLoI3E+n17wXNZ1efq003n8/87m8aee4Oqrr+S4407g9NN/ynrrrdet73VdpZRi4sQ9mDhxD6699npeffUVXnzxeV577VU+//xzgiAofBDg448/Yq+99u7hakVPu+SSy3j22adZsGBB3na/+tXPefPN9ygvL8f/zj6kr/wjJf93dqfOEX3gfiKPT8I74nt4e+4VhjO/+grR+/+ByjPYr7XMT36Kv89+nWoriuO4407g6quvpL6+42fDd999h1dffZmJE/cg2GFHmh6ZRNm+e+U9rirC9Yo7+VVUgb9V/h756xBCCCHEcvEC9y7SAAWCltZmkSf+k3e7VSoMOchHKbxjfoh3wEHEbv8b0bv+jp49u+C5zfARZH75a7LHnZD/3qTjkLrschInn7BSYIQZPJiGn57ForlzsdZy551/73YAA8DDDz9GRUUFDQ0NXHjheQXbb7XV+G6fSwghhOgJEsJQwCGHHML77y9PRf3888856aSTuOmmmxgwoOupu4sXL+bMM8/ks88+Czv05gYIHXrooUWsuuv+8Ic/cM899/T4ec4880zOOuusldav2BHB68yb1SvIrpDM3p3ODX1NNtv+TcOO1vdVtdkkN3/5AmnjsXw+xLY66tfcvD6qHI4YvC2bJYb3+ce3r3//oufIz5boSfLzJXrK2vyzFQSGqdPn8vB/3ufzr8IOFL4fhK9zMl7La53mgAVoP3QBcsvWkqpWpPorrFIYFzA2vP7SCqvDm8+eCYg4ThiCZS1aKQJr8QODqzWeMejcgQNjiDkREpEIad/HWIsXGPxcIEO/RIJ9xo1m5w1GMqSyfLX/e1hr8exMMuZrUsH7NJnJKAsojWfno3L/eXY2Fg9FItzewsGSwaJarluxzXFhGSACNN8w17mvE4QBDc0HsigiKGJYUoThDDq32UURQ1OJoRFLCkUUKCGqh1PhnkKZswuOynUONODlHmuxblndvyti3SU/W31b1iSZ600lbRow1uebzHs0BIsoc2pwVPjGcFOwFGstLlEUisB4LPa+pdoZ2ubmjM09ETq4+KSIUELWJlG0HehgLShcqp0R1Ppz8Gy6JQDKIUbKb8CzKRSK4ZEtGV96FFG9fFZb3wOQn1shRMestUyf3nZgx9Zbtz/bSHvGj2/bwWT69Oktr7WEEEIIsWaQCSf6sM70a4lKCINoS6tCIQwW5WXyt4kXKYQBsDUDIE8Ig1q0sGjnEqDq66jtRLvKyqoermTNY4cMofGJZyg7qHMDop2vv6Jy5FC8/Q7AfeM1VH19y7bIpEfx77+Ppvv/FYY0APg+0dv/RvwPl6AaGjp1jtRlV3DFY8uDERsbG7n55hu59dZbOPTQwzjzzJ+z9dYyMGRFpaWl7L//Aey//wEApFIppk+fxuzZs5k3by5NTY14no/Wmurqavr168cGG2zI6NFjSCQSq7l6UQxVVdVcffW1HH/8sXnbzZ49m8suu5irrroGCGcCVgvmE7/2mk6dRzU1Eb3nLqL33NXlGv2ttib9+0tpbGzkr3+9mR/96DgGDRrc5eOIrqmoqOC0007nmmuuytvu0ksvZrfddkcpRbDDjmROPZ3YbX/tsL1etjS8Nl+FALTIs0/n3W61xt9tYrePL4QQQvQ10QJjuTKE13PrpLo63FdeztvE330P7PBOThhWVUXm7HPJ/PLXuK++jPPaZJz/fYz+4gtUUyPESzDDhxNsPR5vn30Jdp3Ybihhu3UcchhNVVXEr7ka5+23sBUVZHfZjVu23po/Hrgv8+bN61yNeWy99XgqKsL+pMccc2ynQhjktbYQQog1jYQwFHDEEUdwxx13MHPmzJbQhP/9738ccMABnHHGGRxxxBEtFwT51NfX8+9//5ubb76ZhlY38pVSrL/++hxxxBE9+W2s8Va8gb5iR4XOWHEfuSkviiGwhmtnPMsSryk3B3DntG6nUYyvHMkPhu3QAxUKIYQQQvS+VDrLvQ++xcdTZrF0aSOO62BzAxaVAj8wWNt+6IIxFkdrrAqXA2MJyhWN/R28hEJZhc1deSkg6mpwVBiuoBQZP8BCS+CCA2gFvjGURqNY38M3FqxtCX9QSqGVYkhFGYENj3zU+M34zrgNKVkDZiKz1pIy79PgP0naTCGwdQQsyz0CEawNgww0YcdKQ9i515KieZhoaHnggs21Xf5IBrlgheY2zXs4QBRLc6idbjmXIcASYPEJCAAfTSmaUhxVQUyPptI9iIgeRFSNRCm5xSCEEKLrUqae6amXmJn9gKwJZ6hKm0YytiEMW1CaMt0frVwythEFLYOPHRUhsFnqggUoHCymbdCCUmDA1XF80gTWawl0sBiUUjhE0MqlvzuKlKmjIVhARIfPo1q5bBDdiZGxbal2RsigZ7H26CgxVvS6OXPmkGo1+14ikWDo0KGd3n/YsGGUlJS0HCOZTDJv3rwuHUMIIYQQPWtdnXBCghILczsRlpG1GiuPpeiCwBoo8LPla7dov6NB/xrydcu3CxbI34NWVvWxcJbW0vHc38vF46V983HfbgLxcZvifvZpp3eJPPNUu+vd1ydTOXIo6e8fC55H5PXJOPM7P3gkffiR/Hejcbz55jkrbQuCgEceeZhHHnmYvffel3/840G5b5iH40TZZJMt2GSTLQq2XRN+7teEGtYF++13EPvtdyDPPPNk3nZ/+9tfOeSQI9h22+0ByP7fhdhFiym5964eqy0YsR519zyAUS7//Oc9uSCIyzn44MM4+eTT2Gab7eR3ugedfPLp3HzzX0gmkx22ee+9d3nssUkceOB3AbB775c3hAHAn78Q04UgjTa/68ZQ/uwz+Y+/9XiyiXKQvxFCrDXkOV2I1StWIEAyDfh19Xir+Lu6Jv6uR597DlXgHnH6oEO7VXt2591h593zNwqAoAvHnrAbqUd2g2yWjDGc/pNTePKiC7tcW0eOOuoHLd9reXk1P/rRidx7751599lssy3XyH9bsXrIz4IQYk0gIyQKcByHiy66iFNPPZUgCFqCGBoaGrj66qv585//zA477MBmm23GhhtuSHl5OYlEgmQySUNDA1999RVTpkzh7bffJpvNthqYFB7HdV1+97vfoXX+pPN1XWlpaZvl1p0SO2vFm3ISwiCK4dkFn/Be7YyWfsudnce3ub0CBkTLOXfDA4hq+ZMrhBBCiLVbJuvzydTZ3PvQWyxcFM4o4xuLDYLcaH8VBh5oRdAqiKF16AIWLOG6VMKSrNH4MYWJkDuGDWevVuBoTTwWwQsCPGNRhGEKWT8g7jp4JgwwQIXBDcZaEpEIad9vCWtI+z6BMYDCoth4UA2Hb7UJmwwZuLoeRgACu4ym4HUa/VfI2s/x7UIUURz6Y2jMBS44WDwgBWgsLooI4VVp2PHDkELR+rVPGLLQ+v+t1ykiucCF5a9BNSWEj1bY2du2XPU6RBmOVWkC24BDf0r0FsSdTShzdyOqO5nGLIQQQqwgsD4Gn3TQwBuN91AXzCOmyijTNYAlZepwiIJSNAZLyJgm+rnDc89RbTs/OipKYLPEdSkZ24Be4Za3BRzlUKmHUhvMxbdZHFwMPnFdgVYu1hoytomADBvGd2b70h/iKBetOjc7gBBCdGTGjBltlgcP7vqMeoMHD25znBkzZkgIgxBCCLEGKcaEE+kVBlxLX4e1hOcXbGLd1R8CLNYshfqHGWNQKwSzrKTAQIauMDUD8m7XCxcW7VwCVH0dtZ1oV1lZ1cOVrKGUoum831H5o6OLdsj4A/d1eR9v/DY0/Okv/KkTdWy44RgZrC1EO5RSXHXVn3j99ck0NNR32M5ay69+dRbPPz+ZaDT3nsAf/4wtKSHxt1uKXpfp14+6fz2KGTwEay133PE3IAxSe+SRB3nkkQfZaqutOemk0zj00COIF/E5V4T69+/P8cefzC23/CVvuyuuuIR9990f13ULXq8AqMWLoQshDK25H32AXpT/mif7nX27dWwhhBCir4p2IoRBNXUcyrQ2i77yUt7tViky+x7QS9V0QTTKeb/+OU8++Z+iHfKMM37GSSed1mbdWWf9gvvvv4egg6CIzTbbgsGDhxStBiGEEKIYZERwJ0yYMIGLL76Y888/H5UbVAThDcBMJsPkyZOZPHly3mO0Dl9ovXzJJZcwYcKEHqy+c3bffXeqq6t7/Dzbbbddu+v79evXZnnBggVdPvaK+/Tv37/LxxCitWXZJu6e8wZZG+RmDw61nTt4Zc0tNYq4E+UXo/ahMlLSk6UKIYQQQvS4xUsauOP+1/nqm0XU1aeIRSOkM1lQYHJhCxC+1glfN4G1uQ8sWuswmAEIFKRqIFnlLL/KsqBtbj+tchNXW5qyHjHXAVTLsQECY4k6mmxg0LnXVxaLUpp4JAIoasoSZHyfwFh2G7M+B2++MRvU9FstnaGstXh2Blkzl2TwOknzZi6QIovP4tzs3R4e3wIBijIUYbjE8sCFJJrmALtcUgUBFh/aBC4YLD5KRbA2i211NRsGLgSADzgtx9FEsDgoElgasQRoyrAo4npzKtx9KHN2QSnpNCyEEKJ7PJNmjjeFr9NvURfMx9iARrMYhabKGUpUlwCKtGkkIIsmkgtgcvBsmmXBHBQdD1SwFhQKY4OVwhMUmriuoB8ujWYRGdOEIcBiaQjCjnUJXclG8YlsFN8dR57vhBBFsmTJkjbL3QlhGDRoUJsQhhWPKYQQQojVa8XAhK5OONHc76S1FSexEGuoAjPaARCR15eiLa0KTNLjF57ZzcZWfUDo/Pnz+PTTT6hfuoQ6YGHuY0HucwR4G9AL5q/yucRyqr6Ouk60q6io6PFa1lTZffbD22ECkbffXC3n9zceR939D/PWJx/z2muv5m0bj8f56U9/3kuVCbH2GTJkKBdeeDHnnvvLvO2mTfuMv/zlOn796/8LV2hN06VXYquqKb368qLVYwYMpO6fDxOMHgPAG2+8xmefTV2p3UcffcjPfvYTLr74An7zmws5/viTilaDCJ1xxlncddfteV87ff75dO677x6OP/4k7IDCIQx68SK6Oz9u9L/PFGyT3We/bh5dCCGE6Jti8fxjZzKAamrsnWJ6k7UFQxj87XbADly9E4i1Z+bMb7jvvruLdrxzzz2PX//6/1bqq7v++qP4+c9/zbXXXt3ufmed9QsJOxRCCLHGkRCGTjriiCNwHIdLLrmEZDK5UhhDIa0vAqy1JBIJLrroIg455JAeq7krdt55Z3beeefVdv4RI0bgui6+H84UkE6nWbp06UrhDPnMmzevzfIGG2xQ1BpF3+KZgD9+9TS1fpJwOJ9tE76wfC7hjikUhw8ez3bVo3q4WiGEEEKInpNMZXnzva954NF3aGzKYAKDsRY/8MNQBEArhVUWayGw4LQKXYAwoMFxFMQ1yXLIVCn8WKtrKQ1YhXYUJdEIad/HWItWCmMtGd/H1RrfGJzc+XxjKI1FUQRkgwBrLYExBErhGYOjFa7WVFWUc9wOW7HD+iNWx8OHtZakeYMG/xkyZhqBXUZAXW4QaRRLFoWLJpa76gxnvQsDFxIsvwLVQIAJ34KAlpnAFeARdonMtlpn0cQJ8AmDGlQuikGhKcXQmAt+yOSCHgwONWgVQ9GPhLMNZc7uuLqGqBolN7aFEEKskkXe17zT+E+SphaNS1SXkLaN+DaLQrHE/4YSXUmlO4TAemDb3k91VRTPpIip8vD5slUwE4BSmkAFlKoBNJqFYbiTciB3rRJR4Rv8UZ2gnMFoFlPtDmdIZBMcFaHcGcSQyCa4KtrbD40QPUIVfstC9JJksu0MLiUlXQ/rXXGfFY8phBBCiNVrxckh5s/v2oDlxYsXt/STANBa98oEGmLVKV9CGETXaZ3/XnvQiZ8rG4utch3PPfcsv/71zzrcHiN8d0J3YxId0TFdX09tgTaJRIJIH/3bkclk+OabGWx64SVUH7R3r5/fH7UBdQ8+hu3Xnz/+8cqC7Y877kQGDRrUC5UJsfY67rgTeeSRB3m7QLDKddf9kYMPPowxYzYKVyhF8uzf4G++JeVn/RhdW7tKdfibbk7dvQ9ghi/vM3DTTdfn3WfJkiVEo/KeQU8YNGgwp576E2644dq87S6//GIOOugQ+vcrPCGfXryo2/UUCmEIhgzF32yLbh9fCCGE6ItiBQIk04BqauqdYnqRnvE1zrcz87bJ7r5nL1XTNf/85z8wxhTteLvssluHfU7POee3NDTUc+edt7fcG4/H41x88eUcdtiRRatBCCGEKBYJYeiCQw89lK233pqLL76YN954A6BNGEMhzWENO++8M7///e8ZMWL1DAJaE0UiEUaMGNFmNqcvv/yS7bffvlP7Z7NZZs2a1WadhDCIVfH60i/4uOFbDEGbSYWVXT6/cPO8xKwQxmABB8WY0kEcPbRzP8NCCCGEEGuiL2cs5B8PvcXM2UtIpz2iEZekH6CUwvMNJje4S1mLozV+c+iCBa0sWiuMCcMZMlFL4xAH44B1FAqLMmCVCq+vNBgFgbU4WhEEFg0tQQwRRxEYMLlBl83jyuIRF1dr0rmgBs+EIRGj+ldz+Fabsv36w6ksWfVZobrCN/NpCl4lFbxJxn5OYJeiKEFTiaEJTQmgc4ELGSwOts3Lcw1YDEkgusJ6H0UUS3PH7ObAhQgGjzCcoXm9g1YJjG2ElmtXi8VDU0qEwfgsxpIlooYTU2MojexAqTMBV0lHbyGEEN1jrWWp/y1L/G/wbZaUqePrzDsoNGV6QPg8bi0ZOx+Ng6MiWCxJU4f1LRHV8fN2gIdWGmsNCmfFE1PqDMACSbuIwPpYC66K4xLDMykythFQjInvxpaJQ3GU3B4XQvSsFQMTYt0YLBWPt/27KCEMQgghxJpl1Ki2gfwrTh5RyIrthw4d2q1rBrEaZLN5N1vXBQm3FSvQWufdbluFsnQovurvedTU5J9ROgM0ABUN9ZBMQiKxyucUoOrrqSvQpqKisldqWZNks1keeOA+rrvuj5SWljJ58jukfnQiJffe2Ws1eDtMoO6u+7H9+/PSSy8wefLLedvHYjHOPPMXvVCZEGs3rTXXXvsX9thjJ7J5rp2y2Sy/+tVZTJr0dJvnyuy++7Ps+cmUn/MLoi+90K0aUj/4IY1/uBrKylrWTZnyCc8//9+8+/Xr149DDz2iW+cUhZ155s+5++47qKur7bDNsmXLuPzyi/nTn27AVFejly3rsG13Qxj03DlEpvwvb5vs3vvJdb0QQgjRRbFY/jCrDOtmCEP0rTcKtslO3KMXKmlr3ry5DBkytMPtQRDwwAP3FfWc/fvXdLjNcRz+8IerOe20M5g69VN832f33fegvLyiqDUIIYQQxSK9TLto5MiR3HHHHXzxxRfce++9vPnmmysN/m/PiBEj2GWXXTjmmGMYM2ZML1S69hk3blybEIYPP/yw0yEMU6ZMaXOTdsCAASvNOCFEZ9Vmm7ht1stkrR8m+6MwzcP8WgUx5BYJB7Kp3NfhILgKt4TzRh9IiSNpyEIIIYRY+zQ0pvnvy1N5/NmPyXo+vhegtMLPJd3q3BvMzddIxli0Bq3CAIaWayWt8EsgWaXIVoWdJSyAtmDCULuIq/BVGC+AgrTvE3Oc8Kqq1SzXxlpKIi4pz8fYcAZsay0oRYClPB6jMh5Dac3RW2/Kvptu1OnAvFVlbUDWTscz80n6z5M2UwhDFpIELCN86Z0koDYX5hVleaSXAgyGJhQluUeouWOJaRX8lXuAWvbR0GoLKDQlGJpWOIaDUlEUZQTWw9KEQuNQjdIOlfpgKtzvEHc26bHHRwghRN8xJzuF6amXWep/iyV8rm4ySzD4RFUZjnIpURUEeHgmjc4FKSgUroqQNvWo3IyQra8DALRy8ckQV+WkbD3K6pbt1locHUEpRZkeQIkqpzFYRMrWElERknYZjoowIjqe9WPbM8DdsNeuE4QQfVsmk2mz3J3ZTFeccS+dTq9STUIIIURPe+mll6irWz7E9NBDD119xfSCFSeH+PLLL7u0/1dffZX3eGIN5nn5t/fRmexFflo7ebcHnZhx0BYhqKWmpuOO8M0WAhWAXjAfM0r+NhWDqq+jtkCbioq+M+DA930efPCfXHvt1XzbaqbQadM+Y9yV16BSSWKPPIiyNs9RVl3qBz+k8errIBbDGMMll/yu4D4//OHxDB48pEfrEmJdMWbMRvzyl+dw1VV/yNvu7bff5J577uSEE05us96sN5K6fz1K5KUXKL38EiIff9ip83rb7UDT+Rfh7bTLStv+8pdrC+5/7LHHU1JS0qlzia6rqqrmZz/7FZdemv9v7j/+cTdHH30s+9YMKBDCsLhbdUSffmKldUlgE2BHYHdgm803Z+QK71kJIYQQIr9YLH+AZBpQycbeKaYXue+/l3e7qajE33qbXqom9MAD93HOOb/gb3+7i/33P7DdNh988B5z584p6nn79Ss8nm/kyPUZOXL9op5XCCGE6AkSwtBNY8aM4ZJLLgFg8eLFfPrppyxbtoz6+nqampooLS2loqKCfv36semmm0ogQCfsvvvuPPXUUy3Lr7/+Oj/+8Y87te8bb7RNDNtzzz2LWpvoW2799mUWZRtalg227Xi3VkEMrd/ma55ZOKocjh+xM0NLZPZgIYQQQqxdrLW888E3THr6I76duxQTGLRW4XWOhWw2wNowEEErhdYKY8KQAGvDmSxsEEYz+A40DVZ4cY1xchdS1qJU7rrJUWitiUddmrJeS/iVUpZsEOBojW8CdJizgG8MiUgErRRpP8A3Ab4xeIEhsJbqkgjj1xvKdzYezSZDBvbK42VshmTwEo3BM3jmWwK7GEMShUZRgiEJxNC4WAyW5sFSTUApFkPLBSYGi8eKF56WAHAAQ+vgBUUMS4rmWDDQKOWgbEnuPBZDCghQRFGUE1EaR1VR4e5HTI8mqobj6vyzXQkhhBD5+DaLZ1MoHL5Jv8eU1NMoFCW6Gke5pE0DTXYJro3j2wy1/hx8J0Ncl7P8+a6ZAqXImjRaOVgboFrdvlZosD6lTn8MARnThLZOuB5LiW6eJdASWA9XlbBN+d6MKZmA5xtiqoyYLu29B0cIIWClWay9QgP12rHiLIEyM7YQQohCWk90MHbsWO69995O7/vNN9+0CfzZeOONu3z+66+/nunTp7csr+shDKNHjyYSibQ8z8+ZM4eFCxcycGDn7lF+8MEHbZbHjRtX9BpFz3j3yy95Hois8BHNfU5Y2Hs11ifWTI6j824PgJeAx4F4q49Yq6+dd99h3/HbrlIdNTWF3xtYAIwG9IIFEsJQJKq+nroCbSoqKgu0WPv5vs8jjzzIn/50Fd98M2Ol7ZMmPcK431xIw8230XTuecSeeoKy359f9DqCkevTeOU1ZPfap2Xdww//i08//STvftFolLPO+mXR6xFiXXbWWb9k0qR/M23aZ3nbXXLJ79h33/3bnaXX22MvanffE3fK/4g++TjRF5/D/Xw6KpkEwCYS+BuNxdtpVzKHHYG/5dbtnmPGjK+ZNOnRvHW4rsuJJ57Sye9OdNfJJ5/GnXfexuzZHU+EaK3lzDNP44MBA8nXG1ctXtStGuKPPrLSujeBmbmPfwGc80sGXH0FO+20CxMm7MzOO+/KRhuNlVAGIYQQIo9YLP9EpmlANTX1TjG9KPJB/hAGb7vtwe29YZyPPvowv/jFTzHGcPLJP+KWW27nkEMOX6nd669PLup5BwwYSHW1jKUSQgix7pAQhiKoqalh4sSJq7uMtd7EiRNxXRff9wF45513mDVrFiNGjMi7n7WWf//7323W7bXXXj1Wp1i3fdowh9eWfY7B0u4t0tZBDM3LrTZoFNtWrc9+AzbvlXqFEEIIIYqlviHFQ5Pe49W3viAIDJlsQDSiMbnrnZbABQvGWNCglQoDqwivy60F5WpSpZbUAIVxFfhgtULZ8PrKKgUaHK0x1pLyfFyt8XKzO2kUARZXK6zVBNagbHjxZQn3c7WlqiRGPBIh7fnsMGo4x2y7JUOren52IM/MpCl4mXTwARnzGYYGFOW5UIQsmlIs5AIYsoDFkoBc4IJCAT6QQqFaIhVoWe8QdrNcHs4QdtsNgxWaB6sqwoFXliTNIQ3WhoNQI2oIFhdjlwGlRNU4YnoMZe5ulOjNUEpuBQghhOg+ay1L/G+YkXmXOdlPCPDxTIqUqSOhqyhzBuDknmuSphYsKKVx0FgMjUHHsxE5RAjIEFPlpG09yjqtOrGFyUyOcqh2RtDAQlK2Ft+mUWiM9WgIFgGWUreKLRMHMCaxM0opsjbo8cdFiDVKz04QKbogkUi0Wc5kMl0+RuuBsO0dUwghhFhRfX19y9eNjV2bTewXv/hFS4CCUoqpU6d2qwabm7G6LwxKKSsrY9ttt+XNN99sWffGG290KnzCWrvShBN77LFHsUsUPeT9b77msjzbB2TSfNpr1Yi1haMLhzC8C1yXp83wm/7Mvj8+Y5XqGDCgcFDMwtxnZ8E8/FU6m2im6+qoLdCmoqLn3+tanay1HHzwfrz33jsdtnnkkYc499zz0Vpj1h9F6oyz8HacQOWPvo9etLDD/TorWG8kqZN/TOqEk6HVLPeNjY384Q8XF9z/2GOPY+jQYatchxB9STQa5dpr/8KBB+7d8lqhPY2NDfzf//2Ku+/+Z/uvJZTC33xL/M23JPmbC8KZInIhDCQS4ewOBfzxj1dgcn0TOnLkkUczfHj+fsti1SUSCS655ApOOumHedt9880Mfmstf83TRncjhEHPnkXknbdWWv9CO20XLVrIpEn/ZtKksK/6p59+xYABMuGFEEII0ZFYLJ53ewZawrTWGU1NONPy30/3VzFUsyuef/5Zzjjj1JZrX9/3+fGPTyKdTnP00ce0afvGG68V9dz77XcAusA9MCGEEGJtIiMvxBqjqqqKvfbai2effRYI33T5y1/+wtVXX513v4cffpg5c+a0LA8bNowJEyb0aK1i3dTkZ7j+6/+SNeHbxyvd7m/V57/NulbL1ZEEZ2+wPxHt9FyhQgghhBBFFBjDcy9P5flXPmPO/Fq0giCwgMXzTUu4grUWrVXLsjEWpcHRisBYDJCuUqQrFX5UYR3C66QIoMP+D1op4lGXVBCAtThKEViLygVcWWtbOlMExpKIRkh5Pr4JsAa8IMBYS2AsjtZUJUo4ePON+c7GG/ZYh25rA7L2S3wzlwb/cTzzJRaNoRZDEwoXSz2GDGEYQiwXrhCGLoCfC0poTndW4QOCl1tnW623KBxsm+6MNhe4YLDh2w+Ak7s0jQAxNOUYmrD4aGIookTUYMrcEyhz98RR6/6sSUIIIXqHb7N80PRvvs18iMUSU6W4xGmySzAYkqaWlG2gyhlCXFfg2wyK5W+sKjRKaZJBLVpFMDbAaecWdVQl8FUG32ZxbASlFAEBDhG0iqBQVLqDiQQlpG0tA9wNKdEVxHQZgyJjWb9sc1yVf2YFIYToDSsGJqRSqS4fY8V9JIRBCCFEZyil8g5uyqe7+xXr/GujPffcs00Iw8MPP9ypEIa33nqL2bNntyzX1NSw5ZZb9kSJogd4mWze7ZE+EEIius4p0JckIIxkzqfQQIbOKC0tpaSkJO9rlOah7nrB/FU+nwiphjrqCrSprFy339NRSjF27MZ5QxhmzvyGyZNfYeLE5cFE/vhtWfbsS5TcfAOJ22/tcF9TWUXjpVfgfDMD9/PpqNploDRmQA3+uE3xdtkNf+ttoJ3BINdccyXz5s3NW38iUcqvf/2bTnynQogVbbvt9pxyyo+57bZ8Q+nhmWee4oknJvHd7x5a+KBKQWlpp2uYMuUTHnnkwQKHVJx11i87fUyxag488LvsscdevPRSe9EHy9068xu+AxzZwXa9cEGXzx2b9Gi76/9bYL+NNhorAQxCCCFEAbFYbKV1USAGxIFyQDV1LUB4TRf55GNUkH+CEG+bwiEMdXW1vPbaZPbf/8BuBxnMmvUtP/nJqQQr1GOM4Wc/+wmZTIbjjjsxrMnzeOedt7t1no5ceGHhgEMhhBBibSIhDO1YsGABr732GlOnTmXp0qXU19dTUVFBv379GDduHLvuuiuDBg1a3WWuk372s5/x3HPPtaRtTZo0id12242DDjqo3fZffvnlSiENP/nJT4hG83eynj17NnvttVebdS+88ALDhw9fherF2u6FJVP5Nr2kZTbnDrUOY7DNqxSucjl5xG5URko62lMIIYQQYo1SV5/ktnsnM2XaXPzAYIwhEo3gBx5aKZRWuUAGMIFFO2GQQpDrQG1sGIZABBoGKvxSBQFYBcrkYgVUGCOgNFilMNaiCS+jFOHx/MAQcRw8Y9DWoggjB7RSlEYjJD1FPOLgKE3G9xlZU8UPt9+KbdYbSqLAtX93GZsiGbxKY/A0npmJbxdiSaOIoIhiSKEoyQ0s9XKhCzYXuJDIfYfNN8EDIHyNE37fzYELy/+/PN3LQRHB4uXWKTQKSwKLJQx18DEEudCFMhTlRHUlcWcslZEDcPUAdLABSkV65LERQgjRdzQGS5md/YSmYCnGBizwP6cxWEiZM6Al5CBjmgish0sMpRQGn2XBHKoh99zVlsYlIEuMctI0tAlhammjHPq5I1jmz8azGZQNA45K3YFgIWuTZGwTjnKZUHoco+Lbt9nfVRKOKfo21XfGO67x+vfv32Z5/vyuD15asKBtB+IVjymEEEIUW18LUCiGAw88kOuuu45kbva2d999lzfffDPv5BHWWjX40ogAAQAASURBVG666aY26w4//HCZIWwt4nkSwiC6TjurHsIQL0IIg1KKmpoBzJr1bYdtlocwdH1Qo2iHtaj6emoLNCsvX7dDGAAOPvgw7rvvnrxt7r33rjYhDABm+AiaLv8jTZf/ET3jaxI3XEtJ7jimvAJv9z1pvPQKzNBhXa7ps8+m8re/3Vyw3Zln/pyBAwd2+fhCiNBvf3shTz31BHPmzM7b7v/+79dsv/2EovfT/sMffl/wtc4BB3yXMWM2Kup5RceUUlxxxR/ZbbcdyWbzX1+fAGwMbNbONj03f4hOe2KPPbLSusXABwX222233bt8LiGEEKKvOe+833HRwgVUPfUEMcLwhRXvemaamlZDZT3Hff+9gm38rcYXbHP77bdy1VV/YNy4TbnssivZddeJXarD8zxOO+1E6upq291ureXss39ONpvhlFNO5803XyeZLN6/xX33PUhVVXXRjieEEEKsCSSEoZUvv/ySa665hldeeaVg21133ZWzzz6bjTaSm23FNHr0aL73ve/xr3/9q2XdOeecw1dffcUJJ5zQkvbteR6PP/44V155JfX19S1tx44dy2GHHdZj9dXV1fHpp5+2u23RokVtlmfNmsUbb7zRbttNN910nU8uX9ssyTbwjzlv4GNyQ90oFMUAqjmPQaFQTKjegL0HbNrDlQohhBBCrLpMxuOJ5z7h5dens2hJA47WZL0AsKQzHsbYXEACOFrjB2FMlTEWrRU6F6bgRSFZBclKjXUJL6BcQIE14eAv7WgsYViDBbKBwdEK3xqsDd9UR4XHjDmabGAw1qJseMPX5EIZymIxYq7DxNGjOHb7LYkU6KjYHZ6ZRVPwCungQzJmCoYGNBW5AaQBmjIsFkMTYRiCAkoIAxYUtAQyZFodtfnKMshtbw5cAIXJBS5kASe3ThGGOCRz6yO581sUDg5DsGSwNOLSn5jelBJna6riuxN1lncqy5r8qcpCCCFEPo3BUv6XfJo52akE1kOh8GyStK1F4RIQUOEMJKLiZG1T+OyWG1wShiz41AXzcYjg4bd7DqXCZzZjfRzaBgdpHFwVo787kpSppz4IO/sHNkujXURElbBhfAKjYttT7Xa9U7UQQvSWUaNGtVnuTgjDivtssMEGq1STEEIIIYqvf//+HHvssdx2220t6y644ALuv//+DgeO3Xrrrbz77rsty+Xl5Zx88sk9XqsoHt9r//VuMwlhEO1xCgStdCaEIVay6iEMADU1NZ0MYej66xjRjqYmVBBQV6BZX+hPtuuuExk8eAjz58/rsM1TTz3OwoULOww8MKM2oPG6G2m87kYwBqyFbr53GAQBZ5/9c3w//9/1gQMHcfrpZ3brHEKIUFlZOVdffS3HHntU3naLFy/ijDNO4cEHH8MpUr+AV199mRdeeK5gu5///FdFOZ/ovA02GM25557PZZddlLddE3AIMBkYusI2Z8F8yGSgnVm326O//orIxx+utP4FCvcbnjhxz06dQwghhOjLqqqqKetfQ76pTdW6FsLw4ft5t/ujNsD2yx+239jY0BIQ+Nlnn3LEEd/lyCOP5ve//0OnAgGttfzud7/l/fffLdj2vPPOZccdd+aBB+4r2LYrNtxwdFGPJ4QQQqwJJIQh57HHHuOCCy4gCIJOzerw6quv8sYbb3DxxRdzxBFH9EKFfcdvf/tbPv30U6ZMmQKAMYabb76Z2267jeHDhxONRpk1a1bLLBLNqquruf7663HdnvuxnjZtGieeeGKn2k6aNIlJkya1u+2ee+5hhx12KGZpYhXdOvNlar1k58IXWgmH0Fkq3QSnr7fHSjM3CiGEEEKsaRYsqufmO15m1tylpNMeAK6j8fwArXTLjNXLQxdoCV1ofqmktSJVCskBYXvrAAY0CoMFpcK8Aa2IRhwyXtAyy7UCrLFopcIz5UIWLBB3XVzHkvJ8tFJkggA/MJTGouw2eiS7jR7FuMEDinbNZa1P1n6Jb+bRGDxJ1nwBaAK7BEMKhYthWS5UIZztWxHOxB1+g9nco9VcT3OcVza3PWi1zkcRywUoqNweFkUJlgDwaQ5yCM8Ry+2ZwJAmDIFIoHCJO5tQ7uxDqbMLSoWDVqM9EEohhBCi78iaFI1mCcb6ZEySD5OP0xgsoURXENHVWGtZGszAIYJWLhnTyBKbpp87AmNXDv5xcAlslqhO4NlUy3XAcuHXlc4waoPZBNZD42KVQSuXmE60tLMYqpxhbF66PxXOQDQu5U4NMV3W8w+MEEKsomHDhhGPx0mnw2FUyWSSOXPmMGxY5wJk5syZQyqVallOJBIMGTKkR2oVQggh1mXvv/8+mUxmpfXTpk1rs5zJZDqcaGHgwIGMHt1xB9JTTjmFxx57rGXyhtmzZ/ODH/yA888/nz333LPlNdH8+fO5+eab20xMAXD66adTVVXVlW9LrGae5+XdHi0w2F70TYUGknYqhCGebwhD59XUDMi7fUHus4QwFIeuD+MXagu0q6io6PFaVjfXdTnmmB9y7bV/7LCN7/scc8yRPPLIf6isrMp/wFX8e3vTTdfz7rtvF2z3299eSFmZ3JMUYlXtvfd+HH74kfz73w/nbTd58itcd90fOfvs36zyOdPpNOee+8uC7Q488GC26sTsxKL4fvrTn/Hss08V/Hv8NfAd4BVgxSsZPXcOZlTnAmxL7r2r3fWFYjpc12XnnXfp1DmEEEKIvs4mSvNuV40NvVRJ74h88F7e7f7W2xQ8xh133M6yZcvarHv44X/x3HPPcsEFv+dHPzoBnec18F/+ch1///vfOlXvxIl78MIL/+Xhh/9VuHEXVFVVF/V4QgghxJpAQhgIAxjOO+88jDEAnRrQY63F930uuOAClFIcfvjhPV1mn1FSUsLf//53fv7zn/PWW2+1rPc8jxkzZrS7z7Bhw7jllltWmlVKiM74smkBb9Z+icnNZdwVCnDRnDB8FwbG1/03QoUQQgix9qqrT/HU85/w4mvTaGhMo5XC8wMUipTxMMaiNCit0DoMYLA2nDhGaYUKLEZBOg6pGkU20Sp4oCXJKoyoUiqczclYS9YLUCp3HMLXW8ZaYo5DNggwEG4kHJypgYjWDKooIxsEjB7Qn5/utgODK8uL9lgY20QyeImm4Fl8OwvfLswFLbgo4lhSaEoAnQtAsCwPXGieOUHn1nvQZvZuBRgUEWybmb8tChfwsGFUBSoXuKApw9AAWAxZwkfBR1OJVuU4WEr0FpQ5++DqwUTVBhL+JYQQoihq/fnMyLzHN5n3yZgk1gY02VoAKvQgHBWGEPmk8WwaBxeFxlVRfOuxzJ9DTHX0xrnCtxmUcjA2wGlzK9qi0MR1GdWMoD6Yj2czGOtToqtImQYCGw5mqXKGsHXpYdRE1u+xx0EIIXqKUoqxY8fy8ccft6z78MMPOx3C8MEHH7RZHjt2rLwWEEIIIbrhnHPOYc6cOQXbLV68uMNJGQ477DCuvPLKDvetqqriuuuu4+STT24JfJgzZw5nnHEGFRUVDB8+nPr6eubNm0cQtA2z22uvvTj55JO78B2JNUHWy+bd7ioJYRArK0oIQ0lxQhgGDMg/g+LC3Ge9cEHedqJzVH09AHUF2lVUVPZ8MWuAY489nuuuuybvZFn/+99H7Ljj1tx88+3sscdePVLHlCmfcNVVfyjYbtttt+cHP/hhj9QgRF906aVX8dJLL6w0wGxF11xzJTvuuBO77LLbKp3vhhuu5euvv8rbRmvNeef9bpXOI7rPcRz+8pe/sueeO680Qd+KPgN2BR4HxrQ+xuxZnQthSKWI33/PSqsthUMYtt12e8rKitd3RQghhFiX2dICIQxNTb1USc9TCxbgzJ6Vt42/zbZ5tzc1NfHXv/6l3W11dbWcc84veOCB+7j66uvYfPMt2mz3PI8//ekqrr326k7Vu99+B/DMM0/xyisvdap9s6OO+gEPPvjPDrcPGTKU6up+XTqmEEIIsTbo8yEM8+bN49JLL8UYs1LHtfZu8je3af5sreUPf/gDO+64I0OHDu35gvuIqqoq7rzzTh5++GFuv/12Zs6c2WG773//+5x22mmUFrhIF6I9gTXc8PVzZEw4QK7jt/Y6tmXFSA4ctGVxCxNCCCGEKKIvvl7AbfdOZvGyJpLJLI6j0Qr8QKG1wprwKigwFkeBVioXE0Bu5mowcU3DAPBjYHKZA8qC1Sr8wglfI8VcB88EKHLHsRYNmJZjLQ9vKI1GSPsB2SAgMJa07+MbQ8x1qUrEmTh6FPtvthElkQirwlqLZ78gGbxExkwha6ZiSKGpxBBgCdCUheEItp6wm6MCSggfCZ1bzhKGLzRTzd8Zy5MoWoVT4OS2L1+nKMXSCAS541rC0IYYLoMw1GNI4TCAmN6YhLMTZc4uuHrQKj0GQgghxIpmpN/j/aZJBDZLVCUo1zWkTB3WhM9d9cF8UraWamc4gfVyYUrNz4MKV0XwbRaj4sCKz/OglcbgU65rqA8WYGyAVssHGkR1OGAgpkvpz/rUmbkoHGoi6+OqKKW6PyNj4xngbtDqvEIIsfbZfffd24QwvP766xx00EGd2nfFmbj32GOPotYmhBBCiOLabrvtuPXWW/nFL35BbW1ty/r6+nqmTp3a7j4HHXQQV1xxhQQtrYV838+7PbKKM7OLdZMuQghDPB4vSi01NSvOH91WSwjDgvlFOV9fp+rqMEB9gXYVFX1jApgRI9Zjzz2/wwsv5B/uumTJEn7wgyN48snn2Gab7YpaQ11dLaecchye5+Vtp7XmqquuzTvbqBCiawYMGMAll1zBWWednredMYbTTjuBp59+kZEj1+/WuT79dAo33HBtwXbHHPMjxozZqFvnEMWxwQYbcs0113PGGacWbDsd2AF4Atgpt07Pmd2p80QefQTdTgDI58C3Bfbdffc9O3UOIYQQQoAtz//6VjU09FIlPS/y4fsF23hbb5N3+7333snixYvztnn//XfZa69dmDhxD/baa2+GD1+Pr7/+ivvvv6dg6FizH/zgh1x66RWMHj2iU+2///1j2XLLrdhll4mMHbsx//vfR0yb9lm7bfff/0C5zy2EEGKd1OdDGP785z/T1NTU5oneWkskEmH8+PGMHj2asrIyGhsb+eKLL/jwww/xPK9N+2QyyfXXX89VV121Or6FdZbWmqOOOoqjjjqK6dOnM3XqVBYtWkQQBFRVVTFmzBi23HJLIt0YkDV8+HCmT5/e5f122GGHbu0n1lwf1M3ky9QCbDfiFxSQcGKcMmLVkpaFEEIIIXrK7HnL+O/LU3n5jelks2GHUD8wBFaBzQ2WtKC0glwQgzEWrUFrhTEWoyBdCcn+CtM6U8A0nyUMHtBKgQJjw+XmgZhaKYwxuI7GNxbdEnZncbRDSUShUfQvS5DyPCriMb6/3ZZMHLP+KoUvGJvBs9PxzGwag8fxzWyU0gR2CYY0ChfDEiwZINZyPWixKBwgw/JgBXJfKyzNHbEMYSCDBnzCwIXmz+FxNAkMTa0eNI1CoYgDAQYXSwowaCoATYmzHeXOfpQ6u6JU/s6YQgghRGc1BcuYmfmIed40PJsmY5LUBfMpURWUO2GHe2stSVuLQuGqKBbwTJplzKJUV7dz70Sh0HgmhaNcjA1wVrjdbIFEbt+GYBG+DVC558S4qsDYgLRtwLcZ+rvrs1P5cZQ5Nb3xkAixbutO0qzoMXvuuSfXX399y/IzzzzDBRdcUDBYurGxkWeeeabNur326pmZP4UQQghRPBMmTODJJ5/kxhtv5LHHHiOVSrXbbpNNNuEnP/kJ++yzTy9XKIql0KDdiJYOx2JlTqsQBqedj1IKhzDEYsUKYch/D6YlhGHpUshmIRotynn7Kt1QRwOFX7JXVlb2RjlrhB/96MSCIQwQDsK+6KLzeeKJ/xbt3EEQcPrpJ3dqkMrJJ5+20iyjQohVd9RRP+C//32Gxx9/LG87143Q0M0Beo2NDZxyynFks9m87RKJBGef/ZtunUMU15FHHs3HH3/ErbfeVLDtMuBQ4H1gBODMKhShEIre/rd21xd+RoKJEyUkVwghhOgsW1aWd7tqbOylSnqe++knebfbSAR/s45fV6bTaW666YZOn++VV17ilVde6nT7ZhttNJbLL/8jpaWlDBs2nDkFQqw233xLbrjhljbrbr31Tr773X2pr69rs36zzbbgggt+3+WahBBCiLVBnw5haGho4Nlnn20JVLC5wUBHHHEEv/zlL9t9s2nJkiVcd911PPzwwyilUCocXPTss89y4YUXUlbgQlF0z9ixYxk7duzqLkOsYzwTcNu3L+PZoFv9khWKwwdvy+gymZVYCCGEEGuet9//mvsefYf6hjSZjE88HiGb9VFa5aIFwqGUgbE4GhytCIzF2lwQg6NJVylSlRDEVJg1YAlfRSoF2oaDKDUopXCUwgK+MWHwAoSBC0qBUrhao5XFCwzWWgJj8QND1g9wHYeo47Dx4BpO22V7BlV0/3VVYJfR5D9P0vwX384nsIuwZFFEwEaxpFGUoNAY0rlvKpO7HmwOfQgHh4ZBDBHaBjEEQBRo21FDEcMS0JxOET7KDppSDA2AxpLNHSlAMwCtwmOXqG0pdXcloocSVWMkDVgIIUTR+DbLR01PMiPzPoHN4qooWKgN5mEIyKoUWZui0h2MxZC1aXTulrECHBUla9K4JAFaQpaaaeUSWI9SVUWTXYq1GqXCGeEMFpcISmnKnBqiKkGTWULS1Oa+XgpYyp2BbBifwHrRrYnp/AOShRBibbTxxhuz+eab88knYeebZDLJ7bffzs9//vO8+91+++0kk8mW5a222orRo0f3aK1CCCHEuurFF1/s1fPV1NTw+9//nt/85jd8+OGHfPXVV9TX1xOJRBg0aBBbbrklI0eO7NWaRPF5QZB3e9SRkF2xsmt/eDx/n/wKOk+bAwscIxaLFaWWmpoBebcvIYyedgG9cAFmeOdmSBTtU3V1rDzn9srKy/tOCMM+++zHuHGb8NlnUwu2feedt5g+fRpjx268yue11vLb357dqQCI9dcfxXnnXbTK5xRCrEwpxXXX/YWPP/6Ib7/9pt02m266Offd9yBDhw7r8vGttZx99s/56qsvC7Y999zzu3UO0TMuuuhSpk79lMmTXy7YdhHwN+BSQBcYRAjgvP0W7gftz1RdKOqnsrKKrbYaX/AcQgghhAjZ8vK823VjAxgDOt9dkrWDU+B1rb/xJhDvOFTz/vvvZcGC+cUuq41EopTbbru7ZaKADTbYsGAIw4QJO620bty4TXjhhcnceutNvPPO20QiLgcccDDHH38iZWX5/82FEEKItVWfDmF44YUXSKfTLUEKSil++tOfcuaZZ3a4T//+/bnssssYOnQoN9xwQ0un40wmw/PPP8+hhx7aS9ULIVbVS4unMjO1uFv7KmBgtIIjBm9b3KKEEEIIIVbR518v4JkXp/DW+zMw1mICg7GWZCobvu4BlNYopTCBwQLGWhylUSoMYQg01A8Br0SF+QMKMOEnq4BcuIJVEHE0vrEtr6m0DvcJgx5A5cLuLIqSqEskMKQ8n6jr4BuD62h2GT2SQ7Ycx9hBNThdvKlurcWzn5MMXiYdfETWfoYlg6YaQwqwaMqxBFgaCIeEaiBOGKigc99gJve5mcpV3XpWIkUYr6ByW0yrfZoDFxpze+jc921QJHAZhM8SIItmMK7ekDJnIqXuLrhKZvwWQghRHGnTwALvSzImiQJmZN5nqT+bEl2BqypRSpEyYRp9hDgWS9LUEvgeFc7glufwZoowaCFtm3BVFGN9nJbQoua2lriuxGBImTq0dVBowJBwq8IWuesBR0XZML4TG8fDmYKiuoQqZxhaycAUIYqqO4mzotNWDIy+55572GGHHfLu87Of/YxTTz21Zfm2225jp512Yrvttmu3/TvvvMPtt9/eZt0vfvGL7hUshBBCiNUmHo8zYcIEJkyYsLpLET3A87y8210tr3XFyrQbyRvAAJAusD0W67jTflcUCmGAcGDjEEAvmC8hDKtI1ddTV7gZlZV9J4TBdV2uu+5GDjlkfzKZTMH2Z5/9c37/+8vYaqvxON0MujHGcOGFv+Guu/5esK3Wmhtv/FvLABUhRPFVVFRy++13ceCBe690bbX33vty6613dGsgl7WWiy++kH//++GCbTfddHNOO+0nXT6H6Dmu63LXXf/gyCMP5sMPPyjY/gXCEAZn1qyCbWNXXNbueg8oNJf0rrtO7PbzjxBCCNEX2U5McKySTdh1YOC++9mnebcHm2yad/vhhx/JkiWLuemm69uE9BeL67rceec/GDduk5Z1I0asV3C/7bffsd31I0euz+WX/7Fo9QkhhBBruj4dwjBlypSWr5VSbLXVVnkDGFo744wzeO211/jgg+U3eKZMmSIhDEKsJQJj+Oe8tzErDKkr1D+5eSCCqxxOXW93ytzizDAghBBCCFEMTzz/P55+YQoNjWkCYymJuTSlsiilwsgAm7vesRatFFqpMKjBglYWG9ckSy2pao2NsDyAAYVqPgAKpWkJS/ACg1JhXEFzRIHBEnMdskGAsWGwA7nBl4ExlERc+pclKIvFOG2X7dhi+OAufZ/WemTtNDwzi8ZgEr6Zg0VhWIzFQ+FiWIQlC8RoG6bgAJkV4hVU7sNvGUy6/MqvOajB5D6H2zQJDMlW6xXgoogBCovF0gRYHPqjlEuZ/g5l7gGUOBLkJYQQorjqg0V8nprMzMzH+DYNKNKmgbRtJKpKcFQUV4f3MJK5EIbw+kChVJSsaaKJJaByWUutjq1xCGyWiKogTW1L8BI0P5MqtNJUOUNxcEnaWnyb6zRtoSlYisHHVTHGxHdl88T+uCraWw+NEKKPef/999sduDFt2rQ2y5lMhjfeeKPdYwwcOJDRo0cXta7ddtuNXXbZhddeew0IB+ydfPLJ/PrXv+aoo46ipKQEgGQyyYMPPsi1117bpuP5xIkTZfCmEEIIIcQaxvP9vNsjzto/i5/oAZ0YuFcohCEeL04/lQEDBhZss5DmEIYFRTlnX6Ya6qntRLuKioqeLmWNMn78ttx++z2ceurxpNP5f/rffvtN9t9/L0aN2oCLL76c/fY7oEvnamio58wzT+fpp5/oVPuzzvol22+fP3RRCLHqttpqPBdddCkXXPCblnUnn3wal156Ja7b9S7uxhiuuOJSbr75hoJtlVL86U/Xd+s8omeVl1fwwAP/5vDDv8unn37CrrtOZNC8eQz98nMGQpuPIbl9nG++zntM95mnibzcftTCW0BjgZomTtyjS9+DEEII0dfZ8sKvb1VDw9ofwpBO43z15Uqr5wDDcl/74/KHMFRVVXPOOb/l+98/lvPPP5dnnnmqqCXecMMt7LHHXm3W7bTTLtx//7159+sohEEIIYToa/r0naPmEIbmjsMnnXRSl/Y/8cQT+eCDD1o6HX/6af70KiHEmuPBeW8zL1PbstwyUzP5gxia22xePozd+m3UkyUKIYQQQnSKtZYp0+byn2c/5pNpc1CA5weAIpX2sLnABaUUWoMxFmMsSucGX1qLBVIlkByoMAqsCxhQFqwGlMUqwFE4OgwYaB6cqZXC2nB760GZCkVZNErGD8j4PgGWZNbHWMPAijIO3Gwsu4xenyGVnb+JHtg6kv6LNJln8e0cArswF7oQAZzc14lcEESS8Ootk7u+a3752xy4kKHtS2IFBKBcrPVbIiXA5AIXUrQNbYigKMGSzC1nsS0xDwNBgcIh4UwkrrciqkcR0SM7/b0KIYQQ+fg2S8Y0AdAYLOGtxn+RMnXEVRlxXYPF0GSW4RIhwKfOn0fWSVLlDCGwHqrVnIsKhVYuKVNPREfxbAZNtNX28H+uihOllKxtwrFRlFIY6+OqCK6KolBUuIOIBgmazFKq3aGUOFVEiDMwMoYRsS0o0X1nJj8hVidVuMk665xzzmHOnDkF2y1evJgTTzyx3W2HHXYYV155ZbFL46qrruLoo49m9uzZQBgEcfnll3PttdcyYsQIrLXMmjVrpRCJ9dZbr0fqEUIIIYQQq8YLgrzbI1pmyRXtKEIIQzRanBCGmpoBBdsszH3WC+YX5Zx9ma6ro64T7Soq+t79s3333Z+nnnqBPffcuVPtZ8z4muOO+z6XXHI5xx9/ckuwYUd83+fRRx/miisuZfbswrOkA+y8866ce+55nWorhFh1p576Ez744D0effQRLrvsSk499SfdOs7ixYv55S9/yrPPPt2p9j/72a8YP14mUFhTVVf345FH/sOJJ/6Q3//+Mrb74H3Kz/lFh+2dWd9CMgmJRJv17v8+InHFJUReeL7DfTszzHH33ffsZOVCCCGEALBlZQXbqMZCMUhrPvfzaShj2qybD6wPbA+cAuwzagM6M1XJiBHrcc89D/D0009y3nnnMGfO7FWqLRaL8ac/3cCRRx690rZddtkNx3EIOrjHudlmWzB48JB2twkhhBB9TZ8OYVi0aBEqN2BIa93lWYQmTJiA1joccGQtCyT1W4i1gmcCnln0CQazUupC6zmP2wtjUECJjnLiiN1aBhgKIYQQQqwuQWC4/9G3efv9b1ha24RW4LoOfmDC+ABrsRYCa3F0GJhgclc5zUEMQULRVKXIlueubZRqGW2psNjcsla0vH6iVeBCOADTEtEK39gw1MGG59Ba4ToaV0eoLk3gB4aJG63PcTtsTSJW+LaytRbPfk5T8CKZ4COydjqWNJpKDNnwHJRjCbA0hPuQBuJAAGiWBy60vvALwxVWXmcBB/BpezUYCR+LliCG1gNXS3HoT8BiwOKqYUT1GEqdvUg4E9BqLU9qFkIIscaw1lIbzGVG5n1mZj7EtxkC69MULMVVMSqdwUR12OE4ZRox1schEj6jK0MqqEPj0N7wbIUDBDjE8Mi0CVZqaaM0lXo4dcFssrYJZcFgKVM1YBVZmyRjG9G4bFv2PTaKy70TIYRoraamhnvuuYczzjiDadOmtaxPp9N88cUX7e4zbtw4brnlFvr169dbZQohhBBCiE4qFMIQlRmVRXscXbBJoRCGWKw4IQz9+/cv2EZCGIpH1dezPvBroBaoW/FzJEJjJEJpaelqqnD12myzzfnPf57l4IP37fQ+v/vdedx44/VcdtmVHHroER22++qrL/npT0/r9HGHDx/BbbfdTSQS6fQ+QohVo5Tiz3++mR/96ER23nnXLu//8ccfcs89d/Loo4/Q2NjQqX122GEC//d/53f5XKJ39evXn4cemsR///sM40ePKdje+forgs02DxeCgNJLLyJx8w0F93u8wPb11x/FyJHrFy5YCCGEEC1MWeF+k6qhvhcq6VnO1JUnc/43YQ/UN3IfZWecwuFHHM0Pf3gcW265dcG+NPvvfyC77jqRa665kltvvanDoIR8NtpoLDfeeCtbbTW+3e1Dhw7joIMOYdKkf7e7/Ze/PLvL5xRCCCHWVX36Hb/GVqlZAwYMoKwTSVutlZWVMXDgwJbwhaampqLWJ4ToGU8s+JAF2fq2IQsqN9MzbYfhwcphDPsO2JxxZUN7ukwhhBBCiA75fsDUz+dx/6Pv8M23S0CF67RSBCYMQdCObhkcCWHogtZhMIIxlkBDapAiW6IwuT5EyoJtvghSFqPCTAYUODrsGOjb8KLJKNCtghgcpXFdyAYGrMU3Acaz+IGhsiTOsKoKDtx8LLtsODLvTWRjU2TNp/h2Fo3BU/hmDhYHw1IsGRQRApYCWSAG2FxAQq5QMq2u31TLh8XLrbOt1jcHNRiagxUUClQca9MoLOHLZoUilmuvcqEPYQiES3+0KqHUOZwy9yBieuPu/rMKIYQQHTLWMCX5X6alX8XagKhKEFfl1JtFBAQYm2JxMJNyW0O50x/PpMNnx9xzrkKjlUOTWUaUEnzazrKuWn12VQzfZnBsJAxgym1zVARHuVQ765Ey9TSY+SgCjPJoNIuIqDgbxCcwKrYt/dz1eu2xEUK0o710WbFGGDZsGA899BB3330399xzDwsXLmy33cCBAzn++OM57rjjiEY7My+KEEIIIYTobVnfz7vddZxeqkSsTawu/HNRKIQhHo8XpRbXdenXrx9Lly7tsI2EMBSPqq9lc+CaDrZn9tiL+n882JslrXF22GFHttpqaz766MNO77Nw4QJOO+1EHnzwn9xxxz/a/f0YO3Zjttxyaz7+uPBxE4lS7r77fmpqarpUuxBi1cXj8W4FMAC88MJz3HvvXZ1u369fP2699Q5cCc1aK0SjUQ488LsECwtPlOh+9UUYwmAt5T/7CfGHHii4zwxg5aGTbe2553c6V6wQQgghWtjOhDC0GtO3tnI/m7rSuhVjDRqbmrjnnju455472HTTzTnuuBM58cRT8h63rKyM3//+Mo4++hiuv/4aHn98Ep7n5d0HwokBzjzzl5x88mkFgzyvu+4vNDTU8+KLz7es01pz3nkXcdBBhxQ8lxBCCNFX9Ok7SK1DGMrLuzc7aXl5uYQwCLEW8U3ApIUfEGCWr2ye9DgXxABtwxhaNyt1YhwxZNteqVUIIYQQoj1NyQz3PPgm//tsDkuXNRGJOARB7tpGQRBYrIUgMGitWkIXmq9vlFJ4ZdA0UBG4ankmgSE30LJ5BShNy+DN5hmxHa0JjEEpMDYMYmg+dyzi4mhDNgioTpSQynqM6l/NyTttw1brDcXVHc/w5JulpIJnSAXPEbAI3y4EPMKXrQ7goSklDEHwc99NBovF0txpURGGKWRzn1sHLpjccQzLh5paFHEsqdz68BiaKEaBtSnCAIYsNhfU4DAQlEHhUursQUxvSUxvjKsHd+vfUwghhFiRtZbaYC7fZD6k1p9LYHya7BLqg0WUOzVEdQIAYwPSthEXF61cDAENwaLwGJgwWKgVjYOxAVo7YJc/t6+o2h3GUn8WgfXQ1sUqg0OUmApn4QvwCfCockawdenBlDnVaOVQqquJ6a6F3AohRLG9+OKLPX6O6dOnr9L+0WiUU089lZNPPpkpU6Ywffp0lixZAoQz0W688cZsuumm6Dyvn4QQQgghxOrnm/wz0EUkhEG0pxM/F4VCGGKx4oQwANTUDMgbwtA81FHPn1e0c/ZVqj7/7J62orKXKllzKaW46KLLOOywA7u87/PP/5eXX36R/fY7oN3t3//+MQVDGEpKSrj//ofYfPMtu3x+IcTqVVdX1+m2JSUl3HXXPxk6dFgPViSKTSmFGTgIU16BzjNjtvPlFwAk/nxNpwIYAJ7oRJt99tm/U8cSQgghxHK2E2P0VENDL1TSs9zP2sY5LQFeztP+008/4bnnnikYwtBs3LhN+Otf7+Cyyxbz2GMP8+abbzB16hRmzPgaYwyu6zJ8+Ai22WY79tvvAPbd94BOB3iWlZVz330P8d577/Lmm6/Rr19/dtxxJzbaaGyn9hdCCCH6ij4dwhAEQUtH4+4mmjqt3hwLgvxvsAohVr83a79kQbaDm7DLxxuGn1ZIYVDAIYPGMzgmb3wKIYQQovdlPZ+PP53NvQ+9ycIljVhrwzAEX2FzQQhKKbReHsRgjMXRGqvC5UwJpPqDH9NYh/B6RxNe6DhgbHMyFThaoZQiMGE4gVWqJc5AKYWrHYw1BMZibXh8PzBk/ICSiEsiGmGX0etz0k7jSbQzc6u1PhnzEangObLmYzw7E/BQVGEIE3sV5VgCLA2olou1BBC0KjwLtD5+c+BCc9LW8nUKF0uW1hd6iihgsC3dGp3ceoVSZWD7YVgMWFw1mKjeiFJnbxLOBLTqXpifEEII0ZHGYAnvNf6bhd7XWAyOiuDbLPXBQhQK32apcAZSoivI2iTWBmgiQBiygIIGs5iEqmj3+EppPJvBUVECm8Wl7XO0Vg4RFaO/ux71wULSpoHA+pSoOI3BEiwGrRwGRUazZemBVLtDe/wxEUKIdZXWmi222IIttthidZcihBBCCCG6wSvQR0hmVhbtKkoIQ/5ZDLuipmYAn3/ecdDcwtxnZ+6cop2zr9IFBgjbivbv5/U1O++8K/vtdwDPPPNUl/bbYoutGDZseIfbDzvsSH73u/M6nDU0Ho9z773/YqeddunSeYUQa4b6+s6FMEQiEe688x/suOOEHq5I9AilCEaPRn/4QYdNnC+/wP3wfRJX/aHTh328wPZEopSdd96108cTQgghROhPN11PRimarKURWj6acp8vBvbJE660tnCmtg1heIawd2s+Bx98WJfPU1NTwymnnM4pp5wOgDEGz/OIRCKrFO7vOA477LAjO+ywY7ePIYQQQqzr5B0/IUSfYa3lrlmvEViz8sblkyF3qMJN8L0h2/dIbUIIIYQQ+Sxa0sCdD7zBFzMWUN+QIR51SKY9FBAYgzHhRUzzjNZKgbW5DyzK0TRWQ7ZShes0YECjMIqwoQrDF5QOQxaaAxccrQmMwRKGNOhckJ0CSqMRvMCS8Ty0gmwQEHEd9h43hgM224hRNdVtZtgO7CIy5gN8M5Nk8DyBrUURxbAESxZFBMMyIAPEwtqxuUs0TRi40Hw81erDp+2F3IpBDM3tNIpYq8CF5pfEMcJb3w4Wr2W7ZiBaJSh1DqXM+S4xPa7dGcOFEEKI7rDWssSfxbJgLoHN4tksX6XfJG0aKdVVOCoMV6j156FxcFQUg8+yYA6GAEX4Jmrr5yaNg7EBgQpaztF6u0JhMVQ7w1gazMK3Hg5uy9NrTJcB4Koolc5gQJHQVQyJjkWjKdXVDIttSpUzRJ4ThViDqTz3OIUQQgghhBDF4QXt9DtoJSohDKI9RQhh6Oxshp0xYMDAvNvn5z7rORLCsKpUgYElplImhGn2u99dyvPP/xff9zvVfv/9D+LOO/+Rd9BJv3792Xvv/XjqqZWH2g4ePIQ77riXbbeVPmFCrK3qCgTdAESjUf761zvYc8+9e6Ei0VOCDccQyRPC4H7yMeW/+CnK5L9Wb9YAvNzcwaYDu+++Z1FDsIQQQoi+4rbbbmFpnufY+YBqauy9gnqAWrIEZ+GCNuv+W2Afx3HYZ5/9VvncWmu5RhFCCCF6ibzjJ4ToM6Y3zWNetjZfzsLyMX0r0CgOGLgFZa68UBFCCCFE78lkfd56/2vue+RtGhrTBEEYhuD5CmstWutc4ILFWjCBRTuglSKwFqMhXQGZKoUfY3lOgQ6/NmFKA2iFVqB1uJ+1FtsqiEEphaMVxtjl2wkHdVobUBKL0K+khH6lCc7cY0c2HNAfCOsytgnfzKDJf5qMfQ9rGwlYgMVHEcECFg9FWW5gaJA7a5YwQqJ5hu7mC7UM4NA2XMHmvimT+9y8Lpprvzy4QeXCHcL1YMiiCFBEcBgIygMbJeHsQVSPI6Y3I6Jllm8hhBDFY61lVvYTpqdfY4k3C6sAY2kySwjwKFGVxLWHQwRjA1K2Ho0ThiPhYgioCxZQpvu3e3ytHLImiati+DaD2/Jc2vyMqYjpBP0YnguA8LDW4BDFJUrWpMjYJgDWi23JDmVHEdOJnn9ghBBCCCGEEEU3c+ZMjjvuuC61b60r+3Z0DCHWVVmTf047V0IYRDuszh/CYCkcwlDMDvYDB+YPYZiX+6zr61CNDdiy8qKdu69RBQYI23IJYWg2evQYfv/7y7jggt8UbLvxxuO46aZbOzXr59FHH7NSCMOECTvzt7/dxaBBg7pdrxBi9SsUwjB06DDuuONexo/ftpcqEj0lGLNR3u3u59O7dLwn1huJ923+17D77rt/l44phBBCiFBpaRlLly7tcHsjoBsaeq+gHuB+9mmbZQs8V2CfCRN2pl+/9vv7CCGEEGLNJO/4CSH6jLtnv45ng5YheV1R5ZbygyE79kRZQgghhBDt+nrmIu575G2+mrmYdNrDdTWeH6CUwvP8MHTBGLRWaK1bAhqMsTiOxrrQOEgRxBQmdwGkLKDCAIdcugLkPmmlUCgcpfCtwWBRNgxgCKMOFKVRl0wQkPUDrIVU1iewhsGV5Xx3843Zdcz61JSVYmwTGfM2Sf9psnY6gZ2HJUBTiSELgKacMMqhHjBYkkAC8FkeruABrTtNhd9I+H/bZl348taDVusV4WxQlnSunROGR6CBCjTlGBYDCofBRPVGlLr7UKJ3RKvSYv+TCiGE6KOMNTQEi/FtBo3LN9kPmZ6ajEKT0FU4yiVNI03G4BIlYxtZ7CepdobgqhjWGjSRluNpHIwNyJoUANYalFr+fKnQGOVRqqupCxYQWB9Hubm2AVEdPsfFdCkD1Cgag8U02VpiqpSMbULjMCK2BRvEtmNgZEO0KtyBWQixhunqzU8hhBBCrLNSqRTvvvtul/axudnJrLVd3leIvsQrMLtuREIYRHuc/PdZfMK46XxisXjRyhk0aHDe7fNafa3nzCEYu3HRzt3X6Pr6vNttpYQwtHbaaWdgreWmm25g/vx5HbabNu0zvve9Q3nwwUcpL6/Ie8y99tqb/v37s2TJEgYMGMi5557HD394PI6TPxxFCLHmq6/vOIThO9/Zhz//+eaCwUNi7eBtuXVRjmOqqkgffSz3z/wG8oQwKKXYa699inJOIYQQoq8pLc3f/7IRUI2NvVNMD3GmTW2z/Clt76W0Z/fd9+qxeoQQQgjRM+QdPyFEn7Ak28iUhtndCmDQKHbvP5YSN1q4sRBCCCHEKkpnPJ5/9TP+/dQHZLI+2WyA46iWzs9ahwEFxje5IAaL1mGIgrEW34VkJaT6aaymecrrVhdBy0MKtFq+ZFkefaAAbcPwBmVty7kdrYkCDorqshICY9l97CiO32E8EXcBafMMS7PTSQevYUmhSGBYkgs+iGNoIJzDKYLF5M5qAQfwsKQIuxe2rqR1sEJz5aYlimF5MIMDKCyZXCsXhcISz7V3sHiEXRg1Lv3QqpIyZz9K9YFE9AaoXCiFEEIIUQwZk+Tb7P/4Mv0WdcHCluCEjG2iVFdT7vRvCUdImWUAaOWEIQv4LAvmUum0PwObVi5Z20RUlZC1KVxWvmcR06VUMoi6YAG+zaIJOxMnnCoAfOuRNvU4OsLO8R8xKr4NRgVEVJyIKt6MikIIIYQQQojVp/m+Xm/vL/fZRF/gFwxhiOTdLvoonT+EId2JQ8TjxbtvM3Bg+/eemi0kfFfFBfSc2RLC0F2eh0o25W1iK/IHCPRFP/7xTzn55B/z5Zdf8Nvfns3rr09eqY1Sih//+IyCAQwA0WiUM874OdYaTjrpVMrKynuibCHEalBXV7vSuq222ppf//o37LPPfvL6ZB3ibz1+lY+R/OttNB36PRqaGnl+09F5244fv40EeAghhBDdVCiEoQlQDfkDC9d07ufT2yy/2ol9dt99j54pRgghhBA9RkIYcjzPY968eV3uROB5Xpvl7hyj2dChQ7u1nxCisGcW/Y+M9bo1CVy5G+e4YbsUvSYhhBBCiBW9/7+ZPPb0R3z97SICk4sZsJYgAD/ww8gCa1FKobXCGIu1YG0YzpAuhWR/jXUIAxia8wxQoCxWAVaBAkcrtFJYws6ixobnUypcj4WY4+AFAQYw1pL2fbzAUB6LMrJfOQdv2Y8thqdpMr/Dy3yOJYlhYS5gwQXqgABFGYqwY2F4PeZjaQLitIp9IAxcaF14c8CCiyXIbQs7SCiiucCF5g4TCkVJ7vhpwqiGLIoAcHEZAMpHUUapsy9RvSExvQWO6t8j/5ZCCCH6pubn6Vp/Pq833EddsBBXRUmoSkCx0H4FQNLUkrYNVLtDiasysjaVCxQKaVx8myUZ1KGUxlrTZnvz82pUJ8gGKYwN0CrcbjEoNFq5lDrVuCpKY7CElK3HwSVrUmRJoZRiQGQUY0t2ZWh0XO89SEIIIYQQQoheIQONhOhZXqEQhoiEMIh2OE7ezZm8W0OxWLw4tQCDBw/Ju90CC4BhgDN3Dl7e1qIjnRlUYjoRItAXua7LxhuP46GHJvGHP1zMTTdd32b7jTfeyqGHHtHp45111i+KXKEQYk0QiUQYOXJ9Ro3agG222Y799z+QzTffUl4TrYNsdT/8DTbE/fqrbu2f/s35eN8/BrIBzzzzFOl0/gisgw46tFvnEUIIIQQkEvlDGBoB1djYO8X0EGeFEIa3C7Tv378/m222Rc8VJIQQQogeISEMOV999RV77rlnt/ZtDl2w1nb7GEoppk6d2q19hRD5BdYwaf4H3QpgUMBu/cZS6soMkEIIIYToOal0loef+IAXJk/DDwKyXkA04mCNReXCEowBiyUwFkcTrsNiAS9iSdUoMmW5GZRyfQlyWQohm1uxwiRLanlzDBZtl6+MR1yijkPK86lIxPD8gNEDXE6Z6DOk+nF8ZrLEXwAYFCXNR0CTwGKwNOTWNQGJFYIUAiC7QiUrXrE1r3Ny7Vtviee+rXSunZNb7wDlaMoxLCUcxjqCmLMZpc7exPW2KLXybOFCCCFEdzUGS/gm8xHfZD4kY5swNqDJ1KLRVDlDcXLhCElbhyHAJYpSigCPpf4c+jnDcwFGbTsDOiqCR5ooJWRJotuEMIRcYpTp/jTaJVhr0TgYAhJOFTr3pO+qGBFdQpnuz5j4TkRUHFdF6ecOp8oZKp0QhRBCCCGEWAd1d+IIIUTnZQv8nkkIg2jPc+++w8OE73i099HUiWMUM4Rh0KDBBdvMIwxh0HNmF+28fY2qqyvYxlZW9kIlay/Xdbnookv5yU/O4skn/8OkSf8mmWziyScfJwgCjjzyaFxXusIK0Ve9/vp7q7sE0Yv88dt2K4TBjFyfzC9/3bL82GOPFNznkEMO6/J5hBBCCBEqLe1ECENDQ+8U00PcLoYwbL/9BLTWBVoJIYQQYk0jd55zitUJQTozCLHmmdowl/og1e6wvkLiOsJRQ3boibKEEEIIITDG8uLr03j25U+ZNXcZSkEQWKy1ZL0Aay3WgtKgtcKacLk5iEG5iqb+imypwjT357S0BC3Y1hdAWuHmbuD6xmCsDbMWlMLRGmMMjnYIjMkN4lQExpD1fTYYuJCdxsxm7OAljKiZA/j4thJDHaBRxLFkgRTgYFteai4PULAkWxXTHP3g59Y1Jz/Q6uvW6zSKGLZlDig3ty0OuWAHi4clRRi6MACtKilzDqJUf5eoM3KV/62EEEKIFRkbMCX5PNPSkwmsj6tiOLg0BUtJ2Xo0Dp6dQbU7lJhKkDbhm8fNoQcOEXybpd4sQKFzQQzLKRTWWhwnCkESYw1ahc/lLU/v2qGcAWjj0GCW4NssFoNDhJSpx7cZUIqayEi2L/seFc6AXnt8hBCrkbxNIYQQQvRpL7zwwuouQYg+wTMm73ZXQhhEO76aN5eHVvEY8XjxJhEZNGhQwTZzc5/13DlFO29foxvqC7axFRLC0BkDBw7kxBNP4cQTT1ndpQghhFhNvG23J/7wv7q8X/r3l0AsvI5atmwpL72U/7Xz9tvvyPDhI7pVoxBCCCEgkehECENTY+8U0wPU0iXoxYtalpcB0ztuDsA222zbozUJIYQQomdICAOs9tneJLhBiJ51/9w3CbB05zd9h8oNGRyTNzqFEEIIUXz1DSluuvNlpkyfSzYbYAJDPB7B973cAEvbMnbKGIvW4WsXa8P12Rg0DtIEEbDNeQWt+3w2JzAoBQocpZZHGqhwHwNo29xGEXcdUA5aNTBqwCKGVi9l21HTGFyZpTwew3GWEIYeOMA8FAGKUsLUh+Z6bS5wIcbysAXdar/WQQwmt860amtz+2ZatdUoormjp7EoLNnc+SM4DATloSil1NmbqB5LTG+Oo/oX459KCCGEwFrLEv9bvs1+QmOwFGstdcEC6sx8SlU1pU41AIH18EgRIYZWDj5Zlvqz6ecOxxCgVrg74agInslQoktJ20bay7vX1iGhq2gyy8BG0EpjCNDKIaoSKBRlTn8iqoSGYCElThWlugpHRah2hzIqti017vqr/R6oEEIIIYQQoncMGzZsdZcgRJ/gFejrE41Ee6kSsTZx3FXvqheLxYtQSai6uh/RaJRsNtthm3m5z84cCWHoLlVfOITBSAiDEEIIUZC1llnjt6ERmJn7+Db3+Q6gox4i/jbb4h16eMvyww//C9/3857rsMOOKErNQgghRF9VWlqWd3sjnXu9vKZyPv+8zfK7ndhn/HgJYRBCCCHWRhLCgIQgCLEuSwYZPmsMc/m7+pvuKs2+AzYvflFCCCGE6NPSGY8nnvuE516dysLFDThak/V8QJFKe2HgggKtFVopgsBgAWMtjtZ4cUuyWuMlFNYlvMjRhPkFrTMOyB1Da3xjCGwYSqWUQitNYM3y3AZrgYDBVfVsPfIzNhv+NZWJFJUljbgOaB0FmgCTC10AQ33uZE1AKZagVSEGyNI2cKE5YMG0atdctGnTVhHOPmBJN38nLZ815VgqMSwFFC7DiDmbknD2Jq63Q6vidT4UQgghAJb4s/ig6XGW+LOw1qJxyNoUjWYpGk2gPSrVYKIqTto2Yq1BE8526RLFJ8syfy6uiq50b6I5lMHmvrbWoFTbKAatNGW6BoCkqcVYsBjKdA3KgkeatGlEKdgssQ9blh6Ao+S2rxB9mZK3PIQQQgghhOhxhUIY3GiklyoRa5PihDDEilBJSCnFoEGDmTXr2w7bNIcw6Lmzi3bevkbV1RVsYysqeqESIYQQYu309ddfccwxRzJnzmwymUy7bb6h4xCG9CV/CCcnIRwzcOedt+c9n9aagw46tNv1CiGEEAJKS0vzbm8AdF1tr9TSE9zPp7VZfrtAe6UUW221dc8VJIQQQoge06d742633XaruwQhRA97bekXpEwWlZuZufWcj227RKw8G+Sokhq2qVy/R+sTQgghRN8yb2EtN9z+ErPmLCOVyaKUwnE1yg8DF5oD4oy1WBOGLigVZiQYC5lyS7KfQ9Aqu0ABdvn/Wt44VhocHQ7idJQisBaT2605jKEiHrDxsJmMX/8z1qtZRE1ZPUpZGtOlVJR4RJwoWsWweOSyh7E4hC8l7fIiSLI8KEHlvg5yy81XYc0hDJrlQQyg0EA8F7hggUg4CJVY7hgu4OW2a6A/jqqkzDmQUn0QET1SZvYWQghRNL7NMi87nQazFGsNadvI1+l3CfBIqCoc7WKtJR004uDiqAhZk2KJ/Zb+7ggCG86a0/q5ySWKb7NEiJGLP2pDKYWxlrguJ2XqcWykzf4RHUMpTaUzmLgqpy5YQEAWlKXRLMFREUbGtmJUfFsGuhvK86IQQgghhBBCCNELsgVCGCKRaC9VItYm2ln1rnrxeHHDqAcOHNRuCEMZMDT3GcCZOyd8w0ruPXWZaqgnRThLdyVQBcRZ3lPJRqNQ5H9XIYQQYl1SVVXF119/lbfNTGCbdtZn9juAYOddWpZfffVlvvzyi7zH2nnn3Rg0aFA3KhVCCCFEs0IhDI2Aql3WO8X0AOeL6W2WC4UwbLzxOMrKynuuICGEEEL0mD4dwnDvvfeu7hKEED3syYUfYXMDHFZ8G7htIEPbiAaNYrd+G8vABSGEEEIUxdLaJp556VNefG0aDU1ptFJ4foBCEQQGYyxKh4MwtQZjLNaGCfxKazIllnSlwittdW2iARv2dwuF1zNahcM7LcvjD3RucCfWMKCylnFDZ7Ne/4VsPmImUTcg7TlUlSbDqyEboaYsBcoj7AIGCoNF546WBlrPshSGKoRtmqk228KwhmYxIMPyKjWKaO56LAWAyW1XRNAMABWgKaPE2Z+IHk1Mb4aj+q3Cv4gQQgjRlm+zTE9N5svMOySDcGY6YwMazRIskFBVxN0ABxefDBnThIOLQuGqKD5ZlvpzKNEdv2Ea4KOUxtgArVo9N1pQWlHpDMFgyJhGlNVYLK6KElNlWGvxyZAlSXVkKNuWHkapUw1AXFfkPa8QQgghhBBCCCGKzyuwPRKVEAaxMiey6l31YrFY4UZdcPzxJ3HIIYcxbM4cNrz1JoYCQ1gevtBMJZOo2mXYanl/pqt0XS3/A3ZstS5CGMZQCVQZQ8mRh3DLLbczcODA1VGiEEIIsUarru5HIlFKMtnUYZuZ7ayzJSU0XXRpmx4r999/X8HzHXPMD7tepBBCCCHaKC+vyLu9HlB1dRAE4Dh5266J3OnTWr62FA5hGD9+2x6tRwghhBA9p0+HMAgh1m31foqZ6cUrhC20L5yXeXkQQ8KJ8d2BW/dwhUIIIYToC6Z9NZ/b75vM0mVNJFNZIq4ThisolbsGCRlj0bp55uxwrW8sqUGKTKnGKLs8WUE3N1Ggls865GiFVgplLYG1GGuIu4aa8jqG9lvI9ht8wZCqpcQjHlWJJpSyBEZTHjcoZbG2lKgbwYY5w0AmV0lzlc21ZVnxykphc9dTulVbh+VFN6+N5lqnckcOv5nwO6hGUYZlCRDBVaOI6k1JON8hprdGKem0KoQQojgag6Us8+eHwQjAF+k3Weh9TVSVUK77o5SmMVgCKBxc0rYez0/Szx1OYMNhFkrpluO5RPFtFj+3rfm5vplWDgEecVVOytahrG7Z3hy2oJVDP2c4jWopTWYpgU3jqBIag8VYwFUR1o+NZ1zJ7lS6g3vroRJCrJXyz8grhBBCCCGEWHUSwiC6w3GLEcIQL0Ily33/+8cC4H74PtW33pS3rZ4zh0BCGLpM1ddTt8I6D1iU+8D3YfLLuO7aN+hECCGE6A1KKYYPH87nn0/vsM237axruOEWgg3HtAlhuP76G9l55924667b+eCD91fap6ZmAAcddMiqFy2EEEL0cWVlK8Y7ttUAKGtRdbXYfv17p6gicr74vOXrr+H/2fvzOMmyus7/f33OuTeW3Ctr69qru6v3jd6gWQQEFQRFB0dFZHHcBxUVN0T5igwqjI46MjI68hX4iV8VRfkKXxdkUWigofeleqnqWrr2NfeM7d57Pr8/bkRm5F5LZlZV1ufJIzsj7jn3xiejkrwRN855H04t0N9CGIwxxphLl4UwGGNWrH8//RS1UKd9dmP7RMfp2oMYbu/ZSme0uKsHGGOMMebycujoIP/2H0/yha88QyNJAciyQBaasQbNyZlOhNB8FdIKYsAL9Q6orBZCQZrBC82JnFNezDRDpNpTpwAnQk95lNu37+Geq3eztmd4InShkcZ4l5KpkKZFnGQU4xQneehCHqKQMRmm0IApH0kLEJh8ZSVtt32zbTKIQSg3AxcC+bo+AhSADKGAkqLUECIc3XhZS4f/AcrRq4hk/bk+/cYYY8ysjid72VW9j0ONpwmaokA1DJJRp9utJnZFRByqyngYxOHw4gFPSoOB9BBdbvYPf0WEVOuIeFQDwsxB071+PZkmNLSC03giiKHDtVYAEArSQSYZawu3sLlwE6AUXAcb4uvo9KuW5HkxxhhjjDHGGGPMmdMQFgxhiAo23sDM5KL4vI9RLC7N71bYuGnBPv7IIbKbb1mSx1/JZGSYoTPot9AqocYYY8zlbPPmLfOGMDzXdlujiNH/8UfUv+v1M/qVSiXe8IYf5A1v+EEeeeQhPvKRD/MP//B31Go1AN70prcu2estY4wx5nLS3d09b/sYzZGmQ4Nkl1gIg4yN4g8fmrh//xnsYyEMxhhjzKXLQhiMMSvWw8P7J+cotgcxNG9PD2NozV10CK9YfeNylGiMMcaYFeq+B/fyV5/6BsOjVRqNlFIpol5vBh1IHragCgHFAc5Jvg1IPFTWOZIChIj8SnO71osZEQTw3oEqKik3bDjMXVftYfua42xcdRpQxutlOotVsuBIMk8xSilEKUEdEChFHieO/NVQ2gxMUCaDFJQ8lKH16ikPXRBkIsBqojSKKLVm0fkx8qAFgAogKHXyAIYIRz8iDi8b6fDfTixbiN0NOOlY1H8PY4wxl6dMU0az06RaxxNzpLGLR6v/hmqg5LqJfZFGqDAeTuDwjIVBqjpGf7QRT0SqCZ7JgfERBVJt0NAKMBmo1OKISEkoSzcVHUbUTbQriifCS0R/tJnh7DjVMEKmKbEUSTUl0UFSTYilyE0d38wtHd+KF7t8a4w5ezJXCq0xxhhjjDFmUaT1+oJ9okJhGSoxlxofnd+1njiK8H5m8OdiCGvXoXGMJHNHjLjDh5fksVc6GRlheIE+HR2dxPH5h3QYY4wxK9XmzVvnbd/T2Un9pd9Mcsed1L/3DWcUMPW8593B//yfH+I3fuO/8Vd/9Zd8/OMf5S1v+S+LVbIxxhhzWevq6lqwzxggg4NLX8wi87t3Tbn/2AL9Ozo6uf76G5auIGOMMcYsKRvFa4xZkSpZnSfGDk3d2ApimG3B6LaByT2+zAtX7VjyGo0xxhiz8uzee5x/+fedfO2BvQRVsiygqlSrCUEVAZxzOCfNtjyIwTtH5pV6l1BZ49DW+Ln21y+0vmsziAHW9w1y/YZjbFp1ilu37qUYN0gzR19HBSdKUKG/axQngVqjACI4F1AE76DDJzAxuVTIgxfStgeT5leYto1pbdLcEgEdKOO0QhgURVCgF0cXygjQRcHdStHdQsm/jFh2TJnEaowxxpyPahhlf/0xdlfvYzQMoJqRaJ1aGKPT99Ht106EG1TDMAgTYQuZJgykh+n162c9thNHPVRwEhE0w8+4vKp0ulWkWqehNSItICKoBjp8LwBeIlb5jc1jpPRHmxDxFKWDzYUb2VK8hQ7Xu2TPjzHGGGOMMcYYY86PyzI+BSTNr0bb7db9m7ZfecHqMxcvFy08yf5zQB2ozfI1upSTAp0jbNiIP/DcnF38EQthOBdueJihBfr09PQsRynGGGPMJWvr1vlDGHaHwNBHPo5zbt5+s+nvX81P/dTbedvbfsbGrhhjjDGLpLt74fe5I0D34MDSF7PI/DNPT7m/UAjDzTffsmShmsYYY4xZehbCYIxZkZ4dP854VpvZ0Lo+OttqcM1ghhu7N+Hl7C/EGmOMMeby9pl/e4x/+eJOhseqZKqUYk8lC5MrYGszwqC5arZIc5tCvaiMr/GkMXkAQyDPQ4A8cEEAlEKcsqZ7lO1rTnL79mfZvPoUHYWEvo5xADIVvAugUGkUAShEKahQKiQ0kjx8wbvWBV0lHxLa0gpWaLVJ25cDMqC1r0MoNQMXQnO7a24vAjGKoowhRHh6iNyVdPhvp+Rfgpe+RXvujTHGXN6SUKehVbxEjGUD3Dv614xlg0RSoNP1oQon0r0oMJ4NUwvj9EcbiaVMXUdx6iZOf15iUm1QyUaYTEOaHGzliEhpUJYeqjqCNs/rubxv5GL6ZQuD2WEaWs37AAXpINUG9TBOSkK3X82Lu97I6njLcj5dxpjLwWzXPo0xxhhjjDGLxofAdy3QZ3jLFhrLUo25lPh44aF6L2fyk5jpBn/wLRNR2ksh27hp3hAGd/jQnG1mbjI6wvACfXp7LZTVGGOMmc/VV18zb3u1WuXIkcNs3nzun7tZAIMxxhizeDo7uxbsMwr0DA4ufTGLLNr1zJT7jy/Q/8Ybb1q6Yowxxhiz5CyEwRizIj088hxhvtHGc1wrFYTvXH/70hRljDHGmBUnBOWJZw7z//7rozyx6wgCJGmGIFRVUVWcSDN0QVGFLFO8B+ccCYFan1Bb5dC2/AOR5ryp5n/WdI9wx1V7eP7Vz7KuZ3gidKGaxMQ+Iw2OJIvwklH0KTgoxQ2SzCMCQQWnUCqkTH5m3LoR5vjppr+WKpKvvRSabR4hAjqBMQIOpQZkCBGOVTgpEskOOqPvIJKtRLIFEXsbaowx5vwFzTiW7OHZ2v0cTXaTaUbQlEoYJpYCfX4D3uUrC1bCMIGMSAoIQkqD0+lhVvvNBAIy7SKBk4iajhFLTKYJnmlBjQJF10midVKt4zVGRMg0o+BKOCJEhDV+K2NhkNHsFAVXJqFGokJvtI4dpXvYUriZoutYrqfMGGOMMcYYY4wxi0TSZME+GheWoRJzqTmTEIb2OOzptFha1HqmC5s2z9vuDx5Y0sdfqWR4mKEF+pzJCqHGGGPM5WzHjvlDGAB27951XiEMxhhjjFk83d3dC/YZAbYMXXohDH7X0xO3h4CFrpbccIOFMBhjjDGXMpv9YoxZkb4+tOecFnwruoibujYtej3GGGOMWXmSJOUvPvl1HnhsPwNDFZwI3jvSLCDkAQ0BUFU8eehCluWBB1lQGn1CpceTFZix0HYUZdyw6SB3XbmHq9YdZ0PfQL56d71EZ6FKknmyzFOKE2KfkgZHFhyRz2OoVIVClOFaq3o7hxNhMkCB5oNJ2+0AuLZiIiBtbgPBAZ0oY7SCG5QUSBB6cPSijCOUKfkXEcv1lP2LiNz8A/aMMcaYM6GqZKQ4HInW+Mro33I02QUqFF0nBecZSI80gxESEt3PqmgjRddJNYwCk6vXRFog1QbD2YkZAQwADkcgJZYSqTZQ1akr3yh4ieiPNjGQHibVOqIOJdDpVuVBD9qgGkYAuL3zO7ip/AoyGkQSU5QuW0nHGLOk5FwujBpjjDHGGGPOXKOxcJ84Xvo6zCXHRQv/XmTztGmxuHjFzPbYW7fO2+6e27+kj79SuZFhhhfo09vbuyy1GGOMMZeq7duvxHtPls39amnPnt188ze/chmrMsYYY8xcuroWDmEYBWTw0gthiJ6eDGF4/Az633jjzUtXjDHGGGOWnIUwGGNWnEwDpxoj57Tvjo71lLwNhjDGGGPM3BpJyiM7D/I3//gAh44OAkKaZogTsiygqjjnEIGQKQpkrSAGERKnVNY5kk5BWzkICut7h7hu02G2rTnJbVv3U4gSMhX6OiqAoCr0d43hJFBrFFEEESWo4EUpxQ1C84CqQgDiZijDzImercCFFsfksL5WGkQHUAESwKH45kTVAkIxfxzGyd9WrqHorqUj+naK7gU46VyCZ94YY8zlaCQ9yb76o+ytP0hDq6gGqmGUQKDPX0Hs84HnidZpaJVIijgcGQmn08OsiTaTkU4NWxDwRDSoUpIiDa3iZllfMKJAJEVSreM1RkQIZIg4YiniiVkTbWU8G2QknERwpNpgNJxCENbHO9hRegGbCzdZ6IIxxhhjjDHGGLOSJOmCXTSyIVlmJn+eIQyUSotWy2zCtivnbffHjkKttuR1rDQyOsLQAn16enqWoxRjjDHmklUsFtm6dRv79u2ds8+zz+5exoqMMcYYM5/u7oVDGEYANziw9MUspvFx3MHnJu6eSQjDDTfcsHT1GGOMMWbJ2Sd+xpgVZ0/lOONZ/az3E+Du3qsWvyBjjDHGrBhDwxX+7K/uZfe+4wyNVCnEnjQNIPlriSwEVPPvTgTnhBDyIIYgUO0Xqt2OEEPRJ2zoH2TL6pPcvn0fG1cNUC406OsYByCoI/IZGqCaFBGBAg1UhWLcgDTGiaIICninEyveioB3jnxNbmUyWEHabre+Q/7W0AOt1btiHB6loxm04IEaSopQwNGHkx4K7vmU/LcSuU04+myCqTHGmPOmmp/MFOXxyud5svolMk2JXYmIAmNhiEoYQXCc0gOsiq6g5LqphTFoBiEBeGJSbTCYHsOJm/E4Ig4CiESI5I879TwmiPP0yyYG0kMkWsdrREZKp+/DE6OqZJqgEtgYX8+NHd9MLAUER7dfQ69fb+dGY8yFoRe6AGOMMcYYY1Y2SZOFOxUKS1+IueS4+PxCGLRYXLxiZnvsbdsX7OMPHiC75tolrWNFUUWGhxleoFtPT99yVGOMMcZc0q655tp5Qxh27Xpmls/8jDHGGHMhFItF4jgmSea+jjYKyODg8hW1CKI9uxGd/ED+sQX6b9mylZ6e3qUtyhhjjDFLykIYjDErzu7x42SEs95PEO7o3b74BRljjDHmkjc6XuMbD+/nr//xfkZGqxNBCw3NJ4kCiAhOhCzLgxgCincORUkjGLlCoBxY1zvM87bv4/lXP8vq7lH6OiqIKEnm8RLIgiPJYrxLKUQBvFCiQRpcvgK3CoJSjBLy2VX5xFJVcKJ51IL4ZryCkvcOMLHCtwAxeeCCNLd4hELzFVQdUAJ1IEXoQFiF0MDJOkr+W4jcVoruLpz0LcfTb4wxZoWrhwrP1XbyzNjXGc1Oo6o0tEZNx+h2q+mMVgGgGqjrOF5iPBEZCQPpEfqjjWSa5ClEbVpBDEXpmDhfTyGAOiIpkVDDa9w2KEuJpEAsRVZHWxjNTjEehvJ4I1WGsxMIQiQFri49n5vL30Kn71vS58kYY4wxxhhjjDEXiXkGj7dotPBke3P58ecbwlC4CEIYnttnIQxno1pF0pShBbr19PQsRzXGGGPMJe3qq68B/mXO9nvv/RLf/d2v4b3v/W1uu+325SvMGGOMMbPq7u5mYGBgzvYRwA1dWiEM/umnptx/fIH+N95409IVY4wxxphlYSEMxpgV58nRg+e0X4cvcE3HFYtcjTHGGGMudXv2n+Qjf/tVjhwdYqxSp1yKGa82ECCoEkJzxe5mmn6+mnb+lTlF1ydcd9NBXnDdM2xdc4o13aOIKGPVIuViHq6QZJ5SlFCIUjIVgjoiHwAhKEQu4GRy8qgik/e1FbUAXmZb9LY1mTQwGbpQBBxKrXmI1grhDmEVUEAZQSgTyw4K/g5K/luI5UZbMcAYY8yi2l99nPtGPkU1G0WIiKVIQ2sMZccQhFTr9LKODtdHXStkJHhikDxkIdOEwfQYJemacezWOUu1da4OiLipfZyjz29iID1ApgleIwKBSAqUpAMAR0TBdeAkYkvhZnqidQB0uF42F26k7GyAtDHGGGOMMcYYc1lpNBbucwaT7c3lx0cLD9WbL4SB4tKGMIQNG9E4RuYJGnHP7V/SGlYaNzIMwPAC/Xp7bVVMY4wxZiFnMonxa1/7Ct/6rS/je7/3DbzrXf8XmzZtXobKjDHGGDObrq75QxhGARmcu/1iFO16ZuK2snAIww03WAiDMcYYc6mzEAZjzIqzp3pytvUtF7Q67rJJhcYYY4yZcOL0KF/8ytN85nOP00gyshBQhXojnQhccCKoaB64EBTvIPLKli1HueGW59h45UmuXH8ccUotiegqV1GENHP0dlTxLlBPIwSH94GgeZhCKU6aQQ75a5OA4lxoVtaaUApOAFEcDucckCHq8lW6cQggOKCEUiEfuhcBHmj2p4CSotQQYhy9RG4bZf/tlPzLcdK9rM+7McaYlSnTlCONXeypP8hgeoSgGSqB0ew0JddJj1878V5+LBvAiSeiQEbKYHYMZTJ8SNzke3dPTKoNgqSgiqJT3tsLjkBGQco0tILXwmS7QkRMJEX6o62MZMeoh3ECKUXpoBpGSDUfcN7pV3Fbx6vZVrxtOZ4uY4w5P+dycdQYY4wxxhhz5tJ0wS56BpPtzeXnfEIYNI7B+8UtaDrvyTZvIdq3d8rmBGjFivjnnlvaGlYYGRkBYGiBft3dFvRqjDHGLOTOO+8+475/+7d/zac//Sl+8id/ml/4hV+ku9vGvhhjjDHLratr/vPvCOBOnlyeYhaJ3/X0xO3nyIMk5nMmIVLGGGOMubjZJ37GmBVFVRlOKu1b5uk9NXDhtu5tS1KTMcYYYy49937jWf7+nx/mxOlRGklKMY6o1DKcCGkWmgEJijhwTliz+jTbtx5n06aTXH/9QUodDdQpvR0VENAgdJdqAIw1iqgKIilBhUKUIQKOQMABikMRp80QhtaXTnn1ogAieATag6SkAJqQRzcoQtQMWgCoAA6lSh7AEONYjUhMJNdQ9q8hchuI5BpE7O2iMcaYxXE6OcRXx/6W4fQEIkIsZYJmDCSHUQKNUEUjpUv6SUmo6ziOCAQ8EUEzhrMTdLpVMw8uIAiJ1hHJg4iEqYPRRWBVtIFTyUEyErzG5GkOQtnlH/hGUqTbXQF6ik7fQ390BYpSdr1sLdzCxsL1eDs3GmOMMcYYY4wxBpAkWbhTobD0hZhLjnMLhyjMGcJQLC1uMW3Gx8fZtetpDh06xIDzHAEONr8OAMfJJxV0AP65/UtWx0okw0MEFp6U0dvbuxzlGGOMMZe0q666mt7ePoaHh86of61W4w//8Pf4y7/8GO9617t585vfSmRhacYYY8yy6erqmrd9BHAnjucrkl0ii6lGTz81cfuxM+h/4403L10xxhhjjFkWdiXBGLOinGyMMpbVOLPl3lp98jdsV3esW6qyjDHGGHMJUFX2HTzN//uvj/D1R/ahCmmaISI0knxVKxFBgK7uMdauHWLLppPceP0BVq8eplhM6O0ZB4FMHZHPSIOj1ojxTimQAEJXoU4tjRBRggqqSuyztpcvQkDz6aPSCmKgGdygOFFUHd45RAL527oUcOSvazxOCqiOo6QooKRAitCD0AVUELoouBdRcNdT8i/Buw3L92QbY4xZkVQDx5P97Kk9xPFkHxkJqDIeBvAS0e3X4sQBMJKeQkSIKAGB4fQkmcsoSSeqindu4rhOPGnISLSWhxupIm0fvrpmlFFJuqiEEQQ30a4EPDGRFFgdb2YwPUIS6mSklKSTQKAaRklDDRHPteUX8vyu1xGJTZQwxlzKzuTaqDHGGGOMMeacNRoL94njpa/DXHK8dwv2mSuEgVJxUWtp9/jjj/K617163j4HgeuwEIazJaMjjLDwO/Wenp7lKMcYY4y5pDnnuP32O/j3f//CWe138uRJ3v3ud/Ha134H69atX6LqjDHGGDNdd3f3vO2jgDQayPAQ2jfLwiwXm2oV13ZdZOcC3YvFIldddfWSlmSMMcaYpWchDMaYFWU4qZARJlaJVlrrRs9H8TiutBAGY4wx5rLVSFI+8ZkH+dqDezk1MIoTwTkhJX8t4Xyd/p4KGzec5vprD7Lj6iN0dVXo6a4gAknq8c3QhUYWE/sEFwVipxA3X4uIEFRwKKUoab4+ESAPYnACooq2tjVvtVMEJ4K4VosAZaAGNJr3o3xPiRHtRlHy0IUinnUU/K2U/asouLsQm2BqjDHmPLUCEcazIe4d/QQnkucAKEgJVBgMh0i1gSMiaKAvWg8IlTCMw+EkDxBChbEwkJ/jZgm3d+JphBpOPIEMP+WypgCBbr+GRGukNPBayA+j0BHlq8jFUmSN38YQRwlkdPpVBFKKUuaa8t1cWbqdPn/FlIAHY4wxxhhjjDHGmBnSZMEuGlkIg5nJuXMPYdBiaXGLabNx46YF+7RCGNyB5y6pFSovNDc8zMAZ9Ovp6VvqUowxxpgV4c477z7rEAaAn/3Zd1gAgzHGGLPMurrmD2EYaX53x4+TXQIhDP7Z3YhOzkzqAm4EdpEvozbdjh3XEkU2bdMYY4y51NnZ3BizouyvnmxONMy1BzC0f/w7PZTBi+OKYu8SV2eMMcaYi02SZOzcdYSP//3XOXhkEFDSLOCd4H1gw/rT3HrLc9xy8x5W9Y7S3V0BoFotUCw2SBJPqo5SMSH2GS4oafDEUUBVCEAcZYRAK4mBAHhRQlsdE69XRFGdDFhQBSeKqkPIX7MgRfLQhQDECB6lo3mUqNmWAUVEVhHJWoru5ZT8S/GyDiedS/qcGmOMWdlUlVPpQfbUHuJQ42lSbSAIlTCCqtIXrcdLfsmxGkZRAgXKqCjjYZiQZvT5dWSkRPiJ4zpxZAq1MA5KHkbUNpBbcARJKEsvlTCE4ifalYDDEUuR1fEWBtLDJFonaMATEVMi0Tr1ME4gY3W8mW/q/gH6oismQiSMMWYlkYWW1zTGGGOMMcacF0kWDmEgtiFZZibv/YJ95g5hKC5uMW02bNiISB4aPpeDze9ubBQZGEBXr16yelYSGRlh+Az69fT0LHktxhhjzErw8pe/kv/xPz5wVvts2LCBn/qpn1miiowxxhgzl+7u+UMYRpvf3YnjZNddv/QFnafomaem3P+Z5lcCPAs8Bdz/0z/HriOHeOaZZ7j11tuWv0hjjDHGLDr7xM8Ys6LUQ5KHMLSlL7SmUkz/qLh9ikVBIrqipVs1wBhjjDEXn5OnR/nI33yV3ftPMDxSpViI6Ow6xU037OHWW/axds0QPd0VssxRqxcol6okiUdV6Oys41ygkQhp5vBOCSqIKOViA8mnjgL5ZFXvmjFRzSAGRXEoGUr+qkSar1WmvmJJgiN2+f75/NAYodTsVW3ukYcuCCWE1QiKl6so+lcSySYK7nmILN3APGOMMSubaiDRBk48aWjwtbG/53DjaRSlIGU8EYPpMWo6jsMT0pT+aCNeYiphEFQQEQRBJKYaxvDEzHyXDp6IhlaJpUBKSsTkipGCgEKH7yGhRiPUiCggIgQNdPt+EIgosCbaxkh2gmoYoey6qekYoo7V0SauKd3DlsKNxC4/N1oAgzHGGGOMMcYYY87WwaNHeQAoAHHzq/12DGz3Ee7ClWguUs4tHMLwv4HbgBJQbH4vAVEI9Bw7yhVXbFj0uuI4Zv36Kzh27OicfQ603fbP7SO1EIYzIsPDDJ1Bv95eWzjGGGOMORN33/18Nm/ewqFDBxfu3PSrv/rrdHR0LGFVxhhjjJlNZ2fXvO2t0EJ34vjSF7MIop1PzLo9Bm4Aruvr45ve/ZtgY5GMMcaYFcVCGIwxK8rRxtDknbYgBmT+FeC6omK+srQxxhhjVryR0SpffXAvn/jMg0TxKW66aS/XXnOAzRtP0dMzTpo40szT2VklyxyI0tszDkCt5oE8bCFTIY4zxCkigaAOVBHJv1TbV++eKqjgRXGShzdA/rJF1TW35f2cFIh8jFKhtfaRkgIBoY982F0FoYeCu4PY3UrJvxQvm5buCTTGGLPiqSqn0oPsrT3Mc/XHyUgJqtTDGIFAn18/EWKQhDoJdQpSQhDqocKp9CBroq0kWsfRfj4UnDiqYTRfWW8isqjZLg5BKLgO0jCEqk6EJCgBRIhcgX63iYH0MInWIOTn0LL0oBqoa5VGqFKQMi/ueQObi9eRaJ1IChSl00IXjDGXh3mugxpjjDHGGGPO34PPPMObF+hzNLIhWWYm7xcOYfj9uRr27+MdH/0w73znuxe1ppZNmzbNG8LQPs3RP7ef9I67lqSOlcYND01MKplPd3fPktdijDHGrATOOf7Tf/rPfPCDf3BG/a+77nre+MY3LXFVxhhjjJnNQoGDQ83v7vglEsLwxGPztqc33GQBDMYYY8wKdFl/4vcf//EfvOxlL7vQZRhjFtFIUp26oRXEMNvA47b3Nx2+sIRVGWOMMeZi8fgzD/Po05+gt3cvP/3jR1jVN0Yj9SCBzo46ITiKpYyuuEqWehqpx0cBmtNEi6WENG0OkFMhoEQ+tD1CPqHUCYgq+QsOITRb8hclMtEXbb1cySeh1pKYQpQSuQwRh4+KgGNyDa0A1BCKONZR9HdQdN9Gwd2BSIwxxhhzLhqhSl0rCIKXmAfH/oX99UdRAgXpIJYSI9kpxsMQgueUHqQ/2kjRdVAJw/n5zOXBhhFFklBnKDvO1PNezhGR0SCmREINx8yB50Upk0qDRqjgKSAiZKQUpQNPDAJroq2MhQFG0wEKrkhVRyETSq6DG8sv4arSnfRF6/Pj0bnUT6ExxhhjjDHGGGMuI0mjPm+7AL5gYxDMTGcSwjCfYrG0SJXMtHHjZh588IE529tDGNyB55asjpVGhoYmJpXMxXtPZ6ddwzTGGGPO1Jve9Fb+9E//mEajsWDf97znfUQWkGaMMcZcEKtWrZp1uwP6m18A7sQlEMKgSrTz8Xm7pLfcukzFGGOMMWY5XdZXFX7iJ36C7/3e7+Wd73ynfZBhzAqRaDpz4xmEyfVE5cUvxhhjjDEXXNDj1NMvMTT6JKOV+yj3nOCuOz3FYp1SMUGDUCqB9xmNJCJJPHEhAwXvA6VSA9U8SEFVEFHiuPl6QyX/Es3Da9vmmaqCiBJU8k0KIDhRQit4QYV6GlGMU0QhqBDUgxZwrk5+qbmOkiHEOPrxcgUF9zKK/pvwsg4nXcv9lBpjjFkhVJUT6X72VB/iQOMJUk1BlWoYJRDoi9ZRcvl5JmhGXStEUpgIUTidHmJ1tJlEa0h7iruAJ6YWxojEEQhTHrfVM3IFklBDNSDiWkUB4CWmP9rEQHqYhlYg5CFHnVEfCKTaoBpGERx3dH4715XvIdUGTiK6XD8Ft3SD0Y0xxhhjjDHGGGMWCmGIwVa9M7O6mEMYNm3aPG/7gbbbfv++JatjpZHhIYYX6NPT0zP1Gqsxxhhj5nXllVfx9re/g9/7vffP2+9Hf/QneOUrv22ZqjLGGGPMdC9/+Sv40z/9czZ98A9Z/8Rj9AOrgW7y0bEtl0IIgzt+DHfq1Lx90psthMEYY4xZiS7rEAaAv/u7v+NrX/sav/M7v8Pdd999ocsxxpyn0bR6TvsV3GX/59AYY4xZEbJwiDTcR6YHScKDBD3C2HiKuGF6exOyIDinOAnU6gWyzFMq1RGUQjNcwUcZikOD4r0CAW1OGVUFJ805os2xUEHBC+TTQ/PAhlYgQ3s2Q6oOAZwEUEiCJ8liFKEUJ4g6uooB51KEAsKafLUsuZKS/xYit4VYbkPEVs8yxhhz9sayQcbDEKpKQUrsqn2DZ2sPoCgl6aTgOhjPhqnrOOA4nR6mx6+l269qBjOkeArNkIUCqTYYzI7hmDlwXMShmuAokFLFz3IJMtKYDtdDJQwTaYyIIyPDE1GQMiKO1dFmKmGY4fQEXiKSUCfVUwiejfG17CjdzebCDTZA2RhjprG/isYYY4wxxiytdIEVd+0qvpmLc27hTvMoFouLVMlMmzZtmrf9IJOfefl9e5esjpXGDQ0xtECfnp7e5SjFGGOMWVF+8Rffyb59e/nkJz8xa/vrXvefeO97f2eZqzLGGGNMu6uvvoarr76G7n/7V0pPPDZnP3f84g9hiB5/dME+6U23LEMlxhhjjFluNusYOHToEG9961t5y1vewjve8Q4KBfs41JhLlZ7jfiUXL2odxhhjjFl6qkrQvaThIdJwkEwfJujRPECBk4SQkKZQKARAqdULqArlcg0RKBUbNBox3itBHapKMU4JQNA8TCGo4l3+WDQDFhQQp0xZ2FtBRFFtTncSSIMjciE/lkCWOpIQUY7reJcHO3iXETlFQzdx1A1UcHQTu7uI3c2U/EvxMv+gN2OMMWYuqsqRZDfPVu/nUOMZMlJQpRpGyUibIQv9CIKqUg3DOInwEhM0Yzg7gQCZZgBTwg4iYlJtEFNEZ303LoBHxBE0w8nUsAbnInr8ajQNVMMYqKCa0e3XTexTDaMEzdhRvJubOl+Gojgcna6Pnmjt0j1xxhhjjDHGGGOMMfNIFghhiC0w0szB+5mBpmejVCotUiUzbdy4ed72cWAQ6Aei3buWrI6VRkaGGF6gj4UwGGOMMWfPOccf//H/4aabbuH//r//lMOHD+G95/bb7+RNb3orb3jDD553AJYxxhhjFkdYt37ednfk0DJVcu6iJx6ft13jmOy665epGmOMMcYsJwthIB9AHkLgYx/7GF/+8pf5wAc+wM0333yhyzLGnINMw8KdZhH0XOMbjDHGGLNcVAOZPkEaniLTvaThUVRPoYByEsiACNWULAtUawUg0FFOgDx0IUkjnOQhC4JSLCYoiqojD1hQnGj+2kDy0AVQnEDWzGEIAbwHIaDkH9gqQlCa+4IqJGlEcIHYJwiQqkMVsuCpJEUU6ChkeCkRu00U/J2U/LcRy+2I2Fs1Y4wxZ0dVOZUeZCQ7RdCMSAocaexmX/0RFCi7LmIpUg2jjGanARjOTtAIFVZFG0i0TqINvOQhhU48KAxnJylL98wHFGkmIerE47eHNAjgcHRJP2N6ClRw4ggEQCi7Tpx4VkebGM+GGcqOA3n7WHYaRen1a7mmdA9Xle4glqVb5c8YY1Ycu9RpjDHGGGPMklowhGGZ6jCXnvMNYVjKhYU2b54/hAHgIHkIgzt5AhkeQnv7lqyelcINDTG0QJ/eXgthMMYYY86Fc46f/umf5ad+6u2MjAzT1dV93q+3jDHGGLP4wqb5FyLzhw7mA3Mv4gClhUIYsmuvB1sQ2hhjjFmRLuuZPf39/QwMDCAiiOQr/u3Zs4c3vOEN/MRP/ARve9vb7GKMMZeY2J3b/2fT5qqexhhjjLl4qDZIw/2kuocsPE2qT4KOE0iAAfKZRR5IAYdqJ2nawLkEEaFQSAgBQAgBxCmFQpLvp4KSb2tfjyooRK45r7Q5cUnz9cGZ6CigKojoZB+FelKgGCc4Cag60uDIgsOJkmaO2AV8lNLIIir1bvo6rqW/8J0U/D146UfEhmUaY4w5e6rK/vqjPF29j9PpQSC/xlUJIzS0SqfrozdaSyT5B33j2TCIEEkBVaUaRiGFoutCYEqQghNPqhkpCajAtEUcHY6A4okIpPi2KQaq4F1Et19LIKOiQwSFgNLpevDNx69phZSETYVrubn8CrzEKIGy62ZNtDUPgzDGGGOMMcYYY4y5iCSNZN72WGTednP5Ot9xaKVSaZEqmWnjxjMLYbiteds/u5v0zruXrJ6VQoaHGF6gT3d3z7LUYowxxqxUIkKvhUMZY4wxF61s6/Z526Vex504Trhiw/IUdA78E4/N257efMsyVWKMMcaY5XZZhzB85jOf4T3veQ+f/exnJ4IYANI05UMf+hBf/OIX+d3f/V2uvvrqC1ypMeZMRec4OaMW5h8kYYwxxpilF3SINHyVLOwj1SfIdC+QoVpFGSGf+SnkoQsxQgdKFUhRFRqNgEi+unZQiHyGTgTjChoU7yeDE/Jt4LyCKK01u1UznChB8/cH2mxqbRMgBCENEYUoBSDNHGnwhAaU44RMhVKU4JySpJ7BShe1pMiBU5vR8GJefcuLWNt9C0liAzGNMcacuVQTDjV2cSo5RKJ1YmIGs6McS57F4elwfXiJaIQaI9kpHBHVMEIjqbI62oQTT13Hcc1LgiKCp0BVx3DqZl043eFIQr0ZQhQQmZo6L0C3X8tgepRAlocmaB5eVHLd+aAnfwWF0MFwdhxIcOIZy06DKGXXzQ1dr+S6znuIs64lfw6NMeayMNsfdGOMMcYYY8yiSZLGvO0FuXhX7TMXljvHhUVaisXiIlUy09q1a4njmCSZe/zMgbbbFsJwBkJAhocZWqBbb2/vclRjjDHGGGOMMcZcENmWrQv2cQcOXLQhDDI2SrRv77x9LITBGGOMWbku6xCG/v5+/uiP/oh//Md/5Ld+67cYHh6eCGNQVZ588kle//rX87M/+7P88A//8IUu1xhzBjr9bB84zzfqOJ/4OJrVlqQeY4wxxswtC/tJwpcIupcsPEngOBChjAEV8tmeAClCCSg12zJAUQTVBiEIQZUoSkEUDfngxjARutAKOhBAaV+AqhXIIMJEP1XJF/uWiTmkpJnHOcVJvkMj8zTSGBQKcR7EUPQJ3gWqjQKjtRKxV44MreLRA1cxON7PSOUWfv5V38J1V6xtW2U8W5on1xhjzIoSNPBU9T6eqn6FsTAMqogI1WyEho4TSYm+aA2+GUxYCcMgEEl+rkppcDo9TK9fi6ri2k6GIvn5thaqzaAFbTtPgeAIpBSlg7qOEzH5vltRvER0uB6CzxgJJ0g1A1ViV6ToOlBVGlol0Qar/CZu63olJddJ0IzOQidXFK4idvkxG5mdF40xxhhjjDHGGHPxS+eZpA4QOwtgNrNbvXo1D22/kuL+fXiY8jUM3LrA/sViaclqc86xYcMmDhzYP2efg223/Z5nl6yWlULGRpEQGF6gX09Pz7LUY4wxxhhjjDHGXAhh68IhDP7AftLnv2AZqjl7fufOBfukNy90VccYY4wxl6rLOoSh5XWvex333HMPv/Zrv8aXv/zlKUEM9Xqd3/3d3+ULX/gC73//+9m8efOFLtcYM49VcfuqmfkkyfmGN2izz2haXbqijDHGmMucqqKaEHiURvYFgu4h070oY8hEsEIdcOShBAHoAAoow837NZpxCEC+wnbQKqpKUMdEwALN87vK5DZRWq8IQhC8V5BmH5E8aEG0bb88dMH7kP8AAkkWEVKhHDfwLiAKkWSIU4YrHWRBKEYpJ8e62X1sI3uOb+Cpw9dyYrST1Z0dfNO1V/Jrr7mdvq7yMj3rxhhjLlVj2RD7ao/xXGMnda3iNaKhVUbCAGXXRY/rR8SRacJ4dpqIAkpgID1G6hJ6fD+VMIKjueKiQKQFUq1TCaOzPqYnItMGTjyBDD/tkqGI0O36SbIamSY4IgRBUTpcb94e9ROHIsPpCepUiKXIWDaAEoilzHXle7i+fA+90bqJ4xYK57fynzHGGGOMMcYYY8yF0FgohEEshMHMLooibunonHXA3pEz2H8pQxgANm/ePG8Iw4G229HuXUtay0ogQ0MADC3Qr6end6lLMcYYY4wxxhhjLhjt6ib09+MGBubs4w88t4wVnZ34oQcW7JPedPMyVGKMMcaYC8FCGJrWrVvHn/3Zn/GJT3yCD3zgA4yPj0+s+qeqPPDAA7zuda/jV37lV/j+7//+C1ytMWYuRRdPTr5k/gCGVrsCY2ltxmqfxhhjjDl7qmMoowQdJgs7ScIXCHqAwDEgIJRRKrTCFJRR8pCFToQIZYT87FwhD2RQ8rctId+mEFQIASTPUICQhywEIHL5NiXfNQ9YaK8v/3KihObkUYAQHM4poXm/lsREIVCMGkAe0AaQBsdItUwcZRSilPF6keND/Tx2YBsP7NvB8ZF1JJnineCd46aNa3j7K1/E9jWr7HWGMcaYGeqhQi1UEBGK0sFjlf/gmdrXSUNCJDFOPOPZMONhCMETNKUYlfE4KtkwqgEvMSJC0MBoOI0TjxJwtAUcCDgi6mG8uWEyoChvzk+gRemkGkZQ/OR1MQIOR9F30i8bGUiPkmmjuZ+n7LpRVRKt0dAqXX4VL+r4z3RH/WSaEEuRtfFWSq49NNEYY4wxxhhjjDHm0pUsEMIQObdMlZhLkfrZg0lrZ7BvqVRc3GKm2bRp/sWJ9rXd9nt2L2ktl7riX32cnp99GwDDC/Tt6elZ+oKMMcYYY4wxxpgLKNu6bd4QBnfwwJxty6pWg9LUEMz4a/dOub8f2ATEzfvZlq1o36rlqM4YY4wxF4CFMEzzfd/3fbzoRS/iV3/1V7n//vsREUTySVeVSoX3vOc9fO5zn+N973sf69evv9DlGmOm2V5eMxGscKbTHAVoaMpIWqU37li64owxxpgVRjUQdBdBBwl6kEyfIgtPEDiF0rpY2kEeqAB56MIA+Zm6E/DkQ8oEqKDEzTZPHrpQa953gEM1RVFCmAxZcI7JVCWVZqiSQmgFqgkimgczKBPblGY4QzPUodooUCokRC4jCw5FSIPDZRGVpEBH3MA5ZaxWZKjSxc5D27hvzw72nViPEgGKIBRjT9CM9T1dfNtN1/CG599KPMdgOmOMMZenoIGjyR6erT3EwcYzZJqCKjWtEDSl26+mx69uBitkDOoxIingcNTCOCfTg6yNtlALoxPXrQCcOII6xrJBYOb7YocnlYyImIwET2FqYQodvodE66TU8VrIayDQ7VYjCCXXxdp4K8PpSaphhJIrMR6GUJRIClxdvINryy9gTTz/YG1jjDFLS/RCV2CMMcYYY8zKlqbpvO0FC2Ew8/Gz/36cSQhDsVhauNN52Lp127zte9tu+717IMvAPgeboeN33kvnH/wekF+nHVqgf29v3xJXZIwxxhhjjDHGXFjZ1u3Ejzw8Z7t/bv/yFTOL4l//JeU//z/EjzxMWLuO+rd8G+Pvez/a2UV831cn+ilwOzAOXAvcBFzb1cWVn/4U1113A1deeRVxHM/+IMYYY4y5JFkIwyw2b97MX/zFX/Cxj32MP/iDP6Ber0+u/qfKvffey+te9zre/e538x3f8R0XuFpjTLvVhW5AEM5spHFrQooSOFQbsBAGY4wxZh5BB8jC11E9Qaa7CGE3gRFgGGW02auAkgAF8jPtUHN7mTxMoTUltEIetiDN7QGoM3l2dqD5IEbVfMIq5KELiuaBC80UBecgZDT75qELE8EM5CELIs3HFUiDI8k8pTjBOaWReoI6ktSjXqhnnlLcQARGqyVGqh08eHwHOw9v4dnjVzBeK9NIO8g0T4PwXkgzxXshC4G7t2/ix1/2fLb29028jzDGGHN5yjTlaLKXSjaMosRS5Ln6kxxoPAkKJddJ2XUylg1RDaMIjsHsGEqgy/dRDWNkpETkgQgRBZJQZzA9TiBjevygx5NqAycOJZCfY5ua58aidDCuw6gGRPJ2JUNEKLgyq91mBpLDJFrPw40QOn0PqkqiNWo6Rsl1clfXa1gdbSalQURMf7SRDm8rthljjDHGGGOMMWblayTJvO2xhTCY+cwRWnBmIQzFxa1lmm3bts/bfpx8kkEnII0G7sBzhCuvWtKaLjXu+DE6PvTBifsBeDP5J6bDze/ttxOgu9uuqxpjjDHGGGOMWdnClq3ztvvdu5apkplKH/4Tut/1yxP33ckTlP/q48T3fZXR//m/cUNDE21HmRwVvbP5xVNPwo+8BYA4jvnzP/84r3rVty9P8cYYY4xZchbCMI+3vvWtvPSlL+Wd73wnjz766MTqgqrK8PAwv/RLv8S//du/8Z73vIdVq1Zd6HKNMcDmYj+xOBoapkxFaY9kmGsq5GMj+7mp21brNMYYc3lTTVBGUa0TdB9Z+CqBvWh4jsAQQtwMXGgFJihKQOhs3h7FNYMVAq1BZI7JoWPtoQsNmNInm1pL879ZSEFl4iTuJN87r5dm+JJM3FcVnORViUAj8YhAHOehDmnmSbOIhlO8BFSFjkL+8wxUO6jUixwfXsWThzez98QVDIx1cXqsF5h8XC8KCk6EKE+GYENvN9/1vBv4rttvxNsAS2OMuawloc7T1a+zq34/Y9kggiNoYDwMkWpCj++nx6/BiUdVqYRhvEREEpNpymB2HBGhrhVAJkJ9RARPTE3HiJh5rsn7CRFFEq2CzLz0V3BlNAQqYQRPjIgjI6PD9eAlwgNr462MZKcYC4MUpEQljAJKJAWuLt7JjvJdrIvnXxXPGGOMMcYYY4wxZqVK0nTe9tjNPsneGADm+P04kxCGUqm0uLVMs337lQv22Qfc3Lwd7dlNw0IYpij+7d8g9frEfQ98eI6+oVjk0K4D+DmCOYwxxhhjjDHGmJUi23HNvO3++DFkcABd1b9MFeWiRx6i69d+Zfa2fXvpfdP3Tdn25ALHS5KEjRs3LVJ1xhhjjLkYWAjDAq688kr+6q/+ig9/+MN88IMfJE3TiYHvqspnP/tZ7r//fnbs2HFejyMifOxjH1uMko25rHVGRUouJsmmDno4kzWoHx89wA8sTVnGGGPMRUlVCbob1UMEThDCbrLwFMpplJNACpTIAxcywKM0yOMRushDF8ab59kqiicPUxCggaAowuSZOGVm6EL7Kt3NJbpVyTS/6VxzE+RBDKqIKIQ8lEE13885JQTy0IVGRBRlOBcAIck8AYe4fF/nMjqiDFVhYLyLJIsYGOviySNbeO70Wg4P9HN0aBXSjHdoVZaHLQSaD5kHQIigCi+9djtvffGdbOnvXex/JmOMMRe5wfQYe2uPcio9QqYJsSsxlB5nLBuk4Ep0uX6cOMazETJNcXhGs0HqWmV1tIlU6ySaEEkMgJcINGUoPUFBSsi0d7ROHFnIz40qYZaKIJYCKQ0yTfPjAaqh2VakHPVAKlTCyMT2DukmaCDRGnWt4CXmxV3fy6bCtSTUcXh6/Bo6vK3KZowxF72gC/cxxhhjjDHGnLN0gRCGyIKazTx0jgn3ZxLCUCwubQjDtm3bF+yzl8kQBv/sbviWVy1lSZecjg/+/hn31b5VlMvlJazGGGOMMcYYY4y5OKTXXb9gn+iZp0nuedEyVNMUAl2/+kuIzv35uhsZnnJ/5wKHdM5xzTXXLkJxxhhjjLlYWAjDGXDO8eM//uO8/OUv51d+5Vd46qmnEJHmhCtlYGCA+++//5yPr6oTwQ7GmPPjxbGp1M/T44fPet991RMEVZz9/9EYY8wKoqoop0DHCYyRZU8S2EnQfageA+ooARgin87ZCkfwQAyMkgcllJrblDySYLx5vxWykAIJkyEMIGToxFuO1vm1PXRhosqJ46gqWdYMOkAQVaQVeICimgc15NsURKg3IgpxHrqgKjSSiCT1lMsNFCjEKc5BFhyDo52IUwbHu3jy8GaODvWz+/gGDg/2TwldaHHNirX5XKLgnRCJIzhlY18P33v3zXz7LdfZa3pjjFnhggbGwzCpNoilAAr3jX+GI43dBA3N8AQYDqdItU5EgUgKOOdQVcbDICJCJDGqSiPUOJ0eoey6AKacRxx+IkRBZ5yd8r6CIz81zbyu5F2BPtYxmB2bCH7ISClKmYIrAcKqaANxVmQ0DBBLgQZ1GqFOLEWuLT2fq0q3sybaYuc3Y4wxxhhjjDHGmGmmLwoxXSGyVe3NPM4rhKG4uLVMs379FRSLRer1+px99rTd9rt3L2k9lyI3OHjGfbV/9RJWYowxxhhjjDHGXHinT5/m0Ucf4sRzzzEGHAOOtn0fAE6Sj9X1Tz+1rCEMxU/8FfGDZzcX8MkF2rdvv5JSaWlDNI0xxhizvCyE4Sxce+21/O3f/i3vfe97+cQnPjERxADNCVnnwAayG7P4riqvP6cQhtGsxsHqKbZ1rF2Cqowx5hKiShQeosgn8BwEEjK2MM4vgd9woaszs8hfiyZAA9Vxgt5P0BOo7ifoXoIOkIcsjKEIigca5MEHSh6gEANlYIw8doC2dg+0D7bKowmUBjIliKF9NW5pRisEdErogtIeukBzYqkqhAD54lDN9tZrbNE8ICHPQKDRiInjFBElC44kiQjBUSo2CAGKxQTnlXoaMVwtEztlYLyTZ45u4ujQKnYe2sqRoVUgMlHB9O8TP6nkW1RBJ8Ig8tpfccPVvOmFz2PTKlsR3BhjVrJaqLC//jjPVL/BcHYKJaCq1HQcQejz6yj4/MOzahgjZBkxJVQCg9lxAhkl6aShNXzzUpyIEFGgEao4iSazippEBFFHSkJ+HpoatJDf8sSuRKI1vMYTYaEABSlRkk4AhrITpFpHUYq+i0QbpJqQaP7Y93R9N9eWX0BdKwhCh+uh6DqW+Fk1xhhjjDHGGGOMuXQ10vlDGGJnIQxmHnP8fpxJCMNSD+J3zrFt23Z27Xpmzj57225Hzzy1pPVcatyxo2fVP9u0aYkqMcYYY4wxxhhjLg4PPPAN3vzm75+3zyCwmuW9ziADp+l67/911vvtXKD92muvP7eCjDHGGHPRshCGs/TpT3+af/qnf5oRnmBhCsZcPG7p3sI/n3polrVC5xdQvjT4FG+2EAZjzGUszv6VTv4Ax8kp2yP2UOTf0UxItJMKv0LwrwF7DbRs8kmVNSAj6ACqj6M6SNADBN1N0NPAaWAcKJCHLDRoBSbkikCKUAMcShmokE/lTJr9WqELGXk4g7R9Zc22KZU1v7d+F0LzMVtbQnMF76mhCzmHakYIgaD5sURBRFEVRCALjixzRFGGE2ikjnoSExSKhRRVKBYbOAfj1SLVeoGoEBgY6+KZYxs5OtTPI/u3c3y0b7JOmShuopr2qlpVtr5Q8E7wTlARNq3q5QdfeBuvuP5qex9gjDEriKoymB3nSGNPMzDBIwjP1L7BeDZEJAU6XBeocCocohbGETwDHGW1bCSWIuPZMAg4cYBDNGMkO4W65tlQJoOJRARBaITKZBJQG4cjaMCJJ5BNBDgAKEokMb3RGgaSg2QkeI3JyIikQMl1NgMVehEco9kABVfC42lolVhKXFd6GVeWnkdftB6ATnqX/kk2xhhjjDHGGGOMWQGSLJu3PfYWwmDmEZ1bCIMTRxQt/VC/swlh8E/ubCaY2+dlANFDD55V/7Bx8xJVYowxxhhjjDHGXBzWr1+/YJ9j5CEM/smFIg4WT9ev/Qru1MmFO7ZR4MkF+lx//Q3nXJMxxhhjLk4WwnCGBgYG+PVf/3W++MUvAkxZgbC1yqAx5uJwU9cWIvEkOv/Ah9l8eeBp3rzppUtQlTHGXPyK2Ufo5H+TT7SHiWnpbS91BKXAGDG/TsjeRQYEeki5i5TXE+T54IvLXPnKoVpHOYFqA/QkmT6H6ingICHsJTAKDAFV8qCFPJShuTf57M0YGCUPQyg2WxIEIQ9lyJgMSag0/3ldc/+EqaELgckZodNDFlr3W1EFs92fGbowWS9kWWtMVn5MEUgzl4ce+PyxGw1HkhSAOlEUQKFUrCPAyGiZNPN4p5we7GbXySt4bmgtDx+4ioGxruaP1ayhNfirbQzY9Opa1XsRFG0GQ7R+GkHE8aqbd/ADL7iNK3q7McYYc2nLNEUQnHiONfbzaOU/ONrYizYDhIJmjIcBBKHHr6XD9yAIda3S0DoFKQOQhAankkOsjjZS03F8W2CRE0/QjGoYnbUGR0Sm+fk3D1xwU9pFhC63ipFwCqcOEYdqHuhQ9l3EUmR1vIXB9CiNUCGQ0SHd1MM4maZkJERS5J7u13FT+WVkJChKLKUZj2WMMWblEPvIwhhjjDHGmCW1UAhDNMcke2MAdI4ghfoC+5UK8eIXM4tt27bP294ewuDGRnEHDxC2blvSmi4V8f1fP6v+YbOFMBhjjDHGGGOMWdnWrTuzEIabgPjRhyFJIF7aayCFf/1nSp/8xFnvdwwYXKDPddddf041GWOMMebiZSEMZ+Czn/0s73nPexgcHJwIXxARVJUoivjJn/xJnv/851/oMo0xTf2FLlbFnZxojJz1vkfrAxyrDXFFqW/xCzPGmItYnH1hwQCGdoLgcAhKxjCezxPzeVDQFAIxgbUo15DxPAJ3gVwDvmM5fpyLTh7aNQDUUa0S9DlgFPQwQQ+hOgicRDkNpMA4SoKqR0mYDDVoBShEwHDz6EWY0qdBHmrgm7cVmQhNSJv9oub9PJxBZyy/3X6/FbrQ3jY9dKFl/tCFvHv+W5NlDpFAknjEgXcZICRJRJY5SqUEJwFBKZXqoDA41AkIqnDiZB8HDq9l38ENPHJoOwOlMuqZmRkhzf/MsgDPfJWjEDnBO0HVsWlVD2998e287LqrZh7IGGPMJWMsG2Rv7XF21R6kFsYAEBzjYRhPTLdfRST5B3mn0oPNECPHSHaKROusjjcwHoaByXDOiJiUBsPZKSbPu5McEYnWyOOsAtIWfiDNc1SRMnUqOCbDrJSAl5gev5pUG1R0BKceVcWLpyx5IJAnpsP14ySm16+mICWCJhR9J1cWb2Nb8RY6fE+zr10KNMYYY4wxxhhjjDlf6QIhDAW/PJPlzSUqmv33o7bAbsXC8gThLxTCsI+pnx5GT+6kYSEMAMTfuO+s+mcbNy1RJcYYY4wxxhhjzMVh7dp1C/Y52vwulQrRk0+Q3nb7ktUjx4/T/Y6fOad9nzyDPtdeayEMxhhjzEpjI6/nMTo6ynvf+14+85nPNCfOMTHAXlXZsWMHH/jAB7jpppsuZJnGmGmcCHf1XM0/nXr4rPfNUD51/H5+ctu3LkFlxhhzkVKlgz/hTAMYWlqT9z2OjIADAooAXhsIh4BDRHwBBYICAZQIpRNYQ2AtsAVlK+o2A5tB1oD0g1ycL1VVM1RB5BTQQHUE1VGggvIcGgAZIOh+0FGUEfLs05Q8FKHKZDhBYDLUwAGKtoIWNEaoNp9n39xOc586NCeFTq6L01pVKW22TQ9JaIUttLa1t7f/Y08PWWhtm7ladut3YDLvwLXV2dqz9bNGqCqNJMJJwLVCF9KIEIRyufm74zMKcUYWhKHRLryDWiPiyNE1HD66mmf3b+SZZzejISYIjK2GtENaTx+zpi3I1Juz/Wq75uv8rLm6uLZ+InF8+63X8v3Pv5V1PV2z7GmMMeZiFDTjaLKPkew0qoGClBjJBnii+hVSbVCQIhEFGlrjdHoYRYkkpuCKRNJLonVqYRxPjIhDUaphhKHUUw8VHJOrGYoIXiNqoQJoc/nxyZOPE0eqQiQRGRnRjHOq0OX7SLI6qSZEEqOqBAI9rhcRoT/aQJwVGMkGSEnokG7GwxBBAwh0ul7uLH8r15fvmbh2ZYwx5jKmC7yhN8YYY4wxxpyXxgIhDFHk5203l7lo9s9AFwxhKC5PCMP27fMHkteBI8Dm5v3oySdovPo1S13Wxa9eJ3r07MYphU2bF+5kjDHGGGOMMcZcwuI4ZvXq1Zw+fXrOPsfabkf3f33pQhiyjJ7/+iO4kyfOaffHFmh3znHNNdee07GNMcYYc/G6OGe2XQTuvfdefu3Xfo0TJ06gqlPCF5xz/NAP/RA///M/T6FQuMCVGmNm84K+HfzLqUcIC80gnsW/D+zkR7a8gtjZwAhjzOXB65N49p/TvpOT8PPvTmXib69DCIRmvzwiIL+XIgwBQwjPonwtP1iYPG4+CV5QIqAIlIESSjdQArqATpAiaFce2KAlkAJKDMQggmoBJEW1hEgF1W5EBlDtQTiNUkYYR6nn++gJlDIahghaAU1RHUA1JR9SNNKsrsZkgELSrFkntqm2oglaP1Trdis4oRWU4MkDCoQ8Cqg1abP1GK75TLYeI2q2tY7VHikwe7BCvnV6/0D75ND8X639rUErdGF6ZIFr+7lbP8v0gYatPq0JpiU0pCgpqpA0PIqnVFRUIY4SnBOSJGJktIx3yuBwJ4ePruPYiT527dnE/oPrcS4/Xgj5s5R2Q7VPUN96frX5IzVra8uhmP4sTf7c0+MnFC9C5AVVYXN/Lz/8krt48TW2eo8xxlzM8vNuwIkn05Rnqg/wdPXrDGenmq9RoJqNUtcKZddNn19HweUDlkeSAZw4ImIyMgbSYxBBGhoAiOTnH0HwEjEehpFZAn+ceFJNcSIEMvy0oAURoSidVHR4ynWmvK+n5LroF8dAepRE66CC4OhwPQBkpIg4uv0qNhZ20OX7SbRGUTq4onAlmwvXEYmtsGiMMcYYY4wxxhizHJIQ5m2P55hkbwzA7+/bQ438E7b2r99fYL/SMoUwbNu2fcE+e5kMYfBP7lzKci4Z0aOPII3GWe2Tbdy0RNUYY4wxxhhjjDEXj3Xr1p9xCEP89fuo/ehPLkkdHf/9tyjc+6Vz3v+RBdq3b7+SUql0zsc3xhhjzMXJPvWbplqt8oEPfIC/+Zu/QZurRbUHMGzevJn3v//93HXXXReyTGPMAu7ovYpOV2Q0LLRWwFQCjGZVvnD6CV619ralKc4YYy4yBf0PJifS65RvC5kSwtB67dS2u8NNBDHk9/Oogcn9J+MJJmlzu6I0CDSA0Yn+rT7aXqcy4/50rUgCbVaozaPpjO5Klsq0QIT2R2/f3jrG1AAEQaZFULSCFoTJAIZWGANMhjHoxGTR6T9Ia6rm5JapQQqz328/jk673zrqbCEL7ffbQxZmTjoVPEqGNFcEFzpQEiABhWpdyDJPoRDIMigU8kCJaq3AeKVMFoSjx/s5cPAKBoe7eWrXZgaGuvNHkskFXDUo3jtSr1T7hbRDmLGQeCt8ofWTTV2IfGbtkkdcZJr/C6qCc4ITz2tuu5bvf/6trO3unPsAxhhjLpiggaPJXnZXH+JospdMUzyelJRqGKMknXS7VTjx1EOVET2Fw1ML45zSQ6yJN+FwVHUMhwcRPBGZpgymJyi58ozHFDyqGYjOGsQgIkQUSbSGY2qgJ0DJdaIhoxrGiIgRcQQyetxqnDjK0sXaaAtD2QmqOkbZdTMehicefX28jRvK97C1cOPEsY0xxhhjjDHGGGPM8kuy+UMYIgthMPP4/d27OHUO+xWXKYRh69aFw8n3Ai9t3o6efGJJ67lUxN+476z3CRbCYIwxxhhjjDHmMrBu3XqeeurJOduPtt0u/PsXIEkgXtzFaIp//Zd0/sHvndcxHl6g/eabbz2v4xtjjDHm4mSf+rV56KGHeOc738nBgwenrErYGiz/fd/3fbzzne+ko6PjQpZpjDkDXhw392zha0O7z3if9iksnzj2Vb51za04m9hijLkMCEOLcIz2WIJWgEGrbep9h0yJEsi3TQ9imDzufG0zMhd0Zp9Ww8xgA51yb6rJqIb2bTNvz3bcycry2tsfb7bbkEdTtO6HaT/QfGEK09tknvtTa2OiwvlCFtqDJ1r8tLrKCClKnfxf24HGZFmgnjqcr+McjI2XGKsUGRvr5LnDazl8ZB2jY5089exGGo38YqkXIQuT/y5e8kCKoEoAGh1Krc8R/Gw/i0wpf/rvh0z7PvksKU4gcoIibFnVx4++9E5euGPhAWbGGGOWx2g2wJHGHhpaw+Epug6ernydk+khQChKGa8RQ+Ek1TCahyW4QNl3ATAehlFRYimCKikJp5LDdPlVgOLETzyWx5PQINH6rLW0gqeUgJ/l7WIsRTJSMlIi8vObEnA4Sq6DsutkID1GNYyhmuFwlF03QTMaWqMeqnS4Hp7f+Rp6/BoS6niJ6ffr6Y82WviCMcYYY4wxxhhjzEUgCfOHMBSixR0kblaWcx2HUizNDI5dCh0dHaxbt54TJ47P2Wdv222/dw9UKnCZj6c72xCGsHYdLFOwhjHGGGOMMcYYcyGtW7d+3vb2EAY3PET8jftIXvxNi/b4hc9/lu53/Mx5HaMGPLVAn1tusRAGY4wxZiWyEAYgSRL+8A//kI9+9KNkWT4JrT2AYd26dbzvfe/jpS996XyHMcZcZF6//gXcN7R73sXcp65jPrnxeGOIrw4+zUv6b1jSGo0x5mKgLM+AnZa5hhVNnxzfvn1qm05pmyuA4UyOv8Auc9Y0//5Tt+YRFK0jhbajTgtQUBCZ7acL0441W2WzntFg2jrdgkOnPO5CoQsKxORBDVmzvaN5u0p7RIZQRjUm0wppCkOjHQyPdvDcwfUcPraeoye6GR/r5tDRVQTNH8c7IejkzxFUcTK5LajinSN1SrVPSDvbgxbaft5ZfqkmAheaN9qfrUiErNmgzcfw3vGaW67jjffcRn/n5T1IzBhjLpSgGXWtIggFKTGQHuPxypc52HiGTFNACJoxGgZBlb5oHd1+FYLQCHUaWiWWEgJUwxinksP0R1dQCaP41iUwESKNSWhQC2MzT58iOPUk2sDNUqOIIOpRSQmaTQlwACi4Ih3Szen0CKkmOPVkktHlevGS19Dvr2BYTlENY5RcBzUdB4WilLmp40VcXbqd/mjDEjzDxhhjjDHGGGOMMWYxJCGbtz1e5JX6zMriZbYrjwsrlkuLXMnctm3bPm8Iw7NttyUEol1Pkz7vjqUv7GKlSvzA189ql+TW25aoGGOMMcYYY4wx5uKyfv0V87Yfmna/8C//36KFMBT+v0/T8xP/BUnTBfvWv+O7SK+9jo4//D1kWgjrTmChI9x88y3nXqgxxhhjLlqXfQjDU089xS//8i/z7LPPoqpTVhRUVV772tfyG7/xG/T09FzAKo0x5+KGzk30Rp0MpeNz9pktgKG1/c8Pf5EX9F1L7PzMHY0xZgVJuRP4+JIdX9qiAya3zQwwyLfNHmswXxjCxET7OemUv/ULBS+czWOf2/5nEg80X9tcAQyz3XfkgQntbTOPOxkS0QpdgPxyoQDF5vfx5vdGs19ns60GlBgfX8X+Q5088OgW9h9aTb1eZmC4SK1eQkP+L+ud5K+3Nb84GYJOCZ5QwMnkv6kq1DtgvNeh0fTnYOaPM180Rfv21rbICarCltW9/Mg33c2Ldmyd5fkxxhiz1IbSE+ypPcru2kM0tAbk12TqWsHh6XKrKPh8RbBTyRFQRRCGshMkWm8GLQyjqjiXD2COKFDXCsPpSQKBiLaB782ghVqoMNu50eEItMI5A9I2KFoVIucpShdjYRBRQcQRNEMQyq6LSAqsiTYxmB6nQQ1RIZIC1TBGqg0CGV1+Fa/sfRNr463UwziCo9P1Ejtb+cwYY8wiOJ83scYYY4wxxpgFJfN/MEUUXfbDscw8vJsrsn5+pdLyBetv334l998/NVRgO3A9cB0wfRmj6Mmdl3UIg9/7LO7UqVnbjgJdza/2f/n6d3/PMlRmjDHGGGOMMcZceJs2bZq3/Tny5eBaI7RKf/c3jP/6b0LxPMZRqVL+0z+m8zffjWTzB6oCZNu2M/qH/wvt6aX+nd9N+f98iOipnUiSkm3bzldXrYK//P/Ne4ybb7bARWOMMWYluqw/9fvjP/5j/uRP/oQ0TacEMKgqfX19vOc97+HVr371Ba7SGHOunHO8dt3t/D9H7j2zHaZ9zn28Mcy/nnqE71h35+IXZ4wxF5HEvYgQenEMn/W+7aEJSz3HY76QhrnNNgV/suV8nP3+7XXMdftMQh+m92gPWpC2+zLRrpNTSRFcc+/WMSLy4IVac1sR8M37AtSb33uATgQF1uDkKtAr2X/wRv760wM8s+8UIUCWBpx3gBKC4p2QiYJCFhTvJn+CiWdAJoM08rAGR8MFar1C0tX2o7X+PdvO2e3PxvR/7dZ9UfAiZOSv+Vuv/WPvefXN1/LmF99O7zKuHmSMMZerahhjf/0pBtJjpJpSlg5qYYx99ccJZBSkREk6SLTOyfQwgQwvMZEUiCmSaoOqjuIlxolDNTAehvFZRCWM4mQyQE9E8BpRDWOAzni/5/FkpIDOCFqAPESqICUaWsVrPHnNiEBJOuj1awiaUtFRJDgCGZ2+l0gK+fEloizddLgu+qNNBFIUpdv1c1XpNrYUbyBu9u1w3Uv2nBtjjDHGGGOMMcaYxZdMWwlvujiO5203lzfv3MKdZlEsL18Iw2te851s334l11xzLTt2XMtd3/+f6D55Ys7+fufjy1bbxSj6xtfnbLsFOE3+iWwfsAroK5Xo+uQn6PvCv/HmN/8XXvKS6bEWxhhjjDHGGGPMyrFly/wLpDXIQwxbUQ3u9GmKn/4U9f/8/ef0eO7oEbre+YsU//kzZ9Rfi0VGPvwxtKcXgOymmxn7nx+a0ueRd/7CvMdYu3Yd69evP6d6jTHGGHNxu6xDGD74wQ9OmYQFeQDDy1/+ct73vvexZs2aC1yhMeZ8vWrNbfzd0ftoaDp/xzkWGviLw1/im1bdQG/csfjFGWPMxUIiaryRDv43ZxIB0E4npvPPHcZw9sEJs5S4QFVnWvXZ/XSL54weVyZDA3I6tXFKaEPrfnvoQnvf1v7a3BKjZEBA8AgdKBUgoDjyDNkYKJBfzsyAPoR+nGzAyQ6cXImTtXh3FyJdPLv/JB/7h/s4dPQ5xsbqRHEe9oDkr6lDaP5u6GTwAZBvn5aU4JwQNP9NUVXqZWFslYOo+bNI2zMz7Zw98/dtpolnTiESQUXY2t/LD7/sLl60Y9ssexhjjDkfqSYMpMdoaJ1YCnRILzurX2V37WEaWgPykINqNkpdx4ilRH+0nrLLk3eGs9MgUJQOgmYMZScBUA2oKq45SFnE4TViNB0AAYefUofDkZKQvxpRZEqKjyAqRBKTkRJRmGjSZmhRb7SOgfQwmSZ4jZvnI+j0vYg4+qONxNkAw9lJRASHZyQ7lQcKEbG9dDO3dryU1fH8ae7GGGPMYpML8cbXGGOMMcaYy0ii87/ojuPCvO3m8ublHEMYissXKP7a134nr33td04+9k03w79/Yc7+8WOPLkdZF63CvV+adbsCQ83bKXCq+UWtNvF8vvKV37bk9RljjDHGGGOMMRfS1q3bF+yzj8kQBoDO//7b1L/zu6FYPOPHccePUfrz/0PHn/5vpDJ+xvuN/q8/Jb3t9nn7PP74Y/O233LLrWf8eMYYY4y5tFzWIQwtrUlhnZ2dvOtd7+J7vud7LnRJxphFsqbQwz191/KloSenNkyd5TqnsVDjzw5+jl+86nVLUp8xxlwsau5HKIT/IKL59/IMUgOmBC9MGWxmsz3OhSCTz6k40DDRAh5I0YkAhvYQBiUPYoA8TAHyMIVAHqbggBIyEa4gKDXytwI95EN+YhxrcLIV756Pk+sQ6UGkFydTk1l37TvB57/6EF95YA/1JEUVggZCkgcvOCc4EULzZ8mC4t3UaAkned2qk78t3jsSApVVjqSVfSStPWTKeXv6r+dcv66+LfxBAREoxJ5vuXEHP/Kyu+kq2iBIY4xZTGPZELtrj/JM9QHGwzAgBM2oaf6hVo9bTY9bjYjQCFVGOYWnQEbGyfQI/dF6StJBNYzim5esnHhQGM5OUpDyRIhmy0TQgjb7tpM84chLRCDFUZjR3uF6GA0DBM0m9s/I6HK9FKXMar+JgewIqTYIGihLN56IVBNqYRwVZXPhWq4r34MSCKQUpMzGwg56/OoleZ6NMcYYY4wxxhhjzIXVWDCEIV6mSsylqBUye7aKZzHpYLGlN91CYZ4QhujxRyFNIboMhyKqEn/ly7M2jTI1Sn82fX19i12RMcYYY4wxxhhzUdm8ecuCffYDL2m77/fvo+tX3sHY738Q2q+lqEKWQa2GO3QE/9x+oicep/Dvnyf+2leQdIHFW6cZ+433Uf+u18/bJ8sydu58Yt4+t9xy21k9rjHGGGMuHZfhJx8zqSrPf/7zef/738/GjRsvdDnGmEX2vRvu4atDz5C2f7Q5bwDD1AETXxp8kpcM3sA9q65ZkvqMMeaiIMKIfJRu/UliHmKhIAVt/g8gtMUx6Cx76rQts/W5FM2dUzEzImD6czC1vXXbAVkzcsBNPLuTAQsyrX9MPmwnkL+sLwLVaceLml+NZvtqnPQg7EDcdpysw8lNOLlmxqTW6U4NjvE3n3mAbzz6HLV6QpoFioWIej1BZHJt8RAUXB60EJqDEEPQKc+KBsV5Rwghvx6qSlaCyipHiJo9W/XMUld7/MRs99v7KXnAgwCbV/Xx1pfcwTddu33Bn9cYY8zcqmGMfbWd7K49QiWMIDiKrsxQepJMUwquRI/rR8RxKjlCI9QAYVBP4MRRli7GwzCKErl8QHrQjMH0OF2uj4ASMfnhmRNPphlJqM88L4jg8ATNyMhwTA1iEISClKnpOKo68fc/aIYgdLoeBGEkO42iiObBP52+F4CCK9OnGxgJJwEo+TJjYQiHozdax/WlF7CteBNFV16iZ9sYY4w5ByvhTbcxxhhjjDEXsWSBEIaoYCEMZm7OndtnVBc0hOF5868GKZUKftczZDfetEwVXTzcvr34I4dnbRs8g/17e1ctbkHGGGOMMcYYY8xFpqurizVr1nDq1Kk5++ybZVv5//kLSp/6JGHdemR0BBkbQ+r1Raur8lM/S/VtP7Ngv/3791KpjM/b5+abb1mssowxxhhzkbnsQxiKxSLveMc7eMtb3nKhSzHGLJGrOtZzV+9V3De8e4Ge+UCJ6R93ZwQ+dOBfuKVnC52+tCQ1GmPMRcF5RvkzyJ6ij7fhZCRPDG3THr4ArQAGnZgBPzNwYeYgtNm25dtnpwu0L9S2/GaGTkxqjwoQWsELrfuCoKqoZM12Tx6yAEqE4skDFaT5FbUdswF0A50IBUSuQNiMkyvx7laQ9YgUEfoRmbYS+DyGRir83T8/xP2PPcfA0DjeOdIsoKrU6ylBYfpYsRAU1zZJVgHvhBB0MoRD8z6JU6r9jrTc3nv2wWdzB19MjZ5ApDnRNt+rFEV803Xb+alX3ENH8cx/dmOMudzVQ40D9aeo1IYIGihKmVqosHP8G9S1RkRMJDGpVjjS2EMgEEuRsutExNEIdao6RiQFnDgyTTmdHqXfb6AaRqYEJjjxpJpRDWN5Fs+0k4vHkZDgmLlKnCA48YBOCVrIG4WidCAI1TBGRAERISOjw3URuyI9UsBLxHB2koQ6Rco0Qp0GNQIpXmJuKL+Qu7teTUZKqg1iKdDpehE5t1XrjDHGGGOMMcYYY8yl69cKRcbrNRLyT2eSaV83bNx0IcszFznv/LztHcCvAbW2r2pXF7e+8MVLX9wckufdsWCf+OEHL8sQhsJXvjxn25mEMPT19S1aLcYYY4wxxhhjzMVqy5atZx3CAM3gx/1ztZ678V/6VSq/+M5ZF4qb7tFHH1mwzy233LoIVRljjDHmYnRZhzDceuutfOADH+DKK6+80KUYY5bYmzZ+Ew8O7yWZmOjabvbwhRYBBtNRPrDnU/zmNd9vK2cbY1Y+fwNDfBFCIObPKetHEcaR5t/LVgxDe5iCzhKtMD2wId+28CT66YRWDMG5mPo3e7HDGuYOBZgettB69FZ4QmDy2fDN7xngEIlQkuYhHODQtmcfeoEiQhGRNcAWvGxH3DU4WY3QhchViJzfS/3TQ+Pc+8Ae/uGzjzBerZNlzXo1n+DqmkEHkIcuiOTXIlu5HTotwCMExXlHluX/mpkqaYdQ6XNo1Hq+ZPIpa7s523Osc7RNBDw4wYmwoa+bt77kDl5+/VV2DjfGmDkkoc5AdpykFS4gvTxV+zq7ag9TDeP5Z00KtVChGsYpSpn+aD1FlyfonEoGQYSClshIOZkeZk20iVoYz88ZLg8q8BKRasJQdoJAwDN1RUBPRKJ1ZJZ3Z4LLtzdDn6b/TY+awUQpDbzGiAiqAQHKvosu+hhIj1LVsYkXFl2uD4CMlECg0/WxOtpET9RPXatExKyNN3FV6Va6ff9iPuXGGGPMkpIFVuU1xhhjjDHGnJ+f827O8QUAIzfcxOKtyWdWGu/mD3b9OeBd07almzYz+IYfXKqSFhS2biOsXo07fXrOPtHDD8EPXn6LIMVf+dKcbRbCYIwxxhhjjDHG5LZu3c7DDz80Z/vixyzMTr1n/Dd/i+qPv+2M9/na1746b3tnZxfbt191vqUZY4wx5iJ1WYcw/PVf//XERABjzMp2Zcd6Xtp/A58feGJay8IBDK0bj47t49MnHuB16+9eoiqNMeYi4xwJP0rCj+b30wqeT1HgkzgOIDSmhiw0J2jOFr4ArdiB2SeCTIYszJxWPzW4Yfb2edIQaJ+u395l3l2mH39O7Udx06p1KKH5qNJsz5rfYyaDGFxbe54+IPQAZZAeYD3CFpzbiJOrEelB6EbkyiUJFag3Ev7hs4/y71/fzdBIhSQLxJEjTVOcE9IQJoIOpC11QRWcTP70CjgnaJh83gXwTsiAympISsLkguaShzjQdoBpP9704IX24zoRgire5d/LccwLr97Kz7/6xZTiqZN8jTHmchY0QxBEHCPZALurj7Cr9iCVMAoIQTNqWgGg262i163Ge0ctVBjJBogkIqHOqfQwq6ONRBJR1XE8EeKEiJhUE06nR3E4nEy97pIHLTRwhBl/50Vc87VEyAMUpuwrCEIkMRkpUVuAQyDQ4Xrocn2cTA+SkeA1JiWhLF0UpAhAv9/AcDjJeBihICXqWqWe1RCEK+JtXFe+m23FG3Ey/0p0xhhjjDHGGGOMMeYy12jM3x5d1sOxzAIWCmGYdWmRYmlpijlTIiTPu4Pi5/9tzi7Rww8uY0EXCVXie788Z/OZhDD09vYtWjnGGGOMMcYYY8zFasuWrfO2P70MNWTr1jP6Zx8leeGLz2q/r33t3nnbb731NpubaIwxxqxgl/WnfvYix5jLy5s3vpSvDe2iEqYOiDjT6asB5aOHv8A1HRu4oXvz4hdojDEXu6iDjDdS5Y2T20KChMdxfB7Pw4gcQhhBNAVagQxzhyhMbWPWe4HpJo+hs2+etf9sTQsFMczdJhM9Wqt1K6G53TMZRRHRClbIj9ZFHsDgEfpR+nHSj8h2YAMi/Ti5GsQjdCHSN091i2u8WudL33iWf/nSTo6cGAEgTTNEhEYjmww8EEE1/2ndtNVVVaEtlwEUnHdkWR7ckKlSL0Otz6GeyadRJrpP3NXmBp0niKH1feL3RPL6NvR08SMvu5uXXnclbgmCKowx5lIzkp7m2dpj7K49TF2rCEJBSoxmgyhKyXXQ41YDcCo9TD3kfYb1FJFEdNDFWDYMQCQxik4ELXS6HlR1yjWWiJiEBqEZnNBOmok7+XkyIEwPPGgPWihMbFUCTjy90VoG0mNkmuIlysMagE7fQ0GKrIu3cDo5Sr0ZJFHwJSphlEwTMjI6fS8v7vpPrI03UdNxADp9L31+3ZKEGxljjDEXxJkkDl5GDhw4wGOPPcaxY8dIkoSenh6uuuoq7rjjDorF4oUuzxhjjDHGXGpUkTSdv4+FQ5t5eD9/COxsIQxcBO9d0oVCGJ7aCdUqlMvLWNWF5Z/djT9xfM72UwvsXyqVKJUucMCGMcYYY4wxxhizDHbsuGbe9mPAaWD1Ej1+/Tu/m9Hf+T103bqz2u/EiRPs2vXMvH1e9KKXnE9pxhhjjLnIXdYhDMaYy8vaYi//+YoX8hdH/mPKJM+5yIwbkJDx/n1/z3+/7i2sL/YtSZ3GGHNJcTHq7iDjjpkDgkIDwj6cPgE8ieMAcAIYQhhHqZNPnW+fHdIKNJge3jDT9L10yo2Zfec61uy7SFvMQytEAcA1v1rbWwOeIoRO8oCFfpR1CGWcW4ewGaQbkfWIdAMlhA3IRbLKdq2e8NWH9vKJf3qIwdEKSZLhRPLwAslDFULIn40QlPb5qQFwbaELCvl+2vr3UxyCc4J6odIHjTIzwhem0+l3ZgligDxULYSAd4IqlAsF7r5qM+941UvoLBYwxpjLzXB6mj21xzmdHieQ0iHd1LXKocYzZKTEUiQipqF1DifPEghEFCi7TkSEeqhS0woFKSA4UhJOpUdZI1dQyUbxbYEJraCFahib+fdcQFTINCWSmQPOnThEhUCGmxbCICKUXTfj2VDe3jxfZmR0uh46XQ94GMiOkWgd1UBJuihIGVUl05Si66BDelgfbyXRBoGMDtfNlcVb2Va8gYKzQa3GGGPM5eBzn/scH/rQh9i5c+es7R0dHbz+9a/np37qp+jv71/SWt785jfzjW9845z3/53f+R1e//rXL2JFxhhjjDHmnC0UwABoZCEMZm4LLRo0WwiDXgQT9dM77py3XdKU6InHSO9+wTJVdOHFX/r3Gds+Cfw34Dj5BJL59Pb2LXpNxhhjjDHGGGPMxei6665fsM9O4KWL/LjpDTcx9t7fJnnZN5/T/l/60hcX7PPiF3/TOR3bGGOMMZcGC2EwxlxWvmv93fzryUc4ngxzJuubz2YgHeP9e/+e37n2TZS8TfA0xpg5uQK46whcB3wPYbY+qqAV0NPAcdBjwDHQUWAYGATqQAUYBxKgCqTNr4w8CiAgregGyWftqza/59EAzX4x+d//1uC3mDxAIQJKgEfpQ1wBkWIenEBKCK1ghRrIFoQySCciXUAZWAvIJbWCdpYFPnvvU3z23qc4emKYJAt5WIIqAUiz5r+Y5BNitRms0Dp9tsIrlJlBFs47siygClkINMpQ7Xeo0zzV4TyeptauCgQNE1vX9XTyYy+7m5dcu53Izz94zRhjLnWD6QmOJQdJtUEkMV2ul6erD3GgsYtM0zy4QJVKGKauFQpSpD+6grLrRFUZyk6CCAUtkUnKqfQIq6ONVMMYiiKS/x2NiEk1YTA9mW+n7e+rgFdPQ2sT/ds5PBkpQQN+lr/7sSuRhCpKmNhfNSAIXa4Ph2MkO50/rgoi0Ol6Aej0PThxDKYnCJJRcEVGm32LUuaWjpdwbfku+qK1i//kG2OMMeai12g0eNe73sWnP/3peftVKhU+/vGP80//9E/80R/9EXffffcyVWiMMcYYYy5p9frCfSwo2szD+/mD2mcNYShc+N+p5HnzhzAAxI88dFmFMBS++LkZ22rAo2e4/1IHAhpjjDHGGGOMMReLMwlheLy3j5cOD533Y6lzNL75lVR//G0kL38FnMfY7s985h/nbS8UCtx5p33ObIwxxqxkFsJgjLmslFzMz1/5Hfz67r8m1akrVMz61mqO91vPVo/xvj1/x2/ueAN+gVUKjDHGzEMEpBPoBLae/+Gm3VZVXDNA4GwCEgqFqYOfGo3Zhjtdmqq1Bg/tPMjff/YRDhwZQDUPXPBOSNOAAE6E0IxVCEGnPLHTQxcUcE4gtEIa8hYngi85RjqVRkdzJ84ugGHicVoP2sYBglCIPXdfuYmff9VL6O0on9VzYYwxFzNVZTg7TTWM58EEvpeRbIDHxr/K4WQPQfO/2almjIUhBKHPr6EvWgNANYyRZg1iimQETiaHWR1fQUyBulbxRIiTiaCFgfQYoDimvr/xRDRCPT9lTzuXOjxKAhqa4Q0z2xEhaMC1BTXkYQkdxD6mkg3jiRFxZKSUXTcFVySWNTg8I+EUDRqU6CDTlPFsmIQEh+O68l3c3vlKamGMVBNiV2RNtJGi61iSfxNjjDHm0jF3+OxKF0Lg537u5/j85z8/Zbv3ng0bNtDd3c2hQ4cYHR2daBsYGODHfuzH+MhHPsLtt9++3CUbY4wxxphLjCSNBftofOEnzJuL17mEMFAsLUktZ0PXriXbvAV/6OCcfaIHH4AfW8aiLqR6ncK9X5qxef1ZHGLTps2LV48xxhhjjDHGGHMR6+rqZsuWrRw8eGDOPg9+53cxvm49pY9/DH/i+BkfW50j23EN6S230Xj5K2h8y6vQ1asX3O+Tn/wETz65k3e845fp7Oyc0T4+Ps4XZwlgbHfnnXdTLtvYZWOMMWYlsxAGY8xl55burbyk73r+Y3AnoGcVvtDusbH9/K8D/8Tbt732klr53BhjLietv8/2dxqSNOO+R/bxt//8EKcGx6nVE+LIk6bpRMirKhNBCiKT92WW+TvtQQwCiBOC5mkJQZVGCaqrFI1lolP7Pmeiva9jMhiC5uOt6ergv77iHl60YxuRt1AkY8ylSVVJSQiaEUsBRdlff5qnqg9wPDlApvmQ21QTGlqjICV6/WpiX0BVOZ4cbAYyCIPZSRSlx/czng2BgBOPw5ORMpAep9N15yFFbWFyETENzVfwi2TqpSJpnhCC6sygBQGn+XECAU/74GHFS0RRylTCKEKMiKDNWjt9D54YFCphZGJ7l/ROPCeI0ulWsSbeRNl1UA8VvBRYG2/i6tLzWOXX2zneGGOMMVN8+MMfnhHA8IY3vIG3ve1trF+fT4UJIfD5z3+e3/7t3+bIkSMAVKtVfu7nfo7PfOYzdHd3L3mdH/nIR86q/44dO5aoEmOMMcYYc9YaycJ9isWlr8Ncsrw7+xAGLV0cv1Pp7XfOG8IQ3/fV/APGy+C6bfyN+5BKZcb2dWdxjI0bLYTBGGOMMcYYY8zl47rrrp83hOHJ3buo/P4HqfzSr+J3PUP0yEP5dQjn0J4eXF8vlMtoFEMc0+jsIaxfT9iwEUpnF2B5+vRp3v3uX+XUqZP8/d//Lf/tv72f1772O6eMRfvUpz5JtVqd9zivec13nNXjGmOMMebSYyEMxpjL0s9sezVPjx/iRGPorFbkbqfA5wceo+hifmLLt9nkH2OMMRelEAJfuG8X//aVp3nu8GmSJAPJJ/0mSUaYZRxUCDplWx6tMBmKoIAXaU7IhaD5pFwRIS5HDJYzko7J8IX245wrIU+EcCJE3nH3lZt5+7e9iDXdM9NnjTHmUlAPNfbXn+TJ6gMMpXl4gsOhKNUwTkGKdPhuPBHVMM5wehpFSSXBi6dP1lLXCg2tEksBESFoYCg7lR9fx3Ftl328RKShQSWMz3wPJOBwpJqgs1wqEhwiSkZKRDzZoIAIJemgFsZxuIn3RRkZ3W4VvX41Ic2ohQpO8zCIDtdNLPmg4R6/DkVo6DhFV6ZOhXqoEEnMluJ1XFu6i82FaxCxsB1jjDHmTM0WpHc5GBwc5E/+5E+mbPuFX/gFfvzHf3zKNucc3/qt38qtt97KD/zAD3D48GEAjh07xkc+8hHe/va3L3mtL3rRi5b8MYwxxhhjzNKQRn3BPhrHC/Yxly/nzyGEoXh2EwmWSnLn3USf/hR7gEeB/cAvtbX7I4dxBw8Qtm67IPUtp8IXZl8Jc/1ZHGPzZgthMMYYY4wxxhhz+bj++hv53Oc+O2f7Y489QpIkxHFMdsONZDfcOKW9UJh6TSVtzHYVZWGqyi//8s9z6tRJAA4fPsQP//CbeMUrvoXf/u3f5aqrrkZV+bM/+5MFjgSvfe3rzqkGY4wxxlw6LITBGHNZKvkCP7/ttfzGnk/Q0DNYqWIOCvzLqYcpuIj/sukVFsRgjDHmolGtJTz69CE+8U8PcfDYICFTQgh478hCmDxnab4gTdCps3R0lkk7zcXQm3fyQISgihchDUrSIQz1ZaiXcw45mvJ4bbcDghNY09XBj7/i+bz8+qvsvGuMuSSMZ6PsrT/B/tpT1LRKREyH7+ZoYz8NreEloihlUDidHWuGGXjwPXTRB8BINpAH3UiBoIGRbBBBSJvvZVp/D504VAMj2WkQxU8LLnDiSbSOx834O+3wQIKSAVM/sMofu0SiNVR1Yt9AwCH0+bUMkNEItWZIgyIInb4HJ5410SaG0pOMhgFEHJFEjGSnCSgOYX1hK3d2vpK+aC2VMApAp+umy69azH8KY4wxxqxwH/7whxkfH5+4f/fdd/NjP/Zjc/Zfv349v/Vbv8UP/dAPTWz76Ec/ypvf/GZWrbLXIcYYY4wxZnaSNBbuVCwufSHmkuUXCGFIZ9t4lqs5LpZKpcJjjz3Kzp2P8+STT7DzG/fxNFBp6/MTQE/b/fhrX6F+GYcwrGZquP18Nm7ctJglGWOMMcYYY4wxF7Vbb71t3vZqtcrOnY/zvOfdsaR1fOpTn+TTn/7UjO1f+MLneNnL7uGnf/rnePvb38Gv/uq7efvbf5LBwcFZj3PHHXeyefOWJa3VGGOMMReehTAYYy5bN/ds43uveCF/dfTLhLNam3tq34yMfzz5Dbw43rLx5TYh1BhjzAWVpBn3PriHf/jso5waHKVWz4gjR6oBEchCyIMUVBE3ec6a7UzYPkBIgcg50iwAEEI+Cdc7hzqh0g9JmYmJuSJnNrjoTDgnRM7xgqu38GMvv5tNq3oX6cjGGLN4htKT7Ks9xUg2CCgdrofxMMy++pMk2iCSCIenoTWGaqdQoEO6WVO4Ai8R49koDa1RkBIIjIcRNA10u1V5WEPzEo4TBxpNBDHItMAELxENreGUWYIWHIKgKKo6472Lx6MKyvQ2pey6kEBei8aICBkZXa6HgiuyVjZxOj1KLVTISOl0PQiORqhR0wreebbF13Nl8WbqWiPThJLrZHNhB1fE25BmYES3BS8YY4wx52+2VL0VLoTA3//930/Z9tM//dMLXqt94QtfyF133cUDDzwAwPj4OP/8z//MG9/4xiWr1RhjjDHGXOLqC4cwaFxYhkLMpSqO43nbZwth0FJ5aYpZwCOPPMR3f/dr5u3zOPDitvvxfV+l/v0r+z2VO3qE6Kmds7ZFwBrg5BkcxyZqGGOMMcYYY4y5nNx11/MX7HP//V9f0hCGffv28ku/9PNzttfrdf7H//gAX/7yf/DpT/8rX/ziV/mv//VH+drXvjKj7xvf+JYlq9MYY4wxFw8LYTDGXNa+Z/0LeWL0AI+O7T+D3rMPXhYgaOAfTnyN8azGT255Nc6CGIwxxiyzNA18/mtP8/n/P3v3HWdHdd99/HPOzNy2vWlVEaogiSYhAaJ3jCtg3HAJsY1tHBecPDF2HD9xHLe4xhCM/bjGFccYF4qpBpneJIqQQCAE6tv7LVPOef64d1d7t6+0K63Q781L7M7MOTO/u3vrzpzveXgTr+5oIYxM30BaP4yw5GcyV4V1FsCMPjBHqT3jd6y1aK1QChylCCJLNgnZcrADPln0jfnZi5dErRTGWrRSWKC6JMkHz1jFeUctGv/OhBBiAllraQi20xzuJLQBnopTqst4PruO7f6LRDbKhxxYS4/pxLdZEipFjTudmJPAWkN70IxWDo5yydoeGoPt1Lmz6I7a86EKhc8SrvJIm26MNfnAhH7BOVppQhMAFlcNfcGuxQwOWlAKZXUhhsEUBThYLA4uro6RMxlc8kELxhoUmjK3gjIqaPJ3kDNZsKBQlDqVfftIqFK0o0moUpRS+DaDQjMzNo8jEiuZE188bL1CCCGEEPti7dq1tLa29i3PmTOHE088cUx9L7300r4QBoB77rlHQhiEEEIIIcSwVDB6CAMx+RuYGJ7jOiNuD4ZYZ5OJySlmFEuXLhu1zdMMDmF4rYvdc9eI2+sZWwjDzJmzJqQeIYQQQgghhBDiYDBr1mxmzJjJrl07h23z6KOPcMUVV07K8TOZDO9//3vp7OwYte3ll38ApRQzZ87ipptu4Vvf+k++/e2vY0x+IruqqiouvfQdk1KnEEIIIaYWCWEQQhzSPO3wmfmX8MmNP6Ix6Byh5fABDL3fGCx3tqwjshEfnfN6HK0nulwhhBBikJ6Mz9rntvK/t61ld3MXkTGFsASNNQat84EGkM9cKJ7XfLD+oQsAjtZExoAlvx8L2tGECnLTNH4czEgFDjETe9Hxhqijd9Cw42hOmj+H95+xksNqKkc6ihBCTKjIhjQE28maNApNua6kLWri2fQjNAX5k0AWMDag27ajcahy6qh0qwDojtoJTYCnPHxyNIY7qFOziGxIaH0cPBQKT8XwbY6WcBc5m8XpF4qgUGg0WdOTf3IewFVuoc/gP+0odD4sjhCHfhd8W4tCEddJciYfkNAb0mCIqHBrKNEVNAXbCayPY10iFVLqlPeFJ9R6M2n2d5MjTUKlyJo0WdIA1HgzWJJcxcLEsVgsofVxVQxHyZ+fhBBCiP1q9Ly915w1a9YULZ988snFYVQjOPnkk4uWH330UdLpNKlUasLqE0IIIYQQryH+6CEMNhbfD4WIg5XnjhzSEQ61MpGclFpGU1lZxezZc9i+fduwbZ4esOxufgnV0ICtr5/c4g6g2O23jrh9mtZgRjyDCsCMGTMnqiQhhBBCCCGEEGLKU0qxatWJ/PnPfxi2zZo19xIEAZ43sSGnxhg+9amP8dxzz47a9nWvez1vfevb+5Ydx+HTn/4XTjnlNK688oPs3r2Lv//7D8r5ZCGEEOIQIVfBCyEOeaVugs8teBv/+uKv6IqyY+oz1IBRyAcx3NP6DK1hN1cffgkJJzahtQohhBC9srmAux96nlvve462zjS+H+J6Dia0+eAFY/IDhAckL4w6FsdS6G+x7MlQ8GIO1ub3Zyscukst0VhH9owQxNC7h97XVq0ApahMJvi7U1fwxuOOHPPAGSGEGK+cydAVtRPZiLhOElcJXsisY2PmSTqj9nwwjbFkbA+hDUjoEqrcWlzlYWxEQ/AqWIiIaI0aQEGJLqcras+HKCgXDYQ2oDnciUcMUEXPa65yyZg0ClC6+OSRoxwC66OtM+h5VCmFthqDYeC8aQpFTCUJyfYF2wAYDFppqt16moNdBDaHi4clH86Q0vmwhTpvNm1hIz2mA20dHBWjK2wjIgJgemwuK0rOxFNxsrYHhabMqaLOnV102yR8QQghhBD7y8aNG4uWV6xYMea+9fX1zJo1ix07dgAQBAEvvfQSxxxzzITWKIQQQgghXhs6W1t5AYgB8QFfe783owyyF4c2d5RBBA+SDzZI9PsXAq4x6AMwGciyZUeNK4QBwHv0Ifw3Xzx5RR1I3d3E1tw7YpPaumnQsHvENtOm1ROPS2CLEEIIIYQQQohDy6pVJ4wYwtDR0c5jjz3CKaecNqHH/fd//zw33fS7UdtVV1fzjW98d8jrlk855TTuvfchvvrV/+BjH7tqQusTQgghxNQlV8MLIQQwP1XPR+a8ju++egu+HTivQPEA095BosMNBzVY1nZu5t82/4ar511CtVc2CRULIYQ4VKWzPn++51keXPsyu5s6sMYS2fxrVeBHg9rbvv/1CxFSqjAbeuE1Lb/YRyuFVfn1xpj8AOPIYj2Fmp2g0/h9xxyzYV48+wcbKcDVDssPn8lV559MfYW8hgohJoZvsvg2h6NcEipFS7ibFzJP8WL2GXImgy08E/kmB1hKnHLKnSq00nTaNnJRBoC06cKJNFXuNNKmmwAfV8VQShHZkNawgVCHBNbH6fcnF1d5BNYnIkQNeDJUaMBisEWBCXu2auxQ2yxonPzzqDUopfttsqR0GVmr8E0GhxgKMDaizKnCU3HqvFm0hLvImjQWQ6lTCUDOZMnZNDEdp9Zdyuz4AnL0ENmQEqeCeckl1Km5aDUw+kEIIYQQ4sB5+eWXi5YXLFgwrv4LFy7sC2Ho3d9khzB0dXWxY8cOurq6SKVSVFZWMn36dBxH3mcJIYQQQkxla5/fwCWjtHkxm6Fiv1QjDkbuKCEdu4DjBq78yhd5+E1vYcGCRZNU1fCWLTuKO+74y7DbnwUM0D8eIvbg/a/ZEIbYfX9F5XIjtqlZtHjUEIbjjls+kWUJIYQQQgghhBAHhbPPPo/Pf/6zw26vqamhYZTP1ONhreXrX/8K119/7Zja/+d/fpv6+vpht9fU1PDNb/7XBFUnhBBCiIOBhDAIIUTB6dVL6Qx6+PGOewgxQ7YZMoBhiAGlFtjYs51/2fRL/nXB25mdqJn4goUQQhxSWtp7eOSpLfzhrqdp78pgIoO1oHX+hUgrhSkEIxgzdEDCwLX9lx2tiEx+GHJk8q+DnusQRZZY3CFWl6DFDUgHuUH7mQhaKSqSCd57ynG8cfkSnAMwk48Q4uBnrQUsSmkiG7Ld38zG9Fp2+FswRPngAuWQMd24yiWpS6lwqomsoSHcRs5kCqEHkNQlGAudphWtHFzlYqyhM2oHq/BJo9B9wQiOcgmMT5dpAwtKF39Q0GgC6+Op2KC6NQ4hARY7ZEiDAgxRUbCDweAol5iKk7E9uNZDKYWxBo2mxKmghHJawp34NoOxFgeXUqf38m9LQpXgOB4pXQZYfJtBoZkdW8QRyeOZHVuYP0aseCCgP0TojxBCCCGmkMn40DaFZbNZdu7cWbRuxowZ49rH9OnTi5a3bNmyz3WN5KKLLuKFF17IBx/2k0qlWLFiBRdccAEXXXQRsdjg945CCCGEEOLA8jOZUdu4JaX7oRJxsHK9kUMYhhOPJya4krFZuvSoEbengc1A/3gIb829k1nSARW//dZB63JAjD2XD01bdSI88LcR9/PWt759wmsTQgghhBBCCCGmuoULFzFv3ny2bNkTsn/kkUs4//wLOf/8Czn++JUTFlofhiGf+9yn+elPfzSm9u973/t5y1tGi18VQgghxKFGQhiEEKKfN9avYnuuhb80r8MMcbXyMJN4D2un38qnX/gZ/zj3LaysXDhhdQohhDh0tLT3cPNfn+XeRzeRzviEkcFzHUKbD04wheCE3gCGgXoDhAYuK62wvWENhRc4rRSe5xCGUV+f2ullZGo0Ozu7iAI7YWN5tILew3uO5tjDZvDPF55OXXnJBB1BCHGoyJo0L2c3sDH9JJ2mDawloVP4NkfadOPgkNQlaOXSHXXQEuSTsj0dJ6nLUErTE7UTWp+4SoCCrE3TFOyk1CknsiEu+YtitdI41qXLtKHIBy/05yoX32bRanCQjFYOWIuxBmfAhwqlFI51MIRoYoO2JVUJaduNtrYv9MFgqHJqKHEqaA52kLUZtNVENqLcqeqrrcKZRkfYRKh8EjpFxnSTxqLRzI4v4sjk8RwWOxJDRGh9XBUbdLuEEEIIIaaytra2QhhXnud51NSMLxR34GwmLS0tE1LbcDZu3Djk+nQ6zQMPPMADDzzANddcw+c+9zkuvPDCSa1FCCGEEEKMj5/NjtomViLnOsTwvL0MWztQIQzLlo0cwgDwNMUhDO7Lm9GvvoKZe/hklXVghCGxu24ftPqbwHeBU4GTZs6iZMbMEXdzzDHH8aY3XTQZFQohhBBCCCGEEFOaUoo3vvEtPPXUOl73ugs577zXcfjh8yb8ODt2bOcjH/kAjz768JjaH3fccr70pa9NeB1CCCGEOPjJVfVCCDHAFXPOxzch97Q+2xfEMGzwwhgSGbpNlq+/ehNvy57CJfWrcYYYkCWEEEIMtLOhnRtue5L1m3bR2Z0FBVFkAEUQ5GcgN3ZPKMJQQQsD1xctW3AcXdjnnhCHyBgcRzNvTi3J2UnW7mqgp92f8IlUrQVHKcqTCS4/bQUXHL2ImCsfT4QQw2sNGtmUeYZt/mZ86xNTcUp0CbuCVwisj6s8YiqOIWKH/wqBzeHgUuXV4ek4xhq6ojZc5aKVS2gDmoId1Lmz6DYdKHRfwIGnYmRthijKP9/2rgdwlCayFkvUF87QSykNVmGsGfRZQaFQaCwW2y9MAcBi8VSCEB9jTV+Ig7ERDg41bj1E5EMlrIO1Fq00KacMRznUebNpCxroMu04ykWhaA+bUeTDHxYmjuO4ktPQSpExPWg0ZU4VlW7dntuFK+ELQgghhDgopdPpouVEIlH0XmssUqnUiPs8EJqamrjqqqt45plnuPrqqw90OUIIIYQQoiDIjRzCoAA3cWAGy4uDg7OX58MSifgEVzI2hx8+n1QqNeLnpKeBSwesi917D9nLPzCpte1v3qMPo9vaBq3/K9AE/AH4w84d8OlPDbuPkpJSvvOd/8aV86JCCCGEEEIIIQ5R//qvXxj3+dyxSqfT/PCH1/Pd736b7u6uMfWprq7mRz/6OQn5m54QQgghhiB/zRdCiAEcpfnoYa+nO8zyaOeLDDnn9zg/82VNwK92reGVdAOfmPsm4o43eichhBCHpE2vNHL3Qy/w0NrNZHIB1vQLWrDgaIjsnuWhDBeYoJUqDP7t7W/RShGLuQRhRNxzqK4q4fiVh/NYw07WvrqdaLiD7A3bWwc4WnPkzGn8yxvPoL6ybOKOIYQ4qBkbsS33Mi9ln6Mrai+EBVTQEbXSEOzA2AhPxdFK0x410mlaUShKdQUVXg1aadrCJiJCYiqBxdAWNgEWhcYUghMU4CqP0AY0h7uICIoCFRSg0eRMZshgAo0mJMBiUQM+HCgUForCFCAftKBx0Cpfh9PvTzIWS5lTSWh9Ok0bWBetNBERFU4NWrvUqBnosIlu04bBUKar8E2WLGlCGxBzEqxInsmM2OFkTDeRjUjoFIfFF1HlTpvg35QQQgghxNTR09NTtByPj39g0sA+kxHCEI/HOfnkkzn99NNZsmQJc+fOpaysDN/3aW1tZd26ddx6662sWbMG2++z+E9+8hOqqqr40Ic+NOE1CSGEEEKI8fOzI4cwxAClZWIGMTwvFturfvH4gRkI4DgOS5Ys5cknnxi2zdoh1r0WQxjif7pp0Los8OAY+8+cOYvrr/8RRx99zITWJYQQQgghhBBCHEwmOoChq6uTxx9/lDvvvJ0bb/xfOjs7xtw3lUrxq1/9jsMOmzuhNQkhhBDitUNCGIQQYgiu1vyf+Rfxny/fxBOdm7EMnsl27PIXzBosD3ZsZPPzu/mX+W/jsGTdKP2EEEIcKqLI8MKWRv54z9M89fwOgjDCGovW+YG8CjCF8ReRGToUQVEcvtC7rFRxWINWCoNFKzDGogrHr68p5a0XLufZtmZuXL+BbBgNud+90VdLYbkimeDy047n9ccdgSMXIgpxSMpEPWzObaDR30FgA5I6RVwn2JzdSEfYilLg4GFsxMaohdAGJFSKuth0PBUntAEttgtXeSg0PaYLE0TUuNPpiTpx0GilAAcstIfNOMpFofpO4uSDGFx8kwMUShe/4XeUS2BzWDvUZwENKAwhmuILZhUaVzmDthkb4ekYZbqKtqiRyEY4ysHYCAeHEqcMhYZQ0WXaCEwOT8VI6hIC6xOYHI5yqHbqmRVbgG+z+DaLp+LMii1gYeJoKt3aif5VCSGEEOIgpCYyTO8g4Pt+0bLnjT8ANzZgEFR2lIF143X55ZezYsUKqqqqBm3zPI+SkhLmzJnDm9/8Zp544gn+8R//kYaGhr423/72tzn99NM58sgjJ7QuIYQQQggxfkEuN+L2vRteLw4l7l6GMOzNZ52JsnTp0SOGMDxG8blAAO/+NRAEcADrnlBhSPyWPw1a/TAw8rMCvPnNF/Oe9/wdp556Oq4rl2sKIYQQQgghhBDj9fTT6/j3f/88QP7aamvp6OikoWE3DQ2792qfruvyk5/8guOPXzWRpQohhBDiNUb+qi+EEMOIaZer51/CN7b8kcc7N2HGPQQ13773JLMqrNsdtPK5l37Oe2ecxbk1ywuDw4QQQhyKgjDiyee2ccNtT7K7qZOsH+BohTUWpRTG2D0XLA2RhtB/1cBXKdvXRoGyWAvW5r8qlV8f8zSz6is5e/ViamdXcM2dD9HU1UP/nIeJHLrjasXyw2dy5TknMbd28MATIcRri7WWpnAX23IvkY56cJVLiVNOa9jI5uwGfJNFoVFKkY3SdJsuHKWpdqZR5lQC0BI0YjDEVJyAHA3BDqZ5M8lE3Rgb4aoYSikUHhnTQ0u4i4gQlz0XdTrKIbARvsnhquKLPVXhXbohGlS/Ih+oYLFYa4sSuBUKB3fQtt4Zi8ucKjoL4RG9xzQYKp1KSnUFFkN71IxvQsBS5UxDFwIZXOWR0mV4eHg6TmB9sJDUJRyXOI0FyaP7fj5CCCGEEGJwgEIQBOPex8Agh3g8vk81DXTOOeeMue3KlSv5xS9+wTve8Q7a2tqA/PvM//qv/+L73//+hNYlhBBCCCHGLzdKYFdczv+LUbh7EUqQiMUmfJbI8Vi+fAW/+MVPh93eDGwB5vdbp7u78J54jGD1KZNd3n7h3r8G3dw8aP1fx9D3S1/6GtOnz5j4ooQQQgghhBBCiENET08PDzzwtwnbXywW4/rrf8zZZ583YfsUQgghxGuThDAIIcQIYtrl0/Mu5j+33MQTnS+OI4jBDp4st5+uKMMPtt/O+u5X+eicN5JwXiPJ/0IIIcbED0Juvnc9f3viJXY2dhBFBmMsKIgKwQtghwxY0AwfvNAbyqCUApvvb7FopbAKPEcTRoaY51BZnuJNZx/NsUfN4pcPPcV9f3gCPzITflsV+dCH8kSCy09fwVtWLJ3wYwghDqzQBryS3URH1IqxEXGdIK6TPJ9ex+5gG8YaQGFtRLfpJLQhpU451W59PiDB+HTYFlzlAIrWqBGjDKW6nLTpxMFBK40iRmgDGv2dKGXRyum76FQphcYlbXpQKJQufjeucQgIcIb4M4hGY4gw1qCVHtQv/0xqUDh96w0RMZKAIcTHsV4+PIcIV7mUO1V4KkZLuKsQomBxlEdKl6OUosQpJyQgG/XgKA+rLB1hC2CpdOtYmjyfBYmjiak4OZvNB+eoxKD6hBBCCCGGZCcyTm/qKykpKVrOjTIz8VAG9kmlUvtU076aO3cun/70p/nsZz/bt27NmjW0t7dTWVl54AoTQgghhBAEAwK8BopJCIMYhRsbf+hbfC/6TKTly48ftc1jFIcwAMT+evdrJoTBu+n3Q64fLYRh0aLFEsAghBBCCCGEEELso4kM0S8pKeXnP/8Np512xoTtUwghhBCvXRLCIIQQo/C0w2fnv5UfbLudO1ueGkMQw8gBDL0iDA+0b2Bjz3b+ce5FLCmdMxHlCiGEmMKa27q599EXueeRF2hq7cZa2xe+YAGNwhQGyww3Zma44IX+2xSgdH5finywg9ZgrGV6bTlvu3A5xy6ZzROv7uBTv76V1u7MmGOGxsvRmhWHz+Rj569mdlXFJB1FCLE/dISt7PC3kDNZXOVS5lTTHOxkQ2YtPVEnvc9IvvHpMZ14KkaNO42kWwpAS9BAZCMcXHpMN1EQMS02k+6oA2MNns7PYBzZiPawhUD7GAwu+cAyBbjKI7A5lDV4qnjGYwdNiCm0LKaVg7LkAyEGbFZKo61LRIRmT8iBxaKUIqFKyNgePKtRSvUF5ZS7VcR0nKZgO6H10dbBEFHh1qCUIuWUYplOW9hIpEKSuoTuqL33qMzwDueoihOZ7s6l07RhCImpJDVuPVrtCXxIquJBhUIIIYQQotjAwIRsNou1dlyzxKbT6RH3eSBcdNFFfOMb36C1tRUAYwwPPfQQr3/96w9wZUIIIYQQhzbfHzn0Ky5BqmIUb7zg9Sz/wXW4gEf+4r3vAbeP0GciBxrsjSOPXEIqVUI63TNsm0eBdw5YF7v9Vno+92+TWtt+4fu4N/950Oou8uETI5EBHUIIIYQQQgghxL6LxxMTsp/58xfwox/9nKOOOnpC9ieEEEKI1z4JYRBCiDFwlOYjcy7E0y63N68lsNG4+g93ua/B0hR08MWXf8Ob6k7g4mmrSToH9uS5EEKIibe9oZ17H93EHQ9sJJ0NiCKDVvmgBaXAFBIQzBhmK82HNQwRvFB4sbE2P3A4v2+FUhB3HGbWlXPGCYt4w5lH0dzTwxf+dDcbdzYRmZGP2T/kYSx622sF5Yk47z11OW85fhlaZn4S4qAQ2Ygd/it0Re0YDElVQkIn2ZB+gldymzBEUHie6Yo6MESU6gqq3VqUcvBNjq5oGxpNREhz2ECtUrgqRo/pxFUeWmkslqzN0OTvxrfZotABRzkYa/LBDoqiwXOq8H9DCBSHMKAUWFV4Dhw86E4Vnj0HbrNYEjqJb3MYa9CFi6QjG+KpGLXedJqCXWRtGrcQ1uAoj6QuRStNnTublnA3WdtDTMUxRHSELVgsjnJYllzFstSJpE03vs3iKI9qdxrT3Nl9dZRQPoG/RSGEEEIc8iYrZW+KqqqqyodlFT5TB0FAS0sLtbW1Y95HQ0ND0XJNTc2E1rg3tNaccMIJ3H77nqFYW7ZsOYAVCSGEEEIIAN/3R9we03I+RIxs2VFHMXBY/gZGDmFIJCZmoMHechyHY489jocffnDYNkOFEbgvPI/z4iaiRYsnr7j9wL3nbnR726D19wPhKH1PPVVCGIQQQgghhBBCiH2VTO7730be8Y7L+OpXv0lpaekEVCSEEEKIQ4WEMAghxBhppfjgrPOYGaviJzvuIWCoIAY7bOACMGwaQ8b43NjwIE92vMQn576Fw5J1E1CxEEKIA8kYy+atTdzwlyd57sXd5IIwP/C3sN32/hvj4BgF2AGJCAMDErRSoMDRmtAYYp5DdUUJF593LKevWojjKH6y5kluXreRjB9M2rgcV2uWz53BP7/hdGrLZAZ3IaainqiLXf42fJvDVR5Vbg27/G08m36C9rAFRf75xDdZMqaLmIpT7daR0PkZgZuD3UQ2RKHoNh0QQY07rS+8wdP5gITQBjQHu0npUiy2L+BAoXCVS9p0o7B4qjiIzFEuOZtBW2fQe2gHBx8wGByKZ5VTaCxRYdueYAeLRePgKIeIEBevsD7//3KnmpzJ0GXasNbpC4oocypxlMs0byatYSNdUTsAZU4lGdODISK0AWVOFccmTqXCraIn6gCgxKng8PgSqlx5by+EEEIIMZkSiQQzZ85kx44dfet27tw5rhCGXbt2FS3Pnz9/wurbFzNmzChabmsbPOhHCCGEEELsX6OFMHhaj7hdCOt6g9ZlR+kTP8AhDAArVqwcMYRhLRAAA29d7LabyXzynyaztEkX+82vhlx/xyj9lFKcfPIpE1+QEEIIIYQQQghxiInH9/5vI0ceuYQvfOHLnH32uRNYkRBCCCEOFRLCIIQQ46CU4g3TVlHmpvjB9jvoijKj9xnjvg2Wl7O7ufrFn/L6mpVcNvNMHCUXaAghxMEmCCMefmoLN935FLuaOskFIVopjLH5r4XUhbGELwwMWehd2ddXgVPYpwKiwjEslrkzq3jrBctZvnQOJckYT2zZzvfueoStLe3jDl8Yso5h2lWXpvjgGSs5e9kCPMcZtY8QYvIYa2gIdtAddWKxpHQJnorzXPpJXso9R2CCwozBhu6oE4Ol1Cmj0qlFK41vsnSZFqy1+ORoCRuZ5s3EWkuP6cJVHlppDIbuqANlFWnThe4XfuAoj9D6dJvOfLBDPxoNWAwGpQZuyy9bzKDbpZRCW42xEY4q/rOGQhFTSQLro9F9+41sSFKnKHUqaQl3EdoQB4eQEFfFSDklpHQpOtJ0RK0EJkdcp/CUR9ak8W0WR3nMiB3O7NgCekwHgfWJqyRz44tZkFhGyimbiF+bEEIIIYTYC/PmzSsKYdi8eTPHHHPMmPtv3ry5aHmqhDC4bvH73SAIDlAlQgghhBCi12jvyeJazo2IUbiDL9cbPYQhOTm1jMOKFcePuD0LPAusGLA+fuufD+oQBtXSjPuXW4fc9pdR+i5bdjTV1TUTX5QQQgghhBBCCHGISezF30aOPvpYrrjiI1x66TsGnXcVQgghhBgreRchhBB74fTqZdTHKvjalt/TGnYPOzBVDbswNAtkjM8fmh7mqe4tXDHrfI4snbPvBQshhJh03ekcN931NI88vYXGli4iY4vCEYC+AIaRDBd40C93AdUviMFYi1L5oc0Jz2HurGrOXn0E564+AsfRtHan+d4tj3DP+hcJCnWMOSFoDHX1bnMdzYq5M/nUhacyrbx0/AcQQuy1jOlhR2Y3vvXxlEeNW8eW9GbWp5+kOWzIN7KQs1myJo2n4lS61VQUQgOaw90ENgAUnVEHjnKpcKroiloxGGI6DkBgAxqDnSRUEqxFF2Z002gsDp1RGyiF12+eKwVoHHybxVOxQbVrHAIibOG5rHibxmIHbbMWFC6ofNCELgSXWZsPbKh0a2mPmgmsj2e9wnOepdSpoMQpQwEtYQO+zQFQ4dYTWUNkAxSKUl1JuVOJVg45m0GjmO4dxpLk8cxNHDHk7RBCCCGEmErUeJP3XgOWLFnCAw880Le8bt06Lr744jH1bWxsLApw8DyPBQsWTHiNe6O5ubloubq6+gBVIoQQQgghevmBP+L2mCMTLYhReN6gVaOHMOz9bI8TZcWKlaO2eZTBIQzeU+vQ27dhZh+c1754N/4ONUT4ymbgxVH6nnXWOZNSkxBCCCGEEEIIcahJJOJjards2dGcccZZvOUtF3PccSsGXZMohBBCCDFeEsIghBB76YjS2XzryA/w1c03simzo2hg6qCPauP87GawbM7s4t82/5oLa4/nHdNPI+mM7YOjEEKI/evlbc3c/uBGHnvmFbp6skSRxZIPShir0YIXBrZRSqEUOFoRGUsi7lFfU8bbL1zOqmMOx3U0kTHcsu55fnzf43RmcsU72ksD61SFf1UlSa489yTOXjo1BqkI8VpkraUp3E1P1InFUqLLcJTDhsw6Xsg8S2B9lAJjI9JRGoMhpUqpcKtxlEPOZGkPWolshCFDe9jKNC9OaEN6TDeu8tBKE9mItrAZLKRNN06/Pxt4yiOwPqEN+oIPemnlEFofrEJpNWgbNl8bqvjiUkU+RCYiwh3wJwqFxlGKiBC3X7CDISSlynAU9JhOFB5KaSJC4jpByiklpuI0hTvxbQ5jIlK6lKQuwVqDUpoSXUZERFKXYjGkTRcODgsTR3NE8jhmxg5HKY0tJN7IyRghhBBCiKntzDPP5Ic//GHf8kMPPTRk0NdQHnzwwaLlE088kZKSkgmvcW88+eSTRcszZsw4QJUIIYQQQohe/hCDsfuLaWc/VSIOWo6DVQrVL7x9tBCGxBQIYZg5cxbTptXT2NgwbJuHgSuHWB+/7WYyH/ropNU2mWK/+sWQ6/8yhr7nnHPexBYjhBBCCCGEEEIcohKJJH//9x9AKYUxBmstiUSKqqoq6uuns3DhYhYvXkxVlYTaCyGEEGJiSQiDEELsg2qvlC8sfCc/2HYnD7ZvICAsbrDXY7XyM6f71ufPzY/wYPsGrph9ASdUHLGPFQshhJgIxhgee3Yr9z32Aus27sAPQozdE1KgyM/UDkOHK0BxoEH/NkO1V4DWCmMsWoE1thDEoDhq0XTeesFxLF04A8/NX9j30u4Wvnbzfbza3IYZuEPbb6d7oX+3mONwxpJ5fODMVdSVTY0BKkIc7LImQ1Owi8D6eCpGlVvLdn8L69NP0hjsLDzHWHzjkzUZPOVR4VZT6eZPHjT5u8jZLFjoUu3ETJxSp5yOqAWLIa7jWCw5mz+OqzzA9oUqOMrBWkt71IzCFiIS9lBoApsjphID1ucDFSKiQYPdVKGfhcHblMLBxWKKthkMSikq3Fraw2YiG+VrKzyJlbkVxFUSG0LadmGNQaGp8GpQKLRyKNHlaNON1hpPJeiIWlEokrqU40vPZHHyWMqdKrImgyEiphLEdHHwmYQvCCGEEOKgZIf7JPratWLFCqqqqmhrawNg27ZtPProo5x00kmj9r3xxhuLls8+++xJqXG8HnvsMbZu3Vq0bvXq1QeoGiGEEEII0csPwhG3x1wJYRBj4LrQL9BjtBCGePzAT9qhlGLFipXcfvutw7b52zDr4zf97qAMYdDPPoPzzNNDbhsthKGsrJxVq06c+KKEEEIIIYQQQohDkOu6fOc71xSt8/3oAFUjhBBCiEOJhDAIIcQ+KnETfOrwN7GwcTq/3HUfvg0Au5eDW+2gWcYtluawg2+88nuOKZ3HB2adz8xEzYTULoQQYnx60jkefeYV/vTXZ9ne0EZkLLbfU/5QoQrDGUsbrcDYfFvTG7wAJJIexx4xi/NOPZIVS+fsqS/nc83tD/K357fgR2b0AvZybLFWUFtWwpXnnMhpR8yTQcpCjJO1luawgZ6oC4CUU4qDy8bMOp7PPEPOpFFojA3J2AwWS1KXUOFU4SiXnMnQbtqIbEhEiIraSTpJciZHt+nGxUNrTWRDWsIGLIaMSeMU/gSgULjKI2PSgMJRxRcFu8ohZwIcQOnix7ejXAKbxdoIBvTTOPkQBgyKwdtQdtA2Q0SJKscnR2h9XOuhlCKyEQmdpMKpQllFW9REZCOwlqRTQlKnAEW5rsEYg0+WhE4QmCwdJn+5arVbz9LU61mYOJpu04FvcrjKpcKpxusXtpBySvfl1ymEEEIIIaYArTUXX3wxP/nJT/rWXXfddZx44okjfmZ9+OGHeeKJJ/qWS0pKuPDCCye11rFIp9N86UtfKlq3ePFi5syZM0wPIYQQQgixv/hhMOL2mCOXYokx8LxxhjAkRmmxf6xcuWrEEIZXC//mDljvrX0S56UXiRYumszyJlzsJz8acn0WuHeUvqeffiae5014TUIIIYQQQgghhBBCCCGE2H/kzJ8QQkwApRRvrj+BRSUz+K9X/0xD0LYXexl5OG5IxLrul/jMSzu4aNpqzq9eQamb3LuChRBCjEtjaxf3PLyJ2/62np6MT2T2hOYMDM+ZSNbmAw8crTHWUpqMs2BOLZe9aSUL59btmTHeWm5eu4Gf37+O9vRol2n1PwDjCmJQgOdozlw6n0+cfwrJmFw4JMRIsiZDU7CbwPp4Kka1W8e23Ms8m36SxmAnFosFAusTmAyu8qhwq6hw8oFbTcEusiaDQhHZkIROkqSEtqgFiyGuE1gsGdNDY7AbjUYBWmkgH5gQ2oDWsAmL7VsP+SAGhSIkwB30p4F84IthcJiLgnxAxBDbUArHekRE+dCFAmMNWilSupwe04myCqV04dYryt1KFJqmcCeBCVBWYbFUONUAlDkVGCK6onZQEFNxOqI2sPnbuiS5gmWpVcR1nO6oAwukdCnTvJmowm2u1tP26ncohBBCCHFwmqxPqVPbFVdcwQ033EA6nQbgscce44c//CEf+tCHhmzf0NDA5z73uaJ173vf+6iurh7xOEcccUTR8s9//nNOPHH42U2/9KUvccUVV1BfXz+Wm0Frayuf+tSneOGFF4rWf+ITnxhTfyGEEEIIMbmCMBxxe8xxRtwuBIB1vaJTdKOd3Usk4qO02D9Wrz5l1DZrgPcNsT5+4w2kP/P5Ca9psqjODmL/e8OQ2+4DMqP0P+ec8ya6JCGEEEIIIYQQQgghhBBC7GcSwiCEEBNoSekcvrzovXx/2194qmsz4VCD04Zkh/hu6FbdUYZf7bqXO1vW8nczzuXEiiPRMgO5EEJMOGMsm15p4Ld/Wcu6jTvwgxBbeJLuH7wwpqEtwyQ1DLVaK7AoHK2IjEEpRSzmcvJx87jo3GOZVV9RNIvnhu0NXHfnw7ywu3nvhtmMMYhBAXNrK/nE+adwzGHTR5xJVIhDibWWpnA3PVEXACVOGQ4uGzLreD79TD5EQSmMicjaDAZLSpdQ7lTiKpecydAQtRDZiIAQHWniXoKcyZG23cRUDKU0oQ1pCnZT7daSNRmcwsd5hcJVHj1hF0qpovADyAcx5Ew2H6sw4GHrKJfA+hgMGl20rTdowVo76PGeP4YdtM1iKHFKyZg0kQ1xVL7GiJCULqPanYYNDT2mG20VxhqSTglxnQ8Wq3Vn0BI2kDMZUrqUnMmQsxmshaRTworSUzg8fgTtUQuhDXBVjOnebCrcPYPkar0Ze//LFEIIIYQQB7Xq6mo+8pGP8O1vf7tv3be+9S127tzJlVde2ReCYIzhr3/9K1/+8pfZuXNnX9tp06bx/ve/f8Lr+sUvfsFvf/tbTj/9dC644AJWrFjB7NmzB7XbtWsXt956Kz/72c9oamoq2nbuuedy3nkygEcIIYQQYirwo1FCGGTmezEWbvHf8kcb0B+LTY0QhuOOW0EqleoLvxvKfQwdwpD43W9Jf/pzoPUQW6eexG9/jerpGXLbn8bQ/+yzz53YgoQQQgghhBBCCCGEEEIIsd9JCIM4aLz44os899xzNDY2YoyhsrKSRYsWceyxx+K6B+aunMvl2Lx5My+99BKtra1kMhnKysqorKxk6dKlzJ8//4DUJQ6s2lg5n5v/dv7Y+Ai/bbifnPHHPCi2/6zqw7GAxdLod/CdrX/g8EQ9H5n9euanZMCZEEJMhEwu4IG1L/GrW56ksaWLMDKDwhImak7R3v1orbDWgqUQ9GCxFirLkrzxzKM59fj5TK8tL+rb2tXDT9c8yV3rXyIwYw392TupmMtFK5byzpOPoyQem9RjCTFVZUyaRn8ngQ3wlEe1W8d2/xXWp9fSEOyk9xHtG5+czeCpGOVOJZVOPiCgMdpNxmRQKCIbkdBJHBzao2YslrhOYK2lJ+qmf0SLUvmLEV3lEtiA1rAZrEX3u0hRFf4LbUhcFX82UoV3lnaIcDCtNMoqjI1ADfxMpXBwiAhx2XPRsLH5wIaYjpMzWTy8fMgEBlBUuDUkTSktYQPWBmAVSinKnAq00tQ49Wg0nVEHjtJ4KkZ72EI+fkYzN76IZalVgCFtetBoSp1y5sYXE9P5i0zrGTxgTQghhBBC9DO5HxGntCuuuIJ169Zx77339q37zW9+w//+7/8yc+ZMysrK2L59O52dnUX9EokE//Vf/0V5efnAXU4I3/e5++67ufvuuwEoLS2lrq6OsrIywjCkubmZxsbGIfuuXLmSb33rW5NSlxBCCCGEGL9cOEoIwwG6fkUcXKxbHNYxWghDIpGcvGLGwfM8Vq06kTVr7h22zZph1jvbtuI9+jDB6lMmp7iJZC2Jn/5oyE2G0UMYlixZxsyZsya8LCGEEEIIIYQQQgghhBBC7F9y5k9MadZafv/73/PDH/6QV155Zcg2lZWVvOtd7+JDH/oQqVRq0mvatGkTd955Jw8//DBPP/00QRAM27ampoZLL72Ud7/73X2zbIlDg1KKi+tXc1TpXP572y1szTaOMGC3MMCO8Q3qtVgCG/FSZiefe+l/OKnySN5RfwbT41X7VrwQQhyidrd08ue/Pst9T7xIOhtgbT4IQSswduSAnDEZ4YnemPwGRyu0VkyrLmP18nm86ayjqCwrfn/jhxF/fnIDv7h/Hd05f8++J4GjFHNrq/jMm85gQX3N5BxEiCnEWENjsJPuqAuwpJwyPDw2ZJ7ihcx6cjbbF6KQNT1YIKlLqHQqcZRL1mRoN61ENiJUIQpFwkuSNRnStpuYiqGUJrQBTcFuqr1asjaLW/horpTCxaM76kIp27e+l1s4hsPgWaIc5RBYHzvEE41GEWGx1qKUGrAtv69B2xQkVRlZ250PXiiEQURElDplVLo1NAY78I2Pg4MhIqlLiKk4MSeOQtEaNhAQkFKl+DZHLsxiMSR0iiOSxzEzNpeuqIOQgLhKMCs+jxneYYNqFEIIIYQQYqy01nz3u9/ls5/9LLfeemvf+iiK2LZt25B9Kisrueaaazj++OP3V5l0d3fT3d09YhutNe9///u56qqr8GQ2ZSGEEEKIKSOIohG3exLCIMbCG28IQ2Lyahmnk08+dcQQhpeB7TBknHLiVz8/KEIYvHvvwX3pxSG3PQbsGqX/BRdcOOE1CSGEEEIIIYQQQgghhBBi/5Mzf2LK6uzs5KqrruLBBx8csV17ezvXX389t9xyC9dffz2LFi2alHoaGhr44Ac/yKZNm8bcp6WlhR/84Af86le/4vOf/zwXXXTRpNQmpq5FJTP50sL38utd9/HXlqfJMfSsGP3H5aqBG0ZhgawNWNO2nic6X+LNtSdyXs0KKr2SfSteCCEOAVFkeObFnfz6tsfZsr2VIIyKhy+rPROI2kkIYlAKtFZgwXU1dVWlXHDqUi44dQnxWPFbdWstj720jWtuf5CGzp7ifU4wBaTiMd536nIuXrkMRw8e8C3Ewawn6mZ3sJ3A+LjKo8atY2ewjfU9T9IUNhRaWXyTI2syeDpGhVNNpc6HXTUGu8ma3kCGkIROkKKEtrAFiyWuE1gMadNDc9Cw531eIcjAVR6B9WkLmrFYVL/HmFYKZSGyEZ6KFdWtCg94M8TUxqoQpmCIcHAGbM1HLeS37XluiWx+WWuH0Ia41kUphbEGhaLSraEn8ugybVirweaft8qcClzlMc2bTXOwm7TpwsEhrhJ0RR0YG2KBmbHDWZhYRkREOurCUS7V7jQWJJdR5lTs1e9OCCGEEEKI0cTjcb797W9zwQUXcP3117Nx48Yh26VSKS666CI+9rGPUVMzecGD//Ef/8EjjzzC2rVr2bVrtKE6UFdXx4UXXsh73vMe5s6dO2l1CSGEEEKIvZMbJYQh7sVG3C4EAE7xecDRQhiSyeTk1TJOJ5982qht1gDvHmJ9/E830f3vX8FO4mewiZC67rvDbvvDGPq//vVvnLhihBBCCCGEEEIIIYQQQghxwEgIg5iSstksH/jAB3jmmWeK1nuex6xZs4jFYmzfvp10Ot23bdu2bbzvfe/jhhtumJQLEzs6OoYNYEilUtTV1VFRUUFXVxdbt24l6nfivbu7m6uvvprm5mY++MEPTnhtYmorc5N8eM6FrKpYxH9vvYW2sGfQDMVDBjCMk8XSE2W4oWENtzU/zqX1p3JuzXLiWmZJE0KIgdo60tz96PPcsuY52rsz2METxw+mxh/EMCBzIb+udweFDY7jMKe+ksveuJJjj5yF5w4cPA2vNrXxzVv+xgu7mjADdzgRLyL9uFpx4vw5fOTck5hZVT4xOxXiAIhsxE5/G11RJxZLSpeQ0Ak2pJ/ixexzBDZAoTA2oifqwioo0aVUOtU4yiFrMrSbViIbEZkIRRtxL07OZEnbbmIqhlKayIY0BbupcmrJ2gxu4WO2QuMql+6oCxS4FL8nc5VLzmZxGBxy4qAJMfmAhgEPbo3GYLDWotSebUopHOtisUNsg4QqIWszaGv6wiAMEWVuJaW6jIZgJyH5IIaIkJQuJaYTeCqODh06omYMESW6nNCGBFEHoQ1IOSXMiy+mzptJh2klsiEpXca8xJHMjS/EUfJnByGEEEIIcWBccMEFXHDBBbz66qs8/fTTNDQ0EAQB5eXlLFiwgBUrVhCPx8e93xdeeGFc7d/+9rfz9re/HYC2tjY2b97Mzp07aW1tJZPJ4DgO5eXlVFVVsXTpUubMmTPumoQQQgghxP7jR4NDcvvzPDk/L0bW2trC3/wsBgiAEFg/Sp9EIjH5hY3R8uUrSCaTZDLDR0f8laFDGFQuR+LXvyDz8asmq7x95j61ltj9a4bcZhk9hGHmzFkce+zyCa9LCCGEEEIIIYQQQgghhBD7n4yGEFPSV7/61aIABq01H/nIR7j88supqMjPmOr7Prfccgtf+9rX6OjoAKC1tZWrrrqKG2+8EccZPIBxIi1evJi3vOUtrF69miVLlqD7zV7b3d3Nn/70J6655hra29v71n/jG99gwYIFnHXWWZNam5iaVpQv5NojP8IPd9zBg20bCNgT1DHkuNm9GkxrsVg6ox5+tutO/tz0CBdNW835NcfjKJnFXAhxaDPG8Mymndy8Zj1Pb9qBH4w8U9GQxhnEMDAfwfb+T0E87nLisYdz4WlLOeLwerQevNeOdJbv/uUBHtr0KuGg9IUhDra3QQyF2e1rSlNccdYJnLNsQdEAbiGmso6wnZ3+Vnybw1UeVU4NjcFu1qfX0hq2FEIMLDmTJWt78FSMKreaSl0FQGOwi8D6YBVdtoOYilOqy2gLW7BY4jqBxZIxaZqC3ahCaEJvkIGjXEIb0Bo259f3+1zQ2zayEZ4qnv0sv81iGHzBbn6bIiJCDwhpUIU1BoPDns88hghXuYV+YV/og7EGhaLWractaqbHdOMWwhoUilJdTlwnqPdm0RzuJmsyOMohqVOko25CAoyy1MVmMTe2gJzNkjVpXOUx3ZvNouTR1Hj1e/vrE0IIIYQQYtLNnTt3UoKb90ZVVRUrV6480GUIIYQQQoh94JuRQxjisdiI24V48cUXuXT37nH1SSSSk1TN+MViMVauPJH7779v2Da3M/ypy+T//ITMRz8Ok3xd195KXnfNsNs2Ai+O0v/CC98g51mFEEIIIYQQQgghhBBCiNcICWEQU87mzZv53e9+V7TuG9/4Bm984xuL1sViMS655BKOPvpoLrvsMjo7OwHYsGEDf/zjH3nrW986KfWdeeaZXHnllRx33HHDtiktLeXd7343Z599Nu95z3vYvn1737avfOUrnHrqqTL7wSGqxE3wycPezEkVR/KznXfT6LdjBs6RvpfhC8XdLQZLc9jOT3fewe3Nj/O62pVcUL2yKDBECCEOBa0dae57fBO3PbCB5vYezGhhBhMkP+w7z5IPOXBQlJbEOfX4BZyzejEL5tQN2TcII35y3xPcsnYjmSAc+0H3IohBAZ7rcPoR8/jU608hIe9RxBQU2pCtuZfpCNuxGBI6RVKneD7zLC9nNhEVwq2MNXRHXVgiSp1yqpwatHbImjQdUQuRjTBkaQtbiXlxAuuTLgQzKKWJbEhL2EjkRGRtBrfwkVmhcJVHOuoBRV/AQS9HOWRtFkcNvmBQ4xAS9IUe9KcKcQrW2qIL8pRSKKux1gx6TCsFcZUiZ7Noq/v6RTaiwq0ioVM0+rsIbYCDQ0RIiS7D0zFq1XR02ERX1I7BUO5UYIhIR934NkeJLmNWbC6VTjWdUQcGQ6lTzhHJo5kXP4K4njozbQkhhBBCiBHY/fO5VwghhBBCiEORb0YO+ZZrQcRoXHf84QOJxNT6+/wpp5w6YgjDTuAZ4NghtjlbXyF2z5345184KbXtC+fll4jf/Mdht//vGPbx+te/acLqEUIIIYQQQgghhBBCCCHEgSUhDGLKufbaa4miPSet3/KWtwwKYOhv0aJFfPrTn+Zf//Vf+9Zdd911vPnNb57Qk9vV1dX85je/YcWKFWPuM2PGDP77v/+bSy65BFOYDWHr1q089thjnHLKKRNWmzi4KKU4qfIIjik9nB9sv41HOl4gsBFWjTxjxvDyF1UPN+bWYNjuN/PTnXdyd+s6Lqo7mdUVS3H11JxVQAghJoK1lqdf2MGdDz/PExu2kvVDBmbeTHoN5J+blVJoraitLGHV0XO59PzjqCxPDd3HWv7w+HP86v51dGRz+3bgMdAK5tZW8k9vOJ0lM6ft3fGEmEAtQRNbc1vwbQ6NQ4VbSVvQyobMU3RFnX3tciZLj+kmpmJUu3WU6nIAGoPdhAQoq+iMOnCUQwXVdIQtWAxxHccW+jcGu3FUPpxKFb46yiW0AW1RM1hQ/cKregMUIhviqeKZzPJhCvkQiIGPP0dpsBARodFD9LNYDIo9780MBg8PVP54jnL79q/Q1LrTaAmbyNkMrnUxWDSKMqecmE5QH5tBo7+bnM3iKI+ULiVr0gQ2wFEOtV490705ZEwPOZvF0zEWxZZxZPJY6r1ZMkOTEEIIIYQQQgghhBBCDMMfJezbi8VG3C7E3lzLlEwmJ6GSvXf22efyta99adD68vIKzl58BG9+4jEOG6F/8rprpmQIQ+obX0OZoa/dscBvRulfWVnJ6tVyPZgQQgghhBBCCCGEEEII8VohIQxiSuno6OCuu+7qW1ZK8fGPf3zUfm9961u5/vrr2bFjBwA7duzgoYce4owzzpiw2mpra6mtrR13vyVLlnDaaaexZs2avnUPPPCAhDAIUm6cTx1+MRu6t/L9bbexw2/G7OUIYTVwYYjdGAyvZBu4dtufuKnxAd41/SyOK1tITMtLgRDitSObC7jlb+u594kX2dnYQdR7IVxvMMHeBjH07zuG/fSOX/Zch/qaMl5/+jLOOekI4rGhn3OttazZ+DL/767HaOrq2bP7SRwHXZaI83enreANy48g5sprgdh/cibHy9lNtIUtRDYkoZMkdYrN2RfYlnsFQ4TFYq2lK+rCEFKiy6hxp+Foh6zJ0BG2olAENqAlbKTem0lERNp04+GhtMYQ0Ra2Yh1L1mZwCh9/FeDpGBmTQWFwVfHFjq5yyZjMoMAEAEc5hDYYFJqQ36/qq7soxEAplNXYQQENFoUirlL4NoeH7usX2YgKt4qYitMcNmBtiIMmIqRU54MWpnkzaQ5202O6sRgq3WoMlkyUD1Yoc8op1RWUOKV0my4slmqnjiWpY1kQX0rKKZmIX6cQQgghhJiK7H5OIRRCCCGEEOIQ4tuRJ1eIxxP7qRJxsHLd8YcwJBJT6351zDHHUVtbR3NzE0cddQznnHMe55xzHitXnoALVB9/FM6uncP2jz38IO6jjxCeeNL+K3oUzgvPE7/pd8NuXwdsGmUfF1zwelw57yqEEEIIIYQQQgghhBBCvGbIX/3FlHLfffcRhmHf8gknnMCcOXNG7ae15pJLLuHaa6/tW3fPPfdMaAjDvli5cmVRCMPOncOfaBSHnqWlh/HVxZdzV8s6ft/wID0mM44xwrZoLJ/KrxrQovhrhGFbrolvvfp7arwy3j79DE6uWCZhDEKIg9rWXa38+i9P8tQL20lng8EN9iWAYQxU3//y4jGX+bNrec+bVnHk/HocPXgwd68nX97OdXc8zLaWjsEl9g9+mCCuVpyy+HA+dPYqpleWT9yOhejHWsuuYAdbsi/SE3XhKJcKp5LuqJMXs8+TNj35gWFK4Zsc3VEXrnKp8aZR7lRiraUp2E1EiLaaHtMNkaJO1dMetmGweCoGWAIb0BjsKiyDUvnHm8bBYmmPWlDkPzP0UoV/EREe8QHV5x9whsEX0vYGM0QY9IAQBo3GYAYFNBhr8ApBD5GNcJTTt16jqfGm0xo24JssLh4Gg1aKUqecmMrX1hI2krNZPBUjpUvJmSyB9fFUjGq3lmnedDI2nQ9zUDGOTB7DEbFjmRE7DK2Gf/4RQgghhBBCCCGEEEIIMT65UULPvFhsP1UiDlZ7M0g/kUhOQiV7T2vNj3/8c+bPX0B9/fRB27Pv+3tK/vPLI+4jdc236PzV8KEH+1vJ17+CGuHx/esx7OPii986cQUJIYQQQgghhBBCCCGEEOKAkxG3YkrpH1QAcOqpp46578knn1wUwnDvvfdOWF37qry8eIBjd3f3AapETFUlToKLpq3mhIoj+NH221nf8yqhDSdtvLAFQiIagw6+t+1m/nf3Gs6pWcEba08krsc/64IQQhwIPZkcf33sRf68Zj2NrZ2TP9HnMEEOvas1EI97nHPiYt5wxlHMnFYx4u42bm/ku395kM0NLaM/31uGDGIYT7aEVjC9ooyPnb+aExceNsZeQoysJ+pmU2YjO/3tBNYnqZOU6FK2+a/QFOwuBBJorDV0Rh2ENiDllFLnTsfVLjmTpTNsx1Eai6ElaECj0Mqlx3Tj4qF1fltP1AXWkjVpnL6PsgpPefjGJ0cOVxW/j3GUQ2Bz6CEeQK5yCKyPweAMGagQYa1FqT19lVIom789xbvMt0uoJIHxUei+foaICqcKF5fWqInIWjSaiIhSp5y4ilPnzqQ53EXG9GCxVDrVWGvJ2jQRAWVOBSldSkInSJseIkLK3UqWJpezMLGMEqeUWMwpqtf3o33+/QohhBBCiIPUpH9AFkIIIYQQ4tDlj/J+OxYfGPwrRLG9C2FITEIl+2b16lOG3ZZ53/tJffdbqGx22Dbxu+7AefYZoqOPmYzyxsVd9yTxm/847HYD/HaUfdTU1HDaaWdOYFVCCCGEEEIIIYQQQgghhDjQJIRBTCkbN24sWl6+fPmY+x511FHEYjF83wegsbGR1tZWqqurJ7TGvdHQ0FC0XFlZeWAKEVPezHg1/3fBZTzesYmf7LyTJr8dg+0bezvwcg418PveRmOcMd1iibA0Bu38dvd93NX8JCdVLuHiulOp8FL7foOEEGISvLClgT+teZbHn9tKzg/378EVaFv8fKwdTW1lCRefeyynLJ9PeenIF0G9uKuJ7/7lITbtbMKM59j7EMSQinlcvGopf3fa8Thaj+eoQhDZiK25LbyQ2UB72IYCypwKfJtjh78V3/ho5aDRZEya7qgDrRTVTg1Vbi0oaPJ3YzC4yiNrMjQEO5kem0lH2IbB4KlY4VghTUEDcZ1/HGmVv78qNI5y6Io6UUoNCFtQaDQ+Ph4Dw6TyDxo75KMtH81giIYMYbDYQQENkc3fBlX4uTgqv81Yg0ZT502nOdiNb3xcPAwGhaLUKcfDQylFS9hEzmbxVIwSXUbOZAmsj0eSuJOixqsjY7oJbYCjHBYklrEsuZyZsblopbHWYrF9P5uiW6vG+CZQCCGEEEIIIYQQQgghxF7xR9kuIQxiNJ43/okxksnkJFQyeWxdHZn3/B2pH/1gxHYlX/0inb++cT9VNQxrKf3c1SM2uR/YPspu3vSmi/bqdyuEEEIIIYQQQgghhBBCiKlLQhjElBEEAVu3bi1at2DBgjH3j8ViHHbYYbz00kt96zZv3jwlQhieeOKJouXDDz/8wBQiDhqrKhZzVOlc7mxZy+8bHqTbZEYcYNs33G4vJ7mzgMHQHHZwa/OjrGl7mjMqj+Gs6uOYm6zfu50KIcQEyvkhtz+0kdseeI5dzZ1Fk3ru1yHHFowFrcB1NEfOq+fC05exatlhxGIjv7XeuKOR793xMM/vbNrbp+thDQpiKAQ2OFqx8vBZ/OMbTqO2rGSCjyoOdrbwQOoduN8WtrAxvZ4tuRfJGR9PeZQ7FTQGu+kx3SgUjnIx1vBC5jl8GxBTcaZ59SSdFL7J0R424SoXBbRGrRgspbqMHtONg4tWGgeLb3M0+DvxrY/T72Opo1x8k6Mn6sItBDP06g1GsNYOeuA7ygGbD03QQwQqGEKstUUhBUoplHWG2F9+OaGSBNZHW93XzxBR4VThKY/msBGsRaOJiCh1yomrOPXeLJqCXWRMGoOl0qnGWkuOLCER5U4FSV1CTMfJmgwhhlKngpPKV7AwsZRSpwxrLVEhHGJgsIJSCrV/n/mEEEIIIcTBZqI/dAohhBBCCCEAsMaQG6VNLDFyWLcQrjv+y/USB+H9KvPRT5D82Y9R4fCh+vG778R78H6CU07bj5UNqOGm3+E98diIbX42hv1ccsnbJqQeIYQQQgghhBBCCCGEEEJMHRLCIKaMbdu2EfY78ZZIJMYdoDB9+vSiEIYtW7awatWqCatxb2zdupXHH3+8aN0ZZ5xxgKoRB5OkE+ct01ZzUsWR/LHxIe5rW0/O+oOuoR40BG+vxuTZwmA+C1i6ozS3tTzKPa1PcmLFEs6rWcni1GyZXVkIsd+9tK2J3965jrUbt+GH0Z4N/VIHbL9VIxqUVDB+WkEqEWP1sfM464RFHLV45ojtrbU8tWUnP7z3cV7c2bzn8Hv7dGqH76sGfD+7qoJPXHgKx82dIc/fh7DIRvg2h4ODp2IE1mdzdhPr00/REjZjrSGhUygU7VErFoipGBpNu2llU2YDAKW6jLrYdBzl0Bw0EmGIqzgREQ3BLurVDNJRFwaDVwhPUBg6ojZyJovFopUuVKVwlUfGpFFKF4UwQD5QIWcD3CHe9SggwgxxSwshCdYMeowoHDQGg8HpF9BgrMHDBQWRDXGUW1iff19U506nJWwgZ7K4xDAYFIpSpxwPD1xFa9hIzubwlEeJLiVnsgTWJ64SxN0UNW4dadNNQICDZlFiKctSy5kVm4tWmshGfbe5qGalcOXjuhBCCCGEEEIIIYQQQkwp1hg+AARADvAL//p/X1t14CcKEVOb63qjtqkFTgAyQPcRR1JRUTnJVU08M3sOuUvfQeKGX43YruSLn6f99nvhAJzPVN1dlPzHv43YJgf8wfMgCIZtM3PmLE444aQJrk4IIYQQQgghhBBCCCGEEAeajOoQU0Zra2vRcn19/bj3MbBPS0vLPtU0Eb71rW/1zTIMsHDhQo4++ugDWJE42NTHq/jwnDdwdvVx/HTnXbyU2UlkDbZvJG7h/rWX56NVYU8DRyZbLFkb8Lf2Z3ioYwOHJabxtvozOLp0PjEtLx9CiMnj+yG3PfActzzwHA2t3WPuN0I+wT5ztKK2ooSzTljMeauPpK66dNQ+D2x8hZ//7Um2NLVh9+MspGWJGH93+vFceNwRxD15vj4URDaiO+oisiExHSelStgd7mRD+hlezD5PZEJQiriK0xN1YzC4yiOu41g0O/ytZE0WB02VV0uJLiUkpClowFEujnJI2x4a/J3UetPojrpwcFBK46IJbUCjvxsw6H4hBxqNQdFjunFV8X1RofLRTzZC6eJHriYf1mCswRkUqKABg7W2KFxEKdDWwWIHbQNIqBQ+ObTVfdsiIircCuIqQXPYQGhDHDQRIaW6jLiOM82bSVOwm7TpwWKpdKqx1pAlQ2hDypwKSpwyPBUnY3oICSlzK1mWWs6ixDJKnFKstUREhZ9ZcV0DwxeEEEIIIYSYCGo/fgYVQgghhBDiUKJdl+sXH4G76YVh27Rc+o4ho4SF6OW6o58b+DVwXuH7tuv+H+G8+ZNa02RJf+Ifif/vb1Bm+EeFt24t8Rt/S+5t79yPleWlvvJFnJ07RmwT8zyevO1OfvPIQ/ziFz9n0xCP/0sueRta6yF6CyGEEEIIIYQQQgghhBDiYCajssSU0dPTU7ScTCbHvY9UKlW0nE6n96mmfXXbbbdx++23F6371Kc+NWVmo47F8id2x3KCVxx4y2KH8Y3K9/Nkx4v8aOud7Mq1ElGYFX6v71J21O4WCG3Ey5mdfPPV31LulvD6aSdyXu0KKr3RByHL/UtMFrlvvfa8uquV/7n5MR5/bit+EI3ceJgBJaMGMfTLrhmNAlxXs2T+dM46YRHnnXTEqPc7ay23r9vE/9z3JLvauoY/VO+GCXxL4Dma849dxAfOWkVtecnE7VhMqH157moP2uiO8sEkpU4ZjnJ4Pv0cT3c9SUfYsSdWyVpyNkdMxUg5KeJuknSUZpv/CsZaYipGfXw6KSdJq99CYAMSKo5RlvawBbAowBDh6RgAHjGyNktDsAuLwVFe34REHi45k0MpS0zFi+7XLi6+9bHYQRMYOUoT2GDQeqU0KtIYZQZt00qjrcKoqCjYIbIWV7loFEaFuCo/i5SxBq0UdbEZtIaNZE0ax3pYZdAoyt0K4jqO1oomv4GczeEpj1K3jBxZAuuT0ElSbgm1Xj09URehDXGVy9LUMRxVupxZ8cPQSmOs6atxsMn/6C2vi2Iyyf1LTBa5b4nJIvctIYQQQgghhBCTxT/vdcOGMIQLF2EO0sHyYv/xPG/UNmG/723p6NdlTFXRwkVkL3svyV/+z4jtSv/tX/DPPR9bVb2fKgP38UdJ/vj/jdrOv/IfqF11Ah9fdQIf+tDHePLJx/nNb37JH/7we7q7uwB417veM9nlCiGEEEIIIYQQQgghhBDiAJAQBjFlDAxMiMfj497HwD4HMoTh5Zdf5vOf/3zRuvPPP59zzz33AFUkXguUUqysXMzR5fN4uHUjP99xL81BW9+gy8lisWgUoTW0Bd38esc9/Gn3QxxAfn6jAAEAAElEQVRRMpt3zDyTRSWzpky4iBDi4GKM4c9/e46b/vo0DS35weXYSZ6yc5QgBq0VJYkYpyyfx4WnHcWyhdMJw5FDITJ+wO8eeoYbH15Pezo79lpGTY0YnaMUS2fX8/ELV3PkrGn7tjNxwGWjDDv9HeRMDld51Hp1NAWNPN21jleyW4hsCCiMjQhsFke5lDqllLqlKAu7/d30RN0oNEknSYVbgVKKtrAVjUNcu4SE7PZ3Ue9NpzPqwFEapTQOoFC0Ba1orVD9wgSUUrg4ZE0GV7nFr/tKoRRENhr8fkDlH3DWDp7hKH/EAGPMoNmBHDSWfKBE/31aLCldQs7mMJi+wANjQ8rcckqcMhr8XQQmwMEhJKTUKSPuJKjXs2jyd9MddWCtpdKtxtiIdNSDb3zK3UrKnQriToKeqBuw1Hh1LCtdzuLUUlJOSeFYZsighaHDF4QQQgghhBBCCCGEEIe6rVu38swzz7B7926CIKC8vJz58+ezYsWKvbouQhxYPVd/jvgDa3CefqpovSkto/Mnv2RQurAQA7ju6CEMQb/vTUnZ5BWzH6T/+bMkfv+/qExm2Da6uZmSL32B7m9ds5+KSlN21T+gRjkvberqyP6fq/uWlVKsXHkCK1eewBe/+FVuvvmPPP30OhYtWjzZFQshhBBCCCGEEEIIIYQQ4gCQEAYxZeRyuaLlsSS/DxSLxYqWs9lxDIKcQO3t7Vx55ZV0d3f3rZs+fTpf/OIXD0g94rUnrj3OrD2GVZWLubvpKf7Q+CDtQTcRgwc4jmQ8l3+Y3tm1C1+7ozRrO19kffcWZiVqOb36GM6vO56UkxhXDUKIQ9Pulg5+8qfHeOjpVwiKAg7sqCEJE2KIYzhaMb22nHNOXMRF5xxLeWly1N3sauvkZ399knvXbyY7SlDDhCkENyhgRmUZHzr3RM4+esH+ObaYEMYatmW30uI340cBCZ2kwqngxcwm1nc/Q8ZkUCiMNfRE3RhlSekkVW4VrvLImgy7/R2ENkKjcZRDqVNKl+kkYzLEdRxQZE2WXf5OypwyQhvhKQ+UwsUjMAG7/V1YbH59QT5IwOKbkKQufgxoNBZLZA0D36lrHCKCIQMKFBqjhn5QazQR+dvR/+ejlcZRLoEN8PBQKv/zUCjqYvW0h210R104OPmgBhRlTgUJJ8n02Ewa/F3kTBZXxUg5JaSjHgIb4BJjmjeL6fEZ9JgufJMjpjwWpZayrPQ4ZsRmo5TCFi66GypkSsIWhBBCCCHE1DfZH6qFEEIIIcRY3H333Xzve9/jueeeG3J7KpXikksu4R/+4R+ort5/s7+LfZRI0H3HPcT+56d4f/oj+Dn841eRueJKzGFzD3R14iDguqNfrhf2+96Wlk5eMfuBmTGTzIc+Suq73xqxXfIXPyP35osJzjhr0msq/fxncF/cNGq77Oe/AOXlQ24rKSnhne98N+9857snuDohhBBCCCGEEEIIIYQQQkwVEsIg+nz5y1/m5z//+aQf52Mf+xgf//jHB60fOMNDEASD2ozG9/0R97k/ZLNZrrzySl555ZW+dalUimuvvZaqqqr9Xo94bStxE7xlxkmcV7ecX+28l/tbn6Uj7OkLShh4uXXxmOO9vxi7f8+cCdiS3s2r6QZubniEo8oO53V1qziydM6QAxeFEIe2+596mZ/9+VG2NXQAQ4XBKBhlxpG+jvsypsTu2Y3nORx3xCzOP/lITlk+H6UUruuM2H3dyzv4yd1P8Nz2BkLTr5C9edqz4+9Xnozz9tXH8O5Tj8NxZED4VNUetPFiZhM9YQ9KKcqcMow2PNv1NE1+I5Af7O+bHN1RN67yqPKqqHLz7xkb/AayNosyii4bEtcJyh2PlqAJsCR0AouhI+zAWkvO5tBKoQohATE8ciaHb3IoVNHrsqtcsiaDUgqlioPMtHKwNsBag1L9HgtK5WseIvRJ42ABSwToQduwZlBAg8VQ4pSSM1kiG+EUjhXZkJRTSpVXw+7cDkIb4FiXkJASp4S4jjMtVo/ja9qjdow1VLgVRER0h/lghQqnkqpEDSVuKV1hJxZDnTONpaXHsih1JAk9cmiUvIcRQgghhBBCCCGEEELsLd/3+Zd/+RduvvnmEdul02l++ctfctttt3HNNdewatWq/VSh2GeJBP6Hr8T/8JUA+P5+CuoWrwmOM/J5SIDeK6asUpBKTW5B+0H641eR+NXP0c1NI7Yr+9iHabv3IWxt7aTVEvvzH0j+4mejtgtOXE3wnvdNWh1CCCGEEEIIIYQQQgghhJj6JIRBTBmpAScNc7ncuPcxsM/AfU62MAy56qqrWLt2bd86z/O49tprOeaYY/ZrLWMx3IUAcoHAwcfF5e+mn8fbak/jtw1r+Fv7s3RHmb5hkr1jlfuPV1bDfD8ee8Ie8v+1BB3c3/osD7dtYH5qBivLFnNe/fFUeCV9feT+JSaL3LemrlwQ8Ku/rOUvD28gkwuLnoyGe17aF2PJNFAKyksSnL/6SM4+cTGzplUCEASDB5dD/v7Vk81x48PPcuva52nrye79wfdBwnM5+6gFXHneiSRjMaLIEkVy3z+QfOOzOfsiW3NbyJosnopR4VbSFDTwam4LoY3A5l8ne0w3vvVJ6hTTYvXEdYxMmKU9asNi8Y1Pa9CCSwxrDd1RFx4eWmsiG9HkNxE4Pr7N4eIBoNC4uHSEHSgsnor3e1wptNXkyJFQiQH5Jvk7qrFmUO6JQmMBg0UN2KbRGCKMscVBBQq0dTBYnKLHuEWhSOgUOZvDtR5K5d+hWKDSqSGrMrRHrVjb+85CUe5U4hGj3ptJY7CbrMngKpeEStIZdhHZAKUcZsRmM8s7jB7TRc5m8XSMWcnDWJI6mlq3fugwhRB8XvuPG3ldFJNJ7l9issh9S0wWuW+JQ47Zl9RCIYQQQgixL4wxXHXVVdxzzz1F6x3HYcaMGZSVlbF9+3a6urr6trW2tnLFFVfw05/+lOXLl+/vkoUQ+5lSCtdxCEc4x9cXwlBSWgjJPnhZa3nmlS2o91/B2V//yohtnYbdlF31UTp/fgPoiQ+id55bT9kn/2HUdjYep+s7/40zCTUIIYQQQgghhBBCCCGEEOLgISEMYsooKSkpWs5kMuPeRzqdLlrenyEM1lquvvpq7r333r51juPwzW9+k1NPPXW/1SEObSk3wd/PuoBL6k/ljpYnubXpEdImVxjmCKoQx9AbyKCY6LHCFqsMAREvpLfyYnobt7Q8zKqKIzih8kiWVyya0KMJIaa2lvZuvvvbv7HuhR17BoWPMA5k3PkFvQkzQ6wejqMV82fVctHZR3PiUYcTi438dthay9Ov7OR//rqWZ17dTWiKQxqGvDmTEMTgOZqVC2bz8dedzLTy0onduRiSsfnftVYaay07/e08l15PQ7CLyIakdAmeirEr2EHGZFDkAwpy1qczbAcF5U4Fdd40FIqWoJnABjg4ZE2WRn83M+IzaQ/biIjw8EArQhvSGOzCUzFs4fgAjnKwNqQtasFRuihcQCsN1hBhiQ24EC+/zRLZEK2KZ1ZSaAzhoNuuCv9FNsRR7qBtGgeDwWHP/iIbktQlRNYntCFuoV9oQ5JOkmnudBqCneRsDsc6hDYk5ZSQ1EkSOolC0xY1E9mIUqeMwAb4YY7IhpTrchYll1Cuy+mI2okwlDllLE4uY15iEZ7y9vbXLIQQQgghhBBCCCGEEBPqRz/60aAAhne+85189KMfpb6+HsgHNdxzzz185StfYefOnUD++oirrrqKW265hbKysv1etxBi//Icd8QQht6zN7b04D0v2NzczI033sANN/yaDRvWc8rJp3HqGWcRW3PviP3id95O6utfJv2Zz09oPaqxkYr3vgPd0z1q2/Q/XU20cBHOqC2FEEIIIYQQQgghhBBCCPFaJiEMos+ZZ55JVVXVpB9n1apVQ66vrq4uWm5oaBj3vgf2qampGfc+9tYXvvAFbrnllr5lpRRf/OIXed3rXrffahCiV4VbwtvrT+e86uXc37aePzU/RGeYwbBn8PDEBjDsGYZsrUWpfNSDAdrDbu5pWct9LU8xK1HLyRVHcXzZEcxO1A09O7UQ4qD38vYmvvmr+9ja0D75BxsmiGGgVCLGqcvn8dZzj2NGbcWo7Vu6evjN357mrqdfpD2dHX9dExTEoJVi2expfPx1JzO/fv+9rzkUWGtJmzS+9XGVS4kuoTvq4vn0Rp5NP0OP6UGhSOkkvs2SNj2AIqY8sLAt2kra9OAohxqnlkqvitCGtPvb0UqjUHRFXRgs1W41nVEHDg6OdsFasibHzuzO/PFx+14TXeXiGx8fn5iKFdXsKJfQ5tBWDbp/KTSWgMF3vvz3dogHisYhIsRag1J7ZvJRChyrQfW+rvfuL/99qS6jx3SjrCqEROT3XulWo4DmYDeB9VHk91nhVOFol2neTJrCBtJRF45yias4nVEHERFKwdz4AubG55G1WdJRN66KUe/N4MjUUVS61QPLF0IIIYQQQgghhBBCiCmlra2N73//+0Xr/umf/okPfehDReu01px33nkcc8wxvOtd72LHjh0A7N69m5/+9Kd84hOf2G81CyEODNd1wc8Nuz0ofD3YQhiCIODuu+/khht+xV133U4Y7gkDf/Ch+1l/0y0sf/RhVHbk868l3/4G0fyF5N7+rgmpS7W3UXHZpTjbt43aNjh+Jel/+OSEHFcIIYQQQgghhBBCCCGEEAc3CWEQfU455RROOeWUA3b8OXPm4Lpu3wm4bDZLa2vroHCGkezatatoef78+RNa43C+/vWvc8MNNxSt+8xnPsOll166X44vxHCqvDLePG01Z1Ufy21Nj3Ff29O0hJ19UQwWu89jhFXRsE5F/2Gevfu3WEIMr2Yb2JZt4qbG+zmy5DBOqTyKY0sXUukdXBcOCCGGtn7zTv7zl3+lrTMzpmCEoVjyQUbYcexgmCAGrWDWtErectYxnLVqEZ478lwl6ZzPbWuf59YnXmBHa0fxLvdzZoxWsGB6DVeeexLHzJ2xfw/+GpOOemgNWwltSFzHqXKqeSW3hWd6nmKHvwNjTeHXq8jaLA4OCZ3AVR6hDdiS20xkQzw86mL1lDoldIYd5GyOmIoDlpaoBaMsykJoQ7xCqILF0hN1ERgfgyWmCh+/lMLDI2PSKBSe3vOxTAFaaXwbDLotvXf1qF+oUi+tHLABxpr89719lEJZjRnyQWlxcIkIcdkT+BDZkLhKoJTGtzlc66GUyv8clEedW4+ONF1RJ8YqjDUknSQpnUIpTS31NAcNBDagRJfg2xy5MAvWUu6Uc3RqOVVuNR1RO6ENSOlS5icWMSc+D0fJnEJCCCGEEEIIIYQQQoiD049+9CN6enr6lletWsUVV1wxbPv6+nq+/OUvc/nll/et+9nPfsZ73/ve/TKBhhDiwHHdkS/Z640uOJhCGB577FEuv/xdNDc3D9vmVw+sYdG/fYmyz/6fUfdX9smPYhMJ/DdfvE91qc4OKt5xMd4zT43a1pSV0/n9n4Dn7dMxhRBCCCGEEEIIIYQQQgjx2iAhDGLK8DyPOXPmsGXLlr51L730EieccMKY+vu+z7ZtxYnl+yOE4brrruPHP/5x0bqPf/zjRRdKCHGglbkp3jHjTC6adgp/bn6Y+9uepTFoJ7IGhhjIOXYDB3QOHuDZu6Z34KjBkLMBT3e/xPruLSS0xwnlSzmh4kiWlRxO3IkN2ocQYmrbuGU3//HTu+joKcxYYkfILBgmMGEiJWIuxy+dw8XnHMviw6aN2DbnB9z59EvctnYjWxraiIYLf7CMP4hhPH0KbZVSzK2t4IqzT+DERYeN84CHrtCGbMttpTvqwmAp1WXEVYyNmQ1szGwgZ3IoFJGNyJosWimSOkmJLsPRDm1hK21hK6DwlEepU0pcxWkNGwFLXCWIiGgMdmPtNNqjdjQKR2kAFIq2oAWtNBqVDxIprHeUS9r04Knii7V620REg26PJr/fyBp04Rj9t9mhQhhQgMJg0PQPMrA4hf2Zov3lH6iVuoou00lkQxzlAhaDpdqtJKlTNAS78G0OZRXWWmq9GrTW1FCHtZYu04lWmpiK0xa1omz+9i9MLGVh8ghCG9ATdeNoh2q3hoWJJZQ4B88Fg0IIIYQQQhyUxhNsKIQQQgghJoQxhptuuqlo3cc+9rG+vwUPZ/Xq1axcuZInnngCgJ6eHv7yl79w2WWXTVqtQogDzx1lkH9vVLctLZv8YibI4sWL6erqGrHNz3/+Uz61dgOx++4hfsdfRmyroojyD7+frkyG3Dv27jlRb32Vive8Hff5jWNq3/2t72LmHr5XxxJCCCGEEEIIIYQQQgghxGuPhDCIKWXJkiVFIQzr1q0bcwjD+vXr8X2/b7muro6ampoJr7G/n/3sZ1xzzTVF697//vfzsY99bFKPK8Teijseb6s/nYvqTuHhjuf4fcMDNAVthDYqjIu24xobPZ6x1L17toAmH/1gMPSYHPe2r+P+jqcp0UlOrzyWVRVHsCA5E1fLy5QQU1lTexf/59o/09yeLt6g9oz3GPLSwlGePCyFAerjGDSiFNRWlvD6U5dy4SlLKUnGh23bnc1xx7pN3PXUJl5taicc63H2JohhjJSC2dUVXH7m8ZyxdPJDpA5G1lqagka25F4mHWVwlUOZU0466mFD5jnaw3Z6ow8yJk3GZIjrBFVuFVVONRERu/ydZE0GhSayESVOGYH16Yw68ZSHVg6hDdkd7KLKrSJns7h4KKVwcYlsSGPQAMrisefiuHwwgsW3PkmVLKq7d5u1g9NJtMrXMfCupQtLQ4UtqMKrqLW26OJdCzg4mAHbDAZXe5SoEjpNJ1i377gODtVeDQmTpCloILA+1hoSOkmpU4ZWDrVuHc1hEzmTJeWUEFi/EFhhKXcrODF5KrXeNDqjdkIbElMxZsfnMsObNerFxUIIIYQQQgghhBBCCPFasXbtWlpbW/uW58yZw4knnjimvpdeemlfCAPAPffcIyEMYkyiCHwfgiD/vdb5f0rt+X7gPzE1eLGRJ6fYE8Jw8ARbV1ZWceGFb+CPf7xp2DbNzc384Y+/513/9T3cM1fjNOwecZ8qiij/+EdIb3iOns//O7hjv4bE++vdlH/sw+jmpjG1T3/4o+QueuuY9y+EEEIIIYQQQgghhBBCiNc+Gd0qppQzzzyT2267rW/5wQcf5MMf/vCY+j700ENFy2efffaE1jbQ7373O772ta8VrXvHO97B1VdfPanHFWIieNrh9KpjOKXyKF7o2cYNu+/l5cxOfBsCtjCXtsKMMWJhpCGWQ4217g1kMFg0qjDnNnSZbm5tfZA72h6h3CnhrKrlLC9bzOHJ6TjKGbhrIcQBYozhiz+5g8ef3z58mELhiWGIcedjN4akF9dRHLVgJpe97niOnFc/7KDv7c3t3Pz4Rh56/lUaO7oHD20fa5EDRsuPJ4xmKAqYVVPO351+PGcum3/IDlrvHxrQE/XwQuZ5XsluIWeyxHSccqecxqCR3f4uTOG3Z6yhK+oshCmUMM2rx1Eu3VEXGZPBWkvWZGgLLXEvTnvYhm9zxFUclCKwAbv9XcRVDIvFUfmPRq5yCW1AS9CEUhT9ThzlEtgMyoLSxb8rrRwCG2JV8d2p9/uIaNDtVr1hC9ag1J4rH5VSaKsxavC9y6JwlEdIWBQEERFR4eSDI3ybxbUxlILIhlQ4VVS7tdgQuqPOfPCIhTqvHq0cUrqECqeKrqgDqzQJnaQz6ijUqDk6tZwjU0cT2YAe04MCSp0y5sUXEtPDB54IIYQQQgghDpBxhBoKIYQQQoiJsWbNmqLlk08+ecx/8z/55JOLlh999FHS6TSpVGrC6hNTS3c3NDYqmpo0TU2KxkZFR4eiqwu6uhTd3fl/XV0UvioymXzYgu+rwlcwZnznlRIJSzIJyeTgr6mUpaICKistVVWWior8197lujrLtGmWUbIDxBi5o4QJhIWvtuTgCWEAuOyy940YwgDwwx9+n3e84zI6f/YrKi9+AyqbHXW/qeuvJfa3++j65n8RHr9qxLa6YTep//wyyV/+z5jrzp17Pj1f+DLbt2+jtLSUysqqMfcVQgghhBBCCCGEEEIIIcRrl4QwiCnljDPOwHVdwjB/OvGxxx5j27ZtzJkzZ8R+1lpuuqn4JN4555wzaXXeeuut/N//+3/zMxoXvOlNb+ILX/jCpB1TiMngKM3S0rn8+4K/Y1uuiXta1nJf21NkjY8phDH0Gnjp9rADjwdc52EHbLJF6/KjmRX5wbRaaQwGYw2tYSc3Nf2NPzc/QIVTyllVKzi2bKEEMghxgL24tYGrrv3zngfySE8Uhe17H8SgoHcQ+oB9V5YlOf+kI7jorGMpSw0eBN7ek+HBDa/w1/Uv8eLOZrLBngHwU2EoigLm1FTwd2cez+lL5r3mwxd849NjegBI6iSuctmS3cIzPc+wy99FZCOSKoGnXdrCViIiHBy00mSiDB1RO6CocMup86aBVewO8oEMDg5pk6YhaGCaN42WsBmFwtMeFsiaLLv8XYQ2wMHp+1m7ysM3OXJk8dSeMANFPogha3vwrDfknTciGpjHgS68ykUmQuvij1kK3RdARFEfpxB6ZNDsCWHIhxRpFIrIRn2ve73ra9062sKmwm1yMRgUigq3AqWqaPR3kbNZjDHEVYJKN3+hWKkuJ7JRPtzCiRMR0R62YrFUudWcUXEus2OH0Ro241sfT3nUezOo9mrH+RsXQgghhBBCCCGEEEKIQ8vGjRuLllesWDHmvvX19cyaNYsdO3YAEAQBL730Esccc8yE1igmTxRBRwe0tyuam4vDFfZ8za9ralKk0wfmvFA2q8hmoa1t749fVWWprzdMm2apr88HM8yebTjsMMOcOfnvSw+u3IADwvW8EbcHha+mtm7yi5lAZ5xxFosWLebFFzcN2+bZZ5/m0Ucf4aSTVtN17fcpv+LyMe3bfe5Zqi48B//0s8he9h78087E1taCUtDdjbf2CeJ/uonEjb9FZTJjrjlcsoyuH/wEHIfPfOafeOSRh/nYxz7JBz/4EaqrK8a8HyGEEEIIIYQQQgghhBBCvPZICIOYUiorKznnnHO44447gHy4wrXXXsvXv/71EfvdeOONfRckAMyaNYvVq1dPSo333nsvV199NcbsmUP73HPP5Wtf+xpa6xF6CjF1KaU4LDGNv5/1Ot5QdxIPtz3HXa1P0Bx0YjBFw0Y1CtNvKKnq+//ow5qHCmSg33z0vXuNMIXjGCILzWEHNzbdxx+a/0alU8pplcdyTNkC5iVmEHdkqg0h9pef3/YoN9z7zJAPd9X3P8aW2jK2pw36UhwArRSL5tTyjgtWcPySOUWvuy2dPTz8wlYe2LCFTTub6cn5+W5jvYZsH9qO+aYU2s6fVsWHzjuRFfNmvabCFyIbscvfRcZkUCiq3EpCG7E+vZ4NPc+Rszkg//4utCEGQ0zFSOgEGsXOYDsZk0GjqXArqPKq8E1Ai2nGUS5aabqiLoy1lDllpE0aDw+lFRZLxqQLYQsRXuFjjgI8FSNj0gDE1Z7ADgVopfGtT4zi1xJFfp8REQMvgdNoDBED9YYm2H6va70c8iFD1tqi33n+ZxAftC2yISldQlInaYtawYJWDqENSekUZU45rnJoChrwCz/XarcWV3lERKR0CcpqwBJXCTqjDiyWmIpzfOmJLE0eg6c9OsN2DJakTjEjNqsv7GFabPqYf+9CCCGEEEIIIYQQQggh4OWXXy5aXrBgwbj6L1y4sOiah5dffllCGKawnh74/vdd/vIXh02bNJ2dr53zPaNpa1O0tTk8//zwbWpq8oEMhx1mmDfPsGCBYdEiw8KFhgoZ0w6A6458yd7nga8CiV/+jDek03zrW9/dL3XtK6UUH/jAh/nMZ/5pxHbf/e43Oemk35N7yyV0v/oqpV/6tzEfI/a3e4n97V4ATEkpOA6qqxNlxx/FHy5aTPvv/oQtK+fxxx/lzjtvB+ArX/ki/+//Xc8//dM/8/d//wESicS49y2EEEIIIYQQQgghhBBCiIOfhDCIKecTn/gEd911V1/IwZ/+9CdOP/103vjGNw7Z/qWXXhoU0nDllVcSi408MHv79u2cc845RevuueceZs+ePWyfRx99lE9+8pMEQdC37tRTT+U73/nOqCdIhThYTItV8pb6U7iw9gTubXuKh9qfY3NmJ6GNMAMiGXRhkGrf8OMB15aMPDDZ9muebznULOH9AxmUVTSHHfyx+X5ubnmQMp3ixIolHFO2iEXJWZS6qX245UKIkfzXb+/lzideyi8McR2ZLfyvL4zBDt4+1svPBrZLJWKcs2oRbz9/BZVlSdI5n8c3bePRTVtZv7WBHa2dBNHgge9DHXjES2/GU+QQNY+0b0cpls6p56Pnr2bRjJq9O8gU0RQ0sTW7lZzN4iqPCqecjqiTZ3qepjVoy/8srCVjMwQ2IK7iVLqVlDll+MZnV7CLwAY4OFR6lSR0gvawDd/6xFUMq6Az6sQWXiciDDGVj0LQyqPHdJM1WYC+0AKFwlUeadODq9yioIPe7wxmUOiFQufDFmyEVnrANjXk65JWGmvBWoPq30cplNUDoot67xeKmIoTEOJZL1+Hzb9+1rrT6DZdpE0a1zp9BVe4laR0/nWtLWrFNz6eilHhVhIYH2MhpcsIrU9SJ1BK0xG146CZEZ/NManlzIsvost0kDUZHOVS4VRR4pT01Vbn1Y/6+xZCCCGEEEIchMY/7kQIIYQQQuyDbDbLzp07i9bNmDFjXPuYPr04HHfLli37XJeYHO3t8O53x3n8cedAlzJltbRoWlrgqacG/4zq6vJhDAsXGo480rB0qWHZsojKyv1f54HkugNjwAdLA+meHtLpnskvaAK9/e3v4itf+SKdnR3DtrnnnrtYt+5Jli8/nswnPoUyESVf+eK4j6V7uve6znDBQjpuugU7bRoAX/3qfxRtb25u4rOf/TTXXXcNn/70v3DZZe9mr08mCyGEEEIIIYQQQgghhBDioCSjxsWUs3DhQt72trfx29/+tm/dP//zP7N582Yuv/xyKgqx+EEQcPPNN/O1r32Nzs7OvrZHHHEEF1988YTXtWnTJq688kpyuVzfurq6Oi677DKeeOKJce0rHo9z/PHHT3SJQkyomONxQe0qzq9ZyfPpbfyl+TGe73mVzjBdiF0wewanqqEHII/9eu/BLQcOYgWIiPoCGbRVtEVd3NH6OHe3PUFKJziqdD7Hli7kyJLDqPOqXlMzzAtxIN18/3NFAQxDPrYt9I4rHy6IYbzqa0o4Y9ViEimP57bu5qof/YnmzjT+wMCF0R7q+xCuMB5D3eS443DSEYfxgbNWMrN6ak/tY63te97siXrYlHmBV7NbydkcCRWn1CmjKWhku78dY/O/g8hGdEVdWCylTim1bh2O1rQGrWSiDNZaIhXhGo8aFac5bMZiSagEVlnaw3aMtWRMNxqNUhpFPlyhM+wEBS57LtBTKLTVZMmQUMUzzvQGAxlrBocCKY21USHYQRX1yYctDKZwgGiIH5RCowuvSXtCGAwRnvJQKEIb4iq372fkaZfp3kwagl2ENsC1LiEhMR2jxCmhxCmhKWikK+rEWEO5U4GjHLI2A0pR5pQTVwkc5RDakJCQhE6wovR0lqSOoswppzvqJLQhMRWnzCnv+10mHJmZRwghhBBCCCGEEEIIISZTW1sbtt8M7J7nUVMzvkDm+vri0NyWlpYJqW1vxWISMDCcH/zAkwCGfdDUpGlq0jz8cPH62bMNy5ZZjj7asGyZ4dhjDfPmWV6rp/xjsdFDGHqVlZUeVI/J6uoK3vve93HdddeO2O473/kGN9zwOwDCT19NJu6R/LfP748SCVedQPrXv8Wtywcw3HHH7TzwwN+GbLt9+3Y+8YmPct1117BmzYMkEnLuTYjXEtc9eJ5fhRB7Tx7rQrz2yeNciEODPNaFeO2Tx7kQYiqSEAYxJX32s5/lueeeY/369QAYY/je977HD3/4Q2bPnk0sFmPbtm2k0+miflVVVXz3u9/FdSf+rr1+/Xp6eorT5ZuamvjoRz867n3NmjWLv/71rxNVmhCTSinFkpLDWFJyGJ1hmjtaHuehtudoCtoJbIRSFjNkZMII+xxj694BzUPtPSwKZHDojNI83LGeRzs3EMdjXnI6R5cuZEnJXA5LTiehY+OoUAjRy/dDrr/5oeLwhaEudlJgehsUvg73EdgUmliV72cVoHv/KZSTX78tl+aXDzxVdMzhAiAmLIhhHwMberuWJmJccNxi3nXqcVSkpsaFOFmTpSvqIrKGlE6SclK8nN3CMz3PsDO3i4iIuIoTVx5tURuRjXCURqPpMT10hV0opah0qqj1ajAYdvm7MBiUVXRH+SCFMqec9rAdBwdHOxgMHWEHoQnwjY+Li1L58ANXuXREbWjAU3uep1XhFSCyETFVfBFaPlABjDU4qvhepgqvCwNpdP71ZEAf1RfCMFwfi7ERul8fqyylqpSczRZ+Rg4WiKyh0q0koZI0BrsJbIAmf/urnBriOs4MbxYN4W4yURqtNKVOORmTJrQRrnKp86ZR49aRtRlyJoerXBYlj+Do1LHMic8FIGdyKCCm40W3pdKtHvudQQghhBBCCPHaZgd/xhFCCCGEEJNn4HULiURi3GHxqVRqxH2KqeOGG+Qi0Mmwfbtm+3a44449P9+qKsvxx5vCv4jjjzeMM99kyhrPdU2lpaWTWMnk+PCHP8oPfnA9YRgO2+b2229j3bq1LF++AgD/k/+IOXweqSs/hJrE50D/kkvJXPd9SCYByOVyfPaznx613wknnCABDEIIIYQQQgghhBBCCCHEIUZCGMSUlEwm+fGPf8wnP/lJHnnkkb71QRCwZcuWIfvMmjWL66+/nnnz5u2vMoU45JS7Kd5WfwaXTDuNF3q28YfGB9ic3kHGZjGF2cVt4b9eQ80M33/bSPr3G0sgg8WgUGTJsjHzCpsyW3GaNLWxSpaUHM6SksNZmJxDXaxyXLdbiEPZ1T+4GeyewIQ+/b7ve1Tq4r5Rv3ZFj9whQxxU3zY7qEO/5eGeOCYyiGEvKWB6VRnvPOVYzj92Ea6z/y/Ci2zE1txWuqIuLFCqS4nrOBvTG9mQ3kDW5PqepwMbABBXcZI6gYOmwd9J2qTROJQ75VTH6siaLJkog6vy4QkdUTsWQ0zFyJosHh5K55//O6JOMiaLxeKq/EcNjcZV0Bl14iin6MLTfNCBIQJiAy5I1UoT2BCjLE6/X1zvd8OFLUT5e14Rp7AHO/COpRTa6vz9ztq+2iwWhaZEl5CxPWAVWmlsYSBTtVtD1mRoi1ox1mKtwdUe5U4FnvKYxnSagkYC6xPXCUDREbYTYSjVpcxLzKPKq6Yj7MCPfFJOCUckl7A4cSRJJ3+hbf96+ks5qUHrhBBCCCGEEEIIIYQQQhw4AydziMfj497HwD4SwjB1+f4knmwSRdraFHff7XD33Q6QD+0+/HDz/9m77zi5rsLu/59zy7SdreqWbMuS5SbbGFdcMTz50Q3GlMehmGLsgGNKIIkxBBIImPaEgE0LJiHU0OEJmBJjSmJTjMtjg7stF1ld2r475Zbz++NO39VqV1ppR7vft16juffMLWfvnLlzZ+ae7+W002LOOivmrLMijjrKMsPMk7bg+/6eJ6rI5zv3Y032j8MOO4w///NX8pWvfGnK6d7znnfzwx/+uPabWPiiFzO69khyr7sE96EHZ7VONpej+IEPUX7dpTQ2ms997tNs2PDIlPP6vs/VV797VusjIiIiIiIiIiIiIiLtTyEM0rZ6enr44he/yHe+8x2+8IUv8Pjjj+92uosvvpjLL7+cjo6OA1xLkYXJNQ7H5Q/nuPzhDIVj/G7wHm7Y+Tv6gxECwsp1xRMTOryym37QZuJo45zTCWQwQESEg1PrnFsmYHN5J9vK/fx64E7ybpZVmaWsyx7KsR2rOSp3GL6jt0OR3Xlg4849BzC0vqBbxu1uypOy3Uw8ybS7C3SZiamCYWakYUfmuw6nHrmKV5/3VNatWDIbS5961dayLdjOQ4UHGYqGMRi63E4iG/FA4SEGwwGMMVhrGY/GKdoSaSdNr9dLj9dNOQ7YXN5MYMs4uOBBt9PNUDhAyZbImAzWwEg8gg0ssY2IK6ELkIQjDIVDOMbBwamdFGUwOBjG4lHSpvlk0ep+uRp40MjgEBFWgg8awxaS4TiOcB2nqdwweQiDi0tENCHAwBLj4hITNz0W2ZCUSeE7PoW4gG99jDGElfJl/nJ2htsZjUeIbLLtu71usm6WtEljsQxEAwBknAwj0XCtloemDmN1Zi3GwEg0goOh1+vjhO4TWJpaVqtbuTwxNAKY8VXSREREREREauysfPIVERERkWkql8tN4zPpXF2VSqWaxovF4j7VSfafNWtiduw48EHcknjsMYfHHnP49reT8cWLLWeeGdVCGY4/3jIHOekz5rrTP0chn8/vx5rsP29/+1/z9a9/lSia/LcwgJtv/m9uuOFHvOAFF9TK4uNPYPR/fkv64/+H9D//H0wQ7HNdgmc8k+I/fYJ4zdqm8o0bN/Kxj31kj/NfeullHHbY4YTh7v8WERERERERERERERGZf9TrVNqa4zi8/OUv5+UvfzkPPPAA9957Lzt27CCKInp6eli3bh1PecpT9uokhlWrVvHAAw9Me/qLLrqIiy66aMbrEZnvur0Onr34dJ616DQeLW7h57tu47dD91KKAyKiWifapMOsrQwbTGM36D30M91zIIOtl1qwJhkOGwIZYiyWmMFohOGxMe4be4yf9v+Obq+Dw9LLOC6/hhPzR7Is1bcPW0Nkfrn30S0TC/cmgGHS17jZ42t/xiZNeNlPDPTlszzvqcfwkjOPJ5+Z+VWtGllrGYqGKMYlXOPQ5XZRtmXuH3+AP479ibF4FAeXDidHIS4yHA9jrcUxhsjGDIVDhDYk42RY7i8j7aYZDAYp2uQkzWJcZCAcIO2n2BHuICYmbTJgYDQaJbYx5biIi4sxyZ7bNx4j4Qhg8U39WMtgMMZQtmVyJtf0dzg4WCzW2knCFgwRE09McjBEMEkIg9Owj29YjjFJmENluzWHLSR1DQjxrVcPWyCmx+uhGBcp2wDfemCSIIder49Ot5NtwTYK8Tg2tjjGYbG/BGNcetzFxFjG4zFSjo9rPAbCfiyQctI8PfcMVqRXMhINU4pLpJwUS/3lHJFZi2smnuWXSh0EZ/6JiIiIiIiIiIiIyLS1BigEe9FhuDXIIZ3et98d9tXuAoQFrrqqxEUX5fY84QzkcpbFiy2dndUb5POWfD4Z7uy05HKWVApSKfB9W7mHVMri++C6SR5bHNfvk5shjiEIoFiE8XFDoQCFQnJfLCb3w8OGwUHD0JBhYCAZHh5u/8DonTsNP/yhxw9/mIx3dVnOPTfk6U+POP/8kNWr2zOkzp1BUkQ223FQviZXrjycl770f/PNb359yune8553cf75f9a8L3V8yn99NeMXvYzsdZ8g8+1vYFr2k9MRnHo6Y1e/h+DcpycFDdvRWstb33olo6OjUy6jq6ubd7zjbwjD6KB8HkRkZvQ6F1kY9FoXmf/0OhdZGPRaF5n/9DoXkXagEAY5aBx99NEcffTRc10NEdkNYwxrsodw+aoXcskhz+GPIxv4ya7f83DhSYI4IiLGxSHGVrrYVk522M15G7s7FWKyq9i3LqKxw251OCbGwRBXyiyWQlykVC6zvTzAnaMP8W1zE11eB2uzKzml6xiO71hLzs3MZDOIzCs/vfX+3YYo7D5cYU+mMVMbn8+V8lxOWbuSV5x7EsesXDrj+UfCER4rPUExLuIalx63m0Jc4O6xu3myvInIRmAhJCS0IZ7xyDpZfOMxFo/yWOkxYhuTNmmWp5eTMWm2lLdgiUkZn7ItszXYyhKW0B/24+BWggAspbjIpvLmZLnUAwp84zMWjWKwpE39pE5T2eOGRE3lkIQtAEQmxqP5JLFq2IKPP6E8Jp6wTRxcIJgQ3OAYB2PNhBAGC7WwiIgIr/KRxpIEMiz2kr89JMSzHlFl/9/j9WItbA+2UrIlojiiw8nT5XZhgbzTCViCOCDrZinGBYpxAWMMazPrOD53Ih1ujqFokMhGZJwMh6ePoMM9OK8+JCIiIiIi81h79jESERERmbc6Ojqaxkul0oyX0TpPLje7nfxl9pxzTsRnPlPiqqtSjIzs/ketTMaydKllyRLLkiVx5b5eltzHLF1qybfpTw1hCENDhl27DNu21W/btzuVe8OmTQ5PPmkIgvb4gW942HDDDT433JD8TrV6dczTnx5y/vkR55wT0t09xxWsyOU69jxRRb5dG8g0/NVf/TXf/e63CMNwt9M8+ugGrr324/z1X79zwmPRmiMZ/edPMfbO95D59jdI/fxn+L//LSba/cnX4Zq1lJ/7Aoovu5jouPW7ne5b3/oPfvGLn+/xb7jqqqtZsmTmvwuLiIiIiIiIiIiIiMjBTyEMIiIy6zJOitO6j+HUrqPpt0P8YfB+btx5O9vKA8Q2wmKTTrcm6Yzb2sG21dSBDLbpuumtUzcHMiRibOX66kk4g8EhsAGRDSmWy2wr7+L3w/fi4tDrd3J8xxqOz6/hiMwh5L0caaf5ajYi89XwWMtJgns6d6rl8eagBjPltAfSZGEuU3GAQ5f08IJTjuU5Jx9Fxm8OFwhtSDkOcI1DyqQIbMjDhYd5qPAw43EBz3h0up2MRkkAQxAHGGOIbcxwNITFknOyLPYX4eHRH/YzFA2BTcIOsqkMnuMxGAzh4pAyPiERW8pb6PG6k3XgY4whhUtgAzaXtmCNbQhCMPjGpxAXMSYZrm+PJOggJgbT/MQYY8BaIiLchrAFU92H2gjMxPLJ9uuucYltjLW2FgBRnysJaGhcR2QjfFJgLJGNKmESENkQ30mxyOtje7CdwAa4eISE5JwsXV4XKSfNtmArpbgEGBb7i7EWIiKyTg7XunjGxzMeQ9EgBodOr5OzcmdxTPYYxmyB8WgMg6HT7WSJv7SlziIiIiIiIiIiIiIiidbAhGKxOMl34VMbHx+fcpnSXl7xiohnPavA3Xc7PPGEIZOJ6emxdHdbenuTkIV8fsLPLgcdz4NFiyyLFlmOOmr300URbN9ueOIJh40bDRs3JtvlkUccHn7YYedO58BVusVjjzk89liKL30JXNfytKdFPPvZIc96VsiaNXOXYHfeeefT19cHwNe+9uUppz2YQxjWrDmS173uDVx//eemnO6f//ljvOAFL+KYY46d9HG7bBmFK99K4cq3wugo3oP34zy5EWfHdvB8bDZLfMhKwuNPwPb07rFeGzc+wd/93cTQh1ZHHXU0l1/+xj1OJyIiIiIiIiIiIiIi85NCGEREZL8xxrAivYgXLj+b5y17Gg+MbuTW/vu5ZfBPDEajVCMYXBziSphCXOm4a2oRC812fxrEnrtVNwcy2IblJf9H2EpNLLENwbhsC3axfXAXvxq8Hd9xWeR1c2TuUNZmV7EqvZRV6WVk3fTElYnMA4t7pzih5yA/aWxPewwDLOnu4P87aR0vO+tEfA+eLG9iQ/AIXuDS5/UxHo9z99gfebDwMJFNrrbi4lKypVqggGtcinGJwXAQiyXvdrDMX4ZjHLYEm4lshMEwFo/jhR4dTo7BaAgfH8dxiIjYHuwgF+UIbYhfCVvwcQhtyI7yTlzjNp3I6RufMTuGhzch7MBisdZOkolhiCtBDC5OU/lk89TCFlrLjcGxzqQhDMYaHJwJYQsxMTknT2BLTWELMTE9fg++SbEz2EFsAwzJsnu9XjrcTpbisCPYRskW8YxH3ulkLBonsAF5pwPX7aLDzVOKS5RsEde4nNjxFI7vOIFD/JUMxUOU4xKe8ej2evBM8vGomz2fnCUiIiIiIiIiIiIiAtDb24sxJvnOHAiCgF27drF48eJpL2Pbtm1N44sWLZrVOsrsW7wYnvnM5Bfvcjma49rMLdeFFSssK1ZEnHHGxMcHB+Hhh53a7aGHHO67z+Wxxw5sOEMUGW65xeOWWzze+15Yty7iWc9KQhlOPTXCO4Bn0V166eUAbNmyeRohDJ0Hokr7zTvecRXf/vY3GBwc3O00QRDwtrddwY9+dCPenp6IfJ7w5FPh5FP3qj5BEHD55a9jaGj39an68Ic/it8S0C8iIiIiIiIiIiIiIguHQhhEROSA8IzL+s7VrEsfyouXnMufxh7ljuGHuHP0QUajMSAJYHAxxFAJZKibqsO02e3I7ue1TcO2FvoQY3Eqa48qU8WAC5TjgE3lHWwp7+SWobtIG59ON8fK9FKOyK7ksMxyju1YTcZRKIPMDy86+zhu+O19E8onfS0ehKEMBotxLbE1EBuMsaw4DI481ueo1d10ZbJ0eiV+V7yZe0fuZzQew1hDbGNG4lEslqyTodvrwifDYDTIQDiIAXyTYkV6GQ4uu8J+XONgcBiPC2wJtpJ3cxTjIimThCrEWIaiYcYq+0PHJCedubhYYoaiIVIm1RSq4OJSooRD8wlq1ZM8YxtP+rzYyj/T8GAtVKHl2a0uuzVswTEOxppJwxacSlBCbOPa3wFgDXQ5XYxVtqNj6mENfW4fgS0zEO0itDGxtaScFN1uN57xMdayI9xJYANyTo7YxgyGg8RE9Hp9LPGXkHbSjEQjWKDb7WZ9x/EcmVmHb3wioiTEwvi1kAeAXkdhCyIiIiIiMg/Zubuaq4iIiMhClMlkOOSQQ9i0aVOtbPPmzTMKYdiyZUvT+Jo1a2atfiJzracHTj015tRT46by0VG4916He+5xueceh3vvdbn3Xofx8QPzw+NDD7k89JDLpz+doq8v5rnPDbnggpBzz404UP3uR0dH9zhNPj9FcP5BoK9vEe94x1W85z1XTzndHXfczkc/eg3vetd792t9PvjB93H77X/Y43Qvf/mf88xn/tl+rYuIiIiIiBwYYZh8Bh0dNYyNmdpwcmsuLxQMpRKUy1AsGsplKJfrZdXhMEx+kmu+maZxY8DzLJ4Hvp/cPM9W7iGVAt+3ZLOQy1k6OpL7XK46ngx3dFi6uizd3dDdbenpsaR1qrqIiIiIyAGhEAYRETngcl6G07uP5fTuYxkKRrlr9GHuHnmYP45tYCwqksQxNAcyJKeOJ/9Xxy2NfYKnd3L57sIcmjsSV9ZmLa5xiYkJCJs7KVvLmC0wHpfYEQxy1+hDpBwf1zj0ep0ckVnJcfkjWJs5lLyXJeukmzojixwMDl3a11bhClOFsex+Jku6t4SbicBCWHSxkSG/cpT8oaM4XozvunSlc/R0pYhMiIPh8XAX5eGAwXCI2MZ0uB0s95fhGIet5a2UbRljDaN2jJRJkXJSDEcjtU7+oQ3YXN5KxqSJbISHhzEGF4diXKAYj+MZtxaq4GAwGAq2QMZkmv4EBxdLeUIQQnW/FdlowvNkMMSVfWlj2IKDQ0Q0obxa59Z1mErNYtN8Ulyyj07CDBrDFmJiHBw6vU5GohGwSWBDaEM847LUX8pgNMhgOEhoQ6y1dHvd5NwOIEdExHA0hDGQdTKMRMNUK3RM9hgOTR9GEAeM2lE8PJb6SzkmdyzdXs+UzcDDwzP66CMiIiIiIiIiIiIi+8cRRxzRFMLwyCOPcOKJJ057/kceeaRpXCEMshDk83D66TGnn17/HSqK4MEHHe680+H2213uvNPlvvscomj//mjZ3+/wta+l+NrXUvT2Wp773IAXvnD/BzKMjo7scZqOjoM7hAHgda+7jK997cvcf//ECwA0+sQn/g+nn34Gf/Znz94v9fjGN77GZz5z7R6nW7JkKf/4jx/aL3UQEREREZGplcswPg5jY6Zyo+W+uWx83FAoOE1lIyPVYIXkvlhsoxNhZ0kmY2uBDF1d0NOTjC9alNz6+urDixfHLFqUhDg4OpVdRERERGRG1BNJRETmVLef57zekziv9yT6y8PcNfowfxx9hHvGHmU8LhLbpBuxm1yzHmgOZHBouBL7br4jm1mn7eapq52Yk8WbhrKo1snZwSUkIoxDXFzGoiKbSju4ZfguHAydbo7Ffi9rsys5LLOCRX43h2WWk3MzE9Yu0m6ee/rR/OTWB/Y8YXMqyr6ZalkWcCxuKgIH4sDBhga/q0zHyjH8fAAGopKDjR2yiwt4+aC2TC8d4HoWN/bp8rpY0tHJuB1nZ7CL7WGMb1IsSy0l46Z5MtyEwZAyPsW4wJZgKzknx1g8TooUxkn2AbuCfjzHxZCEGQB4xqcclxlimLRJ18IWwODiUqKI33Io3riPqQYcJH9yJWyBCJ+JZ3nFNAckGGMwtmHf2MA1bhLasJuwhdZ9oDW2ts7GsIXIRqRNmpybYygawlpbC1vo9DpZ4i/BNS6D4SBlW8axDkv9pRhj6HA6CJyQoi3gGhfPeAyGA1gsnW4XZ3Wew7LUUoaiIQJbxjc+K1KHsDK1qmE7ioiIiIiIyO7NOMJQRERERPbRsccey80331wbv/POO3nxi188rXm3b9/eFODg+z5r166d9TqKHAxcF449NubYY2Ne8YoQSDrf3H23y+23O/z+9y6/+53H4OD++81oYMDw9a+n+PrXU/T0WJ73vICLLgo5++wI193z/DMxOjq6x2ny+c7ZXekcSKVS/PM/f4rnP///I47jKae94orL+NGPbuSoo46e1Tr85jc38453vGVa0374w/9Eb2/frK5fRERERGS+iePk89r4+O4DEqpl1VCF6YQrBIHOEZyOYjEJl9i2bfrzuK6lt9eyeHE9oKEa2NBY1tublPX2WrLZ/fc3iIiIiIgcDBTCICIibaMv1cUz+k7mGX0ns6s8xJ/GNnD3yCPcO/Yoo3GByFosMQaDg0OMJSZO+hEbKmVT/2DfeAr6xO7GTHi0sROzbVi2JQmAAEtIhNtQH4AYcK2DxdAfDjMQjvBwYSPGQIebxcdlUaqbVellHJpexrEda+jxOkk5ulq7tJc3X3QuP/3DA1hLLcjAkPTh36fQhT3Ob0n1lkj3lDGuJQ4NwahPqrtE5+oR3GxUr4gBx7PYyGBjA8bid4QYN8ZGDuWhFF7sk+uNMOkIxyR/hOdGxCZmIBishAGkCW3I1vI2sk6WIA7xjYcxBsc6FKMC4/E4Hl4tDMDBwRhDIS6SMc3BKo4xWGsnDUMAiFrCFqp7pMhG+KYetlANZ4iImuY3lX+7C1uIbVzZPmbCPDGWxkDjmJiUSSd7sUrYgq3UpcvtxsEwGA3iWrdSU0tvqo+804FjHAbCAcpxmbSTptPtomRLuLjk3TyxjUk7aQIbMBQO4RmPk/JP4YSOE+lwOuiP+olsRMbJsDK1kpSTmqphiIiIiIiIiIiIiIi0nfPPP5/rr7++Nv6b3/wGa+20woVvueWWpvEzzjiDjo6OWa+jyMEql4OnPS3iaU+L+Mu/DIhjuP9+h9/9zuV3v3P5zW9ctm/fP5fyHBysBzKsWBHzkpcEvPSlIccdN/V5CdM1vRCG/Kysa66dcsppXH75FXzuc5+acrrBwUEuvvgifvzjn7N8+YpZWfdtt93Kq171vwmCYI/TvuIVr+aCC140K+sVEREREWlHhULyWWdgwDA8nAQfjIwYRkcNIyNU7pPy6vDoKJWyemjC+LjCEg42UWTYudOwc+f058lmkzCGnp56MENjSEN1uKsL8nlLV5els9PS2QmeTocXERERkXlAh7UiItKWFqW6eXrqqTy996kMhqPcN/pYLZRhMBpNOhdjcXBwTHI1+sYABqfSyXgqEwMZ7JR9wluXFjeFMiTdoC22dj35kAhTmcYSkzI+ESHD0SgeDoOFYTYUNuEZl5iYtJOix82zIrWYQzPLWZFeTJeb54jsStLqlCxzxBjDf7z7lVz8wa/N+EKa9bCGyivLJMEKbjoCawiLLjY0dKwaI3fIOE4qwkaGqOTipiO8XFhflhfjZSNsbAjHXcJxDzxLpidIwhZiiEoewXCKdHcZ44BrPdyUoWMZ9PpZBsMBXPxKwIBlNBpjPBrHYmuhB57xCOKAoWiItJNqODnS4BiXsi02BSQkj5jKPqB5A1X3CRER3iSH3ZGNYJKwhdYwmd2FLVTDISKiiSdy2iQgIiLGa4hbsFg6nTxFWyKyEa5xa3Vf4i8hsGUGw0GMTcIYUo5Pr9eLZ1yMMQyEA8Q2psPtAGsZjoYB6PV66Xa7iYkp2TLWGpanVnBS/imsyx5FTMxYNIbFknNyyfwVi1k8YduIiIiIiIjIPpjh53cRERER2Xcnn3wyvb29DAwMALBx40Z+//vf87SnPW2P837nO99pGn/mM5+5X+ooMl84Dhx3XMxxx8W8/vUB1sKGDYZf/crj1792uflmj9HR2e8MtGWLw6c+leZTn0qzfn3Ey14WcNFFIcuX7/2HsNHRkSkfdxyH7Dy67Og73/l33HjjT3nkkYennO7JJzfyspe9iG996wesWHHIPq3zD3/4PRdf/JI9bmuAo446mg9+8KP7tD6Rg00c09TxcnSUyn29E2apBOWyoVyGIIBSyRAEVMaT8sbhMEzOFYnj+n0cG6ydrDyph+sm+/fqzXVt5T455aT6eHJvcV1Ipao3i++D79eHq+WpFLVx37cT5unsdMhkLJkMZDLguoZs1pJOJ9NNI09LRERkTsUx7Npl2LrVsG2bYetWh/7+JGBhcJDKvWm6Lxb1BifTVygYCgXD5s0znzeXqwYytIY0QFeXJZ+vP1Yd7+pKxqvzdXTomExERERE5pZCGEREpO31eHnO7DmeM3uOZzQc55HCJv40+ih3jj7IjvIgYeXq8AaDi5t0SG6Y38UhrkQyVL+H2d1pEPXvafZ8osTUU1RjHSweSchCQLnSlRoiYlwcIkIiG5HCoxAVGY8KbCnv5I6x+/FwyboZDNDl5lma6uWQ1BIOzx7CIq8H3/FY4veScvwpayKyr7o7c3zrPa/iz//xq0SVF1ItYMG1+F1lHM8Sh4Zw1MPriMgeOkaqpwyOJS45EDmkekr4ncnVRSzgpUOMC3HoEBZcbAx+R0S2Er4QlRyCoQx4MemOsBLoEON1gI0MXkcExmIDB8d18DssXZ2W2DikSNdCCQIbsjPYiWscHJMEEiT7C4eiLZI2zSEnxhistcTWNu4UaiEIEREublO5wRDaEM/UD6+r4QmxjZuWs7uwBacW4dIsCVtIIl1awxaq8zQHPSTT9Lm9DEcjtbCFiAiDYYm/hLF4jP5wgMgmAQ5dXhedbmft7x6OhjDGkHGyjFSCFhwcjsoexYrUIRTiAsW4gGd8VqVWcmzHcfR6vcn2sVFSr5ZvvrPO/DlBTERERERERERERESkkeM4vPjFL+bf/u3famWf/vSnOeOMMyZ8X97ot7/9LbfddlttvKOjg+c+97n7ta4i840xsHatZe3agEsvDQgCuP12l1//2uVXv/K4806HOJ7dHhv33ONyzz0u73+/5ZnPjHjlKwOe9awQf4Y/3Y+Ojk75eD7fOeU+5GCTy+W4/vov8bzn/S+KxeKU0z7wwP1ccMGz+eY3v8fatev2an0/+MF3efOb30ipVNrjtNlsluuv/xIdHR17nFZkrpXL1K5IXQ1M2FOQwthYvbxxXl3BeveMsWSzkMkkoQxJUENSlk7blnFqYQ7ZbP2xXA46OpL7XM7Whhvvs1l1LBQRkYmshYEB2LrVaQpYqA5v21YfDkO9kUh7Gh9Pjje3bdv7ZThOPbShMdChPtwc8FANeejpsfT1WXp6kmMzERGZXdYm30+MjcHYWBLgGIaGMIQoSgIaw9A0DDeXxc3dKGqfiz3PqQ339VmOPz5CX9eJyFxTCIOIiBxU8l6Op3Su4ymd63hpfD5PFndy39ij3D7yABtLWynFZSDp7+zhERE1dXSudnCudqZ2MMQTri9fm3iPkqgFKhEP1JZtW8YhBkvtBImYmJCko7IlJiCsTevgkMKnZMuUwwDXuAyFY2wqb+f/8SAxMb7xyDs5Uo7PYr+HRX43i/weVmdWsDS1CIMh52bIu7npblqRmmJcpD8YJLQhaSdFn9dLv7uTK/9mDbc+/jAPPLGTqOAClszyIl4uCT4xjsXxk9dbHDjEgQPGkuoMcDyLjaA8kiIad0l1l3FSFmstTsrixoY4MLiZiDh0wILjW1K9RSq5CdjIwZBc2cDrDXFcQ8Zka8EKsY0p2CKudTFOY1CBoUyEY50JoQoWCG2EZ/ymckjCBKD5TCmDSconCVVo3ZPsvtypBbI0lRuDsZV5JoQtuLjGEBHiWg9jDDExjjEs8hazK+wnsAEeHiHJ87bYX0LGybAj2EkxLmIwLPWX4DoeOZOjHJcpxEVcx8E3HoPhIDGWLq+bc7rOYZHfx3A0TGADUibFyvQhrEoduscTvVzjTvm4iIiIiIiI7Getv1aLiIiIyAFx2WWX8Y1vfIPx8XEAbr31Vq6//nouv/zySafftm0b7373u5vKLrnkEvr6+vZ7XUXmM9+Hpz0t4mlPi7jqqjL9/XDTTR7/9V8eN93kMTo6ex2U4tjw8597/PznHkuWxFx8ccArXxmwZs2eL/oA0wlhyM9GNdvK8cefwDXXfIy3v/3Ne5z2iSce56KLLuDWW+8inU5Pex3j4+P84z++l3/9189Pe55PfepfOPbY46Y9vchMWFvvlDBZQEJrcELr8MhIc4hCuayOlgeCtYbxcfZ7UEU17KE1oKE1tKHxqtDVDoat452dyTk1IiLSvqyF4eF6uEISpOBUQhaSoIXqsN7zRZLP3UNDMDS096+HXM7S22ubghl6e+vDfX3Vx5MOv4sWxfT0gOPM2p8hIjKnogjGx5PvJcbGks+51eHme9M0XbWsOlx/LCk7EEFQrpvmrW8t87d/W9Z+WUTmjEIYRETkoJV2UqzNHcLa3CE8b/GZDIQjPDj2BHeNPsQfRx9hLC7UOjQnYQe2ErhgMTChC7SDA8zsJPXpnDphW5bZ2CHbwRCRhDg4GBxcYiKKtozBJPNWJg9tiMEhjU/ZBuyKB3GMw7byLgyQNj4hIQ4OHV6WrJOmy83T53fT63XS63VzeOYQsk4aYwydXodCGhaQoXCYHcEuIhuRdtIs8xfzeOlJ7ht7kJFoFNe4dLg5rLVsKD7OeFwAC4ENCWyAYwxpk8Jb7LOuL8VAMEg5ConKhmAghbWGVF8Jx4+xMbieJS45eB0RxrHEgcE4kOoKiNIRbjoiDg3gABY3G+BlDTZOggiMqUQVpCJwLFmTxXGSEAZrLeO2kISWmOZP0xZLRCUUoqHUwCTlyXAS1FJ/pLpviFteu7srT/YdE8MWnFrYQvO+xhiDY5MQi8awhSSExcV3PEIb4FkfYwyhDfEcj2X+UrYF2wltiGMdIiJ6vB56/B4847M93E4xLuIZjy63m0I8TkxMp9sJWHyTAmMYiUbwjMdJ+ZN4SseJdLh5+sP+WttYmTqElJPaY5sSEREREREREREREZG6vr4+3vjGN/Lxj3+8VvZP//RPbN68mTe96U0sW7YMgDiO+cUvfsEHP/hBNm/eXJt26dKlvP71rz/g9RaZ7/r64GUvC3nZy0LKZfjtb13+6788fvYzjyeemL0zd3fscLjuujTXXZfm7LNDXvWqgOc/P5zyiptjYyNTLnM+hjAAvPKVl3Dbbbfy9a9/ZY/Tvu99H5x2AIO1lv/8z+/zwQ++j8cee3Ta9Xn3u/+eCy64cNrTy8JSKiUdvpIbDA8bBgeT8eFhw/DwnoMUxsaSzmMik5ntsIdqYENydejkqtHd3fXOho33PT00DFtmkHcjIiItrIWREdi+vTlIYbLhQkHHBSIH0vi4YXzcsGnT9Odx3SScYfHi5LZkiWXRovr44sVJWEP1sXy+fhV3EZHdiePke4YggHLZUC5TuTUPJ49PPU2x2BqWMDFIoXp/MB97RJHh4x9PUyoZ/v7vS3NdHRFZoBTCICIi84JjHBb53ZzZcwJn9pxAEIc8WdrOvWOP8puhP7K1vIswTuIOTKXDdFTpeG0mdMlOOnbbyr+k1EzoYN0qmbM1mKG5y3fcMkXctNRkCbYyn4tDjCEgxGBwcIiJKRPU6matJWV8yrbEuI1IGx9rLQPBMEMYtrITiyXl+Dg4lG2Ab3zyThbPcelwcuS9HF1uB4v9HpamFtHhZjHG0OXmWZVeVqtRa2d3ObCCOGA0GiPGknOyZJw0m8pb2VzaSmADUk6KRV4vu4IB/jh+H8PhKI4xZJ0MDobtwQ4iGwGGYlykGJfwjU/WyZByUozHBYaCISyWrJtlhb+MgJCB0jYiQow1hG7EIifLQJQEgHR4WSIvxM0lQQOlyCGO3aSVOzHOojKOARs6De0nxu0IMdbFdT0cY3Adh4iQgICMSeGZ+iHqeFxIXjcOtH78rwYuuLi18ep93FCeMJVXTX0f0LicxldqdZ/Q+pqvLm9CgItxkuCIlvoZY3ArYQuxjWvbICbGwSXnpinEBXzrgzEENiTnZlnqLWVrsIWSLWOtxbEOS1JLyLk5lpEEMZTjMmknjYPDrqAfsCxy+1icWYzn+IxFyVVzlnsrOCG3niOzR+Ial7FonJiIrJMl49TP+Frk66paIiIiIiIiIiIiIiL76rLLLuPOO+/kl7/8Za3sP/7jP/jWt77FIYccQmdnJ08++STDw8NN82UyGT7xiU/Q1dV1oKsssqCkUvD0p0c8/ekRH/hAiXvvdfjhDz3+8z89Hn549i4dfsstHrfc4rFoUcyrXhXw2tcGrFw58XyD0dHRKZczX0MYjDF87GOfYMuWzfzylzftdrrXvvZSLrzwJbt9vHrierEI3/zmV7n++v/Dxo0bZlSXCy98LS95yTvYutXguuB5llQKstkZLUbaWBwnV5uuBymYplCFqcqHhw/ujgqyMFU73WzZMvN5G68SPVVgQ29vEuxQve/oUKdDEZl/GoOYBgfrQUyDg4adOw3btxt27DDs2OGwfXsyXippZ3gw8rykA30+b8nnLbkcpNPJ54J0unG4XpZKWfzktM8pb9YmHW3DEILAVO6rt3on2yQkoH6fdJxNhstltau5EEXV1/j0pk+nJwtpqAY4xE2P9fUl7UzHTyL7V/V7o+RmKJWSfW6xWB1Oggyah01lmskDEKYKTwgCs9uAhSBI1hNFeuHvrX/7N58rriizZMl0LqMrIjK7FMIgIiLzku94HJE9hCOyh/D8xWdTisrcP/44vx36E/ePP8ZIOI5DTGQjDIaoEodgMBO+1EgCEAxRNYyg1pm7/rid0F27/lhj6ELz2MRO3nHDeHNcg8XgYEnCI1ycynhE2ZZqncIDG9bqE2HJmBQhEcW4hIND2vgEccCuyvh20w9FSDk+sY0JiUkZj7ybI7RREuBgfDrcLDk3wxK/l7ybw3dc8m4Hh6SX4lhDSETaSbEqvRwHQ8kG+MYjZXzMAv6WyFpb+/uDOKA/HCK0IWknRZ/Xw65wgCeKmwhsgGc8lviLGAlHua/wEMPhKJ5x6XBzODhsKD5OMS5hrSUkwjGG0Eb4xsNaKMRFxuJxPOPS6ebpcHKMRqMMhUmwQtqkWJ5aRtmWGYsKWGLCOCSyEd3GZTQaxXO8JKwjLvNkaXPSPg1kTAZrLeW4zKbSZowxpEwKYwyO9SnHZQKSAAHHd2p/e9GOY4GOVP0MlchGFGwBF0PW8evlcdLaIyK8CYeoltCGuCZVGbO18sjGuKZ6QlT9Fdccb1IPVWh8xTk4kwasVMtbJX+vAUzTc2uxuLgYYwhtWAuRCAnxjUfezTMUDWGtW9nfhPR4PfR6vewItjMWjxLFESmTZrG3GMcxdHvdDIXDBDYg5+UIbEB/MAAGjs0dy9r0GiyW0WgUYww9Xg9HZ4+m25v65Mw9PS4iIiIiIiIiIiIiInvPcRw++clPcvXVV3PDDTfUyqMoYuPGjZPO09PTw7XXXsspp5xyoKopIiSdHdavj1m/vsxVV5W57z6H//xPjx/+0OOhh2YnkGHXLodPfjLNddeleO5zQy69NODss6PaOQl7CmHo6OiclXq0k+oVgnftSnHllV/j8cefx4YNd0yYrqfnJDZt+mde/OIso6PJifCFQv2E+Op93SPAzAIY4LX84Af/yg9+MPkFKTIZSyaTdErOZJLxbBay2aRzVmcndHfXrzjf3U3DcFJe7bTszl7Gx4JjLRQKjZ0gzYRQhaRs8lCFkRGwduGetyIyE3tzlWhIOq8mQQ3JvrA6nIzXwxqqYQ6Njyn0RqZSfQ8YGTGMjsLoqKkNj4xUh5PxsTFDFCWd7eI4mTcZrp7rlYwnx2EWY8BxLI5T7yztONTGq8NQH3YcW3ssCW9Kbq5r8Tzw/cby5P1/d2WN8zXfbNOyJytz3f3XcdfapLN4GEIUJbcwNA3DyS2Ok/L6cHUeU5uucf7m8epwvXyysnr5xOnqz3H9ua3eQ2sbaH0smafaKbNYrB9rNo4rUKF9dXTYyq0+nM+bWlk+b8lk4tpw9b51uBq8kE63d2f4MEw+Q1VDwgYHzaQBIUNDhoEBw65d9Zva8YFTKhk2bzZs3jy96VOp5Bipr68ectXXVw3Aojbc2Vlvu0lbT4Y99QSUeSCOYXy8fozXGEbTel8oNI4bCoXdPVYPWQgC7QPnk0LB8PDDDkuWRHNdFRFZgHToJSIiC0LaTfGUznU8pXMdADvKg/y/kQe4e/RhNpa2Mx4VKdkAay2WmJg46VRNEnrQGI7g4BARU41I2FNAQ3OUQjPb9JhtGY+bljQx5qHe1dzBqcwRJ0ESlemLtoyhHhQREtcCJywRWZOhZMsU4iIuLmmTohwH7IwHcE3y949ay1A0DFgeHN+AMYaMk8ZaS8mW8YxH3sligdAm4QA5J4NrXHJulrTxcYyDa1z6vG46vTwOSWf1DjfH8tRiSnG5siyXpf4iMk6awXCYmJick2VFagkD4TDFuJQsx+/GiVMMhaOENiLrpknb5G8ZjwqAocPNkjI+o9EYxThZdqeXBywDwRCBDUk5Pn1eD+NxgV3BAJGNyThplvqL2BbspD8cIrYROTfHcn8Jj5WeZDAYSurlZunzeni8uIkdwU5CG9Pp5OjwOthS2s7WYDuhjUgZny63g4FokGJcIsYSxWHtWUg5KRwMxbjIaDSOYxw6nBw5k2E0HmckGsViyToZlvmLGbMFBsJBYmtxcejyO/HxKs+hQxzHDNsRYjdiLBrDd3xcHAIbsqm8GQt4xsU1fiVYIWBreTuecfEroQg+PoW4gMWSIwsmCSBwrUuZMp71MU7yxYQx1bZpiUxcaYv1wIOkpUW4JGeVVNtoXPnXOD2VNpQytiUEwRDbmGpR82ONr82ktbfGmxicyus2aprXMQ7GJmEmjeVJ2ELlNWVjHFOvo4uH53iENki2QyV4Ietm6PV62FbeQWCD2mt/cWoJeSePg0t/1E9kI7JOhrSTYTwexydF3unCd1xcXAq2gIkMeTfPOV1nc2R2HcPRMIVK2+jxeljuL1/Q4SYiIiIiIiIiIiIiIu0snU7z8Y9/nGc/+9l89rOf5b777pt0ulwux4UXXsiVV17JokWLDnAtRaSRMXDccTHHHZcEMtx/v8P3v+/xne/4PPnk5B30ZyKODTfc4HPDDT5HHx3x+tcHvOxlwR5DGPL5/D6v+0CIIti507B1a3LbsiW5GvCuXYb+/uS2c2d9uH4SfB74L+B5wK0NS+xicPA73HjjTEIozpxhrV8DfAHY/fNb7YA3OLhvv80ak3RK7utLOtUsWlTvXNM6Xh3u6ZlfwQ1BQFNIQj00oR6q0FhWvyXTq+OESHsLw2Q/v3PnzOdNp5sDGzo7qXU2rHaOTcanLk+lZv/vkr1XKlVDEqiEJNSHW8snC1RonC4JUZBW1QCH1oCHalADTB5EUA8sMMQxE8IVFFwksymdTgIScjkmhCY0luVyzY9NNlydPputB6Q0SqWaD57L5fnTQdPzoLc3CXebeBb67lkLY2M0hTLs2lX/bLZrl9NUtmtXsh+WA6NcNmzbZti2be/mz2SS10gqlYT7JDeL70Mqlbwv+P7kASN2kmbU/B7RHHQz+WNM8ZiZdJrW0JxqWTXIqPFvaB2u/k2ZjMHzkvF02uL7Xi1AMZ2uBigm2yedTkIUmx+rjiePpdPJ8mVmoigJhxkZST7HV4/bhofr49VjvMbjwNZjwrExHXvIzEx2DCAiciAYayc7hBKRhWDHjhFgfn/xIHPvYGhfsY15uPAkD41v5MHxJ3iiuI3xqEDJliuxBhZD0jE9IGjq3m1q4QdJmYtT61xvSMIRLMnfXO00XZ2/GoxQX9bux6sdxKvjTi3uIa6s16UaH1EfT+ruVLqgV8MXHAwGh5ioUr960INvPAIbYEm6suecLCVbJCLCwyNjUpRtQECIaxxS+IQ2JKou1xisTTrQO8YhJAJr8UwS8FCwJWJiPDxyboZyHDQFOQAU4gIYyDppUsanZMtENsY1LiknCQ6IbYzrJH+JaxwiG+Mbj7IN8Sqd/SNi0sanbAMcnKTzv02+ULLYpPN8HGGMIbZRJXTCULJlYhtjjCHrpLEWxqNxypXQhqybwVrLaDRG2YakjU/erYQ7hEO1bbXI78EAu8J+IpsED/R63WScNNuCncREGGvIuGlyTo7BcCh5jq2tBV0U4hKuSQIEqh37Y2wlRMEltjHluJyEORgf10l+QQnjkLIt4huflFP/lbEQFYiJ6XBytfYYxCElW0qeXzddq0MhTqbNOllc41amTZ4vgyHnZGvLGK8s18Ul62TAQGQjSrZYq1vKJPUIbEC5soy0k8KrZIIV4xIhIQZD1slWAhWgEBcrIQ4OWacef5+Uh6RMqrbsxuVknUwt+AGotOOAnMk1BRgU4xIGcI2LZ5K6xMRENqLDzTEWjeNV2kZgAzrcPIu8XraWt9Xaim98VqUPwTcphqIh+sMBwjgk73aQdjLJl5gW8m6epf4SAhswHhfwjcchqRUc37GeQ1IrKNkSxUogSs7N1ba7zC8Hw/uiHJzUtmR/UvuS/UVtS/YXta2D05Il8+/qnnPl6pdfe0DX96FvveWArk9ERETkYPP4449z1113sW3bNoIgoKuri7Vr13LyySeTTqfnunqTqp5LIJPT586FI47h9793+fa3Pf7zP32Gh2fvxPCOjlGMOZ7R0cd3O83LXnYxn/7052dtnTNlbXJS/ZYtTiVcwbBtm8OWLdXAhaR82zZDFO3LthkBLgR+URn/NvDSGS5jE7BqmtO+F/gHalcBaEPGJKEMvb1UghriSlBDfbynh5aryyed0mYzzz8MqV1dsnol8qSTBQ0dLSYfHxmphyyMj7fvthaR+SGVSjroZrPJvrDxvtppd7LHstl6p95qZ710Olle0rkv6bTXWuZ57X3V9OmyForFZF+fXEG4+arCreONHebqwQk0BSiMjCg8R+RglcvZSshNY9hNc/hNR0cyXA9HaAxNaA5ZOJAdm/U5fXaUSjAwkIQ0NN5XhwcHDQMDNJUPDOzr50GRueW6STBDNbChel8NbageJzaO16fZ/byt0+Ryyf2BDn2wFsplJjm2S47vxsYmHvdNFqpQHU+OBfWalwPv0ENjfve7MQWn7IbOuRLZv7y5roCIiMhcc4zDUbnDOCp3GM/nbIpxmQ3jT/JYaSuPjj/J46UtDIYjlOOkg3g1YABrk5ABmsMXaAlOqJoYstCcSepgiBrmbXw8GW6dtz7eGMBQD2xonHqyEkNEjFOJdIiIKp3jqxEPEUVbxBJjKiEOASEhIQCxtWAgxhITEWPImSwxEUVbxljImAyOMRRskZINSJsUKXzKlBkMh/GMh4dHFEcM2qGkLsZADCPxeO3HqhiLseAbj5g42e4RuNYh42aSDvk2xgCZSghAMS5hbYxjXLrcHEVbJIiTgAkPl063g5F4lIgYLKSMT9pNMxaN19YXOmGl/mUMUIiKRDbCYglthIdDYEOGwuFK8IYhTZrIROwI+nGMxcElY3xiY+kPBwFbCUdIwhwKUZHRaIy0SeM1hCgMRSP4xq91xPetx5gtJOswfq3tWpLAiaYgSGOxFkIbkaokasS23kJDIvzKYWBkkzYcEdUCICz1+I/AhrU6xLU2ZGthE9X2Z6AS+2Fr7bfWPittpd62G9eRcI1DaOvLqvKMV6sjk5S3vs4cYzDWNK3TVmJFMiZLQIhvvSSEw0Z4jsdir4+dwS6CWmBHxCK/j16/lx3lnQyGQ0Q2IuOk6XY7CW1MzunAtW5S7mYYicaAUTJOhmf2nM+hqZWMxmMU4yKe8VjsLWJN9oha0MNkMiaTtF8REREREREREREREZk3Dj/8cA4//PC5roaI7AXHgTPPjDjzzIhrrilx440e3/62x89/7hGG+3bC+djYISThA7u3YsUh+7SOqRQKsG1bEqSwbZupBCs4lXCF+vCB6TzfCfwY+CvAZeYBDAArgUOBjVNMkwU+D7xqL5Z/YFmbdHLq74dHHgGYXoB/KpWEMvT2Jh1DkiuG2tqVRSEJVqhe+ToMIYoMUZR0uKp2uigWk3t1ol3YPC/pdJnLJR3PU6n6lXWrndGrbaw+nMznOEkHdcehadiYxnJbPy8oTtpi9WrtUVS/t7b+WLU8DJOOREFgKvf14eRmCIL6NKVSfRqZn8rl5PkfHDwwz7ExSSe66ushCWloDmzwPHDd5FYfti3j9deM5yW36tVdq5dYbL2CdGt58ppI/v7JXhvV10P1Vi43d7TT1YdF5hfXtSxZkhwP9vUlQV29vdV7GobrQV7VcAVX14xa8NJpWL7csnz59K/zG8fUwnmSDtqN4W3N442Bba2dugsFvR/J3IiiJGDqQAULtIY+1IMekmHXnXi816haFobJMV/jMV7rMV/1M1Ec6/UlB7dUyvK+95UUwCAic0YhDCIiIi0yTorj8ms4Lr8GFsFoNM5AMMITxS08MP4ED44/Tn84RGCTjuyxSTrsJ0EIFhcHgyGu/DOYCcnXphJ1EFdCHBycCY83hyY0Bzg0hj1MxjZ1cbctU5qm0qbO8pXxZO2G2EY4Jvl7ImLKNqjUPalP0ZYBi4ODxVKOy5U4hmQJISHYejhFRJR0to+T7vyhDUm7KWwcEVS2V9ZkcHAo2AKxtaTwybgpwjhi3BYwOHS4WbBQsEWGohHSxifrpoljy1g8BkDOyWIcQxiH9EeDeLhkTBoMlOIyO6MBUiZFxkmDhfG4yHhYJGPSpBwXG1vG4gJgyZosjmOwsWU8LgAmqWe1zBawQK5SZqxLgTKRtWQdP9lmtTYS41cDCUz9uWgMNagGaoQ2JG19MIbIxJV2FifbEY/Yxk3TVjv4R3FYC+pIpnVrbcKQhDz4bmOAgqk9Px5eU/tqDUCoBni0BivUW1u1DTkTgkag3tYtzUElbuWkEVNrgdVyp7Ktml8j1XYXY5vCIwC63E4KcZHQhjg4hESkTIrlqWXsCndQiAvY2GJwWJFaRt7NYzDsDHcRxAFZJ4MF+oMBXOOyLLWUHqebgIBiXMIzDkfljuQp+RM5PH0oA+EgpbiEa1z6vF5ybg4RERERERGROdN6JoaIiIiIiIjss0wGLrgg5IILQrZvN3zzmz5f+5rPhg2tv2NO19QBDAAbNpzOv/+739QxqqPD1jpHVTsz169iXb9q4dgYTVcsrQ7v2pUELAwMtNsJ+GngM1D5/XvvnMnuQxhOB74CHLUPy29/5bJhxw7Djh1zXROZK9lscvXpxitWV4erV61uvap19YrXyXz18kyGCec7HeyspdYRqVQyRJFLqUQtfGR0NK7tT4tFKo9Vh03LY8l9cjO1++o81U7u4+Pq9DQfWZu85xYK0Hz2nYjI/uE4SbhCtYP8smVxbXj58phlyyzLllkWL7a1MBeRA8FxoLMzOcY85JC9/40yCGgKZWgMbKiXTXx8eNgwOloPfNBxl7S7Ax36IHIw6+62nHJKxF//dYlTT92X7wxFRPaNQhhERET2IO/myLs5Ds0s4+yek7DWUooDHitu5u7Rh3i4sJHt5QFKcUBgw1rwACQdzlPGIyAgrnRsdyuBBUlAQ73TeiMHUzm1oBqUUJ/CVP7ZhvFGEz+SVzv617XGMjRGNpiG0sblVzv1G0zDPElH+GpZQIjBVP5GCGxY6VKf/ItsEuRAQ8f/IA4IK/PV5rGmsr2SZXqxR9mWMTjJPJXO9dUAgsCG+PgEBLW6hTbCw60sG0IirLEYa4gq4RehDUnhESdd+akHEbjEJq4FSISEpPCJTFx5apMgBAevocwSETfUy9aCJlyTalgHBHGI57jElXnAENqIVKXdhDZqCLJIghGqYQgGh8BGuMZrClaIbExsYxzj1J4nC8Q2xjVuQ+hGEhBSDS5obCfVYIV6EEJDlKaphm+0tiZwjUtQCeioLtEYg2s9YoKmAAXHODjWwRLhWFMPcjAGx1aWUFkfQGxifPzkObQRnnErW9KyxF/EWFygHJdwrENkI7JuluWpZYxFo+wIdlG0JTzj0uv1YInJmg4whpCAjJumHJfpt/24uJyWP4VV6ZUENqBIkZTj0ef3cVzH0bhRqrIpWrcbLE8tQ0REREREREREREREREQWhqVLLW9+c5krryzzu9+5fOUrPj/6kUexOLsn0P/oR+fxox9lZnWZ7W9feoydCXyrpawP+DvgzehUSWlHxuw5DGG6QQr5PHhq5lMyBlKp5JbPW1Kp5rOpyuVot/PurWpQTjWQYWxssvukI1bzff3x0dF6h0N1MBQRmX8WL54YqFAdTgIXknAFvc/LfOb70NcHfX1TX6RwKtbC2BgMDSUhhIOD9WDCwcF6QOHgIE1lg4OGMNSxlYgsXJlMEujY0QG5XON9PRQ2l6MyXi9rnC6bTfblnpcEyHpeckuGbcNwMl1jaFTjdUZ8360NGwNBMPuf00VEZkofxURERGbIGEPGTXFMx2qO6VgNJB3dNxQ28WRpO08Ut/J4cQsD4Qgj0RhBHIJxcLHJlSisIayEALi4SUf5SiBDa8ABJIEMlTVDpcP91CEMpunrp9avhab/NVG9u301gKFx/mQ9tjbFxK+8DLYSkuBUTpSIiQgrQQWmEjRRtmWMqU5jCW1YC20wlWWUCSrrSv76MA5r28XBwRITxCGhjahGPgQ2wDWmsm2TaZNlN4YUWCIbE9qwFihRDUMIG0IPQhuSsj5hHNbWmgQ/eC1lAb71iGxYKTGENsQ3PlElOqAa0hDXIiTqgRRhJQCiMSQjshGe8bC2/lxENqoERNC0nVrDNWh63kxtPY2twDGG2FbKqoEItWUm7a0aiOAZj7INsMRNQQS+8QhskDyrDeUOLhA0tOH68j08IiKMTeaJiPBNirTjU4xLeNbDGktsLUv9xRgMO4KdFOMQsHS5nfR5veRtB9vKO2phC2knzVA0BECf30ev1wNYinEJgJXpFZyUP4F12bUMRcOMR+M4xqXH665Mm0il3KY6l6NKe5hvl3kQERERERGRecfavTsxSURERERERGbGGDjzzIgzz4y45hr47nd9/v3ffR54wN3zzGSBwh6mWTELtVxIzmwYXg5cDrwd6J6b6si81tlp6e5OAhJaQxKmE6RQHc7laqdkyDxlDGSzkM1aFi2Cve1U2KjawbAaytB4lejW8ZERw9BQ0tlwYKDeITEI1PBERPa3vr7GQIXJAxaWLLH4/lzXVGR+MIbacfbKldM/5rIWRkeTYIb+fsOuXYadOw07dji14eqtOl4q6VhKRA4c30+OF9LpZDidrocLVkMTpgpIaCxLAhWawxXmOuip8XsRZ1/yWUVE9hOFMIiIiMwCxzgcmTuUI3OHAsnJ7juCQUbCMbaUd/Dw+JM8XtzMznCAkg1I4VOOg3ond5IwgRQ+Rcq14AAPl4iYiJhqZ/16+EG1Q32r5vL69JOPT1xO6/STa+zcP9l0k8/Xuu4kxMFUQhqSYIZqWT3uIWwINQCIiCpbqBorkIQuVAMGauENNmiooyWw9fCG6nYIbEhso8o0BogJbHOggyUJakieh3pZZKtRCg1lxMQNz1WMTUpaOkDEkz0n1rZsuPr2MpWnqfHZqkd2NHOMW9tmtbLKNq5HWdSDFQIbQiUcI1mXwTceRVvCaThcNMbgYIgwONZpCm2oBjBYa2v3MTEZk6lsqygJuSDCd3wW+33sDPqT5yhOFrU8vYyck2NbeTsj0QjWQqebxzUusY3pdPMENsQ1DimTYiAcxDUux3YczfrcMcQ2ZjwuYLF0uDnWZdfS4yUn1FTr1Sjn5hARERERERERERERERER2Vc9PXDppQGvf33ALbe4fOELPj/9qTfFlcqfB3x3iiVePPuVnPdOAl4PvBh4Djo1UqaSyVi6uiw9PZauLujutpPcJi/v6kqu3igyVxo7GK5YMfNQh2qIQ/Xq0IODpmm4eoXo5vHkViiow6GILGzV44elSy1Ll8YsXZoEKSTjSdmSJZZly5IOkiLS/oyBzs4kaO3ww/d8bFUNbaiHM0wMa2gNbogiHUOJtLtquEE6bSthB8lwKkXlNjEIwfeT8j1Nk07byrTN0zc+Vr9vXq7vK5hARGSu6ZcGERGR/cAYw9JUL0tTvazNreKcnqfWHttR7ufe8UfZVtrJ5tJOtgY7KcUBY9E4ZQJc64Bxkk7jtR75lpRJYa0lIAQsLi4QVx6td6pvDVxoLKuP1x9v7dRfjSiw0BIIQMNUEzUuc0/Tt05jJ5mqeZp6UMPu5rGVv9KplVYDDOqxAxZbC0ioim08IcRg4hUjTWVLN5dNjD/YXTBG8iWdsa1TV7ZzyzzNQRlJXasBCTE2+RtNEoRgcLANQRAArvEIbZBsD1MPVvCMR9mW8fBqG89J4hOSYWuaypNgBZqCFRwcPOMREuLbJII5sAEdTgee4zEWjWGsIbaWlONzSGo54/E4u8JdlG0Z17j0eX34xqfb7WQkGiUgpMPNEdqQoWiYnJtlbXY1nW4nY9EYZRuQcTKsy67h2I6j8Y3HUDhMZGOyToYer3tCwMLE7a8vMEVERERERGSBmPC9hoiIiIiIiBwoxsA550Scc07Ek08avvQln69+1WfXrtazpZ/N1CEML9mPtWwvxljy+aRDW2dn83BXV/3Kfdls0nE+nU7us9nkBPVMBjIZcF2L616L44DrljCmhOtSGbcYA3FsiCIIQ4jj5D6KIIqS8iCAUgmKRUO57FAsGsbHoVCAsTFLoZCMt15xvjqszskHjuMkIQn1IIUkIKEaqjCxzNLTQ60sk5nrv0Bk7jSGOKxaNbPvEgsFGBpKghnq99RCGhpvQ0PV4eRxdT6U2eQ4ls7OpB13dibHC6mUxXEq5+mZ5BggOQ4wtXKAMLRYmxwLxHHylXp1vF5udlNev4UhBEH92CI5rjAEAbWyIFC7b+R5FtdNwow8j8qwxfOSccehMrz76arHd9XntPneNj3/rfdQH/f9+nFkJmMn3Hd0NIcx9fQkbU5BTCLSGNpwxBEWJjnDvFEcw9AQtbCG/v7k+Ki/PzmWar1Vy8tlvYfIwub7llyu/p1QLmcrN8hm64+13mcy9e+LUqlqsEI9XKF5uF6moAMREdkdhTCIiIgcYEtSfTw91VcbL8VltpV3MR4V2VLeyWPFzWwu7aA/GGQ8LpEzGUo2ILAhFotb6YzvGZfYQkiEgyFj0pRsQFz5MidlfEIb1sZdHOJKCAHsLkphYkhD86NTfaFjpxibuvRg+Jposjom0Q6NgQlJ4IODIWwJe6iGKDQGNzQGIEASFJCEJbiUbYCBhufbo2wDLDGu8WvT+8ajZEu4laU1L9dWQj2S5bu4SVRDJVDBmCQEwsXFGENAhG+TiSMiutwuQhtQtgGedQltSM7NsjS1mG3lnYzHBayNSTtplqQWY4DYRozHRYwx5Nwso/EYFuj1+uhxO4mJKNuA2MasSC/nefkTOSy1ip3hLkpxCc94LPEXsyS1eMrnI5PSGREiIiIiIiIiIiIiIiIi0r5WrbK8+91l3vGOMj/4gccXv5jizjurvbZeDFwDPDbJnOuBiw5UNWddKmVZvjy5IvCiRcmtry+5LV4c14ar5V1dB/JE9+l3Nk6lmnvYlcvRHucpl2kKZujv3/1t1656B5uF2rmmo8M2dW7s7q53dqyGKzSWN5Z1dKiDhMhcyGaTDk/Ll88svMFaGBtLwhiqAQ71wIYk2GFoyDA6ahgdhdFRw8iIqdwn4+PjC3NfOZ9Ug5fyeVsJT6iHKOTzVO6bh3f3WDZbD1XYk715T59NcZwEPVXDn6YT3tBYFgT10IcwbJ0vKWtddhJEYGthBY2hBY3BBEmoga2FHdSDEGxLKELzdM0BCfVwhMkCExqDE3QdJRFZiBwHenuhtzdm3brpzWNtNQzQMDaWHAtVhxvvy+Vkv199v2gdb9W4H27dJ0/2PjFx3E4IuZlsuomPTZyv+nmu+t5VrXPydyTvbeUylfvq+6QhCJK/u1hsvBmKxXqoYqEA1upN50CbLGSz9ZhuquPAjo7m0AXfn+u/SEREJKEQBhERkTmWdlIcllkBwDEdRzQ9NhKO8WDhcYbCMXaU+9lc3kF/MMRIOMZYXMR1PFKkKNsyJRtgMLWu+I5NxmIiXDwyTopCXCQmxkwW2oBHSFQJabAY4wJxLTSgGhZgG8IFGgMEbEvoQDJOwzi1eZqWYerjtml6WwsSMDhN45PFQRicWn2b56svsRpqEBFRTSZwjIO1MVFluwA4joMTWyKi2rIc4+CRBBE0rrMamBBX1uvggPFqARgGUwtSSJ6PaplbCVzwCGzyTZdL8oNPtcxWhqvbycUlJMaj/sNQEqzg1AIVqtvFqSw/JMJrCFbo9ropx2UCG+BYh8hGdHl5erxutpa3U7IlrLXk3BxL/EWUbcDOYBdlW8Z3fNJOmpFwjKyTIetmyJg0ERFlW8bBcEzHUZzUcTyecRmKRohsRNbJsDa7mh6vG4DYxrUwiKpFDcEkIiIiIiIiIrIP7MxOgBYREREREZH9K5OBiy8OufjikDvvdPi3f0vxgx8solT6BfAi4I8NU/8Z8BWg/XqXG2NZvNiyYkXS+Xb58pjly5PxFStili1L7nt7F24Hu1QKFi+2LF4M0w18qHZMbgxlqF4ddWCgPtx6m+sraztOEqBR7VzR2ZmMJ/e2Uk5DkEJz2EJXl1WHCpEFxBhqna5Wrdq77y+jKNlftoYzVIMbCoWkw13r/fi4YXx86seLxQX6xjUNrlu/2nC1g9zkYQn1znPV4cbyfD5ZzkIM0HEcaldYrmt9Heh7fRERqTOGWmf0JUtA7xOJ6QYrWZuEOZRKyTFfNZyhGtpQKiXD1ccKhfp4a7BD9ZixPn/zeH2eg/d40veT0INcLjle6+iwtc/6U33ubx1XWKKIiMxXCmEQERFpY51eB6d0HtdUVohKSad/G/NoYRNbyjsZCIfZFQywKxgksAEj4ThlG5DGB1IEtkzRlioBDaYWfOBgiLB4uPj4WCAgxMUhQ5qAMiHJFxRpkyKy1ZiGGM94GAyBDakGHvjGpWzDSqyDxccnJMRWohyq648bvgzy8AkJatN4uJXhemyDXwslSMo842EshIRUYwdSxqNUCTOwlfqkTIqiLdaW5hsvCTKwEdUvpHzjYo1DHJexxIDBw8M4hjiOiIlxcXCNA5UQhhiLZzwcYwAPbAjVbWLAsQ4ODlElMMFgwIBrXSIifLxaAIGHS0BQC2pI/uIkzsFAZf0u1iYhEimTSkIkrAELESHdbiehjSjZMsaCtZYur5PepmAFyLs5Fns9FOMyA8EgZcqknDQp41OIi+TdDlzThWdcLFC0JVwcntZ1Ckdm11CMi4zHRRwMnW6eo3NH0uHmCOKAki3jG5+U8ZvCFSbjGH3DIiIiIiIiIiIiIiIiIiILz1OfGnPddUX+4R8MN9ywgptuuo1f//oBxsc3AMcA65iLAIaurnqoQjVMYcWK+vDy5ZalS9Vpfn9o7Jh8+OHTD24YH6d2FfmhoeqV5amNl0oTryTqOPWrWLdemTqTsbUr3FfvM5n6FSgzmfoVLfP5pHPFQg3bEJG54brUOoHNdkfEOE6uNl0uJ/vLUikZLpWqw81lyX3jsKnMm3TAK5eT0IjqLQxNw3C13DQMV8uT6ar718arR08sq998PwkC8v3kvToZt03lyX1yq+7rq/v45L75ysPV+1RqVje1iIiIyH5nTHIMk0olAQGJ/RtkYS1NAQ7VoIbdBTY0BzzUy6rXW2g89mv8u6r3nlc/5vM8asd6zePJ8WD1s331WK95GH3XIyIisgcKYRARETnIZN00WZJY5F6/q+mxchwwHI0S2ZhSVOax0ib6y0MMRaMMBsP0h8OENmQkGqcUl8k6GRxjGI+LSQd+DBmTJiKiTADW4JgkOsHFweISEWNwSJsUsbWVkAVIGx/PJAEH1eCAlONDbAkqYQkZJ43FUorLxJXQAt/4RDasxCQYUo5PFCfrt7VpvFr4gcHgGxeMIYzDWkiC53hEcVwLhUiZdCXKwCEmqoUwGFsti3FwcE014CCZzq8EKbjWweBgiXBNkpzpVP6FRHiVE18ck2ybEItLMl0SouBisEnghbXVrAh8PDCGyEYYa4iIyDlZLJbABjjWIbIReSdHzs0yEA4R2AAs5N0OlvqL2RH2MxKNYK0l62bp9PKENsaEI0n4hpsi7aQZj4t0up0sd5fiG49SXCK0ETk3yymdT2F15lCGwxEKcRHXuPR6PazLHoFnPEo2mTZtUvjO1N+u+I6Pj76BERERERERERERERERERGZjkWLLJdcEnDJJRDHq3nssSP4059c7rkn4LHHHLZsMWze7LBzp2F8fOY93X3f0t1t6euz9PQk97290NtrWbo0CVVIbjHLliUd6uXgYQx0dCRXp1y5UldEFRHZV45T3a9Ccwc97WNFREREZM+MoRJoCPVjSB1LioiIzAcKYRAREZlHUo7PYqe3Nn5YdkXT4+U4YCwqABDbmA3FJxmJxijFZQaDYbYHAwyHo4zHRcpxAIBvXMbjAiVbwjUuXU6eUlymGJfAJKENMZaQiDCOcHFxjIsBApsENDg4OMYBa7A2xmAAg288sODiERLg4eJYB2NMbd4UPsYk05ZsGQc3CUWwFgeHiDhZDuDjE1YCHzzjYozBsx4lIjxcjDVgwLVuEt5gnEoAg8HBYHEwVEITABcHpxIbGccWa5J1ZhyP2FqiOCKqhDn0uB0UKtvNWovneCzzFjMYDVKyZWxsSZkUy1NLGIpGGI6GsdaSclL0eT1ExAyFwwQ2IOX45Nwsxjh0unkgCXHwjc9IPErezXFsbi05J8doNEbZBmScNEdmj+CozFr6o37GogIOhh6vm1XpFTiVvzX5u909tqWMyexLUxQRERERERGRuRLrZA4REREREZGDiePAmjWWNWtCXvjCiY9HEYyNwchIPZDB2vrVEQEymfpVqzOZ5IqIIiIiIiIiIiIiIiIisvf0c4uIiMgCknJ8Uo5fG1+U6pkwjW04U2NreSdD4Si2ksTYHwywIxigHAeUbcBoNE5/OEQQB5RsANYSk4QajEcFAhuSczOkTYqCLVGMSzjG0GlyWAzjtoC1Ft/x6XFyjMcFCraIwdDhZMFAMS5hI4tjHLrdLkpxiUJUwlRCCTrdFONRkUJUxOCQdzqwWEq2TBwngQOL3F6KtkjRliC2eMZnmbeE4WiEYlwGLGknQ4/byUA0lExnDR1uli43T384RCkuYTB0enlyTpbhcISiTcryXgcp4+EYh2Kc1K3DzWGxdDh5uoxJQhCwlG2ZDjfL2sxqur08Q9EI5bhMyqQ4t+t0jsgexq5ggEJcxDUuvV43azOriYgYiUaJraXDzZJ3d38pkkVMfF4BjDG47DmAQURERERERERERERERERE2oPrQlcXdHVZdBVFERERERERERERERGRA0MhDCIiItLEGFMbXpFewor0kimnt9YSk4QdhDZie3kXpbiMZ1w6nBwby1sYjcZxMHjGoxiX2F7uJ7ABvvEwxmFHeReFuISDIe34jMcFxuMi1saAIeOkGY3HknAGm8VgwED1BJO0k8LFI7QhrnHBWnJk8U29zMen2xg8XEJCHBz6vB46nCwxMWUbALDcWcKy1GICGzIWjRMRc5Tfx+rsKspxyHA4QkREt9fJkZnVlG3AcDRKbCOyTpajckcQW8uucIDIRmSdDIelD8E1LuNxgSAOSDtpcm52t9t0debQCWU+HhknPePnU0REREREREQWGnXIEREREREREREREREREREREREREdkXCmEQERGRfWKMwcUFwDMuh6SXNj3el+req+XGNiYmxjPJ4UoxLlGKy7jGJedk8HzDUDhKaCOybpp0lGEsLjAWjQPQ6ebJOmmGopFKKIRHt5fHxWU0GiOwISnHp8PJARDakNBGpBw/CXLYR0tTiyaU5d0O2PdFi4iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIyH6iEAYRERFpS45xcHBq4xknTcZJ18Y9x2VRqqc2Xo4j8m6OvJtrWk6P1zVh2Z1efkKZb3x8/FmouYiIiIiIiIjIHIrtXNdARERERERERERERERERERERERE5KDm7HkSEREREREREREREREREREREREREREREREREREREREREZH5z5vrCoiIiIiIiIiIiIiIiMhssXNdAREREREREREREREREREREREREZGDmjPXFRARERERERERERERERERERERERERERERERERERERERERaQfeXFdAREREREREREREREREZkls57oGIiIiIiIiIiIiIiIiIiIiIiIiIgc1Z64rICIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiLSDhTCICIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICeHNdAREREREREREREREREZktdq4rICIiIiIiIiIiIiIiIiIiIiIiInJQc+a6AiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi7cCb6wqIiIiIiIiIiIiIiIjI7LCxnesqiIiIiIiIiIiIiIiIiIiIiIiIiBzUnLmugIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhIO/DmugIiIiIiIiIiIiIiIiIyS6yd6xqIiIiIiIiIiIiIiIiIiIiIiIiIHNScua6AiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiEg78Oa6AiIiIiIiIiIiIiIiIjI7rLVzXQURERERERERERERERERERERERGRg5oz1xUQEREREREREREREREREREREREREREREREREREREREREWkHCmEQEREREREREREREREREREREREREREREREREREREREREQG8ua6AiIiIiIiIiIiIiIiIzBJr57oGIiIiIiIiIiIiIiIiIiIiIiIiIgc1Z64rICIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiLSDoy1uiSSiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgz1xUQEREREREREREREREREREREREREREREREREREREREREWkHCmEQEREREREREREREREREREREREREREREREREREREREREUEhDCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIigEIYREREREREREREREREREREREREREREREREREREREREREQAhTCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiAAKYRARERERERERERERERERERERERERERERERERERERERERARTCICIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICKIRBRERERERERERERERERERERERERERERERERERERERERARQCIOIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICKAQBhERERERERERERERERERERERERERERERERERERERERERQCEMIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiKAQhhERERERERERERERERERERERERERERERERERERERERERACFMIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIAAphEBEREREREREREREREREREREREREREREREREREREREREBFMIgIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgIohEFEREREREREREREREREREREREREREREREREREREREREBFAIg4iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgIoBAGERERERERERERERERERERERERERERERERERERERERERFAIQwiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIoBCGEREREREREREREREREREREREREREREREREREREREREREAIUwiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgACmEQEREREREREREREREREREREREREREREREREREREREREQEUwiAiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiAiiEQUREREREREREREREREREREREREREREREREREREREREQEUAiDiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiAigEAYREREREREREREREREREREREREREREREREREREREREREUAhDCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIigEIYREREREREREREREREREREREREREREREREREREREREREQAhTCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiADgzXUFRGTfPPTQQ9xzzz1s376dOI7p6elh3bp1POUpT8Hz5uYlPjAwwIYNG9iyZQu7du2iUCjgOA5dXV0sW7aM9evXs3Tp0llf5x133MHGjRsZHx8nl8tx6KGHcvLJJ9Pb2zur61oo2rFtlUolHnnkER5++GH6+/spFAp0dnbS09PDcccdx5o1a+akXjJzal+JJ554grvvvputW7cSBAFdXV2sWbOGk08+mXQ6PevrWwjasW3J/KC2ldi2bRt33nknmzdvplgsks/nWb16NaeccgodHR1zXb2DVju3rzAMueuuu3jooYcYHBzEcRyWLl3K+vXrWbdu3ZzWbSFo12MFay333HMP9913H/39/QAsWrSIY445hvXr12OMmbV16bPe/qG2JftTu7avA0n7LhERERERkfbSrp9V9V2IyOxp19e5iCwMek8XERGZmrWWJ598kgcffJCtW7cyMjJCKpWiq6uL1atXc8IJJ7TFcbvOkxLZNwfLa11E9l65XGbDhg1s2rSJbdu2MTY2RhiG5PN5enp6OProo1m7di2u685pPdv5vGwROfhoryFyELLW8t3vfpfrr7+exx57bNJpenp6+PM//3Muv/xycrncfq1Pf38///f//l9uu+027r77brZv377HedatW8dLX/pS/vf//t9ks9m9Xvf999/PJz/5SX71q18Rx/GEx13X5elPfzpvfetbOeaYY/Z6PQtFu7UtgAcffJD/+q//4re//S133XUXQRDsdtpFixbx0pe+lFe+8pUsW7ZsRuu57rrr+NSnPrXX9Xzxi1/Mhz/84b2efyFYyO2r1c9//nM+85nPcM8990z6eC6X46KLLuIv//Iv6evr26d1LQTt2LaqoijioYce4q677uLuu+/m7rvv5uGHH256z7ryyit585vfvFfL/973vsfVV1+91/U7/fTT+cpXvrLX8893C7lttbr11lu57rrruPXWWyd93Pd9nve85/GWt7yFVatWzco657t2bl8AY2NjfP7zn+cb3/gGg4ODk05zxBFHcNlll3HRRRfN6MQh7bv2rF2PFYIg4Mtf/jJf+tKX2LZt26TTLF++nNe85jW8+tWvxvf9vV6XPuvtHwuxbf3+97/nkksu2eu6rVy5kl/84hd7Pf9C0o7ty1rLhg0basdLd911Fw8++GDTZ7/Z/DyvfZeIiIiIiEh7acfPqnBgv2cTme/a6XX+6le/ere/pU3Hhz70IS666KJZrJHI/LBt27ba97t33303f/rTnxgbG6s9Ppff4+s9XUREZPeGhob4+c9/zv/8z//wu9/9joGBgd1O6/s+T3/603nNa17D6aeffgBrmdif50mJzHft/lp/5jOfyaZNm/Z6/i9/+cucccYZs1gjkYPPT3/6U37zm99w5513smHDBsIwnHL6zs5Onv/853PJJZewdu3aA1TL9j8vW0QOXsZaa+e6EiIyfcPDw7ztbW/jlltumdb0hx56KJ/97Gf3a/rib37zG173utft1byrVq3iIx/5CKeeeuqM5/3Sl77ERz/60T0ewAF4nsc73/lOXv3qV+9NNReEdmtb27Zt4w1veAMPPvjgjOfN5/O85z3v4cILL5z2PAph2L8WevuqKpfLvOtd7+KHP/zhtKbv6+vj2muv5bTTTpvxuhaKdmtbVddffz2//OUvuffeeykUClNOqxCG9rTQ21aVtZaPfexj/Ou//uu0ps/lcnz4wx/m2c9+9j6td75r1/ZV9cADD3DFFVfw5JNPTmv6c845h0984hN0dnZOa3rtu3avnY8VtmzZwhVXXMG99947renXr1/PZz/72b0Kr9Jnvdm3kNuWQhj2v3ZsX9/97nf54Q9/yJ/+9CdGRkamnHa2Ps9r3yUiIiIiItI+2vGzatWB/J5NZD5rx9e5QhhEZs/tt9/OF7/4Re666649XhBqrr7H13u6yOxpt7AVvaeL7Lv3ve99fPvb357ywmi7c+GFF/Ke97yHfD6/H2o20f4+T0pkPjsYXusKYRDZd+edd95ugwen4vs+f/EXf8GVV1653wOM2v28bBE5uDlzXQERmb5iscill1464aDA931Wr17NUUcdNSGJaePGjVxyySU8/vjjB7KqAPT29rJu3TpOOukkjj76aLq7uydM8+STT/L617+em2++eUbL/uIXv8g111wz4cT2JUuWsH79epYsWdJUHoYhH/jAB/jyl7888z9kAWjHtjU0NLTbDvK5XI7DDz+cE088kSOOOALXdZseHx0d5aqrruILX/jCfqmbzIzaVyKOY972trdNOAnEdV1WrVrFscceO+FL2f7+fi677DLuvPPOGa1roWjHtlX1ox/9iNtvv32PneSlPalt1X3gAx+YEMBgjGHFihWsX7+e3t7epsfGx8f5q7/6K2688cYDUr+DUTu3L4ANGzbwmte8ZsIPi7lcjqOPPprVq1dPuELLzTffzGWXXUapVNrv9ZvP2vlYYdeuXVxyySUTTiLLZDKsW7eOtWvXkk6nmx675557uOSSS+jv75/RuvRZb/apbcn+1K7t66abbuK3v/3tHgMYZov2XSIiIiIiIu2jXT+rgr4LEZkt7fw6F5HZ8cc//pEbb7xxjwEMc0Xv6SL77vbbb+fKK6/k3HPP5bzzzuPKK6/k+uuv5/e//31TAIOIHJzuuuuuSTtlu67L8uXLWb9+PUcfffSkQQY/+MEPeN3rXndA9gU6T0pk3xwsr3URmX3pdJrVq1dzwgknsH79elauXDkhaCEIAj71qU/x7ne/e7/Wpd3PyxaRg5831xUQken70Ic+xN13310bdxyHN77xjbz2ta+tBRyUy2V+9KMf8eEPf5ihoSEg+SHxbW97G9/5zncmdCaeLcYYTjzxRM4++2xOPfVU1q9fT09Pz4TpHnroIb75zW/y9a9/nSiKACiVSrzjHe/gJz/5CX19fXtc1x133MHHPvaxprLTTz+dd77znaxfv75W9sc//pGPfvSjTYm0H/nIRzjppJM48cQT9/IvnZ/auW1VHXXUUbzoRS/izDPP5Nhjj8Vx6jlCo6Oj/N//+3+59tprGRwcrJV/7GMfY+3atTzjGc+Y8fquuuoqjjnmmGlPv3Tp0hmvY6FQ+0p84Qtf4Kabbmoqu/jii7niiitqKfdxHHPTTTdxzTXXsHnzZgAKhQJve9vb+NGPfqTk3BYHQ9tq5TgOqVSKYrG4X5Z/6aWXcs4550x7+q6urv1Sj4Od2lbixz/+MV/96lebyp797Gfz9re/ndWrV9fKfvvb3/KhD32IBx54AIAoirjqqqs49thjWbVq1azVZ75o5/YVhiFvfetbGRgYqJX19PRw9dVX8/znP7/2o+Lg4CBf/OIX+fznP08cxwDceeedfOxjH+Pv/u7vZrxe7bsS7Xys8M53vpMnnniiNp5Op3nHO97By1/+crLZLJCEsHzrW9/i4x//eO2H5scee4x3vetdfO5zn5vWevRZb/9Q22r2ohe9iAsvvHDa07eeJCnN2rl97U4ul2N8fHzWlqd9l4iIiIiISHtp58+qc/FdiMh81M6v80Zf/OIXZzT9kUceuZ9qIjK/zPZ3vHtD7+ki+64atiIi819XVxcveMELOP/88znllFOarnofRRG33XYb1157Lbfddlut/O677+bqq6/m2muv3W/1mqvzpETmq3Z9rTdavHjxhPM79mQm/UlE5rOlS5dy/vnnc+qpp/LUpz6VVatWNfW5geRCqT/72c/49Kc/zdatW2vl3/3udznllFN4yUtesl/q1s7nZYvI/GCstXauKyEie/bII49wwQUX1IILAP7pn/6JF7zgBZNO/9BDD/GKV7yC4eHhWtk111yzXw5a+vv7CYKg9kPmdNxyyy38xV/8RVPy3Rve8Ab+5m/+Zo/zXnzxxU3J9M94xjO49tprSaVSE6Ytl8u8+c1v5le/+lWt7LTTTpvQoXAha9e29eCDD3LBBRdw/vnn86Y3vYmTTjppj/Ns2bKFV73qVU2JpIcddhg//vGPJySRtrruuuv41Kc+VRv/8pe/zBlnnLHX9ZeE2ldiYGCA//W//ldTWuc73vEOLr/88kmn37ZtG3/+53/Opk2bamV/+Zd/yVve8pY91nOhaNe2VfWiF72I+++/n5UrV3L88cdzwgkncOKJJ7J+/Xo+8IEP8P3vf7827ZVXXsmb3/zmvVrP9773Pa6++ura+Ic+9CEuuuiifa7/Qqa2lSiXyzznOc9p2g9dfPHF/MM//MOEpFKAkZERXvva1/KnP/2pVnbhhRfykY98ZK/WP1+1e/v65je/yXvf+97aeHd3N1//+td3e9LfD3/4Q/76r/+6Nu55HjfccENTSMdktO+aqJ2PFW6++WYuvfTS2rjv+3zxi1/ktNNOm3T6W2+9lde//vVNn/W+9KUv8bSnPW2P69JnvdmntgW///3vueSSS2rj+/L+KM3auX1dccUV3HTTTSxZsoTjjz+eE088kRNOOIETTjiBr3zlK02f/1/84hfz4Q9/eK/XpX2XiIiIiIhI+2jnz6oH8ns2kfmsnV/nr371q5sCOKsB5iIyc//+7//Ohz70ITo6Oli/fn3td/ETTjiBJ598sul7/5UrV/KLX/zigNVN7+kis6P6Op9Ma9jKgX6dt76n702wki7qJQvdRRddxODgIG9605u44IILyGQyU04fRRHve9/7+OY3v9lUvj/fMw/UeVIi89nB8Fp/5jOfWftO4EAfU4jMF/fffz9HH330pOePT2ZoaIjXve513HPPPbWyJUuW8N///d8Tghv2Vbufly0i88Ps7rlEZL+57rrrmg4KXvSiF+32oABg3bp1/O3f/m1T2ac//emmL/NnS19f34wCGADOPvtsXve61zWV/exnP9vjfL/+9a+bTmzv6enhmmuumfTEdoBUKsU111xDT09PrewPf/gDt9xyy4zqO5+1a9vq6+vjP/7jP/iXf/mXaXWQB1ixYgWf+tSnmg7Mn3jiiaYvxOXAUvtKfOELX2g6CeS0007jsssu2+30y5Yt44Mf/GBT2b//+783Je4udO3atqr+4R/+gd/85jf84he/4Nprr+Wyyy7jjDPOaEp2lfaktpX4zne+03Qy2urVq3nXu9612y/QOjs7+chHPtIUSvPDH/6QRx55ZFbrdbBr5/ZVLpf57Gc/21T2t3/7t1NedemCCy7ghS98YW08DEOuu+66Wa/bQtDOxwqf/OQnm8Yvu+yy3Z5EBsnV39/whjc0lX3iE5/Y43r0WW//UNuS/amd29df/uVf8qtf/Yqbb76Zz33uc1xxxRWce+65TfuM2aB9l4iIiIiISHtp58+q+i5EZHa08+tcRGbPM5/5TG644QZuu+02vvKVr/C3f/u3POc5z2HlypVzXTW9p4vMso6ODk4//XQuvfRSPvnJT/KLX/yCz33uc3NdrSZnnXXWjG4KYBCBt7zlLfz0pz/lZS972R47ZQO4rsvf//3fc/zxxzeVf/vb394v9dN5UiKzo91f6yIyO4455phpBzBAEmz0sY99rGmeHTt2cMcdd8x63dr5vGwRmT8UwiByEBgaGuLGG2+sjRtjpnXVxpe85CVNPzxs2rSJ3/zmN/uljnuj8YsIgI0bN1Iul6ec5zvf+U7T+Ctf+Ur6+vqmnGfRokW84hWvaCrTB7VEO7etxYsXc/LJJ894vmOPPZZzzz23qezmm2+erWrJDKh9JeI45nvf+15T2ZVXXrnHD6Jnnnkmp556am18bGyMn/zkJzOs8fzUzm2r6qlPfSqLFi3aL8uW/Udtq671mOvyyy8nnU5POc+RRx7J8573vNp4FEUT9n8LWbu3r5tvvpktW7bUxleuXDmtZNc3v/nNTe9pP/vZzxgZGZn1+s1n7Xys8MADD3D33XfXxnO5XNOVfXbnDW94A7lcrjZ+55137jGURZ/1Zp/aluxP7dy+ANavX8+KFStmfbmttO8SERERERFpH+38WVXfhYjMjnZ+nYvI7DrssMM48sgjZ/0KmftK7+kis6edw1ZEZN+df/75uw2u3x3XdScEF+2v8791npTI7Gj317qIzJ21a9eyfv36prLZ/hzc7udli8j80V7fUIrIpH71q18RhmFt/PTTT+fQQw/d43yO43DRRRc1ld10002zXr+9ddhhh00omyppvlwuT/iANZ0vPCab7r//+7/3GPiwEMzXttX44znA5s2b56gmC5vaV+KOO+6gv7+/Nn7ooYdyxhlnTGtdL33pS5vG22k7zKX52rZk7qltJbZu3co999xTG8/lcjz3uc+d1rzab+1eu7ev1mVedNFF00quPeyww5qu7BIEAb/+9a9nvX7zWTsfK7Qu7znPeQ75fH6P8+XzeZ7znOc0lf385z/f7fT6rLd/qG3J/tTO7etA0b5LRERERESkvbTzZ1V9FyIyO9r5dS4iC4Pe00VmT7uGrYjI3Go9P3dwcJBCoTDr69F5UiJz60C91kVkbrX2GZyqv+DeaPfzskVk/tA3FyIHgdYP5+ecc8605z3rrLOaxn/5y1/OSp1mQ6lUmlDW1dW12+l///vfMz4+Xhs/4ogjpp16u2rVKlavXl0bHxsb4w9/+MP0KztPzde21dqORkdH56gmC5vaV6J1O5x11lnT+rK2Om2j1v3gQjVf25bMPbWtxK9+9aum8ZNPPrnpqhxTOfnkk8lms7XxRx99lMcee2wWa3fwavf2tS/1O/vss5vGD+b2Pxfa+VjhQLVbfdbbP9S2ZH9q5/Z1oGjfJSIiIiIi0l7a+bOqvgsRmR3t/DoXkYVB7+kiIiL7V3d394SykZGRWV+PzpMSmVsH6rUuInOrtc9gZ2fnrC5fn9FF5EBRCIPIQeC+++5rGn/qU5867XmPP/54UqlUbXz79u1NqfBz6a677moaX7NmTVOnvVb7sh0g6RQ41fIWovnatrZt29Y03tPTMzcVWeDUvhKt26F1XzSVZcuWNXXiCYKAhx9+eNrzz1fztW3J3FPbSuzLdvA8jxNOOGHK5S1U7dy+du7cyY4dO2rjqVSK4447btrzt7633X///bNWt4WgXY8VrLU88MADTWUzabetf8cDDzyAtXbSafVZb/9Q25L9qV3b14GkfZeIiIiIiEh7adfPqvouRGT2tOvrXEQWBr2ni4iI7H+t5+fC7J8DrvOkRObegXiti8jcstbyxz/+sans+OOPn9V1tPN52SIyvyiEQaTNBUHAE0880VS2du3aac+fSqU47LDDmsoeeeSRWanbvojjmM9//vNNZS9+8YunnGfDhg1N40ceeeSM1tm63dphO8yl+dq2AG677bam8carS85EuVzmkUce4bbbbuOuu+7i8ccfp1AozEIN5z+1r7rWfddMtgNM3Ne1Lm+hmc9ta7ZEUcRjjz3GHXfcwZ133smjjz7K6OjoXFer7alt1e3rMVfr9AfrdphN7d6+Wpd1+OGHN325uCetz/njjz9OGIYzqsNC3ne167HCpk2bmo59c7kchxxyyLTnX7lyZVPI3vj4OFu2bJl0Wn3W2z/UtnbPWsvGjRv5f//v/3H77bfzyCOPMDQ0NKNlLHTt2r4OJO27RERERERE2ku7flZth+9CROaLdn2dT2VkZIT777+fP/zhD9xzzz1s2rSJKIr2+3pFZPbpPV1ERGT/az0/d+XKlTM6h2k62uE8KZGF7kC81qfS39/Pfffdxx/+8Afuu+8+tmzZooA0kVn2ne98h+3bt9fG16xZw4knnjhry2/387JFZH7x5roCIjK1jRs3Nn0wz2Qy9PX1zWgZy5cvb0pvf/TRRznttNNmrY4zNTw8zN///d9z66231srWrFnDJZdcMuV8jz76aNP4ihUrZrTe1ulbl7fQzMe2BfDEE0/whz/8oans6U9/+oyX8/73v5+NGzdSKpWayj3PY/369Zx33nm84hWvmPE2WyjUvhLFYpHNmzc3lc1037V8+fKmce275mfbmi3/8i//wgc+8AHGxsaayh3H4aijjuKss87iVa96VdNVXiShtlWnY67Z1+7tq/U5an3v2ZO+vj7S6XTtuCkIAp588slpB2Et5H1XOx8r7Gu7qM7TuJxHH3100pPRtN+ZfWpbu/f973+fr371qwwODk54bM2aNTztaU/jFa94BevWrZtxvRaKdm5fB5L2XSIiIiIiIu2jnT+rzvV3ISLzRTu/znfnwgsv5IEHHiCO46byXC7HySefzLOf/WwuvPDCA9rRRET2nt7TRRa2kZERNm3axMjICLlcjp6eHpYvX47runNdNZF55bvf/W7T+HnnnTfr65jr86RE5MC81ieza9cunve8503a0bqnp4dTTjmFF7zgBTz72c/We7zIPvj+97/P+973vtq44zi8973vxRgza+to9/OyRWR+UQiDSJvr7+9vGl+2bNmMl9E6z65du/apTtNx6623Nh3QFAoFduzYwV133cWNN97IyMhI7bHVq1fzhS98gUwmM+UyW+s9023ROn3rtl1oDta2tSf/9E//1JREeOSRR3LCCSfMeDmNB9ONwjDkrrvu4q677uL666/n9a9/PVdeeaU+aLdQ+0oMDAw0Te/7PosWLZrROttxO8yl+dq2Zstjjz02aXkcx9x///3cf//9fPnLX+alL30pV1999R7fexcSta261m0x0x+ali5dOuXyFqJ2b1+ty9qbE4aWLl3Kxo0bm5Y53R8XF/K+q52PFWajXSxbtqzpx+vd1U2f9Waf2tbubdq0abePbdiwgQ0bNvAf//EfPOtZz+L9738/PT09M67ffNfO7etA0r5LRERERESkfbTzZ9W5/i5EZL5o59f57tx3332Tlo+Pj3PzzTdz8803c+211/Lud7+b5z73ufu1LiKy7/SeLrJwKVhJ5MD49a9/PeEiaRdddNGsr2euz5MSWegO1Gt9MsVicbdXuh8cHOSmm27ipptu4rDDDuODH/wgp59++gGpl8jB5tFHH2XLli218SAIGB4e5qGHHuKmm25q6ovl+z7/+I//yJlnnjmrdWj387JFZH5RCINIm2u9Gmw2m53xMnK5XNP4+Pj4PtVpOq644oqmoIXJdHZ28opXvIK/+Iu/oKOjY4/LbK1369+1J63b7kBsh3Z2sLatqfz4xz/mpz/9aVPZX/3VX81qYlqjYrHIZz7zGW677TY+97nPTasdLxRqX4nWOmcymRm3x3bbDnNtPratAy0MQ77xjW9wxx138K//+q8TOswvVGpbiWKxSBRFTWUz3RbzYTvMtnZvX63L2pv67e9j7fm672rnY4UD2S70WW/2qW3tG2stP/vZz/jjH//I9ddfz5FHHjmryz/YtXP7OpC07xIREREREWkf7fxZ9WD4LkTkYNDOr/N9sWPHDt72trdx9913c9VVV811dURkCnpPF1m4FKwksv8NDg7y3ve+t6nsz/7szzjxxBNnfV16TxeZOwfytb4vnnjiCV772tdy1VVX8ZrXvGauqyPSdr7+9a/z5S9/ecppjDGce+65vOMd7+CYY46Z9Tq0+3nZIjK/KIRBpM21vomn0+kZL6N1nnY4MMjn87zhDW/goosumnbH9dZ6zzQ1tvWKua0HXQvNfGtbGzZs4D3veU9T2bOe9Sz+7M/+bNrLMMZw0kkncf7553PiiSeydu1auru7cRyHgYEB7r33Xn75y1/ygx/8gFKpVJvv1ltv5e1vfzuf+cxncF131v6mg5naV6J1P3Owb4d2MN/a1mw59thjOf/883nqU5/KkUceSW9vL77vMzQ0xIMPPsj//M//8O1vf7spIOnBBx/kjW98I1/96ldn3GFsPlLbSkxW55lui/mwHWZbu7ev2ahf67H2dOqnfVd7HyscyHahz3qzT21rotWrV/OMZzyD0047jXXr1tHX10cmk2F4eJhHH32U3/zmN3zzm99kx44dtXk2b97M5Zdfzre+9S0WL14843rOV+3cvg4k7btERERERETaRzt/Vp2r70JE5pt2fp23ruOss87ivPPO49hjj+Xwww+ns7OTcrlMf38/d955JzfccAO//vWvsdbW5vu3f/s3ent7ufzyy2e9TiIyO/SeLiJTUbCSyN6L45i/+Zu/YevWrbWyzs5O/u7v/m6/rE/v6SJz40C/1hvl83nOPfdczjnnHI455hhWrVpFPp+nWCyybds27rzzTr73ve9x++231+aJoogPfehDLF68mOc///n7vY4i881znvMcXv3qV++XAAZo//OyRWR+UQiDSJtr7OgN4Pv+jJfRehJ4sVjcpzrNhtHRUf75n/+ZT3/607zmNa/hLW95yx5PVm/dFjM9ub11+tblLTTzqW0NDg7ypje9idHR0VrZ8uXLef/73z/tZZx99tm84AUv4Igjjpj08WXLlrFs2TKe8YxncMUVV/BXf/VX3HHHHbXHf/WrX/H1r3+dV7/61Xv/h8wjal+JcrncNH4wb4d2MZ/a1mw47rjj+N73vsf69esnfXzx4sUsXryYs846ize+8Y28613v4uc//3nt8XvuuYdrr72Wd77znQeqym1LbSsx2fHRTLfFfNgOs63d29eBrp/2XXXtfKxwINuFPuvNPrWtupUrV/LlL3+ZM844Y9LH+/r66Ovr45RTTuHyyy/ngx/8IN/85jdrj2/atIn3ve99XHfddTOu53zVzu3rQNK+S0REREREpH2082fVdv9+WORg0c6v86rXvva1nHzyyfT29k54zPd9Ojo6OPTQQ3nhC1/Ibbfdxtvf/na2bdtWm+bjH/8455133n47OV1E9o3e00UWFgUriRw4H/3oR/nv//7vprL3v//9rFixYr+sT+/pInPjQL/Wq/7mb/6G8847b9ILx+bzefL5PGvXruWlL30pN954I+9617sYHh4GwFrLu9/9bk4//XSWLFmyX+spMt/85Cc/4Sc/+Qmnnnoq11xzDYcffvisLl/v5/8/e/cdFsX1vg38pvcuNlCxF2wYS+wFTdQYWzSW2DWJGmvsGmONYqImtsSvxh67QewVib1hBwsKIgiKSO/9/cOX/bnsws7uzrK7cH+uy+tyzj5z5mE5O2WZ8wwRFScWYSBS4JdffsHOnTs1vp0JEyZg4sSJMu0FKytlZWUp3XfBP0SqUuFJWf7+/pL/5+XlITk5GW/fvsX9+/fh7e0tmbyemZmJzZs3IzAwEBs3biwyNzMzM6SlpUmWC/5cimjjfSgKx5Y40tPTMW7cOISGhkraLC0tsW7dOrl/2C5MkyZNBMeWL18e27dvx/Dhw3Hv3j1J+19//YV+/frBwsJCcF+awvElDnXHV8ELM319Hz7GsaVblLkBx87ODuvWrcPkyZNx9uxZSfuePXswcuRIlCtXThMpCsaxpRvk5ZyVlaXUz6KL7wPHV9GKO7+StO9Sly6fKxTnuChp13q6gGPr/7i6usLV1VVwbosXL4a5uTl27NghaT979iwePXqEBg0aKJ1rSaTL46s4cd9FRERERESkO3T5WlXXvx8m0he6/DnP5+npKTi2adOm2LVrFwYMGIC4uDgAH+6v+uOPP7Bx40ZR8yIicfCYTlR6sLASUfHZuXMntm3bJtU2ZswYdO/eXWPb5DGdqPhp47Oer1u3boJju3TpAmdnZwwfPlwyGTstLQ0bN27E/PnzNZUikd6ZN28e5s2bJ1lOT09HfHw8nj59inPnzuH48eOSz5C/vz/69euHrVu3inrvHY/nRFScDLWdABEVzdLSUmpZlafiFVynYJ+aZmBgABsbG9SsWRP9+/fH3r178dtvv0n9gfTatWvw8vIqsp+CeSt7c3vBqlTF/T7ompIwtrKzszFlyhRJUQ/gw5fc69atQ8OGDTW6bTMzM6xYsQLGxv9XzygmJgZXr17V6Hb1BcfXBwWrZurj+6BrSsLY0iZDQ0MsXboUtra2kraMjAycOnVKi1npBo6tD+TlrOx7URLeB7Hp+vgSIz9NnmuX5H2XLp8rFOe44LWe+Di21DNz5kyZ6ttHjx4VdRv6TJfHV3HivouIiIiIiEh36PK1qj58F0KkD3T5c66qKlWqYObMmVJtFy9eRHx8vHYSIqIi8ZhOVHp4enoKfgBYfmGlj+PzCysRUdGOHTuGZcuWSbX17dsX06dP1+h2eUwnKl7a+qyrqnHjxhgzZoxU2/Hjx5Gbm6uljIh0n7m5OcqXL48OHTrgl19+wdGjR1G3bl3J64mJifjhhx+QmJgo2jZ1/b5sIipZWISBSMcV/CPix0/YEyo1NVVqWRdODHr27IkVK1ZIte3duxchISGFrlMw74I/lyIF3ztdeB+0Sd/HVl5eHmbNmgU/Pz9Jm5GREVauXIk2bdoUSw5VqlRBp06dpNquXLlSLNvWdRxfHxTMOT09HXl5eUrloov7cG3S97GlC+zs7PDVV19JtbGADMdWPnNzcxgZGUm1KftelIT3QWy6Pr4K9qVKfpo+1y6p+y5dPlcoznHBaz3xcWypx9jYGEOHDpVqKwn7HLHo8vgqTtx3ERERERER6Q5dvlbVh+9CiPSBLn/O1dG7d284OjpKlnNzc3Ht2jUtZkREheExnYgKw8JKRMrz8/PD7Nmzpc7pP/vsMyxduhQGBgYa3TaP6UTFR5ufdXUMGzZM6j7a+Ph4BAQEaDEjIv1SpUoVbN26FRUqVJC0RUVFYcuWLaJtQ9fvyyaiksVYcQhR6dahQwfBFU3V0axZM7ntH/+hDfhw4qGsgus4OTkp3YcmdO/eHXv27MHt27cBfJj0fOTIEUydOlVuvJOTE8LDwyXLyr4XuvY+cGypZ+HChTh+/Lhk2cDAAIsXL0bXrl2LLQcA+PTTT3H27FnJ8suXL4t1+4Xh+FKPWOPLwcEBBgYGki+PsrKyEBMTgzJlygjug/suafo+tnRFy5YtsW3bNsmyLuy7OLZ0h6OjI6KjoyXLb9++Rbly5QSv/+7dO6llXXgfOL6KVrCvt2/fKt1HcfzedXHfpS5dPlcQY1wIza2kXevpAo4t9bVs2VJq+dWrV8jLy9PpPwIXF10eX8WJ+y4iIiIiIiLdocvXqvryXQiRrtPlz7k6DA0N0bx5c5w+fVrSVhL+/kFUEvGYTkRF6d27N3777TfExsYC+L/CSt27d9dyZkS658aNG5g8eTKys7Mlba1bt8aqVatkHh6kCfpynxSRvtP2Z10ddnZ2qFevHh49eiRpCwkJQcOGDbWYFZF+cXR0xMSJEzF37lxJm7e3d6HzBVXp/2O6dl82EZUsLMJApEDr1q3RunVrrW2/UqVKMDY2llx8pKenIzY2VuaEoShv3ryRWq5WrZqoOaqjS5cukiIMAHD37t1CY6tWrYr79+9LliMjI5XaVsH4qlWrKrW+2Di2VPfrr79i3759Um2zZ89Gv379imX7H/u4OhsAyZfo2sbxpToxx5e5uTkqVqyIiIgISVtkZKRSN4Lo2j6cY6tkKF++vNSyLuy7OLZ0R9WqVaWKMERGRqJRo0aC19e1cy6A40uRgr+jgttSJCYmBhkZGZJlExMTVKpUSZTcPqaL+y516fK5QsFxocofnQuuU1huJe1aTxdwbKmv4D4nOzsbCQkJsLe3F31b+kaXx1dx4r6LiIiIiIhId+jytaq+fBdCpOt0+XOuroL3ncTFxWkpEyIqCo/pRFQUFlYiEubBgwcYN26c1H1GHh4eWL9+PUxNTYslB325T4pIn+nCZ11dFSpUkCrCwGt1IuV16dIF8+bNkxRVfffuHSIiIuDi4qJ237p+XzYRlSyG2k6AiIom78L8xYsXgtfPzMyUeiofoFsnBpUrV5Zafv/+faGxBfMODg5WalshISFF9lfa6OvY2rBhA7Zs2SLVNnHiRIwYMULj25bH2Fi6ntHH1RpLM46v/1PwC1tl910F47nv0s+xpWu475LFsfV/uN8Sn66Pr4J9hYWFITMzU/D6BX/nlStXltnPiKGk7rt09TPn4uICc3NzyXJqaqrUza2KREREIC0tTbJsaWkpcyNpPl7raQbHlnpMTExk2krKfkcMujq+ihP3XURERERERLpFV69V9eW7ECJ9oKufc3UV/PtHVlaWljIhoqLwmE5EirCwElHRnj59im+//RapqamStnr16mHz5s2wtLQstjz05T4pIn2lK591dfFanUh9tra2sLOzk2oras6gMnT9vmwiKllYhIFID9StW1dq+d69e4LXDQgIkPpiwNnZGU5OTqLlJraivoSoU6eO1PLdu3eV6rtgfMH3tTTSt7G1fft2rF27Vqpt1KhRmDBhgka3W5SCFwHKVE4r6Ti+PlDnfciv9pfPxMQE1atXVyufkkDfxpYu4r5LPo6tD9R5H7Kzs6Wq/8rrr7TS5fHl7OwMZ2dnyXJmZiYCAwMFr19c59kldd+lq+cKBgYGqF27tsq5FRwXtWvXhoGBgdxYXutpBseWeqKjo6WWDQwMYG9vL/p29JWujq/ixH0XERERERGRbtHVa1V9+S6ESB/o6udcXSX17x9EJQ2P6USkCCdrEhUuJCQEo0aNQkJCgqStevXq2LJlC2xsbIo1F325T4pIH+nSZ11dvFYn0gwxCxfp8n3ZRFSysAgDkR7o0KGD1PLVq1cFr3vt2jWp5U6dOomRkmgiIyOllsuUKVNobIsWLaSq34WGhgquJv369WuEhoZKlq2srNC8eXPlki2B9GlsHTx4EF5eXlJtAwYMwKxZszS6XUXu3LkjtVy+fHktZaJ7OL4+KPg+XLt2DXl5eYLWLfietWjRAlZWVmrnpO/0aWzpKu675OPY+qDg+3D37l2pqsRFuXv3rtTTO9zc3GSeSlRa6fr4at++vdSyMvkVjO3YsaMoORVUUvddunyuIOa4LWpc8FpPMzi21FNwn+Ps7MynV3xEl8dXceG+i4iIiIiISLfo8rWqPnwXQqQPdPlzro6C30UWfIo2EekOHtOJqCicrEkkX0REBEaOHImYmBhJm6urK7Zt26a1z4k+3CdFpG908bOuqszMTJmHkfFanUh5ycnJUkVZgKLnDCpL1+/LJqKSg0UYiPRA+/btpW70v3XrFsLDwxWul5eXB29vb6k2T09P0fNTx4ULF6SWC1aL/piZmRlat24t1fbvv/8K2k7BuLZt28LU1FRgliWXvoytEydO4Oeff5b64/mXX36JhQsXamybQiQmJuLs2bNSbS1bttRSNrqH4+uDJk2awMHBQbIcHh6OmzdvClr30KFDUsu8uPtAX8aWrsrOzoaPj49UG/ddH3BsfVChQgXUq1dPspyamopTp04JWrfgfkuf3wex6fr4KniM8fb2FnTjYlhYGG7fvi1ZNjExkflDpRhK8r5Ll88VCvZ3+vRppKSkKFwvOTkZp0+flmoratzyWk8zOLbUU/A9KCn7HLHo8vgqLtx3ERERERER6RZdvlbVh+9CiPSBLn/OVXXr1i2EhYVJtfG7SCLdxWM6ERWFhZWIZL179w4jRozA27dvJW3lypXD9u3bUa5cOa3lpev3SRHpG139rKvqxIkTUg8jMzU1RZMmTbSYEZF+unjxotTx1dHREc7OzqL1r+v3ZRNRycEiDER6wN7eXuqAnpeXh3Xr1ilc79ChQ1JP4HNxcdGpP9Rdv34dV65ckWpTdOLSr18/qeXdu3cjNja2yHViYmKwZ8+eIvsprfRhbPn5+WHWrFnIzc2VtHXu3BleXl4wNNTuYWzFihVITEyULJuYmKBdu3ZazEi3cHx9YGhoiD59+ki1bdiwQeEXttevX4e/v79k2crKCt26dRMlJ32nD2NLl23atAmvXr2SauMXBx9wbP2fgudKmzZtQkZGRpHrBAcH4+TJk5JlQ0ND9O3bVyP56SNdH19t27ZF+fLlJcsRERGCJpKuW7dO6pj22WefwcbGRvT8SvK+S5fPFerUqYMGDRpIllNTU/H3338rXO/vv/9GamqqZLlx48aoUaNGkevwWk98HFuqO3LkCG7duiXV1rlzZ9G3o890eXwVJ+67iIiIiIiIdIcuX6vq+nchRPpClz/nqkhNTcXSpUul2mrVqoVKlSppKSMiUoTHdCIqDAsrEcmKj4/HqFGjpD4bjo6O2LZtm9bPeXX9PikifaLLn3VVREdH4/fff5dqa926NSwsLLSUEZF+Sk9Px9q1a6XaOnToIOocMF2/L5uISg4WYSDSE5MmTZI62Thy5AiOHz9eaPyLFy/w66+/SrWNGzdO4VP1Xr9+jdq1a0v9e/36daHxISEhWL16NeLj44X9IP/f7du3MWnSJKm2Ro0aoWnTpkWu16FDBzRu3FiyHB8fj7lz5yIrK0tufGZmJubNmyeVX9OmTdG2bVul8i3JdHVsAcDNmzcxefJkqd9vmzZt8Pvvv0tVLFPXpk2bEBAQIDg+OzsbXl5eMk9KGDhwIMqWLStaXiUBx9cH3377LSwtLSXLt27dwubNmwuNj4qKwrx586Tahg0bBkdHR1Hz0me6PLaKy549e3D9+nWl1tm2bZvMFxqdOnVC/fr1xUxNr3FsfdC/f39UrFhRshwaGoply5YVehNbcnIyZs6cKbVP7dGjB28cKUCXx5epqSnGjh0r1fbrr7/ixYsXha5z7NgxHD16VLJsZGSEiRMnFrkd7rvkK65zhYLjQsgTwgpet23evFmqqn9Bt27dkrnZbMqUKQq3w2s9zSjtY+vEiRM4e/asoCdW5Dt+/Dh++uknqba6deuiS5cugvsoLXR5fBUX7ruIiIiIiIh0iy5fqxbX92xEJZ2ufs6XLl2KqKgoAT/BB7GxsRg3bhyePXsm1V5wX0FEmsVjOhGJgYWViGQlJydjzJgxeP78uaTN1tYWW7duRfXq1UXdli7fJ0VU0unyZ/3du3dYu3YtEhISlNrGmDFjpK7vDQwM+FmnUu3XX3/Fw4cPlVonPj4e48aNQ2hoqKTNyMgII0aMKHK9Tp06SX3Gvb29FW6ruO7LJqLSTdwZhkSkMTVq1ED//v2xf/9+SduMGTMQHByMESNGwM7ODgCQlZWFY8eOwcvLC4mJiZLY2rVry1SDF0NGRgb+97//YefOnejYsSM+//xzNGrUCBUqVJCJTU9Px927d/Hvv//ixIkTUpMgTE1N8fPPP8PAwEDhNmfMmIGhQ4dKnlzv5+eHUaNGYfbs2XB3d5fEBQQEYMWKFVJPrzQyMsKMGTPU+ZFLHF0dW0FBQRg3bpzUU7ednZ0xePBgqScUCGFmZoZPPvmk0NcvX76MVatWwcPDA926dUPLli1RrVo1mYn4SUlJuHjxIv7++288efJE6rXKlSvjhx9+UCqv0oDj6wNHR0eMHTsWq1evlrStWrUKkZGRGDduHMqVKwcAyM3NxYULF/DLL78gMjJSElu2bFmMGjVKqbxKOl0dW/kSEhIQGBgo97Xo6Gip5fDwcFy7dk1urLu7u+RnKejhw4dYtGgR6tSpg27duqFt27aoWbOmzJcAaWlpuH79OrZu3Srzh397e3vMmTNH6I9VKnBsfWBqaopp06Zh2rRpkrZ9+/YhLi4OP/74I9zc3CTt169fx/Lly6VuErO0tORNYnLo+vjq168fdu/eLfmjSEJCAr755hvMmTMHPXr0kJwbxcfHY/v27fjf//4ntf6AAQNQtWrVIrfBfZd8unyu0K5dO7Rp0wZXrlwB8GF8jh49GtOmTcPXX38tqfKdmpqKAwcOYPXq1VKTj9u3by+4SjCv9cRX2sdWSEgI1q9fjypVqqBbt27o0KEDateuLXWTNvBhYvydO3ewc+dOXLhwQeo1MzMzLFy4UND3FaWNLo+vjIwM3LlzR+5r4eHhUsvR0dGFnjPVqFFDYbFF7ruIiIiIiIh0hy5fqxbn92xEJZmufs537dqF/fv3o127dvj888/RpEkTuLq6ysS9efMGJ06cwPbt22X+tte5c2cWgyX6yJ07d6Tu68n39OlTqeWMjIxCv+MtW7as6A8O4DGdSL/Url1bannnzp1o0aJFofFLly7Ft99+KzmnUCQ2NhZTp05lYSWiAsaNG4dHjx5JtY0YMQJxcXGFHrcLo+g+N1UVx31SRCWdLn/WMzMzsWHDBmzbtg2dOnWSzHOSd4x/9eoVvL29sXv3biQlJUm9NmzYMKl7P4hKm6tXr2LLli1o2LAhunfvjk8//RQ1atSAiYmJVFxeXh5CQkJw+vRp7Nq1C3FxcVKvDx8+XObcXAy6fl82EZUMBnnKPAqOiLQqLS0NQ4YMQUBAgFS7iYkJXF1dYWpqivDwcKSmpkq97uDggL179wq60H/9+jU8PT2l2nx9feX+YRAAnjx5gt69e8u029nZwdHRETY2NsjJyUFiYiIiIyORk5MjE2tqaor169ejffv2CvPLt3nzZqxcuVKmvWzZsnB2dsa7d+9k/lgJALNnz8bIkSMFb6e00MWx5e3tLdrkOhcXF5mJNB8bOnSo1CQI4MO4LF++PGxsbGBoaIj4+HhERERIJlV8zNnZGf/884/UhFT6P6V9fOXLzc3F+PHj4efnJ9VuZGSEihUrwsbGBq9fv5a6qAMAc3NzbN26VWGhh9JIF8dWvps3b2LYsGECf5LCFfWHv9mzZ+Pw4cNSbcbGxpJ9l4mJCRITExERESH3SbxWVlbYsmULPDw81M6zpCntY+tjCxcuxN69e6XaDAwMUKFCBTg4OCAyMlLmizJDQ0P8/vvv6Nq1q9p5lkS6PL4AIDg4GIMHD5Z6QjfwobBG5cqVkZ6eLne/0rBhQ+zatQvm5uZF9s99V+GK41xB2RtM8r1//x4DBgyQqR5ubm6OSpUqIS8vD+Hh4TI3wlWuXBn79+9X+ESxj/FaT3yleWytW7cO69evl2ozNDSU7HPMzc2RlJSEiIgIuTdympiYYPXq1fjss88U/iylla6OL3nHQlUsX74cffv2VRjHfRcREREREZHu0NVrVaB4v2cjKsl08XMu7yZya2trODs7w8bGBtnZ2Xj//j3evXsnd/2mTZtiy5YtCv/OQlSadOrUCREREWr10adPH3h5eRX6Oo/pRNpVVLGVFStWSJbLlCmD3377TW4fioqtqHJMNzU1Vbuw0oYNGwrdBlFpIOYkS0WfW12+T4qopNPlz3ph943Y29vDyckJ1tbWSE9PR3R0NGJjY+X20bVrV/z+++8wNDRU4ichKll69eolUwzRxMQE5cqVg62tLUxMTJCSkoI3b94gJSVFbh99+vTBsmXLFH6WCn4PIPS+reK4L5uISjdjxSFEpCssLCywZcsWTJ48GTdu3JC0Z2Vl4eXLl3LXcXFxwV9//VXsJwUJCQlISEhQGFe/fn0sXboUdevWVar/b7/9FkZGRli5cqVUYYd3797J/YOlkZERZs6ciREjRii1ndJCn8ZWccnMzERYWJjCuPbt22P58uVwcnIqhqz0E8fXB4aGhlizZg3mzJmDEydOSNpzcnJknsSaz97eHmvXrmUBhkJwbMnKzs6W+SO/PI0aNcLKlStRuXLlYshK/3Bs/Z+ff/4ZZmZm2L59u6QtLy8PkZGRUk8NymdhYYFly5axAEMRdH18Va9eHTt27MD48eOlvsxMTU2V+SI1X6tWrbBmzRqV/7DIfdcHunyuUKZMGezcuRPjx4+XGgfp6emSJwIUVLduXfz1119K30TGaz3xcWxJy83NlXsMK8jNzQ2rVq1C/fr1VdpOaaHL46s4cd9FRERERESkO3T5WlUb34UQlUS6/Dn/WHJyMpKTk4uMMTQ0xKhRozBlyhSZJwgSke7iMZ1IHDNmzBBUbOX9+/eFFrVWVGxFFZmZmTh//jzOnz8PQPnCSqtWrRI1HyLSHG3cJ0VE2hUfHy9TeKUgU1NT/PjjjxgxYgQMDAyKJzEiPZKVlSXonl9ra2tMmzYNgwYN0uhnSdfvyyYi/cdyTER6xt7eHtu2bcOSJUtQpUqVIuPGjh2LY8eOiVphrqAaNWrg77//xtChQ1G7dm0YGRkpXMfc3Byenp7YsGEDDhw4oHQBhnyjRo3Cv//+iw4dOhRaEcvQ0BAdO3aEt7c3b2xXQNfGVnEaO3YsBg4ciJo1awoaw5aWlujatSv++ecfbNq0iQUYBCjN4+tjZmZmWL16NdauXVvkvs/S0hKDBw/GyZMnBVXYL81K89gaNGgQhg8fDnd3d0E35JiZmaFt27bYuHEj9u/fX2InMYulNI+tjxkaGmLOnDnYsWMHmjZtWmiciYkJvvzySxw7dgzdu3cvxgz1k66Przp16uDo0aP4/vvvYWdnV2icm5sbli5diq1bt8LW1lZQ39x3FU2XzxVcXFxw8OBBTJ8+HWXLli00rmzZspgxYwYOHDiAChUqqLQtXuuJr7SOrW7duuH777+Hh4eHoBsgjI2NJTdGHT9+nAUYBNLl8VWcuO8iIiIiIiLSHbp8rVqc37MRlWS69jlfsmQJvvjiC8GfV2dnZwwbNgynT5/GjBkzWICBSA/xmE5UeiQnJ+Ply5d4+PAhHj9+LLcAg6GhIcaMGYPt27dzYjaRntHkfVJEpD1lypTBvHnz0LlzZ5QpU0bQOi4uLhg3bhzOnz+PkSNHsgADEYDVq1dj+vTpaNWqFaytrRXGGxgYoHbt2pg5cybOnTuHwYMHF8tnSdfvyyYi/WaQl5eXp+0kiEh1z549w+PHjxEdHY2cnBzY29ujZs2aaNSokVb+QJeamooXL14gPDwcMTExSE1NhaGhIaytrWFnZ4caNWqgRo0agia6KyM2NhZ3795FeHg4UlNTYWlpiUqVKqFJkyasHq0iXRtbxSUtLQ0vXrxAREQEoqOjkZqaitzcXNja2sLW1hY1atRArVq1RB/DpU1pHV8FvXr1Cg8ePEBUVBSysrJga2uL6tWro0mTJjAzM9N2enqptI6tzMxMhISE4PXr14iKikJKSgqys7NhbW0NW1tbVK1aFXXr1oWpqam2U9VbpXVsFfT27VvcvXsXb968QUZGBqysrODm5oZPPvlE0JdrJJ8uj6+srCw8ePAAz58/R3x8PIyMjODs7Ix69eqp/QUk912K6eq5Qm5uLgICAvDs2TPExMQAAJycnFCnTh24u7sXOvlYFbzW04zSOLZycnLw8uVLhIeH4+3bt0hOTkZWVhYsLS1hZ2cHV1dXNGjQgDdFiUBXx1dx4r6LiIiIiIhIt+jqtWpxfs9GVNLp0uc8Li4OwcHBiIyMRGxsLNLS0mBkZARbW1s4ODigXr16qFSpUrHmRESaxWM6kWo6deok9eR5VfTp0wdeXl6Fvl7wvoadO3cWWZjpwIEDuHHjhuTeGEWcnZ3RrVs3DBkypMjJXkSkHzR5nxQRade7d+/w8uVLvHnzBnFxcUhLS4OJiQns7Ozg6OiIBg0aoFy5ctpOk0in5ebmIjQ0FGFhYYiMjERycjKys7NhZWUFGxsbuLi4wN3dXSfuJ9fl+7KJSP+wCAMRERERERERERERERERERERERERERERERFYWImIiIiIiIiIWISBiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiAgAYKjtBIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIdAGLMBARERERERERERERERERERERERERERERERERERERERERgUUYiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgAsAgDEREREREREREREREREREREREREREREREREREREREREREAFmEgIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgLAIgxERERERERERERERERERERERERERERERERERERERERERABYhIGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICACLMBARERERERERERERERERERERERERERERERERERERERERAWARBiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiACzCQEREREREREREREREREREREREREREREREREREREREREQEgEUYiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgAsAgDEREREREREREREREREREREREREREREREREREREREREREAFmEgIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgLAIgxERERERERERERERERERERERERERERERERERERERERERABYhIGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICACLMBARERERERERERERERERERERERERERERERERERERERERAWARBiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiACzCQEREREREREREREREREREREREREREREREREREREREREQEgEUYiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgAsAgDEREREREREREREREREREREREREREREREREREREREREREAFmEgIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgLAIgxERERERERERERERERERERERERERERERERERERERERERABYhIGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICACLMBARERERERERERERERERERERERERERERERERERERERERAWARBiIiIiIiIr1Uu3ZtqX/r1q0r9hxu3rwpk8fNmzeLPQ8Cpk2bJvV7uHjxorZT0rjdu3dL/cy///67tlMiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIqISgEUYiIiIiIiIiPTYrVu3cPz4cclyy5Yt0b59ey1mVDy+/vprVKlSRbK8detWhIWFaTEjIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIqCYy1nQAREREREclau3YtNmzYINXWuHFj7NmzB0ZGRir3m5eXh9GjR+Pq1atS7UOHDsVPP/2kcr+K1K5dW3CsiYkJbGxsYGNjA1dXV7i7u8PDwwNt27aFiYmJxnIk0kfZ2dlYvHixZNnAwAAzZszQYkbFx8TEBFOmTMHUqVMBAJmZmVi2bBk2btyo5cyIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiEifGWo7ASIiIiIikjVu3DjUrVtXqu3+/fvYsmWLWv3u2bNHpgCDm5sbpk+frla/YsrKykJsbCxevXqFq1evYtOmTRg3bhzat2+P33//HWlpadpOUW+9fv0atWvXlvrn7e2t7bRIDf/++y+eP38uWe7YsSPc3d21mFHx6tatG6pXry5Z9vPzw61bt7SYERERERERERERERERERERERERERERERER6TsWYSAiIiIi0kEmJibw8vKCiYmJVPu6deukJlwrIywsDCtXrpRqMzIywooVK2Bubq5yrsUlJiYGGzduRM+ePfHw4UNtp0OkdRkZGfjzzz+l2saOHaulbLTDwMAA3377rVTb6tWrtZQNERERERERERERERERERERERERERERERGVBCzCQERERESko+rUqYMJEyZItWVmZmLWrFnIzs5Wqq/c3FzMmjULqampUu2jRo1C48aN1U1VaSYmJqhTp47cf9WqVYODg0Oh64aFhWH06NF4+vRpMWZMpHv27t2Lt2/fSpZbtGiBRo0aaTEj7ejRowfKly8vWb537x4uXryoxYyIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiEifGWs7ASIiIiIiKty3334LX19fPHz4UNIWGBiIjRs3yhRoKMrWrVtx9+5dqbZatWph0qRJouWqjLJly+LIkSNFxrx9+xbnzp3Dtm3bEBERIfVaYmIixo8fj9OnT8PU1FSTqeqsZ8+eaTsFtGjRQifyKI2ysrKwbds2qbbBgwdrKRvtMjExQf/+/bFu3TpJ2+bNm9G+fXstZkVERERERERERERERERERERERERERERERPrKUNsJEBERERFR4YyMjODl5QUzMzOp9o0bN+LJkyeC+nj+/DnWrFkj1WZiYgIvLy+dLmBQvnx5DB06FEePHkWHDh1kXo+IiMDOnTuLPzEiHXDq1Cm8fftWslymTBl4enpqMSPt+uqrr2BkZCRZvn37NgICArSYERERERERERERERERERERERERERERERER6SsWYSAiIiIi0nHVq1fHlClTpNqysrIwc+ZMZGZmFrludnY2Zs2aJRM3duxYuLu7i52qRlhbW2PNmjWoVauWzGv79+/XQkZE2rdjxw6p5V69esHExERL2WhfhQoV0KpVK6k2FmkhIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJVsAgDEREREZEeGDFiBJo0aSLVFhQUhPXr1xe53l9//YXAwECpNnd3d4wdO1b0HDXJ3NwckyZNkmkPCwtDWFiYFjIi0p6goCAEBARItXXt2lVL2eiOgu/B2bNnkZycrKVsiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhIXxlrOwEiIiIiIlLM0NAQXl5e6NWrF9LS0iTtf//9Nzp37oyGDRvKrBMQEICNGzdKtZmammLFihUwNta/S4F27drBzMwMGRkZUu2BgYGoXLmy4H4iIyPx5MkTxMbGIi4uDqampnB0dETZsmXRuHFjmJubi5p3fHw8nj17hrCwMKSkpCA1NRUmJiawsLCAo6MjXF1d4ebmBltbW1G3q68yMzPx8OFDREVFISYmBmlpabC3t4eTkxNq1KgBNze3YsnjzZs3ePToESIjI5GWlgY7OzuUKVMGTZo0QZkyZYolh8IcPnxYatnFxUXuPkAsz549w9OnT/H+/XtkZmbC1tYWtWrVQqNGjWBqaiqoj+zsbAQGBiIoKAhxcXEwNDREmTJlUKdOHdSpU0eUPDt37owFCxYgOzsbAJCWloYzZ87gq6++EqV/IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIqHfRv5hURERERUSlVpUoVTJ8+HUuWLJG05eTkYNasWfDx8YGZmZmkPTMzE7NmzZJMRs43adIk1KxZs9hyFpOZmRkqV66M58+fS7XHxsYqXDcxMRFbt27FuXPn8OLFiyK30axZMwwcOBBdunRROdeMjAwcOHAAR44cwaNHjxTGGxgYoGrVqmjWrBk+//xztGjRQmGhjNq1a0stT5gwARMnTpSJ8/b2xpw5cwrtZ86cOUW+DgDNmzfHrl27ZNpv3ryJYcOGSbXt3LkTLVq0KLI/ea5du4Zdu3bhxo0bSE1NLTSuUqVK6Ny5M0aPHg1nZ2elt9OpUydERERIlvv06QMvLy/J8rlz5/D333/j/v37ctc3MDBAgwYNMGHCBLRv317p7Yvh1KlTUsuq5lHUGMrIyMCOHTuwZ88evHnzRu769vb2+Oabb/Ddd98VWrwkJiYGmzdvxuHDhxEfHy83xtXVFT/88AP69OkDAwMDlX6W/Hw8PDxw+/ZtSdvx48dZhIGIiIioBHr9+jU8PT0Fxfr6+sLV1VXDGVFJtm7dOqxfv15hXGHXzkREREREREREREREREREREREpH9YhIGIiIiISI988803OHv2LG7evClpCwkJwe+//47Zs2dL2n7//XeZYgMeHh4YNWpUseWqCdbW1jJtSUlJRa6za9curFu3DgkJCQr7z8jIwJUrV3DlyhV4eHhg0aJFMhPVFbl58ybmzp2L169fC14nLy8PISEhCAkJwf79+7F582a0a9dOqe3qq/DwcCxcuBBXrlwRHL9t2zbs378fY8aMwbhx42BoaKh2HklJSZgxYwb8/PyKjMvLy8PDhw/x3XffoU+fPli6dKnCghlievr0qUxRhObNm4u6jeDgYIwfPx6hoaFFxsXHx2PDhg04e/YsNm3ahIoVK0q97uvri7lz5xZafCHf69evMWfOHJw9exZr166Fqampyrm3aNFCqgjD7du3kZKSAisrK5X7JCIiIiIiIiIiIt2Wnp6O+/fvIyAgAI8ePUJYWBgSExORnJyM5ORkGBkZwdzcHObm5rCxsUG5cuVQrlw5lC9fHm5ubqhduzaqVaum1neTRERERERERERERERERFSysAgDEREREZEeMTAwwPLly/Hll18iJSVF0r5jxw507twZTZs2hb+/P7Zv3y61noWFBby8vGBkZFTMGYsrOTlZps3GxkZubE5ODhYtWoT9+/ertK179+5h8ODBWL9+PVq2bClonYsXL2LChAnIzMxUaZulTUBAAL7//nu8f/9e6XVTU1Oxdu1aPHv2DCtXrlTr5ti4uDgMGzYMQUFBSq13+PBhZGdnY+XKlSpvW1mXLl2SaROzCENQUBCGDBkiqGhJvufPn2P06NE4ePCgpFCKt7c35s2bh9zcXMH9+Pn5Yfr06Vi7dq3Seedr0aKF1BNqs7KycP36dXTu3FnlPomIiEhzwsLC0KVLF6XX+/PPP+Hp6amBjIiIqDRTthCnGPr06QMvL69i3y4RUUnx7NkzHDhwAEeOHCmyYHN2djYyMjKQkJCAqKgomSLWAGBsbIyqVavCw8MDn3zyCZo2bQpXV1dNpk9EREREREREREREREREOoxFGIiIiIiI9IyLiwtmz56N+fPnS9pyc3MxZ84c7Nu3D3PmzJGZ+Dxt2jS4ubkVc6biysjIQFhYmEy7o6Oj3Pj58+fj33//lWk3MzND27Zt0bRpUzg7OyM9PR0RERHw9fXFs2fPpGKTk5Px7bffYseOHfjkk0+KzC82NhazZs2SKcBgbGyMpk2bwsPDAy4uLrCysgIApKSkICYmBs+fP8fjx48REhJSZP+qsrOzQ506dQB8mJAeHBws9XqFChVgZ2dXZB+VK1cWPa/g4GAMHToUqampMq+5ubmhc+fOqFKlCqytrREdHY2HDx/iwoULMvFnzpxBZmYmNm7cqFIe2dnZ+OGHH6QKMNSrVw9t2rRBpUqVYGNjg4SEBDx48ADnzp2TuZH32LFj6Ny5M7p27arS9pV1+/ZtqeWKFSvCyclJlL6TkpIwduxYSQEGExMTtGjRAp9++inKli0LQ0NDRERE4MKFC3jw4IHUuiEhIVi1ahUWLFiAmzdvYv78+ZL9kI2NDdq1a4fGjRvDyckJmZmZCA4OxsmTJxERESHVz5kzZ3Dy5El0795dpZ+hfv36MDAwQF5enqTt1q1bLMJARESko3x8fFRa78iRIyzCQFTK3bx5E7du3VIY5+Ligr59+xZDRkRERFSckpOTsWLFChw4cEC0PrOzs/H8+XM8f/5c0u93332HadOmibYN0j/nz5/HkydPFMbVrVuX30MTERERERERERERERGVMCzCQERERESkh77++mucOXMGV65ckbSFhYWhV69eiI6Olopt0aIFhgwZUtwpiu7SpUvIyMiQaa9Xr55M28mTJ+UWYPD09MSCBQtQrlw5mdcmT54MPz8/LFiwAFFRUZL2rKwszJgxA0eOHIGNjU2h+e3btw9xcXFSba1bt8bSpUtRsWLFIn82AHj9+jXOnz+PvXv3KoxVhqenp2SC2uvXr2Umq02aNKnYJ6RkZmbixx9/lCmoYG9vj7lz56JXr15y10tISICXlxe8vb2l2v38/LBjxw4MHz5c6VzOnj0rGVdubm5YuHAhWrZsKRM3cOBAzJgxAzNmzJD63AHAmjVriq0Iw6NHj6SWxXxK5969eyVFRFq2bImFCxfKLd4yduxYHD58GD/99BOys7Ml7fv378fgwYMxY8YMSfvQoUMxadIk2NrayvQzadIkLFu2TGbMr1mzRuUiDJaWlqhcuTJevXolaSv4nhEREZFuyMvLw9GjR1Va18/PDwkJCQqLiRFRyXXr1i2sX79eYVzz5s1ZhIGIiKiEefjwIaZMmSJT4FUT0tPTNb4N0m3nz5/H4cOHFcb16dOHRRiIiIiIiIiIiIiIiIhKGENtJ0BERERERKpZtmyZzMTmggUYrKyssHz5chgYGBRnaqLLyMjA2rVrZdorVaqEKlWqSLWlpKRg4cKFMrFff/01NmzYILcAQ76OHTti9+7dMjERERH4448/iszR19dXarlatWrYuHGjoAIMAODq6ooRI0bg9OnTaN68uaB19NXWrVvx9OlTqTZ7e3vs2LGj0AIMAGBnZ4fly5dj7NixMq+tXLlSqniGUPkFGBo0aID9+/fLLcCQz9HREX/99Rdq1aol1R4SEgJ/f3+lt62siIgImUIfNWvWFK3//AIM3bp1w99//y23AEO+Pn36YNKkSVJtOTk5GD58uOT38PPPP+Onn36SW4ABAExNTbFgwQK0bt1aqj00NBR3795V+eco+Pt58uQJcnJyVO6PiIiINOPOnTsIDw9Xad3MzEycPHlS5IyIiIiIiEjXPXr0CCNGjCiWAgxEREREREREREREREREVLqxCAMRERERkZ4qV64c5s2bV2TM7Nmz4eLiUkwZaUZKSgqmTp2KoKAgmde+/vprmbbDhw8jISFBqq1BgwZYtGiRoGIUlSpVwpo1a2Rivb29Zfr92OvXr6WWe/XqBVNTU4XbK8jAwADm5uZKr6cvsrKy8M8//8i0L1++HHXq1BHUx9SpU9G2bVuptszMTOzevVulnGxtbbF27VrY29srjDU1NcX06dNl2q9cuaLStpURGhoq0ya0yIdQbm5uWLZsGYyNjRXGjhw5Uubp0zExMQA+jP9vvvlGYR8GBgaYPHmyTPulS5cEZiyr4HuSlpaGt2/fqtwfERERaYaPj49a6x85ckScRIiIiIiISC/Ex8dj/PjxSElJ0XYqRERERERERERERERERFQKsAgDEREREZEe6927N9q0aSP3tXbt2sktUqAvoqKisHv3bvTs2RO+vr4yr1eoUAHDhg2TaZc3wf/nn3+GoaHwyx8PDw/06dNHqi01NRXe3t6FrlPwxk8hE/pLo7NnzyI6OlqqrX379ujUqZNS/fz8888wMjKSatu/fz+ysrKUzmnYsGFKFTNo06YNHB0dpdoCAwOV3q6y5D3drVy5cqJu44cffoClpaWgWFNTU3To0EGm3cjICFOmTBG8zUaNGqF8+fJSbY8fPxa8fkEF+wLkv3dERESkPRkZGTh9+rRafdy7dw+vXr0SKSMiIiIiItJ1K1euxLt377SdBhERERERERERERERERGVEoofbUlERERERDorNjYWT58+lfva559/XszZCPfu3Tv06tVL7muZmZlISEhATExMoetbW1vjzz//hLm5uVT7mzdv8PLlS6m2+vXro2HDhkrnOGjQIJmiC1evXsXIkSPlxtvb20sVF7hz5w4GDhyo9HZLuqtXr8q0DR48WOl+KleujDZt2uDixYuStvj4eDx+/BiNGjVSqi9li5UYGRnB3d0dly9flrQVHHea8PbtW5m2MmXKiNa/lZUVunXrptQ69erVk3kKdatWrZQqagEAdevWlfr51Hk/nZ2dZdrevHmjcn9EREQkPl9fXyQlJandj4+PDyZPnixCRkREhZs4cSImTpyo7TSIiIhKtYiICBw+fFjbaRARERERERERERERERFRKcIiDEREREREemzRokV4//693NdWrVqFTp06wdHRsZizUiwrK6vQ4hGKuLq6YtWqVahXr57Ma3fv3pVpU7UYRcOGDeHq6orXr19L2u7fv4+8vDwYGBjIjff19ZUsHzt2DI0bN8bgwYPlxpdWBX9HlpaWaNu2rUp9devWTaoIQ37/yhRhqFy5MsqVK6f0titXriy1LMYkQkWSk5Nl2iwtLUXrv3HjxjAxMVFqHXnFFpo2bar0tl1dXaWWExMTle4jn4WFhUxbSkqKyv0RERGR+AoWcVLV0aNHMWnSJJ5vExERERGVcD4+PsjOzhYUa2BggNatW6NTp06oX78+XFxcYGVlBVNTUyQmJiIxMRGxsbEICgrC48eP8fjxYwQGBiInJ0fDPwURERERERERERERERER6RMWYSAiIiIi0lMnTpzA6dOnC309NjYWixYtwpo1a4oxK81xcnJCv379MHbs2EInngcGBsq0NWjQQOVt1q9fX6oIQ1JSEsLCwlClShWZ2L59+0oVYcjLy8PixYuxd+9e9O3bF56ennLXK01SU1MRGhoq1Va3bl0YGRmp1J+83628MVAUVX8nNjY2UsvyCiSILT09XabNzMxMtP4LFpYQwsrKSiP9qPN+yntP0tLSVO6PiIiIxBUTE4MrV66I0tfr169x584dlYpAERERqePZs2faToGIqFQpWIy3MGXKlMHatWvxySefyH3dwcEBDg4OqFKlCjw8PCTt8fHxuHjxIvz8/HDx4kWkpqaKkjcRERERERERERERERER6S8WYSAiIiIi0kPR0dFYvHixTLuNjQ2SkpIky6dPn8apU6fQrVu34kxPLSYmJrC2toaNjQ1cXV1Rv359eHh4oG3btjAxMSly3bi4OJm2atWqqZxLjRo15G5D3sT9zp07o3Pnzjh//rxU+/Pnz7FixQqsWLECFSpUwCeffIIGDRrAw8MD7u7uMDYuPZdl8fHxyMvLk2qrXr26yv1Vq1YNhoaGyM3NlbTJGwNFsbOzU2nbBX9vQp/Cpg55T2JTtYCFPKq8F/LGrxj9qPN+ysuJT7EjIiLSHceOHRP13MnHx4dFGIiIiIiISrDs7Gw8fvxYUKyXl1ehBRiKYm9vj169eqFXr15ITk7G0aNHsW/fPqX7EUtcXByCg4MRHx+PzMxMWFlZwdXVFW5ubqJ+J0xEREREREREREREREREhSs9s32IiIiIiEqQ+fPnIz4+Xqpt4MCBaNOmDSZMmCDVvnjxYrRo0QKOjo7FmGHRXFxccOHCBdH7TUxMlGmztbVVuT956yYkJBQav3LlSvz00084fvy43NffvHmD48ePS163tLRE69at0b17d3Tu3BmmpqYq56oP5P1+bGxsVO7P0NAQ1tbWUv0W9fuRR1FhD11ibm4u05aRkSFa/2IVBNF2YZH09HSZNnnvHREREWnHkSNHBMXVrVsXT548URh3+vRpzJ8/H2ZmZuqmVqTc3FwEBATgzp07ePz4McLCwhAVFYXExERkZGTAwMAAlpaWsLa2houLC6pUqYI6derAw8MDderUEXWiVHJyMm7cuIFHjx7h2bNniIyMRHR0NNLS0pCRkQEzMzNYWFjA0dERlStXhpubGxo0aIAmTZqgfPnyouWRnZ2Ne/fuSd6T8PBwREVFITU1FRkZGTA1NYWNjQ0qVKiA6tWro3Hjxmjfvj0qVKggWg7FKT4+HteuXcODBw8QFBSEyMhIxMbGIi0tDbm5uTA3N4ejoyNcXV1Rt25dNG3aFK1bt9aJc9GXL1/izJkz8Pf3R0hICOLi4pCamgojIyOULVsW27dvh5ubW5F9vH//Hs+fP0dwcDBCQ0MRFRWFd+/eITo6WvI7z/8smJqawtraGk5OTnB1dUW1atXQsGFDNG3aFPb29krn//TpUzx79kyqreByUXkL3e+0bt0aZcqUkWlft24d1q9fr3D95s2bY9euXYK2VZS8vDwEBATg1q1bePz4MV69eoWoqCgkJycjPT0dxsbGsLCwgJOTEypWrIjatWujUaNGaNWqlVrX2GJJSkrCmTNncOXKFTx79gxRUVHIyMiAra0tHB0dUb16dbRt2xadOnWCk5OTttMtsd6+fYvTp0/jxo0bCA4ORkxMjOSp7mXKlMHq1avRvHlzpfrMy8vDo0ePcPv2bQQGBkrGZkpKCjIyMmBsbAwrKytUqFABVatWRaNGjdC2bVtUrVpVEz+ixNu3b3Hy5EncuHEDL168QGxsLLKysmBlZQUXFxfUqVMHHTp0QMeOHUv8d29i0edjfHZ2Ni5evIiLFy8iICAAERERSE5OhqWlJRwdHeHi4oJWrVqhY8eOahWHFSIqKgrXr19HQEAAgoOD8ebNG8TExCA9PR05OTkwNzeHpaUlypYti8qVK6N69epo1KgRPDw8Ct2fZ2dno1OnToiKilK4/S1btqBNmzYq5f7gwQN8/fXXCuPs7Oxw+fJljZ+Lv3nzBllZWQrjypcvj7Zt26q9PWtrawwePBiDBw9WuuivOuLi4rBv3z6cPHkSQUFBcmNsbW3Rrl07DBo0SKPF6HR9P5Cf3927d/H06VNJfsnJycjIyICRkREsLS1ha2uLSpUqoVKlSnB3d4eHhwdq1KgBAwMDuf3eu3cPYWFhUm3h4eGCcgoPDxd83tmlSxdYWloKilXG48ePcfbsWdy7dw8vX75EQkKC5PyxYsWK8PHxgZWVlejb1XW3bt3C6dOncf/+fYSHhyM1NRUWFhYoX748GjRogC5duqBdu3aC/7bx+PFjnDhxAnfv3kVoaCiSkpIk1+Curq5o06YNOnTooPFzICIiIiIiIiIiIiIi0jwWYSAiIiIi0jPe3t7w8/OTanN1dcXMmTNhZWWFHj16SBUBiI2NxcKFC7F27driTrXYpaSkSC0bGBjAwsJC5f7k3QRXcBsfs7CwwKpVq9CnTx/873//w+3bt5GXl1dofGpqKs6dO4dz586hXLlyGD9+PAYMGFDoDYD6Ljk5WaZN3RsNLSwspIowFPX70XfyxrKYRRhKCnlFGNTZDxAREZF4nj9/LvgJtosWLcKoUaPknkN+LCkpCb6+vujevbsYKcoICQnB/v37cezYMcTExBQZm5CQgISEBERERODWrVuSdltbW3To0AFffvkl2rVrp1IeeXl58PX1xaFDh3DlypUiJ6GlpaUhLS0NsbGxePHihdRr1atXR5cuXdC/f3+4urqqlEtwcDD27NmDY8eOFVkELT09Henp6YiOjsbDhw9x+PBhAEDTpk0xcuRIdO7cWaXtF6e8vDycP38ee/fuxY0bN5CTk1NobEpKClJSUhAeHo7r169j69atsLS0xJdffolRo0YpLHJQFFWLAISHh2P58uW4cOGC3GvTnJwcvHnzBmlpaTKvRUdH49SpU7h79y7u3LmDd+/eCc43OzsbqampePfunVQxFWNjY7Ro0QKDBw9Gp06dYGhoKKi/c+fOCfr55QkJCcHMmTMFxe7cuVNuEYbiEhUVhT179uDff/9FdHR0oXGZmZnIzMxEQkICQkJCcOXKFQAfigy2adMGQ4YMUXnSLfDhe6c5c+YojCtYYDMpKQl//vkn9u3bJ5ns/7HY2FjJfunMmTOwsLDAiBEj8O2335bKyYCKqPp7iI2NxW+//YajR48iOztb7jrR0dFyC2UW5s2bN9i7dy+8vb2LHJs5OTnIyMhAbGwsAgMDJd9P1q1bF8OHD8eXX34pauHGt2/fYvXq1Th+/Ljc/XP+cfnx48fw9vaGs7Mzxo0bh0GDBkn2Pzdv3sSwYcMEbU9I8ZfZs2dLjndF6dOnD7y8vARtFwCGDh0qdW5RmAkTJmDixImC+y1IF47xr1+/hqenp6BYX19fyflMTk4ODh48iD///FNugYLExEQkJiYiNDQUV69excqVK/HFF1/gxx9/hIuLi8r5FpSamgofHx/8+++/CAgIKDI2/9whOjoagYGBknZDQ0M0adIEXbp0wddffy31/amxsTEGDRqEP/74Q2EuBw4cUPl4cPLkSUFxX3zxhcYLMAAQXAhBEwUAHBwclIpX5bwtLy8PO3fuxJo1axR+v52YmCgp9NyxY0csWrQI5cqVUyrHoujCfqAoAQEB2LdvH06fPo2kpKRC43JycpCZmYn4+HiZogplypSBp6cn+vTpAw8PD6nX9u/fL2g/Lo+/vz/8/f0Fxfr6+sr924iqx5EnT55g2bJlhR4rsrOzERYWJnO8FPs4mE/V8xix+/P398eyZcuk9rH5kpKSkJSUhOfPn8Pb2xtubm6YNWsWOnXqVGj/T548wYoVK3D9+nWZ17KysiTHmStXrmDFihXo1asXpk6dKmoxRCIiIiIiIiIiIiIiKl4swkBEREREpEfevn2LZcuWSbUZGBhg+fLlkhvW58+fj5s3b0rdFH3mzBmcPHlSYxOTdEXBm/bz8vKQlpam8gRseZMGhEwMaNOmDdq0aYOIiAj8999/uHXrFu7evVvkpJWoqCgsWLAA//33H9auXVsin8xnbW0t0ybvPVZGwclCJXnihrwnhMbHxxd/IjpO3s3BfLoqERGRbhA6mcXNzQ2NGjVCx44dcezYMYXxPj4+ol/rREdH47fffsOxY8eQm5urVl+JiYk4evQogoKCVCrCkD+Bo7Cn4SojODgYwcHBcHBwwIgRI5RaNy4uDr/99ht8fHyKLEagSP7kpCZNmmDx4sWoWbOmyn1p0u3bt/HLL79IFRFQVmpqKvbv3w9vb28MHToUU6ZMKZaJigBw9uxZzJo1S+Vrrlu3buGXX34RNafs7GxcvXoVV69eRf369bF06VLUrVtX1G3oo/T0dKxfvx47d+5Uq9BeVlYW/Pz84Ofnh6ZNm2L+/PmoU6eOiJkW7ubNm5g+fbpSxTrS0tLw119/wc/PD1u3buV1mwj8/f0xceJExMbGitJfWloa1q1bh127diEzM1Plfp48eYLZs2djy5YtWLhwoShPbj937hzmzp2rVDGJ6OhoLF68GCdPnsSaNWu0WnRF1+j7MT4iIgLTpk3DvXv3BK+Tl5eH48eP4/Lly9i0aRMaN26sVg65ubnYs2cP/vzzT4WFu4T0lf9etmjRQuZYOWDAAPz1118KjxkXLlzA+/fvlR7reXl5OH36tKDYvn37KtW3qoTug+QV4NB1qampmDZtmqCJ6AX5+fnh/v372LBhAz755BO18tD1/UBoaCi8vLxkCpSr4v3799i/fz/ev3+PP//8U4TstOuff/6Bl5dXkYX6Spu8vDysX78eGzZsKLJQ+sdCQ0Mxbtw4jBgxArNnz5Yplv7333/jjz/+EPw+5+XlwcfHBxcvXsTff/+N+vXrK/1zEBERERERERERERGR9gl7xAwREREREemEefPmyTzdZ8iQIWjevLlk2d7eHgsXLpRZd/HixWrfAKrrbG1tZdqUuRm7IHlPUrKzsxO8vouLC7755husWbMGly9fhp+fH3777TcMGDCg0Cff+Pn5YfHixSrnrMvk/X6KelqVIrm5uTJPRlbm96NvKlasKNP29u1bLWSi2+S9J/LeOyIiIipeubm5ggoqAEDXrl0BAN26dRMUf/XqVbx//17l3Ao6c+YMvvjiCxw5ckTtAgzqyMzMxPz58zF69GhRCjCo4+bNm/jyyy/x77//qjUp62N3795Fv3794OPjI0p/YsnNzcWqVaswbNgwtQowfCwrKwtbt25Fv379EB4eLkqfRfHx8cHkyZPVLnqnSQEBARgwYIDgJ22XVC9evEDv3r2xefNmtQowFOTv749+/fph586dovVZmEOHDmHkyJFKFWD42NOnTzF48GCZ63tSzvXr1zFq1CjRCjA8ffoUvXv3xpYtW9QqwPCx58+fY9iwYdi0aZNa/ezbtw+TJk1S+Ts/f39/DBw4EG/evFErj5JC34/xjx49Qr9+/ZQqwPCxhIQEjBw5EgEBASrn8PbtWwwePBhLliwplu/fHR0d8cUXXyiMy8rKgre3t9L93717V9B3jrVq1UKDBg2U7l8VNjY2guIiIyNx5swZDWcjnrS0NHz//fcqFWDIFxcXh1GjRsHf31/lPnR9P7B792706tVLlAIMJc1ff/2FJUuWsADDR/Ly8rBgwQKsX79ecAGGj23fvl2mGN2iRYvw22+/qfQ+x8XFYfjw4Xj27JnS6xIRERERERERERERkfaxCAMRERERkZ7Yu3cvrly5ItXm5uaGadOmycR27twZPXv2lGqLi4vDokWLNJqjtjk6Osq0hYSEqNzfixcvZNocHBxU7q9ixYro2bMnFi9ejIsXL2Lnzp1o06aNTNyhQ4fw/PlzlbejqxwcHGSeHhQcHKxyfy9fvpSZFKfO70fXVapUSaZNH5/upmny3hNXV1ctZEJEREQfu379uuAJuvnFF9q2bQtra2uF8dnZ2Th+/Lha+eX73//+h8mTJyMhIUGU/lSVmJiIoUOH4sCBA1rNAwCOHz+O0aNHIzo6WvS+09PTMWvWLGzfvl30vlWRlZWFSZMmYdOmTRopwBEUFIRBgwbJvdYUy61bt/DTTz9ptYCIUBkZGZgxY4bMdx2lRf5E8JcvX2qk/6ysLPzyyy9YtmyZRvoHgIMHD2LevHlqT9gMDQ3Fr7/+KlJWpU9wcDAmTJggWiGP69evY/DgwQgNDRWlv4/l5ORg1apVMpMbhTp79iwWLVqk9j4uPDwcI0aMUKs4aEmg78f4J0+eYMSIEWoXH0lNTcWcOXNUmlz75MkTtYpAqGrYsGGC4g4ePKj0JORTp04Jivvqq6+U6lcd9vb2gmNnzpyJf/75R7QCMpo0e/Zs3Lp1S+1+0tPTMX78eJWKy+jyfiAvLw8LFy7E4sWLkZ6eLm5yJcCxY8fwxx9/aDsNnbNhwwbs379frT527dolKRb3xx9/YM+ePWr1l5ycjDlz5iA7O1utfoiIiIiIiIiIiIiIqPixCAMRERERkR4IDw+XuRnd0NAQy5cvh4WFhdx1fvrpJzg7O0u1nTlzpkQ/ZdLd3V2m7dGjRyr3V3BdW1tbVK5cWeX+CmrRogW2bNmCAQMGSLXn5eXh3Llzom1HV1hYWKBq1apSbU+ePFF5soa83239+vVV6ksfVK9eHSYmJlJtmpqso88Kvieurq6CJm8SERGRZgl9Amq1atVQp04dAICpqSk6deokaL0jR46omprEli1bsHr1apWelimm1NRUjB49Gvfv39dqHgDg6+uLmTNnavzJqsuXL8fRo0c1ug1F8vLyMGPGDI1fi0VHR+Pbb78VXJREGYmJicXy+xJTdnY2Zs6cqfXCJ8Xt2bNnGDt2bLFMAN+xYwfWrVsner/R0dFYsGCBaP0dOHAAgYGBovVXWmRlZWH69OlITk4Wpb+HDx9i/PjxSElJEaW/wuzcuRN//fWXUuu8e/dO1CIzoaGhWLp0qSh96aOScIyfMWOGaGM/KCgIu3fvVmqd4OBgjBw5UiOT1xWpW7cumjVrpjAuLCwM169fF9xvbm4uTp8+rTDOxMREpgi0JpUtW1ZwIYb09HQsWbIE7dq1w/z583HmzBm8f/9eswmq4O7du4Lea6ESEhLw888/K7WOru8HFi9ejL1792ogI/33+vVrUc/DSop3795h/fr1ovTl5eWFs2fPYuPGjaL0FxgYiH379onSFxERERERERERERERFR8WYSAiIiIi0nF5eXmYO3cuUlNTpdpHjBiBJk2aFLqenZ0dFi9eLNO+ePFixMTEiJ6nLvDw8JBpO3PmjEp9BQQE4PXr11JtjRo1goGBgUr9FWXq1KkwMjKSanv27Jno2zE2NpZpU/dplcoq+DtKTU3F5cuXVepL3k2q8sZASWFmZoaaNWtKtQUFBWkpG92Ul5cn89lp0KCBlrIhIiKifCkpKTh//ryg2K5duxa5XJjHjx/j+fPnSueW7/Lly1i5cqXK64tp/vz5ePjwobbTQFhYGGbOnFls1ww///wzQkJCimVb8mzZskXwk5/VFRkZiZkzZ4pe8OPp06cqPQFZ22JiYrBp0yZtp1FsUlJSMGnSpGIpwJBvw4YNKl97FyYzM1PU/UNeXp7aTy0ujd69e4fHjx+L0ld8fDwmTZok8x2kpqxduxY3b94UHL9gwQLRC7bo4z5TDCXlGJ+WliZqf8rsg1JSUvDDDz8gLi5O1ByUMXToUEFxBw4cENynv7+/oKIS7du3h6Ojo+B+1WVgYIDmzZsrtU5cXBwOHDiASZMmoXXr1ujYsSMmTZqEzZs348aNG6IV8FBVdna26H1eunRJcPE7Xd8PHDhwAHv27NFgRvrt9u3bGi+YpI+ysrJEu8aKiorC5MmTRb1mYxEGIiIiIiIiIiIiIiL9IzsDh4iIiIiIdMqOHTtw69Ytqbbq1atjypQpCtft1KkTevfuLXXjXVxcHBYuXKiRpyBqW4UKFVC9enUEBwdL2gICAhAQEID69esr1Ze8G/zatGmjdo7yODg4wNHRUeoGV03cBGplZSXTVlw31udr06YN/v33X6m2ffv2oUOHDkr1Ex4eLjOBxMHBAfXq1VM3RZ3WqFEjqckVL168QHZ2ttwCG6VRWFiYzJhu1KiRlrIhIiKifGfPnhV83tmtWzep5bZt28LGxkbQZOXDhw9j5syZSueXnJyMOXPmKP1kbXNzc3zyySdo1KgRHB0dYWFhgfj4eERHR+PevXsIDAxUenLVmTNncPz4caXWAYBy5cqhVatWqFq1KhwdHZGdnY24uDiEhYXh1q1biIiIULrPefPmKXVd4uTkhPbt26N27dqwsbFBfHw87t27h//++0/Q03XT0tIwb948rTztNjQ0FH/88YdS67i7u6NVq1aoWLEijI2NERERgUuXLgmeDH39+nUcOnQI/fv3VyFj7bG3t0eNGjVQs2ZNlClTBtbW1rCysoKhoSHS09Px7t07vHz5Erdv30ZsbKzgfg8cOICJEyfC3Nxcg9nrhnXr1iE0NFRwvLGxMVq0aIFmzZqhTJkySElJQUhICHx9fQU/2TsvLw/z58/H6dOnNfYeGxgYoHHjxmjTpg3KlSuHpKQkXL16FVevXhU8ee3EiRP46aefYGpqqpEcxVS7dm21+5gwYQImTpwoQjbiWLFihVJFCWxsbNC+fXu4u7vDzs4OSUlJePToES5cuCDouJ+bm4t58+bh5MmTCn/n165dw4ULFwTnBgBubm7o1KkTXF1dYWRkhMjISPz3338aKXyqb0rqMd7NzQ2enp5wdXVFbm4uAgICcOrUKaSnpwtaPyQkBPfu3RNU5HX16tV4+fKl0jnWrFkTn376KSpUqAB7e3ukpqYiLi4OT58+xZ07dxAfHy+4r86dO6NixYqIjIwsMu78+fOIjY0VVDTh5MmTgrb91VdfCYoTU9euXXH27FmV14+MjERkZKSkaLOhoSFq1qyJ5s2bo23btmjZsqVWjz9t2rTBgAED0KhRIzg4OCA+Ph4BAQE4cOAA/Pz8BPezfv169OrVS2ExaV3eD0RGRmLZsmWCc8tnbW2NZs2aoX79+nBwcICpqSni4uLw9u1b3LlzB0FBQUpf85F+s7e3R7du3VCjRg2YmJggKCgIPj4+gse+vPHSqFEjdOjQAc7OzoiLi8OpU6cEXwM+f/4cDx484N8siIiIiIiIiIiIiIj0CGdpEBERERHpsJcvX+L333+XajMyMoKXlxfMzMwE9TFv3jxcu3YN7969k7SdPXsWJ06cwBdffCFqvrrgm2++weLFi6XalixZgn379im88TDfw4cPcfjwYak2S0tL9O3bV7Q8P5aRkSHzJD8HBwfRt2NlZQVjY2OpiWDh4eGib6coXbp0gbOzs1TBCT8/P1y8eBHt27cX3M/SpUtlJrQNGDAAJiYmouWqi9q0aSN1o2pGRgYePXok6Obw0sDf31+mTVPFU4iIiEg4oU9jrVGjBmrVqiXVZmpqik6dOuHIkSMK1z927BimT58OQ0NDpfLbvHmzoCf+5rOwsMCoUaMwcuRI2NjYFBqXnJyMw4cPY8+ePYKe+pqdnY0VK1YIzgP48J5NnToVnTt3LjLu+fPn2LNnD3x8fARNjPX19ZUpBlgYY2NjTJgwAaNGjZJ7nRoeHo7p06fj/v37Cvu6e/cuzp8/r/DnEdvKlSsFTR4DABcXFyxfvhwtWrSQeW3q1Kk4efIk5s2bJ+h9XrNmDXr27Cn4+l5ZhoaG6N69O7p06YL69eujTJkyAIDo6Gg8ffoUly9flkxELErjxo3h6emJzp07o1q1aoK2nZubC19fX/zyyy+CJnUnJibiypUrcn/3EydOlJmovm7dOqxfv15hv82bN8euXbsE5VwcIiMj8c8//wiOb9iwIby8vFC9enWZ13766SesX78e//vf/wT19ebNG+zcuRPfffed4O0LVbFiRfz6669o1qyZVPuoUaNw+fJlTJo0SdBnIjk5GU+fPkXDhg1Fz7E06dixI7p27YomTZrAyckJJiYmiImJQVBQEK5du4ZTp07JrPP06VOZ78KKMmzYMEyaNEnucfD9+/f46aefBE0aDg8Px969ezF8+PAi45T53JiYmGDu3LkYNGiQzHeBP/74I06dOoX58+cLKvBUEpXEY7y5uTlmz56NQYMGybw2btw4jB07VtC5GADcuXNH4fdswcHBSheUaNeuHX788UfUrVu30Ji8vDxcv34d//zzD/z8/BROFjcyMsLgwYOxcuXKIuOysrLg7e2NMWPGFBmXk5MjqMhBmTJl0K5dO4VxYuvatSvWrFmDV69eidJfbm4unj17hmfPnmHXrl2wsbFB9+7dMXjwYNSpU0eUbQhhYGCAn3/+GYMHD5ZqL1u2LDp16oROnTrB29sb8+bNE1RAIL94cVG/I13fD6xatQppaWmC8gM+TLQfN24cBg0aVOR5dUxMDA4ePIh9+/YVen7q5eUFLy8vqbbZs2cLOkb26dNHZt3iYmpqij59+sDT0xO1atWCk5MTsrOz8fbtWzx+/BiXLl3CuXPntJKbtnz++edYtmwZrK2tpdpHjhyJAQMGCC5mls/c3BzLly9H9+7dpdrHjBmD+fPn49ChQ4L6uXPnDoswEBERERERERERERHpEeXuRCQiIiIiomKTk5OD2bNnyzyp69tvv1XqZnRbW1ssWbJEpn3x4sVK32SkD3r37g17e3uptvv378t9D+SJiIjApEmTZG5o/Oqrr2Brayt3nVevXmHDhg1KPeXzY/v27UNmZqZUmyZu9DQ0NJSZuHHlypViffqTiYkJhg4dKtM+a9YsvHjxQlAfa9aswX///SfVZmZmJnOjaknUsmVLmUITN2/e1FI2uqfge1GxYkXUrFlTS9kQERER8GHSr9AJPl27dlWqvaB3797h2rVrgnMDgJSUFOzZs0dwvLOzM3bt2lXoxNOPWVtbY+jQoThx4gQWLFgAOzu7IuNPnjyJiIgIwbl4enri0KFDgiYz1qxZEwsWLMC5c+fQs2dPhQXqtm3bJigHQ0NDrF69GuPGjSt0wlOlSpWwY8eOIicdqrJtsYSFhcHX11dQbOXKlXHo0CG5BRjyde/eHZs2bYKxseI66NHR0Th27JjgXJVRpUoVeHt7Y9WqVejatStcXV1hbm4Oc3NzVKpUCV26dMHixYtx8eJFuLm5yaxvaGiIrl27wtvbG/v378d3330nuABD/vpdunTBwYMH4ezsLGgdZT+/+mj37t2CC364u7tj27ZtcgswAB8m2/3444+YNm2a4O3/888/grcvVJkyZbBz506ZAgz52rZti3nz5gnuLzAwUKzUSh1HR0fs2LEDGzduRO/evVG5cmVYWVnB1NQUFSpUQPv27TFnzhxcuHABn376qdS627ZtQ15enqDtzJkzB/PmzSv0OFimTBls2LBB8CTtHTt2FPndVGRkpMz3QEX57bffMHjw4EKPdd26dcPGjRtLfCHPwpS0Y7yRkRFWr14ttwAD8OF4+Oeffwo6LgPC9kHbtm1DTk6O4BynTJmCzZs3K3yfDAwM0KpVK/z55584dOiQoEm6/fv3h4WFhcK4gwcPKoy5desWYmJiFMb17NlT8PspJiMjIyxYsEDpgmtCJSUlYf/+/ejVqxfGjRuH0NBQjWynoPHjxyv8Xrtv376YNGmS4D737dtX5Ou6vB+IiIiQWyyoMFWrVsXBgwcxYsQIhYXNnJycMHbsWJw9exaTJ08W9NnRBw0bNsTJkyexePFitG/fHhUqVICpqSksLS1RrVo19OjRA7/++isuXboEKysrbadbLFq0aIHVq1fLFGAAAFdXV4VFaeRZtmyZTAEG4MPnZO7cuTJ/lyxMQECA0tsmIiIiIiIiIiIiIiLtYREGIiIiIiIdtWXLFpmnB9WqVQs//PCD0n116NABffv2lWqLj4/HwoUL1chQN1lZWWHBggUy7bt378akSZOKLDxx8eJFDB48WOYpSC4uLpg8eXKh66WmpmLt2rXo0KEDpk+fjnPnzskUz5AnMzMTW7ZswW+//SbVbmRkhC+++ELh+qoo+CS3ly9fYt68eUpN9lLXyJEjZW7KjIuLw9ChQ3Hy5MlC10tMTMS8efPw559/yrw2ffp0lCtXTvRcdY2VlRVatmwp1VYaJioJkf+0wI95enpqKRsiIiLKd/ToUcFFv7p16ya3vU2bNgoLHuTz8fERmhoA4Ny5c0hMTBQUa2Jigj///BMNGjRQahuGhoYYPHgwNm/eXGTcv//+K7jPhg0bYs2aNUpPHCpTpgx+++03DBw4sNCY8PBw3L59W1B/gwcPxueff64wLv+poUL4+/sjPDxcUKwYfHx8BI1RAwMDrFq1Co6OjgpjmzVrhm+++Ubw9sXm4uKCXbt2CZoMZ25uLncc5T9t2t3dXa1cnJ2d8d133wmKLemT7/Py8nD06FFBsUZGRvDy8pI7caygb7/9VvDTdKOiokQv5Ddv3jxUqlSpyJiePXsK+lkACC7QSNJsbW2xa9cumeIK8hgbG0v9PlJTU3H69GlB2+nYsSNGjBihMM7IyAjLli1TOCEW+DDhtqiCTRcuXBA84b1r166Fnk98rGnTpnKLhJZ0JfEY//XXXyv8/qdq1aoy36cVRtE+KCMjAydOnBCc3/DhwzFu3DjB8fnc3d2xf//+Qgvx5LO3t8eXX36psL/Q0FDcuHGjyJiivpf9WL9+/QTFaULr1q0xdepUjW/nwoUL6Nmzp8JiBuqqWLEivv/+e0Gxo0ePhqurq6DY69evF7rf1PX9gI+Pj+B9vq2tLf7++29UrlxZUHw+U1NTjB8/HsuWLVNqPV1UsadqkgABAABJREFUv359bNu2TeG5GADY2NjAyMioGLLSLiMjIyxatKjIYjFt27ZVqs+WLVsW+Tc7KysrdOzYUVBfz58/V2rbRERERERERERERESkXSzCQERERESkg4KCgrB27VqpNhMTE6xYsQKmpqYq9TlnzhyZSernzp3D8ePHVc5TV3Xv3h1fffWVTPuZM2fg6emJiRMnYvv27Thx4gS8vb2xdu1a9O7dG9999x3evn0rtY6JiQl+++03QZO+MjIycOzYMUyYMAEtWrTAwIEDsWjRImzfvh3e3t44c+YMjh07hm3btmHWrFno0KEDfv31V5mnUH777beoUKGCem9CIeS9L97e3ujUqZPkRrJevXpJ/VPmiZVCmJqaYtWqVbC0tJRqj42NxdSpU9GtWzesWrUKBw8exMmTJ7Fr1y5Mnz4dHTp0wKFDh2T669ChQ6m6cb5nz55Sy/7+/oiNjdVSNrrj/v37ePfunVRbr169tJQNERER5Tty5IiguJo1a6JGjRpyXzM1NUWnTp0E9XP+/HmkpKQIzs/X11dw7JgxY9CwYUPB8QUVNRE1ISFB8GQoQ0ND/Prrr2o9wbuoXIS+J8bGxhg/frzgbdatWxeffPKJoNgLFy4I7lddQn/eDh06KPX7HzJkiKC4u3fvIj4+XnC/Qvzyyy9qF6kr7AnyqhD6ey+uJ05rS0BAgMw1S2E+++wz1KpVS1CsgYGBUp9FPz8/wbGK1KpVS+4TgQsyNTVFnTp1BPUptDAOSZs5c2ahx1FFrl27JqiYKABMnDhRcL/Ozs6CJu8CRe/37927J3ibQou+AB+O66VhMurHStox3tjYGBMmTBAUK7SIlqJ90NWrV5Gamiqor0qVKmH69OmCYuUxMDAQ9LcAod+LHjhwoNDXsrOzce7cOYV9NGrUSGFhCE377rvvsHDhwiInWIshIyMDCxYswMaNGzW2jb59+woqVgN8OJYWLLRdmNTUVAQFBcl9Tdf3A8pcn82cOVNwYQp5hL73usrExAS//vqr4EJXpUXHjh1RtWrVImOqVq2q1PW0kAJU9erVE9RXUlKS4O0SEREREREREREREZH2afavkkREREREpLSsrCzMnj1bZmL+2LFjBd/EI4+trS2WLFkiczPykiVL8Omnn6JMmTIq962LlixZAiMjI5mbS9PT03H27FmcPXtWYR/W1tZYv3694JsHC27n3r17St0oDnwoICH05mFVNGzYEH379oW3t7fMa7GxsXIn89va2oqeR/Xq1bFz5058//33iImJkXotJCQEmzZtEtTPZ599hpUrV4o6QUjXdenSBVZWVpLJhTk5OfD19UX//v21nJl2FfxM16hRQ+mnVBMREZG4Hj16hODgYEGxXbt2LfL1bt26CSrokJaWhrNnz6JPnz6Ctnvnzh1BcWZmZhg2bJigWFXcv39f8BNfu3TponBSiTru3r0rKO7TTz+Fk5OTUn03a9ZM0Ht+7949DB8+XKm+VZGcnFzoBLWChDxl+mOVK1dG2bJlFU66z8nJwYMHD9C+fXul+i9MixYtBD/tu7jY2dkJiouPj0dGRobeT4grjDLfDwgpbPCx1q1bw87ODgkJCaLmoYgyn4uKFSsKiuPENOVVqlRJrSfTCz0WVq1aFe7u7kr13axZMxw9elRhXFHjUuiYdXV1VSo/JycnfPLJJ7h165bgdfRdSTvGK/Odtlj7IKGfF+DDpF1VCyoro1atWvj0009x48aNIuPOnTuHuLg4ODg4yLx2/fp1xMXFKdyW0CIAmjZo0CDUq1cPS5YswaNHjzS6rT/++AM1a9aEp6en6H137txZqXhPT0+Z4t2FuX//PurWrSvTrsv7gZSUFDx9+lTQtpydnUt9Ad4vv/xS60VRdJGQz6qRkREcHBwEFUgzNzcXdH0l9DjDgmNERERERERERERERPrFUNsJEBERERGRtI0bNyIwMFCqzd3dHWPHjlW77/bt2+Orr76SaouPj8eCBQvU7lvXGBkZYcmSJZg3b57gCR8fa9y4Mfbs2SPo5ipzc3NYWVmpkqaEpaUlpk2bhtWrV6v1RFshFi1ahGHDhsHQULuXhA0aNMD+/fvRqlUrpde1tLTExIkTsWbNmhI7Qacw5ubmMpMKhUxoKMlycnJw8uRJqbYBAwZoKRsiIiLKJ6RoQr5u3boV+Xrr1q1hY2MjqC8fHx9BcVFRUTIFwQrTvHlzODo6CopVxZMnTwTHKipYoS6huXh4eCjdd9myZUXNQV1Pnz5Fbm6uoFhVft5y5coJzkMsmpwcmZSUBD8/P6xfvx4//vgjBg4cCE9PTzRv3hwNGjRA3bp1Ubt2bZl/ykxazC82VxIp83tWthikiYkJGjZsKCg2KChI8LhXpHnz5oJjhe7DhT5hnv5Pnz591CpOqcn9vjL7wby8PJn29PR0RERECOpDlUKMpa14Y0k7xrdo0UJwrFj7IF06Z/vY0KFDFcZkZmYWep5c8Hs1eczNzfHFF18om5rGNGrUCAcPHsSqVatUGrNC5eXlYcGCBcjMzBS1XxMTE9SoUUOpdapXry74bwdhYWFy23V5P/Ds2TPBhek8PT2LpciJLiv4tz76QOg5sdDr+5o1awr6G5SlpaWg/niuS0RERERERERERESkX4y1nQAREREREf2fwMBAbNy4UarNxMQEXl5eMDYW5/R9zpw5uHr1Kt6+fStpO3/+PI4dO6b0kz31wbBhw9CrVy9s27YNZ86cQUhISKGxZmZmaNq0KQYOHIjPPvtM8DaqVq2KGzdu4Pbt27h8+TLu3r2Lx48fIysrS+G61atXR/fu3TFgwAA4OzsL3qY6TE1NMW/ePIwaNQonTpzAgwcP8Pz5c8TFxSElJUVQ3mKpVKkStm3bhqtXr2LXrl24efNmkTehVapUCZ6enhgzZkyxvV+6aNiwYdizZ49k4sytW7fw8uVLjT4RWZddunRJap9ma2vLm1CJiIi0LCsrCydOnBAUW6tWLYVP8DQ1NYWnp6egAgu3bt3CmzdvUKFChSLjXr9+LSg/QPkJ0crSlVxyc3Px5s0bQbHr1q3DunXrNJLHmzdvkJeXp9akYiGETuwFgI4dO+pEHoooMyleiJycHJw5cwaHDh3CjRs3BE+MU1V6erpG+9cmob9nR0dHpZ88DXyYIHb58mWFcVlZWYiOjhY8Ob4wBgYGqFWrluB4c3NzQXHyJuJT0dT93Asdm97e3vD29lZrW4XJzMxEdHS0zATehIQEwX2o8jTw0vQE8ZJ4jK9du7bgWAsLC0FxivZBQs/ZqlSpgjJlygiKFUOnTp3g6uqqML8DBw5g5MiRUm1ZWVnw9fVVuI0uXboILmZRXAwMDNCjRw/06NEDz58/x4kTJ3DlyhUEBgaKVnAIAKKjo3Ho0CEMHjxYtD4rVqyodDFmExMTVKxYEa9evVIYm5iYKNOm6/sBXbkm0gempqZo1KiRttPQOUZGRqhcubKgWKFFPIT+zcXIyEhQHM91iYiIiIiIiIiIiIj0C4swEBERERHpEHd3dwQGBmp0GzY2Nrh48aJGt1HQs2fPinV7BdnZ2WHKlCmYMmUKIiIi8OTJE8TFxSEuLg4mJiZwdHRE2bJl0bhxY8E35BZkamqK1q1bo3Xr1gA+3Dz+6tUrhIWF4d27d0hJSUFmZiYsLCxgbW0NV1dX1K5dW+Wn6YrxnlaoUAFjxoxRef0WLVqI9rvNf+8yMzPx8OFDvHnzBrGxsUhLS4O9vT0cHR1Rs2ZNtYsMXLhwQZR8J06ciIkTJ4rSlyqqVKkCT09PnDt3TtJ24MABzJo1S3AfYvzuxBoD6r6fBw4ckFru378/rKys1E2LiIiI1HDp0iXExsYKiu3WrZvgOCFFGHJzc3H06FF8//33RcYJzQ8AXF1dBceqIiYmRlCciYmJ2hOni5KYmFisRdkKk5GRgaSkJNja2mp0O8qMAU16//69KP3Y29ujYsWKovQFAPfu3cO8efMQHBwsWp+KiDlhUtcIHW+qTtpVZr2YmBi19yWWlpaCn/gLQOmJprpO2991faxu3bpqrS/0GKRpMTExahVhsLOzU3qbqqyjr0riMV6Z/Z5Y+yChnxdNnzsWZGhoiCFDhsDLy6vIuJCQENy+fRvNmjWTtF29elXQZ03XC57WrFlT8jeAhIQE+Pv74/79+7h//z4CAgLUfvr88ePHRS3CYG1trdH15P1OdX0/oEvXZ7quZs2aJe7cSgxWVlaCiysIjbO3t1cjIyIiIiIiIiIiIiIi0ncswkBERERERKWKi4sLXFxcNL4dU1NT1KxZEzVr1tT4tkoSU1NTNG3aVNtp6IUffvgB58+flzw56dChQ/jhhx9UvoFXX4WGhuK///6TLFtaWmL06NHaS4iIiIgAAEeOHBEcK7QIQ6tWrWBrayv3qa7ytq+oCENaWpqg7QKan6SZnp6uE3lkZGRotH9lpKWlabwIg9D3XdPEykPMJ26fOnUKs2bN0qkxoe+EvpeqFpRTZj0xxpyyeRoaGqq9TZKVX+xTHbryOZd3XE5KShK8viqFVUtTAUdd+T0D4h3jlfn9GRgYqL09QHfO2eTp168f1q5dq7DYwP79+6WKMJw8eVJh3y4uLvj000/VzrG42NnZwdPTE56engCAnJwcPHnyBDdu3MDFixfh7++vdOGnhw8fIj09Hebm5qLkqGo/QtdLSUmRadP1/YAuXZ/pOjHP+0sSZc4FhJ6bKlN0jIiIiIiIiIiIiIiISh4WYSAiIiIiIiLSQ3Xr1kXXrl1x6tQpAB+eZLZ37158++23Ws6seP39999SN00PGzYMTk5OWsyIiIiIEhIS4OfnJyjWwcEBDx8+xMOHDwXFV6pUCYGBgQrjgoOD8fDhQzRs2FBQv6R7srOztZ1CsRHricQ2Njai9OPv74+pU6dKCr6RflBmgrEYv1tln77MIgyaUZIKMcrb7yszSVmVfam2JiQr+xnUhSfXi0msY7yxsfDbXUrDPsjGxga9e/fGnj17iow7e/Ys4uPjYW9vj8zMTFy4cEFh33369BGtkIU2GBkZoX79+qhfvz7GjBmDqKgobNu2Dbt27RI8HrOysvD8+XM0aNBAlJxULYgkdD1dLzJTms71NUGs835l5OXlCd4PaOv3q8xxQZt9EhERERERERERERGR/uBfCoiIiIiIiIj01OTJk3Hu3DnJTY07duzA0KFDRXsim66LioqCj4+PZNne3h6jR4/WXkJEREQEADh16hQyMzMFxcbFxWHmzJkayePo0aNFFmFQ5imZCQkJYqRUKKHnb7qSR3EojgIAqjw1XZcpOylenoyMDMybN48FGDTAzMxMUJy8J1cLkZycLDi2pI390szU1FTtPszNzZUaP5oib79T8CnpRVHlZ1D186aunJwcpeLFyLO0HeM1RejnRdPnbIUZMmQI9u7dW+R7nJGRAR8fH4wYMQKXLl1CUlJSkX0aGBigd+/eImeqXeXKlcPs2bPRoUMHjBkzRnChk/j4eNFyUHW/K3Q9eftPXd8P6NL1ma4T47xfWTk5OYILEujCeQUREREREREREREREZEYSn65fyIiIiIiIqISqmrVqhg2bJhkOTo6Gjt37tRiRsVr3bp1UjdJT548WakJGkRERKQZHxdJ0qYTJ04UOaHKwcFBcF8RERFipFQoR0dHQXFZWVmIiorSWB42NjZamdCjLfb29tpOQeecPXsWoaGhgmJNTEzQq1cvrFu3DmfOnMG9e/fw9OlTPHv2TOqfr6+vZpPWE0L3OTExMSr1r8x6Qvc5VDooczwsbsrsp1+/fq10/+Hh4UqvIwahE77zqbpf+FhpO8ZritD9p6bPHQtTvXp1tG7dWmHcwYMHAXwonqZI8+bNUalSJbVz00Wffvop+vbtKzhezIn/kZGRSu8LsrKyEBkZKSjWzs5Opk3X9wO6dH1GspQZr2Ict4iIiIiIiIiIiIiIiHSBsBLVRERERERERKSTJkyYgOPHj+Pdu3cAgE2bNqF///46PYlCDMHBwfD29pYsu7u7Y+DAgVrMiIiIiAAgLCwM9+7d03YaAIDY2FhcunQJnp6ecl9XZjLZnTt3xEpLLldXV8Gxd+7cQffu3TWSh6GhIcqXLy9oUuqvv/6KXr16aSSP4iL0fTczM8Pdu3cFP/lVn505c0ZQnJ2dHbZt2wZ3d3eFsenp6eqmVSK4uLgIiouJiUFsbKzShRKeP38uKM7ExARly5ZVqm8q2VxcXATt9ydPnozx48cXQ0b/x9raGra2tkhMTFQY++zZM6X7V2WdohgYGAiKS0tLE9zn+/fvRZnMWtqO8Zri6uqKsLAwhXGhoaGIiYmBk5NTMWQlbdiwYbhy5UqRMS9evMC1a9dw4cIFhf199dVXYqWmk1q3bo39+/cLihX6GRciKysLz58/R7169QSvExwcLHgivLxrHV3fDyh7TfTll19qMJvSQZkxnZaWBgsLC0GxYh9fiYiIiIiIiIiIiIiItMVQ2wkQERERERERkeqsrKywatUqTJgwARMmTMDw4cO19iTH4vTmzRuMGzdO8nMvW7YMhob8moOIiEjbfHx8tJ2ClCNHjhT6Wrly5QRPcr516xZiY2PFSktG3bp1BccKnSSvqjp16giKe/jwoUbzKA61atUSNPEoIyMDT58+LYaMtM/f319Q3OTJkwUVYABUezq9ImJOgiwutWvXFhyrbOGXrKwswZ/JmjVr8tqJpOjyft/AwAANGzYUFPvo0SOlihVkZWUpnKiuLEtLS0FxQopK5Lt9+7aq6cjQ5d+1vhD6HgLA6dOnNZhJ4dq1awc3NzeFcXPnzkVqamqRMdbW1vjss89Eykw9mir0JnRSOSD8My6Ur6+vUvHnz58XHNu4cWO57bq8H6hdu7bgc5QLFy4ILkihLn087xRKmTEt9NiVmZnJ4wgREREREREREREREZUYvMOGiIiIiIiISM81b94cEydOlPwTOkFBn7Vp00bqZ1bmJngiIiLSjLy8PBw9elTbaUjx8/NDQkJCoa83adJEUD/p6enYvXu3WGnJaNy4MYyMjATFnjt3TtATmFXl4eEhKO7kyZPIzMzUWB7FwdbWFjVq1BAUq2sFRjQhKysL8fHxgmJbtGghuN///vtPtYSKYGZmJiguPT1d9G2rSuj+Bvjw+VLGtWvXBP/uCpuUSaWX0P3+lStXlCpyIBah+eXk5ODff/8V3O/p06eVKoYghLW1taA4ZYrTHD9+XNV0ZJSmY7ymfPLJJ4Jjd+zYUWyTxD9mYGCAIUOGKIx78+aNwpju3bsrVaRAk6ZNm4aBAwfi8uXLovYbHBwsOLZ8+fKibtvb2xsZGRmCYjMzM3H48GFBsZaWloUWf9Ll/YC1tbXgolVRUVE4duyYhjP6QB/PO4WysbERHCu08POlS5eKvAYnIiIiIiIiIiIiIiLSJyzCQEREREREREREREREartz547giRnFJTMzs8jJzF26dBHc16ZNmxAYGKhyLmlpaYW+Zm9vj6ZNmwrqJycnBzNnzkR2drZGcvH09BTUR2xsLDZt2qRyDgWlpqZi9+7d2LBhg2h9CiH05z1w4ABCQkJE225oaCgWLlyIBw8eiNanuuLi4pCXlycoVuik0tevX8Pb21udtOQSOtE5NDQUOTk5om9fFfXr14ezs7Og2DNnzuD58+eCYvPy8pT63HTs2FFwLJUObdq0gampqcK4rKwsrFy5UrTtZmVlwcfHB7/88kuRca1atRLc5//+9z9BE8uTk5Px+++/C+5XKDs7O0Fx0dHRiIyMVBj36NEj+Pr6qpuWRGk7xmtCmzZtBD85/tWrV1i9erXK28rNzRU8Qb+gPn36CD5WFqVv375q9yGme/fuYcyYMejZsycOHjyI1NRUtfpLTU3F3r17BcUaGhqicuXKam2voMjISPzvf/8TFLtlyxbBBVxatGhRaIE3Xd8PdO7cWXCfK1asELTPL0xR10QfE/pZUqagh66wtbUVHCvkuiU3Nxfr169XJyUiIiIiIiIiIiIiIiKdwiIMRERERERERERERESkNh8fH22nINeRI0cKfa1z586Cn/6ZmZmJcePG4fHjx0rn4O3tje+//77IGGUmud27dw8//vij0k9bTUxMxJw5c3DgwIFCY9zc3NC4cWNB/f31119Fvr9CvHz5EqtXr0aHDh2wePHiYi/k0bNnTxgYGCiMy8jIwLhx4wRNmi1MdnY2Ll++jHHjxqFbt27Yu3evTj0xV5knXZ87d05hTFJSEn744QeVJ5AWRehE58TERI0UgVCFoaEhvvzyS0GxOTk5mDVrFlJSUhTGbt68WXAxD2dnZ7Rs2VJQLJUe1tbWgosSeXt7qz0p982bN9i0aRM8PT0xa9YsPH36tMj4Jk2aoFatWoL6Tk5OxpgxYxAVFVVoTEJCAsaNG4eIiAil8haievXqgmP/+eefIl9PTEzE3LlzBRfHEaK0HeM1wdzcHF27dhUcv23bNpU+M8HBwRg8eLDKBaCsra3Rp08fldbNV61aNXh4eKjVh6Y8e/YMP/30E9q0aYM5c+bg4sWLyMzMVKqP6OhofP/993j16pWg+Fq1asHKykqVdIv0559/KiwE4e3tjbVr1wruc9CgQYW+puv7gV69ehVaQKKg+Ph4jBkzRnBxinw5OTn4+++/8dNPPwmKF3reGRQUhGvXrimVi7Y5ODjAyclJUKy3t7fCwhVr1qzBkydPxEiNiIiIiIiIiIiIiIhIJxhrOwEiIiIiIiIiIiIiItJvGRkZOH36tKDYypUrC5rArci0adNw/PhxhXH37t3Dq1evUKVKFZnXrK2tMXDgQGzevFnQNqOiovDNN99g9OjRGDFiRJFPRc3IyMDJkyexc+dOPH78GHXq1Cmy7y+++AJ//PGH4Ke5njlzBi9fvsTUqVPRqVOnImMjIyOxe/duHDx4EAkJCZgzZ06R8aNGjcKkSZMU5pCdnY1Zs2bh6tWr+OGHH+S+xwVlZmbi2bNnuHjxIs6cOYOgoCCF62hS9erV0aFDB/j5+SmMDQ0NRZ8+fTBx4kT06dNH0ES8uLg43Lt3D+fOncOFCxcQHx8vQtaaYWNjAzMzM0FFEzZv3owqVaoUWsTizp07mDt3LkJDQzWQKQRPyAaA+fPn4/z58/jkk0/g6OgIExMTmZgmTZqgUqVKYqYo1zfffINdu3YhKytLYWxgYCBGjhyJ5cuXy53YnZmZiQ0bNmDjxo2Ctz9kyBC5Pz/RyJEjceLECUGxq1atgr+/P6ZOnYq6desqjM/JyUFwcDAuXbqEs2fP4uHDh0oXFhg0aBAWLVokKPbFixf44osvMGLECHTu3Bmurq4wMjJCZGQk/vvvP2zbtg3R0dFKbV+o+vXrC47dtm0bqlWrhn79+sm8FhwcjBkzZmjkGFmajvGaMnr0aPj4+CA3N1dhbF5eHlatWoW7d+9iypQpCs8HHz58iJ07d+L06dOCjhVFGTp0KP755x+VC3koUyBMW1JSUuDt7Q1vb2+Ym5ujSZMmaNSoEerWrYtKlSqhfPnysLKygomJCdLS0hAdHY2goCBcunQJx48fVzih/GMdO3bUyM+Ql5eHhQsX4vz58xg0aBAaNmwIe3t7JCQkICAgAPv37xd0nprP1dUVbdu2LTJGl/cDlSpVwueff46TJ08Kin/x4gX69euH8ePHY+DAgTA1NS00Njk5GYcPH8auXbvw6tUreHp6CtqGMued3333HTw9PSW/R2Nj2dvyWrdujTJlygjuU9Pc3d1x6dIlhXERERGYOnUqVq5cKXMdnJGRgdWrV2P79u0aypKIiIiIiIiIiIiIiEg7WISBiIiIiIiIiIiIiIjU4uvri6SkJEGx3bt3F2Wb3bp1E1SEAQCOHDlS6ESjsWPHwsfHR/CEzNTUVKxbtw6bN29G06ZN0ahRIzg5OcHc3BwJCQl4//49Hj16hAcPHgiazJ7PxMQEM2fOxNSpUwWvExQUhHHjxqF8+fJo1aoVqlatCgcHB+Tk5CAuLg4RERHw9/fHy5cvBfcJAJ9//jmaNGmCu3fvKozNy8vDkSNHcOTIEbi7u6NBgwZwc3ODtbU1DAwMkJiYiISEBERHR+Pp06cICgpSe1Kh2KZPn47Lly8jOztbYWx8fDyWLFmClStXonnz5qhbty6cnZ1hZWWFtLQ0yc8bHh6Ox48fa+RJ65rUoEED+Pv7K4zLzMzEzJkzsWnTJrRr1w4uLi4wNTVFZGQkrl+/jvv372s0z2rVqsHS0hKpqakKY/Py8vDff//hv//+KzRm+fLlxVKEwdXVFYMGDcLOnTsFxT948AA9e/bEp59+imbNmsHJyQlpaWkICQnBuXPn8P79e8HbLleuHIYPH65q6lTCNWjQAD169BB8XL148SIuXryI6tWro3HjxqhWrRpsbW1hZGSEpKQkJCQkICYmBs+ePcPTp0+Rnp6uVn59+vTBli1bBD/tPCkpCevWrcO6devU2q6ynJycULVqVUHH3dzcXMybNw///vsvOnbsCEdHR8TGxsLf3x9Xr14VdExSRWk7xmtCjRo1MGDAAOzdu1fwOn5+fvDz80OtWrXQokULVKxYEXZ2dkhLS0NcXByCg4Ph7+8vaoGQKlWqoH379kUe/wpjZGSEXr16iZZLcUhPT8e1a9dw7do10fs2MjLSeFGKK1eu4MqVK2r388MPP8DQ0LDIGF3fD0ybNg0XLlwQfOyIi4vDL7/8grVr16J58+Zwd3eHg4MDTE1NERcXh+joaNy/fx+BgYEq7Vvd3d0Fx2ZlZeH06dNFFijcuXOnThVhaNasmaAiDMCHfVnXrl3Ro0cPVKtWDRkZGQgODsbZs2cRExOj4UyJiIiIiIiIiIiIiIiKH4swEBERERERERERERGRWo4cOSI4tlu3bqJss23btrCyskJKSorC2KNHj2LixIkwMDCQec3a2hq//PILvv/+e6WeFJyeni7aZKl83bt3x7lz5wQ/+TXf27dv4e3tLVoeAPDLL7/gq6++EjTJPV9gYCACAwNFzaM41KhRAxMmTMAff/wheJ20tDTJJOSSpGPHjoKKMOR78eIFXrx4ocGM5DM0NES7du2KnOCmqyZPnoz//vsPYWFhguKzs7NF2dcsXrwYFhYWavVBJdvcuXNx69YtvHv3TvA6wcHBCA4O1mBWH1hYWGDp0qUYOXKkUsdqbejbty9WrVolOP7u3buCJkKLqTQd4zVl+vTpuH79OkJDQ5VaLygoCEFBQZpJSo6hQ4eqVIShXbt2KFu2rPgJ6akePXqgcuXK2k5DoTZt2gguFqHL+wFXV1fMmjULixYtUmq9pKQk+Pr6wtfXV9R8ypQpgwYNGuDRo0ei9qsrevXqhT/++AM5OTmC4qOjo7Ft2zYNZ0VERERERERERERERKQbii5/TkREREREREREREREVISYmBjBk4OrVauGOnXqiLJdMzMzdOzYUVBseHg47ty5U+jr7du3x9SpU0XJS11Lly5V6mmrmlKtWjWsWLECRkZG2k6lWIwdOxafffaZttPQun79+sHW1lbUPjX15OiBAwdqpF9Ns7a2xtq1a2FlZVVs2xw7diw6dOhQbNsj/eTk5IS1a9fqbLGOli1bYtCgQaL1Z2hoiBEjRojWX74+ffrAzMxM1D5NTU1F7a+0HeM1wdraGuvXr4e9vb22UylS69atUb16daXX09SxWx85OTlh5syZovfr4eGBJk2aiNafra0tlixZIjhe1/cDgwcPxoABA7SdhoS+nncKUa5cOdHPE8U+bhEREREREREREREREWkLizAQEREREREREREREZHKjh07huzsbEGx3bt3F3Xb3bp1Exzr4+NT5Ovff/89Jk6cqGZG6rOyssLWrVvRoEEDbaeCzz77DF5eXjAxMdF2KhpnYGCAVatWoXPnztpORavs7e1F/Ry0bNkS48aNE62/gn1//vnnGulb0+rWrYuNGzfC2tpa49saMmSIzhSZId3n4eGBv/76q1iLhChj7ty5aNOmjSh9zZs3D506dRKlr485OztjwoQJovU3atQoNG7cWLT+8pWmY7ym1KxZE1u2bIGTk5O2UymUgYEBhgwZotQ6Dg4OggudlXQWFhZYu3YtypQpI3rfJiYm2LBhA2rVqqV2X2ZmZtiwYQMqVqyo1Hq6vh9YuHAhvv76a22nAQDo3bu3RvbFumLOnDmwtLQUpa9q1aphypQpovRFRERERERERERERESkbSzCQEREREREREREREREKjty5IjgWLGLMLRt21bwRNHTp08jIyOjyJgJEybg999/h42NjRjpqcze3h67d+/WiacQ9+zZE9u2bUO5cuW0nYrGmZqaYt26dRg7dqzOPhW4OAwbNgz9+vVTux93d3esX78ehoaa+3Pk0qVL0ahRI431r0nNmzfHnj174ObmppH+TUxMMHv2bMyfP18j/VPJ1bJlS+zfvx/VqlXTdioyTExM8NdffylVhEleH7/88ovSE9OVMXr0aDRv3lztfsaOHYtZs2aJkJF8pekYryn169fHoUOHdPpY1Lt3b9ja2gqO79mzp05OyjcwMCjW7Tk5OeHvv/9G06ZNNbYNR0dH7Ny5U61t2NvbY8uWLSrvc3R5P2BoaIglS5Zg7ty5MDU11WouxsbGWL16tcbO27StUqVKmDt3rtr91KtXDzt37oSDg4MIWREREREREREREREREWkfizAQEREREREREREREZFKnj9/jsePHwuKrVWrFqpXry7q9s3MzAQ/xTopKQm+vr4K47p3744TJ06gR48eGp08roiZmRmWL1+OTZs2oUaNGlrLAwCaNWuGEydOYMiQIRqZlGdgYIAmTZpg4cKFmD17tuj9K8PQ0BBTp07Fvn374OHhoZFtWFpaolevXtiyZYtGJ/apY9GiRRg+fLjK67dv3x47d+6EtbW1iFnJsrW1xe7duzF27FilJpjqitq1a8PHxwejRo0SdXKhh4cHDhw4gJEjR4rWJ5UuNWvWxJEjR/DDDz+I9mTsgurUqYOZM2di5cqVSq1namqKP/74AwsXLoS9vb1S69arVw979+4VpdBMUYyMjLBp0ya0bdtWpfWtrKzw22+/YerUqSJnJqs0HeM1pWLFiti7dy/mzp2rkxOPLS0tlRrzulAETJ5Dhw5h6dKlaNOmjUaLRBgYGKBHjx44cuRIsZynOTg4YMeOHZg4cSLMzMyUWrd9+/Y4cuQImjVrplYOur4fGD58OHx8fNCuXTvRc1OGi4sL/v33XwwaNAgWFhZazUUT+vfvj6VLl6p8Ddy7d2/8888/cHZ2FjkzIiIiIiIiIiIiIiIi7THWdgJERERERERERERERKSffHx8BMd2795dIzl07doVx44dExTr4+MjKI9y5cph1apVGD9+PPbu3YsTJ04gNjZWpfysra3RoUMH9OzZU6X127dvj7Zt2+L8+fM4dOgQrl69iuzsbJX6cnNzw+eff47OnTsrva6NjQ3mz5+P0aNHY//+/Thy5AjevHmjUh7Ah/elWbNmaNmyJTw9PeHq6qpyX5rQsGFD7Nu3D9euXcP+/fvh5+eHjIwMlfurXLkyWrZsiVatWqF9+/Y6P3HL2NgYc+fORevWrfH777/jyZMngtYrX748JkyYgP79+2s4w/9jYmKCqVOnYuzYsTh//jzu3buHx48fIyoqCklJSUhJSUFubq7K/U+cOBETJ04UMWNpFhYWmDVrFoYNG4bdu3fDx8cH0dHRSvdjbGyMtm3bYtCgQWjfvr0GMqXSxtTUFJMmTcKQIUNw8OBBHD58GC9fvlS5P3NzczRp0gQtW7ZEx44dUbNmTbXyGzRoEL744gvs378fx44dw7NnzwrdbosWLdCvXz907ty52AosWVhYYOPGjdizZw/+/PNPxMXFKVzHxMQEPXr0wNSpU4v1qfSl7RivCUZGRhg+fDj69euHw4cPw9vbG4GBgSr1ZWhoiMaNG+Pzzz9H5cqVRcnvm2++wfbt2xUeD93d3VGnTh1Rtik2BwcH9O/fH/3790dCQgKuXLkCf39/3LlzB8+fP1frWJ/f/2effYYhQ4agVq1aImUtjLGxseT8ae/evTh9+nSh+1sbGxu0bdsWgwcPVrv4QsF+dXk/UL16dWzevBkPHz7E3r17cfbsWSQnJ6vUl6OjIzw9PVUqOGJtbY2FCxfixx9/xJkzZ/DgwQM8fvwYMTExSEpKQmpqKvLy8lTKSxf0798fNWrUwIoVK3Dv3j1B69StWxc//vij1otkEBERERERERERERERaYJBnj7/9YeIiIiIiIiIiIiIiEjDcnNz8ejRI/j7++PJkyd49eqVZIJ3RkYGDA0NYWFhAWtra1SsWBGVK1dG7dq10aRJE9SrVw/GxuLVxE5OTsaNGzfw4MEDBAUFITIyEu/evUNaWhqysrJgamoKCwsLODo6wtXVFVWqVEHDhg3RpEkTuLi4iJYHADx9+hS3bt3CkydP8PLlS0RFRSEhIUFSrMDKygpWVlawtraGi4sLqlatimrVqqF27dpwd3eHkZGRqPloUnp6Om7evIkHDx7g2bNneP36NaKjo5GSkoLMzEyYmppKfl57e3tUqVIF1apVQ7Vq1dCwYUNUrFhR2z+CWm7evIlLly7hzp07ePPmDeLj45GTkwMrKyu4urqiXr16aN++Pdq3by/zBOWcnBzBRQWcnZ31alxoQl5eHh49eoRbt27h8ePHCA0Nxbt375CcnIyMjAwYGRlJPuMuLi6oXbs2GjZsiNatW8PW1lbb6VMJ9/LlS9y8eROPHz9GSEgI3r59i7i4OGRkZCA3NxeWlpaS/X758uUl+8GaNWuiYcOGMDU11VhusbGxCAkJQUxMDLKzs2FpaYmKFSuiatWqhW735s2bGDZsmKD+CyvyIERycjIuXryIy5cvIzAwEHFxcYiPj4exsTGcnJxQs2ZNfPrpp+jWrVuxFl8oSmk6xmvK27dvce3aNQQGBuLFixd4+/YtYmJikJ6ejpycHJibm8PS0hLOzs6oVKkSqlWrBg8PD3h4eMDOzk7UXGJjY9GmTRvk5OQUGTd//nwMGTJE1G0Xh6SkJAQEBCA0NBRhYWF49eoVIiMjkZycjNTUVKSmpiI9PR3GxsYwNzeHvb09nJ2d4ebmhlq1asHDwwMNGjQQZdyuW7cO69evVxjXvHlz7Nq1q9DXY2NjERwcjLi4OGRlZcHS0hKVKlWCm5ubqNcWRdHl/UBWVhbu3buHO3fu4OnTpwgPD5ecL2VmZsLQ0BCWlpawsbGBi4sLKleujHr16qFJkyaoVatWsRXk0Wd37tzBpUuXcPPmTbx7904yFm1sbFClShV4eHigc+fO+OSTT7SdKhERERERERERERERkcawCAMRERERERERERERERERERGVKsVVhIFI23bt2oWlS5cWGWNqaoorV66IXgCitBGrCAMRERERERERERERERERaR9LexMRERERERERERERERERERERlTDp6enYvn27wrjPPvuMBRiIiIiIiIiIiIiIiIiIiD7CIgxERERERERERERERERERERERCVIWloaZs6cidevXyuM/eabb4ohIyIiIiIiIiIiIiIiIiIi/WGs7QSIiIiIiIiIiIiIiIiIiIiIiEh5R44ckfw/NzcXSUlJePHiBXx9ffH+/XuF67u7u6NJkyaaTJGIiIiIiIiIiIiIiIiISO+wCAMRERERERERERERERERERERkR6aOXOmWutPnDhRpEyIiIiIiIiIiIiIiIiIiEoOQ20nQERERERERERERERERERERERExat58+bo2LGjttMgIiIiIiIiIiIiIiIiItI5LMJARERERERERERERERERERERFSKWFpaYsmSJdpOg4iIiIiIiIiIiIiIiIhIJ7EIAxERERERERERERERERERERFRKWFgYIAlS5bAzc1N26kQEREREREREREREREREekkFmEgIiIiIiIiIiIiIiIiIiIiIioFjIyMsGzZMvTo0UPbqRARERERERERERERERER6SwWYSAiIiIiIiIiIiIiIiIiIiIiKuEaNGiAgwcPom/fvtpOhYiIiIiIiIiIiIiIiIhIpxlrOwEiIiIiIiIiIqL/x96dR+lV13ni/9xak8q+QGWpAgWUnUAkhFTFHkWgtXUcQH/ToDTjBtqAIy7d0y6ntdt2OWO7saktAj2Otowb0w4wNga1zVMhJBDCKpqApCorIUkFUqklVff3B5OSJ0k9VZVU3ed5ql6vc+qcfO/3c+99X1TO9+CpNwAAAACMnNra2pg6dWocc8wxsWDBgvjTP/3TOPPMM4sdCwAAAAAAAKAsJGmapsUOAQAAAAAAAAAAAAAAAAAAAFBsFcUOAAAAAAAAAAAAAAAAAAAAAFAKlDAAAAAAAAAAAAAAAAAAAAAAhBIGAAAAAAAAAAAAAAAAAAAAgIhQwgAAAAAAAAAAAAAAAAAAAAAQEUoYAAAAAAAAAAAAAAAAAAAAACJCCQMAAAAAAAAAAAAAAAAAAABARChhAAAAAAAAAAAAAAAAAAAAAIgIJQwAAAAAAAAAAAAAAAAAAAAAEaGEAQAAAAAAAAAAAAAAAAAAACAilDAAAAAAAAAAAAAAAAAAAAAARIQSBgAAAAAAAAAAAAAAAAAAAICIiKgqdgCgeNrbOyIioru7t8hJAABg/KqpqcxbO58DAEDxOJ8DAEDpcD4HAIDS4XwOAAClY//5fNq0uiIngbGtotgBAAAAAAAAAAAAAAAAAAAAAEqBEgYAAAAAAAAAAAAAAAAAAACAUMIAAAAAAAAAAAAAAAAAAAAAEBFKGAAAAAAAAAAAAAAAAAAAAAAiQgkDAAAAAAAAAAAAAAAAAAAAQEQoYQAAAAAAAAAAAAAAAAAAAACICCUMAAAAAAAAAAAAAAAAAAAAABGhhAEAAAAAAAAAAAAAAAAAAAAgIpQwAAAAAAAAAAAAAAAAAAAAAESEEgYAAAAAAAAAAAAAAAAAAACAiFDCAAAAAAAAAAAAAAAAAAAAABARShgAAAAAAAAAAAAAAAAAAAAAIkIJAwAAAAAAAAAAAAAAAAAAAEBEKGEAAAAAAAAAAAAAAAAAAAAAiAglDAAAAAAAAAAAAAAAAAAAAAARoYQBAAAAAAAAAAAAAAAAAAAAICKUMAAAAAAAAAAAAAAAAAAAAABEhBIGAAAAAAAAAAAAAAAAAAAAgIhQwgAAAAAAAAAAAAAAAAAAAAAQEUoYAAAAAAAAAAAAAAAAAAAAACJCCQMAAAAAAAAAAAAAAAAAAABARChhgHHt2GOvj//4H++If/u3p4sdBQAAAAAAAAAAAAAAAAAAoOiUMMA41t7eFb/5zYa4/PI745vffLDYcQAAAAAAAAAAAAAAAAAAAIpKCQMQERFf/GIutm3bU+wYAAAAAAAAAAAAAAAAAAAARaOEAYiIiI6OfXHHHU8UOwYAAAAAAAAAAAAAAAAAAEDRKGEA+uVyrcWOAAAAAAAAAAAAAAAAAAAAUDRKGIB+K1dujJ6e3mLHAAAAAAAAAAAAAAAAAAAAKAolDEC/PXt6Yu3arcWOAQAAAAAAAAAAAAAAAAAAUBRKGIA8LS1txY4AAAAAAAAAAAAAAAAAAABQFEoYgDzLl7cWOwIAAAAAAAAAAAAAAAAAAEBRKGEA8jzwwMbo6ektdgwAAAAAAAAAAAAAAAAAAIDMKWEA8nR07IuHH95a7BgAAAAAAAAAAAAAAAAAAACZU8IAHCSXay12BAAAAAAAAAAAAAAAAAAAgMwpYQAOksu1FTsCAAAAAAAAAAAAAAAAAABA5pQwAAdZtWpjdHf3FjsGAAAAAAAAAAAAAAAAAABAppQwAAfp6NgXa9ZsKXYMAAAAAAAAAAAAAAAAAACATClhAA4pl2stdgQAAAAAAAAAAAAAAAAAAIBMKWEADimXayt2BAAAAAAAAAAAAAAAAAAAgEwpYQAOadWqjdHVta/YMQAAAAAAAAAAAAAAAAAAADKjhAE4pM7O3lizZkuxYwAAAAAAAAAAAAAAAAAAAGRGCQMwoOXLW4sdAQAAAAAAAAAAAAAAAAAAIDNKGGAcO+646QX3W1rasgkCAAAAAAAAAAAAAAAAAABQApQwwDj22tceU3B/9epN0dm5L6M0AAAAAAAAAAAAAAAAAAAAxaWEAcaxpUsbC+53dvbGQw9tzigNAAAAAAAAAAAAAAAAAABAcSlhgHFs6dJjBp3J5doySAIAAAAAAAAAAAAAAAAAAFB8ShhgHJs7d3KccMKMgjO5XGtGaQAAAAAAAAAAAAAAAAAAAIpLCQOMc6997TEF9x98cHN0du7LKA0AAAAAAAAAAAAAAAAAAEDxKGGAcW7p0saC+11dvbF69aaM0gAAAAAAAAAAAAAAAAAAABSPEgYY55qbC5cwRETkcm0ZJAEAAAAAAAAAAAAAAAAAACguJQwwzs2ZMzle9aqZBWdyudaM0gAAAAAAAAAAAAAAAAAAABSPEgYgmpoaCu4/9NCW6OjoySgNAAAAAAAAAAAAAAAAAABAcShhAGLp0saC+93dvfHgg5szSgMAAAAAAAAAAAAAAAAAAFAcShiAWLKkYdCZXK41gyQAAAAAAAAAAAAAAAAAAADFo4QBiKOPnhQnnjir4Ewu15ZRGgAAAAAAAAAAAAAAAAAAgOJQwgBERERTU0PB/Yce2hwdHT0ZpQEAAAAAAAAAAAAAAAAAAMieEgYgIiKWLm0suN/T0xerVm3KKA0AAAAAAAAAAAAAAAAAAED2lDAAERFx7rkNg87kcq0ZJAEAAAAAAAAAAAAAAAAAACgOJQxAREQcdVRdnHTSrIIzuVxbRmkAAAAAAAAAAAAAAAAAAACyp4QB6Nfc3Fhwf82aLfHii90ZpQEAAAAAAAAAAAAAAAAAAMiWEgagX1NTQ8H9ffv6YtWqTRmlAQAAAAAAAAAAAAAAAAAAyJYSBqBfU1PjoDMtLW0ZJAEAAAAAAAAAAAAAAAAAAMieEgag36xZE+Pkk2cXnFm+vDWjNAAAAAAAAAAAAAAAAAAAANlSwgDkWbq0seD+ww9viRdf7M4oDQAAAAAAAAAAAAAAAAAAQHaUMAB5mpoaCu739qbxwAMbM0oDAAAAAAAAAAAAAAAAAACQHSUMQJ6mpoZIksIzuVxbNmEAAAAAAAAAAAAAAAAAAAAypIQByDNjxsQ45ZSjCs7kcq0ZpQEAAAAAAAAAAAAAAAAAAMiOEgbgIM3NDQX3167dGi+80JVRGgAAAAAAAAAAAAAAAAAAgGwoYQAO0tzcWHC/tzeNlSs3ZpQGAAAAAAAAAAAAAAAAAAAgG0oYgIMsWdIQSVJ4JpdryyYMAAAAAAAAAAAAAAAAAABARpQwAAeZPn1CnHba0QVnWlpaM0oDAAAAAAAAAAAAAAAAAACQDSUMwCE1NTUU3F+7dlvs3t2VURoAAAAAAAAAAAAAAAAAAIDRp4QBOKSlSxsL7vf1pbFy5caM0gAAAAAAAAAAAAAAAAAAAIw+JQzAIZ177vyoqEgKzixf3ppRGgAAAAAAAAAAAAAAAAAAgNGnhAE4pGnTJsTppx9dcKalpS2jNAAAAAAAAAAAAAAAAAAAAKNPCQMwoKamhoL7jz66LdrbOzNKAwAAAAAAAAAAAAAAAAAAMLqUMAADam5uLLjf15fG/fdvzCgNAAAAAAAAAAAAAAAAAADA6FLCAAzo3HPnR0VFUnBm+fLWjNIAAAAAAAAAAAAAAAAAAACMLiUMwICmTq2NM844uuBMS0tbRmkAAAAAAAAAAAAAAAAAAABGlxIGoKDm5saC+489ti127erMKA0AAAAAAAAAAAAAAAAAAMDoUcIAFNTc3FBwP00jVqxoyygNAAAAAAAAAAAAAAAAAADA6FHCABS0ePH8qKxMCs60tChhAAAAAAAAAAAAAAAAAAAAyp8SBqCgKVNqY8GC+oIzy5e3ZpQGAAAAAAAAAAAAAAAAAABg9ChhAAbV3NxYcP+JJ56LnTv3ZpQGAAAAAAAAAAAAAAAAAABgdChhAAbV3NxQcD9NI1pa2jJKAwAAAAAAAAAAAAAAAAAAMDqUMACDOuec+VFZmRScUcIAAAAAAAAAAAAAAAAAAACUOyUMwKAmT66JM8+cU3Bm+fLWjNIAAAAAAAAAAAAAAAAAAACMDiUMwJA0NzcU3H/yye3x/PN7M0oDAAAAAAAAAAAAAAAAAAAw8pQwAEPS3Nw46MyKFW0ZJAEAAAAAAAAAAAAAAAAAABgdShiAIVm0aF5UVRX+W0Yu15pRGgAAAAAAAAAAAAAAAAAAgJGnhAEYksmTa+Kss+YUnGlpUcIAAAAAAAAAAAAAAAAAAACULyUMwJA1NzcU3H/yyedj+/aOjNIAAAAAAAAAAAAAAAAAAACMLCUMwJA1NzcOOrNiRVsGSQAAAAAAAAAAAAAAAAAAAEaeEgZgyM4+e15UVxf+28by5a0ZpQEAAAAAAAAAAAAAAAAAABhZShiAIZs0qTrOOmtOwZmWlraM0gAAAAAAAAAAAAAAAAAAAIwsJQzAsCxd2lhw/6mnno9t2/ZklAYAAAAAAAAAAAAAAAAAAGDkKGEAhqWpqXAJQ0TEihVtGSQBAAAAAAAAAAAAAAAAAAAYWUoYgGE5++y5UVNTWXAml1PCAAAAAAAAAAAAAAAAAAAAlB8lDMCw1NVVx8KFcwrO5HKtGaUBAAAAAAAAAAAAAAAAAAAYOVXFDsD4s2HDhnjkkUdiy5Yt0dPTE1OnTo3jjjsuFi5cGLW1tSP2nq6urnjooYfi6aefjt27d0d1dXXMmTMnFixYEI2NjSP2nojsvqlUNDc3xv33bxxw//e/3xFbt+6J+vpJGaYCAAAAAAAAAAAAAAAAAAA4MkoYStTWrVvjkUceibVr18YjjzwSjz32WOzZs6d/f/78+XHfffcd1rNPPPHEI8q2bNmyaGhoGPZ9v/jFL+Lmm2+Oxx9//JD7dXV1cckll8Q111wTM2fOPOx8O3bsiBtvvDF++tOfRkdHxyFnTj311Lj66qvj/PPPP+z3RGT3TaWmubkhvvzlwjMtLa1x8cUnZRMIAAAAAAAAAAAAAAAAAABgBCRpmqbFDsFLHnzwwbjtttti7dq1sW3btoKz5VTC0N3dHZ/4xCfiZz/72ZDmZ86cGddff30sWrRo2NlWrlwZH/rQh2Lnzp1Dmr/ooovis5/9bNTU1AzrPVl+02hqb3+ppKK7u3dY93V27otXveqm6Ooa+L4rrjgj/vEfj6zkAgAAxoOamsq89XDP5wAAwMhxPgcAgNLhfA4AAKXD+RwAAErH/vP5tGl1RU4CY1tFsQPwR48++mjce++9gxYwlJO+vr647rrrDiorqKysjIaGhjj55JNjypQpeXs7duyIK6+8MtasWTOsd61evTquuuqqgwoYpk6dGqecckrMnz8/Kivz/+HPnXfeGR/96EdjOF0kWX5TqZowoSpe85q5BWdyudaM0gAAAAAAAAAAAAAAAAAAAIyMqmIHYGjq6uqio6NjxJ974oknxt/8zd8M656jjjpqyLO33HJLLFu2LO/apZdeGldffXXU19dHxEulBsuWLYvPf/7zsWnTpoiI2Lt3b1x33XXxf/7P/zmo0OBQ2tvb48Mf/nB0dnb2X5s/f3584hOfiDe84Q2RJElERGzZsiVuvvnmuOOOO/rn/u3f/i1uv/32ePe7311S31TqmpoaoqWlbcD99et3xpYtL8acOZMzTAUAAAAAAAAAAAAAAAAAAHD4lDCUoEmTJsWpp54ap59+epxxxhlx+umnR1tbW1xxxRUj/q5p06ZFU1PTiD83ImLnzp3xzW9+M+/aRz/60bjqqqvyrlVUVMQFF1wQZ5xxRlx22WWxcePGiHipMOG2226L//pf/+ug7/rOd74T27Zt6183NDTE97///f5ShP3mzJkTf//3fx/z5s2Lr371q/3Xb7rpprjkkkti2rRpJfNNpW7p0sb4x3+8v+BMLtcab3vbyRklAgAAAAAAAAAAAAAAAAAAODIVxQ7AH5133nlx1113xerVq+O73/1u/PVf/3W88Y1vjPnz5xc72mG55ZZbYs+ePf3rRYsWxZVXXjngfH19fXzuc5/Lu3b77bfHzp07C75nx44d8d3vfjfv2j/8wz8cVMDwcu9///tj0aJF/esXXnghbr311oLvicjum8rBwoVzo7a2suBMS0tbRmkAAAAAAAAAAAAAAAAAAACOnBKGEnLMMcfECSecEBUV5f8fS19fX/zkJz/Ju3bttddGkiQF71uyZEmcffbZ/es9e/bEPffcU/Ceu+66Kzo6OvrXixYtiiVLlhS8J0mSuOaaa/Ku/fjHP440TQe8J8tvKgcTJlTFokXzCs7kcq0ZpQEAAAAAAAAAAAAAAAAAADhy5f/b/pSkhx56KHbs2NG/bmxsjMWLFw/p3re//e1562XLlhWcP3D/wPsHcu6550ZDQ0P/+rnnnouHH354wPksv6lcNDU1FNx/+uldsXnzCxmlAQAAAAAAAAAAAAAAAAAAODJKGBgVv/71r/PWTU1NkSTJkO5tamrKW69cuTI6OjoOObtnz55YvXp13rXm5uYhvSdJkoPe9atf/WrA+ay+qZwsXdo46Ewu15ZBEgAAAAAAAAAAAAAAAAAAgCOnhIFR8eSTT+atFy5cOOR76+vrY/78+f3rnp6eWLdu3SFn161bFz09Pf3rhoaGOOqoo4b8rgNzHZi70N5ofVM5OeusOTFhQmXBmVyuNaM0AAAAAAAAAAAAAAAAAAAAR0YJAxERsW3btnjsscdi1apV8dRTT8W2bduO6HlPP/103vr4448f1v0nnHBCweftt379+oL3DebAXAc+r1CG0fqmclJbWxWLFs0vOKOEAQAAAAAAAAAAAAAAAAAAKBdVxQ5Acf3ud7+LN7zhDdHW1nbQ3lFHHRWLFi2Kiy++OP7kT/5kyM/s7OyMTZs25V2bO3fusHLNmTMnb/3MM88ccu7A6wfeN5gDc23atCm6urqitrY273qW31Rumpsb4je/2TDg/h/+0B4bN74Q8+dPyTAVAAAAAAAAAAAAAAAAAADA8ClhGOd27doVu3btOuTec889F3fffXfcfffdccopp8QXv/jFOPHEEwd95s6dOyNN0/51dXV1zJo1a1i56uvr89bPP//8IecOvD7cEobZs2dHVVVV7Nu3LyIi+vr6YteuXQe9P8tvylJVVeURP+M//Idj44tfbCk4s3Llxrj00lOP+F0AADAWjcS5HAAAGBnO5wAAUDqczwEAoHQ4nwMAQOlwPodsVBQ7AOXhiSeeiP/8n/9z3HPPPYPOdnR05K0nTJgQSZIM6311dXUFnznQ9YkTJw7rPUmSRG1tbd61PXv2DPqe0fymcvOa18yNiRML97n85jcbMkoDAAAAAAAAAAAAAAAAAABw+Ar/5jRj1owZM+L1r399LFmyJE488cSYM2dOTJo0KTo6OmLTpk3x4IMPxv/6X/8rfvvb3/bf09nZGX/1V38Vs2fPjkWLFg347ANLDA4sORiKA+8ZagnD4bxrwoQJeZkP9a4sv6nc1NRUxuLF8+NXv3p2wJnly1szTAQAAAAAAAAAAAAAAAAAAHB4lDCMQ1/60pfijW98Y9TU1By0N3Xq1Jg6dWqcdNJJ8c53vjN+8IMfxOc+97no7u6OiIienp746Ec/Gvfee++ARQT7Z/errq4edsYDs3V2dh5yrqurK5N3ZflN5ei1rz2mYAnDs8+2x4YN7XHMMdMyTAUAAAAAAAAAAAAAAAAAADA8ShjGobe+9a1Dnr300ktj5syZ8aEPfSj6+voiImLr1q3xve99L97znvcc8p4DywZ6enqGnfHA0oOBCh8OvD5a78rym7K0b19vRER0d/ce0XMWL54/6MyvfvVsXHrpqUf0HgAAGA+O9HwOAACMHOdzAAAoHc7nAABQOpzPAQAAGOsqih2A0nfhhRfGf/pP/ynv2v/+3/97wPlJkyblrbu6uob9zgPvqaurO+TcgdcP512dnZ2DvivLbypHZ51VH3V1hTtdWlraMkoDAAAAAAAAAAAAAAAAAABweJQwMCTvfve789ZPPfVUbN++/ZCzB5YLdHZ2Rpqmw3pfR0dHwWcOdH3v3r3Dek+apgeVIxxYuHCo94zmN5Wj6urKOOec+QVncrnWjNIAAAAAAAAAAAAAAAAAAAAcHiUMDMmJJ54Ys2bN6l+naRp/+MMfDjk7Y8aMSJKkf93T0xPPP//8sN63devWvPXL313o+pYtW4b1nu3bt8e+ffv61xUVFTFjxoyD5rL8pnK1dGljwf3W1t2xYUN7RmkAAAAAAAAAAAAAAAAAAACGTwkDQzZnzpy89Y4dOw45N2HChJg3b17etU2bNg3rXZs3b85bH3fccYece+UrX1nwvuG+Z968eVFbW3vQXJbfVK6amhoGncnlWjNIAgAAAAAAAAAAAAAAAAAAcHiUMDBkVVVVeet9+/YNOHtgOcL69euH9a4D5wcqLDjw+rp160blPRHZfVO5WrCgPurqqgvO5HJtGaUBAAAAAAAAAAAAAAAAAAAYPiUMDNn27dvz1jNmzBhw9uSTT85br1mzZsjv2bZtW2zcuLF/XV1dHccff/whZ0844YSorv7jL/5v3Lgxtm3bNuR3PfTQQ3nrA3MX2hutbypX1dWVce658wvO5HKtkaZpRokAAAAAAAAAAAAAAAAAAACGRwkDQ7Jly5a8EoGIiLlz5w44/7rXvS5v3dLSMuRfvs/lcnnrxYsXx6RJkw45O3ny5Dj77LMPetdQpGl60OzrX//6Aeez+qZy1tTUUHB/48YX4tln2zNKAwAAAAAAAAAAAAAAAAAAMDxKGBiSH/3oR3nruXPnxite8YoB5xcuXBgzZszoX7e2tsbKlSsP613nnXdewfkD9w+8fyD3339/tLW19a9nz54dCxYsGHA+y28qV0uXNg4609LSNugMAAAAAAAAAAAAAAAAAABAMShhYFDr16+PW2+9Ne/a+eefX/CeioqKuPjii/Ou3XTTTZGmacH7VqxYEatXr+5fT5o0Kd70pjcVvOfNb35z1NXV9a9XrVoVK1asKHhPmqZx00035V275JJLoqJi4P9JZPlN5eqMM+pj8uSagjPLl7dmlAYAAAAAAAAAAAAAAAAAAGB4lDCMI08++WTcfvvtsXfv3mHd8773vS/27NnTf23ChAlx5ZVXDnrvlVdemVeO8MADD8S3v/3tAee3bt0an/zkJ/OuXXHFFTFz5syC75k1a1a8853vzLv2qU99KrZu3TrgPd/61rdi1apV/espU6bEe9/73oLvicjum8pVVVVFnHvu/IIzLS2tgxZXAAAAAAAAAAAAAAAAAAAAFENVsQOQ78EHH4yurq6Drv/2t7/NW3d1dUVLS8shn3H00UfHCSeccND13bt3xxe+8IX4xje+ERdeeGGcf/75cfrppx9UCJCmafzud7+LH/7wh3HHHXdEd3d33v5HPvKRqK+vH/RbZs6cGR/4wAfiK1/5Sv+1L3/5y7Fp06b4y7/8y/5n9PX1xX333Ref+9znYtOmTXnf8Z73vGfQ90REvO9974s777wznnvuuYiIaGtri8suuyw++clPxnnnnRdJkkRExJYtW+Lmm2+OO+64I+/+D3zgAzF9+vSS+qZy1dTUEL/4xTMD7m/a9GI888yuOO64GRmmAgAAAAAAAAAAAAAAAAAAGFyS+lfSl5TzzjsvNm7ceETPuPjii+OLX/ziQddXrlwZV1xxxUHXZ8+eHTNmzIhJkyZFR0dHbN26Ndrb2w/57Pe85z3x3/7bfxtylr6+vrj66qvjl7/8Zd71ysrKmDdvXkyZMiXa2tpi9+7defsTJkyIW2+9NV7zmtcM+V2rVq2K9773vQeVWEydOjUaGhpi9+7dsXnz5ujt7c3bf8Mb3hA33XRTf1FDKX3TaGtv74iIiO7u3kEmh+7hh7fEhRd+v+DMV75yQVx++ekj9k4AAChnNTWVeeuRPJ8DAADD43wOAAClw/kcAABKh/M5AACUjv3n82nT6oqcBMa2imIHoPi2b98ev//97+Phhx+O3/3ud4csYJg8eXJ86UtfGlYBQ0RERUVFfP3rX483v/nNedd7e3ujtbU1nnjiiYPKCqZPnx7/9E//NOyygkWLFsW3vvWtmD59et713bt3xxNPPBFtbW0HFTC85S1via997WtDLmDI+pvK0WmnHR1TptQUnFm+vDWjNAAAAAAAAAAAAAAAAAAAAEOnhGEcefWrXx0f+9jH4rWvfe1BRQUDOe644+Kv/uqv4r777ou3vvWth/Xe2tra+MpXvhLXX399nHzyyQPO1dXVxTve8Y64++67Y/HixYf1riVLlsRdd90Vl112WUycOHHAuVNOOSVuuOGG+PKXvxw1NYULAw4ly28qN1VVFXHuufMLzrS0tEaaphklAgAAAAAAAAAAAAAAAAAAGJok9ZvQ49bGjRvj2WefjU2bNsXu3bujs7MzamtrY+rUqXH00UfHGWecETNmzBjx9z777LOxdu3a2Lp1a/T09MTUqVPj+OOPj4ULF0Ztbe2IvaezszPWrFkT69evj927d0d1dXXU19fHggUL4thjjx2x90Rk900jrb29IyIiurt7R/S5N9+8Oj7zmX8vOLNixbvj+ONH/r9fAABQbmpqKvPWI30+BwAAhs75HAAASofzOQAAlA7ncwAAKB37z+fTptUVOQmMbUoYYBwbrRKGtWu3xgUXfK/gzD/+4/lxxRVnjOh7AQCgHPk/qQEAoHQ4nwMAQOlwPgcAgNLhfA4AAKVDCQNko6LYAYCx57TTjoqpU2sLzrS0tGaUBgAAAAAAAAAAAAAAAAAAYGiUMAAjrrKyIpYsmV9wZvnytkjTNKNEAAAAAAAAAAAAAAAAAAAAg1PCAIyK5ubGgvvbtu2J9et3ZpQGAAAAAAAAAAAAAAAAAABgcEoYgFExWAlDRMTy5a0ZJAEAAAAAAAAAAAAAAAAAABgaJQzAqDj11KNi+vTagjMtLW0ZpQEAAAAAAAAAAAAAAAAAABicEgZgVFRUJHHuuQ0FZ3K51kjTNKNEAAAAAAAAAAAAAAAAAAAAhSlhAEbN0qWNBfefe64jfv/7HRmlAQAAAAAAAAAAAAAAAAAAKEwJAzBqmpoKlzBERCxf3ppBEgAAAAAAAAAAAAAAAAAAgMEpYQBGzSmnzI4ZMyYUnGlpacsoDQAAAAAAAAAAAAAAAAAAQGFKGIBRU1GRxJIlDQVnWlpaI03TjBIBAAAAAAAAAAAAAAAAAAAMTAkDMKqamwuXMGzfvjeeeur5jNIAAAAAAAAAAAAAAAAAAAAMTAkDMKqamxsHncnl2jJIAgAAAAAAAAAAAAAAAAAAUJgSBmBUnXTS7Jg5c0LBmVyuNaM0AAAAAAAAAAAAAAAAAAAAA1PCAIyqiookmpoaC86sWNEWfX1pRokAAAAAAAAAAAAAAAAAAAAOTQkDMOqamxsK7j///N747W+3Z5QGAAAAAAAAAAAAAAAAAADg0JQwAKOuublx0JmWlrYMkgAAAAAAAAAAAAAAAAAAAAxMCQMw6k48cVbMmjWx4Mzy5a0ZpQEAAAAAAAAAAAAAAAAAADg0JQzAqEuSJJqaGgrOrFjRFn19aUaJAAAAAAAAAAAAAAAAAAAADqaEAchEc3Njwf2dOzvjiSe2Z5QGAAAAAAAAAAAAAAAAAADgYEoYgEwMVsIQEdHS0ppBEgAAAAAAAAAAAAAAAAAAgENTwgBk4tWvnhmzZ9cVnMnllDAAAAAAAAAAAAAAAAAAAADFo4QByESSJNHc3FBwZsWKtujrSzNKBAAAAAAAAAAAAAAAAAAAkE8JA5CZ5ubGgvu7dnXF448/l1EaAAAAAAAAAAAAAAAAAACAfEoYgMwMVsIQEZHLtWaQBAAAAAAAAAAAAAAAAAAA4GBKGIDMnHDCjDj66EkFZ1pa2jJKAwAAAAAAAAAAAAAAAAAAkE8JA5CZJEmiubmh4ExLS1v09vZllAgAAAAAAAAAAAAAAAAAAOCPlDAAmWpqaiy4v3t3Vzz++HMZpQEAAAAAAAAAAAAAAAAAAPijqmIHGA09PT2xfv362LlzZ+zatSu6uroiIuKiiy4qbjAgli4tXMIQEbF8eWuccUZ9BmkAAAAAAAAAAAAAAAAAAAD+aMyUMHR1dcUPf/jDuPfee2Pt2rX9xQsvV6iEYcWKFfHCCy/0r0888cQ49thjRyMqjGvHHTc96usnxdatewacaWlpi6uvPjvDVAAAAAAAAAAAAAAAAAAAAGOkhOH73/9+3HjjjbFz586IiEjT9KCZJEkKPmPlypXxrW99q3/9+te/Pm6++eaRDQpEkiTR3NwYP/nJbwecWbGiLXp7+6KysiLDZAAAAAAAAAAAAAAAAAAAwHhX1r/h3NnZGR/96Efjs5/9bOzYsaO/fCFJkryfobjiiiuipqYmIl4qcfj3f//32LFjx6hlh/Gsubmh4P4LL3THo49uyygNAAAAAAAAAAAAAAAAAADAS8q2hCFN0/jIRz4Sd999d6Rp2l+4kKZp3s9QzZw5My688ML+e3p7e2PZsmWjFR/GtebmxkFncrm2DJIAAAAAAAAAAAAAAAAAAAD8UdmWMNxwww1x3333RUT0ly9UVVXF29/+9rjxxhvjzjvvjOOPP35Yz3zjG9/Y/7yIiFwuN7KhgYiIeOUrp8fcuZMLzuRyrRmlAQAAAAAAAAAAAAAAAAAAeElVsQMcjq1bt8Ytt9zSX5aQpmmceOKJceONN0ZjY2P/XHV19bCe+9rXvjYmTJgQXV1dkaZprFy5ckRzAy9JkiSamxvjRz96csCZ++/fGPv29UVVVdl2xQAAAAAAAAAAAAAAAAAAAGWmLH+7+Z/+6Z+iu7s7Il4qYDj22GPje9/7Xl4Bw+GoqamJk046KdI0jYiIXbt2xbZt2444L3Cw5uaGgvsvvtgdjzyyNaM0AAAAAAAAAAAAAAAAAAAAZVrCcO+990aSJJGmaSRJEv/wD/8QkydPHpFnn3baaXnrp59+ekSeC+Rrahq8NCWXa8sgCQAAAAAAAAAAAAAAAAAAwEvKroRh/fr1sW3btv71KaecEosWLRqx5zc0NOStN2/ePGLPBv7oFa+YFvPnTyk4k8u1ZpQGAAAAAAAAAAAAAAAAAACgDEsY1q1b1//nJEmiubl5RJ8/derUvPWLL744os8HXpIkSTQ1NRScWblyY/T09GaUCAAAAAAAAAAAAAAAAAAAGO/KroRhx44dERGRpmlERBx77LEj+vxJkyZFxEu/IB4R0dHRMaLPB/5o6dLGgvt79vTEI49syygNAAAAAAAAAAAAAAAAAAAw3pVdCcPu3bvz1lOmTBnR5+8vXdhf8lBbWzuizwf+qKmpcAlDREQu15pBEgAAAAAAAAAAAAAAAAAAgDIsYZg8eXLees+ePSP6/B07duStp0+fPqLPB/7o2GOnRWPj1IIzShgAAAAAAAAAAAAAAAAAAICslF0Jw8yZMyMiIkmSiIh47rnnRvT5jz/+eN56xowZI/p8IF9TU0PB/ZUrN0VPT29GaQAAAAAAAAAAAAAAAAAAgPGs7EoY6uvr89aPPvroiD27t7c3Hnjggf6Ch4iIE088ccSeDxysubmx4H5HR088/PDWjNIAAAAAAAAAAAAAAAAAAADjWdmVMJx++ukxceLEiIhI0zRyuVzs2bNnRJ599913x/bt2/vXDQ0NMWfOnBF5NnBoTU0Ng87kcq0ZJAEAAAAAAAAAAAAAAAAAAMa7sithqK6ujsWLF0eaphERsXfv3viXf/mXI37uiy++GDfccEMkSRJpmkaSJLFkyZIjfi5Q2DHHTItjjplacCaXa8soDQAAAAAAAAAAAAAAAAAAMJ6VXQlDRMRFF10UEdFfmHDTTTfFunXrDvt5PT098bGPfSw2bNiQd/3yyy8/kpjAEDU3NxbcX7VqY3R392aUBgAAAAAAAAAAAAAAAAAAGK/KsoThjW98Y5xyyikR8VIRw969e+Nd73pXPPLII8N+1oYNG+Lyyy+PX//61/2lDkmSxOte97p49atfPdLRgUNoaipcwtDRsS/WrNmSURoAAAAAAAAAAAAAAAAAAGC8KssShoiIT3ziE1FZWRkRLxUxbN++PS677LL45Cc/GQ8//HDs27dvwHu3b98e99xzT3zkIx+JP/uzP4tHHnkk0jTt3580aVL8zd/8zah/A/CS5uaGQWdaWtoySAIAAAAAAAAAAAAAAAAAAIxnSfry9oEyc8cdd8SnP/3pSJIkIiLSNO3/c1VVVURE9PT0RMRLRQ2zZs2K3bt391/bf8/+/f33X3/99XHBBRdk+SlQFO3tHRER0d3dW+QkEYsWfSeefbZ9wP3XvvaY+PGP355hIgAAyEZNTWXeuhTO5wAAMF45nwMAQOlwPgcAgNLhfA4AAKVj//l82rS6IieBsa2i2AGOxJ//+Z/HRz7ykf7ihf1FCmmaRk9Pz0FlC9u3b4/u7u7+mf2lC/vvq6qqir/9279VwABFsHRpY8H91as3RVfXvozSAAAAAAAAAAAAAAAAAAAA41FZlzBERFx11VXxne98J2bNmpVXqjDUn4iXChpmzJgR3/72t+Oyyy4r8hfB+NTU1FBwf+/efbFmzZaM0gAAAAAAAAAAAAAAAAAAAONR2ZcwREQsWbIkfv7zn8fHPvaxOOqooyJN0/6fQ3n5/uTJk+Paa6+Ne++9N5YsWZJxcmC/5ubGQWdyubYMkgAAAAAAAAAAAAAAAAAAAONVkg7UVFCmenp6Ys2aNfHAAw/EmjVrYsuWLbFr165ob2+PCRMmxIwZM2LWrFmxYMGCaGpqinPOOScmTpxY7NhQFO3tHRER0d3dW+QkL1m8+NZ45pldA+4vXdoYP/nJ/5ddIAAAyEBNTWXeulTO5wAAMB45nwMAQOlwPgcAgNLhfA4AAKVj//l82rS6IieBsa2q2AFGWnV1dZxzzjlxzjnnFDsKMEzNzQ0FSxhWr94UnZ37YsKEMfe3LgAAAAAAAAAAAAAAAAAAoARUFDsAwH7NzY0F9zs7e+OhhzZnlAYAAAAAAAAAAAAAAAAAABhvlDAAJWOwEoaIiFyuLYMkAAAAAAAAAAAAAAAAAADAeKSEASgZc+ZMjuOPn1FwpqWlNaM0AAAAAAAAAAAAAAAAAADAeKOEASgpTU0NBfdXr94cnZ37MkoDAAAAAAAAAAAAAAAAAACMJ0oYgJKydGljwf2urt548MHNGaUBAAAAAAAAAAAAAAAAAADGEyUMQElpamoYdGb58tYMkgAAAAAAAAAAAAAAAAAAAONNVbED7HfFFVcUO8JBkiSJf/7nfy52DBhX6usnx6teNTN+//sdA860tChhAAAAAAAAAAAAAAAAAAAARl7JlDA88MADkSRJsWP0S9O0pPLAeNLU1FCwhOHBB7fE3r09MXFidYapAAAAAAAAAAAAAAAAAACAsa6i2AFGQpqmBX8OdxYojubmxoL73d29sXr15ozSAAAAAAAAAAAAAAAAAAAA40XJlTAMVpIwUHFCkiQD/rx8ttDcy98PFE9TU8OgM7lcawZJAAAAAAAAAAAAAAAAAACA8aSq2AH2W7Ro0WHf++ijj0ZXV1f/en+JQmVlZcydOzemTJkSEydOjL1798YLL7wQmzdvjt7e3oiIvPKFiRMnxmmnnXYEXwGMhKOPnhSvfvXM+N3vdgw4k8u1ZZgIAAAAAAAAAAAAAAAAAAAYD0qmhOG73/3usO/ZvXt3/PVf/3V0dnZGkiSRpmnMnj073vrWt8aFF14YJ598ctTW1h50X1dXVzz55JPx85//PH72s5/F9u3bI0mS6OzsjMmTJ8d//+//PaZMmTISnwUcpubmxoIlDA89tDk6Onqirq46w1QAAAAAAAAAAAAAAAAAAMBYlqRpmhY7xOHYtWtXXH755bF+/fqIiKioqIj3ve998Zd/+ZcxYcKEIT+nq6srbr755vjOd74Tvb29ERFx/PHHx//8n/8zpk+fPhrRoWS0t3dERER3d2+RkxzsX//1d/G+9/2fgjM//OHb4j/8h2MzSgQAAKOjpqYyb12K53MAABgvnM8BAKB0OJ8DAEDpcD4HAIDSsf98Pm1aXZGTwNhWUewAh+uDH/xgrFu3LtI0jaqqqvjKV74SH/7wh4dVwBARUVtbGx/+8Ifjq1/9alRVVUVExLp16+KDH/zgaMQGhmjJkoZBZ1pa2jJIAgAAAAAAAAAAAAAAAAAAjBdlWcJw5513xqpVqyJJkkiSJK655pr40z/90yN65gUXXBDXXnttpGkaERGrV6+On/zkJyMRFzgMRx1VFyedNKvgzPLlrRmlAQAAAAAAAAAAAAAAAAAAxoOyLGG49dZbIyIiTdM46qij4qqrrhqR577vfe+Lo48+OpIkiTRN47bbbhuR5wKHp7m5seD+mjVbYs+enozSAAAAAAAAAAAAAAAAAAAAY13ZlTC0tbXF7373u0iSJJIkiQsvvDAqKkbmMyorK+PCCy+MNE0jImLdunXR2to6Is8Ghq+pqaHg/r59ffHAAxszSgMAAAAAAAAAAAAAAAAAAIx1ZVfC8Pjjj0dE9BclnHDCCSP6/Fe96lWHfB+QvaamxkFnWlraMkgCAAAAAAAAAAAAAAAAAACMB2VXwrB58+a89fTp00f0+VOnTo2IiCRJIiJiy5YtI/p8YOhmzZoYJ588u+DM8uWtGaUBAAAAAAAAAAAAAAAAAADGurIrYejs7MxbP//88yP6/J07d0ZERJqmERHR1dU1os8Hhqe5uaHg/sMPb4kXX+zOKA0AAAAAAAAAAAAAAAAAADCWlV0Jw8yZMyMiIkmSiIh46qmnRvT5v/3tb/PWM2bMGNHnA8PT3NxYcL+3N40HHtiUURoAAAAAAAAAAAAAAAAAAGAsK7sShvr6+v4/p2ka9957b3R3d4/Is7u7u+Pee+/tL3iIiDj66KNH5NnA4VmypCFe9j/JQ8rlWrMJAwAAAAAAAAAAAAAAAAAAjGllV8KwYMGCqKqq6l/v2rUrrr/++hF59g033BA7d+7sX1dWVsZZZ501Is8GDs/MmRPjlFOOKjjT0qKEAQAAAAAAAAAAAAAAAAAAOHJlV8Iwffr0OPfccyNN00iSJNI0jVtvvTW+//3vH9Fzf/CDH8Qtt9zS/8wkSWLJkiUxbdq0EUoOHK7m5oaC+w8/vDVefLE7ozQAAAAAAAAAAAAAAAAAAMBYVXYlDBERV111VSRJEhERSZJEX19ffPazn42Pf/zjsWPHjmE9a8eOHfHxj388/u7v/i7SNM3be//73z9imYHD19zcWHC/tzeNlSs3ZpQGAAAAAAAAAAAAAAAAAAAYq6qKHeBwnHPOOXHJJZfEj3/840iSJJIkiTRN484774x77rknzjvvvLjgggvitNNOi8bGg395u7W1NR577LH4xS9+EcuWLYuurq5I07T/OUmSxNve9rY4++yzi/B1wIHOPXd+JEnEAT0peZYvb403vOGV2YUCAAAAAAAAAAAAAAAAAADGnCRNC/1ac+nq6uqK97///XH//fdHkiQREbH/U/avIyIqKytj0qRJUVdXFx0dHbFnz57o7e3t3z/wnjRNY8mSJfHNb34zamtrs/ocKIr29o6IiOju7h1ksvjOO++78dhjzw24f9ZZ9fHzn78zw0QAADAyamoq89blcD4HAICxyvkcAABKh/M5AACUDudzAAAoHfvP59Om1RU5CYxtFcUOcLhqa2vjW9/6Vrz+9a/PK1JIkiTSNO3/2bdvX7S3t8fmzZujvb099u3bl7e//56IlwoYzjvvPAUMUIKamxsL7q9duy127+7KKA0AAAAAAAAAAAAAAAAAADAWlW0JQ8RLRQzf+MY34vOf/3xMnTr1oDKGofxEvFS+MGXKlPjCF74QN998swIGKEGDlTD09aWxcuXGjNIAAAAAAAAAAAAAAAAAAABjUVmXMOx3ySWXxLJly+KTn/xkHH/88ZGm6ZB/jj/++PjUpz4V9913X1x88cXF/hRgAEuWzI//15syoFyuNZswAAAAAAAAAAAAAAAAAADAmJSkaZoWO8RI27x5czz88MPx+OOPx/PPPx8vvPBC7NmzJyZNmhRTpkyJWbNmxamnnhpnnnlmzJ07t9hxoWja2zsiIqK7u7fISYbm/PP/ZzzyyLYB9xcsqI97731nhokAAODI1dRU5q3L5XwOAABjkfM5AACUDudzAAAoHc7nAABQOvafz6dNqytyEhjbqoodYDTMnTs35s6dG29605uKHQUYQc3NjQVLGB59dFu0t3fGtGkTMkwFAAAAAAAAAAAAAAAAAACMFRXFDgAwVM3NjQX3+/rSuP/+jRmlAQAAAAAAAAAAAAAAAAAAxholDEDZOPfc+VFRkRScyeXaMkoDAAAAAAAAAAAAAAAAAACMNUoYgLIxdWptnHHG0QVncrnWjNIAAAAAAAAAAAAAAAAAAABjjRIGoKw0NTUU3H/ssW2xa1dnRmkAAAAAAAAAAAAAAAAAAICxRAkDUFaWLm0suJ+mEStWtGWUBgAAAAAAAAAAAAAAAAAAGEuUMABlZfHi+VFZmRScaWlRwgAAAAAAAAAAAAAAAAAAAAxfVbEDHI6TTz45k/ckSRJPPPFEJu8ChmbKlNpYsKA+Hnpoy4AzuVxrhokAAAAAAAAAAAAAAAAAAICxoqLYAQ5HmqaZ/QClp6mpoeD+448/Fzt37s0oDQAAAAAAAAAAAAAAAAAAMFaUZQlDRESSJKP6A5SupUsbC+6nacSKFRszSgMAAAAAAAAAAAAAAAAAAIwVZVvCkKbpEf8Ueh5Qus45Z35UVhYuS8nlWjNKAwAAAAAAAAAAAAAAAAAAjBVVxQ5wOK699trDvrenpyd27doVGzZsiIcffjj27t0bSfLSL3NPmDAhLrvsspg0adJIRQVGweTJNXHmmXPiwQc3DzijhAEAAAAAAAAAAAAAAAAAABiucVfC8HI9PT3xr//6r/GNb3wj2traoqurK375y1/Gt7/97WhsbByRdwCjo7m5oWAJwxNPbI/nn98bs2ZNzDAVAAAAAAAAAAAAAAAAAABQziqKHaCYqqur421ve1vceeed8brXvS7SNI0//OEPcfnll8eWLVuKHQ8ooKlp8KKUFSvaMkgCAAAAAAAAAAAAAAAAAACMFeO6hGG/yZMnx/XXXx9nnHFGRERs3bo1rr322ujr6ytyMmAg55wzL6qqCv8tLJdrzSgNAAAAAAAAAAAAAAAAAAAwFihh+H9qamri05/+dCRJEkmSxOOPPx4/+MEPih0LGMDkyTVx5pn1BWdaWpQwAAAAAAAAAAAAAAAAAAAAQ6eE4WVOPfXUWLhwYaRpGmmaxj//8z8XOxJQwNKljQX3n3zy+di+vSOjNAAAAAAAAAAAAAAAAAAAQLlTwnCAJUuW9P95w4YN8fTTTxcxDVBIU1PhEoaIiBUr2jJIAgAAAAAAAAAAAAAAAAAAjAVKGA4wb968vPUTTzxRpCTAYBYtmhfV1YX/NpbLtWaUBgAAAAAAAAAAAAAAAAAAKHdKGA5QV1cXERFJkkRExNatW4sZByhg0qTqOOusOQVncrm2jNIAAAAAAAAAAAAAAAAAAADlTgnDAXbu3BkREWmaRkREb29vMeMAg1i6tLHg/lNPPR/PPdeRURoAAAAAAAAAAAAAAAAAAKCcKWE4wEMPPZS3nj59enGCAEPS1FS4hCEioqWlNYMkAAAAAAAAAAAAAAAAAABAuVPC8DJbtmyJe++9N5Ik6b9WX19fxETAYM4+e27U1FQWnMnl2jJKAwAAAAAAAAAAAAAAAAAAlLOqYgcoFS+++GJ86EMfis7Ozv4ShsrKynjNa15T5GTZ6Orqioceeiiefvrp2L17d1RXV8ecOXNiwYIF0djYOKLv2rBhQzzyyCOxZcuW6OnpialTp8Zxxx0XCxcujNra2hF7z1j8Jg5WV1cdCxfOifvv3zjgTC7XmmEiAAAAAAAAAAAAAAAAAACgXI37EoYXX3wx7rnnnrj55ptjy5YtkSRJpGkaSZLEkiVLYvLkyUXJtXXr1njkkUdi7dq18cgjj8Rjjz0We/bs6d+fP39+3HfffUf8nh07dsSNN94YP/3pT6Ojo+OQM6eeempcffXVcf755x/Ru37xi1/EzTffHI8//vgh9+vq6uKSSy6Ja665JmbOnHnY7xmL30RhTU0NBUsYfv/7HbF1656or5+UYSoAAAAAAAAAAAAAAAAAAKDcJGmapsUOMVwf//jHj+j+ffv2xYsvvhhtbW3xzDPPRG9vb+z/y7C/hKGioiJ++MMfxqmnnjoSkYfkwQcfjNtuuy3Wrl0b27ZtKzg7EiUMK1eujA996EOxc+fOIc1fdNFF8dnPfjZqamqG9Z7u7u74xCc+ET/72c+GND9z5sy4/vrrY9GiRcN6T8TY/KbR1N7+UklFd3dvkZMcmeXLN8Qll/yo4My3vvVncfHFJ2WUCAAAhq6mpjJvXe7ncwAAKGfO5wAAUDqczwEAoHQ4nwMAQOnYfz6fNq2uyElgbKsqdoDD8dOf/jSSJDni57y8f+LA51177bWZFjBERDz66KNx7733ZvKu1atXx1VXXRWdnZ1516dOnRoNDQ3R3t4eW7Zsid7eP/7DkTvvvDM6Ojri+uuvH/Jf/76+vrjuuuti2bJledcrKytj7ty5MWXKlGhra4sXXnihf2/Hjh1x5ZVXxm233RZnnXXWuP4mhuY1r5kbNTWVBf9hXi7XpoQBAAAAAAAAAAAAAAAAAAAoqKLYAY5EmqZH9JMkSf/P/udVVFTEBz/4wbj66quL/HX56upGrpGmvb09PvzhD+eVFcyfPz9uuummeOCBB+KnP/1p3HfffXHffffFn//5n+fd+2//9m9x++23D/ldt9xyy0FlBZdeemn88pe/jGXLlsWdd94ZDzzwQNx4440xb968/pm9e/fGddddl1dkMN6+iaGbOLE6zj57bsGZlpbWjNIAAAAAAAAAAAAAAAAAAADlqqxLGF5eojDcn4g4qJDhT/7kT+KOO+6Ia665pqjfNWnSpDjnnHPive99b3z961+P++67L775zW+O2PO/853vxLZt2/rXDQ0N8S//8i9x/vnn9/+1iYiYM2dO/P3f/318+MMfzrv/pptuivb29kHfs3PnzoNyf/SjH42/+7u/i/r6+v5rFRUVccEFF8QPfvCDmD9/fv/1LVu2xG233TZuv4nhaWpqKLi/bt3O2LLlxYzSAAAAAAAAAAAAAAAAAAAA5ShJ0zQtdojhOu+8847o/urq6pg0aVJMnTo1XvnKV8app54aS5cujTlz5oxQwsOzYcOG6O7ujuOOOy4qKvL7MVauXBlXXHFF/3r+/Plx3333DfsdO3bsiDe84Q3R0dHRf+3222+PJUuWDHhPmqbxF3/xF7Fq1ar+ax/4wAcOKjI40Je+9KW45ZZb+teLFi2K7373u3mlCAdasWJFvOtd7+pfT5o0KZYtWxYzZswYV9+Ulfb2l/6adXf3FjnJkWtpaY2LLvphwZlvfvPP4pJLTsooEQAADE1NTWXeeiyczwEAoFw5nwMAQOlwPgcAgNLhfA4AAKVj//l82rS6IieBsa2q2AEOx+GUD5SDY445ZtTfcdddd+WVFSxatKhgWUFERJIkcc011+QVCfz4xz+O6667bsDygb6+vvjJT36Sd+3aa68tWFYQEbFkyZI4++yzY/Xq1RERsWfPnrjnnnviHe94x7j6JoZv4cK5UVtbGV1dA/8DvVyuVQkDAAAAAAAAAAAAAAAAAAAwoIpiByBby5Yty1u//e1vH9J95557bjQ0NPSvn3vuuXj44YcHnH/ooYdix44d/evGxsZYvHjxkN51YKYDMx9oLH4TwzdhQlUsWjSv4Ewu15pRGgAAAAAAAAAAAAAAAAAAoBwpYRhH9uzZE6tXr8671tzcPKR7kySJpqamvGu/+tWvBpz/9a9/nbduamqKJEmG9K4D37Ny5cro6Og45OxY/CYOX1NTQ8H9p5/eFZs3v5BRGgAAAAAAAAAAAAAAAAAAoNwoYRhH1q1bFz09Pf3rhoaGOOqoo4Z8/8KFC/PWTz755ICzB+4deG8h9fX1MX/+/P51T09PrFu37pCzY/GbOHzNzY2DzuRybRkkAQAAAAAAAAAAAAAAAAAAypEShnFk/fr1eesTTjhhWPcff/zxBZ/3ck8//XTBewdzYLYDnzdQhrHwTRy+hQvnxIQJlQVncrnWjNIAAAAAAAAAAAAAAAAAAADlpqrYAQ7Hxz/+8f4/z5s3Lz74wQ+O2LNvuOGG2LRpU0REJEkSn//850fs2cX2zDPP5K3nzJkzrPvnzp2bt960aVN0dXVFbW1t3vXOzs7+v4YD3TuYA7MdmH2g62Phmzh8tbVVsWjRvPjNbwYuWlDCAAAAAAAAAAAAAAAAAAAADKQsSxh++tOfRpIkERFx0kknjWgJw7Jly+Kpp56KNE3HXAnD888/n7cebmHB7Nmzo6qqKvbt2xcREX19fbFr166or6/Pm9u5c2ekadq/rq6ujlmzZg3rXQc+88DsA10fC9+UpaqqymJHGHF/8ifHFixh+MMf2mPbtj3R0DA1w1QAADCwsXguBwCAcuV8DgAApcP5HAAASofzOQAAlA7nc8hGRbEDHImX/1J8OTy32Do6OvLWEydOHNb9SZJEbW1t3rU9e/YM+p4JEyb0l2YMVV1dXcFnDnR9LHwTR2bp0sZBZ5YvH7ikAQAAAAAAAAAAAAAAAAAAGL/KuoRhtAz3l+vLxYG/9H9g+cBQTJgwoeAzIw4uMTic9xx4z1BLGMbCN3FkXvOauTFxYlXBGSUMAAAAAAAAAAAAAAAAAADAoShhGEe6urry1tXV1cN+Rk1NTd66s7PzoJnu7u5M3hMxNr+JI1NTUxmLF88vOPOb32zIKA0AAAAAAAAAAAAAAAAAAFBOCv/r4seh3t7e/j9XVY2tvzy1tbV5656enmE/48AyggOfGXFw2cBovedQ18fCN2Vp376X/vve3d07yGR5aWpqiF/96tkB9599tj3Wr98ZjY1TM0wFAABDM9bO5wAAUM6czwEAoHQ4nwMAQOlwPgcAAGCsqyh2gFKza9eu/j/X1dUVL8goOPB7urq6hv2Mzs7Ogs+MiJg0adIRv+fAewb6z2IsfhNHrqmpcdCZXK41gyQAAAAAAAAAAAAAAAAAAEA5UcLwMjt27Ijnnnuufz19+vTihRkFB/7S/969e4d1f5qmBxUJHFhOcKj3dHZ2Rpqmw3pXR0dHwWcOdH0sfBNH7swz66OurqrgTEtLW0ZpAAAAAAAAAAAAAAAAAACAcqGE4WVuv/32/j8nSRLHHXdc8cKMglmzZuWtt2zZMqz7t2/fHvv27etfV1RUxIwZMw6amzFjRiRJ0r/u6emJ559/fljv2rp1a976wOwDXR8L38SRq6mpjHPOmV9wJpdrzSgNAAAAAAAAAAAAAAAAAABQLgr/q+KLZNWqVUOe7ejoGNb8y/X29kZHR0e0trbGv//7v0dLS0skSRJpmkaSJHHaaacd1nNL1Stf+cq89ebNm4d1/4Hz8+bNi9ra2oPmJkyYEPPmzYuNGzf2X9u0aVPMnj37sN81UCHGWPwmRkZzc2P86lfPDrjf2ro7Nmxoj2OOmZZhKgAAAAAAAAAAAAAAAAAAoJSVZAnDX/zFX0SSJAVn0jSNiIgNGzbEFVdcMSLv3V++sN+b3/zmEXluqTjwl/7XrVs3rPvXr19f8Hkv98pXvjKvsGD9+vVxxhlnjPi7xuI3MTKamxsGnWlpaVPCAAAAAAAAAAAAAAAAAAAA9KsodoBC0jQ95M9QZg7nZ38BQ5Ik8Za3vCVe8YpXFOGrR88JJ5wQ1dXV/euNGzfGtm3bhnz/Qw89lLc++eSTB5w9cG/NmjVDfs+2bdvyyg6qq6vj+OOPP+TsWPwmRsaCBfVRV1ddcGb58taM0gAAAAAAAAAAAAAAAAAAAOWgpEsYkiQ55M9QZg7nZ38Zw7nnnhuf/vSni/TVo2fy5Mlx9tln511raWkZ0r1pmh40+/rXv37A+de97nUHvefAAo2B5HK5vPXixYtj0qRJh5wdi9/EyKiuroxzz51fcKalpXXI/xkCAAAAAAAAAAAAAAAAAABjX8mWMOwvRDjUz1DnhvMzefLkeO1rXxtf+9rX4tZbb43JkycX6ctH13nnnZe3/tGPfjSk++6///5oa2vrX8+ePTsWLFgw4PzChQtjxowZ/evW1tZYuXLlkN51YKYDMx9oLH4TI6OpqaHgflvbC/Hss+0ZpQEAAAAAAAAAAAAAAAAAAEpdVbEDHMr/+B//Y8C9NE3jv/yX/xJJkkSapnHsscfGZz/72cN6T2VlZUyaNCmmTZsWc+fOPdy4ZeXNb35zfPWrX42Ojo6IiFi1alWsWLEilixZMuA9aZrGTTfdlHftkksuiYqKgTs8Kioq4uKLL45bb721/9pNN90UixcvjiRJBrxvxYoVsXr16v71pEmT4k1vetO4+yZGxtKljYPOtLS0xSteMX30wwAAAAAAAAAAAAAAAAAAACWvJEsYzjnnnCHNJUkSdXV1Q54nYtasWfHOd74zvv3tb/df+9SnPhXf//73o76+/pD3fOtb34pVq1b1r6dMmRLvfe97B33XlVdeGT/4wQ/6yxEeeOCB+Pa3vx1XXXXVIee3bt0an/zkJ/OuXXHFFTFz5sxx902MjDPOqI9Jk6pjz56eAWeWL2+Nd7zjtAxTAQAAAAAAAAAAAAAAAAAApaqi2AEOV5qmkaZpsWOMuAcffDBaWloO+nn88cfz5rq6ug4519LSEuvWrSv4jve9731x1FFH9a/b2trisssui2XLluX9Nd2yZUv87d/+bXz1q1/Nu/8DH/hATJ8+fdBvmTlzZnzgAx/Iu/blL385PvOZz8TWrVv7r/X19cUvfvGLuPTSS2Pjxo39148++uh4z3veM+h7xuo3ceSqqiri3HPnF5xpaWkdk38vAQAAAAAAAAAAAAAAAAAAhi9Jy/C3j2+88cb+P8+ePTsuvfTSIqYZWeedd17eL+0fjosvvji++MUvFpxZtWpVvPe9742urq6861OnTo2GhobYvXt3bN68OXp7e/P23/CGN8RNN90USZIMKUtfX19cffXV8ctf/jLvemVlZcybNy+mTJkSbW1tsXv37rz9CRMmxK233hqvec1rhvSesfpNo629vSMiIrq7eweZLF833rgq/v7vf1Nw5v773x3HHTcjo0QAAJCvpqYybz2Wz+cAAFDqnM8BAKB0OJ8DAEDpcD4HAIDSsf98Pm1aXZGTwNhWliUMY1lWJQwREStWrIjrrrsudu3aNaTnvuUtb4kvfOELUVNTM6w8XV1d8fGPfzzuuuuuIc1Pnz49rr/++li8ePGw3hMxNr9pNI2HEoY1a7bEn/7p9wvOfOUrF8Tll5+eUSIAAMjn/6QGAIDS4XwOAAClw/kcAABKh/M5AACUDiUMkI2KYgegeJYsWRJ33XVXXHbZZTFx4sQB50455ZS44YYb4stf/vKwywoiImpra+MrX/lKXH/99XHyyScPOFdXVxfveMc74u677z7ssoKx+E0cmdNPPzqmTCn8n3Eu15pRGgAAAAAAAAAAAAAAAAAAoJQlaZqmxQ5B8XV2dsaaNWti/fr1sXv37qiuro76+vpYsGBBHHvssSP6rmeffTbWrl0bW7dujZ6enpg6dWocf/zxsXDhwqitrR2x94zFbxpp7e0dETH2m0jf+c6fxr33PjPg/pw5k2Lt2qsiSZIMUwEAwEv8mwIAAKB0OJ8DAEDpcD4HAIDS4XwOAAClY//5fNq0uiIngbFNCQOMY+OlhOHmm1fHZz7z7wVn7r//3XHccTMySgQAAH/k/6QGAIDS4XwOAAClw/kcAABKh/M5AACUDiUMkI2KYgcAGG3NzY2Dzixf3ppBEgAAAAAAAAAAAAAAAAAAoJRVFTvAfnfeeechr1900UVDnh0Nh3o/UF5OO+2omDq1Nnbv7hpwpqWlNa644owMUwEAAAAAAAAAAAAAAAAAAKUmSdM0LXaIiIiTTjopkiQ56PqTTz455NnRcKj3w1jR3t4RERHd3b1FTjL6/uIv7oyf//zpAfePPnpSPProVZn9vQUAAParqanMW4+H8zkAAJQq53MAACgdzucAAFA6nM8BAKB07D+fT5tWV+QkMLZVFDvAgdI07f8Zzuxo/ABjR1NTY8H9bdv2xPr1OzNKAwAAAAAAAAAAAAAAAAAAlKKSK2FIkmTI/yb6/bOj8QOMLUuXFi5hiIhYvrw1gyQAAAAAAAAAAAAAAAAAAECpKqkShjRN+3+GMzsaP8DYcsops2PatNqCMy0tbRmlAQAAAAAAAAAAAAAAAAAASlFVsQPst2zZslGZBYiIqKysiCVLGuL//t/1A87kcq2RpmkkSZJhMgAAAAAAAAAAAAAAAAAAoFSUTAnD/PnzR2UWYL/m5saCJQzPPdcRv//9jnj1q2dlmAoAAAAAAAAAAAAAAAAAACgVFcUOAJCV5ubGQWdyubYMkgAAAAAAAAAAAAAAAAAAAKVICQMwbpxyyuyYMWNCwZlcrjWjNAAAAAAAAAAAAAAAAAAAQKlRwgCMGxUVSSxZ0lBwpqWlNdI0zSgRAAAAAAAAAAAAAAAAAABQSpQwAONKc3PhEobt2/fGU089n1EaAAAAAAAAAAAAAAAAAACglChhAMaVpqbGQWdyubYMkgAAAAAAAAAAAAAAAAAAAKVGCQMwrpx88uyYOXNCwZlcrjWjNAAAAAAAAAAAAAAAAAAAQClRwgCMKxUVSSxZ0lBwZsWKtujrSzNKBAAAAAAAAAAAAAAAAAAAlIqqYgcYKVu2bIlcLhePP/54PPPMM/HCCy/ECy+8EPv27TvsZyZJEr/4xS9GMCVQCpYubYy77lo34P7zz++Np556Pk4+eXaGqQAAAAAAAAAAAAAAAAAAgGIr+xKGRx55JG644YZoaWmJvr6+/utpeuT/FvskSY74GUDpaWpqHHQml2tVwgAAAAAAAAAAAAAAAAAAAONMRbEDHImvf/3r8Y53vCOWL18evb29kaZp/0+SJEf0A4xdJ500K2bNmlhwJpdrzSgNAAAAAAAAAAAAAAAAAABQKsq2hOFrX/tafOMb34h9+/YdsnTh5YUMh/MDjF1JkkRTU0PBmZaWtujr8/cCAAAAAAAAAAAAAAAAAAAYT6qKHeBwrF27Nr75zW9GkiR519M0jcrKyjj22GPjmGOOicmTJ0d1dXWRUgKlrLm5MX72s98PuL9zZ2c8+eT2OPXUozJMBQAAAAAAAAAAAAAAAAAAFFNZljB87Wtfy1unaRqzZ8+Oa665Jt785jfH1KlTixMMKBvNzY2DzuRyrUoYAAAAAAAAAAAAAAAAAABgHKkodoDh2r17dzzwwAORJEmkaRoREaeeemrcddddcdlllylgAIbk1a+eGbNn1xWcyeVaM0oDAAAAAAAAAAAAAAAAAACUgrIrYXjwwQejt7e3f11bWxs33HBDTJs2rYipgHKTJEk0NzcUnFmxoi36+tKMEgEAAAAAAAAAAAAAAAAAAMVWdiUM27Zt6/9zkiRx/vnnx7x584qYCChXTU2NBfd37eqKxx9/LqM0AAAAAAAAAAAAAAAAAABAsZVdCcOuXbsiIiJNX/q30y9cuLCIaYBytnRp4RKGiIiWlrYMkgAAAAAAAAAAAAAAAAAAAKWg7EoYampq8tYzZ84sUhKg3J1wwow4+uhJBWdyudaM0gAAAAAAAAAAAAAAAAAAAMVWdiUM9fX1eeuOjo4iJQHKXZIk0dzcUHBmxYq26O3tyygRAAAAAAAAAAAAAAAAAABQTGVXwnDqqadGxEu/PB0RsWnTpmLGAcpcU1Njwf329q54/PHnMkoDAAAAAAAAAAAAAAAAAAAUU9mVMBx77LHxqle9qn+9YsWKIqYByt3SpYVLGCIicrm2DJIAAAAAAAAAAAAAAAAAAADFVnYlDBER73rXuyJN00jTNNasWRO//e1vix0JKFPHHTc96usnFZzJ5VozSgMAAAAAAAAAAAAAAAAAABRTWZYwXHLJJXHmmWdGRESapvGZz3wmuru7ixsKKEtJkkRzc0PBmRUr2qK3ty+jRAAAAAAAAAAAAAAAAAAAQLGUZQlDkiTx9a9/PY4++uhI0zTWrl0b1113Xbz44ovFjgaUoebmxoL7L7zQHY8+ui2jNAAAAAAAAAAAAAAAAAAAQLGUZQlDRER9fX1873vfi1e84hWRpmn88pe/jIsuuijuvPPO2LdvX7HjAWVksBKGiIhcri2DJAAAAAAAAAAAAAAAAAAAQDElaZqmxQ4xXDfeeGP/n/fs2RPf//73o7u7O9I0jSRJYuLEiXHmmWfGscceG9OmTYuqqqrDfte11147EpGhJLW3d0RERHd3b5GTFFeapnHmmd+OzZtfHHDmggteGd/73sUZpgIAYLyoqanMW4/38zkAABST8zkAAJQO53MAACgdzucAAFA69p/Pp02rK3ISGNvKsoThpJNOiiRJDrm3/3MG2h+uJ598ckSeA6VICcMf/eVf3h0//vFvB9yfPLkmfve7q6OqqiLDVAAAjAf+T2qA/5+9+46vsr77P/4+2XsnZBKSQCAERDYkSESxw467rjp624qjw631bl2929tatff4tWq1VlvU1j3bOqoWqgECCGGPkE0GJCE7ZK/r90fIkQA5QHJynXOS1/PxOI9zruv6Xt/rc2lIvuca7wsAAOfB+BwAAABwHozPAQAAAOfB+BwAAABwHoQwAOZw6buJDcMY8pIGwhcsFstJy0byAjBxLFuWYHN5a2u39uw5YlI1AAAAAAAAAAAAAAAAAAAAAAAAAAAAABzBpUMYBgMXBl+2lp3tC8DEkpFhO4RBkjZsqDChEgAAAAAAAAAAAAAAAAAAAAAAAAAAAACO4rIhDIZhjOkLwMQyZUqw4uICbbbZuJEQBgAAAAAAAAAAAAAAAAAAAAAAAAAAAGA883B0ASNx4MABR5cAYJyxWCzKyIjXm2/mDdtm8+ZD6unpk6enu4mVAQAAAAAAAAAAAAAAAAAAAAAAAAAAADCLm6MLAABnkZmZYHN5W1uPdu8+YlI1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxGCAMAHHO6EAZJysmpMKESAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5ACAMAHDN5cpDi4wNttiGEAQAAAAAAAAAAAAAAAAAAAAAAAAAAABi/CGEAgGMsFosyMxNstvn888Pq6ekzqSIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiKEAQCOc7oQhvb2Hu3cWWNSNQAAAAAAAAAAAAAAAAAAAAAAAAAAAADMRAgDABwnIyP+tG02bqw0oRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZiOEAQCOM3lysCZPDrLZZsOGCpOqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAGAmQhgA4ASZmQk2l2/dekjd3X0mVQMAAAAAAAAAAAAAAAAAAAAAAAAAAADALB6OLmAk0tLSxqxvNzc3BQQEKCAgQMHBwUpNTdXs2bO1cOFCpaamjtl2ATiPjIwEvfrqvmGXt7f3aseOai1eHGdiVQAAAAAAAAAAAAAAAAAAAAAAAAAAAADGmkuGMBiGMWZ99/X1qbm5Wc3NzTp06JDy8vL0t7/9TZI0Z84cXXvttfra1742ZtsH4HiZmfGnbbNxYyUhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA44+boAkbKYrGY8jIMw/rauXOn7rnnHt10002qr6939H8CAGMkPj5IiYnBNtts2FBhUjUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzOKyIQzHhyMMvs6kzana2mp3fCDDYNv169friiuuUF1dnSn7CsB8mZnxNpfn5h5WV1evSdUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMIOHowsYiVtvvdX6+ejRo3r99dfV1dUlSdaAhZCQEM2cOVPx8fEKCAiQl5eXWltb1dTUpPz8fJWWlqq3t3dIwMKcOXO0bNky9fb2qqWlRXV1ddq1a5dqamokaUgQw+HDh3XrrbfqL3/5izw9Pc3cfQAmyMxM0Cuv7Bt2eUdHr3bsqNGSJXEmVgUAAAAAAAAAAAAAAAAAAAAAAAAAAABgLLl0CMPevXt1yy23qKurS4ZhyN3dXZdeeqkuv/xyzZkzx2Yfra2t+uCDD/SXv/xFRUVFslgs2rVrl2bNmqX7779fbm5u1rYHDhzQc889pw8++MAa2mAYhnbt2qU33nhD3/nOd8Z0fwGYLzMz4bRtcnIqCGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxhGLYRiGo4sYiX379unaa69VR0eHDMPQlClT9Nvf/lYzZsw4q356e3v1+9//Xk899ZQsFosk6Wtf+5r+93//96S2//jHP/TTn/5UPT09kiTDMBQbG6t//vOfcnd3H/1OASZrbm6XJHV39zm4Eue0ePFqlZY2Dbv8vPMS9PbbV5hXEAAAAMYlL6+h3ycZnwMAAACOw/gcAAAAcB6MzwEAAADnwfgcAAAAcB6D4/PgYD8HVwKMb26OLmAkOjo6dNttt6m9vV2GYSgxMVEvvfTSWQcwSJKHh4duu+023XvvvTIMQ4Zh6IMPPtBf/vKXk9p+9atf1YMPPqjjcyuqqqq0efPmUe0PAOeUmRlvc/nWrYfV1dVrUjUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxppLhjA8//zzOnz4sCTJYrHo4YcfVkRExKj6vO6667R48WJJkmEYeuKJJ9Ta2npSu29/+9tKT08fEsSwdevWUW0bgHPKzEywubyzs0/bt1ebVA0AAAAAAAAAAAAAAAAAAAAAAAAAAACAseaSIQyvvfaaLBaLLBaLZs2apYULF9ql3+uvv17SQLBDa2ur3n///VO2+853vmNtJ0k7duywy/YBOJeMjPjTttmwocKESgAAAAAAAAAAAAAAAAAAAAAAAAAAAACYweVCGA4cOKAjR45Yp7OysuzWd0ZGhry8vKzT69atO2W7JUuWWD8bhqHq6mq71QDAecTEBCo5OcRmm40bCWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxguXC2HIz8+XNBB+IElxcXF269vT01MRERHW/gsKCk7ZLjY2VoGBgdbplpYWu9UAwLlkZibYXJ6bW6XOzl6TqgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAwllwuhKGurm7ItLe3t1379/HxsX6ur68ftl1ISIj189GjR+1aAwDncboQhq6uPm3bVmVSNQAAAAAAAAAAAAAAAAAAAAAAAAAAAADGksuFMPT19Q2ZPjGUYbSO7+/EbR3v+LAGd3d3u9YAwHlkZsaftk1OToUJlQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYay4XwhAZGSlJslgskqQdO3bYre+SkhK1tLRYpyMiIoZt29bWZv3s6+trtxoAOJdJkwI0dWqozTaEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAADjg8uFMERHR1s/G4ah7OxsNTU12aXvv/71r9bPFotFkyZNGrZtY2Oj9XNYWJhdtg/AOWVmJthcvm1btTo6ekyqBgAAAAAAAAAAAAAAAAAAAAAAAAAAAMBYcbkQhnnz5snX19c63dHRoUcffXTU/ZaUlOiFF16QxWKRYRiSpMzMzFO2raioUEdHh6SBsIa4uLhRbx+A8zpdCEN3d59yc6tMqgYAAAAAAAAAAAAAAAAAAAAAAAAAAADAWHG5EAZvb28tX75chmFYAxP+/ve/67//+79H3OfBgwd1ww03qLu7e8j8r371q6dsv3v37iHTU6dOHfG2ATi/jIz407bJyakwoRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY8nlQhgk6bbbbpOHh4ckWYMYnn/+eV1zzTUnBSTY0t7erueee06XXHKJqqqqrH1ZLBZdfPHFSklJOeV6//rXvyRJhmFIks4999zR7RAApxYV5a/U1DCbbXJyKk2qBgAAAAAAAAAAAAAAAAAAAAAAAAAAAMBY8XB0ASMxdepUXX/99Xr22WdlsVis4Qnbt2/XlVdeqalTp2r58uVKT09XXFycAgIC5OXlpba2NjU2NqqgoEC7du3Sp59+qs7OTmvwwqCgoCDdd999p9x2W1ubPvvsM+s23dzctGjRIrN2HYCDZGYmqKCgYdjl27dXqb29R35+niZWBQAAAAAAAAAAAAAAAAAAAAAAAAAAAMCeXDKEQZLuuusuVVdX6+9///uQIAbDMFRYWKiioqLT9mEYhiRZAxgMw1BQUJD++Mc/KiIi4pTrvPPOO2pra7NOz58/X6GhoXbYIwDOLDMzQc8/v2vY5T09/dq69bCyshJNrAoAAAAAAAAAAAAAAAAAAAAAAAAAAACAPblsCIPFYtFjjz2m4OBgvfTSS9Z5gwYDFk7Xx/HtExIS9Jvf/EazZs0adp1ly5bp9ddft05HRUWNpHwALmbp0vjTttm4sZIQBgAAAAAAAAAAAAAAAAAAAAAAAAAAAMCFuWwIgyS5ubnpgQce0EUXXaRf/OIXKikpkTQQrnB8wMJwBoMaPD09ddVVV+nuu++Wr6+vzXWSkpJGXzgAlxMZ6acZM8J14ED9sG1ycipMrAgAAAAAAAAAAAAAAAAAAAAAAAAAAACAvbl0CMOgRYsW6cMPP9SmTZv0xhtvaPPmzWpsbLS5jru7u1JTU/XVr35Vl19+ucLCwkyqFoCrysiItxnCsGNHtdraeuTv72liVQAAAAAAAAAAAAAAAAAAAAAAAAAAAADsZVyEMAxaunSpli5dKkmqqKhQfn6+mpqa1NLSou7ubgUGBiooKEgxMTFKT0+Xr6+vgysG4EoyMxO0evWuYZf39PRr69bDOv/8RBOrAgAAAAAAAAAAAAAAAAAAAAAAAAAAAGAv4yqE4XgJCQlKSEhwdBkAxpGMjNP/TsnJqSCEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAHBRbo4uAABcRXi4r9LSImy2ycmpMKkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPZGCAMAnIXMzHiby3furFFra7dJ1QAAAAAAAAAAAAAAAAAAAAAAAAAAAACwJ0IYAOAsZGYm2Fze29uvLVsOm1QNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHsihAEAzsLSpfGnbZOTU2FCJQAAAAAAAAAAAAAAAAAAAAAAAAAAAADsjRAGADgLYWG+mjkzwmabjRsJYQAAAAAAAAAAAAAAAAAAAAAAAAAAAABckYejCxgLfX19qqur09GjR3X06FH19vaOuK+FCxfasTIA48GyZQnav79u2OU7d9aotbVbAQFeJlYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAYLTGTQjDwYMH9dZbb2nbtm3av3+/uru7R92nxWLR/v377VAdgPEkIyNBzz67Y9jlfX2GPv/8kC68MMnEqgAAAAAAAAAAAAAAAAAAAAAAAAAAAACMlsuHMNTU1OjnP/+51q1bJ8MwJMn6DgBjYenSOFkskq1fNTk5FYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7GzdEFjMamTZv0rW99S9nZ2erv77eGL1gsllG/AGA4oaG+Sk+PtNkmJ6fCpGoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2IvLhjAUFRXplltuUWNjowzDsAYnGIZxxq/j2VoGACfKzEywuXzXriM6erTLpGoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2IOHowsYCcMwdMcdd6i9vX1I+MLs2bP1b//2b0pMTNQvf/lLVVRUWAMaXnzxRXV2dqq5uVkVFRXauXOnPv/8c3V1dVn7CAwM1D333KOkpCRH7h4AF5CZmaA//GH7sMv7+w1t3nxIF12UbGJVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEbDJUMYPv74YxUXF8tisVhDFm699Vbdeuut1jZ+fn5D1lm0aNFJ/TQ2Nurll1/Ws88+q56eHh09elSPPfaYnnjiCZ133nljvh8AXNfSpXGyWCTDGL5NTk4FIQwAAAAAAAAAAAAAAAAAAAAAAAAAAACAC3FzdAEj8fLLL0uSNYDha1/72pAAhjMVGhqqW2+9VW+//bbi4uJksVjU0dGhm2++Wdu2bbN32QDGkeBgH82eHWWzTU5OpUnVAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAHlwth6O7u1s6dO2WxWCRJbm5u+vGPfzyqPqdNm6YXXnhB4eHhslgs6unp0Y9//GO1t7fbo2QA41RGRoLN5Xv2HFFzc6dJ1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYLZcLYdi9e7d6enokSRaLRfPmzVNMTMyo+42Pj9e9994rwzBksVhUU1Ojv/zlL6PuF8D4tWyZ7RCG/n5DmzcfMqkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKPlciEMVVVVQ6bnzJlzRusNBjfY8vWvf12TJ0+WJBmGoTfeeOPsCwQwYSxZEic3N4vNNjk5lSZVAwAAAAAAAAAAAAAAAAAAAAAAAAAAAGC0XC6Eobm5WdJASIIkJSYmnrKdm9vQXevq6jqj/i+44AJr34cPH9bBgwdHWCmA8S4oyFvnnBNls83GjRUmVQMAAAAAAAAAAAAAAAAAAAAAAAAAAABgtFwuhKG1tXXIdEBAwCnb+fr6WsMUJKmtre2M+k9KShoynZ+ff5YVAphIMjLibS7fs+eImpo6TaoGAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGi4XAiDj4/PkGmLxXLKdieGM9TU1JxR/8HBwUP6ra6uPtsSAUwgy5Yl2FxuGNLmzYdMqgYAAAAAAAAAAAAAAAAAAAAAAAAAAADAaLhcCMOJ4Qqtra2nbBcSEjJkury8/Iz6b29vHzLd0dFx5sUBmHAWL46Tu/upw2AG5eRUmFQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNFwuRCGuLg4SZLFMnDTc1NT0ynbpaSkDGm3Y8eOM+o/Pz9fkmQYhiTJ19d3xLUCGP8CA701Z84km20IYQAAAAAAAAAAAAAAAAAAAAAAAAAAAABcg8uFMCQnJw+ZLikpOWW76dOnWz8bhqG1a9eqv7/fZt99fX36+OOPrcENkhQWFjaKagFMBBkZ8TaX79tXq8bGDpOqAQAAAAAAAAAAAAAAAAAAAAAAAAAAADBSLhfCMGnSJEVERFini4qKTtlu4cKF8vHxsU7X1NTo5Zdfttn37373O1VXVw+ZN3v27FFUC2AiyMxMsLncMKRNmw6ZVA0AAAAAAAAAAAAAAAAAAAAAAAAAAACAkXK5EAZpIGDBMAwZhqH9+/ertbX1pDZ+fn5asWKFDMOQxWKRYRj69a9/rRdffFF9fX1D2nZ2dup///d/9cwzz8hisVjnJyQkaMqUKWO9OwBc3OLFcXJ3t9hsk5NTYVI1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEbKw9EFjERGRob+8Y9/SJL6+vq0efNmrVy58qR2N954oz7++GNrEENvb68ee+wxPf3005ozZ46Cg4PV2NioHTt2qL29fUhgg8Vi0XXXXWfyngFwRQEBXjr33Enatq162DaEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOz83RBYzEypUr5eHhIYtl4Mnz77333inbpaen66qrrpJhGJJkDVhobm7W+vXr9f777ysnJ0dtbW3W4IXBdnPmzNGVV15pzg4BcHmZmQk2l+/fX6eGhg6TqgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEi4ZwhAaGqovf/nLiomJUUxMjPLz89Xa2nrKtvfff78uuOCCIUEMg2ELhmFYwxeOn5eUlKQnnnhC7u7u5uwQAJeXkWE7hEGSNm6sNKESAAAAAAAAAAAAAAAAAAAAAAAAAAAAACNlMQbTCcax3t5ePfvss3ruuefU0fHFk+gtFouO3303Nzd985vf1IMPPqiAgABHlAqYqrm5XZLU3d3n4EpcX2trt1JTn1Zvb/+wbW688Vw98sgFJlYFAAAAV+DlNTQAkPE5AAAA4DiMzwEAAADnwfgcAAAAcB6MzwEAAADnMTg+Dw72c3AlwPg2IUIYBjU0NGjt2rXauHGjqqqq1NjYKD8/P0VGRmrBggX60pe+pClTpji6TMA0hDDY18UXv6rc3Kphl6elhSs7+3smVgQAAABXwElqAAAAwHkwPgcAAACcB+NzAAAAwHkwPgcAAACcByEMgDk8HF2AmcLCwnTFFVfoiiuucHQpAMahZcsSbIYw5OXVq66uXRERDG4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ+Tm6AIAYLzIyEg4bZtNmypNqAQAAAAAAAAAAAAAAAAAAAAAAAAAAADASBDCAAB2snBhrDw9bf9azcmpMKkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGeLEAYAsBN/f0/NnRtts01OTqVJ1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4W4QwAIAdZWYm2Fyen1+v2tp2k6oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAcDYIYQAAOzpdCIMkbdpUaUIlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM6Wh6MLONHWrVsdXcIQCxcudHQJ40pXV5e2b9+ukpIStbS0yNPTU9HR0ZozZ44SEk5/8/rZKC8v1+7du1VdXa2enh4FBQUpOTlZ8+bNk7e3t922Y+Y+wfktWBAjT0839fT0D9tmw4YKffObqSZWBQAAAAAAAAAAAAAAAAAAAAAAAAAAAOBMOF0Iw7XXXiuLxeLoMiRJFotF+/fvd3QZdvfkk0/qd7/73YjXv+SSS/TYY4+d1ToNDQ363e9+p3fffVft7e2nbJOenq6bb75ZK1euHHFtkrRmzRo9/fTT2rdv3ymX+/n56dJLL9Utt9yisLCwEW/HzH2C6/Dz89T8+THavPnQsG02bqwwsSIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ8rN0QUMxzAMp3hh9D7//HNdfPHFevnll4cNK5Ckffv26ZZbbtFPf/pTdXd3n/V2uru7dc899+iWW24ZNoBBktrb2/XSSy/pa1/7mrZu3XrW25HM2ye4poyMeJvLCwoaVFPTZlI1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAM6U04YwWCwWh75gH7m5ufr+97+vxsbGIfODgoI0c+ZMxcXFyd3dfciyv/71r/rxj398ViEY/f39uvPOO/Xee+8Nme/u7q74+HilpaUpMDBwyLKGhgbddNNN2rFjh1PuE1zXsmUJp22zaVOlCZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBseji5gONysbp6f/vSnmjFjxhm3j4qKOqN2zc3Nuuuuu9TZ2WmdFxcXp/vvv18XXnihNeyiurpaTz/9tF5//XVru08++UQvvPCCVq1adUbb+uMf/6i1a9cOmXfVVVfp5ptv1qRJkyQNBDWsXbtWjzzyiA4fPixJ6ujo0J133qn333//pJAGR+8TXNf8+THy8nJXd3ffsG02bKjQt7413cSqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJyO04YwDAoJCdHFF1+syMhIR5cybqWnp2vx4sV27/dPf/qTjhw5Yp2Oj4/XK6+8Yg1FGBQdHa2HHnpIsbGx+s1vfmOd/9RTT+nSSy9VcHCwze00NjbqmWeeGTLvxz/+sb7//e8Pmefm5qaLLrpI55xzjq6++modOnRI0kBgwvPPP6/bb7/dafYJrs3X11Pz50dr06ZDw7bZuLHCxIoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnAmnDWGwWCySpObmZr3xxhtatmyZLrvsMl1wwQVyd3d3cHU4nYaGBv3lL38ZMu/hhx8+KazgeD/4wQ+0YcMGbd26VZJ09OhRrV69WnfddZfNbf3xj39UW1ubdXrhwoW66aabhm0/adIk/epXv9J1111nnffCCy/o2muvVWhoqFPsE1xfZmaCzRCGoqJGVVe3Kjo6wMSqAAAAAAAAAAAAAAAAAAAAAAAAAAAAANji5ugCTsUwjCHTvb29ys7O1u23367zzjtPv/71r1VYWOig6nAmPvjgA7W3t1unFy5cqKVLl9pcx2Kx6JZbbhky7+233z7p5+F4/f39euedd4bMu/XWW60hHsNZunSpFixYYJ1ua2vTP/7xD5vrmLVPGB8yMxNO22bjxkoTKgEAAAAAAAAAAAAAAAAAAAAAAAAAAABwppwuhOGll17St771Lfn4+MgwDBmGYb2h3jAMNTQ06IUXXtA3v/lNXXHFFXr99dfV2trq4KpxorVr1w6Zvvzyy89ovSVLlig+Pt46XVtbq507dw7bfvv27WpoaLBOJyQkaPHixWe0rRNrOrHmE5m1Txgf5s+Pkbe3u802OTkVJlUDAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Ew4XQjDggUL9Nhjj2nDhg365S9/qXPPPXdIGIPFYrFO79mzR7/4xS+0bNky/eQnP9HmzZsdXT4ktbW1KTc3d8i8zMzMM1rXYrEoIyNjyLzPPvts2PbZ2dlDpjMyMqyhHadz4nY+//xztbe3n7KtmfuE8cHHx0MLFsTYbEMIAwAAAAAAAAAAAAAAAAAAAAAAAAAAAOBcnC6EYZC/v7+uuOIKvfbaa/rggw+0atUqhYeHyzAMSRoSyNDZ2an33ntPq1at0sqVK/X000+rqqrKwXswcRUVFamnp8c6HR8fr8jIyDNef968eUOm8/Lyhm174rIT17Vl0qRJiouLs0739PSoqKjolG3N3CeMH5mZCTaXl5Q0qarqqEnVAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgdpw1hOF5KSop++tOfKjs7W7/73e+0YsUKubu7yzAMaxiDJBmGocrKSj355JNauXKlbrjhBn344Yfq7u528B44v+7ubhUXFys3N1e7du1SWVmZOjo6RtRXcXHxkOmpU6ee1fopKSk2+zteSUmJzXVP58TaTuxvuBrGcp8wfpwuhEGScnIqTagEAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJnwcHQBZ8Pd3V0rV67UypUrVVdXp3fffVfvvvuu9cb548MY+vr6tHHjRm3cuFFBQUH6xje+oUsvvVQzZ8505C44pYceekgVFRXq6uoaMt/Dw0Pp6elavny5rrnmGoWFhZ1Rf6WlpUOmo6Ojz6qemJiYIdOHDx9WV1eXvL29h8zv7OzU4cOHba57OifWdmLtw80fq33C+DJvXrR8fNzV2dk3bJuNGyt0+eVpJlYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAYDguFcJwvIiICN1000266aabtGPHDr355pv66KOP1N7eLmloIENzc7Nefvllvfzyy5o+fbouu+wyfeMb31BISIgD98B5FBUVnXJ+b2+vdu3apV27dum5557T9ddfr1tvvVXu7u42+6uvrx8yfbaBBREREfLw8FBvb68kqb+/X01NTZo0adKQdo2NjTIMwzrt6emp8PDws9rWiX2eWPtw88dqn8zm4WH7/yVGx8vLXYsWxWnduvJh2+TkVMrLi/8PAAAAExnjcgAAAMB5MD4HAAAAnAfjcwAAAMB5MD4HAAAAnAfjc8Acbo4uwB7mzp2rRx55RDk5OfrVr36l+fPnyzAMGYYhi8Uii8VinT5w4IAeeeQRLV++XHfeeafWrVvn6PJdQmdnp55++mldd911amtrs9l2MAhjkK+v71lty2KxyNvbe8i8U23zxO34+PhYwzfOlJ+fn80+h5s/VvuE8WfZsgSby0tLm1RZ2WJSNQAAAAAAAAAAAAAAAAAAAAAAAAAAAABsGRchDIN8fX112WWX6eWXX9ZHH32kG2+8URERETIMQ5KGBDJ0d3fro48+0g9+8APV19c7uHLzWSwWzZ07V3fddZeef/55rVu3Trt27dKePXu0bt06PfPMM7ryyitPCg7YsmWL7r77bvX19Q3b94mBBSf2cSZ8fHxs9imdHGIwku2cuM6ZhjCM1T5h/DnvvMmnbbNhQ4UJlQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4nXEVwnC8KVOm6J577lF2drZ+//vfa+XKlXJ3d5dhGNYwhokqMzNT//jHP/Taa6/phz/8oTIyMjRp0iT5+PjIy8tLkyZN0ooVK/TQQw/pk08+0bx584as/9lnn+mVV14Ztv+urq4h056enmddo5eX15Dpzs7Ok9p0d3ebsh3JvH3C+DNvXrR8fT1stiGEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAHAOtu8MHgfc3Ny0YsUKrVixQrm5ubr77rtVW1vr6LIc6sRQBVuio6P1wgsv6Hvf+5527Nhhnf/73/9el19+uXx9fU9ax9vbe8h0T0/PWdd4YsDCiX1KJ4cajNV2TjV/LLdlpt7ePklSd3efgysZvywWixYujNW6deXDtlm/vpz/BwAAALBibAgAAAA4D8bnAAAAgPNgfA4AAAA4D8bnAAAAAIDxzs3RBYy19vZ2vfnmm7r66qt17bXXqra2VoZhOLosl+Lt7a1f//rX8vD4IrOjvr5eOTk5p2zv5+c3ZLqrq+ust9nZ2WmzT0ny9/cf9XZOXOdU2znV/LHaJ4xPmZkJNpeXlTWrsrLFpGoAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGfchjDk5ubqvvvuU2Zmpv7zP/9TO3bssIYvWCyWIW1PnMbJEhMTdcEFFwyZt2HDhlO2PTFcoKOj46y2ZRjGSSEHJwYunGo7nZ2dZx2w0d7ebrPP4eaP1T5hfDpdCIMk5eRUmlAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFs8HF2APdXU1Ojdd9/Vu+++q/Lyckk6KXhhcDo8PFzf/OY3ddlllyksLMwxBbuYJUuW6JNPPrFOl5aWnrJdeHj4kOnq6uqz2k5dXZ16e3ut025ubgoNDT2pXWhoqCwWi/X/aU9Pj+rr6xUREXHG26qpqRkyfWLtw80fq33C+HTuuZPk5+eh9vbeYdvk5FToyitnmlgVAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBO5fAhDT0+P1qxZo7ffflubNm1Sf3//kOCF48MX3N3ddd555+nyyy/X+eefLw8Pl999U8XExAyZbmhoOGW7pKSkIdNVVVVntZ0T28fGxsrb2/ukdj4+PoqNjdWhQ4es8w4fPnxWIQwnbis5OfmU7czaJ4xPXl7uWrQoTp99VjZsm40bK0ysCAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCpuGwKQV5ent5++229//77am5ulqQh4QvHTycnJ+vSSy/Vt771rbO6QR9DnRha0dvbe8p2JwYZFBUVndV2iouLbfZ3vKSkpCEhDMXFxTrnnHPsvi0z9wnjU2Zmgs0QhvLyFpWXN2vy5GATqwIAAAAAAAAAAAAAAAAAAAAAAAAAAABwPJcKYWhubtZ7772nd955R3l5eZKGBi9YLBYZhiHDMOTv76+vfvWruuyyyzR37lxHlj1u1NXVDZkOCws7ZbupU6fK09NTPT09kqRDhw7pyJEjioqKOqPtbN++fch0WlrasG3T0tK0YcMG6/SOHTt0ySWXnNF2jhw5MiTAwdPTUykpKadsa+Y+YXzKyIg/bZuNGysJYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcyM3RBZyJ9evX684779R5552nX/3qV9q/f781bOHE8IUFCxbo0Ucf1YYNG/Twww8TwGBH27ZtGzIdHR19ynYBAQFasGDBkHkbN248o20YhnFS2xUrVgzb/vzzzz9pO4PBHKeTk5MzZHrx4sXy9/c/ZVsz9wnj07nnTpKfn6fNNhs2VJhUDQAAAAAAAAAAAAAAAAAAAAAAAAAAAIBTcdoQhoqKCv32t7/VihUr9P3vf18ff/yxuru7hwQvSAM3uEdFRekHP/iBPv74Y7300ku65JJL5Ovr6+A9GF9aWlr0ySefDJm3dOnSYdtfcMEFQ6bfeuutM9rO5s2bVVlZaZ2OiIjQnDlzhm0/b948hYaGWqcrKir0+eefn9G2TqzpxJpPZNY+YXzy9HTX4sWxNtts3FhxxiEiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzP6UIY/vrXv+raa6/Vl770Jf3hD39QVVWV9abkwfAFwzDk4eFhbfPpp5/qrrvuUmJiooOrH79+/etfq6WlxTrt6emp5cuXD9v+a1/7mvz8/KzTW7du1aZNm2xuwzAMPfXUU0PmXXrppXJzG/7H1M3NTZdccsmQeU899dRpb2TftGmTcnNzrdP+/v766le/anMds/YJ41dmZoLN5ZWVR1Ve3mKzDQAAAAAAAAAAAAAAAAAAAAAAAAAAAICx43R3gt97773Kzc2VYRgyDGNI8IJhGEpNTdV9992ndevW6YknnlBWVhY3tJ+FZ599Vnv37j3j9r29vXrsscf01ltvDZl/1VVXKSoqatj1wsPD9Z3vfGfIvAcffFA1NTXDrvOHP/xBW7dutU4HBgbqhhtuOG2NN91005BwhC1btui5554btn1NTY0eeOCBIfO++93vKiwszOZ2zNwnjE+nC2GQpJycChMqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAHAqTptecHz4QmBgoK655hq9/fbb+tvf/qbvfe97Cg0NdXSJLmn9+vW67LLLdNVVV+nFF19UQUGBent7T2p39OhRvf/++7r88sv1/PPPD1k2efJk3XLLLafd1o033qjIyEjrdGVlpa6++mqtXbtWhmFY51dXV+s///M/9Zvf/GbI+j/84Q8VEhJy2u2EhYXphz/84ZB5//d//6df/OIXQwIS+vv7tWbNGl111VU6dOiQdX5UVJSuv/76027HzH3C+DRnziT5+3vabEMIAwAAAAAAAAAAAAAAAAAAAAAAAAAAAOA4FuP4O8edwIwZM6zhC5IUHBysrKwseXt7m16LxWLRQw89ZPp2x9K1116rLVu2DJnn5eWl6OhoBQYGys3NTU1NTTp06JD6+/tPWj8yMlIvvfSSpkyZckbb27p1q2644QZ1dXUNmR8UFKT4+Hi1tLSoqqpKfX19Q5ZfeOGFeuqpp2SxWM5oO/39/br55pv16aefDpnv7u6u2NhYBQYGqrKyUi0tLUOW+/j4aPXq1Zo/f/4ZbcfMfTJDc3O7JKm7u+80LWEvV1/9jtauPTjs8tjYAO3YcZNT/ZwAAABgbHl5uQ+ZZnwOAAAAOA7jcwAAAMB5MD4HAAAAnAfjcwAAAMB5DI7Pg4P9HFwJML45fQiDo25ENgxDFotFeXl5Dtn+WDlVCMOZysrK0qOPPqrw8PCzWm/Tpk2688471dTUdEbtv/71r+vRRx+Vl5fXWW2nq6tL9913nz744IMzah8SEqInnnhCixcvPqvtSObt01gjhMF8v/vdVj300HqbbT7//HolJYWYUxAAAAAcjpPUAAAAgPNgfA4AAAA4D8bnAAAAgPNgfA4AAAA4D0IYAHO4ObqA0zEMwyGv8eqHP/yhrrrqKk2bNk3u7u6nbe/n56evfOUreumll/Tss8+edQCDJC1dulQffPCBrr76avn6+g7bbubMmXryySf1f//3fyMKK/D29tb/+3//T0888YTS0tKGbefn56drrrlGH3744YgCGCTz9gnjT2Zmwmnb5ORUmFAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBNZDCdLHJgxY4YsFoujy5BhGLJYLMrLy3N0KWOmo6NDRUVFOnTokGpra9Xe3q7+/n4FBQUpKChIU6dOVWpq6hmFNZypzs5O7dixQ8XFxWppaZGnp6cmTZqkOXPmKDEx0W7bkaSysjLt2rVLNTU16unpUVBQkFJSUjRv3jx5e3vbbTtm7pO9NTe3SyKJ1Ey9vf1KTX1ara3dw7a57LIZ+v3vLzaxKgAAADgSTwoAAAAAnAfjcwAAAMB5MD4HAAAAnAfjcwAAAMB5DI7Pg4P9HFwJML45ZQiDsxjvIQwAIQyO8Z3vvKt//rN02OXR0f7atev7ThFIAwAAgLHHSWoAAADAeTA+BwAAAJwH43MAAADAeTA+BwAAAJwHIQyAOTwcXcCJ1q5d6+gSAGBMZWQk2AxhqK5uU2lpk5KTQ02sCgAAAAAAAAAAAAAAAAAAAAAAAAAAAIDThTDExcU5ugQAGFPLliWctk1OTgUhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDJ3BxdAABMNLNmRSooyNtmm5ycCpOqAQAAAAAAAAAAAAAAAAAAAAAAAAAAADCIEAYAMJm7u5uWLo2z2SYnp1KGYZhUEQAAAAAAAAAAAAAAAAAAAAAAAAAAAACJEAYAcIiMjASby2tq2lRc3GhSNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkQhgAwCGWLbMdwiBJOTmVJlQCAAAAAAAAAAAAAAAAAAAAAAAAAAAAYBAhDADgADNnRig42Ntmm5ycCpOqAQAAAAAAAAAAAAAAAAAAAAAAAAAAACARwgAADuHu7qalS+NttsnJqZBhGCZVBAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAQBgBwkMzMBJvLa2vbVVjYYFI1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhhAAAHyciIP22bnJxKEyoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBHCAAAOk54eqZAQb5ttNm6sMKkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQwAICDuLlZtHRpvM02OTmVMgzDpIoAAAAAAAAAAAAAAAAAAAAAAAAAAACAiY0QBgBwoGXLEmwur6trV0FBg0nVAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMbIQwA4EAZGbZDGCRpw4YKEyoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAgDADhQWlqEwsJ8bLbZuJEQBgAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMhDAAgAO5uVm0dGm8zTYbN1aqv98wqSIAAAAAAAAAAAAAAAAAAAAAAAAAAABg4iKEAQAcLDMzweby+voO5efXm1QNAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHERwgAADna6EAZJysmpMKESAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGIjhAEAHGz69HCFh/vabEMIAwAAAAAAAAAAAAAAAAAAAAAAAAAAADD2CGEAAAdzc7MoIyPeZptNmyrV32+YVBEAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMRHCAABOICMjwebyhoZO5eXVmVQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDERwgAATmDZMtshDJK0cWOFCZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExchDADgBFJTwxQR4WezzYYNhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY4kQBgBwAhaLRZmZ8TbbbNpUqf5+w6SKAAAAAAAAAAAAAAAAAAAAAAAAAAAAgImHEAYAcBIZGQk2lzc1dWnfvlqTqgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAmHkIYAMBJLFtmO4RBkjZurDShEgAAAAAAAAAAAAAAAAAAAAAAAAAAAGBiIoQBAJzE1Kmhioz0s9kmJ6fCpGoAAAAAAAAAAAAAAAAAAAAAAAAAAACAiYcQBgBwEhaLRZmZCTbbbNpUqb6+fpMqAgAAAAAAAAAAAAAAAAAAAAAAAAAAACYWQhgAwImcLoShublL+/fXmVQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAMLEQwgAATiQzM/60bTZsqDChEgAAAAAAAAAAAAAAAAAAAAAAAAAAAGDiIYQBAJxISkqoJk3yt9lm40ZCGAAAAAAAAAAAAAAAAAAAAAAAAAAAAICxQAgDADgRi8WizMx4m202bTqkvr5+kyoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAJg5CGADAyWRmJthc3tLSpb17a02qBgAAAAAAAAAAAAAAAAAAAAAAAAAAAJg4CGEAACdzuhAGSdqwocKESgC4goaGDtXUtMkwDEeXAgAAAAAAAAAAAAAAAAAAAAAAAACAyyOEAQCcTFJSiGJiAmy22biREAZgIjMMQ//4R5G+8pVXNGPG7zV79h+UkfGC/vSnHeru7nN0eQAAAAAAAAAAAAAAAAAAAAAAAAAAuCxCGADAyVgsFmVkxNtss2nTIfX29ptUEQBnUlBQryuvfEff+97ftX17tXV+cXGj7rvvU2VmvqC3385Tf7/hwCoBAAAAAAAAAAAAAAAAAAAAAAAAAHBNhDAAgBPKzEywuby1tVt79hwxqRoAzqClpUs/+9lnOv/8v+izz8qGbVdW1qwf/egfWrnyJf3rXwdlGIQxAAAAAAAAAAAAAAAAAAAAAAAAAABwpghhAAAndLoQBknasKHChEoAOFp/v6FXXtmrJUue1x/+sF29vf1ntN7evbW66qp3dNllb2nHjuoxrhIAAAAAAAAAAAAAAAAAAAAAAAAAgPGBEAYAcEJTpgQrNjbAZpuNGwlhAMa73NzD+spXXtGdd36iurr2EfWxYUOFvvzlV3TDDe+puLjRzhUCAAAAAAAAAAAAAAAAAAAAAAAAADC+EMIAAE7IYrEoMzPBZpvNmw+pt7ffpIoAmKmmplW33vqRLr74Ne3cWWOXPt97r1DLlr2ge+5Zo5qaVrv0CQAAAAAAAAAAAAAAAAAAAAAAAADAeEMIAwA4qdOFMLS19WjXLvvcnA3AOXR39+l3v9uqJUue1xtv7Ld7/319hv78591atGi1Hnlkg1pauuy+DQAAAAAAAAAAAAAAAAAAAAAAAAAAXBkhDADgpE4XwiBJOTkVJlQCwAxr1pQoK+vPeuih9Wpr6xnTbXV09Oq3v92ihQv/pKefzlVnZ++Ybg8AAAAAAAAAAAAAAAAAAAAAAAAAAFdBCAMAOKnJk4MUHx9osw0hDIDrKylp1He+866uueavKi5uPOv1LRYpJMR7RNtubOzUL36xTkuXPq/XXtunvr7+EfUDAAAAAAAAAAAAAAAAAAAAAAAAAMB4YTEMw3B0EQAco7m5XZLU3d3n4EownNtu+0ivv75/2OV+fp4qLLxZnp7uJlYFwB5aW7v1m998rmee2aaenpGFHyxeHKdHHlmhpKQQPf10rn7/+21qa+sZcU0zZoTrgQeW6UtfSpbFYhlxPwCAs+PlNXQsx/gcAADndPRol3JyKpWdXabPPz+kpqZOeXq6KzU1TKmp4UpNDdf06WGaNi1c/v6eji4XwAgxPgcAAACcB+NzAAAAwHkwPgcAAACcx+D4PDjYz8GVAOMbIQzABEYIg/N77bV9uv32j222+eCDq7RwYaxJFQEYrf5+Q2+9ladf/nK9amraRtRHTEyAfv7z5brkkulDwhJqa9v1m99s1osv7h5xsIMkLVoUq5/97DwtXhw34j4AAGeOk9QAADinnp4+bd9erezsMmVnl2v79ir19Z3Z4fTJk4OOBTOEafr0cE2fPhDSEBDgNcZVAxgtxucAAACA82B8DgAAADgPxucAAACA8yCEATAHIQzABEYIg/MrL2/WggV/stnmgQeW6Y47FplUEYDR2LmzWvff/6lyc6tGtL6Xl7tuuWWBbr99kc2nqh482KTHHtuod945MNJSJUlf+UqK7r8/UzNmRIyqHwCAbZykBgDAORiGoaKixmOhC2XKyalUa2u3XbcRFxeo1NQwpaaGHxfOEKbgYB+7bgfAyDE+BwAAAByvv9/Qzp3V2r69WqGhPlq4MFZTp4YxPgcAAAAciOPnAAAAgPMghAEwByEMwARGCINrWLDgjyovbxl2eVZWot588zITKwJwtmpr2/XIIxv0yit7NdKR11e+kqL/+q8sJSWFnPE6e/Yc0cMPr9enn5aNbKOS3Nws+va3Z+onP1mq+PigEfcDABgeJ6kBAHCc2tp2rV9fbg1eOHy41SF1REf7W4MZvghoCFNoqK9D6gEmMsbnAAAAgOP09PTp7bcP6He/26qCgoYhyzIzE3Tddefo4ounytPTfZgeAAAAAIwVjp8DAAAAzoMQBsAchDAAExghDK7h9ts/1muv7Rt2uZ+fhwoKbjnp4CYAx+vp6dPq1bv0P/+zSS0tXSPqY9q0MD388PlasWLKiOvYsKFcv/zleu3YUTPiPry93XX99efqjjsWKSyMm4AAwJ44SQ0AgHk6Onq0efOhY6EL5dq3r9bRJdkUGel3LJghTKmp4ZoxYyCkISKCk2fAWGF8DgAAAJivo6NHr7yyV089lavKyqM220ZF+evaa2fru9+drZiYQJMqBAAAAMDxcwAAAMB5EMIAmIMQBmACI4TBNbz++n7ddttHNtu8//5VWrQo1qSKAJyJzz4r04MPfnrSE1rOVGCgl/7jP5bqhhvOtcuTXAzD0PvvF+qRR3JUXNw44n6Cgrx1220LddNNc+Xn5znqugAAnKQGAGAs9fcb2rPniDV0YcuWQ+rqcv2/teHhvicFM6Smhisqyk8Wi8XR5QEujfE5AAAAYJ6Wli49//wu/eEP21RX13FW67q7W/TVr07VqlVztGxZAt+HAQAAgDHG8XMAAADAeRDCAJiDEAZgAiOEwTVUVrZo3rw/2mxz332ZuuuuxSZVBMCWgweb9POfZ+sf/yge0foWi3TNNbN0332Zioryt3N1Uk9Pn159dZ/+5382qaambcT9TJrkr//4j6W65ppZ8vBws2OFADDxcJIaMJdhGOrp6VdnZ686OnrV2Tnw6uo6cbpvyPSpXh0dA+sNnd83ZLqnp18REb6aM2eS5s+P0YIFMZo1K+qkf/sA7KeiouVY6EKZ1q8vV0NDp6NLMk1IiLdSU8M1ffrAa+BzmKKjA7gZBThDjM8BAACAsXfkSJuefXa7nn9+l44e7R51f9OmhWnVqjn69rdnKijI2w4VAgAAADgRx88BAAAA50EIA2AOQhiACYwQBtexcOGfVFbWPOzy5csn6623LjexIgAnamvr0ZNPbtFTT+WO+Kmq8+fH6JFHVmju3Gg7V3ey9vYePffcDj355Fa1tHSNuJ+UlFDdf3+mvv71adzQAwAjxElqTGSGYairq88aZDAYenAmAQinfvWdUUhCf79jD4d5e7vrnHO+CGVYsCBGsbGBDq0JcGXNzZ3asKFC2dnlWreuTCUlTY4uyekEBnpZAxmmT4/Q9OlhSk0NV1xcIN/lgBMwPgcAAADGTkVFi556aqteeWWvOjvtP9b28/PU5Zen6brr5mjWrEi79w8AAABMZBw/BwAAAJwHIQyAOQhhACYwQhhcx513fqxXXtk37HJfXw8VFNwsb28PE6sCIA3cOPjXv+brv/5rnQ4fbh1RH1FR/vrZz87TFVekyc3N3JtfGho69PjjW7R69c4Rh0dI0rx50XrwwWVatmyyHasDgImBk9RwFoZhWAMQjg9EGJjXe4pQhD6bgQinCkAYmDd0PY5MDYiJCdCCBTHHghlidc45UfLx4TsecCrd3X3avr1Kn31Wpuzscu3YUW1quIrFIp177iRlZCSotbVbBQX1ys+vV0NDp2k12Iu/v6dSU8OOBTQMvFJTw5WQEGT691PAWTA+BwAAAOwvP79eTz65Ve+8c0C9vf2mbHPRolitWjVHX//6NK6lAAAAAOyA4+cAAACA8yCEATAHIQzABEYIg+t48839uuWWj2y2+fvfr9SSJXEmVQRAkvburdX99/9LmzcfGtH6np5u+sEP5unuu5coIMDLztWdncrKFv33f2/SG2/sH9XNSxdcMEUPPLBMs2dH2bE6ABjfOEmNU+nvN+wQgNBnMxTh5JAEfvaciaenm2bNitSCBbHHghlilJAQxBPrMSEZhqGCggZlZ5cpO7tMGzdWqq2tx9QaEhODlZWVqKysyVq2LEGhob4ntamraz8WyNCg/Pw6FRQ0KD+/XrW17abWag++vh6aNm0gnGHGjIFghtTUMCUmBsvd3c3R5QFjivE5AAAAYD87dlTr8ce36MMPixxWQ0SEn/7932fpu989R/HxQQ6rAwAmkq6uXpWWNqmwsEFFRY1qaOiQv7+nkpJClZwcouTkUIWF+XDOAwBcDMfPAQAAAOdBCANgDkIYgAmMEAbXcejQUc2d+5zNNj/9aYZ+/OMlJlUETGwNDR167LGN+vOfd484sGDlyiT98pfnKyUl1M7Vjc6BA3V65JEcffRR8aj6ueyyGbr33kwlJgbbqTIAGL84ST0x9PX1a8eOav3rXwd14EC9Wlq6hoQkDIYsDIYidHXxc4CTRUb6WQMZFiyI0Zw50fL393R0WcCYqKlp07p1ZVq3rlzZ2WWqrm4zdfshId4677zJWr58IHhhypSQEffV0NChgoKGYwENA6+CgnrT98kevL3dNXVqmKZPD9f06QPBDNOnh2vKlBB5eBDOgPGB8TkAAAAwOoZhaP36Cj3++BatX1/u6HKs3Nws+tKXkrVq1RxlZSXKzY0bfwFgtBobB459FhU1WAMXCgsbVFbWfNrraYKDvZWSEqqkpIFQhsFwhuTkEAUH+5i0BwCAs8HxcwAAAMB5EMIAmIMQBmACI4TBtSxa9CcdPNg87PLzzkvQ229fYWJFwMTT29uvF1/crV//OkdNTV0j6iMpKUQPP3y+Lroo2c7V2dfmzYf08MPrtWXL4RH34enppu997xzdddcSRUbyxQ4AhsNJ6vGroaFDn356UGvWlOrTTw+qoaHT0SVhnHF3t2jmzMghwQxJSSE8OQouqb29R5s3V+qzzwZCF/Ly6kzdvqenmxYtilVWVqKyshJ1zjlRcncf21CB5ubO48IZGpSfX6eCggYdOnR0TLc7Fry83JWSEqLp0yOswQypqeFKSgo5aawDODvG5xODYRg6cqRNhYUN6u7uV1SUv1JTw/idBQAAMAr9/YY++qhYTzyxRdu3V4+6v9jYAN1660L19xtavXqnSkqaRl/kMcnJIbruujm66qp0hYRwoy8A2NLX16+KipZjQQuNxwUuNKiurmNMthkR4aukpIFAhpSUUCUnD4Q1JCWFKCDAa0y2CQA4PY6fAwAAAM6DEAbAHIQwABMYIQyu5e67P9FLL+0ddrmPj7sKC2+Rt7eHiVUBE0dOToXuv//TEd8I5O/vqbvvXqLvf3+uy/w7NQxDH39col/9aoPy8+tH3I+/v6duvnmBfvSj+ZwMB4BT4CT1+GEYhvburdWaNaVas6ZU27ZVnfYpP4C9hYX5HAtliNX8+TGaO3eSAgO9HV0WcJK+vn7t3n1E2dllys4u09atVab/DUxLizgWujBZS5bEy9/f09TtD+fo0S4VFjaooKBB+fn1ys+vV0FBvcrLWxxd2lnz8HBTcnKINZRh4D1MKSmhLvPdGBMP4/Pxp62tR/n5ddq/v055eQOv/ftrTwpJ8/Jy1/Tp4Zo1K1KzZkVq9uwopadHMpYCAAA4jZ6ePr37br6efHLrqM4pDkpJCdVtty3U5ZenWc8t9vcb+uyzg3r22R365JMSux139fX10KWXztCqVXN0zjmT7NInALiqtrYelZQ0qrDwi5CFwsIGlZQ0qrPTeY6PREf7Kzl5IKAhKSn0WEhDiKZMCZGPD8ccAWAscfwcAAAAcB6EMADmIIQBmMAIYXAtb72Vp5tv/ofNNn/727e1dGm8SRUBE0NlZYt+8Yt1+vvfC0bcxxVXpOlnPztP0dEBdqzMPH19/XrzzTz9+tcbR/VE1ogIX9199xJ997vn8FRBADgOJ6ld29GjXfrsszKtXVuqtWsPqqamzdElAUNYLNKMGRFasCBGCxbEaP78GE2dGiY3N4ujS8MEdPBgk7Kzy7VuXZnWry9XU1OXqdufNMnfGrqwfHmiJk3yN3X7o9XW1qOiogZrKMNgQENZWbNc7Si/u7tFU6YMhDMMBjOkpoZr6tRQ+fo6RxgGJi7G566rr69fpaVNx0IWBoIW8vLqRv17csqUYM2aFWUNZpg1K1LR0QGyWBhPAQCAia2jo0evvLJPTz+dq4qK0QcHzp4dpTvvXKSLL54qd3c3Sacen1dUtOjPf96tl1/eY9cnsM+fH6NVq+bom99M5SZeAOOWYRg6cqTdGrBQVDQQBltU1KDKypFfD+IMLBYpLi7wWEDDQDDD4PvkycFcpwIAdsDxcwAAAMB5EMIAmIMQBmACI4TBtVRVHdWcOc/ZbPOTnyzVPfcsNakiYHzr6OjRU0/l6sknt6qjo3dEfcyZM0mPPLJCCxfG2rk6x+js7NXq1Tv1+ONb1NjYefoVhpGYGKx7783QJZfM4OY/ABAnqV2NYRgqKGjQmjWlWru2VJs3H1Jvb7+jy8IY8fZ2l7e3h3x8Bl6+vh7y9nYfMu3j42FtMzg9MM9dvr4e6uzs086d1crNrRpVoJU9BQd7a968aM2fH6MFC2I1b160QkJ8HF0WxqGmpk6tX1+u7OxyZWeXqays2dTt+/l5KjMz/ljwQqJSU8PG5Q2zHR09KipqVEFBvQoKGnTgQJ0KChpUWtpktyeDmsViGfjOOGNGhDWYYfr0cE2dGiZ/f8IZYA7G567hyJE25eXVWQMX8vLqlJ9fZ9qTOSMifJWePhDIMBjOkJISar1ZEAAAYDxraenSCy/s0jPPbFddXfuo+8vIiNftty/SihWJJ31vtzU+7+rq1fvvF2r16l3auvXwqOsYFB7uq2uumaXvfvccJSYG261fADBTT0+fysqarQELg4ELhYWNamkxNxzXGbi7W5SQEGQNZUhJCVVS0sDnhIQgvs8DwBni+DkAAADgPAhhAMxBCAMwgRHC4HqWLFmtkpKmYZdnZsbr3Xe/bV5BwDhkGIbef79Qv/jFuhE/sSUiwlcPPLBMV189a1yGDDQ3d+qpp3L1hz9sH3FAhSTNmhWpBx8875QXVAHARMJJaufX3t6jnJwKa/BCefnon+qGs+fjc3Iggq0AhNO18fFxP+7zqV/2HstVVR3Vtm3Vys09rG3bqrVrV7VpNwqeTmpqmObPjzkWzBCj6dPDuegQZ62rq1e5uVXKzi5TdnaZdu06YmoIgJubRXPnRisra7KyshI1f37MhH66WVdXr4qLG1VQ0KD8/HoVFNQrP79eJSVNLhcgZLFICQnBmj79i2CGwZCGgAAvR5eHcYbxuXNpb+9RQUG9NWhh4L3Wrk88thdfXw+lpUVo1qwoazBDWlqE/PwIkQEAAONDbW27nntuu1av3mWXG3i/9KVk3X77Ii1aNHyg/ZmOz/fsOaIXXtilt9/OU3v7yM9fHs9ikS66KFmrVs3RihVTxuV5XwCur6WlS4WFx4csNKioqFGlpa53DNBRPD3dNGVKiJKTQ6zBDCkpoUpODlVMTAC//wHgOBw/BwAAAJwHIQyAOQhhACYwQhhcz49//E/95S97hl3u7e2uwsJb5OPjYWJVwPiRl1enBx/8VOvXV4xofXd3i268ca7uuWeJgoPH/5OEq6tb9b//u1kvv7xHfX0jH1IuW5agn/3sPM2dG23H6gDAdXCS2jkdPNikNWtKtWZNqXJyKtTVxf+X430RbnDqsIMzCUkYGohwqpf7ce3tH4jgDLq7+7R/f61yc6uUm1ulbduqVFbW7OiyJEkBAV6aOzdaCxYMhDLMmxej8HBfR5cFJ2MYhg4cqLeGLmzaVGm3Gx3OVFJSiLKyEpWVNVnLliVMiO9io9Xd3afS0iZrKMNASEOdiooa1dPjehdmx8cHKjU1/Fg4wxchDUFB3o4uDS6K8blj9PcbOniwyRq2MBC4UKvS0ia58plMNzeLUlJCNXt2pNLTvwhniIjgIggAAOA6Kitb9PTTuXr55b2jCmiXBsZH3/pWqm67bZHS0yNP2/5sx+fNzZ164439ev75XSoqahxVrcdLTAzWddfN0dVXpyssjGNkAMzV32/o8OGjxwUtNKqoqEEFBQ06cqTN0eWNaz4+7kpKGghnGAhmCFFy8sB7VJQ/DxwBMOFw/BwAAABwHoQwAOYghAGYwAhhcD3vvHNAP/zhhzbbvPvuFcrMTDCpImB8aGrq1P/8zyatXr1zxGECy5dP1q9+tULTp4fbuTrnV1TUoEcfzdF77xWOqp9vfGOa7r9/mVJSQu1UGQC4Bk5SO4eurl5t3nxIa9aUau3aUrteoDuWLBadJgDB/RQBCLanTwxAGFx/sH9vb3cuKhtDR460afv2auXmHta2bVXasaPa9Jvah5OUFKIFC2I0f36MFi6MVVpahDw83BxdFkxWXd2q7OxyZWeXad26ctMv8g0L89F5501WVlaili+frMmTg03d/njW29uvgwebjgtmGAhpKCpqcMkwopiYgCHBDIOfQ0O5WQa2MT4fe3V17UOCFvLy6pSfX+80Yx4zREf7a9asKM2ePRDMkJ4eqSlTQsZl8BgAAHBdBQX1evLJrXr77QOjfpq6l5e7rroqXbfcskBJSSFntd7xznR8bhiG1q+v0PPP79RHHxWPKlD+eD4+7vrWt2Zo1ao5BMwDsLvOzl6VlDSqqKhRhYUNKiysV2Fho4qLG1z6O7Ofn6cSE4NUW9uhurp2R5djN/7+ntZAhoH3Lz6HhflwLg3AuMTxcwAAXEtPT58aGjoUGup70t9xAK6PEAbAHIQwABMYIQyup6amVbNnP2uzzT33LNFPfpJhUkWAa+vr69fLL+/Vo4/mqL6+Y0R9TJ4cpIceOl9f/WrKhD+Bun17lR5+eIM2bKgYcR/u7hZ95zuz9R//sUSTJgXYsToAcF6cpHacw4ePau3aUq1ZU6p168rV1tZjynbj4wO1dGm8goK8jwtJ8DwuFMH9FKEIpw5J8PIiEGG86+3tV15enbZtq1JubpW2batScbFzhIT4+XlozpxJWrAgVvPnD4QzTJrk7+iyYGetrd3atKlS69YNBC8cOFBv6va9vNy1eHGssrISlZWVqNmzo7hB1WR9ff0qK2tWQUGDCgrqreEMhYUNo34CqiNERfmfFMyQmhrOU+lhxfjcfjo7e1VQUK/9++u0f3+dNXiBp3SeWkCAl9LTIzVrVqQ1nGH69HB5e3s4ujQAADDB7NxZrccf36IPPyzSaK8q8/Pz1HXXnaMf/nC+oqPP/tyfPcbnhw8f1Z//vFt/+cse1dba7+bfc8+dpOuvP1f/9m+p8vX1tFu/AMa/+vqOISELRUUNKixsUHl586h/7zpSdLS/pk0L09SpYUPeY2MDrOeyWlq6VFrapJKSRhUXN6qkpEmlpQOfm5q6HLwH9hMc7K2UlFAlJYWcENQQouBgH0eXBwAjxvFzAACcX2Vli15/fb/eeeeAiosb1d9vyGKRIiP9FRsboNjYwOPev/gcHR1AUAPgYghhAMxBCAMwgRHC4JoyMp63+VTepUvj9Le/XWliRYBr+vzzQ7r//k+1Z8+REa3v5+eh229fpB/9aD4X1RzHMAx9+mmZfvnL9dq3r3bE/fj6eugHP5inW29dqKAgbztWCADOh5PU5unt7VdubpXWrCnRmjWl2r+/zpTteni4afHiWF14YZJWrkzS9OnhBCdgVBoaOrR9+0AoQ25ulbZvr1Zra7ejy5I0EFI2f36MFiwYCGWYNSuKE3Qupq+vXzt31ig7u0zZ2WXKza1ST8/onnZ5ttLTI5WVNVlZWYlavDhOfn5853JG/f2GKiparMEMBQUNys+vU35+g9rbzQk2sqeICN+TghmmTw9XZKQff7cnGMbnZ6+/31B5efOQoIW8vDrrRT0YOQ8PN6WmhmnWrChrMEN6eqRCQrhhAwAA2JdhGMrJqdBvf7tF69aVj7q/sDAf3XjjXN1ww7kKDfUdcT/2HJ93d/fpww+L9PzzO7Vp06ER93OikBBvXX31LH3ve+coOTnUbv0CcG2DwaZFRY0qLGywBi0UFTWooaHT0eWNmIeHm5KTQ6wBC4OvqVNDFRg4ums7Gho6VFIyEMxw4ruznAOxh4gIXyUlDQQypKSEKjl5IKwhKSlEAQFeji4PAGzi+DkAAM6po6NHH35YpFdf3af168tHFPB3qqCGmJhAxcUR1AA4K0IYAHMQwgBMYIQwuKZ77lmjP/9597DLvbzcVVh4MzeFA8Ooqjqqhx5ar7ffPjDiPi65ZLr+8z+XKy4u0I6VjS/9/YbeffeAHn10o8rLm0fcT2ioj+64Y5Guv/5c+fjw1D8A4xMnqcdWbW27/vWvg1q7tlSffnpQzc3mPEUnKspfF144RStXJikrK5FQIYypvr5+FRQ0aNu2Km3bNhDMkJ9f7+iyJEne3u4655xJWrDgi2CG2FjG0c7EMAyVljYpO7tc2dllysmpMO135aDY2ABlZSVq+fLJOu+8yYqK8jd1+7AvwzB06NDRY+EMDdaQhvz8eh096noXS4eG+hwLZwhTYmKwYmICFBPzxQUGhISMP4zPbWto6BgStLB/f63y8updJnwlOtpfaWkRSkuL0MyZkUpLi1BIiI/y8uq0d+8R7dlzRHv31qqsbOTHs8wweXKQ0tMjh4QzxMUFEhoDAADOWn+/oY8/LtYTT2zRtm3Vo+4vJiZAN9+8QP/+77Pl7z/670tjNT7fv79WL7ywW2++uV9tbfYby15wwRStWjVHK1cmyd3dzW79AnBera3dKi4+OWihuLjJpY8pBAd7a+rUMKWmhg0JXJg8OUienubecGMYhmpr208Z0FBa2qSOjl5T6xlL0dH+Sk4eCGhISgo9FtIQoilTQrhmBoBT4Pg5AADOwzAM7dhRrVde2ae//jVfLS1jf63P8UENMTEBiosLJKgBcCBCGABzEMIATGCEMLimv/41X9///gc227z99uU677zJJlUEuIaurl4988x2/eY3n4/4ovD09Eg98sgKLV0ab+fqxq/u7j79+c+79f/+32bV1XWMuJ+4uED99KcZuuKKNC5YAjDucJLavvr7De3aVaM1a0q1Zk2Jdu6sGVGy89myWKT582O0cmWSVq5M0qxZUXJz4wYoOE5zc6e2b6+2hjJs21Zl+o31w4mNDdD8+TFasCBW8+fH6Jxzorh40GQNDR3asKFC2dllys4uU3l5i6nbDwjwUmZmvLKyEpWVlaipU0O5aXQCMAxD1dWtQ4IZCgoalJ9fp6Ym5/j9NBLBwd6KiQlQdHSANaAhJibQ+jk6OkDh4b6MC1wI4/MBXV29KihoOCFsoU7V1W2OLu2M+Pl5Ki0tfEjYQlpahMLCzuwpzC0tXdq3r/ZYMMPAe35+vXp6+se48pELDfXRrFmRSk8fCGWYPTtK06aFycODY2kAAOBkvb39evfdA3ryya06cGD0YZ7JySG67baFuvzyNHl72+84z1iPz48e7dIbb+TphRd22TXUNCEhSN/73jm65ppZiojgAljA1RmGoZqaNhUWfhGyUFAw8H74cKujyxuVyZODrCELA++hmjo1TJGRfi5xzLa/f+CY42AwQ3HxQDBDSUmjDh5sHjfHdSyWgetmBgIaBoIZBt8nTw7mBicApuH4OQAAjldT06a33srTa6/tc5qH9JwoMtLvWEADQQ3AWCKEATAHIQzABEYIg2uqqWnT7Nl/sNnm7rsX6957M02qCHBuhmHok09K9LOffaaDB0f2BLvQUB/dd1+mrr12NgEAI9Ta2q2nn87V73+/bVRPk5kxI1z3379MX/5yskuc8AeAM8FJ6tFraupUdnaZ/vnPUv3rX6WjCv45G6GhPlqxYopWrkzSihVTFB5+Zjd0AY7Q32+opKRRublVx16HdeBAvfr7HX9o0NPTTbNnRx0LZojR/PkxSkgIYrxnR11dvdqy5fCx0IVy7d5tTkDNIHd3i+bNi1FW1mRlZSVq3rxo05+WBudlGIaOHGlXQUH9sXCGL0Ia6uvN+Zs+1jw93YaENAwNbBiYjo4OIJDGSUy08blhGKqoaDkWtFBnDV0oKmpQX5/jxwmn4+ZmUXJyyJCghbS0CCUmBts9/KS7u0/5+fXHhTMc0d69tTp6tNuu27Enb293paVFWMMZZs+O0syZEQoI8HJ0aQAAwEE6O3v16qv79NRTuSovH9m50+PNmhWpO+5YpK9/fdqYnEc1a3xuGIY2barU6tW79OGHRerttU/4lpeXu775zVStWjVHCxbEcLwLcHLd3X06eLDJGrAwGLhQWNio1lbn/e53Oj4+7kpJGQxaCNW0aWGaNi1cyckh8vPzdHR5Y6avr1+VlUetAQ2lpY0qLh74XF7e7BLHPc6Eu7tFCQlB1lCGlJRQJSUNfE5ICOI6JwB2NdGOnwMA4Cy6u/v0z3+W6LXX9mnNmtJx8X3GVlDD4IMvCGoAbCOEATAHIQzABEYIg+tatuwFFRQ0DLt8yZI4/f3vV5pYEeCcCgsb9OCDn+rTT8tGtL6bm0XXXXeOfvrTDIWGclOlPdTWtus3v9msF1/cPaonBy5aFKuf/ew8LV4cZ8fqAMAxOEl99gzD0P79dVq7tlRr1pRq69bDpp1YmD07SitXJunCC5M0f340Fy7BpbW2dmvnzmrl5lZp27aBcAZnueE5Kspf8+dHa/78GC1cGKtzzpkkf//xezGovfX3D/yezM4u07p1Zdq8+ZA6OnpNrWHq1FAtXz4QupCZmaCgIG9Tt4/xoa6ufUgwQ0FBvQ4cqFdtbbujSxsT4eG+pwxriI394nNIiA837Yyx8Tw+b2rqPClsIS+vzmVuJImM9LOGLcycOfCaNi1Mvr6OGyMYhqGysmbt3TsQzDD47sxPQrVYpKSkEM2eHaVZs6I0a1akZs2K0qRJ/o4uDQAAjKGjR7v0wgu79cwz2+zynWrJkjjdeecirVgxZUy/ozhifF5d3aqXXtqjP/95t6qr2+zW7+zZUVq1ao4uuWQGx7kAB2tq6jwuYKFBRUWNKixs0MGDTS59I0tEhJ+mTQvVtGnhx4IWQjV1apji44PsHlTo6np6+lRR0WINZRgMaigpaVRlZYupIcZjydPTTVOmhCg5OcQazJCSEqrk5FDFxATwcwHgrI3n4+cAADijfftq9dpr+/TWW3lOc02XmU4V1BAb+8Vnghow0RHCAJiDEAZgAiOEwXX95Cdr9cILu4Zd7unppsLCW8Z1Wjlgy9GjXfrf/92s557bMeKnlGRmxuvhh1coPT3SztVBkg4ebNJjj23UO+8cGFU/X/lKiu6/P1MzZkTYqTIAMB8nqc9Ma2u31q8v15o1pVq7ttS0m5oCAryUlTVZF12UrAsumKLo6ABTtgs4gmEYOniw+Vggw2Ft21atvXuPOMVFp+7uFqWnR2r+/BgtWBCj+fNjlJQUwo3Ixzl8+KjWrSvXZ5+Vad26ctXVmXuTeni4rzV0YfnyyYqPDzJ1+5hYGho6VFDwRTBDfn6D8vPr7HpzjLPy8XEfEtQweGHB8aENkyb5y9OTCw1GajyMz7u7+1RY2GANWdi/v1Z5eXVOHQxwPF9fD82YEa60tAilpUVq5swIpaVFKCLCdS4cqK/vGBLKsHdvrQoLG9Tf7/hx1XAiI/00a1akNZxh9uwoJSWFcEMGAAAurq6uXc89t0OrV+9Uc3PXqPu76KIk3X77ItOC0h05Pu/p6dNHHxXr+ed3acOGCrv1GxTkrauvTtd1181RSkqo3foFMFR/v6HKypZjQQuNQ0IXXDng093doilTQjRtWpimTg099j7wmYeL2EdnZ6/KyppVUtKo4uJGlZZ+EdJQVeUax1bOhI+Pu5KSBsIZBoIZQpScPPAeFeXP+RcApzQejp8DAODsGhs79M47B/Tqq/u0e/cRR5fj9I4PaoiNDTz2IqgBEwMhDIA5CGEAJjBCGFzX3/9eoBtvfN9mm7feulzLl082qSLAOfT3G3r99X16+OENIz5pHhcXqP/6ryx94xvTOKFogj17juhXv9qgf/3r4Ij7cHOz6Nvfnqmf/GQpN3oBcEmcpD41wzBUUtKkNWtKtWZNqTZtqjTtv8306eG68MIpWrkySYsWxXEQHhNae3uPdu+u0datVcfCGap05Ihz3OQcHu6r+fNjrMEMc+dGKyDAy9Flmaa1tVs5ORXKzi5Tdna5CgsbTN2+j4+7Fi+OV1bWQPBCenokN2nC4ZqbO63hDPn5X4Q0VFYedXRpprJYpMhI/5PCGQY/x8YOfA4M9HZ0qU7JlcbnhmHo0KGjx4IW6pSXNxC2UFjYOOJgUjNZLFJSUojS0iI0c2bksfcIJSYGy93dzdHl2V1HR4/y8uqOBTPUas+eI8rLq1V7e6+jSxuWn5+nZs6MOBbMEKlZs6I0Y0a4fH0JgAYAwNkdOnRUTz+dq5de2qOOjtGNN9zcLPq3f0vVbbct0qxZ5gbYO8v4vKCgXi+8sEuvv75fR492263frKxErVo1R1/6UrI8PMbfGBgwQ0dHj4qLm6wBC4OvkpLGUf/+c6SAAC9NmxaqqVPDrEEL06aFacqUYHl7ezi6vAmrra1HpaVNKi0dCGUoLm60BjSYHYw8lvz9Pa2BDAPvX3wOC/PheipgAnOW8TkAAONNX1+/PvusTK++uk8ffVTM31g7i4z0s4YzENSA8YQQBsAchDAAExghDK6rtrZd6enP2Gxz112Ldd99mSZVBDjetm1VeuCBT7V9e/WI1vfxcdcttyzUbbctlJ8fFxGbbcOGcv3yl+u1Y0fNiPvw9nbX9defqzvuWKSwMJ7wAMB1cJL6C52dvdq4scIavHDwYLMp2/X19dCyZQm68MIkXXhhkhITg03ZLuCKDMNQZeXRY4EMh7VtW5V27z6inh7H3+jp5mbR9OnhWrAg5tgrVikpoeMmGKC3t1/bt1dr3bqB0IVt26pMv8F29uwoa+jCokWx3IAJl9Ha2n0skKFB+fn11pCG8nJzxhrOyt/f8xRBDYHWeTExAYqM9BuXN8Pb4qzj85aWruPCFr54tbSM/mnGZoiI8B0StpCWFqHp08Mn/HG4vr5+lZY2ac+eI8fCGY5oz55ap75xw93domnTwpSeHnksnGEgoIHjcQAAOIfCwgY9+eRWvfVW3qiPG3h5uevKK2fqllsWKDk51E4Vnn0Nx3P0+Ly1tVtvv31Aq1fvVF5end36jYsL1He/e46+851Zioryt1u/wHhhGIbq6jpUVNSggoIGa+BCUVGDKipa5MpXwMbGBgwJWkhNHfg8aZI/N7q7mJaWLmsgw+B7aWmjiosb1dTkGsdvzkRwsLdSUkKVlBRyQlBDiIKDfRxdHoAx5mzjcwAAXF1xcaNee22fXn99n6qr7ftQHE9PN335yyn65jdT1dnZq8OHj+rw4dZj7wOv8fRdZbQIaoArIoQBMAchDMAERgiDa1u+/EUdOFA/7PJFi2L1/vtXmVgR4Bg1NW361a826LXX9o24j69/fZp+8YvlmjyZGy4dyTAMvf9+oR55JEfFxY0j7icoyFu33bZQN900d8JfyA/ANUz0k9QVFS1as6ZUa9eWav36ctOeSjR5crAuuihJF12UpKVL47mRGBiFzs5e7dlz5FgwQ5W2bavSoUPO8dT54GBvzZsXrQULYjV/fozmz492mYsADcNQSUmTPvusTNnZZcrJqbDrkxbPRHx8oLKyEpWVlahlyxIUEcEJG4wvbW09Kir6IphhMKTh4MEml754357c3S2KivIfEszwRWDDQGhDdHSA/P3Hz1jK0ePznp4+FRU1Dgla2L+/VpWVzvG39XR8fNw1fXqENWhhIHghghvJzoJhGDpypO24YIZa7dlzRKWlTY4uzaa4uEDNmhU5JJxh8uQgbhoCAMAku3bV6PHHt+iDDwpH/X3Gz89T3/veOfrhD+cpJibQPgWOkKPH58MxDEOff35YL7ywU++9V2i3gFJPTzd9/evTtGrVuVq8OJaxFCac3t5+lZU1q7Dwi5CFwXdXvjHEy8tdyckhmjbti7CFadPClJISqoAAL0eXBxM0NHScFNAw+N7aau5x/7EUEeGrpKShwQzJyQOBDfysA+ODs47PAQBwJa2t3frb3/L16qv7tGXLYbv3P2tWpK6+Ol2XXpqm8HDbIeptbT2qqjoxnIGghuGcLqghOtpf3t4eji4TLsgwDHV396mrq0+dnb3q7Ow94fPAdEfHwOfB5QEBXoqJCdCll6Y7eheAcY0QBmACI4TBtd1771qtXr1r2OWenm4qKLhlXF0ADRyvu7tPzz23Q//3f5tHfEJyxoxwPfzwCi1fPtnO1WE0enr69Oqr+/Q//7NJNTUjT/WcNMlf//EfS3XNNbPk4TGxntoJwLVMtJPUPT192rLlsNasKdWaNaXKzx8+WMyePD3dtHRpvFauTNLKlUlKSQnlAlZgDFVVHbUGMuTmVmn37hp1djrH77fU1DAtWBBzLJQhRtOnhzvNU97r6tq1fn25srPLtG5duek33AYGeikzM0FZWYk6//xEJSeH8LsSE1JHR4+KihqtwQwHDtSpoqJF1dWtqqvrcHR5Tik42PukgIbo6IELDwY/h4f7ys3N+X+nmDU+NwxDVVWtx0IWBoIW8vLqVFjYYLcbuMbalCnB1qCF9PRIpaVFKCkpxGn+ro43ra3d2revVnv3fhHOkJdX59TfIYOCvDVrVuSx10AwQ2pqGE+JAQDATgzD0MaNlXr88S367LOyUfcXGuqjG2+cqxtuOFdhYbYv0DaLKxw/r6lp0yuv7NWLL+7S4cOtdus3LS1Cq1bN0eWXp3HjKsadtrYeFRTUnxC00KiSkkaX+U58KqGhPicFLUydGqrJk4O5ZgGnNBDE2K7S0i+CGYqLBz4fPNhkWni9GSIj/azBDElJX4QzENAAuBZXGJ8DAOCM+vsNbdpUqVdf3af33y9Qe7t9x/phYT667LI0XXVVumbPjrJr321tPaqubtWhQ0cJajgDwwU1DH4mqMG59fb2DxuCMPC5b0gIwpkEJpz4+cQ+B+eN5g5vw/i5/f4jADgJIQzABEYIg2t7770C3XDD+zbbvPHGZTr//ESTKgLM869/leqBBz5TcXHjiNYPDvbWT36yVNddN0eenlzw66za23v03HM79OSTW9XSMvKDMykpobr//kx9/evTuIEMgFOaCCepa2patXbtQa1ZU6rs7DLTnuQeExOglSuTdOGFSVq+fDIX8AAO1N3dp337ao+FMhxWbm61ysubHV2WJCkgwEtz50Zr4cIvghnMutGgo6NHW7YcVnZ2mbKzy7VnzxFTtjvIw8NN8+fHKCtrsrKyEjV3bjQXAwOn0dXVq+rqNlVVtaq6ulVVVa3Wz4cPH1V1dauqq9vG5ZhutDw93RQdPTSo4fjX4DIfH8decDAW4/PW1m7l5dUdC1yotX52lYtRwsJ8rGELM2cOhC1Mnx7O+NoJ9PT0qbCwQXv2DIQz7NtXqz17jqi52Xl/try83DV9erg1nGH27Cilp0cqMNDb0aUBAOAy+vsN/fOfJfrtb7do27aqUfcXHe2vH/1oga69drbTjfFc6fh5b2+/PvmkRM8/v0vZ2aMPxRgUEOClK6+cqeuum6Pp08Pt1i9glo6OHu3bV6tdu2q0a9cR7dpVrfz8BvX3u+ZlqxaLNHly8HFBC6HHghfCT/uEUeBs9Pcbqq5utYYylJQ0qrS0ScXFjSora3bqv4lnKyrKX8nJIccCGkKt70lJITyACnAyrjQ+BwDAGVRUtOj11/fptdf22/06KTc3iy68cIquuipdX/pSskNv7D9dUENVVasaGzsdVp+zOTGoISYmQHFxgQQ1HNPfbwwbfDB8CMLAsuFCEAbbna5tX59rHq8ihAEYW4QwABMYIQyura6uXTNnPmOzzR13LNIDDywzqSJg7JWUNOrnP8/Wxx+XjGh9i0X693+frfvuy1REhJ+dq8NYaWjo0OOPb9Hq1TvV1TXyv1lz507Sz352npYtm2zH6gBg9MbjSeq+vn5t316ttWtLtWZNqXbvNuemYjc3ixYujNXKlUlauTJJM2dGEMADOLEjR9q0bVvVsWCGKu3cWW33pPeRSk4O0fz5MVqwIFYLFsQoLS3CLuEE/f2G9u2r1WeflSk7u0xbthxSZ6e5v/dTU8OUlZWo5csnKzMzwelurgDGA8MwVF/fMSSoYTCg4fh5rnIDvtnCwnwUExM4JJzhxMCGkBCfMRvnjWZ83tvbr5KSRu3fXzckdKG8vMXeZY4JLy93paaGWYMWBkIXIjRpkj/jahdiGIYqK49q794j2rPniPbuHQhoqKw86ujSbEpMDNbs2VHWYIZZsyIVHR3Azx4AAMfp7e3X3/6Wryee2KK8vPpR95eUFKLbbluoK65Ic9qLel31+HlRUYNefHG3Xn1136jC5k+0bFmCVq2ao698JYWHDcApdXX1Ki+vTjt31mjXrhrt3FmjAwfqXPICdj8/D6WkDIQsTJ0aptTUcE2dOnBTuK8vN4XDsfr6+lVZeVQlJY3HXk3W9/LyZpf8NzecSZMGAxoG/v0lJX3x2c+Pf4uA2Vx1fA4AgJk6Onr04YdFeuWVfdqwoXxUT7c/lWnTwnTVVen69rfTNGlSgH07H0PDBTVUVR3VoUMENZxoMKhhMKDB7KAGwzDU3d13yuCDL8INeo99PnVIwtD1hgYf2ApMYIx59ghhAMYWIQzABEYIg+vLynrR5sUVCxbE6MMPrzaxImBstLZ267e//VzPPLN9xL+zFi6M1aOPrtA550yyc3UwS2Vli/77vzfpjTf2j+qpGCtWJOrBB8/T7NlRdqwOAEZuvJykbmjo0KefHtSaNaX69NODamgw54B4RISvLrhgIHTh/PMTFRLiY8p2Adhfb2+/8vLqlJs7GMxwWCUlTY4uS9LABbfnnht9LJghRvPnxygqyv+M1q2sbFF2dpnWrSvX+vXlqqvrGONqh4qI8NPy5ZN1/vkDwQuxsYGmbh/A8Nrbe6yBDIOvodNHVVPTNq4umrYXHx/3IeEM0dFfPCFicP6kSf4juinpTMbnhmHoyJE27ds3NGyhsLBhVAGSZpo8OeiksIXk5FC7hA7BOTU2dmjfvlrt2TMQyrB3b60KCuqd+ndMeLivZs0aCGQYDGdISQmVuzs/pwCAiaWzs1evvbZPTz2Vq7Ky0T8xLz09UnfcsUjf+MY0p/+76urHz9vaevTuuwe0evVO7d1ba7d+o6P9de215+jaa2crOtp1LrbH+NLT06cDB+qtYQu7dtUoL6/O5f6dTprkr2nTwjR16heBC9OmhSk2NlBuboTCwfX09PSpvLxlSDhDcXGjSkubVFnZYvcbwBwpOtpfycmhSk4OUVJS6LGAhhBNmUJAAzBWXH18DgDAWDEMQ9u2Vem11/brr3/Nt2sopyQFBnrpW9+arquvTtf8+THjNsT8xKCGqqrWYwENBDWcSkSE35CAhpiYAAUGeh8XgjAQanB2IQhfBCjAdRDCAIwtQhiACYwQBtd3//3/0h//uHPY5R4ebioouJmnWsJlGYaht98+oIceWqfq6rYR9REd7a+f/3y5Lr10xrg94DDRHDhQp0ceydFHHxWPqp9LL52he+/N0JQpIfYpDABGyFVPUhuGob17a/XPf5ZozZpSbd9ePaqQnLMxd+4kXXjhQPDCuedGcxEcMI41NHRo+/Yq5eYOvLZvr1Zra7ejy5IkTZ4crAULorVgQazmz49RenqkvLzc1dLSpZycCmVnlyk7u1zFxY2m1uXr66ElS+KUlZWorKxEpaVF8HsScGF9ff2qq2sfEtRwqtAGZ/nd6EwsloGLDmJiAo49CWJoaMPA/IGLEI534vi8oaFD+fn11qCFwdAFs0LHRiskxNsatJCWFqmZMyM0Y0b4SfuNiamzs1f5+fXau/eI9uwZCGbYt69WbW09ji5tWL6+HkpLixgSzjBzZiQ3VwAAxqXW1m698MIuPfPMdh05MrJzpcdbvDhOd9yxUBdemOQy501d9fj5iQzDUG5ulZ5/fpf+/vcCu+2Hh4ebLr54qlatmqOMjHiX+f8K19PX16+CgoZjgQvV2rWrRnv31rpMEKGHh5uSkkI0dWrocYELYZo6NVTBwYR7Y+Lo7OxVWVmziosbVVIyEMwwGNIw0uuynFVMTICSk0OUnDwQzjAQ0BCqKVOC5evLMQRgpMbL+BwAAHupqWnTm2/u12uv7VNBQYPd+z/vvMm6+up0XXzxVM6FHUNQA3AyQhiAsUUIAzCBEcLg+t5/v1DXX/+ezTavvXapLrhgijkFAXa0e3eN7rvvU23denhE63t5uetHP5qvO+5YRBDJOLV58yE9/PB6bdkysp8RSfL0dNP3vneO7rpriSIj/exYHQCcOVc6Sd3S0qXs7DKtXVuqtWsPqqbGnItxgoK8tWJFoi68MEkXXDDljJ8+D2D8GbzYNzf3sLZtq9K2bdXKz693dFmSBp7KPmVKiAoLG0x9orTFIs2ZM0nLl09WVlaiFi6MlY+Ph2nbB+AcWlu7VVXVar3IYDCcYfDz4cOtqq1tG1dPurMXf3/PIeEM8fFBcnd3U15erfbvr1NpaZOjSzwjnp5umjYtTGlpEZo5cyBsIS0tQjExAdyIhbPS32/o4MEm7d1beyyYYSCcwazvfyPh5mZRSkrosVCGgXCG2bOjFBHB8T4AgGuqr+/Qc89t15/+tFPNzaN/at6FF07RHXcs0pIl8XaozlyudPz8TNXVteuVV/bqxRd3q6KixW79Tp8eruuum6NvfzuN0DWMSn+/oeLiRmvYws6dNdq794ja23sdXdppBQV5a9q0UGvIwuArMTFYnp7up+8AmMDa2npUWtqk0tLGYyENAwENJSVNqqtrd3R5dhUbG2ANZ/jiPURTpoRwfgU4jfE4PgcA4Gx1d/fpk09K9Npr+7R2bandrxGaPDlIV16ZriuvnKnJk4Pt2vdEMRjUcPjwF8EMBDVgPCOEARhbhDAAExghDK6voaFDM2b83mab229fqAcfPM+kioDRq6tr16OP5uill/aM+MaAL385Wf/1X1lKTg61b3FwOoZh6OOPS/TIIxt04MDIb77z9/fUzTcv0I9+NJ/QDgCmc+aT1IZhqKCgQWvWlGrNmhJ9/vlh9fb2m7LttLQIXXRRklauTNKCBbHy8HAzZbsAXE9zc6e2b69Wbm7VsWCGKrvcoODMJk8OUlZWorKyErVsWYLCwnwdXRIAF9DT06cjR9pVVTU0qOHw4S8+V1e3qqPD+W+qmOji4wOtYQtpaQNhC1OnhnJDCcbUkSNt2ru31hrKsHfvERUXNzp1uEt0tL9mzYrS7NkDwQzp6ZGaMiVEbm4EkwAAnNOhQ0f1+9/n6qWX9oz6Zmc3N4u++c1U3XbbQs2eHWWnCs3nzMfPR6uvr19r1x7U6tU79a9/HbRbv/7+nrriiplatWqO0tIi7NYvxifDMFRa2mQNW9i1q0a7dx9Ra2u3o0uzKT4+UFOnhik1NcwauDB1apiiovwIIgTGQEtLlzWQoaRkIKShtHTgc1PT+DkfY7FIsbGBSk4OUVJS6LH3gaCGxMRgAhoAje/xOQAAp7N3b61ee22v3n77gOrrO+zat6+vh77+9Wm6+up0ZWQkcC7LBO3tPdYHXRDUAFdHCAMwtghhACYwQhjGh/PP/7P2768bdvn8+dH6xz+uMbEiYGR6evr0/PO79N//vUktLSM7QTd1aqgefvh8XXBBkp2rg7Pr6+vXm2/m6de/3qhDh46OuJ+ICF/dffcSffe755x00ggAxoqznaRub+9RTk6F/vnPUq1dW2rXJ3HZ4ufnqeXLJ2vlyiRdeGGS4uICTdkugPFn8Elt27ZVaevWw9q2rUoHDtSrv991D4MGB3tr2bIEZWUlavnyyUpKCuFiYgBjwjAMNTd3qaqq1RrWMPg6Pqihrs6+F5Xg1AIDvYYELQy8whUc7OPo0gBJUmtrt/Ly6o4LZziivLw6dXY673mngAAvzZ0brczMeGVmJmju3GiOAwIAHK64uFFPPrlFb76Zp56e0YXgenq66corZ+rWWxeOi8B6Zzt+PlZKS5v04ou79Oqr++x6cfeSJXG6/vpzdfHFUxnzQIZhqKKixRq4sHNnjXbvrnHaQFtvb3elpIRaAxamTRt4JSeHyt/f09HlATimoaHjWDBDk0pLvwhqKClpcvpAl7NhsUhxcYHWcIbk5NBjAQ0hSkwMlrc3AQ2YGCbK+BwAgEENDR16550DevXVfdqz54jd+1+4MFZXX52uf/u3VAUGetu9f4yOraCGw4cH5hPUALNZLAPBLV5e7mpp6VZ/v0EIAzDGCGEAJjBCGMaHBx/8VM8+u2PY5e7uFhUW3sKT3eHU1q0r1wMPfKr8/PoRrR8Q4KV77lmiG2+cy8UjE1xnZ69Wr96pxx/fMqqDGomJwbr33gxdcskM0kQBjDlnOEldWtqktWtLtWZNqXJyKtTVZU4NKSmh1tCFpUvjuDgFwJhpbe3Wjh3V2ratSrm5Vdq2rcruqfT25OnppoULY7V8+WRlZSXq3HMnyd3dzdFlAYBVV1evqqvbhoQzHB/cUF3dqurqNo49nyEPDzdNmxZ6LGQhUjNnDgQuxMUFEroDl9Pb26+iogZrMMOePQPvznoBkp+fhxYtilNmZoIyM+N17rnR8vBg3AUAMMfu3TV6/PEtev/9Qo326i0/Pw9de+05+tGP5is2dvwE3DrD8XMzdXT06G9/K9Dq1Tu1c2eN3fqNivLXv//7LH33u+eMq58PDM8wDFVVtWrnzppjoQvV2rWrRg0Nzjcuj4jwtYYsDLyHaurUMCUkBHFMFHBhhmGotrZdpaVNKi39Iphh8HNbW4+jS7QbNzeL4uMDNWXKQDhDcnLIsYCGUCUmBnMtG8aViTY+BwBMTH19/frsszK9+uo+ffRRsd3/3kVH++vb356pq65K19SpYXbtG+Y7VVDD4cNHj70IahjPfHzc5e3tIW9vD/n4eFinT/zs7e1+bN6Jn0+33sD0iZ89PNys15G4u1t05Ei7ZsyIcvB/DWB8I4QBmMAIYRgfPvywSNdd93ebbV599RJdeGGSSRUBZ668vFk//3m2PvigaMR9XH11uu6/f5kmTfK3Y2Vwdc3NnXrqqVz94Q/b1dHRO+J+Zs2K1IMPnqcVKxK56QHAmHHESequrl5t3nxIa9aUau3aUhUVNY75NqWBpxZlZMTroouSdcEFU8bFk9gAuCbDMFRa2jQklGHfvlr19TnuUOmMGeHKykpUVtZkLVkST5giAJdnGIbq6zusoQyHDw+ENAyGNgy+NzU55xM3x0psbMCxsIUIzZwZqbS0CE2bFsbF2BjXBm8A27PnyJBwhvLyZkeXdhJ/f08tWTIYypCg2bOjCGUAANiVYRjavPmQfvvbz/Xpp2Wj7i8kxFs33jhXN944V2Fhvnao0LlM5Ju8duyo1vPP79K77x6wW3Cyu7tFX/5yiq6//lydd14C5z/HkZqa/8/efYdHVeV/HP9Meu8hnZJEOgRQukpdXdvaFey9YN2f7q6Lve/q6q64urpKEXbFuva1ga4KSFNqEDGEkk4gvZeZ3x9Jhtw0UiYzycz79TzzZM6Ze8/9JoTk5M65n1tuCFvYujVP+fkVji6rlfj4QKWkRGncuGilpERpzJgBCg93vp9dADpmsVh06FBTQENDOEN6emFjQEORKiqcLaAhqDGUoSGYoen5wIEENKD/ceX5OQDA+e3dW6iVK3fqrbd2KTe33KZje3m569e/TtL8+aM0Y8Yg3ntyMc2DGpqCGQhqsA1PT7cOAwsaQhLc5evr0Y3AhI7H7AvnVpvm58HBfg6uBHBuhDAALowQBudQWFip4cP/0eGdMW699QQ98MDJ9isKOIaKilo9//wmvfDCJlVVde9n0IQJ0Xr88Vk6/vgYG1cHZ5KbW6a//GW9/v3vHT26oO7EExN0//0nafz4aBtWBwAN7PUmdXZ2qVat2qdVq/bp228P2m3xSnx8oObOTdTcuUM0fXqC/P097XJcAOiqiopabduWp82bc7R5c7Y2b87p1YXKAwb4a8aMgTr55IbghejogF47FgD0ZRUVtdZAhqbH0XbDnSLy8sodGpTTHQEBXho+PNwatDByZEPwQkiIj6NLA/qM4uIqpabmNwYz5GvHjkP6+ecjqqszO7o0q8BAL02dGt8YyhCvUaMiuRsvAKBbLBaLvvxyn557bqM2bcru8XhRUf66+ebjdcUVY506yJGLvKSCgkqtXJmqZcu26cAB24VYJSeH6qqrUnTxxSMVHMzfKf3J4cMV2r69IWhh69Y8bduWp5ycMkeX1Up0tL81bGHcuCiNHRulyEgWhAPoWENAQ7k1kCE9vSGkoSmwoaKi+zdi6Wvc3ExKSGgroCFUAwcGydOTgAb0PczPAQDOprS0Wh98sEcrV6ba5JxdS2PGDNAll4zSuecOd8oAVdhO07qJrKz+F9Tg5mayhhm0HVjg0RiC0Lngg462bbmfq79vSwgDYB+EMAAujBAG5zF79grt3Jnf7uvjx0fp888vtWNFQNssFos+/HCPHnroW2VllXZrjMhIP91//0m66KKRcnNzfHoc+oe0tAI9+eRaffTRLz0a56yzjtPChScqKYk7twOwnd56k7quzqzNm7OtwQu7dh22ybjH4uHhpsmTYzVnzhDNnTtEw4aF94nEVwDoKovFoszMUm3enK0ffsjR5s052rHjkGpru3dRoJ+fh6ZOjdeMGYM0Y8YgDR/Oz0cA6Kz6erMOH66whjRkZ5cZghuanpeV1di9Nnd3k5KSQq1hC02BCwkJQfycB7qhurpOe/YUaOfOQ9Zghp078x3y/7stwcHemjo1XieemKBp0xI0cmQE56kBAB2qqzPrww/3aNGijTY5Rzt4cLBuvXWiLr54pLy9PWxQYd/GRV5Hmc0Wff31fi1duk1ffpne4Y06usLPz0Pnnz9CV12VojFjBthmUNhMUVGVtm1rCFpoClzIyChxdFmtRET4GgIXUlKiCJ0FYHMWi0V5eU0BDYXWkIZ9+4q0f3+RUwU0uLs3D2gIVWJiiPV5QgIBDXAc5ucAAGdgNlu0bl2GVq5M1ccf/6LKStvOI8PDfXX++cM1b95ojR4dadOx4dqOFdSQl1em2lqzNdCgecBBy2AEY0iCu3x9Pa3BBx2HILQMTXDn7xMHIoQBsA9CGAAXRgiD87j//v/p5Zd/bPd1NzeTfvllgQIDve1YFWCUmpqve+/9WuvWZXZrfw8PN91ww3jdddcUvpfRbT/+mKPHHlujNWsyuj2Gu7tJl1wyWr/73VQWjgCwCVu+SZ2fX6Gvvtqv1av36euv96u4uLqn5XXKgAH+mjNnsObOHaIZMwYpKIjf1QCcU1VVnXbsOKTNm3MagxmylZ3d9l3m3NxMGjcuqjF0YaCOPz7GJS6OAABHKi2ttgYzNA9naP7Izy/v9sVK0dH+1qCFESMiNXJkhI47Lkw+Pvx8B3qT2WzRwYPF2rHjkFJT863hDH3hbr9hYT6aOjVe06cnaPr0BIK2AABW1dV1evPNXXr++U06cKC4x+ONHBmhO+6YpHtreeUAAIPxSURBVLPOGioPD9e5uxcXebXtwIFiLV++Xf/+9w4VFNjuDngTJ8bq6qtTdNZZx3EeywFKS6u1ffsha9jC1q252r+/5z8/bC001McQtjBuXLRiYwOYBwNwKIvFotzcssaAhqMhDU0BDba+sM6R3N1NGjgwuDGUoSGYYciQhpCGgQODXWquCPtjfg4A6M8OHizWm2/u0ptv7tLBg7b9e9vd3aQ5c4Zo3rxROuWUxFa/MwGgNxDCANgHIQyACyOEwXl89tleXXHFBx1u8/rr52ju3EQ7VQQcVVBQqT//eZ1ee227zObuTTtmzRqkxx6bpeOOC7NxdXBFFotFX399QI8++p1SU/O7PY6vr4duuGGCbr31BAUH+9iwQgCupidvUpvNFm3blqdVq/Zp1ap0bd2aZ7O7X3XEZJKOPz5Gc+cO0dy5QzR69ADu/AnAZWVnl+qHH3L044+5qq6uk7e3hyZMiNZJJw1USAjzRADoa2pr63XoUIVyckqtQQ3Z2UdDG3Jzy1RTY1Z0tL9GjozU8OHh1uCFsDBfR5cPoJnDhyuUmtoQyLBzZ7527jyktLTCbp+HtoWICF9Nm5agadPideKJCTruuDAuRgMAF1NWVqPXXtuul176QXl55T0eb+LEWN155yTNnTvEJX+ncJFXx6qq6vThh3u0dOk2/fBDjs3GjYjw1aWXjtEVV4xVQkKQzcbFUWVlNdq5M98atrBtW57S0godXVYrQUHeSkkZYA1bSEmJ0sCBQS758whA/2U2Nw9oKLSGNOzf3xDSUFXlPPMLDw83DRwY1BjQEKrExJDGgIZQJSQEEdCAHmN+DgDobyoqavXJJ7/ojTdS9d133b+BX3uGDg3TvHmjdOGFIxQVxY39ANgXIQyAfRDCALgwQhicR1FRlYYNe7HDC+4WLDheDz00w35FweXV15u1fPkO/elPa1VY2L27bwweHKxHH52pU05J5E182JzZbNF77+3Wk0+u61GiaWioj+64Y5KuuWYcd74E0C1dfZO6qKhK//vfAa1atU9ffbVPhw9X9mZ5VqGhPpo1a7Dmzh2iWbMGKzycC9AAAADgfFhECvRvFRW12r37sHbsaAhl2LkzX7t25TvsjpcDBvhr+vR4TZuWoBNPTFBiYgjnugHASRUUVOqVV7Zo8eItKiqq7vF4s2cP1h13TNKUKXEu/buD+Xnnbd+ep6VLt+k//9lts7mPm5tJp5ySqKuuStHMmYMIY+6myspapaY2BS7kadu2PO3ZU+DQ8LC2+Pt7auzYAUpJida4cVEaNy5KgweH8O8OwKmZzRbl5JQpPb3QENLQFNBQXe08cw9PTzcNHBjcGNDQEMzQFNKQkBAkd3cCGnBszM+dV12dWUeOVOrw4Qrro6amXpGRfoqNDVR8fJCCgrwdXSYAdIrFYtEPP+Ro5cpUvf/+zyotrbHp+IGBXjr33OGaP3+UJkyIdulzdwAcixAGwD4IYQBcGCEMzmXu3H9p+/ZD7b4+blyUvvjiUjtWBFf2/feZWrjwa6Wm5ndrfz8/T/3f/03WjTdOkLc3F7Wjd9XU1Gv58u169tn1PbqQOS4uUH/4wzRdeOEI3pgE0CXHepPaYrFo167DWr16n1at2qdNm7JVX2+fP+XHjBmguXOHaO7cIZowIZqfbwAAAHB6LCIFnE99vVnp6UXasiVX69ZlaM2azB6FsvZEdLS/pk9PsD4GDw5mcR4A9HPZ2aX6xz9+0IoV21VR0bML300m6ayzhuqOOyZpzJgBNqqwf2N+3nVFRVV6441ULV26Tfv2Fdls3CFDQnTVVSmaN2+kQkMJaW5PdXWdfvrpsDVsYevWPO3efdhu7+t0lq+vh0aPHqBx46KUktIQuJCUFMr7QADQjNlsUXZ2qdLTi6wBDfv2NTzfv9/5AhoGDWoKaAg1fIyPD+T3A6yYn/cfFotF5eW1OnSoXIcPG8MV8vMrmrUrlZ9frsLCqg5vBCg1XHQcFxfY+AiyPo+PD1RsbMOj5fcIANhTXl6Z3nrrJ73xRqp++aXApmObTNJJJw3U/PmjdPrpyfL19bTp+ADQHYQwAPZBCAPgwghhcC4PPPCNXnrph3Zfd3Mzac+eBSSRoldlZZXq4Ye/1fvv/9ztMc4/f7geeOAkxcQE2rAy4NjKymr04oub9Y9//KDy8tpujzN8eLgWLjxRp56ayAJqAJ3S1pvUZWU1+u67g1q1ap9Wr96n7Owyu9QSEOClmTMHae7cIZo9e7CiowPsclwAAACgr2ARKeAaMjJKtHZthvWRmVnqkDri4gI1fXqCTjwxQdOmxWvgwGCH1AEA6Lr09EI9//wmvfXWLtXWmns0lqenmy66aKRuvXWikpJCbVShc2B+3n1ms0XffHNAS5du0xdfpMtsts0SQR8fd5133nBdffU4paRE2WTM/qq2tl67dx+xhi1s25anXbvye/wzwda8vNw1enSkNWwhJSVKQ4eGy8ODC2oBoLvq683Kzi6zBjM0BDUUNgY0FDvVnMXLy90a0NAUzpCY2PA8Lo6ABlfD/NyxamvrVVBQqfz8ynYCFYztqir7/vuYTNKAAf4dBjVERvqxphKATdXU1Ovzz/fqjTdS9dVX+20egjhwYLDmzx+liy4aqYSEIJuODQA9RQgDYB+EMAAujBAG5/LFF+m67LL3O9zmX/86R6eckmifguBSqqrq9OKLm/XccxtVWdm9O7yMHTtAjz8+S5Mnx9m4OqBr8vMr9Ne/rtdrr23v0QKZSZNidf/9J/E9DeCYvLzcZbFYtHdvoT7/PF2ff75X69dn2W2ePmxYuObMGay5c4do0qQ4UukBAADg0lhECrgei8WiAweKtW5dptasaQhlyMmxTxhiSwMHBmn69ARNm9YQzBAXR1gxAPQ1O3Yc0qJFG/XRR7/0+KJ2Pz8PXX75WN188/GKjeVnfluYn9tGZmaJli/frn/9a4cOH6602bgTJkTr6qvH6eyzh8rHx8Nm4/ZFdXVm7dlzNHBh+/Y87dyZ3+fugu7h4aaRIyOsgQvjxkVr2LBw3vsBADuqrzcrK6u0MZihyBrU0BDQUNTnwnp6wsvLXYMHB2vAAH8FB3s3PnwUEuKj4GBvhYT4KCSkoe/oa97y9OT3Un/F/Ny2LBaLyspqlJ/fPDyh/YCFgoIqR5fcY97e7oqNDWwW1HA0sKEpqCEgwMvRZQLoB3bsOKQ33kjVu+/+ZPOfj35+HjrzzKGaP3+Upk6Nl5sb4TEA+iZCGAD7IIQBcGGEMDiX4uIqDRv2jw4Xetx00/F65JEZdqwKzs5isei//03Tgw9+q4MHi7s1Rni4rxYunK5LLhlNMjb6lP37i/SnP63Tf/6zu0fj/PrXSVq4cLqGD4+wUWUA+rvKylqlpzcstkhLK1R6eqE2bszWvn1Fdjm+r6+HTjwxQXPmDNGcOUM0aBB32QQAAACasIgUgMVi0b59RVq7tiGQYc2aTB06VO6QWgYPDtaJJx4NZYiODnBIHQAAaf36TD333EatXr2/x2MFB3vr2mvH6frrJyg83LfnxTkx5ue2VV1dp08+SdOSJVu1cWO2zcYNC/PRJZeM1pVXpjjFew719Wbt3VuorVvzrKELO3ce6vYNKXqLu7tJw4aFa9y4KKWkRGvcuCiNGBHh9IEYANCf1deblZlZaghmSE8vVHp6kQ4cKFZdnfMENHTEz8/TGs7QPKSheXhDU2hDyzAHfs85FvPzY6utrdeRI5WGAIWOAhb6WqhXXxAS4q24uKA2gxri4gIVHe1PmAvgogoKKvXuuz9p5cpU7dyZb/PxJ02K1fz5o3T22cMIhAHQLxDCANgHIQyACyOEwfn86lf/1rZtee2+PnbsAK1adZkdK4Iz+/nnI7r33q/17bcHu7W/u7tJ11wzTr/73VSFhPjYuDrAdnbsOKTHH1+jr77a3+0x3NxMuuiikfr976cqPj7IdsUB6LPMZouys0uVllaovXsLtHdvYePzQmVmlsjef4kPGhSsX/1qiObOHaKpU+Pl6+tp3wIAAACAfoJFpABaslgs2ru3UGvWZDQGM2Tq8OEKh9SSlBSq6dMTNH16vKZNS1BUlL9D6gAAV2GxWLR69T797W8bbXLB+oAB/rr55uN15ZVjWcjdSczPe8/OnflaunSr3n33J1VU2CZcwGSS5swZomuuSdGsWYP7xU0YzGaL9u8v0tateY2hC7navv2QystrHV2agckkDR0arpSUqMbQhSiNGhUpPz/e7wEAZ1FXZ1ZmZonS04saAxoKrTd3OHiwxGUCGo7Fx8fdGs7QPMTh6Mem11qGOvjIz89DJhN3su4JV5yfWywWlZbWWIMTmocrNAUr5OeXWwMWCgttezd2tObmZlJ0tL9iYwMVH28Ma4iPD1JsbKDCwnz4/w44ibo6s77+er9WrkzV55/vVW2tbedEMTEBuuiikZo3b5SSkkJtOjYA9DZCGAD7IIQBcGGEMDifhx76Ri+++EO7r5tM0s8/L+CCd/RIcXGV/vKX9Xr11S2qr+/eNOKkkxL0+OOzNHx4hI2rA3rPmjUH9eij32nLlvbDbo7F29td11wzTnfcMUlhYdzZCHAGJSXVjQELxqCF9PRCh94RydPTTVOnxmvu3IbghaSkUN5cBAAAADrBFReRAugai8WiPXsKrKEM69ZlqKDAMYurhw4NawxlSNC0afGKiGCBDZxb07m4pvNv6emF2ru3SAcPFqu+3qIBA/wUExOg6OgAxcYGKjo6QDExDY/Y2ABFRPj1iwuC4Xj19WZ9+OEeLVq0SampPb+r3sCBwbrttom6+OKR3Lm3i5if976Skmq99dYuLV26Tb/8UmCzcQcODNaVV47VJZeMVnh433hf1GKx6ODBEm3blqetW3O1bVuetm07pJKSakeX1kpSUqg1cGHcuCiNHj2A8BYAcGF1dWZlZJRo375C7dtXZA1nSE8/+vcQjs3T063d8IZjhToEBnqx5kLOMz+vra3XkSOVrUIVjAELldbn1dX98/N0Zb6+HoqLC2wMaghUXFxQi6CGAG5gA/RxaWkFWrkyVW+9tUt5eeU2HdvLy12nnZak+fNHacaMQZwzBtBvEcIA2AchDIALI4TB+Xz5ZbouvfT9DrdZvvxs/frXSfYpCE6lvt6slStT9cQTa3T4cGW3xkhICNLDD8/QGWck86YE+iWLxaKPP/5FTzyxVnv3FnZ7nMBAL91220Rdf/0E+ftzMh/o62pr63XwYIk1aKEpdCEtrVD5+Y6582VbYmICNHfuEM2ZM0QnnzyQxXgAAABANzjLIlIA9mM2W7R792GtXZuhNWsy9P33mSoqcsyFfCNGhDcGMjSEMhAEi/6oqqpO+/cXGcIW9u5taB8+3LNzce7uJkVF+TcGMwQ2C2wIsD6PiWERviurrq7TW2/t0t//vln79hX1eLwRIyJ0++0TdfbZw+ThwWLu7mB+bj8Wi0Vr1mRo6dJt+vTTNJtdzOnt7a6zzx6mq69O0YQJ0XZbJ2CxWJSdXWYNW9i6NU/btuX1yTsTDxoUrHHjoqyhC2PHRikoyNvRZQEA+ona2vrGgIaixoCGQmtIQ0ZGCQENNuLmZmoMavBuDGbwadFu+Nj0vHmoQ1CQt9Nc3NlX5+cWi0UlJdU6fLjSGqRgDFQwth117g59S3i4bwdBDYEaMMDfaf7vAv1FaWm13n//Z61cmarNm3NsPn5KSpTmzRul884bptBQ3j8B0P8RwgDYByEMgAsjhMH5lJZW67jjXpTZ3P6P9htvnKBHH51pv6LgFDZuzNa9936tbdvyurW/r6+Hbr99khYsOJ6Fa3AKtbX1WrkyVU8//X2PElajovx1991Tdcklo+Tp6X7sHQD0GovFosOHK7V3b0O4QvPAhf37i1VXZ3Z0ia24uZk0cWKs5s4dorlzh2jkyAhCjgAAAIAe6quLSAH0H2azRamp+Vq7NkNr12bo+++zHHJ3ZZNJGjkyUiee2BDIMHVqvEJCfOxeB9CW+nqzMjNLm4UsHA1cyMgokaNXsYSG+lgDGWJjj4YzNA9vCA314VycEykrq9Hy5dv10ks/KDe353fWO+GEGN1552T96ldD+D7pIebnjpGdXaoVK3ZoxYodOnTIdnebTEmJ0tVXp+icc4bJz8+26wby8sq0devRsIWtW/N6HN7TG+LjAxvDFqKVkhKllJQBXPgBAOg1TQEN6emFjQENR0MaMjJKOlxnCtsKCvJWSIh3u+ENTf1N2zQPc+hLa8rsOT+vqanXkSMVjcEK5crPr2wzUKHhUcnfCr3A3d3k0kEuHh5uiokJMAQ1NHw8GtYQHOzN3/1AD5nNFq1dm6GVK1P1ySe/qLKyzqbjh4f76oILRmjevFEaNSrSpmMDgKMRwgDYByEMgAsjhME5nXrqv7VlS/sXyo8eHamvvrrcjhWhP8vNLdMjj3ynd975qdtjnH32UD344MmKjw+yYWVA31BRUatXXtmi55/f1KOF1ElJoVq4cLrOPPM4TsoDvayyslbp6UfvpNc8bKG4uO8n3UdE+Gr27IbQhZkzB3HxBAAAAGBjXOQFwNbq683auTNfa9Y0hDKsX5+lsrIau9dhMkljxgzQ9OkJmj49QVOmxHGHZfQqi8Wi/PwKQ8hCQ9BCw91Z+/vvWB8fd0VFNYQ0xMQ0BDXExgZan8fEBCgqyr9PXSyD1goKKvXqq1u0ePFWFRZW9Xi8WbMG6Y47Jmnq1Hje77ER5ueOVVtbr//+N01Ll27TunWZNhs3JMRb8+aN1lVXjVViYmiX98/Pr9D27c0DF3JtEqBia9HR/tawhXHjojR2bJQiI1kQDQDoG2pqjgY0NPydVtgY0lCkzEwCGvoSf3/PxkAGn1YhDc3DGprCHJqHPfj4eNi0lp7Mzy0Wi0pKqq0BCg0fGwIWDh9uHbDQH9bw9Dfe3u6KjPRTRETzh68iI/0VEeFr7RswwE9hYb5yczMpP79CmZklys4uU2ZmibKySps9SnT4cKWjPy2H8vf3VHx8kGJjA6zhDE2BDXFxDf3e3rb9fwg4i4MHi/XGG6l6661dOniwxKZju7ubNHfuEM2bN0q/+lViq99fAOAsCGEA7IMQBsCFEcLgnB555Fv9/e+b233dZJJ2776ZJH10qLq6Ti+//KOefXaDKipquzXGiBEReuKJWZo+PcHG1QF9T0FBpZ57bqOWLNmq6uru/14dPz5K999/kk48caANqwNcj9lsUXZ2qdLSCrV3b0Hjx4ZHZqbj76TXVePHR2nOnIbghXHjouXmxuJdAAAAoLdwkReA3lZXZ9b27XnWUIYNG7K7fR6+J9zcTEpJORrKMHlynAICvOxeB/q/0tJqQ+hpQ9BCw8fSUvsHjvQlJpMUGemvmJgAw6N5YENMTAD/9xwgJ6dU//jHj1q+fHuPfwabTNKZZx6n22+fpJSUKBtViCbMz/uOn346rGXLtumtt3apvNx2c5dZswbp6qvH6Ve/GiJ3d7dWrxcWVmrbtkPWsIVt2/KUmVlqs+PbSkSEn8aNi7IGLqSkRCk6OsDRZQEA0C01NfU6eLC4MZShUPv2FVmDGjIzSwlo6Ed8fNzbDW1o2d88vCE42Ed+fh6twuVazs9LS6t15MjRAIVDhyqsz9sKWKitNdvz03cJYWE+1vCEjgIWIiP9FBDgZfPAwMrKWuXklCkzs1TZ2aVtBjVUVNj2rvb9TWSkn+Ljm8IZGoIajj6CFBnpx1owuIyKilp98skveuONVH33XYbNxx82LFzz5o3SBReMUFSUv83HB4C+hhAGwD4IYQBcGCEMzmn16n2aP/+9DrdZtuw3Ov30ZDtVhP7myy/Tdd99/9O+fUXd2j8kxFv33DNdV1wxVh4erRdJAM4sM7NETz31vd56a1eP3nCcNWuQ7rvvJI0ZM8CG1QHOp6SkWmlpBdbF3WlphUpLK9C+fUWqrOy/b+AFBXlr1qxBmjs3UbNmDdKAAbwhAAAAANgLF3kBsLfa2npt3ZqntWsztGZNhjZtynbIeQ13d5PGjYvWiScmaNq0eE2aFCd/f0+714G+qbq6TgcOFLcKWdi7t0iHDvW9O4/3NwEBXoqNbQhnOBrWEGgIboiIYEG+LaSnF+qFFzbrzTd39Xie5+HhpgsvHKHbbpuo5OQwG1WIlpif9z1lZTV6661dWrZsm3bvPmKzcePjA3XllSkaNy5KO3Y0hS7k6cCBYpsdw1ZCQ30MYQvjxkUrNjbA5he0AQDQF1VX1+ngwRKlpxcqPb1IubllKi6uUlFRteFjcXG1ywfz9Xeenm6NQQ1Hwxl8fT1UUFCp/PyGwIWSkmpHl+l0vL3dFRnZOlChddtXYWG+8vTs23d3t1gsKiqqahbS0BDMcPR5qXJzy1Rf77qXNHl6ujUGNLQX1BCowEBvR5cJdJvFYtHmzTl6441Uvf/+zzafHwQFeevcc4dp/vxRGj8+mr/NAbgUQhgA+yCEAXBhhDA4p7KyGh133AsdnpCaOjVOv/pVosLCfBUS4qOwMB+FhvoqNNRHoaE+ff6kHHpHWlqB7r//f1q9en+39ndzM+mKK8bqnnumKSzM17bFAf3M7t2H9cQTa/XZZ3t7NM555w3XPfdM0+DBIbYpDOiHamvrdfBgidLSCpSW1rDAu+l5fn6Fo8vrMX9/TyUnh+m448I0dGiYTjxxoMaNiyLICAAAAHAQLvIC4Gg1NfX68cdcrV2boXXrGkIZqqrs/7PI09NN48c3hTIkaOLEGPn6EsrgzOrrzcrKKm0RstAQtJCZWcKdTh3M09NNUVH+io4OUGxsQ0BDw/MA6/Po6AD5+Hg4utQ+aefOfC1atFEffrinx9/Lvr4euvzyMbr55hMUFxdoowrRHubnfZfFYtH69VlasmSrPvkkTXV1znlX46Agb6WkDLCGLaSkRGngwCAu6gAAoBPq6swqKalWUVFDKEPTx4ZHlaG/qKi62bYN/VzhAGdgMklhYb6N4Qm+ioz0V0SEb5sBC5GRfvL393S5uWZdnVl5eeXKzCxpEdRQpszMEmVllaqwsMrRZTpUUJC34uLaD2qIiQlg7T/6nNzcMr311i69+eYu/fJLgU3HNpmkk08epPnzR+m005J47wKAyyKEAbAPQhgAF0YIg/M67bTX9cMPud3ePyDAq1UwQ8PDt43+hr7AQG/uvtJPlZZW69lnN+if//xRtbXdWxgxdWqcHn98tkaPjrRxdUD/tn59lh577Dtt3Jjd7TE8Pd105ZVj9dvfTlFkJH8gwzlZLBbl51c0Biw0hCzs3dvw/MCB4n6/cM/NzaSBA4OUlBSq5OSwxo8Nz6Oi/OXtbVwYzfwcAAAAcBwu8gLQ11RV1enHH3O0Zk2G1q3L1ObNOQ752eTl5a7jj4/W9OkJmj49QccfH8PF3v2QxWLR4cOVrYIW0tMLtW9fkaqr+b3X34WH+yo6uiGYofWjYVF+cLC3y1zQsX59lhYt2qhVq/b1eKygIG9dd904XXfdeEVE8H6NvTA/7x/y8sq0YsUOLV++Xbm55Y4up9v8/T01duwApaREa/z4KKWkRGnw4BDWwgAA4ABms0WlpdWGcIaWYQ5FRVVthjwUFVV1eBMzoKd8fNwVGelvDU9oClVoK2AhPNyXG7HYQHl5bWNAw9GgBmNgQ6lDgmz7CpNJioryV1zc0XCGloEN4eG+LnM+CI5TXV2nL75I18qVqfrqq/02D/YdNChY8+eP0kUXjVR8fJBNxwaA/ogQBsA+CGEAXBghDM7r0Ue/0/PPb7LrMd3dTQoJMQYzNLSPBje07vMhedCBzGaL3nprlx57bI0OHereQojY2AA99NAMnX32UE7OAe2wWCz64ot0Pf74Gu3efaTb4/j7e2rBghN0883HKyDAy4YVAvZTWVmr9PSixoCFAusi77S0QpWUVDu6vB4LC/NRUlKYkpNDlZQUag1dGDw4uFXQQnMsIgUAAAD6DubnAPq6yspabd6co7VrM7R2baZ+/DGn2wHLPeHj464TTohtDGWI14QJMa1+hsJxyspqDCELR0MXipziPJzUcC4uMfHoeTg/P0/l5JQ1PkqVk1Om3Nwyl16A3x5fXw9FRwcoNjagRWBDoPX5gAH+/fYiEYvFoq++2q/nntuo9euzejxeZKSfbrrpeF111VgFBnrboEJ0BfPz/qW2tl6ff56upUu36rvvMhxdTod8fT00ZswAjRvXELaQkhKlpKRQubv3z599AADgKIvFovLy2mbBDFUqKqo2fGwZ2lBcXN34qCKg0AWZTA2hhs3DE1oHLBx9zd/fk/WyfYzFYtGRI5XKyiptfJS0CmrIyyuXK1855ePjrtjYwHaDGmJiAvjeRrft2HFIK1fu1Lvv7lZhYZVNx/bz89BZZw3V/PmjNGVKPEGJANAMIQyAfRDCALgwQhic11df7de8ef9xdBmd4uPjrtBQX4WG+igsrOFjSMjR5231hYT49NtFP33Fli25WrjwK/3wQ2639vf2dtctt5yg226bJH9/gjSAzqivN+vtt3/Sn/+8TllZpd0eJyLCV2eccZxCQnwUFOSt4OCGR9PzoKCjzzu66BvoLWazRVlZpY2LuwuUltYQspCeXqjMzJJ+/2aWl5e7hgwJaQxYaAhZaFroHRbm2+0xm2N+DgAAADgO83MA/U15ea02bcpuDGXI0Nateaqrs38og6+vhyZObAplSND48VHy9CSUoTfV1NTrwIHiFiELDY+8vP57F/LmfH09DEELDc9DlJjYuXNxFotFhYVV1kCGnJwyZWeXWp83PWy9MNgZuLmZNGCAn2JiAhoDGwKtz2NiGtrR0QF96n3C+nqzPvroFy1atFE7d+b3eLyBA4N1yy0naP78UfLx4f0WR2F+3n/t2XNEy5Zt05tv7lJpaY1Da/H2dtfo0ZFKSYnSuHHRSkmJ0nHHhbHuBAAAtKmy8miAQ/PQhvbCHJq3KyrqHF0+Gvn6eigy0hie0F7AQni4L2FcLqC2tl45OWXNghpaBzYUFztHeGl3eXm5W9eehoQ0rUNtWKfavH30eUO7aQ0r54Ndy5EjlXr33Z+0cmWqUlN7fi6upcmT4zR//ij95jdDuXEdALSDEAbAPghhAFwYIQzOq6ysRkOHvuiQRXb2EhTk3RjS4GMNcWh4+Fr7GoIbjvYFBHi5fELnoUPleuKJNXr99dRuj3H66cl6+OEZGjQo2IaVAa6jqqpOS5Zs1XPPbez1hZ0+Pu4KCvJRUJBXs6AGn8agBi/r8+ZBDs3DHHx9PVz+5ybaV1JSrbS0AmvAQkPYQoH27StSZWX/f1M5JiZAycmhSkoKswYuJCWFKiEhyOZvvLKIFAAAAOg7mJ8D6O/Kymq0cWOW1q7NtIYymM32XxLg5+epyZOPhjKkpERxoWM3mM0WZWeXthm0cPBgiUP+bW3N3d2kQYOCm4UsHH1ERwfY5c5mlZW1ys0tV05OqTWYITe3TNnZR5/n5ZU79Xuv3RUU5K3Y2KPhDA2PQOvz6OgAhYf79uq/Y3V1nd5++yf9/e+blJ5e1OPxRowI1223TdI55wzj51YfwPy8/ysrq9F//rNbS5Zs1a5dh3v9eJ6ebho5silwIUopKVEaPjyci4EAAIBd1NTUq6ioSiUlDSEOLcMcioqqVVLSOsyhqKhaZWWODa7q69zcTAoL81VkpG8bYQqt230pNBD9R2lptbKyGgIZMjNbBzXk5JTxd2kH/Pw8rKEMbYU0NH8tJMTbsH41KMjbLucB0TN1dWZ9/fV+rVyZqs8/36vaWtueL42JCdDFF4/UvHmjlJgYatOxAcAZEcIA2AchDIALI4TBuZ1//jv67ruDji6jT/HwcDMEMzSFODT0+VpDHJoCHZr6nOFO8jU19Vq8eKv+8pfvu32XiaFDw/TYY7M0c+YgG1cHuKbi4iq98MJmvfzyj332gnVPTzcFB3srMNC7xYnxo33thTsEB3vL39+TEId+rra2XgcPlljDFvbubfpYqPz8CkeX12P+/p7NAhbCrEELiYmhdk1PZhEpAAAA0HcwPwfgbEpLq7V+fZbWrMnQunWZ2r49T45YIRAQ4KUpU+IaQxniNWbMAO4w2MhisejIkcpWIQvp6YXat69IVVXO8bsoNjZAiYmtgxYGDgzqFxfG1tebdfhwhTWkITu7IZyhqd0U4FBeXuvoUvscLy93RUf7Kzo6QLGxgS0CG46GNbSchx1LWVmN/vWvHfrHP35QTk5Zj+s8/vgY3XHHJJ1ySiKL/vsQ5ufOw2KxaOPGbC1dulUfffSLTS7UcHc3afjwCGvYwrhxURoxIsIp1ngAAADXU1dnbhXe0PSxvVCH4uKjH/vjFSF+fp7W8ISGAIX2AxbCwnw4lwSHM5stys+vUFZWSbOABmNQgzOsqXMEk0mGNanN16U272vebghzaFi3ylrV3vXLLwVauXKn3n77J+Xlldt0bG9vd512WrLmzRulGTMG8rMeALqAEAbAPghhAFwYIQzO7ZtvDujCC991dBlOwc/P0xrMEBrq22ZwQ8u+4GDvPnMS4Ouv9+u++/6nX34p6Nb+QUHe+v3vp+rqq1P6xSI4oL/JzS3TX/6yXv/+9w7V1zvX1NzNzdROYIN3Y2BDx+EOgYGkG9uDxdLw5tDevYVKSyuwLvJOSyvUgQPF/f7ubm5uJg0cGKTk5DDrwu7k5FAlJ4cpKsq/T7z5wiJSAAAAoO9gfg7A2RUXV+n777O0dm2G1q7NUGpqvkMW6QcFeWvq1KZQhgSNGhXp9OcCy8pqtG9fkfX8W/PQheLiakeXZxMhId5KSgozhCwkJoZqyJAQl7kDZWlpdauQhuzsUkNgA4vx2xYR4WcIZYiNPfo8JqYhwCEw0EtFRVVavHirXnlliwoLq3p83BkzBunOOydp2rT4PnG+GEbMz53ToUPlev31nXrtte3Kyirt1D4mkzRsWLg1bCElJUqjRkXK19c1fr8AAAB0xGy2qLS02hrO0DykoWWoQ1v9tlqz5uZmUnh48yAFX0VG+je2jQEL4eF+LnOuAK6lurpO2dlljUENZa0CGzIzSwjx7AUeHm6t1qeGhPi0CmtoGejQ8Jo3YX5tKCmp1vvv/6yVK1P1ww85Nh9/3LgozZs3SuedN1whIT42Hx8AXAEhDIB9EMIAuDBCGJzf4sVbdO+9/5PZzI96ezOZpJCQpmCGhqCG5kEOoaHNQxyO9tkyiXPfviI9+OA3+uyzvd3+HC69dLT++McTFRnJpBzobWlpBXryybX66KNfHF1Kn9GUbhwU5NXsBLhPY4CDlyHpuL1wBw+PvhGI0xdUVNRaF3mnpRUoLa1hkXdaWqFKSvr/Iu+wMB8lJYUpOTm0WdhCmAYPDu7zb5KwiBQAAADoO5ifA3A1hYWVWrcuU+vWZWrNmgz99NNhh9QREuKtqVPjraEMI0ZE9MtQhpqaeh08WNxm0EJurm3vEOYovr4eGjIkxBCy0PQ8LMzX0eX1CzU19crLK1dOTkNQQ3Z2qfV58wAH5iGt+fl5ymKxqLKyrkfjmEzSGWccp9tvn6hx46JtVB16A/Nz51ZXZ9aXX6Zr6dJt+t//DhheS04ObQxciFZKSpRGj45UQICXgyoFAABwXhaLReXltc2CGaraDXOorTUrNNRHkZENYQphYb6GcIXQUJ8+c/MyoK+yWCwqKalWZmapsrNLlZlZ2iqoISenrN/fOKm/8fFxV1CQT4uQhtbrU41hDj5Ot07VbLZozZoMrVy5U//9b1qPz8G1FBHhqwsuGKl580Zq5MhIm44NAK6IEAbAPghhAFwYIQyuIT29UF9+uU8//3xYBQVVKiysVGFhlfXBv3/f4uXl3iyYoSGcISysIcyh6XnLvtBQH8Pik7KyGi1atFEvvvhDt/99TzghRk88MYtFR4AD/Phjjh57bI3WrMlwdClOwd/f0xDK0FZQQ9MJ8cBAr1ZBD3394v2WzGaLsrJKlZZWYA1YSEsr1N69BcrM7NydhPoyLy93JSaGKDExVMnJDSELzrDAm0WkAAAAQN/B/ByAqzt8uELff5+ptWsztHZtpn7++YhD6ggL89G0aQmaPr0hmGHYsPA+c4d6s9minJyyViELe/cW6uDBYpvdPdKR3N1NGjgwuM2ghZiYgH4ZkNHfWCwWFRRUKSenTDk5pY0fjz5vCmwoKur/Abv25OHhpgsuGKHbbpuo444Lc3Q56ATm567j0KFy7dp1WH5+nho+PFxBQd6OLgkAAAAtMD8H7KO+3qxDh8rbDWrIzi7V4cOVji4Tzfj7exoCGoxhDcbAhpAQb2vgQ0iIt/z9vRx+vvXAgWK98Uaq3nprlzIySmw6tru7Sb/6VaLmzRulX/1qiDw93Y+9EwCgUwhhAOyDEAbAhRHCgKYE24ZAhqPhDAUFla36CgsrVVBQpaKihge/PfqWgAAva3BDbm65Dh3q3t2UoqL8df/9J+mCC0Y4/IQO4MosFou+/vqAHn30O6Wm5ju6HJfm6+uhwMCWgQ3e1r5j9fv4ePTK4vCSkmqlpRU0Biw0PNLSCrRvX5HN04cdISYmQMnJoUpKaghZaHgeqoSEIKdMzOdNagAAAKDvYH4OAEaHDpVr3bqmUIYMpaUVOqSOiAg/TZ8er2nTEnTiiQlKTg7t9VCGgoLKNoMWnOUcnCRFR/u3CllISgrVwIHBrX4nom+qqKi1BjLk5JQpO7vU0M7JKVNeXrnMZtd+c9fX10OXXjpaCxacoPj4IEeXgy5gfg4AAAD0HczPgb6joqJWOTlljcEMJa0CG7KzS1VR4RznMJ2dm5tJQUFeCgryUUiId7Owho6CHI4+9/Xt3hrViopaffzxL1q5cqfWrs20+ec1fHi45s0bpQsuGKEBA/xtPj4AgBAGwF4IYQBcGCEM6K76erOKi6utgQ1FRVUqKDga2tBWX2FhJSdz+jBPTzfddNPx+u1vJysgwMvR5QBoZDZb9N57u/Xkk+t08GCxo8tBN3h5uTeeIG86Od508rupz6fZay0DHbyUl1feGLBQqL17G0IX0tIKdfhwhaM/tR7z9/dsFrAQpuTkUCUnh2nIkBCX+13Em9QAAABA38H8HAA6lptbZg1lWLMmQ/v2FTmkjqgof0Mow5AhId1aaFpeXqv09MLGR5EhdKGwsKoXKre/4GBvJScbgxYSE0Nd8jycq6qvNys/v0LZ2aXKySmzhjRkZ5c1C2xwzoX5QUHeuvbacbruuvGKjGQRYn/E/BwAAADoO5ifA/2HxWJRYWFVY0hD66CGpvNErh7c6Qwa1qg2D2swrkttHuAQHOwtSfrooz16//09KiursWktwcHeOvfc4Zo/f5TGjYvq9SBlAHB1hDAA9kEIA2AjBw8e1Pbt25Wbm6va2loFBQUpMTFREyZMkLe3t6PLaxMhDLC3qqq6xnCGpmAGY3DD0b6G/oKCKhUVVamuzuzo0p3aKack6pFHZigxMdTRpQBoR01Nvb76ar++/nq/MjJKVFJSrZKSahUXNzwqKmodXSLQJjc3kwYODFJycph1gXdT2EJUlD8n2RvxJjUAAADQdzA/B4Cuyc4u1dq1GY2hDJkOC5ONiQnQ9OkJmj49XtOnJ2jQoGDruafa2nodPFhiDVhoClnYu7dQOTllDqnX1nx83DVkyNGQhaaghaSkUIWF+XAeDsdksVhUUlLdGMhgfOTmlik7u1S5uWU6fLjS0aV2SmSkn268cYKuvjpFgYF9c70GOof5OQAAANB3MD8HnEtdnVm5uWXKzCxVQUGldU1qUVFVs/WpVdZ1qiUlDa+Vl7NeFUeZTNKMGYM0f/4onXZasnx8PBxdEgC4DEIYAPsghAHooVWrVunFF19Uampqm6/7+fnpvPPO0y233KKwsDA7V9cxQhjQH1gsFpWV1aigwBjM0PS87b6Gkz/oWGJiiB57bKbmzk10dCkAeqi2tl6lpTXWE91NJ78bwhpqrM+bXm/+vLi4WqWltk2zhesJC/NRUlKYkpObghYaQhcGDw6Wtzcn1Y+FN6kBAACAvoP5OQD0TEZGiTWUYe3aDGVmljqkjvj4QCUnh+ngwWIdOFCs+vr+vyyiKfC0ZchCUlKoYmMD5eZG0AJ6X3V1nXJzy63hDDk5RwMamvfV1jomZH/gwCAtWHCC5s8fJV9fT4fUANtifg4AAAD0HczPAUgN4Q1NgQzN16IWFVU1e16tkpKjAQ5HgxyqVFXFzw5nMHhwsObPH62LLhqpuLhAR5cDAC6JEAbAPghhALqppqZGCxcu1EcffdSp7cPCwrRo0SJNnDixlyvrPEIY4Mzq6syNwQxVKiioVGFhQ1BD0/O2+goLK13ixI6/v6fuumuKbrhhQquT4gBcU329WaWlNa3CGdoKbDCGOzScFC8pqZHZzJ8Vzs7Ly12JiSHWhd1NQQsNd9PzdXR5/RpvUgMAAAB9B/NzALAdi8WiAweKtW5dptasaQhlyMkpc3RZfV5UlH+bQQuDBgXzvg76BbPZoiNHKpWb2xDQYAxsOPrclqH6w4aF6/bbJ+qcc4bJ05P/J86E+TkAAADQdzA/B2ALVVV1zdaktgxqqDKsV20e9ND0mjME7vZXfn6eOvvsoZo/f5QmT46TyUQwMAA4EiEMgH0QwgB0g9ls1q233qrVq1cb+t3d3RUTE6PAwEBlZmaqtNR4ZxdfX18tXbpU48ePt2e57SKEAWitoqK2MZihIZShIZyh4XlbfU3P+8vFxxdfPFL33XeioqICHF0KACdiNltUXl7TGMzQ/KR3e0EO1SotNfbV1TnmrlhoLSYmQMnJoUpKCmv82PBISAiSu7ubo8tzSrxJDQAAAPQdzM8BoPdYLBbt21ektWsbAhnWrMnUoUPlji7LIYKCvJWUFGIIWWgKXQgI8HJ0eYBdlJXVWAMZjj6OhjZkZ5fp0KFydbSqacKEaN1xxySdemqS3NxY9O2MmJ8DAAAAfQfzcwCOZrFYVF5eq5ISY0BDUVHDDcVaBjo0bGdcw4qumzIlTvPnj9JZZw3l/DUA9CGEMAD2QQgD0A3//Oc/9cwzzxj65s2bpwULFigqKkpSQ1DD6tWr9cQTTyg7O9u6XXR0tD7++GMFBgbatea2EMIA2IbZbFFJSbUhmKGgoHVYQ0FBlYqKjgY6lJXV2K3GceOi9MQTs3TCCbF2OyYAdJbFYlFFRZ01mKHhZHdVs8CGmlYJx823LS6uZj7TRf7+nkpODlNSUog1bCE5OUxDhoRwktwBeJMaAAAA6DuYnwOA/VgsFu3dW6g1azIagxkydfhwhaPLshlvb3clJhqDFpqeh4f7cpcwoBPq6sw6dKhcOTllys4uVW5umfLzK+Tj46GTTx6o44+P4f+Sk2N+DgAAAPQdzM8B9Hf19ebG9ajV1iCH5s+b32is+ZrVptcqKuoc/SnYTWxsgC6+eJQuvnikEhNDHV0OAKANhDAA9kEIA9BFhYWFmjNnjsrLj96V5a677tINN9zQ5vZ5eXmaP3++srKyrH233HKLbr/99l6v9VgIYQAcq6amXoWFxmCGpo8t+4qKqhqfV3Xp/2xEhJ/uu+9EzZs3iru/AHBqVVV1rcIZmqcXH33eOtzBWU+Ou7mZNHBgUGPYQsPi7qawhagofxam9iG8SQ0AAAD0HczPAcBxLBaL9uwpsIYyrFuXoYKCKkeX1SE3N5MSEoJahSwkJYUqNjZA7u5uji4RAPo15ucAAABA38H8HICrq6mpbxbUUGW4kVjTWtSioqb1qq1fr601O/pT6JC3t7tOPz1Z8+aN0sknD+T8NgD0cYQwAPZBCAPQRU8//bReffVVa3vixIlasWJFhxexff/997rqqqusbX9/f61evVqhoY5NhCOEAeh/LBaLystrreENBQWVKixs+NgQ3NDw3MvLXSkpUTr//OEKDPR2dNkA0Oc1nRw3BjZUNwts6DjcoaysxmG1h4f7KjGxIWChIWihIXRh8OBgeXt7OKwudB5vUgMAAAB9B/NzAOg7zGaLdu8+rLVrM7RmTYa+/z5TRUXVDqllwAB/JSWFtApaGDSIc3AA0JuYnwMAAAB9B/NzAOg+i8Wiyso665rToqIqwxrVptCGhiCH1q+VlNTIbO6dy//Gj4/SvHmjde65wxQS4tMrxwAA2B4hDIB9EMIAdIHZbNb06dNVUFBg7Xvttdc0ZcqUY+576aWXavPmzdb2gw8+qEsuuaRX6uwsQhgAAABso67ObA1qKC2tMZwQbxnY0Ly/aZ+Skmp19JeZl5e7EhNDrIu7m4IWkpNDFRrqa79PFL2CN6kBAACAvoP5OQD0XWazRamp+Vq7NkNr12bo+++zVFJiu1CGwECvViELDe0QAq8BwEGYnwMAAAB9B/NzAHAcs9mi8vIaFRU1rTmtahbScDTE4ej61CoVFbV/o7GYmACdc84wzZs3SiNGRDjoswIA9AQhDIB9EMIAdMHmzZt16aWXWtsJCQn68ssvZTKZjrnve++9p3vuucfaPvHEE7V48eJeqbOzCGEAAADoG8xmi8rKagyBDSUl1fL29tDgwcFKSAiSu7ubo8tEL+FNagAAAKDvYH4OAP1Hfb1ZO3fma82ahlCG9euzWi0kbcnLy11DhoQYAk+bghciI/069b4vAMB+mJ8DAAAAfQfzcwDov+rqzNZAhrAwHwUH+zi6JABADxHCANiHh6MLAPqTb775xtCeNm1apxfiTJs2zdDesGGDKioq5OfHLzoAAABX5+ZmUlCQt4KCuKMeAAAAAAAA0Bnu7m5KSYlSSkqUbrnlBNXVmbV9e57WrMnQnj0FqqioVXS0vzVkISkpVHFxgYSdAgAAAAAAAABcioeHm8LCfBUW5uvoUgAAAPoVQhiALvjpp58M7QkTJnR636ioKMXFxSkrK0uSVFtbq7S0NI0dO9amNQIAAAAAAAAAAACAq/HwcNOECTGaMCHG0aUAAAAAAAAAAAAAAIB+jls8AF2Qnp5uaCclJXVp/+Tk5A7HAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4DiEMQCdVVVUpOzvb0BcT07W7qERHRxva+/bt63FdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADbIIQB6KTCwkJZLBZr29PTU+Hh4V0aIyoqytA+cuSITWoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPSch6MLAPqLiooKQ9vHx0cmk6lLY/j5+XU4pr15eLg79PgAAAAAmJcDAAAAfQnzcwAAAKDvYH4OAAAA9B3MzwEAAIC+g/k5YB9uji4A6C/Ky8sNbW9v7y6P0XIfR4cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACOIoQB6KSamhpD29PTs8tjeHl5GdpVVVU9qgkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYDuEMACd1DJAoba2tstjtAxy8Pb27lFNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADb8XB0AUB/4e/vb2hXV1d3eYyW+/j5+fWopp6qq6uXJNXU1Du0DgAAAABHMT8HAAAA+g7m5wAAAEDfwfwcAAAA6DuYnwMAAAAAnJ2bowsA+ouWgQlVVVWyWCxdGqOioqLDMQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjkMIA9BJoaGhMplM1nZtba2OHDnSpTHy8vIM7fDwcJvUBgAAAAAAAAAAAAAAAAAAAAAAAAAAAADoOUIYgE7y8fFRbGysoS87O7tLY+Tk5BjaiYmJPa4LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAbhDAAXTBkyBBDe+/evV3av+X2hDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQN9BCAPQBSNGjDC0t2zZ0ul9Dx06pKysLGvb09NTSUlJNqsNAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAzhDAAXTBz5kxDe926dbJYLJ3ad+3atYb25MmT5e/vb6vSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9RAgD0AUTJkxQaGiotZ2RkaENGzZ0at933nnH0J49e7ZNawMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9AwhDEAXuLm56dxzzzX0vfDCC7JYLB3u9/3332vz5s3Wtr+/v0477bReqREAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0D2EMABddP3118vPz8/a3rhxo1555ZV2t8/Ly9O9995r6LviiisUFhbWazUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAALqOEAagi8LCwnTTTTcZ+p555hk99NBDysvLs/aZzWatWrVK8+bNU1ZWlrV/wIABuuaaa+xWLwAAAAAAAAAAAAAAAAAAAAAAAAAAAACgc0wWi8Xi6CKA/sZsNmvBggX6+uuvDf3u7u6KjY1VYGCgMjMzVVJSYnjdx8dHS5Ys0fHHH2/PcttVXFwhSaqpqXdwJQAAAIDr8vJyN7SZnwMAAACOw/wcAAAA6DuYnwMAAAB9B/NzAAAAoO9omp8HB/s5uBLAubk5ugCgP3Jzc9Nzzz2nM844w9BfX1+vjIwM7dq1q1UAQ0hIiP75z3/2mQAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIARIQxAN3l7e+vZZ5/VokWLNGLEiHa38/Pz0yWXXKL//ve/mjx5sh0rBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0hclisVgcXQTgDA4cOKBt27YpLy9PtbW1CgoKUlJSkiZMmCBvb29Hl9em4uIKSVJNTb2DKwEAAABcl5eXu6HN/BwAAABwHObnAAAAQN/B/BwAAADoO5ifAwAAAH1H0/w8ONjPwZUAzs3D0QUAzmLQoEEaNGiQo8sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHSTm6MLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6AsIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgSTJZLBaLo4sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwNDdHFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAXEMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCKEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCKEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCKEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASJI8HF0AAPs7ePCgtm/frtzcXNXW1iooKEiJiYmaMGGCvL29HV0eAAAA4NQsFosyMzO1Z88e5ebmqrS0VF5eXgoKCtLgwYM1ZswY5uUAAAAAAAAAADRKT0/X7t27lZeXp8rKSvn4+Cg8PFxDhgzR8OHD5eXl5egSAQAAAKdWU1OjXbt2ae/evSopKVFVVZUCAgIUHh6ukSNHatCgQTKZTI4uEwAAAEAbqqur9eOPPyo9PV0lJSXy9PRUdHS0UlJSlJCQ4OjygD6NEAbAhaxatUovvviiUlNT23zdz89P5513nm655RaFhYXZuToAAADAeRUXF2vVqlX67rvvtH79ehUWFra7raenp2bMmKErr7xSkyZNsmOVAAAAAJr7v//7P33yySeGvri4OH311VcOqggAAABwHWVlZfrXv/6lt99+W5mZme1u5+npqbFjx+rUU0/VlVdeaccKAQAAAOe3c+dOLVu2TJ9//rlqamra3S4qKkoXXHCBrrjiCoWEhNivQAAAAKAfysvL0/bt27Vt2zZt375dO3fuVHl5ufV1W61NKSgo0N///ne99957qqioaHObUaNGacGCBZo7d26Pjwc4I5PFYrE4uggAvaumpkYLFy7URx991Kntw8LCtGjRIk2cOLGXKwMAAACc38MPP6y3335btbW1Xd73nHPO0f3336+AgIBeqAwAAABAe7766ivdfPPNrfoJYQAAAAB639dff6377rtPhw8f7vQ+ERERWrt2bS9WBQAAALgOs9msZ599VosXL5bZbO70fhEREXryySd18skn92J1AAAAQP/zww8/aOnSpdq2bZsOHTrU4ba2WJuyYcMG3XHHHR3eOLC5c845R48++qi8vLx6dFzA2bg5ugAAvctsNuvOO+9sFcDg7u6u+Ph4jRgxQoGBgYbXCgoKdP3112vLli32LBUAAABwStu2bWszgMHd3V3R0dEaNWqUhg0b1mpeLknvv/++rr76akO6KQAAAIDeVVpaqoceesjRZQAAAAAuadmyZbr55ptbBTB4e3srISFBY8eO1dChQxUaGuqgCgEAAADn98ADD+iVV15pFcDg6+uroUOHauzYsRo4cKBMJpPh9cOHD2vBggX65ptv7FkuAAAA0Oft2LFDX3755TEDGGxh8+bNuuGGG1oFMAQFBWnkyJGKi4uTu7u74bX3339fd911lywWS6/XB/QnHo4uAEDvevXVV7V69WpD37x587RgwQJFRUVJaghqWL16tZ544gllZ2dLkiorK3XnnXfq448/bvNiMAAAAABdFxQUpDPPPFMzZ87U8ccfr4CAAOtr9fX12rx5sxYtWqTNmzdb+7dv364//vGPWrRokSNKBgAAAFzOU089pby8PEmSn5+fKioqHFwRAAAA4BrefvttPfnkk4a+k08+WZdffrmmTJnS6g5ceXl5Wr9+vVavXq3t27fbs1QAAADAaX322Wd6++23DX3Jycn6/e9/r+nTp8vD4+glKAUFBXr99df10ksvWW9QUltbq3vuuUefffaZgoOD7Vo7AAAA0B/Zcm1KcXGxfvvb36qqqsraFxcXp4ULF2rOnDnWILXc3Fy9+OKLevPNN63bffHFF1q2bJmuvvpqm9QCOAOThWgSwGkVFhZqzpw5hrvm3nXXXbrhhhva3D4vL0/z589XVlaWte+WW27R7bff3uu1AgAAAM7qvPPOU1FRkW6++WadddZZ8vHx6XD7+vp6Pfzww4aTWpL02muvacqUKb1ZKgAAAODyNmzYoCuvvFIWi0Vubm6666679PTTT1tfj4uL01dffeXACgEAAADndODAAZ111lmqrq6WJHl6eupPf/qTzjzzzE7tX1xczAVeAAAAgA2cddZZ2rNnj7U9evRorVixQn5+fu3u8/333+u6665TXV2dte///u//dOONN/ZqrQAAAEB/sWzZMj355JPy9/fXqFGjNGbMGI0dO1ZjxoxRZmamrrjiCuu2PVmb8uyzz+rll1+2tuPj4/X6669bb+bd0ksvvaS//vWv1nZgYKBWr17N+XagkZujCwDQe1599VVDAMPEiRN1/fXXt7t9VFSUHn/8cUPfsmXLVFhY2Gs1AgAAAM7u9ttv12effaYLL7zwmAEMkuTu7q4HH3xQo0ePNvS3vMsAAAAAANuqqqrSfffdp6b88ssuu0xjxoxxcFUAAACAa7j//vutAQyS9PTTT3c6gEESC0IBAAAAG8jIyDAEMEjSgw8+2GEAgyRNnTpV559/vqHv66+/tnl9AAAAQH81e/ZsffLJJ9q8ebNWrFih3//+9/r1r3+tuLg4mx2joKBAK1asMPQ99thj7QYwSNKNN96oiRMnWtulpaVasmSJzWoC+jtCGAAnZTab9Z///MfQd+utt8pkMnW439SpU3XCCSdY2+Xl5fr00097pUYAAADAFcycOVNeXl5d2sfd3V3XXXedoW/NmjW2LAsAAABAC88995wOHjwoSYqNjdWdd97p2IIAAAAAF7Fq1Spt2LDB2v71r3+t0047zYEVAQAAAK4pPT3d0I6OjtbYsWM7te+pp55qaB84cMBmdQEAAAD93cCBA5WcnCw3t967pPuTTz5RRUWFtT1x4kRNnTq1w31MJpNuueUWQ9+7775rvYEJ4OoIYQCc1I8//qiCggJrOyEhQZMnT+7UvhdccIGhvXr1apvWBgAAAODYmoejSVJRUZEqKysdVA0AAADg3LZv367XXnvN2n7ggQfk7+/vwIoAAAAA1/HWW28Z2rfeequDKgEAAABcW3FxsaEdExPT6X1bbltaWmqTmgAAAAB0TstrQFteI9qeKVOmKD4+3trOz8/X1q1bbVka0G8RwgA4qW+++cbQnjZtmkwmU6f2nTZtmqG9YcMGQwoSAAAAgN4XHBzcqo83qAEAAADbq62t1b333qv6+npJDXfdnTVrloOrAgAAAFxDXl6e1qxZY22PGDFCxx13nAMrAgAAAFxXYGCgoV1VVdXpfaurqw3tkJAQW5QEAAAAoBPKy8u1efNmQ9/06dM7ta/JZGp1Pen//vc/W5UG9GuEMABO6qeffjK0J0yY0Ol9o6KiFBcXZ23X1tYqLS3NZrUBAAAAOLa8vLxWfbxBDQAAANjeyy+/rD179kiSgoKCdN999zm4IgAAAMB1fPvtt9ZANEmaPHmyA6sBAAAAXNuIESMM7b1793b6Rn7bt283tMeOHWuzugAAAAB0LC0tTbW1tdZ2fHy8IiMjO71/y2tPW16bCrgqQhgAJ5Wenm5oJyUldWn/5OTkDscDAAAA0LtappHGxcXJy8vLQdUAAAAAziktLU0vvfSStX333Xd36U1oAAAAAD2zY8cOQ3v48OHW57t27dJjjz2m3/zmN5o4caJSUlI0e/ZsXX311Vq8eHGbYcYAAAAAui86Olrjx4+3tmtqarRixYpj7ldTU6PXXnvN0HfBBRfYvD4AAAAAbdu7d6+h3fLa0GNpee1py/EAV0UIA+CEqqqqlJ2dbeiLiYnp0hjR0dGG9r59+3pcFwAAAIDOe/fddw3tk08+2UGVAAAAAM7JbDbr3nvvtd4J4IQTTtBFF13k4KoAAAAA17Jz505DOyEhQeXl5Vq4cKHOPfdcrVixQj///LNKSkpUVVWlrKwsrVu3Tk899ZROOeUUPfvss4a7ewEAAADombvvvltubkcvM1m0aJHee++9drcvKSnR7bffbrhIa9asWZo9e3av1gkAAADgqJbXfra8NvRYWl57mp2drerq6h7XBfR3Ho4uAIDtFRYWymKxWNuenp4KDw/v0hhRUVGG9pEjR2xSGwAAAIBj++abb7Rp0yZD33nnneegagAAAADntHz5cm3dulVSw3n0Rx55RCaTybFFAQAAAC7mwIEDhrbJZNJll12mXbt2HXPfqqoqvfzyy9qxY4eef/55BQQE9FaZAAAAgMs44YQTdP/99+uRRx6RxWJRXV2d7rnnHv373//WKaecoiFDhsjb21uFhYXavn27Pv74YxUVFVn3nz59up599lnHfQIAAACAC2p57WdXQxgiIiLk4eGhuro6SQ03NikqKmp1jSngaghhAJxQRUWFoe3j49PlhaN+fn4djgkAAACgdxQVFemBBx4w9M2dO1djx451UEUAAACA88nIyNBzzz1nbd94441KSkpyYEUAAACA6zGbzSovLzf0Pf7449YABpPJpJkzZ2rGjBmKjo5WZWWldu3apQ8++ECHDh2y7rNu3Tr98Y9/1PPPP2/X+gEAAABndckll2jIkCF6/PHH9csvv0iSduzYoR07drS7T0JCgq677jpddNFFcnNzs1epAAAAANT62k9fX98u7W8ymeTt7W0NYZDU6vw94Ir46xZwQi1/wXl7e3d5jJb7EMIAAAAA9D6z2azf/e53ys3NtfYFBgbqvvvuc2BVAAAAgPN54IEHrOe9ExMTdeONNzq4IgAAAMD1lJaWymKxGPpSU1MlSSEhIfrXv/6ll156SfPnz9esWbN0+umn6+6779Znn32mM88807DfF198offff99epQMAAABOb+rUqXrnnXd0zTXXyN3dvcNtY2Njdc011+jMM88kgAEAAABwgJbXfnbnelIfH58OxwRcEX/hAk6opqbG0Pb09OzyGF5eXoZ2VVVVj2oCAAAAcGxPPfWUvv32W0PfI488opiYGAdVBAAAADift99+W+vWrZPUkOT/6KOPtjonDgAAAKD3tbeA093dXf/85z91wgkntPm6v7+/nn76aZ144omG/pdeeqlVqAMAAACA7lm5cqXmzp2rJUuWqL6+vsNts7Oz9fDDD2vOnDl655137FQhAAAAgCbV1dWGNteTArbh4egCANhey194tbW1XR6jZZBDd9KPAAAAAHTe8uXLtXTpUkPfddddp9NPP91BFQEAAADO59ChQ3rqqaes7QsvvLDdC7sAAAAA9K721qJccMEFSklJ6XBfNzc3PfTQQzrllFNkNpslSfv27dPGjRs1efJkm9cKAAAAuIra2lrddddd+vzzz619ISEhuvTSSzVz5kwNHjxYvr6+Kiws1M6dO/Wf//xHq1atksViUVFRke69917t3btXf/jDHxz4WQAAAACupeX5dq4nBWzDzdEFALA9f39/Q7tlklFntNzHz8+vRzUBAAAAaN9HH32kJ554wtB33nnn6e6773ZQRQAAAIBzeuSRR1RSUiJJioyM1O9+9zsHVwQAAAC4rvbWolx00UWd2j8hIUHTpk0z9G3atKnHdQEAAACu7KGHHjIEMIwdO1Yff/yxbr/9do0dO1ZBQUHy9PTUgAEDNHv2bP3973/XCy+8YLhAa8mSJXr33XcdUT4AAADgklqeb+/O9aRVVVUdjgm4IkIYACfU8hdcVVWVLBZLl8aoqKjocEwAAAAAtvH111/rnnvuMczZTznlFD322GMymUwOrAwAAABwLp9++qm+/PJLa3vhwoUKCgpyYEUAAACAa/Px8ZG7u7uhz9/fXyNHjuz0GBMnTjS0d+7caZPaAAAAAFe0YcMGvfPOO9Z2eHi4Xn75ZUVGRna435w5c/TAAw8Y+p566qlWF3EBAAAA6B0tr/2srKzs0v4Wi6VVcEPLG4UDrogQBsAJhYaGGi7Wqq2t1ZEjR7o0Rl5enqEdHh5uk9oAAAAAHLV+/Xrdcccdqqurs/ZNnz5dzzzzTKuFpwAAAAB65umnn7Y+nzlzpk4//XQHVgMAAABAksLCwgztQYMGyc2t80vahgwZYmh3dX0MAAAAgKNWrFhhaF955ZWt5uztOe+88zR48GBru6ioSF988YUtywMAAADQjpbXfubm5nZp/8OHDxvWs7u5uSk0NNQmtQH9mYejCwBgez4+PoqNjVVWVpa1Lzs7WxEREZ0eIycnx9BOTEy0WX0AAAAApG3btunmm282pIaOHz9ef//73+Xl5eXAygAAAADnVFJSYn3+v//9T8OGDevyGFlZWa32e//99zVixIge1wcAAAC4oqSkJOXn51vbAQEBXdq/5fbN5/0AAAAAOs9isWj9+vWGvlmzZnV6fzc3N82cOVPLli2z9m3evFm/+c1vbFUiAAAAgHa0DCxueW3osbTcPjY2Vt7e3j2uC+jvOh8bDqBfafmLc+/evV3av+X2hDAAAAAAtrN7925df/31qqiosPaNHDlSr7zyivz8/BxYGQAAAAAAAAAA9pOcnGxo19TUdGn/5kHHUsONSwAAAAB0XXFxsUpLSw198fHxXRqj5fZ5eXk9rgsAAADAsbW89jMtLa1L+3MtKdA2QhgAJ9Xyrltbtmzp9L6HDh1SVlaWte3p6amkpCSb1QYAAAC4svT0dF1zzTUqLi629iUlJWnx4sUKDAx0YGUAAAAAAAAAANjXyJEjDe3Dhw93af8jR44Y2iEhIT0tCQAAAHBJbQWieXh4dGmMltvX19f3qCYAAAAAnZOcnCxPT09rOysrS4cOHer0/j/++KOh3fLaVMBVde2vYgD9xsyZM/XKK69Y2+vWrZPFYpHJZDrmvmvXrjW0J0+eLH9/f5vXCAAAALiarKwsXX311YZFofHx8Vq6dKnCwsIcWBkAAADg/F588UXV1dV1aZ/du3frz3/+s7UdERGhp59+2rDNwIEDbVIfAAAA4IpmzpwpNzc3mc1mSVJmZqaKioo6HaaQmppqaA8ZMsTWJQIAAAAuoa05eF5enhISEjo9Rl5enqHNWhgAAADAPgICAnTCCSfo+++/t/atW7dO55xzzjH3tVgsWrdunaFv1qxZti4R6JcIYQCc1IQJExQaGqrCwkJJUkZGhjZs2KApU6Ycc9933nnH0J49e3av1AgAAAC4kkOHDumqq65Sbm6utS8qKkrLli1TVFSUAysDAAAAXMOkSZO6vI+7u7uh7e3trWnTptmqJAAAAMDlhYeHa8KECdq8ebO178svv9SFF154zH3r6uq0atUqQ1935v0AAAAAJC8vL0VGRio/P9/at379+i6FMKxfv97QJsQYAAAAsJ/Zs2cbQhjeeeedToUwrF+/XpmZmdZ2RESEUlJSeqNEoN9xc3QBAHqHm5ubzj33XEPfCy+8IIvF0uF+33//veGNbX9/f5122mm9UiMAAADgKoqKinTNNdfo4MGD1r6wsDAtXbq0S29WAwAAAAAAAADgbC6++GJD+9VXX1VNTc0x93vrrbcMF4gFBATopJNOsnl9AAAAgKuYOnWqob18+XLV1dV1at+NGzdqy5Ythr7O3DwQAAAAgG2cccYZ8vPzs7Y3bdpkCGVoi8Vi0QsvvGDoO++88+TmxqXngEQIA+DUrr/+esMvzo0bN+qVV15pd/u8vDzde++9hr4rrrhCYWFhvVYjAAAA4OzKysp03XXX6ZdffrH2BQUFacmSJUpKSnJgZQAAAAAAAAAAON6ZZ56poUOHWtv79+/XAw88ILPZ3O4+27Zt09NPP23ou+SSSxQYGNhrdQIAAADO7je/+Y2hvWfPHj388MMdzs0l6cCBA7rrrrsMfYMHD9b48eNtXiMAAACAtoWHh+vSSy819N13333Ky8trd5+XX35ZmzZtsrYDAwN17bXX9lqNQH/j4egCAPSesLAw3XTTTXr22Wetfc8884yys7N18803KyoqSpJkNpv11Vdf6fHHH1d2drZ12wEDBuiaa66xe90AAACAM7n55pu1Y8cOQ99VV12lwsJCrVu3rktjjRo1SsHBwbYsDwAAAAAAAAAAh3Jzc9PChQt19dVXy2KxSJLee+895eXl6a677tLo0aOt25aWluqdd97RokWLVFFRYe0fPHiwbrzxRrvXDgAAADiTk046SZMnT9aGDRusfW+99Zb27t2r2267TRMnTpSHx9FLUAoLC/Xee+/pxRdfVGlpqWGs3/72t3J3d7db7QAAAEBf98MPP6i6urpV/+7duw3t6urqdteYDxgwQMnJye0e47rrrtP777+v/Px8SVJmZqbmz5+ve++9V7Nnz5bJZJIk5ebm6sUXX9Sbb75p2P+mm25SSEhIVz4twKmZLE3vXAFwSmazWQsWLNDXX39t6Hd3d1dsbKwCAwOVmZmpkpISw+s+Pj5asmSJjj/+eHuWCwAAADidYcOG2Wys5cuXa/LkyTYbDwAAAEDHNmzYoCuuuMLajouL01dffeXAigAAAADn9c9//lPPPPNMq/7IyEhFRUWpsrJSBw8eVG1treH1kJAQLV++3Kbn4wEAAABXlZ+fr3nz5ikzM7PVa35+foqPj5ePj4+KioqUkZGhti5Hueaaa/SHP/zBHuUCAAAA/cbs2bOVlZXVozHOPfdc/elPf+pwm02bNunaa69tFfgQFBSk+Ph4lZSUKCcnR/X19YbX58yZoxdeeMEa1ABAcnN0AQB6l5ubm5577jmdccYZhv76+nplZGRo165drQIYQkJC9M9//pMABgAAAAAAAAAAAAAAANjFDTfcoPvuu0+enp6G/vz8fO3cuVN79+5tFcAwZMgQvfnmmwQwAAAAADYSGRmpf/3rX5o0aVKr1yoqKrRnzx5t375dBw8ebBXA4Onpqbvuuku///3v7VUuAAAAgBYmTpyol19+WSEhIYb+kpIS7dq1S5mZma0CGM4880z97W9/I4ABaIEQBsAFeHt769lnn9WiRYs0YsSIdrfz8/PTJZdcov/+97/cXRcAAAAAAAAAAAAAAAB2dfnll+uDDz7Q6aef3iqMobn4+Hjde++9+vDDDzV48GD7FQgAAAC4gJiYGL322mv629/+pkmTJsnNrePLTgIDAzV//nx9+OGHuuGGG7hwCwAAAHCwqVOn6pNPPtH8+fPl6+vb7nYjR47U888/r2eeeUZeXl52rBDoH0yWlvGDAJzegQMHtG3bNuXl5am2tlZBQUFKSkrShAkT5O3t7ejyAAAAAAAAAAAAAAAA4OLKysr0448/6sCBAyotLZWfn58iIiI0cuRIJSYmOro8AAAAwGWUlZVp586dysjIUGlpqaqrqxUQEKCQkBANGzZMycnJxwxqAAAAAOAYVVVV2rJli/bu3auSkhJ5enoqKipKKSkpGjRokKPLA/o0QhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkETcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCKEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCKEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAkQhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEcIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgiRAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCKEAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBIhDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIIYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBECAMAAAAAAAAAAAAAAAB6wV133aVhw4ZZH998842jS+rT/v3vfxu+Xn/9618dXRIAAAAAAAAAAAAAuCRCGAAAAAAAAAAAAAAAAGBTGzdu1Mcff2xtT506VTNmzHBgRX3fRRddpEGDBlnbS5Ys0cGDBx1YEQAAAAAAAAAAAAC4JpPFYrE4uggAAAAAAAAAAAAAgP1lZmZqzpw5Nh1z+PDh+uCDD2w6JoD+pa6uTuecc45++eUXSZLJZNK7776rUaNGHXPfe+65R++9956hb/ny5Zo8eXKP67r88su1ceNGQ9/q1asVHx/f47Ft5b///a9++9vfWtuzZs3SSy+95MCKAAAAAAAAAAAAAMD1uDm6AAAAAAAAAAAAAAAAADiPd9991xrAIDUECXQmgAHSaaedpqSkJGv766+/bhUcAQAAAAAAAAAAAADoXYQwAAAAAAAAAAAAAAAAwCaqq6v14osvGvpuuukmB1XT/5hMJl1//fWGvmeffdZB1QAAAAAAAAAAAACAa/JwdAEAAAAAAAAAAAAAgL7Dz89PAwcO7Pb+Q4YMsWE1APqblStXKjc319qePHmyUlJSHFhR/3PmmWfqb3/7m/XruGXLFn3zzTeaMWOGgysDAAAAAAAAAAAAANdACAMAAAAAAAAAAAAAwGr06NFasWKFo8sA0A/V1tZq6dKlhr5LLrnEQdX0X56enrrwwgv1/PPPW/teeeUVQhgAAAAAAAAAAAAAwE7cHF0AAAAAAAAAAAAAAAAA+r9PP/1Uubm51nZERITmzJnjwIr6r/PPP1/u7u7W9qZNm7Rz504HVgQAAAAAAAAAAAAAroMQBgAAAAAAAAAAAAAAAPTYa6+9ZmifffbZ8vT0dFA1/VtMTIymTZtm6Fu+fLmDqgEAAAAAAAAAAAAA10IIAwAAAAAAAAAAAAAAAHpkz5492rlzp6Hv17/+tYOqcQ4tv35ffPGFysrKHFQNAAAAAAAAAAAAALgOD0cXAAAAAAAAAAAAAABATU2Ndu7cqX379qmwsFA1NTXy9/fXuHHjlJKS0ulx0tPTtW/fPhUUFKiwsFBeXl4KDQ1VTEyMUlJS5O3tbfPa8/LytGPHDh06dEjFxcXy9fVVfHy8xowZo6ioKJsfry/Kzs7Wzz//rIKCAhUUFMjd3V2hoaEaMGCAxo0bJ39//16vYf/+/UpNTVVeXp5qamoUEhKiAQMG6Pjjj1dwcHCvHLPp+zY3N1dFRUUqKSmRl5eXAgIClJCQoOTkZEVGRvbKsfua9957z9COi4vT2LFjHVSNc5g7d64efPBB1dXVSZIqKyv1+eef6/zzz3dwZQAAAAAAAAAAAADg3AhhAAAAAAAAAAAAAAD0mv/85z/64x//aOhbvXq14uPjJUm//PKLXn31VX3xxReqqKhotf+55557zBCGffv2admyZfruu++UlZXV7nbe3t6aOHGirr76ap144ond+GyMvvzySy1btkw//PCDLBZLq9dNJpPGjRun66+/XnPmzLH2z54921Dnueeeqz/96U8dHuuee+4xXOQeFxenr776qss1b9iwQVdccYWhb/ny5Zo8eXKXx8rLy9OyZcv0v//9T+np6e1u5+npqZSUFF166aU67bTTZDKZunScYcOGGdq33nqrbrvtNkmS2WzWe++9p2XLlmnPnj1t7u/u7q5Jkybpzjvv1Lhx47p07LbU19fro48+0kcffaQffvhBlZWVHW4/ZMgQnXTSSTr33HM1cuTIVq///ve/1wcffGBtm0wmffnll0pISOh2jT/99JPOOeccQ9+VV16phQsXdnvMY/n0008N7RkzZvTaseylrf8vttD8Z2BHQkJCNH78eG3atMna9/HHHxPCAAAAAAAAAAAAAAC9zM3RBQAAAAAAAAAAAAAAXNOLL76oc845R++//36bAQzHUlhYqHvvvVdnnHGG3njjjQ4DGCSpurpaa9as0bXXXqvLL79cubm53aq7oKBACxYs0K233qrNmze3GcAgSRaLRVu2bNGCBQt0xx13HPNi/f6iqqpKf/7zn/WrX/1KS5Ys6TCAQZJqa2u1efNm/fa3v9XZZ5/dblhCV+Xl5emSSy7RwoULOxyzvr5e33//vS6++GL99a9/7dExP//8c5122mn6wx/+oDVr1nTq33Tfvn1avny5zj33XC1durTV65deeqmhbbFY9Oabb/aozpUrV7bqmzdvXo/G7Mju3buVk5Nj6Js0aVKvHc+VtAxI2bRpk8rLyx1UDQAAAAAAAAAAAAC4BkIYAAAAAAAAAAAAAAB29/DDD+u5555TXV1dt/bft2+fLr74Yr3zzjuqr6/v8v4bN27UBRdcoO3bt3dpv8LCQl111VVavXp1l/b77LPPdP3116umpqZL+/U1+fn5uvzyy7VkyRJVV1d3ef+ff/5Z8+bN0zfffNOjOjIyMnThhRdqy5YtXdrvpZde6lYQg9ls1p///GfdfvvtOnDgQJf3b1JWVtaqLyUlRaNHjzb0vfvuu93+XikrK9NHH31k6JsyZYoSExO7NV5nfPvtt636CGGwjZYhDLW1tfr+++8dVA0AAAAAAAAAAAAAuAYPRxcAAAAAAAAAAAAAAHAtb7/9tl5//XVr28/PT9OnT9eECRMUHh4ui8Wi3NxcbdiwQW5ure8tkJaWpksuuUTFxcWtXhs7dqwmTJigIUOGKCgoSLW1tcrPz9eWLVv07bffGi5sz8/P1w033KD33ntPMTExx6y7trZW1157rX7++edWr0VFRemUU05RUlKSgoODdeTIEe3atUurV6+21rlp0yb9+c9/7tTXqC86fPiwLr74YmVlZbV6bejQoZo4caKSk5MVFBQkSTpy5Ii2bt2qb775RuXl5dZty8vLddttt+mNN97QyJEju1xHeXm5rrvuOuXl5UmSTCaTxo8fr2nTpikmJkZ+fn4qLCzUjz/+qC+//LJVWMQrr7yi2bNnKyUlpdPH/N3vfqePP/64zdeGDh2qadOmaeDAgQoNDVVtba2Ki4uVlpamnTt3ateuXbJYLB2Of9lll+mee+6xtgsKCvT555/rrLPO6nSNTT744ANVVFQY+ubPn9/lcbpi06ZNhnZsbKzCw8N79Zj24Ofnp+HDh3d7f4vF0ubPi64YPXq0TCaT4Xto48aNmjt3bo/GBQAAAAAAAAAAAAC0jxAGAAAAAAAAAAAAAIBdvfLKK9bn8+bN05133qnQ0NBW2910002tLqCvqKjQHXfc0SqAYdasWfrd736npKSkdo+bn5+vp556Sh9++KG1r7CwULfffrvefPPNNgMfmnvppZeUmppq6PPy8tJtt92ma6+9Vu7u7q32qaio0F//+lctX75ckvTvf/9bnp6eHR6nLzKbzbrrrrtaBTCMHz9ef/zjH9sNNLjyyitVUlKiF198UcuWLbNeSF5dXa3bbrtNH3zwgQICArpUy+uvv279vkhJSdGDDz6oUaNGtdru0ksvVWZmpm6//XbDv1t9fb0WLVqkxYsXd+p4ixcvbjOAYdKkSfrd736nsWPHdrh/Xl6ePv30U/3rX/9qd5szzjhDf/7zn1VYWGjte+ONN7oVwvDGG28Y2pGRkb1+wf6OHTsM7WHDhvXq8exlzJgx+uCDD7q9/5NPPtkqhCEhIaHNn3ft8fPz08CBA3XgwAFrX8uvNwAAAAAAAAAAAADAtjpeQQIAAAAAAAAAAAAAgI3V19dLku655x49/PDDHV6Q7O3tbWg/9dRTSktLM/TdfffdeumllzoMYJAaLkZ/+umndeuttxr6t2/frs8++6zDfQ8ePKiXX37Z0Ofh4aG//vWvuuGGG9oMYJAaLqC+99579cc//lGSZLFYVFNT0+Gx+qLFixdr/fr1hr5LL71UK1eubDeAoUlQUJDuuecePf7444b+zMxMrVy5ssu1NAUwzJo1SytWrGgzgKFJfHy8lixZooiICEP/unXrlJ2dfcxj7dmzR88880yr/iuvvFKvvfbaMQMYJCkqKkpXXXWVPv/8c11wwQVtbuPl5aULL7zQ0Ld582b98ssvxxy/5T579uwx9F144YXy8Oi9e3RkZWUZwiMk6bjjjuu14/UXixcv1rJlywx9YWFhWrx4sfz9/bs01tChQw3tn376yfpzFAAAAAAAAAAAAABge733LjsAAAAAAAAAAAAAoN/ZuXOnzj777G7t+9hjj2nMmDGd2vbUU0/V1Vdf3aXx8/Ly9M477xj6LrnkEl1//fVdGue2227Tli1btHbtWmvfK6+8otNPP73dfV5//XXV1tYa+m644QbNnTu3U8e86qqrtGPHDn388cddqrUvqKys1OLFiw19M2fO1AMPPNClcc4//3xt2bJFb7/9trXvtdde05VXXikvL68ujRUXF6enn366VUhHW0JCQnTLLbfo4YcftvaZzWatXbu2VfBBSy+//HKri93PPPNMLVy4sEv1SpK7u7tiYmLafX3evHlavHix4XgrV67s0te5ZaiFu7u7Lrrooi7X2hX79+9v1RcbG2vTY9x3333y8/Pr8TgHDx60QTXH9uGHH+rpp5829Pn5+enll1/WoEGDujxey69nZWWlcnNzFRcX16M6AQAAAAAAAAAAAABtI4QBAAAAAAAAAAAAAGBVUVGh3bt3d3vfznBzc9Pvf//7Lo+/bNkyQxBCQECA7rrrri6PI0kLFiwwhDDs2rVLWVlZbV7UXFNTo/fee8/QN2DAAN14441dOuYf/vAHffHFF6qpqelWzY7y7rvvqrCw0Np2c3PTfffd162xbrnlFr3zzjuyWCySpPz8fG3dulWTJk3q0ji33nqrAgMDO739GWecoccee8wQcJCamtphCENmZqY+/fRTQ19YWJghzMGW4uLiNHPmTK1evdra98EHH+juu+/uVABBQUGBPv/8c0PfjBkzOgx+sIWsrKxWfVFRUTY9hr3CE2xh3bp1WrhwofV7XJI8PDz03HPPaezYsd0aMzo6ulVfez+vAAAAAAAAAAAAAAA95+boAgAAAAAAAAAAAAAArmXKlCmKj4/v8n4tLzA/7bTTFBAQ0K0aJkyYoKCgIEPfxo0b29x227ZtKioqMvT95je/kY+PT5eOOWDAAM2aNatL+/QFLb/uU6ZMUUJCQrfGiomJ0dChQw197X3d2+Pn56czzzyzS/sEBwdr0KBBhr59+/Z1uM8333xjCG2QpHnz5nX7e64zLrvsMkO7rKxMH3/8caf2fffddw0hJZI0f/58m9XWntzc3FZ9ERERvX7cvig1NVW33nprq3+Hxx57TCeffHK3x42MjGzVl5OT0+3xAAAAAAAAAAAAAAAdI4QBAAAAAAAAAAAAAGBXkydP7vI+WVlZysrKMvRNmDCh2zW4ubkpNjbW0Ldr1642t926dWurvlNOOaVbx+3ufo5SU1Ojbdu2Gfp68nWX1CqAo72ve3tSUlLk5eXV5eMOHDjQ0C4tLe1w+w0bNrTqO/vss7t83K6YNm2aEhMTDX0rV6485n4Wi0VvvvmmoS8hIUEnnXSSTetrS1lZWas+Pz+/Xj9uX5ORkaEbbrhB5eXlhv7/+7//07nnntujsX19fVv1tTwOAAAAAAAAAAAAAMB2PBxdAAAAAAAAAAAAAACg75g0aZJWrFjRq8cYOXJkl/f58ccfW/X94x//0GuvvdbtOg4ePGhoFxYWtrldamqqoe3h4aHhw4d365ijRo3q1n6OsnPnTlVXVxv63n33Xa1atarbY+bk5Bja7X3d2zNo0KBuHTcgIMDQbis8oLmW4RthYWEaPHhwt47dFZdeeqkeffRRa3vXrl3atm2bUlJS2t3nu+++U0ZGhqHv4osvlslk6rU6m1RVVbXq8/b2tukxli9f3q3wlpYuv/xybdy40QYVGRUUFOjaa6/V4cOHDf2XXXaZbrzxxh6P39bXs7KyssfjAgAAAAAAAAAAAADaRggDAAAAAAAAAAAAAMCuwsPDu7xPbm5uq76WIQo9VVRU1Gb/kSNHDO2YmJhuX2Q+ePBgubu7q76+vlv721tbX/ecnJxWQQo90d7XvT0hISHdOo6np6ehXVdX1+H2BQUFhvbQoUO7ddyuOuecc/Tss8+qvLzc2rdy5coOQxhWrlxpaHt5een888/vtRqba+t72d3d3S7H7gsqKip0ww036MCBA4b+U089Vffee69NjuHh0Xp5T3/5GQIAAAAAAAAAAAAA/ZGbowsAAAAAAAAAAAAAALiWgICALu/T1Qv1u6O6urrN/tLSUkM7MDCw28cwmUzy9/fv9v725sive3vauiDd1srKylRbW2voCw4O7vXjSg3/P84++2xD36effqri4uI2t8/NzdU333xj6Dv11FMVFhbWazU25+Pj06qvq/+m/VVdXZ1uv/127dixw9A/adIk/eUvf5Gbm22W5VRVVbXqa+vrDgAAAAAAAAAAAACwDUIYAAAAAAAAAAAAAAB25e7u3uV9SkpKeqGSzikvLze0fX19ezReT/e3J0d+3R2p5b+5JPn5+dnt+JdddpmhXVVVpffee6/Nbd98803V19cb+ubPn99rtbXU1vezq4Qw3Hffffruu+8MfUOHDtULL7wgLy8vmx2nrRCG/vRzBAAAAAAAAAAAAAD6m96/PQQAAAAAAAAAAAAAAD3k7e3dqu+VV17RySef3OvH9vf3N7QrKyt7NF5P97cnHx+fVn0PPfSQXS/yd4SW/+aSVFFRYbfjJyUlacqUKVq/fr21b+XKlbryyitlMpmsfXV1dXr77bcN+w4dOlTHH3+83WoNDw9v1VdUVGS34zvKX/7yl1bBGDExMXr11VcVFBRk02MVFxe36mvr6w4AAAAAAAAAAAAAsA03RxcAAAAAAAAAAAAAAMCxhIaGtupr68Lk3hAYGGhol5aWdnssi8Wi8vLynpbUbXV1dV3aPiQkpFWfvb7ujhQQECBPT09Dn70/78suu8zQ3r9/vyGUQZJWrVql/Px8Q9+8efN6vbbmYmNjW/Xl5ubatQZ7W7FihV555RVDX3BwsF599VVFRUXZ/HhtfT3b+roDAAAAAAAAAAAAAGyDEAYAAAAAAAAAAAAAQJ8XERHRqi87O9sux255x/mcnBxVV1d3a6z9+/ervr6+y/t5eHgY2rW1td06flFRUZe2d+TX3dFafu579uyx6/Fnz56tmJgYQ9/KlSsN7TfeeMPQ9vPz09lnn93rtTWXkJDQqi8vL8+uNdjTp59+qieeeMLQ5+3trX/84x9KTk7ulWO29fWMj4/vlWMBAAAAAAAAAAAAAAhhAAAAAAAAAAAAAAD0AykpKa36Nm3aZJdjjxo1ytCuq6vT7t27uzVWampqt/YLCAgwtMvKyro1zoED/9/evcd6Xdd/AH8eOEBxBA5gIsHAM1JygegkNohNrhbOahDmwQg2IVDCWP4Brq3aagvsIpUrGVEJqzRvU1IzbqccM2EkcrGAKZhMkXOMg5hH4HDO+f3Rfmd9RZFzgPOFeDz+e7/e78/79eTzPfx3zuv7zxadHzRoUNq1K/zVgrZ678V25ZVXFqwPHDiQPXv2tFn/9u3bp7KysqC2du3aVFdXJ0n27NmTZ599tmD/s5/97HE/K2fagAED0qFDh4JaW76ntrRhw4bMnz8/jY2NzbX27dvnrrvuytVXX33G+r77ffbt27fNP2cAAAAAAACA84khDAAAAAAAAACc9QYOHJiePXsW1DZt2pTa2toz3vvdf4yfJKtXr27VXatWrWrVc126dClY19XV5cCBAy2+p6UDFMrLy48bQrF79+68+OKLLe59rhk2bNhxtccee6xNM3zxi19Mx44dm9fHjh3Lgw8+mCS5//7709TUVHD+pptuatN8SdKpU6dceumlBbVdu3a1eY4zbefOnfnqV7+ao0ePFtS/9a1vZdy4cWesb1NTU3bu3FlQGzx48BnrBwAAAAAAAIAhDAAAAAAAAACcA0pKSjJmzJiC2jvvvJMVK1ac8d5DhgxJeXl5Qe2xxx7LkSNHWnRPTU1NqqqqWpWhoqLiuNrWrVtbdMc///nPPPvssy3uPXbs2ONqS5cubfE955rRo0entLS0oPb73/8+//73v9ssQ48ePTJhwoSC2oMPPpi6uro8+uijBfWrrroqH//4x9ss238bMmRIwfrFF1/MsWPHipLlTHjttdcyc+bMvPXWWwX1OXPmpLKy8oz2fuWVV1JXV1dQe/f7BgAAAAAAAOD0MoQBAAAAAAAAgHPCrFmzjvuj+F/84hfZsmXLGe3bsWPHTJw4saBWXV3d4kEEd955Z44ePdqqDIMGDTqu9oc//KFFd/zwhz9MY2Nji3tPnTo1Xbt2LaitXLkyq1evbvFd55LevXvn+uuvL6gdOHAg3/72t9s0x9SpUwvW+/btyx133JGDBw8W1M/0MIATGTlyZMH6yJEj2bZtW5HSnF4HDx7MjBkzUl1dXVCfPHly5s2bd8b7b9q06bjau983AAAAAAAAAKeXIQwAAAAAAAAAnBP69euXSZMmFdTq6+szZ86cPPfcc626s6GhIU888UQWL158wnNTpkxJhw4dCmpLlixJVVXVSfVZsWJFi4cm/Ld+/frlkksuKag9+eST2bp160k9//Of/zyrVq1qVe8uXbpkxowZBbWmpqbMnz8/a9asadWdSfKXv/ylzQcatNSsWbOO+9wff/zxLFy4ME1NTS26q6GhIfv27WtxhiuuuCKDBw8uqP3pT38qWJeXl2fChAktvvt0GT58+HHvacOGDUVKc/ocPnw4t9xyS3bv3l1QHz16dL7zne+0SYZ3v8ePfvSjufTSS9ukNwAAAAAAAMD5yhAGAAAAAAAAAM4Zd9xxRy677LKC2htvvJFp06blBz/4QWpqak7qnh07dmTx4sUZP358br/99uzYseOE5/v375/Zs2cX1I4dO5avfe1r+eUvf5mGhob3fO6dd97JokWL8r3vfS9JUlJSko4dO55UxnebPHlywbqxsTGzZ8/O3/72t/d9prq6OgsWLMhPfvKTJEmnTp1a1XvmzJkZMWJEQa2uri5z587NN7/5zezdu/ek7nn55ZezZMmSXH/99Zk1a9YJs58NBgwYkAULFhxXv/feezN9+vRs27btA++orq7O8uXL8+lPfzoPPfRQq3JMnTr1hPuTJk1q9Wd7OpSVlWX48OEFtWeeeaZIaU6fBQsWZPPmzQW1K6+8MosXL0779u3PeP+mpqb89a9/LaiNHTv2jPcFAAAAAAAAON+VFjsAAAAAAAAAAJyssrKy3HPPPbnxxhvzxhtvNNfr6+uzbNmyLF++PFdddVWuvvrqXHzxxenWrVvq6+vz1ltvpaamJjt27Mj27dtPeljDf7vllltSVVWVF154obl29OjRfP/738+KFSty7bXXZsCAAenatWtqa2vz97//PWvWrMnBgwebz3/pS19KVVVVXn311Rb3nzJlSn77299m3759zbUDBw7kpptuysiRIzNixIhcfPHFaWhoSE1NTTZt2pRnnnkmhw8fTvKfAQy33357Fi5c2OLepaWl+fGPf5zKysrs3r27ud7U1JQHHnggDz/8cAYNGpShQ4emb9++KS8vT2NjYw4dOpQDBw5k165d2b59e6v+3cX25S9/OVu3bs3KlSsL6hs2bMjkyZMzcODAfOpTn0rfvn3TvXv3HDt2LIcOHcpLL72U7du3Z/v27WlsbDylDNddd10WLVqU2tra4/ZKSkpSWVl5SvefDp/73Ofy9NNPN683bdqUAwcOpEePHkVMdWrea8jGv/71r1N+30uXLk2vXr0+8Nzzzz+f6urqgtrnP//5U+oNAAAAAAAAwAczhAEAAAAAAACAc0rfvn3z0EMPZd68edmyZUvBXn19fTZu3JiNGzee9r4dOnTIsmXLMn369Ozatatg7/XXX8+KFStO+PzQoUOzYMGCVFVVtar/BRdckIULF+YrX/lK6uvrC/bWr1+f9evXv++zpaWlueuuu9KlS5dW9U6Sbt265f7778/8+fPz5z//uWCvoaEhW7ZsOe7z+F9x55135sILL8yvfvWr4/Z27tyZnTt3ntH+HTt2zA033JClS5cetzdixIj079//jPY/GePHj09ZWVnefvvtJP/5mVi7dm1uuOGGIic7vfbu3XvKd7z7/+/7WbVqVcH6Yx/7WAYPHnzK/QEAAAAAAAA4sXbFDgAAAAAAAAAALdW7d+/85je/yZw5c05psECSDBgwIBMmTDipsz169Mjy5cszZsyYFvW49tprs2zZsnTs2LE1EZsNHz48P/vZz9K5c+eTfqZnz55ZtmxZxo0bd0q9k/8MYliyZEm+8Y1v5MILLzylu/r06ZNJkyadcqa20K5duyxYsCCLFy9Onz59WnVHSUlJevTo0eoMU6ZMSfv27d+zfjb40Ic+lIkTJxbUVq5cWaQ0576GhoY8+eSTBbUbb7yxSGkAAAAAAAAAzi+lxQ4AAAAAAAAAAK3RsWPHzJs3LzfffHPuu+++rFu3Ltu2bcuxY8dO+FyHDh0yePDgjBgxIqNGjWrxN8v36NEj99xzT1atWpV77703zz33XJqamt7z7JAhQzJz5sxce+21LepxItdcc02eeuqp3H333XniiSdSV1f3nufKy8szadKkzJ49O+Xl5aetf0lJSaZPn57Kyso8/PDDeeqpp/L888/nyJEjJ3yuXbt2ufzyyzN8+PBcc801+eQnP5mSkpLTlqstXHfddRk/fnweeeSRPP7449m8eXPq6+tP+MzAgQMzatSoTJo0KZdcckmre/fu3Ts9e/ZMdXV1c61Xr14ZPXp0q+883aZNm5bf/e53aWxsTJJs3Lgxe/bsSUVFRZGTnXuefvrpvP76683rrl275gtf+EIREwEAAAAAAACcP0qa3u83QQAAAAAAAADgHFNXV5dt27alpqYmBw8ezKFDh9KpU6eUlZWlZ8+eqaioSP/+/dOhQ4fT1nP//v3ZunVrqqur8+abb6Zz587p06dPrrjiivTq1eu482PGjMmrr77avJ44cWIWLVrUqt719fXZvHlzXnnlldTW1qaxsTHdu3fPZZddlkGDBqW0tG2+m+Ho0aPZtm1b9u/f3/ze27dvn7KysnTv3j0VFRWpqKhIp06d2iRPW6mrq8uWLVtSU1OT2travP322+ncuXO6dOmS/v37Z8CAAenevftp6bV+/frMmDGjoHbbbbdl7ty5p+X+02Xu3LlZvXp18/rmm2/OggULipjo3HTrrbdm3bp1zesZM2Zk/vz5RUwEAAAAAAAAcP4whAEAAAAAAAAA2tDpHMLA+eO2227LqlWrmtelpaVZt27dew76KKZ//OMfmThxYv7/11G6du2aqqqqXHDBBUVOdu54+eWXM2HChDQ2NiZJOnfunDVr1qRnz55FTgYAAAAAAABwfmhX7AAAAAAAAAAAALy/ffv2Ze3atQW1sWPHnnUDGJLk8ssvz2c+85nm9aFDh3LfffcVMdG5Z9myZc0DGJJk2rRpBjAAAAAAAAAAtCFDGAAAAAAAAAAAzmJLly5NQ0NDQW3atGlFSvPB5s2bl9LS0ub18uXLc/jw4SImOnfs378/jz76aPO6vLw8M2bMKF4gAAAAAAAAgPOQIQwAAAAAAAAAAGepF154IQ888EBBbdCgQRk6dGiREn2wioqKgiERNTU1WbFiRRETnTvuvvvu1NfXN6/nzZuXrl27FjERAAAAAAAAwPnHEAYAAAAAAAAAgLNMU1NT/vjHP2b27Nk5duxYwd7Xv/71IqU6eXPnzs1FF13UvF66dGlqa2uLmOjs99JLL+WRRx5pXn/iE59IZWVlERMBAAAAAAAAnJ9Kix0AAAAAAAAAAOB8t3bt2vz0pz9Nkhw5ciSvvfZajhw5cty5UaNGZeTIkW0dr8XKysryox/9KBs2bGiu7d27N927dy9iqrPbvn37cuuttzavx48fn3btfL8KAAAAAAAAQFszhAEAAAAAAAAAoMjefPPN7Nix44RnPvKRj+S73/1uGyU6dcOGDcuwYcOKHeOcMXLkyHNiwAYAAAAAAADA/zrj8gEAAAAAAAAAznL9+vXLr3/961x00UXFjgIAAAAAAAAA/9NKix0AAAAAAAAAAIBCpaWl6datWwYOHJhx48Zl0qRJ+fCHP1zsWAAAAAAAAADwP6+kqampqdghAAAAAAAAAAAAAAAAAAAAAIqtXbEDAAAAAAAAAAAAAAAAAAAAAJwNDGEAAAAAAAAAAAAAAAAAAAAAiCEMAAAAAAAAAAAAAAAAAAAAAEkMYQAAAAAAAAAAAAAAAAAAAABIYggDAAAAAAAAAAAAAAAAAAAAQBJDGAAAAAAAAAAAAAAAAAAAAACSGMIAAAAAAAAAAAAAAAAAAAAAkMQQBgAAAAAAAAAAAAAAAAAAAIAkhjAAAAAAAAAAAAAAAAAAAAAAJDGEAQAAAAAAAAAAAAAAAAAAACCJIQwAAAAAAAAAAAAAAAAAAAAASQxhAAAAAAAAAAAAAAAAAAAAAEhiCAMAAAAAAAAAAAAAAAAAAABAEkMYAAAAAAAAAAAAAAAAAAAAAJIYwgAAAAAAAAAAAAAAAAAAAACQxBAGAAAAAAAAAAAAAAAAAAAAgCSGMAAAAAAAAAAAAAAAAAAAAAAkMYQBAAAAAAAAAAAAAAAAAAAAIIkhDAAAAAAAAAAAAAAAAAAAAABJDGEAAAAAAAAAAAAAAAAAAAAASGIIAwAAAAAAAAAAAAAAAAAAAEASQxgAAAAAAAAAAAAAAAAAAAAAkhjCAAAAAAAAAAAAAAAAAAAAAJDEEAYAAAAAAAAAAAAAAAAAAACAJIYwAAAAAAAAAAAAAAAAAAAAACQxhAEAAAAAAAAAAAAAAAAAAAAgiSEMAAAAAAAAAAAAAAAAAAAAAEkMYQAAAAAAAAAAAAAAAAAAAABIkvwf4Rc+iegGlTIAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "height": 600, + "width": 800 + } + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\ud83c\udfa5 Displaying videos:\n", + "\ud83c\udfac videos/pinata_simulation_20250814_034824.mp4:\n", + " File size: 0.72 MB\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a reusable visualization function\n", + "from IPython.display import Image, Video, display\n", + "\n", + "\n", + "def visualize_run_results(project, run_number, node_id):\n", + " \"\"\"Display all output files from a run\"\"\"\n", + " print(f\"\ud83d\udcca Results from Run {run_number} - Node: {node_id}\")\n", + "\n", + " # Get list of output files\n", + " output_files = project.runs.list_node_outputs(run_number, node_id)\n", + " print(\"\ud83d\udcc2 Output files:\")\n", + " for file in output_files:\n", + " print(f\" - {file}\")\n", + "\n", + " # Get the output path\n", + " output_path = project.runs.get_output_path(run_number, node_id)\n", + " print(f\"\\n\ud83d\udcc1 Output directory: {output_path}\")\n", + " print(f\"Directory exists: {output_path.exists()}\")\n", + "\n", + " if not output_files:\n", + " print(\"\u274c No output files found!\")\n", + " return\n", + "\n", + " # Look for images and videos\n", + " image_files = [f for f in output_files if f.lower().endswith((\".png\", \".jpg\", \".jpeg\", \".gif\", \".svg\"))]\n", + " video_files = [f for f in output_files if f.lower().endswith((\".mp4\", \".avi\", \".mov\", \".webm\"))]\n", + "\n", + " print(\"\\n\ud83d\uddbc\ufe0f Displaying images:\")\n", + " for img_file in image_files:\n", + " img_path = output_path / img_file\n", + " if img_path.exists():\n", + " print(f\"\ud83d\udcf7 {img_file}:\")\n", + " display(Image(str(img_path), width=800, height=600))\n", + " else:\n", + " print(f\"\u274c {img_file} not found\")\n", + "\n", + " print(\"\\n\ud83c\udfa5 Displaying videos:\")\n", + " for vid_file in video_files:\n", + " vid_path = output_path / vid_file\n", + " if vid_path.exists():\n", + " print(f\"\ud83c\udfac {vid_file}:\")\n", + " print(f\" File size: {vid_path.stat().st_size / 1024 / 1024:.2f} MB\")\n", + " display(Video(str(vid_path.absolute()), width=600, height=400, embed=True))\n", + " else:\n", + " print(f\"\u274c {vid_file} not found\")\n", + "\n", + " if not image_files and not video_files:\n", + " print(\"\ud83d\udcdd No image or video files found. Available files:\")\n", + " for file in output_files:\n", + " file_path = output_path / file\n", + " if file_path.exists():\n", + " print(f\" \ud83d\udcc4 {file} ({file_path.stat().st_size} bytes)\")\n", + "\n", + "\n", + "# Test the function with the previous run\n", + "visualize_run_results(project, run_number, \"Mujoco-Simulation\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Parameter Experiment - Change Motor Strength and Compare Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's increase the motor strength and see what happens. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 1: Change the motor strength parameter from 20.0 to 35.0\n", + "from fluidize.core.types.parameters import Parameter\n", + "\n", + "print(\"\ud83d\udd27 Updating motor strength parameter from 20.0 to 35.0...\")\n", + "\n", + "# Create updated parameter\n", + "new_motor_strength = Parameter(\n", + " name=\"motor_strength\",\n", + " value=\"35.0\", # Increased from 20.0 to 35.0\n", + " type=\"text\",\n", + " label=\"Motor Strength\",\n", + " description=\"Control signal strength for bat motor (higher = faster swing, more collision force)\",\n", + " scope=\"simulation\",\n", + " location=[\"source/pinata_simulation.py\"],\n", + ")\n", + "\n", + "# Update the parameter\n", + "project.graph.upsert_parameter(\"Mujoco-Simulation\", new_motor_strength)\n", + "\n", + "# Show the updated parameters\n", + "print(\"\\n\u2705 Parameters updated!\")\n", + "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After changing the parameter what you do is exactly the same, just run the flow with one line!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 2: Run a new simulation with the updated parameters\n", + "from fluidize.core.types.runs import RunFlowPayload\n", + "\n", + "print(\"\ud83d\ude80 Starting new simulation with motor strength = 35.0...\")\n", + "\n", + "payload = RunFlowPayload(\n", + " name=\"high-motor-experiment\",\n", + " description=\"Testing increased motor strength (35.0 vs 20.0)\",\n", + " tags=[\"experiment\", \"parameter-study\", \"high-power\"],\n", + ")\n", + "\n", + "result = project.runs.run_flow(payload)\n", + "new_run_number = result[\"run_number\"]\n", + "\n", + "print(f\"\u2705 Simulation started! Run number: {new_run_number}\")\n", + "print(f\"Status: {result['flow_status']}\")\n", + "print(\"\\n\u23f3 Wait a moment for simulation to complete, then run the next cell...\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we just visualize the results again and see what happened" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 3: Visualize the new results using our reusable function\n", + "print(\"\ud83d\udcca Results from the HIGH motor strength simulation (35.0):\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Use the new_run_number from the previous cell\n", + "visualize_run_results(project, new_run_number, \"Mujoco-Simulation\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fluidize-python", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/example-projects/MUJOCO.zip b/examples/example-projects/MUJOCO.zip new file mode 100644 index 0000000000000000000000000000000000000000..a0f207d7f658020456f33abe7bd4e5a89643fd04 GIT binary patch literal 48014 zcmb5V1C(W3wk;aAZQG6vWZ1TC+qP{Z!?rSP+qP|F;73)x_s+e)&aZ#pYHe+_wp$-- zjnzk=ea=0moFp&^6u>_Ya7$Rte}4F1FW>+;0Mg15vVyYo%1V#`z}630W=opcX3lQV z0DvHmfB*m>DBnMo`v&;OI|P7X6O86=wRHpW_cw~~6YVbmJADUzYhx#42S+*!M_ZeJ z;+>LanHBy!Ud54uoZOf+t+$Qo4#*T(<@`s@?jVuM<_DyLtD z;%p#7cB_}PN8$4JQ7D9ay>)s>gb#HD<|l>)Wor1!+3H^tIRP}LDeWdU(rHa83jWzv zdA~-mn>jaX=ljx~QwHmQbCqX;A@DqARDxP6;=&G|HqB~i&}9-|D9Sef8D5qvyJ1w_?7ql zX#VE${1=q`|BizB7mBpAg{`42t)jWLvz5M+xvkB=An}#{KOz4`*|={=4opC_-R~y= z0Q3*q{vXc&JLKPy_#Y8U{+&~u@^u!#j4+$m)C1DAK`c%*PG=ish7kPr$y|X`OexjY z5U@1&su!+(I9B@f{O>Ujz=gh)t$B7()Ci&eftYbPV89&71IY^nc zF8_$qQa<HI^z(zwjB*(At_V%=P9wy!4+X4Q{C z!G;ShPa>VL>>>E&opd=+kGw#hc~F3dPxCh4mPz2D{K*92N?BlqB#XH5bv zmROQg5}q`Qx)XztpCe}^S6*To4PdnV!2pRWLmHO}PHHAH$?*x4x4S#X4eNwNY9g(0 zG?Q?;U1JXn5Hgs$h6i2@B)?W!y&vp$9W0w^_Ex){fxr{|l*Q*k#vxS0j4Gi39OI)NWE6NhMSU>FonrZsAdbzs=ILT#8?DHa2b z#mF8-uD@c9ZqwqGgT>?W_y=*-M8g4?6oTi28$hfpE(rt?x8U~c8hrvP)&ld>sD5K? zi80}gS#0(evh#OZtj)CkYJ!JeX(2?$6l$cY0E;f76?^&pL#(ZLfKm|sHd)iOU^7LE zVS(YKnCw7%>LA3X1!%qgCrMaB5`$=EX1p2Q!zuqrl7AK*U8g3)Cnr_{L!W9D41a3u zt#-%Tom0UD9PRqL={7q2ZKJtF_cMA`OZD%e1?1D|d(C`xz{iO75?Cf@^5TjIc{@`P zj|^YhGuDODnX#5_ipRT0!+ugnny^xpoa*qUDdn97<4p{y=Fc2ZZ+HF1_DB*!@dg2* zgLg>uTrlj!-eSC92JOb7Lp-fRbigJ- zpo7g~RYS%2wB-F;a! za7pfuHYS@6@7I5ECSKnoi+y>c?BMsn z!tu?5|2(od*xDI8IGGze{^eHwDE>VSWZG@|84%Y0psq2k+NgX8D&|=q1?p)VuqMc~ zipo8lSFBWp+Hfa`Dk#+9u*g5kPE9JY7Dm971yOsbhC4%oa!l&0!NdF-CYjoH7?xBLkr6qw=W>ha;%a$nX^A9vWwO0iy`@FYZGq?`|`-GR)Mqv{RHS3HSA zmqdJ*%WYlhwB8N)Ukc?P7D#K1nXvggO<3P)BKuE;^6!@JAHL{sJcDxVB-FPr3cB`= z=zLsAPyrd0ejxZIOQ4WKwkVcB`#QVKZeF!#?~-O~(#a%mC}-pj=*PG*>JFD`sqhnW zRk(y>rPP@d0wzIlwcbU$PI|F&%qywO)glX_R(cNMg&x%mAjp%&OdL`UZR%ExOM;*D zN7_qXPWfPs1E;zOn3VC#&!T(eRx68?^(Z`+PEK^|)cah0G-)ih#NFDYY^1fBMgv|) zQJkVbo|HS*?$67EXT>yIf60g9w|uzFV4eTN(vJTBk;l-=*4fCw+1$$LFY-*u|1Ei% z;yU5_31EVrxr5os0)OAJ(X|GF0qvEPzdeZ0mrm*oCdzX9@@QLURp0?2m_$_a|4=NH z9Sd5Z)oF)MkyK_&506xf22k2?xx)jgb03g3$(a{_2kI}`6|u`zT}U!OspHxU4N`Id_NDzld#`;l$b;Fm$!S({O{iGKe`A< zTW1GD<9}Ja0G9v6u>XZ@XKwR7bI^7CKX#JN z&i$X-+;N{}w({?GuZVj+W_`rr`X05D2}hm>E2a?BvlE!vFV^;4JNBnq?6ZRjIEZi) z$r{S2u_E&v1~3UA5J{$ytR0*CD5(2{WB>p;{ir0~RLKE&f~=Ub?#PviWQuGD7t&yL zdG*zACuQfv79I|@`a8WWBXE{>lEL2@$E!Le^Q&CyKJmO`qvi?1%0fEik;Yic;yLjZ zg&B#=8Pa!AkE8vq8Y0R%ea1=BBbFJAFLlo(nWE}afJ(W9ncZlxfo|(V0#X5e-)Q6d{Ahtv>jZ)dJy@cPAkP5kb`QE7#;f@Mx1JvtLkhU}+2;$19&FUG*xxy-S3N$;^Eo5_D{n zjwY?RGR^6+0OwN{6msRyo29F4ZsAGQ!uP>OQWPl*cTRbYD(KnJ%Mi<9>GMXvhQ;SA z?7Lc%6*n=Cud%I1^GEvvn3BLG(vVI>i04S($VBk42psP`Fs0;GbxR%B?ah!xUu0lq8y z+UXi?D!XKY?9g0sJherNhS>zHh>H0WB6a!ydMv?F+BujxTA&hjszd? z!w1UyQa$18zuoqQ{;Y4uF&qDZDsusYDsu5=WWTn%Wy=YP^b%04zAYY3qyy;O97T`K zNwAgGL4X@q#$2cIN6ynk%;V+3I z6Hju6b0Wayp?|@N^q(g>fqC!MTksdJIjJ0gpgHk+JdB@(%#)rs3$baB*rPg`fk~}} z>qT{IuJ*;w=J|o3ZEXO8#;T#-spOK6*yXcl)h;Rjx?Iy$6 za~|iwh6jf0EA%e7hwmK5534CU6Cpj&y-v6R6gai3H$&LBb`UG9)CJ9nS!s5JAcsb< zgOoIDBwkzgL1PYB4q%lKKMC4M*8qZIfapYJC)&fBUA$9f*DLbGvp~Lrjc*=Q|63G{ zATfHI=R@j`z6;V4A?1G25rw@pKz<)Z{=uo zzEaW8kN(K5thz1oN=G0v8Lt%Vi3j#(;#&-4mD9S0za4ghLZlkoDxw3+C#pdq{i0hP zjwM`!As_L*`@^Z6FZ(`SY;6u5+$i|KEPdah#HL+{sHWA=>jKO?{qf&aH7yaH%2w_b4nogP|QY&$>!3+vWXo5~U;=#nuba>yiq( zy4@n(nEpT{s!Mysty3b-#=jjts+a8e1pyOacQ{y!X}69dkMGi_GBBD!@#JIACQkrFm}!7wSqQii~O%9;g_&ON5PM?*n&RZiqNHRP05C zF1XGOx7NIj77e4*Vc)fv46ZU^F79bTn_0_qD7N0x$ap!#QD*vPiO}h@}@lfa#pLU}c?id`-eb0Uz(HIWZ{|+Hu{_ zKEzI`x+{3=MQ&WODj6X?z2E=(!T-% zlbf-$L!x-}vUY*ZpHf-AN^Jr6e6WLd9`}`Wu54Y(jFnvVh#CM2E{w}Zf~(>ykJIk~ z$rfRr;?VTg8H3{{S;}A$xf2MCh|li&u+s)&t7hVCWETb?w@mjAV4?C(JoQqGb*=t-h8Xo?Hjb z>0deZN^UEA6A~K~F9UG_Y@74zoC5u1B+b^(97Ujt#~?L- zTxs}Cl#nr`eO@+9gIvCamR8r^^F_YJ3{Nq|g_Z%$mWnR<1?5J-cuj6M+;mQd*ZbKa z=*&O{0MiF)5h&tOU?q86ua%^-?`QmtJBc}-^ofvhoR`8ojP@aHuj~@L=FIa3!b_0V zT6*f|!}HfYem9vk;Kr|xj?)T@)aZ`6lK_12{BUv0e62*_z-zqy8v7?hMj4 zHW#-=7@qgPL#QdyCxs?r)RL)L=&M%}NzXn*f;uQ6U*zTeOx&7;Z`QG$a-aLlu8DVv zq>CY=>c$wgqK}z=Y;xchMd5t74DmDEGwwU+Fc z>fckUEm>&x07_?h$#=h zs+{mA&dp;3JLs&_fr353vy7Ny2Q)cn3Vo`)so|GTbA`a|@6kO1(X1URr~I{{&qyf- z3P5yMzHQTeAT>f=p*@KM_t=^kXHc@j=>3&X7-Xw6xeNBahgyh>lye z%vxZHuno0ibsmpm)w#h(2-X_?WV)oVxPygu30hHIsgakupc9tKSpk%sP|wa1l~56& zj8umf>X2>?@0U|)){!JUDNKSQj%q^aPM?K1z5Rjct}Sdp?-1&COdZjlc9NH&K>s51 zJ7PwZKkp-^IoqVOHgF8!H)@JmCRjBtgqCNeg%jG6t38Uz=vR#Ly6enArba?p4aLzy zqZM=E@>8@Xx9-UO&iut zHqcvHbP)5^zZ~k%qjq_VCO_+YHW%XtSqh@@9>OUS%b?V|e-251{UF7>1b2D3HYxVw zQE0r$ptj#lvv?;zs+E!7BwqSmzVYNqKqfUgj1!$`8Z;(|qaNrEoO|-axw7e?IHBE{Mg#7ze0l=` zxvzTX-l4jm_Z=d(`~Pg3)NTJtj9dL8f6bT%i-C8p!(5cs+|CdwnYty$h-ocfVpV!e zm?C_WrlSPmm;Y@7xqlqF;qi1I8=aHBlL;;14i*`!6-oe~JiI!_q`@AbJPbwm8V0pCtjDd|um}Sk z?P{$L*9YXPDVS>wa+#YL@Puk}4N`Nw3Z*N@=2ECYTZaWT79T^2VICw=j=N|m)>t0C ztM%2r-_x53hu?*RGC|MHbwP<)w{AQ8dQALOm7VJ|$SF7xNR=eZ{ zAL~(H@vVaJ_k_`rDDuc?ilNa)X5Br1E{^Vl(+{73k$tEQRSn>nybW;II1$4Puua=% z`%Fk*K?_QWryiFiw0nrw_Af#QO9J-!5%1?OVprIMA*?oCZx{}4YBf@2iO#G0MD`^V z0~ZjdVgw0jb`KICt?(+F5&L=Z7HQi_%-i1yX=*^7gMfcFZ9T!-;=?oNFh!*F_V`^P zXBEXIE{4wlTdaOocCi_9I+gdAmFwp#x|N_q7A%fb!S?fDVyrPR9ksit91la7Sq5_) zawTButgPL5#$#%)Xw*hWkvX?Lmy(?q4E$so(4KB-Ss^-#M{00)G%dTcwt5KXzF($t z#A@r0p2NkO`w3G~0aD>&ce;Nlu@6OVOR@f7Zkxq~m#me7;JMaJChS+qBQ#Pi?o3j8 zHw8QQdw8gz#LLkR_}13$fZixx4nL7j>tKiESl|`-m!Vfw5(F@*Mo6g zopJKUN-nrUx0a*QTOz7}D`TMjy{Syletza=Sy&g?KgufPU>@aQYkw#(p%bVnQ*B3W zn!Sv~?%T8LnxX0OM2n(`Tfur{WvAGBYJl?efE?*aklomj=TsX0_$xB!+!%&BGgR8U zxfbx8dB;CB+|^etr;osY8R70JWIjEW1ro)i?p6 z)pVOV&*jLcvG-@DlT;4gNzS&q$N#phayGeMGH@-=a4jl{MKkMMUk=OGUuP4@cofI= zpm07Zu)3<&|Cx~RJcu^lcCNv7eRT!RI258sVU5(|B|$_hF+Z~9xZabGN`DW5;_!#2 zECrbgiS0>H-Q9VQOz;Gcf~hp#+4Hi?JGzDapfD1M9W96FXT`NlZR;dxB*$u32M&w+ zL}MZEh>-(l)eZc$n;K0$m>;FYA{VaF+f!PfDz=E74>{t3AS2EKq=(P&>F zE5Zi5#HTqPJ-@#F*GYsVO8XLi5`PD-v_G$S6U_jObo*r}coKgg+bV0*RY-6L=J?NH znx|1Lx7UlVbvk0MQ*Z)7S>Bc9-T)mJ(&@i!E-@)v^Z5)CWPrFQY_q6YfVKnMv487 z;51Xv7KwYJs5~JGiN&jhE|kAk7ak@iid!t@CyUD#FNI05Ai8bUWmT=4`6}vO=WGMZ zwFN+_WZVvg4=d2X6|{9#)gEDin>ixv8)k!rqdK@hl)c%htEKUaqth(i$K3%%hWWNn z+B1&d9&|jgn4Yzk^KUYvX2VM$o<_5|nv$(uMi??gYr2nsiV!vL)k0avr6=eXcd0|u z%STaeO~%>!Q30~h%RjXipcFNagMrOy<3jL*ooM4kxQIvnU}s&blDH@vU%`XfdHQ~uWbRHc;t42gO_`PA2nP7|Z7uk^ft}sfuFv7R`ixnw$oS9{3 z12K@FdkH!QFqltVUI~%SgsG0YZc(p542IyUJ`EWtyI9pckTA|)S+ez}Y2-xqy9+Fj z9zEa$c)t3UaT;A#?E8?j>~s+KZrhuIp4Qe^NrNKva%NT;+oI-33qixQ5nH5y{M^9Dmn zXdVRGi(r^Eb-35qHd*ZF@EL-kW52ZQCjg;^=rm1Z%78yQ??vFz?HoNc)RauGP&PKO zRWf-!aoIjGte~TI&`NFll#xbFhx)bvY+X7B!aRR?&L7zFI~7HTjykX*xj9 z>o^rj*KLS9gB~h+vwuzFg#( zyM4~eXoY{+U-3s>-qKQV52Rv92X$K?*-dbZfx~R{qEi)8zOr3hGfO|!P`{WcBQ@;P zQjpJ%mFADMMW}3Xcm+O3&86oa9`;$P)NeI2$d9Dirh4bC*R4UDzco&I0o4f-sE8!e z7Iw|XuscpujZ%&?$A(BG{4q(DNeiAW8^8Pj#ZtR`O6uj@$gx;kUl*hgHI?Yp`FKh| z<~ERcO;_~UFi9W$ZE69x{%+~m=ae{#eI0uWg6j}k3TydkAIaSZJ{<1lI}%{Bn8Q)t z{YmXGwyhPk)Nazn&0*c09>Tjv+~)QKq<5K`kk#?Jw^*RM+kjp=gjxK%@$6~MNW+$C z<>Qj;6S5_v0Z=g;~$uj12J73l8M+0(K*8ugRn!!tve5Ztyzm zO38`G!kl#~b=Pzc*5`(M6r7w}F|&5@>06>oYXHiPk0JTSsg)gj^L8CxdmMe3M_>2LJ>%nf{)5jAs{Go53~^dP_-78q zdx;K)iU{K%yVoM@BW~_IbiQKEAwuX5B(hfvQV73(*f9r}ewYs<4A*eNY9Z8Z77h>4 zFfLiQc6UL!&GiTVUu)$0-~Zvqe}?SUg8%>o!vO%${SVg2os1owbpN$b{=ZkpO?Llw zb-YS-(q^9xq3aK&Npj#NTU=tlPCzSPT(LFUx$|#(8&D99UpPZZWeG}1tSg4_pf1n# zKbu!Hp&#a4&yX*Oon8#pQ8qTtcK|rL73!FXgbD-F zSx^i%(t@Ac$=&t|Q8o5a>BXh*qxfB{kiRegK!%}V=z*=cu~!z%8IRNwA@-n$efr#j zH#%P&WX!_h$Mw69DRv-C3~oD4N}kKDW}RbJn9OPD=yAe>f(8}$Ar>w26G0Drsw_lO zA|Z+j)G-S2aP-4XUp`&dgjl$k%aExodbhgnrVh}ehetjMh1Ai%c%-cLY-7BQy-hGs z^jZ(}N$9EpXK_NPWV^)V$_dJK>twd81|U}=?=U&6T{}04exQ!;R4s9Me5m&WzWd`u zDy1>rilKm!(oH5lKiLjTkc^acR@qi zmB81f^tg+|t$_!3beDIyi9qmHupR$np6>LcYyNbwb2+aSv6Q5C5>`V&*G10{-fXQ7 z?u=|1UE%r2)zv{7POc2^Wk|EH3qROkyF5s;Ej4I$ews4r^QDnVkr1Sz8#@V40Gqlq zE(NWuL{ecQRGrl;u5)*!wpU3|(z&3c+tGo*CF7)e!-A{GE8w zHVlEk?&g~A=59ooq`_qnQiiT@#$&1WF%+#dOw<>nFjC5r@s~`SiZNWouxv*fakcuz zk1$z}TegH1cSi`!>8j0vJ7|5Wojkj5u$**@4f`hR)_(?|X%2gJ17oXNd1r2r#vTdP zwR&e??3{fTlg38-hz&VCwnc1?(L93FOMz!Z2AO1Lu)w?E3yT!2a|_y6icL74$aR;4 zU+hH3sWYLAH*we;qbVKqh|3K33PdE31D=%k*b0mMfQ>sNf3JuCQ;U8DUH}IIe1Ukh z$L1$cYF`Wfg3JToe0iCnq+l^n$px@%!y!sj>Ike2@U?zAX6Bg~S`f2|AG2m}0cO7$ zv2qgoAs?Jr5snF=Na=w5N6b8F!=RQYx+w~2o`g-sCwdzk&DQNY-Z0W#&cLdvb?9^N^+b^EKda(KJ99t#uO~J+BE4})e7dqWK2VZXJ z0(TsejLo;I<2sk;^EEXZ+5^J0`kY7Cbu)UeQJy@&9zeI}zEfoH4iYxDU`w?D~#{fGzv_SH>`G3Y2DgH*HU zqBICJDh7LeztR0m8CeZsHPgjREa*T103u-k02u!V%4lS4;B2bv@bhwZ_>$4AAN-?uL&iDJAdLLbrqpYpE#nr90)x!rXrd3IltaG1h3z`;;e0uIA4 z_O@OlK)i{9Rt*#l*1HD5Zc?$Hs-kg+BkQNIswgAnB;AJy^9H=TI|G7Q^b2Y+g2Np1vF_@;faepTHhO^7w)lAdl*r~*lY51*P9JnOP znHykmm%ILcQS|mCy?kXrY-RI2;}ClLos#375xnJ%E^GiCN5dJ;NUKOoO>>Y@=&Xh! zG)&-j%26JY^LnHv;)A=7J zD8JOIt(YlVeRxe3#Etet_xdkXC(5|dF14H!*TRK+&z;teg@ zq-N{Nv~glH?XtbAoN~0wt>%AB0~-y$9OG}MD6{}Z8q|cNq+Q~!MX;P$qkSfqadGI} zx?#mCk-zXI-(g*W{-wkbf-xser*+1d%cBy%Y>o@XGGruqTw1ixVl_kOE?2cFNB_%M zRbnKsrmgq^&PLS;IW!8LR9z??P&bl3dAsNmm$lN}oC;lt;4(New&Sa;A%nyp&Na2T z<93E)(>@#ikA0bQpK(f>L-23U3432J=;*5Qtt(go!xRJuwUfyZqQ!*)a_Pwip1~Tk zIuh{uq9w3b>mT9twORx1YS}Pal#gAjqM_iEy0S=DHe5eF?~6jF&XQJop3&1OG3UAt zTr|&?`|PKM`P0-j`?HYx&vB&j8?#Ab_T0u?)LUbly@tG}z4T}YhukNbX6`N-novtb zu&@${+Vj<{ka&%DWPeNVkvd!^usNln^}@nR%>TM&8N{KKjK|`qc)h~09BFnyng`o) z!^vpwwqeqe<3)7%k>P%ka0Sg}l*{}10k1WqEj;m7T}~0PGGcp!uVQPG&z2{LdE_Lx z;Pb1Yf|(t$tz2SBI0xhWsxUtgvni9w#@%(=5DWh2oQt&O0tx!Xd@gSwc&L&h@i2^( zFcU^Y>77@d5=6GTDtb#NLiZQ{SZm@{Wp!*< zdl&0fA9Z0nQ0Yal8qFrI_oVaD78nc>1f|y}mL#H;aAhz>HPWSv?P2S25!NG(mEE7z z%R&3K)*_YD!V-z1x&)Mjbqo&q5b*ZPGd+|lbM0Izz{zC%1Bz4^)HnZi3+BO&?2jd&n9=ngRI6WqdNYs6A|x17vup$LTvZ7{qcyr_Yib9&`D zi{xuhryA)1nO|2Z{o**W&95C5^;~^E;hXSvNH@`r+_{1sk-LuyA#NY3eV*%CE|8Sy zPd?J~-oBHsZv3_bRvDX90XFzY><8zU`rb&-8sztxdavN#6o-ML%k?blly4m=527KsC0 zgly%>oOB0(l7w46i0?5)l7?HZiT9aA6YGaMW8;57|0T@731Bs$f|_rTzPsyMfd4Nn z>vvO!ot5$bR^>SRzg1;z#a^2=K7{WkRI;hw=Aa4Oa6uuQ&cGvwoXiTk=WcIoC0nE@8ax)oa;Z9_NCMy0)l!_ zv=%@Lc0#mc%qS8HbR-r%$Y`*Tq=rLoc!5b|az}S2Q$zO_v?RfwPMpDy@Age%1ky{C zm8RRr6(~P0M7?EBYkosj#_2CXb}$KUe0gFYOk!2ZBQ;7~2YZE7&8WrAnTAjx^Ae+8 zvPJO_`VhqmP`lTb8deK`D&?o&JS&*5?7I)lmh&SdoX5@@4+q@n^_lGf^8RWJuglj; zGzYyD_|mUS-=6j*@d1fBI-_oBSKlbQKVuUc#mUeK75pcROh zJc;IJp)Z%ivk$CJs zz56b#;iE$^JBO;YBp~aR!C=5UCq(=LI8y_^B*uC#a+jP+x7vjhq)?Xj4k+NoPiNfSKFDeX2(p1 z>n6o5=jBN{=BLRF0J#L^StRX(gB~~W8^Ka$6B=(==)})l7pqXLAAf~xzb6F_HtpLF zS#3J2>#$u47BJh|F>O{&q&(To9c*Qf|FdQ7U(M`F-;<^9zO4Uq(EJZ9fv&EdyP>|J znX#_!zuK1MzNbq6v2E!eQR+~4-Zhv20E7Yn0Hpsfqx^ddlcAlvlbNjzEi)tIH~S6$ z+0XQk%kcW%7V-bu(^1H&X|=ABvXGf@SW@_MITNv|VqW=j`NNQW@@ST+=+c_ti=i!vHVtV2nlyK_pihoGPl69fwfqEpE@*+P zURCIupD?vOIiBM3B&5SzWm1XH_E&AkImex$@6z6#v3}d(zS~;w7g+r7;QB9ZjmOWh zE&(q|dEprR>t>#7Xbrn1KTU>ZMJN1or_!KvVj8*jW7@2#D#?#}Wtl|QAVak7QsU>Q zYOFwRqpP%*cf8Yor{Sk+pT0>6R`OfgMzOjtDmYeR@@g8;`Z4mgrymvRVUD8@c(D z#7#!D9nf>V4S0hy9Es9@kK>!+5u&Da11+@&Hf#!>0={2@0zXMZa%V1YPj?jTG)M7V zuhs<~3EXc0!9W3oiHxD}^YUc`&2df!AvMyacT>83_bUIV9l1HumChQpEB!k&hg0vWSWF^T`-Jst2rArXa^*?#uQL+jqwaxS0$G3 z9^f%WmYDK1fV6sb<>j!}0xdLHlLjRh(I9p6$g2!DT$4r6N<7?(cpime#d)FSFw$%+ zJ9QNaZ(gjD3MkXf*rC(vzSFPSA3v3UoWt7j2)0ehJz2;*#r~?`5Q9t=X79kW^bP+R0*A_dc3g9sN5crqH&*=&cvZGRMr8} zkMRqj%&`hMDGnxA_oGYpsY%@~PVDZtr}w6oJrMLvxh!)!(g|Yl@eKn|#;HxIGLVEC?#ux2$PFM(px48Gxy?U! zsohnGWNO~95Ad`Y7t6lF+EsFJTWyf+Uzg+y+-}bNQbrCXWvgPL2H+9gQZDI-`rNdiJpz*prguT=$@)R;4g+Ee%uvNI-zU{G$Q6PCB%4Nv9-1n>G`lE*#_Nz+G2 z(Pd0FNtzGD(1i`jm@`s5Cuf6T4-j3FZY7~51hlhSiD6G6<1bEsBZiJjk1#+&*jx=| zHoBAbg)*VfGfa(zI9Wwy#2wR$8;ibHRY$0C<$=fmF+#>mlH<}Pcjk4C-v=N2#rF0* zJ9m&-)YhF8(@l==Yr9FAXf3EGY%-mYi!C3ggR(|U03<&1A3ET>m{_NGNB*s{L} zYYP5Pl(UO>V0B#!jQA1xbR63F0$Dld${$qt*#6{NNE~#D`=kyy&oHQgnm=#+B#AccHp$H?KFdVq(G1`h6Ge-tyllG2Tq1s3-!Qz7#d1OhRvS=X7bxad!2!QDe{NW8swOk(x_cI{Q&*b&p=vzl*bKIgze5oTfcg0=Mc}& zHOVkoVgn-`TF|fL6ciB?LW#__zy;G;8W|B2OlkEszZ>7%%TScjtujjTk~zOiliEZB zI0|Gm8i>!5SeRg5dM5=}2xp|wuR@i_o@>nilzv(}a_n!(-4F*h?C0Vc))9CF(h{he z!B>w}0;bO&I7?`8l4oDOmlO)uo2PigYlZv6xn2TkNXI$SJe@N6$fk#Tqc31+K7UuS zN3=Bcm6MTMO?VsJtcI#uq0b=TNCgCfwx_mtR?#gFpbMY-+{vwR=(od&3qp(DuD-Pw z(`3MtiX*=m*}^@4!fY5YEcmJASVar$skCthV70_|XPj|Dt0M;NNZuU8Ob-F#5rJ4Z z786RX5Gx*rW)zFsi_WBm;WN~5$tgBYr-iyM7Gg!X+K6dCiV$^=EG*GtU|c~8c!->_ zJ|R7W*i+NOU=YP{xUtkMqXocbNZh1eP;10`w3@Pa-k=+Yj>)9Ilti$HB1C_l@+UU zsV|}=eMZO?>I#L*U&%~jKcxKo{Gn!kGl#Z9tHmLZ#f?h&1^ZD07p^2#LNneYA_ABA zto2L^$&3_~Pf2x@_A(|H6eNu?QTuapiS~nG^G|TN`H;=Ba-y=Do&@{ z-~i{Xj{qXeW>-ELFJhHu3+ey~*hz?w&@yo&m#K&ZLM82I^}>jjJL~zIVie$+ty3+$ zd*PY;rLlt1ozna$YRCgCn1Itmx)no!%f~pB#@F##F`~_=hnHXb@<|LJ(j>>N&RLKE zehMZM8XSZH?%=BTO{~8N7uZiOJdV zDE$Kbd=lxlMa47KL%~AlAsmg@ryP>iJ@s^3W-X@#TSK7oLba3?mcDHiYhE zacGyUp&f8}OGl(!$Ng4hd}Zj}@(W?qi3*Bn|2c7dB+n^VYyL0Jw&C^g;^s#YpB0ah zrzH4Q#`lQvwD>~nrHyqgd6t+(-y^RF>&%nN2W1CeVRHHX7L$rG#dCL?S!I7s2UP-? z^qUXIjiEY^oMkD>9#x&;RlpjZiUUV!%US03@K5HUGj#)&B@)`uczQ{X zoEPW-mkf^#n4i^us>`h^5lhxt>Q@=&4A0EV9yV%xs>G)d5p8!1NewGH1LWt~%iqiL%d{Iu(GGY8AfWpLNa>Q=ClG#PUe;T3+1xV zW#mBNK>@=+t@vTy#_2!LZ-XLDpS>;xGAxpgL&4 zb#%ycgE-l@wjrafLPhX8$%2ay5yqt7azMD)Od`BBhl_UnaB%#{uHkKdQPa3~(Ky46 zWCL3m+%7KPDw26#(T|IQ9~K;w-u3ZR9n)!Ol#t%RklmCFLTjoXbjefnKBj%zi1RR4 zsO%(+xEkMWBE8bd@J*o}w-{(%^8;27@414$USwJb6CE2nbSZTyshWEkm$Z)o6Fhkj5d%wM(p1EFC$7_?l#2uV((C~L7H2?=4qlELH6v?una44sTmMafKy=Mtb zc%J}wC(G1A%~ES}I-EO-O+Bv3*HVe|6&Q0yq((PWEWO;C`MG<&wdQf$`zq?Ks~i7D ze((u-dJ?q2K?o{a<>?w&WoK#C&fCGE6UCiZbW^*)LF5`E7EMg*P{^6nHZJg%{l=D} zHrH-3Oy@TftQD@j7+(XV%oU?vPz1Q8484WL49^(&Av&qYI{*{&VUm~q)`B@;Jxs{Z z1{XZ)4k2|VsP9m{xVB#u`FKyP&j1fG+};!)plU zZEIJGDYoB!;=QE(NEvsV{m5fDf@Sy)9%a9Pq3GL__U!;JK~s;Zv$&^=Q6#=(kZW>yJi`4DO+BT@ZkSrYbRxUe&XE+ieR6+a;Z0%oC zXD>lEh;$Z-|1hAgc`6D)(cLkEJTrsvrIe{)HM&;Xk>$;T4VI8{%y1tvO^^{3&Baoc zvp)wwbm8iL(xeLp>$t{|#KqY=#J^c>1w}NYXoDv*gh!T&51`kjN5}yCA6?isYKJo-iC#xG454aQp`$(IVH; zn^8$pJ^^*taTDfZ-$IP9F0-Vc%P>%hz zhy8VZ_pYNt?O+eqLbS{bISY7?=_UcebNa%r>;F_Sgb!bI?M*?c%}_DI){ z!qF=)OA_tpU}WzOWoU41cyHK6(T9G^i-L0};+LBX!NPsJ=vc-G_*_2WW>)9L<6co?xr>x2T_F#?*(U+0H)ciNc?SsA28Sjm7!dD*XHBqWJdwuhzo*Y@_7PYo zy|LXRq)@JK10c)@F_q5*26e$_={>a}?VXR{%@y2!9l9-lZGae>G^~906f$1lQ3+QW zvFgy;YidKq7r>Wwc&#jDDMk(`4H&pxt>NcwtShr3igx+YqBorv#}OUd)C>>n#bY_a zj8nD7mj;M}K~n4TbNr?ruh+*8c}oPs`kBs3$9>1^#yPRg6Wg|v|C_0rnv1!ao37gT-Cf;luV?KQLA2oUP5C0#!MyNpLMhYFrIY@y zPwBmJJ*Pu=rLB+7WgZIf(c}I%p7)54{=B!|_nChog?QZGZ^3-e;i`h9Yjan~dOIGr zWtyq){&oqNfH_L|)v-HTqbSN*Qd z#!XJ&wa)!*%Z}He2PEjm6dKQ3zaxCwcavht?w@_3&p1NNO~;I^5fyz-sv za{a3F%q`d2Wmh-|aGhI*-wR4yL28KhjdpK>XFuFDZ-aG&9%Y!G2eN;}ke@M6t0-)e z%QK49T>l;K4QL5KNYZ~FOwt6#>v;J|6UfBKL9^66(mWo+F`1D z<&Nsju3aqeJ;P*iA;!bN2gR1r?TgT54rg;Ti6CR{I44;u3FW!abRykY8bBv#Dh(hX zYchRDo=DJC!0%2CPxdMj^OAlaQ0^5?8e*_)0_bKZe@htWE_uLkGN6cZt;bQS5Yx(djL%m`k7G>m=Rp4+R2r`V=oq$fos0%V{Y+3gdIeS(_zKV?mp zog4Rn4OMtAXU~;;h+>xGIxmp7(5b`7=aFL3-T7o<;#_NYc}9zIn4T?zwe&melwCI{ z@fG1Cxq#{CEFo_Nw&3(Zdo-B}a?5+#4fDyVHgww;C zm^DH@MGks5Qy#1_pi8VsY^1SP{#JAOG$*@<<;5`DPG0UV-SoPfvir7jl}mU78pAtu znAJabZP1AMeiH;({V~L^El2*@TLo?E3#Ka&xRI~)yiGw=+IXnV+{-N7sm9Bb;`b5=1)~HbM53=h>A~C+|9HH~X0qO9>=bp$jdA^{J8H_!zTIpSfCy^q2YEyEc1qh4b3?gXhAZ^D>zs_1 zib6a{%lG(WEZ9k>VD&8LQk{G9EOoYt)&u+j?hG!fyv; z|A?vv^xBcmwe%G|&dp|-Bqsvw(y5P%uVucTHl zZo6l?{{cMn1NZg&uHy|-+ zMQT9eXliwG0Mkep+-oQwM8OFCnO!RC{i4zGwe!X^-<6t7z*up@QY~p5(3QB_4?t!c z#uEAYBX;TKA*=_E>4W{13lpVyuM@q~sTXTq%#fwDAHN#d;wYE}t zI_#Cjyq~<^fk`$NDr*kbO9OhH9tsGyhyHgvnP&s`54oeFa^_d$)0YWmYtQ&YnK`Zh zSVYS4ILf+@V~dieP2e~6NopVbkrQgJO`KIk57<8rL>J!^UKiYCPy6H9SYJI+6p1&Z zl5W^%RxoN+dXnXWfm*vkG8bY&RAG#IZ0 zsj#G^#1J($GO~O~kVO8P#68-7DEtd0NQCVf>2fZh%vaMLI?F4b`hnysgy~J}ziZ^h zMNG=J?zygraSt&Jd2oz0&shYNprKF5aS#^@|5kIZ8J6Tja#>sO&-`)kR~nw)nQq5N z2jz{QuUsVE_U2#1w$^uRB`5JBV4PAae?nfu(_e35{WwLOoq zR)P(7bgT2n<4zT}ZD$rHU(8DOJEr#r|FUEy$=dGs!Dag8FZ>v2x!|+Q7Uzx2Y_Qj( zxxcnp^VfP7bpUSA2F-NAt>bID;8lnvq=j#t^#!VGu#+#J=WTg_`9V74@Hypv58^y%bd5$OdH}@815882W!c4W;i_*V98FpMK6-zrItGmk{pe?wW zIMVdNDyK@s_d(8~A4i~g+9%Hf!k&#lhe=LQE_P@8F!qkig3hsX5!4+=tV?m?BYuM9 zVas?Q>OLv~W%TTvljWjK)l8ND=qBQZEI86n%?pCjNnU~jsXn-0Hs9==5iF@{{0k=y ziRW-%sFzP6rX!oW(`WcFwG-DK@PEBuL*HMbU^+2Q6iMsaP$UpjDhdOTx4jBzctXOM zl7o8`)l8Na~1NId(%r4W6my%;-z2O(;}C#Wj4cv zBC@pYYyUO5{y(PdN8q0IJI|6sI02u5DQu#WtK*I{Dn<(fW0f!HwqDr=`PI0m)rEYncL=%4^2d zormFi{?Ct$3t+!&`K{SnzO1tHQ(0IQ?-K@`dAo)0KU)N40fB_4f$2mHo0n2Qt}>yK zUnDu=!ch@?u`IHF*da9zpP>;TugA^U2}Tr$m&p=O0Wil303p{+EYDNfJUM8iDQito$o-J(8?e|o{_(is&lyLbe$fipW0k)a9gb|ueH`IG)4NsAu z2>FdK(z_K|TSC>X(WMWT2IJ*L*(XDQzg1a2H^(FaZW*JVdAwe@QthS8bk7dK$x)u! z77hs@EXv!oEQz2ux-$Ebd85OE;Y;g+BzneX!>IN=$jXSV-c*VcRucC-z5M-F`cM@0 z+LPSn{giVLUVnY#WBD9TQw8}$fXn>J&!ET<9qPyuApk&KB7W>v^3bK^wO!d`|K$9=iNs)j^gWPV$At75 zW>&}WFHQC}Ny;-q9zwH2>NClyA`Svz!_uf10&Mj*6AJ}U9i=db(4jFw6%D0NYl^B8 ziBfAUEd!)}R{wj!u|%aQludjDBO0+My`>H$z?Fj@G;dOCZ53jpaW+h2%0yXH{&OX+ zmJ(`!Or9R;0abkWM{-C9{JX5<=ge{een~#3G>5aCvC%f!ew%C?AnmPrx z+q&Wr<>|HSt=-X5sLp~{dACMAf-6ZN#K0{L^r{23>1LF5r6VgBkeH?5X2noSLVJ>d z*!>J+D7kxUx~oTO2d4?7g1aJ(3n$^0a#p$BC3Q{S5rnP-WgJlJI3EIVFUpO0DG9h2 zVj|O*tZEi{rjNpHLh}H1GLftbVI4;5rk9?;`Bf$(+4hV7%d&HHo$5kOBG!`_*_u{Z ze@!=wD9*)+@Sssnx1Qx|cV3BfFT$llctbZTh+))oNf%%yu|K)+*Ht0XlQ}lS9plhL zjOFY^=|}rU&RfOY{ndy#JVUsq(N9qF1kv|MUUI^iI=*vn7;PtwkqtTb`JN%*49%fl z&Xi*cx7C?L2~8lKz4#_GE3QY#1Ffp4vY@aXrG-(h;Wg=ny21MFpn*%79VsE`zvtPZ zrQU)miF;w3pink0?0s-HZls2x#l4I@aKp9L-^!6ZeEa~)MRuOgciI&s$^##ia8rvx zIzT^#-0lGr~Cl+mVx;hpRa3yfS5l4LQr3jFh8gRXJIAPUhq__IL;Ic z#A}gCilH}-!+Ho+k*=(L-BNo9gzzc;20%mu9+iPI*?eh<@rMqP;$egf6V7^3bVsLY za|xoHEdQq=tx zNYo3uukfX2$4mi!&75ttZWhF7g7A_**u*%fY!ydAmw#2>TnY6jQg~PJvh;Ml<>$XT z*4PEn>Zp{04SNx9rPd;7v2)>7v`J1iD65R_sqT=u8o$Qn_4CkS-hnDa;)=r`Z{RGr zz-!#o9!lOd;j1tXVm%fZT@6WN7Y)-W8a5aDExB-0xbk3j?AY(^-9NUJ&QXnK!77g3 z(jcPz_d`~t-$ZsS2(19zs2`mO;r>QU_`V_wx#N=jCl2K0&dSpQ2T}`59ll9T zw1dgNtbJ?v1#XD9<&q9|=)%SJxpO7EYZ&QowYE~rH|gChTS7BaZRhx^uCMx`bne`s zA(vB7-TCAy2bq2C`Ep!3J2=ebG{R6e2n6$Yw&XrflC_M-{OsWuI%}Oe7XhKxmCtg9 zDr1(4Qh9Mg-C4|k*;&BcI0*NWi4{+SR!26agG$eyTrnE-<7E&#Sdy5RXB)<7f~4W= zew2H8PA@I9KlEcp7}-iKpP&1Ag8TwgF7$G0uSACgrrRMl=n%ZMtZ>Fh*|J3qk=XN` zmsirkW!M|*Lk7)hzrCHdMdUxu)wvw)%qJYHTY&QUvmDm0+M%#H1}t5Q0JER6cg)qf zT3Al3F{DeZ=)BqN$pD+`&$z01W-rZ@2o5iG{1wHnM8YFQ1u_Mu_}*HR+iVdl`_TcA zq#0H)Px@|uwbv=0lQZlWDq}RcV@#;6JfJ6A_**dJm3Ek zKG49Ol!4uG=;D4hg8lM0lIfWOF+~9_ro8fi!;+#G3OyzypJMa6*^U?h2{fHMfv>jH zBDb&D^CjuUzW#PY0xDB3Qui}4H&(ibfXXAKSX2U`w<2(=qUz%XNXX>#kfB&|&2xe# z0FD0RG0jU}(-aST1xU^4gV^^VaJpb96>pIOwkpWehMWw@`L3&&$EF~a0F*Q%15Fky z=!c)3$(FR8nU3WcldxLjptBD@SI#JD+Dfln3yJn+Aj8Whsj0>*$E`&y%I?4}j;1|p z2x8LIyXYc}O0&;wJQ}1LrX0{8UzQns^K02?$ZW2)^>l<-rjpdcKa19 zSS5eYbRpouQ9TI`^t%X77dzrMtO`fdyj1`3#P zz|K!_!BHzLb_@MZ5zIintl{zJB;_C%Dw#KISK!>g{oI z;B)wTLS018R&lLrpo7YR-bgXKQGbHMM$&fif9DfUA$T9~+JSREdZ*r!E@VYT?qW0$ zz|(t+fU|ag<;%0V4f{y957a2LH)RoCbJUb~pP>~s7b@iXZAdwa{V z!7;cY5$m}f7tW_{0y^&0L{l3oZS+4 zY#YBTRKsG6ASvBlgsd8qxnEA|WaJizUbsni5LDFZXekiauO_OU1xtVN5|tTWHa#;9 z3&Ci#@J9EMTc05O4S8TUXo{4Qw}_=5(ZdY%H(0*i@0{q)};W*b#L=USd&!iTX_eGrAk=hNNREQV^nK(bocMWDHwC;m(OvdROmu z_qBy+fz>=AdrUZSK8Yul1VDhF99}dwNX~Of-xEt-$0B zZ{Rf6)~?3C-nFPBZ{Iz5Gw$C|jlln^()QJZb>jYIsPhV5f0ue(gFL@5IUpkE;_Fh~ zm~Ezhm2R+guoj|s_MLS*RnD<%b4>)CJst=?r5F^Ou-e*=M(&9? zrS4M=EKJ*1`t`z}efSgwByxm1lz~$);y*9bJ9Q&pTNJ-Ia3MT$0%JZ@+ z2gPToWr2KQqn%;Ol`GiS9I1}jFU4R_{P_tf--tD>G?+{)*ZZ%OUuv#mAVoi8m5HdL zCdIyJ)&;fLt$p$d<)w9AwsPDNP|Xi{Dq?#1O`xSIt1Gk{BUNezGCH;^SzOK(icyaB z2GH+5q)cj1)@^1uq`_F}a>TxXlzB_z%*#*Fm8rRXx(bnYhtW>Kw}HDhmSq^*Qz`AA z%Py$n`CFDe zx5!JYl`*q&)j!EB@V}=rN@=gDxhU;icubc)D)5-oHfZlO@e#J~dfChBu^X@|@)*n! z9QU$(S|8La8JfVtdUFV0pym`H&H4o;)47~_csz#M>KM6PQ~mAH?3DWZpfhJ9yC6H5 z(-_}eACNu8^;W%`0*HqQA5)BlgfxiLIWeja;Hn~&}mKN}zOKB0LXldkyz`%`=_4*<7mwslg_?SibLlQ* z^bqyd4np-}>e*!0yoOOofUUQq8J-&_KFU-uHO2hHSSOZFVkNuU*^EGIbP)vsenyCR zzrX(A0(!@4cWsahbqV*dT8WVjWdJAtMPrA4!x*wZ0$l(Ty6qC2N|iv<228bwR;bQh zn+M)eA@iss-OfZiVx=I8&W%w?lG1zhI*(tlRP0|`)Tjv zfWODffY!#eEb?cHGqLLTB})hMrpN1XrY*_Gt@Q`2MsNVM^AB79JdiLb$@=={M%`PU z4QE4=D5!y!)e!coV|avf5mo=6z(OI2PWhKxnyuEsAsRkua+CDhx2Ueurml!;`|_@+ zixZ<2cEzimF?YtcTeFv5X;#OkRWoSw3fFQq!&J9(-{$4@>D(D<+9!*?`vqJ=hz3Zn z+LD*3!+w*optgOV)ldHmER*=AQW!KDyx=G0l{r;GrSD={M@F@rtPQzk^ZUoW>N?l4 zA~#TbSF;tS-Y(&JI``VK6(#$9!F@?HOzZ3GJm z5egsub4u+LP7pG5bN!2CHR+ut5k1#pzYal4B`i!pzu7J>5Ae``{8?7oHa^7mTQq zrY$qC3v=Bt$$l$8q2t+PvSyme>MKr|ZG5n&W;|*qO8)%Xqh@pdu$O2-0#v%Vo%rO2 z$~pdk;S2oXKl_NA$R5J4L>s|~)r7$q)`eDT6uoS4g3nxDmpegNTDdnunD#T<(M={0 zui8XPC{+_&q}_xIS)NM1@|p22#l`WzowHQUbQXyuC9z=9Y$QGTwbXx$ zT1swdskbtn1j|mQS^jXntW34kzjWGUW||eIs&FZG>Z%|#Ss82Mkz^EVw+W&c-87Mx zVJcf{)jX^a`mkE)pLqAW)#g!zzEcq;PSI^JH;cpgKg&aZ5Ro6~%&JZ*)$1o~Y@5q* z9b87jNEk)+gL|k$Q7O|E$rb5PLa^&yjXRsx zJQgI?F@}nu*rKsl|J3*_?dsFHyWQ38_g%(kLHNV$sZzt{K2j*!^}4ho?Oh2#v$gujXJC@TvV<;j%lV8LmQv30XvU#RwLhIsl}pE zKm$at4Ka%fmS{ZM_VzxxZ-Xb3`1>SL(4=o!*ygpk(`DnXxvVqk9zTYo!qR(Q0q~dF zu_54Zd`hg|s*S?Yo>KrYv{Bc?NlJpYx^umH8NxB=|MIF>>)WJSt^U|MHjv|OTj|X; z)juV3Bx-sqh0)$jsY7X)8?U*fwO^tm{BB0oYZ$IBy*V$WXNS=s!q1D7cg_`r3 zvd9@9modl{&oy^8mPfCz929E}j)-HleQI}kcSMIvtEAfrU~IvPH4Q7%4`Ik|1c&h@ z;ScPf9%_Q(4541j;l6z+9{j<){9tD#Yb2tvKa1%e*N$5(w*?&mK8oNMmMdTCm^?_Uh~b zZh7{~2s*k`r`yvicHG(4q-dNbFIQtdf6$aGypYZtZcd^gol2fT@yv1nf(3Q<;cxev zMVJ-l^xx(ao=E# zEM23ZHd4(uoryEgB9#+64TN%9xy^=QVUt|I>R(EAG*j#CiT#uDl5I@Ch~yH3j}*g` ziVF^lK9w)LD1i!zH;jR_#ln^7{Ni98-aT8&KKwhhVc`DZqtoTqx3c-ml+#vVk<*s| zr{YxnJKUjr9JQY*rr1HP@b{#eO|DQl^W#TO^vAnGU-G-*`0n{(Vu-kgEow1T_n`e; zpEem8s!oARZVapW{N_YAa8%Ov_M37ZT9-xhyeZ9kl*SM=1<`%yAqp;(z|N+iumhCT z_j>O(N`Co>(`^Ij@+KH8f#3dwfZGWN14HBvI61?O2s3&wCz%bwiFS`K+%y1aZf5Lj?*s%UZ@C;rIb{!5mE*vCPy&?-NRgtOTvEE z2O;70YS{4N|7cub*BB;K9i)H@R&0D0lWuSs=wJ2kohJ4x?UqQ-GQsIUZ$=30!; zinkcDx)e60n?@kf4Mh_@>WkCQ8uvJ7Gb` zB*UB};cOCv8j7Y#{Hrhl0t{L?GDt7bY&1URzR)D z{CTJwm!V21HXsDKq?@CD@i$OoeWGHhrLJY;KVeO3o^;6)cHRPsuttEawH8*kP6e~p zob`E3l{D%TF|;3{AQJoER9tf0AM)ry)SVEemT7J|XMyP*HwAlze&tVuu5@k2JDbS( zL3JaeZ3$|Jv2$&_E>S`*u*|hrIsSfZSFHq{FBfoz&bXzkgAZ4uBJF8etGdTWH#!$+ z;2Oyr0cq2(E^hzvlizjesJ%fbHZacquypDLlA{44*k0f-X>&{AKA{aDz zn9R%oDE0!GdxBRDt4KYD-$G#E1Q4ed zE4*HC3ThKbyu$%#qmff_s^B|2(>YR9;8*CvlhO4EpS9?+6lt`tIL@_P4!1KCl3_#f z59rJrbP%{QjfZ9nwpj7Vjym5$6_JGL?-wQQ9aK|hME_xi0aikIe&beqL+sM@Q164@ z>g%x8rUjSNhl?|5{+`&t3y%`vFUjqVBK*?HI&^d=qc)0JGFNac5jmN8!aZFq9(^(n zyK3o77m#oa?Lv-itx##21lq8z?l5(vK%-iw>!5NQk6LQw6ewx|FOUc+A;}+J_BBkt zdh8K=Kic2Yz^4Kl2I*>@?uHkhc4@mBUK?GOaS@{*JjjcMxNNJ+37c=FH%Q&uyWA4Q94U^H|LHv8)bhEAJfyQby7Jpb;}>ip%CRBeBB;Fjo-|}_1#iLznt9V7sV5ugatW%GHO6#dwE;hiQpl`S zNUKbip{Pov;3{Drm@g(_aV!!3l;bW@c(=g)bP23;*@XQqIm-9ZwD#vMGPzj=GLSAL z;nb%YSX7DNb;K0XV}A}P`0#eoenoEx_%#>n)Z4M!hrV(Q!?~%xv;M+HBOk-8%Od7|)LuoZUQY@}!n|WCc=4HCL22yz(jPtCq z3-yr8Wgq?qw`XWoOiaPjel;cwo0yp4GvXkQV6d=knkL~1CZkZ}RR}Y}+)PpL3^)gw{RrAeInkA)#yZIA2j<&i9KSQl<)Lk0#qRQ;oEt zb<=PuX)cQBAI}VDArokOCM*Ve?`Rab##~}35OWV`DIKLLI*EKDbNBF`;bkRI)=}zm zV>!o2;U@X(c40iE&cl-d^d2)hh3+3pfWEVjDvRs)GHOU&Ypm{qQ3Vb1&>h=a-7FSZ z6AqBzRzEUQSRfKnV(AxwcDr&pFj~2bp}Y!A0H2P4ciYn8I6+*>j8nP<^C0G#?>O@` z?5gOpd`&%2G%k}S5sUFiE3KjLsP(`%PB748cr5cSx>4-v0QMWr>Kw?PyMgL%jK*dL zEn#&XA&{dvdKCE_b4*H0$WZUfS>NmE_Se1^T>8a?t?c0rf8RYrhDJQk!ZhGGHJ8|f zuzZm)TMySH_S(jLv$j$JA6aIYTqB$)a`(!=|B5vQGLsThk3%e)<1py86_lxec<#s~ zqE;L;(M{%DKFkZ#n>r+b{!h-o?4K=7a0>t0u>N3>GX&ehHcSXHrM1d}fKlczJL8V7 zEPYqpvF`7oolv{#tPw|L9LBl7QBiC{b*Wf6xst3}@b|8Tzc&Cc-_}L_zJ%L@buk`B z0wV>0i?R_1<0r)`_0t=fx=wUrFapNz)8Ev&?h zcbHd7M#PB9nECejA&)EF*Cq?xixD0zb%#w-7>>VrKB)6-0>HA?3%4z`;)=f)g!caa zeuUSY`KI)_l+Wl6Z#jUQoh`g)L<&<)3dtqSOC!{}LS$*d82mbNw=iJkex+(utkE?f zC+o_Xsl}SP8$^y>!q`#p+l}UxmnH#o6Ddc54(d(8n2>$`7_nS{dd6l&!LrhuS8(hc z9kQV{L{$1d8!Q=B*?!1TtrIAr#b1Ke7x!5O8CyAD3NpuVq$3$`a=^>=MCs*m#^DCH zpl`rc!?Yz}&Wy;9;L|U}SBYve^`SCk8ml%YxAJtRQGBtAgPn^kQqw+gLQlGV{PS?C zgY=b7q^W1+A1|W74~4tFLcb|1Y}mFyBAP&41=QLawBCys264}*FXalblF%33DYEYUROH_XpUw5oWHBQ6kl3z^`D zb|EH7_9MqqP)w4ur`9v05png*->^l`G+V``%9Q6w@&+cQof{vWJwU5DL&xsKutSO zJ`mD*(yuOju#4*-${dQlgtKgE=HO9E?gr%mnkcH9aPqi$ls?4Bn6B7$?O0kmh$oyxMjOo5<_= z;6uu#@mS136e(6>%&lq*@U^gG#a3B?Bf>|cI(RnfFxpV=D?qd>-|Crb_O-shB6hwV zy4K=B`WwGA3Nhj)UWR)NW5#YWXH$P5wg_)R%#`CvOPCJT!$E8;b-ziIARy31WkTQu zpZ*=qUGFSMUi90k(zAtU-JppfE-hwSI&!Z<;>gMq$1(`WGEiGZUzELFA0D5NB>WpS z@?|kq!6-IdOHneJ?&iR42?tjww^E2Bs3IUfXK_cM6|97!Dmc)}`A7Z4wqerTfXaE~x z>q~~r7-RN=uqrO{QayKu!cN^mhm)+?uDxpS4c1Nc5(BoDg}9F6Qwh6V%2ILSG!A^G zwJ~2d971J(pvq$69mQ4|R9fd!fZ8@-|=!}PoUrJ<9mY{rGpV5H$=nGGHyDY$rZ{# zJy0}IxF|3??n7c&GkIbX`26eYQyY)A?Y4{wq=YYDzw4^dXQ9BHF#UUrD>#S||C?`H zrkt=}_Xp7BP)cgKd*=Qwq^ybU;oMCj|LjAoDsC7^M7_||e$Oq@ef(hdPN(c~b>oe` zGBo>4Am(#rY~FjWIb$ZmOs4Q8rS^8>N}09Ls!aDL3pSy+4^_|a$N=V9a#Ua)TpJE3 z2cFXoJ$=He^=5)PdS9M(i~o{2;~u)d$%Ii5n=|=6BCs{WV+dL4ow3PVC~p^qRcOS= z^`{#P&joS}+>yd-Mb#C}oXO_)&x#d3M=m{|-FW!}?m^>k7&lvivs(|C!DX6(vBzp% z;xr91=bsEFT>F$a4bppB6r0!mo+)2+`mJ`%y`>`TtoFr3*e{xqDV3Iiw&r2tzYRcZzwFr`3Bd350@nq9 zxwO4nNDu8j+&Dm;lY@t>BEfuD6qioew{V0h`NiZ`1LD&pl3|Bvtoby-5Srq^eMir8 zz*-&p2#7Gs17}$U)>TIRi-5WX)OB#%+E+FMr>?KQJkzZweY>pWb_>8_~q0y7nuQ zk-M20x+vw_qHxGxx&CdZ)YWWMpHauxt*i3|y@n^Hgpe!-`Jk#r`z0{@Zdd*L@VSz~ zdyM$`@G}$(PWO1_n^>Mz@2_`~0@`kc-(q6tq21W1VAg?}X7oob$gKg6mL!w9lrYdc zbe#uTi655xjsz1-NcGPr|NHF=A%%7&`A9*<;AN3t<78AeP*ZNOX1sC-wxa=9ufa5a z$gzCrger^d8{x7O6NiQ4AHJmrUq7BGCbpr|sUQw5hO@FMQMwBsHM_ykNOp1-4#pbK zQ!U5Ys#oqU!R}OTf_K5@_0)}&EL__Wuc3c@C*ykP-iKOB8^HrK5|;1PGVrgrgwjg6 zr{J`_H|AtEAWrb94SjLz(Lo_2jIYw+H(Onrcw>^j#^P|i#SW}*K5`NnJ=2C`$#pHU z2B-=Zh-1+tZ0OKTe2~{MjfNEZVuK+H80&#+sNV0W?$f@Rt&n#wK`YtI8*tHRm4=zm1EhwXxAih6zj-IPn}4_L z{=@{-+Wwe$Vfv50UhZS)4~+qe^i^iE%k*i%K=u)CDABcybgnOo*QLv}HsacV=Atmi zH{x)9j1q}$R(qoT%2u;3)6*GlBz zMfJ=j(*vv$`UFkcKuK@yIHn2MnXz*}Cge|JZXnG{)mlcU&$gHg;nKXRj+$%3P{9_IqSe~QdHii4d?K3)yb z*oE+W0*g@`;AF92CR=fl4&l=?zz$iU8ieO2iB6&eE`In+@qP-Exh4-L!#-rA&ty?l zf-|(;xKP{4w`1s?>`CFHLvnh4i$`enWN*DriF40^alrNIw> zE8IR9XZ5~CS(M1>yHEiogg?mdHFMue>x6z=_?nk6eiyD88i~2OW0Z5a$``{`pWwU4 z{k&||zn{B-6NTeqbZ-&rLJ9v_;nAXOGeo4u;?JX*hGLetiOP7v&`H)L_b6k3fHWD2 za*Jj{^UMQ*VL>Ls0=)>h(kulM55!r_8%$^D4M*j2ylD18YR!YxGa-wmwS~o12FL7d zI|hHqPBZCb#>>09uEm-B%CG88M)A?X*di+tpB&KN4oI%MDUXjN7fkBpC3qS0E?*2E zs@!g&u&@lo<4^W`&Uw}j*GBh02Uc4?_>`pdrtmEJH3*I7Wn+{4QlmUJ3=($n?Qh^O zAYl>@yi8y~4{jnQ93l4EW*5c<9o7SOnxk~w zdp{i4E`vN;+Sfjxu5=onSt?5CX+$E_Bdi3WFYw1Ox*&+QBcqXFnuzx%Ms_{D1G*Dm z^^GSO7?4^iDzK>jSv!T7hH9uy5U0r;l$uIm&;NwTyDSfJIs}d;zYus}Wfw@bHDOxY zBWSj>3|%XMrD|Ob&)&nF{cJ(!vRXc`vKOJ!@NPHHZ}6?)_{QmYV_7Zi<>YVqwxU*c zOz+&+Itydslp=*%99~ceOLaihG|mGj4-72XIql)l+T7XUc8zXMf?#-mCO|a z9X>}&*~n%(U(R3 zb*aQOYCo5X#?Avc?Z^O>&LgCIpys%bp&@6CzK6Tv;24e&!9kLYhW<%(2ZpASgB5-V0AwCA1~`6g3j6;O@H@{ zryjWppNC-tXzEf0OcxBLgbe8SHsGsn0&KRnztSg{q>!wuAb2?LE?W+}zR*exrP3_Wr%`&Ok6l$8p@ zZ%YQMb@h2m9%2nAnA2%G;b87>1Dg;(QpCaE8(dJvzX5hvMu?T5e^+t;wK?AvMrwe> zyX8rRigjeWMM3uHA~u-A7^+@KxzgkDZI-$bGO8O~4zBORCfmJZoDc@F{x{ue0OW8j zVuKGPa>e~9+OoE|qUr^r+>RCER!oweKv|YUhy03?EEhIG{5VKvE=%4 zYAyuPzT$ejk2byaF+rJ-g?8%+&SyE8zzA$r^4!h=MRCcEZVFovWiR~3&ztkj@#%Tw zO~6pD4{ygc1QyYU7a)|i#aU0&$le#C-I$^=!}glzo$|0>DF@!?bV%y$Vi?WDTNGCk zA7FqW56gjMJ|Wy{C6^MS9*LtxHZHO7hq%xrtE@5_wLBNco$3GFhQh6DZH1~JVAEj zj%LL>9h#vqj2lkRu|j+Q2n>ReJK$erdI^rH*pT%GDlBOGmTQFB$cjwcMyTY)EIr)!WuqMj%a6c_?qEOz}L z%hkjZEk@8?^y6eXMW`KM4R2&}B~0y25zM?$Dt*dT(JpYAG%Za$EjR2sf}K7V@9HSw zTeM4We-<(B@0Iyi3l;&@r?u~ohMX0HcAO`f|ES~zm54t2C6yv*p?I`xA{%BorBx@f$VV-e)y7sJ(^}pw1apMdgCQ;5*|5+_K5nOd?MT`R152f_#~+>6qnUX zv7&^cUy|tRLSBCbE|4cpI3MX~4D4*-!RvnZFO=0he&2x!!6C?Q7=G5p_GiV>)H5*-8*IduxcJMXK zIAq6R;L8=otW zR7}|98NTpDJ312xUnb1A53?xS6oA>X3;mhX|ce=7S5sJOCiTO_y!cXxLuxVuXQm*DOpKyY_=cL@+6xVyW%I|TP%>F#%L_v?TA z{(r_eHBQy2G3Q=$t*upi?H1iqZz$jwr#j5Oa&=pSWTvIGC zn7;%O)e6_}9Ryeo63BIh~aodlGLMh~SZ;Z&G2n3qu3x^q(fP~+EdA5_D2ZyG#N&iv?G3hmW_*W z<-Dt?EY3V#Ih_#QV!VEpD*dd!tm3-%t9CAFMeo*5G3!v$j{dBg{JHk4CU@N~?d+ik zo6A|w6CXPWqjwf=HGMDKZFXy)*ZBHz7EvyfRQ9>W4jk6#o+*ayQn`Gd+9D6aU|izD z^k%<4v>1GV@6t<;Y1fN}_m5BG@(S}!qv^%MGBQip7tAgS1%#pqg^EZds6Dr&t@L6p zaKxC{9!kD=U~tAyQQL~DZC+RQ-`i*1Szn(ob-DODq>)gmyG|1~X6&C#%g}K1l|8-E zJh>;}bCrn7X>*ZP4yn})J?xr}21UpeG)SpYC?FhF86aI4Rhh=(2aD42VgVs`zV9G7 zFCAif^w8u!Ig^$W3OZ41Y)pO*E%A9one9BLUve+8y^lBXG;h#kkAE~2Ql*Tc5MlVD zlyf0_#6;38^ps{wqn1zQV^xa->s?%z=6GnyPM$OaVgFz)Mnr7+;wdpXy9YzsaZGjgFqWnIkficN))@%7qPMX(qt*ILxxkO z%a>A5Arqq$h9D2s>`)|K3E+F)7=0|hwX~IjT4e|Az5T7M^YSd$e)>A z(82dzc#l}wKGj<@wod50RxFE;E**oX5ZDY2L=335Iibk( z>V)HV!BR(=h<70-y{26SZ-ixiU|N&DtFsx_@wV9#g=hgZ5m`SpD2Wz`kAxq=0)n=YcpeYKG7_0TaJ3AE zpm!_tHzz7zlw9yfAQ_nKt|I#-`Pje9+{}Bo&D!%WS1zlT1~s0^B+>!F#r&PiBATf^ z=B=r>pqrO5#QQtGZz@<{0}Q4Ed1IaBcX@NoNit!I1q`CjlXaKbpFxsK%Y5^~y*(zy zPDT6m30JV%LI=<$Sv^6E@$AQXPja7SM|^=hAk0F{(i(OnG;Fn3{o3paJ(1Br$81tK z-)@<`U0c1~$5(BGvcv^w*ZC9DP2WO#EK|jALeg`}ENM@5v=-yyRPHa$l)|8@d%!}S%Yi)^FS?O#y=y(E*H}1Ij>NOKES*h=%yMZ3rv2XNJa@aP(3v`5Sk{fS zI={X)8Cm-1>UqsE))aL0v5VVApUN1!RS>YfFj7ysV(PWQ|1$ez_tMsWc{aN{7uLKw zjjz&|-UD^1v@;v?p1jk#kXcFQ$25$+miisn7gxwX-p zxWudePyzaiW@~-sjL?|3Qtx?*cQ9NigaDvHWflp!jra{$K$)vDBtiQbVn5&lN#IK7 zlZ(52UsD*d3Ob^1@xg6=b}3+5v=c-8{rW}eQe*@iKv7lI-#zfHNEIzL=SlA+>bV@* z(%&($tQ6X5uT2ERC4=~3KFCRf_L;i$Q8$05>F19ZbFV5Yr;+Edu3C&947YACq4sNG zy{YS=P}Hv7lplu}vP3801C{~^;6k%g8RvD*#_)7SoH7~$X@kih4SVpVV8mIH1{FGj zI>Nb6PfgT&noq(X+{y<#!)nJ@y9e_x5AU6IZAW!(ldcNs(Vk$g@lH`xgdX7wLzQyy zrbJ=EL+qrrPGO*Dqll~cU|p3PED6^j8M9XXcsrH8PY4t_Upw6C>lXD9M&Ym! zngs`@!Rt`*@{4%-!Wy14!fWJ5c3|Hdo25z0Ba?$0bg22=3vG}}wIE+FbvMT}K|Zyf zUOVo772!$fqYG&&s0i@NWJ1Cro-AULV;ip?`Ow&AV{LvN^-Xbuc_jEExD~+T1C7{A zVkc?p^U(cTZm#tGr9+6>GWem73;$N&B2NeD1xtlLW!HtP`=zc%ejm85lB}BXz4qrk z_Hwjj}Bm38f?bGwnUvtJ3^ahHLZf-k{gmf=Ku)rX5&18M0K= zF%wRXQII|cdA$6DM$U>W8HpK7RQSbG&{c<7IfoG8cS5O>%N3qRo(t`azW(_;B@5Ay zV8F*M#2PfMOOpL>xMH zK)!Xj3WApYWHX}Oy^}={X3i0@q?Kay%b!U;F*qA|>vtu1Ni(gSJNm|IaTN$! zGdmQ>eZxO}&e-W1&vxV9N9g#&dhFPrd)Be)(&zqX#gggi$<&*j$F*z>1&hdRJ9ygX zt(0oiaZ%U$V1z4m=k+?&r*mM=h8O ztfbT0JlnXazAH;d$F~oWt~oW$jdkoVJ!Ln$4|S_9X@Zib@v&qqR2Wo_xKguPWOxEP zJfZ{gkA)pDH{g=-TCeWbn*5|X9xkkGi0k(42u68YSwiaGY@1c%a`&xx3lQ#g$Bq+A z=|_eu#xW%K%vz%I#`(#1Z8GMjq-BKk2;=AlNo>>m&=A=|m3=7?U^q%!ja#SmXR=dM z#SBeV1sr3U21tvosp#{$rHA6MN(UgzA={#!^yV>gB~AJl0KEOUQ?tRVqv^n|9b|3^ zKF%-G3_XO2-(4VrQYGsVW3)7E9p6nwK6>J$Aeix-?l0|lSd>PK|qMTxJ(%y za$GkZ^0P=tD^Xb4nguM3a2t7`XIuI7k87Bh{P%DD?dum+FmFvduPkuexs_Pv9PcFf znTM!1aBs9o({IP<9O0ATO$|l62_}mr*ihf@yw`qxe~1}%R(XjO1GrgtzxRuBHyviI zJWWH{wcO3EV) zDg}YUh6<)lP3{E2la@?>CDLI=bdgh0;);F-b!1L7gd19IMfaLmj9BomX}Q`nLcO34 z?>`>UzUb;dpHyAzcW*pdu}d{k4$<_^rG06d8jXWtcjztVaP_p#9ntN_y4M&2kMWOV zrXS8H<*c~A_De(~^GasEy6s-NyxCv&Q|LAwYw;%X#D|6z0L;Yxh!DqQ1{`jXAYvEo zBG12rlZi6?!DoJ>%bi7;)rbE=AUvtp{n1_GbHV9?v|SQ!D#d)Av&lYM-_XZ;DK&vU z_*Dhd;@zRtzPI_rbF0O4Fh$hf6e<04k+Nq-QWZhG706K@Bm`;Fy`T?diYhg-8Sdp( z4n2IMY6-1s)m9B)eMRuiF$jsVBvy{E7kJ6saRXEquFTjq)SO`Pd4WQyk!HeiY(aHQ zi&h0*Q7%Tcb8gB0@Qzr_q;ttPbVjnI!#l~3Bn`}c4%hxH3`OiWA2??E=j_Liz1$Tt z+`!egkjlZbRxryq81rt{?4Q28+%IolKK4hn=o)`wqUaZg?ynaRCE^8jwO$~2e!;?< z2}){68@-(q|Lj=xq=0x7WT&`OQ!9vQVZWv$eQSuLuM^*h%*}Rox>#T}!1|&u&|&W4Tk=U0p98 z!$yf~pK6oeX2@0-aqYYa+k3el#1z&Nw*A-KM!wC*;&STAF-EQlsO~XmooSN4f3HQJ zA8$Uzre#XVGZ!-P(HOW=tcqh9!wcs4jlG5gDgx14lxpUC2(p;F^eij!V_7o%F4i<= zxjsugW|ALwL67V;CH*73Q2{>z@q2y|*AyZuMgnKJ65o-H;z#26H^h>4Fj&Gbl4-+P zHRk%cspbHwLF3{#3VVj>^p=AN4U(T^AcX)>vDn^Y*@B^-uulHH z_NfJQM0wvL%|jtxKw&3qooVe$_wVA(o+`y`iUpD~H!>Xr!1`7JC;Q>Z+*3ju-kTPE zLs#1!TgT98GGcDLR97O;$o@S6H253q-Ador?jI)eO)^icT3UuqecDa}O7#3c0kWnx z?Ow6rRl?T0TNI;&_XFeh?w#JuKJA-~w?SnL6Gk!Q@tq2Z-8s$AQpWdo(Z)Wge1LUz zQqmS2Z|*4ZiOzrFevEWL#G86gFm+|ZQXI$q;_@);Wci2(jlx?^zU7?$zF$gAW6|(o z{TK;v0^9o>Dpjy7OD`kyfe|piX1y{3iX8%y>_+m4$ejp&$aX?>ML@!qTMma9&!n<@qwWP z6t+yvaF$(X{L^`mM2^x+ZEL2hPP;icdmB^)*rcIuhPfBHE=$>ChA=UL>?!T6YlLTL z4E%1aBIT^HcKCz~^((#b7iG%TbG$`@!eRyA6U3S!L5VmO_n)Z#I9*v`)e)=g4O_WA zqpFj=(g|U#MOgh=*RRKOk41N)Kk*j zOLIOPKYdp#c(7((t(0`(4nOAUpuFhs92}eUI<|W|o%}w3j)``QEOnaqvK;9piK~7U z3R_~`U(=OG#O!T`w3K)0HvDMh2nw)9YTYGic)+ip)|t1H+U|vuCdwl+G#w0Kbe!bQ zPz!^t^KDbuzpLiw9H9wY-WqeF(qVNDi0N!j6!}ORjD)s4EUQTVfY{FLcwUgk)5_9p zcMK+C0m4bP!_#TV-4U1OA`aNKe$DeGc!t$`QMoo28*7LxFUJ>UP%Ou&FY1i0fvgE- zrnuhc7Pw!oSASCO46Rx2Dz~4FRo4T^xZgt!T5ZaN>zD)fvIW_bz8}#k%JzQUeH5(h z1`iQlM|MjZ?Qf)yTn`_`w6V3TwXY8*^|ZKtWGTDbPT$c-3d?u6${Mkf-VhV#3?mX9 zeuZ}eeRNDhZKG5TW4Vp)Q3VAXVL|5EUK&uapV}b8t#*8vH7f$CNc@iZSr;NF3?k9% z{=@afv$>StnGjtlvMyab^#7fkRK$>OtPe|E@YZFzFp5LK$T za6HxAqT|urTe1ubav{lBpPZr6y4i0DZC-JO^2}4DVXx3&tXU-bCss30@^!#Jcg3X< znxi(LJ&9a9BV*VUp7w(G_eN`XTQ=_zb)?JBA>W4{OWNo&kGbaQjmt(01pq$&2%f+q z^b?K}N^fl)-`26T%UeH4x+5CH&yyMK2oz*onk0rq2}2H4?up-RL+vJPB58NqF2v6I z87j?@kBSK(G?Yl3lrYfZqcIR95cWt-4qLgDOcTk4utU^RbqR4SgxZOD#NQLHGGp|# z83GsYxAQIJg91!%;`m+(b;cg1Rx1x5)Qm=;g~oD#b_zSMs=yNWSW#nU8aPA1FrYC; z*ExLb(ohmb$Kfd5;^LQ$4cDEZqFEV*n>**OgnP#*cC;5QYrw$`lB}8OSlQ~Upd>=4 z(SukPe!C?Tf=)h&x1Q<}W-m0T9iaH7J(V)_3=!(CY}(ng()nGv(NmL;)3;NeObrm- z`+Ci(gQTubXEc9y;z03n2L|Udh;6*lcWC?~#9G-P(7vi>Yiwa9b=Ra2B~g7nRBS3= zLeRP=reo&>2kX*@)ML&DL!h@Z*ATFe_$!cV;9Wt$^m~x$KsL-M*6QvkjTq z;*_pAT}EK^ePb>*%Td<~umN3bk}`8S#gKOxjvcySh%>vwf1@Ou^yy)XTdo*B!Ae? zDQln*W@^gC$0dzpLiJn;BEb`-yZZ4(8} z%A)0fL5w?UT*L8UXon{Vsc0)u@+i(^+Yb+qqdWB`0c62dB*WLwU?iOPk>De}9nL%* z?P%(vfL_CDhr-g}bCO~yS?39w0aAxEFQl~ex&@^*EH&DfoZU2V%Um7qFGZgg#wMo6 zZ0~b>KrKnRL?VT~$v8x1T0U)rEeq|~KO4k$Wn z>Z~DTY-q)ypv|O&iDb^Eld&CMfukgMZ>5WO+@YV&Frj%29HK}YRk3eS_(;;>A2PAE zXkS8h16<4wOTKJ(f{~y>6M!w?hq}wT`d<1{_C&!xvAFW%#SGBKr%F3{{1EEoP@`vY zNA2Z=JrnaqhdkzBiC`Xv6wEI8AUxtf`Q9&d%(YbSD;d8^=NkKG?&)>p==w#8LBPOD zDcH_ZXTRCQpo5g9Eo0R5x7{vOu#`oNiLX%CY75*aRS6NLcb?w+L=E4(cAQ2SOtOZ4 zxNK!Dm{z*-gqsvJCsEj;o%zq;2O@b(ig>;q9{|%oxuL;4Mcr_I&eF4Kb9?I45LFx{ zH}Ioc-g<(l-q_~iy2i6^aTm23s|UHOkUuwpUQi`3av2l#Kq;`BGgPl@NYdM!U;f01 zj!`G5fDYVWvk9^hIa2?vrt-|M16yeX)TMw7Kn39k5(zK}Atzu5En-|xmJYG!)<3UX z;8{fZN(8Y~M=s7#5wd<08;C_Ik{xZPIIf+QArGZVgnRgYHegu;%3a)QEu5XD*;AQ@ z1N*^y8H4cY5#fWPo9NGMm8NA$^5oqVR*Ub8?GkzW<|H&KHg3tRYmh&wo8&85gMsPs ziH?;52{NtyA%N+<o-)?pa*CM)R z*^m-1xLNZaFPt?#a^bPdNk~m-ly>Exe4{en4*!lH_G7uc7WfMradK$xZJN4D`i6g= z({qM{Tt;kwr#sj~E|GOOU&B7dh^AUH&XpDFgGYsDKP(fjN=2@N|6GsFY9CjAg7B%- zgl`R#t;SCN4jOV(s^%m5lI;cA)vU+!EM?vGu)nV1R_fb7AWOVrPJuoYV zT6A_g@Bpukt7S2 zmXco!;Gh6B7&yo@bi!?vhq3+AK_gsWS1w^Zt&9iF%Z*B*LYMYNF#|-UdTck!Az52; zA<{JD3V)^%6$6xL@aNacO2lm5BfNz{$x`)J^&n>AFcU+)+BwYYe|cVc@t7(*B^)Dm zt(NbL?zj-fxtq|kDnxS$t-)A59B7J!d7cuEvXHF~&@fU|BTBq6`Fu_Abshr7Z-7^4 z|0!J=m2{4+CPLJdZ?4i|&xZwBhixFiXY!rU1jq8s0s2;q^6LhgmnBHRI;iOl#fE%} z`^4JvjBPvypyff+YzEdWY8wj$g_8VhqmMdc?y_o=2WCMQSkvU^_lTNz>_)~NX!;T4 zHn2ADjTc+sHc;rous)qp$|Y0ggMf2kNTW)i^M~@@YhBgUnO8m4WlSGG9Slq9xv+U2 zp6~>>>~+t6?Q1PF&}+c2B~2vl#CK@obBm++x{j##;B?Jn+EAneJTGQEC`lpCBKmC! zyfNQ;(%YiDi#~x* z`x(Y$hluWzrYnl@4fn!VXqYUb3H0bUyWOZ~#nKJ1Co~MC~Z(dMX=SGdwY|v`YD>VX-E|eY+-Ua27`ACxHS~&D0rGuA7H}Nl@05m@=O36%pVnu4@H&z8hHhq zpOdMmiuFVXf@*58)PQ|71~EMWX_df3RnL<`Vcca*_k_YF`0UR4oTo5jTem~6nfFsg z>$t5;Brs1hI$`psAzDsZI3ybz-<}_9+bP{)1l$Olw*J5JI@j1H}#K4xs0 zDK5kgqFFtWX7OPNW2>Y;hYr>u`A}?__E(7@piQZ97~w6Xlyp zs)Q_eAA_($LBG--_(P>%Xi9*;=jI65%BYc1MR8nLT#_ z8MEAddJbgVbZ0l5JCETSkEb;%GXf=fDYn{}h^QP@S=dc+{(EzJb4hr6i^KS&?NHoXqgS|3IYAf@5{>uRe)EQ7VkW} z>=EQfmjVE^Qjz&pCpo{S9_~5nC1fb+){rkhX9y3Jg~!tn8gIRdg|*WzD{tOb={!T~*~%aN3*1IJ!C?$S$a{S~@7`T*3)BVE3qCyl=oVMM^09LqF1qhq z8&V;2-_ZmSVTR#a?Cx~bt_FZGs6XgTA2d_$>(1q!o)15}b#|XGWqRqzPHqLS|J#_q zESggF+KoTBkw|tA0S$oJRVO%pfk=NB!Aluwa$H!k#{&)3z9KQ8^D}3M_#*6Vni)mJ zUUHv}=e<>Pn7d5 z?gJ4@wtCi#EY{DK5`uyn%o4*ZVrvPM#Y&Svr7)VhdI;2rv@}U8bvm9plCIia#PP_9 zu_GIs37bR&_7oU`yDBAhtFf7|#yI+JB4|c?l?1z#Gcsg1EcN(WNF*O8ZU3dfD)xhG zDhWb`!;gv4#Wn9&Pq9DTMgz9SJC_0wG&tBFy({Y-iGo5|rzUVnE~|aui`7eS*b%&D z8|K*LLexLhO8qzxcJqf-*D&9TvVfQTE~Otb8v%_X+(;Z^?7+L{gBM}QBKU@j%M}_S zSD|fgBW5pgNbFe`nVrcrh9FAf-%bl?)R)}G%6V6ig=NMeZx+4CqbtO4uV5jyCRidn z{a!V2h{wqQwa|tBX=dE-kXoXFAzBPq>L8T9hqzgR;aneW7RU5mHem$Sh=0eJ-i5yY zE;b}PN9yQOmpFJ5^^2u=zcS!jF_jCAPwIFur<@am15Mj)GH?aB!H^JcE2C0`HEl45 zZ61Roo?>&y0e3Qo4iZ#@q?3fc7zS-`LGlO}4mU(HM=1=!zrW^3jA{dPaJ_K2(enzU z7158KQ4umAAso`W?=oH=k45Z*t#qXJr{%dF4wjv^SmwJOA?J)3rGF@ zX!1Zqzg|7ZChO9Y5m7f_)#0Jx7sL&aQgFl*#L^wWKhQ*FAI8fz*inR@U}A#OBPH zNrZ=Idr9m9+ww3`a)F=lMSFX?#tahoNR@0JGbqR9Po3>uUnECa^UNzY&cgKFfb{7~ z>PUpo1_oFZ9{M_sV+(T&N}5k{WewBv2&&?HG74V}#`oW)erY<;Tz+>!o7SvwWF15?6ahDkS2tMl9oHPwn5)J>tbKFiIP?lTEnDB}(xF(-InS^AsPGKoTA9-p z_QdU6qoE8-gJCLOy;KYFxX83>ywBb(#fnEH&G3b#Wy&6)gsY8>(`jaFL82A@ZEkZ| zSnjj1!2zeA@S;L6BWhRK}aOQznkexq#>_2R_r z<~DF0n%Pk7Jk-^aE;TKRDi^cR6X4QY5@X9!SlNwM26?S&*eYr*@5oopk6hoa2LjdMrLj-I%eQ(i%k?Ug55jwM?>Cu92o z$o4(me;xqh9J1~Q1>nh4W$59k=v46K0@4lePnsEJo=0O67BSS2JRh!-TRKA!!$X?ldodO*(%g{CDmd zTj1f!GAZAKdm%wU-Vi}RNdD% ze+-#O3A*Nax4kw!gjYU!FUrVp7ODwNW|%)}Ll`a7eV$h@rFW7lJhWIn;23~dWDk&@ z)*y5OEX`#_(+F4jI%lc^V&^OR&-G%wRLdnTKjBVFDg+SJh|gZ@3yWpcTAuR5ZyQ^B zR#{wq@(iwMt?NBsQZh(G45C#@`vx#xto?NDRkk{J5JdN+h^^ptoj#`>ux9R^xqJQW z9)9w0<=BMGS|6m<{8$_&Sex)AA9JT!nwOt){RvTscxN^e4FX0n+_MM_@T1<2pV108 zy}~k41vF<<;7xxiqDa4lMJV@lM`yAvjM@NBK=&=pw3N!JA_fB=c^Pi$B>g7fbOQ{Y zP22rP7QCWS0iM;T@`0*pzUoE7k;0+3joNP_7&6v_w>igtWYxzSb=0CMlFcX4H6XVH4xtMfe0etbK27DD?Lj z!h^eYW_lQ^VPqboOC`>tyq-+ufbZbNPA_+EhMDDq zyw$DQB#)Q}rsfjbIiPY}Z+YHd+!oNyoNTz>vs!&PK>HjKjW|i2$N-}4e|8vnMGYPE zgJ5RP^ACPchd!3pav3|5XCCtsS!{%&Lg3f>V*M@vcup zFf{f<#d8^=mQu;ZG$j_76h2A%EUbuHHpk4B%aBgRX8oSm4lHIsU&6UHMH!`KUv}O! zpvaYdUQp1!Xm+T{#fJq|2UH+~go3=@>+8(^w=ly55DvFqAwcR`y)B@=hmX17BO(>^ z+KIYf1x`+$d;LcSjUf#!Y(|}R<+g&VPpcx_0s?9}5^`^o7#!=<8{A%IgqjJ|$_m&& zJ7?IbFPL({nP+a!_?}FKlFS6y)C?n0ZuVtiXp+`$CD+Vbu8M};Zyh@AWq;WG6uz|( zTDRPYJ?(tOOl~!fs4EfTufiPQZeWtVmIDX5jHd2MV;Sr*6kxHl=lISFb=OmSa#hqW z;QdJWDn=3?*B*RuRitpp*YvsF_3pKO#n(rD`la5iX&x1K%Cw&%l-l7ON|A8kQ1PS{ zAJNs;lq=&$2N=|&_1*qtZOnG030(W=t#aLJhY8QjO1u9t`0horqA$GngxD+#*+B*3 z&+0TqxcHDuXmT35 zCYn7=nJCh2NfQ_68v};WI6k`(mUPdeP_|tE$M+`^#BqM0Ok9XT)x#xzQvEXhf;WOj zI}oTLAPe#Q74$nBV3kR6sLCz;+!<*Y&`JEGqM0}iQXo*QQ~TB!c9~Zi zzD%FqKPC}8GpyO&-4S~-Ex% zWkA6Qz<)=EvivJD6bRNI9LON2Lcbp6)T9+e6o7ybAmG;5>HoW@{T&Pq_(f5gB|MeHzA7FL{4hGgHP9_eH3>J>IHosvXlK&(2iUk4yPjVyA z4u}#BywU!G{r%tAKwJZ311AFpcLQsy-;jy^xztCX2mtMEBic+L20pN;@Bf1A0Q}^S zQh#zVurvF2frEJeLxF!+HoD-i%EJFeSpe9-U>%%o9DkQL`=5Oko%2^j?7tx9{2Niu z*}~SymR`l&+S$s$$=ufFcX&e8zm1dr?7d&`+}NNPn?M~vfM8UA(c$`^;Qw#_{4Z>X zz%d`+pcF?l5ceGv2nf-i*iOH4zWbLve>cY3z}$wx(d;+h4sZMiC;T3fVc9^**6MBw zfL?3|GLim?CI71|koOPY{+&hC*2vPt!PMN!34-*pmy9qvcHNa z5AzR1b`G|7CJs*KCXW9O*(a5MWcwAeABR|p>w#=IKsJiMnB@!%!2f90->b)ejN{)W zQ~^rpGJ$jatI`er&9X4Kf8a8*vUN5#bT+p#{#K-)qf7+FxV*f5HL;4 zf0$ag_m8wqLVi-%JHcY-eTiKc+_8{|Cc?Jv}>jBLgEd6Ft4(LrL+U#r?%tjlS`$%>n`<>I=mG7vrx!FY^DB z@$X?}WasW=W@|&w%FGPZ!05La`!7ZMdn(u8`*dJz0E=X6{NF|Rm#63jb%$TZMStUf04_fK S8nR%3paENJV;~X;$o~P%%^Vs4 literal 0 HcmV?d00001 diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/Dockerfile b/examples/example-projects/MUJOCO/Mujoco-Simulation/Dockerfile new file mode 100644 index 0000000..35c3b10 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/Dockerfile @@ -0,0 +1,32 @@ +# MuJoCo Simulation Container - With OpenGL support +FROM python:3.9 + +# Install system dependencies for OpenGL and MuJoCo +RUN apt-get update && apt-get install -y \ + libosmesa6-dev \ + libgl1-mesa-dev \ + libglfw3 \ + xvfb \ + && rm -rf /var/lib/apt/lists/* + +# Set working directory +WORKDIR /app + +# Install MuJoCo Python package and dependencies +RUN pip install --no-cache-dir \ + mujoco \ + numpy \ + imageio \ + imageio-ffmpeg \ + matplotlib \ + seaborn + +# Set environment variables for MuJoCo +ENV MUJOCO_GL=osmesa +ENV PYTHONPATH=/app/source + +# Make sure main.sh will be executable when mounted +RUN mkdir -p /app/node + +# Entry point - execute main.sh script + CMD ["/bin/bash"] diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/README.md b/examples/example-projects/MUJOCO/Mujoco-Simulation/README.md new file mode 100644 index 0000000..789cc05 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/README.md @@ -0,0 +1,123 @@ +# MuJoCo Pinata Simulation + +Enhanced implementation of the "Tendons, actuators and sensors" example from the MuJoCo tutorial with professional visualization and Docker compatibility. + +## Overview + +This simulation features: +- **Pinata**: A compound object (box + sphere) suspended by a tendon +- **Bat**: Motor-controlled bat that swings to hit the pinata +- **Sensors**: IMU (accelerometer + gyroscope) to measure pinata motion +- **Enhanced Visualization**: High-quality video output and publication-ready plots + +## Features + +### Simulation Components +- Spatial tendon with realistic physics +- Motor actuator with sinusoidal control +- Multi-body pinata with realistic dynamics +- Comprehensive sensor suite (IMU, joint sensors, tendon length) + +### Outputs +- **MP4 Video**: High-quality 1280x720 @ 60fps with contact visualization +- **Analysis Plots**: Multi-panel scientific plots with: + - Accelerometer time series (3-axis) + - Position tracking and phase plots + - Energy analysis (kinetic/potential) + - Frequency spectrum analysis + - Bat motion and wire length correlation +- **Data Export**: Both NPZ (binary) and CSV formats for easy analysis +- **Comprehensive Logging**: Simulation parameters and statistics + +### Enhanced Visualization +- Contact points and force vectors +- Tendon visualization +- Professional matplotlib styling with Seaborn +- Multiple camera views +- Anti-aliased rendering + +## Running the Simulation + +### Docker (Recommended) +```bash +docker run -v $(pwd):/app mujoco-simulation:latest +``` + +The simulation will automatically: +1. Create output directories (`source/outputs/`) +2. Run the pinata simulation +3. Generate all visualization and data files +4. Print a summary of created files + +### Expected Outputs +``` +source/outputs/ +ā”œā”€ā”€ videos/ +ā”‚ ā””ā”€ā”€ pinata_simulation_[timestamp].mp4 +ā”œā”€ā”€ plots/ +ā”‚ ā””ā”€ā”€ comprehensive_analysis_[timestamp].png +ā”œā”€ā”€ data/ +ā”‚ ā”œā”€ā”€ simulation_data_[timestamp].npz +ā”‚ ā””ā”€ā”€ sensor_data_[timestamp].csv +ā””ā”€ā”€ logs/ + ā””ā”€ā”€ simulation_log_[timestamp].txt +``` + +## Technical Details + +### Model Specifications +- **Physics**: RK4 integrator with 2ms timestep +- **Rendering**: OpenGL with anti-aliasing and shadows +- **Contact**: Realistic contact dynamics with visualization +- **Materials**: Custom textures and lighting + +### Data Collection +- Full 6-DOF IMU data (acceleration + angular velocity) +- Pinata position and velocity tracking +- Bat joint angles and velocities +- Tendon length measurements +- Energy calculations + +### Analysis Features +- Time-domain analysis of all sensor channels +- Frequency-domain analysis (FFT) of acceleration +- Phase space plots for trajectory analysis +- Energy conservation tracking +- Statistical summaries + +## Dependencies + +All dependencies are pre-installed in the Docker container: +- `mujoco` - Physics simulation +- `numpy` - Numerical computing +- `matplotlib` - Plotting +- `seaborn` - Enhanced plot styling +- `imageio` - Video generation +- `imageio-ffmpeg` - MP4 encoding + +## Files + +- `pinata_simulation.py` - Main simulation script +- `test_pinata.py` - Environment validation script +- `main.sh` - Docker entry point +- `Dockerfile` - Container specification + +## Customization + +Key parameters can be modified in the `PinataSimulation` class: +- `duration` - Simulation time (default: 3.0s) +- `framerate` - Video framerate (default: 60 fps) +- `video_width/height` - Resolution (default: 1280x720) +- Control strategy in `control_strategy()` method + +## Scientific Applications + +This simulation demonstrates: +- Multi-body dynamics with constraints +- Sensor fusion and data analysis +- Contact mechanics visualization +- Control system implementation +- Real-time physics simulation +- Scientific data visualization + +Perfect for education, research, and demonstration of advanced physics simulation capabilities. diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/cloudbuild.yaml b/examples/example-projects/MUJOCO/Mujoco-Simulation/cloudbuild.yaml new file mode 100644 index 0000000..e9795f4 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/cloudbuild.yaml @@ -0,0 +1,14 @@ +steps: + - name: 'gcr.io/cloud-builders/docker' + args: + - 'build' + - '-t' + - 'northamerica-northeast1-docker.pkg.dev/fluidize/fluidize-docker/mujoco-example:latest' + - '.' + - name: 'gcr.io/cloud-builders/docker' + args: + - 'push' + - 'northamerica-northeast1-docker.pkg.dev/fluidize/fluidize-docker/mujoco-example:latest' + +images: + - 'northamerica-northeast1-docker.pkg.dev/fluidize/fluidize-docker/mujoco-example:latest' diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/main.sh b/examples/example-projects/MUJOCO/Mujoco-Simulation/main.sh new file mode 100755 index 0000000..d64ff60 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/main.sh @@ -0,0 +1,58 @@ +#!/bin/bash + +# MuJoCo Simulation Main Execution Script +# This script is executed by the fluidize framework inside the Docker container + +set -e # Exit on any error + +echo "Starting MuJoCo Simulation Setup..." + +# Python dependencies are already installed in the Docker image +echo "Python dependencies pre-installed in Docker image" + +echo "Environment Variables:" +echo " FLUIDIZE_NODE_PATH: ${FLUIDIZE_NODE_PATH:-not set}" +echo " FLUIDIZE_SIMULATION_PATH: ${FLUIDIZE_SIMULATION_PATH:-not set}" +echo " FLUIDIZE_OUTPUT_PATH: ${FLUIDIZE_OUTPUT_PATH:-not set}" +echo " FLUIDIZE_INPUT_PATH: ${FLUIDIZE_INPUT_PATH:-not set}" + +# Set default paths if environment variables are not set +NODE_PATH="${FLUIDIZE_NODE_PATH:-/app}" +SIMULATION_PATH="${FLUIDIZE_SIMULATION_PATH:-/app/source}" +OUTPUT_PATH="${FLUIDIZE_OUTPUT_PATH:-/app/source/outputs}" +INPUT_PATH="${FLUIDIZE_INPUT_PATH:-}" + +echo "Using paths:" +echo " Node path: $NODE_PATH" +echo " Simulation path: $SIMULATION_PATH" +echo " Output path: $OUTPUT_PATH" +echo " Input path: $INPUT_PATH" + +# Ensure output directory exists +mkdir -p "$OUTPUT_PATH" + +# Change to simulation directory +cd "$SIMULATION_PATH" + +# Set MuJoCo environment variables for headless rendering +export MUJOCO_GL=osmesa +export PYTHONPATH="$SIMULATION_PATH:$PYTHONPATH" + +# Export paths for the Python script +export SIMULATION_OUTPUT_PATH="$OUTPUT_PATH" +export SIMULATION_INPUT_PATH="$INPUT_PATH" + +# Run the MuJoCo simulation +echo "Executing pinata simulation..." +python pinata_simulation.py + +# Check if simulation was successful +if [ $? -eq 0 ]; then + echo "MuJoCo simulation completed successfully!" + echo "Output files generated in: $OUTPUT_PATH" + ls -la "$OUTPUT_PATH" + exit 0 # Explicitly exit with success code +else + echo "MuJoCo simulation failed!" + exit 1 +fi diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/metadata.yaml b/examples/example-projects/MUJOCO/Mujoco-Simulation/metadata.yaml new file mode 100644 index 0000000..e9bfaa3 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/metadata.yaml @@ -0,0 +1,12 @@ +simulation: + authors: [] + code_url: null + date: '2025-08-13' + description: A demo simulation of a humanoid in MuJoCo + id: mujoco-humanoid-demo + metadata_version: '1.0' + mlflow_run_id: null + name: MuJoCo Humanoid Locomotion Demo + paper_url: null + tags: [] + version: '0.1' diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json b/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json new file mode 100644 index 0000000..7940dbc --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json @@ -0,0 +1,20 @@ +{ + "parameters": [ + { + "value": "20.0", + "description": "Control signal strength for bat motor (higher = faster swing, more collision force)", + "type": "text", + "label": "Motor Strength", + "name": "motor_strength", + "latex": null, + "location": [ + "source/pinata_simulation.py", + "source/pinata_simulation.py", + "source/pinata_simulation.py", + "source/pinata_simulation.py" + ], + "options": null, + "scope": "simulation" + } + ] +} diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/properties.yaml b/examples/example-projects/MUJOCO/Mujoco-Simulation/properties.yaml new file mode 100644 index 0000000..35b7ee5 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/properties.yaml @@ -0,0 +1,10 @@ +simulation: + container_image: northamerica-northeast1-docker.pkg.dev/fluidize/fluidize-docker/mujoco-example + last_run: null + node_id: Mujoco-Simulation + properties_version: '1.0' + run_status: NOT_RUN + should_run: true + simulation_mount_path: source + source_output_folder: source/outputs + version: '1.0' diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/source/debug_tutorial.py b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/debug_tutorial.py new file mode 100644 index 0000000..3c152cd --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/debug_tutorial.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python +"""Debug script to test the exact tutorial MJCF""" + +import os + +import mujoco + +# Set environment for headless rendering +os.environ["MUJOCO_GL"] = "osmesa" + +# EXACT tutorial MJCF from your message +MJCF = """ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +""" + + +def main(): + print("šŸ§Ŗ Testing exact tutorial MJCF...") + + try: + model = mujoco.MjModel.from_xml_string(MJCF) + data = mujoco.MjData(model) + + print("āœ… Model created successfully") + print(f"šŸ“Š Bodies: {model.nbody}, Geoms: {model.ngeom}") + print(f"šŸ”— Tendons: {model.ntendon}") + + # Reset and step forward to see initial state + mujoco.mj_resetData(model, data) + mujoco.mj_forward(model, data) + + print(f"Initial pinata position: {data.body('box_and_sphere').xpos}") + print(f"Initial wire length: {data.tendon('wire').length[0]:.3f}m") + + # Step simulation a few times to see if pinata falls + data.ctrl = 20 # Set motor control + + for i in range(100): + mujoco.mj_step(model, data) + if i % 20 == 0: + pos = data.body("box_and_sphere").xpos + wire_len = data.tendon("wire").length[0] + print(f"Step {i:3d}: pinata z={pos[2]:.3f}, wire_len={wire_len:.3f}") + + final_pos = data.body("box_and_sphere").xpos + print(f"\nFinal pinata position: {final_pos}") + + if final_pos[2] < -0.4: + print("āŒ PINATA FELL TO GROUND!") + else: + print("āœ… Pinata stayed suspended") + + return 0 + + except Exception as e: + print(f"āŒ Error: {e}") + return 1 + + +if __name__ == "__main__": + exit(main()) diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/source/pinata_simulation.py b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/pinata_simulation.py new file mode 100644 index 0000000..fcb7c07 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/pinata_simulation.py @@ -0,0 +1,488 @@ +#!/usr/bin/env python +""" +MuJoCo Pinata Simulation with Tendons, Actuators, and Sensors +Enhanced version with professional visualization and Docker compatibility +""" + +import os +import sys +from datetime import datetime + +# Set matplotlib backend for headless operation +import matplotlib +import numpy as np + +matplotlib.use("Agg") # Must be set before importing pyplot +import matplotlib.pyplot as plt +import seaborn as sns +from matplotlib.gridspec import GridSpec + +try: + import imageio + import mujoco + + print(f"āœ… MuJoCo version: {mujoco.__version__}") + print("āœ… ImageIO available for video generation") +except ImportError as e: + print(f"āŒ Import error: {e}") + sys.exit(1) + +# Set professional plot style +plt.style.use("seaborn-v0_8" if "seaborn-v0_8" in plt.style.available else "default") +sns.set_palette("husl") + + +class PinataSimulation: + """ + Enhanced MuJoCo Pinata simulation with professional visualization + """ + + def __init__(self, output_path=None): + """Initialize the simulation with output path configuration""" + self.output_path = output_path or os.environ.get("SIMULATION_OUTPUT_PATH", "outputs") + self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + + # Create output directories + self.video_dir = os.path.join(self.output_path, "videos") + self.plot_dir = os.path.join(self.output_path, "plots") + self.data_dir = os.path.join(self.output_path, "data") + self.log_dir = os.path.join(self.output_path, "logs") + + for directory in [self.video_dir, self.plot_dir, self.data_dir, self.log_dir]: + os.makedirs(directory, exist_ok=True) + + # Simulation parameters + self.duration = 3.0 # seconds + self.framerate = 60 # Hz + self.video_width = 1280 + self.video_height = 720 + + # Data storage + self.times = [] + self.sensor_data = [] + self.positions = [] + self.velocities = [] + self.bat_angles = [] + self.tendon_lengths = [] + + print("šŸŽÆ Pinata Simulation initialized") + print(f"šŸ“ Output path: {self.output_path}") + print(f"šŸ•’ Timestamp: {self.timestamp}") + + def create_mjcf_model(self): + """Create the MJCF XML model for the pinata simulation""" + mjcf_xml = """ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + """ + return mjcf_xml + + def setup_simulation(self): + """Initialize the MuJoCo model and data structures""" + print("šŸ”§ Setting up simulation...") + + # Create model from XML + mjcf_xml = self.create_mjcf_model() + self.model = mujoco.MjModel.from_xml_string(mjcf_xml) + self.data = mujoco.MjData(self.model) + + # Setup visualization options - clean view without force arrows + self.vis_options = mujoco.MjvOption() + self.vis_options.flags[mujoco.mjtVisFlag.mjVIS_TENDON] = True # Keep tendon visible + + print(f"šŸ“Š Model loaded: {self.model.ngeom} geoms, {self.model.nbody} bodies") + print(f"šŸŽ›ļø Actuators: {self.model.nu}, Sensors: {self.model.nsensor}") + + def control_strategy(self, time): + """Define control strategy for the bat motor - parameterized for tuning""" + # Constant actuator signal - parameterized for tuning + return {{motor_strength}} + + def collect_data(self): + """Collect sensor and state data during simulation""" + self.times.append(self.data.time) + + # Sensor data - simplified to match tutorial + accel_data = self.data.sensor("accelerometer").data.copy() + + # Get bat joint position and velocity directly + bat_pos = self.data.joint("swing").qpos[0] if hasattr(self.data.joint("swing"), "qpos") else 0.0 + bat_vel = self.data.joint("swing").qvel[0] if hasattr(self.data.joint("swing"), "qvel") else 0.0 + + # Calculate wire length from tendon + wire_len = self.data.tendon("wire").length[0] if hasattr(self.data.tendon("wire"), "length") else 0.0 + + sensor_reading = { + "accel": accel_data, + "gyro": np.zeros(3), # No gyro in simplified version + "bat_pos": bat_pos, + "bat_vel": bat_vel, + "wire_length": wire_len, + } + self.sensor_data.append(sensor_reading) + + # Kinematic data + pinata_pos = self.data.body("box_and_sphere").xpos.copy() + pinata_vel = self.data.body("box_and_sphere").cvel.copy() + + self.positions.append(pinata_pos) + self.velocities.append(pinata_vel) + self.bat_angles.append(bat_pos) + self.tendon_lengths.append(wire_len) + + def run_simulation(self): + """Execute the main simulation loop""" + print("šŸš€ Starting simulation...") + + # Reset and initialize - exactly like tutorial + mujoco.mj_resetData(self.model, self.data) + + frames = [] + n_frames = int(self.duration * self.framerate) + + with mujoco.Renderer(self.model, self.video_height, self.video_width) as renderer: + step_count = 0 + last_frame_time = 0 + + while self.data.time < self.duration: + # Control signal + control_signal = self.control_strategy(self.data.time) + self.data.ctrl[0] = control_signal + + # Step simulation + mujoco.mj_step(self.model, self.data) + step_count += 1 + + # Collect data every timestep + self.collect_data() + + # Render frame + if len(frames) < self.data.time * self.framerate: + mujoco.mj_forward(self.model, self.data) + renderer.update_scene(self.data, camera="fixed", scene_option=self.vis_options) + pixels = renderer.render() + frames.append(pixels) + last_frame_time = self.data.time + + # Progress indicator + if step_count % 1000 == 0: + progress = (self.data.time / self.duration) * 100 + print(f"ā³ Progress: {progress:.1f}% (t={self.data.time:.2f}s)") + + print(f"āœ… Simulation completed: {len(frames)} frames, {step_count} steps") + return frames + + def create_video(self, frames): + """Generate MP4 video from simulation frames""" + print("šŸŽ¬ Creating video...") + + video_filename = f"pinata_simulation_{self.timestamp}.mp4" + video_path = os.path.join(self.video_dir, video_filename) + + # Write video with high quality settings + imageio.mimsave( + video_path, + frames, + fps=self.framerate, + codec="libx264", + quality=8, + macro_block_size=1, + ffmpeg_params=["-preset", "slow", "-crf", "18"], + ) + + print(f"šŸ“¹ Video saved: {video_path}") + return video_path + + def create_plots(self): + """Generate comprehensive analysis plots""" + print("šŸ“Š Creating analysis plots...") + + # Convert data to numpy arrays + times = np.array(self.times) + positions = np.array(self.positions) + velocities = np.array(self.velocities) + + # Extract sensor data + accel_x = [s["accel"][0] for s in self.sensor_data] + accel_y = [s["accel"][1] for s in self.sensor_data] + accel_z = [s["accel"][2] for s in self.sensor_data] + bat_angles = [s["bat_pos"] for s in self.sensor_data] + wire_lengths = [s["wire_length"] for s in self.sensor_data] + + # Create comprehensive plot + fig = plt.figure(figsize=(16, 12), dpi=150) + gs = GridSpec(4, 2, figure=fig, hspace=0.3, wspace=0.25) + + # Accelerometer data + ax1 = fig.add_subplot(gs[0, :]) + ax1.plot(times, accel_x, "r-", label="X-axis", linewidth=2, alpha=0.8) + ax1.plot(times, accel_y, "g-", label="Y-axis", linewidth=2, alpha=0.8) + ax1.plot(times, accel_z, "b-", label="Z-axis", linewidth=2, alpha=0.8) + ax1.set_title("IMU Accelerometer Data", fontsize=14, fontweight="bold") + ax1.set_ylabel("Acceleration (m/sĀ²)", fontsize=12) + ax1.legend(loc="upper right") + ax1.grid(True, alpha=0.3) + + # Position tracking + ax2 = fig.add_subplot(gs[1, 0]) + ax2.plot(times, positions[:, 0], "r-", label="X", linewidth=2) + ax2.plot(times, positions[:, 1], "g-", label="Y", linewidth=2) + ax2.plot(times, positions[:, 2], "b-", label="Z", linewidth=2) + ax2.set_title("Pinata Position", fontsize=14, fontweight="bold") + ax2.set_ylabel("Position (m)", fontsize=12) + ax2.legend() + ax2.grid(True, alpha=0.3) + + # Bat angle and wire length + ax3 = fig.add_subplot(gs[1, 1]) + ax3_twin = ax3.twinx() + line1 = ax3.plot(times, bat_angles, "purple", linewidth=2, label="Bat Angle") + line2 = ax3_twin.plot(times, wire_lengths, "orange", linewidth=2, label="Wire Length") + ax3.set_title("Bat Motion & Wire Length", fontsize=14, fontweight="bold") + ax3.set_ylabel("Bat Angle (rad)", fontsize=12, color="purple") + ax3_twin.set_ylabel("Wire Length (m)", fontsize=12, color="orange") + ax3.grid(True, alpha=0.3) + + # Phase plot (X-Y position) + ax4 = fig.add_subplot(gs[2, 0]) + scatter = ax4.scatter(positions[:, 0], positions[:, 1], c=times, cmap="viridis", s=10, alpha=0.7) + ax4.set_title("Position Phase Plot (X-Y)", fontsize=14, fontweight="bold") + ax4.set_xlabel("X Position (m)", fontsize=12) + ax4.set_ylabel("Y Position (m)", fontsize=12) + ax4.grid(True, alpha=0.3) + cbar = plt.colorbar(scatter, ax=ax4) + cbar.set_label("Time (s)", fontsize=10) + + # Energy analysis + ax5 = fig.add_subplot(gs[2, 1]) + # Calculate kinetic energy (approximate) + kinetic_energy = 0.5 * 0.7 * np.sum(velocities[:, :3] ** 2, axis=1) # mass * vĀ² + potential_energy = 0.7 * 9.81 * positions[:, 2] # m * g * h + total_energy = kinetic_energy + potential_energy + + ax5.plot(times, kinetic_energy, "r-", label="Kinetic", linewidth=2) + ax5.plot(times, potential_energy, "b-", label="Potential", linewidth=2) + ax5.plot(times, total_energy, "k--", label="Total", linewidth=2) + ax5.set_title("Energy Analysis", fontsize=14, fontweight="bold") + ax5.set_ylabel("Energy (J)", fontsize=12) + ax5.legend() + ax5.grid(True, alpha=0.3) + + # Spectral analysis of acceleration + ax6 = fig.add_subplot(gs[3, :]) + accel_magnitude = np.sqrt(np.array(accel_x) ** 2 + np.array(accel_y) ** 2 + np.array(accel_z) ** 2) + + # Compute FFT + dt = times[1] - times[0] + freqs = np.fft.fftfreq(len(accel_magnitude), dt)[: len(accel_magnitude) // 2] + fft_magnitude = np.abs(np.fft.fft(accel_magnitude))[: len(accel_magnitude) // 2] + + ax6.plot(freqs, fft_magnitude, "navy", linewidth=2) + ax6.set_title("Acceleration Frequency Spectrum", fontsize=14, fontweight="bold") + ax6.set_xlabel("Frequency (Hz)", fontsize=12) + ax6.set_ylabel("Magnitude", fontsize=12) + ax6.set_xlim(0, 10) # Focus on low frequencies + ax6.grid(True, alpha=0.3) + + plt.suptitle(f"Pinata Simulation Analysis - {self.timestamp}", fontsize=16, fontweight="bold", y=0.98) + + # Save plot + plot_filename = f"comprehensive_analysis_{self.timestamp}.png" + plot_path = os.path.join(self.plot_dir, plot_filename) + plt.savefig(plot_path, dpi=300, bbox_inches="tight", facecolor="white", edgecolor="none") + plt.close() + + print(f"šŸ“ˆ Plot saved: {plot_path}") + return plot_path + + def save_data(self): + """Save simulation data to files""" + print("šŸ’¾ Saving data...") + + # Prepare data dictionary + data_dict = { + "times": np.array(self.times), + "positions": np.array(self.positions), + "velocities": np.array(self.velocities), + "accelerometer": np.array([s["accel"] for s in self.sensor_data]), + "gyroscope": np.array([s["gyro"] for s in self.sensor_data]), + "bat_angles": np.array([s["bat_pos"] for s in self.sensor_data]), + "wire_lengths": np.array([s["wire_length"] for s in self.sensor_data]), + "simulation_params": { + "duration": self.duration, + "timestep": self.model.opt.timestep, + "framerate": self.framerate, + }, + } + + # Save as NPZ + npz_filename = f"simulation_data_{self.timestamp}.npz" + npz_path = os.path.join(self.data_dir, npz_filename) + np.savez_compressed(npz_path, **data_dict) + + # Save as CSV for easy access + csv_data = { + "time": self.times, + "pos_x": [p[0] for p in self.positions], + "pos_y": [p[1] for p in self.positions], + "pos_z": [p[2] for p in self.positions], + "accel_x": [s["accel"][0] for s in self.sensor_data], + "accel_y": [s["accel"][1] for s in self.sensor_data], + "accel_z": [s["accel"][2] for s in self.sensor_data], + "bat_angle": [s["bat_pos"] for s in self.sensor_data], + "wire_length": [s["wire_length"] for s in self.sensor_data], + } + + import csv + + csv_filename = f"sensor_data_{self.timestamp}.csv" + csv_path = os.path.join(self.data_dir, csv_filename) + + with open(csv_path, "w", newline="") as csvfile: + writer = csv.DictWriter(csvfile, fieldnames=csv_data.keys()) + writer.writeheader() + for i in range(len(self.times)): + row = {key: values[i] for key, values in csv_data.items()} + writer.writerow(row) + + print(f"šŸ’¾ Data saved: {npz_path}") + print(f"šŸ“Š CSV saved: {csv_path}") + return npz_path, csv_path + + def generate_summary_log(self, video_path, plot_path, data_paths): + """Generate a summary log of the simulation""" + log_filename = f"simulation_log_{self.timestamp}.txt" + log_path = os.path.join(self.log_dir, log_filename) + + with open(log_path, "w") as f: + f.write("MuJoCo Pinata Simulation Log\n") + f.write(f"{'=' * 50}\n") + f.write(f"Timestamp: {self.timestamp}\n") + f.write(f"Duration: {self.duration:.2f} seconds\n") + f.write(f"Total data points: {len(self.times)}\n") + f.write(f"Average timestep: {np.mean(np.diff(self.times)):.4f} seconds\n") + f.write(f"Video file: {video_path}\n") + f.write(f"Plot file: {plot_path}\n") + f.write(f"Data files: {', '.join(data_paths)}\n") + f.write("\nSimulation Statistics:\n") + f.write(f"Max acceleration: {np.max([np.linalg.norm(s['accel']) for s in self.sensor_data]):.2f} m/sĀ²\n") + f.write(f"Max bat angle: {np.max(self.bat_angles):.3f} rad\n") + f.write(f"Wire length range: {np.min(self.tendon_lengths):.3f} - {np.max(self.tendon_lengths):.3f} m\n") + + print(f"šŸ“‹ Log saved: {log_path}") + return log_path + + +def main(): + """Main execution function""" + print("šŸŽ­ Starting MuJoCo Pinata Simulation") + print("=" * 50) + + # Check environment + print(f"šŸ Python: {sys.version}") + print(f"šŸ”§ MuJoCo GL: {os.environ.get('MUJOCO_GL', 'not set')}") + print(f"šŸ“ Output path: {os.environ.get('SIMULATION_OUTPUT_PATH', 'default')}") + + try: + # Initialize simulation + sim = PinataSimulation() + + # Setup + sim.setup_simulation() + + # Run simulation + frames = sim.run_simulation() + + # Generate outputs + video_path = sim.create_video(frames) + plot_path = sim.create_plots() + data_paths = sim.save_data() + log_path = sim.generate_summary_log(video_path, plot_path, data_paths) + + # Final summary + print("\nšŸŽ‰ Simulation completed successfully!") + print("šŸ“‚ Generated files:") + print(f" šŸ“¹ Video: {video_path}") + print(f" šŸ“Š Plots: {plot_path}") + print(f" šŸ’¾ Data: {', '.join(data_paths)}") + print(f" šŸ“‹ Log: {log_path}") + + return 0 + + except Exception as e: + print(f"āŒ Simulation failed: {e}") + import traceback + + traceback.print_exc() + return 1 + + +if __name__ == "__main__": + exit_code = main() + sys.exit(exit_code) diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_pinata.py b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_pinata.py new file mode 100644 index 0000000..edc6b0d --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_pinata.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python +""" +Quick test script for the pinata simulation setup +""" + +import os +import sys + + +def test_imports(): + """Test if all required packages can be imported""" + try: + import numpy as np + + print(f"āœ… NumPy {np.__version__}") + except ImportError as e: + print(f"āŒ NumPy import failed: {e}") + return False + + try: + import matplotlib + + matplotlib.use("Agg") # Set headless backend + import matplotlib.pyplot as plt + + print(f"āœ… Matplotlib {matplotlib.__version__}") + except ImportError as e: + print(f"āŒ Matplotlib import failed: {e}") + return False + + try: + import seaborn as sns + + print(f"āœ… Seaborn {sns.__version__}") + except ImportError as e: + print(f"āŒ Seaborn import failed: {e}") + return False + + try: + import imageio + + print(f"āœ… ImageIO {imageio.__version__}") + except ImportError as e: + print(f"āŒ ImageIO import failed: {e}") + return False + + try: + import mujoco + + print(f"āœ… MuJoCo {mujoco.__version__}") + except ImportError as e: + print(f"āŒ MuJoCo import failed: {e}") + return False + + return True + + +def test_environment(): + """Test environment setup""" + print("\nšŸ” Environment Check:") + print(f"Python version: {sys.version}") + print(f"MUJOCO_GL: {os.environ.get('MUJOCO_GL', 'not set')}") + print(f"Output path: {os.environ.get('SIMULATION_OUTPUT_PATH', 'not set')}") + + # Test output directory creation + output_path = os.environ.get("SIMULATION_OUTPUT_PATH", "test_outputs") + os.makedirs(output_path, exist_ok=True) + + test_file = os.path.join(output_path, "test.txt") + with open(test_file, "w") as f: + f.write("Test file created successfully") + + if os.path.exists(test_file): + print(f"āœ… Output directory writable: {output_path}") + os.remove(test_file) + return True + else: + print(f"āŒ Cannot write to output directory: {output_path}") + return False + + +def test_mujoco_basic(): + """Test basic MuJoCo functionality""" + try: + import mujoco + + # Test basic model creation + simple_xml = """ + + + + + + + + + + """ + + model = mujoco.MjModel.from_xml_string(simple_xml) + data = mujoco.MjData(model) + + # Test forward kinematics + mujoco.mj_forward(model, data) + + print("āœ… MuJoCo basic functionality working") + return True + + except Exception as e: + print(f"āŒ MuJoCo test failed: {e}") + return False + + +def main(): + print("šŸ§Ŗ Testing Pinata Simulation Environment") + print("=" * 50) + + success = True + + # Test imports + print("\nšŸ“¦ Testing imports...") + if not test_imports(): + success = False + + # Test environment + print("\nšŸŒ Testing environment...") + if not test_environment(): + success = False + + # Test MuJoCo + print("\nšŸŽÆ Testing MuJoCo...") + if not test_mujoco_basic(): + success = False + + print("\n" + "=" * 50) + if success: + print("šŸŽ‰ All tests passed! Ready for pinata simulation.") + return 0 + else: + print("āŒ Some tests failed. Check the environment.") + return 1 + + +if __name__ == "__main__": + exit_code = main() + sys.exit(exit_code) diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_simple.py b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_simple.py new file mode 100644 index 0000000..0544c14 --- /dev/null +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/source/test_simple.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python +"""Simple test script to verify container execution.""" + +import os +import sys + +print("=== SIMPLE TEST SCRIPT ===") +print(f"Python version: {sys.version}") +print(f"Current working directory: {os.getcwd()}") +print("Environment variables:") +for key, value in os.environ.items(): + if key.startswith("FLUIDIZE") or key.startswith("SIMULATION"): + print(f" {key}: {value}") + +# Test if we can import mujoco +try: + import mujoco + + print(f"āœ… MuJoCo imported successfully: version {mujoco.__version__}") +except Exception as e: + print(f"āŒ Failed to import MuJoCo: {e}") + +# Create a simple output file +output_path = os.environ.get("SIMULATION_OUTPUT_PATH", "outputs") +os.makedirs(output_path, exist_ok=True) +test_file = os.path.join(output_path, "test_output.txt") +with open(test_file, "w") as f: + f.write("Test completed successfully!\n") +print(f"āœ… Created test file: {test_file}") + +print("=== TEST COMPLETED ===") diff --git a/examples/example-projects/MUJOCO/graph.json b/examples/example-projects/MUJOCO/graph.json new file mode 100644 index 0000000..086e934 --- /dev/null +++ b/examples/example-projects/MUJOCO/graph.json @@ -0,0 +1,17 @@ +{ + "nodes": [ + { + "id": "Mujoco-Simulation", + "position": { + "x": 150.0, + "y": 100.0 + }, + "data": { + "label": "MuJoCo Humanoid Simulation", + "simulation_id": null + }, + "type": "physics-simulation" + } + ], + "edges": [] +} diff --git a/examples/example-projects/MUJOCO/metadata.yaml b/examples/example-projects/MUJOCO/metadata.yaml new file mode 100644 index 0000000..8cb4d08 --- /dev/null +++ b/examples/example-projects/MUJOCO/metadata.yaml @@ -0,0 +1,7 @@ +project: + description: A MuJoCo simulation project + id: MUJOCO + label: MUJOCO DEMO + location: '' + metadata_version: '1.0' + status: active diff --git a/examples/example-projects/MUJOCO/parameters.json b/examples/example-projects/MUJOCO/parameters.json new file mode 100644 index 0000000..c1cc0bc --- /dev/null +++ b/examples/example-projects/MUJOCO/parameters.json @@ -0,0 +1,4 @@ +{ + "metadata": {}, + "parameters": {} +} diff --git a/fluidize/core/modules/execute/docker_client.py b/fluidize/core/modules/execute/docker_client.py index 1f37572..40ef135 100644 --- a/fluidize/core/modules/execute/docker_client.py +++ b/fluidize/core/modules/execute/docker_client.py @@ -110,6 +110,9 @@ def run_container(self, container_spec: ContainerSpec, volumes: list[Volume], ** ContainerResult with execution details """ try: + # Pull image if not available locally (Docker will select appropriate architecture) + self.pull_image(container_spec.image) + # Convert volumes to Docker SDK format docker_volumes = self._convert_volumes(volumes, container_spec.volume_mounts) @@ -127,11 +130,15 @@ def run_container(self, container_spec: ContainerSpec, volumes: list[Volume], ** **kwargs, } + # Let Docker automatically select the appropriate platform for the host architecture + # Multi-arch manifest will choose the right image (ARM64 for Apple Silicon, AMD64 for Intel) + # Add security context if provided if container_spec.security_context: self._apply_security_context(run_kwargs, container_spec.security_context) logger.info(f"Running container: {container_spec.name}") + logger.info(f"Using platform: {run_kwargs.get('platform', 'default')}") logger.debug(f"Container run args: {run_kwargs}") # Run container diff --git a/pyproject.toml b/pyproject.toml index ddf5fb2..469d144 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -76,8 +76,8 @@ line-length = 120 fix = true exclude = [ "tests/fixtures/", - "utils/fluidize_demo.ipynb", - "utils/demo.ipynb", + "utils", + "examples", ] [tool.ruff.lint] @@ -136,4 +136,4 @@ branch = true source = ["fluidize"] [tool.deptry] -extend_exclude = ["utils"] +extend_exclude = ["utils", "examples"] diff --git a/utils/demo.ipynb b/utils/demo.ipynb deleted file mode 100644 index c512c27..0000000 --- a/utils/demo.ipynb +++ /dev/null @@ -1,312 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Fluidize-Python Interactive Demo\n", - "\n", - "This notebook demonstrates the fluidize-python library for managing scientific computing projects.\n", - "\n", - "## Setup\n", - "\n", - "First, let's import the client and see where our projects will be stored:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Import the fluidize client - handlers auto-register!\n", - "from fluidize.client import FluidizeClient\n", - "\n", - "# Create client and config\n", - "client = FluidizeClient(mode=\"local\")\n", - "\n", - "print(f\"\ud83d\udcc1 Projects will be stored in: {client.config.local_projects_path}\")\n", - "print(f\"\ud83d\udcc1 Base directory: {client.config.local_base_path}\")\n", - "print(f\"\ud83d\ude80 Client ready in '{client.mode}' mode!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now load a project. This contains everything we need to run a simulation pipeline!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Get our MUJOCO project for node creation\n", - "project = client.projects.get(\"MUJOCO\")\n", - "\n", - "print(f\"\ud83c\udfaf Working with project: {project.label}\")\n", - "print(f\"\ud83d\udcca Current graph state: {len(project.graph.get().nodes)} nodes, {len(project.graph.get().edges)} edges\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now list the parameters that we can tune for this simulation. Here to make it simple, we just have one, which will see in a bit!" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example Run" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now run the simulation. The payload here is for you to describe what this run was. All the things like parameters and your source code is automatically tracked for each run. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "from fluidize.core.types.runs import RunFlowPayload\n", - "\n", - "# Just providing information about what the run is \n", - "payload = RunFlowPayload(\n", - " name=\"simulation-run-1\", description=\"Running with Velocity 20\", tags=[\"simulation\", \"analysis\"]\n", - ")\n", - "\n", - "\n", - "result = project.runs.run_flow(payload)\n", - "run_number = result['run_number']" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Looking at Results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# List all output files from the latest run\n", - "node_id = \"Mujoco-Simulation\"\n", - "\n", - "# Get list of output files\n", - "output_files = project.runs.list_node_outputs(run_number, node_id)\n", - "print(f\"\ud83d\udcc2 Output files from run {run_number}:\")\n", - "for file in output_files:\n", - " print(f\" - {file}\")\n", - "\n", - "# Get the output path\n", - "output_path = project.runs.get_output_path(run_number, node_id)\n", - "print(f\"\\n\ud83d\udcc1 Output directory: {output_path}\")\n", - "print(f\"Directory exists: {output_path.exists()}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Create a reusable visualization function\n", - "from IPython.display import Image, Video, display\n", - "\n", - "def visualize_run_results(project, run_number, node_id):\n", - " \"\"\"Display all output files from a run\"\"\"\n", - " print(f\"\ud83d\udcca Results from Run {run_number} - Node: {node_id}\")\n", - " \n", - " # Get list of output files\n", - " output_files = project.runs.list_node_outputs(run_number, node_id)\n", - " print(f\"\ud83d\udcc2 Output files:\")\n", - " for file in output_files:\n", - " print(f\" - {file}\")\n", - "\n", - " # Get the output path\n", - " output_path = project.runs.get_output_path(run_number, node_id)\n", - " print(f\"\\n\ud83d\udcc1 Output directory: {output_path}\")\n", - " print(f\"Directory exists: {output_path.exists()}\")\n", - " \n", - " if not output_files:\n", - " print(\"\u274c No output files found!\")\n", - " return\n", - " \n", - " # Look for images and videos\n", - " image_files = [f for f in output_files if f.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.svg'))]\n", - " video_files = [f for f in output_files if f.lower().endswith(('.mp4', '.avi', '.mov', '.webm'))]\n", - "\n", - " print(\"\\n\ud83d\uddbc\ufe0f Displaying images:\")\n", - " for img_file in image_files:\n", - " img_path = output_path / img_file\n", - " if img_path.exists():\n", - " print(f\"\ud83d\udcf7 {img_file}:\")\n", - " display(Image(str(img_path), width=800, height=600))\n", - " else:\n", - " print(f\"\u274c {img_file} not found\")\n", - "\n", - " print(\"\\n\ud83c\udfa5 Displaying videos:\")\n", - " for vid_file in video_files:\n", - " vid_path = output_path / vid_file\n", - " if vid_path.exists():\n", - " print(f\"\ud83c\udfac {vid_file}:\")\n", - " print(f\" File size: {vid_path.stat().st_size / 1024 / 1024:.2f} MB\")\n", - " display(Video(str(vid_path.absolute()), width=600, height=400, embed=True))\n", - " else:\n", - " print(f\"\u274c {vid_file} not found\")\n", - "\n", - " if not image_files and not video_files:\n", - " print(\"\ud83d\udcdd No image or video files found. Available files:\")\n", - " for file in output_files:\n", - " file_path = output_path / file\n", - " if file_path.exists():\n", - " print(f\" \ud83d\udcc4 {file} ({file_path.stat().st_size} bytes)\")\n", - "\n", - "# Test the function with the previous run\n", - "visualize_run_results(project, run_number, \"Mujoco-Simulation\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Parameter Experiment - Change Motor Strength and Compare Results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Step 1: Change the motor strength parameter from 20.0 to 35.0\n", - "from fluidize.core.types.parameters import Parameter\n", - "\n", - "print(\"\ud83d\udd27 Updating motor strength parameter from 20.0 to 35.0...\")\n", - "\n", - "# Create updated parameter\n", - "new_motor_strength = Parameter(\n", - " name=\"motor_strength\",\n", - " value=\"35.0\", # Increased from 20.0 to 35.0\n", - " type=\"text\",\n", - " label=\"Motor Strength\", \n", - " description=\"Control signal strength for bat motor (higher = faster swing, more collision force)\",\n", - " scope=\"simulation\",\n", - " location=[\"source/pinata_simulation.py\"]\n", - ")\n", - "\n", - "# Update the parameter\n", - "project.graph.upsert_parameter(\"Mujoco-Simulation\", new_motor_strength)\n", - "\n", - "# Show the updated parameters\n", - "print(\"\\n\u2705 Parameters updated!\")\n", - "print(project.graph.show_parameters(\"Mujoco-Simulation\"))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Step 2: Run a new simulation with the updated parameters\n", - "from fluidize.core.types.runs import RunFlowPayload\n", - "\n", - "print(\"\ud83d\ude80 Starting new simulation with motor strength = 35.0...\")\n", - "\n", - "payload = RunFlowPayload(\n", - " name=\"high-motor-experiment\", \n", - " description=\"Testing increased motor strength (35.0 vs 20.0)\", \n", - " tags=[\"experiment\", \"parameter-study\", \"high-power\"]\n", - ")\n", - "\n", - "result = project.runs.run_flow(payload)\n", - "new_run_number = result['run_number']\n", - "\n", - "print(f\"\u2705 Simulation started! Run number: {new_run_number}\")\n", - "print(f\"Status: {result['flow_status']}\")\n", - "print(\"\\n\u23f3 Wait a moment for simulation to complete, then run the next cell...\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Step 3: Visualize the new results using our reusable function\n", - "print(\"\ud83d\udcca Results from the HIGH motor strength simulation (35.0):\")\n", - "print(\"=\"*60)\n", - "\n", - "# Use the new_run_number from the previous cell\n", - "visualize_run_results(project, new_run_number, \"Mujoco-Simulation\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Step 4: Compare with the previous results (motor strength = 20.0)\n", - "print(\"\ud83d\udcca COMPARISON - Results from the NORMAL motor strength simulation (20.0):\")\n", - "print(\"=\"*60)\n", - "\n", - "# Show the previous run results for comparison\n", - "visualize_run_results(project, 11, \"Mujoco-Simulation\") # Run 11 was with motor_strength=20.0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "fluidize-python", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/utils/fluidize_demo.ipynb b/utils/interactive-testing.ipynb similarity index 99% rename from utils/fluidize_demo.ipynb rename to utils/interactive-testing.ipynb index 7547dff..51c23f1 100644 --- a/utils/fluidize_demo.ipynb +++ b/utils/interactive-testing.ipynb @@ -145,7 +145,7 @@ "import datetime\n", "\n", "from fluidize.core.types.graph import GraphNode, Position, graphNodeData\n", - "from fluidize.core.types.node import author, nodeMetadata_simulation, nodeProperties_simulation, tag\n", + "from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation\n", "\n", "print(\"\ud83d\udce6 Imported all node creation types successfully!\")" ] @@ -263,7 +263,7 @@ " description=\"A demo simulation of a humanoid in MuJoCo\",\n", " date=datetime.date.today(),\n", " authors=[],\n", - " tags=[]\n", + " tags=[],\n", ")\n", "\n", "print(\"\u2705 Created nodeProperties:\")\n", @@ -311,7 +311,7 @@ "print(f\" Node ID: {created_node.id}\")\n", "print(f\" Label: {created_node.data.label}\")\n", "print(f\" Type: {created_node.type}\")\n", - "print(f\" Simulation ID: {created_node.data.simulation_id}\")\n" + "print(f\" Simulation ID: {created_node.data.simulation_id}\")" ] }, { From 8524873e4f2571b34f46af8715276478deb2e505 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 21:02:58 -0700 Subject: [PATCH 07/17] UPDATE README --- README.md | 2 +- README_DRAFT.md | 186 --------------------------------------- README_OLD.md | 74 ---------------- run_mujoco_simulation.py | 63 ------------- 4 files changed, 1 insertion(+), 324 deletions(-) delete mode 100644 README_DRAFT.md delete mode 100644 README_OLD.md delete mode 100644 run_mujoco_simulation.py diff --git a/README.md b/README.md index 53e9d95..9c2b8b8 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ ### An Open Framework for AI-Driven Scientific Computing - **fluidize-python ** is a library for building modular, reproducible scientific computing pipelines. It provides a unified interface to a wide range of physical simulation tools, eliminating the need to navigate the inconsistent, incomplete instructions that often vary from tool to tool. + **fluidize-python** is a library for building modular, reproducible scientific computing pipelines. It provides a unified interface to a wide range of physical simulation tools, eliminating the need to navigate the inconsistent, incomplete instructions that often vary from tool to tool. This library marks our first step toward AI-orchestrated scientific computing. By standardizing tools and practices within our framework, AI agents can automatically build, configure, and execute computational pipelines across domains and simulation platforms. Our goal is to improve todayā€™s simulation tools so AI can assist researchers and scientists in accelerating the pace of innovation and scientific discovery. diff --git a/README_DRAFT.md b/README_DRAFT.md deleted file mode 100644 index 28a8766..0000000 --- a/README_DRAFT.md +++ /dev/null @@ -1,186 +0,0 @@ -# Fluidize - -[![Python](https://img.shields.io/badge/python-3.9%2B-blue?style=for-the-badge&logo=python&logoColor=white)](https://python.org) -[![PyPI](https://img.shields.io/pypi/v/fluidize?style=for-the-badge&logo=pypi&logoColor=white)](https://pypi.org/project/fluidize/) -[![License](https://img.shields.io/github/license/Fluidize-Inc/fluidize-python?style=for-the-badge)](LICENSE) -[![Documentation](https://img.shields.io/badge/docs-available-brightgreen?style=for-the-badge&logo=gitbook&logoColor=white)](https://Fluidize-Inc.github.io/fluidize-python/) - - -**Open Foundation for AI-Driven Scientific Computing** - -Fluidize library provides the foundational types and abstractions for building and executing AI-orchestrated scientific computing pipelines. This allows agents to automatically orchestrate, configure, and iterate through computational pipeline with minimal prompting. - -Fluidize is a Python library that establishes a standard for AI-orchestrated scientific computing. With this common framework, agents can automatically build, configure, and run computational pipelines across different domains and platforms. - - -**The Problem** - -Students and researchers face significant barriers while translating their ideas into production ready pipelines: - -- -- Time spent on software engineering instead of research - - - -**Solution** - -We devised a wrapper - - -Here are the building blocks. - - -Nodes: These are the foundational building blocks for Fluidize. It comes with the minimal set of information to run the simulation with no required modification for the source code itself. It is modular and easily easily extensible. - -- Consistent and predictable input and output path for all simulations -- An arbitrary complicated scientific computing software to be be run with a single API endpoint. - - - - Here are the information specified on the nodes (More Could be put in documentation?) - -- Properties.yaml - This tells the container image link, the working directory for the simulation running in the container, and where the output path is. - -- Metadata.yaml - This provides more context on what the node is, including description, version, authors, and the repository URL it came from. - -- Dockerfile - This provides the setup instructions for simulation runs - -- Parameters.json - This is where you put your parameters you would like to tune during your experiments. - -- main.sh - This is the script that executes your source code. - -- source/ - This is where the source code is. - -The good news is that we can automate the generation of these nodes. - -Projects: Projects are a way of orchestrating nodes. - -- graph.json - Graph specifiying how nodes are connected. It allows orchestration of generated nodes. -- metadata.yaml - This provides more context on what the project does. - -More information on each of these files can be found in the documentation. - - - - - - - - - - - - ---- - -## Getting Started - -### Requirements - -- Python 3.9+ -- Docker Desktop (for local execution) - Download and install Docker Desktop (version 20.10+) from https://docs.docker.com/desktop/. - After installation, verify with: - ```bash - docker --version - ``` - Ensure the Docker daemon is running before using Fluidize. - -### Install from PyPI - -```bash -pip install fluidize -``` - -### Development Installation - -```bash -git clone https://github.com/Fluidize-Inc/fluidize-python.git -cd fluidize-python -make install -``` - ---- - -### Basic Usage - -```python -from fluidize import FluidizeClient - -client = FluidizeClient() - -# Create a new project -project = client.projects.create(name="My Project") - -# Load a project -loaded_project = client.projects.get(project_id=project.id) - -# Run Project -loaded_project.run.run_flow() - -``` - ---- - - -## šŸ“š Documentation - -- **[API Documentation](https://Fluidize-Inc.github.io/fluidize-python/)** - Complete API reference -- **[Interactive Demo](utils/fluidize_demo.ipynb)** - Jupyter notebook walkthrough -- **[Examples](examples/)** - Examples - ---- - -## šŸ¤ Contributing - -We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details. - -### Quick Contributing Steps - -1. Fork the repository -2. Create a feature branch: `git checkout -b feature/amazing-feature` -3. Run quality checks: `make check` -4. Commit changes: `git commit -m 'Add amazing feature'` -5. Push to branch: `git push origin feature/amazing-feature` -6. Open a Pull Request - - -We are looking to collaborate with researchers who are interested in ... - ---- - -## Roadmap - -- - - ---- - -## šŸ“„ License - -This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. - ---- - -## Contact - -Henry Bae - henry@fluidize.ai - - - ---- - -What should the documentation contain: - -- Overview of Fluidize Project - - -- Overview of Fluidize Node -- Overview of Fluidize Workflow - ---- - -

- Built with ā¤ļø by the Fluidize team
- -

diff --git a/README_OLD.md b/README_OLD.md deleted file mode 100644 index 8df86d9..0000000 --- a/README_OLD.md +++ /dev/null @@ -1,74 +0,0 @@ -# fluidize-python - -[![Release](https://img.shields.io/github/v/release/Fluidize-Inc/fluidize-python)](https://img.shields.io/github/v/release/Fluidize-Inc/fluidize-python) -[![Build status](https://img.shields.io/github/actions/workflow/status/Fluidize-Inc/fluidize-python/main.yml?branch=main)](https://github.com/Fluidize-Inc/fluidize-python/actions/workflows/main.yml?query=branch%3Amain) -[![codecov](https://codecov.io/gh/Fluidize-Inc/fluidize-python/branch/main/graph/badge.svg)](https://codecov.io/gh/Fluidize-Inc/fluidize-python) -[![Commit activity](https://img.shields.io/github/commit-activity/m/Fluidize-Inc/fluidize-python)](https://img.shields.io/github/commit-activity/m/Fluidize-Inc/fluidize-python) -[![License](https://img.shields.io/github/license/Fluidize-Inc/fluidize-python)](https://img.shields.io/github/license/Fluidize-Inc/fluidize-python) - -Python package for automatic generation of scientific computing software pipelines. - -- **Github repository**: -- **Documentation** - -## Getting started with your project - -### 1. Create a New Repository - -First, create a repository on GitHub with the same name as this project, and then run the following commands: - -```bash -git init -b main -git add . -git commit -m "init commit" -git remote add origin git@github.com:Fluidize-Inc/fluidize-python.git -git push -u origin main -``` - -### 2. Set Up Your Development Environment - -Then, install the environment and the pre-commit hooks with - -```bash -make install -``` - -This will also generate your `uv.lock` file - -### 3. Run the pre-commit hooks - -Initially, the CI/CD pipeline might be failing due to formatting issues. To resolve those run: - -```bash -uv run pre-commit run -a -``` - -### 4. Commit the changes - -Lastly, commit the changes made by the two steps above to your repository. - -```bash -git add . -git commit -m 'Fix formatting issues' -git push origin main -``` - -You are now ready to start development on your project! -The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release. - -To finalize the set-up for publishing to PyPI, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/publishing/#set-up-for-pypi). -For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/mkdocs/#enabling-the-documentation-on-github). -To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/codecov/). - -## Releasing a new version - -- Create an API Token on [PyPI](https://pypi.org/). -- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/Fluidize-Inc/fluidize-python/settings/secrets/actions/new). -- Create a [new release](https://github.com/Fluidize-Inc/fluidize-python/releases/new) on Github. -- Create a new tag in the form `*.*.*`. - -For more details, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/cicd/#how-to-trigger-a-release). - ---- - -Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv). diff --git a/run_mujoco_simulation.py b/run_mujoco_simulation.py deleted file mode 100644 index ef69f00..0000000 --- a/run_mujoco_simulation.py +++ /dev/null @@ -1,63 +0,0 @@ -""" -Script to run the MuJoCo simulation using FluidizeClient. - -This script demonstrates how to use the fluidize client to execute -the cartpole parameter tuning simulation. -""" - -from fluidize import FluidizeClient -from fluidize.core.types.runs import RunFlowPayload - - -def main(): - """Run the MuJoCo cartpole simulation.""" - print("šŸš€ Starting MuJoCo Simulation via Fluidize Client") - print("=" * 60) - - try: - # Initialize client in local mode - print("šŸ“¦ Initializing FluidizeClient in local mode...") - client = FluidizeClient(mode="local") - print(f"āœ… Client initialized: {client}") - - # Get the MUJOCO project - print("\nšŸ“ Getting MUJOCO project...") - project = client.projects.get("MUJOCO") - print(f"āœ… Project found: {project}") - - # Create run payload - payload = RunFlowPayload( - name="MuJoCo Cartpole Parameter Tuning Demo", - description="Cartpole balancing simulation testing different control gain parameters to demonstrate parameter tuning effects", - tags=["mujoco", "cartpole", "parameter-tuning", "control-systems", "demo"], - ) - print(f"\nšŸŽÆ Payload created: {payload.name}") - - # Run the flow - print("\nšŸƒ Starting simulation flow...") - result = project.runs.run_flow(payload) - print(f"āœ… Flow execution result: {result}") - - print("\n" + "=" * 60) - print("šŸŽ‰ MuJoCo simulation flow started successfully!") - print(f"šŸ“Š Flow Status: {result.get('flow_status', 'Unknown')}") - print(f"šŸ”¢ Run Number: {result.get('run_number', 'Unknown')}") - print("\nšŸ’” The simulation will:") - print(" ā€¢ Test 4 different control gain values (5.0, 10.0, 20.0, 50.0)") - print(" ā€¢ Generate MP4 videos showing cartpole behavior for each gain") - print(" ā€¢ Create comparison plots showing performance vs parameters") - print(" ā€¢ Save structured results to JSON") - print("\nšŸ“ Check the output directory for results:") - print(f" {project._project_summary.location}/Mujoco-Simulation/source/outputs/") - - except Exception as e: - print(f"āŒ Error running simulation: {e}") - print("\nšŸ” Troubleshooting tips:") - print(" ā€¢ Ensure Docker is running and accessible") - print(" ā€¢ Check that the MUJOCO project exists in ~/.fluidize/projects/") - print(" ā€¢ Verify the project structure is correct") - raise - - -if __name__ == "__main__": - main() From ef7f2f8fdfac5203b6c1c12da86154825d03dd5d Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 21:22:46 -0700 Subject: [PATCH 08/17] Update README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9c2b8b8..67d9d71 100644 --- a/README.md +++ b/README.md @@ -41,7 +41,7 @@ make install ## Run Examples -Example projects are located in this folder: [example/](example/) +Example projects are located in this folder: [examples/](examples/). There you can find an [Jupyter Notebook](examples/demo.ipynb) of a simple simulation ## The Problem From 217817a3f4103d1ce933c20d5965c06d5613b0b7 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 21:29:31 -0700 Subject: [PATCH 09/17] Deploy Docs Updated --- .github/workflows/on-release-main.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/on-release-main.yml b/.github/workflows/on-release-main.yml index fec7fbb..224903a 100644 --- a/.github/workflows/on-release-main.yml +++ b/.github/workflows/on-release-main.yml @@ -55,6 +55,8 @@ jobs: deploy-docs: needs: publish runs-on: ubuntu-latest + permissions: + contents: write steps: - name: Check out uses: actions/checkout@v4 From e088d2aaf413b3dc166e4552d500f550887a26c4 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 21:38:25 -0700 Subject: [PATCH 10/17] Change name to Fluidize for simplicity --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 469d144..f6b43ce 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [project] -name = "fluidize-python" +name = "fluidize" version = "0.0.2" description = "Python package for automatic generation of scientific computing software pipelines." authors = [{ name = "Henry Bae", email = "henry@fluidize.ai" }] From 30cd9c61046b0b6c83700dc25e2417a4fd7d18f3 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Wed, 13 Aug 2025 21:42:15 -0700 Subject: [PATCH 11/17] Repo Name Change -> UV Sync Change --- uv.lock | 247 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 124 insertions(+), 123 deletions(-) diff --git a/uv.lock b/uv.lock index 4be5dfd..b5e98e6 100644 --- a/uv.lock +++ b/uv.lock @@ -482,97 +482,97 @@ wheels = [ [[package]] name = "coverage" -version = "7.10.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/76/17780846fc7aade1e66712e1e27dd28faa0a5d987a1f433610974959eaa8/coverage-7.10.2.tar.gz", hash = "sha256:5d6e6d84e6dd31a8ded64759626627247d676a23c1b892e1326f7c55c8d61055", size = 820754, upload-time = "2025-08-04T00:35:17.511Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d8/5f/5ce748ab3f142593698aff5f8a0cf020775aa4e24b9d8748b5a56b64d3f8/coverage-7.10.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:79f0283ab5e6499fd5fe382ca3d62afa40fb50ff227676a3125d18af70eabf65", size = 215003, upload-time = "2025-08-04T00:33:02.977Z" }, - { url = "https://files.pythonhosted.org/packages/f4/ed/507088561217b000109552139802fa99c33c16ad19999c687b601b3790d0/coverage-7.10.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e4545e906f595ee8ab8e03e21be20d899bfc06647925bc5b224ad7e8c40e08b8", size = 215391, upload-time = "2025-08-04T00:33:05.645Z" }, - { url = "https://files.pythonhosted.org/packages/79/1b/0f496259fe137c4c5e1e8eaff496fb95af88b71700f5e57725a4ddbe742b/coverage-7.10.2-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ae385e1d58fbc6a9b1c315e5510ac52281e271478b45f92ca9b5ad42cf39643f", size = 242367, upload-time = "2025-08-04T00:33:07.189Z" }, - { url = "https://files.pythonhosted.org/packages/b9/8e/5a8835fb0122a2e2a108bf3527931693c4625fdc4d953950a480b9625852/coverage-7.10.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6f0cbe5f7dd19f3a32bac2251b95d51c3b89621ac88a2648096ce40f9a5aa1e7", size = 243627, upload-time = "2025-08-04T00:33:08.809Z" }, - { url = "https://files.pythonhosted.org/packages/c3/96/6a528429c2e0e8d85261764d0cd42e51a429510509bcc14676ee5d1bb212/coverage-7.10.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fd17f427f041f6b116dc90b4049c6f3e1230524407d00daa2d8c7915037b5947", size = 245485, upload-time = "2025-08-04T00:33:10.29Z" }, - { url = "https://files.pythonhosted.org/packages/bf/82/1fba935c4d02c33275aca319deabf1f22c0f95f2c0000bf7c5f276d6f7b4/coverage-7.10.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7f10ca4cde7b466405cce0a0e9971a13eb22e57a5ecc8b5f93a81090cc9c7eb9", size = 243429, upload-time = "2025-08-04T00:33:11.909Z" }, - { url = "https://files.pythonhosted.org/packages/fc/a8/c8dc0a57a729fc93be33ab78f187a8f52d455fa8f79bfb379fe23b45868d/coverage-7.10.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3b990df23dd51dccce26d18fb09fd85a77ebe46368f387b0ffba7a74e470b31b", size = 242104, upload-time = "2025-08-04T00:33:13.467Z" }, - { url = "https://files.pythonhosted.org/packages/b9/6f/0b7da1682e2557caeed299a00897b42afde99a241a01eba0197eb982b90f/coverage-7.10.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc3902584d25c7eef57fb38f440aa849a26a3a9f761a029a72b69acfca4e31f8", size = 242397, upload-time = "2025-08-04T00:33:14.682Z" }, - { url = "https://files.pythonhosted.org/packages/2d/e4/54dc833dadccd519c04a28852f39a37e522bad35d70cfe038817cdb8f168/coverage-7.10.2-cp310-cp310-win32.whl", hash = "sha256:9dd37e9ac00d5eb72f38ed93e3cdf2280b1dbda3bb9b48c6941805f265ad8d87", size = 217502, upload-time = "2025-08-04T00:33:16.254Z" }, - { url = "https://files.pythonhosted.org/packages/c3/e7/2f78159c4c127549172f427dff15b02176329327bf6a6a1fcf1f603b5456/coverage-7.10.2-cp310-cp310-win_amd64.whl", hash = "sha256:99d16f15cb5baf0729354c5bd3080ae53847a4072b9ba1e10957522fb290417f", size = 218388, upload-time = "2025-08-04T00:33:17.4Z" }, - { url = "https://files.pythonhosted.org/packages/6e/53/0125a6fc0af4f2687b4e08b0fb332cd0d5e60f3ca849e7456f995d022656/coverage-7.10.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2c3b210d79925a476dfc8d74c7d53224888421edebf3a611f3adae923e212b27", size = 215119, upload-time = "2025-08-04T00:33:19.101Z" }, - { url = "https://files.pythonhosted.org/packages/0e/2e/960d9871de9152dbc9ff950913c6a6e9cf2eb4cc80d5bc8f93029f9f2f9f/coverage-7.10.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bf67d1787cd317c3f8b2e4c6ed1ae93497be7e30605a0d32237ac37a37a8a322", size = 215511, upload-time = "2025-08-04T00:33:20.32Z" }, - { url = "https://files.pythonhosted.org/packages/3f/34/68509e44995b9cad806d81b76c22bc5181f3535bca7cd9c15791bfd8951e/coverage-7.10.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:069b779d03d458602bc0e27189876e7d8bdf6b24ac0f12900de22dd2154e6ad7", size = 245513, upload-time = "2025-08-04T00:33:21.896Z" }, - { url = "https://files.pythonhosted.org/packages/ef/d4/9b12f357413248ce40804b0f58030b55a25b28a5c02db95fb0aa50c5d62c/coverage-7.10.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4c2de4cb80b9990e71c62c2d3e9f3ec71b804b1f9ca4784ec7e74127e0f42468", size = 247350, upload-time = "2025-08-04T00:33:23.917Z" }, - { url = "https://files.pythonhosted.org/packages/b6/40/257945eda1f72098e4a3c350b1d68fdc5d7d032684a0aeb6c2391153ecf4/coverage-7.10.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75bf7ab2374a7eb107602f1e07310cda164016cd60968abf817b7a0b5703e288", size = 249516, upload-time = "2025-08-04T00:33:25.5Z" }, - { url = "https://files.pythonhosted.org/packages/ff/55/8987f852ece378cecbf39a367f3f7ec53351e39a9151b130af3a3045b83f/coverage-7.10.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3f37516458ec1550815134937f73d6d15b434059cd10f64678a2068f65c62406", size = 247241, upload-time = "2025-08-04T00:33:26.767Z" }, - { url = "https://files.pythonhosted.org/packages/df/ae/da397de7a42a18cea6062ed9c3b72c50b39e0b9e7b2893d7172d3333a9a1/coverage-7.10.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:de3c6271c482c250d3303fb5c6bdb8ca025fff20a67245e1425df04dc990ece9", size = 245274, upload-time = "2025-08-04T00:33:28.494Z" }, - { url = "https://files.pythonhosted.org/packages/4e/64/7baa895eb55ec0e1ec35b988687ecd5d4475ababb0d7ae5ca3874dd90ee7/coverage-7.10.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:98a838101321ac3089c9bb1d4bfa967e8afed58021fda72d7880dc1997f20ae1", size = 245882, upload-time = "2025-08-04T00:33:30.048Z" }, - { url = "https://files.pythonhosted.org/packages/24/6c/1fd76a0bd09ae75220ae9775a8290416d726f0e5ba26ea72346747161240/coverage-7.10.2-cp311-cp311-win32.whl", hash = "sha256:f2a79145a531a0e42df32d37be5af069b4a914845b6f686590739b786f2f7bce", size = 217541, upload-time = "2025-08-04T00:33:31.376Z" }, - { url = "https://files.pythonhosted.org/packages/5f/2d/8c18fb7a6e74c79fd4661e82535bc8c68aee12f46c204eabf910b097ccc9/coverage-7.10.2-cp311-cp311-win_amd64.whl", hash = "sha256:e4f5f1320f8ee0d7cfa421ceb257bef9d39fd614dd3ddcfcacd284d4824ed2c2", size = 218426, upload-time = "2025-08-04T00:33:32.976Z" }, - { url = "https://files.pythonhosted.org/packages/da/40/425bb35e4ff7c7af177edf5dffd4154bc2a677b27696afe6526d75c77fec/coverage-7.10.2-cp311-cp311-win_arm64.whl", hash = "sha256:d8f2d83118f25328552c728b8e91babf93217db259ca5c2cd4dd4220b8926293", size = 217116, upload-time = "2025-08-04T00:33:34.302Z" }, - { url = "https://files.pythonhosted.org/packages/4e/1e/2c752bdbbf6f1199c59b1a10557fbb6fb3dc96b3c0077b30bd41a5922c1f/coverage-7.10.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:890ad3a26da9ec7bf69255b9371800e2a8da9bc223ae5d86daeb940b42247c83", size = 215311, upload-time = "2025-08-04T00:33:35.524Z" }, - { url = "https://files.pythonhosted.org/packages/68/6a/84277d73a2cafb96e24be81b7169372ba7ff28768ebbf98e55c85a491b0f/coverage-7.10.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:38fd1ccfca7838c031d7a7874d4353e2f1b98eb5d2a80a2fe5732d542ae25e9c", size = 215550, upload-time = "2025-08-04T00:33:37.109Z" }, - { url = "https://files.pythonhosted.org/packages/b5/e7/5358b73b46ac76f56cc2de921eeabd44fabd0b7ff82ea4f6b8c159c4d5dc/coverage-7.10.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:76c1ffaaf4f6f0f6e8e9ca06f24bb6454a7a5d4ced97a1bc466f0d6baf4bd518", size = 246564, upload-time = "2025-08-04T00:33:38.33Z" }, - { url = "https://files.pythonhosted.org/packages/7c/0e/b0c901dd411cb7fc0cfcb28ef0dc6f3049030f616bfe9fc4143aecd95901/coverage-7.10.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:86da8a3a84b79ead5c7d0e960c34f580bc3b231bb546627773a3f53c532c2f21", size = 248993, upload-time = "2025-08-04T00:33:39.555Z" }, - { url = "https://files.pythonhosted.org/packages/0e/4e/a876db272072a9e0df93f311e187ccdd5f39a190c6d1c1f0b6e255a0d08e/coverage-7.10.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99cef9731c8a39801830a604cc53c93c9e57ea8b44953d26589499eded9576e0", size = 250454, upload-time = "2025-08-04T00:33:41.023Z" }, - { url = "https://files.pythonhosted.org/packages/64/d6/1222dc69f8dd1be208d55708a9f4a450ad582bf4fa05320617fea1eaa6d8/coverage-7.10.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ea58b112f2966a8b91eb13f5d3b1f8bb43c180d624cd3283fb33b1cedcc2dd75", size = 248365, upload-time = "2025-08-04T00:33:42.376Z" }, - { url = "https://files.pythonhosted.org/packages/62/e3/40fd71151064fc315c922dd9a35e15b30616f00146db1d6a0b590553a75a/coverage-7.10.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:20f405188d28da9522b7232e51154e1b884fc18d0b3a10f382d54784715bbe01", size = 246562, upload-time = "2025-08-04T00:33:43.663Z" }, - { url = "https://files.pythonhosted.org/packages/fc/14/8aa93ddcd6623ddaef5d8966268ac9545b145bce4fe7b1738fd1c3f0d957/coverage-7.10.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:64586ce42bbe0da4d9f76f97235c545d1abb9b25985a8791857690f96e23dc3b", size = 247772, upload-time = "2025-08-04T00:33:45.068Z" }, - { url = "https://files.pythonhosted.org/packages/07/4e/dcb1c01490623c61e2f2ea85cb185fa6a524265bb70eeb897d3c193efeb9/coverage-7.10.2-cp312-cp312-win32.whl", hash = "sha256:bc2e69b795d97ee6d126e7e22e78a509438b46be6ff44f4dccbb5230f550d340", size = 217710, upload-time = "2025-08-04T00:33:46.378Z" }, - { url = "https://files.pythonhosted.org/packages/79/16/e8aab4162b5f80ad2e5e1f54b1826e2053aa2f4db508b864af647f00c239/coverage-7.10.2-cp312-cp312-win_amd64.whl", hash = "sha256:adda2268b8cf0d11f160fad3743b4dfe9813cd6ecf02c1d6397eceaa5b45b388", size = 218499, upload-time = "2025-08-04T00:33:48.048Z" }, - { url = "https://files.pythonhosted.org/packages/06/7f/c112ec766e8f1131ce8ce26254be028772757b2d1e63e4f6a4b0ad9a526c/coverage-7.10.2-cp312-cp312-win_arm64.whl", hash = "sha256:164429decd0d6b39a0582eaa30c67bf482612c0330572343042d0ed9e7f15c20", size = 217154, upload-time = "2025-08-04T00:33:49.299Z" }, - { url = "https://files.pythonhosted.org/packages/8d/04/9b7a741557f93c0ed791b854d27aa8d9fe0b0ce7bb7c52ca1b0f2619cb74/coverage-7.10.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:aca7b5645afa688de6d4f8e89d30c577f62956fefb1bad021490d63173874186", size = 215337, upload-time = "2025-08-04T00:33:50.61Z" }, - { url = "https://files.pythonhosted.org/packages/02/a4/8d1088cd644750c94bc305d3cf56082b4cdf7fb854a25abb23359e74892f/coverage-7.10.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:96e5921342574a14303dfdb73de0019e1ac041c863743c8fe1aa6c2b4a257226", size = 215596, upload-time = "2025-08-04T00:33:52.33Z" }, - { url = "https://files.pythonhosted.org/packages/01/2f/643a8d73343f70e162d8177a3972b76e306b96239026bc0c12cfde4f7c7a/coverage-7.10.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:11333094c1bff621aa811b67ed794865cbcaa99984dedea4bd9cf780ad64ecba", size = 246145, upload-time = "2025-08-04T00:33:53.641Z" }, - { url = "https://files.pythonhosted.org/packages/1f/4a/722098d1848db4072cda71b69ede1e55730d9063bf868375264d0d302bc9/coverage-7.10.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6eb586fa7d2aee8d65d5ae1dd71414020b2f447435c57ee8de8abea0a77d5074", size = 248492, upload-time = "2025-08-04T00:33:55.366Z" }, - { url = "https://files.pythonhosted.org/packages/3f/b0/8a6d7f326f6e3e6ed398cde27f9055e860a1e858317001835c521673fb60/coverage-7.10.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d358f259d8019d4ef25d8c5b78aca4c7af25e28bd4231312911c22a0e824a57", size = 249927, upload-time = "2025-08-04T00:33:57.042Z" }, - { url = "https://files.pythonhosted.org/packages/bb/21/1aaadd3197b54d1e61794475379ecd0f68d8fc5c2ebd352964dc6f698a3d/coverage-7.10.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5250bda76e30382e0a2dcd68d961afcab92c3a7613606e6269855c6979a1b0bb", size = 248138, upload-time = "2025-08-04T00:33:58.329Z" }, - { url = "https://files.pythonhosted.org/packages/48/65/be75bafb2bdd22fd8bf9bf63cd5873b91bb26ec0d68f02d4b8b09c02decb/coverage-7.10.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a91e027d66eff214d88d9afbe528e21c9ef1ecdf4956c46e366c50f3094696d0", size = 246111, upload-time = "2025-08-04T00:33:59.899Z" }, - { url = "https://files.pythonhosted.org/packages/5e/30/a4f0c5e249c3cc60e6c6f30d8368e372f2d380eda40e0434c192ac27ccf5/coverage-7.10.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:228946da741558904e2c03ce870ba5efd9cd6e48cbc004d9a27abee08100a15a", size = 247493, upload-time = "2025-08-04T00:34:01.619Z" }, - { url = "https://files.pythonhosted.org/packages/85/99/f09b9493e44a75cf99ca834394c12f8cb70da6c1711ee296534f97b52729/coverage-7.10.2-cp313-cp313-win32.whl", hash = "sha256:95e23987b52d02e7c413bf2d6dc6288bd5721beb518052109a13bfdc62c8033b", size = 217756, upload-time = "2025-08-04T00:34:03.277Z" }, - { url = "https://files.pythonhosted.org/packages/2d/bb/cbcb09103be330c7d26ff0ab05c4a8861dd2e254656fdbd3eb7600af4336/coverage-7.10.2-cp313-cp313-win_amd64.whl", hash = "sha256:f35481d42c6d146d48ec92d4e239c23f97b53a3f1fbd2302e7c64336f28641fe", size = 218526, upload-time = "2025-08-04T00:34:04.635Z" }, - { url = "https://files.pythonhosted.org/packages/37/8f/8bfb4e0bca52c00ab680767c0dd8cfd928a2a72d69897d9b2d5d8b5f63f5/coverage-7.10.2-cp313-cp313-win_arm64.whl", hash = "sha256:65b451949cb789c346f9f9002441fc934d8ccedcc9ec09daabc2139ad13853f7", size = 217176, upload-time = "2025-08-04T00:34:05.973Z" }, - { url = "https://files.pythonhosted.org/packages/1e/25/d458ba0bf16a8204a88d74dbb7ec5520f29937ffcbbc12371f931c11efd2/coverage-7.10.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e8415918856a3e7d57a4e0ad94651b761317de459eb74d34cc1bb51aad80f07e", size = 216058, upload-time = "2025-08-04T00:34:07.368Z" }, - { url = "https://files.pythonhosted.org/packages/0b/1c/af4dfd2d7244dc7610fed6d59d57a23ea165681cd764445dc58d71ed01a6/coverage-7.10.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f287a25a8ca53901c613498e4a40885b19361a2fe8fbfdbb7f8ef2cad2a23f03", size = 216273, upload-time = "2025-08-04T00:34:09.073Z" }, - { url = "https://files.pythonhosted.org/packages/8e/67/ec5095d4035c6e16368226fa9cb15f77f891194c7e3725aeefd08e7a3e5a/coverage-7.10.2-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:75cc1a3f8c88c69bf16a871dab1fe5a7303fdb1e9f285f204b60f1ee539b8fc0", size = 257513, upload-time = "2025-08-04T00:34:10.403Z" }, - { url = "https://files.pythonhosted.org/packages/1c/47/be5550b57a3a8ba797de4236b0fd31031f88397b2afc84ab3c2d4cf265f6/coverage-7.10.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ca07fa78cc9d26bc8c4740de1abd3489cf9c47cc06d9a8ab3d552ff5101af4c0", size = 259377, upload-time = "2025-08-04T00:34:12.138Z" }, - { url = "https://files.pythonhosted.org/packages/37/50/b12a4da1382e672305c2d17cd3029dc16b8a0470de2191dbf26b91431378/coverage-7.10.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c2e117e64c26300032755d4520cd769f2623cde1a1d1c3515b05a3b8add0ade1", size = 261516, upload-time = "2025-08-04T00:34:13.608Z" }, - { url = "https://files.pythonhosted.org/packages/db/41/4d3296dbd33dd8da178171540ca3391af7c0184c0870fd4d4574ac290290/coverage-7.10.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:daaf98009977f577b71f8800208f4d40d4dcf5c2db53d4d822787cdc198d76e1", size = 259110, upload-time = "2025-08-04T00:34:15.089Z" }, - { url = "https://files.pythonhosted.org/packages/ea/f1/b409959ecbc0cec0e61e65683b22bacaa4a3b11512f834e16dd8ffbc37db/coverage-7.10.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:ea8d8fe546c528535c761ba424410bbeb36ba8a0f24be653e94b70c93fd8a8ca", size = 257248, upload-time = "2025-08-04T00:34:16.501Z" }, - { url = "https://files.pythonhosted.org/packages/48/ab/7076dc1c240412e9267d36ec93e9e299d7659f6a5c1e958f87e998b0fb6d/coverage-7.10.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:fe024d40ac31eb8d5aae70215b41dafa264676caa4404ae155f77d2fa95c37bb", size = 258063, upload-time = "2025-08-04T00:34:18.338Z" }, - { url = "https://files.pythonhosted.org/packages/1e/77/f6b51a0288f8f5f7dcc7c89abdd22cf514f3bc5151284f5cd628917f8e10/coverage-7.10.2-cp313-cp313t-win32.whl", hash = "sha256:8f34b09f68bdadec122ffad312154eda965ade433559cc1eadd96cca3de5c824", size = 218433, upload-time = "2025-08-04T00:34:19.71Z" }, - { url = "https://files.pythonhosted.org/packages/7b/6d/547a86493e25270ce8481543e77f3a0aa3aa872c1374246b7b76273d66eb/coverage-7.10.2-cp313-cp313t-win_amd64.whl", hash = "sha256:71d40b3ac0f26fa9ffa6ee16219a714fed5c6ec197cdcd2018904ab5e75bcfa3", size = 219523, upload-time = "2025-08-04T00:34:21.171Z" }, - { url = "https://files.pythonhosted.org/packages/ff/d5/3c711e38eaf9ab587edc9bed232c0298aed84e751a9f54aaa556ceaf7da6/coverage-7.10.2-cp313-cp313t-win_arm64.whl", hash = "sha256:abb57fdd38bf6f7dcc66b38dafb7af7c5fdc31ac6029ce373a6f7f5331d6f60f", size = 217739, upload-time = "2025-08-04T00:34:22.514Z" }, - { url = "https://files.pythonhosted.org/packages/71/53/83bafa669bb9d06d4c8c6a055d8d05677216f9480c4698fb183ba7ec5e47/coverage-7.10.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a3e853cc04987c85ec410905667eed4bf08b1d84d80dfab2684bb250ac8da4f6", size = 215328, upload-time = "2025-08-04T00:34:23.991Z" }, - { url = "https://files.pythonhosted.org/packages/1d/6c/30827a9c5a48a813e865fbaf91e2db25cce990bd223a022650ef2293fe11/coverage-7.10.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0100b19f230df72c90fdb36db59d3f39232391e8d89616a7de30f677da4f532b", size = 215608, upload-time = "2025-08-04T00:34:25.437Z" }, - { url = "https://files.pythonhosted.org/packages/bb/a0/c92d85948056ddc397b72a3d79d36d9579c53cb25393ed3c40db7d33b193/coverage-7.10.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9c1cd71483ea78331bdfadb8dcec4f4edfb73c7002c1206d8e0af6797853f5be", size = 246111, upload-time = "2025-08-04T00:34:26.857Z" }, - { url = "https://files.pythonhosted.org/packages/c2/cf/d695cf86b2559aadd072c91720a7844be4fb82cb4a3b642a2c6ce075692d/coverage-7.10.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9f75dbf4899e29a37d74f48342f29279391668ef625fdac6d2f67363518056a1", size = 248419, upload-time = "2025-08-04T00:34:28.726Z" }, - { url = "https://files.pythonhosted.org/packages/ce/0a/03206aec4a05986e039418c038470d874045f6e00426b0c3879adc1f9251/coverage-7.10.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7df481e7508de1c38b9b8043da48d94931aefa3e32b47dd20277e4978ed5b95", size = 250038, upload-time = "2025-08-04T00:34:30.061Z" }, - { url = "https://files.pythonhosted.org/packages/ab/9b/b3bd6bd52118c12bc4cf319f5baba65009c9beea84e665b6b9f03fa3f180/coverage-7.10.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:835f39e618099325e7612b3406f57af30ab0a0af350490eff6421e2e5f608e46", size = 248066, upload-time = "2025-08-04T00:34:31.53Z" }, - { url = "https://files.pythonhosted.org/packages/80/cc/bfa92e261d3e055c851a073e87ba6a3bff12a1f7134233e48a8f7d855875/coverage-7.10.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:12e52b5aa00aa720097d6947d2eb9e404e7c1101ad775f9661ba165ed0a28303", size = 245909, upload-time = "2025-08-04T00:34:32.943Z" }, - { url = "https://files.pythonhosted.org/packages/12/80/c8df15db4847710c72084164f615ae900af1ec380dce7f74a5678ccdf5e1/coverage-7.10.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:718044729bf1fe3e9eb9f31b52e44ddae07e434ec050c8c628bf5adc56fe4bdd", size = 247329, upload-time = "2025-08-04T00:34:34.388Z" }, - { url = "https://files.pythonhosted.org/packages/04/6f/cb66e1f7124d5dd9ced69f889f02931419cb448125e44a89a13f4e036124/coverage-7.10.2-cp314-cp314-win32.whl", hash = "sha256:f256173b48cc68486299d510a3e729a96e62c889703807482dbf56946befb5c8", size = 218007, upload-time = "2025-08-04T00:34:35.846Z" }, - { url = "https://files.pythonhosted.org/packages/8c/e1/3d4be307278ce32c1b9d95cc02ee60d54ddab784036101d053ec9e4fe7f5/coverage-7.10.2-cp314-cp314-win_amd64.whl", hash = "sha256:2e980e4179f33d9b65ac4acb86c9c0dde904098853f27f289766657ed16e07b3", size = 218802, upload-time = "2025-08-04T00:34:37.35Z" }, - { url = "https://files.pythonhosted.org/packages/ec/66/1e43bbeb66c55a5a5efec70f1c153cf90cfc7f1662ab4ebe2d844de9122c/coverage-7.10.2-cp314-cp314-win_arm64.whl", hash = "sha256:14fb5b6641ab5b3c4161572579f0f2ea8834f9d3af2f7dd8fbaecd58ef9175cc", size = 217397, upload-time = "2025-08-04T00:34:39.15Z" }, - { url = "https://files.pythonhosted.org/packages/81/01/ae29c129217f6110dc694a217475b8aecbb1b075d8073401f868c825fa99/coverage-7.10.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e96649ac34a3d0e6491e82a2af71098e43be2874b619547c3282fc11d3840a4b", size = 216068, upload-time = "2025-08-04T00:34:40.648Z" }, - { url = "https://files.pythonhosted.org/packages/a2/50/6e9221d4139f357258f36dfa1d8cac4ec56d9d5acf5fdcc909bb016954d7/coverage-7.10.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1a2e934e9da26341d342d30bfe91422bbfdb3f1f069ec87f19b2909d10d8dcc4", size = 216285, upload-time = "2025-08-04T00:34:42.441Z" }, - { url = "https://files.pythonhosted.org/packages/eb/ec/89d1d0c0ece0d296b4588e0ef4df185200456d42a47f1141335f482c2fc5/coverage-7.10.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:651015dcd5fd9b5a51ca79ece60d353cacc5beaf304db750407b29c89f72fe2b", size = 257603, upload-time = "2025-08-04T00:34:43.899Z" }, - { url = "https://files.pythonhosted.org/packages/82/06/c830af66734671c778fc49d35b58339e8f0687fbd2ae285c3f96c94da092/coverage-7.10.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:81bf6a32212f9f66da03d63ecb9cd9bd48e662050a937db7199dbf47d19831de", size = 259568, upload-time = "2025-08-04T00:34:45.519Z" }, - { url = "https://files.pythonhosted.org/packages/60/57/f280dd6f1c556ecc744fbf39e835c33d3ae987d040d64d61c6f821e87829/coverage-7.10.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d800705f6951f75a905ea6feb03fff8f3ea3468b81e7563373ddc29aa3e5d1ca", size = 261691, upload-time = "2025-08-04T00:34:47.019Z" }, - { url = "https://files.pythonhosted.org/packages/54/2b/c63a0acbd19d99ec32326164c23df3a4e18984fb86e902afdd66ff7b3d83/coverage-7.10.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:248b5394718e10d067354448dc406d651709c6765669679311170da18e0e9af8", size = 259166, upload-time = "2025-08-04T00:34:48.792Z" }, - { url = "https://files.pythonhosted.org/packages/fd/c5/cd2997dcfcbf0683634da9df52d3967bc1f1741c1475dd0e4722012ba9ef/coverage-7.10.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5c61675a922b569137cf943770d7ad3edd0202d992ce53ac328c5ff68213ccf4", size = 257241, upload-time = "2025-08-04T00:34:51.038Z" }, - { url = "https://files.pythonhosted.org/packages/16/26/c9e30f82fdad8d47aee90af4978b18c88fa74369ae0f0ba0dbf08cee3a80/coverage-7.10.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:52d708b5fd65589461381fa442d9905f5903d76c086c6a4108e8e9efdca7a7ed", size = 258139, upload-time = "2025-08-04T00:34:52.533Z" }, - { url = "https://files.pythonhosted.org/packages/c9/99/bdb7bd00bebcd3dedfb895fa9af8e46b91422993e4a37ac634a5f1113790/coverage-7.10.2-cp314-cp314t-win32.whl", hash = "sha256:916369b3b914186b2c5e5ad2f7264b02cff5df96cdd7cdad65dccd39aa5fd9f0", size = 218809, upload-time = "2025-08-04T00:34:54.075Z" }, - { url = "https://files.pythonhosted.org/packages/eb/5e/56a7852e38a04d1520dda4dfbfbf74a3d6dec932c20526968f7444763567/coverage-7.10.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5b9d538e8e04916a5df63052d698b30c74eb0174f2ca9cd942c981f274a18eaf", size = 219926, upload-time = "2025-08-04T00:34:55.643Z" }, - { url = "https://files.pythonhosted.org/packages/e0/12/7fbe6b9c52bb9d627e9556f9f2edfdbe88b315e084cdecc9afead0c3b36a/coverage-7.10.2-cp314-cp314t-win_arm64.whl", hash = "sha256:04c74f9ef1f925456a9fd23a7eef1103126186d0500ef9a0acb0bd2514bdc7cc", size = 217925, upload-time = "2025-08-04T00:34:57.564Z" }, - { url = "https://files.pythonhosted.org/packages/f5/c9/139fa9f64edfa5bae1492a4efecef7209f59ba5f9d862db594be7a85d7fb/coverage-7.10.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:765b13b164685a2f8b2abef867ad07aebedc0e090c757958a186f64e39d63dbd", size = 215003, upload-time = "2025-08-04T00:34:59.079Z" }, - { url = "https://files.pythonhosted.org/packages/fd/9f/8682ccdd223c2ab34de6575ef3c78fae9bdaece1710b4d95bb9b0abd4d2f/coverage-7.10.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a219b70100500d0c7fd3ebb824a3302efb6b1a122baa9d4eb3f43df8f0b3d899", size = 215382, upload-time = "2025-08-04T00:35:00.772Z" }, - { url = "https://files.pythonhosted.org/packages/ab/4e/45b9658499db7149e1ed5b46ccac6101dc5c0ddb786a0304f7bb0c0d90d4/coverage-7.10.2-cp39-cp39-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e33e79a219105aa315439ee051bd50b6caa705dc4164a5aba6932c8ac3ce2d98", size = 241457, upload-time = "2025-08-04T00:35:02.696Z" }, - { url = "https://files.pythonhosted.org/packages/dd/66/aaf159bfe94ee3996b8786034a8e713bc68cd650aa7c1a41b612846cdc41/coverage-7.10.2-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bc3945b7bad33957a9eca16e9e5eae4b17cb03173ef594fdaad228f4fc7da53b", size = 243354, upload-time = "2025-08-04T00:35:04.238Z" }, - { url = "https://files.pythonhosted.org/packages/21/31/8fd2f67d8580380e7b19b23838e308b6757197e94a1b3b87e0ad483f70c8/coverage-7.10.2-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9bdff88e858ee608a924acfad32a180d2bf6e13e059d6a7174abbae075f30436", size = 244923, upload-time = "2025-08-04T00:35:06.159Z" }, - { url = "https://files.pythonhosted.org/packages/55/90/67b129b08200e08962961f56604083923bc8484bc641c92ee6801c1ae822/coverage-7.10.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:44329cbed24966c0b49acb386352c9722219af1f0c80db7f218af7793d251902", size = 242856, upload-time = "2025-08-04T00:35:07.735Z" }, - { url = "https://files.pythonhosted.org/packages/4d/8f/3f428363f713ab3432e602665cdefe436fd427263471644dd3742b6eebd8/coverage-7.10.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:be127f292496d0fbe20d8025f73221b36117b3587f890346e80a13b310712982", size = 241092, upload-time = "2025-08-04T00:35:09.381Z" }, - { url = "https://files.pythonhosted.org/packages/ac/4d/e8531ea19f047b8b1d1d1c85794e4b35ae762e570f072ca2afbce67be176/coverage-7.10.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6c031da749a05f7a01447dd7f47beedb498edd293e31e1878c0d52db18787df0", size = 242044, upload-time = "2025-08-04T00:35:10.929Z" }, - { url = "https://files.pythonhosted.org/packages/62/6b/22cb6281b4d06b73edae2facc7935a15151ddb8e8d8928a184b7a3100289/coverage-7.10.2-cp39-cp39-win32.whl", hash = "sha256:22aca3e691c7709c5999ccf48b7a8ff5cf5a8bd6fe9b36efbd4993f5a36b2fcf", size = 217512, upload-time = "2025-08-04T00:35:12.801Z" }, - { url = "https://files.pythonhosted.org/packages/9e/83/bce22e6880837de640d6ff630c7493709a3511f93c5154a326b337f01a81/coverage-7.10.2-cp39-cp39-win_amd64.whl", hash = "sha256:c7195444b932356055a8e287fa910bf9753a84a1bc33aeb3770e8fca521e032e", size = 218406, upload-time = "2025-08-04T00:35:14.351Z" }, - { url = "https://files.pythonhosted.org/packages/18/d8/9b768ac73a8ac2d10c080af23937212434a958c8d2a1c84e89b450237942/coverage-7.10.2-py3-none-any.whl", hash = "sha256:95db3750dd2e6e93d99fa2498f3a1580581e49c494bddccc6f85c5c21604921f", size = 206973, upload-time = "2025-08-04T00:35:15.918Z" }, +version = "7.10.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/2c/253cc41cd0f40b84c1c34c5363e0407d73d4a1cae005fed6db3b823175bd/coverage-7.10.3.tar.gz", hash = "sha256:812ba9250532e4a823b070b0420a36499859542335af3dca8f47fc6aa1a05619", size = 822936, upload-time = "2025-08-10T21:27:39.968Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/44/e14576c34b37764c821866909788ff7463228907ab82bae188dab2b421f1/coverage-7.10.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:53808194afdf948c462215e9403cca27a81cf150d2f9b386aee4dab614ae2ffe", size = 215964, upload-time = "2025-08-10T21:25:22.828Z" }, + { url = "https://files.pythonhosted.org/packages/e6/15/f4f92d9b83100903efe06c9396ee8d8bdba133399d37c186fc5b16d03a87/coverage-7.10.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f4d1b837d1abf72187a61645dbf799e0d7705aa9232924946e1f57eb09a3bf00", size = 216361, upload-time = "2025-08-10T21:25:25.603Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3a/c92e8cd5e89acc41cfc026dfb7acedf89661ce2ea1ee0ee13aacb6b2c20c/coverage-7.10.3-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2a90dd4505d3cc68b847ab10c5ee81822a968b5191664e8a0801778fa60459fa", size = 243115, upload-time = "2025-08-10T21:25:27.09Z" }, + { url = "https://files.pythonhosted.org/packages/23/53/c1d8c2778823b1d95ca81701bb8f42c87dc341a2f170acdf716567523490/coverage-7.10.3-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d52989685ff5bf909c430e6d7f6550937bc6d6f3e6ecb303c97a86100efd4596", size = 244927, upload-time = "2025-08-10T21:25:28.77Z" }, + { url = "https://files.pythonhosted.org/packages/79/41/1e115fd809031f432b4ff8e2ca19999fb6196ab95c35ae7ad5e07c001130/coverage-7.10.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bdb558a1d97345bde3a9f4d3e8d11c9e5611f748646e9bb61d7d612a796671b5", size = 246784, upload-time = "2025-08-10T21:25:30.195Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b2/0eba9bdf8f1b327ae2713c74d4b7aa85451bb70622ab4e7b8c000936677c/coverage-7.10.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c9e6331a8f09cb1fc8bda032752af03c366870b48cce908875ba2620d20d0ad4", size = 244828, upload-time = "2025-08-10T21:25:31.785Z" }, + { url = "https://files.pythonhosted.org/packages/1f/cc/74c56b6bf71f2a53b9aa3df8bc27163994e0861c065b4fe3a8ac290bed35/coverage-7.10.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:992f48bf35b720e174e7fae916d943599f1a66501a2710d06c5f8104e0756ee1", size = 242844, upload-time = "2025-08-10T21:25:33.37Z" }, + { url = "https://files.pythonhosted.org/packages/b6/7b/ac183fbe19ac5596c223cb47af5737f4437e7566100b7e46cc29b66695a5/coverage-7.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c5595fc4ad6a39312c786ec3326d7322d0cf10e3ac6a6df70809910026d67cfb", size = 243721, upload-time = "2025-08-10T21:25:34.939Z" }, + { url = "https://files.pythonhosted.org/packages/57/96/cb90da3b5a885af48f531905234a1e7376acfc1334242183d23154a1c285/coverage-7.10.3-cp310-cp310-win32.whl", hash = "sha256:9e92fa1f2bd5a57df9d00cf9ce1eb4ef6fccca4ceabec1c984837de55329db34", size = 218481, upload-time = "2025-08-10T21:25:36.935Z" }, + { url = "https://files.pythonhosted.org/packages/15/67/1ba4c7d75745c4819c54a85766e0a88cc2bff79e1760c8a2debc34106dc2/coverage-7.10.3-cp310-cp310-win_amd64.whl", hash = "sha256:b96524d6e4a3ce6a75c56bb15dbd08023b0ae2289c254e15b9fbdddf0c577416", size = 219382, upload-time = "2025-08-10T21:25:38.267Z" }, + { url = "https://files.pythonhosted.org/packages/87/04/810e506d7a19889c244d35199cbf3239a2f952b55580aa42ca4287409424/coverage-7.10.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f2ff2e2afdf0d51b9b8301e542d9c21a8d084fd23d4c8ea2b3a1b3c96f5f7397", size = 216075, upload-time = "2025-08-10T21:25:39.891Z" }, + { url = "https://files.pythonhosted.org/packages/2e/50/6b3fbab034717b4af3060bdaea6b13dfdc6b1fad44b5082e2a95cd378a9a/coverage-7.10.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:18ecc5d1b9a8c570f6c9b808fa9a2b16836b3dd5414a6d467ae942208b095f85", size = 216476, upload-time = "2025-08-10T21:25:41.137Z" }, + { url = "https://files.pythonhosted.org/packages/c7/96/4368c624c1ed92659812b63afc76c492be7867ac8e64b7190b88bb26d43c/coverage-7.10.3-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1af4461b25fe92889590d438905e1fc79a95680ec2a1ff69a591bb3fdb6c7157", size = 246865, upload-time = "2025-08-10T21:25:42.408Z" }, + { url = "https://files.pythonhosted.org/packages/34/12/5608f76070939395c17053bf16e81fd6c06cf362a537ea9d07e281013a27/coverage-7.10.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3966bc9a76b09a40dc6063c8b10375e827ea5dfcaffae402dd65953bef4cba54", size = 248800, upload-time = "2025-08-10T21:25:44.098Z" }, + { url = "https://files.pythonhosted.org/packages/ce/52/7cc90c448a0ad724283cbcdfd66b8d23a598861a6a22ac2b7b8696491798/coverage-7.10.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:205a95b87ef4eb303b7bc5118b47b6b6604a644bcbdb33c336a41cfc0a08c06a", size = 250904, upload-time = "2025-08-10T21:25:45.384Z" }, + { url = "https://files.pythonhosted.org/packages/e6/70/9967b847063c1c393b4f4d6daab1131558ebb6b51f01e7df7150aa99f11d/coverage-7.10.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b3801b79fb2ad61e3c7e2554bab754fc5f105626056980a2b9cf3aef4f13f84", size = 248597, upload-time = "2025-08-10T21:25:47.059Z" }, + { url = "https://files.pythonhosted.org/packages/2d/fe/263307ce6878b9ed4865af42e784b42bb82d066bcf10f68defa42931c2c7/coverage-7.10.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b0dc69c60224cda33d384572da945759756e3f06b9cdac27f302f53961e63160", size = 246647, upload-time = "2025-08-10T21:25:48.334Z" }, + { url = "https://files.pythonhosted.org/packages/8e/27/d27af83ad162eba62c4eb7844a1de6cf7d9f6b185df50b0a3514a6f80ddd/coverage-7.10.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a83d4f134bab2c7ff758e6bb1541dd72b54ba295ced6a63d93efc2e20cb9b124", size = 247290, upload-time = "2025-08-10T21:25:49.945Z" }, + { url = "https://files.pythonhosted.org/packages/28/83/904ff27e15467a5622dbe9ad2ed5831b4a616a62570ec5924d06477dff5a/coverage-7.10.3-cp311-cp311-win32.whl", hash = "sha256:54e409dd64e5302b2a8fdf44ec1c26f47abd1f45a2dcf67bd161873ee05a59b8", size = 218521, upload-time = "2025-08-10T21:25:51.208Z" }, + { url = "https://files.pythonhosted.org/packages/b8/29/bc717b8902faaccf0ca486185f0dcab4778561a529dde51cb157acaafa16/coverage-7.10.3-cp311-cp311-win_amd64.whl", hash = "sha256:30c601610a9b23807c5e9e2e442054b795953ab85d525c3de1b1b27cebeb2117", size = 219412, upload-time = "2025-08-10T21:25:52.494Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7a/5a1a7028c11bb589268c656c6b3f2bbf06e0aced31bbdf7a4e94e8442cc0/coverage-7.10.3-cp311-cp311-win_arm64.whl", hash = "sha256:dabe662312a97958e932dee056f2659051d822552c0b866823e8ba1c2fe64770", size = 218091, upload-time = "2025-08-10T21:25:54.102Z" }, + { url = "https://files.pythonhosted.org/packages/b8/62/13c0b66e966c43d7aa64dadc8cd2afa1f5a2bf9bb863bdabc21fb94e8b63/coverage-7.10.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:449c1e2d3a84d18bd204258a897a87bc57380072eb2aded6a5b5226046207b42", size = 216262, upload-time = "2025-08-10T21:25:55.367Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f0/59fdf79be7ac2f0206fc739032f482cfd3f66b18f5248108ff192741beae/coverage-7.10.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1d4f9ce50b9261ad196dc2b2e9f1fbbee21651b54c3097a25ad783679fd18294", size = 216496, upload-time = "2025-08-10T21:25:56.759Z" }, + { url = "https://files.pythonhosted.org/packages/34/b1/bc83788ba31bde6a0c02eb96bbc14b2d1eb083ee073beda18753fa2c4c66/coverage-7.10.3-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4dd4564207b160d0d45c36a10bc0a3d12563028e8b48cd6459ea322302a156d7", size = 247989, upload-time = "2025-08-10T21:25:58.067Z" }, + { url = "https://files.pythonhosted.org/packages/0c/29/f8bdf88357956c844bd872e87cb16748a37234f7f48c721dc7e981145eb7/coverage-7.10.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5ca3c9530ee072b7cb6a6ea7b640bcdff0ad3b334ae9687e521e59f79b1d0437", size = 250738, upload-time = "2025-08-10T21:25:59.406Z" }, + { url = "https://files.pythonhosted.org/packages/ae/df/6396301d332b71e42bbe624670af9376f63f73a455cc24723656afa95796/coverage-7.10.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b6df359e59fa243c9925ae6507e27f29c46698359f45e568fd51b9315dbbe587", size = 251868, upload-time = "2025-08-10T21:26:00.65Z" }, + { url = "https://files.pythonhosted.org/packages/91/21/d760b2df6139b6ef62c9cc03afb9bcdf7d6e36ed4d078baacffa618b4c1c/coverage-7.10.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a181e4c2c896c2ff64c6312db3bda38e9ade2e1aa67f86a5628ae85873786cea", size = 249790, upload-time = "2025-08-10T21:26:02.009Z" }, + { url = "https://files.pythonhosted.org/packages/69/91/5dcaa134568202397fa4023d7066d4318dc852b53b428052cd914faa05e1/coverage-7.10.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a374d4e923814e8b72b205ef6b3d3a647bb50e66f3558582eda074c976923613", size = 247907, upload-time = "2025-08-10T21:26:03.757Z" }, + { url = "https://files.pythonhosted.org/packages/38/ed/70c0e871cdfef75f27faceada461206c1cc2510c151e1ef8d60a6fedda39/coverage-7.10.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:daeefff05993e5e8c6e7499a8508e7bd94502b6b9a9159c84fd1fe6bce3151cb", size = 249344, upload-time = "2025-08-10T21:26:05.11Z" }, + { url = "https://files.pythonhosted.org/packages/5f/55/c8a273ed503cedc07f8a00dcd843daf28e849f0972e4c6be4c027f418ad6/coverage-7.10.3-cp312-cp312-win32.whl", hash = "sha256:187ecdcac21f9636d570e419773df7bd2fda2e7fa040f812e7f95d0bddf5f79a", size = 218693, upload-time = "2025-08-10T21:26:06.534Z" }, + { url = "https://files.pythonhosted.org/packages/94/58/dd3cfb2473b85be0b6eb8c5b6d80b6fc3f8f23611e69ef745cef8cf8bad5/coverage-7.10.3-cp312-cp312-win_amd64.whl", hash = "sha256:4a50ad2524ee7e4c2a95e60d2b0b83283bdfc745fe82359d567e4f15d3823eb5", size = 219501, upload-time = "2025-08-10T21:26:08.195Z" }, + { url = "https://files.pythonhosted.org/packages/56/af/7cbcbf23d46de6f24246e3f76b30df099d05636b30c53c158a196f7da3ad/coverage-7.10.3-cp312-cp312-win_arm64.whl", hash = "sha256:c112f04e075d3495fa3ed2200f71317da99608cbb2e9345bdb6de8819fc30571", size = 218135, upload-time = "2025-08-10T21:26:09.584Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ff/239e4de9cc149c80e9cc359fab60592365b8c4cbfcad58b8a939d18c6898/coverage-7.10.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b99e87304ffe0eb97c5308447328a584258951853807afdc58b16143a530518a", size = 216298, upload-time = "2025-08-10T21:26:10.973Z" }, + { url = "https://files.pythonhosted.org/packages/56/da/28717da68f8ba68f14b9f558aaa8f3e39ada8b9a1ae4f4977c8f98b286d5/coverage-7.10.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4af09c7574d09afbc1ea7da9dcea23665c01f3bc1b1feb061dac135f98ffc53a", size = 216546, upload-time = "2025-08-10T21:26:12.616Z" }, + { url = "https://files.pythonhosted.org/packages/de/bb/e1ade16b9e3f2d6c323faeb6bee8e6c23f3a72760a5d9af102ef56a656cb/coverage-7.10.3-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:488e9b50dc5d2aa9521053cfa706209e5acf5289e81edc28291a24f4e4488f46", size = 247538, upload-time = "2025-08-10T21:26:14.455Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2f/6ae1db51dc34db499bfe340e89f79a63bd115fc32513a7bacdf17d33cd86/coverage-7.10.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:913ceddb4289cbba3a310704a424e3fb7aac2bc0c3a23ea473193cb290cf17d4", size = 250141, upload-time = "2025-08-10T21:26:15.787Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ed/33efd8819895b10c66348bf26f011dd621e804866c996ea6893d682218df/coverage-7.10.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b1f91cbc78c7112ab84ed2a8defbccd90f888fcae40a97ddd6466b0bec6ae8a", size = 251415, upload-time = "2025-08-10T21:26:17.535Z" }, + { url = "https://files.pythonhosted.org/packages/26/04/cb83826f313d07dc743359c9914d9bc460e0798da9a0e38b4f4fabc207ed/coverage-7.10.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0bac054d45af7cd938834b43a9878b36ea92781bcb009eab040a5b09e9927e3", size = 249575, upload-time = "2025-08-10T21:26:18.921Z" }, + { url = "https://files.pythonhosted.org/packages/2d/fd/ae963c7a8e9581c20fa4355ab8940ca272554d8102e872dbb932a644e410/coverage-7.10.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:fe72cbdd12d9e0f4aca873fa6d755e103888a7f9085e4a62d282d9d5b9f7928c", size = 247466, upload-time = "2025-08-10T21:26:20.263Z" }, + { url = "https://files.pythonhosted.org/packages/99/e8/b68d1487c6af370b8d5ef223c6d7e250d952c3acfbfcdbf1a773aa0da9d2/coverage-7.10.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c1e2e927ab3eadd7c244023927d646e4c15c65bb2ac7ae3c3e9537c013700d21", size = 249084, upload-time = "2025-08-10T21:26:21.638Z" }, + { url = "https://files.pythonhosted.org/packages/66/4d/a0bcb561645c2c1e21758d8200443669d6560d2a2fb03955291110212ec4/coverage-7.10.3-cp313-cp313-win32.whl", hash = "sha256:24d0c13de473b04920ddd6e5da3c08831b1170b8f3b17461d7429b61cad59ae0", size = 218735, upload-time = "2025-08-10T21:26:23.009Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c3/78b4adddbc0feb3b223f62761e5f9b4c5a758037aaf76e0a5845e9e35e48/coverage-7.10.3-cp313-cp313-win_amd64.whl", hash = "sha256:3564aae76bce4b96e2345cf53b4c87e938c4985424a9be6a66ee902626edec4c", size = 219531, upload-time = "2025-08-10T21:26:24.474Z" }, + { url = "https://files.pythonhosted.org/packages/70/1b/1229c0b2a527fa5390db58d164aa896d513a1fbb85a1b6b6676846f00552/coverage-7.10.3-cp313-cp313-win_arm64.whl", hash = "sha256:f35580f19f297455f44afcd773c9c7a058e52eb6eb170aa31222e635f2e38b87", size = 218162, upload-time = "2025-08-10T21:26:25.847Z" }, + { url = "https://files.pythonhosted.org/packages/fc/26/1c1f450e15a3bf3eaecf053ff64538a2612a23f05b21d79ce03be9ff5903/coverage-7.10.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07009152f497a0464ffdf2634586787aea0e69ddd023eafb23fc38267db94b84", size = 217003, upload-time = "2025-08-10T21:26:27.231Z" }, + { url = "https://files.pythonhosted.org/packages/29/96/4b40036181d8c2948454b458750960956a3c4785f26a3c29418bbbee1666/coverage-7.10.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8dd2ba5f0c7e7e8cc418be2f0c14c4d9e3f08b8fb8e4c0f83c2fe87d03eb655e", size = 217238, upload-time = "2025-08-10T21:26:28.83Z" }, + { url = "https://files.pythonhosted.org/packages/62/23/8dfc52e95da20957293fb94d97397a100e63095ec1e0ef5c09dd8c6f591a/coverage-7.10.3-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1ae22b97003c74186e034a93e4f946c75fad8c0ce8d92fbbc168b5e15ee2841f", size = 258561, upload-time = "2025-08-10T21:26:30.475Z" }, + { url = "https://files.pythonhosted.org/packages/59/95/00e7fcbeda3f632232f4c07dde226afe3511a7781a000aa67798feadc535/coverage-7.10.3-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb329f1046888a36b1dc35504d3029e1dd5afe2196d94315d18c45ee380f67d5", size = 260735, upload-time = "2025-08-10T21:26:32.333Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4c/f4666cbc4571804ba2a65b078ff0de600b0b577dc245389e0bc9b69ae7ca/coverage-7.10.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce01048199a91f07f96ca3074b0c14021f4fe7ffd29a3e6a188ac60a5c3a4af8", size = 262960, upload-time = "2025-08-10T21:26:33.701Z" }, + { url = "https://files.pythonhosted.org/packages/c1/a5/8a9e8a7b12a290ed98b60f73d1d3e5e9ced75a4c94a0d1a671ce3ddfff2a/coverage-7.10.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:08b989a06eb9dfacf96d42b7fb4c9a22bafa370d245dc22fa839f2168c6f9fa1", size = 260515, upload-time = "2025-08-10T21:26:35.16Z" }, + { url = "https://files.pythonhosted.org/packages/86/11/bb59f7f33b2cac0c5b17db0d9d0abba9c90d9eda51a6e727b43bd5fce4ae/coverage-7.10.3-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:669fe0d4e69c575c52148511029b722ba8d26e8a3129840c2ce0522e1452b256", size = 258278, upload-time = "2025-08-10T21:26:36.539Z" }, + { url = "https://files.pythonhosted.org/packages/cc/22/3646f8903743c07b3e53fded0700fed06c580a980482f04bf9536657ac17/coverage-7.10.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3262d19092771c83f3413831d9904b1ccc5f98da5de4ffa4ad67f5b20c7aaf7b", size = 259408, upload-time = "2025-08-10T21:26:37.954Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/6375e9d905da22ddea41cd85c30994b8b6f6c02e44e4c5744b76d16b026f/coverage-7.10.3-cp313-cp313t-win32.whl", hash = "sha256:cc0ee4b2ccd42cab7ee6be46d8a67d230cb33a0a7cd47a58b587a7063b6c6b0e", size = 219396, upload-time = "2025-08-10T21:26:39.426Z" }, + { url = "https://files.pythonhosted.org/packages/33/3b/7da37fd14412b8c8b6e73c3e7458fef6b1b05a37f990a9776f88e7740c89/coverage-7.10.3-cp313-cp313t-win_amd64.whl", hash = "sha256:03db599f213341e2960430984e04cf35fb179724e052a3ee627a068653cf4a7c", size = 220458, upload-time = "2025-08-10T21:26:40.905Z" }, + { url = "https://files.pythonhosted.org/packages/28/cc/59a9a70f17edab513c844ee7a5c63cf1057041a84cc725b46a51c6f8301b/coverage-7.10.3-cp313-cp313t-win_arm64.whl", hash = "sha256:46eae7893ba65f53c71284585a262f083ef71594f05ec5c85baf79c402369098", size = 218722, upload-time = "2025-08-10T21:26:42.362Z" }, + { url = "https://files.pythonhosted.org/packages/2d/84/bb773b51a06edbf1231b47dc810a23851f2796e913b335a0fa364773b842/coverage-7.10.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:bce8b8180912914032785850d8f3aacb25ec1810f5f54afc4a8b114e7a9b55de", size = 216280, upload-time = "2025-08-10T21:26:44.132Z" }, + { url = "https://files.pythonhosted.org/packages/92/a8/4d8ca9c111d09865f18d56facff64d5fa076a5593c290bd1cfc5dceb8dba/coverage-7.10.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07790b4b37d56608536f7c1079bd1aa511567ac2966d33d5cec9cf520c50a7c8", size = 216557, upload-time = "2025-08-10T21:26:45.598Z" }, + { url = "https://files.pythonhosted.org/packages/fe/b2/eb668bfc5060194bc5e1ccd6f664e8e045881cfee66c42a2aa6e6c5b26e8/coverage-7.10.3-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e79367ef2cd9166acedcbf136a458dfe9a4a2dd4d1ee95738fb2ee581c56f667", size = 247598, upload-time = "2025-08-10T21:26:47.081Z" }, + { url = "https://files.pythonhosted.org/packages/fd/b0/9faa4ac62c8822219dd83e5d0e73876398af17d7305968aed8d1606d1830/coverage-7.10.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:419d2a0f769f26cb1d05e9ccbc5eab4cb5d70231604d47150867c07822acbdf4", size = 250131, upload-time = "2025-08-10T21:26:48.65Z" }, + { url = "https://files.pythonhosted.org/packages/4e/90/203537e310844d4bf1bdcfab89c1e05c25025c06d8489b9e6f937ad1a9e2/coverage-7.10.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee221cf244757cdc2ac882e3062ab414b8464ad9c884c21e878517ea64b3fa26", size = 251485, upload-time = "2025-08-10T21:26:50.368Z" }, + { url = "https://files.pythonhosted.org/packages/b9/b2/9d894b26bc53c70a1fe503d62240ce6564256d6d35600bdb86b80e516e7d/coverage-7.10.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c2079d8cdd6f7373d628e14b3357f24d1db02c9dc22e6a007418ca7a2be0435a", size = 249488, upload-time = "2025-08-10T21:26:52.045Z" }, + { url = "https://files.pythonhosted.org/packages/b4/28/af167dbac5281ba6c55c933a0ca6675d68347d5aee39cacc14d44150b922/coverage-7.10.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:bd8df1f83c0703fa3ca781b02d36f9ec67ad9cb725b18d486405924f5e4270bd", size = 247419, upload-time = "2025-08-10T21:26:53.533Z" }, + { url = "https://files.pythonhosted.org/packages/f4/1c/9a4ddc9f0dcb150d4cd619e1c4bb39bcf694c6129220bdd1e5895d694dda/coverage-7.10.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6b4e25e0fa335c8aa26e42a52053f3786a61cc7622b4d54ae2dad994aa754fec", size = 248917, upload-time = "2025-08-10T21:26:55.11Z" }, + { url = "https://files.pythonhosted.org/packages/92/27/c6a60c7cbe10dbcdcd7fc9ee89d531dc04ea4c073800279bb269954c5a9f/coverage-7.10.3-cp314-cp314-win32.whl", hash = "sha256:d7c3d02c2866deb217dce664c71787f4b25420ea3eaf87056f44fb364a3528f5", size = 218999, upload-time = "2025-08-10T21:26:56.637Z" }, + { url = "https://files.pythonhosted.org/packages/36/09/a94c1369964ab31273576615d55e7d14619a1c47a662ed3e2a2fe4dee7d4/coverage-7.10.3-cp314-cp314-win_amd64.whl", hash = "sha256:9c8916d44d9e0fe6cdb2227dc6b0edd8bc6c8ef13438bbbf69af7482d9bb9833", size = 219801, upload-time = "2025-08-10T21:26:58.207Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/f5cd2a80f401c01cf0f3add64a7b791b7d53fd6090a4e3e9ea52691cf3c4/coverage-7.10.3-cp314-cp314-win_arm64.whl", hash = "sha256:1007d6a2b3cf197c57105cc1ba390d9ff7f0bee215ced4dea530181e49c65ab4", size = 218381, upload-time = "2025-08-10T21:26:59.707Z" }, + { url = "https://files.pythonhosted.org/packages/73/3d/89d65baf1ea39e148ee989de6da601469ba93c1d905b17dfb0b83bd39c96/coverage-7.10.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ebc8791d346410d096818788877d675ca55c91db87d60e8f477bd41c6970ffc6", size = 217019, upload-time = "2025-08-10T21:27:01.242Z" }, + { url = "https://files.pythonhosted.org/packages/7d/7d/d9850230cd9c999ce3a1e600f85c2fff61a81c301334d7a1faa1a5ba19c8/coverage-7.10.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f4e4d8e75f6fd3c6940ebeed29e3d9d632e1f18f6fb65d33086d99d4d073241", size = 217237, upload-time = "2025-08-10T21:27:03.442Z" }, + { url = "https://files.pythonhosted.org/packages/36/51/b87002d417202ab27f4a1cd6bd34ee3b78f51b3ddbef51639099661da991/coverage-7.10.3-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:24581ed69f132b6225a31b0228ae4885731cddc966f8a33fe5987288bdbbbd5e", size = 258735, upload-time = "2025-08-10T21:27:05.124Z" }, + { url = "https://files.pythonhosted.org/packages/1c/02/1f8612bfcb46fc7ca64a353fff1cd4ed932bb6e0b4e0bb88b699c16794b8/coverage-7.10.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec151569ddfccbf71bac8c422dce15e176167385a00cd86e887f9a80035ce8a5", size = 260901, upload-time = "2025-08-10T21:27:06.68Z" }, + { url = "https://files.pythonhosted.org/packages/aa/3a/fe39e624ddcb2373908bd922756384bb70ac1c5009b0d1674eb326a3e428/coverage-7.10.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2ae8e7c56290b908ee817200c0b65929b8050bc28530b131fe7c6dfee3e7d86b", size = 263157, upload-time = "2025-08-10T21:27:08.398Z" }, + { url = "https://files.pythonhosted.org/packages/5e/89/496b6d5a10fa0d0691a633bb2b2bcf4f38f0bdfcbde21ad9e32d1af328ed/coverage-7.10.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5fb742309766d7e48e9eb4dc34bc95a424707bc6140c0e7d9726e794f11b92a0", size = 260597, upload-time = "2025-08-10T21:27:10.237Z" }, + { url = "https://files.pythonhosted.org/packages/b6/a6/8b5bf6a9e8c6aaeb47d5fe9687014148efc05c3588110246d5fdeef9b492/coverage-7.10.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:c65e2a5b32fbe1e499f1036efa6eb9cb4ea2bf6f7168d0e7a5852f3024f471b1", size = 258353, upload-time = "2025-08-10T21:27:11.773Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6d/ad131be74f8afd28150a07565dfbdc86592fd61d97e2dc83383d9af219f0/coverage-7.10.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d48d2cb07d50f12f4f18d2bb75d9d19e3506c26d96fffabf56d22936e5ed8f7c", size = 259504, upload-time = "2025-08-10T21:27:13.254Z" }, + { url = "https://files.pythonhosted.org/packages/ec/30/fc9b5097092758cba3375a8cc4ff61774f8cd733bcfb6c9d21a60077a8d8/coverage-7.10.3-cp314-cp314t-win32.whl", hash = "sha256:dec0d9bc15ee305e09fe2cd1911d3f0371262d3cfdae05d79515d8cb712b4869", size = 219782, upload-time = "2025-08-10T21:27:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/72/9b/27fbf79451b1fac15c4bda6ec6e9deae27cf7c0648c1305aa21a3454f5c4/coverage-7.10.3-cp314-cp314t-win_amd64.whl", hash = "sha256:424ea93a323aa0f7f01174308ea78bde885c3089ec1bef7143a6d93c3e24ef64", size = 220898, upload-time = "2025-08-10T21:27:16.297Z" }, + { url = "https://files.pythonhosted.org/packages/d1/cf/a32bbf92869cbf0b7c8b84325327bfc718ad4b6d2c63374fef3d58e39306/coverage-7.10.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f5983c132a62d93d71c9ef896a0b9bf6e6828d8d2ea32611f58684fba60bba35", size = 218922, upload-time = "2025-08-10T21:27:18.22Z" }, + { url = "https://files.pythonhosted.org/packages/f1/66/c06f4a93c65b6fc6578ef4f1fe51f83d61fc6f2a74ec0ce434ed288d834a/coverage-7.10.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:da749daa7e141985487e1ff90a68315b0845930ed53dc397f4ae8f8bab25b551", size = 215951, upload-time = "2025-08-10T21:27:19.815Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ea/cc18c70a6f72f8e4def212eaebd8388c64f29608da10b3c38c8ec76f5e49/coverage-7.10.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3126fb6a47d287f461d9b1aa5d1a8c97034d1dffb4f452f2cf211289dae74ef", size = 216335, upload-time = "2025-08-10T21:27:21.737Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fb/9c6d1d67c6d54b149f06b9f374bc9ca03e4d7d7784c8cfd12ceda20e3787/coverage-7.10.3-cp39-cp39-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3da794db13cc27ca40e1ec8127945b97fab78ba548040047d54e7bfa6d442dca", size = 242772, upload-time = "2025-08-10T21:27:23.884Z" }, + { url = "https://files.pythonhosted.org/packages/5a/e5/4223bdb28b992a19a13ab1410c761e2bfe92ca1e7bba8e85ee2024eeda85/coverage-7.10.3-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4e27bebbd184ef8d1c1e092b74a2b7109dcbe2618dce6e96b1776d53b14b3fe8", size = 244596, upload-time = "2025-08-10T21:27:25.842Z" }, + { url = "https://files.pythonhosted.org/packages/d2/13/d646ba28613669d487c654a760571c10128247d12d9f50e93f69542679a2/coverage-7.10.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8fd4ee2580b9fefbd301b4f8f85b62ac90d1e848bea54f89a5748cf132782118", size = 246370, upload-time = "2025-08-10T21:27:27.503Z" }, + { url = "https://files.pythonhosted.org/packages/02/7c/aff99c67d8c383142b0877ee435caf493765356336211c4899257325d6c7/coverage-7.10.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6999920bdd73259ce11cabfc1307484f071ecc6abdb2ca58d98facbcefc70f16", size = 244254, upload-time = "2025-08-10T21:27:29.357Z" }, + { url = "https://files.pythonhosted.org/packages/b0/13/a51ea145ed51ddfa8717bb29926d9111aca343fab38f04692a843d50be6b/coverage-7.10.3-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:c3623f929db885fab100cb88220a5b193321ed37e03af719efdbaf5d10b6e227", size = 242325, upload-time = "2025-08-10T21:27:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/d8/4b/6119be0089c89ad49d2e5a508d55a1485c878642b706a7f95b26e299137d/coverage-7.10.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:25b902c5e15dea056485d782e420bb84621cc08ee75d5131ecb3dbef8bd1365f", size = 243281, upload-time = "2025-08-10T21:27:32.815Z" }, + { url = "https://files.pythonhosted.org/packages/34/c8/1b2e7e53eee4bc1304e56e10361b08197a77a26ceb07201dcc9e759ef132/coverage-7.10.3-cp39-cp39-win32.whl", hash = "sha256:f930a4d92b004b643183451fe9c8fe398ccf866ed37d172ebaccfd443a097f61", size = 218489, upload-time = "2025-08-10T21:27:34.905Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/9c0c230a199809c39e2dff0f1f889dfb04dcd07d83c1c26a8ef671660e08/coverage-7.10.3-cp39-cp39-win_amd64.whl", hash = "sha256:08e638a93c8acba13c7842953f92a33d52d73e410329acd472280d2a21a6c0e1", size = 219396, upload-time = "2025-08-10T21:27:36.61Z" }, + { url = "https://files.pythonhosted.org/packages/84/19/e67f4ae24e232c7f713337f3f4f7c9c58afd0c02866fb07c7b9255a19ed7/coverage-7.10.3-py3-none-any.whl", hash = "sha256:416a8d74dc0adfd33944ba2f405897bab87b7e9e84a391e09d241956bd953ce1", size = 207921, upload-time = "2025-08-10T21:27:38.254Z" }, ] [package.optional-dependencies] @@ -591,15 +591,15 @@ wheels = [ [[package]] name = "databricks-sdk" -version = "0.62.0" +version = "0.63.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "google-auth" }, { name = "requests" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e9/16/1ad8be298b3135a3be0875afb97ce07a4fecd32489f8351bc4419e5e083b/databricks_sdk-0.62.0.tar.gz", hash = "sha256:12f8da735f74cba5265dcb0620c30941628f63787e6ea7e57cc5ed22d9e1b987", size = 725602, upload-time = "2025-08-06T11:31:06.415Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/af/f77be9ed096e7e83732e80d87997256d7bd7d9aff62fa0d51e4068ae786c/databricks_sdk-0.63.0.tar.gz", hash = "sha256:f141bc810b4145e93e628a0e159ea41806440aed0cd17adddd252d65d1968465", size = 732112, upload-time = "2025-08-13T09:00:08.722Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/cd/5fe949ec0b160130066d0ba82b4f499dc494a7405723836ebc37511f6bfc/databricks_sdk-0.62.0-py3-none-any.whl", hash = "sha256:79d4abe60306239985a5b718583923e13316c5417204017b0dadf74bccfcc6e1", size = 681789, upload-time = "2025-08-06T11:31:04.492Z" }, + { url = "https://files.pythonhosted.org/packages/22/fd/2bb9bdf083a6943630762108e3e4e24b83f0571dd39cfa4fd467adaa1921/databricks_sdk-0.63.0-py3-none-any.whl", hash = "sha256:3ea569dcd0a4395c17221a5da39db4da85c6fc91b5fc14546514e329451d5eb3", size = 688018, upload-time = "2025-08-13T09:00:07.071Z" }, ] [[package]] @@ -720,7 +720,7 @@ wheels = [ ] [[package]] -name = "fluidize-python" +name = "fluidize" version = "0.0.2" source = { editable = "." } dependencies = [ @@ -1012,14 +1012,14 @@ wheels = [ [[package]] name = "griffe" -version = "1.11.0" +version = "1.11.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/22/01/4897bb317b347070b73a2f795e38a897ab3b022e020ff2f3ea6bc6a5994b/griffe-1.11.0.tar.gz", hash = "sha256:c153b5bc63ca521f059e9451533a67e44a9d06cf9bf1756e4298bda5bd3262e8", size = 410774, upload-time = "2025-08-07T18:23:36.784Z" } +sdist = { url = "https://files.pythonhosted.org/packages/18/0f/9cbd56eb047de77a4b93d8d4674e70cd19a1ff64d7410651b514a1ed93d5/griffe-1.11.1.tar.gz", hash = "sha256:d54ffad1ec4da9658901eb5521e9cddcdb7a496604f67d8ae71077f03f549b7e", size = 410996, upload-time = "2025-08-11T11:38:35.528Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a7/55/588425bdbe8097b621db813e9b33f0a8a7257771683e0f5369c6c8eb66ab/griffe-1.11.0-py3-none-any.whl", hash = "sha256:dc56cc6af8d322807ecdb484b39838c7a51ca750cf21ccccf890500c4d6389d8", size = 137576, upload-time = "2025-08-07T18:23:34.859Z" }, + { url = "https://files.pythonhosted.org/packages/e6/a3/451ffd422ce143758a39c0290aaa7c9727ecc2bcc19debd7a8f3c6075ce9/griffe-1.11.1-py3-none-any.whl", hash = "sha256:5799cf7c513e4b928cfc6107ee6c4bc4a92e001f07022d97fd8dee2f612b6064", size = 138745, upload-time = "2025-08-11T11:38:33.964Z" }, ] [[package]] @@ -3533,28 +3533,28 @@ wheels = [ [[package]] name = "uv" -version = "0.8.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9c/d0/4cd8ac2c7938da78c8e9ca791205f80e74b0f5a680f2a2d50323d54961d0/uv-0.8.8.tar.gz", hash = "sha256:6880e96cd994e53445d364206ddb4b2fff89fd2fbc74a74bef4a6f86384b07d9", size = 3477036, upload-time = "2025-08-09T00:26:00.883Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/08/d5/49e188db80f3d8b1969bdbcb8a5468a3796827f15d773241204f206a9ff6/uv-0.8.8-py3-none-linux_armv6l.whl", hash = "sha256:fcdbee030de120478db1a4bb3e3bbf04eec572527ea9107ecf064a808259b6c9", size = 18470316, upload-time = "2025-08-09T00:25:11.956Z" }, - { url = "https://files.pythonhosted.org/packages/01/50/add1afadccd141d0d72b54e5146f8181fcc6efd1567a17c5b1edec444010/uv-0.8.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:461e8fb83931755cf0596bf1b8ccbfe02765e81a0d392c495c07685d6b6591f9", size = 18468770, upload-time = "2025-08-09T00:25:15.391Z" }, - { url = "https://files.pythonhosted.org/packages/8c/ac/3c6dc8781d37ef9854f412322caffac2978dd3fa1bf806f7daebcfebf2be/uv-0.8.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:58056e5ccebb0a1aad27bd89d0ccc5b65c086d5a7f6b0ac16a9dde030b63cf14", size = 17200419, upload-time = "2025-08-09T00:25:18.264Z" }, - { url = "https://files.pythonhosted.org/packages/a1/9e/c30ea1f634673d234999985984afbe96c3d2a4381986e36df0bb46c0f21b/uv-0.8.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:5b4c56a620137f562e1d7b09eac6c9d4adeb876aefc51be27973257fcb426c9d", size = 17779351, upload-time = "2025-08-09T00:25:20.891Z" }, - { url = "https://files.pythonhosted.org/packages/2f/89/f2885c6e97a265b4b18050df6285f56c81b603a867a63fcd8f2caa04d95c/uv-0.8.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5fc33adb91c4e3db550648aa30c2b97e8e4d8b8842ead7784a9e76dae3cb14dc", size = 18139292, upload-time = "2025-08-09T00:25:23.352Z" }, - { url = "https://files.pythonhosted.org/packages/38/5f/98dad16987919e7dc02f2566026a263ea6307bf57e8de0008dde4717d9cf/uv-0.8.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:19a82d6738d3aa58e6646b9d6c343d103abf0c4caf97a68d16a8cab55282e4be", size = 18932468, upload-time = "2025-08-09T00:25:25.691Z" }, - { url = "https://files.pythonhosted.org/packages/56/99/52d0d9f53cc5df11b1a459e743bd7b2f4660d49f125a63640eb85ce993e0/uv-0.8.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:9dce4de70098cb5b98feea9ef0b8f7db5d6b9deea003a926bc044a793872d719", size = 20251614, upload-time = "2025-08-09T00:25:28.122Z" }, - { url = "https://files.pythonhosted.org/packages/9e/b1/0698099a905b4a07b8fa9d6838e0680de707216ccf003433ca1b4afff224/uv-0.8.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1038324c178d2d7407a4005c4c3294cbad6a02368ba5a85242308de62a6f4e12", size = 19916222, upload-time = "2025-08-09T00:25:30.732Z" }, - { url = "https://files.pythonhosted.org/packages/7f/29/8384e0f3f3536ef376d94b7ab177753179906a6c2f5bab893e3fb9525b45/uv-0.8.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3bd016beea3935f9148b3d2482e3d60dee36f0260f9e99d4f57acfd978c1142a", size = 19238516, upload-time = "2025-08-09T00:25:33.637Z" }, - { url = "https://files.pythonhosted.org/packages/0e/f1/6c107deccd6e66eb1c46776d8cef4ca9274aac73cec1b14453fe85e18a54/uv-0.8.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0a2b5ebc96aba2b0bf54283d2906b40f32949298cbc6ec48648097ddeac5c5d", size = 19232295, upload-time = "2025-08-09T00:25:37.154Z" }, - { url = "https://files.pythonhosted.org/packages/c5/96/9f5e935cd970102c67ce2a753ac721665fb4477c262e86afa0ab385cefff/uv-0.8.8-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:e529dc0a1be5e896d299e4eae4599fa68909f8cb3e6c5ee1a46f66c9048e3334", size = 18046917, upload-time = "2025-08-09T00:25:39.72Z" }, - { url = "https://files.pythonhosted.org/packages/32/75/97f371add0a02e5e37156ac0fea908ab4a1160fdf716d0e6c257b6767122/uv-0.8.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5d58d986c3b6a9ce0fb48cd48b3aee6cb1b1057f928d598432e75a4fcaa370f4", size = 18949133, upload-time = "2025-08-09T00:25:42.139Z" }, - { url = "https://files.pythonhosted.org/packages/1a/1b/ea988ae9d8c5531454ea6904290e229624c9ea830a5c37b91ec74ebde9a4/uv-0.8.8-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:e117e1230559058fd286292dd5839e8e82d1aaf05763bf4a496e91fe07b69fa1", size = 18080018, upload-time = "2025-08-09T00:25:44.645Z" }, - { url = "https://files.pythonhosted.org/packages/ff/14/3b16af331b79ae826d00a73e98f26f7f660dabedc0f82acb99069601b355/uv-0.8.8-py3-none-musllinux_1_1_i686.whl", hash = "sha256:372934fd94193c98dec59bd379cf39e73f906ae6162cbfb66686f32afd75fa0f", size = 18437896, upload-time = "2025-08-09T00:25:49.162Z" }, - { url = "https://files.pythonhosted.org/packages/1c/b6/c866684da5571dbf42e9a60b6587a62adc8a2eb592f07411d3b29cb09871/uv-0.8.8-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:9330c924faa9df00a5e78b54561ecf4e5eac1211066f027620dbe85bd6f479ce", size = 19341221, upload-time = "2025-08-09T00:25:51.444Z" }, - { url = "https://files.pythonhosted.org/packages/49/ea/55a0eff462b2ec5a6327dd87c401c53306406c830fa8f2cabd2af79dd97f/uv-0.8.8-py3-none-win32.whl", hash = "sha256:65113735aa3427d3897e2f537da1331d1391735c6eecb9b820da6a15fd2f6738", size = 18244601, upload-time = "2025-08-09T00:25:53.696Z" }, - { url = "https://files.pythonhosted.org/packages/bf/c0/f56ddb1b2276405618e3d2522018c962c010fc71f97f385d01b7e1dcd8df/uv-0.8.8-py3-none-win_amd64.whl", hash = "sha256:66189ca0b4051396aa19a6f036351477656073d0fd01618051faca699e1b3cdc", size = 20233481, upload-time = "2025-08-09T00:25:56.247Z" }, - { url = "https://files.pythonhosted.org/packages/ac/1a/70dc4c730c19f3af40be9450b98b801e03cd6d16609743013f7258f69a29/uv-0.8.8-py3-none-win_arm64.whl", hash = "sha256:1d829486e88ebbf7895306ff09a8b6014d3af7a18e27d751979ee37bf3a27832", size = 18786215, upload-time = "2025-08-09T00:25:58.941Z" }, +version = "0.8.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/c8/e8a279be427bc685f5f6ffcaf04ab33e119bc504bd608582325654dc9b28/uv-0.8.10.tar.gz", hash = "sha256:af8a5526b0e331775a264fa0dbccfd53c183cb974f269a208af136d7561f9eb2", size = 3484570, upload-time = "2025-08-13T20:35:24.45Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/00/4605a743cf18a881574442f2c2de7ef5282147f3b51601d0c91e4b6cff6e/uv-0.8.10-py3-none-linux_armv6l.whl", hash = "sha256:9ad21eeaa4156a1bf5ed85903f80db06e2c02badd3a587ba98d3171517960555", size = 18491669, upload-time = "2025-08-13T20:34:35.674Z" }, + { url = "https://files.pythonhosted.org/packages/26/e4/4d5cff7ea2eaa2c8bb8c88fd6937c5fd1e4463bca4232aa4e1ccc4e5f792/uv-0.8.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:defc50bb319be2d58be74a680710cd4b7697e88d5f79974eacd354df95f0b6b0", size = 18535975, upload-time = "2025-08-13T20:34:39.346Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/78f40228077514af4fa459ad9e6270de75fc89a089b3e78764ee54e0406b/uv-0.8.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:88df34c32555064fae459cce665757619fd1af7deb2dc393352b15d909d2d131", size = 17209654, upload-time = "2025-08-13T20:34:41.945Z" }, + { url = "https://files.pythonhosted.org/packages/9b/42/05c4597c98d8e3a08e352e148cb3ded08e2e7bed0eb0bf4ebacc5947a79d/uv-0.8.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:c4a493cd4b15b3aef11523531aff96a77a586666a63e842fa437966b7b7ee62d", size = 17800097, upload-time = "2025-08-13T20:34:44.144Z" }, + { url = "https://files.pythonhosted.org/packages/eb/7e/5225dad966f7333d37c69e02ebebd08f433b988b2b7a16d32a7ce7de1409/uv-0.8.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:86fe044c2be43977566a0d184a487edd7aace2febb757fd95927684b629ef50b", size = 18148771, upload-time = "2025-08-13T20:34:46.229Z" }, + { url = "https://files.pythonhosted.org/packages/90/99/380a607253fa9114d6490837faf56577c3aa3f7627cd221475ff33c847c8/uv-0.8.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4cc190d403a89e46d13cec83b6f8e8d7d07aaf1e5a996eac9a3f0c2a8cd92537", size = 18958576, upload-time = "2025-08-13T20:34:48.318Z" }, + { url = "https://files.pythonhosted.org/packages/a0/81/0b70cf49acb03f0b4d654d947216f9c4f6278adcaf9151b1d631faa5c6a6/uv-0.8.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:57b71dc79eff25a5419d3fe4a563d3b9397f55d789f685ef27f43f033b31f482", size = 20244856, upload-time = "2025-08-13T20:34:50.661Z" }, + { url = "https://files.pythonhosted.org/packages/96/a7/60a16660790065d1e4cf81b9a88450cde6095d0be242a7c8d7ad8ffaf1b6/uv-0.8.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb79a46d8099f563ef58237bf4e9009f876a40145e757ea883a92b24b724d01e", size = 19925999, upload-time = "2025-08-13T20:34:53.248Z" }, + { url = "https://files.pythonhosted.org/packages/57/c9/fdf511b55dbeed7e75811f5d44b2152f2cf977895f7af98584035adb287d/uv-0.8.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:38286d230daad82388469c8dc7a1d2f5dc279c11178319c886d1a88d7938e513", size = 19275418, upload-time = "2025-08-13T20:34:55.589Z" }, + { url = "https://files.pythonhosted.org/packages/e0/48/d3f1edfc5e60e0aec4a994cc3b609a29970cb5c63cf72eeb4795b465da89/uv-0.8.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab072cd3bf2f9dc264659a1ff48ad91a910ac4830bcfe965e2d3f89c86646f46", size = 19256345, upload-time = "2025-08-13T20:34:58.485Z" }, + { url = "https://files.pythonhosted.org/packages/e7/7c/ddc1be8df60a421484a1f15c521618e8e887ea109adf02db281175576487/uv-0.8.10-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:3fdf89fc40af9902141c39ed943bcfca15664623363335eb032a44f22001e2b4", size = 18091725, upload-time = "2025-08-13T20:35:00.661Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c3/f893d6872150ede53be6de0d7167fd2791cad11d83af46856d71ca432b57/uv-0.8.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:36a5ce708d52388c37043e7335f9eb3fea5a19a56166a2cc6adb365179a1cd77", size = 18973295, upload-time = "2025-08-13T20:35:03.289Z" }, + { url = "https://files.pythonhosted.org/packages/a0/43/56c902f8ebd4c13cefe7ff59d8c3ef4be33cb76f3903aed0936c2fc1f15f/uv-0.8.10-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:a5495b5a6e3111c03cf5e4dbdd598bc8fd1da887e3920d58cd5a2d4c8bc9a473", size = 18110100, upload-time = "2025-08-13T20:35:05.458Z" }, + { url = "https://files.pythonhosted.org/packages/0f/d5/44ed1228f930d530fdd013262a8fa6f4be73736f46b43a72d90561517466/uv-0.8.10-py3-none-musllinux_1_1_i686.whl", hash = "sha256:b3ff3c451fcd23ea78356d8c18e802d0e423cbe655273601e3ec039a51b33286", size = 18505545, upload-time = "2025-08-13T20:35:08.156Z" }, + { url = "https://files.pythonhosted.org/packages/63/c5/8ae29f3635b92609c294712a24659ef618c32f51e66d2b52d846a1cb487b/uv-0.8.10-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:31e4fc37ee94b94c032384a0957ad32ba7dce4ce6c04b4880fd3e31e25e51a82", size = 19393427, upload-time = "2025-08-13T20:35:11.806Z" }, + { url = "https://files.pythonhosted.org/packages/23/2c/eba3ae60b8de7062cb727cce0fb30c84e5975e1191f5fb6683b5abf73781/uv-0.8.10-py3-none-win32.whl", hash = "sha256:3e190cee3bb2b4f574a419eef87ae8e33f713e9cd6f856b83277ece70ad9ca9b", size = 18278764, upload-time = "2025-08-13T20:35:15.069Z" }, + { url = "https://files.pythonhosted.org/packages/97/ed/bce1c3833edf701a973535982ee8c38514054a4f5ebf0f69a14f652510b7/uv-0.8.10-py3-none-win_amd64.whl", hash = "sha256:b00637c63d5dfc9f879281c5c91db2bb909ab1f9ab275dab015e7fb6cac6be5b", size = 20267476, upload-time = "2025-08-13T20:35:18.52Z" }, + { url = "https://files.pythonhosted.org/packages/56/56/87859397617fd08ce513efe20f6cd6798bfafc9f675a233892449fd94d14/uv-0.8.10-py3-none-win_arm64.whl", hash = "sha256:e0a02bcec766eb0862b7082ab746b204add7d9fcaa62322502d159b5a7ccc54a", size = 18866639, upload-time = "2025-08-13T20:35:20.993Z" }, ] [[package]] @@ -3574,16 +3574,17 @@ wheels = [ [[package]] name = "virtualenv" -version = "20.33.1" +version = "20.34.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "distlib" }, { name = "filelock" }, { name = "platformdirs" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8b/60/4f20960df6c7b363a18a55ab034c8f2bcd5d9770d1f94f9370ec104c1855/virtualenv-20.33.1.tar.gz", hash = "sha256:1b44478d9e261b3fb8baa5e74a0ca3bc0e05f21aa36167bf9cbf850e542765b8", size = 6082160, upload-time = "2025-08-05T16:10:55.605Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/14/37fcdba2808a6c615681cd216fecae00413c9dab44fb2e57805ecf3eaee3/virtualenv-20.34.0.tar.gz", hash = "sha256:44815b2c9dee7ed86e387b842a84f20b93f7f417f95886ca1996a72a4138eb1a", size = 6003808, upload-time = "2025-08-13T14:24:07.464Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ca/ff/ded57ac5ff40a09e6e198550bab075d780941e0b0f83cbeabd087c59383a/virtualenv-20.33.1-py3-none-any.whl", hash = "sha256:07c19bc66c11acab6a5958b815cbcee30891cd1c2ccf53785a28651a0d8d8a67", size = 6060362, upload-time = "2025-08-05T16:10:52.81Z" }, + { url = "https://files.pythonhosted.org/packages/76/06/04c8e804f813cf972e3262f3f8584c232de64f0cde9f703b46cf53a45090/virtualenv-20.34.0-py3-none-any.whl", hash = "sha256:341f5afa7eee943e4984a9207c025feedd768baff6753cd660c857ceb3e36026", size = 5983279, upload-time = "2025-08-13T14:24:05.111Z" }, ] [[package]] From f397a1b635136856b79c61e36fd631c91c0584d3 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Thu, 14 Aug 2025 15:01:13 -0700 Subject: [PATCH 12/17] Removed unused files --- fluidize/backends/local/graph.py | 156 ------------------------- fluidize/core/utils/dataloader/json.py | 13 --- 2 files changed, 169 deletions(-) delete mode 100644 fluidize/backends/local/graph.py delete mode 100644 fluidize/core/utils/dataloader/json.py diff --git a/fluidize/backends/local/graph.py b/fluidize/backends/local/graph.py deleted file mode 100644 index 196b1cc..0000000 --- a/fluidize/backends/local/graph.py +++ /dev/null @@ -1,156 +0,0 @@ -""" -Local filesystem-based graph backend interface. - -This module provides the local backend interface for graph operations, -wrapping the core GraphProcessor with backend-specific functionality. -""" - -from typing import Optional - -from fluidize.core.modules.graph.processor import GraphProcessor -from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode -from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation -from fluidize.core.types.project import ProjectSummary - - -class GraphHandler: - """ - Local filesystem-based graph processor backend. - - This class provides a clean interface for graph operations using the local backend, - wrapping the core GraphProcessor functionality. - """ - - def __init__(self) -> None: - """Initialize the local graph processor.""" - pass - - def get_graph(self, project: ProjectSummary) -> GraphData: - """ - Get the complete graph for a project. - - Args: - project: The project to get the graph for - - Returns: - GraphData containing all nodes and edges - """ - processor = GraphProcessor(project) - return processor.get_graph() - - def insert_node(self, project: ProjectSummary, node: GraphNode, sim_global: bool = True) -> GraphNode: - """ - Insert a new node into the project graph. - - Args: - project: The project to add the node to - node: The node to insert - sim_global: Whether to use global simulations (placeholder for future) - - Returns: - The inserted node - """ - processor = GraphProcessor(project) - return processor.insert_node(node, sim_global) - - def insert_node_from_scratch( - self, - project: ProjectSummary, - GraphNode: GraphNode, - nodeProperties: nodeProperties_simulation, - nodeMetadata: nodeMetadata_simulation, - repo_link: Optional[str] = None, - ) -> GraphNode: - """ - Insert a new node into the project graph from scratch. - - Args: - project: The project to add the node to - nodeProperties: The properties of the node to insert - sim_global: Whether to use global simulations (placeholder for future) - - Returns: - The inserted node - """ - processor = GraphProcessor(project) - return processor.insert_node_from_scratch(GraphNode, nodeProperties, nodeMetadata, repo_link) - - def update_node_position(self, project: ProjectSummary, node: GraphNode) -> GraphNode: - """ - Update a node's position in the graph. - - Args: - project: The project containing the node - node: The node with updated position - - Returns: - The updated node - """ - processor = GraphProcessor(project) - return processor.update_node_position(node) - - def delete_node(self, project: ProjectSummary, node_id: str) -> None: - """ - Delete a node from the project graph. - - Args: - project: The project containing the node - node_id: ID of the node to delete - """ - processor = GraphProcessor(project) - processor.delete_node(node_id) - - def upsert_edge(self, project: ProjectSummary, edge: GraphEdge) -> GraphEdge: - """ - Add or update an edge in the project graph. - - Args: - project: The project containing the graph - edge: The edge to upsewrt - - Returns: - The upserted edge - """ - processor = GraphProcessor(project) - return processor.upsert_edge(edge) - - def delete_edge(self, project: ProjectSummary, edge_id: str) -> None: - """ - Delete an edge from the project graph. - - Args: - project: The project containing the edge - edge_id: ID of the edge to delete - """ - processor = GraphProcessor(project) - processor.delete_edge(edge_id) - - def ensure_graph_initialized(self, project: ProjectSummary) -> None: - """ - Ensure the project has a graph.json file initialized. - - Args: - project: The project to initialize the graph for - """ - processor = GraphProcessor(project) - processor._ensure_graph_file_exists() - - def show_graph_ascii(self, project: ProjectSummary) -> str: - """ - Get ASCII representation of the project graph. - - Args: - project: The project to visualize - - Returns: - ASCII string representation of the graph - """ - processor = GraphProcessor(project) - graph_data = processor.get_graph() - - # Create Graph model from the data to use ASCII visualization - from fluidize.core.modules.graph.model import Graph - - graph = Graph(nodes=graph_data.nodes, edges=graph_data.edges) - - return graph.to_ascii() diff --git a/fluidize/core/utils/dataloader/json.py b/fluidize/core/utils/dataloader/json.py deleted file mode 100644 index 02dbf0d..0000000 --- a/fluidize/core/utils/dataloader/json.py +++ /dev/null @@ -1,13 +0,0 @@ -import json -from typing import Any - - -def read_json(path: str) -> dict[str, Any]: - with open(path) as f: - data = json.load(f) - return dict(data) - - -def write_local_json(path: str, data: dict[str, Any]) -> None: - with open(path, "w") as f: - json.dump(data, f, indent=2) From bca374b55c966a2ff1cb373f89907ee45086b400 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Thu, 14 Aug 2025 15:01:51 -0700 Subject: [PATCH 13/17] Renamed Project to ProjectManager --- fluidize/managers/project_manager.py | 2 +- fluidize/managers/projects.py | 18 ++++----- tests/integration/test_graph_workflow.py | 6 +-- tests/unit/managers/test_project.py | 20 +++++----- tests/unit/managers/test_projects.py | 50 ++++++++++++------------ tests/unit/test_run_flow_direct.py | 6 +-- 6 files changed, 51 insertions(+), 51 deletions(-) diff --git a/fluidize/managers/project_manager.py b/fluidize/managers/project_manager.py index 21ed9eb..9d2e996 100644 --- a/fluidize/managers/project_manager.py +++ b/fluidize/managers/project_manager.py @@ -10,7 +10,7 @@ from .project_runs import ProjectRuns -class Project: +class ProjectManager: """ Project entity that wraps project data and provides access to scoped managers. diff --git a/fluidize/managers/projects.py b/fluidize/managers/projects.py index db50238..4bf35c1 100644 --- a/fluidize/managers/projects.py +++ b/fluidize/managers/projects.py @@ -1,6 +1,6 @@ from typing import Any, Optional -from .project_manager import Project +from .project_manager import ProjectManager class Projects: @@ -27,7 +27,7 @@ def create( description: str = "", location: str = "", status: str = "", - ) -> Project: + ) -> ProjectManager: """ Create a new project. @@ -48,9 +48,9 @@ def create( location=location, status=status, ) - return Project(self.adapter, project_summary) + return ProjectManager(self.adapter, project_summary) - def get(self, project_id: str) -> Project: + def get(self, project_id: str) -> ProjectManager: """ Get a project by ID. @@ -61,9 +61,9 @@ def get(self, project_id: str) -> Project: Project wrapped in Project class """ project_summary = self.adapter.projects.retrieve(project_id) - return Project(self.adapter, project_summary) + return ProjectManager(self.adapter, project_summary) - def list(self) -> list[Project]: + def list(self) -> list[ProjectManager]: """ List all projects. @@ -71,7 +71,7 @@ def list(self) -> list[Project]: List of projects wrapped in Project class """ project_summaries = self.adapter.projects.list() - return [Project(self.adapter, summary) for summary in project_summaries] + return [ProjectManager(self.adapter, summary) for summary in project_summaries] def update( self, @@ -80,7 +80,7 @@ def update( description: Optional[str] = None, location: Optional[str] = None, status: Optional[str] = None, - ) -> Project: + ) -> ProjectManager: """ Update an existing project. @@ -106,4 +106,4 @@ def update( update_data["status"] = status project_summary = self.adapter.projects.upsert(**update_data) - return Project(self.adapter, project_summary) + return ProjectManager(self.adapter, project_summary) diff --git a/tests/integration/test_graph_workflow.py b/tests/integration/test_graph_workflow.py index 19456e5..13e7ad7 100644 --- a/tests/integration/test_graph_workflow.py +++ b/tests/integration/test_graph_workflow.py @@ -7,7 +7,7 @@ from fluidize import FluidizeClient from fluidize.core.types.graph import GraphNode, Position, graphNodeData -from fluidize.managers.project_manager import Project +from fluidize.managers.project_manager import ProjectManager from tests.fixtures.sample_graphs import SampleGraphs @@ -61,7 +61,7 @@ def test_complete_project_graph_workflow(self, client): description="Testing complete graph workflow", ) - assert isinstance(project, Project) + assert isinstance(project, ProjectManager) assert project.id == "integration-test-project" assert project.label == "Integration Test Project" @@ -356,7 +356,7 @@ def test_project_list_with_graphs(self, client): # Each project should be a Project wrapper with graph access for project in projects_list: - assert isinstance(project, Project) + assert isinstance(project, ProjectManager) assert hasattr(project, "graph") # Each project's graph should have one node diff --git a/tests/unit/managers/test_project.py b/tests/unit/managers/test_project.py index 5d9de1a..82afa94 100644 --- a/tests/unit/managers/test_project.py +++ b/tests/unit/managers/test_project.py @@ -5,7 +5,7 @@ import pytest from fluidize.managers.project_graph import ProjectGraph -from fluidize.managers.project_manager import Project +from fluidize.managers.project_manager import ProjectManager from tests.fixtures.sample_projects import SampleProjects @@ -27,11 +27,11 @@ def sample_project_summary(self): @pytest.fixture def project_wrapper(self, mock_adapter, sample_project_summary): """Create a Project wrapper instance for testing.""" - return Project(mock_adapter, sample_project_summary) + return ProjectManager(mock_adapter, sample_project_summary) def test_init(self, mock_adapter, sample_project_summary): """Test Project wrapper initialization.""" - project = Project(mock_adapter, sample_project_summary) + project = ProjectManager(mock_adapter, sample_project_summary) assert project._adapter is mock_adapter assert project._project_summary is sample_project_summary @@ -97,7 +97,7 @@ def test_created_at_property_with_attribute(self, mock_adapter): project_summary.status = "active" project_summary.created_at = "2024-01-01T00:00:00Z" - project = Project(mock_adapter, project_summary) + project = ProjectManager(mock_adapter, project_summary) assert project.created_at == "2024-01-01T00:00:00Z" @@ -120,7 +120,7 @@ def test_updated_at_property_with_attribute(self, mock_adapter): project_summary.status = "active" project_summary.updated_at = "2024-01-01T12:00:00Z" - project = Project(mock_adapter, project_summary) + project = ProjectManager(mock_adapter, project_summary) assert project.updated_at == "2024-01-01T12:00:00Z" @@ -149,7 +149,7 @@ def test_to_dict_complete_project(self, project_wrapper, sample_project_summary) def test_to_dict_minimal_project(self, mock_adapter): """Test to_dict with minimal project data.""" minimal_summary = SampleProjects.minimal_project() - project = Project(mock_adapter, minimal_summary) + project = ProjectManager(mock_adapter, minimal_summary) result = project.to_dict() @@ -179,7 +179,7 @@ def test_to_dict_with_timestamps(self, mock_adapter): project_summary.created_at = "2024-01-01T00:00:00Z" project_summary.updated_at = "2024-01-01T12:00:00Z" - project = Project(mock_adapter, project_summary) + project = ProjectManager(mock_adapter, project_summary) result = project.to_dict() @@ -195,7 +195,7 @@ def test_repr(self, project_wrapper, sample_project_summary): def test_repr_with_none_label(self, mock_adapter): """Test __repr__ method when label is None.""" minimal_summary = SampleProjects.minimal_project() - project = Project(mock_adapter, minimal_summary) + project = ProjectManager(mock_adapter, minimal_summary) result = repr(project) # Handle case where minimal project might have label=None or no label attribute @@ -212,7 +212,7 @@ def test_str_with_label(self, project_wrapper, sample_project_summary): def test_str_without_label(self, mock_adapter): """Test __str__ method without label.""" minimal_summary = SampleProjects.minimal_project() - project = Project(mock_adapter, minimal_summary) + project = ProjectManager(mock_adapter, minimal_summary) result = str(project) expected = f"Project {minimal_summary.id}: No label" @@ -277,7 +277,7 @@ def test_graph_integration(self, project_wrapper, mock_adapter, sample_project_s def test_wrapper_with_different_project_types(self, mock_adapter, project_fixture): """Test Project wrapper with different types of ProjectSummary objects.""" project_summary = getattr(SampleProjects, project_fixture)() - project = Project(mock_adapter, project_summary) + project = ProjectManager(mock_adapter, project_summary) # Basic functionality should work for all project types assert project.id == project_summary.id diff --git a/tests/unit/managers/test_projects.py b/tests/unit/managers/test_projects.py index 5c48621..6d63018 100644 --- a/tests/unit/managers/test_projects.py +++ b/tests/unit/managers/test_projects.py @@ -31,7 +31,7 @@ def test_init(self, mock_adapter): def test_create_project_with_all_fields(self, projects_manager, mock_adapter): """Test create method with all optional fields.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() mock_adapter.projects.upsert.return_value = sample_project @@ -44,7 +44,7 @@ def test_create_project_with_all_fields(self, projects_manager, mock_adapter): status=sample_project.status, ) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id assert result.label == sample_project.label assert result.description == sample_project.description @@ -60,7 +60,7 @@ def test_create_project_with_all_fields(self, projects_manager, mock_adapter): def test_create_project_minimal(self, projects_manager, mock_adapter): """Test create method with minimal required fields.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager project_id = "minimal-create" minimal_project = SampleProjects.minimal_project() @@ -68,7 +68,7 @@ def test_create_project_minimal(self, projects_manager, mock_adapter): result = projects_manager.create(project_id) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == minimal_project.id assert result.metadata_version == minimal_project.metadata_version mock_adapter.projects.upsert.assert_called_once_with( @@ -77,7 +77,7 @@ def test_create_project_minimal(self, projects_manager, mock_adapter): def test_create_project_partial_fields(self, projects_manager, mock_adapter): """Test create method with some optional fields.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() mock_adapter.projects.upsert.return_value = sample_project @@ -86,7 +86,7 @@ def test_create_project_partial_fields(self, projects_manager, mock_adapter): project_id="partial-create", label="Partial Project", description="Only some fields provided" ) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id="partial-create", @@ -98,7 +98,7 @@ def test_create_project_partial_fields(self, projects_manager, mock_adapter): def test_get_project(self, projects_manager, mock_adapter): """Test get method retrieves project by ID.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() project_id = sample_project.id @@ -106,7 +106,7 @@ def test_get_project(self, projects_manager, mock_adapter): result = projects_manager.get(project_id) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id mock_adapter.projects.retrieve.assert_called_once_with(project_id) @@ -131,7 +131,7 @@ def test_list_projects_empty(self, projects_manager, mock_adapter): def test_list_projects_with_data(self, projects_manager, mock_adapter): """Test list method with multiple projects.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_projects = SampleProjects.projects_for_listing() mock_adapter.projects.list.return_value = sample_projects @@ -141,12 +141,12 @@ def test_list_projects_with_data(self, projects_manager, mock_adapter): assert isinstance(result, list) assert len(result) == 3 for project in result: - assert isinstance(project, Project) + assert isinstance(project, ProjectManager) mock_adapter.projects.list.assert_called_once() def test_update_project_with_all_fields(self, projects_manager, mock_adapter): """Test update method with all optional fields.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() project_id = sample_project.id @@ -162,7 +162,7 @@ def test_update_project_with_all_fields(self, projects_manager, mock_adapter): status=update_data["status"], ) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id=project_id, @@ -174,7 +174,7 @@ def test_update_project_with_all_fields(self, projects_manager, mock_adapter): def test_update_project_partial_fields(self, projects_manager, mock_adapter): """Test update method with only some fields.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() project_id = "update-partial" @@ -184,7 +184,7 @@ def test_update_project_partial_fields(self, projects_manager, mock_adapter): project_id=project_id, label="Updated Label", description="Updated Description" ) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id=project_id, label="Updated Label", description="Updated Description" @@ -192,7 +192,7 @@ def test_update_project_partial_fields(self, projects_manager, mock_adapter): def test_update_project_no_optional_fields(self, projects_manager, mock_adapter): """Test update method with only project_id.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() project_id = "update-id-only" @@ -200,7 +200,7 @@ def test_update_project_no_optional_fields(self, projects_manager, mock_adapter) result = projects_manager.update(project_id=project_id) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with(id=project_id) @@ -215,7 +215,7 @@ def test_update_project_no_optional_fields(self, projects_manager, mock_adapter) ) def test_update_project_single_field(self, projects_manager, mock_adapter, field_name, field_value): """Test update method with individual fields.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() project_id = "single-field-update" @@ -225,7 +225,7 @@ def test_update_project_single_field(self, projects_manager, mock_adapter, field result = projects_manager.update(**kwargs) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id expected_call = {"id": project_id, field_name: field_value} @@ -233,7 +233,7 @@ def test_update_project_single_field(self, projects_manager, mock_adapter, field def test_update_filters_none_values(self, projects_manager, mock_adapter): """Test update method only includes non-None values in update data.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager sample_project = SampleProjects.standard_project() project_id = "filter-none-test" @@ -247,7 +247,7 @@ def test_update_filters_none_values(self, projects_manager, mock_adapter): status=None, # Should be filtered out ) - assert isinstance(result, Project) + assert isinstance(result, ProjectManager) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id=project_id, @@ -318,7 +318,7 @@ def test_manager_interface_compatibility(self, mock_adapter): def test_project_wrapper_return_types(self, mock_adapter): """Test that manager methods return Project wrapper instances.""" - from fluidize.managers.project_manager import Project + from fluidize.managers.project_manager import ProjectManager manager = Projects(mock_adapter) sample_project = SampleProjects.standard_project() @@ -328,24 +328,24 @@ def test_project_wrapper_return_types(self, mock_adapter): # Test create returns Project wrapper created_project = manager.create("test-create") - assert isinstance(created_project, Project) + assert isinstance(created_project, ProjectManager) assert created_project.id == sample_project.id # Test get returns Project wrapper retrieved_project = manager.get("test-get") - assert isinstance(retrieved_project, Project) + assert isinstance(retrieved_project, ProjectManager) assert retrieved_project.id == sample_project.id # Test list returns list of Project wrappers projects_list = manager.list() assert isinstance(projects_list, list) assert len(projects_list) == 1 - assert isinstance(projects_list[0], Project) + assert isinstance(projects_list[0], ProjectManager) assert projects_list[0].id == sample_project.id # Test update returns Project wrapper updated_project = manager.update("test-update", label="New Label") - assert isinstance(updated_project, Project) + assert isinstance(updated_project, ProjectManager) assert updated_project.id == sample_project.id def test_project_wrapper_graph_property_access(self, mock_adapter): diff --git a/tests/unit/test_run_flow_direct.py b/tests/unit/test_run_flow_direct.py index a4d65ca..d3f8461 100644 --- a/tests/unit/test_run_flow_direct.py +++ b/tests/unit/test_run_flow_direct.py @@ -13,7 +13,7 @@ from fluidize.config import FluidizeConfig from fluidize.core.types.project import ProjectSummary from fluidize.core.types.runs import RunFlowPayload -from fluidize.managers.project_manager import Project +from fluidize.managers.project_manager import ProjectManager @pytest.fixture @@ -79,7 +79,7 @@ def local_adapter(test_config): @pytest.fixture def project_manager(local_adapter, project_from_file): """Create a Project manager instance for testing.""" - return Project(local_adapter, project_from_file) + return ProjectManager(local_adapter, project_from_file) class TestRunFlowDirect: @@ -300,7 +300,7 @@ def test_run_flow_empty_graph(self, local_adapter, test_config): # Load project using from_file like the other tests project_summary = ProjectSummary.from_file(empty_project_dir) - project_manager = Project(local_adapter, project_summary) + project_manager = ProjectManager(local_adapter, project_summary) payload = RunFlowPayload(name="empty_graph_test") From bb03199da13c47f7c76df0f77c72cd5763651f7e Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Thu, 14 Aug 2025 22:47:59 -0700 Subject: [PATCH 14/17] Revert "Renamed Project to ProjectManager" This reverts commit bca374b55c966a2ff1cb373f89907ee45086b400. --- fluidize/managers/project_manager.py | 2 +- fluidize/managers/projects.py | 18 ++++----- tests/integration/test_graph_workflow.py | 6 +-- tests/unit/managers/test_project.py | 20 +++++----- tests/unit/managers/test_projects.py | 50 ++++++++++++------------ tests/unit/test_run_flow_direct.py | 6 +-- 6 files changed, 51 insertions(+), 51 deletions(-) diff --git a/fluidize/managers/project_manager.py b/fluidize/managers/project_manager.py index 9d2e996..21ed9eb 100644 --- a/fluidize/managers/project_manager.py +++ b/fluidize/managers/project_manager.py @@ -10,7 +10,7 @@ from .project_runs import ProjectRuns -class ProjectManager: +class Project: """ Project entity that wraps project data and provides access to scoped managers. diff --git a/fluidize/managers/projects.py b/fluidize/managers/projects.py index 4bf35c1..db50238 100644 --- a/fluidize/managers/projects.py +++ b/fluidize/managers/projects.py @@ -1,6 +1,6 @@ from typing import Any, Optional -from .project_manager import ProjectManager +from .project_manager import Project class Projects: @@ -27,7 +27,7 @@ def create( description: str = "", location: str = "", status: str = "", - ) -> ProjectManager: + ) -> Project: """ Create a new project. @@ -48,9 +48,9 @@ def create( location=location, status=status, ) - return ProjectManager(self.adapter, project_summary) + return Project(self.adapter, project_summary) - def get(self, project_id: str) -> ProjectManager: + def get(self, project_id: str) -> Project: """ Get a project by ID. @@ -61,9 +61,9 @@ def get(self, project_id: str) -> ProjectManager: Project wrapped in Project class """ project_summary = self.adapter.projects.retrieve(project_id) - return ProjectManager(self.adapter, project_summary) + return Project(self.adapter, project_summary) - def list(self) -> list[ProjectManager]: + def list(self) -> list[Project]: """ List all projects. @@ -71,7 +71,7 @@ def list(self) -> list[ProjectManager]: List of projects wrapped in Project class """ project_summaries = self.adapter.projects.list() - return [ProjectManager(self.adapter, summary) for summary in project_summaries] + return [Project(self.adapter, summary) for summary in project_summaries] def update( self, @@ -80,7 +80,7 @@ def update( description: Optional[str] = None, location: Optional[str] = None, status: Optional[str] = None, - ) -> ProjectManager: + ) -> Project: """ Update an existing project. @@ -106,4 +106,4 @@ def update( update_data["status"] = status project_summary = self.adapter.projects.upsert(**update_data) - return ProjectManager(self.adapter, project_summary) + return Project(self.adapter, project_summary) diff --git a/tests/integration/test_graph_workflow.py b/tests/integration/test_graph_workflow.py index 13e7ad7..19456e5 100644 --- a/tests/integration/test_graph_workflow.py +++ b/tests/integration/test_graph_workflow.py @@ -7,7 +7,7 @@ from fluidize import FluidizeClient from fluidize.core.types.graph import GraphNode, Position, graphNodeData -from fluidize.managers.project_manager import ProjectManager +from fluidize.managers.project_manager import Project from tests.fixtures.sample_graphs import SampleGraphs @@ -61,7 +61,7 @@ def test_complete_project_graph_workflow(self, client): description="Testing complete graph workflow", ) - assert isinstance(project, ProjectManager) + assert isinstance(project, Project) assert project.id == "integration-test-project" assert project.label == "Integration Test Project" @@ -356,7 +356,7 @@ def test_project_list_with_graphs(self, client): # Each project should be a Project wrapper with graph access for project in projects_list: - assert isinstance(project, ProjectManager) + assert isinstance(project, Project) assert hasattr(project, "graph") # Each project's graph should have one node diff --git a/tests/unit/managers/test_project.py b/tests/unit/managers/test_project.py index 82afa94..5d9de1a 100644 --- a/tests/unit/managers/test_project.py +++ b/tests/unit/managers/test_project.py @@ -5,7 +5,7 @@ import pytest from fluidize.managers.project_graph import ProjectGraph -from fluidize.managers.project_manager import ProjectManager +from fluidize.managers.project_manager import Project from tests.fixtures.sample_projects import SampleProjects @@ -27,11 +27,11 @@ def sample_project_summary(self): @pytest.fixture def project_wrapper(self, mock_adapter, sample_project_summary): """Create a Project wrapper instance for testing.""" - return ProjectManager(mock_adapter, sample_project_summary) + return Project(mock_adapter, sample_project_summary) def test_init(self, mock_adapter, sample_project_summary): """Test Project wrapper initialization.""" - project = ProjectManager(mock_adapter, sample_project_summary) + project = Project(mock_adapter, sample_project_summary) assert project._adapter is mock_adapter assert project._project_summary is sample_project_summary @@ -97,7 +97,7 @@ def test_created_at_property_with_attribute(self, mock_adapter): project_summary.status = "active" project_summary.created_at = "2024-01-01T00:00:00Z" - project = ProjectManager(mock_adapter, project_summary) + project = Project(mock_adapter, project_summary) assert project.created_at == "2024-01-01T00:00:00Z" @@ -120,7 +120,7 @@ def test_updated_at_property_with_attribute(self, mock_adapter): project_summary.status = "active" project_summary.updated_at = "2024-01-01T12:00:00Z" - project = ProjectManager(mock_adapter, project_summary) + project = Project(mock_adapter, project_summary) assert project.updated_at == "2024-01-01T12:00:00Z" @@ -149,7 +149,7 @@ def test_to_dict_complete_project(self, project_wrapper, sample_project_summary) def test_to_dict_minimal_project(self, mock_adapter): """Test to_dict with minimal project data.""" minimal_summary = SampleProjects.minimal_project() - project = ProjectManager(mock_adapter, minimal_summary) + project = Project(mock_adapter, minimal_summary) result = project.to_dict() @@ -179,7 +179,7 @@ def test_to_dict_with_timestamps(self, mock_adapter): project_summary.created_at = "2024-01-01T00:00:00Z" project_summary.updated_at = "2024-01-01T12:00:00Z" - project = ProjectManager(mock_adapter, project_summary) + project = Project(mock_adapter, project_summary) result = project.to_dict() @@ -195,7 +195,7 @@ def test_repr(self, project_wrapper, sample_project_summary): def test_repr_with_none_label(self, mock_adapter): """Test __repr__ method when label is None.""" minimal_summary = SampleProjects.minimal_project() - project = ProjectManager(mock_adapter, minimal_summary) + project = Project(mock_adapter, minimal_summary) result = repr(project) # Handle case where minimal project might have label=None or no label attribute @@ -212,7 +212,7 @@ def test_str_with_label(self, project_wrapper, sample_project_summary): def test_str_without_label(self, mock_adapter): """Test __str__ method without label.""" minimal_summary = SampleProjects.minimal_project() - project = ProjectManager(mock_adapter, minimal_summary) + project = Project(mock_adapter, minimal_summary) result = str(project) expected = f"Project {minimal_summary.id}: No label" @@ -277,7 +277,7 @@ def test_graph_integration(self, project_wrapper, mock_adapter, sample_project_s def test_wrapper_with_different_project_types(self, mock_adapter, project_fixture): """Test Project wrapper with different types of ProjectSummary objects.""" project_summary = getattr(SampleProjects, project_fixture)() - project = ProjectManager(mock_adapter, project_summary) + project = Project(mock_adapter, project_summary) # Basic functionality should work for all project types assert project.id == project_summary.id diff --git a/tests/unit/managers/test_projects.py b/tests/unit/managers/test_projects.py index 6d63018..5c48621 100644 --- a/tests/unit/managers/test_projects.py +++ b/tests/unit/managers/test_projects.py @@ -31,7 +31,7 @@ def test_init(self, mock_adapter): def test_create_project_with_all_fields(self, projects_manager, mock_adapter): """Test create method with all optional fields.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() mock_adapter.projects.upsert.return_value = sample_project @@ -44,7 +44,7 @@ def test_create_project_with_all_fields(self, projects_manager, mock_adapter): status=sample_project.status, ) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id assert result.label == sample_project.label assert result.description == sample_project.description @@ -60,7 +60,7 @@ def test_create_project_with_all_fields(self, projects_manager, mock_adapter): def test_create_project_minimal(self, projects_manager, mock_adapter): """Test create method with minimal required fields.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project project_id = "minimal-create" minimal_project = SampleProjects.minimal_project() @@ -68,7 +68,7 @@ def test_create_project_minimal(self, projects_manager, mock_adapter): result = projects_manager.create(project_id) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == minimal_project.id assert result.metadata_version == minimal_project.metadata_version mock_adapter.projects.upsert.assert_called_once_with( @@ -77,7 +77,7 @@ def test_create_project_minimal(self, projects_manager, mock_adapter): def test_create_project_partial_fields(self, projects_manager, mock_adapter): """Test create method with some optional fields.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() mock_adapter.projects.upsert.return_value = sample_project @@ -86,7 +86,7 @@ def test_create_project_partial_fields(self, projects_manager, mock_adapter): project_id="partial-create", label="Partial Project", description="Only some fields provided" ) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id="partial-create", @@ -98,7 +98,7 @@ def test_create_project_partial_fields(self, projects_manager, mock_adapter): def test_get_project(self, projects_manager, mock_adapter): """Test get method retrieves project by ID.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() project_id = sample_project.id @@ -106,7 +106,7 @@ def test_get_project(self, projects_manager, mock_adapter): result = projects_manager.get(project_id) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id mock_adapter.projects.retrieve.assert_called_once_with(project_id) @@ -131,7 +131,7 @@ def test_list_projects_empty(self, projects_manager, mock_adapter): def test_list_projects_with_data(self, projects_manager, mock_adapter): """Test list method with multiple projects.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_projects = SampleProjects.projects_for_listing() mock_adapter.projects.list.return_value = sample_projects @@ -141,12 +141,12 @@ def test_list_projects_with_data(self, projects_manager, mock_adapter): assert isinstance(result, list) assert len(result) == 3 for project in result: - assert isinstance(project, ProjectManager) + assert isinstance(project, Project) mock_adapter.projects.list.assert_called_once() def test_update_project_with_all_fields(self, projects_manager, mock_adapter): """Test update method with all optional fields.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() project_id = sample_project.id @@ -162,7 +162,7 @@ def test_update_project_with_all_fields(self, projects_manager, mock_adapter): status=update_data["status"], ) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id=project_id, @@ -174,7 +174,7 @@ def test_update_project_with_all_fields(self, projects_manager, mock_adapter): def test_update_project_partial_fields(self, projects_manager, mock_adapter): """Test update method with only some fields.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() project_id = "update-partial" @@ -184,7 +184,7 @@ def test_update_project_partial_fields(self, projects_manager, mock_adapter): project_id=project_id, label="Updated Label", description="Updated Description" ) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id=project_id, label="Updated Label", description="Updated Description" @@ -192,7 +192,7 @@ def test_update_project_partial_fields(self, projects_manager, mock_adapter): def test_update_project_no_optional_fields(self, projects_manager, mock_adapter): """Test update method with only project_id.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() project_id = "update-id-only" @@ -200,7 +200,7 @@ def test_update_project_no_optional_fields(self, projects_manager, mock_adapter) result = projects_manager.update(project_id=project_id) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with(id=project_id) @@ -215,7 +215,7 @@ def test_update_project_no_optional_fields(self, projects_manager, mock_adapter) ) def test_update_project_single_field(self, projects_manager, mock_adapter, field_name, field_value): """Test update method with individual fields.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() project_id = "single-field-update" @@ -225,7 +225,7 @@ def test_update_project_single_field(self, projects_manager, mock_adapter, field result = projects_manager.update(**kwargs) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id expected_call = {"id": project_id, field_name: field_value} @@ -233,7 +233,7 @@ def test_update_project_single_field(self, projects_manager, mock_adapter, field def test_update_filters_none_values(self, projects_manager, mock_adapter): """Test update method only includes non-None values in update data.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project sample_project = SampleProjects.standard_project() project_id = "filter-none-test" @@ -247,7 +247,7 @@ def test_update_filters_none_values(self, projects_manager, mock_adapter): status=None, # Should be filtered out ) - assert isinstance(result, ProjectManager) + assert isinstance(result, Project) assert result.id == sample_project.id mock_adapter.projects.upsert.assert_called_once_with( id=project_id, @@ -318,7 +318,7 @@ def test_manager_interface_compatibility(self, mock_adapter): def test_project_wrapper_return_types(self, mock_adapter): """Test that manager methods return Project wrapper instances.""" - from fluidize.managers.project_manager import ProjectManager + from fluidize.managers.project_manager import Project manager = Projects(mock_adapter) sample_project = SampleProjects.standard_project() @@ -328,24 +328,24 @@ def test_project_wrapper_return_types(self, mock_adapter): # Test create returns Project wrapper created_project = manager.create("test-create") - assert isinstance(created_project, ProjectManager) + assert isinstance(created_project, Project) assert created_project.id == sample_project.id # Test get returns Project wrapper retrieved_project = manager.get("test-get") - assert isinstance(retrieved_project, ProjectManager) + assert isinstance(retrieved_project, Project) assert retrieved_project.id == sample_project.id # Test list returns list of Project wrappers projects_list = manager.list() assert isinstance(projects_list, list) assert len(projects_list) == 1 - assert isinstance(projects_list[0], ProjectManager) + assert isinstance(projects_list[0], Project) assert projects_list[0].id == sample_project.id # Test update returns Project wrapper updated_project = manager.update("test-update", label="New Label") - assert isinstance(updated_project, ProjectManager) + assert isinstance(updated_project, Project) assert updated_project.id == sample_project.id def test_project_wrapper_graph_property_access(self, mock_adapter): diff --git a/tests/unit/test_run_flow_direct.py b/tests/unit/test_run_flow_direct.py index d3f8461..a4d65ca 100644 --- a/tests/unit/test_run_flow_direct.py +++ b/tests/unit/test_run_flow_direct.py @@ -13,7 +13,7 @@ from fluidize.config import FluidizeConfig from fluidize.core.types.project import ProjectSummary from fluidize.core.types.runs import RunFlowPayload -from fluidize.managers.project_manager import ProjectManager +from fluidize.managers.project_manager import Project @pytest.fixture @@ -79,7 +79,7 @@ def local_adapter(test_config): @pytest.fixture def project_manager(local_adapter, project_from_file): """Create a Project manager instance for testing.""" - return ProjectManager(local_adapter, project_from_file) + return Project(local_adapter, project_from_file) class TestRunFlowDirect: @@ -300,7 +300,7 @@ def test_run_flow_empty_graph(self, local_adapter, test_config): # Load project using from_file like the other tests project_summary = ProjectSummary.from_file(empty_project_dir) - project_manager = ProjectManager(local_adapter, project_summary) + project_manager = Project(local_adapter, project_summary) payload = RunFlowPayload(name="empty_graph_test") From 2f4db13b73e70d4615cdcd39a7f42046d8786d6d Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Thu, 14 Aug 2025 22:50:36 -0700 Subject: [PATCH 15/17] Removed project graph and project runs --- fluidize/managers/project_graph.py | 180 ----------------------------- fluidize/managers/project_runs.py | 89 -------------- 2 files changed, 269 deletions(-) delete mode 100644 fluidize/managers/project_graph.py delete mode 100644 fluidize/managers/project_runs.py diff --git a/fluidize/managers/project_graph.py b/fluidize/managers/project_graph.py deleted file mode 100644 index 18be2c7..0000000 --- a/fluidize/managers/project_graph.py +++ /dev/null @@ -1,180 +0,0 @@ -""" -Project-scoped graph manager for user-friendly graph operations. -""" - -from typing import Any, Optional - -from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode -from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation -from fluidize.core.types.parameters import Parameter -from fluidize.core.types.project import ProjectSummary - - -class ProjectGraph: - """ - Graph manager for a specific project. - - Provides graph operations like adding nodes/edges without requiring - project context on each method call. - """ - - def __init__(self, adapter: Any, project: ProjectSummary) -> None: - """ - Initialize project-scoped graph manager. - - Args: - adapter: adapter adapter (FluidizeSDK or Localadapter) - project: The project this graph manager is bound to - """ - self.adapter = adapter - self.project = project - - # Ensure graph is initialized for this project - if hasattr(self.adapter, "graph") and hasattr(self.adapter.graph, "ensure_graph_initialized"): - self.adapter.graph.ensure_graph_initialized(self.project) - - def get(self) -> GraphData: - """ - Get the complete graph for this project. - - Returns: - GraphData containing all nodes and edges for this project - """ - return self.adapter.graph.get_graph(self.project) # type: ignore[no-any-return] - - def add_node(self, node: GraphNode, sim_global: bool = True) -> GraphNode: - """ - Add a new node to this project's graph. - - Args: - node: The node to insert - sim_global: Whether to use global simulations (placeholder for future) - - Returns: - The inserted node - """ - return self.adapter.graph.insert_node(self.project, node, sim_global) # type: ignore[no-any-return] - - def add_node_from_scratch( - self, - node: GraphNode, - node_properties: nodeProperties_simulation, - node_metadata: nodeMetadata_simulation, - repo_link: Optional[str] = None, - ) -> GraphNode: - """ - Add a new node to this project's graph from scratch, creating all necessary files and directories. - - Args: - node: The graph node to insert - node_properties: Properties configuration for the node - node_metadata: Metadata configuration for the node - repo_link: Optional repository URL to clone into the source directory - - Returns: - The inserted node - """ - return self.adapter.graph.insert_node_from_scratch( # type: ignore[no-any-return] - self.project, node, node_properties, node_metadata, repo_link - ) - - def update_node_position(self, node: GraphNode) -> GraphNode: - """ - Update a node's position in this project's graph. - - Args: - node: The node with updated position - - Returns: - The updated node - """ - return self.adapter.graph.update_node_position(self.project, node) # type: ignore[no-any-return] - - def delete_node(self, node_id: str) -> None: - """ - Delete a node from this project's graph. - - Args: - node_id: ID of the node to delete - """ - self.adapter.graph.delete_node(self.project, node_id) - - def add_edge(self, edge: GraphEdge) -> GraphEdge: - """ - Add or update an edge in this project's graph. - - Args: - edge: The edge to upsert - - Returns: - The upserted edge - """ - return self.adapter.graph.upsert_edge(self.project, edge) # type: ignore[no-any-return] - - def delete_edge(self, edge_id: str) -> None: - """ - Delete an edge from this project's graph. - - Args: - edge_id: ID of the edge to delete - """ - self.adapter.graph.delete_edge(self.project, edge_id) - - def show(self) -> str: - """ - Get ASCII visualization of this project's graph. - - Returns: - ASCII string representation of the graph structure - """ - return self.adapter.graph.show_graph_ascii(self.project) # type: ignore[no-any-return] - - def get_parameters(self, node_id: str) -> list[Parameter]: - """ - Get the parameters for a specific node in this project's graph. - - Args: - node_id: ID of the node to retrieve parameters for - - Returns: - A list of Parameter objects for the node - """ - return self.adapter.graph.get_parameters(self.project, node_id) # type: ignore[no-any-return] - - def upsert_parameter(self, node_id: str, parameter: Parameter) -> Parameter: - """ - Upsert a parameter for a specific node in this project's graph. - - Args: - node_id: ID of the node to update parameters for - parameter: The parameter to upsert - - Returns: - The upserted parameter - """ - return self.adapter.graph.upsert_parameter(self.project, node_id, parameter) # type: ignore[no-any-return] - - def set_parameters(self, node_id: str, parameters: list[Parameter]) -> list[Parameter]: - """ - Set all parameters for a specific node in this project's graph, replacing existing ones. - - Args: - node_id: ID of the node to set parameters for - parameters: List of parameters to set - - Returns: - The list of parameters that were set - """ - return self.adapter.graph.set_parameters(self.project, node_id, parameters) # type: ignore[no-any-return] - - def show_parameters(self, node_id: str) -> str: - """ - Get a nicely formatted string display of parameters for a specific node in this project's graph. - - Args: - node_id: ID of the node to retrieve parameters for - - Returns: - A formatted string displaying the parameters - """ - return self.adapter.graph.show_parameters(self.project, node_id) # type: ignore[no-any-return] diff --git a/fluidize/managers/project_runs.py b/fluidize/managers/project_runs.py deleted file mode 100644 index 703da6c..0000000 --- a/fluidize/managers/project_runs.py +++ /dev/null @@ -1,89 +0,0 @@ -""" -Project-scoped runs manager for user-friendly run operations. -""" - -from typing import Any - -from upath import UPath - -from fluidize.core.types.project import ProjectSummary -from fluidize.core.types.runs import RunFlowPayload - - -class ProjectRuns: - """ - Runs manager for a specific project. - - Provides run operations like executing workflows without requiring - project context on each method call. - """ - - def __init__(self, adapter: Any, project: ProjectSummary) -> None: - """ - Initialize project-scoped runs manager. - - Args: - adapter: adapter adapter (FluidizeSDK or Localadapter) - project: The project this runs manager is bound to - """ - self.adapter = adapter - self.project = project - - def run_flow(self, payload: RunFlowPayload) -> dict[str, Any]: - """ - Execute a flow run for this project. - - Args: - payload: Run configuration (name, description, tags) - - Returns: - Dictionary with flow_status and run_number - """ - return self.adapter.runs.run_flow(self.project, payload) # type: ignore[no-any-return] - - def list_runs(self) -> list[str]: - """ - List all runs for this project. - - Returns: - List of run identifiers for this project - """ - return self.adapter.runs.list_runs(self.project) # type: ignore[no-any-return] - - def get_status(self, run_number: int) -> dict[str, Any]: - """ - Get the status of a specific run for this project. - - Args: - run_number: The run number to check - - Returns: - Dictionary with run status information - """ - return self.adapter.runs.get_run_status(self.project, run_number) # type: ignore[no-any-return] - - def list_node_outputs(self, run_number: int, node_id: str) -> list[str]: - """ - List all output files for a specific node in a run for this project. - - Args: - run_number: The run number - node_id: The node ID to list outputs for - - Returns: - List of relative file paths within the node's output directory - """ - return self.adapter.runs.list_node_outputs(self.project, run_number, node_id) # type: ignore[no-any-return] - - def get_output_path(self, run_number: int, node_id: str) -> UPath: - """ - Get the full path to a node's output directory for this project. - - Args: - run_number: The run number - node_id: The node ID - - Returns: - UPath to the node's output directory - """ - return self.adapter.runs.get_output_path(self.project, run_number, node_id) # type: ignore[no-any-return] From 8ba36b2817d49af0f61aadfddd1e50e604c82746 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Thu, 14 Aug 2025 23:00:57 -0700 Subject: [PATCH 16/17] Conflicts Fixed --- fluidize/managers/graph.py | 51 +++++++++++++++++++++++ fluidize/managers/runs.py | 30 ++++++++++++- tests/unit/managers/test_project_graph.py | 4 +- 3 files changed, 82 insertions(+), 3 deletions(-) diff --git a/fluidize/managers/graph.py b/fluidize/managers/graph.py index bcb3e70..1c4292d 100644 --- a/fluidize/managers/graph.py +++ b/fluidize/managers/graph.py @@ -6,6 +6,7 @@ from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation +from fluidize.core.types.parameters import Parameter from fluidize.core.types.project import ProjectSummary @@ -127,3 +128,53 @@ def show(self) -> str: ASCII string representation of the graph structure """ return self.adapter.graph.show_graph_ascii(self.project) # type: ignore[no-any-return] + + def get_parameters(self, node_id: str) -> list[Parameter]: + """ + Get the parameters for a specific node in this project's graph. + + Args: + node_id: ID of the node to retrieve parameters for + + Returns: + A list of Parameter objects for the node + """ + return self.adapter.graph.get_parameters(self.project, node_id) # type: ignore[no-any-return] + + def upsert_parameter(self, node_id: str, parameter: Parameter) -> Parameter: + """ + Upsert a parameter for a specific node in this project's graph. + + Args: + node_id: ID of the node to update parameters for + parameter: The parameter to upsert + + Returns: + The upserted parameter + """ + return self.adapter.graph.upsert_parameter(self.project, node_id, parameter) # type: ignore[no-any-return] + + def set_parameters(self, node_id: str, parameters: list[Parameter]) -> list[Parameter]: + """ + Set all parameters for a specific node in this project's graph, replacing existing ones. + + Args: + node_id: ID of the node to set parameters for + parameters: List of parameters to set + + Returns: + The list of parameters that were set + """ + return self.adapter.graph.set_parameters(self.project, node_id, parameters) # type: ignore[no-any-return] + + def show_parameters(self, node_id: str) -> str: + """ + Get a nicely formatted string display of parameters for a specific node in this project's graph. + + Args: + node_id: ID of the node to retrieve parameters for + + Returns: + A formatted string displaying the parameters + """ + return self.adapter.graph.show_parameters(self.project, node_id) # type: ignore[no-any-return] diff --git a/fluidize/managers/runs.py b/fluidize/managers/runs.py index 856389b..47cbe4a 100644 --- a/fluidize/managers/runs.py +++ b/fluidize/managers/runs.py @@ -4,6 +4,8 @@ from typing import Any +from upath import UPath + from fluidize.core.types.project import ProjectSummary from fluidize.core.types.runs import RunFlowPayload @@ -39,7 +41,7 @@ def run_flow(self, payload: RunFlowPayload) -> dict[str, Any]: """ return self.adapter.runs.run_flow(self.project, payload) # type: ignore[no-any-return] - def list(self) -> list[str]: + def list_runs(self) -> list[str]: """ List all runs for this project. @@ -59,3 +61,29 @@ def get_status(self, run_number: int) -> dict[str, Any]: Dictionary with run status information """ return self.adapter.runs.get_run_status(self.project, run_number) # type: ignore[no-any-return] + + def list_node_outputs(self, run_number: int, node_id: str) -> list[str]: + """ + List all output files for a specific node in a run for this project. + + Args: + run_number: The run number + node_id: The node ID to list outputs for + + Returns: + List of relative file paths within the node's output directory + """ + return self.adapter.runs.list_node_outputs(self.project, run_number, node_id) # type: ignore[no-any-return] + + def get_output_path(self, run_number: int, node_id: str) -> UPath: + """ + Get the full path to a node's output directory for this project. + + Args: + run_number: The run number + node_id: The node ID + + Returns: + UPath to the node's output directory + """ + return self.adapter.runs.get_output_path(self.project, run_number, node_id) # type: ignore[no-any-return] diff --git a/tests/unit/managers/test_project_graph.py b/tests/unit/managers/test_project_graph.py index 9cdc7ab..b419de6 100644 --- a/tests/unit/managers/test_project_graph.py +++ b/tests/unit/managers/test_project_graph.py @@ -462,8 +462,8 @@ def test_parameter_methods_use_correct_project_context(self, mock_adapter): project1 = SampleProjects.standard_project() project2 = SampleProjects.minimal_project() - graph1 = ProjectGraph(mock_adapter, project1) - graph2 = ProjectGraph(mock_adapter, project2) + graph1 = GraphManager(mock_adapter, project1) + graph2 = GraphManager(mock_adapter, project2) parameter = Parameter( name="test_param", value="test_value", type="text", label="Test Parameter", description="A test parameter" From 1ed591482a43976adc77372e30c5213fa4869626 Mon Sep 17 00:00:00 2001 From: Henry Bae <69275685+BaeHenryS@users.noreply.github.com> Date: Fri, 15 Aug 2025 15:38:35 -0700 Subject: [PATCH 17/17] Node Class Added for Easy manipulation of node properties, parameters, metadata --- .../MUJOCO/Mujoco-Simulation/parameters.json | 3 - fluidize/adapters/local/graph.py | 35 +- .../types/file_models/json_file_model_base.py | 106 +++++ .../types/file_models/parameters_model.py | 56 +++ fluidize/core/types/node.py | 13 + fluidize/managers/graph.py | 33 +- fluidize/managers/node.py | 446 ++++++++++++++++++ tests/unit/backends/local/test_graph.py | 195 ++++---- tests/unit/managers/test_node.py | 199 ++++++++ tests/unit/managers/test_project_graph.py | 16 +- 10 files changed, 981 insertions(+), 121 deletions(-) create mode 100644 fluidize/core/types/file_models/json_file_model_base.py create mode 100644 fluidize/core/types/file_models/parameters_model.py create mode 100644 fluidize/managers/node.py create mode 100644 tests/unit/managers/test_node.py diff --git a/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json b/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json index 7940dbc..57b41a6 100644 --- a/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json +++ b/examples/example-projects/MUJOCO/Mujoco-Simulation/parameters.json @@ -8,9 +8,6 @@ "name": "motor_strength", "latex": null, "location": [ - "source/pinata_simulation.py", - "source/pinata_simulation.py", - "source/pinata_simulation.py", "source/pinata_simulation.py" ], "options": null, diff --git a/fluidize/adapters/local/graph.py b/fluidize/adapters/local/graph.py index 0f5aedc..70ea95f 100644 --- a/fluidize/adapters/local/graph.py +++ b/fluidize/adapters/local/graph.py @@ -7,14 +7,11 @@ from typing import Optional -from fluidize.core.modules.graph.parameters import parse_parameters_from_json from fluidize.core.modules.graph.processor import GraphProcessor from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode -from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation +from fluidize.core.types.node import nodeMetadata_simulation, nodeParameters_simulation, nodeProperties_simulation from fluidize.core.types.parameters import Parameter from fluidize.core.types.project import ProjectSummary -from fluidize.core.utils.dataloader.data_loader import DataLoader -from fluidize.core.utils.dataloader.data_writer import DataWriter from fluidize.core.utils.pathfinder.path_finder import PathFinder @@ -171,9 +168,9 @@ def get_parameters(self, project: ProjectSummary, node_id: str) -> list[Paramete Returns: A list of Parameter objects for the node """ - parameters_path = PathFinder.get_node_parameters_path(project, node_id) - data = DataLoader.load_json(parameters_path) - return parse_parameters_from_json(data) + node_path = PathFinder.get_node_path(project, node_id) + parameters_model = nodeParameters_simulation.from_file(node_path) + return parameters_model.parameters def upsert_parameter(self, project: ProjectSummary, node_id: str, parameter: Parameter) -> Parameter: """ @@ -187,12 +184,11 @@ def upsert_parameter(self, project: ProjectSummary, node_id: str, parameter: Par Returns: The upserted parameter """ - parameters_path = PathFinder.get_node_parameters_path(project, node_id) - data = DataLoader.load_json(parameters_path) - params = parse_parameters_from_json(data) + node_path = PathFinder.get_node_path(project, node_id) + parameters_model = nodeParameters_simulation.from_file(node_path) # Check if parameter with same name exists - for p in params: + for p in parameters_model.parameters: if p.name == parameter.name: # Update the existing parameter with new values p.value = parameter.value @@ -211,13 +207,10 @@ def upsert_parameter(self, project: ProjectSummary, node_id: str, parameter: Par break else: # Parameter doesn't exist, add it - params.append(parameter) + parameters_model.parameters.append(parameter) - # Write updated parameters back - DataWriter.write_json( - filepath=parameters_path, - data={"parameters": [p.model_dump() for p in params]}, - ) + # Save updated parameters back + parameters_model.save() return parameter def set_parameters(self, project: ProjectSummary, node_id: str, parameters: list[Parameter]) -> list[Parameter]: @@ -232,10 +225,10 @@ def set_parameters(self, project: ProjectSummary, node_id: str, parameters: list Returns: The list of parameters that were set """ - parameters_path = PathFinder.get_node_parameters_path(project, node_id) - data = {"parameters": [p.model_dump() for p in parameters]} - - DataWriter.write_json(filepath=parameters_path, data=data) + node_path = PathFinder.get_node_path(project, node_id) + parameters_model = nodeParameters_simulation.from_file(node_path) + parameters_model.parameters = parameters + parameters_model.save() return parameters def show_parameters(self, project: ProjectSummary, node_id: str) -> str: diff --git a/fluidize/core/types/file_models/json_file_model_base.py b/fluidize/core/types/file_models/json_file_model_base.py new file mode 100644 index 0000000..b0e8ff2 --- /dev/null +++ b/fluidize/core/types/file_models/json_file_model_base.py @@ -0,0 +1,106 @@ +from __future__ import annotations + +from typing import Any, TypeVar, Union + +from pydantic import BaseModel, ConfigDict, PrivateAttr, ValidationError +from upath import UPath + +T = TypeVar("T", bound="JSONFileModelBase") + + +class JSONFileModelBase(BaseModel): + _filepath: Union[UPath, None] = PrivateAttr(default=None) + + @property + def filepath(self) -> UPath: + """Return the exact path to the model file. Raises if not set.""" + if not self._filepath: + raise ValueError() + return self._filepath + + @property + def directory(self) -> UPath: + """Return the folder containing the model file. Raises if filepath not set.""" + fp = self.filepath + return fp.parent + + @classmethod + def from_file(cls: type[T], directory: Union[str, UPath]) -> T: + from fluidize.core.utils.dataloader.data_loader import DataLoader + + filename = getattr(cls, "_filename", None) + if not filename: + raise TypeError() + + path = UPath(directory) / filename + data = DataLoader.load_json(path) + + if not data: + raise FileNotFoundError() + + try: + instance = cls.model_validate(data) + except ValidationError: + raise + except Exception as e: + raise ValueError() from e + else: + instance._filepath = path + return instance + + @classmethod + def from_dict_and_path(cls: type[T], data: dict, path: UPath) -> T: + """Creates a model instance from a dictionary and a path, without reading the file again.""" + if not data: + raise ValueError() + + try: + instance = cls.model_validate(data) + except ValidationError: + raise + except Exception as e: + raise ValueError() from e + else: + instance._filepath = path + return instance + + def model_dump_wrapped(self) -> dict[str, Any]: + config = getattr(self, "Key", None) + key = getattr(config, "key", None) + + if not key: + return self.model_dump() + + return {key: self.model_dump(mode="json")} + + def save(self, directory: UPath | None = None) -> None: + from fluidize.core.utils.dataloader.data_loader import DataLoader + from fluidize.core.utils.dataloader.data_writer import DataWriter + + if directory: + filename = getattr(self.__class__, "_filename", None) + if not filename: + raise TypeError() + self._filepath = UPath(directory) / filename + + if not self._filepath: + raise ValueError() + + # Load existing data to preserve other keys, if the file already exists. + # Pass a new UPath object to avoid issues with object caching if it's the same file. + existing_data = DataLoader.load_json(UPath(self._filepath)) + + new_data = self.model_dump_wrapped() + existing_data.update(new_data) + + DataWriter.write_json(self._filepath, existing_data) + + def edit(self, **kwargs: Any) -> None: + for key, value in kwargs.items(): + if hasattr(self, key): + setattr(self, key, value) + else: + raise AttributeError() + self.save() + + model_config = ConfigDict(arbitrary_types_allowed=True) diff --git a/fluidize/core/types/file_models/parameters_model.py b/fluidize/core/types/file_models/parameters_model.py new file mode 100644 index 0000000..2c2abd4 --- /dev/null +++ b/fluidize/core/types/file_models/parameters_model.py @@ -0,0 +1,56 @@ +from typing import Any, ClassVar + +from pydantic import Field, model_validator + +from fluidize.core.constants import FileConstants +from fluidize.core.types.parameters import Parameter + +from .json_file_model_base import JSONFileModelBase + + +class ParametersModel(JSONFileModelBase): + _filename: ClassVar[str] = FileConstants.PARAMETERS_SUFFIX + """ + A base model for parameters objects stored in JSON structure. + + This model provides two main functionalities: + 1. A validator to automatically unpack nested data based on a 'key' + from the subclass's Config. + 2. A method to wrap the model's data back into the nested structure + for serialization. + """ + + parameters: list[Parameter] = Field(default_factory=list) + + @model_validator(mode="before") + @classmethod + def _unpack_and_validate(cls, data: Any) -> Any: + """ + Unpacks and validates the data against the key + specified in the subclass's Config. + """ + if not isinstance(data, dict): + return data + + config = getattr(cls, "Key", None) + key = getattr(config, "key", None) + + # If there's no key in the config or the key is not in the data, + # assume the data is already in the correct, unpacked structure. + if not key or key not in data: + return data + + unpacked_data = data[key] + if not isinstance(unpacked_data, list): + # If parameters is not a list, treat it as empty + unpacked_data = [] + + # Return data in the format expected by the model + return {"parameters": unpacked_data} + + def model_dump_wrapped(self) -> dict[str, Any]: + """Override to avoid double wrapping of parameters key.""" + return {"parameters": [p.model_dump() for p in self.parameters]} + + class Key: + key = "parameters" diff --git a/fluidize/core/types/node.py b/fluidize/core/types/node.py index 9e49ce4..15a2d23 100644 --- a/fluidize/core/types/node.py +++ b/fluidize/core/types/node.py @@ -11,6 +11,7 @@ from pydantic import BaseModel, ConfigDict, computed_field from .file_models.metadata_model import MetadataModel +from .file_models.parameters_model import ParametersModel from .file_models.properties_model import PropertiesModel from .runs import RunStatus @@ -95,3 +96,15 @@ class nodeMetadata_simulation(MetadataModel): class Key: key = "simulation" metadata_version = "1.0" + + +class nodeParameters_simulation(ParametersModel): + """ + Parameters configuration for a simulation node. + + Handles loading and saving of parameters.json files with the structure: + {"parameters": [list of Parameter objects]} + """ + + class Key: + key = "parameters" diff --git a/fluidize/managers/graph.py b/fluidize/managers/graph.py index 1c4292d..6e7738f 100644 --- a/fluidize/managers/graph.py +++ b/fluidize/managers/graph.py @@ -2,9 +2,12 @@ Project-scoped graph manager for user-friendly graph operations. """ -from typing import Any, Optional +from typing import TYPE_CHECKING, Any, Optional from fluidize.core.types.graph import GraphData, GraphEdge, GraphNode + +if TYPE_CHECKING: + from .node import NodeManager from fluidize.core.types.node import nodeMetadata_simulation, nodeProperties_simulation from fluidize.core.types.parameters import Parameter from fluidize.core.types.project import ProjectSummary @@ -42,7 +45,21 @@ def get(self) -> GraphData: """ return self.adapter.graph.get_graph(self.project) # type: ignore[no-any-return] - def add_node(self, node: GraphNode, sim_global: bool = True) -> GraphNode: + def get_node(self, node_id: str) -> "NodeManager": + """ + Get a NodeManager for a specific node in the project. + + Args: + node_id: ID of the node to get a manager for + + Returns: + NodeManager instance for the specified node + """ + from .node import NodeManager + + return NodeManager(self.adapter, self.project, node_id) + + def add_node(self, node: GraphNode, sim_global: bool = True) -> "NodeManager": """ Add a new node to this project's graph. @@ -51,9 +68,10 @@ def add_node(self, node: GraphNode, sim_global: bool = True) -> GraphNode: sim_global: Whether to use global simulations (placeholder for future) Returns: - The inserted node + NodeManager for the inserted node """ - return self.adapter.graph.insert_node(self.project, node, sim_global) # type: ignore[no-any-return] + inserted_node = self.adapter.graph.insert_node(self.project, node, sim_global) + return self.get_node(inserted_node.id) def add_node_from_scratch( self, @@ -61,7 +79,7 @@ def add_node_from_scratch( node_properties: nodeProperties_simulation, node_metadata: nodeMetadata_simulation, repo_link: Optional[str] = None, - ) -> GraphNode: + ) -> "NodeManager": """ Add a new node to this project's graph from scratch, creating all necessary files and directories. @@ -72,11 +90,12 @@ def add_node_from_scratch( repo_link: Optional repository URL to clone into the source directory Returns: - The inserted node + NodeManager for the inserted node """ - return self.adapter.graph.insert_node_from_scratch( # type: ignore[no-any-return] + inserted_node = self.adapter.graph.insert_node_from_scratch( self.project, node, node_properties, node_metadata, repo_link ) + return self.get_node(inserted_node.id) def update_node_position(self, node: GraphNode) -> GraphNode: """ diff --git a/fluidize/managers/node.py b/fluidize/managers/node.py new file mode 100644 index 0000000..cef596e --- /dev/null +++ b/fluidize/managers/node.py @@ -0,0 +1,446 @@ +""" +Node-scoped manager for user-friendly node operations. +""" + +from typing import Any, Optional + +from upath import UPath + +from fluidize.core.constants import FileConstants +from fluidize.core.types.graph import GraphNode +from fluidize.core.types.node import nodeMetadata_simulation, nodeParameters_simulation, nodeProperties_simulation +from fluidize.core.types.parameters import Parameter +from fluidize.core.types.project import ProjectSummary +from fluidize.core.utils.pathfinder.path_finder import PathFinder + + +class NodeManager: + """ + Node manager for a specific node within a project. + + Provides node-specific operations like editing parameters, metadata, + and properties without requiring project and node context on each method call. + """ + + def __init__(self, adapter: Any, project: ProjectSummary, node_id: str) -> None: + """ + Initialize node-scoped manager. + + Args: + adapter: adapter adapter (FluidizeSDK or Localadapter) + project: The project this node belongs to + node_id: The ID of the node this manager is bound to + """ + self.adapter = adapter + self.project = project + self.node_id = node_id + + @property + def id(self) -> str: + """ + Get the node ID. + + Returns: + The ID of the node this manager is bound to + """ + return self.node_id + + @property + def data(self) -> Any: + """ + Get the node's data. + + Returns: + The data of the graph node + """ + return self.get_node().data + + def get_node(self) -> GraphNode: + """ + Get the complete graph node data. + + Returns: + GraphNode containing the node data + + Raises: + ValueError: If the node is not found in the project graph + """ + graph = self.adapter.graph.get_graph(self.project) + for node in graph.nodes: + if node.id == self.node_id: + return node # type: ignore[no-any-return] + msg = f"Node with ID '{self.node_id}' not found in project '{self.project.id}'" + raise ValueError(msg) + + def exists(self) -> bool: + """ + Check if this node exists in the project graph. + + Returns: + True if the node exists, False otherwise + """ + try: + self.get_node() + except ValueError: + return False + else: + return True + + def delete(self) -> None: + """ + Delete this node from the project graph and filesystem. + """ + self.adapter.graph.delete_node(self.project, self.node_id) + + def update_position(self, x: float, y: float) -> GraphNode: + """ + Update the node's position in the graph. + + Args: + x: New x coordinate + y: New y coordinate + + Returns: + The updated graph node + """ + node = self.get_node() + node.position.x = x + node.position.y = y + return self.adapter.graph.update_node_position(self.project, node) # type: ignore[no-any-return] + + def get_metadata(self) -> nodeMetadata_simulation: + """ + Get the node's metadata from metadata.yaml. + + Returns: + The node's metadata + + Raises: + FileNotFoundError: If metadata file doesn't exist + ValueError: If metadata file is invalid + """ + node_path = PathFinder.get_node_path(self.project, self.node_id) + return nodeMetadata_simulation.from_file(node_path) + + def update_metadata(self, **kwargs: Any) -> nodeMetadata_simulation: + """ + Update specific fields in the node's metadata. + + Args: + **kwargs: Fields to update (e.g., name="New Name", description="New desc") + + Returns: + The updated metadata + + Raises: + AttributeError: If trying to update a field that doesn't exist + """ + metadata = self.get_metadata() + metadata.edit(**kwargs) + return metadata + + def save_metadata(self, metadata: nodeMetadata_simulation) -> None: + """ + Save metadata object to the node's metadata.yaml file. + + Args: + metadata: The metadata object to save + """ + node_path = PathFinder.get_node_path(self.project, self.node_id) + metadata.save(node_path) + + def get_properties(self) -> nodeProperties_simulation: + """ + Get the node's properties from properties.yaml. + + Returns: + The node's properties + + Raises: + FileNotFoundError: If properties file doesn't exist + ValueError: If properties file is invalid + """ + node_path = PathFinder.get_node_path(self.project, self.node_id) + return nodeProperties_simulation.from_file(node_path) + + def update_properties(self, **kwargs: Any) -> nodeProperties_simulation: + """ + Update specific fields in the node's properties. + + Args: + **kwargs: Fields to update (e.g., container_image="new:tag", should_run=False) + + Returns: + The updated properties + + Raises: + AttributeError: If trying to update a field that doesn't exist + """ + properties = self.get_properties() + properties.edit(**kwargs) + return properties + + def save_properties(self, properties: nodeProperties_simulation) -> None: + """ + Save properties object to the node's properties.yaml file. + + Args: + properties: The properties object to save + """ + node_path = PathFinder.get_node_path(self.project, self.node_id) + properties.save(node_path) + + def get_parameters_model(self) -> nodeParameters_simulation: + """ + Get the node's parameters model from parameters.json. + + Returns: + The node's parameters model + + Raises: + FileNotFoundError: If parameters file doesn't exist + ValueError: If parameters file is invalid + """ + node_path = PathFinder.get_node_path(self.project, self.node_id) + return nodeParameters_simulation.from_file(node_path) + + def get_parameters(self) -> list[Parameter]: + """ + Get the node's parameters list from parameters.json. + + Returns: + List of Parameter objects for the node + """ + return self.get_parameters_model().parameters + + def get_parameter(self, name: str) -> Optional[Parameter]: + """ + Get a specific parameter by name. + + Args: + name: Name of the parameter to retrieve + + Returns: + The parameter if found, None otherwise + """ + parameters = self.get_parameters() + for param in parameters: + if param.name == name: + return param + return None + + def update_parameter(self, parameter: Parameter) -> Parameter: + """ + Update or add a parameter. + + Args: + parameter: The parameter to update/add + + Returns: + The updated parameter + """ + parameters_model = self.get_parameters_model() + + # Check if parameter with same name exists + for p in parameters_model.parameters: + if p.name == parameter.name: + # Update existing parameter + p.value = parameter.value + p.description = parameter.description + p.type = parameter.type + p.label = parameter.label + p.latex = parameter.latex + p.options = parameter.options + p.scope = parameter.scope + # Handle location extension + if parameter.location: + if p.location: + p.location.extend(parameter.location) + else: + p.location = parameter.location + break + else: + # Parameter doesn't exist, add it + parameters_model.parameters.append(parameter) + + parameters_model.save() + return parameter + + def set_parameters(self, parameters: list[Parameter]) -> list[Parameter]: + """ + Replace all parameters with the provided list. + + Args: + parameters: List of parameters to set + W + Returns: + The list of parameters that were set + """ + parameters_model = self.get_parameters_model() + parameters_model.parameters = parameters + parameters_model.save() + return parameters + + def remove_parameter(self, name: str) -> bool: + """ + Remove a parameter by name. + + Args: + name: Name of the parameter to remove + + Returns: + True if parameter was removed, False if it didn't exist + """ + parameters_model = self.get_parameters_model() + original_count = len(parameters_model.parameters) + parameters_model.parameters = [p for p in parameters_model.parameters if p.name != name] + + if len(parameters_model.parameters) < original_count: + parameters_model.save() + return True + return False + + def show_parameters(self) -> str: + """ + Get a formatted string display of all parameters. + + Returns: + A formatted string displaying the parameters + """ + parameters = self.get_parameters() + + if not parameters: + return f"No parameters found for node '{self.node_id}'" + + output = f"Parameters for node '{self.node_id}':\n\n" + + for i, param in enumerate(parameters, 1): + output += f"Parameter {i}:\n" + output += f" Name: {param.name}\n" + output += f" Value: {param.value}\n" + output += f" Description: {param.description}\n" + output += f" Type: {param.type}\n" + output += f" Label: {param.label}\n" + if param.latex: + output += f" LaTeX: {param.latex}\n" + if param.location: + output += f" Location: {param.location}\n" + if param.options: + output += f" Options: {[opt.label for opt in param.options]}\n" + if param.scope: + output += f" Scope: {param.scope}\n" + output += "\n" + + return output + + def get_node_directory(self) -> UPath: + """ + Get the filesystem path to this node's directory. + + Returns: + Path to the node's directory + """ + return PathFinder.get_node_path(self.project, self.node_id) + + def get_metadata_path(self) -> UPath: + """ + Get the filesystem path to this node's metadata.yaml file. + + Returns: + Path to the metadata file + """ + return self.get_node_directory() / FileConstants.METADATA_SUFFIX + + def get_properties_path(self) -> UPath: + """ + Get the filesystem path to this node's properties.yaml file. + + Returns: + Path to the properties file + """ + return PathFinder.get_properties_path(self.project, self.node_id) + + def get_parameters_path(self) -> UPath: + """ + Get the filesystem path to this node's parameters.json file. + + Returns: + Path to the parameters file + """ + return PathFinder.get_node_parameters_path(self.project, self.node_id) + + def validate(self) -> dict[str, Any]: + """ + Validate the node's files and structure. + + Returns: + Dictionary containing validation results with keys: + - 'valid': bool indicating if node is valid + - 'graph_node_exists': bool + - 'metadata_exists': bool + - 'properties_exists': bool + - 'parameters_exists': bool + - 'errors': list of error messages + """ + result: dict[str, Any] = { + "valid": True, + "graph_node_exists": False, + "metadata_exists": False, + "properties_exists": False, + "parameters_exists": False, + "errors": [], + } + + # Check if node exists in graph + try: + self.get_node() + result["graph_node_exists"] = True + except ValueError as e: + result["errors"].append(str(e)) + + # Check metadata file + try: + self.get_metadata() + result["metadata_exists"] = True + except Exception as e: + result["errors"].append(f"Metadata error: {e}") + + # Check properties file + try: + self.get_properties() + result["properties_exists"] = True + except Exception as e: + result["errors"].append(f"Properties error: {e}") + + # Check parameters file + try: + self.get_parameters() + result["parameters_exists"] = True + except Exception as e: + result["errors"].append(f"Parameters error: {e}") + + result["valid"] = len(result["errors"]) == 0 + return result + + def to_dict(self) -> dict[str, Any]: + """ + Convert the complete node information to a dictionary. + + Returns: + Dictionary containing node graph data, metadata, properties, and parameters + """ + try: + return { + "graph_node": self.get_node().model_dump(), + "metadata": self.get_metadata().model_dump(), + "properties": self.get_properties().model_dump(), + "parameters": [p.model_dump() for p in self.get_parameters()], + "paths": { + "node_directory": str(self.get_node_directory()), + "metadata_file": str(self.get_metadata_path()), + "properties_file": str(self.get_properties_path()), + "parameters_file": str(self.get_parameters_path()), + }, + } + except Exception as e: + return {"error": str(e), "node_id": self.node_id, "project": self.project.id} diff --git a/tests/unit/backends/local/test_graph.py b/tests/unit/backends/local/test_graph.py index dfb197b..a61bbab 100644 --- a/tests/unit/backends/local/test_graph.py +++ b/tests/unit/backends/local/test_graph.py @@ -310,31 +310,33 @@ def test_individual_operations(self, sample_project, operation, method_name, arg else: processor_method.assert_called_once() - @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.nodeParameters_simulation") @patch("fluidize.adapters.local.graph.PathFinder") - def test_get_parameters_success(self, mock_pathfinder, mock_dataloader, sample_project): + def test_get_parameters_success(self, mock_pathfinder, mock_node_params, sample_project): """Test successful parameter retrieval.""" # Mock setup mock_parameters_path = Mock() - mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path - mock_dataloader.load_json.return_value = { - "parameters": [ - { - "name": "test_param", - "value": "test_value", - "type": "text", - "label": "Test Parameter", - "description": "A test parameter", - } - ] - } + mock_pathfinder.get_node_path.return_value = mock_parameters_path + + # Mock the parameters model instance + mock_params_instance = Mock() + mock_params_instance.parameters = [ + Parameter( + name="test_param", + value="test_value", + type="text", + label="Test Parameter", + description="A test parameter", + ) + ] + mock_node_params.from_file.return_value = mock_params_instance handler = GraphHandler() result = handler.get_parameters(sample_project, "test-node-id") # Verify calls - mock_pathfinder.get_node_parameters_path.assert_called_once_with(sample_project, "test-node-id") - mock_dataloader.load_json.assert_called_once_with(mock_parameters_path) + mock_pathfinder.get_node_path.assert_called_once_with(sample_project, "test-node-id") + mock_node_params.from_file.assert_called_once_with(mock_parameters_path) # Verify result assert len(result) == 1 @@ -342,16 +344,19 @@ def test_get_parameters_success(self, mock_pathfinder, mock_dataloader, sample_p assert result[0].name == "test_param" assert result[0].value == "test_value" - @patch("fluidize.adapters.local.graph.DataWriter") - @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.nodeParameters_simulation") @patch("fluidize.adapters.local.graph.PathFinder") - def test_upsert_parameter_new_parameter(self, mock_pathfinder, mock_dataloader, mock_datawriter, sample_project): + def test_upsert_parameter_new_parameter(self, mock_pathfinder, mock_node_params, sample_project): """Test upserting a new parameter.""" # Mock setup mock_parameters_path = Mock() - mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path - mock_dataloader.load_json.return_value = {"parameters": []} - mock_datawriter.write_json.return_value = True + mock_pathfinder.get_node_path.return_value = mock_parameters_path + + # Mock the parameters model instance with empty parameters + mock_params_instance = Mock() + mock_params_instance.parameters = [] + mock_node_params.from_file.return_value = mock_params_instance + mock_params_instance.save.return_value = None new_parameter = Parameter( name="new_param", value="new_value", type="text", label="New Parameter", description="A new parameter" @@ -361,41 +366,38 @@ def test_upsert_parameter_new_parameter(self, mock_pathfinder, mock_dataloader, result = handler.upsert_parameter(sample_project, "test-node-id", new_parameter) # Verify calls - mock_pathfinder.get_node_parameters_path.assert_called_once_with(sample_project, "test-node-id") - mock_dataloader.load_json.assert_called_once_with(mock_parameters_path) - mock_datawriter.write_json.assert_called_once() + mock_pathfinder.get_node_path.assert_called_once_with(sample_project, "test-node-id") + mock_node_params.from_file.assert_called_once_with(mock_parameters_path) + mock_params_instance.save.assert_called_once() - # Verify the written data contains the new parameter - written_data = mock_datawriter.write_json.call_args[1]["data"] - assert len(written_data["parameters"]) == 1 - assert written_data["parameters"][0]["name"] == "new_param" + # Verify the parameter was added to the instance + assert len(mock_params_instance.parameters) == 1 + assert mock_params_instance.parameters[0].name == "new_param" # Verify result assert result == new_parameter - @patch("fluidize.adapters.local.graph.DataWriter") - @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.nodeParameters_simulation") @patch("fluidize.adapters.local.graph.PathFinder") - def test_upsert_parameter_existing_parameter( - self, mock_pathfinder, mock_dataloader, mock_datawriter, sample_project - ): + def test_upsert_parameter_existing_parameter(self, mock_pathfinder, mock_node_params, sample_project): """Test upserting an existing parameter extends locations.""" # Mock setup with existing parameter mock_parameters_path = Mock() - mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path - mock_dataloader.load_json.return_value = { - "parameters": [ - { - "name": "existing_param", - "value": "existing_value", - "type": "text", - "label": "Existing Parameter", - "description": "An existing parameter", - "location": ["file1.py"], - } - ] - } - mock_datawriter.write_json.return_value = True + mock_pathfinder.get_node_path.return_value = mock_parameters_path + + # Mock the parameters model instance with existing parameter + existing_param = Parameter( + name="existing_param", + value="existing_value", + type="text", + label="Existing Parameter", + description="An existing parameter", + location=["file1.py"], + ) + mock_params_instance = Mock() + mock_params_instance.parameters = [existing_param] + mock_node_params.from_file.return_value = mock_params_instance + mock_params_instance.save.return_value = None update_parameter = Parameter( name="existing_param", @@ -409,24 +411,32 @@ def test_upsert_parameter_existing_parameter( handler = GraphHandler() result = handler.upsert_parameter(sample_project, "test-node-id", update_parameter) - # Verify the written data extends the location - written_data = mock_datawriter.write_json.call_args[1]["data"] - assert len(written_data["parameters"]) == 1 - param_data = written_data["parameters"][0] - assert param_data["name"] == "existing_param" - assert param_data["location"] == ["file1.py", "file2.py"] + # Verify calls + mock_pathfinder.get_node_path.assert_called_once_with(sample_project, "test-node-id") + mock_node_params.from_file.assert_called_once_with(mock_parameters_path) + mock_params_instance.save.assert_called_once() + + # Verify the parameter location was extended + updated_param = mock_params_instance.parameters[0] + assert updated_param.name == "existing_param" + assert updated_param.location == ["file1.py", "file2.py"] # Verify result assert result == update_parameter - @patch("fluidize.adapters.local.graph.DataWriter") + @patch("fluidize.adapters.local.graph.nodeParameters_simulation") @patch("fluidize.adapters.local.graph.PathFinder") - def test_set_parameters_success(self, mock_pathfinder, mock_datawriter, sample_project): + def test_set_parameters_success(self, mock_pathfinder, mock_node_params, sample_project): """Test setting parameters replaces all existing parameters.""" # Mock setup mock_parameters_path = Mock() - mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path - mock_datawriter.write_json.return_value = True + mock_pathfinder.get_node_path.return_value = mock_parameters_path + + # Mock the parameters model instance + mock_params_instance = Mock() + mock_params_instance.parameters = [] + mock_node_params.from_file.return_value = mock_params_instance + mock_params_instance.save.return_value = None parameters = [ Parameter(name="param1", value="value1", type="text", label="Parameter 1", description="First parameter"), @@ -439,42 +449,49 @@ def test_set_parameters_success(self, mock_pathfinder, mock_datawriter, sample_p result = handler.set_parameters(sample_project, "test-node-id", parameters) # Verify calls - mock_pathfinder.get_node_parameters_path.assert_called_once_with(sample_project, "test-node-id") - mock_datawriter.write_json.assert_called_once() + mock_pathfinder.get_node_path.assert_called_once_with(sample_project, "test-node-id") + mock_node_params.from_file.assert_called_once_with(mock_parameters_path) + mock_params_instance.save.assert_called_once() - # Verify the written data - written_data = mock_datawriter.write_json.call_args[1]["data"] - assert len(written_data["parameters"]) == 2 - assert written_data["parameters"][0]["name"] == "param1" - assert written_data["parameters"][1]["name"] == "param2" + # Verify the parameters were set correctly + assert mock_params_instance.parameters == parameters + assert len(mock_params_instance.parameters) == 2 + assert mock_params_instance.parameters[0].name == "param1" + assert mock_params_instance.parameters[1].name == "param2" # Verify result assert result == parameters - @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.nodeParameters_simulation") @patch("fluidize.adapters.local.graph.PathFinder") - def test_show_parameters_success(self, mock_pathfinder, mock_dataloader, sample_project): + def test_show_parameters_success(self, mock_pathfinder, mock_node_params, sample_project): """Test showing parameters in nice format.""" # Mock setup mock_parameters_path = Mock() - mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path - mock_dataloader.load_json.return_value = { - "parameters": [ - { - "name": "motor_strength", - "value": "20.0", - "type": "text", - "label": "Motor Strength", - "description": "Control signal strength for bat motor", - "scope": "simulation", - "location": ["source/pinata_simulation.py"], - } - ] - } + mock_pathfinder.get_node_path.return_value = mock_parameters_path + + # Mock the parameters model instance with a parameter + mock_params_instance = Mock() + mock_params_instance.parameters = [ + Parameter( + name="motor_strength", + value="20.0", + type="text", + label="Motor Strength", + description="Control signal strength for bat motor", + scope="simulation", + location=["source/pinata_simulation.py"], + ) + ] + mock_node_params.from_file.return_value = mock_params_instance handler = GraphHandler() result = handler.show_parameters(sample_project, "test-node-id") + # Verify calls + mock_pathfinder.get_node_path.assert_called_once_with(sample_project, "test-node-id") + mock_node_params.from_file.assert_called_once_with(mock_parameters_path) + # Verify the formatted output contains expected content assert "Parameters for node 'test-node-id':" in result assert "Name: motor_strength" in result @@ -485,17 +502,25 @@ def test_show_parameters_success(self, mock_pathfinder, mock_dataloader, sample_ assert "Scope: simulation" in result assert "Location: source/pinata_simulation.py" in result - @patch("fluidize.adapters.local.graph.DataLoader") + @patch("fluidize.adapters.local.graph.nodeParameters_simulation") @patch("fluidize.adapters.local.graph.PathFinder") - def test_show_parameters_no_parameters(self, mock_pathfinder, mock_dataloader, sample_project): + def test_show_parameters_no_parameters(self, mock_pathfinder, mock_node_params, sample_project): """Test showing parameters when none exist.""" # Mock setup for empty parameters mock_parameters_path = Mock() - mock_pathfinder.get_node_parameters_path.return_value = mock_parameters_path - mock_dataloader.load_json.return_value = {"parameters": []} + mock_pathfinder.get_node_path.return_value = mock_parameters_path + + # Mock the parameters model instance with empty parameters + mock_params_instance = Mock() + mock_params_instance.parameters = [] + mock_node_params.from_file.return_value = mock_params_instance handler = GraphHandler() result = handler.show_parameters(sample_project, "empty-node-id") + # Verify calls + mock_pathfinder.get_node_path.assert_called_once_with(sample_project, "empty-node-id") + mock_node_params.from_file.assert_called_once_with(mock_parameters_path) + # Verify the no parameters message assert result == "No parameters found for node 'empty-node-id'" diff --git a/tests/unit/managers/test_node.py b/tests/unit/managers/test_node.py new file mode 100644 index 0000000..6b7d906 --- /dev/null +++ b/tests/unit/managers/test_node.py @@ -0,0 +1,199 @@ +"""Unit tests for NodeManager - node-scoped operations.""" + +from unittest.mock import Mock, patch + +import pytest + +from fluidize.core.types.graph import GraphData, GraphNode, Position, graphNodeData +from fluidize.core.types.parameters import Parameter +from fluidize.managers.node import NodeManager +from tests.fixtures.sample_projects import SampleProjects + + +class TestNodeManager: + """Test suite for NodeManager class.""" + + @pytest.fixture + def mock_adapter(self): + """Create a mock adapter with graph handler.""" + adapter = Mock() + adapter.graph = Mock() + return adapter + + @pytest.fixture + def sample_project(self): + """Sample project for testing.""" + return SampleProjects.standard_project() + + @pytest.fixture + def sample_node(self): + """Sample graph node for testing.""" + return GraphNode( + id="test-node-001", + position=Position(x=100.0, y=200.0), + data=graphNodeData(label="Test Node", simulation_id="test-sim-001"), + type="simulation", + ) + + @pytest.fixture + def node_manager(self, mock_adapter, sample_project): + """Create a NodeManager instance for testing.""" + return NodeManager(mock_adapter, sample_project, "test-node-001") + + def test_init(self, mock_adapter, sample_project): + """Test NodeManager initialization.""" + node_manager = NodeManager(mock_adapter, sample_project, "test-node-001") + + assert node_manager.adapter is mock_adapter + assert node_manager.project is sample_project + assert node_manager.node_id == "test-node-001" + + def test_get_node_success(self, node_manager, mock_adapter, sample_node): + """Test successful node retrieval.""" + graph_data = GraphData(nodes=[sample_node], edges=[]) + mock_adapter.graph.get_graph.return_value = graph_data + + result = node_manager.get_node() + + assert result == sample_node + mock_adapter.graph.get_graph.assert_called_once_with(node_manager.project) + + def test_get_node_not_found(self, node_manager, mock_adapter): + """Test node not found error.""" + graph_data = GraphData(nodes=[], edges=[]) + mock_adapter.graph.get_graph.return_value = graph_data + + with pytest.raises(ValueError, match="Node with ID 'test-node-001' not found"): + node_manager.get_node() + + def test_exists_true(self, node_manager, mock_adapter, sample_node): + """Test exists returns True when node exists.""" + graph_data = GraphData(nodes=[sample_node], edges=[]) + mock_adapter.graph.get_graph.return_value = graph_data + + assert node_manager.exists() is True + + def test_exists_false(self, node_manager, mock_adapter): + """Test exists returns False when node doesn't exist.""" + graph_data = GraphData(nodes=[], edges=[]) + mock_adapter.graph.get_graph.return_value = graph_data + + assert node_manager.exists() is False + + def test_delete(self, node_manager, mock_adapter): + """Test node deletion.""" + node_manager.delete() + + mock_adapter.graph.delete_node.assert_called_once_with(node_manager.project, "test-node-001") + + def test_update_position(self, node_manager, mock_adapter, sample_node): + """Test node position update.""" + graph_data = GraphData(nodes=[sample_node], edges=[]) + mock_adapter.graph.get_graph.return_value = graph_data + mock_adapter.graph.update_node_position.return_value = sample_node + + result = node_manager.update_position(300.0, 400.0) + + assert result == sample_node + assert sample_node.position.x == 300.0 + assert sample_node.position.y == 400.0 + mock_adapter.graph.update_node_position.assert_called_once() + + @patch("fluidize.managers.node.nodeMetadata_simulation") + def test_get_metadata(self, mock_metadata_class, node_manager): + """Test getting node metadata.""" + mock_metadata = Mock() + mock_metadata_class.from_file.return_value = mock_metadata + + result = node_manager.get_metadata() + + assert result == mock_metadata + mock_metadata_class.from_file.assert_called_once() + + @patch("fluidize.managers.node.nodeProperties_simulation") + def test_get_properties(self, mock_properties_class, node_manager): + """Test getting node properties.""" + mock_properties = Mock() + mock_properties_class.from_file.return_value = mock_properties + + result = node_manager.get_properties() + + assert result == mock_properties + mock_properties_class.from_file.assert_called_once() + + @patch("fluidize.managers.node.nodeParameters_simulation") + def test_get_parameters_model(self, mock_parameters_class, node_manager): + """Test getting node parameters model.""" + mock_parameters = Mock() + mock_parameters.parameters = [] + mock_parameters_class.from_file.return_value = mock_parameters + + result = node_manager.get_parameters_model() + + assert result == mock_parameters + mock_parameters_class.from_file.assert_called_once() + + @patch("fluidize.managers.node.nodeParameters_simulation") + def test_get_parameters(self, mock_parameters_class, node_manager): + """Test getting node parameters list.""" + mock_parameter = Parameter( + value="test_value", description="Test parameter", type="text", label="Test", name="test_param" + ) + mock_parameters = Mock() + mock_parameters.parameters = [mock_parameter] + mock_parameters_class.from_file.return_value = mock_parameters + + result = node_manager.get_parameters() + + assert result == [mock_parameter] + + def test_get_parameter_found(self, node_manager): + """Test getting a specific parameter by name.""" + mock_parameter = Parameter( + value="test_value", description="Test parameter", type="text", label="Test", name="test_param" + ) + + with patch.object(node_manager, "get_parameters", return_value=[mock_parameter]): + result = node_manager.get_parameter("test_param") + assert result == mock_parameter + + def test_get_parameter_not_found(self, node_manager): + """Test getting a parameter that doesn't exist.""" + with patch.object(node_manager, "get_parameters", return_value=[]): + result = node_manager.get_parameter("nonexistent") + assert result is None + + def test_validate_all_valid(self, node_manager, sample_node): + """Test validation when all components are valid.""" + + with ( + patch.object(node_manager, "get_node", return_value=sample_node), + patch.object(node_manager, "get_metadata"), + patch.object(node_manager, "get_properties"), + patch.object(node_manager, "get_parameters", return_value=[]), + ): + result = node_manager.validate() + + assert result["valid"] is True + assert result["graph_node_exists"] is True + assert result["metadata_exists"] is True + assert result["properties_exists"] is True + assert result["parameters_exists"] is True + assert len(result["errors"]) == 0 + + def test_validate_with_errors(self, node_manager): + """Test validation when there are errors.""" + with ( + patch.object(node_manager, "get_node", side_effect=ValueError("Node not found")), + patch.object(node_manager, "get_metadata", side_effect=FileNotFoundError("Metadata not found")), + patch.object(node_manager, "get_properties"), + patch.object(node_manager, "get_parameters", return_value=[]), + ): + result = node_manager.validate() + + assert result["valid"] is False + assert result["graph_node_exists"] is False + assert result["metadata_exists"] is False + assert len(result["errors"]) == 2 + assert "Node not found" in result["errors"][0] + assert "Metadata error: Metadata not found" in result["errors"][1] diff --git a/tests/unit/managers/test_project_graph.py b/tests/unit/managers/test_project_graph.py index b419de6..f411022 100644 --- a/tests/unit/managers/test_project_graph.py +++ b/tests/unit/managers/test_project_graph.py @@ -9,6 +9,7 @@ from fluidize.core.types.parameters import Parameter from fluidize.core.types.runs import RunStatus from fluidize.managers.graph import GraphManager +from fluidize.managers.node import NodeManager from tests.fixtures.sample_graphs import SampleGraphs from tests.fixtures.sample_projects import SampleProjects @@ -94,7 +95,8 @@ def test_add_node_success(self, project_graph, mock_adapter): result = project_graph.add_node(node) - assert result == node + assert isinstance(result, NodeManager) + assert result.node_id == node.id mock_adapter.graph.insert_node.assert_called_once_with( project_graph.project, node, @@ -108,7 +110,8 @@ def test_add_node_with_sim_global_false(self, project_graph, mock_adapter): result = project_graph.add_node(node, sim_global=False) - assert result == node + assert isinstance(result, NodeManager) + assert result.node_id == node.id mock_adapter.graph.insert_node.assert_called_once_with(project_graph.project, node, False) def test_add_node_from_scratch_success(self, project_graph, mock_adapter): @@ -142,7 +145,8 @@ def test_add_node_from_scratch_success(self, project_graph, mock_adapter): result = project_graph.add_node_from_scratch(node, node_properties, node_metadata) - assert result == node + assert isinstance(result, NodeManager) + assert result.node_id == node.id mock_adapter.graph.insert_node_from_scratch.assert_called_once_with( project_graph.project, node, @@ -175,7 +179,8 @@ def test_add_node_from_scratch_with_repo_link(self, project_graph, mock_adapter) result = project_graph.add_node_from_scratch(node, node_properties, node_metadata, repo_link) - assert result == node + assert isinstance(result, NodeManager) + assert result.node_id == node.id mock_adapter.graph.insert_node_from_scratch.assert_called_once_with( project_graph.project, node, node_properties, node_metadata, repo_link ) @@ -344,7 +349,8 @@ def test_add_node_from_scratch_delegates_to_adapter(self, project_graph, mock_ad result = project_graph.add_node_from_scratch(node, node_properties, node_metadata) - assert result == node + assert isinstance(result, NodeManager) + assert result.node_id == node.id mock_adapter.graph.insert_node_from_scratch.assert_called_once_with( project_graph.project, node, node_properties, node_metadata, None )