From 6e685a32492b54da7565c8557cb3638988d9e6cf Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 19 Dec 2023 11:09:39 -0800 Subject: [PATCH 1/9] Change defualt model for `lmm` --- autogen/agentchat/contrib/multimodal_conversable_agent.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/autogen/agentchat/contrib/multimodal_conversable_agent.py b/autogen/agentchat/contrib/multimodal_conversable_agent.py index 9a8c36591e9d..e6f3720186c5 100644 --- a/autogen/agentchat/contrib/multimodal_conversable_agent.py +++ b/autogen/agentchat/contrib/multimodal_conversable_agent.py @@ -16,9 +16,14 @@ def colored(x, *args, **kwargs): from autogen.code_utils import content_str DEFAULT_LMM_SYS_MSG = """You are a helpful AI assistant.""" +DEFAULT_MODEL = "gpt-4-vision-preview" class MultimodalConversableAgent(ConversableAgent): + DEFAULT_CONFIG = { + "model": DEFAULT_MODEL, + } + def __init__( self, name: str, From 70e982b8571490f8d404c888db38dce817737021 Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 2 Jan 2024 15:55:22 -0800 Subject: [PATCH 2/9] Try to use PIL image for LMM's _oai_messages --- autogen/agentchat/contrib/img_utils.py | 148 +++++- .../contrib/multimodal_conversable_agent.py | 52 ++- notebook/agentchat_lmm_gpt-4v.ipynb | 435 +++++++++++------- notebook/plot_temperatures.py | 30 ++ notebook/plot_temperatures_improved.py | 41 ++ test/agentchat/contrib/test_img_utils.py | 71 ++- 6 files changed, 587 insertions(+), 190 deletions(-) create mode 100644 notebook/plot_temperatures.py create mode 100644 notebook/plot_temperatures_improved.py diff --git a/autogen/agentchat/contrib/img_utils.py b/autogen/agentchat/contrib/img_utils.py index 4fc08f8f3576..9a5f1f61a817 100644 --- a/autogen/agentchat/contrib/img_utils.py +++ b/autogen/agentchat/contrib/img_utils.py @@ -1,5 +1,7 @@ import base64 +import copy import mimetypes +import os import re from io import BytesIO from typing import Any, Dict, List, Optional, Tuple, Union @@ -8,17 +10,59 @@ from PIL import Image -def get_image_data(image_file: str, use_b64=True) -> bytes: +def get_pil_image(image_file: str) -> Image.Image: + """ + Loads an image from a file and returns a PIL Image object. + + Parameters: + image_file (str): The filename, URL, URI, or base64 string of the image file. + + Returns: + Image.Image: The PIL Image object. + """ if image_file.startswith("http://") or image_file.startswith("https://"): + # A URL file response = requests.get(image_file) - content = response.content + content = BytesIO(response.content) + image = Image.open(content) elif re.match(r"data:image/(?:png|jpeg);base64,", image_file): - return re.sub(r"data:image/(?:png|jpeg);base64,", "", image_file) + # A URI. Remove the prefix and decode the base64 string. + base64_data = re.sub(r"data:image/(?:png|jpeg);base64,", "", image_file) + image = _to_pil(base64_data) + elif os.path.exists(image_file): + # A local file + image = Image.open(image_file) else: - image = Image.open(image_file).convert("RGB") - buffered = BytesIO() - image.save(buffered, format="PNG") - content = buffered.getvalue() + # base64 encoded string + image = _to_pil(image_file) + + return image.convert("RGB") + + +def get_image_data(image_file: str, use_b64=True) -> bytes: + """ + Loads an image and returns its data either as raw bytes or in base64-encoded format. + + This function first loads an image from the specified file, URL, or base64 string using + the `get_pil_image` function. It then saves this image in memory in PNG format and + retrieves its binary content. Depending on the `use_b64` flag, this binary content is + either returned directly or as a base64-encoded string. + + Parameters: + image_file (str): The path to the image file, a URL to an image, or a base64-encoded + string of the image. + use_b64 (bool): If True, the function returns a base64-encoded string of the image data. + If False, it returns the raw byte data of the image. Defaults to True. + + Returns: + bytes: The image data in raw bytes if `use_b64` is False, or a base64-encoded string + if `use_b64` is True. + """ + image = get_pil_image(image_file) + + buffered = BytesIO() + image.save(buffered, format="PNG") + content = buffered.getvalue() if use_b64: return base64.b64encode(content).decode("utf-8") @@ -72,6 +116,22 @@ def llava_formatter(prompt: str, order_image_tokens: bool = False) -> Tuple[str, return new_prompt, images +def pil_to_data_uri(image: Image.Image) -> str: + """ + Converts a PIL Image object to a data URI. + + Parameters: + image (Image.Image): The PIL Image object. + + Returns: + str: The data URI string. + """ + buffered = BytesIO() + image.save(buffered, format="PNG") + content = buffered.getvalue() + return convert_base64_to_data_uri(base64.b64encode(content).decode("utf-8")) + + def convert_base64_to_data_uri(base64_image): def _get_mime_type_from_data_uri(base64_image): # Decode the base64 string @@ -92,16 +152,19 @@ def _get_mime_type_from_data_uri(base64_image): return data_uri -def gpt4v_formatter(prompt: str) -> List[Union[str, dict]]: +def gpt4v_formatter(prompt: str, img_format: str = "uri") -> List[Union[str, dict]]: """ Formats the input prompt by replacing image tags and returns a list of text and images. - Parameters: + Args: - prompt (str): The input string that may contain image tags like . + - img_format (str): what image format shoule be used. One of "uri", "url", "pil". Returns: - List[Union[str, dict]]: A list of alternating text and image dictionary items. """ + assert img_format in ["uri", "url", "pil"] + output = [] last_index = 0 image_count = 0 @@ -114,7 +177,15 @@ def gpt4v_formatter(prompt: str) -> List[Union[str, dict]]: image_location = match.group(1) try: - img_data = get_image_data(image_location) + if img_format == "pil": + img_data = get_pil_image(image_location) + elif img_format == "uri": + img_data = get_image_data(image_location) + img_data = convert_base64_to_data_uri(img_data) + elif img_format == "url": + img_data = image_location + else: + raise ValueError(f"Unknown image format {img_format}") except Exception as e: # Warning and skip this token print(f"Warning! Unable to load image from {image_location}, because {e}") @@ -124,7 +195,7 @@ def gpt4v_formatter(prompt: str) -> List[Union[str, dict]]: 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)}}) + output.append({"type": "image_url", "image_url": {"url": img_data}}) last_index = match.end() image_count += 1 @@ -162,9 +233,62 @@ def _to_pil(data: str) -> Image.Image: and finally creates and returns a PIL Image object from the BytesIO object. Parameters: - data (str): The base64 encoded image data string. + data (str): The encoded image data string. Returns: Image.Image: The PIL Image object created from the input data. """ return Image.open(BytesIO(base64.b64decode(data))) + + +def message_formatter_pil_to_b64(messages: List[Dict]) -> List[Dict]: + """ + Converts the PIL image URLs in the messages to base64 encoded data URIs. + + This function iterates over a list of message dictionaries. For each message, + if it contains a 'content' key with a list of items, it looks for items + with an 'image_url' key. The function then converts the PIL image URL + (pointed to by 'image_url') to a base64 encoded data URI. + + Parameters: + messages (List[Dict]): A list of message dictionaries. Each dictionary + may contain a 'content' key with a list of items, + some of which might be image URLs. + + Returns: + List[Dict]: A new list of message dictionaries with PIL image URLs in the + 'image_url' key converted to base64 encoded data URIs. + + Example Input: + [ + {'content': [{'type': 'text', 'text': 'You are a helpful AI assistant.'}], 'role': 'system'}, + {'content': [ + {'type': 'text', 'text': "What's the breed of this dog here? \n"}, + {'type': 'image_url', 'image_url': {'url': }}, + {'type': 'text', 'text': '.'}], + 'role': 'user'} + ] + + Example Output: + [ + {'content': [{'type': 'text', 'text': 'You are a helpful AI assistant.'}], 'role': 'system'}, + {'content': [ + {'type': 'text', 'text': "What's the breed of this dog here? \n"}, + {'type': 'image_url', 'image_url': {'url': }}, + {'type': 'text', 'text': '.'}], + 'role': 'user'} + ] + """ + new_messages = [] + for message in messages: + # Handle the new GPT messages format. + if isinstance(message, dict) and "content" in message and isinstance(message["content"], list): + message = copy.deepcopy(message) + # import pdb; pdb.set_trace() + for item in message["content"]: + if isinstance(item, dict) and "image_url" in item: + item["image_url"]["url"] = pil_to_data_uri(item["image_url"]["url"]) + + new_messages.append(message) + + return new_messages diff --git a/autogen/agentchat/contrib/multimodal_conversable_agent.py b/autogen/agentchat/contrib/multimodal_conversable_agent.py index e6f3720186c5..a978e8fb722d 100644 --- a/autogen/agentchat/contrib/multimodal_conversable_agent.py +++ b/autogen/agentchat/contrib/multimodal_conversable_agent.py @@ -3,7 +3,14 @@ from autogen import OpenAIWrapper from autogen.agentchat import Agent, ConversableAgent -from autogen.agentchat.contrib.img_utils import gpt4v_formatter +from autogen.agentchat.contrib.img_utils import ( + convert_base64_to_data_uri, + gpt4v_formatter, + message_formatter_pil_to_b64, + pil_to_data_uri, +) + +from ..._pydantic import model_dump try: from termcolor import colored @@ -55,6 +62,21 @@ def __init__( else (lambda x: content_str(x.get("content")) == "TERMINATE") ) + # Override the `generate_oai_reply` + def _replace_reply_func(arr, x, y): + for item in arr: + if item["reply_func"] is x: + item["reply_func"] = y + + _replace_reply_func( + self._reply_func_list, ConversableAgent.generate_oai_reply, MultimodalConversableAgent.generate_oai_reply + ) + _replace_reply_func( + self._reply_func_list, + ConversableAgent.a_generate_oai_reply, + MultimodalConversableAgent.a_generate_oai_reply, + ) + def update_system_message(self, system_message: Union[Dict, List, str]): """Update the system message. @@ -76,14 +98,14 @@ def _message_to_dict(message: Union[Dict, List, str]) -> Dict: will be processed using the gpt4v_formatter. """ if isinstance(message, str): - return {"content": gpt4v_formatter(message)} + return {"content": gpt4v_formatter(message, img_format="pil")} if isinstance(message, list): return {"content": message} if isinstance(message, dict): assert "content" in message, "The message dict must have a `content` field" if isinstance(message["content"], str): message = copy.deepcopy(message) - message["content"] = gpt4v_formatter(message["content"]) + message["content"] = gpt4v_formatter(message["content"], img_format="pil") try: content_str(message["content"]) except (TypeError, ValueError) as e: @@ -91,3 +113,27 @@ def _message_to_dict(message: Union[Dict, List, str]) -> Dict: raise e return message raise ValueError(f"Unsupported message type: {type(message)}") + + def generate_oai_reply( + self, + messages: Optional[List[Dict]] = None, + sender: Optional[Agent] = None, + config: Optional[OpenAIWrapper] = None, + ) -> Tuple[bool, Union[str, Dict, None]]: + """Generate a reply using autogen.oai.""" + client = self.client if config is None else config + if client is None: + return False, None + if messages is None: + messages = self._oai_messages[sender] + + messages_with_b64_img = message_formatter_pil_to_b64(self._oai_system_message + messages) + + # TODO: #1143 handle token limit exceeded error + response = client.create(context=messages[-1].pop("context", None), messages=messages_with_b64_img) + + # TODO: line 301, line 271 is converting messages to dict. Can be removed after ChatCompletionMessage_to_dict is merged. + extracted_response = client.extract_text_or_completion_object(response)[0] + if not isinstance(extracted_response, str): + extracted_response = model_dump(extracted_response) + return True, extracted_response diff --git a/notebook/agentchat_lmm_gpt-4v.ipynb b/notebook/agentchat_lmm_gpt-4v.ipynb index 260a22d35a92..54f9d9a61a5e 100644 --- a/notebook/agentchat_lmm_gpt-4v.ipynb +++ b/notebook/agentchat_lmm_gpt-4v.ipynb @@ -15,7 +15,7 @@ "source": [ "### Before everything starts, install AutoGen with the `lmm` option\n", "```bash\n", - "pip install \"pyautogen[lmm]~=0.2.0b4\"\n", + "pip install \"pyautogen[lmm]~=0.2.2\"\n", "```" ] }, @@ -91,6 +91,34 @@ { "cell_type": "code", "execution_count": 3, + "id": "0b7fc18e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 4]\n" + ] + } + ], + "source": [ + "x = [1, 2, gpt4_llm_config]\n", + "\n", + "\n", + "def replace(arr, x, y):\n", + " idx = arr.index(x)\n", + " if idx >= 0:\n", + " arr[idx] = y\n", + " \n", + "replace(x, gpt4_llm_config, 4)\n", + "\n", + "print(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "id": "67157629", "metadata": { "scrolled": false @@ -102,7 +130,7 @@ "text": [ "\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n", "\n", - "What's the breed of this dog? \n", + "What's the breed of this dog here? \n", ".\n", "\n", "--------------------------------------------------------------------------------\n", @@ -110,7 +138,7 @@ ">>>>>>>> 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", + "The dog in the image appears to be a Poodle or a Poodle mix, possibly a Labradoodle or Goldendoodle, given its curly coat and overall facial structure. These types of dogs are known for their curly, hypoallergenic fur and friendly disposition. The exact breed can be difficult to determine from a photo alone, especially with mixed breeds, as they can inherit various traits from each parent breed.\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -132,7 +160,7 @@ "\n", "# Ask the question with an image\n", "user_proxy.initiate_chat(image_agent, \n", - " message=\"\"\"What's the breed of this dog? \n", + " message=\"\"\"What's the breed of this dog here? \n", ".\"\"\")" ] }, @@ -148,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "73a2b234", "metadata": { "scrolled": false @@ -160,7 +188,7 @@ "text": [ "\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n", "\n", - "What is this breed? \n", + "How about this breed? \n", "\n", "\n", "Among the breeds, which one barks less?\n", @@ -170,9 +198,9 @@ ">>>>>>>> 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", + "The dog in the image is a Siberian Husky, identifiable by its thick fur, erect triangular ears, and distinctive facial 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", + "Between Siberian Huskies and Poodles (or their mixes like Labradoodles and Goldendoodles), Siberian Huskies are generally known to be less prone to barking. They are more likely to howl or talk in other vocal ways. Poodles and their mixes can vary in their tendency to bark, but they are often more vocal than Huskies in terms of barking. However, individual temperaments can vary greatly within any breed, and training also plays a significant role in a dog's vocal behavior.\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -180,7 +208,7 @@ ], "source": [ "# Ask the question with an image\n", - "user_proxy.send(message=\"\"\"What is this breed? \n", + "user_proxy.send(message=\"\"\"How about this breed? \n", "\n", "\n", "Among the breeds, which one barks less?\"\"\", \n", @@ -204,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "e8eca993", "metadata": {}, "outputs": [], @@ -307,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "977b9017", "metadata": { "scrolled": false @@ -320,7 +348,7 @@ "\u001b[33mUser\u001b[0m (to Figure Creator~):\n", "\n", "\n", - "Plot a figure by using the data from:\n", + "Plot a figure by using the data from here:\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", @@ -330,7 +358,7 @@ "\u001b[33mCommander\u001b[0m (to Coder):\n", "\n", "\n", - "Plot a figure by using the data from:\n", + "Plot a figure by using the data from here:\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", @@ -339,40 +367,44 @@ "--------------------------------------------------------------------------------\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", + "To achieve this, I will provide you with a Python script that uses the `pandas` library to read data from the CSV file located at the provided URL, and `matplotlib` to plot both the high and low temperatures. If you don't already have `pandas` and `matplotlib` installed, you will need to install them first by running `pip install pandas matplotlib`.\n", "\n", - "This is how we could do this:\n", + "Please execute the following Python code:\n", "\n", "```python\n", + "# filename: plot_temperatures.py\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", - "# Step 1: Load the Data\n", + "# URL of the CSV file\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", + "# Read the data from the URL\n", + "data = pd.read_csv(url)\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", + "# Extract the Date, Temperature High, and Temperature Low columns\n", + "dates = pd.to_datetime(data['date'])\n", + "temp_high = data['temp_max']\n", + "temp_low = data['temp_min']\n", "\n", - "plt.title('Seattle Weather')\n", + "# Plot the high and low temperatures\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(dates, temp_high, label='High Temperature', color='r')\n", + "plt.plot(dates, temp_low, label='Low Temperature', color='b')\n", "plt.xlabel('Date')\n", - "plt.ylabel('Temperature (F)')\n", + "plt.ylabel('Temperature (°C)')\n", + "plt.title('High and Low Temperatures in Seattle')\n", "plt.legend()\n", - "plt.grid()\n", + "plt.grid(True)\n", "\n", "# Save the figure\n", "plt.savefig('result.jpg')\n", "\n", - "# Display the plot\n", + "# Show 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", + "After running this script, it will output a plot of the high and low temperatures and save the figure as `result.jpg` in the current directory. Open the `result.jpg` file to view the figure.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -381,17 +413,17 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Figure(1000x600)\n", + "Figure(1000x500)\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", + "The script executed successfully, and it created a figure of the high and low temperatures from the Seattle weather dataset. You should find the figure saved as `result.jpg` in the current directory.\n", "\n", - "If you check the working directory, you should find the figure saved as `result.jpg`.\n", + "You can view this figure by opening the `result.jpg` file on your computer.\n", "\n", - "Let me know if you need help with anything else.\n", + "If there's anything more you'd like to do with this plot or if you have any other requests, please let me know.\n", "\n", "TERMINATE\n", "\n", @@ -400,7 +432,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAE9CAYAAACWQ2EXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9ebRl11Xfi3/mWnvvc25XnaqkKklWX7LlTjbuBdiAMeCAMU6CHSeExyMJbwSSN8zvB2QEXsYAxm+M8NKOxBBiTIwdetvYYIyNsWxjbMuN3Kix+lJTjapU3a2q251z9l5rzt8fa+1zT5VKcklWc2/d/dW4qnPvOWeffdZee8255vzO7xQzMzp06NChQ4cOGxbu2T6BDh06dOjQocOzi84Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02ODonIEOHTp06NBhg6NzBjp06NChQ4cNjs4Z6NChQ4cOHTY4OmegQ4cOHTp02OAonu0T6NChwyrM7DH/LiJPyfHb4zzW46cbInLW79n+/fHO5Zk6xw4dNho6Z6BDhzWCSUOoqqgqzjlUFREhxoj3HudOD+idaVxDCHjvAYgx4pwjxkhRFIQQEBGcc6cZVjNDVTGz8fHb50Vk/L72s9pjTL5n8tzbY7TfqX3uTGM+6Yy032Hyb8D4+595zh06dHjq0KUJOnRYQ5g0tiEEHnzwQW655Rbuu+++sVGEVUPZGnFg7EC0jxcWFsYGeGVlhRgjZsbhw4c5efLko4wtMDbwIQTuu+8+YowMh0P27t3LiRMnUFWWl5fZv38/o9HoNOehNeitY9Cey+LiIjFGVJVjx45x+PDh056PMT6mg2JmY8emQ4cOTx86Z6BDhzWEGCOQDOGHP/xh3vnOd3LTTTfxB3/wBzz88MOn7bRbY9oa0daR8N6zf/9+3vnOdxJCYDQa8eu//uvMz89TFAUf+tCH+PznP49zjhDC+PPa9zvnWFlZ4Vd/9VfZt28fTdPwS7/0S/ze7/0eZsbHP/5x/uRP/uQ0I90a88ljtQ7Nb/7mb3LnnXfiveeTn/wkH/zgB8evn4xotN+pjS60x22jEu25dujQ4alHlybo0GENod2ZA9x44438o3/0j3jd6143NrRN0/D+97+fO++8k507d/ITP/ETiAjvf//7OXz4MJdddhlvfetb+exnP8tf/uVfsry8zEte8hI+9alP0TQNP/iDPzg21sPhkI985CPccsstbNu2jZ/4iZ9g586dAMzNzXHttddy22238ZKXvIStW7dy4MABmqbha1/7Gt/7vd/LHXfcwZ//+Z9T1zU/9EM/xHd913fx2c9+ls9+9rOUZcmb3/xmNm3axF//9V9zzz338NrXvpbZ2VnuvPNOfuM3fgMR4Z//83/O3NwcH/nIR7j55pvZtGkTP/mTP0mMkd/7vd9j69atbNu2jX/8j/8xZVk+a9elQ4fzHV1koEOHNYof+7Ef413vehc/93M/x3ve8x6Wl5f5yEc+wgMPPMDP/uzPIiL86Z/+KVVV8YIXvICXv/zlfPnLX+aTn/wk119/PS984Qt5xzvewRve8AauuuoqfvZnf5bv+77vA1Jq4HOf+xw33XQTP/MzP8O2bdt43/veN45MOOd46Utfyq233sptt93GK1/5Sqampti7dy8PP/wwl1xyCf/pP/0n3vjGN/LjP/7j/O7v/i7z8/NceOGFvOY1r+GCCy7gP/7H/8iFF17Ii1/8Yn7iJ36Ct73tbagqp06d4u1vfzsAf/u3f8vNN9/MjTfeyM/8zM9wxRVX8D//5/9kaWmJv/3bv+VVr3oVP/IjP3Iap6BDhw5PPbrIQIcOawztzv0HfuAHeMUrXsGDDz7Iu9/9bmKMPPzww+zZs4ff/u3f5vjx41x88cXcfffdvO997+NlL3sZIsLBgwd5/vOfT7/fZ/PmzZgZRVGwdetWqqoa5+Vvv/12HnjgAd71rnexuLjI9PQ0TdNQFAVmxktf+lLe+973AvAjP/IjqCqf/vSnERGqquL222/nAx/4AADD4ZBDhw7xvve9j61btzI1NcX8/Pw4xD83N8fc3BwAr3jFK7jiiit4wQtewAMPPMDRo0fZu3cvv/3bv83y8jJFkZalK664gpe85CUURfGolEKHDh2eWnTOQIcOawhtztzM2LNnD1u2bGH37t1ceeWVLCwssHv3bmZnZ/n7f//vY2aUZcmXv/xlXvCCF/CWt7yFu+66a+xMrKyscPLkSebm5uj1eszPz7Np06bxZ1177bUcO3aMn/qpnwKgLEt6vd74+a1bt+Kc4xvf+AbveMc7CCHwjne8g7e85S1s2rSJF7zgBbz1rW9l27ZtrKyssGXLFg4cOMC//tf/mrvuuouPfvSjAPT7fRYWFhgMBhRFQVEU41RIURQ897nP5b777uOf/bN/NnZc2ooEEcF7P66K6NChw9ODzhk4B3Q7kg7PFCZLCW+//XZuvfVW6roe5/Q3bdrEH/3RH/E7v/M7TE9P88M//MO89rWv5bd+67f4b//tv3HRRRexa9cuLr30Unbv3s1//a//lZ/+6Z/mTW96E+9617t4wxvewM6dO9m2bRuvfOUrOXbsGO9+97vp9Xr8wA/8AFdeeeW46mBmZobXve51zM/PMzU1xVVXXcUVV1zBDTfcwK5du/i5n/s5PvzhDxNC4Iorrhh/zn/5L/+FXbt28YpXvALnHG9605v40Ic+xIEDB7j88svHkYmtW7cyGAy44YYbOHjwIP/rf/0vnHN8//d/P7t37+bqq68ej4f3flzG2KHDM4GNVsYq1t1dj8Jj1Tt36PBM48y5+Hh/P5tYz7kICz3WZzzW+TzeZ5zrax7r2Od6Hh06PJPYCHOycwbOgjPLnWBjTIYOHTp06HB2nO82oEsTfAuc7xOgQ4cOHTp06JyBx4CqMhgM+MpXvkLTNOO/P5au+rfCpLLcWg/GrIdzbHFmeHqtY72lntbj+K6H84RubJ9OfLtj237XXq/Ha17zGqqqeipPb02icwYeAyLCqVOn+LM/+zN+9Ed/dDw5Whb0402wMw3/wYMH2blz51m12dcCJs+3aRqOHz/Orl27AMa69msVIQSOHj06Hl9YWwvrmXPh4Ycf5qKLLqIsy9MkhdciWuni7du3j0sS2/m/FnDmgn/8+HH6/T6zs7On/X2t4uTJk4gIW7ZsWXNjC6fP3cFgwOLiItu3bx8rT661851EXdecOHGCiy66aPy3JzoXzIw/+ZM/4aUvfWnnDGxktDfBtddey/d+7/eO1c+ezOJy7733jpnRLdaiUwDpJtq3bx/XXHMNsPZ3A6rKvffey/Oe97zTGuSsNbTjeM8997B79+6zyvGuRdx3331cccUVZ22QtNZw4MABNm/ezOzs7GnSyGsVR44cQUTYvn07sHbXBBFhcXGR+fl5LrvssvHf1vLYNk3DQw89xO7du5/UutBu/L785S+PHbXzvUdG5wycBe1EaJrmUfXNT1QJbbIb3NmIiWsNk41uzuxetxYxaVDXauRlEmc284G1Pb6TfQbW8nnC6ffm5DivVUyO6Vof3zMjF2vZ8YbT76knO7Zn9us439E5A2dBK3RSluVpE2k4GrGwsESIEROHiWCAM8Xx6JBZewNJ2ePw/EmcGd6BxYiT7AyYrB5nosb8zPa1Z3aHa4//WGWQj8dRmHwOTr+xm6bBOcfRo0fZsmUL/X7/qRvYpwFnG5+1jslrtZbP+WxthdcD2tRWGtt27q+98293m2vdEYDTncL1IAD17a4Lk42/1vq1earQOQNnwaS3bmYgSiSwtHKS3lSPbdObMYTWxj76ZjYmF5/NmwNlWeDFshOgGIYhKA5UwVaN8tm6uU06BpOf175ncic0ebO2j0MIlGV52jHOfG/7XIyRpmlYXl4eOwNr9YaY7NjXYi2d69kcsTNb9a6l8z0TbWh08p5YKzhbdK093zTGgCgg+W6UVd9gfIvKs+InTBqptTi28OjxbcfWe7/mjeTZoppP9HzbY6x1x+epQucMnANUQIE6BuZmZ/DWIBioAQa+AlkdymTm29XGEBvhNaZ1xxmIIzpPxBMRCiRFDbLsakvYa/O0rZFudxHj85roQ9++Psb4qNaykwao1Z2H1RB760C0mvAti3Y0Go2P0aHD+sTEQm45emdnzudufnfo0DkD5wAxj1iBxWmiTRGcR8Qg21yHndb+8cylJRQOKR1OkpuACc4cJUKJ8Pt/8Ifcccc32b9/P9dccw0ve9nL+Ht/7+89Kgc6ifb31nFod/2tYf/whz/MN77xDf7dv/t3zM/P80u/9Ev82q/9GldffXU6xxwZmHQMJvkC30pRrkOHtQ+hdchXQwKT6TwH3bzu0AHonIFzgiOCi5TFEMcUXnwy6qTNhok8erMxgcamAMEZoErhJacIUhTh7f/k7Rx55DC/8Ru/wS/8wi/woQ99iF/7tV/jkksu4Sd/8if59//+3zM7O8vS0hLXXXcdt912G69//evZvXs3v/mbv8mmTZuYnZ3lZ37mZ5iZmcE5x7Fjx3jooYfYu3cv3/zmN1laWmJxcZFvfOMbfPSjH0Uk9ZK///77OXDgAM9//vP5yle+wj/5J//ktNB75wh0WP/I9+r4f62D28UEOnRo0TkD5wAxwZuAehopWGoCX7tnHyMT1IGnoJyIDaRFJ+/oBVYapSoDPYtce8lOdm2ZoydCYQqmKIxTAHv37uUzn/kMb3rTm/jYxz7Gd3zHd7Bv3z5+6Zd+iU996lOcOnWKf/pP/yl/8Ad/wMUXX8zCwgK//Mu/zLvf/W7uuOMOXv7yl4/TAa961av47Gc/y6FDh3j+859PWZZs2bKFV7ziFXz+85/nk5/8JG9+85v52Mc+xqc+9Sl+8Rd/kaqqxm1n12rFQ4cO54oxTzdzfJTEn/He4wycSOcQdOhA5wycIwTMgXlAGNY1X/ji11imoBHB/AzBJobS0o6/hdcBU25E1QzZ8v3fxa4tc+k1mo4t4sY78KWlJfr9PnNzc7z97W9n9+7dbNq0iR07drBz5056vR4XXnjhOD2wdetWNm3axEUXXcTCwsKYNxBC4EUvehF//Md/zHXXXUeMkeFwyB/90R+xfft2tmzZwvHjx5menmZqaorl5WUuuOCCNS0w1KHDE8JqwQ4AQSCo8ODBo1x88U5mSs/GoIZ16PCt0TkD5wBzipmCayhpuLBX8P/89D8AE0QgioE7o0vbxOPRyCi9o3CZXyDJWVDvMEBDM3YGrr76ajZv3syDDz5Iv9/nuuuuO03wpSUDxhhRVe666y7e8573cNddd/GDP/iDp72mLEt+5Vd+henpaf7wD/9w3Cd+cXGRAwcOcOWVV/L5z3+e2dlZ3v72t/Onf/qn/PRP//RZ0wJ2RoVEIkbmhwJdwPXxcObYPYG3tZDT/2ATx+tG/vGQxkwRIrAwHPG7f/B+fvKn/inPvWQH5bN7cusabQR0PP8yPcPax3RRl/WEzhk4F1iRZrj2MSuR0hPNMEnTvcAoTlu5Tw+vqzR4X1KIIKaICQ6PaxcqcWzfvp1f/MVfZMeOHfzbf/tv2b9/P9PT01x00UX8wi/8Aps3b+YNb3gDzjlmZmZ4xzveweLiItdffz3f/d3fzQ//8A+zc+fOcXXAW97yFqanp5mbm8PMePvb386WLVu4+uqr2bdvH3Nzc0xPTxNj5OUvfzlTU1McPHiQsiwJIZzxXSKYJ2Y9BG9ttUQq28JcZ5HOinaMDPC5xiT9K+24UvDYzkJONU2UxMmkQ9CFuIF29BSxBohn3ImrHqvLPJ35pmSkLo2ldcSBs+FRFZhYTn0aZmnmNgY9DGc1ggcKsADiUHNn7o86rHF0zsA5QsSABodS4PEiE8uMtA+AdM9IW79s4HPlgEMQ8ROGFMDhvKPne1x66aUAbNu2jW3bto0/u5UA7fV6Yz2ASy+9lP3793P99dfz/Oc//1G7+Z07d06cu3DxxRePf3/Ri140fjwpKnPFFVegqqc5A2IKNKg42nZNLv/diOk3cd16+phYdQYSqb0NTLfOgIPHC1aPQ93tDqydN55o4De6LbNU+ptEv2qwkFxUI03NXEkgOEoBdY6VYhtOevSebMRmg+D0wFRes3J55tIocOvBeV522Q5mbYC5PjiPaINJQXCO81/N//xC5wycA0xATTBJimZJKqi9MSz/3Z11RyJAaQO8Fog4EA+SixHF5eXoiS1IbVngpZdeyiWXXPK0Mv7T7rNAsu/vzPLCayAFiuvyro+BFC7NfJAkL0VBjTPN+jceedzROzMVMFEiZ+Alp2o2eLWHAIqnlj5BylRQKI9+TVtNYGThLjpX4DExjv49mkQsGMdPLvLuP/kkV/3cP2Rqpoe4Kos8ZV2TZ/yEO3y76JyBc8TqLSFn/A7gCTIx/eX0h4ZLi5AISLsTzByAcb3TuW/xWv2BZ0Yzvt35C4UZQkQsYOIZ4qhFmGUsudDhNLQugOX0UIPXEVgDlCjFWBnvMZMEmSsgGCaKjWtYFafABlFHOxPj+08MhzHCMXA9ailzMiAb/TPeNI7mjctmn7lzXk9IKZREJra8aRlvb8yIBstaMTJH7XsEEaaAQjzg0npgtuEd1fWEzhk4B4glToBYu8i4FBvI9tujFNZwNi8aYCgF+F52BNJ7nAhiKVRslp0EO11T+0xD30oLn80RmHQQzvb75N9aHYGz9Tg4ezmhTJRLRgwj4Ln30DGCK7j+oi3dTf8YsGzRLedbW59R1XLG4PHHbTWQHXJIvMBM8GhyKqxM0aYNiMSlSNTABuGeh+fxVZ/tU8kgqTw6ajU2aN10PQcoOSmYuC5SkFwvJZijKaahrLj/yCkOzi/yuuuek9xbSeyMLj6wvtA5A+cAySkBRwQMJZFnJnhd+ElH4DSDKkQcJo6omXDo0sD7vMv+3Oe+yKFHjowbl1x11VW86EUvGksQxxjHhr9tJCQi43rp9JGnG/b777+fI0eO8MpXvhJV5cYbb+Q1r3kNt956K9dffz1btmwBOE2K+LH6k6smX0URUIc5zxDhxi/dzvGFhhf80zdQ+G51PRscafxwHjVhYJ6Ax4nDWctFeYyxE8YpBiyCOGpLrPgKoeR0QuFGwyqbPbKsjj//228Qg3HNtqvxcpalTbKCODwDEbXzAy3jIoqjMUdj4MWzEj3RlZgpX7x9D1+65R5ueN4/xudYaGENSO/ZPv0OTwCdM3BOSNlFwfAWcCaUMQKKuOQxB6lOf/kECl2gCgGTEnUF4HJ6IDkJuy7excpgxHvf+15+/ud/nuXlZT72sY9xzTXX8LznPY+bb76Z4XAIJDLhHXfcwStf+Up6vR533XUXCwsL7Nq1i+uuu27c6OjGG2/kE5/4BO9+97u59957+dVf/VV+93d/l+3bt+Oc45ZbbqFpGk6cOMF3fdd3MTc3B5wlMmCJJxCiED3U5llcGlLOTbEUjJW4kc3R40PMQA0nQm3CIAontWLkCnoCPgI+p4oewy7Z+P8Ro2BosDCMbCkzh2MDl2+1RYMQiVKyYD1ODCLeCYKiCI8a2qwB0ulpnQNEMEsMoQZhqYnUQE+EWoW21dpQHStaUQcoSw8oRd44dSGY9YMujnMOiOII4lEcYgGpT+KGh3Cjh5HBA7jlPRSDhyZ+HqRYaX8eoFrZAyv3I4P9FM1JCh2lTLIIUHLllVfz4he/mO3bt3PxxRfz8Y9/nOnpad73vvfx0EMP8Z//83/m8OHDfOxjH+MP//APWVlZ4T3veQ+HDh3iP/yH/4CZ8Z73vIe9e/eOlQydczz/+c/nq1/9Kl/+8pd51ateBcBf/MVfcOTIEX7/93+fW2+9lT179vDRj370Mb97asikCGlB+OpdD/LO932QhRBoxBM0px/O8l6b+Nm4UDCjMfjs1+/ib750K0Npl8nwmCSt02Btl0tYHCn/4/c/yr6jJ1Ep2OiLrQigETVjSI9GCtoxP31ULaflxhVyE888+mejT9w2ImDiCMCxUyt85OOfZrlWAsIoKGJKYUodjWEURk2q5AhA522tP3SRgXOAAiqSjXckLBzjlhv/At8s4Jpl+i4gWo9fb5NMJVLRgVazrPjN7H71D7D56pcAVSKXSSLotAb8oYce4tZbb6UoCmKMLC8vs2vXLl7/+tejqkxNTXHDDTfw1a9+FTPjuuuu4/Wvfz3Hjx/ngQceYPfu3UAKg77mNa/hk5/8JFu2bOGSSy4Z/11EqKqKN77xjZw4cYJPfOITjyk9bALicytPMw6eXOa+4xFv4JxnRIm2PIUz35v/3dDmShV8yl0fOLbEgVOpEyRtFcDjbZ4se+viwFK+VhD2Hh9QZwdh40a62+ZgAq7CaebQ+BKVEieeEkUyidNZBAKNCdFlqaE2JW4QJy6FP70saINO4MSGEoMGOFE79h0fEDSlSUcxgCTNlKDGyAl1oxR5LBM5ZkMO3LpF5wycA4S2th7AUcxu5gWvewNQIzSIKrgzSFyTxnW4CFUf9XP0Nl1My7132WmwiX7mO3bs4LnPfS4/9VM/xWg04uKLLx5zBJxzeO8py3JcXrh371727t3L3XffzfOf//zTSINbtmzhRS96EVdffTU333zzmEDYkhSLohgTEtv3PdopEHCJCtTDiEWfpWo7swiFwMAK1DbwmvktIL5ARagQ1BwjN50cKcCcH1cTnPW9tHUGHhOPCPQsMvBzmBSkjtMbcweWxqYt7e1RYlQWaGKklpICoRdHBO8JlPSsARuwotMMzGPtpLVcOszqHB7f6xt8QqsmbYHl6Hh4aMzbDCcWltg6vYVhGKEopo46BIZiNGqUJrmSwG/48Vtv6JyBc4C3dFM4IiYFVFvpX7iJVm0LVxHdY0lsGKycoPCA66O+R3RF2uNldn4IkX6/zyte8Qquvvpq3vSmN/GBD3yA7du385a3vIVXv/rV9Ho9Lr/8cvr9PlVV8R3f8R0455ibm+PjH/84L37xi8c9CNoUwQUXXMANN9yAc47BYMC2bdt48YtfzJYtW3jlK1/J9PQ0IQRe8IIXnLV6YeIbTDxOPOH2CY2KmwjBjqsZ6OSKJ1nrqQRbnmTVxZnv2Yhj+RgQAWv5PBGP4lHEPBO1A4BDXY/gBOdWp2Qr5lRY65blVIKsHn+jjraIEU34my/cxnv/7gEWlyJ7HjnCFTu3YDGMI6AhRIIqQeM44tWpY64/dM7AOWDM5iaVdkXXI+QYriH4XGzYTv7Ts5XC0G8i9ipCbkxUAIWAt4hYpPCe2dlZ3va2tyEivPa1r+V1r3sdqopzjre97W0AvPKVrxwb2x//8R9nz549POc5z+Ff/at/dVrZIMANN9wArJYjvvGNb6RpGi699FKcc/zYj/0Yzjk2b97MJZdcclpJ4rdC+qz0OIaG1YbMbvzdZTIxu5HlitsdpoC4jUz3e+ph4sYROMn3oDfN92IrEJZG3FzByApqAmYBQ1NpZw51OyV5AC45CJZDA48XuTm/ke7pBs+9B4/w8FCQco5HFgKKoRpWZYljRNVogo6pFh0Zbf2hcwbOAZbTAzGbfQGck3HKMf21OdubIEcAhOQAJJGUdplxmS+QcsqTZX7k3x+rlbCIcNVVV/Ev/+W/HJcgnhnqV1WKohg/VxTF+Ln22MBp721/vpWqYVRDswOyStYyzATTVE8vrYqZbOSloa1BTY6aiWQy4JNzC9odrW5IA7UKyyVsrdlxgDPFstOeNq1ZJtuMBuHzt93HntBLjcI09TAwi3g8WL5vomG+5WNs3Ly3AGoGTtDeDIsExALHVxpCGrh8DYQQFbW03qRoCxOhlQ7rBZ0zcA5QcWnii8NUEY2UAoxzlgWB/mnvkfFNYThdpIr5/Zb6EyTxjlRNkJyL9L5WNyAdQ0779/TjC71ej16v95ivP9djne35NtIAjJfdiVcTo6E2eTwhIsQssuPUKJycdowNiYnx9s6RfKccjH5Sg5Kz5RuTKnAGTh/ARCAsaEzwIhTmxy7XUlA+9sVvsjS3bTUyQFswLFjy1xAnSVejzTJs3ImLuFStkgjUHueMwbBun037HYEQNI1hy8Mgp8M27NitT3TOwDkh1yv7guFwiJOKwiXzl5yBdvVYRbtWmxkSG7RRxDk0ghRVlvj0E+vNs7e6n6ly2DQNdV2PIwln5REYbc+SvNt1yRmQFDEoRVAb7806ZLRlmK3z94TsjbWVKrZa/sYTOcD5jahGFEeUgkEA7wrEAg7HyIyjI4dsqmh7iqTQgKAiBAfBUreIQjyEJrURgY07vuZAUhq00AYnMZGlgRiTU6tGThuA5p4bCRt10NYvOmfgHCAYhQib52ZZOHWKkwt1zgK0neSWs5Lc5HvSM6rKyROn2LJlC87l/CXLtO9uQ23PNtrUQAiB5eVlNm/ezObNmx/lCKS0QPpXc6jQslsUgYePnuKrN3+DH/2h1+WdsK2Bb/ftoE2APDbj/5whSQEvdbVkQrp9sq3V43+GjR2CJ/LB5x/SfXTGIDhPE42Hjy5w08338GPfcz2bp5M7qsBy9PTwYIpZKjtEk5jWUlA+/YWvcvnFO3jp7ivxVqSLdb4qa9pZxi+HACe/sQMKi1RW400RDTgganIEglpKGaoR2jRBjgy0Dus4siipSmP8+Bn4mh3OHZ0zcA5wAmZKWfjUWtidLhXzeOZcDeYXBmy+YEcq5aPtBgaT7LJnc22fNPjD4ZCVlZWxUmHeiKbaYcCpohIZ4BhZiZCUEWM2bA8eOsWNtz7Im37gteBkndfB2yr3Qzjtyp2rC5cMvmIoNUYtnhjBOc15pLRCple4Mas95qV68gY1JEcWUij73M/ifER7bVI0wICY2uaxZ98hPvTZr/I9r3kem6amkwXCGDaRniWWT8xdRp1LI73cBD7ypXt5w8sdL7/yMgRBvRvfoecrIhGvHnNgWV3VxAMBo6CtvXRmVKIE9TggmEMwFE1N2rSkQVCLYI5BLkeuomZSpmAmOCPP942tnrkW0TkD5wQZs/ThHDZlOYzbmnnRQOlddioAcclIjg/07BrNMwmKrabB6nOOKIaY4GPECKwYjKzEUacGTpL6xQ+lYN5fgJPzpVHJqvnXid9axkf73GNDEGpEjKEZI1cQA+BrkBK0AB8xS3LDhkMs57AlThij9ImJtJm5GRuamJnurTQbszAYSiUwisZJP0ctDodDUbwZsWlABdWCOL4Ha4os7HxSdjBgGmcrBN8niqd3PlsrheiyMyCgEnDmM6k5OQOJC+gwKSg9DLTEAxHBqxFRavFYKKiDohKQUPDg/Ck2TU9xSa8PIRDLIjlfOTKg0jY/P58HeH1hY68mTxLyLX7gXKZ4S7JZD/GynMzIERIsImoQFfeo5kZZqfG8kSPNV9VWG097DNeSJs7Utn2c4yTGtY1rsdVJ2pEheFFK6uRymFGglNacJWaUP+98Gd6nAGemUSIQpN3Vp7nrIKcHGAcVnIFohcsGzmGoGHglOkPX/H357WPSALQVTgGh3Se2RcMAvapKgmWAaU4RWps6NFRjGm0n/Nlf/jVf++a9KfjlPG1Ckdx4y3HmutHh2UbnDHR4fAg5zBoRLFdTaCobDElY6PxdM7Ozlh2CtFRaLpnU3NL68a1yrtHALHUtNM1FceIZ4hgJDHGEvPgqgjrAwmMmAca9IDayQzDx3Vtjn3gYQjBoJpQ/2iBcqohLY9deOZWSkNVDU39Rzektd3on0vMRkrutSkoDSi51HgLR0k4+qtE0yXD3er1xZ1PL/6ql+8FU0ahAilot18aIikYZV9SM57K1LaQ6rCV0zkCHx8c4Tq1jzx4EVcNUUn325MstSR2bnFMLnjUPy5GOFMBZzVOrGmr6mMTCiQOA5TbWlrpVWjQaFe47vMB988t88f5D3Hz3AUZa8chKzZ0HjhIV1CrUTq9S0fH4P13feB3BHEl9cDUlZxjBoMZz377jBEtubO4xippLVT2qBBH2LQ+46/BJajPMIqUIaEkRobQJzsh5htXkl4EYkeQMrNSRWx86yFDTPIuxdQZSP5NWW0TNMEnzUHWVCm0iBBFqKwi+PK3nw+oHn59jut7ROQMdviXaG7kNGao4ahxBCmplNXRIfnxeirWM95bZQfBEyomKkMd4lxkmEKLQKMSQ+AG1CH9y45d5119+iXd97FZ+/6++zIlB4JYDx/i9j36BmpJwBjMB0o7svMrCPGm0u00ZR6eSM6BEM5ZGkT+/8avMLw8ZGDQGQQqCeRCPqtIAH735dn7rzz7JySZgSOYY9MDcWCzsfEWrg2KWOg2aCvsOzvO/PvQ3LNVxbLJDkk6lqqpxZMXGTqmmlIEqURUzRzSozWHOIX7SWWsxqdfaYa2gcwY6fGtoDpCboCYE8azUkRPDSOM855/hPxvaQixHMGGgxoDcrvXx30ZUw3JXN4dgMe3DHlkY8sig4ZSf4URd0JjxyJKwLL0sXc1ZhdzaDevZG0dvPEwaGzNQ55Gqz6mRsoIwNOHEMKKuSokAtbE6Zk3FqcYnEaeioBFh0YQVMj/mfEXesZM2/fkfR22OE9GxNEpzy0xpmiQ01Ov10Ng6o6kigLEjplmBMKdp9HQhjXFHE0mOtHamZ82huyIdvjUMci8yGoNIwZdvvZ/79h+iFrchlEfT0pjCzQG48XM38+kv3k78Vm90afe6MgrsO3CMGNI7IkLjShpXMKIESsSEE4sjVuoaLEC01brsifMYV3+cB3kYO+3HVj2dc8IkWyAdRFxqqRtwxHKKxju+fs8D/NZ7P8LxxRHRJInjmFEaUIPWjiQ46KlF+Ksv3c5nv/kA5vx5O7db3kSb5msNezBYGAYWBzVgmEbqukYwqsqjuRmRqqZ/x3eGoTGiksqM8zRPV+YMkm36vPMxeri+sSFKC1tp3Ztuuom77rqLSy65hO/93u/l4MGDfPrTn+bqq6/mO7/zO8dhsMn3qOq31Ok/l89vmw6tB0y2NG53EN6MBiPgCQj7jpxiJRPqmVi/U677mVPIa8e2ffztXKezQdqwqKQeE470ne8+vEhZxbEk61nPjVUnQkNkcWUZEc8ywoxAVRT4keHMsSIeFeHkwgqBklodM1nwppWuVhi3izZdTVk8nUtqO/+fjrFtYxtpV9qG+7N5yVyJx/3I8fxqSzAdIaQ56MURJLmwBx85wS0PnUSndiGuRE1wlrqQVt6hUuZ3K4MmcPDhI1xx6Q4ahN7TOLqTa036rs+ccRQzPAoutUNPoubGUjQiMwxCSEJiQRiIUrBM2RNW1DNUIChmQq2CV6hcEiAaKQxMIeZGRmJgNaKKuaIVNaSw3NnlafrO3+66cC4N2843bBhnIMbI9u3b+c7v/E7+9E//lKmpKT7ykY/w5je/mU984hNs3ryZ66+/HpfJRa0aXyvJ+0Qnx+QEbNX9Jo+x1ibb5PmeuUgpitdUcjWy5NWPYsUQo5QCl9uVRlUaVXA57CpgwZDi7M2WnqrzLsvyNGfrqf2sdKxgSZbVNOLEs+jnmK2mxzufx/rEYIp3UDpH1eux0hiLZszWDahRmcOpMir71MCJpRWiVAzxqb2u0RZlJXqcJZKcmubvaU9busDMxk2sJv/2FH4CQO4xODHnTDBnky953EOI0yTSpA6jYHHoIChR0tgW5QzL1VYMTwy52VhUsECIgeg9NVBIugdWhhC0aL/w0xZ8ObMp2DO7JhhiSnQF3qCydJ+PVKibHstBWagDFoW6LCltGacFCwYDUmmtSyojeHP0SqFWWGyU+WGDRqWpNUd7RggFCgSBCsVbDdJ72rgv3+660NqMtbZOP53YEM6ASCK67Ny5kw984AMcOXIE7z39fp9XvepVLCwscMcdd3D99dejqjz88MN85CMf4dSpU5w6dYoHHnjgCX9me4OrKkePHn1U06C1Nsna863rmlOnTo2dIl/4VJMdAwNvnDi5TAiBlcEQzBgORzz4wD7KsgCUI0eOsbS0wgMP7GPagzcdhxKfrvM+cuQI8PTsrCSzphspKK3BORiocGphGYvKnvsfoP94NdPigRFLTY+lwYhB7fnybfdw5IG7Obo4i/clg+EQryP27d3P0cOHGTXK/n0HGLACkvKwhhCk5OjiiNFgyKFDj/CAn8dZ2z3u6cHhw4eJMVKWJTHGp3iMlaRGlyIfzkj6DaSQvYnkxMzZ4SiJ0eGLIadcj0EduOehExw4chREGAxG7N1/kINHjhMpiDEwWF4ihoaDR45zX7XCiYUBK8MRDx+cZzAYcHR+iWPzJ9m+ZZb7H9hLpc1jfv63i8XFRUSEhYWFcavxZwqtiHgjPbyma+CI7Nu/gonj7756JzceP8QPv/rlnFwcUViJjIbse+hhPvOVuzl68hShqXnk8AkWl1ZoTHhkfok/+sjnqYsZlkbGieML3P/AQTaPjlMWJSvSpxFHaTWFNcQckXk6EGNkfn7+24rsmhkrKytrbq1+urAhnIHWO5ydneX7vu/7mJ+f58EHHwRWO/tNTpjt27fz1re+lUOHDvHxj3+cSy+99EmFmVqj3zQNF1100fizJtsHrxW05zsajRARdu7cuZomMCgwBhLYNFfjiyK1Ri4KisJzySU7KYoCwbjgqNLrHWbnzouY6xUpovA0rnExppzmJZdcgllqE/xULqqrzoCjsIDGSC0FVe8Is7OzXPacS+k9jrOTugvWzK8IRdXHGoefmuLA8SVs9mLKosCFSKElOy66iLK4F9PAzh0XsKu/ZaxLZQhRCqr5ZQrvuGD7dnZdPEshT99caufurl27xm21J53ap+ATgKRZEZ3gtCCKoAKVJgGgx80SaCptc1IzZUJvaoqFuuHEygriNlGWnot2XcTWow0q86mToVPUCXPbt7HjOTvo3b1Ir7fAJRdupigLZuam8VWf2ZkpLr3kYnpPozjO0aNHERG2bduWHG/vn8F1ISWegqR7NElcRzadOEww4fDCgCPzS/wfl2zHV7N4W2HHdEmoA1Y6ejMVhXds3jzDzOwsbskoZ2c5eP+DxNlZYjHNppk5du68kC26BTHFyj7B5WbwFjGePvJxXdeYGZdccsl4/X+i60LTNPT7qRvt05MmW1vYEM5Au8u95ZZbmJubw8yYnp5mOBzyhS98ga985Sv8g3/wD8bGu9/v0+/3iTGO2wQ/2YlgZhRFwfT0NMBpUr9rFVVVMTU1NTauBkgMSFGNC+m892iMCAW9Xo+qTDe2E8E7R9Wr6PeKrEX+9J1re6NPnu9Ti2ToPYInh8w1LSxFUdCrqseVrG0rEKpoiC9Tn0vvsaJCi2RqnAdMcOKJllpDV1VBr1clXXfLDG48pfdUpcc5T39q+mm/gdsIWlEU47D2U4XEDUhy3eoFZwUngxI0Ml1UUHzrrpdqQDCmJPUbGOLQssRi4ngURQlVH/MFGgYUXhk5YSAFiyZI1UtjWTh8URAQhlEpK0+/V1I9Zd/20aiqdPTW4DyzxialmDwOn+/RGGOSJXYlQ0qW3RRFVWKuwiiYK9P1H5ggXsAivdIRMVzVwwpPKCqCn6ahhytKoghWTtErHDiSjgOWFQifvnWwXWf7/f6TXhfKshw7v+e7IwAbxBloQ0VHjhzhq1/9Ki95yUu44YYbeOELX8hNN93Ed3/3d3PdddeN8/pnToAnugieLazUTs5ngyz0rXC2nHB782j2iMU5oJXfhRBidp7a7yL59aneeJLWJqm26GnB5LVpz/kpHds2DJ+sMSJpPjVNs1p6Jmcn8bXGDlKvgWgpHNsK4CCp2YuZERWaGBg2ilpBbRBwpGotyS1jkviRqSYFuDOV3Z5itLuhSQf2qRzbCIk02DLaDW66/X7ufuA+/u+3/D0Mw8nZ3YH29YjhnAeFBkGKgmFbyBabJDFsRjSYKjyhHhKd5+9uP8CXbvoisuNKYkhti0yNxqCOqYTW5Xn7dIzv5Dowuc48YzitSiXPUTNCiARzDIPDXD83JUrS2aWkKNlAfb4vNEkQC/iyoFYhugJ1nhqhFsd7P3gjb3zNC3nxlZeuSj6TtEqezkZFT+W6sJbW6qcTG8IZEBGKouD7v//7KYpinJ+79tprufrqq8cTpw3VbYSQ0BNGW71lSX0vxvCokjeBMYP3/EYil57LHJnQZku/ayQ0OpY1dq6t3oBRiNTmCVakrpAiNJaiEmWqKcwtkG21DC8Vbz+dX/ZpQ2vQxSQr4MHhxZq98wtZLvhbfC9J49Hu+Uw8tXPU2Tn1mnpnaIip3W5sQJTahL0nhgwOHOHabZfjfA5Xi6PBUUewmNX51unYfkvkeWO57EdMcOIIUWlMGI4Ur44yGkYgFkZZGSbGYOTpBz2tsrUsCuoGYjRibDCMpSjsO7HMQgg0TvDS1o48Wkyrw7OPDeEMQKuMJ+N/W4fAez8ONbflKE9tXnRtY2zQLW97H9PA5Z0/hpkSQjytfrh9+7ich0fvPNYnHn3eZhBCoN3xPx4mxyHtghVtIs4Ub4HC+bHOex2UUUxh2qOnltnzzQPUMXLVZTvZ/ZwdeFutKhgfdR0PbWsasBQtccBiA1pN50x9cqLa8kyx9l35OVk9UFt1Mb+wSKOp9NKZUghEjfSrEldDXTfUOJapCG6KUXBZVCc5WI0JdUwO70ZD0mhQVI1REygiiVxoAfVQVGn0RyPPVITWXUqpUM9oaDR1RIsBURsGwDIlAxGCwGpHiG9dJNLhmceGcAZE5LQd/2T488wc/uTzGwUKOGtAiqTQFmtMG9SVOCJiPjPaHWYRNc/IlBdfPkNYCgSgR2olW6ugIowUGlLneFi/zlVrdp2t7mWSQyQ4a5KBepyp4lKwm4DitQaUYRRqqfAWqWJITG5VQgygMHIVew4d5wN/9lmGxSz/+AdfxHWXbqdECBgRQaJMlBSuz7laWJJqtkIoAXUQzTMMPVwmmqXZWYyjK9I6oJL6PKR8t0dFKeOIpcVAoMITUY3UBl6V7792M43OcfsjNX0/wtQYaEFhijUjGgOLkRCNUWDsYKzTof2WaP0qD2CKCTTiiBYpdcBS3MomKVl2KU0wpZFe5VBxmAZidkybCGYFcwxYCLCgBb2mgRhogrEcHY1KbvpkxBzH8RbhvJQtX79Y20y2pwiTRr/913s//n3y+aeajb7Wsbo7Cyl3LYk01kRlqErQ5M2nNkWtM+CoVbnu0rlxANznjm9RU1Y8WKr9Ti7BOt4HiBBFWskfIEUGTASJ8XGXMiFHAxCCGd6SKR+qMHI9sIgnpv7xZmhUnCkBz7IKx5nhiGyndhUlEW8Qc84VFQzFZP2OrUNxEokOirzRb5oIMo0TpZA05jlDkjARjRIEyV3xogiVNogKJn0cRjCjBogNz9tivOCSCwixwDU1XhVchWid52uuHIlGEx0uUxfPX1OVvp2Y5rltNIBqxNuAZS2IzrMkKY0z3dT0S5fXgSYRYcVo1FD1zLqG+do4OnQMG0UoiNEI6pLIUL5/4phAGFjHU/e8xMaxeh3OitUFbzVFMAyOv/q7r/PAsQXUFUwuia3wTUqteECT129NcgjiiMJqCsta5PYtBXvXPLIU0/h3JancnUve88xXqCpNNNSEqIK6aswBiJZ2w0sLCyysDDFXIGZUPjXXCa61hYrlnvDrfUE98/RT+iU9Y1agVKnSon2xtB0x038iaVebSGkQxaG5PDGaJq6ASnb+hSaE1HETA1/QaGq5iyU53Rhzw52znNt5CREQn/sFCE1OE4RQYzFQCLgwZNob0z6luYLlnhxZ1tkAX/S45/79HFsccPD4AotDJQQjhBxFaz9u7NSdv27WekXnDHTIBms1ZLdUN/zpjV/mprv3EeUMydBMYIsxKfG1PLZ2x6ZqmDmCOAICUp1HZKHkMClJf/3x4wKPhkGuGjCiJXJg9P3xrrcx2Dw7RVV6TtaBxhwWa3ouSUAPRIgITiMmp1dsnA8wIMQ4DgNEhLrtcGerLXINl3pnEUHSWCRHIKWoFEDaypZUqeG8TznxGFBT1Cyx3tXlkLcRNSYCnComZ7qA5yFaEqGkZF4j0GgidYYQcd4hGtnc87z5Da9mrvDJGQDqJMy96gxUPQ48cpzl4Di6WLMwMupohAAacvzQ2lXm/I65rFd0zkCHNAkkMaq9CQ2eU24LB1eEUZysQWp3ZKkm2XuPkXZhSEmgYGCeJXo8ND/kjkcWOTpY58upcdru2ywtlo1CNJdTLHZ2+dIx4W2CSilCExx1dNTBc2xxRB0Slz6YUYoyN93nyIIjUmCWWsQeXhxw56FT1DG1eGk0IOfh7io0DeJSiH6pCTx4ZJE6l1LmWABR2hFVTNLfg2ZHwQwv4CximdUeYkBcykPEzHRN5YbCwiASJbMTVMe9NVIZ6HmMPGfNEnH1yMkVji0MGTQBnCPGQAxKSYoIXHf5hVRiiMBCIxxeShE/zVEUX1aoeCIe8z2i63H85IhBo6SSGcFCQI0cmTn/5u56R+cMbHSM7VRWR0RRYMXP8ZmvPEA9SnKsuVx+HAWIMeKLJEgUESyTD1fUc3jg+O9//En+P//pg3zq1n3rfFE9rR4ASGHlqGmXnnb7uirQ9CiNCUthfbNk5Jxn1CjH5hc4Mr/IngNHOHny1FhroBTFYs2XvrGfBp/0HdTzN1/8Jv/59z/GsVMjDE+diYlyHt3CQkoTtGN45579/NYf/Q0Lo5iezOWslr91W/pnIkQFSN0HXWi4+uILKXPb3BhjLh9M0YLkPEROLQ/Zs+8Rmlw5IGLEuBrBOe9VaLNjq97xic9+kb/53O2MYsroN01IkS8DH2umXOJnmHPcdOs9fPH2h9J7czqwFaVqDxwNvn7HvcwvLNOoy/M/3TtKyjB0WFs4f1aSDk8KKa9PrhYArwEsMpQejfQQi4CNMwXG6g648ClUmBbmdHePglK7PocWI0vFFo6N3Lp2BsZ6SuNKvsyiVsvtcG1sNR5dhdK+qTU2DsQxagLBhCZCdL1EZAWaqBQWme73WAmC+QoVGNWBhVjwSO0YqKB4GpIwzvkWx1bVcXnqyBzHgmc55gJDtzq246qCyVa4anhVZhx87yufx/ZNfRQj5CgWwpgTEEJAipLlOqAuKT+muZ17QWyASLaagqS2xSNzrASojSyJmeZZqjQyvBleUurqVG0saa7wyJuDXlng8ju8BZyDlQhUfQKGuVVeh+a15rwf4HWGzhlY5zBO37ue+Ze2Dnj8kwmAiRK/ysvWMY1Qca6gsaQX5iQdyyaOrplk5J3DYXhTsBqPoqFOLO9yiqGV1ObPj5DgOIecx0KE5WHNQwceGY9JjCl0ajahBCCkfHeOHIjzREv13MGMKB6Xy16jJb14L4b6ithGIUxYqI1RMUWDS+RDWgLjOh9bm3BIM1rfa6DCQCrUtTnn1dbY6T0CeMzaLLTg1Chjw4xEXGyIlp2BIhFho6VKlyYEVATxZQ5bpwhCiDr+/Mk5f8Ypr32CYcvjae95Vsm/k+qHIas21Qq1JYGsJgTEO1RS91EBChHE0utHeBpfpcqCvI5UVZnWDgs4AhCxsqQmHTuaMRiN2HfwSCrjFFn3U/d8Q+cMnAdoF8h0YypYxDRilnZZqbxqGVigsSz8oasGS8XSTWyRKAUBqCTi4yhFAXSFFYNRzL3ic6vTyslYSY/cgcxCwGtNKPsoAe/aYPr6RM6OTJCesg5FGPGpb+zhnX/2GQZq1M5h3kEc0BAZGpg1ECKiBaUJhQpmnlEw6mCYBYgNYg2xTHK4JiVTlSAsYwjeG8sSGEVhpmkYBCgc9OMQk7iuSwvBkTo+AJmYFlRwZkQVFmqfStNiRByY8wiWytRMgBLT1O2wp8bQeWpXUvkAbpRjViBhROWSfG7EEyiJIdIEAfN4Ui57ZEVycuMQi3UuhsvljdnotT/KOnAIFNBUUTEwozYFXQJtGAEBQZzgDVasx4qWiDZUZZUIhDQpqheNwhmb5qa54bLNTIVhSs3gKDWk8SgLHENm1FEyReOVaBGxiCg48dxz8CS//r5PcXRh5bQoT4e1gc4ZOA9w1shAu/MX4VSjpEbCQxoSaQi19iWZBFdDdgZqPIU1eIsE85gGTkVlBJnCZQTzVD5p62OgksmEGilpaPCJ3BVHz8aQPIWQ5AiIjB+bJefplPZ4eFShzo1L2tDAMCrzdcBQzBnmJQkVOTDvGQYQXyBqlAZeFPWJKKjqKSVSuBrLRMUFVzJfC1YHFprISoj0SCHX9c0hTOMqmpxYBUK0ZMCA5VqI0UAjgqCSlitngSwwkJQvzfAKNWBFCc0inhFCqnaR2FC5lv7qUUpiE0E8ThzeQmLT45NOhjWYhTMMfnunZNaCrZN4lyWCX9JRMtCGiHGisaT6KOAxGlcwsiJJOOMRHF5CGt9gOCIzUyWvfe7FzEo7IoIzTetJWSDS0DOPc30al8o+vaSNh2CMXJ/9oxmWRs263iCcr+icgfMAZy5KZoBzKMbCcsPvffCLHF+MCFPj3vFtc51cIJSMXe5QaNGQ3OO8jp6R9vngJ27l63fvJYhLxCIBn5vItHl0BExjzucCuLS4nxeQcSmfwVhCuE0fjEumpOKbDx3mf3/4CyyHpJU/dMpAjFAoeGM4GuLM4c2na+Ac4nLIVYSyLMeMzSgz3HTbQb50zyFOuCk+fcdhTjTCUF361PXtDTwq0RE0jrUERnVNHOsCPNb7E5/FBLyA1xFb+8KO6RLRQBNTuWJRZoKbpAhBCIG2+VSbfjCEEBUTn5pEnflhbQguub1MzPw1B4PkfEqamwWCNwfS4+Cpmvd8+HOMRk2mDae0X1MHokJRlEl+oE0iCoh34BxFWdBEQzKvYJRdrKmiwsxjXvDOVlM5ZyCEyKgJXYpgDaJzBs4btIuS0DbHieaYX1zhq/ftYymAWpWeb3eUkzekywqDAhpTZCFYwZI6loLjC7fez95DR6nVo9n0eZc+NYiknYe1zkCuFRefWd7nHzRXCCQVN3B58TNXsueRk3z9voMsBkfAgbRcAKVw0NSjdA1ciqYkJUyXOQOJmd1yOaKW7D94ghOjyKJ4vnbffkbOo5rKQNf7mmqszsU2b99GYUajlKZaJWk+2vAKqZNe4wSLSiWRH/6el/PiKy6iLIQ6Jl0HX5RJaTRHspqY5XAzp6Pl1oRoRClpJLebPvNss2Jf+7NmIakrZJp+RgV4FUwLHllu+Or9+9HYpO+ghppSx0BQKEo/9pPaWIiI0ETDFSWIw9TAhJWs6zBTeIwiOwOK2JlSw5IpDCnSc7bOrh2eXXTOwHmC8Z5V0n7fLNX/1wZLlNSuQKRcrZl3xqTOWuowniIDGgNmkcb3OToILCPU5SyhKHO4UcadIBVhUeFkHRhq24UuhQbJKnvn223fcjHEOVxRkWlsya6I45HFIaNyhpEJlTmqRuhF6AXo4RmuDFBf0DiPOYeTidbEGK7Np5rhSTtesfS5MzN9xCIepVj7WevHxfjMZfX3mHPcZskx0FSYPlHWMQFJmgArCseGAXwfJ5GLt02zpXCpeU6EUdOqZRretcQ1N3aaAWJOmwUTghTU4lkc1dRZIKqtpwfGCpxr2Z4lLhC0Y+Y1P/IFKyosUSWRpjaNYJ5RjCiGL3K8QAoaI0sQC95nCUyNlCJoVI4NAsEiU04SH0MMJwFnKXIgyHic1LLse9aD6LC20DkD5wHae7715slyrEYSshk6T2OJDVxCNvmrUc/2tlXAxAj1AHHC8WHgPX9+Ew8cOoVUMwRzxNhS6RI7PiB87vYH+V8f/AyDoAxGpJ2WJpLXeXnPW+6CieB9CWTTYkpQWBhFBupQB0RSK1h1VJQU4jl5apFgKccdSfoDIHnMbNwbI8ntBjwBb4FKI5uqCq8RjQHNojHrFtIarIREZdHxjjTa6Vn7MxHNaMTzzQcP8j8+8BlOLKceGpUXegKIoxHBlxXOOyzG09I7q86IoJqdEYORCvseWeB/f+CvaTQTG3EpcobLEYV10GTHVh+Ys3FWSXO6IOKS44NjpI6RpnLVohCcGA0Few4cZ3HQgKSKF4dROqPnFGeOj33xLoahoYeilKhPktqrMavV6oXVoZcN1QhuvaBzBs43WBsjSOmAJkYaLBOxEmEthVbbnU5iY0/mnkMzIhAYes9dh47yyPF5fFGmaENM6m6OxBkI4vnGg4e45aFHWDGIrkxiJDk/cD62gjUy8x8Qlxp/uhxbEQfDOkBRohFGDhYNlgWG+PT3rLjincsORdLNTyFyoyzTLhaEIEYQTQ5bgJIScRUjHAP3rVsorwdMTj+dKMsM8fH7WqgII4EHjhzni3c/zGKoCFKkklcTVAqCGnUTcM6f5gy00a3WYsaQrmsTFfM9jpxa5u779zEyI5AaITWWGPjRHCapVHGt0ghbPlDr8SdHP4UHRA2njhphZFAj1HjqKEQTyiKlCWrx7D10DHUVEYdzgiPireb6667isksv5KGj84yahr4TjBLzpAoik9PSL2DEEHPZrbD+E1znHzZEC+MNiXQv0sSIWkw8ANUkfONazQHGRB/LpMCUT22IknZdKyH3mndQ1yH3jU9v8k5YHhn3Hw2on2YEDIOmxi+qqQtcdgbGtc200Yv0v/WzJJzu1GjetYovwATJ7XbNUlveGCPDwYgPf+0O+pu2sNwoC97RmMfE4TVCk8ouvU+cgRRtUIoi1c4jRnBCbQ4osWiExhHpsaAlf/fNB/ju3Zeyud97NgbkKYbkyIDhMqflTGdATnuUeCp37DnMA0drRr3N1FpSUScirIG5gn0HTlCHmNMEUDjB4/IuVcb58ERVcARN0sajAFr0Uv8I4IG9DzNdVlx+yY5EHUBY06Xylts7m4BLtURGciq9Kl6NYYj83dfuIOIYREdjSmNQ+tRpsKHi0PFBUmh0hgWl5x1OA5unCuaXFC17KMZUlaMlzqVCjwmOQHvntDoc6fKt2ZHbsOicgXWOlgOQcoTSUgfx5ogktTui0QTAJ5Pl1ecFV8dVBxJdVhsThlqxiGcqKqUrGEhBzzU0TUmtjuD74EqmCuHUUDm8/xTP2yyp1lt7RJdK6QoJECNoZMl5ZsMAXJG0z83nHuftF1mji8PYY2oNUxJiieowSTulFFpJnd8KDIInmmPv/ALv+qubWbI+W2b7zO24hJ6LqZGT8xQWcFbTEyhlioCC1JS9Hip9Lt/i2H7BZr5x/woqJV5GNBqY9g2HTgz568/ewjX/Ygubd65PZyANbcvIT9e/VqFvRjCIdQQNSRtDk8aAOcXwaDCGKL/zkb/j60eM2pUUbkBPRyCeRmBQK/cePIohFE4oCWwvRmzZtYt79h5JSnkWUfMMLLXzjZpkc00cS66f0g4Gn/jaPUxPTfF/7trBlJFKRmWNO7PZ6BpGYTUNOcVEYOgalkY1//kjX0asx2VXXE0TlREVc84wrTm1vMxX7gm8/MoL6FUe3wghNDgvvOjikq+cAkJFL1Z4D4UMcaEgyjRmDY4UoalDSi/UJqgGwvkXLDwv0KUJzhu0OVADYtvrjaYJmCpNBHNCdO0i3LIEwIh5t5N2EyMriUVFFSLOHCMpCGFIUCOKw6RCnGOmcKhzNK7CiVAqNCoEIROJEhNcgSUDLGDa0NaUJ6ztFserUkOaHIIccVFL20JpaZhCq4QPJPW2gQkLtpklt40Rc5k7EFOrWHGIREQClSgxwCAq0LB1rocz4eJNnlftvohCHOY8ilKHIT2pCSosyWbiur+Fc1KgbR6Ui10V0BCTgaYNLRuRmOZY3rHPR8+im0JwFDaktIZUkplSVMEcqFKKUGrgsi0Vl++aI2qSzfWkLpvDmC5sUEu8mRipfQVAabAkfRZ9fyK0tT4sWooHpHlZq2DqiChapM3DfLmVeXcBBMU0EMUxW5Q4IlEjQ5vh8ou2MFWCxEBReKp+n11zFV4anBV4LXCFo3ANFUZqb5Q6ZyQScTqXUVQQS9UhHdYc1vtK0uGxkEOZw6ZJbVxziC4ZttP3Mw4Fl8JEDqUOgSQ0bDQKdzx0kuXGYa6kCWm35kWZqoq0s2oXc4yQm/ZEjRhCo3BsOfD52w4QXIH5YjXPLSlHvra3V4+GkZn/jxKeyXyNXHJ4LoxpkwKcxxUVt957GMOzYxNM6QoFkX6RhF3EjKIsaZpWWjdVHZxPy6rlOdt+qdiWvhloIrag5vj8LXvYd2xl3GZ4EqvkNMMs8eBVI6Uz+s64YMpTmdIrJKexYiqxs+RupEZJbXptlaAZo+Ld5HK5yjdYixDIp+eIeEbq+cw39nCqDsRglFqM1wiVJHt97OQCR46u0J+aGkfyw2iF6SrH8Fx2SlUpC0/hchdTMbwDCYHCNM1XbBy2TIRQYVg3iMjjlop2ePbQOQPnAdpbarw02moV9CBEouUGLI958xmNaxnxDUvDOosOBRorufn2h1hq0m4LQCxSoPRLn1rFZhJA6oOe2sCmtvRpB3dgfpEP3/glhlqgLfFKIHPGn55BeRph2GmlZqc/N0Ga/JZrnRAslRYawu33PkzEc93F23nNC66gIrBjs6cqBNOQar1DwGcdAp8bHJ0vaO2D0ZYWNjkaIDQATmjUeP/ffI7P33bP2YdXVjNOYllQWANehO94/jW89YdewbbK0NEQJ8K2LZuZnZkhNOmNIaTITYir5YZGetx2PlwvNkw0VRBFERYb5Y/++jPsP7mIqkNqzbl9cmIRjp9Y4NDhY1RVlTpwamSm73npdZdR5PiM+ZRi7BeeMldkqEupngrjFS+6mtKDuGzwBTSXLS8NhkSTMY+ow9pC5wyse9jqT8vMsyTrGoA6M3hXW8M++kaMeJYg36TKycEQiwY0BAqGWtBIRR2EGBQnUPrcvARF8qIQohI0Tp4RjRor6tBiijiuW87TbtxLYX0tDpLrzMe7nPTX8fOTFRRJUGg1SuB9qhQYl4CLoyrBOSW6KYI5Lt3W4wWXbsFZZPN0SeXBiVEWJUGz8AupfLMVeGxr39c72rFLBjikagCEFSBYkiBekCkODy3pEZCiAS6XZ2KMyYJmEUwJeVd/+UWbeeHl25hGqXwiGW7bupleVRBCmoZB02c0IaK5NDZGUHWr45u33Wt71rY7c0MMAp5h0WcANKqUeMZtSnA06nBFD0WYnknzC4zN046rds3g2/taUhqnckaBpYZGznAOKoxrLprCaYORJYeN1JALWFwajK/XuvGoNhA6Z2CdI6m3JQb7uJmOSlK0A5abFKJTnaz9PR3HF4b85U13szyMqCkLo4iFRJpTPLW53K436wsIFLklrOEQ77NRMlQNzZEJJO0IggpNFEYxVTNYlnpNjWTWQb32mTDGTkC7y5GJ58ZKa+SFz8CsFRQ6/ZZzAqUohUAtJfiCvoMpqxGBwjtKSWFXlw2Yz8YONEdg8rmsM6fqTIzZ5/l7hBhocOw9usTnbrmPWiMgDIppTtXhjJmThZvMKLJoDiI0UanVUIECY1ogmTzBOY8Xyc5dMu5Nkx2QkNJcms9Jo61qFKwXSNJQTJ0GIFIQxBFa0uY4gJXu0ZCZRmXpxkWTJUqFUbjWGfA45ygFiry5UJeiMaUpPQFPhKzfaJLKFRVYHgwT14Z1d8dvCHTOwHmCdicuyfXGOUfU3KCk3TVOKJJNYv/RBf74k19huQ4E5xhESf0JyKWIOKIq4MZiO4Uv8s44CbaIS68Z1U3W2Sc5A2qEEMEcThxB23NoK6H9o85nrcOwsUBQWxe/+tyqVLGRIgNt69g2mjAJZ0ZFkimOUqJSUgKVJSJi4YWClIf1RYGJJIW4vKDHCWr2+SDkMv4OBnVUGil58NA8n/7KbZikedWUfZZCohq2r09jnN7an0rLWhMCUYyRQlEWODNKoExXhqKocELWeLDx9Zyemc3teVPgSjBCDGee6Zo2aCmXn4xyabkhliYHPZoS2/ScpJbYIbcvRjxF4cbSzYUFShRvyRlQSWmtAsNjqaujBxGjMKOy1FVSWO1W2nZySGkCxjobHdYWOmfgPMJk8C2qcWJpyPIotWddDV233c1XX29lj7raxMoIEE+UAi+Cl7Q7ct5R1yOiKisrg7Sr8j7V0+PyIu0Y1kk2tvAlJi4RCWNAQ8SiMhoFjh49QRNbAtH6aLSTg63j34ykfgfZ0Zp4leWxbiMBbYpA8+7zzAips0BlDYkSmDQIkotkmDjEOXzuE+992oKJ92PyYoi6ej3zZ41/Tv+oNQ/LjuxYvlagwVEb1FLlCo4klLPSwNLy8LQ3S9a+mKpWXd5TS9nJypEDb0ne2XD4osRJVtKMq07dzPR0dnRb3kDLuVlHELC8QxdNcsQuO+IRJdN+8xqQqihU0vzyfpWEmQTG9LS1JUkKJzfezFL/A5Jj6yWltGBifckXY9QEJEe3sibRxFxtU53rc+6eD+icgfWOlm2lAbMRtabbPGL8xz/5PB++6T7MemkhtSRt2zjSYhCaFNaXkkI9o9EQpaAw44XPmeHiuQqREaFZYWWwzKHlwP1HlxFtmCodjaUQuMTI0YVlvr7nIdCaygnqZ9KOSmsGWoMo39i7wP/vfZ/g2NJyoiyZga3hyIAlDoWRQqxmAqYMEUauj0SjCCmEbzR4HRHU04jHs0IJ9Mo+Jp7GHNFSqLqkoZTkHGwqAtc/Zys9VSJ+3PExlMkgFSKURG54TsVFsyWCUHpH1EiDY0ULoAYbQQMjFNMRGDSslwU1RYrSDjKiksxYrYL6hiie6KZw6kCFMgz54r0P878/881M8EvpqOSIwrTAjDhe8tyrufPBoxxZUqoycT0QIxQFCFRFoLIRBXBSPLWVVCEyLStgkcb1URVUjVFOgRUkcpzLAsVrdYQNoZYeKg7zioniJI2fRRBLUT0fPX0dUuNwFHgapsuGiGcqBl58xVY8AtbDiWOzKaKG+YKrLt7OlEBhI6RwDJgmVj2Ci5jr0SuMC6cLYjOg1MiyelboAw6xhsYixAYdDYjRMALGAKzutAieBXTOwDqHsJorbjQwFEFcgRk8eLLhkQGopAZDbcsRg5wfLGgkBfQkBowGE6Ew5eXXXsB1l+/CkXQBwFhoPCPp4SzgNBGEvDicwbAxjiwOMI2U3mFSphpxi9QaiBjzwXFo1GMYFZHV/fTaziCmXYumhwhZq975VBUZc4MiIlgkZOa70OAk9x2Q5AgETY1yqiJJvuIcl+3cytt++LtBBySht0T4irnG3TlPKfATb3w5O7cmB6vwjhiVaMIoQjL7SSsikhxDcsRifaypq9e/bZ+lgKngNFWnBCuICCPAeceSlexfDOPvZzg0GqVLDtR0IVxx8Vbq6Ki1wMnqx6hLfBcvgb4XvPMsRIf6ksKMvg/JkaUYcwaavHuVdlfbkvOe0XF6IhCwlpOjOW2Qkxvj6BGIOgptEo/ABGeRygfMHFOl54aX7abwHrMSBKY0Nc8S77jhZc9l19bNVBIRwPsiXT1nRINdF27j5S9+Lt4l0nFyiPMYopgIGtNcrV3ufIqCrb8Ko/MBnTNwHkAskX9Wgufh40uEXLpnuLyrMprUjwxRhwUA4VSEe48tEjSmskA80QRUmS4cVS4hbEPfMRgWkmpbv0wLrGlaCCJCEEdjUJUFEtOtHRWaYCzVxsETS6k1rAngM8nwWR26x4ec/Zc2yyHIhJa+SymWvOPSlnyW0zOqSox50XRuTCQUydUZRZny1z7FXFM+PNXIG9ArHVXhEIuU3qMxjtMwySIKVqy+Dwxva3t4T4eMg1ztSXsVfOOIAaI4TtSBWw4dZyF4oMh8llWktMzEETN3JaUPVpkqkP7mBKqqRFU5cXKBEHOaqyyT02w21pNoQniUZ7WWxzaR/5I4puGJ0kovp5y9WhxXY6hqkn7OY1/kCphogvi0WYjGOI3gRPBAz0OhNcRIqZHpuMgMEYmB0oFqUthMxGLBYkOpg1zyWSAI4kqOjwoeOjmkyXEzkHXIJFr/6JyB8wAmabG85d4H+O0/+AtOrYwy2QeiCFEiEU0h+ego86rwudvu4T/8wUdZGAyJwEhKgqQ64NLBJTvmkBBSpAHH8vIyczN9Lr5wG17SKiu5rrvBUUtBNMn65U0qK1IhqOPIyRU+cuNXGFAQTBBzSbVP1leznbR4pscpR98qEPrkDJCa2SQC2kTHNkvCT5IJgN75RMR0DueyKcykwGTQJ+os8m6q9IIXoyxSdYia0cRI0uVxjBxJ9U0cSEvkWh+xASCnjCcIkSq4KEn5Esftew/y7/7HX7D/xAjTVOJ2OiQT3/JvMlHVMX51fl4E71InQ1Xl7z73JZpoSVK6KLIIUeIMRE3cjFa7YzKtsWZhhstEvZAd9UT9NdRi5g0YbSIsTohoeZ+qDwqfxkgt7+Lzodu5WQA9a6i8Y8eWGX741ddx2Y7NFAKVEywqU1VJaGqiOQiRKg4xU2pyQzPxfPQLt/H7f3UzEUEpQNz6mrfnCTpn4DxAK4m70CiPLDashFW1wbRjTfKqJrlLXq4qOLZcc2hFGDY1wRWsmGM5pp7ys2XBVbsuoFeWqEu93+vhgIt2bGXXRZvolT7XA2RhFlexXCfNgqpw+GwSo0JdN8Si5GQTGOEzGatdUNcXhBSFF5FxT/u0oLpEAAQaJREoYZUMlSsMnHd473NzovT3wgEak1NgOh4ZJzbxGqNwUOTKA8tldtHSOURzLI5dCQ9iiMUxB2E9oBWvSjtyw0KknUlEOLVSc4I+IzeNmJ/Ymss4KuCdpw0PmNpY58FNhAzaULkAU72KudlNqKX0mjhP4Qu8S45eE3KaaEwmJBvFVtd7bToEgiEaiSqsKAxUiJI0LixGcD4lDyTP5VSjiheXSICmVKTeIoX4nI4kOZqWxtULTHnDe8+OzdP8Hz/6ci7e1MMBpXOUhTDTc6wMhwwjqEHPRUZqLGlypswL9x9f4OhA80imCJusN0f2PEDnDKx7GK3Wf+0KRtIn5vCw5B1lYQaaan7NJbfeCZjzNDKFFCW1q/jK3Qf46y98k9qSyljpUg12VAHnWF5aole6xDZwbVe0XOLmSr5yxxHwPbxAkXIRKaQeNeXSvSfgQFMI22G0wijrCZMCaq2xjyRZ1/seOs7+g8dRHHXLQLe27K2NFEjiEpBC+m1mF9O8CObrJ5Yfp51a5YXSGYUIaqnSY9gEoGTYCO/+8Kc4fmIZXIHi1/bO9SwY5//zWKkZIae4fFREPCM3RbReCiPn5lGtwYeUGlgtN8wsd3GnpQhS183EiK/KgumZaUxcIttlwygopmnHHM2omzjWIkjO39qODBigFhkZ/Pmnv8EXbrufplX/VKMt90sZu1T5k6IqiaDqYmDOBy6YLhEb5YtjOeok43RBYUpR9iiAzQI9AXEFhfc4lJlSaJqakYFKgfeeg6cGvOvPPs8jJ5dpzDi6MsJ8SZUKE7Ashd7hmUXnDJwXSAIfEc/IivEi6HPDoiIYxEQoi87AZREbc2AlIRq1lNz98HFuue9gdgbcWCDIEKIaGkNqAStK2coXoykPiefI/DIqnsIZzkIOs4JoIjBFyeLDZokot07liDUz88alfOSiDoQ9Dx7g1NIgydfm8Otp742a1CC13V/KOB3QmpcUcZkMbeewrBNKL5SFQ2NqS9sokHkYX3/gICvDSMDTIOvNx2oHcTW14mDoArVFqhgoVFAqxAqcKSopIuZ90rCA1jFIh3NZIdJ7xzh5MPGcAM4ZvV4i3Gre6Y+Gw/FFTodN1yznc/IxVh2ONQsnrJjypTse4O4DRwiUCA5TQ9WludPyV0TYsnnLeFffLxxvfv13cNXOTRTU4/JCEZDsfEmej1V/GkiiQ97ApGBmdhaPMdfvMRyOqElRQ+dL9p9Y4i9vuptH5hcwEVbqOsXVVJNaogi6DqfvekfnDKwDpDWy/f+k8WlvmFwlIKkXgObIgMtNQ3zaJqT6bDNiFgVxgFNhaEJtQnCeU8NIyAqGSTPfpfSCeETanamd3rQlh1ClKCirVIIkFnOaIMfRLXdPM0M0M/DWQRi7PTtpmWgkkaV252I5L5vCx5aZ6qnNsVqqe4c2U51Dz82IUZOqNEqZkCY+0zHItd5pLKGQ5BAUvk0PGI0q5hyjKIykpIlGsKQ1/2y3hV6dn5MzePW3Ni8/+WptiXuAilFLpDbFqaZaefM4k5wYyA6Vc0guF/DZyJtZmr+2Ssq0CffKieCc4ERxrj1SSriN6nos3W0WiQajEJMRNWgMmny/rWVEEkN/2TwjFVQ8Ii7NX0uiZJJUl1LKZKoHBqXzeIFLtk4x5RQ05PRVauYkLc8n8y6qXj9f3QZnSYF025bNlESm+yXD0YhhE1FXIc4ziMKKm2NgiWMjzqXmRppImhFyGe+zOXobD50zsMZhkw+y4UwktVYS14iuT9+gMkcjjpDTBl6NwhpG0jAUx0337ufXP3gTx4YNhsMDRwdDfv8zdxE0EPCcWGpwGnL4OqKi+TN6BHNsscVUa+0dA3FEX6DO6PuaKR/pl0IoZwBhR18Y0aOuFY+jcdO4OEoa89lZWMtoDZdTodBAAzTmETXE1aiLSOlRTYpsjRnLRQlASY86KMZKKsWyPqVNoTKk1w80/T5bXMOVVSZ5iaeWHiIljkTMakzYVBU8d1Nk2hk9Z8kZQBnRTwarXskto8HFkuASybBP2/Ph2TdYltRlUldL0txNE7s1V6nyJE3vHkaVGtpYxHSKb9x5gqF3jLyjIFLJSto9xgLF0SsFE0XFM6dJiCggxAa8TFEVTSotxAimiDRUoaa0irIUzIHH4SRS+pod27ZgplQ2QmPg9uOBAwMPdTrPD39jD7934y2M4lq2VoKTglItjR0ObERlkRWNmDQ4VVxcoqZCVSlYBAJTLgmKeSc4XyCuSj0JNOK1pkDHJZy+KJgr3WoKUgLeKZfOGJdONRQ9oW6SboRUJTMWiA5Wij6/9ze3cWh+mSjGUAx1BeaMwiLeZDWa0+EZQecMrAPYox6tMqTb9IAzw2VykyaRUNrLG32qKjh0fJHP3PYQy3UYv3sUlfsPLxJCIJhjeVijMXV5a3P6zmIO83tKlz67qlL5ldcRiDBVwlzfMeUVDZGLNk3zD17/SkqXdtIu5wydNakZTN4J25qegun8UsRYGUHKfRoEDbjCM1BYUWgV8NQ7LAbUcnBVFVOoxYH3FFZz2WbHJRfNcd1VF/FTb34tLiQN+CQKlUaktAZD2bltjv/vP/uHXL5zO6UIhU+tY0eW1AqJIbWgBVxMOzZH0itod2/PJibn7pjlf0ZcK2ev818cZi6H7BWs5MSCUosjZNKa2IhohqnH8BS5kZNppNJRUhiUHGMRoXSBQmwcd9H8WsyldJek+dnzkZ6MeO1LL2O2l65jY8JD8ysMo8OHVCHz9T37+eIdDxHWeFRLcBSWGgUlhn5EVGmyOiZqCA0Bj6lR+LQJKIQ8j1I0zFzSxDDSdPKSS2GdIL5gqvSZRwE4Q8TYvWsL/9ePv56ZvsNCBE1NzPpe8lpScOtDR9h3YoHalTCOoDWkriodffCZxlpeiTtMwNoFzgxvRtH2DJ/oACgGaMrtpWx8QZDEkI4xYqaZnX62T0iSwnWjNFGRzMoWlMIaKpIqWShmEYGZqqSHMd0soCHgXcHczDT9AnrUzPqGa3ZNw/AkMXePczm0HSxJ7Zq0pm/t7gDUjETCdpwaRG65Zy/LjSFln0aNpVjx9XsPEyyZmh6RQoxBFG7ft0ytFUE8g8JoXMN0bLgg1Gy2iOiACy+YpkLxcZnChuQAPyJKQaQUYceWGUrnmOpXeOfwRcX+g4dZHgaaTFJUVdrsSwtZKwuqCJYbAhWm+PFJehi7PzBO3I8rMFb/bLlyI/2e8mAxy+t6n3gqBQ19b1kxz3L4f5Q6bJpATAyNgFB7D5mQ6bIhqpww7SLb5ypKawhU3Hb/EXr9Hj0L9Lzmio/EF1njWYKM1aqX9DhLYwMhV71oTPdl4X1Kn4jLZNZxkixdD/GIK8AV+MqjkipjpnvVuBJApABVZirHxVtmmHbgsiQ5ZhRFEnISERpX8vUDCxxZTmWKYkPE6nSeImt5WTgv0TkD6wA5c7xa52sBsSQ2Gyb+nkqy4ng7ZuKIkm6+GJOR8f5MOQ9DLTXQqQOoczS5eiB9luEtUFlNxBOLKZxFNvUdF8xO8Q9f/wqm+1P4smRmuo8FxYvhtM50pUBNWtB9rn0OGOrWbpOisT5AzjurgrmCu/cf5b0f/CsWozLS1MnxyIry+x/9OwYxcSH6Lu3KhxE++aV7GNQefEEolaDLvOA5O3jrd72SzbHG0RAFfAE+N5WJzlGTVPKcpDaxhRkeTeIuZYkvKxaWVmhMaHK5W8znPK6Fl0xHXAPewCrzXvO8TZUQae7mWoqx2ISuOgOT/H9L81Q14jLpTS2VcxZOqCQy13N87w3fwUy/ytEBxWxEIclRI+biFQy84Iqkw2++IEqFE0fPKXN9UBUWhsJf/d3NrIxGlDFgGmkAJx4Rv2aTXJNaDUqq6GlNu1rSTTCT7Ez5PHfS2pApBJmn0l6B1hlwiHeIU8oCcELhlOnKJ53DfD3MoO9SqqpnEWJNbCKgFD6RNTEYacF7PnonB086JIJIqkCy3PewwzOLzhlYF1ilCSZELNYEhYHBQJM0bTPOYba0rYnypyyOs9q9cBVpgXSZfOYYhRwZaJ8XkDgE5zFX0LPIjDRs7ZW88VW7masclSheGppmlGOJHtfz1HgWY8S8T+u8RoIqcUzuXhsGq8WZ7YDbaEoQYWGkDOlzciX3ERCopWDoekRJLGyvSq8s8b0pRlJirkq7SBtRxiUu39bnu156LZU2SGyIpP7y4sildCVDUkoFTcoFnrQc90q/2gLZp0U8hJDa0URFxws8jxX+eYYxSRzMISltQCM1MCAJKSuSw/6aIltC6sYoq5oBrWhTQsonJ9EaR1l4KqdsmfK8+qVXMFX4VOliioilLo+SitbEDK+RHiM29R2OVH1RW0kdklpEVQgNFY2bIpZTqCRjNVTHChA0RdvWkjPQdsWcbFSlBogRQkobqqU0kpLSBkkQLLccV8sVFkZVFDlNOHF8UtogjIb0JFJJIrT2qNlUapqjTlJXQ+eoHDhN1UerVTUO531OG1rSJilnGIQ0y2tKapumsa608NlA5wyscYi1YVPLfAAgC87UwFfvP8qeQycxSWG7NnyZee/jUJ/l0FzLa59EqnFPO4iII5hA1m83EULO9YspBUKvHjDrAyUwh7GdJTY1C2wrDN8sp12uc2ghzNfCXQcXqCnwrkgSupbK4iSnPNYi2rJBh6Z8NLDcRAaULIwiznt828SorU+XVv7WJZ12U6QQCots1obp4QJTtoK41ELOtep44vAWKUgVBA7wMTDrEg+kFczxhcO7VFGQehisli5qjgqMnZicL382IYlykhtnkZ3QNJaPLAz53G37GEQbNxlKKoxtdUYiP441A1SJY6pBuh+iZiGb0uPjiJ7V9CQ1E3JtAsocuBIdazFFtpTGBbbArqpmWpLaJtlJcGFAJXknbalEc0UVlR6nmOYzdx7kxCAV7q41tHO2fQzkDYCBZelstdxVs5XVlrGz5pxL3QidZEnrVVaHABYD1AOmdMQURoUxKw1zTvExXS/D4fAUkqo8vHfgPKOmIZpRVgUajFY/snHp9UcXaz5x+14+dssBFkcxi2qtzbXhfEXxbJ9Ah3NBvpnb8igDnGeI8P6/+TLb54QX/MSPJOEby4QoDG+ayThp19CWtj3K/kpquZvCiY4QSeVG+fMa12MmLiIWmS6MH3z1dVy4eRYibJvu8X/9vZcwGg7YtXM7+5ciH//8rUQJeAfHFlc4PL+CFhegweXWsDnpYYZYsebW1VaABVLuHk3kqZVhTa2eEwsNVa+H1ksIYVx+pgbBHOJLqtLjaVBx9MWxe8c23vqyl7Bjy5DgI0029N6gksgPv+6V3D5/C30NVAYv330xF2+pqFqDboLP1QRlIYgGvCuJIeT8eVuSl/Lz47D7s+oP5MhAlp7O9X2oK3jo+DHe88EbuerCt3DVRVtXdyXWtn8mOQiyWpIZQtYVKDyWQ91qwky/ROamKOshRU5HiaQKAaJDiirJbAs4G/HqF17F9k3b2DQ7w2zl+Js7DjNrK7z0mp288fqXsKn09J2xbCm0XZsjuln2LTq+9KefZtRs4SWXTT0bA/q4ONMRIEsIx7asN8tlqxnmXCr7dalXSVJvdOM20G2qpoUABZHnXXUJby5K+jRgwve/6sU8Z9schTVEq2h1SVzmOKk41GUJ8qLANTnpqREpHCKBQo09Dy/z63+0h8Lm+J//+vVccOksXYeCZxYbwhmwp2D3+VQc48kf74zQdSbeRREWGmFOXa6Fzvp12tLyNIv7tO91j3K22y6GiW/QGjRLedG8uwwUmHM4C0y5yHc875p0m6ox5eGHrr8M51JXvksb47OfGzKioczH1aJHExQvRcplWy57U81Gwp7STcC3e60CwvLygLnpfvqeOckZQkQpWVyu6VcFI1OcRMQSeU8xGksiOL3C8DT4oqJU5RXXXMkbX3Utex+8jYASnNEzqExxccCrr7uYKz57J8VoiSmDKy7YxOXbZ/FmiUyF4J0k0ScPWMQTiZpC52qJGGYTzLsUJf72Aq5njuWTGVvJ52etQRJHrcaSVpwcRFaiMevTrrXtkJm9gRTlysYsBMvNhSqkCS2Tj15VsOPinRx98P5xtCXvdUEdzpWoCMEZLjY8Z9s0z9myLZHWqPm72x5kiiFXXNDj+156OSeWlqnikL6UNCGyuBJorODYyHFCp/BW4osiBzqeuoD2k5u3q9oJy3XEYUz1SkytVQ5OqaOkO8zKSFhp0uMkC55C8oKm6gCSsuCqE5Y+xZlRELlgU5/vfulufFzEpODlz7+cMipoPXnZUtqLFGEM5jk5qKmbJp2T5oibgbOawgpq67FYXEgRp4g4HGF1PLLeBrbq2z6ZkXqq1/DzDRsmTWA55xhCIMY4ftw0TSqrC2E115Y7zLXveTKTaPI9k/m8J3HmQEoPVCQiWZAeIExbpCjL1N41awsU0gNc0iDwimoPL7OYGiNxTOExFWqFEUI/1pg4nOYyJBcJNPQc+JgiC1NxiWXmKDBmGSSCoACFIKL0HJQI0w5mRRi5TRRSUAGiHqeOTXYK0RVGUlBo0tin8FnH4MmjvUZP+v3j/wcgEs340oEVfv33P8WJUUNNRfSeQmKq2TbH4nDI5sJTiE87TjM0pgWzEcfWqRHXX+zxgKNg2Ctw3ug5pdRAXx29WKOmuXRrmj4OXEWQpNSoDlwiWSCWShMraZiRIbHo0ViZZkMmxWmMePFYDDk8HycM45OH6reZGTehsFQ6KSZE10MsMiWOxWKO//TnX+MvbzmEWJMa5/i08KsmXkbpIwUrNDZNHQXPkE1VwQxDAqk1tjPPbG8WMU9BbjEdjRGKFlAZTOcUhLg+U0AlUFnAmzIoZ1kuZuk7YxYoJHWAHDjl8KDkq/ceoSxWOHxwPys6Q00iyH67QZdvf2zzcYCRBt75sVv448/dyhCQ2CAWwCIxpLB/wPP+rz7Ep29+gKiSWxZXFLqC10U8fUT6ucFZD1EYmdCoB4mIJpLhnIC6KZyrmMaonBF8heRW2o6A9ykSWTohWMWHvrSXpjYqrwwbj7pWLltpvGGuBOtRFYs0opj1aWXWG4Ng0CpVJHLvtxgas297fNv3bxQnYkNEBgDquuZ973sfe/fuZdu2bfyLf/EvWFxc5L3vfS/Ly8v80A/9EK9+9aspy3I8CUIIeO9PCxufCyZJaJPvVdWJ8PMTOF7+cbnPt7kCi0qRyT7pNcmLDyE1B0JICmuuTK1sJZXzibZdzKCOipPUnrQ00BAwMcxBmWsQBXAaGZWb8c1iWmByblvJ5cEpXZjyrghW9FMJnAjel4SgXHrhVu6fDzSadeLNxo1SVg/wxGG5XKl9/ETHNf1rmVuRvtPe+RXuPrRA04ZXTfEWMVUCnpHBdDVFNteJzBbBqRFD4PrnXsrrXrWbW+/cyzAGmn5Fr8ohTxOcOcRIRl8ENY9oknROodW0+DkDLGIuicH2nNGXGnGCLysaS9fcSLutmB3acbY471qfyJicObbe+7Pmop/I+IoazgewFBUQU5wJjS956ETNfY8sYnJBVvRrGzyllFVq9xwYacWSetSVOPH0y5KAS2kTGjZVM/SyA2W52ZMKUBRUZUFBVu8Uj7cGJF9zk1TBocpcz+FNCQYjCmJR0qhwahDxLhBGAcpZxI0o/Oqe/Mk6BW1PhScztu3gZmoFUZU7D50iWj/zM2zMNxJJpD1VeHhxxMmVhl6/yup/JdgyXtrIDJSFIaEe6wykPF6q+0DAqWJS5DUpYCTia09rEj9Zx8qbTgRcycGFQOFLRJSlYeqCaLmhlorh1aico7CVxI4yDxYRZ212ibbS5FxHva2cUtVV4u054tt21NYhNowzUBQFb3rTm5ienuad73wn99xzD3feeSdXX301r3rVq/jv//2/87KXvWw8gZqmGbecnTTi54rWMLUOQdM0lGVSp5tcAM7hSHkRy0LElsLxzhKhsKxKlAYRGI00Hzt9fogR1UhVGYM64ENERTi+Etg0o6hzBCkh9yFomibfNIZ4j4YcAnU9GhVKcRRVhVqbzVs1OONzNUntdosihfVMMRNm5rYQjh3DiaeORoyau8m5id35E0d7jdpzF5EndOOPDVY7zmYsLa8AiaepmvQRkFSXra5kWBvV1Awiyah7E2JIaRZRZXOvYlYD/cEJqt4WVlC8Jmci4hlGI/iSkQVGQSmFcX7cSO1yy8y+X5VlNQpRKsmruqZxVVJ5oaoizo3LDJ0ZiII9+eBfuyDWdZ1C8094bJP2hVme75oX/olYr3OOlcFK6tkQJbfShaCK847SCzIcMYrKwVOBFfP0p/osDU8RIngL9K1h2gbM+ggxZK2NREJTBV/0UHMoyRHx2YGK5lHxmEambERfAmJGUGgoCZZEjpqmyY6RI8lJN0A/EfG+jfBAGy1sI1uTDZfObYDHs3Zy0LNIlhE0YiLEaLnU1NE0iSCgUnB4MRLx4CtUIoVEvCklynRcwpumNFN7TaKm1EIiZOT1aFIoPY2rttoXMab1QISmCfh+Sq8cnz9FNIdKNvgkd8M5h9ck9BhjpPDp8/1pJaatC/b460U7piGE8d+eyNi21+bJR3TXH9alM3AuF+dsBnfbtm0cPnyYxcVFLr30Uj75yU/yoz/6o+zYsQOA4XDI9PQ0999/P3/8x3/MwsICo9GIPXv2POEJ0ToDqsqxY8dO8/6fKF/ARAlSUmqDMxi5Kcq4zEg8dRMYDkfcdfcDzM+fJMbI3r37GM2XNHWDlx7eAscXaxaDYxiU3/yDv+ZlV23nZLGJ4Mpxz4BVZyBy6NBxYj0CcgMX78E8R4/Oc8+9e1LYF6PQhiAlhuBpOBErVpaX2Oxg374DiMXxsQ1PVOXQkZPcKwsp6iD+26qCMzOOHj06XlSfsNOW9vW4XPteU3Do0DIhBPbuP8QJr9Cs4BwcOX6KQVBOLi6zddqjYURR9BkOhjz40CHqasDRw4eJ3jE4PsMrr9rF8brizlMrLBw7wZ49D3Hs+AlGtpflYc1oVPPAA/uomgFaViwtLSM25IEH9+JCoIo1hUgqfXMFw1OL7Ng8y3BhOWm5S8n8/AJ77j/AgWOnWBkMeHDvXubiPL1cChq/zQ3OsWPHqOs6icU8id2SGDhzRD/Ex4qhKxAbcPC4p24avDgOHT7KfXsqHh5WDEcNDuOhfYcYLi9x5QVbWJiqOTZ/jC99/Viqblk+yUWbKpaGA8LiCbZevo1NbsCVO2Z55ODDHHnkEZwpJ48vIghLSyvc/9BexCIlkZ6OiNLHpKQxY+XUIjPS0NOGB/bcz0PNVG5dDEhyhmLMxFsRfOFZXl7h/gf2MRUHT3psl5aWADh16hQhhCc8dyUTM1Wg0cBoNGL+RMOe+/ezOS7QGBxvPFGNU6dGhBgZ1Q1qMAzKX3/+64waTzBo8AyXhxADh/cd4MXP2UpYXuT++x5EwohYD6iHKwxGDSZFIhhrQEi6JkM/RS8usn+lZDQa8cgjJ7iPIUcGwvLyMqMwDc6xQuTAoUdQtpC1MhHL1QWZ5Lxv3zEuXD4FrsFbUqNQEZSSFIdrtw+PPV4xRk6cOIGqPrmxzRuM5eXls2iznJ9Yl84AnB5yV1VWVlZYXl5m06ZN9Hq9XGKXy8Pybub48eP8zu/8Dm9729u48MILmZ6e5vjx41x++eWoKt57VJWrr76aX/mVX+HQoUO8//3v57nPfe6TjgyoKvfddx9XXXXVOAXRnts5HglDafCUpHzwiIKKhpHBpttWaDxc97yr+Mbhh4AHuOqKy7h06xRVdQ+sGL2yYGqmx9y2GRocBxciLyk927dNE3Purj2nmZkZdLDAlVdczHBlGezBFAyPiSi3fetWrnvu7rSbJaUuEqExPT4RhJkvHub5VzyH5111Mf1iL6aRzdN9CreCU8dFF27lec/blXLcZog8+d1rjBHvPddcc834OzzxUHaSwCFlO7nxwJ0URcFVV+zign6PUiKKMffQHTi/RFl6dl7gOFjBKRPK/gyXXLaTqzcXbHlwkbJwvOaFV/Gi3Vewf6nh/3nPJ3nOzh0899orsXtHXHn1lcx98T6mpeC5uy9nWoTajKn+XmbdFLuvvoJShFJjXvpShcDV1xovj8Zf3LwfJ4p4x9zcFNde8xy0qKh6FZdeegnX7r6QyprE4pKJjn1PEGbGnj17uOyyy6iqCniiKYe8BVfBfI2opxaPl8DSnmOUxV5AmJub49rnXkvvlNLv30+vKrjsORezuX8n/+RHrgfn+X/f/WkODg3nlJ3TkR967Qv52NceYjjo832vuZaXX7KZffsPcvm2aWbnNoEZXzt+F6Ue58JtO9l9zVVUXvAopQVMqpSHFtixd5HLL9zC93/3y7iw57DFETM+sljXaFbvdE5SNYMpGGzZvIlrr7mcWffkQwNHjhwBYMeOHaetU09oeHPgaBQb5r5wnG1bHdde8xxmtUGd45GVSFHcx9R0D+cGq1FAFR5ZrClnNjEY1uA9m2YrbKHiFdc/nxe+5AVsqVxWBjRWFhc5eXKeSy69DCS1PE5VB0mqfCQFfRsxtaBU1b1csnMLz3veZczMrzAz+zBuQSgqz+zmWXT/Eub8OPTfFjcagrqC3twcV1x3GWD0aHA6Al+iUqVNh+Uia3ls81XXNfv27eOqq64CeMLrAqS1ZW5urosMrAeYGTfffDOf/vSnOXXqVAotFQWXX345P/qjP8qFF144fm1d1/zyL/8yO3bs4J577mHnzp18z/d8D+973/v43Oc+xwtf+EJmZmbGr081sskjfMIG5rTStPTvmcd6YhMzL+cmKWcHOcSaUwKaA2cTk9blnD8IrvAcGQoueIKUjKqSRgr6tqoBrprCn/3NfYajpXGuOO3+a/o+UGqgRPHS9h2HMQe11TAQwQvMTicVuJJICMtsKtNxkh462QHIYzF+/xOHc268kD5RPsZq5tHGRrflM7R553atb0VuIDk9m8tIFRbwZY+hOQ7ML/KcrVuTUfdCBWyrHIs9oZCAF00cCsnktTCEMEjcjPEJpbCrc2m31PaXT+kDoy/CrEsGrS3NjFmwKGocN65arUYUHE98ETzbGD9ZrksevHFlyth2SjtnSddeks6vZc0GSKVsF1bQ6xVM+TqpBHqYshU2F0mQCQ3MFMKsF2YciPM5Hw09McpmiSmJlBiZrQI58NzqNxSmVA4Kl2ZzZcpUPc+M38GSekajmt44KpJnjOVxlifnak1GCp/UmjCZNpf0i+Tug9JOXHEpopEbECtG0ETKCwi1lPRdysur9/jcjdSLsbXyeR+er3m+Rq7tUcDqdzdj4h62bNbT+JZlSdM0DIbK9FwP8amxenpFTJGFLEjRmCRVz+UVDi4NcV64dMrjcGCtlkcSsB7rrj7GmLUbwclxfTLRgY2EdekMtHn4GCMrKyu8/e1vZ/v27fR6PZaWlti7dy+Li4vs2LFjbCy89/ybf/NvGA6HlGXJ3NwcO3bs4Od//udZWlri8ssvf+I5u2cZKQ2rhGioMi4ze1Sxkyv48u2H2HHBkNqEppihocBp6lcAQoiR5eUBs3MFTrJYCFB6YccFs+w9NmDKK8/ZuZV2OUgL/OnZuzbkN90zvAilBC7cNs3Fm/uUOkIp8vWjXUG+LRLW0wHNrLzJ79U6W2IKoxU2V5t42fMu40uHjSPH5/mzv/4sL/6Xb2ZFlU0+Kds5Us7Zu2zrSD3bC+DVL9xNGRqKc/nyZggxXRccThVRxSSRMDWfc8z1+Sm83TpZT8MAPYWwsYFOrPiW72KWDHMpMOVBnGPkpnCVUbqG0vksfwslyeksRNE8OyPClc/ZydU7D9C3IZVrs9rp89oQs2tNpdg4v76lX/GG79jNZ/eNuGfeaJqaas3N0jMgSScAOf3ub2Ig6qo6ZYpuZK4Jwpyk744rkpPvU/lvD1jNzbvVD+HxiZNpc9LG2/7/7P15sGTHfd8Lfn6Zec6pqrv17RWNxr4RJEBwgURR3CTKMiVRkiVbu/38/Oywx3/MiwmHYyY8MzHv/TcR8yZmU3ikpxmPn2VZdlimRC3UQpEUQHEFCZIgNmJtAN3ofbn7rapzMvP3mz/yVN0LUBRJUQQFGsm4RHffe6tO5cmT+Vu+ixGCJ6XMznjCYbeK8zK/byIJpFQWkmWieJDARoJf+89/yokTx/hn738bVc/L6Y3a6aVM/0bfjlfjeFUGA8C8rH/ixAm892xublLXNQcPHuTuu+9+CQtgVpq//fbbAebtAOcc1157LbAXBc5e92/akK9RqTLbU2LLvdTwHvOmHNZVUzPe6ljbnhajkdCQ+x8UyyAB7xw5F2R+dh7niqTrUiO8843XcvGTz7E0MN76+hP91mD7NoS9iMDMsNRSSymtBmf8xN96E9esrPCBT36lAI60oPSFGXZ8L7vYA2T11wd/5arB1x/74IO295nM5lvO3rXQywWnDnLH0eUhP/72H+DJ3/w8V9a3ubK1S8ZoleLyNucZGN4ZXsrf1QxJkR/9vruo+8+v/X2av//Lr1CgGMdI70iY58CxWeCSTYt2P3tbeP+S89ebZWwvGbOs/dsxXoJrKwdQMvZVQ2aBwCy43APDzQIaE8F5T/I10Q1YaBxStzhfFQAafRJsWgBvs3IzcOsNR/neu29gNN3CWUKl7t+2/ynbu8hyvwtAcrkK/JO/+14u/PaDPLt+FTUjuCLfO8t8vz5wcGbJPDMN68145p/7Wxv7ZmkO4hPnEcnz9zCDLhW1T+1BnClrr65Yriu4Qld2IsWTYNaqsH0KgNLrl8yf+b6sP4voZSZd3D/NfVUNK2qZg6oc5jiHc/0alVm9ouB8zAvqHFk845i5sDlGRrulyiMO6YGD/5VU7L8j41WrMzDL+J9++mlOnz7NI488wlNPPTVHPO/P8J1zhBCKu1kIpZTdl8FDCPPv7f/+37TRF+H3nZblX5IaHZ7OwCqh09SXSWcCQ5FBVTKlTmrIymR9jal5JuKLkp15snWoDzQE8It4JywE5Xrb5K5FQapdmgPGSKznbEWUjg6YHT8tDifC4XyFgzIpBj9mHKhggEGoWJIdWiuaB8VGNe8zJclgeb55fruf+7JhFQ332fEfKaJIWTxTnUGVSmCSTVEJRBUGVcXBCg6kMdlqcDVOIaqn8QGnLSZGFkeTMkthQiYz9gdQ7zhMYuh6kad+Doc+EwU6Zg+mgKY+8y+begQaH1C/WIITLwRgqkaWjKoQUCLM+7lFEcnogITNidvxq2tIf+1Ds5IssmOOP3j0HL/zuVNEK9LZKqVcXGkEXKGXpY6gmc5AtMNnCBLomsBS3OUm15KqgARotEVyxjnIuaJOiaDj0tqiWPGu1MIwZNQyGektcHTvULPMxDmsEipmlYKWJSfcYFMWcoIgXLM8QtSjllAXibOo6y8Zph2tZk5udfzf//grvLi5D2xo9jUD/G94bgFIiI2Z4kgukKX0+bN41IRnL2/S5Ui0AvZtoyfJkMpagiQcjpCgoXgJ1HUf7kiP9ifR5swW4HsV0sIAiEAkmyMBVR5DLo6FlU7mAfWCRQ6xTZaKTMWCJJyrSK4mS6DKHq9C6qmeCyq4ZLS+BtcwsMJ6MucIKBUGFjCpXqsM/DWPV2VlYHbgz2gjDzzwAJPJhOXlZTY3N7n22mu55557XtIr+qsAAP/mDJlH2nt5XPn/rNabjRQvOHtJZaBseHUoUbX237SciFlok0OkGJSYFfriwVFFN57QeOOmG67hf/uPf5obF4es3HYDVRCWQigVOudwNsUIpcxoHhWoK8d/9/f+NoeWGrbakjHUZHzlqZcOcE0QnBaNBNc3jffujO377yvzpMv+A9HK/M10/rPMytjlcrIZGSFlJYgwcI6RF8Q3dNahQKdCcKUnrbN15wdoVfdWLLHQEaUoOmKZbA0ixS3Oeu0AN//8gWhC7RSzSCWBt991Hd/3QstnHn0crPC/izFNCdScQZzZ0IrNp/PlK/obOM++9fntcScqwkcfeJg4Vf7e224sPeKUcOKL2pzsUWIzwtjAnBBEqJxDHLzu+oPcc/0q29sXCc6IKdJlqFzRZCjv5MiUgKgy40ffdhs+tuQ5Ja3k6AWxUu53EgEpNLZy0YnGV/y9H7qXC4tX+J3Pf5nvvetadr+8ztbuFBOd40f+0qEJQuD82jq/d/9DvPvWZW5YOcFfy9qefRxTsDTX/Mja6wuIYCZs7Ezouo6UFVErwa4EvLU46/0IKCiKYurkelxHjyXC472j7rEGJZAqIZNDcWqop1QPrFRXknh6lQKGteN973oLf/Kfv4KT0vYp6oNl7xZz/d5T/j2oIjYzAnPzamF5JopiIhT7829bReu/0vGqDAaAOV3krrvu4sqVK/PS/9raGsvLyy85/L9ZMZpXy9ivmKim5H5OXp7vNVUoqmqmPfpY6CK0EYTy8IsPuDzlYB3ZSpsshcxiFbjp2ApL0Xj38QpHpspSTF/U8GlMkATVCCjGPR7HiWOHCBLZnLSIZbyUDV7qmuWFmpAzNTMg4azEOJOr7YuNtleQfEXvnBkx9nM7K09IOaT3t2O8OOrgWVhYRG2H5Gt2DNps+BBACvwqiBD9kLEbIXGdpek5vLsRFcGlK2Dg5Gj/IV2/6e2FcuqKyqN0a4gfMPQ1x5dqbjgQ+JLEAqpWsGxInh1offldXCmYS7nvXgRnReLXekzBt31uzZBemco7YZKKJC0I3kHWiEg9F6DKPtC6ml2K46X3QqiEGuXQsnCwbol5SuVgNyqpHlJLOZiyC0TX4CjCTrUZ141KxWZ2DaWwtRdQW49IL7gBQGbgNuW6o0tcf2ibkbQs15mFxuPH5d58I4GU+NnK7vUwXgK++1bnta8eSbF/rjBqYhEOs4LXMQeTdtr/eA8gzHu8ezXFOd8nV7OvvWKxYCgVwVoW8xU2pAKUTCDhaaxFdAJ+RHaDMila7L2LCFp5zSOrQ4Z0VBTtCKeRRiYkkV5qu8yLIyOWC7f/lVmdr41941UZDOyn4Wxvb/MzP/MzDIdDRIScM2tra1y4cIFrrrlmzjD4bh37hTFU9auiZQHqUIBsMxtjEyFmiLGvM+RMMmEgys2rws6ZbRrtEBUqhuCFUZpC3iaGQyXbM2XtmQcgJQ7e8yNAjSf3vHLw5GK/K+B6ilsVAk3lcJrnVQ5DEMvzsqTQW8/2GcgrvSGYQYqFUz6/TGY2u/1XNpyD4ByDYUDN2EkV//nPnuCp0xu897ZDqBTM/wgrCHcvrH/5z8jPPYPdeic6OsjOlz+M+CGjN/0U0Sqcr7Ac51kr0mNFttc4+7nf4fi9P4RbrAl+iUYySaUI51gvkqLWA7NlnjnO3AuLSU9fcSj7L3910uE3MZ99n3dmUBW87+dVegaEgvStGhFahckk8dsfeYitcewPqAIQrEms+o4uGAHh6uYODqN2Ai4TKQ6bo9mNVBiQcBiZClPBZGYIDYgwI2/6XvwGBXzpUVfAks9UaZfVhRGjatJnp/TiN19nyOx92PONYK/uNbtNf5UxLwzgEakIBjWJrDPVzFIRiikiTkgzgSPVHqMimDLfR2dup3vBQGHUqHjyxgUuf/qDNHf9KPS0zCygVtQcjcJOcBkG3nHtgYalyvdun45R3bDaaKmKOU9tkRplm7qIQUlgRhksfhtGlr95uK3v9vGqPSVnQL9Tp07xe7/3e4QQqKqKyWRCVVX84i/+4hw4+N1WGZjnjT04Mufcq31ZX+Kefd8ByqCqSsRtCq6U86KWgAAD74wsgVuuO8FPvOMNvPmmw6wsNqWs54yJcwyswhEwr3jbQMTYOfsIzXQT7v4hECvcdxy1d33ZEbIKyYQmJRakZVDBWB27FPpdbYZZJnlPNMEbNH3gUsqBzJhTr8zcWsmehF65jdmmWw7e1M9xcMWmNfQsgc2Jcv+XnufsZkfV+7oDNJbwGqnIdKe/yMLl55H2Kn60wO7Jz9C5RRbf/GM4Kc4TMlN3NAXxiHbEjecZf+U+4uvvoVm6vqhRWib7hs7VtGq0sWzKqnneEjATLBspCJ0qjUiRi3Y9gGvetP72Ta5zHpUyg66nqDnXAyf7YGUmoZz6Q+Dy1pjNx9a4YbFiJjFTC9QS+Yl3fy9dTry43hK7zOIwUEkpaJsYaEfIGbRGpEA0ESkqkprBBaxnZkQEc0YgMZSuUBVdaTV4AVGjkczRlQFvvOM6/uiz5/DM2BtfX4CpZ9qV2Mu7uSbA7N+/lWH9fLUINVUR7MmRzldMVKil6H9Mk1A3TV+KLwEZbma1PbvOPRxSFap5a2y2lvL4At2zn2bljntBr0cC1GgJ4i1gplTS4lzD0aXA/+Ef/wjXDAeEnhp7wzUHeNdbbuWpi9uIW+C6Iyv8g595F7/ywc9w9uq0AG7Nei8F6MyRJOy1Cb61qXptfIPjVRkMzACAZsb73/9+3v3ud7O2tsbOzg4HDhzg0KFDc/nU76Yg4KtHKf3PqXD7Mo/+2whC4z1eIFt5uJVi5JJSj3i3DFIzqAOHGk9eqAgOkPKQRmeIeYY6wuIW8dJnaY7dSaUTFvIGpVY927ZtjkpVhOwqTDyLTFnNayyEEad2lE88c4nrl2recHgR8cLFrQkXN3e54/rDxeDoO0gd0r4hrDMueY+3yCrMpHW9CB7DmVKJMU3G1a7UQ8JeOAZWOqwVmZGug22ATXHWMsibOE2ItcAiJoHCGOgPNzxiLT5tciBdxZuVMrYIjbVUkrm0lbgyiUxNekBeuQez3DGL8NSFywwXRly7sEAlhrmCtvdzNPi3Zx6lL2285OXnh1CPcMehVqxzyz+Xv2epQKpC94PS30ZZbSpMGs5stNTe0eSWyvU9bJcIk3N0G1dojtwDdYOIx0xJl59BnOJXrmN8/iQLh6/FRkfxmmjSlKFNCf1czG14razD4IxB8Gguvhxm2ksef0OTUPrps6dS9u7OtzqiCV86eYHX33iYOngUePHShAtbE1YODEvbJQs+hH5VlMhk1oOnXNo+DZQStEjfx/AuIDqlu/g0h+JFqtMPYNffgbgF3PZZ2q2LDI6/Bdp12rUnGB59K5V33LQ8pNGyC6gZIy9cs1Rx8kLEec/SwHH70WUO1HDeIskG5eC3ooNwdiOyneqXzuFrEcG3fbxq2QSwBwxcXFzkpptu4q677uL48eMMh8M5o+C7Oxiwoo+u+wllzLRr5g9QHSq8CHN7WCd0KdO2CSeup6oVh7FGOwbW9diDgKAMGfcv38Dmec7f/5tYN8XSAGc9bYi9MKC8bdlQo1QkcVy/2vCjb72Vxjk+8qUz/I//9pP8+99/ABVPxPPgE8/zW398X0HBQw+MeuV3gFl2bZR5lRlewCDmHmWtew0MMcWRSGrsxL4dUjrgRZdfAuoqglBaHzIr20tf9WjBOqA3ktoXDJSQogQI3hK4BqgQg++/8zg/eM8JXjhzjkeevURr0NoMYV7aLCIwTolf+Q+/w598+oE5a6Pg6XkZePOVH2aQCaj1AlR9H1ysl6l1hXWQoM+wDW9K6IOYxox33HULg0FDFoe3yPbJz3P5Mx+AuDXHIahm1r70x+w8/lG0u8wL9/8meuWpIumsie+56xb+1tvfQu2k763PhLRm2ICelpfy/MLtG6gMGPufyq/++7c0d8DmNPHvf/djXNidkCnVvideuMCfff4r5B6QGTOEambTtO/9BWY+JmpG207ngcFeoUAg77J9/kmq8UXyYx8mb13FWcf2kx/n6p/9/5AUiee/wrn7fwOsxaTqg2HrX0JwZjTaUjtFnKeRxJI3hjrl2sOr88ptCAFfDXjoyXOcW5vOxadeG6/MeFUHA7AXEKjqvHWwX5Hur6JX/0oO+6qvl/2pNPlf+gv7/zCrDDAT9pT5i2n/uUNVKgNqhepm/bzEno3hNCOiRYHNMp4E4sh9m6G27ZJFqlFNNljevYAkUFugmMPObIteCvqxPstKCMdXR/z0u++mEsc2Q9bdAa62ShEXc2xOM9vRzTff2Uf8VulXf9mYlf9n11wOfiP37m26j/5l1us4UMxqpG8wezEkR1QCSeqi4rYvG45SkM8OSNREaUCq8vOu7iO30q/x+48KS2ARXI25umSrlsE6vCpvufk4f+vuaxGBjWmLzg6yvkpUgINGMrg6UXajvkT4dWYy8+0c+010So9cimth//dSbnckg9wHMtJXUjBXfCv6NWx9y6gIztAHr8Z733Y7wyqQe8OhKq0zGp8HiajQF/UjC7svMIznQbdZHj+P232RIIXn/oYbruE9b7pz7rQ3y/n3lDT69lDu+u+7vambRd77vvZ/7vmPzRbEV0353nvN2nzRZhiDvX8rtr26928YYxO2UmB9rESRQi9uRqxtj2kpFNWoSgj7V9bMobO//VI0RdRAxOal/V7wFyES4g6VtixMz0PuEEks6VUO7jyDpS3qyQUOTE9jeULHLDmQ/j6VN/YopgkDvFNGAXyecuuNh8va0MyRw4eLJqGr6HpjqSR9KUNeOmWy7xO9Nv56xqs2GHDOzQ/8ruv4T//pP/Grv/qrnD17loceemgeJLwawIOzB29vf9kPNipl0oyCtaWnhpGtwyWDNKHFgcLYBaZuAVAkJVrXkFGkbvDSYsBEBlR1TYxTJmaoRYIqgZbackEFOy2UIoOyRA6Ufq+PEMdY9Jh1eL3KbHPOPUBtVh9wJAylyi1DU5xUxWJWPJV0uNzRekd2hU2grmHilxgBggNX92oy386Zl/kBWSSec6kAmC8qbbEIp5ZqvxJTRMlkMhZK0FkRcQptWMKyZ8kmVL6QtUyM6OBgvsiSjokM8Nqh1qF46qzU1GAVkpVDskXNhCmQrz7BzqO/T5quo+N1qjTFP/Uh9Cv/ETe+QHSwKDBQ4eL2BEtGYw7JLeY8wTwRwQeYuIPk3ICH6IrMb0D2dK2/TcPEyCRI4FTIwbNZLSK5uOMlFKOlU+OzJy9wbrdFmGAuEkODBUflYIG+miEBc66AIFXpXMdSrdR0OFGiLKF5gEUgCUmEiMNborEJZg24AYvdJfTis+Tcor5mWY1VPOYdnSutlRKPRLzL+BRIpoS8Bo1nLAfI2uDVILZYbLEUS7CGUrQyyhNd4IrF2XJWTdqD6EF0wgzloxrZjJmPnbzCpUksoNDc0qoVjIJNCyMod+yYcf9T51jvYLozLrbL3mNMcAGeurTFx09eZaKOEWBtxszjNVKbgnrEAp0sFjAxHrPMclWAu8WurAj+uKgEEzINWQUkk5tFMg7RNdqdddz2ZeK5L2M541IRQks9QDM6YYrDOSGniIqno2BjljSBCbVGRt4wqbAU8Ro5tSt8/sxWqdD1gZn1a0G+gcrMa+ObG6/KYODlet5f/OIXSSlx/vx5zIz777//q37mb+4odrPOCj94lq1aSVPnUfxci7v/vrqaDkeykmfN6HiiBSBoWjLc4FxveqO4DF49A4oDYUyFanb7Tcc5enAJL8W+dXYNwixzrvuaeIJcBGLIEadjTNO+zyJ7COq5aHH/IPeAOnGOnKY4dP4e5SF3ZPN7Yjvi9yGcvk1TD3vvMQ9hoDVPcqGY1Mw16fesZks3vAQq7773DRxfGWKa520SnSO0YVh5/s4PvJmbjy4RUketLZK7ki2pYTkXARVX8ePveCM/+957qXKiffERLn3k3xDXnqF99kHcdIOdBz7E1Q//OnnrQpHgFY9J4PGTF9kaJ0wqsto8uJlVPbLUOPw+n4VUpnSfD8C3Z1jPwPBznn9ye64WipE1EVX53T/5NE+e6oNLKcejuBIP+tlkzmoKfcks9wV9mbdFPA4hiPUVlFTkni2WFo1zmGaCdVx69AGs2+x/x/c6BYonUVthwJgERDMD4NDSiH/0U+/hruuWWXARyR0t0EpFxBeRH90LhXtYxLy6NfeZeNn87NUPCj7l/OV1fu0/fZQLazvz3n0SIfbVkBnqf2OS+e37HmF9Eum6VFZeL/KVvedTjz7PBz/2ELstVMHPu25OAE0F82LFddBppHhjZoY+lwBm1rLRjNMp4st1eNuBtEuiIuMg7iJpiuyssfHYp6l0imiLh5Jk9C01nEedJ6VImAX54kolQhyCUXlfqpG9ANGjz5zhD//8ob2JnM8aL/n7a+OvZ7wqg4G/aMxc1U6fPv2qqAbMRtneEtJ3y4vYzf6jX/vtxZUDsjdTac1zJRqtG/ZlYfCa8NoRk6H9wepNGDkIJkiGJmdGIojVtF3Amee265a46cSRAmbb7yA4q/HtFe5JsSu91tThcsRSN2tOMD/U+9Kq0qvMzUBLAM4zbTs8Dj/bcKCUV82+MTGXv8YhfRvGcCCBcVI22kwXhmwlI/W8cwNSKvdotiED3HHdQW493DCgBTPU1UUxTcCZMhTjXffcyrGDA6TboMm7SJoUGiaGsw4TR2fCm265hnfecQ0DWnza4kh7mjB+jqWdk1Q2YZB2qNt1XNwpOg0+EN2A6Bqm5onUZOf78i64/lAtwYFRAYHSlihemN9e6mZh9wm7aky1LFJnmRmexAx8qOliYtJlVAotzolDtJfI3Yd0/4uWxuzAhDLfQRJVtwmTi1Q6LlgLK2FD+cQRy4k6biJ5C0F6+WhDtDDoGzoQiOJpBEY65qB3vO+tt3PrEgy6dTKJC51yPilbPrDeKdn7vsUgvXzu/NJLQvKyqd7fVDPoS/WONiaypr4dIGxFZayUYM9KwL29O2UjJjpXRMAqwGdBZMB2gqupeA+AYzhYKBbiZjR1hWAEMQJt/9XhLeElU1Uzf4O+RaYJp9tEb8AUPz4JO6cImshJye0Yl8c0eYwfX8RPL2DtGlhCdLqHwBBHp4LGjiq3BAGcw4d5+E/d1H3rIiChJuaS0Mz0Gb56gX0Ti/G18XXHd0Uw8OY3v5nt7W1efPFFPvzhD/NzP/dz3+lL+iaHzeU7e+VY9g7h/tDoDyv6cvzzF9b5v/7GRzl1pcO0ANycZVyOPPjoM3TO43pxlcpDdiXr9XTUPpNcYNdKT3bkoZHMoPL95ru3a8lLestGTi2ODDnita8UzIBoMgNglQxJ979GD6rDebqYkT57KhnZHj7ilcQMzj5pyYSEpI77P/s4T56+wNVp4pMPPUHb+9gXYyyd/+LMbXGlEm4/UtPomNrRV0DcvG9fWccCHXnjHOnSaZhsEC+dLfdUBKdt6ZcLDFBCHuNyKqArm5DPPkZ88WGcGN7awtXOY7BEdJ5OKl44d5Xnzm4TXUWyvYKqm/VsmWnz7R2pZa19uzEDkHD85h98gvu/+ELxqrDc96TLGks5kyggy1KW9jhXGC5OejfJPrN+yWvPW2l769WJ4aabyMaLXPjYb5PHlymVBkd0DdkykjvU1QRtkW5cmDVCv3Y9Yr5U1yhr8drVJe68ZpmRwRBjwRLeeZ7bEf6P//aj/A//5kM8ePoS//o//D6bbe6xAX0V4GXT+xeFXXvBQMmQiz5Fb8pjSjT4dx/8BB/7/JNEfC+DbEzajm0FDQ1dG/FWqn7JHF96boOPPvgsrTq6lBHvC9DYjOGgoQoO74oDYMFVyLzyIqEiUQy9TUAJYB2dA9Fduk/9R67+zv+LfOpRSB2p28WnKcE6ltnm/Bf/hNOf+n2wSdEzca60eExIUnHdkWXuvPZgobGJ4HxRPnQoTVXUCJGi52EuoOLKn1+i6/BaFPDtGK+eFPovGV/4whd4/etfz9//+3+fuq7nVYJXwyibsi/gPjWcnxeh+1G2zgIvK4pylcDmzpgvvXCZdQ6yfGDABCFqkZ89s77FxBmp73FLMDrvaL1jsQEfOiYoYwCfGHgj5I6q33z3Sv2za9xzGTTVIhqUO5x2iHbst/TZ+6XCQya1xWFPM+ZcyWZzf1z1JfikRooJVYfOFEdfoSHzz1YOgEsbE3ajkFzD2UtrZDNc/7lzSsUTQ/d0KyoS73/3Xfz+E59kMxkuRoIvLZ5S7kyIGF3cxcddLE3Q6S59TRch4SRRSVEIRDzmPVkDLRVh9xIy3kC9Q3rRKOIaaqkU+51nMo1sbLVEc33oWEYpHVufoTs6A1VoxJWAcy5V/O2qDghJ4Nkru0yWOjR1eCu8/1k7CnGkLEQtRkDiK8QlpO+3zziHqvklr5w09wH0HiwOrNAL0ybtxWfQvINIEeWJrkbiBNMprR/Q5A66DtPe8Mk5yIKjaN47TTQmvOX2a7jzxh9jofZEQBTUL3A6LnDhwjpH68zzV8ecurLFJGYONAH2BdAlrp+Z+rx82EvPNSmZsviKaFKsqc3x5Jkr7Gblb7/jDTSuVFvamEg2C6lLoKc5o1Jx5soOJp5rVkvQ1TQDuu4qqpmmqZlMxlQhMEkBDQOyC1SuIhulHQB4zVTiCjVYMzihymP82QdZ0CUCd+F1gqYxaCSIQ1xLOv8opApsTOIguwY14C0TMN7/zrtZzIlkineOyimuD9IaX4zTrNeGUBxtBDM3k1vcN3X2bcYT/dc3viuCgQMHDvDLv/zLvPDCC4QQuPnmm3nXu971nb6sb3AIm9HotDgEekqBXfqsRwkIeQ7S8yS8FRnVcTVCo2dKxcVpZmIFfbsWK9ZakOBAlBCgQ9DgOXxgyDBtspVbJjHjdEzjjdoVUJeTPdzC/uFmfTvLRRxEY/nKaV863/+OGWKRGmMoETcvSAu4UFTfxJF79rXr2Q2FJmm8ck+5zS/b+pJ6tDLnJqFk97PEs0d1e+/mPWCkXPtCUzFymciUoY8sVMXxsVCmCo8AQHJEdO+4VhGyCziUEr46kBq0g+k2KoLfuID4Qm0rQIAMu6fIaUzjiu9Dq4muaxFcYUKUVy9VDymbZieeragQE0eHFYj0FLBv41yLMEnKtltmlwEOK2V7CgiMnmaZVIjZE7WsD5GME8U5+5oCPdZnyHvtqRmTIuGspbFdhEhCig8GCRe3sfZKEcEyg5QIeQedXoXFa1FX98A5w43P4FxFMzxBNagQ6QMpE0LsSJUn+xFT1zKxYlitL2kNzGoye5f/1dilr6Z2Zi1+AG0s06MIm1ozSjVrE+XIwFHPAn8V6MGFKkaUTHaCaMCoyeaKdHY1IPV4l6au8U7w3vU02eKlEdSoTVgMxR+gth3YvoRrlqlSh6SI04zLuwyIsPUsITdIbokqBDfA547leBHLAZteRIYDvCxStescSJcYpY6V4FjwgU0V3Kw1YYnaZYbeqCSTTMlS9Emi9k6XX6NN9Nr46xvfFW2C48eP85M/+ZOsrq5y4MCBV11l4A8/+Qi/8aFP0gHSH6RYoeEk2ZddAEYuBihAdIXStzZJ/N9+/U954coWnTi++NxFHj61QbYEKBWCJ+AUbjq8wi0HF2nX1xmvXeXOE0e5/fprqZ2VCF3+or13tmkZaO4z/ohoQlPkpcXnHqRkHcuDwN23nuDw8gGkBxI5X7jjWYTclyoRSDmRc0L1L6gyfDuHFa4G9D3uAmxATHr53jK0bxV4H/aAqcAM6OgtslIl7rnlGEeXF3rRJI8RMCtVHXMBvGcG7FM8rVsoIDbrS8xZmV5+jq3HP84wb8LpxxEn1Nri4hhvLe19v0leO8exxQHHD9QES4QeqPny+QumiDim5vjs4yf5f//mH7PV9tK7ufv2brEGDz58ki+fXMeGw8Jj76sb2pfTjdKeaSOlBO4cIq4EDn2wVYoX+47V/l6U6lMPqC0hc1+QyXiLJXAFnHU0eQd94tOMH/lzKkl4nSJpjF78Cs99+FfQyTmctZAjpomNz32ArSfvh55+2EtAcdeJo3z/DYscSlepcof2pfhS5dqv97EXaGrPo395MPDywndRuSwU0PG00E0zYMMVHnzyHB/800/P2xA5Gz4ZLu9ZV0dy72VRIRZQNWLO1HVTwK8Gg0EooOLgCJZYbhx3nDjMME255dAK1y2NGDKmO/UlLn3kX2Pb50kXzzKIU5x5jAaqBsZXcXkC2tGpZ8KoAJYnV1iIl3j2E7/H9rMPsNhe5uRH/heOxxe569giCxhkJUsRkRoFoSJx63XHWF2qcRrna9mcJyYlZ51XgF46Y6+Nv87xXREMjMdjzp07x5kzZ3juuee4evXqd/qSvu6Y8YWzwen1CU+fXdsTgtE8B3lFg6kVdsFMUGaW9WlfJNztIqeuTpgmR3KOzWi8cL6UuMGoDEKGoTne8frr+YX3vZ3GMkti/JO/+y7eesc1OM2E4BErVqd+v4mw7UkcF8VDAe2z3Nzteyx78xstAcuBofDf//33cOcNh2coQdBCXVIpG1imOOruZke2IrO752s/q0bsca6t/0z7f+IbmOx9AMUiGDMDK86si+mrFNmYg/9mRQExnavOBS/MW6wmcwEfEeHEwYb/9S+9hyMrI9S09DklgPMFxFYPsGrQv2pB8rd+WAIKMmIdSEvcPk+zfoph3qRp1wmjJbAOEaiIDHbPEyaXueHwkJ//8TfTDBwpd3iLJNXCN+/R+9pjEyRUXFjf4ssnL7Dd9jiPfo3tP75s3//KHXvpkTX/+Zdz6/s1Yv38JjMmBhe2JozVkfC9iZLRCUSR/j6XzK/TTDIQ11MIpFDxnPRNqJ5dY2XaMTNCSvOr8xghT8BasgOTohboMNAxIW0xnF7Ab5/Gp12qvAvdGrLxLOHSo4htl065ZSRnhtvPM+yulBaCFKaPV+P973gD/7v/5t3cddgzpLBCciyfWeaVCu3nqchra3/N9KJSX4sWV/wayu91MfW4E2hjZkLD1c3t/tUhZsVpWZOtwdQK/XiGL/LmURU0ZwbBoVb68gtBEQ+V8wRTllzLnccCCzrmx97xRn7wzTfh0hXy+ikGVx7CdAPtCo5FCLSyQNcskyxhFkGVrJ4oDdZ1VHETn7aRzTP47Wdx4+eor36Fe19/mH/0k+8oVUUnxEIaQVRZHjj+u7/3Pdx8fLGfQytVRxFaFSY2q63NdpkyVwmYWBHbynMthtIWey1U+ObHd0UwsLq6yt13380999xDXdecOnXqO31JLxkzSN1cS8ASmhOtGpfaxDMbRudHOC3WtrhBKW4aXBpHPvDpZ7g4LoeuJA8C3iBocQ/zMqXzy4SuKZmI92xu7eB0ACLUQ09tipddDsiUhSB0oaIy4+jAs+TAS00KNfjMQtzEpS00T1E8QmJqBdsgpkzcAppbvEV83i1gI8oDqVCoQ2FA5YQba8eKCNlXOISBeNAKYbuYoET4w889w5+eirShxuI2ZpGEgcWyrWrETMvrW+FxF2rZLKf/RkYiY0RA04TOlC5HMkUWV7LizBirxwLUfky2VAKqPEZzRFJk5IoYkBfBzBUzXOfo6hFL0nJj8Ih3tL4uGaVlTDtcd5VJdZA0OEZOimalsv6KDCCQ177M+hN/UHjruoJR40TJw2uYhiV2qhNEBFHDn/woEnc44Fp2a2FLHLXucKVL/ManTvLilSlIYUOodjhtCc6xVh8lOo8TBV8zA3zu/+qRLBhKkr6S0fvY7+2yhpH7v6Z54JpNUU2cHUd+5eMv8LGTU9QnFnymVseUIR948CRPXt6hNqX2nmlqaaVQDCtfAJ1RBOeUSjJjKVLawSKtGVNnDAKc0AlOjASEyTbD5z6Ku/IE40HAQouL/bVPNklXzxNIhMvP4bqrOF1j8vgfkbaeo8mGRIfKAmB43YaUsC6SrASrLmuhy1VwcKFiZfEAEhtMAztTYSJVwUGYYL2l+NhCsU+OjlbKLJXR9VO4Z1Q9CzxVFXprYczT5MyCtez6JbowpCHTiSPFFrNMCg33PbvJ73/5PJZg1E0Qgc5lpuIRFznquqKCqVOuC5kknqoZoLbAAT/mmoXAQrVNUzkGuxfY/dJ/ISUjMUDSFoSa1CwDkeABKR4aSRwpCS4ZwRS3cZpq5zypywx3ruLzGvHMQ4TtC3iU1RqSBBxGg1F7YTEY1/hdbmtg1UHnR0QLDHSCpZZNBvyXz53k2auT0pajmKAZnq+cu8qvffY5fuNTz7E2TSiJIsJGz2h6bXwz47sCM7CwsMA999yDmbG4uMif/MmffKcv6aXjLwhTXa8Yd+nqFs+evsiJA3XvzbOnLCDAi+cu8Ru/+zHuvv5nWVk4hlKsccW5XlUw4cioNOxhrGYuZaVTf+zIEjddd5yrZ87SBKi9R1ECSuNhao6WARKUXanZ8Uc47JfBfNloS3McyR0pTsoB127jLBFTR6MtYkrqGQR13/sWIJjNy7jSg+SKq17CDNpk/PmDT3LywpA3HOlT7j47h1ID6V0AisKk2ysX71Eav/7Ui1nBBfQbbVbFxPUlyR7NJr7vo0aGwyJw01FQ0BFDpcg6R9jj7Ft5iMQlKqAxiJRSr6MIrwiCtWPcoWtJOiqkSylWrbXtgkUsK9Mrz3LxoY9y/Rt/sFRITtxFvHqB6vrX4/yYcV6i1gq5dInxsw8x+L5NRhrAGiaxJsuQMxPPlx96lNetjjhy5HChqVqmdsKorjBX9dlpAUTM1CRmWWj5UHtHVKmQZIrj/V7Lavb9ly7v3vxIlasbu/z2H32STT8sv6sZh9Am4eMPPsbhm26ArCwMqtKLtgBquKQMxLPTdXhxc/JjMCVoLusH4+ZrD/O/+W9/kiPLFUaCPGH75GcZrj9JyJ7kPJZiaZ1sb9Fub9FoxtbOUudM7TrOPf84SwuHClMnxZ4P70CFzjxVN6XWDvVhX/Pf8F6oq6pUhkyYRiv9+WxzC+ksnoRgThi3IL7XrDBDZFb2/uqe3J4LaWmbiPPUdUWXin+Ik4KwTdoHx87xxa+cYjpNpOQ4vHqA9U6YtolOQTUxcGU3OXp4le9/y+18/OyD1A6Wa+P977iDt544yBtvu4aRV2z9LNsPf5zR3e8n9/bOOlgkH1xFzj0NGFIFZNx/1txCGtMsNtj2BSzvEvyYSjYRU648+WV052qhEWuHd8UsqhHhH/7oOzl2eIXX3XoLJw4s8uyFbbJ4Yo/dcOKYJuGjn3iIwz7xhne9rrw/hXL5xAtn+PU/fIzVBO99w99hdTDga0zra+MbGN8VwcCTTz7Jr//6r5NSYnFx8VVBLTRV8B4oroNuH5e29D2N3JdDW6l6YBu0OpPrLLrqtQvk3p0x5XLAgZJTOYRFhIF3HDu0gjt7hhCq0rvMiVqUkc8MbEKtExaoGOSOq35IJ4GhTghpjPm69Gfby9S6Sey2YXIJi+MiZBK3yOEAGgZFuc+Bs+qln5e+OC4zyFehjHUIu9kRLBdUue0TG6KUB8fi8EAljj0FBsWZ23cwfd0ZL8FDn+Qm54jiaERw1jE72Iocs5ZeMJ4tg0pqdtFSNXBVoQS6Ht8hRqDYs+JrTErm0l9xqSxoB7klugY3OAB5DHED08iiL25z5jLVZI0D7VXC9EWUHfTED7HRPcOB5ethfJ62bRg5sAtXCGkX360zyoepckU79URZ4cK2sWU1uyZ04uhm2IWcCT0AdW+l9QXX+RTOAKDSBwpGZUVXolcomJf2y3Dz+1raKfRtHsVSqX5JX6LGFdZIsYI2Yi/53ACinklr5CQEPD5nKjyOCucqAtCkjoEGKssgnsUm8KY7joIb42jAJ7ytUU3XqCJMnQPdwKV10nSDKgBZcXHCwAXInsqMKk3otEW6TVzcACm0vpQzVR7jbBuxZQqTv8yRd1BXhbmjZoxbLQBdLYe8qhExpgKjZCTtW2D7noX9/33JKrViM1wAo46JAaHCS1daCL2SYcxaWlpWaHttKgHJ4cNHWDt7sagq9I6moQp4EQ4eWOLowQHOEgOvLLLL3ccPcHxYc/DGYywwRmip0zY+bRc5aBVSGJAWj+HdBYbsIM0QE4d3DtMxYhPcygHC9nOIr7HJJg2bSExUeRexCZYTnoi0l8n1MbwLfO+txxAyR1YXqXOmckaVp8SwwMSaEoiKMI2JudT6vv+Pvqazmih7eiD7n/fXxjc3XpXBwMtpOiLCP/2n/5Qbb7wRVeWBBx74Dl3ZNzZMte8fgpqSct7r2RaAcM80LgIy09mhApy9us4nH3+G49ffVJTEkFKsFSk8+J7rn2ZcQKAJEFA0Rbz3OOcIZAaiVJOrrD96HwfaZQ7US0we/C2Wj95NbdfSvfB5po//Kf71f5vmxnvZfvjDDM8/xiCt0z32ceTqWbCG9tRjVHeeQKF38uslQ+nzyVkWTV8Z6OmDirHTKVOtaPIunhElv+7zQREurm/xkS88y4+/824ONRXzUEKAWVb/NR78v+hfBcA5nnjuEi9c2uAnvu8ORmKA6zfX4lIXqsA4V/z+A6d4w/FFvvzoaaYyQKq672dLn4H0KukOoq+J0tu7UjrWXkC2LzJ5/PM0VYVZi119nitf/iijPGaaG9QNyMHhJmPq9bPI6YcIVWK6cCNbK56lhROYDMlhSHZTzA9IO1epLj6FlwMISpsyiYonnzlFao3UJgLC2lbHNAvmPVUIc3ncGW5hL42afZJioESPp3DWO/XN/eWtX3G92ZLN4KO9boJRVA29x1f1vHeee0lB8zVZIpu7vZy4RZJU5GrIl586Q2xbfHDFZtkFKGQ/Dg8CR0dN34M3aoHgFJUaswpEqWRKpWOcDXHWMn3sw+SNLWT3Ikw2sBDwpkQa2uoAuAY/uUq9e5H0/BcZn36RwYk7qQ6fwCZbpJ3z2NppqqNvLDGn69ewQSUZJ5loNeNUgtiZgZWK5+mzl3no2Rf4++++l0m3Rcp7eptfc1+gP9y1+I20wEc+9xTnr+z02gfFXtijdAqGJ2ajwtFGw8xRO9/33RVVI6nNzYdqL1QOKit04olLNJKpewlrISM5UUui0klZDeoIYchOc5xUH6HuJrh6BFQkC7g4JVkkNUs4q8nViFo7rNtBc6KylpoCzIxXz7Lz5MdZ/r5fwtdDKk2YGA1Qe8fIKUdlk00R1rUpdF41gi8tmLIj9qgMESbZiK4m9gJNc27J/irXa+MbHq9azMCsnHbhwgU+8IEP8Kd/+qfcd999/P7v/z5f/OIXv9OX95cO8b4ApaAHRdlMkgejtBCkV5IzKZx35zwe4+zaJh/6zKNc3m17ulPG+UBWiCnPAUhms83ain6AdohmqqrCC1QOvu9Nt7MQ1xk/8sek8QZeMvGxP2K48zxBd9l58RHcw79Dd+Fh3Pg848//HnrmMeoQqc49SjO9hEs7tBdPIlbAXJVOkbSN5UzUWeC2dyxXvhxI5f4Z06jgAu97+60s1UVLfi7ninDm0hq/9dHPcH5tA+9mNsm9sA8vfe2/aOz/iXlbwQWePX2OP/n4g+y0HWaQxNMZpKzFMEiEtXHiDz7xOH/+6Ivc9/nH2Z5mxBXchO8lU7MIyXmyVMRqgbEKQoQ8JRqAkncvMH3hEQZVX5VZf56dx+6jiptkGYF4FEOiUo+3SScfwZaXGd75dk6862dpbn4LnVUFMFoPyfUimDE5/xzmEp2bEHUXL5Hp5gZMI406KnM8e/osm9O8J2RlWhDaCJ0VWp/a7Ftzj75ZfFAAfOKZGnTzKGEPyvry2Vc1FE+nMLWiyCfOk9TAB7IayYw2eTJKqJWxJnZc4PnLV2DgcQ1YACrBidEY/OOf+xF++n3vBinVneICWSG2UDwC8rTfzAx8xmSbfPJj2LP34TdPEyxCaABPNzpG/UP/AFs4iGvXGcQ18qkvMf7S7zE9/xikHarpVfTSU+ycfQIp0oB9WCMEEbzkgmkRYX2nJVIqdA5BvPDIM2f4zEOPl/Vhwsz5sKzDr7EvULQCZsZrUYQPf+YhrmyPqVwBxmVTvCmdlvoTLpCsF1I2Cg1VFbEehW+UPr8mgii1wDBA44VoDjdLDiRgVmOuIaYIaQqaitmbBA6+8QdZfOMPFl2CapHsGlL2uDRBScTmAK1bhLf+CO2hG8Fy0dXIRebY5Sl5+yLjr3wSxleodAquApkFqMrrbzjG//mf/Rj/6G/dxYDct1ILqDf36dFcyEwMH0JhoIh/iZfbXzbHr42vPV61wQCUCHoymVDXNV3Xsba2hveeX/qlX/pOX9o3PvoEXm0vGDBgJvxjQJbCW/ckWvGss8h2dpgPpcfdbzYpG/TedynbnPdcC7gci4GOKU4gSObEkRFD1xJ0wtgqdv2IYFPEWiReRdImIe0yai/ibIvl7iIut8jSAYJNcdbiHPi8A+TeEnYN8mU8HYgVfMG+Hp7vJWZFSrCy27bUleddrzvCyKU5H3oWDCQcOzIowDkMXjJPX19Ody8YKL87e93oAtu5ojOIVIxTQblnHF6KwVWrnrEN2UyBlpqkpc3hmIkzzTAN5XOZhCIalXeQvF6ommZIGjOIuzTDJVRqfLfGUncB0gRTcNMXqbtzyHSHoRZq287qjcjKdQxO3IMsXAMIQRIZQRcOkOshVfBEgeQU6BhUivTyxpvTyFaCsXmSHxX9fC1+EG0qjpStGRPKoZOF3lZ5Hz1OIJswzo5dM6azIKFnmry8Q1MqJIGUYWxC50bs6R7OpKod5io2dqaICEsDQcVoTUjOESqoXARtEad4B0Eztx0bcXSlmWMdFAMJaBRc3EHa0zQJzDVQGd52GY1fZHF8Dh/HmASiNagEpn4RbngzMSwh010qSYTpJVbbU9TdFdAJTDYY5DVCewVSzw6QXjcxAxrxrrCB1ncmRUWxj6AMoXM1ExqiOLbHE3ChgF/7mZozJPaPvi1YAIgFGDn2CyRXFXaP9Godlom57AjWqxZ2WjAGrihklTaBFSEz7x1OjDp4xMBbRxMguap3Jp29f6nEeMv4dptALoA8HLZ6K/HoHWi9QPZDzDfUGG58GWxCG0ZQLeGvfSPt4CBOEmF6FfPluZFum6pbZzFehfYqki5irqgMloqIsTpsePtNh3jD4QEh99RKtRIIyJ6i6b7pmglbv3b4/zWMV20wMPPAvu666/gX/+Jf8MM//MNUVUVKidOnT3+nL++bGkppF+wPCIB5Bbc4eBZd9UTg4lj47ONXUOeLgcmsNZDSPIjIWec6/wEYNgHVhBMprQKUSgxPLj3duItoKlawccrOp/4j1bmHyL4hXngR0oSgLVEGtIvXYOLJeJKrCojIGY6W7acfYPuxTyC601/7/CguSGApoj2j4RA1Y2cyYby1xuFaGNiUbLqXmVJ8GjpXCu9iOs9K87zM/Y2OvU3DgIxnVwNThJ2o/Jc//HOu7nR02VDNeB9oM0QXGMeShamWioCTXpWQ0r9tMIYkGpRalfGph7n8hT/G5635TTQz/PJRWr+AtBPqtFNeL+0w/dy/58on/w0yvopYx0Qdk4UbQVbQ6gDqhwSsSOh60DCgdQPMD1A8WI0oDAcV6oVtV/NHj5zh//mhB3nw5BXG2dP1mWMyoculMvDQV07yyS9+hSlGEunvlZUVKWX+E56pCH/8icf4ynPn5g2Q2X0QmOM2jFJFOL8x4YN/9gTTggjYF7wJ2RxJHecuXkFMuX51ESYT4qSlMsdAjcODmkGONGKYFmGaBgjSg0ApwQuUoHb64v1s3ff/pdnYQKwBMQapI4zHuC6RcyDWS7TVIs4XO2JcjYYBmhxdBrQj5A2cdlgb0dQV+uH55yHn/hkr688ZHDq4gmlCDa5u7hAVco/gLaFZYKIVO63y4oVL/TM++7+vPYp5U1FXPL+2y6Vd6xH4isqshaO0sZcsBkw8bdLSEgiCWXHbzFnJqlS9hbmoMqxgWDkcWuzM+/vtKWua2OLaTVg7Q9CWGb+k9Qdo/SodNVYvkcwxzNvY45/CX3yGUAccAfUraDXC513c1ReI6siuKZoEO1cJ7SbdxWfZ/sKfFOwMOhcudwaNKbVBpgbrK03G3mftj31HaX16S3jLX5UWvIYY+ObHqzIY2OObg/eekydP8oEPfIAPfehDPP300zz66KOv5NUw20D32Nn0G+RsY93r0tq+Q6zfbxHK4ZZf8nrFyXAPslX+nKUYqDx16hwxg/gKtdLPbS312TOkRN98KGXNe15/nMXRAB8qZm5kVej10w0W2qss5Q3EEtpt0z70ewxOfxrBmGxcKfQ+ESbmicPVwhuvFxkcuhZoUU14S1x9/hGuPvUASFvo4s6jPahOrIjNOC+853tvxzvYnXYsjGqOrS5SkYoOQS/7Vw58QWXWNrB5lWH/AfOX355ZgLVnOGR9ANVq4Sp3WXng4afZmOR5K12cY3c6JabMJAlJ+mCKEoSquFIKzS2NKgPNVCSCZXZeeJgrT30W0Z15zz0RyKODRLeApoxoJCvUuk185mPokx/BbZ0uoisrxzl2z/vALxApADxNhVKpzTJp8RCDG25lkgw0IDrCtKKuajIw8YHPnN3mg194lk889GwxLzLft2CU1EWiGc+9eJZHnjlDm8umyzxwm+nqG+JrJjHz2UdO8uLFq/Pv04sulTW8ZwWtwIvrUz77yHMQGkyKnHZZliXTi1nY3h3zupuO877vvZXahJCLFsbIlH/8d97NHdcdpeqphljCM4Mr9u0J6zd83SVeeYj0zJ8zbLcKHiUlQgZyETPKuWLhru+necP3oTkSpCBagg/QJcK115NjQjQW5cm2LZ/SlK0Xn8TSFGcJsTGzCtg73vJ6Dh1cQcyYTCbkvsVUKiZGl4xpgmlMbGxslWc/v6T2x0yyGopGQbRCY8xaKJxnzl3g8tYY8xVqBTA4+/WYZV6ZMSuiXZ0q3lvvU2KghcIaiq4zg6bmwNKAf/6LP8qoKS2rovKrOMqaJE3xmtDpOo6ExDHBOZLUJGo69dh1tzG48VaCtFRbZwhbl2iaGqe59xPweKfY1hV0souJQ9KEPNnAa0vaPMvOsw8i3TZCLu+j07KHWp8cuVB8E6yn/paySf9Ql/VZ3F51nnDMdwLh6+0Kr42/YLwqgwHnHN77ORju0qVLvPOd7+S2227jp3/6p1lfX3+Fr2gmPfPyeDQjxFIatVLeS0BLid59LxMiZkQtjAF6C1pTLX1OEUQyag7JA0CpbQLO42ShVHPzgEZg01qqHKmSEpND6foHCq5Z8fgAdR0YmOGdoo1H3TKdG4IN8LlFrAUtfV6fdxhYSz2+gl18Cs0JF8c4CuLeaPCHbqS78jQ2aaHLjOIOzc6Lxc1MQbIwNaVKu0UspfaIb7l1GWpfBEPMA1WFmMdppqVUSqZWaI2SMt6s9NZ9qTaEXrRkthF8rWEUFLsRyFqWu+vTtDZDpYaoY1wdRIAmjxGpsBBodUyMO5zZnLIVRmAtPk7QHIh+QG6v0J79LNJt49wiY1+TJLM8XWeFHfAOW38WW3+O7Cu0WUBDhaaWEMdUccKg3cFypEpT6M4xHR5gZ/X1DA+/DSQh0uLTLjsM2W0WGC/ew/rwJjh0DW07pcodaE0OiywOjMU4ZrnbZjus0toyY1tCaHF5SqeGyC5hWih32Y1o6wWCwcBKDzzhwFyfEBpOlUBiUxqyBZxBKwMiYW51a1T0YsiIdDy1HtmqDuLTLiZCSLtYbkGKRn0kkJznmkHmhpUBravBFcT9gJbXH3GMXFeCScu9CFFCe+0DM6PqlfokePy0ZpQrxG8ibgKpI6vQhQO46RjfbiLH3sz04NuIwfVgwCUazYStK8ixw8Q8JUWlkwVk6wKim6hrGNplZHoBWX8ezn4e8hrd5pNcX+2yujig0UiVdnAIXZdJkgiaGU9akqt77YGS/WruwyWzXnDHcBKBKWKJRy+2vLATSR5ij6DPODqrSAzmbS51nt0M3mecQlBBcmIzR4bDSGcelwRywmcYhjxPQgZeeNuxIY1lnFqR+fWD8rBIpqWjc8u4tIuLLXr6YYZEnBUdjolbhuWbuTK4kZ16kWCJgVvEh2UIHnHK2A/YcgfIkzFH1h+j0V3MMu3uBpomNN0ZqjwG8aXSECd0Zx/GtZdpfSBJwrFR2FaxtEHEIsFAzEjqezlqQczTut43oo8CRKxvlr42vpnxqgwGgD1JWBHuuOMOrr32Wt70pjfx7/7dv+Otb33rd+CKXrb4ZiytWZfaiozvS2sEpQTmpJSfMfCzviRAn9nP42Fz/e/13bO+3+ecA82oJq47cpAgQhuLf7toAeIsWMtIWxZcybDUDakEgrWs+Jb3vOVO7rzhKJVEvEUqbXHW4a1jmDZpH7ofF8eQplioUbeAXXc3HHkdu+fPs/3CY7jcUlvLZOMi22c+j2OCOkofWkrk75yy2sC1CyOGbkTXQnCeWlwBQWmJ+CvrGFC8Aspn72ekrwzMMtevd088Si0ZMe1NhkrNoZQWE1mgFaOVojTnNLJA5L333MhSVqrUcenCObrpmKVaufuWowwl4SyTdq/wlU/8MS5NcLgC3pKC9nYWAeXS5/+YzY//NoOFAYPFJZx4fO6o201ct4Mbr+OnEW+O7MDd+r0s3PFubLQMriFRYX7AgbvezYE73sHC9feyeuv3YqMjdO2U244v8P57b2JRWt50w0F+8u1v4I5rVxnoLhVKUiGYFREZExJGNCto7GR0VpDmhR/fGyHZrA4z8zosv7u3zm2e7e95VPZoFYNHnn6O6Kui1IxROcgpFpyIKqogOGoH1Qw/gpGlGC0JMKg82YzODYq+Q18dmEk5zzcuy1jXITFiJLKvQCrcNbfTDg9DHCPtDlKNGBy5idisMrzmRnxYwgvkGLHhEtNJob8RpzDdIHiH+EFpD+SWrSc+x9N/9ttYd4Wzn/8gk5OfZ2BFCMy5ct0J6am90HaJqXqm2VBXgatKoOU8JsUtVKQHCfe/9+9/6z4+9tlnijAW9BWyfat5tvgBjQmvud8DHeNpi+EYBMM5x5GDBxBXHP+KkaYjhNIuWHDC8UNLNJQDdq+6ZmCpPCN5it+9xObn/wSnBbHjBqsc+p73s3j8bhZu/2HCPe8nVquor3ALB5m6BhPPyq1vo7n1nWjKsLtOJQZpSjveKM/upOBpTAvziO3LnPyz32K8dhIved6KGnqlto5A7iXae83SfeqgZU+Y1U3ltarAtzBeldTCl4+rV6/inOOnfuqn+JEf+RGapnlF33//kSTzsrQgOExmj1pRzXNlB+21dWZ+hEolJfKeLeS9vvk3MsoDUptx3eoyVy9fYmqlp19rBIxKW2pLDJyh4mjDKl4CYmMW8wbvfOutqHdsfr7DWS5oX1UIjnroSNtnkF6oKLuKsV+hue1t2PLNjDRTjZ+FfCuqiWCJuj2FkyljGeFI4Hp1QhLX1pFblge4TiFD7YTKOTppSAbBEqIdTqT3ZvirPd5lS9Ei8qJS+uJWzFCk7zMW6iZEieReMGdFOn74rhUee2CJkxevgm9pnFJpx9vfcg3PPPIQjUUk7eK6TSCBJQZ+JuLjEU2gHYOdF6jHp+iO3EFYPYaEESIB122jMgRaQgy4lYYoDXLLO1h9048SQ4WJowMaN2T4uneDB5MjDI9ey8ZTW1h8iiOjCf/kvTfy+NMn+Z6bVnjHG+6g/chJnjn7CLhCRws5M1HHjnqSNOxoAfhNCbSqvZ7F7CB72QFUilVzams5+HVPq0AigscTEBUsCylCFkMtEcQ4sLyIc6XdkTMgRTyo8g4n4B0UoJonuYCJsDSqydMJUABkbqbWZxDokDTFV4tgGZcmeG9YNqIfYFWFHr2FePYUozQuzpnOE665gZ3mWpavuxNXH8BXBfPi3RKqghcIeRMSuFCTU4R6VIKNzdMM2ysQdzgYzzKeHMKnE2RqhvWQZjRgkvunuddUiOYYx/K58IFoQhZXAse+Bajl6cfMM87QWihWxSZoHwx4K8Grqey5esYpo+DYyUWPZBojGgIDZ/gUuen6Azxy6iqT2BKqYrRU+bLhB4ybjx9g4Aq2QCnhVYEjpPJlSqU7rKQO5UiRrl48xsotP4P5AcM3vA4OHmLnsQcY1DU6WGJbPI1vWL77R9EjN6Mn70dUyDkS8hhrt4jZqOMYpwUDVCytpyxOz+GnFwhMKZbTNceXRywYbOy0BfCK4Eyo7LUD/9sxXrWVgf1DRPjd3/1dHnroIZ599lnOnz//Sl9Bnxu9dJROXNG46xuczBz8Zv2vomsPXvb+7avNY/bi4L0tmfmf1BLihJATSzZlFDKX1jeYjKcsWUc2JWlFzDXmhOQdU7+CygAoB39lU2rJcwpPMc4RxvURYr2EkOikKVlkCIXf6xfRagQ2oTr9abrzXySKI+RElUtZNFMcx6AgyxtJLE9OUV15isoK9ahyRuc8rTRkLeyJJ17cYH3czoFi38owHBMJPHb6Kmc3x0UG2VdMqbiym1AtcrNF2txobMqCg7oSsm9QV5e7Zsaooc/8MxI7GiKC9lrvqe+nB3waY2nMwDao0wZRKjQsM64Os+0Pl/USaiRYsXjdXWdn3JEH12L+SDFyot/3zUE4iPpr6PwQCyvUgxXc5efpnn+Qo37KQFsODSuWfXHpqyWSxCHeMyLzwoV1Hjs9IVJzerPj6fNbTAXOXt3m9MXt8k4v52dRggS1fbi3/VgYlIJ576tZ6rBU9C5UtKDvNdNUdQ8E67X3tRdr8g4R6dsNxZjGXI2I4+DAsbL9AuHMw7isdK5mikNyh559mJ0n7oN2i5mXhzQNmVACStcQrfSRcrtFt7VWNAvcApsLN7ETjoCMyKq0YUTnD+FcjbOEXX0OGV/C1QtEqqIroRE/ucpAJ+BqQrtF6LZBFV95mrpmMFzk4uakBzcK057mm1PGW1njhSIHiPbBomHmUQKTJERqXDPqqaqu1+oQvCY8WsCXM3ZGalmtXTFLsoRS/AYqVSpLVL7FnDBpE1Ud+qqjzQP62pV9pjQyZ3dQQRNqDpUGUSXYGHx57pMb9etzxCQso/WNTPwB0A71hRXiHFh9DK2vIfdaCOID7K4h21dR32DduAQXM3VLUUZ5E848heQJKkJ0Q4KvMRzJ1axHz2efucznnjnHtCCqX2sE/DWP74pgYHFxkcFgwP3338999933igIIX0ps2esJAj0gSIj4Qv8zmWc39GY5BcwWipyp0Zvo7C30WQig/V/a3LufWSkHmhniyqN8eHHET7zzdbztrhuZxpalUcMv/tD3cmRxxFQrsgyJDrxXmtxSVw1YRxZfSnCayVLNNerS6BByz48wPXgH0Txx6QT4mV97oToNV1bwSwOmz36Sq5/4j0hwBFWSHcRpoFKossNYxExoJHHcXeLsg7+Dd5tEHeO9I2MMtKU1ZUccv/qhT/GF5658PfD1NzAc0TxbWfm1D3yYP/r0Q0QJRN+wGWse+PLz5ATOGrpYONV3v+4mRpUj+sykqmldQ3I15kPvSUB/qClOu9LXFqHyVgyl1LD1i2yfPknlyj1NMkBlSFq9lYW3/Dg2PMy0WUEOHAdzSJ7iBgepj9+KuEAgUpEZAXUQ8CNM6rIOnKd2DcOtM2w+8kmqvEPt9qkvpIS6Ym3tnOOtt9/ImUvrPPjYBdrs+PgXn+D3PvZltlrHUy+c53NfehIVhxP/skB0r+aaVUlWlklnhWVQ5K6LAl5nvQSUeFLf5h/VgUqEOlT9mt4LBlxW6lAcIJ3MrLNLGT0AP3zv7bz32sj2x34ZmVyh61sbMGX62Ee5/LH/hW7zDODpopEXVonNAcJdb0OWVpHcFbtk7UjtDlIPkHqV1Tf+MAdufitQUYWArRyjvv4eVBpMM+2Fp9DdcyQZEMNymQWL1C5D7kAGqBuRsqcSRxWUxiVGA8cnH/gCKRWjqE57gJ8mgnUMQpHe7gxizmielsC6B7Z2GSbJMUkKEoia6XrssbeIWBEaanFEPJPplLe9/mbuvfMaGp9ZGDUMQmAojqCJJpR7EGOkCh4zpa6KM6kTwzlPlIqWPkCxDtIWabyG8yUw6cIiJo4kVdmDpOhxzFIfv3iEg7e+EcEIAjUJlxNZCpAV50nmiqfJ5mWadhtGB9A4RXKH5F2KVqPHk1l77gnyeJ0Bxb1UvafLsKsVD52e8j/9xkf5n37jD3hxc4vk+mbpTP75tVrBtzy+K4KBG264gXvvvZcTJ07wi7/4i9x+++2v6PvPsaxzeC+9RDBEVTanuTxQUmPOvSQBMyC7ms417ExbVMIcTS8vewdgnr1KX/IWJ+CNpMp1hw7x5htXedsdh7E05cTqIj/7zttY1cvkmAmxxZMYxUvcOj3JNZXC9HJvRgNYMfogFx15W7qW4dv+Lmn1ZmKbsOtfh4QKEUPEYQTcyiHs4AkG7LAweZ46rlGbkvMIMWUwvgJxAlb0BWqLHM5XWI1nccQC/BHHSt7huulzbHWRy9HYlBGXO0d6Obn4r3R/hCnGlU7YUUfs+7sdNRvRcXG7Y2ING10mhhHfc8+drFSBwbChs1DuSd+nDgLOErmbIqkr1QAR8OEloKVB3sXFnaJM12utC0o7Osro+/4uHL6BXA1J172FXb+MhoblE2+iOnAQXJE4DhQ7V0epOBSB456GRc3QxlTtZSqJ1LSE4MGg1glZKtR7BpXj3luXkeCZqgcCa9PYgwA9nQQ6E/SrMi2ZYzOM0jFKJpgPjJMxThTfAw10KqxPM7sUCd5WDZ8zhxcXEMvUVclMc7b+qxxI3hdJPy9FBnqmgdEIvOnGw7zndcusbD6Ba08zbC8zIIIkqrTOUncOpxuAFsGfpWu42lxHeMuPsrtwI9os0+GgqnHOsGoI1TLXfM/7GBy9E3xRQKyOXI9bvZVsRdhrxBi2L2Bhke1wEFfVkBMqnlpKAN9qIHYdVdphwJjloAwqZZoSQmGotBnaaEy7WER8qprNTlmPymYsLbx525A+2OqFw1SKIVciIKbUvlQ/k6/YiJmJCetbY95z9wne8fpVlodwaGWBATDMSoVSuCOlnVO5EnKEvi1TgjyHuhqkrCkf12DnFGHzBZpUwL/J1aV1pG1pW84YJJapTXGDIc3tb8VkiJijyr0+orgi8a1K9gNaFSRPaUY1unwUv72J1ynsnsHyTlGl1Fyos2mDweRFFnWL4EBRIp6rredC17CmAybsg2v3rZRvPWl4bXxXBAOPPvooX/rSl3jooYeIMfKhD33oFb6C/flUTxUSR1TjyuYOH/vUF7g6jqgL5Fkk0JcIDIgELmyO+cgnv0Si0LRmkcDLFbe1X/WlOkDRBxdj0AyoUBZFGHkQIoshszBe5/xHfo3DfsIdK8IyW1z+7H/iPe4xbnWXWf/M76KxBc1IHtPolNBt4awlV4vY8DrwC+TxJrawgvR9ZQtDNCyCLeLdMeouM9q5wMLpL1AsWiLanefc/b/C+NJj4Io1scstS7rDSp6CDdlqB9RhgZVzD/HG+AgffeQyv3nfM9SSyH029Fces9aMFFia+dBvHn1lg8ynH7/I/+U37+fFifHv/uBLrI2NUV2zYMZIhQohkAnW0dAxFOHa1RFLtSB5jMstEMAVEyOjZGSNTfDtFm32QE2dJzidkKhJg+O0YRGpK7pDd7O+eisbfokYThRktxhliy50wuIPCGjxFijcxxGC0cR1nCirdWaxcQTghuWKrLnHomQWg0eckKhQM9Z2d1FX1NuShF7X/WsPpajAJYWI8GefeoDPPvoErQlQsz1Vfv13P87Dp8+zY0ZUCEk5ceAAHmjqprjxURz9HMXoJ/jiQ+FEQEuAEKTI5Y7YJe+sM1GYnnuIC3/8/8A2nwIXmFbLqBjoGJspPa7cwMbqG8iD1xGv/34mS7exG1bQwWKJNuoh2QeSX0XdMiXTdeTBMuIP0iwdKpQ4nTA59TQsHEQP3AIyKIdadtRpF6ZrSJqwmDe5ecVzeEGo85jlYWC0uIA44fLGNs+cukgKQ85cXuPUxTXGfoEP3v8o//q/PMBv/MmnmLhREZzqSZk5KWpKTBHrLcA1l+B8WHucE05d2OZ//s2PcW5jh81xy9GhZ0kiQ99RuUjtYGU0xJsWFVPLBFEqX4KBInraVzJ7BdQaqPMO46c+ydUP/X/Ij93HUDeopaVg9DOh25iFhr28eFWcKhzkwRE6v4owxGmFybAPBrYLJbYa4UfLaNeWZGOwiF66RJW2Wf/0B0lXnsflTIUieZfu/BPkxz7MLaMxQ+mo8hSnsbRdfFMwJczwQHtNU30tGviWx3dFMLC1tcUtt9xCVVWsr6/3G88rOWbAsf7oltkjV7L39UliN8/6hbMMrOe9G2WjlsBTp8/1dsAGvapgoR7ucbjVwPVGMkbJpASHC0IlGY/hrWwANZnQrhHOPMg1i4n/0//q73CoydjzD/BT9ww5OtrEXX2GOk/L4ZgTdW6punVMrOjJuxofhGEQlpdXwTnEfMkSqyG4BZRlyIJrO8L6C6AtLu9i3WW6F+5nuv0Cktbw1pFipAI8HmyBmGqCF4aXH+VY+yKPPrfJo8+dp9IJzjKxs1k3sxy0VmbO+gxnr4M9+6levMlyaa6Y4bWY9NTez0MryRlvkVNrm5yeKluh5rnLm2xPIrVzDExYFEeTWhrrpZwtcXx5xL/8Zz/DzUdHELcJOgESJhVOHAFDnCEWce0OOVnBEFhRB/QY0TeoK6qSo9vfwXU/+9+jR28j1ysFdS59GX6+psphbbMAUjzWv4a3Fmfwr/75z3Dd0WWCU971pls5uLSA73Egje9xKihkZXvcoQgxl7J+plQGZjLQc/EhKwVYp2U+U2+W9cK5yzz9wpXCe0cYd5EvPXOaC+sbJDWmqfg73HHjIY4fWsWZkkxocwHR+lAzCB7nAkjBDUDfQ5aSzYp2qHNs0NBdeZH05H2k7TPgAl29SBaBlBBaTDPhujdw4Ht+km7pdRx51y9w6C3vw/wSUg1oQ4OFIWaORF1kfDEwh69GuNFhlm64A1wostpxF3/0Oq7/2z+HDVeLNK8zRKdIt00Tpyzmdf75L/0tvvf2I9QB7r7jBhYHFWKwvTtmfXsHy4ntZFxqA9Eqzq5PuP/R0zx+bpupk/n9dBgpK1GNLhfWULHsLkyPn/rbb2V5cZGrG9s8+OQp1qYdHcLisOBDTJVBHWiCcdddt3Lw4AqSIsGsqGk6Cu2zD4AMwYkDJ1QWkTxm98LT5DMPMRifRoIi0x3qPCnYhjzu2VD9BiYNM2UUqw6QqwUwhxLIMig4AOvADFtZZeHOe5BuinPgwrAEf3GLyekvo+NLzHQWBi7B9llurtb5ybfdyaJ2NDYu4VIfLGlOBOglzcvua1D2KvZXt15rG3yz47siGLj33nt5/vnnefjhh/m3//bf8iM/8iOv6PvPJISy9N00KRF/kEI72vEjLk+70j/MsfDcKbrcmDFiF5yx4xqyFNtfQZhq4MpYcTSoCFMPbXIMfIOZkKWgcZ1V1I1nILtkpzjxRDx1E3BVpu7d4w4tOZxfpO4m1NU2IhsEVercliJ0GlBrRRPPsuUWqQ1Ex6jPSL0KS0fZZhFjqaCBnQIRfIcJZNcgzlNVVUFn54aRDZB2CusncbGjVc+0GrArxSMhpAmjdIbUrbHhDzAdb5Esc0WWyG7IUDOVZSZmTDNzFDKuoKgxIYvRiZHzhJRbOjOMSNKiGS94BmYEV9PZkBYhJsX5TJIBXS6KD2oVKbZ4l1HnwRm17VDlzNgto9QsinB05KnaS8j4CkPdRLZP46nABlRxkxg3MV8RpmtUaQs3WGTqD4KMCv2ShOCxVEN9BLf6PXTDGzG/iUlEpTAcJPvSXuk7y1lAzJfDwiWyGMmgMrimDiwEEGtZrmtGqoUa6jLaBKoItU2o1Oh0QMzC1rSEsVMTYh9kOlVagYT2AK/EMGckd3RWDrAYllkbL+KcoZJps3BFlhHnacyYEoguMnSJhbxNY1OmvfGOWqSTQCOZTMD3ZkQ+OLKHKLngUqRGtWOgO4TsMKlBlsmaWNIrDPMlZJyBSE4TWLwJXb6D6EawcD0yWGUx7hIGAy4Mj5PrFaoEwUqVBDxBhrioIEPCwlE6bbDsGViLVAtw5PVElrDNJ8ndWaahgRyo0hCdbrLabHFUI1OUA94I0ylQDqoh29yYTzG1zEZ1mGWLeN1l2y2yzQEEyN5xZZpp28hEMztktjtPoyN2W2U3FZrtLctFWyRhXK0Oc2lqTDWiHsaupg2r1FIxdFOaoZCkBL/SgxMrZwxdy9AVHQlTQVRJLuO3zxfgpwqeXYKfkkbH0VzjUsYssBtK86Ppk6zCPGkhT9F6geQzDGAi5TM1eQtYwbSiHSwgS9dBSnTe7xkp2SbDvIm3CAZqAUeHn2yyGNc4inE8XWbJTrHhl0mpKkmPVHgocW0uwZJiRCtS2n3T5TV04V9hfFdQC5eWlvj5n/957r33Xg4fPszrX//6V+y9+6Lz3t9mTVaKoYqIsLbT8gcf+Qzf89/+cL+twzwOMyPYTN52FlYUmtdzZy7yW3/4OTTvM/BUqH2hhClGcA5vQhWqUsJ3grhSpwjBIa705MUSaEQ04VxA6gZchboB2k2Z8YvNBDfZYe8dHVItsFuNWFm+le6G97Jw7A3YrlCtvg7zNSIZE08RNa0waQqO0tUFPbxxistfeYjV9x3llkMrPOcjjbSIjal0k4W1h9jd+DRDO0A33uTF2FFpS5uFQc9qyK4YwFg2nJ/JsPY9zKSICa5IBxZBl5xxLtD1fO4qp17aVlhQw2vpU1cWmXHpDcgpleqNgAue6Ae0boFojsXFRRqBoUZ2H/044Yn7cFvrnP/sHzDSn6a2a0hnH2Hz5OdYyQ35wnO4i0/gBkVDnr4cn3GwdC2T7Y6FELAwgtU7YOVaRAYEjAj0N48+Re8zoVJaKtxxQU1wmkGhkj6z9gK+IfshW7lCfTGzib5GtGTe4zZz7tJFvEacZryVtWhiPSYF0KLDoCJEMVqMDphgxJRKZcAJaxuRrclMsGgmYGssNo7XnTjAtCvmSFFh0kZkkFgKntRFajGqXrSrWEwXcyI0IapYl7G4QcMGznbx2qLdlGAta08+zOEbbi2un26AmetpZyVIMDHi8CD14PWIGyKSEQsgvogcOSutI+fIoaFrlvEHF0nnW1K1ysAq6naNjU9/EiTjXAVxG80TdnamBLfIWn2I7McMamizQzCGFnlH9TRHDqzS2JRgEUeDuYqpes5eHnP+wgZHnPE/f/A+7r3nLu6+6w4qHdNox7jLfObRU7z5jTezUivHRoFrlgMXdhJRKn79A59gbZypBCqMoJmRV7xEakoVwAm04nGupvaem48sccuRVQZieOD6Zc/b/CnO3/d5Ru/+CXwe0+RYDtyqQSfbYEp2A6IfUJv0iqhl7yq+CAO6sMR4+VZWh8eRm9+OGx3F3AhbuI7tG36Q6dHDLI2uQ6NgrilmY5Ygd8W/JJWgwlsshlBxBzdZ48Zqk/X0JGfzGit6PdIOSwVQ/Fztcl4xQ+jSPuwWr3EP/yrjuyIYePbZZ/nVX/1VbrvtNu677z7e8pa38PM///Pf6csqB5U4qBd57txVOnNUbkYT3O9S2Bv4sEfaMhG2Y+TM2i7QlD4ghmWlqQJTLVG7cw6vUNcN5isQV1zVLNME6/uxkSpv4m0bi5fxxF51LJAlFMR7XMciWG6RnYTXbi5E46Rm1wkHlm/jxI+9GWsCC3e+gzi4iSTbpdzZDEELalnqYdE3z1tFYW16lnTlRaTb4J7bbuHoG25i+/nPIXWHpQ2OT56lnj7JgLsRhO1WqRDapNggFEfADEkVm8/fjHDpUJ0BiKpyzWqAR1WYIFRS+tQ+lDJ4PVOok6owH/pqDmbEGEu/tfdwGFORXEOtHd93z+2MgqfKG4yvPE2z9gxNavFrT1GnF1gJR3CbTzLcPYUPq+TNM9TtRXT1dYX/Lg7vA+Iq/I1vIK3tgGRUhBve83NIaMBGOJQKPzdxecm+1l+nONe3phTJW0XLwbbLunIDsgmZipyVJZdZ9ImL2SMSqAR2orI9mSCWcL34iyFMe0GcqQlDJ0TnSCJ0FCR8MivCRRrnm+/upCXlmRMhc1vjlaHwk7/wA3z8c0/zubNTzBw688bIGWcRjxGcFaEbMXChN+5WJCk+Gz6vMah3EVqIgrXFbEc3noXpJWoSOFdeqy9nm8COH+IP3Mod7/yHyMIRcC29WAOIkENGqoJbUFfTDlZZuuf72LqySTM8hmXPUKb46fMgi0h1GGnPIW4TmxrSTalcZJgnjILSmSc66DBuTKe4JWxzJY8Zpk1qt8SWH5LNs7E7YXtnh0MLNSe3HMuTAbdqIqQdyB4Jy5wfC3fFzLvuvp4333KMf/Dj38OT//5z7EY4e2Ubv3SogAJRvHaMgoAv8IiZmZM4JaeWUeX53/83P8qRBirtUKm45ZoV/sd/+INc/c//knzlKE17lkGKEFaQegHlEkgm+SWiWwEriP9yywWzooMxPHwjN/7YP0eaVU782HFscIzIEHfgOo79/P+A+sTWV76Al4D3DS44IGPZiiBZipDHRUchR1wc4/OUt9yxwsoLF/ji7nmWpuegXiqrorfSlh4nMGNebW9PgME8OHhtfPPjuyIYePHFF/mBH/gBfvzHf5zz58/zW7/1W3PvgtmQlzuEfTvHS9hZQmee0CySZC9rmvVnysbpihten+mqFETy1GBsoZQ1Z7oEmgnBY21BNjtXAG5N8CXwEGFYBQaSqUVxOBqJtC98HtldI59/nLB7pWwYOZXMME8YP/ZnNCtHGcgUJi1NSj0iuCDmq0oLaHB0Da0kFkaLCBVOC5XIRgeh67AU8V7RU59n0m5Qj8/juooB25gmgnTULhFCYGMy5svPPMudeZvGJVSFMRVTGSA2JWsmxrLJfu6RM7z12kMsVYGZHOE8pGoa7n/wce65+VpOHD3Q++7CZmvc9+hTvPuNN7NUObQK/WElTKRm1y2ylNv5DTMg59yDJMH5UlJubMIquxwdniiYgDQmjC8Tuk3UPKvpKovpMgvdKbrH7mMxTWF1hGycIYgyXrqesR4DGWLsgCW0XiK6CnzJTlNzrKgTqiASCS7TiSfYVz+kMxS1iOHiNuMnP0n9ugXGVx6nOnAN9epbGXqj0sjhsMvSpUe5gfOczgs4V7jqVyeZzjWoTOjEk8XY2G352FPPcfv1Jzh59iI//uZb+/61FOlHFWaiA5b6HjSlX5vxTNpUNmhATGnEWA6exjqcQdbe0tiUBZ9pSL1TYmmvFXxb6P9bmBGDNIWNM0ycYzEsgCyj1lBZx2jjMdJjH8Gtn9qz7gUgYO4AO4s3MBjdggyuL+GVmyB9EI0Dc4q4UqsRMVQqdLBKDIssDZYQa0hW0diYlD1BW9ov/DF583mGOoLnP83t6xtcUmNYKSkndhHGBBIVw26NZd1l0XYZNoGpBXCeNvvCBnKeMQ3mAi4lOhO2tGYiDSHUxOg4MvAsiHCk9lTek9tMckPENUWXoSeUhirgXTEDzuJBPKvuCrhdRhiHhw6viqky9UIl0DRDFnUTe/R3qdYv4XPHZHAHdXMI48miUjk4Sttci0iFWJoHgI5QKnBSI8PrMfEwWpmzf0QCunA9Jh1V8zC53cFJBb4EEVEroquKqKC2xfhME9olshpOtjmYz3FQNhn6zHbX9Tgaep+Kwk4xypLc2trBODgPA17rEnzz47siGDh48CC/8iu/wsMPP8zp06ep65pf/uVf5hd+4Rc4fPjw3MvglR5z6ouv+pCdXvq1fL+U/QXvAk48we9xxQUw54pjmVRoHwHHmAhVjbVFJSw4IZjSFCUjHMbrbrmO6w8tUvUmOZLHjB/7M3aPnmPhhc8yatdBi4pbo1OqvMX4sY+iR25kMW2BTqlcD+yyIp1Eiji6IiIkHrwjZAVJZD8kLx6BtUsgDqdTqtMPEM8+wpApOl0hWkQp5GczpcMxTnBpfUw8uECXGqIbMqUhSQMSSV1X1Nwk8MAXH+cX3nELRw6vMJs9AbLADvB7H/8MMX8Ph4++BSeGeM/zV9b57Q/fx/fe9kuM/CKd870VasUkF1upUl4el9J4/8pVXfctHqidseon/OP3vZn3vPE4TosMr5vsYilhKKNul0Heprv4OWz9UVznyJJAxyRq3K3v4NqD96IywNTwlsiu2E/jS4bfhUAwIWihZzkiX80l6T95H9g6IMQNrnzudzm8eJTLX/ggcuNbOfqeNzCwKXWa8P03Nwyf+UPuaVZ5pD3GNDdoNeTKzpSkDu8HjK2mE+GxFy7zH/7si/zAG7f4xCPP8oN331x67AkkC9oVnKmkQI6OrAVD0KVMFs/2tCVjxY3RQS3G0EETHG1saZPhxGPtNj/9Y2/kTTcfI2rJ5X7sh17PeGq0V9bwksFV5V4whYvnaKsFshtQSUW0jGRjuP0c3af+Mw3Dvj3iynMiDVRHuO29v0S9sELyIwilPO6ckbLMn0sVAxKe3ON9KsQ3+CpAs0B14i701B/i/KC0WJ7/En7gGFRKOvd5rrt4luN6J84JFos8cSVg1YjgNgm545ZjC6zecIRnz28VCmWoyVIorh5lsVunsVV23CJb0lBLCbJahcobNcai5OL4KUaWmsbXZPEkPPiGuglMQ9UHVoE6BP7lT7+dOJ5woPGE3ILUxbWSQpFNfhEVT3ju8zSaIRxE7nkfrdvBnfk00ddUb3ov1976diwsIlxlBm6e6UOAkkONB1L/2ef7n3gcjsq2cYyppCH5muw9WTxdCa0hTYvOitRYLs+7WsQL+FCjoS5UVh+K74BZaWGoFUlnVSbtdF+bYP9/Xxvf6PiuCAZuuukm/tW/+lfFTU51fvAvLS29shWB2dgHJHAieOdwUjIfN2tn9aW80nf1iBVJ3tIKtjk/waT4jkfnaa3wl0MzIG1uIhIQFB93WayKsGnAWPSw2kClxQUQgzqtk/I6K/ECphNapdAJNeKJLMeLSFzABUfuhKxCzBULbkgnQzpZBmvxYoT5g1bsaRJF5jZUwyLw4gO1blNRfN5tMikHr69AMtm6coB0mSgLTHKA0KDZkVNGQsk+tUdUJ6mIdOS+Hz3zMJzRnZI4JlIzkUAUobIiYTvBM5FAEpiKkKsKjR0JYzg5x/H2FK2coA3F/dJS6Vn7PhBy4jCNjHzL9992hGNLNU4NzUqObcEVAC6O0bzNQtximLewsETswV/qArZ8gsUb30j0RbzFYWi9wpQa3LB0YK3X9hfrJWuNYFqAnV9zeRku7nIgniNMzrPavcgk34Qn0Qh4U44sGDesn+Nwt0utd5C9o01CdIGFQU3bTklWMq5OGtb9EjvZs+lGhWWgRVYrxoxKIKowVU/yw6JNIEKXC2Zkc3uXWZdGrJT/Z0XdZBVZGoQtXLvN644tcMvRBc5e3sK1W7z7dUcYbyUePH+SkLfADYim1MOA392hGdW4uAbdGSo2wdVUKVHlK1BfA74iZ18krBE0jBiduAdTpQ2CNzCtyuR5g+xQt4iGGqRoSUSpsbBQ9AnEUOfQ5RuIsoriWVioCetTptUJ/MqIrBNW20tcxwq1QBZHMBhpoqFDreAIhgFWBg7RgoRXqXoDIg8WcXGbToVxWKaeXOFYu0mnx+nkGBIazJRRsQBFxEgJgu9bHc6jObM6UqZSsDA+dwwt8wO3H0dxVJIhT0i+poghG1W8QtYdrIs0CJgnDxepX/c2xmcfA6vJoSIv38rSdW9hZ1xh5L656co+Jj1rR4oQmadXIcwRfCjPpyaca8EiyKDfAxRvDq8J0hh00FN9Dcu5YKRyLJLMviht2DyL2pdJiZCt6CcUauFrgcC3Mr4rgoEQAg8++CAXL14k58w999zDz/7sz86Feb7TQ7DStzYQZpbGRcc8G0hf3qtCoZs564VYKOTCKBUvXNxm5/IlpqkCXxeN8t6da6EWGge1K6IitRkLPlNbBDNa1xQLYTJBJz16vEItFNCfOLzuYjtraBjQZaOTBls4Tg6rtIs3sV3dXB5kFFFPchA8WF4ogUtVl/zKLzIaHYT10svvqkWqq1fxeVjCG4lonlCTGaRESJ4qT/G6y5AJIyaMrcLMiOpozZOlSPDMDEn2D0ehYmEBLPTCPD20yBzRAhF4+tIO59Y2uGexQbJxs77Ae0fP8cD2ApfCIiFU2LQrQYDbM4BKeBBHjeJnPcocod3G5/8/e/8dbFly33eCn19mHnfNs/XK++pq341GNzwaniBIiJRIUSIpaUaGknY2OAqFYjW7G7uxG6F/JmIjNjSzIcaGYldmNWZFSZzRiJK4Q9EAFA0MCQ802pvq8vXq+evOOZn52z/y3FfVABqOaFQ31b+OV/26+pl78p6T+TNfMwNKoq0JTCmbMSZOqGWNWBwkjG5g6ZgakiUGiCpqMny+wrRcAzcEDeQSUgdGoCanIPm167dIBm4PbRqKOIZmlyru0GqLkqiJrZSozcliTWGSY2YS9fFomLI2XGa99Z0zYcSJpTUZbVCarm0fUFqNtMbwxade5KUHFxhJzos3dvi9L7/Aj701AfhslrM7GnfHRdq0bcI64hUuXFlnZxawogxMyyINQwJFbDlgp6zh8X6DJ7eeYedpZfGetzElUPQXcHu7LI/WaX//f6QZHqG9+nmKbIU2BDLdwpuSPBsQggFNRltJgb9HNGnkJgjEAkwAPFEcTbaKyXK8lFAuotUKuCE+6yXHPAO4ITH00UKJpUXIaKszTCsPzrCsY97hnmFn9xq7MWNvOuN3Pv0Vpq1P96/JESPkJnWErAZmNk++n5KcM29OhX/32QtszwIPmys82NvgDybC159f4IEHhqgYMpvAvIaQOp0aOrhuoGcDCw62/R59DayVylphqIKndTk1ya2wEaUMUwZRmHzhVynCDfrtNnVcxecLtM7RHy4RXYVojykO1ztKMKuEhDAlzsF5mjqX85RcUVQjrQgFLZG8a+lnXSfEIbaPcQ6hJo8edVNsvUHz1HO4egdTZOCnSDtNQMIwIyeQ6YxMa1pNPzONW+eA3JSwNiGNMOa1353f9d948SciGfjMZz5Dnuf8jb/xNxARer3erVZqJ9kbY3xNuwS3YG3M5wMdmC1iwgwpkuea4hHS3FuIncBQRpQMY+ZYgojReYs4VenPXFrnyevP4E6+jTJ3qFh8iAzKgl/4+KN89cIIvbmJ0cTx/oU/9xGKzBKmz+JJzmax26jTBp0y7qjJKEVo8ZM9ZOkgPjrk6L0svufPMsuGLJ57Gwv9VUy+MIcQ7UvPpiu1qDWoK6iOHkSO3cPs+hPgE92w2NsilA7RKVARY8PyoMfpYg22PPcfW8O+XGPjFOtrMuNRlCYGZlqSRHa+ddYvmnQYYsJVk6liO1Oi2JWpXoRnLl5lc3MLThzAq3J3tkW+cI0n9o5xU3rgClpRkBbtpE6NAUwSFDI2I5AcANWP0WaMkJwQIzU/+o6HODR6Af16S/GW9xJPPcrsPzyLC2NiTNWTEcWKwWtOefAs5977EyAVaEytceaHGNBJ/abLNh1bYo42mcNMIUSTrLHbBNATjQRVahVaKalND+96NOT81T/9Tp67sssnvvAyYoWlwrBLwMU0jTWSWBk+RiSkVmw00BqYhsgL19d58uI1ahHWR3v8wZMX+egjZ/Ex0s8MTd3gFYIaohoqTZ2p1vW4urHFykKfv/hn3869K44zRxewGji6ssD/7q98nFOHFilXDP31o2x+/Q9YPH03TYBYDIGWKniar/8WIe/R2JrssZ/CP/sScuNzCQxre2n0QnKeNCZRQsS47g4l4RDwiHgwjpUH3g/W4HEUp97CiYUhmmnqZmXJLjw7egrWTjMZXSaYBH7snXsbs+kFbAxUYZfF8DLTG0+jtsfVcc1vf+0yb8uGODtiFhTrCnJnyJklWqwMUEljgFpynrg65aXL68hgmdPxMh89KTx9reWZmzfQ/ABtJI0aXU7QGque6WiM8Z5MFcKMd91/lg8/eJpDPcPf/tkPcHRluP/MJN2KDKtTRJU422H3U/+K5XiJbLZJPPJ2yoc/yOjLv0klluGpu5kuHGNw+iz5ifuJtofqOFkJ76P1kwaK6faAtFeFlLwa0+mlCFYc6oYEcowxiLEIPiU1zRgZbbLzzOdZCmN8HCB+jMYZ+BEujCiipQwN0cg+e0hJHVN8TW4t/YVh8rtAE77lzfi+4k+EzsDdd9/N5uYmzz//PM899xzXr1/HmCQ3Oq/0vPf7SYH3nhACIYT9v4sx7v/d9xrz229/1t/V9KJKFVqs32JKpJVIQ5JxVVGMTvGaPMun3nZ8cro5fWSGJUqJEWXmcmamoFWhZzwBh0pG30Tee3KJ0uXJoEQUS+ChgwPOrvTITKTQSTKNCRO8KgVTCA0Sa4x6rIKYHMeIthyiUhAOPoyc/DClzcirA5SnH4NsFSs2iZUAhgxDoDUlWiRTl1gtMuudZ+wyMuMZ+B1sHONdQQw73Sol576sEJaGltVBQessTZ4TpYcjBwthtpV07jWNQL7ZUy/1VxqEkc2YGoMJDW3wPL3Tsj6b4XzDi+tjdtsGR87FWc7T05Z2a5O12UWUbRwNmanwpiCLDTYjdT6kJfM1mQ9kNnUm/O4VdPwSRlvafMCMBozhAbfDAXOTkCv1kceJBx4kqGBCQKIwNQWYKQUNweRIb4nB8QdACjAlSeuwB+RUgJHUvlaSeZQgWJUkTiyQeBIB7SqwuhkxM4uY3Q2k3oQwJjOSpKE1I5gef+meko+vbDOkpY2OYebINEOoadTgbSDzhjGGLAgNhu1RQ+0h0z7RDjD5gNwHcpmyZ5dREaahZs3NiG1DS8RjsdGytPUMrh0xtgNClnGknPDT967ywTNrFHlJKzm9zPHYyQMsFgXD4ZC3rNUsjK9AqDFUUAzxZUPjcvJoqNoxQg6H3kpcuws1hn6WRjtebFeB5ki0CA4jQl/SjFwcYHMsBQZHtvYQbuUBSjHo0nnk1IdBSjKN4PJ0mC4cZXTwbmq7QOYKJO4hB1ZA+kmSURSkwm2/wKq/ytVZZNf0KTSQNTuY0CLBk4cphe4QpKPxAjWRKBW7sYcvCmzbshgmHLJbDJ1QyJjYNYZmIdGDbVHgJBC9x4ZIJBKdcnwo3HtwCbd9hbceUNYGQnCOXCM9BdWAuf4ZfMyICMN4DakboiuRg8eQU+9CtCR3Q2T5DPXwGM2BRzELh7rnvaE1FRaDSEzjAACxZJJGd0YyCgxImfAZnfcK+UEyqbD5BDEFEi216xGNRX0klzHGCiZkyGybmVFiqBGriC/IgrBjF2ltReU9RZd6ZGGGITAYrqBtGjPM5ebMm62B7zn+RHQG1tfXuXz5Mk8//TRZliEiPPDAA/v/f67lf/PmTW7evMmRI0dYWFhgOp1y+fJlFhYWWF1d3e8ifD8ht38mSTbYiNCrSk6trXJlGhGF3NiOBmsRtdigiK8hTJGYsukoBjRgYiSnIZB44l4N+EiZpSoTAs46cmOwAjOb04rDkhDZRWig2Uj6+TFi2rrrWgRMrNEwAwndvM4g2iLWgkSkqDr6YcIOY8wrDuJbzgmKqCc6g5R5p5vQUmqNDVOQfjJ2wXWARpMq6tjidIrThJsIg1XCyCQkf0dNU42dmuS3eE+6X28JmLbBxDa174FZFP7B//eTTPvLbDHk7//TT3Lq3jPMzAKfffoaOzd+l49uXeG+xQryEhFYMlNMuElfRqx2R2zCDTi8NRgL+Wyd67/735EPZxiEkFVp7bTFjTaIs5302m2Oiuu6FTl0Vb0Qkc6LfV9DQLr1lVuX9UpEdDcL1W6toaN8JmOfPCShG0JLRqR+/gvUX/sdPvTwQ9z8oysU7QQXJpxZGzCQXU5c/g+8PTvAHzWRJdtPfQZNuvMhegiKD2lEsTWp+Qf//ov8yPs83vUppUnUtBCZaYa2TQK6BSUvKtoww8TIIOywajdov/x5wtnDLNjjZNpy8vgRBlWOi3H//p3fD04KIGLaMabeS8mAnyHOEMRiFxaRzV001oj20DzDmXRvSNHDWJcAbXPzxf217dZT5nftbQs93/40raWYDEyGGjtvC4GrwObJSMmmjpwal7Q7Qpv089vIjRefxoZH+b3PPsPGpIUc1DrKMGHhxldQs47DMMlXgYxCI/0YO7ldRxEn1GaBKJZMG1rJuZkdhnxAQcuhMvLRe5f4rRfHbE/gQw8eYqFXctfaAh996Dj9IsP4CRc+8c+pjh5l7fE/h5IlNpDkqN/hwm/+C0786GmynsNpi7QzmsERimMPQbmQnFMRIIFbxeS3deRiWqPuntxntHzD8zhH8+yPRFWx2YCYL6A2wxS9bi/RhI2KNVY8lGX6fVs3cLaCqExlQGtKMm3phT0gkukMC9TARqhoNKNfOho/ZZ+RkigK37xnvBnfNv5EJANN0/COd7yDH//xH8cYQ57nr/j/8wP+05/+NP/yX/5L/upf/au85z3v4Zd+6ZcwxnDt2jX+zt/5Oxw/fnx/XvzHCb3NUbAsMh6+5xyXP/t1DAZJuq/pwJc8bU/qEZ0S1TIBDJZKFEfAhilKgY9QR0vbRBYGfapsk9oHnLWIMRTUpMclPbQpM2/Bj5AItvWYepZoYSjGj1E/wkhkzhyTGFMJpRGxt2gPt0NzvsXVYqxFy6Q45keeiilWk5BMIKcxGVEjJqZkxMTkkGjiDI05XoF7HoMv7nY6DKFrd4MP3+mhFkIbICjBe8Rm+Bi5vFuzVbdMshVCO2bJF8ykBwaevLrJu3oVE3pMpSKYnKqwbJqCsRsSjNBIqqxULdGaVFX6XQajJ8AMGZucKiuQ2V7CeYw30HovXZ9RIoaZ6ZOZBis24Rg6Bb/59FfnR9O36WzebleVOkadZDAZjelRkTwcgvcUsaEMG8y2n+Gvfuzn+fqVPYQxIRtw7z3nqXoVK6NnWMXi43FCmehpUQU0rR8xEJrUiZkF5QW/wnM7DYN+xkNrgvE1rVoa8g6XobQ+4voLjOuGViDzYw6HaxyePE/Yu8zh6ghLZsqH33me3EnCeCQdSCDhQ+YHN8GjMaDRI6HG5AWtW8WduA/d+wKEGY30qIoKY5N1r+8t45wjDcLifhvZfBdjwfmc2XaT7+gKWtvrkgFBpUyqmkS8GxLtQrL3NRYbkuWV0iLtiNLB9a1dWlOlpN44bJhxrHmJE7Mt+nIPeVHRCw0lTRJI0paoSStAjaGVHKcNUYRaSg72LdbPWOpF/tZPPMDX/z+fYZJZ/vLH7mfQy3jk1CHOHz9IT2pktkG18yR2OIUwTWJWmlRCbdyhGl/FTm4i5VoqDsIM89CHcI98nDj1YBI+Zp+8ty96dftqfXeR8H7JVUOKirpcpXI9QrVIND1cbJPE8WwL4xtiWWGLFeL2C+SlgXaaWKziEi4ijvHWEcXSIkyB61PIpWUprCNeiSR5Zun2njfje4s3ZDLwjdV7URT88i//Mn/wB3+AMYa3ve1t/MIv/ML+/xdJVJiPf/zj3Lx5E4DJZML6+jp/7+/9PX7t136NP/zDP+TYsWP7jARgf2Tw/XQLkj2xktzuIjMfuLg1pr8yRKJybTQBgZFCi+JDy8Qbnt4cMapbzi+UtArRJJWtNhhGNZiZ5+jiIj0HY3xKOkTohV36YQQ3n8EODiHlMmoykD5BMmxocM1kH89g2jFxtoMS8SYnKDgxYC1zTf+oSZLWiuFVl0CF4BZozQGabAp+RNVVVWoLpiwgWpO3e7B7FY0PI0g3HpGEGI4Rn6+AnUBsMDYnotRqkVkDJOwHOgcq3dqWGiyX9yI73jFudV8vX4xLiG0xkJVM6oAxBU1b0ytL6u77+3HKsr7IcpxxQYa0EglGKOtdjs0usOJHWBkmi1SbAw2uDfhiiGNM9G2ykB5voO0uXpOCXpSc3WyNoAVLklFpgJj49DEqmdxmff3qi7v/ZySxA/axAuSM7TLDrE9sZ4SYjGlMmJLpLhom9HWKxAYXpgxnzxFvHmTR30TU422FKwtUTAI1kpzzokLbpmcmKsxU2GwNa/4aZyYb3Nx5gPW9GmMM41YS6yMGTNFnc7TNE9dGTKTCqCfTRPdaLGAx7LAcG/KgqBG8FIgmu2IlJpCfGjQkTwyNgagB7R1guzyPG57H589ja2XXHmHolrAuo5WMWXmIvsmxGgidJ0VyYezgl6/6+KbnU0mjKDSgpmJqFkDy5HGBxZBse6fZMmN7iIHpY8Rh6inEFkukJ01KlOjRmGkH+IObexMyA0vTKyyGIxCvcIAJRXueWbFELQVNLAkmeU346MhjTRlmnPIvc3oyQ+Lb0GzIkgbW3IyLYcyCaCfOZKiMQGgJuy+g4+uYeASjoRPTyhCS10MZx1iaBM4lI8Pgi0PE/Bhxdp3aDNNoSufMBen2sJT0zR1Tb+1vr7au3cpqQKJHTUaTL1OYkpgvMXGrDNsNbKxh5yo0U2IxxLg+RmsyP4XZOv36BiU5pnMmmWnBtizxzI1desMB9WiTo/EqJ8eXGISTtzqKQsLPzF9/1xn+XuP1AD7/YcYbMhmA9EYlgRjhoYce4pd+6Zdo25YjR45805sYY9yv1OeV/2QyoSgKyrJkaWmJa9eu7ScCL774Iv/iX/wLdnd3mc1mPP3009/zjTG/AYPCaDzi4taY/+af/Sr/5Z9+L5bIL//2H2GKkur43RS9klMHV9iabPBf/9NPcPHmiP/83Sep+n0aMqIYdifCcxdvkk37nBgYcm0woWE6m/Lk8y+xakcM+zUX/s3/g+zU2/DH3kF0Jdn1PZa8sBB2E73KJwe/uHWDvReeJPORvFgmOodMoB4n9vN4fYMbTz5NYxY629NvHVmsaXWRmTioArIwZXNrShkrJBtQL95NsfMMZb3Fxqf/A+LO0I53CW3LZDaibkpmmxsMlo8QYkwzVicY67i00TLbeRkFZrMZL758Dd24kcYepOpvYgr+9e9+mcvjkksbY556+llaCvxkRMwNISRHxmYyxoXkVBi1xpqWQhsOt9f4wMoeV/cu8UfhnUg94cqFy1Qbv8c9l3+Hs3o312fHefnFS6i/TNVW9CfbNFoS2iQHraLozjUwY7xkTC5fZRKOE4+9lbaZsrXXcP25ZzDec/3mJo08Rx5aorVEtGv7f3MISTK5MWlKWoYp1ggNlnI6Iq7dx6y5jPXXCTs7ULeIzRhvbHHjxZc4f2SB066muvoy1Ze/xNZTv0cxvsFiZSnHDWE0IgbP9vYOTz93gQuXrtF4ZWu3ZuaFl16+Shn3+PyXJ7xdn+Ju+xL/5FOOC34N8TN2Z5EXnn2Bjes38GGFF282/Df/4++xZ5Y5LAMmpqK5tsV4ZYO3nz2AbN3gwpNbNHbAxDkg0IvJpW9ie1TtLqs3N9F6xo1nn2a0s0nZz5gcfi+jbJkwOEYpOf7w27i57sn3ZuTZAtPyCJdevsbVrRk7ewOuGQGpUM1Sd+xVsgFDoJUMEIqYxi1ZvQHLp7ly8SZ768/RBM/B3RFlq1Aeoz65ymQn0t/cZmW2RWxbrChZnCH1jFEtTKPDqceEGZ9+4nnucQsM8ynHq5bT+hxnBsrVSy+xt3QejbA5iTgZYDSmZzN4Cr/DY1yk94Vf50Ie2Vx8gDzucveKxZ0asn79BmxdRkm0yL7fxH3ul5F6xN7ujN2vP8VWtUffp70ob16g1zRceu454mpLz5RYydneqnn5uSvY6U3ypbO8dOEqhoCMp8j161x/+lla20MmG+w0hvF4QkabcC8xvOraKgkKa/yUHru0ISNujan7DebgwxTXv0jRXkFefhasMqsEaRw901Giv/ppBpvPsNJb4rHzRxn2TvCpyw3b0x7/93/62/zv/+IHmd28yDtWxjwsF9nYjHz96Wco1UOIRHFsbazvY8S+12RARGjblr29vTtDT78D8YZNBuYHfAiBl19+mX/0j/4Rk8mEX/zFX+RTn/oUf/2v//X9r51niE3TUNc1s9mMsizZ29vj5s2bPPvss/t+BiLC6dOn+bt/9+9y7do1fvVXf5Vz5859T6JFt1Mag8IXN58EVzIzGcfOnqYw0H76GWYYjh49yLEr13n3e+7mN//dHzAt19iUAumvcOzYMmJeRjotdXUlTRDOnzvGky9e4OZOYHFhwD3nz/D4fcfRdo/RP/vv6Q9airuOEKWiyddpMkPma4QM4ywxCEWvwBcZLuvBgeOYQ4eoP/9JGB4g7O5QrR7k8N330dIjc4kJ8S2vVQNy1ymi8agEbK00z32S0ZeHyGCB1Y/+PNPP/ivMC5+hkikLJ4+z8SWDTD0Hi5atvZq1xR79U/cgX3qOzCio0HhFi0Vq9RjjKcuSE8cPcffaIlk3s1SBjaBo/2maSWRxeYm77zrDzEO/dOxo6vZ6UUJdY6MQJRAlgHiseso45UB7hWm7SItDyyFHTxzmkFtkvblKpcfoW8vDp1ZZtgXXn1rGTnfJTI/QPwJ767gsxxhPGwONG9A7eprl+9+NfeguJHg0XyHQx0THSJ7lzJmTVGrQLIExv10yIDHQmgRezGMDMTDDUZjTmHuPMPv314nPbuFcILMtbRBYPspd95zn8H1L5LsXaV9agN3LDCdXmLgBj957D7/2BeXQakWROfr9PmfOnOTSdoM3e7SmJLiKE6cOYcUzayOrdoNj/iKj8Dgz6TFgRuEMd507zaEXt7i0k9Tl9oKwQ5FYDBEOHehz5MG7ePAtD7MQW1wIeFPQmIhIICPx0Uc4enFMe8nRMGHh+CLmekn/9MOs3vOngSkzs0574evc+5N/E/oHqUdfJoyusPy+n0GH5whXLlEtLrA87HXAzLzrprzKc0qbQIdYilh3Sosec++9RCmJdpBMo15apN1cZOX9P8NysYq6FaY7X4GNl7F5gbZTMm0Ylg6bl0TjyHRGrlNaUzJCWa5y3nbsDDe//jscbQKrhw9TLAw44K+xFQ3RlSzZhgqDFguUFlaaGxyfPMXqmmP1xDEyPcgv3H0fRhURQ6VjnHrEGzQuMPrCmDET7NIKB+99CwfzZaqYjLyYWLY/lXP0+GE4dJKbktHaBXqraxw6dxrhJNk9J/BuDTNdZ+MLQ7KDhzhy1zkaCsJoSLY14cSJ42QE1OUdSO9b37uBpAjpwhjxN7n0+UX6S8scfOv74f7DbP3P/zeyi9fJ2xmtZISlg+TVceIVJTdCslqrOVpF/tafezd7y2f53/6DX+Pzkz61G7J4eJlBv+IDJw6z9uIf8cLgLu46fxcDaYnBMGsCZe44deoUwD6Y/LuNGJPCa7/f/75A5W/EeMMmA7fP9p966ikef/xx/vAP/5Ber8e1a9e+6evbtuV3f/d3+b3f+z36/T7Ly8v8yI/8CP/tf/vfcvDgQd72trft0w/nB79zDlVNWurfA5bg9raUESiMQ4IjhKzTDzDUrWVjBi9eWKdHZJmWXqzZ8YI3PcBiQ+KAi1WiKkEcddOy0DcMcwOhSXQ1o2RS443gujay0Qk6uoK98QVc2EXa3SR2EyMiDtM2uBjBVDQsYNwKrV0AqTCmBApEHFaSl/qrDrYVcEndLxDpWw9ZiVdHoIDiIHv5YVRKrBEwlsyPyGY3WPGXWGwyTJjiektk1mI0pA5BWfDS9W2KJl1727b7YDAR2X85mSGBERFM9EmR0QE2ow45E02yuZNZS9QyUTKNwZukr+Bj4in0qSmpwVSdipqgWZn8CyTHbT5LzEb0mj36k+eR3n3E3jGCeRZrA2Y2xpuALwZYW+HzAdHk5CEQbYZoEsRRm+Eyh2nmHhQkO9lvfSOBJNfCJKeflB+NcTRklNkhdHgYiS3F3kVMvYUXg7d9DMJQGiSbsWkH9MyArNnBlgMOTZ7lRFxlYO8lhhbpaFvbe2Nadew2kbFmPHV5m5FUBGloO8vnNkJjk4Je5fcQa4nBU7pIZSJ1CJ0wVWCgexQbT5D7d9FmFd5kOByOgJlepN2+jjv8IBjHwFhMmBAm1+nPrhMufhXZvQL5uyFbAumj+QAtFyBbSfNwV+LtAlocQm2ZsBkuT92abvQh3wB8fcXazg2ZkDQqV4M3fYxNDnlzBovLK6ZSEd1hKI8mrIdzSAz4oDixOEJS0osJ0Z7jySXNxUsT6Lfb5NaQSwIFP3PlJseLAQ/o84zUcSMeYkl2yU1gmi3S4Ji4RayfwLUvki/cR7a8hkgg95uMzCoQqC99CWsrsgN3UTkFv4FnTDQ5mXSDKEnPnRCR2ECYkhll5hbIJZBrjXcLtPY4ikkiPp0vhrEGJwY1grUG5ywmJEr03IjtW0Ug4aKM2DQodRnG5agZIOUpJmaFUgwiLUhOaysiFbkoGpJGg9oeud/F3vwsB6bP8Vb/FS6Fs7Sxx5dfHnO1rbB2Sj5dh5jwI0YixtIVMLf28O8HCzYvON/sDLzOw/ukb//CCy/Q7/f55Cc/yZe+9CX+4T/8h7znPe95xdeKCHme85GPfIQPf/jDr/j7j3/840CnQNcd4vN/O+f2RxHfS9z+M0S1o9gYGp8RPeRZkuN49qUbfOX5dT7+6Cl6RPJ2inEQNRDaJtGcTMMsWHyMNGT4tqXK4dyJQ9zcbXj3fccZmM5UKCap0VwSan/3uS9Qf+Z/ZimOwHswDahD8hzj9/C+JT/9CObEY2SLfZoLL9PKkP7xt9A79VA3b/wO1y6ASSqAFgFpQGfo4grLD30EFk7TO/Mu4pUvEUKTzIu0xYzXOVNd45JWYALGVFhafGa5+8wplhaFT3/lWfqmorCpw5J4+tpJrs6BeCkZyDGY4IGkgTANMPGCV4cj0vhIr8yZhUDQDOY0PQWrnrPFjI8dhnvf8hAHbUDaEVVsqKRm23uuf+k/cmixJgsTpNlGBgZz6lFmF75EVdQ0kym6cID+Pe+kPHyWmYBqRhTXbYoJyzXnQ2NtB5r7dujBDhEvHQf4Nq2FpOjYg2IRIriNF9B2G2NXQRWjdQKL1tsUvsbEFml2qWLkwMX/wNuyd3Ow8jx49khC82tkc2uHEBpmbcHOuOYf/vNPsOMOsmyEhYUDtDHDxcDhlYzpXgXthBpooqeygdIKbe3JdUzmd+j5XWZf+g3MPR/DHD6Gt6ZTqIvMbj7HS5/8nzj7p/4u5cqhJDEba0Zb1xnWW8w++c/xUsHbf45oOjaGyQmSgSsJQYlZH4oeGO3EhRyiiaCbdDW+DTZT0t0jdHReMSgm0UElsWKMJCCrIgSbEW2PSJGsclXS+4lJlboqTbTU413WqsDawiIyu4IzUOqYKo4oXPr5tSn5V7/+B/zFnyz4wMEpN7f2uFkv0csakiTcKgAAkfZJREFUSqnxtqAxBeN8FVzJ7u/+T8ymBzjywZ/DadJKKFDY2+al/98/Yen4OQ5/6BdQss4hcZbYDmnAhqFKGiNBQKfQ7OGynOK+D5MfPZ8kwlG8cWmU6EoWHnwcu3YqGUhZULG3knFjby3ht4kkoW66G7+F0CZ4s+snHQeBaAvys+9i+f73oWGV5tlFXGih8TRU5GGK/8yv4Pe2+GDvHr5ws+RFzvBP/s0fIkaJ50GzitpDUMVjcbTJC6Or6L+fRMAYs48d+08l3rDJgLVJk/rZZ59laWmJv/bX/hrvete7OHToEA899NA3ff3tFf83/pxXi/n3fD+Zody2cYuAzyyNrVIlkYFkwsgU+KzHdizAKSEIM8kIMqL2nl0RAh5rU6t2ZiqG0tA3kUfvXmX94sv83KNrDPxVsIfI6l0cDW52kaglRqFqrmPiGFohOqENBeUgR5pL6GiN+qGfpvfwT2PjDvX6CL++Tn73O7CnHu8q2u90pQGVFoOj0gZcTWDCxsJRDr3jF8GtMnigz94Tv0Y2vgzbTyTZJRM5OHuO0p5lJspyXdETZVoIf/axk5zKR3z+KxMWDh7DNHvUuznqk9NdkLybSSY1RzUWH0BjqoC8RqIRmukEp5FcI+B58K5DPP/ii2xPcyoC1gi1rcDkrOkG712r+eB7zyR1tJnS93uc8M+zwxqDsEs1HTHCkbNIky8xvOvd2Cd/izhbZ5pFxr0THPnQ34biDD1RUN9VZGkTVaPkndIfWQLffcdtyiSa6PzAAigE5oLVUQvabJlKLyAayQyUs22Y3SQMzyDuMEXwSS3RFag19NsNlnSHfuH4kUeO8tmvXqLQlsZ7rDaMmhZE2TW9RI6sI4cXS/yuowiRt51z/C9fs0yiY9NDkIa+KSlcj20juLjN0OxiJWDjmBgcubEoLYYpYgZYcSyMnkPCDjrNkKKfRiDRURnLQvsSuGNIXqBGwU9R7eHtImQGB0zLw4ytYUE2UFllZjOMcYADtd8W65IezaSpbwXQHCNQ3s6VU01g2rygweIkgUV9iNQBbF2jUTGhwRnLThxCvcfd1Yxz584x/tqz+GhxNuAJDG1DFWfUZoVtLZminGgushyXUXMWbzJ6OsZESzSGqk2sHGm3cONLRAJCD+wqmSpx7ybL9QtYM0AmLxG1YmxXsDYBVlsMljFQogpWK0K7jgtraP8I/ff/daiOgTgyBCeSEohyjerRn2dOM7QizMThjGDlFhfm29FgHAqiqGSIyfAEQvBYMwUipcww0rLjDlM+9jcp7n4H2kzY/OJbWdn4Mvl4I1Fd44x8eh2ZbHDI9Vjxyzxb3sUuBathh0WpGZtFtncbdiY1YdBjRZvkxvnHZIbNv//NzsDrPLz3+6DAf/yP/zGHDh3ar8ifeuop/tJf+kv7X/uDQJJ+Lz/jG7/XomQSUU2ZakRp1BAlQxV265ogykgMI9NDdIemgamWeF1M+X3rUYTcQM8KklkOV5Gw8TwXvvyrHH/Pz2MVnB+x99X/SOi/nWq6jiHNmdXmzOwCDX1Mv0fYfYk4vkT2sKAmR6UP1SHiIKNxy2CKjtPuEXHfpgxIqPhkm+oRcsiPkS/fD6aPmgAmjVnCxhW2PvGrhI2LiaNtNaG2swLyCiclh8M6h+weJiuZymo6+aKh1gzfbT5zlUa0RjT/pj1pjtIXTUemx2AViEkXzWji+4eupY0qmbYc6meUqlg/YnTlOap2h/euDrBcpNe2WFMnHnw7Sd+XDVBbpU6Lc0klzhREcd9MH0xLxW0cgv0l/b6SzfkfmdCagjIMgYDEmtnLX6b9/CdZec8axDq5Tyr7r2X+60rrQGtMDEzI2bSr7GqgaR2VcdQxR0Uw1JRSIyL4qOQZRI1cuDnif/nEE2jtcYXFZomi2vMN56opuUxR8rQxqxLm7k8qoJDpDLP9LDc+9+ssv/0nyId9IBB6B4ijHYItEJcSP0xJrA4hgzFIcszz5Qq6dAZsL3HgVTFJ07Oj7nZMou96QW/7D1WUnCgtZuUoLN4FpkSJWBWIU8zus4g01FkG4nGxZqwFq7mj8sI0CpGUlMSoLBfJM6SNATGJC2DxJL0+MDYh/G2sKeI0daFiRDRgtU7dHhmCJBOnGKY43cVuv8jG7/4K1eQyIk3SWjBd18nkeBFQQzbbZPTl36b/6ApTt8CC6WFM/solkC51leIb9rHbFkikG7G8+spq3FcUQVggWzpP7C+hUkFsyF2JBEWzDFssEqVCnWBWTtHuvICb7iTdiOghNFj1OE3MDR8V68BpSHoVsWV7NuW///ef4eEH7+YnHjqKyuyb3+L/RA717zfekMmAqpJl2f7N+pM/+ZO8/e1v33+zy7K8ky/vm8II5BKRkDblGqGONsncqkfqXfrO0go0kxEDnUBdYT1kXvFZxrTxCEphIpWxnD99jPsOfwxz+XeYfP23CI98EGMHSDvG7V1jdvGzLKz08G2bnOJsTv+tH4K2Yrr1PNVsk3YyJlOfjixTcfi+d9HOaq5tNwSxXfYfSLzjV8MMGCBVVWhEpUd19J2cXTmXLI/tDNNEEKh0yt7VJ+nFKc6kOgdxiOsTbQ62Yll3WXUjoi2RaKiyiJvWjEJLUO3auaTXI8kS99s2L0QI0STKYZyiMVBlhnvPniNb/xJOGxyBhX7BsbfcSx5rqK8SbjzFkF0eziLbbUUWV5CmIQ9TTL1HRgOmJNgKQ4FxOdY65o4SiaP+WjtlKuoisnKY3K4SL34ZkRFmeoH6yleR2YfB7yQ9BwTRxE4QSda3ReaIMRBEmCDMyMnCFK+Q6ZiplEl4iSkDJskEyESME2yMbLSBL7xwiccOOFrjwHpaY1gJylm7g5UJgSEmTjBa05J3yYEk3+MYYO8C/qnfZnb/+8h7ljxzZPe/m/ClDVpTph41QrAVvXveSf/MvXjJcOpZOnEfS4cPEbNVfEydItGQdDM6iun3/w6kJFStpbrrMU4fepSYDYkEHA6NNWa2jkhB68rEKPENe90oZRgmbEUlqsFJhNhy39kDnDYP8ttffGF/bCSqqfonYp0jw5H5bfphh8LvJWovPiUCYQfccucnAkEbrJ9Q7l1hd30XVzSUVUbIyiTfCyBFoiBqS6Y76I0RzDbRfNhJNb82ISJJRE2UaIecfP+fBwLRlEl4y1QIjt7SEvnCUgJy2oqD7/szjMYXCaMv4hRUAxIajAaMUU6fOsnvXe3smI0hmIJSW3Znns9+5SK21+fHHzxOMPl3fI1vxivjDZkMiMj+PGh5eZnBYMCJEyf2gSKvt1mPoGSaaG2qyjjAyBuiseTthKGP9LMCTw8mm/R1QggLFHGKYUowBZNZCwiZUUojLGYGkznGcYdlfxMJU9rg8D7QpyaGDVRzmmgoVAgmI1s+R9NYwmidfrGMsbtY57piLcf0D4LzzHbXkzacatJS/7bHbQJoOY0EAYtF3DJ2uEArQiRl79EYLC1Vs0Fhkv2ykjT5ndGkfJcXNFlBbgr6YZej7Ysc8udYiFeZtTUaA14c1/emtAr9Kmf3tpd2q5C59ZdWBMkczhsKqRP/29ccWVtm77pSiEdiwBIoXMDoGCYvU06vkIddlvwmC3KYVo7imhkSWwgzstiCQLAlzvRQmyM2209W5rgGc5s18msRIReavEcoKlSeI5dd+rJNVl9CRhfQehOnEwIGq4rEhF9RhMzCLjkNOaAstzd4sP0aG7KC4Hm5OIsiOCb0m5uJxWEjVpRKGyZ5waQYohLQaNA4ozU9HBnDOCHYFiEdmrS7RLtGxKUuUmiJatDQUoQRxjoQw9RDb+EwYgqMq5AsJfYNkJWr2GKYqn5jkXKZWC3Tdq1sqy3SIQWivGr6+t2Hpp8WiwNYegQxBGlxamhxBHEYFfKYqGwNFh+mrPgLFO2VJAFOINcZNrZkYR1jdslpUwtcEhvHdCBXsUk7NGt2WfQbFGGPqEk/wsUpMrmIDo6gtur0EZQ8CsVkj14zS4DjfIkQe0Q1BAFiwI4vou0WYiJFDMj4Jpl57fdIMZo6OMZghoeR2CR/DwJik39F6gomK2VRB71T7JglVkj6Z2iEkMYzjsCJI4fhigexNLagFegRqX0klCvgLJa5A8ub8b3EGzYZmM/6H3/88Vf8PXx/gJHXMpTkRIgkNP8zF7Z58dIOwQt9qTmxfBDJ+uxxkFk7wQIbatmTyE5maYxje3cPK5BZS5EZbFdtiLZkEhDJaBrPXMXfEvAxmQmph5gJmh8gaKCVnFCu0roaLVdS/SSGSE4rJgHemLcNv5UjwG3XJiTVPZL5kRHAdepr6crBGFpyohoK2nSg2hIXI7lOsVphvCfmlnHWo8gc+uwneP/SSxwoVzlTbDG+PiH6lmeub/H3/4ffZBTg4bfcj4+zZG8KhBj2MwKdzzRDw2DQg70tji1XvHhpA9GGzCR6ltOWzJokOkNNnGyy8x//LeX2JURnWCvMYsYufSrd7iSPLdKVdtGVaLYE2XZKBn6oQiWJnaDGpc6KOFDIwwy//ix7n/hl2slNhtMtojicsRA9IaZmeu4c2onrVNFzd3yJh1ae58lml6nrc3XqmUVDaWcszG5g2ymOhr6F0ws5T+1GpBqy57c4kMHJpYpndw1tTGa3wTikHnH993+NhfIkcmYVr4JVj5mOIIRkSy1CknUW1PWxrodRwdgMXIHp3k1vCgzZ/n0ZsdSkztvcAjp1uc33Ipb36mG6UY8Zolky2BGSKI8MjlC7Q1TNBNs2uMKAgSxucpqnaW58ETEZudYsuZZSZ+x++t+RTTaw4XBihkACKPoZYiKqHeJ/usmhbI26mdEYR4nA7nXWf/Ofs/TB49iV40TJ0aAYbxFfU4nCZIZWp4lxgMEQVYnbV7jxm/9P1h5+J0FcGm/VOxTm1fUXfiAhgAaMBFRyWrVkndUxpM5jRg6uSPblapLvSXaQbPl4AjyaLAGH2xrTTMlsw6HVRUo7YhYDKppEjUJLiBFb9AltQGLAdaOXN+O7j9fXqfk9xFxV8NU+Xk+hxiWNe000ufW9GaOZxxJ5/2N389f+3AdYosZmlpnJKOIOjZ+x7XrUeX//sFMgy/MOJNWp/GHxkqGmwIQaoqc1BcngNImfOEk4BWJBIPHBg+2THz6DPXT3/sYEYIjksU3yrJLkQL+b2jbJLCecQTTJNVBUcBSIGlo3oLZ9ojjIctTm2OjpmZbM2iSHq56+bjMM2yztPsHf/vh9/G8+fJ67w/OshI1kRbw15Qvrylc3lM9cGPHczXHnZf6tFcMKE7HtiOOrfX7knXfjNIkNOTQlPbHt1NWSbKvSsnf5GVycMjdAa21FG0Fmmzg/IZicYAswQuMKfLFA66q0sYnZBwy+9g+XgFTJQdL5pJ8QHdYLxWwTf+FTuJtPYJnRKp2yXFIWFHH0M0Pf7zH0O5RxylG9zsP6FPfwEndnGxTaYtVQScNq3KWKnpwZh/qOv/sX3s9C5ikJqGk5XYz4xR9/J0d7GWJqJq4gRkuuNXH9eXS2sV+1ox7GO2R+gjZ7yYAnrENsCJIneWAjYBL4zGhNpp1fo5gEYuuYFgZwSqL2pV5Th43obKz/WKubfmfEJmodJJVEKyw98D7M0lmC5CBKKTOqZoMeE46aDWTnZbJYU+mE08s5eRiTXfka2faLqTOGEEJSPSydwZo02jAoRZxywIzJ4gxfLSJFiZtuYS5/CW02kDDCximqNRoiNIHYzpKMs+kToyWjoQobyOga5tqX0a0bqXPnZ9jpJvbVKJc/oFDm+o4NRrUjaWryIUCZeFBbEsQl8ygxqWCyA4Yn70IEoslTghSTw6vRlgfuP83pIysU0rLgN1ny6+S04Bu8RjYnwlgF6XxK3ozvPt6wycAbKdTYhKjV9MA3AOKwRA4OHGtsMPj6f8fx+gtU7XXeXlzgRP0SMQgL9Q5lO+qaguDyEqzFI0STE01JI2m2av0eLkw7a2IDEfIwgdgmVLTNu4Q9QDbA9w+g5QEgVSgGyLQl0xnS+QgE7Hfot2qq6qJ0NiGKSkukhRiRmIE4GukxpkdrS9TkkJVYIrkqaodonpNFOO9forr8m/QmV1n2I8rZ8wx2X6QUz+996WU+9fyYLbvMLF/k5RsbRLEJS4Ci8Zs3fxNqBk5ZG+SslpZcApk2OANiDBbFmk6CNQTQSC4tMTTErtKX0NKLY/L6ClmzRSsljRskcJYtCVkfigFi804StQMvvsYjgvSbqnTkuVlacy3Bl+SxYcB1qrAOfpZeGwLeY0yaw1c2sNa+zAlzMylaxpZhHFH4XapmAxsaCIqNM3r1NnloqYxnaIXTizkHC2WFKege7uofcqLd4AgTMjNiIqkSFF8ziCNcHLNP9tNAM9qi57exL32Oyu9in/4d4u51Ag6RgJhkiY3JQWuctp3ufMI9dGB1MhSrTaKuIQRJyYAlJCW97zshSIBYM9e4l9g9I12KUR2FakidKU3m6MsOJ8wGZQzYVumrJw8zKp2R1VvYdo+h36DwO6maRQjGpk5G9GhI12yMkNPQ0wlGA9pbTDWu1vTjJu3my2y//HUIu8AExIM2BKmJOURrUG2gucbka7+BztYRP2E28wgeW2/SblzGu16Hx3htIglnpz1oXrqI2s7AqKBus+S86jKCSc4QFkGjSUkggZBVaJbj2+SZYXxN30SGOZRxzCm9TnHti2TtLjY07I1HfPGFLZ7anCUp9jfje4o3k4EfQlgCwVoa0yOq4NuQOpmxJbeOsP0c40/9vzgx+xpr8TofW7nOOb1K1QSW46SbOSb0rOQmOQuqJgAeGUFdqhK0xgaPiykrFvXY6BPSWgIiLSvH7+HQWz8CeYWnJJqs2y7jrQ9NLfb53Pu7nb7O3cZlHyEd0480FQfe8mGWPvxXsA/+eHr4Q2R1WPGuh+6CvCRmwoFewc8/eoT+s/+OYrYJ7Qwz3aCY3MRQ828+9QT/9vefwEfH1GdMJg2hMz2yUWk1dSRUwUUIUtDgePTeY/ylH32UlUHJo3efwsUmgc1EiWLJneBig4SQHNVig2Q5IeshxvDeR+5myc4ws21MmKZVMumgOvDQh+mdegfGpBn8vDuS9Nx5TTuxadEzTGw6z9aWaDIwDoLHhRmuc0kU36GrjYMYuP/cMQ6uDFjce5az9gainiAZDd1mbBIltuz1+PH3vIVh5jHaYHwLUVkqCt5+5giVnzCUmvzyHzG78gR9ZogxTNtIlAyxFhOm0AFVIYA01L4m93u4l75E0Www+tInmF5/HkubWEHGJryHcYgK0plX3b6oAvvzdro7b59J8gNZ+E7AC0A6h8RIMvEql9HeECTSmox+3OP8sMW0NUoOATJVjhYtZRhjrcF015Z1Ty4I2tZ84JG7WFg9SBsl2ZCjCSlPTO10W6Ci2OjZvfQ1Ln3+k2i7A7RgWiCJG8UYUAtIIOytc/0P/y1xfBMDtNNRUmMMU5rNi8mZ8dXErn4AkbpjaX8ySgfk7CwlY8aJd32M8sF34aOg81FkDGk0IyVRMtwj74WVI2ntNeKsQbQht0BsOZHtkV/7Mj1mHFpdYK/2XJ/A73/lAqFLQQQS7oD57tbRRflOWKj/9OLNZOA1DkFZCDdxMmImC4QoxLpFTcAJWCkhKlnokUehp57V6Q28Rowq2zJgZjJsEIo4JS8bykxw7QjRaaqYokJ7jSA1iFA0IwppMKYmNR5zkIj6XdyhR+DsxzDWkLcZaEgPoySnskiG7w46SRPS73iFiAV3iwtvKMgpwLm0C9g++T0fJXvX34JH/yaNc9ig9I1waikgErBZpIwTzh9bYaW+hNe9pI8QLINmxIKbciNfYCZCGWdE+njN8QFiSBXblJyWRF3LYsSECMZy7kDFR84WrNnAvQczrFiC92RhAs6wUBnKdpQ2qgBWWhpbwMoxiBkLQwuhQY1DQ4vTujO1c9gT78Mc/SCVDVTMQHuIRmppCa/5niMYY8lVMTHHqDKxhpiFRPLQkhgrkJwqTtLmb3JyPHcdLigLSzm+zlpzCdSg0aPG4WNkpqn93SuVP/Ouu3BMibbFYmkko8qU959exAksxJajzTVy2cFbw4RljBRof4VGSoxRVApsIFXxssOsU8OzoSaTGkuLCTvkMoa8T+P6lA4sDiRPdLqOWaC3d6vEopKDFNCBJLuGNPMj6Ptc2vR7cR2Xxu7TbQ2gLie6JUpyVEtsVHpxzFBGGFPTWoMaw2p9maGpCcYRJSPYHo6AEyF4yAh86FzO2kKPgd/hgL9JbBpUbepeZRYN0olX9emNn2PRX0ZMQ4yWKGkGX0SDbS3BZbQI4h09v4VITRFbTH0ZCQbNFnDjTVyc8Fo6+yXvQwFTgEj3uU3JaF7hTj5KOP3e5AQZ0wAJMwN2CDJgz63gz3+AdnAc8TUqGR6DMQGMMLMDSq1ZCzdw4llZLGhtTh0DwXsaBE/WPXtJWjhBuLktGXgzbo83JIDwjRRC4MDkWc7H6zzZLhJU2W6EmToWdMJQJ7hQ4zSQERIf21W8sOeY7UFjKlQUrCMGWDCBYu8ao0tfYnDPPYTNCwzjHvErv0WsG/IwwRpFrj2J3b2afMux+JgRbdG5+ZVoN/MWuVVLwbzuEm7ttt++LyB8I2z7ld8Lc3ezLAEJ7RI7do2y8AQx4GtstgRYjLjUxtaUluBjOqQIrPYzqrphEhwGmzjIGLQ1tFowyh1RIr3o2dqbMQ173MvLHHYtQzlDuPpl2uvXyMMpNlhk6gx961nwm2g7RYxFQkf/jAGMQ1yiJyX3tYg2LXMJW+mcGUUM2AzNe0Sbkcltq9mBK1+zEGFKn11ZZCEvEs/epG6Mdwuob7GG/Q3x1lvSsUQ0otMR2qY5rsYIIVI5yzS2lO0OB2cNxfomxkBjSoLJ03166Yv0Xv4cGk+BaqLPEYFARsQGj0gaO9VAlGQa1Fz6KpObX8O2O6h1BBUsDRAgNsSoxPwAW/kpbLlGlVfcXmferj7JbZ9xa9W/4fPvd1AjfOOtrfvyxXQSzqCux0SWKbIpTIWi2aYMY5y1qApWkp2uuCzpfXR4BlBmAcTlhBtP8sgkstg8xSnzHEUmhBZ6ziX6n9iUlMeITHfJotn3s1Bu4SdEDLgcJSBhgo0t6hOWQNpkkT6r1ghtnZ7/13CIle7/b/z5Ml9IMDltdpC97BAHrMUTUeMQMmK2wGb/LEv5UWq3SG4rIoHYJXfRFLRSYCSNNwUFjVhr8Tg2a/jtz3yZkweWiR2uZK5gLnrbVb++oGV3PN7sDLzWoZHF0XPczQUW/SZoZBqSGIlET25CaudrIKMliw0Rx8vbkUvr2wxlQhYaGjF4k1MC9fWvc/2P/j1MbjJ69ouUfof2S79O/PoncNoASrb5InLpKxhC4uLny8jaiU4P3yV6khOM+B9QS/VVFwA0YBG8OLKVwxz4yF9htnSCViM6m2CzEjGOiCPWDRIFp0rwKaPPq5KDlWHZ73Xt/YgzAUTwXmg1ozHp1JMYubY1YruteSS7wE8NnuZgvIG/+EWaz/4PxNkWbTagUcuBYc5f/rMfYVAmmhhioB4jsU1UQVek0XGHJdCmQWNEjXTJAAn9DTRuiYkWabdBcCr7+i2vXRiWTjzA8ff9eWK2CJKAdIrFnbiP0F/99loHqohviL5JVE9NPhc2zih1xrvvPcbPv+MY4wtfQ9t2ny1R0rL9tV9Hnv6NNKYhYk3ECBgJHF7IeeyBuzEx4rr5uEqO6ITJk7/O7IlfJ5tcRSkJJglaGQ2InyHi0IWTrLzvP2PxsT8Dea+7hltJ1p3cw+VWNoCKwxy5i9X3/wzTwSliiHzoLWe55/AC2lE453eJZHnqYnSv3hAJXgiqTC5+lbdNP8VH9LOcNdeJbc25U0d433sew1iXhJ80jQJkvIP1UzQKEmPqZonrXpJB8wK0gbCJ1RaaZLNMPSIWfcoP/DRx9TSN7b2mY4LvGOKoTjzMkbf9qSQzTovHEdTRO3iGsz/2X1CsnCfYYSeKZjDqsbEhM6nrM2eZAOROOgYVvHyz5lf+199hr6nxOh8rJUBpwi7c6bvo9RlvJgOveSh53GNBxth2hAueIraUmrj20RZo6ulSSUPPb2GbvQRs273B3c3TrMVNghGmpo+oo6xv0NMdiB6nqcU61F0GYRNRUHIyrcl1QlRLaytmxRGoDpAeDEOwOd7q/jzttbx+IYKCRwjVkOzc+5mWBwhGme1uo8UQbEFQQZsZKNhQQwioRly/YsnUrDRbZKoggdx2ICxNFL9e06DBcHVvxiY53qyw0K7zQPNHrI2eIAvbDKeXycMe/XaLvNkmM8rZB8+RSUBdmZDZfoaJHu1obQIJ8BUDEnx3PZIYGGJIjUfDSA6wpb1udm+Sfeu8DHmN9h3FUCwcpTrxVihX0ahYTSYyHLmbNhsSO7W//TJ3XiJp9xM0JJW3rtJMQyVPXyc8dGKRx+46kjZhDeTtHn2m5HiKdpvKb+KjYDp1OBElt4ahixwY9lFbEmPCT6g4tN2jt/EVVkbPYHcu0rphZ4iT5sWiIZk22SXK+z5Kec8HwFZpnednMK99w+XV4pVMJaF1Q2bDU7h7HmfsVnACj5w7xNGVEjqw8H5PwyaPCu0UEQ2KCw0SA2Wzx8HmIoeaCzg/xhpYXXKsHF5MwE9rwU8QbTH1Hq4ddwPwNOJLiSxEY9CsRLUmbL6A9TXSzpJgz2QTU/Xg9NuJyydRW3LnDsSOpzE8RnXqMVKDWgkYouSY/hrl+fchLpmXqa8xEinDHm73AothhzzWzJteRoRckwKkc5ba9KjdAG+ytCbdvS7z50DnH3fo8l+n8WYy8EOI2EHqVCz4SBWmnFm2vOvBMxw6uAzWISKcOjDksdPLrJoJfSb4F/+Qnzmyzk+er6jMlJD3iZpjphtp3h0txrnUHowtRsBrUvJSLKgQbQmH7qK8632Y8iDGgI1KlJzgbPre1zD24V4xbTxRHJodxtte2rTGO+hwBWyRKFztFPUz8jCFUBNpUQsHy8gjh3oM8hw00C8TRa72EeNn3DOseOaFG/xf/vGv8OzmlKBLuLzgEJdZufoZ/HibgOOuY4v89FsPcsiNMKFF4oycNukFGAvNGIcn2qxDJCsSAxpSO1JEiKppfi0GJaLiKI6+hd7xB9KZ2+kuROI+PfG1CAEwOeqWCaZKVWQIII5YrKLi9g/59PWvHN8ASdBF0yRVY0iHvtasVcLp1V5H6bMQW6o4ogwjoire5kTjaFWw2uCYgUaMRBZ7FmcMsnyEWC5BRw0LW9fQl7+CW38Bt34RhgehY70ASFsjvkZMRjALtG6IGpfmzGK6rrPuv/o7tZfvU5gP3UM4/FbUrGBcyWJhOLk2RPwEMZLa2ETECMG6ZNzTPW9WFG3GWIloG1JBYHK8KZKxWruNCSOcTc+3jLeRdoprJ2TtKCUbMXa6/yaNtqwhFhVhssvos/8B00yhnSVmxc2XE5WxOIzPl9A5u+SOLGD6Q01BMBWIxWC7IYBFTUYrPVQclaSOqdGWXthl47f/BXdXI04uOqKGxEIQknSWH2FjizeO1hS0MaZ75Btswm89k292B26PN5OBH0IYkrrYNDgaBfGeDz50kv/Tf/Y477tnAdPu4NTz2L2n+C//yk9xbDnHhBlLcZNH3AX+iw+d5v4Vn2bbajCTbfAziDnWZcToUcmT1oDNUi0uGdo55umpt7D4+M8RyoMk7TQlWkN0tjvwXssTqwMYapKLdYBKPz2kzS5ZM8aWfbBdFu8n4KcUfgf8CPVjYmY51Lf8nb/8ExxZHQCBMnXwmU4bFquCDz12kr1WeHFPaWJAfQ2uINcJw+2nCe2Yienx0NnD/OJPvYdFO0uqbmFEbJLlK0ERP0mtdpPvJwMaPBqTiIk4R9T0fs6HBBHL8v3v59BD7yfOBa+izrHzr+2hpYEgGSJzsJSAccR8gO1aox2kmm9SZVPtFBVDNyZI6oKFttxz8gDvfugcVUw6AJKmuWTW4I3rOOBKVMi1ST4DGshzx/lTxxEgHDhNWD2LEUFiTWhn0E5AJK3akdMY70mkVIOElhyPiE+iRZLIgZGuitNXpgB3trAzLD/yIwzf+nHE9shjzdpyj5N3nUkc/jhXPEiYGTHutnFHSrxGs471006JNqe2A1rJO1VCj7QTNEoSUatHSKix7Tglytg0uhIDNkdFMS4jugINM8rZtaSh4WtEW/I4Tlbk2QqSDe7svGVeqe//pyWQ4eKtYVD3JTgJiEBQg4k1+e4FfuYD9/ETj9+XMC6S6MFZmFCEMQXJ1t2rSV0x6EYpt/1qkX3tljfjVryZDPxAQtNG9S3LFSWPI3qmoRHH9WmkwbBg4Qg7lNc/BfUV8jjFtDtUmceJ4k3SBFhoN+jtfI1DzUv0dYSNgTjZQv2U4JXMgiVJuwZyxCiOlmTZYjHaUmfLUB6nlgxoU2vYWKJzaJIXes0iCbKaBDKjxqlPs1aJOD8hjy2uN0gHmBG0mSRaYrODmW1DnKBETL1LpeME0NNIVaT28mRvSr+oyPoZsRgiOiALM6psB9Eao4Zh2MVMN5lFkDCmkCmiShnGsHWRTCK4nISSmyY1QuuItuNS+BaNSf6aqpdAXV0yEMSmjkK2TOOWE7NdSBv1Nx+/P+BQiHX6VDowo1hihIBLQD+5DW73TaJMKdGJsSV26o1WIrmN5NpSmppq7wJZu40ArVpmUlBjcXgqHUMMOPVkmvTjrTUMeyWCATtk7JYTSFWbNG4xllY7+mMxTNVgVEwE3bhJ7scYnZKZFtPhvvWVL/l1ESpCyA/hs0MoJokK+QkiBmtzCAFrkjqiagIAqxicy8iyjKhwfRyTKmA7SutHMsyyGgkmxyg4a4mqiZZIhGaC7TRAkgGDSaMEEcQ5NMuTwmaznXwafAPqcTrFEFHTh6zokts7tZjajUoCjkBA8KrpeSUmvwaAbhwXTEHj+gQVCj+mL1OGVhFjiAquyJB2Qo8ZphmTjKltwlXQwXi6zTlKp3gp8pp27d6I8WYy8McO3f/nlhQuhP2NTMhVydqGTAOf/eozjCXNlOO1J7n8r/8+7dVnUktxfDMJBJmMVmz6CRKZfPbfcZ5LLPp1MttST6fQNGhsMdlcpCVDaQmH7qI99U68yzFEvDiCWwRcV5MkipZZPYdbu/+HI84hpF1x38fM4NbOovkSxmVItpA2M4mJxx8UEwN7L30Nf+V5VAVfjxi/8FUWs4AaR5Eltb+6bhMdzkKwkcIUhKbFtpsMTQtqEjhz9wY5oYMTG6IPxM1L1J/5DUwz6VhoSeLZxhngwFapqgstLkxQAtpbAnNLsMXQmSU5g5oCoVtPsUg6El+zmG/llgCmSzw6vjnZEM4+Tr10Js1nxRDE4svF5CKpAUKL1ZYQEs7Axhk2zHDRQ/DE8QaTz/0qxYXPQzMjZH1WBj1OLFXQjlPHSz2IwWhLpg2VtLiiIGhIyHbXw4t2IlQBo5Eo4PNFtLe2jzg3REbPP4GMNhICv9NH+HZi2Hd2Lxe82PScGoshUpikKBiaJgFMYzrYpuUacfFY6tQdOEOWlVhgu05aIS7OWHIzylxwcYrvL1HTh1bJjEkOfMETxSCtQIyoJsxMWx3AkBGdpckqjAzIwhS0JVoHfobTmojibYGKxR66F7dymtdSdOg7LB23sER6G2tjbsyt6akSUJdGniGSGD7GYbTFxoAxlrh8DJaPcFC3+Oi9B1nOFA2BJqYiJJKSsXkeLPMO07x4ezP2481k4AcSHYNV6XR2BC8koxAVfOxhtOL+Y0vsTm4yMYoVS9HukE9fpm0neHXks100KrU4EE9BErgZ7LzEvbPnWWtfBDvBREfpIyI1jbUEEWK0WBr2lh8i//j/lbB4GPEtUzskugHIlEoDygC1JSv3/ziHH/5pjBSv6aZquiZgsKAUiCY1xtXHfpK4dC+UA0y+BkSMekyzRzR9DBm9ZhMzvo4r+0St6c+eZcVfABx9k1Ekk3ZyF1kyNX29ThNrtr2jjI4qtISusrJhStbuAQVIBqGh1An55ovk2iAugk4htIneaYaIFEkEpZ2Rx228eHzvAI0OUHGIKFaFzApihQrBScJ/YHJsNwd9LQlcSoGEGcFAbTLUmZRgFWuUH/0/4u/5UdqO1ultRjx0DqzDtDNoR1g/IQgEckomlEzJxaPqoJ0y3P06/Z1ncJlDsJyyGzx6NECY0GQDCp3gXUlUoZjd5LhepmIPGKPSYDXinaAmYmIkCzVOa8LKKeyB87TG0BQDMJ5e2KDUKaqWSKK+7avXJT7nPsbl2ztm/HAiR8lEEJMRbZ6gD9qQZK3TwWOjMll7ED39DjwF8uDHCGT0MkvbekynbHj8YEl/ZQm0pTl+L41USNDExpAaxBHIEM3RKEBDUMv0wHnE9miWVhn1j1JlR6h2b4C1yHABmh2sTvDimFIiBBbf8hOsPPhxko7CnYg5HTJDxOGAQgRsmXAt3RgJo4RiCeM9fU0dsJktYV/c2BBOP0o8fB+n/EX+8ntOcTAXQlRal9Nq7AqyWyJVluRj8Saf4JvjzWTgNQpBEge2uyGdiawMMmbNLAnjmCTyk+RVmwT4Cw2EFtVU7VmJRBxZnHDOrfPIaqTSCYXfJWt3QQMuhkSVkZZISXAD6C9TZweJ1uFiaremyWvXMha6quA7SQ3/INaBfQDv7aG2QE2eqpei7DYHSZQsSJQ+jdhQY0ODCzOmT/5HVveeoYwTjpQ1S2ETo5412eHo5lc5ry+T4alDRm6EXNtUHSjgO6W6NqnhSWy7EUDTrYcDbQkxMLJr+NW7E3hNUiudENME2OYIpjMqurWppJcv+5sZPxSPDEGsTevolhktnGOnOEJte4hNmu+4MqHxY8DFNJQ1BEQbxldeZLq7iWrkuZcusL211SU5QlAQPI4x0SnjrIc3sGbWWf/Uv8JMr2HDHtnWBa7d2KW1fdi9xFtmn2f56/+KePHLGFd0CoKdpkHUJLwjOb5YxJR9olh28zVqdRSSDGe0o40ZvbWJv/Kq7/xG/srXkBIV3a84u5JTO7xQJ7ZjXEG0BWXmKLRld+vm/uTcjHcw00naN4zDasvs6ovJhCo/TO0LlACmTv+OOdpCLBxt7tDeaZrBeXpLB5BmCurwJqe9eYPkDqo4P0nMEcnB9Jg34+9MdCsocuvZmT8z+4QNk7Awcx+FTl0UEawAGpJctSuwAqWFGAJXrt9kMqvZ2tzofkxKHe8k6PSNEG8mAz+Q6OoU0eSkBfv0IbQhGsXqmKW8YTKb4mOa7ao6iKlNqAKxbcBPU72nLU4jycOg5Xi8wnm3TZ8G43eRsIdGsBoxkiVFMi3xUkBWsvTIx5jlQ3IJ5NIBsG5/0O5YdJKk1oF1iWdus0S5MrbzB0iPrUjsDmvBOkux+TSn9Cql1rz3vqP8zZ96L3k1oIoj1q5/inNcRBFGHs4cP8wj508Qo08jipAodDLbhTjFhGlq5PgmwexMBlrT+BZ7/4dYe9+fR12VOj0xEKMmNpLNXqHYeGdD8QpBchbPvZ3DP/W3WPnIX8aXB/bxAWo7XbFOnEUwRO8xYcbo5kV8M8Go8vWnn6NtWoLkOJFk/qQtRlqm0WIe+SDZybO859GT+Gd/h2xyjb5rseMbXL22TovFbr/IY/oEb/FfIlt/CuNK1LoEiOvoi1ot0larDA6fJkqG7a2w/CP/Odnxe6GtCTES1SCinYX263v7nh9SgnTJwCupukbAWQFjaBSMdaws9nn8sQewMalURlUYb8N0lIR3bI6Z7RLH1/FZzuCxn8ItHEUIYCYkgaYMGx1qlKmzlGcf5+B7/yLm6Elal+GlRFYO48d7qeKOkazZRUJLFIuX17fe3HwXFTtn7dymhiKCNQkVhekwE6oMBz0euP8edvZGHFxb4/CBlcT0RbvEvBtG3PE98PUZd3o3+xMQkuhRCBDnQ6mu4k9a4Pgp/bDDiuzimylBb93aViM2TojWEn2NtGMsgSqOKeIUuhlr6Tc50K5TqQf1RKPpfFMHrsKYiKrDY1M2vXYfe72DqbqWebV9B+ZkXaV0O5snzhHvJkvgu/l02JhXJgPz12tKghoq3WPYrIMRhoXlvmML1LZPKIcssUO/3WIaLLMIg1xYdTW56TosGtN8e7YFHW0raiR4n6hbHT0zhJZmcBKzcjcxW6SVMiUDOlcbtKlCMXMJkzsbSUHZIIOjmMNvQw49gneDBNHY70AJKo7W9JhJD/IhEltsSEwBjS02L9AQUHFk6hFtQWtMFCRbolm6G4bHWLANB9otMu+RmLgpESGXlnx0maVwjUWzRU9HiTVobKIuxjrdenmfWbGIWT6Mmh7T8jB67DG2sqN410Pj/CBIHhev99h/nBJS8NZHd8NbSTRCOuMlW/RwRI4t5tjYIC65NOYxjU8gdRFsvYsLu7TBI6sPEE2FIRCsBzzETrhIFV/kTLMj2OX7oRzgFlZRU6C9RWLb4rMhXnKcn0KHZZqD6F7X0Qk7Jclp0x3oaW+wkpIBMRZ1OdYIrpmwttQntDVLC0MODAeJvRTjq+O734z9uPO72Z+AEObt4bn6dac9EwPt3g2m65dYY5ti81msn6aDyTdJ8U09/pmvEsQmIFizh4sNh4rAIhMKiQQEEz1LTDmxMqRVoUUJ7ZTGQ3A9VCXNHwFMRuwdYas6TRMMroM177fg78ga3fa5MSkZsFmHhJ4nBF0FP/86VTQo6qoEntKIw9OoQ/KSwhgCluj6hCjUMUnmtq0mNcd2FxvbNBKIHhcbzPgG42e+wOTS02AkGch0pjz4Oo0E8iHBFEyrw9QLJ1GNiRGRp41JTNKdVzG3WsJ3Irq2qjFCoECzQ5CtITishjQekAjW0poe095RZO1+9twq3mVInKZqk0A0rmNqGCqdYdo92msvQSOEkCPZGioL0LQU3mOCAy0Y0cNYRxZGmNF6AtBFSSZD6ju46FzmuQWbE21JUEcsDrC7cC8UxwgHH2G2eBZINt/JXEtfeeO8XmN+sKomhH/o3BmhU9dLqpUeh7gCQ6Af98i1IWrXrwkTMk2sIDEZeb1LVk9SpyFbwoviVJMRVYioH6NhTGYrGhWi7YHrE22JZEuQZQSTgUam1WGaao0YI1EcSUj79RtdKQBYcFmSct5ny6SEwIl2I5i0j2hogZqBtJQmkBuf9AmInUGW3NZdeD0Mml5/8Xq+J96AEbqEoGsQBE/UKbbe46jZY3F0gZ542rqlshHjp+SmIZ9uUi2t0KsKmG1jtebn//SH+Nkfez9ZOyFqRI3h7sPLfOx9byOYDJtZbLuJI6J5H40Zhik2NmgU3OpRzvzIX8EuH+6qwztZCMwPTLn1YRIKO85b7mIQY5AYuuc9YqRLBhCctiSMQ5rPttHQzy0DJhTa0pCERlQjUnusSFINFFIF1s6SNfP0Jn79BcxkPVW/c9Ty/H3zNUZrjLasPPA+hm//UziTOMvqHGo6SVn72rq+fbdhNB0SqS+VgylxMYCTpKIo4BXacpWlj/wFBo//LOUjHyFqltZFui3SFJQGcpexPHDkYY+tS88Qo+LUp6TDFkiT5LKj2sQM0FvVr9YNRJOMZyQJWtmsTNtwmEHbpPddElalPHiWYz/613HDoxx778/Sf/znMBFM9ARuSfe+bmNf8J5b+JAOH5FwJJIqWFEQm7QZbIbG5GSIn906qrRBYpOcHl2One3h6jZ1brIMdTUEQbWH+IjIHlqv0yuXkOj2kzokR/JVvFFMnoMY4um3YO97N0HyhMdQktfB63YEMx+yWtRl6cOm+2HOBjAo1kjHMLBkErDtDu9/9DSrFSwWFkfEEvffI5V97bM341vEnd/N/sRERyUgEuOtvFPw5LFmod3ioOxRakOYTbFxitBAnCWjlqqXMMj1Hq6dsloqq0s5RZhhQg3G0JOanpvgo8e5gJtdwYQpIcsIMUd0muxso6KuID/4ELXr7+vody/oDqzLKz9Pwh8dbqKDN0JKBjTGtLF2drXRB9CWPIxBBCNCZtL8e6mAo3aLlfY6RqBpA1mY4Oo9MJY6WtQ4nCQvdIeH6RbW75HFyf7Pd0ZSJR2SIZHVCSbuoQtHkeVznYucdC6MHb7Bdjj3/dblHQido1XaTmAodamsNl2zxSImHcw7sSQeuIdYnaFdOsdUStSn1n2MymiSZJiJgVxqcj/C6SS5azLCMsZkAfyM1lgikDGmH/cwsUWKAZIVmNCQNZNU3UmBdSXWmCTxHJrULie9v+r6yOq9KBnN4Dhh4Xw3IWoTyPb1ngwwf4W3tdxjAkrSdWysJCXCxGu3iM2xVnBhQmHp8AZ0KpCeIBZxOVmokSZRXaNTME2iJ4UeRi3S3EDrdapqCRuTZydMMeogWyXYiHEZPkJTHsQvncSbMr0GjUiMr+/VnY8TXZ6eOfPNYEcR04EzTRJYomZtYDjQtwwLxRESyHCep32L3/Fm3Io3k4E/dqQkIOH1c1CDk7kMpkUwWOPIjacnUyqJzKY14dpXufEffwUX2+SIl/dQA9t/8O9hdIPNL30CGV1CdIZzsePet+CnqApiDfUXfx3du0YoS7zNmS4dIy6fJtpBUh40PaJa1PWAVCWY/fl9N6d/zVeny/CZ43nnc+A0c98HXovBGsH6OqHIJaHQM7+HcRbfae+XVulLcg+0ecZQJsiNJ3Abz2GbGo8wiwCRoJFIkVTc6j1MrJldfI5sdKNjYTicIUlFm5yNT/+v8MLncAYwGUpGtBWj3T28r8mtw1nwpkjvNbfGQnci5nuZYrpqtGWOXVE3SHNSU4IdINZD1idSIWZAjA4jLY6aEGFnnMSoXBxDvYtoi+s6B0EiYhuMk6R8qYrSgGnJ4xQRQbMcrwbxE4rZOqKBaCvIqySDe+05ti49iYaYRKVsGiF4k6OStBqawSm2j7wLzZc64ODrd7dWNLkYdh/t3OcjNLTGMBucpLE9nLQYk+6vBHhzoJ7s5d9n1U0wGjE6Z7QYolHElhgDtauQlaTgqOrw+ZAQDb5t2X3yc9jxdWy5TLv8VnRwFAhIVLCWIA5jHVZA3AL2wAPsHXo7mIIogsqdFB36zpEmLkm/I9qU9apGgskQIhlNosDaAaY8jJeczd/9FS7+1j/jnmyDk0PBkZxN52PI1/t45E7Hm2vzA4mQRD0kR0ktu2gg2gwkIfy9NWAjRMO0tQx2nqC3/lny0CLREEyBWsNw82uU9Tq9m18n23kJkVRRRZfju+oj4DC2oLjxBKHZoy0WCEsHqH76/8Dqu/8ite11xi9tUsirDiblMbG3VTJmHwX9moZIGgUgkLTGAN33CZEY0saKTXPAdpQkcm2BJZLVm5jhQTj3YdQWnDm0wvGyZWim5E7pmykD3WStuUwWAnumz43WkTPBtdt4L6hmSGygqmhuvIzdu5Q2WAqMghQLhN5Bete/QHX1cxhTgV3CmRyxhjY0YDwiFWJz2rxP0IK5Ze+dDcFjE3aVKVEL2qxC+0cQDfhQ4PM1srxBopJhktKdV0ycUuiUQMbUG8SSqISaVOEkRIwKM1MmkJarME1D5pPDoHeGYEi6+5mjdcPkQzDbImqbGCNZMsTJx5fxs6vEOhkakSnWGHIjGOvomUjvyH0s/8x/TXHgPJn6xGh4HUckdLNqmOQGQYntmFANKN/7F5CVk+RaJyli18OEBmMdVW45v/sZDrptnHbJkXEk8GBATI8olnj2Hlbf9bNIa4m6Srj3UTRPGhlm/WXszjXswmEOf+y/orrrR8DkqVp2AWt6iZUgEWMreqfew+Gf/D/jyiH1Pqvo9bu+cwipWEEyqK3rkkYHGsjjlMrUyeb65DvIDpymd/VTrLzwr/mvfvpB/uy7H8QBydHxG5KBN0bT6Ycer29+yRslOvTwrUfrthm5SKqBRVERms6dz0hItq0a0reLRYztpFvnbnLtPlVJVJGYmASiyb6XEDAh4BhiZIbpP4AtVogKRhzqYKc6wuJgdV+s5Yf+HCjYxIxmPgcUFNEWGxusdhVKNwKgcwbEOvAtPijGLhCr1WRvagJHwhWyl36fqljltH8JK4HQVZdCRNoJTK9i2EybsUJrS7Rao92ZIDuXkVgn8KJJrm+h1yfrIEZibqMNZgV5V9HtDs4Q3UEs1zAa0nx3/jb/MNf09sVVOp31bs5qHDsyZGiqJGObtVAOqGOGmiXUAi4ALabtBqmatBQETd4LwSf/hblkrVgQi3Wy74KnCqIGJ6RN2i2wYy3CHpXxSehRWzI8QWZI22KcEq0STAkUXfV/m3yQcfQX1wghYO1toNLXaUiHcsc4vO1jNN0zEYfpLSbxJ7lNZ6BLiq3LiaTnP9k7y/6hpZDodMbgswGUi8Ra2MsOwXCI16/TyyM6vcmkbSgGq7jBCtEmALOKIlmBiENsljACrkDyiiKvUpIHr2A8vN5Cuu3TAiF6TLTsZsdYsAEXWpQCxFIVBUXZg6zE5WVKfOKMxcUebXG7oJLc9ueb8WrxZmfgtYjbEu40LkztZAVmpp+sh2O7D4ZJM/Q5IG2OTI7JojQmZLIQMbGGUO8nA8lWt8FJRogZsEbA4iSByDXLOfCOn8YtHbnFO/8hg4aS5GgaDSTdsJQMoKGTs72F8TXGICHcEh5RiGJTl6CokrhIO+Ln3nuK7JlfZ/ap/zf3xOfJ1dNIkUBnvsE1e/j15zHjdQwNIoHaDjCnH05grN1riWBlErhDraMcLILpNPNvBwa6HIfH5D3Kx36a8uRj5HisdvoE+0yIOxUJe61iUBy2N+TIO38MM1hGjUGo8cM11h77GWzvGMGkqhxtkAbm78e8wlVXECQjxoDEBiEkYKc6nMswzRRDg4kBo0o2P16WTrH41h/FD48T88XklqkeQySaFm081nuiU7zpo5So3kLdp0iiMsbc6TX9bqJLpIwBcayeeoCYFWkQFizqklz2vpiOSZgYVLBZ3ik+pPVRSda9kFwmxaakLu+tQrRI/xBL7/gJZOVM6sLEKbL1ctIPyBdAbOeJkcCZanNCVMQWqC0xWZWSjQ7U+fo/GhO40cSIU8AMWH37T5GtnqWkRWxJlG6/KEswhogSQ8CKIsHjzOv5+l6f8WYy8BpEtz3v/3eqb5IuezAFthlR6bjTdU+Vv+5Lrd52E2vyxEuK3UoWZ0kwh+QiJ0SMryHzTDLw1nbnWIAoRDtg6b6PYsrlH+LVf0OoduCojttMqkQlQktBY/vQoYSNMckqeF8kic4G1mPjDI0Nedjj0QeWONPfYenq5zgaLlPFCcFk6WAOnsn2OgsyIadhLmtaux66dgZTDbA0qCuSzkGMiC0pF1cQlzPXO5hL9GheEnDMYkF+5l2UB+9J0rzRd52dO9xq7Wxc022T0NfVQx9Ai4UEyCwKpsUK+X0/SiwWUWL6e20wkeRuCcQuGYgmJ0q6PhsmiPhOpSXDicX4KUKddApUyAlkRGL/EP23/xh64CxTswjlIqpKkJyZLYm+JfMTEAimh0pOwtoA+w3cdH/Mn4PX2l77jxtz6Kg3juzg3UlNU0CkQEx34AsYM9elSNdnXMJJ5LHBavLWaMgTAwMQ61CT4e0Q1ILt0X/gQ2j/aOeD4ImzbVg6hOmvQgRrDQFDEIOqIfqIuAqyClf008/BIDrvDMRXv7DXQUj3+oLmjM0y9vz7MMsn0wgxztVUu/tHkqGRtQ6Jyc9FeH1f3+sx3hwTvBYh38DaEYsEJcPjfYPb22JothLadY6mF7nFo42dPEYMGFJFbTSQhRlh+zpMx4l6hxKbCTMnXBPLgo1YpgiuO0ULghVstykBPwSJ3FcPTdD1RP+joO4fY+Ydi52BkbUG7TAE8+olySg3WNMCDXG6ib7wWfJmE5lsskiPSSgRwFqHdZZ6NqIsIwGHNz2stiAZZAPI+rSU+OoQBE/ht1GTpYp4n5U8ZyYL6vrs5IfwxRIH7SKSt8zyA+Tk9DqA0p2ttNKNFiVNRY1xYA6CZBgidezT9A6DO0g0pru6IsnS4mklw2MJIaAiROsIqhTtFN28gmhywBR1GFHa2V6ymTZ9MpMEihSPuAXID1C7Ia5cxfeGVCanLQ+xYw+yOtqj7wJtJkRb7G/gt8e+HO0bIOatbCEBUK0spoo+tmiwqRI36e6wXXITYurgkJdEEXoyo6dT0GTXHKOm59QmKWFTLINN1b5ky0i+0B1/EWMEXy5D1utuvbA/LlJJeA9MTjAlg2oB1O0LUKUX/vpe54QpUiZmyGZ+lF6+TGv7HXlnglOZp+uASQlUjLd1It9MBr7XeDMZeA1C6ObfXUYQJFneFrRIM2apuc5Ce4PcKkTDnGYnxt46UlTBt+lml3Tj46eMtq4z29tmoa+oRiKB/sm3cO7+s2TVAIk+gRFNvK3tc2eR2a9gE0hSZ1Q35OhjH0dnW2lEohFjktOfanIekxjxxiC2xA76yfip3mPyxB9g2xpi5OBCQc8KbuY7PrfQeMXlBfnZB2iuPEO1d4VMQxIocQPiofsoH/sxxn/0G1DvJA8C23UW9qWG03rZao2VD/41XF6ArcD2WHn8Z5GVc8S4L+Fwx1Z2rigXSEkfRBrpk0xcDYvH30p/rSb2+qhRTPSY2EsdBZmRL6wQtgtaH9MM3GaJqRGn+JsXQQJGLJBhrBDbGcQZxBxsomSW6tPBbkuiLSgOnWLcCIX06d/9CEflEv43/hF5vA5rd6WumZl3HF7fh9Krh6YqtOsiGfqAQgcIxpg5FCZ1YiQdXVHBZAWK8Oj54yxcvwBN29HkFCMh4VhMjua9hBEyiidHTNZt2AYlw/VW02iL1D2DNOIyIuATJkZtiektgM2gs/d5Y0Qkxkj/5INUheDyiolNIwGm13Da23/e98GQoglzFNsO7/JmfC/xZjLwmsRtIwLpdO8xuNiQa8MgbjMMO0hoCbj5jtHNH+d85QBtC2gHMEyALImJUz7vIqgYbP8+Bqc/QrAOq5FWBUQTUp74Cl3uH3p0qnbMX4FGoirBFtijD2H8iHnaYozZN/uZz1e9ycEtUvZWiK6HiUrW7lBrEq7p95Lpy944JQdR09y7lQxz8j52NzYp9tbJYkqsgqmIB87D2fcw/dyn6YlJHGaTvBIw9jZdBoH8AL1HfgoJNXQ0TXPugwQpUMm47cruaERJAkRopMZQAmikXD5PdJEphlw84gNWe5gYUVtTrBwk7uU0rU8678amey3WycrYhm72bRHXHVgmop3CoY0RK23HpTcY52DlOM3VXbzrka2cJZ54B8H9Y8xshFOXkgFp2BeJ/3bn051f2lcPTRbFaTaXJ5ZEmFNjTTcykP37KZLocpLliAjnTh8huzpNvH8ixjqCtCSKYYa4AtGGxFZKibJD059S4qplkhBXTNgOTFIw1AjBIyajlQyK3n6vjTmA8I0QRvALhykHJcQZwZhEmR5dgenSfv8uYU3SvpE7i9TTN/0Hvo94fQ/l3ijRedenelJSW5WUCEixhF8+S+MhN8ksBw1pZAAEsQTJMWowEmnF0toBhgm04/SIS4tGg9JD8BhpaQ6+lfGxjzBzC2ixCLaHEQe4VBmQNnVEuXMixJB2RHMbrSe1shWIpoBsIVEPVdNYQxz///bePMqu6kzs/X1773PuVKOqNAsJjSBmkAEDBmxsDLhpM9iGjuNgp9NvdYbu9Vbnve6V1/kvK8nKykpip512OwFjm6HbwW1jwG4aGzvGDWYwFqMEUjFqQEiipJrvcM7Z+/2xzzl1qyQGlSSoos6PJaSa7t3nqz18+xutS7BdvTR614FT3u3RfRLx6k8RqSrGNmk6Q9S3DmctykaUNYiLaUkVnFBWAqUFxGuuYrzvNITYb5KpL1Z0L1qF3meujL/hOZf2TdCTrU91iZZUSHQnon3RFqs7SST8YJWsXLaaLHlKpWPP2v4iGlQNK1VfDY8Y0tu/ipu4OMaabgLXIrExFocLOtDO4qz2XnynCV0dUQ6CSqpwae/F0iUCLCIx1gQgJeziM3CLz0SWnYXqWkOkyujyYqLaCSS6hF24PB23wVfrnCs31UNx6cFqfKMALCES13HEoA2BxPR1lNJAToNyESIhttQNDoKJMYz4OAOtYiItQBW08b28lPG1+dMmU0pUenvTOJyPBchdjSHKaV8NcuEG1ElXYTtXY0+8GFfqxcscfHYTU6xfsxEBbyFB41QHiMFgMfEEjd/+jLcefwDtvGUGHEo5GrqbyAVMvL4VbFp/g7YGR6klreDwFJaBo8Yfdv74Jb0lqCxUCKkugZXn4nb+HJvEoEvEuuIPG/G+cisabR1KJTRFI+VuymYIbBOLQZIIVIWWLSHSAtfAbPoipY6VHPzhH/vqZCYtq+s0IUAaGObbwX6ApBXWFN5a4W81EKabkxVDQoJxgpMqESEoS2PBCiqrLoJf3kFAgu0+icpl/zej398ByS5aYQ/utPMx25+g0WihZYSSJFhVphRP0BWPIaV++j5xPY3uGsmvvorELQJtSIxBUGiX+K6JosFob7FwYFSQeeIRHNXcdaDJHDl6tuyjognysShQIZX8i4Ev707gDxMHTofYskPF45Ak2O6FVNxLtGwTFziSoIuSsyS6ioobgC9NbLXFBjU0QuIqaBTWlCi5hAnliEwJKLHw3N9Dwgar1lsS3UciUO7qRa27kPpzgwTrTsdteRVcFacihGA2n0nvgKRFxRyBjWjpmIQKJA2sikCXqWhH56IuRrRGoTGuhVIBUanXXwhadaxVWAPK1WmaDsJW1VfdwxKIAlUBYrQSrJj0LFMo5/cSoYFVITEhKu11otd9jPLqC3CmwqL+s9FZi/AU3/53Fm/9XhPwN30FEICrUJIEiUbhrW30jfRzsGcjTnvFVGkIlpxCuHQtrZHdOHwqt5P26TW7C1l90MziGTGXaDe9SVsAHICioTox4SISUSSxoFySVntrpilGisRZlFKEtun9f8pAIigX+ZuFsxg7BsN7EF3FhT2oajc6a1ErbRN9VgUHSX4pmfrv7KvimzqJgA5IHBB0UTd9lMq93ncqfmOgXPFFlBBf1a7WQ9MaEtskLAV0TkR0TAzSkQyxQEZROsCUyowHZRIpUVEh4LzlRBRKKSDxm2NbLrhK1SjlfOUCP+DZJNMUmWbynfZ7P1yig6SVHlWSQNKEciex0zRbCa7kTdqKyb7xTrR3EQBKq8l0UKXQxvjmWJLVf1coUwFlEeN8dLxLQAwuqBElChV0EAXdWNWBdaa9ysDcIk0lcG6ykI2I8vEu4H8XyqCUoiQx4lq+rkBSB+MvCyoeRWzDF9Zxvo6+E998R9Ka+2njDMQJeUOkbAjp2nfpgCSdp4LBmRARTVAOpg47m8uzXOi5dTX72OH7EAA6aRASe7dMZmUyFcS00L2LSfbshnjcr1/XLrLCEP5OFNI5zjgRktpC9OrzqJtuRClKaS9u5Zq+RCm+tKkSRWBjtLNYKeGcIRAHpop1Fl1/E/f8o1DqRlV6QQcoXWKuO8iyyGxMgCgDfWsor/wIiemkKQFWlfwB7RxOhcSx9e4WZUhMjcSCU8KaRVXOXlFlVTViRakOYQnBUetdSCPoxumqPwgVIH7DVS5J/d3+fZyotNPc3DcpTtlM0884B0qcb4DTrOMqnbScZqKVAJIqSC69RIkPflUGEERl2R3OH3TGoPOWQlmlGJ26J7wCp0WBlGhZg9UhmA46lp+MqSxMY2nmOq7dAu/naJrraZ2AtRjnOzbGKGwygTVeyVLxCMY1SCinbkaLUwku7YGh0rgZJP0rzzhSPk03s2qll5H8d50GK5IqJ/D+1xc5Giazq7zrNfs4CaokEiCRb8imJa1TIQEtQhJTQXUtZnBwkKR+AOViJN1fmfL/ub+2jweFMnDcEeJKH10XXI3pWeLb5SYtvNM1JtEl6qaTJiVQIU5CoiSkGWuSyB96UYwvsc0EYX2QsO8ETFc/BGXqdOEI320QsxZxmQ/TkRgfXFY+5UK6zvkMmBotFWA7+rCJBa2IVYCLEwIXIypNwcIhSjjnlLVcft5a+tUYXclB0CEgBItXUe9aiVUdk7ct5cub5rd/U6UlZZx4kzrOB2SR1Tz40OBSy0CESyJsqUqiQl8hUmXWEsFpjUUTSYlYvBzJWj2LIkFAhwQkPkVWvDMIERxeIVBCavUp0aJE4hQuqLL8/E9SWbKmrXLiXEYmLTCSZsKkaQTO4es14FsPj+le4sRiJSSWEiR1nBIa0keCV+qdSnyGgLRZBtL0Y1E6Pej9+x7q988skmkDH8hTNedKymaGb2blEGe97180cbWPSFcgbmGICCQryqawqoLSZViwHDGCJEM+pTgteJarAA5fY8EVCsF0CmXgfSBRJVxpIZYA4xICsSQSAIYJ08Pe0kqa1SUkqsS46qFeXuo3ByJQaZFSiXHKom2ElRrO+CY64+VVJLrm32gOaf/tKJTPClLaR6nrXlywPE1VM7iOhSijQWkSHfoCNklzsiSDjUAErSylUBHGo5RsA3TJV2QLexkuL8eWF/l0q9T87UvqOlxQAlMjCTqJXJpiaLOqfh9o7uCxJb1VohXETbSLfd67+IZaADrtHe/CClaXiSu9NAkRU/Y3UuvN/xFBqgxY35grUyLSOJBsaxErIGXCai/WKZAQFfYgupqO6YMRxTFBJDdBC6RuA2/l890Zne+EKRp0N6Nd67FhD1ChrmokWBqmQqO6hobpJnEapy2YABBU2iY7r7qhlO+emd53USYPkvNjyFwJKi1xLJMVEOdQDQfIq2eAi9K7vSGpLWJc1XwnUg3KNpBA++BqVcLp0Be7ao3TevEJXDSBs0nb6x36DgWTFMrA+4BzgtNlEIexLZRApMokpkrnKRex8po/ZtE5l+F0lWTxRro+9SVMzyJ0cwQFGBcDEU0dpFpyGYhITIkTLr2RUt+K3FA4h9b7FByANqniU8NKF6KESq1G2L3ER/mLJhFfNVAnDZ+SlfjSziowPtIdb8r2MQghsSgoLWDDJz5HuGQ9Kqik6XM6NcNanBhUuYvutadhTZWsbGtWFc/NVaG2kd8m0wPDRU3Exj5GQKWHBSBG+8qMYRU6etEnnkydErH4wkwEZVy1k0SX0aUaRjk0iVcw0ltr3pIakLT4VdcJa9IywxqkAhivZn1Y9uRMMWiLGQgESBIcAeX+9az/zB9S7V9Hdcl6uldtxFpFvHQt/Vd8Bb14HegyiSQ4pVIVNPOJt8lVJI2gV96l1tZzZFKY3pkzt/HFlRwJFsE6Rffq01iw8SM4CThh3ToW9flsClEKY8r+YiAhJWJaO7eiEt9106XVDKdmFRRMp1AG3hd8+o8RR+Ba4BIiVSJSFWzXCszai9F9a0lUiWGzEFlxNk6V0HHd58DbFkhCQ/vWudZqxEW0nKCWno4q95D5LufkVStbm8qnRokKidNIbVOtQrWXxPkDJkGDcwQuQsT6hkcuRpkAayHC3/h9oaeACKElZWrLT0FKC1DVTh8sKBqtfEqjjQFVRfUsJsb7YbMqhHYOinOS6f5RyYLRERsTatBa0vIWzh9mOsDpAFeqYsMaraCGC6revy8aF5ZwHd3EKsCUaxgl3tWiJQ81yMrugrfIJmhUWE1vzwJpzry4fERzkzw+YDJ41yVJrgz4iWWRUgeUF6GXn4kr9SGVBZT6TiAmZKzUg6w4k3HVkZaG9jUKckvD9PfL3AMiUyoKTpXjnJbqJM6CS7xlQBmk2ge9y3wMUalEqByQgBN0pepTlHUJF9cxreE0uBWctUWUwHtgXioDzjmstblJb/ofa49lKUuHuJbf/CTAhIYKFokT6qpMEvSA68SpkKRU8T5DUyOhgm2MkFh/yOumUE6aoGJE130BHHGgQhBf1EimWQZSL+4cQaHDKk1VxiowrklsehnqOhMX9PpqY8piGCe0o8TK4HSVIBnHWovVZSSJWFTVLDQt6qqKNV0+7QgFVBFTY7xrNePVJTjVwqqA8WAZY5UlOFVDoynLWBo4lxaCtpl/ce6RbpWAz4W3aagfojASE4siMR1UXAstEGBxYTexqeBMiVh3YE0vAU1IbS7OhTRLPQQqRpkSRiICG6NUyYcV4NNbbZqoJAJKLATdjCw6D4IFPu0L660yH5BsjhaHw4rDifXR/lJCYZCkSSwatEEUONvEEYAu+dBLEZxUsKaEbYyhdAWCXko2IRCHuACxioPVtUS1FamdKwvqjLEIUc9imiotUkb70S+p2wC0c3N23uJIC6aBUxrtHMaCVV3Ycjc2aRHaFiUbIYlFxDFRPYFm91pwDq002CbaRiSE3oWI9cWgAOcmS44XTDIvUwvbD/zMj+ac841ynDvmvjWtHVhviv3EuSez/adbWdDZRaPVJJYKYQQuVESVDoQGoLDUIAzQpQ7cWB1lDaWoTmwMiapjXYjKqgtmN4WUuXSZTQOvETSm1kMr7CbRjsCOUV52Cgt7TgTdgSYCoxEVIa5FS6qUgi5C16QJqKCCSlqcu245Z115EeGrgin3+dsBFpwPGOw6/VMgY6AhloDw9Kvpv+hzSFiDZpNS9BbETSIHRlx6h52bOPFFagOXIC4ikhLgUMogNqKuqpSCGr1Sp0daLO+uYE0HCQHalLBxBStdlJNRAg0kiohuyiecTjw+iO7oIdQxJZv44C0RxHkfeSIKRVq90MaYvpUs/+z/Q7mrJxvd1Fr5cxCbprb547fki+Ako8TO13uwkKYOBjilKYlDaOHbCgeEzWF/0JsyOolInEOkihCw9BP/lFL3Ch9nrBTKRSTOEpsq5VPOIHn214jRiAi+VJZX9PxsdV72czTeZTL+QhMpjbIWSRyJqRLrMiXj0K1xVFIG8bLtPOlSX61RjxPHjpZroCWmqTSBS3xmgfjUYq80zd11fbyYOxfHY0xW+hbAWp/jb6095ooAQGx9z/NKPMqa5hZ61ThS60WbNOpXDE5CVOdyJqQHVJkEcKUaUuslMp1M6H7ioIeGVGhKB6gSgp77aYVA1ltdhyUwJVxQhtSPX+5d7PPerQA1WuWlNEqLcVLy5j/r/M3MaJxNKAeGnt5uwnIZZYL0BhDilCbWiqBzMaXqSnA1nDhstRvpWAqiaOgKg/QSO0VIQoSQtJeInpNMdRU4a3HKkKgyVsoYV6cniFia7KaSDKNpoVxMElYRXNpe11fCs6rKsFmEW3wyB4LlJKV+ArG+Ap+YNBhxWny785YIVEC1b0naTte7YWxuYp+LCILvEOiD/RICqWMPvpFGsSufSWHjfJcV0r4cWepcVE+DBAM/r8tLaaoaTpWoLliMzrpopj9tVQcjsgDXvQqnq1OyCebyDH07nGhcVuYrrZyY6AqRC3HOpkpXmUQFmK5+dEc/SODdf3ELsUm7w2ryhWWuzrnjy7y0DMBk1O/4+DgAlUoFrXVuITh2CE6FCIqg8Ray+QkWq6VEsgixCUr79qaxE8KFJ9G/wYKq+sh5VUaZTppBi3Dt+Yy/+VtiB73rzgEJ0qA6afNYzkEEH+CT1nO3KsAFVayU/GFlI4gtzhisdNB3xhUkySDRnn3ev5o1QdIBLolROLRAZJM0jMLfAGKxtICSCxEX+GY7koBO/AXVQbjyPFoXWVh4KooWIfimPnkS+dxi0mhs8wmiRSFiSFSNYOGJaK0oqYT1lWGCxkFEIox21IMyKjqAQ7DK4FSIqvTRcfYVBEs3UDrTYqrLqKiEcXF+45bJQjFZ7IAVEKdRKiC/lTnxUTSKOSnXDMkUcRFEW1wyQmvbSwSd54D4KpckcRrJT/69TnyaoLTGMYFPKa6c9glU/Q32bf4ZNV327r+0iLdzvjRZ2L2M3nOugo4FWKnkwYNMvvTc1a2mkaVQZpZDxM/l6sKVTJQW4J0uFieKyEe+erXBCSaJkKiBs9HU1yRzqczdOXc8mbfKgIiwZ88e/uIv/gKlFGeccQaf//znMcaQJIk3vx2Dgh0+YEvjlCGUhEWNVzjQAswJBEYjTtLbF4R9q1nYsRwIUUaIdJlSqRtbgcpF1zHy4D7CQFE9+TxiCXw706woyTHyD7ZbS9pdJ8eV9OVFpzdQUyLGYBGMaEQs1mcW07H+o7RauxjeczfiYmIVkDhBtPY5x85hncUqryQo520DDp9v7DdoQazC6QBLgj+aQkqrzkGvPA3tApwd9ylzhIA5pjLI3FSZ0nk85TsZV542g0qj0mKpohatwVX7aFnokzGMbSA2xpkqLqgSR3vwymwAaHRlAX2broSSYXHPKqLXXqVCk0ASnwOPIM6hxPkMmqyVjAhehpa8gQ9pBz+ObecM51y+ftvX8PHAR5X49StKMCVBR+M+sC3t3yBJjFOS++99vYy0nXASYUxInEDp1EuJ3tpO/PSv0vRBk6cUgp+3qtJP96YraRzY603eMrXaafas0i7T4zBvnXP5xel4YgGV1SHxZhbMglU0OpZRlXF0UkfwDcj8fPOyMAjKxt5lxWQmjYU8S0PSdfBenmAuFWw6GualMpBtEg899BDnnXcel1xyCf/hP/wHrrzySrq6uoiiiLGxMd566y1arRatVuuI3QdZ7IG1ljiKiSLfdyxIYhbqMYwCsY4kinFRROwEZUMSV/EfJw2UKRGEnTjVInE9ONOJlYTYloljR2IT4iT1Eh6lMSMbb7PZpNVq0Wg08mdud6kca3y3scS3HW02fW5/FNNsNLAaJGmgRRFZRySCSsq0bAc2iSCq03TknQZdq0XUrKObDbAJcRSTSIRxEbGOSSQkiSNcDC5uMaF70XRjIoNxDktMpMTf5gBrDbjEl9s9qmdsmwtxzMTEBFr7bel4yjYNcyPBglM0VYyLW6hmiyYBge4mtmVAkOYwpltoRTBolhBIF7HqRtC0EkcSx7RaFqGbOIp8X0SrqNGgpBzElmYrInAxVgyx6PwW5q0FjsntejLkLZly5M3gCds26jiOaTQaaK1zZeDYWvmmvzlEzmdjmNjXpDBKSOKIJE6IrSUQRxK1aDYbOKd87AYJQWJxzpIQoCJfOyRxFUhibLNOvRWjncNqRaQduBY4g7hemnbMtyqPWrhmE1SAdUluGhDnEBJ88aeZSzdXLkTyfbB9X8jm8PHAYX0Qr1X4qIimr0bYqjAeLKaj9QIlWtAaxTYmEBESa5FmQkuqSDSGbk4Q1RskWJ+kqBXaxYgDq3TbLDz8s0dRRJIk+cdzqU7DTJiXygD4m+/g4CDnnXcenZ2dGGOIogitNbt27eLee+9leHiY4eFhduzYcUSvnSkb2QEwNjTEm9EE3ZHQYQw9NKg3RjAOGqPjDL2+g8QkPqs9KRMwQZhM0EwSSs2EOHEc2DdOEgtxXGdi9yATukKsm1Qif9NKjsIP1j7eVqvF8PAwQRBMsQwcN+047QUgtkltfJBWq8nEgQMMm91EUqbD1UlwtKSEEyFwdTqGxtDENN7aQzNRSJwQj45SjwOGd7zOggODqPFxDu5+g7oeJ6RFJCGRCqglY2jXwuoarLyQJKgwsPstyklEOWlgVYy2hoYu0VAhJYtvCjPD++v0uXDw4EHK5XL+uezzx4vsQHZoWiqgFI1RbuwEFK26pTl4gJIdZ9XqlcQjL1CvLMKeciaqswuz4GTGDwxRAva/+QZRayeJU1jVAFWmc+8b1KRJKAkTI6O8+fpuqq6BFUWkfFVMhU3jWg4nv6Oza0+/+Q8ODtJoNBgeHsZam1v5jgc+U6dFyxliKVFx4yzUXbhEEUUJB9/cg2o1sa0WI0MHGd+1A1ElJGkRKUP/+ASBKIbGmiQ7dxCrEsHQXsJ4jKH9uxmP3sCIEIkQK0fFjhFJDWWBiXF6ogkG33yDptuJxRBb0vijrKeGJSuqfSyo1+s0m02A4y5bACTGikLFZZTERLpBaEFiTWXFadhXttEcn2Bi35sMJq/5YlgqIIgn6DnpIkafewg3OszQG7vBWhSWSMoYF6GcJZHUN/gOOOdoNBp+OB9yRQDmsTKglGLBggW88cYbrFu3jiRJCIKAJElYvnw5/+Jf/Av27NnDD3/4Q9auXXvEN4z2A8Bub3HC8iW0nl/MxIEatXiC7o4SzUZI19Jl9G1YDaqJo4R1BklGGXouJE5qqP6FBPUJelevY+jVTqLY0bd+A6iFJJJgkrRf+lHO1Wy8jUaDnTt3snbtWuD4LwLrwNoEIwn2rRZvlkp0LV3EwhNPJJGQwDXxLYW9z1nRohm/yH7bpLJyBcMvPUdJaYIFvVTHyixau5qkvoBoqJMFa9cSBV2E4ogISICyawB16tJNuHoNOhpnaakTxBC6GCsJ4gxN0YCl7FwaqDVzpswFaznxxBPzW9Vx32Tc5F+RQJg0saOwOyzTt2o11aVLaIQt1MplyAsDdK85i8qqT/vWxDbCPXYv9lXNshOWI4tW4bRGS0RMgA7eZEhiyoFm4QkrWbhqDSXXAsH31gBfkKgtjGtyNJnv9tjc3J1zlMtlurq66O7ufh9ucg4YwxLSokRgI9TBk2m+/htMrZP+DesY31JFvWnpW7KExWvWggSIS2iJwMF+6mi6+pfSs3Y1sVRh3zCjKqFz0QLUqtUICqt86Z3AjdG0Nb/Wx2rYhzWlVSuQ5etADNb53hGQKYCTRvGjespUjqOjowwODrJq1Sr/Hsf9cExLtid+HsW6iUkSrKuiam8wsfdBJNHUlp9A5/K1WAuxLmFtQnmp5sDLL9DX003n6nS8zmK1z/gQR56W+XY454jjmGq1Oi8UAZinykB2m7jkkkv4+te/zm9+8xs2bdpER0cHSimSJEEphTGGOI7zG9yRvH57TXDlHMoY6omiIiWUq4MSIsqEyqRaPCRpHXyNwUiVhgtIqp3ElEBbxFhUEiEu9XeJxunYB8nJzDfV6Rtn+9jbb7DHB+cXpmviTMhb4TI6pUI5nkAFBotCOe1vmJLgSHBRTNmGiArRtRJ2MIZyBbN3N9FT38Hsehxf592XznWSVmFw+Kh3yogonA4RIPBZ7z5eQXxlPB/+1daAZ4bPP30utMuz3Qx7PHDTYqUMvkiOC7sYW3IuCxesxRlfsrkcHyRx4Ew/SIlEaUQnNEsLGOndRH/QiyFOuxgqlBNcECLK0R82CDr6fJS2TG4pWtJMjzTQdXJggj+sUo5CtpMvMSnb6TI/XjgXImiC7P1NJy5J0rnqkCTxsSraf59zEU4UBkcUlLEqxKRBlEocrrqYA0s/TqW8COMsSk9mEjgpo5V4d0sQsH/ZJSwoLyVMYzVUWn44n655CsPRuQk+mH3Bx1z4AkyA+ObhYL07NKjgInBRHRfUAI3WPnbIYCHoIAqqvlCZaES8PLLky7Qz2buKJnM3zRfmpTIAfqIvW7aMP//zP8c5R61Wy4NijMkKpsgx8ekqQLTC6pBSFPngKaVJKOOMLyji0oAhBWAV2pVQKsSGZWIVQmBR1Q5azZEpGbJWXNr58Nj5Rqcv8uO5IAT8RuZA1fpYfvEXqfSvzO+SVoUoJ75XgBZfnFQrxDqQki8lDDgJYP8AjZ8P0Nl8E33KlTiVRm6T3pEE/DFvKGcDSBUCnT6jSb/PgA8Cm36pPdrnPd5+7ClvBsnkfupTs5xFhd2su/L/IiiVcRMHaeoaQTzqEzp0J6W4iQsqvkxR5xLWf/b/JejqBeXS+AmDEojDMmhFJyNgqmgiHKX8vcEiuVVFpoyrPWXuWJKt1/fFxyuldG75EzgxVYgjQi1eGRCwJL7XgNOgWlgElQiJLpGIIcT6OSoO1bmMFb/zZwShpmUTAh2kwZZgXYAWh9gITMDCT/8xqtrnDzs/GCb/OsaTNmX6Xnh85at93xDxJn2NAu2biIkOsIkjpAESotDgFKkNASvWpxoDViS1KfoaGACWAPUuQ59PSkDGvFUGsgOvq6vrkIJDx3wjSXOtlTZpcxx8RHHW7rXNf5WtZYVFCYjRYBL/9dIJNDU+ultFCAbtlFch5ujclTQCHSqI1vStP89nwqkA5XxGQSxgVGY/KWElIQrG04+6EBciqoxOBKIWYg1KdaKs8cVypqhP0w+ldxDdh2BDyB8h7dKmTYBLhKDcnQaeps1w0gZEhCVvNUEQ0bRUCVPtBeUbFWXSytaP1to3KZoiqywWwLV9fMjIjs8Dv29I/pT5/7X2h71OSzdLdmPX0w7p1LWHSvs1TAZVBuUqyrUwJj34fDoG+duIAgnQpc45X7Tp7cknLZlRSdLIf+scKiyl7aFT05dM/1mN0ZrJTJpsob/bgp/fzFtloL0CYebPzQoPHeubmxPv7ZYg9JuFKH9byPuRexMYeWS1v4GJVrggBONN6bZnI8ou8LdgiVBOI/bY317fT/IUHxGcLqWpmKklz4ESnxToBMR6y0lLIuJgHJyjQoVI0opicYvQxYgVYlciQDBZOttcFdBR4SYPrGw3RSEq8MWaBK8IKIV1DqsMBKX88LIIsSoRSwnBIOIVz8waLXhTqlVqXkr3EJRXBiRTBki7RObzz8/TXO4iPu04tV7hxCsHLjNtZyqCx5Fm36gQK96O+GGVuzvkI+/isg5cUPEFh9yh3wkKcQqjTRpImalrk2qBvJOOOo+Zl8rAO6UdHZd0GfEuABOWfdvRNMfdZfnGbZsr4LvxKYVTIS7ooCEhiKb75Ivpss3UpRClB+l0zXiuYUElgCHJdHlxKOcwykcBGxHEKa/4OItTlpYSnIUQqLsWTjuUtNCuQWI0raBCRQG2hajyHJfR0WCzuyiT16z0kBFvldHaYBNwOsxjCDI7VYTG6QC0wTqvtnrPq4+nUCJYSf2waSXJeYOb9k9ROFFp5UBJFYFMNqSy9/J3yjfUyi0DklkLHFPaFrfZHrLS444PwbJ/B3KxTrnIe4XAioAOUKbkQ1PTdEpLpjwpEEOgDSSt3Bk1ZX99X55i7jEvyxFn5s3pvb6PV99v35xEEZYraaU2v8E60YgK0iArmIz+8VXfIlXBmi7qagFICRtUkVI3SgRxoa9rLu3m2DmIgBOLk8Q/S+prVcqBJN4CkkYW+wMoJqbCCEtITDc6hEg5H+VeUjjXoimKhq6SIIgcx/SnOYC/PaY3UyE1lQq0mfaVMjinSFSQFsSZbOLiN9dUncgOs+xrgldaHcd8zcwNsjkJIP6AR6GDENJwNZe7AcmVAQGvXEFbVLuaVBbSbdmv7MxlQ24B9PvJ1N/FhxnJLQCpAqsMQana5vxzqYIkqUc2wGiD2BbiLIdzV80PyR0Z81IZeL/JtoygXPVmRFEQlFJ/7bRcYElvXqUaLV3FVBZSW3o2TteIjGAVYBOEwL+uwncvnKP4zc53XdTOETiLcTY1bxv8XdQXdHEqwukWlZ51dK67BlM7gaSsMbU+glIPkTW+AEu5j2DBGhIpMdd7Nxwdcsif7Fbpt0gHSqOMQStD5+Kl3sTNZCMXRYJ2Ft/nLXNlZVkQqs26Nod9VTNFsgCglKwKYx4zkMXzSDoNhfxoUiq1BGSHepvs0u9PRPIMIx/y4ea03n8ktEVQTX4iP9M1JqxMWduZ68q7ZgJMYNKAQR9vddgr0zyR5XtlXroJ3m/yNVwup0Fwgpgg9c1mbUhl0j8oQiIlmq5MddFqVvadidNVmoCohDD2r+GUYMXO0d5kHl8rzbcp9f48S1alzpsBA8ASAYHyxVT0glNYc+mJUDXUyxXMgpXorhOoU0O5mMq6TVROv4i6DQhF5tsRNUn7ZieTH7rsY+dv9ijtC7P09eG0aZOXQ7vYF11y2TydtBQgyse/tKWAHfrGH2LctH8oQ4wh0KV0XWfR95lNX5EVYBKl/KVguiKQ2Qid5GedV8p8M+N095gvEs6MAdPWsPJNzaZ9NpMN4lMNJ6teTn593imsR0BhGXgfcKR9zwONFWipGknQTRIsINadvtEGgvL9+UBgpOMkGpW1CGWk3AVoSoBOA8BE/J1ZmL6ZzC0yo+jkka3yZ1KAOB8voPHpg5aK79hY7fGboi7jjIaghtVVJLFQWQ7lJZg0UGu+Mn1WtPtM81njFNYESDxObEuI0yCJjwfIrQmZr/vQG6xVgQ88JFUKJm0O84RJa4nrOpF9yz9Fa+FpgPKBw2JQIunNXmNwYFtgaiS6CqqEc1n/jwSIyOI8FJldbHJtZG6GD/eszqxPXhOwgBWNiE4bFCmk1AkubpvI3nrlg7UDooWnMBQsAmdzXTXN0cqtM/Nnjr43CsvA+0AiClyECzSxKoG1BLV++i86Hdu3Mo2Wl9Q6kICC3tM+RUdzAoIORGuUMpQEcCbfCfTc1QGmoMBfnqZFRfnYIL9sDdlyV76YjWqBS3BSSpu7+VgMpSxS6iYxVe9IkXkW1NbOuwaZSaoMhMjEBE7VUhUsBjGI8/J24o8k/yPtr5h2mXSmzcLl0v/msr3qyBHnCPvWctIN/x/KGLAtnBbAoFwWAyC+345roYIOMBUfo5SeSpY0iwjr6w6kvw3/e8wiE6YGw30Y8c+WKZW+v4JzCoX1cQCicKUuslM+tZMCadaAKdN96iXUd+/AJYkv2JamerZbCT7MMpwJhTJwnHGAVQolQlLqIKKDkhr0ZYeXnoky3b6CWb7M/X2g3NFLuaMn9S+ayQCtqX8x16e0vM0H058qM/F5KVn/Lye0KNPSHRCUcSK+gqAO/CZLFvlekHGIXMUHp032R3g7e8LhX0yUwiWSm8UPZ/L+0CIC6NTf4uuT6LBK+2z1EskOrdRfqEuYsEYQaB/gmv58Il6pCohySR5Ogh9yqb4N7W2vFFZ0fjnwdWEAHE58XrIEFSJnQIdkxdymJhlS7AzTKJSB9wHBIVawlaVgKsRxSFjtIwkWIRh/W5A2X6BoX5DIubYFMF/JlCQ3KZ/MbI2GjkU0RvaDBIhSJKIRYyArIJXaWwoOT5Yh4GbQLCkvgy2pMpClz7V9x4eZ/FgR0lw/4/9yzpunxXjXX/ptFl8RUusQHXagg8wykIAE3hyOwjidWwQKJtd9XtbaaVSt2xfJcjIZt9LuCFMBzlSwbY6W3PXgstf6gB5pllIoA8cZAQIbgzIE3evpWNiH6T4Js+RkYnx6oxKXT3dS/2JWnGT+GVynMxmAlS91wQe0qZDOE0+j4QAV4gQiFWDCMgq/ITtRhUnwnfDJ7pAk0w7y94Z1bXEF81bxmgwQzPQCZ42PcRGTHla++JUoX0tDBTUa5QXUVBkjgo8X8G2dcub1xM1k1iaCbN3rkHDBIlSplq7vKdcEwMdqJGl9FiWZi6VwErwThTLwPqDTlpkqXEBU60etuAhXW+Ebx+AOnZoy6TSYNI/NR4S0xdjkZ/LYAgNiCbqWEVWHcNr7FiMdUAlKCDY1Ixa8Iy4tcmPtkdcKyIrjuLczan/YZ21bqp+Qy8+79gSrQhJdwphg8tuyGg66RL22nEawkFCFYFtohIQs9mI+827rXsCUUrdK5qaBzILofNQFCZIqC3bKfppJd37L+FAKZeB9ICudqZUm3PAJZNHpNFWJko1SF4FqU1ZTK4GTqRrxvJ26hy5cl1YdwykSXWNc9YJp4ZQiFoMzxm8FovPq5AVvQ5rTbq3NmzUd0Y8r8Re4KXM4v58dw4HONlxbQRsfv5JHCohfxTEBttqDVDu9nNOf898W0HfGJ4iqK4mcEJCgETThB/M4s453Wvfa1xNRBpxKg6/t5HdPmcaTJd4zC5aV49Uma25TKAPvAzaooKxFVJPyaVfjdJnYfwVsAlLOTbReEchStFLc9EYw85EsGUjyP1YgEk1DhTgDKEWilK+ih8Vh53fNofdCWjffWZsWwTmSnxUma/DrvLX2NC32Q0y2TjMXSeaS8s9txZCEVVxYmZy5Lu0wKoq4YzkTpouagiCKEWXRYua1LfBQDl33Dgc6wKowVRAmmR6xolz6GqmS6uMyDm/Hmu98uNNVZwliY39zUiFO94CqEAqIMv7PVB/B2/wpmC4HwaGJ0SoGKmn1wjou6MDaEOcE6z7Mt9Ojw4Gvkic1wmYDqwOczr6m3j0XW3wrbh820K54OeZwUcwjYLISQK4QZJdT5wiSceqqC0xnGtGedh8l9WmrLpRotAN0GSjhGxJn5Yvf58eZtRwqCFddznD3RpAyKonxMtOIA+XSvhmZ5aatxHP2GytEeyiFZeB9QLvY37rEkEXHGvD+rkPUMcm12IJ2ZMq/sruCsk2Ma+J0H00XUulbhO5biXUBjri4Zb0bSoCQoNUgSQ92aT/M30l04tNmXVpYTyS9KTs1DwxZb7dOJ/uMhPE4LTGIDlMPoPeD5+U0JCR0EAhAkMcKzQPhHQGHX/fSewIbrvgyYUef99I48SWeXRox4JLUDjD5Gu21Gqa+cgEUysAHRh4RcNgZWUzTdyOTkBKFcgLOMBosgSVdVDqXgoj/vBRGwbfH4ZtBJWDjtOyrS9O1OKT0/qGIT4Gdt6J95wfXLsa4FrgoTRWcrMUgWcxBViHzODRI+zAy6YEyVBYsAWewEuTugrYQznf++YJDKJSBgrmNA2KHuIDSynNpdYY43YlYn+jlnCXvGlcwDTfZMdLFSJbimvaJePf4P/EtucWlTXmEvGNMAZBWF3Qx3lPtHQUIYKP8cwVHjlMhLvY9XrKsoUKSR0ehDBTMbZTx3fN0yJILr4FQiAjTiS3o+dyo6F1JAwCV9s2KyA7y9tTWd/px8UWetID1ld8mAweyQFiZt9exyHTSVC4tIZDgFNjUEuDzXGyhN80EwQdVm1LqCJDDxF0VHCmFMlUwZ/Eeap3WztdIbTG2sgRE5TXHCv/rOyAABqREZAWndGpufa8yEywKlMk/9n8VRxyiiLtPZEgvBt0Bafb7ZGmCQkYzJ13XqWtF5NBC2PO5QdlMKSwDBXMYIRFFIr7bY6JKtBACyAuRZFnGhUpwKD7n2lDpXkjDVHES4FCIeo9dB0Vwyvjyz0pP2YDbc7vnJ4qu0z6OOmECdCc+sDIBMb4Fj6hD0uIKjoQsyLW9+0jWo+AQ1aDgPVAoAwVzGgskImlqm4+GV9b7vq34dqVFxMDb48QQdi+iFVR9RbfUQTDZZuCd1ALxVpjcolDcdydRBIs20L0oJBaDoZX2IHCpglocWEeDVwSS6Z8lzYV5/wf0IaCwpRTMaYxzGGdxypsLQ5dmy+nMfFhkErwd3sgf40r9NMURGo1yCaAQl9UheAfZicYRUjKCjhOImiS0mECQJM5qac5fVAXRQVobX4OEmNRyJaTFmgqOgum1WAoF62goZmPBnEbjez845duUZoGDpL7v+do6573hUERYXcMqXy7bd8pUpO7td0YMNugixpeFxTkSYlo4sHH6PfNU+lknR1LlVDSILzCWz9FiZs4cwct3yh//hUKqM6NQBgrmLG+36CUPLiq223dHQGlEBWkgoPL9HN6L4FRAvdTPmO7BOQPK33lVEbjpyQLcaJuTxWF1jJhuFSiUq6OliBkoKJjXpOZV5YMAnUya9t91a5WAYNF6VFL3bZCdz+LIqmsWQYQFBXOHQhkoKJin5EValU/PVDpMexK01Qp4J2eBBCw981JQLZyaNH77f5l3/tmCgoJZRaEMFBTMV9ICQ6BJHKkykEZjC2213d8G0UipG2ilxYZc6mRIvOuhsAgUFMwZCmWgoGCe4tO0HSiFxaCDCnZKBsA7Wwb8V0tk2QdegYiRtIPce3Y3FBQUfOAUAYQFBfMZ6/sLWFPGVattqYTv2sAYRLAiWF/mqS2Ey2KLFgUFBXOKQhkoKJi3CFhItLCn9zRsrQ/jIEgrDrl3cxPgNxBFVg9WgAoQ5r35CrtAQcHcoFAGCgrmKT7NLcB0drH+kzegqwt8+2IrqV3g3a0DQtZ6N+tLEKRuAuZzj6KCgjlHETNQUDBP8ce8QoIOehatAlfKv/ZeDvFDG8VJ/u9CCSgomFsUykBBwTzGaUFU2bd7EQPOW/t9PGBR3rWgYL5QKAMFBfMWwSpfJx8p45ygckXAlyUuVIGCgvlBoQwUFMxXZLK8kLj28KGsaqBK6wcUFBR82CmUgYKCeYxylvakQMH6/rDO5wkUboKCgvlBkU1wGJwrMqQLPvz4WoMxgkVc1iPekmcQHGYZFGvj+FHIdvYwH38XhWXgMFjr86udc4jIUU8M59yUP8fiNY8Xkhadsdbm45ytY4XJReucI0kStNYf8IjemXZ5fvBzIesk0B7+ryfLFItPL8xkC6C1nrXzoV2uH7xs351sjNZarLUYY2b1eGFyX4DZfWAei32hfQ+cDxSWgcOglDrqDaX9Z7IJaa2dtRNr+uLJ/pY50oo2G3OmyM0mph9S2VyYHUx3BUwtFKSUmtVzt122MDkPZrsSC1621topY55tvN2+MFfIxnqkso2iKFfU5guFZeAwWGtRSuUbYRzHKHVkelO7IpFtpNnEbNeuZwvZeOM4zsecLf7ZNtZ2st9P+2E12zbV6TdA5xxxHCMiRzyv3k+cc7RaLQDiOEZrTRzHH/CoptK+zjKlpV0xnM1zt9Vq5TLN9prZRibfTLZzZV+IoogkSfILzZFeFLI1Cszq5zyWFMrAYcgsAyLCwMAA/+7f/bsjfo32TWr79u2cdNJJ+U1gNpqesvE2m012797NunXrZu1tpR1rLdu3b+fkk0+elXKFqXNh27ZtbNy4MVcOZuuYM7Zv386aNWswZnZuFe2H0o4dO+jv76ejo2NOyHbv3r1orenv75+1Y83kOzo6yvDwMCtXrpy1Snc7rVaL119/nfXr189Its45tNaMjIzMSiXteCBuNv9GPyDaRRJF0Yz8pO0a9X/8j/+RP/3TPyUMQ4BZeRvMxrt3716+973v8Ud/9Ee5UjQbx5vRbDb5T//pP/Fv/+2/za05s432ufDv//2/58///M9zH+ZsHG+Gc47//J//M3/4h39IZ2fnrIzHaF+X3/3ud7nwwgtZu3YtIpL/ma088MADhGHIJZdcglJq1o01k62I8MILL/Dkk0/yxS9+cU7sCwcOHODWW2/lT/7kT2Ys28xakynCs+33c6yZner+B0z7Lz07wI+E9g1KRFi4cCEigtZ61m1S04PZSqUSvb29UxbAbBrvdJIkYcmSJSil0FrPuk11+lzIboGzcS5Mx1rL4sWLUUphjMk3/9ky3ulzd8GCBRhjMMbMetk65+ju7s5lO9vGO1221WqVzs5OgiCYogjMlvFOJwgCFi5cmF8QjkYhmC8UloHjwHSRHjhwgJ6enlyjhtkzyaaPNY5jxsbG6O7uzr8+2w7Ydqy1HDx4kAULFuSxHrNprNMDSQ8cOEBvb+8Ul9FsmQvTcc5x8OBBuru7c5nOxgMrY3h4mEqlQhiGuYtrNlozwI99YmICEaFSqcy6uTtdts1mk2azSWdnZ/712TTe6cRxzOjoKD09PbNOtrOVQhl4D8zURdAeOAZM2VCPhCP5/plmPrS/R5IkUw6omSyi4z3mjCyoKbttz4TjOdZjPReO9Gfe63jfzq8aRVFudZkp73W8M50H04N1j+bW+n7M22ysmWyP5qA6nrJ9p31htso2o93P/37sCx8GCjfBeyDbZPbt28eWLVsol8ucc845lMtlduzYwYsvvsiGDRs44YQT2LdvH1u3bmXt2rWceOKJjIyM8OyzzxJFEeeccw5dXV35rcVayzPPPMPIyAjnnHMOtVqNF198kb179/KRj3yEzs7O/OZ4JBMzWwhbt25l9+7drFy5kvXr16OUYvPmzQwPD7Np0yZqtRrbt29n165dfOxjH6NSqbBr1y62b99Ob28vZ555Zv7ezjnGx8d54oknWLBgAWeeeSY7duzg+eefxzlHT08PF154YW7+PhLZZhG/L7/8Mq+88gr9/f2ceeaZOOcYGBhg165dnHPOOfT29vL6668zMDDApk2b6Onp4eDBg2zevJkwDPNnAr+QG40Gv/3tb9Fas2nTJkSEp556imazybnnnkupVDriW3mWDbBnzx5eeOEFOjo6OOussyiVSrz66qsMDAywceNGli1bxp49e3jxxRfZuHEjy5cvZ2RkhCeffBJrLWeffTZdXV15brm1ls2bNzMxMcF5551HkiT8+te/ptVqYYzhggsuoKen54hlmylK+/fv5/nnn0drzdlnn02tVmPv3r08//zzrF69mtWrVzM8PMzTTz/N0qVL84BXEWHbtm2ICBs2bAC8VSuOY1544QX279/PWWedRW9vL9u3b+f111/nIx/5SG4JO9INNY5jGo0GmzdvptVqcfbZZ9Pb28vw8DBPPvkk/f39nHLKKdTrdZ555hmq1SqbNm3K19Tu3bvZv38/Z555Zh7rY63ltdde4+WXX+b0009n0aJFPP744wwODiIinHLKKaxZswY48gPLOUej0eCZZ55hdHSUU045heXLlzM6OsrmzZupVqv5XH7mmWeIooiPfvSjOOf47W9/y969e6lWq3z0ox+lWq3mFqM9e/awZcsW1qxZw/r169m3bx9PP/00q1ev5sQTT8xdC0dClgXwzDPPsH//ftavX8+qVauw1vKb3/yGKIrYtGkTQRCwdetW3nrrLS699FKMMTz//PO8/vrrhGHIueeeS29vby6DoaEhnnzySVasWMEpp5zCiy++yMDAAACLFi3ivPPOm5Hym+1j27ZtY8eOHSxbtoxTTz2VOI7ZunUrBw4cYNOmTXR0dDAwMMDrr7/OBRdckO8BL7zwArt372bDhg2sXr06VzDGxsZ48skn6ezs5Oyzz6bVarF582aMMZx99tkEQTBrrXXHk/n3xEfBa6+9RqPR4Omnn+auu+5i//79fP3rX2d0dJSvf/3rHDhwgL179/Lwww/z8MMPY63ljTfeYM+ePezZs4e//Mu/nJKz/cgjj3Dvvffy8ssv861vfYtWq8XAwADf+c532Lt371HdFqy1vPjii4gIt9xyCy+//HL+fjt37uSWW24hiiJeeeUVbr/9doaHh4miiG3bttFsNvn7v/97fvnLX+YbXrPZ5H/+z//J7t27ufvuu/n1r39NGIb09fUxODjIj370o3yzOVKyhff888+TJAk/+tGPeOyxx3j55Ze55ZZb2L9/P1/72teYmJjglVde4fvf/z7btm0DvGnYWsvLL7/MrbfeOiVN63vf+x5PPfUUDz/8MPfddx+NRoOBgQG+/e1v02g0ZixbgJdffpkoinj00Ue57777eOONN/gf/+N/MDo6yn//7/+d0dFR9uzZw09/+tN8LjSbTer1OgcOHOC//Jf/ksdlWGv5+c9/zk9/+lO2bdvGrbfemvvAq9Uq3/3ud5mYmJhRznM23l27dnHgwAEGBgby1/vqV7/K/v37+eY3v8nOnTvZs2cPv/3tb/nxj39MkiREUcTOnTv5xje+wd13302z2QTID5Q777wzf+4sevtv//ZvefXVV2e8mWaKy969ezlw4ABf+9rXqNfrfOMb32D37t3cdddd+cG7bds2/uZv/iZfU2NjY3zrW9/i5ptvJoqifJ1lYxwZGeG//bf/xujoKJ2dnfT29vKTn/yE1157bcZpiCLC+Pg427dvZ2JiIp+nd955J88++yw/+9nPePDBBxkZGWHr1q3cfPPNecra7bffDkBPT08uV/BzOhvnX/7lX7J79+58X/nZz352VDfdVqvF9u3bcc7xF3/xF+zbt4+/+7u/46GHHmLLli387//9v4miiIGBAW699Vbq9ToAd999d+7iyhT+zNXxta99jaGhIb7zne/w/PPPU6lU6Ovr4+WXX+bnP//5jHP1szn07LPP4pzj9ttv58UXX+Spp57irrvuYseOHXzzm9+kXq/zyiuvcNttt+X75uOPP84999yTB+5mqbxRFHHzzTfz6quv8pOf/IRf/epXjI+Ps2XLFm677bZZnSFxvCmUgfdAtkmcf/75fPrTn+ass85iZGSEN998k/7+fq655hrWr1/PCy+8wOmnn87FF1+cL4CNGzfyuc99jvPOO4/R0VGstflG9cQTT/CZz3yGG2+8kZ07d+Kc47Of/Swnnnhifquayaaa/eznPvc5Lr30Uvr7+6nX6zz99NN85jOf4Qtf+AK7d++m2Wzy6U9/mrVr12KtJQgCLr/8cq688kpWr16dp9Vkh9iuXbu4/vrrufrqq9m8eTOLFy/m/PPPZ2RkhCuvvBJjzIwWflYn4JprruHyyy9n1apVjI6OsnXrVi688EI+97nP0Wq12Lt3L5deeilnnHFGbl498cQT6evrY3h4mI6ODpRStFotrLW88MILXH/99dxwww1s3ryZSqXCddddN+WGfaSLP/u5iy++mE996lOceuqpjIyMsGvXLlatWsW1117L8uXLGRgY4JxzzuHSSy/Nb6gLFy5k9erVDA0N5QdAs9nEOccTTzzB7/7u7/J7v/d7vPTSS7k1o1arcdppp7F48eIZjddaSxzHnHXWWVx77bWce+65DA0NceDAAcIw5LrrruOss87i6aefZsOGDVx22WV50Gwcx9x77718+tOfzl0FURThnOPpp5/msssu47rrrmNkZISJiQkuv/xy1q1blz/vTBXDlStXct1113HhhRfSaDSYmJhg//79XH/99Vx55ZU8/vjjLFu2jM985jOEYZjfpu+++24uuOCCPN4lW2vPPfccZ5xxBtdeey21Wo3BwUFOPfVUTj31VESETZs2AcwohSyKIvr6+vjSl77ExRdfTBRFNJtNtm/fzj/6R/+Iz372szz22GP09PRwzTXX5HNPROjp6ckvDlEUEccxSZLkKZLXXHMNGzduZGBggNNOO42Pf/zjBEEAzMyMLiKEYciNN97IxRdfTLVaza0an//85/n85z/Pli1bMMbwO7/zOyxbtiw/9Ht7e9myZQs//elPaTabNBoNms0mBw4coF6vc/3113PJJZfw7LPPsmLFCs4//3wOHjzIFVdckR/IR0qmNN1www1cdtllLFy4kImJCZ5++mmuuuoqPv/5z7Nnzx7Gx8f55Cc/yYYNG/L3euCBBxgcHOTXv/41e/fuzedCo9Fg165dfO5zn+Oaa67hN7/5DQsWLOC6667LLQozle9cp3ATvAeyjc05x0svvcRPfvIT/vk//+fs3buXSqUC+KyD7FaaFebIAgYHBwe54447+L3f+z0OHDjAzTffzIYNG4jjGGNMHqGbFXbJFmB7as+R0F7k6L777qNWq7F+/XoeeOCBfMIbY3LzfFacIxvv5s2bGRgY4E/+5E945JFHeOSRR7jooovyTaxcLudWgKGhIQYGBvj93/99YGb+uex9rbU88sgj7N27lxtvvJG7776b/v5+tNZ5kFU2hkxJstbS2dlJT09Pfvu67777OPfcc4njmCAICIKAKIryqmLtHKls2+fCli1beOihh/ijP/ojtm/fTrVaxTl3yFzIxpskCV1dXXR2drJ792527NjBbbfdxqmnnpqXTDXGoLXOf+6BBx7g6quvnnG0efYzmZXqrrvu4itf+QqNRoNyuYwxhkqlMsUfnI3lwQcf5NVXXwVgYGCAV155hR//+Mf09fUxMTFBqVQiDMP8xjnT+dpOdmgMDQ3xv/7X/+Laa6/N5Zetlfa4i2zM27Zt45FHHuH888/nlVdeYfv27fyf//N/UErR39+fH6Llcjn31T/66KOcddZZuTtuJuPOflf1ep1vf/vbXHnllXkAY7lczuXT7mvPFNk//dM/xRjDX/3VX/Gb3/yGffv2sXv3bs444wyCIEBrTblcptFoHJNc92xfaLVafO9732PDhg0sXryYRqORuyiyOZvJO9uTvvKVryAi3H///dx///309fXx7LPP8tGPfjRX/iqVCgcOHEBE2LVrFyMjI5x++um5nI6U9n3hgQceIAgCTj31VP7hH/6BarWKMYZSqXTIzwCMjo7y8Y9/nNNPP51vfOMbRFHEI488woUXXohzDmMM1WqVZrOZWw3amW/xAlAoA+8Z5xyvvfYat9xyC1/+8pdZuHAhWmteffVVdu3axcDAQH4zGBsbY3x8nPHxceI45r/+1//KFVdcwYYNGyiVSvybf/NvsNbywx/+kGeeeSY/YKvVKsPDw9TrdYaGhhgfH6ejo2NGYxUR7rnnHl566SW+8pWvEAQBa9eu5fHHH88nerVaZWJigkajwcjICI1Gg61bt/L973+ff/Wv/hWVSoVLLrmECy+8kGazyf33389LL73E448/zoknnpj7PU8++WRqtdpRLaBMEXjggQf44z/+Y8rlMuvWrePBBx/klFNO4eDBg/T19eW3ktHRUVqtFiMjIyxYsICPfOQjfOc732HdunX863/9rxERNm/ezJYtWxgfH2fVqlVorXnrrbdoNBoMDQ3lloQjlS3Aiy++yB133MEf/MEf0NPTw4oVK7jvvvvYvXs3r776Kr/7u79LFEWMj4/nkdjj4+MEQcC5557Lww8/TG9vL3/2Z38G+MPvueeeY2hoiFqtRrlcZteuXQwNDbFx48aj6gmQJAl79+7lq1/9Kl/84hdZsWIF9Xqdffv2sWPHDrZs2cLVV1+NtZbR0dF8Dp9xxhlUq1Vee+01yuUyfX19ef2JX/ziFzz99NMsXLiQOI7p7u5mbGyMer3OwYMHiaJoxmm54+PjfPWrX+VjH/sYZ5xxBmEYYq1l27ZtPPPMM6xatQrnHCMjI4yPjzMyMkJ/fz9f/vKXefPNNzHG0NPTw7/8l/+SJEnYtm1b7r7Ys2cPCxcuZGxsjIcffpjf//3fP6qguMxy9vWvf53Vq1dz8cUXUy6X6e3tZfPmzQwODrJ8+XIAxsfHaTQauRVraGiISqVCvV6nXC5zww034Jxj7969/OxnP2Pnzp1s3bqV888/n2azycjISL63tN9ij0S2zjnuvPNOms0mN954I8YYVq5cyWOPPcbSpUvp6OggCIJ8/xkbG6NWqzE8PJzvT+VymSuuuILLL7+c0dFR7rnnHl577TWefPJJLrjgApIk4R/+4R84//zz8zkwU6XbWsvf/d3f8eyzz/KHf/iHBEHA+vXrefTRR+no6CBJEjo6OnLr5dDQEMuWLWPjxo1MTExMWXPnn38+SZLw4IMPsn37dp5//nnWr1+fZ/nU63WGh4fp7+8/Ytl+GCjcBO8REeG5554D4N577+WnP/0pCxcu5Hd+53e48847+ehHP8rq1avZsmVL7u9+9NFHeemllxgdHeXhhx/mtttuy19LKcVVV11Fs9nkZz/7Gf/sn/0zjDH84Ac/oF6v8+Mf/5jBwcEZ+9uSJOHZZ59lbGyMb3/727z00ktcccUVANx3333cdNNNBEHA/fffT7PZ5Pvf/z5vvPEGTz31FM45brvtNh577LE8Sr9arfLlL3+Z+++/H4BPfvKTiPjKZFddddWMI6KzmwrA5s2bSZKEb3/72zz99NOcddZZrFmzhttvv50bb7yR3t5efvWrX7Fr167cv/7666/zrW99K5dhqVSiUqlQKpW48cYb+e1vf8v27dv5whe+QBzH3HHHHTjn+N73vpe7bY6E7BkzJe5v//ZveeihhzjhhBO47LLLuOOOO/jkJz/JihUreOqpp9i8eTPPPfccv/71rxkcHOS73/0u9957L1/5yleoVqtordFac+211zI4OMgjjzzCl7/8ZUSEwcFBrrzySqrV6pT3PhKy8tLbt28niiLuv/9+fvzjH1OpVPjCF77A3/zN37BhwwZOO+00Xn75ZR588EH27NnDL37xCxYvXszHPvYxLr30Ui677DIWLFiQWwMuuugiqtUq99xzDzfddBPGGO6//37eeustHnjgAV566aUZ3WZFhJ07dzIyMsITTzzBX//1X9NqtfiDP/gD/v7v/x6lFJ/4xCfYt28fP/jBD2i1Wvzwhz+ku7ubCy64gE9+8pNcddVVLFq0KJ+7Gzdu5IwzzuCuu+7iuuuuo7u7myiKWL9+PStXrpyxVSDzRQ8NDbFz58483mN0dJR/8k/+CY8++ig7d+7k+uuvZ2xsjLvuuguAO++8k7GxMX7xi19w8803s379ej7ykY/kN93ly5dz+eWXc/vtt3PuueeyZs0aBgYGePjhh3nllVf4xS9+MWPZNhoNXnzxRd58801uvfVW9uzZwxe+8AX27NnDI488wk033UQcx/zoRz/Kx7pv3z4ee+wx/uqv/gpjDNdccw3gb/s9PT188Ytf5Pvf/z7Lli3j3HPPBfy6/vjHP57LdiaKbLtLamJigltuuYWBgQEuueQSyuUyP/jBD7jpppsol8s88MADjI+Pc8899+RugP379/OTn/yEf/yP/zFhGFKpVKhWq3zxi1/kgQceYGRkhM985jOMj4/z13/918RxzF133UWj0ZiXboIitfA9kEUMZxt3+wGSJEl+c8m+9+3ScTIT3HSf6uHSorIc6ez7jySFKAtWa7+ZtZdnzd6/vR569vrZc2SHezam9vStzIycvUb2/e3P817Hm7lUsrG3KxWZz3C6/DLXRhaJf7iUp/YNqD2lr930mPnBjzSCvF6vEwTBIZtc+1xof8/s95g9X/vPTI9dmC7v6bI8Etlm6WtZ/fv2Z203jWbK6eHmZBYn0O6+mi7D7Nnb50y7O+dIxpu5GzJ3QPucy9xp7eNr/5O5vrJxT5dt9n3T5TrT+h+ZuyFzCbXLBcg7EWbjfbvGX9PTeNvnyuFkm33fke4LSZLQarVyN8b012uXR/sztY97enfF47UvTG881m4Zy77WLtv2ddP+uezf7X+379HT94Xsa0e6L3wYKCwD74H2A7l9gxORKRtQ+6TLFkhWua19oU2fpO2b3nRFYya6WhYMmI2pfbztB9PhNsDMZz39Odp99NOremXjnq4IvRfa36P9wMnG1T7+9nFkG9J0f+z0jSf73PSDafp7HYlss02oXQbT50JGuw/2cIpKuxzax97+/TMNxsues/13lr1e+2Y9XebtYwDyNLb2722XbTbP2+f4TGjfiNvHln2uXQ7T11v2nNn8PdzGnz13+/yergAdCe2xHe0+8ezf7f0csj0ke672sbXPmfa5ko2tfbztMjlSsn0hG0P7Gmk/DNsP+MO9f/vv4HD7wvS5MZN9of192mV7OCUze+92JTT7ufZ9e/o4DrcvtH/vfKOwDLwHjmbDOFYcyfu2Kxfv9eeO5QI40pv2O33t/ZD3kY73WMyFmT7bsZJt9vX2W9/hNvHslpiVem5X+toVhmMx5pkeHMeKI33fYzF33+6Aeqfvm64IvVdmsi8cSz7ofeF4yvbDQKEMFBTMUzKzfPsBr5TKb4/tTboOd8OebhEoKCiYuxTZBAUF85hf/vKX3HXXXaxYsQLnHDfccAPr16+f4sp6+OGH2b9/P9dee22uGMRxPKNsgYKCgtlJoQwUFMxjxsbG+NSnPsU111zDs88+yze/+U1uuOEGHnroIRqNBjfddBOPP/44TzzxBMaYPIXSWsvVV1/NBRdc8EE/QkFBwTGgCCAsKJjHZNHipVKJk046iYMHD7Jo0SJOPvlk6vU6v/rVrzjjjDO4+uqrueqqq7jjjjvo7++nu7ubu+++e8aprwUFBbOLwjJQUDCPySKxkyRh//79GGO49dZbueCCC1i7di2jo6N51HxWOnnjxo309fUddaGpgoKC2UOhDBQUzGOMMTz00EPs3buXN998ky996Uts3bqVLVu28NZbb7F69WpWrFjBvffey+rVq/n0pz/Nr371K/r7+9m4cSMnnXTSB/0IBQUFx4Aim6CgYJ7inGN0dJTBwUGUUtRqtbzE61tvvUWtVstruGdWg97eXvbu3Ytzvm11Vte/oKBgblMoAwUF85jDLf+3qznxTp8vKCiY2xTKQEFBQUFBwTynyCYoKCgoKCiY5xTKQEFBQUFBwTynUAYKCgoKCgrmOYUyUFBQUFBQMM8plIGCgoKCgoJ5TqEMFBQUFBQUzHMKZaCgoKCgoGCeUygDBQUFBQUF85xCGSgoKCgoKJjnFMpAQUFBQUHBPKdQBgoKCgoKCuY5hTJQUFBQUFAwzymUgYKCgoKCgnlOoQwUFBQUFBTMcwploKCgoKCgYJ5TKAMFBQUFBQXznEIZKCgoKCgomOcUykBBQUFBQcE8p1AGCgoKCgoK5jmFMlBQUFBQUDDP+f8BJHxhOAVLItkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -419,88 +451,102 @@ "--------------------------------------------------------------------------------\n", "\u001b[33mCritics\u001b[0m (to Commander):\n", "\n", - "To improve the provided figure of Seattle Weather, here are a few suggestions:\n", + "The provided figure shows a time series plot of high and low temperatures in Seattle. Here are a few suggestions for improving the plot:\n", + "\n", + "1. **Resolution and Clarity**: The image appears to have low resolution, which makes the text and lines a bit blurry. Increasing the resolution would enhance clarity.\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", + "2. **Color Contrast**: The colors chosen for high and low temperatures (red and blue) are good for contrast, but ensuring that they are distinguishable by all audiences, including those with color vision deficiencies, can be useful. Consider using colorblind-friendly palettes.\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", + "3. **Line Thickness**: The lines look slightly thick, which can cause them to blur together when they cross or when viewed at smaller sizes. Thinner lines might provide better clarity.\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", + "4. **Smoothing**: The data appears to be quite noisy. If the aim is to show trends, consider applying a smoothing filter or showing a moving average to make the general trends more apparent.\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", + "5. **Legend**: The legend is clear, but it is positioned in such a way that it could potentially cover up data points. Consider placing the legend outside the main plot area or making it semi-transparent so that no data is obscured.\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", + "6. **Axes Labels**: The font size for the axes labels and the title could be increased to improve legibility, especially if the image is scaled down.\n", "\n", - "6. Legend Positioning: The legend is well-placed and doesn't overlap with the\n", + "7. **Grid Lines**: The grid lines are helpful, but if they are too prominent, they can distract from the data. Lightening the grid\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", + "The provided figure shows a time series plot of high and low temperatures in Seattle. Here are a few suggestions for improving the plot:\n", + "\n", + "1. **Resolution and Clarity**: The image appears to have low resolution, which makes the text and lines a bit blurry. Increasing the resolution would enhance clarity.\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", + "2. **Color Contrast**: The colors chosen for high and low temperatures (red and blue) are good for contrast, but ensuring that they are distinguishable by all audiences, including those with color vision deficiencies, can be useful. Consider using colorblind-friendly palettes.\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", + "3. **Line Thickness**: The lines look slightly thick, which can cause them to blur together when they cross or when viewed at smaller sizes. Thinner lines might provide better clarity.\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", + "4. **Smoothing**: The data appears to be quite noisy. If the aim is to show trends, consider applying a smoothing filter or showing a moving average to make the general trends more apparent.\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", + "5. **Legend**: The legend is clear, but it is positioned in such a way that it could potentially cover up data points. Consider placing the legend outside the main plot area or making it semi-transparent so that no data is obscured.\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", + "6. **Axes Labels**: The font size for the axes labels and the title could be increased to improve legibility, especially if the image is scaled down.\n", "\n", - "6. Legend Positioning: The legend is well-placed and doesn't overlap with the\n", + "7. **Grid Lines**: The grid lines are helpful, but if they are too prominent, they can distract from the data. Lightening the grid\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", + "To address the feedback and improve the figure, I'll make several adjustments to the script. The improvements will include:\n", + "\n", + "1. Increase the resolution by specifying a higher DPI (dots per inch) when saving the figure.\n", + "2. Use a colorblind-friendly palette for the high and low temperature lines.\n", + "3. Decrease the line thickness for better clarity.\n", + "4. Apply a rolling window to smooth the high and low temperature data.\n", + "5. Move the legend to an optimal location to avoid covering data points and make it semi-transparent.\n", + "6. Increase the font size for axes labels and title to improve legibility.\n", + "7. Adjust grid line style to be less prominent.\n", + "\n", + "Please execute the updated Python script:\n", "\n", "```python\n", + "# filename: plot_temperatures_improved.py\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "import matplotlib.dates as mdates\n", + "import seaborn as sns # For colorblind-friendly palette\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", + "# Ensure you have seaborn installed: pip install seaborn\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", + "# URL of the CSV file\n", + "url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\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", + "# Read the data from the URL\n", + "data = pd.read_csv(url)\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", + "# Extract the Date, Temperature High, and Temperature Low columns\n", + "dates = pd.to_datetime(data['date'])\n", + "temp_high = data['temp_max'].rolling(window=7).mean() # 7-day rolling average\n", + "temp_low = data['temp_min'].rolling(window=7).mean() # 7-day rolling average\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", + "# Plot the high and low temperatures using seaborn's colorblind-friendly palette\n", + "plt.figure(figsize=(10, 5), dpi=150)\n", + "plt.plot(dates, temp_high, label='High Temperature', color=sns.color_palette('colorblind')[2], linewidth=1)\n", + "plt.plot(dates, temp_low, label='Low Temperature', color=sns.color_palette('colorblind')[0], linewidth=1)\n", + "plt.xlabel('Date', fontsize=12)\n", + "plt.ylabel('Temperature (°C)', fontsize=12)\n", + "plt.title('High and Low Temperatures in Seattle (7-day Rolling Average)', fontsize=14)\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", + "# Adjusting the legend\n", + "leg = plt.legend(loc='upper left', frameon=True)\n", + "leg.get_frame().set_alpha(0.5)\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", + "# Adjusting the grid\n", + "plt.grid(True, linestyle='--', linewidth=0.5, color='grey', alpha=0.7)\n", "\n", - "# Set legend and it's position\n", - "plt.legend(loc='upper right')\n", + "# Increase tick label size\n", + "plt.tick_params(labelsize=10)\n", "\n", - "# Save the figure\n", - "plt.savefig('result.jpg')\n", + "# Save the figure with high resolution\n", + "plt.savefig('result.jpg', format='jpg', dpi=150)\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", + "This script should create a higher-quality figure with the suggested improvements. Once the script has run, please check the `result.jpg` file for the enhanced plot.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -509,17 +555,17 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Figure(1000x600)\n", + "Figure(1500x750)\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", + "The script executed successfully and created an improved figure with high resolution, colorblind-friendly colors, thinner lines, smoothed data, a better-positioned and semi-transparent legend, enhanced legibility for labels and title, and less prominent grid lines.\n", "\n", - "Please check the image `result.jpg` in your current directory to see the final improved figure with all your mentioned changes. \n", + "The updated figure is saved as `result.jpg` in the current directory. You can view the figure by opening the `result.jpg` file on your computer.\n", "\n", - "If there's anything else you need assistance with, feel free to ask.\n", + "If there are any more changes you would like to make or if you need further assistance, feel free to let me know.\n", "\n", "TERMINATE\n", "\n", @@ -528,7 +574,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -553,79 +599,16 @@ "--------------------------------------------------------------------------------\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", + "I'm sorry, but as an AI developed by OpenAI, I don't have the capability to view images directly or interpret visual feedback. My previous response provided an updated script intended to address the initial feedback points you provided.\n", "\n", - "Great! The code has successfully executed and the improved plot was generated and saved as `result.jpg`.\n", + "If there are specific aspects of the figure from the `result.jpg` file that you would like to further adjust, please provide clear textual feedback about what specific improvements you would like to see. For example, you can ask for:\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", + "- Adjustments to the graphical elements such as line style or markers.\n", + "- Changes to the axes or grid to improve visibility.\n", + "- Modifications to the smoothing function or its parameters.\n", + "- Any other specific visual modifications to the plot.\n", "\n", - "If you have any other requests or need further assistance, feel free to ask. \n", + "Once I have your specific feedback, I can provide you with an updated code script to address those points.\n", "\n", "TERMINATE\n", "\n", @@ -634,7 +617,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAE9CAYAAACWQ2EXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebhlV1nn/3nXWnufc+58696aU5WkUkkqE4QAkSFBSJgCiIJBQYYGmfSHA4raNtI/tR8VpbX1aX20mxYVbUVapBGEHxBIAoEwk6SSkKRSqQw1V915Oufsvdd6f3+svU+duqlUhspNKtT5JvWce8/d47vXXusdv6+oqtJDDz300EMPPZyyME/2BfTQQw899NBDD08uespADz300EMPPZzi6CkDPfTQQw899HCKo6cM9NBDDz300MMpjp4y0EMPPfTQQw+nOHrKQA899NBDDz2c4ugpAz300EMPPfRwiqOnDPTQQw899NDDKQ73SDcUkZW8jh566KGHHnroYQXwSLgFe56BHnrooYceejjF0VMGeuihhx566OEUR08Z6OGkQy8k1UMPPfTwxOIR5wz00EMFYwyq2vns/h4ghICqoqqISGebapEXEZxz5HkOgLW2cwxVxVrbOQaA9x4R6exvjOn8vTp+tV91jOpfdU3V993X6r0/6vwictRxl+8nIkedu/uequ9DCA+SVbVfURQP2r5C9XO1fXUN3efqPt/y44cQEJGOrKr9RQRrbedeq2N1P8Pq3Nbazt+7P6ttqvNU+1bX0i2L5ftV17T82rv37b6G5ceqnlM1Jrrvu1tuzjm8951r6x6f3fdcPaPqXqv7Wv4svfcPOcYrOVT7LB831bG7n0W3fKttl4/77vuq7u2hZNN93O5n0i3f5WOxhx6Oh54y0MOjRvciXKvVGB4exlpLq9ViamrqqEl1ObonxCRJEBGKogAgSRLyPMday8jICDMzMw9SBKrFxVpLmqbUajVmZ2ep1+sMDw8zNTWF957BwUG897Tbbbz3nQmzuu5q4ei+jyzLcM4xODjI/Pz8URN8Nbl2L2zdcqgWle5JGmBwcJBGo8GhQ4c61zw8PMzExETnONW+3crL8kVyuewr+XbvXykdlZyr74eGhlhYWOgscAAjIyOoKvPz8xhj6O/vp9FoMDExweDgIK1Wi3a7/SDFqDpuvV5n9erVHXkAFEXB4cOHO8/sWGOgW6noluvyBbT7Xqr7XC7z7jGhqtTr9Y6CWS3ozrmOAqCqpGlKu93ubLP8ON0K1XJF1hjD0NAQtVqNpaUlFhcXO8c2xnRkU43P5cpP9z1XikBfXx9DQ0NHKS1FUeC9Z3Z2FlXtKDrLFcHlit1yxaSHHh4NemGCHh4TqgX0537u53jf+97Hu971Ln7xF3+RWq0GxAmqmsy7rfduC/aKK67gyiuvRFU5/fTTee973wtAlmX87u/+LuvWretMht3HqBbJrVu38gd/8AekacqGDRv45Cc/yUUXXUSapvzar/0az3zmM4+azLsXhW5LamhoiN/8zd+kv78fEeHXf/3XOf/88zuLZ7cSUN1bdczlVuXyCfs//sf/yD/8wz8wPDyMqvL2t7+dT33qU6xfv/4hLenKajzWhN69UHZbosvl0+31+JVf+RW2bNnSOU+SJPzFX/wFf/RHf4RzDuccv/M7v8OHP/xhBgcHecYznsHY2BjGGJIkOcrCrZST9evX86Y3vYn3vve9fOxjH+Od73wnr3nNax6kcHV7PCp5Lvc+VOOhW/Hptqare63GQbVd9/bOOX7t136N0dHRo55LnudHjZ+iKDoL93LFqlsZqa6he/H+mZ/5Gf7Lf/kv/NzP/Rwf/OAHueyyyzqy7/aedCu43Qqec+6osaiqbN26lbe+9a38v//v/8vf/u3f8rM/+7NceeWVXHbZZQwPDx/1LLvHQPd4qb5b/s710MOjQc8z0MOjRjXRjI6O8qM/+qP8/M//PJOTkx3Lfnh4mB//8R9nfHyc73znO3z961/nzDPP5CUveQlJknDDDTewc+dOrrrqKjZu3MimTZtI05Srr74aYwz/9E//RK1WwxjDwMAAr3jFKzj99NO5+eabue6668jzHBFh165djI+PMz4+znnnncfOnTt5+tOfzl133cX555/Phz/8YZ797GfznOc8h/n5eT796U8zNTXFK1/5Ss466yz27dvHZz/7WS655BJe/epXA3DttdeSJAmXXnopL3rRi7jtttv46le/SpqmvPSlL2XLli3cfvvtXHvttTz96U9ny5YtjI6OcuONN7Jnzx5mZmYeZM3Pzs5y6aWX8p3vfIeLL76YAwcOALBp0yZe/vKXkyQJN954IzfddBNXXnkls7OzfP/73+d1r3sdX/3qV9mzZ09noXnJS17CBRdcwPT0NJ/97GeZmpribW97G5OTk2zZsoUbbriB73//+2zcuJGf+ImfoN1us3HjRpIkeZCbudFocOaZZ9JsNhkdHcV7T1EU9PX14ZzjaU97Gueddx6Dg4Pkec7HP/5xFhYWEBHuvfdePvShD3HmmWeyceNG/vAP/5DTTjuNd73rXSRJwuc//3l27tzJ61//eprNJmeeeSY33ngj/f39PO1pT+OLX/wit956K2984xtpt9ud53v99deTpilXXXVVR9bXXHMN55xzDhdffDGDg4PceOONrF+/nvPPP59Dhw7x2c9+ls2bN/PqV7+avr4+vvSlLzE0NMQ3vvENJicnufLKK/nBD37A2NgY27ZtY2BggG9/+9v09/dz6aWXMjk5yb//+7/TbDZ5xStewRlnnMH+/fv5+Mc/3nmW27Zt46qrruKXf/mXmZ2dZdu2bXzgAx9gz549/MiP/Aif+MQnMMbwYz/2Y3zrW98ihMCrXvUqGo0G1113Hbfeeiuvfe1rUVVGR0f5xCc+wfT0NLfccgvbt2/nBS94AS9/+cv5oz/6IwB+6qd+CmMMl112GePj46xbt44DBw5w991388IXvpC77rqLL33pS51xuXXrVu6++26+8IUvdBSeXpigh0eDnmegh0eNShmYm5tj165d/P7v/z6/8iu/wtatW3HO8Qu/8Aukacp1113Hf/gP/4FzzjmHEAI7duzg/vvv51d/9VcZGRnhvvvu47vf/S6f+9znuOWWW7j33nv52Mc+xqFDh4BoVf3sz/4sp59+Op///Od5zWtewyWXXAJEq3BpaYn9+/dz1llncdFFF/Gxj32Ms846i61btzI1NcXGjRt5+9vfzo033oiq8s53vhPnHLOzs9xyyy1cdNFFvO51r+Puu+9m3759fPKTn+QHP/gBfX19rFu3jq997Wu86U1vYv369bzhDW/g7LPP5pprruGlL30pl156aWf/b3zjG0xNTfH+97+f9evXHyWrEALXX389l19+OZdccgn33nsvk5OTHctu165d7Nmzh/e+972sXbuWHTt28I53vIO3v/3tbNu27ahtAZaWlrjlllsYHx/n3e9+N0mS8PrXv55Vq1bxzW9+k1/8xV9kbGyM973vfczPz7Njxw62bdtGnudH5XG0Wi2uu+46XvKSl3DFFVfw9a9/nSzLAHjuc5/L+Pg4Z5xxBldffTXf/e53Oe2003jZy17WeS4hhM4xsyzreFd27tzJD37wA973vvcxNDTEa17zGtatW8f27dv5/d//fVatWsWOHTv4pV/6Jay1XHXVVZx77rlce+21vPWtb+W8887jjW98I1u3buWaa67hiiuu4PLLL+fss8/mzW9+M9/85jfZu3cvCwsL3HTTTWzYsIG3ve1t7Nmzh/379/OpT32K2267jec973mMjY117mfNmjVccMEF/ORP/iTf+c53GB4e5s1vfjNf/epXSZKEd7/73Tzzmc/kxS9+MV/84he56667jvJYPOtZz+K2225jamqKLMvYuXMnS0tLrFu3jssvv5zTTjuNsbExrrrqKkII/NZv/RYHDx7ke9/7Hr/6q7/K+Pg4r3rVqzjvvPP48pe/TLPZxHvfUcAqT0Ke53jvedGLXsTg4CAXXXQRL37xi/nGN77B1VdfzY//+I/zta99jbe85S1s2LCBn/zJn+SCCy7gmmuu4bLLLuOFL3zhg0JVPfTwSNDzDPTwqFEtKO12m9/5nd/h7LPP5pJLLuGP/uiP+O3f/m2e85zncMstt7B69WqGhobYvHkzIyMjXH755ezdu5d169axatUqDh8+TK1WY9++fYyOjjI3N8f9999/lOv2iiuu4J577uFVr3oVAwMDnHvuuXz729/uLGw33ngjL3zhC1m1ahW33HILL3/5y7n88su59957Oeecc1i/fj0vfelL6evrY/369WzcuJGf/MmfZGZmhtHRUbZt28a//du/0Ww2eeCBB1haWqIoCq655hpuvvlm9u3bx2mnncbzn/98ZmZmeOUrX8no6ChnnHEGeZ5z3XXXsX37dgA+8IEPdOLRFUSEe+65hzPOOIM3vOEN/PVf/zVbt25FVXnOc57D8573PPbt28fGjRtZs2YNt99+O9/4xjf45V/+Za6++mqazWZH5oODg7zmNa+h2WzSaDQYHR3FGMP09DTXX389e/bs6eRLbNq0iQ996ENMT09z6623HuU+rrwM3/nOd/ilX/olRIQ/+ZM/4cUvfvGDFpFvfetb3HLLLaxdu7YTajjWeFi7di0XXnhh5/mtXbuWNWvWMD09zZe//GUOHjzI3r17ufHGGwkhcPXVVzMwMID3ns997nPceuutfOtb3+LCCy/k8ssvZ2Zmhpe//OUMDQ1x3nnnsWfPHr761a9y2223MTAwwNVXX83CwgL1ep3+/n5arVbnGU5NTR0VT+923X/9619n+/btvO1tb2P16tW8+MUvZmhoiHXr1vHP//zPLC0t8cY3vpHvfOc73HrrrZ2xWOWTdLvjjTEsLCzw9a9/nRe/+MVMTExw55130tfXx4UXXsiePXswxjA2Nsa6devI85zPfe5z3HPPPY/IjV+FEm688UZuvvlmdu7cyfe+9z22b9/O3Nwco6OjXHnllczMzPBjP/ZjHc/HNddcc1TiZg89PBL0lIEeHjUqF2SSJAwPD7Njxw52797Ni170IoaGhti9ezc33HAD999/P5/61Kc4dOgQ//k//2c++tGPsn//fn7kR36EJEmAmGDXnTjYaDQ6SWAhBO655x6++c1vsn37dkSEQ4cOHRXLvf3223nHO97B97//fSYmJti7dy+vec1r+L3f+z2cc+zatYtPfvKTiAhZlrF582aazSZ/9md/xk/91E+xZcuWjqVbJRG22+3ONVSW7/3338+uXbv4xje+QZqmHDhwgJe//OWdxb9K1KsSGLuR5zlf/OIXedGLXsSdd97ZsfSf//zn84//+I888MADXH755TjnWLNmDc95znP48pe/zEte8hJ27drVkc3mzZsZGhri937v93jBC17A1VdfDcSEs8qqryzZLMtYv349xpjOZxV/rizHxcVFbrzxRur1OjMzM5376Ear1ToqT2G51VnlNywuLnLvvffy2c9+lmazyb/+6792lJNqUaus4O7cBuccp59+Ojt37uT000/n1ltvZc+ePezYsYMbb7yRJEk4dOgQl112WceCPvPMM0mShD/+4z/mpS99KS972cs646m/v5+ZmRnm5ubYuHEjhw4dYtOmTZ2EvRACRVGwd+9edu3axac//emOYjsxMcEHP/hBxsbG+K3f+i1uvfVW7r77bkIIfPe73+U1r3kNW7ZsYe/evVx66aUYY7j33nuZmpriD/7gD2i1Wvz3//7fWVxc5IEHHuDaa69lenqaT37yk+zZs4c8z8nz/EGZ/w+FStbdCuHS0lJnoa88SwcPHuQrX/kK1tqOItTzDPTwaNFTBnp41Kgsy3q9zjve8Q4ajQa1Wo3t27fzrW99i4mJCV7/+tcjIszNzfF3f/d3fOlLX+Jtb3sbhw4dYmpqiqWlJW666SZ+5Vd+hfe85z18/OMfZ2pqit/93d/lr/7qr5icnKQoCv7iL/6Cd77znTzzmc8kyzI+8pGPMDU11VFIdu7cyeLiIrfddhtFUXDTTTfx8pe/nDvuuKMT233b295Gnud8+9vf5itf+QqvetWreP/734/3nsnJSZrNJtu3b+fXf/3X+fSnP83MzExnkZ+enqbVavHRj36Ut73tbZx33nm0Wi3+6Z/+iaWlpc5C19fXx2/8xm/wp3/6p+zevbsjq8nJSVqtFt/85je5/vrrsdYyMTFBlmV84Qtf4M1vfjOHDh3iwIEDtNttXvOa1/CFL3yBL37xi/yn//SfuOCCC9i+fTuqyr333su+ffv4wAc+QLPZZP/+/YgIhw8f7iyy1fn++q//mve85z0cOHCA2dlZms3mUUmcExMTLC4u8vd///dArC44dOgQIQSmp6dpt9ssLi6ysLBAURQsLi4yPz//oLGQ5zkTExPs2bOHj33sY/zMz/wMRVGwb98+PvzhDzM5OUmWZXjvO5UGqsr09HTHTX755Zfzghe8gOnpab7//e+za9cu3vGOd7Bt2zba7Tb//M//zPz8PNPT0wDs2LGDyclJPvCBD5BlGfv376fVanHDDTfwi7/4i3zuc5/js5/9LO9617t43vOeR1EULCwssLi4yOHDh7HW8pWvfIUtW7bw1re+Fe89X/va1xgcHOR1r3sdaZpy9913s2fPno7iuWvXLv7X//pf/PzP/3xH8frDP/xDFhcXaTab7N69m7GxsY6y9/d///e87nWvI89z9u/fz0c/+tHOcz9WZUBViVNhYmKCPM+Zn59nYWGBEEJHlqrK4cOHaTab/M3f/E0nrLS0tMQnP/lJDhw40FMGenjUEH2Eo6aXndrDseCc61hdeZ53kpaSJOnUt1cJf2madv5eLV5pmnasdmstzrnOz9U2VcZ7d5y6G2madhaWytqsJuwqI777+qprriz4oiiw1nY8FJXl1V3WVf1cZaFXFh7QOU6SJJ1r7pbPcv6B7vMsl0l1vuo6l+9byaj72rvP2/1zmqYAnSz67uuqrqEb1XfdpWzdVuixXM8iRzgjRKRTLlp5AZZfW3XO6vsPf/jD/OVf/iU7duzAe0+r1TpqXFWy7r6W7r9X11l5T6rjFkXxoPtf/ryWj43qGquQwrHc7NV4re6v+zlX1/FQ2x5rfFSoPDfdZbbVNVcKXPd4ON647CkCPSzHI/JE9ZSBHnro4cnClVdeyS233MLMzEwnlNBDDz08vugpAz300MNJjSRJjuKe6Fm1PfTw+OORvFe90sIeeujhSUM3le6xGCt76KGHJwY9z0APPfTQQw89/BCj5xnooYceeuihhx4eFj1loIceeuihhx5OcfSUgR566KGHHno4xdFTBnrooYceeujhFEdPGeihhx566KGHUxw9ZaCHHnrooYceTnH0lIEeeuihhx56OMXRUwZ66KGHHnro4RRHTxnooYceeuihh1McPWWghx566KGHHk5x9JSBHnrooYceejjF0VMGeuihhx566OEUR08Z6KGHHnrooYdTHD1loIceeuihhx5OcfSUgR566KGHHno4xeGe7AvooYceelgJSNfPKl1fVj9r178eeuiCSBwkqqfO4OgpAw+DU3FQ9NDDDwOUuO7rg37p2qD3WvdwDJyK831PGXgYqCoi0lEKeuihh6cIyvlc5DhrvhztQeihB+gpAz10QUTo6+vj0ksvJUmSU3Jw9NDDDyOUqOD3vAI9LEdl/FVotVp885vfJM/zJ/Gqnhj0lIHjYHh4mNe+9rV85jOfOSHPgHMO731noPUUi8cXSZKcEi/rkwHnHEVRADz1x2556VYMqoqi0W3wJMEYg4jgvX/SruF4EBFCCE9Zr2iSJJ1595GM2xACzrmjtn/DG97A9u3bmZube2qP/UeAnjLwEKhehB07dnDddded0GLT399Pq9XCe//Un1BPMogIjUaDVqvVkWtPvo8PRIR6vU673X5qyrYrUTDmDQqmzBsQgQD4J/F+0jQF6MwtJ5Nsq9DoU/K5A9ZakiSh3W53vjvePVT3KiIYc6TI7tJLL6UoilNi3u4pAw8BESFJEqy1J6y5F0XR0bBPhUH1REJVCSH0ZLoCqGT7lEWVNNj5UREEayxBPTzJY+Zklm1lHVeWsjEGa+2TfVmPGNX8/WjmWxEhz/POc6nutzIMf9jRUwYeAiEEiqJ4xC6m46EaVE/tBUswCEECToVCHBCw6vHl34+NJ/aeTzYZR0NUSun5MoFdoPwdHoGEjsqCNwiCiiIaVly6J73yKgAWJIBR8IKoRaU4IjcRUMUirElTnnP6Jm7bs5edSy0qwRqObP7DP+0/MhjjKLyybdu5POey51L4DCGGV4wKzkepKVXppiDlPCCqIAWh/B7AaNw+HPmqg+Wxejg6TFEpJJXiX1nwIQSMMUfN09X31tqOQts9jqvtu89THbPZbPLFL36R6enpUy6s21MGHgLV4Fo+cB4LnvKWqwFRi1WD2ox6ISy4OqI5jcKzhBAekr/qiZlejzWZnDQQh9GEhCZelNwkYBJMsQSqHM/vZIBgodpIJCEJlswUSMhBdUUVgm438ckmXyOgBlAb9QHncWrRUMebJYIJUBjAYKQgUeHsuuMNQymfGxxgZ7PVCSFYSlnzxFYcdi9EJxcEcFgLFzztaXz1+uvZu+eBMsyiOIREhTxAIXQWfUEQBaPxvS8MIIIEcBq38QhqBGvNUeOrc+auBXj5Ylwt9NXfun9evn/19+XKwbHOVXlBLr30Up7+9Kdz/fXXnxLegG70lIEnAMaYB2mvTxmUM6V6yFGsQI3AUmgzLDAqwgMKD22jrvz9VolYJyNUAFECilPFKRQElBAn0IcRTzl/drhCJeSkBLwR/BOwap3MsjUKqnGxb+Q542rIvecwHsVACBiNwlOiPlULMNJW+oOUDycqUwVHPANPpCJwssoWFNE2ThIGkhrT+yfRZvRqGTEYa0j7lGazTdsr2l2coUAwoLX4uwRQX6kBnTFtrevIIITwIAveWttZzL33Ry3qyxfq7sUejlj/1f4QczOqkG/1XbWdMYYsy3jggQc477zzVlCuJy96ysATgMoz8JRTBOCIYS8GRGl4WCMQQsZLN29htXg+cv8DFE/ivZ38nhdBRBlQqAFtAvkjUARg2QQrUCcwDkzkgSUnrLTxcjKPXYMQcASUcYG3bD2LO6bm+eThyRiKUTAYBMiJSphDaBSCLQMDHQXgiG7Q8RbAyioGJ6tcobQBVEkFfN7GJI7CmKhkGQNJyqoi4H3BgEtQ55hrNfEhoAgqDpUEKjVMyuoNfEzmFHjLW97Cueeey6ZNm7jnnnv46le/yvXXX99ZnCtUSkKV7V8t6NV33bkNb37zmznttNP4kz/5E9atW8cHP/hBfvM3f5O9e/ce5SWAo8MF3crGqYqeMvAE4FgurKcSbICgIOJ5xrpRXjC6js/ceRcXGMfmgSH+Xh6giT545qze+hV+v7onjpMNojF+mlDwvPUbWJtYPr57D1OiWO1MlQ8JC3gPNkSbal2txk9uuYCv7NnFLUuztI+z7+OByjNwMo7ZgCGIRW2gUQjnJw0W+wNMT0S/tTGEyv1iQXx0VYsqXqr6AkAENaUGUMYJDCvvJeieF042+SrgraEdPKkx1HzGuFNaWYsQoC9k1JIGLY3j2CC0A7SJ41kpQHJEFaMQpPQeKIjGUMI//eM/snbdOn75l3+ZP/7jP+a1r30tv/3bv819993Hxz/+cd7//vczPz9PrVZj586dnH/++Xzuc59jcnKSt771rSwtLXH48GE+8pGPkOc51lrWrl3LOeecw9q1a7niiitoNBoYY7j00ku58sorybKMv/3bv+W8885jZGSEPXv2cN555/FP//RPD/JMnGo4eWfRHk4aWIUEIVE4t2+EC2p9rLYwnmUMtzMsVPMtCXHbI3nHK/9incwskQZIUWooF46Oc3H/CIMoxhc4Hp79zgAmCAmWGrCpv59nDg5zwcAwzj8xsgVOStkWBAIh5g0AtbzAhUB0lwTQQDBKSMBYGAb6CeSak6uPSQcQV6hyl1h2GBWFUzpcIOAFghESUdZaw7n1lOcND3FZXz+X99V5Zhp4bl+d5zYcP5LC8wcbXDbYz/OH+vjRwX5e1hjgqsYQV/SP8LS+QfoCoIJiwSSEoB0egHPPPZfLLruM7du386IXvYgzzjiDTZs28S//8i8sLi4iIvzLv/wLV155JSMjIwwODvIXf/EXjI+Ps3XrViB6ELIs49vf/jZXXHEFGzdu5O6778Zay549e/jud7/Lxo0bed7znsfNN9/M5Zdfzjve8Q6uu+66Tkih5xnoYUVx8ruxj4+qQssCI3lgqF3gRKKVVebGV4qALaOCBUfm2JVGN6HTyYYjCWmB/qJg3Cu1UqCPJLUy7n8kaaAeAqPtJQbz/AhfzgoOre4wwclnNWlMZgkmWqPGoRiSEKgT8wBy4wkJNDJ4RmOQrWmKdYoXj2pARTCqODVlMqZSoASRFa88rBaek3LsxjgBosqgGDbgOH9wlGeu20ij1SKVgJcMVBFjEGPJVckFCiMYFfoyi8UxaxK+m82z966baQqoGHzpiKnyAYaHh1lYWGB6epqPfvSj7N27l5mZGQ4dOsTk5CR79uzh0KFD1Ot1QghMTEywtLTExMQE/f39R4VcbrrpJt797nfzta99DYjkQ29605u48847mZiYYHx8vJM/UKvVWFhYOKWVgAo9ZeAJwMnsan0kyCVmB1tRakFJglIklnZqaCWmdBPGf4kIiUtYyLNobD0Bt2ytPfkm0xJqIA+CCBj11DWGXAOQYVA9PoeFL28rV1M6tQNpyHBa4J8AX3Z3AuHJOH5N8GghpTwtBsOIGgasYcYXzBuhLYFVWF635emcns+RyAImeEy58FuEGkpfUqNVFCxqEXM6YMVlCycp30AAipgwrAZmDHxnZoKbZifIvKdmhESELHhSMSRiWPIFrdIQaIvQFOiLGbQcDp4pA2oUKTxJqWxVrvlbb72VK6+8kjPPPBPvPTfffHNHSapyBFS1QwB04YUX8pa3vIWzzz6bT3ziE535NYTAwsICv/u7v8vs7Czvfve7O9+PjY2xceNGdu/ezRVXXMF9993H9773PV772tfyd3/3dyfnc3gCccooA8sX4+7yk+X1rI83uj0DJ+OE+nAwZemQ0ZiXHSQgRgjO4CVOGKIGS+DZa9ewbd1G/u/t2zmU5w9qFLcSWGnPgECnBa4tvR0qpqxfD8cnryllJygeT0gcTuIioEbBG5BAEiyKpZAsNs8JBoeQmzgR+hAwKF5itVzbClZjTsJKynflPQMSfUkSZQuGQIhqz8MMnlj8pqBKEMhN9KOcPTzKS888nY/fvp2FMrM9EVgtBSO+wJRxbEscvwIM24SfuPASduzfy1cP3k9uTJnMsXJUwSeDZ6Aqp4y/GEyIYa2WibkVqUBqA1kiHG7ltIqM6bbSn1jSJGWx1aYvTUnEMJd5ZkKOlmFFJZASvYZt6OLL8ASEEIRDhw7xp3/6pxw6dIj/+l//K+vXr2dpaYnp6Wk+9KEPsbi4yL//+7/TbrfJsoy/+qu/Yt26dXzve9/ja1/7Gp/61Kc4fPhwJ+nwYx/7GPPz87TbbUSEj3zkI8zMzPDnf/7nbNq0ic985jMsLi6SpinXXnsteZ6zbt26kzrU+EThlFAGKtKf7izS6sF3E1p47x8XxsFjnb9b+XgqKQSGWI7VTJQ0V4x41AaGROgPUPdKokKsPM555kCDZxUFXzHCBDy4bewKYGU9AzH/wZuYC514ITeCr5SBoMdXBkJUGGoCqEdtSs06TO5xKDW1tKwyqEITBzYvj2ewKIVGfQOJOQZGhKZNWEgS6gFaRHf4SmFFPQNiSjomj7fgishXoQgOT2Y47lqsIoRyYVcBbBtLwfo04WIP1yHs8FFlgDbIAqm0yRHUOFCoK9REGRS4xHiUwLcV2moIxoFvPr733IWTwTPggKIkaw7WUAuBMQz7JRCA1CSMGMFqTHVVq+RqSIPS53MyDSR4akERLfBOcSqMakIbYS60y7JaSBUKH71dvkw4zvOc/fv3AzA1NcXU1FTn2vbs2QPA5OQkEN/z/fv309/fz6233srtt99+1L2EEDh8+HDnd1Xl4MGDqCqtVovp6eljymD37t2d48PJmR/zROCUUAaqkpKKtaq7bhWOJq9YiRezYjJ8qiJAZ0G3ColCvxoGMDjVo5LgjCpWFXkCb3clPQNHcs5jkNMT768eovW6xPHj/omCt0KwMBAMA+2AFxDjuWxoNf1Fju2DIR3guokDjKcJGwcH+NahWWYJECDB4FVICaQqmCB4gexhzv14YGU9AzF5QsrkiRwhlCQ1hTelFnS83bWMkigGsCFQC56REBgxhotXr+KWA1Ms+pwNRhlSU+YVBHJATeC8/kFOS/qZXpikLh7E0w9kwbO4wmvCk+4ZkCN6rCFAEVhbq/OsobV8bWoPM0GxLqVPGpjcYIMjUY3qsYKoQ/FISLFqoTyGFUNf0k8IOZ4sKmpFWVhYlnDaUCoEj/RSu7y3O3fu5O67737Ysbh8vB5v+4qj4PEgmXuq4pRQBkQEay2vetWruPjiizvlJZdeeinPe97zmJyc5H/8j//B7OzsilhBzjnyPH9KDjKlYhcr3bIiJEE5wyaMuxqtYuUsp0eKlfQMSBfFKkRDtU/hwloDJ8LNrSUWjrO/QfGqmCAMF9BvBSfRIr1qbANnJEJNm2CG2DkzyUvWruHcxhgHJ+/iFl1EVCBYIqVxgVPBhZh9+EQoAyubMxC1ACWWnwZRcB4wBG8jcc3D+D2qIxii5TkYYLUKtSznmes28v9NTBMwXNE3yFDmS49AgVcIEnjW2Fqeu2oTn77jG1jNSdXz9HqNA2K4qdVaUfmeDJ6BKuXEEMsuLxxbzVWnn8XMD6b51uw8wRpSa6mlNbS1gNO4iGfWULOWtjH0GUPAUGDQINggiAZs8DG22KnOUNQqJsRk4yq59pGg24X/SPgZHu18UCkC9Xr9pO0iudI4JZSBKvHkS1/6Etdccw2/8Au/wIUXXsiVV17JBz/4QV796lfzrGc9q1NiciwqzBNx85/M5VkPB6WcjlXQMpEwAS5ZvZExl3KwaCJS1g6Xy2as3T6y/4ni8Q6xPNrjRQKbGF0NBgYwvGLLOVgn3H3bLSwc5xhRdsraWoM1I4PIUpMhYzjXJZzZajMCDGjGnGkRBFanfQxlQpNAVotx65ADYsiDECgn2yciM3MZHnfPgEarPlSFqFJOwuqJdSm2TEc77iFQkRhyCYFB72k0+unTwHCmDClsGlvFy9ZuYGBxiSVjsVicKonAQLvJ6syTAol4VlvhgrPO4e5mxl337jiuovd44UmzSNV0PCsAKTBCYO3SAtuShP3WMBWaDLUXuPpFz+feqQOkPueutmW4bhk2KfvyBdYl/TS8sIcmOYHBNozXBpn3gbtNizxNSJuANSwlgZoP1Aulbe3Dzg/dXpNuNsFHMha7SYS6ZfxQ+yZJwsaNG/nqV796clZ4rDBOGWWgamn5zne+k7POOouvf/3rzM7OMjk5yX333cfmzZs7A2fDhg08//nPZ2xsjP7+fur1OsBROQXH4hRfTiJSbVOr1Y7S/rv5sCssz1k43sBdvpgdb5uH2udY2yy/B4gThSoYUlITqJk4Ra9WR5LniA3UaylJ4aipYsvsXytC6lIKEyIL3DHkdazndCz5ddOSLpejiHRawXaziFWfxyJ2OdY2x5INlJ4BNRgLqh41nv4M1gcLRqhbS82ajru1YkMrigLrLJkW9HvLKo0WbGYKnrt6FeuH1rJhehEC9OVQ1C2rUsdoEPoLQ10cfeLx1iNJQlsE0Vp0rCs0jGHAWVQM2pX78kgnsOONm27U6/Wjcmoe7fGXn+uoxN0yxJRLgsXgpE3D51hjmXMWbI2gWrqzj3G9qlhnKBT6RXAaOL3Wj/QNY/wiDXUMA2tQhoo2FsWWWYkjoWAjMEjAhIxEFXzOegxnSMps1mTAGHyaUhRF55k+FAf+Q31W93+sfZxzR+UvHUtWj/ZZHo/I6KjrI45tq0JhIAkFNZ8zGJRVWc5lwwOcvnYdn7/3HpJbtrNt0xY21OusCg0GWkv0q3JG/wDf3n+YZ/StYqSWcvPcPP2NBqfZGrbe4LaZGfYdPsw+lEVXoxBLYcAFjwlKsUw+1lryPCdJEoqiOGrhr7D83V3+nnffc5qmnURC7/2R97JrPqmOb4yh2Wzygx/8gIMHD9LX19fZ51TBKXGn1UQ2Pz/Pn/3Zn/Ha176WCy64gHq9TpIkjI+PMzU11VmAFxYWuOuuuxgfH+eSSy7pkFFUC/gjfWGrbYqiOKbrqXvgVotcd6fE4x3/eNdwvIlp+TYPh8pqMBpi/XU5OQ8EMCaQi1IETwiGQsNR/eFD8ASOLa+H0+y796n+LXendisLldy6LYHlx69+r55ldwe0h5KHioB6RA0SAuoUg2HAO+bydrxnf/SzrEJCmitqAyaABKEZcsaMcFE6wFqpMdJYYh7IvaFAGbKOfgMm8dQpGGl5RANt2yJzgteAJg2MWPAlSYqUbNGPwoo5Xix1+XGqsftouTIeiTKQqMYcTOfAK/3B85zhIcaGR/jMA/tY8IaAP+ZYUY2hgVAEvJgog+BZ0xiihSDiMRKTMAdCQQgtChESnxLUc8FAnTDUx5pCyKWgKMfpaAFpVuA1h6AUeU5QPSrMt1xGx1POH+raKwWgku9jtUK7j38smR9vn+jrMrFjQFDSAI0koV54zu4bpJELN3nl9LkWxd33M9ucZqw+TP/sAq4h9PfNke+/l6HVGcOS0Jjbx6q+QTabfhZSg50+zBZjOLgwx03zc+QYUhUKQiyLDUfLY/kCf7xrfzhZV0ZClmVHnaO7y2H3MY8lz8c/R+bkximhDKgqaZry+te/nlqtxjnnnMM///M/MzAwwHve8x7WrFnDf/tv/62jYc7Pz3PrrbeyZs0anvGMZ1AUxUMuRI9kwHjvj1IGHsoaqwbroz3+sXBMK1ceeV/uThGAACK44PHiS5IRqGMIkuNNwKsneBsLhoxBTLQ8fIikLuFRxuAe7b3XarWO1faI7+8YL/0xz2ejEMRH13JQj7GOukk5VCzRCrFk8ChZq2JKBQWgCEpbLSF4Br0w3g4MSBsxGSEYlmqKT5RhZ6iZjMJ41vQlnNk/zECh3L2wyDeaC+QCoQFiDLkGivLcKxlxrsZ+94JzIjjKMq4maBvQIlBXz4+u2UDDOb7CbmaKNuE4YQJB8EEjyyCQOIsrFBs83ngKYiOcuhVy5xGTUF+CQj1nNfpYWx+lOTlFMLEu3lhLf3DkFhYakBEoitB5lo/H4nCUZ6Qcr92exhPFsSzkY25XfioGbw1efeRWEMFhCEWBBsM8ijUCVsizgtQFGklKTkYdJbGGNHjqxtKQgiEt6M8ysMJZopw/vJpFY/nu3AyBQOpNrCZwSiyVOXLdlWc0z/PjLvIPZ+xUBgLwIFbBSgE7ngGw/NinikLwlFcGHkqLXK4xZ1nGl770JQYGBvi3f/s3JiYmuOOOO1i3bh0LCwtMTEwAR0gwKjdeNaGfCB6Ow6Bba30sk8Ly6j2hqj+Xss9rwKpB1JZV3SFa/CJoWUBvCR2Cm5oIT0tqzOY592jAqyM3BQ3AhoTUC2KUJorzglMhl5yGBpZQ1An9KAlKM2j3zPOI8GgXnmoyXRGuiACYykMSedgTgTwVmlletrsxqHiw0Uyvq6MIAW9j6WGb6BK1xmI1MKiePimQYKh5pU4gC3mkyxVHLfdcUK/xnI0b6MsNX1la5JYdd+ABp4FcWwSjZKYkdVrBueqxKJKPFLFToIL3VG1sBoOnnseEtJoJeIVMADVlhUpApRrfBindzs4aMi9kUmATg3oD1uBE6JMa+zJFQsbZxmCcZVgstaU2SxgWi4xBVTQo/WmCBCErrw8BH2LYy2rMYAim/MMJ5m10KwWP15jtPo5D8AZUtCLHILZuCiQoOZaqoZMLpQ/QWmywJIXF2MBcIizUHNQSpq1j0gasC2hQCiu0nBCs4ilY09dPwzkKb/Aa6DOG/qJN39wCFktuDW1fxHkmPPi6K4XgeJ6rR3Lf8NANtpbPLcfyECw/92P12jzV8JRVBpxzR2mTy+NH3S9ZNTD27t171DEWFxe55557HnTsahAdr5PVo1mwHslE+lCD9BEdvzpG1+/RqheQ8sNHTvAYpfWxEYsqigUEV7nuRBg2ll8+axvbD+zjr6YnWNCEkCyBFxLpp1ZES2sy99Q0oaYWTEbqASyNoJxLgHqNO/OCieCPvlCWXfAJYnl44JHus/znY+6rZfKgQKGBhkIdaKUe387pQ5gSE5PeRMEYXIjNWpGABIuXWIaY4CiMp6+mJKFNQUpwGX2Fw2AonNBKawzlgfNSy5qleRq50G+EtS5h0Bj6jVK4DFdawyuNx7u0sFvWRZltaoqcgNBGCBLwQWiqZZxAI0m4vyjIxGJVYy+CcoAHMVggVV8qZP0EE1BtkoToCrYCDWlwz/wiuQmcOSAELKKW1BSYxIIGhgArQi21NApLnQQo71dAVHGULQyEx6wIHGusPV6y7UZc9oVCAhiwHhRLMJG20gWlLbEDYd1nbLYWi1KTeL9podQ1p1DIRNi/OM9dc/NcMD7K2OQiVi0mdiSKVQPBc6atkSF4PIIjrfUh1tMXAi4kqHV4FwjBY/IHV8I8kjnv0cyPy8OAD4djeWxPFa8APEWVgW43jjGGJEkYGxtjaGiIgwcPHlUiWNWgP5noLn1biWtZbhyG6lsFghIMBFc1cAGCdNSCOK/Kkf2DUBcYsY5nrN/AhqU5drTyzjrelkDuDIWBuXbOQJJE69gLKTCWGzZjeMvpZ3K4NsxnD0/wv/ffRw4PVgaWuzQeAyoPTru9Mv37BKgemRJb4QqxFfFwrgyiYApMiBOuF2XRBIL1JAGMCgWxbCvxBhcMKoYgUIhincUgWASHYIhu2jNWjWJbGcGkKDlXnbaZi4dW8/1DO/F4BrA0QiwvXEl0U2mv1HvUPSyMxHJMC1w8Nspz12/if991B/e2o+QziJ4aBVTwQWhLDBmYIFivpGLIg0dThzNgEsdCfqTPg5TeMGcMJrGIxFI3VMAZCgI26JEubhpLSqsRZjxUxu2JSGQlu20qkJXcGOKjAuuBlgkEF1jKwYYCDTAscPWGsxiSnIZvk6WL+DSQBWEYS8Dw5f33M9Eu0HbO5v5BmhKVohoAQjNkJCbFaJxLElUGrSWzSu5i8m0tV8YJLMCKV2mISCdU8GTP/08VPCWVAThivV9xxRU85znPIUkSWq0W9Xqdw4cP85nPfIb777+/ozA8mbWjK62QPNSRbcn8VQuwKIq3ofJxEqu5yzp4NBK9aWyVO2ANDaBuLJvTGntacyQ5NAAxATVCEMNiUVCvpeQGgoW2j9ZTooE1qvS3M85OEhxxEX1QLOPxuHfVxyWU81AwlCSDZTzVS2x/2/CwbWCYy087jZ37dlMASQA1ilGPVYlJfsQkxEjcZEANpiypCmVFXVEKpi7R9WyCUs+JzI7G0pc1OU8Szm23OaRKWgRi6V1Fh7RyY6s7X2BFLKVlhzOiOFVSUTYnNS42da53CfvabZrQoYWG6tkIPjq3omLoo7dgd3OB+f5IQ2xqjqWiOl1UuFRjwEwkJmY6wATQxFAUgVRDVBBKlUBRfMlFXS+97ic6o6w4v0DJ/CXaNdGrYjz0BQiqtCw4NWyRlHNcjf1+kpAUFMEjtsZAMLTFsEcDi0BIDPWmRxOhRaCvLCme9wWDro7ReEITPHX1tFPILEDOuY0Rrlh3Bp/bey/zebaiJBmVZxdOPQv/seIpqQyoHil1mpiY4K/+6q+Ynp4mhECapmzYsIEsyzrbPdkNKLrpiFcEpYUdP0wZUI18AGtrNZ63bi3fOXCAXXmBasyJK0rN3pTuzkpCNWAoSTBFRkOV9UFZK3DJulUstDLq6nFeCMaS+xhuqIuSqpI5QRPLogs4zUlthpMMK7Ez3FFPQXlcFILKM1A978cf0W+iGuMtWk6wdVXGPDxj9Rr+7949zKt2vAY/MriKTcOjXLf/Pg74SLwSbOzlUHgAU/Z519LdDRKUupgywSknsYpRwXjDNqnj6oaaX+T8NGWVJiw6ocWKpgsAR4/dlVAEKu8UVJ0vBRsKElWGraXP51RdMDOhEyIwShn39qCxRl7FE6yhmTj2tKGG0KdCYg3tkpgoqMGpiURQQBVHqxFZ8YIRxCqNtqcfZRIhSGTU1LIbl+ZHGkidyANYSc8AlNNAiJfYJpa2Oh84t9bgmWvGuPbAQfaS03aQ20A/KTUPIRf6cKQhMIClaQ2LqkwWOXfOTzNeG6JWBLJE6ZNIHz2HZ50ItmwbbTTEZlBqCc5ggM2J5UfXrOeWif3ck62sT6vnGXj0WNnRuEKoJqcqb2BwcJCNGzeydu1asixj165d7N27t6MdPtmDobJcVywRpTysqWxFiZ3xasDZI6O8Yt3pnJ3WSUOgrqVLNAYVO3NZZXGlQF+SYAk0fM62tMEZScqrNm7i4oEhBlVJco/10SKv54HzVXhmrZ/hYBgqADwiIU7qhE5HQyfm8XIIdFB5BlbqGcc29yXlskq5gCkSCuq+oL/VYlhjGMAbwRl40fAaXje0gTXWkaDUA9QFMNELE4gsbK6I3gRsJH9JFdpFTqGBVOJE5nxgczAMmIJ2zXN6vY/+lpJbxZVZICuJ7vdnpcZvxfBoIZIBKdRQ6okhN54lYMmC2ih/i5AANQKDFGy2hrMH+0gkoFbYPj/NDVOHCWoYQkiNkBd5zOMoUz6VmEsDiorEHgWhLB8NOSPec0HfAA0DxijDRA8bVijk8VHClme6P54QSkuvVGJaxLBUP8pzB1bx2vEz2NwYpC+AV1hwgaYFjCOhzkA7oc8XjNmUTOM2iz5wvy9YEgUfEPVssAnGGGZ8RiippWNyskfw2GBwpc05LIHhVpNBXXm68uWegR4eHk9Zz0BVIrJ+/XoajQajo6PMzs5y4MCBJ/vyHoQkSVbQcuVIkmAngzCaTxYYFGGsnTPQde4qGbrUG2J9gRyZQFJjEBuoFQU/suE0pmbrbF4KzLVz6mnMEQgh0ApKQww/uX4jBwdG+ds7trMmNySJkmCwKtTEYhWcWAr1D04TOMG8gZX2DMREzBj7h678AQlAjisXbcWCCkkoWKcF6+bnWaMw1N+PyQs2i9DXbmMkdh6sukCKV9QozhgGVGkHT0s9dQ/BCbkJ9BUBFwpyK6habDCsAS5yljt9YHoFld0V9QwsQ8wX8CRaLvbOEUzsw6AAakkUxBcxcZDAGUnCs0eGedmZpzE03yYEz81L89zRzHhlcGxs9NMnlrwoEJuAClIu6j4UYAQ1ULcuVsmg1ETYOjTCa9dsYucd23mgvcRWm9IE7gzt2GhSOWE390p7BrTrhzLKhVUYEmE0KxhVz7OSBs4FhiiAPE4dYlENNMTz9KE19KtBrCMHMpfQNo56PR79rMFVZKLM+YIgsVIBieWeICTBUvc2JtCmBufbRIqwxyFh6DjoeQYePZ6SykCHNKMkj7jiiisYGhqi2Wxy5plnct999/GVr3zlyb7MDvI8B1YwdiXVR/yvcqU6iA11NKdwkDsgaLRGy30cUZOv2sUaIEkswUTNv5/AsBGGWjlrXIJ1hmCgJZ55AiTCpnJ7K0LNGbzRkhgnTiJWILWW4OOJw8M1oHkUWGnPQDQkFfHRIvWljIJRChPwztAUaGtUeqyArxcQ2pzVqPO8M8+lL8vpM561rYBRT27BS4xdJxgCig+BmhVy9TRDzohLKVJYyNpIzVIrYgJi5uqYtnKxS3nG2Vv5kz37+N78/IqNreWegcf7HEclD5qYw2Ik9sDoswlJcKQIRg2qjoTITBdKN/+rt57L5SFheL7NYOFpAdMSmENImsq5A2Ox/6MPGLHxZw0Y69CQlYufULcpSQBnBOsDg17YiGdV7pnB8OqN2yis4893f58ZUVyQSFR0Ave+kuFLhU61hg3R45eYBEKbdgpLrsk6U/Dis7ZRkzajS01GpE3bCRk5SzWPsXCeH2IqazOX52QI1gsiCbvmD9NQYV19lCWi3KEySOJ84q0h8ZbUx2XG1h2eoqxfepiWlCd6/72cgUeNp6Qy0E0q8b3vfY88z0nTtDNxzczMPLkXuAzLaTUf94EZoKHQNoYgCUIgGE/bQ58qdW1SS2LLXe9AC0W8YLGIFPG11DLfAGFNYlECzcQSdIltSUriDHYxx5k+vImlfPMhxMxhcfgiw1pDf5VMKAanUA/CRcOjnLN6I5+9/04O5DmU1jQmYL2e8JTwaPjKHzXKCdVXljxQk1jznptYKeAFchFqGjWFvBYIWWDAWDaLYbhsc2xCQTBllYsRgkZmRxscDVOwYWSQBa1xb/AMO8fM/DyT+SID/WMM5AZvDC1X0BBhi3GghjGXUCcmaPryumxF1XNUs/rHePtPgIvVE1kdEwGLoTBCglLTOIaGVelTZdHAaBBetuUc7luc4/YD+9mQWtY0c8hieZukFg0xz8OnjjWmRjMUqAqLYrnTJQwvLbLJCB4QjfksJokhGxFD2wb6vNKfZfSpYIywuiHUbGwbjYmtpJ0K+QkI+ImQrQuWIIG1tZRXnr6Vm/fdjzFQWKWhysYiY0CUmhf6k0ArqbEggQFTRG7C1HJHe4lD7QwQTBvCsOV784s8u2+YhiqHTUG7LagIc7XY0TPxDjUK3mJsVAD6naAmkKhSI5bfBroUTZGYxNn59sTQCw88OjwllQE40rRicXER7z333HMPd91110nZgrK7JnYlrq3qAtY2gBhsEShqhqQIbFBLX95kyDist3gbm+24wuKw5FKwKU3ZtGqQ2w4tYinYLEq9EKDOYGhydtIgN56aeJJCUCeIFizkHqNCElLQnLqBVR5sUDIbs5WHfODZI0O8sDHMD9KU6TxHMXixiMkeF2VgRVF6UcriAASoa+QSEDHYoNRCzCsIRJdzEmKGdiJC0IxEsxhWsZHO2QTTSUb0AhIS1E8wUu9nblH50sQhxgYT6uK4e77N+QMpnozMBZCCmkLdC0VSY8CYqAwoYE3pwYBQNlV6UN3pY8BKhQk6OXgGTLA4AhZL5oREFIOiZDzdWZaGh7lhcZEhX/BCl3BfvZ89ohi/hHfgxSHqyKyn5mPoa7aurJtZBNvHUgj84PAhHpid4xV9w5yhCZo4NA+4VEhrFlvmb7SdUPdFzMGxsX20tU2sz0jKyhLP0V6NkxFGISWlaQrW1ixX1WswOEh/oaTBIEEQyRGxiEnw0iYhZSEv2KgZxgi7nedzM4eYL/MNNCi5FQ4by5KrYXygSHIKbwlY7lia4ZJ6H9Y7CikoBKThaQAbxGKNLUsyFTBY8RWvF15sWd305CZ8n6p4SiYQwpEJ6mlPexpbtmzhVa96Vady4MmuHliO5dzXjzeCgUUjqHr68xYNVdIs8KxaH+c2+gg2wUoSLZ9CSQowYmmLpwY8d3iMnz39Ii5oDKASaFhLQx19bWF8PtDwMQt5pFajL6nFGnmUZhGL4kQDA9awNnUkJnbUs0pZMy8MWUvabHIawrNXrWJUAkazGJ54nGSwYsltGpUtSmtTShd2GqBWKA1vOjXqBmgEoR4MVg0JpizsCCVfQekh0GgBWQXvhXlnmC+JYVIs+/MWk1LgjTDtHNOpYbrhWEpstKZMDDGYEHMzPCURTlmxUVS8ESUpzMmPstulCKYMV9ky189qxpWr1/HGMy7gDONooDRMwXkqPC3tw2lUGsQYggiZwHyRkwPBmdj4yxlmCTzQWuIH89MspIamCZEum5KXXyP3htEQy+MwMcZuhAZCnzi0KDXDIHgtiaVOYgQDHo/xgT6JpcaJjSET1JecZIoYwTrXKYFdynNCEIIX5oNn99xcmVFApMRWpa3KbGJYMkrQQEsDTevY29LIGmmgmUCzBqo5A8A6rSFY5hND04E6g9GYK5IoOK8gilqqPpYnhJ5n4NHhKakMVOyCxhjuu+8+nHPccccdnTDBSifmPFqsuGcAobDCgMJWI6Tk9Ktw9RlbOHegHy8pxsQKAVMyqXkJNIxyujWMBFg/32KtFTKUrGaZ8AWzqSXYGAtPisBovY+BtI4KZEZYoqrbVkbSlHP6+8tExticp1IGGiHQ7zOeNzLM6845n62Dg6QVZcvjyDewErBEWtd4mdF9aUx0LbuCchEBJLYX7leoe4MagzORHafDghYi8ZMpS+NMEDSpcdfcDDNOMIUS8oIFAs0kLjYthHatzl6fs6gBCTFcQBluSMSWnBFKEmIGty+trlgLd+J4IjgyYnZ/mfWiUeZGoCaejUE5fSljM8LpzjDgm1zY6OeF4+uoA+LLJl8itA1MZG0WVJmeX6BuHFjLggZmBeaARRNQW4Z6AEQYdilGYrmnLa1/NSBWaIihTxxtH8gxUPI/nKgi+0R4MD2BATxDZahKVDrvaCoGWyYOI4ISQyfNLIsKZdrggdYSs8F3chDaomgIZKrcvThPu56gwLzCTFqjbV1sfiQKWJquwIpSRxgODikiCRoSEIkL0BCGcWOpEWmpH69V6WTzEJ/sOLlWzUeI6iEbY5ifn+fv/u7v+MIXvnCUklC1njwZtMOVvAahjHUGw9NGRnjj2eczktQwwLhmpKGFYMs4fcCYWK8dCDxjfDU/u2UrNaek2mSUghETF7e7lua5RRc51BcpYl0I1FQQH/CiZCYqDiAYDdQKz+lJLdIX+bjgiRisCI3g6Xcxd2BLyzNqbEw0Uh5XX+tKvPwVuYyKlv9iiZs6iY1dFIwYiPmS9ImhpkLuqvX62J0aq1zqqdxz4+EDTPkCh0WsoQm0NTpLbRC0cNy05wDTiwW1YPHW4g0EEVLrQKCmsNYY+oiuDCOR1/Ckd2Z3XZ4hJmlaBCexq2FSeIwUWJNx3tAQrzv3XDY4Q9JeYpUItRC5MjQoaiAzhllgQZWDhyeo+/j3zIcyv0PJi4ANYFVY9DlYYc3gcExeJFaOqDEEF7PiU4llsU0TaFstOfkKTrQ+bnlznccdApjAGhFWacBp9MFYEZxAYqNSKxqiV0niGG4HTy6GRZOyfXGKeS1JzCU2bxKgrXDT1CRzEghimBHY4yyTmSdILHjVhYK5hQWcARVDgsMFZa1XNhZQz2MuwUu2bOVV51wUnS4Eyv8fN/SUgkeGp2TOQEWRGkLgJ37iJ0iShLvvvpuFhQXWrl3L2WefzQ033MD27ds7VtmTGTp4qBaZjxcSIHjDJmu4oL9O3VqKAtA2mIRUBbGRkjQJMG1jCddWk/Jc6lxv5ujXNleMj7FpZITNrcDuwjO7uMD540PUmiEyuYVAoTlLeZNWPaVQxRgLPiMpCrb0D5c9EMp2SBpAhNTEzOFhrzRaGa5svUuIpCgngu6FFh7/Fz9AmUQYmQENZcVA8GgS69JdOemqD5w3OsZ4vU4Qj7USwyUS3fZauvGDhRAUrGUK4ZARMgyihpaEsr88YAxWLN4nTIZArhYXHG2bx/JEAw3nMBrJpX787Au5/oGd3LwwWwqni0jiBLCSVNpHnYfoTbIS/6VeSMXQSgLztcCwtWzVhEa+gLcWk0e2QlOy4HmNiltOpGnOq3CVp6yLL9fvQpGgODHM+zZ5M7DZNlCJlqnBkBErKRJrSFVJRMgcFAQGFdDAHI/PorVS8jViqAGv2rKVra2p2CVSBVEFfAzFdCL4oYyAGDJVcpswk9Z4QD1LZUUC1TgGcpQZVZaANsrdC3Ps3f49Ro3ix1bhjCUPhpnmAsMDCdZZxFlElQsl5Zwzzudf9+5iX97k2QPD6FJRVUTjAsfpVfno8ESN3R8GPCWVAaDTnOgzn/kMZ5xxBs985jMZGhpiz549fOpTn2L//v0r08XuMWBFS9+oqIWF/uDp90tYFQKGIKF08XuwgXMbDTb1DfD52UnmNDDkPSNFmwtNjb6QsS2tcbodIluY5x4T8Cguh0IC1iiiSu49S6GgcA0KFbxXAh7jYZiUggKpuiNYg4aAU0NhNDaU8TlQJs4Re6idSMJQN7HUinhgjIAqVoU+IrnQqE1wIYZIGhroC4pogUXZOjjCWIAlbccGLV475AQexRshl9jZsTAwV68zA6CRQKtlYwx8IBfECnPWsjDYx15nmSpyNO1j0RckSWQxrEvsCbG53sezG8PsHxjk9oVZsjJH/0TRnYOz0u9SRa9c9WqwajBqyVykze0LMJhFoqUlC8ZaHILtRO8jIYECgUgOlJuYoOqDdpwQhcZmR0GVeZ/j8xzRNLJFi4DEKpFEI4PhelOj7j1GPDVVzu8fot9ZvjozfUIc+93NtVZi7JpC6asnXDQ0zCZpR8VJqhCT4oTSM6ClIiAUCm3vyYzw3UP7uW1uisJCfwG+rOJSVYqgZBpo+4KWBvYFT7O1yEWNfkQcrcQwMdzPwsIcQ75gyDkS67Bp4LTEcXp9kPbqtVxzcDfrm02yLOBKz5vxMfR4IorWis8LP4R4SioDVQ9wVWVhYYFbb72Vm2+++UFutyqh8MnuTeCcI8/zFZtI2xLdq0YCQk6CxZS93JNcEApSB88cHOHKtWdy0/ws8z5DJNCqFZzpBgluDoIy4mvMDNSZabVxanC5UlhwJhLkeA0Ea2gHjxqDmMgqmKhBi0DThpiIJYa5ZhOSOkYMucRaZ9EYM1QLlGQkJ4KKXGTFXniN7uQayvqkxvrBflZ5aHggeAaM49zRUW6dm0YKZTTzjIjBJsKZaZ3E+9KFLZgkIYiyFGIb10yF7+89zGxekKjDB6XtYqe9gULAGe5vLfHlPTu5s2jzbKPkRmi2c+qujlVlIEmwwCoR1jbbjBTRi5OpRnPuBJMIjTGdCp2VInXqPLqunAFT1nQGtZiguCIuzDYYChcd+nVjceIRtMzDqDwwcd/cwJJVWkaJhXGCorRUyS1QQKu8J1vWxgeBgxMTDIyP0wiGM2p9JI0BhspmPwMBnj++ng0Dfdw0O8PCCcikym1aCa+lUFI7F4HhdsFQEfBOS5ZSgIC11c9VvC72aWgHT24N9xYZk1pgrFAvogzTJCGESI4VgpIXik8MC05YRGiJATHcvzDN1wtgYZqXrRplzCakCq3QpuE8Y+0lXrJqnEQXGPct5hT6FGZs7DdRC0rzRO6/nBdWsm/JDxuekjkDEF143vuO1W2t7bxc3S2Iq8/utsbL/8GRSa87+bDKP3isC83j1TkxJvhUEdUSxmKs4WwRNgqI8VhNCOqoUWDF4zWN5UUas9wHAgyEwECZwBYwqHGItGhjMCYhSJtaWqMdSovFOFwQUg+tVLDGM2BHmPQJe6Tgu81FWj6lCAXeWVpGyIuMae+5fWqSxHuGvMcaxQYld/E6qnriEy0jeiztix8sW8CBxeGwMYvdgEhSZpEJYHnuqg285YytnJHEojcrwjA5Lz59Paf39+NwJKK0WCLFs2mkn9REZUyCobBDbG/mXD8zy31Zm904vrT/ENNBKbSfloUaOSYoS6afLCQcaLX4Pw/sZLLZJhdP5gL9zZxGEHIj1EvL16DYsITXIjZWigI5IdnC0Y2KHhMEBButDhvlaoBBgS3GMFBmuVux1DAkwWJVUCu0k4LMKG3jSENBSuR28KS4YBnQnD6NzaOUNplzfG+pySGNeS0epaaxxeCiEMmwAHWWtqtRUKctjrZmqGaYYJnTBjfPzrJoPAnC89auZ4soQ83AqiywyRjWFwWj8tAZ7535QiJvRyPeeiTasRaMRHmcaOWTVPJNgZQakbgJcYCLyXiqGO/xGOpBqWlOvypCSg2L9YILBYXNKSQhYFnSAsTQDpFq0XjtUIonSZ1Fk9LKcwoULwkZI/EVcQHRgA2WuxYW+Le9D7BPDN42GLbKgIGBwtIwDi9thltLvGhsnDXO0RcKni6GC0Jk4syMKZVDS9WUq5MBI5VsHxwmrHCi80JHxKeQV+Epqwx0Z+gPDw8zMjICQL1e5+yzzz7mPv39/axatYr+/n6cc1hrGRwcZNWqVTQaDZxzRykFlUfhsVYnVNdYHbdb+Xg0OKIMOIQ4oWIMqYHXbz6N15y2ARdy+uwgElJq4gFP0BRxkXs91egebDslkejuNjhM4TDSJgk1XO7AFdi8wHgFDeRGsGrxWJpJdCQdKhx3NZVdrYz/vW8Pd9t+7k8N39c296K0Asy5GvehDCUJm+t1Uo00s21jGCpL60DLzPfHjqqFdaW4PVrYMmsdGymTE7H0C6wWoa4GiyWgZAjrjOGcxQU2NCzBEuPaIWd90WbYGHJS2hpoNyxZUGreo3kkb2nVUnYGxz8eOsw/HTzMbOKYD4ZJoI1lMqQ0U4f1GYXCHQEeAJaCMp0QiW6KuHgkXmOzHQN1fLRojVC4Ngt4Co3LlPW+jA8/diRJckJjt0xZi2ps+XgSLGcPDvD/XPw0Lu4bYCzEsljEYNREAiIjpBKIqpSl7jNqGvAmAAmiQp029VzxBtR6JlotPvXAbg6FIvaBkNi1M3ilpfFaFJgInrvFsCNY9qmQ4Umc0JaUnSbhZhG8c2gIjGct1kgLp4GNJLz5vDM4f7CfkLUe0qvVWXzKxlMOyjI+AWMRiY17nD1iaDy2Bas0ZHAICauNMCpCorHlU6jCLsZQpDVqeWAgZIxqwHpHKo6Y1hcoJMeXTbSbWuA0Jh2bAOKJSa3A3lbGfc5xyOfMa2C/hx1zElt7UnZBVWHWOCYUpoPBS8K4DUhoU28qQ65OVjYzG2pDo4C1g3V+/pyt/Oq5F3J2vS92WC2VAelSBjrNpTi+3B4vj+GppAw8JcMEy7Fq1Sre8Y538IUvfIHLL7+cm2++mR07dhy1jXOOt7/97QwMDNDX18ef//mfMzAwwM///M9TFAXf+MY3+OxnP9vxKlSu0SpGBhwVduj+PCpLvPy5+7Pbuur+23J0d1js3p8yptfxpgYQY7Hes65/iLTdpE+jG95CZHIrM30KArkN2Ng8DxcKhlAGgMRZCguDuUFKTTs3gUwCTTzGCMEFiiDMpxZRw2II/M2+HewIAQnCzizjv+66jUHJOeQDG53jVzdsJtc0cuYbS+oDoShQNXirqDFUU0dUdB7sgj6WHJfLrpJtJd9q0XqoYx1L1gbBBmgXMUZp1fOskSEuXbuaT+x4gD1FpEQRARVPzQbWNmqkGrkXCgEJQhqUggDiaBaBQlIGQ0piDIac7c1ZPrZ3JzfnC+QG8hAYIVADZkObL++5k/VbT2NRhLbAvz1wB87ClPeIhXkDhToICQuDdQaARqEkvnSRl8rQkfus6hUejOUyPB5OhI7YAFajC9rHXpmIWhJSRjFsI+FnN23hm/NT/MP+A7StkomnkOiOH29CXWPJpvMwisGqx5uAd5YajkQNC4XSrjkym5Krdjpx5kaYs4Z2kKj8qmMJuOHQQXZNTZR5H4Gr1w3hJeWW5jT/MHGYVgiYLHJJ9BnFjvYznxeskpRtGGpB6Etqx5w8j3pvQ6xKaGqICksQUBubIQFFODInPJbuqknlAcJTF+HHtpzJoeYi1++dYgoliKFm4viIvB+ebaNDDLiUWjsnMRrzV0xUTlRjQmYI0DYJwRi0TOZTgSI13LDvfu48uI/7g8cE+Jf772YmxEZIBAhWaFqlFQrUCkURWKspzxodpqkZRgx9Nom9PaqMQQxOlbFaDSd9jFpLmkERAgFPnNX0SMSr0rWOMSd041ihrYeS86M5xg8rfiiUgQceeIDbb7+d3/u93+Pf//3f+fKXv/ygbYwx/M3f/A1ZlvGe97yHTZs28YxnPIMvfOEL3HzzzXzgAx/g2muvpdlsUqvVGB0dZWxsjKIojvISOOce9FkNmOWDs9qm0lC7B1y3ItH9e5UY2SmTlJh2H1/YuCBbjaVUToR6EMbEMShC3RhEPQSlbqM15k1sdtPIY3ngQJ5z6ZrV5AuLNIilUzZEwpbYQEcpNCeox6nFeI8Lkde2VjjaYrg95BxAcJIyJ8L3g9IIBYs1oalK0DpFrjS1IASPDVFL977Al12SjDWItzgRvBSdhaySR7csuj+7t+n+jMf3x1TUuretZN15dl5JEAoNBAvGKxc1BnluMsiXUfZaRUIsdbMmYCkYNXFRqhY5V0DdB4wLFCLsbhV86/BhXrL1Aobzgn4v3EfBzdkScy7BmMjM5sqywwy4s1hipgjkaQ2PYb9CZnzp9hWCURbSGoedBamhhZIqJCHmCCQIoYjtfEVM5PkPcSFWjozJ5bk0cGzrqpJX1QSqe5/jKWjVviEEEhPLA5tq8M4RCW4SCh8YDIFVrSU2akruGvyrjfIzEvBOSBGSYFhylpYTBtSwpn8AQyA3SssKaR5z4WddwrRLmSyrAKD0YhgbPWpFKJPnHJlJOCg5EyHDiWEgeFomZVFq7JIlbsmarEkSUEeqnuALglNyp/RngXGfElRo25JDTwRTjr1qDDrnCD6QiCG3SmHL2n6JFSOJWrwFMSaSAFV5C13v/vJxvlzeMalVMUZohUgU9syBUfaq8B0mmHaRWKzfRrbMJMRwzLgIrohhptMGB3EiqIfExioCDyyocKhWYx6wVsgDeGtRZzhceOZ9RuZi34HbQ5u2SVAMqSeW3Np4P0FilcJIBkl9kFmTYQUaIRopQSxBot1vgpJkBUNWOQ3HaOmNmHMxvCLBEvBYI+AFsY7gs84c2+0VrMZ4Ne/aYzyfKoywXBle/m70PANPMZx//vmsXr2aN7zhDVx55ZVcffXVfPSjHz1qmzzP8d5z7rnnMjY2xq5du7jqqqv4yle+wsLCAq1Wi3q9zvz8PBs3buSVr3wlY2NjnUW9GhRJkjzo81jZ1iGEzn5JknRCBXDEO9D94i9PduwoCRITAzOTYIPDaEEqQhYS+hCSwpMGGEoS6kmccPutYcBYEuNADFaUtQg1MYz4gstWr6VtZhjJAymxnAjrkFBgVElUSL3S7yz14EhCwWg7JhLOOaWVGCRJ8ZniTEIhBuMLqBnwjtSlqGQURnBGKdRQhEDDWVSUJHEkiUNNLU6Y2kLM0RNg98vb/XmsF9g515HdcqWgwnJlQCR2OywIGCM4yQmJxWWBcR9Y3czpN4JzFgpLTQTnwOFJ8sBiasidkgbHIMKZ9RrbiwJ1cK96vp61yaYOc7aBSwcS2urApjRcncK2aCeOWQxaduabEk+BgQL6XIpSgz4PrQxroZYV3DI/RTNb4rL+QTQIYj0150itJbU2NopKHEm8UIyPFmhYtmB3j7WHUmS7lYEqpHYsr9VyZaAay/F5GQSPqMWmDpcV1F1KVhSkzpCKp8+3WJXn1I2lHmJoZjEBnwizdeGuxVmKIFxSr1E3KV4zFtWzf3GBbWmNlhhumpnnB3mblqRMC5h6QgzwWBIfOyBaA8ZJVJJMSiggGEdWNMlrDWbTlO0zM/jEEqyjmdQpMk+igcTnkVlTAhI8NjiWxFM4SyIGU+YrVYuPcw4vBak6SJQgSn8QWiZmzqYI7STS7FkxnT4rx1NkHyTvEMN4xsWKnFQMg62M8dyTGsE2HM4bRqylIULNCIgy6CPhbwNhc9pHXx4w3iEKhQ20jPJAUfDFQwe4e2EWcQk2BKxNaQO2XiMUAWtj2WvbNQlJP/XmAgNiSORIUrFJLCGJHqvBHCbq0CKUi3t8F6tSRQMkXkm1YEv/IOfmS8yg3OEUIcHmhsLkODGx4sM5vByZY5crA5USYK3tzL3dz6fyJi4P03QbZdXfTxWF4IdCGbj99tu59957SdOUz372s9RqtaP+Xj3Qc845hze+8Y18+MMfZmZmhv3797N161amp6ep1+s0m02cczzwwAP85V/+JevXr+enf/qnabfbncFSZacu/zwWqm6FrVbrhKoJLDH5qQgFsadYJMHJNC8z3YVQFBRaEIgDvcgD6j3qYlnc1sYQNRdoaMZYZtiUKy4vML6gsIZWCHHSVCEvlKVWxlK9n1m1tBNhoB2Y7U/4weQErbYnay+hFqTdouxygGSgNWGpYdkzNctCFoleFq1Q5J5RNThrEQ1kzYw2gRwhRB64h5Tf8s/lMMbQbDajlZ1lj1iu8Xgm8p4ZRX2Tto+lfUY96gPtIjbAsSKgBSZAjYTtiwuYoQHO9An9RcYz16zm23OzGA0cdpbb84y7d9/D8/r6OG/wDLJ2jhYZtUIoTMF9WY4Vw0SRkyWWWR8AR6JKlrfjc5xr4bUAC/05fHdqktsFnrH1IoIo2ALNA77wFBpL5wofyLI2mRfEn2hGRnx38jx/VHI9Il/iLC8ZElqMe0VEOeBziqJBJj7yKkggb+WkOFyIfACKMt1v+cIDh8koOH3zaYzaGhkw6z075hfZNhaTLne023xpepoCOGQgBCAYDi82mR9JmC08C6o0s2YsoQuCDYondthcyDKm+z27FxfJfKCZFOwoWow36gy3SpbJIqMlAeMsjULIjLJQeNr64Pe/GqeBSHk8AGw0jvtCm6bmoIYsBGxiCBq3f0xlm0awueItNMVET5MvWAoFee6hrQwNjlDzsWzPSyDxUBhAPf3tPDZqwkIIZLaglaTcn2V894FdzKNkpSe/ICYVZhp5TRRLG0ewObSbhDwjQyhcgg9KlhXkbc8sBYeTwJrg0CKjHQJBEozGVsdILOcUhEQDJmuzOkl4ybZt3D83zw/23YMvCvBCbj2Fxj4WPs8B/5BzQjXn53n+oNLuh9rnQeJ9kqvQnmg8ZRMIuzE8PMyv//qv85GPfIT/+T//Jz/+4z/+oG2SJOH9738/AwMD/NRP/RRbtmzhi1/8Is9//vN53/vexzXXXEOr1ToqA7XbEnoy0X32qkmKr+pwDSQmDlx1EjOmTUnnqlL22VEahSfFU0iGCxmr1DJAuTBLQJ1FjEVVyI1jzlp2tFrclhg+PT3NbfU+blTPZ/bvo62Ryx2IncnKNECnwoJXtrucm/MlljA0bY3vTkzw/UOHIUmh8DS0zKYmcGJNYLtk9FifkZTXoJGcJkUw9ZS2NSTOoWUTIouSGBMz3YNl+8Iif3f33Rz2AQk56yRwtsIqVVo+0MYwhWEaIU9SQvDl/eZIUL5wz24+s/M+2jhQiXz4pZW+ROz9UCvzAQiQYZgzwqQT7l6ap+mEYBVrBCuGRGPZmDVV8djjF+c8sfEfSwUb3vOKzZt55TnnUC9L2bx1qBFyFxP7EhGCFWpFYG0RUBUOinDYB7w4VA1ta5gzhklj8RjUGiZ8wYSBaSIREwAKt87Nc327xR0hMFPJo2QkjHn+kXzI+LJuHsjFMuED/+fu27m2OclkLcUHx5IPZEl0gecmUFOoHet2u1BIwKCc1ejjbRddyuaBYWIbnjgWThgS+2KYUL2L0aPiBSRXEmB9Xx99BkzwFDbSLQcx5EYQ8bQdtK2hECjwqAhLKkzZhEyEih04MjMGyhZYSNmay3qFIhCAtgiFMRQmsmjGZMTArtSzYA1SCEENubHYMsm18gxATD6saaDfwlqxrPUW8ZELIVJ+d278kYnnFLHoHy/8UHgGLr74Yr7zne8A8IlPfIIf/dEfPervlYb3C7/wCx3X6NLSEnme8wd/8AeIyFHlh90uz26l4MmCwJE3RqJCUJGrxDIli1iL2nIiMAYjobRmwWuBkZRglUXNyBEaaUpRLoSdxDOF2Xabxf5BDlrDXZMH2T0zwVRRsG5ykgmr7AkxZNEfhMznqFMKAwseghomisBH7ridzHvW2BqLST/7QmCoXieXGL+shUCDyFxWlJOircIDj9F78pjJRarJrrR4+o1gS471ukux7TY5ZWKmtRDAYzkgcKfPOZC3OT0JDIXAy8Y3sDkd4I75g9RL0lorBkyCoiwJ5BQENRwyShFSVAMETxIi+10msVVvsAGbR9KoEGDJWBChCDlfPrCbF5xxJuslkJjYHCrVaGhZka45s4wtn6BsO3i0OobETHenwqAqF9bqZNbQIE48phDSouykWVZEtK0wEhwvHFmH1xRUyLMCaUOhnjnbZsIUTIYYVrFBmctyMqkKzwoIICrsF+UjD+wiVcO8CqKRBjsQXfdqldQT/2nJWuggE8OdWUZz9/0MrhZ+dGCYu2YX2VjvZzBAYZRBD/0Pd/8mVjOsMY5zpc6wsSXZ0ePRojfezwCephokaMwNSR3WWBo+NiFb7SzOF1iBpilbB4shWCW3niUHaWFIsxi2NGUiraoDCbFxU9mTQ4nKVmQPDZG/RJVCfWxk5KCpnkULTRQrhqlWxjX7HuD0jVswLcEbyI2j7qNiAdEzoFLWeviCmi8w7YwxsSVrpOCIeUtHeMx7eLzxlFYGqtjv/Pw8zjmWlpZ49atfzczMzFHbee8JITA7O/ug2NvCwkLnWBWqxb+7pOqEMko7lUZxci69YygxU5qy0190vx1p6avl7xBT1dT4MsAW+WpruVIrChouiTz1QagFC9SwZoHgFhGt0SKQSuwXoCZFMAxTkJlAMJZaLjRrLaaw/M3BCab7cu6Ym2GWQCsPtID9eZu8ADUWNHKUU1qtiJSO/pjweKBd0LKBYavUikhiMtlXZ64+xMDsAhcP9vH2/vXctxT49NRBRIRnDw8y7mp8ceIw85hyIoolRMGEIyZEVVVU/m4exkqo/qrVL0e5WaISgJQd6DR2JUyNYNShmDLhMWbFJyhtF6lV8wVh2gcmTYHXnIHguHB8DNu05N6Qi48JmRowQah7Fy03IhdQdLrnJAg50Wpr2xoN70mMgs3wRZUoFm9YQ8yH26eee2sJg4mj3ypPryWMi6BFgtgkMvIFg6glNZ6rxtayv9XkzvlZ5uPdEIwD2g9roKqUY1COlXEtRFXKdwlbSnrgQNBo6asGBoMh9R5TdqRLiK2XQ7AYa6lp9Gal3tGngcbIIDNtj4TAAoZca+xfavLpuQPsdYYRGxWFBTXMB8WEyDqIj3S7Qszg3xtybIiJniXFz5GlxES+i6WkwVwyWN6CR8WTAfdnnoPqmXIFN+cZa+wG0rxFLk2cVNUEDnEW1QLUQ6g4BaJyjEAtBGrFEqnGcVxIqXwGUAw5Et9pcSQhYyQo09ZRdBZd6PB2V3OHhdNM4MVr1nPz5DR7NCNRzxZX49yBIb47O01dYNw5chGMSVA8uTE0ciGzlmACjVxJC5hJhIVcMWrKnhs5lApG2VLs6CVYFNVQZvhHzwAK+1tNPvLA/dzVbJL7GEK5YW6BK9blnEGgMMo0hm8uLfCMwT76xeFRClEkgHWG04ylFXJmyOgL0DIJhe+UTiCEMvxE5PZWiSVWtvTkFoLl5Gtlf7LjKakMdFuAzjm2b98OwE033cR5553X+b0b3QOj2/KvcCzr/1jbPRZoFXooF7FqsvBVvaApX7VQLW1lBnjlTiXmCEC0YLxaPMqgQkNjEqBBqAfFeTBSw8kcmjTx7T5ahZKkYNRAkVAXQcjJbMk1oIbMLDLhHV/PcnY1Z/ESJ/ilWHQUmxIp4GOQohNB9tWziIuCamQQ8xIN0z6fE0Lg+xNT2PmMF9UHOGe0zulugNtt4ItTB1HgytXjbE0G+N70NPNl44J4ZgMajihQWsqx4x05PrnI0RPY0X8wGl8AFUshDq8ZKTAShH6x1MREzqEgpKL0qSWUrZ+FQFuVmSLDpjUchnnfwrtBFoBMAg4hJ9C0CV5jwqloVCxyQDRDiMQumYEpY1kXXGw8pYFcDKHsimg1elG8KksK1+3fixtZzbkjw7xwfIww3yRx/QSZjC5VjW7aPgm8du1Gvr8wy73zs8yV94MmGGk/rLNa9Uggp6NQHSVcW47Q8rmEyA4oxNwLQkGwSuGhlTqSkMccGOcIxoOrkbYzLuyvM24NA5mQuMCSCZjCkasyo0LLWBad4bqlNofEc9XoKGoMd8zPsr/Ij1yYVrFPjV4crYJYxdH3WiqyHvje5DS7FwsWfCgH2JFxY8WypIF9Wcac6WO1KchYIhNLDagbyLwHe2RchgCiBg0mVhIQwLRjTFwNwQWMj3TSoRwUqgImYZiCS+uWbxYwGVc76kCuUNg4ZmtqSILykrFBXrduPRSGB2b24cnZGGr8yPAYk80FVieGcQ9Sd+S+iBn5ItQDZKXffSBTEu85XAuEPDbGKkQxPj+2ErBMiFn3l0Xs1/D5w4eB6GnLgYPeMxmUM0PsqHk4BK6dm2HrUD9DCqEkhlIxBA2MOEvbKg2Tc0YtZUdbaaKdZ9NR5zTK2RCV1FDOEZHp9MTn7VMNT3llYOvWrbzrXe9ibm6u49YfGxvjX//1X5/EKzwaSeLI8wzvFYx0kr067Nsa431ZySV35IXTqjobiIpviqABkixwtnOxFMsoNSJlMFYYcIakrYjE/gQ+92hNUfUkamNHwcTFBjtqmAkBVUtWBIrO5P9oX6RQWt6RdIQQ6WELcbQQ7llqsrDUZNuWITaamMDlnEUMSFBqicMBqbWdxDdfzti2S4FSoAilq7JMPqrK3x7y5S93lHDElpWuf6Gsr66psjlxbJCEAa+MGUutiBNazRoGTQOX+5ibofH7vc2CxYHV1LJFnA1kNscXObWyw9HBPOd7S/Pc01rCw1GN7lQoZRUXrntaC0yp0FbQPE5uamI9uify6eOg6eHm6TnWmJRtQ4Oc02hwuJ2Ta5uygWJclFTo19jZz5tIGlOFmaTM+8g4Pge8tRYjQtByMn4QyhK7cgjE7IrYb8LhGVRlRCxDVlnyBePlWM4SQ1uEhhZstjVev+1CwuwsNV8geBIfF9VW2c3KS8GiyZmRSCVsFJYMfHf6EBMEcmM7GeqV9fywQzhEmdzenOaOxUmWoGPh5lHUBByZT5jJPbvyRVZbw4DWqOee81yCoCx5j8WxOwSWTKnGW9ORjZWozNWIil2o8n6siW94ABsCqgVn9Td4w7lnM3vHvXynuUhulM2S0qbgAevREMmnLh5axSvWbWZ1s2BVo4HOQstZXGHYkhX8hw0bWT3Uz6qpRVxRIM5ggifxsT32UloqpTbggtJfFBTBk/tALYDFVPb+o0a3A88RDRhUyKueBd7T9jmJ5iQ+ehg0ULaOjlVLbSOcObKKH+8b4S/u+AFLoh3NJJTPzmKwZVYUKOKr9ztSS1dVGj2l4JHhKakMVKUfELP5q/K9a6+9lt27d3Po0KEn+QqPRl7knditL9+UyktgFEZ9dB3OCaipZus498aSXaXQ2A0ww2AIXDg0xOvP2MLqkLNUeDYA/b4An3P24CCHFw5SK0xUJgIxWz4EkEacUIzHipLh+EFrmvWJIwvaaflCPO0jQJz+O1aEgTxUC6+w6BIWRJgTKBQm0xh0THwgFRsnCsCFWP1gg+I4QnQCgaAGjTZ0ZG5DIy+AKWXjj9MIqut2DILpOIurqTqgEkiCZxB47oaNrDMpaRG4aMM6+hammA6KNZaaq2GzNiFEC8YDX5uc5Bkj47wgqdHXWowB6LKkryWw2xf8wx230VKlcLGmujtp0gNGo5v5y/fvpEYkcDEl2U61sqmWJq+N1u58gP0IqsJaSWkMD6PWkxqlTlzslRh6Egs1DfQRiWrm1JM/QmXPF74sY6OTg3C0fI8otNETYuLqF+K5RgXecdZWWvMZDevwZXzZITRyAeMZDwkhMzQLwZqC3BRx8dCYSJkQAE/bxHp/JO7vXcKkFrHPQChlJF3KycMkOUgAL8KMrd47OopZEGgauC1bZCgd5u6iYN8dtzG+YTPPqvex1Vj+n7PPZ29N2PnAXjavO4s/v+c2trfmSTC0iRweBI+lhvNKreO1iGM7V6UKsVhiM7BxZ1irntOc4RYNBKNcvfVCFman+LuD97JY3tv6tMaGAvp8mwEDNQ+IIRQZz+gbQJMMzZTcGIyNjvzEKzUPLVcqKQEKIxRWSYNirGVJPKgQsESV6LEtpKXjBUtcZNouZbYm3N2cZiqxLJTP1fhYpWBC9aqWz9Aa+to5W9uGMRGm8GXPijhXUr4fQohpyGXoxRArPVQCaVkJcMJh3lMET0llAOjU4e7cuZPf+I3fYNu2bbzpTW9iYmKCD33oQ0/25R0F6yxFRoxJY1EHiEc89Cu8ZNVqTF+df9+zmyWNJU9qooswLSJb4AzQdJZMBKs5I86xWQ21Vo64hFes28CZaUJD4cKBIRb6hxgsElxQmuIoVLGiLEoKYmjQxhOYS2rscZa1pAQJ0XosF6DYv+BhJlQo3fmUyVkBFYtRIQuBiTRhyUT63maApkJaEPMbVBkSwarS8IHExNBIObfHCES5EKoIoaRHdcHjiEqHGjr1w8d84fXIdSoSZUtUjpAy9kj0KDkRRqwjydsY5xhv1OkzhlnrwQgmjeVRIB0vw/0+8H/33sfFZ26hzxiaNcesj2EUn8TujHuyskteMFg1MZu843+NHgCHYUIrk/aIQlidRynDxkX8zIB5MWTGUiuUwdTRltgHYhyYR1kqQy2ZFvQHzyXDI2wcH+Hf79vD/qC0usL9cOxJ01lLUX3/EJ6BKm3AYfASqxxqqqxW+JHREV6IZSKps6+ABGUEGM099UzxaYCQsyq3TLVb+IGU3AZQS2ai4pTGJxQraCSGu4wY2saxUID1YMtR06b0GnViGg89dm2pTHmICkwR8zMMUXENVvnK9D7unp3kfokVBDtE2Jb0M9pucVrWYliFtY0aw3lgfVrjjvYSKZbc5wRiflDdCK4c11KFBiVyDAi2E3ILoUBNDdU2jYYjXwg4I5wTlDWNVexfV/CFvbvJBBINOKsEV9DfbLNJYSiL1nLDKpYM9TBjlWnfpM8mpJRkUCr05YEkGDLrmEuFPFgOGc9uX9AUxUu3h/KxobACPioeBw1YJ/x/9x/kkN9Pf83RNo5FBJfUaBpPzUcFwYYcKTy1rGB9blmtgT0ax7wlKgOi4AgMouQCiwZ8ELxasB6xgjU9z8CjwVNWGYCY4Dc0NMSLX/xiLrzwQu6//35uuOGGx0TtuZIoQoylR6tQOnz8TmHcOl42toG87vjG3t1kGpu25KX9uCpJeemaTVxzaDf3iQcRTK401NPXblNTIXjl6X0DDBRtCJ5NBlqjY/TlBrEwKcJqG7PRb5mdYbGd8fyxBh7l21OHuXHyEBdvOou2b8bJlsgeFvN35Xi3RmXbKDFW1y49H0Yth1ot/vWOm9nVWkDLcKwVS1JEI9MEZa1xPG18lM01ixYBlyRokXfcvAaoqdIy0T0fCoMPsTTRAD6U1utDvPCVNyFU91KGMgwBJzEWq6VGUyjUrWDE09SCPixjqswHpW4gNYpK5LwPnRCO5bD3LCWWPbnn4/fu4HtLTQpJIMQEqtyUMgwx+amolK1SgtW1BYlfmqL0WmhUeqSUsVdie1dVglh2Tk9yc2I5fWg1iWYURc6ZxvKKDafx+fk57l5YwCIECYwKnN/o55LhtXzT7OOgerzT0hCTDgnWcviitK4AljMNAmjMBK9CD+BBPeuc4+p1m3l2f4O12TxzwZDSz4bM87rxVWxIGqhVCjw2SUA9oWjjrSvj6ELLGlRjmCxLEzS0Y16NCguqTNSSmIwXIBXBE2hXou4kljw04tsYx1D1fErnS3wmBSyocm+R07axr8fnJw8xNz/Pj61dwwZVnGakto2XFm0TaNnI9eBEqZVjfsC52PXTyBHVRCMPRDkc43ukGitsnBCS2BNjVQ6j2SJn0Mdz66v4Bns4IIpDaaFYU3B2f51XrFnP6kzBGgojeOsRLRAjTFNQI6UwlrkkZzBEdkfE8oCBHc0Wa4bH+Jd7buOQVxZFKTMyHzsE1BiCetoqfPm+nYwby51ZzqLAJlfnQGOA2SKjMdDP9vt3cVpS46L+IWoB6hqoizCoGVesWU2xsMjNCwuUcUXqKBcMjHDZ+DjzxSKfP3CQwwqCJfeRUMjbnmfg0eApqQx0U9ZecsklvPe97+Wmm24iTVN++qd/mnPOOYf/83/+z5N8lUdgbOS2t2Xdf2Vh1YENjQZnpXV2Fwu4xEKmWIRcIwnQpsFBrjztdL4/fZD72wusl5TT+wYZD4GGhZYPBGsZytpY4qRVL1oMW4Hc0EoC22en2NgYJTWW24sWh1qLXCwNklqNbx06yM6sjXMN8nazVFTi9R1/Kj2CQMzCTxSysl2vCswauGF+MnaaC9AAxCuKoWkDwQhr0xovXL+JNTrHlFEKqRSQuOitMo4L6g3uaC1yuOxvUKVWKoCJnhfJHvqFr1yWsZwiljWOW8v6Rp175+eZMmBKT5MJHpsYEE9fq8WlSY3xIuOMRp2hLCvrtaMD1RMtXSORR30uSfn8/CL7bQqaxFgtRHrWDj1w9GZUISKL0jZaLnK2TBoPaNnlsTLeq3k5SiZSGE+FwO1Zm5caQ4qh5nMuqPdx9qox9rh9HJyfY02tnzTEqpOh4BnPPCMmcv17L1TL0/IeGxWsNQRvCCae1+sRV0K1cGbVhWlApMBKYLOr85LR9YxnTUQOkpsEZYANts5PrF5f1rVnJAXkJnqU0nrsslkvhFwsTYFWUJpYZlJDsxkQD2ocdy/M86n77mRf1iaTmHB59Hh9+NFbUCoE4Ui0o5J1APoD5Bja1NDQIljP9tYiM1mbCzaMMWSE/gJczbCUFjGubQzeF2yuJYy6GnsXFhhKkpKKW6goioT/n70/DbLkus6z0WftvTPzDDX2PAHdGAiAAEFwAkeLEkUNtiRbVEiy+FmyIixL12Hfqz9XEQ7/tn/YIYd9v/gsWVLIlixTozXYGiyZgySKokCKE0gCIIix0d3oubqrq+pMmbn3XvfHznPqdKFHoLvRja4XqK7h5MmTuXMPa6/1rnclXYVEulx3ujhSmeZCLQtqeaSV0c49wQ9YLJvqjwKzCIW3WI3cmTnmduxgcdCnEptEfciJxtAJ8HIYgViWNfLVwVn+TmcrXbH0rOEzy0t8drXHzkHkLwclI41NNsHVi0ydB01qi5FAEOW53iqHVegbg2jkeH/A/zp2grA2oLXa5dnlM3zX3ju4s91lftjDqUElkHeFb53Zy+hMnyd7z1In85YCeGunyw/ObaNnZnjq9BnO+kBSN0zZTTbf9AxcDW5JY2BcQCjGyGOPPcZHPvIRYF1PYDAYvL4XuAEhxklM3Uy5gK1CV5VcayRXqsxS1jVOFW2U8GaisrWu6RihHeG9c4t83z1v4syhp4ihpspTudeZqibYVIe85WvyLEXXqzxy3CjeOBThRAicFCiNoVeWPD/ssypQe6XyIRHFznOtXsFAMmmHZZsFLoy/RDnrQJzFlMm1GetAnTt6TqlF6IqwpayQeoBrz4A1hCa2b4jc3Z3nn97/MP/1G1+i3+/Rd+veiEZrZaqYzivdwuuGQPoyQenEyPv37OX9u/fx3x//AqX3dF1Grp525iDUiI1sMx1+7M4HOOGHzM4UbB/WZCESsuS58c0iFFCyAKZOaWJKDjG1SYvk1vcy5n+MuRDr8dTKNItByuNLrmSjWE0EQz+O2aAEVcQkHXlvYNkKAyNkAYoIO9Uw7JXs8JHt1nJfZ54trsVqck0BFa3ckZcjCmsJVhg0vJsLTpqN7G3HZdTBT/rxuEnt2OdtUoEbESVTOGCE7cMSIwHjlLyuiTFQO0s3VE3MN1AEw2qeMsQ6nW6S/o2puqV3whChh/L0uSVkVKFqCWo5FEYcO3WcykJoCVWZNrPjLjAOXV2q96pJr7uYnkNNIlqOz2EjVC6RCK034AMey0qE0cCTtdvMlh6b5ZyOKe7eqpWWCn/vjgNs7Szyv554nK5zGCOIazL2m0cRVAkaJoQ7C3RV6FSWueDYrpHvu+tNuNaQc3WNlMmXYUTZpo6F0mLEUIcRIQcrnmgybMjJQkFtPTPRUlUREcNZ8XwVz9syhw1w1glfWFnmi1UgG51mNc8hVmR1SkOuLtN+l4KQRLyk8dJWBny0RJLA1iBEPn7qFBnCaLgGomwd9Lh/bit3Y1j0EbGKd5GZ/oi9dSJfjsbPDmhZz9ZRn7bzOFVKA6qCaEpnDZucgavCLWkMABORoMFgwGAwOI85eqMfvKNxlTf+RauJmIQxk0UhusRKJpYYjYkpLTCroBrJA7Ricj2PHbNKOpetA0aT/sCsKHeFEQfm5pNugQQUT20tUQOzVaS0npZkVBloVVN6eCGO2JLNNH71RCD78toqx4YlmXMY20ZCka5VPEUT1m5WpEs3QOPmHNG8Jza7xwgY0OARMViFiorSZRgxtL3nDpMRMuGTp/q8t72DrhhinlykrSqyKyp7qorMJJW0lEO8rsWQYq9CgaU0kj7bJje884kfECVtv9TEpGIXHFtrYV9dU4rh7qLgx+7az+defhlwKYYvAeNHdKXNXNZibugxvmS1bfDBog1hK6jFxEhUZaDpusWXQDISKtJ6SmB9IR1nYjU/aqThk/hJsxFT2GK9jdd/8TE2XIomtOCSpPLMKJLjGHYi39md4a333kMrWuZjICPiTaS0lkWbkTPgO3bexc4i41defo5eVKw3tDQymPQ/h7EF22PgR++5h2dOL/PxpTOUkohlKV0y0cTUeipvaUXlu7fM8EN7dtHuR2wMqLapfIm2RwRb4GuDiwbN2qz6kswp3oPQYimtkiwYpZQelSoVkT8++HLjvneoRkrRxG9RoE6LakjpDE1/vJwp0LycuI6TZzF5i6b+HDTS5GEkA8YEqgBLUVApCDLCO+hEZU4lCQo52C0Zd3vDFmvY1WqR+4CTZGmIJiU+IzHF5iUDPDuJbCXS8hndaLirM8P96ljoe3rtnGHhqG3aGXdtjpUaxSJiKYJSWsXiqewIRYg2MnA51UAZznpKX7EalOO5pVtGSslYEWEkUGkydkwzX/kLcEWvDil7KTZkWrRJCWw2GxGh15A71BmMwN+eOctzZ8/y97tz/L+37gVjybzQjo7AkGiU4AIEw0gSIdqbmgFNJoIJKZSUJq5NBcKrxC0tR7xRO2Bce/1GwwBmzKSDqbrbKeO6UJ1MAFHG5USF2qRcXDGQ19AJSbBFm9hicqWmnaLV5mcJdPyQHVmBDUI7RNo+EowliCHTVI645QWxINayUlc8vbpKUEFDhBixOFacowK8KEeNckpTPFzNmLQFVxQ4bMZ4OTm6cbQmEnhaCDU2ugpKZQ1Hls+RR89OV3DOVzxeeYYVLEbFaiALni7KVgwultRj9yXrru3xZzsxOJIMr23cw2mnlf61klGooRWh0MR4nwkwW5UIcGee8X4XeKjbIhPHSBxr1iXjIQwxscKFklEWOWcjbWkncSdNJWpNVCqNDJyjVrBJpR1p2PXjRWbi7tf132vW/zhmD2jTduPfmFrkphcriSldr28NMQiDIudMy+FR7hXL2yTyQAa5r5hFmPWRTA07xLEowruKGb49a7E1joMPKfsEM/ZeWGJUusbwgVbBW8WR06gGGQEygiG5ZhvixQyGD8/PsldrPIE6Cwxch4ExCDVFgDw4nBpeLkv+bOk4VCVdHxGxHDWR3z35ModjBZrKUwvKaeAYEPCg9Xo7BBKpcqzq11hc2vx3uX47bmc/btqxK6kZbzEohDKdTSy4pKHxxNnTrESobGKvFxFmSOO7jJHCB7b5wNYiZ8YKNgRaYlIRIZ/CCXXj8xfNsQg/cMc+vmX7ArURNBMWCscCMF8JmTeQOYwkj4Vr5YwyTykWlRzr0/XFukRNSbCQh5jCHAEqq/SJPHtmjf/+/PMcrGtoFBmJkaAlhDpVRIWJ2NarRerN4xThcZsmPklsjIHJQ4gKwTBQw0GnHG5UVTVqki1WUBuYU2j5SB4T+dJFQ22gNJYcl/jAOs6HWi/Lvokrwy3rGZhGp9Phx37sx3jTm97E2toav/7rv86LL754wz5/eo4e05akURrsqDBbB8oA5VRC29gXaQDVQG4NBYJYSYuBTdvtKAqS+ANOU333LCaZU7RxjapS2oDPMo6ZyAwFWQjUVWS5XbBKJGhGIGMtBoZiUHJMTEzxHpHfOPQkQ18zanYEI9L4lcDlptQrgBBFKTXSIWMYhCfqig9klswZKh9Z8YGQCztFuKuuuGvrVoajPplNCoStpq28ESY8t8a1HmJSRJRocMhErC2iBJuqMM5ieGTLAmcGNS/0+rTUsxAC72i3yAhEX9FWpeMja7njcyeP8b4du9keU+xjzQln1fPyiVUent9G12QkffZGDUFj86xe647qyhGB58+t8ufmZT4yu5O/lVWeXjrKRxfuBKeIUfIqUubC7laHuRCYDYEH8ha9bodt5YjFzPHOvODYqCJoxoCI2tRPizogzR0qEYkewZOH1P88PnkpNDAXlECga3N2F7NoGBEdrBU1rVqwI0MrWopgcDGABI5LzZep+Yh1GF+n59YyPB5r7m3PUY561DE0Bub5KZmT53/DoFNeBzgTanzRwvQG5MFio3BnZ5aZ1bPkQCd4Oi2YdRbXOAlnNTIfU6hlTT2VAxcVozVbneW9na084CI9qanbSnckBBPxNqXezYTAlhgJEVwGa8bQzVvEUUkrs/iorJQ1M8UssQ60fKoisOYDrs7p4TkVlYODAQ/1+3xL0SXTVAo54Bmrn1qYTsm4bu05VltJA6ZZuCPUCANnEKNEExCp2GUi37t9K6dNzuOnTrESA8ak91uBTOz5z4qkX7CJK8cbwnR6z3veg3OOf/Nv/g2f+tSn+JEf+ZEb+vkTY0BplPJS/XKnyo4s59Edu9hthUz9JGsMTZW6BMWJ0o1woNNpCEJpe5JFyFGipJCIAwqT3hOFFD9UIQupQNFqZvj46VMcGVZY5wgifGltlaUQWMOw1OlyzntKYzhdFJwTSxSDB77UX+Gb5YDQBFJrk1L7XnMH0ZSG5yQZNl0K1rzhWExZwl1jiKr0CAwJPGgc35sv8NFdd/Bte/fispQz3DVQNIHV8+uIpZ1aLZGUJCaoOkQtUSLY5ACeEcP37b+Pd23dSUYkk0hHI9+6uJ23z82TWWGvy1nE8MKgz6dXBpwRm8IQJP2FkSs43Btxxhmq3CVVSGn281HHAmmv2MRfLyhwxge+2O9xsjPLl1T5s9VVzlqLR1LNAjGsxopZl3Ega5P7irdt3cpH9h1gJ5FZG/jQ7n20ESIGLxYS0RxHRJzBSeIjqE1yQg90ujzQzhFqRJSOwLu6s+x2lgxoVY2XQWGmisyXMOMNmVpqYxlmMMwDa1nkHMJIhNoEHIEiQE/hU0tn+eLacOJt0mmX7432/jaDQBQIKZVtgLBcZFQmQ9TgjbJv+3ZaKItZxmKekceKfXnOvCuQ4Lmv3eZ9s3O8faZDNwZcTCmHjppdzjHnlblRZLb2WGoWbDKAKuewQdjm4b2z89xlDPMtx8FyxAlfE3NHLUqlhpNR8eLoVSMGtqafeZakQqIwLCMxKkNgaDMQaSSiUpYLRic8nMRyvd5I5oDR5NkVUppoibCWpWRMGxWh5p52xg/tuZMf3n8ve/I8bY5oxMtUKIy56KDb5AtcGd4QxsDq6iqdToddu3axbds26rpm//79FEWBMea6hw4m9qcml2mavJLbZXu7xbfddTdvardpExFJRvc4bdsZg/E1i2J5x459uJC24i4qW0XYI4KIJzRaLtakYh+llUSeMkn/vTaRY37EJ1d7PLayzMDC6XrEHx06wjnv+Ua/x9/4IadCxUpd8YUw4isrK8k5HCxDkpuu0T6eyPRdC69ATiMuJEKUjIFts6pQKMwreBX6ITA0kffv3sc/vONuHqwq9kWlyC3Emnkx5GNXo4wnsOacJMGWTJJjUiWbaDWIQjQRi2dH6Vn0ASMKLrmfH+7O846tW7EK9y1sZd5anlhd48UYWdWkgph7pe0dkRYvZxmfjWs8Xa42WQHNLsQkT4Su3/YNMQiiMTxfl/x1HPLE8jlOqvL54TJDKzgf6dc1z66eIwhkXskMdKJny2jEjARiLNmittldgZHxPhxUIqXWtCN0a48Ultwa/sEd9/L9B+5O1TJV2VPkfPT+B3hkYYFMSLt/HP3hkFblaFWGIqRdXOmUkQMVQxYgw+KjkAGFj2hURhj+4vgx/s+Jl6lpwiXXpLjP1UHG/zTGuSF5+wKwXFV8aXWJM87SVzhWDVMfBBbynC2zHQqteEsxw6w4bAi8bXaeH7v3fr5/3x3sMYa5KrLPuCTDbATTMsQQaJeenXXNrpjSkFdNss525y2+f/+9fLDTYUEjf33yOF9eOsUwg55Ehs7xrEbWnOWcekYuUkrNSqypRBlFT0FKJVURRrnF2ySBbicuzXTTckMsLp0QJ8dSURZYKoccs4ZgCwq12BiY08CeQcm2UZUKywHONCnGIZBJU/lzjKkpf5M7cGV4QxgD/X6f/fv385M/+ZN8+MMfZuvWrfzET/wEW7duvbEdoYm9jveoANZX7FXl/XvuSMbAtAGrTdqsBJyvWWwmRatKG+GR+Tm+Y/8BnNZYkmu2bR2geJNkWWsRRlZQiQxFOAk8nztWnXI2VpxQZYDyVL/Prz75VZaqiuWq5Nef/BpfW10BIq24XjwpG08EDbM9vubmS7FkSTM6h+shh00qdZwpLBiDGkOvDqzVNTNEtoaSLaGk6wNWDAWwFUNHm1x2s55ih4FO5tgplhnGsW4BC22UO4JQxOTu7oSKtvrkBs1SWlfbV7Srkkwt7SBA4Bwh1RdoRI3UR3xtWLEFj5clv/zskzw9XElaCWNvgDbpea+1ua62ddVw3Nf86je/wqHls9TAZ9bOsKIBo1AWBWdcxtCm9MCIx0mgkwmzrQxxOXXwOAIzDNkrsL2Cnd4SDRhnaAt0IlhNVeoOlMp9mpFLmszvbre5O0b2xUhmBGMz1EdeGK3xTGY4kTlCy0HDpchUsENDN7axIrQkp6gtRi2DzNIzhh6WHusaFq/r3q4xCEzD3QjAyVDze888yddWlllBeH5tmRAqCmBOFedrbPQsVJpY9c6ytQ4cGJY8mBXsa7dZNI5/cs8j/L0Dd9N2gpiAWIfPDe9sz3IXjrrI+Nq5Zc4Zg0TP7trzPXfeybYs50RUzhjDyEBfK3oYHlte4aSvWRahig6rLfqVcqSIHMXTB2orPF/3OWgCZ2KqGDkpBihTRNfriiZYKuNYtRKMISIcLYd8bu0MLyP44HBiMSHQjZEsJsl0T+IKWU0egm5RTG0Q1vkim4bAleMNwRl49tln+Y//8T8yNzeHc44zZ85w9OhRQghYaycpJtcVU6MnQCoxENPi1R0M2JdldIHTU+yCJi0Z7xQfA3m0TW9OJLo9Wc72CJ0YmIuROWBBHFlIhkA6S3Lpd9KGmUoNL2ukcsKaeoZq8cYSjOcsSqvZ9JdG8BEISU64uaKJV8OEZBiUDbv7tWCsGOaB/338IAunj9G26fO2zc7wrEnSvpWCISLOo+KTspzJaEXlkZ37+PP+kOOSYsuTIS7KbF3zA3ffxzfPnOIzZ84ipOpobyo6/ODO/fz2kReJvqYlgW4mtMRQ2Bw05TxnMTHiJUI/86yFqskAULx4MtfiXNHmkyeP8HRd0bepyqENjUEiglhDNarX+QKN9+d6TkVpjQqEAlajsiUYvEROhLoR7LEMrWMolto4KlOTqaCNlkJeK0OfCi91IhyYneODO3Zy9NwSO7bt4edf+Aa+CtSSiHtbg7BFoeMrFqwwp4k0ui8vWCwH7HMZRoTgHBIMT8WSL774PH9/cScPzXeYl5p2qBnYjEGrzYmyJGji0ix3M0K0jVy0oKLn1XG44VbW9OfK2KRtPCZGGCqcROllOaUo53zNDoVZscyo0A2JOpfGmqVvhM6wYk5TlcZW4XB1zZtqZS5r4SWRL2sCfQdbakNsdflGv8cfnjjJu6rA9+zYx2xdskikHz0rUSlNYs2P6hqTW5YRfNbiLFBkXQpZ4KUAv3LoIMdGI5YlzQefP3Oapd4aR+oaL0JLhfHAumGR9uYBm+afIIpRywqePzp2mFOu4Cd33MnWzBKbcskqqTKqBZwVRCO5EeY6bey5aZnxVMDsVZc2vw3xhjAG3vKWt/CTP/mTHDp0iBACzz//PIcPH0ZE8N7f4AyD9ZkjVSxV2kGZ8YFCJAkPjWc5SZ6ByikSY5JFb+RxQZCypq1K2yv3zi1QtWbZJo6Wn3DnMCoEEWZrIQecWg4ur7CyY54BQtCcQIkjx8fICE+qG+6wMVKTJnu1EJpa5pgkF9xCmuI2+uq3CiIEm0h/CrxkPa0q8HCnS+2SW7Rqpp8QU4352qW6A7ESMnHYOrC3u8h8q4UM18VQ0hBXdknGO7JZWtvgb8+cSepsUbm3NcOH29t4jJeI7YwiVnSMMCdCRzJMNARJAsW2yQ6oTGAUPFYF8QFTCD0f+cTxl/jU2hlWrCDeNIJBYzVBgzeGQV2z0Zl9Q3ZYmjwEHiEYoaprRhoZoZzq96jKmoChFkMe0ntqjWRBqCXHm5K2Kg/Oz/GBrM2pzhxdM0MbQaIhdAKVVe4p5rirMwCrzGSGt2/Zxl8unWaLtRR1ye5OB9PrEZzFRMtSDl+pK95vDTPGYaPgVFlqG/7PkaM8trJKJ89Zagl/u3Scu/Mt7PBzzAbA+CZ98+K3fUOg698mEQOEaITKKSMxlCEwDEpHDNuc4207d1JUHjKLSmQ5BPphxD2uSxGVgQYqUSSzzDilPSqZy1sUdaAyYG1GrEryTpvjpuLFqMxEz98pDO3aM2stfREGGggIUiujQU27sIxUqYKyIsInXz5OxhrfiJFz5QiNEKWN9cIaFc/0BwzbFurkuRONDe/ldfDFNJugCNQWXlQPpeeH8pxZUxNiRSGpFmZOysKyksahRKWV5RM3t0gy0Mcl6DdxZXhDGAOdTodPfepT/MVf/AUiMqlgN5ZXHWsSfPCDH+S7vuu7+J3f+R2efPJJHn30UT784Q9z6NAh/uf//J8Mh0OA86zJ8c+X+r6OVBBEVbFBJnUBzhSzaDyFQyG2EARrRqhVRBydYUZwBu+UToQ1KwxE8TalDpqgfN/CTh6ONfOjEd6mjOtVl/KU/6a/zHvNIpmPRK05h/LHy31O155+kzQVfZ2ud7yExjCpbqcpJLo+BcRUIGbY/Pza5oXYuEjSjyEIfWCpHHE8Ki7L+NuzJ6iA0huCRDIio9CidIYZP6IVckwdGj4A61mLRrEBMl/SFk9WBkoDLa349tkO77SW7rDHDyxsoe4KHXEcyJW/m+fsdwY1SuaVyjq8VQxDRsYSmpBEHSMuCMs5fKla43jwREnKiKnJUmT1RIj8zsoKJ9f6E1EUGceBXmvzXQIKVALqIYTImjQ76iCM8oKqNByLPU7VNQNb8KwEcqfcHXI6VUkuykhCky8gtMUwpxU+VqgZsRjh7d0MWweCtFnsZrxz1GOGwBZT8B27d/H5M0vMkxFNh471zAAzwVGajIoa1BBMypjx+Qx/sTbi66PIJ9dWOV2VzKvyW/0RXzjTY3cB+9uRM3WZFqbxTV6G2H69RGWaRB2I6fwVYw2IZIAZD59fOcfL7QwfDW8z8MG241vmZzGjGo+nsIHTBGLt0DxQG8WEGRwFHRNpa8li4djT2omhIiNjUFuMga0xUsbIaVLZ8kyVvBUYlTXeLhBFWBbD0e4WPnP8JKOV05z0NZ/qnePwWo+vnVtBWaNnZJ0PqKngTw2sAlrFhsE/ZfWc/8N1hcK6XoSGRKmOEBwsK5ytK+7LQKkxYsljIGtE2xwONEcFrI1EEaJK4nbEwPTydvE5+9K4nQSL3hDGwKFDh/gX/+Jf8G3f9m2EEPj617/Oxz72sfOOMcbw/PPP8+53v5udO3dy+PBhfvRHf5Rf/MVf5CMf+QjvfOc7eeyxxyayrNZasiybhBpiTDnP47oH09/HaYRRSAxzTXFCh2GpqniuP+R+J+y1hhe8JVjYY5JE8RwOpzkVkU70PGwydhjHSTRJwRIpLewYlTgqKqesEugGQ6tw9Icj/uz4Ejv372UggdJCFSN/euwYa4CXVBEh2QDTMW1txHhS5sNk0k0vEQQmG7MrtK6nB46qYoxJlRJJsXdBkOCIRNZqz1LlKTTy+VNLlBh6PqBtwdQeozPkBOapiUYao0UxEbKYYovBRIqg7Om2KSSS14EoSfXvIwcO8NYSXO15z5ZFhjbSCsLuLOejB/YjktQqM9KuWgjk6rHq8CGVDO5bBbHUFs4RqZsdODR6DGowIiz7wB8deTntqEQwJPEZI+uKcxfboYxrAoz708bjNhqf57WzNMWcgiJi8SZijVBF5bnhgB2tRc4O+zzdW2N7f4WnXz7Mgfk59s3vIcdzzlVE8eQmpZT54BGJzBY5q4zYm2f80F0HGJ1eIq8VtYHd6plFcbVnLkv8CyuSCibZmgeNoV0rocgwZaJULoWKlZl5jq4M+NWXD/GNCCMCTlKt+//x3AugykuDszy2fDaNPxLJUGju/yKL03T7jQXHrrStx++5EMbFsYwIMUTEGEJz7NjQ81H5/PIpsmXlvTOzSAi8e36OXf0hI+Pw3tPKBVGlxIJNkmJSC7PBMIOQSyCLgQrBmYhV5fRKn/m2p3BgJMlvv9Tv8dXeMu9pKS3X4glfciYEXDni870Bf766ystnzwDwvw4+RymN8BlpPpJ63CZ16jNpVmhkmGOqBDimDTa79DQ3yCv65cZxvrF/Trfhxfr15BjSxkPS0EE1Ju3REPEKR8shvZkZMjU4IxRlzR0u50g1ZNZmlNbhbSCXiDUpNBa1xggTz8C4X1zJc7/QWLtd8IYwBt785jfzqU99ij/6oz9CVSnL8rzXRYQQAidOnODMmTRgFhYW6PV6vPDCC3z1q1/l7rvv5rHHHsMYw1133cUP//APs7i4yGg0wlpLURR473HOveI7DXEsSso8N8YgIZIZR1XVHFw6wbfsXuT77ryTrx49i2bK399+gO0SmT+3St+lAj934fj/3P1m1roz/NXKcdprK4ys4KxlFCJdcnKjvDBc4e5snoXVyFKWETLLU6EkZBm0M4raIpJ0EeekoA41mPMt3ItNmhf625VaxuOBNJaFttYSQ5hIAUsQjGREoxT1EDVCFSC4DJNn9PF46yhjJISKvcCo4xhphbgus8YyYwps1sYDw6xm0XvetnsfW9Qyh2GLzZn3gdkgzMZU7jgpM9JIlgpZpQQTqCzJI6CG3DvyqNgio4yRmGX43FBHJabYDa1WjpJq2EejSDRoCLSy1mRxjiGed/8hNnKzl1mgxtyWS01U42cxPkYkVQjEK1YcgYjLDYPegI8ffIHuA49wzOW8FCKnDr9IjB6JHU5bQ8CxapMYUSdacoGOSevVXJajPnCnGLZUNVvmFrFVZIWa/dsX2e4d+Bq1gY4DW1ii8WzPhH+0dw8FNUMVOsFCq82hUPNcbvnsqeOctIYqz7DOEMsRrbxNXdc45yaT9vj+jTX4qZoJ0204Pm7cbuPvl5q8x89lPHbHRv6l2nr6/ONjx9cTcksI4KInWKFwGQt5B+sFm1vKKLh2mzwanq373N2aZz4q5LDXKr3G2k73lhT1QowMCMw6y8mO4+SpZdpFhxe05teOHiG7cx97Z2b5rWe/wfEsUNd9Tj79VYatnJgJxqb6FlaEbJzrumF8Ti/mF12kx8+gabNxqHXS7y7yXDZ+1vT7L2V4jT9rPBZqDdgQeKocsKdYYGuc4c6BMB+F77/nHtyhZ9hRZCznSqnKVs3Y4gxqHV4ycgWTufOud/pZbjQcp9tj2nAYV0S9HfCGMAaWl5f56Ec/SoyRuq45dOgQn//85yevjwf1dIccDoeTh1wUBXVdA4kR/tJLL/F//9//N9u3b+f7v//7qet6Enq40HdpzhmhCSwmC3skhhbCSl2SebjDFhSxJC89b8bwlryLn1WWqorj587w/oVtbFdhbbDG2VbOqTUlSCqpGp2hUwnRwDdHa8wWC+wnZ6kVOeojv/fSN4nOsRRSbHBga6JRRnWN19h4Aa5vzu1FXWpjElYEoUZF6RMYxYCXjH7tWYmes2UPY7dSBgMi7IyJCBh9jfp0HwPvCb5ECcS6xinszQrapU8Lf12nXPdASkUURaKnXRswgg+phPIwF9ZCRe4cEqA2OZV1nLLwsq/pxUhWBXKb4xXKOlD7gI8R1dCkEQhWDGWdjE8jhhjH/pSrCxFcjTty2jMwLslo1KRnXCej59ng+W/PPMkZhaWo5MGnktVLS9wtOd+/ex/91TWyPKUgikBhk1BLB4uo58O79zEXPLMhxcW9eGakoF15iJ5OgHmvlEQqX7KjChS1oZeNCKbFKCpr5YgvnR6wPFjlxKDmhEBJ8lNbYLXfS/dTNcWzdcoTcBVd9VW132tFMFQBaiJ9DE6EdtEmVJFzAsY5ogjeK39+/CS7yXnrXIdAxSMLswyXA2oS8z2JOhowhrN1yUJsMRoFvnLmDKc1yWi/NPL82qGjtN0STw6HDLLIibokV6iGIypnwPsmBUZTeO46jPfr3dYp5g99hb/xZ3jhG6vcgfL/uuMB7o2R/eWI7921jTkr/M2xo+SSsbU1x0ztOVvXVMagwWJjZFSmwN3VXsPYq3BDyOc3CW5ZY2B6d3Tq1Ck++clPUpblhDQ4jbFleNddd/HQQw+xdetWDh48SAiBH/7hH+aRRx7hl3/5l89zIQ6HQ6qqOm/HAlzw+ytCmppi2yEGSgSvUGcpD3bGgq082/yIxaJAWi2eicLR4ZCwTRA/om1y8liSe08epOEaRBw5EcMTZcBIBbML/P7R53i5qqlUibXHNy7WOLm+eN71Xk9cyWcIifgYIwRrqIISoiIYhqMRWsOJfk0/9HmkmMWWA7w4XBSsKtFEolYp/TIq24CueoxGVMCrTsIaUWJy7YrBWsuIiDWpfkA/dyyPhixGi1rDUl6wJJ4/Pv4SJzXSAWZHBmsVP5dRhYiqvGJuDXF9sliv6Hf1bX01z2dyrK5/KbFhgSaVxjOirNQlHgeSoQqBGlzkYPQMxHJ4ULMSR7TFkothodvGkXSacmruLRZwMqQMNafqIeeCcmfWwgaFzLFLDR9a2IF1hn5V0Q2GOo8oFZVtseqSlOwa8FSvwgOlIWWnqKS2kw21RGRMYOOyXIHJW65ywXk1i9MF3+MVi5mk5RqUMnqGueVzp45x/1yHnd0WnsixCIeynL3tLt1yyN1FzrGiaIolpcJASNKNWNaaSIcwVM55j2858pHBq/BEXROrmhBTinGl2ghfNzEjM84NvH672evZ1pP3aCqUdDwETo0CpxFeyhy7NTAfPfeIMAQO1TUuCg/Nd/n2Xdt5rD/gid4waSnwyrDRlfaVy4UT3oi4ZY0BVcU5R4yRc+fOMT8/z8LCAn/wB3/A9u3bX3G8MQbnHI899hjee1SVn/u5n+ORRx7h137t1zh48OCk02x0HV6uQ0SmSM/Th2qa2GKIDCQSc6VjhC1i2Jo7YgZ1HVlzBaeMsFrYRJKzgegjuRhaIQkQNbw5apdxJAoHTxznmZmST5w9wxok3fQm1uc1TbYEXddcvwkwoSQ063VswgS+eXUQAVp8fXnAKVewZ24HUg0QyUEsi8AWYNt8wSwGM6y5G8iqEmMt3uqk0pqKUtuIUUHEJlImqcxyVhR8rXeGtdJz92yLc0b5PyeP8gI1f7N0hr6DVhBqNYS8oDQwiNokijW6kTpeiV9nNF114ptqhCFUhFoEEw1RBW8TqcXWkOPwWI6IcnJU8rbWLFYgb4wyiYJxMOM9wQm93PDMyohOqw3RsZYJwSkz0fDt2/fwpPQ455Vh1mJQ1NhKk8FlQIjUMBEPGpdonuAaNOH1nrAvev5osM2uHk0ZQWSOU77mS2sr3LHQRYLSs8Iy8BdLp1irhnzQ5dw906LrPSqKSqpQiSaezqpEKoUhBh8Uao8GR4XBE0gxN0FC0sqIkqTKM1XqkKyKSfG069oy1xeRFHqtBU5F5bPLp9izZSv31oZWVTEykXMi1N7Tto7v3rMbd+4cL60cYcgrDXe4+r6yaQzcAjDGUNc1eZ7z6KOPIiLMz89TliUf/OAH+du//dtXHP/ss8/y4osvEkKYxIM++clPnnfMOO541Z3mMn8QJ+RlpKPK27bvZFvRoQ7KWp7xfH/AIVXOimGmmEWrQCFQmET+cxrQRlxkSFrUnu31eW61Ty/Lktv6vOsVJGrSDRCui6vw1UIakl1UqELAu5wSoZbIUAxV1uUFNTyf5dxtLTUBW5W8pbPA/UVBnsOH3nwfHXX43ojWsGZBIiYGosRG+TGFVlQihJT2t1zA0qBkrysI1vAXp09zx9x2ojhWCsdfnjvJS3Wg14R5BghPaJ9784KBSGNk6HgPts50X7+xC+M6N/35pXrTTxLXN4ZJmNgQLJiojQKdMlI4oYE2BnE5BkNHk/APaqks5D5CCcP5gmNW2KuG2uQ8H5apc8N9tktntU/eEk5KxhdCyT2mzYwEspD6pCFJDSW1raTi1/gxrnjnf9NChNB4BWLjlo8hEl3GmhHIUkGmJS0ZAV/qr3Git8b79t+P+sCMEVSSIJZEmgJRwmr0lAorNqX6uDIV/QkioKlOQSTVK6lJmQISEj+mbtKWRZNs+a3cvJP+oVAK/PnxIyxqydyW7dwRG96QGlZ8TdTI7sGQBzWy0xoOR8BuphZeDW5ZY2BMYGm322RZhveeTqfDW97ylgsSCDcu7mNC0LizjGND4zDBq0UTHp/AAGWoMSEyX6fCRTu6s7SqCNbyUrnGJw4eRlo5ZbTYWshKQ9cqlXF4EyliJKLUmdCvPKFKaoNDm6O1oym2up4RIEKmaUEcjTUNboJZYdwupnFlrlUlVmLSG5DAcjXiUH/AwaB8/uxplpdOo1TMqGFHMcO3796DqdfYdnoVVceIpKcfNOBUcZrkYAsRMm3KP0foA0/3V3ny6Cl+4O5FQuY4SmRLhEoyTmvgnFrWSEVbnDoGEvhfJ48wGyt2bd2aUgab617PN3/9m9WQSKvjxV80DeoUFlBqo7gYMTXkKVTP8VBxmpqlfp8tMwuQ5RgRWuIw0aKkipqFKu2Y04vCoeGQHXNzVDbji71Vnju5yk/efR9zNpBJzsG65DMrS/x/2/cSUdpNSe50kY0xEEHGoZRGwUfCxe2om77MjJFJhkFoOA4ZJuXzI/g6YEzkxbOn8cDAOU6FQNWIizkatVJjsCHNHEGEXgjJM2AFL2OVy6bcMYzrYGJJ3h+MoqFZ+JsJKIY3gCEgSe7akbyHZy385ekl3r+4g53qCAg1wkqoqNUzNxry4OwM79ixk6PHT1L7JgS1aRBcEW5ZY2C8mL/zne+cLP779u3jfe97H//1v/7X844dK1FNCH9TLNjphX+aLfxqsXEARqB0ORk5uS8pgJnaIIWhUMO5AEdjZMF7Qj2gOxK8MWzLhdmWpaV9iBFjc2oJnKCm9hVomhIyCQTV8+oj0GSOh/Hvr/es0FxDusYIQekr/P7LxzBRU+U7lBfrET978Bu8HCpGwLPN81ggsCKedwwCORlBLCqWjo0EP6QMjqG1zNgBdyjsWphlVjJcAKcln1vr8d/OnqRfenYs93j3tq34GtYUnp3bxm9/88ss+woRS6lK9CmWvRTht06dor28zPI4RZINNQim7/F1QOB8q0TZIOE7bndNE2oNfGVlmZPPPMHqcMi3tHN8HlCBPCSXt5hzdL0lSOREYfndI8f43NqQNy1EvBmw5oSvDUq+dLbPd7UyAo6SgpdCpGeSIlwvK+hpI8s91pnY2E/15uierxoKGINIoIrKqmYsaEalNT5EggSwwtk6NpoUgohSWU0erxYMqhZ/eOIw37G4kzu9Y2mmYMlYzkqLEzan1uTyrwEaQ6oJFFA3MXGaUNv4OY/DDbc0pvrHWOpkpNBTxRshBVQt/RA4Gz3H+kP2dzJmYsl3FAX7DtzFn50+yhOxQrRojKUKg45V428Ba/PG4pY0BsaLtTGGmZkZFhcXefLJJ3niiScQEbIse8V7NqbVbfzbxY59NdhAG6AMHu89Yg3WOSzCqhNiVnBWcoZAVnvOBMegaBOlZF49he0QMYwKpfCCizCUyCiExBEgNjutV/bqMH0BNwkmrmxVauCl+nyiZx94sh5Nfh9C2kEpfGNliUcXt9OpEvMfAUNN5hSHQbOcrbXw3fv2MPSemSgErxiB01nGs77GYHky1txbZPQFvrZ8mjPB8LXeGhVJcjcZUHGyiB5VRatG9XDKILhZcKFriRsOiBv+vhYj3xwOaAH4gA/J5ZxjCBjKTOnZDkfU81cnD/Hxs6tUktQiWyHxWQbA8eCpTI5TMCGFBGJQes7wiSMHeaHXm+qHG9ruZmrEV4uoyesRYGDhqHMMqsBfvPQCJ0JS9oykKodRQKISIpwYrPCWzgwzBmpv+WJvxNu2Okpf8ocHn+eb/R52dIQlY1MYgHjeeB4bUBuN/Ykx8AbAhF/E9H0lGeiehb5N6X/GR1ZRjnlPsBmiI95StNjXXuDrZ47zDRotjqnzirxhmuma4pY0BqYX8xAC73jHO1hcXJz87bnnnuPFF198PS/xPDgJGDzihNkioxbPoRD52uklPhOG9F0iq/3RmT4vtTxb4wrfMj9PnnV4yiiHzh3jQ/M7mSuTm7BkzB6H8AoB3DcaDCNRPnv2LLvalg90Flio0wyoJMGSmkCv1+PO1ixucZ6DR1+i7QPeZQwNrJb95NZ3GV9bO0N+SjkZAqtac/DsYQJp5xWQ82eh2wCiOYW26CZmAf3KEIuCT6+s8dneMk8PVlnKclp1wGCxwSXjC1gznlVXUtRKR5U8RKwvOKIj/uTsKY7wRt98KdJkmS7Hik+eOkJvdZUXBz2GBjw2ZfhpE1aKiStzshygZpHdtsPxoAwEloxwpGX5+Noy5yKc8ysoSQ68HnN/0Ekc/Y3u+J4MP0ltZ7B4hR6Bzx47zp7t29liLEWM9EU5pCVD18GFIbMC1WjEnLG4CFFqtDmRjq2LN3oDvgrcksbARlWp3/u93+Nv/uZvAC6pQPZ6wcYa1/ATHtq5ndbQ81JV8cdLx3neQF0IdXD8+fI5PqdD7pOS+1qWdnsHf7VyhqfXBjy0xTIbHdEG0j411Za/5d2Bl4NCdI7nqppfP3iMO+6fYYsaVBKhKopluS45sbLG290utvQrnCqqNWeLLserES+O1lIRxhg4OOpx5vAalSqjPE3WplEunJ5sbwcoMAyKBs9OlJbUeHGUts3/OX6Qr6hPfTMaMoEVazmTZZwOKUOgjCVZVrBdDc/EkhHCuazNywZekkT6ekNbA5LUO43CAPj0iWN40o69KxaJrpHI1Wb9SUSJMxIZOcd2HBKUkSrP1ENW8Jx2QtSCkhrjm8CagBhBX2PBsFsO5/FKBMgYmpLPnF7iTcbwwZ13oASCEZ4oe7xkFrgnZOSlJ88DHWvJgToGVGRSL8aoEPSN3jmvHrekMTD2CAB87nOfm2QHTL9+M8EagzUZg+GIXe02No44jXIay1CUooyoRioVBsYwiuDUIV5YHow4VHleVMNiUbAaqyZ+2OjN3AY72eiTa/CUQt9YbKWMnDK0ho7mnGbICQ1EhJavyAyMCuEbseJPXnyRL9d1Q8SKBCP0NNJGsMEkUaPpD7ulg9hXhwisxhJnPQ9vmSVzJWu1o6bFGpaRBNpk+JhRackzoU87tvj66golYENgUS3YjL6WHI+eL4Qhx6oRfUmT7hvabyURJfEiSlL10ChgglAEQxYMMTN4abI7NPF4DgXPihgWDUQrVAJ/eujFtMFxFg0WtD6fDzLupDcJcfVGQiHpOWAIxnEuVvSNpZbkVZEIz6yu8DuHA/9i114WDFQtR9HtYFeWcap4lDBJvbm5Nos3C25JY2AaS0tLr/clXBY10JOcwWhA19TMxZrnMAxwRPW4mOLVMEJjzQA4lhe0ZrucPVFzqvL89jefRh54O8dVkjHAJIz2hp4ZLIo1hkqEEJXaZmRWeGLlLN8oS75v7wFWWOWMM9TOpvS5zPKijvgfLxzj+apmJYV1iRogGFLR5lSC2MeLz65vdLsgAKtaYbRmr7V4C8/UA7ZsWaRHys7oaoavI5UVPnPsJN88fYaXQqqWZ7wyUwmlTVkLpyXw2wefStU3xeCiUl32Km5h6Dh2bwhoKnutQgZkKKJChTAKsSH9CR54uj/kyaPH2b11nkHh8CKc0EhLQeoUCrRjAvDks3TjR7+hMXbUaWNgqY7VFIUSIaghCvRFMSr0MTzWG/AdQVh0GYfqiqfPLjNodBca9Y1mTG8aAxfCLW8M3OxQYFWEM50ux5bO8lBeMB8MWgdqBNEmMdAp6IgYlWPAfzt1il3n1vj6sMdIDM+EwP84/iJny2FTQEjWdw5vaChiIkaEQpVKYWSEE4Xjq70B3x4Mo2BZFUuFozCBInMs+ZJDdc0SQt24BFXAahLWGZBStJxG/EU/+Y2NCJwrA3l07LULnKqH/PGpk7RX1jgRAyLgJQkHqQbWRKnKmtJ0cDFQVx5VR21oWARwVD1FMEQjxDe4G3acXhqbPDhRxZGIlEM8JZGhBoa+nizsUWDZKKfLGsTy+LljrFQlwRr6IWJVsGgqc36JDvhG75uGpJXgSWmzUWMyjzTlFkhI3tQSSOoVOSdjxR+fPM7ee+7l8HCNg6MRlTHk0WLwk9TrN7S36jVg0xi4zlBgReBLS0usDQfcJ/O0ckvwniCKYaxMLhj1FAqVyfniyoi2ruElIFKwLJHPr5zBxDQ4ktwmyVp+A/dtAWr1GGdp1ZEXTp9mZcceTnvDi/WIvhdiME3SkAUNTdqVMBKDN8lbIKRKg65x1YYscQhcU0dpGm90j8A0SgRTZWzNZ3iyPMqTdU1VlvSdTZU4s0gcpawMFKIKkKNUjEJkZA0jZzBAEUm68GRASUhF+t6wyBqdgLExmQqEK15gIFCaVIK48n7Kg5fUG/sxQjQ8vXqWWhPvIORABUYDIUu5oGaDPXW79E2Z7OaZWsBTOXSngEZE004/GMHEHDXw5VGPz60sc2jQp98u0MpDZZM2w1jj4g3uTX212DQGbgBO1BW/8fw3ubOV8/dkJwHLKChOa0qraFTw0rDjIUaPYhiQSnuq1uv5thOO21Qi7hsYEZLsaoycBT5x5jRu2yLPrawR64rTmeJHFk8ki55cPQNT4GqPaCIOKTopJlVD2mGExPK+kFzzG7xJz4NXZcUO2GFG+MpRKvRIbaQAQVNNg6YyZ4UiOiSq56xkYIRRtDyb1K8hetI+OI6zCd+w8Bs8HxGd8HmE1G/XWspAPflYY8AIRYQhjjOteaKm0tNRAC94PEhEGuGAjWnKtwvC2JnfrN+KpvojGgkIawjepuVLRYnU2BhYioFfOvgiXoSq3U6ps0nYeIp3cTu15JVj0xi4AYjWck48WzXFvpSMqE0BIqBZ8VEacZGm867vApoc7cnAWP/3jY6k0iqoRtaAkff8xrPPkvlAV5WXCsO5NcWrITcGU3kGuTAoI6ZZwCbtqJOWnEwMb/D16rKICkNTEQ0wXXSrsT6dGrwoMa4LLYlWKMoQhw+Bkfc8t7KaeASa6hLcDlvYC7mbdeqHIJZzqgSl4QUpaqAOsGQNh4uclSB4k95ngiFKBJNSFm+DJrwopsfsGMkPo43y4DjlMP0dqRH11MBpSVoCbYAYiGMF2umHs4lXYNMYuAGIIVUlE4UQtJGzbRKN4mbXvBziWIPMpEpmy96TNelcv/PMk1gfONBq0VOYN0lh7KxN/IIcQ3nbL/kXRwSCD1A4QowTz9O4yUMIr6j1Pv7dAxgD0VDWN1NJrNcfCpxGmMlbqQCXpIJRiOAdfHXtDNVTj3NwNCRagWCSa1xTG8dNV/YroBPqn0KIZDFJbEtUooYJv2ByyG1UfvhaYNMYuAEQY9Bkv+I1opLY7Ikkw6YAxmWh620kqdphGcGL4fmqZqbVwvfXeNbUPJzl2LqmL5YRhiYB83W89psbquB9gCIjxKnVZ7zruoRmh4+Jh1FHf1vvYi+ECPz50Zcwpx2rBqKmOQA1YAxL6vnqqM/AQIwG1CCkNg86/uF1vYWbEuPyS0GSwZRGuBLHIuFTokw3m97MzY7b1hgYFySy1gLnixVda4vSh4ATQx0DlUaCNfg4zgWQzRjWJSCAJbmzo5IK3jSWQYipyMtagKDKn549STYzx5tsh5NnT1NbIapLQgWbuADSTlWtxQvUMq5rIJN/mfIKbEREqWNIqXVKY/BuJm5BMgaerksqX1I5UB+xCOIVDVBFOOuSdFiSKBQCEUdKUWy4hpsW1gYoikHoG2Gt3aIWMGLWeVSN7sB0/ZlNXBluS2PAWosxiUMuIpMOE2PEGJPcdK+hcuFGGGeJdcSLEqylUm2Ia5sd9XIY1xQZM/4T52Kd/y8xkjnLqhc+ceoUczVsuWMXLw1SCmbQze3VpRBVGYWAN0USvGnKS49XofH4mA4PTKBJ3S2anCBNGd9NAE1KMYzdK43NH3CNUasIwSWygNRpY6BNOqEF/GZTvgLTTtQTdcVjZ05zynu8GqymcOLYuTXtGbjZROhuVtyWxkAIARHBWsv999/Pjh07ePzxx1lbWzsvRnqtEIGgER9h4Ctiu4WXFDbQzaoZl8S4Ytk0ZJ0GiCUg9RAV6ItwCMM3ZtqcMtIQ4m7xUq7XGQEY1BXRzdKrB+cVdVGVRBy8kCFA8gyEGIluTHk9f8LehF1PAWrohsmM1VR6mID1SqaB0pAks0OalMMbP1HoVUNRvrlyjkOrKywZg9oC6+tUiFDHx4A21Wo3cWXYmGJ9W2BsMT788MP8+I//OPfccw8/9VM/hbV2Eja4llAFNUI/Br728jFKFaIkGdPNvnoZCKhNoVaVdZbxeNFJXgPfpCA7nlo+yy995XMcrkaYqNg3en7ba0Ji/p/zgWFUXl5ZJohOdrKwPlamPWiTd6viVaEpVbxpCJwPh5CrSVoBUVOsm0ZZ0CSNkVwhIzX5eDZO4ZnNTcI0dOq7AmvAcaC2GWhSJTBTvU9QRMwF++0mLozb0hgY49FHH+UTn/gEv/7rv87OnTuZnZ2dxJmyLCPP80kxpHFYYfz9apBFiwuBnihPAau2i6uF2kWcgMNc9w57IwbExs+4Jp+pkCqMJCLm9GqjNDLDNk8COUROxZoXBj0GsdEjvwB58LU8yyvB9AJ6Pc//ms8DOI2cci1OtnZytialu2YRMYYcizXrE+rGz/VATYu8MsQMxAoZhihJMCYHzA1qi5vx/JFASELFk79NCo7HlEqIMQxpBHOT/AUVvCp/1vRzup7j/fWaq8aGQCS1kUfB12gcUVFTNymt42PEnP/srmbcT7fj7eJduC3DBGNegHOO4XA4MQDyPAfgrrvu4qMf/SgLCwv0+31arRawzimITQXCaYLKhTrw+JhWe4YqBlzmsZmloMMcBVk7w9LCVMnV6r3HOUcIYXKNFx0YzWsXOmb6tY3XMv3310Ky2fj5F/t+sWu90CCbPm7653Gbb2yT8fcsy+ga+4p2u9D5x++bfpaXa+uLXe/Gax7/7pyjrmuyLMN7f0WT89Wc39rz73X6/VfyLCf3L6Cx5BvDPnJmiZNGKExOnQsuWDpWsJ0WkfQMxp85RgEE43BkmExoFTlFnWEcmFiTRaU2hhj1Fc/lQobjhe7lUs/yYm19ufa41s/yUtd7qX5urU3nc9l5x18Nxs/yYvd0oblhut9cChe6l+nxcqH7v9DnX+6zxs/SWov3/oLP8kKfdbG+McZ4Pp+eszde/6X6YYwR59xt41m4LY2Bccc4ePAgb3vb2ybFjnq9HgAHDx7kZ3/2Z9m2bRs/8iM/QlmWr6iKeCWT7/gYby3EGhkETBu0FryP+GHNkIAJglapk1ZV9YrPuRCu5BoutHBOT3TXspNvHJSXMzwuN0lcyf2NX+92uwwGg8lgv9j5L2c4vRpjYPo84+PKsjzvWW40jDae91Lnv9j1bVy0ruZZTgyu5Brgq71zfOPcMqIwBGKV6jn0VbAmUJblK+4TEkej52sKVxBLpYolPgYqC6jHRSVc4LqulTFwsbYen+Ny938xXOmz3Hi+qzUGnHOo6mvKXno1O9erfc+lxu3lxs+VGgPj917uWV6pMTD++2g0esVnXOhzL3S9InJdOGQ3K25LY2CMz372s+zfv58f+qEf4rd+67cYjUaTxcT7lI42vVO9GC722vjvoa4wmpTIVnzNi1JzclI6tzm3JCPlQgPgcue/1I7gYrvjy537UrjcJH2pny91zRuv/XLXOP67937yjC53/ktN0lfyviu5Xlh/lhd7DhvPezU7tfHPGyezK32Wk+OaOMvIwCgzGK/YqORNiKUUaE25qzdm2FSqLIWa+a5FIpiYsmSIAmIJJPnYaVzsel9tX7nU2LxWz3JjW1+sz1/oei9m/AHXpOz6pRbC6Z83Go9Xikv13yuZS67W6LhYFtfF2vhSz3h8ro1G86Wez5UYk29U3JbGwHhwr62t8Yu/+IsXHVCXMgSuZmDlGOqYJtfn65L//MyXWPOeWlMVPWiERl7l+S+Eaz1QL/S+Sw2q14KrvffLLbiX+oxX83lXcq6L/X69zv9qP8cGS4gCRokqZI3ka4TzGEUXmkhL4GVn6JkUcjCMKxWOOfMXv5dr2S4XWkCu5bO8Htc8bs/x7vPV7PAv9xkbP++1nuti57nW7XItzi8iFwyHXI3BPB2CuR1wWxoDY1xux3GpWNzVwKpSqxIMrBl4xg9RTZNlppv6eK8Vl9odbuLiMCSSn1fFB4UmuyCSNvcpN/7iqYUl8FcvH8aZo9ShEYs1QIwgm2mdm3h9cTkv4CbOx21tDNww2JSqZRVCqlyaENbzszfx6jBNxIJr66F4oyNCU2FwXbS5nt4EBbC5vWhYyAPPVyUIKW9eBWwcq+ok8Zwbdzu3HK5XNssm1j0Dt8uu/lpg0xi4ArxWy7ISJQjkUchUqCKNbKuui7xsrmGvCqo6IflsDvyrhIC3pDS3sUXaqD1LSMarhosLtwSgbyQlyatgUZCkD6nrp9rs2hfB7eSCvtEYe3Y354Urx6YxcAGMF39rLQ8++CAf/ehHr8qK35jC0u526K/1MNrkXRuT8mA3VNnaxKtDq9Wi3++fJzG9iSuAgIoiaQ1P5qlMXkI0pWdVdT1hvL9iHIhMVnxRiEYnhkUqICObXfsiGMuiD4fD87xbm7g2eC3zwngNOHDgwG3jwRG9wi3v7dRRx+6lLMu47777XvW9j11V//Sf/lN+5Vd+ZbKDHee9buK1w1rLT/zET/Bf/st/AXhFLvwmXhv+8T/+x/z+7/8+o9EI7/1m215DPProo8QYefzxxyfG1u00z15PdLtdfuAHfoDf/M3fnHgPr3ZDN9Y6eOaZZ85L+b4VcSXL/KZn4BIIIfDkk0++JoKatZYTJ07w9NNPT3JeNw2Ba4dWq8XRo0d58sknJ27XzTrm1wYiwvHjx3nqqafo9/vAZo34a4kdO3YwGo144oknznNrb+K1Y+vWrRw5coQnnnhiMt9ezbzrnLvq99zq2DQGLgJVneyEXssADSHwx3/8x5Nc+E1cW9R1zcc//vHJ75uL1bWDqvKpT31qIjq02bbXFk8//fR5C9Xm/HDt0O/3+fSnPw28umyja6EBcathM0ywiVsem6lD1w+bbbuJWxWbfXcdV9IOmwHATdzy2Bzw1w+bbbuJWxWbfffqsGkMbGITm9jEJjZxm2PTGNjEJjaxiU1s4jbHpjGwiU1sYhOb2MRtjk1jYBOb2MQmNrGJ2xybxsAmNrGJTWxiE7c5No2BTWxiE5vYxCZuc2waA5vYxCY2sYlN3ObYNAY2sYlNbGITm7jNsWkMbGITm9jEJjZxm2PTGNjEq4BMfW3iUpANP7+6AbfZ1pvYxCauLzYLFV0EIjL52iwiMsaFljMFbp/KXleLHKgFooEspAE3NKAGrBdAuXT5H7vh90hq801s4npCMBgiCqJp2Ov4y2CAeJmeeytjPPfDqyt0dCti0xi4CKYLM90OHeGSkKkfptoi7Vd10xS4BCKCNhv785ZxGe/2LzehRl7pX7jN++MmbgB0amTrhi4X3/A9UEQwxhBCuG0KHm0aAxeAMeY8y9Bae1vVtT4PAtp4A6RZzgyNITCeI0Te8JPDq4MQMahIMgYM+EhqOBQRRZFLBgDMZDs23phNhwymt2ub2MQ1hCRzIDkFBGmmvyigRlFA9I0buhqvAdba28IQgE1j4IIYP/z5+Xn+yT/5J6+5jvvYspx2O90yECEiCIpoxKS9Lut+gWQevJ53dDNb7gJEEVTShGoAJKIasGjTdhduv9TCAUnTMjA2BsbHjyfj63fv0217M7fzrYjp+eCma1tRokSMgo0WickjFa0SJHkGDPYypuzrh+n59mqOHz+D8e/GGH7pl36JwWBwcz2f64BNY+AiiDFSFAWdTodf+ZVfeU2egaIoGI1GGJN22LdWpxKiWEQDhojRmHgUgIol6tgkeP3QarUYjUav6zVcDAaPw4AYyhgRa8kAEzwqSt0YAxd9vxE0NpOvMWjUG9raRVFQVdUt1mdvDTiXpt+6rtOzvYnaWEURC+ojjhxRSX3PQpAaBCTe3Pxz5xze+ys2tMbGw/TxP/3TP33TPZvrhU1j4BKIMbK2tsaxY8deU2fodrsTy/LW8w4YkqNw7BVIUexoLEiWXo8j0NcnjCIidDqdm9JyH29MCgUwlNai1mICZNETTCToeqDgFQanCODAmNS+2oQENJ5ngF2vuxYR2u02o9Ho9g2TXSeICFmWAVBV1U3nGZAmtKUqoA5xORIjiidzEILnJrrcV8BaS57nE0P2ciTA6XDA9LHD4fCmei7XE5vGwAUwfvjjuNFrxTjMcOsZArC+1EzFrcWAZLjZrQhCfe7463d1qoQQbkpXqyZfKkENUFBs20XIcvypVcpYks0W5HFIuXruIicATIbYgu78DP3lM2ioJi+PDbPrd/3rbQubYYJrCVUlxnjB3ehNAVWsgtoMzdoUM/NkxvDOd7yVLZ2CTCJBZN3ivcmgqud5Bq7keBHhxIkTfPGLX6SqqvNeux2waQxcBteiI4zDA9fqfDca44RCAYJY1LbB5dzxyPtYmJ/lq//7N9DXyKt41dc2RfS8KSGCNxnWzXH3uz9Ma/denv3ff0bv2BHufvTDtOI5nvj0/0mWgxg01ClfQJqQkljmt+/mPd/+IR77+J+xdvplkKatVZrcguvLGbjpFqppNMkVqc0ExAEG1GM0IEJD4nSMvSqIaSy1CEREJ6e5oSGY1ztj6cKMk9QSgmBIhNetB+7jvnd/gMWW4dzBZ/n8576AiTXBNu/VhtEynegi0oS/EtdoeoRubOcLjd+NMf8r+X18rvHO3lo7yQY47w438GCm//7oo4/yyCOP8IUvfOHm7vfXAZvGwGVwLTrE2MWqqhhjbjGXqyJGsCheDXZxP7P738rKwa8Rtr4JM98B2ZgLfwOvrhn4N6tBYIISTSRkFt/dTZy5G9vOQFYIc3egdjuRT5AWKkeBB5TK5phYoVpjuzMMtuyD9i6cHgdb4QFiC9WKy6cnvnrc7O2bkPpnEEtrz/0UC7tYefZL5PUKRpXStZh906P4YY/B6SPsuvdBTh9+iXr1BMQSQXEk08DfwKu+0IJ0I/HKJFWZfI8oQUCdQfa9jdVd7+aBxRF//Xu/weryCtY61EZCVWKsYI0Qfb2edYAhmhbEGkNNxnoibaAx3OC8BXscmxcRQghYaxERvPcURUFd1xPjtK5r8jyfzKVjL8v4+9gzEGMkxnjehmx8PKxv1MZaMq1WiwceeODaN/YtgJubAfI641pZhdOD/dYyBAAEMYaYcgjZfc+D3POeb2F2+y68bVNLzuutjnczW+8pBTOmnZLJqTUjagQJBOOopUWyydNO1aJgLdguwc0SpUBti4HpEFpb8DJLwIIRRP3rTt68GTBJthTDwv57ePCD30E+s4hXQy0GXId73vPtbHv4feQ7D3DPez7M9nseAVMwpr96JLUr7nU1bm8kXilfpUzv26NxkLVo776LynbJWy2MRFQ9RbuFm1kE18Z1F8lnFwkmx4vBI6TkgxpQIkKNUGGosUTJEJOTZRkiwvbt29m9ezc7d+5k9+7ddDqdyaZJVcmyDO/9JMV7vLh7n0y3aU7AmJQ5Pz/P7OwsxhistWzbto0sy/jABz7AzMzMJG1w/P5Jm9xy8/O1w6Zn4AbjVnQ9hRBBBWMzis4s5B3EtgiuINwE9uTNvWttnK5iUJvhMagaMA41tom7OogVoh4L1Cp073iA7XsPcPwbX4W5nQxllu6b3s7cbIdzh/6WcvllHHXjR9jEhNnicoJtgbSIrkMMNda00NY8pRvipcvAzVHsvheeeAxUUWzjG0i6euiN9A+8nhiP3QsFSASVHCM5MRpiUKIqYlNmTC2WKA5MDjbHi2DyDnE0JLVhxFI3oluWiGPMchEUYkBc8gp853d+J/feey+PPvoon/rUp3jiiSd46qmn6Pf79Pt95ubmJvH/uq4pioLV1VWMMRRFQbvdpt/vMxqNJl6Gf/bP/hl33nkn//Jf/kvuvfdefumXfol/9I/+ES+++CJlWbK4uDjxRpw5c+aWm5OvBzaNgRuA6Y52KxoD43h2VCFIxjAYvDjyvIOX6qYlEd00EBDrUJc1OyMDxiYNB8kAC6oYQmJwm4xtb3kvc3c9yPIosvWeNxOyReYf2MLCm+7CZSVHv3ACeQPLwV4xGo+VNJoN0RaMyJDuFuLKccSkNLg6KuoKcG1GUtDdewDX6UCpTWggxbcNHgi3gZSTkKSux9wJnQobNCyhEDEoDsUKBCy1FNj2VuhsIS8sEsHmGVme4/IW5doaaEpBtuqJWIJkqJiUnuwHSDnAiFLVETGG3/7t32bfvn3Mzs7ysY99jH/+z/8573jHO2i1Wvzcz/0cv/ALv8BXvvIVDhw4wLPPPsvOnTv50pe+xEsvvcTP/MzP8Pjjj7O4uMjP/uzPsrKyMrlD5xwHDhzgQx/6EC+88ALOOX78x3+c//7f/zs/8zM/w+HDh9m9ezcf+9jH+PKXv3zjH8FNhk1j4AZgmjF8S7qhBBJLyxDFESVHpUk3Mg0j+nXMlLiZDayUVWhoLW6lNbfAMG9RbN/F4PgTqDEoFsQhYkADQSGYFr5YoJcv4u54gGzrnQxjxijLUVPhswUwHTRWXO/8run6HDcjRAQmSnjJSA3FLLvf80GOfPwwYW0V8BiJTSRcEZchWYbpzsBK834BqzUFgShQIajKJAxzvfrX2N39+ni3zqdNGiNEnSZhRhDFEoCImgztLHLHWx5hx72P0JNW6n4i6yTChpBpUIiRaDKCOAieNiMGh7/BM3/5x4j2UD+AqZi/qvLII4/w0EMP8fjjj/PQQw9xxx130Ov1+LVf+zX+4T/8hxw8eJA//dM/5Ud/9Ec5fPgwL7zwAv/pP/0nfvqnf5q77rqLr3/960B6Xp/97Gf53u/9XlqtFi+99BIiQp7nE+7Wxz72MR588EHe8Y53nGcM3OyexuuFTWPgBmDc0W/NTqaIhuanRPyJYjAuRyTtbjH2db2/8UJ1MxoF452WZAVqC7xYdu+/i+WvW9RYTIiNPDEEDF4UMRklGYqjteceom0To1Ab6KultF2QLrX0UK2v7/VP5VzfjO17Pi3dEG3OyBTM7NqPKTrEVQVNKo7iHGQFFRZRg+ssMLAFJp9FqxKpk3BVsA5tb0GqEVqtXTeDa5xe+PphnSPQ8P6TcWpyMBnGZajJiFmRCH8acXnB6aVletVTCDVxNESsRbIM9SGdRYRYVhCaEJm1EEa40MevncDqKkZrpnvuuC289zzzzDP87u/+Ln/4h3/I0aNHGQwGDIdDyrJkbW1tIuAmIjjnsNaSZRllWU74BCLCs88+y3ve8x7+/M//nLe+9a0YYyavlWXJYDBgNBpNuAs3Xd++wdg0Bm4AnHO3tIrbWPw2TC0KzjmSLolinEuOxtfJK3Azt+849QqXETBEsfjYpBFGxTTpbenSM4IEisVtzOzYjreG2JknekMhloF4ooU77nuQ8NxXWT21BnVyy14vWGsnBVtuxvaFKfqqGEzWpjYZzrZR10rOb3F4kzG/6w6GdaS0HcBgZnYwd+At7HvgYZ75678grPSpCfisw973fjf+zFFOfvXTk8+51vc/zZa/8VBodvzjtGFVRWyGkrHtrjezcM9DHH7heezibqI4nJZ04ohTpw4zPHkMkQGht4q4HNNqJSY/jdFYVWg5Qr0naxWEekSsBhArMgloOL/Peu9ZWVnh61//Ou9973v5iZ/4CZaXl/nN3/xNzp49S4yR1dVVyrKkqiqWl5cxxnDnnXfyMz/zM4QQOHz48GRRX1tbYzAY8K/+1b8C4O6772Y4HLK6uor3nrNnz2KtZTQa0e/3b9q+fSNxWxkDMzMzzM7Osry8TFmWbNu2jVarhfeekydPvsJKn64p8Fo6y83hYt2Y6Xv+36WJGUYRnOr5kUTRqc2RIBKxtsCRgRFwKaPASFPnTCdULKZ/uh4Y7yiuv+jQhbOyzZg5DZjGVRqnjzTJBU2eTYQEQ+N+FePSwUaSYdXZQjG3QDG7jXaesQpEMhBP1ICoICbHdObYdf/DrJ565jrd6zrG7G14vT0Dr+y/09UxgjiKrbux3XmiptALWRs1BnE5lbSQbIatd9zLMJvBiCHfcS8zW7Yyd8e92JmvENZO4XWEa82x+MC7GR16iqUnPosEj1dJ+g46Jt299j79+pfGneIyQQqLFF2yLXtZuONBWvvfglkeULoOBouJEeMr2qHC4xBbUsYBIgaLR6VO84UKReaJdZ9aS2bcLKUfMQyN5wVptEyV8XM9efI0/+E//P+oa8//8//8J5w1+BCo65p/+2//LVVV8Qd/8AeTNvv5n/953vrWt/L444/zi7/4ixOvAKR2/dVf/VVUdSIe9PM///PUdc1/+A//gaqq+Pf//t/jvedrX/saTz755KZngNvIGLDW8sEPfpAf//Ef55d/+Zd57LHH+Nf/+l/zwgsvcOrUKX7/93+f0Wh0Xnz0UupgV2MojHNZp3NaN+JCghqvZYE7X1iDRnQlxaUz8aA0O9UcjCWLfYhClbXphhE+RioKauOIDJJLW1tEW+DciCzbQma2UJsBsZjHuNPY6IlNnLUgxV2DLZAwwlxEGueCPOarvPdxXHs6Henq2ufyn2fJUISIBxOSwaOOAqF0EK2SjxSHMCJigcpEVAqQiHRaSNVHpEUVasiEQIvSgRhDZiLdB97Djnf/A5ae+gpZDISQk0VFypMMWtuwZQdrZ1jLPObNb6d4/BNUy8tpSr1Ok9l0Bc9rcf6r79dy/teYv6IxRahUUWeI+RYe+K6PMtr+EEEd1ApZFyOWzu478Z0dEBSTtYgUuDhk/oFHKU8ewUfBkoGZw4VIhsWbWVbdApiMVq30jaA2QN0BFCt9VK/eJNhYtGzcttfy+V1Z3x4TCAPRaCICSovZN7+Lre/9uwzPQDQtstE5IOCNIWqbgbQJ0keiEtWTSWTEHEEKLKcJpkBigfE9KtcF26F2OV4UpQINTaZB420UC1hUI2UVQS31qMITEj1WZFJ3ZFoVcOwJ+PSnP81oNMJ7f167jt8zvufx72M12OFwOGkf7/1kbh6nL441D26XugRwmxgD4wX+U5/6FLt27SLLsonUapZlEzcUrItXTAtYbFS5u5BhcLHPnY4LXiz+On7/eDG7kGLWRmw0GDa+tv7e8d48JlU7XQ+BRrFIMUux4w6qk99ENKfYcw/DYy/iwxA7ewez27ZTLr9Ede4cxc67iXMLiHFkuw7gc0dm27QXtjI6+2LSIrAZaCQGn+bt8b1Lk5TQXOr5+4JLcw0ux0UY3++0h+BCk+vGtrqYkXf+H5Sk9CepZKusX7dtvgxKbJj9AUsweXIBqE8ZAllBZ8cd+F6PECy0tpDtfhMmy9PkaCxGoDU7T5zZQb7tDmyomK2WUW9YO/IscdsQE9u4fAY7E/HtWWR2F7r8MuMl6XpwNjbyXa7kWVysX27E5cbN+vfpPt0Q+tCG+CeEaJCsi8/n8CZPceosp7X7AFX/ZTpb9iYvQajwCEYChQRKY2B+O5pXtLfvx2uO7b+E1zROsrmtaGceyiVEQ/PMfVPFszGykQtc75Ut7Bvnhmv5/Db2841/awJ8iVRptOnbhmJ2njrvoN0CLxFjCrJYYetlOhox4oESi8FGhdqjlBgbKbRPaZWoqf5GNAWqkVoygs3BFWms+JrYKDvIOFwhOiFrTuYEeeW9TGNpaYlTp05NQlmX2mRdyZw9FjvK8/xKmvgNh9vCGBgjhDBxe45dRgA/9VM/xbFjx/jqV7+KiLB//35+8Ad/kMXFRcqyJM/zSUcZW44XmvAutrtvt9uTv09bmtPfrbXnCWu81olhfUJSrCZDwGMx4ia7XGs7bLnrYfa+97t4+tO/h405d3/nRzj22Gc49fKL7H7kW9nzlod4+anPsvqVL/LA3/so57bsIATIDjzAIBOcdthz/8McPPoUeW6otAXG4nyPXISaDMGsi+OMmcfj6xNpjITzJ9ALTa4XM5KKonhFu258z8Vem7b+N15Dem9sjIE8pf+JoARAEHUU0UAWKK0nE8FHh2vPEsqKjgSyWBK372LHfW+nOnWOWPbo7H+I+3Zvp6rnqHprSGsOoU8+M8dAcoq7H6IIx1l+8Qt053awdu5lWouLmLqi5SBGRyzm2HLv21g69QxGB69qsZ5ul439ZnyesQDM9LGX82Jd7lleCJfazZrGGJhOfUtdO2JsAbQJ3e34vEuwGUEF4zLufPRb0Lv3sFxZKlVyI2AcLozwvdPYYo7Q6lDanB3v+DZ2W6H35Cc4/uJBNAZmt+2hd/dbqL/+GN1C8LFHS4TK5KhJrPmAueT9X6hPjX8fE9emK5pe6P6v9Pwb+/ul21pALIInmoCLhuBbRJclgrDNQBTXXqSINeHsEezsIlu2LTL0q3jfQU2ELuAsJguYaBGTWAjB5RRhgNFIJh5vS2IR6LZaDAeekU/iQ07rZrNiUv1O1WRQS5EM6YskeI7ve7yx27iDv5gRcDGMNxC7d+9mOBzSbrcn8/H1MLJvRtwWxsC4s2RZNhmAeZ6zvLxMVVWcPn2a2dnZybGHDx/mF37hF9i9ezff933fNyGnjd1HG42By4UQpmNXGyfJ8fEbr/dSu4tLeQJecSyQAVFoBII0EQKNI0hOVsxSF1tQ00HIqIsF8vl9ZJVBF+6gn2/B7XmA+NXn6HV2089buGFFnXeo6NMyjpjPEL0yCoF8cQu4NoOTL2BCiRqP6jgfPu2p1yeq9d8v1X4bF+vpdhv/raqqieDIxRaf8e/jZzgmxl3sWU6uUQGpQZVMQrMIQJDISB3R1wTxxJg4F2amRb51C6NjRwAPps1aLDD9VaQsGNoHqIG5LGdURordD9CuF/DtBUrXRqOjv9Lj5Oc/wbA/AHocuPM+oMvIO1zWpsKRd+aoyipVjbxI213Io3Uhr9SlUJblK/rZ5Yy1jR6ajc9uIy5mDKAgoildrfEuJcolGLGIOOyWRTp33k9l29QKWKFSQ8jncdvehF9dIydArPBRsdUKRz/7Ce78tr+PLRYZEqhbWynabYbZAtqaxbickeSYxTsZ8UVk0CMYRfyIUgzBBCT6VML7VRgDIjJxbU+Hti527JWcf2N7X4yrNDEGsBjxRKPYKDjbQSuPzXJsq40PfYIWhP4qz33qf/Fne7bxXT/845xcW8XHBXL1aF1hxZAzotA+a8OKUCzi8oLo17BEMlGqQR+NgZnuDGurPaJG4mCZjl8BhMq0yLUmDyNqaVHaNlYrLmUMbAznbnx9fMyF+tyF5lBrLc45/uRP/oTBYHDTE2evNW4LY2D84D/wgQ/woQ99iF6vR4yRt7/97XS7Xeq6nuSnjj0AvV6PXq8HrMeZ4Pw6A9Pfp3Gh167k+Mv97Upee8WxNJOn0giDJoQQwQpBLUGThneoR6hGtOhy57d9N3l3F6WJ2C13EDvbGUqHyuTgIAZP7hRioHazRNMBVe555H3k89t5/I9OEdUnN+R519sYAIBw4YVoY1ttbPPp48Zf42d0Ia/LxveMj73Ye6aPtYyJlMmVCeAEPAZci1oLJA7TDovEzdj/yKNs2beXr/zmb1CpYIut1KbArC1jmMGrobQdRlVN7Mxz57d9hG48x5IsJpdtqFk9fZJy7TQyPAuN4nOtBVELqioSXN2kfJ6/KFzu/jf+7XJ9abqNL7Tjv1z7Xeo6LndN2oQBaNgak9cl7WpVDSqW+971d2i9+QOcdXNEwCY1ASppUTmDbYEbLWO0RjtbaekQWTuFU0+pQi0W7cwytDl11sHMbaUWR3Qttt73Vta+8lf4NY86Qx2UaGdRa8D3IFy6zS/UJtNtM16wLmT8X+y8Fzv/lbb3+mvN2FSIqngfkrAYlsJa1Htq10GMQaseh44Enjyywplhn2LLXkKu1DMFJoyoV06xpb2dF5/+PAv3dck7e1B2YTWSm8jx489gRNh1z5s4HZbZ0Rae+9QvoEsvoLZFaebJ44B2vUItOaVpI3HIxYyBy2GsTjgcDi+5sZo+3ns/4R/AOnl20zPwBsLY6vurv/orvvjFL1LXNXVd85nPfGby+oUWnGtlEV7IBXgjMbVk8IrBJSk2ZzRg1CN4cDkhb1MbiwrEfJYtb3sfYBDNqeOQThihRvDVELewi2LLHsrTR/DFAu1tB2jvvYfhoa8iWnI+J2CdfyHGoDHyWgvtbCxCci0xPnMYawHEhoMhDre4gx33v41TT3yJsDponAg5+ex2elmbmLdZ3PdWzIPvInMZo7Uz5C3BaEm0kSAGl2eUbKHWGcRltOsztHtLHPzCX6CjHoVW1NGQhSE6Oov1A2xuWCmFjrUpd76+NlkvF8L0bvPG75AEJEMJxKbynTZxenBJa0iE2OpSujbBZlgB8RWZGEZKinmr0nv6y2ANsw99gMIPYbQKvsS2lGE5wOWJ6KlZRtGdJ7oOdYSs6JLNbCWbX6Czc4Hlrz/NjofeT2/tML1nv8CrXazg+nA8XgtSe9qJ6ZUVGQt3PZBURsOIECzeKye//jVm7unQ3b6TldYMGmqGpyrcjq2MlmviyoBB11PaLiYGMl+z6g3ddoezIaPsbGOVAaNhxWC1h+l22f6OD7D09BcZnjmByojS1BAGvNr2FRFardYVGwMX86DdTrgtjIFx3CeEwGAwmCz+YxbpeKLbGBu9Vph2170eLiedZBLTkHbGZoEmv6uYNO+KImLQrEVwHYI4rCgYy9x9b0GwlMEx9CV7oufkiR6D6mW23/Mw83sOcOrcWUrbpd3ZSnfPPQwPP0Wqqnc+xCSC1rXSe72eqZtCWvxD02iqENSipsPsvnvY9+j76Z08yerKsSRlqxllzCArQBxbHngv3PdWSl+yeuIIRadke+jjjRLNDC7W1MYycrNkYY3s9HMsff1v8Msv4rQikAymE098Flu3qNdWaG2bgV1vw8xvxWYF0V9dfPRq8PoYAQ2MBVuAVhiBEGqMtaAOcQUaarCGkBXUkqFicQScBkJVYrMZjFG6LrIyOM3KWo/5+95Ff+kEoRwQ6xqJNX7tHMX8DGqV3Amx1SG4NhrLFI7Iu8zvv5Ntb34zg4Or7Hv7t7J04il6zz8OsXzVt7cxtHJjMTUAJwaWQaxFxYIxRJuR79hH1T8MWlIPKw5+6TOce/5x/Fqf/r77KN7x7QQT8IMeYjJkuMrJb3yejjEUex7GqMfEmjwXbAZGPblzhMrjnUPF0N1xgF3v+k5WV9aolp7FaIoJSXxtbfPKkN/lj7/dDIBp3BbGwLSbfzpGN178x5bjOI58rcsMX8+d6zqmO/E02cqQWANgqRvWQHLRqyraVGkTIMkN58SsjTEOQyTDE6Mwci1mvcf4SPDJ/T868hIuO0048BBzD7wLbXWJWZdKbUplFMekOKyMgwOw4+6HaM8t8NLXv4CJFTGAStZcer1BI/3yC9HVte/GwX7p85/fC0yjxJbuxbbnWYkFuCJlGxgwsSKogZmttHbvY+i6CG384ATl6lnscMSMX6VnWlSiiFao5HgcXQ2sPf84K098GleNsMZQhcT4Xv3mV3B1jY2ewamMTnsPnbseZP+7vo2XPvfHUI+mNA4MhjjOMcCikwp1YxX/cUtcrnWnPQM3Bo3VJYb53ftZuOM+Xn7iC8TRuUYu17Hzze9i6+59PPeFv6SuamjNppQ2VTI8VgO95WWyhRybO1rWslSNGJ44Qnu0zNKxQ8R6gISSTCLSP0cxmzPSDrM79tLPVglBERMx1mHzNtpdZJk2sTPHyLTQ9iwYB1zYGFg3uMejETa2tohcIFR2/ji+tth47tQTRNM1alN0yACVCDEagiuQKEgI6GiNo1/+S2zosXJ2meLUKXY88DaiGMrBCFPW2NEay09/idFaxfYffDfGKMZUyI67iM4wEkeVzxDDCKKgkuHFsRYLFu97Oyee/Qz1aA2CR6b6XJwyXK6kecYpsZNDr8Az8Hp4bW8mvP4l514lRGSy4x//nOf5ZDHfiHEmwTQhZBwTml74N/5+LXCxmPe1hYGm8poVyAwYEbAt3MJeJOvQFk3h5+42TDEDxuBndqBYMgR1OZ42dWuGItZ0/Dn6z34BOfsSEUcVSzITMMOagSsQf5T+i18kq1YZ7nmE/O1/jzC/HUzEGg82I5vfh3EdIMOKJRfDwlu+A/eW70GzFhoDuXFIZzt2fg9GbGOhpgXhSnDlz8tMfdkmy+HSOwGPTYzxIBAKlAxHwMY+YjtEs4iWoxSnNkpmV6kzi3d7aG/ZgyksqCULgRhGDFee4/QTj+Erg0aPGk+UlIboV3usvHgYV1U4jZQEVDwxAFVJiDUBJXohW12C9gzc9+3YziLSmF1gwObpOYsBk9GmMQeNYHEYLM3/l7l7LkrAupZIT6N5MiYHKcDN0LrnnWx530dob9lHMTOPFQE3y8J7/iH2Ld9FtmUbooGYz1NHR6vusfrc1zBVD1MPUE256lW0jHyLuLrEuS//b1YOPg5xgIs94uAca899nXYIlHaB4dYHMDvvpkOJiyM0WiRvUbfaeGtABsmrKA5s8riZV9yN4EhUDwsgjQhSc+zkeAXRsakw9kGNW+NKns6VQqZaePxdkifQ5WQIWd4h37of291JW2FkBSMO0ZpWjGjIMHGE+DWCGoKOGPZepn/qWVxZQh1Y6XbxJpDFIWZ0FqktLghZUHRmNzHr4uKAgKciIjPboTUPdQ+jNXP77qO162Fkfh+ikZT3ZLFy+XG6EVfDV9l4/O2KW9YYSHK4iRnunDuPcX5jduJXjvH1XS8XVCNlxPn7aUGxzO7cx/3f84Pk++9h4GDUKrj37/4Q297xrbQO3M/sgw8STSJkYVOmhe12Uvy7GnLyy59jbfk0Hk+vdxqJA2K9SjQVqkNGyycZ9VZRHLY9Q2txETUGkxe05hZ519/9B2zZey/YGSKOANTqqCVPngjAZy12P/xe3vzB74K8dZ6+3OUwft5jo/DSSHRKSclPmHE51cu8R8YZGE1p1gCocWBb1CHp2wRxSBCCGLzJECkwW3YR8zZZMGQ+IF6JoyEnv/ZVzHCIqyuqE4eZq5aZiyvYtVOUJ19GtNkH6YSzCKpTjl1BVFOM1zZKB9q8JulYGd+vhgn7/nwi3pX1xel+ez1dqDL5GvfjSKvdoTRtOvvewrv+/o+Tze1AMVQRynyekC+AWLJYka0dY3FwmLWvfBJ35iBu5WUKTd4VKwFf9tFylUOPP0bvxJHJrrLqrRBPH8X4EgkBayztdptY9shGA3I1ONMmsx2cFKhtEetIy3VTis55ufEkDo5xeAwVEI1p1vlX+mFEpPn7+N7HdN8Al0ire3UY94LARFtUBJWc2rTZ+cA7uP/7/y+23fsQPqTQoIprHAhxw6U0QUYf6J85izEWEwJRZJLCrKKorVBTEbRERdC6xpYVba90XJf97/8eFu55BMioVQhZh5k3v5M3fegfYOd24iUnmCTjPfl43fD9Iri6eWETcIuGCcaegEceeYQPfOAD7Nq1i6qqePbZZ/nLv/xLjh079npf4nmo63oSqrguJC/GwjdpkE/SnSRjduseih334Ga/SakOk80h2+7HDLosMEOrM0cITXlXcaCKyx3GOkylUPbQUKFhxOjQM7S7LVzvBNliB/wACFB7HEL0ETGWKELI2philnz7nbhtB3ADJay9TKjXUNMYRwgqjtjezsyBB7Eth7RmCGU/3ZXKZV3ZG1OzLoxxcGSdPTH+ujx1ccrroE05XGOQ7nboLCYt97lF1LWwdaRuz+Nbs7Sx1HPbMa05ugji6+T2VIuNgRk8o+A59cW/Ztl69v+db8X7U2BGBAGjYNQC/qL3L6RUR0wyqlLunQH148YBQlKCREAjQkitoAZtSvVe8u4vkvZ2LTE+qwGiRkAgetqZTSVwt9xFuf0A5Fuhf5xMayoy7MI+OH6UllFOPPnXnDn8JcqTh3nmk6fRbI679t5NaHXJ4giqFST2AYMa2xiiBqcVfvUUp4+8SDZ3FyYMya2w9NJzrDz3FPvf+2GyxZ2I62K1hcnmUWNx+SxiClQMUVOZ34nRJRbpLOAyQ907h2hMHgzODztFXQ/nJQ/BekBhHPJ5bS1+fnjiFQEyY3ELu/GDmnzHffjZ3VTkjLU1gthkkEYPjazWekmjiApYX5FTQt2jFUpWiUnMDMhZI4yGrPXWsDt24MsKfE1RRCI5zO2lu20/Z5d7GOMog2K27Ka9ZYZibjclBq0GxLI36bvQdOvLzAzT88KmMXBluLm20FeB/fv388ADD/DJT36Sf/fv/h3/+T//Zw4fPsz73/9+Wq3W631552FauOJ6TKjr9MD16SMqYDJUCiwzUBeYWGDcPFYW8HEWqRytqtkzug7RtkGEditHjUuLV9nD+ZpWKAlnjtJZPYE9+QLu3HFM2QdfY2JEYiS3FtRQY9Filmi7rNo5ivveyZu/54fobr8DNTkmyzDWIEbAZux6z7dj976JvrSJ6popUSb3djlceue6Hr2V8367ssl2ejqd7FrzOe5833excM+DqAi7Hn0/2bY9BLos3P8+FvbehYlKZ89dmC3bERMwOkQ1Eo0h1j3iaBnBE1ZPMHjxK9jTzxCWD4OOiCjyCvfz+UieA8UYwLbB5ETbAVM0xY9oOPfgpYXaGQxmfQpVc0ULzXSbXq9JVae+EqE1fY6TkAh+C3s5wxyhNYdoTR77OCvsevBR7Px+IpZssMzwyDPYapX63DHC6gkK30NXTqBrJ2F4lkIDlkiSxAW1GYQR+DXC2lnyOCIPw/R6f5l44iDOKlsfepj53XfgpSC25/FFRpW30dY82Bkwrakem37a/fB7efjb/gGmmEv8pEbBcPz6K/xe0sTv2biEvxaY834af43P72YWeMt3/ACzb3o3g4X9rEmXaLLmuLTFMOrJtILYGJgyDo0ohCF++Ri6coSweojWylGkOgfUSDVkYbREfu4Y9dJRMjwaanz0eAPeGMhm8EEwzmBChRCpgcq1ifk893/wu7nrne8Dm4MZX9EtvGjd5LglPQMAzz//PHVdc+TIEWZmZjhx4gQnTpy4KUkgFxMguWbnZ33iGE8mUUkTvhpKVTr79iNr99HZuR+fF0gGGE8wqWRr+8ADjMpINBZjLJ481TYPFXY4pFWOqE+/zDMff4mwepylQy9RnjpGZnyqO6CpVrxKqinf2rqb+k0P03OzmG0tssyTd+fAGFTSZOOco1JHa3433s1ScwbV9aF+eRf+OvHn4guVvPI3SeJAim1coBfnHEy3rRu3a97F7bwLbc0gIriFXcxs2cNwKMze+y6CzXGhxnYXGImDeplM+mA8GKEqz7F65gj54i40jmC0xDc/86f4GKARsgkoQf2F6Y6qk7BBNBmdu99KjBWthe343irh9HNAEkey1tC+60GqoRKOP5myO0Suyhi4EamF471rEJMWHHFYmyFGKbZsRbMOmAxEiL7CxEBr615mHngfob0F72uEkGoVxICEihkGLB88yDee+SLlqSN0J76QxFbHZIgOIA6wWhOHa5w79jzb73oTMljG6hqupfRaHUI0aJYz9/A7CF1H8Dkzdz4A5R30jx1E1g41DZbO391xALN1F3l3C6PhMkbHxmdSrhC0WVfHAR3BWHO+kE6c7n2vHuM5wQgEJYUAjMN0t8G2/cw8tAu3sB3Nclwc4KLHRUW0xoURHSkRPxa2sohEnIJQsvTNr7B24kXKlTOsnVnCn3kBEc9g6Tgv/Mnv4uuaLfc/DPUIQ6DWimADYMh9JASPJeIMVL6iyFzDdSpwW+/A5DmSt9D/P3t/+mzJdZ13g7+1987MM9yhbo2oAgrzRIAjOIiTKGqkLEuvrGhblsPSB1luh91W246w/wF/sCMsh2XJ4VD7jdDrftsdslvdtmVZ1kRRpMQBpEiQAAlirkJVoebhzmfKzL336g8789xzL24NoACwisCKqDrnniFP5sqdO9de61nPMx7tEtZf3Tc3Y7n4Zrdb0lvtBPWLv/iL5HnOL/7iL04xBDeHQuDu9kZNpm0VcLc6cBRhkguL7/0AB370/8Lej/4Iw15GLCZUrmI9z6hcwb4H38PSw+/F44gq1CZPgi+hxIaaIpbE0TLV+Zewg0uMzx4DP0ZiwKtP/d+NamGtwty+w9zx7u+jcov47iKV6xDFgknzXzqHrXZ6gerWurXlK9ctDPFV7bWmsAPgATVZWlHb4ga+lTouDI0IYd4ndPYSsekmKfNI1ufIux/DHX0HUcGZGg2KDYH1My8wPv8SlIO0B7FE/LBJYRokBqrVy8SNtURkcE0i1pljR4idBe782E9w5L3fzwMf/0nuePRDaEznQCS15t33sU9x6KEPouQz27yRUGu7vZHp1pQEtiA5SAdsD286RHHM9fuJjyKfQ80cle0TMXjJOPCejxLzeYIaVLcQEepLVk98i/Li84zPH4fYMoBCko8MqAgx1KBVA7ELTNZX076Mh/jhMqsXX2HiMkxWYMTROXyUaBXT6TF//2M88MM/S+/IOxohMGmix0AlHcp8D+q6IGZrRS4tiC+VBlS1qYgZggriCnBdosnZ7Xp+7ba1jaBp3EdykB6x2M+GWaC4435sr4+NE9i8TNxYwQVP5sfE1XOsnXoeCQ1fSKNvIiRuEiZrjK+8gik3qS+dwlTj9LFQsXby2wwunIDJOoWJSAwEX4NERCJBPVFAbU5tctQWOFdgY0C6c5T5IvnSbeSdOdqrIYVH18cTvQ0IfO12S2YGYoxYaymKgqNHj3L06FHuu+8+yrLk/PnzU4Wqm8Xe+FXVbPIvNFzfihIRVQyGgdvLuGfodzqIBnJqRjFS0iWSoVpAt4uEpCpWRkthMlSgjkmpL/gBwohMAxXjBKszljoGMBBUsSJYV1CVJR3TI0iHaAUfRqmRqcn1GdPcrMTijEVCggmZhiWxXcHdiNdutFtjWmq0Od2lQxR7DrB+6jjK+No/YCwtGM8AmvWQ7iIqklYxdQGdBcrFRepsjg5Dgh+SS48iBC4/9xTnX/gMeTWhtklpL6tLxCteJYHMYkwSxWqacCi0ClPXPJ4xOb6zHzN3hJFbIuSLiLFJvIeEGxl391LnESVLmDe5MTxG69s3Z1JNN8n5fYfJF/axfO4SIV+gMn0CBmOEfY88xnBxkcnCnYjpYjUQg8Eq+LpO2IlAypr4MS88/mmIPo1pMdQ0KnmagHshRJx1ZOqJ0WMFNFTNDTsg1Sa6eiU5qQoUMac0jsJA9IZJ5wAb+UG6DzxGOPcEYXMFUEQjQRyl6aaWWdWZW5dJN0Ntx2vjW0mZirw7z+LBw1w+e4YY/DWzVjdmWzfRiIBkGNdn332PUO29F1/sxYulZz0ujLn01Ffoze9h/j13YrXk7PNPsfrkn5CFuvl+iuZVwUdwCLUGJCpolcodbdnOjlAqok6IoUK8RyYV3QBelGgdvtPHHbmHSbaIJ6NXDFJmpzuPd/PE6BGTgWxlsm50NL4dDLw2uyUzA5BaBS9dusTP//zPA/C3//bf5hd+4RdYWlq6ofTQ9VCmszX+mx+AYhvlu0hOCg5UEvjMaMTVitQ5uAPE0KcfhI4XjM/IvcFJhs87+Jh6i71xGD9h85WXUF+ycekkKye+SaiG0EqLmoiSdN6jOBSLqBAnI0YXXkGyDqVYgiRAo2pE8GnCFpf2z7omXWuxMa0WRDRtqzmy11LX3v08tRPuTJ3WOA7c924e+YGfwHV66bvMrDVkC68gM5XKgMG7PpLPYfKESwkxtXC6PfsY95fSqnP9MuunnkdCIPMeNxki1ZiOBEzwEJUrL79IefxJ6o3l6d4ZbdLHux11e4zNf2oMlbEE16XyQsx6TGyP0s0TXB+1NgHWsoLg+viQAF8xK8AUCYx1Q+NasE0/vJBa5naiOWTHs+TjHLIFkGzqwatWfBvKYWzBne/6Ph782A/h5vdS08HbLj4qXiN77nmEwx/5K8jCQcJwA/ElahSnE2I1JLaTf/SIeqQeYkKJ1YBowMMU1a/1hNWXnmT12NPU3rN69hjjV75NKCu82pRBiJ7VEy9QDDdx4kAFEyGurlCurxCzOULeZ/8D72Tx/vemDhNt4KoCXjKietTmVNkc0aRrss1fiChgkLY0JrD/3nfw7h/8a3T27NsGKNwK91PQ1DYfbr0LqSOoA6bTvDuDIcJA1gdxmE6PBz7ygxz9wEdQceT1kDC4gsYKVw+pV84Q/RAdL1OunEb8ECdNLknbZUY6xkD6CRWAMOW5UONSQKslk3KCtQXOV9iqxEZDUlEX+ofv4ej7PkaQhCES1yGQoZ15auNQU6C2gAZLNHtlTEeTmB0oo+3j+u2g4MbslswMtDfy3/iN32B+fp7Lly9fM13cfn7//v0cOXKEkydPsrm5ydzcHHfffTcrKyucO3du1zJD255yowNqN6DgrDjO1YCE1wIYttPn1jpi+2A3khGNJ1dlLsCaLELe0HmqoniMnWDIEDwuVmzagpDN0YsDJt6wmSl9jVh1DK3iTz7F8p/8FlQbDI59lcGxJxLjGw3NSmj4u6UgaIZTgwseGa3RuXCc6tBhgrMIE6wKuRhcmIB0KE0PbIFkBbhNKlvQwTBuQIXB7MXFZQzaoJuvLVgy+/jq97XhuDeIRgzgQ2AjP8Rm73YwOWIdNnoQmknJgPdYkyb/WkGNoN297Pu+nyR2l/Ax4SRwORo3Kfbuo+ocpFdNqI4/yei5p1i440NIbjA2TepBAwahFsPqiWcZnHwaGz1BUuYoTd1+6/zG5j7ZrOaT5jxEE4nWMDEZ0Vjm/ZDSWILrkB99iLn7HmPjxS+mVVrRQaIl0w3ILfd87G9x8cRLlC9/hYBjtsj06oFniSYjk4ooGYKlw5gSQ20KiOMmQFC8GNTkWKmQoLDndu740Ke48I0/RpdPQIBSMhBwsUwrVQGjQrAWEz0aHaPO7bj5w+TFHLnp4JvatZXIIJ8nmBxbDRh860+Yv/cB/KF3kNcDzPAKSMuvGRvJbGnqAimrk3xapT8nFetf+G2izYkU1Kee5NzpZzDv+t+wZBgjeGPR09+kc+kYwzsOEoqMjh+y+uy3yI8+hFm4E1MP8M7AIz8CLz0Hm+dIlYi08jWM6d3xMEuPfJxzX/z/4gbnZy9cjBYUlFTGE40QOwdY6T0EzuEIqOQEApkGotD43dDREYIyFJNKXlohWZd7PvRjbF6+wuUXv4aLY4IYrAEzfxv3fOiHOfPM15mUFeu9gwy68xShpn/5eY6deI793/cTSF2y+srTLHz/j7J+5llGp76JaDktW4lWKFA38Vughih4TXkqVVLKQAJGM4o4Zrw5oYqOPAwI9SYDsRibkYeaUCwxzufosw5RcJkSYkbo7cGLIs5hogM6GGqEmkgk4sgRsIaJ7WD8JF2r5IBHjL5q3r0WZffVXt+phvi9bLdsZgDgb/2tv8Xf+Tt/h3vuueeaqfiWbfCxxx7jn/yTf8L73/9+8jznl3/5l/nkJz/JP/7H/5g777xz22Bp+QtmWwKv9Tj7W1cTbJmlPr5aZmK37bctSVtbbSpnku4TmZYIkUqEkesQxEEb1BjbAKVI1MIkkZ1Y9DBZBzUgGnAoEiOGSKEVbF5C/Dq5xIQkjnXzm7K1ShVBJFK4Maa6gl95hUxLTPDYIOTe0AmgIVJFS8j6YIqmNNCk2I0lGoP6cuvO1/qlWQZf64a/09+vOh/MbE4k6baTWho9iZRHiyWCLbZCrBjAdfHFElEMltQalnXnuPOdj7H33odTK6YrCJrSr25hH7a/N5HcjEeYesScDsiqjeQ768CkdrIEAIxIrNKZbQPZbXu9bVAwra8oEJWCQDeMsTEFaLEowBo6/T5H7roHVBMFgQiIJbge0j/I0r3vYt+Re0EEIyERz8yAMLcBMlVxElOPuOkR80UqsQn7QbsynUneauqCEANZ0eXwQ+9kbt8RVBwqkrpHWjMgif4IVDEKQkx17SwDl0pUTDaYlwnWD9DoIQYK8fjxJnVVoTHVojX4tI4WQF59xcwMGKC5BjU0KPn0XGJJh5JuGGKrQUqHh4AvEzbG+jFFGOKqQdLxMAZnBTGGzp792Ll5rLGYNqUtBiOWpTvuYv/9jzK37zDBdonZPEEyomoSDEPQqBADQcGbHEXwJsNn86jpJ/815x5JuJd6Ol4THkKKPSw98H72NOc3iEkMf2R0997GgQffw8G7H4bOIhM6qDhGa5c59tUvUFTr9PwAwgiNPhWq6hpiQFt1xvRjSFPKm16Xrxq3jY9j+lwcDZEYINbUo3VyfHO+wOQ9KimYBKEKSo3BI5DnCAGHR6RGtMRRk7G19lexKduSzxON23b9aNRtc8Nshnd27r0a8+DNnw1+/e2WzAy0J67b7dIKUlzPRITPfvaz3H777Vhr6ff77Nu3j1/7tV/jJ3/yJ3nsscc4efIkxhj27t3LQw89xN69e+l0Olibpr1ZCePZx9kb/Ow+WmsJIVAUxVQJaycF8uz+7b59S9A0yU17kSUNdmMEYqRLTOQcxR7uff8PcenMOZbPPknUnOC6IDkmCplJ7WpeLNJbRJbGRAMiERMMYhwaAoWfUFYDrIPMG7CJTGT2GKfPTWQuXGa85jBrV8jmF8mtwUSL05jS4tZSx5z9D72XzcEIsQYnieo1X9hLf26O4eoVsjmH6XQwI5+4Aa1gAxjjiDFcVbPcObdNYazFlIQQUolTbarvxyYzYBMHuyCILbjjwz/B5NJx1l/4cqJhDjXuyEMcfd/3c+nL/5Ny5UJKVZqcaHMkX8K3TH4EVCzS34ux86AVMXoQz3x5GZN3OadNIGUMTlLyN6HFDc4YiPqq8TQ9RhQxGTEK1gqu4R0I43UWqlW86aNYYmcOawxEj8dgii7WD7BFjopQHH2Yo72cSWc/WiyAzSkoqa/TVdDLDcOQs+foO9l35/2c/MofEKtNrBgKk9pIMxI6PBiX0vNikaJDJTm+fwCf9yn8iKipR92KEKxD1JFHT7BQSKQWgyscwQjqMoxz+NVzzO/vcubCReZufwgfIoUf4ocbiCq5icR6QhSwzUpQJVVrYuqvfdU11o4Na0CxqBisJOKmPA6Yry5zsVpPN72soK4qcmp0vMGCG3Cl2khUxplD0WkJxjlHaPElJEyCZB0qzZC8B9kc+x/+EEv7DnHsiS9gwiqSd4mTIbl11GLAmlTOEEvv8F3c8c7v5+WvfQ3WT9FhQsQSrUWjIajFGoMJJTErOPi+j1PuuYuRPYezksYrDmMFr5ZRLNBiD5KvILbARdi8dIrh+eP0u7ezp1xh2W8izmJiTOPYOWy0ZLaJQ1QQkwK/yO5zWXoxFZQslroaEccbWI1Um8ss+QG4Bbw6bKdPFMuk8mTWYq1DTGD+4CE6nS5Sl4hzWCe4aFNmTAHbJcRA9+Ahjj72Q5z+0h8i68tMOR4NZFmG937XubWdw2b3f3bObuf8txJp0S0ZDEA6kf/pP/0n9uzZw4ULF675WRGZ3ozbkz4/P894PCbGyMbGBocOHZpOxFmWsXfvXpaWlrYNip2Ps/92BgPtjWn2vdmLZud3dotWp/8aCL40mGsjQjSkGqFJYDMrltA5SOe+D3Cgd5yVc0+DLQidObw4jEKmMUmVSga9Rdjb8NeHCr9Zkc3vJUTPgnryOq3UtREV2nms7X7GasLpL30ab5eQWCHZPIcfeg8h1uTiWT31PP3b76bK5pg7dA927qWEFxAg6+PylJIdrVxgvn8o+YRE7pNwXk0GZId/rpby2+k7Iw36uE2jpA+lUgBg8y77HvogK3nB+oknkegxashuu5/8rvdTvPgko9VLkPWI2RyTaCilQMRgYrOfNsc3pYhcK0ZhTDlY5tnP/Q5iO2xeOdeAItNnTJPVaQ4MY2RbkLh9oFskUToleAWJRHnz/ClO/fkfMPd9P01cPIB05rHWYqipJUdsBxuHWJcREOzeI/T2LFKbHiPTI2Z9bKgIUa5WJEBQTAwENey951H23P0Q9tmvElcnQMTEBknQZFzEkFK9zqKuQ206yMJtQE5kBNJUfUVQ10GkTywHiEmZl4Q1MESXob0FvFjKCy/z4reeY7g5ov/DS2S9ec4+9SWqy+eoxgO61YiXvvJF6vEQi6Zsk6QMhTbn+mpjgyb7kfATaXhsnHqe54NneOZ42hYgvobhCue/+jlW9QqD88c4dN9jKVCPNeIMLRhWGsZBsTb5wWRoPodXgIxDD70XN78Pnv4GcbSJ2ILoaogeI4IaIVoBHMWew+x/9Ps4/fIVysEqGmqMJNrriKAyR9bJiONVTNbl4IOPseb2oq6X6LFFky9CTYyBaDJqMsRlGA1kviQvVyBssnr8OV4sPcMLLyNZly6eTfWIlebSaTITIlM+wBn446vHrqSMRxSBMEHqAc4oG6ePUX7jCyw9+v1ofx/OpvKdLUdIlqVynLX0l/YTTGRcj4n5IjFfxEdHjJ6oIXEPUNM/eCdLd7+Ts9/4Crq5itGGeG2GynyWnXa3OWzn49Xm9O91u2WDgaNHj/Lwww/zzW9+E+cceZ5z2223cc899/D4448zHA6nn21PbJ7n089ubGzQ7/c5cOAA999/P88++yyQgoWLFy/yv/7X/+Lw4cP83M/9HHU9TchNywaz4kdXszYAqesa7/13WHvyQNbkxVJ9tynXpeUPQo3gFFQLNrIFKlPgJSGG9z7ynkTwQcDGihhC6tu1HciKJEQ0WUVPX6bzzkUqajr1mPXRJj5EohdirK+6dwYoXzlOxRxIDXYB9+A7wFS4uMHoxBP0+hZ36B2M6aLSTcQmWY/D7/4wFy5foRyPGK9cZP7Ow8QQExhMAhpJK5TrwAidc1TVdnXE1vfJprCm5Ds1aWWjEY3KRAo6hx8iSpdYrxIjWDvPpplnbBfw0uXO932Ugd3LRA3R5Eg1JA5X6ezZx4RUW+/gmQubrI/W8KM1Vl96EtSmNG6sSHRCgZkEL9fnQHTN2Q5EEgguElC/wpVnv0rx0Idh4QC2t4iJnhhqNJsnhIyqjrg6YkUZ41DTR8SycM8DmIvvZvXpzxHi1b1rAO8MIeZUZIxsToiRWCdxnkoDlab9CQTUR8Qqk1LJVSjJ2HP3Oxh8cwG/uoJSTVvpisVD3Peuj3D8y5/H1+tM4hiyjKyfRIf2v/8j5PN74aUnWHv2L8B20MEyEiZsfPtxwnAdW4/o+E3qc6fQ8YDoK3SmAyVexb/t2Nhi1AuUDdogbFxk+bkViJMULIQhVBM6YcT4xLcYbZwAG9EQEspdPUmhyhBjoKpT+cBrGrsERcQ2xy1M7CJRe8Q6krke9374E1w69TwrLz6TWApF8ALqA0Fz1rXL4e/7YTZcycqzn0vofJ8CnmL/Id7xfR9heOUMx595gSF9vCnwCt6nFlYjZSrB+JIQU5bMAbnWdOua0egCTNbwIbL8/JOIq8j6S3TGq9hqgE4GhLqmJnW+KIkTMyEzrtPpICZ1BY03yfwQfEW1fIbqW19hz32PYRYPItWYvlTI6AoBpXvbHUw0p8ahmmGyBRbf90k640fo+Q1e/Nrn8ZsrUFdAwGvG2PaIZNR1NaUNj2KoTVoEzurRXM/asdEq2m6fR7637ZYMBkSE1dVVut0u/+Af/APm5+fx3rO6usof/MEfvKq1sA0EfvAHf5CPfvSjTCYTNjY2+OM//mP+/t//+1y5coWvfe1r00jw9RYWmi0jfGfbbOrMbWJOQNWCTSvAbOkA9eXzOJtTuwIW9uH6R1h64MPIvtuoUAoTkHpMYRxVDGR5hzz2WH/lGCtPf4E4UPYeWaKTO176wmcYnfk2aIXGtl59FQAf4Ih4SqxW1DEj1xIdLXPyyT9h48XHqasR+z95B7gObvEAkveoyFi851HW3LnUvlaN0opdDAbf0LrOqu9d27+vyYSEXEZAI6Ga4BYPId29yHA5+TXrozbH7rkDt3Qni/c9huZLSNEjAp3xKue++hnu/ORfJbhFxEbMeIVT3/g0o9MvILFKN/4Wbp3W2VyzV/CqlmrgKSRoD7qGMEDHa6gIXjKMRKLJ8HP7yfbeib90BbUOK6mnvsaREynm9xAO38uVZ7+USI+u9cuabpjRZClLJG212s2IYW+ZxohiKRb34qWgu+82FvYdZG31JEZDwzPvcAuHuO2RD3Hx+BnC5DJhucYVc0gxR6kZnf1HiLVF6xHiN0BrCmryOEDqFaiHZGFENw5BxyS1y4aI6TX7dibE1ir5lnZ8eDKt6cQJ1OtIGKA4QkytsSnPk1oXpcF0aJN5siKgBuOKhMmxjkpSNwdaY4t55u96BC1ylo8dQ0IF1iW57AhIhto++aF5Fo/ezeXnzHTfUMPSbffQv+f9jOfvwCw7vOslyWDRZqyRsEKk7Fh0HeruIrY7h4mek0/8OcMzXwetsGqIWqLRU483efbPfp9y4yJousGmcZBwK4n/4/pelhZj5CeJs0ADJoyJfgNRT4yROUrWj32D5We+Tt7tc2D/TzExexCXROdKunQfeB+daoOlsE72rW/hB2ugJRBRk+FNB3WpVGyme/Y2z8BrtVsyGFBVxuMxv/d7v8cf/uEf0ul0pqvvVp1w5+cBPvOZz/CZz3xmWjaw1vLpT396Wwrp9ZYvhi064u88INhawwgt1XDSdV+87S7u+ZGf4bn//v8mz1IPc3bHXRx63yeZFIeSxri1+HJEl7qp+2WoCr28YOPKBSbHv4IJBYMXDtDZt4/N579G9MtgKzIRar16v38kdReotMC4itVzp5lbOMfgm18mH11gcvoZ/HCN/v7D3Pvh72foFig1silz1J29xFih1ahJOSfJ3thMPFdPYu/u3xs1I6ZJf0Y6UjMxOcwfwF55Cc3nuO2BB/EaOfKBT3ApVmzYBXx3X2pvijUdv4E/8xzl+vchB5awKPl4mdVvP47ZuNjcY8K0Fa+eqsXNHM/VY6xXeXk6ybV9a6oY9eDHGOOo1ZIbR0TpHrmf+3/4p3jpfxwH47ASMRJABaOpX9ybHmqK9uzt+qsp+2TBpLYug8dKRdAEKgz6amW92Gxq/6HDqMuofHujpFmDk9oOO0tsyBz24D08+K5PcvKP/jPlMKOWjCBZwlMg1OWEXCM+1mxcPk+vY2GyjgmejYtnyPt9wmQDiVWz/faX4EYIp9MZibSwNNPqe2BAI06UweplstVLUG+SaSqbxJjkrhBJxyymEY1qwghjUxejCNY5rHokM0RpSgqxArPAKF+kzvoIeQJzWjvVPzI2J0ahcjnS69NAVFLZDkOwXVbtPsYHDnDXX30EtQ4TxqgEonEQHb4B/KnJGdKl/8C7obBUVWDl2ScJ41MYo0iwZPjUtyOe9ZefAcqUd9SWvdA0WIDERXItawGGEYMJnsHKRUI5wcaA1gNMqAgCHR1z9oWvMT75FH5ukcHZd5Dd9X48gSyUVKagNH1Cbun4Bp8TSjIpm9Jcam3G5WxryxU7LfG+bTdmt2QwAEyBIQDD4XDbDX2nGWMIISRA2cz7IbwalPZGpIVCaLZvSGsX3T6FpndzLDWKEkWwDVGJb1YXjtBc1qmOHkSBGtvpIwuHkbxLUViKPKeyOaY/T41ipSAEZY8GVl78Nrp4gP5tD6X6cvB0KLFhggsTzj/xp2ing1TLWJJgjhVLfY35VCGtZEQJqqCeM88/hTl5ATNcpktkHAPOwBCHI0MCGE20xcFZbKwxfkhGjTGWSnp0lvZQVmPCeEyx5xD1cI1YbiYEODNTvAghERnsuu5Oa9dI27Gd1nEOTOoSACF3lkn0GOcINqN36D6y3iJqDbXk2N4ipaauDOMMRlzqftAyrQrVYH1NJ9aIH7e3kh2tOt/pKmUrK7DtoDRtMzT9874cEYskYW3wyN7byW97GLuwl2A6aUJXnxQRxaaJXXfUf/NFisX9xGoMePzGpdSeh8Pk3aYu3uIv2mazRk1RXMrkaEjZiGKOOgTEFcjCYch6aLXZrN4F152ndD2kv0hncT+uu0Q5SRLZ6+fPsefwPUhd4UebRARRz9m/+ByJDGiCIFx69utcOfkSYbSOkTaLceOmzF6H8qrXpMnIXXj+SS6eeBmqYeP6RikxluneqGDVJCFwUdyeg0ixhFHSTck5ahzZvqNI3k3npyHnmVBQ2YWGqCckVUQctrcHl+WoCj6Ami7d/XcxWT6LBsXEmhihtBbt7UmLGw1InCCSAjAkQzOH2XuE0JlHjeBdn2L/7alEVm+CTyyA0hyvEQjeQxyDxGlHQNDWO+0Vdu0sl9KAjFEINa88/scQk8y2hJqsHuEVJpMJfuU8pl6n3hjz0mf+J/f8zO3I/rvRWGM1p7IQs4xJqeAyJHF/JkEk101AZStsFVHTDtzMbLQ3o92SwUC7ggemtXgR2YYCnbUWaQ6vTim3tf+/TEqpnTx011dNswoV1GrqHaelDYmppuYsmP24apUoE2LWoahLMo1sihAlI4uRUrLUpqVjTKxRCQSXUflIzDPMQg8RR4h9rKnJdZVSHkaBnl9jfeMSVZHhojKOEcyEzcun8EHwBBitwGjmSAKMb0DXr80IJA/XaLlCKFeByCaCw2EMbGQdeuJY8J4QIdiAMxNMOcHWmxSMEz3wnge57yf+Chvnj3PxhWPc9xN/m1e+9AcMX3gc50dAQyksyZNRt6iBEi1yA8yLcZomBcU3WGORAkxGFirUdplIRqEjMh0R5m/nyI/+PHUxj7cZlppgDMZP6LmmLVPTqliiotZifKSjIGWEYFGb0rMSG2T4tDl0p9+u79r2e7rtz/RXFEOFYAVctYp2DqJqKOKQQe8ACz/+f6WfO0ZuPt2ANRBIhDrGRIgVRiwqGaKepXd9kqUP/jjl+gW6cZ1jv/v/QFVw/QX6R45SS0aULmoEJKYVu5IAoW5PSn3XFRUdatMnI+Btxp6P/QzVxgUmLz2eJvHo6RQ5I3XURReNDi32Ie4SPd3ErQ7g4F04KbHVgJEpkDBCNk62TW3JEePLhPEVYJa4elsx5Qa9y/Q7W6C4MH1fxxdhfAlDpMKgto/dOMeiX2Yjn0c14oLD6QLWGvZ9+FOYAw9hqpVUInA5m3aR/mN/lVw8unIKcRkwJhfHZlzANE11ms0hpsfSox+gXLtIMBYjghx6mId/6v/GC3/0/2F08SzUF0EEZyf4uIqJc3i6RFujWQrgEM/ckYc58Ff/72y8/Bd0dJNN6SCdeXRwDuJgesAJNUEDZ1FmcS0ziCmmfA3XtbSI0YYL1awdT3gIk0M0FPUmpQoVXXxdk2mkjhVx4xxm/Ty67y6i65PVGaVRKlODibQwpUEqiAAAX2dJREFU6hpQO0fMD5D7isxGKtL12WYT3y4TvDa7JYMBYHrz/7Ef+zF++Id/mDzPCSHw7/7dv+P06dPflYHw6qxvu9pI7YDTmUfAa+N648n3HuHIe36Ki998nGpwlqWH3o0/9TyTlXOJqpaQSG4kscZFDBbFqmBihrE5FHMEU+AxhJhQ8sFA1NQWWJseYnI65TKLYYVR7LNRDVg+dXxmr18vn21NqRFFbMm8GSN+AwmeyjgmtkBIkf0kDvEhY2znsPvuYumhe/CLt9OpI8W5Adn8Xlx/AW3WsTL7M0axNvUmt1mX1hKiuMVbmCSXrE1Ptmlq+DYDSeluMQJFL63emi4KRcCmlKPStnM2P25gIYwYbl6kKnKsM+AFYkJIX19Z4S9vJgZyAnVM2Y8oif3NB8X1FlCtiZjZkdh0MgDG0b/zEbAZ6ye/TTG3hHb2IGLJ4zy4PqM4xnZypNsjxIAzjjoIIhkaK7AgWZe9D7yH4YVXCJfXYbp2S8F6J8txvXnqaFAxYAu683uIktO5911MDMw9/EHKl55nbHp4nVAbS66B6OuZc9qOq6Yezixc8PW3HcXG5jdBQ83Fl56h98gnqXpLQETzDnO338nGBUvW7acsoBGk28f156mMSxmOlvlRBGKFrUdkW1VucisYPyYrHJtWmLh08yvmF6i90HnwXbj9h9h47s/AGVqK7/a8xhhRY8nnljhw570M3V6GxX6y/XczMd2UqSnmKdftmzA6t3vTGpfapIGOU0Z+jNUklxxFiFHARC6fPMbeu9+Hk3RVO0nNqwK0gzcC2f4jLNz1IGSdpkNJmqxrOjJjmmXA20HBDdktHQw45/iBH/gBfvM3f5PNzU1CCKyvr3+3d+1VVqkjSo5ouXVvgnQTEsPife9j76MfJ3dznHnhq9z3yZ/mwueEsyvLDWFNJEha/6ABpEMQi4QJSEGlDi2W8K5DNBliM2rbJUQ/7WsfS4es02Hz5S9zaW0deeRHKWuPhtQm9oaZQF2ts/rMV+gdWsPMdakO3s44L3B1RmZ7KI6gjsrN073rHRy+732UeUa5skJ+4HZqcbi8Cy15jc4ELxqJIRDRmbS8ptqmyZt0YYVKDjhiiIiknnQ1biqPqmIQcVB0m1UbzSpIEJcjNgMSLsGKEOsKPxqw/PRfMLF76b/rPWQZKBl4h6EimGY/3zD3Ki6U9OKYQWzVHIRgC6w0zt9R098iihFM3uPIx36KupqwceFUSvBgCBTU0kOli5gStQZvDKZpg0zUsHN4qVHGdOf28q6P/SjPfflPuXL5GEyrtyYxeEYhRlIHixSQ9cn7C0yMw/T2Mo4TFu58B76zh4npEBrWQYlj1KfxuTOdf21Y6+toIqC2CToS/FGlxg/XmFQTolqMGiprWbrnPs49lWFsBhLxqvQWllg8eIiLmgLQ6FMwI5JgfUY9zgjRdhJ2wSR8gbUCnR4VqWWzjAkjcOCdHyILJS+eew6xrjlnDX138GSZYWxyDt7zCPd8+If41israD5H6O2jtv0kAmQzqkBTAnqjbbs0sxhQrXnl+afZu+8hbCxBNCmkmqZranOFfhyxfPYcvaXbMW4fpmryetakdmo1LB29n7lDdzKJEVv0p2Mh5Y0CMW4Rxr0dEFzfbkkGwpbNL8bIYDDgAx/4AA8++CAPPfQQeZ7fXCfeGJbuezdz9z6WJldoJuoqIWJjINoOY9tH5g8g2Tyl7RNcF8UmUFIEq2BimmKLfbdz6N0fgd489tBtaNFj/3s+zNI7PoBv0sDdfbexcPAONEZcUxtXrVk59k3OPvFZbD3EWjPFhL+RptWYM1/6E178nf+T84//Eb04QDUgwVKoQ+oJ0SdwY+zO4W2HMlqCyQniCJKzdPgokhVoA/FqTVCsERCTgFfpRcDQOXAnh971ISgWmTv6IHe898OprbK5VSkONXliMpOUOZCsAGPRqEgMzb0gBVg6BYFGgq9QrTn/jS+w+dyXydkkJSoTuMu2+/FGOleVvB4zH4aYkEoiYg2V2kT+c5WvtSsssRmTuUMMpYtGj9U6Ad0UiAaCYNQxv/cwxnXxPqZgwGX073qQvY9+ELBoPsc4WyAWexI74fQ8JH/FGJpOhA4L972H/e/9GHXWT+WKdAYJkmOLPgiI32ReV+lUy4m7YtsYfaOdutNMkzmaNqaioSKEMXU5IIueTvR49ZR5DnmfGAyqHrWOaHMqrxjrEsugpHOEcWAKgskwe2+j/47vY8+jH6c4cDfqCirJUcnJTIaNiqjBS4fY2UvIFjHSjFNIADoES8RoIGKRYomBW4K5vYjWFL15jAh9v0YRKiQkIqw3ztoszhYWI7Zy4Rq49NyTVGefpwgDJPqmTRpQD0yYq9dZ+/qfI+NlxE/omoRJ0SxrxpWldn3GklHbApN3meUSMSLTkvFNdT+4ie2WzAy0JQKAl156if3797O0tISq8txzzzEYDL7Le8g0ZWWygn3v+CBkfV44dRINFZaASiI7sShoIGjECdCAHNU6cF1Mtw/DdXLKBBRTWLjvndz7gY8xuPQynTvvZCKO/pF7MCgTsYhGyLvNZOsRX9MNYy6/8gImVmgckYUJwbyRSdbGDQqmUpQhGRP8+ZqN576FvWeRbu8AvcyyMVpG602sVo0UdVKpi0RcllGpY2HvAYrePOXoCrA9c6wxMeDRpGENEEzGnrse5r73fZC1lRF77n2Eu+9/gMvHv00YDXHOUgVFXU6ICbQpLseJJjnZmCSUsRkh66DWoZjmRhkgVBAqJI6I5SqycYlibg+iNa8C/L1RpsrayRdR0yMcfg8WT+1JIjHjdVxevOreqVPK4PRidAW1ryFMMDpptOUN1nskVDgs+/fdgZEuMAaXGCkPPvpe5g8cZOWFr0A+x9j08cV8A1xTtK3bSyqRGZdDZw+H3/Nx8r0HqbI+QQSniZJZxKAx0hFl+dIJhs+tMxquUo43pnXqrUT9mx0SbHUoGEA0oGGCKTeYGy0zuHCa7O5HKa0gtot1HaJAMBbtzDdjJ2VVLIlRVDAEcipyzPwBDn/wU3QsDOduT6S7pou1Y4wP5ERUoTIFIRosAYI0+BhDEEm9KuqpfY3aDmWxxFgyMEJPhwlgFyuGJ77J0p2PMqrG/OUVEa9nOvM/SYaaOnmx3uDSM48z2n+YarRBSxNNqBlefoVz33ycevkMTiaoVbxPwF+dX0hZP1GCyYgmJ2idsnnSECRFGqrntzMDr8Vu2WDg4MGDVFXF2bNnGY1G03bBGyEDelNNhMp1yDp7QBMToBimQiqGrJkcFKM1QgmxIuKYP/ow937o/Rz77O9TXj6DkUR7ysIRBtki6gqiK0CScIw0iF9DIJIuGKeejo7oD89Rnn8+IYTV4UJF7rRRHHxjE64J0hMwVPiNkle+8Kcc2ftuTGcfYjyTjUtEP0KDx/WTVr1Og3yDug7RFmCLVBucATEJTDMDAGhIfjAOs+c2hsV+jvzgT7Ox6RkU+9B8HsajRO1sHbi0whLrQCyuyBM2QZW6LMlc+ozYjKg0oncpgEMDajxaDekO1ig0QhyiUif0tUrj1jfKt8rmmRNsXlzmtp96KFEVi1BjmaxdYm7PAdhJ1Z3Qg0gjRetIjAFpRaaJT8CZpM4kCd3uXZ8QM5zLyGz6Xu26lK4P1qAup7ZdNO+nkaQBK4lVkFaRD0P/zgcwh+4ldvoJJa+hEeMRak0hVC4RNi7y8nN/BmGSgmPVHZmB2bDgjbYt/Ev7lwhoqOhWa8iZ5zj/5S9w9OBtRAciGUYb3QHjturZzZcTfsg0LZup/OBVCPkStTF400nqldYhNk+sDFo1rY7FDLOeb9YbhkDCvFiJDMsRds8+unOHqCTHOkeHEdFYQuW59NTj7L/tXjS8GWQ6u437VG4RnTA88RSDU8cwdRJdSjmNgF+9wKmvfAZMRu2TGqXRxGp5+NH3cOblJ/Ebq015Ly0BbFs+CDFVCQ1vZwZeo92ywUCWZcQYWVpaot/vJ4BXUz74btmuQz8koQ+jFRKr1M6moM6C9IlugVo6KY1KgNRfQHR9ZOku5I73IotfJ2xuEvwQ1Ui+cJAydqCGLFpiFDwu1cI1pGBA0krZacXgwknO/PnvUA8upXYc28PEmlwVyJnpAH8DfCJ4MtRESsDFCNWI3Nd4raiySLmxSoiBOkRsZ47a5NSiBFvgbU40ligurS6loUduti9ADKmHflr0UgCD7S0xzhaRAwuYBWFTAjHvISZxuiMW8jxxL4hBMeRFZ4pLCOMxsTcHWYFx2QzhT2yyEaFpYYgc+4uvpDbVMIJMk/5NbACMb2AwYOK4SefXiC9xWUEtgow2MfN7EO3setdMuhIGo4JVAEuQgtLNUVtLqK6gBupOl3F3juAK5tSRGQNREOlitYN1DnFZatfMOolSl4hRz/rqMtmeJXqZQa2jf+h2fLFAlAzFE8XgTdPmiDSAxzXUV+BHmFgRo7Al5ftmlwhoVs+zVe+GSCcEXvnqn6G1kHufeCckpvZTTXLH0QrknaYMlVbvqpqCT2MhRqwfIyayiQUcToQsNHX0zOKtEkOdGPVIyoWF8WDqlIQRkzQfBCxKPZnQXVgk1z5jkyUwbAxUJieKQqgICmKLN9+XjQngoqJMklhYI4KGgFOI6qnrAbgOtZ+QWUOoUylp7uBhXN4jsL4VcIqS5elWJoak0aa8nRl4jXZLYgZCCJw7d45HH32UbrebVnEN6dCsEMX17HoiFNt4zK+1nV3+ahGtYh25ND3eUpKmShAinUN38uj/9ncoDt2bJkeTJ/Y7AQJ402Pg5jn0kb/CkQ9+rKEQ7mB7c2TGYEwHE8A0ffQikSJukIcNVBWPxWrErV9geOF44lhXAfXY4UU6oyvNhfjGmgJI0lNITKoTCr9Kbj21BsJwA42CqEE780m6FEd3/x0s3HUfPoAp5ugffRCkmGq5t1O0sQZMD9EMJ809uEEhR+1SSRfX6SdiElsAkTy3aN7j4Pu+D7pzlM4izuBsDiIYnaA+4MkRlyEma1Z4abXfrkBQgVgzWT7P6PIZJAm1v5GQzKmlBjIPGvHGEK0QoyJBsNWYorxC1qT+kQZrIxEIiEsrUwCVDCQx2NXWUWcFaiyuM889P/TX6Nz9EGKa1X62CG4BkQxrDbbokmUOQ8BYRzQdoikwzjLZXCEMh+ADMetQ1R61QjBZwjasXU6ZA6N4q7j+Is71kdD4WGjKDNNmMVoiofbZG+3fZKmDXWllpgGNjC+dwq+fI8QxMSpObMPln0am1YiYlGlyfjOVB6MSXIaiGI04Z9AGNZ9aMwJWKtTkiR8CoZKM2ljUeCprqI1LpaAsx8TQ9NgYQiyJowmSz+GNA+OQrEerMxjEotUAs3GOot54Ezw468lXh3MSY8r+NGW11IED0AJII0STwKcoQZkSXYkEnJEkS67K3nseYe8d987EbeZVgkRv27XtlgwGILXQ/OzP/iw/+7M/y5133jklFYLrn/y2E8FaO32cfT7LY9CqnF3P2pR2QgonjXeaPngNWUL6O6U2OVFzCq/I/B6q29+N7r0TMSUhW4BsHovSDSGlawG97d107303+aF7wPZRR+rPL+aJ1qQ6tZEkUnP5JS5968+gHqT+8SgU5QDViFdBvEf9Ci9/8Xd5+bO/SyjX2Clju5u/rubH6/k5reqqFK4Hh6qg5SaXn/08DFfQ0uPHa4gKrq4IRQeVCVmIqFuApYNYESbSYe6Bj9A5dD9OklgPkqdzJBm9gw9T9PYnKhSbFA97tiCLOaKGrlY48ZDn6f4tysR16e47ylAKhnmedJ9MgaBkspFwA2YOyQpETUrdYrDG4kNIZc6gKaDSIWjK3BASAU68Cr/AbpLMu712rdchjbkMEtOfTdwBTiMZAhsrnPn8f2d88WRaWSJgTQI/xppgcrJ9RwhiiE0woP09WEqiREwMiF3AH/4AoXcbnckqhU4Ii3eT3fNBQr+LdhzZ/H46nYKMiry3SPfII3TufBexv4ijouNLsgjB5sS6xDAghkCoBoQLx3Eh0tEhomNqLM50kZBm9JYBP2iDQJAU8E6zZ9ccfTfm62udg61ZJJAY+dN+xKhJWCiMCGFIbXMmdg4JFusCmidFTqcT1GSMx2Mml54lixVrZ05TZhnGKEaVieRU1lBYsK7A4/HiGbslsv5hssoT6eO1oDAVQSxVzFEzh3cdbF2SEVPQz5Bi5TIxWqIRCgm4ooeXHNWYSJnqDY5/+v/g3OP/Dfy1qahvaCF0nfkiPW/6XESa+DnpL9Qk/EVLq6VEahKHSItnCBODUYvYGggYn8CSQolzjuHGOhtry9SLd5Hvv6dJMBgUm8oLpulouc6i72r23cw0v9l2S5YJ2hP0T//pP+Wd73wnH/rQh/j4xz/Or//6r7O5uXnd77flhH/2z/4ZCwsLrK2t8R/+w39gY2Njm5pVGyS0hEU7KYWnjzQTU9MDKwm5B6Seb7UZQXIoesSqxqF4hczYdNMQm3rBsw7kHQJCNK0anFJj2XPoLu77gR/npT/+nZQyVMF05ohRyYiJIlU6WK+sv/QM/dvuoXtkjiAOaWljW8GUGBiuXG6ynj7dwK7jr+vZdAKd+WzyETMIovRgDQwunWdvqIjB4stxWjF5T1QlFf2bnngiJpQYazEHj3LbB76fU3/wbKp5Sk4gov0D3P+jP83Gy1/nzOOvAAXEjJh3GJPOgxEhBMV05xLpkOvg47QpK833klLeUo9ZP3sMxwGsH5HlbathAiUZ61JponltNzXKtttltxTlrMb6tV7b8uGrVdba96IB8SPiy98mywLaXyTO347UawxPvUz3kSH5kQ41GbnUGFWCyanyPRx690fIOz3GxiAuI+v2ECJoA/hzHTCWGDzdBqrRuftBHnjfXkI2h68nZJ29kM0xth2Kux7ktoN/kyCOqnOQeuMY6ut0Pq3DOpsCLQLl6mXK1UsEasLaGllvDyGzjPFEKTFhgogSlFf5aKft5uv2+Wv19ezjznM5a9OiQSNApAoqFrU5wTq8gsOgxhInY8qNNeyBQFy9hDuygMsyxAcwhjoG5vMkN+ypiMHTW1ikTyRuXKKKlu6+PRAnFFlGVyqcjYiW6HiAZntgPGLzzDepz59k7h3vJLo+JgZs3qNu9Aw0BqIPbG5cAdx1AYS7+Xvndb4bxfr1nu/22k5fJ35DJfpEfRw0dfYknE9iEI1iiOsrqSzXz5hUHpoMqYhijWFn3nO3c3ktmvjZMfS9brdk2NOeTOcci4uLdDod1tbWmEwmN3Ty2gF922238dRTT/Hf/tt/YzgcbgsAsiyblh92SlrOPpqmnUXShtP2YcolkOVd8t4Cle3Qu/0hxHVRIsHaBF4jUszNozjo9LCdfiIOcg5jm1uVzRlpjswfwBZ9ogil5NjeHlSEGEPqOc56eHWE1YuUzz3OXL1KrYYqpkCAhgnRmFSHEImYbT3cW/7ZmSnYTeJzpz9n35++PpO2a9G+qoEQPKGq0sog+nQDajj426ghgYMSsNIrVLaLzh9Ci/nmeFKqPmR7GXT3IPsOEI3FeMGoJWSOOrNpEhFQcfTm9+P23o7pLqSfMYmV0EVFXQ9yx+DiaS5+8bP0q2X6MqSTJ5pZ1YivS1BNyOiU23zV+JqVTN3NLzv9uZsPr/eZ5gUmApaK4Tf/ghd+5//Jua/+EUY2iHGCCSGVM5oA1YYa6ydJWCqbp+oemAaxRhzWOIwqaKSKBrNwAJW0ar186jgbK6vkC/sIxR5q24Osj7F9oukwMTmjzjzD+YOUvUOUMo/WFmJNFEUlcdvHoLgYqS6fxwwv0Y3rrHz+T+lcvEweA5VVYiE4IbE6XscfszeRq9mN+LN9vlNKeqf87fS95rpPpD8R1YRu16xPtEXDc2Uhcwn97wNWPVQbWD9sgIVZ+ow05R0SV0ZdlQk74IRw+TTDb/0FLqZFRB5rXKMv4dRjokdDYHDieV758//J2slvwPAyqoHhxkUwkSAGK5raXU2WAHdavyojeCPX/W7j+bWM3etdE7PnUmjmNhGMpKyrNgRikQSwdHjCcJXMgNcUjKXIbLtkfbvd9vFa89fO194qdktmBiBdpL/2a7/Gnj17+NrXvsaZM2f48R//cX7/93+f5eXla3439T5Hfvd3f5f5+Xn+4T/8h/zGb/wGp06dwnvP/fffz9/8m3+TpaUlVldXKYoCEaGqKvI8f9UjMaW6VFK07ST1FFvbo1jcS3d+L5POPPf+4E9xoRozeuV5qk4BvUVEhKLbxdQl0u3i5hZR1yHkOY4O0mQPKtsFN4fLO+RZTnB9pLcE1iHONanqiLUZYiOycYa4ehrZvw+KDtLp4qoJmTEpXaiCMyAxdXEnzMFW1L8zUp5G7DOR9c7V6uxnWmroEBrUsy3QALnx+KiEIsOKEn2FsYas4zAkbvRtdUUjGDUEFdR10Kwg7/cwOiQTxXpH7C2ivR4TA51uFzdRpJsjNhJMSKv/qGAyioUDHP7+H0MWD2KspQ4TrHE4cZTdPWjRgckm1CNk/RQyfJBs4WCSolUleo8UihGl6BRITCRGsytT5xx1XeOcS4xwOwKD1mftxOS9J8uyqWzqbMDZ+rEV1mrLVjHGhJ4uwI09TmrqaoCVEoxC5sizjI5EMq2xWsHaWYYXX6E48gBOlWgT54JxGZJ1yPIOGiM2t1QmZ//D78Y4B77ETAZECdi9B5lIgcfhxGPzDsYajInUAhPJMabABJv4LUKVFCK7c2TiEJPhQkT9CF0/Szz9deLqcarT+6Hown6H9HrYTpciRIIoxtqpjkhrrb+ttdR1PfXf7GTejlPbfL89L1mWbTs/7Xda37YaJrPnMsuyVwHSMuuooiK5wxnwNkfyPuIKnElDLi8KnI5AEn+m6BgbKsziYbRcRoxFaNoxVTEGQkykQwEhy4VMPKpClCJdqzbHLN5G3t9L9CDBU9iA8xvkxqChplYlTDZwEoh1hak3mXN9nELW6yPlgGCLGe6M7Rmn9nF2LM/eVFsfxRi3+XG3sds+Xi97M3ue1NfEPG+IgxrciEbEOKTTJe8vYvIOXmoKnSAake4itr+Hbp2yillebJuPZs/lzuuy3Y9t+9D8/VYJDG7JYKAdRP/7//6/0+v1qKqKLEup3NkL+Vqmqvz5n/85qkq/3+dd73oXL7/8MjFGXnrpJf7Fv/gXHD58mL/xN/4Go9Fo+r26rnd9TJaSWy24LRqDqwJqLF4NvruPKjrKsoSFQ+RLRwiSlObwgbFGzIFDCVfQX4Cxow40DIQOL2myDsETyHH77kCzLsFkZKHE+QlUm+hkwOXjZ9gwn+XQj92PrUt0PKT2E0KjXAhCiU6F0N54a2qAjRq6DjaJ9QSxGWEyIlRpUkPj1mK70U+PpJSfJ92EtRpTlWNSRUHIO0Vix/MV1WCQVmVlt1HqSz3aqkoQB0uHcft6DKWTIFumoXEtPdnCQbK+I6xcIG6uc+Irf8qS7Gf/B34EQVANVOWETrdHCJ5qMm4kgLePtbIsAaiq6oa981o+OzUBvKGuI0bXMdTopCYEi68ik3IC9ZgsTCg08MrXPsv4+Le47SOfIj/0ABMkrWoBrTWt2gFiILgC6S2iYrChwo7XkUy2Sl4iSFQIHqcVRSzJpUgcBihOS3S0gvT2UPmIzftItFQ4HEocbzA69SwvXXoROxhyavkS88tXuP9Tn4TRmHEFkxBRbswvN+K/neflO/nOrE0wIIaiHCUgn7GggkSP9UOCS8qHEmuqskrBzGAVX9cUB++mXJ2klkFjEaNIBGLqCJBOTNJk9QgdbyAmp2xY+gZ1BfO3Q3c/1caQXrFOGF6mngwIFIxKj1Ww1RBCzfjMSWTlBIceeJRYjRmOx+Sxoqp3jtzXdvytfUdj9zq/aYHoh/hynDJxoojY1JkRoRyVqAq23CQLSUCq2HcU3XuU0ZkV1JfkIU73X1Vf03VZluU0UH+r2C0ZDEA6uV/96levWte6XjCQ5zk/93M/RwiB97///fz7f//vt0XEMcbpSuPGZI1ni+OtJUKBNgId00ktgAiH3/cx5t75QSaap5rYeETphN6dd1Ih7H/gYcaXKtR0EluYIzHhGTAaKG3B/nseZmwCExz9eoXO2ik2zr4A9QSrAR0s09EJPpYQa4wopgXBT6tyb1I9LNUHpp6KoQafSjDEpjVQwwzVcAIaGZRqfTmtXucMeZ4htkvMFqkiIJEHHn0X3nUZjRN9cCkgnQIvOYJDGrmgYAydw3dTSY23vYRe1oiLAVPB3vveiciItYuvQFBUJ4TxGjEEcutSJ4j3SfnQ1+mQ3iz/7WbKVNI2NKC6TLrkPsd4BeMRI1gRbKhwkzWYXMIOL5DZ+xmHJmwVSXgJLCbGpLaXddH+3qSDIYr4CdRlCqxMUie0BDSzWAvWl1gJuCaAM9SYMMLFeYzJmT9yN1lVU5tE8gQeQolsDik0oNUF4tpxwsv7iINVIKZ225taeC6VvjTUifCpqXUXotSDK7g9+3HWYEJN9IE6KL4uqaNy6JEPc2V9hDaFOtVGwQxNOAsNZCawduUVXBxgQ43J+ymQdwWH3vtRjHNsPvV5FsrzVBeeTSUZM8+49CzphDjeJDeG0g+YnH+Wek4SxbMwlUm+mU1IvAEaI5gtACJNySDLCvxkwPqVV+jc+wH2P/J+5u/Yxzf/y0mqevmqWbm3bXe7JYOB2fRqe7Lb9OqNyFaKCHVd84UvfIFer8ef/MmfcOXKlW11pfZfO6Bei6XrTEg1rrQ6MKJMNJvqvbu5fYylIEqGMSUm1AQXG7lggxa9JKGrBic1gYBYg7WClcTGVVIQpKKWnJ5UnPjT/8ro4mkIER+FwkERhmxuroC00jGze2mIb1JeYPvEk1aU4quEcI8e1EAM05bM9uNGPbJ6jklQ+vctYrIC093H/kc+Rm0XEL9O1d+DxhyqPJEoZRmLD7wD6e0nxjxhwCUJC5usRxlKvGTgRzgTU1ZmfYTpHyRolVAUmtqWfDkihMRwJgB1BaopUHxzPHdNMyHigEp8ar2qlV4NYbQBTAhiqXE4myPqIUywvsRgwBSJiVCkwZMkcmBUidYlgKpYnICpJ4ifJEyHKkmPMRBtgWRdBEemWQqwxBBNTZRAotWwRFsQ85zaZASpiUabqDQjEIjUDC6+wAt/dAozWcFJTPLdN7OJTb6KHgk1RiLWgNWSS8eep//oB8ib8a1eCSrEqqYOMMr2QHehwdFI027c0DfXNUTPaOUMF7/9OAf2HqIbx6wPI66boWTY3nzKIqye48QTX6JbDrExEoxDx0O6fhNfN6RN1YjlY0+xdvIFTDUEKZLq53fZfdeyhLuKqK9x1lLFgNhmBrMWEcvc/DyXrpxh/cSLLD5WofOLFPkS5AtgNzDmrVn7/07tlgwGYItQ4sCBA/zIj/wIi4uLfPnLX+bb3/72dQMCbSbz48ePb6sZtTbbPXBjg6mtcsftvDepIR0loibD1olnPRQLlBTkklF7n6hEicTao7KAIzDBUPcs1qR+5RgEEYu4OZwILgYmxpIZxfpNTBig9YBYDxJKWITR8jnOPvGHrB//dvrdEGbyF2/WVCC0rAA2UdPgU9M7NtQNz1KFUmBjIIuKp0MUm244MfGZF5MBSqDO5zD7H2T+nd+PLtzGZO0ck46jQ44Tm+R1XUbvwH3g+jhJneFBM8xoDZPnROvAjxIAzORIvUJ9+RTxtr2QzzU8M4muVUUoMgvDZS6/8AxsDCkOLKZzYuybVWO5qm1V0VNWZP3sS5z/6h+weeYFIHUbFH7Ipaf/guGls9CsQrNMMN4kydcGDBfEkirYNYpDsw5Gk268Bo/W5ZTPwsSYXs9SyaBaX2Z85RjZve/A5/OAIVqLCXUiwnIFUVIJqDY5kSyNeRwVoKLgh4lsaMoieTPfriD53OAnI5aPPc2ed30sUYhbhxms4uqKmM0T1CG1R8WgUSmC4tUk9lBVrAaiJPU+qxbqQCDghiswHrB6YRP5yu9R77uf7qPvQ0yBRrCTtcQfMl7FNr03oNh6DDjKibBXPZPhGhIDYbyWgjnxN3UgAI3ot4BQ4fwmgxNnWLz7fkTSoqjFSk2qEoYjOqFknBeMJv00lxCIUac9SbN2CyRFvit2S3YTwNaN+pd/+ZcJIfD000/zC7/wCxw9evSGt9Gu/NvVf/v3bp+7tiUGNWhDgiYNb0B0ghFPrQ5Xl4iWFHc9SvfgHZhIGtzREGOFjYGoHXIfiNKlLDIyScBAozlRLMXSnXSLgk41oHJgdIJZfokiphp6SrXXqEIcXuHK13+fevkU6sekDu3WAm/OncwAiVY1b4oT2qCxbRjTrddThkDBxYqOV6L0CVmO1QpVi1dHPtoAY5hkC3Tv+xBld4naKBTzBNdDomKdgkutbJnbh9VI5lcRhQpHfekk2WQZK4E9soFQUWmOjRU6Po8NJd4XBFWMjgBF60BRbbAwfIXJ134ff/LrLJSXyGLZkOK8CS68hnlIVXVN6Ao/OMP5r/42Yf0MRIOJYxY2jrH25f+Brp4DYxKpk/FkonhSz7sQ8DYjWEuGxxISOJBIReqs0TrVuBM9cKSULiqOTAwyuMzqF/8zcXyZ0OT2xWRIvUFXB1ixKUgDgslRuggRZZwqHTH9N9HAgNSDfnOXCFLWKuXcPcOXv0VGTTBziahKPUXwhLxLqQZbjRACkUgx2STTOonuaCTzgdrF1CEQHZQRLymLo5VQj9e5+NX/iVw5RpJCN0nyd/0cfrQCCgMELzlohZ1sUtslKllIlMnDFYLmJA0UReINgAW+y5a6XCKu3mC+vMzkG39GvnkFCR7rCsiSRHuICnWk74eAT1wtpsDGGmOb7qXpVmW6bHs7X/Bqu2UzAy2SuCxLvvSlL7GyssJ73/teOp3OFH393d2/BpVPJJOkHJg7i4bIoYcepDO/xEZQxFlMCJhYYbQk04DTkhAdHRunNx0D+BCxvQWsK+haYRxqjMD4zClOXDlJubaa+PGJaTqPrTrfd9MUqFEi7RlREfA155/7OlbraR0wqDap14j4MZaAiCXWFRtXzrMQSqK13Hb33WxaRTWkTIA4omoqJUZFQqDXK6hWzuH6XUI3I0iWao+xJo43OPvSN1l6+LFEQhTCVKEQSBiGZtfL0y+w9q1F1tdPo6ML+GqTE1/5NJsXXkm98PpdTw7ssK3WTDSw+tyTlC8/h5+sIFoBRaL4tQVKlrQWmlq1sS0fRTNharuKUhDF+4q2AJZeN6gtiDaFD6KePEwgjOhIzVBLTj39FEfyjOK+D1OZDKueqo6I2FZS6s130RthMaTyiUno8xgCRj25RGIokXpEriUSx9SjdTKtkU6HYAtotAWiJvE+DalMINsWIRF8Ar4lagOhGg2nGJYkR5yEgPLxKlm9Tt+UdMOA8cYVSOwl6fvAzb4+NgABBidP8HINk5Xz5PUEsftxS0eRlY2kkEnKgtbRE2OZGMLnFqiuCJnX9u1pNnTm6njbdtgtHQwALC0t8Su/8iuMRiP27dvH/fffzxNPPMFv/dZvvcl7NJN8n06wER8qqsEKne4RQl03k6CjiiaxBxpJLHaN8I0RTW0yRAoniNZJRT0GXObwtoNXQxit052bJ9aeYrDKpae/hqs3cQ2jl5kJAr67g7/lF2tWe5iEDwgl68efhlg3NxshREFVkFjS0xITKtTlECsmGxfZO14nFoYoDmsdsS4RYwgmo6ZR4lNIVKSRyZmXWLjtIFlvDzUZIUSMRur1Kwye+QZHHngHMfbRmIiXpiJEoZXMjcTNi5z+8h9i/CYuenyouPitLyNaUah/0/Ir35FpYHL6RSaxJo/jxG+hSvAkgKDt4euSYroETy2mOuVPaBQHNdX3fd3K3mr7cWiocWNUtB7jNs4x2dgg6+fkw0tMzr/EhWdz7r/nPUSxhPGAft6lFAVxoG88HfYbbqrQpKRb7FKIccqAF6JPuhEEJHjK0SY5EenOUbseVg3SMBxGAhpqJDQ0lqpby1jfdEq1rXajwTRw1aYkKXGC3zhPb3yJlbXTuGFOvXkJo+U0GGjxQjfxyE3cHwiTKxcYL19EbI4NE0qTc/B9P8Dc4TsJWZbGqU2dRtYEitxy4MGHOXvua1hRfB22Z3ZnUwJvRwXb7JYNBlrMwL/6V/9qmg1QVaqq2tYK+OZYgv9Acy+ivSlFJpurvPi1L3DXD92BxoAYy6SOdExGVME19f2ohoAQJCNKWmlhDF4TH7oRpQ4eM79EULjw1T9HnOPwhz+CiRPQCSKJ4MUrNx9ASIBGjAVAtMbVFYriJYEs6xCwYsnjBC4eY6P0zN/1EFYrBpdOceLP/5g7PvFT1L0FNMDG+fPMH9wP0icYcEYgCDLXRQpHPbzCsc88ztJH/yqL93+AsQ+JttWPET9Mq7UOjbRqs+JVRTTxvQeAOIEqYjUFCFHr1PIlmu4B3yV33pCpQj1oWixDmwBIoo8mA1dQT1bpEmj59GcVLNu/EqgwEnyrIKjTUoHY5nOhJI6WOfbp3yZohwtOCKMVCJuMTz/P8Pwp7O3vYOPUMW6/8w4GsSSNh+8R04b3YBoMKB5HMDl1lAZImcpjVYh4NWjRJ9qczEckQhAlSiSGOhFG7SxPblNkVdSXbLEIppS4i57LLz/D2vqEcuMKKyeeoNxYBq23ndmtfzfVLDE1BYJ6hLKhW88xtmZsLdXcAcxtimQJxKoNtidMNlk7u8yeg0cw+SKx3kSxiMQGuwU056CpqX43D/Gms1s2GGjLBD/0Qz/EJz7xiWnv6K//+q9z6dKlN3lvdNuzdBEHCBFiwK9dwI6WyYp5QKlCoiDOrEU0YNEkatIIdXhJCnLRpJ5aIwHbrBDm7rgbWMevn8PEmqJ+Nx0LxAofU0+9h1ZrN+3UTXPHasLy5kZim+xFAhR6Ql3hxFCECWHjLNU4Yu58CKnHaNgkXD6D8yO8WYQIcX0Ne2g/ahxetWFWtMzddhS7ZxFfj6mXX0EvHcMevZ+cxLlvY5XaL6GhPk2MgjF4cGklvHUTTCu2NriKzf9RlfK75MUbN4VYNXvcjIYoRK9oVHCCH25gSEI5xhi0qeQb1YbvISaWzeiJ0Sf1DSGx12nAZImrINQTXKyoV880UNEUdVgUJuvIZJiuhZVzdJYEXT//PVG4bZNJqGLEJNEsJPGBSEalFq+CVnVTNhRCiGAcea+XGB5FCb5CTEFtAiF6jJLKZtCuMGDa2SQJ3BoqWp0GFdN0eYCvhowvnQCtmYzqJvqbEVm6BaxV9VCtgRpRiFJRWcPI5lhT0KFp8VUwYtHRJvHyOXqPvBM7fwjZDOA9OqvB0KZudfrH29bYLRsMtB0B73jHO/iX//Jfsrm5SYyRyeTa4htv4B7t/poG/Op5Tnz+D3n4h34SJymdqKpIDFgdk4VIJ4zoqEPChFyUiUaiWqzNSIyyPqFoM8dkdYPy4jHmlvrMxRFjdDq4W0GXa+7Wd8OmF1+amNpnW2TIddIbiIErJ55j5fE/YuldHyUzwmRzBWKF1AOyUFFKxCBIXWKaydALSV6XDFcsUOVdxlWJVOuMT36T3vu+n4GvyA2Mgm/aLy1BLLm1qTSjbblGt+142leZOZAmumom4JvHybuZNNmXmb99QDQkDEE5wBXNMYgkeVuT6PNEwApoiA03RAqJRBNTpIpgiw7RpFZdQXAapgBCaPpINEyzLX71Ak/9wZ9RDzfeFMXMN9K2nXlN40ScQzWBkoWAJaKxxoQJORWGCq1HmDChKCxVqMhDBBuZUFNLuirMjWBRQj2z4rUpZa4puA2xakowW1uZBdLd7LZ9FZ9eK8cjnAZc9DibeDEkJCSSwWCqMYMrF5n499I9+iCbT5+ZZv1skwyI07nybdtpt2Q3wSx/9osvvsg/+kf/iF/6pV/il37pl9i/f/93e/em1q4uTZwQ1i8hfpxSqyIYAUskToaMLhxn7fSz5PUaHb/J8PIruDBONLKxTpShzerVB6jLEVqvM14+ycXjz3Dl9BkkgFNJ0V3LKhLB6s106bf9DElyuU7Ct03aOaSVjnp0uILfuIANY9RXTJYvAwH1Y0yoiJJuRvgkvIMIwURUDCIFQTqM1KLWkWuNX36Fy8ef5cqJl1LAQQK/BZOh4rDWMFxfZbC50az0dAqem5qh6ceffT2ymzbBzWWJ+36r59VACKl9jxrKcSMFq0TVtGptSLti8IxHQyDd3GLwTd4gPQ9R0WKeKptnpAWzTBYRSyRLahMRli9cxBmDrQZUK6eRyWrDVfC9YZpoLhGXwKwaIy7WdHWCqTcpR8tcOf5tys1LjM+fxIxXyaTCaMXKmVPoaIDEulm/3wDiXbXJDDTYIEnC3jr93o48gGx/cvPMCbtbOn4BNQgGgnLm+RexozFzvqbwNQbBNBoh0UdsrPHDDRTHne98jGx+MQXsxqRYl5v/uL+bdksGA7OkQO9///v53Oc+x+c//3m++MUvMhwOb4gkqAX6tP92CpTMPn9txBWv/mzUxLaGCpL1yYwjDzWCZ3D2OKf/8L/wyte/hJOArp/nzJf+lGr9MlmcIKFGUOqG+hSXWAlEPQzXOPH5P2Tt9DHMtOa7hV4wu+7Nd8Nm65Oz/1Lkrya1H9pYIdan5WR0FMbRDxvIYAUbIWpgokqMJDBUXRLVYWJivou2gxpD1IxC8oTeJsBkk9N/9rtU556nqNboUSHGYYCuVvS0JFw+y+DsaYwkOt3kOGkmWWhb97ZNKjd7UgBo217T8BCQQPRjou3ggscMN1ApwGR0bMTGgFXBEqGuCJfPIiYFBkFqavHUOMYBQlUjxQLGZth6hBeLZzbb02YQlPHpF1ioVzCxQkPAaI3RmxfAdiOWRnCdAqSUq0ezDhCRUKYEnXqoh0zWLnL8s/+Deu0S1YUTTC6dBhHspYuc+9ynWRmMGWeWwoOtA8HURKkRk0ozYgzBZtRqUQl0GCOhYjoaNdXPk/9J88NVB6dyK+DqpVk4JFM2X/p2auEMHmMLTIwIFhXFVJv0NabzYSH0FojGJEEmFJVZfMpNUze9qeyWLRNAEra4cuUKZVmytrY2BRG2whTX+l4bBLRaBrBdu3qWffC1MRDqq56pESQEVDr4Yi+5FBTRMwGyahM2TqMmraK6YYSZrOG0xpEmXhNCYt0KiYyEkNDLWYiE8XICd+FnEoJx+v/NMeyvUkKZ7nGGas5k/Qq5lFR1DcGyfvYcYj9PuXyGTKGMFdEYChrVtVBRB4fRmiJ2Ca4AUZxYilFJfeUMXmIiLpqcR03Bxae/gOZzKfXtJ7B2nsvPPUEYXCSfrOHUk9kGxC2OKep65hBuDp/eiKUATDSSKVSSCIW8HzORDi4O0cEG3i5ANp9Y9DRiSGyEdYwU4zViOIgVQWSCxAlWEvY9Dga4ok8eR/Qnl1mXpDWfOlnSuTVGqMUSh+fYeOZzlOuXUZM3K+BbOxhAwGoiC9KoaFBid5EQPFqPmajgrEM1QKygHKdOASK+nFBJRm+0gRmco7IWySx7x54rFy9xea5i/PLzGKnIAG8Mxli6xjJYW2axU6VWQzWIMUist13vrmnl3SpjzD65uYOA1lLAUqMIogHKZYrRBZRIaQs69QYxChonXHr+Cdz8PuJ4DXTCOOskPEb0lCYBs1El8bEronKLeOHNs1s2GGj1AkajEZ/61KcYj8eEEPiP//E/TgUprmatOpm1lg9/+MMcOHCAL3/5y9uAh7OypTemTXB1cxg0CtHmzL3nMaBPKTapuQVNdLwE/MYVur29mFhipoI9SkYkq0swjjqEhrMt3HS3/O/ERMFET9SS0cpl9hGJ5RDHhPWXv8n6maeRMCEDxFfk4w2cn1CrIVAnFmMVCCVOFIxinFAN16k31gk0LJLRg0ROPP0EmC7SPwxiWDtzkvPf+CLUm7h6jfm4waAczOgO3MpTxtb+t3XlqEJQxfuAEyX4QGW79O96kNBdYKwp2NIQUptnWeMkgwrcaMyByYALay+xZ9ExHG0S9xwB5xKeYBeoitdUxy43rvDs5/+IGAKofzNVMd5Qa2mEYxNzFodvJ8RN1JgGJqON8l5i0mzPSYwRFYvPxkQ9z9zoLMVkERsNWRiy/GdfhmqMaSAsWnvcZJXFjfOsnbqIPvwQPqbFy1Y2EG7mDoHXYtNjEkllz+ZVXw6Zk5AyeK5RNYxjLj73dbA97FwfjTViukiWbcN0bO+meNt22i0ZDMxqEPzX//pf+cQnPsGXvvQler0eGxsb18wKtN9XVd773vfyqU99iq9//ev8vb/39/jX//pfU1XVVGqzzRS8Vm2CnaZVQA2MfaR3x1HGY8fYJKCR+Ightb6cfepLrO+Zww9XEQ3EEPEh0nWWzWNPsXDXg2g0nH/6q0iYpKyvvHbthJvJUj+xUkkC8DkE9RXoGAljYgVqbJp06wlnvvZF9r7XMn/0AYIfo+IBQeoRzipibAKs+QmISbLSDSbB+KaX20QkJDEnG8e4egPihJUTTxOtY/XU8wmENdvjfYvbVl1ZiEHJRRksX6SaDCmBhSNHiUUHLSNUI8qNK/Q6fSY+aTWoj0zOn+Xlz/4vVq+M6B+ZI5s/wNz+o5gsJ4QdHAQAWLwCBIgBDWOMJHKdKEIrlnXrmiUmTsYpzmJuYZGwOkhqo0jiHwixuaM3WBRDIrrSnCAVxGWWv/5ZOmdW6D32UbwtyYeX0UY5xJPkdDfOPMOJP/v/4efuZ8K7G8GnyPY1rtwiRYDXZgnL41k5fYLFd69i+gVqMtCQWqtjTQwVTGpsqJDm2r/a6Ppe8s3rZbdkMNDqbMcY+fmf/3n27t3LxYsXueeee3j88cd54YUXrvt9gPe+97388R//MU888QQf//jHmZubY3V1lTvvvJMf/MEfZP/+/XQ6HfI8R0Tw3uOce9VjW0qYVUtsdb69D8z350iUIwZvC0KeU0ZLBlgRMmtxVhltXGRz8ywm72Cb1UOoKkRyVp/7OvP7byNoxvjiSTInFNYScQkUNlN/nd2X9rEVYLraZ65nO7c368edGvJtJqV93KlzPvtebiTxpud9sBkmJBlY2y3INeKjRzODRKGwhvHZY2zuu53FOx9Isq/qEQTxJWIzpLcHKXo4IsYIWacHvsJIxKnHqBJyQyk1WRxThBEdl3xXrZ/j4pNr2LBJkVkEhxFLDHHb+Z7VZd/N160m+qzo1U4fX80f1/LV7Lmc/ezOz8z8CjTKF46Imi5GI90stW8Ols8SyzWsCURrcLGmqIf06zGsnGH+0B2MTJn4LHOLCSNWTz5NlJy1E0P2PvhBrHNkRZFke/MMh8MaoW5YDhO6qyaTmOh7MdRIkpNu0r+qcdv4vNbx7xy/7Wdan+82TmfHY6tV772flhVnt7nT1y2b6as+C+By1NcUJiM4m1gDm9+TholQTOrKyDoFMdQUEYI4RATnc0IN3SxSnT5OZm/DZxAXc1wOToSJ5ETJcFqShU3WTj7J4jtvSzoP1iT57pC4HL2Cikvtyhqw0pJI6a7j6nrX/aw/dp6fa43H3c5d+/3dFGV3O0+JkwUCDoMhw+Mj1GuXseU6rrefOio2z+jlBoNS4rG2pktFJUrWncO4AptBGQyFGComWFNAMOgMgHW3fWjb198qdksGA+1Ay/OcbrfL008/jTGG+fn56fvXWi23wYQxJrVEieBcckUIgdXVVR5//HH27dvHhz70oWkWop1sdj7uFgyoKiEEYgxMJgOCnSNGJWIRkxND+s5kPEzSp1qhDEDq1AxQe7QO+HJCzCyUq6lf1li03MRXJTWakAKS+Ax2mwBnhZh2ijFZa7eVP641OewMHGa3NxsM7FR7bLe/M0CYykTHxHgXmos/8x4Zj6ijJ0SShCkejYqlIvpVQrlB1IiWJaYuwdb4coS4DhT7iNkcwVfEckysqiYtHVGNqbWzLol+hef+7PeQcpNYTkADUTdRxoRYU2r63SCKamzOZZK1nj2OneOt9UVoSGN2BgM7b3g7/bHbhDr73m7bDCFMz+WrgwEhrR4DUSNGa5gMyCerdKoVBn4zCRNlhlxrLj3/NVYuHcOvXWB58QDZ/Dw2DjHOE+OYGGsUC1RU4yFiDFmWEYdDoq+IISARvFqkocDV4DFGCVExEvDaSOimBDuqcdtxzQZTO49/9hpus3dtJnBWYXRnYD47Lttzudu52enr9vuz56KV0lVqJHhCiJTrq2xePEdv39E09urGF6rU1SThCEIgNLLZVVliakFrm0r/vsJUQ2LYwMcxJWBDSBoFVtKql0jUMWFykQ4bOPH4usJGjwoENahJGBHV1LGjvDpw2j1wfLW1/mjH16zfZ30yO/auNnZ38+tssNxuu72mNCacTsCkdsCY5Li1GnDpxadZ+uAdRE0Sx6FOapGqFfUwcPybX2XfR/4KmIygQvA+zb0SmvJUREICdu8cU7P7u3Oe+163WzIYgDSQ/vpf/+s89dRT/MzP/AxZlvH0009z9uzZG/pujJEXX3yRT3ziE8QYqeuawWCAiDAYDDh+/Dibm5t89KMfnU4ebfCw83HnzaC9GNr3jIWaOl24QdBo8HWNzZWoFUENdVAwHhMrokkyuUZA6wpkDq03CXVJdB1MOYSgLd0IcRfcwG436/b1dh/bG9ZrtZ3bm31tZ8DR/lZ7ke98DIARg2pF9Jv0Jqu4apMYKqLmuGgJVWqvDKFOwVI9TEHRuCSrSlxPWS0ndJYOcfTHfpasvwfWTqOhQkOFaEzsjo2XJAaQIeOT34KomJi4D4g1RpLI01bTlkdEp+ey1bzYGUTN+qG9kXnvrxuY7vTHbrbzXM4Go63trsXRNmhpIrvVgMGj41Wy8WXGF47jqxGqBuO6iVBo7SIbLz2JxAHl5dPsv+d+8uEK47XLqAZUPaIWDYKGlHkIIVJNJqhPQZtvfKfqk/9QSg+IICpEjYi0Y2/rhns1n1zNN7O+vtp1uNPXs9fl1UTJZrcxe53v/G0lYAUSv3NJPVzDxAoRhVA3/iaRifkaYgrIlCZ4pwZVvE8kQtXmObrrp5HVC6k1M3iQxL2hGggGNHpGl18hu/IifrBKDB6jMWGKBbQlGIoNKT/br/mdx3g9a33Ujq/ZIHh2kXS17V3rHM7uT3ttTefWhhdAJTRBTbqBq44YnT/FwTjBmw4xJNn32isqgokV6yee5cD7P4lxBVVUQvSkklWADELtIW4vUe02T+3Mpn6v2y0ZDLSD+eGHH+ZXf/VXeeaZZ8jznEuXLjEajV614r2afeUrX2H//v187GMf4zd/8zepqmrbhTI7ocPVJ6mdqcadjxM/QU2FxIgNilWL92NiqKljBSQpWW0Y3mgJcEJNKFM2QKgJMaQJNXHEpfa6q9Rdd9unq+3ja7WrBRnX+uzVzNAgsmPJ6NIpnv3T32V44SUkKioRg8WoaVTMUvYA6obVzZP5pLBHXRG7e9DuEmVQ1J9EJGJaUpamXu7Vk6HYGFEZEtQQG8IWowGrLROCofXt9fy1m693GxutXS9AuNZnX/u5a1exAAmsqqM1nvyj3yGMzmGWbqeWApfNE9VR1zVWS4pYUwVPfeoYz/zX/0LYuJS62BWsKlVt0TK1u4YYEwOozIK0ml/X2Pg/Y0sxw6cxvuOzr9Wu5evdgvOdq9BrbXO37b/qcxrQoE2baQ2hwqon1CValQ0HRvvZ5Lt0zIr3JWrHBCaoAWJguHKSp3/n/0RHqxifWmTRlo2jPRZLuXyRb/2P/xdhUqbtTvcJIP2Wbr1w1eP6Tuw7U3Xd3a593bTvNHOMNp2xEvHlEKnHuE6OIgSTNSRZmoKsMEE0tQ8HTZtox3/a/KsZB652DG22461gt2QwAOnk3X///fzzf/7Pp1F7jJF/+2//7XWzA+0KYTQa8du//dvb0luzE0tb9/9OB/u07ohQaU3tKzKxSBxj4wRreqgakr64NGs4UGMJlBhRsljRDwOsdKgvnKC/Zz21KZEyAy1UaLda6Rttf5nfmfq7fcFHiGOuvPQEIqlHWzXgm4lNVACHRkFiJNdN8ClosgSkGlOrUmYLZDZgJSQVOBFiOxk3qemgjZRyUJgGVGnC2E7Vos1+vLYb+Gv1wezz1/d3to4o3RxqIkodI37tLMgEfI3TiC8WiarYeiM1/WmisDHq8etn0TBpAlUSuDvGxFegHnGk34kQBIyCIaZSwFUORUle/26su143X6vO3FYCvk5S3Jkh3Yzw1CLUvllcoASTgJPRl2BqQj1utlWiXomrQzJRAt20rw3MEiCEJsWtJX5jlALcJthtZi22OhZeH/vL+ug7HePb3m0DONKcE+qSqDVKgLqRY5Y0G2Ic1DVZKLFFgRqDjYpITEF/83x6TVzH3s4M3AImIhw7dox/82/+Dd77KcjnRkWKbnSVEGP8jtsK2+3aCMQJdV3hMTgpiWFArLsYFRpF+qaC2qTNTEVZD3F+yF6/yssUnH/iT7FMCGXDCgdM6X11+2/e7Nbu5zS5HWlasIa0926IRElH6dQgmlHTwSks6jrWQFDBRI/EGieRkViyWOH8cCr0lGyLK2B7UUWn7zXPtnYI3hC/7jburjYW//K/2zIuAlo1Iw0ImwCYuiQPJb6zHyObUK2g1lKHxBcwMQp+DTQSRJqKa7O6D5uIKgGPhIBEJTYMjQ6lmlLlwm7qhG9GH8Fr8fVrt5Sjq0kBklcw4qirlCVAQ5J3DgCKVcWLQ9WBL7HGJCXCkLJSoVHrqJRm3G/pYmxZSPV0oBUp2k44/PpyN/xlffSX87tpBm5TCFVAhTAeorFOZEO1x2okSPKSj12MT2JkWZahVrARVCMVOahBGgXHG/HUrTKfvh52ywYDAJ///OcZjUbTGuAsoO9mMiNA9Gio8WSoSTW4Ba3IY5kalKeyPWmi7fgRUq2zfv4YI3eAeryWgINxwo5E7I6/vzdNiQipBl2PNxhfPkushlhRanVUpacInkxGdOIQv345SRzzVvDOd26xqc9mzjFe32SwugwxNbdrk17d6cPppD6Dn9DXeUV6a5gjSuqGQBzOZukGHRXFpDV98/e0Vz4tb8FXRE0Ko7TZK7b83Qb5b9sOH4hCXeLLCXZux9hsn2hAyyGZTRH+9sBft330bduyWzYYEBE+85nPTFtA2tr+TsTqzWCmaaGy0RPFpf73akQ/FqxP1rYR9QJIqCmqTRyWUy8+wTeeGRHrMcQJRutpcWCr7vW9f8tL/gmgFRvnTvHkH/wucaJkWrO6MWC0ssYejfQo2Tz1LCtf+0JiaHvbrmGp5GIAa5T19RVitVWHvu4lFNqslDbLtreapSJBW5+39YheGLI6WmsuySYwiLNXa5PU9xVRAyHGhBnQFuzXFq1ucXbG181aH+uW/2KdwL7T0Gm2pp84WxhvUpi4lVxo32tmz7cGCuC12S0bDLQ3/1kU9euX/nt9LULqs66HmJhSf/WVc5w/820G509i0STjKyndb4LnzDe/TjG/Dx1cJMQajVsiui1k8OY6yjfImuu9je4NHvUlYWMFbI7xAzLTBV9hiUg9IRutEQbLTRL3bbuWKU0gjaaMQEzo9fTetdtNp6U2bcPTt9gUq0m4yQAhlqy+8HWy6Fm7dAbqATYkQHJiEpUGaJhyBlIOyYwSWuVGmWXag7fI1X1Nk0bQrB1XIgmQCoHcbo0/nRl6QkB9yfnnnqSqfMrITtdKiS9yduH1tm3ZLRsM3Er9n+IKqIaEzUv04hgRw3DzPOef+hKuWsYoTGXyNKG1V04cA/MK4sdsIxSa+ce2V7+HbabW71AMHh+VaCNFXGeutlyqh0hUXGawoU6tXfHt1dX1TGMkBI/VgMS6GWstHE2m2YFds22qxJgAss3y+M3c9ZvAIkkrEERr/MZ5zj21llatmeBIOAsJW3wULcBPyhHOT8jbzgoxqArTfoy3mit3mFz1WQT1jAcbdJa2+BRatwmRGCZcOv4sJi9AI1t9K2+HAdeyW1K18FazKhgMMHjlBYrJKnZwicGpp6FcweDTZAIppSXN5BJCAhk1K4/W3mqBgEBD98p0XnCqWDxoxbEnv8DqM18kDq9Qe5+oWxuPSbsae9uuaTHGtOKKPrW0ztz0Y9wi6NmZJUjl70TjcqsE5q+3tdejAKIlxCHERGKlIV3bLbYCTWPZovh6AuNNFgqLE03cF9t0Rl/d/vZWs+15kiYwjRH1JSunT81MfdPeQQwxKTaGCaYeps83M6zMbvit7dpd7ZbNDNxKJq5AxwP82hVk8xLrF87jL54io0Km7UmpktVOLgam3PhbAJidsdutzOt+o9bomc8AqoQm9SqBK6eeo+N6+MX7QBOPe5iqDaZPf68HTH9Z0xhSMBB8Ewi040owxr6KKW76vZk0bQIQvtVmWNNwUsSZW3hsrmGDGIeGQPRbGSoRwQKTjXUGF88wuXweCXFaStjy4a2u2/B62ta8mKopClXZ9F7NfmoLYSCq5BLxAjQKhe2MoG9PCbvaWzYY2I2u940yX4/TIB5e5tin/zN+MkZDSdB6yooXGxBWVBoGt4Y7gdlx+9YbwdNWtmb5FWjZAYFG5Cm3JRMfCVEwIZIRQWzDEfDW89lrMSUmcisMRhvOhZa0hjjNDMAupYImgFAyNJZpW2KTyFba+FvAGv7/doAmUgoUqHEw3KAeXMa2OAwVaiCOlzn5md9G62EicxIBTVf+FmLjrWvbQX/p7j299YeA80P6YYjLAHFY0riDLehFCNqUZbagm7rtyds2a2/ZYGA2EGhJh9oV0Cw39ethuQmMiagfEy8+30yuW6QXsf2/Ge0pqZiQ8NtB2m/FEazT6bGNCaYd6xFyaQZxUKSa0O9kXFk5C8YQ35II99diKQsQfQnikJhkddt3BLDGXDUzgAYkVigOdAISgQwhsBs58vee7Vy5pxJLmlcUj6HjS3y5RtFkDEJqHUC0xI0voCTC5mR1u5Vdtv3Ws51+2IKleMaXzlCfP0YYrSLWYBoF7RZmLSJJuMyXMEPPNrPht22HvWWDAWst+/btwxhDVVUMh0Pqun5DgIne+xnmrbdMH8CbYkGbcspknQW/QnXuNJee/zrElsXwu72HN7lp4sk3QiMOsz0PFa6VGWg7EIxBmwD37aGdTISUDfB1oyOyHcSWSBybksIueIy37do2vHieb/7h7xHLJD8ezNZiqolxp5oJb/v2xuwtGQyICJ1Oh1/91V/l29/+Ni+//DJ/9Ed/RAjhDSEuyrJsqnb39sB8fU2BKkbwG1Snv0k1WIPhBURrrDUEfX2zPN9rJkRyaxJmYIefUmbAYky4CmagFdxpMQOwPRp46xVnpzom3pP7ES4kRHsQm4BtMzlqY1KJ4TtlOH1LW6yIg2WQGkxSJWy6sxu4oJnKT79tN2ZvmWDgajKzw+GQEydOMBqNUN2uzT2rwQ3MrO5f2wTXlh3eaipYr5ddi9M8CiAG4pgXvvQHiQbWTzAoMezOM/Dd0HG4ac0IQsBKU19tu7Ta+/hM8Lp7e2HAipnWa7ebTHEbbxVfT48xBLLJGnnuUuugdUTv2Y4C2ppXXq+54a0ytg0eo55IIz40Q76SCjG6rQw865PXKhT2VrG3RDBw+PBh/tpf+2t0u0n8Q1X57//9v/Mrv/IrOOf4u3/373LhwgXOnz9PCIG77rqLn/7pn2ZpaQlVpdPpTOmOW6312YEFuw+a9jOdTmf62d0Ai6o6jWJntdyvleLaObiv9t7OfbmacMhrtd0urtlAanaC221fd7sgZz+323Z3+qR9zIsMYz3eT7AOxGUgJuEtZKvtaOdxG2NuyNdX29/dfK2qOJfU/9qM0I0on93o9oHpfs+qc76Wczll6gQqDayvXmH/EY/RQF7kWFujkqbUXq83HZ/tuJ9aUSCxxorFGuj0CrzmdKJSYVExCVq3y1jZuZ/XErS52li5mq+v54/X+1zutr9R4eJLT5HP7UHEU3Q74JuuIQURi7UWMYK1dtu2rra/u+33TtbV3a773Y7xRuxq88WsjPHO/bvavl9v+9c7lzu35wATI9EIfsrRIojS6L1A1ukAbLvO23lk9rrZbX9bvzr3lrhFAm+RYGB5eZnf//3fnw64EAJXrlzh4sWLGGNYXV1lbm5uelGdP3+e3/qt3/r/t3dvsVFUfxzAvzM7221LCy290VKogYaA3AxoMCjKpYoEDEqUS1BC8cFLgqighMsDxhe8RtFEwz9KgkSNgAINKioBgQgSyyWKUiKFAi0tLfS+bXd25/wftmc6u9222+2WAvP9vPS2Ozs9e/bMb87ld5CamorHHnsMXq83YPyps0bNSj5GXuiD12sH91QoihKwb3qkwUB3nt9bugo8uorOw/n/zGMogKe5yZxAZLRmGBDCCMg00FXgFEkwYD2OfJzcK0N2UYbqXYrk+MHPk3Wlu++l+f8CENDQcr3Kn2PA0wK9pRk+nw5DUfw7QqrN0HXdnE8TcBxns3+LYk8zvE1NEF4PvDAAQ4cOnxkMBA8VRCsY6Kis5TG6+v87Eu572a48g762nD8NKBqE0NGieKEY/q2IDKHAUJzQNP+WWV11ZXd2vpH0AHT3OT1pR8J5re68l/J4un9syv9z6xCBXIIICCiKCkNV0NLS0q3/y/oeyoCgu+V7u7JFMOD1elFWVmZWNEVRkJaWhqVLlyI+Ph61tbW4dOmS+eZ7PB5cv34dmqaZd0Sd7ZneVWXRdR0+n78bVb6GlbVShpqs1Vlk3dHfrRG3/Dn4taNZyUPNOI+krOS5Wh/f+XP8jzUMAVVB687vjtaZx76QF5Hg1+ju+XXFevcU/D5E8hrBvSXydz19L/0jLALCq/sXyPl8ED4DhiEgFJk/QHT8OroOb5MbMf36+ZO7GP6FoIaAf0GoUNpWggT9L5Gec7BQZR2tY3d0/HCP7UQToCgwVLmCoLVMIczjCNF2g3Arzx2Q/7N1OKMndbqj1wj1XoY6viGTCvj8GTDV1jpnwD/EpaBtt9lQvRhdnbdsL+0SCAA2CQas0Z38EFZWVuLjjz+Gqqpobm427/yBtki0swko3Wl0HA6HWck7+sB3dMGItDKGugj2ZsWOZkPWvcABkOvgvOaS4tZz6eTpvVUW8rihgseeHtP6fVSOC0B1AIrRAkXoUFQXoMTAgRYIAf+Wuq0vE/JipTfDcb0YTk9/CGjwqhpgCEt6qPZ1ItqBAICQF49oCL5Id/f4/oBUQBg+yJvXtqFtf2UNvgm41YU6z2i/l8HHDHl8y68Msz9Aljn8c1866FEK93zC6TG8k9giGABCRJaGAbfb3eljreNMPWHtWaDokneuZvGK7pdztO8mbyeGEBC+ZjgMD/xpnJ3Q4G9PfXAE3F21a1x9HpQe/xWqozVoEA5A6GaaGFjXdvey3g7uImHeRoi2L239JD4IETh0ZMf61yMhy7Xtb9Zh2WjdVN3JbBMM9CWn0wmPx2OrinWzKIoCTdNYvhESBqAaOlyiBYbuBoR1BYZ/vkuH3ePCgKexuvV7mUuz7S7NHvdTkVNVbg3TWxSlbWIm24XwMBi4CeREL0b/0SeEMJM6USQEXKqBOMMNT8N1AHpAzrfg4bPAcjYAXzOA1jXzQliTxtosw0D3sbew9wghAuZpsX3oGkPTTkSrEtlpecrNJnsG5IQf6h5FVeG+cQ3VF/9F/dUL/kmXaBvtV1t7BjrigAFNkcmHgi9ufD86o7ameqbos/YMUHh4lepCNGaVdn53RT0h7wDsNNEn2uqrruKvAz9A+DwAvK3BgD/7kOFrvyJDkqUt/yyENeegnO7Nut4RZiTtPcGrYKhrDAZCkBfsaK0xVVW1XW4Big5FUcy7K5Zt9yiKAsXwQaAFwueFAh8gvK3Ls/z1VdbdjlajyM17RUDaQvk4vh+dsfZmse5GV0/L1rqE1y4BG4OBTsgLjTXTW0+OxQ9+7wjuEmT5hk+Bv6tfZmiA6u/sN5TWhXBKZ8Gs0pqpUDFXDyjCOsggX4FCkW2CHC7gnWz0yLLtySRCWe8ZDNic/ICOHTsWa9eu7dZzg/MVpKamorKyEorSltKYokNRFKSkpKCqqqpduVPX/Inc/EMsqgIYwoDwpyACoCAlZSBqqqsDJmNZn220HcUcGGCPQHj69esHAGhoaDB/x7obHaqqIjk5GdevX4+4XRBCICcnxzbzOhQRZshkp0oqI0KHw4HY2NiIhgtkNi1FUbB69Wp89NFHaG5u7vXkP3YTGxuLV155Be+++y7HCaNMVVWsWLECW7ZsQW1tLQD2ukRTXl4edF3HoUOHbvkMhLeblJQULF68GJ988gmA7q/csPYK19XV3fZpicM5d/YMdELXdRhG17nDO+NwOFBTU4PGxkYzT7a8y6Ke03UddXV1aGhoMDckuZ0/tLcSRVFQU1ODhoYGuN1us2eLoqO2thY+nw8NDQ3QNI3b7UaR0+k02wWZUr477ULw0Jgd2hT2DHRAVgY547cnUXtmZiaqqqrMY/FDHz2qqiIrKwsVFRXmvhO8w4qezMxMVFdXw+PxAODa+GgaMGBAwJ0nyzZ6nE4n0tLSUFlZ2W7jo3A5HI52aZJvV2Gldmcw0LlwJvZYy0aOv1p/19lGGdS14MlrsgxlxC+/UveFmtgqh7jk32/3LtK+Yl3lIsvUWo63274EtxLZjR+cSjx418FI24XgHShvdwwGbhKHw4GYmBi0tLSYmxtZG1P2BEROzt0I3rMdaL+5CXWfdbWMtVdFljGDrMjJsrXucWJdpnknXGT6ktxVVvaqWCdos80NFE5ds8c0yV4m5xU4nU4MGTIE6enpZk53NqY9I++oHA4H4uPjMWLECGRlZQUEWxQ5mbRJURQMHz4cubm5AfsRUOSss9AzMzORl5dnZiO1ywz13iS3m09MTEReXh6ys7MBMICNFCcQRoGiKIiLi8OiRYuQkpKCjIwMfPrppygqKmKUGgW6riM9PR35+fnQdR05OTl4++23UV5ezg9+D8meFk3TsGjRImRmZmLVqlXmhEyKnOxlmTVrFqZPn45du3ZB0zTuYhpFMTExeOqpp+Dz+VBcXMyJmD3AT3uY5BiVNVGIoiiIjY2FqqpwuVwoKSnBe++9h+PHj2PIkCEBExCpYzKng7z4yO+t5avrOvbs2YOdO3dCVVWMGjUKMTExvGB1wZrURpJ7ObhcLsTExJiPu3HjBs6cOYMnn3wSGRkZvGB1wVq2snxl2cqvADBw4EAYhoHp06dj/fr1GDlyZMBsdQotuGwdDof5s8vlMstw2LBhSEpKQn5+Pp5//nkkJCT08ZnfntiShsFaKWUXqqqqmDRpEjZu3IjBgwejrq4Ov/76K4QQGDhwICoqKsyLFbtbOycbT2v5Op1OzJkzB2+99RYSExNRW1uLs2fPYuTIkfjhhx8wc+ZMjBs3rq9P/ZYny1RVVXOMFQDGjBmD999/H3fffbcZdLlcLpSXl+O1117D2LFjebHqgjUYkGUshEBaWhrWr1+PefPmQQiBvXv34ty5c9iyZQu+++475Ofnw+l0sl3ogpwvJMsWAFwuFxYtWoQ1a9bA5XJBCIGYmBj0798fGzduxMCBAzFs2DDW3QgwGOgGeacko9Lk5GQUFhZi6dKlZsKbhIQEZGVlITMzE88995yt0llGIng2uwwMZCBVVlaGxx9/3Gxo9+/fj6NHj6K6uhotLS3sGQiDtXydTicURUFaWhoOHTqEBQsWID4+HoZhIDs7G+np6di0aRNSUlJYb8Mg669hGHA6nVBVFampqTh9+jQeeughDBkyBHV1dfjiiy9QXl4OAOZSQuqYLFdZtg6HA5qmIT4+Hm63G0IIPPjgg/B6vdi2bRsyMjIwevRo+Hw+cxksdQ/nDIRBXqQSExOxcOFCZGdn4/Dhwzh06BCEEFi7di3Gjx+PEydOIDExESNGjMDly5exY8cOJsHpgixbwzCQlZWFZ555Bk6nEwUFBSgoKEBycjLefPNNHDp0CJcvX0ZOTg4WL16MkydPoqioiGUbBiEEYmNjsXDhQgwdOhSFhYX46aefIITAsGHDMGnSJBw8eBAbNmyA2+2GqqqIi4tj2XbBupxtxowZmDJlCsrKyvDNN9/g7Nmz0HUdTz/9NDZt2gRN0zB79myMHj0aX331FXRd7+Ozv7VZl/UNHz4cCxYsgGEY2LFjB3bv3o3jx49j9erVOHXqFP7++298+eWXuP/++/Hnn3+iuLi4r0//tsSlhSEEL2ED/N2tkydPxr333os9e/bgpZdewrfffouTJ08iNzcXL7/8Mv744w/88ssv8Hq9uHbtWsBSImoj7/6tSzA1TcOzzz6LyspKlJeXY/78+di0aROuXLmCvLw85OXl4fTp09i7dy+8Xi8aGxt5dxWC7FqVKwQAfwKWUaNGYfbs2fj666+xbNkyHDhwAAcPHsTgwYOxdu1aFBYW4scff0Rpaam5goPlG8h6tyo/0w6HAwMGDMC6devw4YcfYtasWXA4HNi8eTM0TcOGDRtw6dIl86LV1NQEj8fDdiEEa921tgsrVqzAsWPHoGkaHn30UXzwwQe4ceMG5s+fj9zcXJw7dw7ff/99QI8AyzYQlxZGSCa0cblcmDx5MpYsWYIxY8aYAUJpaSl27dqFGTNmAAAyMjKgqipKSkpw9epVVFRUmA0pK2V7cm1wQkICZs2ahcWLFyM9Pd1cI1xYWIjCwkLMmDEDiqIgIyMDcXFx+Ouvv1BTU4P6+npeqDogL1aapmHixInIz883x/81TcPVq1exfft2TJ06FXFxcUhPT4fL5UJpaSkqKiqYu6ELcs5FTk4OlixZYi4XNAwDzc3N2L59O7Kzs3HXXXehf//+iI+PhxAC//zzD2pra80LFtuF9jRNgxACAwYMwNy5c7FgwQIkJyebNw1HjhzBpUuXMHnyZDgcDqSmpiIhIQEnTpxAS0sL8zf0EIOBEOSEoMmTJ+O+++5DWVkZlixZgqKiIgwePBijRo3C+fPnkZKSAqfTiaKiIrzxxhs4ePBgX5/6bUFesObOnYukpCR4vV4sWbIEBw4cwNSpU5GRkYGioiIzyPrtt9+watUqnDlzpq9P/ZYn51bcc889mDJlCs6fP49ly5ahoqICLpcLEyZMQElJCRITE+F0OnH58mWsXLkS+/bt4zLNMKWlpWHRokUoKSnBtGnTMHToUJw8eRJPPPEE3G436urq0L9/fzQ1NeGdd97BZ599hrq6ur4+7Vue7BlYsGABVFVFQkIC5s2bh3379mHOnDlISkrCf//9h/T0dABAQUEB1q1bh+LiYlv1XPcWzhkIQW548++//+LkyZMAgIcffhhutxubN2/GCy+8gMbGRhw7dgwej8e8o7J2c1Fo1u7Rw4cP49q1axgyZAiys7Nx5coVFBQUYOXKldB1Hbt27YLP58OVK1fM58j3hjp38eJFFBcXw+12Y8aMGfB4PPjf//6H5cuXY+bMmThx4gSamprM3QgBew0FRkIOndTX12Pbtm0oLS1Fbm4uFEXB7t27sXz5cqxZswa6ruPChQuor69HY2MjAHDopQvW7Jc///wzysrKMG7cOEycOBFFRUU4evQoVq1aBQDYunUrdF3HpUuX2C5EEecMdMA6A3v48OGYO3cutm7dCiEEvF4v+vXrh6tXr5qPkc9hF1XXrDnbAeCRRx5BQkICfv/9dzQ3N5trtKuqqu6o/OA3g6y3snEdNGgQli1bhs2bN8PhcKCpqQmJiYkBGzuxbMMnlxP6fD7Exsbi9ddfx+effw5VVVFdXY2kpCRUV1fD7Xabj2f5hsfaLiiKgvnz56O8vBznzp1DQ0MDYmNj4fV6cePGDQAs2+7gnIEesI49jR07FqmpqVi5ciUGDRqEhoYGlJWVtRufYsUMj8wlLstvwoQJGDt2LF588UX069cPVVVVqKysbLcJCXVNlqm8yxo9ejTS0tLw6quvYvjw4aivr0dpaWnEO7nZnUzfDADJycnIycnBsmXLMG3aNHg8HpSWlpqBgHw8hSe4XRg/fjweeOAB5OfnIyYmBteuXTMDAYBlG20cJgiDz+fDxYsXsXv3blRVVfX16dxRFEVBY2MjioqKsH///oCGlHpOCIELFy5g586dARMEqedkHoxdu3bh3Llz7KaOIlVVUVNTg1OnTuHIkSNoaWnp61O643GYIAzWzHgyeuXYX/RYU7PK1MMUHdZdHzVNY0KWKJMrCeRcIbYL0eNwOAK20+aeA5HjFsZRxPGpm4PlTEQUXZwzEEW8QN0cLGciopuPwQAREZHNMRggIiKyOQYDRERENsdggIiIyOYYDBAREdkcgwEiIiKbYzBARERkcwwGiIiIbI7BABERkc0xGCAiIrI5BgNEREQ2x2CAiIjI5hgMEBER2RyDASIiIptjMEBERGRzDAaIiIhsjsEAERGRzTEYICIisjkGA0RERDbHYICIiMjmGAwQERHZHIMBIiIim2MwQEREZHMMBoiIiGyOwQAREZHNMRggIiKyOQYDRERENsdggIiIyOYYDBAREdkcgwEiIiKbYzBARERkcwwGiIiIbI7BABERkc0xGCAiIrI5BgNEREQ2x2CAiIjI5hgMEBER2RyDASIiIpvTwn2gEKI3z4OIiIj6CHsGiIiIbI7BABERkc0xGCAiIrI5BgNEREQ2x2CAiIjI5hgMEBER2RyDASIiIptjMEBERGRzDAaIiIhs7v/E6g1mAPwDAwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -659,17 +642,6 @@ "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, \"cache_seed\": 42}\n", - "\n", - "\n", "creator = FigureCreator(\n", " name=\"Figure Creator~\",\n", " llm_config=gpt4_llm_config\n", @@ -683,7 +655,7 @@ ")\n", "\n", "user_proxy.initiate_chat(creator, message=\"\"\"\n", - "Plot a figure by using the data from:\n", + "Plot a figure by using the data from here:\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", @@ -692,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "f0a58827", "metadata": {}, "outputs": [], @@ -719,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "56bd5742", "metadata": { "scrolled": false @@ -739,14 +711,14 @@ ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33mimage-explainer-1\u001b[0m (to chat_manager):\n", "\n", - "In a soft-focus world, a caramel-colored puppy with a coat of curly fur sits serenely, its innocent eyes gazing into the distance. Adorned with a collar that hosts a vibrant, multicolored bandana and a shiny tag engraved with the name \"Webster,\" the pup exudes a sense of youthful curiosity and gentle charm. Behind this bundle of joy, the muted backdrop of a home's interior whispers tales of comfort and domesticity, with a pair of black boots resting by the door, hinting at the comings and goings of human life amidst which this little creature finds its love and belonging.\n", + "In the soft embrace of a quiet room, a curly-haired sentinel of joy rests upon the floor—a puppy, with fur the color of sunlit autumn leaves. Its innocent eyes, deep and dark as a twilight sky, gaze into the world with wonder and gentle curiosity. Adorned with a collar that boasts a bright, mosaic-like pattern, the young canine wears a name tag shaped like a heart, whispering the promise of unconditional love and companionship. In the background, a pair of black boots stands sentinel, hinting at the return of a beloved owner, while the puppy waits, the embodiment of warmth and affection in an often too brisk world.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33mimage-explainer-2\u001b[0m (to chat_manager):\n", + "\u001b[33mUser_proxy\u001b[0m (to chat_manager):\n", + "\n", "\n", - "The image shows a young, caramel-colored puppy with curly fur sitting on the floor. The puppy is wearing a blue collar with a colorful bandana and a tag that appears to have the name \"Webster\" engraved on it. In the background, there are black boots near a white door, suggesting an indoor, home setting. The focus is on the puppy, making the background appear softly blurred. The puppy's expression is gentle, with a hint of curiosity in its eyes.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -798,6 +770,131 @@ " message=f\"\"\"Describe the image:\n", " .\"\"\")" ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0fe6917a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "defaultdict(list,\n", + " {: [{'content': [{'type': 'text',\n", + " 'text': 'Describe the image:\\n '},\n", + " {'type': 'image_url',\n", + " 'image_url': {'url': }},\n", + " {'type': 'text', 'text': '.'}],\n", + " 'name': 'User_proxy',\n", + " 'role': 'user'},\n", + " {'content': [{'type': 'text',\n", + " 'text': 'In the soft embrace of a quiet room, a curly-haired sentinel of joy rests upon the floor—a puppy, with fur the color of sunlit autumn leaves. Its innocent eyes, deep and dark as a twilight sky, gaze into the world with wonder and gentle curiosity. Adorned with a collar that boasts a bright, mosaic-like pattern, the young canine wears a name tag shaped like a heart, whispering the promise of unconditional love and companionship. In the background, a pair of black boots stands sentinel, hinting at the return of a beloved owner, while the puppy waits, the embodiment of warmth and affection in an often too brisk world.'}],\n", + " 'role': 'assistant'},\n", + " {'content': [{'type': 'text', 'text': ''}],\n", + " 'name': 'User_proxy',\n", + " 'role': 'user'},\n", + " {'content': [{'type': 'text', 'text': ''}],\n", + " 'name': 'User_proxy',\n", + " 'role': 'user'},\n", + " {'content': [{'type': 'text', 'text': ''}],\n", + " 'name': 'User_proxy',\n", + " 'role': 'user'}]})" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agent1._oai_messages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04115031", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b71c029f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x05\\x08\\x06\\x00\\x00\\x00\\x8do&\\xe5\\x00\\x00\\x00\\x1cIDAT\\x08\\xd7c\\xf8\\xff\\xff?\\xc3\\x7f\\x06 \\x05\\xc3 \\x12\\x84\\xd01\\xf1\\x82X\\xcd\\x04\\x00\\x0e\\xf55\\xcb\\xd1\\x8e\\x0e\\x1f\\x00\\x00\\x00\\x00IEND\\xaeB`\\x82'\n", + "b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x05\\x08\\x06\\x00\\x00\\x00\\x8do&\\xe5\\x00\\x00\\x00&IDATx\\x9c}\\xc81\\x12\\x00\\x10\\x00\\xc0\\xb0\\xd6\\xff\\xff\\\\\\x0b\\xe7\\x18d\\x8c\\x15hl\\xa5\\xc1\\x89e\\xbc\\xf1\\xc9\\xf2\\x9ar\\x02\\x10k\\x0c\\x02\\xf3\\x0f\\xba=\\x00\\x00\\x00\\x00IEND\\xaeB`\\x82'\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[18], line 27\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28mprint\u001b[39m(image_data)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28mprint\u001b[39m(recovered_content)\n\u001b[0;32m---> 27\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m image_data \u001b[38;5;241m==\u001b[39m recovered_content\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "import base64\n", + "import copy\n", + "import mimetypes\n", + "import re\n", + "from io import BytesIO\n", + "from typing import Any, Dict, List, Optional, Tuple, Union\n", + "\n", + "import requests\n", + "from PIL import Image\n", + "\n", + "\n", + "raw_encoded_image = (\n", + " \"iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4\"\n", + " \"//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\"\n", + ")\n", + "image_data = base64.b64decode(raw_encoded_image)\n", + "image = Image.open(BytesIO(image_data))\n", + "\n", + "\n", + "buffered = BytesIO()\n", + "image.save(buffered, format=\"PNG\")\n", + "recovered_content = buffered.getvalue()\n", + "\n", + "print(image_data)\n", + "print(recovered_content)\n", + "\n", + "assert image_data == recovered_content" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ff4701db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x05\\x08\\x06\\x00\\x00\\x00\\x8do&\\xe5\\x00\\x00\\x00\\x1cIDAT\\x08\\xd7c\\xf8\\xff\\xff?\\xc3\\x7f\\x06 \\x05\\xc3 \\x12\\x84\\xd01\\xf1\\x82X\\xcd\\x04\\x00\\x0e\\xf55\\xcb\\xd1\\x8e\\x0e\\x1f\\x00\\x00\\x00\\x00IEND\\xaeB`\\x82'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image_data" + ] } ], "metadata": { diff --git a/notebook/plot_temperatures.py b/notebook/plot_temperatures.py new file mode 100644 index 000000000000..893d92e43e09 --- /dev/null +++ b/notebook/plot_temperatures.py @@ -0,0 +1,30 @@ +# filename: plot_temperatures.py +import pandas as pd +import matplotlib.pyplot as plt + +# URL of the CSV file +url = "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv" + +# Read the data from the URL +data = pd.read_csv(url) + +# Extract the Date, Temperature High, and Temperature Low columns +dates = pd.to_datetime(data["date"]) +temp_high = data["temp_max"] +temp_low = data["temp_min"] + +# Plot the high and low temperatures +plt.figure(figsize=(10, 5)) +plt.plot(dates, temp_high, label="High Temperature", color="r") +plt.plot(dates, temp_low, label="Low Temperature", color="b") +plt.xlabel("Date") +plt.ylabel("Temperature (°C)") +plt.title("High and Low Temperatures in Seattle") +plt.legend() +plt.grid(True) + +# Save the figure +plt.savefig("result.jpg") + +# Show the plot +plt.show() diff --git a/notebook/plot_temperatures_improved.py b/notebook/plot_temperatures_improved.py new file mode 100644 index 000000000000..8e28fce91133 --- /dev/null +++ b/notebook/plot_temperatures_improved.py @@ -0,0 +1,41 @@ +# filename: plot_temperatures_improved.py +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns # For colorblind-friendly palette + +# Ensure you have seaborn installed: pip install seaborn + +# URL of the CSV file +url = "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv" + +# Read the data from the URL +data = pd.read_csv(url) + +# Extract the Date, Temperature High, and Temperature Low columns +dates = pd.to_datetime(data["date"]) +temp_high = data["temp_max"].rolling(window=7).mean() # 7-day rolling average +temp_low = data["temp_min"].rolling(window=7).mean() # 7-day rolling average + +# Plot the high and low temperatures using seaborn's colorblind-friendly palette +plt.figure(figsize=(10, 5), dpi=150) +plt.plot(dates, temp_high, label="High Temperature", color=sns.color_palette("colorblind")[2], linewidth=1) +plt.plot(dates, temp_low, label="Low Temperature", color=sns.color_palette("colorblind")[0], linewidth=1) +plt.xlabel("Date", fontsize=12) +plt.ylabel("Temperature (°C)", fontsize=12) +plt.title("High and Low Temperatures in Seattle (7-day Rolling Average)", fontsize=14) + +# Adjusting the legend +leg = plt.legend(loc="upper left", frameon=True) +leg.get_frame().set_alpha(0.5) + +# Adjusting the grid +plt.grid(True, linestyle="--", linewidth=0.5, color="grey", alpha=0.7) + +# Increase tick label size +plt.tick_params(labelsize=10) + +# Save the figure with high resolution +plt.savefig("result.jpg", format="jpg", dpi=150) + +# Show the plot +plt.show() diff --git a/test/agentchat/contrib/test_img_utils.py b/test/agentchat/contrib/test_img_utils.py index 9c38153f6b71..3568721d30d5 100644 --- a/test/agentchat/contrib/test_img_utils.py +++ b/test/agentchat/contrib/test_img_utils.py @@ -4,13 +4,20 @@ import unittest from unittest.mock import patch +import numpy as np import pytest import requests try: from PIL import Image - from autogen.agentchat.contrib.img_utils import extract_img_paths, get_image_data, gpt4v_formatter, llava_formatter + from autogen.agentchat.contrib.img_utils import ( + extract_img_paths, + get_image_data, + get_pil_image, + gpt4v_formatter, + llava_formatter, + ) except ImportError: skip = True else: @@ -18,7 +25,8 @@ base64_encoded_image = ( - "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" + "data:image/png;base64," + "iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4" "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" ) @@ -27,6 +35,27 @@ "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" ) +raw_pil_image = Image.new("RGB", (10, 10), color="red") + + +@pytest.mark.skipif(skip, reason="dependency is not installed") +class TestGetPilImage(unittest.TestCase): + def test_image(self) -> bytes: + # Create a small red image for testing + temp_file = "_temp.png" + raw_pil_image.save(temp_file) + img2 = get_pil_image(temp_file) + self.assert_((np.array(raw_pil_image) == np.array(img2)).all()) + + +def are_b64_images_equal(x: str, y: str): + """ + Asserts that two base64 encoded images are equal. + """ + img1 = get_pil_image(x) + img2 = get_pil_image(y) + return (np.array(img1) == np.array(img2)).all() + @pytest.mark.skipif(skip, reason="dependency is not installed") class TestGetImageData(unittest.TestCase): @@ -34,20 +63,20 @@ 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_response._content = base64.b64decode(raw_encoded_image) 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")) + self.assertTrue(are_b64_images_equal(result, raw_encoded_image)) def test_base64_encoded_image(self): result = get_image_data(base64_encoded_image) - self.assertEqual(result, base64_encoded_image.split(",", 1)[1]) + + self.assertTrue(are_b64_images_equal(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) @@ -126,6 +155,36 @@ def test_with_images(self, mock_get_image_data): result = gpt4v_formatter(prompt) self.assertEqual(result, expected_output) + @patch("autogen.agentchat.contrib.img_utils.get_pil_image") + def test_with_images_for_pil(self, mock_get_pil_image): + """ + Test the gpt4v_formatter function with a prompt containing images. + """ + # Mock the get_image_data function to return a fixed string. + mock_get_pil_image.return_value = raw_pil_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": raw_pil_image}}, + {"type": "text", "text": "."}, + ] + result = gpt4v_formatter(prompt, img_format="pil") + self.assertEqual(result, expected_output) + + def test_with_images_for_url(self): + """ + Test the gpt4v_formatter function with a prompt containing images. + """ + 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": "http://example.com/image.png"}}, + {"type": "text", "text": "."}, + ] + result = gpt4v_formatter(prompt, img_format="url") + self.assertEqual(result, expected_output) + @patch("autogen.agentchat.contrib.img_utils.get_image_data") def test_multiple_images(self, mock_get_image_data): """ From 791c4e086724e9d0898700cec297c60f28cbfeca Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 2 Jan 2024 16:43:01 -0800 Subject: [PATCH 3/9] Update test cases and llava --- autogen/agentchat/contrib/img_utils.py | 12 ++++++++---- autogen/agentchat/contrib/llava_agent.py | 4 +++- test/agentchat/contrib/test_img_utils.py | 7 ++++++- test/agentchat/contrib/test_lmm.py | 5 ++++- 4 files changed, 21 insertions(+), 7 deletions(-) diff --git a/autogen/agentchat/contrib/img_utils.py b/autogen/agentchat/contrib/img_utils.py index 9a5f1f61a817..854469819f1c 100644 --- a/autogen/agentchat/contrib/img_utils.py +++ b/autogen/agentchat/contrib/img_utils.py @@ -10,16 +10,20 @@ from PIL import Image -def get_pil_image(image_file: str) -> Image.Image: +def get_pil_image(image_file: Union[str, Image.Image]) -> Image.Image: """ Loads an image from a file and returns a PIL Image object. Parameters: - image_file (str): The filename, URL, URI, or base64 string of the image file. + image_file (str, or Image): The filename, URL, URI, or base64 string of the image file. Returns: Image.Image: The PIL Image object. """ + if isinstance(image_file, Image.Image): + # Already a PIL Image object + return image_file + if image_file.startswith("http://") or image_file.startswith("https://"): # A URL file response = requests.get(image_file) @@ -39,7 +43,7 @@ def get_pil_image(image_file: str) -> Image.Image: return image.convert("RGB") -def get_image_data(image_file: str, use_b64=True) -> bytes: +def get_image_data(image_file: Union[str, Image.Image], use_b64=True) -> bytes: """ Loads an image and returns its data either as raw bytes or in base64-encoded format. @@ -49,7 +53,7 @@ def get_image_data(image_file: str, use_b64=True) -> bytes: either returned directly or as a base64-encoded string. Parameters: - image_file (str): The path to the image file, a URL to an image, or a base64-encoded + image_file (str, or Image): The path to the image file, a URL to an image, or a base64-encoded string of the image. use_b64 (bool): If True, the function returns a base64-encoded string of the image data. If False, it returns the raw byte data of the image. Defaults to True. diff --git a/autogen/agentchat/contrib/llava_agent.py b/autogen/agentchat/contrib/llava_agent.py index 65c39fd1e200..376c6c88f249 100644 --- a/autogen/agentchat/contrib/llava_agent.py +++ b/autogen/agentchat/contrib/llava_agent.py @@ -77,7 +77,9 @@ def _image_reply(self, messages=None, sender=None, config=None): 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] + + # TODO: PIL to base64 + images = [get_image_data(im) for im in images] print(colored(prompt, "blue")) out = "" diff --git a/test/agentchat/contrib/test_img_utils.py b/test/agentchat/contrib/test_img_utils.py index 3568721d30d5..70b31dc8adcb 100644 --- a/test/agentchat/contrib/test_img_utils.py +++ b/test/agentchat/contrib/test_img_utils.py @@ -40,13 +40,18 @@ @pytest.mark.skipif(skip, reason="dependency is not installed") class TestGetPilImage(unittest.TestCase): - def test_image(self) -> bytes: + def test_read_local_file(self): # Create a small red image for testing temp_file = "_temp.png" raw_pil_image.save(temp_file) img2 = get_pil_image(temp_file) self.assert_((np.array(raw_pil_image) == np.array(img2)).all()) + def test_read_pil(self): + # Create a small red image for testing + img2 = get_pil_image(raw_pil_image) + self.assert_((np.array(raw_pil_image) == np.array(img2)).all()) + def are_b64_images_equal(x: str, y: str): """ diff --git a/test/agentchat/contrib/test_lmm.py b/test/agentchat/contrib/test_lmm.py index 415133971600..a6d99b5d7890 100644 --- a/test/agentchat/contrib/test_lmm.py +++ b/test/agentchat/contrib/test_lmm.py @@ -5,6 +5,7 @@ import autogen from autogen.agentchat.agent import Agent +from autogen.agentchat.contrib.img_utils import get_pil_image try: from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent @@ -19,6 +20,8 @@ "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" ) +pil_image = get_pil_image(base64_encoded_image) + @pytest.mark.skipif(skip, reason="dependency is not installed") class TestMultimodalConversableAgent(unittest.TestCase): @@ -51,7 +54,7 @@ def test_system_message(self): self.agent.system_message, [ {"type": "text", "text": "We will discuss "}, - {"type": "image_url", "image_url": {"url": base64_encoded_image}}, + {"type": "image_url", "image_url": {"url": pil_image}}, {"type": "text", "text": " in this conversation."}, ], ) From eddcb33e2c58e45bc4a299950b53387f9f85a6c3 Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 2 Jan 2024 16:50:47 -0800 Subject: [PATCH 4/9] Remove redundant files --- notebook/agentchat_lmm_gpt-4v.ipynb | 95 +++----------------------- notebook/plot_temperatures.py | 30 -------- notebook/plot_temperatures_improved.py | 41 ----------- 3 files changed, 9 insertions(+), 157 deletions(-) delete mode 100644 notebook/plot_temperatures.py delete mode 100644 notebook/plot_temperatures_improved.py diff --git a/notebook/agentchat_lmm_gpt-4v.ipynb b/notebook/agentchat_lmm_gpt-4v.ipynb index 54f9d9a61a5e..982af764c63c 100644 --- a/notebook/agentchat_lmm_gpt-4v.ipynb +++ b/notebook/agentchat_lmm_gpt-4v.ipynb @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "0b7fc18e", + "id": "6868785c", "metadata": {}, "outputs": [ { @@ -335,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "977b9017", "metadata": { "scrolled": false @@ -664,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "f0a58827", "metadata": {}, "outputs": [], @@ -691,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "56bd5742", "metadata": { "scrolled": false @@ -773,15 +773,15 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "0fe6917a", + "execution_count": 10, + "id": "00bd473d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "defaultdict(list,\n", - " {: [{'content': [{'type': 'text',\n", + " {: [{'content': [{'type': 'text',\n", " 'text': 'Describe the image:\\n '},\n", " {'type': 'image_url',\n", " 'image_url': {'url': }},\n", @@ -802,7 +802,7 @@ " 'role': 'user'}]})" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -814,87 +814,10 @@ { "cell_type": "code", "execution_count": null, - "id": "04115031", + "id": "39d293fb", "metadata": {}, "outputs": [], "source": [] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "b71c029f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x05\\x08\\x06\\x00\\x00\\x00\\x8do&\\xe5\\x00\\x00\\x00\\x1cIDAT\\x08\\xd7c\\xf8\\xff\\xff?\\xc3\\x7f\\x06 \\x05\\xc3 \\x12\\x84\\xd01\\xf1\\x82X\\xcd\\x04\\x00\\x0e\\xf55\\xcb\\xd1\\x8e\\x0e\\x1f\\x00\\x00\\x00\\x00IEND\\xaeB`\\x82'\n", - "b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x05\\x08\\x06\\x00\\x00\\x00\\x8do&\\xe5\\x00\\x00\\x00&IDATx\\x9c}\\xc81\\x12\\x00\\x10\\x00\\xc0\\xb0\\xd6\\xff\\xff\\\\\\x0b\\xe7\\x18d\\x8c\\x15hl\\xa5\\xc1\\x89e\\xbc\\xf1\\xc9\\xf2\\x9ar\\x02\\x10k\\x0c\\x02\\xf3\\x0f\\xba=\\x00\\x00\\x00\\x00IEND\\xaeB`\\x82'\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[18], line 27\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28mprint\u001b[39m(image_data)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28mprint\u001b[39m(recovered_content)\n\u001b[0;32m---> 27\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m image_data \u001b[38;5;241m==\u001b[39m recovered_content\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], - "source": [ - "import base64\n", - "import copy\n", - "import mimetypes\n", - "import re\n", - "from io import BytesIO\n", - "from typing import Any, Dict, List, Optional, Tuple, Union\n", - "\n", - "import requests\n", - "from PIL import Image\n", - "\n", - "\n", - "raw_encoded_image = (\n", - " \"iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4\"\n", - " \"//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\"\n", - ")\n", - "image_data = base64.b64decode(raw_encoded_image)\n", - "image = Image.open(BytesIO(image_data))\n", - "\n", - "\n", - "buffered = BytesIO()\n", - "image.save(buffered, format=\"PNG\")\n", - "recovered_content = buffered.getvalue()\n", - "\n", - "print(image_data)\n", - "print(recovered_content)\n", - "\n", - "assert image_data == recovered_content" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "ff4701db", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x05\\x08\\x06\\x00\\x00\\x00\\x8do&\\xe5\\x00\\x00\\x00\\x1cIDAT\\x08\\xd7c\\xf8\\xff\\xff?\\xc3\\x7f\\x06 \\x05\\xc3 \\x12\\x84\\xd01\\xf1\\x82X\\xcd\\x04\\x00\\x0e\\xf55\\xcb\\xd1\\x8e\\x0e\\x1f\\x00\\x00\\x00\\x00IEND\\xaeB`\\x82'" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "image_data" - ] } ], "metadata": { diff --git a/notebook/plot_temperatures.py b/notebook/plot_temperatures.py deleted file mode 100644 index 893d92e43e09..000000000000 --- a/notebook/plot_temperatures.py +++ /dev/null @@ -1,30 +0,0 @@ -# filename: plot_temperatures.py -import pandas as pd -import matplotlib.pyplot as plt - -# URL of the CSV file -url = "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv" - -# Read the data from the URL -data = pd.read_csv(url) - -# Extract the Date, Temperature High, and Temperature Low columns -dates = pd.to_datetime(data["date"]) -temp_high = data["temp_max"] -temp_low = data["temp_min"] - -# Plot the high and low temperatures -plt.figure(figsize=(10, 5)) -plt.plot(dates, temp_high, label="High Temperature", color="r") -plt.plot(dates, temp_low, label="Low Temperature", color="b") -plt.xlabel("Date") -plt.ylabel("Temperature (°C)") -plt.title("High and Low Temperatures in Seattle") -plt.legend() -plt.grid(True) - -# Save the figure -plt.savefig("result.jpg") - -# Show the plot -plt.show() diff --git a/notebook/plot_temperatures_improved.py b/notebook/plot_temperatures_improved.py deleted file mode 100644 index 8e28fce91133..000000000000 --- a/notebook/plot_temperatures_improved.py +++ /dev/null @@ -1,41 +0,0 @@ -# filename: plot_temperatures_improved.py -import pandas as pd -import matplotlib.pyplot as plt -import seaborn as sns # For colorblind-friendly palette - -# Ensure you have seaborn installed: pip install seaborn - -# URL of the CSV file -url = "https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv" - -# Read the data from the URL -data = pd.read_csv(url) - -# Extract the Date, Temperature High, and Temperature Low columns -dates = pd.to_datetime(data["date"]) -temp_high = data["temp_max"].rolling(window=7).mean() # 7-day rolling average -temp_low = data["temp_min"].rolling(window=7).mean() # 7-day rolling average - -# Plot the high and low temperatures using seaborn's colorblind-friendly palette -plt.figure(figsize=(10, 5), dpi=150) -plt.plot(dates, temp_high, label="High Temperature", color=sns.color_palette("colorblind")[2], linewidth=1) -plt.plot(dates, temp_low, label="Low Temperature", color=sns.color_palette("colorblind")[0], linewidth=1) -plt.xlabel("Date", fontsize=12) -plt.ylabel("Temperature (°C)", fontsize=12) -plt.title("High and Low Temperatures in Seattle (7-day Rolling Average)", fontsize=14) - -# Adjusting the legend -leg = plt.legend(loc="upper left", frameon=True) -leg.get_frame().set_alpha(0.5) - -# Adjusting the grid -plt.grid(True, linestyle="--", linewidth=0.5, color="grey", alpha=0.7) - -# Increase tick label size -plt.tick_params(labelsize=10) - -# Save the figure with high resolution -plt.savefig("result.jpg", format="jpg", dpi=150) - -# Show the plot -plt.show() From ff7da0b6295481b07fc6dcfe62f7a86734f5e6b9 Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 2 Jan 2024 16:53:07 -0800 Subject: [PATCH 5/9] Update the imports for lmm tests --- test/agentchat/contrib/test_img_utils.py | 3 +-- test/agentchat/contrib/test_llava.py | 9 +-------- test/agentchat/contrib/test_lmm.py | 2 +- 3 files changed, 3 insertions(+), 11 deletions(-) diff --git a/test/agentchat/contrib/test_img_utils.py b/test/agentchat/contrib/test_img_utils.py index 70b31dc8adcb..cad916e427cb 100644 --- a/test/agentchat/contrib/test_img_utils.py +++ b/test/agentchat/contrib/test_img_utils.py @@ -1,14 +1,13 @@ import base64 import os -import pdb import unittest from unittest.mock import patch -import numpy as np import pytest import requests try: + import numpy as np from PIL import Image from autogen.agentchat.contrib.img_utils import ( diff --git a/test/agentchat/contrib/test_llava.py b/test/agentchat/contrib/test_llava.py index 5ae5e4abb889..b7502e8c83e4 100644 --- a/test/agentchat/contrib/test_llava.py +++ b/test/agentchat/contrib/test_llava.py @@ -3,15 +3,8 @@ import pytest -import autogen - try: - from autogen.agentchat.contrib.llava_agent import ( - LLaVAAgent, - _llava_call_binary_with_config, - llava_call, - llava_call_binary, - ) + from autogen.agentchat.contrib.llava_agent import LLaVAAgent, _llava_call_binary_with_config, llava_call except ImportError: skip = True else: diff --git a/test/agentchat/contrib/test_lmm.py b/test/agentchat/contrib/test_lmm.py index a6d99b5d7890..c60faf33250d 100644 --- a/test/agentchat/contrib/test_lmm.py +++ b/test/agentchat/contrib/test_lmm.py @@ -5,9 +5,9 @@ import autogen from autogen.agentchat.agent import Agent -from autogen.agentchat.contrib.img_utils import get_pil_image try: + from autogen.agentchat.contrib.img_utils import get_pil_image from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent except ImportError: skip = True From e64b75bf1b6e51633d259b0b978899cb06c7e2c1 Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 2 Jan 2024 17:04:39 -0800 Subject: [PATCH 6/9] Test case fix --- autogen/agentchat/contrib/img_utils.py | 1 - test/agentchat/contrib/test_img_utils.py | 38 +++++++++++++++++++++++- test/agentchat/contrib/test_lmm.py | 6 +++- 3 files changed, 42 insertions(+), 3 deletions(-) diff --git a/autogen/agentchat/contrib/img_utils.py b/autogen/agentchat/contrib/img_utils.py index 854469819f1c..1a275ec94c56 100644 --- a/autogen/agentchat/contrib/img_utils.py +++ b/autogen/agentchat/contrib/img_utils.py @@ -288,7 +288,6 @@ def message_formatter_pil_to_b64(messages: List[Dict]) -> List[Dict]: # Handle the new GPT messages format. if isinstance(message, dict) and "content" in message and isinstance(message["content"], list): message = copy.deepcopy(message) - # import pdb; pdb.set_trace() for item in message["content"]: if isinstance(item, dict) and "image_url" in item: item["image_url"]["url"] = pil_to_data_uri(item["image_url"]["url"]) diff --git a/test/agentchat/contrib/test_img_utils.py b/test/agentchat/contrib/test_img_utils.py index cad916e427cb..7d8385546ad4 100644 --- a/test/agentchat/contrib/test_img_utils.py +++ b/test/agentchat/contrib/test_img_utils.py @@ -11,11 +11,13 @@ from PIL import Image from autogen.agentchat.contrib.img_utils import ( + convert_base64_to_data_uri, extract_img_paths, get_image_data, get_pil_image, gpt4v_formatter, llava_formatter, + message_formatter_pil_to_b64, ) except ImportError: skip = True @@ -34,7 +36,10 @@ "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" ) -raw_pil_image = Image.new("RGB", (10, 10), color="red") +if skip: + raw_pil_image = None +else: + raw_pil_image = Image.new("RGB", (10, 10), color="red") @pytest.mark.skipif(skip, reason="dependency is not installed") @@ -252,5 +257,36 @@ def test_local_paths(self): self.assertEqual(result, expected_output) +@pytest.mark.skipif(skip, reason="dependency is not installed") +class MessageFormatterPILtoB64Test(unittest.TestCase): + def test_formatting(self): + messages = [ + {"content": [{"type": "text", "text": "You are a helpful AI assistant."}], "role": "system"}, + { + "content": [ + {"type": "text", "text": "What's the breed of this dog here? \n"}, + {"type": "image_url", "image_url": {"url": raw_pil_image}}, + {"type": "text", "text": "."}, + ], + "role": "user", + }, + ] + + img_uri_data = convert_base64_to_data_uri(get_image_data(raw_pil_image)) + expected_output = [ + {"content": [{"type": "text", "text": "You are a helpful AI assistant."}], "role": "system"}, + { + "content": [ + {"type": "text", "text": "What's the breed of this dog here? \n"}, + {"type": "image_url", "image_url": {"url": img_uri_data}}, + {"type": "text", "text": "."}, + ], + "role": "user", + }, + ] + result = message_formatter_pil_to_b64(messages) + self.assertEqual(result, expected_output) + + if __name__ == "__main__": unittest.main() diff --git a/test/agentchat/contrib/test_lmm.py b/test/agentchat/contrib/test_lmm.py index c60faf33250d..546878867611 100644 --- a/test/agentchat/contrib/test_lmm.py +++ b/test/agentchat/contrib/test_lmm.py @@ -20,7 +20,11 @@ "//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==" ) -pil_image = get_pil_image(base64_encoded_image) + +if skip: + pil_image = None +else: + pil_image = get_pil_image(base64_encoded_image) @pytest.mark.skipif(skip, reason="dependency is not installed") From 3347646a163a90c6da61fe2ced3a545ab7f90e92 Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Tue, 2 Jan 2024 17:06:09 -0800 Subject: [PATCH 7/9] Docstring update --- autogen/agentchat/contrib/img_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/autogen/agentchat/contrib/img_utils.py b/autogen/agentchat/contrib/img_utils.py index 1a275ec94c56..7afc61bb216a 100644 --- a/autogen/agentchat/contrib/img_utils.py +++ b/autogen/agentchat/contrib/img_utils.py @@ -268,7 +268,7 @@ def message_formatter_pil_to_b64(messages: List[Dict]) -> List[Dict]: {'content': [{'type': 'text', 'text': 'You are a helpful AI assistant.'}], 'role': 'system'}, {'content': [ {'type': 'text', 'text': "What's the breed of this dog here? \n"}, - {'type': 'image_url', 'image_url': {'url': }}, + {'type': 'image_url', 'image_url': {'url': a PIL.Image.Image}}, {'type': 'text', 'text': '.'}], 'role': 'user'} ] @@ -278,7 +278,7 @@ def message_formatter_pil_to_b64(messages: List[Dict]) -> List[Dict]: {'content': [{'type': 'text', 'text': 'You are a helpful AI assistant.'}], 'role': 'system'}, {'content': [ {'type': 'text', 'text': "What's the breed of this dog here? \n"}, - {'type': 'image_url', 'image_url': {'url': }}, + {'type': 'image_url', 'image_url': {'url': a B64 Image}}, {'type': 'text', 'text': '.'}], 'role': 'user'} ] From bcfc9159f169a57de8b19543fe7adc2beb9139dc Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Wed, 7 Feb 2024 10:43:08 -0800 Subject: [PATCH 8/9] LMM notebook lint --- notebook/agentchat_lmm_gpt-4v.ipynb | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/notebook/agentchat_lmm_gpt-4v.ipynb b/notebook/agentchat_lmm_gpt-4v.ipynb index 20dad9af3456..c56c6e6a1db7 100644 --- a/notebook/agentchat_lmm_gpt-4v.ipynb +++ b/notebook/agentchat_lmm_gpt-4v.ipynb @@ -112,7 +112,8 @@ " idx = arr.index(x)\n", " if idx >= 0:\n", " arr[idx] = y\n", - " \n", + "\n", + "\n", "replace(x, gpt4_llm_config, 4)\n", "\n", "print(x)" @@ -636,15 +637,9 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", - "import time\n", - "from PIL import Image\n", "\n", - "creator = FigureCreator(\n", - " name=\"Figure Creator~\",\n", - " llm_config=gpt4_llm_config\n", - " \n", - ")\n", + "\n", + "creator = FigureCreator(name=\"Figure Creator~\", llm_config=gpt4_llm_config)\n", "\n", "user_proxy = autogen.UserProxyAgent(\n", " name=\"User\", human_input_mode=\"NEVER\", max_consecutive_auto_reply=0, code_execution_config={\"use_docker\": False}\n", From 44a48628b62461153e44848fbf0b2ecaf458dd13 Mon Sep 17 00:00:00 2001 From: Beibin Li Date: Wed, 7 Feb 2024 10:50:47 -0800 Subject: [PATCH 9/9] Typo correction for img_utils and its test --- autogen/agentchat/contrib/img_utils.py | 2 +- test/agentchat/contrib/test_img_utils.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/autogen/agentchat/contrib/img_utils.py b/autogen/agentchat/contrib/img_utils.py index 7afc61bb216a..6062f3b05530 100644 --- a/autogen/agentchat/contrib/img_utils.py +++ b/autogen/agentchat/contrib/img_utils.py @@ -162,7 +162,7 @@ def gpt4v_formatter(prompt: str, img_format: str = "uri") -> List[Union[str, dic Args: - prompt (str): The input string that may contain image tags like . - - img_format (str): what image format shoule be used. One of "uri", "url", "pil". + - img_format (str): what image format should be used. One of "uri", "url", "pil". Returns: - List[Union[str, dict]]: A list of alternating text and image dictionary items. diff --git a/test/agentchat/contrib/test_img_utils.py b/test/agentchat/contrib/test_img_utils.py index 7d8385546ad4..39a4a7f608af 100644 --- a/test/agentchat/contrib/test_img_utils.py +++ b/test/agentchat/contrib/test_img_utils.py @@ -49,12 +49,12 @@ def test_read_local_file(self): temp_file = "_temp.png" raw_pil_image.save(temp_file) img2 = get_pil_image(temp_file) - self.assert_((np.array(raw_pil_image) == np.array(img2)).all()) + self.assertTrue((np.array(raw_pil_image) == np.array(img2)).all()) def test_read_pil(self): # Create a small red image for testing img2 = get_pil_image(raw_pil_image) - self.assert_((np.array(raw_pil_image) == np.array(img2)).all()) + self.assertTrue((np.array(raw_pil_image) == np.array(img2)).all()) def are_b64_images_equal(x: str, y: str):