From bc65e23753bd7c391991d04ad6466581d7d099e3 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Fri, 10 Oct 2025 16:53:21 +0000 Subject: [PATCH 01/12] init version, lcb works but simple query wont --- .devcontainer/devcontainer.json | 2 +- .openhands/setup.sh | 1 + frontend/public/mockServiceWorker.js | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index c90ff435ca60..8a199f77f88a 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -12,7 +12,7 @@ "ghcr.io/devcontainers/features/node:1": {}, }, "postCreateCommand": ".devcontainer/setup.sh", - "runArgs": ["--add-host=host.docker.internal:host-gateway"], + "runArgs": ["--add-host=host.docker.internal:host-gateway", "--network=host"], "containerEnv": { "DOCKER_HOST_ADDR": "host.docker.internal" }, diff --git a/.openhands/setup.sh b/.openhands/setup.sh index f2c29926d3e4..223f2e3e5e3f 100755 --- a/.openhands/setup.sh +++ b/.openhands/setup.sh @@ -11,3 +11,4 @@ if [ -d ".git" ]; then pre-commit install make install-pre-commit-hooks fi +sudo apt-get update && sudo apt-get install -y tmux diff --git a/frontend/public/mockServiceWorker.js b/frontend/public/mockServiceWorker.js index be4527c7ee5a..723b0714cdef 100644 --- a/frontend/public/mockServiceWorker.js +++ b/frontend/public/mockServiceWorker.js @@ -7,7 +7,7 @@ * - Please do NOT modify this file. */ -const PACKAGE_VERSION = '2.10.4' +const PACKAGE_VERSION = '2.10.5' const INTEGRITY_CHECKSUM = 'f5825c521429caf22a4dd13b66e243af' const IS_MOCKED_RESPONSE = Symbol('isMockedResponse') const activeClientIds = new Set() From 2852a944dea7ceb4dd9698461a389dca6b829122 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Fri, 10 Oct 2025 16:55:18 +0000 Subject: [PATCH 02/12] init add config.toml --- config.toml | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 config.toml diff --git a/config.toml b/config.toml new file mode 100644 index 000000000000..ef3c4ddbf78f --- /dev/null +++ b/config.toml @@ -0,0 +1,48 @@ +[core] +workspace_base="/workspaces" +search_api_key="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" # this is from Step 8 +save_trajectory_path="/workspaces/OpenHands/trajectories.json" +run_as_openhands=false + + +[llm.gptoss-120b] +model="openai/gpt-oss-120b" # openai/ . The will be from litellm config settings. +api_key="serving-on-vllm" +base_url="http://0.0.0.0:14129/" # Port 14129 is the Litellm port that we got from Step 5 +max_input_tokens = 65384 +max_output_tokens = 16384 +max_message_chars = 50000 + +[llm.qwen_coder_30b_small] +model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. +api_key="serving-on-vllm" +base_url="http://0.0.0.0:4000/" +max_input_tokens = 65384 +max_output_tokens = 16384 +max_message_chars = 50000 +native_tool_calling = true + + +[agent] +enable_history_truncation = true +llm_config = "llm.qwen_coder_30b_small" + +[sandbox] +timeout = 120 + +[llm] +model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. +api_key="serving-on-vllm" +base_url="http://0.0.0.0:4000/" +max_input_tokens = 65384 +max_output_tokens = 16384 +max_message_chars = 50000 +native_tool_calling = true + +[condenser.summarizer_for_eval_gptoss-120b] +type = "llm" +llm_config = "qwen_coder_30b_small" # Reference to an LLM config to use for summarization +keep_first = 2 # Number of initial events to always keep +max_size = 100 # Maximum size of history before triggering summarization + + From e42b1fbf55901626b62be1b5761a03c5dc80d00f Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Thu, 16 Oct 2025 23:29:58 +0000 Subject: [PATCH 03/12] reflection sign of life --- config.toml | 4 +- .../agenthub/codeact_agent/codeact_agent.py | 152 ++++++++++++++++-- .../codeact_agent/function_calling.py | 20 ++- .../agenthub/codeact_agent/tools/__init__.py | 3 +- .../agenthub/codeact_agent/tools/think.py | 25 +++ 5 files changed, 188 insertions(+), 16 deletions(-) diff --git a/config.toml b/config.toml index ef3c4ddbf78f..eb99de87f4d4 100644 --- a/config.toml +++ b/config.toml @@ -16,7 +16,7 @@ max_message_chars = 50000 [llm.qwen_coder_30b_small] model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. api_key="serving-on-vllm" -base_url="http://0.0.0.0:4000/" +base_url="http://0.0.0.0:31824/" max_input_tokens = 65384 max_output_tokens = 16384 max_message_chars = 50000 @@ -33,7 +33,7 @@ timeout = 120 [llm] model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. api_key="serving-on-vllm" -base_url="http://0.0.0.0:4000/" +base_url="http://0.0.0.0:31824/" max_input_tokens = 65384 max_output_tokens = 16384 max_message_chars = 50000 diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index f73ff2b6016f..1a4f4822ff5f 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -2,6 +2,9 @@ import sys from collections import deque from typing import TYPE_CHECKING +import random +import re +from dataclasses import dataclass from openhands.llm.llm_registry import LLMRegistry @@ -26,14 +29,14 @@ from openhands.agenthub.codeact_agent.tools.task_tracker import ( create_task_tracker_tool, ) -from openhands.agenthub.codeact_agent.tools.think import ThinkTool +from openhands.agenthub.codeact_agent.tools.think import ThinkTool, ReflectionTool from openhands.controller.agent import Agent from openhands.controller.state.state import State from openhands.core.config import AgentConfig from openhands.core.logger import openhands_logger as logger -from openhands.core.message import Message +from openhands.core.message import Message, TextContent from openhands.events.action import AgentFinishAction, MessageAction -from openhands.events.event import Event +from openhands.events.event import Event, EventSource from openhands.llm.llm_utils import check_tools from openhands.memory.condenser import Condenser from openhands.memory.condenser.condenser import Condensation, View @@ -44,6 +47,30 @@ PluginRequirement, ) from openhands.utils.prompt import PromptManager +from openhands.events.action.agent import AgentThinkAction +from openhands.core.exceptions import ( + FunctionCallNotExistsError, + FunctionCallValidationError, +) + + + +# Optional: in the long run, move this into AgentConfig +@dataclass +class AutoReflectionConfig: + enabled: bool = True + # Probabilistic trigger: after each observation event, fire with probability `prob` + prob: float = 0.50 + # Reactive trigger: check last turn for "no tool" or "error observation" + reactive_enabled: bool = True + # How many past events to consider for the โ€œlast N stepsโ€ wording + lookback_window: int = 3 + # The seeded thought text; {n} is formatted with lookback_window + prompt: str = ( + "Look back at the last {n} steps. Are you making good progress, or should you " + "step back and reconsider your approach? If you're off-track, propose " + "concrete adjustments and the single next best action/tool to try." + ) class CodeActAgent(Agent): @@ -65,6 +92,11 @@ class CodeActAgent(Agent): ![image](https://github.com/All-Hands-AI/OpenHands/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3) + [Cerebras-Only] We want to trigger an autoreflection on 3 cases: + (1) there is a tool parsing problem | This is in the Action space + (2) the observation returned by tool call contains some errors | This is in the Observation space + (3) general check: Probabilistically (say 10% chance) add it after N steps to โ€œLook back at last N steps to see if you are making good progress or should take a step back and reconsider your approachโ€ + """ sandbox_plugins: list[PluginRequirement] = [ @@ -95,6 +127,11 @@ def __init__(self, config: AgentConfig, llm_registry: LLMRegistry) -> None: # Override with router if needed self.llm = self.llm_registry.get_router(self.config) + # NOTE: reflection + self._num_steps = 0 + self._last_reflection_step = -1 + self.auto_reflect = AutoReflectionConfig() + @property def prompt_manager(self) -> PromptManager: if self._prompt_manager is None: @@ -127,6 +164,7 @@ def _get_tools(self) -> list['ChatCompletionToolParam']: tools.append(create_cmd_run_tool(use_short_description=use_short_tool_desc)) if self.config.enable_think: tools.append(ThinkTool) + tools.append(ReflectionTool) if self.config.enable_finish: tools.append(FinishTool) if self.config.enable_condensation_request: @@ -156,6 +194,9 @@ def reset(self) -> None: super().reset() # Only clear pending actions, not LLM metrics self.pending_actions.clear() + # NOTE: reflection + self._num_steps = 0 + self._last_reflection_step = -1 def step(self, state: State) -> 'Action': """Performs one step using the CodeAct Agent. @@ -179,15 +220,6 @@ def step(self, state: State) -> 'Action': - BrowseInteractiveAction(browser_actions) - interact with browser using specified actions - MCPAction(name, arguments) - interact with MCP server tools """ - # Continue with pending actions if any - if self.pending_actions: - return self.pending_actions.popleft() - - # if we're done, go back - latest_user_message = state.get_last_user_message() - if latest_user_message and latest_user_message.content.strip() == '/exit': - return AgentFinishAction() - # Condense the events from the state. If we get a view we'll pass those # to the conversation manager for processing, but if we get a condensation # event we'll just return that instead of an action. The controller will @@ -204,23 +236,71 @@ def step(self, state: State) -> 'Action': f'Processing {len(condensed_history)} events from a total of {len(state.history)} events' ) + # NOTE: reflection case 1: Revisit last observation to catch if there is tool call failures + if self.auto_reflect.enabled: + if self.auto_reflect.reactive_enabled: + is_last_turn_tool_error, tool_call_error_message =self._last_turn_has_tool_error(condensed_history) + if is_last_turn_tool_error and not self._last_event_is_autoreflect(condensed_history): + self.pending_actions.clear() # clear the queue + self._last_reflection_step = self._num_steps + tool_call_reflection_prompt = f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool." + return self._emit_reflection(tool_call_reflection_prompt) + + # NOTE: reflection case 2: Probablistically do general last N step reflection + # Let's do not break any pending actions + # Also make sure the last action was not think + if random.random() < self.auto_reflect.prob and \ + not self.pending_actions and \ + self._last_reflection_step != self._num_steps and \ + not self._last_event_is_autoreflect(condensed_history): + + self._last_reflection_step = self._num_steps + return self._emit_reflection( + self.auto_reflect.prompt.format(n=self.auto_reflect.lookback_window) + ) + + # Continue with pending actions if any + if self.pending_actions: + return self.pending_actions.popleft() + + # if we're done, go back + latest_user_message = state.get_last_user_message() + if latest_user_message and latest_user_message.content.strip() == '/exit': + return AgentFinishAction() + initial_user_message = self._get_initial_user_message(state.history) messages = self._get_messages(condensed_history, initial_user_message) + params: dict = { 'messages': messages, } + params['tools'] = check_tools(self.tools, self.llm.config) params['extra_body'] = { 'metadata': state.to_llm_metadata( model_name=self.llm.config.model, agent_name=self.name ) } + # if self._num_steps > 5: + # breakpoint() + logger.debug(f'Last utterance input to LLM: {messages[-1]}') response = self.llm.completion(**params) logger.debug(f'Response from LLM: {response}') + # try: actions = self.response_to_actions(response) + # NOTE: reflection case 3: cope with tool parse failures + # except Exception as e: + # # Wrong tool parsing will be raised by response_to_actions in function_calling.py + # logger.warning(f"[AutoReflect] Tool-call parse error: {e}. Injecting reflection.") + # self._last_reflection_step = self._num_steps + # return self._emit_reflection( + # f"Malformed tool call (invalid JSON/args):\n```\n{e}\n```\n" + # "Reflect briefly and emit a valid tool call or a better-plan message." + # ) logger.debug(f'Actions after response_to_actions: {actions}') for action in actions: self.pending_actions.append(action) + self._num_steps += 1 return self.pending_actions.popleft() def _get_initial_user_message(self, history: list[Event]) -> MessageAction: @@ -297,3 +377,51 @@ def response_to_actions(self, response: 'ModelResponse') -> list['Action']: response, mcp_tool_names=list(self.mcp_tools.keys()), ) + + + def _last_turn_has_tool_error(self, events: list[Event]) -> tuple[bool, str | None]: + ''' + We want to trigger a reflection on two cases related to tool calling: + (1) there is a tool call parsing problem | This is in the Action space + (2) the observation returned by tool call contains some errors | This is in the Observation space + + In this function we solve (2) + ''' + # Edge case: no events + if not events: + return False, None + + # Make sure we only focus on Observations + if not events[-1].__class__.__name__.lower().endswith("observation"): + return False, None + + # For direct code execution or cmd execution observations + if events[-1].__class__.__name__ in ["IPythonRunCellObservation", "CmdOutputObservation"]: + if events[-1].error: + return True, events[-1].__str__() + + # For other observations + if events[-1].__class__.__name__ == "ErrorObservation": + return True, events[-1].__str__() + + return False, None + + + def _emit_reflection(self, text: str) -> MessageAction: + msg = MessageAction(content=f"[AutoReflect]\n{text}\n Next step: Use `reflection` tool in next turn to do this reflection, no other tools are allowed!") + msg._source = EventSource.AGENT # <-- set source after init + return msg + + def _last_event_is_autoreflect(self, events) -> bool: + # Scan backwards, skip observations; stop on the last action/message. + for ev in reversed(events): + name = ev.__class__.__name__.lower() + if name.endswith("observation"): + continue + if isinstance(ev, MessageAction) and getattr(ev, "_source", None) == EventSource.AGENT: + text = (getattr(ev, "content", "") or "").strip().lower() + return text.startswith("[autoreflect]") + if name.endswith("action"): + # last action but not our autoreflect + return False + return False diff --git a/openhands/agenthub/codeact_agent/function_calling.py b/openhands/agenthub/codeact_agent/function_calling.py index 34875645bdd7..8141afbb63c5 100644 --- a/openhands/agenthub/codeact_agent/function_calling.py +++ b/openhands/agenthub/codeact_agent/function_calling.py @@ -16,6 +16,7 @@ IPythonTool, LLMBasedFileEditTool, ThinkTool, + ReflectionTool, create_cmd_run_tool, create_str_replace_editor_tool, ) @@ -231,7 +232,24 @@ def response_to_actions( # AgentThinkAction # ================================================ elif tool_call.function.name == ThinkTool['function']['name']: - action = AgentThinkAction(thought=arguments.get('thought', '')) + # action = AgentThinkAction(thought=arguments.get('thought', '')) + thought_arg = arguments.get('thought', '') + if thought_arg: + logger.info(f"------ OLD CONTENT: {response.choices[0].message.content}") + content = response.choices[0].message.content or "" + response.choices[0].message.content = f"{content}\nHere's my detailed thought:\n{thought_arg}" + logger.info(f"------ NEW CONTENT: {response.choices[0].message.content}") + action = AgentThinkAction(thought=thought_arg) + + elif tool_call.function.name == ReflectionTool['function']['name']: + # action = AgentThinkAction(thought=arguments.get('thought', '')) + reflection_arg = arguments.get('reflection', '') + if reflection_arg: + logger.info(f"------ OLD CONTENT: {response.choices[0].message.content}") + content = response.choices[0].message.content or "" + response.choices[0].message.content = f"{content}\nHere's my detailed thought:\n{reflection_arg}" + logger.info(f"------ NEW CONTENT: {response.choices[0].message.content}") + action = AgentThinkAction(thought=reflection_arg) # ================================================ # CondensationRequestAction diff --git a/openhands/agenthub/codeact_agent/tools/__init__.py b/openhands/agenthub/codeact_agent/tools/__init__.py index 41e190db2787..258aa3ac81b7 100644 --- a/openhands/agenthub/codeact_agent/tools/__init__.py +++ b/openhands/agenthub/codeact_agent/tools/__init__.py @@ -5,7 +5,7 @@ from .ipython import IPythonTool from .llm_based_edit import LLMBasedFileEditTool from .str_replace_editor import create_str_replace_editor_tool -from .think import ThinkTool +from .think import ThinkTool, ReflectionTool __all__ = [ 'BrowserTool', @@ -16,4 +16,5 @@ 'LLMBasedFileEditTool', 'create_str_replace_editor_tool', 'ThinkTool', + 'ReflectionTool', ] diff --git a/openhands/agenthub/codeact_agent/tools/think.py b/openhands/agenthub/codeact_agent/tools/think.py index 198675801216..b9d6acf459fc 100644 --- a/openhands/agenthub/codeact_agent/tools/think.py +++ b/openhands/agenthub/codeact_agent/tools/think.py @@ -25,3 +25,28 @@ }, ), ) + + +_REFLECTION_DESCRIPTION = """Use the tool to reflect about one or a few previous steps. It will not obtain new information or make any changes to the repository, but just log the reflection. + +Common use cases: +1. After a few rounds of executing commands or code, call this tool to reflect the progress, and assess which change(s) are needed. +2. If you see any execution errors or tool parse issues, call this tool immediately to come up with a plan to fix it +3. After receiving test results, use this tool to brainstorm ways to fix failing tests. + +The tool simply logs your reflection process for better transparency and does not execute any code or make changes.""" + +ReflectionTool = ChatCompletionToolParam( + type='function', + function=ChatCompletionToolParamFunctionChunk( + name='reflection', + description=_REFLECTION_DESCRIPTION, + parameters={ + 'type': 'object', + 'properties': { + 'reflection': {'type': 'string', 'description': 'The reflection to log.'}, + }, + 'required': ['reflection'], + }, + ), +) From 5b64be36a670a82318da0950d7cee70d90da9aa8 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Tue, 21 Oct 2025 15:31:36 +0000 Subject: [PATCH 04/12] more setup for evals --- .devcontainer/devcontainer.json | 11 + clean_docker.sh | 11 + config.toml | 4 +- .../evaluate_trajectory_harsh.py | 491 +++++++++++++++++ .../evaluate_trajectory_harsh_local.py | 502 ++++++++++++++++++ evaluation/benchmarks/swe_bench/run_infer.py | 2 + .../agenthub/codeact_agent/codeact_agent.py | 50 +- 7 files changed, 1046 insertions(+), 25 deletions(-) create mode 100755 clean_docker.sh create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh.py create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 8a199f77f88a..585cb316d15b 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -16,4 +16,15 @@ "containerEnv": { "DOCKER_HOST_ADDR": "host.docker.internal" }, + "mounts": [ + "source=/mlf11-shared/swebench_dockers_for_eval,target=/workspaces/Openhands/swebench_dockers_for_eval,type=bind,consistency=cached" // the Openhands instead of OpenHands is intentional, due to file mounting issues + ], + "customizations": { + "vscode": { + "extensions": [ + "ms-python.python@2024.2.1", // e.g., "ms-python.python@2022.8.1" + "ms-python.vscode-pylance" + ] + } + } } diff --git a/clean_docker.sh b/clean_docker.sh new file mode 100755 index 000000000000..5f1d7432fe97 --- /dev/null +++ b/clean_docker.sh @@ -0,0 +1,11 @@ +# docker images 'ghcr.io/all-hands-ai/runtime' -q | sort -u | \ +# while read -r id; do +# if [ -z "$(docker ps -aq --filter ancestor="$id")" ]; then +# tags=$(docker image inspect "$id" --format '{{join .RepoTags " "}}' 2>/dev/null || true) +# [ -n "$tags" ] && docker rmi $tags +# docker rmi "$id" 2>/dev/null || true +# fi +# done +# docker image prune -f; docker builder prune -f; docker volume prune -f + +docker system prune -a -f --volumes; diff --git a/config.toml b/config.toml index eb99de87f4d4..ef3c4ddbf78f 100644 --- a/config.toml +++ b/config.toml @@ -16,7 +16,7 @@ max_message_chars = 50000 [llm.qwen_coder_30b_small] model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. api_key="serving-on-vllm" -base_url="http://0.0.0.0:31824/" +base_url="http://0.0.0.0:4000/" max_input_tokens = 65384 max_output_tokens = 16384 max_message_chars = 50000 @@ -33,7 +33,7 @@ timeout = 120 [llm] model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. api_key="serving-on-vllm" -base_url="http://0.0.0.0:31824/" +base_url="http://0.0.0.0:4000/" max_input_tokens = 65384 max_output_tokens = 16384 max_message_chars = 50000 diff --git a/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh.py b/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh.py new file mode 100644 index 000000000000..74dd93ef78a2 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh.py @@ -0,0 +1,491 @@ +#!/usr/bin/env python3 +""" +Python equivalent of the bash script for running SWE-bench evaluations. +Handles Docker image loading, evaluation execution, error logging, and consolidated reporting. +""" + +import argparse +import subprocess +import json +import os +import sys +import logging +from pathlib import Path +from datetime import datetime +from typing import Dict, List, Optional +import re + + +class SWEBenchEvaluator: + def __init__(self, run_id: str, predictions_path: str, output_dir: str = "output"): + self.run_id = run_id + self.predictions_path = predictions_path + self.output_dir = Path(output_dir) + # self.docker_image_dir = "/mlf3-shared/sapankumars/swe_docker_images" + self.docker_image_dir = "/mlf11-shared/swebench_dockers/dev/docker_images" + self.instance_ids_file = "/mlf-transfers-only/srinjoym/coding_agent_eval/50_problems_eval/problem_list.txt" + + # Create output directory if it doesn't exist + self.output_dir.mkdir(parents=True, exist_ok=True) + + # Setup logging + self.setup_logging() + + # Results tracking + self.results = [] + self.consolidated_stats = { + "total_instances": 0, + "successful_loads": 0, + "failed_loads": 0, + "missing_docker_images": 0, + "successful_evals": 0, + "failed_evals": 0, + "skipped_evals": 0, + "start_time": datetime.now().isoformat(), + "end_time": None + } + + # SWE-bench evaluation stats (consolidated across all instances) + self.swe_bench_stats = { + "total_instances": 0, + "instances_submitted": 0, + "instances_completed": 0, + "instances_incomplete": 0, + "instances_resolved": 0, + "instances_unresolved": 0, + "instances_with_empty_patches": 0, + "instances_with_errors": 0, + "unstopped_containers": 0, + "unremoved_images": 0, + "completed_ids":[], + "incomplete_ids":[], + "resolved_ids":[], + "unresolved_ids":[], + "error_ids": [], + "empty_patch_ids": [], + "submitted_ids": [] + } + + + def setup_logging(self): + """Setup logging configuration""" + # Create logs subdirectory in output directory + log_dir = self.output_dir / "logs" + log_dir.mkdir(exist_ok=True) + + # Generate timestamp for file naming + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + + # Main log file + log_file = log_dir / f"swe_bench_eval_{self.run_id}_{timestamp}.log" + + logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler(log_file), + logging.StreamHandler(sys.stdout) + ] + ) + self.logger = logging.getLogger(__name__) + + # JSONL results file + self.results_file = log_dir / f"swe_bench_results_{self.run_id}_{timestamp}.jsonl" + self.logger.info(f"Output directory: {self.output_dir.absolute()}") + self.logger.info(f"Log file: {log_file}") + self.logger.info(f"Results file: {self.results_file}") + + def load_instance_ids(self) -> List[str]: + """Load instance IDs from the specified file""" + try: + instance_ids = [] + with open(self.predictions_path, 'r') as f: + for line in f: + if line.strip(): + try: + data = json.loads(line) + if "instance_id" in data: + self.logger.info(f"Found instance_id in predictions: {data['instance_id']}") + instance_ids.append(data['instance_id']) + except json.JSONDecodeError: + self.logger.warning(f"Invalid JSON line in predictions file: {line.strip()}") + + + self.logger.info(f"Loaded {len(instance_ids)} instance IDs from {self.instance_ids_file}") + return instance_ids + except FileNotFoundError: + self.logger.error(f"Instance IDs file not found: {self.instance_ids_file}") + sys.exit(1) + except Exception as e: + self.logger.error(f"Error reading instance IDs file: {e}") + sys.exit(1) + + def load_docker_image(self, instance_id: str) -> tuple[bool, str]: + """ + Load Docker image for the given SWE-bench instance ID. + + Strategy: + 1. Try loading from main tarball directory. + 2. If not found, try fallback directory (e.g., downloaded previously). + 3. If still not found, try pulling from DockerHub with prefetch-style name. + """ + base_tarfile_path = Path(self.docker_image_dir) / f"{instance_id}__latest.tar" + fallback_dir = Path(self.docker_image_dir) / "harshg" + fallback_dir.mkdir(parents=True, exist_ok=True) + fallback_tarfile_path = fallback_dir / f"{instance_id}__latest.tar" + + def try_docker_load(path: Path) -> tuple[bool, str]: + """Helper to run docker load from a tar file.""" + self.logger.info(f"๐Ÿ“ฆ Attempting to load Docker image from: {path}") + result = subprocess.run( + ["docker", "load", "-i", str(path)], + capture_output=True, + text=True, + timeout=300 + ) + if result.returncode == 0: + self.logger.info(f"โœ… Successfully loaded Docker image for {instance_id}") + return True, "Success" + else: + self.logger.warning(f"โš ๏ธ Docker load failed for {instance_id} from {path}: {result.stderr.strip()}") + return False, result.stderr.strip() + + # --- Step 1: Try loading from main tar folder --- + if base_tarfile_path.exists(): + ok, msg = try_docker_load(base_tarfile_path) + if ok: + return True, msg + + # --- Step 2: Try loading from fallback folder --- + if fallback_tarfile_path.exists(): + self.logger.info(f"๐Ÿ” Checking fallback folder for pre-downloaded image: {fallback_tarfile_path}") + ok, msg = try_docker_load(fallback_tarfile_path) + if ok: + return True, msg + else: + self.logger.warning(f"โš ๏ธ Loading from fallback folder failed: {msg}") + + # --- Step 3: Pull from DockerHub (prefetch naming) --- + repo1 = instance_id.split("__")[0] + repo2 = instance_id.split("__")[1] if "__" in instance_id else "" + dockerhub_image = f"swebench/sweb.eval.x86_64.{repo1}_1776_{repo2}:latest" + + self.logger.info(f"๐ŸŒ Attempting to pull image from DockerHub: {dockerhub_image}") + pull_result = subprocess.run( + ["docker", "pull", dockerhub_image], + capture_output=True, + text=True + ) + + if pull_result.returncode == 0: + self.logger.info(f"โœ… Pulled image {dockerhub_image} from DockerHub. Saving locally to fallback...") + save_result = subprocess.run( + ["docker", "save", "-o", str(fallback_tarfile_path), dockerhub_image], + capture_output=True, + text=True + ) + if save_result.returncode == 0: + subprocess.run(["chmod", "777", str(fallback_tarfile_path)], check=False) + self.logger.info(f"โœ… Saved pulled image to {fallback_tarfile_path}") + subprocess.run(["docker", "rmi", dockerhub_image], capture_output=True, text=True) + return try_docker_load(fallback_tarfile_path) + else: + error_msg = f"โŒ Docker save failed: {save_result.stderr.strip()}" + self.logger.error(error_msg) + return False, error_msg + else: + error_msg = f"โŒ Docker pull failed: {pull_result.stderr.strip()}" + self.logger.error(error_msg) + return False, error_msg + + def run_evaluation(self, instance_id: str) -> Dict: + """Run SWE-bench evaluation for the given instance ID""" + # cmd = [ + # "python", "-m", "swebench.harness.run_evaluation", + # "--dataset_name", "princeton-nlp/SWE-bench_Verified", + # "--max_workers", "15", + # "--cache_level", "none", + # "--clean", "True", + # "--predictions_path", self.predictions_path, + # "--run_id", self.run_id, + # "--instance_ids", instance_id + # ] + + cmd = [ + "python", "-m", "swebench.harness.run_evaluation", + "--dataset_name", "princeton-nlp/SWE-bench", + "--max_workers", "15", + "--cache_level", "none", + "--clean", "True", + "--predictions_path", self.predictions_path, + "--run_id", self.run_id, + "--instance_ids", instance_id, + "--split", "dev" + ] + + self.logger.info(f"Running evaluation for {instance_id}") + + try: + result = subprocess.run( + cmd, + capture_output=True, + text=True, + timeout=3600 # 1 hour timeout + ) + + # Parse evaluation output + eval_result = self.parse_evaluation_output(instance_id, result.stdout, result.stderr, result.returncode) + eval_result["instance_id"] = instance_id + eval_result["command"] = " ".join(cmd) + + if result.returncode == 0: + self.logger.info(f"Evaluation completed successfully for {instance_id}") + eval_result["status"] = "success" + else: + self.logger.error(f"Evaluation failed for {instance_id}: {result.stderr}") + eval_result["status"] = "failed" + + return eval_result + + except subprocess.TimeoutExpired: + self.logger.error(f"Evaluation timed out for {instance_id}") + return { + "instance_id": instance_id, + "status": "timeout", + "error": "Evaluation timed out after 1 hour" + } + except Exception as e: + self.logger.error(f"Exception during evaluation for {instance_id}: {e}") + return { + "instance_id": instance_id, + "status": "error", + "error": str(e) + } + + def parse_evaluation_output(self, instance_id: str, stdout: str, stderr: str, return_code: int) -> Dict: + """Parse the evaluation output to extract relevant information""" + result = { + "stdout": stdout, + "stderr": stderr, + "return_code": return_code, + "total_instances": 0, + "instances_submitted": 0, + "instances_completed": 0, + "instances_incomplete": 0, + "instances_resolved": 0, + "instances_unresolved": 0, + "instances_with_empty_patches": 0, + "instances_with_errors": 0, + "unstopped_containers": 0, + "unremoved_images": 0, + "report_file": None + } + + # Extract statistics from stdout + if stdout: + # Define all the patterns to match + patterns = { + "total_instances": r'Total instances: (\d+)', + "instances_submitted": r'Instances submitted: (\d+)', + "instances_completed": r'Instances completed: (\d+)', + "instances_incomplete": r'Instances incomplete: (\d+)', + "instances_resolved": r'Instances resolved: (\d+)', + "instances_unresolved": r'Instances unresolved: (\d+)', + "instances_with_empty_patches": r'Instances with empty patches: (\d+)', + "instances_with_errors": r'Instances with errors: (\d+)', + "unstopped_containers": r'Unstopped containers: (\d+)', + "unremoved_images": r'Unremoved images: (\d+)' + } + + # Extract values using regex patterns + for key, pattern in patterns.items(): + match = re.search(pattern, stdout) + if match: + result[key] = int(match.group(1)) + + if key == "instances_completed" and int(match.group(1)) > 0: + self.swe_bench_stats["completed_ids"].append(instance_id) + elif key == "instances_incomplete" and int(match.group(1)) > 0: + self.swe_bench_stats["incomplete_ids"].append(instance_id) + elif key == "instances_resolved" and int(match.group(1)) > 0: + self.swe_bench_stats["resolved_ids"].append(instance_id) + elif key == "instances_unresolved" and int(match.group(1)) > 0: + self.swe_bench_stats["unresolved_ids"].append(instance_id) + elif key == "instances_with_errors" and int(match.group(1)) > 0: + self.swe_bench_stats["error_ids"].append(instance_id) + elif key == "instances_with_empty_patches" and int(match.group(1)) > 0: + self.swe_bench_stats["empty_patch_ids"].append(instance_id) + elif key == "instances_submitted" and int(match.group(1)) > 0: + self.swe_bench_stats["submitted_ids"].append(instance_id) + + # Extract report file name + report_match = re.search(r'Report written to (.+\.json)', stdout) + if report_match: + result["report_file"] = report_match.group(1).strip() + + return result + + def log_instance_result(self, instance_id: str, docker_load_success: bool, docker_error: Optional[str], eval_result: Optional[Dict]): + """Log the result for a single instance to JSONL file""" + log_entry = { + "instance_id": instance_id, + "timestamp": datetime.now().isoformat(), + "docker_load_success": docker_load_success, + "docker_load_error": docker_error if not docker_load_success else None, + "evaluation_result": eval_result + } + + with open(self.results_file, 'a') as f: + f.write(json.dumps(log_entry) + '\n') + + self.results.append(log_entry) + + def update_consolidated_stats(self, docker_load_success: bool, docker_error: Optional[str], eval_result: Optional[Dict]): + """Update consolidated statistics""" + self.consolidated_stats["total_instances"] += 1 + + if docker_load_success: + self.consolidated_stats["successful_loads"] += 1 + else: + self.consolidated_stats["failed_loads"] += 1 + # Check if it's specifically a missing Docker image + if docker_error and "Docker image tar not found" in docker_error: + self.consolidated_stats["missing_docker_images"] += 1 + + if eval_result: + if eval_result.get("status") == "success": + self.consolidated_stats["successful_evals"] += 1 + + # Aggregate SWE-bench specific stats + swe_stats_keys = [ + "total_instances", "instances_submitted", "instances_completed", + "instances_incomplete", "instances_resolved", "instances_unresolved", + "instances_with_empty_patches", "instances_with_errors", + "unstopped_containers", "unremoved_images" + ] + + for key in swe_stats_keys: + if key in eval_result: + self.swe_bench_stats[key] += eval_result[key] + + else: + self.consolidated_stats["failed_evals"] += 1 + else: + # Evaluation was skipped (likely due to Docker load failure) + self.consolidated_stats["skipped_evals"] += 1 + + def process_instance(self, instance_id: str): + """Process a single instance: load Docker image and run evaluation""" + self.logger.info(f"Processing task: instance_id={instance_id}") + + # Load Docker image + docker_load_success, docker_error = self.load_docker_image(instance_id) + eval_result = None + + if docker_load_success: + # Run evaluation + eval_result = self.run_evaluation(instance_id) + else: + self.logger.warning(f"Skipping evaluation for {instance_id} due to Docker load failure: {docker_error}") + + # Log results + self.log_instance_result(instance_id, docker_load_success, docker_error, eval_result) + self.update_consolidated_stats(docker_load_success, docker_error, eval_result) + + def generate_consolidated_report(self): + """Generate a consolidated report of all evaluations""" + self.consolidated_stats["end_time"] = datetime.now().isoformat() + + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + report_file = self.output_dir / f"consolidated_report_{self.run_id}_{timestamp}.json" + + report = { + "run_id": self.run_id, + "predictions_path": self.predictions_path, + "output_directory": str(self.output_dir.absolute()), + "execution_statistics": self.consolidated_stats, + "swe_bench_statistics": self.swe_bench_stats, + "detailed_results": self.results + } + + with open(report_file, 'w') as f: + json.dump(report, f, indent=2) + + self.logger.info(f"Consolidated report written to {report_file}") + + # Print execution summary + stats = self.consolidated_stats + self.logger.info("=== EXECUTION SUMMARY ===") + self.logger.info(f"Total instances processed: {stats['total_instances']}") + self.logger.info(f"Successful Docker loads: {stats['successful_loads']}") + self.logger.info(f"Failed Docker loads: {stats['failed_loads']}") + self.logger.info(f"Missing Docker images: {stats['missing_docker_images']}") + self.logger.info(f"Successful evaluations: {stats['successful_evals']}") + self.logger.info(f"Failed evaluations: {stats['failed_evals']}") + self.logger.info(f"Skipped evaluations: {stats['skipped_evals']}") + + # Print SWE-bench consolidated results + swe_stats = self.swe_bench_stats + self.logger.info("=== SWE-BENCH CONSOLIDATED RESULTS ===") + self.logger.info(f"Total instances: {swe_stats['total_instances']}") + self.logger.info(f"Instances submitted: {swe_stats['instances_submitted']}") + self.logger.info(f"Instances completed: {swe_stats['instances_completed']}") + self.logger.info(f"Instances incomplete: {swe_stats['instances_incomplete']}") + self.logger.info(f"Instances resolved: {swe_stats['instances_resolved']}") + self.logger.info(f"Instances unresolved: {swe_stats['instances_unresolved']}") + self.logger.info(f"Instances with empty patches: {swe_stats['instances_with_empty_patches']}") + self.logger.info(f"Instances with errors: {swe_stats['instances_with_errors']}") + self.logger.info(f"Unstopped containers: {swe_stats['unstopped_containers']}") + self.logger.info(f"Unremoved images: {swe_stats['unremoved_images']}") + + return report_file + + def run(self): + """Main execution method""" + self.logger.info(f"Starting SWE-bench evaluation with run_id: {self.run_id}") + self.logger.info(f"Predictions path: {self.predictions_path}") + self.logger.info(f"Output directory: {self.output_dir.absolute()}") + + # Load instance IDs + instance_ids = self.load_instance_ids() + + # Process each instance + for instance_id in instance_ids: + try: + self.process_instance(instance_id) + except KeyboardInterrupt: + self.logger.info("Evaluation interrupted by user") + break + except Exception as e: + self.logger.error(f"Unexpected error processing {instance_id}: {e}") + continue + + # Generate consolidated report + report_file = self.generate_consolidated_report() + self.logger.info(f"Evaluation completed! All outputs saved to: {self.output_dir.absolute()}") + return report_file + + +def main(): + parser = argparse.ArgumentParser(description="Run SWE-bench evaluations") + parser.add_argument("--run_id", required=True, help="Run ID for the evaluation") + parser.add_argument("--predictions_path", required=True, help="Path to predictions file") + parser.add_argument("--output_dir", default="output", help="Output directory for logs and reports (default: output)") + + args = parser.parse_args() + + # Validate arguments + if not args.run_id: + parser.error("run_id is required") + if not args.predictions_path: + parser.error("predictions_path is required") + if not Path(args.predictions_path).exists(): + parser.error(f"Predictions path does not exist: {args.predictions_path}") + + # Create and run evaluator + evaluator = SWEBenchEvaluator(args.run_id, args.predictions_path, args.output_dir) + evaluator.run() + + +if __name__ == "__main__": + main() diff --git a/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py b/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py new file mode 100644 index 000000000000..8ef724c7c198 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py @@ -0,0 +1,502 @@ +#!/usr/bin/env python3 +""" +Python equivalent of the bash script for running SWE-bench evaluations. +Handles Docker image loading, evaluation execution, error logging, and consolidated reporting. +""" + +import argparse +import subprocess +import json +import os +import sys +import logging +from pathlib import Path +from datetime import datetime +from typing import Dict, List, Optional +import re + + +class SWEBenchEvaluator: + def __init__(self, run_id: str, predictions_path: str, output_dir: str = "output", dataset_name: str = "princeton-nlp/SWE-bench", dataset_split="dev"): + self.run_id = run_id + self.predictions_path = predictions_path + self.output_dir = Path(output_dir) + # self.docker_image_dir = "/mlf3-shared/sapankumars/swe_docker_images" + self.parent_docker_image_dir = "/workspaces/Openhands/swebench_dockers_for_eval" + # self.instance_ids_file = "/workspaces/OpenHands/problem_list.txt" + dockers_dict = { + "princeton-nlp/SWE-bench_dev": os.path.join(self.parent_docker_image_dir, "swebench_dockers/dev/docker_images"), + "princeton-nlp/SWE-bench_test": os.path.join(self.parent_docker_image_dir, "swebench_dockers/test/docker_images"), + "princeton-nlp/SWE-bench_train": os.path.join(self.parent_docker_image_dir, "swebench_dockers/train/docker_images"), + "princeton-nlp/SWE-bench_Verified_dev": os.path.join(self.parent_docker_image_dir, "swebench_verified_dockers/dev/docker_images"), + } + self.docker_image_dir = dockers_dict[f"{dataset_name}_{dataset_split}"] + + # Create output directory if it doesn't exist + self.output_dir.mkdir(parents=True, exist_ok=True) + + # Setup logging + self.setup_logging() + self.dataset_name = dataset_name + self.dataset_split = dataset_split + + # Results tracking + self.results = [] + self.consolidated_stats = { + "total_instances": 0, + "successful_loads": 0, + "failed_loads": 0, + "missing_docker_images": 0, + "successful_evals": 0, + "failed_evals": 0, + "skipped_evals": 0, + "start_time": datetime.now().isoformat(), + "end_time": None + } + + # SWE-bench evaluation stats (consolidated across all instances) + self.swe_bench_stats = { + "total_instances": 0, + "instances_submitted": 0, + "instances_completed": 0, + "instances_incomplete": 0, + "instances_resolved": 0, + "instances_unresolved": 0, + "instances_with_empty_patches": 0, + "instances_with_errors": 0, + "unstopped_containers": 0, + "unremoved_images": 0, + "completed_ids":[], + "incomplete_ids":[], + "resolved_ids":[], + "unresolved_ids":[], + "error_ids": [], + "empty_patch_ids": [], + "submitted_ids": [] + } + + + def setup_logging(self): + """Setup logging configuration""" + # Create logs subdirectory in output directory + log_dir = self.output_dir / "logs" + log_dir.mkdir(exist_ok=True) + + # Generate timestamp for file naming + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + + # Main log file + log_file = log_dir / f"swe_bench_eval_{self.run_id}_{timestamp}.log" + + logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler(log_file), + logging.StreamHandler(sys.stdout) + ] + ) + self.logger = logging.getLogger(__name__) + + # JSONL results file + self.results_file = log_dir / f"swe_bench_results_{self.run_id}_{timestamp}.jsonl" + self.logger.info(f"Output directory: {self.output_dir.absolute()}") + self.logger.info(f"Log file: {log_file}") + self.logger.info(f"Results file: {self.results_file}") + + def load_instance_ids(self) -> List[str]: + """Load instance IDs from the specified file""" + try: + instance_ids = [] + with open(self.predictions_path, 'r') as f: + for line in f: + if line.strip(): + try: + data = json.loads(line) + if "instance_id" in data: + self.logger.info(f"Found instance_id in predictions: {data['instance_id']}") + instance_ids.append(data['instance_id']) + except json.JSONDecodeError: + self.logger.warning(f"Invalid JSON line in predictions file: {line.strip()}") + + + return instance_ids + except FileNotFoundError: + self.logger.error(f"predictions_path file not found: {self.predictions_path}") + sys.exit(1) + except Exception as e: + self.logger.error(f"Error reading predictions_path: {e}") + sys.exit(1) + + def load_docker_image(self, instance_id: str) -> tuple[bool, str]: + """ + Load Docker image for the given SWE-bench instance ID. + + Strategy: + 1. Try loading from main tarball directory. + 2. If not found, try fallback directory (e.g., downloaded previously). + 3. If still not found, try pulling from DockerHub with prefetch-style name. + """ + base_tarfile_path = Path(self.docker_image_dir) / f"{instance_id}__latest.tar" + fallback_dir = Path(self.docker_image_dir) / "harshg" + fallback_dir.mkdir(parents=True, exist_ok=True) + fallback_tarfile_path = fallback_dir / f"{instance_id}__latest.tar" + + def try_docker_load(path: Path) -> tuple[bool, str]: + """Helper to run docker load from a tar file.""" + self.logger.info(f"๐Ÿ“ฆ Attempting to load Docker image from: {path}") + result = subprocess.run( + ["docker", "load", "-i", str(path)], + capture_output=True, + text=True, + timeout=300 + ) + if result.returncode == 0: + self.logger.info(f"โœ… Successfully loaded Docker image for {instance_id}") + return True, "Success" + else: + self.logger.warning(f"โš ๏ธ Docker load failed for {instance_id} from {path}: {result.stderr.strip()}") + return False, result.stderr.strip() + + # --- Step 1: Try loading from main tar folder --- + if base_tarfile_path.exists(): + ok, msg = try_docker_load(base_tarfile_path) + if ok: + return True, msg + + # --- Step 2: Try loading from fallback folder --- + if fallback_tarfile_path.exists(): + self.logger.info(f"๐Ÿ” Checking fallback folder for pre-downloaded image: {fallback_tarfile_path}") + ok, msg = try_docker_load(fallback_tarfile_path) + if ok: + return True, msg + else: + self.logger.warning(f"โš ๏ธ Loading from fallback folder failed: {msg}") + + # --- Step 3: Pull from DockerHub (prefetch naming) --- + repo1 = instance_id.split("__")[0] + repo2 = instance_id.split("__")[1] if "__" in instance_id else "" + dockerhub_image = f"swebench/sweb.eval.x86_64.{repo1}_1776_{repo2}:latest" + + self.logger.info(f"๐ŸŒ Attempting to pull image from DockerHub: {dockerhub_image}") + pull_result = subprocess.run( + ["docker", "pull", dockerhub_image], + capture_output=True, + text=True + ) + + if pull_result.returncode == 0: + self.logger.info(f"โœ… Pulled image {dockerhub_image} from DockerHub. Saving locally to fallback...") + save_result = subprocess.run( + ["docker", "save", "-o", str(fallback_tarfile_path), dockerhub_image], + capture_output=True, + text=True + ) + if save_result.returncode == 0: + subprocess.run(["chmod", "777", str(fallback_tarfile_path)], check=False) + self.logger.info(f"โœ… Saved pulled image to {fallback_tarfile_path}") + subprocess.run(["docker", "rmi", dockerhub_image], capture_output=True, text=True) + return try_docker_load(fallback_tarfile_path) + else: + error_msg = f"โŒ Docker save failed: {save_result.stderr.strip()}" + self.logger.error(error_msg) + return False, error_msg + else: + error_msg = f"โŒ Docker pull failed: {pull_result.stderr.strip()}" + self.logger.error(error_msg) + return False, error_msg + + def run_evaluation(self, instance_id: str) -> Dict: + """Run SWE-bench evaluation for the given instance ID""" + # cmd = [ + # "python", "-m", "swebench.harness.run_evaluation", + # "--dataset_name", "princeton-nlp/SWE-bench_Verified", + # "--max_workers", "15", + # "--cache_level", "none", + # "--clean", "True", + # "--predictions_path", self.predictions_path, + # "--run_id", self.run_id, + # "--instance_ids", instance_id + # ] + + cmd = [ + "python", "-m", "swebench.harness.run_evaluation", + "--dataset_name", f"{self.dataset_name}", + "--max_workers", "15", + "--cache_level", "none", + "--clean", "True", + "--predictions_path", self.predictions_path, + "--run_id", self.run_id, + "--instance_ids", instance_id, + "--split", f"{self.dataset_split}" + ] + + self.logger.info(f"Running evaluation for {instance_id}") + + try: + result = subprocess.run( + cmd, + capture_output=True, + text=True, + timeout=3600 # 1 hour timeout + ) + + # Parse evaluation output + eval_result = self.parse_evaluation_output(instance_id, result.stdout, result.stderr, result.returncode) + eval_result["instance_id"] = instance_id + eval_result["command"] = " ".join(cmd) + + if result.returncode == 0: + self.logger.info(f"Evaluation completed successfully for {instance_id}") + eval_result["status"] = "success" + else: + self.logger.error(f"Evaluation failed for {instance_id}: {result.stderr}") + eval_result["status"] = "failed" + + return eval_result + + except subprocess.TimeoutExpired: + self.logger.error(f"Evaluation timed out for {instance_id}") + return { + "instance_id": instance_id, + "status": "timeout", + "error": "Evaluation timed out after 1 hour" + } + except Exception as e: + self.logger.error(f"Exception during evaluation for {instance_id}: {e}") + return { + "instance_id": instance_id, + "status": "error", + "error": str(e) + } + + def parse_evaluation_output(self, instance_id: str, stdout: str, stderr: str, return_code: int) -> Dict: + """Parse the evaluation output to extract relevant information""" + result = { + "stdout": stdout, + "stderr": stderr, + "return_code": return_code, + "total_instances": 0, + "instances_submitted": 0, + "instances_completed": 0, + "instances_incomplete": 0, + "instances_resolved": 0, + "instances_unresolved": 0, + "instances_with_empty_patches": 0, + "instances_with_errors": 0, + "unstopped_containers": 0, + "unremoved_images": 0, + "report_file": None + } + + # Extract statistics from stdout + if stdout: + # Define all the patterns to match + patterns = { + "total_instances": r'Total instances: (\d+)', + "instances_submitted": r'Instances submitted: (\d+)', + "instances_completed": r'Instances completed: (\d+)', + "instances_incomplete": r'Instances incomplete: (\d+)', + "instances_resolved": r'Instances resolved: (\d+)', + "instances_unresolved": r'Instances unresolved: (\d+)', + "instances_with_empty_patches": r'Instances with empty patches: (\d+)', + "instances_with_errors": r'Instances with errors: (\d+)', + "unstopped_containers": r'Unstopped containers: (\d+)', + "unremoved_images": r'Unremoved images: (\d+)' + } + + # Extract values using regex patterns + for key, pattern in patterns.items(): + match = re.search(pattern, stdout) + if match: + result[key] = int(match.group(1)) + + if key == "instances_completed" and int(match.group(1)) > 0: + self.swe_bench_stats["completed_ids"].append(instance_id) + elif key == "instances_incomplete" and int(match.group(1)) > 0: + self.swe_bench_stats["incomplete_ids"].append(instance_id) + elif key == "instances_resolved" and int(match.group(1)) > 0: + self.swe_bench_stats["resolved_ids"].append(instance_id) + elif key == "instances_unresolved" and int(match.group(1)) > 0: + self.swe_bench_stats["unresolved_ids"].append(instance_id) + elif key == "instances_with_errors" and int(match.group(1)) > 0: + self.swe_bench_stats["error_ids"].append(instance_id) + elif key == "instances_with_empty_patches" and int(match.group(1)) > 0: + self.swe_bench_stats["empty_patch_ids"].append(instance_id) + elif key == "instances_submitted" and int(match.group(1)) > 0: + self.swe_bench_stats["submitted_ids"].append(instance_id) + + # Extract report file name + report_match = re.search(r'Report written to (.+\.json)', stdout) + if report_match: + result["report_file"] = report_match.group(1).strip() + + return result + + def log_instance_result(self, instance_id: str, docker_load_success: bool, docker_error: Optional[str], eval_result: Optional[Dict]): + """Log the result for a single instance to JSONL file""" + log_entry = { + "instance_id": instance_id, + "timestamp": datetime.now().isoformat(), + "docker_load_success": docker_load_success, + "docker_load_error": docker_error if not docker_load_success else None, + "evaluation_result": eval_result + } + + with open(self.results_file, 'a') as f: + f.write(json.dumps(log_entry) + '\n') + + self.results.append(log_entry) + + def update_consolidated_stats(self, docker_load_success: bool, docker_error: Optional[str], eval_result: Optional[Dict]): + """Update consolidated statistics""" + self.consolidated_stats["total_instances"] += 1 + + if docker_load_success: + self.consolidated_stats["successful_loads"] += 1 + else: + self.consolidated_stats["failed_loads"] += 1 + # Check if it's specifically a missing Docker image + if docker_error and "Docker image tar not found" in docker_error: + self.consolidated_stats["missing_docker_images"] += 1 + + if eval_result: + if eval_result.get("status") == "success": + self.consolidated_stats["successful_evals"] += 1 + + # Aggregate SWE-bench specific stats + swe_stats_keys = [ + "total_instances", "instances_submitted", "instances_completed", + "instances_incomplete", "instances_resolved", "instances_unresolved", + "instances_with_empty_patches", "instances_with_errors", + "unstopped_containers", "unremoved_images" + ] + + for key in swe_stats_keys: + if key in eval_result: + self.swe_bench_stats[key] += eval_result[key] + + else: + self.consolidated_stats["failed_evals"] += 1 + else: + # Evaluation was skipped (likely due to Docker load failure) + self.consolidated_stats["skipped_evals"] += 1 + + def process_instance(self, instance_id: str): + """Process a single instance: load Docker image and run evaluation""" + self.logger.info(f"Processing task: instance_id={instance_id}") + + # Load Docker image + docker_load_success, docker_error = self.load_docker_image(instance_id) + eval_result = None + + if docker_load_success: + # Run evaluation + eval_result = self.run_evaluation(instance_id) + else: + self.logger.warning(f"Skipping evaluation for {instance_id} due to Docker load failure: {docker_error}") + + # Log results + self.log_instance_result(instance_id, docker_load_success, docker_error, eval_result) + self.update_consolidated_stats(docker_load_success, docker_error, eval_result) + + def generate_consolidated_report(self): + """Generate a consolidated report of all evaluations""" + self.consolidated_stats["end_time"] = datetime.now().isoformat() + + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + report_file = self.output_dir / f"consolidated_report_{self.run_id}_{timestamp}.json" + + report = { + "run_id": self.run_id, + "predictions_path": self.predictions_path, + "output_directory": str(self.output_dir.absolute()), + "execution_statistics": self.consolidated_stats, + "swe_bench_statistics": self.swe_bench_stats, + "detailed_results": self.results + } + + with open(report_file, 'w') as f: + json.dump(report, f, indent=2) + + self.logger.info(f"Consolidated report written to {report_file}") + + # Print execution summary + stats = self.consolidated_stats + self.logger.info("=== EXECUTION SUMMARY ===") + self.logger.info(f"Total instances processed: {stats['total_instances']}") + self.logger.info(f"Successful Docker loads: {stats['successful_loads']}") + self.logger.info(f"Failed Docker loads: {stats['failed_loads']}") + self.logger.info(f"Missing Docker images: {stats['missing_docker_images']}") + self.logger.info(f"Successful evaluations: {stats['successful_evals']}") + self.logger.info(f"Failed evaluations: {stats['failed_evals']}") + self.logger.info(f"Skipped evaluations: {stats['skipped_evals']}") + + # Print SWE-bench consolidated results + swe_stats = self.swe_bench_stats + self.logger.info("=== SWE-BENCH CONSOLIDATED RESULTS ===") + self.logger.info(f"Total instances: {swe_stats['total_instances']}") + self.logger.info(f"Instances submitted: {swe_stats['instances_submitted']}") + self.logger.info(f"Instances completed: {swe_stats['instances_completed']}") + self.logger.info(f"Instances incomplete: {swe_stats['instances_incomplete']}") + self.logger.info(f"Instances resolved: {swe_stats['instances_resolved']}") + self.logger.info(f"Instances unresolved: {swe_stats['instances_unresolved']}") + self.logger.info(f"Instances with empty patches: {swe_stats['instances_with_empty_patches']}") + self.logger.info(f"Instances with errors: {swe_stats['instances_with_errors']}") + self.logger.info(f"Unstopped containers: {swe_stats['unstopped_containers']}") + self.logger.info(f"Unremoved images: {swe_stats['unremoved_images']}") + + return report_file + + def run(self): + """Main execution method""" + self.logger.info(f"Starting SWE-bench evaluation with run_id: {self.run_id}") + self.logger.info(f"Predictions path: {self.predictions_path}") + self.logger.info(f"Output directory: {self.output_dir.absolute()}") + + # Load instance IDs + instance_ids = self.load_instance_ids() + + # Process each instance + for instance_id in instance_ids: + try: + self.process_instance(instance_id) + except KeyboardInterrupt: + self.logger.info("Evaluation interrupted by user") + break + except Exception as e: + self.logger.error(f"Unexpected error processing {instance_id}: {e}") + continue + + # Generate consolidated report + report_file = self.generate_consolidated_report() + self.logger.info(f"Evaluation completed! All outputs saved to: {self.output_dir.absolute()}") + return report_file + + +def main(): + parser = argparse.ArgumentParser(description="Run SWE-bench evaluations") + parser.add_argument("--run_id", required=True, help="Run ID for the evaluation") + parser.add_argument("--predictions_path", required=True, help="Path to predictions file") + parser.add_argument("--output_dir", default="output", help="Output directory for logs and reports (default: output)") + parser.add_argument("--dataset_name", default="princeton-nlp/SWE-bench", help="Dataset name for SWE-bench (default: princeton-nlp/SWE-bench)") + parser.add_argument("--dataset_split", default="dev", help="Dataset name for SWE-bench (default: dev)") + + + args = parser.parse_args() + + # Validate arguments + if not args.run_id: + parser.error("run_id is required") + if not args.predictions_path: + parser.error("predictions_path is required") + if not Path(args.predictions_path).exists(): + parser.error(f"Predictions path does not exist: {args.predictions_path}") + + # Create and run evaluator + evaluator = SWEBenchEvaluator(args.run_id, args.predictions_path, args.output_dir, args.dataset_name, args.dataset_split) + evaluator.run() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/evaluation/benchmarks/swe_bench/run_infer.py b/evaluation/benchmarks/swe_bench/run_infer.py index 2b86cc3baac0..b7562b9b6a54 100644 --- a/evaluation/benchmarks/swe_bench/run_infer.py +++ b/evaluation/benchmarks/swe_bench/run_infer.py @@ -238,6 +238,8 @@ def get_config( sandbox_config=sandbox_config, ) + config.save_trajectory_path = os.path.join(metadata.eval_output_dir, 'llm_completions', instance['instance_id'], f"{instance['instance_id']}_trajectory.json") + config.set_llm_config( update_llm_config_for_completions_logging( metadata.llm_config, metadata.eval_output_dir, instance['instance_id'] diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index 1a4f4822ff5f..c386b2444763 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -58,9 +58,9 @@ # Optional: in the long run, move this into AgentConfig @dataclass class AutoReflectionConfig: - enabled: bool = True + enabled: bool = False # Probabilistic trigger: after each observation event, fire with probability `prob` - prob: float = 0.50 + prob: float = 0.10 # Reactive trigger: check last turn for "no tool" or "error observation" reactive_enabled: bool = True # How many past events to consider for the โ€œlast N stepsโ€ wording @@ -236,24 +236,25 @@ def step(self, state: State) -> 'Action': f'Processing {len(condensed_history)} events from a total of {len(state.history)} events' ) - # NOTE: reflection case 1: Revisit last observation to catch if there is tool call failures + # NOTE: reflection case 2: Revisit last observation to catch if there is tool call failures if self.auto_reflect.enabled: if self.auto_reflect.reactive_enabled: is_last_turn_tool_error, tool_call_error_message =self._last_turn_has_tool_error(condensed_history) - if is_last_turn_tool_error and not self._last_event_is_autoreflect(condensed_history): + if is_last_turn_tool_error and not self._last_action_is_autoreflect(condensed_history): self.pending_actions.clear() # clear the queue + self._num_steps += 1 self._last_reflection_step = self._num_steps - tool_call_reflection_prompt = f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool." - return self._emit_reflection(tool_call_reflection_prompt) + return self._emit_reflection(f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool.") - # NOTE: reflection case 2: Probablistically do general last N step reflection + # NOTE: reflection case 1: Probablistically do general last N step reflection # Let's do not break any pending actions # Also make sure the last action was not think if random.random() < self.auto_reflect.prob and \ not self.pending_actions and \ self._last_reflection_step != self._num_steps and \ - not self._last_event_is_autoreflect(condensed_history): + not self._last_action_is_autoreflect(condensed_history): + self._num_steps += 1 self._last_reflection_step = self._num_steps return self._emit_reflection( self.auto_reflect.prompt.format(n=self.auto_reflect.lookback_window) @@ -281,28 +282,31 @@ def step(self, state: State) -> 'Action': model_name=self.llm.config.model, agent_name=self.name ) } - # if self._num_steps > 5: - # breakpoint() + logger.debug(f'Last utterance input to LLM: {messages[-1]}') response = self.llm.completion(**params) logger.debug(f'Response from LLM: {response}') - # try: - actions = self.response_to_actions(response) + try: + actions = self.response_to_actions(response) # NOTE: reflection case 3: cope with tool parse failures - # except Exception as e: - # # Wrong tool parsing will be raised by response_to_actions in function_calling.py - # logger.warning(f"[AutoReflect] Tool-call parse error: {e}. Injecting reflection.") - # self._last_reflection_step = self._num_steps - # return self._emit_reflection( - # f"Malformed tool call (invalid JSON/args):\n```\n{e}\n```\n" - # "Reflect briefly and emit a valid tool call or a better-plan message." - # ) + except Exception as e: + # Wrong tool parsing will be raised by response_to_actions in function_calling.py + if self.auto_reflect.enabled: + self._last_reflection_step = self._num_steps + self._num_steps += 1 + return self._emit_reflection( + f"Malformed tool call (invalid JSON/args):\n```\n{e}\n```\n" + "Reflect briefly and emit a valid tool call or a better-plan message." + ) + else: + pass logger.debug(f'Actions after response_to_actions: {actions}') for action in actions: self.pending_actions.append(action) self._num_steps += 1 return self.pending_actions.popleft() + def _get_initial_user_message(self, history: list[Event]) -> MessageAction: """Finds the initial user message action from the full history.""" initial_user_message: MessageAction | None = None @@ -378,7 +382,7 @@ def response_to_actions(self, response: 'ModelResponse') -> list['Action']: mcp_tool_names=list(self.mcp_tools.keys()), ) - + # NOTE: add for self-reflection def _last_turn_has_tool_error(self, events: list[Event]) -> tuple[bool, str | None]: ''' We want to trigger a reflection on two cases related to tool calling: @@ -408,11 +412,11 @@ def _last_turn_has_tool_error(self, events: list[Event]) -> tuple[bool, str | N def _emit_reflection(self, text: str) -> MessageAction: - msg = MessageAction(content=f"[AutoReflect]\n{text}\n Next step: Use `reflection` tool in next turn to do this reflection, no other tools are allowed!") + msg = MessageAction(content=f"[AutoReflect]\n{text}\n Next step: You MUST use `reflection` tool/action in next turn to do this reflection, no others are allowed. Again, You MUST use `reflection` tool/action in next turn to do this reflection, no others are allowed.") msg._source = EventSource.AGENT # <-- set source after init return msg - def _last_event_is_autoreflect(self, events) -> bool: + def _last_action_is_autoreflect(self, events) -> bool: # Scan backwards, skip observations; stop on the last action/message. for ev in reversed(events): name = ev.__class__.__name__.lower() From be38685929c9715831079ad81639f810641c9c2e Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Fri, 24 Oct 2025 05:22:46 +0000 Subject: [PATCH 05/12] batch update on use local docker and eval --- clean_docker.sh | 18 +- config_llm.yaml | 6 + evaluation/benchmarks/swe_bench/run_infer.py | 9 +- .../swe_bench/run_infer_local_docker.py | 1047 +++++++++++++++++ .../scripts/run_infer_local_docker.sh | 150 +++ openhands.ipynb | 594 ++++++++++ .../agenthub/codeact_agent/codeact_agent.py | 29 +- .../runtime/impl/docker/docker_runtime.py | 50 + save_runtime_image_local.py | 83 ++ 9 files changed, 1962 insertions(+), 24 deletions(-) create mode 100644 config_llm.yaml create mode 100644 evaluation/benchmarks/swe_bench/run_infer_local_docker.py create mode 100755 evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh create mode 100644 openhands.ipynb create mode 100644 save_runtime_image_local.py diff --git a/clean_docker.sh b/clean_docker.sh index 5f1d7432fe97..0bddb5dc460d 100755 --- a/clean_docker.sh +++ b/clean_docker.sh @@ -1,11 +1,11 @@ -# docker images 'ghcr.io/all-hands-ai/runtime' -q | sort -u | \ -# while read -r id; do -# if [ -z "$(docker ps -aq --filter ancestor="$id")" ]; then -# tags=$(docker image inspect "$id" --format '{{join .RepoTags " "}}' 2>/dev/null || true) -# [ -n "$tags" ] && docker rmi $tags -# docker rmi "$id" 2>/dev/null || true -# fi -# done -# docker image prune -f; docker builder prune -f; docker volume prune -f +docker images 'ghcr.io/all-hands-ai/runtime' -q | sort -u | \ +while read -r id; do + if [ -z "$(docker ps -aq --filter ancestor="$id")" ]; then + tags=$(docker image inspect "$id" --format '{{join .RepoTags " "}}' 2>/dev/null || true) + [ -n "$tags" ] && docker rmi $tags + docker rmi "$id" 2>/dev/null || true + fi +done +docker image prune -f; docker builder prune -f; docker volume prune -f docker system prune -a -f --volumes; diff --git a/config_llm.yaml b/config_llm.yaml new file mode 100644 index 000000000000..4264238162fb --- /dev/null +++ b/config_llm.yaml @@ -0,0 +1,6 @@ +model_list: + - model_name: qwen-coder-30b-small + litellm_params: + model: hosted_vllm/Qwen/Qwen3-Coder-30B-A3B-Instruct + api_base: http://localhost:10000/v1/ + api_key: "serving-on-vllm" diff --git a/evaluation/benchmarks/swe_bench/run_infer.py b/evaluation/benchmarks/swe_bench/run_infer.py index b7562b9b6a54..39f43e234cc4 100644 --- a/evaluation/benchmarks/swe_bench/run_infer.py +++ b/evaluation/benchmarks/swe_bench/run_infer.py @@ -69,6 +69,9 @@ USE_HINT_TEXT = os.environ.get('USE_HINT_TEXT', 'false').lower() == 'true' RUN_WITH_BROWSING = os.environ.get('RUN_WITH_BROWSING', 'false').lower() == 'true' ENABLE_LLM_EDITOR = os.environ.get('ENABLE_LLM_EDITOR', 'false').lower() == 'true' + +CONFIG_ML = os.environ.get('CONFIG_ML', '') + BenchMode = Literal['swe', 'swt', 'swt-ci'] # Global variable to track dataset type @@ -833,13 +836,17 @@ def filter_dataset(dataset: pd.DataFrame, filter_column: str) -> pd.DataFrame: dataset_description = ( args.dataset.replace('/', '__') + '-' + args.split.replace('/', '__') ) + + eval_output_dir = os.environ.get('EVAL_OUTPUT_DIR', args.eval_output_dir) + logger.debug(f"Eval output dir: {eval_output_dir}") metadata = make_metadata( llm_config, dataset_description, args.agent_cls, args.max_iterations, args.eval_note, - args.eval_output_dir, + # args.eval_output_dir, + eval_output_dir, details=details, agent_config=agent_config, condenser_config=condenser_config, diff --git a/evaluation/benchmarks/swe_bench/run_infer_local_docker.py b/evaluation/benchmarks/swe_bench/run_infer_local_docker.py new file mode 100644 index 000000000000..fa7eaf21f356 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/run_infer_local_docker.py @@ -0,0 +1,1047 @@ +import asyncio +import copy +import json +import os +import tempfile +from typing import Any, Literal +import docker + +import pandas as pd +import toml +from datasets import load_dataset +from jinja2 import Environment, FileSystemLoader + +import openhands.agenthub +from evaluation.benchmarks.swe_bench.binary_patch_utils import ( + remove_binary_diffs, + remove_binary_files_from_git, +) +from evaluation.benchmarks.swe_bench.resource.mapping import ( + get_instance_resource_factor, +) +from evaluation.benchmarks.swe_bench.resource.swt_bench_constants import ( + MAP_REPO_TO_INSTALL, + MAP_REPO_TO_TEST_FRAMEWORK_VERBOSE, + MAP_VERSION_TO_INSTALL, +) +from evaluation.utils.shared import ( + EvalException, + EvalMetadata, + EvalOutput, + assert_and_raise, + check_maximum_retries_exceeded, + codeact_user_response, + get_default_sandbox_config_for_eval, + get_metrics, + get_openhands_config_for_eval, + is_fatal_evaluation_error, + make_metadata, + prepare_dataset, + reset_logger_for_multiprocessing, + run_evaluation, + update_llm_config_for_completions_logging, +) +from openhands.controller.state.state import State +from openhands.core.config import ( + AgentConfig, + OpenHandsConfig, + get_agent_config_arg, + get_evaluation_parser, + get_llm_config_arg, + get_llms_for_routing_config, + get_model_routing_config_arg, +) +from openhands.core.config.condenser_config import NoOpCondenserConfig +from openhands.core.config.utils import get_condenser_config_arg +from openhands.core.logger import openhands_logger as logger +from openhands.core.main import create_runtime, run_controller +from openhands.critic import AgentFinishedCritic +from openhands.events.action import CmdRunAction, FileReadAction, MessageAction +from openhands.events.observation import ( + CmdOutputObservation, + ErrorObservation, + FileReadObservation, +) +from openhands.events.serialization.event import event_from_dict, event_to_dict +from openhands.runtime.base import Runtime +from openhands.utils.async_utils import call_async_from_sync +from openhands.utils.shutdown_listener import sleep_if_should_continue + +USE_HINT_TEXT = os.environ.get('USE_HINT_TEXT', 'false').lower() == 'true' +RUN_WITH_BROWSING = os.environ.get('RUN_WITH_BROWSING', 'false').lower() == 'true' +ENABLE_LLM_EDITOR = os.environ.get('ENABLE_LLM_EDITOR', 'false').lower() == 'true' +LOCAL_DOCKER_IMAGE_DIR = os.environ.get('LOCAL_DOCKER_IMAGE_DIR', '') +CONFIG_ML = os.environ.get('CONFIG_ML', '') + +BenchMode = Literal['swe', 'swt', 'swt-ci'] + +# Global variable to track dataset type +DATASET_TYPE = 'SWE-bench' + + +def set_dataset_type(dataset_name: str) -> str: + """Set dataset type based on dataset name.""" + global DATASET_TYPE + name_lower = dataset_name.lower() + + if 'swe-gym' in name_lower: + DATASET_TYPE = 'SWE-Gym' + elif 'swe-bench-live' in name_lower: + DATASET_TYPE = 'SWE-bench-Live' + elif 'swe-rebench' in name_lower: + DATASET_TYPE = 'SWE-rebench' + elif 'multimodal' in name_lower: + DATASET_TYPE = 'Multimodal' + else: + DATASET_TYPE = 'SWE-bench' + + logger.info(f'Dataset type set to: {DATASET_TYPE}') + + +AGENT_CLS_TO_FAKE_USER_RESPONSE_FN = { + 'CodeActAgent': codeact_user_response, +} + + +def _get_swebench_workspace_dir_name(instance: pd.Series) -> str: + if DATASET_TYPE == 'SWE-bench-Live': + return instance.instance_id + else: + return f'{instance.repo}__{instance.version}'.replace('/', '__') + + +def get_instruction(instance: pd.Series, metadata: EvalMetadata) -> MessageAction: + workspace_dir_name = _get_swebench_workspace_dir_name(instance) + mode = metadata.details['mode'] + llm_model = metadata.llm_config.model + + # Determine the template file based on mode and LLM + if metadata.instruction_template_name: + template_name = metadata.instruction_template_name + elif mode.startswith('swt'): + template_name = 'swt.j2' + elif mode == 'swe': + if 'gpt-4.1' in llm_model: + template_name = 'swe_gpt4.j2' + else: + template_name = ( + 'swe_default.j2' # Default for 'swe' mode (regular swe-bench) + ) + else: + # Fallback or error handling if mode is unexpected + logger.error(f'Unexpected evaluation mode: {mode}. Falling back to default.') + template_name = 'swe_default.j2' + + logger.debug(f'Using instruction template file: {template_name}') + # Set up Jinja2 environment + # Assuming templates are in 'evaluation/benchmarks/swe_bench/prompts' relative to this script + prompts_dir = os.path.join(os.path.dirname(__file__), 'prompts') + env = Environment(loader=FileSystemLoader(prompts_dir)) + template = env.get_template(template_name) + + # Prepare context for rendering + context = { + 'instance': instance, + 'workspace_dir_name': workspace_dir_name, + 'metadata': metadata, # Pass metadata if needed in templates + } + + # Add specific context for swt-ci mode if needed + if mode == 'swt-ci': + context['test_instructions'] = ( + f'The following command can be used to run the tests: `{list(MAP_REPO_TO_TEST_FRAMEWORK_VERBOSE[instance.repo].values())[0]}`. Make sure they fail in the expected way.\n' + ) + else: + context['test_instructions'] = '' # Ensure it's defined for other modes + + # Render the instruction + instruction = template.render(context) + + if RUN_WITH_BROWSING: + instruction += ( + '\nYou SHOULD NEVER attempt to browse the web. \n' + ) + + if 'image_assets' in instance: + assets = json.loads(instance['image_assets']) + assert 'problem_statement' in assets, ( + 'problem_statement is required in image_assets' + ) + image_urls = assets['problem_statement'] + return MessageAction(content=instruction, image_urls=image_urls) + return MessageAction(content=instruction) + + +# TODO: migrate all swe-bench docker to ghcr.io/openhands +DEFAULT_DOCKER_IMAGE_PREFIX = os.environ.get( + 'EVAL_DOCKER_IMAGE_PREFIX', 'docker.io/xingyaoww/' +) +logger.info(f'Default docker image prefix: {DEFAULT_DOCKER_IMAGE_PREFIX}') + + +def load_local_image_if_needed(path: str, custom_tag: str = None) -> str: + """ + Load a Docker image from a local .tar file and return its name. + """ + client = docker.from_env() + logger.info(f"{os.path.exists(path)}, {path.endswith(".tar")}") + if os.path.exists(path) and path.endswith(".tar"): + logger.info(f"๐Ÿ“ฆ Loading local image from {path} ...") + with open(path, "rb") as f: + image = client.images.load(f.read())[0] + # Return the repo:tag string to use as base image + if custom_tag is not None: + logger.info(f"๐Ÿท๏ธ Retagging image to {custom_tag}") + image.tag(custom_tag) + + # Return the custom tag for use elsewhere + return custom_tag if custom_tag else image.tags[0] + else: + return path + + +def get_instance_docker_image( + instance_id: str, + swebench_official_image: bool = False, +) -> str: + if swebench_official_image: + # Official SWE-Bench image + # swebench/sweb.eval.x86_64.django_1776_django-11333:v1 + # SWE-bench-Live uses the same naming convention as SWE-Bench + if DATASET_TYPE == 'SWE-bench-Live': + docker_image_prefix = 'docker.io/starryzhang/' + elif DATASET_TYPE == 'SWE-bench': + if not LOCAL_DOCKER_IMAGE_DIR: + docker_image_prefix = 'docker.io/swebench/' + else: + docker_image_prefix = f"{LOCAL_DOCKER_IMAGE_DIR}/" + logger.debug(f'Using LOCAL SWE-Bench image from: {docker_image_prefix}') + + elif DATASET_TYPE == 'SWE-rebench': + docker_image_prefix = 'docker.io/swerebench/' + repo, name = instance_id.split('__') + image_name = f'{docker_image_prefix.rstrip("/")}/sweb.eval.x86_64.{repo}_1776_{name}:latest'.lower() + if LOCAL_DOCKER_IMAGE_DIR: + image_name = f'{docker_image_prefix.rstrip("/")}/{instance_id}__latest.tar' + logger.debug(f'Using LOCAL SWE-Bench image: {image_name}') + else: + logger.debug(f'Using OFFICIAL SWE-Bench image: {image_name}') + return image_name + else: + # OpenHands version of the image + docker_image_prefix = DEFAULT_DOCKER_IMAGE_PREFIX + image_name = 'sweb.eval.x86_64.' + instance_id + image_name = image_name.replace( + '__', '_s_' + ) # to comply with docker image naming convention + return (docker_image_prefix.rstrip('/') + '/' + image_name).lower() + + + + +def get_config( + instance: pd.Series, + metadata: EvalMetadata, +) -> OpenHandsConfig: + # We use a different instance image for the each instance of swe-bench eval + use_swebench_official_image = DATASET_TYPE != 'SWE-Gym' + + base_container_image = get_instance_docker_image( + instance['instance_id'], + swebench_official_image=use_swebench_official_image, + ) + + if LOCAL_DOCKER_IMAGE_DIR: + logger.info(f"Loading Local Docker") + base_container_image = load_local_image_if_needed(base_container_image, custom_tag= f"openhands_local_{instance['instance_id'].split('__')[1]}:latest") + logger.info( + f'Using LOCAL docker image for instance {instance["instance_id"]}: {base_container_image}' + ) + + logger.info( + f'Using instance container image: {base_container_image}. ' + f'Please make sure this image exists. ' + f'Submit an issue on https://github.com/All-Hands-AI/OpenHands if you run into any issues.' + ) + + sandbox_config = get_default_sandbox_config_for_eval() + sandbox_config.base_container_image = base_container_image + sandbox_config.enable_auto_lint = True + sandbox_config.use_host_network = False + # Add platform to the sandbox config to solve issue 4401 + sandbox_config.platform = 'linux/amd64' + sandbox_config.remote_runtime_resource_factor = get_instance_resource_factor( + dataset_name=metadata.dataset, + instance_id=instance['instance_id'], + ) + + config = get_openhands_config_for_eval( + metadata=metadata, + enable_browser=RUN_WITH_BROWSING, + runtime=os.environ.get('RUNTIME', 'docker'), + sandbox_config=sandbox_config, + ) + + config.save_trajectory_path = os.path.join(metadata.eval_output_dir, 'llm_completions', instance['instance_id'], f"{instance['instance_id']}_trajectory.json") + + config.set_llm_config( + update_llm_config_for_completions_logging( + metadata.llm_config, metadata.eval_output_dir, instance['instance_id'] + ) + ) + # get 'draft_editor' config if exists + config.set_llm_config(get_llm_config_arg('draft_editor'), 'draft_editor') + + model_routing_config = get_model_routing_config_arg() + model_routing_config.llms_for_routing = ( + get_llms_for_routing_config() + ) # Populate with LLMs for routing from config.toml file + + agent_config = AgentConfig( + enable_jupyter=False, + enable_browsing=RUN_WITH_BROWSING, + enable_llm_editor=ENABLE_LLM_EDITOR, + enable_mcp=False, + condenser=metadata.condenser_config, + enable_prompt_extensions=False, + model_routing=model_routing_config, + ) + config.set_agent_config(agent_config) + + return config + + +def initialize_runtime( + runtime: Runtime, + instance: pd.Series, # this argument is not required + metadata: EvalMetadata, +): + """Initialize the runtime for the agent. + + This function is called before the runtime is used to run the agent. + """ + logger.info('-' * 30) + logger.info('BEGIN Runtime Initialization Fn') + logger.info('-' * 30) + workspace_dir_name = _get_swebench_workspace_dir_name(instance) + obs: CmdOutputObservation + + # Set instance id and git configuration + action = CmdRunAction( + command=f"""echo 'export SWE_INSTANCE_ID={instance['instance_id']}' >> ~/.bashrc && echo 'export PIP_CACHE_DIR=~/.cache/pip' >> ~/.bashrc && echo "alias git='git --no-pager'" >> ~/.bashrc && git config --global core.pager "" && git config --global diff.binary false""" + ) + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + obs.exit_code == 0, + f'Failed to export SWE_INSTANCE_ID and configure git: {str(obs)}', + ) + + action = CmdRunAction(command="""export USER=$(whoami); echo USER=${USER} """) + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise(obs.exit_code == 0, f'Failed to export USER: {str(obs)}') + + # inject the init script + script_dir = os.path.dirname(__file__) + + # inject the instance info + action = CmdRunAction(command='mkdir -p /swe_util/eval_data/instances') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + obs.exit_code == 0, + f'Failed to create /swe_util/eval_data/instances: {str(obs)}', + ) + + swe_instance_json_name = 'swe-bench-instance.json' + with tempfile.TemporaryDirectory() as temp_dir: + # Construct the full path for the desired file name within the temporary directory + temp_file_path = os.path.join(temp_dir, swe_instance_json_name) + # Write to the file with the desired name within the temporary directory + with open(temp_file_path, 'w') as f: + if not isinstance(instance, dict): + json.dump([instance.to_dict()], f) + else: + json.dump([instance], f) + + # Copy the file to the desired location + runtime.copy_to(temp_file_path, '/swe_util/eval_data/instances/') + + # inject the instance swe entry + if DATASET_TYPE == 'SWE-bench-Live': + entry_script_path = 'instance_swe_entry_live.sh' + elif DATASET_TYPE == 'SWE-rebench': + entry_script_path = 'instance_swe_entry_rebench.sh' + else: + entry_script_path = 'instance_swe_entry.sh' + runtime.copy_to( + str(os.path.join(script_dir, f'scripts/setup/{entry_script_path}')), + '/swe_util/', + ) + + action = CmdRunAction(command='cat ~/.bashrc') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise(obs.exit_code == 0, f'Failed to cat ~/.bashrc: {str(obs)}') + + action = CmdRunAction(command='source ~/.bashrc') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + if isinstance(obs, ErrorObservation): + logger.error(f'Failed to source ~/.bashrc: {str(obs)}') + assert_and_raise(obs.exit_code == 0, f'Failed to source ~/.bashrc: {str(obs)}') + + action = CmdRunAction(command=f'source /swe_util/{entry_script_path}') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + obs.exit_code == 0, + f'Failed to source /swe_util/{entry_script_path}: {str(obs)}', + ) + + action = CmdRunAction(command=f'cd /workspace/{workspace_dir_name}') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + obs.exit_code == 0, + f'Failed to cd to /workspace/{workspace_dir_name}: {str(obs)}', + ) + + action = CmdRunAction(command='git reset --hard') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise(obs.exit_code == 0, f'Failed to git reset --hard: {str(obs)}') + + action = CmdRunAction( + command='for remote_name in $(git remote); do git remote remove "${remote_name}"; done' + ) + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise(obs.exit_code == 0, f'Failed to remove git remotes: {str(obs)}') + + if metadata.details['mode'] == 'swt-ci': + # set up repo + setup_commands = [] + if instance['repo'] in MAP_REPO_TO_INSTALL: + setup_commands.append(MAP_REPO_TO_INSTALL[instance['repo']]) + + # Run pre-install set up if provided + install = MAP_VERSION_TO_INSTALL.get(instance['repo'], {}).get( + instance['version'], [] + ) + if 'pre_install' in install: + for pre_install in install['pre_install']: + setup_commands.append(pre_install) + + if 'install' in install: + setup_commands.append(install['install']) + + for command in setup_commands: + action = CmdRunAction(command=command) + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + + if DATASET_TYPE != 'Multimodal' and DATASET_TYPE != 'SWE-bench-Live': + # Only for non-multimodal datasets, we need to activate the testbed environment for Python + # SWE-Bench multimodal datasets and SWE-bench-Live are not using the testbed environment + action = CmdRunAction(command='which python') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + obs.exit_code == 0 and 'testbed' in obs.content, + f'Expected to find python interpreter from testbed, but got: {str(obs)}', + ) + + logger.info('-' * 30) + logger.info('END Runtime Initialization Fn') + logger.info('-' * 30) + + +def complete_runtime( + runtime: Runtime, + instance: pd.Series, # this argument is not required, but it is used to get the workspace_dir_name +) -> dict[str, Any]: + """Complete the runtime for the agent. + + This function is called before the runtime is used to run the agent. + If you need to do something in the sandbox to get the correctness metric after + the agent has run, modify this function. + """ + logger.info('-' * 30) + logger.info('BEGIN Runtime Completion Fn') + logger.info('-' * 30) + obs: CmdOutputObservation + workspace_dir_name = _get_swebench_workspace_dir_name(instance) + + action = CmdRunAction(command=f'cd /workspace/{workspace_dir_name}') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + + if obs.exit_code == -1: + # The previous command is still running + # We need to kill previous command + logger.info('The previous command is still running, trying to kill it...') + action = CmdRunAction(command='C-c') + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + + # Then run the command again + action = CmdRunAction(command=f'cd /workspace/{workspace_dir_name}') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + + if obs.exit_code == -1: + # The previous command is still running + # We need to kill previous command + logger.info('The previous command is still running, trying to ctrl+z it...') + action = CmdRunAction(command='C-z') + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + + # Then run the command again + action = CmdRunAction(command=f'cd /workspace/{workspace_dir_name}') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + + assert_and_raise( + isinstance(obs, CmdOutputObservation) and obs.exit_code == 0, + f'Failed to cd to /workspace/{workspace_dir_name}: {str(obs)}', + ) + + action = CmdRunAction(command='git config --global core.pager ""') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + isinstance(obs, CmdOutputObservation) and obs.exit_code == 0, + f'Failed to git config --global core.pager "": {str(obs)}', + ) + + # First check for any git repositories in subdirectories + action = CmdRunAction(command='find . -type d -name .git -not -path "./.git"') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + isinstance(obs, CmdOutputObservation) and obs.exit_code == 0, + f'Failed to find git repositories: {str(obs)}', + ) + + git_dirs = [p for p in obs.content.strip().split('\n') if p] + if git_dirs: + # Remove all .git directories in subdirectories + for git_dir in git_dirs: + action = CmdRunAction(command=f'rm -rf "{git_dir}"') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + isinstance(obs, CmdOutputObservation) and obs.exit_code == 0, + f'Failed to remove git directory {git_dir}: {str(obs)}', + ) + + # add all files + action = CmdRunAction(command='git add -A') + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + isinstance(obs, CmdOutputObservation) and obs.exit_code == 0, + f'Failed to git add -A: {str(obs)}', + ) + + # Remove binary files from git staging + action = CmdRunAction(command=remove_binary_files_from_git()) + action.set_hard_timeout(600) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + assert_and_raise( + isinstance(obs, CmdOutputObservation) and obs.exit_code == 0, + f'Failed to remove binary files: {str(obs)}', + ) + + n_retries = 0 + git_patch = None + while n_retries < 5: + action = CmdRunAction( + command=f'git diff --no-color --cached {instance["base_commit"]} > patch.diff' + ) + action.set_hard_timeout(max(300 + 100 * n_retries, 600)) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + n_retries += 1 + if isinstance(obs, CmdOutputObservation): + if obs.exit_code == 0: + # Read the patch file + action = FileReadAction(path='patch.diff') + action.set_hard_timeout(max(300 + 100 * n_retries, 600)) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + if isinstance(obs, FileReadObservation): + git_patch = obs.content + break + elif isinstance(obs, ErrorObservation): + # Fall back to cat "patch.diff" to get the patch + assert 'File could not be decoded as utf-8' in obs.content + action = CmdRunAction(command='cat patch.diff') + action.set_hard_timeout(max(300 + 100 * n_retries, 600)) + logger.info(action, extra={'msg_type': 'ACTION'}) + obs = runtime.run_action(action) + assert isinstance(obs, CmdOutputObservation) and obs.exit_code == 0 + logger.info(obs, extra={'msg_type': 'OBSERVATION'}) + git_patch = obs.content + break + else: + assert_and_raise(False, f'Unexpected observation type: {str(obs)}') + else: + logger.info('Failed to get git diff, retrying...') + sleep_if_should_continue(10) + elif isinstance(obs, ErrorObservation): + logger.error(f'Error occurred: {obs.content}. Retrying...') + sleep_if_should_continue(10) + else: + assert_and_raise(False, f'Unexpected observation type: {str(obs)}') + + assert_and_raise(git_patch is not None, 'Failed to get git diff (None)') + + # Remove binary diffs from the patch + git_patch = remove_binary_diffs(git_patch) + + logger.info('-' * 30) + logger.info('END Runtime Completion Fn') + logger.info('-' * 30) + return {'git_patch': git_patch} + + +def process_instance( + instance: pd.Series, + metadata: EvalMetadata, + reset_logger: bool = True, + runtime_failure_count: int = 0, +) -> EvalOutput: + config = get_config(instance, metadata) + + # Setup the logger properly, so you can run multi-processing to parallelize the evaluation + if reset_logger: + log_dir = os.path.join(metadata.eval_output_dir, 'infer_logs') + reset_logger_for_multiprocessing(logger, instance.instance_id, log_dir) + else: + logger.info(f'Starting evaluation for instance {instance.instance_id}.') + + # Increase resource_factor with increasing attempt_id + if runtime_failure_count > 0: + config.sandbox.remote_runtime_resource_factor = min( + config.sandbox.remote_runtime_resource_factor * (2**runtime_failure_count), + 8, + ) + logger.warning( + f'This is the {runtime_failure_count + 1}th attempt for instance {instance.instance_id}, setting resource factor to {config.sandbox.remote_runtime_resource_factor}' + ) + + metadata = copy.deepcopy(metadata) + metadata.details['runtime_failure_count'] = runtime_failure_count + metadata.details['remote_runtime_resource_factor'] = ( + config.sandbox.remote_runtime_resource_factor + ) + + runtime = create_runtime(config) + call_async_from_sync(runtime.connect) + + try: + initialize_runtime(runtime, instance, metadata) + + message_action = get_instruction(instance, metadata) + + # Here's how you can run the agent (similar to the `main` function) and get the final task state + state: State | None = asyncio.run( + run_controller( + config=config, + initial_user_action=message_action, + runtime=runtime, + fake_user_response_fn=AGENT_CLS_TO_FAKE_USER_RESPONSE_FN[ + metadata.agent_class + ], + ) + ) + + # if fatal error, throw EvalError to trigger re-run + if is_fatal_evaluation_error(state.last_error): + raise EvalException('Fatal error detected: ' + state.last_error) + + # ======= THIS IS SWE-Bench specific ======= + # Get git patch + if DATASET_TYPE == 'SWE-bench-Live': + from evaluation.benchmarks.swe_bench.live_utils import ( + complete_runtime as complete_runtime_fn, + ) + else: + complete_runtime_fn = complete_runtime + return_val = complete_runtime_fn(runtime, instance) + git_patch = return_val['git_patch'] + logger.info( + f'Got git diff for instance {instance.instance_id}:\n--------\n{git_patch}\n--------' + ) + finally: + runtime.close() + # ========================================== + + # ======= Attempt to evaluate the agent's edits ======= + # we use eval_infer.sh to evaluate the agent's edits, not here + # because the agent may alter the environment / testcases + test_result = { + 'git_patch': git_patch, + } + + # If you are working on some simpler benchmark that only evaluates the final model output (e.g., in a MessageAction) + # You can simply get the LAST `MessageAction` from the returned `state.history` and parse it for evaluation. + if state is None: + raise ValueError('State should not be None.') + + # NOTE: this is NO LONGER the event stream, but an agent history that includes delegate agent's events + histories = [event_to_dict(event) for event in state.history] + metrics = get_metrics(state) + + # Save the output + instruction = message_action.content + if message_action.image_urls: + instruction += ( + '\n\n' + '\n'.join(message_action.image_urls) + '' + ) + output = EvalOutput( + instance_id=instance.instance_id, + instruction=instruction, + instance=instance.to_dict(), # SWE Bench specific + test_result=test_result, + metadata=metadata, + history=histories, + metrics=metrics, + error=state.last_error if state and state.last_error else None, + ) + return output + + +def filter_dataset(dataset: pd.DataFrame, filter_column: str) -> pd.DataFrame: + if not CONFIG_ML: + file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.toml') + logger.info(f"DEFAULT: Loading {file_path} for filtering dataset...") + else: + file_path = CONFIG_ML + logger.info(f"CONFIG ML: Loading {file_path} for filtering dataset...") + if os.path.exists(file_path): + with open(file_path, 'r') as file: + data = toml.load(file) + # NOTE:empty file means normal random selection in the dataset + if 'selected_ids' in data: + selected_ids = data['selected_ids'] + logger.info( + f'Filtering {len(selected_ids)} tasks from "selected_ids"...' + ) + subset = dataset[dataset[filter_column].isin(selected_ids)] + logger.info(f'Retained {subset.shape[0]} tasks after filtering') + return subset + if 'selected_repos' in data: + # repos for the swe-bench instances: + # ['astropy/astropy', 'django/django', 'matplotlib/matplotlib', 'mwaskom/seaborn', 'pallets/flask', 'psf/requests', 'pydata/xarray', 'pylint-dev/pylint', 'pytest-dev/pytest', 'scikit-learn/scikit-learn', 'sphinx-doc/sphinx', 'sympy/sympy'] + selected_repos = data['selected_repos'] + if isinstance(selected_repos, str): + selected_repos = [selected_repos] + assert isinstance(selected_repos, list) + logger.info( + f'Filtering {selected_repos} tasks from "selected_repos"...' + ) + subset = dataset[dataset['repo'].isin(selected_repos)] + logger.info(f'Retained {subset.shape[0]} tasks after filtering') + return subset + + skip_ids = os.environ.get('SKIP_IDS', '').split(',') + if len(skip_ids) > 0: + logger.info(f'Filtering {len(skip_ids)} tasks from "SKIP_IDS"...') + return dataset[~dataset[filter_column].isin(skip_ids)] + return dataset + + +if __name__ == '__main__': + parser = get_evaluation_parser() + parser.add_argument( + '--dataset', + type=str, + default='princeton-nlp/SWE-bench', + help='data set to evaluate on, either full-test or lite-test', + ) + parser.add_argument( + '--split', + type=str, + default='test', + help='split to evaluate on', + ) + parser.add_argument( + '--mode', + type=str, + default='swe', + choices=['swe', 'swt', 'swt-ci'], + help="mode to run the evaluation, either 'swe', 'swt', or 'swt-ci'", + ) + + args, _ = parser.parse_known_args() + + # NOTE: It is preferable to load datasets from huggingface datasets and perform post-processing + # so we don't need to manage file uploading to OpenHands's repo + dataset = load_dataset(args.dataset, split=args.split) + + # Set the global dataset type based on dataset name + set_dataset_type(args.dataset) + + swe_bench_tests = filter_dataset(dataset.to_pandas(), 'instance_id') + logger.info( + f'Loaded dataset {args.dataset} with split {args.split}: {len(swe_bench_tests)} tasks' + ) + if DATASET_TYPE == 'SWE-Gym': + with open( + os.path.join( + os.path.dirname(os.path.abspath(__file__)), + 'split', + 'swegym_verified_instances.json', + ), + 'r', + ) as f: + swegym_verified_instances = json.load(f) + swe_bench_tests = swe_bench_tests[ + swe_bench_tests['instance_id'].isin(swegym_verified_instances) + ] + logger.info( + f'{len(swe_bench_tests)} tasks left after filtering for SWE-Gym verified instances' + ) + + llm_config = None + if args.llm_config: + llm_config = get_llm_config_arg(args.llm_config, args.config_file) + llm_config.log_completions = True + # modify_params must be False for evaluation purpose, for reproducibility and accurancy of results + llm_config.modify_params = False + + if llm_config is None: + raise ValueError(f'Could not find LLM config: --llm_config {args.llm_config}') + + # Get condenser config from environment variable + condenser_name = os.environ.get('EVAL_CONDENSER') + if condenser_name: + condenser_config = get_condenser_config_arg(condenser_name, args.config_file) + if condenser_config is None: + raise ValueError( + f'Could not find Condenser config: EVAL_CONDENSER={condenser_name}' + ) + else: + # If no specific condenser config is provided via env var, default to NoOpCondenser + condenser_config = NoOpCondenserConfig() + logger.debug( + 'No Condenser config provided via EVAL_CONDENSER, using NoOpCondenser.' + ) + + agent_config = None + if args.agent_config: + agent_config = get_agent_config_arg(args.agent_config, args.config_file) + + details = {'mode': args.mode} + _agent_cls = openhands.agenthub.Agent.get_cls(args.agent_cls) + + dataset_description = ( + args.dataset.replace('/', '__') + '-' + args.split.replace('/', '__') + ) + eval_output_dir = os.environ.get('EVAL_OUTPUT_DIR', args.eval_output_dir) + logger.debug(f"Eval output dir: {eval_output_dir}") + metadata = make_metadata( + llm_config, + dataset_description, + args.agent_cls, + args.max_iterations, + args.eval_note, + eval_output_dir, + # args.eval_output_dir, + details=details, + agent_config=agent_config, + condenser_config=condenser_config, + ) + + output_file = os.path.join(metadata.eval_output_dir, 'output.jsonl') + print(f'### OUTPUT FILE: {output_file} ###') + + # Run evaluation in iterative mode: + # If a rollout fails to output AgentFinishAction, we will try again until it succeeds OR total 3 attempts have been made. + ITERATIVE_EVAL_MODE = ( + os.environ.get('ITERATIVE_EVAL_MODE', 'false').lower() == 'true' + ) + ITERATIVE_EVAL_MODE_MAX_ATTEMPTS = int( + os.environ.get('ITERATIVE_EVAL_MODE_MAX_ATTEMPTS', '3') + ) + + if not ITERATIVE_EVAL_MODE: + # load the dataset + instances = prepare_dataset(swe_bench_tests, output_file, args.eval_n_limit) + if len(instances) > 0 and not isinstance( + instances['PASS_TO_PASS'][instances['PASS_TO_PASS'].index[0]], str + ): + for col in ['PASS_TO_PASS', 'FAIL_TO_PASS']: + instances[col] = instances[col].apply(lambda x: str(x)) + + run_evaluation( + instances, + metadata, + output_file, + args.eval_num_workers, + process_instance, + timeout_seconds=8 + * 60 + * 60, # 8 hour PER instance should be more than enough + max_retries=5, + ) + else: + critic = AgentFinishedCritic() + + def get_cur_output_file_path(attempt: int) -> str: + return ( + f'{output_file.removesuffix(".jsonl")}.critic_attempt_{attempt}.jsonl' + ) + + eval_ids = None + for attempt in range(1, ITERATIVE_EVAL_MODE_MAX_ATTEMPTS + 1): + cur_output_file = get_cur_output_file_path(attempt) + logger.info( + f'Running evaluation with critic {critic.__class__.__name__} for attempt {attempt} of {ITERATIVE_EVAL_MODE_MAX_ATTEMPTS}.' + ) + + # For deterministic eval, we set temperature to 0.1 for (>1) attempt + # so hopefully we get slightly different results + if attempt > 1 and metadata.llm_config.temperature == 0: + logger.info( + f'Detected temperature is 0 for (>1) attempt {attempt}. Setting temperature to 0.1...' + ) + metadata.llm_config.temperature = 0.1 + + # Load instances - at first attempt, we evaluate all instances + # On subsequent attempts, we only evaluate the instances that failed the previous attempt determined by critic + instances = prepare_dataset( + swe_bench_tests, cur_output_file, args.eval_n_limit, eval_ids=eval_ids + ) + if len(instances) > 0 and not isinstance( + instances['PASS_TO_PASS'][instances['PASS_TO_PASS'].index[0]], str + ): + for col in ['PASS_TO_PASS', 'FAIL_TO_PASS']: + instances[col] = instances[col].apply(lambda x: str(x)) + + # Run evaluation - but save them to cur_output_file + logger.info( + f'Evaluating {len(instances)} instances for attempt {attempt}...' + ) + run_evaluation( + instances, + metadata, + cur_output_file, + args.eval_num_workers, + process_instance, + timeout_seconds=8 + * 60 + * 60, # 8 hour PER instance should be more than enough + max_retries=5, + ) + + # When eval is done, we update eval_ids to the instances that failed the current attempt + instances_failed = [] + logger.info( + f'Use critic {critic.__class__.__name__} to check {len(instances)} instances for attempt {attempt}...' + ) + with open(cur_output_file, 'r') as f: + for line in f: + instance = json.loads(line) + try: + history = [ + event_from_dict(event) for event in instance['history'] + ] + critic_result = critic.evaluate( + history, instance['test_result'].get('git_patch', '') + ) + if not critic_result.success: + instances_failed.append(instance['instance_id']) + except Exception as e: + logger.error( + f'Error loading history for instance {instance["instance_id"]}: {e}' + ) + instances_failed.append(instance['instance_id']) + logger.info( + f'{len(instances_failed)} instances failed the current attempt {attempt}: {instances_failed}' + ) + eval_ids = instances_failed + + # If no instances failed, we break + if len(instances_failed) == 0: + break + + # Then we should aggregate the results from all attempts into the original output file + # and remove the intermediate files + logger.info( + 'Aggregating results from all attempts into the original output file...' + ) + fout = open(output_file, 'w') + added_instance_ids = set() + for attempt in reversed(range(1, ITERATIVE_EVAL_MODE_MAX_ATTEMPTS + 1)): + cur_output_file = get_cur_output_file_path(attempt) + if not os.path.exists(cur_output_file): + logger.warning( + f'Intermediate output file {cur_output_file} does not exist. Skipping...' + ) + continue + + with open(cur_output_file, 'r') as f: + for line in f: + instance = json.loads(line) + # Also make sure git_patch is not empty - otherwise we fall back to previous attempt (empty patch is worse than anything else) + if ( + instance['instance_id'] not in added_instance_ids + and instance['test_result'].get('git_patch', '').strip() + ): + fout.write(line) + added_instance_ids.add(instance['instance_id']) + logger.info( + f'Aggregated instances from {cur_output_file}. Total instances added so far: {len(added_instance_ids)}' + ) + fout.close() + logger.info( + f'Done! Total {len(added_instance_ids)} instances added to {output_file}' + ) + # Check if any instances reached maximum retries + check_maximum_retries_exceeded(metadata.eval_output_dir) diff --git a/evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh b/evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh new file mode 100755 index 000000000000..47df9a116c93 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh @@ -0,0 +1,150 @@ +#!/usr/bin/env bash +set -eo pipefail + +source "evaluation/utils/version_control.sh" + +MODEL_CONFIG=$1 +COMMIT_HASH=$2 +AGENT=$3 +EVAL_LIMIT=$4 +MAX_ITER=$5 +NUM_WORKERS=$6 +DATASET=$7 +SPLIT=$8 +N_RUNS=$9 +MODE=${10} + + +if [ -z "$NUM_WORKERS" ]; then + NUM_WORKERS=1 + echo "Number of workers not specified, use default $NUM_WORKERS" +fi +checkout_eval_branch + +if [ -z "$AGENT" ]; then + echo "Agent not specified, use default CodeActAgent" + AGENT="CodeActAgent" +fi + +if [ -z "$MAX_ITER" ]; then + echo "MAX_ITER not specified, use default 100" + MAX_ITER=100 +fi + +if [ -z "$RUN_WITH_BROWSING" ]; then + echo "RUN_WITH_BROWSING not specified, use default false" + RUN_WITH_BROWSING=false +fi + + +if [ -z "$DATASET" ]; then + echo "DATASET not specified, use default princeton-nlp/SWE-bench_Lite" + DATASET="princeton-nlp/SWE-bench_Lite" +fi + +if [ -z "$SPLIT" ]; then + echo "SPLIT not specified, use default test" + SPLIT="test" +fi + +if [ -z "$MODE" ]; then + MODE="swe" + echo "MODE not specified, use default $MODE" +fi + +if [ -n "$EVAL_CONDENSER" ]; then + echo "Using Condenser Config: $EVAL_CONDENSER" +else + echo "No Condenser Config provided via EVAL_CONDENSER, use default (NoOpCondenser)." +fi + +export RUN_WITH_BROWSING=$RUN_WITH_BROWSING +echo "RUN_WITH_BROWSING: $RUN_WITH_BROWSING" + +get_openhands_version + +echo "AGENT: $AGENT" +echo "OPENHANDS_VERSION: $OPENHANDS_VERSION" +echo "MODEL_CONFIG: $MODEL_CONFIG" +echo "DATASET: $DATASET" +echo "SPLIT: $SPLIT" +echo "MAX_ITER: $MAX_ITER" +echo "NUM_WORKERS: $NUM_WORKERS" +echo "COMMIT_HASH: $COMMIT_HASH" +echo "MODE: $MODE" +echo "EVAL_CONDENSER: $EVAL_CONDENSER" + +echo "LOCAL_DOCKER_IMAGE_DIR: $LOCAL_DOCKER_IMAGE_DIR" +echo "CONFIG_ML: $CONFIG_ML" +echo "EVAL_OUTPUT_DIR: $EVAL_OUTPUT_DIR" + +# Default to NOT use Hint +if [ -z "$USE_HINT_TEXT" ]; then + export USE_HINT_TEXT=false +fi +echo "USE_HINT_TEXT: $USE_HINT_TEXT" +EVAL_NOTE="$OPENHANDS_VERSION" +# if not using Hint, add -no-hint to the eval note +if [ "$USE_HINT_TEXT" = false ]; then + EVAL_NOTE="$EVAL_NOTE-no-hint" +fi + +if [ "$RUN_WITH_BROWSING" = true ]; then + EVAL_NOTE="$EVAL_NOTE-with-browsing" +fi + +if [ -n "$EXP_NAME" ]; then + EVAL_NOTE="$EVAL_NOTE-$EXP_NAME" +fi +# if mode != swe, add mode to the eval note +if [ "$MODE" != "swe" ]; then + EVAL_NOTE="${EVAL_NOTE}-${MODE}" +fi +# Add condenser config to eval note if provided +if [ -n "$EVAL_CONDENSER" ]; then + EVAL_NOTE="${EVAL_NOTE}-${EVAL_CONDENSER}" +fi + +function run_eval() { + local eval_note="${1}" + COMMAND="poetry run python evaluation/benchmarks/swe_bench/run_infer_local_docker.py \ + --agent-cls $AGENT \ + --llm-config $MODEL_CONFIG \ + --max-iterations $MAX_ITER \ + --eval-num-workers $NUM_WORKERS \ + --eval-note $eval_note \ + --dataset $DATASET \ + --split $SPLIT \ + --mode $MODE" + + + + if [ -n "$EVAL_LIMIT" ]; then + echo "EVAL_LIMIT: $EVAL_LIMIT" + COMMAND="$COMMAND --eval-n-limit $EVAL_LIMIT" + fi + + # Run the command + eval $COMMAND +} + +unset SANDBOX_ENV_GITHUB_TOKEN # prevent the agent from using the github token to push +if [ -z "$N_RUNS" ]; then + N_RUNS=1 + echo "N_RUNS not specified, use default $N_RUNS" +fi + +# Skip runs if the run number is in the SKIP_RUNS list +# read from env variable SKIP_RUNS as a comma separated list of run numbers +SKIP_RUNS=(${SKIP_RUNS//,/ }) +for i in $(seq 1 $N_RUNS); do + if [[ " ${SKIP_RUNS[@]} " =~ " $i " ]]; then + echo "Skipping run $i" + continue + fi + current_eval_note="$EVAL_NOTE-run_$i" + echo "EVAL_NOTE: $current_eval_note" + run_eval $current_eval_note +done + +checkout_original_branch diff --git a/openhands.ipynb b/openhands.ipynb new file mode 100644 index 000000000000..942245cef5a8 --- /dev/null +++ b/openhands.ipynb @@ -0,0 +1,594 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "from datetime import datetime, timedelta\n", + "from typing import Iterable, List, Dict, Optional\n", + "\n", + "# Target markers (cheap substring checks first)\n", + "START_SUBSTR = \"Starting evaluation for instance\"\n", + "BEGIN_SUBSTR = \"BEGIN Runtime Initialization Fn\"\n", + "END_SUBSTR = \"END Runtime Completion Fn\"\n", + "\n", + "# Keep existing robust patterns\n", + "START_RE = re.compile(r'Starting evaluation for instance\\s+(?P.+?)\\.')\n", + "BEGIN_RE = re.compile(r'\\bBEGIN Runtime Initialization Fn\\b')\n", + "END_RE = re.compile(r'\\bEND Runtime Completion Fn\\b')\n", + "\n", + "# Fast timestamp-at-line-start with optional ANSI color codes\n", + "# e.g. \"\\x1b[92m02:18:18\" or \"02:18:18\"\n", + "TS_AT_START_RE = re.compile(\n", + " r'^\\s*(?:\\x1b\\[[0-9;]*m\\s*)*(?P\\d{2}):(?P\\d{2}):(?P\\d{2})'\n", + ")\n", + "\n", + "def _parse_time(h: int, m: int, s: int) -> datetime:\n", + " \"\"\"Force same date for all times.\"\"\"\n", + " return datetime(1970, 1, 1, h, m, s)\n", + "\n", + "def _extract_timestamp_fast(line: str) -> Optional[datetime]:\n", + " \"\"\"\n", + " Only parse HH:MM:SS at the *start* of the line (after optional ANSI codes).\n", + " Returns datetime(1970-01-01 HH:MM:SS) or None.\n", + " \"\"\"\n", + " m = TS_AT_START_RE.match(line)\n", + " if not m:\n", + " return None\n", + " return _parse_time(int(m.group('h')), int(m.group('m')), int(m.group('s')))\n", + "\n", + "def parse_log_triplets(lines: Iterable[str], to_dataframe: bool = False):\n", + " \"\"\"\n", + " Only parse timestamps for lines that contain one of the target markers.\n", + " Perf-friendly: cheap substring checks first, then minimal regex work.\n", + " \"\"\"\n", + " results: List[Dict] = []\n", + " current = None # {'id','t1','t2','t3'}\n", + "\n", + " for line in lines:\n", + " # Cheap pre-filter: skip most lines fast\n", + " if (START_SUBSTR not in line\n", + " and BEGIN_SUBSTR not in line\n", + " and END_SUBSTR not in line):\n", + " continue\n", + "\n", + " # Try to extract timestamp only now\n", + " ts = _extract_timestamp_fast(line)\n", + " if ts is None:\n", + " # If a target line lacks a parsable timestamp, skip (or log/warn)\n", + " continue\n", + "\n", + " # 1) Starting evaluation...\n", + " if START_SUBSTR in line:\n", + " m_start = START_RE.search(line)\n", + " if m_start:\n", + " # Flush partial previous instance if needed\n", + " if current and ('t1' in current) and ('t2' in current) and ('t3' not in current):\n", + " results.append({\n", + " 'instance_id': current['id'],\n", + " 'docker_build_start_ts': current['t1'],\n", + " 'llm_execution_start_ts': current.get('t2'),\n", + " 'end_ts': None,\n", + " 'docker_build_time': (current['t2'] - current['t1']).total_seconds() if current.get('t2') else None,\n", + " 'llm_execution_time': None,\n", + " 'total_time': None,\n", + " 'complete_triplet': False,\n", + " })\n", + " current = {'id': m_start.group('id'), 't1': ts}\n", + " continue\n", + "\n", + " # 2) BEGIN Runtime Initialization Fn\n", + " if BEGIN_SUBSTR in line and BEGIN_RE.search(line):\n", + " if current and 't1' in current and 't2' not in current:\n", + " current['t2'] = ts\n", + " continue\n", + "\n", + " # 3) END Runtime Completion Fn\n", + " if END_SUBSTR in line and END_RE.search(line):\n", + " if current and 't1' in current and 't3' not in current:\n", + " current['t3'] = ts\n", + " results.append({\n", + " 'instance_id': current['id'],\n", + " 'docker_build_start_ts': current['t1'],\n", + " 'llm_execution_start_ts': current.get('t2'),\n", + " 'end_ts': current.get('t3'),\n", + " 'docker_build_time': (current['t2'] - current['t1']).total_seconds() if current.get('t2') else None,\n", + " 'llm_execution_time': (current['t3'] - current['t2']).total_seconds() if current.get('t2') and current.get('t3') else None,\n", + " 'total_time': (current['t3'] - current['t1']).total_seconds() if current.get('t1') and current.get('t3') else None,\n", + " 'complete_triplet': ('t2' in current),\n", + " })\n", + " current = None\n", + " continue\n", + "\n", + " # EOF: flush partial\n", + " if current:\n", + " results.append({\n", + " 'instance_id': current['id'],\n", + " 'docker_build_start_ts': current.get('t1'),\n", + " 'llm_execution_start_ts': current.get('t2'),\n", + " 'end_ts': current.get('t3'),\n", + " 'docker_build_time': (current['t2'] - current['t1']).total_seconds() if current.get('t2') and current.get('t1') else None,\n", + " 'llm_execution_time': (current['t3'] - current['t2']).total_seconds() if current.get('t3') and current.get('t2') else None,\n", + " 'total_time': (current['t3'] - current['t1']).total_seconds() if current.get('t3') and current.get('t1') else None,\n", + " 'complete_triplet': ('t1' in current) and ('t2' in current) and ('t3' in current),\n", + " })\n", + "\n", + " if to_dataframe:\n", + " try:\n", + " import pandas as pd\n", + " df = pd.DataFrame(results)\n", + " cols = [\n", + " 'instance_id', 'docker_build_start_ts', 'llm_execution_start_ts', 'end_ts',\n", + " 'docker_build_time', 'llm_execution_time', 'total_time', 'complete_triplet'\n", + " ]\n", + " return df[cols]\n", + " except ImportError:\n", + " pass\n", + " return results\n", + "\n", + "def parse_log_file(path: str, to_dataframe: bool = False):\n", + " with open(path, 'r', encoding='utf-8', errors='replace') as f:\n", + " return parse_log_triplets(f, to_dataframe=to_dataframe)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "docker_local_log_file = '/workspaces/OpenHands/qwen-coder-30b-small_maxiter_100_N_local_docker_test_10_samples.log'\n", + "docker_remote_log_file = '/workspaces/OpenHands/qwen-coder-30b-small_maxiter_100_N_remote_docker_test_10_samples.log'" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
instance_iddocker_build_start_tsllm_execution_start_tsend_tsdocker_build_timellm_execution_timetotal_timecomplete_triplet
0pyvista__pyvista-4321970-01-01 02:13:421970-01-01 02:14:291970-01-01 02:17:5047.0201.0248.0True
1sqlfluff__sqlfluff-8911970-01-01 02:18:001970-01-01 02:22:401970-01-01 02:26:37280.0237.0517.0True
2pvlib__pvlib-python-16661970-01-01 02:27:001970-01-01 02:31:111970-01-01 02:34:12251.0181.0432.0True
3sqlfluff__sqlfluff-8801970-01-01 02:34:211970-01-01 02:38:351970-01-01 02:41:38254.0183.0437.0True
4pylint-dev__astroid-20151970-01-01 02:41:491970-01-01 02:46:201970-01-01 03:07:55271.01295.01566.0True
5marshmallow-code__marshmallow-21231970-01-01 03:08:081970-01-01 03:12:311970-01-01 03:15:46263.0195.0458.0True
6pyvista__pyvista-36751970-01-01 03:16:441970-01-01 03:22:161970-01-01 03:25:30332.0194.0526.0True
7pvlib__pvlib-python-11761970-01-01 03:25:551970-01-01 03:30:351970-01-01 03:34:41280.0246.0526.0True
8pvlib__pvlib-python-16231970-01-01 03:35:021970-01-01 03:40:041970-01-01 03:42:32302.0148.0450.0True
9pvlib__pvlib-python-14781970-01-01 03:42:551970-01-01 03:47:281970-01-01 03:52:17273.0289.0562.0True
\n", + "
" + ], + "text/plain": [ + " instance_id docker_build_start_ts \\\n", + "0 pyvista__pyvista-432 1970-01-01 02:13:42 \n", + "1 sqlfluff__sqlfluff-891 1970-01-01 02:18:00 \n", + "2 pvlib__pvlib-python-1666 1970-01-01 02:27:00 \n", + "3 sqlfluff__sqlfluff-880 1970-01-01 02:34:21 \n", + "4 pylint-dev__astroid-2015 1970-01-01 02:41:49 \n", + "5 marshmallow-code__marshmallow-2123 1970-01-01 03:08:08 \n", + "6 pyvista__pyvista-3675 1970-01-01 03:16:44 \n", + "7 pvlib__pvlib-python-1176 1970-01-01 03:25:55 \n", + "8 pvlib__pvlib-python-1623 1970-01-01 03:35:02 \n", + "9 pvlib__pvlib-python-1478 1970-01-01 03:42:55 \n", + "\n", + " llm_execution_start_ts end_ts docker_build_time \\\n", + "0 1970-01-01 02:14:29 1970-01-01 02:17:50 47.0 \n", + "1 1970-01-01 02:22:40 1970-01-01 02:26:37 280.0 \n", + "2 1970-01-01 02:31:11 1970-01-01 02:34:12 251.0 \n", + "3 1970-01-01 02:38:35 1970-01-01 02:41:38 254.0 \n", + "4 1970-01-01 02:46:20 1970-01-01 03:07:55 271.0 \n", + "5 1970-01-01 03:12:31 1970-01-01 03:15:46 263.0 \n", + "6 1970-01-01 03:22:16 1970-01-01 03:25:30 332.0 \n", + "7 1970-01-01 03:30:35 1970-01-01 03:34:41 280.0 \n", + "8 1970-01-01 03:40:04 1970-01-01 03:42:32 302.0 \n", + "9 1970-01-01 03:47:28 1970-01-01 03:52:17 273.0 \n", + "\n", + " llm_execution_time total_time complete_triplet \n", + "0 201.0 248.0 True \n", + "1 237.0 517.0 True \n", + "2 181.0 432.0 True \n", + "3 183.0 437.0 True \n", + "4 1295.0 1566.0 True \n", + "5 195.0 458.0 True \n", + "6 194.0 526.0 True \n", + "7 246.0 526.0 True \n", + "8 148.0 450.0 True \n", + "9 289.0 562.0 True " + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "local_df = parse_log_file(docker_local_log_file, to_dataframe=True)\n", + "local_df.head(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
instance_iddocker_build_start_tsllm_execution_start_tsend_tsdocker_build_timellm_execution_timetotal_timecomplete_triplet
0pyvista__pyvista-4321970-01-01 03:11:311970-01-01 03:15:511970-01-01 03:19:11260.0200.0460.0True
1sqlfluff__sqlfluff-8911970-01-01 03:19:151970-01-01 03:23:461970-01-01 03:28:44271.0298.0569.0True
2pvlib__pvlib-python-16661970-01-01 03:28:511970-01-01 03:33:161970-01-01 03:36:19265.0183.0448.0True
3sqlfluff__sqlfluff-8801970-01-01 03:36:211970-01-01 03:40:251970-01-01 03:43:46244.0201.0445.0True
4pylint-dev__astroid-20151970-01-01 03:43:521970-01-01 03:48:141970-01-01 03:57:06262.0532.0794.0True
5marshmallow-code__marshmallow-21231970-01-01 04:00:461970-01-01 04:01:181970-01-01 04:04:1632.0178.0210.0True
6pyvista__pyvista-36751970-01-01 04:04:201970-01-01 04:07:381970-01-01 04:10:58198.0200.0398.0True
7pvlib__pvlib-python-11761970-01-01 04:11:011970-01-01 04:14:061970-01-01 04:18:02185.0236.0421.0True
8pvlib__pvlib-python-16231970-01-01 04:18:031970-01-01 04:21:021970-01-01 04:23:38179.0156.0335.0True
9pvlib__pvlib-python-14781970-01-01 04:23:411970-01-01 04:28:031970-01-01 04:32:43262.0280.0542.0True
\n", + "
" + ], + "text/plain": [ + " instance_id docker_build_start_ts \\\n", + "0 pyvista__pyvista-432 1970-01-01 03:11:31 \n", + "1 sqlfluff__sqlfluff-891 1970-01-01 03:19:15 \n", + "2 pvlib__pvlib-python-1666 1970-01-01 03:28:51 \n", + "3 sqlfluff__sqlfluff-880 1970-01-01 03:36:21 \n", + "4 pylint-dev__astroid-2015 1970-01-01 03:43:52 \n", + "5 marshmallow-code__marshmallow-2123 1970-01-01 04:00:46 \n", + "6 pyvista__pyvista-3675 1970-01-01 04:04:20 \n", + "7 pvlib__pvlib-python-1176 1970-01-01 04:11:01 \n", + "8 pvlib__pvlib-python-1623 1970-01-01 04:18:03 \n", + "9 pvlib__pvlib-python-1478 1970-01-01 04:23:41 \n", + "\n", + " llm_execution_start_ts end_ts docker_build_time \\\n", + "0 1970-01-01 03:15:51 1970-01-01 03:19:11 260.0 \n", + "1 1970-01-01 03:23:46 1970-01-01 03:28:44 271.0 \n", + "2 1970-01-01 03:33:16 1970-01-01 03:36:19 265.0 \n", + "3 1970-01-01 03:40:25 1970-01-01 03:43:46 244.0 \n", + "4 1970-01-01 03:48:14 1970-01-01 03:57:06 262.0 \n", + "5 1970-01-01 04:01:18 1970-01-01 04:04:16 32.0 \n", + "6 1970-01-01 04:07:38 1970-01-01 04:10:58 198.0 \n", + "7 1970-01-01 04:14:06 1970-01-01 04:18:02 185.0 \n", + "8 1970-01-01 04:21:02 1970-01-01 04:23:38 179.0 \n", + "9 1970-01-01 04:28:03 1970-01-01 04:32:43 262.0 \n", + "\n", + " llm_execution_time total_time complete_triplet \n", + "0 200.0 460.0 True \n", + "1 298.0 569.0 True \n", + "2 183.0 448.0 True \n", + "3 201.0 445.0 True \n", + "4 532.0 794.0 True \n", + "5 178.0 210.0 True \n", + "6 200.0 398.0 True \n", + "7 236.0 421.0 True \n", + "8 156.0 335.0 True \n", + "9 280.0 542.0 True " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "remote_df = parse_log_file(docker_remote_log_file, to_dataframe=True)\n", + "remote_df.head(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Local totals (minutes):\n", + "docker_build_time 42.550000\n", + "llm_execution_time 52.816667\n", + "total_time 95.366667\n", + "dtype: float64\n", + "\n", + "Remote totals (minutes):\n", + "docker_build_time 35.966667\n", + "llm_execution_time 41.066667\n", + "total_time 77.033333\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "# Total times across all instances\n", + "local_totals = local_df[[\"docker_build_time\", \"llm_execution_time\", \"total_time\"]].sum()\n", + "remote_totals = remote_df[[\"docker_build_time\", \"llm_execution_time\", \"total_time\"]].sum()\n", + "\n", + "print(\"Local totals (minutes):\")\n", + "print(local_totals / 60)\n", + "print(\"\\nRemote totals (minutes):\")\n", + "print(remote_totals / 60)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index c386b2444763..fba9e56c69fa 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -58,13 +58,13 @@ # Optional: in the long run, move this into AgentConfig @dataclass class AutoReflectionConfig: - enabled: bool = False + enabled: bool = True # Probabilistic trigger: after each observation event, fire with probability `prob` prob: float = 0.10 # Reactive trigger: check last turn for "no tool" or "error observation" reactive_enabled: bool = True # How many past events to consider for the โ€œlast N stepsโ€ wording - lookback_window: int = 3 + lookback_window: int = 5 # The seeded thought text; {n} is formatted with lookback_window prompt: str = ( "Look back at the last {n} steps. Are you making good progress, or should you " @@ -240,7 +240,7 @@ def step(self, state: State) -> 'Action': if self.auto_reflect.enabled: if self.auto_reflect.reactive_enabled: is_last_turn_tool_error, tool_call_error_message =self._last_turn_has_tool_error(condensed_history) - if is_last_turn_tool_error and not self._last_action_is_autoreflect(condensed_history): + if is_last_turn_tool_error and not self._last_action_is_think(condensed_history): self.pending_actions.clear() # clear the queue self._num_steps += 1 self._last_reflection_step = self._num_steps @@ -252,7 +252,7 @@ def step(self, state: State) -> 'Action': if random.random() < self.auto_reflect.prob and \ not self.pending_actions and \ self._last_reflection_step != self._num_steps and \ - not self._last_action_is_autoreflect(condensed_history): + not self._last_action_is_think(condensed_history): self._num_steps += 1 self._last_reflection_step = self._num_steps @@ -416,16 +416,17 @@ def _emit_reflection(self, text: str) -> MessageAction: msg._source = EventSource.AGENT # <-- set source after init return msg - def _last_action_is_autoreflect(self, events) -> bool: - # Scan backwards, skip observations; stop on the last action/message. + def _last_action_is_think(self, events) -> bool: + """Return True if the last non-observation event is a Think/Reflection action.""" for ev in reversed(events): name = ev.__class__.__name__.lower() if name.endswith("observation"): - continue - if isinstance(ev, MessageAction) and getattr(ev, "_source", None) == EventSource.AGENT: - text = (getattr(ev, "content", "") or "").strip().lower() - return text.startswith("[autoreflect]") - if name.endswith("action"): - # last action but not our autoreflect - return False - return False + continue # skip + # we've reached the last non-observation event + if name.endswith("action") and "think" in name: + print("Do not do reflection given last action is already think/reflection...") + return True + else: + return False # stop after first non-observation event + return False # no actions found + diff --git a/openhands/runtime/impl/docker/docker_runtime.py b/openhands/runtime/impl/docker/docker_runtime.py index 0dfc1e8946d0..ecf4106f56b9 100644 --- a/openhands/runtime/impl/docker/docker_runtime.py +++ b/openhands/runtime/impl/docker/docker_runtime.py @@ -4,6 +4,8 @@ from functools import lru_cache from typing import Callable from uuid import UUID +import os, glob +from pathlib import Path import docker import httpx @@ -231,6 +233,23 @@ async def connect(self) -> None: self.log('error', str(e)) def maybe_build_runtime_container_image(self): + repo, index = self.get_info_from_base_image() + + runtime_docker_image_folder = self.find_folder_by_prefix_suffix(repo, index, "/workspaces/OpenHands") + tar_files = glob.glob(os.path.join(runtime_docker_image_folder, "*.tar")) + if not tar_files: + raise FileNotFoundError("No .tar file found!") + elif len(tar_files) > 1: + raise RuntimeError("More than one .tar file found!") + else: + tar_path = tar_files[0] + logger.debug(f"[Michael] Found tar file: {tar_path}") + + logger.debug(f"[Michael] Loading local runtime image from {tar_path} ...") + with open(tar_path, "rb") as f: + self.runtime_container_image = self.docker_client.images.load(f.read())[0] + logger.debug(f"[Michael] Successfuly loaded local runtime image from {tar_path} ...") + if self.runtime_container_image is None: if self.base_container_image is None: raise ValueError( @@ -247,6 +266,37 @@ def maybe_build_runtime_container_image(self): enable_browser=self.config.enable_browser, ) + + def find_folder_by_prefix_suffix(self, input_a, input_b, search_dir): + matches = [] + for p in Path(search_dir).iterdir(): + if p.is_dir() and p.name.startswith(input_a) and p.name.endswith(input_b): + matches.append(p) + + if matches: + print("โœ… Found matching folder(s):") + for m in matches: + print(" ", m) + + assert len(matches) == 1, "No folder found..." + return matches[0] + + + + def get_info_from_base_image(self): + if self.base_container_image.startswith("docker.io"): + repo = self.base_container_image.split(":")[0].split("/")[-1].split(".")[-1].split("__")[0] + index = self.base_container_image.split(":")[0].split("/")[-1].split(".")[-1].split("-")[-1] + return repo, index + elif self.base_container_image.startswith("openhands_local"): + repo = self.base_container_image.split(":")[0].split("-")[0].split("_")[-1] + index = self.base_container_image.split(":")[0].split("-")[-1] + return repo, index + else: + raise ValueError( + 'This base_container_image is not available either on the cloud or locally' + ) + @staticmethod @lru_cache(maxsize=1) def _init_docker_client() -> docker.DockerClient: diff --git a/save_runtime_image_local.py b/save_runtime_image_local.py new file mode 100644 index 000000000000..9b67ee5b7fbd --- /dev/null +++ b/save_runtime_image_local.py @@ -0,0 +1,83 @@ +import os +import docker +import subprocess +from tqdm import tqdm +import time +from openhands.runtime.utils.runtime_build import build_runtime_image +from openhands.runtime.builder import DockerRuntimeBuilder + +# --- Config --- +client = docker.from_env() +docker_builder = DockerRuntimeBuilder(client) + +def instance_id_to_remote_name(instance_id): + docker_image_prefix = 'docker.io/swebench/' + repo, name = instance_id.split('__') + return f'{docker_image_prefix.rstrip("/")}/sweb.eval.x86_64.{repo}_1776_{name}:latest'.lower() + +base_image_dir = "/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images" +output_root = "/workspaces/Openhands/swebench_dockers_for_eval/runtime_dockers/swebench_dev" + +tar_files = [f for f in os.listdir(base_image_dir) if f.endswith('.tar')] +instance_names = [f.removesuffix('__latest.tar') for f in tar_files] + +MAX_RETRIES = 3 +RETRY_DELAY = 10 # seconds + +def is_valid_tar(path: str) -> bool: + """Quickly verify that a .tar file contains a valid Docker image.""" + if not os.path.exists(path) or os.path.getsize(path) < 1024 * 100: # <100 KB โ†’ suspicious + return False + try: + subprocess.run( + ["docker", "load", "-i", path], + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + check=True, + ) + return True + except subprocess.CalledProcessError: + return False + +for instance_name in tqdm(instance_names): + base_image_name = instance_id_to_remote_name(instance_name) + output_dir = os.path.join(output_root, instance_name) + + # --- Skip if valid tar already exists --- + if os.path.isdir(output_dir): + tar_candidates = [os.path.join(output_dir, f) for f in os.listdir(output_dir) if f.endswith(".tar")] + if tar_candidates: + latest_tar = max(tar_candidates, key=os.path.getmtime) + if is_valid_tar(latest_tar): + print(f"โญ๏ธ Skipping {instance_name} (valid image already exists: {os.path.basename(latest_tar)})") + continue + else: + print(f"โš ๏ธ Found existing tar for {instance_name} but itโ€™s invalid โ†’ rebuilding") + + # --- Build with retries --- + for attempt in range(1, MAX_RETRIES + 1): + try: + image_name = build_runtime_image( + base_image_name, + docker_builder, + platform=None, + enable_browser=True, + ) + print(f"Built image: {image_name}") + + os.makedirs(output_dir, exist_ok=True) + safe_image_name = image_name.split("/")[-1].split(":")[-1] + tar_path = os.path.join(output_dir, f"{safe_image_name}.tar") + + print(f"Saving image to {tar_path} ...") + subprocess.run(["docker", "save", "-o", tar_path, image_name], check=True) + print(f"โœ… Image saved to: {tar_path}") + break # success โ†’ exit retry loop + + except Exception as e: + print(f"โš ๏ธ Build failed for {instance_name} (attempt {attempt}/{MAX_RETRIES}): {e}") + if attempt < MAX_RETRIES: + print(f"Retrying in {RETRY_DELAY} seconds...") + time.sleep(RETRY_DELAY) + else: + print(f"โŒ Giving up on {instance_name} after {MAX_RETRIES} attempts.") From f147e6b03f8cd270a55d05165f8be2ba15254bce Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Sat, 25 Oct 2025 22:18:15 +0000 Subject: [PATCH 06/12] end to end running with all local dockers --- .devcontainer/devcontainer.json | 3 +- evaluation/benchmarks/swe_bench/config_2.toml | 27 + .../other_scripts/bash_tool_call_summary.py | 442 ++++++++++++++ .../bash_tool_call_summary_filtered.py | 569 ++++++++++++++++++ .../generate_localisation_report.py | 219 +++++++ .../other_scripts/generate_run_summary.py | 160 +++++ .../other_scripts/run_end_to_end_local.sh | 219 +++++++ evaluation/utils/shared.py | 13 +- .../agenthub/codeact_agent/codeact_agent.py | 2 +- .../runtime/impl/docker/docker_runtime.py | 105 +++- save_runtime_image_local.py | 70 ++- 11 files changed, 1780 insertions(+), 49 deletions(-) create mode 100644 evaluation/benchmarks/swe_bench/config_2.toml create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary.py create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary_filtered.py create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/generate_localisation_report.py create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/generate_run_summary.py create mode 100755 evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 585cb316d15b..0475cfd7e9c0 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -17,7 +17,8 @@ "DOCKER_HOST_ADDR": "host.docker.internal" }, "mounts": [ - "source=/mlf11-shared/swebench_dockers_for_eval,target=/workspaces/Openhands/swebench_dockers_for_eval,type=bind,consistency=cached" // the Openhands instead of OpenHands is intentional, due to file mounting issues + "source=/mlf11-shared/swebench_dockers_for_eval,target=/workspaces/Openhands/swebench_dockers_for_eval,type=bind,consistency=cached", // the Openhands instead of OpenHands is intentional, due to file mounting issues + "source=/mlf15-shared/michaelw,target=/workspaces/Openhands/michaelw,type=bind,consistency=cached" // the Openhands instead of OpenHands is intentional, due to file mounting issues ], "customizations": { "vscode": { diff --git a/evaluation/benchmarks/swe_bench/config_2.toml b/evaluation/benchmarks/swe_bench/config_2.toml new file mode 100644 index 000000000000..901252f95d6f --- /dev/null +++ b/evaluation/benchmarks/swe_bench/config_2.toml @@ -0,0 +1,27 @@ +selected_ids = [ + "pvlib__pvlib-python-1707", + "pylint-dev__astroid-1614", + "sqlfluff__sqlfluff-884", + "pydicom__pydicom-1192", + "pvlib__pvlib-python-1589", + "pylint-dev__astroid-1616", + "sqlfluff__sqlfluff-905", + "pydicom__pydicom-938", + "marshmallow-code__marshmallow-1343", + "sqlfluff__sqlfluff-2419", + "pvlib__pvlib-python-1854", + "pylint-dev__astroid-1719", + "marshmallow-code__marshmallow-1164", + "marshmallow-code__marshmallow-1252", + "pydicom__pydicom-965", + "pylint-dev__astroid-1903", + "pydicom__pydicom-1694", + "pylint-dev__astroid-1196", + "pydicom__pydicom-1256", + "pydicom__pydicom-1228", + "pvlib__pvlib-python-1738", + "pvlib__pvlib-python-1349", + "pylint-dev__astroid-1962", + "pylint-dev__astroid-1959", + "marshmallow-code__marshmallow-1810", +] diff --git a/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary.py b/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary.py new file mode 100644 index 000000000000..0a3e900902b3 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary.py @@ -0,0 +1,442 @@ +import json +import os +import logging +import matplotlib.pyplot as plt +import argparse +import toml + + + +# qwen_input_file = '/cb/home/harshg/mlf2/agentic_flows/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench_Verified-test/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_v0.54.0-no-hint-run_1/output.jsonl' +# gpt_oss_file ='/cb/home/harshg/mlf2/agentic_flows/OpenHands/evaluation/evaluation_outputs_aarti_fix_50/outputs/princeton-nlp__SWE-bench_Verified-test/CodeActAgent/gpt-oss-120b-small_maxiter_100_N_v0.54.0-no-hint-summarizer_for_eval_gptoss-120b-run_1/output.jsonl' +# output_dir_gpt_oss = "/cb/home/harshg/mlf2/agentic_flows/summaries_new/gpt_oss_120b__summary" +# output_dir_qwen = "/cb/home/harshg/mlf2/agentic_flows/summaries_new/qwen_coder_30b_tool_call__summary" + +# qwen_480b_input = "/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench_Verified-test/CodeActAgent/qwen-3-coder-480b_maxiter_250_N_v0.56.0-no-hint-run_1/output.jsonl" +# qwen_480b_output = "/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench_Verified-test/CodeActAgent/qwen-3-coder-480b_maxiter_250_N_v0.56.0-no-hint-run_1" + + +# qwen_30b_input = "/workspaces/OpenHands/evaluation/evaluation_outputs_50_cmd_loc/outputs/princeton-nlp__SWE-bench_Verified-test/CodeActAgent/qwen-coder-30b-small_maxiter_250_N_v0.56.0-no-hint-run_1/output.jsonl" +# qwen_30b_output = "/workspaces/OpenHands/evaluation/evaluation_outputs_50_cmd_loc/outputs/princeton-nlp__SWE-bench_Verified-test/CodeActAgent/qwen-coder-30b-small_maxiter_250_N_v0.56.0-no-hint-run_1/logs/bash_tools_summary_2" + + + +def get_search_text_groups(): + search_text_groups = { + "Empty_patches": { + "include": ['"test_result": {"git_patch": ""}'], + "exclude": [] + }, + "Non-empty_patches": { + "include": ['"test_result": {"git_patch": "diff'], + "exclude": [] + }, + "agentGotStuckError": { + "include": ['AgentStuckInLoopError: Agent got stuck in a loop'], + "exclude": [] + }, + "agentGotStuckError_and_empty_patches": { + "include": ['AgentStuckInLoopError: Agent got stuck in a loop','"test_result": {"git_patch": ""}'], + "exclude": [] + }, + "agentGotStuckError_and_non_empty_patches": { + "include": ['AgentStuckInLoopError: Agent got stuck in a loop','"test_result": {"git_patch": "diff'], + "exclude": [] + }, + "without_errror_and_non_empty_patches": { + "include": ['"test_result": {"git_patch": "diff'], + "exclude": ["AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR", "AgentStuckInLoopError: Agent got stuck in a loop",'RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','RuntimeError: There was an unexpected error while','STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'] + }, + "without_error_and_empty_patches": { + "include": ['"test_result": {"git_patch": ""}'], + "exclude": ["AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR", "AgentStuckInLoopError: Agent got stuck in a loop",'RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','RuntimeError: There was an unexpected error while','STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'] + }, + 'without_error_patches': { + 'include': [], + 'exclude': ["AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR", "AgentStuckInLoopError: Agent got stuck in a loop",'RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','RuntimeError: There was an unexpected error while','STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'] + }, + 'max_iters_error_and_non_empty_patches' : { + "include": ['RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','"test_result": {"git_patch":"diff'], + "exclude": [] + }, + "max_iters_error_and_empty_patches" : { + "include": ['RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','"test_result": {"git_patch": ""}'], + "exclude": [] + }, + 'max_iters_error' : { + "include": ['RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100'], + "exclude": [] + }, + "runtime_errors":{ + "include": ['RuntimeError: There was an unexpected error while'], + "exclude": [] + }, + "runtime_error_empty_patches":{ + "include": ['RuntimeError: There was an unexpected error while','"test_result": {"git_patch": ""}'], + "exclude": [] + }, + "runtime_error_non_empty_patches":{ + "include": ['RuntimeError: There was an unexpected error while','"test_result": {"git_patch": "diff'], + "exclude": [] + }, + "llm_internal_server_error":{ + "include": ['STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'], + "exclude": [] + }, + } + return search_text_groups + + +def plot_histograms(summary_data, group_name, output_dir): + # Create a directory for plots + plots_dir = os.path.join(output_dir, "plots", group_name) + os.makedirs(plots_dir, exist_ok=True) + + # Plot total bash tool calls + if summary_data['total_bash_tool_calls']: + plt.figure(figsize=(10, 6)) + bars = plt.bar(summary_data['total_bash_tool_calls'].keys(), summary_data['total_bash_tool_calls'].values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Total Bash Tool Calls for {group_name}") + plt.xlabel("Bash Tools") + plt.ylabel("Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"total_bash_tool_calls.png")) + plt.close() + + # Plot average bash tool calls per instance + if summary_data['avg_bash_tool_calls_per_instance']: + plt.figure(figsize=(10, 6)) + bars = plt.bar(summary_data['avg_bash_tool_calls_per_instance'].keys(), summary_data['avg_bash_tool_calls_per_instance'].values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Average Bash Tool Calls per Instance for {group_name}") + plt.xlabel("Bash Tools") + plt.ylabel("Average Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"avg_bash_tool_calls_per_instance.png")) + plt.close() + + # Plot total tool calls + if summary_data['total_tool_calls']: + plt.figure(figsize=(10, 6)) + bars = plt.bar(summary_data['total_tool_calls'].keys(), summary_data['total_tool_calls'].values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Total Tool Calls for {group_name}") + plt.xlabel("Tools") + plt.ylabel("Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"total_tool_calls.png")) + plt.close() + + # Plot average tool calls per instance + if summary_data['avg_tool_calls_per_instance']: + plt.figure(figsize=(10, 6)) + bars = plt.bar(summary_data['avg_tool_calls_per_instance'].keys(), summary_data['avg_tool_calls_per_instance'].values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Average Tool Calls per Instance for {group_name}") + plt.xlabel("Tools") + plt.ylabel("Average Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"avg_tool_calls_per_instance.png")) + plt.close() + + + + +def add_item(dict_obj, key, value): + if key in dict_obj: + dict_obj[key].append(value) + else: + dict_obj[key] = [value] + + +def eval_entry(entry, logger): + history = entry['history'][3:] + conversation_size = len(history) + events = [] + out_source = [] + bash_tool_summary = {} # {'ls': {'count': , list: [{'id', 'command' }]}, {} + source = {} + source_ids_list = {} + events_list = [] + tool_call_counts = {} + agent_messages = [] + user_messages = {} + observations = {} + agent_calls = [] + # observation_list = [ {id,action, output}] + # action_list = [ {id, action, command} ] + + + for item in history: + + + ## Count source occurrences and store ids + if item['source'] not in source_ids_list: + source_ids_list[item['source']] = [] + source[item['source']] = 0 + source_ids_list[item['source']].append(item['id']) + source[item['source']] +=1 + + + action = item.get('action', '') + observation = item.get('observation', '') + try: + if observation!= '': + events_list.append(f"id_{item['id']}_{item['source']}_observation_{observation} {item['message']}") + add_item(observations, item['source'], str({'id': item['id'], 'source': item['source'] ,'observation': observation ,'message': item['message']})) + elif action != '': + + if item['source'] == 'agent': + ### tools to summarize "edit/run/finish/message/think/" + if action in ['edit', 'run', 'finish', 'think', 'task_tracking', 'run_ipython', 'view', 'read']: + function_name = item.get('tool_call_metadata', {}).get('function_name', '') + events_list.append(f"id_{item['id']}_{item['source']}_action_{action}_{function_name} {item['message']}") + agent_calls.append({'id': item['id'], 'action': action, 'function_name': item['tool_call_metadata']['function_name'], 'message': item['message']}) + ### tool call summary ##### + tool_name = item['tool_call_metadata']['function_name'] + if tool_name not in tool_call_counts: + tool_call_counts[tool_name] = 0 + tool_call_counts[tool_name] += 1 + + + #### bash tool summary ##### + if action == 'run': + if item['tool_call_metadata']['function_name'] == 'execute_bash': + command = item['message'].split('Running command: ')[-1].strip() + for cmd in command.split('&&'): + prefix = cmd.strip().split(' ')[0] + cmd = cmd.strip() + prefix = prefix.split('<')[0].split('>')[0].split('=')[0] # Handle redirection + if prefix not in bash_tool_summary: + bash_tool_summary[prefix] = {'count': 0, 'list': []} + bash_tool_summary[prefix]['count'] += 1 + bash_tool_summary[prefix]['list'].append({'id': item['id'], 'command': command}) + ########################### + + ##### empty messages ##### + elif action == 'message': + events_list.append(f"id_{item['id']}_{item['source']}_action_{action} {item['message']}") + if item['message'].strip() == '': + agent_messages.append({'id': item['id'], 'message': item['message']}) + ########################### + elif action == 'condensation': + events_list.append(f"id_{item['id']}_{item['source']}_action_{action} {item['message']}") + agent_calls.append({'id': item['id'], 'action': action, 'function_name':'condensation','message': item['message']}) + else: + logger.warning(f"Unrecognized agent action without tool_call_metadata: {item}") + + elif item['source'] == 'user': + events_list.append(f"id_{item['id']}_{item['source']}_action_{action} {item['message']}") + add_item(user_messages, action, {'id': item['id'], 'message': item['message']}) + + else: + logger.warning(f"Unrecognized source with action: {item}") + + + else: + logger.warning(f"\n\nItem with no action or observation: {item}\n\n") + except Exception as e: + logger.error(f"\n\nError processing item {item}: {e}\n\n") + bash_tool_call_counts = {tool: details['count'] for tool, details in bash_tool_summary.items()} + + summary = { + 'instance_id': entry.get('instance_id', ''), + 'error': entry.get('error', ''), + 'conversation_size': conversation_size, + 'source_counts': source, + 'tool_call_counts': tool_call_counts, + 'bash_tool_call_counts': bash_tool_call_counts, + 'agent_calls': agent_calls, + 'agent_messages': agent_messages, + 'observations': observations, + 'user_messages': user_messages, + 'events': events_list, + 'bash_tool_call_summary': bash_tool_summary, + 'source_ids': source_ids_list, + } + + return summary + + +def summary_file(group_name, filtered_entries, summary_dir, logger): + summaries = [] + bash_tool_calls = {} + tool_calls = {} + for entry in filtered_entries: + summary = eval_entry(entry, logger) + summaries.append(summary) + # Aggregate bash tool calls + for tool, count in summary['bash_tool_call_counts'].items(): + if tool not in bash_tool_calls: + bash_tool_calls[tool] = 0 + bash_tool_calls[tool] += count + + # tool_call_counts + for tool, count in summary['tool_call_counts'].items(): + if tool not in tool_calls: + tool_calls[tool] = 0 + tool_calls[tool] += count + + ### avg tool calls per instance + avg_tool_calls = {tool: count / len(filtered_entries) for tool, count in tool_calls.items()} + avg_bash_tool_calls = {tool: count / len(filtered_entries) for tool, count in bash_tool_calls.items()} + + # Save summaries to a JSON file + summary_file_path = os.path.join(summary_dir, f"{group_name}_summary.json") + with open(summary_file_path, 'w') as summary_outfile: + json.dump(summaries, summary_outfile, indent=4) + logger.info(f"Summary saved to: {summary_file_path}") + + return { + 'total_bash_tool_calls': bash_tool_calls, + 'avg_bash_tool_calls_per_instance': avg_bash_tool_calls, + 'total_tool_calls': tool_calls, + 'avg_tool_calls_per_instance': avg_tool_calls + } + + + +# Function to save metadata +def save_metadata(group_name, filtered_entries, summary, metadata_dir, logger): + metadata = { + "group_name": group_name, + "entry_count": len(filtered_entries), + "inclusion_criteria": search_text_groups[group_name].get("include", []), + "exclusion_criteria": search_text_groups[group_name].get("exclude", []), + "summary": summary, + "instance_ids": [entry.get("instance_id") for entry in filtered_entries], + } + metadata_file = os.path.join(metadata_dir, f"{group_name}_metadata.json") + with open(metadata_file, 'w') as meta_outfile: + json.dump(metadata, meta_outfile, indent=4) + logger.info(f"Metadata saved to: {metadata_file}") + + +# Function to filter entries +def filter_entries(input_file, search_text_groups, output_dir, metadata_dir, summary_dir, logger, selected_ids): + with open(input_file, 'r') as infile: + lines = infile.readlines() + + for group_name, criteria in search_text_groups.items(): + include_texts = criteria.get("include", []) + exclude_texts = criteria.get("exclude", []) + filtered_entries = [] + + for line in lines: + try: + entry = json.loads(line) + text = json.dumps(entry) # Convert entry back to string for searching + + if selected_ids is not None and entry["instance_id"] not in selected_ids: + logger.info(f"Skipping {entry['instance_id']} since not in selected_ids") + continue + + # Check inclusion criteria (all must be present) + if all(inc_text in text for inc_text in include_texts): + # Check exclusion criteria (none must be present) + if not any(exc_text in line for exc_text in exclude_texts): + filtered_entries.append(entry) + except json.JSONDecodeError: + logger.info(f"Skipping invalid JSON line: {line}") + + # Create subdirectories for JSON and JSONL files + json_dir = os.path.join(output_dir, "json") + jsonl_dir = os.path.join(output_dir, "jsonl") + os.makedirs(json_dir, exist_ok=True) + os.makedirs(jsonl_dir, exist_ok=True) + + if not filtered_entries: + print(f"No entries found for group: {group_name}") + continue + # Save filtered entries to a new JSONL file + print(f"Group: {group_name}, Found {len(filtered_entries)} matching entries.") + jsonl_output_file = os.path.join(jsonl_dir, f"{group_name}_filtered.jsonl") + with open(jsonl_output_file, 'w') as outfile: + for entry in filtered_entries: + outfile.write(json.dumps(entry) + '\n') + logger.info(f"Filtered entries saved to: {jsonl_output_file}") + + # Save filtered entries to a new JSON file + json_output_file = os.path.join(json_dir, f"{group_name}_filtered.json") + with open(json_output_file, 'w') as json_outfile: + json.dump(filtered_entries, json_outfile, indent=4) + logger.info(f"Filtered entries saved to: {json_output_file}") + + print(f"---- Evaluating summaries for group: {group_name} {len(filtered_entries)}") + summary = summary_file(group_name, filtered_entries, summary_dir, logger) + + plot_histograms(summary, group_name, output_dir) + + + # Save metadata + save_metadata(group_name, filtered_entries, summary, metadata_dir, logger) + +def parse_arguments(): + parser = argparse.ArgumentParser(description="Filter JSONL entries based on search criteria.") + parser.add_argument("--input_file", type=str, help="Path to the input output JSONL file.") + parser.add_argument("--output_dir", type=str, help="Directory to save the output files.") + parser.add_argument('--selected_ids', type=str, required=False, default=None, help="Pass toml file with key selected_ids") + return parser.parse_args() + + +def setup_logging(output_dir): + log_file = os.path.join(output_dir, "summary_openhands.log") + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(levelname)s - %(message)s", + handlers=[ + logging.StreamHandler(), + logging.FileHandler(log_file, mode='w') + ] + ) + return logging.getLogger(__name__) + + + + +if __name__ == "__main__": + + args = parse_arguments() + input_file = args.input_file + output_dir = args.output_dir + + os.makedirs(output_dir, exist_ok=True) + + # Additional folder for metadata + metadata_dir = os.path.join(output_dir, "metadata") + summary_dir = os.path.join(output_dir, "summary") + os.makedirs(metadata_dir, exist_ok=True) + os.makedirs(summary_dir, exist_ok=True) + + search_text_groups = get_search_text_groups() + logger = setup_logging(output_dir) + + selected_ids = None + if args.selected_ids is not None: + selected_ids = toml.load(args.selected_ids)["selected_ids"] + + logger.info(f"Selected_IDS: {selected_ids}") + + # Run the filtering process + filter_entries(input_file, search_text_groups, output_dir, metadata_dir, summary_dir, logger, selected_ids) diff --git a/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary_filtered.py b/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary_filtered.py new file mode 100644 index 000000000000..36389fddb7ca --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary_filtered.py @@ -0,0 +1,569 @@ +import json +import os +import logging +import matplotlib.pyplot as plt +import argparse +import toml + + + +def get_search_text_groups(): + search_text_groups = { + "Empty_patches": { + "include": ['"test_result": {"git_patch": ""}'], + "exclude": [] + }, + "Non-empty_patches": { + "include": ['"test_result": {"git_patch": "diff'], + "exclude": [] + }, + "agentGotStuckError": { + "include": ['AgentStuckInLoopError: Agent got stuck in a loop'], + "exclude": [] + }, + "agentGotStuckError_and_empty_patches": { + "include": ['AgentStuckInLoopError: Agent got stuck in a loop','"test_result": {"git_patch": ""}'], + "exclude": [] + }, + "agentGotStuckError_and_non_empty_patches": { + "include": ['AgentStuckInLoopError: Agent got stuck in a loop','"test_result": {"git_patch": "diff'], + "exclude": [] + }, + "without_errror_and_non_empty_patches": { + "include": ['"test_result": {"git_patch": "diff'], + "exclude": ["AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR", "AgentStuckInLoopError: Agent got stuck in a loop",'RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','RuntimeError: There was an unexpected error while','STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'] + }, + "without_error_and_empty_patches": { + "include": ['"test_result": {"git_patch": ""}'], + "exclude": ["AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR", "AgentStuckInLoopError: Agent got stuck in a loop",'RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','RuntimeError: There was an unexpected error while','STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'] + }, + 'without_error_patches': { + 'include': [], + 'exclude': ["AGENT_ERROR$ERROR_ACTION_NOT_EXECUTED_ERROR", "AgentStuckInLoopError: Agent got stuck in a loop",'RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','RuntimeError: There was an unexpected error while','STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'] + }, + 'max_iters_error_and_non_empty_patches' : { + "include": ['RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','"test_result": {"git_patch":"diff'], + "exclude": [] + }, + "max_iters_error_and_empty_patches" : { + "include": ['RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100','"test_result": {"git_patch": ""}'], + "exclude": [] + }, + 'max_iters_error' : { + "include": ['RuntimeError: Agent reached maximum iteration. Current iteration: 100, max iteration: 100'], + "exclude": [] + }, + "runtime_errors":{ + "include": ['RuntimeError: There was an unexpected error while'], + "exclude": [] + }, + "runtime_error_empty_patches":{ + "include": ['RuntimeError: There was an unexpected error while','"test_result": {"git_patch": ""}'], + "exclude": [] + }, + "runtime_error_non_empty_patches":{ + "include": ['RuntimeError: There was an unexpected error while','"test_result": {"git_patch": "diff'], + "exclude": [] + }, + "llm_internal_server_error":{ + "include": ['STATUS$ERROR_LLM_INTERNAL_SERVER_ERROR'], + "exclude": [] + }, + } + return search_text_groups + + + +def plot_histograms(summary_data, group_name, output_dir): + + def sort_data(data_dict): + return dict(sorted(data_dict.items(), key=lambda item: item[1], reverse=True)) + # Create a directory for plots + plots_dir = os.path.join(output_dir, "plots", group_name) + os.makedirs(plots_dir, exist_ok=True) + + num_instances = summary_data['num_instances'] + + # Plot total bash tool calls + if summary_data['total_bash_tool_calls']: + sorted_data = sort_data(summary_data['total_bash_tool_calls']) + plt.figure(figsize=(10, 6)) + bars = plt.bar(sorted_data.keys(), sorted_data.values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Total Bash Tool Calls for {group_name}={sum(list(sorted_data.values()))}, num_instances={num_instances}") + plt.xlabel("Bash Tools") + plt.ylabel("Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"total_bash_tool_calls.png")) + plt.close() + + # Plot average bash tool calls per instance + if summary_data['avg_bash_tool_calls_per_instance']: + sorted_data = sort_data(summary_data['avg_bash_tool_calls_per_instance']) + plt.figure(figsize=(10, 6)) + bars = plt.bar(sorted_data.keys(), sorted_data.values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Average Bash Tool Calls per Instance for {group_name}, num_instances={num_instances}") + plt.xlabel("Bash Tools") + plt.ylabel("Average Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"avg_bash_tool_calls_per_instance.png")) + plt.close() + + # Plot total tool calls + if summary_data['total_tool_calls']: + sorted_data = sort_data(summary_data['total_tool_calls']) + plt.figure(figsize=(10, 6)) + bars = plt.bar(sorted_data.keys(), sorted_data.values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Total Tool Calls for {group_name}={sum(list(sorted_data.values()))}, num_instances={num_instances}") + plt.xlabel("Tools") + plt.ylabel("Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"total_tool_calls.png")) + plt.close() + + # Plot average tool calls per instance + if summary_data['avg_tool_calls_per_instance']: + sorted_data = sort_data(summary_data['avg_tool_calls_per_instance']) + plt.figure(figsize=(10, 6)) + bars = plt.bar(sorted_data.keys(), sorted_data.values()) + for bar in bars: + height = bar.get_height() + plt.text(bar.get_x() + bar.get_width()/2., height + height*0.01, + f'{height:.3f}', + ha='center', va='bottom') + plt.title(f"Average Tool Calls per Instance for {group_name}, num_instances={num_instances}") + plt.xlabel("Tools") + plt.ylabel("Average Count") + plt.xticks(rotation=45, ha="right") + plt.tight_layout() + plt.savefig(os.path.join(plots_dir, f"avg_tool_calls_per_instance.png")) + plt.close() + + + +def add_item(dict_obj, key, value): + if key in dict_obj: + dict_obj[key].append(value) + else: + dict_obj[key] = [value] + + +def eval_entry(entry, logger): + history = entry['history'][3:] + conversation_size = len(history) + events = [] + out_source = [] + bash_tool_summary = {} # {'ls': {'count': , list: [{'id', 'command' }]}, {} + source = {} + source_ids_list = {} + events_list = [] + tool_call_counts = {} + agent_messages = [] + user_messages = {} + observations = {} + agent_calls = [] + # observation_list = [ {id,action, output}] + # action_list = [ {id, action, command} ] + + + for item in history: + + + ## Count source occurrences and store ids + if item['source'] not in source_ids_list: + source_ids_list[item['source']] = [] + source[item['source']] = 0 + source_ids_list[item['source']].append(item['id']) + source[item['source']] +=1 + + + action = item.get('action', '') + observation = item.get('observation', '') + try: + if observation!= '': + events_list.append(f"id_{item['id']}_{item['source']}_observation_{observation} {item['message']}") + add_item(observations, item['source'], str({'id': item['id'], 'source': item['source'] ,'observation': observation ,'message': item['message']})) + elif action != '': + + if item['source'] == 'agent': + ### tools to summarize "edit/run/finish/message/think/" + if action in ['edit', 'run', 'finish', 'think', 'task_tracking', 'run_ipython', 'view', 'read']: + function_name = item.get('tool_call_metadata', {}).get('function_name', '') + events_list.append(f"id_{item['id']}_{item['source']}_action_{action}_{function_name} {item['message']}") + agent_calls.append({'id': item['id'], 'action': action, 'function_name': item['tool_call_metadata']['function_name'], 'message': item['message']}) + ### tool call summary ##### + tool_name = item['tool_call_metadata']['function_name'] + if tool_name not in tool_call_counts: + tool_call_counts[tool_name] = 0 + tool_call_counts[tool_name] += 1 + + + #### bash tool summary ##### + if action == 'run': + if item['tool_call_metadata']['function_name'] == 'execute_bash': + command = item['message'].split('Running command: ')[-1].strip() + for cmd in command.split('&&'): + prefix = cmd.strip().split(' ')[0] + cmd = cmd.strip() + prefix = prefix.split('<')[0].split('>')[0].split('=')[0] # Handle redirection + if prefix not in bash_tool_summary: + bash_tool_summary[prefix] = {'count': 0, 'list': []} + bash_tool_summary[prefix]['count'] += 1 + bash_tool_summary[prefix]['list'].append({'id': item['id'], 'command': command}) + ########################### + + ##### empty messages ##### + elif action == 'message': + events_list.append(f"id_{item['id']}_{item['source']}_action_{action} {item['message']}") + if item['message'].strip() == '': + agent_messages.append({'id': item['id'], 'message': item['message']}) + ########################### + elif action == 'condensation': + events_list.append(f"id_{item['id']}_{item['source']}_action_{action} {item['message']}") + agent_calls.append({'id': item['id'], 'action': action, 'function_name':'condensation','message': item['message']}) + else: + logger.warning(f"Unrecognized agent action without tool_call_metadata: {item}") + + elif item['source'] == 'user': + events_list.append(f"id_{item['id']}_{item['source']}_action_{action} {item['message']}") + add_item(user_messages, action, {'id': item['id'], 'message': item['message']}) + + else: + logger.warning(f"Unrecognized source with action: {item}") + + + else: + logger.warning(f"\n\nItem with no action or observation: {item}\n\n") + except Exception as e: + logger.error(f"\n\nError processing item {item}: {e}\n\n") + bash_tool_call_counts = {tool: details['count'] for tool, details in bash_tool_summary.items()} + + summary = { + 'instance_id': entry.get('instance_id', ''), + 'error': entry.get('error', ''), + 'conversation_size': conversation_size, + 'source_counts': source, + 'tool_call_counts': tool_call_counts, + 'bash_tool_call_counts': bash_tool_call_counts, + 'agent_calls': agent_calls, + 'agent_messages': agent_messages, + 'observations': observations, + 'user_messages': user_messages, + 'events': events_list, + 'bash_tool_call_summary': bash_tool_summary, + 'source_ids': source_ids_list, + } + + return summary + + +def summary_file(group_name, filtered_entries, summary_dir, logger): + summaries = [] + bash_tool_calls = {} + tool_calls = {} + for entry in filtered_entries: + summary = eval_entry(entry, logger) + summaries.append(summary) + # Aggregate bash tool calls + for tool, count in summary['bash_tool_call_counts'].items(): + if tool not in bash_tool_calls: + bash_tool_calls[tool] = 0 + bash_tool_calls[tool] += count + + # tool_call_counts + for tool, count in summary['tool_call_counts'].items(): + if tool not in tool_calls: + tool_calls[tool] = 0 + tool_calls[tool] += count + + ### avg tool calls per instance + avg_tool_calls = {tool: count / len(filtered_entries) for tool, count in tool_calls.items()} + avg_bash_tool_calls = {tool: count / len(filtered_entries) for tool, count in bash_tool_calls.items()} + + # Save summaries to a JSON file + summary_file_path = os.path.join(summary_dir, f"{group_name}_summary.json") + with open(summary_file_path, 'w') as summary_outfile: + json.dump(summaries, summary_outfile, indent=4) + logger.info(f"Summary saved to: {summary_file_path}") + + return { + 'total_bash_tool_calls': bash_tool_calls, + 'avg_bash_tool_calls_per_instance': avg_bash_tool_calls, + 'total_tool_calls': tool_calls, + 'avg_tool_calls_per_instance': avg_tool_calls, + 'num_instances': len(filtered_entries) + } + + + +# Function to save metadata +def save_metadata(group_name, filtered_entries, summary, metadata_dir, logger, overall_stats): + metadata = { + "group_name": group_name, + "entry_count": len(filtered_entries), + "inclusion_criteria": search_text_groups[group_name].get("include", []), + "exclusion_criteria": search_text_groups[group_name].get("exclude", []), + "summary": summary, + "instance_ids": [entry.get("instance_id") for entry in filtered_entries], + "overall_instances_in_this_category": overall_stats + } + metadata_file = os.path.join(metadata_dir, f"{group_name}_metadata.json") + with open(metadata_file, 'w') as meta_outfile: + json.dump(metadata, meta_outfile, indent=4) + logger.info(f"Metadata saved to: {metadata_file}") + + +def _filter_instances(loc_file, result_file, logger, selected_ids): + with open(loc_file, 'r') as loc_fh: + loc_data = [json.loads(line) for line in loc_fh if line.strip()] + + if selected_ids is not None: + loc_data = [x for x in loc_data if x["instance_id"] in selected_ids] + logger.info(f"selected_data: {len(loc_data)}") + + + recall_eq_1 = [item['instance_id'] for item in loc_data if item.get('recall', 0) == 1.0] + recall_less_1 = [item['instance_id'] for item in loc_data if item.get('recall', 0) < 1.0] + + logger.info(f"Instances with recall=1: {len(recall_eq_1)}/{len(loc_data)}") + logger.info(f"Instances with recall < 1: {len(recall_less_1)}/{len(loc_data)}") + + with open(result_file, 'r') as res_fh: + result_data = json.load(res_fh) + + stats = result_data["swe_bench_statistics"] + resolved = stats["resolved_ids"] + if selected_ids is not None: + resolved = [x for x in resolved if x in selected_ids] + unresolved = stats["unresolved_ids"] + if selected_ids is not None: + unresolved = [x for x in unresolved if x in selected_ids] + + total_instances = len(loc_data) + + logger.info(f"Resolved instances: {len(resolved)}/{total_instances}") + logger.info(f"Unresolved instances: {len(unresolved)}/{total_instances}") + + all_instances = [x["instance_id"] for x in loc_data] + + return recall_eq_1, recall_less_1, resolved, unresolved, all_instances + + +# Function to filter entries +def filter_entries(input_file, search_text_groups, output_dir, metadata_dir, summary_dir, logger, filtered_instances=None): + with open(input_file, 'r') as infile: + lines = infile.readlines() + + overall_stats = {"total_entries": 0, "all_instance_ids": []} + for line in lines: + entry = json.loads(line) + if filtered_instances is not None: + if entry["instance_id"] in filtered_instances: + overall_stats["total_entries"] += 1 + overall_stats["all_instance_ids"].append(entry["instance_id"]) + else: + overall_stats["total_entries"] += 1 + overall_stats["all_instance_ids"].append(entry["instance_id"]) + + for group_name, criteria in search_text_groups.items(): + logger.info(f"------------- Processing group: {group_name} -------------") + include_texts = criteria.get("include", []) + exclude_texts = criteria.get("exclude", []) + filtered_entries = [] + + for line in lines: + try: + entry = json.loads(line) + if filtered_instances is not None and entry["instance_id"] not in filtered_instances: + logger.info(f"Skipping instance_id {entry['instance_id']} not in filtered instances.") + continue + text = json.dumps(entry) # Convert entry back to string for searching + + # if group_name == "without_errror_and_non_empty_patches": + # logger.info(f"Checking instance_id {entry['instance_id']}") + # logger.info(f"Entry line: {line}") + # logger.info(f"Entry text: {text}") + # logger.info(f"Include texts: {include_texts}") + # logger.info(f"Exclude texts: {exclude_texts}") + # logger.info(f"Include check: {all(inc_text in line for inc_text in include_texts)}") + # logger.info(f"Exclude check: {any(exc_text in line for exc_text in exclude_texts)}") + + # logger.info(f"Include check: {all(inc_text in text for inc_text in include_texts)}") + # logger.info(f"Exclude check: {any(exc_text in text for exc_text in exclude_texts)}") + + # Check inclusion criteria (all must be present) + if all(inc_text in text for inc_text in include_texts): + # Check exclusion criteria (none must be present) + if not any(exc_text in text for exc_text in exclude_texts): + filtered_entries.append(entry) + except json.JSONDecodeError: + logger.info(f"Skipping invalid JSON line: {text}") + + # Create subdirectories for JSON and JSONL files + json_dir = os.path.join(output_dir, "json") + jsonl_dir = os.path.join(output_dir, "jsonl") + os.makedirs(json_dir, exist_ok=True) + os.makedirs(jsonl_dir, exist_ok=True) + + if not filtered_entries: + logger.info(f"No entries found for group: {group_name}") + continue + # Save filtered entries to a new JSONL file + logger.info(f"Group: {group_name}, Found {len(filtered_entries)} matching entries.") + jsonl_output_file = os.path.join(jsonl_dir, f"{group_name}_filtered.jsonl") + with open(jsonl_output_file, 'w') as outfile: + for entry in filtered_entries: + outfile.write(json.dumps(entry) + '\n') + logger.info(f"Filtered entries saved to: {jsonl_output_file}") + + # Save filtered entries to a new JSON file + json_output_file = os.path.join(json_dir, f"{group_name}_filtered.json") + with open(json_output_file, 'w') as json_outfile: + json.dump(filtered_entries, json_outfile, indent=4) + logger.info(f"Filtered entries saved to: {json_output_file}") + + + summary = summary_file(group_name, filtered_entries, summary_dir, logger) + + plot_histograms(summary, group_name, output_dir) + + + # Save metadata + save_metadata(group_name, filtered_entries, summary, metadata_dir, logger, overall_stats) + +def parse_arguments(): + parser = argparse.ArgumentParser(description="Filter JSONL entries based on search criteria.") + parser.add_argument("--input_file", required=True, type=str, help="Path to the input JSONL file.") + parser.add_argument("--output_dir", required=True, type=str, help="Directory to save the output files.") + parser.add_argument("--loc_json", type=str, help="Path to the localization JSON file with instance details.", default=None, required=True) + parser.add_argument("--eval_json", type=str, help="Path to the eval_summary JSON file with instance details.", default=None, required=True) + parser.add_argument('--selected_ids', type=str, required=False, default=None, help="Pass toml file with key selected_ids") + + return parser.parse_args() + + +def setup_logging(output_dir): + log_file = os.path.join(output_dir, "summary_openhands.log") + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(levelname)s - %(message)s", + handlers=[ + logging.StreamHandler(), + logging.FileHandler(log_file, mode='w') + ] + ) + return logging.getLogger(__name__) + + + +if __name__ == "__main__": + + args = parse_arguments() + input_file = args.input_file + output_dir = args.output_dir + + os.makedirs(output_dir, exist_ok=True) + + search_text_groups = get_search_text_groups() + logger = setup_logging(output_dir) + + selected_ids = None + if args.selected_ids is not None: + selected_ids = toml.load(args.selected_ids)["selected_ids"] + + logger.info(f"Selected_IDS: {selected_ids}") + + recall_eq_1, recall_less_1, resolved, unresolved, all_instances = _filter_instances(args.loc_json, args.eval_json, logger, selected_ids) + + + # Run the filtering process - recall=1 + if recall_eq_1: + output_recall_1 = os.path.join(output_dir, "recall_eq_1") + os.makedirs(output_recall_1, exist_ok=True) + metadata_dir = os.path.join(output_recall_1, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_recall_1, "summary") + os.makedirs(summary_dir, exist_ok=True) + filter_entries(input_file, search_text_groups, output_recall_1, metadata_dir, summary_dir, logger, recall_eq_1) + + # Run the filtering process - recall < 1 + if recall_less_1: + output_recall_less_1 = os.path.join(output_dir, "recall_less_1") + os.makedirs(output_recall_less_1, exist_ok=True) + metadata_dir = os.path.join(output_recall_less_1, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_recall_less_1, "summary") + os.makedirs(summary_dir, exist_ok=True) + filter_entries(input_file, search_text_groups, output_recall_less_1, metadata_dir, summary_dir, logger, recall_less_1) + + # Run the filtering process - resolved + if resolved: + output_resolved = os.path.join(output_dir, "resolved") + os.makedirs(output_resolved, exist_ok=True) + metadata_dir = os.path.join(output_resolved, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_resolved, "summary") + os.makedirs(summary_dir, exist_ok=True) + filter_entries(input_file, search_text_groups, output_resolved, metadata_dir, summary_dir, logger, resolved) + + + # Run the filtering process - unresolved + if unresolved: + output_unresolved = os.path.join(output_dir, "unresolved") + os.makedirs(output_unresolved, exist_ok=True) + metadata_dir = os.path.join(output_unresolved, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_unresolved, "summary") + os.makedirs(summary_dir, exist_ok=True) + + filter_entries(input_file, search_text_groups, output_unresolved, metadata_dir, summary_dir, logger, unresolved) + + # Run the filtering process - recall_1 and resolved + recall_1_and_resolved = list(set(recall_eq_1) & set(resolved)) + if recall_1_and_resolved: + output_recall_1_and_resolved = os.path.join(output_dir, "recall_eq_1_and_resolved") + os.makedirs(output_recall_1_and_resolved, exist_ok=True) + metadata_dir = os.path.join(output_recall_1_and_resolved, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_recall_1_and_resolved, "summary") + os.makedirs(summary_dir, exist_ok=True) + filter_entries(input_file, search_text_groups, output_recall_1_and_resolved, metadata_dir, summary_dir, logger, recall_1_and_resolved) + + # Run the filtering process - recall_1 and unresolved + recall_1_and_unresolved = list(set(recall_eq_1) & set(unresolved)) + if recall_1_and_unresolved: + output_recall_1_and_unresolved = os.path.join(output_dir, "recall_eq_1_and_unresolved") + os.makedirs(output_recall_1_and_unresolved, exist_ok=True) + metadata_dir = os.path.join(output_recall_1_and_unresolved, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_recall_1_and_unresolved, "summary") + os.makedirs(summary_dir, exist_ok=True) + filter_entries(input_file, search_text_groups, output_recall_1_and_unresolved, metadata_dir, summary_dir, logger, recall_1_and_unresolved) + + # Run the filtering process - no filter + output_no_filter = os.path.join(output_dir, "no_filter") + os.makedirs(output_no_filter, exist_ok=True) + metadata_dir = os.path.join(output_no_filter, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + summary_dir = os.path.join(output_no_filter, "summary") + os.makedirs(summary_dir, exist_ok=True) + filter_entries(input_file, search_text_groups, output_no_filter, metadata_dir, summary_dir, logger, filtered_instances=all_instances) + + logger.info("Processing completed.") diff --git a/evaluation/benchmarks/swe_bench/other_scripts/generate_localisation_report.py b/evaluation/benchmarks/swe_bench/other_scripts/generate_localisation_report.py new file mode 100644 index 000000000000..7d95067363a6 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/generate_localisation_report.py @@ -0,0 +1,219 @@ +import json +import os +# from transformers import AutoTokenizer +from datasets import load_dataset, disable_progress_bars +import matplotlib.pyplot as plt +import argparse +from tqdm import tqdm +import toml + +## disable datasets progress bars +disable_progress_bars() + +# ORACLE_DATASET = 'princeton-nlp/SWE-bench_oracle' + +# ORACLE_DATASET = 'princeton-nlp/SWE-bench_Verified' + +# oracle_ds = load_dataset(ORACLE_DATASET, split='test') + +ORACLE_DATASET = 'princeton-nlp/SWE-bench' + +oracle_ds = load_dataset(ORACLE_DATASET, split='dev') + + +## load trajectory +## extract files modified from the patch generated +## extract files needed to be modified from the oracle patch +## compare the two sets of files , and finally output the report into json, + + +def extract_files_from_patch(patch_text): + files = set() + lines = patch_text.split('\n') + for line in lines: + if line.startswith('+++ b/'): + file_path = line[6:] # Remove '+++ b/' prefix + files.add(file_path) + return files + + +def generate_plots(report, report_dir): + + + def gen_plot(data, title, plot_path): + fig, axes = plt.subplots(1, 1, figsize=(15, 5)) + axes.hist(data, bins=10, range=(0, 1), edgecolor='black', alpha=0.7) + axes.set_title(title) + axes.set_xlabel('Proportion Correctly Modified') + axes.set_ylabel('Count') + axes.set_xlim(0, 1) + + plt.tight_layout() + plt.show() + # plt.savefig(f'/mlf-transfers-only/srinjoym/coding_agent_eval/50_problems_eval/pass@1/analysis/localisation_report/mini_swe_agent_{model_name}_localization_accuracy_plots.png', dpi=300, bbox_inches='tight') + plt.savefig(plot_path, dpi=300, bbox_inches='tight') + + + def gen_plot_label(data, title, plot_path): + fig, axes = plt.subplots(1, 1, figsize=(15, 5)) + n, bins, patches = axes.hist(data, bins=10, range=(0, 1), edgecolor='black', alpha=0.7) + + # Add value labels on top of each bar + for i in range(len(n)): + if n[i] > 0: # Only show labels for non-zero bars + axes.text(bins[i] + (bins[i+1] - bins[i])/2, n[i] + max(n)*0.01, + f'{int(n[i])}', ha='center', va='bottom', fontweight='bold') + + axes.set_title(title) + axes.set_xlabel('Proportion Correctly Modified') + axes.set_ylabel('Count') + axes.set_xlim(0, 1) + + # Adjust y-axis to accommodate labels + axes.set_ylim(0, max(n) * 1.1) + + plt.tight_layout() + plt.show() + plt.savefig(plot_path, dpi=300, bbox_inches='tight') + + + precision = [] + recall = [] + + + for i, row_entry in enumerate(report): + #proportions = [item['proportion_correctly_modified'] for item in data] + + precision.append(row_entry['precision']) + recall.append(row_entry['recall']) + + + precision_plot_path = os.path.join(report_dir, 'localization_precision_plot.png') + average_precision = sum(precision) / len(precision) if precision else 0 + precision_title = f'localisation_precision_avg_{average_precision:.2f}' + + recall_plot_path = os.path.join(report_dir, 'localization_recall_plot.png') + average_recall = sum(recall) / len(recall) if recall else 0 + recall_title = f'localisation_recall_avg_{average_recall:.2f}' + + # gen_plot(precision, precision_title, precision_plot_path) + # gen_plot(recall, recall_title, recall_plot_path) + + gen_plot_label(precision, precision_title, precision_plot_path) + gen_plot_label(recall, recall_title, recall_plot_path) + + +def analyse_entry(instance_id, gen_patch): + + oracle_instance = oracle_ds.filter(lambda x: x['instance_id'] == instance_id)[0] + oracle_patch = oracle_instance['patch'] + + print(f" Analysing {instance_id} ---") + + files_modified_by_patch = extract_files_from_patch(gen_patch) + files_needed_to_be_modified = extract_files_from_patch(oracle_patch) + + ## calculate the intersection over union of these two sets + intersection = files_modified_by_patch.intersection(files_needed_to_be_modified) + union = files_modified_by_patch.union(files_needed_to_be_modified) + iou = len(intersection) / len(union) if union else 0 + recall = len(intersection) /len(files_needed_to_be_modified) if files_needed_to_be_modified else 0 + precision = len(intersection) / len(files_modified_by_patch) if files_modified_by_patch else 0 + + unnecessary_edits = [] + edits_correct = [] + + for file in list(files_modified_by_patch): + if file not in files_needed_to_be_modified: + unnecessary_edits.append(file) + if file in files_needed_to_be_modified: + edits_correct.append(file) + + + + cur_entry = { + 'instance_id': instance_id, + 'files_modified_by_patch': list(files_modified_by_patch), + 'files_needed_to_be_modified': list(files_needed_to_be_modified), + 'proportion_correctly_modified': iou, + 'recall': recall, + 'precision': precision, + 'unnecessary_edits_counts': len(unnecessary_edits), + 'edits_correct_counts': len(edits_correct) + } + + + return cur_entry + +def analyse_patches(generated_entries, output_file=None): + + complete_report = [] + + for entry in tqdm(generated_entries, desc="Analysing Predictions ..... "): + instance_id = entry['instance_id'] + gen_patch = entry['model_patch'] + cur_entry_analysis = analyse_entry(instance_id, gen_patch) + complete_report.append(cur_entry_analysis) + + if output_file is not None: + with open(output_file, 'w') as f: + for entry in complete_report: + f.write(json.dumps(entry) +'\n') + + return complete_report + + + + + + +def main(): + + parser = argparse.ArgumentParser(description="Generate localisation report") + parser.add_argument('--model_name', type=str, required=True, help='Name of the model used for generating trajectories') + parser.add_argument('--predictions_path', type=str, required=True, help='Path to the predictions JSONL file') + parser.add_argument('--report_dir', type=str, required=True, help='Directory to save the localisation report and plots') + parser.add_argument('--selected_ids', type=str, required=False, default=None, help="Pass toml file with key selected_ids") + args = parser.parse_args() + + model_name = args.model_name + predictions_path = args.predictions_path + localisation_report_dir = args.report_dir + + os.makedirs(localisation_report_dir, exist_ok=True) + + selected_ids = None + if args.selected_ids is not None: + selected_ids = toml.load(args.selected_ids)["selected_ids"] + + print(f"Selected_IDS: {selected_ids}") + + predictions_data = [] + with open(predictions_path, 'r', encoding='utf-8') as f: + for line in f: + data_line = json.loads(line) + instance_id = data_line["instance_id"] + if selected_ids is not None: + if instance_id in selected_ids: + predictions_data.append(data_line) + else: + predictions_data.append(data_line) + + + localisation_report_path = os.path.join(localisation_report_dir, f'{model_name}_localisation_report.jsonl') + + print('Reading predictions from file:', predictions_path) + print('Model used:', model_name) + print('report saved at:', localisation_report_path) + + complete_report = [] + + print(f'Len of predictions_data:',{len(predictions_data)}) + complete_report = analyse_patches(predictions_data, localisation_report_path) + + print('Generating plots...') + + generate_plots(complete_report, localisation_report_dir) + +if __name__ == '__main__': + main() diff --git a/evaluation/benchmarks/swe_bench/other_scripts/generate_run_summary.py b/evaluation/benchmarks/swe_bench/other_scripts/generate_run_summary.py new file mode 100644 index 000000000000..7e7a47c7ddcc --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/generate_run_summary.py @@ -0,0 +1,160 @@ +import json +import logging +import argparse +import os +import toml +from bash_tool_call_summary_filtered import get_search_text_groups +from bash_tool_call_summary_filtered import eval_entry + + +def get_groups_matched(entry, search_text_groups, logger): + matched_groups = [] + text = json.dumps(entry) + for group_name, criteria in search_text_groups.items(): + + logger.info(f"------------- Processing group: {group_name} -------------") + include_texts = criteria.get("include", []) + exclude_texts = criteria.get("exclude", []) + + # Check inclusion criteria (all must be present) + if all(inc_text in text for inc_text in include_texts): + # Check exclusion criteria (none must be present) + if not any(exc_text in text for exc_text in exclude_texts): + matched_groups.append(group_name) + + return matched_groups + + +def single_instance_summary(entry, localization_report, eval_report, search_text_groups, logger): + summary_instance = { + 'instance_id': entry['instance_id'], + 'error': entry.get('error', ''), + 'conversation_size': None, + 'source_counts': None, + 'tool_call_counts': None, + 'bash_tool_call_counts': None, + 'matched_groups': None, + 'is_resolved': False, + 'precision': None, + 'recall': None, + 'files_modified_by_patch': None, + 'files_needed_to_be_modified': None, + 'llm_metrics': { + "num_calls_to_llm": 0, + 'prompt_tokens': None, + 'completion_tokens': None + } + } + + summary = eval_entry(entry, logger) + matched_groups = get_groups_matched(entry, search_text_groups, logger) + summary_instance['matched_groups'] = matched_groups + + for k, val in summary.items(): + if k in summary_instance: + summary_instance[k] = val + + found_last = False + for item in reversed(entry['history']): + if 'llm_metrics' in item: + if item['source'] == 'agent': + summary_instance['llm_metrics']['num_calls_to_llm'] += 1 + if not found_last: + summary_instance['llm_metrics']['prompt_tokens'] = item['llm_metrics']['accumulated_token_usage']['prompt_tokens'] + summary_instance['llm_metrics']['completion_tokens'] = item['llm_metrics']['accumulated_token_usage']['completion_tokens'] + found_last = True + + for line in localization_report: + if line['instance_id'] == entry['instance_id']: + summary_instance['precision'] = line['precision'] + summary_instance['recall'] = line['recall'] + summary_instance['files_modified_by_patch'] = line['files_modified_by_patch'] + summary_instance['files_needed_to_be_modified'] = line['files_needed_to_be_modified'] + + swe_bench_statistics = eval_report['swe_bench_statistics'] + if entry['instance_id'] in swe_bench_statistics['resolved_ids']: + summary_instance['is_resolved'] = True + + return summary_instance + + +def build_summary_of_run(input_file, eval_summary_file, localization_report, selected_ids, logger): + + search_text_groups = get_search_text_groups() + + with open(eval_summary_file, 'r') as eval_fh: + eval_report_data = json.load(eval_fh) + + loc_report_data = [] + with open(localization_report, 'r') as infile: + lines = infile.readlines() + for line in lines: + loc_report_data.append(json.loads(line)) + + with open(input_file, 'r') as infile: + lines = infile.readlines() + + overall_summary = [] + for line in lines: + try: + entry = json.loads(line) + if selected_ids is not None and entry["instance_id"] not in selected_ids: + logger.info(f"Skipping instance_id {entry['instance_id']} not in selected_ids instances.") + continue + + summary_instance = single_instance_summary(entry, loc_report_data, eval_report_data, search_text_groups, logger) + overall_summary.append(summary_instance) + + except json.JSONDecodeError: + logger.info(f"Skipping invalid JSON line: {line}") + + fname = f"overall_summary.json" if selected_ids is None else f"overall_summary_selected.json" + output_file = os.path.join(os.path.dirname(input_file), fname) + with open(output_file, 'w') as outfile: + json.dump(overall_summary, outfile, indent=4) + + logger.info(f"Summary saved to {output_file}") + + +def setup_logging(output_dir): + log_file = os.path.join(output_dir, "summary_openhands.log") + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(levelname)s - %(message)s", + handlers=[ + logging.StreamHandler(), + logging.FileHandler(log_file, mode='w') + ] + ) + return logging.getLogger(__name__) + + +def parse_arguments(): + parser = argparse.ArgumentParser(description="Filter JSONL entries based on search criteria.") + parser.add_argument("--input_file", required=True, type=str, help="Path to the input JSONL file.") + parser.add_argument("--eval_summary_file", required=True, type=str, help="Path to the evaluation summary JSON file.") + parser.add_argument("--localization_report", required=True, type=str, help="Path to the localization report JSONL file.") + parser.add_argument('--selected_ids', type=str, required=False, default=None, help="Path to TOML file with key 'selected_ids'") + + return parser.parse_args() + + +if __name__ == "__main__": + + args = parse_arguments() + input_file = args.input_file + eval_summary_file = args.eval_summary_file + localization_report = args.localization_report + output_dir = os.path.dirname(input_file) + + os.makedirs(output_dir, exist_ok=True) + + logger = setup_logging(output_dir) + + selected_ids = None + if args.selected_ids is not None: + selected_ids = toml.load(args.selected_ids)["selected_ids"] + + logger.info(f"Selected_IDS: {selected_ids}") + + build_summary_of_run(input_file, eval_summary_file, localization_report, selected_ids, logger) diff --git a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh new file mode 100755 index 000000000000..0daa21dab20a --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh @@ -0,0 +1,219 @@ +#!/bin/bash + +#!/bin/bash +set -e # Exit on any error + +####################################### +# ๐Ÿ“‹ Setup Logging to File and Log CMD +####################################### + +TIMESTAMP=$(date +"%Y%m%d_%H%M%S") +# LOGDIR_RUN="logs_end_to_end" +# mkdir -p "$LOGDIR_RUN" +# LOGFILE="$LOGDIR_RUN/eval_run_${TIMESTAMP}.log" + +LOGFILE="eval_run_${TIMESTAMP}.log" + +# Start logging stdout and stderr +exec > >(tee -i "$LOGFILE") 2>&1 + +# Log the command that started the script +echo "๐Ÿ”ง Command:" +echo "$0 $@" +echo "========================================" +echo "๐Ÿ“… Started at: $(date)" +echo "๐Ÿ“ Log file: $LOGFILE" +echo "========================================" + + +########################## +# ----- ARGUMENTS -------# +########################## +EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_26_baseline/" +MODEL="llm.qwen_coder_30b_small" +LOCAL_DOCKER_DIR="/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images/" +CONFIG_ML="/workspaces/OpenHands/evaluation/benchmarks/swe_bench/config_2.toml" +MAX_TURNS=100 +NUM_SAMPLES=26 +DATASET="princeton-nlp/SWE-bench" +SPLIT="dev" +# DATASET="princeton-nlp/SWE-bench_Verified" +# SPLIT="test" + +NUM_WORKERS=1 +NUM_RUNS=1 + +########################## +# ---- ENV EXPORTS ------# +########################## +export EVAL_OUTPUT_DIR=$EVAL_OUTPUT_DIR +export DEBUG=1 +export EVAL_SKIP_MAXIMUM_RETRIES_EXCEEDED=true +export LOCAL_DOCKER_IMAGE_DIR=$LOCAL_DOCKER_DIR +export CONFIG_ML=$CONFIG_ML + +########################## +# ----- CONFIG LOG ------# +########################## +echo "" +echo "=========== SWE-Bench Evaluation Configuration ===========" +echo " EVAL_OUTPUT_DIR: $EVAL_OUTPUT_DIR" +echo " MODEL: $MODEL" +echo " MAX_TURNS: $MAX_TURNS" +echo " NUM_SAMPLES: $NUM_SAMPLES" +echo " NUM_WORKERS: $NUM_WORKERS" +echo " NUM_RUNS: $NUM_RUNS" +echo " DATASET: $DATASET" +echo " SPLIT: $SPLIT" +echo " LOCAL_DOCKER_IMAGE_DIR: $LOCAL_DOCKER_IMAGE_DIR" +echo "==========================================================" +echo "" + +########################## +# -- RUN INFERENCE ----- # +########################## +# Placeholder for actual inference call +# Uncomment and customize if needed +# /path/to/inference.sh $MODEL ... +############################# +# ๐Ÿš€ Run Main Evaluation # +############################# +echo "๐Ÿ”ง Starting main inference..." +/workspaces/OpenHands/evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh \ + $MODEL \ + HEAD \ + CodeActAgent \ + $NUM_SAMPLES \ + $MAX_TURNS \ + $NUM_WORKERS \ + $DATASET \ + $SPLIT \ + $NUM_RUNS \ + swe +echo "โœ… Evaluation complete. Results saved in $EVAL_OUTPUT_DIR" +echo + +########################## +# --- TOOL CALL SUMMARY --# +########################## +echo ">>> [1/5] TOOL CALL SUMMARY" + +JSONL_DIR=$EVAL_OUTPUT_DIR +ALL_JSONL_FILES=$(find "$JSONL_DIR" -type f -name "output.jsonl") +JSONL_FILE=$(echo "$ALL_JSONL_FILES" | head -n 1) +PARENT_FOLDER=$(dirname "$JSONL_FILE") +TOOL_SUMMARY_OUTPUT="$PARENT_FOLDER/bash_tool_call_summary_$MODEL" + +echo " Using JSONL file: $JSONL_FILE" +echo " Saving summary to: $TOOL_SUMMARY_OUTPUT" + +python3 /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary.py \ + --input_file "$JSONL_FILE" \ + --output_dir "$TOOL_SUMMARY_OUTPUT" + +echo "โœ… Tool call summary complete." + +########################## +# --- CONVERT TO SWE-BENCH FORMAT --# +########################## +echo "" +echo ">>> [2/5] CONVERTING OUTPUT TO SWE-BENCH FORMAT" + +python3 /workspaces/OpenHands/evaluation/benchmarks/swe_bench/scripts/eval/convert_oh_output_to_swe_json.py "$JSONL_FILE" + +SWEBENCH_JSONL="$PARENT_FOLDER/output.swebench.jsonl" +echo "โœ… Converted to: $SWEBENCH_JSONL" + +########################## +# ---- LOCALIZATION REPORT ----# +########################## +echo "" +echo ">>> [3/5] LOCALIZATION REPORT" + +LOC_SUMMARY_OUTPUT="$PARENT_FOLDER/localization" +mkdir -p "$LOC_SUMMARY_OUTPUT" + +python3 /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/generate_localisation_report.py \ + --model_name "$MODEL" \ + --predictions_path "$SWEBENCH_JSONL" \ + --report_dir "$LOC_SUMMARY_OUTPUT" + +echo "โœ… Localization summary saved to: $LOC_SUMMARY_OUTPUT" + +########################## +# --- FINAL EVAL (TRAJECTORY) ---# +########################## +echo "" +echo ">>> [4/5] TRAJECTORY EVALUATION" + +OUT_FINAL="$PARENT_FOLDER/final_eval" +mkdir -p "$OUT_FINAL" +FINAL_PRED_PATH="$SWEBENCH_JSONL" + +EXEC_SCRIPT="$PARENT_FOLDER/run_commands.sh" +echo "#!/bin/bash" > "$EXEC_SCRIPT" +echo "" >> "$EXEC_SCRIPT" + +cat >> "$EXEC_SCRIPT" << EOF +cd $OUT_FINAL +python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py \\ + --run_id "$MODEL" \\ + --predictions_path "$FINAL_PRED_PATH" \\ + --output_dir "$OUT_FINAL" \\ + --dataset_name "$DATASET" \\ + --dataset_split "$SPLIT" +EOF + +chmod +x "$EXEC_SCRIPT" +cat "$EXEC_SCRIPT" + +# Run it now +cd "$OUT_FINAL" +python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py \ + --run_id "$MODEL" \ + --predictions_path "$FINAL_PRED_PATH" \ + --output_dir "$OUT_FINAL" \ + --dataset_name "$DATASET" \ + --dataset_split "$SPLIT" + +EVAL_JSON=$(find "$OUT_FINAL" -type f -name "consolidated_report*.json" | head -n 1) + +echo "โœ… Evaluation completed: $EVAL_JSON" + +########################## +# --- FILTERED LOCALIZATION ---# +########################## +echo "" +echo ">>> [5/5] FILTERED LOCALIZATION SUMMARY" + +TOOL_SUMMARY_OUTPUT="$PARENT_FOLDER/bash_tool_call_summary_filtered_$MODEL" +LOC_JSONL_FILE=$(find "$LOC_SUMMARY_OUTPUT" -type f -name "*localisation_report.jsonl" | head -n 1) + +python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/bash_tool_call_summary_filtered.py \ + --input_file "$JSONL_FILE" \ + --output_dir "$TOOL_SUMMARY_OUTPUT" \ + --loc_json "$LOC_JSONL_FILE" \ + --eval_json "$EVAL_JSON" + +echo "โœ… Filtered localization summary saved." + +########################## +# -------- RUN SUMMARY -------- # +########################## +echo "" +echo ">>> GENERATING FINAL RUN SUMMARY" + +python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/generate_run_summary.py \ + --input_file "$JSONL_FILE" \ + --eval_summary_file "$EVAL_JSON" \ + --localization_report "$LOC_JSONL_FILE" + +echo "โœ… Final summary generated." + +########################## +# -------- DONE -------- # +########################## +echo "" +echo "๐ŸŽ‰ All steps completed successfully." +echo "๐Ÿ‘‰ You can re-run evaluation using: $EXEC_SCRIPT" +echo "๐Ÿ“‚ Results located in: $PARENT_FOLDER" diff --git a/evaluation/utils/shared.py b/evaluation/utils/shared.py index a3d9c125af0b..fb5e9193da70 100644 --- a/evaluation/utils/shared.py +++ b/evaluation/utils/shared.py @@ -177,12 +177,13 @@ def make_metadata( model_path = model_name.replace(':', '_').replace('@', '-') eval_note = f'_N_{eval_note}' if eval_note else '' - eval_output_path = os.path.join( - eval_output_dir, - dataset_name, - agent_class, - f'{model_path}_maxiter_{max_iterations}{eval_note}', - ) + # eval_output_path = os.path.join( + # eval_output_dir, + # dataset_name, + # agent_class, + # f'{model_path}_maxiter_{max_iterations}{eval_note}', + # ) + eval_output_path = eval_output_dir pathlib.Path(eval_output_path).mkdir(parents=True, exist_ok=True) pathlib.Path(os.path.join(eval_output_path, 'logs')).mkdir( diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index fba9e56c69fa..36ea3f8b7074 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -58,7 +58,7 @@ # Optional: in the long run, move this into AgentConfig @dataclass class AutoReflectionConfig: - enabled: bool = True + enabled: bool = False # Probabilistic trigger: after each observation event, fire with probability `prob` prob: float = 0.10 # Reactive trigger: check last turn for "no tool" or "error observation" diff --git a/openhands/runtime/impl/docker/docker_runtime.py b/openhands/runtime/impl/docker/docker_runtime.py index ecf4106f56b9..19bbdde437c2 100644 --- a/openhands/runtime/impl/docker/docker_runtime.py +++ b/openhands/runtime/impl/docker/docker_runtime.py @@ -12,6 +12,9 @@ import tenacity from docker.models.containers import Container from docker.types import DriverConfig, Mount +from docker.errors import NotFound + +import json, tarfile, time from openhands.core.config import OpenHandsConfig from openhands.core.exceptions import ( @@ -56,6 +59,11 @@ APP_PORT_RANGE_2 = (45000, 49151) +DOCKER_TIMEOUT_SECS = 600 +APPEAR_WAIT_SECS = 30 +APPEAR_POLL = 0.5 + + def _is_retryablewait_until_alive_error(exception: Exception) -> bool: if isinstance(exception, tenacity.RetryError): cause = exception.last_attempt.exception() @@ -232,29 +240,98 @@ async def connect(self) -> None: ) self.log('error', str(e)) + + def _repotags_from_tar(self, tar_path: str): + try: + with tarfile.open(tar_path, "r:*") as tf: + f = tf.extractfile("manifest.json") + if not f: return [] + manifest = json.load(f) + tags = [] + for e in manifest: + tags.extend(e.get("RepoTags") or []) + # de-dup + return list(dict.fromkeys(tags)) + except Exception: + return [] + + def _wait_until_image_visible(self, client, ref: str, timeout=APPEAR_WAIT_SECS): + + deadline = time.time() + timeout + while time.time() < deadline: + try: + return client.images.get(ref) + except NotFound: + time.sleep(APPEAR_POLL) + except Exception: + time.sleep(APPEAR_POLL) + return None + def maybe_build_runtime_container_image(self): - repo, index = self.get_info_from_base_image() + # make sure you created the client with a large timeout somewhere: + # self.docker_client = docker.from_env(timeout=DOCKER_TIMEOUT_SECS) - runtime_docker_image_folder = self.find_folder_by_prefix_suffix(repo, index, "/workspaces/OpenHands") + repo, index = self.get_info_from_base_image() + runtime_docker_image_folder = self.find_folder_by_prefix_suffix( + repo, index, "/workspaces/Openhands/swebench_dockers_for_eval/runtime_dockers/swebench_dev/" + ) tar_files = glob.glob(os.path.join(runtime_docker_image_folder, "*.tar")) if not tar_files: raise FileNotFoundError("No .tar file found!") - elif len(tar_files) > 1: + if len(tar_files) > 1: raise RuntimeError("More than one .tar file found!") - else: - tar_path = tar_files[0] - logger.debug(f"[Michael] Found tar file: {tar_path}") + tar_path = tar_files[0] + logger.debug(f"[Michael] Found tar file: {tar_path}") - logger.debug(f"[Michael] Loading local runtime image from {tar_path} ...") - with open(tar_path, "rb") as f: - self.runtime_container_image = self.docker_client.images.load(f.read())[0] - logger.debug(f"[Michael] Successfuly loaded local runtime image from {tar_path} ...") + expected_tags = self._repotags_from_tar(tar_path) + logger.debug(f"[Michael] RepoTags in tar: {expected_tags or '(none)'}") + # 1) If image already present, use it and skip load + for tag in expected_tags: + try: + img = self.docker_client.images.get(tag) + self.runtime_container_image = img + logger.debug(f"[Michael] Image already present: {tag} -> {img.id}") + break + except NotFound: + pass + + # 2) Load if needed โ€” STREAM, with higher timeout + if self.runtime_container_image is None: + logger.debug(f"[Michael] Loading local runtime image from {tar_path} ... (this can take minutes)") + with open(tar_path, "rb") as f: + # stream the tar to the daemon; consume the generator so the load fully completes + for _ in self.docker_client.api.load_image(data=f, quiet=False): + pass + logger.debug("[Michael] docker load finished; resolving image tag...") + + # Prefer resolving by tag present in manifest + for tag in expected_tags: + img = self._wait_until_image_visible(self.docker_client, tag) + if img: + self.runtime_container_image = img + logger.debug(f"[Michael] Resolved loaded image: {tag} -> {img.id}") + break + + # Fallback: list images and pick one whose tag/repo matches your expectation + if self.runtime_container_image is None: + images = self.docker_client.images.list() + for im in images: + tags = im.tags or [] + if any("ghcr.io/all-hands-ai/runtime" in t for t in tags): + self.runtime_container_image = im + logger.debug(f"[Michael] Fallback resolved image: {im.id} ({tags})") + break + + if self.runtime_container_image is None: + raise RuntimeError("Loaded image, but could not resolve it. Check manifest.json RepoTags.") + + logger.debug(f"[Michael] Using runtime image: {self.runtime_container_image.id} ({self.runtime_container_image.tags})") + + # Your existing fallback stays: if self.runtime_container_image is None: if self.base_container_image is None: - raise ValueError( - 'Neither runtime container image nor base container image is set' - ) + raise ValueError('Neither runtime container image nor base container image is set') self.set_runtime_status(RuntimeStatus.BUILDING_RUNTIME) self.runtime_container_image = build_runtime_image( self.base_container_image, @@ -301,7 +378,7 @@ def get_info_from_base_image(self): @lru_cache(maxsize=1) def _init_docker_client() -> docker.DockerClient: try: - return docker.from_env() + return docker.from_env(timeout=600) except Exception as ex: logger.error( 'Launch docker client failed. Please make sure you have installed docker and started docker desktop/daemon.', diff --git a/save_runtime_image_local.py b/save_runtime_image_local.py index 9b67ee5b7fbd..0fc929cc7313 100644 --- a/save_runtime_image_local.py +++ b/save_runtime_image_local.py @@ -2,10 +2,11 @@ import docker import subprocess from tqdm import tqdm -import time +import time, shutil from openhands.runtime.utils.runtime_build import build_runtime_image from openhands.runtime.builder import DockerRuntimeBuilder + # --- Config --- client = docker.from_env() docker_builder = DockerRuntimeBuilder(client) @@ -17,9 +18,11 @@ def instance_id_to_remote_name(instance_id): base_image_dir = "/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images" output_root = "/workspaces/Openhands/swebench_dockers_for_eval/runtime_dockers/swebench_dev" +build_folder = "/workspaces/Openhands/michaelw/build_folder" tar_files = [f for f in os.listdir(base_image_dir) if f.endswith('.tar')] -instance_names = [f.removesuffix('__latest.tar') for f in tar_files] +# instance_names = [f.removesuffix('__latest.tar') for f in tar_files] +instance_names = ["sqlfluff__sqlfluff-884"] MAX_RETRIES = 3 RETRY_DELAY = 10 # seconds @@ -42,6 +45,8 @@ def is_valid_tar(path: str) -> bool: for instance_name in tqdm(instance_names): base_image_name = instance_id_to_remote_name(instance_name) output_dir = os.path.join(output_root, instance_name) + shutil.rmtree(build_folder, ignore_errors=True) + os.makedirs(build_folder, exist_ok=True) # --- Skip if valid tar already exists --- if os.path.isdir(output_dir): @@ -49,35 +54,46 @@ def is_valid_tar(path: str) -> bool: if tar_candidates: latest_tar = max(tar_candidates, key=os.path.getmtime) if is_valid_tar(latest_tar): - print(f"โญ๏ธ Skipping {instance_name} (valid image already exists: {os.path.basename(latest_tar)})") + # print(f"โญ๏ธ Skipping {instance_name} (valid image already exists: {os.path.basename(latest_tar)})") continue else: print(f"โš ๏ธ Found existing tar for {instance_name} but itโ€™s invalid โ†’ rebuilding") - # --- Build with retries --- - for attempt in range(1, MAX_RETRIES + 1): - try: - image_name = build_runtime_image( - base_image_name, - docker_builder, - platform=None, - enable_browser=True, - ) - print(f"Built image: {image_name}") + # # --- Build with retries --- + # for attempt in range(1, MAX_RETRIES + 1): + # try: + # image_name = build_runtime_image( + # base_image_name, + # docker_builder, + # platform=None, + # enable_browser=True, + # build_folder=build_folder, + # ) + # print(f"Built image: {image_name}") - os.makedirs(output_dir, exist_ok=True) - safe_image_name = image_name.split("/")[-1].split(":")[-1] - tar_path = os.path.join(output_dir, f"{safe_image_name}.tar") + # os.makedirs(output_dir, exist_ok=True) + # safe_image_name = image_name.split("/")[-1].split(":")[-1] + # tar_path = os.path.join(output_dir, f"{safe_image_name}.tar") - print(f"Saving image to {tar_path} ...") - subprocess.run(["docker", "save", "-o", tar_path, image_name], check=True) - print(f"โœ… Image saved to: {tar_path}") - break # success โ†’ exit retry loop + # print(f"Saving image to {tar_path} ...") + # subprocess.run(["docker", "save", "-o", tar_path, image_name], check=True) + # print(f"โœ… Image saved to: {tar_path}") + # print(f"๐Ÿงน Removing local image {image_name} to free disk space...") + # try: + # client.images.remove(image=image_name, force=True, noprune=False) + # print(f"โœ… Removed image: {image_name}") + # subprocess.run( + # ["bash", "/workspaces/OpenHands/clean_docker.sh"] + # ) + # except Exception as e: + # print(f"โš ๏ธ Could not remove image {image_name}: {e}") - except Exception as e: - print(f"โš ๏ธ Build failed for {instance_name} (attempt {attempt}/{MAX_RETRIES}): {e}") - if attempt < MAX_RETRIES: - print(f"Retrying in {RETRY_DELAY} seconds...") - time.sleep(RETRY_DELAY) - else: - print(f"โŒ Giving up on {instance_name} after {MAX_RETRIES} attempts.") + # break # success โ†’ exit retry loop + + # except Exception as e: + # print(f"โš ๏ธ Build failed for {instance_name} (attempt {attempt}/{MAX_RETRIES}): {e}") + # if attempt < MAX_RETRIES: + # print(f"Retrying in {RETRY_DELAY} seconds...") + # time.sleep(RETRY_DELAY) + # else: + # print(f"โŒ Giving up on {instance_name} after {MAX_RETRIES} attempts.") From b33e54b36e7d5d1f12bfdc217e834367819794b2 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Thu, 30 Oct 2025 00:24:08 +0000 Subject: [PATCH 07/12] update --- .devcontainer/devcontainer.json | 2 +- clean_docker.sh | 2 +- .../other_scripts/run_end_to_end_local.sh | 10 +++++-- .../swe_bench/run_infer_local_docker.py | 6 ++-- .../agenthub/codeact_agent/codeact_agent.py | 28 ++++++++--------- openhands/runtime/base.py | 6 ++++ .../runtime/impl/docker/docker_runtime.py | 30 +++++++++++-------- save_runtime_image_local.py | 8 ++--- 8 files changed, 55 insertions(+), 37 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 0475cfd7e9c0..8d2cd30280d4 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -18,7 +18,7 @@ }, "mounts": [ "source=/mlf11-shared/swebench_dockers_for_eval,target=/workspaces/Openhands/swebench_dockers_for_eval,type=bind,consistency=cached", // the Openhands instead of OpenHands is intentional, due to file mounting issues - "source=/mlf15-shared/michaelw,target=/workspaces/Openhands/michaelw,type=bind,consistency=cached" // the Openhands instead of OpenHands is intentional, due to file mounting issues + "source=/mlf14-shared/michaelw/runtime_dockers,target=/workspaces/Openhands/runtime_dockers,type=bind,consistency=cached" // the Openhands instead of OpenHands is intentional, due to file mounting issues ], "customizations": { "vscode": { diff --git a/clean_docker.sh b/clean_docker.sh index 0bddb5dc460d..a57a771d2afc 100755 --- a/clean_docker.sh +++ b/clean_docker.sh @@ -6,6 +6,6 @@ while read -r id; do docker rmi "$id" 2>/dev/null || true fi done -docker image prune -f; docker builder prune -f; docker volume prune -f +docker image prune -f; docker builder prune -f; docker volume prune -f; docker system prune -a -f --volumes; diff --git a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh index 0daa21dab20a..db63b532258a 100755 --- a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh +++ b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh @@ -26,15 +26,21 @@ echo "๐Ÿ“ Log file: $LOGFILE" echo "========================================" +export TMPDIR=/workspaces/Openhands/runtime_dockers/temp_swebench +export DOCKER_TMPDIR=/workspaces/Openhands/runtime_dockers/temp_swebench +export TEMP=/workspaces/Openhands/runtime_dockers/temp_swebench +export TMP=/workspaces/Openhands/runtime_dockers/temp_swebench + + ########################## # ----- ARGUMENTS -------# ########################## -EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_26_baseline/" +EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_176_reflection_no_prob/" MODEL="llm.qwen_coder_30b_small" LOCAL_DOCKER_DIR="/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images/" CONFIG_ML="/workspaces/OpenHands/evaluation/benchmarks/swe_bench/config_2.toml" MAX_TURNS=100 -NUM_SAMPLES=26 +NUM_SAMPLES=176 DATASET="princeton-nlp/SWE-bench" SPLIT="dev" # DATASET="princeton-nlp/SWE-bench_Verified" diff --git a/evaluation/benchmarks/swe_bench/run_infer_local_docker.py b/evaluation/benchmarks/swe_bench/run_infer_local_docker.py index fa7eaf21f356..9db412b9fe69 100644 --- a/evaluation/benchmarks/swe_bench/run_infer_local_docker.py +++ b/evaluation/benchmarks/swe_bench/run_infer_local_docker.py @@ -252,8 +252,10 @@ def get_config( ) if LOCAL_DOCKER_IMAGE_DIR: - logger.info(f"Loading Local Docker") - base_container_image = load_local_image_if_needed(base_container_image, custom_tag= f"openhands_local_{instance['instance_id'].split('__')[1]}:latest") + logger.info(f"Loading Local Docker (getting names only, not actually loading image to memory)") + base_container_image = f"openhands_local_{instance['instance_id']}:latest" + # base_container_image = load_local_image_if_needed(base_container_image, custom_tag= f"openhands_local_{instance['instance_id']}:latest") + # base_container_image = load_local_image_if_needed(base_container_image, custom_tag= f"openhands_local_{instance['instance_id'].split('__')[1]}:latest") logger.info( f'Using LOCAL docker image for instance {instance["instance_id"]}: {base_container_image}' ) diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index 36ea3f8b7074..f348e76bb680 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -58,7 +58,7 @@ # Optional: in the long run, move this into AgentConfig @dataclass class AutoReflectionConfig: - enabled: bool = False + enabled: bool = True # Probabilistic trigger: after each observation event, fire with probability `prob` prob: float = 0.10 # Reactive trigger: check last turn for "no tool" or "error observation" @@ -246,19 +246,19 @@ def step(self, state: State) -> 'Action': self._last_reflection_step = self._num_steps return self._emit_reflection(f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool.") - # NOTE: reflection case 1: Probablistically do general last N step reflection - # Let's do not break any pending actions - # Also make sure the last action was not think - if random.random() < self.auto_reflect.prob and \ - not self.pending_actions and \ - self._last_reflection_step != self._num_steps and \ - not self._last_action_is_think(condensed_history): - - self._num_steps += 1 - self._last_reflection_step = self._num_steps - return self._emit_reflection( - self.auto_reflect.prompt.format(n=self.auto_reflect.lookback_window) - ) + # # NOTE: reflection case 1: Probablistically do general last N step reflection + # # Let's do not break any pending actions + # # Also make sure the last action was not think + # if random.random() < self.auto_reflect.prob and \ + # not self.pending_actions and \ + # self._last_reflection_step != self._num_steps and \ + # not self._last_action_is_think(condensed_history): + + # self._num_steps += 1 + # self._last_reflection_step = self._num_steps + # return self._emit_reflection( + # self.auto_reflect.prompt.format(n=self.auto_reflect.lookback_window) + # ) # Continue with pending actions if any if self.pending_actions: diff --git a/openhands/runtime/base.py b/openhands/runtime/base.py index 3e5018aa39c8..4370c015f74d 100644 --- a/openhands/runtime/base.py +++ b/openhands/runtime/base.py @@ -946,6 +946,12 @@ def run_action(self, action: Action) -> Observation: task_list=[], content=f'Failed to read the task list from session directory {task_file_path}. Error: {str(e)}', ) + else: + return TaskTrackingObservation( + command=action.command, + task_list=[], + content=f'Unknown command: {action.command}', + ) return NullObservation('') if ( diff --git a/openhands/runtime/impl/docker/docker_runtime.py b/openhands/runtime/impl/docker/docker_runtime.py index 19bbdde437c2..61f87eb0563d 100644 --- a/openhands/runtime/impl/docker/docker_runtime.py +++ b/openhands/runtime/impl/docker/docker_runtime.py @@ -14,7 +14,8 @@ from docker.types import DriverConfig, Mount from docker.errors import NotFound -import json, tarfile, time +import json, tarfile, time, re +from typing import Tuple from openhands.core.config import OpenHandsConfig from openhands.core.exceptions import ( @@ -271,9 +272,9 @@ def maybe_build_runtime_container_image(self): # make sure you created the client with a large timeout somewhere: # self.docker_client = docker.from_env(timeout=DOCKER_TIMEOUT_SECS) - repo, index = self.get_info_from_base_image() - runtime_docker_image_folder = self.find_folder_by_prefix_suffix( - repo, index, "/workspaces/Openhands/swebench_dockers_for_eval/runtime_dockers/swebench_dev/" + repo, name = self.get_info_from_base_image() + runtime_docker_image_folder = self.find_folder_by_repo_name( + repo, name, "/workspaces/Openhands/runtime_dockers/swebench_dev/" ) tar_files = glob.glob(os.path.join(runtime_docker_image_folder, "*.tar")) if not tar_files: @@ -344,11 +345,13 @@ def maybe_build_runtime_container_image(self): ) - def find_folder_by_prefix_suffix(self, input_a, input_b, search_dir): + def find_folder_by_repo_name(self, repo, name, search_dir): matches = [] for p in Path(search_dir).iterdir(): - if p.is_dir() and p.name.startswith(input_a) and p.name.endswith(input_b): - matches.append(p) + if p.is_dir(): + folder_repo, folder_name = p.name.split("__") + if folder_repo == repo and folder_name == name: + matches.append(p) if matches: print("โœ… Found matching folder(s):") @@ -360,15 +363,16 @@ def find_folder_by_prefix_suffix(self, input_a, input_b, search_dir): + def get_info_from_base_image(self): if self.base_container_image.startswith("docker.io"): - repo = self.base_container_image.split(":")[0].split("/")[-1].split(".")[-1].split("__")[0] - index = self.base_container_image.split(":")[0].split("/")[-1].split(".")[-1].split("-")[-1] - return repo, index + repo = self.base_container_image.split(":")[0].split("/")[-1].split(".")[-1].split("_1776_")[0] + name = self.base_container_image.split(":")[0].split("/")[-1].split(".")[-1].split("_1776_")[1] + return repo, name elif self.base_container_image.startswith("openhands_local"): - repo = self.base_container_image.split(":")[0].split("-")[0].split("_")[-1] - index = self.base_container_image.split(":")[0].split("-")[-1] - return repo, index + repo = self.base_container_image.split(":")[0].split("openhands_local_")[1].split("__")[0] + name = self.base_container_image.split(":")[0].split("openhands_local_")[1].split("__")[1] + return repo, name else: raise ValueError( 'This base_container_image is not available either on the cloud or locally' diff --git a/save_runtime_image_local.py b/save_runtime_image_local.py index 0fc929cc7313..b2dbe4db37d4 100644 --- a/save_runtime_image_local.py +++ b/save_runtime_image_local.py @@ -18,7 +18,7 @@ def instance_id_to_remote_name(instance_id): base_image_dir = "/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images" output_root = "/workspaces/Openhands/swebench_dockers_for_eval/runtime_dockers/swebench_dev" -build_folder = "/workspaces/Openhands/michaelw/build_folder" +# build_folder = "/workspaces/Openhands/michaelw/build_folder" tar_files = [f for f in os.listdir(base_image_dir) if f.endswith('.tar')] # instance_names = [f.removesuffix('__latest.tar') for f in tar_files] @@ -45,8 +45,8 @@ def is_valid_tar(path: str) -> bool: for instance_name in tqdm(instance_names): base_image_name = instance_id_to_remote_name(instance_name) output_dir = os.path.join(output_root, instance_name) - shutil.rmtree(build_folder, ignore_errors=True) - os.makedirs(build_folder, exist_ok=True) + # shutil.rmtree(build_folder, ignore_errors=True) + # os.makedirs(build_folder, exist_ok=True) # --- Skip if valid tar already exists --- if os.path.isdir(output_dir): @@ -67,7 +67,7 @@ def is_valid_tar(path: str) -> bool: # docker_builder, # platform=None, # enable_browser=True, - # build_folder=build_folder, + ## build_folder=build_folder, # ) # print(f"Built image: {image_name}") From 214658442eea2b8526333ecb2df55a38d2765082 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Thu, 30 Oct 2025 23:20:36 +0000 Subject: [PATCH 08/12] refactor self reflection using env var --- .../agenthub/codeact_agent/codeact_agent.py | 70 ++++++++----------- save_runtime_image_local.py | 68 +++++++++--------- 2 files changed, 62 insertions(+), 76 deletions(-) diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index f348e76bb680..a8aaaec107fe 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -3,8 +3,6 @@ from collections import deque from typing import TYPE_CHECKING import random -import re -from dataclasses import dataclass from openhands.llm.llm_registry import LLMRegistry @@ -34,7 +32,7 @@ from openhands.controller.state.state import State from openhands.core.config import AgentConfig from openhands.core.logger import openhands_logger as logger -from openhands.core.message import Message, TextContent +from openhands.core.message import Message from openhands.events.action import AgentFinishAction, MessageAction from openhands.events.event import Event, EventSource from openhands.llm.llm_utils import check_tools @@ -47,31 +45,8 @@ PluginRequirement, ) from openhands.utils.prompt import PromptManager -from openhands.events.action.agent import AgentThinkAction -from openhands.core.exceptions import ( - FunctionCallNotExistsError, - FunctionCallValidationError, -) - -# Optional: in the long run, move this into AgentConfig -@dataclass -class AutoReflectionConfig: - enabled: bool = True - # Probabilistic trigger: after each observation event, fire with probability `prob` - prob: float = 0.10 - # Reactive trigger: check last turn for "no tool" or "error observation" - reactive_enabled: bool = True - # How many past events to consider for the โ€œlast N stepsโ€ wording - lookback_window: int = 5 - # The seeded thought text; {n} is formatted with lookback_window - prompt: str = ( - "Look back at the last {n} steps. Are you making good progress, or should you " - "step back and reconsider your approach? If you're off-track, propose " - "concrete adjustments and the single next best action/tool to try." - ) - class CodeActAgent(Agent): VERSION = '2.2' @@ -130,7 +105,18 @@ def __init__(self, config: AgentConfig, llm_registry: LLMRegistry) -> None: # NOTE: reflection self._num_steps = 0 self._last_reflection_step = -1 - self.auto_reflect = AutoReflectionConfig() + self.auto_reflect_enabled = os.getenv("AUTO_REFLECTION_ENABLED", "true").lower() == "true" + self.auto_reflect_prob = float(os.getenv("AUTO_REFLECTION_PROB", "0.10")) + self.auto_reflect_reactive = os.getenv("AUTO_REFLECTION_REACTIVE_ENABLED", "true").lower() == "true" + self.auto_reflect_lookback = int(os.getenv("AUTO_REFLECTION_LOOKBACK_WINDOW", "5")) + self.auto_reflect_prompt = os.getenv( + "AUTO_REFLECTION_PROMPT", + ( + "Look back at the last {n} steps. Are you making good progress, or should you " + "step back and reconsider your approach? If you're off-track, propose " + "concrete adjustments and the single next best action/tool to try." + ), + ) @property def prompt_manager(self) -> PromptManager: @@ -237,8 +223,8 @@ def step(self, state: State) -> 'Action': ) # NOTE: reflection case 2: Revisit last observation to catch if there is tool call failures - if self.auto_reflect.enabled: - if self.auto_reflect.reactive_enabled: + if self.auto_reflect_enabled: + if self.auto_reflect_reactive: is_last_turn_tool_error, tool_call_error_message =self._last_turn_has_tool_error(condensed_history) if is_last_turn_tool_error and not self._last_action_is_think(condensed_history): self.pending_actions.clear() # clear the queue @@ -246,19 +232,19 @@ def step(self, state: State) -> 'Action': self._last_reflection_step = self._num_steps return self._emit_reflection(f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool.") - # # NOTE: reflection case 1: Probablistically do general last N step reflection - # # Let's do not break any pending actions - # # Also make sure the last action was not think - # if random.random() < self.auto_reflect.prob and \ - # not self.pending_actions and \ - # self._last_reflection_step != self._num_steps and \ - # not self._last_action_is_think(condensed_history): + # NOTE: reflection case 1: Probablistically do general last N step reflection + # Let's do not break any pending actions + # Also make sure the last action was not think + if random.random() < self.auto_reflect_prob and \ + not self.pending_actions and \ + self._last_reflection_step != self._num_steps and \ + not self._last_action_is_think(condensed_history): - # self._num_steps += 1 - # self._last_reflection_step = self._num_steps - # return self._emit_reflection( - # self.auto_reflect.prompt.format(n=self.auto_reflect.lookback_window) - # ) + self._num_steps += 1 + self._last_reflection_step = self._num_steps + return self._emit_reflection( + self.auto_reflect_prompt.format(n=self.auto_reflect_lookback) + ) # Continue with pending actions if any if self.pending_actions: @@ -291,7 +277,7 @@ def step(self, state: State) -> 'Action': # NOTE: reflection case 3: cope with tool parse failures except Exception as e: # Wrong tool parsing will be raised by response_to_actions in function_calling.py - if self.auto_reflect.enabled: + if self.auto_reflect_enabled: self._last_reflection_step = self._num_steps self._num_steps += 1 return self._emit_reflection( diff --git a/save_runtime_image_local.py b/save_runtime_image_local.py index b2dbe4db37d4..a44c3ca11b32 100644 --- a/save_runtime_image_local.py +++ b/save_runtime_image_local.py @@ -59,41 +59,41 @@ def is_valid_tar(path: str) -> bool: else: print(f"โš ๏ธ Found existing tar for {instance_name} but itโ€™s invalid โ†’ rebuilding") - # # --- Build with retries --- - # for attempt in range(1, MAX_RETRIES + 1): - # try: - # image_name = build_runtime_image( - # base_image_name, - # docker_builder, - # platform=None, - # enable_browser=True, - ## build_folder=build_folder, - # ) - # print(f"Built image: {image_name}") + # --- Build with retries --- + for attempt in range(1, MAX_RETRIES + 1): + try: + image_name = build_runtime_image( + base_image_name, + docker_builder, + platform=None, + enable_browser=True, + # build_folder=build_folder, + ) + print(f"Built image: {image_name}") - # os.makedirs(output_dir, exist_ok=True) - # safe_image_name = image_name.split("/")[-1].split(":")[-1] - # tar_path = os.path.join(output_dir, f"{safe_image_name}.tar") + os.makedirs(output_dir, exist_ok=True) + safe_image_name = image_name.split("/")[-1].split(":")[-1] + tar_path = os.path.join(output_dir, f"{safe_image_name}.tar") - # print(f"Saving image to {tar_path} ...") - # subprocess.run(["docker", "save", "-o", tar_path, image_name], check=True) - # print(f"โœ… Image saved to: {tar_path}") - # print(f"๐Ÿงน Removing local image {image_name} to free disk space...") - # try: - # client.images.remove(image=image_name, force=True, noprune=False) - # print(f"โœ… Removed image: {image_name}") - # subprocess.run( - # ["bash", "/workspaces/OpenHands/clean_docker.sh"] - # ) - # except Exception as e: - # print(f"โš ๏ธ Could not remove image {image_name}: {e}") + print(f"Saving image to {tar_path} ...") + subprocess.run(["docker", "save", "-o", tar_path, image_name], check=True) + print(f"โœ… Image saved to: {tar_path}") + print(f"๐Ÿงน Removing local image {image_name} to free disk space...") + try: + client.images.remove(image=image_name, force=True, noprune=False) + print(f"โœ… Removed image: {image_name}") + subprocess.run( + ["bash", "/workspaces/OpenHands/clean_docker.sh"] + ) + except Exception as e: + print(f"โš ๏ธ Could not remove image {image_name}: {e}") - # break # success โ†’ exit retry loop + break # success โ†’ exit retry loop - # except Exception as e: - # print(f"โš ๏ธ Build failed for {instance_name} (attempt {attempt}/{MAX_RETRIES}): {e}") - # if attempt < MAX_RETRIES: - # print(f"Retrying in {RETRY_DELAY} seconds...") - # time.sleep(RETRY_DELAY) - # else: - # print(f"โŒ Giving up on {instance_name} after {MAX_RETRIES} attempts.") + except Exception as e: + print(f"โš ๏ธ Build failed for {instance_name} (attempt {attempt}/{MAX_RETRIES}): {e}") + if attempt < MAX_RETRIES: + print(f"Retrying in {RETRY_DELAY} seconds...") + time.sleep(RETRY_DELAY) + else: + print(f"โŒ Giving up on {instance_name} after {MAX_RETRIES} attempts.") From 282c7153898f51f56104f2c0194fcb00840082c3 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Fri, 31 Oct 2025 00:22:48 +0000 Subject: [PATCH 09/12] ready to merge reflection with loc agent --- .../agenthub/codeact_agent/codeact_agent.py | 26 ++++--------------- 1 file changed, 5 insertions(+), 21 deletions(-) diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index a8aaaec107fe..91a00c5c2b9e 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -103,8 +103,6 @@ def __init__(self, config: AgentConfig, llm_registry: LLMRegistry) -> None: self.llm = self.llm_registry.get_router(self.config) # NOTE: reflection - self._num_steps = 0 - self._last_reflection_step = -1 self.auto_reflect_enabled = os.getenv("AUTO_REFLECTION_ENABLED", "true").lower() == "true" self.auto_reflect_prob = float(os.getenv("AUTO_REFLECTION_PROB", "0.10")) self.auto_reflect_reactive = os.getenv("AUTO_REFLECTION_REACTIVE_ENABLED", "true").lower() == "true" @@ -180,9 +178,6 @@ def reset(self) -> None: super().reset() # Only clear pending actions, not LLM metrics self.pending_actions.clear() - # NOTE: reflection - self._num_steps = 0 - self._last_reflection_step = -1 def step(self, state: State) -> 'Action': """Performs one step using the CodeAct Agent. @@ -210,6 +205,10 @@ def step(self, state: State) -> 'Action': # to the conversation manager for processing, but if we get a condensation # event we'll just return that instead of an action. The controller will # immediately ask the agent to step again with the new view. + # Continue with pending actions if any + if self.pending_actions: + return self.pending_actions.popleft() + condensed_history: list[Event] = [] match self.condenser.condensed_history(state): case View(events=events): @@ -227,28 +226,16 @@ def step(self, state: State) -> 'Action': if self.auto_reflect_reactive: is_last_turn_tool_error, tool_call_error_message =self._last_turn_has_tool_error(condensed_history) if is_last_turn_tool_error and not self._last_action_is_think(condensed_history): - self.pending_actions.clear() # clear the queue - self._num_steps += 1 - self._last_reflection_step = self._num_steps return self._emit_reflection(f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool.") # NOTE: reflection case 1: Probablistically do general last N step reflection # Let's do not break any pending actions # Also make sure the last action was not think - if random.random() < self.auto_reflect_prob and \ - not self.pending_actions and \ - self._last_reflection_step != self._num_steps and \ - not self._last_action_is_think(condensed_history): - - self._num_steps += 1 - self._last_reflection_step = self._num_steps + if random.random() < self.auto_reflect_prob and not self._last_action_is_think(condensed_history): return self._emit_reflection( self.auto_reflect_prompt.format(n=self.auto_reflect_lookback) ) - # Continue with pending actions if any - if self.pending_actions: - return self.pending_actions.popleft() # if we're done, go back latest_user_message = state.get_last_user_message() @@ -278,8 +265,6 @@ def step(self, state: State) -> 'Action': except Exception as e: # Wrong tool parsing will be raised by response_to_actions in function_calling.py if self.auto_reflect_enabled: - self._last_reflection_step = self._num_steps - self._num_steps += 1 return self._emit_reflection( f"Malformed tool call (invalid JSON/args):\n```\n{e}\n```\n" "Reflect briefly and emit a valid tool call or a better-plan message." @@ -289,7 +274,6 @@ def step(self, state: State) -> 'Action': logger.debug(f'Actions after response_to_actions: {actions}') for action in actions: self.pending_actions.append(action) - self._num_steps += 1 return self.pending_actions.popleft() From b9e92194ffed2ff3c89cb7685f0fa96385f790e8 Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Tue, 4 Nov 2025 01:58:52 +0000 Subject: [PATCH 10/12] clean up intermediate trajectory files --- .../swe_bench/other_scripts/clean_up.py | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 evaluation/benchmarks/swe_bench/other_scripts/clean_up.py diff --git a/evaluation/benchmarks/swe_bench/other_scripts/clean_up.py b/evaluation/benchmarks/swe_bench/other_scripts/clean_up.py new file mode 100644 index 000000000000..b54dd93af811 --- /dev/null +++ b/evaluation/benchmarks/swe_bench/other_scripts/clean_up.py @@ -0,0 +1,33 @@ + + +import argparse +import os + +def parse_arguments(): + parser = argparse.ArgumentParser(description="Clean up unnecessary files after OpenHands Swe-bench evaluation") + parser.add_argument("--evaluation_folder", type=str, help="A folder like /workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_176_baseline") + return parser.parse_args() + + +if __name__ == "__main__": + + args = parse_arguments() + base_folder = args.evaluation_folder + + llm_completion_folder = os.path.join(base_folder, "llm_completions") + + + instance_ids = [d for d in os.listdir(llm_completion_folder) if os.path.isdir(os.path.join(llm_completion_folder, d))] + + + for instance_id in instance_ids: + + instance_folder = os.path.join(llm_completion_folder, instance_id) + + intermediate_files = sorted( + [f for f in os.listdir(instance_folder) if os.path.isfile(os.path.join(instance_folder, f)) and "trajectory" not in f] + ) + + # Skip the final messages json file, delete only the previous ones + for file in intermediate_files[:-1]: + os.remove(os.path.join(instance_folder, file)) From f439018f4c327a325252188607540d15341d1c8d Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Wed, 5 Nov 2025 19:47:44 +0000 Subject: [PATCH 11/12] add logprobs and refactor end to end scripts --- .../other_scripts/run_end_to_end_local.sh | 117 ++++++++++++------ openhands/llm/llm.py | 3 + openhands/llm/llm_utils.py | 36 ++++++ 3 files changed, 116 insertions(+), 40 deletions(-) diff --git a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh index db63b532258a..80920ee2874b 100755 --- a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh +++ b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh @@ -1,5 +1,3 @@ -#!/bin/bash - #!/bin/bash set -e # Exit on any error @@ -8,9 +6,6 @@ set -e # Exit on any error ####################################### TIMESTAMP=$(date +"%Y%m%d_%H%M%S") -# LOGDIR_RUN="logs_end_to_end" -# mkdir -p "$LOGDIR_RUN" -# LOGFILE="$LOGDIR_RUN/eval_run_${TIMESTAMP}.log" LOGFILE="eval_run_${TIMESTAMP}.log" @@ -26,21 +21,22 @@ echo "๐Ÿ“ Log file: $LOGFILE" echo "========================================" -export TMPDIR=/workspaces/Openhands/runtime_dockers/temp_swebench -export DOCKER_TMPDIR=/workspaces/Openhands/runtime_dockers/temp_swebench -export TEMP=/workspaces/Openhands/runtime_dockers/temp_swebench -export TMP=/workspaces/Openhands/runtime_dockers/temp_swebench - - ########################## # ----- ARGUMENTS -------# ########################## -EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_176_reflection_no_prob/" +# Usage: +# ./run.sh # default: gen_and_eval +# ./run.sh inference_only +# ./run.sh eval_only +# ./run.sh gen_and_eval +MODE=${1:-gen_and_eval} # inference_only | eval_only | gen_and_eval + +EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_test_1105/" MODEL="llm.qwen_coder_30b_small" LOCAL_DOCKER_DIR="/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images/" CONFIG_ML="/workspaces/OpenHands/evaluation/benchmarks/swe_bench/config_2.toml" MAX_TURNS=100 -NUM_SAMPLES=176 +NUM_SAMPLES=1 DATASET="princeton-nlp/SWE-bench" SPLIT="dev" # DATASET="princeton-nlp/SWE-bench_Verified" @@ -63,8 +59,9 @@ export CONFIG_ML=$CONFIG_ML ########################## echo "" echo "=========== SWE-Bench Evaluation Configuration ===========" -echo " EVAL_OUTPUT_DIR: $EVAL_OUTPUT_DIR" -echo " MODEL: $MODEL" +echo " MODE: $MODE" +echo " EVAL_OUTPUT_DIR: $EVAL_OUTPUT_DIR" +echo " MODEL: $MODEL" echo " MAX_TURNS: $MAX_TURNS" echo " NUM_SAMPLES: $NUM_SAMPLES" echo " NUM_WORKERS: $NUM_WORKERS" @@ -78,36 +75,67 @@ echo "" ########################## # -- RUN INFERENCE ----- # ########################## -# Placeholder for actual inference call -# Uncomment and customize if needed -# /path/to/inference.sh $MODEL ... -############################# -# ๐Ÿš€ Run Main Evaluation # -############################# -echo "๐Ÿ”ง Starting main inference..." -/workspaces/OpenHands/evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh \ - $MODEL \ - HEAD \ - CodeActAgent \ - $NUM_SAMPLES \ - $MAX_TURNS \ - $NUM_WORKERS \ - $DATASET \ - $SPLIT \ - $NUM_RUNS \ - swe -echo "โœ… Evaluation complete. Results saved in $EVAL_OUTPUT_DIR" -echo +JSONL_DIR=$EVAL_OUTPUT_DIR + +if [[ "$MODE" == "inference_only" || "$MODE" == "gen_and_eval" ]]; then + echo "๐Ÿ”ง Starting main inference..." + /workspaces/OpenHands/evaluation/benchmarks/swe_bench/scripts/run_infer_local_docker.sh \ + $MODEL \ + HEAD \ + CodeActAgent \ + $NUM_SAMPLES \ + $MAX_TURNS \ + $NUM_WORKERS \ + $DATASET \ + $SPLIT \ + $NUM_RUNS \ + swe + echo "โœ… Inference complete. Results saved in $EVAL_OUTPUT_DIR" + echo +else + echo "โญ๏ธ Skipping inference step (mode=$MODE)" +fi + +############################################ +# From here on: steps that need output.jsonl +############################################ + +# Find the produced JSONL (or the existing one, if eval_only) +ALL_JSONL_FILES=$(find "$JSONL_DIR" -type f -name "output.jsonl" || true) +JSONL_FILE=$(echo "$ALL_JSONL_FILES" | head -n 1 || true) + +if [[ -z "$JSONL_FILE" ]]; then + echo "โŒ Could not find output.jsonl under $JSONL_DIR" + echo " Make sure inference has been run or EVAL_OUTPUT_DIR is correct." + exit 1 +fi + +PARENT_FOLDER=$(dirname "$JSONL_FILE") + +# If mode is inference_only, stop here +if [[ "$MODE" == "inference_only" ]]; then + echo "๐ŸŽ‰ inference_only mode: stopping after inference." + echo "๐Ÿ“‚ Results located in: $PARENT_FOLDER" + + # inference_only: do cleanup before exiting + echo "" + echo ">>> CLEANUP EXTRA MODEL MESSAGE HISTORY FILES (inference_only)" + python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/clean_up.py \ + --evaluation_folder "$EVAL_OUTPUT_DIR" + echo "โœ… Cleaned up all intermediate model generation files (inference_only)" + + exit 0 +fi + +################################# +# Below runs for: gen_and_eval, eval_only +################################# ########################## # --- TOOL CALL SUMMARY --# ########################## echo ">>> [1/5] TOOL CALL SUMMARY" -JSONL_DIR=$EVAL_OUTPUT_DIR -ALL_JSONL_FILES=$(find "$JSONL_DIR" -type f -name "output.jsonl") -JSONL_FILE=$(echo "$ALL_JSONL_FILES" | head -n 1) -PARENT_FOLDER=$(dirname "$JSONL_FILE") TOOL_SUMMARY_OUTPUT="$PARENT_FOLDER/bash_tool_call_summary_$MODEL" echo " Using JSONL file: $JSONL_FILE" @@ -131,7 +159,7 @@ SWEBENCH_JSONL="$PARENT_FOLDER/output.swebench.jsonl" echo "โœ… Converted to: $SWEBENCH_JSONL" ########################## -# ---- LOCALIZATION REPORT ----# +# ---- LOCALization REPORT ----# ########################## echo "" echo ">>> [3/5] LOCALIZATION REPORT" @@ -216,6 +244,15 @@ python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/gener echo "โœ… Final summary generated." +########################## +# -------- CLEAN UP -------- # +########################## +echo "" +echo ">>> CLEANUP EXTRA MODEL MESSAGE HISTORY FILES" +python /workspaces/OpenHands/evaluation/benchmarks/swe_bench/other_scripts/clean_up.py \ + --evaluation_folder "$EVAL_OUTPUT_DIR" +echo "โœ… Cleaned up all intermediate model generation files" + ########################## # -------- DONE -------- # ########################## diff --git a/openhands/llm/llm.py b/openhands/llm/llm.py index fab3de1e4008..358dda3e5415 100644 --- a/openhands/llm/llm.py +++ b/openhands/llm/llm.py @@ -10,6 +10,7 @@ from openhands.core.config import LLMConfig from openhands.llm.metrics import Metrics from openhands.llm.model_features import get_features +from openhands.llm.llm_utils import extract_and_strip_logprobs with warnings.catch_warnings(): warnings.simplefilter('ignore') @@ -377,6 +378,8 @@ def wrapper(*args: Any, **kwargs: Any) -> Any: f'{self.config.model.replace("/", "__")}-{time.time()}.json', ) + extract_and_strip_logprobs(resp) + # set up the dict to be logged _d = { 'messages': messages, diff --git a/openhands/llm/llm_utils.py b/openhands/llm/llm_utils.py index c59c24d0bf4d..09d63da54ff2 100644 --- a/openhands/llm/llm_utils.py +++ b/openhands/llm/llm_utils.py @@ -8,6 +8,42 @@ from litellm import ChatCompletionToolParam +def extract_and_strip_logprobs(resp): + """ + - Pulls out tokens/logprobs from response_dict["choices"][i]["logprobs"]["content"] + - Removes the big logprobs blocks from each choice + - Returns (tokens, logprobs, cleaned_response_dict) + """ + + all_tokens = [] + all_logprobs = [] + + choices = resp.get("choices", []) + for choice in choices: + lp = choice.get("logprobs") + if not lp: + continue + + content = lp.get("content", []) + for item in content: + all_tokens.append(item.get("token")) + all_logprobs.append(item.get("logprob")) + + # Cleanup redundant logprobs from resp Pydantic object + try: + choice.logprobs = { + "tokens": all_tokens, + "all_logprobs": all_logprobs, + } + except Exception: + # 2) if the model is frozen/immutable, fall back to __dict__ + try: + choice.__dict__["logprobs"] = None + except Exception: + # last resort: do nothing; at least we extracted them + pass + + def check_tools( tools: list['ChatCompletionToolParam'], llm_config: LLMConfig ) -> list['ChatCompletionToolParam']: From cd293e2395066223a26cde15bd695433bf1bd7dd Mon Sep 17 00:00:00 2001 From: michaelw-cerebras Date: Tue, 11 Nov 2025 02:53:50 +0000 Subject: [PATCH 12/12] self-reflection final push --- config.toml | 17 +- config_llm.yaml | 5 + evaluation/benchmarks/swe_bench/config_2.toml | 75 +- .../evaluate_trajectory_harsh_local.py | 4 +- .../other_scripts/run_end_to_end_local.sh | 6 +- openhands.ipynb | 1347 ++++++++++------- .../agenthub/codeact_agent/codeact_agent.py | 9 +- 7 files changed, 906 insertions(+), 557 deletions(-) diff --git a/config.toml b/config.toml index ef3c4ddbf78f..38efe4db2f43 100644 --- a/config.toml +++ b/config.toml @@ -22,6 +22,15 @@ max_output_tokens = 16384 max_message_chars = 50000 native_tool_calling = true +[llm.cepov3_optillm_qwen30b] +model="openai/Qwen/Qwen3-Coder-30B-A3B-Instruct" +base_url="http://localhost:10010/v1" +max_input_tokens = 65384 +max_output_tokens = 16384 +max_message_chars = 50000 +native_tool_calling = true +log_completions = true + [agent] enable_history_truncation = true @@ -30,14 +39,6 @@ llm_config = "llm.qwen_coder_30b_small" [sandbox] timeout = 120 -[llm] -model="openai/qwen-coder-30b-small" ##model_name will be from litellm config settings. -api_key="serving-on-vllm" -base_url="http://0.0.0.0:4000/" -max_input_tokens = 65384 -max_output_tokens = 16384 -max_message_chars = 50000 -native_tool_calling = true [condenser.summarizer_for_eval_gptoss-120b] type = "llm" diff --git a/config_llm.yaml b/config_llm.yaml index 4264238162fb..cb9fdfc4f3ee 100644 --- a/config_llm.yaml +++ b/config_llm.yaml @@ -4,3 +4,8 @@ model_list: model: hosted_vllm/Qwen/Qwen3-Coder-30B-A3B-Instruct api_base: http://localhost:10000/v1/ api_key: "serving-on-vllm" + # - model_name: qwen-coder-30b-small + # litellm_params: + # model: hosted_vllm/Qwen/Qwen3-Coder-30B-A3B-Instruct + # api_base: http://localhost:10000/v1/ + # api_key: "serving-on-vllm" diff --git a/evaluation/benchmarks/swe_bench/config_2.toml b/evaluation/benchmarks/swe_bench/config_2.toml index 901252f95d6f..d0aab25b872f 100644 --- a/evaluation/benchmarks/swe_bench/config_2.toml +++ b/evaluation/benchmarks/swe_bench/config_2.toml @@ -1,27 +1,52 @@ selected_ids = [ - "pvlib__pvlib-python-1707", - "pylint-dev__astroid-1614", - "sqlfluff__sqlfluff-884", - "pydicom__pydicom-1192", - "pvlib__pvlib-python-1589", - "pylint-dev__astroid-1616", - "sqlfluff__sqlfluff-905", - "pydicom__pydicom-938", - "marshmallow-code__marshmallow-1343", - "sqlfluff__sqlfluff-2419", - "pvlib__pvlib-python-1854", - "pylint-dev__astroid-1719", - "marshmallow-code__marshmallow-1164", - "marshmallow-code__marshmallow-1252", - "pydicom__pydicom-965", - "pylint-dev__astroid-1903", - "pydicom__pydicom-1694", - "pylint-dev__astroid-1196", - "pydicom__pydicom-1256", - "pydicom__pydicom-1228", - "pvlib__pvlib-python-1738", - "pvlib__pvlib-python-1349", - "pylint-dev__astroid-1962", - "pylint-dev__astroid-1959", - "marshmallow-code__marshmallow-1810", + "pvlib__pvlib-python-1666", + "pvlib__pvlib-python-1478", + "pylint-dev__astroid-2015", + "pyvista__pyvista-432", + "pyvista__pyvista-3675", + "sqlfluff__sqlfluff-880", + "sqlfluff__sqlfluff-891", + "marshmallow-code__marshmallow-2123", + "pvlib__pvlib-python-1623", + "pvlib__pvlib-python-1176", + "pvlib__pvlib-python-1469", + "pvlib__pvlib-python-1033", + "pydicom__pydicom-916", + "pydicom__pydicom-1236", + "pvlib__pvlib-python-718", + "pvlib__pvlib-python-1053", + "pvlib__pvlib-python-1518", + "pylint-dev__astroid-1741", + "pylint-dev__astroid-1030", + "pylint-dev__astroid-2219", + "pyvista__pyvista-4226", + "pyvista__pyvista-3750", + "pyvista__pyvista-4225", + "pydicom__pydicom-1241", + "pydicom__pydicom-1017", + "pydicom__pydicom-1048", + "pydicom__pydicom-1720", + "pydicom__pydicom-1334", + "pydicom__pydicom-997", + "marshmallow-code__marshmallow-1229", + "pvlib__pvlib-python-823", + "pvlib__pvlib-python-1186", + "pvlib__pvlib-python-1764", + "pvlib__pvlib-python-1682", + "pvlib__pvlib-python-1832", + "pvlib__pvlib-python-1089", + "pylint-dev__astroid-2240", + "pylint-dev__astroid-1417", + "pylint-dev__astroid-984", + "pylint-dev__astroid-1092", + "pylint-dev__astroid-983", + "pydicom__pydicom-995", + "pydicom__pydicom-897", + "pydicom__pydicom-1674", + "pydicom__pydicom-1375", + "pvlib__pvlib-python-807", + "pvlib__pvlib-python-1048", + "pvlib__pvlib-python-1181", + "pvlib__pvlib-python-1480", + "pvlib__pvlib-python-763", ] diff --git a/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py b/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py index 8ef724c7c198..c9dd99716717 100644 --- a/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py +++ b/evaluation/benchmarks/swe_bench/other_scripts/evaluate_trajectory_harsh_local.py @@ -222,7 +222,7 @@ def run_evaluation(self, instance_id: str) -> Dict: cmd = [ "python", "-m", "swebench.harness.run_evaluation", "--dataset_name", f"{self.dataset_name}", - "--max_workers", "15", + "--max_workers", "5", "--cache_level", "none", "--clean", "True", "--predictions_path", self.predictions_path, @@ -499,4 +499,4 @@ def main(): if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh index 80920ee2874b..a733747f7a49 100755 --- a/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh +++ b/evaluation/benchmarks/swe_bench/other_scripts/run_end_to_end_local.sh @@ -31,8 +31,9 @@ echo "========================================" # ./run.sh gen_and_eval MODE=${1:-gen_and_eval} # inference_only | eval_only | gen_and_eval -EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_test_1105/" -MODEL="llm.qwen_coder_30b_small" +EVAL_OUTPUT_DIR="/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/cepov3_optillm_qwen30b_maxiter_100_N_50_baseline/" +# MODEL="llm.qwen_coder_30b_small" +MODEL="llm.cepov3_optillm_qwen30b" LOCAL_DOCKER_DIR="/workspaces/Openhands/swebench_dockers_for_eval/swebench_dockers/dev/docker_images/" CONFIG_ML="/workspaces/OpenHands/evaluation/benchmarks/swe_bench/config_2.toml" MAX_TURNS=100 @@ -53,6 +54,7 @@ export DEBUG=1 export EVAL_SKIP_MAXIMUM_RETRIES_EXCEEDED=true export LOCAL_DOCKER_IMAGE_DIR=$LOCAL_DOCKER_DIR export CONFIG_ML=$CONFIG_ML +export OPENAI_API_KEY="serving-on-vllm" ########################## # ----- CONFIG LOG ------# diff --git a/openhands.ipynb b/openhands.ipynb index 942245cef5a8..e861e7b760f9 100644 --- a/openhands.ipynb +++ b/openhands.ipynb @@ -1,581 +1,884 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Complete evaluation pipeline\n", + " - Input instance_id\n", + " - get what test are failing before\n", + "\n", + "- Docker understanding\n", + " - flow in openhands\n", + " - dockerfile" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import json, os, random, math\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "import re\n", - "from datetime import datetime, timedelta\n", - "from typing import Iterable, List, Dict, Optional\n", - "\n", - "# Target markers (cheap substring checks first)\n", - "START_SUBSTR = \"Starting evaluation for instance\"\n", - "BEGIN_SUBSTR = \"BEGIN Runtime Initialization Fn\"\n", - "END_SUBSTR = \"END Runtime Completion Fn\"\n", - "\n", - "# Keep existing robust patterns\n", - "START_RE = re.compile(r'Starting evaluation for instance\\s+(?P.+?)\\.')\n", - "BEGIN_RE = re.compile(r'\\bBEGIN Runtime Initialization Fn\\b')\n", - "END_RE = re.compile(r'\\bEND Runtime Completion Fn\\b')\n", - "\n", - "# Fast timestamp-at-line-start with optional ANSI color codes\n", - "# e.g. \"\\x1b[92m02:18:18\" or \"02:18:18\"\n", - "TS_AT_START_RE = re.compile(\n", - " r'^\\s*(?:\\x1b\\[[0-9;]*m\\s*)*(?P\\d{2}):(?P\\d{2}):(?P\\d{2})'\n", - ")\n", - "\n", - "def _parse_time(h: int, m: int, s: int) -> datetime:\n", - " \"\"\"Force same date for all times.\"\"\"\n", - " return datetime(1970, 1, 1, h, m, s)\n", - "\n", - "def _extract_timestamp_fast(line: str) -> Optional[datetime]:\n", - " \"\"\"\n", - " Only parse HH:MM:SS at the *start* of the line (after optional ANSI codes).\n", - " Returns datetime(1970-01-01 HH:MM:SS) or None.\n", - " \"\"\"\n", - " m = TS_AT_START_RE.match(line)\n", - " if not m:\n", + "base_dir = \"/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent\"\n", + "run_name = \"qwen-coder-30b-small_maxiter_100_N_176_baseline_logprobs\"\n", + "all_instance_ids = [d for d in os.listdir(os.path.join(base_dir, run_name, \"llm_completions\")) if os.path.isdir(os.path.join(base_dir, run_name, \"llm_completions\", d))]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# LogProbs Analysis\n", + "- First categorize samples to succeed, failed, partially failed\n", + " - For failed, first focus on those reach max iterations\n", + "- Pick a max-iter-failed example, plot histogram on log prob\n", + "- " + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "def get_logprobs_from_turn(turn):\n", + " try:\n", + " return turn[\"tool_call_metadata\"][\"model_response\"][\"choices\"][0][\"logprobs\"]\n", + " except:\n", " return None\n", - " return _parse_time(int(m.group('h')), int(m.group('m')), int(m.group('s')))\n", - "\n", - "def parse_log_triplets(lines: Iterable[str], to_dataframe: bool = False):\n", - " \"\"\"\n", - " Only parse timestamps for lines that contain one of the target markers.\n", - " Perf-friendly: cheap substring checks first, then minimal regex work.\n", - " \"\"\"\n", - " results: List[Dict] = []\n", - " current = None # {'id','t1','t2','t3'}\n", - "\n", - " for line in lines:\n", - " # Cheap pre-filter: skip most lines fast\n", - " if (START_SUBSTR not in line\n", - " and BEGIN_SUBSTR not in line\n", - " and END_SUBSTR not in line):\n", - " continue\n", "\n", - " # Try to extract timestamp only now\n", - " ts = _extract_timestamp_fast(line)\n", - " if ts is None:\n", - " # If a target line lacks a parsable timestamp, skip (or log/warn)\n", + "\n", + "def is_structural(tok):\n", + " return tok in (\"\", \"\", \"\\n\") or tok.startswith(\"<\")\n", + "\n", + "\n", + "def turn_logprob(logprob_list, token_list):\n", + " seq_logprob = 0.0\n", + " valid_logprob_count = 0\n", + " for token, logprob in zip(token_list, logprob_list):\n", + " if is_structural(token):\n", " continue\n", + " if logprob is not None:\n", + " seq_logprob += logprob\n", + " valid_logprob_count += 1\n", + " seq_prob = math.exp(seq_logprob)\n", + " avg_logprob = seq_logprob / valid_logprob_count\n", + "\n", + " return {\n", + " \"sequence_log_probs\": seq_logprob,\n", + " \"avergage_logprob_per_token\": avg_logprob,\n", + " \"sequence_prob\": seq_prob,\n", + " }\n", "\n", - " # 1) Starting evaluation...\n", - " if START_SUBSTR in line:\n", - " m_start = START_RE.search(line)\n", - " if m_start:\n", - " # Flush partial previous instance if needed\n", - " if current and ('t1' in current) and ('t2' in current) and ('t3' not in current):\n", - " results.append({\n", - " 'instance_id': current['id'],\n", - " 'docker_build_start_ts': current['t1'],\n", - " 'llm_execution_start_ts': current.get('t2'),\n", - " 'end_ts': None,\n", - " 'docker_build_time': (current['t2'] - current['t1']).total_seconds() if current.get('t2') else None,\n", - " 'llm_execution_time': None,\n", - " 'total_time': None,\n", - " 'complete_triplet': False,\n", - " })\n", - " current = {'id': m_start.group('id'), 't1': ts}\n", - " continue\n", - "\n", - " # 2) BEGIN Runtime Initialization Fn\n", - " if BEGIN_SUBSTR in line and BEGIN_RE.search(line):\n", - " if current and 't1' in current and 't2' not in current:\n", - " current['t2'] = ts\n", + "def trajectory_logprob_stats(trajectory):\n", + " logprob_infos = []\n", + "\n", + " for turn in trajectory:\n", + " logprob_dict = get_logprobs_from_turn(turn)\n", + " if not logprob_dict:\n", " continue\n", + " token_list = logprob_dict[\"tokens\"]\n", + " logprob_list = logprob_dict[\"all_logprobs\"]\n", + "\n", + " sequence_logprob_info = turn_logprob(logprob_list, token_list)\n", + " logprob_infos.append(sequence_logprob_info)\n", + " return logprob_infos\n", + "\n", "\n", - " # 3) END Runtime Completion Fn\n", - " if END_SUBSTR in line and END_RE.search(line):\n", - " if current and 't1' in current and 't3' not in current:\n", - " current['t3'] = ts\n", - " results.append({\n", - " 'instance_id': current['id'],\n", - " 'docker_build_start_ts': current['t1'],\n", - " 'llm_execution_start_ts': current.get('t2'),\n", - " 'end_ts': current.get('t3'),\n", - " 'docker_build_time': (current['t2'] - current['t1']).total_seconds() if current.get('t2') else None,\n", - " 'llm_execution_time': (current['t3'] - current['t2']).total_seconds() if current.get('t2') and current.get('t3') else None,\n", - " 'total_time': (current['t3'] - current['t1']).total_seconds() if current.get('t1') and current.get('t3') else None,\n", - " 'complete_triplet': ('t2' in current),\n", - " })\n", - " current = None\n", + "def plot_trajectory_logprob_hists(trajectory):\n", + " seq_logprobs = []\n", + " avg_logprobs = []\n", + " seq_probs = []\n", + "\n", + " for turn in trajectory:\n", + " logprob_dict = get_logprobs_from_turn(turn)\n", + " if not logprob_dict:\n", " continue\n", "\n", - " # EOF: flush partial\n", - " if current:\n", - " results.append({\n", - " 'instance_id': current['id'],\n", - " 'docker_build_start_ts': current.get('t1'),\n", - " 'llm_execution_start_ts': current.get('t2'),\n", - " 'end_ts': current.get('t3'),\n", - " 'docker_build_time': (current['t2'] - current['t1']).total_seconds() if current.get('t2') and current.get('t1') else None,\n", - " 'llm_execution_time': (current['t3'] - current['t2']).total_seconds() if current.get('t3') and current.get('t2') else None,\n", - " 'total_time': (current['t3'] - current['t1']).total_seconds() if current.get('t3') and current.get('t1') else None,\n", - " 'complete_triplet': ('t1' in current) and ('t2' in current) and ('t3' in current),\n", - " })\n", - "\n", - " if to_dataframe:\n", - " try:\n", - " import pandas as pd\n", - " df = pd.DataFrame(results)\n", - " cols = [\n", - " 'instance_id', 'docker_build_start_ts', 'llm_execution_start_ts', 'end_ts',\n", - " 'docker_build_time', 'llm_execution_time', 'total_time', 'complete_triplet'\n", - " ]\n", - " return df[cols]\n", - " except ImportError:\n", - " pass\n", - " return results\n", - "\n", - "def parse_log_file(path: str, to_dataframe: bool = False):\n", - " with open(path, 'r', encoding='utf-8', errors='replace') as f:\n", - " return parse_log_triplets(f, to_dataframe=to_dataframe)\n" + " # your saved names:\n", + " token_list = logprob_dict[\"tokens\"]\n", + " logprob_list = logprob_dict[\"all_logprobs\"]\n", + "\n", + " turn_stats = turn_logprob(logprob_list, token_list)\n", + " seq_logprobs.append(turn_stats[\"sequence_log_probs\"])\n", + " avg_logprobs.append(turn_stats[\"avergage_logprob_per_token\"])\n", + " seq_probs.append(turn_stats[\"sequence_prob\"])\n", + "\n", + " # guard: if nothing to plot\n", + " if not seq_logprobs:\n", + " print(\"No logprob data found in trajectory.\")\n", + " return\n", + "\n", + " fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "\n", + " # 1) sequence_log_probs\n", + " axes[0].hist(seq_logprobs, bins=20)\n", + " axes[0].set_title(\"Sequence log probs\")\n", + " axes[0].set_xlabel(\"log P(sequence)\")\n", + " axes[0].set_ylabel(\"count\")\n", + "\n", + " # 2) average_logprob_per_token\n", + " axes[1].hist(avg_logprobs, bins=20)\n", + " axes[1].set_title(\"Avg log prob per token\")\n", + " axes[1].set_xlabel(\"avg log p\")\n", + " axes[1].set_ylabel(\"count\")\n", + "\n", + " # 3) sequence_prob\n", + " axes[2].hist(seq_probs, bins=20)\n", + " axes[2].set_title(\"Sequence prob\")\n", + " axes[2].set_xlabel(\"P(sequence)\")\n", + " axes[2].set_ylabel(\"count\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def get_trajectory_from_instance_id(instance_id, base_dir, run_name):\n", + " trajectory_file = os.path.join(\n", + " base_dir,\n", + " run_name,\n", + " \"llm_completions\",\n", + " instance_id,\n", + " f\"{instance_id}_trajectory.json\"\n", + " )\n", + "\n", + " with open(trajectory_file, \"r\") as f:\n", + " trajectory = json.load(f)\n", + " return trajectory\n", + "\n", + "\n", + "def turn_to_turn_logprob_dynamics(logprob_infos):\n", + " # logprob_infos: list of dicts from your trajectory_logprob_stats\n", + " seq_logprobs = [d[\"sequence_log_probs\"] for d in logprob_infos]\n", + " deltas = [seq_logprobs[i] - seq_logprobs[i-1] for i in range(1, len(seq_logprobs))]\n", + " return seq_logprobs, deltas\n", + "\n", + "\n", + "def plot_turn_dynamics(logprob_infos, status, instance_id):\n", + " seq_logprobs, deltas = turn_to_turn_logprob_dynamics(logprob_infos)\n", + "\n", + " plt.figure(figsize=(8, 4))\n", + " plt.plot(range(len(seq_logprobs)), seq_logprobs, marker='o', label='Sequence logprob')\n", + " plt.plot(range(1, len(seq_logprobs)), deltas, marker='x', linestyle='--', label='ฮ” logprob (turn-to-turn)')\n", + " plt.xlabel(\"Turn index\")\n", + " plt.ylabel(\"logprob\")\n", + " plt.title(f\"{instance_id} Turn-to-turn logprob dynamics: {status}\")\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not found for instance pydicom__pydicom-1255\n" + ] + } + ], "source": [ - "docker_local_log_file = '/workspaces/OpenHands/qwen-coder-30b-small_maxiter_100_N_local_docker_test_10_samples.log'\n", - "docker_remote_log_file = '/workspaces/OpenHands/qwen-coder-30b-small_maxiter_100_N_remote_docker_test_10_samples.log'" + "# Find partially resolved instances\n", + "\n", + "eval_log_folder = \"/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent/qwen-coder-30b-small_maxiter_100_N_176_baseline_logprobs/final_eval/logs/run_evaluation/llm.qwen_coder_30b_small/qwen-coder-30b-small_maxiter_100_N_176_baseline_logprobs_2\"\n", + "\n", + "fully_resolved = []\n", + "partial_resolve_no_degrad = []\n", + "partial_resolve_degrad = []\n", + "fully_fail = []\n", + "\n", + "for instance_id in all_instance_ids:\n", + " report_json = os.path.join(\n", + " eval_log_folder,\n", + " instance_id,\n", + " \"report.json\"\n", + " )\n", + " try:\n", + " with open(report_json, \"r\") as f:\n", + " report = json.load(f)[instance_id]\n", + " except:\n", + " print(\"Not found for instance\", instance_id)\n", + " continue\n", + "\n", + " test_status = report[\"tests_status\"]\n", + "\n", + " # Case 1: fully resolve\n", + " if report[\"resolved\"]:\n", + " fully_resolved.append(instance_id)\n", + " continue\n", + " # Case 2: partially resolve and no degradation\n", + " if len(test_status[\"FAIL_TO_PASS\"][\"success\"]) > 0 and \\\n", + " len(test_status[\"FAIL_TO_PASS\"][\"failure\"]) > 0 and \\\n", + " len(test_status[\"PASS_TO_PASS\"][\"failure\"]) == 0:\n", + " partial_resolve_no_degrad.append(instance_id)\n", + " continue\n", + " # Case 3: partially resolve but degradation\n", + " if len(test_status[\"FAIL_TO_PASS\"][\"success\"]) > 0 and \\\n", + " len(test_status[\"PASS_TO_PASS\"][\"failure\"]) > 0:\n", + " partial_resolve_degrad.append(instance_id)\n", + " continue\n", + " # Case 4: completely fail\n", + " if len(test_status[\"FAIL_TO_PASS\"][\"success\"]) == 0:\n", + " fully_fail.append(instance_id)\n", + " continue\n" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
instance_iddocker_build_start_tsllm_execution_start_tsend_tsdocker_build_timellm_execution_timetotal_timecomplete_triplet
0pyvista__pyvista-4321970-01-01 02:13:421970-01-01 02:14:291970-01-01 02:17:5047.0201.0248.0True
1sqlfluff__sqlfluff-8911970-01-01 02:18:001970-01-01 02:22:401970-01-01 02:26:37280.0237.0517.0True
2pvlib__pvlib-python-16661970-01-01 02:27:001970-01-01 02:31:111970-01-01 02:34:12251.0181.0432.0True
3sqlfluff__sqlfluff-8801970-01-01 02:34:211970-01-01 02:38:351970-01-01 02:41:38254.0183.0437.0True
4pylint-dev__astroid-20151970-01-01 02:41:491970-01-01 02:46:201970-01-01 03:07:55271.01295.01566.0True
5marshmallow-code__marshmallow-21231970-01-01 03:08:081970-01-01 03:12:311970-01-01 03:15:46263.0195.0458.0True
6pyvista__pyvista-36751970-01-01 03:16:441970-01-01 03:22:161970-01-01 03:25:30332.0194.0526.0True
7pvlib__pvlib-python-11761970-01-01 03:25:551970-01-01 03:30:351970-01-01 03:34:41280.0246.0526.0True
8pvlib__pvlib-python-16231970-01-01 03:35:021970-01-01 03:40:041970-01-01 03:42:32302.0148.0450.0True
9pvlib__pvlib-python-14781970-01-01 03:42:551970-01-01 03:47:281970-01-01 03:52:17273.0289.0562.0True
\n", - "
" - ], "text/plain": [ - " instance_id docker_build_start_ts \\\n", - "0 pyvista__pyvista-432 1970-01-01 02:13:42 \n", - "1 sqlfluff__sqlfluff-891 1970-01-01 02:18:00 \n", - "2 pvlib__pvlib-python-1666 1970-01-01 02:27:00 \n", - "3 sqlfluff__sqlfluff-880 1970-01-01 02:34:21 \n", - "4 pylint-dev__astroid-2015 1970-01-01 02:41:49 \n", - "5 marshmallow-code__marshmallow-2123 1970-01-01 03:08:08 \n", - "6 pyvista__pyvista-3675 1970-01-01 03:16:44 \n", - "7 pvlib__pvlib-python-1176 1970-01-01 03:25:55 \n", - "8 pvlib__pvlib-python-1623 1970-01-01 03:35:02 \n", - "9 pvlib__pvlib-python-1478 1970-01-01 03:42:55 \n", - "\n", - " llm_execution_start_ts end_ts docker_build_time \\\n", - "0 1970-01-01 02:14:29 1970-01-01 02:17:50 47.0 \n", - "1 1970-01-01 02:22:40 1970-01-01 02:26:37 280.0 \n", - "2 1970-01-01 02:31:11 1970-01-01 02:34:12 251.0 \n", - "3 1970-01-01 02:38:35 1970-01-01 02:41:38 254.0 \n", - "4 1970-01-01 02:46:20 1970-01-01 03:07:55 271.0 \n", - "5 1970-01-01 03:12:31 1970-01-01 03:15:46 263.0 \n", - "6 1970-01-01 03:22:16 1970-01-01 03:25:30 332.0 \n", - "7 1970-01-01 03:30:35 1970-01-01 03:34:41 280.0 \n", - "8 1970-01-01 03:40:04 1970-01-01 03:42:32 302.0 \n", - "9 1970-01-01 03:47:28 1970-01-01 03:52:17 273.0 \n", - "\n", - " llm_execution_time total_time complete_triplet \n", - "0 201.0 248.0 True \n", - "1 237.0 517.0 True \n", - "2 181.0 432.0 True \n", - "3 183.0 437.0 True \n", - "4 1295.0 1566.0 True \n", - "5 195.0 458.0 True \n", - "6 194.0 526.0 True \n", - "7 246.0 526.0 True \n", - "8 148.0 450.0 True \n", - "9 289.0 562.0 True " + "['pvlib__pvlib-python-1349',\n", + " 'marshmallow-code__marshmallow-1252',\n", + " 'pydicom__pydicom-938',\n", + " 'pylint-dev__astroid-1903',\n", + " 'pvlib__pvlib-python-1606',\n", + " 'pylint-dev__astroid-1719',\n", + " 'pydicom__pydicom-1228',\n", + " 'pylint-dev__astroid-1616',\n", + " 'sqlfluff__sqlfluff-880',\n", + " 'pydicom__pydicom-800',\n", + " 'marshmallow-code__marshmallow-1810',\n", + " 'pydicom__pydicom-1192',\n", + " 'pydicom__pydicom-1694',\n", + " 'pydicom__pydicom-1256',\n", + " 'marshmallow-code__marshmallow-1164',\n", + " 'pylint-dev__astroid-1614',\n", + " 'pvlib__pvlib-python-1738',\n", + " 'sqlfluff__sqlfluff-2419',\n", + " 'marshmallow-code__marshmallow-1343']" ] }, - "execution_count": 38, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "local_df = parse_log_file(docker_local_log_file, to_dataframe=True)\n", - "local_df.head(20)" + "fully_resolved" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 63, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
instance_iddocker_build_start_tsllm_execution_start_tsend_tsdocker_build_timellm_execution_timetotal_timecomplete_triplet
0pyvista__pyvista-4321970-01-01 03:11:311970-01-01 03:15:511970-01-01 03:19:11260.0200.0460.0True
1sqlfluff__sqlfluff-8911970-01-01 03:19:151970-01-01 03:23:461970-01-01 03:28:44271.0298.0569.0True
2pvlib__pvlib-python-16661970-01-01 03:28:511970-01-01 03:33:161970-01-01 03:36:19265.0183.0448.0True
3sqlfluff__sqlfluff-8801970-01-01 03:36:211970-01-01 03:40:251970-01-01 03:43:46244.0201.0445.0True
4pylint-dev__astroid-20151970-01-01 03:43:521970-01-01 03:48:141970-01-01 03:57:06262.0532.0794.0True
5marshmallow-code__marshmallow-21231970-01-01 04:00:461970-01-01 04:01:181970-01-01 04:04:1632.0178.0210.0True
6pyvista__pyvista-36751970-01-01 04:04:201970-01-01 04:07:381970-01-01 04:10:58198.0200.0398.0True
7pvlib__pvlib-python-11761970-01-01 04:11:011970-01-01 04:14:061970-01-01 04:18:02185.0236.0421.0True
8pvlib__pvlib-python-16231970-01-01 04:18:031970-01-01 04:21:021970-01-01 04:23:38179.0156.0335.0True
9pvlib__pvlib-python-14781970-01-01 04:23:411970-01-01 04:28:031970-01-01 04:32:43262.0280.0542.0True
\n", - "
" - ], + "image/png": "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", "text/plain": [ - " instance_id docker_build_start_ts \\\n", - "0 pyvista__pyvista-432 1970-01-01 03:11:31 \n", - "1 sqlfluff__sqlfluff-891 1970-01-01 03:19:15 \n", - "2 pvlib__pvlib-python-1666 1970-01-01 03:28:51 \n", - "3 sqlfluff__sqlfluff-880 1970-01-01 03:36:21 \n", - "4 pylint-dev__astroid-2015 1970-01-01 03:43:52 \n", - "5 marshmallow-code__marshmallow-2123 1970-01-01 04:00:46 \n", - "6 pyvista__pyvista-3675 1970-01-01 04:04:20 \n", - "7 pvlib__pvlib-python-1176 1970-01-01 04:11:01 \n", - "8 pvlib__pvlib-python-1623 1970-01-01 04:18:03 \n", - "9 pvlib__pvlib-python-1478 1970-01-01 04:23:41 \n", - "\n", - " llm_execution_start_ts end_ts docker_build_time \\\n", - "0 1970-01-01 03:15:51 1970-01-01 03:19:11 260.0 \n", - "1 1970-01-01 03:23:46 1970-01-01 03:28:44 271.0 \n", - "2 1970-01-01 03:33:16 1970-01-01 03:36:19 265.0 \n", - "3 1970-01-01 03:40:25 1970-01-01 03:43:46 244.0 \n", - "4 1970-01-01 03:48:14 1970-01-01 03:57:06 262.0 \n", - "5 1970-01-01 04:01:18 1970-01-01 04:04:16 32.0 \n", - "6 1970-01-01 04:07:38 1970-01-01 04:10:58 198.0 \n", - "7 1970-01-01 04:14:06 1970-01-01 04:18:02 185.0 \n", - "8 1970-01-01 04:21:02 1970-01-01 04:23:38 179.0 \n", - "9 1970-01-01 04:28:03 1970-01-01 04:32:43 262.0 \n", - "\n", - " llm_execution_time total_time complete_triplet \n", - "0 200.0 460.0 True \n", - "1 298.0 569.0 True \n", - "2 183.0 448.0 True \n", - "3 201.0 445.0 True \n", - "4 532.0 794.0 True \n", - "5 178.0 210.0 True \n", - "6 200.0 398.0 True \n", - "7 236.0 421.0 True \n", - "8 156.0 335.0 True \n", - "9 280.0 542.0 True " + "
" ] }, - "execution_count": 39, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsMAAAGJCAYAAABvpz7VAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4FNXXgN/dzaYXWiAJvTfpEDqhV2mCgqIUEStFEbCgUgRBBEUBQb+fdBAFEQsondB770U6gdCSENK2zPfHZGZrkk0jhfs+zz67c2fmzrl37sycPXPuORpJkiQEAoFAIBAIBIKnEG1OCyAQCAQCgUAgEOQUQhkWCAQCgUAgEDy1CGVYIBAIBAKBQPDUIpRhgUAgEAgEAsFTi1CGBQKBQCAQCARPLUIZFggEAoFAIBA8tQhlWCAQCAQCgUDw1CKUYYFAIBAIBALBU4tQhgUCgUAgEAgETy1CGRa4hEajYfz48erywoUL0Wg0XLlyRS0rU6YMzz777JMXLgu4cuUKGo2GhQsXqmXjx49Ho9HYbKfRaBg6dOgTli5jtGzZkmeeeSanxRAInggtW7akZcuWOS1GlqHcf+7du5el9eanfnL2HBIIMoJQhgWCPMytW7cYP348R48ezWlRXOLcuXO89957NGnSBE9PzxQfZNu2bUOj0aT4mTx5srrt9u3b6datGyVLlsTT05OgoCA6duzIrl27HOo1m83MmzeP2rVr4+vrS7FixejUqRO7d+9OVe6WLVumKo/ysf7DmFN88cUXrFmzJsvrzWtjTSAQCFzFLacFEORNXnnlFfr27YuHh0dOi5JtfPLJJ3z44Yc5LUaq3Lp1iwkTJlCmTBlq166d0+KkyZ49e/juu++oVq0aVatWTVGxqlq1KkuWLHEoX7JkCRs2bKB9+/Zq2fnz59Fqtbz55psEBQXx8OFDli5dSosWLVi7di0dO3ZUtx09ejRff/01L7/8Mm+//TZRUVH88MMPhIWFsWvXLkJDQ53KM3bsWF577TV1+cCBA3z33Xd8/PHHVK1aVS2vWbNmersky/niiy/o3bs3PXr0yNJ689pYE+R/nobnkODJIJRhQYbQ6XTodLqcFiNbcXNzw81NXCJZSbdu3YiKisLPz4/p06enqAwXK1aMl19+2aF8woQJVKxYkQYNGqhlr732mo2iCvD2229Trlw5Zs6cqSrDRqORuXPn0rt3bxtF+/nnn6dcuXIsW7YsRWW4Xbt2Nsuenp589913tGvXLkteOZvNZpKSkvD09Mx0XXmNhIQE3N3d0Wrz94tKo9GI2WzG3d09p0XJNzwNzyHBkyF/332eUhRfs7Nnz/LCCy/g7+9P4cKFGTFiBAkJCep2zzzzDK1atXLY32w2U7x4cXr37p3iMVLz1dqwYQO1a9fG09OTatWqsXr16ixplzUDBw7E19eX//77jw4dOuDj40NISAgTJ05EkiQADAYDhQoVYtCgQQ77x8TE4OnpyahRo1I8hjOfYYVly5ZRuXJlPD09qVevHtu3b88yuSVJokyZMnTv3t1h/4SEBAICAnjjjTfYtm2bqhQOGjRIfVVv7fcMcPr0aVq1aoW3tzfFixdn2rRpDvVGRkYyePBgihUrhqenJ7Vq1WLRokU22yh+1dOnT+fHH3+kfPnyeHh40KBBAw4cOOBS+wsVKoSfn59L29qzf/9+Ll68SL9+/dLc1tvbm8DAQKKiotQyg8FAfHw8xYoVs9m2aNGiaLVavLy8MiSXwsCBAylTpoxDeWq+58uWLaN69ep4eHjw77//qtfVrl27GDlyJIGBgfj4+NCzZ0/u3r2bpgwajYbHjx+zaNEidTwMHDhQXX/kyBE6deqEv78/vr6+tGnThr1796ZZb1pjrUyZMjbHUbD3T1XcX1asWMEnn3xC8eLF8fb2JiYmRr02bt68SY8ePfD19SUwMJBRo0ZhMpnSlNEZroxrgPv37/PKK6/g7+9PgQIFGDBgAMeOHXO4nly5fsH2Wpk5c6Z6rZw+fRqALVu20Lx5c3x8fChQoADdu3fnzJkzTttw7969VO/jqaFcp15eXoSGhrJjxw6b9bGxsfj4+DBixAiHfW/cuIFOp2PKlCkA6Rqbf/zxB126dCEkJAQPDw/Kly/P559/7nAelXkNx48fJywsDG9vbypUqMCqVasACA8Pp2HDhnh5eVG5cmU2bdpks39Kz6F//vmHsLAw/Pz88Pf3p0GDBixfvlxdf+HCBXr16kVQUBCenp6UKFGCvn37Eh0dbdPvZ8+eJS4uLs1+3rhxI82aNaNAgQL4+vpSuXJlPv744zTlVK6Hbdu22ZTv27ePzp07U7BgQXx8fKhZsybffvutzTbK8z0wMFDtn7Fjx9psc/PmTV599VWKFSuGh4cH1atXZ/78+Q7yz5o1i+rVq+Pt7U3BggWpX7++TX89evSId999lzJlyuDh4UHRokVp164dhw8fTrNv8gpCGc7HvPDCCyQkJDBlyhQ6d+7Md999x+uvv66u79OnD9u3b+f27ds2++3cuZNbt27Rt2/fdB/zwoUL9OnTh06dOjFlyhTc3Nx4/vnn2bhxY6bbY4/JZKJjx44UK1aMadOmUa9ePcaNG8e4ceMA0Ov19OzZkzVr1pCUlGSz75o1a0hMTMxQG8PDw3n33Xd5+eWXmThxIvfv36djx46cPHkyS+TWaDS8/PLL/PPPPzx48MBm37/++ouYmBhefvllqlatysSJEwF4/fXXWbJkCUuWLKFFixbq9g8fPqRjx47UqlWLGTNmUKVKFT744AP++ecfdZv4+HhatmzJkiVL6NevH1999RUBAQEMHDjQ4QYMsHz5cr766iveeOMNJk2axJUrV3juuecwGAzp7sv0sGzZMoAUleGYmBj1Afbxxx9z8uRJ2rRpo6738vKiYcOGLFy4kGXLlnHt2jWOHz/OwIEDKViwoM218STYsmUL7733Hn369OHbb7+1UaSHDRvGsWPHGDduHG+99RZ//fWXSxM3lyxZgoeHB82bN1fHwxtvvAHAqVOnaN68OceOHWPMmDF8+umnXL58mZYtW7Jv375U63VlrKWHzz//nLVr1zJq1Ci++OIL1VpqMpno0KEDhQsXZvr06YSFhTFjxgx+/PHHdB/D1XFtNpvp2rUrP//8MwMGDGDy5MlEREQwYMAAp/Wmdf1as2DBAmbNmsXrr7/OjBkzKFSoEJs2baJDhw5ERkYyfvx4Ro4cye7du2natKlT40Ja9/GU+Omnn3jjjTcICgpi2rRpNG3alG7dunH9+nV1G19fX3r27Mkvv/zioKj+/PPPSJLkcL25MjYXLlyIr68vI0eO5Ntvv6VevXp89tlnTt3OHj58yLPPPkvDhg2ZNm0aHh4e9O3bl19++YW+ffvSuXNnpk6dyuPHj+nduzePHj1Ktd0LFy6kS5cuPHjwgI8++oipU6dSu3Zt/v33XwCSkpLo0KEDe/fuZdiwYcyZM4fXX3+d//77z+bP8+zZs6latSr79+9P9XinTp3i2WefJTExkYkTJzJjxgy6devmdM6CK2zcuJEWLVpw+vRpRowYwYwZM2jVqhV///23us3x48dp2LAhW7ZsYciQIXz77bf06NGDv/76S93mzp07NGrUiE2bNjF06FC+/fZbKlSowODBg5k5c6a63f/93/8xfPhwqlWrxsyZM5kwYQK1a9e2uSe8+eabzJ07l169evH9998zatQovLy8UvwDlyeRBPmOcePGSYDUrVs3m/K3335bAqRjx45JkiRJ586dkwBp1qxZDtv5+vpKcXFxahkgjRs3Tl1esGCBBEiXL19Wy0qXLi0B0m+//aaWRUdHS8HBwVKdOnWysIWSNGDAAAmQhg0bppaZzWapS5cukru7u3T37l1JkiRp/fr1EiD99ddfNvt37txZKleunLp8+fJlCZAWLFiglin9aA0gAdLBgwfVsqtXr0qenp5Sz549s0xu5dzMnTvXZv9u3bpJZcqUkcxmsyRJknTgwAEHuRXCwsIkQFq8eLFalpiYKAUFBUm9evVSy2bOnCkB0tKlS9WypKQkqXHjxpKvr68UExNj00eFCxeWHjx4oG77xx9/OO3jtPjqq68cxlBKGI1GqVixYlJoaGiK23To0EE9P+7u7tIbb7whxcfH22xz4cIFqW7duup2gFSuXDnp7Nmz6ZJ95cqVEiBt3bpVLRswYIBUunRph21TGkdarVY6deqUTblyXbVt21Y9x5IkSe+9956k0+mkqKioNGXz8fGRBgwY4FDeo0cPyd3dXbp06ZJaduvWLcnPz09q0aJFmvWmNtZKly7t9JhhYWFSWFiYurx161a1z63vL5JkuTYmTpxoU16nTh2pXr16acpnfyxXx/Vvv/0mAdLMmTPV7Uwmk9S6dWuH9rp6/SrXir+/vxQZGWkjZ+3ataWiRYtK9+/fV8uOHTsmabVaqX///mqZq/dxZyQlJUlFixaVateuLSUmJqrlP/74owTY9JNyj/znn39s6qhZs6bNdukZm/bnVpIk6Y033pC8vb2lhIQEtUy5Ry1fvlwtO3v2rHp97N2710FO6/Nh/xyKioqS/Pz8pIYNGzpc+4rMR44ckQBp5cqVzrpORel/62vcGd98840EqOfeGc6el5JkuR6UYxiNRqls2bJS6dKlpYcPHzqVX5IkqUWLFpKfn5909erVFLcZPHiwFBwcLN27d89mm759+0oBAQHqOerevbtUvXr1VNsYEBAgvfPOO6luk9cRluF8zDvvvGOzPGzYMADWrVsHQKVKlahduza//PKLuo3JZGLVqlV07do1Q6+NQ0JC6Nmzp7rs7+9P//79OXLkiIMFOiuwtkgor56TkpLU12mtW7emSJEiNm18+PAhGzdupE+fPhk6ZuPGjalXr566XKpUKbp378769etdfp2bltyVKlWiYcOGqjUU4MGDB/zzzz/069cvRfcNe3x9fW18b93d3QkNDeW///5Ty9atW0dQUBAvvviiWqbX6xk+fDixsbGEh4fb1NmnTx8KFiyoLjdv3hzAps6sZvPmzdy5cydVF4mpU6eyYcMGfvrpJxo1akRSUhJGo9FmGz8/P6pXr84777zD6tWr+f777zEajfTo0SPLQ1ilRVhYGNWqVXO67vXXX7c5x82bN8dkMnH16tUMHctkMrFhwwZ69OhBuXLl1PLg4GBeeukldu7cSUxMTIbqzggDBgxI8f7y5ptv2iw3b948Q2PL1XH977//otfrGTJkiLqdVqt1uH9ak9b1q9CrVy8CAwPV5YiICI4ePcrAgQMpVKiQWl6zZk3atWun3putSes+7oyDBw8SGRnJm2++aeOjPHDgQAICAmy2bdu2LSEhITb3mpMnT3L8+HGnfvuujE3rc/vo0SPu3btH8+bNiYuL4+zZszb1+fr62ryhq1y5MgUKFKBq1ao0bNhQLVd+pzYWNm7cyKNHj/jwww8d/O8VmZX2r1+/PlUXiPHjxyNJUppzAgoUKADIriFmsznVbdPiyJEjXL58mXfffVetV0GR/+7du2zfvp1XX32VUqVKOd1GkiR+++03unbtiiRJ3Lt3T/106NCB6Oho1cWhQIEC3LhxI1VXtwIFCrBv3z5u3bqVqfblZoQynI+pWLGizXL58uXRarU2r+L69OnDrl27uHnzJiD7MEVGRmZYUaxQoYKDolapUiWALI8FqdVqbR7szo7l5uZGr169+OOPP0hMTARg9erVGAyGDLfRvl+V48bFxXH37l2SkpK4ffu2zcdaSXZFboD+/fuza9cu9SGzcuVKDAYDr7zyisuylihRwuF8FCxYkIcPH6rLV69epWLFig4TmJQoCfYKmP0NWFGMlTrj4+Md2p9Zli1bhk6nS/Wc1a5dm3bt2vHqq6+yceNG9u/fb+PHajQaadu2LQEBAcyePZuePXvy1ltvsWnTJi5dusRXX32VaTnTQ9myZVNcl1YfR0dH2/SvvTuNPXfv3iUuLo7KlSs7rKtatSpms1l9fX737l2bumNjY9PVLldIqe2enp42yiM4jldXcXVcX716leDgYLy9vW22q1ChgtN6Xb1+wbGdyjFTOg/37t3j8ePHNuWu3MftUY5jv69er3eQXavV0q9fP9asWaMqh8uWLcPT05Pnn3/eoe60xibIrgM9e/YkICAAf39/AgMDVcXa2i8XnN+jAgICKFmypEOZ/XHsuXTpEkCq8dXLli3LyJEj+d///keRIkXo0KEDc+bMcZDLVfr06UPTpk157bXXKFasGH379uXXX3/NkGLsivzKn4HUtrl79y5RUVH8+OOPBAYG2nyUOTSRkZEAfPDBB/j6+hIaGkrFihV55513HFw8pk2bxsmTJylZsiShoaGMHz8+W40fOYFQhp8inFkT+/TpgyRJrFy5EoBff/2VgIAAm3BUeZ2+ffvy6NEj1U/2119/pUqVKtSqVStbjrd7926Cg4NtPtZ+eq7St29f9Hq9arFZunQp9evXd/ogTYmUZlpLVpN90ktadf7yyy8O7c8M8fHx/P7777Rt29Zh8ltKuLu7061bN1avXk18fDwgxyM+efIk3bp1s9m2YsWKVK1aNcM+fgopWetTeluQ2puXtPp4xIgRNv373HPPpVPalGnQoIFN3dOnT09zn6xqe36LDJDZSZnOcPWtUHro378/sbGxrFmzBkmSWL58Oc8++6yDFRnSHptRUVGEhYVx7NgxJk6cyF9//cXGjRv58ssvARyUxJTqy457l8KMGTM4fvw4H3/8MfHx8QwfPpzq1atz48aNdNfl5eXF9u3b2bRpE6+88grHjx+nT58+tGvXTh3/6b0+MovSxy+//DIbN250+mnatCkg/wk7d+4cK1asoFmzZvz22280a9bMxgf+hRde4L///mPWrFmEhITw1VdfUb16dZu5J3kdETcqH3PhwgUby8TFixcxm802E3XKli1LaGgov/zyC0OHDmX16tX06NEjw3EbL168iCRJNhf/+fPnAZzOtM8MZrOZ//77T7XKpHSsFi1aEBwczC+//EKzZs3YsmWLw6zb9HDhwgWHsvPnz6sRDDw8PBwmDAYFBaVb7kKFCtGlSxeWLVtGv3792LVrl83EB8iaB2Pp0qU5fvw4ZrPZxoqmvM4sXbp0uurr0KFDlk6Y/PPPP3n06JFLUSSsiY+PR5IkHj16hJeXF3fu3AGcP4AMBoODS0V6KViwoM0EHIWMujakxpgxY2xeYVu7rTgbE4GBgXh7e3Pu3DmHdWfPnkWr1aqWuGXLlql/IADVkpjaWEut7faWyCeFq+O6dOnSbN26lbi4OBvr8MWLF53W6+r1m5JMQIrnoUiRIvj4+NiUu3IfT+k4Fy5coHXr1mq5wWDg8uXLDoaAZ555hjp16rBs2TJKlCjBtWvXmDVrVqptSYlt27Zx//59Vq9ebTPB8vLlyxmqLz2UL18ekN08UrLsK9SoUYMaNWrwySefqBMY582bx6RJk9J9XK1WS5s2bWjTpg1ff/01X3zxBWPHjmXr1q20bdtWvT7trxH7e4O1/G3btnV6LOV6Sm3CdmBgIH5+fphMphTrscbHx4c+ffrQp08fkpKSeO6555g8eTIfffSR6m4SHBzM22+/zdtvv01kZCR169Zl8uTJdOrUKc368wLCMpyPmTNnjs2ycnOzH7x9+vRh7969zJ8/n3v37mXYfQDkwPy///67uhwTE8PixYupXbu2jUKYVcyePVv9LUkSs2fPRq/X20QR0Gq19O7dm7/++oslS5ZgNBoz1cY9e/bYhJS5fv06f/zxB+3bt0en01GwYEHatm1r87H3X3NFbpCDyp8+fZrRo0ej0+kcol8oD05nioirdO7cmdu3b9v4VRuNRmbNmoWvry9hYWHpqi84ONih/Zlh+fLleHt72/iiW6O87rMmKiqK3377jZIlS1K0aFHA8ip7xYoVNtsePnyYc+fOUadOnUzJWb58eaKjozl+/LhaFhERYXM9ZBXVqlWz6V9rH3YfHx+H8aDT6Wjfvj1//PGHzev1O3fusHz5cpo1a4a/vz8ATZs2talbefimNtbKly/P3r17baK2/P333xl6I5JVuDquO3TogMFg4P/+7//U7cxms8P90xpXr197goODqV27NosWLbLpx5MnT7JhwwY6d+7ssI+r93Fr6tevT2BgIPPmzbM5JwsXLkzxXvHKK6+wYcMGZs6cSeHChTOs5CgWXWsLblJSEt9//32G6ksP7du3x8/PjylTpjiEn1PkiYmJcfjjW6NGDbRarepKB66HVnPmoqQkpVHqU5Rc6xCcJpPJIUpK3bp1KVu2LDNnznQ4T4r8gYGBtGjRgvnz53Pt2jWn2+h0Onr16sVvv/3mVGm2DoV3//59m3Xu7u5Uq1YNSZIwGAyYTCYHF5KiRYsSEhJi0195HWEZzsdcvnyZbt260bFjR/bs2cPSpUt56aWXHKwCL7zwAqNGjWLUqFEUKlQoU8pLpUqVGDx4MAcOHKBYsWLMnz+fO3fusGDBgsw2xwFPT0/+/fdfBgwYQMOGDfnnn39Yu3YtH3/8sYPfYZ8+fZg1axbjxo2jRo0aNlnD0sszzzxDhw4dGD58OB4eHupNfsKECVkud5cuXShcuDArV66kU6dOqmKnUL58eQoUKMC8efPw8/PDx8eHhg0bpuqPas/rr7/ODz/8wMCBAzl06BBlypRh1apVqiU6o3GBnREdHa0+zBW3hNmzZ1OgQAEKFCjgEKJJmTTYq1cvfH19ndbZqVMnSpQoQcOGDSlatCjXrl1jwYIF3Lp1y0YRqlevHu3atWPRokXExMTQvn17IiIimDVrFl5eXrz77ruZalvfvn354IMP6NmzJ8OHDycuLo65c+dSqVKlJxqPs169emzatImvv/6akJAQypYtS8OGDZk0aZIaD/Xtt9/Gzc2NH374gcTERKexp+1Jbay99tprrFq1io4dO/LCCy9w6dIlli5dqioBOYGr47pHjx6Ehoby/vvvc/HiRapUqcKff/6pKjn2FvH0XL/O+Oqrr+jUqRONGzdm8ODBxMfHM2vWLAICApym83b1Pm6NXq9n0qRJvPHGG7Ru3Zo+ffpw+fJlFixYkKKl/qWXXmLMmDH8/vvvvPXWW+j1+jTb4owmTZpQsGBBBgwYwPDhw9FoNCxZsiRL3BvSwt/fn2+++YbXXnuNBg0a8NJLL1GwYEGOHTtGXFwcixYtYsuWLQwdOpTnn3+eSpUqYTQaWbJkiapAKsyePZsJEyawdevWVCfRTZw4ke3bt9OlSxdKly5NZGQk33//PSVKlKBZs2YAVK9enUaNGvHRRx/x4MEDChUqxIoVKxyUcq1Wy9y5c+natSu1a9dm0KBBBAcHc/bsWU6dOsX69esB+O6772jWrBl169bl9ddfp2zZsly5coW1a9eqiYymTp3K1q1badiwIUOGDKFatWo8ePCAw4cPs2nTJnV8t2/fnqCgIJo2bUqxYsU4c+YMs2fPpkuXLvj5+REVFUWJEiXo3bs3tWrVwtfXl02bNnHgwAFmzJiRhWcvh3misSsETwQlJMzp06el3r17S35+flLBggWloUOHOoSbUWjatKkESK+99prT9bgYWq1Lly7S+vXrpZo1a0oeHh5SlSpV0gxhkxEGDBgg+fj4SJcuXZLat28veXt7S8WKFZPGjRsnmUwmh+3NZrNUsmRJCZAmTZrksD49odXeeecdaenSpVLFihUlDw8PqU6dOmmG38mo3JJkCaVkHX7Imj/++EOqVq2a5ObmZtOGsLAwpyFznIUAu3PnjjRo0CCpSJEikru7u1SjRg2HEFpKH3311VcOddqPj5RQ6nD2cRaWbN68eRIg/fnnnynWOXv2bKlZs2ZSkSJFJDc3NykwMFDq2rWrtH37dodt4+LipIkTJ0rVqlWTvLy8pICAAOnZZ5+Vjhw5kqbs1jgLrSZJkrRhwwbpmWeekdzd3aXKlStLS5cuTXUc2aNcVwcOHLAptw/BlBpnz56VWrRoIXl5eUmATcizw4cPSx06dJB8fX0lb29vqVWrVtLu3btdbndKY02SJGnGjBlS8eLFJQ8PD6lp06bSwYMHUwyt5uyeoFwb9jjrP2fYH0uSXBvXkiRJd+/elV566SXJz89PCggIkAYOHCjt2rVLAqQVK1Y4yJjW9ZvatSJJkrRp0yapadOmkpeXl+Tv7y917dpVOn36tNN2p+c+bs/3338vlS1bVvLw8JDq168vbd++3Wk/KXTu3FkCnI6J9IzNXbt2SY0aNZK8vLykkJAQacyYMWpoNOvtUrpHKc8Se+yvm5RClv35559SkyZN1P4NDQ2Vfv75Z0mSJOm///6TXn31Val8+fKSp6enVKhQIalVq1bSpk2bbOpwNbTa5s2bpe7du0shISGSu7u7FBISIr344ovS+fPnbba7dOmS1LZtW8nDw0MqVqyY9PHHH0sbN250eoydO3dK7dq1k/z8/CQfHx+pZs2aDiFQT548KfXs2VMqUKCA5OnpKVWuXFn69NNPbba5c+eO9M4770glS5aU9Hq9FBQUJLVp00b68ccf1W1++OEHqUWLFlLhwoUlDw8PqXz58tLo0aOl6OhoSZLkcJyjR4+WatWqpcpTq1Yt6fvvv0+1X/IaGkl6An/XBE+U8ePHM2HCBO7evUuRIkVyWpxsYeDAgaxatSpbZrpnJxmR+7333uOnn37i9u3bDjPeBQJB9rBmzRp69uzJzp071clGefW+4yo9e/bkxIkTKfpLCwT5FeEzLBDkYhISEli6dCm9evUSirBAkE1YTxgE2Z9z1qxZ+Pv7U7du3RyS6skSERHB2rVr0xW6USDILwifYcETJa2Ys15eXg4PJnuyYyJebiMyMpJNmzaxatUq7t+/z4gRI3JaJIEg3zJs2DDi4+Np3LgxiYmJrF69mt27d/PFF19kS3i03MTly5fZtWsX//vf/9Dr9Wr6boHgaUIow4InSloxZwcMGMCiRYtS3eZp8Ow5ffo0/fr1o2jRonz33Xfq7GSBQJD1tG7dmhkzZvD333+TkJBAhQoVmDVrlsOEzvxIeHg4gwYNolSpUixatOipMDYIBPYIn2HBE8U+Xak9ISEhaaZ8zGyoLoFAIBAIBAIFoQwLBAKBQCAQCJ5axAQ6gUAgEAgEAsFTi/AZTidms5lbt27h5+eXLTniBQKBQCAQCASZQ5IkHj16REhIiE1K9pQ2zjOEh4dLzz77rBQcHCwB0u+//26zfsCAAQ6B/Dt06GCzzf37922Cq7/66qvSo0ePXJbh+vXrKSYNEB/xER/xER/xER/xEZ/c87l+/Xqaul2esgw/fvyYWrVq8eqrr/Lcc8853aZjx442qX89PDxs1vfr14+IiAg2btyIwWBg0KBBvP766yxfvtwlGZQUntevX8ff3z+DLXEdg8HAhg0baN++fYbTYz6NiH5LP6LP0o/os/Qj+ixjiH5LP6LP0k9+6rOYmBhKliyp6m2pkaeU4U6dOtGpU6dUt/Hw8EgxNMyZM2f4999/OXDgAPXr1wdg1qxZdO7cmenTpxMSEpKmDIprhL+//xNThr29vfH398/zA/NJIvot/Yg+Sz+iz9KP6LOMIfot/Yg+Sz/5sc9ccWnNU8qwK2zbto2iRYtSsGBBWrduzaRJkyhcuDAAe/bsoUCBAqoiDHKYLq1Wy759++jZs6dDfYmJiSQmJqrLMTExgDxgDAZDNrcG9RhP4lj5CdFv6Uf0WfoRfZZ+RJ9lDNFv6Uf0WfrJT32WnjbkK2W4Y8eOPPfcc5QtW5ZLly7x8ccf06lTJ/bs2YNOp+P27dsULVrUZh83NzcKFSqUYma0KVOmMGHCBIfyDRs2PNH0uBs3bnxix8pPiH5LP6LP0o/os/Qj+ixjiH5LP6LP0k9+6LO4uDiXt81XynDfvn3V3zVq1KBmzZqUL1+ebdu20aZNmwzV+dFHHzFy5Eh1WfFBad++/RNzk9i4cSPt2rXLN68sngSi39KP6LP0I/os/Yg+yxii39KP6LP0k5/6THmT7wr5Shm2p1y5chQpUoSLFy/Spk0bgoKCiIyMtNnGaDTy4MGDFP2MPTw8HCbhAej1+hQHiiRJGI1GTCZTpttgMplwc3PDZDKlHRpEoCL6Lf3kxj7T6/XodLqcFiNNUrsfCJwj+ixjiH5LP6LP0k9+6LP0yJ+vleEbN25w//59goODAWjcuDFRUVEcOnSIevXqAbBlyxbMZjMNGzbMkmMmJSURERGRLvN8akiSRFBQENevXxdxjdOB6Lf0kxv7TKPRUKJECXx9fXNaFIFAIBDkU/KUMhwbG8vFixfV5cuXL3P06FEKFSpEoUKFmDBhAr169SIoKIhLly4xZswYKlSoQIcOHQCoWrUqHTt2ZMiQIcybNw+DwcDQoUPp27evS5Ek0sJsNnP58mV0Oh0hISG4u7tnWqkwm83Exsbi6+uba6x1eQHRb+knt/WZJEncvXuXGzduULFixTxhIRYIBAJB3iNPKcMHDx6kVatW6rLiyztgwADmzp3L8ePHWbRoEVFRUYSEhNC+fXs+//xzGzeHZcuWMXToUNq0aYNWq6VXr1589913WSJfUlISZrOZkiVLZtnkOrPZTFJSEp6enrlCQckriH5LP7mxzwIDA7ly5QoGg0EowwKBQCDIFvKUMtyyZUskSUpx/fr169Oso1ChQi4n2MgouUWREAjyOrnFXUPgAlungFYHYWMc14VPA7MJWn305OUSCASCNBBam0AgEAgyj1YHWyfLiq814dPkcq2w7AsEgtxJnrIMCwQCgSCXoliEt06G6JvQeRrs+lZebjXWucVYIBAIcgHCMpxLMZkl9ly6z5/HbnHgajQmc8ruIYLs58qVK2g0Go4ePZrToriMRqNhzZo1OS2G4GkibAyUawmHF8LkIKEICwSCPIGwDOdC/j0ZwYS/ThMRnaCWBflfZHy3anR8Jjhbjnn37l0+++wz1q5dy507dyhYsCC1atXis88+o2nTptlyTIFAkA+5dVT+lsygcxeKsEAgyPUIy3Au49+TEby19LCNIgxwJyaBt5Ye5t+TEdly3F69enHkyBEWLVrE+fPn+fPPP2nZsiX379/PluMJMk5+yBkvyMe4eVp+m5IcfYgFAoEglyGU4WxGkiTikowufR4lGBj35ymcOUQoZeP/PM2jBINL9aUWecOaqKgoduzYwZdffkmrVq0oXbo0oaGhfPTRR3Tr1s1mu9dee43AwED8/f1p3bo1x44ds6lr6tSpFCtWDD8/PwYPHsyHH35I7dq11fUtW7bk3XfftdmnR48eDBw4UF1OTExk1KhRFC9eHB8fHxo2bMi2bdvU9QsXLqRAgQKsX7+eqlWr4uvrS8eOHYmIsP2jsHTpUmrUqIGHhwfBwcEMHTo0XW1Ji/DwcEJDQ9X6P/zwQ4xGo7r+0aNH9OvXDx8fH4KDg/nmm28c2l+mTBk+//xzXnzxRXx8fChevDhz5syxOY5Go2Hu3Ll069YNHx8fJk+eDMDcuXMpX7487u7uVK5cmSVLljjIGBERQadOnfDy8qJcuXKsWrUqXW0UCNJF+DSIvS3/bjJMdpFwNqlOIBAIchHCTSKbiTeYqPZZ2iHfXEECbsckUGP8Bpe2Pz2xA97uaZ9iX19ffH19WbNmDY0aNXKafhrg+eefx8vLi3/++YeAgAB++OEH2rRpw/nz5ylUqBC//vor48ePZ86cOTRr1owlS5bw3XffUa5cufQ0k6FDh3L69GlWrFhBSEgIv//+Ox07duTEiRNUrFgRgLi4OKZPn86SJUvQarW8/PLLjBo1imXLlgGyojh69GimTJlC586diY6OZteuXS63JS1u3rxJ586dGThwIIsXL+bs2bMMGTIET09Pxo8fD8hxsHft2sWff/5JsWLF+Oyzzzh8+LDNnwOAr776io8//pgJEyawfv16RowYQaVKlWjXrp26zfjx45k6dSozZ87Ezc2N33//nREjRjBz5kzatm3L33//zaBBgyhRooRNLO5PP/2UqVOn8u2337JkyRL69u3LiRMnqFq1arrOiUCQJkrUiOL14eZB0HnYTqoD4TIhEAhyJUIZFuDm5sbChQvVzHx169YlLCyMvn37UrNmTQB27tzJ/v37iYyMVJXl6dOns2bNGlatWsXrr7/OzJkzGTx4MIMHDwZg0qRJbNq0iYSEhBSPbc+1a9dYsGAB165dU7MCjho1in///ZcFCxbwxRdfALKrwLx58yhfvjwgK9ATJ05U6/niiy945513GD58uBr3uUGDBi63JS2+//57SpYsyezZs9FoNFSpUoVbt27xwQcf8Nlnn/H48WMWLVrE8uXLadOmDQALFixwmumwadOmfPjhhwBUqlSJXbt28c0339gowy+99BKDBg1Sl1988UUGDhzI22+/DciK9969e5k+fbqNMvz888/z2muvAfD555+zceNGZs2axffff59mGwWCdGE2yZbgmJuyMqzEiFYUYLMp52QTCASCVBDKcDbjpddxemIHl7bdf/kBAxccSHO7hYMaEFo2beull971uJ69evWiS5cu7Nixg7179/LPP/8wbdo0/ve//zFw4ECOHTtGbGwshQsXttkvPj6eS5cuAXDmzBnefPNNm/WNGzdm69atLstx4sQJTCYTlSpVsilPTEy0Oba3t7eqCAMEBwcTGRkJQGRkJLdu3SIsLMzpMVxpS1qcOXOGxo0b2ySFaNq0KbGxsdy4cYOHDx9iMBgIDQ1V1wcEBFC5cmWHuho3buywPHPmTJuy+vXrOxzfXmlv2rQp3377bZp156WIGII8hJJQ46935e/tX0HrT+TfwiIsEAhyMUIZzmY0Go1LrgoAzSsGEhzgye3oBKd+wxogKMCT5hUD0WmzPjOXp6cn7dq1o127dnz66ae89tprjBs3joEDBxIbG0twcLCN765CgQIFXD6GVqt18GW2nhAWGxuLTqfj0KFDDul3fX191d96vd5mnUajUev18vJKVYasasuTxMfHJ6dFEAhco+qzcGgBFKuR05IIBAKBS4gJdLkInVbDuK7VAFnxtUZZHte1WrYows6oVq0ajx8/BqBu3brcvn0bNzc3KlSoYPMpUqQIAFWrVmXfvn02dezdu9dmOTAw0Gaim8lk4uTJk+pynTp1MJlMREZGOhwnKCjIJbn9/PwoU6YM4eHhTte70pa0qFq1Knv27LFR7Hft2oWfnx8lSpSgXLly6PV6DhywWPqjo6M5f/68Q132fbR37940fXqrVq1q4wOtHL9atWqZrlsgyBS65DkHpsSclUMgEAhcRCjDuYyOzwQz9+W6BAV42pQHBXgy9+W62RJn+P79+7Ru3ZqlS5dy/PhxLl++zMqVK5k2bRrdu3cHoG3btjRu3JgePXqwYcMGrly5wu7duxk7diwHDx4EYMSIEcyfP58FCxZw/vx5xo0bx6lTp2yO1bp1a9auXcvatWs5e/Ysb731FlFRUer6SpUq0a9fP/r378/q1au5fPky+/fvZ8qUKaxdu9blNn322WfMmTOHWbNmceHCBQ4fPsysWbNcbktavP3221y/fp1hw4Zx9uxZ/vjjD8aNG8fIkSPRarX4+fkxYMAARo8ezdatWzl16hSDBw9Gq9XauFaArMROmzaN8+fPM2fOHFauXMmIESNSPf7o0aNZuHAhc+fO5cKFC3z99desXr2aUaNG2Wy3cuVK5s+fr56P/fv320TVEAiynJhb8vfjezkrh0AgELiIcJPIhXR8Jph21YLYf/kBd2Li8dGaaFm9BHo3132A04Ovry8NGzbkm2++4dKlSxgMBkqWLMmQIUP4+OOPAdkNYd26dYwdO5ZBgwZx9+5dgoKCaNGiBcWKFQOgT58+XLp0iTFjxpCQkECvXr146623WL/eEk3j1Vdf5dixY/Tv3x83Nzfee+89mwlfIE80mzRpEu+//z43b96kSJEiNGrUiGeffdblNg0YMICoqCg1qkSRIkXo3bu3y21Ji+LFi7Nu3TpGjx5NrVq1KFSoEIMHD+aTTz5Rt/n666958803efbZZ/H392fMmDFcv34dT0/bPzrvv/8+Bw8eZMKECfj7+/P111/ToUPqfuY9evTg22+/Zfr06YwYMYKyZcuyYMECWrZsabPdhAkTWLFiBW+//TbBwcH8/PPPDtZjgSBL+fcD+Tv+Qc7KIRAIBC6ikVwNRisAICYmhoCAAKKjo/H397dZl5CQwOXLlylbtqyDwpNRzGYzMTEx+Pv7q1ER8hLjx49nzZo1T3zSVm7st8ePH1O8eHFmzJihRtwoU6YM7777rkPs5ZwgN/ZZdlxTWYnBYGDdunV07tzZwY/9qeXLMhD/UP49PtphteizjCH6Lf2IPks/+anPUtPX7BGWYYEgmzhy5Ahnz54lNDSU6OhoNfSb4noiEAgEAoEg5xHKsECQjUyfPp1z587h7u5OvXr12LFjh8uT9ASCPIkygc6rYM7KIRAIBC4ilGFBtjJ+/Hg1I9vTRp06dTh06FCq21y5cuXJCCMQPCk8/OSUzH2W5bQk+ZutU0Crcx7DOXxachKUj568XAJBHiR3OAYKBAKBIH9gTA6p5uY8rbsgi9Dq5DTX4dNsy5W02NrsmXAtEORHhGVYIBAIBFmHEl9Y5w6SZEnLLMhaFIvw1smQ+AgqtIHr++XlVmNF1j+BIB0IZVggEAgEWUfo67Dlc/ihOYy6AL5Fc1qi/Iu1Qrz7O/m3UIQFgnQj3CQEAoFAkHW0GCVbhcHiMiHIPqwV35R8iAUCQaoIZVggEAgEWYtbckxoU1LOyvE0YO0zbDY5+hALBII0EcqwQCAQCLIGSYJ7FyAxRl4WluHsRZksV7CsvFy1m/NJdQKBIFWEMizIFGXKlGHmzJk5LYbLtGzZMsPZ3lq0aMHy5cuzVqCnmKSkJMqUKcPBgwdzWhRBVmGIh9n1LcsmoQxnG4oi3GosRN+Qy0o3kZeFQiwQpAuhDOc2tk5J+SYWPk1en43s2bMHjUZDly5dsvU4eY0///yTO3fu0LdvX7VMo9GwZs2anBMKGDhwID169MiSuiZMmEDz5s2zpC5XcHd3Z9SoUXzwwQdP7JiCbMZe+TUKN4lsw2yyTJYzG+Sy6Bvycqux8nqBQOASQhnObaQUO3L7V08kduRPP/3Eiy++yObNm7l161a2HisrSUrK3ofud999x6BBg9Bqs/6SyW7ZnzSSJGE0Gl3atl+/fuzcuZNTp05ls1SCJ4K98issw9lHq49kxVeSHNeFjREJNwSCdCCU4SdF0uOUP4YEy3ZhY6DFaFnx3TIJkh7jsXs62m1fyOVNhrlWbwaIjY3ll19+4d1336VVq1YsXLgw3XVcu3aN7t274+vri7+/Py+88AJ37tyx2WbSpEkULVoUPz8/XnvtNT788ENq166trlesnRMmTCAwMBB/f3/efPNNG6WxZcuWDB06lHfffZciRYrQoUMHAMLDwwkNDcXLy4sqVarw0UcfOShmRqORoUOHEhAQQJEiRfj000+RnD1Qkrl79y5btmyha9eualmZMmUA6NmzJxqNRl12Zql99913admyZaqyb9u2DY1Gw+bNm6lfvz7e3t40adKEc+fOpSjX+PHjWbRoEX/88QcajQaNRsO2bdsAOHHiBK1bt8bLy4vChQvz+uuvExsbm2JdCxcuZOLEiZw8eRKdTodGo2HhwoVcuXIFjUbD0aNH1W2joqJsjqXI/s8//1CvXj08PDzYuXMnLVu2ZPjw4YwZM4ZChQoRFBTkkI2wYMGCNG3alBUrVqQomyAPYa38lmslZ6MTZC/WkxRD6uScHAJBHkYow0+KL0JS/vz6iu22e+bI39u/Qju1BF77Z6nLLO1tu+3MGs7rzAC//vorQUFBhIaG0q9fP+bPn5+qkmiP2Wyme/fuPHjwgPDwcDZu3Mh///1Hnz591G2WLVvG5MmT+fLLLzl06BClSpVi7ty5DnVt3ryZM2fOsG3bNn7++WdWr17NhAkTbLZZtGgR7u7u7Nq1i3nz5nHz5k06d+5MgwYNOHLkCDNmzGD+/PlMmjTJYT83Nzf279/Pt99+y9dff83//ve/FNu1c+dOvL29qVq1qlp24MABABYsWEBERIS67Cr2siuMHTuWGTNmcPDgQdzc3Hj11VdTrGPUqFG88MILdOzYkYiICCIiImjSpAmPHz+mQ4cOFCxYkAMHDrBy5Uo2bdrE0KFDU6yrT58+jBw5kipVqnDz5k0iIiJszpsrfPjhh0ydOpUzZ85Qs2ZNtZ0+Pj7s27ePadOmMXHiRDZu3GizX2hoKDt27EjXsQS5FMUy7OEP/dcI5exJYLQyplTtlnNyCAR5GJF0Q6Dy008/0a9fPwB69OjBG2+8QXh4uI1VMzU2b97MiRMnuHz5MiVLlgRg8eLFVK9enQMHDtCgQQNmzZrF4MGDGTRoEACfffYZGzZscLBauru7M3/+fLy9valevToTJ05k9OjRfP7556qrQsWKFZk2zeJOMnbsWEqWLMns2bORJImQkBCioqL48MMP+eyzz9T9SpYsyTfffINGo6Fy5cqcOHGCb775hiFDhjht19WrVylWrJiNi0RgYCAABQoUICgoyKX+scZe9oiICAAmT55MWFgYICuXXbp0ISEhAU9PT4c6fH198fLyIjEx0UaGRYsWkZCQwOLFi/Hx8QFg9uzZdO3alS+//JJixYo51OXl5YWvry9ubm4EBQVlyB1k4sSJtGvXzqasZs2ajBs3Tm3z7Nmz2bx5s812ISEhXL16Nd3HE+RCrLPPCZ4MasQODej0OSqKQJBXEcrwk+LjVPxvNXZ+wKMvws5vYPtXSDp3NKYkzM1HoW0+EjR2Ssq7J7JEvHPnzrF7927VNcLX15fu3bvz008/uawMnzlzhpIlS6qKMEC1atUoUKAAZ86coUGDBpw7d463337bZr/Q0FC2bNliU1arVi28vb3V5caNGxMbG8v169cpXbo0APXq1XM4fuPGjdFoNKpFu0mTJsTGxnLjxg1KlSoFQKNGjdBYpYht3LgxM2bMwGQyodM5+mTHx8c7VUYzg73sCopFFSA4OBiAyMhIQO5LhY8//piPP/7YaR1nzpyhVq1aqiIM0LRpU8xmM+fOnaNYsWL4+vqq615++WUb63RGqV+/vkOZdXtAbpPSHgUvLy/i4uIyfXxBLkCxUrp55KwcTxOqZViSXeQ8fFPdXCAQOCKU4SeFu0/a2yjsmSO7RLQai9R8FAkbP8drx3T5AWOfXSg99abCTz/9RIMGDahYsaJa1q9fP55//nlmz55NQEBAlhwnK7FW9rKTIkWK8PDhQ5e21Wq1Dq4lBoPBYbuUZNfrLZYdRWE3m82UKFHCxm+3UKFCLsmTEtZ1+fv7p7idYiG2bpOz9oDzNlm3B+Q2mc1mm7IHDx6olnZBHse7CDR6G/Z+D1+UgI5ToO4rae8nyDjWsZz/+QB6zMk5WQSCPIrwGc5tWMeOTFZ8ExuOwNzy42yLHWk0Glm8eDEvvfSSTXn79u3x9vbm559/dqmeqlWrcv36da5fv66WnT59mqioKNWqWblyZQf/Wmf+tseOHSM+Pl5d3rt3L76+vjZWZ2fH37Nnj43itnv3bvz8/ChRooRatm/fPpv99u7dS8WKFZ1ahQHq1KnD7du3HRRivV6PyWQbvigwMFB1eVCwVjwzipubGxUqVFA/ijLs7u7uIEPVqlU5duwYjx9bJlLu2rULrVZL5cqVAWzqKlq0aIp1KUqqdZuyoj3WnDx5kjp1hG9pvqBgaVkBrtYDkh7JcYcF2Yt3YShSSf5t7T8sEAhcRijDuQ3r2JHWtBidbbEj//77b+7cucMzzzzDyZMn1c+5c+do0aIFP/30k0v1tG3blho1atCvXz8OHz7M/v376d+/P2FhYeor9GHDhvHTTz+xaNEiLly4wKRJkzh+/LiN2wLI4cYGDx7M6dOnWbduHePGjWPo0KGp+rK+/fbbXL9+nWHDhnH27FnWrVvH+PHjGTlypM1+165dY+TIkZw7d46ff/6ZWbNmMWLEiBTrrVOnDkWKFGHXrl025WXKlGHz5s02inLr1q05ePAgixcv5sKFC4wbN46TJ0+61H8ZoUyZMhw/fpxz585x7949DAYD/fr1w9PTkwEDBnDy5Em2bt3KsGHDeOWVV5z6CyuULl2aa9eucfToUe7du0diYiJeXl40atRInRgXHh7OJ598kqVt2LFjB+3bt8/SOgU5jOImIUKrZT/ehaDRW/JvoQwLBBlCKMO5DSV2pDOyKXakouy2a9eOGjVq2Hx+//13Dh48yPHjx9OsR6PR8Mcff1CwYEFatGhB27ZtKVeuHL/88ou6Tb9+/fjoo48YNWoUdevW5fLlywwcONDBJ7dNmzZUrFiRFi1a0KdPH7p16+YQlsue4sWLs27dOvbv30+dOnUYOXIkr776qoPy1r9/f+Lj4wkNDeWdd95hxIgRvP766ynWq9PpGDRoEMuWLbMpnzFjBhs3bqRkyZKqZbNDhw58+umnjBkzhgYNGvDo0SP69++fZt9llCFDhlC5cmXq169PYGAgu3btwtvbm/Xr1/PgwQMaNGhA7969adOmDbNnz061rl69etGmTRvatGlDYGCg+kZg/vz5GI1G6tWrx7vvvusQnSMz7Nmzh+joaHr37p32xoLcT9JjiL5psQiLdMxPBrfk+6fob4EgQ2ik9MTOEhATE0NAQADR0dEOvpYJCQlcvnyZsmXLZtmEK7PZTExMDP7+/tmS8CE30K5dO4KCgliyZAkgx+qNiorKVHa3rO6327dvU716dQ4fPqxO4Mtv5MRY69OnD7Vq1UpxMmB2XFNZicFgYN26dXTu3NnBP/qp5ORvsMoqHGDYB9DK9tyKPssYKfbb43uw5XM4tBDKNIeBf+eYjLkNMdbST37qs9T0NXvEBDrBEyUuLo558+bRoUMHdDodP//8M5s2bXKIPZvbCAoK4qeffuLatWv5Vhl+0iQlJVGjRg3ee++9nBZFkFXYZ6ATlsrs59peWREG0d8CQQYRyrDgiaLRaFi3bh2TJ08mISGBypUr89tvv9G2bducFi1N7DPLCTKHu7t7lvsfC3IYex9hU5Lz7QRZh7WfsFFMWBQIMoJQhgVPFC8vLzZt2pTqNhlJAy0QCHIB1pbhkg0hIOXoL4IswtoaXL5NzskhEORh8pQT6vbt2+natSshISFoNBoHn1JJkvjss88IDg7Gy8uLtm3bcuHCBZttHjx4QL9+/fD396dAgQIMHjzYIfuZQCAQCDKAYhmu2QcGb4DGb6e+vSDzKNbgql2h3YTUtxUIBE7JU8rw48ePqVWrFnPmOA8qPm3aNL777jvmzZvHvn378PHxoUOHDiQkWF4j9evXj1OnTrFx40b+/vtvtm/fnmokgYwg5iQKBFmDuJbyGEaRjvmJo/S5W+6bYCoQ5BXylJtEp06d6NSpk9N1kiQxc+ZMPvnkE7p37w7A4sWLKVasGGvWrKFv376cOXOGf//9lwMHDqhxb2fNmkXnzp2ZPn06ISEhmZJPmXkZFxeHl5dXpuoSCATyJDsgxYQoglyG4iMs0jE/ORSfYZ27HNJOL549AkF6yVPKcGpcvnyZ27dv20zECggIoGHDhuzZs4e+ffuyZ88eChQooCrCICeK0Gq17Nu3j549ezrUm5iYSGKixScrJiYGkMOPOEtL6+fnx507dzCbzXh7ezskk0gvkiSRlJREfHx8put6mhD9ln5yW5+ZzWYiIyPx9PREkqQU00DnJIpMuVG2nEATWB1t7Zch+iaa6ZWQSjfF1ONHm21En2WMlPpNmxiHDuDoMqSTv2H84MaTFy6XIsZa+slPfZaeNuQbZfj27dsADhm2ihUrpq67ffu2mnpWwc3NjUKFCqnb2DNlyhQmTHD0w9qwYQPe3t5O9/Hz8+Px48f5Ni6wQPCkMBgM3L1716WkLzlJbg8N+ETRtKdE4i7qxf7D3Wvn2bNundPNRJ9lDPt+KxjrRXDRTlSM/AeNMYF1a9dCLvgzm5sQYy395Ic+i4uLc3nbfKMMZxcfffQRI0eOVJdjYmIoWbIk7du3TzWIs8lkwmg0Ztrn0Wg0snv3bpo0aYKbmzhdriL6Lf3ktj7TaDTo9fpc/afSYDCwceNG2rVrl+cD1GclmjMGuPoDRQr60blzZ5t1os8yRqr9lhADM8oB0LlDW+GmkowYa+knP/WZ8ibfFXL+iZdFBAUFAXDnzh2Cg4PV8jt37lC7dm11m8jISJv9jEYjDx48UPe3x8PDAw8PxxuLXq9PdaBk1SAyGAwYjUZ8fX3z/MB8koh+Sz+izzJOWveDp4aEGJDM4Cb3hdZkQJtCv4g+yxhO+03ja1mvMYHoVxvEWEs/+aHP0iN/7jW5pJOyZcsSFBTE5s2b1bKYmBj27dtH48aNAWjcuDFRUVEcOnRI3WbLli2YzWYaNmz4xGUWCASCfMXakfBlaTi8WF4WGdGyn3sX4PYJy7Loc4Eg3eQpy3BsbCwXL15Uly9fvszRo0cpVKgQpUqV4t1332XSpElUrFiRsmXL8umnnxISEqJmDqtatSodO3ZkyJAhzJs3D4PBwNChQ+nbt2+mI0kIBALBU4+iiHn4yd/2GekEWc+WSXB6jWXZOiOdQCBwiTylDB88eJBWrVqpy4ov74ABA1i4cCFjxozh8ePHvP7660RFRdGsWTP+/fdfPD0t8ReXLVvG0KFDadOmDVqtll69evHdd9898bYIBAJBvkMJraYow8JKmf3Y97Hoc4Eg3eQpZbhly5apTkjTaDRMnDiRiRMnprhNoUKFWL58eXaIJxAIBE83iiLmEwjFngH/4jkrz9OAtSW4alcxeU4gyAB5ShkWCAQCQS5GsQwH1YA2n+WsLE8Lyh+Q5xdB9R45KopAkFfJNxPoBAKBQJDDqOmYhXXyiaFYhkU6ZoEgwwhlWCAQCARZgzJhzs09Z+V4mlD+gLh5gCTJH4FAkC6Em4RAIBAIsoaK7aFIJdD7wHd1ZbeJEcchFydOyfMoluFlz4NkgheWQNVnc1YmgSCPIZRhgUAgEGQNip9wQgw8uCT/NiWC1ivnZMrvNHoLHt+DE7/Cg/9EaDWBIAMIZVggEAgEWYt1RANjIuiFMpxthA6Rv28eSlaGRWg1gSC9iHdXAoFAIMgakh6DyQA6K59hJcKEIHvRJ0+gE5ZhgSDdCMuwQCAQCLKG6ZUgKRaGHZYVYlOSsFRmN7eOypEktMmPc9HfAkG6EcqwQCAQCLIG68gGOg9ZGRaW4ezDbIIfw+TflbvI38b4nJNHIMijCDcJgUAgEGQesxnMBvm3zsMSXk28ts8+rPvWMyC5TFiGBYL0IizDAoFAIMg81hZgN3coXBG8i4BGl3My5XesFd+Q2vAoAgqUzjFxBIK8ilCGBQKBQJB5TFaKmZsnDF6fc7I8LSiWYa0bNHxD/ggEgnQj3CQEAoFAAFunQPg05+vCp8nrU8NoZRnWiQx0TwSRilkgyBKEMiwQCAQC0Opg62RHhTh8mlyuTcPdQbEM69xBo8keGQW2WE9YFAgEGUa4SQgEAoEAwsbI31snQ8wtKBcG9y7Iy63GWtanhM4dqnYDTbKN5fe34NZh6DgVyrfKXtmfVqwtw4cXw/qxUKkj9Pq/nJVLIMhjCGVYIBAIBDLWCvGhBfJvVxRhAN+i0GeJZTnqGtw9C/EPsl5OgYxPIDR/H/TeIEmQGCPHeRYIBOlCuEkIBAKBwIK14qt1c00RdoYaWk3EGc42AkpAm8+gxSiL37AIZScQpBuhDAsEAoHAwraplt9mY8qT6uyRJPmjoChnJhH39omg+A2LOMOCrCazk2vzAEIZFggEAoFM+DTYZvVgq9rN+aQ6Z1zZARMKwNxm8rJOWIaznYRouHcRYiMtfz4MIgOdIIvJ7OTaPIDwGRYIBAKB5cHW7D24slO2Cr+wGLZ/JZdD6i4TitKrBJJQLJXCMpx9nF8Pq4dAuZbQ9F25TFiGBVmN9VyCm4eg05dw/FfXJ9fmAYQyLBAIBAIwm5w/2JRlsyn1/dXQaslKsGoZFspZtqFGk/ASPsOC7CVsDFwOh/P/yh/IN4owCGVYIBAIBACtPkp5nSsPPPuYtz6BEFAS3H0yL5vAOdZ97lUQSoTKk+oEguzA2gVH555vFGEQyrBAIBAI7Dn1O5xdBxXaQK2+ru1jSnaTUCzCbcfJH0H2oSgnbp5QtAq8tjFn5RHkb2IiLL9NSbJrVT5RiIUyLBAIBAIL5/6FlQPl354BrivDIhvak0f0ueBJET4NHt2Sf9cbCP7FXZtLkEcQyrBAIBAILCREW36nJ4GDvWVYkP1YZ6ATCLILZXJtcG2IOAr+JSBstLwunyjEQhkWCAQCgQVrBTjxkev7+ReHCm0huJa8fPxX2DsXKraDVh9nrYwCGVUZ9oD4h/B9E7ls9MV8Ee5KkEtQJtf6FpNDKAY9I5e7Ork2DyCUYYFAIBBYsFaG02MZrtJZ/ig8vgu3DkPh8lknm8CW0k1kRaRUY9kir7zGNiaCu3fOyibIPyiTaw0JcP+iHNKvQlvQ6fO8RVhBKMMCgUAgsJAY6/x3ehGh1bKfKl3kD4DJaCk3JghlWJD1aLSw+zv5d5vPwLtQzsqThYgMdAJBXuYpSJMpeMJk1DJsj0gP/GTRuYE22b4lYg0LsgNjPGiS3W/S40KVBxDKsECQl3kK0mQKnjA2yvBj1/fb8ClMDoFtX8rLOpGBLtuJjZTDXRnsJtIJZViQHcxtBlKyf3Bm/ijnQoSbhECQl7FOk6ksK4pwPsoOJHiCFCgFQTWh9ktQ/1XX9zPEgeGx5WHpprhJJGW9jAKZP96BCxug+xyo87JsjU+KFdZ4QfaQZGUNzmeWYaEMCwR5HWuFePtXcogroQgLMkqL0fInvSgKmOIrLCzD2Y99aDU3L9tygSCrkCRbBTifKcPCTUIgyA+EjZGVEFNSvkuTKcgjKHGGFV9hd285RbCHX87JlN+xT7oR9AyE1BWxngVZjzEBzFaTNPOZMiwswwJBfiB8mqyMaHT5Lk2mIAeQJFg3Sn7gdZoGXgXS3ke1DCcrZuVawgdXsklAAeBoGX7pl5yTRZC/sY8sI5RhgUCQq1B8hAuUhqirULhCvskKJMgBfmwJj+9B9HV5ueVHrinDqmVYWCWfGCIds8AVtk6RJ1M7ex6ET0tOqvFR6nUkxlh+jzgOPoFZK2MOI9wkBIK8jPVkuaircln0TXnZWZQJgSAtom9aFGFwPaKEvWVYkP2IdMwCV8iKqEOKJdgvBAqWzndxrIVlWCDIyyhpMsPGWKzBkK/SZAqeMErIJI0WJLPrIZSKVpUjSvgVk5ejrsOat2RF7eVV2SPr0469ZfiPd+C/cGg/Car3yDGxBLmMrIg65OEHz/QGT//skzMHEcpwfiQrXokI8gapnUfhIiFIL2aTrNAC+AVDzE3Xs9B1mGy7bDbAlR3g7pu1Mgos1HwB4h5YXlk/vi9b9ROic1YuQe4js1GHCpeH3j/B1T2w8TMoWh1q9ck+eZ8wwk0iPyISMTx9mM05LYEgP2BtBfYLSi7L4EQZnchAl+20mwjdZ4N/iLwssv4JUiMrog5FHINd38L5f7JevhwkXynD48ePR6PR2HyqVKmirk9ISOCdd96hcOHC+Pr60qtXL+7cuZODEmcTYWMsPqP/fChnKRKJGPI31pMbkHJMDEEeR7ECa93Au7D8Oz1Z6KxRFDOzQfxZe1KIDHSC1FCiDoEl6pCrGJPAZLCESnT1jVEeId+5SVSvXp1Nmzapy25ulia+9957rF27lpUrVxIQEMDQoUN57rnn2LVrV06Imr2EjZEd3nd/B/vmymVCEc6/WL8WNSbKyoc2X/3XFTwJFMuwu6/FvcHVh94PLeTUwP1+hZA6trFuTUmgFZO8shRJkqN+uHnICopGIyzDgpRRDGKFK8H981CpU/qiDu39HjaNA88C8rIIrZa7cXNzIygoyKE8Ojqan376ieXLl9O6dWsAFixYQNWqVdm7dy+NGjV60qJmP2Way8owiEQM+R1rZXjYIfnBKBCkG42syLr7Quev5BjDngGu7fr4HjyOtCxbh/syJoBeKMNZSuIjmF5B/j32jty/wjIscIaiCDd/H3bMkMtC6kDxuq4rxIry6xMICVFCGc7tXLhwgZCQEDw9PWncuDFTpkyhVKlSHDp0CIPBQNu2bdVtq1SpQqlSpdizZ0+KynBiYiKJiZZ/2TEx8utog8GAwWDI3sYkH8f6Oz1oj/2C6h1sSsK0ZQrm5qOyTrhcTGb6LU/iXQxNt+8BkPxLgdGYxg6OPHV9lgXkuz4rUBYGbbQtkwAX2udmTEQDGCSdvL2kQZ+8zpDwGNx85N/5rc+eEA79lhBr6V9JCwYDWq0eHWBKisMs+leMtWS0xiRo8SHmGs+jT1aGTfFRmNtORGsygTFJHS8p9Zk2PhodYPYLRnv/AlLiI4y5vF/Tc97zlTLcsGFDFi5cSOXKlYmIiGDChAk0b96ckydPcvv2bdzd3SlQoIDNPsWKFeP27dsp1jllyhQmTJjgUL5hwwa8vZ9cnL2NGzemvZEVlW6voWrEanX5fNGuVNo+lfMXznM+qEcWS5d7SW+/5W2SX2tfX5epWp6uPssaRJ9B54TH6IHwnXt47HlZLtN6AbBl0wYS3AvZbC/6LGMo/eaVdI/2gEmjZ90/8mSmcpEPKO1ZnBvX7nJhXebuA/kJMdZqABCw6W9aJpfcuHCCo0nrgGpygd14se+zOlfPUgq4EWOmFGCIvc8/uXyMxcXFubxtvlKGO3XqpP6uWbMmDRs2pHTp0vz66694eXllqM6PPvqIkSNHqssxMTGULFmS9u3b4++f/fH2DAYDGzdupF27duj1+rR3ALQ7pqM7shpz+bZoL23CXLU7ZZ/7CdOO6VTdPpVKFSvlewtxRvotP6A59jOah5cx13geCldM175Pa59lhvzcZ5pru9GcXoNUtDpS3QFpbu92XJ4kF9amPQSUkAs7y8k7Wlttl5/7LDtx6Lf7F+EUaN296Ny5c/JW8nfF5M/Tjhhrtmj+2wbn5N8li/gSoo4bCyn1mW7Vr/AAilcNhV070UtJdO7UKVe75Clv8l0hXynD9hQoUIBKlSpx8eJF2rVrR1JSElFRUTbW4Tt37jj1MVbw8PDAw8Mxo5Jer3+iF1e6jqcBWo1FW6IBBBRHG1IHrV4PrT8CnQ6d2YTuKbkxPOnzlGPcPQcPLsPmcRD/AF3xOhBULUNVPTV9loXkmz47sgzCp0KVZ+W4oofmy78bvpb6fpIEJtmdTO/pAy70Rb7psyeMpd/khDoavZfoxzQQYy0Zg0U51CZEy3pBCjj0mUGeSKsrUgHe3InG3Vden4uV4fSc83ytDMfGxnLp0iVeeeUV6tWrh16vZ/PmzfTq1QuAc+fOce3aNRo3bpzDkmYx1okYSobC47tyYHbvQmISXX7lxEo5kLqCCLovyAiP70LUNYh/CO7JIZRcyUBnsvLNs44iIcg+7LPPCQRpEf/Q8rt8q/Ttq0SV8SoIQTWyTqZcQr6KvTRq1CjCw8O5cuUKu3fvpmfPnuh0Ol588UUCAgIYPHgwI0eOZOvWrRw6dIhBgwbRuHHj/BlJQuGvEfBtLTi6LKclEWQn9spvQlSOiCHI41iHVvNIR2g1yQTF60NQTUtEA5DvP4t7wJ1TWS7qU48xXv627u+z62BOQ/hjaM7IJMjdxCUrw3X7p98wVroxVOwAAcWzXq5cQL6yDN+4cYMXX3yR+/fvExgYSLNmzdi7dy+BgXKqym+++QatVkuvXr1ITEykQ4cOfP/99zksdTby6I4cPB9ky7Ag/+KgDAvLsCADKAk2PKziDLtiGdZ7wZDNjuXX9sHdM3LYNUHW4l0Ear0EvoGWMkMc3D0LvkVzTi5B7kWnl9Os+xZL/77tJ1l+7/sBYm5Bg9egQMmsky8HyVfK8IoVK1Jd7+npyZw5c5gzZ84TkiiHWf4CRByVf8cLZThfEx8lf/sGQexty7JAkB6U2KHuPumzDKeEW7LLhJL1SpB1FK0CPefalomkG4LUaPau/DGbZZcJD3/Q6tLay5ED/4N756Fiu3yjDOcrNwmBHdYKsLAM528US3DB0rbLAkF6UN0k/Kx8hjMRXF8nlLMniki6IUgLSYIvguHLMrJ119V9TFax69XslPkn8YZQhvMzcVbO8taO84L8h+IjXEAow4JMoFiBPXxl67BSJkmp73fvIsyoCj+E2ZYrlkqTUIazHGMSJMWB2WQpE5ZhQVpoNJaskq7qBUmx8HlhmBwMhng5/TfkK2U4X7lJCKwwJtladIRlOH+jKL81+0CjNzPmEyYQ+AdD4QpyylXfYjDssOXBlxqGx/DoFkhm23IlsoRRuElkOUeXwt/vyaHv+iZPkBaWYUFqLO8rG05i78jLrirDitJrTJTHmFCGBXkG+0EufIbzN+0nQdx9Ode8d6G0txcInNFtlu1y4fKu7acou252YdVyg2V46xTZL9LZ7PnwabJl1TocZV5BDa1mFU1C6W+DUIYFTrh5CB5Hyr7CiTHpUIaVN0Z+smXZIznhmFCGBbkea+W3bn95YpUg/1Kjd05LIHiaUZRdnV3MW507oLGNQ/yk0epg62T5t7VCHD5NLm81NmfkyiyK9ddaGXb3Bf8SthEmBAKQXZ0UvaBQOXlyfXotw4oS7JGOSDN5BKEM51cUt4jCFRytPYL0k1esS4mxcHC+fJNq9XFOSyPI6+z4Gh5FQJPhqc8aTykBRO/5oNHmbJYq5Zq1VoitFeG8mojIWZ8XLg8jRUxngROSYsGcPAlOVYZdfGOcmJy5TlGChZuEIM/gXRjqDZS/BZknN1uXEqLh6h7wKSI/DDd+Kpc3H+X42logSI05DeXY5C//Bn5BcGQJPPgPnumVujKshE6zzz6XkbBN2YG1Qrz9K1nevKwIg3PLsECQEooVWOcB/iG2ZWmRZOUmAVD/VajWQ75H5BOEMpxfKVoFun4r/058JPuT+hQFd++clSuvkputS/cuwM99oEApGH4M0ACSrCSL16UCVzEZ5YQNAFq9/O3uYqzhvJAaOGwMbJsiK8Jat7ytCEPe6HNB7kF5W+xdCELqQPWeUOwZ1/ZV3SSSleGAEvInHyGU4aeBn9pD5Gl45Xco3zqnpcm7hI2RH0BbJ8sPVcmc84owWBJseAaAVps8OSJanjUslGGBq1j7/ylh1dQsdGm8DnX3gaLVoGBZ2/Jjv8DZv6BSJ6jTL+tkzQjh0yzRLsxGeTmnr93M4MwybEyCBR3l+9Sr/7oWCUTwdKBYgb0KynNM0jPPxLcoVGwPwbWzRbTcgFCG8ytxD2RfPc8A8CpkKRNkjlovwo7p8kNV5547HqZKjGHPAvK3V4CsDIssdIL0oKRi1rpZrI2uZqGr2E7+2HP3DJz5S57UlZMob3EUSjZ07vaUlwiqAVW7QmBlS5lOL0cMADmihFCGBQpmk5yKOSOuDRXayh+Fh1fgxCpZvwgdkmUi5iRCGc6vbPhUjkPZ+lPwLiiXicQbmefYcstvU1LusC6pynCA7bdIvCFID2r2OV/LhDf3TM4a1+WC0GqKIlyzLxxfIZcFlJQf7nlZIa7/qvyxRqOR+9yUKGINC2yp2BbeP2tZNpvk61p5XqSHqGuw5XMoUlkow4JcTryVf9DTYhnO7ogP4dNgxwzLwyb0jdzxMFWUXsUyrHwrSrJA4AqJdpNkIPMhlNSMaDmYdMNskt2Z/IIsyvCjCOj9k2V9fsLNM1kZFlnoBClw+yTMayYn1hl1Lu3tJck2Ikw+jCYh0jHnVxTF16uQJQlDfk+8oUR8CJ9mW65YhjIzs12po8qzFitXpQ7yQ9bZMZ8kijLsVUD+Vi3DUTkhjSCvovgFK9Zg699puUkcnA+z6sOWSbbluSHpRquP5D+rMbcsZTE35e+wMbkjJGJGMBmdp8lW/4AIy7AgBTwDgOS4w2mlWgf4/Q2YHAIH/icvi6QbgjzD02gZtor4oDWZgGpod0yH7VMzP9FNsS5d3WUpi75hqTMnrUvWE+gAWn8CzUc6TmYSCFJDo5XjjxYoZSlrOgIavJZ2iMbYu3D/Ajy+a1uupmPOBVZKG2U4wtHalddY3B2u7YbeC6B6D0u5mpI5F/S5IPew+XO4shMavWXx/zUlgSHOMmE2JRIfySnXtckqo2IZTooFs1meuJ3HEcpwfuVptAyDqpzqtk7mWY0bOsmYNREfFOvRrPqWMmvrUk5Ss488k79EA3m5aNWclUeQNynbAoYfsS1zdbKNyUlqYLCyDOegm4SCtTJcsZ1sOdV75Zw8mcWYYJnIa43e07JeIFCIPA3X90KtvrLyq9WD2SDPJXJFGQbLmyL17ZEkK8n5YKKmUIbzI5JkmSznXUhWjuoOkGcfPw1UaIMUPhWd2Yikc0eTVcqqJMnWYAXr3zlJmabyRyDIKRQrpL1ipkygyw1WykcR8ne/3+TJRHkdpU/1dn9AfAIhIebJyyPI3ViHVtNo5O/HkXJ5WjGD1Qx0ye4Rei/Q6EAyyYqyUIYFuZKEaHmQgmwZ9g+B4vVyVqYnyfqxaMwmJDRosjLiQ9wDMMbLv5/pBaVzqQIaeRYubJDPe3piSQoE9kSehRO/yiGZUps1rlh+7RNAPPMcVOtmUYpzEsUyrGTfyuuklIFu0LonL4sg92NtIFO+FWU4Lewn12o08u+EqHzjNyyU4XyJJKdiTox1tBrkd8KnwbU9AJws3o9q5Uugy6qIDzHJlmCfotB7fubqykr+C5eVkKAa8uuuiGNySuZyLYUyLHCdPd/D0eVQ+0Vo/I5c9uA/OYJK8XqpK8OqZdhO6dXp5U9uYOhBeHRLTlkuSXLijdwiW0ZQleFc8EcjN5HdUYXyKqrrZEHbb1fmEtlnoAPotwrc3KFA6ayTMQcRynB+xKugJRUzyDf+xBh50BconS+c3Z2iRHzwKQqPIwmJ2oe51gfodLqsCYGmuEXktjSUKwfK/uBv75VdYkScYUFGiL4Od07AYysXAsWXUEnIkRKqZdg99e1yEp/C8mfLJNg9S54c2OrjnJYq46RkGX7a0Vrd75u8ZylXng+txuaMXDmJteukogSXbSG/8fEtlvb+SU7CLpZskLUy5jBCGX4aMJtgavIM8VEX82+KXrMJWn4Mu2YCUPjxBYx3jmddxAdVGS4uW8JiboJ/8Zy1zEiSVZzhZCVYCbEmMtAJ0oP9JBlwPQOdV0E5CoUSuUbh3kXY/pUcjaLjF1kna2bQeciKpDIBNq9iTGHS4tYv5LdFjd+RXVSeNrIzqlBeJemxPFkOLMqwq38EJUl2CUx8lLEEHXkEoQznRxJj5VeAngHJGYnc5N8J0bIFMb8qw60+kkMmbbM8dDUPL8s/suIGWLc/lG8t/55ZE2Jvw+vhEFI783VnlKRYi3+4mnRDWIYFGcCZ9cddCaGUhl9gxynyx574h3KiiwKlc1YZvrobTq2BkqHgHyyXxUTknDxZQflWzicv3b8oRw2wDrf2tJFdUYXyKkmx4BciK8V67/Ttq9HAy6scy8/9I0eoKN8mZ5+BWUSmleHr168DULJkyUwLI8gijiyBfz+UJ3kpvq1ehWTlKL/HGn5wyW75v6yrW+8FRSrKv/1DZGU4+kbO3ggUhVert4SJslaG83osVcGTQ7H+pmQZzshYUtwmcjq02vX9sP8HecJPrb5ymXWotbzIC4udl7uJ0GoAlGmGpHXL+qhCeRG/IHj/jGO52SS/YXBPp4IMcPwXOPW7fL/IB8pwhpxHjUYjn376KQEBAZQpU4YyZcoQEBDAJ598gsFgyGoZBenF3lEenp5Yw3bKr2oZzmoUv2FXXrVunZJyhrrwafL6jKK4QngVsCgqioVYMmU8ja7g6UO1DDvJQCeZMhYeTZdLsqEpYdX8gmULGciT6fIjbrkonF1OsnYUGrMRM1pLVCGBhcOLYWJhWJ3KxNjUULNT5o9oEhlShocNG8aPP/7ItGnTOHLkCEeOHGHatGn89NNPDB8+PKtlFKSXeKuEGwpPSxa6Ks9C/z8wtZQnSWgeZKEyvH4sbPsSHt+3KMPR19PeLzvTRNv7C4NsIdYmz5IXfsMCV1Etw1YB+K2txKn9sfr9TfghTM5wZY1iGTbmsGVY+dPqX9wSWi0hOm1f6LyIsAzL99bIUwBoMWOq+aLze/DTjLsPckrmqNS3u74fvigOP7W3Lc9nKZkz5CaxfPlyVqxYQadOndSymjVrUrJkSV588UXmzp2bZQIKMoCi8HpbKcNKOtX8bhn2LgTlWmIuUA7dtskQfU1+EGd2lrvJCHu/lzM+1RsgP1QBol2wDFtN6MAQL/vynV9vmdmcmdd3qjJcwFKm0cArq+WbnW/RjNcteLrwLignbLAeS1otvL5NVoqty+25exYijjpGnVAUM1MOWykV/2D/YPD0l9uTFCtbjD0q5qxsGeHRbfjmGdn/88Ortu4rT3s6ZsXIoNHK92uAYs/I99qsCrOZ1zi5Gvb9IGdebDFKLvNy8W1xQox8rRjibcsVX/WnWRn28PCgTJkyDuVly5bF3T0Xh9Z5WnBmGfZ+SizDCr5BGLXuuJmTIOoaFKmQufoeRcg3Vq1eDt2WHjcJsFWId34t/86KCR1Fq0DHL21dYkAOmyMQpIcBfzkvD6mT9r5pZaAzG8Fszrmwjop/sOIiUaGtLBN51J/eEC9HBzAbHP24n3bLsNkEDYbAgf9TizSRp6Hn95b1TxsP/pMnVVo/B5VnRlpJN+yzzyko7lTX9qSc2CoPxXXO0J1p6NChfP755yQmWv55JiYmMnnyZIYOHZplwgkyiDPLcKlGckrm/JyJTpJk/9ujy8GUyL5yIzG8vgsKZkFQcOuwalqtlZtEOlIyN7OKeanRZo11olA5aPQm1OqT+boEgoyihvmyCzNo/UYmp6zDJiPE3pF/Ky4SLyyCvssy/yc5p0ipv0GeDOXuB9qnNFhUq4/k5501kafl77AxeUIxy3LsYwxb/05TGVYSbvjaliuWYZMh+9wAnyAuXy3PPfeczfKmTZsoUaIEtWrVAuDYsWMkJSXRpk2brJVQkH7inFiGq3WXP/mZ2DsQPlVWND/ozj2/ahBYOWuyTClKr3+yElywDNR6KX2K9o6vLb8lc9aliXbGxU1w57RsIc4HM30FOcjR5XD/EtR4Xn4T4YyU0jG7+8LoS7LFOKeSQzyOlCcAanT5x20otYQbTYbJn7xKVmSQuyP7C5tLN0V7dReae+fk/fKIYpblqBOtnSjDxgT5TYMSjcgeZyEXrZf9gqDmC7YuKNYJTvKIS4rLynBAgG2w5V69etksi9BquYiqXeWZ0ko8zacFJZJEQEnH17WZRUnFrFiEfYpAz3T4xodPk+Mfh74hh3jSumWN/1rkGflGV6gc+FllEjq6HE7+Bh2nCmVYkDYJMbCws2xRHPCXHJtc4fASuLYbgp5JWRlOKR2zRiNfKzmJXzCM/k9Wiq2VIUmSFYGUlIDcTEoJN/ID1hnkrO+N6ckgl2wJlip3wXRtPzpDHDy8IqfifhpxZhn2SH57YDbK61O6DpylYgYo0xwGrpXdBgMryWVbJ8O2KbKxJw8pwpAOZXjBggXZKYcgK+k01bFMScmcGCu/6s+PKMpwoXIAeCfeRbv7W3D3krMxZQZrN4n0Yn0Tbz5Kjs+YEAX1BmVeId71LRz7GdqOt3XDUKJLiGgSAldIjIHbJ2SfeJ3dY8GVLHSmVF7b5zQajSUVs8KxFfDncNl3+MXlOSdbRsmKVMxZYYHNDqznV5iSoM7LcPzX9FkaO02DOi9jLlKNxzt+pED8FdlafPzX7G1zbu1TZ/OINBqo0kV+Y5Ka77yzzJQgv2WxftMSNkY+R5I569wAnyCZms1w9+5ddu7cyc6dO7l7925WySTIDm6fkFMy/1+rnJYk+7ifnHAj+d+/V9J9dFs/h/3/l8pOLhJtZxkG2Trz4D+ITWPsm03yTTw2Eg7+JM9sBtmFo9XYzE3ocBZNAkQWuuwkO+NG5xSKomvvFwiWh2BqodW8i8gfZ8rZ+rHwxzvw6E7m5cwqPPxlBT6vxhpOzWf42l5Y8hz880HqdWRnyMfMXiNhY+R74/av4Nta6X/lXrC0/Ia0QCke+FTAHFJPdpfLzjZD9tefUZxZhkFO3PL8gtTfIgeUgJINVSNTimyeaPmtuAHmITLkYf/48WOGDRvG4sWLMZvl0CU6nY7+/fsza9YsvL0zkM1EkDUYk8DwGDwCbGduW0eTyK9Zyewsw489kv+1Rl2Tnfwz4zvce4EcOcL6n/Wfw2Qrb9sJ0OzdlPdt9RFEXYeZz8j/wtt8Jr9yKlBK/meeGRTLr33OeEU5TohKff/casnIzVi/xm1iZY1Pz2vc3Iai6Lr7Oa5zxTI8/HDK646tgLh70OgdW1ee9JCZcXrsF7h5ECp3llMYg1VK5kwqwzl1/XgGQNkw56/94x7Apc1p/xG2tsAqy1nl65kVrg4NXrPUgSbD8pwo2Z+SnTuj1euhcnI42Ozyb83OPs0Mis++vTLsCo3ekj/2JD2W3fEM8fKbih0zbNfnsTB2GVKGR44cSXh4OH/99RdNmzYFYOfOnQwfPpz3339fxBnOSa7vhUVdIbAKvLPPUq4ocWaD/OCz9//JD9gpwwn6gkhuXmiM8bJCnBl/MXdvSypmBTXWsAsRJa4nn4vgmqkrzulFeeB5FbAtd9UynB8Vu+zG6oGnTXiEZ1I5tDumw/apec5PTkV9FerjuE5RkJMyGE9UsV5mJppEZpSri5vgxK+yhUtVhpOv3djIzP1RzgqlLyOUaggD/nS+Lj0Z6KyVt+1fyW4JuUUp/NN6EqAE26ZCyw/T3u/SVvnPT9mWEFQ7ddmyss3W9SfGWCzEZkPO3xfe3CF/S5LjOrNJ/qQ3Fr8xEdaNsiy3GguhQ2BaOdkyXKVrnlKIM6QM//bbb6xatYqWLVuqZZ07d8bLy4sXXnhBKMM5iRJJwv61ubu3/M/QmCBvk9+UYUkCJduc8jpHo4FCZeXJFA/+y/rJE+mJNXx9v/xdsmHWyuAsAx1YlOO0fIatFTuTCaiW9xW7J0HYGJDM6LZNoT3JHnd5ub+UZBnO3CRcsQynhjKZNTNZ6KwVmNhIaPOpnETAFeXKPsYwyC4dWr2sqMTesXV/yqhcynJOWwKViVCuxhkOG2NRCnXuWasUQsaUzvBpcPZv+bdnAaj9kjwxyxVf1DN/ye5oTR/ZKsOGBIurRPNRsPWL5Dbrs/483T0vf5sNWdunmcX+jfDfI+HgfGg7znbOiStY+xA3G2lpY7ORsGO67E+cWTfAJ0iGlOG4uDiKFXN83VW0aFHi4uIyLZQgE8Q7iTGs4FVI9pGLf5A1sXdzG2/ukJXegmUh+Q+wVLCsHHBdsRpnhKhr8s25SCVoapVuPD0pma/vlb9LhlrVex2QZHeJjKK4QWTGZzj5JqbbOplnNW7oJGPWPMjzuwtGyw+RwqeikSQkjRZNbnngZQTVTcKZz7CP7Tb2JETLPqpuHnIkCnu/yKywDIM8ju5flJMpHPgfILk2ThW/YH8rZVirlaNMRF+TLY4FSmV8nForfYpSnJN/jNJjGTabYHF3iyJsSsrakI8V28P2aelTtO0zyL36LxStKr/id8XSqMQULlpdLdIt6SobJF7bBMXrwpq3UB8SJkPWtjkxFi6styy72qc5cb9080ROyZxKrOGf2svPwOcX2sZvdnO3GNjqDbSU1x8kh2EMrJyn3DEzNIGucePGjBs3joQEyz/P+Ph4JkyYQOPGjbNMOEEGcBZjWCE/Z6FTrMAV2ti87pEKlpV/ZEYZvncejiyRozZY42pK5sRYuH1S/l0y+WayZZLsQ7x7VsblMhktCoq9MhxcG15eDT3nuVaXJCFpZUVYyipLRm6dTJJVhE9Dk/zaUSOZYfPnOSxQZtAkT4Ir7LiqxvMwZAu0Ged8V0O8/Fr62h7n51S1DGdSGZYk+VqUF+SwUGmNU0myTcVsjaIcJz3O/DgNG4PNjPwWo+Xv7Jpsue8HmFoa1o5yXKdmoIt3XGfP6tfhSvIr9FKNoGg1532REcxmWNZbVja1bhalMM39TNBkhOwzXLaF7PIHlkl1qVkaJUmOrw5QzKIMo3WTY01HnpZlOL5CLg99Q/aHzao2A+z93na5aHXX6s+u++Xd8/BTB1jztuM6VxJvPIqQP86SuCh/njeNg/+1hVNrZCNR0Sp5ShGGDFqGZ86cSceOHR2Sbnh6erJ+/fo09hZkK8qg9nbiKO9qxpmcIhv+GUuKy4QSaSIjKMqu/atUZTn+ASTFya4ozrh5SL4R+5ewhGYrWk3+vrY343JJZjkVc0K0o5uEdyH5j4Er3L8E26agQcKs0aE1JcnnIrNWiNz4Cjmr2PYlbPsCU4sPiN+3EN/EO/KrQTePvNmuWn1SzmLoH2JrVbUnpRjDCoql8tgKqNjOcb2r1/bFzXDriGXZbEzb4hb/0KIU+tm1oWxzOQZy/Vdly2Nmxmn4NFRLI8Dvb8JzP2SfT3HiI/mtkDNru6oMp/HnI3wanFwl/y7fRp50p3WDJsOzxtfz9zfg8V35z9B7p+Hv91yr19k4OLVGHj/N3pP9pVMi+gYkRsvtKFLJ8oYwsJqs9B9aBDf2I/9xkSCoBvw5VO6zrGiz9Xmt2B5+DJP/wDV9N+36re+XkiT/odoxPfP3y0cR8ptJZ28JFT0hNQNZYipvjTz85Mmxp35P3jYmYzLmAjKkDNeoUYMLFy6wbNkyzp49C8CLL75Iv3798PLKgwHM8xqpKY2Xw+VvZ5bhSh1kv9nMvJbPTjLz4Dj1u2wRqNgeSjZQi6VKnaF0IzljXEZxFlYNZAXU3Ve2zsbcdJxgp3D/ovzKz/omrvgO3zkp32yc+WqmhZu7nIo5s6wcCEiYC5bjYZKOwo8vyJn8Uhpj6SFsjCVd59YvsHm1nVfdKJQEKkUqY67anf/+u0nNG0vlay4PTRjJMtTscylMwFGUs5Or5FenGZmoKUnw1wj5d9Hq0PELuLYv7f5+lGwV9ioEeruwb60/sfwu2zw5nXsG/VuVNsRHwd45suWxUDlomRzeLKv/EKaWdMPNA1nZS8Myp6So1mjh2W9k5fXaHtB7Z97XM3yaPGkRZMvrb6/C5e1yXOeMXCPn/oHz/8j38dSUYcVFonBFeTwaDABIRavK5bF35Cgcl8Plt3S1X5Jljb4GVbtl3r/VbOdiVryebAzx9HetT8PGyG9atn0h+0i76gqUGmqM4dQMZFHO95WklJNugONzq0Lyn92HV2Vr8aPbsptLHiDdyrDBYKBKlSr8/fffDBkyJDtkEqRFakrj7RPyb+/CmMwS+y8/IPJRAkX9PKkX+g6Hrj4k8n4CRZPuE1q2EDqt3Q0zWUExNR9tu2/pgtz+ayLeN3YQV6I5QV0/k+uyWx+XkMjD0FHO604L63/G0TfkeLxx9yD8y7RvCKf/hFOr5ZuOlTKMTxEoEJxmu1KVW03FXNyhT0PrDybikYlTFx7hH51CnzYYLL9qVm4qIFuIA0rK/sY3D0K5lunrKzscznXpglzfNI/4R/d5XGMA9SuVdH4+/v0Ibh8H4ESDqdzZ9xvtuYDkVRDN1smciYghqsF71CtdUD3fRXw8QAP3YhPlPkjtXJvNtq+20VgmaiSPY7Mksa/ka6rsDa79D7fwLzhTZRgPLtyzOZa1HKkeOzPnOy0l/fx6uR33znHi+gPWSS2opl+DW/wD7pbtgeb4euIexKV4jTi7hpQ+LXRwJr7uGop1m+Cwb1Yup3bOHMZSoQQidiwi2qDjce3XHPdVJmqlZBnuPV9WAg4ugK2TuXUvlkNR9an95+eUPvEt12q9x5GAfhS9lML1A3JkgZgbcmjCV1bLKWDLtZRfxaamXKkuEmkky7l/CenSFiStHq0pCbNWj7H+Gxy6dD/1PlMU29r95OPHRsoTkozJCo0mOSSY2Zi12bnUpBsejuerVDCHXr5IZGxi6n2qkb0kpUod2fvAF7eivWlwbQ/SoQXs6xbOnThz6vunxsMr8rfOHRq9LV8zl7fLGTPDPkxdKbx1VL5Xlm5icQ2o1l3+g3HmT+jwhW3YUGuS0zDbuEgABCa/iUuKtUy0rjdQrr9uf9g6ST53fZakr5323L8of9+7IBtHmgyX32Y808s1g4zJCBFHkxekrJl8l1KMYeuylN4WGxPlSYCQgjLsb/kdVNPiiuThB6f/kMd61HUokPszFKdbGdbr9Ta+wnmVOXPm8NVXX3H79m1q1arFrFmzCA0NTXvHHKByxGq0O05D62QrmbXSeGWHJef65e1QvjV4+LP3UWHe+3ILvWOX01R3kl2mZ+hnfg6zBO+6reKipOU9nxdZ6fkFnnod5zv+DBqodGorgff28b/tl4hNMKr77tHASLdV7DJVo+n9b/j60HUkCYf1Mwy9mXVsL8EBniwuv42Kjw/JDy1nF/TCZ+XvgX9bylqMlsOQHV5kKWsy3HH/8Gnw3zZL3Q+S3SAKlcdklrj15+fUPLeeW8ZDBHcfz+2oREod+4Yftl1kWnx3lus/RwJmS9XTljs5FfOxR368mUKfQgQQQXCAJ3/7TaWwr4dtuzz95Y+13CVDZWX4+n6LMmzfLnus19d/Fe5dYHuEhg+2PiYiOkFtVxXjpxx3n4CvJoGwwyEk+Zdxfj6u7AJgr6Y2u9b+SnPdceI07njHP2StMZTCpzey+0QE/czPsdTtcwKBlwyfAjBMt5rLGjMjfV5O5VxLdtE2JNm37PVtEDaGC3ceUXHbFwSYluKp0RMneeCmO81uU1X2nIhg1lE5JJ11u97Rrlb7/z2fF/kmaAMVHx9SFczbf03E68YuAu/vT3Ecp3q+7f9sKuO0bAu5vGRDQGK/piY7/lhIW91JjkrB1Ndd4NTFyxwyV+T9VK4R62uokeaU2qfDdKt5Xy+vDzvQyKad/czPZcmyTmNmhLG34zhNHldHg3rz1tHSNmN8qlSbP9y/5KZUmG4HnnHss/LJ7jjWCSCsr+3kLFX/Fh3ENd1VXj/xLRMk0FyHr429+W5fA9h3FCDl+4ZfCFTviTmkLjc2zbP8oWg7nHsREcTceshDRXFb3NVy7Apt5FTMSlg4++tLkiA2kpjFL+IffQ4NYJZAazZw+csmvJj0JYqF1em1HXdfViqPLpOttHfPyuETr++TJ+iZjbLV7eru5OEvx+Wn1oupX9tOrn3dku40eXAf6KwqwxcfGHklxXsSKfdpQowcIxYY8V8DSp8cQzPdCWI1nvjG3mHZwtn8ZW6ScrvTkvtxciKi2i/B4cVwaYv8Fi3mpvxmsk4/y/72z4Fd38qGjRZj5EgP/22D0s0s+986DCXqOz925Bm5vJis/Gp3TKfp+d/ReHeRz2PcfeA+kmcB9nu1oNysdnhojPhpdGiu72XL9m14Fa8hj6MdX7l+Lw4bI7vTnVoju8S1GO38+ZZanwFsGCv3lUJKk+/Sek5YH9teGbbeV3FbslKGlT7T+p2G0NcsdSpuEtb7t50AP/eVjVaVOtgeu0So7J5xYYNsEFL2zaVv/DLkJvHOO+/w5Zdf8r///Q83twxVkaP88ssvjBw5knnz5tGwYUNmzpxJhw4dOHfuHEWLFs1p8RyQNFp026eCzspaFTZG9qG7vN2yYZkW8Mrv/HsygreWHmaobrn6cH1fvwoMsMjUAQ/JwFv6v2gUf5qSSfJrpcUL5dd5TfX72GWqxhusAD2WfUFWIEzPMcy8Wi1zth7g+djlVDy9ivuBjSickhVbmbihXOyGBPj7XTkuqDUH58uvsBSLr2KNUZQTq7BqOx74cWbym7xuWiErHSe+Zf3RXdyX/JBozdtuv1BLf4ImOvmm2YQzacudbBmesvMRvbWOfarsq+xfOHE/3MPhJmbe9iXabV9wt0hDArdOxlShHTrgzqlw/isxmIbX/4d22xeWdjnrM+t2R56GU7/jaa5CRNJnDNOtVtv1jnk10fjgSwL+xNHKWbtqvYj5zmm0wGVDAbVd3lr5tXdl7Q3+NDXmff0qGplOq3UPM68G4H29rFSmeq53zIAbB+Ru9K9EQMx5iDjKwx+7MivkS+YfbsQh9wVU012Tc8Fo4aCpInvM1dVxBajHXsIkmupOq/3fKP40ja+dVhXMXYfX01R3mhmG3kAp3k9lHKc5TpU/m8o4vbIDmo/CsPcH9MANg5/aZ410Z9lvqszHhsHcoojaP5D2NQSwzKpdTXWnHdtpOp0ly3K/OBmnd07B1V2suViB3uyyGeMFjbIi6Uu88z6LuiY3IlkZNm/7Em1yn11dPY4bNYex+cwdduzeyY/6baC1zK2pgG2M7hTPR+uP+fdkBNd+H2+5tu9/Q+LRWVwwV2OA4UM4tpePff7kdZPdfUVJxWx//cTckhVCUyJW9i1OmstSU3eZytobzNd/xauGMc77LGwMGOJkBbdgGTmcV9kWcHWXHLYt7gGUawXzO8hKsjWz6sJrm2XFWZHVWjbrcZi8XnttF4GAacd0VRlec+I+vUn7nuTQp14FISmWS+ZgSsedUvf31cr1vuK2kb+SmqTcbiu5HOSu3FlWgDRacPOyrFcm++6aKf8Z0GodnwNNhiW/eUFWqA8tkPfd/qU8zyLyNJxeIyvDzo7dfY4cx92rIIRPQ7d9KpJvVXS7vpbL4h9yP7ARvzyoQPziz2io3w/ABXNxKmpvcnXD90wwDkgeRytcvxeD/MdHMkHppnJ4N/vnW2r7ho2R35zss5rwXLaF/HzfOhkijkPfpS6PFZtjK368XgUc902MkceoX7C6vdpn26fK/tcgK8LK+bLe32yS3eBAdlG0PrZi4FGU4Vweuz5DmuyBAwfYvHkzGzZsoEaNGvj42AZqX716dZYIl118/fXXDBkyhEGDBgEwb9481q5dy/z58/nwQxeCej9hzgf1oFLFSuiUga/RyCmGFZ8vhSvbMf/Yign3xjI02cpk//B9X7+K4+ayHDeVVR+WR8wVbR7WHhhoqpOV5Cba02r1zbXHMaGjvOaWWlZfe1793VB7hs3mK7TRHmakfhVfG3qzMuYldrU8iDYlnzmwXNBFKtlGbFDigCbFwv4fZGXY3t9OWQYkNBxe+xMj9L+noLhX577Zj6a6006T8A3TrXYqt6TRoQHa6A4yxO0fh7oDNI9ZbmpDF+1edX9fTzde3zoZIo7B47vcMfpQLGKLvO+N52Qr4EVZLq87h9kzfzSN9b9xodpwKr7wuaVd0Tdkt4ITK1Nsd7TkrVoVFWXnff0q7pr9QQMDdOvp7bbDoV3mc/+ilQxcNQfyots2tV3vm39hmP4PKmhv4W1OYo+pijpWLkvBan/+Y2yAGyZG6H93PNeP78p+muFT1XE1K/I5Fui/pJXuGAUjdlDh+liG6QpTWPvI5nzU113AHSPrTfVtxmVj7Sma6k5zwRzCX+YmFOIRTXWnOWwqzwfGN/iGOaqcP5qeZbHeMlO/sfaM+ruu9gIlzXfood3lfJzePAQFSsvRFS5vl1/NS/JrXen0H+gNj3hg9uU5t10OY6GXeTtrzY1opT3q9Nj1tOepYr5mM+7MEjTVneaKuSj/mBtSVBNFU91pzplK8KnxVT5nPk11p9lvqsxGc31CNPdoqjvNNXMR9purUlxzl6a605wwlaGf4RNVsT5nKsEvplYEEk1T3WnOm4qzwNTRZpwr41QqWA4N0Eh7io66g06vHx8SnF8j276QFWEPfy78+ikVT39nGYfHZ3Ly8B4+c9sHHrZt1mqgm9teLkgl5GOlcP1hNvFv4EBO//wJI63uaZ9IS3jN7R/CdMepZbxIC+1xXjfJ+3etFULF1Px0ra4fa5S65zON1rqjtNYdZYr0I7ekIo7XdvxD1brKwyuOdTcZJkdoUCYnhdSV09/OCZWV6GW9YdT5lGW7exY6fSUr2VsnY2rxIecvnKfq9qmYi1ZHC9TXnqWl7rjD+XpWt5ebUhHOmkvytv4vx2u/fBti8eGqVMzmOfGheTlv6v8mVHuOahrbe7na7oQY2UL7+K6s+NjLfWIVaNxkN4F9cy3rN0+U/xzfOw/n1spWXPvnwN1zyRlU/WVF2Nn5Ov2nnAhm2xfO11stm1p8yO5H1XjW7zS67VOJCajMqze60EJ7zOF+CfCcbgcxkjevm+R7WrV6k+hYZolc96PbsqX70hbn50sJQegT6Niu+5dkxbNgadg713Hfh1dsn33K+k0TYOfXcPYveW6HEu0jjXbbHFv5w3X7hOwrbb+v3bJ9n+FfXPZ/T+0a8iok98u2KY7P9f/CYcsX8h+aXDxxWiNJzlKSpI6iRKbEggULMixQdpOUlIS3tzerVq2iR48eavmAAQOIiorijz/+sNk+MTGRxETLrNyYmBhKlizJvXv38Pf3J7sxGAxs3LiRdu3a4bH3W/lfGxo0SIoHphzjVHn9BiRKbnhojDYWMIAZbt/Ty21nqsdT9k2SdLhrUvbrmmHozVC3NXhojDblilJjfeylr9an8Y35suw6dzSmJEwtPsTcXA4LpN0x3WYdoK7XbpuMbtc3ct1O9gXQrh6M7swfan/Yt/tX/QRCdecc2iBJ8mva9/WrnPaZtdxKf9jXPdftGzq5HcAsadBqJJv14Q32UfrEtzZ9Zr3vCN1vvKf/DYOkRa8x83Xy+ll9a9GhejG0f7yN7uSv6vm2b3fsT90peHsXJkmDzu7YinLs7NjW7VKUEnvZluknqX+IANViqRzLfizY1H11Lrpd36RwPiR+139GHd0ljJIWN41Zrdsg6dCnMOaU85MWSl1JkhvuqWyf0jhtEt4P7c0Dlu00OjSSCUnnjuRfAu1DS4g++z5T+jy1dgBqu2cYejPc7XeXtlXalRZKPx0yVaCe7qLDepOkRZd8bFfH6fs6+c+Rs/XWY8mk1aMzG1IdhwA/GTvyufEVPnebzytum23kdqj77BfoDi/EiBY3zA6yrXX/iOraqzbXwGzTcwQFeLA99AD6HVPV+6PDfWP7l/KrcKftlvjX/QOqaG84HSv2feZQt3JPSx4/5hKhmAask1cmRKP7vxZoY26q6+331y3tgfbqTiSNBo0kX/uJjUawceNGOvmcwH3nVyleu65e+8o1Yr//z/rPaaw743S9fbvNIfUwDbJEkNIt7Yn26o4U+1y3pBvaa7ud3tOUPkuxT7d9IVt40+pzq+eE0mft2rVDv+db9DumOh1rw3W/MVL/m825VsbR1pEt0G+fgm7X1+o9zebYkoRuYUe0tw45Xe/QrqbvYW5psY5qN41Dt29Oiu3SLeyI9uZB58dOod0Oz9Z07GvdZ6rOkdaz18n5Tut8PgliYmIoUqQI0dHRaeprGVKG8zK3bt2iePHi7N692yYm8pgxYwgPD2ffvn02248fP54JEyY41LN8+XK8vb2zXV57nj36KjrJiBkNWiTOBD/H+aAeVI5YTZXba9TyRMmNyomLbfZ1x8AZj4HoNBKSJFtStcmKjVnSYECHh8ZIouTGOlNDerrtUm+Im0x1aKU9ik4jYZS0fGt8jvf1q9T1O03Vaao9hUYDBklHxUTLRIT+FU100h+l4eWZaCUTJo0bf9ee77RdgNomhUq311A1Qn7bYNK48Xetn1QzotZsoPWZj/BJigRw2u4g7rPLYzg6jaQ+NBWFZYahN8PcfsddY3Iqd70iEl2OvIobRqd1V9dcZq3HWKfH7l/RxITrr6DBsU8Uznn0V/tc3leigDuMq2ui7ZkP8EuMsLTbrs8KXfyF5o/Wptjuix4v46YxI0lQPnEp5uSw4q60y4sETnoMRqeRSJLcqJS4WJXVLCX3ffI4ejZpMqeksmrdryQup2LkPwDqvrZInPMYgIfGaKMYKtbB9/Wr1Ae9UdJiQqv20UFzZRprT6PVSJglDVelopTR3EGjAZOkoXziMlVOk6Rlj7kqzXSn1OMcN5WlhvYyGo1jnw0uH8eHt4ejN8UBqNeSKTkRyc2A+gRHH0KLlEK7sDn2dnMNWumOqcc+ZKpAbe0ldBr5+pxt7MH7+lXqeqXNZknDDnMNmmtPoNVYruXzHq/grjFhkjSsNIXxvC5cHdNrzE3ppt2DXmMiUXKjTdIMtru/q/bTBak4lbU3MjRO9Ri54Nnf6flUxpJy/TobS4rckLriZpK0lE9calP3kNh5lHy4y6ncAD21O/jGfa7T9UOrmXj/P7ldZnT8UXsBl2I0xBjAXw9l/SR6HBuIDrPTuovykP2e76TYbqXPzGj5q85Ch7FguVdr+aP2Qodj9zw2EC1mjLjxV+35WM9R636kv/rb2bWf2rUL8J9HP7TJY6N84jIbudO69sHZfcm63f3RWIWRu+tbjStFWlHiwS6CY45iRosWs1O5PQzRdDg5TFbM7NZ7Jt2n/an35D7V6PirtqNRrduRAWoISPv1IQ/3Uf/K97KS7eTYF6I1DLs0yGm7wDJOnY2jZhym0X/JRhlgf7l3uR1QF4Aqt1ZR+Y4lNbazY3c9Oght8tulOH1htlSdgkknRwJxeL7Z7etmiqfL8TdSXA+WsZbaszUj+6a13jvxLm1Pj0qxz9XzlcI1kt3ExcXx0ksvuaQMZ8rhNzIyknPnZItb5cqVc6W/bWb56KOPGDlypLqsWIbbt2+fM5ZhyYik0aGVTJhLN6fCyz9SAYDOmJfeR3t1B0ZJVh6G6VbbPHje0P2lPog9NEb2mKrQxMoC4JF8c/TQGOlp/QrY6oGlrLdxwbCzROg1Jptjd2hSh0YrX5UtbBotOsnIs36nLf8g/x2T3C7532WlipWo0LyzWp92x2mIwLJvwirMvZJvhNE30F3SQpL8wHLWbkVpsLay9TN8kqbc7Zs3lK0oVv1iX3c77SH1t/361/z3qMGN7OsGWRFQbszW+0YlQdliPvgdjVC3te8zgITv5X/dzs73MN1qVRHWaOA7t1kMNY5wuV2v6dbZjJVl+kk2sgLqH4sf9V/TNOk7QEP3mkWosE62FBkkHe5O6h6m+91GEd5lqqaun2V6jkZa2b9VWe+WrKzIx5VUBdFDY+SWuTBltXdSlLOZ7lSq49hatr4lItHflBVh62vM/PLvsGM6xZOtHCn1mf35bKU75vI1pFjiLW022rRzmX6S+qD20BgpqYm0OT9BPFAVYQ+NkS/dfrDZX5f85sgsaRxkH1zgIJrrKY/TN3WWB739+VTHkuR8LA3TrcZdY8IoaXDTpG530WnMjHVbymTjywB0qV+OEmv2qGPJWZ831Z5Mbpfj9ddZv1e9/rSYiDyxjtmPu6n7Dndbjc7NnOL57KPbmmK7X/PbZVW32eHa1O6Yriaw0ZqSnB5b62ZW772RJ9ZRvOundKguZ3Y136mL9tZhJCzXvrVl2C2Va3eYbrVq5NBpJEbpfmG6SY4h/Wy9MtT77/tUr/2U7kugjBUJSatHkxxlIDD2NIGx8lsLc/F6aG8eQtK5ozMlOe0XDThdr1v8bHL0Xw1ayZTCvpLap/brdf83TV6v0Tn0Wbt27aj4x6QU26WMU2frylWvTeghiyKsAUL/+xbTS6uQSjVB96tFKbc+trWFVCuZ1D7zNtyn85WJmN7YiXbfPHRHZEU4tT5T2+jkOaD7sQVayWgzVmyss8njMKW6dXb7OliG09hfOSf269V1aJxeI0+CmJgYl7fNkDIcExPDO++8w4oVKzCZ5H87Op2OPn36MGfOHAICAtKoIecoUqQIOp2OO3ds/W3v3LlDUFCQw/YeHh54eDiGDNLr9ej1+myT00GO5NcVtBqLxmyCa7vRXt6Odvc3Fv+dqzswl2nBwutBxCSY1Yev9cPY/uG7y1SNvWbLBJ+D5kqpvo5Naz3APbM/7+tXoQFW+r5E4zNfqDdOjWSGgJLotk9Fp0sOm3NI/jep6fkDPLyCbutkeZ3SLqXdl3fAle3ozv6FbseXcpzQUysh9jYxReoy/3YZTJLWabuV18zKtzIJzJpT5lI2cje5tRDt9qmYg2sx4W47isRfcaj7Xf1qIswFCdY+5G9jQ3V/X083Sp2SsxxFSIVYbmyd4vlYYWrNPP03NuuLHv/eVrjG71j6LLlf9A/l8/CZcRCFibZR7JW6NcAIt9941m0f56XVcrv2vY320ibMzUbS8kAzescuz9BYOWKuQG3tRYpr7/O920w+dhtNtfA30Uhm4twC+DGhTYrnY4ahNzqNmQaas+r5UNYrx9IgqRPnZht7qEqy8mfGWi77ZWs5nTHb2EPtJ+V8VzidnA2wYFk0Dy9D2RaWa0wZq8Ait97EJhhTbJdSb0rYX0PWbW6qO81Vc6DL7UzPcqQ5gHmmbvgQbzNOS59YgaT3RmOIY7GxndN2KUr6j4bOTq+Rx94l+F9MKEar8209Du3/ENj3WUPtGZrpTjHEbR2PJG9W+r5EgyMfopHMJHoHU/nBDKf793aTJ+s8xI+Fhg42x652bhVKcoUfDM/yBiuI1Rkt/sluact23FSW6tor7DDXsL22T6+QfUM9A6BmnxTvWesLvyL7Ojs59nJjK57XbeeR5MkbphV8vdKIm9skOt5fIkdMADTBtaFKF3RbJ+MBVLp9HveI1ZhbfkzLPfV5PpVrt6tuD5W0Nxmq/4Mk9Kz0fYn6hz9Ae2035uBatHwwLsVrf4WxJcek8oRw32Gs0GqsnHo8OfGMBQ3am4cs68OnpXwvt18vSWrKek2fpRB52vV9lfWR8h8jzUu/wK0jap9BNTz2fku1c3NSNOCkNk7rX5uP9tZhKNMMTdgHsHIgmrj7uK3sDx/dsIQeK9sCzYC/bGUDW7n/ehcOLUAbcwPtV2UsXZdWn3kXliNh1H7J4TnA3dPJvS/Xk+KxU6rbLxjNowio8QK67VNt+ky3fSq4+6GpPxA8/F0/J2kd+wmRHh0tQ8rwkCFDOHLkCH///bfqarBnzx5GjBjBG2+8wYoVKzJS7RPB3d2devXqsXnzZtVn2Gw2s3nzZoYOHZqzwqVApdtr5H+P9s7nigP7lR3yRJ9WY9GGjaFEcjQJCfkiV5QI64vd+uFrPctcURwVZcJ6X5DDRFlva73egyTedvuTgppHzDM8y0j9Kgb430B7PDnLWrmWsjN99HVoPNRxAkupxlDzBfm3XbvU5A1XkqNnbP9KDl90eTuUbYH/5e14e1RiSrL1xV42ncbMXkM1h0lBMwy9qaK5The3fTzCh68NvS1yb9sLJRuivb6PIRXr0PrEc077NFATTX/tRm5SRN0fE3KA+YubOGEuq1oZnJ2PSprr1NNdwCxZ1odEnJazFt04KMdubPS2nHLZul/8S0DMDR5IfvxsbqPWr7Rrluk5/HnMKlMLeum2875+Fc/pL6K9dBSAC9pyhFUKZNaBlGVLa6wAPDZ70NntAGVN7+MVex2TpMHbGI1J0qbabgXlfNiPNWfKpSKHffQF+2UNUorjFMBf85g4vNhsqsNI/Spe9T6L5mGEPAO+alc5Tqb9JJHkiSGtb0fR9kjTFK+vd91WpXps+2vI+nyl1a7MLvuY4plleg4NWMZpq7FoDi3CZDLyo+lZ7koBDnLvNVfDiI5TUhli8ba9Rip1wuf8P1TRBPGGcaTTdgGpjoXT0iGa6U6RIOnluv2uob0iz/TXd5xE0FpPZkU77v+9oStv6/+isOYR80zdbI5tbjIC7e5vMaNhmqkPsXimOA5Tku0XUyvi8eAR3gw3r7bpMzUCjt4TsySh3TqZuyc2EXhvH8awj9kX8iofLj9MlMn5feNH07N01+3GT5PAUmMbRupXceC3syCdlOMWH10mJ2BIvufrtk6mKrLvpe7KDrboFvKKeQgYnPfpQ/yYpF3AA7OvpU+vyX2qbTGa4Y8q8tFq5+1+2W0TfTXb6Jk4AYPBzdLupiMgdIh8PbT8AK7uTI5olJzRrWwL24hH4PxeDnKc34dXLNdXy4/l5CclG0LVZ1Pft+Gbckxe6/UKJeqrIcN0WyfTxLcqutgzmFt+zKo99dFEJ9icb+tx+oJuK910e9hueob39ato4X6WUsdO2h575Bn4tjY8ugUTC1naPeAvx3Yr9w2lrOtM+fuQlYuH9fqwMU7HUuy5bRSI280Fn3qUb1lGnliqtFvvLU/IBGg20vbYLT6QozncOiLH+3bWp1d3y8lpKrSFIhVt+owyzeVtkx5D+0mpn5PU2m2/LhdOosuQMvz333+zfv16mjVrppZ16NCB//u//6Njx45ZJlx2MXLkSAYMGED9+vUJDQ1l5syZPH78OM2JgTmF4piusx9AyvJ/22wGXsdngpn7cl1Gr3IDg+XhO8cs3wCsJ9As53PANhSPTmNWl633NUuW7bQaHOo2S7BfqsoJc1nMXoVpU7WcHNtS+Vdbd4B8A7u6U7aqlGkuR0t4eBlKNbEE5k6hXbQeKwczP52c+jHyrBzGJvmiLFX4FVh62EF267YpbW2sPQXAHPNz1OEcXdz2Ecx9Vvq+RNfyIbLcrcaqQdzLlq/C3Fp1GfazxqHdvbTbAKipucxIn0kM8Lsmx+RMzgJ42b0SGqtwR/Zyddbt44I5hIraW5wyl8bLDcxhH6Nt+YElLmNACcd+KVgWHlziJY8wjm2LY1a0bbsAXnX7x0Yp7R0TDlq4ZA5m7eatBGm2AL2dnm/rsTLH/BxLnYyVJtqTNNadZY+pKnW0F5L3kZwqGqmdD/tjD9etstlWadcrxk94x7zapq5hTpatx7CzcdxNu4vv3OcQIRXiQtWhVIw9CIGd5JnXrT4GkpNPlBhMhcIbcXfT4tV0FIeuPuS2Xzy+p08yK9F5n800yopuSteI9TXU2HTKpg8OSFXYa6jGHPNzNu3MqmWdRnaXWOn7kmWcho2BsDHogE9ORvDpmuIQ7yi3gsM14uEP5/9Bq/dQx7lyvlw51wBbzHW4Yi5GGe0djno1ony8/OZO8gthv1czahS/wW0rJUbZf7apB2aNlkipAFrMzDY9RxPtKSoV86Nwzedh97fcl/wwocvQODRbrXfoMwC9J/+ejGDCnvr0NvSmaeRJFpt6M2fDM5ilfSnWrU5IM9eis24/9/FnhqE3TXUniSlWH/8ileQdlVTSYWMwX9rG/Qf3KdB8FLq5K/GKu8WoDpV4b08tpFjHPl1tas4YtxUU0say3789VePl61PyL85et1C2nZN9yOfRy2GcNjSfoZguigram7btTnwEX5aBVp8AkmqMsIl1bx1KLKV7+c1DML+jPHZKNZXDdinZ+hRS2veXV+Ds39BnmVz+3zZ4pndyhsMqlni6YWMwmUxoDv0uPz9bfsC4IhG8ufSwek7sx6knSVTU3uSuKYCvDb0ZGHwVatgZodw84P0zMKGQHGVGo7MowsmYmo8m9vRmkoxmzoe8ChfvqYmDGvoFJ8/ecCSlsTTNbSe9dbB62wHW+L7A4mrDLdffru8sFcQ/kGVV/hzU6y9HcdDq5TjYzvr01wFyWUK0Y58lxciKr2dA6ufE+pwpx7ZeZzZZljOb5S+byNAEulKlSrF27Vpq1KhhU378+HE6d+7MjRs3Utgz9zB79mw16Ubt2rX57rvvaNgwlTSPycTExBAQEOCSQ3ZWYDAYWLduHZ07d063W8aUf87wQ/h/hFUqwpthFWyyUF25F8fP+69xO8Z5ApUgfw9eDC1FmSI+6cpwtWTPFdadvE37akX5sX8DOS3jtzXlG8aYS3JQ8r/fhWI14K2d8EMLOfxYl68tgblTQ5JgZg3ZuqxgdVGuPHid0auO2+wiT0qyLBfy0dOzdnHaVguiXumCbNxzkC6b22GQdGg/u2t5zQPwf23kDHEvLIFq3QidvJHIR0m8364S9csUol7pgmwJ30LHHb2Ilbzw+OQGen3yf8y1o+DMnxysPYnnN/mQ0oVm/8ru97LjCWrW3yYTW1SD91LNBGU0man0yT+YJZjzUl3aVSvGoasPSdg8hVa3/o8Zht5sNdfmbw85Be2/pvo2IbQUwoLMDOkcSmi5wBTPdxEfD8ySxLCfjxAVb3CY9PadoQdfm15I40Q6MrhpGfWcpJTtLq0xbH+uUxrHbuGTqX51Cd6aJA41+Z4bRVvaZIm7HBnNe5GdefA4KcW6NcDbYWV5dOsi7Zs3TLXP0lpOrZ1Zseyu0/LivHCKepr56pWwVMfSkWsP6fn9bgp46Zn7cj3qlS5IoymbePDYwBc9nqFPaCnbfXd9Cxs/42bp7jQ71yfFcW6N/TgruH86iVcPUCvhABfMxUlATw3tFaYbX0AjmdFpzMw09lbsjymek+AAT8Z1rUbHZ4LhwiZY1osz5lJ0SppqL0KqDG1VnuFtKhF+PpIhi+V5AXs/akNQgKf8hkoyg5uHGtM9o7PQn9Nu52v3eZw2l6Zz0hQaaM6y0mOivLLtePApqiaosHkWfFdTtky+vg1jsVpUGCtPWJ33cl1aVymm9qnhv+3siS/NQmMHvnefSW3tf3xl7INWMql9GuDlxqtNy9pcI7u+G0SrmDVsKtiHVsN+sJzvBV1kY0bVbnI2uJTeVqYVQmvLZDmmbmKMbBFu/I4ltW9aiRn+GApHlshvztolT27fOE6OX1y3P3ST3Z1MZok9FyPZsGOfzfX54epjXL0fb1OlMo7KaCLY5vE+SZKO8J77aVe7ghzG1C9IjsdrLePWyXKGOLvU3f+ejGDCX6eJiHZ8tir3SocQmq3G8m/hV1IcS2U1EXiSxHUpkMfIE/fnvlyXjpUC4Itgy4Zv7bbNvnfrCPzYUk5a8/4ZnPLncDnJVatPIGy07Tj7ezgcWy6PRSVzaHp4dFt+hiZEyS4l9vFMs5n06GsZsgx/8sknjBw5kiVLlqh+trdv32b06NF8+umnGanyiTN06NBc6xaRVcTEy75M9UoXonH5wgDqN8DQ1hXUNJ6upNi13jelZR8PHetO3mb3pQckGc24X9worywZKv9jr9Yd1o2GOyfkeJERx0DrBtV6uNYojUZOmfljS3lZp7e56ZYLlGM9FvbR0yUkwamSYt+2sPo1MW3SoNeYeBwVgU/hEpbjKamYA0pgMJm5GysrR31CS1LUT54N3LZFC34M785RY2nev/+I8kHJloku06HzV9QHvi92m3eWH7Z5cCs3YPtXdj0vj2ffxZ9x051jhqE3c482QHd0O4UC/C0PejsSjWa17tZViuLupiW0bCGa3e9Eb8NDOcY0cv0xkpdTRfj/2zvvOCnq84+/Z2fb9Qp3Rz+6VEEFEY1dEFtCSDHWJGpEbKhBjbEQRcTESmzRJMafJragsaBCFFEjRWmKFAFpwh0HXK/b5vfHlC23d7d7XL/n/Xod3M7O7s1+d3fmM898vp9HATYUKxzbPwOn3dbo+71ix2FKjc/XQv90K2bPo6lNCuFGBUyUvxVJQ5/hWNsOTxqUBd/nwh79vaz49Blu8KYD+sSmm+yv85p3BsV+T9jjAhFHKQ14cvlOfjkUJuZn4mhizGK5fSSPbez2nm1f8a37Miq1BJIHFTb4NwFqvHrlJjvFZT3HdPv/QD3IqJT+9UW0Tx+n3lnpPHXxeGa/uoEaT/TqT16amzvOHoZ/95qwMdu2xs7Y2i+o0+wMse1jgffnbA70J1Gr4RrH25atxHwLQk+cJt7/X0qqowh1I4e9SEtv9PVGY/LgHjjtNs4ckcuvszYyreI1KhZ/Su6FD+hVsVcuJjDiAubGKP4b4qPAOPyawgjbbvooBzlDNSbkjvlZ4+LDrBg7EvGH1LMmD862vrvb1tgZ7t3IEm04PZRSjrZ9R51mJ0mrDhvT8hofj/53G09dPN56vxN7j4TyN+lRuyv8/TabhyRkNFwZhKarf6oj2Azi4/thxZ/hh0/Wzx6ORt+Juhjeuzq4zPy9zwQgUpCqvLDty3r7nVS3nZ8c0yfsBHxrYRm7P+hJf1sRJ9g2g6+vLrS9VfCbTyBvbKN5u40JWlMIP+ydwcK1x/PUiAKmhtgH9qg70Dg/yiNhpxa+z1eAuW9v4swr+qOG3mF2/rNuH9L/T8pucDitqm9taf37asvC12mEem3B+2ewtiDAxPJ9etpE5SHUlB5NPk970Swx/NRTT7F9+3b69etHv379ANizZw8ul4uDBw/yzDPPWOuuXbu2ZbZUiJuSKl2sZCRGryirNqXRg3FzGNUrjd8kLuM036d8u8rDqD16jiiDz9D/X/WM3q3p8DZ49RJ92aDTgh2iYmnVuM0Q2DaHXqUJuSy365DunRqak8Ix2TUNipRQkhPcFCiZ5HGYw/t2BMWwzxNsbJLWlwPltWgaOFWbfvJgYHc4+SDvatbsLuGsguqgGAbrTHhU7zSrcvrgjDH0Tk+0dsBLNxWy8H/T6aMc5Gf25QBMNIRwmlLFdvelPOabzqNlM5j54lq9IjAsQ59kk5gFPYZRZghTh6rgdugX4VbvLKagrJaFTCdVqeJKu149SlVqol4m1oBSj8KXu0s4cWhOo29BUUWw6tHY7PNIzIpbU4I1VqJ9hmP5TL+fdQnf+9Zyhf09TlE3cLv2ErWakxvsb0Qdm8ZYtMvGnIBG202njZ/EJP1glkgtWiCAYgu5UFu8U6+2pfaCHz9LdZ0uZJJcwcPDxd5/M8Cxl40lU4FR4U/uN3LY7S6mjspjyTcHWLRuH+eN6cXPj+tb7yQ74PexeHfIwwMal+44hRne/XrVLNCLTwJjsNvCEzdMFGDxxkJ+d84IVJvC6LRaqmq201/NQbX1Dz7x2AvxD5nKnx7/CMVLTKJVAXLT9O00GZWtckzVNvbuNd7hXZ+Br5ZDVb6o1b94KCWFL7VhTFS2cKZtDWc71uobOmxa4w/0GmLY7qbWGzRzuOy6NIoc06kBXSxu13pbQtgcUzMhYe7bmzhzRC6qTSG5z0jYDNm1u4J/s+qw3nYXYOr8YJOJSGLxg5rd+z7TUxqoK9fHddXTTVeV+xpXcPev1ff/NrvRkU+BvhMbrNZHnsxW1Pr42/92cVx+pnUCMWlQFm99fAz9ve9xcP1ikpJTdSGc1FO/mhmt8h2joA21J4aN98lz2FNcTfWa3VEfFw0NKCirZcu3WxkZeocpfq3bhjhOakSEJqTr/zcqhtMb3Z5o1XDz5GOVK40cpZRfP/4GP7/gvKjFnI5As8RwaLMKoeNSUq1XbNITnW32N202hdNSv2di6RY++vI/vHvC3QzOOYf8o05gzY7DpB+o4qjD26yweQBG/yT2Vo2NdcE5eQ67D1cB0D8rvgzo5xKv4rtSH79WetPPXFixH9BAdUFSNvt3lQD6wdIWId5G905jze4Svvq+jB+O660frOxuSwyv2a0/dnSfdGYc09d63IT8TG56dT0At/p+w4/VT7EretzTQv90ZttfAyCDivCDVs++qH8/G1xpcPseymt1MZyW4EAx/maoYJ3nu4Rfqh9gV/Q4p8bEXlFFXYP3mZhV8cjkiciZ2JGYFbeWPgmLB39A03fcvkuYbvuUTFslv7Hrec3xCuF4TiDaE3eKLoZtikZNdSUJySGXDKsP65e+0/RPfpVHj85LcgZrTj5F34cEvFE+G0ZrYFR9Ha+hOo7ul87kIfUrUpFFw9CTNtCvkCxy3hW1cRAEhcDqncVMGpTFr73/5GTXe3z97Sw47tjgijYbanIWs84/kZkvNl2UMb/Rd583IuzkLGPEKbD7XnpVb4G6Sr3dMvB96vgmn7MpbrS/To2mj9tV9nfI04r1cRx4Crx1g36iccETuh/XRAsEx9yRSJ1PH1BF0U+GIfqYAoy07Y5pTHMGj4WlkBcoora6EndiMhwyGhel9WtYCMfDGffoE6r3r9U3PhYhDJA1WBdntaVQ+BX0PgauWga1Zfgdycx97uOYTnyinQQAVPc7FXa8R/L3y2GHISIHnab7mgP+BiviTQlacy6B+bcLymp5/n87uWTSAF5NvJA/++o3yTFJo5KL1A9JUmr4o+/n1vLK8sPBCXTO5OBJkkksYjhriP76egyvf18MleGmTj72a9nkKKW4qvYHizkdUBA3SwzffffdLb0dQitQWm1WhttODLNsPsmKLsL7Hf4fZ/z7R0AGtqWbmWXTJ/As0X7EDY432DH8NwwaNlZvwfnpn5reETZxVg6w87A+i7h/ZiLEHjHIrp6ns6y4iDOrQ8aqwricnNYbFIWCMn1H0yvdXe/x43KdbLd9Teb2L4G74Y2rYc8KOHsBjPwRX+7WW7Ie2z8j7HHmQQuC2cChFdYSLQWATKUCCO5EN+/YqdfnEvXnKzPe61R3sD5pCtaGnrsh0dczpX6UYCQT8jP5XdJbXOUPr9xFWj7M29Eqbu1F6JjP8t3APx3zrCYc8QjhUGI5gWhPEhNTrS6JVZWl4WK4Tv9smX7IyjpDDIdUhv2K/rnyRxPDmqZX5+z658ZjiDOnvaFpQuGEnrSFWm6aej/Mx3kTekIlaJHt6Q3MCcW3L/qaEuN7AlH85VHsOgBjRo3h+8XZ9FEOUbFpKSn71+l39D8RVuyL6TVGYv5tv2bjFPtXfMwxDBgyArb/nz6xeOWTsPZ5feWzF4SLEV9INdrhpq5Krwy77LaoJ8JP+H/IjfZ/W7nUsYxpVo9elJBChlLBvu1fM2jMJH0/DdBjaLNec1QufRMW5OsT0VRnbFVlm0233W1botsjeh+jL3ensXrH4biq9ZEnASybzyR3OV5NJduzD9/Kv2AHfANPY/8b91BdW0fJhFuYENDqXc1al38lj65aH/PfBrj33c3MW7y5XtU6Ehde5jhewa8pPOz7CX7DHBEYeg5MvURPezD9zKFYYrgRm8SI8/WfaGTm69FxDYhps7DQ2Obv07IYx3Z6KXrVOvLko6NwRE03hI5NsDLcdhdwtx2sZmTJh/g1hcG2/fRRivhe68ksW3gF0Y/KTVueIfCtA1vAG1tFoJGzcvN+szI8ICsRTxxiuFd6AoAleAHodzz8rkCfoQvsKzXEcFpCvccfnVbJBc75VJe68Hlvx75/nW6xMGY2r9ldCsAxEWLYPPg0VGF916d74DKoCHtcVanecY9EvcJaXqsLmNSE4Hs9IT+TvDQ3P6n8JzfFUL1VgDSnVk+wR0O1KZw2NIuHv9LbloZiPqeZXNBQxa29CBUKxypbLSHc1ElCY8RyAtGe2FQblbhJpobayrLwOz2V+v9O/WBaZYjh5BAx7LPpn6uAL4rQmDJP/zG8qx6fIc7U2MRw5ElbrJYb63HJOXAQ7NVF4St8NE//7h53JVNHDedARR13/+cbRvVO5Y5pI2LylwNkJjlZ4xxNH+8y/J88DAEfpPZh7Ogx5L13mMKy2ph9w+kJDp64aDzHDchkze4S/rEil4c2GyePRYaYt9lh+YLgg7w14WI44Ie8o42rTwnUGe+JaZGIHNNZ6pthDVpiGVPFZuO5tBtYcxAu9mQzCELEcJQKYnNZ9UxQCPs9YZa3aB5U8/0alzSafhhieMJvdIFM+Hc7HqzH2VT6f/Mkm7W+FAYyOZUNBDSFZ19/m5l2w16yYWXUeQ6hYx4PTQlhgEOkWVnf2ZRRRGawuKAo0YUwQCAA9oTGK8ON8bP6XVNDCS0sNESBph+j8pTi+icfHYhmieGMjAzrDDQURVFwu90MHjyYyy+/vMNGlXUHNE0LVoaT2qYyHOlTA3jDeRev+k5hluOtsAri4/7pzLK/iSvg1fuex1IRaMxLfPIcNE1j5/IlgF4Z3rYz9m0flFDB+bb/kbVnOzAseIczUf8BCkr1L31elMpwn8FjqNLcJCm17Pn6Y/qVGpfL8sZSUetla6GuzCPFcM8Udz0hDPUrrBlKZdjjsmzGbUMMm57hUDGs2hReGPQxQzYZkzYaqd6a3+bpAwIxC9bBP7ufESMLyI3iFQs92DZUcWsvmmvxiEY8JxDtTbWSoIvhqggxXGd8lqzKsOkZDoorv03fh2jRKsMmxjHB4zfEsCM2Mdyck7bQqwxqqm5PcdVG+CW/WQSHt8PIHwFwsFzf9nF9M6JOKG6QZfPpneADL6SX6Ek1RZnHsm1nMfdnvceGqsNhl8CjYX6jHvjxaCYPzrb+dorbzrkbp+NWNWaV/1tfadsH+kn/Z4/qftXIS9+uFPjNcuumaZNwhVTij3RMAYr7T2Hlgb1MKDY8yfk/0AVr/slNj1ksNDERrSEPKsA4JZWrEk6mV9Ikxj5xnO7p/eGT9ExpXsKTuU94P+sSNnm3cpPjdXb79c/VAS09KISNMSssq613yd8c8yP1kUcjgI2DpJNHMXlKMUVaZmzFhan36z+xxJkFAtZJRazEcvKx3xDDZmU41se1Nc0Sw3fddRfz5s3j7LPPZsIEvXK1evVq3n//fWbNmsXOnTuZOXMmPp+PK6+8skU3WIiNKo/fOig1NIGupQn1qZ1s28Cx6jZ6KOX1hDBEVIAiKgLNpaTaS4VRIe2bmcC2OB47PLCDy51PsOPAEOCGqOvsNyvD6fUrw6qqsss1hJGer+FLI1A9cyAkZLB+20ECGvTJSCAnNVxIT8jP5Bu3jYdro+ee5iglXGz/kAzDJmEetAYmGqLErAybYtgd/pUe0iORbSOu57Udp0DITvqJwHTwBqu3uSGz/ONh6qg8zhyRG3eiQ3sSr8WjIZpzAtGe1CoJoIGnKuKSSQOV4VCbRMDWiGc4ArMy7IyxMtyck7ZQIeDO0MVIsq84/IkrjUpxsi5qTJGSmxZnBc+mMqL807BFf9rWg5xtt3Kz43XWavWFcKwWjJG9UumV5uaPZT9mZuJb+lUy0y6w6unoYjiCOl/9k48jHVOAQT30z8O2IuPzMXya/tMSNGF52+TdSkHE9y90PNdpQ7imegh5nxzmc/d2fRJoUg8mpCeRl+aOuVofehJgzSUIaZICkGcrqXf8iuY3Vm0Kv5t2FNf9a11zRyUq5mfpgJZBnlLM8KRKrv6hIcLfvAaqi/UmJZv+A8k9dY95vSdR6y8zObwD/nKqvs6tcVSQiK0avl3rzarAcLZrveN6XFvTLDH82Wefcd9993H11VeHLX/mmWdYsmQJ//73vxkzZgyPP/64iOF2osTIR3XabSQ4GvkitCChZ3uzfdfwiW12VC9mZEXuvaNXcFQLdKbZZVgkeqW5ccf5mpNzBgCQ6Q251PrRfbpv+LgroNfR7DcOptFsEgDlmaOh8Gv67V+sL+g1DghOnousCoN+0Orzoz8w88W19TJUAZ7ync/F9g/JpALF2AXffd4IbAVGZciySQQn0IVx6u0MAT6LesnxeIoqavlXA7P8Y6W5iQ7tRTwWj1CiCZzmnEC0F2tdx7K2qj+9bCnhd5ieYUMMVxsT6JKdoWJY/1xpvihiePkf9TzTCVfAoNOCYjhGzzDEd9IWKSrN9Jd0f7Fu1VAU8FQHo7uSewJwwMijzk2N70D8ftYlfOPdaomjbwL9Gap8zxX29+qJpGhZ2Y2dECqKwhkjckhb/Qi2gBe/zYHq9+BbtgC/4sIFfLWrkJE9jmpw++q8pmc4fJ93JGMKMDxDY4a6nKF764Bj4hkyi4asDhn7S0gcO5veJ/02LBrMf9Jv+esnO7D5PA0+5432161GQuONRj9a7igUVzLq8gf5v4GlnLlucpPbFnkSsCLEbxweFxndZx05CW7N7hK+3KWfkEXuK5qLmb4z86U1FG7PBHZw/xnZ2Mz36ruPoXyf3rlv2xI9qSlenMlQV6Z33wyE7PdK98AL5+odUK/8KOpDzWp4YycfnwbG8KlnDNCx5o5E0iwx/MEHH7BgwYJ6y08//XRuvvlmAKZNm8Ztt912ZFsnNJvg5DlHVEtLaxB6tvdD2/+iejGjWQJKj5sNealH3Kpx1yEzSSL+mc6ZvQYBkEEZgbpqbK5E2PIuFG2CkT8ECJlAF10MO/oeA4X/tG7vdA5j//ZDvLdRn4g3vl961MeZE3yiXRYs1lL42D+WEpLpnerg9+eP0Q9aOw7rKxme5Gg2iVBiEawdtDFQqxCrxSOyQUukwGnuCUR78K+MmawqLWZhwqDwO0zPZoRNIjGkMvxh9iU8VDyZc7JOpl5rou9X6wfiYWcDwUplPGI4npO2SFGZ3qMXAC48aLVlKAnpUGWc1NrdepczsJqz5MVRGQ6tFoJeLRys7GOkvX4qQ2TkW6wnhFMOvcDkSCvD8vspDyTjssF9b65l70cad5yt27eU/evgjV/rKQCXLIpqkwCOaEwBBqdp/MnxDN5aFW/pHBxVByB7aMP+1Agai9sCvXtt3paPwoT46p3F3F/VwGQuA79m42bH6yhoTLDpuceFqWPJM6rNg0+9g/unj+L2RRvDHtdUtb65cZHRJsElOFSu+sFABmQnkZ3kYlNBOfMWN9D0ohHM9J2xfdIp3Kbv622VBfqdAX9wkneuLjbDotU0Df5+tp688cMnIbEBAWr60bUAeCpANZKYakqCiUoNoNr04syRpLV0FJolhjMzM3n77beZPTs8FPztt98mM1Mf8KqqKlJSUqI9XGgDzMlzbZkkEYtPLTJr0TpLHHTkrRp3HdYzhgdkxy+Ge2b3pFJzk6zUUnJgF1n9RkCZMVM8rS/VHp91ghHNM8yy+SQe2Bu26NYVKqs/X8V16iLOtgdY+NEvyEl1R/XONmQ3uOCJz7i84FauPXUQy88cFtyJHHWBHnE0QD+olNfo1bx6lWGhQZpj8ejMJxDmhDjTBmHxg9/qP0ZVKDiBLlizO5g8jP8FkjjBHmUijlktttIk4rNJhNKcqwzZmRk84v0xJSTzW69GSgJQYUxGS86xvMyFhijLiUMMh04QairpojmTg7a9eieT9z7TqF0nQfFQWFbLdS9v4JdDFc6pq9CrdkYl3zz5aOhqWHOv3OT0HmjNgyhZ/gQZ657Qky4uf6fJx8aa9RvpvY3FSxo5PgCBikJY9oJlu8jdop8M9Upzc0bPqpiaLx3JXILI11Xl8VuNTCYPyeb4QVn87X87m2XfAP1qxk7NELPlhhiuOmi0g7YFu855KvWrIs5E/YrPnhX6ckf0Ao5+n1uPD/XX6VFqSboYVupiyxieOiqPxy88muv/tb7R7pC9Ux3cee5RTOkgc0ciaZYYvvPOO5k5cybLli2zPMNffPEFixcv5umnnwZg6dKlnHxyCxnthbhpjySJWHxqoUIYIs4SY5hF3Nglx9AkiXix21UO2rJJ1r6npOA7snr20S8dAaT2Zr8xeS7FZQ+LLzPZdrCaEXtesioJlZqbb7QBYTvWw5WeRnMWox208rOT2FxQQY8Ud/hrHnqW/mNgVYajbJvQMJ3N4nEkJLns2PFRXVMdfQVj8ky0aDWzymsK3TDMTn1GznCzKsNHQKLTzl/tP6OyzsfldQ5SINgsx/ALV9R6rdcVj02iOdXCWCcH+QMay7cW8laU3N+F/umMsu0ikVp2armWR3XRLhu3TQg23IAQz3ALj7dis7HP0Y+hvm9xbjMEcAxJErHEbZlEem9j9ZIu9Ic3Euq9f0mY/3hLoW79Gdc3nWNSKmNqvtRScwlCCfUUmxXUaHa4UKIdG3PS3PzJfxK7Mk/gqbMv0Fco36//n5yjXyE0EzmqD4GzXzBWzZnSuBgGvfFG5QFDDBvHplrDZhRD97mMRBcaelrK3PNH0jNVP26/vmYvv3tjI6+57+NY7xaUlLeAvk09XbvQLDF85ZVXMmLECP785z+zaNEiAIYNG8by5cs54YQTACy7hNA+tEvGMLH71DKSnNz/o1H1RGHjl9Z0osXawJHZJABKHTng+Z7qol1QblxKdqeDK5n9pfqOJVpVODJF4/98ZzDXdykz1bfqWUKihbw3hvn+lVZU6x3x7NHfT9MznJogaYlCdC489DiPuxexcsdVcPIfG1wv2gS6AbVb+IW6gh6lVUBEzmxkZdjftmIYoEeKi8o6Hwcr6hjYIzlEDIf7hVPc9rDX1RTNqRbGKuhW7yzmvqofNnj/b7w3hd02G7x8V1DEcNCbLQC13gZsEi1AWVI+lH1LUqXhBeoxrPEHEFvcViihFfVYPKgm83wX8yv1A1QlUC+RyEzvGZqTDA2c+0XS3LkEDRF5paAxO1xTky1zU90UkcGKKkewY1yFUSFOydOvfiT10P3DVQchvV9srZhN3GlBMWxidqSLQQx/ZFTizxqZwwXjghPlpo7K43dvbKTOr6CoASj7vultaSeafeScPHkykyc3bVIX2gfLJtFGsWoWTfjUnvp4O2w7xA+GZEcVws25tGZi2iTym2GTAKhOyAMPeIv3Br+0afpZbGN+4Wjdnn6qfhy1g1a8l1IzEp086/gTZ65YC3nPwZif6HfsWakL9axBoDqsNAmxSQgN4jAyZM30CJP/3qNnyJ5wHfQ/IWrO8MiyT7jC8QIrD1UBPw1/fERl2NNKlcrGGJJQSZaylerCDBh4gj7pddSP9Xa9QGGZLtjjnTwXT7Uw3slBzY2Xqqwy3j9HZGW45SdKezOHQNkHIbeH8uWOw41epTuSrN94PKjXq2+gKgECNge2iEQiszI8LDeZuu9i34ZY5xLEQ+h4NDd9x/zcllZ7qfX6dUuMWRlO1T3zJGUbYtgQwbF0nzMxBW9NqbVIiaH7nMmyrboYPm14z7DlGYkO3A4b+zVDkJd3QTHs9/t588032bxZN4WPHDmS888/H1Vtm+QCoXFCJ9C1Bw1dfnY5bHyy7RAffFPI8q1FlNZ4yU5yEdA0bvv3181uo1lS5bGsAv0yE4HYz+BNvu07g+cOHsWY5EkcU2ZUQtL0s9x9ZsZwlCSJ5nTQivWAkZHkpA7jhKbamDQX8MPfpgIa3LINknuGRKuJGBaiozl0j2k9Mbx7BexdCWMvBHS/I0BSSJqEeUVC8UeZ5d+gZ7jtjgU/9y7iNNe/+WrrL+GEE/RKWciEIfNkNt5YtVirhc2ZHNRUBTmPw/RQSjmgZXCA4GtJdxieb+PSd51ZGY4x1zkmls1n28FqXt2VyAkhiyf/9Xt+ZnsBVQlwg29GizafMB83dVQeV5yUz7Ofhsd8hVZQr1MXcZPjdbaNuJ4hP703LKPYe+It7Diof8aH5aTwVRxi2Pz70QTr/63Yxb3vxj8JLnI8mmPNSk2wk+CAywNv4XlrCe5z79O/d44kvTIMuuh1pujd6CA+Mdz7WD2/OlT4mjYJsxJNdAvju1/tZ+ehKlQbHD8w/HUoikKv9AT2lxjLu1plePv27UybNo19+/YxbJh+2WT+/Pn07duXd999l0GDBjXxDEJr0x4T6GJhXN90spKdHK70cNnfv2j280RWWM1YtdxUNwlOFa83fjGs9h7Hsi+dOKvToMoQnml6bFOB1X2u/o6+OR20Yj1gZCY5KDZaMltiuKYUy3VmpEmYHeikMiw0hOLSP0c2X8R1YytnWL+iErRJBMWsorqMx0aJVrMqw+E2iRYVZ00QSOwBpaCYKRIRNDdWDRquFkJQEDdk3WqMpiwBN9lf4yf2T1jg/TlP+c+3Grz0TzXG1W6I4VaoxG87WM2QTY8z2jfVUgnlWgI/s31k2UWgZZpPRKuomzGW543txRlH9QyroO789138ovp1VvT/DZN+eq/+gJCM4rLKOrz+8SS77PROd/NVM15/NMF6+eR8nvus+ZPgjgRFUchJTWRm5Vukfl0NJ82EE66FSbP0jogAF74Caoiki6UVs8nZDwR/9xotyxPSIHuYdQxsysLoD8DZj31a73vQOz2BfcXGNnQ1MXz99dczaNAgVq5caaVHHD58mIsvvpjrr7+ed999t0U3UoifEqMynN7BxPAH3xRyuLLhDMl4MSusu60kifgnz5mY+cEFZbVw8m/1HY1fP/jvb8QmEU+3p3h3kOmJTvZgRBkZbaGt/11poDrw+QPW5KCGotUEwebWP0d2X1X4HWbOsCuFQECj2qwMu6JUhgNRvrs3bNAFsc2OP6DhN46OzUmTaC5Kij5RzlFrCIAlv9ebVRx/DWQNalasWiiR1cLsJBcocKiyrtmNZZqaVFWDfnLhVjxhDV4UV7Ieq2ZcHm9pm0TkHIiN/gGMUndRoSXUmwNhbvNt//6aFLfDajN9yrAe/Gv13ob/SAShFfVar59lhgf1ihPzGds33Vpv0qAs3LlJPLR1BhuZwaTQJzEE8aH9eq770JzkFo0VPdJJcEdKTqqbwooMUpVqPfKs53D9Cohq7PPVCDnn9x5RK+bAxGtQT9QbUB2JhbFXWgL7tC5aGV6+fHmYEAbIysrigQceEB9xB6HUqgx3HHFkzjJuScwK685DZpJE8/zCAL1SFM63/Y/BxWWgTTbaMDfdijnWbk/mZdZ4dpCZiU5KIivD5v/GZWCz6x7oE4QEIRqqW/8cOSLFcEgHuipP8LMU6hlWDAuELZoYVpSgRcITzJprywl0jjT9wJtQZ/glv/63LhiOvghoXqxaJPFkB8dKY5Oqag17lJu6sAYv2rhLYcKvrXUbzBluJtHmQPg0G71txfXmQJiU1ni56LlVTTabiLzfBlx/+hDqfAH+t+0QKPpkrGqPn15pbsb0qe9XVU/7HQs3/Y+0PaUEAhq20H3pyXN46/0twA6G5zWvNXNjHMkkuCMlN81N4feZDGVfMF6tMU67Q/+JJ/9Rq//mHUk6iGrTbRJfhIphszFOB6NZR06Xy0VFRUW95ZWVlTidHasS2V0JRqt1nPcj3lnGTZGe4CCgaXh8Aavzj6JgVabipVdaAo87n4AA1JbfjTtNnwygaZpVGe7dQMONhlI0Qn2FzdlBZiY569skqo3KcET3uSSniqMNq3FC58KeoH+OnIGI9r6mx9CVTJXRcEO1KWHiqlExHPpUIdFrbSmGEzL171SKr1jPSzbtEka02pFWhluTaB7VJJfKsqdfA+CCkZlc8bPTGmzwYnWgayFbSnPmQJg0tOuN7My3r6SaO97cSJ0vwKMfbov6mLIaLx98U1hvf3lUXipuh42yGi/fHapicM/wJiBbjclzw3Nbp89Be7Wgz011c0AzuphW7Ie/nQ3uVDh/oZ6asmclfPqQ3oVuWkhaTGOtmE2+/BssvUdv63zOY2F3HUk6yKRBWfRKd7Nfy+Jb10iGDh1hVKw7ji4xaZYYPvfcc7nqqqv461//auUMr1q1iquvvprzz2+8e4zQNpRWte8Eumg0d5ZxQ0SrRvxr9V4+3nrQ6tYUD2kpyRzS0shWyrA/cwIMmwpT7qfE76bWG2xdGpUoKRrBS6lH0zPFzXXN2EFmJDkpNWwSgarD2KBeZbip7nOCAGBL68OH/nEcdvRniLnQ7wOf8b10JlNZafiFnWrYJWZTDKvRxPBrvwSbHab9kTqfkVihgL0Nu0wlmy2ZtTLdK2n6KI1LxFZluBme4bYgsuq861AVdZouGHITNLApDRb4Wtom0Zw5EI0RrTPf+xs91nY3RJXHHzU1yKHaGNMnndU7i1m7u6SeGLaSJHJar+lXe+ST56S6KTQnUh7aDns+1383M4TrKvROkLmj439yxabn6teUWIvUl6ZD9SHqRsxt1vaax/te6QnU4uIa13z+++OO23uiWaeSjz/+OIMGDWLSpEm43W7cbjcnnHACgwcP5tFHH23hTRTixesPUGF4SDvSBLrmzjJu6pgazbd03csb2HA4voOxoigcUvVqsL36IKx/CRwJ7Dcmz2Unu5o84Jg7yQuO7s3kIdlMHpzNBUf3ZtKgrGZVCpKcKkVKD5b5x1Ldy5jXbYlhozIs3eeEGFByR/Nr7295WLk0uNBTqQtZAGcy1Z76GcMAZTkTucozm1eSLwl/0kAAvlkEX78KAX+w4YZqa7M28ABZPfPwawo2NPyF3+gLEzLB7sTjC3DImKfQnAl07UGCU6XGTJHxhVfybR/eDU+eABteAYI2CXcLVYbNORDXh2QrD6t7gYe8M7jZ8TrXqYvier7QSiHEb5eb+/amelf7jumvV0jX7C4JW15e62Wfsb8entvyNon2JDctpDK834iec6boKRAQnChnRqv934/gnz8LRrA1hpkiEZIzrBzeBkWbyEx0NWt7zeO9Oc9mf2kNWhQbRkehWZXh9PR0/vOf/7B9+3YrWu2oo45i8ODBLbpxQvMwY9UUpWNVC+MJVAfdBvHEReM5bkAmX+wsZtY/11JqVEEbI7Rb05yARjwjUO7KhRrjsl1KHqgOSwz3itaGuZVRFIXixHx+WXEr7xx3IqMA+p8Ap/wOckYA0n1OiA0zHSKsHXNCOtx5SI9psjuprCs31g0/NPhT+7AkcBzjbenhT+oPSZewO/FUt33DDYCslEQe9v+Uci2BW8oPkwaQkgsEK1RO1UZmW+euNxO3XbU8wwFPdVjVSindA0XfgPFetXRlONY5EPFWiM33IZ7L7g3lso/vp4vCtXvCxfC3RlU4L81NWqIDr7fp40VnITfNTaHZkvnQt/r/qSEWEnOiXNVB/YrPjmWABraFTT95lJxhUxiPHNSPvLTvmp2iYVqTqj1+yiqrSXdhJdd0JGIWwzfddFOj9y9btsz6/eGHH27+FglHjDl5Li3B0eK+pSMh1tm45hY/8OPRTB6sn+3abEpMQtjE7Nb05e4SThyaE/PjPEl5YBZiUvWMYXPH3StKxnBbkJnkpKiizvKB03eC/mMg3eeEWDAnxNV66tACARSj/TKKYjVwMD3DkWLYasfsj7i0HRq1prrwGJaLtmy4Afq+5RX3TzlUWcdvKg7oYtjoPhecPOdq02r1keB22vg6kM9jvh9x5fCzCcvI8Ro7qMic4RYc81g7icaDWSlsjl0u8jHj+6UDsK2okpdX76F/VhLH9M9g8df6xLKeqa5mzx3pqOSmulkVOIpp3gW8c66G7YPbghnDAIlGZTjgg5KdWGWhhBiSiyIqw0rAh+LVE5rUxPSYG6FES9FwO1Syk51cWvsiaQ9fDCdcD2c2z3rRmsR89Fy3bl1M63WWnU1XpqSdWjHHQkOzcUOJNtGs+V2NouSiNoI/pTcYV5kOqT1JDZmch6LHRrX1CYb5PpZUVEIgs96EiHLxDAsxkGTzsMV1GW7FS3X1bhKT0+utE+w+F/4ZS/YWc4HtMzJrUoGTgneENuFQHXiMDOPW6IbWFD1SXByqrKO2tFBfEDl5LrV9Tmabg1O18Q0D2egbyIVDTg8Xw6Ztwh7Rga4lc50b6ST6xc6JzPrnWvDFVpyIrBQ2xy4X+ZgvdhWj2hT8AY3bFn0NhCc6bNhbxokLPmrW3JGOSo8UF5VKIpv8iVRXbdJnkpjd50A/oXWl6lcMigwbSmJm/ci1aLjT9f8NMezwh2SRu1KZOiqDpy4ez+xXNlDjDZrXY03R6JWeQEVBIorWcVsyxyyGQyu/QscmmCTRMcVRczI7m9/VKEa/k9Fx6T87HZgW/9d3wIN3vscs2yJutAd4dOMMTlzwUYtH5jRFRpKD/zpvYfBb+yH3Y32yg+rUZw07EsQmIcREYmIyGrrYra4o08Xw/vXwyR+hxzA4/S4rrzqs+xyQUrWHx5xP8n1NHnB78A6zMqy6QFGsynFb2yQABidWkaxsYVvaCQy+dZd+qZiWiVVraxRFIcGhUu3xU+uJqMJ6jcKAQ5fIVppEK5yARJsoNnlINg/8eLRVKYw3bzceu1y0XPZ4Mm+ve3kDvxyqMK2Jv9MZcKg2spNdHKyoo674e10Mp0Qch5KyDTFsdMqLNWPYFMOeCgj4gmLYlWoVX6aOyuOt9ftZvLGQGeP78ONj+sSWorFsPlf4D/CB1ZJ5X/C+5Q/q0W+n3k57IzlMXZDSDtp9LpR4J5qZO9BYa7IKkO7UONaYaNEUZselId5vqdN0UVmgZTHLpk8i8Wv6V8UMFX9/Yww5jy1ERqITj+l8rj4Mr/8Knjwe9q0BgjYJmUAnNIZis1GNLghrK42JMqV7YMs7sPNTAGsCXXKETUJ16o+zaxHVQLMyXK8Vc9sfWi6oe4fXXH+g9/Z/6p0Zk8OTJDpirFpjpNr9DFL2ETi4JWy5YlaGHWZluOVtEk1hXuGLTNeJ3HXnprnrpUGYdjmg0f15NCEdb+Yt6HNHuoplIjfVzUXqf8na9Ly+ILQyDMGWzCW7g7djwZ0KvcbDoNPAV4vDb8QthrZnBiqNHPHjB2UxaVAWTrvNOo43OEncpnJ+yd+ZbNMr+FZl2GyhHUv0WxsgJsMuSLD7XNcRR83p/jN9QCAmS0Nkx6VdgZ4MUIoYp2zjh/bP63VcigwVb230rGEjPqi6pF7OcFmNdJ8TYqNaSSCZGmqr9clXoRnDAJWGZzgxwiZhd+pi10GEGLYqw/qJtyWG26EyrCX3hEOgmm1oDQrKO3asWkOMsu/lOdeteN7pA8O/Cd5heYaNynALT6CLlSPJ222uXa45mbfNmTvSUclJdfPjg5/oN376fzD8nPAVLl+s2yJWPgUb/lmvFbM/iu3Fer9Of12vwBtXVLTsoSgRYrvSKLxEniw3yslz+HJ3Mb/47in9dvl+WPYALJ8Pp94RbKXdzogY7oKUdILKcHOIp/uP2a0pFqJ1XPJo9npC2KShGc6tRXqik1KM+JyqomAWpBWtJpVhITZqlQTQwFNliuFg9zkIeoYjJ9DZjcpwPTHcYzjcvg8C+vK6dhTDqtGSeWTpR/DObJh8I2T050AnrQwH7AngCakEG2hJPVF8tdZ71iqe4Rg5krzd5tjl2mruSIdk2Xx+XnMomChRURCsqkbaDfwecCSFVYbf31jQ5LEzzzx2Jg3C95PPcTjCjynmBNt4O50WjbuBh7cWcZPj30CgwwlhEDHcJSmp6nitmFuKWKsRDXVrikZzOy61dBORhshMcgS70B3egVUXT9AtIEHPsHydhcapsyWCH7w1hhiuMzqJGlml1gQ6Z3Qx7Iy0SdhsVlUZgpfs28Mm4UoP8U9++TeY8BsgOIGus1WGFSMtQvGF72f8l72LLUSktEaaRFsRb4vrVp870pGxqZxR+BxrMSJszfxg025w6h3BdSffoP8YnVpaymddWRfdRtUUvdITuMb/Y651/Aen5tOvJHUgIQziGe6SBG0SXasybBLqN47Zt9QITXVciuVxrUlGopMSszJ82MhAdqWBqh8Qg9FqXe/kR2hZ6lT90rqvxhDBEZXhygYqww6XLsyc+NACDcdqtadNIimrd/iC5J4EAhoHDDHcYPfIjophg1B9NdBIs4L2skm0B609d6RDc/IcNg69lvHqdv32/x6FjxcEhfDJc/Rs4RdnwH/v0dexqTH7rP/seIwNriuYYlvdoM+6wjjWRO4fmqJXupvr1EX6/kN16pXr5Q/G9RytjYjhLkhnmEDXkYi345KCfjkpdIZza5KZ5KTE9AwfMsRwYvBvSwc6IVZ2J4zgI//RlNmMiTF1hhh2hdskIis/Dqcuhm2Khi80Uqvwa3jzGvj0IYB2TZNI69EnfEFCBsXVHrx+DUXpfNVB1RhzhQD4G44xM8VwS3Wg68jEOvku9P5Y5450BkqOu5E1/pDmZh/fH243qCmG7Uth7xfWKrH6rN14SFWqSVOq+Ln/bfxPToaVT1v3a5pGlad5NonsNY9Zx9b91+3Rt3nZvA4liLv+t6cbEswZFnEUC2bHpZsc9TsuRQriaDOcW5uMRCffaXksDxwNacYB3/ALa5omOcNCzCzJ+w2/8s7hu5Rj9QXmBDrTM+xpoOlGQgo3eK7hGs/1ePwhFaOS3Xrb8q3v60/XHpXhZfNh+YNkZIRX/zx+jf3/mcuN9tdJdTuwdbIMfMUZkotsNkAI1GF/7lT461lWxFowTaLrV4YhviSLhT8fy9isrpEkAXqaxO98VwQXRNoNTI/w7s/gpZ/C4R0x2/nK0bvCpVJFH+UgSWXfQm2pdX+tN2BVi+OySSx/ENvH9/Oc40IW+qfrHV1PntPhBLGYDLsgpVbOsFSGYyXWjksNhYq3JhlJTj4JjOUTz1i2TMvHve0da5ZwnS9gVeOkMiw0RaLhBTYnwnDBn+GcP2Ge5pmV4cg0CafLxX8CJwIwL2DDaqZqtmOOiFZrU/+qTYVl83jlkx0cHRjORNsWdgVyWHTPldxkf52l2gzKarztkhF+JDgcLvyagqpo4KsFexJqwINywIioUp34Axpe4+SkM3qGm0trzB3pDOSkuTnL9iUAmupEMe0GpiAOjVLb9gFMnR+zna9c0205qUo1qYqRMxwSrVZRpxddFAUSnXGceAX8cOod/HfrSVBRrIthCG5zwN/wY9sQEcNdDE3TKDUrw0kijmKmkY5La3YfT1FFLf9qJCqoNUlyqjhVGx5/gMOJ+fQOqQSYk+dsir6eIDSG2Vmuyjiw6a2YgxXIhmwSqk2xOn6FtWT2GTnDEdFqbSnM3s+6hE3erdzEyyzVxuubhcpN9tfD0mDMjPDI3NuOittp51n/uUwYmM1442RDDYQ0ObHZqDNyoaF90iTak1iSLDqIzmoxUlY+bNkNpl/7OPnfPKFXV0EXl5G5wknZTMhIjanJSZlxiptOFVm2+jnD5gl0stMeX6dhI+Gi14H1AOwrDUlH6UCT6EQMdzEq6nz4jEsZ4hmOnyOJCmotFEUhI8nBgfI6Sssr6J3m1kUM4a2YpRW60BQnHXyZm1xP8fWOqcD/1bvfzBmO7EAHcKa6HjvVeKuPAzOZIbIy7G/bphvm5KAC/3Q09FhEgMG2/fViEdsjI/xISHCoPOC7kOv7DmF8QgZ4vahGhJ3VcMMbPDFpjwQPoQ1Z/iDKx/fzN+cvWFh7LieU1ZJviklTEJ90c/hjXKmoSjCjvzHMynCKUkV/VxV4CHamAyprjRPlZqYWmdGGn28/zLi+Ge1SWGoM+fZ0MUqr9J1lgkPF7ZBKYVchJ0Fjo+tXjPzbEL3znBGJJd3nhHhwOuwkKB5Un1H5ef938MbVcPBboOHKMMAD6hP82bkQf2lIO9UGKsNt5RkOnRy00D+dOk3fbk8DsYihGeEdHXNCnBmdBiGVYbtezTcnz9ltCnYRw10bw26wJOtSABZ/XcCKHYfxTL6FPWNns2V/CSt2loY/xiiQmD7r7OTwAlmoFjU9w5N62UlrxCYRb6wa6NFuL67cA8Bn2w9x4bMrOXHBR23aybUp5NvTxQg23BBx1JVISkzGjnFQfO50+FqvgAUzhuX9FppGcesRfXavIYa3vAMb/gW1ZfgDGjVecwJd/RNpr9ES3OcJmZATURlu66YboZODQmMRnU3EIrZVRviRkOBQyaaMhIpdVuqHzaoMm2K482YMC3Fy6u28n3UJ678vBeD/Vu7mwmdXMvzO91i0ZjfvbiziwmdX1n/c8gdh2Xymjsrj0Z8dDejJKv+68ni23Hs2pw3XrRVDBg9D6zWe7P5H4fDXF8NmZTjeWDUz49g8VpmYtqWOIojlG9TFKJHJc12SzGQXxWbWMIR0n5NYNSF2bEZzDetg5wlGq1WH+E+jHfC8iv4Z83tDhGREO2ZLDKttc1XKnBx0XYyxiJGP68i4HCp/dy7gxs0/hz0rALCblWFHeGXYJVcBuzymqKz1hud8BzTwazbr836b90oADuacFGzIYXSqqzAEbb/MRCujf0hPfZ9Q1OMElKuWEThzHrWONLTkHEhIt/5OlbF/iCdWrbGMY3PZ3Lc3Rc00bmvEM9zFkMlzXZP0RAelWgq9FOPyriGGrcpwgnyVhaZxJBhiOGCIYTNn2JlkTZBRbUrUSqPPqAz7QyvDk2bB+EutBjBtbZOYkJ/J75Le4ip/+GQ583/TQ2zeVtATYdoqI/xISHCo1GIUNYxoNQAtqQeK8f03PcNSGe7aNNU4I/Tz/l//eCo1NyVFe+lxYF5YDnFpjdmQK6gPzEhO03IHsHz4fUybNi2sHbPlGY6jMtxUxnGobam95+bIEbSLIZXhrklmkpNiLdj21my6US42CSEOHImpALj91XojB9Pm4EymstK4DOpUo07G9CkO0MDvrQt5woSwNIq2brqh2hROG5rFw1/N4M8RHmFTIJixiO2REX4kJDhVajSjUYhRjT+YOgrfzzdbIkVsEt2DWBpnhAriOs3OUG0Xe8bOpl9IYoNZLEtLCOqDVKPSa15lbIiKBrpTNkasdqSOYFvqUt+gAQMGoChK2M8DDzwQts5XX33FSSedhNvtpm/fvjz4YMcIfG4ppOFG1yQj0WlF3wBBm4RMoBPiwGWKYa3GmoSp35HS6OQ5AJ9NP4CG2SQi8BjirC2bbgz+2f2MuPC+qE0YFvqn86hvBqBXhDtLrBroE+jqolSGQwl2nxObRFcmVrFoTiI1vfPr8q8Muz/Yg6B+ZbiuqgweHY39oUFBb3oITe0fohGrHakj2Ja6XGX4D3/4A1deGfwApKQEfZbl5eWcddZZnHHGGTz99NN8/fXX/OpXvyI9PZ2rrrqqPTa3xZFWzF2QZfOZdKCKHaHnrgl6t61jdz9Hkr0ER8Id7bRxQmfCmdqD1YFhlCrpnGX6hVUXqA7rYNdQ5cdveIYDoWL4q1dh72oYdjYMPr19mm4QexOGzlARNklwqNSYYtgXXQxJZbh7EKtYDJ1E6lJ8jNv5LBx9j3W/WRlOT6gvhg/V2aB0Dwpw5jezUb1vw0//Ya1n2iTi8QxPyM9sNOO4I9mWupwYTklJITc3N+p9L730Eh6Ph7/97W84nU5GjhzJ+vXrefjhhzulGPZHaRCxrUg/wJVWe/EHtE618xcawKZy1JaFVDI0uEx1wPIHmVL0VzZqM8iSyrAQA+7sfvzUczeKAt/VVerWAad+xaGhVswm76T8lL8e2M9ZKSOCC79bDutfhNQ8XQz728/D2hEzwo8El0OlXDMrw3qjgj7Fn6O+8KR+8nHijdZkqu7Sirm70pSohPBJpH/2T+f2pLe4asMjkJkY4hk2KsNJoTYJ/dhRWhcAVyrUleP2laMVfxf2/BXNqAyrtmDGsQJh297RbEtdTgw/8MAD3HvvvfTr149f/OIXzJ49G7tdf5krVqzgBz/4AU5n8IMwZcoUFixYQElJSb3e9gB1dXXU1QU9cuXl5QB4vV683vqXEloSf0Bj5Y6DrDmkkLatiOPys1m3t5Siijp2H67mlS+/p7A8uG02RZ9ZCnrsytJNhfx+2nCmjMxp1e3siJjvTWu/R23CCbM5WFrFcese5QtlNONPOgc+mo/6yQO8mnwJCw+dzcMO5Yhfa5caszais42ZU9F3EJoG5UkDSJyzRxdaXi9l1fq+JNFhi/p6NiZNYrn/EMfae1r3q94abIBfsRPweq1MXBtag2PS2casvXAomlUZ9tdV4vV6SfQUYStYiT97KAGvl+paXdw41CP//ndFutJn7Y6zh3HdyxvqiUqoL4QBep13J/7iAajL5uH3+wmcdAslVfrnJcUZ/I4nGiqwvMaLlpqGUqdrnIArjUDIuFUY81Pc9vg+a6cPy2bhz8dy3+ItYXolN83FHWcP5/Rh2a32/sTzvF1KDF9//fWMHz+ezMxMPv/8c26//XYKCgp4+OGHASgsLCQ/Pz/sMTk5OdZ90cTw/PnzmTt3br3lS5YsITExsRVehc6GwwqLdtko9SiAygvb1qOgoRF6BmX2VNIJaOG3C8trufbl9fxqaICxWe0fXdIeLF26tL03oUU4XDueEiMuyv/pZlTNx+a86TxeNBWAb79ez+Lv17XI3+oqY9aWdJYx0zRQUNFQeOu9paSGuKlWFer7moqSQyxevLjeY4sP2QAbazd8RULhBgCO27eHXsA3W7az8/Biig6pgMJX69cS2N34PqezjFl7sbsCNgdG4NQU8vdrHFi6lKMML+eu7wvZuHgxXx7Q37Oy4oNR3zNBp6t81n45NFQX6ChoqErASlNJd2pMHxDAv3sN7zCCoXnTUb7dwtaKxewt0r+fW79eh7JX/36WewDslNd4KXMppBvPe6Csli9CPlO79+vf/+2bN7L40Ndxb/utI2BHuUK5F1IdMCi1Cv/uNSze3dzRaJrq6uhe+2h0eDF82223sWDBgkbX2bx5M8OHD+emm26ylo0ZMwan08lvfvMb5s+fj8vlatbfv/3228Oet7y8nL59+3LWWWeRmprarOdsig++OcDfV2yod/YXLoSBGG4rwHsHEplz0Q86xKWItsLr9bJ06VLOPPPMsHiYzkpVnY+j19m51v4mLnxoqpPBv/oLPPwpVNVw2g8mMa5v+hH9ja42Zm1BZxyzMevGkMthika/T+9Bo63l+z7bCTu3Mahfb6ZNG13vcRsPvUl22VaO7TeZaaefCID6yotQCiPGjOOocdN48rvPoaqSEyZO4MTB0S0KnXHM2oNvD1Tw8EY7q+0nsfLCU/B6vRT8/UUABgwZQb9Tp3F45R74bgt9e+UxbdrYdt7ijkdX+6xNA+YENL7cXUJRRR09U1yM65vOcferVPsCLJg+igvG5kUc66cBMAi4f+NyoI6zTp7MqN66fqnz+rlzzYdoKCRl94bv9U5xPfsOYdq0adaz/HXPSigr58Tjj+W0YT3a5gUfIeaV/Fjo8GL45ptv5vLLL290nYEDB0ZdPnHiRHw+H7t27WLYsGHk5uZy4MCBsHXM2w35jF0uV1Qh7XA4WuXL5Q9ozHtva4O+oHjRc/zqWPd9Raf2zzWX1nqf2po0u50bHW/gUnQhrPg9OD5/hPIa/QCYmZzQYq+zq4xZW9KZxixJqSOROlw7P8Kx+VnocwwcdwW1Xn2vk5LgjPpazip/jTucH7CyqA6H41R9oVGptLsSweHA69efI9HV9Hh0pjFrD5IT9ONOrddvjZNqjLfqSkJ1OPAZB4oEp13GshG60mfNAZw4NNz6mJuWwHeHqhiQnYzb1fDkeTNnODs1eLxwOBw47TY8vgA+ZyrmKCmJ6dhDc4aNOQVpia5OM5bxbGeHF8M9evSgR4/mnYWsX78em81Gz549AZg0aRJ33HEHXq/XGqSlS5cybNiwqBaJ9iCWPMHm0BFy/ITmo3zyR25UX+Mh7wymXPkwo7Y/A8vmcblvBo8zXaLVhJiptSVAAJyFX8Lu98BbBcddQWVd4xPoNKPLHH5PcKH5e2QHOkk3OGISHCpOvCT7ytAqi8CVgRrZgc6cQOeQ8e7OZCU7+e5QFYerPA2uU+v1W9/P9Ijo1VS3g0OVdVSlDiaBD/SF7vSwdZoTrdaZ6DLfoBUrVvDoo4+yYcMGvvvuO1566SVmz57NxRdfbAndX/ziFzidTn7961/zzTff8Morr/DYY4+F2SDam9YSrR0hx09oJkZLzRfcF7HQP53iKg+cPIfaE2/jJrveglM60AmxUmfT5zqoVcZVMqceP2m2Y052RU8m0GymGA5pumG2Y7brVcy2brrRlXE5VH6kfsYq50y0/1wHgKoZE4Ls+v7cascsaRLdmqwk/ft3uLKuwXXMWDXVptQTtGnG8WP7mJvxH/cbau3paInhV5KbE63Wmegyr8rlcvHyyy9zzz33UFdXR35+PrNnzw4TumlpaSxZsoRZs2ZxzDHHkJ2dzV133dWhYtVaWrR2pBw/oZkE/HDqHby39QdQetjqMnhw/A28umw7LlWTg6EQMx5DDDuqi/QFRrRapVH5SXQ2URn2hVSfLvwXeCohSb/61l45w12RBIdKrWZmO+vRagFsaI5EFOM9k5xhAfTKMMChyoYrw1Z32gRHvQ6TZtZwWY2XwFnz+MA3mWnjg35hf0Czohe7amW4y7yq8ePHs3LlyibXGzNmDJ9++mkbbFHziCVPMFY6Wo6f0ExOvR2AjL1rAFj+7UF6prhx2W0s9E8n1WHnmB2HO11TAaF98NoTwQPuWkMMu/Q2301dBtWM6q8SWhlO7gn0tG56pFLZYjhUBY+ii5yApxoFWJM/i5xp00LaMZs2CRnv7kxWslEZrmq6MhxpkYBg1nB5TfQosipPsFVzPO2YOxNd81V1YhoLqW6K0Jxh0CvCd583otO0HxUa5v2NBXz87UEAFq3dx6K1+zBP7strfVz47Ery5P0WYsBvN2wSAaOK5DTFcOOeYVRTDDdcfRKbRMuhKAoBVfcGm003IrE8wzLe3ZpsozJ8uJHKcJnZcCNKd1qzMpy290Psnz7EcUoOZgoFBE+UHarSZT9rIoY7IFNH5fHUxeOZ+/amsMl09cRuqosLJ/RjQHZSl2g/KkTn/Y0FzHxxbf2ovYgFhWW1zHxxLU9dPF4EsdAghxMH8kXpUI6zfasvcOme4UqrHXMDVUazMhwIOeAum6+3Cj5+Jv6kHPzGDsqpds0DZlsTsLshAJq3pl5wJkCt2CQEQj3DDYvhaK2YTX5U+g8GqBXU1B2PUraHXuzBW74PsgbA8gdxVlQDx5HsstezWHQVRAx3UKaOyuPMEbms2F7Ekk9XcdZJE5kwsEeTYrc7xqd1ZfwBjblvb4rpCoHZcmXu25s4c0SunAgJUVnT71f8ZdcpfNjzMQaVrwpWhj2N2yQOZE/irq1l9Egey3Hmwi+eherDMPbneFzB1B+pDLcMAXsCeEDx6kWR8bueQn35BTj7AcgeEpImITaJ7ozlGW7MJmFYINKi2CQcDgc3O15nbVHIBH7FZk3erhuvz73qqhYJEDHcoVFtChPzMzm8WWNifiYOu03Ebjcj3qg9PVe6ltU7i+WzIkQlyZgg90K/+5g7pV/MNomKzJG84NeY6grJZPcFo9XMyVwgYrjFsLt1MezTbRI9KjZjKykFr95ZSybQCRCbTcKcQJcRxSbxzZCrWb2zmJuLX7eW2dY+D589BKfewY5ev4TPV3fZyXPQhaLVBKEr0tyoPcmVFhrCtEGU+hyQkltvAl1SA2kSLsP6YPqCgWDMmt1lTZ5TFLDLVYkWoc6VwWu+H1A44AIAbJohdhy677tO0jsEgjaJshqv9T2MpKwRm0Sq28FC/3SWpP7YWqYaQpiT53T5WDUQMSwIHZrmRu1JrrTQEMOLP2S16xou3nuXtcwf0KjxmpXh6Jfck/1lTFQ206t6i75A00KabriCDTdUW5f1FbY1tc5sfuu7mm9G3wqETHqUnGEhhLQEh2WLMyvAkTSaJmHkDD+XdCWaTf9dU51w8hwAKqz5BCKGBUFoB8yovVilhQLkSa600Ahuu0JPpZTjqj6BxXOg8mBM0Um5JV/wiuteflHytL4gNFXC7pQkiVYgwamL3FpvAAJ+VM14n6zKsGGTkA503RqbTSEzycwaju4bLjXSJNKi2CTMDqbnlvwfSsCHX7HrqTHLHwSCDTfEJiEIQrtgRu0BTQpiyZUWYsGRkBK8sfoZ8NVYFgm7reHoJJtDr0bazUv1vhArjuqSjOFWwGVXSaCWQOVByycMgPFeSLSaYJKV1LhvuLE0iVS3g+vURVxa+xL+H9zGO0f/Df8PboNl82D5g9b+QWwSgiC0G2bUXm5auPUhUu/mprklVk1oEkdCavgCZ3LQL9xIdJLq0H2JVkvg0E50qlO6z7UCCU6Vr11XMP3Dk6F0d/AOu54/LDYJwSS7icYbphiONoGu38Y/c7PjdRZqPyVw0i0A+v+n3gHL5jH2u78AXbsy3HVfmSB0IcyovdU7i61oPcmVFpqDMyktfIErharDVQAkORsWVcHKsCGGEzJg1he6XcJmE5tEK+C226jBRQo1KLWl+BUHNlVFseljbNok3GKT6PZkNZEoUWo13ahfGXbZNB7yzmCh/4dcETpB1vAMezftB7q2Z7jrvjJB6GKoNqVeXJrEpwnx4goVw6oLVEdYZbghVKdeeXKYYli1Q4+h1v2ekAl0QsuQ4FSpxUEKNWgJmbx79F+ZdvZUTDkjlWHBxGq8UVVfDNd6/brvnAZyhs+4g4XL3gOgss4ffufJc3irYB3s3t+lK8Oy1xIEQehGuJODNgnNqU/EqoxBDNsjK8MRWGJYKsMthtuhUqsZnf/MlsxKcHxrvZIzLOgEK8P1bRJlRsMN1aaQEuU77lBtJBpXhcpq63+/JVpNEARB6FIkJadbv2s2/QDaVPc5AIdTF8MOjINl+X746D5YqadLmJfsRQy3HG6HSi2Gx9NovGGiaVqwMiw2iW5PY403zLi19ARHg3MCUt16xbiixlfvPolWEwRBELoUCYnJXOq5DYBAgh7BV1nXeMYwgC01hwXen/NE4Cf6grLv4ZM/wqqnAMJyhoWWwe2wUWOIYWXvKibseATbh/cA4PVraEafdrFJCKZN4lAUm4Q5eS6aRcLEzBouj1IZNm1UXdkm0XVfmSAIglAPRVH42jGGCbVP8Po5x9EPqI7FJpGcxVP+87FrCr8H8BmXY1X9ICw2iZYnIaQyrBR/R175OgJ7wifPgdgkBMhsxCbRWKyaiZk1XF5bvzJc2Q2i1bruKxMEQRCi4nS5OFCXQbkzF2i6FTMEK76+gEYgoGGzWjHrB2FJk2h53A6VT/2j8aX2Y2JCur7QER6rBiKGBcg2J9BFsUmUWUkS9WPVTEybRHmNl+SI+4JNNxoW050d+QYJgiB0I/wBjYd997PSNYtd6/6LxxdgW1ElAKU1XvwBLerjnCqMUr5jvPItHq83mDMcURkWYdZyJDhUFvqn82T6b9F6jtQXRrRidtql/bUQnEBX4/VT7Qmv7jbWitkktZHKcNAz3HXtOFIZFgRB6A4sm8+2g9VcuuMUVgTWgALVK//B8P+5mWVbxI32AI9umMGXu4q5+7wR9Zq3OG0B3nH9HoCy6ktwW5VhsUm0FmZ+cK3XH0yTMFsxS5KEEEKiU8XtsFHrDXC40kNiZlDelVg2icYqw0HPcK+Q5R5fwPpup0hlWBAEQejMbDtYzZBNjzOj8p/WstPUdcyyLeJmx+v4Nf1wUFhWy8wX1/L+xoKwxzuNDnQA3rqakMqwYZOQynCL43aogIbPUwO1pfpCR3hlWCbPCaDPBbAm0UX4hssaabhhYnqGKyIqw6aFCrp2ZVj2WoIgCF0cf0Dj0h2n8JB3Bjc7XreWJ1DHzY7Xje5T0wEwTRJz394UZplQbDbqNP2A6fPUQmRl2C9pEi2N26Fyj/0fvFkyHXX5fAC0CJuEdJ8TTBqKV4vLJhERrWZOnnM7bNi78HdbbBKCIAhdnNU7iykoq2UhuuA1BXGSUhcmhE00oKCsltU7i8O6HHqw48KL11MLw8+F3NHgSNLvE5tEixOaJmFhTKCThhtCJFnJZhe68MqwFa3WSJqEOYGurNYLScHllXVdf/IcSGVYEAShy1NUUWv9vtA/HY+mX+70aPZ6QrihxwF4lZDKcGIm9BpntWSuEzHc4oQ23fCP/yVvHf03AqfeBYhNQqhPVpL+WTkUURk2m25kNJYmYeQMR9okukOsGogYFgRB6PL0THFbv1+nLsKp+KnT7DgVH9epi2J6HICXEDEcQbDphoizliLBoVKrGTnDvho0xW7ZUqwJdGKTEAysynCEGDbbMcdmkwhvuhGMVRMxLAiCIHRiJuRnkpfm5np1keURHlb3guUhjhTECpCX5mZCfmbYcrMy7PfUwq7P4NOH4bvlgNgkWgO9A50ucDRveDvmOpmwKERgeYYbsEk0niYRfQJdd4hVA/EMC4IgdHlUm8ILgz5myKbXeTjEI2z+b3qIF/qnYybW3n3eCFRbeH7tm87zqK0s5RR3DmxfBJ89AsdfAwNPlqYbrYDbGbRJqJv/w/iMIpTdqTD4VLFJCPXIijKBrtbrp8a4itBYO2bTT1wW0Y65qpt4hkUMC4IgdAOG9Ehk24jreW3HKVAWtDk8EZgOXlAVXVzlprmj5gwDLE68gE1l5Rzryo0SrSYTuloat12lRgtW8/qWrMBX9j0QbMcs4y2YRItWM20Pqk2xsoSjYVaGa70BQpobWjaJru4Z7tqvThAEQdA59XaGAJ8FNFbvLKaoopaeKW6O6Z/Bmt3HU1RRy79SdGtEZEXYxKz6enyB+tFqYpNocRyqQoHSkw/8xzJF/VJfaEareY3KsEMqw4KOVRmuClaGS0KSJBrrVJjitqMooGlQ4w8uF5uEIAiC0OVQbUpYXBpQ73ZD5CmHqFP2odXkg88Qw2Zl2C8e1pZGURQ2qcP5jWcIW/IW4C7aYEWriWdYiCTbmEBXXOUhENCw2RRKjSSJ9EZi1QBsNoVkl52KWh+hUcPdxSYh3yJBEAQhJmaWP8Z7rtvJ3Pcx+I3qU2RluAsH87cHCU6jIuc1rC12Uwzr5TtpuiGYmNFp/oBmJUiUGv835hc2Ma0SoWK4u9gk5FskCIIgxERA0Q+2mq8upDJsRH2JTaJVMCfIKZ4KfUG9ynDXvnwtxI5qU0gyTp4+3HIAjy/A2t0l+p0aYR0lo2HGq1X7g3YKM2fYfN6uiuy1BEEQhJjw2/SDpearC6kMmxPoRAy3BsPU/Wx3XYyraj8QbMcsHeiEUN7fWMCJCz6iyqN/Lm557SuG3/kez3zyHQDr9pZy4oKPeH9jQYPPkWY03gitDJue4WS32CQEQRAEAU0NqQyfcQ9c/i4MmQKITaK1UBwu7ErI9H6pDAsRvL+xgJkvrqWgLLwZTmQhuLCslpkvrm1QEFs2iZAJdEHPsNgkBEEQBIGALUQM9xgGA06EVD2CTWwSrYPNEL8Ai0c/CRn5QGiahIx3d8Yf0Jj79iYaN0DomOvMfXtTVMuEaZMQz7AgCIIgNIBZGbYyhkOQphuthDPR+tVvc4JNrwRLzrAAsHpncb2KcGNoQEFZLat3Fte7z6wMV/uieIa7eGW4a786QRAEocXQjMly+OtgwytQWwbDp0FaH8smIZftWxY1RAyrgWB3MLFJCABFFbEL4aYel2p6hkNsEpXdxCbRtV+dIAiC0GLsTT+OdfurSUs6mkmfPQwHt0CPoRFiWCqVLYnD6bJ+H7/7GdBmAJIzLOj0THG32OPSImwSmqZZYlhsEoIgCIIA7M3+AQt8F7I5aWIwWs1INxCbROuQEOIJzi1fD0YXsTozTUI8w92aCfmZ5KW5abi3XDgKkJemd5qMxKz+HqiGVTuLKa/xWd7ib/aXNxnN1pmRb5EgCIIQE+HtmA3fsOrE5w9YB0pJk2hZ3A6VzYG+9ZaLTUIAPVv47vNGADQpiM377z5vRL2W6+9vLOD+xZsB2F9j4+K/fcm4e5dY9//q+S+ajGbrzMheSxAEQYiJJGropxzAXVsUUhl2WVVhkMpwS5PgULnFezUANY4Ma7kphqUDnTB1VB5PXTye3LRw60OE3iU3zc1TF49n6qi8sOVmNFtJtTdsebzRbJ2ZTmMCmTdvHu+++y7r16/H6XRSWlpab509e/Ywc+ZMli1bRnJyMpdddhnz58/Hbg++zI8//pibbrqJb775hr59+/L73/+eyy+/vO1eiCAIQiflqAPv8IlrAWsLTw6pDLssvzCIGG5p3A6VBPQTD7/NaR20g2kSUhkWdEF85ohcVu8spqiilp4pbo7pn8Ga3SXW7Qn5mfUqwvFGsyno0Wxnjsit91ydmU4jhj0eDz/5yU+YNGkSf/3rX+vd7/f7Oeecc8jNzeXzzz+noKCASy+9FIfDwf333w/Azp07Oeecc7j66qt56aWX+PDDD7niiivIy8tjypQpbf2SBEEQOhWKXZ/MpQS8IZVhpyWGFQXsXegA2RFwO1Tcil6x8xvtsCEkZ1hOPgQD1aYwaVBW2LLI25EcSTRbU8/dmeg0Ynju3LkAPP/881HvX7JkCZs2beK///0vOTk5HH300dx7773ceuut3HPPPTidTp5++mny8/N56KGHADjqqKP47LPPeOSRR0QMC4IgNIHNoYthNeDR49UAVJclzJyqDUURMdySJDhsvOicD0Ba7V7MC9lWZVhsEsIR0JLRbJ2ZTiOGm2LFihWMHj2anJwca9mUKVOYOXMm33zzDePGjWPFihWcccYZYY+bMmUKN954Y4PPW1dXR11dnXW7vLwcAK/Xi9frbehhLYb5N9rib3UlZNziR8YsfrrbmGk2PXpJDdTh+8W/wVeH5kimukK3TDjttibHoruN2ZESqXXNcas1TkBUAjKWDSCftabJSmyeDMxKtHf4cY1n+7qMGC4sLAwTwoB1u7CwsNF1ysvLqampISEhgUjmz59vVaVDWbJkCYmJifWWtxZLly5ts7/VlZBxix8Zs/jpLmNWu3cfEwDNU8u7m6v0hdv+y74qADv4vSxevDim5+ouY3akbDmo8KF/HKer69ic92O+NcatxqMCCv/7ZDmbXI0/R3dHPmsNE9Ag3alS6oGm8ygANNKdcHDTSozwiQ5LdXV1zOu2qxi+7bbbWLBgQaPrbN68meHDh7fRFtXn9ttv56abbrJul5eX07dvX8466yxSU1Nb/e97vV6WLl3KmWeeicPhaPW/11WQcYsfGbP46W5jtnF5NXwGbjXAtGnTrOVffV8GX60iJTGBadN+0OhzdLcxOxJsnyxgeG0NW9ALNT6bizPPPBNVtbN99UxUJcDUs/5MVpKziWfqnshnLTYcAw5w3csbABqdSKcY/943fSxTRuY0smbHwLySHwvtKoZvvvnmJpMcBg4cGNNz5ebmsnr16rBlBw4csO4z/zeXha6TmpoatSoM4HK5cLnqn3Y7HI42/XK19d/rKsi4xY+MWfx0lzFzuPSrYcmBChzrXwBHIhx9IQFFv5bvcqgxj0N3GbMjwu5k2OY/4mEAoHu1HQ4HfPoQNzte5yHvDJITXDgcXeYib6sgn7XGOffoPtjtKnPf3hQ2mc6mhMer5aa5ufu8EfWi2Toq8bzn7foN6tGjBz169GiR55o0aRLz5s2jqKiInj17AvqlkdTUVEaMGGGtE3kJb+nSpUyaNKlFtkEQBKErE0jryz98Z5LhVjj/3ZssMWymSUjDjRbm5DnsLalm9PpHAOhb/D9sn/4J9ZMHeMg7g4X+6VwvaRJCC2BGs63YXsSST1dx1kkTmTCwR5PRbF2FTvMt2rNnD+vXr2fPnj34/X7Wr1/P+vXrqaysBOCss85ixIgRXHLJJWzYsIEPPviA3//+98yaNcuq7F599dV89913zJkzhy1btvDkk0/y6quvMnv27PZ8aYIgCJ0CLWMgd/t+yb+Uc/UFqn553kw2kIzhlqfk2BspCOjNNpLrClA/eYDKE25loX86NomyE1oQ1aYwMT+TY7I1JuZn4rTbmDQoiwuO7s2kQVldVghDJxLDd911F+PGjePuu++msrKScePGMW7cOL788ksAVFXlnXfeQVVVJk2axMUXX8yll17KH/7wB+s58vPzeffdd1m6dCljx47loYce4rnnnpNYNUEQhBgwxa4SCHafA4KVYRHDLY7bofJDz734saEAmuqk5Ngbrfskyk4QjpxOYzR6/vnnG8wYNunfv3+TM5lPOeUU1q1b14JbJgiC0D1w2jSyKSPHb7RjNcRwndgkWo0Eh8pP1Y9RCeBX7Kh+D4krHwLGS8MNQWghOo0YFgRBENqXhJpCvnTPDC5QpTLc2mR8+Sg3O17nYd8MBh57PuelbiLrkwe4Tp3Ba/ZftPfmCUKXQMSwIAiCEBNOV0TqjmmT8Etr4FZh+YMkf77Amiz3kOYjcNItFFbUcfO6R0jXHMDp7b2VgtDpkT2XIAiCEBMOlzt8gTGBTirDrUTAj//k37HQPx0Ajz7M7B55LQ95Z+C0NZYKKwhCrEhlWBAEQYiJUDFce97TuDP0vFERw63EqbejAvali/EFNIwOzNT5Aiz0T2d0chqXtOsGCkLXQMSwIAiCEBNOZ4gY7n8q7my9oZEphsUm0Tq4HSqVdT48eoKdFWUn4y0ILYN8kwRBEISYsDuc+DU9ysvrCXaqMj3DkibROrgdKkBYZRjA5ZDxFoSWQL5JgiAIQsx40FucOr96CfauBkKi1aRS2Sq4DdFreobrvGYlXm2vTRKELoXsuQRBEISYeUs5BYC0lQ/CqqcB8Qy3NglWZVivyotNQhBaFvkmCYIgCDHzR/tvmO+9UL+hRjbdkEpla2DaJDwRNglzuSAIR4aIYUEQBCFmXHYbTrz6DbtEq7UFCQ15hmW8BaFFkG+SIAiCEDMpqpccpUS/oUrTjbbAnChniuFar9gkBKElkWg1QRAEIWaerJnDQPsu/YZVGdbFmVSGWwe3Ma7byxVW7DjMjoOVAByu8uAPaKg2pT03TxA6PSKGBUEQhJjxK47gDbueOyw2idbj/Y0FfLr9EAAri2ysfH6Ndd87XxWwZncJd583gqmj8tprEwWh0yN7LkEQBCFmfLYQMSw2iVbl/Y0FzHxxLbWmPyIKhWW1zHxxLe9vLGjDLROEroXsuQRBEISY8Su6NaIw52QYPg0I5t5K042Wwx/QmPv2JrQm1jPvn/v2JvyBptYWBCEasucSBEEQYsZvVIb35J4JOSOBkA50UhluMVbvLKagrLbpFdEFcUFZLat3FrfuRglCF0X2XIIgCELMBGx6ZVjz1VnLxDPc8hRVxCaEj/QxgiCIGBYEQRDiwK/qYrhvwQdQtg8IEcNik2gxeqa42+QxgiCIGBYEQRDiYHfiWAB6Fa+GPSuAkA50UhluMSbkZ5KX5iaW0DQFyEtzMyE/s7U3SxC6JLLnEgRBEGLmi54/5ovAUP2GUSUOpklIe+CWQrUp3H3eCIBGBbF5393njZC8YUFoJiKGBUEQhJhx2m048ek37Ea0mlSGW4Wpo/J46uLx5KY1bH/ITXPz1MXjJWdYEI4AabohCIIgxIzTppBMjX7DrAz7JGe4tZg6Ko8zR+SyYnsRSz5dxRmTJ6Da7RyqrKNnim6NkIqwIBwZIoYFQRCEmDm94C8MshkNHuzhTTekMtw6qDaFifmZHN6sMWlQFg6Ho+kHCYIQM7LnEgRBEGLH7gz+rrrw+QNWswdJkxAEoTMiey5BEAQhdtQQMWx3WlVhkMqwIAidE9lzCYIgCDGjGNYIAFJ7W35hEDEsCELnRPZcgiAIQswodj3ZYG3SSZCYaYlhRQG7TOQSBKETImJYEARBiBnFoVeG1YAHCGm4odpQFBHDgiB0PkQMC4IgCDFjs+tJBqNrVoPfF9JwQw4ngiB0TmTvJQiCIMSMPyEbABsa+GpDGm5I9zlBEDonIoYFQRCEmKnKGmP9vnJPJZW1ejc6fyDAih2HrZg1QRCEzoI03RAEQRCaZtl8th2sZv7m0ZwGBDSFn//1S2yKwnXqIlRPgAuf9ZKX5ubu80ZIe2BBEDoNUhkWBEEQmmTbwWqGbHqcn3rfAMCLHVCYZVvEzY7X8Wv64aSwrJaZL67l/Y0F7bi1giAIsSNiWBAEQWgUf0Dj0h2n8JB3BlfaFwPgUrxcp+pC+CHvDBb6pwNgmiTmvr1JLBOCIHQKRAwLgiAIjbJ6ZzEFZbUs9E/nTd8J1vJIIWyiAQVltazeWdzGWyoIghA/IoYFQRCERimqqLV+n+27Br+m5wnXafZ6QrihxwmCIHRURAwLgiAIjdIzxW39fq36JqqiUafZcSk+rlMXxfQ4QRCEjoqIYUEQBKFRJuRnkpfm5voQj/Cwuhd4yDuDmx2v1xPECpCX5mZCfmb7bLAgCEIcSLSaIAiC0CiqTeGFQR8zZNPrPBziETb/v9nxunXbbMh893kjUG3SnlkQhI5Pp6kMz5s3jxNOOIHExETS09OjrqMoSr2fl19+OWydjz/+mPHjx+NyuRg8eDDPP/9862+8IAhCJ2dIj0S2jbie15J/Ebb8icB0HvLOQFX0TnS5aW6euni85AwLgtBp6DSVYY/Hw09+8hMmTZrEX//61wbX+/vf/87UqVOt26HCeefOnZxzzjlcffXVvPTSS3z44YdcccUV5OXlMWXKlNbcfEEQhM7NqbczBPgsoLF6ZzFFFbX0THFzTP8M1uw+nqKKWv6VolsjpCIsCEJnotOI4blz5wI0WclNT08nNzc36n1PP/00+fn5PPTQQwAcddRRfPbZZzzyyCMihgVBEGJAtSlMGpQVtizytiAIQmei04jhWJk1axZXXHEFAwcO5Oqrr+aXv/wliqJXKVasWMEZZ5wRtv6UKVO48cYbG3y+uro66urqrNvl5eUAeL1evF5vy7+ACMy/0RZ/qysh4xY/MmbxI2MWPzJmzUPGLX5kzOKnK41ZPK+hS4nhP/zhD5x22mkkJiayZMkSrrnmGiorK7n++usBKCwsJCcnJ+wxOTk5lJeXU1NTQ0JCQr3nnD9/vlWVDmXJkiUkJia2zguJwtKlS9vsb3UlZNziR8YsfmTM4kfGrHnIuMWPjFn8dIUxq66ujnnddhXDt912GwsWLGh0nc2bNzN8+PCYnu/OO++0fh83bhxVVVX88Y9/tMRwc7j99tu56aabrNvl5eX07duXs846i9TU1GY/b6x4vV6WLl3KmWeeicPhaPW/11WQcYsfGbP4kTGLHxmz5iHjFj8yZvHTlcbMvJIfC+0qhm+++WYuv/zyRtcZOHBgs59/4sSJ3HvvvdTV1eFyucjNzeXAgQNh6xw4cIDU1NSoVWEAl8uFy+Wqt9zhcLTpB6Wt/15XQcYtfmTM4kfGLH5kzJqHjFv8yJjFT1cYs3i2v13FcI8ePejRo0erPf/69evJyMiwxOykSZNYvHhx2DpLly5l0qRJrbYNgiAIgiAIQsel03iG9+zZQ3FxMXv27MHv97N+/XoABg8eTHJyMm+//TYHDhzg+OOPx+12s3TpUu6//35uueUW6zmuvvpq/vznPzNnzhx+9atf8dFHH/Hqq6/y7rvvttOrEgRBEARBENqTTiOG77rrLv7xj39Yt8eNGwfAsmXLOOWUU3A4HDzxxBPMnj0bTdMYPHgwDz/8MFdeeaX1mPz8fN59911mz57NY489Rp8+fXjuuefiilXTNA2Iz4tyJHi9XqqrqykvL+/0lyzaEhm3+JExix8Zs/iRMWseMm7xI2MWP11pzEydZuq2xlC0WNYSLL7//nv69u3b3pshCIIgCIIgNMHevXvp06dPo+uIGI6TQCDA/v37SUlJsfKLWxMzvWLv3r1tkl7RVZBxix8Zs/iRMYsfGbPmIeMWPzJm8dOVxkzTNCoqKujVqxc2m63RdTuNTaKjYLPZmjzDaA1SU1M7/QezPZBxix8Zs/iRMYsfGbPmIeMWPzJm8dNVxiwtLS2m9RqXyoIgCIIgCILQhRExLAiCIAiCIHRbRAx3cFwuF3fffXfUxh9Cw8i4xY+MWfzImMWPjFnzkHGLHxmz+OmuYyYT6ARBEARBEIRui1SGBUEQBEEQhG6LiGFBEARBEASh2yJiWBAEQRAEQei2iBgWBEEQBEEQui0ihjs4TzzxBAMGDMDtdjNx4kRWr17d3pvUYZg/fz7HHXccKSkp9OzZkx/+8Ids3bo1bJ3a2lpmzZpFVlYWycnJ/PjHP+bAgQPttMUdjwceeABFUbjxxhutZTJm9dm3bx8XX3wxWVlZJCQkMHr0aL788kvrfk3TuOuuu8jLyyMhIYEzzjiDbdu2teMWty9+v58777yT/Px8EhISGDRoEPfeey+h87VlzOCTTz7hvPPOo1evXiiKwptvvhl2fyxjVFxczEUXXURqairp6en8+te/prKysg1fRdvS2Jh5vV5uvfVWRo8eTVJSEr169eLSSy9l//79Yc8hY/Zmg+teffXVKIrCo48+Gra8q4+ZiOEOzCuvvMJNN93E3Xffzdq1axk7dixTpkyhqKiovTetQ7B8+XJmzZrFypUrWbp0KV6vl7POOouqqiprndmzZ/P222/z2muvsXz5cvbv38/06dPbcas7Dl988QXPPPMMY8aMCVsuYxZOSUkJkydPxuFw8N5777Fp0yYeeughMjIyrHUefPBBHn/8cZ5++mlWrVpFUlISU6ZMoba2th23vP1YsGABTz31FH/+85/ZvHkzCxYs4MEHH2ThwoXWOjJmUFVVxdixY3niiSei3h/LGF100UV88803LF26lHfeeYdPPvmEq666qq1eQpvT2JhVV1ezdu1a7rzzTtauXcuiRYvYunUr559/fth6MmbReeONN1i5ciW9evWqd1+XHzNN6LBMmDBBmzVrlnXb7/drvXr10ubPn9+OW9VxKSoq0gBt+fLlmqZpWmlpqeZwOLTXXnvNWmfz5s0aoK1YsaK9NrNDUFFRoQ0ZMkRbunSpdvLJJ2s33HCDpmkyZtG49dZbtRNPPLHB+wOBgJabm6v98Y9/tJaVlpZqLpdL+9e//tUWm9jhOOecc7Rf/epXYcumT5+uXXTRRZqmyZhFA9DeeOMN63YsY7Rp0yYN0L744gtrnffee09TFEXbt29fm217exE5ZtFYvXq1Bmi7d+/WNE3GrKEx+/7777XevXtrGzdu1Pr376898sgj1n3dYcykMtxB8Xg8rFmzhjPOOMNaZrPZOOOMM1ixYkU7blnHpaysDIDMzEwA1qxZg9frDRvD4cOH069fv24/hrNmzeKcc84JGxuQMYvGW2+9xbHHHstPfvITevbsybhx43j22Wet+3fu3ElhYWHYmKWlpTFx4sRuO2YnnHACH374Id9++y0AGzZs4LPPPuPss88GZMxiIZYxWrFiBenp6Rx77LHWOmeccQY2m41Vq1a1+TZ3RMrKylAUhfT0dEDGLBqBQIBLLrmE3/72t4wcObLe/d1hzOztvQFCdA4dOoTf7ycnJydseU5ODlu2bGmnreq4BAIBbrzxRiZPnsyoUaMAKCwsxOl0WjtBk5ycHAoLC9thKzsGL7/8MmvXruWLL76od5+MWX2+++47nnrqKW666SZ+97vf8cUXX3D99dfjdDq57LLLrHGJ9l3trmN22223UV5ezvDhw1FVFb/fz7x587jooosAZMxiIJYxKiwspGfPnmH32+12MjMzZRzR5z/ceuutXHjhhaSmpgIyZtFYsGABdrud66+/Pur93WHMRAwLXYJZs2axceNGPvvss/belA7N3r17ueGGG1i6dClut7u9N6dTEAgEOPbYY7n//vsBGDduHBs3buTpp5/msssua+et65i8+uqrvPTSS/zzn/9k5MiRrF+/nhtvvJFevXrJmAltgtfr5ac//SmapvHUU0+19+Z0WNasWcNjjz3G2rVrURSlvTen3RCbRAclOzsbVVXrzeI/cOAAubm57bRVHZNrr72Wd955h2XLltGnTx9reW5uLh6Ph9LS0rD1u/MYrlmzhqKiIsaPH4/dbsdut7N8+XIef/xx7HY7OTk5MmYR5OXlMWLEiLBlRx11FHv27AGwxkW+q0F++9vfctttt/Hzn/+c0aNHc8kllzB79mzmz58PyJjFQixjlJubW29Ctc/no7i4uFuPoymEd+/ezdKlS62qMMiYRfLpp59SVFREv379rGPC7t27ufnmmxkwYADQPcZMxHAHxel0cswxx/Dhhx9aywKBAB9++CGTJk1qxy3rOGiaxrXXXssbb7zBRx99RH5+ftj9xxxzDA6HI2wMt27dyp49e7rtGJ5++ul8/fXXrF+/3vo59thjueiii6zfZczCmTx5cr3Ivm+//Zb+/fsDkJ+fT25ubtiYlZeXs2rVqm47ZtXV1dhs4YcXVVUJBAKAjFksxDJGkyZNorS0lDVr1ljrfPTRRwQCASZOnNjm29wRMIXwtm3b+O9//0tWVlbY/TJm4VxyySV89dVXYceEXr168dvf/pYPPvgA6CZj1t4z+ISGefnllzWXy6U9//zz2qZNm7SrrrpKS09P1woLC9t70zoEM2fO1NLS0rSPP/5YKygosH6qq6utda6++mqtX79+2kcffaR9+eWX2qRJk7RJkya141Z3PELTJDRNxiyS1atXa3a7XZs3b562bds27aWXXtISExO1F1980VrngQce0NLT07X//Oc/2ldffaVdcMEFWn5+vlZTU9OOW95+XHbZZVrv3r21d955R9u5c6e2aNEiLTs7W5szZ461joyZnuqybt06bd26dRqgPfzww9q6deus5INYxmjq1KnauOjnN6AAAAYqSURBVHHjtFWrVmmfffaZNmTIEO3CCy9sr5fU6jQ2Zh6PRzv//PO1Pn36aOvXrw87LtTV1VnPIWMW/jmLJDJNQtO6/piJGO7gLFy4UOvXr5/mdDq1CRMmaCtXrmzvTeowAFF//v73v1vr1NTUaNdcc42WkZGhJSYmaj/60Y+0goKC9tvoDkikGJYxq8/bb7+tjRo1SnO5XNrw4cO1v/zlL2H3BwIB7c4779RycnI0l8ulnX766drWrVvbaWvbn/Lycu2GG27Q+vXrp7ndbm3gwIHaHXfcESZIZMw0bdmyZVH3YZdddpmmabGN0eHDh7ULL7xQS05O1lJTU7Vf/vKXWkVFRTu8mrahsTHbuXNng8eFZcuWWc8hYxb+OYskmhju6mOmaFpISyBBEARBEARB6EaIZ1gQBEEQBEHotogYFgRBEARBELotIoYFQRAEQRCEbouIYUEQBEEQBKHbImJYEARBEARB6LaIGBYEQRAEQRC6LSKGBUEQBEEQhG6LiGFBEARBEASh2yJiWBAEoZujKApvvvnmET3H888/T3p6eotsjyAIQlsiYlgQBKEdUBSl0Z977rmnzbaloKCAs88+u83+niAIQkfC3t4bIAiC0B0pKCiwfn/llVe466672Lp1q7UsOTk5rufzeDw4nc5mbUtubm6zHicIgtAVkMqwIAhCO5Cbm2v9pKWloSiKdfvpp5/mxBNPDFv/0UcfZcCAAdbtyy+/nB/+8IfMmzePXr16MWzYMHbt2oWiKCxatIhTTz2VxMRExo4dy4oVKxrdllCbRKzP8fzzz9OvXz8SExP50Y9+xOHDh+s973/+8x/Gjx+P2+1m4MCBzJ07F5/PB8Af/vAHevXqFfa4c845h1NPPZVAIBDPUAqCIBwRIoYFQRA6KR9++CFbt25l6dKlvPPOO9byO+64g1tuuYX169czdOhQLrzwQkuExkpjz7Fq1Sp+/etfc+2117J+/XpOPfVU7rvvvrDHf/rpp1x66aXccMMNbNq0iWeeeYbnn3+eefPmWc8/YMAArrjiCgCeeOIJPv/8c/7xj39gs8mhSRCEtkNsEoIgCJ2UpKQknnvuOcsesWvXLgBuueUWzjnnHADmzp3LyJEj2b59O8OHD4/5uRt7jscee4ypU6cyZ84cAIYOHcrnn3/O+++/bz1+7ty53HbbbVx22WUADBw4kHvvvZc5c+Zw9913o6oqL774IkcffTS33XYbjz/+OM899xz9+vU74nERBEGIBzn9FgRB6KSMHj06qk94zJgx1u95eXkAFBUVxfXcjT3H5s2bmThxYtj6kyZNCru9YcMG/vCHP5CcnGz9XHnllRQUFFBdXQ3oAvlPf/oTCxYs4Pzzz+cXv/hFXNsoCILQEkhlWBAEoYNhs9nQNC1smdfrrbdeUlJS1Mc7HA7rd0VRAOL24R7pc1RWVjJ37lymT59e7z632239/sknn6CqKrt27cLn82G3y2FJEIS2RSrDgiAIHYwePXpQWFgYJojXr1/ffhsUwVFHHcWqVavClq1cuTLs9vjx49m6dSuDBw+u92N6gl955RUWLVrExx9/zJ49e7j33nvb7DUIgiCYyCm4IAhCB+OUU07h4MGDPPjgg8yYMYP333+f9957j9TU1PbeNACuv/56Jk+ezJ/+9CcuuOACPvjggzC/MMBdd93FueeeS79+/ZgxYwY2m40NGzawceNG7rvvPr7//ntmzpzJggULOPHEE/n73//Oueeey9lnn83xxx/fTq9MEITuiFSGBUEQOhhHHXUUTz75JE888QRjx45l9erV3HLLLe29WRbHH388zz77LI899hhjx45lyZIl/P73vw9bZ8qUKbzzzjssWbKE4447juOPP55HHnmE/v37o2kal19+ORMmTODaa6+11p85cyYXX3wxlZWV7fGyBEHopihapDFNEARBEARBELoJUhkWBEEQBEEQui0ihgVBEARBEIRui4hhQRAEQRAEodsiYlgQBEEQBEHotogYFgRBEARBELotIoYFQRAEQRCEbouIYUEQBEEQBKHbImJYEARBEARB6LaIGBYEQRAEQRC6LSKGBUEQBEEQhG6LiGFBEARBEASh2/L/5J1a2Yf1qSMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs0AAAGJCAYAAABxbg5mAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0K5JREFUeJzsnXd4FEUbwH/X0hshIQk1oRN6J/ReRUCwgVIFpUkT7AIKIiiCoKKf0hSQJoKCCAEh9C4IBEILHRJaCElIcrnb74/Nbu6SuySECxCZ3/Pkye3s7Mw7ZWffnX3nHY0kSRICgUAgEAgEAoHALtrHLYBAIBAIBAKBQPCkI5RmgUAgEAgEAoEgB4TSLBAIBAKBQCAQ5IBQmgUCgUAgEAgEghwQSrNAIBAIBAKBQJADQmkWCAQCgUAgEAhyQCjNAoFAIBAIBAJBDgilWSAQCAQCgUAgyAGhNAsEAoFAIBAIBDkglGbBA6HRaJgwYYJ6vGDBAjQaDefPn39sMkFWuQR5Z8KECWg0mlzFFfUueNz07duX4ODgxy2Gw1DG1AMHDjg03f9SPW3duhWNRsPWrVsftyiCpwyhNAseG5GRkUyYMOGxK9wFkSVLljBz5szHLUauuXbtGu+88w4tWrTA09Mzxwdeamoqn376KRUrVsTFxYWAgAA6derE5cuX1TgJCQmMHz+e9u3b4+vri0ajYcGCBXbTNJvNzJkzhxo1auDq6krhwoVp2bIlR44csXtN37590Wg0Of717ds3D7XiWL799ttsy59XkpKSmDBhglBQBALBU4/+cQsgKNi8+uqrvPTSSzg7Oz/wtZGRkUycOJHmzZv/Z2ZAHhVLlizh2LFjjBw50uFpf/DBB7zzzjsOTTMqKoqpU6dSrlw5qlatyu7du+3GNRqNdOrUiV27djFw4ECqVavGnTt32Lt3L3fv3qV48eIA3Lx5k48//piSJUtSvXr1HJW6/v37s3jxYnr37s2wYcNITEzkn3/+ITY21u41r7/+Oq1bt1aPo6Oj+eijjxg0aBBNmjRRw8uUKZPLmsg/vv32W/z8/ByuwCclJTFx4kQAmjdv7tC0BYK80LRpU+7fv4+Tk9PjFkXwlCGUZsFDodPp0Ol0j1sMQTYkJyfj5OSEVpu7D0t6vR693rFDQ+3atbl16xa+vr6sXLmS559/3m7cGTNmEBERwY4dO6hXr57deEFBQVy7do3AwEAOHDhA3bp17cZdvnw5CxcuZNWqVXTr1i3XcoeFhREWFqYeHzhwgI8++oiwsDBeeeWVXKdjD0mSSE5OxtXV9aHTKmikpaVhNpv/84qP2WwmNTUVFxeXxy3KfwatVivqU/BYEOYZ/2EU29STJ0/ywgsv4OXlReHChRkxYgTJyclqvGbNmlG9enWbaVSoUIF27drZzcOWTXNwcDDPPPOMqvS4uLhQunRpfvrpJ6vrFMWpRYsW6mfunGYLU1JSGDVqFP7+/nh6evLss89afbK35MqVK/Tv35+AgACcnZ2pXLky8+bNU8/HxMSg1+vVWTRLoqKi0Gg0fP3119nK8yD8+++/9O3bl9KlS+Pi4kJgYCD9+/fn1q1bVvHu3bvHyJEjCQ4OxtnZmSJFitCmTRsOHToEyLN969at48KFC2q9KTP1iq3f0qVL+eCDDyhWrBhubm7Ex8cDsGLFCmrXro2rqyt+fn688sorXLlyxSp/WzbND1LvtvD09MTX1zfHeGazma+++opu3bpRr1490tLSSEpKshnX2dmZwMDAXOX/5ZdfUq9ePbp164bZbCYxMTHXsueEPRvw7O6NDRs2UKdOHVxdXfn+++/Vdlu+fDmTJ0+mePHiuLi40KpVK86cOZOjDMHBwRw/fpyIiAi1T1jOCp87d47nn38eX19f3NzcaNCgAevWrcsx3fPnz+Pv7w/AxIkT1bQVO/bmzZvbnH3ObD97/vx5NBoNX3zxBTNnzqRMmTI4OzurJloajYYzZ87Qt29ffHx88Pb2pl+/fnbbPicSExMZM2YMJUqUwNnZmQoVKvDFF18gSZJVvPv37/Pmm2/i5+en9usrV65ksdXP7VgKsp3/sGHDWLx4MZUrV8bZ2Zm//voLgH/++YcOHTrg5eWFh4cHrVq1Ys+ePTbLkJSUxOuvv07hwoXx8vKid+/e3LlzJ1flX716NVWqVMHFxYUqVarw22+/WZ2XJIng4GC6dOmS5drk5GS8vb15/fXXAR6ob27fvp3nn3+ekiVL4uzsTIkSJRg1ahT379+3ite3b188PDy4ePEizzzzDB4eHhQrVoxvvvkGgKNHj9KyZUvc3d0pVaoUS5Yssbrenk3z3r176dixI4UKFcLd3Z1q1arx1VdfqeevX79Ov379KF68OM7OzgQFBdGlSxere/Tu3bucPHmSu3fv5ljPBw4coF27dvj5+eHq6kpISAj9+/fPUU7lfshsTqX0L39/f1xdXalQoQLvv/++VZwrV64wYMAAihYtirOzMyEhIQwePJjU1FQ1TlxcHCNHjlT7f9myZZk6dSpms9kqraVLl1K7dm08PT3x8vKiatWqVvVlNBqZOHEi5cqVw8XFhcKFC9O4cWPCw8NzrJv/KmKm+SnghRdeIDg4mClTprBnzx5mzZrFnTt3VCX21VdfZeDAgRw7dowqVaqo1+3fv59Tp07xwQcfPHCeZ86coUePHgwYMIA+ffowb948+vbtS+3atalcuTJNmzblzTffZNasWbz33ntUqlQJQP1vj9dee41FixbRs2dPGjZsyN9//02nTp2yxIuJiaFBgwbqA8zf35/169czYMAA4uPjGTlyJAEBATRr1ozly5czfvx4q+uXLVuGTqfLdkb0QQkPD+fcuXP069ePwMBAjh8/zv/+9z+OHz/Onj17VMXrjTfeYOXKlQwbNozQ0FBu3brFjh07OHHiBLVq1eL999/n7t27XL58mRkzZgDg4eFhldcnn3yCk5MTb731FikpKTg5ObFgwQL69etH3bp1mTJlCjExMXz11Vfs3LmTf/75Bx8fH7uy57beH5bIyEiuXr1KtWrVGDRoEAsXLiQ1NVUdzFu0aPHAacbHx7Nv3z6GDBnCe++9x+zZs0lISCAkJITPPvuMF154weHlyI6oqChefvllXn/9dQYOHEiFChXUc5999hlarZa33nqLu3fvMm3aNHr16sXevXuzTXPmzJkMHz4cDw8P9SEbEBAAyPdCw4YNSUpK4s0336Rw4cIsXLiQZ599lpUrV2Y78+7v78+cOXMYPHgw3bp147nnngOgWrVqeSr7/PnzSU5OZtCgQTg7O1u9SL3wwguEhIQwZcoUDh06xI8//kiRIkWYOnXqA+UhSRLPPvssW7ZsYcCAAdSoUYMNGzYwduxYrly5ot4zICtvy5cv59VXX6VBgwZERERk269zGksV/v77b5YvX86wYcPw8/NTX2qaNGmCl5cX48aNw2Aw8P3339O8eXMiIiKoX7++VRrDhg3Dx8eHCRMmEBUVxZw5c7hw4YKqiNlj48aNdO/endDQUKZMmcKtW7dURVFBo9HwyiuvMG3aNG7fvm3VDn/88Qfx8fFZvqTkpm+uWLGCpKQkBg8eTOHChdm3bx+zZ8/m8uXLrFixwio9k8lEhw4daNq0KdOmTWPx4sUMGzYMd3d33n//fXr16sVzzz3Hd999R+/evQkLCyMkJMRuucPDw3nmmWcICgpixIgRBAYGcuLECdauXcuIESMA6N69O8ePH2f48OEEBwcTGxtLeHg4Fy9eVF/yfvvtN/r168f8+fOzNXWKjY2lbdu2+Pv788477+Dj48P58+dZtWqV3Wuy499//6VJkyYYDAYGDRpEcHAwZ8+e5Y8//mDy5MkAXL16lXr16hEXF8egQYOoWLEiV65cYeXKlSQlJeHk5ERSUhLNmjXjypUrvP7665QsWZJdu3bx7rvvcu3aNXUtTHh4OC+//DKtWrVS77ETJ06wc+dOtb4mTJjAlClTeO2116hXrx7x8fEcOHCAQ4cO0aZNmzyVs8AjCf6zjB8/XgKkZ5991ip8yJAhEiAdOXJEkiRJiouLk1xcXKS3337bKt6bb74pubu7SwkJCWoYII0fP149nj9/vgRI0dHRalipUqUkQNq2bZsaFhsbKzk7O0tjxoxRw1asWCEB0pYtW3JVnsOHD0uANGTIEKvwnj17ZpFrwIABUlBQkHTz5k2ruC+99JLk7e0tJSUlSZIkSd9//70ESEePHrWKFxoaKrVs2TJXcuUWJU9Lfvnllyx15e3tLQ0dOjTbtDp16iSVKlUqS/iWLVskQCpdurRVfqmpqVKRIkWkKlWqSPfv31fD165dKwHSRx99pIYp/UbhQeo9N2TX7qtWrZIAqXDhwlK5cuWk+fPnS/Pnz5fKlSsnOTk5qX02M/v375cAaf78+VnOHTp0SE0zICBA+vbbb6XFixdL9erVkzQajbR+/fpcy24rn8z1pZDdvfHXX39ZxVXarVKlSlJKSooa/tVXX9nsn7aoXLmy1KxZsyzhI0eOlABp+/btati9e/ekkJAQKTg4WDKZTNmme+PGDbvt3KxZM5t59unTx6p/RkdHS4Dk5eUlxcbGWsVV6q9///5W4d26dZMKFy6crWy28lq9erUESJMmTbKK16NHD0mj0UhnzpyRJEmSDh48KAHSyJEjreL17ds3S3lzO5ZKkjxGarVa6fjx41Zxu3btKjk5OUlnz55Vw65evSp5enpKTZs2VcOUflO7dm0pNTVVDZ82bZoESGvWrMm2PmrUqCEFBQVJcXFxatjGjRslwKqeoqKiJECaM2eO1fXPPvusFBwcLJnNZkmSHqxv2hrjpkyZImk0GunChQtqWJ8+fSRA+vTTT9WwO3fuSK6urpJGo5GWLl2qhp88eTJLeygyKWNIWlqaFBISIpUqVUq6c+eOVf5KOe7cuSMB0ueff26v6iRJyqh/W2OJJb/99psESPv377cbJ7OcCsr9YJlH06ZNJU9PT6t6spRfkiSpd+/eklartZmnEu+TTz6R3N3dpVOnTlmdf+eddySdTiddvHhRkiRJGjFihOTl5SWlpaXZlb969epSp06d7J5/GhHmGU8BQ4cOtToePnw4AH/++ScA3t7edOnShV9++UX9fGkymVi2bBldu3bF3d39gfMMDQ21Wijl7+9PhQoVOHfuXF6Locr75ptvWoVnXgwnSRK//vornTt3RpIkbt68qf61a9eOu3fvqqYOzz33HHq9nmXLlqnXHzt2jMjISF588cU8y2oLS7vV5ORkbt68SYMGDQBUeQB8fHzYu3cvV69ezXNeffr0scrvwIEDxMbGMmTIECtbwE6dOlGxYsVsP9Xntt4dQUJCAiCbqGzevJm+ffvSt29fNm3ahCRJTJs2Lc9p3rp1izVr1jB48GB69uzJ5s2bKVy4MJMmTXJoGXIiJCTErslTv379rGx8lXvoYe+bevXq0bhxYzXMw8ODQYMGcf78eSIjI/Oc9oPSvXt31dwjM2+88YbVcZMmTbh165ZqWpRb/vzzT3Q6XZb+OmbMGCRJYv369QCqycSQIUOs4injoy1yGksVmjVrRmhoqHpsMpnYuHEjXbt2pXTp0mp4UFAQPXv2ZMeOHVnKOWjQIAwGg3o8ePBg9Hp9lrwsuXbtGocPH6ZPnz54e3ur4W3atLGSB6B8+fLUr1+fxYsXq2G3b99m/fr19OrVK8tsdm76puWYk5iYyM2bN2nYsCGSJPHPP/9kkfe1115Tf/v4+FChQgXc3d2tvv5UqFABHx+fbO+Bf/75h+joaEaOHJnli5lSDldXV5ycnNi6dWu2Zi59+/ZFkqQcF9Qq+axduxaj0Zht3Jy4ceMG27Zto3///pQsWdKm/GazmdWrV9O5c2fq1KmTJQ0l3ooVK2jSpAmFChWyeva1bt0ak8nEtm3bVPkTExOzNbXw8fHh+PHjnD59+qHK919CKM1PAeXKlbM6LlOmDFqt1sqOq3fv3ly8eJHt27cDsGnTJmJiYnj11VfzlGfmGx+gUKFCubLJu3v3LtevX1f/bt++DcCFCxfQarVZPBVYft4GeQCKi4vjf//7H/7+/lZ//fr1A1A9Jvj5+dGqVSuWL1+uXr9s2TL0er36KdpR3L59mxEjRhAQEICrqyv+/v7q50ZL+7lp06Zx7NgxSpQoQb169ZgwYcIDK02ZP2NeuHAByFpXABUrVlTP2yK39Z6ammrVbtevX8dkMj2Q3MpDt1GjRpQoUUINL1myJI0bN2bXrl0PlJ5lmiEhIVafwD08POjcuTP79u0jLS3tgdPNK9l9Ys583xQqVAhAvW8SEhKs6vfGjRs55nfhwgWb7a6YQiltf/v2bau0c2PT+aA8TNlzy4ULFyhatCienp5W4ZnLq/TrzDKVLVvWbtq5GUshazlv3LhBUlKS3XYwm81cunQp27w8PDwICgrK1kWnUrbM14Lte793797s3LlTvW7FihUYjUab435u2ufixYv07dsXX19fPDw88Pf3p1mzZgBZ+pOLi0uWFyhvb2+KFy+eRWH39vbOth+cPXsWwMq8MDPOzs5MnTqV9evXExAQoJqFXL9+3e412dGsWTO6d+/OxIkT8fPzo0uXLsyfP5+UlJQHTksZ37OT/8aNG8THx2cbB+D06dP89ddfWZ59ihcg5dk3ZMgQypcvT4cOHShevDj9+/dXXyQVPv74Y+Li4ihfvjxVq1Zl7Nix/Pvvvw9cvv8SQml+CrFlD9euXTsCAgJYtGgRAIsWLSIwMNDK3daDYM+jhjKTnR0jRowgKChI/XtQ5VVZ7PDKK68QHh5u869Ro0Zq/JdeeolTp05x+PBhQPa00KpVK/z8/B4o35x44YUX+OGHH3jjjTdYtWoVGzduVAcpywUaL7zwAufOnWP27NkULVqUzz//nMqVK6szZLnhcXhj2LVrl1W7BQUFZVEEcqJo0aJAhj2uJUWKFHlgBSo3aRqNxodaGGjPvtTeC0N2bZPTffPFF19Y1W92HkMelOeee84qbcWuMTseZdmfROyVv6B4Q3nppZcwGAzqbPOiRYuoU6eOTQU7p/YxmUy0adOGdevW8fbbb7N69WrCw8PVxW6ZF6HZSy8/+8HIkSM5deoUU6ZMwcXFhQ8//JBKlSrZnAXPCY1Gw8qVK9m9ezfDhg1TF57Xrl1b/br1oPeHIzCbzbRp08bus6979+6APPYdPnyY33//XV0D0KFDB/r06aOm1bRpU86ePcu8efOoUqUKP/74I7Vq1eLHH3/MN/mfdMRCwKeA06dPW818nDlzBrPZbLW6XafT0bNnTxYsWMDUqVNZvXo1AwcOzFd3cvYGlHHjxlktQlFmNEqVKoXZbObs2bNWg3pUVJTV9YqHB5PJlCulv2vXrrz++uuqicapU6d49913H7g82XHnzh02b97MxIkT+eijj9Rwe5+9goKCGDJkCEOGDCE2NpZatWoxefJkOnToANivO3uUKlUKkOuqZcuWVueioqLU8/auzU29V69ePcunvtx6t1CoWrUqBoMhi0cPkBfB2Pu0nx1FixYlMDDQbpouLi5ZZiUfBKV/xsXFWX0azm72Pq/07t3byszCUjmz1ydKlSqVpa1AXqmvnAeYPn261UuJ8rKRXV8rVKiQza8g+VH23FKqVCk2bdrEvXv3rNo1c3mVfh0dHW01M5udt5LcjKW28Pf3x83NzW47aLVaqy8rSl6WC18TEhK4du0aHTt2tJuPUjZb44qtvH19fenUqROLFy+mV69e7Ny5M8+bJh09epRTp06xcOFCevfurYY/Ck8LylewY8eO5TjmlylThjFjxjBmzBhOnz5NjRo1mD59ujph9KA0aNCABg0aMHnyZJYsWUKvXr1YunQpr732mtXYYEnm+0Mx2Tl27JjdfPz9/fHy8so2DsjlS0hIyNWzz8nJic6dO9O5c2fMZjNDhgzh+++/58MPP1S/uPj6+tKvXz/69etHQkICTZs2ZcKECVamNU8TYqb5KUBx46Mwe/ZsAFUBU3j11Ve5c+cOr7/+OgkJCQ7xQ5sdiq105gElNDSU1q1bq3+1a9e2knfWrFlW8TMP8jqdju7du/Prr7/aHGAyf9L28fGhXbt2LF++nKVLl+Lk5ETXrl0fomRZUV4+Ms+WZJbdZDJl+YxZpEgRihYtavXZz93d/YE+n9epU4ciRYrw3XffWaWzfv16Tpw4ka3HgNzWe6FChazarXXr1g/sS9XT05OOHTuya9cuVckBeVX3rl278rxi+8UXX+TSpUtWD/CbN2+yZs0aWrZsmWsf1rZQHtiKrSDI9pwLFy7Mc5r2KF26tFX9Wn4xcXd3z3IvAXTs2JF9+/ZZbSiTmJjI//73P4KDg1Vb19q1a1ulrYS7ubkBWe9TkMt+8uRJq3vqyJEj7Ny50xHFzRMdO3bEZDJlcRc5Y8YMNBqN2p8Vu/Jvv/3WKp4yPtoit2NpZnQ6HW3btmXNmjVW5hUxMTEsWbKExo0b4+XlZXXN//73Pytb2Tlz5pCWlpZtXkFBQdSoUYOFCxdajQ/h4eF2bddfffVVIiMjGTt2LDqdjpdeeinbsmRXRrAe4yRJsnJhll/UqlWLkJAQZs6cmaWfKvIkJSVlcQ9YpkwZPD09rcbE3Lqcu3PnTpbxvEaNGgBqeqVKlUKn01mNDZC1z/n7+9O0aVPmzZvHxYsXbcqv1Wrp2rUrf/zxh80t1pV4L7zwArt372bDhg1Z4sTFxammaJldnWq1WtUrjiJ/5jgeHh6ULVs2TyYo/xXETPNTQHR0NM8++yzt27dn9+7dquuwzL6Za9asSZUqVVixYgWVKlWiVq1a+SpXjRo10Ol0TJ06lbt37+Ls7EzLli0pUqSI3fgvv/wy3377LXfv3qVhw4Zs3rzZ5szQZ599xpYtW6hfvz4DBw4kNDSU27dvc+jQITZt2qTaSSu8+OKLvPLKK3z77be0a9cuW/drecHLy0u1oTMajRQrVoyNGzcSHR1tFe/evXsUL16cHj16UL16dTw8PNi0aRP79+9n+vTparzatWuzbNkyRo8eTd26dVX7XHsYDAamTp1Kv379aNasGS+//LLqci44OJhRo0bZvfZB6j07lAV3x48fB+Dnn39mx44dAFZuDT/99FM2b95My5Yt1cVcs2bNwtfXl/fee88qza+//pq4uDh10eQff/yh+o8ePny4uhjq3XffZfny5XTv3p3Ro0fj7e3Nd999h9Fo5NNPP32gcmSmbdu2lCxZkgEDBqiKx7x58/D398/yAMxPateuzZw5c5g0aRJly5alSJEitGzZknfeeYdffvmFDh068Oabb+Lr68vChQuJjo7m119/zfGFwdXVldDQUJYtW0b58uXx9fWlSpUqVKlShf79+/Pll1/Srl07BgwYQGxsLN999x2VK1d+4AV8jqJz5860aNGC999/n/Pnz1O9enU2btzImjVrGDlypPqSU7t2bbp3787MmTO5deuW6nLu1KlTgO0Z9tyOpbaYNGkS4eHhNG7cmCFDhqDX6/n+++9JSUmxucA1NTWVVq1a8cILLxAVFcW3335L48aNefbZZ7PNZ8qUKXTq1InGjRvTv39/bt++zezZs6lcubJqNmBJp06dKFy4MCtWrKBDhw52x9+cqFixImXKlOGtt97iypUreHl58euvv+bJpOpB0Wq1zJkzh86dO1OjRg369etHUFAQJ0+e5Pjx42zYsIFTp06p9RkaGoper+e3334jJibG6kUhty7nFi5cyLfffku3bt0oU6YM9+7d44cffsDLy0v9GuDt7c3zzz/P7Nmz0Wg0lClThrVr19rchXTWrFk0btyYWrVqMWjQIEJCQjh//jzr1q1TTQc//fRTNm7cSLNmzRg0aBCVKlXi2rVrrFixgh07duDj48PYsWP5/fffeeaZZ1Q3r4mJiRw9epSVK1dy/vx5/Pz8eO2117h9+zYtW7akePHiXLhwgdmzZ1OjRg3V/j80NJTmzZtTu3ZtfH19OXDggOoO9anlEXvrEDxCFDdJkZGRUo8ePSRPT0+pUKFC0rBhw6zcjlmiuDWydAVkCbl0OWfLTY0t91Q//PCDVLp0aUmn0+XK/dz9+/elN998UypcuLDk7u4ude7cWbp06ZJNl1gxMTHS0KFDpRIlSkgGg0EKDAyUWrVqJf3vf//Lkm58fLzk6uoqAdKiRYuylSGvXL58WerWrZvk4+MjeXt7S88//7x09epVK9lTUlKksWPHStWrV5c8PT0ld3d3qXr16tK3335rlVZCQoLUs2dPycfHx8qVlOLiaMWKFTZlWLZsmVSzZk3J2dlZ8vX1lXr16iVdvnzZKo4tF2oPUu/2AOz+ZebgwYNS69atJXd3d8nT01Pq0qVLFhdKkpThws3Wn2WflCRJOnv2rNStWzfJy8tLcnV1lVq2bCnt27cvV7Ir2HNtd/DgQal+/fqSk5OTVLJkSenLL798oHvDXrvZck1lj+vXr0udOnWSPD09JcDqXjt79qzUo0cPycfHR3JxcZHq1asnrV27Ntfl3rVrl1S7dm3JyckpS5svWrRIKl26tOTk5CTVqFFD2rBhg12Xc7bcfSn97caNG1bhturPFpnzkiTZpd6oUaOkokWLSgaDQSpXrpz0+eefW7nvkiRJSkxMlIYOHSr5+vpKHh4eUteuXVVXbJ999lkWGXMzlgJ2XUYeOnRIateuneTh4SG5ublJLVq0kHbt2mWz3BEREdKgQYOkQoUKSR4eHlKvXr2kW7duZVsXCr/++qtUqVIlydnZWQoNDZVWrVpls54UFNd5S5YsyXLuQfpmZGSk1Lp1a8nDw0Py8/OTBg4cKB05ciRLvD59+kju7u5Z8mrWrJlUuXLlLOGZ7xt7rtx27NghtWnTRh07q1WrJs2ePVuSJEm6efOmNHToUKlixYqSu7u75O3tLdWvX19avny5VRq5dTl36NAh6eWXX5ZKliwpOTs7S0WKFJGeeeYZ6cCBA1bxbty4IXXv3l1yc3OTChUqJL3++uvSsWPHbOZx7Ngx9Rnh4uIiVahQQfrwww+t4ly4cEHq3bu35O/vLzk7O0ulS5eWhg4dauUO8N69e9K7774rlS1bVnJycpL8/Pykhg0bSl988YXqxnDlypVS27ZtpSJFiqjj1uuvvy5du3ZNTWfSpElSvXr1JB8fH8nV1VWqWLGiNHnyZCtXiE8bGkl6gldZCB6KCRMmMHHiRG7cuJHrRW1fffUVo0aN4vz58zY9YAgEAsF/mcOHD1OzZk0WLVpEr169gLyNpQWJUaNGMXfuXK5fv66a4wgEgqwIm2aBiiRJzJ07l2bNmgmFWSAQ/OfJvL0zyLb6Wq2Wpk2bPgaJHj3JycksWrSI7t27C4VZIMgBYdMsIDExkd9//50tW7Zw9OhR1qxZ87hFeqLIyY+nq6urzYevJQ/qRUIgEOQ/06ZN4+DBg7Ro0QK9Xs/69etZv349gwYNyuLN4r9GbGwsmzZtYuXKldy6dStXLgYFgqcdoTQLuHHjBj179sTHx4f33nsvx4UmTxtBQUHZnu/Tp0+OnhKEFZRA8OTRsGFDwsPD+eSTT0hISKBkyZJMmDCB999//3GLlu9ERkbSq1cvihQpwqxZs1TPDwKBwD7CplkgyIFNmzZle75o0aI5bnmd101iBAKBQCAQPBkIpVkgEAgEAoFAIMgBsRBQIBAIBAKBQCDIAWHT/ICYzWauXr2Kp6fnA29lLBAIBAKBQCDIfyRJ4t69exQtWvShdn21RCjND8jVq1f/86uqBQKBQCAQCP4LXLp0ieLFizskrQKlNF+5coW3336b9evXk5SURNmyZZk/fz516tQB5LeK8ePH88MPPxAXF0ejRo2YM2cO5cqVU9O4ffs2w4cP548//kCr1dK9e3e++uorPDw8ciWDp6cnIDeCl5eX4wuZCaPRyMaNG2nbti0GgyHf83saEHXqWER9OhZRn45F1KdjEfXpWER9OhbL+rx//z4lSpRQ9TZHUGCU5jt37tCoUSNatGjB+vXr8ff35/Tp0xQqVEiNM23aNGbNmsXChQsJCQnhww8/pF27dkRGRuLi4gJAr169uHbtGuHh4RiNRvr168egQYNYsmRJruRQTDK8vLwemdLs5uaGl5eXuKEchKhTxyLq07GI+nQsoj4di6hPxyLq07HYqk9HmtIWGKV56tSplChRgvnz56thISEh6m9Jkpg5cyYffPABXbp0AeCnn34iICCA1atX89JLL3HixAn++usv9u/fr85Oz549m44dO/LFF19QtGjRR1sogUAgEAgEAkGBoMAozb///jvt2rXj+eefJyIigmLFijFkyBAGDhwIQHR0NNevX7fyh+vt7U39+vXZvXs3L730Ert378bHx0dVmEH2n6vVatm7dy/dunXLkm9KSgopKSnqcXx8PCC/zRiNxvwqroqSx6PI62lB1KljEfXpWER9OhZRn45F1KdjEfXpWCzrMz/qtMAozefOnWPOnDmMHj2a9957j/379/Pmm2/i5OREnz591K2OAwICrK4LCAhQz12/fp0iRYpYndfr9fj6+trdKnnKlClMnDgxS/jGjRtxc3NzRNFyRXh4+CPL62lB1KljEfXpWER9OhZRn45F1KdjEfXpWMLDw0lKSnJ4ugVGaTabzdSpU4dPP/0UgJo1a3Ls2DG+++47+vTpk2/5vvvuu4wePVo9jo+Pp0SJErRt2/aR2TSHh4fTpk0bYe/kIESdOhZRn45F1KdjeRLrU5IkTCYTJpOJgra/WFpaGrt27aJhw4bo9QVGhXhiEfWZdzQaDXq9Hp1Op4ZZ3u/37993eJ4FpoWCgoIIDQ21CqtUqRK//vorAIGBgQDExMQQFBSkxomJiaFGjRpqnNjYWKs00tLSuH37tnp9ZpydnXF2ds4SbjAYHukA/KjzexoQdepYRH06FlGfjuVJqc/U1FSuXbuWL7NgjwJJkggMDOTatWtirwIHIOrz4dBoNBQvXjyLBzSDwUBaWprD8yswSnOjRo2IioqyCjt16hSlSpUC5EWBgYGBbN68WVWS4+Pj2bt3L4MHDwYgLCyMuLg4Dh48SO3atQH4+++/MZvN1K9f/9EVRiAQCARPHWazmejoaHQ6HUWLFsXJyanAKUpms5mEhAQ8PDwctmHE04yoz7wjSRI3btzg8uXLlCtXzmrGOb8oMErzqFGjaNiwIZ9++ikvvPAC+/bt43//+x//+9//APltY+TIkUyaNIly5cqpLueKFi1K165dAXlmun379gwcOJDvvvsOo9HIsGHDeOmll4TnDIFAIBDkK6mpqZjNZkqUKPFI18Q4ErPZTGpqKi4uLkLJcwCiPh8Of39/zp8/j9FoFEqzJXXr1uW3337j3Xff5eOPPyYkJISZM2fSq1cvNc64ceNITExk0KBBxMXF0bhxY/766y/VRzPA4sWLGTZsGK1atVI3N5k1a9bjKJJAIBAI/stsmQJaHTQbZxWs1Wrh3nWQJPAKsnOxQCDIiUf9pabAKM0AzzzzDM8884zd8xqNho8//piPP/7YbhxfX99cb2QiEAgEAkGe0epgy2T5t6XinHgDUm6Cp1CYBYKCRIFSmgUCgUAgKDAoivKWyXD3CrSYCMl3IfE+FCoKnrYXoAsEgicTYUAjEAgEAkF+0WwclG0NhxbA901kpdnd/6EVZpNZYvfZW6w5fIXdZ29hMhcs13X/Nc6fP49Go+Hw4cOPW5Rco9FoWL169eMWo0AhZpoFAoFAIMhPbpxK/yEBGllpfgj+OnaNiX9Ecu1ushoW5O3C+M6htK+SPyYfN27c4KOPPmLdunXExMRQqFAhqlevzkcffUSjRo3yJU+B4ElDKM0CgUAgEOQnyXctDiTZptmlRJ6S+uvYNQYvOkTmeeXrd5MZvOgQc16plS+Kc/fu3UlNTWX+/Pn4+/uTlJTEli1buHXrlsPzEjwcRqPxifBJ/l9EmGcIBAKBQJBfREyDlHSl2ScEXLxlpfnedUD2NZuUmparv3vJRsb/fjyLwgyoYRN+j+ResjFX6eV2N8K4uDi2b9/O1KlTadGiBSVLlqRevXq8++67PPvss1bxXnvtNfz9/fHy8qJly5YcOXLEKq3PPvuMgIAAPD09GTBgAO+88466twJA8+bNGTlypNU1Xbt2pW/fvupxSkoKb731FsWKFcPd3Z369euzdetW9fyCBQvw8fFhw4YNVKpUCQ8PD9q3b8+1a9es0p03bx6VK1fG2dmZoKAghg0b9kBlyYmIiAjq1aunpv/OO+9Ybbhx7949XnnlFYoVK0axYsWYMWNGlvIHBwfzySef8PLLL+Pu7k6xYsX45ptvrPLRaDTMmTOHZ599Fnd3dyZPlhefzpkzhzJlyuDk5ESFChX4+eefs8h47do1OnTogKurK6VLl2blypUPVManDTHTLBAIBAJBfhAxTV4EWKI+XNoLIU1kpdndA+7JCtx9Zz9CP9rgkOwk4Hp8MlUnbMxV/MiP2+HmlLMa4OHhgYeHB6tXr6ZevXp24z3//PO4urqyfv16vL29+f7772nVqhWnTp3C19eX5cuXM2HCBL755hsaN27Mzz//zKxZsyhdunRuiwjAsGHDiIyMZOnSpRQtWpTffvuN9u3bc/ToUcqVKwdAUlISX3zxBT///DNarZZXXnmFt956i8WLFwOyQjl69Gg+++wzOnTowN27d9m5c2euy5ITV65coWPHjvTt25effvqJkydPMnDgQFxcXJgwYQIAo0ePZteuXSxZsoSQkBAmTJjAoUOHrF4iAD7//HPee+89Jk6cyIYNGxgxYgTly5enTZs2apwJEybw2WefMXPmTPR6Pb/99hsjRoxg5syZtG7dmrVr19KvXz+KFy9OixYt1Os+/PBDPvvsM7766it+/vlnXnrpJY4ePUqlSpUeqE2eFoTSLBAIBAJBfmA2QYv3wbUQ6JzAJ90kw90fnAyyn+YCgF6vZ8GCBerGYNWqVaNly5a8/PLLVKtWDYAdO3awb98+YmNjcXZ2BuCLL75g9erVrFy5kkGDBjFz5kwGDBjAgAEDAJg0aRKbNm0iOTnZbt6ZuXjxIvPnz+fixYvqpmRvvfUWf/31F/Pnz+fTTz8FZBOF7777jjJlygCyom3pjnbSpEmMGTOGESNGqGF169bNdVly4ttvv6VEiRJ8/fXXaDQaKlasyNWrV3n77bf56KOPSExMZOHChSxatIhmzZrh5eXF/PnzbW601qhRI9555x0Aypcvz86dO5kxY4aV0tyzZ0/69eunHr/88sv07duXIUOGALKCvmfPHr744gsrpfn555/ntddeA+CTTz4hPDyc2bNn8+233+ZYxqcRoTQLBAKBQJAftHhX/n8/DvzKgeQEqenn0r1nuEoSkR+3y1Vy+6Jv03f+/hzjLehXl3ohOc+Guhpyv4Na9+7d6dSpExEREWzbto0tW7bw+eef8+OPP9K3b1+OHDlCQkIChQsXtrru/v37nD17FoATJ07wxhtvWJ0PCwtjy5YtuZbj6NGjmEwmypcvbxWekpJilbebm5uqMAMEBQURGxsLQGxsLFevXqVVq1Y288hNWXLixIkThIWFWW2+0ahRIxISErh8+TJ37tzBaDRazdx7e3tToUKFLGmFhYVlOZ45c6ZVWJ06dbLkn1m5b9SoEV999VWOaRckDyCPGqE0CwQCgUCQn9w4CT91gWINofGXVqc0Gk2uTCQAmpTzJ8jbhet3k23aNWuAQG8XmpTzR6d1/E5pLi4utGnThvr16/PJJ58waNAgxo8fT9++fUlISCAoKMjKtljBx8cn13lotdosttZGo1H9nZCQgE6n4+DBg1m2Tfbw8FB/Z14Ip9Fo1HRdXV2zlcFRZXmUuLu7P24RngrEQkCBQCAQCPITvfyJn7TU7OPlgE6rYXznUEBWkC1Rjsd3Ds0XhdkWoaGhJCYmAlCrVi2uX7+OXq+nbNmyVn9+fn4AVKpUib1791qlsWfPHqtjf39/qwV7JpOJY8eOqcc1a9bEZDIRGxubJZ/AwNz5vvb09CQ4OJjNmzfbPJ+bsuREpUqV2L17t9ULwM6dO/H09KR48eKULl0ag8HA/v0ZXw7u3r3LqVOnsqSVuY727NmTo81xpUqVrGy0lfxDQ0MfOu2nGTHTLBAIBAJBfvJbuklCYsxDJ9W+ShBzXqmVxU9zYD76ab516xbPP/88/fv3p0qVKmg0Gk6ePMm0adPo0qULAK1btyYsLIyuXbsybdo0ypcvz9WrV1m3bh3dunWjTp06jBgxgr59+1KnTh0aNWrE4sWLOX78uNVCwJYtWzJ69GjWrVtHmTJl+PLLL4mLi1PPly9fnl69etG7d2+mT59OzZo1uXHjBps3b6ZatWp06tQpV2WaMGECb7zxBkWKFKFDhw7cu3ePnTt3Mnz48FyVJSeGDBnCzJkzGT58OMOGDSMqKorx48czevRotFotnp6e9OnTh7fffhsXFxeCg4OZOHEiWq3WyqQDZGV32rRpdO3alfDwcFasWMG6deuyzX/s2LG88MIL1KxZk9atW/PHH3+watUqNm3aZBVvxYoV1KlTh8aNG7N48WL27dvH3Llzc1WHTyNCaRYIBAKBID8xJjk0ufZVgmgTGsi+6NvE3kumiKcL9UJ8822G2cPDg/r16zNjxgzOnj2L0WikRIkSDBw4kPfeew+QzR/+/PNP3n//ffr168eNGzcIDAykadOmBAQEAPDiiy9y9uxZxo0bR3JyMt27d2fw4MFs2JDhPaR///4cOXKE3r17o9frGTVqlNXCNYD58+erC/muXLmCn58fDRo04Jlnnsl1mfr06UNycjIzZszgrbfews/Pjx49euS6LDlRrFgx/vzzT8aOHUv16tXx9fVlwIABfPDBB2qcL7/8ktdff52XXnoJLy8vxo0bx6VLl3BxcbFKa8yYMRw4cICJEyfi5eXFl19+Sbt22dvBd+3ala+++oovvviCESNGEBISwvz582nevLlVvIkTJ7J06VKGDBlCUFAQv/zyS5bZaEEGGim3jhoFAMTHx+Pt7c3du3fx8vLK9/yMRiN//vknHTt2FM7KHYSoU8ci6tOxiPp0LE9Efc6sCnEXSfYoQXSnFYSEhGRRjAoKZrOZ+Ph4vLy80Gof3sJzwoQJrF69+qldfGZZn/fv36dYsWJMnz5d9TASHBzMyJEjs/iuFsgkJycTHR2t3lOW9/v9+/cdrq+JmWaBQCAQCPIVixlgMU8lSOeff/4hMjKS0NBQTCYTkyZNAlBNXgRPHkJpFggEAoHgkSGUZkEGX375JVFRUTg5OVG7dm22b9+e68WGgkePUJoFAoFAIHgUlGtLVr8XTzcTJkxQd8h72qhZsyb79+/P1tzl/Pnzj14wgV2EyzmBQCAQCPITc5r8v+YroBFKs0BQUBEzzQKBQCAQ5CcBVeStsw0egOlxSyMQCPKIUJoFAoFAIMhPei2Hq4ch6SZI3o9bGoFAkEeE0iwQCAQCQX7zy8sg6aD94sctiUAgyCPCplkgEAgEgvxG2UpbuJwTCAosQmkWCAQCgSC/SE2EL8rDnej0AKE0CwQFFaE0CwQCgUCQX6SlQEJMxvFTNtMcHBzMzJkzH7cYuaZ58+Z53n2vadOmLFmyxLECPcWkpqYSHBzMgQMHHrcoKkJpFggEAoEgv0hLyRTwkErzlikQMc32uYhp8vl8ZPfu3RQqVIhnnnkmX/MpaPz+++/ExMTw0ksvqWEajYbVq1c/PqGAvn370rVrV4ekNWHCBGrUqOGQtHKDk5MTb731Fm+//fYjyzMnhNIsEAgEAkF+kZZsffywE81aHWyZnFVxjpgmh2t1D5lB9sybN4/u3bvz999/c/Xq1XzNy5Gkpqbma/qzZs2iX79+NjcoeVjyW/ZHjSRJpKWl5Spur1692LFjB8ePH89nqXKHUJoFAoFAIMgvcjvTnJpo/89ooXg3GwdNx8oK8t+T5PN/T5KPm46FhsNzl24eSEhIYPny5QwePJjmzZuzYMGCB07j4sWLdOnSBQ8PD7y8vHjhhReIiYmxijNp0iSKFCmCp6cnr732Gu+8847VDKcyezpx4kT8/f3x8vLijTfesFIumzdvzrBhwxg5ciR+fn60a9cOgIiICOrVq4ezszNBQUG88847WRS4tLQ0hg0bhre3N35+fnz44YdI2ZjV3Lhxg7///pvOnTurYcHBwQB069YNjUajHtua+X333Xdp2bJltrJv3boVjUbD5s2bqVOnDm5ubjRs2JCoqCi7ck2YMIGFCxeyZs0aNBoNGo2GrVu3AnD06FFatmyJq6srhQsXZtCgQSQkJNhNa8GCBUycOJEjR46oaS1YsIDz58+j0Wg4fPiwGjcuLs4qL0X29evXU7t2bZydndmxYwfNmzfnzTffZNy4cfj6+hIYGJhld8hChQrRqFEjli5dale2R4lQmgUCgUAgyC8sZ5obDAWdwXa8T4va/1v+qnXc3d/I/7d9Lp/f9nnG8aIe1nFnVrWdZh5Yvnw5gYGB1K5dm549ezJv3rxslcnMmM1munTpwu3bt4mIiCA8PJxz587x4osvqnEWL17M5MmTmTp1KgcPHqRkyZLMmTMnS1qbN2/mxIkTbN26lV9++YVVq1YxceJEqzgLFy7EycmJnTt38t1333HlyhU6duxI3bp1OXLkCHPmzGHu3LlMmjQpy3V6vZ59+/bx1Vdf8eWXX/Ljjz/aLdeOHTtwc3OjUqVKatj+/fsBmD9/PteuXVOPc0tm2RXef/99pk+fzoEDB9Dr9fTv399uGm+99RYvvPAC7du359q1a1y7do2GDRuSmJhIu3btKFSoEPv372fFihVs2rSJYcOG2U3rxRdfZMyYMVSuXFlNy7LdcsM777zDZ599xokTJ6hWrZpaTnd3d/bu3cu0adP4+OOPCQ8Pt7quXr16bN++/YHyyi+En2aBQCAQCPILZaa5UAjU6QfR0dnHf4KZO3cuPXv2BKBr164MHjyYiIgImjdvnqvrN2/ezNGjR4mOjqZEiRIA/PTTT1SuXJn9+/dTt25dZs+ezYABA+jXrx8AH330ERs3bswyC+rk5MS8efNwc3OjcuXKfPzxx4wdO5ZPPvlENZEoV64c06ZlmLG8//77lChRgq+//hqNRkPFihW5evUqb7/9Nh999JF6XYkSJZgxYwYajYYKFSpw9OhRZsyYwcCBA22W68KFCwQEBFiZZvj7+wPg4+NDYGBgrurHksyyX7t2DYDJkyfTrFkzQFZCO3XqRHJyMi4uLlnS8PDwwNXVlZSUFCsZFi5cSHJyMj/99BPu7u4AfP3113Tu3JmpU6cSEBCQJS1XV1c8PDzQ6/V5Kg/Axx9/TJs2bazCqlWrxvjx49Uyf/3112zevNkqXtGiRblw4UKe8nQ0QmkWCAQCgSC/0DtBQFXwLpZ9vPeysQ/WZLJTHnsGdsyQZ5Z1TmBKlU0zGo8CTaYPyCOP5k3uTERFRbFr1y7mzZsHyApZly5dmDt3bq6V5hMnTlCiRAlVYQYIDQ3Fx8eHEydOULduXaKiohgyZIjVdfXq1ePvv/+2CqtevTpubm7qcVhYGAkJCVy6dIlSpUoBULt27Sz5h4WFodFo1LBGjRqRkJDA5cuXKVmyJAANGjSwihMWFsb06dMxmUzodFltxu/fv29TaX0YMsuuoMzQAgQFBQEQGxsLyHWp8N577/Hee+/ZTOPEiRNUr15dVZhBrgez2UxUVBQBAQF4eHio51555RWr2e68UqdOnSxhluUBuUxKeRRcXV1JSkp66PwdgVCaBQKBQCDIL4rWhME7IP4axEaC2Y55hpO77XBb7P5GVphbvC/bOCuLAHVO8nFe082GuXPnUrduXcqVK0d8fDwgL9J6/vnn+frrr/H2fvK2B7dUCvMTPz8/7ty5k6u4Wq02i0mL0WjMEs+e7AZDRv9RFHuz2Uzx4sWt7Ip9fX1zJY89LNPy8vKyG0+ZXbcsk63ygO0yWZYH5DKZzWarsNu3b6sz948bYdMsEAgEAkF+s2s2LO8NqfYXW+UKRUFWFGaQ/7d437ZXDQeQlpbGTz/9pJpmKLRt2xY3Nzd++eWXXKVTqVIlLl26xKVLl9SwyMhI4uLi1FnSChUqZLH/tWUPfOTIEe7fv68e79mzBw8PD6tZbFv5796920rB27lzJ56enhQvXlwN27t3r9V1e/bsoVy5cjZnmQFq1qzJ9evXsyjOBoMBk8lkFebv76+aWigcPfrwXwP0ej1ly5ZV/xSl2cnJKYsMlSpV4siRIyQmZiwI3blzJ1qtlgoVKgBYpVWkSBG7aSnKrGWZLBVuR3Ds2DFq1qzp0DTzilCaBQKBQCDIb/RO8v+H3dzEbLJWmBUUxdlssn3dQ7B27VpiYmKoUqUKx44dIzIykmPHjhEVFUXTpk2ZO3durtJp3bo1VatWpVevXhw6dIh9+/bRu3dvmjVrpn66Hz58OHPnzmXhwoWcPn2aSZMm8e+//1qZS4Dshm3AgAFERkby559/Mn78eIYNG5aty7chQ4Zw6dIlhg8fzsmTJ1mzZg3jx49n9OjRVtddvHiR0aNHExUVxS+//MLs2bMZMWKE3XRr1qyJn58fO3futAoPDg5m8+bNVgp1y5YtOXDgAD/99BOnT59mwoQJnDhxIlf1lxeCg4P5999/iYqK4ubNmxiNRnr16oWLiwt9+vTh2LFjbNmyheHDh/Pqq6/atGe2TCs6OprDhw9z8+ZNUlJScHV1pUGDBuoCv4iICD744AOHlmH79u20bdvWoWnmFaE0CwQCgUCQXxz/DWbVlG2QgYd21Nzi3awKs0KzcfJ5B6MoxW3atKF69eo0atSI6tWrU7VqVX777TcOHDjAv//+m2M6Go2GNWvWUKhQIZo2bUrr1q0pXbo0y5YtU+P06tWLd999l7feeotatWoRHR1N3759s9gMt2rVinLlytG0aVNefPFFnn322SzuyjJTrFgx/vzzT/bt20f16tV54403GDBgQBYlr3fv3ty/f5969eoxdOhQRowYwaBBg+ymq9Pp6NevH4sXL7YKnz59OuHh4ZQoUUKdKW3Xrh0ffvgh48aNo27duty7d89qQxRHM3DgQCpUqECdOnXw9/dn586duLm5sWHDBm7fvk3dunXp0aMHrVq14uuvv842re7du9O+fXtatGiBv7+/+oVh3rx5pKWlUbt2bUaOHJnFG8nDsHv3bu7evUuPHj1yjvwI0EgP4i9GQHx8PN7e3ty9ezdbOx9HYTQa+fPPP+nYsWMW2x9B3hB16lhEfToWUZ+O5bHX5/65sG40AMkeJYhu8R0hles4fOHYo8JsNhMfH4+Xl1e+bORhizZt2hAYGMjPP/8MyL6O4+LiHvtue5Zcv36dypUrc+jQIXUhYm54HPVZkHjxxRepXr263UWNycnJREdHExISgouLi9X9fv/+fYfra2IhoEAgEAgE+UWWzU0E2ZGUlMR3331Hu3bt0Ol0/PLLL2zatCmL794njcDAQObOncvFixcfSGkW2Cc1NZWqVasyatSoxy2KilCaBQKBQCDIL7Jsoy0+7maHRqPhzz//ZPLkySQnJ1OhQgV+/fVXWrdu/bhFy5HMO/0JHg4nJyeH20c/LEJpFggEAoEgv1BmmvWu8n+hNGeLq6srmzZtyjZOXrbvFggcgVCaBQKBQCDIL5SZ5uJ1oFRLcHLLPr5AIHhiKbBW55999hkajYaRI0eqYcnJyQwdOpTChQvj4eFB9+7diYmJsbru4sWLdOrUCTc3N4oUKcLYsWNJS0t7xNILBAKB4KnAlCr/L14XwoaAk3uWzS0EAkHeeNT3UoFUmvfv38/333+fZfvFUaNG8ccff7BixQoiIiK4evUqzz33nHreZDLRqVMnUlNT2bVrFwsXLmTBggV89NFHj7oIAoFAIHgacC0EhULA3U/13vGkbAksEBR0UlPll1J7G884mgJnnpGQkECvXr344YcfrHwB3r17l7lz57JkyRJatmwJwPz586lUqRJ79uyhQYMGbNy4kcjISDZt2kRAQAA1atTgk08+4e2332bChAk4OTk9rmIJBAKB4L9Is3HynzEZ3Z1z+BjSiI2NBcDNzS3Lph1POmazmdTUVJKTk4WLNAcg6jPvmM1mbty4gZubG3r9o1FnC5zSPHToUDp16kTr1q2tlOaDBw9iNBqtVthWrFiRkiVLsnv3bho0aMDu3bupWrWq1Y437dq1Y/DgwRw/ftzmNo0pKSmkpGS4DIqPjwdk35/29ld3JEoejyKvpwVRp45F1KdjEfXpWJ6U+tRc+Qf9gvYE+ARj6rEui+lgQUGSJJKTk3FxcSlwCv+TiKjPh0Or1VK0aFHVzNbyfs+Pe75AKc1Lly7l0KFDNvehv379Ok5OTvj4+FiFBwQEcP36dTVO5i0ilWMlTmamTJnCxIkTs4Rv3LgRN7dHt6DjSfdRWRARdepYRH06FlGfjuVx16dX0gVaAKkJcRw8eBCNRvPIPikLBP9FJEnCZDIRFRWV5Vx4eHi+mEEVGKX50qVLjBgxgvDw8Ee6k9K7777L6NGj1eP4+HhKlChB27ZtH9mOgOHh4bRp00bsDuYgRJ06FlGfjkXUp2N53PWp/XM02qv/YK7SA6LAWQ8dO3Z85HI4isddn/81RH06Fsv6vH//vsPTLzBK88GDB4mNjaVWrVpqmMlkYtu2bXz99dds2LCB1NRU4uLirGabY2JiCAwMBOQde/bt22eVrvKJTImTGWdnZ5ydnbOEGwyGR9rBH3V+TwOiTh2LqE/HIurTsTy2+rwTDTFH0VXtDoDGlPqfaFfRPx2LqE/HYjAY8sUzWoGxOm/VqhVHjx7l8OHD6l+dOnXo1auX+ttgMLB582b1mqioKC5evEhYWBgAYWFhHD16VF2EAfIUvpeXF6GhoY+8TAKBQCD4j6NsbuKc/mUyLVlscCIQFFAKzEyzp6cnVapUsQpzd3encOHCaviAAQMYPXo0vr6+eHl5MXz4cMLCwmjQoAEAbdu2JTQ0lFdffZVp06Zx/fp1PvjgA4YOHWpzNlkgEAgEgodC2dzExVv+L5nBnAY6MasoEBQ0CozSnBtmzJiBVqule/fupKSk0K5dO7799lv1vE6nY+3atQwePJiwsDDc3d3p06cPH3/88WOUWiAQCAT/WZSZZkVpBlmRFkqzQFDgKNBK89atW62OXVxc+Oabb/jmm2/sXlOqVCn+/PPPfJZMIBAIBAIyZpqdvaD+YNA7g0Z4zRAICiIFWmkWCAQCgeCJRplpNrhCh88erywCgeChEEqzQCAQCAT5hbu/bMdseHR+/QUCQf4glGaBQCAQCPKLwTsyft+LAWMSeAaB4dHtNyAQCBxDgXE5JxAIBAJBgeaHljCrBsRGPm5JBAJBHhBKs0AgEAgEjwJ9umtTU+rjlUMgEOQJoTQLBAKBQJAfpCbC/5rDvPaQlgr6dJMMxaOGQCAoUAibZoFAIBAI8gPjfbj6j/xbqwe9k/xb8aghEAgKFGKmWSAQCASC/ECZUdY5gVYrZpoFggKOUJoFAoFAIMgPlBllRVlWbJrFTLNAUCARSrNAIBAIBPmBohzr0s0y1JlmoTQLBAURYdMsEAgEAkF+oJhhKMpyubbgXQL8yj0+mQQCQZ4RSrNAIBAIBPmBap6RbpZRd8Djk0UgEDw0wjxDIBAIBIJ8QQJXX3At9LgFEQgEDkDMNAsEAoFAkB+UaghvR2ccpyZBaoI88+zi/fjkEggEeULMNAsEAoFA8CjYMhm+KAfbpz9uSQQCQR4QSrNAIBAIBI8C4T1DICjQCKVZIBAIBIL8IOovWPAMbJkiH4vNTQSCAo2waRYIBAKBID+4ewnObwc3X/lYbG4iEBRoxEyzQCAQCAT5QZYdAcVMs0BQkBFKs0AgEAgE+YGiHKs7Aqb/FzPNAkGBRCjNAoFAIBDkB2KmWSD4TyFsmgUCgUAgyA/UbbTTbZl9y0D1nhAQ+vhkEggEeUYozQKBQCAQ5AemVPm/MsNcoq78JxAICiTCPEMgEAgEgvxC55yhNAsEggKNmGkWCAQCgSA/6DBV/lMwm2WTDVMquPo8NrEEAkHeEDPNAoFAIBA8Cq7+A58GwXdNHrckAoEgDwilWSAQCASCR4G6uYnwniEQFESE0iwQCAQCQX6waQIseRHO75CPVZdzwk+zQFAQEUqzQCAQCAT5waX9cOovSLwhHyszzSahNAsEBRGhNAsEAoFAkB+ofpptbG4iSY9HJoFAkGeE0iwQCAQCQX6g7giYPsOsbKMNGT6cBQJBgUEozQKBQCAQ5AfKTLNOUZpdsp4TCAQFBuGnWSAQCASC/ECdaU5XlnVOUOnZ9GPNYxNLIBDkDaE0CwQCgUCQH6g2zekzzRoNvPjz45NHIBA8FMI8QyAQCASC/MBslP+LbbQFgv8EYqZZIBAIBIL84O3zYEoDjcX8lCSByQhanfwnEAgKDGKmWSAQCASC/EKnB63Fo/ar6jDJH64efmwiCQSCvCGUZoFAIBAIHhW6dLdzwnuGQFDgKDBK85QpU6hbty6enp4UKVKErl27EhUVZRUnOTmZoUOHUrhwYTw8POjevTsxMTFWcS5evEinTp1wc3OjSJEijB07lrS0tEdZFIFAIBA86WyZAhHTbJ+LmCafz46UBFjaC1b2l000FCw3OBEIBAWKAqM0R0REMHToUPbs2UN4eDhGo5G2bduSmJioxhk1ahR//PEHK1asICIigqtXr/Lcc8+p500mE506dSI1NZVdu3axcOFCFixYwEcfffQ4iiQQCASCJxWtDrZMzqo4R0yTw3OyRzYmwcm1cOxX67jKBidpYittgaCgUWAWAv71119WxwsWLKBIkSIcPHiQpk2bcvfuXebOncuSJUto2bIlAPPnz6dSpUrs2bOHBg0asHHjRiIjI9m0aRMBAQHUqFGDTz75hLfffpsJEybg5ORkK2uBQCAQPG00Gyf/3zI541hRmFu8n3HeHpZbaGssfDKLmWaBoMBSYJTmzNy9excAX19fAA4ePIjRaKR169ZqnIoVK1KyZEl2795NgwYN2L17N1WrViUgIECN065dOwYPHszx48epWbNmlnxSUlJIScmYEYiPjwfAaDRiNBrzpWyWKHk8iryeFkSdOhZRn45F1Kdjeaj6bDgKrcmEbstkpG2fozGlYmr6DuaGoyCn9JITMQCS3pk0i7g6nRNaIC31PlIBbGPRPx2LqE/HYlmf+VGnBVJpNpvNjBw5kkaNGlGlShUArl+/jpOTEz4+PlZxAwICuH79uhrHUmFWzivnbDFlyhQmTpyYJXzjxo24ubk9bFFyTXh4+CPL62lB1KljEfXpWER9Opa812coz2j06EypmDR61t4LhT//zPEqr/sXaQGkpMEGi/j1bsURBBz7Zz8XLnnkUabHj+ifjkXUp2MJDw8nKSnJ4ekWSKV56NChHDt2jB07duR7Xu+++y6jR49Wj+Pj4ylRogRt27bFy8sr3/M3Go2Eh4fTpk0bDAZDvuf3NCDq1LGI+nQsoj4dy8PWp/b3oeikNCStDp05jWc8IzE3eSvH6zRXDsFJcHb3omPHjhnp7YzCfDWQKrXaU7lMqweW53Ej+qdjEfXpWCzr8/79+w5Pv8ApzcOGDWPt2rVs27aN4sWLq+GBgYGkpqYSFxdnNdscExNDYGCgGmffvn1W6SneNZQ4mXF2dsbZ2TlLuMFgeKQd/FHn9zQg6tSxiPp0LKI+HUue6jNiGhxdBoDGbIKm49Bt+wydTpezTTOyxwyN3sU63+bydQVmFb4dRP90LKI+HYvBYMgXz2gF5r6VJIlhw4bx22+/8ffffxMSEmJ1vnbt2hgMBjZv3qyGRUVFcfHiRcLCwgAICwvj6NGjxMbGqnHCw8Px8vIiNDT00RREIBAIBE8+yqK/4vUywmr1lhcB2vKqkRnLhYACgeA/QYGZaR46dChLlixhzZo1eHp6qjbI3t7euLq64u3tzYABAxg9ejS+vr54eXkxfPhwwsLCaNCgAQBt27YlNDSUV199lWnTpnH9+nU++OADhg4danM2WSAQCARPKWaTrCDfPAWX079QJsZmzDCbTdlfX6YlvB8DZjuLkSTJ2quGQCB44ikwSvOcOXMAaN68uVX4/Pnz6du3LwAzZsxAq9XSvXt3UlJSaNeuHd9++60aV6fTsXbtWgYPHkxYWBju7u706dOHjz/++FEVQyAQCAQFgRbvyv9/6pIRlnhT/p+jaQayQmxwATLNNP89CXbMgPpvQLvJDhFVIBA8GgqM0ixJUo5xXFxc+Oabb/jmm2/sxilVqhR/5mLls0AgEAgEqqIMkBBrP15u0WjBnCY2NxEICiAFxqZZIBAIBIJHjqWinHgj99ed2wqrBsG+H6zDdcqOgGJzE4GgoCGUZoFAIBAIbGE2w/3bGceWs845cSMK/l0GF3Zah6s7AoqZZoGgoCGUZoFAIBAIbKHVwvvXIWyYfGx8gM0S7HnP0DtbnxcIBAWGAmPTLBAIBALBI0dngFYfQZuPQavL/XXKTLI+k2cmRYk2pTpGPoFA8MgQM80CgUAgEGSH3vnBFGawUJozzzQr5hlP2Uzzlin2fVtHTJPPCwRPOEJpFggEAoHAFtHb4dfXsi7myw2qeUammWavIAhpBoHVHl6+goRWZ3tTGGUTmQd9KckvhHIvyAZhniEQCAQCgS1ijsPRFXA/Tl7Ql3gTev8u2zrnhL2Z5uDG8t/ThuLbestkuBMNDYZC1J/ycYv3c+f7+lGgKPdgLZOi3Ld4//HIJXgiEEqzQCAQCAS2UFzMeReHg/Pl3/fvgHvhnK+1N9P8NNNsnFx/e76Fw0vksCdJYQZr5V45tlSYnyRZBY8coTQLBAKBQGCLxHQfzV5FwbWQrPAlxuZOae74ObSeKJTmzJRuISvNIPusfhKV0Gbj5G3Ot0yGLZ8CklCYBYCwaRYIBAKBwDaKX2Z3f3Avkh6Wyw1ODK6ycu3sYR1+/Rh8Vgpm1XKcnAWJgwsyfptS7dsPP26ajAE0gPTkKveCR45QmgUCgUAgsIWiILv7y3/w8Ftpa7SQHAfJdx8uHUfyqBa/RUyDqHUZx1W6214c+CSw40tAkn8/icq9WLD4WBBKs0AgEAgEtlAUZHd/8EhXmnO7K+DOWbB2FFw9bB2ubm7yBO0I+Cg8W1jaBVd+Tg4rVls+ftIUZ0VW7xLycWjXJ0/GguKN5D+GsGkWCAQCgcAWSbfk/x4WM825Nc+I+hMu7pZteIvWyAh/Ev00Wy5+i7sAbSfDvv85dvGb2ZSR1vHVUKQSlGgAxWtnnH8SUJTOcu3g9AY5LKg6BFS27VXjcSEWLD4WhNIsEAgEAoEt3r4ASTfBzU9WmjVaMN7P3bX2vGcoSrPZCGZz7tzXPQqajZNd7P2zCP5ZjMMXv7V4V/5/ZBm4+0HD4bLdt5L3k4Ki3Mcczwi7cx6enZVx/knBUnGOmArmNKEw5zNCaRYIBAKBwBY6PXgGyr8bjZAXh+X2s7fdbbQtjk0poHV9eDkdRe0+ELmafFv8ZjLC6jdAMsOYUxlK85OEotz/r3lGWNwF+f+TqIw2HC4rzeY0ecv3J1HG/xBPyCuuQCBwCGJxiECQPzzoVtrqTHPmbbSds8Z5UjizOeN3fix+i78iK8xag7wQ8sxm2bXbk8id87Z/P2ls/CDjt8n4ZNld/wcRSrNA8F9CLA4RCBzDpX2wcgDs/jZv19ubadbqoXhdKNX4yVIYI6bB7q9lhRag/huOX/wWd1H+7xkI39SFRc/JnkSeNJLvyj65AYJqyNueP4lETIP9P2Ycl+/w5C1Y/I8hzDMEgv8SljZukgRVe8DRlbD1U2HrJhA8CLEn4NhKSLkHYUMg6TasGy0rVK/+lvP19rbR1mjgtU2Ol/dhUF6q/SvBjRNyWEgzcCvs2MVvitLsV16un8RYOcy10MOn7UjupJtjuBWG1yMeryz2UNqs6gtwdLkc5huS4Y0ExHifDwilWSD4r2GpOG/9VP4tFGaB4MFQvGQoruZ0BjieriynJoKTe/bXK0qzzil/5HMkZhOEDYXd32SE3TqdMWY4avGbojT7lJRfPhSlOai6Y9J3FIoNc6HgxypGtlh6IwluDNu+AIOb49tMYIVQmgWC/yLNxsHWz0AyARqhMAsED4rlxiYATh7yrHFasuy/2Tck++uHH5TjehXNXzkdQYt3ZftiS6X55mn5vyPHjsxK85UDGWFPEkm3ZDMan1LysTFZ9nbi7Pl45bJEWbAIUKu3vIhTQYz3+YawaRYI/otETEtXmAEkYeMmEDwoqtKcvn22RmOxlXYuNjjxDIBCpeQZ6szMbQfTysCVg46R1REoSjKAq2/+zJBbKs0+Ja3DniRq94X3Y6DzTAgfD5MDYMfMxyyUDcxmSEmQ+6bgkfDQM82XLl0CoESJEg8tjEAgcACKrVujkbBzphwmbNwEggcj80wzyP6F717M/QYn9rh/R/b/nJr0cOk4klvpSnPDN6HtJ/mTR5tP4OYpKFE/YxvxJ1FpBtndoM4b3Hzl4yfRg8bdS/BVNSgUAsMPyT6/JUko0flInmaa09LS+PDDD/H29iY4OJjg4GC8vb354IMPMBqNjpZRIBDkFkVhrtUXjBYP5Fp9xKrqJxnhKvDJI0FRmv0ywjyUmeYclObURPhznOwOzGzOev5J3EpbmWn2r5B/eRSvDTVeBp8SGaYPT6rSrKDKeeHxymELpc30LvDXO/B5WTj26+OV6T9Onmaahw8fzqpVq5g2bRphYWEA7N69mwkTJnDr1i3mzJnjUCEFAkEuURaHaLTwt8VsUVA1OVwsDnkyUVwFAjQclRFuuS3u08KWKXJ92PoqEjEtvY+/m/Wco0lKN8FQFGXIUKATY7O/NuUe7Ptevg/bTsp6/kncSvvWGfl/4XKPJr+AUGj+HviVfTT55RZJgvkdZVv0TtMzFgPeeRKV5lPyf79ykHZffpmzNLMROJw8Kc1Llixh6dKldOjQQQ2rVq0aJUqU4OWXXxZKs0DwuFCUieXpi0K0BnkBy/Wj0PmrxyeXIHssPJ5o46/hbKyBdvsXsO2zp8/zieULhGW5H/ULxOiT8oIw5fM8pG+lrct5K217G5soqDPNT4jSbEyWXeqBrIBt/liesWz+LlR/yTF53D4H0dtkt3Yl68tKafO3HZO2I0mIgYu75Beebt/JdukgvyjlxmvKo0RVmsuDq096WNRjE+dpIE9Ks7OzM8HBwVnCQ0JCcHIqAO51BIL/OtePyv9rvAz/LJZnvgT5g6NmRpuNg4RYdPt/oB2ggadPYQZrl4n378i+xs9szlCYH1V96PTyYj5Lmr8LLT+SbUezw97GJgrqTPMTYp5hcIH3rkL8ZfklIfmubMN746Tj8riwC/4YAWVawaurHJeuo1Fsl72Ky4s4XQuBszek3JVNSYpUeqziWWFpUuPibR0myBfyZNM8bNgwPvnkE1JSMm74lJQUJk+ezLBhwxwmnEAgyAMp9+RZHYBmb8sPwx7zHq9M/2UcuQujixcgK8yS1vD0KcwKzcbJn+73fAs/tHr0CrM99M45K8xgf2MTy3QATE+I0gxyuRSPFoqJhiMVMEvPGZZhZzbB7WjH5fOwKGYYygyz5e8nzURDmVX2Kyf/gWxmI8zw8o1czzQ/99xzVsebNm2iePHiVK8uOyU/cuQIqamptGrVyrESCgSCByMmEpDAMwi8iz9uafLOk2LbmhOWM6PKsaUpwYMoekdXqj81ZqOczuNWFB8X5dumb84jye7PHmU9XP0Hds2GwGrQeOSDX5/TTLNvaXl7ZhefPAqYzxROtzNW7JwdgS2lOfwjecOYtpOh4RMy4abMNFsqzeXbQ0AV60Whj5uk2xkLUguXA4Mr6Jxlk5+4izn7ERfkiVwrzd7e3lbH3bt3tzoWLueeMAqKwiFwPNf/lf8HVn28cjwsT4pta26wVJy3fQ6m1AdXmP+epK7Q31xpKs3976B7ml0Fhn8k/9do5fp8lC8QN0/LNr0JsdZK873rsP5tWSnuudT+9Yqtss6O0pxfLt3yyuaP5a9T9V6HUmEZi/Nun5OfFQ/ytcQetpRm5ffdSw+fvqOwtRtgywccax7F89dklDc1SboNzh5yWOGyEHtc7r9Cac4Xcq00z58/Pz/lEDiagqRwCByLMlOiKM1HV8qfucu2eXQvSo54aDhyBvdR0GwcbJsmK3gPaloRMU1WtgHJqxgJzoGYmwxAp7NzH//XiZgmLxoDeGaG/Fn8UdaDuoV2EetwjQ4iVwMaMKXJds+2yGmm+UnjzCa4dgSq9JCPvUvICr8pRVYifUs/fB7ZKc1Pkts5Zfz0Cc57Go/i+esZAM/Otg4rFSbPhuvF2rL84qE2N7lx4wZRUbJNTYUKFfD398/hCsEjw1LhMKVBrVfgyNInV+EQOI526RubIMnHKffkncdcvLO7yrE46qHRbByY0+Rrtk4Byfzk9t+IafLsD8geSx5kZtRskj8Bn92CFNJc3pzAmAT1X884/7Sg9BGFY6vg/A6o/NyjU5wT0l3KuWd6prn5km5xLnvWyLxQUKFUQ3mziYKwyYQkwa2z8m+/8vJ/rQ4Kl4HYSLh55uGVZpMR4q/Iv62U5ifQV7Nkll+OLGeaQX4RSoixlt8ej+uFv9P0/ElXoJInpTkxMZHhw4fz008/YU533K7T6ejduzezZ8/Gzc3NoUIK8ojVJ+Op8u8nVeEQOBYPi4d9YDX5//Vjubv2SZslVuwrJTNo9U9m/906Vba/De0qz0S6eD+YgqfUZ2oSpsQ7VFj2PvrpA6HZ2CezvPmJ2QSVusCJNbIdaUBliI6QXX09Kl/jyjbZmZVmrQ7cCss+nBNv2FeandxkpdMeu76W/ThX7/n4zeTuXYPUhKyKYrFasp2sJk/+AqyJvyrfvzrnjK3IwXqm+UnZya7/X/JEk6Ust8/BrFpgcIP3ruROzmbj5HrdMhm2fgaSybHP37iLcv80uDomPUGuyNPdMHr0aCIiIvjjjz+Ii4sjLi6ONWvWEBERwZgxYxwto+BhaDZOVjQA0Dx9D2CB7CJJo5X9jN6LyTm+o7xBKB4QtkyGCT55n2XZNDHjtzntydvVMGKarDBrdLJiYHCXXXblZRdGJzfwKEKK3guNKQXObnWcnI9i10FH5NHi3QyzhnJt5D+A0+HQdOyjUTJtbaGtoO4KmMMGJ9mRmiArPQ+7HbcjUHz9Fgq2/qzf5RsY+DeUa/3weXgUgb7roPsP1t5HvNPXQqXEQ3Lcw+fjKHR663HOs6j835gof2HILYqZjmR6cJOtnPipK0wOggu7s557lC5Gn7LdTPOkNP/666/MnTuXDh064OXlhZeXFx07duSHH35g5cqVOScgeHhy21EjpsmKBgASrBMvNf9pTq6DRd3hgMUaBCe3DBdSiv/m7Gg2TlZut0yWZ1BTEvI+S1y0RvoPSVYqH/ShsXWq7DtWQaN98rYDN5ugeD35wagzQKVn5HC9c+5nRjPFueFVRf5xaa9c/47Aka7x8jsPvTM4eUC5tlCqkTzDl3A9d/3XESgKsS2lWd0V8Kb96y/tg00T7G9p7MhttB9WaVHcyikuy/IDgysEN4bQLtbhTm4ZdfwkmWhkxuAieyOCDJvn3GDp51ox2XIEaSnpckjWXwfSUuHLUJhSPGOzmvzmUYwrTxB5UpqTkpIICMj6WapIkSIkJSU9tFCCXJCbjho+PkPRCe0qn9//45OlcAgcy8Xd8qKemOPW4cqiQMWzRk4os8RbP4UpxfKmMEsS/P6mxbFJ7pO5RZnBbfE+TLgLJerLM7khzZ4sxbnZuIwV91Wfl/9AtsVtPDp3M6NrhsGcRnBqAwCJTkWQvEvKD9oLOx0np/Iy9Pck+aHqaDtLyzyU9slLHl2+hnHRcpvrneU2Bzi98eFlzA2J6bOJmRcCQoaSl90s8ZWDsGOG/BJrC8WrhiN2BHxYpUXdPtvOdtamNNvhjqLlB9B1DngVy998csO/y+HHNrK7wcyovprP5y6tiGlwbmvGeKDVO27cun1OHk+dPMEzMCNc75RhTqN8QchvLO/5dWNkhf5JXrD9kOTJpjksLIzx48fz008/4eIiO2+/f/8+EydOJCwszKECCuyQk80owM6Z8v/4KxA2TLa11Dylq/GfFpSZuMzu5gKrwrGVDzZT55fpIdpg8IPJ8utr8uyg1iDvWBVzTO6TTu6563vmTDaAdQbIi+Nq95FnrZ6UxXHR2+QFQq6F5N3ONBpw85PtXs9tzfnztiTB2b/lutKlfx7XaJBCmqE5/DOc3QLl2+UsR25t0SWzvKgy3VuHwx9sjnC/B9amAuXawKn18gth07ccJ6s9RhyWP8Pb8qOsbKWdms0E0aPcRvth1w8Yk+R7NPNMszEZvmsMd6LlF5j0jXfyxPHVsvlFSLOsrtBq9819Ovntyi3mGFzeJ9tzZ6ZQsDwpEZeLDU4s67/pWPnF5Oo/ENzEMc9fRSH2L5/VvtqvnOzC7+YpKNkg73k8CM3GyXWz/0fYPxeQ/pMKM+RRaZ45cybt27fPsrmJi4sLGzZscKiAgmxoNg7ux9n2LLD5Y/mTpjGJU261OHGrKC39a+F54xB3i9Tn2tU73Dl7i3ohvgDsi75N7L1kini6ULtUIQ5euJPr49ykUS/EF53W/uIJk1myut4RctmTc2/0bQ7e1FA4+jb1Svs7JM3MsmdX1tyQuT5yVZ+SpCrFpoCq7Dt7KyN+QFW0PiW5nubJvsNXciWn+eI+tMg+ODSAeeGzSK/9bbOdshAxDY6tRDK4cqVCP875NqFQTScq3T+IfstkTlyLJ67uqOxlCKoG9+MwpSSx7/J9Ys0NKdK6FbWDfTPq4uytPPXHvLSzXTnTNyQxh3Zl74V7xN5Lpn6JDgScXsqFk4c4klgp+zRunJQVZr0LphIN1P5ZvlQdKvEzSSc3ER6UizbLrceS5u/IYVL6S0e9QbbTewhMTcaiifgcrSkVCQ3mRqPAxj1usyx3L4N3cat7oLhTXWoD0qW9rN8XSaHCAQ65z+yi1amzzFnuxRbjOVjuLWITUimSPoZmkeNRb6PdbBxmSUK7ZTKmiGnozEbSmr3H/uIDiM3pfn92NnSaAea0LGVtkHwXjTmNiN27cSpZx/79nhP7/id/Mek+F5NPcN6fFfntyk3Z8c+nVNZnkldJdMD5M5FcK2qn3RVunYFqL8kKs0YDDd+Elf3kL4BNxz78C7+iNPuVzyqnbzl0Z//mdOQhbnp3yl7O9JcQU5OxWdrk+h8fk5Scwp16b+V8r13YLb/4A49lM6JHSJ6U5qpVq3L69GkWL17MyZOyzc7LL79Mr169cHUtGCs5v/nmGz7//HOuX79O9erVmT17NvXq1XvcYtlFu22qPPNi2RHvnIcTv8u/JTNWC/18SoExiWv4se7vCMJ037LF7MOzejDFHKfLxcEMPv4WhwwGAIxG2VXWGUlLL/NzDNWuopHuGDtNVewe6zRmoiHbNHQaMyPSehDo5cyMwI2USzxIUvEmBHb+iIMX7lBo3xfcuW9m1PW2PJ+4JFdp5iRXbuT0BfaeW0NvB6Y5M032cZpdWd1cnAns/BHX//gYt8vb1fPKAOXurOe+EbaeiiUpJdVufQZ5u/BTma2USzwIpZvL7R5/FZJuYdboaPlTDM8mfmMl5w+a6cRdN8KRwwC200jn9PIPKRf5HTtNoVzHl+66HWivHmL1x10ZmZyhZAV5u7Ag5G8aXQpH6xkJLdNnecwmToe+yRtn6tP1nxXU1U1ko6kKXczPMVTbA92xK8w8vCdDBv90jzvKLJIkyQN6zFFmrT2AOTneqg3MEozUr8xSN/nRd6zqO7OcxmT1Hhz6b2nK7hlHI90xVpvK8r35G+7s9AAy1XfmNM5uAeCmby06T99Fj4QldNQd4+9z5amg1+B29zSfLv2bGHyzbTOrGcfobbIt8MVd8m+LWR/z1qloJVPGy9CPrdnb4S9iE1IylJbtn2c82LOb2Tu3NYscfx27xsXfJjDInJruEEHi5qRytNN8T9z9jE/9NsuSEAszKpPgGcIzKZ/SOfFXGumOsdVUhUhtG06YS7JmVSSJRNuvz0xot39Bo1O/WffPzOWwU9a/jl1j4h+R9EhYkqX/ZVuOzDPNmfNQXLjdjMpwTZi5Pm0dW6YB6szqX8euMXF3HbZLWvRmIyZJQ/mNVTBLe7KXU0Gn568TN7j42wSrcUer86W+NpZV4VtZY06zf7/nVJ/p9sp7brsxaurfVvU5xNyWKppzaJDYZq6efbta9vHz2zM2XsnUx1U5bPTPbOVMN704eM+bYZnkXIkf0w1w+dwJXonKYey6flR211eygWzGc3YL+FeCVh9C+Q5WiyHz1D/T7dBPmQLpk0nOP/HkEwNciDrMa8eykVP5vWUyc7ed5V5ymprGbg2M1q9kurEHs4/syb7vJN6UXwgUstuM6D+wsdoDK81Go5GKFSuydu1aBg4cmB8y5TvLli1j9OjRfPfdd9SvX5+ZM2fSrl07oqKiKFLEhg3bk0Bms4rb52BBZ+tFUkiwsDP0/p17EbPwBKJMRRll+JWdplCe1e8hzuzOQak8hbiHSdIyUloGwHRJVvjGGFbSwBRJI10kO02h2R5PN8rXZJfGLlMlhutWQSKEXVzJTlMojW7N4MuDl5AkCNMep6HuBNNN22hkyF2aOcmVFzkdkeZI/UpMkjbbslbUnWDnoQ1qmo1uzVCPlTTHGFZS3o6cSpznE5ZQLnIlt/wbUFjpF+mu5U6ZivJs6krGGFZayZmcamI2z6m9xWYazcZxZunblDspK8xKnocpTQ3dObqylYs6H740vaCmUeHkSs45h+K37TPQyQPyX/59GbzhEMN0qxhuWK3WH0ZYZmqBOX05hSLD6dA3KRfgmdHHSzeHmKMkSwackm8y1PC7moaTMY0YCuHBfV4zrH8k7WxXTv8KkBLPFakw5ZIOMzr9XnvDsJZEowuzTVnrO0sal/cD8MOVUvRgCWMMct8Zavidg6ay/GluQAqGbNssC+e3y76NkSCkqRzn5J9c3rWU4hfXAPCvqTTVdefQ3jpN6sKujDDKD7L33H9nkGlpxqxddjN7IU2tzof/c5qAVS/SXif7/f3dFEZn3W4CNHdYbRpGc2Zm3//St30/dxc6m35V60Lpy0tMrXKuz0xy6rZ9huRRCZ1F/8xSDsuyJsRC0i1OUYLBB+szTLfKSg6M2GxXq3JYzjTbyqPaS7INsd4lQwGM3pZRn/aOM7dJi/fZdOgkI5afYJ5hGnpdugtYjUSEYThNUmchvxpl33f+OnaNyF8+YLRhpdV9869JNqUorb0GZuiRfr8f18v3e5pGy/6Sr6kzlPUv/YhWWYegyGk2qT6a31x/mxd1W6zqMzjtOt31OzhhLsm21Oo5t2uzcRn1oRDcNFf9M9t2B9X04v0t8fTQ/m0l509pbVhpasq/5pDs+1/RmrLC7OQhvyzs+FKW48YJeaa5YqeH65+gzjRPPwQ9NEus5Fye1hSAMpqrgNxm5SJXsrXoQEr7e1DyyAzMksTeEq8RHt8Jd2MUY1gKBjL6OMgKc3o/t9t3zCZYNVB2Wwjyi3rp5rKcWybLXjyU3S//IxurPbDSbDAYSE52gB3WY+TLL79k4MCB9Osnvx199913rFu3jnnz5vHOO+88ZulsY27yVsbuYEm35dktxVl8iQayO59F3SB6G+Y5jfGMP0OKpKe57l+18w83y4P/v8bSXKdwljxmm56jgTZDeehl/IDFTLJ7PNv0nKwQZ5PGHnPWm1CRQwmT0NBIF8k+UwVWmxvxgnbrQ8mVFzkdkaZJ0ua6rHmVU4kz2rCSL409WBHfk53ND6DdMhlzcFO0gBmNqmRYPtwVOf5neoZBurW200hNpOjJ+Vwx+6pK42zTc8wzdWCXdjjemiQaaCPBhJUcP5m7sb/ZUQxbJmO+eYatJ0oxTHfOSg6lLt7Ur2K5qQXXpUIZMpxtzo4eLdEBbJmMOXINWuCsVJShht9t1ucPaR1VxT6/29munA3fZLauL5VTjzDa8KtNOZeYWtFTt9luGpLWgAYoprlBb/2mLGlsNdcgDk+77Q5AoxEQMRW2T5cfShHT5EWEICsXa4ZiOrKM4ulhSh4/8AVtdIdopjvKVOl7Lkv+DDLJbZYU34nWoYHUby5/9r94O4l/QgZSM/oHSh6ZkTGzl/4wNJtMVNi2kJK6a1Z5HJbKMt7wM8HaWDYYxtLO+Ln9PuxfCS2QKLnY7DtKm2bXJoCVXKam77DrXijPeEZab0tuz+43PU6KpjzDdFdsyvGMbjdnpGKcNJe03SZF021iLx+QFTxbeShhCzrLbVSsDnT8AtaOzFCY+/whT4REb5M9tPiVU79MAJjvx1Fma3d2Ot3FT3uPnaZQdpmrMNawnBLaW+xzGkLD1NkM1v1uW86bp5FuncbvmpHRhmN2x4wO2n3UMURljAnJchuMifgUs2k10VJFzkhawgzpSqSt+sTAS7q/7d4nxTQ3sm9XU6rs1zn+GkRvQ9Jo0UjySwLnt3FtyRD2hb5vt3/mtt0BOmr38KZhdRY5pxt78JOpXfZyKhu2BFSGHV9ysfoo+b7x+oGSNu6jvPRPc9nWrNe2oK72JK/p19usz1KaGH4xfEKY7oR8/lwLOAdjXV9k6NZPkUy/sco4klct1onW12Z4+zAgfxXKdtwB1SzDXKw2e5v+TOy9ZOqExlIs8gfYNYuTt4y4ubhYt0kBRiNJkpRzNGs+/fRTTp06xY8//ohe/1CbCj5yUlNTcXNzY+XKlXTt2lUN79Onj+pv2pKUlBRSUjLszuLj4ylRogQ3b97Ey+shFkbkEqPRSHh4OG3atMFgMKDd/jk6ZaMSwFy8PqY+GSu0dYu6ob2wXT3OPAgOT581SZH0OGvSuGKWledi2luYJQ1ajUS82RUv7X01jqKYKOdvmz3w1Saox0dNwWw017FKV0lDiQOwx1SRdeYG+JCg3tiW563KLWm5KXkTpL2jpnnB7E8p7Q1MkgadRuKm2RM/7T01DUVOJX6S2Qk3bSpmCbQaiDV7o0HCXxtvt2xKmhl5eOFnET/G7EOANk71w3/L7EkaOgK0cVZlmW7swV3ceVG3lcraC1ZltV+/spw3zN5oMVNYe0/NZ4+pIg10J9VrLNt1Uf86hF2eJ89YpMfP3O4A/zNMp63uoFo2e2kozDQ+x0xTD/W4EPG8ottk1c6WaSzoXYMm1xag256xOjyzHFP13/OiPsKmnIv616F+iC/avz9Bt/sru2l8qf+G5/Q71TTumw24ao1WaYL8wFfqXGk3pexKH1bKcdHsT0ntDTWNZLMBF61Rvd6mnNu/QLftM5t1ATBGt5zhhtXZl/WPN9H9u8Ruu2W+X+22O/J8oqmp/NIvh2nQkPXemmHszlem7ulHEuuc3qWy9qJdGXxcdCxlHBW5oPbR73UvUazzh7SrLHtR0m6eiG5PhseBxWkteT/tNfX4A/3PvKZfD4BR0mHQmLKW5dKP2fYdpS7SJC16jdnq/JBmITQsU5h6p2fgtH8OZo0OrWTC2OQdjGEj1DHUec9Xct2kK1ympu9gbmK9sFC3rCfaMxtttj3A+/pFDNT/abddM99HtvJQ+o6k1aMxp5EZRT7lvKlUE3QW4zqApHNCY0pVj/ebyvO8cQIAL+i28Jn+B7Qa1DbLSU5bY8YM/Td0s7jXlBdLhaWGj2mgO6nm8WV6GrNfqp7RN/4Yju7fX+z2r1G6FYww/GZTDvU++XM0un9+yiirpgp1pWNqX1DrWtKi05iz9k+lvtPrzGabrB+L7tD8PN+Lspxj0P2zUL0fv9e9xJTEZ9U03tIvY5h+jdq3vte9RGDH9+DyYev+mZ2cOYw7ipxKm2Rusw/1PzFA/xeAVVmH6VfjrLHuizk9K5Qx5p5Hadqkfs71eFlX8ucOW51H465JsTtm5BeWOtP9+/fx8/Pj7t27DtPX8qQ0d+vWjc2bN+Ph4UHVqlVxd3e3Or9q1So7Vz5+rl69SrFixdi1a5eVp49x48YRERHB3r17reJPmDCBiRMnZk6GJUuWPLadDzsf7odWMmFGyx81F1id05vu0/Hf19EAqZKO8ik/Z7k+yrk3zpq0bDdgUjp6iqSnQspPRDv3tBv3pLkE7VOn5ird7G7SzNedNJcgRHMNZ00aKZKe81IgFbSXbaQqXxuSskSVQZE/OxmUsp1z7mVTcQdIkpzRYVJl2GmuQkvdYdsJI6f5dVpXK4UtOxQZzjr3QpdN3MrJcznk/LoqR4WUjAdI73ImavtJdPqnP3rSSJX0lLc4r9BGe4AfnL4EsvaN3uVMPKPfT73oWYCs2JSz0Xcgo//YkqOrZhu1Lv6QnodtOZT6NklayqQsylKOMjHrqXL1F6v6sUSLmbPOr9jsY5blOuv8CjqLB6qtuE4aEymSnm/TujDKYNunrknSUCZlcRY5AbXObckpl7UnWg2kSVrK2iirV9IFmkV9hBbJbhqnnHvjpEnL0ia9y5moUziNzof7KRs7ExXYlYrXV3Mi6DlOBXSh5oUfKHlnh0WZs7aJCylEOvdT7xfLB2RNzWm+MsympNbaJ7EcpxttAu7TR7uesLg16CT5XrbVdzSYmWP4ivY62RTFVt9p43KSJqcn2zyvoNwnkgQrTU0Ym2bt0cWXeA46vyHvQi7pqCv9xHPBZqoXltur1M0t1Lgk+zA3a3T8UWN+ljwqXFtFxeur7crhzn2OuwywWZ9Ku6pjdHoeZgnOxmuIN4KXAUI8JbockfuOgqJoZcaInjrmhRzQ9MagMdkcXzP3L4CW2kPMNXyBRmP7fq/tJ/HsP33QINm8HiCQW+x2Ho5GY61AzTV15HvDlzTRZewympGGhI8TjK9lQquBkrciqHlxrt36BNTni3yvLVJrom0xE88F3KT5qQm4pN0Fsipy7+kWM8iQMXEkyyGXtX95ue3dUm7QOvItNEiYNHrW1piXRQbfhCgan56MJhs5lbHP1r1Y20+i+sX5BN/aYlHWhVi2aiHiOZTeP+W+s9BKToBnDvdHJ6VhRsM5/zYcL/6Ker1H8hVS9N60PzoMLeYc5VReKi6Z/dhkrk1n7W78tPFWcY2Sjllp3RhjWKm+0MaZ3fDRJmVqV+uyKnKa0FImWamLjLI20h5lsZPsI9xeWfObpKQkevbs6VClOU/TxD4+PnTv3j3niP8B3n33XUaPHq0eKzPNbdu2fUwzzV/Ii3h0TmhNqTzjGWn1Jqrd/oWqMDtpTAzXrcryFqooPM6aNNakyS8OXfS71RvmhKkElXSX1DiLDZPQpD/49Rozp81FKae9qh4fN5fKkq6ShhJnl6kS9bUn0Wlk5QDAWZOmyrnXVIH6uij1+h/TOqDDREV9hhz69NX+SppnzUGU0V5T5V5smGQlwzFTMFV059Xzv6Y1xoSWF/TbrMqm1UhZ0lSOL5v9KK+7osYvhLzTkpLm8rRm6DDRXb8Do6RVXwKU+GmSli3mGrTRHcq2fnUaST2/Mq0JJrS8qI9Qw/5nmK4O1s6aNKt2bdukvvzmT0bZM7c7QCVNhqukzH2jY73y1P39DUCerTHY6DuW/cckabLk06p+NWquHaa2kZMNOYbrVqkvEjqNmVG6FcwwPa+Wo36wD/ov31TTsFWWobrVqlJk0Jj41xRCNV20VZ9X0lfa8by5CMHaWPX4jLkoZbVX1fpqqJUf/koaSppyOlKW+q4f4ovup2fQpr+k2JJTLqv8W68x20xDu/0LtFGS3XYbrluFU3qfMmhMjNCt5Kv02f+2TeoTdmCEqjBrgIrXV2Ns8g63SvTHdC+Fi6HzKLqjP/qLOzDZaZOBunVo0x/iTpo0xhhWUlZzhTLaa1TRnk/vE7KioryMjjGsxEeTwDNxewjQxKlpKW2SOQ8JLbclD7vt2rZJfRpu/0bNy15dyDLIL6PP67fjrUlikDFjw6bZhlmqQmnQmBhjms9Hp/rTr7yJse3L4fJDXzWuVjJlGT8BdHO/yLb/vabLUNAy16dyL1qO0RXv76PPuRbqLBzAm/pV6PVpap1n/pJ00FSW2roz6f0xjW+lyRi0JvX8V8ZueGkS6affqKaRWc7KmvNqXWS+3xU5lS8RmfunwvO6CCuFWbF5Ha1fmUVxt0wjLhX8QxvI98nP3+XYrhqNPJmh00j8bPiUV42y3ev2K0ZG3ZqFC3fVNtFrzKrpFMCnpl5U1kbTSBepyvGebglTTL1YH+PGuJcb4TSnDhokJI0GnZRms9212yPRnCbb+9nZ4l7Mcj+X9ED/hbxI2ogyTv9mlcYruk0WbSKf/9r0HKvOaxn1Qgvc9s1CJ6UhaQ1ozUbK3thIaY9UTC+vQBMdgW7Vp0ho0WK22z/tPYv7aTeo7XBJ8idYG2t1z6smHroMEw+lPjOP02GX58ly6pzQmVKzlBOglua0+tuyrOtj3BjXq2m+eb7JPNPsaPK0ucn8+fOz/XuS8fPzQ6fTERNjvZ1wTEwMgYGBWeI7Ozurux4qfyDbdj+qPzW/XTPkz2kt3kfz4Q1o8T66bZ9h2DXD6ry5+Xs0c1nBl8YejDGsVJUI5WaYbuxBhZSfmG7sQRf9brrodzPd2INyKT+z0xRKJd0ldppCqZDyk5XNaNmURew0hVJOe1U9nm7sQXf9Dqt0LdNQ4jTUnVAVZmeLm7R8ep71dVFqntONPXhNv55++o1WaZbRXrOSQzlW5FbkVOJX0Z1XzytyvqDfZpVm5rJlzqO87opVmjV1Z63SfEEfQXf9jvT6k8s6xrBSHbT0GjNtdIdyVb9Kmj3023lRH2F1TSNdJPfMLhg0Jv5IayDbButWEeTtQsOrC9R2b+6yPEu7K20/2vArc9Pac1+S/d8qcXxcDVTZ3AeNMZFUZ1/CND+r5cicxhjDSvaZKqBLN3lQ5PBxkmh85G00yXeRDO60dl6cJQ3l+i+N3bkiyWZBIwy/qeUIK1sEQ8QUNMlxSDpn2jr/nG0fVuqmmi5abquUDLmVOEo7Bmtjrdq1bHofVtpA6X/lLdLcZQqlecp0NU0rObd8jPaS7JngReev7cq5Iq0JAPfSbXSt0rC4X221m5LGLGNXbkjeAIwyrMpo90s/oDslmzxo2k6WfcAC83ed55V5Bxi94ih7F76H/uKOdCWjq902ke/Fn1TTli763arCHGP2UWf2SqcsVuMM0P+FP3Fq/1DaxF7f6anforZJ5jpteHWBWp8fG0Zk2+4VUxYQaS4JQFvdQf52Gs1Lur9ZbJiUvvg4lGiz/An4Vf0m3tEtYdV5LfoTqzNsYAHKtLIeP9PHUG36BkDTDG/YlGOUYZXqPeM74zM270VljD4d+iYVTn7N84m/WN+L+ow632kKpYHupFV/rK07Y9UfLce26cYejDD8po6PSrvZqq99pgqsNdXnl7TmtuVM32RlhbaD3ft9urEHZdLbvZEukjRJqyq5ANtNlQGINJe0SuNWUppcnxd3Ya7Riz5OX2bbrpvMsh14E91xPtfPASQ+N3xPJeSX1wOmcnxt6qrWh2UaSrvfk1wwSzDIsI5hulVcu5vC/Z+eRxt/GTQ6NHUHQdNxNts949lp/16clyb7SzdJGhtjwido0pJJ07tRIXmh3TZRFlfuNVVgjGElw3SriEvVcHvDVNVcRiOZoVhtALTRWzHMqYd+6YtoUu6hTbmLuWRDmriszNUzvpLuEmZJVlDTJC1z0joTrI2VleS0rmTHPUn2hmY5Tje8/KMsZ9Nx7Ol5MttnxRGT7CXmkKmMWtZrd1P45/K9R6Mzpf92JA9lkBwbG0tUVBQAFSpUeHI9T1jg5ORE7dq12bx5s2rTbDab2bx5M8OGDXu8wmWDdvsXkD4Y23W/k766WttsHOP9rvHGoueQSPceoI20WthlC2XwUQYlywVRto6Hm7Oa4WROI3OcA+by6oxAbuLnRa68yOmINDOTU1nzIifABQL40tiD0YaV9PG6jHbrHijXDu2/S1lQLoX2BzLaXcFyJqGs5irNdP+SIukZY1hJh7S9eMRdwizBysQa9ORX1ZbZVhqLTK3Zrh1JgDaONWlhjDaspJvzMXSn5UUkmpYf8I5nTd5YJKnXZe5/Uvpixcvmwow2rKRzmaLoth+EnfJiEU29gYw7m8wbizR2+/Cj6DudzbvV+2WMpZy7ZDMWSjTg9frNeWORl005/2d6hs66PXhqkpmf1ta6rFsmQ50BaJuOZbxfTLb36w18+MSwgATJRa5vp2i02w8CkOIWxEbnjpwr3g7T6c8YzVLu6dKytLsl9sYEy7ICpEkaArRxduPYMunInIYtOWabnkMD1n24Sg9wcqdpsRd5bUV0tmNXx9QpLDFMoqHuBKW115mi+dHK5taTJLY4jcJPe4/XDWupZjqLYfuJ9DarL29P7l9Rdglmuahpy2R585LEG7RtUJPnN7nblGOI/ndcSWWRuQ1JRhfrcrR4H7yKYY74gg9Pl6VuulJhqy4cMeZmrnN7Y/01yc9azkYjYOdXgAbvLp/x5XL3HNtMSdtyHcn4tH6UM10hSipOZ+1uNY2a0fshffGXttk4Xil7jcGLAuy3qwlW8SG1dGd5Xr+doppb6ph31BRMD2OGmaSy4C1zGoq9rjIj3lL7D4WuyZ5ckEzw7zIw3odm72Rt9+bvoW3+NuP9rjE4m3uxrjaKqtrzbDLVtL6f986B5u+xyaUd5tVX7LbJDXyopvsRI3pV4WygjaTU0Uio3B2O/woBofDaZlj8PJwJlzeYUQhujLbvOsYfy17OzG2mzNIPs1hYPVKf4WEpcxoA1bTnKK65yXFzqYxxZ5s87tyL3Mj6+Gf5KZv7/ZRUgu91M/DWJKllBYi9V8NmPy4I5MmmOT4+nqFDh7J06VJMJvmTuU6n48UXX+Sbb77B29vb4YI6kmXLltGnTx++//576tWrx8yZM1m+fDknT560uT24JfHx8Xh7ezvURiY7jEYjf/75J894HEWX2U+zgh1/lB2/2k7ktfj0gVn2v/iNhY/RkfqV6puY4tPWJGn5JpPPWnvHir1odmmoLuXSb0IlDZBvrF2mSuw2V1YfILlJMye58iKnI9JUvGfktqzK+cxlN0nyByDL42/Mz/E//ee01v3DFlN13nMbb+03M+4i/PMzNB3HX0X68/avR+mdusxKzh80PYhLMvKm7ldGp9vvnjcXIRU9JTU3OGoOoa7ulNWgm7lNlDRG65fzpn41UeYS3CzZnorX1lDYFIvkGcTezn+z71IiX4afUtPI3P+KcIddzsMxoyGqVC+qhhSVO6WFD1GzWaL+p5u4kZBqMw3FxV9+t/PMtB54kcjy6oeoGJg+th1cIG9I0mk61H2NV+fuZfvpmzbl/Mkwhaa6o0ylL8+FemX4Sz29Qd4lrNFIaDORD347yqK9F22mMVq/nN7acHy0iWw3VcZFY6SKJhpXjZENpjqckEqqfsIz9yVbL8mZ+1/mc5YL7jIvJLKMY2uRmWUcW33HmVRqaM5y0aumXd+v83ZE8/HaSLtjl8K3+hl00O1XzccsbS9LaGLY4PQ2bppU1Q44rdl7XErUEnJgEjdLdaRQnyVZfVLv+wESY2HwLv664cuoZYd5zbzSSo5DTgPx0STSKuVzkrzKZC3H3HZwaQ+vp45kg7me3TZR+rC9MSE3Y4TS7pnbNXN9ZfG1W6ohLOgke3sY+S9rDl/hzIqPsow7ShpKm+80haLTmDFJWpvK+Zu6VXi5aOnfKAStTp/F7/XIpYcZKK20KacWM0N1q63WhJw2F6VN6hdkxl4fVuTcZapEde053DWyWczFaiMJivwBQ1oipjd2o4tam9HuZiMcmAdFKsOrv/HXyVuMXHaYgeascr6mW8cHhsXsN1fEp0rbLP6Pd5+9xcs/7LErZ2XNedY5v0e85Eb1lP8xTLeaRrpjBFVvRylvrbz9eq0+8Gz6i/nK1+DYCvm3Rgfjb1vV54ilhxlkpz4t22y/VJF6mhPq89jW/Zo5jVH6FZgkLbNM3RmuW0VT3b9U0ZzHVZPKBlNtTkilsh13vEjkH+dB6DQSjZK/4jnddnQaM/X7fUFYmawevByBojN17NiR+/fvO1xfy5PS/OKLL/LPP/8we/ZsdTHd7t27GTFiBDVq1GDp0qUOES4/+frrr9XNTWrUqMGsWbOoX79+jtc9LqW5Y8eONj812Ns57t/LcUxZL8/8ffViDdCQ5938HmZHQMvNS67HZ7gq1GqwUkoCvZx5uV5Jgv3c831HwN1nYtm4fS9tm9R36I6AuS2rsqLd8nzmh9uHnSpRyN3ZKt/169fQ5WBfblAI34+irW3Cvm8G1w7DCz9D6LN8tOYYP+2+QIsK/gxqWkaVc8/ZWwxdcog3jT/SX7+Bfaby9DR+wFjdMl43rLM5mPq4GvimVy0alC6sltV75yeUPrsIF42RoalvEoc77+p/YbmpBd7cU8vqotcyuHkZtV0t6+/U1iUsvV6Mzg2rM+HZynB+p7zpg1cQANtP3+DVufvwcNIxu2ct4pONDtuhMtfH8ckk/f4Wz5k3cqzeVGp3ek3eWODrOqDVw5hTpDoXot6nm4hLMvJex0oEeDlbpRHz1zS63viOwy71qfHOxoyKnVlN9gvbczmUb8fQJYdY9+81utUIwjPxslX/TN48hRZX5QWW8ZIrQ40j+MzwA85SKn7ae9l+QcoJy/5n+XnX0r4x84tUTnEsGdaiDKPaVABg07/RNPotDA9NMrEDDlKkRNks8QG+jzjLlPUnqV7Cm/6NQqzqc+eZG3y95ayVLPY8CdTRnGSF08fqwt9KqT9RjBjKaK5yXgokxSuE8Z1DaV8lKCNzs1nekMLNF3QGXvlxDzvO3KJX/ZI8U60otUsV4u6kEApLd9nQZAVtW7bOap+Zfj/2TR3LVnPNPLXLw/Bhp0q8GhbML/suMuH3o1Rwvce6D1+2lvP0Jlg/TnZj13MZkVfj6ThrO+5OOj7tVpUiXhl1rvS/L409mGVDQVXqXUl9ziu15DpNSZD9FBcKhpqvgkbDM7O2c+xqPK81CaFVxQBqlyrErM2n+XrLGTVdZSGbvcXsOZHZLve7tGf4LK0nK50mUEd7ig/1o2nUdVBGu1/YDfPbg1dxGH0cgO7f7uTgxTj6hJWifZUgtS4uXzhN94j2slee/gcIKFkO7l6R+4vBFZNZovHUv7l217ZrXj1pHHMegIvGSIuU6ZyXgvB2ktjzfltclvaA6Ajo/FXG9uKK6zmdk80t6Vt8sYXom0kMaV6GJuX8H7jNLBnQKJjWoYFZ0lDijtEvZ7h+NbfMnhTO5bjzii6cM1IxDprLk4aeQG8XdrzdMl9tmvNTac6TecbatWvZsGEDjRs3VsPatWvHDz/8QPv27R0iWH4zbNiwJ9ocIzcou1VZ3pyZFTBnvRZng9bqoWDrDS9z2IMe241TRl49u9Omct+A2HvJ/JLN1qkPK5ctOeuH+HLrhET9EF8Meq3jyp7LsuZ1y+YmjZthPqDBX3OHhDtX8ShcTD5hMsrO9AECqwJw8rq8YLFz9aJW8mq1GuLuG/mYPiRLTgwx/MFxbX+bCodC3H0jWo1GlSmsTGFOH/TERSPP5I7U/0q71Kl0Tp3Em7rfGJXuhxUgOc3MzE2nmfNKLVUO5f929758M3cfKw9eokW5QtRb0w+XlJukvbKGA4Qy7S/5pa9brWK0qGht+pXn/piH490HiuB8JQ3t8V+h02twNH3Wp0xLcC/M9hMxxCUZ8fd0ZkDjEKu2CytTmDPNuvPbsqNsT6pDaJoZJ71W3pwo7gJoDVCqEWazxK4zsoeKF+sUJ+b4JbV/1gvxpfGtDjxvvM1ow694ae7TWHuUlWlNGWH47aEU5mEtyvBmq/IWD8iVqtswyL2phWWczLI0Kuuv1km7GqWJXFua0LRILu37nSIlRkNaKmz7HMq2huJ1Qatla9QNALrVKEaXGsWs6rNeiC+/HrrC8wlL5M04bCxgUmQI00aqngqcNWkM1cqLpi5J8hdFzd1kBi86lKHkgbxbm2fGF8fbiXI/bx0aoPaJHi4/cCEuld/K17H98E93BZeK420qs0MDBHq70LeR3A+7VPbh+Q0DcJNSSLzXHndv34zI5VpDuUOqcfK5mwkAVAj0pEtN6zrnYmFO+7zJirPNweJ58435OTBCGe1VBvEHe9xbMOTZphl1eSda9h3u6gu1egNwJU5enNW9VnEqBcmKTKOyfqrSnHkhm60FijnxvamzuljRKOn4LK0nIHtkqqM9RWDyGet2j0n3AhJQWU3jcrqcz9UqTvUSPhl1UaYwx/dUoXLqUaIjfibg1Y9h3Rh5M6EuX6Or3JX3O1Vi2JJ/bMqWhp5IqRTBXCdIc5vzUhDPBZtl70lXD8uRFD/fmX01Z/I5bTSZuXRblvPVsFIEebvm2GY/O7+Ii6RDlz5+gzxRk/nlURl3ehjvMMawkhbaw9TSyW2UW4UZYJGpDZDhV2N859B8U5gfBXlSmgsXLmzTBMPb25tChQo9tFCCnPnr2DUGLzqUxQtr5s+XKWnmrA+Fx4BOq8mVovNfIDdlzUtd+Bby5YK2KKWkK1w5sY8KjbvJJ26ekh/Szl7gUwpJkjhxVXYrFFrU+u069l7G4DnN9DID9OvVB1R2A6DldSazRO+zzelpvMBwwxrKaa/QWbuLkppYVWHOnNbEPyJpExpoNVg2vvQDb7udZ2pSF379+RuaOcVwS/Kk0Y+3GKgdRyuNmaP0YP2x6zQq6/fY+m/Rxr1h2QIqJ+5l6z8nqHNgCR5AWuUe7D97i2/SH/adqgbZfBiUDq3Li06juJWYygsX78gz9soGFSXqgbMHxy/f5U6SEQ9nPdWKexN+POP6fdG3uXY3mVl0J1gTw3P6HfTT/YVTJl/HeaFRWX+clBfHXD5kbeWpHFu6+FMUOGXmX+F20WZwMRLDuXBgtLzV97ZpcGghjD7JvWQj+8/Ln6CbV8i6Tkan1chmBpEPpuDbUqoVryO2+qfCzYR037MezmqY3uAEGElJs+PSMH0bbU93dzT3sOEt2/HYUkp8vH24oXHDjRSunztKmZrNbFwoxz13IxGA0v4eWeO0eJdywA6zlOVL3d8na1F0eQe6GnaR8mwnnC3v0/RtqSkUDEBCShp3kuR+VKyQqxqtXoi8RXxuXoRskXmy6HXdH1YedhTF+6QkLyCtqLkEWLR7TPoNl640JxtNxKR7Oynhm9W1bEK5rnD8KE7Rf/Pnvhdpf2YTWrMRk18F9p29xd5zt2zKpRz3TX2beNwI8nZldocKmC4clF+kU+7Ku0QWqWR7cxPLdUzAhUqDSTNLuDnpCPRysdtmlpM48v3Yhn3Rt/kqm4kaZdyZzXMU09zkJf1W9Vxuxp3MZfdxMzDluaqPVQ9xBHlSmj/44ANGjx7Nzz//rHqcuH79OmPHjuXDDz90qICCrJjMEhP/iHyggTi7h4Kg4BDjVo5SiVdIOH8IFKX5+lH5f0AV0Gq5fDuJeylpOOm0lMn0ACzimTGwPsiMjuV1ymA6nReprL1AS91hPjf8Dyc7s9UScO1uMvuib1u9HJy5eZ/B5mU847SZEul+gFeYmjNQ+4eVbfithNTH+uJX6vpGbuFDYU0ce1fOxEnrSVWtK2HL9PTTjqOpxswhevDHkas0KO2bRUatVkOjsn78fuQqO07flJXmc+lKc+kWAGw7Lc+sNihdGIPO2qmR5QvL6LQhdNLtydWLTnbYVGhz8ZANj7zOvJ3nVTd3lljKkt2skl/NznBxDmUTD2JMScJwOlw+UbYNaLXsPBNDmlmitJ87wX7WewAolPN343So/ZlPy7UUtpTqipqLHJNKs9jUinjcM/onR+DgQghuDPUGYjZL3E6UZ40Lezip+Tjr5W3UUu0qzfI1fZpWYOO6VNtxHgIfN3kGOy4pY7Yw0MZsIUCMUwn8U+8QdykSbCnN6Zy7Ic80l/a3Xecgv7Bk/lLXrnIgGzQBVCOae9fP4FzF4oJMSvOVO/KsqLerAS8Xg1W6uXkRys6c4Ofd5/lk3Qm75kMAu8yyUlxRe9F6XFK+1KUrzZfT5XR30lHILdPXgi1T8Eq+Sd/UcewwV6HHmnl0NBiJohSbvpuB0Wjk53Q7X1eDjkFNS1uZpx04f5t+C/ZDmpkfetehQhE3/rwAmmvpM9OB1UBnkO2tbe2gpxybTZyJlV90yvh7oLGzOYKtSRzIeaLGctx5J20Qz+siVNeo2Y07vcNK0cHCnOXbrWeQzm5hiO9pGvoXA55CpXnOnDmcOXOGkiVLUrKk/OZ28eJFnJ2duXHjBt9//70a99ChQ46R9CnEZJbYG32bgzc1FI6+TVhZedZlwc5ou/ZStrCntAgKHhdK9WDZ4Yr4aRtSWwlUlOZ004zj6bPM5QM9sihgDzqjY0u5shxM+xvHEaXtnefZ6leN0Qwx/KGG60ljjOEPK2UnN7OB+cnpG0mUS3et1lx3mBdTP8KTJPrp/rRS7m8n2lfuG5ctTNS/e9AdOwit35M93QCUkZXmHafll4Ym5fyy5J/XFx175PSZNLuHrGIekZNZmD0FDqBctTBi1/hShNuc3L+RiqfT7bzLtQZQTTOaVfC3Xwg7Cr5sH1uWfds/Y7exst0Z8Tf0f9BJs49t5qocl2QXYLH3kiHxKESulu1H6w0kPtlIWnrBCrtnzDT3TlmCt+E0zjHjoHzbrPKlzzQ3LF+MOYUKMXr5EZJSTXbrK6fj3Kz5sGfWleAeAqn/Yow9ZSFfKnxZCXxD4JVV4OLFuZvpM81+Nmaas0Gj0XDXpRikQHLMWeuTitLsK9fx5TvyhhnFLWaZFey9COXWnMDP09mmva6l4u2cvji4mOYWXiQQjwex8UkQY600X7oty1nC1y2LMnr6RhKVzv5IVU0PtlKDLtpdAMSaPBmqW8Z0KWNhZlKqKYt5WsOyftQs6cOec7c5fvUuFYrIM9lScDPoMU91A0iLd21Vt0y64nw2/StX2SIP1ma5IfO4o9NIdn2CW9KhSpCVKd69ZCOc30jDmwchqpKVCUxBJE9Ks+X204L8wdpeWcdPpw/YnF14ECyVFkHBxDO0Db8e8qXyTYtB0jMQgqqrfj0jr8lKc6XArAsfHmRGx55y5cjZ6mm8TCfdHkppb8gr0/XrH2i2Or9RlPt+xrMMMqyj/v/bu/P4psq0/+OfbE0o0FLWgkBZBVkVGLCiAo8KKI4yDs4ziAw4jA48KCAooiiIigyIC6gjOvO4PL/R0VERR1Sgo4gLqywigsiOAmWHFkqbNDm/P06SNt0b0iXh+369+mpzzsk5J3dzkit3rvu6rT/SmOMMsa0o9OZcUnDfp0kuv3NOwZth4ey2X1Ez+zS4EqHJZZxze1m/7yQAVxYRNEf6q+uSAtqyGNipMdd1SC5xoGVxARyAzWZlV51UGp76GM+ql+HsTxgWG56UvqzfdYxPthwy26xtCUFzYF9FBPi929Rn6PIhxdzDbKvrbOvpYtlDsuVEMGhuWNsFh8xjBwajBlIzElx2Mxfdr0vu93Swfc+GzKJnKCXXP5GJ3cnATo1Zvv0I76z7hRs6JTM8tUVYA47LMuajKL56beAkOE/lDbTj5B7IOmYG987aGIYRTM9oXUJPc3HctZtDDnlBcvA4/tv+nuZAD25RQfP5phM0rO1iT4Hp1QPypw+lebtzwqiNCw8ZQDPLcXBnmh+U6pkDU38+mRc05xd4PRjiOcgkx3vU4hyp/rJ4V9m2FDp2ca8JXZvW4bf7n+S6ZT9C43+ZG9dqCJ3KN2ncLv+3A+H8z0oTiQ4WMJ+jTxld6M96srd/huvq0Ellok1YQfP06dMjfR6ST3H5yuEGywH5gxaJTh39Oco7Dp/BHRhUdsU95o/ftkNF5zMHlPbVdiAvtbjgKtK91b9zT2el857g5Ddl7a2uDIHg/kmGcbPtGxpZT/GVczz2Yt6ciwvuG13Uin3WpqT4fmHp+h9pd+0/uKTWWQysvL5yF26vj3o1HaTUjcfweUP2Wd4POgZw77Vti6xYUlpAW1bnNUZh+Sxq+cuAdT5r9tKt9bZl6MyVjLUu5I8WH88xhCkLN/PoTR3LHdwHnp/pp7OLTWFLN+rShT0kW06GPj/XHzQ3SDAHwh07Y6ZW1M+XzwyQazVTNbyeYp6PIz8CT3ZwPx6veSZdm9UpNCA2oKLGfNRo3B52QlJW3oygHPPP1lavDVgsHM3I5kxOrjntdb3CObylsdZtAcfAdWZ/6IoT/vrCwaA50NNc/DHCTSfo2bIuE2veTnox38IWvFYtmD3WXZPjzEG9YKZFkNfT3LxA0Jw/zxdC8+eLy/Mt6jWhS9M6JFmOUcdzhNyDG4Hw/te7jualZ0RaJDpYAGq7HJxo1BuOv4bj4Fqzoooz8udbWc5rchOJvHDylUtT3CdAiT5Nk2qQ6trLxZ7t7N/ZhDbtuxbaZmtgEGDjYkrslPDVdlkqmkS6t/p3ti9CZossa291ZcgfpD+W+wdecMzHbvGVL7hfPosdR7NY7e3McMsvnNvxFYO2XUyd+Lrc+eGf/fWkh3D8rIer5ixn6vXtCu3vfD/oVKe0rB1Hs+h88j+s8HamlSWdZtajLPdeyljrwpB0l8MZOWHlstusFqb/ugNj/rGhyNxrMINmgMYWc8Bh8PmZ4Q+aa5vHO15M0OzzB81GcUFzk9Ayc4EBg858vdWVpV5KR/gKGnsP4svNxWq3m4OHwSw3R17w1axufDBfuzxqNGoDP0FizkGzZJ/VaubknvIH0WXpaT5PZfm/B4S8LiU3huEfhKzfH0jPKHCe+a9rc3KQ97FZDHKLqYde3H27NE3kY6M1V7AV48AG4j1dsa6cBy2uMOtnl4FhGOw+4u9proD0DDj/1x0Als9iWM2T/Hy0Ac2sR2HfyryUphVz/LnbJaSiVDNhBc1JSUlFJp1bLBZcLhdt2rRh5MiR3HHHHed9gheawCfZSImVMi9islgsTHZ+wGWsY8MPzaFlKzMHzm6+iZ/O8gRLOl1STE9zwPn0FlaH3urKkD9Ib2U5GKz3W57gfsfRLNpunc8Wb2+ww5VWMwd9eM47jHW8F5IDmX46m3ve/o47LrZwQ/4dnucHneqi4NfbGf5pehtbjjPCnhaxXPaBnRrz0u3dis29TjfMKk8t4k7z0u/zBeUZgfQMc7KdQHpG/kGAkC9oDqRhlCLHY14PcWEEpOerccrFLPH1ZLcvmd+cPE3jBvXguD9Vo14gaPYPAixm4GVp6jZpRa5hxYHHnPQnoQlYrHDPejNFw9/jnhc0l783uyxK+78HNKppYc61SVxdzIexQBm3gr3uReX5FqzQUZz8922aVINdcReDD9w/r6d+TQe2ra9Cy6thxEfF7iO/I5k5ZObkYrNaSAnj24EyicTrjtVG6v6X2Wy0pBlH2bn63xy1dafXz3/H+sWT5mDHKBJW0Dxt2jRmzpzJ9ddfT8+ePQFYu3YtS5YsYezYsezZs4cxY8aQm5vLnXfeGdETjnXn+/VzpPMXpfo5k3QJpK/DOLQZVr9kflrvPR6ueSSYz9ysbo2Q0ekRV0IJqsrqra4M5xvcFwwSAVKsR3jZ8QwDbN8WmwO5cK+VyT6jUJXfaC/dWNTX2x7DVihgDjifXPZA7nXB5+f/fr2bncvM/8+gFmAJvDb6fGbAB8Gg+XgxQbPXP1iryKDZcw7WvAx2J/T8M1it5OSaKTdV0dPscDiYkziV3UfP0vmUj8YNyEvP8Pc0l1hurgya1U/gT55JZNjr8358PfOatVggKcX88StpIGCklJRz/+i/f+DskV186bsP6+dx0OsA5GRAjTrB+xuGkTcQsEBwH874gqI+8FssFnyNL4MDUOPkT9TDX6o3UJ+5DHb5e5mbh/ntQHmc1+tOn8lsT8+gy7bnAfDt/JyV28+R6niPHR3G0baoWY6rsbCC5q+//ponnniC0aNHhyx/+eWXWbZsGe+//z5dunRh/vz5CprL6Xy+fg7MAhXp/EWpXuxNukA6JJ7+EdJ95hSw8eYLciBoLjY1I8KKKkFVWb3VleF8g/viciCLCpgDDOCU28K3+05y5cWNCq2PZgW/3r7bvqjclVfKo6jnZ992DfnKHzRbAukYAOf80xNbrFDTrFR0tJj0DMMW6Gku4rxyMuE//nE/vcz3yGB6hqPyg2Ywc153Hz3L7qNnuaptAzheIGg+Vnq5uZI0TarBCuMyDDccz4aiCnAUV6O5IhQX5F3Vtj6vHT6FFytWT5Y5KdTLV0GtZBi7GlyJnD7nITMn1/+44gvttzyl8Ur6wH9RysUc+yWB+mTQ/MQ3/oXlCJorcBBgJC3ZcogxG1O5z7aPsY5/09pidiA84xnC8xsu56UOh6KqUy+soHnp0qXMnj270PJrrrmGSZMmAXDDDTcwZcqU8zu7C1BZBrEUVHAWqGjqeZLya9C2J2yApp7dGAfPmi/M/nJzefnMhScfqnaiJOXgfIL7gkHiOPsHOCxe3KXUOjXvW7av/qNJJCqvnK/kBBdbfC0Y6Z7MK7+9mWAfcs368PBRM3i2mW+NeT3NBYJmq/92UT3NgUDa7gpOHJKX01z56RkArerH05CTnPp5G3iSzUo7x3ZA3dZAvp7mcpabC3DabTROcHHwdDb7T2SZHzK2LITDP0Db/tC8V7E1mitT+8YJeLGx355Ca88O2PIeGP6OB5f5mhlIzWhQ20mNuML/r/KUxivpA3/XZnXY7GvFf9k25S0sT09zBQ4CjJT8Y7Se8v6eP9k/CV7z8/0dDdE2h0RYQXPdunX56KOPuPfee0OWf/TRR9Sta36CP3v2LLVr1z7/M7zAlGcwAyhn+ULUvE1HzhpOalpy4LS/5FUjc0aBraVUzqiOqn3KwXkE9wWDRIfFW+Yayw1rO4tdF62qQy57nXgHOfYEvsi9lMPOVjTLv9JqNYNnv+P+iU0aFEjPWNHiHkb8ciMjG19MasED+Cc2wZ73/3NX4UBAgH45X/Cg60G27u4Kjuvh9veD63JyvcG0ifPpteyZcIL6Z5bDxj3Q/G74cTFsed8MRpv3qpTUjNK0TzZjku89TWnNDtjsL/eWr3ZwcYMAg86zNB4Ay2dxucfgBV/7YNBs1GyAJbFpmQfH5fU0V9+gOf8YreI+JEfbHBJhBc2PPPIIY8aMYfny5cGc5nXr1vHJJ5+wYMECANLS0ujTp/jZh6R4xQ1mKM8sUBK74hx2dthb0dG7DYCcmk2wxNVhzU9H+SndDJrbJesDa6SFE9yHmwOZGGfQIyUpoudfHVSHXHaLxUJyoot9x7NIz8gucprkgGPF9DRbHfFk4yTbW8R5BXqabXn3qcqcZoDEpu3gO2iQ83OhdfuOZ+EzoJbTToPz+KDW3XmA4Y43ObSzC3B3+Wo0V5I2DWths1rY7GnKYAeQccBc0ShvGsNAjeaC5eYKCrc0HgBWGzVXziTJ9XumZ49ghuMNTiZ2JOGLOdhXPMm29vdwatfxEr9l21nBlTMiIfBNW0mzND7vvSWq5pAIK2i+88476dChAy+88AILFy4EoF27dqxYsYIrrjDLpQTSNCQ8RQ1iCcwIWJZZoCRG+cuXbfI0p6PVDJq/zGjMnx/5lLHWhdxj8/Fc7hB+9/IqHtWHqSoXbg7kLS18MXtdV4dc9kYJLtqc/Iqaa9dBzdugwcXw7Wvm9OadfgsdbgbySs7Vqxna0xwIfnOKmkY7OLFJ3rcMedUzqiZoTm7VBYAGnCDr1BHi6zQMrss/fXZxUzGXhaNBa/gFap3zf/tVKGguvUZzRXM5bLSqX5Ntx5qHrmjYIfjn/nyzAVaYPpPZcTiTu7bO5webOVDyx5+PcMXBJ83AclMqbFpd5MyHYOaHBzrUqnNOc8ParlJnaTS3u7zKzrG8wq7T3Lt3b3r37h3Jc5ECCg5iCbyJRsvXGBJ5gfJlX/v6s4vGtLYe4gcjpXCN29PZYdW4lcgrbw7k1Ovb4d23vgrOtJJUg1z2xokuhtiW0mHrFri4nRk0/7wWtn4IjS8FINvj5Yx/QFj9Aj2wrTLW8LTjbYwj3YHOoTv35s0GGFDVOc1J9RpwjETqcxrH364CIxdufAY63BzMjQ233FxA7cZtYCPUzj0BmYch67j/4C2A6tHTDHCv4332+utzBwXSM1bMoceefbzFDRUaNC/ZcogxGy7nbtvBYAWZK2xbCw0OTi/mdXyP/39Wv1YcdeLjCu2/uujZsi4/uKw8k130LI0WINFljao5JMIOmr1eL4sWLWLbNrO3q2PHjtx0003YbFXzoiAS6wqWL1vi7cE2bwoXcYxbHV9GrMatRFg5cyB93lw+2VfaTqNfVeayJye4OIz/jTrwFX3gd4EazXE2K7WdoW+V9bL3c7ntK9afLeItNDgQsIj0jCqqngFw2NGM+p7TOM76y+o5zRSu8y03F9AkOZlTRk3qWM7C7i/MhfH1wGWOr6joGs1lVa92DW44/hGH45rRyO1PV2nQ3swlXj6TU3G3AYXLzUVK/sFxpVWQKe51PFhXuxrnM4N5jTf9zWNFjtGyYD7+l37TLaren8IKmnfu3MkNN9zAgQMHaNfOnL1q1qxZNGvWjI8//pjWrVtH9CRFpOjyZYFBFZGucSuRV9YcyAKzaEsFaJTgCk5wQuah0N8FZgOsVyuuUNqCxR8QW71FVM9ofKk5QUW+9IyqHggIkFmrJZzckreg/sXA+ZebC2heN579RkPqWPbg3bUcGwR7maFyajSXxdnLJ/L0jmNM4j2zikjd1rByPiyfia/vQ8xK6wwYNKtbMedZlsFx+QVex59N+4neberTPSWJFT8dAaC2y47XZ1TroLO4MVrROh4rrKB53LhxtG7dmtWrVwerZRw/fpzbb7+dcePG8fHHH0f0JEWk8mvcisSq5EQXK41AT/Oh0N8FepoL1mgGsDrMgNjmcxfeeXxdc2Y3P8Mwqjw9A8Cb1BpO+v+21cAbn8z6Xcf48VAmACl1zy9orlszjnWWRnRhD8au5eZCf9BcmTWaS9M+OYE/em/BarFw74F3If178Lqh31TSu96DZ8nn2K0WGidWzHmWdXBcQS8s38kLy3eGTGD22bYjXDn782offBY14Uy0jscK62PvihUrmDNnTjBgBqhXrx5/+ctfWLFiRcROTkTylFbjtiz3ExEzaE4PBM2ZByE7A9xm8FhUT3NB1jgzkC4yaC7A7c0bLFgl6RnLZ7HjX4/w1z2N2OUzH9uPnoa0n7aUla8+wJ+NdwC48//WsWTLobAPY7FYOO1qCsDhxv1g/HfwX48AVIsazQGNE10kuOzMy/2NOR261w22OOgzOTgI8KKkGhUW0JU0OO5pzxAmOd4r8fXcV6AObSDv+Xz+d5Uh8E3bzZdeRGrrelEZMEOYQbPT6SQzM7PQ8jNnzhAXV32T0kWiWaB82bh8L7jtcv6v2BdaC+YbRDQNshCpDMn50jOMjIN5qRnORHCaeaLHzpbQ0+xPvbAXFTQf3gpr/wa7PgdCK2zE2So/aA4MHu7mXs/b3n4A7DYaBwcPew3znA5n5Jx38LWp4WAG5TzJlyl3m73MdVsC1Sc1A8zgvn3jBO6xLcTq8wfMXjesmBOcPru0cnPno2fLuiS6rCHVdAICgXOggkxZBGLoGR9txVswopaIC+sKvvHGG7nrrrtYs2YNhmFgGAarV69m9OjR3HTTTZE+RxEhr3zZREfh8mUFA2dNeiNSvAa1nXkDAc8cgTOHweqAhLyvuI9lFt/TbIvzp2cYnkLr2PcNfHIfrH8dyCs3B5Wf0xwYPBx4ffi1dRUA9TldqKczEsFXreTW/GC0YNfp0MdZXSpnBIzmPSY53uPLi+6CR45Cv6mwfCZNNj8PVOxgxcDguPy1yPN73nsLz+UOKdc+849fkYoV1hU8f/58WrduTWpqKi6XC5fLxRVXXEGbNm147rnnInyKIhIQLF9W67aQ5S/6QnsokhNdKjcnUgyHzYqlZgNGuiez85YlkNIbHj4Co5YFtzke6GmuWbin2eYwgz+HUURPc6BOs39yk0DljDi79bzqIIcjOHjY/8G6i20PPsNCqm1bqYOHw9G8bjxWfFzz4zT4fCZ4zGC5OtRoDloxh/869Hee9gxhbs7NfLjpAKuajiK3z0P03v+y2fFgGBXaaxsYHJecGJo6d779Gxq/UvHCGghYp04dPvzwQ3bu3BksOXfJJZfQpk2biJ6ciBRQDWrcisSC5DrxfHHmUm63t6St1T9Az5UYXB/Iaa5fu3BPs7tJd7pnv0T9pDosLbiyQMm5qqycUWmDh5fPAquNZskjmWL/J6ln0uDLNOg7BVbMoevOn4GB1aOn2edlTYvRPP/j1fDLaca/vQkAq6UTY61mx8M/1/3MFz8drdABdkVNYNazVQPW7zvJNzuP8sLyXeXep8avVLwyB80TJ04scf3y5cuDfz/zzDPhn5GIlKoqa9yKxIJGCS7gNIcyig4Qg1NoF9HT7IirwXESsXuLGMPj9fc+2wM9zVVXOaO0wcPFBc7lDr6sNlg+k86/yqGvPa96lu/LuVi/eJIj/trHZ3Nyq7xE2pIGIxmzdEOh5T6DMk0sEkkFJzBz2K2ktq5Hz5Z1eX/DAdJPZ1OW/m4L5reLGr9S8cocNG/cuLFM21X2108iIiLllZzgoqdlGylbv4bv10DCRZA6FpqbU/oeC/Q0FzEQ0OWvguEuchrtQE+zGXjmVGFPc2Dw8K1n3mJiGcqbhR18+aeFbrtubshi6xdP8qLlv3kq40YA5i77iTfX7K+yEmn5JxYpTVVOEGWzWpj+6w5FTgpSkMavVK4yB835e5JFRESiWXKiixa2b7l6/6fmggPr4dJhgBlcnQhWzyjcm+xyn+Yx+2vYvRagf+jK3AI9zR7/bIBVEDQHBg+33Vp48DAQEjifT/BVcFroADNIvzlk28rowS1O/olFyqIqJ4gqblKQ/HWaIXonCYlWYU+jLSIiEq2SE1xsMwr0qPqrZ5zKcgcDk6SahYNmp8XDH+xpeIwiUi4CPc220PSMuCqaDTA4eHhXX8gXfL3ouwU8hAweDif4Kjgt9Dj7BzgsXjyGrcj0j6rswQ13oFxVDbAralIQc/zKyaifJCRaKWgWEZELTnKiiy8CU2kH1DZnAzx+1uwtTop34CiitnKcy189w+Il1+PG7sgXWPf6M1w8EOq1BvKlZziqaDbACh48XHBaaIfFW2redFX14IY7UK4qB9hp/Er1oqBZREQuOI0S8s0KCOYkF/FmMHIs0z8IsIh8ZgCHM68KhDvnXGjQ3PAS8yewvgpzmvOrqOAr3Gmh89+3sgRyvDXATsJVtVexiIhIFUhOdJFOvp7m2slgNd8Sj/l7musVkZoBEJcvaPbklBz4Beo0V3XQXFHOZ1royu7BDQywA4qcWCQ/DbCToqinWURELizLZ1HLaiMrLq9HGLs/EF4xh2Z7jwF9qF+76J5muyOOXMOK3eLDnXMudOWONDh7DFJSIalFlZacqww9W9blB5eVZ7KLnhYaKDQtdFX24GqAnZwPBc0iInJh8dcVvtt1G+TkW75iDiyfydlmdwFQv5ieZgA3Duzk4CkYNH8zD/Z+Bb/9XzNorsLqGZUhMC10ceXRCgbS1aEHVwPsJFwKmkVE5MLSZzIAdyyfyT9z+1L/mnFc5/0als+EflNZfGwg8HORNZoD3BYH8UUFzcVObhKbQTMU33tbJ94BwKksT3BZdenB1QA7CYeCZhERufD0mcySLekMPfq/eL/8BgwP9JsKfSZz7I11QPEDAQFGOJ4iPdPLq7VSQlcUN7mJI3aDZii69zaQflFwmXpwJVopaBYRkQvSljZ/pt+RN3DiMatn+HugA7MB1itiYpOAE45kDnOOHF+BYDjXn+9hM+/rjvGc5vyK6r0F9eBK7Ijtj74iIiLFuPboGzgtuXhwmGkVK+YAcDw4G2DxPc2BIDjHU2Aq7UDQHOxpju2cZpELiXqaRUTkwrNiDpfufJGnPUNY0fgO/t15pZnTDBzL7AIUPYV2wJDcxcTZ92M/Xgda985bEQyazfteCDnNIhcKXcUiInJh8VfJONRtIs97b2HPsbOsajoKX9+HYPlM/uR7F4BdR8/i9RU9DUY/95f80b4E+6k9oSsK5jR7qnYabRGJHPU0i4jIhcXnZUeHcQz7vjeQQ2Z2LkP/tpo68ZfxJ36HzZILwB9fX0fjYqo9eK1mZQhfbk7ovge/BO4zkHARkD89I/ZzmkViXVR89N27dy+jRo2iZcuW1KhRg9atWzN9+nTcbnfIdps3b+aqq67C5XLRrFkz5syZU2hf7777Lu3bt8flctG5c2c++eSTynoYIiJSDSxpMJL+Gy7nSGZowHsqy8Pc7ME8lzskuCz9dDZj/rGBJVsOhWybazXznX3uAjMCthsInYeAKwG4cKpniFwIouIq/vHHH/H5fLz88sv88MMPPPvssyxYsICHHnoouE1GRgb9+/cnJSWF9evX89RTT/Hoo4/yyiuvBLdZuXIlQ4cOZdSoUWzcuJHBgwczePBgtmzZUhUPS0REKpnXZzDjo62FJuEoTmC7GR9tDUnV8FrNnGWjYE9zAW7lNIvEjKhIzxg4cCADBw4M3m7VqhXbt2/npZdeYu7cuQC8+eabuN1uXn31VeLi4ujYsSObNm3imWee4a67zNmd5s2bx8CBA7n//vsBePzxx0lLS+OFF15gwYIFlf/ARESkUq3dcyJkAo6yMIBDp7NZu+dEsHyazx80+zz59uX1wA+LzEGA7W8Eqy3mp9EWuZBERdBclNOnT1O3bt689atWreLqq68mLi5vtPOAAQOYPXs2J0+eJCkpiVWrVjFx4sSQ/QwYMIBFixYVe5ycnBxycvJ6EjIyMgDweDx4PJ7i7hYxgWNUxrEuFGrTyFJ7RpbaM7IKtuehU2fD3tehU2fxeMy0i0DQbHjO5f2vzp3CsfBP5vGmHAKbg2yPmR9txRcT/1M9PyNL7RlZ+duzIto0KoPmnTt38vzzzwd7mQHS09Np2bJlyHaNGjUKrktKSiI9PT24LP826enpxR5r1qxZzJgxo9DyZcuWER8ffz4Po1zS0tIq7VgXCrVpZKk9I0vtGVmB9tx92gKE1+u7+4dNfPLLRgBqnTPfkI+mHwiOjXF6TjEQMLDwyZJlYLFw+JgNsPD9dxsx9pc1KaT60/MzstSekZWWlkZWVlbE91ulQfOUKVOYPXt2idts27aN9u3bB28fOHCAgQMHcuutt3LnnXdW9Cny4IMPhvROZ2Rk0KxZM/r3709CQkKFH9/j8ZCWlsZ1112Hw+Go8ONdCNSmkaX2jCy1Z2QVbE+vz+C9p7/kcEZOmfOaLUByopO7//vq4BTQz7oTeGLDjdzcvRNjB3Y3Nzy1H7YAdhc3DBoEwIu7VsLZM/S+vCe9Y2BmPD0/I0vtGVn52/PcuXMR33+VBs2TJk1i5MiRJW7TqlWr4N8HDx6kX79+XHHFFSED/ACSk5M5fPhwyLLA7eTk5BK3CawvitPpxOksPCuUw+Go1Cd4ZR/vQqA2jSy1Z2SpPSMr0J4O4NGbOjLmHxuwQKmBs8X/e/qvO+Jy5qX/eWsms8fIIsuWmO//ZJaXs9idwWVur5nTXNMVF1P/Tz0/I0vtGVkOh4Pc3NyI77dKg+YGDRrQoEGDMm174MAB+vXrR/fu3XnttdewWkNHIqempjJ16lQ8Hk/wiZeWlka7du1ISkoKbvPZZ58xYcKE4P3S0tJITU2NzAMSEZFqb2Cnxrx0ezdmfLQ1ZFBgnXjzveNUVl4uZHIxdZoDk5XkeLx5C72B2QDzOlpUPUMkdkRFTvOBAwfo27cvKSkpzJ07l6NHjwbXBXqJb7vtNmbMmMGoUaN44IEH2LJlC/PmzePZZ58Nbjt+/Hj69OnD008/zaBBg3j77bf59ttvC/Vai4hIbBvYqTHXdUhm7Z4THMnMpmFtFz1bmoPLCy4LpGTk1+LsZibZF1P3eDegk7kwt3DQrOoZIrEjKoLmtLQ0du7cyc6dO2natGnIOsMwv1xLTExk2bJljB07lu7du1O/fn2mTZsWLDcHcMUVV/DWW2/x8MMP89BDD9G2bVsWLVpEp06dKvXxiIhI1bNZLcEScvkVtaygi85u4bf2Raw7nQWMNxcGgmZb4aBZ02iLRL+oCJpHjhxZau4zQJcuXfjqq69K3ObWW2/l1ltvjdCZiYjIhcji7022evPNTFuvDfzmZXDkVVbKm0ZbQbNItIuKoFlERKQ6sdhdAFh9+YLm2o2g6++DN70+A4/X/DZUQbNI9NNVLCIiUk5Wh9nTbPcVP412YBAggNOhnGaRaKeeZhERkXKyOIroaT61H9K3QEJjaHJZaNCsnmaRqKerWEREpJxs/qDZnj9o3rUc3h4KX5iTdgXyma0WsBdRgUNEoouCZhERkXIKBs1GvqA5MCjQP0gwf+UMi0VBs0i0U3qGiIhIOWUnd2NQzkzq1q3H/wsszPVPlBIMmgOVM5TPLBILFDSLiIiUkz2+Dj8YLWlm1MhbWCBozvZoNkCRWKIrWUREpJzyptHOG+xHrj89wz+5idvrD5odeqsViQXqaRYRESmnGrmZ/I/tQ5y5NuBac2HB9AyPptAWiSUKmkVERMrJ5T3DZMc7ZPmcwEvmwkIDATUboEgsUdAsIiJSTnFOM5fZSb7qGR1vgfoXQ+OuQGj1DBGJfgqaRUREyikQNNssBrkeN3ZHHDTvZf74BYJm9TSLxAZdySIiIuXkcOVVzcjJzipymxyPSs6JxBIFzSIiIuUU6GkG8OT4BwAe3Ai7v4DMw0C+6hnqaRaJCbqSRUREyslmt+MxzB5kd845c+Fnj8P/3Qy7PgPyVc9wqKdZJBYoaBYREQmDGwcAuYGguZhptNXTLBIbNBBQREQkDGOtD3Mq28dcZwNzQaBOsy205JyqZ4jEBgXNIiIiYfjR0YH0c9lkE2cuyM0xf9tdgHqaRWKNrmQREZEwBKfS9gfHeUGzZgQUiUXqaRYREQnDQOMrDNshOHURpCSBNzRodns1I6BILFHQLCIiEobfuRfRxrGLzSeuAS4tvqfZoaBZJBYoaBYREQlDrsXMZfZ6/AMA+z4I2acg4SIgf06z0jNEYoGCZhERkTB4rWbJOV8gaO4+ImS9qmeIxBZdySIiImHwWs00jGDQXICqZ4jEFl3JIiIiYfAFe5pzwOeDvd/AL+vBmwvkr56ht1qRWKD0DBERkTB4/ZOYGLnZ5sQmr99grnjwANhq4fYqp1kklujjr4iISBh81nyTmuTmS9EITm7iLzmn6hkiMUFXsoiISBi+aXgbQ91T2VrvOvC6zYUWG9jML3GVniESW5SeISIiEoZTtduyyuegm61BXk+zv0YzaCCgSKzRlSwiIhKGQNqFO9dXaGITyJeeoZxmkZigoFlERCQMzc79xDDbf2hycl1e0GxTT7NIrNKVLCIiEoY2GauZ6XiVTseXFtnT7NaMgCIxRTnNIiIi4fAHyBavGxKawDXTIa5WcHWwp1nVM0RigoJmERGRMFj8QbPV54bEi+CqicF1uV4fXp8BQJxNQbNILNCVLCIiEgaLw6zHbPW5C60L9DKDeppFYoV6mkVERMJg9QfNNm8OZJ2AU/uhRhIkpYQEzeppFokNupJFRETCYPHP/GczPLBjGbzSBxZPAPLKzdmtFuwKmkVigq5kERGRMNjizKDZ7ss3jbY/kHar3JxIzIm6qzknJ4dLL70Ui8XCpk2bQtZt3ryZq666CpfLRbNmzZgzZ06h+7/77ru0b98el8tF586d+eSTTyrpzEVEJJZkN+zKne6JLKhxJ+T685r9gwPzKmeo3JxIrIi6oHny5Mk0adKk0PKMjAz69+9PSkoK69ev56mnnuLRRx/llVdeCW6zcuVKhg4dyqhRo9i4cSODBw9m8ODBbNmypTIfgoiIxABLrUak+XqwiYvzepr9k5vkeMygWfnMIrEjqq7mTz/9lGXLljF37txC6958803cbjevvvoqHTt25Pe//z3jxo3jmWeeCW4zb948Bg4cyP33388ll1zC448/Trdu3XjhhRcq82GIiEgMCPQiFzWNdnAKbVXOEIkZUVM94/Dhw9x5550sWrSI+Pj4QutXrVrF1VdfTVxcXHDZgAEDmD17NidPniQpKYlVq1YxceLEkPsNGDCARYsWFXvcnJwccnJygrczMjIA8Hg8eDye83xUpQscozKOdaFQm0aW2jOy1J6RVZHtac85xWDr19TOseN1O7ABXmscPo+Hs9lmukaczRJT/0s9PyNL7RlZ+duzQq75iO+xAhiGwciRIxk9ejQ9evRg7969hbZJT0+nZcuWIcsaNWoUXJeUlER6enpwWf5t0tPTiz32rFmzmDFjRqHly5YtKzJ4ryhpaWmVdqwLhdo0stSekaX2jKyKaM/sU4d4Lu6vnPbGs3tHH9oCu/f/wtZPPuGHkxbARvbZMzE5dkbPz8hSe0ZWWloaWVlZEd9vlQbNU6ZMYfbs2SVus23bNpYtW0ZmZiYPPvhgJZ1ZngcffDCkdzojI4NmzZrRv39/EhISKvz4Ho+HtLQ0rrvuOhwOR4Uf70KgNo0stWdkqT0jqyLbM33fT7AH4sil5X+NxLu/PS2b9aJFm2ux/XAYfvyOhvWSuOGGnhE9blXS8zOy1J6Rlb89z507F/H9V2nQPGnSJEaOHFniNq1ateLzzz9n1apVOJ3OkHU9evRg2LBhvPHGGyQnJ3P48OGQ9YHbycnJwd9FbRNYXxSn01nouAAOh6NSn+CVfbwLgdo0stSekaX2jKyKaM8atWoD4MSD5eL+WNoPDK7zYgHAFWeLyf+jnp+RpfaMLIfDQW5ubsT3W6VBc4MGDWjQoEGp282fP58nnngiePvgwYMMGDCAd955h169egGQmprK1KlT8Xg8wSdeWloa7dq1IykpKbjNZ599xoQJE4L7SktLIzU1NYKPSkRELgSOuBoAWC0GnlwPjri8DhZVzxCJPVGR09y8efOQ27Vq1QKgdevWNG3aFIDbbruNGTNmMGrUKB544AG2bNnCvHnzePbZZ4P3Gz9+PH369OHpp59m0KBBvP3223z77bchZelERETKwumqEfzbc2QHDpcLajUEV0Je9Qy76jSLxIqY+QicmJjIsmXL2LNnD927d2fSpElMmzaNu+66K7jNFVdcwVtvvcUrr7xC165dee+991i0aBGdOnWqwjMXEZFoFOfMC5odn0yAF7rDDwuB/JObxMzbrMgFLyp6mgtq0aIFhmEUWt6lSxe++uqrEu976623cuutt1bUqYmIyAXCarPhNmzEWbyQY5YjDU5uomm0RWJOVAbNIiIi1cGD3MNZN8yzfWEuKDiNttIzRGKGgmYREZEwLbdfyYkcNz7Ll+YCuwvINyOgeppFYoauZhERkTAFg+LgNNrmrLTB6hkKmkVihnqaRUREwnSFZTNu6zEcZw6aC4I9zUrPEIk1CppFRETCdI/7f2kR9zP4O5rzBgL60zNUPUMkZihoFhERCVOuxUzHONWgB3Va/QpqmzPMulU9QyTmKGgWEREJU67VCV7Y3WYk3QYMDy5XeoZI7NFHYBERkTB5LQ4AfLnZIctVp1kk9uhqFhERCVOu1UzPiD+1EzIOgc8MlnM8Zk6zqmeIxA5dzSIiImHy+Qf+ddixAJ5pD9mnAPU0i8QiXc0iIiJh8vl7moMKzgjoUE6zSKxQ0CwiIhKmtfVu5nHPsLwF/p5nt2YEFIk5uppFRETC9HNidxZ7U80bFhvYzKJUSs8QiT26mkVERMLktFuJs3jMG/7ZAEEl50RikYJmERGRMCXnHuAG61rzhj0vv1nVM0RijyY3ERERCVOXE0tJdfzTvFFkT7OCZpFYoatZREQkXP5qGQB0+W8ADMPIVz1Db7MisUJXs4iISJgs/qD524Rr4boZAHi8RnC9cppFYoeCZhERkTBZ/CkZVp87uCzHX24OlJ4hEkt0NYuIiIQp0NNcx30Ecs4AefnMoKBZJJboahYREQmT1WH2NLdy/wj//D2QFzTH2axYLJYqOzcRiSwFzSIiImGyOvINBAxMoe3RbIAisUhXtIiISJjO1e/ENl9z84Z/Cm1VzhCJTbqiRUREwmTUack73r7mDX9Ps1uzAYrEJAXNIiIiYYqzW4kjMI12gZ5mpWeIxBRd0SIiImGqYZyjj3WzeSMYNGsKbZFYpGm0RUREwlQz6xc6234wb/hrNud41NMsEot0RYuIiITJEZevesZF3YH86RnKaRaJJQqaRUREwmR31gAg23BAl98BeekZqp4hElt0RYuIiITJ4Q+aXRYPhs/sYXZrIKBITNIVLSIiEiaHMz74t8edDSg9QyRWKWgWEREJk9PpCv5trHwBUPUMkVilK1pERCRMTleN4N9enwGoeoZIrNIVLSIiEiZfvrfRnWccuHN97Dp6BoCTZ93BQFpEop+CZhERkfJaPosd/3qEK2d/zhpfewAWrD1J+0c+pdn3LzDB/h5Ltx7mytmfs2TLoSo+WRGJBAXNIiIi5bTjaBZtt85nyJm3iCMXADcOxloXMsnxHl7DfHtNP53NmH9sUOAsEgM0I6CIiEg5eH0Gf9jVlyGeg0xyvEcgA+Mm6zfcZF/N054hPO+9BQADsAAzPtrKdR2SsVktVXbeInJ+1NMsIiJSDmv3nODQ6Wye997C054hBOLgggFzgAEcOp3N2j0nKv9kRSRioipo/vjjj+nVqxc1atQgKSmJwYMHh6zfv38/gwYNIj4+noYNG3L//feTm5sbss0XX3xBt27dcDqdtGnThtdff73yHoCIiES9I5nZwb+f995Crj8Vw23YCwXMxd1PRKJP1ATN77//PsOHD+eOO+7gu+++45tvvuG2224Lrvd6vQwaNAi3283KlSt54403eP3115k2bVpwmz179jBo0CD69evHpk2bmDBhAn/6059YunRpVTwkERGJQg1r59Vmvse2ELvFR45hJ86Syz22hWW6n4hEn6jIac7NzWX8+PE89dRTjBo1Kri8Q4cOwb+XLVvG1q1b+c9//kOjRo249NJLefzxx3nggQd49NFHiYuLY8GCBbRs2ZKnn34agEsuuYSvv/6aZ599lgEDBhR57JycHHJycoK3MzIyAPB4PHg8nop4uCECx6iMY10o1KaRpfaMLLVnZFVEe17WtDbJCU5+d/afTHS8F0zJuMdmDgIEQnqcLUByopPLmtaO+v+rnp+RpfaMrPztWRFtajEMo9oXkVy7di29evXi1VdfZf78+aSnp3PppZfy1FNP0alTJwCmTZvGv//9bzZt2hS83549e2jVqhUbNmzgsssu4+qrr6Zbt24899xzwW1ee+01JkyYwOnTp4s89qOPPsqMGTMKLX/rrbeIj48v4h4iIhLrEnZ/SL/T7xfKYQ4EznnLzbfYP17so2u9av92KxIzsrKyuO222zh9+jQJCQkR2WdU9DTv3r0bMAPYZ555hhYtWvD000/Tt29ffvrpJ+rWrUt6ejqNGjUKuV/gdnp6evB3UdtkZGRw7tw5atSoQUEPPvggEydODN7OyMigWbNm9O/fP2L/hJJ4PB7S0tK47rrrcDgcFX68C4HaNLLUnpGl9oysimpP65ffs/3o3by7ux9k5H0b+aLvFvCAzWLOCtg40cXU69szoGOj4nYVVfT8jCy1Z2Tlb89z585FfP9VGjRPmTKF2bNnl7jNtm3b8PnMF5+pU6fy29/+FjB7iJs2bcq7777Ln//85wo7R6fTidPpLLTc4XBU6hO8so93IVCbRpbaM7LUnpEV8fa85mHaAd/4DNbuOcGRzGwa1nbRPSWJ9fsu50hmNv+s7aJny7oxWWZOz8/IUntGlsPhKFQIIhKqNGieNGkSI0eOLHGbVq1aceiQWRQ+fw6z0+mkVatW7N+/H4Dk5GTWrl0bct/Dhw8H1wV+B5bl3yYhIaHIXmYREZGS2KwWUlvXC1lW8LaIxIYqDZobNGhAgwYNSt2ue/fuOJ1Otm/fzpVXXgmYXfB79+4lJSUFgNTUVGbOnMmRI0do2LAhAGlpaSQkJASD7dTUVD755JOQfaelpZGamhrJhyUiIiIiMSYqSs4lJCQwevRopk+fzrJly9i+fTtjxowB4NZbbwWgf//+dOjQgeHDh/Pdd9+xdOlSHn74YcaOHRtMrxg9ejS7d+9m8uTJ/Pjjj/z1r3/lX//6F/fee2+VPTYRERERqf6iYiAgwFNPPYXdbmf48OGcO3eOXr168fnnn5OUlASAzWZj8eLFjBkzhtTUVGrWrMmIESN47LHHgvto2bIlH3/8Mffeey/z5s2jadOm/P3vfy+23JyIiIiICERR0OxwOJg7dy5z584tdpuUlJRC6RcF9e3bl40bN0b69EREREQkhkVFeoaIiIiISFVS0CwiIiIiUoqoSc+oLgITKAam065oHo+HrKwsMjIyVMMxQtSmkaX2jCy1Z2SpPSNL7RlZas/Iyt+egclNIjnxtYLmcsrMzASgWbNmVXwmIiIiIlKSzMxMEhMTI7IvixHJEPwC4PP5OHjwILVr18ZiqfhZngLTdv/888+VMm33hUBtGllqz8hSe0aW2jOy1J6RpfaMrPztWbt2bTIzM2nSpAlWa2SykdXTXE5Wq5WmTZtW+nETEhJ0QUWY2jSy1J6RpfaMLLVnZKk9I0vtGVmB9oxUD3OABgKKiIiIiJRCQbOIiIiISCkUNFdzTqeT6dOnB6cCl/OnNo0stWdkqT0jS+0ZWWrPyFJ7RlZFt6cGAoqIiIiIlEI9zSIiIiIipVDQLCIiIiJSCgXNIiIiIiKlUNAsIiIiIlIKBc3V3IsvvkiLFi1wuVz06tWLtWvXVvUpRYVZs2bxq1/9itq1a9OwYUMGDx7M9u3bQ7bJzs5m7Nix1KtXj1q1avHb3/6Ww4cPV9EZR5e//OUvWCwWJkyYEFym9iyfAwcOcPvtt1OvXj1q1KhB586d+fbbb4PrDcNg2rRpNG7cmBo1anDttdeyY8eOKjzj6svr9fLII4/QsmVLatSoQevWrXn88cfJP85d7Vm8L7/8kl//+tc0adIEi8XCokWLQtaXpe1OnDjBsGHDSEhIoE6dOowaNYozZ85U4qOoXkpqU4/HwwMPPEDnzp2pWbMmTZo04Q9/+AMHDx4M2YfaNE9pz9H8Ro8ejcVi4bnnngtZHon2VNBcjb3zzjtMnDiR6dOns2HDBrp27cqAAQM4cuRIVZ9atbdixQrGjh3L6tWrSUtLw+Px0L9/f86ePRvc5t577+Wjjz7i3XffZcWKFRw8eJBbbrmlCs86Oqxbt46XX36ZLl26hCxXe5bdyZMn6d27Nw6Hg08//ZStW7fy9NNPk5SUFNxmzpw5zJ8/nwULFrBmzRpq1qzJgAEDyM7OrsIzr55mz57NSy+9xAsvvMC2bduYPXs2c+bM4fnnnw9uo/Ys3tmzZ+natSsvvvhikevL0nbDhg3jhx9+IC0tjcWLF/Pll19y1113VdZDqHZKatOsrCw2bNjAI488woYNG1i4cCHbt2/npptuCtlObZqntOdowAcffMDq1atp0qRJoXURaU9Dqq2ePXsaY8eODd72er1GkyZNjFmzZlXhWUWnI0eOGICxYsUKwzAM49SpU4bD4TDefffd4Dbbtm0zAGPVqlVVdZrVXmZmptG2bVsjLS3N6NOnjzF+/HjDMNSe5fXAAw8YV155ZbHrfT6fkZycbDz11FPBZadOnTKcTqfxz3/+szJOMaoMGjTI+OMf/xiy7JZbbjGGDRtmGIbaszwA44MPPgjeLkvbbd261QCMdevWBbf59NNPDYvFYhw4cKDSzr26KtimRVm7dq0BGPv27TMMQ21akuLa85dffjEuuugiY8uWLUZKSorx7LPPBtdFqj3V01xNud1u1q9fz7XXXhtcZrVaufbaa1m1alUVnll0On36NAB169YFYP369Xg8npD2bd++Pc2bN1f7lmDs2LEMGjQopN1A7Vle//73v+nRowe33norDRs25LLLLuNvf/tbcP2ePXtIT08Pac/ExER69eql9izCFVdcwWeffcZPP/0EwHfffcfXX3/N9ddfD6g9z0dZ2m7VqlXUqVOHHj16BLe59tprsVqtrFmzptLPORqdPn0ai8VCnTp1ALVpefl8PoYPH879999Px44dC62PVHvaI3K2EnHHjh3D6/XSqFGjkOWNGjXixx9/rKKzik4+n48JEybQu3dvOnXqBEB6ejpxcXHBF6iARo0akZ6eXgVnWf29/fbbbNiwgXXr1hVap/Ysn927d/PSSy8xceJEHnroIdatW8e4ceOIi4tjxIgRwTYr6vpXexY2ZcoUMjIyaN++PTabDa/Xy8yZMxk2bBiA2vM8lKXt0tPTadiwYch6u91O3bp11b5lkJ2dzQMPPMDQoUNJSEgA1KblNXv2bOx2O+PGjStyfaTaU0GzxLyxY8eyZcsWvv7666o+laj1888/M378eNLS0nC5XFV9OlHP5/PRo0cPnnzySQAuu+wytmzZwoIFCxgxYkQVn130+de//sWbb77JW2+9RceOHdm0aRMTJkygSZMmak+p1jweD7/73e8wDIOXXnqpqk8nKq1fv5558+axYcMGLBZLhR5L6RnVVP369bHZbIWqDxw+fJjk5OQqOqvoc/fdd7N48WKWL19O06ZNg8uTk5Nxu92cOnUqZHu1b9HWr1/PkSNH6NatG3a7HbvdzooVK5g/fz52u51GjRqpPcuhcePGdOjQIWTZJZdcwv79+wGCbabrv2zuv/9+pkyZwu9//3s6d+7M8OHDuffee5k1axag9jwfZWm75OTkQgPUc3NzOXHihNq3BIGAed++faSlpQV7mUFtWh5fffUVR44coXnz5sH3p3379jFp0iRatGgBRK49FTRXU3FxcXTv3p3PPvssuMzn8/HZZ5+RmppahWcWHQzD4O677+aDDz7g888/p2XLliHru3fvjsPhCGnf7du3s3//frVvEa655hq+//57Nm3aFPzp0aMHw4YNC/6t9iy73r17FyqB+NNPP5GSkgJAy5YtSU5ODmnPjIwM1qxZo/YsQlZWFlZr6NuZzWbD5/MBas/zUZa2S01N5dSpU6xfvz64zeeff47P56NXr16Vfs7RIBAw79ixg//85z/Uq1cvZL3atOyGDx/O5s2bQ96fmjRpwv3338/SpUuBCLZn+OMXpaK9/fbbhtPpNF5//XVj69atxl133WXUqVPHSE9Pr+pTq/bGjBljJCYmGl988YVx6NCh4E9WVlZwm9GjRxvNmzc3Pv/8c+Pbb781UlNTjdTU1Co86+iSv3qGYag9y2Pt2rWG3W43Zs6caezYscN48803jfj4eOMf//hHcJu//OUvRp06dYwPP/zQ2Lx5s3HzzTcbLVu2NM6dO1eFZ149jRgxwrjooouMxYsXG3v27DEWLlxo1K9f35g8eXJwG7Vn8TIzM42NGzcaGzduNADjmWeeMTZu3Bis5FCWths4cKBx2WWXGWvWrDG+/vpro23btsbQoUOr6iFVuZLa1O12GzfddJPRtGlTY9OmTSHvUTk5OcF9qE3zlPYcLahg9QzDiEx7Kmiu5p5//nmjefPmRlxcnNGzZ09j9erVVX1KUQEo8ue1114LbnPu3Dnjf/7nf4ykpCQjPj7e+M1vfmMcOnSo6k46yhQMmtWe5fPRRx8ZnTp1MpxOp9G+fXvjlVdeCVnv8/mMRx55xGjUqJHhdDqNa665xti+fXsVnW31lpGRYYwfP95o3ry54XK5jFatWhlTp04NCUDUnsVbvnx5ka+XI0aMMAyjbG13/PhxY+jQoUatWrWMhIQE44477jAyMzOr4NFUDyW16Z49e4p9j1q+fHlwH2rTPKU9RwsqKmiORHtaDCPflEkiIiIiIlKIcppFREREREqhoFlEREREpBQKmkVERERESqGgWURERESkFAqaRURERERKoaBZRERERKQUCppFREREREqhoFlEREREpBQKmkVELnAWi4VFixad1z5ef/116tSpE5HzERGpjhQ0i4hUAYvFUuLPo48+WmnncujQIa6//vpKO56ISDSyV/UJiIhciA4dOhT8+5133mHatGls3749uKxWrVrl2p/b7SYuLi6sc0lOTg7rfiIiFxL1NIuIVIHk5OTgT2JiIhaLJXh7wYIFXHnllSHbP/fcc7Ro0SJ4e+TIkQwePJiZM2fSpEkT2rVrx969e7FYLCxcuJB+/foRHx9P165dWbVqVYnnkj89o6z7eP3112nevDnx8fH85je/4fjx44X2++GHH9KtWzdcLhetWrVixowZ5ObmAvDYY4/RpEmTkPsNGjSIfv364fP5ytOUIiKVQkGziEiU+uyzz9i+fTtpaWksXrw4uHzq1Kncd999bNq0iYsvvpihQ4cGg9WyKmkfa9asYdSoUdx9991s2rSJfv368cQTT4Tc/6uvvuIPf/gD48ePZ+vWrbz88su8/vrrzJw5M7j/Fi1a8Kc//QmAF198kZUrV/LGG29gteqtSUSqH6VniIhEqZo1a/L3v/89mJaxd+9eAO677z4GDRoEwIwZM+jYsSM7d+6kffv2Zd53SfuYN28eAwcOZPLkyQBcfPHFrFy5kiVLlgTvP2PGDKZMmcKIESMAaNWqFY8//jiTJ09m+vTp2Gw2/vGPf3DppZcyZcoU5s+fz9///neaN29+3u0iIlIR9HFeRCRKde7cucg85i5dugT/bty4MQBHjhwp175L2se2bdvo1atXyPapqakht7/77jsee+wxatWqFfy58847OXToEFlZWYAZSM+dO5fZs2dz0003cdttt5XrHEVEKpN6mkVEqhmr1YphGCHLPB5Poe1q1qxZ5P0dDkfwb4vFAlDuPOHz3ceZM2eYMWMGt9xyS6F1Lpcr+PeXX36JzWZj79695ObmYrfrbUlEqif1NIuIVDMNGjQgPT09JHDetGlT1Z1QAZdccglr1qwJWbZ69eqQ2926dWP79u20adOm0E8gZ/mdd95h4cKFfPHFF+zfv5/HH3+80h6DiEh56SO9iEg107dvX44ePcqcOXMYMmQIS5Ys4dNPPyUhIaGqTw2AcePG0bt3b+bOncvNN9/M0qVLQ/KZAaZNm8aNN95I8+bNGTJkCFarle+++44tW7bwxBNP8MsvvzBmzBhmz57NlVdeyWuvvcaNN97I9ddfz+WXX15Fj0xEpHjqaRYRqWYuueQS/vrXv/Liiy/StWtX1q5dy3333VfVpxV0+eWX87e//Y158+bRtWtXli1bxsMPPxyyzYABA1i8eDHLli3jV7/6FZdffjnPPvssKSkpGIbByJEj6dmzJ3fffXdw+zFjxnD77bdz5syZqnhYIiIlshgFE+dERERERCSEeppFREREREqhoFlEREREpBQKmkVERERESqGgWURERESkFAqaRURERERKoaBZRERERKQUCppFREREREqhoFlEREREpBQKmkVERERESqGgWURERESkFAqaRURERERK8f8BGK1oLW8jVSkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtoAAAGJCAYAAAC0HJT3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4FEUbwH93l56QBEggoUPovReBUKQr0gVF6SjSRQTRT4qKCtKkiA0piqg0G0jvSO+9SSd0kpCe3O33x2Sv5O6Su5AK83uee+52dm5mdnZ299133nlfjaIoChKJRCKRSCQSiSRD0WZ3AyQSiUQikUgkkqcRKWhLJBKJRCKRSCSZgBS0JRKJRCKRSCSSTEAK2hKJRCKRSCQSSSYgBW2JRCKRSCQSiSQTkIK2RCKRSCQSiUSSCUhBWyKRSCQSiUQiyQSkoC2RSCQSiUQikWQCUtCWSCQSiUQikUgyASlo5wAmTpyIRqPh/v372d0UI2qbzClRogR9+vTJngZlMbaOX2KNRqNh6NCh2d0MCzQaDRMnTjRuL1q0CI1Gw5UrV7KtTRJJZnLlyhU0Gg2LFi3K7qZkGCVKlODFF1/M0DKftn5q2rQpTZs2ze5mSNJACtoSiUSSRcyfP59u3bpRrFgxNBqN3RfXHTt28NJLL1G0aFE8PDwICgqiTZs27N69O9Xyw8PDKVCgABqNhhUrVljsO3XqFN26daNUqVJ4eXkREBBAaGgof/31V6plqsKJI5/sfpk5ffo0EydOzJR2rF271uIFTiKRSBzBJbsbIJFIJM8KU6ZM4fHjx9StW5ewsDC7+c6fP49Wq2XQoEEEBQXx6NEjfvrpJ0JDQ1mzZg1t2rSx+b/x48cTExNjc9/Vq1d5/PgxvXv3plChQsTExLBy5UpeeuklvvnmG9544w2b/wsMDOTHH3+0SJs+fTo3btxg5syZVnmzk9OnTzNp0iSaNm1KiRIlMrTstWvXMm/ePClsS3IMGzZsyO4mSBxACtqZRFJSEgaDATc3t+xuikTiFNHR0Xh7e2d3M55Ktm/fbtRm+/j42M03YMAABgwYYJE2ePBgSpUqxaxZs2wK2idPnmT+/PmMHz+e8ePHW+1v164d7dq1s0gbOnQotWrVYsaMGXYFbW9vb1577TWLtF9++YVHjx5ZpaeXZ3nMPSvH/qwcZ1Yi5YvcwVNtOqLa2Z4/f57XXnsNPz8/AgMD+fDDD1EUhevXr9OhQwd8fX0JCgpi+vTpFv9PSEhg/Pjx1KpVCz8/P7y9vWncuDFbt261yKdOrU6bNo1Zs2YREhKCu7s7p0+fBmDOnDlUqlQJLy8v8ubNS+3atfn555+t2hseHk6fPn3w9/fHz8+Pvn37WmmnVJvY5cuXU7FiRTw9PWnQoAEnTpwA4JtvvqF06dJ4eHjQtGlTqynUnTt3Gqeu3d3dKVq0KG+//TaxsbHp6uP//vuPbt26kS9fPry8vKhfvz5r1qwx7lcUhYCAAEaNGmVMMxgM+Pv7o9PpCA8PN6ZPmTIFFxcXoqKi0qx33759tGvXjrx58+Lt7U3VqlX58ssvLfJs2bKFxo0b4+3tjb+/Px06dODMmTNWZe3atYs6derg4eFBSEgI33zzjd16f/rpJ2rVqoWnpyf58uWjR48eXL9+Pc32OktWnec+ffrg4+PDpUuXaNeuHXny5KFnz54AXLhwgS5duhAUFISHhwdFihShR48eREREWLX3999/p3Llyri7u1OpUiXWrVtnsT+rrkVn+Oqrr6hUqRLu7u4UKlSIIUOGWIzH2bNnW43R6dOno9FoLMazXq8nT548jB07Ns06ixcvnm7bfy8vLwIDAy3aY86IESPo1KkTjRs3drhMnU5H0aJF7ZbpDClt41VSru1Qbea3b9/O4MGDKVCgAEWKFAGEzWnlypU5ffo0zZo1w8vLi8KFCzN16tQ061+0aBHdunUDoFmzZkZzlm3bthnzpHXO7dGnTx/mzZtnPE71A7Bt2zaresC2PXBq15t6zad1LTmDo/fAbdu2Ubt2bYt7oK11Kmobly5dSrly5fDw8KBWrVrs2LHDIp/639OnT/Pqq6+SN29eGjVqBAgl1Mcff2x8TpYoUYL333+f+Ph4m8ewYcMGqlevjoeHBxUrVmTVqlUOHbv6PPXz88Pf35/evXtbneuFCxei0Wg4cuSI1f8//fRTdDodN2/eBBwfm+mRG+bNm2c06WrVqhXXr19HURQ+/vhjihQpgqenJx06dODhw4cWZdiy0Y6Li2PixImULVsWDw8PgoOD6dy5M5cuXTLm+eWXX6hVqxZ58uTB19eXKlWqWD0/L126ZPEfeyQmJjJp0iTKlCmDh4cH+fPnp1GjRmzcuDHVdoK4HlLOPBkMBr788kuqVKmCh4cHgYGBtGnThoMHD1rk++mnn6hbt65RrgoNDbXS8P/zzz/G8Z8nTx5eeOEFTp06ZZHn9u3b9O3blyJFiuDu7k5wcDAdOnSweKYePHiQ1q1bExAQgKenJyVLlqRfv35p9o3KM6HR7t69OxUqVODzzz9nzZo1fPLJJ+TLl49vvvmG5s2bM2XKFJYuXcro0aOpU6cOoaGhAERGRvL999/zyiuvMHDgQB4/fsyCBQto3bo1+/fvp3r16hb1LFy4kLi4ON544w3c3d3Jly8f3333HcOHD6dr166MGDGCuLg4jh8/zr59+3j11Vct/v/yyy9TsmRJPvvsMw4fPsz3339PgQIFmDJlikW+nTt38ueffzJkyBAAPvvsM1588UXGjBnDV199xeDBg3n06BFTp06lX79+bNmyxfjf5cuXExMTw1tvvUX+/PnZv38/c+bM4caNGyxfvtypfr1z5w7PPfccMTExDB8+nPz587N48WJeeuklVqxYQadOndBoNDRs2NDiRnz8+HEiIiLQarXs3r2bF154wXhcNWrUSFXTB7Bx40ZefPFFgoODGTFiBEFBQZw5c4a///6bESNGALBp0ybatm1LqVKlmDhxIrGxscyZM4eGDRty+PBh48V94sQJWrVqRWBgIBMnTiQpKYkJEyZQsGBBq3onT57Mhx9+yMsvv8yAAQO4d+8ec+bMITQ0lCNHjuDv7+9U/6VFVp3npKQkWrduTaNGjZg2bRpeXl4kJCTQunVr4uPjGTZsGEFBQdy8eZO///6b8PBw/Pz8jP/ftWsXq1atYvDgweTJk4fZs2fTpUsXrl27Rv78+S3qyqprMS0mTpzIpEmTaNGiBW+99Rbnzp1j/vz5HDhwgN27d+Pq6krjxo0xGAzs2rXLuChr586daLVadu7caSzryJEjREVFGduakURGRpKQkMD9+/dZsmQJJ0+e5P3337fKt3z5cv7991/OnDmTpn1ydHQ0sbGxRERE8Oeff/LPP//QvXv3DG97WgwePJjAwEDGjx9PdHS0Mf3Ro0e0adOGzp078/LLL7NixQrGjh1LlSpVaNu2rd3yQkNDGT58OLNnz+b999+nQoUKAMZvR865Pd58801u3brFxo0brcxonMXW9abizLWUFo7eA48cOUKbNm0IDg5m0qRJ6PV6PvroI7tmQNu3b+fXX39l+PDhuLu789VXX9GmTRv2799P5cqVLfJ269aNMmXK8Omnn6IoCiBmaxYvXkzXrl1555132LdvH5999hlnzpxh9erVFv+/cOEC3bt3Z9CgQfTu3ZuFCxfSrVs31q1bR8uWLe0eu6IodOjQgV27djFo0CAqVKjA6tWr6d27t0W+rl27MmTIEJYuXUqNGjUs9i1dupSmTZtSuHBhY5ojY9PZe9XSpUtJSEhg2LBhPHz4kKlTp/Lyyy/TvHlztm3bxtixY7l48SJz5sxh9OjR/PDDD3aPW6/X8+KLL7J582Z69OjBiBEjePz4MRs3buTkyZOEhISwceNGXnnlFZ5//nmjbHHmzBl2795tfH4CPP/88wBp3k8mTpzIZ599xoABA6hbty6RkZEcPHiQw4cPp3qO7NG/f38WLVpE27ZtGTBgAElJSezcuZO9e/dSu3ZtACZNmsTEiRN57rnn+Oijj3Bzc2Pfvn1s2bKFVq1aAfDjjz/Su3dvWrduzZQpU4iJiWH+/Pk0atSII0eOGMd/ly5dOHXqFMOGDaNEiRLcvXuXjRs3cu3aNeO2KiO89957+Pv7c+XKFYdf+ABQnmImTJigAMobb7xhTEtKSlKKFCmiaDQa5fPPPzemP3r0SPH09FR69+5tkTc+Pt6izEePHikFCxZU+vXrZ0y7fPmyAii+vr7K3bt3LfJ36NBBqVSpkkPtNC9TURSlU6dOSv78+S3SAMXd3V25fPmyMe2bb75RACUoKEiJjIw0po8bN04BLPLGxMRY1f/ZZ58pGo1GuXr1qlWbzClevLhF/4wcOVIBlJ07dxrTHj9+rJQsWVIpUaKEotfrFUVRlC+++ELR6XTGts2ePVspXry4UrduXWXs2LGKoiiKXq9X/P39lbfffju1rlKSkpKUkiVLKsWLF1cePXpksc9gMBh/V69eXSlQoIDy4MEDY9qxY8cUrVar9OrVy5jWsWNHxcPDw+LYT58+reh0Oovjv3LliqLT6ZTJkydb1HnixAnFxcXFKv1Jyarz3Lt3bwVQ3nvvPYu8R44cUQBl+fLlabbTzc1NuXjxojHt2LFjCqDMmTPHmJZV16LapgkTJhi3Fy5caNE/d+/eVdzc3JRWrVoZx6iiKMrcuXMVQPnhhx8URRFj0tfXVxkzZoyiKGJ85c+fX+nWrZui0+mUx48fK4qiKDNmzFC0Wq3VeEwLb29vi2O0RevWrRXA2M9vvvmmEhsba5EnJiZGKVasmDJu3DhFURRl69atqZ67N99801imVqtVunbtqjx8+NCptr/wwgtK8eLFLdJS9rtKyvuGej4aNWqkJCUlWeRt0qSJAihLliwxpsXHxytBQUFKly5d0mzX8uXLFUDZunWrRbqj5zw1hgwZYnVPVBRTf6esU30uLFy40Jhm73pTFMevJVvYqsvRe2D79u0VLy8v5ebNm8a0CxcuKC4uLlbHq46bgwcPGtOuXr2qeHh4KJ06dTKmqdf7K6+8YvH/o0ePKoAyYMAAi/TRo0crgLJlyxZjWvHixRVAWblypTEtIiJCCQ4OVmrUqJFqf/z+++8KoEydOtWYlpSUpDRu3Niqn1555RWlUKFCFuPi8OHDVvkcHZvOyg2BgYFKeHi4MV29n1erVk1JTEy0aKebm5sSFxdn0aYmTZoYt3/44QcFUGbMmGHVJ+rzccSIEYqvr6/VtZeS4sWLW13jtqhWrZrywgsvpJonZTtVevfubVHHli1bFEAZPny43fZfuHBB0Wq1SqdOnSzOmXmex48fK/7+/srAgQMt9t++fVvx8/Mzpj969EgBlC+++MJu21evXq0AyoEDB1I9xtR4qk1HVMxtHXU6HbVr10ZRFPr3729M9/f3p1y5cvz3338WeVUbKIPBwMOHD0lKSqJ27docPnzYqp4uXbpYaQH8/f25ceMGBw4cSLOdgwYNsthu3LgxDx48IDIy0iL9+eeft5huqVevnrH+PHnyWKWbH5Onp6fxd3R0NPfv3+e5555DURSb02epsXbtWurWrWucEgTw8fHhjTfe4MqVK0bTmcaNG6PX6/n3338BoRVs3LgxjRs3NmoGT548SXh4eJrT3keOHOHy5cuMHDnSSoOsTnOGhYVx9OhR+vTpQ758+Yz7q1atSsuWLVm7di0g3v7Xr19Px44dKVasmDFfhQoVaN26tUXZq1atwmAw8PLLL3P//n3jJygoiDJlyjyRCYM9svI8v/XWWxbbqsZ6/fr1dhfXqbRo0YKQkBDjdtWqVfH19bVoj0pWXYupsWnTJhISEhg5ciRarekWOHDgQHx9fY2mT1qtlueee844G3PmzBkePHjAe++9h6Io7NmzBxDjuXLlyhk+owHw+eefs2HDBhYsWED9+vVJSEggKSnJKk9iYqJNTbctRo4cycaNG1m8eDFt27ZFr9eTkJCQ4W1Pi4EDB6LT6azSfXx8LGy/3dzcqFu3rs3x5CiOnvOsIuX1puLMtZQaztwDN23aRMeOHSlUqJAxX+nSpe3OHjRo0IBatWoZt4sVK0aHDh1Yv349er3eIm/KZ5par7npFcA777wDYHUeChUqRKdOnYzbvr6+9OrViyNHjnD79m27x7927VpcXFws+lmn0zFs2DCrvL169eLWrVsW9/ClS5fi6elJly5dLPI6MjadvVd169bNYoZQvZ+/9tpruLi4WKQnJCQYTVlssXLlSgICAmwep/p89Pf3Jzo62sK0wxZXrlxxyHuPv78/p06d4sKFC2nmTYuVK1ei0WiYMGGC1T61/b///jsGg4Hx48dbXMvmeTZu3Eh4eDivvPKKxfNap9NRr14947n29PTEzc2Nbdu28ejRI7vHB/D333+TmJiYruN6JgRtcyEKhBDh4eFBQECAVXrKzl68eDFVq1Y12h4FBgayZs0am3aqJUuWtEobO3YsPj4+1K1blzJlyjBkyBC7LrpStjNv3rwAVm2ydTwARYsWtZlu/v9r164Zb74+Pj4EBgbSpEkTAJvHlBpXr16lXLlyVunqVO3Vq1cBqFmzJl5eXkahWhW0Q0NDOXjwIHFxccZ9qtAeGxvL7du3LT6A0WYs5RRlynYBdtt2//59oqOjuXfvHrGxsZQpU8YqX8r/XrhwAUVRKFOmDIGBgRafM2fOcPfu3VR6Kn1k1Xl2cXEx2siqlCxZklGjRvH9998TEBBA69atmTdvns0xkrKdIMaurRtXVl2LqWFvfLi5uVGqVCnjfhAviYcOHSI2NpadO3cSHBxMzZo1qVatmnHM7tq1y+IF8d69exbj1pE1B/aoXr06LVu2pF+/fmzcuJH9+/db2DtfuXKFL774gsmTJ6dpcqVSvnx5WrRoQa9evfj777+Jioqiffv2xqn9rMLW/RKgSJEiVrbBKcdTyntDWmtMHD3nCQkJVmWnFB6fFFvXm4oz11JqOHoPvHv3LrGxsZQuXdoqn600wOb9smzZssTExHDv3j2L9JTn+OrVq2i1Wquyg4KC8Pf3t7j21DakHAtly5YFUjdpuHr1KsHBwVbXhK3+aNmyJcHBwSxduhQQwvGyZcvo0KGDhUIDHBub4Ny96knu8ym5dOkS5cqVsxDQUzJ48GDKli1L27ZtKVKkCP369XuidQAfffQR4eHhlC1blipVqvDuu+9y/PjxdJV16dIlChUqZPFyaCuPVqulYsWKdvOoQn/z5s2tntcbNmwwPq/d3d2ZMmUK//zzDwULFiQ0NJSpU6davMQ1adKELl26MGnSJAICAujQoQMLFy60u6bAFs+EoG1La2IrDbB42Pz000/06dOHkJAQFixYwLp169i4cSPNmzfHYDBY/ddci6hSoUIFzp07xy+//EKjRo1YuXIljRo1svnG5kibUsuX1v/1ej0tW7ZkzZo1jB07lt9//52NGzcaF+vYOqaMwNXVlXr16rFjxw4uXrzI7du3ady4MY0aNSIxMZF9+/axc+dOypcvb5wR+PXXXwkODrb4ZCcGgwGNRmMcAyk/qS2gTC9ZdZ7d3d2tNAMgFv4dP36c999/n9jYWIYPH06lSpW4ceOGU+1JK29mXIsZhTpG9+zZY3xBBIyzMWfPnuXevXsWgnadOnUsxu20adMypC1ubm689NJLrFq1yihYjh8/nsKFCxsXxF65csX4kLh37x5XrlxJs3+6du3KgQMHOH/+fIa0MyX2BFVb90twbDykvDf8+uuvT95Q4N9//7UqO63FzvYWt9o7bnvXGzh3LeUG7J3jnBQMTKfT8eqrr7Jy5Uri4uLYunUrt27dsulRJzPuVem9z6eXAgUKcPToUf78809eeukltm7dStu2ba3s1x0lNDSUS5cu8cMPP1C5cmW+//57atasyffff2/M4+w18qSo/fzjjz/afF7/8ccfxrwjR47k/PnzfPbZZ3h4ePDhhx9SoUIF48yvGpNgz549DB06lJs3b9KvXz9q1arlsBLlmVgMmV5WrFhBqVKlWLVqlcVAsSUkp4a3tzfdu3ene/fuJCQk0LlzZyZPnsy4cePw8PDI6Gbb5cSJE5w/f57FixfTq1cvY3paU0j2KF68OOfOnbNKP3v2rHG/SuPGjZkyZQqbNm0iICCA8uXLo9FoqFSpEjt37mTnzp0WUcBat25ts13qtOrJkydp0aKF3XYBdtsWEBCAt7c3Hh4eeHp62pzySvnfkJAQFEWhZMmSRo1KTiUjz3OVKlWoUqUK//vf//j3339p2LAhX3/9NZ988klGNjlNMupaBMvxUapUKWN6QkICly9fthhXdevWxc3NzThG3333XUA8XL777js2b95s3FZZunSphYbVvI4nJTY2FkVRePz4MZ6enly7do2LFy/arGPw4MGA0IClZtaittXZmYGU5M2b18qrQ0JCQqr+wtNLyrFcqVIlwP4D3dFzXq1aNauyg4KCUi1bnXlMeewptbNZiTP3QA8PDy5evGiVz1YaYPN+ef78eaNXnLTaZTAYuHDhgnHmE8TC+vDwcItnhtoGRVEs+l59IUzNT3rx4sXZvHkzUVFRFlptW/0Bwnxk+vTp/PXXX/zzzz8EBgZamQ86Skbeq5wlJCSEffv2kZiYmOriXjc3N9q3b0/79u0xGAwMHjyYb775hg8//NDuTEZq5MuXj759+9K3b1/jwvCJEycaTQXz5s1r0/wp5TUSEhLC+vXrefjwoV2tdkhICAaDgdOnT9tdBK/KCQUKFLArJ6TM/8477/DOO+9w4cIFqlevzvTp0/npp5+MeerXr0/9+vWZPHkyP//8Mz179uSXX36xcsNqi2dCo51e1DdK8zfIffv2GW0zHeHBgwcW225ublSsWBFFUdJt75NebB2PoihWbn0cpV27duzfv9+iP6Kjo/n2228pUaKExdRO48aNiY+PZ9asWTRq1Mh4A2rcuDE//vgjt27dstAKBgcH06JFC4sPCDOUkiVLMmvWLKsHm3pcwcHBVK9encWLF1vkOXnyJBs2bDD6EtbpdLRu3Zrff/+da9euGfOdOXOG9evXW5TduXNndDodkyZNstIoKIpidZ6zk4w4z5GRkVa2wFWqVEGr1To1ZZZRZMS1qNKiRQvc3NyYPXu2RXkLFiwgIiLC6AUHwMPDgzp16rBs2TKuXbtmodGOjY1l9uzZhISEWMy4NGzY0GLcpkfQtmWKFB4ezsqVKylatCgFChQA4JNPPmH16tUWn48//hiAMWPGsHr1aqPvYltlJiYmsmTJEjw9PVOdinWEkJAQKzdv3377baZorVLeG9T+V4815b3B0XOeN29eq7JVZYi9sosXL45Op7M69q+++irDjtdZnLkHtmjRgt9//51bt24Z8128eJF//vnHZtl79uyxsDW+fv06f/zxB61atbKrhVVR6501a5ZF+owZMwAsrj2AW7duWXgiiYyMZMmSJVSvXt34AmSvnqSkJObPn29M0+v1zJkzx2b+qlWrUrVqVb7//ntWrlxJjx49UjW/SI2MvFc5S5cuXbh//z5z58612qe2J+WzSqvVUrVqVQCLe7uj7v1Slufj40Pp0qUtygoJCTHO/qkcO3bMyoy2S5cuKIrCpEmT7La/Y8eOaLVaPvroI6sZAjVP69at8fX15dNPP7UpZ6ntiImJIS4uzmJfSEgIefLkMbb/0aNHVs98VcB39FkoNdqp8OKLL7Jq1So6derECy+8wOXLl/n666+pWLGiw1MGrVq1IigoiIYNG1KwYEHOnDnD3LlzeeGFF6zsvzKb8uXLExISwujRo7l58ya+vr6sXLnSafs/lffee49ly5bRtm1bhg8fTr58+Vi8eDGXL19m5cqVFtOjDRo0wMXFhXPnzlkExggNDTXeDB3x/6vVapk/fz7t27enevXq9O3bl+DgYM6ePcupU6eMAvIXX3xB27ZtadCgAf379ze6tvLz87Pw9Ttp0iTWrVtH48aNGTx4MElJSUa/5+Z2ZiEhIXzyySeMGzeOK1eu0LFjR/LkycPly5dZvXo1b7zxBqNHj05XP2Y0GXGet2zZwtChQ+nWrRtly5YlKSmJH3/8EZ1OZ7VAKCvIiGtRJTAwkHHjxjFp0iTatGnDSy+9xLlz5/jqq6+oU6eO1ZRx48aN+fzzz/Hz86NKlSqA0JSUK1eOc+fO2Q2jbou//vqLY8eOAULIPX78uHF24KWXXjI+8FT7yXr16lGgQAGuXbvGwoULuXXrloWZhPlCZBVVe12nTh06duxoTH/zzTeJjIwkNDSUwoULc/v2bZYuXcrZs2eZPn26wzbe9hgwYACDBg2iS5cutGzZkmPHjrF+/Xor+/vMpHr16uh0OqZMmUJERATu7u40b96cAgUKOHXObaEuABw+fDitW7dGp9PRo0cP/Pz86NatG3PmzEGj0RASEsLff/+dKes2nMHRe+DEiRPZsGEDDRs25K233kKv1zN37lwqV67M0aNHrcqtXLkyrVu3tnDvB9gUjlJSrVo1evfuzbfffkt4eDhNmjRh//79LF68mI4dO9KsWTOL/GXLlqV///4cOHCAggUL8sMPP3Dnzh0WLlyYaj3t27enYcOGvPfee1y5csXofzu1WZtevXoZ7+FPEogpI+9VztKrVy+WLFnCqFGj2L9/P40bNyY6OppNmzYxePBgOnTowIABA3j48CHNmzenSJEiXL16lTlz5lC9enWLWQZH3ftVrFiRpk2bUqtWLfLly8fBgwdZsWIFQ4cONebp168fM2bMoHXr1vTv35+7d+/y9ddfU6lSJQtnD82aNeP1119n9uzZXLhwgTZt2mAwGNi5cyfNmjVj6NChlC5dmg8++ICPP/6Yxo0b07lzZ9zd3Tlw4ACFChXis88+w9fXl/nz5/P6669Ts2ZNevToQWBgINeuXWPNmjU0bNiQuXPncv78eZ5//nlefvllKlasiIuLC6tXr+bOnTv06NEDEPb2X331FZ06dSIkJITHjx/z3Xff4evraxUAzC7p9leSC1BdDN27d88ivXfv3oq3t7dV/iZNmli44jMYDMqnn36qFC9eXHF3d1dq1Kih/P3331YuaVQ3PbZcxHzzzTdKaGiokj9/fsXd3V0JCQlR3n33XSUiIiLNdqZ0S6Yowr3SkCFDLPLZq9+Wm6/Tp08rLVq0UHx8fJSAgABl4MCBRhdS5q6MHHHvpyiKcunSJaVr166Kv7+/4uHhodStW1f5+++/rfpBURSlTp06CqDs27fPmHbjxg0FUIoWLWrzP/bYtWuX0rJlSyVPnjyKt7e3UrVqVSsXWJs2bVIaNmyoeHp6Kr6+vkr79u2V06dPW5W1fft2pVatWoqbm5tSqlQp5euvv7Z5/IqiKCtXrlQaNWqkeHt7K97e3kr58uWVIUOGKOfOnXOq/WmRVefZ3rXw33//Kf369VNCQkIUDw8PJV++fEqzZs2UTZs2pdlORbEeK1l1LaptSs29n8rcuXOV8uXLK66urkrBggWVt956y6aLvjVr1iiA0rZtW4v0AQMGKICyYMECq//YQ3XvZutjfl7mzp2rNGrUSAkICFBcXFyUwMBApX379sqOHTvSrMOee79ly5YpLVq0UAoWLKi4uLgoefPmVVq0aKH88ccfDrdfxZZ7P71er4wdO1YJCAhQvLy8lNatWysXL160697PlruslOddxdZ5tsd3332nlCpVyuii09ztnqPn3BZJSUnKsGHDlMDAQEWj0VjcH+7du6d06dJF8fLyUvLmzau8+eabysmTJx2+3hTF8WvJFrbc+ymK4/fAzZs3KzVq1FDc3NyUkJAQ5fvvv1feeecdxcPDw2Ybf/rpJ6VMmTLGazGla0N717uiKEpiYqIyadIkpWTJkoqrq6tStGhRZdy4cRZu69TjfuGFF5T169crVatWVdzd3ZXy5cun6XJU5cGDB8rrr7+u+Pr6Kn5+fsrrr79udFuasp8URVHCwsIUnU6nlC1b1mZ5jo7NJ5Ub7F2/tq4bW27zYmJilA8++MDYv0FBQUrXrl2VS5cuKYqiKCtWrFBatWqlFChQQHFzc1OKFSumvPnmm0pYWJhFOY669/vkk0+UunXrKv7+/oqnp6dSvnx5ZfLkyUpCQoJFvp9++kkpVaqU4ubmplSvXl1Zv369zes6KSlJ+eKLL5Ty5csrbm5uSmBgoNK2bVvl0KFDFvl++OEHpUaNGoq7u7uSN29epUmTJsrGjRut+rJ169aKn5+f4uHhoYSEhCh9+vQxuqe8f/++MmTIEKV8+fKKt7e34ufnp9SrV0/57bffjGUcPnxYeeWVV5RixYop7u7uSoECBZQXX3zRwsVlWmgUJZeuspBIJBKJRJIpdOzY0cptm0ajYciQITZNE3I79+/fJzg4mPHjx/Phhx9md3MkTxHSRlsikUgkkmeYlO4RL1y4wNq1a22GzX5aWbRoEXq9ntdffz27myJ5ypA22hJJBqGGtU6NhIQEYzADW3h6eloEL5BIJJLMplSpUvTp08foU3z+/Pm4ubkxZsyY7G5aprNlyxZOnz7N5MmT6dixY6reTCSS9CAFbYkkg/j111/p27fvE5XRu3dvo79riUQiyQratGnDsmXLuH37Nu7u7jRo0IBPP/3UZnCap42PPvrI6LrUnlcSieRJkDbaEkkGERYWxqlTp1LN8+jRI6PfXVsUKlToid2sSSQSiUQiyRlIQVsikUgkEolEIskE5GJIiUQikUgkEokkE5A22k5iMBi4desWefLksRuSVyKRSCQSiUSSfSiKwuPHjylUqJBFAL2sRgraTnLr1i2KFi2a3c2QSCQSiUQikaTB9evXKVKkSLbVLwVtJ1HDpl+/fh1fX99Mry8xMZENGzbQqlUrXF1dM72+ZxXZz5mP7OOsQfZz5iP7OGuQ/Zz5PM19HBkZSdGiRY1yW3YhBW0nUc1FfH19s0zQ9vLywtfX96m7CHISsp8zH9nHWYPs58xH9nHWIPs583kW+ji7zXzlYkiJRCKRSCQSiSQTkIK2RCKRSCQSiUSSCUhBWyKRSCQSiUQiyQSkjbZEIpFIJFmIoigkJSWh1+uzuyk5msTERFxcXIiLi5N9lUnk9j52dXVFp9NldzNSRQraEolEIpFkEQkJCYSFhRETE5PdTcnxKIpCUFAQ169fz/YFbU8rub2PNRoNRYoUwcfHJ7ubYpdcJWjv2LGDL774gkOHDhEWFsbq1avp2LGjcb+iKEyYMIHvvvuO8PBwGjZsyPz58ylTpowxz8OHDxk2bBh//fUXWq2WLl268OWXX+bokySRSCSS3I/BYODy5cvodDoKFSqEm5tbrhRusgqDwUBUVBQ+Pj7ZGnDkaSY397GiKNy7d48bN25QpkyZHKvZzlWCdnR0NNWqVaNfv3507tzZav/UqVOZPXs2ixcvpmTJknz44Ye0bt2a06dP4+HhAUDPnj0JCwtj48aNJCYm0rdvX9544w1+/vnnrD4ciUQikTxDJCQkYDAYKFq0KF5eXtndnByPwWAgISEBDw+PXCcE5hZyex8HBgZy5coVEhMTpaCdEbRt25a2bdva3KcoCrNmzeJ///sfHTp0AGDJkiUULFiQ33//nR49enDmzBnWrVvHgQMHqF27NgBz5syhXbt2TJs2jUKFCmXZsUgkEkmuZOtnoNVBkzHW+7ZPBYMemo3L+nblInKjQCOR5ERyw4xQrhK0U+Py5cvcvn2bFi1aGNP8/PyoV68ee/bsoUePHuzZswd/f3+jkA3QokULtFot+/bto1OnTlblxsfHEx8fb9yOjIwExAKCxMTETDwijPWYf0syB9nPmY/s46whs/tZq4Bu62T0ej2GxqNN6TunodvxOfrQ9zA85ec4vX2cmJiIoigYDAYMBkNmNO2pQlEU47fsr8wht/exwWBAURSbGu2c8qx5agTt27dvA1CwYEGL9IIFCxr33b59mwIFCljsd3FxIV++fMY8Kfnss8+YNGmSVfqGDRuydOpv48aNWVbXs4zs58xH9nHWkHn9XJGywZ2psONzrp3ax+nCPSh1bz0VwlZxJrgz5x9XhLVrM6nunIWzfezi4kJQUBBRUVEkJCRkUquePh4/fpzdTXjqya19nJCQQGxsLDt27CApKcliX05ZcPzUCNqZxbhx4xg1apRxOzIykqJFi9KqVassC8G+ceNGWrZs+dSGR80JyH7OfGQfZw1Z08/t0P+ho+TJ5ZR4uA2NoqAPfY/SjUdTOpNqzEmkt4/j4uK4fv06Pj4+xnVD6UVvUDhw5SF3H8dTII87dUrkQ6fN+dPozqAoCo8fPyZPnjw53kTgypUrhISEcOjQIapXr57dzXEInU7HypUrad68ea7oY1vExcXh6elJaGio1TWlWiBkN0+NoB0UFATAnTt3CA4ONqbfuXPHOOiDgoK4e/euxf+SkpJ4+PCh8f8pcXd3x93d3Srd1dU1S4WFrK7vWUX2c+Yj+zhryPR+DmkGJ5ejURTQuaFrPo6cuRQp83C2j/V6PRqNBq1W+0R22utOhjHpr9OERcQZ04L9PJjQviJtKgen8s/0c+/ePcaPH8+aNWu4c+cOefPmpVq1aowfP56GDRtmSp2qKYPaZzkZtX1Pem6zi9zQx7bQarVoNBqb12JOec7kvl61Q8mSJQkKCmLz5s3GtMjISPbt20eDBg0AaNCgAeHh4Rw6dMiYZ8uWLRgMBurVq5flbZZIJJJcy5k/xbdGC/oEsRBSkumsOxnGWz8dthCyAW5HxPHWT4dZdzIsU+rt0qULR44cYfHixZw/f54///yTpk2b8uDBg0ypT5J+coptskSQqwTtqKgojh49ytGjRwGxAPLo0aNcu3YNjUbDyJEj+eSTT/jzzz85ceIEvXr1olChQkZf2xUqVKBNmzYMHDiQ/fv3s3v3boYOHUqPHj2kxxGJRCJxlO1T4fw68btyF2j2AWydLIXtdKAoCjEJSQ59HsclMuHPUyi2ykn+nvjnaR7HJTpUnroQLi3Cw8PZuXMnU6ZMoVmzZhQvXpy6desybtw4XnrpJYt8AwYMIDAwEF9fX5o3b86xY8csyvr8888pWLAgefLkoX///rz33nsWphZNmzZl5MiRFv/p1KkTffr0MW7Hx8czevRoChcujLe3N/Xq1WPbtm3G/YsWLcLf35/169dToUIFfHx8aNOmDWFhli8hP/zwA5UqVcLd3Z3g4GCGDh3q1LGkxfbt26lbt66x/Pfee8/Cjvjx48f07NkTb29vgoODmTlzptXxlyhRgo8//phXXnkFb29vChcuzLx58yzq0Wg0zJ8/n5deeglvb28mT54MwPz58wkJCcHNzY1y5crx448/WrUxLCyMrl274u3tTalSpVixYoVTxyhJm1xlOnLw4EGaNWtm3FZtp3v37s2iRYsYM2YM0dHRvPHGG4SHh9OoUSPWrVtnYbezdOlShg4dyvPPP28MWDN79uwsPxaJRCLJlWyfKoTqApXg7ik4sRwmRoh9W8UD3qbrP4lNYhP1VBy/PkPKUoDbkXFUmbjBofynP2qNl1vaYoCPjw8+Pj78/vvv1K9f36Y5JUC3bt3w9PTkn3/+wc/Pj2+++Ybnn3+e8+fPky9fPn777TcmTpzIvHnzaNSoET/++COzZ8+mVKlSzhwmQ4cO5fTp0/zyyy8UKlSI1atX06ZNG06cOGEMUBcTE8O0adP48ccf0Wq1vPbaa4wePZqlS5cCQggdNWoUn3/+OW3btiUiIoLdu3c7fCxpcfPmTdq1a0efPn1YsmQJZ8+eZeDAgXh4eDBx4kRAyDC7d+/mzz//pGDBgowfP57Dhw9b2Xh/8cUXvP/++0yaNIn169czYsQIypYtS8uWLY15Jk6cyOeff86sWbNwcXFh9erVjBgxglmzZtGiRQv+/vtv+vbtS5EiRSzkqAkTJjB+/Hjmzp3L0qVL6dGjBydOnKBChQpOnROJfXKVoN20adNU38A1Gg0fffQRH330kd08+fLlk8FpJBKJJL0Y9EKDffOwELRVVOHaoM+edkkyDRcXFxYtWsTAgQP5+uuvqVmzJk2aNKFHjx5UrVoVgF27drF//37u3r1rFMSnTZvG77//zooVK3jjjTeYNWsW/fv3p3///gB88sknbNq0ibi4OLt1p+TatWssXLiQa9euGWeiR48ezbp161i4cCGffvopIMwnvv76a0JCQgAhnJvLBp988gnvvPMOI0aMMKbVqVPH4WNJi6+++oqiRYsyd+5cNBoN5cuX59atW4wdO5bx48cTHR3N4sWL+fnnn3n++ecBWLhwoc3Z9YYNG/Lee+8BULZsWXbv3s3MmTMtBO1XX32Vvn37GrdfeeUV+vTpw+DBgwEh1O/du5dp06ZZCNpdu3alV69e+Pr68vHHH7Nx40bmzJnDV199leYxShwjVwnaEolEIslm1GA0P/ew3ic12U7j6arj9EetHcq7//JD+iw8kGa+RX3rULdk2lpXT1fHl6926dKFF154gZ07d7J3717++ecfpk6dyvfff0+fPn04duwYUVFR5M+f3+J/sbGxXLp0CYAzZ84waNAgi/0NGjRg69atDrfjxIkT6PV6ypYta5EeHx9vUbeXl5dRyAYIDg42OkO4e/cut27dMgq4KXHkWNLizJkzNGjQwMKTR8OGDYmKiuLGjRs8evSIxMRE6tata9zv5+dHuXLlrMpS15mZb8+aNcsizTw+iFp/yheChg0b8uWXX1qk1a9f36ps1TxXkjFIQVsikUgkkmxCo9E4ZL4B0LhMIMF+HtyOiLNpp60Bgvw8aFwmMFNc/Xl4eNCyZUtatmzJhx9+yIABA5gwYQJ9+vQhKiqK4OBgC1tpFX9/f4fr0Gq1VjPX5ov7oqKi0Ol0HDp0yCpAiY+Pj/F3So8TGo3GWK6np2eqbcioY8lKvL29s7sJEjvkqsWQEolEIskhNBhi+u3gojrJk6HTapjQviIghGpz1O0J7StmmT/tihUrEh0dDUDNmjW5ffs2Li4ulC5d2uITEBAACIcE+/btsyhj7969FtuBgYEWixb1ej2nTplMlGrUqIFer+fu3btW9dhz05uSPHnyUKJECQsvZeY4cixpUaFCBfbs2WPx0rB7927y5MlDkSJFKFWqFK6urhw4YJqhiIiI4Pz581ZlpeyjvXv3pmlDXaFCBQubc7X+ihUrWqTZOh/SPjtjkRptiUQikThPcDXT76Q4cE1dSyjJGNpUDmb+azWt/GgHZaIf7QcPHtCtWzf69etH1apVyZMnDwcPHmTq1Kl06NABgBYtWtCgQQM6duzI1KlTKVu2LLdu3WLNmjV06tSJ2rVrM2LECPr06UPt2rVp2LAhS5cu5dSpUxaLIZs3b86oUaNYs2YNJUuWZOrUqYSHhxv3ly1blp49e9KrVy+mT59OjRo1uHfvHps3b6Zq1aq88MILDh3TxIkTGTRoEAUKFKBt27Y8fvyY3bt3M2zYMIeOJS0GDx7MrFmzGDZsGEOHDuXcuXNMmDCBUaNGodVqyZMnD7179+bdd98lX758FChQgAkTJhj9Qpuze/dupk6dSseOHdm4cSPLly9nzZo1qdb/7rvv8vLLL1OjRg1atGjBX3/9xapVq9i0aZNFvhUrVlCpUiVatGjBsmXL2L9/PwsWLHCoDyWOIQVtiUQikTiPuWAtBe0spU3lYFpWDGL/5YfcfRxHgTwe1C2ZeZEhfXx8qFevHjNnzuTSpUskJiZStGhRBg4cyPvvvw8I04y1a9fywQcf0LdvX+7du0dQUBChoaEULFgQgO7du3Pp0iXGjBlDXFwcXbp04a233mL9epPXlX79+nHs2DF69eqFi4sLgwYNomnTphbtWbhwoXEx482bNwkICKB+/fq8+OKLDh9T7969iYuLY+bMmYwePZqAgAC6du3q8LGkReHChVm7di3vvvsu1apVI1++fPTv35///e9/xjwzZsxg0KBBvPjii/j6+jJmzBiuX79uFeHwnXfe4eDBg0yaNAlfX19mzJhB69ap2/V37NiRL7/8kmnTpjFixAhKlizJwoULrfpy4sSJrFy5ktGjRxMcHMyyZcustN6SJ0OjOOpIUwKIIDh+fn5ERERkWQj2tWvX0q5duxwT5ehpRPZz5iP7OGvIsn6+sBGWCsGE0RfBJzDz6sphpLeP4+LiuHz5MiVLlnziEOxPCxMnTuT333+3uQDPYDAQGRmJr69vroxa6CzR0dEULlyY6dOnGz2zlChRgpEjR1r5Fs8ocnsfp3ZNZbW8Zg+p0ZZIJBKJ8+xO9l7QZcEzJWRLJBnFkSNHOHv2LHXr1iUiIsLoflA1x5E8HUhBWyKRSCTOkxQvvl2kZlYiSS/Tpk3j3LlzuLm5UatWLXbu3OnwgktJ7kAK2hKJRCJxnqRY8e0qBW1J+pk4caIxUuKzRo0aNTh06FCqea5cuZI1jZFkGrnPIEcikUgk2Y+q0f6pC4Qdy962SCQSSQ5FCtoSiUQicZ5Es7DZMQ+zrx0SiUSSg5GCtkQikUicJynO9m+JRCKRGJGCtkQikUicRwraEolEkiZS0JZIJBKJ83T+1vQ7UQraEolEYgspaEskEonEecq1hXLJ4a6lRlsikUhsIgVtiUQikaQP1bWfFLQldihRogSzZs3K7mY4TNOmTdMdhTE0NJSff/45Yxv0DJOQkECJEiU4ePBgdjfliZCCtkQikUicIzEWjv8Gl3eCZz7QypAMWcbWz2D7VNv7tk8V+zORPXv2oNFoeOGFFzK1ntzGn3/+yZ07d+jRo4cxTaPR8Pvvv2dfo4A+ffrQsWPHDClr4sSJVK9ePUPKcgQ3NzdGjx7N2LFjs6zOzEAK2hKJRCJxjpiHsGogxD6CsZeh7sDsbtGzg1YHWydbC9vbp4p0rS5Tq1+wYAGvvPIKmzdv5tatW5laV0aSkJCQqeXPnj2bvn37otVmvFiV2W3PahRFISkpyaG8PXv2ZNeuXZw6dSqTW5V5SEFbIpFIJM6hmoq4emZvO54mEqLtf8wXmzYZA6HvCqF6yydi/5ZPxHbou/DcMMfKTQdRUVH8+uuvjBw5kmbNmrFo0SKny7h27RodOnTAx8cHX19fXn75Ze7cuWOR55NPPqFAgQL4+fkxfPhwxo0bZ6FJVbW0kyZNIjAwEF9fXwYNGmQhkDZt2pShQ4cycuRIAgICaN26NQDbt2+nbt26uLu7ExwczHvvvWcl9CUlJTF06FD8/PwICAjgww8/RFEUu8d07949tmzZQvv27Y1pJUqUAKBTp05oNBrjti0N88iRI2natGmqbd+2bRsajYbNmzdTu3ZtvLy8eO655zh37pzddk2cOJHFixfzxx9/oNFo0Gg0bNu2DYATJ07QvHlzvL29KVWqFG+++SZRUVF2y1q0aBGTJk3i2LFjxrIWLVrElStX0Gg0HD161Jg3PDzcoi617f/88w+1atXC3d2dXbt20bRpU4YPH86YMWPIly8fQUFBVlFC8+bNS8OGDfnll1/sti2nIwVtiUQikTiHKmi7uGdvO54mPi1k//Pb65Z598wT3zu+EPt3fGHa/qmrZd5ZVWyXmQ5+++03goKCqFu3Lj179uSHH35IVQBNicFgoEOHDjx8+JDt27ezceNG/vvvP7p3727Ms3TpUiZPnsyUKVM4cOAARYoU4euvv7Yqa/PmzZw5c4Zt27axbNkyVq1axaRJkyzyLF68GDc3N3bv3s3XX3/NzZs3adeuHXXq1OHYsWPMnz+fBQsW8Mknn1j9z8XFhf379/Pll18yY8YMvv/+e7vHtWvXLry8vKhQoYIx7cCBAwAsXLiQsLAw47ajpGy7ygcffMD06dM5ePAgLi4u9OvXz24Zo0eP5uWXX6ZNmzaEhYURFhbGc889R3R0NK1btyZv3rzs27ePRYsWsXnzZoYOHWq3rO7du/POO+9QqVIlY1nm580R3nvvPT7//HPOnDlD1apVjcfp7e3Nvn37mDp1Kh999BEbN260+F/dunXZuXOnU3XlJKRhnUQikUicQ9WwRt+DRS9CSHNoPCp72yTJdBYsWEDPnj0B6NixI2+++Sbbt2+30MamxubNmzlx4gSXL1+maNGiACxZsoRKlSpx4MAB6tSpw5w5c+jfvz99+/bFYDAwZswYduzYYaVtdXNz44cffsDLy4tKlSrx0Ucf8e677/Lxxx8bzTfKlCnD1KkmE5sPPviAokWLMnfuXDQaDeXLl+fWrVuMHTuW8ePHG/9XtGhRZs6ciUajoVy5cpw4cYKZM2cycKBtE6mrV69SsGBBC7ORwMBAAPz9/QkKCnKof8xJ2fawsDAAJk+eTJMmTQAhuL7wwgvExcXh4eFhVYaPjw+enp7Ex8dbtGHx4sXExcWxZMkSPD09KVasGLNnz6ZDhw5MmTKFggULWpXl6emJj48PLi4u6ToegI8++oiWLVtapFWtWpUJEyYYj3nu3Lls3rzZIl+hQoW4evVquurMCUhBWyKRSCTOkRRr+n1lJ/imT0MqMeP9VOydNSnsrt+9CLtmCg22zg30CcJspNHboEkxUT3yRIY079y5c/z7779GcxEfHx86dOjAggULHBa0z5w5Q9GiRY1CNkDFihXx9/fnzJkz1KlTh3PnzjF48GCL/9WpU4etW7dapFWrVg0vLy/jdoMGDYiKiuL69esUL14cgFq1alnV36BBAzQajTGtYcOGREVFcePGDYoVKwZA/fr1LfI0aNCA6dOno9fr0emsbeBjY2NtCrpPQsq2q6iaYIDg4GAA7t69C4i+VHn//fd5//33bZZx5swZqlWrhre3NwaDARD9YDAYOHfuHAULFsTHx8eY/7XXXrM5q+AstWvXTvV4QByTejwqnp6exMTEPHH92YUUtCUSiUTiHCnd+Un3fk+Om7fjeffME0J2sw+Ezba6EFLnJrbTW24qLFiwgDp16lCmTBljWs+ePenWrRtz587Fz88vQ+rJSLy9M+bY0yIgIIBHjx45lFer1VqZ2yQmJlrls9d2V1dX42/1ZcBgMFCkSBELO+l8+fI51B57mJfl6+trN5+qxTc/JlvHA7aPyfx4QByTKvyrPHz40DhDkBuRNtoSiUQicY6UkSBlZMisQxWqVSEbxHezD2x7I8kAkpKSWLJkCa+++qpFeqtWrfDy8mLZsmUOlVOhQgWuX7/O9evXjWmnT58mPDzcqI0tV66clT2zLT/Kx44dIzbWNLOyd+9efHx8LLTlturfs2ePhVC4e/du8uTJQ5EiRYxp+/bts/jf3r17KVOmjE1tNkCNGjW4ffu2lbDt6uqKXq+3SAsMDDSagaiYC7XpxcXFhdKlSxs/qqDt5uZm1YYKFSpw7NgxoqNNi2J3796NVqulXLlyABZlFShQwG5ZqgBsfkwZcTzmnDx5kho1amRomVmJFLQlEolE4hyFqkOnb6FKN7EtNdpZh0FvKWSrqMK2QW/7f0/A33//zZ07d6hcuTInT540fs6dO0doaCgLFixwqJwWLVpQpUoVevbsyeHDh9m/fz+9evWiSZMmRrOCYcOGsWDBAhYvXsyFCxeYNm0ax48ftzDlAOHyrn///pw+fZq1a9cyYcIEhg4dmqp7vcGDB3P9+nWGDRvG2bNn+eOPP5gwYQKjRo2y+N+1a9cYNWoU586dY9myZcyZM4cRI0bYLbdGjRoEBASwe/dui/QSJUqwefNmCyG8efPmHDx4kCVLlnDhwgUmTJjAyZMnHeq/9FCiRAmOHz/OuXPnuH//PomJifTs2RMPDw969+7NyZMn2blzJyNGjOD111+3aZ9tXtbly5c5evQo9+/fJz4+Hk9PT+rXr29c5Lh9+3b+97//Zegx7Ny5k1atWmVomVmJFLQlEolE4hx+RaBad6jYQWxLQTvraDbOWshWaTJG7M9gVEG6ZcuWVKlSxeKzevVqDh48yPHjx9MsR6PR8Mcff5A3b15CQ0Np0aIFpUqV4tdffzXm6dmzJ+PGjWP06NHUrl2bq1ev0rt3bysb6Oeff54yZcoQGhpK9+7deemll6xcw6WkcOHCrF27lv3791OtWjUGDRpE//79rQTDXr16ERsbS926dRkyZAgjRozgjTfesFuuTqejb9++LF261CJ9+vTpbNy4kaJFixo1sq1bt+bDDz9kzJgx1KlTh8ePH9OrV680+y69DBw4kHLlylG7dm0CAwPZvXs3Xl5erF+/nocPH1KvXj169+5N8+bNmTt3bqpldenShTZt2tCsWTMCAwONMxk//PADSUlJ1KpVi5EjR1p5cXkS9uzZQ0REBF27dk07cw5Fozjjm0dCZGQkfn5+REREpGq3lFEkJiaydu1a2rVrZ2XLJMk4ZD9nPrKPs4Ys7ecLG2FpVwiqCoNyr/stZ0lvH8fFxXH58mVKliyZ4YvnnkYMBgORkZF07dqV4OBgfvzxR0D4og4PD8/2qIvm3L59m0qVKnH48GHjYszcgNrHvr6+mRJs50np3r071apVs7uwM7VrKqvlNXvIxZASiUQicY77F+D+eYi4CTp30MkXJ0nGEBMTw9dff03r1q3RaDQsXryYzZs3W/lWzmkEBQWxYMECrl27lqsE7ZxMQkICVapU4e23387upjwRUtCWSCQSiXOc/gO2fAw1XocP76adXyJxEI1Gw9q1a5k8eTJxcXGULl2a5cuX06JFi+xuWpqkjPgoeTLc3Nwy3N47O5CCtkQikUicwxgZUpo/SDIWT09PNm3aBFiaNZiTntDvEkl2kfMMciQSiUSSs1EFbVcpaEskEklqSEFbIpFIJM6h+s1OiIGfu8NPudcjQHYgfRBIJBlDbriWpOmIRCKRSJzDaDriDufXid+KAil8HUssUT2UxMTE4Onpmc2tkUhyPwkJCQB2gwnlBKSgLZFIJBLnUAVtD3/LNFcpPKaGTqfD39+fu3fFAlIvLy+rQCwSEwaDgYSEBOLi4nKk67mngdzcxwaDgXv37uHl5YWLS84VZ3NuyyQSiUSSM1EFbU9/U1pirBS0HSAoKAjAKGxL7KMoCrGxsXh6esoXkkwit/exVqulWLFiObrtUtCWSCQSiXPU7g+lmkHx50CjA0UPSfHZ3apcgUajITg4mAIFCpCYmJjdzcnRJCYmsmPHDkJDQ2WQq0wit/exm5tbjtfES0FbIpFIJM4R0kx8QGixE6IgKTZ725TL0Ol0OdquNCeg0+lISkrCw8MjVwqBuQHZx5lPzn4NkEgkEknOxsVdfEuNtkQikVghNdoSiUQicY6r/4I+EYKrgYsnaF2koC2RSCQ2kIK2RCKRSJzjz2Hw4CL0WQsjjoFOPkokEonEFtJ0RCKRSCTOoWqvXT2kkC2R5CS2fgbbp9ret32q2C/JUqSgLZFIJBLnSExe+Ogi3flJJDkKrQ62TrYWtrdPFelauQA3q5GqCIlEIpE4h6rRdnEXD/BbR6HBYCjRKFubJZE88zQZI763TjZtq0J2sw9M+yVZhhS0JRKJROIcqis/V0+4vg8uboIKL2ZvmyQSicBc2N72ufBzL4XsbEOajkgkEonEcfRJYEgSv108xAdM5iQSiST7UYVqRS+CSkkhO9uQgrZEIpFIHEcNvw6WgrZ07yeR5BzMbbQVvf0FkpJMR5qOSCQSicRxtC7Q9gshcLt4CM8jICNDSiQ5BdUmO6gK3D4BpZpZ2mxLshQpaEskEonEcVw9oN4bpm2p0ZZIcg7mCx+j7wlBu3AtKP6cFLazCSloSyQSiST9SBttiSTnYDBb+Lj5I5GWEAXPf2jaL8lSpKAtkUgkEseJfwxhx8A9T3IIdlWjHZf6/yQSSebTbJz4Nuhh53TxO/KW+Jaa7GxBCtoSiUQicZx752HRC+BXDN4+IR7eTcaAzi27WyaRSFQSoky/C9fKvnZIpKAtkUgkEicw+tBO1mS7uGdfWyQSiW3iH4tvrSs0HJG9bXnGke79JBKJROI4qomIFLAlkpyLKmi75wGNJnvb8owjBW2JRCKROE6iKmh7iu9re2HVGyZ7UIlEkv3EJ5uOuPuIIFOSbEMK2hKJRCJxnJQa7YgbcPxX+G9btjVJIpGkID5SfIdfgy+rZm9bnnGkoC2RSCQSx1EFbddkjbYqcEs/2hJJzkE1HUn5W5LlSEFbIpFIJI6j+stW3fqpJiTSj7ZEknMwmJmLxD8GRcm+tjzjPFWC9sSJE9FoNBaf8uXLG/fHxcUxZMgQ8ufPj4+PD126dOHOnTvZ2GKJRCLJZRSpA89PgCpdxbZRoy39aEskOYYqXeH9ZP/ZKJAQna3NeZZ56tz7VapUiU2bNhm3XVxMh/j222+zZs0ali9fjp+fH0OHDqVz587s3r07O5oqkUgkuY9C1cVHRTUhkYK2RJKzcPUCjRYUg9Bqu/tkd4ueSZ46QdvFxYWgoCCr9IiICBYsWMDPP/9M8+bNAVi4cCEVKlRg79691K9fP6ubKpHkbrZ+Blqd7Whj26cmhwIel/XtkmQtxhDsUtCWSHIUGg245YH4CMsANpIs5akTtC9cuEChQoXw8PCgQYMGfPbZZxQrVoxDhw6RmJhIixYtjHnLly9PsWLF2LNnj11BOz4+nvh40yKfyEixkjcxMZHExMTMPZjkesy/nUG7YwpodBgaj7bet3MaKHoMoWOfuI1PA0/Sz88qWgV0Wyej1+stxph25zR0Oz5HH/oeBrP+lH2cNWR6P4dfg9iHkKcQ+BQAdLgCSlIcSc/IuZVjOWuQ/Zx+tHvnobmyE218BABJ0Q9R/Kz78Wnu45xyTBpFeXos5P/55x+ioqIoV64cYWFhTJo0iZs3b3Ly5En++usv+vbtayE0A9StW5dmzZoxZcoUm2VOnDiRSZMmWaX//PPPeHl5ZcpxZBRlb/9OhbBVnAnuzPmgjmmmSyTOknIsybH19FP1+mJK3t/M2aCOnAvujEbR46qPQa9xRa/zyO7mSSQSoOaV+RR9tAeAMN8anCnUjceeRbK5VVlLTEwMr776KhEREfj6+mZbO54qQTsl4eHhFC9enBkzZuDp6ZkuQduWRrto0aLcv38/S05cYmIiGzdupGXLlri6ujr9fwvtYqN30O6abtq2oel+VnnSfn6WUceYonNDo0+wO7ZkH2cNmd3Pur+Goz3+M/qm/8PQcGSGl58bkGM5a5D9nH50v76K9uIGktrNRKnxut18T3MfR0ZGEhAQkO2C9lNnOmKOv78/ZcuW5eLFi7Rs2ZKEhATCw8Px9/c35rlz545Nm24Vd3d33N2tQw27urpm6aBMd33Nx4FOh27rZHQ7PhdpzT5A12QMuoxt4lNBVp/Xp4Lm42D3DDT6BNC5oWs+LtWxJfs4a8i0fjYkAKBz90b3jJ9HOZazBtnP6SAxBgAXLz9woO+exj7OKcfzVLn3S0lUVBSXLl0iODiYWrVq4erqyubNm437z507x7Vr12jQoEE2tjILsFisprG9eE0iSS/bp4I+Qaxu1yeIbcnTizFgTbKZiKLA32/D74MhLtLxcrZ+Zn+sbJ8q9kskkvShRoZ0T9bkPr3GCzmep0rQHj16NNu3b+fKlSv8+++/dOrUCZ1OxyuvvIKfnx/9+/dn1KhRbN26lUOHDtG3b18aNGjw9HscsXiYKVIQkmQc26fC1snit2IQwvbWyXKMPc0YQ7AnC9oaDRxeAkeXOheBTquzPVbUMaWVc24SSbpRvYxsnQyfFIRdM7K3Pc8wT5XpyI0bN3jllVd48OABgYGBNGrUiL179xIYGAjAzJkz0Wq1dOnShfj4eFq3bs1XX32Vza3OZMwFIYBi9U3bUrMteRLUsdXsA9OY0uig6Tg5xp5mElMI2iCiQyY8ds6Xtjo2zMeK+ZiSY0ciST/qS697HnFdxkv3ftnFUyVo//LLL6nu9/DwYN68ecybNy+LWpTNmD+0/p0rfGm+NBdOrZaCkOTJMehNApH5y5w6pgz67GmXJHNJqdEGYUbirKANYqw8DkvWbE8RYaOlkC2RPDlqCPY8hcS3M7NNkgzlqRK0JSlQBaHG75gEIQ9/KQhJMgY1GI0t2z8pKOU8MirAUM3XoVRTCChjSlOF7vREh7yyS3wbkkDnJseORJIRjL0C+iTYm6xYlIJ2tiEF7acZc0Fo7BWIvCXsaEE+zCQZR/LqdkkOR7WJBsvr33zmyxFq9bFOe5LokBE3TL/VxbS59f4ko6VKchI6F2E6AjIyZDbyVC2GlNhBo4E7p2H+c7CoXXa3RvK0EfvI9NuQJGdKcipNxpjs6dUFiBllE51ejfb2qZYvainbl9vIaQs8pWcXiep1JN4Jj0CSDEVqtJ8VPPOKb3OhSCLJCGLDzTYUiIsAr3zZ1RpJapgvQNzxhdAgOytk3zkNOlfwLw4ubiLNNR2Ctip85guBh5fE+pGar5vaZ97e3ELKBZ6h74p+zq4Fnhk1iyHJXTz8D/4ZC35FoGwbkSZNR7INKWg/C4Qdgy3JN9vYcGFKotFka5MkTxHuPlC7n7i5d/hKrAOQ5FzqviEWHiYHGHJa+Pu+BSRGw/AjkK+USOu+VHyrL/SOoK4huXkIIm+aXs5y+xoSc2FbFXKza4GneVsUBUJHw87p0rPL007UXbiwQVyfNXtD8YYQWC67W/XMIgXtZ4F75+HCevFb0Ys3W4/sC0cqecrIWwJenJndrZA4ytbJJo8E6bGJtuV1JE9B59uR0lbZfFFtbhcAzT3xaLTZezzmwva2T8VvKWQ/3aiu/Nx8oFB16Ls2W5vzrCNttJ8FUpqLSPMRieTZZPtU2P+tabvJOOdsovWJ4mUdLAXtJ+Xn7vBtU3h8O+PKzE7M+1MxZL/Neei7pt9aVylkP+2kjAopyVakoP0sIAVtSWYSFwExD+HoMlj/Adw4mN0tkthCtcut2ceUVqefcwsQzW2wzQXt48th7btwaUv62nbzEIQdheh76ft/TkLt58K1xHbxhtm/wHPHF6bfhsTsF/wlmYt5sBpJtiNNR54F4sItt6WgLclIds2yDO+bryQUqZ1tzZHYQbWJjnlgSot54JxNdKIdQfvyNjjyE/gUhJDmjrcp5iEs62ESsGMeOv7fnIj5IkPFIF4gAsoIv+PZtcBTbVOeQvD4FlTumnsXm0ocQ3Xl5+4DSQkws6IQvt85B57+2dq0ZxEpaD8LqIK11hWqdgfvgOxtj+TpQr7I5Q5Um+iVA0xp0ffFt6MCV1Ks+Na5gdZsQtTFM3l/vHNtir4P1/eZtmNzuaBtHi11/3ciLeYBtP/StD8rUYXsum/C/m9EWslQsTBOCttPL+YabZ2rcIJgSBQCuBS0sxwpaD8LqILPC9OhVu/sbYvk6UMdXzo3sbjOwt2fJMeRUqPtDKogrQrWKi7uyftjnSsvpWCd2zXa6svMrSOwdrT47RMkvrNDoFUFf/9iprSY+7nfs4skdRKTr0P3PMLDmHseca1JF3/ZghS0nwVUQcgZ11sSiaOognW+UnDvrBS0czqqFhuE0OUM7r7QcCRoUzw6XNOp0U4pWOd2jbZKZJj4LlQTXpiWfe1QBf9/55jSopNfrqQm++ml5SRo/qHJu5C7T7KgLaNDZgdS0H4W6LlcCNte+cWFpujBwy+7WyV5WlBf5PKWFIJ2SlMSSc5CFW4bvwNlWjn33zwFxUM8JapGO/FJNdpPidmROlPglT9726HyJC9XktyJzkV8IH3RIbd+JgIe2Xoh2z41ebZknPU+iRXS68izgIef8HW8/1v4rDCsfz+7WyR5mlAF7XwlLbclOQ9FMQlaNXtbmhQ8Cem10TbXaLv7PT2BtNQ+zinrYdT25C0hAhZJni1U7yPOmI6oUUVTeqhR7f61uoxr31OO1Gg/S6habDm1L8lIVA12XlXQDs+ulkjSIjHG5KIvPdrW+CiIvis0ZOZC5JPaaNcbBG2nON+enIqqQT62TLg8fOvf7BW6VXORhiOkR6BngQ0fQuQteG6YCFjj5iPSE5wwHTEPdPT4tignMkwEPZIBj5xCCtpPOwkxsH6csM8uUFGkSUFIklEoinAXFvsQyrWFEg1zznS5xBqtC/RYBndPw/l1wra6/AuO//+/rfDra1C0HvTfYEqv0lW49XPWJM2gF24CPfM597+cjrmmPuqOELyzU9BWNdpeOUTDLslcLm2BOyeh+qtiu2AlSIh2fp2WubCtIoVsp5GC9tNOzAM4tEh4hHjlF5Emp/YlGYVGAy/OSDufJGfg4g7l24n7wdIuEFTFOUE70Ub4dRAP8PQstm71sfg8bd4vUtpBO+vdJaNRNexhx4QdfdWXnx4zHYk1KSND2lpX4ShNxsDWTwFFvKhLIdtppI320465xxH1QSgXq0kkzzbeybMO0c6690s2DcnI8OsgtL5LOsKiFzO23OzCwx/yBJu2s3sBYvcf4eUfYec0WP2GcyYEktxHRkaG3D4VUMRvQ5KMKpoOpEb7aUcVqs0FbanRlmQUSfFiStLDTyyO2TlDaO9CR0t3kjmRe+eFVlO1qY55IMx/HNVuqosdXVMI2g//g8NLhAlIw+HOt0ujE2YpaIR2O7cvtOqSHKxm2atwbo2l14/sIKgKFKwsXpCS4kR7ZHjupxNFMbnxc/d5srLUhY95S8Gj/4TJmAx05DRSo/20owrVHv4mwScxxnnvABKJLa7shKkl4ZsmYvvf2bBnLjy+k73tktjmwgZYNQCOJZuR6eOd026q7vtSBqyJDINdM4Ww7Qw/9xAfYxsUiItwroycjFey7XlOCMSj0YB3oPid3aYskswjKV5EgQTTy9SRn+CLMvDHEMfLUYXsGq8JIRuEl6JmH9j2RiKxi9Ro51Yc9XFpbjri7gvlXxQhWPWJJq2WRJJe1IW1alhfD38x5qR5Us5EFbD8iwphOSlWpDmq3TRGhkxx71BNSZx5gVcUuLRZRBNtNxXc8kDCYyGUej0liyPVBZDZaToSeQuO/yaEJK/8EHE9+zXskszD/MVZ9TaiGIS3IGfOuxpVNF8pIaiD8D7S5XvTfolDSEE7t6L6uARLYVt9C232gdg2F7S1WuixNGvbKXm6MY4v/+TvvPDosjRPyqmYe5/wyg+RN4Sddt4Sjv1ftdF2TaHRVk1JnHHvlxAthGwQJideeYWgndujQ0aGweL2kCcIKneGgHLZ61Xl3jnYNEF4nfItJNKy22ZcknmoCyFdvU0mWKrA7UxkSGNU0bmmtMe3xbc0G3EKKWjnVlK63WkyxlLIVvfL8OuSzETVXHv4i29V4JaCds5ENWHwyicWREbecM6MoHBtqDMAitW3TFc12qpXEkdQBWqdG7h5C2E0/FrOMLN4EqLvwoMLQuCp3U98shPzKJWqez+p0X56yVcKPrxvqdlOT2RIlajbpt+Pb9vPJ7GLFLRzM+bCtup+J6WPyyZjxY1etalUFKFJ0rpYL2iSSJzFaDqS/CKnCtzSV3vORBWwvPJDs/8JjXKh6o7/v3w78UmJ0XTECUFbFag98wn7YdVcJLdrtI2CbQ7xWR19T3x7B+QMUxZJ5qNztVSupScypIoqXFfqDK0np55XYhMpaOd2moxJ1morgMZ6SsfNW3xUlvUQgSo6fAU1emZlSyVPIylttKVnm5yNKgR6B0CJRhlXrmpKYkh03GtIrJl2HYRg6uEn1o/kZlSXiU9iZ+7oGhyH2mNmLlSpkzAhCaqS/rZJch/u6YgMqaIK2uXamkyPJE4hvY7kdixW/ipprwRW32ylICTJCFKaJqkCt1wMmTOJMdNop4foBxB1z3rRo/niSEe12uYabYDO38J716BW7/S1Laeg9rF3AETdha+eg5lVxGyio6hrcFLez1XzQGfcH5q3p0htoWAJrur4/yW5iyu7YeUA2POVKS0jNNp5gp68bc8oUqOdm1FvuiquXtYLJLdPFe78avURC56kxlGSkRR/DlzcxIIvgNr9oXIX8JE35RxJx6+FKYFfUXh0BW4cFC7fSjVx7P9/DhN+oV+cBbX7mtJdPOHNncKExNFgNknx4n9eyfekpyVSobnpiJs33D0lthOiHPfuYm4WGPtIaBOv7bVeg+MI0U/4ciXJXdw/ByeWC1ecDQaLNHdfKFhFaLad9VNfuy88vAxhx+H8eqjYAYrWzZy2P6VIQTu3ogrZTcfBzcNwYb24qTd621LYPrxEuHOq0F4I2qoNrdQ4SjKC54ZabvsVFh9JzqRcG9PvE7/B329DuXaOC9r2vI5otc5rSWv0FB99knP/y+mYC7Zu3ulzowiWwvbeZO2ks0I2WC6GjI8SAntiDFR8yblyJOknI02B0sJWVEhPf3hrV/rKa5Dse3tFPzi5UpiPSEHbKaSgnVtRfVw2GSOmcw/+APlKQpWupv1gY2pfarQlEgkmDaczXkfs+dF+EnTJj6Fre2Hb5+I+9uLMjCs/q3HzFuHX8xQU294Byb6rnXCjqNJwpElxorEjqKXFi7OEd5mCVUSo+6VdhOs3KWhnHY66480IVBd+bk8YFTIl6izl47CMLfcZQArauRXzt1/v/NDkXdO2eiEnJZgWPxjdr0lBW5KBxDw0hV8HYc93+Eeh4Wz8Tva2TWJJxE24ulsELilWP32u3uxFhgTY+7WwB67dH3yDnW9fQpQIw656ycittJ5s6Z3BK58QtNPj6WPbZ6bfil4IZs4K2wXKiw9AnOqGMVqcy5QzE5LMwVF3vBmBLY12eol9JPzC+wabbLRl1F+nkYshczuPrsKdU7Yd0RvNQzRCGAIzQTvcOr9E4gyJcSL8+kf5TGGzYx7A1k9gz7zsbZvEmpsHYdVA2DhBbGe0RnvPPNjxBUTedKys9R/Az93h6r9iW10Umdv9aKdEfaFxNuz59qmwawaUaCy2g6s/eehrd1/Quorf0pd21tJkjCl8+UT/zBGyQQR9AmtB+8dOMK0sXN/veFmXtsD8BvBLTzFLA1KjnQ6koJ3b2fcNzH8Ofn8LLmyC+xdN+1SttbnG0b+oCMPuqE2mRGIP9UVOoxXhs8HyRc4ZLwuSzCflojjVp3JcuON20vZstMEsOqSDXkeu7RGuRtX71NPiRzsl3umYOTDXdtZ4TaS55zEJao4K23ERsHMGHEmOCKzRSF/a2YlRqFZSbGcg9jTa0feF6ZCqFHEEVXvtU9BkChUlNdrOIgXt3E7ENfF95k9he3dqtWmfraiQBSuJMOwtJmZZEyVPKeqsiIefMBUBk4mSok+fKylJ5hGTwm+1Z14g2dOHo8KtGvnRlkbb2eiQKd37qd9JcZAQ41gZOQ2DHubWhQWtTddH3pLCK495PANHymn2AdR7U5j6gPASo2pF1TU4aRFxEzZPgg3/M6UZTYac1LBLnhxb7hozGnuCdnqiQ6ra6zzBZhptGR3SWaSNdm4nPFnQDq4OYUdNgjdYR+2TSDISWy9yrp6gcwd9vNCUevhmS9MkNjD3pwxilsszrxCyYx6AT4G0y6jcWeT1DrTe52x0yJQBa9zziIi1hiSxz83LsXJyErHhwr0amATrZuOc9yih5l/2CpxbC1V7mNKc0YKmPOcg1vSY75NkDeosRc3ecHixGB+2Fkg+Ka/8KoTtlLNO6fGlrWqv8xQUWm0QgnpCtHMvjs84UtDO7YRfF98lGglBO9xM0A5pBiOOiweXOWoYdldP5/xpSiTmqKYj5oK2RiNcSUXdEYK4qo2TZD/mbt5UXpwBOjfHI76lFoLZGdMRfZJpClvVZGs04nf0XaHt9iviWJtyEqrw6uEnwmA/KQ8vi+8q3Zz3WAKWUSFV0rMIVvJkmJsC1RkgBO2EaAh9N+OFbRc3cLHhM12NDmlrPZc9zDXa7nngjW3it63F0BK7SEE7NxMfZdIKlWgEe+ZaCtou7pC3uPX/ppQQQtLwI5CvVFa0VPI0YlwD4G+Z7pk3WdAOz+oWSVLDltBVqVPGle+MRtvcj7/5i5p3gJgNScylpiO2+ji9KIowFwHh8jA9qC9X3maCV81eUPp5KFz7iZoncQJzd7wgXnZjHoj4Fjo3x02BnoT0aLRVMxGfguJFuFCNjG/XM4AUtHMzEcnabA8/YXsNEHEDDAaTzawt3HzEg066+JM8CbZMR8AkeMvxlbOwpdF2BkUR59TFQ8yGpYzkaLTRjnWgLckKAnc/kx9tgEG7U7935XRshbi/c0qExHbzgQEbHS/r8W2x+FSjhfCrcPxX4ZYxpLnjZdgS/OVC+KxHNfs58lOyG8wHQniNeZjxCyL/HCZMsJp9YGkypAraCc5otFXTkXS465QYkYJ2bkbVXvsXgzyFREADfYLQJvoGw4kVcPsElG0tQmWreOYVAQykICR5EvKVgkqdoWg9y/T2s0AxSLORnEarj8WLeFAVU9rds3DnpFiwV6RW6v+PfyzcOQJ8cMdkKqLy/HgRmdbfxixaShIeg6uXKfy6Sm4WssFMg2wm4Ghd4e5p8VLhDI+SzUb8igg3a//OgfqDnRO0bdloS7KP2yfhzgmo+ya0y4SFkIoihHnFAE3GWu7zKwoFKjn+om0wQMPhJnkC4Nw6uLxDmKWWaZmxbX+KkYJ2biZfiHi4eSRrhXwLi8WQEdfFhXF+HZxYLhY5WQja/uJbTu1LnoRybcUnJQUqZH1bMpKsDJeclZRqap12/Ffhq7num2kL2qoPbbDtdSSgjONtKVwLPggTQbWeJqJtzBqoQm58hDheFzfHylLts/OWNNlnq2kOt8eGRjv2Edw4KH5LYSlreXBBfBesmDnlJ8YIIRusI0PWHSg+jqLVQuhoy7TL22HvV+L+KMeOw0hBOzcTUNoy+l6zcYDGdFNOzYbWfL8kZ/C0Cni5jawMl5zdOBO0RvWh7eJhbTaSXlIKnceXw9GlULoFPDc0Y+rISnSuQuFhPtXu4S/MPxSD6GdHo2aqGu18JYWwbZ7mKM+PFzbZ+Uub0u6egaVdRZkjjjpXnuTJuJ8saOd34qXUGYz215rM8QqiRoeUvrSdQgraTxPVX7XctmdDKzXaOZPcJuDFR9n2XHPzMFzcLF4EM3KxXVaRleGSs4rYcDi/XsxuhTQzpRuDlzggaKfmQxvg6h64vheCqorFdukh8qYIw666EsttNBopPuZotcKbSsx98XFU0C5QUVw/xRqYFkM+upL2Ghxz8oeIjznpjVQpeTISY03mnl75YElHMd6H7M+4F1fVo4i775OX+fhO8ngtZJIhfNQw7DI6pDNIQTs3c3WPMBvJH2L74WdX0JYa7RyJuYB394ywqT36c84V8JZ0EGG9X/kVyrUxpd84KMKwV+yQOwVtsDwX2z4T2sjMOAdZNYvx8D9Y/YZYy/HOGVO6UaPtgKs31ZuIPddel7bAjqlQZ2DagvaBBULwr9IVqr5s1p6nODpkzH3nhNvKncUHQJ8o1uAkxUHUbcfdMdprCwh/yM6YskiejIf/AYqw1c9fGq7sFK53I2+BX+GMqUMNRuPuY73v+gERQdq3EPT+M+2yTq6E9ePEPbzbIpGmarRl0BqnyOUrT55xfnsd5jeAe2fFduwjuLgJzm8wbYO1oB1UVYRhz+22tE8jTcZAhZfg1CqYWSnnCtlgZpqUIijN0/Ii1yDZdEExiFX8mXEO1FkMWxHjtk7OOD/3tty8gZmg7YBgm5SGRtvoR9sBryNhx+DCemubY9WntiPtyU08qe9qnSv4FxW/HbXTNhhg10w4vMTSvt7DXwjtILXaWYlqNhJQRpxP1cRTtdvOCOxFhVR5cMFx86OoZGHa3AzKKGhL0xFnkIJ2biUhBqLvid+qd4ew4/BTF9jwgbjJGgNCpBC0q3QVYdhrvp517ZU4jrmfU51bzhSyweQL2WoNQPJ2bjdNWmu2/sGQlDnhktWQ2ubCdmaYqRhd+6XwPuFtJgAqSuplqIJ2yohzKkY/2vG295uTMiqkSmZotLd+Zv/cbZ8q9mcUC1+ABa3gwSXL9PylILCCuJ4dISnB5KpVxVk77bhw2DRRuHvTmD3qtVrnZjIkGUdgedNCSNVO+34GCtqq676UCyHBeT/a5j60VVRBOz5CyCASh3hi05Hr14Uv56JFiz5xYyROEHFDfLvlMQk6qsYj/Lq4ENTVx6rgI8kdhB0z/dYnCGHAGYErK8wRFMUkSNvzo20elCS3sX2qMNsBEZUvoGzmhEs2L2/rZNj+uXVwi4wg2oZ/Z/NtfbyIVGdrytk8b5VupodtSpzyo23PrC0TNNpZtfZBUYQpVVKcmAEx56U5zpV17wx8Ewq+RWDUKZHWdooo11G3meo5d7cRpdI7QETglNEhs45KHcVHJaA0nAceXMy4Osq0hnf/A0Oi9T7zyJCKkrYN92MbGm13X+GWMzFGaLxlwDuHSJegnZSUxKRJk5g9ezZRUeINysfHh2HDhjFhwgRcXTMg9Kwkdcx9aKsXjG8RQCOmbpPiRfj12Ee2p3oVRTwQ3byyrMkSB9jwoUmbN/Yq7P/WeQEvKwSL+MegJEczS/kiZzQdCX/yerIDtZ/8igl3mcUbQu2+Yl9mCdvlXxBlG/RCKMro8m35dwbhmaDDPCHgphUyvGAl6PK9/f3ORIZMS6MdFyH6IiNMZ7JqcWtCtOnYn9RvtWoeYr5wMrCcc2UYfWjb8JvsjLcZSeZg1Gifz7gydS62zzeYNNqGRCEfpPSDnxKjoG32Yq3RwIDNYvx4Bz55e58R0iVoDxs2jFWrVjF16lQaNGgAwJ49e5g4cSIPHjxg/vz5GdpIiQ0iVEHbbCbBxU0sdIi8CRE3hV9cWyHY75wW2hKvfDA6Ay9yyZOxfSr8O1v8Dq4mBFhbQkJamP8nMRaafwg7p2WsYKHaX6tRAs1RBe/4SNAnWUb+yw0Y9BA6FnbPEtv6BPjnPajW3bQ/o1n/vum3PtH5WYy0SC0qZI3XMqYOVydMR1SNtWcKQdszL6ARi7zjI6013unF/JrY8YU4pxk9a6AKti4eQuv3JKjmIaq5SHpILRx8gyHCS1URGYY9S1DNssy1yAFlxff9DNRop4a5OUlCVNqCdpQNQRsyzwf4U0y6noA///wzv/zyC23bmoJVVK1alaJFi/LKK69IQTsrMNdom+NXVAja4VftB6BwzyPeamMfOTaFJMkaDHoo3x5uH4cSjUVa1D1oOMK031GajBG2f7tmwO4vhfY5IwULe/bZKdPiIuxrWHIqzcbBlV2wYwp4F4Bre+DUaiH0NR2b9v+dZftU+G+baTt/mYzXnD9p+HUQLwCKIjTftu4ZqjeStExHFMW+RlvnCuMfZNwiUHOajDEJ2Zmx9sHcDj5l//y3Hf4ZKxbCdf8x7bJUjXY+M0E7LgL2fCVcq700O+0y1DU8trTrtgJNSTKP6Hswu6Y4/wM2ifEdUEZcj35FMm725tRqce8q3cL6HGt14OoNidHiJTa1WZfEWNMaL3umYhKHSZeg7e7uTokSJazSS5YsiZubdBWUJaiCtl8K23j/YsKX7ek/IOyo8DBSpatlHlVLpE+Q5iM5CXO7aX2iWNh6cRO8vjp9QoH6oFX0GS9YuHqJ8Ou2VrfrXKDvOuGNJKVHktyCzg3KtoU8BaFgZfEAu7oLyGBB29yEoWwb+KaxeFEOHZOxwvZzw8WDt2g96323jgitWnDV1M0TDv4A/4yxdPdlTtF60Ptva+E5JYmxwtZYn2Ct0YbMEbIB1rwj6tRoxfemSdBiQsaVb4wKaeOYFIOwu3ZUqWFLo63RCRt+gJaT0tb2Z8TLlSRjuH8eEh6LWQ91fHsHwJj/Mraeq//Cge+FssPWy1RgOTHjZL7I1haKQQQ7ir4v7LLNubwDzv0DhWpC1W4Z1vSnmXQJ2kOHDuXjjz9m4cKFuLsL+9/4+HgmT57M0KG5MJpXbqTGa8JmsmRjy3TVlOT0H4Ai3PilFLTdvMWDzpAktNpS0M556FyFNhWEhiKkuXP/f3zHUkuankWVqRFQBrottL+/eIOMqSe7KFoXXv1F/L6b7Hf6+oGM9ztsvvBRUYSf68e3RP3NPsg4M5Vi9cTHFnu+ghO/QatPUhe0je797Ew5e+e3vh/Zws1LhF9PjLPvKjCj2T5VCCBgWiS+a4Ywe8qwWQPVJtqGptDcu4sjPLwivs012u4+4p4QfVcErklL0I5OpT1Rd+HWUWE+UDLUsTblNnJSpF2ja7+ymVtPWu793tjqWDlu3pZRp825eViEYa/aQwraDuKwoN25c2eL7U2bNlGkSBGqVasGwLFjx0hISOD559MZEUziHCHNbQtfFV4SU88XNghfzLZuxhqNSI++JwTtjHKWn9vISTdiEIsH3fOYNB4lGsGxn+HyTufL+mMwkGwXmCcYitTNvIV8TzuB5YVWMOYB3DoMxepnXNnNxiXPPh0Ts0/1BwkBNKAMlGmZcfWkhqML49KKDOks9mxEd86Ay9uh3luWgZDSizpr4JlX3O8CygoNY76QDL4mNMnh120EkzHv47QiOyYlQGSyV6mUNtr5SgpB++FlKFQj9eY0GCL6z7eI9b6ru2F5HxF1MisF7ay85+akSLuqZxF7odczyoQzLUE7I1C9kMjokA7jsKDt5+dnsd2lSxeLbeneL4dQqLr43Dkptu1pPcwF7WcV8xvxc2+b0rMr5PnG8cJEofVkqNlLCNoghLv4qNRdr5mzfaowOQF4foKw8dbqTMcFTy5YJMWLWRF70/xn18KdU1CmRdoCQU4j6q7Q3qrrHzQaKP4cnPlLzC44Kmg7IlSEjoY/hgl3nAM2m+zxMxKDHk6sEMJeqabWi1NVG/q0tK1pRYaMDYcTy8XvugPT21q4e1rMxpR24EXDkT4GqDNAaLR17tDxa/i+uTC/azQq42YNqr8iPrZQBW1FL851atpofbww9Ym4AT4FLPflLQnX9znmSztvcduL4eHJA+ikl6wUfrPK24wjGDXapS3TT66EzR9BseegUwasbcsoQTv8GsRFCvvxlF6l8iT71Y6SQWscxWFBe+HCVKaJJVlL7CO4vl9ElrI31WvPx7HK0xK970kwuxFrE+PRKBXR7pwGOz7PnmiMV3aJRSpqgIC8xU0u5q7vSzustYpBD03GQlAVcQNXhWH1eDJCsNg6WSyybPQ2tJhovf/4L0JT6+GX+wTtw0tgy8dQqw+0/1KkFW8kBO2ru4HRjpXjiFBxba8QvLwCMq+fYh+J8OsAH9rQWjsaHdIYsMaOJjr2IawdLbwbpCZoX9oKe+eLF5bGo6z3q3bbjgStcaSPm4yBzR+L9DItxSLxAhWFQJ+/NNTomXY9T4qLu7B1jY8UttypCdrueYQNti3UaIKORoe0h2pOktUBa7Ja+M0KbzOOoEZ/TKnR1rokmwGlsa7BUdIStDd8COfXQei7UPVl++UcWCC8LtV7C9p+brlParSd5on8bt27d49z584BUK5cOQIDpV/FLOHWUfj5ZTGlPWSf9f6Lm+HoT+K3vWA1xRsKP5hP6u81t9NkDMRFoNs1jfaABrLnRhx5Cx5eEgu1zDWmqvnIlV2OC9q2pl71SXDnRMYdl/oiZ8+NWW4OWnN1t/guYObGqkRD8R1x0/FpXkeEivXJGrwyrUwvRHGRcGmLsIXOCNMJVWvpmde2q0VHowSmZaPtaMCaBxdF+HV7tu7qYkJHgtY40seKAqd/F/srdjR93z0t0rNC0AbRz/GRyf1cOs3sNlFtth9dSTvv3q+FDXqljuKF16Ityff92EdZ74IzK4VfRRFCZWZ6m0mLpAR4dFX8DkghaKuC94OLGWM+okaGtCdoR98TZlNpCclGH9oFrfepiqC4CHGt24sUKzGSrqsrOjqaYcOGsWTJEgzJq1d1Oh29evVizpw5eHnJxXWZij2PIyq/v2X6bU9zkpGr7SHn2Ts7isEAt08AQshWNDo02WHDfGWX+A6uZvlQLNnYJGg7gi1/rbHhMK+uuMm+c856Ojo9qDMhac2YnF8vvnPLuNAnwrXkl9fiDU3pBSrB8KNCo+jMw1AV9LZOhm2fW7tZVPunbGvTf06ugL/fFl48MkLQTsv7hCp0OWyjnYagrehTF97s+dBWcUajDbYFt6bvm9LvnBKCjM7d1J+VOsK2T4V2PTY8Y6LnLu8rPMa0+kQsZk1JQFnRR2mFun94WWjAfYKsbbmNYdivpl6GosCG/wk3rqWftyFo5yP5jif6OSPuCY4+AxTF0tWiNhMCNKkcXgy7ZyfXoxPf26ZkjptOe8Q/FjMpETctoyxCcmRFjXgBi7prW7B1ti6wHYLdPD0+KvVyVEE8ZXtBjCUXD/Hi/fi25YJdiU1SWZFhn1GjRrF9+3b++usvwsPDCQ8P548//mD79u28846dlaqSjMOeD20VcwHcwYAPeoPCnksP+OPoTfZceoDeoNhMs4s6hbt9qmW6ql1y1GXX1s+sy7Ao6zPHynGU/d+KhVeAggaNordff2ZyJXnBo2qXrVKiMVR/Deq+4Vg5Nw7AnJrCrEPF01+MCcUAJ1dlSHNT9aOt1gnC3tTBcfHEYzAjCDsm/Mx65rXUaGu14oGSHo2T+h9FL1y0qULFg0tiSlnrgr5UM+NxHnITQppyfT//7Dv55MetaqqTBeqUfZrgLu4RCZF3U68ruCqUayfMLWxhrtlKSkWrbc+HtoozGm2Vih2EtlJ136cxe7RpdVC5ixCuVU1fYDkIrCDOTdhRx+tJjbCjwsTLkGR7LL/yK3varOGPR8VS7+d142BGBTj0g3U5BaugH3KQvS9sSP2aiIswheH2CrAuBy1K8rNhy+HTGXNtOfoM2DkNw/yGoE9AQQOGRPR/jcr46zz6vvBd/vCSeGnVJS/i3fZp1t7jvfPDq7/CW7us7x+uHiY7etW85EkYtAuGH4ECFWyOQYObGP+XboSl3s+q/bVPQetyFFCSfWvvPHIia+7LuZx0abRXrlzJihUraNq0qTGtXbt2eHp68vLLL8uANZmAdscUMdXaZAxEXBeJqqBtvuhHqxPpNw9ClZehUE30BoWbf0wiJi4eb3cXCufzQQkdw/7/HpBv/1Qexml4+3YrukX/jE5j4DJw2FWEY05MTGRWknAPGOznwZKQbZQJ9DLVpQoNZlql8DNbuO1Xg+Dww/jd2Yuh6fvsK9Kfu0dvUiCPB3VL5kO38wvLNqv/N7e5BFOea/8K/53NPjBqTvSN37U6LoCbD6M4XGqQZV3/bRMLwcw1J/fOwQYxdR/jU4J92hrU8AjDf+tkrj2M4UjJgdT872uLcqPjk/DycCeo/Xhu//URMXHxPKo7OvVjApO2x/yY1Dzbp8LpP0VaiVDr89lxnvWASJlHrev4r/DwP7hzGsO2KcY2F8SHvEDUgaVs9mif9nlIq66UGu2UeVQNmW8R4Qln62SiT23GNy6Y6O/m4X93n3Fc5F02jkexBofGYJCvOzODNpDXU2c5li8/JO/+aVbnJs1xkfK41JmDYs8J4drWsaec4rV3LkDMmJxabdpW9LD0Zej5m1GbfT+gDqumjSEmPgGAi4oWD11xKmmvsuGPn1htaJz6tZfiXGmTEigXdgHtztPQfJxZhMD8rDsZxrXVEy3qGmhoRzvtQB4k+LL5u73266r/lvjYO+7GZrbrSfFCqLXVNyk12inzFE4OtGW+fiS1Pj73DyzrIX5rtOKFcusnwhY7pDkUqABdf7Aup0Qj6L/B2td7anUlo905jXJhZ9HuOGG6LyfPCOy8qTDm5y10jbIcy99puhIek2gsw24/Jy90PBjhy7Ap6SyncrKzAjcf1p17xKS/TluV01bxpBTw3br97DFEm8qJPmR9r3Skb8xnFi7vEDNC5vftJmPg5mEMWz5Fi4HzhsJoMVBaG4bu0AL2733ITH03i2Mqld/dciw7054fOwmtq5s3lGwitLCXtwtzt5R2/Q6c80zLk7+MMAXaPVv4wVafCeZ5wHr2z1Zd3gHgHcC6k2E2z3kSOkYAB89fZ+xpca0vKrmFcuE3LMdyskZ75x0XxvxmPQbX8zZhca482KjBQCr3DHvHnpNmMbOAdGm0Y2JiKFjQeoqjQIECxMTEPHGjsoJ58+ZRokQJPDw8qFevHvv378/uJqWOxkxbYNRoF7XUFqhCqjrt45mXdRejWTB5EMWOzWTNybv8dugW2m2fsuOjltT+sSycXUODa18zPfZ/vOO6Ar2iRa9oGaL8yhDlV/SKaYh0i/qZMqdnc+FejE3txbr8r3NcUw7/23soe/Yr/O7sBWD+9ku88t1eRvxylFe+28uCyYOs26yW02RMsjA9GbZO5sydaMLPbYfLOzCUCGVPkf6cuRMNWydz+ONGVsel3fYpvx26Zbsu83r0ibD4JeFLHJj/qDaHH+jwv7uXPfoKFDs2k4vLx1uVu+bkXYodm8mBSQ2Ndad5TGBKS5lncXvxHRcuhITre1MvB2yf8+1TxTEla6xvhMdatDnvzW3oFQ0+D44z69d/HGtzanXFRhjHmM08/4lZAuLCWZf/dU5oyuJ/dy9NI1bjf3efxbhYc/JummNwpMsKhulW0S16GQ2ufWNxzg9+1Ih9C0fbPDcOjQvz41Lts0s0tH1cc+rAl9VMDzh7/aOyc5qwBQbwT9ZcXVgPK/obZ1JOhMXwhv4X43G/47qCSEVoh5/XHXHo2rNoi0aHotGi2/G5SEsWbK/He3J62f+s6uqrXctv+mZsNtRyvi7z4945zaQ1TIxNZeyYabRt5Tn7N6BxrI8fXoblvU3tajpOmFwALO0mPHckY9g2xXhPuRYeDwe+w7B3voW2Ts2T1jWh2/E5ikZrui9v/cwYSW/En9foGvWz1Vh+Pf5Xi2Js9vO2KUb769GbH6e/nN2zAIhx9eetnw7bLOd0UhFGJQzioqGQRTkPYvTO3QvMUX2UX9kpTEMu7xDuA5uMgYQY4hd3RovI85e+ARv0phDwI1xXM0y3yqIte69EcDNGh27H5yRtneL4ubr6r4iwC5AQLeISFEv27Z8YIxYeO3oNP2mehGiTuZCtPGoExrhwy2eCeZ6Us8KptGfdyTC757xykogJ4KOJMfZzubNzCYvVmcbyFlObhv55y2Y5TRJ2cg9/DMkipNP3jGeMdGm0GzRowIQJE1iyZAkeHsIuLzY2lkmTJtGgQc4PVPHrr78yatQovv76a+rVq8esWbNo3bo1586do0CBDLBVywQMjUej0yUPYDVS0+UdcGiR9UKS5Lf1u9fPc3r3/xjluoLpiV2Zozf5Qn/HdQVo4J7Bj/t6XxrqTrNbX5E5+s7Gm505w3SrjOX8eKYx82rWpEFTBW2y9vfPpPo0OT6WKrorAGiTFX6nDMUZov2VOJ3eWPYbelFOTOQLtKgYRD2zco6UHEjwhTBUC8cyZ+bhojFwiPLUurKDfy+MYY6+M0tdN9NQd5KD+jKsN9ThRe0em21+Q7+CGYldqVjrE9qU+NGkyajwEobo+2iBbxJfMPaNFgNvu4rjr6i9ymmDpXusOfrO1NeetuovYz35X6dN5WCL82D1Zv/oMtQZCP9tFeewaH0IaSY0nDunm2YAHsdRo1oMxbZO5vaNy9zMU5VA/R2KHZtp+5zfvwCxD0nSeVHk2h+2zznQUbebJEWbdpvteQPYOllM04Nw57ZvPteqvc0Rv54UyOMhzue2TwG4e/c22l97UkV3HjApguMUF4bwKwZdPNP1L9vsU3NUoRCwOC7xv5MkaQz0TPpfmuVYjYuUx64Kig8uwsEfLI+riQHtdmG6tG3HZko9+tf+uYgNF7aMyf1Asw/EoqzvmolIjCdXYKjek7XaZrzIVrvnKlR7jBG6FbztuooZiV1Zfqkpu7o2R5fKuTI89zbnH6+lbJmy6LZOhiJ1ALh/9RSjXM/YrUvtr1GuK2zXpSjCtjXVcZHcf3vmwr6vbedR7T4vbYOTy63H+8GZXKs6giOl3qTG6on2+1ifBIcXCe05QJP3RJ7nhsMXIWJh2MxK8OYOLuxcQZnTs8WxHxXPqHc9uzNk26f8m3ieb/Uv8obubxq4ruBCxeGUsXE/Ne9nfeh7nH9ckdKN25nuy4AeLa/pNjLKdaXNfu6tW8/fhgY8UHzt9zOQhJYO2l287brKZjltdAeYk9SJMpobqZZzOcaTobpVvGPnGXAusSj3yGt53iNfZXfTg2gdvReAmM1Y2c969kajE/e4f8ZiMOhxTxCzFPMSXzK2JUjzkM4u4gW3hPY2P2s/5jld8ji90BSAYToN72z/FIP+dy4r5bmoaO2fK4M+OWCbwHx81Q+5RMFLy1FuHWFn6TGUSG18OXrsaeU5tFhEhSzXDo4ts3NNFBLmTy7uli8ntkxcUqnLcG4dYXdKMlSH3XMOkIdYi3O+5FEn9jZsZTGW43Gjl25DquWkec9Iq3+eETSKktbKDGtOnDhBmzZtiI+PtwhY4+Hhwfr166lUqVKGNzQjqVevHnXq1GHu3LkAGAwGihYtyrBhw3jvvfcs8sbHxxMfH2/cjoyMpGjRoty/fx9f38wPL52YmMjGjRtp2bIlrq6uaHdMEVPeyehD38NgPmULaFf2RXf2L+N2yosEYIbLV3R22WWcBY80eOKrjSVBccFNk8T0xK6U11zjBZf9GBQhOKcsx9/ThW+Uj6jHSavZdL2iQadR+DOpPheUIslvxCIttXLiFRfcNUk2+yJC8cJPE2PMs1tfkYa608b90Yo7EYo3hbQPSVB0uGn0TE/sylx9Z4L83Nk6KhTX3dOFNkrnhkafwK9JTRib9KZFPT+7fsJzutPGY7plyIcHCeTTRhnLVes2PybzenRaDdqd04yaL41iEAstFUvXeoqLJ5qkWGN7zpUfSu//mnE70jTmPnD5iYEua43t+UbXg8LtP6R1JdOsklpXaud8nsssXnDZbywn1TZrXdAYkmyPLzUPGjQofKPrwWfRL1mcz6HKMgaw2thf6hhKUrS4aCzD/6pjbq++PPV1ZzEoGrQahQuGQhjQUk57A72iRZf8v+mJXZmvf4kPXH6ir8sGrhgKUEJ713guHhl8yKuNMo6TLxM70Va3n7LamyQqOlxtjAudVmO8ttTzZeu4fldGUIIw43HYPBebPkS3bz4KYrmZRR8aktB90wjtw4vGemydq+G6lYxyXWnzfP7Urzb1SuazGl9qPeb3DPe9X6Lb8TkGjQ6tordZ17BkQUw9plTrsnVMKceFA2NHxdZ4H+6yilEuK4znz5Hxrq83BEMLM5d44VdxmV8XjZkrS1vH/rnLt/Rw2WYcczOS88zpUc1Yn63jiq8/wvK+vG4sukMLLK6tlHV94zqD1rqDxrps9vPfI9AdW5pqOb+5TqSu7rzN+6mxnN9eR3fhH5t1pTzvaj+nLKfBjR9sji+b5zz5XgCguHigSYoz3tMMwTXQhh0x/mdlUiPeSRpsUc4frv+jmu4/i+dIyjb/6jqJerpzDp0rlQtlBvD61bYW42uN2zgqaa8a70mpjS/1np3qsTuQRyXVctT+8syPNvaBsU8N+cuCRov2/tnUr63149Ad/C7VsaM+922NnUW9qtOwTAG0Wz5Ct2e2zfuByqcu3/Oqy5bU7xnbJqPbPRNF64rGkGizzZlNZGQkAQEBREREZIm8Zo90CdogzEeWLl3K2bNnAahQoQI9e/bE0zNnu3pJSEjAy8uLFStW0LFjR2N67969jYs6zZk4cSKTJln7NP3555+zxbuK1pDIC8cGosWAXuPC39V/sMqTJ/Y6zc8K2+N4xYVy8Uus8oRobrLZ/V2bdaj/+Z/Ljwxw+ceYvlFfk8GJI0lMnghRb9TqjS+lQD5Gt4zBrn8xPbErQ11+NwrQ6/W1GZI4nCRcqKc5w+eu31JSe8d40SYpWqIUD/y1McYbglp2yjZecn/NKIClJEFxoazZsQ+tqKeMn8KLR/uhU5Ls9o0LSZx372VRn63+ueTeE51GIUnRUjr+J6t6ANof6YsWvUlA0bigVZJQi37kVQrf2GvolCSScKF03OLkPeaVK1x274kmWVAtHf8jAP3KGqiWX9TjlhhJm5ND0QCJio4yyXnM8SSO0+790Gis86ht9kh4SOtTIyG5rbbGF5CiDxdbtRfgnHtv3DVJVjdjVYh8aPDBTxODTmMgXnGhdvzXnPAYYLvTES9vs5K68I7rCqMAn1penUYhXnGhQfxcDnsMMu5Led7Nz1dax/WG7m/ed11mVo44X+bnotKNpZS+t95uH+oM8bQ7Pgitorc7BgG746tXGT21AkRdLx3pLR7G6Pirhu1YB2mNd4D/3Hui1ShW48Kyrl5owKG6HBk7qY13dezY62P3xHDanBwOqbSnYMQR6v83E7C+F6iU1txgk/uYFHkU/N1gQk09Wg0UfbCTmte+A+xfEwGPT9Hw4hTA/j23mfYIC92+sJlH7WfzuuyV85puI5+4Lky1nDK3/6Ji2PJUywG44P46rho9CYqOsmbnvVVhPR0L3KftmbdV3yRcy9uQoyUslRKFH/5LratfG/Pc9ylPYNRZzgR35nxQR8re/p0KYatM9z9FQ0j8Uqt2mN+bDIqGmcnX+YzELhxXQhjn8jPltCYzIL2iJST+J1KeKxQDLx3tI+pCS0icekym8ZWPCA65v2V2HxR9Yz6+RDl90aCgAOcLduBsoS4WbS4ftpJyt4W8YNDo+Ku69Rh0S4yk7cmhos0OXBMGtEbTmpSYP0NslZM3+hKh54Wskto5P+fey+zash47AC8c6YcL9u8ZL2r3MNdtjs261HJK3ttE1RtL0jz2zCQmJoZXX3012wVtp01HEhMTKV++PH///TcDBw7MjDZlKvfv30ev11vZmBcsWND40mDOuHHjGDXKFFRB1Wi3atUqezTaO6ehxYCic0OnT+DFPKdtviFzFhIUHe6aJIbpVlm9kbbTCjtZVQg6oy9KBd11EpK1G8N0q/BGeA5Q35Bb6g5zUDuIfYYKPFTy0MNlm5VmV52yB5iqf4VY3I3TTKqw3Fp3kEPaQVxQilBbK0wKwgx5CdY+MmpX/DUxRsFMFehP6ktQWXfF2Malrp8YhTR3TRI/Jj2PH9G85CJsw91SHHupitVof6g3WiUJvdYVd0Oizb55S/enhfb1j6QGxOFGd5ftxrpE3eKm5KIxWNZTqTrtqgYnnyu96Y2+7iBw90Ozc4pRe+GXNz/amP9QdG646BMYplttQ/O02qjlEXWtZq6+M//c8WJMT6GN1S3tnPyw0+Cq0ds8rgG6tcaHS8o8apt1v75qzK9TkuyOL52SRALqWEnZZg3DdKsshGzzcTFb3wUFjXFcGDWXrtMtxuRGfU20GHhed9Q4vszzKwocV0rhRiIVtNeN/zuvL0xZ3U1jvj66dWzXV6GJ7gSKgtU1YX6+0jquYpq7xmtCzZPyXLjMEv2laF3QGaz7ULtzGlpFjyGVMThMtwqdRjFq+83ztGpcz6hlVrWIWvTGeqw02kpSmnVpk/s25biwrAurumyNi7TuTWqe1Ma7uyYJQyp9rF3ZT/QxmlTacxr+E+M9ZR+qtNWa1uaY5wlPgMCK9alXMh+6Oe8b86jXhJVG+w8xg2hQNHbvuaHaY6LNNsag2s+6H78GhEBqr5w6mrN26zKer037IEwcu71yhulW4Zr8suqm0TNa9wvT9GJR6YabOnrcXYxGZ7r/F3+0G09XLXkHrBIJj67g8lVv431Hg0Jg1Fn0oe9RuvHoZE/h7TD8dA/t1Z0oiGs4tXuT+XU+PbGr8R6REp3GwAcuPzI56XWLc6WOU0WrQ2fQ2xxfPXWbU9wHbYwvs2tLA5S78welS5XA0PxDUxsWmjw7aRU7Y/DPIeKck/b9VNG5odUnYMhXWsx4JWuvDaVbgWJAe2lT6tfWH4OTx4X1+DI/56qQnTJP8wa1hEZ75zR02M6jUlZz3fjb7hhc/kvysWvsHntmExkZmaX12cPpxZCurq7ExcVlRltyJO7u7vj6+lp8QPRDVn2M9f07U0xDNfsAzYf3oNkH6HZ8juu/M035k/Ncq/Y2ZeN/NN6szG1VVcF1emJXSsf/xG59RSrorrNbX5Gy8UuM/3nFZZswIYlfxBZ9dQD8NDG00h2yELKFQNzJuG3LLvZffQUqx//ANn1VYzkphezpiV2Zm9TR6r9z9J3Zra9IZd0VYxvVunbrK1Iuuc2vu2zmJZe9LE9qzGFDab5Pamtx7DX2jUAbdgQFDQurLnOob6YndqWDyx66u2xnemJXypnVfUovvL48NPhYlBPs7215rsbfF+dq/9fodk4xnb+SoWhvHoCSoex99Wyq7fkqsT3xihgL77iuYKhuFWER8Ry58RjXf2eivbIDgqpwodHMNI+rjI1xobZZe3GDqeNrvGZ/fFUdQdm4JWnWNVffMc1xofbpc7oz7NZXNPZ7S91hntcdZXpiV0LilxrrUh8UGg1EKR5U0F63GMtldTctxsVw199pojtBlOKBRgO/JDW1e77uhnSlYtwPdo/rNZfNxCmuaDSwNKm59bnYNhlNtBDGNaPOWF+jZuNC+d89vtX1SLX/zK/H4bpVBPt50KB0AVM5WjEmqDfIoh7AaDZCmVYoff5Jta5LBmE3vV5f235d6tqQWn3tjgtq9kbT+tPU8zT7IM3xvktfCa0GzhkK2xzvurN/gk8BNA2GpHofPFN+mM3xbl7XZn0NQKxXMc/zICYJ122foI00aVJpMBTdjs9x3yuELGNdybbmDd2Fraqtuvq6iGtLo4GvEtvb7GfttX8xFK3PONexdsvp4CLWo1xVCtgfG/vmYWj6PqEey+2W847rCr5NbMdjRayzGur6JyN1K4z7m+uOAvCDvg0n9SUAKHB3JzFfNcVVC67/jBLCqF9RNOMfClekgEar5eC1SNaeukvY35PRXt1JeFADzpZ9i6803VMd7+bXOYiXbhDCIwjhe7e+EpGKJwNd/rE8V+bjq+cFp+6DVuNLjQ7cf6PRP7xuz5e4bpkozvnPndHeOmTyTV+8ke0xeEIsXNVU6pTqOLV4Jjy8CCVD0Yx/AM0+QHtxA9pLm9J+7p/8DYAj2sqpnnP1OWY+dvzdFOqHBBrbY6jdnxfcF9otZ7jr7+zVlweEaaXNMXh+rTj2Eo1stzkL5afsJl2LIYcMGcKUKVP4/vvvcXHJwohSGUBAQAA6nY47d+5YpN+5c4egoKBsalXa2AwNnjIqmvq72QcUbvwuwWe3MDdCvGWaawbMFzcM060yCqwNdacZZrAWhuJxo1/iGN42LGeEq1jsolc0ZkK26W13mGGV3boA+iS+Z1FOkqI1Ctlz9J0Z6SLyp2yz2sYDSvk023xNKchNQyB6RWu8mTTVHqXkvYsA7NJXJOrgz8zRW9dja+GHOSnrBsinjWJu4ku847qCPB4u1Lt+UiyCq9UXitQ2RVE0Z/tU06KXyzvwd59prNNeewI1EXRz2cEZQ1FjHv8De+DsHOO4CDEorDhQDKJSPy7zuizaXLSe8AUMULqF8JSRcnxV7ESx41+ywLUG/RPfdagPUxsXjozBlMxN6mhz4WNq5YQp+Smjucl/SrBxXFgcOxB4aRVutEv1XFTRXqaV7hDXlIIWQoHxXIDw0exTwPIavbLTwtWZDijWaSIzliWlea40wCjXFbQPKYRu5yFRXsORRu8SFKggFqRtnYxWr6fs7fPojqwSERBP/44u5gHFOi21W1cF7TVCCGOnoQqnDCWs62r2Aez7Rvyp7hvgW8jmfYeI6yIMe9P3Td6DzPPUfQOu7yfw+s1U+/hfQyUa6U4RoIlkRmIXu+PdwqjXRnvCi/SHo3tTrWuJvhX7tYMJ1EbwY9Lzxjw1Lh+AY7NMZZZuAXUGgIcfuq2TKRvcWWjNk+/L2iZjmBAQxls/2a/rVZctBGsestFQm7hEd5v9rG0yhubJniMUG+UsTGpFX5cN5Nc8tj82UrTHVjnqGFttaMzvbh/irklipOsq6mnP0EAnvFOYxqHCYj6nie4EfuGnUD4pgEYxiPtX7+T1QH3+5sJvH1ImeYEpQAfXFcxI6srsK6Z7QaxO7/C9CbCaFftN/5AIvBmoW2M6V//th+OzoMk4aDKGu0dTH1/26jKOr+eGm67dN7bDghYiGMyeubD3K+FdpWQolH8R/hkD7j62x3tgBbh3BoKqQuNRpnTzPOpYTvFMsOvr295zv2wbOL+OIsFBzPnP/rHX1p5nm+5tXk98D02iGDs1/BRcd58QYzmoCtqDC5hX2Y82B+2PnWX659mtHU4h7UN+SWpqGoPb9sGOKcZ7D4kxtiO4PkOky0a7U6dObN68GR8fH6pUqYK3t7fF/lWrMigoRiZRr1496taty5w54qFoMBgoVqwYQ4cOtVoMmZLIyEj8/PyyzOYnMTGRtWvX8qLPCXSqj8uU2PHdqbr5ARiqW2W0ZdYrWuMNZqTLCuP2MLM86puguQ/jlIumdusr0jPxf1bNGWanLvP9T1KOvTarrgh1GoPRS8X0xK4U1dzlRd1evDQJXDUEUlx7z+Jmm1p71brUcs3zDNOtop/LP+TVRPNawjhqai7wUtWClC6QR5yHBxeFX+um74sbcyp+tK8/eEzj/fVTbU8lzWXWuH9AoqJjQVJb4jRudKlZhKL581iMi3Unwxj002G75dTUnKeHbitHldIEEGHZ5iZjYMc04Yu7Zm8oVs96fHn4wz/vskZflyGJIx065+k5n+Zj0Px8mp+LOpqzxhc+9bzbGxd1tWdprDvJOn0d3kp8m2G6VaZjv38eTq0iOm8FKoV9mGqbX9NtpINuNz8nPc9qQ2Njni41i1D0wW64eUgIlO1Mi5bZPtW2L3fg479P47VnukU98wyd0Sh63nX5jaKaO0zzGMG3ZfZZ+qkt1RQWtDQV1GcNXP0XfVICFy5coEzZ8uj0sSJ4Ue1+8OJM1p0M4/xv4zEku7VU65ruMo9Out18nPgaa3062/aJ+2kR4T1h2GHIH2L7vrP5Y+Hmr85AeGGadZ6gqrCsO1H5KlP51vt2+9iVJI65D8RLE0+r+Cm01h4w9XGK8W7RxynaozcoNJqyhdsRcSipjME5rrNpr9vLoqRWPFR88fXQ0q9hSbTxEaB1ERFbq75srEq/5TMunD9LmTJlrO7L606GMf6PU3SPWWYxlr/TdOWbpA+ppz3LiITB7M/TIlXfw+tOhvHuiuP0SfzNopzflFZspz8AZeKWEODnY11OnmBxzynXlnVX9Ly36gSvx/9q1R7VH/dz2pMscf0MF41JHLClcJjpMo+XdP+KdTMaHUkf3OfQ1UfcfRzHlfsxzNp03u6zxpyU52GeoTPmMU/UZ8S/+grsVypYXOeqQkavaNEAvh5a+peJRXP2L+Fhp3RLrj+MSvN+WkITxjCX33EnkXOGIqbxFX1SXKsNhogonyDcRH4TaoqeqtHBhIdwdQ8sbAO+hWHUaesxePw3EYjmtZXiRQ3s+9o2j6xpy4/20aXinL7yCxSsZJ1H6wKbJ0H1nqwr/aGFH23zc/570lBKaO/QLX48N3yrs6jkFpTwG6axfPVf4RGr49esc2nK+6tP0jPuF5tj51OX73jVZSubDbUoVrmhGIO3jggXpioFKsHgfy2PPYv8aGe1vGaPdKmj/f396dKlS9oZcyijRo2id+/e1K5dm7p16zJr1iyio6Pp27dvdjfNLobQsejsTYPYeTtsUzmY+a/VZOKfp5gTaeblw8sVfyA8xjIQiEvdsZQI8DYG9ADYe+kB/j8f5vWEX620kO+4rmCYwdp+y8KjiFldYDl95Uw55qhttlUXZnWB5Zt4tOJuJWTbqkerMU1VzkrqarNcrUb8L0R7i466f6nn9h9lun5CadVVHMAc4ZeYwrWgTAubxwJAkzEUMigEnxMCgb3jPqWUZL+hHCU1t9muVOOKTy2G1csPh34QYaYLCm8/tUvkM7bP1nFV1F7lZZftlFHCuNPtT8s2A4SmsKNLOb62CK1EnGteNInC/tBem82xNy7SGoNqMJo9sYNYfrsVtyPjLMoZqKxApzGVk/LY1fO3N/YEjXUnqaG9QJCvOxVfMjtf68XiYc9SDQiO8TAKZraO6yd9S37SmwRc4b3Eg2Edm8NX9URiyVDrPrRznT6MTmCBvjPtqwbTomJBCuTxYFjxvBy6+ogKSwbhr4mmfIdAQip/bPnH479ZbocdgyZjMCQmci5qLSGN26FblnytBAvvUG0qB7Pm+Fv8dTyMjtUL0b1OMYYVz8uemUsgGmoX8eL9N5uj0z5v3dCkFCHYbR2PGqgo2XzGKs9hsTjNO18wwdEedsd7Ii4cNJQlVHeCBtrTln0ccw8SYsAtxWJ0G+3RaTVMaF/RqHCwN06X65vQXreXjrrd1Iufx5ed6qNNeV2YYWg8mnOP1xIS2k7cl5e9KiJwtvmMNpVrEeznSYd58eTxcOHb12tTt2Q+BgFbZvzE6chYapcswIz+Kfo5MVYIOflKQZ4g2lQOZseFe8zZ15mWFQvQr2Ep6pbMxxt6PfpPBqDTKHzduThNa1ezPl8zKkHkDSi4hTaVa3HncTwT/uhMlcK+vN+uorE9MzeeZ+7Wi/xrqMw7iW/xpdtXoimKzmZf/acEGxcZu5PE3IkDmZ3k2H07ZZ583q58+GIlgnxN4/3u4zgKHJ5Ng2vCBGe2nVkx9cV7g74W2pJtibv6PZ6A3sUT3bZPeVxuKD7uLkTFJ9ltjwboottJkqJlYmJvXP0KivH1TWMh0OYrZcrsVwRq9oJdM4VPbn2iEBrrJS+yjrwJ0Q8sx6CiCG3urSPiBVPFnjbXXPi0lefECrh/ziTsp8yzcYL49vCjTeVgmpcvSNn/iWv229dr8XyFggwCTk8OAP0deld1p2335hj0oaxdazaW54kXFPIUpE1IMLEJet7+rTNlCvjwUYfKxrGz//JDrp/3xLB3G89rD7G+wERO+5Wk1ZFf8QQMFTuiPf07UdGRnLj0QAQJe8Y02SrpErQXLrS94jy30L17d+7du8f48eO5ffs21atXZ926dTaD8OR22lQOploRfxp8vgUNsHRAPeqVEnZl+y8/FDc2NVKeDTcbDcsEsLzCTsqcXmF0pwTWU24pb2b9G5agRcUgC2EpbvNnNLvlXDkqtoTdIF93XqlbzEowW7T7Mh+vOcMcfWfKaG4YF0d6a+JTNQtpVdhAr9Z1qVsq0HTTTyHwqWm1kh8MYet2w71/ec77NrXMH8yxj4RGG6BwTZv1maMKBIOSBQJ7jEwYwj38ScKF+e0rojvwsdB0JMZAl+8B+PvYLQwKVC3sy7h2Fa3avPeoN5xYSA3NeZRiyQUnxgqTkeINxYMkNZJDelcrVxqOYPQ44AhNggwMbFeXBqWFQObIGGwQkh9ChP/q3QbF6j/Qkv2XH/JliuNMef7+PlSK/qujOUFZtn3QFC83s9vfjQMAaIvWYUJJk2CWFmprJ7SviE6DeEm5vF30owPoDQpbzwmh9LX6xY3XpnrcF1wL4Z90gchbF6ByPcs/P7xsuR12zHJbUUxpwdWNyeGx4hoKLRso+hbw8PSCaPB3M9g8ByiK8PWeFG8t4JrjHSi+o+7Z3q/ar/sUsBCAbbHXUNEoaC/RtxZ9rNXA5o/g2C/Q5jOom/aC/DaVg3kjtCTf7LDsL/N7yi5DFX5LasImpRazetQ2+VZPiUFvO+DGzUMQdRt1RETGiT4u7O9p7GOAczU/ZOCG83T2K8zrKfv53jlY2Ba8C8C7Ihz39YdiQXrLCkHGcnRaF9rqvua/GHdWFyllfb4UxXiN4i3+Ex4t2lO5sJ9FexqWDmDuVnGfUhf62losDfaVJIrimHCdkofRiQT5ehjbY2zXI38u+Axn+aWmEGF6qZ5n6AyJYjZrVlJXKmqu0tblAFw8BCS7f72yQ7Tv2HOAbTexKpeVYI4ZSlFN+x8v6PbSoP04dPfPwp0TYu1DxY6mzNunCiHb3MxDNYNoOg78ilrfNzX/b+/Mw6Mqz/99nzmzZd8ISZAtLLIqsggiWKQu4Fprba0Vq/1abSnuVtS6UFSK2Kp1q7b6q9pq61aqxQVBRdxYFATFIGsAgYSEhOyZ/fz+OHPOzCQzyWRfeO7r4iJztnnnnTPnfM7zPu/nUeD037e4X2LiTNP/NwrcNOSUm/WHAZv++6z3hlyZZozINs8TT0I21EAf7QiqRSHMAVOnplj/P+h3X1qjWyOO6Zcace5MHZrF1H3r2GXN5x33cfx9+QEmWlbxA3sh1SSysqCKC4HammouCVacXXDe6Ni/rV5MmxKsS0pK2LZtGwAjRozotsVeonHNNddwzTXXdHUzOoVqt37BSU+0cfKwPuby8B9NUwzPTmTH6MYXvn86LsapqahKZDngaD+mqUOzYF8WO9LjO04sER2PMOuT4jD/vs53HWep67EF3UmauiHkJmpMyc/EZrVE7ZuGy6YOzWLDqT/n+y/k47YP5tPwlQeDvrEZ+XoFvDiYPTaPH0/sz6sb9kcsD4+w/8T6IX7NQubZdzJ7sBX+q1t4MeXX5rDcfwv0aOoPJ/SP2uZxA6az6athnKDspPjz/5J32m9g1yp46RLIOQ7mfqJHDL315o06glpdRA3Lz+fJMRNYuKyAosrIKDPQqEz0HWeNwL93g+6uEPze4j0HDVSLEvd305DzJw1l4fKplNd62FpUzcRBGfoKnwcObtL/7j+Z2X3y+NOPj+fmV7+K2L/h50qllhEpbq78wemh8/34n0SkGDTHl/uOUFHnJS3BFmpPGFXOY6BmB+7SXY13dlUACgyYrD8kGZ/B3Hm//sBnsek53EHKajwAZCTZzWXf9JnNq0XZjEqbRtSSY4oCl77a/AdqGNFuiCHAk7LNEbdr//0lXn/oUc0439cERgNwkrqVJ39yQqiP93wMAW+o0mYcHKzUxcI5x+Vy5pjcRteUgxV13P2/31Dr9vOzBId+7r/1WzjuR5B/qv4w++4dcOyZ5gOtid8X+rypepXF8tpgHyfaIzYdmKWnWe4ri1JBOVh6nYzB5qJ95XXB/SIfbnzJebjrasz3icBTGxp9SOwTbI/++TOTItszOT+TvDQnP675V0RhM0NEAxGvm8pvbo3YLqmOYqww83aGA58ENNbsLGHFx+s485QpwQDISZRUu7i+tIZr37+W9ZbfkGmpAfQJ9k0FUgzCr6dv+KcxzrKb6/tuInNsHryvWysy7PTQdTtasZXwnOOZd8D4S1v82VtMQrr+fyyh7UzV/wWpDd737aoFhzX0cOhNzIEa0KqLGx/D69KvGQDJeuCxJOhBnpPqbLT5jtI6hvt349YmUE4qV1vfBKDAP4AL1Q/YFchjQ+BYAIorXcx9YSNPzplw1IntVgntqqoq5s2bx0svvYTfrz8OqarKxRdfzBNPPEFaWlq7NlJoG4YwSG9w0Y+bsAtfc9HEWOK3vY4TjzDrmxK6IOgWVoEmrYoMUlsxQXnksGHsYReBKg8lVS76GhejA3qUhWMmtuh4lcFo4yUnDuCkoVmNIrR1K9/hktp/8sHXabBjO/g9+nvs+gBWLeLIlFvY/F0FqkXh3OP7RX2PRLuVXVmnckL5TtxfvwGn/SZY9hoYdLJe3e3VK2DQdPjFW40PUGtEy/owe0wep4/K4dg73yGgwV8uncCsMfqk4obfccDv4+29LeqOdkVRFCYMTOe9rSV8ue9ISNgWfw1+NyRk6rnHQIpTPxny0pzcdtbICGH2XkEx//vXX3jU9hj+3JOxj72s1W16/1tdoJ06Ihur2tgEypM6CGpACZbljmD2Yjh9oS6oHx2v55l7akHRf+dKUfBBoe8oveJckCN1ujjLChNdh9PH8Zo/mSvsg+Nuu7/B73jioAwKym2cAPiqS1ACWuPfcG1IaIP+cJmXtpV95fVcf9pwThqSZZ7vDy1PZs+hHNzZY5k9LCg0K77TS5QrKgw8Ka52urx+3t+qT37/5SlDGD8w8oFm6tAsWPU3MvqV8X+FM3nqw10k7/iaSZteQCv8EO2EyziyeyNZ7koqS/aRHGgwflNboqcaKKr5uYyHmczkyGvuoEz9c+wtq23cUGOEIjMfAJ8/wIEjekR7YGak0DYEc1mtm0YY0WyrE+xJwe2C7UlyRGyqWhQ9v7uZEUs1RuES43WsWgbNEX6tbohqUZiSn0nZ1sgAiJF378PKDb55PG9bgqLQZCAlPE3FvJ5WuXjyrVr83hfIPLIZynbplW4Bjv9xaOeAP3pFQ+N1o5BwkNLtkNQn7kCLQcPflXHdKfc6yQb27D/IgHFRflsNqAkK7WRnA5mXnAMlYKs9FGWnoPhWHZCg/04OVevnWHZK5LnjD2j8fNepXOQ9yM221+inlHGiZTs+zcIUdVuj88XwAV+4rIAzRuc22/7eRKuE9lVXXcWXX37Jm2++aZZcX7NmDddffz2/+tWveOmll9q1kULbqAjeWNMS2mZ1E280sbOOE4t4ozQGCpCb5mBoapSbXzMkOawM75vCtkPVbN5fyRmjDaEdHBJvgdAOBDTWFZYDcPHkgZwwIN1cZ/TNZ8m/56Fn67ip+P+Z68rUbLJWLWLfuBv5Q9lZQDHThmY1ujCGk3j8D+DDZzim4guoK4dtwcJEo84NbVQba/g/UizVe/1mhOj7I/vGjFbHuh91JtNyfBy/4xWGfaHAKc/pC4NpI/Q/0XSwML6HU0f05QcnHBNxjFlj83g1ayRqtQYHPtejQDYnfP7/oN94PR86WnpBFD7Yqgvt74+MPhqoZg2Bg5BQ813U9Vjtei5pcq5+kyzeAnl6qpJSbKSNjDM31zTNFF3h0VYj4uX2xSeYlm8pajSSYVEgRathsxOsniq+d/+7/O78cZHRKyPymxz6vEYg4LxxefrEVPRz58IT8zl16cNMtmfySvCmz55P9P/7nRARvWuKD7eVUufxc0x6QsRvKgKLyveLnuYO9QB13zmYVKS7In1RmcqJqxfznm8GF1uhvGgPs5d8wB1njQjtW1Wk/5+Sa37v0R5mAAalwnL7rQzwllBfu4uEpJTQSjOirQvtgxUufAENu9VCboNo4lmB1fzE9glJhT+CExrMLaoN5vAm9jHPZyPy3bA9EHvEsmGqRixaE8nWr7khEdkS1heWm+fdOGUXikJE/Ydo7YmVppK9YR3f7ctmsFKiu4dU7AN7Mhx7VnwT92bM10fE9q3VHwDH/TS0bulVULRJn7w44iwgtog2lu05XMe/1+9rNA8F4CZPPT+3whvrCnhpyweNR44/fUSPdp9wKWQNpdqlC+0kR+S1yJquB2Cc7ijX9+qg+E7JMc+dQ8G2NIxoG9/DY0Q+lMWqJgm62C6qdLG+sLzd7vc9gVYJ7TfffJN3332X6dOnm8tmzZrF008/zezZs9utcUL7YORktlVo9xTijdIY1lgAd5w1Ev/eDa16vx9l7CSn/FVs606E0ffoOZKtiGhvLa6ist5Lkl1lbL/oImLq0CxuTr6U8+s/Y5hFv8Fn7VuuW2itOxHQIxKb91eyfEtRzCG6k048iR0fHMNwywH2vDKfwfXleO3paMecRMHXGzgB8FaXYIkWlcz/np6TGBwmN4SSw2rBaYtPYHYVx+c6mWh9HW+lNSSQJ/2fnn4Rlmm+rlAXKycNiS4EBgwfR8mGdPoGKmD/el3svnWTHtW8dU+ECIwW+d2w9wjfFlWx7VA1FgVmHJsd9X0Sc4fC15DhPtD0B+t3AmxfrudkB4V2YOq1qMeeCY6QmKvz+PEExXR4GkGWv5iZli/pW10DHNf4+Ef26JOkEjNZfub7pvVcOAENKklirud6DmtpHHR5Gg8Ve4IpE8GHNJ8/QJXLSG2LFIEnBfPVN+2rwOX16+fWno/1lUHPZoOmBMzfPtLTbmaNyUFRokfRlmddRoF3GzeFTZ4GOBHd6eKNwDQutq4mVzlCcWU91760mV8cq3A2QPVBfeOU0G8t2sMMQHpaOhZLOUm4Kdz7LfmjTwytbBDR3luuP/gPyEjA0uA3ONL/LSepH7OmbHjjD9MgPxtCQrth6ggQc6RRP09P4tOdpbAqSupSK4mY19CKqKaRbhIrZxyii/9oaSoj+qWTtT/48LfzPQBK+59BxqePYV39B7aOvJYKYyJfrLbWl8PfZ4FigVHn63MY/F4o0e1fydYfyqI9nEZLs2uIsa7Kqo9qpFIXPQ1j4z91h5Ohp0HWUDN1JNkRed93ZA6gSMuk1J9CI1Lz9LxyNXSelAYj2n0bBG7C+/MJ/wXcaH0Ni6IXyosMZAXQUAivzhk1ZagX0yqhnZWVFTU9JC0tjYyMxnmGQtdSVW+kjhwdQhvii9KAHlVZcN5oThvRp9VpDcclVzFV/YyC4rCI+Jz/6GI77/jYOzZg7W49inpifmbUNAKAd78ppqjSxeXcxseOG7AEHQAazvyvqvc2mQ+Xsf5BvrOls9OrkVb4LijwRv3xzF+wklss/+YEG9jcR5h+/0ruPP+4yGOc+3DEsSp70IPcyJFjKdXSyFYqObxzPX1GfU+PCodNWK1yeSk4WAXAlPzoUZepQ/vw2eejuUD9DAo/hsqgEG4QaY0V+Q3PPrBaFNbuLov6PWX112/SGYEj+P1+VDX4IHN4J/zvWsgdq9sITr1Gf2A4ZlJoZ0cKDIrMuDYEl8NqIdEeeigaVv4Rc+x/ZMPhmcDFjT+wzw2+ejRvHQuXFTQx+VXhncCUsFcNhoqvel/Pf7botx7j3AFIb3D+DM5KJDfVSXFVPQVfbWDC+Il6XwPkh4R2vALmjU0HmZyf2aif/QFN399/IVZ8XGd73VxniDgHer8lKB5SqKWaZJbusTA/oGEzItqpoeOWB1NHspIbC9tDah6p/p1U7N8G4ULbSA8KRrT3BvO4B2Ul0RAtQc+9ttSXNVpnpnYlhubjlDUltINEG2mcOjSLyfmZ/GfjAdOJp6U0PN9z2zgprm+Ks1U549HSVLLOvovnN+7hct9rfOEfzn8DpzB6+x4u3f0H/dibpsKmZibypeTqE1hrS3T3pwEn6mlcfo9e5Cl9sGm127D/mhLYDSnWMikM5FBFYvQ0DFeFvmFw0qSZOtIgop1w7Aymvvk4qYqVyFkoQPpAmH5jxKJYEe3w/pynvh4U2eGVbH9IgeP/SFTcnOj6C6WkR933aKBVQvvOO+/kpptu4p///KdZ5KW4uJhbbrmFu+66q5m9hc7GzNHuAUKo3WgmSlNS7eLfYbngXm/8F7yG9BlxMmyBQe5taH4fimqF3OP0fy1g7W4jihpd3BmCAOBC9WNTZEcbMm0uH25HaR3H+7/hQf9FXGz9ENCrAs6zLGWubRkBTb9BuqsONzuBpbIHPcglOW18ZR9FtnctpQUf60K7AV/sKSegwaCsRHLTot8QpuRnsTgwhgvUz/DsWo29MjiBNczWL9bNtWGKr8evxezjvv2Hcor3cfb70/mk2sMx6Qn6irIdsO8z8AYf7sKEJ02cy+GRzfDorhK07LP4o+T8gjm5zos9QtA2R9ShYluCuf5I8NqU4rQ2erhUFIWpQzKZV/Azhi07CAn/gMp9ukgfoOdnt0TAlNdGibATmYrwkP8nzLO+gapoERZ3buxUaEmkK7XkKkeo0pKp8Ch8sfcI0y0WSBsYMTmzvC62sK1K6A81OyMnuPrculczmBFtcyJkg/xsACVJF9E2V3mjdQw/A37+Bth0ga5pGkdqYwv/5gi3SGzOYchYf+Ppw82J7NFcgNqSnzs5P5NvnBYecsWXM95UmsryLUUsqLmQw6ou0I+zFOJQfI1SH5qdyJd3vB4RL/5KF9rG/IicsfhRmnk4jY+GtqIRv60hmaFJksFJkyGhHSnzsoMit8rlw+X109QYZI3bR51Hz/nrmxoZ0Y4nRdP4zE7FDVrbUoZ6Mq0S2k8++SQ7d+5k4MCBDByo+4Pt27cPh8NBaWkpf/3rX81tN26MzyZL6Dgq6oM52q2dDNmDiRWlaU8GjxxPreYgSXGxf+dX9B/RvJ1fQwLBBwKILbQNQRDvkGmsfLiGk1gA6jQHY5VCrrf9lwe9F3GF9V2yqCZTqeSwlhYS7JpfP3KYlVVPimgDVPY5AYrW6rnZu1fDltf0qmojzwFgXXBk4aQY0WyAtEQbZdlToOJprAc3QLlux2akNBgPRS25uUZ7KFJVFVvGALTDtewtqw0JbSPNIMyhIpyMmh1YVvwOhp0GI0LpfLEEoGILlpkORHGxAF0IAl6l+WvIJOVbRln2sTFwLN9oevtiDRUb80caplgYTB3ah73f5DCMg/q8h9n3Q3UROJJb3MexHj7D26YXN9EaROb031SxlhkU2uVs1wYE93Xr1SJP/GXEe5kPNFE+V9QJrlpAL/BTsc9MqzEmTA7Kaiy0rSn6Nk7PkcYfNLlvRA58Vb0PX/DprqmIdlMYDjHNjc7Eila35zVXtSj0/+E9MYV/w/k3ED1NJTxw8Zj/Qq6xvo5D8UWdVNnsRL7c40JCG/QJ1gB5x0c8yHUEJdUu/UHYH/ztGhFtlzEZMvK6nOq04rRZcHkDlFS5yQt3ATj0jX4uZgwGR4oZzU5xWCPtUIkvRbNW08V5Ap42pwz1ZFoltC+44IJ2bobQkRyVEe1OxGazsc1+LGO9X1Oy9VP6l67Wh+1H/QCSo+feNqSgSM/PTnZYY+Znl1Q3FtnQ/JBpQ5ETbRKLHa8psh/zX8h56hqylGqylCrdjtkQ7HwF/7xAL9V+5QogdH6lJfSMB7mEwSdB0VP0rfxKvzlu/IeeWx0U2muDDzxTYuRnA7BqMXOSyth/pA/9OaznaVpsuhPG6gc4WFZNUWV8rhjQ9CShAZmJ7D5cy3fldTA0uLBBmgEAO9/Xbf5GXUB29TeoO5bqlRzDhXZNdKFtMYV2rIi2vtwQ5E1xiXUVP1I/Zon3p3zjHwwEh4oP74Tlt0LWcDjrfv1jBM+djBijIbNKn+VL9Iiav/gb1DMWmusOvLGQi2v38mdiT9RrSLR+Noaxm3uAXR8YSZGWSZ0Wiuw1zFs1MIV2lAhyaILrvtBCW0IjsR5KHWkstJ3pupBO8lc0+5kNZ5IUhzXC5q2lzB6bxxmjc6PON2ivaHVL2tIW4Q+RIxnXqktNkR1rUqVx7jy8cjvThvWJ+OyjlCEcC6FItiG4c4/r8HzkvinOUDRbseiTOYmdOqIoCo/bn2C4so2aXU/B+LBRvRV36g5WFzwJJ/zMtPbLTo1+njdl/Wv3W7icZQAk4G5zylBPplVCe8GCBe3dDqED6WkRx55IVebxcOhrtO/WQ8EqXeAMPDluoW2kjZw4OCNmfnbfFCeFrbDZapgPF37hjxXJWRmYyJeB4RzRUiL3swTzP8Mmy/S082vQ8dPxfWYhK1CG9s3reqSlv54rW+P2seWAftOaEmNkAQCLyowDT/NeYAJVtgxGB3ZA/0mw5glYtYiakde2qm3RbspnWjfwY9vr2L85BU68U18YxXOZNY/Drg+wJGaTXh9cH+Y4AiE3jIZCW7Xr54i1mYh2QmIieWnOJvN1SzU9opalVEYOFe/epD/YGDnNYe2JZT2amujgVFUXLdrez3TPatUKqx9g4OaH8Wvxi+xwwvt5cn4mv0v6H1f7m36AvdsXcvdQgDS7xqQo3uf+gGZG6qNFtJNyh8PXkNnEBFdN08JSRxrnaCdl6CmbqYEonspb/gPuahgyEzIGNSn6W0pnjBDGS1uFf2snVT6+aiePr9oZIeoHKx4+dAQfBv2+MKF9PH3r2icfeYhykEdtj+PGxo88CyN/W4f1eiY400y3kNoYqSMAx1jKGWQpYcPhfZErDG/tFP38MvooJ1ZOdROWvV/um8Shv39KqnKAP5w7jJFTv3/URbIN2lSwRugZ9KQc2p6KdeAkOPQiY8uWAx49PzJ7RKPtYjlQvP6lftNtKndtcn4mNyXNoTjGMGTDm0KsfLiGPuPRIjl/9P2UhvRNcUJJpLUfhFKTesr5NSi3D1uVQeRrB0io1G80/mNOhIDGC2v34g9o9Em2N7JUi2DGfNy+AKd/vJhvfAPBApXuAGmrFhE49Xd8pv4YNm1tcduiTRIaqpZwkrqWDYfD1hkR7cywiHbeCbDrA5SizaTX7Q0tCyOWG4Zq11NSrFosoa2fc4rqaLai4+Gg0O6j6CLQHCoO8183CKWORD93lFNv1d1zDj+L1VfL58ufI8ezn4GbH2bDkLk8VnBK1P2aI7yfVYvC94/N4qGvLuLxOHN+AS4cHKyi+cRJ+gjWxf+ElFwq672mAMuIkqqRNWgU3wYGsFvrR67Pj9Wq6mkxfq9+zUhIp6zWQ53Hj6LAgMyERsdIydSFUJpWg9/nQ7WG3co/exwOboSf/gsyBsU1EbKn0hbh39pJlQbhkfO9Wg41mpPkgItP13zMtNMX6ukj2SOZbLE1+3AaD34sjLXsoUZzNk7DMCLaznRz++oYriMA9Y4+4AVvRYOHPUNoJweFdjCi3TA/uyHRvodkp5V69HNuTLZNH244SmmV0M7IyIhqk6QoCk6nk2HDhnHFFVfwi1/8IsreQmcTKljTM4RQT6TfmGl416s4FP2mVpk5loSAwobCMlNUH6n1cO9bTQ91PvNxIfl9kqIOr7V0UhJEz4drnc94ULDvMcRSSGhX9aSI9qrF7Cyt45e+W8n2l/CG424qtCROfbKQq/hTcFLsRRyu8TB9SRSv2vBD5VzOt/6d3KC+ildTSTu0jieUi3n6o/FU1LVMZDc1SciRPRR2QKorOFkuEIAjQSEdHtEORq+V3R+Q4C1HQ0HJHRtxrCMx/JQNoW2LJbSdaXpZ+eyR5rD9b1/9yhyehtC5XKbpqU/HWGt48uKwyWNRPLSPxFFMa82AX3Jm6bNYFDjx85sBdDvLVojsWP087OI/MHpMEblR3Ev+ycURkyv7p6rcevZY3Q7UXQ2lwe86OGRvVGFMdVqxRRmd6tsvn+8F/ojHF+DjKjcDMhN1z+bt78A5D8GJV5ppI3mpzqjpHul98pjqeoxyUvjU5adPctit3LD3M6tCxvbQPppp6aTKptCwMN97NaVaOqUf1fP+bVeY110Vmn04bQrjvl1Vp6cQJSsujkm1RbpB9TsBrg0+rAWpieGjDeAxq0OGFa3xufUUODAj2rEcR+IhwaZSSVCge6NUQj2KaJXQvvvuu1m0aBFnnXUWkydPBmD9+vUsX76cefPmUVhYyNy5c/H5fFx11VXt2mCh5YQK1siFtkNYtZi6klqO8/w/7lBf4DLre7x0oA9L7nqHeZalqEqA62MUfGjoQBHLGcGgPXIT4/UZf9p/Dk68VJIcFpU0ItrhUcme8yC3o7SO4QWP8iPtIqos+pD8l4FhXOZ7hXm213gwLBWhKaeBkNvFD5lr+a85KvBH1w+AljnYNDdJKP0Y3Su5ry+YclF/RH/QqS2B1P6hDQ2hXRWMUmUNjfDQhrCIdgPRFcgYwl3eK1ASs7gnWiPzT4lwNpk9No+N+yr420e7mXFsNr+eMZSJgzL447vf8u2n+rD5pGwfSni/1QSFdlJ4sZqmJ0Mu31LE82v2UmS5kb/ZdVvJaHaW8dBcP0dLRTAE+Zz/tw6t8GOecz6MI2sYvjHv63agRgTQkQoOQ2jr33+sCLLFojAgI4FdpbXsLavThbaRCmQ6jugTIRuWXjewWq3UJ+birvNSXuuhT3JYxNEoWJMUKbR7Y0S7LbRkUmU8vB0Izsmo0hrNtTCu27f952uzrgVEt6HMTXVwyeSBpmuLcQ6eev8Kgi6TrL5uImpyWATZ6jCr2hoYqSMpDStDAlpyLpSAtS6sDLvxIBxWFbIkhod2PCTYVDYFhlKPkxmJmRy98exWCu1PPvmE++67j1//+tcRy//617+yYsUK/vOf/3D88cfz6KOPitDuYvwBLawgRPcXQj2RHaV1HLv1Ma6yXMQ4i27ZtTkwlHmW0LBkvMRTprY9JiU15zM+zrKLb22/4EPLFFwXPh8WlWw8/N9TcrQbuq1sDejOEXa8jYaPIfZ3Ee52Ec8kqoa01Fc4Z9BIANKopbK8lLTMbLjpG70inRq8hK9arE+EcqaZw8ha7vH6zS2swl2siLYlNZd/+s8kG0d0oR0Fr1+P9o3pl2qKisn5WXzyiZ46ojSsLBrl3DlSG/shLdwVYoSiV8aMt5+jCpg4JmPFqlo7tl8qn+1OxBmojcgxV6qNqpBhHtrBiHZTwnZgZiK7Smv47nAFDM2M7aEdJT/bIDPJTkWdVy/3nhNc6K0PWT4G+9ksB5/UcrHU24k3cNESZlg249lngUHf1wVw2HttLarmkfd3MCU/kxtOP7ZRZcimrt190pOpOeQkWXGheiqBplNkmkodsabp56vTFfqNKmbaSOOqkH1bEdF22lUW+y4FYPuA6RzNj3mtEtrvvvsuS5YsabT8tNNO4+ab9aG9s88+m9tuu61trRPaTLUrdKPp7kKoJ9JQvPk1/QI1XtnJVba3Y5aibYp4ytS2eVJSEz7jv3mxLzu2vcnp6pfMOEaJjErWRsnRrusZQjtWyeBpakGLSga31GYxnLvOGcVlUwe36KEoMTmNw6TThwpK9n2rC23QC+0YWFRYtUj3cg4T2qx+QF8+8w4gFN1sGNE2S7B7/THb0RCXNxCxL0CfZDuHg6kj1JXpAt8oRx81dSR2fn9r+/muc0ZxxbR88xjt4YiRk+qkWAtOfKwtDQ3RG0I7rFhNKCc6trC91PsfHnM8x5bNP4Ixd+o58IqqV1wF9gWFdqyINsAlygoybV+h7dVg6LnBtgUfZiw2PcpOSPhL6kh0mgpcfLqzlMfjqIp5g/U1FE1jn5bDg/anYDUw5B0YdHLEg+6eoGXjqSP6Rlyv47l2pzptVJFIMq5QTrbBjvd0X/2BJ8Pw04GmU0ecGccAkOI9HFpYY5RfzzUXxaoKGQ8JYVWC671+7Nbok/yPBloltDMzM1m2bBk33hhZQWjZsmVkZupPaLW1taSkRCnxKXQqhghKsqtR8wWFthEu3vKUcn5m/QCg1SI7nM4oUxtNsI/pl8aab/XfbqOo5IApejpC+kBzUU+JaDd0W7nO+l9sij+qb25T+7bWZhGgT4oDu9XSYqeGw7Z+9PFWUHVwJ5wQJTd5xnz9/1WLADiQPpncuiOw5hFdZAfXGz7aDUWXAy9TlK0k+v3ArMbHX/MX+PhBGPdTmKW/hyHKnbbQdaVPsoNyUrnWfyOPXnlG5HCxt17/PyJ1xLD3aywCW9vPfVIcpqBuL0eM3DQn5aTgw4oVnylKQhHtfua2R0yhHfv3kJycQrLiwl69L+SJnj7AHKHYWx7b2s9gkn8z49VPWFd6ChAU2nVhowbBqGRvngzZXrS1KqZfs5jno0nO2EYPurtLdaE9JDv2SEUsUhNsVGlJ9FPKob4icmXhh/DZYzDVbQrtWk/s1JGUvgM4qGVSFEjnmOAyLXsEnL4wYsSpLTnaNtWCalHwBzRcXn+3vz90JK0S2nfddRdz585l1apVZo72559/zttvv81TTz0FwMqVK5kxY0b7tVRoFRWm44hcZDuCcAH2O9+V/ET9EKsSiEu8NUdXlanNSrZTRjAqWXs4cmVQZIVT2UPOsYZuK4bIjicVIXzf1tosNjxOS6hO7I+nYhs1Rw7BO7fqjgbTbzJvqoAupusrYO0T5FZuRF2zPkJk+/yBkLBtILqcgWpedtwLgBa4BcXS4KHcXaWLuLBJTW6fEdGOFNp+VJZ5T+QPuZNJsYRF037xNnhdeopLkCNN5Gi3l51le5Cb6kTDQqmSQZ5WGhLYrYxoO3OGwXZIc+0Ps2oMOcjEkzricWRCLQTCf6N1wfzssPLr7Wnvd7QR7wT0x/wXogA3hYvtdU+FRPaM+Wiaxu7SGgCGtkZoO618p2WT44RGppJRXEfMgjVRUkcyBh7HOPfjAHxtjGJlDYfc0aH93T5qjaqQrYhoA9xqe4VLeRvvR3Ph3IXN79BLaVWI86qrrmL16tUkJSWxdOlSli5dSmJiIqtXr+bKK68E4Oabb+bll19u18YKLSc0EfLofZrsSCLF239NkW2It9agAHldWKY2K8lhWrThrtRzgWPg9QdM54nuXhDJcFu5LixKOsL9Dx70XsTNtteifl/RvovJ+Zm8nDSnkRWcwWP+C/lzg8mvbf1O1438HSPdz7M84Wy9ouXeT8FX33jD2X9AU+2omg9NtYci3YQeuhWl8Xdld4Zu/F5PlKI1QXs/rKHz3WVGtENiOsGukmTXXx+uiXLe2JxmyoumaU1OpG1pP3fk78aI6B0MBCWOIbAdycHy66ERnnhcPjKOORaAXF8RWnnkRMhat4/DNfp30FTqSCBBj8Ba6sKEdr8Jevn12X8wFxk52pI60jqMPO7ctMgHuIZZSK8m/wy/Jew8DhPZAIeq3NR6/KgWJao3enOkJti4yvtbHh3zMgydGbnSFNpp5iIjRzta6khqgtV8QC6tiV6kqiQYzU52WEmK4sUdD1aLQpLixu+ubtX+vYVW+2hPmzaNadOmtWdbhA6gpwzr91RaapXXHN2hTG1Wsp0qEvFjQSWgRzJT++l5hgF/RG5wVdgM+tRufo7F67ZivI71XbTEZrGp47SEfjnZBDioRzqbKr+++gEUvwe/YkX1e/ShayNtpDb00N2wKJLDEfJqdrvrsTsbeDcbD1thk7uMiHa40AY9dWNM+QYsn++A8afp5amjUOfx4wlOqIzmN91edpbtgeEjXBTIANVIGRlAYOZdqGdGTh+NlQcfTs6gEQQ0hSTFRVXOZFLP/hNk65NejUI16Ym2Jq/bSnCI3+oqDy1MzIQhp5ovNU0T15F2IFYe92e7DnPFs58DsPQ3J6NW/A+ePUvfqcGDrhHNHpiZ2Kp8ZeNcqKr3NV5pCO2EdAA8vgCe4O8zJUpEW1EU+qY6+K683vTKVg5uBLsTsoaBPalNjiMGfqsTvBDwiL1fq/D7/bz++uts3ap7iI4ZM4bzzz8fVW19iVeh/ZFiNR1LS8VbQ1rqQNEZZCXZ0bBQTirZVOiTv1L76ekKf5sBfUbANeuBUJQ0xWntEVW/mioZ7NRUVCU+l4pYbgWtdbtojoGZemSzrKwUDGHVUGgH80H937uNN6tHc25KAWowZ5sZ85sUXHZ7KFrncdVBWoOosBHRVkM3XSOi7WggGvokO5hT9R6D1q2BNKsutMsL4a2b9ajtOQ8CobQRm6qYUfCGtIedZXvgsKpkJtnZ5BrGqflJOFPy4HD0beOJaDsTkjikZJJDGQddVlInh9y5QmkjsaPZANYUfVKsw3Mk5jY1bp/5MJMlriNtIloe96kj+jI0O4ldpbV8W1xNXvEnwY3t0OBBd9fhYH52n5ZHs0GfDAmhe3oEDSLatWH+9tEi2gB3aM8w2r6e4u13Ahmob90AJQUwZykMOy3McaT1501A1YW25oky+nYU0SqhvXPnTs4++2wOHDjAiBF69bvFixczYMAA3nrrLYYOHdrMEYTOoid5HPdUmrPKM/JI89Kc3HXOKDKSHK225esMsoKevG/5JvPzSX2xBAtxmPnaPbj8elMlg+EM1heW80ic30VTvsvt5XZhMDAVHrU9xqz6z/XwbWKfSI/ssElXgZNvhLffJnDKb/XAR1BsH8m8DIheFtyiWnBrNhyKF687yk0xWII9noh2VpI9lHpkTKat3A+73oeKYeZ2FWHFaqIVQDNoDzvL9iAn1ckztecwbdqJTB+SAYVvR90u3gjyYXs/cjxl1BzcAZxmLg95aDctyBxp+qTSZF+Y0N7+LlQdDBYXOtZsS4JNJSHGw4zQNsb0S2NXaS2Jax6EPU+F0kWM3yTAjPlmRLs1EyFBT/f4sfohc797H1ZdBDN/F1ppTI4MCm0jnc9pszQavTLIVmsYaCnlwJHvIDmjcfl1oypkG+Y8BNTgyJgUrGk51113HUOHDmXt2rWmy0hZWRlz5szhuuuu46233mrXRgqtJ2S9JsOGHUYTVnkb9p5ESbWLfzchBtrLGaG9SE+wYVHg974rOPv7p4U8VMMdDYJU9tAHuVh+yS39LtrrOM2RnZ7O6ZaNOJRgpCq89DoE7cOCN3hvWMTLGLoO+GMWqzFwY8OBF687yk2xiRztRhHtFEdjoW3aQja29otVfj2cNttZtgO5qQ62FsGh4MO003sE62PjdEvFX7wNitKiVI2DaROpKA6Qsf8j2D8J+k8C4o9oJ6br5tkpgTCrtw3Pwba34dyHIftYcRzpBEb3S2XQlseZsue1iJzshk5Au0tPBWBIdnKr3ifVaSONWob4dkH57siVDSLaNU14aBt4E/qa1SEtiV4UsyqkPipkTPTPaUtE22oIbYlot5jVq1dHiGyArKws7r//fsnb7mZU1Mf2qRXal+4gBtoDi0UhM8nO4RoPh2s8IaEdxUO7x0W0eyiKxcIhNZf8QJTS6wAzb4+9c/CGf+T9HUDslAaPYgfq8Hmi2EqmD9QrT6bkmItM15GGOdrJDooICm2jGmSUiqLxlF/vThiT4YqrXOCtw+kpD1XhDEbk6zx+s1+aE7ffjrqGFfuXs6zkTjwvrEOdvxOAr/ZXAPpEY39AixmpT+o/lpNcj1FpSeObgIbFooRGnYzy68ZESHEc6TDG9EtlgxLg/9ku4cqwnGwg4kF39+FgRLu1qSMJNioJ7tvQR/uq9/WKsUHnmpDQjj2KoSXnQCnY6g7h8AWPp9rNqpCH2iGirdl0oa2I0G45DoeD6urGs0hramqw2+UH3Z2oEiEktIKsJAeHa9wcqSiHjIA+ySZq+fXgg5yMmHQ4FY5+UK8L7e+UXHJ8gRalTzQX0X7O+hNq6+u5yBbl4fD0Bfq/MGLnaNvZYhStMYrUGII7rFhNRQsi2t2BnFQneZTx68+uwro2QMKAYF51RFVI/TM5rBYSY6VqrFrMjtI6/t/WU5im6P3yVV0mv7xvJVdpr3Ga18vXXMRfP9rN/zYfjJl7npGaRDFZENAfeDOS7I1GnWQiZMczOi+Vy3wXQTX8xOUlxdngfJ4xH5fXz/4Vy4G2RLStVGnBUY6GQjtzSMRLU2hH8dA2sKbp3u9O92Gc3gp9YXKu+dBoRLTbkqPtcvRhfWAEqcnDyG5+815Lq+z9zj33XK6++mrWrVuHpmlomsbatWv59a9/zfnnn9/ebRTagJkHKUJbaAGZSXbmqsuY9so4WKEXW4hefl2/oHd3x5EezarF7HjlLr6q00cQn/adzSnrT2LkXe/w2d/nU/janVzy9FqmL/mA5VuKYh7mSIxiNQZvO8/hWf9Z1Nris8eLZu8HekTbTB2paSJ1pDZ2sZruSG6qXrTGGahF8dWT4gpGs1MbC+3MpNh55ztK6xhe8CiXeV5mkKIXvtmr9eUy98vM017Gr4Vuy8WVLua+sDHq9+qwqqQEbdeMhyhqI320JXWk48lKdpAbHPX7tji6jd3esjo0TZ803qeVowtpCTaqghFtraHQbkDIQzu20HZm6kI72RsmtMNGrNojR/tg6gn8xLOAj4bNb37jXkyrhPajjz7K0KFDmTp1Kk6nE6fTycknn8ywYcP485//3M5NFNqC4QqR1kOiRkL3ICvZzhEaTIJsMCwNkprUGRjCrH9AF3a6OFOYZ9EtJA1hZoiyd785FPU4pu1cDGFrWI65ffGVYQ9NhmzsOhKRo61pIaGdHIprhcqv9wwRmJPmxI2dKkWfhJpeG8yTjRLRjiVs/QGNn+861fRun2/Ta00MoKRRBUwIWRouXFaAP9DY4HCe/U0etP2F+v1f6xaM7qAAMyPaUn69MxjTTx/B+eZAdAEcmgiZ3OTE36ZIceqVIQG08MqQVQfh/Xtg/dPmolDqSGyhnZI9AICMQHmY0A6VXzfs/dqSo+0MjurUe6IX8DpaaFXqSHp6Om+88QY7d+407f1GjRrFsGHDmtlT6GxCEW250Arx0yfZwUEt6GphiKR+4yHghayQq5DkaHcshjC7yHvQtIocoJRELU2uoRuSLHrnW+aPanys5ioEDuEASUoRgZoh0HCg94UfweEdcMGTMHgamqaFVYZsGNG2U0o6N2g38+crztSFtuE6kNRzU0eMqOUhLYNUqsmoayy0m4sgry8sp6jSxWNE2n9OVrdHrYAJ+vdaVOlifWF5Y3s57XNGqlv5snQ71A3WFyqqWSEwniqVQtsZ0y+V978t4ZuDVVHX7zIqQrYyPxv0B2G3NXhNDo9oH9kDHz+op48EbSJr4xDaGTkDOaBlUaJlUJYwFP/3F6D2GWrub4j1vq0ov26QEBztqvfG9/DeW4lbaN90001Nrl+1apX590MPPdT6FgnthqZpVErEUWgFmUl2vjKjksFIdpQJd5WSmtShhAuzLKWKK6wrGGX5jlGW76IKM12UudlV1ThqZgrtGBHka2qfYLTjazYWZwANlHrlfqjYC5p+wzRENjSOaGclO/Bi5XX3RO7POxGnxaJXK/S5CZWWCU2G7EmpIwAH/ekMV/fhNCaQpfYztznSjNA28l5B99a/0fofLIqGR1ObLWwVvq9BvT0dfOCpKg3lZydmgkX/TuLx9BbazuhgRLugKLrQ3l0a9NBupbWfiTOVMk8KyYlZOPw+UK1Ry69Xu5rP0U7NyOZE/xN4fAHutvoITD0b1aZfx41odpJdbVKsN0ffQCnrHb/BudEKZ+1q9XF6OnH34JdffhnXdq0dFhHan3qvH69fH26UiKPQErKS7ZRhTGiLUZkDiWh3NOHi6ve+K5ijvodVCeDWrE0Ks6oGNS3isZ3zqXa9ips3iutIA3s/tzcktBtGtFOdVuyqBY8/wOEaN/0zghO4rJFRVXMibQ8JAqQn2rBbLRRroRx2LW0gSlp/83VzEe3wfNdr1aVBkW3Frvi4Vl3a5HcaLVfW68iEOgjUlOpOND//n14oJYhMhuwcxvTTgxLbD1Xj8QUaVX40i9W0ciKkgZKQwcTqv/Kv86dwshqUb1HKr9eY5ddjSzxFUeib4mD/kfpG14tQsZrWR7MB7HY7fZUKAl6LPrJ1lOrDuIV2eMRa6BkYaSM2VYk9A14QopCV5KDccI7w1oKnFiy2iPLrIHMAOpqGwswQ2Y5mhFlqg68jHtu5gEVfHl1oR5ZgN/K4LYp+fQlHURT6JNsZVL0B1m2H8bMgZ3SjQxrnTlOlyrsTiqKQm+qkuEq3Pyvs8336/+oVbLZQZzeXEz05P5O8NCc/rvkXN4Wl/hipQNC4iqyCbi1oFEMKx+/UU0mUujK9gNGQGRHry2qaThcS2of+GQmkOK1Uu3zsKKk2hTfoD7ltLVZjYEw6r3KFKeMoQttIHUlpJhqdk+pk/5F60qq2QdExkDcWbM52Kb8OoDr1z2shoD8AWo/OFKbWjwkI3Z7wYjUy0iC0hKxkO9Uk4MGKHR8c2AjPnwvJOfDb7eZ2EtHuWFoqzHRR5mBoam3EceKxnTOEthZHRNvlDeVnR7u2ZCU7uKxuJf3Xrgf1CBR/rXtxn/eIuc2R2p6Vow16+khBxSCK+55Ctb1/o/XltU0/PKgWhX8M/ZDhBa/xUFjqj/F/w+/U6NkF542Oat2oBCc9Wl3lUd9PUkc6B0VRGJ2XyrrCcgoOVkUI7cM1HqpdPhQFBjdT7bM5jOtsVX2oxHo0oV0dR442wC89L/CwfQUDS0rh74vg159C7lhK2imibXOEfV5vnQhtofchjhBCa9FvzApvadP54YQBejEE0KPaQTRNC6sMKTfyjqClwgzgjrNG4t+7IeI48djO+VX9Jqj5ogntyBLsLp9h7RfduKpPsp2yQ8ERkYOboHC1LrSNw/kDVAXzSHvSuZOT5mRZYDITRs8ht7KgYSZ7XC4fw7MT2TH6Ol7ddSpUhvr6n46LcWoqqhKKVuamOWP6aAOoQRcXh6ccCj+Gsh1wzCTIO556j9+chCapIx3PmH5prCss55uDVfw4bLkRze6fkdDICrOlpDqtLLY+zfdXF0Hfh2HQySGhnZBubmfY+zWVOgKQaXUz0FIaWmBWhQw6jrQxou1wOPBqKjbFr1eHDBbDOdoQod2LkWI1QmvJStYvsDe6r+ass2fj3L1SXxHmoe3yBvD49cimnGMdRyxh9kTgQvCCqhjfgZUlPzqe00b04e29kccor2s+VzdgCQptr7vxyhg52g3zsw0iLP5KCvT/wxxHjJEQ6FkTaXODVmfOA2s4c88CVM/r8ONnzfXl8bh8zLyd4cAnAY31heURBYfgDNYXlvNInEWI7Gl6nyb6KmDLa3oJ9hm3Qd7xlAVFv121tGlCmxAfhsXf2t1lvLHpAH1TnEwclMF7W3W7zcxEe5OVPuMhNcHGEEsRfWq+hepifaGrQv8/WupIE5MhAQLJuRDU2ZrFhpKopyeFcrTbJrQTbCou7NioP6rLsMuvrxcjxWqE1pLqtGJTFbx+fRJdvyjl140RE6tFIUnmAHQcMYTZxEEZbNh7Es9+WggFhzhzdC6zx+bh9XobHcIoxd1kZFMNrvM3ENoBP/QdpUe1jdSR5iLaKQ4OE+alDRFVIQ3HkRSnFavaqnIOnc+qxcwqq+RpToHKAyR4ywkYn231AxDwU147AYDMpOavuapFaWTXB0RdFgtL/jSmvPs4tpQ+fFL7gr4wSlVISR3seAxf+G+Lq7n+pU2APofBsD/fvL+S6Us+aHKEojlSw7y0zUj2zDth0v/pVR2DhHy0mz4PrWlh7UjOCVWFrDI8tNuWOuK060I7RYS20FuRiWpCa1EUhcwkO4eqXBw5coR+Rwr1FRFVIUMjJnIj73iiCbOpQ7OorPeyouBQTGsxCImApoR2YeZ0Pi6ykJs8kanhKywqzP00Ylsjoh1rKDwryc5uYzKtQdi5E/LQ7kEpDRaVSbuf5Fq1lMtLXgstX/0ArFqEf8bvzHSYzvKtzkhL4xCZ2Oo0tLoyPac7UT9HpCpk57F8SxGL3traaHnDGkNGUakn50xoldhOTbBSiSG0K4IL8yKqk0LI3i/J0XQAxJ4esqastmWRFGzwnjJ9jkdptbtNUfgEm8rXgXxybPWMsRy9crOHhBKE1iDFaoS2kJXk4Dbrvxnz/Ci9IAI0EEvyINcdGHuMLmi3H6qOWdWxrJmqkAAH+kzjcf8P2ZFwQrPvaZRfd1ij30KyU8JSRwySGke0e9JESGbM58D4G828eAAq9sGqRTDzDsomXg/oUczOSqXKCgp6r18jYNhwGhHt4ChGljiOdCj+gMbCZQU0rtvZmOYqfTaHHtEO2mU2UYa91tNM6siqxex45S7+8PERc9FnJXYm3reSp+79FRcHR0fue2sr05d8wPItRS1uK+hC+/+887nafj/0HdmqY/QGRGj3YqRYjdAWspLtVGgNfF8To0e0ha7jmPQE0hNteP0aOw7VRN2muUIqEBLN4cVoYmFWhYwR0e6THJY6YhCROtKzyq8bBE6Zz4Pei8zXloq9MPMOmDHfzINPT7S3KQ+3JSTYVW6zv8pDtr+glu3QFwbTu8RDu3MwikrFS3ilz5aSlmCjigZC+9NH9X81ehqTpmnNTobcUVrH8IJH+Z7rQ3NZhZbEZe6Xmae9jF8LSUMjCt8asZ1gl8qQIEK7VyNCSGgLWUlhRWsAhp0O2SPMl1IVsnugKApjg3ZiXx+IHuWKR3SlaNWMUvaSXPdd5IqKffDoBHjmdHNRcxHtrGQ7xVomN1tuCU3SCs/v72Hl1w36pjp4zH8hvqAQ0Sw2mDEfiDMPvgM4X/2UC9VPQguCD8NlprXf0Wmp1llEq9jZUfulJkTJ0f74QVh5F9Trwt3tC+ALRsujTYL1BzR+vutUHvRexDzb/8zlKdRzc5iFqEFbovBmCXaPCG2hl2KmjvSwm5nQPchKdlBm5NnmnQBz/gMjzjLXy4Nc92FMMH1kSxuE9ojSFbzjuJ2zDz0VucJTC+W7oLzQXGREtGPlaPdJduDGztL68fhu2QN3lsLIc831R3qoLaTDqjI/4Q2sSgC/YkUJePUcbbouJ7pGTQ97pegl2AmzGpTUkQ4lWsXOjtov1WmjXEvhCKlgTYBAANzBuRnBB1pjIiRAkr2x0DYi8I/5LzRHZ9yalXOs6xqJbIPWRuGdNpXF1qf5wDIX7atXW7Rvb0KEdi8mVLBGhJDQcjKT7CGhHaUMe8inXW7kXY0R0d5yMPqEyHjs/Sw2/cavhpXwBsKs/UKR0eYi2hmJdiyKXnW5vNajVxQNqyraIydDAqx+gN9oL/Og9yIeGPQs/u/dpudor34gNOG0kz9TvS0dgD3HnAsX/1OfvIqkjnQWRlGpeJOFFCAvRqXP5khNsPJ6YDrTAk/DBU+Apxq0YKqXMx0I89C2q1iipDCFR9If819oVpp1a9aYlWaj7RsPCXaVVKWWPKUcX+2R5nfopYjQ7sUYEUcRQkJr6JMcljpSfVBXTWEY51eqPMh1OccdowvtrUVVeP2Nc6zjEV0Wmy6k1UADe78GxWog3N4vekRbtShkJjmYZvka/9onoXRbxPojZgXFHnTuBN1FlqZdzmP+C6n0QOCU3+o52qsWMWzrX4DOL3fuseuCrcg+GEadZy4X15HOQbUoLDhvNECzYru5Sp/NkerUfy91Hr/+OzfSR1QHBB+UTWu/GBMhwyPp16pLTZHtUHxcqy5t8v1bGoV3Wi24CE7YddU2s3XvRYR2L8aIGkkOrdAaMpPCUke0ANyTCWHlucWnvfswMDORFIcVjy/A7tLIG5rPHzAfiuKKaAdiRbRDN9mQvV+MW8iqxVxnXcot1pfJ++z38MTk0LrVD3Daof8H9LAgQMAPM+/g80G/BKDC6KYZ82HmHbjceh93drlzf4Ju56fUlUUsl/LrncfssXk8OWcCuWmRQrShls5Nc7ba2g8iXUSqXb6o5ddrmim/bkTgr1OXmjnZI9z/4EHvRdxsey2q2G5tFN6qWvAEhbbPffQK7aPX2LCX4/UHqA1OQJDUEaE1ZCXbqcfJdiWfY7VCXWzbQjcSydHuPlgsCqP7pbKusJwtB6tICFtXUe81ByOaeiiy2PW9VK1BwRtfUFFGiWjHqgyJReXnrhcpaeg8EowK1zkuBXrYZMiZtwOQ8952ACo9YSpqxnz+c2AjUNT56TBB3+yTDv0bvrsSBpwIdN3kzKOV2WPzOGN0bpSiUkciqn+2xZHGqlro76jjgcBDJP3jj3DWffqKcKHtalpoqxaFfwz9kOEFr/FQWE628b9hX2m8bmsU3qvq1w2/p67F+/YWRGj3UsJLHMvQvtBiVi1miMsPjGeB7wr+rS6A9EH6umAVvMr6UwCZbNtdGHtMGusKy/mmqJpJYfdDw9ovPdHWZBVGNfgQZYsV0VZDQrvZiPaM+bz9dRFnH/57aFlQZDPzDp74ZALg7nk52kBusFpeZYNu6irfaktKyM2FTS/CgBNx+/xUByOb4jrSecQqKtWeOB1OTvYUwCGgRi/vTkK6ud7w0I6VOgIwPDuRHaOv49Vdp0KYNeE/HRfj1FRUJaQfctOcbapm6bM4IQABiWgLvQ1jWD/Vae00T1ehF2FRSV93P9eqF7HNPwBUdHu2MLEkEe3uhVG4puBgFZOOCS03c3WbEbVqMKJt1RooSKsDMgZDaqiKnLu5iDawYfBVHFuynGGWg/qC4Hmjfe8WKlYsB3rmQ1pOmiG0I6+rXTX5sCb/bJZv/B+z1c/Z70kiL6BxuFpvi0WBgqJKJudnyX2gl2BLSMHvVlAVDXKPh6s+ACX0O6xuJqINwMzbGQ58EtBYs7OEFR+v48xTpjB1WF/gDNYXlvNIO0Xh/aoutDWJaAu9jUpxhBDawoz5aJrGzR/+gZX+Cfqy2lJTLDFjPhUfrgB6pljqjRgTIrccrOILu0JWYTmTh2Szbreeu2tVlabLKaf15y++8/E5s7gufPmxs/R/YTQb0Ua3+LvMczufOq/DggaqHWbMp87twxOcsNkTI9rZyXqE+LAL1hWWB8UJFFfpkcHvyuvaVLY6blYtZkdpHbds+x4Lg9OtntlYxevfrOSXgVe5werjz76LuOTpdeS1MSopdB9SEhxUVySSTq0+Qf2YiRHrjRztWMVqwlEtClPyMynbqjElTFC3ZxS+ytqHre4BJDmym9+4lyKTIXspEm0U2opy6q08bb2EM9SN+oKwKniBgEaVS1xHuhPbi/WqkG5fgH/uVJnz9y8Yedc7PPyeXjFw+6GaJsspWzIG8IDvp/yDc5p9r2ZztNFday5SV4dEtt8TYYNnVy0k2mPv3x1ZvqWIK5/7HAB3QGHO379g4n0rmXjfSvOa+7v/bmlT2ep4Mar7/cz1EllUA1CupXKZ+2Wu4ZV2q+4ndC9SE6xNlmGvDQrtlDiEdmfwScoszvIsYdvo67u6KV2GCO1eihSrEdqD/6XNwa8FI3OKxayCV+3ymRPs5GGu61m+pYh5/9rYaHnDQm5NCS5DNBvR6qZwxRHRnrj3aW62vcY/nZfCXaWmDZ7tkz8B+rVJUXpOOsPyLUXMfWEjh6oj7Q8r6rzm9dago4VteHW/m22vMVUtAOD7lo3tXt1P6F6kJtioIlgd8utX9PLrBzaY683UkSZytDsTp1XKsIvQ7qVIsRqhPfiF7xVURSOgWHXXkWAVPCN6l2BTm4xqCh2PP6CxcFkB8cinpgSXw6IxUDlEf9++yJ02PAdPnaKXeg7ibsZHm9UPMOTrRyIFX9AGL2fDg1yrLu1RaSMt6WPoeGEbrbofwAXWz9q9up/QvUh12kIR7Q3P6eXXCz8217ckdaQzSAiOWrmO4jLsIrR7KRX1EtEW2sjqB7iw8nke9F7EX2esNyOSrH4grCqknF9djSG64iWW4HL4KvnIcSPv2H5LwB92U6w6CMVf6f8HMSLasSpDEvBTPXU+j/kvpLzWQ8AQmzPm8+2oa1GVQI86d1rax9CxwrZhdT8jTaQjqvsJ3YvUBBvlpFKrpuvpWBBh79fdUkdG+7byvv1mTl43t6ub0mWI0O6lVJrFanpO1EjoRgTdRVYfczWP+S+krMZtRiRZtYjU9Q8DMmLSHWitcGq4n90Rct/2uOtDK6IVrDFytGNFtGfejuM03XfaF9Ai7EbXD/wlf/Zd1KMi2m0Rpx0hbBtW91OVQIdV9xO6F6lOK9d4r+N3w1+HQdP1hdEK1nST1JEEVWOopYikuu+6uildRvf4JoR2RyZDCm0iWAXvW34Eu741LeKMHG13UQUg51d3oLXCqeF+DmeS+bfb7cKZmKy/iFaCvbmINmC3Wkh1Wqly+Thc4yYjaHvXE8uvt0WcdoSwNar7/bjmX9wUlpN9bbDaH9Aosq2geyK3tLqf0L0wJp9X1nujVoY0crST7N1D3ikOPc1F9R+9Iynd45sQ2h0jdSStBw3PCt2IYBW8rA37gZAXMwAz5vP52r2waYsI7W6AIbqKK11x5RDHElw2mw2/pvvzet1hnrdNRLRj5mgHyUq2U+Xy8camA0wbls3EQRkUFOnioNbt7xwbvHagpX0MHStsO7u6n9B9SHXq19yqei+4DaGdbq6v7WYRbdWuC22rCG2ht2G6jogQEtpAVjAKWVYT6bRQKXMAug2qRWHBeaOZ+8JGFGhSCDYluBSLBQ82EvDgcYWnjrQuor18SxEHjujHeXzVLh5ftQuLEnJC+d/mg3y+p7xH+Du3pI+hc4RtZ1b3E7oPaQk2TrV8yfVly8EfnLgcLXWkm+Rom0I7IEJb6KH4AxrrC8spCaviBLq9FMCBivoeEzUSuh9GOemymshqgZKa1L2YPTaPJ+dMYOGygohJe+HCFpoXXB5FF9re5nK0vU1HtA0rvIaCNJbd4JNzJnR7ERirj42HzXCLv04RtmHV/RrfA9q3up/QfUhNsJJBDeP9X4cWdmehHUxJswdceoGdHmTp2V50j29CaBXLtxQ1e9FfuKyAv320W6IZQqvIClbBK6/1oGma6XtcUSeVR7sbs8fmccbo3IiSypOHZLNh75EIEdaU4PJgB2rxhaeO2JMhKRscKeYil8/w0W4stFtqN6igX6fOGJ3b7cVgtD42KkM2FLud9VlUixK1kl97VvcTug+pThuVhOZTcNl/ISEDAE3Tut1kSKsjrK0+F9gSYm/cS+ke34TQYmJFjBoWToCeFTUSuhdG6ojHH6Da7TPzA42ItlSF7F40LKlss1paJLiWWc/A66plmjUUIeMHj0dsEwhoeHyxU0faYjfYE8RhZ5StFoRYpCaEfLQDmUOxDP2+ua7O4zcLiXWXiLbdmch+rQ+KPYljfO6jUmiLvV8PpLsVTxB6LzbVgjMopt4vOIQ/oOEPaOwr0yOepVUuOad6ES8mXMpi36XUOHNjbuPxhypHRotot5fdoCAIjUlxWKlWglHi+sgS7MZESIuiFxPrDjgddqa7H2V+zt8gIb2rm9Ml9CqhPXjwYBRFifh3//33R2zz1Vdfccopp+B0OhkwYAAPPPBAF7W29XS34glC72T5liKmL/nATBO48ZXNTLxvJRPvW8nW4moAHv1gJ9OXfNBhpaaFzsUsw+6LXYbdFVZKOVpEu73sBgVBaIzFouC3p+p/1x+GgjfMddVh+dlKN8mFNh7G66UyZO/hnnvuoaioyPx37bXXmuuqqqo488wzGTRoEBs2bOCPf/wjv//97/nb3/7WhS1uOd2teILQ+zBSkxo+0FXUeRulJxmpSSK2ez5Zai3HUIqvviq0cOnV8Pez4OCXQEiEqxYFm9r4FmJY4cV7m1eAPPF3FoS4UcImP/LRH80/a1zdayIkhCLr9d7YD++9nV4ntFNSUsjNzTX/JSWFEvFffPFFPB4Pf//73xkzZgw//elPue6663jooYe6sMUtp7sVTxB6F5KadPRyW9UiPnVeT/r+VaGFBzbCvs/Ao6cLGRHtWNZ+hhUe0KzYFn9nQWg5NmdoYjKWkKjubh7aAAl2lSdtD/Nk5Vz9WnIU0n2+jXbi/vvv595772XgwIH87Gc/48Ybb8Rq1T/mmjVr+N73vofdHnJKmDVrFkuWLOHIkSNkZGQ0Op7b7cbtDnkIV1XpkR6v14vX23jiYXtjvEf4e43vn0JuqoNDVe4WFk9wML5/Sqe0u6cRrZ+PVta1ITVpzc4SpsSITEofdw5t6Wefol8bfe46c3+rz40C+LCieb3U1uuOMw6rJeZ7nDaiD4/9dBz3vf0txVWh62dju0EHd5w1ktNG9OlR54Wcy52D9HMklo+WgKKSkjCD+0ov5U7biwQyh+L3erF8/CeyS6qA6STZ1bj7rKP72KZoDFYOMTjwHb6aMrRO/C67y3nTq4T2ddddx4QJE8jMzOSzzz7j9ttvp6ioyIxYFxcXk5+fH7FPTk6OuS6a0F68eDELFy5stHzFihUkJiZ2wKeIzsqVKyNen52r8PcqI6IUHgnSoi7TgLNy6nh3+Tsd18heQMN+PhrZcFgBWjeRZsXH6yjb2vTjn/Rx59Cafu7r1b+7/Xt3U/z22wDMqq3ECXy8dj1VCcXsqwGwovk8vB3cJha3joZdVQpVXki1QX6KRmF16PXQ1Fr8ezfw9t4WN7VbIOdy5yD9rHNs8S5GFS3lPOsOyhQ9FWNPcQXuv1/NqKKl7E39EQD1VUea/W02pKP6+FA9TEJ/gN+w9mOKv61rZo/2o66u896rKbq90L7ttttYsmRJk9ts3bqVkSNHctNNN5nLjj/+eOx2O7/61a9YvHgxDoejiSPE5vbbb484blVVFQMGDODMM88kNTW1VcdsCV6vl5UrV3LGGWdgs4Ws1M4GJnxziAXLtkaUx05PtIGmmCXYQc9/vOOskcwak9Ph7e2pxOrno5GswnL+seOLVu175ilTmoxoSx93PG3p5807noUa6Nc3i0lnnw2Adeu14IPpp54GWcP5fM8R+Ppz0lOSOPvs6R3xEbo9ci53DtLPDTkb/8fHMuej+9moDANgcGIdln3v4f/ebXxn/wm8+S2D++dx9tnj4jpiR/fxgYp6Dnyja7iJ40ajjTm73d8jFkYGQlfT7YX2zTffzBVXXNHkNkOGDIm6fMqUKfh8Pvbs2cOIESPIzc3l0KFDEdsYr3Nzo9tZORyOqCLdZrN16g8/2vude0J/LBaV3/xrIwMzE1nyo+PNCUVdVTyhp9PZ32t3ZOqwvuSlOSmudLUwNcnJ1GF9mz3XpI87h9b0c0DV53Aofk9o32AJdpszGWw2/MHRMqdNPeq/RzmXOwfp5zC+fzurdpYx8+DTAFj2fQYz70CdMZ+6VTsB3Wu7pf3VUX2ckhCgPhjRtvjdWDpZN3UHur3Qzs7OJjs7u1X7btq0CYvFQt++euWuqVOncscdd+D1es0vYOXKlYwYMSJq2khP4GClXir5uGPSIgomSPEEobUYk9nmvrARBZoV2zKhrfegWfWgghYU12haoxLsrqB7gKOb+PQKwtHGV0N+xYwDz2BRNH0y5Iz5QKj8elJ3ch2xq7jQrys+dx1HYy3hXuM6smbNGv785z+zefNmdu/ezYsvvsiNN97InDlzTBH9s5/9DLvdzpVXXsk333zDyy+/zCOPPBKRGtLTOFChC+3+GUdftSWh45g9No8n50wgNy3SpSY90aanJ4WRm+aUqqO9BE0Njt4Z4trv1cs725JA1W+Rbp/uOuKM4ToiCELHckrR37EoGj6sEPDBar0eiOE6ktKNhLbTqlKv6dcOr6u2i1vTNXSfb6ONOBwOXnrpJX7/+9/jdrvJz8/nxhtvjBDRaWlprFixgnnz5jFx4kT69OnD3XffzdVXX92FLW8b+4+I0BY6htlj8zhjdG6jNCSQ1KTeSlHqOF48eBhbwkimAljtcOueiG0koi0IXcjqB5iw6y886L2IzUN/xT+GfgirFgFQ4zoT6F72fhaLQoUljQNaFknK0RjP7kVCe8KECaxdu7bZ7Y4//ng+/vjjTmhR53AgKLSPEaEtdACqRYmahiSpSb2TwpwzeHTLYC5LGcRPYmwjEW1B6CJWPwCrFrFzzPU8tmEKJ9R7zbQRVi1iRsYBlnJmt0odAXjC+nMW1V3Ce2O+R3pXN6YL6F7fhtBi9h/R7Wv6Z3Se1aAgCL0TowiNIaajYUS0nRLRFoTOJeCHmXdQNuBK2LCWKlfQXSwotn1f6D6Z3akyJOjVISvwUu85OqtDdq9vQ2gRVS4vVcGSq8ekS0RbEIS2kWDxk041FnelvqByP/z315CYBT95HgiJ8FiVIQVB6CBm3g5AapFuW1cVZuPLjPk8//UnQGW3FNoA9d7YD/C9GblS9mCMtJGMRFu3GyoSBKHnMfrQ/9jk/BU/OahPrsJVCXs+hr2fmdtIRFsQupa0BH1CelW9D00L+UIZriPdTWjP1NbxX/vd5K1f1NVN6RJEaPdgQhMhJW1EEIS2Y7HpriNqIGjvZ1r7hWoJuL0S0RaEriQ1KLQ9/gBuXygdoyY4wt2dJkMCZKl1jLfsxFGxq6ub0iXIlbIHcyCYny1pI4IgtAcWm27nqAaC1WYNP+1woe2TiLYgdCVOq8WsX7Dq2xL8AQ1/QKMymEqy41A1/kC85cY6Hs0a1Cje+q5tSBfRvR57hBYh1n6CILQnhtC2mkI7slgNgEsi2oLQZSzfUsTCZQVmIbG5L240axsYD8E3vLyZJcu3seC80d2ivoEWvH4ovqNTaMuVsgcjxWoEQWhPVJt+LZGItiB0P5ZvKWLuCxspqnRFLK+o81JR541YVlzpYu4LG1m+pagzmxgVxa6nt1pEaAs9jf2mh7bkaAuC0HZUux55smkNhXbjiLbTJrcPQegs/AEtIpLdHMZ2C5cVdHkaiWI8wPtdzWzZO5ErZQ8m5KEtEW1BENqONSi0rYbQDvj00utRItoOq0S0BaGzWF9Y3iiS3RwaUFTpYn1hecc0Kk4swYj20Sq0JUe7h1Lr9nEkOFQkVSEFQWgPlJQclvqnU2fLYg7AcRfp/8IsxMwcbYloC0KnUVLdepHaln3bA8WRRKWWiMeSREqXtqRrEKHdQzHys1OdVlKdti5ujSAIvQFLZj43eX9Dhs2mC20DRTH/DE2GlIi2IHQWfVOczW/UAfu2B3UpQxjnfoY54wdyX5e2pGuQkEQP5YB4aAuC0M7Yg04iHl/sUsmhyZBy+xCEzmJyfiZ5aU6U5jc1UYC8NCeT8zM7qllxkWAPVoY8Skuwy5Wyh2LkZ0vaiCAI7YVDtWDHi81Xoy/46lX410/hi2fNbSSiLQidj2pRWHDeaIC4xLaxzYLzRqNaWiLP2x+jBLtLSrALPQnx0BYEob1x+irZ7rycTfYr8Xk9UPotbH8HSraa20hEWxC6htlj83hyzgRy0yJTQdITbaaXtkFumpMn50zoFj7aCVYL/7T9gRv2XQN1XTsxsyuQHO0eyv5gjrZUhRQEob2wO0PXE4+7HmuUEuwur/hoC0JXMXtsHmeMzmV9YTkl1S76poRSQxou6+pItoHTYWWSZTsJbg94aiCxa1NZOhsR2j2U/ZKjLQhCO2N3hAltVz2JUQvWSGVIQehKVIvC1KFZjZZHW9YdSLCp1GMnAc9RWYZdrpQ9lAOSOiIIQjtjtdnxanqk2utxgT+K0JaItiAILUAX2sFriLeuaxvTBYjQ7oG4vH4O1+g3QBHagiC0J97gQKfHVd+oMmQgoOHxGwVr5PYhCELzJNgtuDS7/kIi2kJPwPDQTnZYSUsQD21BENoPt6LfEH3uOjBztHWh7Q6z/ZOItiAI8eCUiLbQ0wh3HFGU7jHZQRCE3oEX/eHd66kHX7AUezB1JNyeSyLagiDEg5GjDRyVEW2ZDNkDMT20xXFEEIR2Zo31RCzuSvItiXDJvyHgw3DlNSLaVouCVRWhLQhC8yTYVWq1BGq0BJIDR5+Xtgjtbow/oLGusJwNhxWyCsuZOqwvAOt36z6UVouCP6B1GwsfQRB6Pk8kzWN7TQ3/Shiol15XQ+lpRkRb0kYEQYiXBJvKFd5bAdgx8iyOtoRXEdrdlOVbili4rICiSheg8o8dX5iG9BV1XgDeLTjE9CUfsOC80d3ClF4QhJ6PUfHR7W9cLtmIaEvaiCAI8RL+YO7y+rEdZaNhR9en7SEs31LE3Bc2BkV2iIo6rymyDYorXcx9YSPLtxR1ZhMFQeil2K0WLARwe7yw/Hfw2pVQ8i0gEW1BEFqOw2rBmE5WfxSWYReh3c3wBzQWLitAi3N7Y7uFywrwB+LdSxAEIToLKu5gt3MOffa8CduXw5bXoP4IIBFtQRBajqIozLF9yPO2+7F++c+ubk6nI1fLbsb6wvJGkezm0ICiShfrC8s7plGCIBw1aBY9o1DzusJ8tCNdRxwS0RYEoQUMVQ8xQ/0KyrZ3dVM6HRHa3YyS6paJ7PbaVxAEAcBv0UV1wOcOqwyp+2ibQlsi2oIgtACfqrukBdzioy10MX1TnF2yryAIAkBA1YV2tIi2kTritMmtQxCE+PEb1xWPCG2hi5mcn0lempOWGPYpQF6ak8n5mR3VLEEQjhIClmBhCZ8rrDJkZOqITIYUBKElBKx6RFuTypBCV6NaFBacNxogLrFtbLPgvNHipy0IQpsJWI1SyfXgNypDRpZgl9QRQRBaQiCYOnI0VoaUq2U3ZPbYPJ6cM4HctMhUkPREm+mlbZCb5uTJORPER1sQhHZBU/XrjtVbE1ooEW1BENqAZtOFtnIURrSlYE03ZfbYPM4YncuanSWs+HgdZ54yJVQZsrCckmoXfVP0dBGJZAuC0F5UJA3hff94apzDmHRHsZ4+Yk8GJKItCEIrMVJHpAS70J1QLQpT8jMp26oxJUxQTx2a1cUtEwSht7K93w95uGAMP0sfyA9sCRCMRAG4JaItCEIr2Jk+jcF7X+TOCaP5ZVc3ppORsIQgCIJg4gg6iri9UoJdEIT2wWm3AYqZfnY0IVdLQRAEwcQQ0QmuQ7D0V7D8dnOd5GgLgtAajGvG0ViCXVJHBEEQBJORxcv41nEP1fv6gK8IknNh9mIAXF7DR1uEtiAI8ZNFBU/Y/kz+1iSY9XpXN6dTEaEtCIIgmKiqilPx4vdX6wsMuz/A7ZPKkIIgtJxEK5yjrsdfcfQ9pIvQFgRBEExUmy6sE7RafYE1ZDNqRLQdEtEWBCEeVi0Gi4rVcSYAKn7we0G1weoHIOCHmbc3c5CejYQlBEEQBBOLTRfWFjR9gUS0BUFoLRYVVi3ihIP/Ci3z1usie9UifX0vRyLagiAIgolqT4hcECWiLTnagiDExYz5AIxbtYiABhYF+OhP8NkjMPMOc31vRsISgiAIgkljoS0RbUEQ2sCM+WwbdR0WBfxYjiqRDSK0BUEQhDBUuzNygUS0BUFoIwfGXYNbs6ISANV+1IhsEKEtCIIghKEmZbLGP5r3lalwyy744V/NdS6JaAuC0AqGFfwFh+LDgxX8Hj1H+yhBcrQFQRAEEyVrGJd47yTNamNzUp+IdW6JaAuC0FJWP8DAr/7Mg96LeD3tUj6e8oU+ERKOisi2CG1BEATBxIhWG/nY4RjLnDaJaAuCEAdBd5HSSTfz2CcT6eMJhMT1USK25WopCIIgmDiCIvqUwOdob94E37xurjMi2g6rRLQFQYiDgB9m3kHV5JsAqHZ5WbOrDP8pt+gTIgO9vyS7RLQFQRAEE4e/jg2OX5GlVMMX6K4jYy4AQjnaEtEWBCEuZt7O8i1F3P30WgDcvgCXPL2WvDQnC867jNlj87q4gR2PXC0FQRAEE4fDoYtsA9UOgD+g4fXrRWwkoi0IQjws31LE3Bc2UlLtjlheXOli7gsbWb6lqIta1nmI0BYEQRBM7DHs/cJztiWiLQhCc/gDGguXFRg1ZiMwli1cVoA/EG2L3oNcLQVBEAQTi6ri0cKyCoMFa4z8bJCItiAIzbO+sJyiSlfM9RpQVOlifWF55zWqCxChLQiCIETgxhZ6EYxoG/nZNlVBtShd0SxBEHoQJdWxRXZrtuupiNAWBEEQIvAo9tALq/63WRVSotmCIMRB3xRn8xu1YLueightQRAEIQIv4UI7MkfbIfnZgiDEweT8TPLSnMQa/1KAvDQnk/MzO7NZnY5cMQVBEIQItqvD2BXIY8f3/wajzgdCEW3JzxYEIR5Ui8KC80YDNBLbxusF543u9aloIrQFQRCECP6Q8jtO8zzIobzTwJkKgNsrEW1BEFrG7LF5PDlnArlpkekhuWlOnpwz4ajw0ZaCNYIgCEIE0cqwu3ySoy0IQsuZPTaPM0bnsr6wnJJqF31T9HSR3h7JNhChLQiCIETgsKr8Rn2DwV9+ADnXQGa+RLQFQWg1qkVh6tCsrm5Gl9BjrpiLFi3i5JNPJjExkfT09Kjb7Nu3j3POOYfExET69u3LLbfcgs/ni9jmww8/ZMKECTgcDoYNG8Zzzz3X8Y0XBEHoQVxX9Sfm215m6PZnoKYEkIi2IAhCa+gxQtvj8fDjH/+YuXPnRl3v9/s555xz8Hg8fPbZZzz//PM899xz3H333eY2hYWFnHPOOcycOZNNmzZxww038Mtf/pJ33323sz6GIAhCtyeZ2tALs2CNHtGWqpCCIAjx02NSRxYuXAgQMwK9YsUKCgoKeO+998jJyeGEE07g3nvv5dZbb+X3v/89drudp556ivz8fB588EEARo0axSeffMLDDz/MrFmzOuujCIIgdGv8lsb2fkZEW1xHBEEQ4qfHCO3mWLNmDccddxw5OTnmslmzZjF37ly++eYbxo8fz5o1azj99NMj9ps1axY33HBDzOO63W7cbrf5uqqqCgCv14vX623fDxEF4z06472OZqSfOx7p486hPfo5XGh7UcHrpc7lAcCuKkf9dyjncucg/dzx9OY+7i6fqdcI7eLi4giRDZivi4uLm9ymqqqK+vp6EhISGh138eLFZjQ9nBUrVpCYmNhezW+WlStXdtp7Hc1IP3c80sedQ1v6OaU+dIP6YPUnuOwFfLVfAVRKig/w9tvftUMLez5yLncO0s8dT2/s47q6uq5uAtDFQvu2225jyZIlTW6zdetWRo4c2Uktasztt9/OTTfdZL6uqqpiwIABnHnmmaSmpnb4+3u9XlauXMkZZ5yBzWbr8Pc7WpF+7nikjzuH9ujnL/f9B8r0v79/5tmQmMm293bCd7sZnj+Is88e1Y4t7nnIudw5SD93PL25j40MhK6mS4X2zTffzBVXXNHkNkOGDInrWLm5uaxfvz5i2aFDh8x1xv/GsvBtUlNTo0azARwOBw6Ho9Fym83WqSdlZ7/f0Yr0c8cjfdw5tKWfVTWUh21LSAabDZ+mv05wyPdnIOdy5yD93PH0xj7uLp+nS4V2dnY22dnZ7XKsqVOnsmjRIkpKSujbty+gD4WkpqYyevRoc5u33347Yr+VK1cyderUdmmDIAhCb6AqcRB1moPtWadxglUPQrgM1xGruI4IgiDES4+5Yu7bt49Nmzaxb98+/H4/mzZtYtOmTdTU1ABw5plnMnr0aC677DI2b97Mu+++y5133sm8efPMiPSvf/1rdu/ezfz58/n222/5y1/+wiuvvMKNN97YlR9NEAShW7FlwKWMdj/Ly/1vB0uwSqQ36DpiE9cRQRCEeOkxkyHvvvtunn/+efP1+PHjAVi1ahWnnnoqqqry5ptvMnfuXKZOnUpSUhKXX34599xzj7lPfn4+b731FjfeeCOPPPII/fv355lnnhFrP0EQhDCM6o+GuAZwBcuxOySiLQiCEDc9Rmg/99xzzVZxHDRoUKPUkIaceuqpfPnll+3YMkEQhN5Fqq+cW6wvkbgvmzW7BjBxUAYHK+oBOFhRjz+goVqULm6lIAhC96fHCG1BEAShg1m1mB2ldVQXfMc86/+gFgY/fRoWBeZZljLNGuDPn17EO1uKWXDeaGaPzevqFguCIHRrZAxQEARBAGBHaR3DCx7lRP/miOXzLEu52fYafk2/ZRRXupj7wkaWbynqimYKgiD0GERoC4IgCPgDGj/fdSoPei/iBHW3ufxaVRfZD3ov4jH/hQAEnf5YuKwAf0CLcjRBEAQBRGgLgiAIwPrCcooqXTzmv5CP/MeZyxuKbAMNKKp0sb6wvJNbKgiC0HMQoS0IgiBQUu0y/77KezN+TZ/s6NasjUR2rP0EQRCESERoC4IgCPRNcZp/X62+iapouDUrDsXHterSuPYTBEEQIhGhLQiCIDA5P5O8NCfXheVkj3D/gwe9F3Gz7bVGYlsB8tKcTM7P7JoGC4Ig9ADE3k8QBEFAtSj8Y+iHDC94jYfCcrKN/2+2vWa+Nhy0F5w3Wvy0BUEQmkCEtiAIggDA8OxEdoy+jld3nQqVodzrJwIXghdURa8UmZvmFB9tQRCEOBChLQiCIOjMvJ3hwCcBjfWF5ZRUu+ib4mTioAw27D2JkmoX/07R00Ukki0IgtA8IrQFQRCECFSLwtShWRHLGr4WBEEQmkcmQwqCIAiCIAhCByBCWxAEQRAEQRA6ABHagiAIgiAIgtABiNAWBEEQBEEQhA5AhLYgCIIgCIIgdAAitAVBEARBEAShAxB7vxaiaRoAVVVVnfJ+Xq+Xuro6qqqqsNlsnfKeRyPSzx2P9HHnIP3c8Ugfdw7Szx1Pb+5jQ6cZuq2rEKHdQqqrqwEYMGBAF7dEEARBEARBaIrq6mrS0tK67P0Vraulfg8jEAhw8OBBUlJSUJSOr4xWVVXFgAED+O6770hNTe3w9ztakX7ueKSPOwfp545H+rhzkH7ueHpzH2uaRnV1Nf369cNi6bpMaYlotxCLxUL//v07/X1TU1N73Y+gOyL93PFIH3cO0s8dj/Rx5yD93PH01j7uyki2gUyGFARBEARBEIQOQIS2IAiCIAiCIHQAIrS7OQ6HgwULFuBwOLq6Kb0a6eeOR/q4c5B+7nikjzsH6eeOR/q445HJkIIgCIIgCILQAUhEWxAEQRAEQRA6ABHagiAIgiAIgtABiNAWBEEQBEEQhA5AhLYgCIIgCIIgdAAitLs5TzzxBIMHD8bpdDJlyhTWr1/f1U3qsSxevJgTTzyRlJQU+vbtywUXXMC2bdsitnG5XMybN4+srCySk5P50Y9+xKFDh7qoxT2f+++/H0VRuOGGG8xl0sftw4EDB5gzZw5ZWVkkJCRw3HHH8cUXX5jrNU3j7rvvJi8vj4SEBE4//XR27NjRhS3uefj9fu666y7y8/NJSEhg6NCh3HvvvYR7CEg/t4yPPvqI8847j379+qEoCq+//nrE+nj6s7y8nEsvvZTU1FTS09O58sorqamp6cRP0f1pqp+9Xi+33norxx13HElJSfTr14+f//znHDx4MOIY0s/tgwjtbszLL7/MTTfdxIIFC9i4cSPjxo1j1qxZlJSUdHXTeiSrV69m3rx5rF27lpUrV+L1ejnzzDOpra01t7nxxhtZtmwZr776KqtXr+bgwYNceOGFXdjqnsvnn3/OX//6V44//viI5dLHbefIkSNMmzYNm83GO++8Q0FBAQ8++CAZGRnmNg888ACPPvooTz31FOvWrSMpKYlZs2bhcrm6sOU9iyVLlvDkk0/y+OOPs3XrVpYsWcIDDzzAY489Zm4j/dwyamtrGTduHE888UTU9fH056WXXso333zDypUrefPNN/noo4+4+uqrO+sj9Aia6ue6ujo2btzIXXfdxcaNG1m6dCnbtm3j/PPPj9hO+rmd0IRuy+TJk7V58+aZr/1+v9avXz9t8eLFXdiq3kNJSYkGaKtXr9Y0TdMqKio0m82mvfrqq+Y2W7du1QBtzZo1XdXMHkl1dbU2fPhwbeXKldqMGTO066+/XtM06eP24tZbb9WmT58ec30gENByc3O1P/7xj+ayiooKzeFwaP/+9787o4m9gnPOOUf7v//7v4hlF154oXbppZdqmib93FYA7b///a/5Op7+LCgo0ADt888/N7d55513NEVRtAMHDnRa23sSDfs5GuvXr9cAbe/evZqmST+3JxLR7qZ4PB42bNjA6aefbi6zWCycfvrprFmzpgtb1nuorKwEIDMzE4ANGzbg9Xoj+nzkyJEMHDhQ+ryFzJs3j3POOSeiL0H6uL343//+x6RJk/jxj39M3759GT9+PE8//bS5vrCwkOLi4oh+TktLY8qUKdLPLeDkk0/m/fffZ/v27QBs3ryZTz75hLPOOguQfm5v4unPNWvWkJ6ezqRJk8xtTj/9dCwWC+vWrev0NvcWKisrURSF9PR0QPq5PbF2dQOE6Bw+fBi/309OTk7E8pycHL799tsualXvIRAIcMMNNzBt2jTGjh0LQHFxMXa73bzQGOTk5FBcXNwFreyZvPTSS2zcuJHPP/+80Trp4/Zh9+7dPPnkk9x000387ne/4/PPP+e6667Dbrdz+eWXm30Z7foh/Rw/t912G1VVVYwcORJVVfH7/SxatIhLL70UQPq5nYmnP4uLi+nbt2/EeqvVSmZmpvR5K3G5XNx6661ccsklpKamAtLP7YkIbeGoZN68eWzZsoVPPvmkq5vSq/juu++4/vrrWblyJU6ns6ub02sJBAJMmjSJP/zhDwCMHz+eLVu28NRTT3H55Zd3cet6D6+88govvvgi//rXvxgzZgybNm3ihhtuoF+/ftLPQq/A6/Xyk5/8BE3TePLJJ7u6Ob0SSR3ppvTp0wdVVRu5MRw6dIjc3NwualXv4JprruHNN99k1apV9O/f31yem5uLx+OhoqIiYnvp8/jZsGEDJSUlTJgwAavVitVqZfXq1Tz66KNYrVZycnKkj9uBvLw8Ro8eHbFs1KhR7Nu3D8DsS7l+tI1bbrmF2267jZ/+9Kccd9xxXHbZZdx4440sXrwYkH5ub+Lpz9zc3EaGAD6fj/LycunzFmKI7L1797Jy5Uozmg3Sz+2JCO1uit1uZ+LEibz//vvmskAgwPvvv8/UqVO7sGU9F03TuOaaa/jvf//LBx98QH5+fsT6iRMnYrPZIvp827Zt7Nu3T/o8Tk477TS+/vprNm3aZP6bNGkSl156qfm39HHbmTZtWiNryu3btzNo0CX6ts4AAAdhSURBVCAA8vPzyc3Njejnqqoq1q1bJ/3cAurq6rBYIm+TqqoSCAQA6ef2Jp7+nDp1KhUVFWzYsMHc5oMPPiAQCDBlypROb3NPxRDZO3bs4L333iMrKytivfRzO9LVszGF2Lz00kuaw+HQnnvuOa2goEC7+uqrtfT0dK24uLirm9YjmTt3rpaWlqZ9+OGHWlFRkfmvrq7O3ObXv/61NnDgQO2DDz7QvvjiC23q1Kna1KlTu7DVPZ9w1xFNkz5uD9avX69ZrVZt0aJF2o4dO7QXX3xRS0xM1F544QVzm/vvv19LT0/X3njjDe2rr77SfvCDH2j5+flafX19F7a8Z3H55ZdrxxxzjPbmm29qhYWF2tKlS7U+ffpo8+fPN7eRfm4Z1dXV2pdffql9+eWXGqA99NBD2pdffmm6XcTTn7Nnz9bGjx+vrVu3Tvvkk0+04cOHa5dccklXfaRuSVP97PF4tPPPP1/r37+/tmnTpoj7odvtNo8h/dw+iNDu5jz22GPawIEDNbvdrk2ePFlbu3ZtVzepxwJE/ffss8+a29TX12u/+c1vtIyMDC0xMVH74Q9/qBUVFXVdo3sBDYW29HH7sGzZMm3s2LGaw+HQRo4cqf3tb3+LWB8IBLS77rpLy8nJ0RwOh3baaadp27Zt66LW9kyqqqq066+/Xhs4cKDmdDq1IUOGaHfccUeEGJF+bhmrVq2Keh2+/PLLNU2Lrz/Lysq0Sy65REtOTtZSU1O1X/ziF1p1dXUXfJruS1P9XFhYGPN+uGrVKvMY0s/tg6JpYSWuBEEQBEEQBEFoFyRHWxAEQRAEQRA6ABHagiAIgiAIgtABiNAWBEEQBEEQhA5AhLYgCIIgCIIgdAAitAVBEARBEAShAxChLQiCIAiCIAgdgAhtQRAEQRAEQegARGgLgiAIgiAIQgcgQlsQBOEoR1EUXn/99TYd47nnniM9Pb1d2iMIgtBbEKEtCILQBSiK0uS/3//+953WlqKiIs4666xOez9BEISjBWtXN0AQBOFopKioyPz75Zdf5u6772bbtm3msuTk5BYdz+PxYLfbW9WW3NzcVu0nCIIgNI1EtAVBELqA3Nxc819aWhqKopivn3rqKaZPnx6x/Z///GcGDx5svr7iiiu44IILWLRoEf369WPEiBHs2bMHRVFYunQpM2fOJDExkXHjxrFmzZom2xKeOhLvMZ577jkGDhxIYmIiP/zhDykrK2t03DfeeIMJEybgdDoZMmQICxcuxOfzAXDPPffQr1+/iP3OOeccZs6cSSAQaElXCoIgdFtEaAuCIPRQ3n//fbZt28bKlSt58803zeV33HEHv/3tb9m0aRPHHnssl1xyiSlw46WpY6xbt44rr7ySa665hk2bNjFz5kzuu+++iP0//vhjfv7zn3P99ddTUFDAX//6V5577jkWLVpkHn/w4MH88pe/BOCJJ57gs88+4/nnn8dikVuTIAi9A0kdEQRB6KEkJSXxzDPPmCkje/bsAeC3v/0t55xzDgALFy5kzJgx7Ny5k5EjR8Z97KaO8cgjjzB79mzmz58PwLHHHstnn33G8uXLzf0XLlzIbbfdxuWXXw7AkCFDuPfee5k/fz4LFixAVVVeeOEFTjjhBG677TYeffRRnnnmGQYOHNjmfhEEQeguSNhAEAShh3LcccdFzcs+/vjjzb/z8vIAKCkpadGxmzrG1q1bmTJlSsT2U6dOjXi9efNm7rnnHpKTk81/V111FUVFRdTV1QG6+P7Tn/7EkiVLOP/88/nZz37WojYKgiB0dySiLQiC0M2wWCxomhaxzOv1NtouKSkp6v42m838W1EUgBbnPbf1GDU1NSxcuJALL7yw0Tqn02n+/dFHH6GqKnv27MHn82G1ym1JEITeg0S0BUEQuhnZ2dkUFxdHiO1NmzZ1XYMaMGrUKNatWxexbO3atRGvJ0yYwLZt2xg2bFijf0YO9ssvv8zSpUv58MMP2bdvH/fee2+nfQZBEITOQEIHgiAI3YxTTz2V0tJSHnjgAS666CKWL1/OO++8Q2pqalc3DYDrrruOadOm8ac//Ykf/OAHvPvuuxH52QB333035557LgMHDuSiiy7CYrGwefNmtmzZwn333cf+/fuZO3cuS5YsYfr06Tz77LOce+65nHXWWZx00kld9MkEQRDaF4loC4IgdDNGjRrFX/7yF5544gnGjRvH+vXr+e1vf9vVzTI56aSTePrpp3nkkUcYN24cK1as4M4774zYZtasWbz55pusWLGCE088kZNOOomHH36YQYMGoWkaV1xxBZMnT+aaa64xt587dy5z5syhpqamKz6WIAhCu6NoDRMBBUEQBEEQBEFoMxLRFgRBEARBEIQOQIS2IAiCIAiCIHQAIrQFQRAEQRAEoQMQoS0IgiAIgiAIHYAIbUEQBEEQBEHoAERoC4IgCIIgCEIHIEJbEARBEARBEDoAEdqCIAiCIAiC0AGI0BYEQRAEQRCEDkCEtiAIgiAIgiB0ACK0BUEQBEEQBKED+P/F73ly5m0+JgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "remote_df = parse_log_file(docker_remote_log_file, to_dataframe=True)\n", - "remote_df.head(20)" + "\n", + "for instance_id in random.sample(fully_resolved, 10):\n", + " trajectory = get_trajectory_from_instance_id(instance_id,\n", + " base_dir,\n", + " run_name)\n", + "\n", + " plot_turn_dynamics(\n", + " logprob_infos=trajectory_logprob_stats(trajectory), status=\"success\", instance_id=instance_id,\n", + " )" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 62, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Local totals (minutes):\n", - "docker_build_time 42.550000\n", - "llm_execution_time 52.816667\n", - "total_time 95.366667\n", - "dtype: float64\n", - "\n", - "Remote totals (minutes):\n", - "docker_build_time 35.966667\n", - "llm_execution_time 41.066667\n", - "total_time 77.033333\n", - "dtype: float64\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "for instance_id in random.sample(fully_fail, 10):\n", + " trajectory = get_trajectory_from_instance_id(instance_id,\n", + " base_dir,\n", + " run_name)\n", + "\n", + " plot_turn_dynamics(\n", + " logprob_infos=trajectory_logprob_stats(trajectory), status=\"fail\", instance_id=instance_id,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Total times across all instances\n", - "local_totals = local_df[[\"docker_build_time\", \"llm_execution_time\", \"total_time\"]].sum()\n", - "remote_totals = remote_df[[\"docker_build_time\", \"llm_execution_time\", \"total_time\"]].sum()\n", - "\n", - "print(\"Local totals (minutes):\")\n", - "print(local_totals / 60)\n", - "print(\"\\nRemote totals (minutes):\")\n", - "print(remote_totals / 60)\n" + "\n", + "for instance_id in random.sample(partial_resolve_no_degrad, 4):\n", + " trajectory = get_trajectory_from_instance_id(instance_id,\n", + " base_dir,\n", + " run_name)\n", + "\n", + " plot_turn_dynamics(\n", + " logprob_infos=trajectory_logprob_stats(trajectory), status=\"partial_nodegrad\", instance_id=instance_id,\n", + " )" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "for instance_id in random.sample(partial_resolve_degrad, 4):\n", + " trajectory = get_trajectory_from_instance_id(instance_id,\n", + " base_dir,\n", + " run_name)\n", + "\n", + " plot_turn_dynamics(\n", + " logprob_infos=trajectory_logprob_stats(trajectory), status=\"partial_degrad\", instance_id=instance_id,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# fully resolve\n", + "# fully fail\n", + "# partial nodegrad:\n", + "# partial degrad\n", + "\n", + "\n", + "\n", + "# no degrad\n", + "# ['pvlib__pvlib-python-1589',\n", + "# 'pylint-dev__astroid-1351',\n", + "# 'pylint-dev__astroid-984',\n", + "# 'marshmallow-code__marshmallow-1702',\n", + "# 'marshmallow-code__marshmallow-1524',\n", + "# 'pylint-dev__astroid-1196']\n", + "\n", + "# with degrad\n", + "# ['pydicom__pydicom-1413',\n", + "# 'pydicom__pydicom-1539',\n", + "# 'pydicom__pydicom-1069',\n", + "# 'pydicom__pydicom-1194',\n", + "# 'pydicom__pydicom-1365',\n", + "# 'pydicom__pydicom-1139',\n", + "# 'pydicom__pydicom-933',\n", + "# 'pydicom__pydicom-1416',\n", + "# 'pylint-dev__astroid-941',\n", + "# 'pvlib__pvlib-python-1739',\n", + "# 'pydicom__pydicom-1555',\n", + "# 'pydicom__pydicom-1375',\n", + "# 'pydicom__pydicom-1076',\n", + "# 'pvlib__pvlib-python-1623',\n", + "# 'pydicom__pydicom-811']" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "fully_resolve_instance = \"pvlib__pvlib-python-1349\"\n", + "partial_no_degrad_instance = \"pvlib__pvlib-python-1589\"\n", + "partial_degrad_instance = \"pvlib__pvlib-python-1739\"\n", + "fully_fail_instance = \"pvlib__pvlib-python-1395\"\n", + "\n", + "# fully_resolve_instance = \"pylint-dev__astroid-1903\"\n", + "# partial_no_degrad_instance = \"pylint-dev__astroid-1196\"\n", + "# partial_degrad_instance = \"pylint-dev__astroid-941\"\n", + "# fully_fail_instance = \"pylint-dev__astroid-1364\"" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "# for idx, instance_id in enumerate([\n", + "# fully_resolve_instance,\n", + "# partial_no_degrad_instance,\n", + "# partial_degrad_instance,\n", + "# fully_fail_instance\n", + "# ]):\n", + "# trajectory = get_trajectory_from_instance_id(instance_id,\n", + "# base_dir,\n", + "# run_name)\n", + "# if idx == 0:\n", + "# status = \"success\"\n", + "# elif idx == 1:\n", + "# status = \"partial_no_degrad\"\n", + "# elif idx == 2:\n", + "# status = \"partial_degrad\"\n", + "# else:\n", + "# status = \"fail\"\n", + "\n", + "# plot_turn_dynamics(\n", + "# logprob_infos=trajectory_logprob_stats(trajectory), status=status, instance_id=instance_id,\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# mean, bottom 5p\n", + "# confidence" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Self-reflection Analysis\n", + "- For each problem, how many turns does self-reflection get triggered?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base_dir = \"/workspaces/OpenHands/evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench-dev/CodeActAgent\"\n", + "# run_name = \"qwen-coder-30b-small_maxiter_100_N_176_reflection_1030\"\n", + "# run_name = \"qwen-coder-30b-small_maxiter_100_N_176_baseline\"\n", + "run_name = \"qwen-coder-30b-small_maxiter_100_N_176_reflection_no_prob\"\n", + "\n", + "\n", + "\n", + "\n", + "instance_ids = [d for d in os.listdir(os.path.join(base_dir, run_name, \"llm_completions\")) if os.path.isdir(os.path.join(base_dir, run_name, \"llm_completions\", d))]\n", + "# instance_id = random.sample(instance_ids, 1)[0]\n", + "# print('Instance ID', instance_id)\n", + "\n", + "total_actions_list = []\n", + "reflection_actions_list = []\n", + "\n", + "for instance_id in instance_ids:\n", + " trajectory_file = os.path.join(\n", + " base_dir,\n", + " run_name,\n", + " \"llm_completions\",\n", + " instance_id,\n", + " f\"{instance_id}_trajectory.json\"\n", + " )\n", + "\n", + " with open(trajectory_file, \"r\") as f:\n", + " trajectory = json.load(f)\n", + "\n", + "\n", + " total_actions, reflection_actions = 0, 0\n", + " for turn in trajectory:\n", + " if not turn.get(\"action\", None):\n", + " continue\n", + " total_actions += 1\n", + " meta = turn.get(\"tool_call_metadata\", {})\n", + " if meta.get(\"function_name\") == \"reflection\":\n", + " reflection_actions += 1\n", + " if \"[AutoReflect]\" in turn.get(\"message\", None):\n", + " reflection_actions += 1\n", + "\n", + " total_actions_list.append(total_actions)\n", + " reflection_actions_list.append(reflection_actions)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -585,8 +888,22 @@ } ], "metadata": { + "kernelspec": { + "display_name": "vllm_venv", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" } }, "nbformat": 4, diff --git a/openhands/agenthub/codeact_agent/codeact_agent.py b/openhands/agenthub/codeact_agent/codeact_agent.py index 91a00c5c2b9e..c332ecedfba6 100644 --- a/openhands/agenthub/codeact_agent/codeact_agent.py +++ b/openhands/agenthub/codeact_agent/codeact_agent.py @@ -103,7 +103,7 @@ def __init__(self, config: AgentConfig, llm_registry: LLMRegistry) -> None: self.llm = self.llm_registry.get_router(self.config) # NOTE: reflection - self.auto_reflect_enabled = os.getenv("AUTO_REFLECTION_ENABLED", "true").lower() == "true" + self.auto_reflect_enabled = os.getenv("AUTO_REFLECTION_ENABLED", "false").lower() == "true" self.auto_reflect_prob = float(os.getenv("AUTO_REFLECTION_PROB", "0.10")) self.auto_reflect_reactive = os.getenv("AUTO_REFLECTION_REACTIVE_ENABLED", "true").lower() == "true" self.auto_reflect_lookback = int(os.getenv("AUTO_REFLECTION_LOOKBACK_WINDOW", "5")) @@ -112,7 +112,7 @@ def __init__(self, config: AgentConfig, llm_registry: LLMRegistry) -> None: ( "Look back at the last {n} steps. Are you making good progress, or should you " "step back and reconsider your approach? If you're off-track, propose " - "concrete adjustments and the single next best action/tool to try." + "concrete adjustments/fixes and the single next best action/tool to try." ), ) @@ -226,7 +226,7 @@ def step(self, state: State) -> 'Action': if self.auto_reflect_reactive: is_last_turn_tool_error, tool_call_error_message =self._last_turn_has_tool_error(condensed_history) if is_last_turn_tool_error and not self._last_action_is_think(condensed_history): - return self._emit_reflection(f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete adjustments plus the single next best action/tool.") + return self._emit_reflection(f"I encountered a tool call with the following error: {tool_call_error_message}. \nI need to think about it and propose concrete fixes for a valid tool call") # NOTE: reflection case 1: Probablistically do general last N step reflection # Let's do not break any pending actions @@ -247,6 +247,7 @@ def step(self, state: State) -> 'Action': params: dict = { 'messages': messages, + 'logprobs': True, } params['tools'] = check_tools(self.tools, self.llm.config) @@ -256,9 +257,7 @@ def step(self, state: State) -> 'Action': ) } - logger.debug(f'Last utterance input to LLM: {messages[-1]}') response = self.llm.completion(**params) - logger.debug(f'Response from LLM: {response}') try: actions = self.response_to_actions(response) # NOTE: reflection case 3: cope with tool parse failures