diff --git a/.github/workflows/contrib-lmm.yml b/.github/workflows/contrib-lmm.yml new file mode 100644 index 00000000000..c032d5ea47b --- /dev/null +++ b/.github/workflows/contrib-lmm.yml @@ -0,0 +1,60 @@ +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions + +name: ContribTests + +on: + pull_request: + branches: ['main', 'dev/v0.2'] + paths: + - 'autogen/img_utils.py' + - 'autogen/agentchat/contrib/multimodal_conversable_agent.py' + - 'autogen/agentchat/contrib/llava_agent.py' + - 'test/test_img_utils.py' + - 'test/agentchat/contrib/test_lmm.py' + - 'test/agentchat/contrib/test_llava.py' + - '.github/workflows/lmm-test.yml' + - 'setup.py' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.head_ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/main' }} + +jobs: + LMMTest: + + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-2019] + python-version: ["3.8", "3.9", "3.10", "3.11"] + steps: + - uses: actions/checkout@v3 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + - name: Install packages and dependencies for all tests + run: | + python -m pip install --upgrade pip wheel + pip install pytest + - name: Install packages and dependencies for LMM + run: | + pip install -e .[lmm] + pip uninstall -y openai + - name: Test LMM and LLaVA + run: | + pytest test/test_img_utils.py test/agentchat/contrib/test_lmm.py test/agentchat/contrib/test_llava.py + - name: Coverage + if: matrix.python-version == '3.10' + run: | + pip install coverage>=5.3 + coverage run -a -m pytest test/test_img_utils.py test/agentchat/contrib/test_lmm.py test/agentchat/contrib/test_llava.py + coverage xml + - name: Upload coverage to Codecov + if: matrix.python-version == '3.10' + uses: codecov/codecov-action@v3 + with: + file: ./coverage.xml + flags: unittests diff --git a/autogen/agentchat/__init__.py b/autogen/agentchat/__init__.py index 6ce32edb7cb..3db1db73a55 100644 --- a/autogen/agentchat/__init__.py +++ b/autogen/agentchat/__init__.py @@ -1,8 +1,8 @@ from .agent import Agent -from .conversable_agent import ConversableAgent from .assistant_agent import AssistantAgent -from .user_proxy_agent import UserProxyAgent +from .conversable_agent import ConversableAgent from .groupchat import GroupChat, GroupChatManager +from .user_proxy_agent import UserProxyAgent __all__ = [ "Agent", diff --git a/autogen/agentchat/contrib/llava_agent.py b/autogen/agentchat/contrib/llava_agent.py new file mode 100644 index 00000000000..39c4b2987c8 --- /dev/null +++ b/autogen/agentchat/contrib/llava_agent.py @@ -0,0 +1,178 @@ +import json +import logging +import os +import pdb +import re +from typing import Any, Dict, List, Optional, Tuple, Union + +import replicate +import requests +from regex import R + +from autogen.agentchat.agent import Agent +from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent +from autogen.code_utils import content_str +from autogen.img_utils import get_image_data, llava_formater + +try: + from termcolor import colored +except ImportError: + + def colored(x, *args, **kwargs): + return x + + +logger = logging.getLogger(__name__) + +# we will override the following variables later. +SEP = "###" + +DEFAULT_LLAVA_SYS_MSG = "You are an AI agent and you can view images." + + +class LLaVAAgent(MultimodalConversableAgent): + def __init__( + self, + name: str, + system_message: Optional[Tuple[str, List]] = DEFAULT_LLAVA_SYS_MSG, + *args, + **kwargs, + ): + """ + Args: + name (str): agent name. + system_message (str): system message for the ChatCompletion inference. + Please override this attribute if you want to reprogram the agent. + **kwargs (dict): Please refer to other kwargs in + [ConversableAgent](../conversable_agent#__init__). + """ + super().__init__( + name, + system_message=system_message, + *args, + **kwargs, + ) + + assert self.llm_config is not None, "llm_config must be provided." + self.register_reply([Agent, None], reply_func=LLaVAAgent._image_reply, position=1) + + def _image_reply(self, messages=None, sender=None, config=None): + # Note: we did not use "llm_config" yet. + + if all((messages is None, sender is None)): + error_msg = f"Either {messages=} or {sender=} must be provided." + logger.error(error_msg) + raise AssertionError(error_msg) + + if messages is None: + messages = self._oai_messages[sender] + + # The formats for LLaVA and GPT are different. So, we manually handle them here. + images = [] + prompt = content_str(self.system_message) + "\n" + for msg in messages: + role = "Human" if msg["role"] == "user" else "Assistant" + # pdb.set_trace() + images += [d["image_url"]["url"] for d in msg["content"] if d["type"] == "image_url"] + content_prompt = content_str(msg["content"]) + prompt += f"{SEP}{role}: {content_prompt}\n" + prompt += "\n" + SEP + "Assistant: " + images = [re.sub("data:image/.+;base64,", "", im, count=1) for im in images] + print(colored(prompt, "blue")) + + out = "" + retry = 10 + while len(out) == 0 and retry > 0: + # image names will be inferred automatically from llava_call + out = llava_call_binary( + prompt=prompt, + images=images, + config_list=self.llm_config["config_list"], + temperature=self.llm_config.get("temperature", 0.5), + max_new_tokens=self.llm_config.get("max_new_tokens", 2000), + ) + retry -= 1 + + assert out != "", "Empty response from LLaVA." + + return True, out + + +def _llava_call_binary_with_config( + prompt: str, images: list, config: dict, max_new_tokens: int = 1000, temperature: float = 0.5, seed: int = 1 +): + if config["base_url"].find("0.0.0.0") >= 0 or config["base_url"].find("localhost") >= 0: + llava_mode = "local" + else: + llava_mode = "remote" + + if llava_mode == "local": + headers = {"User-Agent": "LLaVA Client"} + pload = { + "model": config["model"], + "prompt": prompt, + "max_new_tokens": max_new_tokens, + "temperature": temperature, + "stop": SEP, + "images": images, + } + + response = requests.post( + config["base_url"].rstrip("/") + "/worker_generate_stream", headers=headers, json=pload, stream=False + ) + + for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False, delimiter=b"\0"): + if chunk: + data = json.loads(chunk.decode("utf-8")) + output = data["text"].split(SEP)[-1] + elif llava_mode == "remote": + # The Replicate version of the model only support 1 image for now. + img = "data:image/jpeg;base64," + images[0] + response = replicate.run( + config["base_url"], input={"image": img, "prompt": prompt.replace("", " "), "seed": seed} + ) + # The yorickvp/llava-13b model can stream output as it's running. + # The predict method returns an iterator, and you can iterate over that output. + output = "" + for item in response: + # https://replicate.com/yorickvp/llava-13b/versions/2facb4a474a0462c15041b78b1ad70952ea46b5ec6ad29583c0b29dbd4249591/api#output-schema + output += item + + # Remove the prompt and the space. + output = output.replace(prompt, "").strip().rstrip() + return output + + +def llava_call_binary( + prompt: str, images: list, config_list: list, max_new_tokens: int = 1000, temperature: float = 0.5, seed: int = 1 +): + # TODO 1: add caching around the LLaVA call to save compute and cost + # TODO 2: add `seed` to ensure reproducibility. The seed is not working now. + + for config in config_list: + try: + return _llava_call_binary_with_config(prompt, images, config, max_new_tokens, temperature, seed) + except Exception as e: + print(f"Error: {e}") + continue + + +def llava_call(prompt: str, llm_config: dict) -> str: + """ + Makes a call to the LLaVA service to generate text based on a given prompt + """ + + prompt, images = llava_formater(prompt, order_image_tokens=False) + + for im in images: + if len(im) == 0: + raise RuntimeError("An image is empty!") + + return llava_call_binary( + prompt, + images, + config_list=llm_config["config_list"], + max_new_tokens=llm_config.get("max_new_tokens", 2000), + temperature=llm_config.get("temperature", 0.5), + seed=llm_config.get("seed", None), + ) diff --git a/autogen/agentchat/contrib/multimodal_conversable_agent.py b/autogen/agentchat/contrib/multimodal_conversable_agent.py new file mode 100644 index 00000000000..088861bb6d8 --- /dev/null +++ b/autogen/agentchat/contrib/multimodal_conversable_agent.py @@ -0,0 +1,107 @@ +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +from autogen import OpenAIWrapper +from autogen.agentchat import Agent, ConversableAgent +from autogen.img_utils import gpt4v_formatter + +try: + from termcolor import colored +except ImportError: + + def colored(x, *args, **kwargs): + return x + + +from autogen.code_utils import content_str + +DEFAULT_LMM_SYS_MSG = """You are a helpful AI assistant.""" + + +class MultimodalConversableAgent(ConversableAgent): + def __init__( + self, + name: str, + system_message: Optional[Union[str, List]] = DEFAULT_LMM_SYS_MSG, + is_termination_msg: str = None, + *args, + **kwargs, + ): + """ + Args: + name (str): agent name. + system_message (str): system message for the OpenAIWrapper inference. + Please override this attribute if you want to reprogram the agent. + **kwargs (dict): Please refer to other kwargs in + [ConversableAgent](../conversable_agent#__init__). + """ + super().__init__( + name, + system_message, + is_termination_msg=is_termination_msg, + *args, + **kwargs, + ) + + self.update_system_message(system_message) + self._is_termination_msg = ( + is_termination_msg + if is_termination_msg is not None + else (lambda x: any([item["text"] == "TERMINATE" for item in x.get("content") if item["type"] == "text"])) + ) + + @property + def system_message(self) -> List: + """Return the system message.""" + return self._oai_system_message[0]["content"] + + def update_system_message(self, system_message: Union[Dict, List, str]): + """Update the system message. + + Args: + system_message (str): system message for the OpenAIWrapper inference. + """ + self._oai_system_message[0]["content"] = self._message_to_dict(system_message)["content"] + self._oai_system_message[0]["role"] = "system" + + @staticmethod + def _message_to_dict(message: Union[Dict, List, str]): + """Convert a message to a dictionary. + + The message can be a string or a dictionary. The string will be put in the "content" field of the new dictionary. + """ + if isinstance(message, str): + return {"content": gpt4v_formatter(message)} + if isinstance(message, list): + return {"content": message} + else: + return message + + def _print_received_message(self, message: Union[Dict, str], sender: Agent): + # print the message received + print(colored(sender.name, "yellow"), "(to", f"{self.name}):\n", flush=True) + if message.get("role") == "function": + func_print = f"***** Response from calling function \"{message['name']}\" *****" + print(colored(func_print, "green"), flush=True) + print(content_str(message["content"]), flush=True) + print(colored("*" * len(func_print), "green"), flush=True) + else: + content = message.get("content") + if content is not None: + if "context" in message: + content = OpenAIWrapper.instantiate( + content, + message["context"], + self.llm_config and self.llm_config.get("allow_format_str_template", False), + ) + print(content_str(content), flush=True) + if "function_call" in message: + func_print = f"***** Suggested function Call: {message['function_call'].get('name', '(No function name found)')} *****" + print(colored(func_print, "green"), flush=True) + print( + "Arguments: \n", + message["function_call"].get("arguments", "(No arguments found)"), + flush=True, + sep="", + ) + print(colored("*" * len(func_print), "green"), flush=True) + print("\n", "-" * 80, flush=True, sep="") diff --git a/autogen/code_utils.py b/autogen/code_utils.py index 9965609f1b8..5e65a65f11c 100644 --- a/autogen/code_utils.py +++ b/autogen/code_utils.py @@ -1,14 +1,15 @@ -import subprocess -import sys +import logging import os import pathlib -from typing import List, Dict, Tuple, Optional, Union, Callable import re +import subprocess +import sys import time +from concurrent.futures import ThreadPoolExecutor, TimeoutError from hashlib import md5 -import logging +from typing import Callable, Dict, List, Optional, Tuple, Union + from autogen import oai -from concurrent.futures import ThreadPoolExecutor, TimeoutError try: import docker @@ -29,6 +30,19 @@ logger = logging.getLogger(__name__) +def content_str(content: Union[str, List]) -> str: + if type(content) is str: + return content + rst = "" + for item in content: + if item["type"] == "text": + rst += item["text"] + else: + assert isinstance(item, dict) and item["type"] == "image_url", "Wrong content format." + rst += "" + return rst + + def infer_lang(code): """infer the language for the code. TODO: make it robust. @@ -46,12 +60,13 @@ def infer_lang(code): def extract_code( - text: str, pattern: str = CODE_BLOCK_PATTERN, detect_single_line_code: bool = False + text: Union[str, List], pattern: str = CODE_BLOCK_PATTERN, detect_single_line_code: bool = False ) -> List[Tuple[str, str]]: """Extract code from a text. Args: - text (str): The text to extract code from. + text (str or List): The content to extract code from. The content can be + a string or a list, as returned by standard GPT or multimodal GPT. pattern (str, optional): The regular expression pattern for finding the code block. Defaults to CODE_BLOCK_PATTERN. detect_single_line_code (bool, optional): Enable the new feature for @@ -62,6 +77,7 @@ def extract_code( If there is no code block in the input text, the language would be "unknown". If there is code block but the language is not specified, the language would be "". """ + text = content_str(text) if not detect_single_line_code: match = re.findall(pattern, text, flags=re.DOTALL) return match if match else [(UNKNOWN, text)] diff --git a/autogen/img_utils.py b/autogen/img_utils.py new file mode 100644 index 00000000000..a8e1a96876a --- /dev/null +++ b/autogen/img_utils.py @@ -0,0 +1,170 @@ +import base64 +import mimetypes +import re +from io import BytesIO +from typing import Any, Dict, List, Optional, Tuple, Union + +import requests +from PIL import Image + + +def get_image_data(image_file: str, use_b64=True) -> bytes: + if image_file.startswith("http://") or image_file.startswith("https://"): + response = requests.get(image_file) + content = response.content + elif re.match(r"data:image/(?:png|jpeg);base64,", image_file): + return re.sub(r"data:image/(?:png|jpeg);base64,", "", image_file) + else: + image = Image.open(image_file).convert("RGB") + buffered = BytesIO() + image.save(buffered, format="PNG") + content = buffered.getvalue() + + if use_b64: + return base64.b64encode(content).decode("utf-8") + else: + return content + + +def llava_formater(prompt: str, order_image_tokens: bool = False) -> Tuple[str, List[str]]: + """ + Formats the input prompt by replacing image tags and returns the new prompt along with image locations. + + Parameters: + - prompt (str): The input string that may contain image tags like . + - order_image_tokens (bool, optional): Whether to order the image tokens with numbers. + It will be useful for GPT-4V. Defaults to False. + + Returns: + - Tuple[str, List[str]]: A tuple containing the formatted string and a list of images (loaded in b64 format). + """ + + # Initialize variables + new_prompt = prompt + image_locations = [] + images = [] + image_count = 0 + + # Regular expression pattern for matching tags + img_tag_pattern = re.compile(r"]+)>") + + # Find all image tags + for match in img_tag_pattern.finditer(prompt): + image_location = match.group(1) + + try: + img_data = get_image_data(image_location) + except Exception as e: + # Remove the token + print(f"Warning! Unable to load image from {image_location}, because of {e}") + new_prompt = new_prompt.replace(match.group(0), "", 1) + continue + + image_locations.append(image_location) + images.append(img_data) + + # Increment the image count and replace the tag in the prompt + new_token = f"" if order_image_tokens else "" + + new_prompt = new_prompt.replace(match.group(0), new_token, 1) + image_count += 1 + + return new_prompt, images + + +def convert_base64_to_data_uri(base64_image): + def _get_mime_type_from_data_uri(base64_image): + # Decode the base64 string + image_data = base64.b64decode(base64_image) + # Check the first few bytes for known signatures + if image_data.startswith(b"\xff\xd8\xff"): + return "image/jpeg" + elif image_data.startswith(b"\x89PNG\r\n\x1a\n"): + return "image/png" + elif image_data.startswith(b"GIF87a") or image_data.startswith(b"GIF89a"): + return "image/gif" + elif image_data.startswith(b"RIFF") and image_data[8:12] == b"WEBP": + return "image/webp" + return "image/jpeg" # use jpeg for unknown formats, best guess. + + mime_type = _get_mime_type_from_data_uri(base64_image) + data_uri = f"data:{mime_type};base64,{base64_image}" + return data_uri + + +def gpt4v_formatter(prompt: str) -> List[Union[str, dict]]: + """ + Formats the input prompt by replacing image tags and returns a list of text and images. + + Parameters: + - prompt (str): The input string that may contain image tags like . + + Returns: + - List[Union[str, dict]]: A list of alternating text and image dictionary items. + """ + output = [] + last_index = 0 + image_count = 0 + + # Regular expression pattern for matching tags + img_tag_pattern = re.compile(r"]+)>") + + # Find all image tags + for match in img_tag_pattern.finditer(prompt): + image_location = match.group(1) + + try: + img_data = get_image_data(image_location) + except Exception as e: + # Warning and skip this token + print(f"Warning! Unable to load image from {image_location}, because {e}") + continue + + # Add text before this image tag to output list + output.append({"type": "text", "text": prompt[last_index : match.start()]}) + + # Add image data to output list + output.append({"type": "image_url", "image_url": {"url": convert_base64_to_data_uri(img_data)}}) + + last_index = match.end() + image_count += 1 + + # Add remaining text to output list + output.append({"type": "text", "text": prompt[last_index:]}) + return output + + +def extract_img_paths(paragraph: str) -> list: + """ + Extract image paths (URLs or local paths) from a text paragraph. + + Parameters: + paragraph (str): The input text paragraph. + + Returns: + list: A list of extracted image paths. + """ + # Regular expression to match image URLs and file paths + img_path_pattern = re.compile( + r"\b(?:http[s]?://\S+\.(?:jpg|jpeg|png|gif|bmp)|\S+\.(?:jpg|jpeg|png|gif|bmp))\b", re.IGNORECASE + ) + + # Find all matches in the paragraph + img_paths = re.findall(img_path_pattern, paragraph) + return img_paths + + +def _to_pil(data: str) -> Image.Image: + """ + Converts a base64 encoded image data string to a PIL Image object. + + This function first decodes the base64 encoded string to bytes, then creates a BytesIO object from the bytes, + and finally creates and returns a PIL Image object from the BytesIO object. + + Parameters: + data (str): The base64 encoded image data string. + + Returns: + Image.Image: The PIL Image object created from the input data. + """ + return Image.open(BytesIO(base64.b64decode(data))) diff --git a/notebook/agentchat_lmm_gpt-4v.ipynb b/notebook/agentchat_lmm_gpt-4v.ipynb new file mode 100644 index 00000000000..50e018076bb --- /dev/null +++ b/notebook/agentchat_lmm_gpt-4v.ipynb @@ -0,0 +1,766 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2c75da30", + "metadata": {}, + "source": [ + "# Agent Chat with Multimodal Models: GPT-4V" + ] + }, + { + "cell_type": "markdown", + "id": "5f51914c", + "metadata": {}, + "source": [ + "### Before everything starts, install AutoGen with the `lmm` option\n", + "```bash\n", + "pip install pyautogen[lmm]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "67d45964", + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "import json\n", + "import os\n", + "\n", + "from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union\n", + "\n", + "import autogen\n", + "from autogen import AssistantAgent, Agent, UserProxyAgent, ConversableAgent\n", + "from termcolor import colored\n", + "import random" + ] + }, + { + "cell_type": "markdown", + "id": "7e4faf59", + "metadata": {}, + "source": [ + "\n", + "## Application 1: Image Chat\n", + "\n", + "In this section, we present a straightforward dual-agent architecture to enable user to chat with a multimodal agent.\n", + "\n", + "\n", + "First, we show this image and ask a question.\n", + "![](https://th.bing.com/th/id/R.422068ce8af4e15b0634fe2540adea7a?rik=y4OcXBE%2fqutDOw&pid=ImgRaw&r=0)" + ] + }, + { + "cell_type": "markdown", + "id": "e3d5580e", + "metadata": {}, + "source": [ + "Within the user proxy agent, we can decide to activate the human input mode or not (for here, we use human_input_mode=\"NEVER\" for conciseness). This allows you to interact with LMM in a multi-round dialogue, enabling you to provide feedback as the conversation unfolds." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b1db6f5d", + "metadata": {}, + "outputs": [], + "source": [ + "from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent\n", + "\n", + "config_list_4v = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4-vision-preview\"],\n", + " },\n", + ")\n", + "\n", + "\n", + "config_list_gpt4 = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " },\n", + ")\n", + "\n", + "gpt4_llm_config = {\"config_list\": config_list_gpt4, \"seed\": 42}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "57462351", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['openai']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Remove the `api_type` param as it is not needed for 4V\n", + "[config.pop(\"api_type\", None) for config in config_list_4v]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e23df0dd", + "metadata": {}, + "outputs": [], + "source": [ + "# image_agent._oai_messages[user_proxy]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "67157629", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n", + "\n", + "What's the breed of this dog? \n", + ".\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mimage-explainer\u001b[0m (to User_proxy):\n", + "\n", + "The dog in the image appears to be a Goldendoodle, which is a crossbreed between a Golden Retriever and a Poodle. They are known for their curly, hypoallergenic coats, which can vary in color, and their friendly and affectionate nature.\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "image_agent = MultimodalConversableAgent(\n", + " name=\"image-explainer\",\n", + " max_consecutive_auto_reply=10,\n", + " llm_config={\"config_list\": config_list_4v, \"temperature\": 0.5, \"max_tokens\": 300}\n", + ")\n", + "\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"User_proxy\",\n", + " system_message=\"A human admin.\",\n", + " human_input_mode=\"NEVER\", # Try between ALWAYS or NEVER\n", + " max_consecutive_auto_reply=0\n", + ")\n", + "\n", + "# Ask the question with an image\n", + "user_proxy.initiate_chat(image_agent, \n", + " message=\"\"\"What's the breed of this dog? \n", + ".\"\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "3f60521d", + "metadata": {}, + "source": [ + "Now, input another image, and ask a followup question.\n", + "\n", + "![](https://th.bing.com/th/id/OIP.29Mi2kJmcHHyQVGe_0NG7QHaEo?pid=ImgDet&rs=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "73a2b234", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n", + "\n", + "What is this breed? \n", + "\n", + "\n", + "Among the breeds, which one barks less?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mimage-explainer\u001b[0m (to User_proxy):\n", + "\n", + "The dog in the image is a Siberian Husky. Siberian Huskies are known for their striking appearance, which includes a thick double coat, erect triangular ears, and distinctive markings.\n", + "\n", + "Between the Goldendoodle and the Siberian Husky, Huskies are generally known to be less prone to barking. They are more likely to howl or vocalize in other ways. Goldendoodles, being a mix of Golden Retrievers and Poodles, can vary in their tendency to bark depending on which traits they inherit from their parent breeds. Golden Retrievers are often quite vocal, while Poodles can be alert barkers. However, every dog is an individual, and their environment and training can significantly influence their barking behavior.\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# Ask the question with an image\n", + "user_proxy.send(message=\"\"\"What is this breed? \n", + "\n", + "\n", + "Among the breeds, which one barks less?\"\"\", \n", + " recipient=image_agent)" + ] + }, + { + "cell_type": "markdown", + "id": "0c40d0eb", + "metadata": {}, + "source": [ + "\n", + "## Application 2: Figure Creator\n", + "\n", + "Here, we define a `FigureCreator` agent, which contains three child agents: commander, coder, and critics.\n", + "\n", + "- Commander: interacts with users, runs code, and coordinates the flow between the coder and critics.\n", + "- Coder: writes code for visualization.\n", + "- Critics: LMM-based agent that provides comments and feedback on the generated image." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e8eca993", + "metadata": {}, + "outputs": [], + "source": [ + "class FigureCreator(AssistantAgent):\n", + "\n", + " def __init__(self, n_iters=2, **kwargs):\n", + " \"\"\"\n", + " Initializes a FigureCreator instance.\n", + " \n", + " This agent facilitates the creation of visualizations through a collaborative effort among its child agents: commander, coder, and critics.\n", + " \n", + " Parameters:\n", + " - n_iters (int, optional): The number of \"improvement\" iterations to run. Defaults to 2.\n", + " - **kwargs: keyword arguments for the parent AssistantAgent.\n", + " \"\"\"\n", + " super().__init__(**kwargs)\n", + " self.register_reply([Agent, None],\n", + " reply_func=FigureCreator._reply_user,\n", + " position=0)\n", + " self._n_iters = n_iters\n", + "\n", + " def _reply_user(self, messages=None, sender=None, config=None):\n", + " if all((messages is None, sender is None)):\n", + " error_msg = f\"Either {messages=} or {sender=} must be provided.\"\n", + " logger.error(error_msg)\n", + " raise AssertionError(error_msg)\n", + "\n", + " if messages is None:\n", + " messages = self._oai_messages[sender]\n", + "\n", + " user_question = messages[-1][\"content\"]\n", + "\n", + " ### Define the agents\n", + " commander = AssistantAgent(\n", + " name=\"Commander\",\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " system_message=\n", + " \"Help me run the code, and tell other agents it is in the file location.\",\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\n", + " \"TERMINATE\"),\n", + " code_execution_config={\n", + " \"last_n_messages\": 3,\n", + " \"work_dir\": \".\",\n", + " \"use_docker\": False\n", + " },\n", + " llm_config=self.llm_config,\n", + " )\n", + "\n", + " critics = MultimodalConversableAgent(\n", + " name=\"Critics\",\n", + " system_message=\n", + " \"\"\"Criticize the input figure. How to replot the figure so it will be better? Find bugs and issues for the figure. \n", + " Pay attention to the color, format, and presentation. Keep in mind of the reader-friendliness.\n", + " If you think the figures is good enough, then simply say NO_ISSUES\"\"\",\n", + " llm_config={\"config_list\": config_list_4v, \"max_tokens\": 300},\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=1,\n", + " # use_docker=False,\n", + " )\n", + "\n", + " coder = AssistantAgent(\n", + " name=\"Coder\",\n", + " llm_config=self.llm_config,\n", + " )\n", + "\n", + " coder.update_system_message(\n", + " coder.system_message +\n", + " \"ALWAYS save the figure in `result.jpg` file. Tell other agents it is in the file location.\"\n", + " )\n", + "\n", + " # Data flow begins\n", + " commander.initiate_chat(coder, message=user_question)\n", + " img = Image.open(\"result.jpg\")\n", + " plt.imshow(img)\n", + " plt.axis('off') # Hide the axes\n", + " plt.show()\n", + " \n", + " for i in range(self._n_iters):\n", + " commander.send(message=\"Improve \",\n", + " recipient=critics,\n", + " request_reply=True)\n", + " \n", + " feedback = commander._oai_messages[critics][-1][\"content\"]\n", + " if feedback.find(\"NO_ISSUES\") >= 0:\n", + " break\n", + " commander.send(\n", + " message=\"Here is the feedback to your figure. Please improve! Save the result to `result.jpg`\\n\"\n", + " + feedback,\n", + " recipient=coder,\n", + " request_reply=True)\n", + " img = Image.open(\"result.jpg\")\n", + " plt.imshow(img)\n", + " plt.axis('off') # Hide the axes\n", + " plt.show()\n", + " \n", + " return True, \"result.jpg\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "977b9017", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to Figure Creator~):\n", + "\n", + "\n", + "Plot a figure by using the data from:\n", + "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\n", + "\n", + "I want to show both temperature high and low.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCommander\u001b[0m (to Coder):\n", + "\n", + "\n", + "Plot a figure by using the data from:\n", + "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\n", + "\n", + "I want to show both temperature high and low.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCoder\u001b[0m (to Commander):\n", + "\n", + "First, we will download the CSV file, then we will parse it using pandas, a popular data analysis library in Python. After that, we will plot the data using matplotlib.\n", + "\n", + "This is how we could do this:\n", + "\n", + "```python\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Step 1: Load the Data\n", + "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n", + "data = pd.read_csv(url)\n", + "\n", + "# Step 2: Parse the date to datetime format\n", + "data['date'] = pd.to_datetime(data['date'])\n", + "\n", + "# Step 3: Plot the Data\n", + "plt.figure(figsize=(10,6))\n", + "plt.plot(data['date'], data['temp_max'], label='Temp Max')\n", + "plt.plot(data['date'], data['temp_min'], label='Temp Min')\n", + "\n", + "plt.title('Seattle Weather')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Temperature (F)')\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "# Save the figure\n", + "plt.savefig('result.jpg')\n", + "\n", + "# Display the plot\n", + "plt.show()\n", + "```\n", + "\n", + "When you run this code, it will load the data from the given URL, parse the 'date' column to datetime format, then plot the \"temp_max\" and \"temp_min\" over time. The resulting plot is then shown to you. The plot will automatically be saved as 'result.jpg' in the current directory. I will also submit these instructions to other agents.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mCommander\u001b[0m (to Coder):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Figure(1000x600)\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCoder\u001b[0m (to Commander):\n", + "\n", + "Great! The code has successfully executed and the plot was generated and saved as `result.jpg`. \n", + "\n", + "If you check the working directory, you should find the figure saved as `result.jpg`.\n", + "\n", + "Let me know if you need help with anything else.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mCommander\u001b[0m (to Critics):\n", + "\n", + "Improve \n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCritics\u001b[0m (to Commander):\n", + "\n", + "To improve the provided figure of Seattle Weather, here are a few suggestions:\n", + "\n", + "1. Data Overlap: There is a significant overlap between the Temp Max (in blue) and Temp Min (in orange) data series, which can make it difficult to follow individual series, especially in cases where Min and Max temperatures are close. This can be improved by either using a line plot with less opacity, applying smoothing to the data lines, or by representing one of the data series in a different manner, such as with a filled area chart underneath the line plot.\n", + "\n", + "2. Labeling: While the axes are labeled, it may be useful to provide units of measurement on the Y-axis label, to clarify that the temperatures are in Fahrenheit. Additionally, including a more descriptive title can help provide context.\n", + "\n", + "3. Grid Lines: The grid lines are helpful for reading the plot, but they could be made lighter or dashed so that they do not compete visually with the data.\n", + "\n", + "4. Date Format: The date format on the X-axis is quite compacted, which may make it difficult to read. Modifying the date formatting to show less frequent ticks, or rotating the labels to improve readability, could be beneficial.\n", + "\n", + "5. Color Scheme: The choice of colors should have sufficient contrast and be colorblind-friendly. Using two distinctively different hues or one line with markers can make it easier to distinguish between the two temperature readings.\n", + "\n", + "6. Legend Positioning: The legend is well-placed and doesn't overlap with the\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCommander\u001b[0m (to Coder):\n", + "\n", + "Here is the feedback to your figure. Please improve! Save the result to `result.jpg`\n", + "To improve the provided figure of Seattle Weather, here are a few suggestions:\n", + "\n", + "1. Data Overlap: There is a significant overlap between the Temp Max (in blue) and Temp Min (in orange) data series, which can make it difficult to follow individual series, especially in cases where Min and Max temperatures are close. This can be improved by either using a line plot with less opacity, applying smoothing to the data lines, or by representing one of the data series in a different manner, such as with a filled area chart underneath the line plot.\n", + "\n", + "2. Labeling: While the axes are labeled, it may be useful to provide units of measurement on the Y-axis label, to clarify that the temperatures are in Fahrenheit. Additionally, including a more descriptive title can help provide context.\n", + "\n", + "3. Grid Lines: The grid lines are helpful for reading the plot, but they could be made lighter or dashed so that they do not compete visually with the data.\n", + "\n", + "4. Date Format: The date format on the X-axis is quite compacted, which may make it difficult to read. Modifying the date formatting to show less frequent ticks, or rotating the labels to improve readability, could be beneficial.\n", + "\n", + "5. Color Scheme: The choice of colors should have sufficient contrast and be colorblind-friendly. Using two distinctively different hues or one line with markers can make it easier to distinguish between the two temperature readings.\n", + "\n", + "6. Legend Positioning: The legend is well-placed and doesn't overlap with the\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCoder\u001b[0m (to Commander):\n", + "\n", + "Thank you for your feedback. I'll implement the changes you requested. Here is the improved version of the code for plotting:\n", + "\n", + "```python\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "# Load the data\n", + "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n", + "data = pd.read_csv(url)\n", + "\n", + "# Parse the date\n", + "data['date'] = pd.to_datetime(data['date'])\n", + "\n", + "# Create the plot\n", + "fig, ax = plt.subplots(figsize=(10,6))\n", + "\n", + "# Plot Temp Max with a smooth blue line\n", + "ax.plot(data['date'], data['temp_max'], color='tab:blue', alpha=0.6, label='Temp Max')\n", + "\n", + "# Plot Temp Min with a smooth orange line\n", + "ax.plot(data['date'], data['temp_min'], color='tab:orange', alpha=0.6, label='Temp Min')\n", + "\n", + "# Improve date formatting\n", + "ax.xaxis.set_major_locator(mdates.MonthLocator(interval=3))\n", + "ax.xaxis.set_major_formatter(mdates.DateFormatter('%b %Y'))\n", + "plt.gcf().autofmt_xdate() # rotation of the x-axis dates\n", + "\n", + "# Add grid lines with styled properties, alpha for transparency\n", + "plt.grid(color='gray', linestyle='dashed', linewidth=0.5, alpha=0.3)\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Temperature (°F)')\n", + "plt.title('Seattle Weather: Max and Min Temperatures Over Time')\n", + "\n", + "# Set legend and it's position\n", + "plt.legend(loc='upper right')\n", + "\n", + "# Save the figure\n", + "plt.savefig('result.jpg')\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "```\n", + "\n", + "This script includes all of your feedback: it adjusts the opacity of the lines to distinguish between them, it includes units on the y-axis, modifies grid lines appearance, improves date formatting and adjusts the title to be more descriptive, changes color scheme, and positions the legend in a non-obstructive location. This code again saves the plot image as `result.jpg` in the current directory.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mCommander\u001b[0m (to Coder):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Figure(1000x600)\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCoder\u001b[0m (to Commander):\n", + "\n", + "Great! The code has been executed successfully and the improved figure was generated and saved as `result.jpg`.\n", + "\n", + "Please check the image `result.jpg` in your current directory to see the final improved figure with all your mentioned changes. \n", + "\n", + "If there's anything else you need assistance with, feel free to ask.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAE9CAYAAACWQ2EXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebRc11Xn/9nn3FtVb9BkSZY8yHZseYqnOIMTJ4Y4AQMB0p0JDKYJEBIWJNDNtICmf8BqoJvuRRPSvSAJoYEETEK6IYG4O2EIAeImZLSTeJIn2ZZlS7Jmvanq3nvO/v1xzrl1q/QkPVlVsR3VN3l+ejWce+6+Z9hnD98tqqpMMMEEE0wwwQSnLcwz3YEJJphgggkmmOCZxUQZmGCCCSaYYILTHBNlYIIJJphggglOc0yUgQkmmGCCCSY4zTFRBiaYYIIJJpjgNMdEGZhgggkmmGCC0xwTZWCCCSaYYIIJTnNMlIEJJphgggkmOM0xUQYmmGCCCSaY4DTHRBmYYIIJJphggtMcE2VgggkmmGCCCU5zTJSBCSaYYIIJJjjNMVEGJphgggkmmOA0x0QZmGCCCSaYYILTHBNlYIIJJphggglOc0yUgQkmmGCCCSY4zTFRBiaYYIIJJpjgNMdEGZhgggkmmGCC0xwTZWCCCSaYYIIJTnNMlIEJJphgggkmOM0xUQYmmGCCCSaY4DTHRBmYYIIJJphggtMcE2VgggkmmGCCCU5zTJSBCSaYYIIJJjjNMVEGJphgggkmmOA0x0QZmGCCCSaYYILTHBNlYIIJJphggglOc0yUgQkmmGCCCSY4zTFRBiaYYIIJJpjgNMdEGZhgggkmmGCC0xwTZWCCCSaYYIIJTnNkz3QHJvj6hKoO/FtE6t/H+076HHDcz34tcKL+rhTNNpaTy9cKTdmeCKPoW/N6zfaO1fZyrw/3ebnPnExfhz+7kn49neucyneGv5dkcKr3/kzPpwme3ZgoAxOMFKqKcw4RoaoqrLWUZYmIICJYazHGHLXAG2Pw3iMi9e/0OWMMzjkAjAnGrOYC2WyjuWg22xpWMprfbb5mra1fr6oKY0zdjvceY0z9Wmoj9T31zTlXf2a5xbt57dSOc448zwf632wzfbb5WrP/TRk1r9m8/2Yf0ufS99J9p/tsKmZZlh3VTrMfw5t+kslwH9K1ms8jfc57P9C/dB1r7VHjavi5pv5mWVbLv/m91HZ6Ttbageul15rPrjmm0rWan2++LiK17JtjxBhDWZZ1v461GTf7N/x36n/q8/AzaMq/Oa+WUyTSmJxgguUwUQYmGDmMMRw5coTHH38c7z3r1q1j06ZNA4us954sy+pFFPoL1+LiIsYYOp0OVVWxtLTEmjVrqKqKRx55hC1btmCtHVggmxvxwsICR44c4eyzz6YsS7Zv385FF11Eq9Vi165dTE9Ps3r16roPqT/NTSYtoAcPHmTNmjWICE888QRnnnkmnU5noL/D10/3mD7TRLrGjh076PV6XHrppQAcPnyYPXv2cMkll5Bl2VEKTFPBaW5YSd5J8WoqTcPKRBOqyuOPP87mzZtpt9tA2Fwefvhhpqen2bx5MwC7d++m1+tx/vnns3PnTjZt2kS73a4357TBpI3+4MGDPPLII/Xm7Jyj0+lw2WWXHaUELiendJ9pQ2/eV3MjbG72TbmKSK28pLYOHz7M2rVrqarqqGdcVRV5nh+lNA4rLM3vNDda7z1VVfHYY4+xsLDAhg0bOPvss+vnkGSQlK1mu8ObeVMJ3LdvHzt37hyYM2eccQbeezZv3szMzMzAvaTn12yvKZ8JJjgRJjEDE4wchw8f5ld/9Vf52Mc+xt/+7d/ywQ9+cOA01tyEgaNOX//n//wf/v7v/x4R4f777+fd7353vVj++q//Onv37h04ZSakNrZv386v//qvUxQFDz74ILfccgv33nsvZVnya7/2azz44IP1acs5N3BCbZ7aDx8+zK//+q/T6/UoioJ3vetdPProo1hrBzaEhLQppkX6WBARfvM3f5O3v/3tHDhwABHhd37nd3jLW97CgQMH6s81N8/lfqdTfNps0jXTRp02xGErhYhQliXvfOc7eeKJJ+rXu90uP/3TP81/+A//gaIoWFpa4hd/8Rf5mZ/5GcqyZPfu3czPz9cWlOZJM11nbm6Ou+66i49//OP85E/+JHfccQcPPvhgvRkmRWfYEpDuKz2PdA/pe81rNTfP5Sw8zbE0Pz/Pr/7qr3Lo0KGjxqAxprbGDI+l9G/nXG0hSn1r9rvX6/HOd76T3/u93+P222/nP/2n/8Rf//Vf1wrNctaF5vNJz29Y6du7dy933HEHf/zHf8yv/uqv8oUvfIEHH3yQHTt21M++aQ1oKonDCkD67AQTHA8Ty8AEI8fBgwfZvn07v/ALv8DatWvrhfyJJ57gQx/6EHNzc7z0pS/lO77jO7jvvvv42Mc+RlEUvOpVr+KFL3whH//4xzl8+DDbt29ncXGRj370o8zPz/OjP/qj9aL91FNP8aEPfYjdu3dzzTXX8PrXv55Op4Oqcskll7Bv3z4OHTrE3XffzQ033MBXvvIVLrzwQp566inOPvtsbrvtNr7whS+wZs0a/s2/+Tds3LiRD3zgAzz++OOcffbZ3HzzzXz2s5/lk5/8JHme8x3f8R0sLS3xN3/zN3zwgx/k6quv5o1vfCP79+/nwx/+MDt37uTaa6/lDW94A5/61Ke4++67KYqC1772tczMzLBlyxZarVYto1arxebNm/nc5z7Htddey44dO9iyZQsA99xzD3/1V39FVVW88pWv5IYbbuAjH/kIa9eu5frrr+e9730vN998M2eddRZZllGWJR/5yEe45557WLNmDd/7vd/LGWecwW/+5m9y1lln8cgjj/DN3/zNvPKVr+SBBx7g1ltvZc2aNezevfsoy8X09DStVosdO3ZQliVTU1N0u11EhHvuuYeNGzdy99138+Uvf5mFhQXa7TY/9EM/xLp16zDGsGXLFn7gB36A++67j8cff5wf+qEf4otf/CK/8iu/gojwr//1v+aqq67iXe96F6tXr2b79u3ccMMNHD58mLvuuos3vOENXHfddfzWb/0WMzMzPPHEE1x77bW87nWv48iRI3zwgx/kiSee4PnPfz5vetOb+OxnP8vnP/95AG666Sa2bdvGAw88wLp167jlllvYtm1brVh+67d+Kzt27OC1r30t69ev59Zbb+XGG29k27Zt3HPPPfR6Pb75m7+Z7du3c9ddd7Fq1Sp+4Ad+gHa7zR/+4R+yf/9+nve85/HmN7+ZPM8RET7/+c/z8MMP89u//dvMzMxw33338f/9f/8fF154IX/7t3/Lj/3Yj2GM4b3vfS+ve93r2LdvHx/72Mfo9Xp827d9G694xSt417veRbvdZmlpiR/+4R9mzZo1XHnllVx11VX89V//Nf/yL/9Sj/3/8T/+B1dddRWf+MQn2LNnD/v27WPz5s1ceOGF3H777Vx++eW88Y1vZGFhgQ9/+MM88sgjXHHFFXz3d38309PTX7tFYILnHCaWgQlGjs2bN3P11Vfz9re/nZ/+6Z/m9ttv58iRI7zrXe/iqquu4q1vfSsf+9jHuO+++1i9ejUveclLuPrqq3n3u9/N3NwcL3jBC/jO7/xO3vKWt3DjjTdy9dVX87M/+7O16Rrgv//3/86ZZ57J29/+dj7zmc9w55131qe+qakpzjvvPB544AHuvvtubr75ZrZt28ZXv/pVzjnnHO666y7+4R/+gbe97W2cf/75/P7v/z5VVXH55Zdz3XXX8dBDD/GRj3yEa6+9losvvpif+qmf4gUveAFVVTEzM8P3f//383//7/9l165d/N7v/R5r1qyp+/G5z32O7du3s23bNr7/+7+fjRs38gd/8AccOHBgwBRsreWbvumb+PSnP82nP/1prrnmGqampvDes3btWl70ohdx2WWX8e53v5unnnqK66+/ng9+8IP8xm/8BtPT02zatIlWq1WfWi+88EJe/vKXUxQFf/iHf0hRFPzjP/4jZ511FjfffDMf+MAH2L9/P7/xG7/BTTfdxE033cQTTzxRyzOdHFutFq9+9av5xCc+wd/8zd/wyle+sj6db9u2jYWFBXbu3Mldd93FLbfcwuLiIp/+9Kfrk29y36TT8K5du3jve9/LG9/4Rl7zmtfwu7/7u8zNzfHpT3+aDRs28KY3vYnf+q3fYuPGjXzbt30bf/AHf0BVVfzLv/wLxhje9ra38bGPfYy77rqL9773vczMzPCOd7yD++67j3/5l39h586d3HHHHdxyyy1cdtllXHTRRbzsZS/j0KFDvP/97+fKK6/k4osv5h3veAfXX3899957L3Nzc6gq9957LwsLC/Xmf8stt7Br1y4+//nP85a3vIUtW7bwR3/0R/zzP/8zO3bs4K1vfSuvfvWrB1wvd911F1dddVWtiF5wwQVMT08zNzfHtm3bePTRR3n44Ye58847UVXe9a53cdNNN3HzzTfz+7//++zfv5//9//+H61Wize/+c2sXr26tjwt9/OVr3yltnjt3LmT7//+7+f222/n3nvv5Qd/8Af5y7/8S/bt28f73vc+8jznR3/0R9m2bRuf/vSnv0azf4LnKiaWgQlGjjzP+aVf+iV27NjB3XffzW/8xm/wi7/4i9x9992ICLfffjuHDh3iyJEj/N3f/R379u3j4osv5uDBg8zNzTEzM8PMzAyzs7N0Oh1arRZr164F+ibWO+64g4MHD3L33Xdz4MCBgVOuiPCSl7yEf/qnf2Jubo5LL72Uj3zkI3z605/myiuvZPv27Tz88MO8973vpdvtYozhgQce4P3vfz/XXHMNxhh27dqFtZZWq8WqVavI85ypqSle8YpX8LznPY+NGzfy5JNP8tWvfpU9e/Zw7733sm/fPvbs2YOIcP3113POOecgIvzqr/7qgDkXgvl569at3Hvvvfzv//2/+aVf+iXuuOMOjDHceuut7N+/nwsvvLCW06WXXsqLXvQi/uiP/oi/+Iu/oN1u45wjyzL27NnDH/zBH3DVVVdRVRW7du3CGMOaNWt48YtfzOzsLACLi4vMz8/XikeKV2hCRHjBC17Af/kv/wVjDN/5nd/JbbfdNmBKd87x4he/mPPPP59LLrmE/fv3D/ipE4wx7Nu3j/vuu48PfehDVFVFr9fj0KFDrF27lhe+8IWsXbuWc889l2uuuQbvPWVZ0uv1yPOcb/iGb2DLli1ceeWVPPzww3z+85/nrLPO4qGHHmLPnj31fd5www2cffbZtRyuuOIKgPp9ay1r1qxhamqqVp7S/VRVRbvd5rrrruPcc8/lL/7iL3j00Ud53/vex+LiIlmWce211/LFL36Rd73rXVx++eX84A/+YN3GzMwMu3btql1EvV4P5xxnnHEGr3jFK/j7v/97jDF84zd+I3NzczzwwAP85V/+JQALCwscOnSI1atXc91117Fx48aB53A8074xhpe97GWcd955nHPOOVx33XVs2bKFNWvWcPjwYb70pS+xceNGtm/fzpNPPsmuXbue3mSe4LTBRBmYYOTodrts376dzZs3c+WVVzI7O0u73ebSSy/lW77lW7jsssuYn5/nvPPO44//+I95y1vewszMDLfeeisQlIlDhw6xtLSEtZZer8f8/DydTqdehK+55hpe/OIX8+IXv5jFxUXOPffc+voiwlVXXcV73/teXv3qV9cBjLfddhu/+7u/y65du3j+85/PW9/61jrg7IEHHuCss87ie77ne3jPe95Dt9vFe0+32+XQoUOsWbMGYCCToNVqccUVV3DxxRfXi/3mzZv58Ic/XJuRy7LkkUce4YILLqDVag1YB9rtNq9//eu58847Oe+882pf8P33389b3vIWVq9ezYc+9CEAHnjgAe644w7e+MY38ld/9Ve84x3vqCPWd+/ejTGG7/qu7+IjH/kIjz/+eC3HZp+ttUxPT9dm9IceemjguaW+rV69mm//9m8nz3NmZ2fr+I50Is6yrG47z3OKoqgD+oaxbt06LrnkEm655RZmZ2fpdrts3Lix3qQhBANmWUZRFEDwcRdFwZe//GXWrl3Lfffdxzd90zdx1VVXcdlll3HDDTfU7Xz84x8nyzKMMezcuZPp6WluvvlmPvzhD7N///76lJ2UzPXr13P//ffX8SjJgtFqtTDGsHXrVvbu3csP/uAPkmUZ1lqmpqb44R/+Yebn5/nlX/5lbrrpJi688EIAXv7yl/NLv/RL3HXXXVxwwQV8/OMfZ+3atbVb6Od//ufJsoxf+7VfY2pqiosvvpg3velNbNy4kYWFBc4999xaqRsOGj0RUhxDehYpJsMYwzXXXMP555/PDTfcwOLiImeeeeaK2pzg9MVEGVgBJsE3J4dut8snPvEJ9u/fT1EUvP71r+faa69l7dq1fPjDH+Yf/uEfOOuss/j+7/9+vuu7vosPf/jDbNq0iRe96EW0221e8YpX8Hu/93u8733v43u/93s577zz+LVf+zV+/Md/nAsvvJDp6Wl+/Md/nFtvvZUvfOELrFq1qva1ppPrRRddxEUXXcRLX/pSrLVcd9113HfffVxwwQVcfvnlHDx4kN///d+n3W5z4403ct111/GZz3yG3/qt32LNmjWce+65rFu3jm/5lm/ht3/7t3n961/PhRdeyNTUFMYYLrjgAtasWcOP/MiPcOutt/K7v/u7rF27lltuuYXNmzfT6XQQEbrdLn/6p3/KO97xDjZt2oRISLm84IILmJmZ4YorruClL30pZVly8cUXk+c5t9xyC3/+53/Oxo0befGLX0y73eZjH/sYb3vb27jmmmv47d/+bR566CEuvvhivPdccsklbN26tTa3X3bZZYgIl1xySZ0psHXrVlatWsVP/MRP8MEPfpC1a9dy3XXX1ZkREDblSy65hDzPeeMb34gxhgMHDnDhhRfW9zw1NcWGDRvodrsAbNy4cdm0t6mpKS666CLOP/983vrWt/LBD34QEeH5z38+559/Plu3biXPc7Isq//tveeiiy7CWkun0+Ghhx7ii1/8Ii9/+cu58sor2bJlC3/yJ3/Cu9/9blatWsWb3/xmNmzYwMzMDMYYrrrqKs4991ze+c53snHjRi6++GLa7XbtnnjNa17Dm970Jt7//vdz5513cuWVV9JutznzzDNrReimm27i0KFD/P7v/z6dTofXvOY17N+/n4985CP0ej1uuukmtmzZUt/n1q1b+Zmf+Rn+/M//nG63y5lnnskv//Ivk+c55557bm2t2bJlC8YYfuzHfoyPfvSjVFXFxRdfXI/H6enpo9JiVbVWLBK2bt1Kq9XinHPOYf369fW/16xZg7W2dlO89a1v5dZbb+U973kPq1ev5vu+7/vq+5xgZTjd0jBFJ6PjKCyX7jTByeNY6XVNc/lyfy/33eU+c7zXV3Kd5fp3rL6caGFYyWdOBk+nvZV+Z9R9XQmONRaaSDEfVVXxIz/yI/z8z/98rdgMt3W8dk70DFf6PJv9XUn/T0auX6tn8Ew8669HnA4ynCgDy2A4fQhOj8EwwQTPNKqqwjnHtm3b2Lp1KzMzM890lyaYAPj63wMmysAymIhkggm+9mhyBiQugwkmeLbg610ZmMQMHAPee5aWlvj85z9PURQnHdyzUoyjzXG1Pc6+jrP958pzey7d/zjabrY1TB40yrZHjeda28+VdWHcbtrh8TZMXqWqtNttrr/++gGOkK9XTJSBY0Ak0Jj+xV/8Bf/qX/2rOu0pBWSd6gBtpiIBNX/5KGCModvtkmVZTc16qki55ktLS7Tb7ZEu0gBLS0t1tsAo+ptQFEUd/T4KJrZE/eucqxeIZ/tYcM5RFEXNYzAqJCreqampOhNiFBjVWEgLemKa7PV69fwdBVL/ut1uPSdGuXEtLS3VwZFN2u6nC2MMS0tLtFqto+ozLIfmAWiY6REGC4v1er2BYNRRoaoqYLRzAqjTV4dTfofv+c/+7M+49tprJ8rA6Yw0QC655BJe9apX1ZvAqAfFuAZ7Svcatal11AtqQrfbHctiUpZlTYIzKqRNcBxjIaUAjhKqSlEUI39u45LDOMaCqlKW5VgW9efSnGhugidC2hRXckIflwzGNSeKoqjTf5dDOjh87nOfq61UX+9uq4kysAzSKacsy4GiME0+8FNtHwZNoaP2Rw1XlTsVNBeB5SrjnSqGudZHieFCRqPod/OkNMqxkLj4xzEWmkVsRt32sLn1VDDqsdDs33D9gVGgWeVx1GO3OdeOV3RqpWjKNrV7sn0Zbi9ZXZIFbtTybSrzo7S6pEqqzRop6Rmmn6SIjOPZPhsxUQaWQdJEk+aYBvioSoA2zVDNwThKDBeSGQXS5Bk1krzHEaDTJLcZVZpVs4zxqJDGwjgwjv4CRy2mo2ozjYVRpsUZY8isRZqZQiNQXJKiOY6xmzbXUcZknNy6EO5vYWGBI3NzgEEFFDAIhlQZEqrKsbi4OPBtLyY1g4giGv84Rt+W41mAQXdEkvdwPEnzM802mgXJmsXIEtFTUrKSMp7nOWvWrKnX/tMpNXOiDCyDpv/oWPnJpzJAhgfuKAdccwI18XTbH77/UVsyhid8wijbby4ip9r2cv0dpbVhHLId/vcoF7flLA6nMtbS79HMMzBigTjPBnzkSlTx4RTFMeqxkNpsnuBPtf2TXRfC9T0gzM3Ps3r1GtpTbZSwnQtg1Nd/eO+xpm9GVxGSLcHEz4sKQe6KV6Wq3LKKerI4DFfkTEpA8+/md4etVM37a67lTQtJUsDT63NzcywsLNQF1oDTwioAE2VgRRiXhjgO98A42m5uUuOaGOOSw3D53lFhXGNhnONhHBiXxWE0GNwURAyI0N/ORhsEO2o059qo1p8VjzERFIt6xYihlRtyqQAPOIKVoFOrVIiP8o191wpL0Ve4sKhYNKoGBsX45RWepksgy7L6FJ/eS38nmZRlWZeiTp9pnvibr6e2m67f5iGh0+kwNzf39AX8HMZEGVgBkib5dP1tx0LSfEeNZn9HscGk76eAsVEHCiWz3Shlm9D0E49KkTkV3+uxkMbCqJWtdMJM/R21a6OqqpEGaI5jLCSrgHMubl6NNuXpqwSpj+OQLVBvcqNSuJrrwgnbTHqUCQJS1biRH61INf+SIS+A9t+pP5U+8v4PfIAHH3iAHTt2sHXrVl75yldy44031mZ9GIzuN8ZQluVRrqk8z2v//q233srOnTv52Z/9WZ544gl+4Rd+gf/6X/8rmzdvrjOKhi29w8/u6z1Q8FiYKAMrxDj8rqnNUaPpxxx1f8cxUcbpd20GBI0K4+jvOGWb2h/HCX7UmRojl61EGYhBsgyP1puRIKdUw32csgXqokOjQpLtyvqrGA3mfK/gJKMgw0sW3C9AWysEBVXEe6Qxfr1YekwBYEQwCpboXiC4F/7N930fe/bs4V3vehc/93M/x1/8xV/wH//jf+R5z3seN998M//5P/9npqamKMuSrVu3ct999/Ga17yGDRs28P73v78uPPXWt76VPM9xzrFnzx4eeOAB9uzZw6c+9SmWlpaoqoovfOELfOpTn6LVavFDP/RD3HvvvRw5coTNmzdz//33833f931HWWJON5wezpARYLk821G02Yz0HnXbo8a4LBkwvsk3bNEZFcbRXvNEPGqMo91x9Xm07SmK4rxSOkfhPA9sf4yFXokf0WXG9cyqqhr52rDSdUxQhArRKgQIIjxxaJ77ntjHV544wFd3HeLu3YvcvXsp/nS5a9cCd8efu548wpefPMg9Tx5g2xNPcahb4lK76lAtyTJbKzzbtm3j9ttv56qrruLv//7veeSRR9ixYwff/d3fXVNSv+lNb+JTn/oUhw8fZn5+nne84x3s27evrr5pjKHVanHdddfxqU99ih07dtTFvM477zxe+MIXsnPnTj7zmc9wzTXXcPvtt/NHf/RH3HjjjQMuhdMpaLCJiWXgJDCOAfJcGnTpJDiutseBcZ3axoFx9nVcY3dclq3RoBHuZgQ1lsI57vjKXaxau5bOs5xIZlwZNicL0XCi3/vUAR7dvRcnbbzJKKSNV+lbWoypnQJGK9r0MK7E+oIzrplGOnm/TQSB2jV2+PBhZmdnWbduHT/wAz9QV2LcvHkz69evZ8uWLWzevLlmg12/fj3T09Ns2LCBhYWFASvotddey3vf+16+4Ru+gd27d1MUBX/6p3/KxRdfzIYNG9i3b19dVbQsS1atWvWskPMzjYkycBIYh9Y4Ti105P3VfvQ42gjPOgW/a930UPT0qDAui87Jy3a5Pgx+91i55Nr4hzTbWcG1m30dNZJlaxztrngspCj58OFgsh76SDB1C4qGTchmOMxKxHfCfjb7O+p5PE6L4Yn6qwhIhoqiAjmeqy46m6suOju4XGI0gJEwIlV1IJvAq+JRvA/ZA1YM4V1BJUPxIH0in6uuuopPfvKTPPLII1hrufbaa5dNCUxZA3fddRd//Md/zIMPPsh3fdd31dc1xjA7O8uv/MqvsGbNGt73vvfVJ/6DBw/yxBNPcO655/LJT36SCy64gBe/+MX85V/+JT/wAz9w2mQNHAsTZeAkMcoJP87o8VG27wHjozYvIeUoeVtVYtDQiO5jXCfYUT+35u/joT41KQRJQgqm0mYc23K+8sb+rZIUgfCjmPrQe7xeDKdajRLjjPVI7R8LIWU9yELUo9gwTgHUxc/EwSkWiydDKRB6tDA2O2UFdhTplCdqf1yZGiduV2ISYOAHsHjaxsS57/Des9DrMTU1hTWR9pmmCzGeFiS0I9JX2sJzMVgrnHnmmfzUT/0UmzZt4ud+7ud48sknmZmZYd26dfzsz/4ss7OzvPa1r2Vqaoosy3j729/OU089xYte9CJuuOEGXve613HmmWcCQXm65ZZbmJ2dpdPp4L3nLW95C+vWrePf/bt/x+OPP85rX/taZmZmWFpa4pu+6ZvIsozdu3dPLANMlIEVYxwTc5SFWIYxsrRCEbyCqeKGYsICoYUDaykstEZgGWj67MahcI2Cwa2Jk28rbeTp34PulhNlfvSVCgX1YZEVOaHchzkWRo1xPLOVjoWgX3nwPby06ZqMlnpy3wMs2ByC55scJcezJEKRrcKpwY7AMjBO2TZT7EYl32Z0/onalKgISFK6RBBywKA4yqqkoyGgMDVVW67EBIV12bUhEBUZMbTbbc4991wANmzYwIYNG8InVDnvvPNQVTZs2IBIIAU666yzWFxc5JprruGqq64aaNUYUysG6e+zzz4bgKmpKdavX1+/1+THOP/881csv69nTJSBFaIZLDWqiZlSZcahEKTN5dR9/Glyh3/3KodBaFvDwflFlqywedXUKV4j+A5XlPJ0kkgBhKNk93s6Y0FFQI/9LIwxdT2J5ZCuohIpXERWZIxJi+i4UljHUZugORaOe/3keRaDGmH3wUXOmMpY17bUypaG7DhSaqHtp7sNJRmeNNKmOup1ISGl8Y461baZt38s1FYoqcCUIFW9uQcYxE9h1KIlVE5pt6MVgGDJUvGxjXr0NmTeTDlcGZJSf+GFF7J169YVf2+CleH0dpKcBNLGOuqNatTpQwmjSlWrU4Hw4Y+8TRdDZYV7HnmML257ED8CM3STf3yUZu2USjVK/+vJjIW0qCqCl/5PWCD797ncWAgLKiDBYIuAR/Bi4rKqA20sh5SfPa60xXHQaZ8MF70S3ABdD//8hXt4ZOdewAYZiUSZheC2cRSAGse6kJA27FHKNxUvO3GbCjgEh4oPK4AEpVZF8OJRW+EMdF3BQm8BNQrGo+Ib35GYzumRtI7Edk8Gw6yCE7P+6DFRBlaIYaKZUSCd2sYRKDS6lMWwKCCKB470CvYcPsKiVxZUmC/9CbajlWFcp6sm+dKosPKxEHKwifnac0s9Ds4vUsW/0f7zOdZY0PSfSP1aouydW6Dr3LLBcsNonl5HjXG1u1ISn7Rdadz4F0tHz2v4uxFqKdAnHUqGrhGMhyTbcaSuQr+i6TgsZSeWraBqQhChtvC0qVyOV4v6sMGXtkslFZUtqLIeJWX425Q4IsGTGkQNohY0i39bVG2cGoOEbsOyTPOhqXgt93lfP18d+EnvV1U18PfwzwQTN8GKMY5gqdTmOAbjKIl21HvQYIrdte8A9zy0g9e+6uWUGLzJRqIMNGU7DmKncTy3lbWpqEKpwgOPPsnup/Zz4ytehLUERSFEXx6zzRAaF7Y9RVishE9/aRvXX3sJ56yZQjRR7B4b4yS3Gj4Vj2qTXZHVRcCYmKKm4I2l8npULIXQtwx4H8SeouBHEUQ4riDKcch2xWNBAW8QMaAtvLcsLfZYM9vBKFCC+nYYnRqogJ1mhDDj4CzIkiZbB7oK/VgZ5VP/8Cn2799fK5VXXnklV1xxxVH1LlLlwqTENBWEZqyNqnLvvfeysLDAi1/8YrrdLp/61Kd4xStewZe//GVe8IIXsHbt2qPYQ8ex7jwXMVEGVohxkg6NA6Psb+3pM7DQq+iV/TOXq8aT/jSqiTlKWuYmVixb9YhYVGC+V3FkqQcWSqfYEPoO9E+Ywwt1uIpHqABLiXBoqQx5CTGQcCV9HTfp0DOzkCbLSJRhcqvU7hNTv6te8d7Rp9atv3bqvRjTyXJcFNIrCh6MslQF74N1S7QCXyHqyFBahaflgBIolLYPoYWx9+ArMDHGRQXMoJvmrLPOptvt8sEPfpCf+ImfYN++ffzVX/0Vl1xyCRdffDGf+9znKIqCdrvN5s2bue+++7j++usB2LZtGwcOHOB5z3sel19+eX1ft912G1/96lf5nd/5He644w5+/dd/nVtvvZVVq1aR5zl33HEHVVVx+PBhrr/+elavXj3WQO7nEiZughViXGk+4zpVjK6/ghgLGFQJucQm6pBeEd8wVevQz9O94rPcMgAr72OKGPAANsfbPJR5MXGl1f4paLl+pu+HCnJKBVSSUfkUpr0CNrkx+VjH6S9f0fWVhh+6P/Ak+qfTxhQsA6FQUUpwG5Ta8MA9ucE7rvsf17hdeUqsQ8Xh3CJFMYevjuCLQ6g/jCn2MuN2k5V7aFe7mXa7MeUeqJ6KP3vBHwR3ENwhYBHohUBECTNi69aLuPrqqznnnHPYtGkTn/zkJ5mdneWP/uiPeOyxx/hv/+2/cfDgQf7sz/6Mj370oxw4cIA//dM/5ZFHHuGd73wnnU6HP/iDP2D37t21vFqtFueddx5f/vKX+cIXvsCLXvQiqqriIx/5CHv37uXd7343999/P3feeSf/+I//+Awqss8+TCwDzyDG7asaSfsKYMA6RCyVg15lMArOGNT3SUdk+GuaQudObjN6pk5Do0baikSVnJAJ4CWLNdziqV76hCpHN6CRz11AMsDQBpztIMZEN8MK+jHGcTYs26+lnJs5AQZwmk6h9HkZVDCRd6AwGYVX1DskKld1DAG+z10gNt7HM286fqZkG7IAItOA71F2PQf3PMnOQ/uYzQWqJcpqjs5Um6LbRauKdqeNtQZRRdWgZhpvciosZ114KdPrNzVyCMK/kuXugQce4N577yXPc3q9HgBnnXUWr3rVqzh8+DBnn302V1xxBe9+97vx3vOCF7yAG2+8kYcffphHH32Us846K7Qrwjd8wzdw2223sXHjxoF0QhFh9erVfMd3fAcPPPAAd955J1VVjTTT6LmMiRRWiFGa9NOkHufEHp1pOEatmx7oNNYYKulgFXrGoN5Gc3VYiPuXjOdhgeGc+uP1d9QyafoGR9X+yseC4MUiviIXjzUZDksGWHWoyVCVUBhumX4FD6sLEdy0QWHKl5Sa42sF65lzE9T9HPFmtZKxUOdiaKw5DxjTRlXwHiqb0dJImOMKKtvi0X1LLLXawSrjqyBTGml0MdiTaEE4MYvD+F19o5btyl0PEosSKd5niOacsW4TrfUb6cy08cUSRdGlMzNDubSIliWt6WlMZghFHwTUh7LFYsln1gIZSgYalC1rgzWsqio2b97M1q1befOb38zCwgKbN28eyK5pt9sYY+qNe9u2bezYsYMdO3bwqle9CugHXG7evJnnP//5XHXVVfzd3/3dQGxWuvf03LIsqxWCZ1rxe6YxUQZOAqMk/oDxWwZG1t/4u9/dsOnrwLvx7zjR0GCaVVa+UI5bORo1cctJ9iD24xjvnsRYONlRM+5FbhzK7crSNvsRAwCVczGd0OCis8AaQC2Vh6/e+zBm3Zl4sThttCCgamPGTCTaWeG9PNfS3Fbe174DpjRtCumQT0+TtzNa7YyiXbHYU+yqGbp5l6LXY92qVcEygGLUQ7UE1oCxIQuBLNgJ6zVCmZqa4qUvfSmXXXYZ3/RN38SHP/xhzj77bM455xyuv/562u12XVOg3W7zwhe+EGsta9eu5aMf/SgveclLeN7znlePwSuuuIL169fzQz/0Q6gq+/btY2Zmhhe84AXMzs7WbW7cuJHLLrtsbDwvz0VMlIEVImmX42h3HBiZv7HWBOIv7W9qgV8gugdE8Cp4DRXiMkNt4l5JL4b5x0eFcfrLnw40+atri8Vgm+OwjIxr7MLRTIyjiniHkxsLAiEmQAxOhZ4PZENGQUxO5RyLpceWjtInZn2NXgXBCzjnMSLBmiDNxMTlMW4LX1O2o7rOypk+FQNRIbCUkqMYCtOiZS1lCUKFUcFgsCrgFWOTgpVBPotKyPSI5q86ZlNRrAjr1q3jTW96EwCvfvWruemmm+r7vfnmmxERbrjhhvpU/7rXvY4777yTiy++mJ/4iZ8ABgnWbrzxRvI8p6oqRIRv/dZvJcsy3vCGNwDw3d/93QBs3bqViy66KNzpJG4AmCgDK8aozYFpU33WZxM0mkjzJcQIRDUgnrBUwQnsOzTHgw8+ynUvvCIuDCvrwzj9+k3T4KjafzqyDYchiVbUZhz8ytus7yHK/URI9z3OiPdl+3cKWOlYaBiq4mk+bF77Ds9zx8OPc8M1l9BqhUp5TqFUE2ItbI5Lli0NdDiFd3zl7vvZuP4MLjhnU6P1Y6ccjNvCN2zWbl7z6SK5CU6sHCpGHRkGKz72AcrKo2qxxqLqiIkGYDI0hmym6CEf1wcTu1zTGgNEs33zflKwb7rXY6UbP//5z+fCCy+syZPSvYgI7XYb7z15ntevLeduaSpy6XqJM+N0VQwm2QQrQHNBHeXEbw7EUWN0pEO1gTts+JHsJm1stVIDOODAQpedTz0VV4CV+bRTf0e14A30fQxKRpP05MSQPleg+nAKdQxoVql/K2lTY/aBT9kEK7ivUY6Fwb7oQFrWqMby0yPxiWNShAOH53h45x6KquqPPgnpnD7GGOAdJmZpeKBbeR7asYcDh4/U430liuzJjYWTwzhS3lY6FkLwZYVohfgKUY9IsJhYFHUFzitiw7x3kd8hFd/yMaDYohhVjHeIrzBaIVqEtuNnkxLQ3NTT7+aamzbvqakp1q1bV1u8hjOG0r+b7aSfYQUjzT3n3MB6fDoSEU0sAytA0j5HmUaVBt7KqEFPHol2dHQIgW7G9AMF60kau++ACkslWZ9s9NgHqwE0g4VGuXk3TxujbPOkAo6iNqAK6gfT2kSCupDGwopOw81Da2p/Bf0dNUT6dMTNBfdUcfIU3X2JqkIlQkke81j6bq0qMRBqSDsUHGhwEYSUzRD5fjJq00mPhZNA85mNUrYrWRdCZcHg6+95oaxgKs+ovFKUJeoKMl8gPcEWixhXkTtFfLAGlJWD9hQZBpxLXgIQj0qwEKxk1UsljEctX+dcvfYmRdx7T6/XG3ClnE6YKAMrQNIcR0mw0tRIx4HU7uh8xYrXvlk4Mbk1T/8KNfd+f9NamayqqiLP85FP/KTxNzetk8HA5ptOPd4PRiAfR+ERaXxfEw3xUPv0x5gxJiyTeowmNcYdnMRClfo76oJCqlo/t/Q3nJplp9nmySoEQjBNOxUqTKgBMUDMFM3U6kKAm4aixwrBty1Z+E792ROjKdtRb1hlWdbtjspqVlXVgHKoGgea9mMogt9FqMjpKuw8sMj+IweYmmqzbspw0eYzOHRoPzv2H+L8Cy7gqT17WJqf43nnncPs9BTqPTt27GTVmjWsX7uWVlQIRMCL4kVRAbsCrSuxD4465qWqqqOUb1UlyzLWrl070ms9V3BaKAPHWziHWd+W2zCaQVijNmGPM7BrVG2H85UJZlUsqKOKlgEfMpGjfzFDvNA1U9i0xpjUxon7O+o0qtTu06V81qF/eKJv2hN8zxC0InOck1bYf1ARKjT4WQGP4UjPgzUcXipoZ3BGZig9zC+VrGoJuYQQzEFTQEqROqqXx8S46YhhdGbVlc6zWiLSV0dFFFGl9IqTnIOLFZtaYAg8+8YoqgWlCC5y7C94YaEMJ1cnBi8mKBUavpf2xlPt79PBOCwOA2NBQaVCyAIfiCo9FQ72Sja2LGICS8jeHjy6b47ZVVDINC/csJYnDh3h/kOe82fX8tgjT7Fj9xLnXryK2Q1rKRWevH8nF62bYv2G9cFG40N2kW/ozgY94fBNlTxHXWSqKIqjLFADCvlpZhWA0yhmoOnzH/ablWU58LnlMOpJOayRjgMjyyaQGAyEUipY8WFjq0KuvBfF0CNHsQ66NvKX+5CqtRLjwHAwz6gw7HM86e838s8d8aDpodSYTn2cKVTbTNSjIjhSNTelFMNn7nqEf/7K4/ztXTv42y/dQ7dX8cRTc/z9F++mFNAQhk1/xQxm7WaBoxPJdhxxGMPtjzqqfsVjIQYMRv9LMPu7Ci9Cr1I+e88jLDmHeocTcOpQSgqxVJKDZNz1yD7++asPo07xkoHNQaFSIXFnHO/ex5lNcKpjdznU/VUCYzAlHh/despTc4v8nzvuold5rC+w3tGlRZcM11nNvAZLRSWCw9LygRWzp5bce2ZwZICrDM60Q5wBHmOCZUBEyAQyPIa+v3/4Z9jHPxwfcKo/w4GH6ScpCOM6pD2bcVrccXNRaQY9pd+pxO04T+rH6tO4F5PRNhjXEO9xqjgNgUPpTYlugRPX0lum6TFtWk35Pp2gtHrVjEmBasIJsjSWIh5xThDyByYUgQ4R7IbKB/aFhaUuTx2YY6kMNR+cWI4segpv42Z0HFms8FbGHfE+DqV2xWNh+HIiiInlnU3GUs8FWWI50vM40wqWrfhlBRa7PfYfmqdSRW1OhaHwSpWoiE5gFWj2d9Q4tbG7PI4Ogu7PVvWOyivziwW9EjAWRfFVicHTzgx4V6cS1y4ujX1N1pRoPYvvDt7T0+jvOPC1OIw913BaKAMJRVEwPz9Pr9ery8XOz88fRTwxvAilU8ooo4bTRB9nCeORn7KjzVQxbH9kL3v2HcAfb7U8CYwzIvvUChV5EAcS6ror4I3w5fsf4ivbd1DBiVc4VZZ6FfsPHqHyivMhgr3nFGxG6ZSeWkoMh7uepdLjsNEac+oYdVpss90UkwGjU+RWMhZk6DeAc1qrb85DpRYnhkf2HOG2f7qHI11F1GBq/7jgCD9eoMRSIdz74CM89PiuFcl/XLIN9+NGriQPKAON8IjkDqkqR7dyLPZ6KBav4KqSTCs6mYbiQxDmvaaN1CBYvFMk1jBRt1KGkZPo7wjRjP86XVMJh3FaxAyICGVZctttt7Ft2zbm5+d529vexu233862bdtotVr823/7b2se62NZEobNl03f9smauIcn+fFS4FaixS6nwKxU+z3+52JqXEwV8hr8iAePzNMrKqpOYCoLLG59mQQjwcqunywyzVSfE/V3pbJOJr/hUqfHi0sYkAf0U8wi7bJaOLi4SCUtHJDp0ZHRA+2L4NWzuNRDTU6lwe2iEnKzvRhEMnoqzHVLvG1RRjlr3Yvw23tNNora+Xoi2Tbve5SumBQzkOJuhnO4l5sny7WxXH+Pdz/LvAqE4LQK6HmBLMdrsMgcWOqyv1sFy4C32JQHL4rNMryY4AIyGaVX9h6aY1V0C9kY9Hm8Ph1PtiuZg8e65+F4jFE8u2QJ7Q/Y/pYtYgKPgMnpek+JwaH4mH2Ri6d0VbRypTkBEMZvpYH1MVi+bE1KtpwZqx7XQ28Ny2LUJ/hm/FezzWPJ9nSyGpwWykAaAN/5nd/JjTfeyP/8n/+zLlTxy7/8y/zlX/4ln/3sZ/n2b/92RIRer8ehQ4fYv3//wEYCHOViSL+f7qBZSTsraXv4M8NKzPEW2eO3H09b6oDALuixOBW8yVAxqKcORg6fDSczUgrRCg5OzZiO5TaVk93MhlOG0uRv1kpvyvxY7Tsg1XJVS/D/K3g1VJho+j9a9qn9tNgaEWzepuw6loqK3YsLOGxIcIunay+w0C0pIyNOyBpIz0BrF41ErgJVRf3yi+2xZDtKNE/wabwNL7LNzy43/pYbt+m1FMx1PGiUk1fFmJyigrn5BSovBG48qIxQGIvzGeoMWoJHcd7hvdabY+U8lYei5+n4eE86OD+H+9p87VifOX7/jz2mmxaHUboJvPcYMSFmIBYjQgPnQuk9lQoLBezYe5jZ1bOhvoZAq5Vx5HDBkcUupQ/uAPWKqoC1FF556vARDrmMJZ/ciXF0egWjMTBzeSWhOW+aSvtyY3d4zh7rXpeb32ncpvG63FqQPjMuy8SzEaeFMpA0waIo+MAHPsAjjzzCy172MlavXs2aNWvYsmULO3furE83Tz75JLfddhv79++vB0ZRFPXGYq3FOVcXuWhGnw5rsssNxvQ5Va3zWlOqSxqgw4OzieO1m9ouimKAG+F47Qy/NiQ9jBG8FojmFKWj8p7Sh6jtykOvV2KzHpXPKXolZVlSFgWFKq5FdLkfe2M3xtDr9QasJEnGw7+HI32b31mu/fTchj/bbPdYslagRMkUjFYUmeC8xXlL2etRtUqKokK0HHiuzf6KMYg6epXQK0rKCvYdWmD7tgfo5hugqvCiOByLS44jcwuUWUW3V1ACFQq2RDGo9ChLT+Wq0FYRUxXFDtz38NhP42w5C8GJxtZyryd472s3V5onTQvBsDJ6onGd3ltaWhqYC8uNz9Ru5ZRcSnou5Lbvfuoghw8doOdWU5UlVc9RVhWlr3BlCHr1zrHUK+gVwQRe9XqUZXB5FKVnqdujckqvcDjXGxh7w3OkOdeOZSE5lnyNMQNjsPm8khzSffaVy6Of7YmeabPPZVninCPPcnBCmXWxXlG1ZJQURUm3Uu578EkWF/Zxwze8hKLS4HZxwoFDc+zcs59upbiiwlUe5z0OYbGCz37lLpY6q1nwjqKq6HYLDCWiijeOwP0QSkw3C5gNz5skz7QuplTplRwQllsTkqzTmp3WhWHL4fDYHZcL6NmI00IZUA0TPc9z3v72t/NXf/VX3HPPPSwsLHDkyBF2797Nhg0b6gFw/vnn8453vINdu3bx0Y9+FGMMU1NTA/nPadCkHOuT7U8asCnf91jMWE9HK03tHC8l52TbVq1QzWm1srpdY3NMZml3clqmjfUt8jyj1cpptVu0FFwe+OFP1F/vPZ1O56j+PV2LQPotInWectM6cLzFu3kdIxKUAe8x1mPVUJXQspbpdoupdkZrqCrjwIIsguDoFkqet7CqICEQEWtoG0PmSowKnXaQq82UTiujYywiGqwvZKi06RVhQWu3WuQtC2IQWRlx1XLyXQmOd3IdnhPH+k5akE/0LDWeJBMnwrFOfQk5YLC0nSfPM8RYTJbTytrkUjHbsnRaGVkrw0iGFYsVQytvhXFqhVZmaLeEdp6RZ0JPhHY7o92y5No5yjq4nBza7fYJpNjHcpvOcnJT1YFnNgqkNcsai3owtkOmLVAL3qLSBWOpTEbXC1luMHkbk2V0pnLIWmANWZ6R25zMGrK8Rd6p0MxSWaHMc1wW1rZ2O6eFwaiGzKMQVUAoGd2P5h8eK+m1dNhqukxWovwsJ+vmmm2tXZayuNnecsro1zNOC2UAgsnxT/7kTzh06BD79u3jzW9+M9Za3vnOd+Kc4yd/8ifrQZAWreGTfyIXGT7hp98nu3EnJUVEjmKIa7Y7fEJbDk1teNhku9xkGViA4sT0Ioim6OLksw6vGRWcaEwXtPQEjDq8FtSB7+Lp4TFlFdLuYm2CEy3o6YTZ3MCHZTD8+0RyGJZH+rdIv5zpcvSn0CiUg5Krhg3dGiwGE90lXd9B1WKl6XXt96EeI/HaJryBSMgmwAjeKM4bMs0RV9HrOQpXYqzDanAMeJEYSuip1NIVpVSP0wqVFmao78NIY2E4W+ZEz2Q5mS6HdNoa/tzwd5Z9hlDT3iItPMpDuw/x1N59XH/lhaGvdTPxe5rMy/EkjUGxqDGo69GjwxItLA4o8QQK4qysUOfoIjhr2L53jt175+lqHlJjFWxV4rViXgAMGUePlWHZNn+W+8yx5u7wWFvuO6MOckvrTZZFXgEjWDJEiKRLFo+SO8e8N3g7RQaRmyknz4VKhUIzxHWD5UyEzJXM+JLCKz2mMNoB36Unhi9ve5SLz17PmWtXIUhUmwXqyI3Bex6WYzqZJwvnsdaE42G57yQ5NC0vw+0Nv/f1jtNGGWi323zP93wPRVGQ5znT09NceumlHDlyhHa7zczMDLD8IEsDIs/z42qjJzto0qn1RNrtyV4jKRdNq8Ax+xsX17S8hqptkUpI+kyCQliYjYIXy6JXMjwiRZ++VTwF0Ip874hiOP6kTZM/5fcu5255unIA6lPFMLnIiuQIWCocBpUMQ1B6FM+S7+BN3t/kj9G/mqcAQbzgPVQuxVRAZQAvZC4s0KWFFh6cUmZCAcyoBipoMRTGYE2w1CSyo2PdSZJlU77Nvp2qQnCicXZCJRBQ9RgqNNw1u+cdj+1b5OUxra0+QSo1/ZJIUCI0ylUlBLplohS2Q9eUGFegVBRA5Swt71Gt6FlDYZQnDvdYPHyYc87ZQBnzBtoELoIFY/DeBOIsEcQcf+w2x9eJTqkrRTqMDI/bp4u0xgw8L1GMWIiyLMVQOUer8iyqYNXSUgXvULHkNlSF7FWCdWHelwKZ6zHje1Tq6PoppqsM6z1dhJ27D7DxjFVsiKRlJBVQZNlUtmETf5LtqDflZrvD116uP6cDTgtlIG3gq1atqrX49NoZZ5wx8Nqx0DSJjmqApFPbOJB8bCdyY4TtIgQI2dCp+j2pDXmDn1cFH/kFvAuTO21Jqj76BCGE3xlWksFaVdVAQM+ocOqphUPQ/gmr9vOu/KshVSvuaKogBhwVxpeUrqL0HjWG/QtLPPzkAeY8XLLOcs76DqKQqcf6HhCCs4RolTkG0imoqqqTMmWv6H6iHE5GmV2mlYG/Kufr18Oo0mgNSO1LeAZxExvuz9LiYggK1BhPAVEp9ZRViXdVP1jQKWXl8c5FTgGJ3Bnp6sdHMvOPkqa8iXG0m2jVa2tOjPw1xNpiPlj/XOWiqIP8LUrHGsQprvSISh24qSjGZpSlUFSGLAuHgcoLZeTUeDoheGl8Acd0dz5dNAOLT6cN/3g4LZSBJtKm0PRhpngCOLafqFmQZFQTtGmyHjWSX/+EfU3mWtUY1ANJc0e1thCk/V4A9R5RZeP6dfSKyN6o4QM+vpdMuSvNNT5Zy8BK0WQ0GwkaboGV3ZvUP8H3rzgXNh4PqCheKowNMvNAgWX33AKf+/JDLJk2U5efyab1G8i8x2qF9SWSrC8nQNPyMmqkk9vIlGP6SqwSVMhUBKu5m2hSpEKya/91VRaXFvFkYQzGse2d8rzzzsKVjp0LFRC4Hmp1I1nAEFzkgVhpBkwzSHfUGEe7A+tCU8GSwAuggSsb52IAHSA4cvHM5IYM8M5jCWmbVbJ6WUvPKYUTTBUCCksnVF7w2iAoItkGToymZWDUGPm68HWA0yY6Yjm/UdP8f6JNqKmljtIyMA5FAAZPxCf8bOgNQgV4SlXmu1XwbTcS5zT2WQBXOTasm8ZKzFmOyoCqoibaBiSdslbW33Gcrpo+3dE0SH0i8ivZMfpfC/2o/w0gqIncDepDfrYqJYauCt18hkWZppA2XgATlm9R14jtOD6S8jrOEsbDwV+ngspV/T5rSOH0npjC1my7v8GoRhdXLJstIqj3eBfPpM4zO5WzeqYNroxxLHFcSiDJ8aqBEEqF0vn6xHs8jFO2cDT50ijGcHOeqVLHBYW5GzdrDcyiXgAU0YKWcXRMiAHyPhSDSgcDr2BbLRZ7jsIrhSek3RJYSj2CH3h0K7+PcZKRjXP9fS7itFAG0qafNMGmVnis38dqZxT4Wg3AlfbXp4gBDaemhdLzd//yFbY/uS8SiUDa0l3y03qPSMjjrq8iEvPvLV0PFTnueEV8nmZ/TwbDAVyjkn1cJ1eEmMmNx+AVKheC2pyCF4M3YSE2QCtv0e0VHOkVdNUGQqIsp4rOF4cJMQwaiHVXqhCMA8Oul1OVrQC+UcUzsAKmk7sOWgfSFwjKWXLBpA0qb7WikhXsLe3c0s4AXyKRSVIx8fQaXV4+cGI4r7gVWrTGGWA2Stku12b4Z5jLziVWTB8qj6oQNVW06LJups1Uy+BdhdNoETCCqscR/F2PPv4kh+YWOHB4jqXS06uU0icLWKMTWv9nRf39WqwLE5wmysCzDc+mgVjPS/WgwXfaQ3nicMHuwwuUyXkQTamBCCfUL86tQXz06cbbqDwUZBQoc5Wnqyvzv8J4ZNE8uY1kYYkxl15XVo89mZ89WvPml05RDM6buFhavAdxjqm8zVRnCuejdcX1yEUpnbLgPF0MpeSAYGp3zDOD4VPxqCLe0zioFOad0kNQKw2/gV/2dBlc3orNbJ0FBBriBLyizgU6Xe9DXIHNKCtATO3XrtJQln4czEr7PWo0T8Wjt5hBRVTujaVCKVzc2I2h5wI3gEFZO93huhdcRjs3mEwoxLDkk2UhuG2whsp71FiKylN66JYuWgYSjtIIVtjX8awL45LtcxWnXczAsw1fq4GojS15eHMOfwVnoQIVQs90eOiJw1x1iWc6NwPzWDWcoKw1oL7WKBUoVViqhM/c+TB+6SDPv2QrV51zBidaWMd5whqJz7F5KtWU8qT1W9J8k/RCfFUE1ZBWKOLxTul2C7q+ZHFhgcoZpgB1HquKVXhsx17UW9pGEV+y/bEDPLl7D+dc+jxK8jrO47jRg2PGaJ5ZQzEmuUyCDPcdOsLdj+3huqu2kqU0VRSk6e8ebMoYQ+mVTp6hviT5ZVrWUFTBagBBien1CvbvP4g1MYBQ4wY34MtZuYVg1Dg1+Wrjv8vLKllTvCrbdzxOYdsUzlGhOBfKc2aAeEcnCwGGKsJju/dQ9rrhadTjPbgCvBBJgjxPPLkHs7Q04CJIvRKVqNCtLFBz1DidUgZXiollYIUYx+AZZx5rs10HqHpUQzlX1X6Eb4gU9iAWlVYdwb3oYX+3xKsn8yWOFh5LSz2ijspX2Eb8kTOBC77yJaXz7Hhqnof3zTO/WC7fwa8Rnk4aXULYEzJCdnQIsPQIToTc9/Bq6BHMyuoVV0U/JFHGPi560TKQUWCoWPTC4dLQ65W4EnICj0EXBS2ZyoSFpQow4KBwsHu+y859B3GVI4uruDuJWxqnotVMBzsZiCadSeowy56PrI0Ih5Z6PL5vjtL5GCsR21cT5KrBZWKIKa8eSkJ/rr54CzMtCaWmXUkrC4F+lVqctnBqKDVjqRJyDW6XkgqckHsTnlhTy9XBfw64wJ+Fsu1b+xp91SqWYgpn9YywwXsRnjo0z+5DS5QenMbATCtUCl0h8Gl4JdOSvfMFB6rQaqahwuNMluGxiAF1gfdhoagoCRTQFk9FSDesvIIrnkmj1ljX3ucqJsrACtEkbhmV2Sq1Oa7grhSwViVTnS9Bw+k/UOdA2uSUDKRFMFoD1uCMCfnteJa8oVLBVAWiFZX3BEr3cFqrJFG1loDHmSmKfLpOQTxRX8cV0NPkIT959JMrpS5jLBQq5Fqx2C3ZfbiLClRVqN2Wajj4FOCn/cJChpKMiq4XemYqxAl4Qxb+QSlgjCMTxUkLr4LHUJmcnmSUWFxVkUWFrhJzQhdMk4Rq1LJtEhrByW+KA4b4uMP2fCgGBUJPhZIMNGz2oj74sRuRKqpgNKQSioDzISp+XcfQokJFcVWF+mCdqXxGRYZzghOLE1sTPFV4xBtyH33lcvz9apyyhX5q4dMPrNVBxcVXseqgxLRUj1ECT4PJKTXDaVDERIOf34tQGktmhEyg5Ssqk1NlHdBQyMmJoWMsnsQNYUO2jBi8tEAFi2OprHjiyBJFKmRyot43gn/HtS48027aZxMmysAKMBx0OMq0t3GlzvRJb8KEDtp+MPfXi3AdhWUHTzoEjd96rRdpNZEkRmxt9jNiEPUY0g8hWlsi1SomXvfEfR0HsQj0U4iejoyFwQ1LiBHkBrwxPLxzF//8hbspnWLq/clQqqHUfgR1ONXGZyISSu3WCkqjGma8Tmab9MLhJFVqKHmsEqochoJFjc4d6x6GgmdHieVSv071GiEmJQy6ykWF+RiLthA2oz4bIVh1gYshxnakr7VbfQIf1cAmKg2FInkFXMqLF8EPX4xBcY9TtnBs1r2nh+BSSiwgZT33g8x9Kq2tfQZAEynDRINlYKrVYvOGDRivNWtWkm/K5LAigRUzEpdJCu7E8tShOf7hX77MQuFQOTGNe/P0Po51YWIZGMREGVgB0kI0rpPVuAJkEo4s9gh5AmHCDm9yNNKLUAnUrBrMst4rKhkLXUev8lTe1dHXtp5IYboLoN7FU1pgK6tWoAyME6d6sqg38gZzivPKYlXRE2G+LBHpTyQnhiWnHFrs4uhfN4UbCiGHO/UN4qIXIxOVSLAST4NeDPPdivmuw9sWC6VHxSDPEs70UY7f1Ept0aqqEOXe8EsPfsEjWoV+EGRsqcgosUH7ClYw5+oNLz2HRANOvVkRS/MSXUGmX5q7aSHQOB4GYkjGc7ochWyHo4MqpxReObLUq+UaYmDiWgT12DIq9fg3CtN5xpbN62kBuQiJmUSJCr0EpcBIeMc01CmP4I3hSKHMFQ4voyUROlmMy+LwXMazY0V5jmCUWmSTKnbU2mmTOGlxqcs//vOXOLLQa7C2ae2vlVoRSG+F4MAQO2VxCEsV/PPnt7F95x7EWiDkZltrEKE2Z0MM0JKwwDo1rMBLADxL/a7DSDZXAW8shRgqE1jwIcRSqMDDT+7lHz97B73SI6Z/epLYn2T+JZq2gZhpEHnojelvZMDDjz3J9sd3U2C4+8FdzHW7/Q1yhRh3cOaoFOZkLVFNrJQuBv1xlDIgcQv3REsMYLVk7XTGmpk8ZBf4sPFbYzCmX/2v+QyAWGpXqJxHJfi/Pf2AxmU3jlpHGY9sm6RDT2/jGgz8RQwm77Bvrsun/vlOirJCoqXQq+Ccx3mNymhcFxREJSoGQttYjPdIdOdULvy2WR7Gs0bq7P7xIvBERNdEtwq1NRRZUfDrc2Jd+DrBRBlYAdICMupTvIgM0NqOCqnKmnOOsnQc6VY4AdeIwTbL+ezikUcVKhV6auj6QEV0aLHHYi+UitXo0zWRs72rllIthQ8n47SYK2GRWQkG6H1HuAA0S+w+HSg0cqT7ZuVAvGLwtlUrAyF0EA4ulcwXwT0z0BBgswwXiXUk+RYkWAUSFa8RUz8nFcNiWeHEUknGkcVe3KxWtJaGnsWxMGrU5vbk5hjBKdZ7Xx/FhzfsZeGhEkMXqNTQMnDNZVs4c00Hg+JqX40MWGTCjw9psoSoeiUEzBWVT6y80VowND+bSmFTsRgxyrIcSbv94RvG7HzpWSilPtFDiDV0zqFRGQjnAolEWMl6FRXaqEAEcqZgKbNZBtEtYKUR7EnabPuWMVU9oXsrfW8c6yOc+rrw9YiJMrACjIN2NC2eo44ZSP1LFLROA6NdSZqq6UQFIRggvdo3lvacUpqMnrS479E9zHVLvMlxCGpCcJCIkMXT6565Re5/Yg+VgdLFU4YqgonJiidGsyjLKBfWJN+nE4SVFAFFUUmLWcgtMGIRsWDzmqkNlAo40ispJFkMBmEk1KlPTI7e+3BqtSYUiRKwWaJlDqezCoMTS6EG057GS1LlViancdIRZ1k26O441ZiBBtPgiTYBVUFNxv7FinseO4STFuodbQmnU2vtgGXAWoP6ocqYoaH+5q8gWc58t+ChRx8PikAjnqN/8fDTpCkfNZp1UE5Jttr/LdaCySljnFB6y2sgHlIiRTqBh2BuqUuliVU0zAONPA9FVfH4k4cC+2OsHWCMYKUfK9CMtVBVMglhhqbZr2Mgja9R1yWAU1sXvl4xUQZWgKNMiyNAGoSjaFObP40I56T9ush2Nzw5+yGG6Y84yZ2jEmHBKV+5/xF27T+MbXXwYqmckIaNlWBevf+x3XzpnofoVkrhDB6pTbt6lJ+g39smbU8qVATjsww8HTl7CCl8qU8aGRuik1mkXwEOCcFni0WFk4ymmqUx2s8YQ7fbGzjsJktOGXh3w6aVshFE6k3PebCt9oDqtqJ7iEW2Ro2mZSD9fSpjOViS+uOiX7RouU8STrrG8sSBI3z2yw8x33XBFaAuEKio4jxIzHQpi7KmkNakBGsKoEsugaCAHTh0mK/cdQ+lq8J80qHI/Igk23FYBprP7KRlK32LljTklYJRvcnD+NT+uuGiVcYmE7rNeHLvfrq9Xm0OMNbi1bPxzA2sW7eWxx7fRbfbIxVzMElpaS42JGXAk0XuAnQ5aQ4ija9xWLVOdV34esSEdGgFGKf2OJLoa/qnfgsxwt+ByVjySiWCeMiUOkraxPGfFgxPjB7WNrgCSwkChbYoJCOTgq53VMbijUW0oKMVS07YPa/0tE1YWYOa4fGoGvBV2LScD6QlOIxIPHGntL3BiOFRyvtUT6shgEqoWe8kpE95dRixWAHrqRfLLPUfy3ypPLz7MFknp1uBz6aQCtQ5jM1xIlQ2pF21pA1YrHisFKhRWr4ELShtOyogFQ7BqKerhvufWmLrGR1msuPr9OPksjj1TAIBsjrOpPIhV90LdLVNqZa2urCRiWCrkLqKbVGJ4aEDXR5fcFRkiFicy+hkGRZwWYfdhxaovNIxAAariuQZzrvwHEyGMxmFChYNr6vH06JnZ1GxCMqjBwumWxmbZzNq3VCOHrujxKm0mSxHYV5XKJYSg9GCGRylNyyo8PDeBbyHJc1ZQphCaVNhCON0V9mhZbqIeCSlHQpsmrXMqeWJvMUqDFPWIF6w4vDWAXlMB1WcK0O54xJUY7VEHLFO6nHv/2vBwzJBwEQZWCFGnULUNOefumaaSISCX8/EtB4nwpLzVALiQoZAKEUErfA1vMRzfjzxilqoPFZLrFi85oEfvupROqHnAj++EaUtSreEx/ctcEYnj0yxMXgwLkNeXb+IjMaMg6GlKgXWjXvSP53201YXTulKXaTIu+AfVcV48DbI3qbveMO++S5/d+dD9JxhutNhdnYKY6idJx7w1oS/K+gVDlcsMdNZixFYnRvWzEzz0BHF+YocR1k52pnh4HzJF++/nzNvuJSZ1dMrlsGocUrt1l81dQaBJ8NHC0uhGV6FTMvabG0Jvn7nlZ7AZ+7azsOHLWJtCKoUSxb92z1neOrIImXlyQWsGKZbhtaqKQ4cngspcIS0t1LBig81NwgxM10JVhiDcveOfaxqWTZcvplMonKIOUohGiVOVdEKo1VAKrwaughWHS3fQ1WYKx1/87ltGFHOPGMNPTKm1DOVhUezuFiybRdcOtuiZRPnSFCOz1qdszS3yKLJWC2GjmQYLOq6eGsQMtAKxeM0HAgqZ3CaxT6tLG7g2boufD1i4iZYIcaRhjLK9BZp/piY4RtNfyH4kWUnX8olMLigravG+u6hdLFXQ69UEFOnD6EeY4I/DxGEEE3sSbnKEsmGTF0Nrqg8LkQsNa7d//e4Kr+dioyXXSJWHPhUESq8+egSCIGZ/cUtKkTOYY0gucFp8D938hzxjtWrOpx79mYMxA0uEOgYE+hek4l3JRiXKXSkJFz0YwUVUFdi1QGGmqdGLKVmVGJwwFK3F83bwUTNkIXJaSg6JMaQG8+62Rab108H94sEG1YzoNDF9LrK+Zjh0d8sBgi0mv8co2yfLvpuQAjqTIj8F5tReV8HrXrncS64U4rSoQitPA/WO0Jm0eYNGwJvA+Hw0GplrJ7KQxCyJLsktXJljYkFp0IvautjjM0I02FlG/CzUbZfr5goA18HiCVtBj10Meipci7mEB9n41DFRDoSiDnHCkhIDXx45366lVL56H9UjxEhy3PA4FJ8Av2SxV6DMuEUDi8uccfd2wjbY59BrtnncZ5cv5aaf9ovrLUhEjty4Yf68DHQSvrlYnMMRgyFKg/tPAIIa6amaAlkRmnn4MoeaEVmLGVRkmW2Tj98pjHadNsU1Z8UpQKRChc3fpFAlfuFex7msb1H4ncaGQE+prMNxDCEgFYRoSWODbM5Gf1CU4IGZsOYMO8imY7ziqtC1ogCZV34qDGPvgYbyqkfGIK9qnCez335IY4slSF+SIJcjLWIsZQejsx3OXBwkTzPQ2yFEVxZMpO3QkBgjEOwYiKVcZS3KpkFUDrtFt5V4UCS4hZUBuJBhsIJnlFMuAb6mCgDK8Q4NpXRpQ2liIF+1G5iEysqF0+qftkJGC37VBqCAQGWul2IVLcew75DC6G6noaAR1Qx0TzqkcCKR7AGVM4Frv4YnFSpcqRbsGPXHhw01JbwM6wMjIuAaZTtarSACGGBaw4LI6ESnPdR7TGmtggkBUCIaZkiZArWgLew/8gc6pUtG1ZzyfnnIFqxdjZnup1hUXKbjsfBVUE8uR6PtrUZ6T8ODF/vlPzcySoQMwpcWYAqSz4UwELBG+HhPYd4fN/hmnewGRUegn1T4aFgpcKEiPStW87kFddcwIyNJ2NjmZ2ept1qUVWh784H3oIqlvRVDXUnhCF3nvSVgq+FsnnS689AfJ6h8srju/Yy3y1wGtx41oTUvdIrXiy9ynNkfoFWq4VXh+KZbuVcdM6ZkWQIvCjqHbkxkeXR1zEUBuXC8zeTWRMvHoJfE/X5Uq+HT/wFK9QGxnlIGPfceK5hogw8gxidr7EZQkhMhbRgDIWDMCn9MaafUDjlwHyXwlsUYakoA1tbPN1XWKpILKQ+EorEFcDTtCJoVARCcGBiLS1UcJJRISE9EaEuNsOgEjAOpWvUfl1V+kQ4Keo/vRcuWP+RAszSRi0iKQAhxncoxig+E6pYoGcmt6yd6SBUtKyQmTBRwxrrEQmfUx0yXR/j3se52I23fcWLMFd6Di70MBJOp4vkzBc+uqxiQSgJgW1hC4pET5HcpowyWjVlWNu2tIg+MzFMtXPyLKQgJouAQigzrdQWNd94fmmemWejEjD47aCwRiegNxYvNvBf1P5yg4ql9BJIyYzFZhaRsPHnRljVaYXYYMCbYE3Jo8vQANZKKBelnqmWBXwdg5RcP0ogQEs6ykrLmo8TkyDCQUyUgRViXDEDo6EcTdMu/i1CWaUTesyhrjfpoT4Aew7N83ef+RKLLlTCC7TDfcVCTYtSBZFgkhUDmTV1bIIYg7Exyj7GCoSOGJwqlYY8+dIFH66mUOzm8WpILqPCOMiiTgg9+kTuYnEhY9JGrsHCojGnwgreCEYMFshQRMKGZ1FEQxaGEFMRown8mNl3ze6MyRSaSGFG1na0H9e6lCrOZDy2/zCf/fK2WkF1pkVRLbedBLm22q3oKZPaHy4CxjnaeFriQMDYDImbm/dpPipiQv0NlcQeqbiqSdmVutufI+PASMZtlKkHKixeDJX30XIY75FIoCWBQ8RkJk7NQCAUMo8CqZYXDfNfQmox6kOM0YCFII375K4Mcut2e6RnFHDijXjcsp24CPqYKAMrxDhPrKfWrtYmwWYrNrN0S0ev6PtT+xuv1N9VoDQZC5XQU3ASTu/h/6Fhh1I5DW4C77FisMamMiakE1URPAjxJBzeUg2nrEqESpW5xd5R5tbl5DIqNAtMjQS6zJ+x6XhQbQTBhZOkQh07kHjfNVaPNASCHEyf2MaQrC+R2lVAtMLGjatpafDuxBvSONOzTp2Ia2iD1WReDmO2SJYlDffsBRyGXllRlikPXxutKVPtMDLV+xAgF5WB3IQ0zkxiTrwxdWGdEFsQJlG73andZFEXCEGK0r9K+G86XY/ndDmqcVsfAowFG6P5TV8RVyTGahhETFD0Cdt/LYX+MhNchMFxEoJbrSXLLEa0jgaKoQKNa0BRVpAU2fhqnRodJ47W740Xk0JFR2OiDKwQozrFj7zNZGr3ZYgRAJBQYvhTdzzMnY/sxxnwWsTA3yz4/ynBF1gftPzC5Sz1Ap2uV8cFa6ZYq0Wg23WOblFxcBH2HumGDGEJPOTJXL64UPDk3jm8g5bxCCUtXyHeYFxJz1h2Hl7ib764jbmiAu9waYVh8BT0bLEMDHnDm0tjSAuMPuYqnZ68r82izsRN2GT4SNGMKlZCsGZkcsaaHmfPZnQKIcPQNaHegyVDY3Ch85ZzV2XMtizWl+RZyBlHJAR6aQr+9HXvmkvqOMtkn7JlQAkuo/S3eBQHovEeQ/qm+JC1soTBULJzz0G+8MDuGKTm8JoF+gEpaKO0PGxav5rH986zsLREZpSuS8qawXpHy3pyKxhvqYDCCMY7Zkw4GZdicSqU8bkXvr8hekItiXGsCwmn0m50ZGBwWC1p4XBkOKeUzmO9q4Mrw+9Uz9CTGYIiimfLGg2FmzBkeDrGgJY4a9k428GoUmiHwpdkWRerguoMhbFkomw0XWzUo+Y0Q31FS10okayK+opSNTA9+iUUF4uqDcbCjBoTy8DRmCgDK8SoeQZG1WaYNAY0mOALor4tlifnSg72Qt32sM1Hjd4IEEyljqS+Z/hI9OW0YuumWS7auDbWIVBUDD0vdGMMgpUQTWwi2U5VOY4slqCQm+C2yDXUkRfvqCRjvhT2LindSsHrwJaVTpijnpynahlQqNkD03RJnPXBBRMUgLRLeEA9kaI4SNynShDeYxumflDWrZvmZVdvJXeKeE8VTbRWDKgJaYcm5/prLmH96hmMr7AmpCGGa7mGoSeesxppW8nPPQ5K11O1DAQ1VhgsC+hQicWKsIh6rAPRkFGwCHit6HrLnvlYFEs8qQy3NUHabWvYtH4VXR/mhTUgWYv0HC1KZoIyayWjcISYDXV0kkUsWXVUYlpc6mQ67upY1oWEU2pXkqUppAxbdXgsJiqmNrqZkhUm8Cv4QFgWl4ROZnn++esRK1RxJLcAVYda4bILNrNqegqRFnmuGL9ASwTxGd7AmtkpLjpzLSZmZPTEolphNdYE0BBSXAKVhL4mBQu+NrKdWAb6mCgDK8TI/aOMztoQOAQyDi30ePTJg3i1OCxeTYzezaJBz2NVyTSUGN471+Ohp+YpGyZABaxYMmvIDVitEA10RmVRhYplqmSZqU3gzSVSAZtncWOKnOcK3ULZ+cQiEs2EYQPr+32b9KCjnKCjiRlobK5IvWClRSt8JGxtkaW4dhXE26zrxduonKQyxdYKrdyS2wzvqjouIHgOYm15gVYmMYNDMCa4GYL5unY2xKqUqW5B34Q9zkJFo44ZqE+ESanxBq+Gioy5pZKvPrSX+RIqm+FjQZ1Gh2JmgQxwNafCO1WUQQgCDJaazFpQ2LV7f22yTs+mjiDEo1WRpByej2pM1R/9upBwyuNWIIyHLIwNEVxV1jUImk3XAa6EgECJsSrtGExoJCptkuJahDwzZMbTMiCVI9eKtjFkOHIc4is6Ux2qaDGLV6pP/vhQGGnPkYLH9syjpo1gg4y1/JrIdmIZ6GOiDKwQo/GPHt3mKDRfNWHz33PgCJ+98z4WCw3FbGJ0cK0MSAU4csJG8sju/Xzyju0sllXDXBjSAzPxbFg7jXEFRoJJ1FcV052cM9bNkkWfY1MhcIT1wmZZ/zWvVKosdgsefvQJijLyuA/dc7NwyCgn6MhjBiKaZvjkQQ5m+5Q+GWMuYiCWavBfp76kk7p6HzZ3HwIEk/sgNgfeo94F2uMYsBUW5rBJhRr0kiij8CKxWmJ4Ailo8dloGVgOzeev0YWgKjjN2X3gCJ/7yoMsOqEyWZ0K2+9Q6hdg+9k6oRhU8G0TszkkBnjkmcGr58nduxLVAMaaMLbVx3QCDYpalGkK2NV4wh21DBJObdym2haWEhuCB70GBd9I4ANpyC/VbICoDKCIK+pjROpGUFKlZguZyiwUi2xaO8UNL7majWtmyCnJxZEbxdgsVIH0QZ4SlYECwFi8ybn74T3cse1RPDnJliY+lFcet2wnloE+JsrACjGubIJTRyL3sDgxlOSxtnsKflLw/YpjKe0HNVQmY97kVJGO9Ui35NBCDxWDtRlrV02TpxGiSndxgVUzbdbM2KAM0N/UFTg8VwFSE44kN0DpQh6zj6twP/1w0K9dp96NEKP2O4b9OYVINZ6hBtfMfK9iqVfhfGByHDiRS/+eU/nnzBoSlY0RDXz5Gjf+yGWQmZCvLQJWhMxKnfNWVo5SlUph977DLFUuBIOFh1+7XsbN8Dj876fVFoPBjmGDkkBjKxmFB2/bFAQyKzUSLSkpO6OxgWpdNw9rbLRSBcFEPYDMWDIDMzNTIS0WhZjRgfchXkN930igjVROSYGD45PtgGxOUrbBIuUpPTw11+XgUgkiWDyuioF8UdbGGLzrzz9rQnBgSzwtI4lkEDTI2miyFABaMdO2TFnl4nM3MWXBuIJcPLl4Wq2cyoeDhlGHEViqPI/vW6JXBdrnw0sFmnXqlMegRId7Hee4nWAQE2XgJPGsUwiE/iYbA31qM7UGDdv6kILmxFKJRSUL+reEQjk9r0h7lnsf3sUd92yn5w1qgnlQYtQ7Cr4qaZkwqW08XaWkRrGGnU/up/IusuOBmJDGVPnA/+7FREa3eMKqN9IRymMZjPyZefpHJU2ujnBefHzXfvYfTOx4Gn2xqXR0cIdkme3XUveKKGQxcLBPHiV1RLymk60xmPhbNTA2VD7k3vec558/9yWOLCzGFjR0VMe3UQ1vUKesyA2Mg/DbqcebQIzj0lhTCWb6aGESM8gzX3ej4dMHiRS5/YsJQenKs3TmD1aBsihCXEYkz3KqlD5kMagYKg+KRbVvah+3KfukZatB8a+88s9fuo97H3qMEFkRrB1OJbJl9mXXarUIr4SfczetZ81Mp85oCe2G0WwExAjWZuSZQTTUf8gI1Oad3CK+ArH0Kod3SiZCZg1PHenxiU9/mb1zi1RGorUwVpMkBWeaRmjGeNaEiZtgEBNl4CQwrvTCU26Dvlfb+RAYFE6RSkuCk6Byni6GRYSQkBVIQlQLeg6WnMFlGYcWS7ouEpA0FgokBBilcDhroo9ckyk8pF/ZLAvxa8ZQuSrUK0gm7BivrNEeK40bSLJ9thMOQeOEGZzG6UqoQLd0qDGB1/4YC00Z0+JEJLoHwPsqBrP1VQsr0SoQTdR5ngUaaAveBauB8zHlMxI7eWkyTjAg21FjOTfXqQXDNpgUCZYlL6G0cx0GoCH4LfMe4/s+/pSymfLbJf47PYPEBjmMzArWCj5ashAJ1NEaFOiKEDxX+qBoO5WQq6+Q6nWMS77DpuynoxCU3rPoLYVCIKvSqKjbYPFoaGCdTqe+TmYNl5y/iel2HrOGIHyROq4lcRTkeatfxChm0cxMT2HU05maolc6vHoyCbEuhVPmfc4RF9KZjYFcHVajSwYDko997E7cBIOYKAMngWfm1KqN/yVlWfsBTgQWu76POOazayCqwVeIq/Dq2XXwMJ+96wG6zqES6r6XxSIPPPYUTiyFNyyUSuEFNYGAJGUT9H2lihEfC5kEE6JE857NbFiYY5DdVDucNLzGFKbY9zoqW+jf0Zg09JPV/rXxM4i+OyRZLmtLaeO7xgQ2u1CjIX6nsd5UVajQEHK5lalOOypvwTwdXdp9E7fNmOm0ybIM0aCEWSt4DSSvSRkL8QJZcoYP3hDjG7srCXKrZZr+o30n0VHf7L9dZ0o8GYP7RMJ4M6pk6mrLkjGmZgNsKpjUZv0Q7FebnCVdN5rE47HXRHrnVivDuQpjLaXzHJzr0S1dJMyCHU8+xb0PPnp0zMKIcbyxq8v8HP19D8aElEISQ6iLCmTY4Pt8itQ1L/IozyxaBGq2zYaSFZRfg0qoUeJdirgQRAyrZqbp5IZWLnR73TBWXEU7b1F6T4+crzy0j/leSdHrYjQdGeK4iIeRcWFiGTgaE2VghRi1FtlkqDtxuw4fA28C85wHX6LqUR/z1hNDmAazsyVsLs4ILreIKnsPLvHVh/ZTlA4Rj4rFl5bH9s4jvkCM4UARWAOthgpmqqGccbqKyabI1WOynCURptwixi3hrcW0w+TPgJnWNC+/dHPYLMqSXCucFKA+FjGyWAQaBDDjQFO2K920fONHVBHvwkKq0EPjacZiVFGVkBoVrZpWAlVrpYYlMXhr8SYLAWfi8erZOGtYP5tx7to2N155Hpl41BqctplyIYjQGY/DsHamxete9jzWzeS0LLQEIKOgjSOkxGUoxisHmcE7CeyFqiA2HNUYj3ybVpdlZZt87aTgfgV1Yez6vgWgb9oS0BwhJ9QqBNUWBxZKLAt4Mbisg6jD4wO7JZZcQqqgZJ7pqgpWBAkZMGKETm7JiL5xySgl0D+7rIUVxeJQa5lSyxRw0fNWM5X3yLyjUuWp+ZJu4cjLBTLgoSee4q7H9lLSn8PjQNPqspx8XfxJW3Vy5/WFahCFnhqcGIwUFK0288ZgWEC0wntLgcOp0NEuGM9UtMIMMJvWBrCQ4kluMSJM24qpvAd5hwyhFFBTcNZsh2+59iJW5x7EUflgbbESrYMCDz3xJHsWu3ibh+ODCkZLshC9ES43RtkmTBSCgIkysAKk9KxRkoskJSCl1B0fcaMnzslYZhVCPnuYL76/DqiGNbfywaQJcfE0ODMV9W1PyOPOqGhh1KFeKDSUx7X11UI6lcNQqaAiITjIGpxCR7u0RLF5RrvTIs8Eo57cZpy1qo0SNtLMgDceX4VsgnBaTmlwOiCHcaQWnowyJ42f9IqKcKRb8MCjuyOtcijM1KuEe7bvptRkxo6BfQ4e2jVP4ZVKbC3H3FqmTcW0hWmp2LyqheAJ21tGRioIEywLmcA5q1tkRshEyYwgxrL/4DzdosJ5sBqUlsJ2UNX62SXLxDhTC6uqOqFsBy1arv7Lp+N77G8wFBlQG41egmqGMy0MVdj8TBbuTTyhlE4ga7Li8b5gVR6iz4NSbIJbQYgWrDDunHq8ViFQlnD69WLI1ZCrMjtjQSpc5Xj0iX24LDAS5lFxLSXHZVMhhmGMdNdVnCvHw4BlQAffSPETlVeUwKHQdUrXK8YXoC5kakhYW3JKREJMv9bmrEY9jWgRsCYEsYpARzy5KSmdYglKmBrPlDVsWj1NroELonIKkUQrzCdHaQ3bnugy31MqDF4MIn0FZJyETillceIq6GOiDKwAzfSsUQ2cZKLKsmzFaV/9A1RMmYK40TeoU2vzMtgsX9FEqslzYi2DsqywNnLoI5HTPMNYizUGq8pMLqzptHj5i55PO7PkVui0bJ0+FHy0wWfrNC5IwYo4UOQn3VmWZcc/ZT5NJPkeyyQ4aGKNrhANZW0lBTWJUCk8dfAIX7rrPpYqj2TtEBzl4J4HHq2VAdVw9w7Do4/vofRBDRDAqufi8zfwkhdcjlUXrTmhOFRiDvS1sTTRFSUJEd0IYRSUZYH6WI0yPsOBYL7G/Y0rtdAYUwedHc/sKkN/afTD+/q9qBCoCwGrmihq4xOJgZjeD0buJ3dTZkMFvXWrZrnmykuZamWNsaW1G0ECoSFWHS1fMmUUazRS5IYxkplAZ6xiKdXw6I4nUIHKOwqFEig9eB/ouka9LjTRarWOY9kKyqVNI0j7r9c/ktxawRdvFFqSk2MiU2Bj5Ctxo16mAJP054j6itxA28QUQ3V0Whl5ZusPhaJa0YVoQrXTEOhqkDgXwzjPuH/7LuaWKgqxdBEqWjgyPP1Mh3HINs/zsaQyP5cxUQZWgCZxyygGTtNFsDLLQJ+IhsZvFcOSUwplIItAAO+U0oVgtuO63iT6DX1wP6TTnpV+7XYVGyqfuZD6Zl3FlHHMZMKFm2aZEo+tSlricb0uRj0mnmKdJ/IeZBibBUVAtT4TarQOVFU1FstAk8zoRBCIyoyjn7mv0awp9BxUkrPQq+iWYeMunFBi46YPJrNBacrycPI1eSAa8g5TLrF+Cs4+YwZTKxsGwdY+Uy+JK1KDO6bZPxNy2o2YWFBHIs9AcsUvvxGP2zIAK31m8alHa9VcL5HRRLeGBoVgwAoW3g4biA7SKmsc8MFq4pluGzZvnK0Vp0COGWtzSCB9MkALZUYcMzakv5lkuq4qTNWjZcOYLwkunqqqQAzetplz0MNismxAtuOyDNT3Oty+gqgLcUFHRQ8E03ztf1dFPBg1uDJE9htvBxJNVMN4SkHDgYBo0D6WyJdyrcgJFqlWprStxZVl/2MSiLGSu8IjsUyyQUwGGlkdaeG8ofTQlYwDlTDnJBRFY7yWgWR1mVgF+nhOKgOqSlmWVFVFVVX1ZEyDJ20A6YGnAZVMesv9JLar5qbUvN4oTwBN09TK2hSkOTWlv6B+4avb+Op9D+EJfmriZ6wV8siulk5UdT744M2h8fSUqsKVZchJRlJwYKQwNUI7N8xO5ayeapF7Zdoazl03y4Ypw1lrptm0ZoYcj6gjszC/0OORnQeoNAQwmRiBnyZ7MmaPyzKQSIdWCh/jAJxTnNPa/qrAUq/ES85iqWTtVqjUaCxqWniNT0mDCyWzGUYsWW1JMayfaTGbGfJo/nfO1f7etbMdMgncbJXCTCdjbSeLQXLBbmCtBMXC9uMENb6fxmz63T8Xj88yAAy0e/Q47ttdaguAhPS8vYfn+afPfZW5bhEiXpSYhhlVBg9gB0+Gcd5Ya+KpLlifMuPITcxrtyFdUCKfRkqBQwxigptiw6pZtqyb5ZzVGavzvKbfXTM9xaY1s2SBuAMnrVi+OwTcHlqs+OS/3Muug0v1uB2nZeB4sh10ZUm0XgQrnI+VBIPIo1UljhNjgiXKq6n5MmrLgUQqbJvmjDQupqgrme3knDHTIXMhU2m202J2qkVuTIxSAFLtDSE+74zC+RC3YC2qgbLIEwayF3jyYJf/++l7+fg/3cmhuQWSUjIuy8C4ntlzGdkz3YGng7Q5l2WJtZbt27dz3333MT8/z5YtW7j88stZt25d3ODC4phORmlwOecGGMqgbwEY3jzS55t+plHcQ2p3xb5sbVoFhALYffAIvXYeUqBimTAB1ClV5YKJWhT1ChaOZyZIFLd+uE8aaHTFB4rRa55/IWtt8GFPW8O3vPgS5j10MkNROf7us/dhsRgjlA5KFG9tqMxXJX82cUfrWwaS6W7UMQPHSy9MFdnSgorY4NaIJ6Vc+oVrAz+90CtC5cbSBUO317QwK7gKi6OTG4olh1ZKnlkuOW8zL7/iHKbbGbmkM3JY7I13vPTq83hibgn8PF7hvM1ruHjDZYg6VDLCQh5N3VFJC5S9UcFT7WsA9XMLn3VjsgxAmFd5ntd9GJBz/Rijf4jgs68QFsuKnfvn2LdUkbdbtMRGUqxgnaHhzw2lC0KNAUSwJsMlH4MqnRa06ACLgbApHJvR6LKymQ0Bid6DVFxw1pls3LQRRMgVDt7zBBbYsnk9N16+kcqHol6VWJzJKGO66LyDg3sPUdopNsy0j7IMjHpzqaqKdrvdF+dw+9qwrInghLokdqBZbkZlhJTiklAFsjSRZ6BWtILSJPV1mnbIpEh4ztq4hrXrriRXh/PCC694PrkYdLFbK/misdImQbFQDJUPRFGZCRbGum11iChLFTx5aIk5v0DlHJb+4W4cm3bg+8gmCkEDz0nLAIRJmGUZH/rQh/joRz9KURSsW7eO7du38573vIevfvWr9Sk/bfzJ/NVUBBKSVWA5jXEcMQMJiYb3eIjGu8bamvKwQW1QBJSQwlf7/Uzww6eULKWhSRzVetroQrvO+1iAKPiyrTjElRitmGrldPI88gx4MlFWZ54NuTAjykwGORVZKtRnDQ4LktWWh7RoICYEQPJMWQbSZpq4EoNRef+ReT53570suX5GgSFsLs4rRVHRybMQqBfvJflvM3W0xLFqJsdoRScTMt9jdceyuh0CBEVDnEdFFt06ntkcWtpD1MWaEDCVQQqzC4t0eK42xCNGq49HJD275WMinjnLQOpBVJQSqxxBIehJizvu383DTx6MmTKJ+V+jy7u/wapXqrJvRQpxIHFRN8KqmQ4WF0vopjEmwdogUYGyQZnKcMxmhllr6BghFzDqaRvH6pYEum5fIjbnyGKPp/YdxivsP7JIYdqUktV76DgtA1l2orNarFxJ8Mnf88CjPLTjCTCxTDFJXwpuFyeGB3bs5P6de6kyi0ubd9z86/TMkMYRmQdrVRhMCASezg2Bd0RpWYsxYE38jMb046gNeA0piI/t2k/pPcYKVdXvnYnVEp0IpWnhJFASB0V2Yhn4WuI5aRlIUFVuvPFGzjzzTPI8r0/2VVXR6/UGHnhZlvzxH/8xjz/+OBs3buQHf/AHWVpa4gMf+AAHDhzgO7/zO3nJS16yrHVgOctA83f6zNPZxJJl4Pjf7Zv/61N1Ug5sHhMPG+6A+G9XVXFDb7KNNY23g7IM/vzgNjFiahO28S4s+lVIC+svIKE/xvdoSyfQELvAcpZJXNZFKFVZvWYtBw/uHQjY6bfQ9+2vVCFYqbyXswz0n13/3JNed4RAwYd27uHyay7HqemH+MW+u6qi08pZ6nVR15emwaOu5JxNazl365kc2rcXgyOzGdZXiNe4aEpkZIxhn74iF4txPUwW2mpbkCrws4f1OJi8rZFAWxyvmoLovF/GMhAVrWHLwPDYPRGO99lhy8DAd2gIt/5HypYQKtPm0aeO0M6U5529LmRQNG9DYp47QdEtq7DZZNZS+lR0KASytTKorIk02WnkelQdWR7yKxIfx0CxIa3i03DM5J5cIcfTzkKgW+WVuYVFjDH0ygqVDBfN7ctZBo4a29L4K7nH0mvLxXg02hi25hwdINpfEZwq23fs4ow101x4/rkhYFLDNYMyoJQoBxcWObhY0mnF2g4CkvgtTHgheAiDhSFpPSrhIYh4DJFhND4f0f6qlO4zxQzYzOIV9uw9iJMMMRmVDxYeUaKSHUwJnpACWcuutgwA2DoAOSmLy2E4FXN4rW4eCJezDJzOwYTPWWUgRYhv376dffv24b1namqKSy65hFarNWBeg6DB33TTTaxZs4bf/d3fZdu2bTz44INs2rSJ17/+9bznPe/hyiuvZNWqVfVgKYpiWVP+covpSRHbNEyKK9rQAJMmtgEVxaiSI9gsp4zm0NwpjizkwWtJbh3iWhip6DnI8HgteWrJhehfFCuhrLGTDuoq2pTBpJoZclehonib4Z2nJWEBjEaDsEIIYAziwynfidA1OdM4DIJKhTGG6VaLBckw2BCaJ2HwZY0FK0X3rkRjPxl5Dz+rpHT4WCQobVASufAPFrCYra5TszyCdT2cGnqmRbdytPMMHPWpsqeC+AqnGavalvWZo1XOgbW41jqcaQergIPKKl0FsR4VAWPJgNxmdONS2FKPmFaQv3dYk9HGYX0vMLkZQ6kZpYSNrogWjq6Pm6HEQkg6uECeaNwNL5wn+myS53KLqhK4542AcT1UcrwxtKjIUYqsRUuVJRf8/IpixCFUof4AFvEl7WqReV3Hga6hpY4pY9Cqi2ctLZPRcT2mjSHPhdIKgsUCGgxSpHFuewKdDEkWKVXUGHqtDNEeU1IE5UMNlSpGj6AizGsbdJ5cPF1pg4ZATq/LbzbhigAOtKFUh20bVVvzKMgxDhdJrs1NbUC+8bcjuEVylCJfRde2YtW/wCKqBPpwUUUlp6gU1CBq2bfkyGyFlOBzQyYGTwcjymx1iJbr4nUakRD3gmkHRUAFTI5XQ4egBBeEsWwAibVQSg21ENra4xAzIIGF8MhiF2dyjAu1TLxYnIfchvvs+ljSONFO+4qweoXxbGsJHL1ODI/VOk4qKhZN13FS7o83zk+nbIPnpDLQnDRzc3NkWcaBAwdYu3ZtfQJsTp6kYW/ZsoWnnnqKQ4cOsXnzZj7xiU/whje8gc2bN6OqdLtdZmZm2L59Ox/60Ic4dOgQq1atoigKyrJfUjPLsnoBPN5AWU4jrf2g8XtlWWKMoSgK8jyvXRWpfa+KEyV3glFDYR0qFS2XUUoH58JG0Csc5eIiRenpVoqhpCq6lKWhkws9b7CVp1tW/O1n7uGa89ZQmRa9osRJqBtQZh5flVTG0isdUnZD4I8a1AXO8aqsWFoqCBEL4eSvWpH7nK4pWUToVp7VxrA4X6Faoc6Ac2gVcrcXi4qFxV5gkUOReP/GmAFXzbGsMMPyPZ6sk1yT3JuWAu89VghFb8RifEGBYa7rWayEolexVBaIGDK3wGKvYMkJeeFYlQtaFXiBnvEc6Xlmiy6LSwUVlmkMF52zjvlexc45x1LhWZhfIkMpspzSA67H4lKB0R6VVBS9Epe3me8WGN/DeRP7XGHyFrkRzlp/BvNFsFKValjoViz1ChaLiqLoMb/UY2mpIpBQW/BBke31estuWivFct9JJ+K0yFZVNWiBEcGJIVNPXi3ibIculg5LVL2SblHivGOxa6iKgl7PUVU9RD0LRajWeM76KcxSwSNHejz10JNYUSgdZ52xmv1VhXa7nLFxA+umM2RqFYtLFSVKro5uUVK6gqqqKCrQpYJCPRWhBLJxHjHCfFUi6lg9PcXiUkVVBgpotEulhvlKwAUmz1LagOJKodvrAZ5er7f8PKcK/nIJmQcZJeIr1OQUZGHx9a4ei8PyTdbNJP/BZxG2wgJLm4LCC4U3LLkw5r33eDxL3lKWJa7yVJXS8yGOpedL7npgJ0V3kVI7II6qqPBViC+6aPNaVk9Z5ucXaLVa9YHIGBP+bUJsjSWwnLqqoliy9HrQ6xZ0C0e3LFlcWsIXXeaqnOkWVEWPffsXWPLTTElg1/ACPhY36xVdDsz12DA7hXeO3BUYXyKVo5QcrxqrrjpE7AnH8vBzSbLudrsD/CNNpaH52ZVwPXy94DmpDCSICO12m/e///1478nznNtuu40XvvCFfO/3fu9Rn927dy/vfe97ecMb3sCZZ57JqlWrWFxcrOMFko/u/PPP59//+3/P3r17+V//63+RZRntdpter0en01l2U18Ox9qgmgM4XTPPAydAyttOffaqVFEZEBWs9ahU5C7DYGi1cnqVp5VbpjodsiwjywydrE2e52SaYXOLsQabZzjTpuuVxbJgavUqTJ5jNZCB5HnGzOq1LBYV7fZUMGObHIMF8RjvaLVypjotOtFK4AXAYYoMm4fUwU6ecdbGM1i7Oie3YMUxlaeKezb0dapDSxRioR3vPe12e4AffRTKgDFmQBkYbkcIqYOIYLwlE0OrdQRrLe12xnQWNmTjlSxfwsTnNdsROtZTZh00U2zL0M5nabXbZGJZO9vh1S+7mkPdiv/9j9uYmekwPTMVqHSthLgKCzNTLdpesBKeZWks050WHS+hoJQIriowNuf8szex/iy445EDGCDPLO1WRqfdIs9K8jxnqtOh07EQlQGhf7KZmpo6Sm7HmlfHk3VCmjftdhtVPcoaB30mO+Mc1rQRY2l7TydX2rklU0u7ndPKc1rekFmLVaHdMrSl4huvuoCWOY8P/7+HqXqgvqLVgssu2MxdOw+ztCQ8b8tmtpwxE83a4aRsvaXTyrBGmJmdIcuFfLpNq5ORo4EVUgO1dCfP2bR+A1vOPpOOsVRa0VJHbjIq06ZSQ2byUGhHskAelRmmO23y6FZLsm3KSrQMHBWSB2VAM9ASTEZLszqz5lhIMj1eLIbF0MJifQgazK2l3WqRR9kXpcPaLBQAkFA0K4xhpeeU9tQsvVLCvG5ZOrlh3Uybb3jp1XQ0hSdylOUuUQNlKGhFd3GRfHqKrpS0WjmdtmWqk1OVU3TabXIyOi1Hp5UjAp12G3G9ujyyx2CMJW91cKpk7QxDhi45WsaS5W1yk+FVamWAp6EMJAyvC8utH6q6opiurxc8Z5WBZOq5/vrrueSSS4C+9jw7O3uU/7IoCv7jf/yPrFu3jt27d3PgwAG+8Ru/kQ9+8IOcffbZXHrppaxevRqg9iWlwZ8Gw3JWh/T3cgto+tzw7/TvZtvD3xkYuKRUxP7v2tmtGjkC6hZiXxvfyVrs3HOE1WtWofkUPguMgs57xLawPlxvsdulMzOLVMEn6lUiXY4P9QjUkVlpuAnC9TT6EA1KJpCL0jIeo0ImgtKjbYNfVtIXE0uKKCJmQLbHU7CGJ++JZN0MQGr+bn5fhvzU4fraD9yDkNNP9Dh7z1QmTElF5T09b7n3ob1suWwDlVPaHUtOooUOQVfWmBCY5RU8zLYycl9i+5etgwSbwZ6qffIoIyHYLbSpGGvwfplc9OiTDu7V6ANujLckw+FxNizn5r+X+1wKzjzW+EY1KiOAMaiJ3nqRaMr2qI9tS7r/fiBbSypWUZHbjEwU78HaHGMq2pngi25QiixkorUsE0NGJ7fk3pGZqBjGjBYh5rBIiHa3CsbHoLYYDDdrYU6hxFCWDvFKVgcxBAKfur9D60ItBxHSDEr3LQqqiSYsvDYwFhuyThvR8q6C0GodTSSpYFPjMyI4L4SCShaliq6N0GapQk4q8hSqOratYH2oyyASApKXX6eIbkIFDbKt6xxE2bjKk+eWXq9LryvMtvO6ZLc2KKcgzA/nPM4LvdKzbfsuVs1Mc866qRDLIIKFSBwl8X6WZw9sbubDrzfH7nLrQvMzxzqEfL3iOa0MGGPodrv87d/+LRdffDE33HADIjJgWksPOM9z3va2t9HtdmvmtGuvvZY1a9Zw5MgRLr/88qOid4ctAMtNymP9e6Votnnsze1YCzYxQj/kaQeTlq9Pg4mdzhjDgcNzzHUrSlo4MWhmcUKgHo6afhVLjRoxGITMe2YzZfOmVex4fB9TuXLBWevqxTasCDFtQIJaYL3H+JLplgGvZHguvvAc1m2a4bHHgsnNaWMjiibP4QXxeL9PRtbpuR1L6Qp/pP2zkbFB2JQlLdpKLF0blryZVsarXnYFn7rrSfYvFDzy+G785RvrNEMbA/5aEiKmiVS4IsF/fd0LnseUujABJW6QMQ4mbRJ9t6ggeDJCnEimDi17ganNt4IryTnQxNDXD7YS+mPsWMrsSnCs7wz7XQc/p/2Tr5hYATBsYSLBGtLUxFQjfTSKqxzGO3I8uVRYLRAM7XyKlg3kQVYMJbEiIUTarf5zPn/zei7dsplOzLcpqpKpTqcOu0MjC6JTWthYplfptHNuesWL+If79/Lg/m4qqBtP+yAa+teUwdFyCoWANHL5exSDwRobt8zlvtP/O8n1mLLVwdyRsEpo/S8IVsVuUQV3jQeMparCNmyMDXM9y1AXeAEyE5UqExTIFMq33LxT4vRP9xr7o5HFVDUEu2oM6lQfichsCIAlKiVBXfIoHtUQAzHfK9nx6OOcsWY1m9ddEpXjmLXT0NqlnrjLY/kxGTBMcDa8/h7re1/PeE4qA80Jct9999Htdrn99tt5+ctfTp7ndYxA80FnWcYLX/jCo9raunXrca/RVAiaA2YUA+VYp9yhnhxLF4jvhok3tARHpcggLmrdhEp6Tg3dMgS6KYEkR1NClkKe5VRVj+kMKhyzFJy7OmdPeZjpTov1q6fJ0gIuyYgYLRCEckZSFlgN/njjHWevn8bmWcww0JjZ0JcB9DX1prxHgeHn1rxmU7Y6sM4GmSrUGwSE2AKnoM4x0zJs2bia6Xw3+6MMVEJJ4UB/C4gPJmtxYQGsFzVlw0yLTjw5R12jvnbdFSFWl4wKEx6DJSOkH6r0NyJNwWYDWkDo+/HkOapxfIx30gdQcvYcWmTBwSXr24CJVfNYZkFPEfChKp4RQ4YncyVtaZEZxVoTWTelfyX1JKpuxDCdC5unc6RcJBfB5K3GxWK6LWC8YHz/HWs8Z62bYV17L7ZcwkuL1VMtisUFjEkbLeFxmuOkv8VSx3OlY8/ew5x35hpW5RkhZ4X4mI4v/5N5Pqaej8SdOsSKOJ+YCAXnPapZPNSHDVo0pa/GWATppxwe7+r11Bg4TacxHJQK55IVwYcUXTG1gujru9fwvgRCIodQiqXrFZ9SnFXreGVJk3UFisDxsJJ5Mcq16NmO56QyANTms6uvvpq5uTnOO++8Y54cn07A1DBSoNQo2mq2OQoTlK83r/7W7H04LQrQylIqVtjhyqrEuTa+Cj5Bj9bELlOdjKq3SI6ydk2Hb7j2Es5Y0+KM9pVYI7RwceEIvPpeUgpT6Etm4arnb2X97DRGQ9Bh23icg04rp2Vasa/N4qmDhUNGifTcVjqplZCKlxbP2Eh4XTVaYEoyoKXQMn0OAiWQFWGyujGDBqXIJBNqIHbKrIk51sc/3Qz2zGMRzjpzLevXrWH3kSKOH4ljQAcWZgjzYGWU1yeP5U6vgz0OOfBOFcVy57aHmS+VC2+4uo4gT+ZySdpLtIioBgrrQjI6JiM3ng2zLdatnyWrjqDGUHhDpQY1ffN0rV0I5MDzzzqDspwl8z64xTQfkmngdLBxDAciJ0fHCJdv2cDhSnhs92HO37SWJ5/s0S3DRTReQ6NVZlgG4d4NToSD8wv842e+xGte+UKmN60P1TpXgJNdb0QklmzuY35xkaIsqTyxhLGS8v4CB6BiJP2E07qusH/9m9VGmePB1/PMcN6Ws3jonqdqBSH0lYFDTrJsqAS5eclwxlKpxsTpvsVjFDiWpfd0xnNWGUg4cOAAr371q2s/v6py5MgRqqpi/fr1dfT/KDBqAoymZeDEH6bWqNN6p3EFTCa6wb4GywAu+FSpNwuNpWGDT88KsVpY0L6nWrCkFRme6Y7l4nOmsShnTJ+JGIMWXUSraE3w0crbVMJgy1nraSkszvXCOz6ctjp5CLoKve6b4UGDP7dhGdCouNRnk6cp9uTTXfa51YaBwfcSQ1p/feufBn3kTc+M0LLCdCzOpIRTYLAMxFTF2HtjJFLeVqAlkAdbTFWg1gR/uvStKwNd1KAEqC9ALCqwbvUU52zewJ65XbVVKFkzhu9S1SMmBGelu62HWy3apyfc5awuQ1dHNRTTQqBbOkon+OiWErGod/VJNHVJCWx1TmLqpIRCROtXZ6yftZRHwvbQrTzeQ2aDMmQTR0UckeJh87rVpOj7YKEY7F9t0arf8KAVRi1bNq1h90KPJ5/cy9op4VAr50DRrwap0TIQTP99xbEhoVpBLNTUxaxq8zuDCnzdpYjhcbvcKtG3IoUTtB9SCFN6NBrGr/MgNiweRhLngkbLVRirqNTzs69lpY1YmletrZAkFxQNHoc4n8/aMItld31PQRFxyyodyTHniC6cyIGgjQv2n8DTX4tPPHZPPzxnlYHEIvilL32J++67jzVr1tBqtZibm6Pb7XLzzTezbt26FZjhV45RB5Ks1DIQ/MqATX5RjxehJwbnyppsKJkugVDm2FVYPJ1M8LaFlxa5q8hw9LwFDZSlSkj/mjLKOdMwO9UlM0qJDTnMGvKDF4CqLJhiEc3Xs/T4VzG+oH3ei8GGSerJ6RCygg8bQTREkBuBjqnoZFk4oUQFRnwJWBa9QxTaIQEcbx2CDSbBU3h0x7cMhL+DREMpXK9QRs6EUGkxEjWpjTyFgvMuKFtGaGdhYVnUNh//8i727t7Plk2zuBg8KSa4GnJT0b3/H5DF/Uxd8RrEZpQP/T9sW7AXvJiuXUuF0PYl4exqQ/EcQBf24LZ9Ei67ie7MZtpAR4uwmZqM0jvKsofi8V5AM8KW4xDXZdF06DnoVAVkDs8UBsGrrxkrn65sj2cZCBUClbYJde4RiaVsg9S9r2LQX6/OuXdSslC1+IevPMli2SMTJbfgxKNZi02mx3yrJBPodkusGnIJPmlnQxBcriXednAGxAcXjQd6rsAQLFNGPFYLKmlTWqXIoBBhGkVMhotcBVOEVLZ2uxNOrGnEaHT9eCH5vRLJD9HcbggxI4JhSaaQEB9PGNnNDZbBnT5apFysNSBR+z9q9FYhxS+sB4bKBOWkjGWbK2CpdFjXowysH/8/e38Wq1uS3fWivxERc86vWc1uc++dfV9Zfbmq7KIxdXw4F3S5lgE/wAMSkgEJ8cILPCLxAi888mCEhIzRkSyEjpDhANecc+DgotxU2WlXpSuzsm92k7td/fq6OWdEjPswYn5r7aysxlXpy6l0Rmrn2nut9XUxY0aM8R//8f/TamWmWSRw4Fwg+p7KWW//qIqo2n1ve4OSFjvcef1bPPTc58n1eTuui1DCwgmNQI+QM0xEuDyCUVMVLoDjTOU5G1qc20DFgwtcrBbc60JpKTyxTXeaSMUwrXLYPiaA8wyluJO79pR/wh9yfIQMfOf4sQwGBpJgzpmf//mf58tf/jI3b97k+PiY8+fP88gjj9zXovZBveYHvWh+EGRAKLVhSg17gDPL98TS1XIQn1i/ithhRSrQnLMMS+hNLyCbbkGmwIap5+K5LT7x5CWqR88yamqs50ARyUV9zOMdSF4CmTS7S14e0jz6eYphPCqCzxbbm9SwOR5WorjcE/yYLkMLBIRaHYgj+UAH1EUvZ+AafxBNPT/YtTu5BoOq332opA4QrNVlxZfMwptqWheFN+4scasekZK7qMGeKs5qs/N7yOFNNHZQZ/T4Fu1Ry+Sxz1gVWVwhq1n2NWRneTUj3X0T99SfQbEDNhQlyJhLm5dAyqUcoINTpUEFvXPkqkHpSnmnLCB5z4H0Q87r90IGrA59ymZr/Zp5XX5RTSUbVRKZ42XPvJuxuWlEzJLYouL4xBMP0usD3F4kyIm6CiactSapJUgrkIbsBC8mZKQpMhJzhnRqvpDWnqaIy2jRzRgwHcV4H06E6aTh0gNbvPzmHVQKQW7I6Qf2ogx+G6c/fl53AsXSJirrQ+z95v7+eTRkYPiu3hcwCIDz9CrU7oSS2JfmEgtwlZiFyouVvNTcTV0hGedhnTpDRxQhuKLDAbaONCGrI+rja9A/jFRTkBp0iYuCr8d4XTHRBTDFNQ1/9k9/ERnXDEHRuY2GZx97kGtHPU6Ere1tvvy5R/g/fu9NjlaRpGpun6poikYwlmI7XYLI9af+gLbgj5CB7xw/1g2UA4x2/vx5PvvZz/Kn//Sf5plnnmE6nd7X9vRBZPQfVH3/R3/OoV3J4THyU/F1Kdwxu2FSVmKy+nR1SsSnJC7ErPR2ApG0R0pL1aj2bG1Mii2smISrKlKyOFnNWV59DcktmloqN2yg3/VTImI12VHlCKHm2t05/+35N/jma9fIvkbFc2//iJffuGryYiKlmvnB1we/471xmqVcOjFiXFcoB1hUKZK/nHAxAJIKST0RT5cFdaatPjzKHuEBZxuyDJsvdjArIMPxP9Sah0eVGRBzRvQkRkWoaVL68Hf2j7m7P1uTxGT9LMM8VnzjjRtcvbODET5P5tV9z+v2g8/rd13DggVDDMmuvOePrVPVQr5UyDKUi3I5DOxgsjKLUlWe8ajGO2uBG/uEF8W6NJR0tMfy3Tdx2hpXQwRyT3/rdbqdt3HxmHtvfxv6mV1vVcZe2KqxdlDMWnoNdTtIsSU4JScTGVKB6ExSKBNJksgkElpUOC1A1B94+QonBTMLqBGshFIO7vf+AVhm+J2XXmfWGuSeUmbn3gE3bt4r6xL6DKFuyHr6sbImnw48E+OU6DoAAUGyIEnp795kfHyb7rWvIe1tnMxJR1eJ7/wOo9yis7vM334eH+fgYDxuGA0aItg+PRrVCErwjsoL5zYnTDz41OE0ozkTY4ZQcePujINFtlLBGm15n8X1I+wP33ft/jEcP9bBwGl4ciDbDG2FQ9T3fqZEP8z4o0QGfuDfL1+tC6AcKFnWzPfhdh9kUq0X15ABh65vqiysLXpVBHFK1o4QZKhGQLYMdf3uRKkB6RYs7lyHuMSJsdq/11A1ud4Hzk75k5//FKpwc2/Ji+/s8Ma7u2ZQI8KdgyPeuHaDE3d24YMKBr7rPAtYADCwqS2qyvnE/vXkg3BCzjpVljXkxtEnWPRpzb9YfwoFx5DhabEkLjm/ntRNA2YJe1JFjoguCzCdSAiSFlT5GNHEs48/xOc/+QTLLrI3WxLFMyiyDe9bEXo8f/D6Na7f2SURUMwBkXUt+Eef1++3hgcZWQsKZD1vlANrqA8nxIhjRYTphOU+BAPGcQEliFBJ4rMfe5RRXa+vX390j+Nbb0KclbkT0Ei38zbx4DraHzK/+Sr54I5B/Zp49pHL/JnPPUu97tEfdBCUrJlQFX+K3CJEsmjR0C+ByhBQls+0TtO/z/oVWMttIEOtXIkoEYP8ZUB43vNHUeaqfPvqTWZtRNXaFmfHS27evkcScyjsVfBVVdZEPvWO7r9uqSjtyZCNl4+CZOJyl1E6Iu29i3ZzFGF1uEd7+2XIK/LimHjvTdAjokB21kWUNZdWQ8jJ2p69E4IkGgcjMg9dOEeFMZAmm5v06tmbtcx7JYkvgdHJznd6Nn6U8REy8J3jxzYYOO0WFmPk3//7f8+/+lf/ijt37vDtb397jQp8UORB+OBrSz84y304PADE6mhYEJBxxcN8gCmLNzyAs+2wqryZ2+RYElNPzJkuZlQc5EjtFCkiOGtRoZJZFdAQpxmfVlR5BWmFiy05xe+8M4cNrBx8DmFSeS6fnRKCqbr1bsJKvZnTMBCbqtNPwI9+y5+gR9+PTX9yfFMYzXY4rcliDNoNac3gVzVNfTfUjwEVj/iwztCdKi51hBSR3JvCeorlObN9ZlWD/klrYx7tjun3ryNxjvZLQxkWd+HoOpI78z/Y8CTxHK16OhwxW4Z1kjNZb38nnuQD6my9DHHAj5Zbnczvd8uutBDRrM+eYlAzEM0cmpUsnh7hcNGyivZvLcHU0IVhMVteLysB82vQyINnR1SulG5IiC4ZMTcYm379mDrNqXSJpBWTeATLHQsGnOPspOLCRk0Y0AsZYHz7ZyVqWhH9Aqc9Io4uqvXuq+DVWxatJqjjVfB6qkNCh3k+NdvvCRiGeeoy7B4tabMyKOydRvRyQfsycGfWsfITDhetHbhRTUsAz1EXOVhGEobG5ZSHSp4lE+4kaTK+kYlYVZUFiwpEB7gOcV0JKwVSgDymDhsEOsiJtFwR4graQwsA1HAtGQSuKF01KNp31hor4FJic9RAjIbQjCbgzLchiafNgWVvwfbpveAEsfvhxx+FQ+qP+/ixDAbe2/f/jW98g1u3bvHqq6/Sti3/+T//5+/4nR/19QYi2gc51jfi933e0+xZsRtercrZiVi/tbL+o1LKADHhXCgZaT45nL2zbgIzNOfMZMQkCLWsqwzIOks1go9B2RlJLT53oBH5Lu/9/WbbBHOU4ISoQnQVeVBn08FxcbgxPzhc4AdtWTRI15FVWPWZXj19HgoHWL11+KxryBuuXNxm4iNB+0K6uv+1xh4eOb/JRhPwuYfc2Vkz1J7FiFGVKA9dPMujVx7Ak+j3rnPnhf9Omt8h7d9EuwXda7/H8Qv/nbQ4IkimFohUvLszYxVBXFhft+GNWj74PvVs7PP+KGMIjr7rEAw6xw4vH8KpNyElcDWL66//3re5tTMj49cBw/1KlwUdkBODH6eGdQw5r2rGS0fIS4QW0d4eLME+aSGvVXHG8t3XjLsBBMlUYsGHdWz4dXk6aIZuyUbwPPXQA5zdGCPZ9AwMag90Pag6c7AcEDvVk6z/+06kDMKUHM4X/PevPc/+bE5XBKT6aKe4ijPzIXG0vfJb33yD4w76AR1UBR9oEV6+dpevf/Mt2miHqYn65PVcrjkPdiHtioiUrhP7jSwRlUgu/B+7URXJGcmZWOZGu45+2XJ89XUa5lTFhkk4KZVYUKDkWBKO9W+cBKXOnWgQ4AJXb+7xuy+8WtAuK2OcvP8fbfxRtTL/OI8fSwLhe0fbtly8eJGbN2+yu7v7gV/gD1oI5/T4vs+rAxStrElKGAR41CdarI97gJcViFFxlcd5T46K96VlTY3H7L3VjXNRKHzs0ja6rKnyEj+8HnZAZkBUiqCJklNvBKwcrbY9SO5990+IYnoDguA1E9Ogx1YkZAcIff0Ig3wdgpHhfvh5/57toOVDqthm7HAs+2gZqq9ZdLHA6uXgi/E7nuvxy+e4tH2Hxc4KqSdmfsNwiClBe/7Epx9nlGdIv7ADKtkh5bynLbwNyZlPPPWwiezEBbk/ZLK6g7R7cHyHSiJufgdxIyQVTz8RJNSsUk/M98u7ns6f/Oka+OlD4EcMt4a2ze81FKHtzZYwv+f1UlbwnpiV2WrFRk7k4XhQ4wEMpapBEAcFldJ/r4ak2EFlkYNlsC3aL6HpyTJCJJAkkKUBGTFymX62C1oo8YNqp/jy+id8Ci+OWoRJqPhTn/8Ue79/jb3FMTkq8wQRhabhOBmPYzhK15DE95yc4aQ8QQb6GNk/ntOlhIzGZqqEkJOp91EExOZtx8E80mtNyrIOqiOOlXhWXWYZlUnjTGWwy4aurEnL91/9IQFYq1QClaoRlFOZ/9wi/S66qHB511gS/RE+LkAcsTuE9hrCeagv38eZsL9mckxo6stVNrllwYFau65oMnplhg6l7fr7VuzpZ/tRxntFzj4aP6bIwHvH5z//eW7cuMGrr77Kv/7X/5q//Jf/8gf6/MOiOYGIf7jxfrWuXBjgpwktphtwirEMlnEM2T+Oo9mCX//6i+wsVmtYW9WQhreu3qbtuvVh79a7qG163gULGspnGXtjqLtsddJ1ZU51nbEg3jKYnOxd5aISt65JnPqQNmv3f1Yt5CxRYkql9WrQVi+vmE8yF2M85/UcvN+f71891PdFXk6eQwoEWWDRDG+8c5O7e0esusTVWzsGbZc5yTm/ZwNVRsHx4NmpZUOxoyreDSdHcWZEhuWMfn6Idiu6oz1kHf440GINnRM+J5xkJK+Y6Jx0eJv+4DaVdoS8IrgWSR1gPhAo7Bwcs7u/KOj2/RejsEju0+pz65+eYE4/zDhBBuS+73GamOWE5194mTev3T7FpRgQcgtRogpRg6ECDGEtDAWqkyDx/oBGSxaOWrueikdyppsdcve1l8ndCivGOKLUJCpUTRdiLD2kVGblpMPCzr5SAgK2p2MubG3gc2bshaa0u83mPf/xK9/gP/7GN/j2u7v8169/k1mf6cVcRvP7Tqu+5/oM8cB6NYIPSGMG4F3X0Wfla7//B7z85rW1rHFSWHaRmD05W5eLFEgvAtd2Zrz6zh16hZigDjVJMzgTBTOfDFm/tqxn1HhGZXJxSSA6XAKnSu6PmL/zexy++J/h4FVIHdodI/0xTiOBlvbqN5m98fuIDqWwcnepIjjOntnmgQvn7Qo7h0kSO0QNNSRbB5OixFxKSwOstQYOT9bY/X+Gmfx++8JHyMD7jQ8FMvDNb36Tn/zJn+Sv//W/zng8ZjKZfKDP/15t9w/oWREy3kGbjbDkNUKOiG9I6sqBmVH1kKxcF1GaKHTzyDs7S47dhHFlTWMxKs617PdLujAiSEA0krz5vKfYsRUm1FLTC3Ta4XNPLcpKKnCdbc5ApRHRhLoJQaETR61GDmr9iEl0uLxCGCNkkAaQ4mKWSOqIGgm5xTr0xTIc74ipLbdrZBAQSVT0LphDIyBUgILLnK6Cw3tr3cr3yhS8mNIaEojveQ5fMkopc99LYGep9OrwLrN/MLM2Q+dYFsZzkITiUV8DmbHAJ564xLeuHrAiIHFJVVq92iTUflLisDmr3OOJuHbXwqAU8JrIfkyWiqlbFTZ9jXamfCCzferVHiJKGxo8CZfusUqPgmZGacmcwHwekTjHpUTvPJVmkGytZGwwjskCO/HUeQVSkziVyf4QQ0QQ50ilDu01l0PAoPmM0AN3usBy7pAUGWkPWNanXkF7ch4xdzW9KJPUsiLSuQakIpQrHPGEbIiUSM8qO/qwieJoNNOJI1Lj1THujuj2r6M6EGc7Olfj8wLJc3JWRqlFE8QcqfMMlRHqAkmEqEqIM5zzPHZhk4f+xCdpKlgp+BypRZjrmOODY6a14wKBneMVmk2Tw8KLohddDnlf2nRPoG4pyJtdBdMkSHhXceS30CRsTxKtKG8eRs64jqeBcSk/xGzqDBUzRFtDKOiI4rk7z/jccWZak1UYO2WhysoJDzhhnjx9SLY+Ral7Tx519HiCjnFZwSfQJQh47YFIyD39wT0m3SHuzHnqmOloqF3PJB+APEJ/PCf1K2BO1g1aPJPcI8UC+uNPXEGzlWSSOMSV/pakTL0iSUCqMkVKGEoHRWkyiyUuNo8OjZ2ZM7lS3hl2gyEW+C5bw31W2x8FBcCHBBnY3Nzk3/ybf8Nv/uZv8uu//uu88MIL/6Pf0g8wSj1XYW/ecmtvbpmOyH3Z8LBpWGA8ZDAG3asLJbNK3Li7oEueJMp+mzlaZVI0VMADSRMhOKZVoEZp25a2XTCSzMSXjgNHIVFhr14gO8uMxWBV7ezmzB0+L/GpNQRh0EUfuAkieBEaSaXXunC7ndUvWWf9doP3WaxGr8PsDJ87r2vEw5/hRv9BMtv7tMrWz63rlsn7sjIMZkWkZCfD72d77zkRpLz3cp08ZsVbB0cQpfFK420DE2doihVl2nULnOgKpxGfEz63IGJdFKm1EkLsybNDfO6R4x1CmXMVZzyN3et4jQTxhNwZvK0O50pGxSmtBECTGRftryJX786M2Kf5ZBJ/lLHOxigwvf0rixBFOFoldpaQfINqWs/rEAwiJpTUFSKsdZZmkjgovfmDKNTJhddCmpWSaCcLalQhRWvBJJb1khFdEVKLHt1F57sYsdJB7AlxRr/7LuTWnDlRgip6fJu82MOJ0NTBuAqCzXtuybEHV9NLxbKzw3/dMXLfqpP1NJ/uQDn5/sk6HLofegJkJa8WOIEVFfdmibuHS6RoI8RsrZi2NodrbgYLWSpKGkHOUDkp3A1l5JyJQXlHFmP2TytPkITXzBhMCKw7ot+7YcqX/cKQJc14jVS5h+UCl3IhfIKnw+eIT4maFfHoJjq/R62R/uBd6u6QqXRMvLAZSiutE7xTnEYqbx0iwZubqorDh0DbRZKyFh06ve6AtePiCWow/OxHXdh//MaHIhi4cOECn//85zk6OuLw8JCjo6M/ktf5YXkDp0Gr+8Fzh7qKF15/l9/65stEF1CxvHhY99ZuZPuF15NapmJ1eK/KYpX4redfY++4IxG4vXPIjbtzNFQkhbEPBIzg9NiVczz72AVy7Mhtx2eefohnHrwAubdWJjghW0lRUZfCjJbeblxtIc/xqUficv0J89AGJHZIbo5qvvDpj3Hx3JmyQcqp+3lgBlgg0CngA99BR9OTw/q+PmtVTm+27z8scx0MlawsoYUXkYeZvf86vWcPkRI0OHLpupCTDK+IxzgFl3u2x4EvfPppzm6MzVjHKXZMRCSt8CLgDK1xOjC0CxokxpwPkmiP7rG4cw2Xl3B01+rtOVNpxuXI7MZb6HyXC2cmPPbQBZyYpoS6QJu0yP96UnGNhEyqAq/d3OG//d6rLKPatc7fg/z3Aw55L1pWWuT6DJ3Ca9d3uLs/x3njsPQpG9yd7LM4zDwn5UxSNQa6K852hTQnUJxyT0h0oorLHUPfvGAHFbQlIB1oiw40Ms4z8s51+jtv45yhJ8IS9t9h97Vv2qFHxuVErR2r66+w3LlVVkfAJLLgk089wpc+9ThnRhYYCEIsvI+h2+d0iAnO1Dbt9Pvek1mWdVYlp0TwNaqCF8+9e/u8/OrbqLNDvCvXLuPoMmUlnwRjijkV5gy1D5AzTjNNVVCIqsIj1D7x6OUpVWx54tI5Hr+0geRjljvX2H/zBfLqgDTbLaJjxYHTB+hWReAqmXNqBrRD+hkhLTl86wXy7ls07T0OXvsdHj3j+ORjl6hUDUEC20tcpvHKx595mLPbFaoRFWvpzCmRXKBnUH4c9EAsaYhAlEAUT3bOAu3Tgdj32Bo+aGn5D8P4UAQDAHVdrzUGhq8f9PjRRSpO1bqwza1LyiwFFtSU7QiQtbNrAnaO58SSNTgcOEjlrvCqxOzoNBClIvuaJIH9owVZLZoei5Hxgvc8eLbimYc2kWyWuJ9+7DwXNxpUHNHV6yy1pwJXr4OBQYZVLSUD7a3GmiOmJlfQvEIGAquxfuLJS2xNR6Vn/BTgryfBwN2DY+4dzI1oNrCGy5ACulIO75NDnFOb7veY8bUYT0EEyueA4Vre/wzvJSsNVWq0IAOO4kVQsj01lbxKMtNa+cQTF5jUJgXs0IKEYMpqYULvN8kaEM1FETJDMfbVuKI/vgvpCJ8WOE147XGTDaJURYTHEfoFcnyTie/52BPnqX2pdUtFq4Fbe3PaZOI4mg1AbrMwS3DQF3Ek8omT4o8wNGcGEb6haKtqm/e1O0fsrxT1FTklOyxDzd6spU9rr0xyysVRUzDlOV86CWR97QZEIYv9y5GocltkfcGlDpnfxbXHiPfk3KOaSVJBzLjlPhMWuPktqnyEpyMe3kSWO4Q4hxTXrZCSe3w/oyqqhENrpAcePjfhM0+e58LU49QQo768/xM05gQNsPtpHWK/96fvN6No6c9PyQSZUgIXarrYk8rq73M2nQoX2F0kduZW4nOFLJpx1uGgELw3JEoTdSHpBXH47Kho2a57xrnnqQc2eeiswPxdqu6Iut1DJBLS0oIwV6FZIdSYVHFGcm/lP/HIfJ+wOsb1c5rVDr4/IC12GLW7XNhwPPfYA+ZrMrQspQWN9DTS8onHz7A1Lg6fDsB4VJGKu0ctq5hPzZ1Y6a5P3DqYc2fW0pZt4yTZ+t4H/cDT+micjA9FMNA0DRsbG2xtbXHt2jW+9a1vfeCv8cO2Kd533JT/Sek5SsDxcsm1O3uscqArhPAhY80Id3b3+I//969z7+CQ4fBUEWKB/gLOPNNdoMtCwmpnXSzeoQLbY890OiWpMHLKqBiUeIGJWL08u0DvarIoUU0uOKqguTfSUnnHSul9Th3kyjbA3JUDUteyumD1+kasrdAyAasBWtLngEAb4XdffIdrt/bt0FhD+afnz1v2ASVYWE/m9z3KhuzspC44kDXL2aWyrk2oKloyIF/gx4j1PEesLum9K88ow8UyuJNEIBGgZLW2O/UMbHdIo/N008sotb2Wr4kMRjlKO9tl580XcN2+oQqjTbKvYHqeNLlAqsYQxtTa099+HennVGRIPSln2izsL5Tfev7b3Ll3CGIELec9UYFQ0RNKSccQnB8tN9JT0LeW1j8B79k7nvNff/ObvPTmTZKap72IsErw9Re+zZ2dfVQzlQfNaa3DT6n7otk0DMQCYy/JDsmCUp3bHPPJpx+iCqEcnituv/I83Z1rZB0aQjMdgnYdaXFA0Ba3f42q28P3hyxuvIYuDwkkI9QpiLPwIqdo3R+pBAQK5EyDslEJ09o+f1boe1ubMaV1QDAEEFmh7aVgUvdN3fvMphJjhIKWiKtMMthXRAoqUq5YTqZOmHG89OZNnv/2DfqkjGpP8M7ajwtAUgePy5lJ5XnwgXPUTqjEEVR4/KELPPngeT75+ENsBQfzexy+8Q2quGScV0iKeC/k6Tmya+wgryemV6AZyS0pO9SPyMeHSLdC4pK6PYDccXDtTfL8AKdtkYE2gqYIPPbAGR48u80nn7zC9ijQiJROmdLmCayy4zd+7xXeunH3BBXEUoN3bt7mP/33r/OfvvI8x2273h/uI15/jzHs5R8hBDY+FATC8+fP8+f//J8H4Nlnn+Xf/tt/+4G/xo/aRfB+hLeM0CalTcK4QPJWE0xQcp42Zfb7RCt2qGSEKEovQvYe7bX0wrsT4SF7w3azamZr7Llw8QJ3ZtcJTqlcJotJsTYScbnDS8IHh9cO7zwdAa8tkhZk3cS7GnRuvfKpJ/czTMWmh7gCH3FSl0PGr7P3tVyIaiFEDtjACZy86AWpJ/SxaDmoX09YxrFSqCSQY6QK98/k9x2nORBl7ktfA7nUgcOpJ1LsPVSVCSAlERYZOqDHl9rlUP89wRxEjG/h1q+gawzD5Qipg2ZKNdlEk2EvKVtmp2W+pDugWtyBvmgcPPg03c4t6nOPEd0x9HvWUbC3A8sdXJxTyTZOE31KRKk4XsFxqyyjtW9qCe6cWOuWW5dGCqAqP6xn4TC9hgZYo0Bel287hXkSljKoWpq8cC+B474nRGP/B2/BZQa6CDgTq9FkXRUgODW1uiAn3QRnxoE/8elHCQ5Ue0Q7wnIHWR2g2Yi5Lh4T1OrfPq9Iap4O9B2hrpF2Ad2ckJbQz3H1lnXJ5GSdLXGB6BynAcUV599IoDLiJJZ5dwM5swS5w3LKZYkMmNjp0Evesyus198p5DCJkESQuiGxtLmRglKVezu5wCJ5Zp0dsme2Ntg5WEDhkahaLd6T2N7c4MGLm7z41l28CCPvefrhB9icNDx+fosRSk7HaH+I6HkL8KVG6zH9dIvUZsRB9g2e4huRe5JUNFvn8PMdW/kZSEtDiWKkIiKpxUkEFUQCToWf+tSzBAdPXjpHdsKYRE0yI7BhHeXAcScso5Z2SNN4yAKrnDnoBAmOTgdUT9+74X7P8RF58GR8KIKBF198kV/6pV8ipURd1/yVv/JXPvDX+GAWzMmBNFQ0h615qGcbG9sgXIPJhD40rMQ2lIPjOe++u4OcO0uSgBOPiJa6nYLm0p+ta9Uvp9aFkJwgkoxaVGrULi6Y33qZOp5hXI04uvYSZy8/yKjeot99C733NuHSx2k2Hqa7/RJh/wYhHdPfeh1/vMLLirR/G39pC6Gyum4pAQyULyllgyLMa6QwtT7zPiltdnQqVotcP8rG8aLlpWv7fOKpK4ydY62P9oNejvVTDeCsZft39o64d7DguScuGWnSUh2bQwQfAikr33rjLmfPbHDj3hGr7Ml4y7bLIaclSCtKQkORhyEscIC0h8R338CrI3iHLo9Y3ngd0RWRyp6TRFjuMF7cgZ1M9g1pfIl+0hFGF1nVFRPt0GQyvSz2ifNDHBYMdDGTJXDz3oEFiKV2f7SMxJwJTmhcptKlacHj0eLM96ONAe5nfemyWOdIkoDisXp+MnSEik4c81R6+vWkxHTv3gFdH0u7WVqjDRojI6/UwRty4zI1yYIGsQNYtGfMCp9bK4+knvjuS2gbkfkNaPchTGizUFXbJDexgyAtqdt99M7rtM0hOjnHeGMDyZG8d5t8dBd3doKjwcphGUTJLpAwlCv2hgjkgceiyt3dQ/b2Dnjmmcfo+kHg633W5nvXsZ5A2MkHvv3OnpGB1a1bKS3usns9q9BLxSo5yEpTOZwXUlRiNuTCO3NLrL3YAZ8TVfAEhcZFgnpqKts7aEE7NEHGo35E1EBfbZOqFb5bkqpJ2VcyuVsSXUWksnp+XZP6iMvG3RCN1PS4OCPNd5jv7rH58DN43xCkmCY5iOoYAQ3Z9qpsEWx0JleW8IU4ktfBfMLR+QZ1DWs3EU0n6NIPMD4KBE7Gj2Uw8N4sfTQa8Xf+zt/hypUrOOd48cUX/8hf84d+Hnuyk1LBqQzeKUjJ2FVO4LBOHVmMiHRwPOOFV97i6Z/8HODJWm5wVdKamKMMJCrRbHXurIXxbNxjccIjlx6gjgt2r32bqvoUTQPH11/hzHaNC9DuvgXXv0WqxozrM8zffol6vk8lS3T/Jr6vUN/RH+3hH8gmGGJYK0N1fl0f1ZNSi5YbV1HTOvCBZ566xHL/HjFFqKv1Gb5/vOB3/uBVHrxyhtHW1Fjw5eT5frfxULO1fmqTSbUyCly7fY9Xr97j8UcuMq5OApesGR88qLJsO7756js89NADvHPtLjreIAdfoOohKy5/k7DOikuPRAnyMnl1wOrudaYPPYFoT7fYZ7ZYcFaXxKpeXyvXHlOlOXk34TcuU116mrB9Adl6kH5nTpQG9Qn1FZpa2tkhbmplk5gSVBXHyxUV0GbLtu8dHNK3PZKVoMm6D4ruQhRwen/wRZmzdYbF6RD2RB3hJMY6JRVblPkG1sdg1uPy2p2eJMbkX0WHOF/Y4zaPd3d2OXP2DHXl6JNJPHsU7zJf+vynSVVjbWRYbZnsC7k2IdohcWmS284jOZJuv0HqltShQyQSnSdrgHpK/eSn4Po16GZUaUbaucoi3iE8+Ayj8UNoe0y/PESO71FvPwSEtQSiArp2ATWhIOM8nADUd3f2eP2td3j6mceKDPMgib0+zk9FUCcBZMYU/uz6CK+8+Q5Hi2rNPXRDN00q3gkFd+kzhKx4V7gw3hu1Rw0lESA4Rx083lunj1fwpNL2OEiBGynQnqNG1aNhzOYjz5G3z7N84wWSr+y6DkFXyuR6grpAePAJdG8HObpr8tvaUeUWSSvifJfD66+xcfEirtkg+ClkQws8cPn8Gf7cT3+Bdw57fuflGyQyqZTy8uD5cGqtqpgbJPJ+x9j3hgeGIOAjG+OT8WPLGRjkgXd3d/nVX/1VfuM3foNvfetbfOUrX+HXf/3X/8he84cZwyQb+am0KaFrHwAlkiQbgYoapFo/1gNVHhNKi1oWz55scrCCJgvZJbx2qEvMNSJZaDL0saNVgJqssJlW1FEIYYT3FXXyPLbZUIXEyHf0MZEIjHJnggarQ0Ka4XRJ1e6Beure07lMnoxosse5FTk4XAp0boKmY9zxNfJixiwrferMNg0wJkSgFiFpxrsWJLPqE46eT50RNvzAFjdYXhF69SyloU9WR7yfPPj9ZYujWpYq2gIRxOa0C1OOdAQ502Vhd5XpU6bPSpetTXAlFfv1JkdaU6mn7zv6OoBU+AjWHtkTRVj5qdW/Ae2O0eUOaGebdVJoGlKzTQ6JnFqa/sBaCLUlLO7iD++gucdlxUtLqoHJJfLFL6DVNmfijjHJq5p2tE0OG7gUkdThJdBrYNOB+J4+jLjXwyJmDqJQIWhSsmT64FjGgFPHcRc5aE3YZqhyJ9Z0RvtbTqyyshsz+zEZ9J2N9JhQOi3kUrWDLoujzTBrM+qMAFdpTzsEibmFrBy3PU1smTQVRziWOkIl4EKiSQuqlBBnmSsh89D2iAcnVUFiRnZXScKLw/XHML+O5pZV2ERQxiyoujl+uU/qembhMn0OTJjTuwa9+CTUY4g9EVPDnLR3qfPSYrP2iBHH9KsDwAKTDk/nakSEID1aum/ms0OSr+nUAT2iLQvXcFxt0QNtTARN+JzJhGJWlQtfxIH2iCZ6Aq1mJnlBmyPzJHQaUOcLIpHXnQlddngyPifrCskJUsaLFNTACISJFVJFkgZUGtp+hbiI9w6IeNfgqFCHUfVzQxUV+kM653Fxn+wmcOY53MXn8LlFKk8qVBvXHhEW+4Cn9xt05z/JKmwjuUfmuwjGOcpujOQVdZ6R2iNY3DSMzrWoq1EXGDeeT10e8cSW0OIQ9UXiWQ0VKDe6aVpAUEci4Eg0KE4dKs1JMPs9ComnCYQfBQI2fmyDAbALure3x/7+PteuXeOFF17g5s2bf2Rlgh9m0Zx+hCnele/rySGma3Y7nFSdy4NVcOqsfa0cf7M+88bVvZJB2M1iycJJN3anSnRuXevcGo2spW7ttiaUCr+p9KWEqFBJhtix//I3cLvv4nNHPLiN5hUhJ5xTGE0RPFk96hskz8shHljefI29t/+AkSjBBTNLKhnQcGs6gQvbU5OhXSyJfcd27czp7JQ/wbqNaG1uo3+4EgGs2yVPD08GkRJ8KV1K/Lff/j1mq87IdSXrWaXESs0z3ohd5Z3lQQwlI0SzevZV6XGH+Z132XvtRVzqLSuWZF0XzdhU12JHSCsktdQxsnj968xeeR5ZJNQpbUrU0ytAZYiDJlyc2+euKlI1xo2mkFqSODoqeqkYVRVZE9EFnn/9Dv/2//5dXnz7JjEZmB+z2cL2JlfJG9dv8OJr7xgprGRdwxaqw8rMmajK1194hXdu3l5fm2E9i7OSCaVUklS4d7TgK7/zopUJRCyDFZN9FrG2wsPjI/NtOLeFpIz0UKmnRnnwzBk2fIVXV3wCzFugErsPdQiqCzF0uXOL2Qtfo2qP1zA4qSfHjPQ9OSoyvUg13kJyKsJOwQ7OtkVcILYtPrfWxFZsoiVH+oO7kDvIvZlOqQkPXdo2qDznTNeuiMpaFhyULkNLxarP3NvZXa/fvJ7lk6Nq4F30KtYlkKwzYO94xWzZscbX8hD+mrGXqiv3nSMle31XVChFc+ExZJwvuENWNseBi2fGppgpJ0iF3VcF6ep6ZHYAaQXpGNN1qMmMrWww2iSPtvA5kd99g8lih6qyABpfQTC74rw4wqVVqZwo0i3wuSUe77J46xW7TsPNmTOO3tqlc0Z8sHJj6UJaz9Y6kTqNPQ7albKeqwF5/W5jaC38KBA4GT+2wcBA/Hj88cf5B//gH/DX/tpf4+mnn+bhhx/m+Pj4A3+9Qdb2/yke2PPZgkHcBwKSBaI1MSUtpQUnpuMOXHpgm7qqjQ2/JrpJEc8RfO4IaYHLK9AlcnSLcHTb1OqWe5B2kTzDxQ71IyMo1duMzlwi9PeoYocQWC130cM3qdqZRfa+FAQKsUrE5I+fefgsdbNBn5R61NCMKnPcU6sGWlPke2lXP8TIyUiZg3BSeV6npTWrKM7tz1s6tU4MR8aRWLUdZFi1GfUOoSjMaUQcltn0c7wmvCiVM6tbXR3RzfdAIkFnuLiP1x6pR+ZoGFuq3OL6JU3sYH4VWdxE20Qngm5dZPrw58DXRbBIyVKTciD7EXl6jnDhMpBJ4klSg3PUDlyy/u+DznNt5rlzuCLi6bMd1FFPHBy75YqjZVs6QEyI6LT8L5j3QEqZw8MjYt/bUTdArGCti0VGWjHFwVmfOWhhpeE7rp6V1T1933Pl4jbPPbzBlIzve2p1uKh84VNPcW5SEXQgQZY+fzWyp1MTWFaxjFm7OW6+Q60zal3iSGQCSTxOBZGK8eVHCecuk90YdRVkpfZGxAsXHjCOQmG70y5QnEn9Lo7QuIA8J6SFuXamIz724BkunNkAzaRkkuIpF8c+cXTJjMJyVlZtC87smjPDPXvf0QXi6FXpFXLRMp7NZyxX7dqSfNh2MtBls/jNEshFX6JPmeAFScYLsg4NxXtDEUZemVbwM198kpH2BaE4dX00mxukgKaOka6Q9tAEiQRUAsdsoGceIZ97guw8vpvhu2NEDKUSjeAqktRItyR0c5woLrclOOigOyIujsy9Uy0Y8vGYoEubDRGGriHrn0hWwmMICdKPfHAN+/kHbT734zx+bDkDg/2v954bN27wy7/8y7zzzjs8/PDDPPXUU3zhC1/4QF/TOfeHEqp4/4Dhg4pCpdROHRohE6zmnKJlK5iIj5GrehxK5a0+G4pH+sCGt9zYcXYcODcGP2uhnzNOx/g4A+dpaOlvvIjLx/jYk2VMYsYqbLIxOk9/+w1k7y7hwgOEKuF2rxP3bhIubhU9BDu0HIIXaPKKMwFuJEdKVnf1zuGdKweLX7PT39OQ9YccShD7gwSy+DWkLae81pMK0Y3oRehjovbKmY2G3cWKGDN3d3ZpcqQRz9g7Vg5UlNQu2X/r2zSPfx7RZJ+BjI8LqrQEXTF/9x2qWy+Z+mA9QbqlMeVdj6SWvNqnDormBs0eJpfopw/B+KwVklTB1bD1IEpFnla0ac6oTrSrno1amFZK23acGzVUVceygd3oaP0U1TmCxzjddoB2qSgoOo96Z+2TqiaKZPk+ogI6dKnEUg+/fw1SrpuskR9jv7929Q7Rj0hSF48JCoClhVbgyNm8FUYeJK8QmdqW7x31yFEHOwQEUxoE09QYFC8oGgTEHlbH1LRImhPcxMoRfkyWQEjJDtdmCyc1nb9KDlPENxA7YtcTxht0R7vUsbOAYDWzGr+r7NBcHdPNdljOlmw/8SyH114hTa9QYcY+LhePhZzRUgbssxH4YirZMkLOQzBkH2EIvBRDz57/1jvs9hXqavqY8VWFhMquiAz6HUVwp3BCtPBz+qz4rHgPoj1BHFk9SY0o7MkEIg2JxtdshJO20OFeAUxZMUdS7nDLPeKr38DVhqioG5M2H6KeXmE1bak3Dgmzu2YnP9mid3cR8cRmm1VznnE8hnhUOo4WpHaF1w7pj4uzIebCuFxw8NYfsPXoFcLkobJYUuHmJJymUrQSXCHbMgRuP+T4w+7nfxzGjyUy4JwjhID35np148YNvvzlL/Pxj3+cv/k3/yaz2ewDf80/DCLw3t/V93x97+8OUb++N1I/9QRaINJcyGuusN+HFieAisjlC2cKqcky3yr31vLmDE4LwTT5HSZBnFUJPvClz32C5x6/bBtwjvi8AhJZGtQFuqNboB2CQ/2GaYQ//BQ6vYTGJXl+E0kLRCOhO4L26L5PnMSU+ypRLowyl6dVyUAU7y0mzSUzSdnYxEqRnP2eM/jdhx1CBhtnPK16+vI8IkI84WKZkplau1SjLT/5qYfY3pggxSwlOisvfPaZCwQplfVuTn9wB597436I4MiEvKIpXu/9/ru4vXfxownVxkV0fNZqpMlEW3yc4ZY9jhYNM+qHPsWZj/0MVBXqxMosfsr46Z/k3NNfZHT5Gc4/80Xi5AJ96rm8BX/py89wvun5zBMX+Wv/7z/Jx65sEnJrgjXqwFe0fU+fMp06evVEFVbZsVLrrsin5uzEVtYCR4rXgohZZa8td3Ww9VY0mwBPUqXtlaRCdibtPBqNTqFqkJLig0e8oE7QAL2HJUoMllVXtdJIR0g9qLVHGl+hg7RCYosrpk4ux9LDLuUwruDCZahG5NiREqifIOcephudZ3TxUVw1wXmPugB+bGtCI46E9Md4UQgjU3DMke5oh+W9tyAvkdld/HLf3CBLiaRpmuLGacp/q7a38kM0sSXng3UbyAkZTko5HOygu3F3j71Zb5bk2YzEMkNLXfFvLPPQp0jlBVKP5kTfmchSXZkl85VLU5pRRUwZ7z2CUjsImIrmw5fOrjti3DoINFQukHGpJ+QOt9w3HX+nVOMplz/309TbD7H55BepPvlnaMMGMYzJbspSxqgbsfXM55l85sv23HFl7zsu0H4FsSN0R0W/waScJLbE3XfI0YKwQQ58MplQOYBEBBYYl8DEmHT9u/crm/5g47TB0UfDxo9lMAAnNXwR4amnnuLixYs888wz/LN/9s949tln/4e+t9O9qycubqfW63sW4Pp3f4B6uK4ztJNfzM7jnOLSgpHPVA4z1Uk9TVwQxDoWyLkQohU0U3mTJhVVGh8J0pLJJOex3aqmrc6RwgZIQr1lQVnGZJfReoI25+ipkP2XyQdvoFkQAtCB5LWEsmJM6IrMqD8iLO4S6IsaGlQh4Jx1R+ACdw/nzFdFo/70pPwhb3onlon2BO4ctRwuI0N/fZKK+Sqi2V4zqeA00dCz4T2V5MJbEKKzedqqPcGbvJLkjiqtDBqV4pqH4tKKKnfmYqhLvK5Q30DYgmqLJA1dstJJVhB1aGpZ9XN0dBFXX1qrPwpmQpWrM2i1AW4DrbZx9RQ338PtvsmlGkZ5xTQo2+OGifRUujJTJGcCNYtlZPeoRV3Fwbxj52hJS+Bw1bO/aIt7o9W75bSSnsg6KLNjX9bfP7HDPQV9K2ixcaZ8DWGwG7KlP7g/em8IkHpHcvYHZ1a9Gw241T3y4TWcdmSBJIrSk45vs7j1GtofAtHg+XpKdhNWbsJKazSM8d7j+xW57XDVlBQ2WcgErbfBT8DVdBpIxUzKaSYd7yFpRuWyQd2FvCfaU+kC6Kjzslz3ch9VFVVVs1j2RVLZZLXTwCMQZ0H7IJwlnLQJltpZp9BJILuq8CTc2qEUKUhNLtMs0KfEtFJCWtC4bF0BzqBe0UwThJQisY8lEQDvpahYQuU997NpSmQyuGYWdUoruRRmLB5fb4M0aHWOPLrCQiYk15DDJp00KN6QhNEFVBWvCcUh7YK8mhf+y9L8D3IqvJPIOB0hB3dM56EUBUJwODFV0mWC6/sr3rp3TEtY81zk5N1/NH7E8WMbDJwe8/mc6XTKX/2rf5V/9I/+ET/7sz/7R/ZaP0gkOWyQ66CgZA9rYtZ7oCkRMw5Z/8L3eAl7+ft/wRKNxMbY89yTD/DIlfOsZseMJfP5555gXIcCt5+SjiVT17URcjRDXkJeklRZZWvZyWGKv/QMeXSWmEEmG4hUxeEtk4NHJhfQ+hz59gvMX/8NvNb0Oib7hLiMS0CBNFGDKvPxbfZvfBvHqoiR2DwltQwp4fidb77MtXsHdD9iaUVLZtVp5qvPv8xLr98wuBZh0SVu3LxHECUlUy4T7Xn00lnG3jHy1nmQBaIzdGXsQDSR1cSXQuoRzBdAXWUiLw7ick5/dGQBT45k15B9jRttM7nyOIwso9LpBaKHXiPZbeGmZ8F5stYFDl2RUeIAi5ckqHKZenGH9uqLVHlFqDzZBU6bLJuRUuLhK2fZ3zvgrXduknC8ce0uv//SWyyz8O7dXd66cduYCfdZNA+hCCUYsJ71wTTL2uDKbxYypZdyuOVI0J6RpXWEqlqv+6wnCEHlPQEh4HG5qOLlzFiVTzxymSe2HLPXvw79MYmibqkdy5uvsPfq10jLu0Aybf7xWWLYpn74WdJoy0iCqcfFFX27AleT/ISth56mPnOJTE2WgBtv4c5ctptQM/3RAbrYw7lMdLW5U+ZiSlU0QCT3SIyGzIkQgqeqPG+8fQMRb/m1Cl0fSdlKI94HC1pOT2+5Sih0yToEUimOZIWouVTLC3VWT0oNbdfy2JXzPH75DCG3jIIU0SuFbAkB2SymjSckOO8KR4ji83B6J7FDOEdDGiTlolSpRBfKWxagBhwtgo7OsXn5ofX7s89kCopZahJG5Mvi0HaJy4lQNyb2tN5HHWiiSXOW965bmaIEZsE7c07NiXd35vynr77E//X1b7O3aq288J57/A+1L3yECHzH+FAEAzFGfu3Xfo23336bg4MDDg4O/she6/1qTCdn+MlJPnAaur7n3u4BfSwSqWVHVznVr+0cfcocL+P6GdZZw/C65e/pVLAweKZnEuKVremIRy9OeOLKBg7lzGTMTzzzINIdQuzMFEeN4DbWFRs1MD/Epd4IOzmjWQyGczWMtqmf/CyMzqIxkjfPra17iygCMtrCb16gkmNCd4/cRZCKTEJzR14cQ074EsQISqNLqv4QSa0BgCL4uKTqZyz7xGEbWaljmV1pcxvmXE4m/L75H/47kSIdNggZwE+F2SrSq9UpzQktcLTsubV7SFTYP44453n2sSuMgtVZbctxZAJOTPSI2JHV6pZDqyOcMLtNDyYSY2eoiBZJYxFyvUl47GO46Sadq+DsIywdJBeYnnmEajohuhI8WWOakQi1sKeTuct57ZnIEpdmpu8gpmRo8slSeCQmNvPIlQ2SlMw0K7M20rvKsmICXbSOASnowCmc6mStrav1ymLVs+ysnl+AL46XHTEWP4ZiirM1rq0c5QcaJJCzueuheOfNAkgFlyHgqDKMUuLR82d57vJZQreP9Ef4dkYopDKfl4zSYVG5iyTNpNEWM7+FPvJx0uQCUSu7PqG4CYpD/Jjp4x/HbV0wFMdVVNMzyPQs2QpgSFrB0S7qA72MyL4xZU+NNgNq4j6kjpA7QoHgK5+JMdqPFPpkr9lmpUuK9xXHy57jNnOwiAVxYJ0YxJzpcjblyVzQxGxSzIPDZpcyB/OWPmcWyyUfe+wizzx8hnHl2JpO8GIW4lr4H96Bk0zlnFFxvZExbQty9wcDaYXO7xHn+6TUl7KPSXzlcutlGVZHwSarmubcRYJ3eGfqjkbCLCWb0m6aMKthV1X4yQZ0K0R7dHmA5h40UtEhfQupQ9s5noSYxzgRRxszq6jMOqXLVjbSYf5OlVvWG8T3Oew/4gp85/hQBAPj8Zh79+7xK7/yK/zKr/wKX/3qV///9tp6+qtSFqEFAgmYtZGvfOMNZtEgaETp102CqXR3e457+NrLb7EcNNJzRmJew7J1BlFhlU3OEyBWikiiloyTmkDNFBhLQiVSBcekm3PwB/8759jjY5etBrp49df4rLzBxXyN9tXfoElzyCMkOip1+NU+eMghwOgcqWrYmu8i9SXaSqj9zSIm4xGM8CRRkeWStPcWG2mX0EVyf8i9V36N5d67NKmn9cIiV2wSmcYZdTaDJpWK8c63uXzvt/n9N3f4P7/xBitX0frKBFuAk16AoQ/CqqgnauW2CQ0WvoMKekYQ/BqudjmRnR3MzsHz7x7z73//HY67zFdeeIfdlSc4hxdHLYGQe0IOON3G4WmC47HL59mcbIP2JJfBOUYSqUXpCKib4DUh/RGuS6z8FHSOZ0aUDagfosoeFyry+Sfg4ufo5RL40ZCQl423BhkRMFEWRwY/JruA+oaeiiwtVY48cX7Kg5X93tZmwruxHaw4msoxq6c4VzNKLXttzwJHioJkT0q+9G2UfvYyg3nwWMjQxoakFTnDb7/yNr/3zo45M9Jz3GX+w9de4/Xbe+SkLLWhk5pLE8dIMuI8OZtkrEsJXMY7TwqhiBApIj0rMkvxBGnxPuPbA1Yx0R68Tve1/xV/cB3cJq4KBI2I2wAneO2oNh5ALnwKGT1FvvxFZOsKTgQdjUnOmcK1OHJ1Ae9HxQJaIYyhOk892UQRmjSDg3vo1qPwwHN0bgNJc0ZxD0cka0MST9Mf8ZmLsL0xxVVjzo9gOp6A8+wfL7l+e59Mz/XZkpuHkaSO3379Dv/b19/k/3rhDTvMMixVyClSpyXJCSmCd70JKeHxqefc1FN5ePdoxb/7jRe4NV+xWnWcHQm1K1okZJyvubIxwvnaGAZJaGRFpZkkmSiKEpCUaRTCWt440137Jqvf+V9Jt36PUAXIYsiJ9oT2ECXRYrEQZMYkKu3J9UWiWJmyIqJ+Yh0mqoag1SMYb+DSMWhPV02IyyVVv8f8W79G3r8KYi2GXh39/hs0N36bBycgTtEEx+48XVQqXSASqQS8DL1G5koa46nN+AcoGnykMfCd40MRDDz11FP8pb/0l/jCF77A3/7bf/sD7ySAE47C+433XXpDWUBgpY6uHGoD3ApD24w9Q0qJ4+XSYmrnjVXvhR4jYg2vnAAnrtTWBsJXtoNOxA6O8sveO4Imqm7OVi389Oc+xtQDi12eeew8oxpcPysZj6EWkhXXz62mB+A8rq4t09i4zJIprYxY6cTQA2PpFf0CayESeiQl0A5t9622m2YMLYOVRgKKc54+JSa6YBr3aboD7h4umaXA0NU/ICL3z/FpMFtPfk9PwG05dQ0oWbURpnTt/JaBZfIssmVOq6j0WXHizLvemVph1oxkRVPPRhP4M1/8BGcqIC7xucNrS6U9jWTTYsDUGCXOzU3PV2XbKsiPbxBfoQSqc1fY+sSfQDcvgxvB0EwoA5XPr0sDUurP9g2T801Z8WR+8nNPsz1p8ApPPvQwdVXZo11lkLFz1oqWMss+oj6g2ZfXWWNR3zG3w1xmnPE5BFZJma1OHCbbGDlY9saDAHMk9BWXz005M/LUTtGUDI3BtAmqKhSehaDOfPZULHtFTGXS5Q4fF2i7h5/fgt5az5wmxtJam5rzdNnB9hXOfuKncOOLbD32SUZXnmKVK7SeklxtinxQ2hRN+0DB1nCY0Fy4Ar4mJ2tnzKNtzj/9CSRUoB1BraRF7tAc8dryE596kssXt9EUuXThXCHigaZEiAvqtCAXnwMBZn3i5t6co07XeFIUyGL+DFHN5wDv6RT6PtI45fMfv0IdlFXM7C2TiYn5YLoHUNaq4Jzn8oVzjMaN7R9SETOEAJX2VFgHjXMOUaVKbcnme/rFDmG1g88ra3/VjF87iNrdUlghthcqhvLUm6yoSZjraZba1qYEOjcmTc5SX37kBAXxRfY4d+YwWYygclFgdd2M83XPpx49z1mdMUpzsjqimk7ioPpY5BTIavvI2nRovYI/Qgb+sONDEQy8/PLL/Nf/+l/5yle+wnK55N/9u3/3P/otrYeIsIiRN9+9u4a8nZwcYk7NQCZ4Cuw8cHUCu/OOV949OKkXYxCic26Nz7pyUNRVWJOLjHesVMFey2Mbx3TdYoRJ7qZBnCTbwT1A3+2suIdZ1oAP5HoC4/Msq0sk/yBd/QBST9CQzVBG/FoMRHwATCI2aMQt92ivfxtpjwnaQmpxgxhR7KjnN1jdu0pwyio77s2Ug1nCk5FoBKSBvLYuGZziV8gaN7Bjy47JUmstwkLCQN0Y2gkHBn15XOF4xJTWgV8IgR4BD15b6mDozAYJdq/Czg3qfs7q1pu4aHasfrHDau8Wjoyf78NiD19VpoyGUStFhOgbsjTgp0jYII7P01db4Jqy2f0g+gqCqgMnVE6Q3OFRRlWDl2ztjzhGRGptiRivQMXRReXw6Nhc8U75wFstNgCek1Vn5YWcrdacxbFq23JNHG2faPtIjxHmMtZdUDthLB01Ec1KzEKXMrEQWXOKZa6tPDFwRwaSrGhilOcQzXjHDnKFvMJ3x+jOdcg9fRa0mkI1pRdHDiNwE7p6ixi2kPE2+GbdtQJqnwNB6hG4CvUjOmpimNBLbYRPH9AU6W5dIx3sUREhHuNSR1we47Snoacm0oxqM9jBSHOT/oBx3KfWnlr70qfvyM4zay2YUgevX7vNvd0j+mzGQn2f6VR4d29JTJmQe7YbGHuD3Dv1fPudIxZdOZSxPSB4seDfOwsCQ9EfUNNa2HSRTW+mRSpCXXmmLFncfJ28uIcv7Bx1AQnBbJy1BfEkqRBVBuaA4ksgV6POlDW13qKttkEqRAy5mjcXWFRn0eYMOQfbI4a9K+diS2FHkObCxegXhH7Odtzj7PHrbHX3qHJLEk8rDb1UBRdkbcyWVUl5kClf3xo/0PiIO3AyPhTBwL179/j0pz/NeDxmtVrRtu3/6Ldkx3GJhnt1vPr2VfqU1znYuthaSgteymaIQeIJYXe+4OWrt+g5IXKpWjCg2GN9CS6sM0AZaD6CsYcFhaho7qhTRtIcHxO1F8zitsDCeYHk1vrlu2N86taiLlmEGGr86AwXnv4SG5c/y4Vn/yTjs5dJQyVZGtuEJINvLDPOCyrtkOUOs2svocsjnnjoLB978lFQT7YTgXB0g3bvOnUQ2uw4XCYWq0S7WJkZirg1m/273eXZjt8ySRbUZHVm/fodv10MifJJa9HQ2plLMADWwpoA76BmxWNXzlF7IaQ53Y1X6G++QeiOWNx6jZAXBF2R998iz3fwXuD4LtoeQhgRZQOjymXwnrB5DvFj0ICGTbYe+Tju/CMkwloU6geBOyWBpjmVJpzMzXUyOYIkUyNMmWleMMkzUhEfct6z6hPHx7M178RhHJBkuM6pslcR0kHXznxJhVWfiyue43je0qdMVPPPyNk4DpNK+OnPP8OVcxNyMqg8ZiMqhkLEA0yURq2lbXAmhOJ+FyMaO3o/JruanAeGvRJ3r0G7R5AexIMOqhQCrmYhY/rpBc488RyuGp+YBakhK+JrkjqyVPRakeoNmoefpJcGqacgAe+Exd13ScuZseC7fTwJ7ReQVozTglGcMbT9CYqXzDTuM+32GeWOSluCWMGqS8rB8Yq9oxkJeOmNt3n75l1WaqRDVVNIvHWw5Gi25OFLZ3jozIhPPnWF4B1t9nz7jTss+4wXt1bp9c5RhVACBMgxWlDsKirv+TOf+RifePgBcnFYPL895k998hHm73yLuHsV3x4iKNnVJXtPoJEoDa2z1svB4GwdqoonTLbZevxT6OgsFz7+k9STbZQKP9pi85kvMX70U2i1jWaD892gl1DuPdGTdeY14bolVVry5KURT40OaI5vUOWWNkHratLgQ6CDMRTEnGi7oWn4B7lrTt0/HyEE6/GhCAZ+4id+ghdffJHnn3+eX/zFX+TP/tk/+z/6LQEl5xTr8+7VGfw2LD61TS9lh3fBJG69X2ewdiIILZ7snPkaCKScqKuqbD5q2uwUmFBMvz8EExjyFKMiMnp4i3R4l3z3darYlsq6MXmd9uSdd9DZLoFENd/D52gkrAzej4l4dLRBc/Fh/MYVqgtPQb1l9WDnSOMt1Hs8pdf68B565218v8D1M+p0RK2JydixtTnBSWDRrtjd2aWKR4xdR3BayiiOLKEYlEDMcGt3ThfzyWbPCboSs3D19g4Hy670wUdUM4uYuXb3gD4X4qWzTay0LuM0FpOnwnDPSoxpLdlsnSAeyT1NXnJusymmT0tG8YAmLwjaMer3kbhkRIvfeZ06L9AqGCudntRs0ckZSAFJvbGrN8/Ra4WGBnUjRuceptq8CM7qvadtnu5fVKXn31lrmEuJuH+N0B+RDq+TZzs0ouYBIHYwjY9vsRX3cCK4YL3nq74gLSaliADLrufNW/vcXfS8fXNvLQ09zPkQv8ZUlAzxSOF1JPG08YRk6BBqUR65sMFG7dAMMbu1sVZFR5VaRJy1lpJMBVN7Gm/XNqmQkiB9T5IGkRonSq+OKA7f7aP3XqNa7SNi8ro+K5Ki1ZHDlH50nur8Q4YMhKGrASPQOc9agcs3xDCGjbPkaoSvzf9ABIL2dm/lnnz7LWK3IqQOOb7DaH6TbWY0FaSUStKrTHTJqD+kKv36VandiQvlXrayQCuBlatp1cSetF+BJqI4cIGLZzbYqgMPnR3baggNyQXr4JCiGilqyOApBUnJiSZakFiJ8OxDD3B+2lgJUmBSKU9f3mA77eN23sId7xriQ4VWk3Uis6q2WYVNg/Ypn2/Yw8TjqjGjC4/B+Bz+/GP4eoK4ChcaJg9/gtEDT6J+SheNMFp5vy7dSerQQl72GBLkcoeLSyajzOVmxUY+pKan61pUgrk3ljVppFYrUc6Xi/dWub733nyqLfYjdMDGj6UC4XvHuXPn+IVf+AW+/OUvc/78eZ577rkP9PlF5D454u8XTZ6WDrVvOERMhWxd+8VsZCOAhAK+6brvX0rRO2MZ/FD/zlkJIdD2HVJYw1mxQELs8RfPnWEyqs1QRiNOV3Q3X2ExjoyOvk3VLjBLGjtyvLYcv/0S4+3LdkB2s2KN2jBSD9GyruygS0pwHnSM1bMTSQKp2ih6+xn1nn73Fu3OVSrpcO0WQbtCrmxtA8DRaWT/7gEPSVzLBmuKiDSoOpJ6umR1xpdfeYfPXNlisjFal0MoGWtU+No3v82zzz7NZ5+8YtoA4tiZd/zm8y9x8f/1JdxkfKpeDD4bvGtUOTl5TopAk5QNA2sn/Pyzj3Pl4rkifNMT+lLvlETVHSHaMd+/Qz9/GUcEt4m0xyAQzj/C9vRpkDHiTOQHPyZja2KoXfdQnOR0WEh8r91NUKq4Yve13+VMdYb529+ArceZPn3J+rOd49KZMfnmb7HRAtUj63LKrO3pYyY7D9k+563dI37jG2/w8FOPc+PVV/hrf+FPMioyzJR5Tqh1JpQVnKPZ6KrzLLv+pKVWTWHQJTugBofKpEog8ZmnH+bJcxMqyfjc8ezjF2lTIqdjOxDDyIi0vsIf7uHyBqQW0hyIFlAd32P58iEqmyeufmjpq/dcevLjhNHERLK0ousTo4pyH9ph4IL19KuvzEvBVairEG8Zcj3ZpHcFz9OO/uabdG6D2iv9/nX09g4bTJAsxBTJCFEctSS8i7jUsTUNnDkz5e7RoV23IREAOqlZqidna+sLKZK9CfIsu54UEhUwrjzem6ogWNDvS4kAVeoalq3pCKTY03jhy598kFnqmVQBl6LF/mAHux4h8ZiJHtPduEvtW7L3jC48BN6R9+4iOVBdeYazFz4OriooISedLQUdwI3p85LajRlOZCs5TAsKUwHmYaGlCGYdBMl4GIPQsGZrB809aE9NR0PE5w5if+KBwSkEoLSr9sU7ZAj2vl9MMOzlzrmPgoEyPhTBwNWrV/mn//Sf8sADD7Czs8PP/MzP8HM/93Mf2PMPAYCJpPzhYSVRvxb+kOF/pULQYwSigBQFNAoXQNfGKBEl50RMiT72hGD97JoyUpXspfK4ZOdHXQWauhqgCTQvCDnh0xE+7tthRc/QW+S0o0mHSL+Jd5hmuNREGRnkp3W5ySJS1SQRgnoTQsGRpCLXW9Adgq6sfJGWNMwNGek71GfDmDWaA1wXWbVL1NV02ZPQoibX4aUq2gCOIEYcMgU6PTkg1/evEEXpqFgm+2TBKHx0eFo/pher1SecqcGhaFwR1JAEdRWuoAFAKcMUCDEro5D51JMPsr1Zl+bFZK1YhcVUaUuK5mMQdF4yGJDUk7yDzQcYX3iyCM1ECz6cCbQMy8m4CQUZKp7tKrJ+T++7rlBcXDEJK1jeo+p3yekimiAER26VCxsV51e7bOeAy5HsDJ1adolRPSLlZBLxakY5sxzYbRPHGugURgUO6PtI10VyVgsi1BMTNMGZhS3CovAIcpEgDhjrOwTPsovE7Knqin51xGMXpjx0ZoODmSnTfezJCxwvItevm4/D4ORXNRV+foepKK7fhW6Jj0c47Qj0kBKx2WZNtizoj7gR00uPW3gtFUKA1J8kjzK4++Vi6SxktWwc5xFfzIymW2aTLB5XN1Srjq5qkJBx8Yit7g6ZbUbefAgSwsoWBqMAGnsmjWc6CmuNkOFIjAotjpZAGxOuWP4qLVk7smwSale0QWxPyGqfNLghuzWNh1EFx2XvEBHq4Pnco9ssnMf3lDqYQfVCsqAqLQj9rNgeR6Jv2HjkKeK9O6g6MhVx8zIbl560g9ruQAa8yJIeE9tyoSaLW/OVtNxvoQTg9v5NQVUHVFM7IELfQpEc1pTWAmlgEuUu93jt8SK4gfhJqfeLcQb6dGIkRvn599qph738B0nu/riMD0WZ4PXXX+enf/qn+ft//+/zd//u3+XFF1+8T27yh/nz3jH4IbzfeO9SGh5+ktcJ3vm1C9/JT0tngXiDowtTllOPH3qM7+3P+OZLr6J4vFerLap1DmxUUjgAIKXmen5rymbjETJeEkl6vGuLGUhkXQBGIUcq6WG5j4p1FuQwhtEmuAoJUxifByAlMxc+EU6yzUBDY+ppvsZtniNItptdI2l+TJ+0sMlL94MXmirgQ8CHChGPuIDTiJNEFrFsKdvhoshao34oNOoAXWNywsNhOmjqJ1VWfaIH3r035+BoTl9kXn03YxoPqNPK6uWuqOGJ4MSZDr5Y5uVywmsqHI1Mzj1tSkQ1ZUdNPePUUaUFKi2p2oDRWcR7I41RmfPicI3AMt96emqFGOpjddD7YCWTdOAkGxq2Q1GQbkWVl2h7RNAVPtvn8WLZT6UdU8xTfjMoE+lBbF43pxN86U4QsaA0hZoVDq3HJLHylB0D8M71d7m7c4i6wK2dfV554yp9NM95J45V2xcuS1GcFOPCdOq4ee+Y2WxBpT3nJoGxNw0Eh3J2XDEV2KoFPd5h98abkKPdE5ogLqn7I/Lrv0v/4m8S714j1CPL7MSIiYQxJrFkwlVIbeJYpXU1q6Apn549UmjQ0NihWk3R0RY4QwpwdnhrPSaLs1q1rw3arsZoM8ZpxwZzxt094tEOkDnsIt949RYDhyAqVMFTefMMkaI8aPoTxlHZO+743Zdu0veRkGaM+gNyt+DarTt48Xis9OdcodKu73NzJo0IYw8bjSUGF7fGbI8aKhI2K9j9qsbcl9Qze/2bxBuvkPuVNeSOz5LFIzImV2Oiq0nNFn58higN+AZKi+7JRkfZwwbRrvt/aJ/Us97Uyj221k/RBN2S46tvFF2DjOa+5AxapLTt8U6SoZZDH4YqOcXyKibffIIwnLpZvsuwks5HiMDp8aFABi5cuMAv/dIvcfXqVd5++21EhH/5L/8lP/dzP8fZs2fXML/JonLfoX4aJhq+eu+/62u9N5IcNul1xr/OWg0q9TlBavF1ZQzqcjt5vNXz1W5qLVC/5pPnMNqAQ7Nwa9bRziLVuYrGzxHX0ecxo+D4uS8+y0u3FsyP56jC2MH//ImH2WCFpH2CJpZyjugSASVJIsUAurDDv2w4Pu2ZvHDYQB/4DGee/TQ0De7yY4weuARuQsAi9GFXEM2IdkhOJKb4rYt055/B3XsHXyBCFxd04TKVAy8TQpqxNVIu1RvMfc+nt89T371G685Q09FKSxsmSFrg+2C2ys4Ih8pJ5jwcYmSIZIIkKkzidKFCTC11MDnf2WxGjJGVBnazsLF4l2eW3+ad8XPs+DFdM0G7JRlPCBDyytQSC7oiLlhtu99D+yOWqWZUPrvXTf7co5fIvMlyNxIe+Z+pts+y+tY1qpRxeUnyVhaqgYaEbj/MhU+fA9dAgdQVxQ0ZbllOWR0OI3Mh1t0gZCQnXBHASRpMr1+EKs8h97gYcRKodE5ii66u+Muff5Kdezf5D1dn1HmD7RCZ6YroNhFKH7qYt0JXOgeW6mjJdOLousjhfMaxVhymhlsHC54T47WMq5q+d6Z+lyOo0OQVpBUrv8GBbHG5WfGzX3yOS9Oa7VHACWxuTPnLf/oLjINDRHno6Qv42y8Az7KgYTrapJ4Lwgo9epMkFSNdIM/9T3S336E6egtXNeBHiFMCpQumeBSYE2PxjChMezuRAs3Tf4pB4zdf+gRnzz6MW14naUD9mORHuHOPUm0/wHw+Y+wikm+z8eCzdLMDvCy5cGbMxcUu3fxNam3Y6zPX91Y8la2VspeGoEds6xFJarP9Loz4ru/Z6hccpoq784x3DRPd5+PNHt9yF7mpI0ISvMJCQP2SiXhWssU8ziAvWVARw5hPPvIAYwcbFfylLz6GVmOydzRZyAFa52hWNxEex8WM3v4Wrj0ADbSXn2XywE+hb/xvIOeor2xzeP1NwsXHGJ+9SELJhSBcAUkgqbUnmgkSeClBByf7gkctqKoc0QnU2zQh4HVFcp7WBZrlIc3OVQv2XYR8zCo5pimayVUd6L2jlwFNSHgUz9IIjVozqhv6FEBbkMaQF31Pd8F7hnOl0FHOhuHff5zHhyIYePjhh/lbf+tvISJ8+tOfXh/mo9HopP9UhOPjY2azGdvb24xGI2KMHB4eMhqNmEwma9jou43vBifJd/zNnsM5q+GNGkeKq1O/MUDdg8JYsjYbNXKP4c9DJmyhhrG8PZKM3a7FmCWIcH4SqD0s1XrOQZg2FSNRGDybVCD3rM2QcrZ/M7QKVWQ68CNa3+M3HqCenqUTjw8e55pCsitQ6zAX2TzUnfMkP6KqJya7u+4y8Dg1eVqnbfncphboxBGqwLg2+ZqUBfNYt7Y41SIRfGpWTyhtQyW7mOZgrnGoktTz8tv3OEjKMirfeOkWTRPos3B7/5gX39mj391hIj0tDUu/SQgNrj1gpEItgFSswoTWg/oe7x1Olfb2NXzcRZzDh4AkQdRT5ZasSzrvYbQB9QT1VWnXPAX1DEXNMLIedk6VAlQtbSqM8BMUgDX0eoIWZeueEDNcdsX+WY920NkeE58IKRH9mDZsINJzZepob9xhHHsaqRlJjanWuvXLkzMu2UaeUuKbr19jev48zlWotmuXPHWBTId3mZxbQq2s1DgY6JKGyOLWXfT8Z6hkmyYv2ZYlj2wFNmqzIyZlau8YjYzICkoImWV7aMY2GiHUIDVUDcRcMkMP07O46QF67JDQ4JzpFkhh7Q9Tft8mf18gr2i9SbH9hFDj3Aa03lAcV4LNMMKNJrhVa/Lb4u26nTqcJi5ye+8W6CPc2Fmx6CLihXFqqeIc3x2R9lcEtolakXC04gmFWZ/V0UtApMVpz1RME0BiogqOJBDEsSkQQ2bRdUyCA3Vs6opLfsEkCJsVdNe/SdN4uPRpMhZI4ATNkdWNN5CLl/FVNgvtbIEg03MwOWtW2FIjlVCNNmB6BqkMORlWIej6/wNPg1No1sB1Eko3iAgu1IirjLDpKyvlDPoWuSXkZRGmUnK3NBnifkmTO0aS8YXo6wqfZu0XIjXQsjmd0GVAvJXgcHj5XgU27tvnPwoEbHwoZmFjY4Nbt27x/PPP8/Wvf53Dw0O+/OUvM51O77vo/+W//Bf+3t/7e3zta1+j6zr+xb/4F/ziL/4i//gf/2N2dnbWvIDvNv4wroXD16au+NiTj+CAvtwzlp14kgQyiss9GnsSSi8QnSuSsoVUU6qMOUMfE01T47wz98HSm01sqbXD66BvSAFhzftdtEf6pTHExRWjkK78PFidWwK5GpFcQ6ICaQqB0T7XdxVdUoF6Sp5smiOd2LMq1gYmKE1e4POi6Po7sw8uB1nKCbd9nib49ZHnck9Uilrj95hrsW6DhKeLiVzcB3//pbd49fo+Kxnx2tWb3D1YkauG/eMlv/uN1zmat2QX6P0EdYFxAK+JEd3auz07TxJvAQ1A7JndvUl/vA+arK6MsbqJx9CvkOwQZ1lJyoGeuhgYDYe4rOHs713VLEOw1yi3aoCika+F8GblJY3R2O7zfVZ7t/mTn32Gh7caslZk5/ncM4+xWS/R3Tc4l49xeUVVickY52HzVkjWehFU6bvI8y+/wzt39/EOHjw7MdW3nEv9OuF0hcYV1SiwVKUTEBeZ5H3ae6/SLffZCJHNfMTnn7rERgAxcwgQZ9Bv7pDcgSZy7HAagYimDqkaer+Fbj2A+trepxj0j6vIUiHVGHEDGXPg0/8AE6sOtJBKKfeLq0i+KuCcgli/vmom+jHqJqhzOO1xsacqTPjlbIaqcu3de3Q5kR3UsiKkJSwPiXvXGaVjJtIzdplebD+IKmbGZTUqUMxqXGASO0a13UkXm4o/9/nPcnZzhHct/9Nnn2U63uTjl87w5z/3BKMqILqivfo86d7LCCuGAo9T22MOb14jzQ+t7RfrWPCXHmL84GNoXRPDhq1VhZxl3brHe+57O+/1JMjlO/dGHVRHVPBhjIYGh5B9TXIj6yIhIWmFEJGqQqqafr7Aa4+kJaPcMpFM0Fzsq2V9H2SpmXeZkbZMfSTnaAnFGn39QdfBR2MYHwpk4Ld+67fY39/nL/7Fv4iIsLm5uT64vPdrHsDP/uzPsre3R86Z+XzOm2++yT/8h/+Q//Af/gNf+9rX+Lmf+7k1bHT66zBO//37BQZDOUEEHjjX8EqOLLqeujZluDZmVmL5s8sRTZnEiKMussyZujIVPlFda4j3MZNjZmPaUAUzdxmCgaA9Y23R7hiqDaBsaNn6xH1u8bFY0OKQ3KFxyYmcb4GpXYn7jcm4RgGGzztE0Sef35HciKiOGDy5O2KjiKGoBDoavCTqvIL+uGT7rrijWbggArJ5Hr8/KwI0jqA9PY5V8utkenijA7hBKa/M256k5umeVAzGDCNWWtOHsZHeXDBeARHvZX3I+9RyLt5lqhvcwa0NXFxuOdvtMI4R9YKTTBAT73G5tXmqGnJrZSbpjyAtcblGHKg4WtnAO6WS6nTfABmIIvjSZqcMa0W+Y22t89ihto9CcYLr3IjKWbucixGfImikT3MePT/lQugZZWUkSyajDt/f5ozuMY0Ns8ahdY2KWR1DucYKmkqbG0LrJsyj0HjlXNWx7BOp70sQ6S3US5kQRqyWmaM2ARVNXDKOM5TIRpNp0jGXNscG2IvVeP3wicSvD8OkgiYtyFWCasS8Ps/m1iXyvEe7JSlM8WFEcjVKTa7GJhxktlJ2PcpyMZGu9zgsrucURIf2WkA86kb0rkFd6YEoASsitPUWfdiiEW8U1b61Ml+BtN2A2HlHG629cZmMN7IpKzbjIVp5aslUuRDmVEoL5zrNxongVZnEORO3wtPS0DDZ2mTsE42seHSrJqjQ1BXT89t2OC/2qNMxwgSnHSqj8pTWZlxjBEXRBsmJDkfYvECzeZE4E1rZtnnMPZlgaAvD2mDN1UGHlWjrRES+Y1+wOxskK+JHZG9dQNmPad0G4zwn5BbiCujJocZVE5QDCwzjHMmZShw+RbxmEp4oDUddYqqO5XLOdtpjujiinpxHsG6cU9jPd+UNnN7LhzLBH3cOwYciGHj88cd56aWXWK1WqCqj0eg+6EfVzFKcc+vMfz6fMx6P2djY4NKlS9y8eXMdAFy9epVf/dVf5fj4GICu64gxklIiZ/MHjzESQiDGeN9rna5BpZRwPtCtInuHM77yOy/y53/qk/jU87Vvvcqq3qLa2KDxQvAV8y7z//3qt1ge7PDZTz5LmG6RYySHij4Kt+8eMOpqzk7PGNLQrdA8put7NmpHPRFufetrTK88S9q8QpAWWRySYsStZgQfySnT94osj5nfTcQ+0qiR0XKKuL5Dck9eLcjLI3o/Qpwjxn49b6d5E44OGZ1BfTmQ3Ii+y4QsRPV047PkNjFZ7dO9/Qr11nPGGO7mqDsmLlbEcEzfjNDU08VILz117jmc99xaLIgxkXxm2SVWK5P+RTwxC8lX/PevfYu9oyVdf5bVqgUX6KKykMyiz1QJjlcdy5gYASkm0/53MOr3mKzeIXKBXi+ziMKiU0bH1wnvfJUz/RMkd47cztB+hbRHuHZGVui0wuFIsYduD+3n5jaYIiI1bD1Sjv6GrjX3Qi+ZpYyIEtAi8oR4UkqkInhUVRWnFpRl4oNnBRmflmgv5O0H6eM+KS3Q5QrpO2K/QvsZdMc8vD1iGhbUe7fRa7ss7r7GZjpgK1zmasq0aiI+fdezajtWbU/XZ5attZB2GRbJ8/b1Q+rlHqvDG1zdj9zrAslvMW+VxVJZLSOSG3YOev6Pr74NKzgTHdL3dIsFbtLz4IVtHMJi2RODI/WZaYAuRYIXspoYTttFXIqkdkXqWxiN6bYfJW+cowv3oOtJk4s0NLTFV6EebdJ3SiQBvdWac7Tyh6ghT86xXJqcsd27FTELQa21tvdG8qxSwG2cp4/Qty1Be0iZlDIyPsdq40EqqdGY0LYl9y2kiOZoLW59JEaTnV7lwLev77MVPGO3Yps5q+M5I23xy8dJTYPGFcvlISobqPSIZmLfofTU/Yz9azMeOgu+ukTfw4PbE+Zth7QrUgVttlKKSwva179JP19SnW1wqwWdr2iSR7UjsSR3C/rlDF85NJpyY84VvnNWYtu4TOwTjsSiz0wydIsVnR8Rk6MJgieZk2KRth4CrPcKvSWsHbnKLU6hzY46ZlzYIG1eoT+6hutndHdvEeIcP9og55ocHV5X9Lt3iMfHNH6bhzYmLMZT3rk3Y0ngf//Ky/yFL3+K1eyQK+wwOThGR5m4vExSb+2VGOoy7NEhhOLgaPfacrmkrmucc4QQ1onf6X19+PcflyDhQxEMzGazdTBQVRUf+9jHeOKJJ9Y/HxZsjHaj9n3PaDRiNptxdHTE1atXeeSRR9a/++CDD/ILv/AL3L17l1/7tV/DOcdoNKLve+q6ZpCqPf31/YaqgnNMx5EknoM24euKhsBhpxxr5uGLI85tj3j8yUf5xsvXiVIx18BKPRtO8M7hnQnsOufJOXPuzJTrtxx1FQheqJuajz/zIONuzP7zL1GlOaPaUYkiPuKCL/X63jTpcTiJZJ9wzYhqskGenkfvvoOMNqCb46oK11SMvB14Ifj1/DRNc9KWg+fsY5/A+NEJScf0d2+ZeVG9xZlP/ymWV7+FuzfDpRZXW4lj6jo2ZMkqrxg1NZOLDzO6e0AlJg7TpM4U7XxDCC1CR1M5mqYmlBapoI4V0CbAV4SqomlqcmFwe+fwocJLJiYl1DU+W93ZOaHyjrH2XGKXRfJ4d4lRFRhXUEvPxXiXs1xg6c8xrm0jHLtoPfTjKdJM0cUu9bimY0Hwji5OyVWN37rIxc/9L0Zqqi+QXGNIAJnaBRxCkx2ixUnuVLfKQHQtq6i0UFkJxWm2bLapOLt1hvjSLvHeOzTqSiDhSI1n1Hh+6jMfh34H7nXIckWWBc1I+cIjj3D1puPM2HFDEqES6irgvEdDYJGUXI2IzkGo6doVZ2XJmbjP9T4SsA6Q5B1hvEEVdplUntpXLLqeQAN+TBMqxlVmem6DCz/zU4wxtUwngvOZWnqkGhnKMrSJOaFyivOJ2iXc1gNcfPo5xGWknRN3r7P56T8F40tUhzvUZx9g/OhTMJ6iUlnAnxOiptph3JOT4LWua6qqss4dpThA2r3Vu0BVXeTKcz8BYULwjdkXNyNCVbHx+KfhsU8gYUK3fw2Jh7ggSBaD9nEEH/DiqXwNOdD5CV2ecX6z4rlzF3nr7evUeUblQZwyoqUh0PtM4zxV8DR1RVDP9qRjKx7g8xGuPkdT1fzkc4/xqY8/wVlt8Q4qTeASKkK3OmRceXKzhW+28G5i7cYKTgNNaTn2dYWra/oedHQW35zBV47Ln/iStbymY/xkA/UVvhkxCiOSSun+sC4QFSM7n0Zg67per9posCRVcsAE32zg6xHV+YepN6Z0L/yf+DizCoR35GqMG50hyh0qWUK/pPKZB0bC/+enniWNL/CrX/l93jyOLAn0laOpPZ974hzHN+7Rh0yoKwLuBF3EWi/fu1eHENZBAJyQyIdAfPg66BAMe/mHvQXxQxEMHB8f8zM/8zP8hb/wF+67yMNQVfq+56tf/Sr/5b/8F7a3t9na2uKLX/wi/+Sf/BOm0yk///M/v44Am6ahqipWq9V9aMJpKPe9fz/9Wqe/vwYAQ0NLRRKDBns/5vYM2nd3maREHUzVLTlP52o6jMTkBBOqSeb+FmOkqYUqeDRHqjACsRbDID1NmhHSHE+Lzndh/7aRb/oWIdNpZe1T3RI/MjWzpdtC6nPM9C6bfoNYLwn1Bio1mcFL4SSgGoiZUnr+VTaJ2EEXBLI/xIUpvZ8SmvP01RkaLcCzeDQlfD+D7h51spJBlhqPFjEQCJI4mLUsuhPFsRPuwtAOZ98YuBepkBlJ1odNjgz9y13fITSkvqdyBkP7SohSkVJi4nqmPrJFRwM474pBkYmjxKN9op/hcmfZYJiQqgrFUTmBvDTkiE18PTH2dVWBmHreQHk8kV2R0iYm65rsgCidJrnZjutO7GPFJJdVK7SukdHUkIPlEul6coCoGSnSr4In+gqXVkjqEVbU8x02+gUX3WVqMQvZpJl5u6JXWCZoCbz57h7Gyze/+Y10iOaM90ofI0lqWgBJNCFRuZbsE1GgdULOPW73KvXZJ/CjS/isZBxBlRD36A9uEy4+h+ktmm+9LnZw87v0117CL47Q8AQ6umCWt9UW6hqkOUuSEdRTogTENyZHLWKFCzGejZziuwyB1v33rc2xpIRI0bmXCu9GqDRrYyjza3AQNgCPOk/yY8im8KiF/KgZUpfxhbjXaI/GDu8To7RgMsomZazw1u1DHh1t4vs5ITmCG6+7HZwPaFSaMOdsPsLtvkv0G4Sti2wwpkbwkslJSNd/Hz/dJlx4lspXVN0hXb8ku1FpFdSTpaTmGYEqWY0vksMYpUYkIX5iRlHqiN7TOGeKlQw+CPY8w5LNpTyQc6bve5qmWe+DpcoIRES86TcgEKaAo6chuGClhBCQYF4dKoZWee1xrqXu7iJHr0N7l63lO2zky3RuysvXj9mddWxf8HTa0qlxSZy4tT6HvGcvPv11QHRPJ3PvZ0b3fnv8h3X8WAYD74VtRqMRv/zLv8xXv/pVnHN84Qtf4G/8jb+x/rlzjqqq+Omf/mm+9KUvAZYhfOlLX2K1WuG9ZzQarQ/y0y2GA9/gdCvKew/87/t+MZW7vmhpZIHkKnaOVxwervjsg1PrEMgZ8RV9EmJpmRXNoNkMXsSjKTLy8PCVCyziAZ988hKNi2sfAZc6fF7itWV5sEN/+zrTnCF35OxQqRHxhJxJfcfo0qPohceR0RaLZUfnJ2x/7FFk8hC5EAhVi+PfKVTgZFinw2CmFNzISIH1FuMnP4ObnGf60DO4vW+RyRCXiLZoXCHze9T1OVOTq8cEZyqMzzx6iQfq83z9lX2q0RYjHyG1luGs6+4nQUKkSKSqDscKmiMxtkiORuaLPVubm0StIfd4Z8I8iTH9qmKUlzzz0Aaff+QKIyeQkmknLJeEPOdg511yWLApCnFFqhzV+QfJB9eM+NYvcM2EyaM/Qd44T/KC5grvTghqrMMAOdWGJes1en8gwMnj1t8b1qYjO1Nec8GQKm0XttE7E68auBhZPB0VI9+jEnGpp9u5ykZ7gTPS8tyj55ktOxzK3nFLFE9MynzV840X3yDKmMY7zk7GNLsrsiYuXDjL4aGwjNFq69ohDoJf0aW+8DEiQXrirTcJD34G8dvFaS+biuHiHgev/DZnJ+cJ4w0zt8odstwluEx/41WcGyHVlCTm15BdINVT1I0QV0iEwWyDwUiNxlL363kd5nYo373vkKEyjvEO3BgkgGjh7ATTiiAgYWxKmS5Y+OuGpzCF0hR7xlXg0XNX6K5eY4IZFQUyoWSbEiq++eZNts5uM4pHVFoDSnDYPeDMDEo8NHlJ+8Yf0GnDhTPn8VmpkCLcNWf5zjcZX3iAcO5hxCkuzam1NYe/9e5j9wsITpegG+QwYvzkJ0nbD2A1PvvsmYT3NecefYZqtGlzWVoIB42EYbZOe3jcV9o6vfHBmuNikxXANbjQAEpyFaMHHyM88DGQcxzdu0bIDXRzJK0IzrG6/k0WfWY66xm7MW2oefH1dxlnM+KqfKbPwkw9IykdFGKCV3b7fOfXqqq+I2m8b0nIiVTxR2WC/4cPVV3XWD/96U/zz//5PyfnzNmzZ9+3VWSA+kej0X3ff99F/D6PPT2+m53x+wUJxtczMaFGO1xWpDKymxY2eB9NyGeEEruW4BpSP2SQkaAdKzyLMGZCz7YD2RqxI0s+frYj3HuRdO45FHO8k+M76OE5NM5o8hIXM+ISRzhwFeMwRlYdMCde+RyjS88Z2+fcisVywdmLH0f8hCwjAqeoTWXO7/t8auYymcFnTwlpzv74CuPLnyRWW/hzT7DaeIiwvIXe/gOq/i4O2OKANm6QZIOMY+R6pkQ+fn6TzSrzm6FjOmlo+pYcMRVFXZKzY+kCtVjwkAZzm2TtllmgF6GLJhakGEns4U3H9ZVnGdWy0LJFjvKSc90u2+OOx648QEiZfHSbJu1wKS1ZpBqXz1CnOa0m6nSEC4/gH3iG+O5r5LTC9Ur2W8jjP4mrzllm4mw79gzZv236RRHXNAY4QV1OSKcyTLgdSsNzDI9DLPsEeqmBiuwW9nvZM5rdJe/eQc9s2EGnHvIeomOQhhFzpv2YajLm8UnF6++uEIWV26RnRZsxDf3kcPR0fkyzuY3fN4fD82crrh4cs1o5dvZWuCzkekSoVvTdEpHAuF8y9h0V1u6XQ41qREVoXc1YHee6O7j2Nmk1wW0/iJBo0oqFbjKJHRJGqEwIOSKyJHrhqDrL1I0QKhINrd9my4GwpKKoVWIW1O49c5tOmVAp1jNvB6FlqzVimbSvEIyV7nIk1Vu04Zgz2gMboEtyv6DuW5MHFjFjKDJZE9MRnL8w5dY1xecWiLTqSWFEw5KRJNQ5Molz3U12woTOj9mQnkoUlyN9rmi5ALLLSI/I3QJNQnZqrYbqqdo9jqUmxg7d/RYuH/H/Y+/Po23Lrvo+/DPXWnvv093u9dW86lSqkkrCahDYAiFk8Ihj/xix4gDDsSHJMEP5I8PEYIiN45FmOCRGygAiMgQRjsawR2iGZJNgBJYlJ0QCgwQSQk2pL1WpqlTt6293mr3Xmr8/5trnnnvffe/d9+45RE91Z41Xt19nnbVXM9ec3/n91mEJXEXQZCqp0iDUDLVjjKHnH0X7r6OpjlGe/U5CdTxPqmAAPAL4ZbonXtFOUoLMzD0ppp9P41f77AtOIXpHdD18c4kknpHrUmB5C5WEMKKWk6S7vhtZuw+aEXVvmbR5jjDZNMGzNKCabKL1FqvSoTepeTF0qR1UGhhKSeVGDLdHfPFyzX2dhpMVNKF33fLCvdTy19rTWyf9pWC37bucRYA+//zzvPvd7+ad73wnL7zwAu9///t3/W77oG/m363Y9f7e5ZurYtVbIi6H3hLjSUMQYdQoE0KWezVmt4ixE06aiIoJEBVOODHo8i0vuxvdPMf5z30MGV8xGd00ZPz842w9+1WcbiOTdUOgRyiXTuD7a1B0jPFrewiuBDHSlsHqKVZO3wWug0ph4dFrhM2mXwOzVQeIwy+tsHTmfggDExwihxNH62w99ini5nkjEUpWEx6ckfpo6CDeOBO6knDNNv2QKDxEghGPiAPnLR2AaS/stTZiYDK1GJOeOosSYPS4q8vLOdVSIySWuyVnVgZ4UWi2qC89Q6VjuvU63XqbqhkT6jG+yfXfKkCFc4Xx57ebhgsWpmw3GXJYdWZ82pBrm+641ti28di2KsX+zXwNdssq+hS9PogRFDUXvs7GU1/E6yY+DQmpwfmdi5oj4gWic4wlUEuXRICUCM0mPho9bCNWE59ipHQ6ZecTgaANw/GIT33xa0woUHW45EELnEKpQzxjXJaytqoXN41ymH5BJA03efZLjzLaXLfvi1AunbC6cxQkp1IoqJZPs3zyLLgSFegsLdM/dRZ8JztN+X4/HZxrr8s2EmDPxKhp3cz4kp+RiqdYPcXyHS8D17GyNVVIDc3WOpIaE/8BanXUUelKTUdHRPE0CIEGlyacWS158K5jFF4Z1TURowZuSbS8E9BIJQ0dMYEhDzitczmp3fcFUHXQjJBmgmxeZONLnyKNtlBfGjcDU6oE0DEVEV8PGV78OnF4BV92jahJwj77n1E4W3TE7R6/aVrrRvuCRelUBFzB0pl76Ry/y9JcJCMWVKVTloRykPegiqW77sd1V4zvwnIbuMZksJe7Jd2ywDmh0dw2dtHaHo75/U98mS9/7RmrerxqV9i7tA63138z2m3rDMyWCj366KN8x3d8B6urqwwGA55++um5v95hw0XOmehQUqMorZPdViXWJE2UwTPBs9lYoLuJkRpHLQVRnKF1NVE4KAWOD7q86r7ThLiNn6xDswn1BqHZpEjbUG9SNFuENDTdb9ehe8/D+JP30IQO0u3kDdA4BpSC3topBsfOZO/f6ItmV9X1KJl3jjWPWzpB9+zL0dABscNHYzTd98kVOjomRZM6TjEZxS/KWCoUoRMSVdpmLV1mkDbopU0kThglqCmZqGcUYZIyZen1nhsCvjQnQhPeWTnfQw/eb+zAGlGBtZUV7jp1AqcTaK7gxpcJky2qekTZjCmbGplM8E1EmoRXj3HhGw2ycwYig5TpVtv6R7nxznSDsb22CUgJ3WVYWrNXlEjJNm70PDJ5HprL+DREm9oOODWeeMR44sdSUIvlhcu4zUp9nqV4iZ5uk1yJusKUBNM2uIA4wYujwND/VyY1E4SgQkcFSQVOlYItnEzQ1Bg7YnbaRC0cKdGUJTWOkXqLrNJBlIJw4gwUpVE4+JQpkSvC4A4Gp+4nSUGSRLm8RO/0fajrgbOUljDLyqC7xvaW1q94/PJpuve8ksZ1qAHEeDKC1hRak5KVuEYc2+OGXtpgkLaIUtDgKdXIh45VIx665xgaa5NPzkemw+R7vROTMq+36TQbuMkGJBOUdtogjckmO8yxkhSpdEjVbOInJpzlqw7iQnYY8txrhpRxk1KHhGYEk23S1Hm6NdtVornv3DUSrKSCSofOnQ9SHD9LlAIUvDdHoywcvgi2TJJS3fUAw9CfISVqLF1AzYmVAffedYfxqDiPIsZV4Ey7ZFgnhrWCK24Y8p4Vnjsys9s2TdCW+D399NN0u11+//d/ny9+8Yv8s3/2z3jlK1+5sNe9FVSpiHnpqubRrq9vc/7CZbxUlE7pV4Elb7fn7bGyzASNEyIZHKeO8bhGkzFwBYFCLBOY1FS+VBuaeoTL8r0xdzFpvlm5Aq89Gu9JYYNO2UVHI5zroBoM5JOFhwy5fm3ypX3e4U7OVTxOujkMGtrtmIShj4s4BFejrrAa8FRnZLWQyh6lS/SlZnz+axxLFzhJiZs8z1ZdEDVycdzwx5/6Chva4e6TyxC3mRI17ruuTRciOEe3bA8xG0MTAW7w3kET7fbVDNn+2mcIWy/ScUqXCWMdm5Ogk1wqqJYr94HkK8NCuCLLCu/fhxvPkVvbmNWX1ARK53Di8WlI4ZRm81lGj3+SOElU4/UsvmSOpm+PIfF4TQQ1R3NQX+Dk6EnW0ypDWWYrnCHi6ekIv3mOGBUJJrGwXCQuREcqAuMYWSuUZZe4qB4vjeklUOMksfnEFymr+yiXTiMkClVoJjYucUSlQ1zcBjo0OJpQoUlwhUeCZLFtwWt3ygNh2ZKsMqjGMaAz83AeJi26w3VJrmTSaofgIBjA0Gkk+ZLgBFJExSHrzxKrF41BVJWBH1HGbdLXH2U0nBhqxDlijmIYxW6cRsncZIuquUSME6TVh5xssfHEF+jf9TB+0MvvMlEyIUzWQQNRE9pZIqZEqUopShxtM/rqZ+idPo1LI7wqTDYMoyHzuwvuFxlQjSAlkUDwfRoKe5YiNDhQb6mjfEnyvoTUh+4q6RJ4ybX/sUGkRuttVlc7yAtDoMRrpNSJEQ2lSKi6DJOQJGAxwSPioZux2zoykFLiC1/4AiEEfuAHfoC3vvWtvPnNb56rYuF+r3uz5rFa8YgwScqF9S1GE6uHvvvUGt/xmlewrBt0ZEI9GdFL67jJJiRFc6wvNlYr7cURsuhRJi1GnLMcrwWAjZXNV6grSb6y8ipXon6ZFNaIUpHKCtdfISydyKE7LCzoSlpxESP23FlO+4fVcqhOZkhkfCenHyTL8TomYYkRXdQFex3fwWuiK5OMoPbEqPTiBt3mMuX283zvn7uHNz9yB4/0LnKMy6gmnru8xWe/folHn9/m489OeOziaHqLSCle9ay8QOmU1V7FIw/cRUVDoDEshAhBEik1+KTIZERqxmy9+DikLY4t9VkddHCuRpmgOqKmRh00wYMP1EWPulqhdtV1blsHu33cdG5SjLxIXEBdyAI9AjqhrK8wfuaLjF/8Gi5NjNwmg0wDDYU29DslS2mbweQiIUUGk4ucbp5lbfgMK6PnjULaOQaM6Wy/SHAOFxuWOhV/8Q2vohMMiOVEOVEl3vTqe6jKgPfGcKni0HpCffE54nhzGmL2NDDaJKaExG2qZgOvmwYu9S6nXkL+9TzLBdSbKmFCpkBBCV37XczhFmXKjbN3LtzK2lVx4LtTYqQ29jC48wGkO8ipKKHDhCIZ619nfAE3vIiIUknNvce6FNKQXngM2Txvt2hNhmHQSClG143abbWgphhfNp2NokAFwnib8XOPEycXkTQEc0FxKUKzZUyHsSG5wpwMIj5uwniT+sLX0Y0XAcMj+HrLnJY5HJRX4VxmrL0EiXM55SBEhYRnFAN1GJjTIDn54Tz4Hp3TZ0EsKpp8AXUDmiidcs/Z05xc6eOxvaNTX6GUiDYNUR0bjWOU+Tiu9+6OUgRX220bGYgxTstafvVXf5U777wTgMcee4zz58/z/d///XN/zVmQ10Gtvam0Wt4RqCOI86CRY0tLHA8jmsf/iM5kQFcGDCYXKZsBTmdL0UxksCwsPw1Mf2Jld3n3E0GdUYmmpCRxBBqIBYgByGLoEnWCSGWKhPnv2v62FPk+v8reMdj1tbTiQfl3hQzLy3lDBfCMi+OMixP4ZoPKRRIVHRkTGCMhEJuaQmCluYic/wqr8Tzd3t0UfojoRXpynM8/cY5aAiPfZ+h6nNtWuqsVqnbL3C/i51JDn4Zj3cCxbqBKY+qU6/Ux5L2TZKJKyfpfytgoUcsu/aq2fGsa45pMEkQ+JCQw8X18FdBqg+jNWWsTBNOxO+B8uSXBFKeoxV1NWY+sd5EipUyIOVwbpTD6YhKOGh/HlNrQH5+nNz6PYAJFy7rJUD0iBeexeVdM1jneylQDMQAApLBJREFU2+JSjDit6ZC4e6ViUDgqIMQJ8cVnOPbQK+l1hMsbE1QdUXoIkUq3jRGvvbmnCakZGWbkxafppnXSc4+RzpYouSJADA0uGUBpczxZFEi8cS20gk4iVzkA5h7uHvebDQmbSKZM899FpsRVdcjgNNo7hg4vgDRUukXVXCH44/TTJoU2+CT00jbdZhMByjQkSoFK17ACJHyqcWkbqYd4WQIcTiOFjkFKJBRIU+Ak0UljZP15RqOCzpn7UewCYLoOdsNWnx3SZsj42ccoBksUzSZptIHgiE2CjUvIUnWdd35wa1O1V6cJZBp5MNbMBqTIqUlPHfqo6zEIBqJO0o656RhEBS2WcMnh0wjimBhHdAIsdwt0c4NQXyFefJIqjXGpZns44pwEXrhSc/+xGzzbo/TAVXZbOgOqOiWFEBG+67u+i2/91m+dHtL9fn8hr3vL3qQo3jm7nSlMYiKmhPNK5YHhOeqvfZxi+CoqPN3JeYp6DYk1TiMihZ0nCYqywodg+ANAJUxBWqITnE6QZIecYOCjQENMDVAyOHYnaaCMvv6oAb3EiHL3bqRABjzqrsNs3yoK8oJHQYVWadirgtaoBpbueiV6oode/jr1c59GU8ldxyu6g+MgjuCFpU7g219xgvL85xnoBn5ymWZcILGmFs9XnjxP4zs0eIRIM9rAaWXOi1hP9vYuaMODdy7xyrMnWas8D9x1nM89/jxtwLcIcOb0SQo3MSBXViJEhFT0ON5PdM7cT1fXYTymsKsNIVmYc/mO+xHvWL90jsorO1GVnZE5qF1dWngAk4RKBF+QnENjmN6KfGoLL5U0Tf0kul549cP3s9ovGT/9PGFyhRpo1FF4hyQITmgIdMqC73j4FZx88nNsDpWCiBdluYi84t472FjfppvGjF/8Is2dvVwTAyIdohuAXqFIE5sHgulQaU2sxza31s/j4zZbzz8Bq2fMWfAFhjUUoMwwOwU3wuJs+VabXJt/2xmO6f/b3NHMUN1KZABANac3gKxfQFimKZYRKVAiRdqmU68T3JgybeNEKaWhqq+YNHjpEZ2Ys5MPfEmRoJHXvPJlXLnSN2xPdpi81kxULQ0igaT2GvHys6zHhurEXUQMk1BpFpkWu12rKjreYvjUZynuf5hCR6b54CrE1dRbVwgrZ64an1uxvTTlO9ZeYQwzRNzGux7iShKeY/c9TPQb6Oa57G6ZpRbx4Rzl/Q/TPHORtL6Od47CefvNOKHySme4gV55lrLTsNSrSJp44fImTz5/ifuPrV2330dRgavttnQGRGRaytLv97njjjt4+OGHr+IJmLfdSmQAVapmREdHDGUACk1MRByqGLdAHNJ3E0rGlgNsNmliQ50UQ8xrPuwSPmAH/qTGVT00Rao0RLbPIWPDDBRAXW/ixgUujc0xECA2uM4A3znB2KDTRj7CfkeWHe57t9Rrjm0O0e4+/qwNdZ5y9STBVzRVwfbzj1E4T7/0dJa6OeQrCJETy476hXWcTCCOSTHSNA2FKhPxBhhMgpeaQscUWjDKYk6t+l6rYljFbXrxMsvhBPeuOKrJOoNuhyTgdWJpjbrm+KBP2h7Z+0wxa9Z3oDegqNcZ9Hpw+SLEBupojHPZ8SmWT6M6RnwFLiPDNd8q2+d2QJ/gViIDKs5AWS7L8+YDRSlMXnqKuJbsPgpBlNXVPmUAGV3BNUMDtuLxriRRoM6qQCoaHrjzBOVTCW0iyZuTGeI2Z8qGK01D4Sd00gaFq3FhAK4xwSpfTVM4Qsxgti10cgFtRnhJuDSyyEwcm0MLiCYmEtAwoJRq5lix8Wznq+zKcrbz8toDfSv7wjRFhmlI5HgXyWUBI3E0UuGdUMYhRTM0siLAp4ZCogHexOcKijTtriSlLAL3nRzwmc0xk9GQbtxEiyxkrTXJVYb414STCHFIUV/Jz9JC7sY8YM9XWza9ZkTVbJoQUGpI9ZAJgVgsQdNQcLNg1WuMz/UiA0i+xLT7iLmjKo5i+Thp5RTDrW0GWRzJnq/FrrbdEktrZ5k8e4mOc6Ro1NJODGiZkiPEMV2GeCno9Pu4LQFfMEqOrXGiqiDk1WCRJZk6W0eRgavttsUMeO/x3vOWt7yF17/+9RZ+yjerRdWF3tLNjYT7+p+wuv4EiBJQao2o6+BcMAZBhaHv5w3d+Ouf2xKe34SUdQMaVXBjkDFc+RqTz/+/+NEm7vwTVPVF9HMfpv7Knxiznja49XPoxRdwcQiajJdFxmzhaNyAktpQ/sFde1uQNje7ewyuGpeZ30dm0dwOkQIXAq6oSG4V6Z1E1s4ihUcbhXpiyPGig4aAT+t0mRAJ03734wb3NOcodAuISCpJOLxEUu1xqSapUruCqMr6VsMoOk6Mn+aO7U+zHEaU575C/OyHSKpslyVFWmelEh5YXaXfjHM0w+Pqmk6MNPSt/FFGiIskH9C0iaM21byiAZesRl3tABOXNdVRUyXM0YqD2s3PL8EXa+jSyxCt6KTaRF5w1J1VHA1IBBcIqaYTR3bTdB6fRkhs8JMNSka02HZ1LoP1lLUqcXenRs89S4PDqyNmFPf281/Bf+3/ZUwixCFlqmnoM2FAUXQ4udajKhrUexpXGINgStRPfYb02IeJcR0nI7w0xLbGvd4GDfiqQ3PsZayvPoQWAzwQFKAHlDuUQm73WOxyBGY/zWN6s/vCzjwWoECkxJgdDURZaGOS3Uv3UFd3UmrDiTCh6C6DGtLd+CsLnHeggo9jOt4Rk4MEDQF34cssXfoi9136GPePv4xKyfKgz72rgoY+QsDFxgTL6m36zYugim+2AU/0yyAer2NwCU01pBEO0+CIAkXaoHaB8bEHkaJngmVzvB1fNbb5cRjHhkVSxFWUmBwzriD2TrC98hBOK6qkENWYMqs+W3d+B9q5m1AAOqGRnq1B3cL5knFawblAGUfUqaTu9ZE0waWa57ciH/rjr3BlbGoVGq1SJYF9TcYxcBQhmLXbNjKw3+eLtlvFDMTty5RxbDeElhYVQ9K7OEbVbg8daoo4pBKjMW22LrLqttloHBNfoC6z/U2G6OYFSGMmW5fpiFiNsfqcP4ww3qJpCgoJhs4OK4SlNdRnFEKuF28xCVdfqNok3s5hllKaCnfM1tHP/v6uZkTyFTllhyMQOsdYeuh1DD/3UaS+ZKI64bT57ymR6gmtkDFqAjC+22EldummSI0BMX0oSLVjFMVuxiSaBMOoDCc1zWRCEYf00wa9Zh3GSn35OUJ/QohjhMhKv+TbX/GtDD/7AXxytvPHOtPQevDexjI2pv6ImgwxdktB8l1Hgom51DXdnTssVx1Q17GWuOV6EtpXm9BZvYNq9Sz1U39EdB2cH4N4ihN3k85N0GbbeqMJQUki074pDlExwZlkDo1PSkg1RYg8fNcqf+HV98NXfp+gE0KKdHykQ2KycZ608SK+nGQ1R5NQ7lDTLZTX3PsAnXPnTdURhyYDLtYb55ArL+B7SyiO6AoaLS2XTmCYPJ0wYPkVD5KkixRlnkrt/JLZ6cY+X+w7timlaTTxYCM7+4Vc/TMVJmEZf+xe+qfuZeuJL9Bx2/y5h+7j7uEQufBpcyYynTQug2y9p98pCGNFYyRog2ydozf2HNMN7lsrCBUUx0/Q6XUZbW5nB1uJGqEZ41KaMpPulNFY+grncM5AhRBJjYHvmAwpqoql+x5k9NhlkitvOG4Htf3Hdgae2II9269VgZLO2r2cWnFoKEkiiHocJWH1Lu5cuhNHjUlBJpzz9t7jNh0cHVftyBqLI6Qap1ZdMqwTowvrVl3RVlPtenaQYiTltfZSIRW6kR2NwgHscIRExl8etEGbOm9MkU4hrHaFk32hENOoX3ZjTnUSPWno6ITxC4/T33iS052Uw3rG8ifNGGlGoBOrk1cPKdFxhk4mJUqJRtYjFePOSerlu6BanrJyJVdaGWBqZjJ213gHM/TMrZDHgd+9KElSBggJ0EeKNZIrEIY09TrS6RsoDEh5jFCjUBYmSKgoexXLUhNSg0oihJKGQC2eYSN0ysCVrQl/8MkvsT6uKYNH4oh+3CI+92UYnaNgzMCPObtcUqoSdIwPNSlNcEFA41TyGXGIMyY6Uo3GBlRnkOz2fiz8WOL7x3D94yDlDHJhylV7w7FtedJvbmMSCF1S0UN9l3EycFujHh2sMXItSGymJhyjulXxgMnzxibndxrLYXe0YSA1Z3oFS77GpS3IZW6uGRK0wamx5Yk2Fv6VhE9jqrTNUmgoJeG6fQtjq4ALNFsXaS49i2xcQK9cJIVcgeEMA6NJIXSRag3KY0i1Nnuk3FrOPzuubSRxfiaMO2cY9e+DznG8c/Sl5tRySSeYgwVKoDGwqQu0mgCFB6cNTUwQa0Lcphc36eg2lY7xzRYlIxNnavEnkzE0NYxHRpWdrOTQEc3hyKmx5DyMt9l+8otobSWjXpS4fhmNEcoudFeh6HNYZ2DvvnATQ4dSoLKEhgETxDArYqXUKktIWAYJSFGiqlZGmMaMnvoCK7rJshsTmIAzwqieDglpYkyozhO9t6LMNgKisymfncjykXTxjh05Aweww04WlxoLYUlOHqfEg2dP8n3f9QgvO92HZkwg8poHzvBXvuv1vPK+u+gGKLYv8PL+hH/vdfdypu+MeEQcjIYZYTuiKLyRBqUGSTVGhFPY78aa6Ark1P30HvnzUC4BdqmNvkvjKmNQu8H726EevnlinB3kQXtXCCB9GilRHUEaokUfFW950NpIXEQTpCGSJogEBoMu/7/veB0n+hXQUPiAasFWHSk6fR6+/zSb6xt8+evn2ZxE0IauRHpxk+Ly12B8CceYB+9c5a++8bVUIeDiFpI2CJKs3E0bJMUcKclMhwoS7XaVgOSyaE3LwyACrmTtnodYu++VuTSzfe8tDv3gY3tzc81uXG1W1GkO9Quoc7m6wILqKjLtj0pLHe0M85nUsAYpUQiENObhu0/yintO4nQTJzWNE2JRZiIqKweL2fGoJVBLsOiWi9xxcg1XlMjgGGGwahgO8Wi9DtvncNRIPUGOncFpotCaQkdI2kZ0YrdMV5G0OBhe5QbjuwiOeUVYvf/V9O57LVF6OOCBu09xx+lVjHfQZn5IdcYXmEBYIwXBgRdlfRyJrkAnI1wc4dQkzy3/rxBNQ4NU28EeJ2gzMSZNjTl+1karPFL0jO8ijmHzPE5rE9VKdRapgqieiXRpwoDD8gzMzt2bibrs4AmcpRLE8BAicfpzBVQ8UcXYKJuaUhqGLzzFax66kz/34Em8NMYp4AKDZp0qDi387xxNBmvLHoDplFo97cyJo1SB2ZEzcEA7zIYiJLyDSV2zvjUCEisd4Y6+ozN8Mee6Ep00ZG0Q6FWB4AMhjjhTbHEynmOtvkgvjSlIxPEWQScgieQ80XmC5NrlYomJyzdtnaA+EMtlpH8SXJnr62HiB4ykmylmr9P3PQvl5t//HqiXgErFhMLC0zHiisEUJOVTQ4oNQkS3LiGjDcQFnNScrmpWi4RzNd3gcRIY12OCdxyvIh0PWgwYI7axxhFFvcVSMnbGhkjlapYtq2B4io3ncVojYg5Iik3GnWT0vZp8i6AkJd92nZG2tPdWV+DKZaTKtxnywsp19fMKx15tdhh4EkEnVK4BnWSVSY/6ihpn5Dcu2KHczmFNkCKkOAUeolZyGYgMKqFTKGy9CM228UM4O5ydACokV9Koo1ZHI5bLLyXRLSSLVQ1opMD5QJKAS0NKHVn6R7yVjtUTXBrS0U38xvN00hbB5UPBzXfc5noDFNCyR6qWkdBFEYoguGC3/hzDw0mkzroESYUm9DMLJlweKbWrcKkVWfJMpKSWDg0Bcc4uEAKiMZMcpZwKhJg01/BjFQeui/MdhIYiblg/svMQXP7dUNGUy7b25dYjJYc6QHXnEyNRayiZUFBPCbFah1xClhIWh08NFTXLXcdSJWiKjKXChy7l9nk6cWR/KxH1jiZh7JB5CQrsy0FxZGZHzsABbNYDvtVFkBKIL/n6My8gKBUR2TzPuU9/hMnGJSAR4jakMeCpKRCUpbRFeuLj9K48Tq+5Qqk10ozQOLGwY6hssZCM4XD1LuTMw0RfQTNBkmYCoC7g8z3RUR67i87J+2mFcK5lsxvorbx3UcGpx2vmSnACIdA/fgZfDhDfQYqBcdtrloMVZ3TMl58nXnrBsBKTDdKLX6WTRjgmdLxtqM1kRNcn+hLpSE2NZztqlh5OnFjqs1w6EomJc5AmhFQTG0ijLeqvfxmtR0h2pjSaxKxzxs3uUEh1foCC+sI20V3hfMlaDiXgcGQeg5s4fG59c9WdXS5FUKWOghYDenfcT7F8kigFKWFYgrLEofhk2BIvDap1xj8kcC3yvyHVm1x49A+J557ES4Mj0ivg+FIXn8Ymx9uMSY0dfq4esuwnDHyDxtqiPS6gCknNOfXUgEDRxXWP21hqQuKYdP4Z0vYlRGurxMCcqXlohszfWtyFZM6JfOJkR0syXbMXQaolfP8YuIpy7YyNiQib42jVPM2IU2tLrK2t0UgJvRXUFUhs8quYM2pzqp1XCfUB7XTBBdRXUC7hQh+XovF3iOk/OI3mQKgSCVRrp+munOYw2/+h9wVaDpWEqEM0IJpLB0nT8mScnyF8UjwRtCY4UyqV3iq+6jOIm7zyntOUXtBmQtJETJp5HdtOt6/NNFpwFBXYsSNn4ADWOgFtPvembxg5R3vi9GlGkwZSpFDLFXbG55FY2681JhCjLlBLheIppKGz9QzH6nMM0iYdsfC/nWZK9IX50Wohx1H3JMUrvpWmGuSbVTIhFTE3wOf+9NbuYnDyPpOBvQmQ283nXbP0qdqmlkSJztE7fRfSWUadCaaotxp4reu8ZhXiGJfGeIHgatzGCxTNFp4x3SA4VZw0dF2kn4a4emsqFa0pIlpzYm2VblHSNMpIggGKVE3OWWtkdCXz5itoJKWIxpTHxOV+1NaeOCjKLL7idrBbQBQhTkFu0Q5UDn4NacsKb7aaABes1A1Pow4NXepyibpYpbjvW3DHzqC+IqrFN1y3ZxoKcUKabEEco3HMaDKiSQ04IYka5FPHlFvP0qsvUqZNyrjFkhuzWtSEuElXh3R0TIgTqjSkTJsM4hXK8QVCvY6TiHPmbCZc5tlvQDy+t4ZbvpPGd1F1BtYUcM7GXVttjDnYLG5gnhZQgmouHZRMACQ5xbXj1MpgFVk5SfIdwqm7c5TGALOFjvEMufPUEsdW++ZU9XsWicpOFmS+j+wUSEuJjSN2+lBUUPZJRR9f9WFS25yuCnQyzgdutECVD/RP303/2JkZbMutWxstvZmxbSUTbJ55rMaqQLNMdCswZim4YFU9U5cIe+8KUTz+2BnCyjHWSnjNw2cpJNmFSpTNrW2bTxkzsNMBcBlrcIQX2LEjZ+CANpsiuGrDbsOu2ftOaiFlVUVTQ6MgEumGxLBJVqYlFk4MOoE4slrcWNPGtFTF6r3FUciIE1yiM7lI0IRnbKVaGknq8DkPHL2j0QDhJGlwmuRcVv8SyIxnQPavS5IL4NwNj6vZ931Li0fbLGCuNUeg7FCngPouGkobO3EgplbmNVE4h49G0+pVqc89idt4AY8y6DrWBh4HVNRsP/9ViriN08hkkljqFpxZ7eCdPTenzjbpWNtmEPJNq5ngXTJQHWJlWb0Vwon7UF9Zzj/Z4e4VxLvMkJedKNk7Hjr9KDex3bZAppsfX2+HUO8keuaV1GsP0EiJ+A64FRrpWemeKE4SKkITrZ57++JzxOE6CfjaM89z+dIFXAaYRgS0oaOGT0nlEr2lAWd7DVe++AeE4TohjhltXOLihXOUjNH151hafxx99nPEC0/hHSTvLHerimC02Y2riGWf5EtqKamX7mfiV9HU4FIGw8l1Sl5vwmajeTcvBHVtm94u1Zw+JYPV8rfbuv/gDKRpUEKPuoJOVbG61GN7Yx2XqYX18gswvIRnYgJfccz2pRchlMTeCVQsUmjERWQsiiO6QFSB5TNw7F587zg6GRGTEH2Hev2SYUcEdLJNTIpKhd4gIngQm6UivmkskWQ1UWF60Bs41278SWyfYupMZrbJvKKCGP6ldoVhMkiUqWGp9Fw4fwFtJoy3NozXoN2/8j8L4OSqriOHYGpHzsBN2tUTxzx2cwRqIBI18wKokYQ0CL65wom0wVadGGrHMmNOiD7g3QQvCYkTYgr4NKFM2yhGI4sXHj7WcNJdxovH6waaJpAmuCS4FJiEDo2r6cQa5DjhvjcwLrqo7yDJZRrdSe6ttxwcWN8P9f4PYC5vl1OCIwcaEF+QfAUh4HRMDB7ihAIjGdLUMfCe9xRJ6DQXWZo8S0iO++7s8T1vOEsZKjpS05u8SNlcJugQIpw+1uV1Z1coXE1wQjlKLMUruHoDnCOmi+YMjBNFjETXIRLwOkJOvwxe/mYm0iNKDyWZ49YoPrPeKN28IWdENVNyXKxit+Agy2vWAbhVPEYAytOvpPNtP0jx6r9Kx0OZRuB6iFvK9+xtxEcTVvJ9S32MztGLQyYqnJskgkQKIMTEJFqZqlMxOZz7/iLlva/mNfctsbr5RZqk4AOTOrEZA1HAjy/ymsEVHuxsUY4vo6HDRAJRnIlApRINA5rOcarjJ3GuJlQVxbf8dcbHX43TRDUZ0aBWGz+H/O6tj+0BTCxw3WQghVBDqnFJwRc2A1KkcIKGikiB94GlbsWr7r8bj5AkEl2PThwZS5+MSW5gpEFxnYlUuEf+Ek1nzW72cchEHSljbvBdxBWkE6+gevBNyMpdVC6RihV09R5CvU4slkmqFGkD1cTYDZA5JM/3KhceeNjYWSU+44l2/smUY1IJECq8xuwMNfli4+hqwiWIoaDueEa+YuCUh8+cYtR4Tq0s86q778i18343PkJydGKRc+M2tCNn4IA2S2q0z0+nH2cqWQAsf7V1hU7ahM1ziBpBjidBspp9Ll0wjrjU4JoxQScMZEQRt/EarfY9g8Q63sKLImJhdE2oLxESZZoYKl4cqVilKVYMIOYzZ5uC/U+mHvbOZ9d/73CLmAnZ91NanXTavLDL6OLp4dgu1JjzhnZfDWlCGSf0VFlziU6aUDhyjtZyhE3K4C21IKRVVkxsLCfb1FdeoNm6kkFeKaOaPaoRTQ3JVRB6UC4TXQeS0UfjvEmnimQkdubal50Nbpfm+wHAg7NS3LeSF5c20pIJnvAlbqYm3xnXJUkKtqVPLNaY+D5RvIWS1TQscB5iTccrldYUjNHtK1mvwYHvgA+QajxNBnXZ2KLWDx1u4dMQF4d2+CNWkQHmfGgE50gSsjhNxbZbRsseE79Kw8AYhl3A5+PgsIFsN0MuM//8sORMTTEF+dmFoJkCMm0aSK7w8IjzOG2odGIAP7fDitd2T8RZxCrldiSzlU7XLOaopTGiBjzEhYxl8biqg7pAFNP8iL4kuQ6RAvF+yoo5r7Hd+/nBRk6me8+uJTP9ef4t8eDz+gRaycrp3HDmHhTUOB1SygQRR1FWVl4809rsQp2dD0c8A2ZHo3BAu3bp18xEowUVtQeo0tQT0vY6/bhJuvwUPg5JMVmNbBriNFFvXEI6FT54mFzGNUNe97JTfPsj99ENaRreve+u0zzywJ3GSigOmpGFFYsSl5QiNTiJqFO0s0bv7KsJpcd5u7fqzALcuRTceEuYTRPMLdTa5t1zH3KptAH1aP9ZmsVCh6CSwVmacDHRlcwC5xVSIiUl4qhTm2pJJpSkTY6iKIw32H7xcdLWZbvXpwZcMGcvDUmxzrXOge6Z+6hO32PYPByE0qSXMw3tPA+XdmwPd0sR2zSdtwMEwTsrQ5uEAd37/hzly16PO3UfSQVPwoeACwXOBfqdwLFBxdlTK3TSFtsXnsmkLS4rY3o0GqqdZPOSOEJiTeEKJCqkCegoa2OY0JAn4ZKVxol3pOx8hf5JBg/9eVyvz+o934J/2RsYBk+MsktX4TA2e/ubZ5pg1gxi4nBE48ZIjYEmRXBiypmQy1KdA63p6RZFGtPvdSyvnXbeqYhAbcDMFBvA8CQWKreqG0lD/HiDUFiqxdZ2BHWkzrI5CL7AOU9YOY6cuo+JX0GjN30I2Z+E/GZsdmxvrrTwYGYh/RY3EICcorONAkSN4VShbLZx6Qr3nlmi3ymnWBVr4ur3ObvWjiIDZkfOwBxMc/4K2fFDHcYwJgIlkW69zgpbdJwymUSCjnCTdQKJkoRUfaITdPschU64d81z/50rpjiokYTj2KDi9EphxDjOo+N1qykOAcGRtKBxwQ7Poo87/TCND/k266YOisjMHeMm94N5etH5gmKgK/HGMhZngHeSgVhEEsm+6zzJFTRizGXel/i8AadMCtSkzGCYYmZqy5u0CjrZoEhXqFKdn4/mG5vDTTYMvxFKkjjc0knc8Ttss0PQooP60ngdpjXahz+sri32ctBG8kfJzgCZ5AaB1CDOMwkD/JmHkZV7YeUOE9tJ9fS1m0ltksTUrA0KqjRC4tCazwx6zhsGRTRZ1EUSwRk7o5PCyIW0yYJZ0QK+rrBysbiNxiE4A36peKRcIZx5BY0v8St30Czfx2bok6TIfPb1ocZ2r831BqgwrV/3hb2faWRAiVLmXL3inOYcuWk+BGqK+iKljhl0u7lfFrHTvD411iSy44RhKBpnc89phHodN9kglF2GdE28SxVwaGGSy+JL2xe6S4xX7mHDr4Ir8MKO8z0HWwQF/FQF1VnUI0kwCe7pzpWdUQmgBUEnSH2eU70Jy76hXxXX7dNRNOBqOxqRA9iN6Y93f28ajfK2vAvnWC2VFTfC0TBpaiZXXmT8+OdwqcHFCeormiQ0T30JnWzRPPtFZHgBr42VB4HJmsZty/L7guHXvwrDKxAcDRVpcJY0OJVPWQ+yzMRXECqMQncntL3T64OFslubZ2RAWmYwsXpgl1kIdwA/yW5Z4hEfUFW6/b69FyeEKhBcpFm/AOMtRC1VMJ6Y1LBLmbWNRBMniAbixRcJo3MmjOO83VR9gSpsPfUl0vln8N7ljbVAQ4/R1jZNgjpvSuqKDArbCd3e+jDshCsPe0PRnKNKOCgqC8V7TyOBkVakYgWkj7iOqQCm2i5eIoxHQ+NT0AZfD/HJwtiIGPGLeLwPuLoGAa/GdpniGO88LvRR9cTUEOMoY0MKnC/tdzfOM7pyziI4GFEWUhL9wDZ0H6B7Elm7hxpPK7B0WJvSGM8zqgWQq09QpU5Qq0UBiBFVR+qtkXwH1URwCk5ochi/1Amj575CxQQvlk6gJbPSlhcSxlJRLp0AKailIIYeUQokNUyefRxGm/jOKqzcDWUfUOMVcSXiPD5UVmfvKtzKWdLS3TTRTdfJYW12X1jE7VrVoikNzsCXuByFEZw2eGkQqfDlio3XVz/NpS99nDs6keMdv4umYu++PTsXjsoLzW5LbYI/a7tePrfNbstO1ngGMGBwvRACZ06scaVXoCkSgTjaIm2/SBlrnINU9BBXI5svQDNB159DlpYtXRaT1SynCRI3jVUrFKStS7hCafpr0D1B8ch3I8t340TpIEhYYlgsUZX9DMDZyU0f1GbRtrdWWngAy4eNiLOyPgHEbsyGkVqh3/GkS09z9tQxTq87uvUWyzhWWCeMr+CbITQTw0io4rXBxzFOjOY0eYemgrhxhYIJ5oUU1JrstlRVxMvPIpIyaUy0zdmbOE3CG8eAtyoMP4cw664hUJ3DbcXmX8q5epwjEZDeCq7pIGoUxE4yoDQ10z9LOcwrTjJfQbSUzEwaTMQbXiUZJ4OI4oMQx2LOqO8gfkRyaiRF6hGxyACTjawqabK8bdoq4mwTEihXTnLH0ndRNx51Alowz3167rfXZGXA4kvw1bR8V6sB1Z334de/gLuybdkwMapgFY+XSDm5QpGWZngD7NkJinNiJYZrZxicfTmMI+NUsHTqLPr8Jr6ZoFsXiKmhHJxi7cT9Ri/sMrNkqOxjrnhxUtE5fh93rNzHhH4+JG98Cbjue9+Dwp/7TVvaQ1pwRYU2AY05eojiqQk6JhR9/LE7cINVhleeI8Un+N7XfzvV4BiGOdi/+Rb/dcRAuGNHzsABbRYzcBUrH+Tb+Oydu60yUJI6iqIkOEUT1MmK+wq1KgLLjloNvI9jNCmF1DTNyPjE1a7PkiYQh8RoMb7SRSQ2qEukahXt38ews8aAEa6xQ67prOI6fTTjcCHlQ2HGrrMW9lJ2zj83mOlHktUOp5RMw85CBET1OLeMOIcXRy9tcdpfQZ7+I5h0WNn8GkUHCgw8KSlSj4eMmnWatE6Z46ERkN4KceMCMhrjY0RDQXIJcRVFWYGO8CkZ/0CqSVIh3uSBRQJSVuYQuJCjLO0mPh9LLTD0pkcwTz2FqEKoOrmW3ZGKPtF3EOnkKdngJCEpgjQZBGh6GQBOPElTvvQajbHoDtAqxZh1GuwQS6oEV1IUfZJsEWMi+UBUcBR4Z+qTqR6ivsScgRbTkEmREwiNkejICZrmCoEJIhWzkazD2EIwA5JIKVGnRFH1iJsC6himQNE5RvQlzg1p8btJHOoEH5RO2jaRItJ0uzBNL2MKdM4YHKVYRuMYLfukbkWjjoDih+sM1eOLJXz3WHYjsu6ELwBj7WsJiZJbgsrTDGuqlCwScwib3RcWMbaimrGTBp50oSRNrEzVyqUbPA2+7EK5TCr6BJ+o4mX6fpvgVoFrO+zX2stfynaUJjigtaQl+9Wltkzvs972VPxnmk+THPIOSGqodITLopqaIjHTtjptjDZUFUk1wTvTKBdBkiHpnAj4aHiBpGjoMkoFSU1+1lKHioSCkw++Ad9doT10b/W9z4qS3JS1HAzs1I5bOjCRxJMIONVM6hegjpYvdFmyVUEpSGGJpEI3rvOm15zlWPM8PPundLaexTdj7DgJNFIwriO6fQmtRyDecrApoqfuRDp9pI6IL9GmJpDAF0h/BS+KaG0RCuyOjXOkqNSuQ3n/qyhP3WH5H/SmGAavP0Q6jQzc0g1Ldj7xnR7dh9+AdJZQlEYDsXeCYy9/Fa7bsdF3DtWcCtEEEqmTOZzqipxqUFzGXGjmHnDe25zDBIpEjHjHeahO30Hn1d9OuXQCl0BDB/WgIRBFkGYTnxoiHYImO0hlRrlBWnU/jwum77BXPvtWrXWy5h3VMpyAkQ51Tt0Fud9IAb6LSmngSfEgOV2ioKFHQUOVtjDyZ2/v3yZ7VssUQugBAaoljj/yBkJ/Dc0sfX58hbLTI3RNYyTlKICoIhJwsSY4pfEefI+WadT7YCDGaUzz1u1Q+8IBTDH+j7EU9F/+MNXxU7aHuSLzVtjnKRkgVZoJhdamfXGD3e5ae/lL2Y6cgZuw/UiHhLyhqrHWxTaqmpnuDDiQDFmsDRGPH16kGr5oCHmdWImXC1b3nuqsPtbJgCSlcZ4kgm88JIdvxqgM8RIhOpJbZb0R0A36aYyTDnUIxOAplh9EspCKgJXqzNoN9tvZnOutLB5jP5tgh7XQSEYvoaRiwJieRQB8xPmC0CQkAm6IOE8RG7xMaMoBY/H4+gp9vULfjZHNS5RpTNclxFdMpMtY+mwMI8vxCpUXUijxWtMjIZ1lYrGMpIKJ7+DKQEhj1DlS95jldEVMOMmXiGRnQDps+2Po0gNItUbtO1byaB09NBCrBWDdEunQ7PMTQVwXOf4aCMsEgUTFRFaQzinA0OzR9Wi0yHO0QbRhrOCdM14KUVyM+O3LuDjBqsEVHyrCeAM04eMEwVGmSCfUSKdCTrwSihNUGhhXS6SgTCSw5Xr48UW7zcoKVZog0pBwtgE5QEog4AQLB0uV9R0OObjshLDneXs1MGuBC56O1KTucSauIqU66z14RAIhjnGuQMOAqtnGqVKXp3CpoVdfIEmf6CrQCS5lzstQkqTAUeTX6eBW7gPp4yiz/7aBdro4Z1GvmIFKXseoOFwzBjdmu+wi1appdegETcJYvM3tQ9jefWH+lRqCc0J0HYZuGV06TfIDA5+mEk2BRivEVzjncp2FYqqh3tJU17G2v0dAwh07ShMc0K63UcsUCWxfSc7J2QdnN01NJiZUjxivbxKrLbRSxHuIWG2xc9NWFExXQBUXJxg2aUS9cQ6218HK3/FpQtFbYbkaIKFjh5nKDqUAO3XW8xiDm1/0kh2ivOermpCOVFQn7seN2z7aLUu0MdQ/HuMKqBE1XEWdInG8TfO1z1OOL+PrTe5YWqUqa8JomypuU+gYTeBSQ+oskcYQcshbnENdhRY9ihN3kC5+Hba38yHqaVXcNMd6bGMekE48SDW4C8oTELepTj+I9I4bOhyZyyJqx/amNqdZgNQ0tw9YogVUKXvLduRWS+AKm4/OFCJdioSqj2wVWftGSOLxqmg9Iq1fRFCSGBkMIuhkAilZBYEvM1GM4QfwFbXrUPXWaOhQSEm5sgYn76d57o8RfwV6y1NwoKXSZ7nj964vZR5JgkWoFto6m76CpbpabgGwaY9i4sw7vy8ILlR477njxDKVV0vpSS4X1oD6AvVFFsPKo5DLMWWqgwC+qHa6M+2W8Tg0UuBdaamKsmt/kzucyP1sVVQPaYtIE1iS1SGdVaozL0c6J6nDMipbVs5K5rfIv58Ui/Y5v6NUeB1Vxusyyr5E7cgZOKAdlLSk3YRtK3CIK3Ldusd4wxp8HOFTbSp5SS0sLka805qqGlALTKJUEk5H1JMruFiT3Cq1K/Bxi7B8grXjLzeOfw0Gvpp2Zr5jcLOetAGZLCzp2zt0SigV1elXUBHAiZWmCZYeSELSLqijLS9zVYkrurh6Cz+5YsQ2NNx7epnQ7XPx6efoyQSXJgTvUfW4ex9h+6knKIbnjdVMPElKZO0O/AOvYrhxiSCXbaPMm6zO5BkVQTrHOfbqNxPDgOgCXkr697yKJjka3NyE9a5PanVrpgi9Y3fCmlE0BwoL9ztTdYRIGBzHrbscrGnz+eB9QnXcQjdgJjKk2OarzhDbPpfD4QrGfonyZI+4mVDXp1x7ACcjRi9+hpIx4mqQLmiwzWe+sIt9bfYWO//G2XVAz37fSyJog5eW+taqBSQEut0ur3zwYUbPfBU3yYBWl1eIy85ALg9toUj2Ou0/8GU3gxax8VdzZGstqbVD4fvUroKya0BcN+NazXEoFlJaKDbPyv5xuoMBWgyYSA9HRIYvILURsbUU67hAJBMvTcbQS1wPM3BY8atvRjtyBg5o179Z5Bxci3sjT0Hx4Cvc0jF0+JwRvaSGQicZIJU3gBmebNt0cyOaLI0oBYpRvjoXwZc0g3uZFA3h8lcppYOEPkkzMYx12HZsd7jddi/l6M0CCFsBF0fMyGlTV4SS5E3Sx4mSkpizIA1JSiZ+icIFYrpsoe/uKnL8PpoXtzDeBcF3lk1AKEWKqoPfygQ5qTH53nCSZsUEnZhsUeBQ56lxeN9jTIl3RVady9oEAmRWOAMy9FAvFp4kVz34ipSlf10Gdx7WbikycEMTCF00JaKrETyBhBPBJUsPJL9Co8YVIIAryvxMIl7H+b3ZTb6NnmgWjlEx3EEgZSa80jQSBoLo2NQoqUjlcWJvFR2+gO9UTCYFHSmMN2af+bkInfmFkQ5l0Gsb5UCzqJA4ukGouoWxjWqycj7xBlxNidCM8M0Ql7kJEGcMjL7IktGzc0Gy0yo52++QokOO2WT8iqIS8IPj6Mn7oLOKXzoBRcfWSx6HndjjId72nn1h3mWbouZkRrWUqWpJcA6addITn2C8HmgVDlFI4k3zwgW2L7zA0spZrne8HUUGrrYjZ+CAdm0vUvaEa/PvGgQWX3TpP/AIGxefMiaySSJonSMDdrCqyi4kuQ8B9Q6JGfFKwURKxDuESE1Jde/r6BVdtj55nqLoIK5kJ8lgteMiO1Snh7XDAIV0Cqy0DUsyCVLr15vz4nEhoE5Nz335HqpOh+FTnyH4LmVvjd5Db2Bz6zxBI+r7hLvuIF3YsBtB6GB5Rk9IY5qkpM5x1h68g8nzS8QnPmNI7cxZIK4yciHNwEVvfVIczoV83xDwHtF2oViKQ8XhXbIc5W7371DjO38QlqBq4FN1yYCpLVlLqpF6jCz3iWzsVAh4U44LNEaXLTupBXU2PgbvtrTL1BnIB9HaA69GZMzJUx78CuqgWDpBOnYnPHOe4uQdbDw7pnJdi3y5q9/zvMu+FqVauOvpS8ZcpETM43N8ZUC3expxZEKsrDvoPIqizZig9U5qMIe1xQVSUqvEkJbPAkQ8qZX8E0s3GJ6D6Q054ugfuxtZ7kIYcMdDHi0qUwVVdqKPc4rILAJAaN0yGm2r1jQyppBqQtpENsfIcADaxzzKBKFC+qv0jt/JaLyNpgniu9d8jXlH4b4Z7Ag9cUBrb8X7RwfyzYkdtgEVl/95tFxhGFYYUYLzRgOrDU7396bF7dTTtrW2KkKKY7j8PIKQ3DKpewItyqyWZtuSYII5KZme97xstrTwZkVJDCvgLAufQXrWpk7DgakBopKcMpQOW2kV7Z4iFp3Mluegc5za900rwFVo9xi4kpiUUFT0Sgf1kGJ8mQ4jK6sqBjQyoMlj70SmkQA3FWuRmX7tpAgs1ZMdNKLVy6MkFVI0QiRpc8KHNOfcTY/tjc2iVSlhojYW+7Acf5bBTlWXCNT1COcFdYHkCkyK1+ZfasdFMh3sTKRA2jQBamx55SqEVShXwBcAJFegro9ohbglxn6F6DpomCaOdlmM8ZbLLPez1rGYd1lsmxJM+7UrQuGV4JPNM9nBolhZn8tlwzFPOxtfQQw/kMuS2wIDprgBt/McZAfn0oKYI0ITOlCtoaGPdpdR3yIXJMtzp7mlCdpn1DTNfBrM1o5VjDYAToTgFKFB0hhL0lk1Fqo0KlD2CYMlZHsD4uS67c97jn0z2JEzcECbLS28tunMP2hxA65cYfmeV5DKpbxBmnzuTkninlZyyM/43yWjt2tkfIV4/muUlcdVXdPzztK0OxLFRhbjnaFx56kJDxxgDPb+Yc5UZDiV6ZY7RNL0gFV0WvJUi9K74x5W736EWKwwUbuFtxUXiMOniYUlpSBFEyEqXOIV95zm1fefYlUvc6oYU7oacY7OsTtRV0JGzMv0gE/GJ+8ki6HkW1jrgNE+yVZPXg2c6byVkeUc8DwspXTzY3sQU3trwbfvOh8EqUFjg1YFeGiakeEfJGBkNd6euTjQnD7JB5FpzZszYNDPNL0hJxdQ30Olm2d3jSKkVKBNidLn+D2PUCytGZBtn7frvZ9WV8xlCBYYGUAka3+AZsAvYL5TarJkdtzBEamCNy0MUjSGwJwCUGmjjCZk5rJ4l+b3QCvmlZ1U3esMYIoeE4SkJXVWz9wRL894EWRu87Z9RiHML8hsrpBjgjdV05bq2heWDhBPzNUCbXokiSeFitDpUY+2sqbDrpULGTiJ7syxRelV3I525Awc0K4tVHTVb+7+SoDQp3vqTlxR0IjxAbS3ijFdNvwq0RcIxkc+pKJOgjRj835FKVxNJUoRG7TrcaXgk2MkFcn56Z5qWIUd9PQ8HvBhNOFl5t9s3nO65NUOkqR2Y1EK/PEzVKfOoji8K6HskXI4OYggaWikOS7gZITTGo/jjuMr3HmiRzdtc8xbmLFODfTWmHRWLacNdvirRWiCGumO0RZVqDOQXZu+EE35UDPcfHsYRmVmMz78Ab6Y8iwQjGkwJjtgTEPDSt6SQpKSgClpRnGIeApNhlNxFdH1LKKjknUGFHB4SYaK10gSb4RCgt2UMSwIoiA1UYUoXZCAOKF36i6k6lvf9llO8yaEWQgxjma8iObQi5pbpKqZTFgQrVFMRwRXMvYdm1c+UDvjXphIh81wgkhJC7MFMWyHGvOlTCOP5hgnMq4oRw8dLXLeZefMUg22y5QZ5Ik5u9pWNxx+3h5mX7hh29gOEVVMoEmgKZfYdgMijkIjRRqD1FiUKpB8iXTWcDSk7RfRrKiZ2vBKi6tgZy8/Ki3csaOROKAdDO09DYpPl5lDaMRY2LwmGimJzpun7oS0cg/Du74Nf+wuiCO0u4qcfS1NtYI0Q4gTq3+nhsaRtGLYrXCyjdOCcMdroHsshwx93kzshulkHsfUTijwllDDM95Ae/GRaTKjQCgIiJWZl0DqGO9/WeJKRShJgzsZux60N5o0MrIlCoQRGhskmnZBk1XhqgTQtRu871Hc/TCsnEFDSRMCSB+nICk/q9CDpTtQsc1TUaLGrL7HNEQrtDrsh5fXvWqo5h6yVKAGR3amGqNVdh2KZgvVgLgBvTgkid3EnPP4tE1TdGi6q8S1+/HijX5ZSouXFBUhTaDoUaahcT8WPaPQZZI/MlU3TOIJa3cTg8fJNo2H6LwRPO3jDSwC5T3vNqexI8k3bfEoRmRlh1cwuXIJRBkQeicY3PtaQm8Z1ztGWDmBqy9Td08T7/9u6B6HlGgoSa6yFSIFSRw+l+Mqgk9jUsv3IQWScpWOlOAKSgRDz6RM89zDiWAJmxJx5JqS/VM0NzUGe7gG5mVt7zqqBMxBFQQ5dg9x+W6C1tzVd9x/okMIDUKJuIrkAvgVijhi8vSnIY5IJJo21TKN0MCOhPqRtXbkDBzQZmuVDxq+bKdai0z33iP1toXGXUlKnu7aKe58xRsY3PEQqVilGZyid/8rSWXP0oDBbv7ahvykoJYu6roQAktnH6LoDJi9f89GMQ4bat0rRjK/G8COlyDItFQtqd16koL6Et9bxVVLWIgvZe2BnL+XTC6iCt4ki4MmRKPhAnym5BXH6tmX4boraNnLoUdPxBF9l0Y6iAQGJ05g6OQJvg2sttUde8Z37nXrM+3O1xxJxSIZuQZehFy2mvPUokZL7ARc1ogoOlB2YGmZmHKEyQcDo3UGqA8Qggnt0FZUtMmCbGIARgDfX2Xse0TXZVq+qVdvP7eyzm5ki3leO5j8lLDICWpKmSg4h3MlEq0ixRerrN77KlxYJZQn6KycJdaOVPZYuf9BXKdr9MFq87oJK6TMGihktkvniLlcWdQcVJnpjepuEbKd1dXOW6xySZnbvtCO69yjWmrrXdsqDFXKpVV6p+4gKnRXlzlx4tgU2ErVA2c8K2hCmwZLnebIkPV6pvnFrOHb2Y6cgQPabF3qLXmUrqJJymoxwdVbRF/RuA7qO1D0idJHOycZMgDpoCrG825HJaK2gSZJRCqQDkkguR2q0dm+tlGMuXrsC6gnbvN4SR0Sega4VPJhXTIulm2MtMkoQ9t0C40YwUrHfj8IaM0gBDrBE50irgBXWLWAs9tD7K7SaAWuhNBhRJdhsQahJLZATK1NLbJNDewzDrfD7dUO+zAtU2sJfqwCLt9qi5LgMAnYOLFSVynR0DWO+9DBl6YpgPMkCvA9kpS4YGVzTq1SYe+Gi4oRHQH4inF1HMISUwLvVmZ5nzGY51gs7HllzEOrtWDls2M8jUX9VNGYrATQVYajkC6JDkifpBUSTH/BaImh8ILg2HDLTFyZIywRxEpya0pSZwlh9832IGfaIsd2vvtCdi5bvGQGV6o4u0RJSdKY8RhWBRRDl4ZOdsJAmwZNDWRwK7AjHcNOtdVRdGDHXpKlhbMqfFMilWvkj+YyWRKoVHjnePXZFT71YsRXfSgDUYJpDviC5HrUvge+mEp0qi+gHhuaXhNeGpx6TKIYRLzdsBY0p/fWE8/dk25zea5Ayh6SmdcSQrF8itWXv4bkK7yOQJWJVDQSMuudJ2kBOiQF0DTh/jMnOPltr6d/5QlcUdFEw2w6AviSpTvvQ5uJVRpISXXXy+jc/TBISa2B5DqUCk5rOxRnEhuLtEXU1oOxuM3qQZCBgMYV4PA4OsGxBKwNOojzRFeSQklIE5IP1DFSiWEBxtJlcOwOJi9EQjUgaKLWZmb+7URQAMR5UoKqt8zJP/ed+N4qE22jLQtQwNzHFncD1AzZdZRi4mOSRrnqRFAa1NVErVExASIrXzU+jJSYgmInvotSURKtRPNlryGRGQbVnODkSiZhQPf0Gvr0kB3xsYPbvObX7B46+3F+lqseAEQz6LhAiw5JClQTXiNIQUTpnrmbzuS4jWus8dFDln8XaVMiDmN42/0ejhwCs5dsZKAt45pMJtR1TdM01HU9LTnZa9cvLby+Gf96gDhhafg8vWaDotunaW9tqJW8dZeJYhm/yiXEKVKV2aO1mmKkwakRku9GJ+y2lNJCAGlzVyfLZVdJPa7sI640DgIV6Czhl08h6ixs7ypS/zQjesQm5v4YilsDxDim5zyrq8ukwkNRGr+7CpJvFK6zTFg6lq8cHqoerrcKrqQJS1xMfRJlDteyLzLg4GDSg9staxMcwKzqrH1uxjIYxTNRwQdHv4Cy3qTrGgvtu0B0wRDYvkBd5qxwJcOwTFq6y6IpxRKmHpfIpQj29+zk08FRekFCRVi5CymX8U7w+ba33/Sd99xdFMgN8oESCpxzFKmGyy/i08SiLj4hjHAhEWnARVSM3lmLiKbGFA3xbLtlms6JDPB0FKt3mFKhAtJWCpSM3ADtrJGk2sXR0EZ8bmTX2t9u1RY5tqgSU8xgXbDdrqDWYJVWscmRL8F1lghLZ3KUQpEYQU0nIvd0p89ASnEhzvftbC/ZyICIcOnSJX7pl36JjY0Nvvd7v5fv/d7vnUYKgF1Rg4OVFl5tkku7EI9rJmw/83nK8UVUTiDeQq1ZvZxi9QzHfDeHFD24glT2mCShu/py0oXnoLPFyh33YeVfasn1fS5Yt6yAdw1bRAlRbhhRwYUAdUkST4t8jBR46Vo+GwHfY/X+1yL+HPrMkxZRyDS6liZocElBo6WjxeFdmIq5qJDFX+yGbNlUl2WKA50T97LmStzacXBtmeHVHvOtzoXr2aJKC0WV4ITC5Vwqlj5RV9E9difiA4VOKCYb+LoBpyZ04z1xVO/SbPBln+Mvfx1h5TTLrqBWhyPl8tb8grNRquwPBDWlB3U9awdoS+2sk7v7PFtaOI/xWJRqITlNkHBGMEYkvfB1pH/GsBcqEHfQ+8qOQ4ZL0IxNryRULN3/5/CjK9Rf/AhOIEoBZWZ6zHiBYnCMEy9/Dd6PqV2XMC1FPLjNe2wXti/ksfXe+D8S4FxBubRKXfVREk4bDEclBKmAgLpNICIxQWygbKML7MoTBB+mpYVHFQVmL9lRUFU+8pGPcPfdd/Nf/Bf/Bf/m3/wbNjY2mGWCa73dWdKSm7+5qanDiVB6pR/X6egw1w+L6cPjSE6gs0p58l5Uekxcj7oYEKs1NsvjcPa1bFWnGPaO4Y7fQ1soZijmqx/jPG9X7WYqInMnbgE7Fya1kvA43zpHeZOVkC+dQnIVrJ3GnbzPKg7UeBhUFQpvOcJk4cWUw9AazTkQMYcgqWGVzQmxbK3zNoZh6TSDe74F6R63NMw1+3vrUaK9NquetohojmS2QY2WP7XSSMckeRMNQimpqXRER2oMdKX44DMDYfYFREm+IJy8h9g5TjjzIJRLxs4oM/GTPeeLKLRoAqt3zwj0mVzuXpsXIcxs+m9RILdcMAFiURavjUW78EgqoCkgVTgCooaRMBfU4VNN5RKopzxxL6zeRU0wMS9fMFFsHosBQGOoKE/fC2FAQ2GRrbYr6IFwAzFGYoxzdbIWpVqoJJrUGPaCLPTUG6C+stdLRrKcpjU+IYdIsmS5Gqsm6M5My3jXmCMDi4zI3W72kowMtJvuc889x7d+67dy6tQpxuMxw+GQ5eVlnnnmGT7+8Y9z7tw5tre3aZpmyrA1mUwIIRBjxHu/a2Ht9banX6cG19SkprawahzjmhGI5QLrmKjHNR3Fqoa9kJrEJBUEqahVSa6kcUJsCpqmoHENMarV3ROnDsssU6CIMB6Pr4mFOOiGKyLUdT11Buq6nn6/fZ/tx/ZQmy07mo2u7P1oi9NkmYk1W0koYoMbb9FIl1ot9+q8UMdIdI6iCTQxEmJNrBt8bJAopBRo6hHaJFKdaOqa2Nj1VJsGXEGj0fQMULbL41Rlj3LSIE6YtDdINVW/hnqKRG772256KSWaprnqmbe/MzsOs9GmvXOj/X7b7l7swGx7s32Y3cT2jvWu9pPlTImJepIQP0bH2wx9B98kq2cHjvmakGCiHYaDewnVGrEnlHViO5VUE8XVNU0UxpKo8BaUSiNIY3MwJmOCOJJGnDg0NYZ4F2NtVO/RZCVvmlHze8ehHYt2nl3rFrsX67P3hjc7NjFGnHM0TcNkMrl6Du7z7PaO9b5rJTamWxFrmpiYpEDpLGcdY6JOgq+TVQWPJ4j3pBgRJ6QGmmaCV6WeNMbSOGmI4oiTETRjmiYR6prYjFHvGCNo9BQRmqQ0EWJtrJgxqdGYa+uYZXbPPePaOrLXWvvXG+vZ35kl7Gnbrev6mut8vzHf+/1dzxI7zGMqSBrxKZJSxMeSWC6TxlukFKmbCamumURLucRGaDonqUeX6NY1dRFoYk0QYZIUFwRtIqmJNH5n/e7dw2erJF4qjsJL0hloN41+v8/6+jp1XVOWJUVRoKosLS1xzz330Ol02NzcnP5NXdcURTFtZ+9GsvdjuwlFdTgvuOBNWlSEMkBQIeWwanDJOPGj3aS6Ehm3eulJkSIS/JAghkz2IaHJoc4hew7fdhNrF9feRTi7AK7F9LZ3k27baSMD10Pitu3u3XD2G6MWoOfrK+BqxuUKKVR00jbOdUwzIClOKrxEm7CuwHlFq6zQKAm0wksPcRNcaigbbwxvODyBwhvfu8siO957Bq/4Lnv/4kzTQOMOCx9KyEC32Wc5u0nMboh7x3Hv89g7Pu3YzD6jWSdr79/vdS5uNNbTPkhA1aGxRqoOjjGJMcNihaXeEnhP1RvwyLEB5eXn8KdeTv/BexBRJA5Jl77GsDrJarmE05rkK0oEkRLvoUpbRJaQckAQDM0dU573GeTqHMREwKiNzUFmmuTeOy9m3+fsQb/f+O49XPbO39n0QNtO+yyvNz+v9/1pP1ygEExnxBW4Y3eiW0/hvSA+EINQUoP34JXGgWuMeyQWFVJ4oi8pg0MlIGKcDOoEJ4kUG0o8zgkqbVSngrKEUEDZtYoZMEDtrv7unkP7refZcdpvHPfO0/2eVTu+4/GYqqqu+tm1LgizH9uf7+6DhUUai6lQSCR5j/OrLN/7aiaPXciMjNCxRYo48OUaS698Mxc+//uWSnUVIhFPQ00gSo47ZqyRD37XmEz37Pxx77z6ZraXpDPQTro3vvGN/OIv/iIf//jHeeCBB1heXgZgMBjwmte8hvPnz/PFL35xmg8TEUL2vsuy3PVxv82p3YScc0isLTcNBO9NTjQ5QrcPZYUPBS41uCKQNOFCwHlb9CEY9WsoOtR4QlGCA+8disd5vys6q6pUVTXND87a7MS+mRxquzh6vd6u/ODe6MBs+wcRA1GsBKvs9UhNZMwS6peRomvvTxxBXR5r+xhd1hHwZc73e0JRIMN19PKTyOVnDLTmPEVRUXiXn93usfC+t6vfxXUcnNln2f5NO757D6EQAiklyrK85vueHfvWuWh/f2/+dW+ZaNuH2Wd7rbFWQ6ARNeBDsJRVZwl6xygGxyGU1E2k7PXgsuB9gZZdcwaSQG+N2g+QcoALFeJKk8bRBi2DHVTeUZQloQgoAecNB+INHUdKiaLIRFjaghGvPTfKspyus9nD/Kr3tmesZ9ferBPcOgHtmmjb24vRmHXM2q+99/u2b2NraZiq6uCDQ7o9mmjSuS4UJuSUgRPistNfFIhAKgpiShTe43zAuYArekh3DamWUF/R7RYEj6UDXMA7j8MhaZnYWUVCue97gKsPsL3vZb/f2c9mx6p9lrOOWusoV1V1XdzA9Z5h297ss5QEKQih8RQOvIBIQPBIfxnEE+MEl+eg82VO1zik0zfXSO25Ow8+i3BNXEOQCtGEL00waq9j0/Z3Nlr3UrCXpDPQen4PPvggP/ETP8HW1hZ33333rg3Xez8NA7cLYDweUxTFvh7utbzrKRmIONscROy7CrhAbBISIQQyTW6uXUaM2KXogK6DC0g1YDKu843KisaS+Nlqmelrz95Yb9az3bu5tBuJqlVfzI7Bfn+z3/eu1QejBm2YRKVXrnLq7KspeyfBdVriUHbYwjLoLOe9UcGHAhVBJOE2nmfj0Q9T1usUZx7CF4FRHfECRVFMHZrZZ3WQPu79fptm2g98NHsYHcRmHYvRaLTvprnfzfd647/XMY1RSVGz5kLAhR53Pfxaiiqg9QjnA5ryeGSNCMO5ePzgJPe+eolycMwUDKc5f5AWWOgc3u/ZSma6NzsW+72XveNxrbG91rjsd4Pb65QelOJ4vzaudUMUAY3WV8XIb2JMFGXJNIEvkm+wkkmFbH23B0/wRikMIL01Vl/5erR/ggmBptmG0rgyolrOPAEaBhx75NtwvaVpdGW//u/3/Ta9NXvB2c+udQDuTcW036vrmk6nc92+7NfmflECwITZNKfP8n5HFjVrGQmD7ETuwMjMIY+zCKqWDpwiBoQpHqluGgjscjr3c6razw8yd253e0k6A7Bzu7r77runG1C7Ec86BLOTpCzLXb+313aFEHf9gHyAZYpg1Rz+jkjVxc1upJKBQIJxDBTdzKZXoeUK9XgT4xZoTE+e6RF51fs70M38JjZIEdmVJpmPKTg1WeGiz8rdD+YXhZQhZ6puuue1JUZRgXyrapKa4zS+zJLbwDUTmkxQFEK+vepuieDWYboVJHG7ke91AA/8jq8R2t6vmuAwm5DNDWMXtCiSbaRQUQxOWPlkxpZoKyfsPSkp4sQAb6GgXFqm1TuEPH+zSmfwgbrdTK+ahe3sPJjNRgL2OjS3Og773frmas5AryBG2MSMuqB59dYHac9tE7uysspMuqTJsiauxC+dJmbp3TAt1wyImCiUCKir8MtnUFfdVFfbNXDQC8KNxrxdOzeKgt2SSab8cnnt53VvWi8VMRrZFdreoSwFqDkS471MJeJbyTHNJYoKhOB3OXnXeq+zEZBvdntJOgN7vcD9bC8Qq/18r8OwX9tXtUUGBopt+EtLA0JRkCYmHKMpUYhHNKNmxULcTYLClSYpS4Vfu4te2EQpMCISQxs72dmG98ur3mx/9/v5bK78ION3M+ZyaaXOhFPJ5WqSFzvYbUE1506zMEwIgUYA8RZSrTdyFKVrm3MdM9Pd1e/1MIfDtQ70g9h+vz97cz3IcztQHwFa+VyNuawSi7SYEAQm8uKzXLGzw63dgHMN/GxZlp1rmXpX7NCOaUYSd/Z32z+42X7vCfdbM4cYh7wmblQJc9NOHfYeU56TTOevTL+208pNf9/EgmwuR7Wxbx2mJA7vTNDJ0Yp3kQ9GoRCLGIoLKF3g4IfUzTpVB13jsyDN9u+u1+bBzE5tFaYRFptvBkR13kqQVS1aYD+f/iXgLOJSj/Z0oH0GQkwRz85efq1I20vBCWjtJekM3Krd6sRIYiHVsurQqHLs2BpVv0cTY/b6ZxXE2o3BiFoIFUoAKSmP30W5psTMHIfVEdxsqfFN2yJzZqKCwyOYE5CkhRRi5Er7WFIsnI0zPn3ItM4l1JukpNQUeHE4mqscpW+kBX4t522uJoYsn16wbEcExG6c4lG1ao3K+2nRn7QSzZnzvv3b6VHfhmNT5rtv01/fILbXoZ/3+NoYZelhQMUqLKTFtFxjZdqPxDg1sNSBhbOFljQkkEjZWWuLM71q+6oGOLyFPs9zHBY+d9usIDvTymisC3xRwXhjeuvPvcgRmMyxkpqp6FibYpj+plxd5fONtC/8f2EvWZ6Bm7V5lJlIVe2E9DOqfTpB9xTCimuvZg5xpbEVSgWh38pvwJ6lsLe/izjE59+mIJpLeUgoEc2Ma5J/tveM8d7C1w4L4XlnnOXjaKqN0ZVE38l4jWa2yngutsixnXe7Vp+tqEYy08J05rQ3dxc8pESoOvnW2f7xjsxNywsw5XnHNs+q06Hb69lGOptnveqTm+jzIsZhIc8sR8tyRA/niAriTYZ439M6f8+oiVs5rDRz4LWKGA2q0QC2tONfI1pj2fFbey+LKpVbjIRx3m9yf9MUMpRB1O1vKTP7oDmp3vspt4ZOx2vnfacFreHb2Y4iAwe02dzRTeUvdUoPhJZLAAQdI6Ei+i6eGq8TIFj4n4RLQ8Zll9FkxNLySVYeWDMpXnFMlckkQJtHvOolddrfeQFf9pYkzdu8c/nYiaa90L7uTNfbpetXz7DyLd8N/WOkUFD2+/hyhegqYijxJx6ge+blgFHrcoic816bHdvZr+fV7txvJ9relHx7grMLZSI2Rj5NcMfvBN+K40z//No3UHGsLi8Rywr1paUNiEYeNf1rrtfCvnZL6+w6tveZzceMTExzasUWuKfxA2JYRpLiNJKc4FzMB1a+uWpjYjuS2R2lMvwFWIrL8jr4lm54+hB2HIxbGZXZaol57wvzxGPsHOo2dm3gdFo+KQ7KHm1UxVxUq6hyOZrS+GWieryOjc05j6vPkS3ncrLrJQAMPKgdOQO3YDczeQSrQ564gJZLqFOKNCb5iqFTVrwQZAR0ULUJ7aVmK3TZdiDVWi6ladm1oFAwOmLYD843r5zztdqcr7U57ZRvoUVOM8vsb+w+VooV5OSrUG1MVKfs4cKybcYi+OW7KJbvISZlgqNgfgfBokKLs5wF8zTJ4WoDrbUbdnuoWK5bQ8CNN2mKs1RS5g3VctjTUZv1ymYuvVXhcYzQDIYTrUnic2DbgIY3a/NO5yyKZU7EnPyUDy5Cl22/RlWdxCchaEMTPEWIM5EYRRihroeQqbKdKRd6apRARAhiQlIyxQMJTCWNd/5/c/1d3L4w37E1sGqEKY7KcBSNpVMEYjGw72s0/AVCICGpJlEwDicpEpQ6RugCJSJCqUCWl0KwyoMjA46cgQPbYTYTQ/0L4gucKikpVANWz55FOseIeGNlE83eamD19L30jym4DlcBhQ6wjhcVal0EHfHVrwP7vd2dW6qYdgOJSKBxXXBFzt9iN1RxtGFcTSmXH87PoVnU2C4i8nLVXJgdhnYzb0u49uRo9/2bnZbRGFF/rT5/Y4RhZ8Gvc2545qMj9Fe543VvxHXXUG9c+UYXvmvAUawk1jsHpAzezAcUGW+gBszcfXOdOcxvucvzL5NbxNhOx0yt+sLWvoOsCGmYof1wGYp4z6mz9yNExFWohJxqMRNyyjcleIlUChzEjpyBA9oth3AFUAvvO2+KhMlVqK/onLqHWnvM3n0T4KQg9E8SCCSpELk1qdJ5T/KFlWft8zrTz7GSIEFmHISdZd1ISe365gyYyrMpQ+VDzS+oNOh2GtsbzQVhxhm4uZYpylxW9w28n+6tTJhjw0g+ogSBokcYnERdh+SCOaxiEsX5N7JlDQ7f3vQNGWBph50YmHcLEK66TfYFC/nn9A470RFthbBckYm0d8dJVAxx4TpLFjVwZWZkkV0pVedmeV+ODI4AhAe2WwYQKuRpTfJdkuswCUtIsYS6PuNUkHKOPAlTYhikT5IejbgpWvlW+ntY20u+MS+Bnv1eZxb9nb+bswgmNjK1af7UkTrL0DkOrkQzMYn4wkqwwCiJ5wyamgeYdL82FzW2NxRAmkZRbr7tGBMpzTdaNO+o1qIiA5qBr5LstgoFhAGErpHmSCDiZ4CYksNb3iS1XQVSTEGe03axm3GzZz7MY0zmJYa1t1+tdsu8bJpWSYmp2mPL3yABl0uHycDVNusFJn+epADXMUGzXY6YtZ4WsC/c7nYUGTigHYpoRkFE8f1jxJUzVCunKFbOkAh47zKJi+FeFXLSIExLkG5lui5SwngR3vS1gU3t1pjx0yJTUBwoS2fusXDKxDaNRMIVpW0AIhSeuQIprQvzjza0HBZzL3/T61P6iohVrtzCASzS0nMnRFyGyR7eFgUgnH/kxaJVoVVtdsV0thpZFiR1OPGQNEM2DLshoUKrJagGJBcgpazcvTOGIRS7+j8Pa/eFeQMI5ylh3KapBAMWu3zbn4IHVfHdgV0AZIaKffqJJ+2KLu75MeB9Mfd94Xa3o8jAAe1aKnUHswiqNKHPqDpOWr0fLVYMAds0uQQm/172gkVlKv/qbmGTbaVK52Xte26VyeZtTdNcg9DIIFqmLNJ2BtqyS1f0oRigoSQUBYgau2NuIzVx7rn4RdziW1W9+UsYy3TuXsuUNk1w8+3HGI10B666f92qzc6FeVgLzpzn7VVzZEoTpGaS81P2PQF8BqhJUeGKcurEZo8WfEWxdgYtl5ngSC5zDtA+BqWuJ/b1HA+reUoYw+59Ye6mSmriVF+jjbAqDnGBNE2/zPBgIFm+XHG6+59hMwyQ1GTlxkVVR92OdhQZOKA556a34puPDBibXu1Klu97FWlwhlpKAlC6NAXItPXGVjKDoV21zeXe3OKdFWSZh7UH3366BPMwow3eEQG6+jXanTSPhSjGUlYQncczIkaTzDVaWPub4N1UdGSeFQXzvsWnlBYSdWnLya5/c5MZzMDNvX7L7X7zeIPrtznPW1v77Od5ewWISG7XWATtP2O/l1TbSIbKyoLboyqnuEQ8g3seIhYrTPJhpjPYAgHKYv6RgXZfmHdkYBE05UKmT25BrkAbNxDnLU0Ae+ZeBhvmqgHZfYOgdSh8KPaVvn4p29EoHNBm88Q3TT+bw54OgeW7oVjC5TY1TeU18HimUMH8YT8egYPYvHKDrbXveRHlb3A9lLPdCPYbCUWsmgAHbgIu0MQuJIcTo3pOOr9w897+ztNaJ3NR7e773LJ/JQJOa3acrXwo3bArjkYDjTpUAy29cX7lW+7zvBHvCxtb1G6vuvOdnZC1MyyBWBQgisvVmWnKT6DlKuI7lNLeyiw60MYHpnTEc7RFVBO07c7XzCWy/u7zeqHHuFhBcaCNjWn+m3a32L/N/Pe3uJd/M9tRZOAm7aYnj1jQ0AGlCMgK7X1dgca124C5A1Nr85CHqIOdx0TfW1e/KNv/NSQPQuYQR/b8TGgUoEHYZqIFrncXrruMEonSIo5vD1vU5nTtNgXUmfaD1sYvYGIX0x9fv2FHoiCJoOrt79XP/J3ckk+wqPk2z3Zbl0lhyuEwzU1nELCo4QAIBVFaUmFLVSgF+AEC9HKDgs/uWL4JT/Ugdn/8RrDZCOmiGDkNL6XTObTr3ffWWH3gtfiqD6nJ+g9G4uTz38i+a3/x9O23qx05A38WJrM3hv0P1/15BF460/baJU/XHwMvGWXhSoZhFT9Yob90EjJhjimXHU3za5ug4kgpSxzf9JTbSS1cl63wZlqcc/nbIh1aEdkVppaZ/7dhfzTuLoKbOdz3/8tvFIaG/+/tWvNAfEn35N0gwYTIxLHbabg+4dW8ia2+GexolzygzXODmmXtWtRGtajN9Btt8TjNwrpSUZx8AK2WUL+UiZwyQrvdJOY8JvNsZ9Ehy/3aNiybR8WbJPSezfNGR7yQKxGm0exvrCNs79guanyv5cQ2ErIYUcK3KRQRWuGnG3lPs32e53ybd/ql/fzP0lQKaDFR0pYPHrwPixjb292OnIEDWhsKm8emPbuAFhkSnVfbs/39s8cMXPevmNYjhz5rL3st6kpUqulBpiiaFBfmt3HNs2Z971xYxMZ07blgnlJU+xd23V9bKZzrnVYgzs0iXeba33mts9k2523Xmwt16NNMIkuaI1RioWyL/t/4vc2OwzwBfymluYCL582BcK3X2Nu2SZlDalMzM/jVvZGWG7X7jXzR+bO2I2fgANYegvMmQvn/5gC4tbZmb1mLsNnFedDxEPJFSwEpoaisEFPyHVexioOZ15jXhjpPINaic6/Xa1dxSFEhLiC3gqrWzAtwg7DsgZtb0Nguyq7dX4HBSRIFhnnZca4yNG7n967T9rwjR/Pcx2bX6yLn7b5ti0wDK07UHALVXY7WjUarbfcISGh25AwcwNryrEWQwiyKgnbepYWtzb+EyKwtJ4ObW5xtvXdbRCTM6L6LR0KJuyZ3/q3ZbJnpPG3epW+tXa+sTkXo9AdshWKH0c1+kj9e7z1KJrFhB3R4SGuJjOZd7tW2O2+79lxwLN/9MDoZge/kUDbmqE7L3nbwFvvZItZaCOG22RduNBc8uqeE0FIw7Ry+XhZmEXPsdrej0TiAtZGBRdDFxkx+MW+bN+lQawshF4FdhDsHP2Tt9xIyw9CQEGogkoA6RlKc7/jOElDN0xZBOgRcn3BHQcpO1orfPe7TFMx1LMaU6XTngxhQ1YWMQ9vuvO1ac0EFKFfwSydBClRdS53Vdogbjdgi1lrTNLfNvtA+s739bV0ocwQiMiVrs9G98cgubq3dznYUGTiALSIy0IbWvtEjA3tDlYuODNx8/k5mKuNhtlZegML5udOOzjsy0M6FRdxcZ+fu1S+cP/oeLkXEV0ArlpPvCdfjE3KOphqQvKefxqAlJjV76zZ7G5zHM5tNxc17rc0SOu3LjyHeWEazGmlbimiR7OtHBWAnUjTPlOK8IgN7+7SIuds+s/36uxsb4Pb9yfXM+/nvC7e7HUUGDmjzvA3O5hjbiMO8bZ6Rgdkb+yJuV2A3i/3piG9ss86A4EEKJIOLUmx2bVzzen7zmguzY7uIKFE7x6793ASRkkITEiqsDj7NQDOvnyYY0mW7OAY6NrdMMrlWC+i4BZudC4exvSCxea+z2bHdOxcsly15PlsVgRNhKk+Qv3c9a5/ZPIG784wMzD6jRewL7TO7Zn+FXFLop//a6tgbzdw2yrtQnoTbzI4iAwe0Q9ER77FZNr/Z2/A8bZ60o7N9XFRe+1YjA3sD23u/aqM536h0xG2f2v4tghnuepiBqVK8M74Bi73q9PvX7Y0LdI7fZQyQoWOSvTsvPPsiN2XzigzMrrNFRgauNRfkGp9f6zt7bUr1zPzkl2+nfaF9Ztd+7/v3/yDvahH7wu1uR6NwQDucUNH+tihxGlicIMlkMlmI83JtoaLDWTsOR0JFV9/cdt2eWnnYFtaW0dnXy74qju7Js6zd8xAqJaqtpFb7N7f2Xm4HoSJYLJYIbK21rzMvu52Eitp1toj9sZ1jR47Ajh2NxAFtEdUELWZgETmreUsYt7YoCeO91QTzslnJ1nnZPCMDrS16Lux3K1Y1YR2cI+ER35bBTX/h+g2Lh2oFdV0DycmsAO+tj/e8kd6tA7+I9bCoKiPYjRmYly1KwGwR2Kf2mS3quS2S5+V2tCNn4IB2u+WV5tXXvZvcInkGjtpdnF2TZ0C8Cem4klAOUAKKP9BRrohpP7gwBcS5nLRtazvm2dfD2KK5BhZp82TKm9c+9s3A3nc7930RduQM3KTNe+EveiO5XQ6t6xKMfIPZLFnJItqdd5vXbFdyUZYrmEhBLDo0YsS5zJC3XLd92hJEpS2eEzSnHeQgTezb33nPhUU7hYt6douy22nuHjn0fzZ2BCC8SbvdvMl5Urou0uaNFVikLepWtIj3f702VU2kMBQdlu6+Hy06RMR4W65XUrjTwtQRaL+2Anu5KSa4vf09mgv72zzxSrfDvnC7zYXb3Y4iAzdh8/ZSFz3J50k7Ciw0x7boqMC88/u329juZwIEBCkHFPd9Oz50CBhq4ECBAc1tt2Or7R/NpyRwHraXJ2Pe9mc1b+c5HouYu4uyRY3vn8W6u93sKDJwQJsFjc3LQ19kaeE8gTezC2ZRJEmzgJ55bi5tu/MuLZxnW7DY0sJr9ldauGABxcmbvxmI4H3A/IEdCVnkcJrx85wL7bNfBIBwkcBE2F26N8/KinkTOsHi94V521Fp4dV2NAoHtNu1tHBeNltCdDuVFrYkK0elhdcuLRQxsiARmfkeN7zkqyp1Xc99sz4qLTRry/Vuh9LCtgxynraIddbaUWnh1XY0Ege0vaRD87CU0sIEMxZVQlQUxUJLC+cdFmzpV+d5yC6itHBRc+FGpEOHMRGhKIq5b9Z7CagOa+2mP+8xuBHp0GGtpf5eRGnhvFMFixIqWtTYtmRGR/oEO3aUJtjH9lsos17qvByCWXrfeW+orfff/jts+20bTdNQluWcerljs2ML8xuPdhxmHaPDtq2qUynYec6FNoIxb1zKXsrreR4ETdNcdcgetv1FrLNF3DLbduc9F1prmoaqqnYdhodtP6VESmm6Hua5L8yjvVlrx3YRmI+9+828278d7SgycB2bLW1pc4PzqvVtbVE5sbbdefZ3EZSurS2KBGQWOzHPGut5jy2wsFvQovLa83ayWpvnXGjX7iIxA4tCvM8SfM1rbOc5DrP7wqIiT4sa23atHQEId+zIGbiBzW5M86op3uuNLrpGeV79XTRyehHW3tpgMeWL85wLs32dly26Dn623W/EErDZtXs7zd3ZiAMsphpmnvvCvOfuop9V299rYcBuxzlzWDtKE+xjsx5/jJGmaabh1tmQ4GHa3/v1PHNXbXvzCrHtdSzmCe5qbRbYtIgDcXZ8D/vs2rFt25zX2M62P0+b7fO8253n2LY2y0c/j5TO7OfzXmezaZhFOEOzfZ5XBdMscG4ec3dRl4VFzK297V/P2VqkI/2NaEfOwDWsXTSPPvooP/MzP0OMkStXrnDs2LFDbyhttCHGyGQyYTKZMBgM5hYSdM6xsbFBWZaUZXno9lrAUUqJS5cusbKysiu9cZj227Dliy++yMmTJ+eyWc/26/LlyywvL0+BXoc9EFrU/8bGBmtra3OdC6PRiJQSvV5vruFhVeXKlSscP3780De42X7Nzt3Z93GYtuc5F9r22vd88eJFjh07Nv3ZPMbWOce5c+c4efIkwFz63PbrwoULnDhxYnoxOeyz895z8eJFlpaWDp0qaMe2PVDPnz/PsWPH5hp6d85x5coVut0uZVnOdWzbubB3jsz+rojw5JNPLkRi/hvRRF8qbs9NWAsuaTdoEeGZZ57hd37nd3jb29526HDzbO3z7//+77O1tcW//+//+3M7AFSVX//1X+d1r3sdr3jFK+ZWTxxj5Od//ud529vexurq6lz6CgaU+if/5J/wD//hP5xL3nw2NPwrv/IrfPu3fzsPP/wwqnpogJ6q8thjj/HRj36UH/qhH5rLptrOhQ9+8IN0u13e/OY3z3UuXLlyhfe85z38+I//+Fz627b7hS98gU984hP80A/9EMBcwI91XfP2t7+dn/qpnzr0XJgd23PnzvFrv/Zr/OiP/ujcMAmtY/mOd7yDH/uxH6Pb7R6qvbbPAOPxmHe84x381E/91NyqmFJK/NIv/RL/0X/0H3H69Om5rbOmafiZn/kZ/v7f//tUVQXMZ19IKfF//V//Fw888ACvfe1r59bflBLvete7+MEf/EFOnz59zX2hjVC1l4lv9jLEo8jAdawoiukkWFlZYWVlZdcN/jDWHlZra2uICP1+fw49Nkspsbq6ysrKCv1+fy4bKtjiOH78OL1ej36/P7fwWYyR1dVVlpaW5p7XX1paYmVlhW63O5e2VXWhcyGEMNe50D6j1dVV+v3+XMmSBoMBx48fp9vtTtudRwpmnnOhnbvLy8vT9TBvAN3q6irLy8tzK7ttAXlra2v0+/1pROuwJYHz3hfa1EiMkWPHjtHr9eh0OnPbF9q11s7dee0Lqsry8jLLy8tTB27vnNibQvhGxMPM244iA/vYLCCm9RgnkwmXL1/m1KlTh95MWm/aOcfW1tZ00h8Wi9BajJFLly7R7XZ3hZxv1WZzoufOnZuOwbwWSNM0vPDCC5w5c2auFRsiwvnz5+n1elRVNd1QD3tgDYdDNjc3OXHixFznwsbGBt57lpaW5jYXVI0Y6MKFC5w8eXIuqO+2b8PhkK2trWm6ZB7y1rNzYR6VK23JW7smzpw5M7exBVsbzz33HKdOnZpbrX27JbftwnwYRWOMnD9/ntXVVcqynOu+8OKLL3LHHXcA88vtqyoXLlyg0+nMzRlon/0LL7zA6urqdI7tty5mcSCLqvr6RrIjZ4BrA19mwXKtU3ArC3K2nfamvZcStA1hHXTCzfZ3FtQ4D/rdtr1r3URuta97AY1tOy0p0GH665zbxa2wl9539vWu1+92Lsw6grNtzYZrb3VzmAVxzb7Orc6t2Y+z/dpbqXCr7YvILhBtezDd7NjubXO277N9PuxcmE0PzPZxFjR3K89u7zo+bH/323f2PrubGds2t92uhdl11XILzGNfmMUKzPb3MHvYbARydi+71bXWOiohhF1zYpZfYXYP3tvvG62nb0Y7ShNkayfL7GJpJ/hhvfLZw3o0Gk1Bfe33Zv/dyGajFnvzym1ev2XduxVr24cdys6WZGh2bA46Hu37bPvVfqzrelcbh+kvMK36aJnF9h4CB13Q7Yba9nsvCv+wLIHtJrWXL3+2Xze7mbaVGPuxAbbz6lbGd9YxUlW2tramKYxZh+mgKYL9HMv2mbWESy3Q81Zs9qbazrPZm93euXAYm23rVsd2dr/Z3t4GmEbybmVsZ/eBts0WeNf+/WH3hbbdEMJ0vs2O6c3sC63N0oW39NbzYHacxTRsbW2xvLw8fd29PCx7X+eb/eDfz765ERE3aS1S/Ktf/Srj8XjXRnhYu3LlCu973/v4p//0n/L5z3/+qoP8Zqw9XFNKfPWrX+W9730vH/7wh+fGtd00DY8//jjvec97+OAHP8h4PAa46mC8mf62t5WtrS0+8YlPzA2lm1JiMpnwh3/4h/zcz/0cv/7rv34oDvpZMpLz58/zG7/xG/zar/0aV65cmcvYtqHaf/Ev/gXvfOc7eeaZZ4DdN6ObsXZsi6JgMpnwxS9+kT/8wz9kfX19LvO23Uwff/xx/tE/+kdcuHDhUO3OHliPPfYYb3/727l8+fL0AD9sX0WEp59+mn/8j/8x58+fnysSfHNzk9/8zd9kc3Pz0G21c6xpmuncffHFF6+KmtyKxRh59NFH+YVf+AW+/vWvzw38llLiT//0T/nZn/1Znn322V3Rw1vdx9r5e+nSJd773vfy5JNPAgd3Kq5lrUOxsbHBu971Lv7tv/23U22Zb3Yg4K3a0ahka8v8PvCBD/AP/+E/5GMf+9hVt7dbtZQS/8//8//gnOOVr3wl/+Jf/IupB3wrHmj7d08//TS/+qu/yqlTp/hX/+pfTRfSYe3ixYv8+q//Oq94xSv4vd/7Pb785S8f6lbVhik3Njb4xV/8Rf7oj/6In//5n+eJJ544tAfejsOnP/1p/tpf+2t88pOf5MUXXwRu3dESEeq65l/9q39Fp9PhxRdf5N/9u383l1r9lBL/9t/+W44fP87a2hp/8Ad/cOiSsbZf//pf/2t++7d/m4985CN84AMfmEtuXEQoy5Jz585RFAXve9/75nbDfvrpp/nKV77C7/3e783F6W7X6ZNPPsmFCxf47d/+7anjPA8egK997Wv8s3/2z/jgBz84F8elrmsee+wxfumXfok3v/nNPPHEEzz77LO3zLfR3vofffRR/pf/5X/hO7/zO9nY2GBjY2MujuFXvvIV3v72t/MX/+Jf5MKFC5w/f366Rx6m/XPnzvHTP/3TAHQ6nauihrdirXP5sY99jH6/T1mWfOQjH2E4HC5M/Oh2t5eEMzAbWp9lnmo3ifX1dUajESEEXvnKV/Lf/rf/Lb/1W7/FpUuXDtR+0zRMJpPpJEvJFNK+9KUv8fjjjyMivOUtb+E/+A/+Ax588MFplcJsSP56/Z39NxwOeeyxxwBYW1vjR37kR3jLW97CPffcc6ANarZ/s59vbm7yqU99iuFwyPLyMm9729t405vexL333nvdhbM3PDkbtWjfw6VLl6Yh3O/5nu/hP//P/3O+7du+jeeee24XnmD2fbeWUmI8Hu8a2xgjL7zwAn/yJ39CSol7772XH/mRH+FTn/oUdV3zv//v//s1n93eOTAbtq/rmq997WtsbGwQQuCtb30rr33ta3n22Wf5/d//fR599NEbHihte22brZP5hS98gRdeeAHvPd/3fd/HI488wmc/+1k+9rGPTQ/DvXPhRmMLsLW1xWg0IsbIG97wBn7kR36EXq/H5z//eb70pS/d8Nm1qaDZtmOMPP7443zpS18CLHR7/vx53vrWt/Inf/In/K//6//KcDjct+39xrZt+7nnnuOFF14AdiIk//F//B/zO7/zO7z3ve890Ni283X2869//et8+ctfnkbGrly5wt/6W3+LT33qU/xv/9v/xmQy2dfZ2JsGmZ1j7by7ePHidK1cvHiRH/iBH+BjH/sYH//4x28YgWrnwexek1LiwoULfPzjH8c5x3333ce9997Lhz70IZ566ine/va3T53ZveOxd2zbfzFGNjc3efzxx0kpcffdd7O0tMTv/M7v8P73v593vOMdbGxsXLev19oXLl++zKc//WnquubOO+/kgQce4F//63/Nhz/8Yd7+9rdz7ty5XWmIvWM72/bef+vr68QYqaqKuq753Oc+xy/8wi/wrne9i4sXL95wLuyduzFGhsMhf/zHf8z6+jreey5dusQnPvEJxuMxn/70p3n/+99/5Ahcw14SzgBcDXprJ/DnP/95fvzHf5zf/d3fJcbIww8/zEMPPcRDDz3Ehz70IdbX128ozzk76dvF9Nhjj/Gud72LX/zFX2Q0GnH8+HHKsuTpp5/m7rvv5oknnuDcuXP7boCzi6s9pGKMjMdjfuVXfoV/8A/+AZ///OcZDAbcdddd08N8MBjwwgsv3HCyt5tmK+9b1zW/9mu/xs/8zM/wR3/0R3S7XU6dOsX29jYvvvgia2trPPXUU9eV2N37mu3i/NCHPsTf+3t/j0cffZSVlRW+9Vu/FRHh4sWLnDlzhq2trX03k9l22xB6u7Fubm7ynve8h3e+85089thjFEVBVVX8pb/0l3jHO95Bp9Ph8ccf33cc9joa7Rg0TcO/+3f/jv/6v/6v+a3f+i1SShw7doxut8uP//iP84M/+IO8//3vP/CNcHaj/uhHP8r/+D/+j7zvfe+jaRpWV1dZW1vj7/29v8cP//APT0OY17oN7X0fbbtf/epX+ft//+/zG7/xGzjnOHv2LKrKI488wnd+53fyK7/yKwyHwxv2tZ1f7Rp58sknefe7383P//zPs76+johw4cIFPvjBD+K956mnnrpmP2edu3Zcm6bhqaee4qd/+qf5uZ/7OUajEc45Ll68yGc+8xmef/55Hn300RvO2/a2186Hpml47rnn+J//5/+Zd77zndODe2tri4985COcP3+exx9/HDgYB0LbfoyRjY0NfvZnf5af/dmfnc7RK1euABbR+IVf+IWpxPD1bK+U+ObmJv/8n/9z3vnOd/Loo4/S6XT4yZ/8Sf7BP/gH/Kf/6X/KXXfdxVNPPXVDx3B2X9je3ubd7343/+gf/SOefvppjh07xo/+6I/ykz/5k/yX/+V/ifd+mo66ns0CcduD9Zd/+Zd5xzvewec+9zmWl5f5O3/n70zbbfeFtk/7Wfv9dm61c+I3fuM3+Lt/9+/y1FNPMRgM+M/+s/+Mv/bX/hr/+B//Y+q65rOf/ewN+zvrwLZz4t/8m3/Du9/9bv7P//P/JKXE6173Op5//nle+9rX8h/+h/8hX/3qVxcit/zNYC8JZ6BdPO1ib5qG9fX16Y3zh3/4h/nwhz/MhQsXpkCsv/pX/yr/8l/+S376p3+aCxcuXLf9Nmx/5coV/viP/5gnn3ySM2fO8FM/9VPcfffd/O7v/u504n7yk5/ks5/9LL/6q78KsO/hMgtmVFXOnTvHk08+SV3XfM/3fA8/8RM/wXvf+15GoxGqytNPP82lS5d4z3vew0c/+tEDjUld1zz99NN8+ctfpq5r/spf+Sv8V//Vf8UHPvABLl++jKqyvr7OhQsX+Kf/9J/yx3/8x/se2PvdCLa3t9nc3CTGyMrKCn/9r/91fuu3fovRaATApUuXeOaZZ/jkJz/Jr//6r0831fbg3w9MV9c1n/70p/nc5z6HiPDDP/zD/O2//ben49AeEh/60IfY2trigQceuOazmr0Jbm1t8cQTT7C+vs4DDzzA//Q//U989KMf5fnnnwdgZWWFyWTCH/zBH/D617/+hgCstt1Lly7x6KOPcuXKFR555BH+h//hf+Dpp5/mscceI6VEVVVsbm7yu7/7u7zuda/bt7Rpv/GeTCasr69PnZi/+Tf/Jp/5zGemB8jy8jJvfOMbcc5x4sSJG5a7tUCtzc1NPvGJT/DYY49x4sQJ/s7f+Tv8+T//5/mt3/otAF7/+tfzvd/7vfzcz/0c3/3d333N0PCs49Y0DU8++SQvvvgig8GAn/qpn6Lb7U5TLg888AAPPfQQv/zLv8w999wzxaZcb2xVrbTz85//PM899xwrKyv8xE/8BK9+9aunqbgHH3yQb/mWb+Fd73oXr3/96w90aANTJ2A8HtM0DW984xvp9/t89KMfnR6UX/ziF/mxH/sxXvWqV93wti0iU7DsF77wBT71qU8B8P3f//383b/7d/m1X/s16rpmZWWFGCMf/OAH2djY4J577tk3kjG7L6SUeP7553n66adRVd761rfyQz/0Q9MU5L333ov3ns9+9rPUdT0t+7vR+E4mEx5//HG++tWvAvA3/sbf4G1vexu/+Zu/yfb2NqdOncJ7zx/+4R8yGo2mDuhe52W/qMbW1tbUsbrzzjv5y3/5L/Obv/mbjEYjXve61/HqV7+aK1eu0DTNlNHxemPbrsWvf/3r/NEf/RGXLl3ijW98I//9f//f88lPfpKnnnqKs2fP8rf/9t/m3e9+N//8n/9zvuM7vmMuZZXfjPaSKC2cdQYmkwnvec97ePzxx3nggQf4m3/zb9Lv93nf+97HcDjkh3/4h/He83//3/83X/nKV/gbf+Nv3LCevA3f/+Iv/iJlWfLEE0/w1re+le/6ru/iueee45/8k3/CT/zET1BVFb/3e7/HiRMneNOb3oT3fop4np2cs2HgP/3TP+V973sfIQTOnj3Lj/zIj+Cc47/77/473vzmN/OGN7yBp556in/5L/8lf+tv/S0efvjh66Jw2+jF5z//ef6P/+P/YDAY0Ol0+NEf/VG89/zyL/8yp0+f5k1vehPD4ZD3vve9/MAP/ABnz56d9nVv+7NT6MKFC7zrXe9ic3OTv/AX/gLf933fR9M0/PzP/zzf/u3fzlve8haefPJJ/pv/5r/h+7//+/nLf/kvMxgMdrW1tySsaRo+8IEP7ApX/if/yX9CCIGf/umf5i1veQsPPvggW1tbfPnLX+ZNb3rTFDnc6rfvnQtgucp3vetdUyfxx37sx1hdXeX9738/X/7yl3nb295GSonf/u3f5r777uMNb3jDDYmGWkfg537u51heXua5557jJ3/yJ7njjjv48Ic/zMc+9rH/f3tnHhd19f3/1wDDsAqCgMimCQjIjhiigoIiLpmIopkfU0sriy9Ztqn16fEps/LzMS1LzU+We5pkKmGGoaJobAIqm8q+7/sMszD394fd+3vPCC7pbzHu8/HgQSTcuXPmvM8999xzzsWyZcugq6uLs2fPYvjw4fDz82O5Kdq1+nRRoMlm+/fvR35+PoYOHYply5bBxMQEx48fR0VFBV566SUAYA5SdHQ0rK2t76oL1HnZvn07gNvn4mFhYYiIiEBrays+/PBDvPLKKzA2Noadnd0dOz2hLghD7j09Pdi7dy+qq6shlUrx7LPPwtvbG6Wlpdi6dSvWr18PsVgMc3Nz5vTSRMj+oIvV999/j/r6ejQ2NiI6OhoTJkxATU0NtmzZghdeeAGWlpYYMmQIe47EYjFbzIXPsVC2arUaly9fxokTJ6Cvr4/Fixdj5MiRuHXrFv773//izTffhLGxMcRiMfT09CCVSllDoP6genbu3DmcO3cOEokEBgYGWLFiBSQSCTZv3gxvb294eXlBLpcjJycH48ePh4WFBWtgJCyHFB5xXbhwAadPnwYhBN7e3oiJiYFKpcK6deuwaNEiDB8+HDU1NUhNTcWsWbNgZ2d31zwP+pxdvnwZCQkJEIvFsLe3x/Lly6FQKLB161aMGTMGvr6+aG5uRnp6OiZNmqQxrvb4QrtQXV2NHTt2QC6XY8qUKZg8eTLkcjk+/vhjPP300/Dz80N5eTkOHDiA8ePHY9KkSXe9Kp3Ktr6+Hv/5z3/wxBNP4NatW4iNjYWDgwPOnDmD7OxsPPPMMzAzM4NUKoVSqbxjvhwB5G+IWq0mSqWSKBQK9qVUKolKpSI3btwg69atIy0tLeTzzz8n+/fvJ0qlktTV1ZGXX36ZrF27lly5coUolUrS29tLent7iVqt1hi/t7eXKJVKIpfLSV1dHWltbSVNTU0kLi6OdHZ2kuvXr5M33niD1NXVke7ubvLhhx+SmJgYkpKSQhQKBRuTfvX29hKVSsW+y+Vy0tHRQZRKJdm9ezdJTEwkra2t5O233yaXL18mCoWCZGVlkcjISPKvf/2LtLa2sjlpz1etVhOFQkFUKhXp7u4mjY2NRC6Xk8OHD5NDhw6Rrq4usmHDBvLbb78RlUpFrl69SiIjI8natWtJW1ubxny1v9M5C+Xx22+/kV27dpGamhry1ltvkT/++IMolUqSk5NDli5dSj766CNSXFxMmpub2d8LZUE/O6VSSVpaWkh9fT2Ry+Vk48aNJCMjg7S2tpL169eT1NRUIpfLyalTp8j06dPJjh07iFQqvUOmdDz6s1KpJO3t7UShUJBr166Rjz76iHR2dpL9+/eTr776ivT09JDGxkayYMEC8uqrr5KioiI2Bh1bWxeoftXX1xOpVEqKiorIu+++S6RSKTlx4gT59NNPiUKhIC0tLWTJkiXk+eefJ9evX2c6SccVylP4ReddVVVF3nzzTdLU1ES+/fZb8vXXXxOFQkHa29tJbGwsWbt2LTl//jxpb2/XGFuoC3RMhUJBGhoaSGNjI2lvbyevv/46aWhoICUlJSQ2NpZUVlaSnp4e8vnnn5O5c+eSkydP3jE/oVxUKhVRqVSkq6uLyGQy0traSlavXk1aWlpIZmYm+Z//+R/S1dVF5HI5+fDDD8mCBQtIQkKChj5py1atVhO5XE7UajWbp0wmI6tXrybl5eWkuLiYvPrqq6ShoYHI5XKyefNmEhUVRY4cOcJkJpyr8L+1dbezs5OsXbuWFBcXk0uXLpHVq1eT9vZ2IpfLyZdffkni4uLInj17iEwmY7rely7Q8drb20ltbS2RyWRk27Zt5OzZs6Sjo4N88MEH5MyZM0SpVJILFy6QqVOnks2bNzPdFT4TQpugUqlIT08P6ezsJAqFgmzatImkpaWR+vp6EhsbSwoKCohSqSRJSUlkxowZ5D//+Q/p7u7uV77ULvT29pKOjg7S1NRE5HI5+eqrr0hSUhKzN5mZmUSlUpHz58+TadOmkQ0bNhCZTMb+Vlu+/dmFAwcOkGPHjpGKigoSGxtL8vPziVKpJCkpKeT5558nn376KampqSGdnZ3s77V1gcpCJpOR6upq0tnZSdLS0simTZtIT08P+fHHH8nmzZuJTCYjdXV1JCoqirz22muksrJSY2596RqHkL9tnwHyp8dPQ7xZWVlwd3eHj48PpFIpC7F+/PHHmDZtGmpqaqCjo4OwsDCMHj36rp3aaHJRfHw88vPzIZfL8fLLL8PS0hJZWVkYM2YMrKysUFxcDDs7O1haWuKzzz6Dra2tRumacDz6vbS0FD/++CPa2towefJkODg44PLly5g4cSKeeuopJCcnw9/fH0VFRViyZAmeeuop1p2rP09XR0cHJSUlOHLkCNrb2zFmzBjY29vjt99+w7Rp0/D000/jxx9/RHBwMPLz87F06VLMmDFDo4Uv/SKCnRRwO4EtKSkJpaWlCAoKgoGBAerr6zF48GAsWLAA8fHx8Pb2RkVFBQYPHoxZs2axMGhfNb5055OWloYTJ05AqVRi6tSp8PLyQkpKCtzc3BASEoLMzEx4eXmhrq4O7733Hvz9/aGnp8d2mH31YGhvb0d8fDyKi4thb2+PWbNmobq6Gm1tbZgyZQo2btyI7u5ulJWV4cknn0RMTAxsbW1ZuLc/Pevq6sKhQ4dQVVWFQYMGYeHChZDJZKirq8OECROQnJyM1tZW1NbWwtvbG88884xGZzntGm1holhmZib++OMP2NraYsKECVAqlZDL5Zg7dy7ee+891NfXM32eMGECAgICoK+vf0dTK+F8aaQlLS0NHR0dePXVV2Fvb4/MzExMnjwZLi4uyMvLg7+/PwwNDfHpp5/C0dFRQw+EslX/Wd559uxZXLhwAfr6+li2bBkMDAyQn58PPz8/WFlZIS8vj4Wv33nnHXh5eWm8775kCwAJCQlIT09HT08PVqxYARsbG+Tn5yM0NBQjRoxAQUEBvLy8IJPJ8P7778PDw4PpQV9tZqnulpeXs6qL2bNnw8jICLW1tQgICEBqaiquXLkCb29vNDQ0wN3dHdOmTWORm/7mrFarce3aNRw9ehRSqRQhISHw9PREamoqxo0bh7CwMFy4cAHBwcGorKzEe++9h8DAQBYRETbFod8JuX0PxE8//YTu7m7Mnj0bDg4OyMjIgKenJyIiInDu3DkMHz4cJSUlePHFFzF16lQYGBjctWJJR0cH165dY+WSU6ZMgZOTE65evYqgoCDMnDkTKSkp8PDwQFFREWJjYzF58mSNaGZfugDcLqVOTExEXV0dwsPDYWJigoqKCsyYMQNPP/00EhISEBsbi/LyclhbW+Opp56659EAIbcvRNqzZw9aW1thZGSEZcuWoaKiAm1tbQgJCcFHH32Ezs5OFBcXY8GCBYiMjGT28a/2hBgo/G3jJPTDv3nzJq5evYqIiAicPXsWhBA4OTnhl19+YQ90b28vOy8OCQm5Z/iI1q8CYEatpKQE8+bNw+HDh5GRkYGuri6YmZnB3t4eK1euhKOjIyuxI+TOs0D6munp6Zg2bRqWLl2K1NRUBAYGoqurC0lJSejq6oKBgQF0dXURFRWF+fPn31cv8N7eXhQUFCAyMhJxcXHIzc2Fi4sL9PX1ER8fj6amJmaMoqOjER0dzRyBvsYWGqoLFy6gra0NwcHBOHr0KFxcXNDZ2Yn09HR23q6jo4Pg4GB8+OGHcHd3Z0aaGjrha9BweFlZGVatWoUlS5YgJycHEyZMQH19PU6ePIny8nJYWlrC2NgYixcvRlBQEFus+0q8ogbgxo0bsLCwwJtvvomysjKIxWKMGTMGR44cQW1tLQsBe3l5ITY2FjY2NvcsJSSEoKKiAsOGDcM777yDnp4eqFQqjB8/Hrt370ZpaSlrzuLh4YG4uDgWur+bbEUiEUpLS5GSkoKwsDDk5OSgubkZXl5e+PnnnwEAJiYmkMvlGDZsGD766COEhYXBwMBAo+ua9muQP0P4zc3NeOuttxAeHo7s7GxER0cjMTERFy9eRGdnJwYNGgQLCwssX74cw4cP77cPAnVu29raUFFRgTVr1sDGxga3bt3CnDlzcPToUVaaKpFIYGFhwc7476W3RJC3EhcXhzFjxiAvLw+zZs3CqVOnkJmZyRZ9Y2NjvPXWW/D09Lwvg9/V1YWffvoJPj4+kEgkSE5OxtSpU3H8+HG0trbCxsYGbW1tMDY2RmxsLJYuXQpLS0uNLn59yVatVqOgoADLly/Hyy+/jIyMDAQEBEChUODIkSOoqqqChYUF9PX1ERMTw/I7tJ8DqgNU7unp6YiJicHcuXNx6dIlhIWF4ebNm7hw4QKkUikMDAwgFouxZMkSzJgx475aI9O+FAsWLMDzzz+PjIwMBAYGorm5GYmJiWhvb2fHFcuWLcO0adPYefvdPjuayKenpwc/Pz/88MMPCAwMxK1bt3D9+nUMGTIE3d3d0NXVRWRkJNavX4+RI0f22eVTW7bFxcUYM2YM1q1bh/b2dhBCEBISgm+++QaFhYUwMjKCvr4+goKCMHfuXHb3wL2eY87ftAOhcEfk6OiI559/Hvr6+hg8eDD09fXxzDPPYOfOndi0aRP8/Pxgbm7OEql6Bd2w7ja+paUlYmJioKuri56eHtjZ2cHV1RUvvPAC0tLSMG7cOKbgfT3o2uNRJ2HWrFkwNjZGUVERjI2NYWRkhNjYWBw+fBhKpRIxMTEA/ncy0f30g9fR0cG0adMgFotRXV0NAwMDmJiYYOXKlTh+/Dj++OMPxMTEsJJHmox3rz4IIpEIgYGBMDExYY6Kubk5li1bhm+//RYikQhTpkyBrq4uu/kLuHtrXEIIxGIx5s2bx7KgHRwcYGJigri4OCQlJUEkEmHGjBlsIRDuSvqaL/nzXHz06NHw9/eHXC6Hnp4eJBIJYmJicOzYMRw/fhyzZ89mTpBKpbrrmaVQBu7u7vD09GSZ+4MGDcL06dMhkUhw+vRpREZGsj7otOMecO9ucLa2tli5ciW7VMXAwABRUVHYvXs3NmzYAEdHR9ja2kJfX58ZPaprd5OvoaEhlixZwqIlzs7OGDp0KF588UWkpKSwCJrQgFJ9054zTRYcPHgwlixZwhwfY2Nj+Pr6oru7G8eOHcOoUaPg4uLCZHs/3eVEIhHMzMzw7LPPgvZ+sLa2houLC5YuXYrff/8dlpaW8Pb2Zou0cLHuKypCMTQ0xOLFi2FpaYm2tjZ0d3fDx8cHVVVV+Oyzz2BiYoJVq1ZBV1eXXSZGZUsb7fQlY0II5s+fD0II8vLy2OezatUqJCQksKgOlS3dCPT+2T5Yeyxqy+bPnw8jIyOkp6fD1NQU5ubmePXVV3H06FHo6+tj4cKFGk76/ThEYrEYUVFR0NPTQ35+PoyNjWFmZoZVq1bh559/hlwux4IFC9hnJXRU72UXwsLCYG5ujpqaGhgYGMDKygrPPfcc9u/fD11dXcyZMwcikQjm5uYa0QX6OtqypfoXGBgIQgjkcjm7s2DmzJkQi8XIzc3Fs88+C0NDQ2bHad7Io7iT4+/OY5lAqD1lughQRZLL5WhsbGQZtDo6Oujo6MCmTZvw4osvoqenB8OHD4dCodBo/wloZpvT1pv5+fnw8fFBS0sLu/wHuG3MpVIpPv74Y8yePRulpaWIiopi13hSJaeKKXy4hX0GKisrIRaLYWtry97LqVOnoFQqYWRkhNGjR2PYsGEaD4rQ4aFlacJko97eXpSXl8PGxgZGRkbMUJ4/fx5VVVUwNTWFm5sbnJ2d+0z8EcpAKBO6gNDSOzqPGzduICkpCbNmzYKOjg6sra2hUChgamrKxtRONNPR0UFWVhbc3NygUqmgVCqZY0ZltHPnTjg4OKC5uRnh4eEsbE/H0t4BC401IYRVC3h5eTE51dTU4NChQwgNDYWOjg78/Pw0DLxwrkJjIjwiaWpqgkKhgJ2dHTPkdXV12L17N8LCwtDd3Y1JkyYxo6wtX+GCRedOyzybm5s1Ln2Ry+X45JNPsGLFCrS0tMDV1RVyuRxGRkZsXnRcoQ6o1WpkZmbCz8+P7cQGDRrE9FEmk2Hz5s2YNGkSysrKMG/ePBZaFr5XOq62E6dUKnH16lX4+voyuff09ODf//43oqKiUF1djcmTJ7OWuMIQOH0N4SJI/59UKkVVVRVcXFw0fvff//43Jk2ahNLSUuY09yVb7UWLvo5IJEJNTY3GpUJqtRq7du1CcHAw1Go1XFxcmM3Q3lVqH5Xl5ORgxIgREIvF6OrqgrW1tcaR39GjRyEWiyGVSjF58mTY29trzFfobPVlF27evAkrKyt2XTgAHDhwAPb29ujp6UFgYCAsLS37nFt/doH20nByctJoJ3zs2DHo6upCoVBg3LhxzN48iF1obm6Gvr4+Bg0axH4/LS0NJSUlGDt2LHNiqF2g+tWXXauqqoJcLoejoyO7ZEtoQ2/cuIFffvkFbm5usLCwQHBwsIYOactCW084d/LYuktUiYTKRLv6VVdX44cffsBbb73FjFhJSQlqa2vx9ddfY86cOXB2dmY7P+EiTR9EOrZKpcKePXswduxYVvu6aNEidt7Z3NyMK1euwMTEBDExMX1WB9A50HnTnVFPTw+MjIxYl6wZM2awhSctLQ0VFRUICwtDcHDwHT3KhQ84/U7Hra2tRXx8PM6fP4/58+dj3rx5AG4bh5ycHFy5cgXTpk1jd3n3dfYnlAug2bM/MzMTjY2NWLBgAfvb7OxsFBQUoKGhAUuWLIFEImHeuPbiSo2eWq3GhQsXkJ6ejrq6OnR2dmLChAmYPXs29PT0oFKpkJGRgYKCAkRHR2PIkCF3nNfSfgl0PKVSCV1dXcjlckgkEtTU1CAhIQFubm4ghEBPTw/Xrl1DamoqAGjsfIRjChHKtru7G0ePHkVOTg5EIhE2btzIXru8vByXLl2CoaEhoqOj75Atff/CSAbdyVJZNzU1YdeuXVi/fj2bV2VlJUpLS7Ft2zaEh4fD3d2dnYMKFz7quFDDSuu5b968idzcXBBCMHfuXAQFBQEA5HI50tPTWcRJeMYsfBZoxIzqAH0NhUKB+Ph4jBw5kl1p3dTUhPT0dMhkMsyZM+eOrPi+5CF8Rs6dO4e0tDRcvnwZ27dvx9ChQwEAHR0dSE9PR2trK6Kiothi3ld1AP2ijhLtTyGXy/Htt99ixYoVGDp0KHO0cnNzUVlZiREjRsDFxYU5z0JdpWMIQ/e5ubk4f/48mpub0dXVBX9/f6ZPOjo6yMjIgFQqxdy5c2FjY3PX54zKl9oFQ0NDnD17Fj4+Phg7diz7/bS0NFy8eBEREREwMTG5w3nVrj4QOkLFxcVISEhAcnIyVq9ejdDQUPY5ZmZmoqmpCTNmzIC5ubnGgq9tC4TfhTqRnJwMMzMzREREALi9WcrMzERxcTFKSkqwfPlyZhfoGNrN1+jrtra2Yt++fXBwcEBpaSksLS3x4osvwsLCgpV4Xr58GZaWlhg/fryGbLW/c+6Px9YZECo/VcqEhAQYGBggMDAQHR0d6Orq0lDsyZMnY8aMGcybpuPQf6cPvFBB9fT0EB0djU8//RS7du1CSUkJfvrpJ4waNYqdgW7atAkuLi7MQPXlkVIDQh/W7u5u7Ny5E76+vhg6dCg7V6W/GxkZCXt7e9jb29+xo+oL2sRFIpEgMTERw4YNw9q1a7Fr1y6MGzcOdnZ2LHwXFRXFfu4L7V0KcHvhOHjwIEs+pN3/6Pm0qakpZs6cidDQUJbHoH1jmNAhoDvThQsXYuXKlYiLi4Orqyu2bNmCgIAA1vnwtddeg729PczMzPrMtwDAFlThIpaYmIimpiY89dRTrHac7vRGjhyJDz74AKNHj9ZwCPuTBXUuWltbUVlZiZKSErz22mvYtm0bUlNTERISAgCws7PDxo0b4ebm1u9nph0hoWH28+fPo7OzE2FhYZDL5ejo6GBXAxNy+1x01qxZsLKy0oh+0HHoDpDKgTa/iomJwbp16/DVV19BoVBg79698PT0hKmpKYyMjPDRRx9h1KhR/R4DCF+HyjYvLw8nT57Ec889ByMjI7S2trIIkImJCdasWYMxY8b0ee2s9vunr1dXVwcjIyOcOHECcXFxsLS0xJEjR7Bq1SqIxWKIxWK89dZb8PDwYJE57c9MOLZIJGINaaqqqpCYmIiYmBhYWlqiuroaNjY27G+8vLxY4iT9W+GiKhKJmENEF0WFQoGZM2filVdewfz58xEeHo5NmzahuLgYrq6uUKvVeOGFFzB06NA+o2NCeVI5qNVqtLa2YseOHQgLC8PQoUNRW1ur8Z7mz58PV1dX2NjY3PMogL6PxsZGGBsb49ixYwgMDIS/vz9L7B08eDB0dHQQHR0NOzu7+6rvF25uuru7sXfvXkybNg0ODg7M6aTyt7KygqenJ8aNG8ciEdrRLO2oRk9PD9zc3GBubo7i4mJs3LgRBw4cQHJyMnOyg4KC4OfnBwcHB+a48eTAh+OxdgYIud0i9PTp0+jp6UFAQABOnDiB6upq1qKTOgOjR4+Gp6cnRKLbFQbajSeo0b116xYLTe3ZswcikQhPPvkkPD09UVRUBE9PT8THx7M5GBsbY/To0RoRBW1ogxi1Wo3Tp08jNzcXrq6u+Mc//oEDBw6gq6tLw5gDQFBQ0B3eeH+LNzX+Fy9eRENDA8RiMXp6ejBq1CgMGTIE8fHxeOWVVyASieDh4QHgdoi3v+Ybwoe5qqoKv/76KywsLODj44NDhw4hICAALS0tUCqVbAc/bdq0OzKhhTteGqIVi8UwNjbGvn370NzcDEdHR8yfPx/Z2dkYN24cBg0axC6C0dPTg6enp8aOt6+50lbS165dw+nTpyGRSLBw4UJcuHABu3btQmNjIxQKBXMGnJ2d2fsTLnR9oaOjA6VSidraWuzYsQPR0dFQKpWwsLDAxIkTsWfPHvj7+7M6fFtbW9Zbva8zZWHYuru7G4mJiejs7MTYsWORnZ2Nuro66Ovrs86PhBCMGDGCzVn42VDDTH8uKyuDlZUVOjs7ceDAASgUCvj6+mLixIm4evUqwsLC0NPTwzrXSSQSeHl5aRwHaNPT0wOxWIyGhgYcPXoU7e3tePrppxEREYFvvvkG3d3daGxshJOTE0Si22f8ISEhd/R/70u+dN4qlQpbt27FwoUL2b9FREQgLi4OU6ZMgYeHBwwNDeHv78+cp/6aNNGdqlKpxKVLl3D9+nX4+flhyJAh2LJlC8u49/f3Z30dXnzxRbYYA5q36FGHuKmpCSqVCqampoiPj0dlZSWsra2xePFipKenIzIyEkOGDGEXOenq6sLNzU3j89aGNkNSKpU4ceIEioqK4O/vjyVLlmDfvn1QKBQayaYikQgTJ068I6pwtx2wSqVCQkICzMzMoKenB7lcjnHjxuHw4cP49ddfWXTPx8cHwO2kQnrMqQ19XZVKhVu3buH333+Ho6MjfH19sXPnTjz55JOora1lvR3kcjnmz5+vsakQRizo/5fJZKiuroaTkxMuXbqE8+fPQyKRYOrUqdi5cycaGxvh6uqKrKws9l7vp4kS58F4LKoJaJiWLqg1NTXYu3cvVCoVTp48CaVSiUGDBuHQoUN46aWXoFQqkZWVhe7ubmY0aaa4rq5un4tgU1MTvvrqKyQmJkKlUiExMRGenp5QKpUoLS3Fc889x6IDQUFBGmPQ5EPh1cHUyLW3t2Pt2rVITk5GU1MTurq64OXlhYMHD+LmzZt4+eWX8cQTT6C4uJi1aQXAxqNGTzhfOieZTAalUonvvvsO169fx8SJE5GTk4NRo0bhypUr2LJlC3R1dVFUVITOzk7WgEdXV5clygmjINSAX7t2DYmJiWwn6ezsjIaGBmRlZSE2NhZ5eXkoLCxkhkgikbCQNl0Eha+lUqlw5MgR7NixAz09PcjNzUVvby9sbW2Rk5ODiIgI5Obm4uOPP4ZEIoGTk5NGWFkoCxrBoefre/fuxRdffAGpVMqMaV5eHg4ePIjZs2dj+vTpqKurQ0tLCzOqNIxLQ9jaO/eqqiq0trZCqVTi8uXLOHr0KGxtbWFlZYWKigpYWFjgs88+Q1ZWFoyNjXHr1i32/vX09FjFhzBhksq2ubkZu3fvZo5hV1cXhg4div3797NyvNTUVKYL9KpYbblSXaP5C9988w0OHz4MhUKB5ORkODo6QldXFwUFBVi4cCF27dqFrVu3wsPDA6ampixqI9Q3Oh6V7ZUrV7BmzRo0NDQgPz8fTzzxBHR0dLB582a4u7tjxYoVkMvlKCsrYwupULbC7HAqY9p9kjpYn3/+OQghmDp1Kn7++WdMnToVX3zxBfbt2wc3NzdcunSJjSMWi6Gvr69x9EB1gZDbx4QHDhxAbW0tysrKcObMGfj6+uLHH3+Ep6cnwsPDkZycjMbGRjamRCK5QwZUz6ijefLkSWzZsgWtra0oKSlBQ0MDHB0dkZOTAz8/PzQ1NeG9996DVCrFqFGj7sivoJ+j0C40Nzfj9ddfR2ZmJqqrqyESieDq6oqdO3eitbUVsbGxsLa2xs2bN1lFjvBZ6CsXRS6Xo7S0FHK5HDKZDNu2bUNlZSUiIiKQlJSE8ePHIzExEV999RWsrKyQmZnJxqZj3s0uXLx4EampqZBKpdi7dy98fX1x/fp11NbW4qWXXmL5AXROBgYGGvOmryN0YLOzs7Fx40bk5eVBJpMhOTkZAQEBuHXrFouIvfHGG/j9998REhLSp+PzsNeKc27z2Eiwt7cXhYWFqKyshJmZGXJzc3H16lU0NjZi+PDhLHGtra0Nzz//PLZu3XpHbbS2YaIQQnD69GnIZDI899xzKCgoQFdXF44fP47IyEhMnDgRarUaa9euxcqVK7Fw4cI76o2FCyEANDQ0sNabTU1NSExMhJ6eHp544glcvXoVS5cuxffffw+5XM7C9lKpVCNs1t+86+rqsG7dOuzbt485F4cOHYKenh6CgoLw888/44033sDEiRPh5eUFa2trZvSEiWvUoNCLlnJzc9HU1ARLS0ucPHkS9fX16OrqgqurKxYuXIiCggKYm5vjjTfeYAs3hT7swt0q/SosLERSUhLi4uLQ1NSEzs5OJCYmwszMDGvWrEFhYSHeffddLFq0CGvWrGEJSMLwqFDWnZ2d7MY0epacn5+PkJAQnD9/Hs888wwuX76MwsJC+Pv7Y/r06WzHdjfZ0hDll19+ic2bN6O8vBxOTk6sPfGMGTNw8OBBzJ8/H3PnzsXYsWNhbGzMchmE599Cg9f75z0CxcXFMDIyQklJCdLS0tDc3Ixhw4Zh1qxZMDU1RVVVFf7xj39gy5YtLHlOezxtXSCE4PLly6ioqMDKlStRXFyM9vZ2HD9+HOPHj0dUVBSam5uxbt06vPDCC1i+fLnGTo2OT8dUKpXs5jy60P/6668ICAhAcXExnJ2dMXjwYHYUtXTpUjQ1Nd0RBehvrqdOncK6devwxx9/sM/57NmzePLJJ3Hjxg2YmJiwVsgWFhZwcHDQeE6pLISZ4s3NzcjNzYVKpYJEIkF8fDxaW1thbGyMoKAgTJ06FZcvX0ZoaCg2bNiAuXPnauxOhbqr/VVVVYWffvqJbTIaGxtx5swZ6OnpYf369SgsLMQbb7yBxYsXY82aNSyaoy1bKvO6ujrWPrupqQnHjx+HhYUFzM3NUVlZiXnz5rGIJO2OSq9Tv5ddKC4uxjvvvIOjR49CqVTC3d0dBw8ehLm5OZydnXHx4kW8/fbbCAoKgqurK2xtbdlCKrQL9DlTqVSQyWTIzs5Ge3s7hgwZgsOHD6O1tRVyuRweHh5YtGgR0tLSMHz4cLz77rtYt26dxsJ8N7sgk8mwZ88ehIaGwsfHB7du3UJhYSGys7Oxfv169PT0YNKkSVi5ciXefPNN+Pr6aiRdaj8XnIfjsXEG1Go1tm7ditjYWCQmJmLOnDk4ePAgAgMDkZCQgN9//x1qtRomJibQ09ODm5sbS4i6FyKRCBERESgvL8cHH3yAlpYWzJw5E4MGDUJKSgoOHToEY2NjhISEwMrK6p5jtrS04O2338ann36K1tZWuLm5wcnJifX97+npQUVFBWtiUl9fD1tbW5iamvYbrhViaGgIT09PDB48GNu3b8eQIUNgbW2Nb775BjU1NfDz82M9DhoaGrBs2TJWbtPXuZqOjg5bMNauXYtbt24hNDQUJ06cgL+/P77//nukpqbCysoK+vr6MDExYccN91O/6+bmBldXV7zzzjvIysqCr68vAgICUFhYiB07dkCtVsPNzQ0eHh4a9dF9yVmpVGLPnj1YtWoVrl69Cjs7O4SGhuLkyZPo6upCY2MjiouLERoaisGDB7OLa+iici/Z6unpwdraGiEhIdizZw/Ky8sxc+ZMfPHFF0hJScHkyZMhkUgwcuRIVFVVYd68ebC3t++3XFJHR4clrr3yyis4ceIE5s6diyNHjsDf3x/Jyck4deoUZDIZrKysoKurCw8PD5Z3ca/5AkBwcDC6u7vx/vvvs8Yu1tbWSEtLw549e2BoaIigoCDY2tqyxa+v8DIhBOnp6XjuueeYszZu3Djk5eWhsrISlZWV6OzshI2NDVxdXSESiVBSUgIfHx+NMHt/iEQiVnaZkpKChIQEzJkzBwkJCYiPj4eHhwfMzMwwfPhw9PT0wNXVFaGhoRp/rz1e758XQa1cuRJff/01vL292eVEUqkUP/zwAwoKCjBixAiIRCI4OjqyxNn7ka2DgwN8fX3xz3/+EykpKXB1dcXkyZNRXFyMb775BlKpFI6OjvDz82PREEAz14JSW1uLV155Bdu2bYNcLme5GykpKWhsbGS3Q076swqlvLwczs7OMDQ0vK/nzNjYGIGBgVAoFPjvf/+LUaNGseieXC6Hq6sra9UslUpZS+/+yqmpM7R69Wr861//QmdnJzw8PHDhwgWMGjUK3377LdLS0uDg4ABdXV2Ym5tj1KhRzEm7F4aGhpg9eza+//57fPvttxCLxVi8eDHa2trwww8/IDs7G2ZmZggPD2dVX0LHivNoeSxKC2kI8NKlS/jpp5/g4uKCmpoalJaWYtGiRXBwcEBBQQH8/f3h7OyskQXcXzRACA2LJiYmIi8vD2vWrIFYLEZ9fT1aWlpgb2/PetL3V9sv/FmhUODQoUP4448/YGNjg/b2dsycORMJCQlYtmwZGhoaYGpqCl9fX41sYGF5W39hL5q89OGHH8LDwwMnT56EtbU15s2bh+bmZjg4OMDT01OjH7tIdDunoK8jB3qeSQjBoUOHWJOcrq4uFBYW4v3330dHRwfrpkcTr6hjIdxJ9DdflUqFwsJCfP311/jnP/8JKysrtLe3s4tmaKa1sB5YOEfhf6vVamRnZ2Pbtm2sVGv48OFobm6Gs7MzK0MMCgpiiWZqtRr6+vpsAbhbzXFvby++++47SCQSXLp0CQqFgp0HK5VKBAcHa9T001C1MGwrnC89K87KysKePXvg7e2N4uJi1NfXIywsDIGBgcjNzYWHhwdGjx7N5CBcVO4mWxrGvXDhApKSkvDuu+/CwMAALS0taGlpgbW1NczMzFgCnHA87c+OEMLulh80aBAkEgm6u7sRFBSEvLw8zJs3D0VFRfDz82N6QGUrPCbo71kjhCArKwu///47VCoVrl27hrFjx2LixIkoLy/HhAkT2D0gdK7C6EhfukCPXjZs2ABvb28UFRVBrb7dEXHNmjXIzMyEqakpJkyYoKEDwl3l3XSBkNsXgX3yySd45513YGdnh66uLtTX18PY2Bg2NjYQi8WsokU4nvbPcrkc27dvR0lJCYYMGYKmpibMnTsXx44dw0svvYSysjIMHToUHh4e7EiLzvN+7EJnZyc++eQTuLq64tSpU3ByckJ0dDQqKyvh4eEBZ2dntvgLjzPvZhdUKhV27NgBpVKJ7u5uKBQK3LhxAxs3bkRZWRk6OjqY403HE0YD+oPqrlQqxWeffcYiOAqFAvX19VCpVLC3t9dwioVJnffTp4LzYDw2CYS6uroYO3YsLl26BBcXFwQHB2Pfvn0secfHx4cph3aTjHtBd0uhoaHIyMjA9evXERAQgGHDhrG6dkAz+1k4vrZS6unpISIiAnl5eQgJCcGvv/4KGxsbzJw5E/r6+ggPD+9zV3a/yk3DuXV1ddi6dSuampogk8k0am2FxwB0Tnd7/4QQTJ8+HR9//DGWLVuG5uZmlJaWIi8vD8888wx7v3SOwgfzfubr6uoKX19fJCYmYunSpRg8eDAzIHSc+5GtSCTC6NGj4e3tzZwKfX19zJkzB2VlZaxngBBhiPVeEHK7odSvv/6K119/HWZmZigoKGDZ0H2NczfZ0t/18fHBiBEjMGTIEISEhGD37t3Izs7GokWL4O7urvE3DypbXV1dBAUF4eLFi8jIyEBoaCisrKzYgq193KI9NyEWFhaYOXMmMjIy4Ofnh9TUVIwfP571VHB1db1DXgA0Prv+IITA3NwcaWlpWL16NWJjY5GVlQUnJycEBARofE59LVB9vXeRSMTmnJ6ejtjYWPzyyy84deoUdHR0EBUVxV5be7G7FzR8bm9vj/DwcBw/fhwvvfQSBg0aBDMzM42FmWbKC2WtjVgsxlNPPYXt27cjNDQUx44dg5OTE8LDw2FoaIjIyMg+ZXa3MYXo6uqiqakJLi4u2L59O8rLy6Gvr8+ORbRlC9zbLojFYsyZMwdbtmzBq6++isLCQhQUFKCsrAxTpky5Y44PenZvZGSEBQsWYPfu3QgMDMTgwYNZx0vhe34QOXD+Go9FZEBYg5qfn4/du3fj3XffZbXNtAXrw4xPxVBUVARzc3MMGzbsL49HveqkpCRkZWUhLi4OBgYGAP638f6rCk096t27d8PFxQUTJky44yF50DM0Ybbzb7/9hpycHMTFxaG3txf6+vqQSCQPPV/gdh5Fc3Mz2wE/zHjl5eXYtm0bYmNjYW9vf8d58l9FrVbj6tWrOHPmDLsLntLX7vR+5wsApaWl+OKLL7B27VrW/OdetyDez9g0mlBcXAyJRMLKRoXRsQcZr7u7G1u2bMH48eOZftFd+sPqbltbGzZs2IAPPviARVgAaOx+H2Q8Oueenh588skniIyMxJgxYyCTyTBo0KCHKjcT9gZpaWlBTU0N3N3dNRyVB5kvjeIcPXoUDQ0NWLFiBXMwgbtHVe4FjcBt3rwZM2bMgLu7+yOzC4QQHD58GB0dHVi+fDkr0xXO/UERylapVOLatWtwd3dnCYzAvTt0ch4tj4UzICxHUavVyMnJgaurq8bVtw+jOMLzQ+oY3E9v73uN19nZibNnzyIiIgISiUQjTP2wC0BVVRV0dXU1OvIJd9MPMj59zzRp7ObNmxg9ejRbAB7FfOkuq7e396GMCJVhb28vzp07B1dXV3ZcQF/nYReA7u5ulJeXs9Iw4RnlXzGo9AxVrVYjPz8fI0eO1Mja/qvOCx2bLqLUsNKw/f2EwrWh4xUWFqK9vR1jx45lzsajcGRVKhXy8vLg5ubWpx48qDNA50ufCT09PY1o3sNsEuh86XOgUCg0Kg0e9LOjutvS0oJLly6xnKFHZRd6e3tRWloKc3NzWFhYPFK70NXVhaqqKuZkPIr5Cltz0zJLsViscdTA+b/HY+MMUGMkNK7CsNfDhI6owlPlowvWw44nEmnWg9N/A/66kRLuNGmjDe0Q6F956Ol34XEAXQQedgEQ3nVAzygf1rkQOm/CBY/WOP9VhIuLdsMd+v1BnQHhZyY8C34UstXWBWG+jDCv425j9DWmSHTnHQKPwpET1ttrl+D9VdkKz5SFuQYPunPXRrgYChto0Xk/6Pj3sgvaR3sPQn+6oB3N+ivOAJ3bo7YL1I4L86aExwI8MvB/l8fGGdCmP2P9qMZ/VOP1l2X+sOPfK8fgQY3qvXiYh/7/1HjCz/5RnSkKo0T9ZS3//yJbOv7ddOF+HAFtg0wRLtxUxg+buCV0ih50vtr0tVA9zHh3G78//qou9GUXHvYs/FHPV3tz8LDjCXnUc+U8PI+FM8DhcB49fe2stXdndAcr3GlzI83h/P3ghzIczgCmr0iLNiqVCsCDZ4pzOJzHh8emtJDD4Tx6ampqkJOTAz09PTg5ObF2ukKam5shlUoxYsSIPo9OeKSAw3n84a4+hzOASUtLQ25uLnR1dXH48GHs378ftbW1SEpKQmZmJnp7e3H8+HF8+eWXyM7OhlQqxcWLF5GSkgKZTPb/evocDucRwSMDHM4ARldXFyNHjkR4eDi8vLzw9ttvw93dHYTcvgaa9vg3MTGBsbExfvzxR3YrY1FREV544QUeGeBw/gZwZ4DDGeDQxdzAwABKpRJVVVXIzMxkl4K5uLhg5MiRsLe3xyeffAI7OzsoFAoMHTr0vqolOBzO//9wZ4DDGcAQcvvej7a2Npw5cwb29vZISUlBTEwMMjIyoFKpoK+vj87OThBC4OjoiEmTJrE7QHhSIYfz94CXFnI4AxRCbl9/fOzYMZiZmcHOzg7Tp0/HzZs3ce7cOVhZWcHW1hbBwcH47rvvMGLECPj7++P48eOQyWQICQnRaIfN4XAeX7gzwOEMUIR9BIA7qwKE/Qe02x7TqgJ+exyH8/eAx/g4nAGM9hXG2q2pha1zhV0IebtYDufvBXcGOJwBjPadC8Jug9QxEP6u8G4FHlTkcP4+8GMCDmcA87CPPz8i4HD+HvBqAg5nAMMXcw6HA/BjAg6Hw+FwBjzcGeBwOBwOZ4DDnQEOh8PhcAY43BngcDgcDmeAw50BDofD4XAGONwZ4HA4HA5ngMOdAQ6Hw+FwBjjcGeBwOBwOZ4DDnQEOh8PhcAY43BngcDgcDmeAw50BDofD4XAGONwZ4HA4HA5ngMOdAQ6Hw+FwBjjcGeBwOBwOZ4DDnQEOh8PhcAY43BngcDgcDmeAw50BDofD4XAGONwZ4HA4HA5ngMOdAQ6Hw+FwBjjcGeBwOBwOZ4DDnQEOh8PhcAY43BngcDgcDmeAw50BDofD4XAGONwZ4HA4HA5ngMOdAQ6Hw+FwBjjcGeBwOBwOZ4DDnQEOh8PhcAY43BngcDgcDmeA878ABTn2iVtheQ4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mCommander\u001b[0m (to Critics):\n", + "\n", + "Improve \n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCommander\u001b[0m (to Coder):\n", + "\n", + "Here is the feedback to your figure. Please improve! Save the result to `result.jpg`\n", + "Improve \n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCoder\u001b[0m (to Commander):\n", + "\n", + "I would appreciate more specific feedback on the figure, however, assuming the context, we could improve the figures as follows:\n", + "\n", + "1. Increase line width for better visibility.\n", + "2. Separate out data into two subplots - one for each temperature series to avoid data overlap.\n", + "3. Utilize a dark theme for a more modern look.\n", + "4. Implement more interactive elements, like hover tooltips (would require shifting from matplotlib to an interactive library like bokeh or plotly).\n", + "\n", + "Please note, that adding interactive elements to a .jpg file is not possible. \n", + "\n", + "Here is the Python code block reflecting first three improvements:\n", + "\n", + "Python:\n", + "```python\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "# Load Data\n", + "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n", + "data = pd.read_csv(url)\n", + "data['date'] = pd.to_datetime(data['date'])\n", + "\n", + "# Dark Background\n", + "plt.style.use('dark_background')\n", + "\n", + "# Subplots\n", + "fig, (ax1, ax2) = plt.subplots(2,1, sharex=True, figsize=(10,6))\n", + "\n", + "# Temp Max\n", + "ax1.plot(data['date'], data['temp_max'], color='tab:red', linewidth=2, label='Temp Max')\n", + "ax1.set_ylabel('Temp Max (°F)')\n", + "ax1.legend(loc='upper right')\n", + "ax1.grid(color='gray', linestyle='dashed', linewidth=0.5, alpha=0.3)\n", + "\n", + "# Temp Min\n", + "ax2.plot(data['date'], data['temp_min'], color='tab:blue', linewidth=2, label='Temp Min')\n", + "ax2.set_ylabel('Temp Min (°F)')\n", + "ax2.legend(loc='upper right')\n", + "ax2.grid(color='gray', linestyle='dashed', linewidth=0.5, alpha=0.3)\n", + "\n", + "# Improve date formatting (shared X-axis)\n", + "ax2.xaxis.set_major_locator(mdates.YearLocator())\n", + "ax2.xaxis.set_major_formatter(mdates.DateFormatter('%Y'))\n", + "fig.autofmt_xdate()\n", + "\n", + "# Title\n", + "plt.suptitle('Seattle Weather: Max and Min Temperatures Over Time')\n", + "\n", + "# Save as 'result.jpg'\n", + "plt.savefig('result.jpg')\n", + "plt.show()\n", + "```\n", + "\n", + "This code block first downloads the dataset, sets the dark background, creates two subplots, and plots the temp_max and temp_min in separate subplots. Lastly, it saves the output figure as 'result.jpg'. Please run this code and check the resulting figure.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mCommander\u001b[0m (to Coder):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Figure(1000x600)\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mCoder\u001b[0m (to Commander):\n", + "\n", + "Great! The code has successfully executed and the improved plot was generated and saved as `result.jpg`.\n", + "\n", + "Please check the image `result.jpg` in your current directory to view the improved visualization. The figure should be separated into two subplots for better clarity and has a darker theme for a more modern look.\n", + "\n", + "If you have any other requests or need further assistance, feel free to ask. \n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mFigure Creator~\u001b[0m (to User):\n", + "\n", + "result.jpg\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import time\n", + "from PIL import Image\n", + "\n", + "\n", + "# config_list_gpt35 = autogen.config_list_from_json(\n", + "# \"OAI_CONFIG_LIST\",\n", + "# filter_dict={\n", + "# \"model\": [\"gpt-35-turbo\", \"gpt-3.5-turbo\"],\n", + "# },\n", + "# )\n", + "\n", + "# gpt35_llm_config = {\"config_list\": config_list_gpt35, \"seed\": 42}\n", + "\n", + "\n", + "creator = FigureCreator(\n", + " name=\"Figure Creator~\",\n", + " llm_config=gpt4_llm_config\n", + " \n", + ")\n", + "\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=0\n", + ")\n", + "\n", + "user_proxy.initiate_chat(creator, message=\"\"\"\n", + "Plot a figure by using the data from:\n", + "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\n", + "\n", + "I want to show both temperature high and low.\n", + "\"\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f0a58827", + "metadata": {}, + "outputs": [], + "source": [ + "if os.path.exists(\"result.jpg\"):\n", + " os.remove(\"result.jpg\") # clean up" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b95bf449", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/agentchat_lmm_llava.ipynb b/notebook/agentchat_lmm_llava.ipynb index d42fb53a0f5..35a51f45ad9 100644 --- a/notebook/agentchat_lmm_llava.ipynb +++ b/notebook/agentchat_lmm_llava.ipynb @@ -12,17 +12,27 @@ "\n", "This notebook contains the following information and examples:\n", "\n", - "1. Install [LLaVA package](#install)\n", - "2. Setup LLaVA Model\n", + "1. Setup LLaVA Model\n", " - Option 1: Use [API calls from `Replicate`](#replicate)\n", " - Option 2: Setup [LLaVA locally (requires GPU)](#local)\n", "2. Application 1: [Image Chat](#app-1)\n", "3. Application 2: [Figure Creator](#app-2)" ] }, + { + "cell_type": "markdown", + "id": "5f51914c", + "metadata": {}, + "source": [ + "### Before everything starts, install AutoGen with the `lmm` option\n", + "```bash\n", + "pip install pyautogen[lmm]\n", + "```" + ] + }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 1, "id": "b1ffe2ab", "metadata": {}, "outputs": [], @@ -36,71 +46,20 @@ { "cell_type": "code", "execution_count": 2, - "id": "2ec49aeb", - "metadata": {}, - "outputs": [], - "source": [ - "# we will override the following variables later.\n", - "MODEL_NAME = \"\" \n", - "SEP = \"###\"" - ] - }, - { - "cell_type": "markdown", - "id": "d64154f0", - "metadata": {}, - "source": [ - "\n", - "## Install the LLaVA library\n", - "\n", - "Please follow the LLaVA GitHub [page](https://github.com/haotian-liu/LLaVA/) to install LLaVA.\n", - "\n", - "\n", - "#### Download the package\n", - "```bash\n", - "git clone https://github.com/haotian-liu/LLaVA.git\n", - "cd LLaVA\n", - "```\n", - "\n", - "#### Install the inference package\n", - "```bash\n", - "conda create -n llava python=3.10 -y\n", - "conda activate llava\n", - "pip install --upgrade pip # enable PEP 660 support\n", - "pip install -e .\n", - "```\n", - "\n", - "### Don't forget AutoGen in the new environment\n", - "```bash\n", - "pip install pyautogen\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "id": "67d45964", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2023-10-20 12:47:04,159] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" - ] - } - ], + "outputs": [], "source": [ "import requests\n", "import json\n", - "from llava.conversation import default_conversation as conv\n", - "from llava.conversation import Conversation\n", + "import os\n", "\n", - "from typing import Dict, List, Optional, Tuple, Union\n", + "from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union\n", "\n", "import autogen\n", - "from autogen import AssistantAgent, Agent, ConversableAgent, OpenAIWrapper\n", - "from termcolor import colored" + "from autogen import AssistantAgent, Agent, UserProxyAgent, ConversableAgent\n", + "from termcolor import colored\n", + "import random" ] }, { @@ -122,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "f650bf3d", "metadata": {}, "outputs": [], @@ -135,13 +94,21 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "267ffd78", "metadata": {}, "outputs": [], "source": [ "if LLAVA_MODE == \"remote\":\n", - " import replicate" + " import replicate\n", + " \n", + " llava_config_list = [\n", + " {\n", + " \"model\": \"whatever, will be ignored for remote\", # The model name doesn't matter here right now.\n", + " \"api_key\": \"None\", # Note that you have to setup the API key with os.environ[\"REPLICATE_API_TOKEN\"] \n", + " \"base_url\": \"yorickvp/llava-13b:2facb4a474a0462c15041b78b1ad70952ea46b5ec6ad29583c0b29dbd4249591\",\n", + " }\n", + " ]" ] }, { @@ -153,6 +120,27 @@ "## [Option 2] Setup LLaVA Locally\n", "\n", "\n", + "## Install the LLaVA library\n", + "\n", + "Please follow the LLaVA GitHub [page](https://github.com/haotian-liu/LLaVA/) to install LLaVA.\n", + "\n", + "\n", + "#### Download the package\n", + "```bash\n", + "git clone https://github.com/haotian-liu/LLaVA.git\n", + "cd LLaVA\n", + "```\n", + "\n", + "#### Install the inference package\n", + "```bash\n", + "conda create -n llava python=3.10 -y\n", + "conda activate llava\n", + "pip install --upgrade pip # enable PEP 660 support\n", + "pip install -e .\n", + "```\n", + "\n", + "\n", + "\n", "Some helpful packages and dependencies:\n", "```bash\n", "conda install -c nvidia cuda-toolkit\n", @@ -173,40 +161,22 @@ "``" ] }, - { - "cell_type": "markdown", - "id": "9c29925f", - "metadata": {}, - "source": [ - "**Note: make sure the environment of this notebook also installed the llava package from `pip install -e .`**" - ] - }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 5, "id": "93bf7915", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'models': ['llava-v1.5-13b']}\n", - "Model Name: llava-v1.5-13b\n" - ] - } - ], + "outputs": [], "source": [ "# Run this code block only if you want to run LlaVA locally\n", - "if LLAVA_MODE == \"local\":\n", - " # Setup some global constants for convenience\n", - " # Note: make sure the addresses below are consistent with your setup in LLaVA \n", - " CONTROLLER_ADDR = \"http://0.0.0.0:10000\"\n", - " SEP = conv.sep\n", - " ret = requests.post(CONTROLLER_ADDR + \"/list_models\")\n", - " print(ret.json())\n", - " MODEL_NAME = ret.json()[\"models\"][0]\n", - " print(\"Model Name:\", MODEL_NAME)" + "if LLAVA_MODE == \"local\": \n", + " llava_config_list = [\n", + " {\n", + " \"model\": \"llava-v1.5-13b\",\n", + " \"api_key\": \"None\",\n", + " \"base_url\": \"http://0.0.0.0:10000\",\n", + " }\n", + " ]" ] }, { @@ -216,322 +186,50 @@ "source": [ "# Multimodal Functions\n", "\n", - "The Multimodal Functions library provides a set of utilities to manage and process multimodal data, focusing on textual and image components. The library allows you to format prompts, extract image paths, and handle image data in various formats.\n", - "\n", - "## Functions\n", - "\n", - "\n", - "### `get_image_data`\n", - "\n", - "This function retrieves the content of an image specified by a file path or URL and optionally converts it to base64 format. It can handle both web-hosted images and locally stored files.\n", - "\n", - "\n", - "### `lmm_formater`\n", - "\n", - "This function formats a user-provided prompt containing `` tags, replacing these tags with `` or numbered versions like ``, ``, etc., and extracts the image locations. It returns a tuple containing the new formatted prompt and a list of image data." + "We cal test the `llava_call` function with the following AutoGen image.\n", + "![](https://raw.githubusercontent.com/microsoft/autogen/main/website/static/img/autogen_agentchat.png)\n" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "4bf7f549", + "execution_count": 6, + "id": "e2ff1607", "metadata": {}, "outputs": [], "source": [ - "import base64\n", - "import re\n", - "from io import BytesIO\n", - "\n", - "from PIL import Image\n", - "\n", - "import re\n", - "\n", - "\n", - "def get_image_data(image_file, use_b64=True):\n", - " if image_file.startswith('http://') or image_file.startswith('https://'):\n", - " response = requests.get(image_file)\n", - " content = response.content\n", - " elif re.match(r\"data:image/(?:png|jpeg);base64,\", image_file):\n", - " return re.sub(r\"data:image/(?:png|jpeg);base64,\", \"\", image_file)\n", - " else:\n", - " image = Image.open(image_file).convert('RGB')\n", - " buffered = BytesIO()\n", - " image.save(buffered, format=\"PNG\")\n", - " content = buffered.getvalue()\n", - " \n", - " if use_b64:\n", - " return base64.b64encode(content).decode('utf-8')\n", - " else:\n", - " return content\n", - "\n", - "def lmm_formater(prompt: str, order_image_tokens: bool = False) -> Tuple[str, List[str]]:\n", - " \"\"\"\n", - " Formats the input prompt by replacing image tags and returns the new prompt along with image locations.\n", - " \n", - " Parameters:\n", - " - prompt (str): The input string that may contain image tags like .\n", - " - order_image_tokens (bool, optional): Whether to order the image tokens with numbers. \n", - " It will be useful for GPT-4V. Defaults to False.\n", - " \n", - " Returns:\n", - " - Tuple[str, List[str]]: A tuple containing the formatted string and a list of images (loaded in b64 format).\n", - " \"\"\"\n", - " \n", - " # Initialize variables\n", - " new_prompt = prompt\n", - " image_locations = []\n", - " images = []\n", - " image_count = 0\n", - " \n", - " # Regular expression pattern for matching tags\n", - " img_tag_pattern = re.compile(r']+)>')\n", - " \n", - " # Find all image tags\n", - " for match in img_tag_pattern.finditer(prompt):\n", - " image_location = match.group(1)\n", - " \n", - " try: \n", - " img_data = get_image_data(image_location)\n", - " except:\n", - " # Remove the token\n", - " print(f\"Warning! Unable to load image from {image_location}\")\n", - " new_prompt = new_prompt.replace(match.group(0), \"\", 1)\n", - " continue\n", - " \n", - " image_locations.append(image_location)\n", - " images.append(img_data)\n", - " \n", - " # Increment the image count and replace the tag in the prompt\n", - " new_token = f'' if order_image_tokens else \"\"\n", - "\n", - " new_prompt = new_prompt.replace(match.group(0), new_token, 1)\n", - " image_count += 1\n", - " \n", - " return new_prompt, images\n", - "\n", - "\n", - "\n", - "def gpt4v_formatter(prompt: str) -> List[Union[str, dict]]:\n", - " \"\"\"\n", - " Formats the input prompt by replacing image tags and returns a list of text and images.\n", - " \n", - " Parameters:\n", - " - prompt (str): The input string that may contain image tags like .\n", - "\n", - " Returns:\n", - " - List[Union[str, dict]]: A list of alternating text and image dictionary items.\n", - " \"\"\"\n", - " output = []\n", - " last_index = 0\n", - " image_count = 0\n", - " \n", - " # Regular expression pattern for matching tags\n", - " img_tag_pattern = re.compile(r']+)>')\n", - " \n", - " # Find all image tags\n", - " for match in img_tag_pattern.finditer(prompt):\n", - " image_location = match.group(1)\n", - " \n", - " try:\n", - " img_data = get_image_data(image_location)\n", - " except:\n", - " # Warning and skip this token\n", - " print(f\"Warning! Unable to load image from {image_location}\")\n", - " continue\n", - "\n", - " # Add text before this image tag to output list\n", - " output.append(prompt[last_index:match.start()])\n", - " \n", - " # Add image data to output list\n", - " output.append({\"image\": img_data})\n", - " \n", - " last_index = match.end()\n", - " image_count += 1\n", - "\n", - " # Add remaining text to output list\n", - " output.append(prompt[last_index:])\n", - " \n", - " return output\n", - "\n", - "\n", - "def extract_img_paths(paragraph: str) -> list:\n", - " \"\"\"\n", - " Extract image paths (URLs or local paths) from a text paragraph.\n", - " \n", - " Parameters:\n", - " paragraph (str): The input text paragraph.\n", - " \n", - " Returns:\n", - " list: A list of extracted image paths.\n", - " \"\"\"\n", - " # Regular expression to match image URLs and file paths\n", - " img_path_pattern = re.compile(r'\\b(?:http[s]?://\\S+\\.(?:jpg|jpeg|png|gif|bmp)|\\S+\\.(?:jpg|jpeg|png|gif|bmp))\\b', \n", - " re.IGNORECASE)\n", - " \n", - " # Find all matches in the paragraph\n", - " img_paths = re.findall(img_path_pattern, paragraph)\n", - " return img_paths\n", - "\n", - "\n", - "def _to_pil(data):\n", - " return Image.open(BytesIO(base64.b64decode(data)))\n", - "\n", - "\n", - "\n", - "def llava_call_binary(prompt: str, images: list, \n", - " model_name:str = MODEL_NAME, \n", - " max_new_tokens:int=1000, temperature: float=0.5, seed: int = 1):\n", - " # TODO 1: add caching around the LLaVA call to save compute and cost\n", - " # TODO 2: add `seed` to ensure reproducibility. The seed is not working now.\n", - " if LLAVA_MODE == \"local\":\n", - " headers = {\"User-Agent\": \"LLaVA Client\"}\n", - " pload = {\n", - " \"model\": model_name,\n", - " \"prompt\": prompt,\n", - " \"max_new_tokens\": max_new_tokens,\n", - " \"temperature\": temperature,\n", - " \"stop\": SEP,\n", - " \"images\": images,\n", - " }\n", - "\n", - " response = requests.post(CONTROLLER_ADDR + \"/worker_generate_stream\", headers=headers,\n", - " json=pload, stream=False)\n", - "\n", - " for chunk in response.iter_lines(chunk_size=8192, decode_unicode=False, delimiter=b\"\\0\"):\n", - " if chunk:\n", - " data = json.loads(chunk.decode(\"utf-8\"))\n", - " output = data[\"text\"].split(SEP)[-1]\n", - " elif LLAVA_MODE == \"remote\":\n", - " # The Replicate version of the model only support 1 image for now.\n", - " img = 'data:image/jpeg;base64,' + images[0]\n", - " response = replicate.run(\n", - " \"yorickvp/llava-13b:2facb4a474a0462c15041b78b1ad70952ea46b5ec6ad29583c0b29dbd4249591\",\n", - " input={\"image\": img, \"prompt\": prompt.replace(\"\", \" \"), \"seed\": seed}\n", - " )\n", - " # The yorickvp/llava-13b model can stream output as it's running.\n", - " # The predict method returns an iterator, and you can iterate over that output.\n", - " output = \"\"\n", - " for item in response:\n", - " # https://replicate.com/yorickvp/llava-13b/versions/2facb4a474a0462c15041b78b1ad70952ea46b5ec6ad29583c0b29dbd4249591/api#output-schema\n", - " output += item\n", - " \n", - " # Remove the prompt and the space.\n", - " output = output.replace(prompt, \"\").strip().rstrip()\n", - " return output\n", - " \n", - "\n", - "def llava_call(prompt:str, model_name: str=MODEL_NAME, images: list=[], \n", - " max_new_tokens:int=1000, temperature: float=0.5, seed: int = 1) -> str:\n", - " \"\"\"\n", - " Makes a call to the LLaVA service to generate text based on a given prompt and optionally provided images.\n", - "\n", - " Args:\n", - " - prompt (str): The input text for the model. Any image paths or placeholders in the text should be replaced with \"\".\n", - " - model_name (str, optional): The name of the model to use for the text generation. Defaults to the global constant MODEL_NAME.\n", - " - images (list, optional): A list of image paths or URLs. If not provided, they will be extracted from the prompt.\n", - " If provided, they will be appended to the prompt with the \"\" placeholder.\n", - " - max_new_tokens (int, optional): Maximum number of new tokens to generate. Defaults to 1000.\n", - " - temperature (float, optional): temperature for the model. Defaults to 0.5.\n", - "\n", - " Returns:\n", - " - str: Generated text from the model.\n", - "\n", - " Raises:\n", - " - AssertionError: If the number of \"\" tokens in the prompt and the number of provided images do not match.\n", - " - RunTimeError: If any of the provided images is empty.\n", - "\n", - " Notes:\n", - " - The function uses global constants: CONTROLLER_ADDR and SEP.\n", - " - Any image paths or URLs in the prompt are automatically replaced with the \"\" token.\n", - " - If more images are provided than there are \"\" tokens in the prompt, the extra tokens are appended to the end of the prompt.\n", - " \"\"\"\n", - "\n", - " if len(images) == 0:\n", - " prompt, images = lmm_formater(prompt, order_image_tokens=False)\n", - " else:\n", - " # Append the token if missing\n", - " assert prompt.count(\"\") <= len(images), \"the number \"\n", - " \"of image token in prompt and in the images list should be the same!\"\n", - " num_token_missing = len(images) - prompt.count(\"\")\n", - " prompt += \" \" * num_token_missing\n", - " images = [get_image_data(x) for x in images]\n", - " \n", - " for im in images:\n", - " if len(im) == 0:\n", - " raise RunTimeError(\"An image is empty!\")\n", - "\n", - " return llava_call_binary(prompt, images, \n", - " model_name, \n", - " max_new_tokens, temperature, seed)\n" - ] - }, - { - "cell_type": "markdown", - "id": "4123df2c", - "metadata": {}, - "source": [ - "Here is the image that we are going to use.\n", - "\n", - "![Image](https://github.com/haotian-liu/LLaVA/raw/main/images/llava_logo.png)" - ] - }, - { - "cell_type": "markdown", - "id": "05ed5a35", - "metadata": {}, - "source": [ - "We can call llava by providing the prompt and images separately.\n" + "from autogen.agentchat.contrib.llava_agent import llava_call" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "ec31ca74", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The image features a small, orange, and black toy animal, possibly a stuffed dog or a toy horse, with flames coming out of its back. The toy is sitting on a table, and it appears to be a unique and creative design. The toy is wearing glasses, adding a touch of whimsy to its appearance. The overall scene is quite eye-catching and playful.\n" - ] - } - ], - "source": [ - "out = llava_call(\"Describe this image: \", \n", - " images=[\"https://github.com/haotian-liu/LLaVA/raw/main/images/llava_logo.png\"])\n", - "print(out)" - ] - }, - { - "cell_type": "markdown", - "id": "6619dc30", + "execution_count": 7, + "id": "7c1be77f", "metadata": {}, - "source": [ - "Or, we can also call LLaVA with only prompt, with images embedded in the prompt with the format\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "12a7db5a", - "metadata": { - "scrolled": true - }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "A red toy with flames and glasses on it.\n" + "The AutoGen framework is a tool for creating and managing conversational agents. It allows for the creation of multiple-agent conversations, enabling complex interactions between different agents. The framework is designed to be flexible and scalable, allowing for the addition of new agents and conversations as needed.\n", + "\n", + "The framework consists of three main components:\n", + "\n", + "1. Agents: These are the individual conversational entities that can be created and managed within the framework. Each agent has its own unique set of conversational capabilities and can engage in conversations with other agents.\n", + "\n", + "2. Conversations: These are the interactions between agents, which can be managed and directed by the framework. Conversations can be structured and organized to facilitate efficient communication between agents.\n", + "\n", + "3. Flexibility: The framework is designed to be flexible, allowing for the addition of new agents and conversations as needed. This flexibility enables the framework to adapt to changing requirements and facilitate the development of more complex conversational systems.\n" ] } ], "source": [ - "out = llava_call(\"Describe this image in one sentence: \")\n", - "print(out)" + "rst = llava_call(\"Describe this AutoGen framework with bullet points.\",\n", + " llm_config={\n", + " \"config_list\": llava_config_list,\n", + " \"temperature\": 0\n", + " })\n", + "\n", + "print(rst)" ] }, { @@ -550,201 +248,26 @@ ] }, { - "cell_type": "code", - "execution_count": 10, - "id": "286938aa", + "cell_type": "markdown", + "id": "e3d5580e", "metadata": {}, - "outputs": [], "source": [ - "\n", - "config_list_gpt4 = autogen.config_list_from_json(\n", - " \"OAI_CONFIG_LIST\",\n", - " filter_dict={\n", - " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", - " },\n", - ")\n", - "\n", - "llm_config = {\"config_list\": config_list_gpt4, \"seed\": 42}\n", - "\n", - "DEFAULT_LMM_SYS_MSG = \"\"\"You are a helpful AI assistant.\n", - "You can also view images, where the \"\" represent the i-th image you received.\"\"\"\n", - "\n", - "class MultimodalConversableAgent(ConversableAgent):\n", - " def __init__(\n", - " self,\n", - " name: str,\n", - " system_message: Optional[Tuple[str, List]] = DEFAULT_LMM_SYS_MSG,\n", - " is_termination_msg=None,\n", - " *args,\n", - " **kwargs,\n", - " ):\n", - " \"\"\"\n", - " Args:\n", - " name (str): agent name.\n", - " system_message (str): system message for the ChatCompletion inference.\n", - " Please override this attribute if you want to reprogram the agent.\n", - " **kwargs (dict): Please refer to other kwargs in\n", - " [ConversableAgent](conversable_agent#__init__).\n", - " \"\"\"\n", - " super().__init__(\n", - " name,\n", - " system_message,\n", - " is_termination_msg=is_termination_msg,\n", - " *args,\n", - " **kwargs,\n", - " )\n", - " \n", - " self.update_system_message(system_message)\n", - " self._is_termination_msg = (\n", - " is_termination_msg if is_termination_msg is not None else (lambda x: x.get(\"content\")[-1] == \"TERMINATE\")\n", - " )\n", - " \n", - " @property\n", - " def system_message(self) -> List:\n", - " \"\"\"Return the system message.\"\"\"\n", - " return self._oai_system_message[0][\"content\"]\n", - "\n", - " def update_system_message(self, system_message: str):\n", - " \"\"\"Update the system message.\n", - "\n", - " Args:\n", - " system_message (str): system message for the ChatCompletion inference.\n", - " \"\"\"\n", - " self._oai_system_message[0][\"content\"] = self._message_to_dict(system_message)[\"content\"]\n", - " self._oai_system_message[0][\"role\"] = \"system\"\n", - " \n", - " @staticmethod\n", - " def _message_to_dict(message: Union[Dict, List, str]):\n", - " \"\"\"Convert a message to a dictionary.\n", - "\n", - " The message can be a string or a dictionary. The string will be put in the \"content\" field of the new dictionary.\n", - " \"\"\"\n", - " if isinstance(message, str):\n", - " return {\"content\": gpt4v_formatter(message)}\n", - " if isinstance(message, list):\n", - " return {\"content\": message}\n", - " else:\n", - " return message\n", - " \n", - " def _content_str(self, content: List) -> str:\n", - " rst = \"\"\n", - " for item in content:\n", - " if isinstance(item, str):\n", - " rst += item\n", - " else:\n", - " assert isinstance(item, dict) and \"image\" in item, (\"Wrong content format.\")\n", - " rst += \"\"\n", - " return rst\n", - " \n", - " def _print_received_message(self, message: Union[Dict, str], sender: Agent):\n", - " # print the message received\n", - " print(colored(sender.name, \"yellow\"), \"(to\", f\"{self.name}):\\n\", flush=True)\n", - " if message.get(\"role\") == \"function\":\n", - " func_print = f\"***** Response from calling function \\\"{message['name']}\\\" *****\"\n", - " print(colored(func_print, \"green\"), flush=True)\n", - " print(self._content_str(message[\"content\"]), flush=True)\n", - " print(colored(\"*\" * len(func_print), \"green\"), flush=True)\n", - " else:\n", - " content = message.get(\"content\")\n", - " if content is not None:\n", - " if \"context\" in message:\n", - " content = OpenAIWrapper.instantiate(\n", - " content,\n", - " message[\"context\"],\n", - " self.llm_config and self.llm_config.get(\"allow_format_str_template\", False),\n", - " )\n", - " print(self._content_str(content), flush=True)\n", - " if \"function_call\" in message:\n", - " func_print = f\"***** Suggested function Call: {message['function_call'].get('name', '(No function name found)')} *****\"\n", - " print(colored(func_print, \"green\"), flush=True)\n", - " print(\n", - " \"Arguments: \\n\",\n", - " message[\"function_call\"].get(\"arguments\", \"(No arguments found)\"),\n", - " flush=True,\n", - " sep=\"\",\n", - " )\n", - " print(colored(\"*\" * len(func_print), \"green\"), flush=True)\n", - " print(\"\\n\", \"-\" * 80, flush=True, sep=\"\")\n", - " # TODO: we may want to udpate `generate_code_execution_reply` or `extract_code` for the \"content\" type change.\n", - " \n", - "\n", - "DEFAULT_LLAVA_SYS_MSG = \"You are an AI agent and you can view images.\"\n", - "class LLaVAAgent(MultimodalConversableAgent):\n", - " def __init__(\n", - " self,\n", - " name: str,\n", - " system_message: Optional[Tuple[str, List]] = DEFAULT_LLAVA_SYS_MSG,\n", - " *args,\n", - " **kwargs,\n", - " ):\n", - " \"\"\"\n", - " Args:\n", - " name (str): agent name.\n", - " system_message (str): system message for the ChatCompletion inference.\n", - " Please override this attribute if you want to reprogram the agent.\n", - " **kwargs (dict): Please refer to other kwargs in\n", - " [ConversableAgent](conversable_agent#__init__).\n", - " \"\"\"\n", - " super().__init__(\n", - " name,\n", - " system_message=system_message,\n", - " *args,\n", - " **kwargs,\n", - " )\n", - " self.register_reply([Agent, None], reply_func=LLaVAAgent._image_reply, position=0)\n", - "\n", - " def _image_reply(\n", - " self,\n", - " messages=None,\n", - " sender=None, config=None\n", - " ):\n", - " # Note: we did not use \"llm_config\" yet.\n", - " # TODO 1: make the LLaVA API design compatible with llm_config\n", - " \n", - " if all((messages is None, sender is None)):\n", - " error_msg = f\"Either {messages=} or {sender=} must be provided.\"\n", - " logger.error(error_msg)\n", - " raise AssertionError(error_msg)\n", - "\n", - " if messages is None:\n", - " messages = self._oai_messages[sender]\n", - "\n", - " # The formats for LLaVA and GPT are different. So, we manually handle them here.\n", - " # TODO: format the images from the history accordingly.\n", - " images = []\n", - " prompt = self._content_str(self.system_message) + \"\\n\"\n", - " for msg in messages:\n", - " role = \"Human\" if msg[\"role\"] == \"user\" else \"Assistant\"\n", - " images += [d[\"image\"] for d in msg[\"content\"] if isinstance(d, dict)]\n", - " content_prompt = self._content_str(msg[\"content\"])\n", - " prompt += f\"{SEP}{role}: {content_prompt}\\n\"\n", - " prompt += \"\\n\" + SEP + \"Assistant: \"\n", - " print(colored(prompt, \"blue\"))\n", - " \n", - " out = \"\"\n", - " retry = 10\n", - " while len(out) == 0 and retry > 0:\n", - " # image names will be inferred automatically from llava_call\n", - " out = llava_call_binary(prompt=prompt, images=images, temperature=0, max_new_tokens=2000)\n", - " retry -= 1\n", - " \n", - " assert out != \"\", \"Empty response from LLaVA.\"\n", - " \n", - " \n", - " return True, out" + "Within the user proxy agent, we can decide to activate the human input mode or not (for here, we use human_input_mode=\"NEVER\" for conciseness). This allows you to interact with LLaVA in a multi-round dialogue, enabling you to provide feedback as the conversation unfolds." ] }, { - "cell_type": "markdown", - "id": "e3d5580e", + "cell_type": "code", + "execution_count": 8, + "id": "b1db6f5d", "metadata": {}, + "outputs": [], "source": [ - "Within the user proxy agent, we can decide to activate the human input mode or not (for here, we use human_input_mode=\"NEVER\" for conciseness). This allows you to interact with LLaVA in a multi-round dialogue, enabling you to provide feedback as the conversation unfolds." + "from autogen.agentchat.contrib.llava_agent import LLaVAAgent" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 9, "id": "67157629", "metadata": { "scrolled": false @@ -760,6 +283,8 @@ ".\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[34mYou are an AI agent and you can view images.\n", "###Human: What's the breed of this dog? \n", ".\n", @@ -767,7 +292,7 @@ "###Assistant: \u001b[0m\n", "\u001b[33mimage-explainer\u001b[0m (to User_proxy):\n", "\n", - "The dog in the image is a poodle.\n", + "The breed of the dog in the image is a poodle.\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -776,7 +301,8 @@ "source": [ "image_agent = LLaVAAgent(\n", " name=\"image-explainer\",\n", - " max_consecutive_auto_reply=0\n", + " max_consecutive_auto_reply=10,\n", + " llm_config={\"config_list\": llava_config_list, \"temperature\": 0.5, \"max_new_tokens\": 1000}\n", ")\n", "\n", "user_proxy = autogen.UserProxyAgent(\n", @@ -787,8 +313,7 @@ " \"work_dir\": \"groupchat\"\n", " },\n", " human_input_mode=\"NEVER\", # Try between ALWAYS or NEVER\n", - "# llm_config=llm_config,\n", - " max_consecutive_auto_reply=0,\n", + " max_consecutive_auto_reply=0\n", ")\n", "\n", "# Ask the question with an image\n", @@ -809,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 10, "id": "73a2b234", "metadata": { "scrolled": false @@ -821,20 +346,19 @@ "text": [ "\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n", "\n", - "How about these breeds? \n", + "What is this breed? \n", "\n", "\n", "Among the breeds, which one barks less?\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[34mYou are an AI agent and you can view images.\n", "###Human: What's the breed of this dog? \n", ".\n", - "###Assistant: The dog in the image is a poodle.\n", - "###Human: How about these breeds? and \n", - "Among all the breeds, which one barks less?\n", - "###Assistant: The breeds of the dog in the image are a poodle and a terrier. Among the two, the poodle is known to bark less.\n", - "###Human: How about these breeds? \n", + "###Assistant: The breed of the dog in the image is a poodle.\n", + "###Human: What is this breed? \n", "\n", "\n", "Among the breeds, which one barks less?\n", @@ -842,7 +366,7 @@ "###Assistant: \u001b[0m\n", "\u001b[33mimage-explainer\u001b[0m (to User_proxy):\n", "\n", - "Among the breeds, the poodle is known to bark less.\n", + "Among the breeds, poodles tend to bark less compared to other breeds. However, it is important to note that individual dogs may have different temperaments and barking habits, regardless of their breed.\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -850,7 +374,7 @@ ], "source": [ "# Ask the question with an image\n", - "user_proxy.send(message=\"\"\"How about these breeds? \n", + "user_proxy.send(message=\"\"\"What is this breed? \n", "\n", "\n", "Among the breeds, which one barks less?\"\"\", \n", @@ -874,7 +398,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "e8eca993", "metadata": {}, "outputs": [], @@ -928,10 +452,12 @@ " critics = LLaVAAgent(\n", " name=\"Critics\",\n", " system_message=\n", - " \"Criticize the input figure. How to replot the figure so it will be better? Find bugs and issues for the figure. If you think the figures is good enough, then simply say NO_ISSUES\",\n", - " llm_config=self.llm_config,\n", + " \"\"\"Criticize the input figure. How to replot the figure so it will be better? Find bugs and issues for the figure. \n", + " Pay attention to the color, format, and presentation. Keep in mind of the reader-friendliness.\n", + " If you think the figures is good enough, then simply say NO_ISSUES\"\"\",\n", + " llm_config={\"config_list\": llava_config_list},\n", " human_input_mode=\"NEVER\",\n", - " max_consecutive_auto_reply=0,\n", + " max_consecutive_auto_reply=1,\n", " # use_docker=False,\n", " )\n", "\n", @@ -975,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "977b9017", "metadata": { "scrolled": false @@ -1007,38 +533,40 @@ "--------------------------------------------------------------------------------\n", "\u001b[33mCoder\u001b[0m (to Commander):\n", "\n", - "To plot the figure using the data from the provided URL, we'll first download the data, then use the pandas library to read the CSV data and finally, use the matplotlib library to plot the temperature high and low.\n", - "\n", - "Step 1: Download the CSV file\n", - "Step 2: Read the CSV file using pandas\n", - "Step 3: Plot the temperature high and low using matplotlib\n", + "First, we will download the CSV file, then we will parse it using pandas, a popular data analysis library in Python. After that, we will plot the data using matplotlib.\n", "\n", - "Please execute the following code:\n", + "This is how we could do this:\n", "\n", "```python\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "import urllib.request\n", "\n", - "# Download the CSV file from the URL\n", + "# Step 1: Load the Data\n", "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n", - "urllib.request.urlretrieve(url, \"seattle-weather.csv\")\n", + "data = pd.read_csv(url)\n", + "\n", + "# Step 2: Parse the date to datetime format\n", + "data['date'] = pd.to_datetime(data['date'])\n", "\n", - "# Read the CSV file using pandas\n", - "data = pd.read_csv(\"seattle-weather.csv\")\n", + "# Step 3: Plot the Data\n", + "plt.figure(figsize=(10,6))\n", + "plt.plot(data['date'], data['temp_max'], label='Temp Max')\n", + "plt.plot(data['date'], data['temp_min'], label='Temp Min')\n", "\n", - "# Plot the temperature high and low using matplotlib\n", - "plt.plot(data[\"date\"], data[\"temp_max\"], label=\"Temperature High\")\n", - "plt.plot(data[\"date\"], data[\"temp_min\"], label=\"Temperature Low\")\n", - "plt.xlabel(\"Date\")\n", - "plt.ylabel(\"Temperature\")\n", - "plt.title(\"Seattle Weather - Temperature High and Low\")\n", + "plt.title('Seattle Weather')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Temperature (F)')\n", "plt.legend()\n", - "plt.savefig(\"result.jpg\")\n", + "plt.grid()\n", + "\n", + "# Save the figure\n", + "plt.savefig('result.jpg')\n", + "\n", + "# Display the plot\n", "plt.show()\n", "```\n", "\n", - "After executing the code, you should see the desired plot with temperature high and low. The figure will be saved as `result.jpg`.\n", + "When you run this code, it will load the data from the given URL, parse the 'date' column to datetime format, then plot the \"temp_max\" and \"temp_min\" over time. The resulting plot is then shown to you. The plot will automatically be saved as 'result.jpg' in the current directory. I will also submit these instructions to other agents.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -1047,13 +575,17 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Figure(640x480)\n", + "Figure(1000x600)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mCoder\u001b[0m (to Commander):\n", "\n", - "Great! The code execution succeeded, and the figure has been plotted using the data provided. The figure is saved in the `result.jpg` file. Please check the file for the plotted figure showing both temperature high and low.\n", + "Great! The code has successfully executed and the plot was generated and saved as `result.jpg`. \n", + "\n", + "If you check the working directory, you should find the figure saved as `result.jpg`.\n", + "\n", + "Let me know if you need help with anything else.\n", "\n", "TERMINATE\n", "\n", @@ -1062,7 +594,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1079,72 +611,90 @@ "Improve \n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[34mCriticize the input figure. How to replot the figure so it will be better? Find bugs and issues for the figure. If you think the figures is good enough, then simply say NO_ISSUES\n", + "\u001b[34mCriticize the input figure. How to replot the figure so it will be better? Find bugs and issues for the figure. \n", + " Pay attention to the color, format, and presentation. Keep in mind of the reader-friendliness.\n", + " If you think the figures is good enough, then simply say NO_ISSUES\n", "###Human: Improve \n", "\n", "###Assistant: \u001b[0m\n", "\u001b[33mCritics\u001b[0m (to Commander):\n", "\n", - "The input figure shows a graph with three different colored lines, representing temperature high, temperature low, and temperature average. The graph is labeled \"Seattle Weather - Temperature High and Low.\" However, the graph is not well-organized, and the lines are not clearly distinguishable.\n", + "The input figure shows a graph of Seattle weather, with a blue line representing the temperature and an orange line representing the humidity. The graph is displayed on a white background, with the title \"Seattle Weather\" at the top.\n", + "\n", + "There are a few issues with the figure that could be improved:\n", + "\n", + "1. The color scheme for the temperature and humidity lines is not clear. The blue line represents the temperature, but it is not immediately clear to the viewer. A more distinct color or labeling could help clarify this.\n", + "2. The graph does not have any axis labels or units, making it difficult for the viewer to understand the scale and units of the temperature and humidity values.\n", + "3. The graph is not well-organized, with the temperature and humidity lines overlapping and not clearly separated. A more organized layout could help the viewer better understand the relationship between the two variables.\n", + "\n", + "To improve the figure, the following changes could be made:\n", "\n", - "To improve the figure, one could use a more visually appealing color scheme for the lines, such as different shades of blue, green, and orange. Additionally, the labels for the temperature high, temperature low, and temperature average could be placed above or below the respective lines to make them more easily readable. The graph could also benefit from a clear title and axis labels to provide more context and information about the data being displayed.\n", + "1. Use a more distinct color for the temperature line, such as red, and label it with a clear title, such as \"Temperature (°C)\".\n", + "2. Add axis labels for both the temperature and humidity lines, indicating the units and scale of the values.\n", + "3. Separate the temperature and humidity lines, either by using different colors or by adding a clear separation between them.\n", + "4. Consider adding a legend or key to help the viewer understand the meaning of the different colors and lines on the graph.\n", + "\n", + "By making these changes, the figure will be more reader-friendly and easier to understand.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mCommander\u001b[0m (to Coder):\n", "\n", "Here is the feedback to your figure. Please improve! Save the result to `result.jpg`\n", - "The input figure shows a graph with three different colored lines, representing temperature high, temperature low, and temperature average. The graph is labeled \"Seattle Weather - Temperature High and Low.\" However, the graph is not well-organized, and the lines are not clearly distinguishable.\n", + "The input figure shows a graph of Seattle weather, with a blue line representing the temperature and an orange line representing the humidity. The graph is displayed on a white background, with the title \"Seattle Weather\" at the top.\n", + "\n", + "There are a few issues with the figure that could be improved:\n", + "\n", + "1. The color scheme for the temperature and humidity lines is not clear. The blue line represents the temperature, but it is not immediately clear to the viewer. A more distinct color or labeling could help clarify this.\n", + "2. The graph does not have any axis labels or units, making it difficult for the viewer to understand the scale and units of the temperature and humidity values.\n", + "3. The graph is not well-organized, with the temperature and humidity lines overlapping and not clearly separated. A more organized layout could help the viewer better understand the relationship between the two variables.\n", + "\n", + "To improve the figure, the following changes could be made:\n", "\n", - "To improve the figure, one could use a more visually appealing color scheme for the lines, such as different shades of blue, green, and orange. Additionally, the labels for the temperature high, temperature low, and temperature average could be placed above or below the respective lines to make them more easily readable. The graph could also benefit from a clear title and axis labels to provide more context and information about the data being displayed.\n", + "1. Use a more distinct color for the temperature line, such as red, and label it with a clear title, such as \"Temperature (°C)\".\n", + "2. Add axis labels for both the temperature and humidity lines, indicating the units and scale of the values.\n", + "3. Separate the temperature and humidity lines, either by using different colors or by adding a clear separation between them.\n", + "4. Consider adding a legend or key to help the viewer understand the meaning of the different colors and lines on the graph.\n", + "\n", + "By making these changes, the figure will be more reader-friendly and easier to understand.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mCoder\u001b[0m (to Commander):\n", "\n", - "I appreciate your feedback. I will make the following improvements based on the feedback provided for the figure:\n", - "\n", - "1. Use a better color scheme for the lines, such as different shades of blue, green, and orange.\n", - "2. Add a label for temperature average.\n", - "3. Place the labels for temperature high, temperature low, and temperature average above or below the respective lines.\n", - "4. Improve the title and axis labels for better readability and context.\n", + "Thank you for your feedback. I will indeed make the improvements accordingly. This time, each graph line will be labeled showing which indicates \"Temp Max\" and which indicates \"Temp Min\". I will also assign a red color to the line representing \"Temp Max\" and a blue color to the line representing \"Temp Min\". I will make sure the axes have the appropriate labels. \n", "\n", - "Please execute the following code to generate the improved figure:\n", + "Follow this code and it will improve your figure and saved as `result.jpg`:\n", "\n", "```python\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "import urllib.request\n", "\n", - "# Download the CSV file from the URL\n", + "# Step 1: Load the Data\n", "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n", - "urllib.request.urlretrieve(url, \"seattle-weather.csv\")\n", - "\n", - "# Read the CSV file using pandas\n", - "data = pd.read_csv(\"seattle-weather.csv\")\n", + "data = pd.read_csv(url)\n", "\n", - "# Calculate temperature average\n", - "data[\"temp_avg\"] = (data[\"temp_max\"] + data[\"temp_min\"]) / 2\n", + "# Step 2: Parse the date to datetime format\n", + "data['date'] = pd.to_datetime(data['date'])\n", "\n", - "# Plot the temperature high, low, and average using matplotlib with better colors\n", - "plt.plot(data[\"date\"], data[\"temp_max\"], color=\"darkorange\", label=\"Temperature High\")\n", - "plt.plot(data[\"date\"], data[\"temp_min\"], color=\"dodgerblue\", label=\"Temperature Low\")\n", - "plt.plot(data[\"date\"], data[\"temp_avg\"], color=\"mediumseagreen\", label=\"Temperature Average\")\n", + "# Step 3: Plot the Data\n", + "plt.figure(figsize=(10,6))\n", + "plt.plot(data['date'], data['temp_max'], color='red', label='Temp Max')\n", + "plt.plot(data['date'], data['temp_min'], color='blue', label='Temp Min')\n", "\n", - "# Improve the title and axis labels\n", - "plt.xlabel(\"Date\", fontsize=12)\n", - "plt.ylabel(\"Temperature\", fontsize=12)\n", - "plt.title(\"Seattle Weather - Temperatures (High, Low, and Average)\", fontsize=14)\n", - "\n", - "# Plot the legend\n", - "plt.legend(fontsize=10, loc='upper right')\n", + "plt.title('Seattle Weather')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Temperature (F)')\n", + "plt.legend()\n", + "plt.grid()\n", "\n", - "# Save the improved figure as 'result.jpg'\n", - "plt.savefig(\"result.jpg\", dpi=100)\n", + "# Save the figure\n", + "plt.savefig('result.jpg')\n", "\n", - "# Show the figure\n", + "# Display the plot\n", "plt.show()\n", + "\n", "```\n", "\n", - "After executing the code, you should see the improved plot with better colors, labels, and readability. The figure will be saved as `result.jpg`.\n", + "This code improves upon the previous one by adding distinct colors for the temperature max and min lines (red and blue, respectively), labeling each line, and providing proper axes labels. The result will be a plot that is more reader-friendly and easier to understand. The plot will automatically be saved as 'result.jpg' in the current directory. I will also submit these instructions to other agents.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -1153,13 +703,17 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Figure(640x480)\n", + "Figure(1000x600)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mCoder\u001b[0m (to Commander):\n", "\n", - "Great! The code execution succeeded, and the improved figure has been plotted using the updated colors, labels, and readability. The figure is saved in the `result.jpg` file. Please check the file for the updated plotted figure showing temperature high, low, and average.\n", + "Great, the code has been successfully executed and the updates have been made based on the feedback. \n", + "\n", + "You should now have a more reader-friendly plot, with clear distinction between maximum and minimum temperatures, and more evident axis labels. This updated figure is saved as `result.jpg` in your current directory.\n", + "\n", + "If you need further improvements or need assistance with something else, feel free to ask.\n", "\n", "TERMINATE\n", "\n", @@ -1168,7 +722,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1185,81 +739,56 @@ "Improve \n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[34mCriticize the input figure. How to replot the figure so it will be better? Find bugs and issues for the figure. If you think the figures is good enough, then simply say NO_ISSUES\n", - "###Human: Improve \n", - "###Assistant: The input figure shows a graph with three different colored lines, representing temperature high, temperature low, and temperature average. The graph is labeled \"Seattle Weather - Temperature High and Low.\" However, the graph is not well-organized, and the lines are not clearly distinguishable.\n", - "\n", - "To improve the figure, one could use a more visually appealing color scheme for the lines, such as different shades of blue, green, and orange. Additionally, the labels for the temperature high, temperature low, and temperature average could be placed above or below the respective lines to make them more easily readable. The graph could also benefit from a clear title and axis labels to provide more context and information about the data being displayed.\n", - "###Human: Improve \n", - "\n", - "###Assistant: \u001b[0m\n", - "\u001b[33mCritics\u001b[0m (to Commander):\n", - "\n", - "To improve the figure, one could use a more visually appealing color scheme for the lines, such as different shades of blue, green, and orange. Additionally, the labels for the temperature high, temperature low, and temperature average could be placed above or below the respective lines to make them more easily readable. The graph could also benefit from a clear title and axis labels to provide more context and information about the data being displayed.\n", - "\n", - "--------------------------------------------------------------------------------\n", "\u001b[33mCommander\u001b[0m (to Coder):\n", "\n", "Here is the feedback to your figure. Please improve! Save the result to `result.jpg`\n", - "To improve the figure, one could use a more visually appealing color scheme for the lines, such as different shades of blue, green, and orange. Additionally, the labels for the temperature high, temperature low, and temperature average could be placed above or below the respective lines to make them more easily readable. The graph could also benefit from a clear title and axis labels to provide more context and information about the data being displayed.\n", + "Improve \n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mCoder\u001b[0m (to Commander):\n", "\n", - "Thank you for the feedback. I misunderstood the part about placing the labels above or below the respective lines. I will implement the necessary changes and generate the figure again. Here's the plan:\n", + "I apologize for the misunderstanding, but without more specific feedback about the figure, it's difficult to understand what improvements are needed. As of now, the figure includes distinct colors for max and min temperatures, clear labeling of lines, and proper axis labels.\n", + "\n", + "However, if you want to improve visual clarity, you can try:\n", "\n", - "1. Improve the line style for better readability by using different line styles.\n", - "2. Annotate the points on the graph with their respective labels (high, low, and average) for better readability.\n", - "3. Keep the colors, title, and axis labels from the previous improvement.\n", + "- Changing the line style (making one of them dotted, for instance).\n", + "- Adding a title to the legend for better clarification.\n", + "- Changing the figure size for a improved view.\n", "\n", - "Please execute the following code to generate the updated figure:\n", + "Here is the modified code:\n", "\n", "```python\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "import urllib.request\n", - "import numpy as np\n", "\n", - "# Download the CSV file from the URL\n", + "# Step 1: Load the Data\n", "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n", - "urllib.request.urlretrieve(url, \"seattle-weather.csv\")\n", - "\n", - "# Read the CSV file using pandas\n", - "data = pd.read_csv(\"seattle-weather.csv\")\n", - "\n", - "# Calculate temperature average\n", - "data[\"temp_avg\"] = (data[\"temp_max\"] + data[\"temp_min\"]) / 2\n", + "data = pd.read_csv(url)\n", "\n", - "# Plot the temperature high, low, and average using matplotlib with better colors\n", - "plt.plot(data[\"date\"], data[\"temp_max\"], color=\"darkorange\", label=\"Temperature High\", linestyle='--')\n", - "plt.plot(data[\"date\"], data[\"temp_min\"], color=\"dodgerblue\", label=\"Temperature Low\", linestyle='-.')\n", - "plt.plot(data[\"date\"], data[\"temp_avg\"], color=\"mediumseagreen\", label=\"Temperature Average\", linestyle='-')\n", + "# Step 2: Parse the date to datetime format\n", + "data['date'] = pd.to_datetime(data['date'])\n", "\n", - "# Improve the title and axis labels\n", - "plt.xlabel(\"Date\", fontsize=12)\n", - "plt.ylabel(\"Temperature\", fontsize=12)\n", - "plt.title(\"Seattle Weather - Temperatures (High, Low, and Average)\", fontsize=14)\n", + "# Step 3: Plot the Data\n", + "plt.figure(figsize=(12,8))\n", + "plt.plot(data['date'], data['temp_max'], 'r-', label='Temp Max')\n", + "plt.plot(data['date'], data['temp_min'], 'b--', label='Temp Min')\n", "\n", - "# Add labels for some data points\n", - "num_labels = 5\n", - "label_indices = np.linspace(0, len(data) - 1, num_labels, dtype=int)\n", + "plt.title('Seattle Weather')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Temperature (F)')\n", + "plt.legend(title='Temperature')\n", "\n", - "for i in label_indices:\n", - " plt.text(data.loc[i, \"date\"], data.loc[i, \"temp_max\"], \"High\", fontsize=8, verticalalignment=\"bottom\", horizontalalignment=\"left\")\n", - " plt.text(data.loc[i, \"date\"], data.loc[i, \"temp_min\"], \"Low\", fontsize=8, verticalalignment=\"top\", horizontalalignment=\"left\")\n", - " plt.text(data.loc[i, \"date\"], data.loc[i, \"temp_avg\"], \"Avg\", fontsize=8, verticalalignment=\"baseline\", horizontalalignment=\"left\")\n", + "plt.grid()\n", "\n", - "# Plot the legend\n", - "plt.legend(fontsize=10, loc='upper right')\n", + "# Save the figure\n", + "plt.savefig('result.jpg')\n", "\n", - "# Save the improved figure as 'result.jpg'\n", - "plt.savefig(\"result.jpg\", dpi=100)\n", - "\n", - "# Show the figure\n", + "# Display the plot\n", "plt.show()\n", + "\n", "```\n", "\n", - "After executing the code, you should see the updated plot that addresses the concerns with labels and better readability. The figure will be saved as `result.jpg`.\n", + "This code changes the line style for the min temperature to dots for better distinction. Adjusts the figure size for a better representation and adds a title to the legend. The plot will automatically be saved as 'result.jpg' in the current directory. You are encouraged to run this code and I will also submit these instructions to other agents.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -1268,13 +797,17 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Figure(640x480)\n", + "Figure(1200x800)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mCoder\u001b[0m (to Commander):\n", "\n", - "Great! The code execution succeeded, and the updated figure has been plotted with the improved line styles and annotations for a better visualization. The figure is saved in the `result.jpg` file. Please check the file for the updated plotted figure showing temperature high, low, and average with better readability.\n", + "Great! The code has successfully executed and the plot was generated and saved as `result.jpg`. The figure now includes distinct colors for max and min temperatures, different line styles, and a clearer legend.\n", + "\n", + "You will find the figure saved as 'result.jpg' in your current directory.\n", + "\n", + "If you need any further improvements or other assistance, please let me know.\n", "\n", "TERMINATE\n", "\n", @@ -1283,7 +816,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1306,17 +839,36 @@ "source": [ "import matplotlib.pyplot as plt\n", "import time\n", + "from PIL import Image\n", + "\n", + "config_list_gpt4 = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " },\n", + ")\n", + "\n", + "gpt4_llm_config = {\"config_list\": config_list_gpt4, \"seed\": 42}\n", + "\n", + "# config_list_gpt35 = autogen.config_list_from_json(\n", + "# \"OAI_CONFIG_LIST\",\n", + "# filter_dict={\n", + "# \"model\": [\"gpt-35-turbo\", \"gpt-3.5-turbo\"],\n", + "# },\n", + "# )\n", + "\n", + "# gpt35_llm_config = {\"config_list\": config_list_gpt35, \"seed\": 42}\n", + "\n", "\n", "creator = FigureCreator(\n", " name=\"Figure Creator~\",\n", - " llm_config=llm_config\n", + " llm_config=gpt4_llm_config\n", " \n", ")\n", "\n", "user_proxy = autogen.UserProxyAgent(\n", " name=\"User\",\n", " human_input_mode=\"NEVER\",\n", - " llm_config=llm_config,\n", " max_consecutive_auto_reply=0\n", ")\n", "\n", @@ -1330,11 +882,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "f0a58827", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "if os.path.exists(\"result.jpg\"):\n", + " os.remove(\"result.jpg\") # clean up" + ] } ], "metadata": { diff --git a/setup.py b/setup.py index b9977ed5ec1..cfca8b602a6 100644 --- a/setup.py +++ b/setup.py @@ -1,12 +1,12 @@ -import setuptools import os +import setuptools + here = os.path.abspath(os.path.dirname(__file__)) with open("README.md", "r", encoding="UTF-8") as fh: long_description = fh.read() - # Get the code version version = {} with open(os.path.join(here, "autogen/version.py")) as fp: @@ -22,7 +22,6 @@ "tiktoken", ] - setuptools.setup( name="pyautogen", version=__version__, @@ -52,6 +51,7 @@ "mathchat": ["sympy", "pydantic==1.10.9", "wolframalpha"], "retrievechat": ["chromadb", "sentence_transformers", "pypdf", "ipython"], "teachable": ["chromadb"], + "lmm": ["replicate", "pillow"], }, classifiers=[ "Programming Language :: Python :: 3", diff --git a/test/agentchat/contrib/test_llava.py b/test/agentchat/contrib/test_llava.py new file mode 100644 index 00000000000..570791a70ec --- /dev/null +++ b/test/agentchat/contrib/test_llava.py @@ -0,0 +1,129 @@ +import unittest +from unittest.mock import MagicMock, patch + +import pytest + +import autogen + +try: + from autogen.agentchat.contrib.llava_agent import ( + LLaVAAgent, + _llava_call_binary_with_config, + llava_call, + llava_call_binary, + ) +except ImportError: + skip = True +else: + skip = False + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestLLaVAAgent(unittest.TestCase): + def setUp(self): + self.agent = LLaVAAgent( + name="TestAgent", + llm_config={ + "timeout": 600, + "seed": 42, + "config_list": [{"model": "llava-fake", "base_url": "localhost:8000", "api_key": "Fake"}], + }, + ) + + def test_init(self): + self.assertIsInstance(self.agent, LLaVAAgent) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestLLavaCallBinaryWithConfig(unittest.TestCase): + @patch("requests.post") + def test_local_mode(self, mock_post): + # Mocking the response of requests.post + mock_response = MagicMock() + mock_response.iter_lines.return_value = [b'{"text":"response text"}'] + mock_post.return_value = mock_response + + # Calling the function + output = _llava_call_binary_with_config( + prompt="Test Prompt", + images=[], + config={"base_url": "http://0.0.0.0/api", "model": "test-model"}, + max_new_tokens=1000, + temperature=0.5, + seed=1, + ) + + # Verifying the results + self.assertEqual(output, "response text") + mock_post.assert_called_once_with( + "http://0.0.0.0/api/worker_generate_stream", + headers={"User-Agent": "LLaVA Client"}, + json={ + "model": "test-model", + "prompt": "Test Prompt", + "max_new_tokens": 1000, + "temperature": 0.5, + "stop": "###", + "images": [], + }, + stream=False, + ) + + @patch("replicate.run") + def test_remote_mode(self, mock_run): + # Mocking the response of replicate.run + mock_run.return_value = iter(["response ", "text"]) + + # Calling the function + output = _llava_call_binary_with_config( + prompt="Test Prompt", + images=["image_data"], + config={"base_url": "http://remote/api", "model": "test-model"}, + max_new_tokens=1000, + temperature=0.5, + seed=1, + ) + + # Verifying the results + self.assertEqual(output, "response text") + mock_run.assert_called_once_with( + "http://remote/api", + input={"image": "data:image/jpeg;base64,image_data", "prompt": "Test Prompt", "seed": 1}, + ) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestLLavaCall(unittest.TestCase): + @patch("autogen.agentchat.contrib.llava_agent.llava_formater") + @patch("autogen.agentchat.contrib.llava_agent.llava_call_binary") + def test_llava_call(self, mock_llava_call_binary, mock_llava_formater): + # Set up the mocks + mock_llava_formater.return_value = ("formatted prompt", ["image1", "image2"]) + mock_llava_call_binary.return_value = "Generated Text" + + # Set up the llm_config dictionary + llm_config = { + "config_list": [{"api_key": "value", "base_url": "localhost:8000"}], + "max_new_tokens": 2000, + "temperature": 0.5, + "seed": 1, + } + + # Call the function + result = llava_call("Test Prompt", llm_config) + + # Check the results + mock_llava_formater.assert_called_once_with("Test Prompt", order_image_tokens=False) + mock_llava_call_binary.assert_called_once_with( + "formatted prompt", + ["image1", "image2"], + config_list=llm_config["config_list"], + max_new_tokens=2000, + temperature=0.5, + seed=1, + ) + self.assertEqual(result, "Generated Text") + + +if __name__ == "__main__": + unittest.main() diff --git a/test/agentchat/contrib/test_lmm.py b/test/agentchat/contrib/test_lmm.py new file mode 100644 index 00000000000..89ef62ccced --- /dev/null +++ b/test/agentchat/contrib/test_lmm.py @@ -0,0 +1,83 @@ +import unittest +from unittest.mock import MagicMock + +import pytest + +import autogen +from autogen.agentchat.agent import Agent + +try: + from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent +except ImportError: + skip = True +else: + skip = False + + +base64_encoded_image = ( + "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" + "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" +) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestMultimodalConversableAgent(unittest.TestCase): + def setUp(self): + self.agent = MultimodalConversableAgent( + name="TestAgent", + llm_config={ + "timeout": 600, + "seed": 42, + "config_list": [{"model": "gpt-4-vision-preview", "api_key": "sk-fake"}], + }, + ) + + def test_system_message(self): + # Test default system message + self.assertEqual( + self.agent.system_message, + [ + { + "type": "text", + "text": "You are a helpful AI assistant.", + } + ], + ) + + # Test updating system message + new_message = f"We will discuss in this conversation." + self.agent.update_system_message(new_message) + self.assertEqual( + self.agent.system_message, + [ + {"type": "text", "text": "We will discuss "}, + {"type": "image_url", "image_url": {"url": base64_encoded_image}}, + {"type": "text", "text": " in this conversation."}, + ], + ) + + def test_message_to_dict(self): + # Test string message + message_str = "Hello" + expected_dict = {"content": [{"type": "text", "text": "Hello"}]} + self.assertDictEqual(self.agent._message_to_dict(message_str), expected_dict) + + # Test list message + message_list = [{"type": "text", "text": "Hello"}] + expected_dict = {"content": message_list} + self.assertDictEqual(self.agent._message_to_dict(message_list), expected_dict) + + # Test dictionary message + message_dict = {"content": [{"type": "text", "text": "Hello"}]} + self.assertDictEqual(self.agent._message_to_dict(message_dict), message_dict) + + def test_print_received_message(self): + sender = Agent(name="SenderAgent") + message_str = "Hello" + self.agent._print_received_message = MagicMock() # Mocking print method to avoid actual print + self.agent._print_received_message(message_str, sender) + self.agent._print_received_message.assert_called_with(message_str, sender) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/test_code.py b/test/test_code.py index 32766d4d70c..18d4b640ec3 100644 --- a/test/test_code.py +++ b/test/test_code.py @@ -1,16 +1,20 @@ -import sys import os +import sys +import unittest + import pytest + import autogen from autogen.code_utils import ( + PATH_SEPARATOR, UNKNOWN, - extract_code, + WIN32, + content_str, execute_code, - infer_lang, + extract_code, improve_code, improve_function, - PATH_SEPARATOR, - WIN32, + infer_lang, ) KEY_LOC = "notebook" @@ -315,8 +319,36 @@ def _test_improve(): f.write(improvement) +class TestContentStr(unittest.TestCase): + def test_string_content(self): + self.assertEqual(content_str("simple string"), "simple string") + + def test_list_of_text_content(self): + content = [{"type": "text", "text": "hello"}, {"type": "text", "text": " world"}] + self.assertEqual(content_str(content), "hello world") + + def test_mixed_content(self): + content = [{"type": "text", "text": "hello"}, {"type": "image_url", "url": "http://example.com/image.png"}] + self.assertEqual(content_str(content), "hello") + + def test_invalid_content(self): + content = [{"type": "text", "text": "hello"}, {"type": "wrong_type", "url": "http://example.com/image.png"}] + with self.assertRaises(AssertionError) as context: + content_str(content) + self.assertIn("Wrong content format", str(context.exception)) + + def test_empty_list(self): + self.assertEqual(content_str([]), "") + + def test_non_dict_in_list(self): + content = ["string", {"type": "text", "text": "text"}] + with self.assertRaises(TypeError): + content_str(content) + + if __name__ == "__main__": # test_infer_lang() # test_extract_code() test_execute_code() # test_find_code() + unittest.main() diff --git a/test/test_img_utils.py b/test/test_img_utils.py new file mode 100644 index 00000000000..fc0053a6561 --- /dev/null +++ b/test/test_img_utils.py @@ -0,0 +1,193 @@ +import base64 +import os +import pdb +import unittest +from unittest.mock import patch + +import pytest +import requests + +try: + from PIL import Image + + from autogen.img_utils import extract_img_paths, get_image_data, gpt4v_formatter, llava_formater +except ImportError: + skip = True +else: + skip = False + + +base64_encoded_image = ( + "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" + "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" +) + +raw_encoded_image = ( + "iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" + "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" +) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestGetImageData(unittest.TestCase): + def test_http_image(self): + with patch("requests.get") as mock_get: + mock_response = requests.Response() + mock_response.status_code = 200 + mock_response._content = b"fake image content" + mock_get.return_value = mock_response + + result = get_image_data("http://example.com/image.png") + self.assertEqual(result, base64.b64encode(b"fake image content").decode("utf-8")) + + def test_base64_encoded_image(self): + result = get_image_data(base64_encoded_image) + self.assertEqual(result, base64_encoded_image.split(",", 1)[1]) + + def test_local_image(self): + # Create a temporary file to simulate a local image file. + temp_file = "_temp.png" + + image = Image.new("RGB", (60, 30), color=(73, 109, 137)) + image.save(temp_file) + + result = get_image_data(temp_file) + with open(temp_file, "rb") as temp_image_file: + temp_image_file.seek(0) + expected_content = base64.b64encode(temp_image_file.read()).decode("utf-8") + + self.assertEqual(result, expected_content) + os.remove(temp_file) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestLlavaFormater(unittest.TestCase): + def test_no_images(self): + """ + Test the llava_formater function with a prompt containing no images. + """ + prompt = "This is a test." + expected_output = (prompt, []) + result = llava_formater(prompt) + self.assertEqual(result, expected_output) + + @patch("autogen.img_utils.get_image_data") + def test_with_images(self, mock_get_image_data): + """ + Test the llava_formater function with a prompt containing images. + """ + # Mock the get_image_data function to return a fixed string. + mock_get_image_data.return_value = raw_encoded_image + + prompt = "This is a test with an image ." + expected_output = ("This is a test with an image .", [raw_encoded_image]) + result = llava_formater(prompt) + self.assertEqual(result, expected_output) + + @patch("autogen.img_utils.get_image_data") + def test_with_ordered_images(self, mock_get_image_data): + """ + Test the llava_formater function with ordered image tokens. + """ + # Mock the get_image_data function to return a fixed string. + mock_get_image_data.return_value = raw_encoded_image + + prompt = "This is a test with an image ." + expected_output = ("This is a test with an image .", [raw_encoded_image]) + result = llava_formater(prompt, order_image_tokens=True) + self.assertEqual(result, expected_output) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestGpt4vFormatter(unittest.TestCase): + def test_no_images(self): + """ + Test the gpt4v_formatter function with a prompt containing no images. + """ + prompt = "This is a test." + expected_output = [{"type": "text", "text": prompt}] + result = gpt4v_formatter(prompt) + self.assertEqual(result, expected_output) + + @patch("autogen.img_utils.get_image_data") + def test_with_images(self, mock_get_image_data): + """ + Test the gpt4v_formatter function with a prompt containing images. + """ + # Mock the get_image_data function to return a fixed string. + mock_get_image_data.return_value = raw_encoded_image + + prompt = "This is a test with an image ." + expected_output = [ + {"type": "text", "text": "This is a test with an image "}, + {"type": "image_url", "image_url": {"url": base64_encoded_image}}, + {"type": "text", "text": "."}, + ] + result = gpt4v_formatter(prompt) + self.assertEqual(result, expected_output) + + @patch("autogen.img_utils.get_image_data") + def test_multiple_images(self, mock_get_image_data): + """ + Test the gpt4v_formatter function with a prompt containing multiple images. + """ + # Mock the get_image_data function to return a fixed string. + mock_get_image_data.return_value = raw_encoded_image + + prompt = ( + "This is a test with images and ." + ) + expected_output = [ + {"type": "text", "text": "This is a test with images "}, + {"type": "image_url", "image_url": {"url": base64_encoded_image}}, + {"type": "text", "text": " and "}, + {"type": "image_url", "image_url": {"url": base64_encoded_image}}, + {"type": "text", "text": "."}, + ] + result = gpt4v_formatter(prompt) + self.assertEqual(result, expected_output) + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestExtractImgPaths(unittest.TestCase): + def test_no_images(self): + """ + Test the extract_img_paths function with a paragraph containing no images. + """ + paragraph = "This is a test paragraph with no images." + expected_output = [] + result = extract_img_paths(paragraph) + self.assertEqual(result, expected_output) + + def test_with_images(self): + """ + Test the extract_img_paths function with a paragraph containing images. + """ + paragraph = ( + "This is a test paragraph with images http://example.com/image1.jpg and http://example.com/image2.png." + ) + expected_output = ["http://example.com/image1.jpg", "http://example.com/image2.png"] + result = extract_img_paths(paragraph) + self.assertEqual(result, expected_output) + + def test_mixed_case(self): + """ + Test the extract_img_paths function with mixed case image extensions. + """ + paragraph = "Mixed case extensions http://example.com/image.JPG and http://example.com/image.Png." + expected_output = ["http://example.com/image.JPG", "http://example.com/image.Png"] + result = extract_img_paths(paragraph) + self.assertEqual(result, expected_output) + + def test_local_paths(self): + """ + Test the extract_img_paths function with local file paths. + """ + paragraph = "Local paths image1.jpeg and image2.GIF." + expected_output = ["image1.jpeg", "image2.GIF"] + result = extract_img_paths(paragraph) + self.assertEqual(result, expected_output) + + +if __name__ == "__main__": + unittest.main() diff --git a/website/blog/2023-11-06-LMM-Agent/img/teaser.png b/website/blog/2023-11-06-LMM-Agent/img/teaser.png new file mode 100644 index 00000000000..60f7fa6d1f8 Binary files /dev/null and b/website/blog/2023-11-06-LMM-Agent/img/teaser.png differ diff --git a/website/blog/2023-11-06-LMM-Agent/index.mdx b/website/blog/2023-11-06-LMM-Agent/index.mdx new file mode 100644 index 00000000000..452079f1c45 --- /dev/null +++ b/website/blog/2023-11-06-LMM-Agent/index.mdx @@ -0,0 +1,77 @@ +--- +title: Multimodal with GPT-4V and LLaVA +authors: beibinli +tags: [LMM, multimodal] +--- + +![LMM Teaser](img/teaser.png) + +**In Brief:** +* Introducing the **Multimodal Conversable Agent** and the **LLaVA Agent** to enhance LMM functionalities. +* Users can input text and images simultaneously using the `` tag to specify image loading. +* Demonstrated through the [GPT-4V notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_lmm_gpt-4v.ipynb). +* Demonstrated through the [LLaVA notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_lmm_llava.ipynb). + +## Introduction +Large multimodal models (LMMs) augment large language models (LLMs) with the ability to process multi-sensory data. + +This blog post and the latest AutoGen update concentrate on visual comprehension. Users can input images, pose questions about them, and receive text-based responses from these LMMs. +We support the `gpt-4-vision-preview` model from OpenAI and `LLaVA` model from Microsoft now. + +Here, we emphasize the **Multimodal Conversable Agent** and the **LLaVA Agent** due to their growing popularity. +GPT-4V represents the forefront in image comprehension, while LLaVA is an efficient model, fine-tuned from LLama-2. + +## Installation +Incorporate the `lmm` feature during AutoGen installation: + +```bash +pip install "pyautogen[lmm]" +``` + +Subsequently, import the **Multimodal Conversable Agent** or **LLaVA Agent** from AutoGen: + +```python +from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent # for GPT-4V +from autogen.agentchat.contrib.llava_agent import LLaVAAgent # for LLaVA +``` + +## Usage + +A simple syntax has been defined to incorporate both messages and images within a single string. + +Example of an in-context learning prompt: + +```python +prompt = """You are now an image classifier for facial expressions. Here are +some examples. + + depicts a happy expression. + represents a sad expression. + portrays a neutral expression. + +Now, identify the facial expression of this individual: +""" + +agent = MultimodalConversableAgent() +user = UserProxyAgent() +user.initiate_chat(agent, message=prompt) +``` + +The `MultimodalConversableAgent` interprets the input prompt, extracting images from local or internet sources. + +## Advanced Usage +Similar to other AutoGen agents, multimodal agents support multi-round dialogues with other agents, code generation, factual queries, and management via a GroupChat interface. + +For example, the `FigureCreator` in our [GPT-4V notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_lmm_gpt-4v.ipynb) and [LLaVA notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_lmm_llava.ipynb) integrates two agents: a coder (an AssistantAgent) and critics (a multimodal agent). +The coder drafts Python code for visualizations, while the critics provide insights for enhancement. Collaboratively, these agents aim to refine visual outputs. +With `human_input_mode=ALWAYS`, you can also contribute suggestions for better visualizations. + +## Reference +- [GPT-4V System Card](https://openai.com/research/gpt-4v-system-card) +- [LLaVA GitHub](https://github.com/haotian-liu/LLaVA) + +## Future Enhancements + +For further inquiries or suggestions, please open an issue in the [AutoGen repository](https://github.com/microsoft/autogen/) or contact me directly at beibin.li@microsoft.com. + +AutoGen will continue to evolve, incorporating more multimodal functionalities such as DALLE model integration, audio interaction, and video comprehension. Stay tuned for these exciting developments. diff --git a/website/blog/authors.yml b/website/blog/authors.yml index 0793230bfd9..d2fefc887cc 100644 --- a/website/blog/authors.yml +++ b/website/blog/authors.yml @@ -33,3 +33,9 @@ rickyloynd-microsoft: title: Senior Research Engineer at Microsoft url: https://github.com/rickyloynd-microsoft image_url: https://github.com/rickyloynd-microsoft.png + +beibinli: + name: Beibin Li + title: Senior Research Engineer at Microsoft + url: https://github.com/beibinli + image_url: https://github.com/beibinli.png diff --git a/website/docs/Installation.md b/website/docs/Installation.md index 05a4b6bd34a..d03e50c1b50 100644 --- a/website/docs/Installation.md +++ b/website/docs/Installation.md @@ -115,6 +115,18 @@ Example notebooks: [Automated Code Generation and Question Answering with Qdrant based Retrieval Augmented Agents](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_qdrant_RetrieveChat.ipynb) +- #### Large Multimodal Model (LMM) Agents + +We offered Multimodal Conversable Agent and LLaVA Agent. Please install with the [lmm] option to use it. +```bash +pip install "pyautogen[lmm]" +``` + +Example notebooks: + +[LLaVA Agent](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_lmm_llava.ipynb) + + - #### mathchat `pyautogen<0.2` offers an experimental agent for math problem solving. Please install with the [mathchat] option to use it.