{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Group Chat\n", "\n", "Group chat is a design pattern where a group of agents share a common thread\n", "of messages: they all subscribe and publish to the same thread. Each participant\n", "agent is specialized for a particular task, such as writer, illustrator, and editor\n", "in a collaborative writing task.\n", "\n", "The order\n", "of converation is maintained by a Group Chat Manager agent, which selects\n", "the next agent to speak. The exact algorithm for selecting the next agent\n", "can vary based on your application requirements. Typicall, a round-robin\n", "algorithm or a selection by an LLM model is used.\n", "\n", "Group chat is useful for dynamically decomposing a complex task into smaller ones \n", "that can be handled by specialized agents with well-defined roles.\n", "\n", "In this example, we implement a simple group chat system with a round-robin\n", "Group Chat Manager to create content for a children's story book. \n", "We use three specialized agents: a writer, an illustrator, and an editor." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Message Protocol\n", "\n", "The message protocol for the group chat system is simple: user publishes\n", "a `GroupChatMessage` message to all participants.\n", "The group chat manager sends out a `RequestToSpeak` message to the next agent\n", "in the round-robin order, and the agent publishes `GroupChatMessage` messages,\n", "which are consumed by all participants.\n", "Once a conclusion is reached, in this case, the editor approves the draft,\n", "the group chat manager stops sending `RequestToSpeak` message, and\n", "the group chat ends." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "from autogen_core.components import Image\n", "from autogen_core.components.models import LLMMessage\n", "from pydantic import BaseModel\n", "\n", "\n", "class GroupChatMessage(BaseModel):\n", " body: LLMMessage\n", "\n", "\n", "class RequestToSpeak(BaseModel):\n", " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Agents\n", "\n", "Let's first define the agents that only uses LLM models to generate text.\n", "The `WriterAgent` is responsible for writing a draft and create a description\n", "for the illustration.\n", "The `EditorAgent` is responsible for approving the draft which includes\n", "both the text written by the `WriterAgent` and the illustration\n", "created by the `IllustratorAgent`.\n", "\n", "The participant agents' classes are all \n", "decorated with {py:meth}`~autogen_core.components.default_subscription`\n", "to subscribe to the default topic type, and\n", "each of them also decorated with {py:meth}`~autogen_core.components.type_subscription`\n", "to subscribe to its own topic type.\n", "This is because the group chat manager publishes a `RequestToSpeak` message\n", "to the next agent's topic type, so to avoid the message being consumed by\n", "other agents." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "from typing import List\n", "\n", "from autogen_core.base import MessageContext\n", "from autogen_core.components import (\n", " DefaultTopicId,\n", " RoutedAgent,\n", " default_subscription,\n", " message_handler,\n", " type_subscription,\n", ")\n", "from autogen_core.components.models import (\n", " AssistantMessage,\n", " ChatCompletionClient,\n", " LLMMessage,\n", " SystemMessage,\n", " UserMessage,\n", ")\n", "\n", "\n", "@default_subscription\n", "@type_subscription(\"writer\")\n", "class WriterAgent(RoutedAgent):\n", " def __init__(\n", " self,\n", " model_client: ChatCompletionClient,\n", " ) -> None:\n", " super().__init__(\"A writer\")\n", " self._model_client = model_client\n", " self._chat_history: List[LLMMessage] = [\n", " SystemMessage(\n", " \"You are a writer. Write a draft with a paragraph description of an illustration, starting the description paragraph with 'ILLUSTRATION'.\"\n", " )\n", " ]\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", " self._chat_history.append(message.body)\n", "\n", " @message_handler\n", " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", " completion = await self._model_client.create(self._chat_history)\n", " assert isinstance(completion.content, str)\n", " self._chat_history.append(AssistantMessage(content=completion.content, source=\"Writer\"))\n", " print(f\"\\n{'-'*80}\\nWriter:\\n{completion.content}\")\n", " await self.publish_message(\n", " GroupChatMessage(body=UserMessage(content=completion.content, source=\"Writer\")), DefaultTopicId()\n", " )\n", "\n", "\n", "@default_subscription\n", "@type_subscription(\"editor\")\n", "class EditorAgent(RoutedAgent):\n", " def __init__(\n", " self,\n", " model_client: ChatCompletionClient,\n", " ) -> None:\n", " super().__init__(\"An editor\")\n", " self._model_client = model_client\n", " self._chat_history: List[LLMMessage] = [\n", " SystemMessage(\"You are an editor. Reply with 'APPROVE' to approve the draft\")\n", " ]\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", " self._chat_history.append(message.body)\n", "\n", " @message_handler\n", " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", " completion = await self._model_client.create(self._chat_history)\n", " assert isinstance(completion.content, str)\n", " self._chat_history.append(AssistantMessage(content=completion.content, source=\"Editor\"))\n", " print(f\"\\n{'-'*80}\\nEditor:\\n{completion.content}\")\n", " await self.publish_message(\n", " GroupChatMessage(body=UserMessage(content=completion.content, source=\"Editor\")), DefaultTopicId()\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's define the `IllustratorAgent` which uses a DALL-E model to generate\n", "an illustration based on the description provided by the `WriterAgent`." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "import re\n", "\n", "import openai\n", "from IPython.display import display\n", "\n", "\n", "@default_subscription\n", "@type_subscription(\"illustrator\")\n", "class IllustratorAgent(RoutedAgent):\n", " def __init__(self, image_client: openai.AsyncClient) -> None:\n", " super().__init__(\"An illustrator\")\n", " self._image_client = image_client\n", " self._chat_history: List[LLMMessage] = []\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", " self._chat_history.append(message.body)\n", "\n", " @message_handler\n", " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", " # Generate an image using dall-e-2\n", " last_message_text = self._chat_history[-1].content\n", " assert isinstance(last_message_text, str)\n", " match = re.search(r\"ILLUSTRATION(.+)\\n\", last_message_text, re.DOTALL)\n", " print(f\"\\n{'-'*80}\\nIllustrator:\\n\")\n", " if match is None:\n", " print(\"No description found\")\n", " await self.publish_message(\n", " GroupChatMessage(body=UserMessage(content=\"No description found\", source=\"Illustrator\")),\n", " DefaultTopicId(),\n", " )\n", " return\n", " description = match.group(1)[:500]\n", " print(description.strip())\n", " response = await self._image_client.images.generate(\n", " prompt=description.strip(), model=\"dall-e-2\", response_format=\"b64_json\", size=\"256x256\"\n", " )\n", " image = Image.from_base64(response.data[0].b64_json) # type: ignore\n", " display(image.image) # type: ignore\n", " await self.publish_message(\n", " GroupChatMessage(body=UserMessage(content=[image], source=\"Illustrator\")), DefaultTopicId()\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lastly, we define the `GroupChatManager` agent which manages the group chat\n", "and selects the next agent to speak in a round-robin fashion.\n", "The group chat manager checks if the editor has approved the draft by \n", "looking for the \"APPORVED\" keyword in the message. If the editor has approved\n", "the draft, the group chat manager stops selecting the next speaker, and the group chat ends.\n", "\n", "The group chat manager subscribes to only the default topic type because\n", "all participants publish to the default topic type only. However, the group chat manager\n", "publishes `RequestToSpeak` messages to the next agent's topic type,\n", "thus the group chat manager's constructor takes a list of agents' topic types\n", "as an argument." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "@default_subscription\n", "class GroupChatManager(RoutedAgent):\n", " def __init__(self, participant_topic_types: List[str]) -> None:\n", " super().__init__(\"Group chat manager\")\n", " self._num_rounds = 0\n", " self._participant_topic_types = participant_topic_types\n", " self._chat_history: List[GroupChatMessage] = []\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", " self._chat_history.append(message)\n", " assert isinstance(message.body, UserMessage)\n", " if message.body.source == \"Editor\" and \"APPROVE\" in message.body.content:\n", " return\n", " speaker_topic_type = self._participant_topic_types[self._num_rounds % len(self._participant_topic_types)]\n", " self._num_rounds += 1\n", " await self.publish_message(RequestToSpeak(), DefaultTopicId(type=speaker_topic_type))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Running the Group Chat\n", "\n", "To run the group chat, we create an {py:class}`~autogen_core.application.SingleThreadedAgentRuntime`\n", "and register the agents' factories and subscriptions.\n", "We then start the runtime and publish a `GroupChatMessage` to start the group chat." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "--------------------------------------------------------------------------------\n", "Writer:\n", "**ILLUSTRATION:** The scene captures a majestic dragon perched on the rugged cliffs of a towering mountain. Its scales shimmer with iridescent hues of emerald, sapphire, and gold, reflecting the light of a setting sun. The dragon's wings are spread wide, made of a delicate, translucent membrane that seems to catch the colors of the sky—fiery reds, oranges, and cool purples. The creature’s eyes glint with ancient wisdom and a touch of mischief, while smoke curls lazily from its nostrils. Below, a lush, green valley stretches out, dotted with medieval villages, castles, and winding rivers. Tall trees frame the edges of the illustration, their leaves rustling in the gentle breeze.\n", "\n", "**Poem:**\n", "\n", "In twilight's glow on mountain high,\n", "The dragon reigns, near touching sky.\n", "With scales that court each fleeting ray,\n", "A living gem at end of day.\n", "\n", "Wings unfurled in sunset's blaze,\n", "Reflective of night's softest haze.\n", "Eyes of lore, both wise and bright,\n", "Guard secrets of the coming night.\n", "\n", "From nostrils, wisps of smoke ascend,\n", "As valleys below in shadows blend.\n", "Ancient heart, fierce yet true,\n", "Watched realms where dreams in whispers flew.\n", "\n", "--------------------------------------------------------------------------------\n", "Illustrator:\n", "\n", ":** The scene captures a majestic dragon perched on the rugged cliffs of a towering mountain. Its scales shimmer with iridescent hues of emerald, sapphire, and gold, reflecting the light of a setting sun. The dragon's wings are spread wide, made of a delicate, translucent membrane that seems to catch the colors of the sky—fiery reds, oranges, and cool purples. The creature’s eyes glint with ancient wisdom and a touch of mischief, while smoke curls lazily from its nostrils. Below, a lush, green v\n" ] }, { "data": { "image/jpeg": "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", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4ATz9Z7OlWZYf9h3vz7kuXVWW6a6uttPjOBMAYQaiEQQpKCmICEKh4EsxQl9Bn0XvGQyGQkEGX5AiJBgSQwxmBph2M22qy1dmpbl53fH+HP3++5Z0M/PmMc+zzVr/Zffa+6m+95/9XyrVarPV3u/Wx8P2sN9WjtVGo+vDeqNerVZ32/WxUqnU6rVavbo/Vmr+rx18dDg0Go1ao3E8um9fqR7rrUbleGzUG8eKP4dKpbrbH2vV+m6z1U69Xtus18f98bA/NGq1g/9cU61V859ut7VK7bDbV915OLj6eNTksVqrV1yiv2PeVWtp2nAqx3qlUj9WDtWGBo4G5bchuLVSM6JjvVbVVDUjr2TUXlUru5pRH/J67zqdNHb7nbF5neEcj9v18mg8h71J6i0N+an6kxszIL+NLJ+6XpN5qQGzyptyQZrz75AxmP9x70bvDnVzcU/6SRO5y1xqppg5ukwrRnzYpykE872v0H1/2DcazXzSbBybDc36vNvvHWuVdrftkt1mgw+1ZrXZHeBhu91pdTqb9erQavUvTrq3L3rrSWWzmi+mlfaw1uiuq7vm6OT4+DuL9Ro1jEQ39f12v14037xqf/16tcLqbeXu5c3Xr75+eTNb7fb7w263y7BwNNPJ+PHYcMp8QqVms9ZqNbYb3KpXqvuKoewq9UbLPai23x18ir3uOx73gKTTkM87M6ohQWW3DfU1jzC4hqAogh1Pnz76zofvLae3dzc30+lqudxpxpBQSuNhSmUHG5prtjC+Nui2W83Gdrdfb8PwdrXRbtV3jXAdPrfbSr3W0nG72WyEKYfjTs/7Q7PRwESsScvHmgGU6dYgikwErkZcNRm/IL+53WwBDyFqTbIBeNWdmRlOGFwkpVM/mja2mUR+ykzrBVg60ozphQCArueCsHRS10XY4tNqxClXBW3p2U/gkx/Sgq4HpPNTD1/I1e6Acmi816YxBLimnTcBKO5FNo0f4L3HqnQPczqpVuqtVkQxV+rGHy9KX2mgRm4y6vy4JyoAIYtEpsc0FkUBEFEHERpgCQvzORxnyAG+JoP9yDYB1r7PCILW90GYLxrNiEqgEHjs682mdl2GVkC3D43haacvoC1dpGcfbxYLN6P1aj7e7xtYeNhWNtV2ZbbGg+Z0Nb/bVtvdfTMIaDw6NkPh6rZKOKvw3cXQ28V6ttsvJtvp7fWrly8vb6kvHC1UjLzCScZofPUjFVmjgMK3UJ8MVnZHwIDt9Zq2ae4rWzMynkhYiFpptduwfdhDSiYYGkKBD5BpHyqF9eGMT4MMt52ejjqd9icff049GeR+HQ5mROHHntbIKI7VDrUKIkbVrO12m9UGprXXQNtjq1brEMQ0XKG1I6Wm0ELuBlTe8yMD0qumfEXl1MkLch8a7TrFnG8zTRegGIUVypm/kdOjhSAmFdRDUUFqbiia+0DMKJDtlraG/QiYe40cv0urhTCoZ76+jmrOSNNIlR46EHZvfUlFNMhDXkdv1uqN0CFoCPLvieLbNG4g+ZUZuRDpg+6q6/yNMbtv3qzIg+u9iBFzHblvAF+EX9P+w5hQ0G3BQMig5dABgwqmQ5WMyGDTF4nM5dol+175Jp/fCzdZdTeLZgz5KmMMRVmbUKtSa/hATz69/6ZIYMatFxKuqeNxF+tXr+IwETI8ZDSj/QEb6jrHcWPfLjctwrzZLe+mq/1+tK92mu3a/rhcLtfb/U4DwwewzIJvaOxGhZXuTtfbLy+3k+V+t9xefbm4un19NZ9vQqRo41AVBzIlYG9QakF9BoAWTQIUYtNcqLSj7mAaHHC8jDnjNgvjXG039XAh1ASwfE01YcEuNCgEvid3qEDyB4NRp9tarbfj2ynChdMuqqBtVBL93QLvQCbfkAYytNpCJXTU2+1mC9zrzF4nHxFDio5l8lkjBGx2ug036ne73XW6HbTMcLgxzYZBgphGOQnGcSTPdDM7EO4CElJnBDFRlepqtW7QfPkINTRgiLRpuaXZ2tAhwWW902nFChwqux31y8+hldzRaLXojNp6sWp2j+v5kl7VKMCXdpAehdJLCOQnpiVigHyhKvNKUPdAlYGBJfa7wqW5M4rJtOiWfGds5TfM1zKmGFEN0ut4eQ87nWQWYXdhpqZ8zUW7FwMXxaxk9IbkC6MMxWCkGH4NBbouK1d6xURGqZXb46eZlbeug4ZcVYspd5c3jfvRl2+NMEJlyI0as+0z7Rd/g6alm/ZxAZF/u+X6AEK7aJn1am2skIDIGIwh9coa8lfHSnu7a8QhcEnuOjTvzt5bV1qtyDcqzja7r95UFtvdatXc3i438+evJ4sNUtKwoBCeZtg0bNGqkbZWe82Z8F3k/2AMmjewQhbcMF6TomF3iEDoCPWGH2imIa4fv90bgN2/Bi2TDB/NulrpdponwyE9PV+uFovZbr3ptJq4GnvCSEJnldbndW81Hh1AweL+hvlENKamhiSt9jHe4GG7Wm+iIKJ4Kqv5rNPtD09Hu0YnAhBeFYHko3daLbIV1hhdXVN8uPruIEhobTc0GnPTwEWiD3kBFpVcrXX6fQDY7nGFFiAJIFgHdc3uiI5ezepw3Ow2ho7dhN+FpI6A5hNuC7cL56JYA757r5CkMBm4WYgPEPvi1MTphOSomXyjgcQkkUwAD2zxoMiMb6JW2I1IlAu1ix+HkC5WJRyIiaS39vHxwowoUg2aGq2d5r7pIRAIq6mE+ztL39pMz+FjYRp0m7WGQ9aMzF2u8H+Ilu7Qgrvvo7QblVeUa+zJLnJSbk0skK9Mh7bUbZRRMRqRIwCKt+mLBFfcB9esDMpA8NeAotvScAnndtvasQ8ttRWFR7I3i16rux8MF/XG2hWbLW3YXS63Xz3f391W94v+frqaLL76crJYI7fxZ1DmHbZkTlHXuhE5IVGz0dpu1yy8WWzWeFonAXWiG/CHk4ZUWO2rEAH6mnW6tZDIrMInnwGJC00p84Zk7nuv1xkN2vPFcjy+Y0r0DSq+3q53tAHPvdWOW7GvHddbhKw2m9UuA1qrb4Fid2i1IXdfXI/dUSxEWDs9lnO73QBAs93o9trHdr81ONMoZCZSMXQKJqMuOrbMPC5vQB66VtutVlwitAhd+PxUkNiiuV/zp0IXMGf5VstV4o+tsKG536yjgeuCG4YnipVsxJUJIYvDlw+jNnZblr3YBAp752Y40cuOydKPthlTfQPCvecfggaqWi3NHhPa8gXjh1EAkRv6NDYkiCh4FyxSjAYfuGKLJpAujSdaNSAjM9HCnOAPKYhUxCnDNSB8FVikI18blWaKiGUCWgXUtKPR/5/IRkpLH7ncINJ1AbcPS9f3uj8DK9G/awpQiulzacI7XWMJ0rJzQbWPK6ttrEcwn9CFVt2tg6kGMWJId0k5UEfNZqdBAR8Oq+VaemIlhMXexrbRq1ROnwwevrertqGlMZksP/ltZyWynA+adPXmqy+u8O3AIIW6TF3mRI41W4+O1QnHgNqW9qg1m/TRAccQIUyLosOm+GGoYcjm1NC9Vg48L6q5suFR39PIf74OFuAgmkL7vUGH4t9vNm8u7+bQrRMyQ8IyX1G9RADfpoEji80uJqhWOxs0h73uYbna8iyq+6Z+WexGY7nE5Vp/2BX2rCFhVyE/5tA9vTg0eqvtobGaaMg4C1AQt4gpdYHaXJqieXlLLf+CjqbIZiu/AK+6J20RdLzN9YFTzMJeDNSAVLxkl/xH228364JFprshagmliveBoO6PstMGjvIWUDqCzpYwc7tG3HHtUjZxUYCU3dkVCgcMguWiUNGb0GQerhAsRhiDGu0CMZAVYMCQUeMfRhYWGmUMRNxKyAhED0fsiWcV0W7iTmXHlzSGeAH5OD188+OzvAriNReImEqmRtiKwgADn/m+UCMTJMTUssHdtxL9xVrGQ8s407zv6l5EXkowDVKmmE9iLOJ+ZBblZT5ABJPO5frd1Rm+Q40Fwxe9HDebdVSP4cU/bO1XUwp/cxxg4n4xr9ze9HievNGPfzP/9a9e3833jeZiNqlvtovZbOXCECRjiUYPZUOngD8zkvzIxE3BtygcoOcLQ0FdOHcN25/EF7Z5S1ZJs5lvNhszgNSQodbY0YjherRiq1k/OxuRgfHdeDnbJJUgCgDEhlRkhoAYfm93x8QtumpUO602k7LbLMfbRVwRwqjxw7HZbq51EYDUJotDp00RAM6hPex3O0O5sinvrnpcLWZJYhqw2LqVGdTWG37KdjAcGreBobhm+VhJHrm/03GlZlE1o4s/s2N4Epgl/PJhY+9NwX0kAoJFWCaPSF7FwtQ3h01sgI5D3sBGU/fQDDECv+AX/vJ9YsiQlcoA3Ri4ey7UjIqhZxiavuNJ3bdYwJUbtI/yKEYzsj5wEzyGO2HPfZPeY2G+CbFDLle7gJUM4rhFgp/AmnTRFIZDRyRtEF7DZcb3jSVxmSGH11iU8erj/jUW6Ni0TEzQSc4Tg5VgJoAxVXojd3p9L7RFPjX9jT0SKcpyJN8AflErBAkQDNLnOtxtKAvkie/VaMWYGHKrI3WxXc6Xm5oQa3jsdoedQXM7uZMbmcwbh6vtfLndLTqN5vWvP5q9erPdVVe7yWI2P25WmTLeG4w/YUT0NFZ6meHr02ANJrkPToWZZcZuQsJYVUSJIsgr2iA0JDD3KlVkIiQIYQqEQmVKaM/cdLvN04sTUnN9ebvi0QVdYmvAiIvSZM7D96qsl+4So5q5lEgGtEceFtorbnWzlXxk8TOAzW3NZrfX7w/5S5wi0SacGlib77RfyY02RAo6w3s8lyg4Im+lvt3tCpGje8wJyEwKV4UbpmUIjaRbeUeEIYqBnBqmD1fLuWjB/IEz6C8oaLc60nNghDUBICVX8qH3hj3MQ+M0lPgGcZL1Q7kwIRALuYQHoUSYYao+LDnpUKSIh5lHNcaGACJA+xiNo98in3E0A5WQ3U+EzahFzjgbfYkgUfNhNkOXHFGUqMa99aHQ30zDXQyTVY7WrrTqrV1ChshsZhk4UMGGE4Nzz/z0RSlEqOMZG1W4p6dgJQKZT7KcklRsoScmUFpayThNL/NFmYiHLxqxMOmO1KXP0AYMMNFllep6v61zc2QBa03pyO0ycafZ8eHmte1Z59CZb4aZ7mEzHdd628rV+url6+XV9fpQofhWi7m1oIhqbB8K6ZVrkBGk9WSefFT6hLC8Cn2Q7kB6omLQKtLsfrSKt4byglRXgBCFlbwkrZwLM/UiZ/po1asXD/uc9MlsPZ8sefwUhMnp1uJHaAdmYXSI71ejzSgU200lRNJQ29JHWNxsdTc+OR6lf6ReUD/eUqspiE5DFoIq/EcpmGJZ+XHWTzI6w2FPmo3NfqOxQLF8FKUedWk+0cM4BJrfGC904p+7LmB0WRyP9XadUNLVx4TeSEcqzcdXR35ZveXbKItY3vgbsnIVIelOLJXAGuIbCV4K9ikYYwgMzdCtESp+TvwtY4KnSuS2JefNRy+Ogcsjo7AbcLgOO8Tu+BGCBl/4mNSKcRUZaLLJAAlZAFZ4bmxFNSOwCceUhWwuiPJDhpAptCl+iGEFGgGrNol1JAHWI9sEuATQka0QqfwNjDN9tyQ4MYikfQgAhhiqlgMg8XdchcwhsE62MYGE4AoktBWJ81VQXvcCVTgR4BVNYaSS3RkUumYyPHM0Ir0bvn3jYC2o06stF7vZ9iAQ2F6+nn3x+ZJrUGuBQnBcPPg0dD8zQqtlNA0gzSXaGDsLFWIAzYcEx3ASe3JYFnAAEla8yae4E/rwW5J9QIeEZ6Gh4fn/0O81Hj04X20O11cTuc5gxeAp06I8k4EkIfR7OBGs18S+GO2P3o/HTpunCn0tao+0TlbJfzSabbKGFsbtIh44aN2TtLJYhuXG2u7tdusWm4z7CCQfvN1u9bre8k/CbR1HVyOxFcGKZUgfZtjAkJnH5/N9Vhzwakv3NCwhbXArVseQLU+SRSQx8uO+NeyQAMqJ3xL0UaqwyJUz9YBcHnpDcwKd1iAIBZEaeV2IxYW75oj0SBstAJHYUH4MBsNiLANTBIijH6ggsP65oWgTVBGpIkCmEVKiqr+hWyhgkL6N+kVKF0BnrYlrmWlEoFnc90QLuSNWHmtpXyQWXBXDVVag0rcv0oYJZIAZUxpGNw56fLUwX2d0G5D6aTRYKqNnJSx6uFL3yFLsjbt1bxoIJsQ/tPrNVjPKxVTkuM0V/pJGs87V7chxQB55gdQaz1fmLRA9WJaa7RrbzsPjetwaVrrrRnVfe/nZs/VkuQLo/VoSBwUwNj9BfwaNrJHv/IIZl0VdGEwIRxA4pbAkNAwZucoW/mMDfWQ9w6VcYxQykZhrWjcCTh8Fi/iF2aeD7smoO5utx9M1ba5zYxBUY40mjaaoJi1xcsA6aYbNLkaSzSSYpo9GSLXWJPdY1pdv0xJDBnj8Fo6Jr3cbQU+UNbIzSpSs1hfLRadeH7APm/kKdc0VojAV/3RseNFnkINph6PAl/MTdV5c3ntI6cNNgsXgIeJgWoAS80SpleU2vMAzLKmLLBCt0UGsZlxtNDhU5ZDdFLzJh7asTIhsLG3KuJdMGUBE2fgR2sFBPdiISXVHrGFBkWW/JBx0jYDxEmKCoybN3jyNypX6I7nR9EWTczR9Hl0RYSn1FzyYJmTiTjieOUcVBfgZgw91pv8Y98Ls+C2l5VA1cRye6Sh+DpMVVkIRdufr4EhSOOKcEDtoKt/739ffjLwIdBH5bwbp7kwLCamlXGhsqBxp2ByQq23w2kTt5BUSajYb7XapW0FOqpNEQa4McBESvde7+95owQBzAq7fvPz6eno3cVmcGwyE7ozP38zRnAr6M9i40ql3KOY3xAnf3UHOAgG8yQDj1saPRVW/DLOMH/RDTIjSS0iXJQq3wMBoNASHN5fT1fYoYPUtemSwGS+eR9vdU4AYggcZF/5GuqJ3UCImCHX4ehJfMp4+yqoXmofK7i5rhRU6mvAlNQSgUO0t6RmIBirV6Xge67Lf0N/32hcB9A8I5hilelhnHf5As9+z3phMrEZRocCupE2NXK+ko9Zus6Q6C5pyeWYEivLUFhQa2IOX9yEHSYOLSptr03URXSLyNnveQBbS1YRsrOZBUsKMglxkLQQJ6QHMTwFvKAGd2sofU9Rj0lCmlfkaSV0TppQ3wFTkYR9tFZ9dI3qJciUPCc5oFe2ZJKeztt2xyGFCpGDHVjalLALZ+57C/tgUEh5m6yEi6HUwQnz0XyL2KGoiBCroRhtr0OgDEc1GsA01hinSl0l5k3c0SfBVk/Du6ELQEzrLJ8Znq8kaW+iVniut8rmEwpXtYtnqtHb7RJxmm95JJet09H2lcbCq27GWc3Jy1v76anZ7m7gw0xUtx9kL/TIQE+ArB/ZFxRmgIadbwysSEsXoWpl4M3aXGcYfRvVYqhrhQ4DYaCNwBWURuhf2HbjpfFdpezpxP7mbRfHrIH/MNZiBGK166a8bgw7rHBurSSFLmFGr8nDggXvF9TBIqaDYQgPJyEhchsqXQSF365BbStRl53FBzkCyK5Ey7WA0Fr8gIKrPSGPWyQNtjfA1ZSSmxztIdURhq+ZRBaf9puYj6nCZH1o1DFYM1SQwluIjZ9GFpK3oFMo5oW2iRoIueWUecEKSsnC9NXJAZxM0Q5kD8XG9wQ9LLTs5Lx/F9cm3MaYpPjKEAnH/hUwcFSoKb0LOUJKtcP2ObHOXg84wJ2pbj9FAPiRdOBm7h7KJrQ0N2wqIdZGMm/HRnfF7UEAmSEd4xdjnPfmxtEcIQwDXJdhAoqIr4iwEfklruicOgEYw22wzOx355+rckD9RffFdUu3mC5KZr4WnqxX9F34TLwQptYbMG52dSEDnGYgxRoQ2S/bce42RLurLAq1cfaPb3L0/8OXGktdnl+PZ3cR4ojpcFLJlDIgQJ6wMCszC2VJhFpLEIPiWtYlBkE6Je2U4WTFEjOhv4DdNeiT0xwATCE3iKIZ7/hmYkLNS7XbaODify9L79BvcGwgqhnZBv0HE82SINGZq1HbyCNjH8mR26EMkig+Y3LuFI6gL+cBafIiZbgBojSBSS3qGs83O1IQEwiOg6NS7g2NPAVEoawHZGi3CBemAHIq4OxkPZURJiRi4ifmfwRUuG3hTNxDMmdSsITVba5ZEVRzVKrni+yzFKcwiWZBsINVWt03rxA9GRSoOwZIz1UPhtVhe5JBlNfQJPaIMDwc1jkYSqJo36rSiaFTvGbkM370Oy8z0QGtSliZBLUT2SGg7TRMHY4QVfI5BicgWYme24bQ4L9BEQblPlxUclzEn3qDhUg+RuFKAlURwi/iCt/ibjsFmU3ZTegeo9GgZ0LJoaRkfjFSwD1uQUWYdroNJpBHGA0Y0TyFt0Q+o7yPjChWiKCLz2IIshpoB0W25tQgQStI327X1x1aMfCZpOMYWhZerqtVuk5pf74+t07OTZ5eXL15dx8XVZS7PBYVIkaSQ3WCizdJOxClykla8S7lk0n0BLlZkumF+kGOaaVFAz4T7PA27Ux+I4VagS8DCTfB+IT8rneJVCGEYBpoJYRhdrs9MNzDUtbb0EIWXlqJjMmpKoZlyTJ0CvSUH0uamfUG0pNYyXpXhrCu9/sCy7HK1S0Holl52a7vKA+q3KsORFMEB4UiZIBgfcpP5YGPKK1JzUlwFOhLP+d8hr1uipQjTTiVcBmewhm9E9+xME/AB602FFRSq4bZ3nBPTa3eiGuOuwfpOkpiDv98QquZB5nqzkz5CPIuXhoR6SfOL6L6poE7tlNnTT81OC3lYadfwq1RVNBkQsX9apiXpv5AvyGoUz6pkjUgvAS14tVQqNRL6Ix1ZCmY5QEX6i6CYkI/FvmEf8hsFiYp/hWtFwcWtxfjjTlga4CCHgD4Khb4PBUJN44vjkwUj7aQXjDWCQoTyHyWVZoq4pvokDC9XQlRiqlYbvAhDQWEmZaBmyjXVR9QUtybgkaKJqjYd3kt0IdoEOMmZ1ypSHCMVcofFbHp1veLZxgt1W0SLatNssWH3MmaYmVgxJibhw/tAS/0wVlNaUabmWDRFVHRsHWREHFI6Wd1lLbPQIBO950On3mGwaMn5gjamUCJdsBtyuJUiCvnjhMoSepUf0LkXkUIkDi0Ss7t0IBBaUgjTgqdcK8nOx2GCODkbVUkc9ZLXms/ncIMO/h6lI7FcIMDz2dRqmx7/SMnIlk02GMj7/6/JU9EmgLUhhV65icTTh0Wy8ZoayLpY6P0NILAZLgMmfwVo1VRr8CTibBE6GA/czRE9LTNjERZk8hGhBNAEBRZSqmUlD6NNEhtQwTB8H62GWlHUSeTChhEikp9OimwPUs1hYKwLpudH39pwgZQYKHoBFNyvFFsQn2h9zmmcBu+hKdWmAUb8ZpTKt+aSL/3EK7hXR6UhF8A9nFHG4VQSzzoIfSlIgE54jXhRcWnKlWQ92szFrozldG1Rt27xERSnm2hZb4Nto0AEl9GXtD4FbDy+xCbd8aRLsITXxWPJlJoKSUxHwkYAEUePv8aqynU2m7vFZPL6anU351IEOenOtRgQQtXjXJg3YsV79Jf21WShol9HQVxT8+Cg/OaoQgyCpXu4v8Inbbg18r5fJeLE1DRcsCltpcVmpblZreeLhaUz3ED9uG9YGb/bRPVoGOnOHza4jE6ztICvQ1rXFatokaOIi5SJ0DjlDzQztlW2cbnKfKx8W3RI6YS8cFSinsyZECj3s3JMGEDyuN/S2YYc5KO4PvVnRuGizooJjQn2nuCnQZf7prwVT1iWM0+qMp+q6oRCbbggak8DmkIEaOY2QGxkLZpOzCQRE6K7N6OnNYvHUtZ0fJT6OfkcbKba+ZXAHhLFANl1kSIFKAEsf+7xQXiMUZx9DyNfhrsyGJJCIRIxM6DSXfAc36XekEwU3qhRlP/OwCk2/6OUGeiLbGdWsAW1mTmiGGcqsZjHYqez2Ic1KGOcbsvUUAn4aLHEOGmpgKMwNW90VZiJDFG6+g0dfFzayQ2BYCwSKx3/E0tcxXOQBKHeEIs+2YrPKjWKnL4zd3mGqH4cLv3E4KQYMRM3cCncSvVku1zvptfTN9er2VKTLtdXOk/skKEYSaqplJWFJenUl0F6YsUQ0nob3nAUkM9M0cFkI2HREYf9SvouIawZsJrBPtLZJZMeKN7KfD6l/qkWXyZX40Y01VdxcdKab4wXHtUw4UCgnFG43l/floiMj19sUOCoV+CNP0kBZAIqQu7lqQhTEoEKSIsuwT1XqB/E2Iy91dNcbT+jRRGD45aeitKKosoPF90YQhx/uKGoG5BFExfjCFT+6NpVGpCODOfocnoBDhCz0Sl0jBpsd9pRaBYHLdFHC5JwKkQpIlUdfQafGQCtUNl3+4x+IItJBHRntV24hFICkKSJIIe5QlwSiP350YiPzNTADTekLHLFAXNfdL4lCPUt6ST/Ot12AYcwd8tHYq/QWjOKUjOn2K9UQ2knNwQPgSl+m5zXVGtZAHFV3BV5D2gzoki/C6M6Ivw0P/viAhPJN5RBDEq4HNKabyQfUKi0KIZ8VxbCEJaDG62aOVrej6fqtTEg1FptlWHhdvRgAgkjINGaTbRgSLpTdVPSIASIUaPUd5Ob9WQ8n4wPW8u94VXGmlEUhPpt7RIXAqt7DICoGFoQaSlqZx7qcdaKWrJEhC5GYAApUmBzojyNIYzNrLShBx9ilnVbyZqZQuvkHFCgUpISsZJBFoDd636AybexeEGR0n2TyZfahxyX1iWt4MJrn99TtJAVMaA+IWDQ6R/pS5BLPpWmmWISU7l1s0QpzKFCAG8lauLRkjskCBs5lHQ/UU3Jzb4h6BZZf2NKQyrgNy896KLQztsQ35jwPnzG8GT5A83MhS5Bj+TRDynqA6iUhdzbfA2AbEmtM2EorknyFTAdVJgmD62rEBDDUVz2KgrG+8BdB+BeiBwH1E+GgQHhgHf+UQ1xbVGhSC4ImoAeIb5MwohrAlOsMk5sCCbYYo0GuoXw+VVTQBva4Ks9U2yROhHeYNgrVys1GSgUVwekgsoYzJCUCGJphkL+DdI3AKD5cg2X2mxyWRmsX0X/uZjyzgRLA9HNB/bT7YZUlDrPR4Et1cCnCcXcSQVipD7ZIOYODcv10QFcEyG9q1RPtnYTji90Ba9+Ik0hVjjhNY+WZjHC4I/ToEhMvJjle/Kb1Q1l9HGs7S5kIvSPLMk2i9/k8UAnqsP0SuBuDBbiEihKVrBDspVRlwZcuI9oBp8xeGt8UlvGwf/MfHUW8+Sf1/cwj4hE1/iIXqgJo7mF0bekEuOLC5uWKIFMqdfrSUSUmDZSuFN7Fj2V7EZc97p6tsNsNu2fnvDYGwrd3Ohr4mbCxmSg3AwWIDgAFvxDqibFn3QEzhg5PrkUoPE1qOdpMVsW4cwMyuokB8Xc7jXMhFP0m+GkwUw8S7/hXvhQqbZjJaHVdXS2TjRjyolxLQ12WtEF3LUEW9jEPEZylK9k4NH6cRj1l5KkUDmxgbQPNrpPWZhp0SKstvG0OAQhrPYzN5NwY2CSoIWRA7pEu4I4H2dUhg0TuTz6Kb9DATeiUC7OZQX0QXnkMCRKiGd6sZaGl+lHVUR1ugBK0h50aSsXGmmgoKMoN7MnOOAe2sT3C+9pKtORSMvOOuGboYFY8rEYgUj3UAktERHoMihi4yfbHeujw/q4mFgbW8/mGV1Ib+B+tGQNzbpNpSxBJgGdIISTiZjHkm4/CDdJr4Eid1F12uYg7FRPcLolgwgeFQbK7IMO8TfDSOEnlaplNxNF7EuPSGBwXkR7+CRzDzXyVSh74MpX6SkzjkcfkJAQ+6GTE5fJ3diyE1JkdqE8/8IafBgT7iGhKj+LANEPSL472DRjLlM74ay4Kg+hYoGxq0Z6gDTRqIkiIgTmRvCiqvEIJwrJAzXaN2MPeTNsL5gBN2qnCEcxHRZCqMxiwiiPKBFQC1/NKSbHEJEtdS+Yy5VPGU/kks7Um3FEZlKSxGbKBhotYhaNtN3HJkQY4tPrvegFnccpzWgyrozJK/8idrGhbI2245THRMW/YF6xB0DxKTkus/VhZCeOa0id7ARqcEhiOoTx0icGFbOFIMnBZ5KcyagnbaJm4WSiqwS1rGg0SCiMVN4mT1NEoizqFNkJv0NHt6NJYBDBC8GpEjFNiFvkwVVeRJsk5U81ZI3PEj9+K97XAGChZbFIEtbp0diTRgwpQnyEbSlFtAz96vlmvQEiqKQeIsR6dZX4QRPFFTeCUJQmp/uNoayjmGf8Y3t7kU6ijcrYqdUMjWKttpb5sw6gz3uZMggmPxxFl6L1Td+os7UqltUYTT1LhOGXGoe4LUXvVI4rpzLEz6a8otS0ocdkP+q1nhAI8477UZ+8hK1aYa18ZRncupgSCUs2ABDdxvIxkpVK2164Sn29tDV+bRsc3dk/f1Dr2GzTEhDV+wOMThAc3KBFBlbUoQ64aaxqciHUj0kaRuiaaNrUw7XsFqDRitaHtVBbTNxW1ZrWShUNCtC7Bsz7krJoJWUESVriiaG069ymrfhq4XZApg9oTjWET1CJy6ZTideWiKJoXFoyCVZhvHrMrLMgJFpHlpgm7nUxEd56bcj+D8ZzQAESlQjAMKgZC37cIbUAMB39pkOsgirL5VEoZDLDM2+6UE9xdbI0WOBZxDN0KMSL/dcL3MMf/x9LTSHwZQNQQTM+8VZXPotOoF+CtsyS4HmbIDpiTHTzyg/6RK8lW9KG0lJsACJH22rbvW4MZVXhVgIJf1Jqy30IjQo8wRzmvNvvh9X1cT6ZrfYyMMxmQX/mRTZSgqM7qmWbRRuoswLuHkYAkswUrLKdlDxkMjQdVchSIoVspGlIr/rPVyGF4bPfeiYaKbJgRsza+Mwe9l1QknK4kCsJICCXzGbGHvBHj6BKO6s7tcXa2m2S9vfLhrbXqxzACOZG7QPqKvxcS3SWAiqALIqvOEYJnwghtdFeWc2sHRrDPrJ22t1ay77fgwo04NjN54lCA4nCgIAT/1Id7b2QxvusA8i9kTg2gRm6d8Jo98LbyHlBA78sXgcqheKpf0phSplwfErUSqY8cZ40MogkWRujXfQcnRFjp6kobUTL2o8PtEfEsAYQfKM1SSSN6bVkjF1DWQRK3seFdmMwFykKSwrIYEfJN8+YoVWMW4AePnhlBMZW9I+R0zdGpL5KIjY5bG3p1v+hDp0kLesgAZ5bUn5FDgtsCqoBLvoO7wAjzDWgok8iBMaHmQgIBBSDf4nqePBQFBWM/KihCeRFcAY+DKHO3Wwi+RYcM0uNW5n2ecrki4SARoLv0DMIIv0AlKSkW0PJrBY9GvVO7m7n0zGozG7HoVLgB3+xhdFG5p6skdds/bbd5xVzHQixWRWO6KvIZJJ4aEbF6ABlNBVKA3HytpJUujRKGap8ywyaXGFDhl5YjFB6x+zCuKJe4kMnmg67Q+t4SoSqVHBE/kuqGtUBtmonySY73oOpIC8+pLw8xMUyKSRGVGAyOhq/2W51h+2yHJHTJoA47FytImitDl0m78R5Z9PvjZGRmjLAkepUCphSGB8hjbK1QpPJYUe6KK6e/pP5wetg0gSQ0i0kPskp2Arfs4yQC5A00MzlaYfPE3/djMtrvMf8WPNoVr5BNHd0bkREBGVwFjLZes1ykBIJMVCFbZosTE0v0IYCujUKTJU6jP8R8+DbTCcXkO5MJIKEk/6kBQQPMO7FoiA26bGsHUST+CLZwMTKcckxLIE10gd2fHD0TUt6rTXttyLKbA0qGT4KFCoWSYnNdwc7IwNNW0fR4BmbiR+Yihgx/bCUvaubkn9UiJVdfy4pHMnk3AXxmU58NIBxronFn10zaVO+T9ZAZD3ig1of2a/qN1ezxWpfb81uxkAZReEnUlpphuPpOMxn6tvUuo3k6oiin1Un0gm4AEyGjup6dGpBEj5mYsRRkvgWpzSCGqEKCIMddIuQc95CdR+5PC/KtBlXELOYi9MGG7gQ13aUJib7HTwVf2YyX8mdWti6bwSkzDg+UiGKOSC1dKd2czSP7oreUgUfQm6X2/ncKoAhxrIguOuxr1bvXTzYVhwEkRxVBh2zGNUMnfgZD8xogxnKMv4CBRH669Ts8mnR/VGcug/y4nuxofHXsNyUTZ3/Y1SUUt2xEXPjCXvcrAnwKuoHxNJfGI8Nms8bYK9zeLLBOWU5vN79xk6bORr0esNWp43BpoTUOk2ipXA03PAiq6cZVaF5QWlYQi2lOhL5SIseowNT2ZPoxUjQhdBmFt4WiQ00faT7qKdMKOca+LTwQb/BeyxPzI9rM40SfkSVFa/FpcBqMOhbvB2yF28sOyN4AjxrmQrBlUFl46I1mWRxIq3F9zAKBGTe7zMKZmYUcXYyCdambE6KEGdIFKRVMqgxB92ECfz4Zr1PAMY3u9kUtGUdLIiVuQeOmYsgB/xkQYpbU20pLcG7uKNMEhnIQTZZPc0uxCLt0p1BejBbFnYUfkVwkCZ5RgVnJcuPj+nGD1UScQ3y7hVUOoYTSxwYyJJZGM6OD2f2oAD2k2spJbLkJ5omk06UhtrAwzWKOxqSJxjzbYQP2QlbiqITjtNZdj8jVBTQbte33cYLfbUTwajA494DNdQfN3NGJcYLJyIBIUpyLBgU4xgjHOpSxvnPbFykXaMmJ0YR3us9KMxIS/kkPDu7Yr1z3lhOO3EDFzGib1UYfgCAg8OqhUCGxz3TvPf6DBZ9EQ1nxGF2jJmmucfL9VKvZtvpN+l12/MxwJ+MKUgFprQt2Ra9HOQx63EsdVNA+436jEnP7Bgio7cui+z3qRvpYYNKSXvgDgVlsSfIjs0IF1yeUWNHwowMN9Pwh6cUn4UKiHY3OiQDSiOiBHQftzYwN6m4whBcKJuvUgBClSJPFKnsMxOXrE70aCYRvmcGBD6KVIaglXa/GZBJ0VMJ0pnEIKuSPauWaak80+x0uyPrZYvbxX7f7fTHb+7CtVg00htrIzAK2LVicNb1B/KDduJytFhha/bRtaFVSJgVBpcn3KKtja3RNWcEZG5C/7hAZhfow6s78n/GnlRpzKX9Ih2DZ8Az0pAOdYIi4k+mBDbbtapjhKPC4g+HsJYgCgXylnLkYxqRU+pyEowWMnb+QowJq7GOY1lbbVYywaUwPXIRVaXawamEm3VXNU8ZV9c6025iBePBBx/Ey0/kZoAdUWZYVJL5AbS38J73ssGpN4/rn2nDIg1drYfcwh0VEE5WRCmgbzhoKessQaEPYkkx3QR0QVQIgYnnx39quIsghRZR89Ha9wos5xfF72ewVsvJ5JaywvvRyYlTKGQybLf22/WGDQx6ycpVYv9kkoIVmLB3KFZPOZR8633JWjrnuuo8P9FKxpYMq/HEFIBhUxV0Irh74hIgGNUK7yuccv035UYNqcbo7lKbGc+AP5ocfHJZUQtmG2xlYc9/+g3uRfNhbUapvlOPziJEUVeUwL22V66WYfjIt2aF+wG732F1YJhvjT20CtkgUXHCxjBcxm+mFePTMKF97G62xm+W47s1+dweFuOZNiNT2kOBe1dec+ISW0RQVSoForUsUuQcsQ+GkLggiiac8Qf2eD3mF4XJB7YDAcFCMvvTQnej4kEEPlEY/X7v0cXAXkcuGJwYXlQFZUXWQ2ihWc3qAgGIAcY7X/oTb4QaKQNFRz8hRlrnLelamiJ6kzDSp0ASmaxYOFfzU2tVuwXndA7COgBFoE9dDrq9ZNgabccBbdaTVrf17oe/szl7LxagUDroNK+MkMiGUuJjQ00OFZ8pA6oBo7zwm5pCyXskGYrphrJ+osJp38I66SzMMMY4ioZnpA6nKGrb1IMPn5MBc0hBeRS+OQm1oyLIniLHzWw2Bhhuz2h01un1C56s56xaKXFV+17sYEkDoxLGxomJ+oWPDCW9syd+46uUaNBIUUplmJrRuVCeyXjjnPsAo32Q9em8og1ijs3GfdykxHmUDUVYTGUavWdNOTcgOp4fqPw8etKvGF/fo1joKREok+tzQ0hGwFhir0rOPlczX6gVqmYmwUnsYkF2QX6MmC8Jp/9ySA5XMcmrTEMvXrf7PTCxEUAm2a7Y9nJcvb2c3o2H3f7t1Z2zpWLeoSfeBZ6X+8gpjSaW8zleYZl8LpnQm7Yjozv48io0uAcEprnpsJPwk0KdlgMEEGzYaTlmwpEnRVzdynGKqn/26tZck66jsyROBbSUCO+FJBYvM0bOlpeYoZhvN8YABonR4yEIzsSokoxwyYeOfIuqMbRsyfcN0NnkKOPfdIhWi1jqMhY+tkLBVt+eCiTlPPRPBcvHeu/x9348eOc7Y2V1BklUGfDkKWKvrWGpNIT+KC1ZzpjkTMcmhpwoqSvqh5bFLpG5/lsqzlOFh6N+jAdDTCaZVOkOaj6Bfilg1IxZxzQWLpu3duI4prYZWcN5A/VfCZH3Y/7rcef814uHD8X0rg9RQEyKyfxy2FMUC5joVmNBhANhgh8dWNrjm8SKURjhH6LEBBKTxK8FBuQwFIWg+xEZOsXpu3t+ZyhJzEdz5yfKCzmkcYuIR0zILyMXBGfgmEMM3FyICeUo6V2x1wEc8sXuJWJ0lzjGX1elkVjbVpuySqrH3EwnAEmwq1Ufs8CZQToSPGQhttCTfCU3Q5V0YpBFshVJUlwfbm83m5nvNOVMWYSSrCvG7V5qohL0ybG4p4u0RRJw1ZbyUkaKSyEJmvI9SDA3jGHDdJYV4koXE5o1Z0AxdRiiBvLh2SkVN544Ym6/SMUbTcM+G2PyASEJ+yY7kD3vhVrJ8HgRbUmphgImK+BmGxP+5nXAHcDQ0UWzJQVC48dYkZrgxzCclAMDFPh6iSyiWt+amdvQBK/dY4LOxmp1u7bmOlr3rQ9/3Hrw3iI2wyy6nb2DxDgVhCW2I0jQbcx4/HsVjklEe9NqOzIa62ODIq1sXNQbDMcPKQMjh/JCFL95JXvAROJ6VtbQsaguXzE1LibPkVEiEWRBoejHnJM/40gxkNPxdDFfDIbd84ePHGMXMMfFAoW43GARjznJALG/VtMUZBq2Qfo2bRojAPsTu5JBstdeJ+QNeKKrjMtN0T3hBNHM5LOqFXk2FZ9HulxutKmOKlIoYnUxikXzRM2HLOlXG7nOqDSKAgh5L1kGVqKaLBslmPZXD+4WucQFJZUmgLZiNIIWS+fWImygY/JituRDw3HNRtgSAhqbNwZQt9ciCUVOdlms6S7vKpPb2d1tazBY7DazybSdHbRoARiBFI7aaFjt9rKWq2u9RSnbqL2vrCX/yyKuSWexicEhGM5MoFjjYPc7nUG3eT1dUvcxEZTEuv7i5RsXhWzownnHAP1FWiPuOk07aF3mVbqrSPcLCPFNuwjG/rkXMwt9YtkwKJ4FxpXQKGxHjNhJY83a6FpVbKq2mjQxpWSflZnYBd/rOh5CRJxlgUQS0j29vp3tcibf/t0/bJw8WWyPw/5AQNkYnvVWS95nSfEm61ICOHMyOUQiExkmnFIu4i0aOh4LqLHpBhomUdsZq9GFxIBO/ZNpfkfcvmSm2mSgtndWa6aXbF3crkAw8QwU0XaaTSYIUDTdmE5n8+lEZuPk/LzbG/Fjmp1kIXm3xZzQO8IalkpGqHQJf8F+/IYYvsLg2MsC91aT9ZC7pM+ibFE2mTauEVLyiwwqkUE+8ieoDUg4Em3pyIJBcS5g2FzWkJSMOrvf8xEd5vp0bMlGwyye2WhQMJHwC0AN3ddhezpPVGDs0WhkjCTL3tjyxh32U3wbhS66LOkvMwu8DaaAIsAo+DVy8wzQOKUghj8RGB1J9nCdWvXVor2errne+4rQ9s1XXzUo3tzUaPTaqxmzEIVor7ckQHx945F9T0pAMSU1HVE0DENl9MuhDFFPTUltTI5OrNnJ7jg6Tun6wAiToKQvybGZZGDZSqY/9k38iQ7+0O9GGKWeHyQ2g5xbkwARScIF1IIJXKN1fEus8eheqWSWUU8hXn6UL5SKtU5bdTOqakrLOcVdxG9qQRIWJN0jGdM7GbSHQ37F0w8+rJ0/mazqg+EIQ3lQubPZbyX6YAMCmGQtqVaKJEOC9fSMEnGguR+AZDZ+UN5mOzETVectZjLhrqHgbdoCJ6GRDnBf3bQVOwnRTLqkvzN5A1YTHVOVBCkOxjWMu1yxYe/m8kovjrnv9YcMXfrN8fNNDltquex1UOTjNN+sxlBhqgSC8OhgvdEPNExc/0AqP95CJ66DcL2SkxxLdODq+FyFG8CKB66l2l2d7SZUVrZ3hbRA7CAgWDxIVeM2xyY24F4bRWaC7aTe0xtbo8kCdPyLFi0WD0/TFTAUYGMn0xwDk4xVqS0jw3w/w7dUGV0XoMCiM+9zyk3sEqWa0i+fRhmYErGiXzLG45Yvar8RxrUWMyf/XL65ag2Gy/Ht8W5i4qiW8FyPrnZusWR/yEVusuM5Kc8oBFvMbU+FMkQX7LIEMViyqY6Rxf7pYoHAN9NlhMTGrvU4+oo1zqZEJIk6M4uIo3Qn/Rn/IR2Wcrmi3Xxv5hR43XZcd5E4malQC0+TIQz7jIQMxGizfgamPSovw6rWVny5FHiHxJZP6NN4hq5k/RQ/E+BW08HotF68N2an2xqdD4cPHzaHD+j+TW00vDhRFiirknhvOVmiG2xtZLrVHqZcJzsb9WZw+JU8tFCMZ6wbo1Aieq8ekMaIhAT8JGuQna4dCAYaXKQUsN5ttZfzbJn1vIZ2y+pgTtvL2aRCB3ucWSu8CAMoJmcUQ1VM+Go6m17fbhfz0cXZw7cfN/o9DE67tIUbADNLhlEV0BH/l5DxDYLsEIuDoXc0xwBjiyaA2HjvQXbMUew/BmRRHX25RxEhP9FOQQSZNMkoIrgnkFFpyTpTJtrUUZgCfGFzLGN4Egb55157gOLgFRfWW6zOFAmt9XGllfFBpD4K0fSG2/oPAew0IUdxIOIBtrt8M2liKuT+VMmYEQMrcSkxIkGWpRJnFV6ki9ha46k2V/N5bzW/vXyzXKw7dM7d3WGx3PpcVcN2ZehBmH1npgtmRAnegCzakrCaVoKxbPkMnbJoR/s4WOeomOzgUB1QLaomwVsepIBsCIXIMUpR16xa7Lh/2fSI9Fla4AXEz9Omb/ymW6Sc6Sj/FbcoUMBM4h/RiVdzn0Yr1f0xyJm/eUZ2/B9shhzoBnsqGrTth5FxIir0BymimX6/PRievv2kN1TSXW8Ohk6CR+zZdN7u9lMYyrxtJsudRWSL5s7LDcagnVaG8/DlftQRUH+RIisXWzkZ5KaWjDUpgegVEsgDsxKpQsP+MuEhkWl0FSPFUKvaUGa2EQo4yQhRkmiL4TZtCsiklLIkRJsJ1i4vF9c3g2Gvd9LvnZ0YGCEE3gwJMiOU+YcTOE5Wi/yIGWDD/FknSoeQ3bsipdALv2KNXJA7tRTG8rstklqFQVuKLqIBEiFz6Qo+4Cl/iIrxZS0+q6sGwaoHO8TENO3Ywa1QwHiSAInqiG7UbGBRdL5WIoWYT4bc6BvqNpwvSh5WcNPs4uFGKopTIMKIU+PAk9SxJrdJGDTE446GJgH+ei21ajgp4BUDD60wVZeTzeTN7G52Ouid7ie3y8W2XnfmlItcaojQHyIQ+1jFVGVpychMjeHOyWQ6OSi6Jk4+YxvUfToCOuubxQkP8Ql8RD+qpJ4jG0wYwSI/EtARSB5gdJJmFbSV6gbYKG5hNHm8HdPLdleeeTQFtQYYbi2yIQmr/ZCFNo1oa1+9U4Jd6sfxjbaFMHVWUbINS+GDcRQDko9N1cHP/Yvh+aPvd0dn9Z6s7r48FsGxuJ3taqEoCN1m03W/120sp7N+baBw02z6JyfKMMhn085dlsTKeFJXslERuwyQ1MTE54Qf4kNNBkyRftjUQLiUqDiVm5WlY6k3TFEsvKuIQ5LoScWlWDruHbCFdwG3FMdyPrt9c728vsVtq+JsWGvQt5qPR9IMSEvlJCsCcQX9GQ9KB6Uwh0rQX8p+IhOMSTSrwbsG1e5VCEFPhFAsNUQTXmKhcEQjbklLIbsBhd6yHK6MEvMlkfYVUQJMEhCUFBZSe2XmfpmWeUUToEpsThHwxCQZpr/5iugiRZgcCIZ6Pkrn9Ag7E6/RmOkLzRIxzoFSLj2aMXymupA8UB/3MzdSCIoHmmM/NvNZr9KujC9nl9daOjvvrZ69vJmspjsJ5RxnGx0mSRJXx8Q04b4iPRmMsbD/ZUuoA+Vq9ZW58gekF+sNBTSmnDVjpA43TTEGFWURsFQiaM2HSB/XLXr8nkJMqUKWSExkm7D5mILle6R6kwcSegfVzA6chbZFISE7jVCIXIaZtER4nQNR8oQXLoMfDjywRBORjLhsEbgqVf7B7/+g7kE4+/ZqNwbJ0/N36/ONw0hubyYOY2v3+/bISIse66vGxvGplTkKUA3VLm+F2Lbkg8l63Desd3iWx9JQ/M5dylJC0JYaa3mbHIHYLiSw6IuDbuALtbFzcjdxqzPeUUwBErC0HEaXIlHn7NpFYCWLWBW4+XWobtbzF198Or++PS43/VFfy3J5MEizWTYv+CRjQjHUhE4iTYPF6lrC3e1XOR+eEcHFGN9iy3MVjyX6GG+K8krOJ4IHc1lzEfaJ5/AvZ9r5BPOizgml6LaZcsiICnUrOUY05BqLYUFukZZ2oMFn8QDixRY5y6pZsWwJ7zzKJzwzPyuJsZHuCLuB2s0IZmz6ivjyqCkGgCyYQiwj1H/ELaaIHYjoiLlbEQ+hG5bHASjhhHCInnD7fj158Wr35We76Ywvvbi7vh4v77jnpTwOAm1Wj0+OLhEodLSyqx3dJGfXlT9HahmdnE9j6ZG41FThUGR6t78M4AuMQ2QKIXJXoEynIAUqIAF6GSfg0uvmikGF3CGKubDmqUhImjBKBrUT7BYGFW2PFm4qLpV0WQ5RZvwCKlKH/RwWmQnzSPUz4DMj4XaqAlwZG0oznz8Yvf925+KJWlKHbipo2tZGL19fd1oDp6Wu19PpYjrY71oDLkDFk5IaOWqaf+CU0OXCBof+6ag5aBk+WGjcnPgVnW4vyrUUxCutJgl4A2XtQTeSF94WomISz46M7nYOwbIALY2z3W3s0NnIP9J7IJudpWVBxvew7DP+5277+ssv33z+udOuO52uzCx6KV0hKhwy4JCvjRODhp48IPWBIVFnATSe4ENImeSplrLQxq0CYleBC6QCaMmfikOQMqbfQGNK8ioQ1FgmFF0iLx6HJ6YtjoJ5kwTBdNnfpmMpOXasaPeiwZE9oZFq+zAPKsEijYZ00ZQoFU5r1XWJuGNOjSnyYx+9kwlkjLO24pPkSai0OIoOX+F68NBS6UkIjRHBI5C5ESLgJyuiBm8YghRd67+nKu64v1ssOzXez+31fLOMhMJ6NKS5c0eDPbPTokEacE7cqI662bcOSksezKCn0qi+WFUXHg8WuaV8MzDVJnEeI8RgGR2p+2zQzYCwA9nIlxBIbFQsME+H/hAUmIEOCWq9JxnSrJazz+PuRMx3DpuIOx0ZT8gdvy790hy0QtxLGPFt7Dkg5RMxNL2RjaM530BJEvtQq7c9JPD86Tutk+FsvvIQAI8DpFt2yyagGgGU8+7k62ggPeXABx5NE17bDhfYHRd4NzUTSeDu2UM+pU7DtrAsGaGsdlBUx4ZdOW3Pr5EXKhELCAR/xM/f1A0AErnlYcOdsSaasXBLtUb7Rj1IKInWTN/mLOzb3nz97PKjj6uesySrVZEbWNnBRzAnd3f9i1S/hM+o7nYYiAMU9OIpscNdfHRNlvAMj2PmC1q2ZBXjh8RSFhOfkMY+SIKZfGWUK2H0f8mdq78MYGMfopthK8IAZKy/S8o/WXiywR2iX8mXFLj2de6lHgJHdxeVphEkMLnSicvxMpYkuGP5Sz4H5w07yDLmcJ9ODY1MMxFXWnRgqyf+tAh2s9KudZx6QUcxgvnOBQAB+JRiNCUOe8rddj2+HbcRZrcUBJcOICMRXeBe4n40i1YmrYQKsqyLNuqjUf9mMZdGyeqtpwcwlcQmPYFK4g3X64Lo2mCXI9ELRVPYhwS+iGrBAn8zVUbKvSGMjlgKdNVPoQFpX1poK7dE4ONQuyw9xMTTEZr2UT4sxjUTNd37iyx15sEf+G/4otB8rmXmU+nHyenwwYMnTx8fmruXb6YejCRj1Bo8wOT5bCqdyKo3a93jptnuDaq9vkls51MLS4d6W3zn3W43lcnan7Zby+pNfHyRsRi0bE+OL6rg1icGlCOI8+AOghSyIDAtC3w2AYycOpwD1RAZ6eQOMZaNkgfCsvjfKk/qnXKHycZRuPrqq9c//9n28rbST0UXF02Tu8NgNptvFpvzx/J39wwo2AnHeIfUf4sYUJMsTCQv+dnkTxA6cUIhoiEFS8bob/EzBArIimSkJbST0o5miudjNJHhYjT4d0S0ZH7JEQBxNDkP+BKLHG+VFRZWaoB9jGEMhN1iRonRIi/3zcJ6WIxEMnRiuKQXsmpOtTPXXqyJU0FJyiTu9x9bGTBFWTKLPPG1yFtxeCxK2MyUQAjrtFAgFiBEksy5dVzNttfXDkA2aI/BupupkQ6sbGYwTrtIXGqAphFQ+S3UG57vnZm2mtzM5vVhz/MBaAQxh9E7QM0sErLgsqtzxAiwIku10+vOc6Ss6UIwHR+KUvk+MO9sKeecKKgL8qVJfBqhDejrtrl4VG61R7lgJevpY1SPRi5CJV2RzHPCKbJEmPSdqIh00V45j5FzggsCkxQRBQdxGfoZ3HDYOuuveXCMEiHY8Z22dr3sN9bX41AoD2l0B7vDwuGoD05GPB/rg6IHe9FWu3p8d5rsuNzNXt5Umneb8bT/8OFysOiNhkrQ4IAcNnu9Vl39k+io6uyGLJ6VoycikTwVoksVRibYlby34aqtKKvSAYGAv9ZZ2YMTI5Ss73axuPv0sy//9b+Zv37Jr63tBuvFArfMOvuqjrXp3XRgCfN0lMLSgFeDXJ3YO8POeLJRIT4DofRtUBjtzxZb1EjtRjwkCqxo6ACUVo6ZLaQnkVnRyyKlAwkQGoy1ybLmgyxpwzQA3DcZUwDbfuUFjRGLavEnV1MNGU4suK6ytuVSF+ezoiFM3wtVrODBhknIl8YiMLnd+FmnxKCiLOXAHDZQy9qLw+1NxIApV6JiXmRcxBSzRDaKnINGutLOcjK+vgY3jSzXxMQ9SlESH1stiioq2jRxeuTTf0404uWvHfUGNdXpKirNaCS8zCsBSWiqbZ+2Y90JMz7uBr36PgeDWh/g6gftXaQzsaThUqDPXeUS6IXOJbfIRlqQFiiiLzkirqTYoCBOSIG579GINuIXJSIC3+gbD7eTXpCWTXYbPYUwyKUqlnRBerPbGI56Dx94AsiTd987PT+TFl9M7wZnnW29s1+seVur5a7Zoe8N5MgOWJugC7IWK0bG5gcfvHP9xVeOBMA8LVISSlM5YRO7j21xfDBCDTIgH9DynAsBAIvby+lXeS5hlXqOEReNAQsmh+94Ex1dXF5z7DSxAikJTdO6Vs0Ka30r3lgsp8+fffLnfz578TU7kDNULBDINdN8EhqrJWtDv08nM9EZHIT2KEUhxdkNkFAk6pTomQoSGwmaxYwGyU6aBq+4qaW01LD4nkFqzAKOJhftPuqGWgI4Ci4i5TLGNiUJ6h6i9lSUpDu00YN4kSRTuAVwqBWBZ4Cti8W0ZCSdDiWdmMEYMDbuATdQcKkRTXiPjxwobRTfLTj+ZvnHTdGFuSOCQ4+VMxgNWLy+tuQfFYvc1UIZYmY7geEHtAoWuMfT22NW9XeL1coRPDRw284b0pBTVkMbQS7RYzSNX+852uXuypJAs9nOboRUq9y73rHWwIYQmaMqGEAJNZXDlF1BThi3qzCCv+vboczn4Rmq7lYxaaknu1ciY1Ei0Q6etJvY3SeQnZQGyyt7H/Mg1+YyCb/GWoM6Q54tRyvPuM7F6bNoCWcjxNE3vrLKbtlPNa7i+O5w9OTp0+99QIN3B6cTh6vX2sfaYjQcvPjqa2chVpq905PRsdlf2RhkU+6x5vGQh8ZWqYG8hHxoo/nkwfH5C+ftUlXA7xk7cStwodnaWjOvqcRsLhLPNofUctU6wKLSG8B+pUP1xMEgrMDuHjCNV0n5ym9xhwUO2YioOlrhdG+9FekpT61vN/PDajb9+vnzn/9sd3uT83GTZGM4hVyYsuqw5jSD3au79ZvXL3oPRqgQpaIzBXnsHm9WQWeOJZXMpKwgLUol7mR0rb92QrrKILIsU3QHgoeW28OGDNDdRLoYlUSWCQZiw+NEwTKxjePihYlnjYJHW7Anttbb3i6Q1BDQZWTJBa6ETvxMbR/9RF1rrATEpSVTjBmJA8EWxWEo/whe0rU8xkDPePUrHWwS7EgykBw40F8t+QJ1fmMe6p5mIQzqXG60Zp3Jqs1cT1azcb/ZWKgRdDAmy5WMgH+Ug061DaHxeig4Kknz3D3gDbZlUTzmMaNIqRqfAolX0oPYnPIwoz80ex2UXm6Wp8MelHa7DgRwQAlXAOXZQwjKyLIuEV8+PIjEl61/5liYIgVU8mmyGnlgLpr5HloogYSGXjC43Ge30ZZIh6zyKBQih8fUnf2fgNvXotJ69+TRuw/ff6cxOJ3OVw8eDYpQORCFOPdgrt3hHlnEEPxu+UczwtGpdPrdPDxWEdFmxWlU0NFonZ89/P53X/30F8jU6Pa1j4HYBYN5wMh45xix1knHCottWZ3haaPTozhw/Vjp1QgRRDYkQOSn4J2uCp9pJNke8oIL4jZLFX6YBFDjk+9VrL54/uzP/uz202eUVRRhdt+tKx2FFfapWTK2YIkhSriu+xePbi8vOYXd0zMoZFwBMJa55RYOLiplMTj2AMX9wqXorSReonECmVLjwNvRfXJ/kdgEjyjpbEHa+F59h0cx4iahlYQEsdXxj/zQcIGtiUWKmIvob3xOJiEOmRlgumFl1SY+A1FLgVPyDVmPoMmAKfpMY5FuKUb69N7UOGoobjyvN7FN1FAmwXTd11HHiJReaYG4DoqzvDA9w0x8j6K9w378xafDw/ru7u7meuIIaKkV6NcZXKWgK0s3HflvYJUJyohE5nGnU/Wu38VaKrnuEXKpIcv54+K9mE4d3CdH19tlLznyllUn+xYgUhZEsJFSiaI9LEvXO5KqwQCCBaVIVvrncwfhoWZ++dy3ZXgobvHVkiyTqzXfFgWR7eMJvp2DUvLvSSCiIPTgn8h+TVFWOp3R+ejBqYKnJHCtx60r68Wysp17JNp2ddvoD+qVRfxGDybbHk7OHtptZrqjk/5suaCoLA4LRs2vNnz3LZHQ69/82jYD0UM5mIojIPm/UiC0ufJ0EdFzZ+dolZN1q9v3SG2yv1kLP9qDkxGFlFSPtKmtbXgeohZto6x8v+93EUXJ4zoLQvWaw76Ps9ubT3+7u7o6cG8K8SjqZLqiNQTl0qIMXHlQzbatxtVYSRs4MrG+43tZmETl+BZkWbAQt5ARycHuOakzBXN4AqPZwheNEc0tetZMesGcuNy0DzPNl40eKg4cvGR9nOkITPMD9gISFSaRqCIcgOtYTEznnKNhzEc0thsieBGcSB1WacAtMErefFrSAtHFOqP6DZjCjYzJ3nVBJlPmCmkHr+36gX5D5f3DAsWcDkCWlNFPWcMvRme3bhxbvepxef1q2DnMr+9e3YyXc9uSaZHcEaGOIuJ8YlbfyVbtpkeFWdDIwcBkXQBsvLEmbSe9GgbPj5nKChghVD4co1avO0nWuPIYixzRE8MlZbZbbXscD1o5AZyuWHtNZq8m4dE3BEUJGSmVmlAhWoGy10oyskgclzJ8AlAoYaiLuxm/MrEUfeWppN0UiYdVldpyfbS2Qvh6Z2etodDUEtPs8cVwvXRYnkRnTRplvlrI8q9uF8daT/GzrL0MPNz1BkPDWC3yuKQIV44ItfOWgBtn4zD84L3F7e1CDgGuEB1xsukzMQfv3pwkUYzGMRQH3cGE5+n1+otmc3k7TSFuqwZ6jd7AtjeP+UJwXi+Xk2FQjw0C293MQMhJCp23Swcktk77h2dvqDQ6IpiJOkmpNOx4qrfiL/cKWxjirfM8eGyDQbdzJiA6ysJDV3RxsGRJTZoqEoek8ATwUWqQx03KgzaiczAxxT9ACKRG6rtAFDLSaZBO9kgun0BQkEjGR7QUoNHNRsj5SBKc7QcCo821BIBYGYMGEi8QxCi9/Iok+CkufbwcH7uYvtUgTGNnwbeYJisVkKAlUVoWxO8VIU2YiJI3qRlhYcJffdK7hCFgKlKa4AC5lquGOq755Ob61gZyMNV/gb9ZMdGMc8tslqul3yUPZT0sgabxxksAAbMBOJjm1qBdtIA6g46d1FkuCe+JQ+IvAxWkR1AiWaaauslhv2fbumlYxzYNhpUJKn5ofkWlx24GaUaGXj4NxEiBt/eFHlhH4MXEuYAY2Emb+cfRSAs5+8isMY1/xWJ3z3qjR33Rlh0Qe3Wv83VLkvi4X2yau0bv6y/euKU/BOLWanYtblnPZ9WTU7sXVtt1fVNj35gyFZrVjUyztJduWo0HP/id1z/7d5Z8HTvD5Q8Lw+SIKXkNSnzuB32tSq2dVrBG3eXNuDscdAb96XLR9XzjfnvqjPZeb3AyXNErYts8cbXV4YAcPbJ70Vqtb1+/0NzJk4e3X7ypzFewQyhcy4MErIbyIbs7PcqTyeOvMp4Osl7Mp9fXivZENJSYQ4YRFbbBEUetnvHKwhB4jAcZRcsFhhLKNpeojBVhoyV1yCnxilsUTQ17gVo0JcEpgI2TwGYQYH4cspewIikLB+ZAVPH/mWN7zCMYxV1MR9Er8YLuPbEEBziWMZi5z8gbkeSWxFWLB0IGYI3VMlpyTE03PDjCMR4Weuj+GB7dxyNAmRxhL99iTiwYwiSJxBMMh6wiYfBmNn1zs55XtpR8cK0r30Z0tJtHJ/Ek8vDRLAtJrmbemqPJPSirZyNB9biuoSrxKk6zdo9rz50W6mRpBVoyIa26z8ZzyFeVEWufChoeaCJ69pX+Jk7JLPidLH50KbE1YFSVZy8RFv1rSglRDEO7kcr7MjiuV57/G9CXCQRAfHjhpYUDDTIL5tW1vWu3vbsbn3fPD/OFSKTbUvWwm6+Od+vqbJlHjj361tP5zYtB84HxVw8b6vrNq1ejhxeORKyLaltd52VvpX8ts3R6J0JUJUn1zvTB7TuLr1/t55SIfjkj8smikMQuDFJUBYQtl0Jbew5QowqqfoHofMF4WiDbTvMQv0VrcvfylUXd/skoTwJTI1md44TczuzqZjO5yQpTpzs8P3lzfaNaCO2KokXMxED8k52nusUBW1fMx8aAbnt62PWH/f5oUHc2QK2z5hpFQIlMxCDpDkyIh0QNQQ0dhV85mDp6Rpu0Fu8hyjaKDCWRjE4N/BylnZx0PPyAkyxAMzXlhjijWfWKQYnWK1fBXs51LBeaXCAK60FcbrJDOgtvxZVJh+4JJnUUhemKIpaxQj6kzlSfxUJlYISB5nWRi90Zi5bzXxprxQjQlFFFOODAULNPee8JD73dsxf12fzFV6+WC/Mwhci/RvTFeTM6cMEvv2LUJGzLUH0OCJ1RR7hd5PNQt2mdM8BErviZUvUZgGCU/0WxK0GQvtZAtoRnrT8/UdL9uOm0eZkGdRS5cmx1WBnHFVE4XEmu0OzGQE2xBtaTSmLdzBtxDdyFIMlx64Let+RXAhUxFY+fqsYqnmRJNC/HEz5c6+x8edrsDwYyUzPn3BLYQ8fad3U3f/Leu6uZisBx+8mjk3ffffnVF+dvPZzdrNE/T9WgtQNwqLAL0mqnowM4fNKgh8Pg/Q/Xi3V3+2aRAJPqMh0u+TEmo6FOUNo4R3JW+DJJ70xoMxkuh42FSwmDW7sFRVGPw+iCxnw/Xu/GKqIJzIoYJd1mmWax9GjkWq1rKQ9pHE/qBI+wHETAkQpAV+sWTv+bJeU/rtbnK9XRD5en56OHDztdtfmEMzQznuiyJByDWgiN92HUbLpv0VX4Yf38YLEsWGfreITk2s3GGZeJlFDStFHstAnHgQqO2D0Nhyp5hycF6jQAD0A4C0f6jKoC2zhELojAFKc/XC8+bETCdXHJtEJ1M/TUMBPvSmzmK0MRxuu1CI3rUv5gXFDCH9K+XRsxI8wF0JeL4njFl2n26YLFfHL57NXHX6yWfOaooxgH/2lAI8np7vE06Z38aC9fRhglB/ZHCzRWLdkHlRDWpo7t6oKdMCNmRamlkdrZwkAxs6JFD5HgLCRPEaVMakV2yxX1suPtYgkeWC7QNN1ABoVD0J49wzxJpi09GWTUDlmCRJvJOBUIgneSSFE3OZnPKyQQxfiE6IXTyEk/ZP1ScnK9Ws8WTpBoHdsX3z8ZLyarY8PWsOXs7p1vfbBedrmTnH1O3ng86Tx5t3N6a4QP3n0qt9TsnMTQUQ5JkPbH45mDJhLmMHIySwqoH1drt7ufVn3jDO5kJFiqBOedlBFgvmGorgKdFOJoRoQtsEEK+9ftxvA4k3J6i/LT0CNPtZwveNoeC1IbnorERBidoNUN+8HJ2eT0TM0KGJO3uAzzRXYqUYcMH1nKsl9zcXcrCvOgG069WqbNfs0OIJ9Q2HVZ5kKgrBTGd09GP9EXkEcls1LwjT1cIwopvg7cFSVJINihOCM6l9iB+PgtsbKSDrG6eEWZZ0kt7hNldu8z6Y63EkiRjXgvFm6tpoVditI8TEkhgBkBYMGaMXgNCcDD0mFCtLJPdI0SElG6jfyKL1OYkmDQSNgpH5sRMSG66J7hxcA4EjgDt/bS4Bs+e/H8V38zv7sLTuOwZMbwB/q8uFimxJJJEFPMxuN9VEPyZQaTJ9W6pqu+kttN6xlyFhBtNFmvlpAeM6RRNJolrMpJmO6NpqCo2VvapATonOnE0NBSFqrCEOkdOc0g1wAiukhlwtows8XcUZlx9MkKcWaVs5lQJaVf8jwKdRSKKmyG/sw62ks+kdGDVOtPBskpu3v9fL2cDi4etUZn/e2q16hOb65SaUQ7NFrDR+8sq83pfN/qPp7cvD4ZvlVt9pUDNnvNuce5f3N8ifEaCBmgDM2Nr/7knaf7zfzf/VVHSTgPxNSNOYWTe7nTiAkac/88aJbYJOXBOFiEWSsBBUnJt+NGmiT854ECYdRW6ieOQtlax0Nc5jfjcbtrZa132u/d9Jo3V0tJGX/z6E+7bVgbmQFuZW11WJLPVFI2PeT89u7FF18apLMa5UylVoFckXe2iudcTssIkAyQcfqyU8QwQT6LU+EjwoF9iQSyWSeubgjLr8vu1XgFpECAkFgv+LlPU9y/yrHJ4IWTLi1ig2P8Wp9ZPuRWGyw6EaUo1sJC8Rxcq4ZKQBcqlR0ewQCqRC4ihUhUOiApeZuUelArLegbcgy7kOGm3M7mVqvZhJ5lNeKSU107m834iy+3b65Wk7u4b9EBlHT2lZMAtLdrkf+j7UyVDggzjdQADDS51Nu7hewAP9Ej0kMx5BLiNURZCXj4TVqLSBho7AaXWP4rdhpV6bLQmjcfxcBpxefqRoAdIURskpg/4QoxzhJysEDkRNjuRAaNgx7ThWikkxOQtdd4WkgbZ9hI4ocToa3GEye7yqoZpcypM5DtfHI75xksHpxbRm9dHe4O1fNjqzt6+N5ytW5mH/VSZDXqOSeD37NiiiwuUeWK6qi5i7ORATg6xSE/Jufh2iTnotvpvDefvv7ko7uJHUAytInXGH7jV3Msq6lYXVBIjsE5YTtrFHZ2UNios1ZFadJ5decEWjluzRfHRrfnnZy/xFXL2vjuzuktzlbyTBksUn27lwSSgV0t430rTgI2jkqnua9NJQj92JAv1F5PZ4JE8B2cn2KszleeconchpccXNyJaL8kC407ZjT8LoltFCeHoOF/3oFxBwYQWbI9FCSWxS8vKI9fpAFKLA5WlIBQI2pNyR2NWlRaYdN9hxR8Dk2hunAXsoEJLxnsgj39UzD3OIxgCA38B6WylQF0Sf7FJY2jZW2BaOkqbmKSXk466JYnpaqSbsoIGpKyytpwsdg9+2r24pPGfm2hRyYxs6nX+v0un80OmFT5Ai+MIkEB5P3sotGLQ8jI0ADMusoKDp/OitdBMctDF+tGxycKElfhd8wOQu/495HcWC309L9oPdKexI7vfYSwSXpLG5FjlIyfiKrJBBDLku9iyriLUO7QIloCP9xDUxCuSEtcD3dQLXoNs5JlYOFoW1WSyBYl4kYaTa+vr65uJ5XHb120znrb6t5RRFZoKpOJp38DR+vMisGJI5gEoDSHDTGcMU5+Tp7GTyzGecIVO45d9daqXht8+N395LpqOcGzZRP67qgdiTgpSJXRPrABVeqVpbdUwf8lPMYX5zjPoEQG6DN0qiGen3W/ivS/p2L2kjxXFQAX6KHrd95/582nnzEbgLc7Lm3BifMiUWl6SMSDqq4oGoDK+G+vXz5rDM4fUAAxzYMe7aPClhGgZQA1PjDYgjbppEQiIAktw/8gG9u43WIOHfgql0kDoiN8Qk9RUCxRUW3hH2zgu6Zyd66OvtcqzRWIB/vJYNg+wbMQ+4LlfZmG9XyOO9YzKViPiZEgf+JsBiZAQsb52vpMO1GVZQ80n7ewPOIWP4U2TR4pcKAk2QqgAUSeWf3N1df/7i+uL7+WgrRciiVMsWQL3Msdu8qcXazTAB2BvI52SDI3jaGbpXtPSvSB+QTKZNAz5UsFHcMYmO27Tv8pO9BS96QnPDNa3pmRxLHTAwTyprL+y90vzmJ6MksgpvGUKZbpZ9hZfTMEGtKE3KgsQHotbiR7pt3EAKIFisTVAjZcJhfCByLB1+Uvui3nSQazhWGiR04vA3RofP7ldfd6ffZuvXF+fvX8S7xS/kcTSHN2epYMpr324O7m1qjAJE4cmCbdawVXmp8ubvekoiPN8j7nb7/9wx8fpjeWTz6/vkmElrnZP3BYN3Y9dbm7VeZSdC5FjMYov5MgwMcCXRZcCYptGqaVtcODrI/Q1aMLlo4qOKho3YzXnc7ZgAt38frL68ItoKL/1KWwNZzy+mI6V/TUZL+EGtOpeV5HFBvOWddsn4I96XENQCr6g0u8TrFQsFqEEW/4rDF6MVRJ6rtIkg0jwMpyP/5E+4aLkRXxhEgvXlCwFn0WFYeL8UDD0ngqwR7VVRZv3FJ2MSWajoknL9jre/YynIPpALfISgwPOSp6NNCn/xI3Z+RcNU+jTRZcYiqRQ1TINz6B4Mwrtj7CwA0llgdaRBrv+c9//vLZ54stp4jzze6KCVKpnqDN/DVi/Do3+IzEbJNE0rKB+caIGeI9N5k3TKwV2/gaUysSD7FFUp/UkTLp2NPd1vrnfLV2kMhiZkthx44lTk+MWMFrZDn9pGm2o5A0wha0qQ3l6hAj0QYJSxY9SRNJxf6wM59yJ6KqmBoX4F2EJ6SXOFEegmpRYqqRYqzBEOvTT+jsbDQJIsNTk0cXy8E4SWTzycerycTJ54++/f3m+cntZLIez1RNWZAddOqTgyVUBcvR90mLxZtPazGEZk07Ut2UWWUw2L795J3f++HNrz+ezzs3Ng363gO7aas576LuQAYJYVrSsgE405LCiJi5FtVGdwEZ6Ku74TYkge1g0z1/tJpt9DperxdOohgO+h5efPLw5MXHzx39hlUUrHUzvzzUh70BMArtuMD/vXyFQ14RavryRe1CwdfWTntH5Za6hsRS7BB1oGQx8Nd/qtjiwMZkC2pjTDNXwbDMY1iF3wnbMh1k98JiDljCR5R8gmqvMBBDmUBfJFETjSdC5upoGSrjJtHjpR1deglyWUOIVMEdkUE5+s7rDAeVICRyYcAO5vEY47Aca6Mg3cTfjCPkJzUPRq3vCGwke28joDBx+tlXz//qZ5e//AUvh5tDbqgDyOBfBvoBOE6kqTQT2ifM82iwuITFUTQYXrCLMpiKA9kjKyIlhkpbAGZ10Vhoh5tEWUxGxBfI5M6zJWG7OH14Lj6QDu4PVLDmESp47RpmgtZO9+q2kLDMpMSKMbDobCbJe0WWK3YsYAkJknIqCTrPbA9a4DJwixUrRKNw3BwjFuKYY1EqJMTegCbsqlnggeMUHSA024zHrPH05bPe25z0PZUWa3uozuZzrBFY22oiPm07cU3QK14U9sVBxR40NsCcgFLfjs663//x40rtfPjsT3/1mUynAlYs3O9bs+m2PTi2YURwpLXQFYhiWNWZoJMJOFgC0aAKhMPu+E+pXQ0ZMIiLPLu9FIyfPrZ1udX51W478whs+lU6CbewLtvhcZEApPyjKisa12S/nQtfjvXhk+52Of/6ly9PHz/oPXlY66HVsaWPEIo9jTOZxROHJeGTCfqOKg/KMll6Nl4JBUBQ4+zQjnFA8S7xgQtQGaX9iW+AOLnTPQgZq+DjOPFRyvgNf8QtOwTYAeXQyZ3n2V6F51G/XDltlLE5PySRZYlv3cWo6DmSiSZeQoA3YXGGF8kXTh+rGw9GWby4ufzsi8tf/vrlX/28Op9JrFOj7irQDzi0A4JGTdJJXogfMjbboxN+7HGRMup77GBzEB1IxURlZGUY0cJ5GSLCQ3i6r6ozYBU1XeQpbgNvyHPeZZg2yUJwWXd9adSmhxtYYnZ/WaKgI47HUb/rPutD32gE+txthE7Sb3Ock2/0TdOITMLj3qRvpCgaI85q4ssiOpElbYd/5peMauJtDouZYrRgdxi3m6NG8CjnVeX201mtfyptRNp2UZXYJ8CxJ461P6zn+9V4Jc7ml2ZNMKJvNCRCvhoVG73ZqHnxx8NKt/6D6eaTr14vrRWkCofSOc6WkTWlsLS2B9ugQ7Z6W2Auvlr8cHagaNyIHmxtFzbJE56mAtTYta2YnZgt57tR50x99XK2TEDofrPMmjc7wDHoRnjoqrYkna2qlrm2mD69vfagG/XU5C9dOvOxcyqYj8pGSZxVACe2Zt9Q3HYq5ikZIXYftAOaEE4XolHaFnkDOcEcNVm+pSbzAZanWJeGYbB9YC73COI6hvauQkuxh5aSsCM62oqbDIBIKnYszRR7w1WNoGReZEIix2AiY/kyvA3gjRY4MDRAOfI0lO2om7r55DdXH3188/GXm+nc/QhH1ym+JX9sBJV7Ly6RGqMuZkRzIaTTYQdDpwPx9+cZrtqQNeq7A09yrZcgVZSB20l4/kSQcrvcQz7UlB4yajD2YSz94naiNRczCnpcHJcuwYeIcOpJlSjs+BNnpyOa49mrSyuvZml6lDTKp717ousmZ5wZm/pc9KOGQuQY2riIuc4LXqXO5O4NicrgREh3OjYKDUlUmXNVQXW7Y48u35W5RvqFJ+tsJ5eTw6p/8dgH9dFA9Sov3EImxaU8MBv+g3lDTqo8Gi/uSxwaDPanOa5UB3/wR4Px8oNK8/Pnb5YJTxwZyWrWEMASmfCLSyrrOJutBCJ5Yq1fcaCJkvnUKXDymqVkOPImsh12JwC0Mlff/fCdZv/HT/7q334GHUYQcxVv1dTsV04Uupck4s2btiCp67FI9M/d7PJAsQ3eemLM9v0s72a9+qDZU9OPlDHCuGWSQk6DiT+WTqPRmPWAO3o7bkfZJy7dFjZIw+B+jvk2RNpb35oivzAQbEkcogkdz/lZURgMn6bYEoTwlwO5tj2ffoLsxMUgQ/KCsgR5YSr5VMqVU8L1pK1cW8QyVGHxArbcre5s/frq+W9/8+Kvf7558eo4nmY1ZucBsieHbq/19Enlwej0dHT4/LPrn/yiXnUyfsJr0zJqv/yhO02JF5KFczsHctqh3gN29AvIC+qNkZJwE3RlniAe8hleEYHIQvRDAt2imPO2nENaOEgSYkII/v2hgfPZIqxdSTUkiwvRdpD0+r3B+Ukn2VWed1kULI839gD3peLNnPascbdlC0cqz9EklxYPO0MKRzOxUDmVXWysOeEOtMYwud0SWVIFRwtkOmgpXVazrP4AWqmDzXx++SJOF7Y06jZyiZMIpC2kltOzAhAdHQrmAaDEK5RIThBAJP2EW9v3/+M/uer/nPp/8XK3sA+Jg1Y/zmOeKv2jeKCeKMSqRqnChd5g3sAK1MQ/idGj2cyAM8O9TETtbA9B7Gb6qn3sv/2k+TNL4wpldB4emQztSXfQr22t7a1VJgPe3VXFuUq1D6tra/vrt77zbRvZJuqRHGW5rw8eVxqJ2fCQcxs/R9oh2DtsrZ7EjeTXxsGmt2zoysIBi464xZ9XieSgRb4DyoIOkiTxVmQh0YkpAFDsRixYSU1AL1ADkd/2qcUYxJjCOTIGiXH9lDkVLe9GKI7JloYmWYWDIZThFHrl0Acytpl98fkn//rfjD/98sDNMGLnaT398OH77z9+5729fMbTx7XT7nK7EO30/u6ffD78H776X/5lfWefbap4VbhAhdGmXX+A2SK35QBQiWWgGo3VgEyCjkOppLDhPCwDqcDZDML+KOzckol7k6/zTolyIhw0KtY06gDDvllpjtoo1CCtrOiu8vzZa9ti5enyrBpOd6vVVzDW8azK+Whwur+rOu0/KYr0Ege13I2khCGpVQTkMEFmVFrWaQzZ/5CbvBtbEu3zTaW6NuJnGnJqCAzKyTr20EScDXE7uXrt3J3moHvsqogdpKiVZB2tZ2HmN36HfQN56wfvcDTkM6L2aFxZvf0P/pgKrv3b3768vJzmkKssvebYCu2vDw7AEgzZ98OlmSytTAuLK9ShrVx5lhkohTApLd1JIxXbtpovDlm03rx4dvnHv//dk7Nnr1/NqpWuJmNpKQByhpcyWTyynMBqgScnVe5nq1XNQUgc7crnf/3r7/7h717f3j2WsVCUceNc4l13qESgJXVKFGR9wqsSpZIsH2QlG279iQsPrBDuFSW233jyYi6hYxJzAmvUDicJQE2BvkgWAuWTxUhMQDyyWhDFzg+W4NYiq4JZ8b2SVv9mvQw9TcaXVJtvEIBI0QfkCYyyXdoWlsnk9cefPf+rf7u6uSSWD999v3k6Gjx9q/PwAQ3ROD2JBjOXTTIWJ9uuisFla//wP/lH88n1+Fc/TQJ658iDephv0vc/h4O1c/WIPhuNTm8mt0GI6QN1WBLxjhYwbdgqKi8yYEKQR1qKZvZl+qXBMqfighMxmxs5eYlmIkGRjTRY3BXqjRNL2tAKlmBZekv2r7acq9CfjKkgBaqk4vTROTCsFkupDuF1ao1FeQnUUdZsrJqjVKIKOI5XYlTMl6x7xuh5KEw2tVNmUUrH4yRlF10zgaioPCnQho2byB8zvZhuVovmiVDBAWHMNSdZviJKhr2itLzMBEKBOGjGkLiQ/2KuN/XGt/6TP1HvfPif/rx2vffgptRx72XpowME1u36fmBpQYqpVp0LB+P9VgRJ1vdBN5k+ORpzUiOk8fgFKRBSffHy5bT9R53f+71v/cvLn+WsX6CMjbBVvyNbJcKjFaPMrdeoqkjQSef6hWPN2as3v/3pTz/4/d+Zj687zZojoVQjdE4Go4uTzrDdGDiAKGqeJokOC9OTqkoOOHYiHkyJfjEYaPHFO36WOYuveJZFHgwV/aCEyiggoTpFZhgM/bQXlwzTGH22k9AQl3AEBVOAIKkYqsIP9QcFFJM+i5NqI4Y7at1q5c1HH7/57LPV1S0eP/zx97sP/+7gyZOHT5/yqS2vBBQQqwgtgCXQyVEauRHE6o9Of/8f/5N/9+rl/Orr4A0E5VUya2wNXg+rzfIyIdNSlY88XLQa1mZUGgl04+eE1SG826KtOAaFRJlxgC0s5ISnyUIyoCyHWJtXNDG323VIqmESznZzESCcZpcocQdKJ8iKg32c2ImVwVkVkuayoN/o9bvdXndko5lpHg+Lmeoii1JIFdff4RYJBWy/6vY93Vo/IAurUknGSDAEHXFKU3mD5AnT0q1YsWPbnJxgDn7OoRjklVBZN93tPWbClnahY052x5B4oeGfhWh+vJyT9A09zFlN9VOMj1WwZuO2f/zwP/2HZ4PuL/75n798dakEjziaFXnlWIr5lZbrZdQ3sO2aVEu545G6SeQEobhymbxYOgC+3/dZby/3rdcv33z4/ugvOsc7KziqvO69FMKdnSSibJvX1OHZhGoKVaeFcu3QUxLLnoyVRz+8uVakcu1ZAVk3bBxme7nacbd2/v6D7kg5Y9FPZLvk/EDDUOAIOFCSYkvpDpCzk43sW4Y4VsERQimiFmDKdRY9DVxBBzVMCSXVmx9imDiDSoGSphrVtbSVtXo5AZYrFt3ap0DDOxrUvEwvS47FVh8OV589t2rFPXv4/e+f/t3TDjXPRaOJHFBjAHKLJkwJ+iCqiQzrOEMH4tT5x1XY1p62n/7dv/Ob//6/TdpF3TALIRVUIG6EblpNxjUFiG7I82+E+WaeZA6OlCnFBSSvUV2xh4UUGbpvY+e4EkndxasiGz7J7ciVd3GE8hPUFQvAi85FYtPc7ZYoO5MgZsU9Ai4+SnIHuWKZNbv1dDWGtiiQfceRhv2u801S8NHuGtjV1RsNRv5FnwmF0V8GMueNRKT8Tb8x8/e+HJ6SHTBWMucg465NA0Wjk2pHUzFFDplw/tqhOeudPT72nHp3e90/O5GSBgKdEp7IcbKa6i/27Wx0g0iOYZuDctWqPf0Hf5+S/R//H/9Nfb4AUWQzUUKkvmFyoOdSEOJQfzvU7iYx+siK93bfZaxxfhUKMZwpbaXc+W/rw/7qbvk7Pzz53ve/9Ve/fJMwPKk8NM48cDr0g1M4E0KokVb0YXuap92PJ87DqCwrX/zqo7OnT/pnZ81m1+FIdhoqV+x3EJECLAoOsSGySJ5XHCtvEgIwK6lESP0nboEVRQKllHpcE2SNCx1WxzpmkY0u9iIKyfWJJmNJioJk1hS47qq9Y3Nh+wXNg/SoE6hkJTvsCi0oqngR5M7/w4cPPFkZxGlNAbYcg1kmM2W0BfXFu4gUCOD9DtYaKd5O1MboB1dqr2rv/f0/efnXfzl5/mI1i7Mf0US5TAhgcpeti0lEZBa+Q2Fci2DTmaULw9OpbnKr6yMLrspgIgfmoCszMIx4PbHDqdQobjfAWalIq1Gy5IbTQrTSScCR3u67cwFvPl55+dDQA9qsRAAxYurW5p75ePWmxuGo2r87ODmlTXXZbXWISmeYzD23GYils9zDiWSHRcxYqrXMNmomG3UNYaWgLwXYDvAR3TmPOUUoWQIG29V2+eZ1fXDSeP7XP7d55fTBw8GjRxxNgKGeJHot65u8+hYKRQVeyHis3qpbq7cf/PGPfvDm1U/+hz9tLTa8KhQXvmGJg+JVAsnceGAYERr21MraDVAXguWgpOh1tPKGPCNLHBm9Obrsy5d33/tg9MG33/vFr680Eg/NggA9Lxd2v9zuQ3SC/Xpz68QyTMnGDCBUiam+7nDz+o2cgnX77snw0aljJNA6+5Fl3dnZooVgLloKvHI0GOL7KcxGtOTOwrIsv9O6HPyYNe9xm9XB7Oh8KtxneBYljctZBVYoL2e2W8+vr15+/sXrr79++M47J0+edkcnsQrCRXcwkNwiomzQekR/9wGnZEe9B2QUhFVDaLLrJSaIxggW/ejaq9Deb9qc0NKU+UhzpMk/I+MjPnj03h/9+x+9+O/2ncOSAaRA8i225GLEClhxMufRFGkHB+AzXSv/ReXoLx2gbPxt2opeYCRi/AgAdZNBs/Z0S57X1rAblvdHX+irZGCiJsA9g3VlnCLjj/MTuTfGGBTTxnKzycKIK/WGB2Sr3JiRppUyf2NQpT2bvMYdjMEXw0nAjYEVB0Ck6nizoDRIoz1qAAXU7ve7aDjxl/7uKwKpXbKfU35z8prWNEcOVSlstpPGw0dPnCYwefn19VdfCiT7Fw/PvvVerW93b46BAWn85rzRaCJQNJV9WJ8+eu8//d9e7reX//wvOhNu1Wa3qXg2DUdK3aSljE3daRnybx5OyLA0bsYICAGFGAFfcqImmuVxPJWJTF1D/cl5f9C1uBgfiAljI1FKPs0kGdZAoCiY3dTTBD03vscsOAyjWus5l3rvw5RYeyzs9MVyNnr7yUn1baELDSFpETVD4YXylg2L8oUaul8hEJePvuMXiU+SSeTzRLsWfwO99ZqdQFJcVGRoxwQQ76NF2X1T0vPubvLps0+//GyyWXYfPHz3d3/UevAoYingwSm8ShvYBhBe502oEFUlPgnDIQgAoo3pJ7tAHYrq0MoijuSlaH69gnnwyVFxubWbkDMtFnVqbo3Okz/+k8lHf/38t78VBJszICRsjYfA5kRu1arEc8fNwAw6IhhR7NY0iv5EHOGNmQeUbqITgpsIH9pow22saMas2xx2z2zyelMIhIYS/NEwRQZiWQ05ZSeGHNDrqdjAIkeVihyueky1ai4Iq9nEuDQxbNEwcZzkImKQ46B7SU5VmgodVgtNb5dSdr6wv8LZtR1HiXN1psulw9TCoOT9CEo0jeyrrnPkgh4abfWtnJGFrcZOFjI6S0VPfviDYJAjPBtP31xOv/r88qNf9p48OXn3nYfvvGsXWbXt+TNojO9woWyzdodKF49/95/847/ZVxc///X0+dd38yUTnlIKTMnIlU+bs418BycRfetsdHuzWM2tl+sqZEN52ekYUjFIbX91e/vRr5cy4YP6brJyfktOr845OLBajrmgAhCC7SDe4hoyBzESKyx70nwWXfvHpaX+nv1NObKXylPibu9crdtYzawWZVSmSz0VeYvSEf9nu3LQkUV+roCiq6ygGV5gqis/TBenIho0ZyTgrx3Ri9lxNr5++Xz58s3sdlofjHrvf3DidJl+38JGdnqIwYg4VOGasaRiHo+DJdzRVFGM+JMfyEq8nGWTLC3QZaoNnPnjRR44Es9KG2UwCeTMmjOrYM63Ng8oWjYzqy/N7dnjp3/7T1599plQLp+lZTKSSTAy0UB4zGeI6AT8YMUZCEGjH9ArRjkX25aQA71BJ4kXLRkDqQE32ZXc4j1HsYg3ZyzanhMo1eG1TRpF1TEbxerR+YK2knEOyb2LDHmhGCEySDV4QxUUSYZsk3WJizIUA5fq0R8T5z8jCCXio9c2xIVehzlSe7RrsNmcWQllQUU6sG+iUR4qkGmM5OKa8kzglrOQMLszWMaSGZuMe1fmMbPqn5+fvP+t9e3V4uXL2dXd3a8+fvWLXw0vzs8ePx4+eth7clY7HQAiZGwInkPnB2c/+s//yfNH/7z5Z3+5/+SrmaVcGwW5lUafvQRo2LSjUgJ/NDw8PO/VH3ZuJ4s3NxO2WGKIkjecrcaaTUe1LFYe7v1mvZy7jW7AEhNGnxg1Na3ktVAl+iiOKyff6rq1hJ6Y1TYZlzZ6PQ/E9UgCVmrPw7ubrq7Gw8cP6sP26GJov58Uj/CoK2xAtJyXlnpUB07wkSg4FIihjz2Aeo+DsFpjQepQWexUU21ux+vb28NsOr26XL55mfMT1Bicnp98/0edJ0+ka7gvoIw5AIFbRTMXEGSc+YGzQB8IxVaYVkxBNrsk3iAzkQrbIXA/jnLkJL4HBR1Vl7mLXw0zHiyTFg/N+naR0RwO2Wys2t3H/97ff/ff/dlq/jd2rQZbMT+Bkk5hJx/wEpAv+pn7E1+neCrxoePdxcsvdoXwWa+PAcqaawZHzadumQHCXAon3967sLooOSKDj4nWDQeyzDd0gG8DvjcjJhLJN4f8JTsiqEyADSnVQdRFsdKx07EWMGBEGvdFcJ9vIxL0SWy/rnyORkri1c1xJ9T5p8QgcWzkwqA7jZ6lAIBxv7jRiMHfyNcr+8HkXdXQEvHsnHApqlCIjSfvPnj6/mMD361W7PvL11dffn3528/Jee/CMetPLt57q/XkrD5oiV5bvcHv/+//0eXF6Df/8s8uP/pkezdBc1OGIwvVIm4kPh471vvkrE/OajbudAZtu82mN0t8iOKzDmMBtF53usuPP3xn9Nn61dWd1Xb907r83SgtG8u2ivhYF6Q1l+TtO7Js7PxhPej1aaqscu7XUULxuvMs8vX09sVi3njxon9+Nnt4xl9HajYKh3v2R5z0c1JIr9bsO4uxHBHOhQJ3aaXr+fp2Ob2dzW7vdjfj/d1sfHs7v7m0N3GtmqreOrkYVS4eDN957+Sdd6h/6YE4ioEaxIelvCx0yIdxpEwuJ10CPb77Byj5l7fwjQpBKs3HJ49TgedFDQdg8UfilQU6jpVPUUaokQbyVAN1LCKJaLFsLFFX0j9/9MPfe/Hxx06YdBMCBuHu1wXrQTdlOTbanRnWThoKHJK9144xJ8DQNKMacLG4vsnR+4FgrtUaATDm2E1mzi8zieFKTbKGU04ajIorCHeS3slRZkON2+QMqLMYhQLvCAx3K+PDyDIamSrXR69nVMCtJ636QRcflm0e6Itc1ATHpHwTfyktpgtRgWUCei2lDNv1zGDKsnQKlbkVapYcZ7KyC0BSkKoqm6APzqxU/iOFl/0bUiUmYxuW9MSD4cn33n9/vb15/urm+Yv5m+tXf/3F1a+/Gjw8e/Q775+//0Q+1ZV/8I/+4VvvPf3//Jf/VevVq9uvXnuaXXc0uh4v4jDZwCWMPnh2fOPFFe9t0R90zi9ORv2e5zQ8f/MardHKBGbravvs7Mm33vvo07lqoxIBoxSYhFvogI5h+to2fgUnbLrjDGLAlsuxfSJOJGDRrEjH4dwcm04hOu7bvcZ6NgaNy/lsyAxZk3P6WaU6Uxo7lN9qDk66pw9GNiq0nSa0WN189er6q8u7528WL282V3fH+V11uUAju90YFs8tOn376cPvfm/w3pPRkydbLhyuJZEiPqFXAyG5Nh9FQyfExAm/M/pv1DDMWV1K3gnD4CVm+psFVdwrl2kmmjYsDYRhDkAsTgQ1UgyxirDnPtQN/AKsYCelMVK3Zz/63bO/+NPd4uV0zoUMJgCFGjKMvCieRrlFH3GNkifSIq578mz8Hci3CACYsOy5055LQoZBibNK9Ry4thl33CIaKb62AWY47ghmY1yjt1yW2CMukNEV4RdxqZx0DUJFAghK7jWLXGOXm3GFCuX6qAgNYno8H00SKmqR45OYLQNm+ItQpG4Stl0qUESOyKh7Y/TiMjpqnzrIQaSU5/I4n62q7XW9P2w5UCUKWGlwp8P/U7uPQF5Eu5I0vEuqm6WpNwaN4Xcen33wZDffbMez2xdvpq+vv/zJx89++flb33vv/e+9N2kc3/rww//jf/6P/+f/+r8etSqXX7944CGVU1vlywNmstmLA1d3YAeOz+azeX857NTfffRgXxtdO8F4Gem/nSyfvZzZTd975+Hiq9fMbChFlO+5DN2FlGaEJJjgsTx1m1Y9WStHNantR8ycQhfScmUc2+KhZqhBT6wWdNdkGeUtcrO+trTaMZ62u83dTX36+VfNxX79enL1xbPbF6/s7WSyGdGgWAVdZd0cDrqDQe/sUWt4JrZ++Dvfap4OpzP7cza9nJVtlAnosQ77eE3pvlgwsIDiqNgwMfrVC1YNb3ELiAOMgL6Ewkm1hfQ+DYYS8roMszEO3EqeI+6lPxw5MbaCIlsWbQ2Ru06pDwB7wHXz3e8+/MGP56/eIMXGE5Witot50VqAAxxFJjhUPOmIEoFNnjGrA4hVnvpsDZVeAnBiFQkvIux8qpy0HBME2viZPARXxPEwAG+Q3ywkWFDSTHnmyM6idQormqsELVSSREKqAe6VNcYmbwP+7If/y1AjkqWm2cgVkZAodzn2hlh4LBIK0WAccDJZvkKOHAsF6nKdCWXL6nvUTRkzw7KYOB/Xbv4cq6x2QtWUtdW25+9afrHVx85SVXBsewpUICwmVeWjYRhA0WuwZnLZ9FSpndU7F933v+PA8uOaO38ze/nVy4+vF29Ou9/97pP3v/ej/83/9b/4zT/9H43ksb0vm9lnL249m8ZyM5rxN6SFnEJtPjaHAcry+VW/13r7wfDuZqxin+369KOXnuZ6cdFcXdcPM5OghrLeRA5MkIsDYzRjMIBwdKyEK9teq61ndt6I0OqOzJMkVT2kYNJZmrvJotbrrA8zh2FIl613krjNhWhDdZizL1mHu9v19Z2UQuIBjw20VCYrRZE02xbkur0z9KkMe2yWnG7/6cXbv//t7oPBfM7AWkbEhNxYFBdy3ftf8W1pEozz48OgP6CliZ1NJA6TZQIDk8IONKXUyjpqVFbOS4xLUGphKT2KLUzx7141BsoBPCAJ0r1mCvOCX0MeYLvW3DT6pz/6g8Zf/Xl7sWgpnGLmo9VjV2KGonpz+JTRGBXoBIHxgX2e5BsSY7jxk4wkZjfMOEkoYunQWS1wlvif0f1a3HVgo9O2IBq3xDmeDmgyazMO1MtjjzJ1hzCT0qA2BylmDcNQw8vAvchnPLKkU421mBHzIjlcR0ZWuiw6ZM/wO+XFqQqJQ/SdqDgTkzvmqkG/A2VMVU6pJNmR1fnofC9Wg4i5t82xVvIZ80s0JYKPtgXXVLE7oj4DKrPgvUrhKOXJFuxwwP+4aSNLTi9IhY8fhWSVh8PTR6fn33lL2nx6O/3NV5dfvNq/+9bZ23/nH85X1Ve/+cvafip2Wtpr0ehhu3PhyCmLwhDFJ0pRkKKe2WpwlMPqe+7skkytHg5rj8H+vQdff3Ll4ClUDuITLOQQkRA9TEwEaZieChsnAZaZXKcB2sdN1NE9q6aV2dTheNWWZV1rhk727Q0T/+CvDNJaUczV6lawwcbmqZoAlA0DCYEZQ2pCbr9ld6lN7zaJNRx99vTBd/7e79X6LRnfnJBsxz6tQRgD77jmMrRGGFc/zEzwRzTxrYw4yk/bxh7VEq1PNeqO2JPtsA2hfSzrl53x4aJG4uSAUS4HKJCInw39+TZS58vieEBCSY2qk7Wk3X/w/d978J13t+NxF52tu0QyXJ0cWiIGwHYDhAEGKKRh3SdUzcbAFDJI5tCYQIG4YKaRvSfCHTZzdb/2680dtF9KX92d5UyrRkygsXZa6t+YDlg2SSzL3NmKsIR1RtLEppkfmvPSkQs1yBmIZTHkaDO67EFqIqlrIpk8eFEkB5vD0Qc9te/zmGe3RAbgM5IqD2yvetCPLpx+dE8kwPm2XJ7VKfOzMdwEk3jh9tgyjdEtD8mLheL/NB2AZfNdNCooRCPwW0KclDEkP0wkZSt69gTr07A8cGnjMAzFPI8f9d+pPMm5KPOlZ7A++Y/+s8qPPvzyn/13ncpsrhY7GfqEQQJZqiVRSlaQnNcoB1t9s97Nd/Uz9XmecNjd3cymHzw6G3R2189eM8KeN2k8NCSSpAoG2wKpxFGEUoIp/oP5O6EWF+GG5spCz34vlcjx9XhdU0OytRy7fVz1ympWnYwnr19mtSKpkSiNzX5lI4bpRthFDM7YktIO8BRfNtr9tgfsPP3Be5VRm8ORjb9ZD4EKWtAKa/aFGWNQGmiTPTBD+fh1iIhW3uWfq00lZiHc5dGbW9EuBh59WUTHVUDBqnE87jEEsZGlkgWJInSh2yhSSpCzJg0eumStGS46Wd/unb39e384eX653VzhsgcQR1xQjNgAYEYVCYPyfI5cknJFLJkgfjcwEiNBoWyf5JJiEL4Zr87CKMmnkZ1fl00F0cqH7IoyL3EnlZokCqZZG+R7ooEEjmWHGBrDDwV8aHq6N9bIWKlCx0zK3oN/D/XFZu1kTZwiolRG7EOSoJFYOgkhQhzANwWNK4mOQBd1wBclr7EWeZ5ADlRKAgA7kg3fbRYDhzfGCivJWzBTijl1iVxC9VSXpfraaRwEhflQPNca+B0rm7WqvIqLRzhAkNWmyjyGUoadIcyxqraKRCfXq53ubhj3+sSR7V2svfkXfza4Gq9eTB1V55SfbrMxV80mXQg0vIHK1qOFK63D3Elk61pzW3k0bHUvLq6Ws+8+fXL13vgXv3ql51KXHF1LM3iHMGwRWCEjhit8rfIUD07CFtcbR3QPU2XqjDjCKWcS1bk6W4H45pdXhzeXBHw5XyKhfJh0IDxnk0NMhzAxoQ+uAjrNKbjQzPnjs71kTAnzlG052CNPkbNtjvr2h7mJWAJSygpwHqCNE0MiROTAP6n6rBxFDeGD4XwDiCJyCV/c4FP+LpQBXzwizI1U0RoRosL1AlSmlCpGCm0WvcSTSeaUt5LOltXB6Y//pPfLX6yY5omt23LhKKAt1wsTjTCvyRULUVZDiuxq1UMVJEKs+kuwpyaEDmR443wKMNeJaSsnJ6PVfBmNbeXLsh0oOwgQQXScGqoyiRCfqs9gzEmcQO7YBR2o6/MxLS+48IkAgggyGCunwTqcxJkJ3jjHwRNsIyfkAAAy3Hvsm63PECO77eLE2Q+p+tG+XMrMwmsOD7d3OQ6AOTiOxzlU7KbTDZWN5fi24+Onjylj/rHjXYp+F/O6UPTlDxEmMElQZFFGP1FCYZq2fJZ9MLsV+HPoSK2Bkv3cS7RCUAfLHSq9ZsVjliZ3x+3w9Pf/3u/97M9+Op6rFKkfJ6i44ajL0VKCMsQWS+mLrEISCPivN642h2GlMmRk9+s/+IPvf/m1p10FuGZKIVk8x2I9ZfEF6NyZIVudJxipROaVO0WCbrWMQKfJzVtiMW4OOX6OX7xQeuhxBE62k9IInoKGZNZCLNNPwSOU24bmsARJfeKGAlURMG5aahRLsTpx+unEeGDMq7VPxZpJ2qaJaCntAkxy2/rAfv8DUxAPDWFkNBqwiWrgALPdlfUH0Rc7Xlaj7g/01aDGzD33hgnpJP8FkWQe0REhmjWuUXIemBGuH9vd48l7D3/449mzTzqXi90yPje0sY6x6fcjUQIk4ZEsgUpJ8hN9TF6d9r5bcAwk1RC4ZQUxutZJlP3ufDYhm7ab47iVNui3T9yE0N+mU5QyzRxpQVEmrg4mEueULBc7xK12ooIPYQnrwCX1JuAT3Y8sYmrktWCZYJpV6AQr2pYQdKwi7ewchZbSnqLdWa88r5oRICQsAejTBXYbsnh0jNR6MTRy7FVFRMi4doBh79RKEwgNzh9bd4IYPlU5GINHy6QWnYlQ/ppDLG1gQfdEHizgxrmIF5aiFRvliokiddxP517U1RA7nqFF0hqNC1B5cLp50Jl93r683Ty//ZVZHWzT3zrgckmKCJlZrRyrt5e5wIZGrZvci9WJ7XzXe3T6crb48dtvffjtt37y11+ReGzimPDXyzIMXGaPojGT1rAdSCgKJ6cT8YDDzjz0x7U4WgN7pWXw8ESRPf/UWbwuKJoVVtAXYwi5mYG2LRBAvxcrFxe1UelZLmkPH0iY9noj+t1DLF0gDHAgTKvlgXSiiuy31KQ2kCqYdgWoJ3GXg8IjrnF8U9edLlJdourLiOA59iG4R1xL4/G/XZLVgwKfQD/REmvuVabsHrAqD5Y0f1iKNuH3gneElbJIYd+xsWuePPrh33r987/cXErvLZK6vB+hJuNGcHuAd2cFMLeBJEmOh0YbORstTowR2IPk6Yk5icwijEMUu134bjOvBmsXuqpKJce1im0gSvk57sXrgB5RJuUSN1XDBMGMzNHqX7pmXfnc2cnujTNp8pghnpMHCPA/c3aHj6kZkIuesm+dbbdSVHPwv6ZlLOl+crVJuQDFdpTAN2ZPb7Ham1JiKtkpX+Sj6mFEfS/A42CbpAWgbnfh8XOMW+G/sohseekOhA4KxiJY0a5AEUUFaVaWpFUgKTbdF2GKtCAaOI43doUvqM4HOahdFtieUCvLBMiOAOdnbbonZ9IRlkuR/7e//Ny2qNnL/aBmJ/uEnZUg2DsOo5YjMWCmdegdPRbGwyq3m8vLu0ePR6/H8/e+8/RXn72yRUZFuJwe2tBeuFxSeVRg1AkFTA1CQHSIAMNDMFULFgmWA2noZX4YXrw1fvbJ/vo2BykWPZqzIVk6b9xLdSQWc09cVRE64om3qx3eT73fP2/0TjyIQWxAG7hPRjLKwv5nW5xtVhbTyDoRsigOagNnIwFZuQsAuOTk0MAJaZRG3CvjLv9MxjTu+R0gRlLIEgkJ2mkfLDZfbPZa7+BjiIFUdgayXW7yQbbhZocdpz05HJe2Ke3uw++fvvuD5bOrxq3j9e7NPdqV5IzYUSuJVndVob/dm/wKYoyehmEEhCqPKuTbkpSyK3q7Oz05mc8nSainEltcYG0nmXgF9n12o3h9DvfztoS/1odShJXI2/DvM2NWfHi0+KTz7Y49Sb5a3Uf0ju197JPNLKKypJ8xhbFdR19mf4NlCnDBYwePOyCq2+6yqg73XAr1kksQlbf3g0EIC73+q7Wv7iYEZnRyjoA0fVznjhIb4UJtIW2c00ztVXMcovIGREuMZHmZ4gwQsjlPh6iOrIE5ScJF3AQWqx6u8qSjEIvKTwAnYiJIdgbn6I7asERu0H3y3tmPvjs67f3w688uP1qtJ1dXrTwxVY7Xc/PiZcVKQqATVhkZltPJNh4lMNs8v5y+8+jh0/feefVGvKUagi/B70iqh6KLYwpsSblQK9HgTIFN4hK4ZDH+AefWcSweyERP393Mnz1jQEyWVqOC4lKYbogF+cdyfAVk0w0AlYgoBnS3HY4GoKFfLqnZx2ODkZyDo4prw3FjoSWP9OiDyEecpoRDxpNkjsFhTuIqNIaCfOmX60NcFaDhFeJ6Q1C0as9FoKUTuocc3bvA3C63SYyAV3Hzs5hAoOJpJeTBIVhNGiBDiEgkmb2r9x9+58dXP//ZaDQ/TJScF/PJHmUO7jDDDIIRSfRBh1HZtFmgQw5QlsDlVGGkRSg8tvAMyvaxFvncz+bOQtjTuWyzp0JkA19OPaQcfUDQsEczyXh4Rxf4NBwzgCRn7q2EgxrQgp1c6jjCKT9JgmkM8RaiMRZZxYtipfranZQPzicLsZaR2/U7X+OqFVJNJiKwAUxKNORHiFZ91L/wTBBOLWxUm525sy0a2UhgOPXhGdcoZn63YX557+xXUqKxk8VI1R1FpWF6qHhsbom9Dvc0H33HxLmWALvfxWCIlkncU+h4C0euqTXWg4uL7/2ofvhsgDeH7/zy14fJV29GRq36g1pY7TxULAqHAnCWX3NIJrFvslzPa93TweqD7z+9Wl5adnAMFRLYxiNoR3dcMQ6RBFPMiAocqa4wkje030nZ22jKk+gP+k6EnH71aXU59YgCDg8d7DKojGcHC4SZI5TWMrsU3IZF2RajLc79xsFRjISqj2x6061HKgrhjzZcltM1LLgtpB7QIspAVACaxR7FXyQ8Ja4IgmI+ow4LvrKD1sUCm3yOuwYEtO7MHmKWi5MRcfFdtGkEla7VgQ/xCNYEpJaf3axaLhfE69ZlWcWQ8xLTUxgn73978NZ59fpmfLfAEsgwCAONaNL+GXDKGQIX9AAD5EkNXsUe7zJC94CflkRPPBVpBs/1XNHswvQk0ahJoD4e7pxfxvbhi5Z8kBGZUyAQkh5yPASMIW2ZUSJHA9Fj9iO6OmrIfdE15N6AqAGXWDiFMexNTw3F9vxVmohFiKpcH9WjRZXBXzz4XXXQP+GZGKpnqeSRCNpMbttnJRLxtEbnm3OWjjIY6GdciRkzPoyN1oE9HlXUU8yBtVdUM6uDYFKtlxOEwNoTVMwD1aPYigfO3HuQAnuU9I5pRJVMk3hRnFefH9qHB+9Wns6eKNzbvb04bp7VG/NPX43sBPSkhoO93JvScACyt3/y2HJcuooGpFovNt/97uNJrf8LB0YodF6MYYWEhYHoBpJqS7yS0XX44mAooAqd+OjZn69gC0vX6xdfL65kk8zISRi4krP1IkvRltqCgaK4mUBgcPIKXRRA4Lq1hXWPF5mEnUMihWtUMjlkuZIuoe4sGxeoxtEBXOyz9xv3NU40KVeNZUk1PXB0s6KEp7klUSOVnLqxfEWhcWQZXpTFLUoTVoStTG/AYcqaLHKkdi8Omknoc04vs+O+NovUv0YtsHuxlHIVzlx68js/+urTT0+G7fmt83YCeJDKn9KoccE3gPgdPFLdrmp/c4qRrmN88qGDRDztk5K0B4B05RGN+TxKDyQAH/xi4kDDwOhEQzI+wY554VHWFrQWT46Nz+GqJagR/BkHDw7BxQ3yGJggYRHzE7FxNng8Ey2Jya2tdqkBip9d4B1lgl1p2cZgeNJsD2udjja4bJmc7eJhcQpSNI8Ye+p1v50ut5ytRrMXfyLllZ4QCKTlKXyhIMCgjbLm2CojLBt5cUXELORRNWFHXVzneNyZWKwJLCmF5atmwuYVd465qwKzn8gqMX3w9O3qYfF4vf1blQ9PesNfd06WX1y2nElEPUiSUEqrGDhBFYbIW2c1qLX7+mb6vfX53/uj7zx7MVOftltMeaYIpmtaO9o+qoQrAGEKpOOESL44Bc1YBG98gvX1zeTFK/UnFgTwKfyHDgzhp7ADXCu/8aRMRyNmlbgnltiJHt3e6dlif5zMln2Z0WyitD3IRmskTtgRmCI2uhkEBUIucrCms8psPsJBHRkpSvvS0Uwtp7aBaLRuTIXro/2AxrtodJ3K00fzRUVjXhBT4IFKxTiQh6wBY0jQCwCJ+DiERa7cEwFxj1YjgYTK6dHnH/7Bywd/ebJ4/WacKhyCgnbldgPImqp+7ldWmTu9wx0aZycHE4+0HCSYiw5NltlSD9uRPoiGzBVGhBdhCH6UQ53JQ0IZvo8bDRQqKDSm2swi6UkGSPhxGVSpyDEdO06ygEdBYcQgZ8erWLf2gj0CP5PRAScPeWjtbr+voshpn2xNtzsE5t6p8Ey2itEacMOz2ucxo8L3GPo4JKowVBMPZVh7tgD0WVnmwxG0wmLsztO60NoKR5yajLrwI+GGSfJ9HUqcNG5Mt6Q/1YdVMdQFN+E+YqAqjYAfZpDlTD+QWM4PRcRgcrLejx49Ga43Z72Th/2BJ9L82Woznl153Ga2mqGf4yVsJkSLpfOos7e3KhfY7Pzbn37yv+51n551b/Kg2jzUKVYnCpmvidGBEr0SWAlrVKcOk1MQqTNnVnznry8p4KqzpoGn2H6eT4BJVoMEI44mhsCkku5xgc37daNhg8VgPFkcTxIDeWpxNDw28//jvXgZ5wQz8JjLF67DUpxJjqVVJN3Ev2aaA3WSkzoUxCNJGYcR0xPxXvKlYcBhlkV9EQAH4SFtgXvpSFPwKBX4Ten8N3Lr4qJNVzRACEIp5ACvxNmZB3Nw+uDs29+uXN86ukZ0SmHEtkevegXfkWJYhkjiQddGqSmbyZJZ4Nvq2vbD+MvziXNE3ux8FAGlw3a5w83GUGwHAKlMZwzcmN7LRILvdGZYSndzMEI1W1LchpFxOfIAK5qI7jJFy6HYYwvyfOYQthwbgRCqH/TDe5Ert4vAZiNhuQ13tVbPOQMcXbU2HousQNuDWnAKFSz00imcYTzJ4YeD4Zozy0PfM28OsmNdrODCgOBqRxZlMpxGdK8eknEzXBJHlBTFA35RRCxD0gH4XPQd0Y7nBDSSHR0JcmEnUIQmvkl5CgpasMYERqrSOpvWWqcf9OtffPKw2f9f9d4z7z+t1BdffdGY3ZJ5nLnXJCIBboTDKioSRZvDV7PdZ7/94ttnD/66uki6PRixTx/iPPc8/GMtg2jaAVt5Hcl02oSf4qfN7e1uPEFnAVjAGlWcXmI1cN8fI6Z5MmJaMKnJiJIr441WbyYTy+tDBaWIIX1hUgiYM8eVmKWAtZiSiIdJG0DcYmlBYy879AqQyyXUQXQbiIq32G7LrAUjlj8BscA8upFJiTKJFEJG/gfkgoB8kQvBOs4YEtNY0Js/oYjRrGxRLAe3EpsW95M9sYktrbTaJ++/d/Wbj2zAWl5PYgWgleUqHUV8DF/uBwUQJqw3mRhECgGhYsHi+cowr50syKtodqhzp8NxJLh4gRKKh6IeQSp6KaLuOWVJATHjTkiL5IbmromUC0ctO0SdmkvM4+nJYDZWY5fEtayPhLMBKvuxHGOp0c5fatjhXrZibup9z65r7j2KcWRNyzYozyoFMov+spnmYAlsJwgDguy2F1tvZFENcWN1FhaFMqzKcqUOVL21dAjth+WNLLuYMgGB4owtugc/EAmUYcKxhJKvwhPaT3gSDsU+IFnEgVecQ29zWwlnTDLhIzrusk4UdZLnpmyrw6tO69G3jrsXnz4YHP/O4e1ptfbb/mj+m9/sFpdOwhUyG4KHdeDnbj7OE22zYtf84mr8D77z1nln+1wcfJ8pEiR1W9zcuAEYzWU3D5reYne9naQjFeOhUR7BbXhReQUo8Z6pNZ9FSQWgRYeZTvhedCJthmGsB4eTOGNXcZzicnOOmVIPAAH38FESLGYxwIkHEPbyKtMKB5grEd86nnsyiajlKr/AJb5RoSq6RggznCQwY4WgIwiJrYqEGmAEh+HNN/eMKebEPfhUeOYyA40qjogGa/uNNVIzrAmFbYFtNB9++IMvfvKzzvWifQuPLBmeYFfp4r4jjMzpXeSFPkgEk1krBdK9ORpaXCFnQmXfjB4gX8GmD4Fcjt46iBp1xxIGM0WIYAXJ3YNs0ZLITXd4dFrWWePlwZ8BeKYBDtgvJUPv+X0kiGxYeocdFfXhmZSOLGVdznMoimg488yz2am2/V6tt4eUEhLy1+4Nl+s8WDqbaakrXTv4ZHC6aVjz4dYIDJ1OFQNl7ikarQpyDh3aRQil9ts8XQYaCO5viWOK2KJB4FWQHscXyVwRt5FPmLQ3JEAD8IuL6Anev1nnT5xyqDR76DNXR1S4aVFpXHUenb9fW9w8e9Ts/Qcey9Ft/s30+vKLVfswJ5N6ikMvw8lNtIiblefDzY2ODx+8/fjrL8bxK0g3WcHjOJpBe5IuMM9v8RCzSksphrh+P53kgYyu5QhGU2obPFyOgJiMVdFKXuO6b7AJo3REN1FuaEE5bQ9WxARQx/V845GJWd1FSPzBXuwUZURuwnU/ovS8TUMey+ARCyVoDU1DWUOARTqpYDmIRdcCkRLDGGUM7f3nATciZDQRGKJFc4ULfudf/MyywSSd8alid3E/ZoYKyhIBBCc6NXV1TZURL+jdxedfDfqt5ThLIMXPDZ/8FHYZoAyAOLaMHoVSVIzY6gxBueqUfRkHS04djxNoNmwXd+F4saLaIvuUwd4B5ckFxyMKrQWy6GEkQXOoSykaZ9uD06NMYuL8gMZBToXT7zga9CJPNa49reacBKlK3gsRobiZV/XzDmBbLRZvphaFXPWwTesrb5MlW/PjI3J0bXYs0g9OZsiDzHSmf7NDeyXD9swNUz642/G99U1bWOxxHKxbYxgL/YXxqVu0H4aVCnKiUzzqPSEacvEOG0Lv4D8RIPnwJA5unNVRPlpsfcQgkEsXUS1sW5QKkHEYJ57HWL/YXsDYzY8Go5OHvbNe88/+2eHq+fODLcNcd9VGTB9TGyVKei3dNaaTxVvnI6HYNv5nfAy5eGAJp+NBBoUhaE7bhfHiZk7nPgw4cSPutdkVqOT/8qYIG26F6YaYBBHCRb3T1Tn5Xqkez1iqysOypnP+mLwYJZKchQs1RhbpA8594EPnhs9aMN10jCaoF5UZqXVXMMo5o1YFlLIowrqAnI6IWnVZHI8ieKBiCFwIF4CU5YY0X5KtrsqsvdMPz5FTVFpJN+xhZI3Wiw9E+N2LojyFi2999/XZz0/3+zezFRLiTrB/P870TECjCph8gKUZfa+VRBXKwWs5KNknHiS6WawqrSGSttsK6x0QH6w5ESGp/FwJzU428zZwkixGQJzXdvwlLlmqQkrRRyhmuAjZFnjiuvF6Sqw41cZFBv5gw1/zPGeROHygiVY2Mi32y8V0PN95tuXgdDA8o2JXKnNwt2y4i2YJSPVOGLLCRnagSRIoR8zaRtXtG57MjAPTusfNcnHX6rEvR0daO9Av4hBNZk6sVIGTVuIqRM1HaYReLqB0o9DCkcLn3EZ+fHB/SkkW7P2VG81Z6mmKM4BhpB3n6cMFiaqf7kb15mr6rsmloG3+8S9av/31R+vpRn7dZh01ane3k8FwgGRW4+Vyvv32O+L47S07G78rsPWX9TJ0xHbGnTUkZ7rwuhzXNR6vV3P8R1cmHLEDj8yAN5TIxHijMCKaZS6xZWWCQWLJRWbvjviCr12Z3U2kA25fX3UfWFXB5pj6tJl1DhKGAQVD92Fx8Qu0r0HaOH3ohVwJidNVIB2ggxZxB46onih+LYaFKF3SW1RWYCnzFqc08Rm77jxoHpF5uS7jx4/MPwo9jdOtBCMpuCgFEWbidT5Ys332zgcPv/PD8eEXgzc3s0nERy9IEkLeox9tTCjDEek71oY00Xd6sAMsdFAJCgkOnyR+89WWRez3ula7JdhEnxZONBazTSQ1RP1RrNEQdBVlFz3pwBpOAwg609lktEoAIjaUhIL0Vmt4cWJlVwm7JEK3oYBHXUPPMDrtynS2nsw3LDLBAAjPds0DcDxq0qbz+O7AZXkzjgx9FAURh4WdaYF7il2T+Dc+IlHzrBWO1X63sjXyMFu+vLwinM4/I8H4wYjYL98Jj2AF6TUX4c1Bp5Q7QqAYXWj9HNMDqzJfGXadyqnoHGO4CdFDGMBN13HggdaGmRQBsnrM0pXMZ7t5u3rx5GHrb/3tD/RgVfCrX366vx1vFH1IOCOJQxTF9fvN9c3tD7799uhiYPN/ShTNPtiKyqJj0dtga048HfVdLam2XdoRq6uC5vR+r2vdhfV5bwzYWwAZoQQflzOjeVHujOKGoU74He9quli0J7runw6iV8EwmAg1tFI8rdQMY0La5vBqM3WW1hzSqesoYogPxN1xLxJAgNAoFRrx5XzpB5mYsWjWe8Wf71JMKAGdgYOOEfmIXDFAqBBTHjwbVMhROgx0U8OA4obHz+gNz779vZsvf3HxsDcdkwBEC3Wi8yJ74Yqr07oGDYrqKwXmkadCE0C04rDwfPIU8Fgpt4q3cQKrXmRQFK4pRFssnDay4zm0ak1lv92+Y5XJYNnkoF5okwLFLMNnAlG4VkQiZopOGjbR9lWwtfuSbllcS6xdXcl4rRfbr19P7+4sQnOV1sf2oNM/s7VFlipM5J4CiwA8mwQLETiutL1sjWSIp09wF+stZ9N2+o7stG68tINWnA3o189e3r0a904elep5DkwQ7Z+4J1TkUwFEUkdZ+iHPKczIf+LCrOzYrI94vg3EI0NFGa2SyI+PgBNJu8OCVzHrEZiQPdmJuKwSbFPHZ51Wm7Pb7//4nK3zuBeVZq8//uLuq5uSSheJucsBX4Lbqozkyfnw6tVYNl0MEKHiNIZ3waMIpDHq5+GSi81xtcjzNIuTHZSXn3CYrBoKy8uG3OM/b2PjCO29r1KEhvFXd2DBwf7X1tYJvnbkrnYOvHfwlon3hkNxXJCX8hmSQxVBuOEkiKThEE/DoIQ9RcwiaXrMIkDAHnT6C88KByxiM4wBXwGvG7OUByBBunfMnZbzwvVEXeaan0kY0q9BpzHTiUzdw5fkGKTr3ckBSYDEoW+1H3/nB1//4tzRwc3u3OI1ohGXiEBagHkBvU7xJmYyuRzTACOVmEpoyghRhZb1pEVn1uRx0/WGc3g4t04ynM/UMso92m4+ovc38q20Bs+Pchfsqk3CJSEQj5UT2HFSekUlFQD1O30FCIN+n+o4fXC+7Hawt6akkizUNrX1C/s61EDUPLxrNRO/WgmGft3DO/II1DnG7FxqDhMlZ2dvdzhYQXm9p1oFjRJX1La96kyeRHnDRDmT54x8fWPJanh6UR+dJk1R70ZXRQ1y0dqeIZMyjwaDizXIw+qGhdiUY1kJgPEnt2ejG9JltYGGl/GkDcwwG74IT+TcEDVRECZuBjQCg3MhXlJSx03t4lVzdFzdfOfbP2jdLHbXL5403/uLyfz61dhzwGCB/lH7KEVwKyN/clFrXtoJWcuTDAIaKjQIlqrzhJ3RADN4xIvpRABmuHCgv4J/TA78w293lJ9AJ8ApohBa4rmhZRkeeBhEjuR6P0MdQ8WE2c0V+3Yr/fqt9zonJ2kpQpAmdITGSASCJq5lrcKr9wWL6c9AkuspghFTQ6sHHrkf1KUjcnu0f1pwu0m5OMmGNByNQ8qKhk/PiJ1+owZ1kp7cG16U71CGU5hV0eLFMad0WO+k2zp7Mn99dXo+XK09KybCFMgjAfaGNuHwN62J9AzDjgArM45FkdDkmGV+TrvZ1mYHacvK+VCcyR8Ou5ttNyN/CmOzU3XWGfQ2OStfyISqmYhkAh2nblktKIejMehloXfLxW+Mzjrnj0btbn1xWJ11hx40cVjepMj90JpOFw7RZUaS/VAVYYXMISCciI2dvok8EMqmDQtZhWh2RbahotPsLOdWDGxgXHcqi1Zt5dHU0+vJ1eXt3dW43VG71FPgeOwPpFUFZBRgtBY1jWOoZ30BQSE8Q492YxcCJk3nFEhWLEgPWNgMZPGNL1InGzgGbByqwihcUYea5z6E2mEjs0Ct6Efr2W0jXXJtQ9j48O1vf/D2sPWTf/PTu28//MVqu5gep8uNlK1bVW+PF+uhYgen1XW6SsQVqOOxWNgD5WnJpicZ9vt2cldms70HrVoxqKc6iPjrMggtzAuQfKjFsDoACe8xHWejYSMHcf0seHshR0MTrpfLu0NnNFyNj93hcDm+WYxzsgtm0yxaiM9OXUYEqPIi9Pc4DJRCQG3He8kx11nG1rL5o1TSPrRH0btu939UfNxtSz952ELeGkUZSnzTeEbpJNqbl6BvN8Fl5maVdoO0+k/AbVR5LdlYo4tloSv1noKT0cMP7j76jfgVtlNpEe/R2Gg0NAwddG82CTiwWmWHt8jnKIecup6z8ulZVTouzenzrEy2kjUsTuU5K/WGyiuqRwgyqncmkwlNsHLagCp4j4/vDyxi2krJ1CuASeUqDjTr5xcOqGk7nGPf6S5s6aB63txZ82T29o3Bl19drnbUH95QvDJIjn7tcaqoKj5CwiTWogR26OSWbPvwpQ27zPxhrunRwGNLZ4s3t9eXd+O7abN/cvrOtxX8EEiLPN5mx6tIIgvH4vcwk6AnV0qshbNREfFtuC7+cjm4JSQunajySLH4/aIjl8S1GII3rvZTgJXDSrArcCyZ6RiU8NmPdY2IXSKFxrLeeXly0dmvnvYOP2xsb6xeH4+/+fUbWSFg9ZzJ2WJxO54/fOt0MGhPJnRbKVmLB2DSHKVqvdcmA+vl3W4xV6IcFiYDUBAUaOn0nr++AMxiHnwZKaAsCQWpNPLIP85HRKzBEBZaiOLhRi+yNWy9YCq7q8ntrNMcjEbSz2ZZAqXYQ3jm9UWU/EiS2hwR+uU0U2+xiQ4PyoU78RtjPPz1ExmKTPJlESYejBtD8AhuvEeo8DniRr0oq49oQbj1vtyO3sqcjDVcErDkBVXEaietyYQYP1DzWy++9YMXf/Vn5wPQOLy+nRYviH4mp11AOuwWwgndRtUaGQvlgGGnSm0dcK8/s4vJMkErlaOzEV8421C2ezuF7Od2kNbtzZ0RngxOQMaxN9ScZ1BSjLyx2XJJl4mBpSDIPBApVrPBxRrpoddtDU/qDtaWbuZ1J+loaeowfn199eqy3Rs4kcb16h3qWpAywaDNrjO0zQPd0CSi66VDCS1yVYTlFXqzNXI8fnV79eufL+5u53PbOk4uvv2j+vA8bScwlyo/bhyajXH1VaXjMJMuksWmxvTBrKfewnLSwOkgBQYFuVmnkGASIxXvnCbCIcoA6ulj7KA1qQEBbFxe/DI02Eouw8vk8OVpfF5gKcII/GizSaf/7OLpYd45e6fy4z/mWWYB/Ze//hotHImj/ElI1K2tTzvKOm32pXydF5Bdig4T9lgke9b79dribrqbTsFF7BBsF+0aTEXFh8+BetScTwJ6sIgE+Qq/AxNo5kaQ5Mg5ZYuuyQmWXnzePA7ttdBFpd+XnXUqiBUW883E2HTEkghKVjRBT3rKj/IZ+2y8iKMoLxG7QU8oHgtJ0C1K2Lcaib2KgjeW3FzGG6oRDtBOwHfIAZcsu86BmreR2AC2ZQNDSjdTSOKKfuKPiE3Gloyosl/AHZ4OhxeTly9G7eYNU0d8s04nUKbJ6ntnHO8WZbGC/omWwHIz4xJyRF3M5IGBoZrncj1D056tFyGbY5z70Z88452Hx61M0jZcacHRaOBoCqO3cchastQm44pENGhEkzEaiAL6cDbjsqy36/nSUoOz3ObT4/XLG2v6Shd21qH3B88U7Qz7ORJgoUiua0sJ20RHE/jgVKCxnw8bSyUEquqW1y8kr7++uR7PVt2Ltx3k0eyPap0Ta0xKNnME1uY4rB83q6nFm0btVnjR2w8tRqjkl0BiCSRuw1BksIjLxqFjIMT+yf9QWTv70PL8mTDBN/4RE8MoBkn+JgLDKzKypDVwLT5WVFeYFPzlk6hdW92z5EPdvBbBdi/O69WLd/c/cvZ/L2tOv/rVa4ccGtDV5YvHg8YHj06cobKtOt5n4zxIlYkY0jvpZXlwOkU25wlrzUR0GW0WeEe/U766peV0HKPmmrg7MSJaiKBGp5Lt1MmWXW/R2twc9ViEDdUCgfli16zO2d9646TZWM4XHuHXc7gczkdoZKCDT+QIKDJFMLZgl28LTsA7iIyO3ySa8uM35zhLqikyJJD6Nz4ocyV9wW7kSwQjKISFelEHCfn5ke6gU6VnghREza+wZDvVYUZSIlt9OAwJK7c5S2nd3R57w5Oru6lH0nC0rLlSVsRTkod6NnCjTwCXxrItK0adJVFqSTU6EKXTjZGTG8lPEotsL+yCBjg4M8Lw1vNJt9tBcddxllQiioLlpTFi4ZDAMqUke2w3HZ3yBBxsuLy7/fbD02q7O99WrxeLm9dj8a2aKmRSgoOE9j2mtHkrfdm2nZdPaW1S7+IIPk59f/3wEZIpe/O4uPXNs8+dBbVvDs6+88O9p0lkTZmoo5q2+D9tJz8jmq0r7mm8JVu32k7qFTXd9W5WWKkUyihRD5fSbRYUi8tLH3AITBX6ixO6t56cnKtEkACdymBopQNS7FEUKV6CASCyqAwhKMFfhKAYB3owZI5pcSGhm3paTvdi8+D4wXH/e53KmfP1Kz/567+5fHPpyWfLJ/32e++8ezbI0UhbD81ezd3bPD/rnJ3ISU+/+lo1zCwQ8NgPf2lzpAY+uKKPCaPpB2RcVwNhhHJYUPLRuE+JmGR8OJeI5os7n4o2PiXxVCAZVcrVuNmtBwpLrGbsTze7ob3yppPtMiaR2VDtNEFkyuyKbo9jrlMagrrOkpa+8lwSNMg2Lg5XSAL5oYoBe5UYF6cim0VfRIvrPIY7i13aY7ncsJ2bIkk1q4Az+ieqKPITkS8CntX4edit+IupvLjY1jyms+4pJ7ObsYsU+vLdGjUn6u3U/02V3MpE3fcg4WHa3mfLnydlcXh2drV6Epn9rJRg7De3sZa0Y5aBbcClqOm7rj2Ian6ykqpgxF9oaLZzwj73g8zr157G7CeaDOxYWnqKtaM2nCHbP72Zrj0VOpqIZ46Cokk4VBrdsVU/PhjzwTvwmOhGZaUp1XAXTcXw64fDytUXqze/eX55Pd71Tk4++K7skhEii826eGMpAMfjMadKhQpa0loZpBF2F7sn7cp1r3arID56HS6jcEh1SkQhV9CQTQny87LbWXaOKuV4oi9ViwMF6zwVxHclYKnYwDa0MwKfGrrP4QDUtB8fwE9WbYIP6g5W6V4r+6/bg8bF29+qrr7XbP5H283nn/+z8Zg+Hzjust89Pj1xasfKiv4dZd3t9R+ctvpyxvRbjkWrSsV5IiI46IQwEE7RXo6gqQtbiCJM016qRozXopqJGk/QxGxQhK4l9alrtragGWbQKDXjiGjL0KIuJ6hlk16mv616JuHSoxUePbFn3MR0zQ/BbbpPRkyqWEK7DACA0lMyu3nywNbWadPNuokbZJGRALOL5MQnigyQFoJmEvqXfMj+/YQScK7czedKHkrSMoOM9ZWPX6f+zMSK8JA/DqnJ4IZsmpURpxCPmicvRcYrewXDPxo6ROfXebTHxUUq4VdzGUw0KCkqXZfIBtaT+Nty+mDTHXEKXMQupiILTnJuabTa2tFjtaVHaCI4vBf6Go8rcQORB/b4GqL8UvYUHx01JyN0NhzUVtNe/bEzVnvDpsOimBvcSjwDfQ4s62a5TGZfVbkAntAqGTaQ9rL2wTvt+ezq+s2rN89WX7/YHHunnR9/q+H8Y2M/Ko3jiRBixc+cH8kYk6MvEpLFw6G5uHW3lUPfgUSH5airAps1zQpLXHjWx/oX+xtoBgg5RCdOBQJnbroI/7xSEQUja4f2xzc1UV4EgmRZIHopPjU2G1G5ne7AeaxR7Of/8kMTiqojCXY61b/uPjie196uHH/nD+v/xf/p8N/8V/9qfOfZrvvpbOZZHoP56+V0eX7e65wOty0P3J7eKYPrdsaTqQSY+RpNuApKWqWjJBCEs9ggWULpkkczorBRJgVtYnQqUudFZWeTkunF6CXB7rpktDJei/zlJBrJD8fQr3f9+bzdnp+eAsHJxfnJg5PET+YfO0AIQDaOu1IWip+iUTnj+wSs6ThA5lQERkXoYjTuB1ZYV3xKute4ot+j5tE+aXXa+WivkM8d3iNDFslyBTMXmacskwVycVYLuauhaJ2343GT8jV3z78UmNIJ3J5hv3t75zT9nALEATt2E6FU5+7OniGIiXAYuVS6PewWIFbZEV8cyRCE4CWsQt3YpMTOnBNFcfxsSkhBhRxlKZVh4pIB98Dg7PtdzUVB1CdPxF6o6XjWPR0tFtMHvaZCHwUMi0FXya1iNwknvjTa2pfUGTnx3CbtbBfcrSZ0iHVPG3sHlc2bT198+dVnnr+3rz/uvvN+ZdCPpx6tql4H86kie9cCyuytVGBCf+7QJggABcmtxsxid61u5UBvp+3OhFZ37gW7RUwFLRaOMZVEl93498pSeiewhZSiZ6EDNyW55N8FTEkLxi8SQZaKFJyNQiRsQTjlmuHhS7KBCVSNNSAo8Wd8AenrauPF4Hx7ePdb+8Z/+H942zbcf/r//KdnwyGVUfNs1UGn60iJtayAizcqwDUpCzh45+0SpznQdmFwTv4RIqvflMcQLMExd8HEI6WE11hEkDFWWW82foEIllPxRW+qfLcAFihFF3OsHNhPmSIVbBAjTIJK+cr5jCW/38B98eDco61RK8tEnpHBDaI59cpNjHZoseF6Tv4xcqVrgW80QPwWeiRei59QxMTimmdNytCLvS3BLMffBcoPYbgIG33P5KA2lR0fDGnZLt67gh3L+GaahWrldPz/X/+ku3t2fVha0Z5aDcuQsswlsLF7zmafxXSWppAmtsjv6AQspA/oQ+QRyBIzQkYU05WWw07CIsFvfil0siORVsnTGYErgyMLbfKzPu66rcqg0dlK7BeHUxrIoOzCWze720b/bjmmEO6WAMR0rzzRIg5+YlK117pQG8xxmqpdC+em28Pt1bNXV0lunj/ovvdupSNfFMJmYFjITCMqn4QXI8+bMkGKDo04LOicsaML6fBZ7dUdw3cQBh96G4mnHL3Pp0shnb0F/CetFnJk1kAfVyGEuNej0VtJP5t/9om6OPstt7zs6NhEeMYUJyWcKzcV2YFaPyG1VSBsQyrg8BMIlG0lt/0Llb2t+eL7//73Pvr8Z89f7U8fvLNwXnnTk51uT4/qIhyI1CtFSO6JVWIi2Df4Qf1U1TU9v7XD8xOvKVUpC3lGJ2mThw3bIALF0GV2kQyeBtGTPLTKxr9Sf4XweCLLhYh2TtQ5uHw31i6b4+I/gE63v3pzOWs355O78ZtXFw8e9nono/OzuH+pnIuIAUZoFNUdzcmhiBzkfSjhK61isGHF14wad5MRET4cwM+cWZJIxUATYcfJjF/EJSoiFKqnGcJQ1gEwiNHgfIo9eWTS8ATvxcfdlz/tfnD2k8/Go1pfkcx8nnQNfaxT5wMSUpWVkZaMJj6sn8QYHA6UoLXoLylwes2sFEkVzyzBZZRQtpY3tjvPAQZpA3F+TFxBi+k7njp/L7yO1xuDlUiAvCiEHg6Hi+VKSv/Iv6ViDocOr7JV7563Z88XtbXtOEm+NgYWmOnORbdxWHjq13S9v93eXb1hxYYfvlXvnToKSZQK/0lfJnseFDJ0UsjsTbJ7arOZSeu83FJstrSW5SzHkO8aFihogsa2upiom7PDViRpcYByJ+g5QEZrVFQoFTIIIMPWqJWAlYnJmUd5w/EmczIKVri6StwUHhp1eFy4XBRdCux4CkQoa7nuir6Lq3AfEmBica9oEqSv7q/k2u0U6z94+/f/cPD4+fsP118ep7O73h98/1t/8uPRf/v/+tlXY9Z7LSRY7irLu8lyJmGlB4Amo6k9mpsdroWX2aXAdPU6rV4vpzx0e+hjEyOulwXq7H0FapxuZ9Eqwg6UdvpQHiDpsHliQU0jncyVilErofTmrLnazSSKR53jqEffbs6QOdkSuWDkubfHJoqV9CJ+cB7IIALDQ9pP8pM6yVu9gA0h8SVS0HugHC3hCq5p3Bu3hspFCrL4b2TRfK4OgY2LGsuqXqxsPE7K9tCejY+vvuTD/M0nL04fPdqP93OZe5fwCrn3fAIZdHXFQX/a8UKDYS9drGVykAkLRRCHwZTbtW/Jp2WvadIkDi6xaEjNxMNUNrKyHMWRly9hSf3YBraztFJrPxg5jXNuxUBip9O5m81aQ7hf7RzWLMzers4aDhnanA+E7LO78bTR6aiO7Mk/13ftKhs1n9/NJ6+uHYTffOdxU+WFLfMJuONJsDx2A6NgdKl5hAj5IUX3lpYAqGQzHaVmQv0c7mSZabFc95r16XIl5zSkoy3gtHt54qlDRLb2AYX2PBXNIHeydSFtCESk7b5sNtpqTJGA14Sg+GeJwy4c59KKtCNGeEWDRcllu4NBxezzb3GSLssSqcsK2Q08Q/YP4lxTW9YaL3r9zsMP2x82/+MnP/vB+auf1Vury+O/93vvPzpdPYryuu21dy82rUm1Pl6XhckEbIExlcNakTZ6GJrMXZRqczd74ximWJw4HrFl4RRbVz32qydxh7sDmU7NgARiWihlKWLOolycRZA13WQkFDny3dRmoOrV7jDtHca95dXd/Hy2Gi8GZ6fy1t1+D6Et97gUMtCHHPDe8SD4pqJMPGsOEYUME6vusR+tce8BJZgMF2Pj7i1CAgM3mmFpMebV19wEyX+wJqryVh43lcpm7sZ60xnffv7xx5/99vndy3Fte8f3mUoTpn2K3vhr62szon95F99YHgwqfUT2mQUjCEMssZiyeg2Hbw8IYc1BcaVOlKrf9HvycLH6wjjGkwKm16jLJHEJghnvj+Px0t7tRw/PHVXhUT0L0ufBEIOeczL5PjIV563jeDLnUw7a+4lHsDnst42IU77/1as7ZS67eqvz/vedAGEYhi4KAUuK3ZIuOoEatvsEv72j+z2Y3Y5D4bnRctFoBOCIkowDT2Eo+qg25s7ZavMS8WPf3u4Xk5tGf2jV2oEDMbxdPpx1MTcnD0obFAOgjdJTNvOjT7Y8pHcMdhA0NEUCDSjLHvY6lCJtdMTwkFJW1zNYtRjFw7QWRcggsx6ilujecBhHm3K12/NK4/GD375oPm5Wn/Zbs6+fT8bv/ebzXy1vJeVbn30yWdoY6mKBk75SdCrtQBNYr7AIxQMDwqRQkgFQLUgOOZdFBK3TBkNEFGSiP4NSe+SUXCQocaxXlmn6hk02M7vkXrLsRf+ZcmSemlVslrnvHA5cmTPU28mrq8H5yeDB2fljCaKeA17EHYxpVCxmUABYI9Gh4IoLbgN+3KAcChLlQjf61mt08ZpSS9xGh0Vhx/bGmUgAci9IwVxcjEzaRNxPiKIIHYnn+BZ1v7vN9Ob6k09fzW8PqprW8+0d19tAInr3egKT2JHotHvuFOHUcFJzJugtTQVeNlIZGxaiVIpfJRpi8nkV7nNUscr66JO504JEovb21qrnJ6PJZDkYnIhlhIKeoTZfLG+rqp6zJTTpYF+IEC0B13qOTGusloP6Wkqj+2h0dbmwEnFwkPfnd8nEtk8Gbz3yYHZ2x2nloUcsZjxNo4dxZA1qjBi5Elha0N0mMMni6P3kbD+Ik+vWiApJtqbjBb3hiB6PClI6YnXDBev12BJJc9TicNftn8nJ+c5DJMryetnRlhUBJGET1flhG5sOMelf0/Z2JnDE1YDGT+KWSA+uYbktWzZ6grghBOuxq0goTcJBUsFfrDB1cdgKGxVvt7armrzvYHQ9aVfWg0pt9sm/+cvzRvP6bn9lv1LrdOYkP0pW4Jo1uvTsEBXbYcVgXDQF5CwLRpUgaW/1trzgjlD7QRuM3e9IArwid7Ehid8xvCzDYTODmHIIB4QbbR7sm7xAzp8gclQXB1QmlJOzUFDQUL3ETDuKwwvbdM7feVuJYm/QA8ucGqBDQhmnB9uyVIJOoYbYACujmYxMwwxjxIBfK6p2ZSQZbSiL+He8RPTMNaIS6gnZSyiDxPSz5883rZgwduNXl//2X/5PS4+hn8069L/z4YV+gQ5hCX8MJ8JGzaff0CO+U5HEjFS/BnmPcWKQb8M0KBAlqT3uO9ivCyHOQWB+JD5aM0+mkuSZLOjkuxSm1O+cRF85ng4HVJKdrbPqpjNqK7fkVImdCZK9f1zxk9HAZtbRqHWcemL7rmPBcHecT9eDwduDx2/bx+4ZcGBkmhFBWTCnwaEBC1XeR7+T2GJfaeL4IAQjcOXDtBLF45fvkZGYhpic3lQfoh2OeDRjp38xnLy5Y8CwpurcTEkwTkoicaW/lEoWESw9ihGKG4pOodmhHJEpi4YZKRaXE8mTWnQDKCm64EgmkuQ+0XVIWbWNOItNOBmOGhex3DvHmKPpYMttxxn8q0XPgdKLWWc5bU3e7D9/Xp/Pn43vXlXOT5+88+bF87+5U5nQHraP5+2clnFtCTHrnUkXEAISyu8s7EqdWHICnLniMRudLcX263T6HSiOe+OkXhrXmafUaOEx70bKwyl9eK8RsuCwITYhh61kxU+Kuhw8AQpNB2ewA+iM/RWFMSW3yyg7B3WxviF+jVeLeXNw/uCphwc7AV/4wWIHRJjntL6oEh3BY6l3SHd6MpGMHoWQPFk15MwqY9lBEhWXIogYLKKCLbqLTaKOiEWxazSZvbrPfvHLj/7qp2+evagtZvX9fLZvTDyZFMGLvqeugv+wKilXrzWhxawsZOawi3AEOqiPHY+3GOzE0lY8U0vOvO74Joe+8hcyIqffEImuR8urrVgh9ba6ItCdXtd87Zpf216JxHuZ1pYnGdIdthKYVB4ZujpoZjxe7abL6ytWRLxbWbV61QeP92ePZ2UwuKtAAMytPiRiz7ggMf4qGRCrU0wGHCc722lBzinljluMxJQnSLAztgN0le3Ikgn20qANxRYCu87kP1atyQ0uTsaX1xSOw0n7J62K9FVlq2pDUjCiyk90DtZh2e71hId29xQ1xI/hI3EuzC5GkFGwMuW1wfG84pcag5+kPqUUPJMm/qZxeux3fzPpbd70l296y5nHgQ/Xyx5TaIjrxezu2rYjiwpfv5m+mOx/+unycj3pH+iGQe3keDqQFUgq88VkTNFeOQKm3klxIqBTmKROZIbb0stY7gUBdZ4wNlGYTtdgCJRNdbmvzjlWzJMCSorXaYe00qYZX8m4FZdZ+KE6coRjlA1L6Lj2ZBmSzRDPeylRkmSAph1l7NQ9O9t0yA7Nj6t9Q8Z7zPBPhxcPTh+eb0fD1pAOYn95xkiGmUwVEeCCHNQcBH1x772Law+sfmJb4zDiXKoVgF4PmVpMnHxfMFyUDh2jFKRRX0y+/ou//MX//Kez+cqJkGs7Gzb7y0nkPRAq2CnNuklTkFRMAUGSJWXtHLOuIiDr2JWzPgNXne5UpWAsBDk+Ej02/PzC0txepKM5m9qIp8oMrZ3z7lqPj7EJ1qJEjh6MbZeHkFFdrSvjmGIPWT9OtrObicc8c1fa/dZiPDdJ+QU7iBfNjiNuh6NTkGIKTTfuHzrk7OpCF7ArxQeA70vSycGIL8qlSyxVVfhNtVEtcT+oua6cYWO1yiFnKrk5R9oj7cTYk4Q9Dqu6n248apxpoTWZXesUvUpX3mJ5PedMPHl8zsqwYVLk+8m0Cn7AHWQZFVxHzMAC24zPGDymKodbZN58pygn8gpE7dl0KAe3nl5sbh9v70arl/XbV30z8dykDadhf81SGkOr9aur2+vJsTF61PzOD3rvvtf4Vz9t/OS381X9rnp6etqpnNbeX02/9yhbjWeL6s28+q9+Nb0Vu1vizhp2yqTM3swDIexcIl+3xVchmPwjQ+cvM+C9UTAYtVJxLgu5qDkVwtIRsqscSf6oK8CIPJBqrgmTyNOKMfTEBef15ZB0GsMVmmTXSpF8vGS8sM2WgFRqy7rFs7vx7PXr3mh49uRseN6v1pfdwbbd6WmMpsAG8iaugCclkFHGZW1Erl6XZsC443NxfbJQzQ3h48lrJfEmNotX4NaDTLkysdX13W9/9tPF1WWisoNtPZUrVfwSsLikrfyLks9Pbk1qn3tGqEad6qhHQ0VImDZeGGbKZZ2ous/DmxMB9wbyHAJdJZmNxWzFAiXltpv2PY1lW/E8QSc7BarH+ny6tIu+NnKCScv2AbpZqCCcsm2j1+nK2i1u7SSTaswao7qa7unw7HwwuU5WyOJWQunFbJtcvGXnZHCkpMkgmsBu4jIKmLShgHw1naclEyq+LHUBAHGq85A63GaWs5sli5KUBaWc5R3bX5wVQWtUaqvZpuL0nQHFpNy65WFbVJiKka4zYnfVoVJMQ/cgagaFt5sTALgrKVci3JgA2yGKuCC1FhFWuV79pBqhuLmccHQWLH2w/vx7z3++n72hCRwlfFmrTprdcePBjTqVi/PjaFg/PWtJfo2G7b+1eNq0O8iaSTKn/+GPv7P65OuP/vIn8zWafqvaG8x/8r/Ul5+qiiM9P37KnPZ+dXn46OXYFgL2DfQFWo7tBX4GGnfZZavTFJijONq97G1CPueZmLP5MJzt02xUdRIHmVB6FRonJW57aiSbniUWOR1I7my2UF/TljHjs+8b1k3IkLlaJKMYTV91TG5EiiTqVch63KT0++1y3LO9xgao7pnD5wYqqxsKEywXeVwIUHKEshiAcwlSSAGXiC4Nr2HSJ1nWEtN7kkXUNucLvxm7GH5MNgWB3KvJn//Tf/bFl182HTpCWKu1NwJM5aG8q3JxgX5R+kX3MzIYKDXAoDlCixzMWPmcZ+Nkq6p98DLJJ/1RY72bEXUOUIkAPbWOtuby9ge2eflrW1/yudYVZx67Rv8bcSZx3C9lzo5ymp7wOeEQWpif7oQlhMTiKbhGaXQq3bcfXnz4/m4+OU49CLvaP7SNZLd17rjAj4MMtugK/s1y4HuWU/AjuoOkMFdR/FkEKJGNizM3Jk+tkOvjPYWbxWgIfml9r2HYCDzqCEZjm3br6jqloLL0jX5bVQZOrGfr9rG3VjKw3/XOOibI2WblPW2m7iASK45RXfBfjAHHg7EwTEQFQH6ajswxUDAcbsRWmvBvbp6/2dSvdoPWxYedt75dOX1o2574wWKVuJzg8tuzvG15jzNpRV41lZq+7tngD975o9/92/Pp6m6ioGLY+J0f3/36r27+/F+091fz7fqds92wW310/uDPf/Vmusm+iizqmWiAEUWX5aaVUhOSm/WpKHtZJicNcFvV0Kcsgg2rykJEDWcB264diUQbSbM2aLOBFJBv+4Pe8OGZpsZ3c4qr3rNKZOk3RQuIGoODgnBikZiARSqIE9c+ka9V7CSTNpUS3dwOL4ajB1k7y9ZSJz3xu7OXfG6N6V5Bp7APo8tmFIrejwmpvETWaDF2gO9m5Z9ccAg9NPzFm5//9//m1Ue/WlzfORDH4e03YyuqWW1xr+YTMfg/+NBXjIK/egvhG1XP7Fw7gYGS5EpKgTSOtoWS5buNSuc8mgBlPEXGUtLMTkinRsmkz/fLeVkwqB5GAyURYtOc+2mBWLqTzm5lzWQ/y/6QyiSrrhWVIU6/UmYwaB6GTFyVVj6sbsZXXz4ftZ0dMsN7uyk9By7LUdEipi7/kBPj6ZOkhEViqcBPHgLVabfk3GMXsiYKcugT65dDoxDKZOusK9WexGD8sagLd1b/9v/tv0ysIyu3XfcGqfAWI9qrKW/nMODdfMH00ennFwN13a1+7exRzwMYjYqOSzTdH6FtFF35xyeipjIcGdaiCNkg7p0uYijoYRnV1V5d/8HjNPq2qjkFMumbFFUh7v06WxirRc4DZ0W7tJYX+ETKBKhZG+KqlyRUq7nY7r74/Kv/959uf/Kv//D9+kLWYN369HXjX/x2cTPnwFmWj0+peTcBkz2fVYGXgl0lkSc9WUrUs/6dB/R4mry4zdptrxtnIiVfRecatowsBZG9whZcJFyTX4qSJ+CO7ebc8mPWUh6RMzq5pL+USjQtMznSnf47rPmoHmFCF5Vo22zESqSw5Zklo4fvPT15+KB3cY5DHCejQ9MIITcsGi7D4bNiOcUK6GwG7sIEgbN7IiW8CLtYqFX9zb/+6a/+8mdfff5bD0SxHHc3W97emTqSlkFFCEIMiOCVsmmBToTADycUJPJPEAHrqtolBRSPmBEuqSPtD7PEC3w31/DsxNWUDOAPjuFOR7Va9EWq/UZnJ3e3lpcSLzFZfNFCzaqlA/jAUX4M56jXqZ4o8W3J6c3J4KDfvjhrzT2JYAsmCnsqahyOgwdyW9CfvClzS8cmPxaiY6riWuDhW1v2iFgnjYEwQSQNZroimFxcrLd8G2/cZNl9YhTjX6TD4UI2Q9RtZ743oiqiKLDBaDizpO4sgIoczPThw1PO+eLOA6iptS35RIgibUQSNnk4VLxYUHCUMWQIuG2E+R3r5WMiqri72jxHX/regL0w3CiW2HFekt9YU2xIWvDWpEprmhNDEGfE66Ros2FL6mB//MHjh4N/9Ktj9dXlzy+61e88PulUJrNK789/jQOyWwPh2opHJxSW5MVX5wbOp8m9aIfv4Swa7rvINbqWSYAozhssU0xtOExJlqWBVE7J2m/aTpiRSeSZEE4Dzl6QajehsGIlixjZ/EEdCL3a7bZaJe4qxwH/5XGwFL5X1lwc/+0EF772pumJs+vb+auTZw++/c6T999rDXoCNWV9cYxysAHqJQOPu+hBuJRE5j//QrrQDmr709v+dPz8119/9suPr199KUxVzDuZ7W7H7HGuL7T8BvvBA+UScESnyxsBA1tgmAlngCnORFq2yqBvD0MZjrrDszYtuZwtu45aOeuzKDQjwyw9cJ9fzOJgRVmdVrMwbGlsKTPhUQqpj8gzZe1cwmaDIPZ4ab1A/fH4csI5Akp7TDy0Wu5INDzat5dXc6dtIwJ9U4Q3u95kRJgptTboIaSAXpMjp2ZBbtGENIq8WeqwIFgiCqDH+knz0v2uTemU4JhjbJDKoZMmRASCQpp5Y84LOmar7d725PZgMF/dKsZWxzebBiy2s1P9bCOa5rRk2xF6EuK6Q0ML2RRj9iYXAYgAw0q4lGQsDyy9y8tgKX/AoHxl0LwmDeSq2GRTcnXGFHxFtmLx0gElVmQlfE9oy5bSPNFi3fcav/t//t/99v9+9+b62c1u9ezNTJ3yjz6s/vw3r1dLSmzQ6488ZsfaNg9uX10nhTPTQ/LWRUPYfWHRki2OqrDhgX2zk4NplCyzFEZSqcTKUuV6jjfblqp1NgFQcBi53cWOZDMfL9xmwaRccc0zR+yDEvpxe3YqZMxRiWCbgnNmyNqhYs4LcRSzfMWydbt/s/xkezs/+dbbj58+NYZIm/lrJOCNMkFcCpVDyNojqPA3a51Zy12+MxsvXj376uOPPvvtX3O/KBZie3trHwpM5l9sWWF00knIH0+GUaJpTLFFVTtfOHo+fIT7WFuJMjA9uRg+eHS+mk6mt/OtAxdqDUX7bHq71RUNOcMh0OLGEx31zB6xtKVeZg4j4XUweCyGvpQJZZtSq96PzcfHJOZytDvmCnZ39fX/l6b/apIsTfPEPg/XOnTqytLV1bp7xPYIcsUs1oAlYQQMNF7wAsZbGq/4MXjBj0AaDSBxBQIkgDWu4C4WI3pmuqe1LplahA7XMtz5+58cRmVlRni4n/Oe933E/9GzjaHppBujSkVl1AjxttTkcwz/8rMm+VW+NoPb5lK85FNQPZGYwtzYnc7Al6SEPKo2rGmDB+yj/uLhkxxKaBb6NOXDskBpvaSOIDj7Q5/gTay8ZTVyJjZTDgIZmxJXNNe/GQ7GalRudlp6VbRuKv2DLsnM5yTZ1mIYQYBCIaQsxD7mL6wV3ncAom20T0FG6ZyVhUduxfqKfEeL3p5v8yBJdYHF7JutdUmfi4Myh2KleLNYMPHlab0V9xPRO3d6v/d//N89+nd/8clPf3Lv/cbyav7eg8Nb/f73f/65efTKRJv97vXQg95UueXsmvLn8nCEi+es58YO7S4JAkUQivHHIGwynoKNZU9L7Jix0epEnkD07ZYnjF1mSFtc0gkK2dKWdNw8LkMx6H/BxUxPptWESJmjstOZtADC60/pqRaaAPomgL65mszFzgYXJ7O5Ou7LO7ePqq1WVReWlsHf9Lt6I8Edzxt3lYzWQMc0IVxXZ6N7q/H42ZOr6eLVixdpd6++3JTOi1GYpjBAcgQ22Q76v+CEVHTTysSw1StgjHaJMEJdglPupLMD2jy8dXB4uDe4uGJ1TMbTKnOH+acvkLmGaRlIXwYsECRkMpBzLbeCcJIOzRFBW9cqnf3u8a1dUO76+pq/3+yI4MCIXDsZOyv4CFU1G9xDHKSmqV8NBpmKXeQ1kTIa+tBCpj8EOsWMQgIqP4t6Jlug0XnYG1V5CD9CmCBSopMJc3hE12es8MqFMGM1Rx2SbUr72XgQaqffpT7itbwxdayZt1FrRUa1VGJBIYoYWCbvCY61Kn12ncFFy4RyIVwmQQCxjznSJMYlilqIclDZCmxubpzc2BglfrIw4FEeWGHav1lXqD8PEo2GTzxApFCYu2BtF0qomeRwpVi02YZwg0fG1K6MRsb75Qf/6T+99913T//Nv71PZp2PDjq9busrf/3Tz4dyCJejo6Nj/f4XqhmlSi4U1y+QujYCg/PzxESI7h6QsmN2t2aYmpmO9Yjm0i43VMSr0my0E3q0KDgyA8I8W6ZsOTmtvdPDUv9Myhbto+il3PeE+pGgG1k2ZqEdb8TCKuYwLowzS4+z2WTsCfHAttuCIOUToJvJ4OrxeNjTFnZ3f/f4uHu4zxGaAj4k5WxLPp2WJKzl8mx8uzJoXb/+61998lc//nQ5G7HsEdbl5RiTexbAM8gg30ac+MFPTLWcSJVfp1haco4j+GO0cLwQAsqMdhu9bl0ev6lEc/UPfB5NtmtkZVItSO3NLAECqbUmLacU0TVkcde53ZA4E3D3+LC732t1GqvJwAH54Ewlg3zEShNFy2DgEsGU5OzU5AErglBY44W7hg87VUuBEtzOc3i1tJ3J1CHyzC+zB3N+ZzKx2s4zJqPf89hjwtGJeGp2JXJEc6iE3Iwp6azpbITmFnEMJhIE+AN/3gTrFZ3MqGoOh1YyC3J0MXKwiQEHAaQiF1NgudLo6rGlpBgI5FAS7IthanaT5r12MY5pl0SSsQ0IlgJ/Rs14yPBGJCR2xRvAY7G8Qu5nN7JWloSFBp0CKtnuOCIBHmROPeQ6LktXYImohAjFPCSjBu7TWL751lfu/8dHs7/+6+7iV9Ph9a297n/4x1/997/4crKovH79mt6tdytz0YQ4Rqs3U5p0My+PrkulmYLH/f077zy0Na4uC9EmGvatArN3cIiB57Npg1TWtKjZcixL8kqidKSra/FkZzeRlFYfi9nEOCcJCXGpcSZlMzIkwjqZGE5Fp2mWokdr2tKwe9XVbYwsDl3dQQb9lpejq834cnJxtnfvrZtGk1kp+8aG8ybKh5H729rMDpanH/TXnz3/8vNHz6+vh81audve/fzzk5xpIVIiVbLL+SdgCR24CPOlcA9gkhhvfudVJhAPAU7WUGSvp10Dirg+P5+NFo7NUyMw6SCBNIAP98f+4e3DfYTx+edfzK6GFZ6DxXY1UVpS7h73m3sdzTc97mBwJefWFbq7+5AC3uAlZLRD0XIdnDZtxj+vGU8m5HnJbJV5Mqb4EHLoUk153sJ0PMzq0qTDtSMG4Ez5tuacp9pJ3Ih1HkcQ6gIKPTAhGWCECfJj+lyxGGA8rywkv2H16AzPVTNDOCVt0HpAlq0ygOlGIxnSzsGlWIT4wQjtjpwPmMfJaDUqycqIWZfnn8QnslljNriux/ExDGlbrdPJh/vDm8X6PCLd4kJWYkdRD/2Xf0h0H4q6yBrxTrBZygk8VESkEytyHkm0XDpPhvWxQrRAHESFevSRuRYBD+6W/uhPgeW756+Wo3NexT/71gd/+bur8aI+Hs34PCHTxWKW/lGl+nIqPq/E7mYuv3ArkFzaHt2mdV1VAyVBEcm8C80ganrVg/HCt5bJk1Y3IRTtCI07JMNE8IEYuxbIgcTtDlWBrhMeZuSw24rxKoVHBQGU+iKRzjvGUK5HzJVXUx2YCWSstZivzKNWJ1jfilMb7oMKK8PBNVOm3um2OuVdWd03s93Ro/frw8VV6W9+9Oj1yUX2fKf2+PG5zYygz1nmKzLChkUa2TV7RbImsy3yB1c4l2a10sXsGTohU5AToNdvgxnD8wG0T/iakXFTlifpQmuNEPu9vkCKy11djaaXw4vTkU7Z6XLF6j9u9A5a21adTmDYLMiI7U6vt2sfZSgiM7tL9bm480VgzG8+1MtTmY2rqimv9Zbg1MFeZaCZiVYH44kAFFBmjZH3MADExp+BfNeS1YAiZEUdASOulpCOf5F8wQjxwxduT9THJeFdCf0SXDR1IaW9TlHZIatRRFjfGQ+nfFb1m+ZqOG7ssQltGB8IIUfuhGaTnU4GY1PjsehLdrNULTwq8MSLLWtiPOE2AJZdNlpJngxhH7IuTjoIBjs6qJwEZrX/ATzxY6hRyGtODuyhIsjNtHaMkI9aKET/m+PMx2I9uAi2geaxffAwzeeUbVbxgXt31v/kn19/+tntZz9stZ6OB6VvvN8xXOHRi7EMC1KKJtMKJFVx/P8JTyavQAvum9lsdHrGAybIVa0cNhttN+f7YOQpQp6OZp2+LlDI2l3cNYoU4E4lFZddm5G00NsjkMO8AK8bqmXE1k76IyBLoIh/As5O4NlZFW3JPKw5HNgpdniklICLpjyN0q0jRYa4CaiPXFxmWOZUj7rBZYONX57uroZCTN//2y8fPR8yv0mf0cSQHfDBTsTSDA8UbGCryRWv+ZWdUiMXzwoesefNqj8iIUEgVFi1CvZgtsn1CFZrJryQ3mRRZ5Xy8a37nng5WT578XwynWymoJHYOa9HFZDu3z7Qn1wamWaq6q5dbO/wkBAJdGPfStHQMMTElk5L98H5ZLrX379/u//BrdZyfPPqYiRzcLJsXV5cDS5f9+u1tDjTEtecXbSEpCUGF0U5zkx6z3o2BmLB72qzA6SwMPVxz+TCUBBoBMKEC1wCwRXNO+321IFTPIVAkJKD+mQt8B9rxzCdbQ241rplW1+Opd+sy73MfmEhuh9Km44nBgXpU0ToIhdBVG4DaiiSt8jAdrkcnazSlvwzT4uWI84luLmpnXdfQifeIBId0SEgFIF+LCegGSuif79BLaF3uCeGCNqXCutCQToheVeiHYKEi6MtvHk52bBUHtlD537x0N45XNw6Pnm8d/jjf9Vrnt+vV2/f262WXnxRPtAe2x5qye5C+CmcLQ9vqg5GZEiTMjoVFl5fLBd7x7dUT3fre4Pr08HZ8+bu7eW4MpX1h6K7XeqxpI1r3KZxE5EOfHBJ8M2CBX+AMnVSelZGN6bZQURKYGCUQzBpIQrEEjKAKjI5xgkP3XICzHAr7SzaTqkv5U7DL18GtKwmWq7tq4l8JaJU+4sfffbTH392fnpJG+MB1E8skYUFdUfEFJuWg7A1bo5jeeUiQey8tkZkIX0olSdWpzMTOS8PXp46YibfwmBzgcl67WjvsCNUYirwYHT6+lTD+pSPUdN4vtPo7opntxoHfQYuQnK8iixvAWz6yqymm4UIGm/6djNedo/2DvZ6MoKpxMl00dm9DUSeTNa2bPe4394/2qn1B+MHL57fffrZ08HgzCAwIG00mcXDn8ZyTHeddFu1bof2IoXZMYS7AUqQkA0jDQsr2RMmwdYOB77LBwX6VxnGDlrnAJyLxweNkuu5mnL1kXwOI6G5pM/pjpiKUtvhMOq1TlJfiHqZrPHIUfrr/l5Dh/iMO3bXqBpGcCIK1CsQJ1NCXYlddrOQOlHDpglJhydxQZgwwAYkxQR5H4pwLHEJ/b2kit7IJQNS83siy2cKuB+W8zr44u9AKizhU2+u5Hde8qPVY57Kdvzet3bqjYef/MV7J6+u5ts/+Ae3qj+7ePR4dXh8691q45ePXk/kE7hbGgYKU/Pkz9ZTUq1U3j8AQoevT3qqW/aPj2+//9nvftoaTm49fH9ytd7Z3eUt0Vo7kTlMzAbZiASZ57werIbNVtvK+JglkLuqb21unNiRVNRP2kXCYCQuzs2RcBsVEUzp1EyzdavNHE6GAMpFy1ilCNjJJdfacBcBXZ7DVr/49ZNffvrq9cUATLqZlUxbto/2pvgTUWJns82FuHnzD23jTH2RihSOpbO3JJsoY4oQ0V3y6lpiZoFb5RaWu732rdu3uUBePnk2G4JlKwN3s56WKQGN3m7P2Ebta404vh5eAzj8POLErInx9aXgVbLCeIpdSCWYlzvch8wMRS575Ub/Ynyzvr55Ubu5f6tB/I5PLhu10ZevzmcLndI7y+VrSdLRSi6E0FO7ptNccgVoMFY4JOfRWNUI0QglO8X3LNqoORDPTUbJ+G3QBOVuvpZnDQFBNPkO9bDcXHq1nCYGVJ5RdnQNge3wWDxTE8C77YD3uJxNpNGXqDE8P9nb33Od09OLg8P91dwResjApPjC4roEqnAYI4ZMzy6j95xKRHJMlr+n45AukntjtCBzJnNu7niQO9JFUG/Af8i7OENU8uZg2S55aGeby+En5xZXBy7w0XCdj8Tq9y2+QW6l8d0PX1Qrt+p/3j17/FFXmGPfML7Onbf6x/3ybuuHP/rtjdlKZEYazmmvO3b5lA9p0NvYdNvt0mR6PfyyvX/vvQcfTEbng+eP9QkV6eH+b3VljhrI02MsJWhA4KSrV7OAdrVaR67RXN7tpp0OaWCdfgOIrHCFuRs4BOGEdQunyqaVypooSfvQ0iU/yp6dUxAmkt2pTdbl3XWpPb9o30yfnJ9+9uWTF4+fjydTdEA6UV7RnTYo2xhh/+Yr/4YN8k+xKZFDfFEeGS/CDVSzAA4prfmtLUu28JpTqvbgwT0dCC5Oz19Mn0+nKD8wXJ8dUciWYCMda8yDGIh8BSneqZbg6BfTGLh1syXowZ2klr3W7u5We/1EhwBdjUhGc1Jd2LDR2gN0obzTwc57DxvJAhorfawPZpPhQJkhf2USdEMrYSweIbtheu08BnREKACTFpRejL5mR0HtNtde2Ua07LFtQ95AHL3RgALqBDUUk2YKND5va3avI72Zi8Bc6XRK6ngHYRWoJb6xnmuAZUcT9lIyfD2o9Vquu5hOWqZtAFuqTpuNIEK8lliwBMsqX1Vh35NgHgMpRkiGYCHTEGxhCVhUEafAUZ7nTfZhiB8vU2U5Q//AdFYYYg4Dg4JBr5GWWbhTzdX81kOA4qSsV6214IRsADSHi3eu9++t3v+z5vpv25dffvxRp9vt/Oh586Levvf19z4cXT5+dMJ7lPhc0uOAAh1u1tPhWKjnCtY8vq18ezl4uZ41Ov1+RRPGk5fcnOimue0hBfVjM7nc2h4kS6LCTi2w5pbxDAE7RVlB8bVEXCFplqSiMw6RBd8+XqNKg/GU/hTehmZszpja4m3RYrUWDwg/Hygp57weT0Z5cHH6ya9+/uLFS+n4MsttSfKcHfmbPfG3g3+zM7YxNlE2CiiQukN0xqFDMWEWvXfsnnblcpWERQnalDBU79/v9nrN6+vJy2dn09kE8xK+Dquqy8Be28DyKHyXTZam7OEgNNABwu9KnZyVer3+XLlso02Sg5mab8q4z1Aj9YZa5iIwnlhPojMPFWqw1Wp9NdruN9ejy8VyMAH5TLZAgLz0iQGAlCnttMs7ysJy0EjApqJsDhUx69ilktnkIBNKnGmERUjKQ0pBEdrx+3h448iXPRHkLcLsGuROgvvqFVRtIiycAngLXTksAEjwUiacxBjPyji6vrogJcbjabuy3jvco0zkbLT7XV4qIFgum6IeUlDDjZut6QmBQCkTAaOqDUyJMyzYgVpZvLV+YWHOJda1VeEd9mShAJxVTtKhhV9yTLgGVRPqsVpwMDFfeD19ztti81Gt0pVdr3ilkP0+xAbn73X0NmXWf7j5Rnf26sXs+S/v3Xvxe3tHP31p9Pn4H/z+e3u7zZ9/em7KY+JV29p8dcn2Y5Rup5foYUAmXY8Ojg4OOt3L01NO0P7+8XBwPhldy+m+Obo93t3utKXszXc5vXmsoEBpaUoO+H4kfvG2bsWOwJn0OBZwsY38SWqqEsdbTSVkRIhsF+XJlNjTKGRbVRh1BIUaGKiyy2HPl9PWznxvt3yxKH95PtQF6umrC82+aT5Q3BtsZJ78zaa9oXcnjURtph3KvcVutUszN2VmQ+Kqj5MCJVYYsqQ/maLlfb/TfHB7dzS+ev7sTN2SbAUUSlnJFuQS02RDrZOIEVmToTH6jakLLbK2GEXapjmkvd1j6u7grbud/r582raimZX1B4nQbAC7pXKRhf9StBKtac/Przfdoy4R3G4Y3UIBagZHS9VmCG4600y9kIubmn4Fkn/XhjUlrI4OSH5UhxMQP588ogeYPLBIb/4NPsasgnNc+YgukRBHEhFMhCaaWYNzUlbHOgVjMuuczkVLM6lwYgI7k+Fs1QbranIgpxdDxTyryepqe713uAsPTjuj8JqFuKLNjv2g0gom87gAEpjFI2QJInqRXUjY2wsgGmMwFB2GwwrhZxKQmBddccHojeiM4kx9kIQjJ1M0Rk0nUgYquKtDT82NJ034P88anonSw/biHqaJuDhQKI17O2sdbu52xzvdwaO/5dw83Ll656j2e0e3/m4xuj6bPTnXTaQiOMu47/IzVkq3FKfdlF+cX9f2j16fDV3NmAI5DNJ4jHWQQLW4Hs2beze1WXf/7nA9HZw+f3e/2Vp0yrXdsdh9tZYuOKA8jzGVWpYS4fBUUYuowPxy4xYQo2DxZI4ZQFE5cFx8EKlyronWMsvT168ff1GeDvcOWh/8wTulzu4Xr27+9t/9ePnFr0evLklJjTVRso2NjAitR+8HLdqXCJlsINageOyqE3DQgAzKQKOM7qjsaMhtp0lvtbGMAc9PXz6T40AKMlv0A2ZhNgzHA+/hkYWyLbn9EoGcmGZzO7CxLdcuc//wUL6J7Fu9dPYO+nu3j9x1q8IdmqJ3ik5KZApWc1jk/3K6QDW8QvzqlBJEdDXtHvfER+fCf/Pnl3v7ncHluE6NNO30rN1rw8mKe+qAqdBYElU8FDvLqhEz+JNeSmSoIYXJcsK12QcPh4ZkPagKsEfYHLfYJGQrtAOU1isTg0N0n2YCezNFoEuGhkGpZeEbVemIYN2Rez2sFT6vK3zGmRxI66vTa2S2u9eT9SWxDNk324I4uFrqpTzhiPvCrYMQEDAiR9lRAPSGVQNzVoYtHFLB4vw3samjOLLy4gQtlwDnrmH6FNI/P1NuHt17iDE5DQl/+soTRq0E8sX1FHSE73yTF+KButFI+t0P24e7i98+HnzxL7TIuBzN5LH1V/NuZXequ6KchWb93Tvd7/bX+9u9J5OdT18akjfgebyojcNxMtQZABrNtrusz9eff7b39sMFRj86rPfemS8v93ZO7jaXs07ziS66fAvSBplJlfJCk5ziCbiGPCyyZSArvJB1a6IJ3xGfpoQ0gMSOHElEmL4cnf/u3vHRnf7ugUT6i1e17lsv/+6Hj370m9roUvyd9gYOkhkSK95mOFZ/e1Qb7b/iFYXoSTwOc6B3hQxUEfRAAxDIthMdHO737t5iF81H4+Fgcp1tBucbJtbpoBpfCGdWCVWxHhnOYTbeKu4UQh+GLrcP9uq9nhZJ4Rhmz05leHMzPTttd7u9vT1G5Gy2EP+WbgRROyB1B+wZeET2SDJk6ekIQM6+/VqnITn0+eMz3Wb1ukFLxFir3VtUFoCER1zOZb9qrydh1n3i/CDfEIxFkYLeECIBY+yhtNHMLctOFJEEfmfe0TcyNVAnUCQ6WWAZ9RED6hTSXp1YMQIUsYjMyMkH+5Ir7qqB64JxSQ+VABBbie7mYcXis+k8hE61kMrxcjQXo6GKNoq3VE+/pAgopB/+ki4q691RRRsEbTm6sISXnBB1lqx07/WNf6wShAhh53gjzBC/L78tTjo7V8DdqJWcf36RUhisEs3v0BDHm3tREFbnrpudcfe4/nH9o/PfG/38ryatg6vOvYfvNnaez5+fzmeTwcMP3nun8eJgcF6TlVi+Pbu5Xg6uZjoUpOx9cnjQ1wCiIY2lVMfEq+nF5aN1W2PG1cPt3bcnGxXwrd3q6vXl6/LBUYIhQD4xE5zGhLGEGu1szRmLKwaaepMeiiAR7HN9S32Mj7SDv3phHF39wz8tVfvl9ZeN8sVB8/hv/u4nv/uLv1xcDJD8FEdxznEThtBRVrbMntCNviBmW+eIFbhk/6LWqdwAMbsu5OFT1gKz3Lst0Pzgy8fPrlWWFmID1KFGkwkI4yzITq6+CChbh2rT78jOblbyo2osXdkJjeZgPO1V24K6Ove4ao6mvJ3omGSySb+bKNjORtmMsgQZmI4U4UnFSb4UbVgTYlORUj27GNaru8+fPqEoKTZPEguUIuKfhfghZFEGKkzHzmZ5ORz1j25LZaFRERCAIlE1900cDy/I60H9BY170ZkjIVnB9irAq9CX6UviirwHfp8k3gjVMCKVuq3M14I/Y1YKa+Dw7u1asyH8W203N9I/k3aQKG9cPxsJgnMlzPxlm6kmwIzIDYDLq+AmsVbbXECIEadwh8Swt0onFLIPNovAR7MhcQeSw/LCG1PBp6B/UsP++96bipJqLzrrMFNkQL6J+YD8Q15Uc+SAo/aQpId3Mp0p++gEGjFrQpLeVWuVj261t0eHr06n/dsPp6uL7x30Dh9rj7lb3RnvTS5Lk9V4On9y9RxEhg/4JQfnl8thTabO/eO2BGsugbK5eY0OS0svlNPfDtvnL777zeNma+9ff355cHdPLeNM7QdyXxnmjo6UGYSMNGaJT0/ug70osY9hYxhDmbWZi5XWZjw/e3pyOV707mslVSstRqXezcVi8/QHP/j+5asvH2NqGbxmEKVw0bHmaHP02RbHZZKXFlzBgtS1qo7i7INySR97Js+tSAJd78i3c6r0wSeffS7zl9blFxWJVRIWmSpTwXUKUsqvChdZ4bQAgeLHFZGVoNzoHgqfABLXJ+diTua4MPSTYio61rwpqbaYret3DxZLKM9CJZBSAQFeFqzTv+fVe2Y8TAchD3A5muw29+lVwQfQBpJHzhFtKquNJKMzAWwi1pyA0WgmVH/ndkkBtxUU6QU0Z5HsE+UC8Xl0zdCRWVpX1QETo4LjVfVlUyIoKQfDh4NB+ERVjgnYZESSZr0T/s0k1IIWCCmSZs0tF0elVch5irfEciR5Oz/WvA6MDD46Zmc5nVVKPbQXZp0UgE/+o22HdiX5xL8hT4Nr1ecizQvaj2/aevK9Y3TliKucKZYt4H/SgNEuQvaGsFBQTfRJBBP3k8CqL9ICBEqSE5vb2UW+RHS4SQz7sE5iBn7erPaXY/Uz6+Odz5t3l2WRDV22zo9vNbqVyjubi5tXGnD1B9vOYHwNPNIkQl/pIgccTqd39zqrUeXi4moxuyq19kpmbq4njZMvv9G69W779o/O1ztvfdOQ48b8dal1u1ru2+9uq79Ws692czPnci+XRo2yemuR4hH7803MsL1z3pyf70zPFKQPOrfbtfXD6k8qq+vR5VWZ0/OTi1/98jULGUuzKbmzC6FIzdkpT52ty9QWr/Lu2e8EKCIC7BmVT1YVUiBiQuMGRl23XTOBc6j7Aq9oUr0QrQeNr4Lpa6nRXhBzMgK2MiJksLiHPRc3j8SB5CaL6ukYP7sf00g2YAFLZoK+nAAE5GSybkw214PnRFOn2+eTQLQ0h6BSzlrkfT21EryKKPmgzLfb7zW6/b1pCZKfSpqw5YuKDh0Jq6cduZQB+SZAMqI1EFFDN342tkh0YOhlYxkQv+dGIbEWSVWKFjXK7nGPwv60dLtBOiddEaW5iT/J80nfCEHqPPAipeWz8TxVk/OVoE9AlkqBpYhBY6krvNRRBVfu4BKJNXjO0d7OnvLQ+WJMv2vQ4DdFM974lOjQOPsjrmKsRog7qPzrEiH6ArSEYfwyi2OixGqxWO+IZC8+5UMJIIT9EjoLrzg44CQXCgDyVr7FRJpAAKqh0B5RedELvqTrgh/b1b3l5e7lb9ut4eKjPzjfe6/y6vngZ39xOT1trC/+8M5sJBb68vLLkckb85gfgo4xq+W1N/7w3dpRe/LJyUyMx5PLxacFO9v5V452vvPO0f/zr3477r+zf6uxQBW7taPO7pCyOb5fr/UzP5EzpNRcZ3LbNBkUwuRgdJlsYczdHGxG7+48mc0nv5bBtJrq/b7XG09mZzuXV5tnox/87dPpxClHQ6ODv1eTkfQxdehU56tyRfF9Hjz6t9hesi21u/mRFkIi/X6n12ufnZ5R4CJb7cSco/vDU6GbyAiEAasBbhz/ZEw6sDklp5iicp37tbHq6CZgQvxKhW6penx0n+rhUZIT4SSi45O5I3zqj/gVp/5GM1e3QcmDywuSic8JcSDEZL3FRxkDHR5y0P1O10RpWVDQTQKkwcEpXGC5kN82Sn5D3qnVyWSkmi8lSpMB2RSoFh6D30lH/fO7MkhQFsxSMQNKvQcsaLOSRmPDEihOLAYHyhAaDWd4JZkL9q/A+64oCCDB1dqaNSEzhZ6Bd5EqUJvkHZrWgw1GErTCHpIxTWqp7vGSNHd7zDkS2fITB98qkpJvWBghyVxmlOXYkuEWPoj4wonEQNghL6HzpDQh1qQP5eJ5Kezhl9FiwT7+x4KFs4toCoGz9aOxhL9dKClGjBr8ImCOIhRWkERkF0f08s78aXv8Ss5P60570mu1Dj/s39v7+mePar/76XHzi7tfad17u/HqLxdPVSev+GcI3akQ0Ae9q//s9/d++fh0W7617OxVJxPNZOTLvVsffnTrrf/2R6enrTutyavZ4+edg73aB/fnw0Ft966epd29B/K5WJOYtFq6KK8ut5UOHeps5ReKxC1LjfFCTe/kTnn0zoedHz49/eXn21+9Hv7e0bx78eLP/6eXLy/tGJkWc5+ZliJjWxB5T+/xgqtqN9KGIMpWeXi/8fi+sQdegoyZkZ1OB0w9Ob3kHh6MZrYu0645qryPEkbmPBOGPzFKUFNeiKVQJGz5RUBBv7M7cc/9g73b9xpmE4IKDaXb+h05jYQWLAA7caL7rAOAd1JrXjgimWgBNs6Klwn2c0hJhUR2vFLW7Oc0c++sS/1G/Yr6alSXo0XmEixtnq2j33Bc1IJHRsi6hFMC0iOEh2NAemreT7viWmnNIzzsjR5BfEOr8JVt078uo1qpxDQpKtrqFd6UEBfawRZgA23kpBCcVLAAjFS7BomoctDWotImaxzVqq1BpPoAnMEh1mq3NSsV15tN7PtyxXFbQHpjXKNkQUz6R09Zzi+NscbkFRPaLZlDRGt2r5DwRJAHe0PvAe0J/Pqlh0DDkU8+7v2x+6M4vJZuwx4zv6UQCB5vj2rI4+TkE/qIHeEfkZKImVLpXum6dfbS4DuotFm50Vln024Oavc+mo7LPxk1j8oH9zqb55Wb8fn9Xq002Y6mejS19+r1f/T2si/SOWcoqGusloSAljdH6+EHtxr/7jcXL8t3yrWrRac6lZaz0P6ydF2WV3/y/re2E00G+E1K8/bmqnTxaCV9vtGXOLXcNpGzHO1a53Ba2T3rv3+3+2K3dvUdAYVm7QePrh5//6e96fIXr0tXS11JkqRaiHNPkwf2rHiIPFF/qOWF7j9RiZCMjYttldMvBP/WJDXW7cX1YHE9tsVkZYGR7Cz86fvARWTse14jbYSLShVl6YQWGpYA3OQMjTNR99d2a945HKs17e5Jg+XKFDBgvrAFHQ83riAXG9TydNdD3DiL5RrNYj3AGRGAfx1bKkuTjgU6B8WlxE9Dim2/hdV4EO5Mnp821QTD1vWKQhkUwJ/lClKgcVqCVmhUuuE8M1A8qZhAMIYtEJOD3EiCbdoGOn+Kd7uTyKPALUJLJACGMfrsjUzVGI4P1aJ18HMbypG7kyWOKGWySG5by5YryBQ0SL4VHVEqzcczQUBRUgASPzlEPflpMt4wgUDxtUCu1WJ4OeBjXs9mUplmo6HCInSbHAo+NvkGbY15uowsK4msf4P1vSMUG8K1p7YsUs2R53/f43Jsk994RDDOSdNu+dfZZiuJPX1Zahbuung1tg9esuM7m/3N9Tc6s/HjF5VoPUGaQY0du745Xl3fvfz0qvR6vXdT6U42a036qsfdiqxQOQjXNzcPqzd/dPvg4vX42bA1K/X5VyYYu776vUbtelR6smipZ9JaZmcpIsqn3x1dXjvexn57/uhXezuSeA1jWxxXBpWdy2m79ap9cNG+06h0JFWjVhMg1pu9euV8M7+4Ws9M7Xpw82V178WLL7c/eFE6vblRMWhHgn08A1uWiMvAMuU72pTJTTSgLg2lbAoOcei+wws2IVuHsCbz62vlhWglfjpvcPic6YQn3BKLEciIdcKlEhtCKotWaCBkdLBarelQWbz6wB1ZOtnoFi8LuCWLX/2Zz++1ZMm2Z3wDK76QplAbae2aqm/djVMSGVsIE8VZ5G+SDx/4BhxKTwaMgKxkVZdfnA37d/cwZWr0Vtvpchjm8YFMhNCFDOZSmrP0An1HphG1Dp15Sdm4I0BhgcVTp0tmZCVhm7nfmG5GuhOKYICwMfkIk2Qz5nOk3DYHKhAjCBxUDvZj2NoKiIJpK11JJhbJkWRHuYvCK/HmhotVMeN7l1xO57wIsf/D2+g3qMaA4xgJNkbDq3LlWu7KFqWwy8mKys1sClHtHR69evxcVJA3qXN44OExcqg+UD6aoKD+PFUQTBgi3PBGBVC6kWNO3r8R/+EL65S051U/Rl2KlQY/bBql2R90pncuXj0di3ZwDnTmtT566W53Pjz9rHH6RetB7eD2TBDy8eXOTkcQu/7RweFsqcfE7KPy/H6l+d/9cnB+PRveXKQVXa/+zYPqrUblv/7yShIVKw6Ysd7KbDk5H7B81ZJbPTvh+Mnf3d6tt3Yrm5qJgI2zVXV9+H6p+0H9ZlKfX6gntIZe9eZg8Xo9fblQW3RZelCpjOuV56t7T6dPdMhjx4F4RIczDyURX8YjGo++3p5dTnndmP12JJtS6NDM6pSCWjgw8I0N8ZsCe9sdmyhkrZFznLPQPy7APAIGRdqeghs143GXclbGW6EdlBxvB6rpEHgJ+2m92mx2egbFt3k+vHPqHIlwKWHiBoosQ2BpCQE/Y0VWJtKRKOdQIFO/DKcVbapwtGP2q8IKgGRZHbUX1+Pj/X5Pgd7aXIzteDxG0xYhEwjzMSzrXS0FR2QuL2kSTGQQojbPIM2AsyWwD/mynlPLag9CKszZvCMXCR15mGg0L9erDTnPtES6ABo1xQfFV51YIIdmmnuHpDS0uEprlYUgXIM3h3XO/d/qiM3xDbOHsgi+YUxjU/EYuesgKEgiKUh3fXNxcSmzHfc7K5FwnRq4LaRwY56r5dno5EynnYkBvMNp57CfhlxNPI3o2WD5CqCP/kTjIfOCJ0LfMYILm4/2y4v2voC99p2vNtLVJfwO1Cuv7+yMvl4Zzj7/Vbc6vWjtLI4fXPfe7VRr+9Nhe/BsZqRc/2avWX75ov2z0913/vjrss1evDgnm3ZLm+/crp9d33w6qTbvyAWrLweGpl98daf+2/MbrpBuZTXS0kZt+UBzJcS7aWyWD5ur71YWbx/2akpgSieL+uHlurM8eKu1aUvtL89/S9gua611pcOR1F9ddcZfopFm/XabyhzOPxu01UZKTETvzNJ09QIlchz+95ylxGTogwg8CiYy1S7xq+zv9s7OL9SsOQJvc9D+8a7CO0TU+5O5d8QT8iMglHVTBRkALZCrH1a7yQlD3KFLFKPXNEe7sqgynLt3tLN/VNvdk52GNqQ7IuXo1nyWsemSkdPsVAtkrlonwOLA9QbIg7ibIwOx5ss4edJZ1VXM4yLTlT5KlBA4qi3lcppltlmpOYBI0LUr0mwksmLtFAQTpgLLwrTxTVF1wLtnv9Ghi3XBFmB9o1ukRvrF4o0t0+HfVbJvwTgkSUACIehIEFeEp2TogWxev0rL3LKc0NVWP7MmnRSPA3lf2hmNxtxBJLdNJ2Pb/U70ySJVGEyAeBolA054h6Wtjxu67pQbjBtsanEYACnCgr6x+UjSd0zjqky+fQaGzABNcWxMeaGedTSc7/e7t4/NWyEnUmsmp9K/EWMxw/EAzRqLKh5Ah44gMIetZ1CTa3SGU8731GEsBogBVyzXX92bS6W8nL1ebEbDauNi/yOF6/vr9e3xi5vR2eX4/O7xAqs8er4zbh3/0//8P796efKDf/UX55/++u7y/KOHt/71Lx617uy9HEzmk+XHrc33Pm7N1/UvXk07tZrKcv1QTJw+rMwe9FvvHZa+c3f08Z19O3X2/OTFtvnFbNv/4AFo2JGCuJY3//Lw4M60dlhqtDko+qvr3md/e9z9hWIrj/705aPv/92TT343ePL8xUT6QjChR4nHDgF5TvuAxAIRPXuIvmLwR/IihEuX69Ozy/T8gyq4T+L6k/4A2Affi92KErVUf6cmk6fcccm/Cx6NvlQ+wl7esnmIXGN7EUKvIC8XI2rqPPMCSPIimFNiG0Yewa3gfFK+mctuz1RloEcY4ZycF5mLNDAt2aeXhLUX62FtN5YjGkWpnYgvSA+qz2RWJOWoXNtrbU5PX/DPcq1HP6T/VwwXMMThOtpYpdt1vx3ZHVtU8XZUYAqqsET8R8kcQ4p69SELl23HWmLHrqbeiRHXKy2ZvRtZLhd8ST4dlojjRD8ceRDRoTK3OEZbWp6WGFK7RvTReDgRQIqwYRA1tzLFJ40KYrVDDko6V9TfrFpqCxiE2lnuGg+aSxWHFraFT6J2sV9U0fDiOsV44s2QYJqx1UQCp69Px9ejIxm5e90iZIfHIcHgZeLftz7q+IsLWFoEC7KAdGIuI5Q8NLkZn0ASQtPPdX1UWT2oXE+vzzY4TG+T/sHk8G1lkG2xqrOn568HjHfecSbsl+elw+98Z3V8e+/27e/dufX4vxp98OLi0emrz2c1Qfn5xfxbrekf3a1/cr06ZRDvt/ZLNyfTARr66t3yf/D2zsPdyWFf08/qxWT22cvpr84rg9pBde/o1fBFudu8dW+4d/tw3bs/2dw2AUcZC5DYms87V7/eO9q8fnpxPf7p808vzh9NT0/UjaTDKCDNiCEDiVWHGwzkn8iBN6lQYX9pDgmYBraH7uxXeATYKcCSYhJYhdeV7CfAdrtp6MyY63QUfpkE7LWCwmUxcn36FBjQ6TpmZ+oL4CnJbMFQtTYzuFlpInX5s0tyJe6oCP7C30S1Z/9jCie8jU/IreKcM068nvRAx6U4rlqfCDfBZJW6gU0eT9lbKg106Zwl1eQsXcennWZ73qmgJ4tHxMXjhLnydCSa7KAYtYplcmFlqrTOcjEhFgrlz1pOcQP5gt6VAiI5xF4UcAfs+57zKJ16aM/snfpG5JI6A08TeU2KYlx+uul4AMyHnDUxJeb9JvdIuUPSH1JbqS1Gap85hQLAubhRM5S9WTQ7mLgrUlWgc77qtoQCcocIcSaeIRWW0pL0Ty3o2EXoYjqM4XJ1cuo4mn0pwfbKnSXDBY8F0kT1hhCiE/zr9civHX3reNsFuQVaLB76T8Is7b9TuVOd75qreX2yNc1ZH/v922vd/ufrhtTnJ89fPnrx9vvlbW97OqwsOm/f++630pdqOth8+dPb88e73Zt/9+h6XD6uj8f/8TvdtyrLz1+vfjHy2KZF1s9Hs+N+95t3mx/szz9szw969cfXO3/7fPOjk+vTsRqjxqa52pf4KzKpk/5ssbee7Vfni+Hz4dm0wSdLvM4vOjsveJhe/mpUOZv89d+dfLZsfPLqchIzUWlVBpGgp9AOFih8YLY1e5ptjZsl0tcGhi3QsD2xZ773CrGTmq9IAeaq3hWR5Q7w7/1PVAQbkwqgOSVgQoxqdcvdvqRPRdAkVlDOTvum3ESs/tDG+hcidMHwaCXcgiQZGBiF5I1sjS5G+5gqefz1jq4RVDs3jYXDMJYFtxke7JYciwIF8WG4ND4MXW60M1vuzHz8pnDEM32cBUntl0gMIgVgCPxMHxZkWC+7u01xOJ36PBW6RB4xhOIfjr5EKxIlggtE1dwfmWxhLRQXrxaoFLbDudSlj7HfssPAYCuJBlZmG2UIrSaaFW2FWmAKz0cKBBu5CYWZuYX4VXVCIu34HQOIPF+cX+71Wt1eH6v5z9+oWS8xZvHiRtIIQfPGTS9jNq2ixCezmTwgpFgIGnfc8KWwxKK5AfowZF73B4vEyecJsykON7AHfbR4xfggkEBhE7sr6qIVGKdfORYKuCqNrigjMft1p6+lhxwu8wqvrgaLxVCpEr/4l8+3k+6d4+7e2ZPHlce/Wf/iX9+rv352WXq9kug3frtWOig1Hg1Hn16WlKQOzR1dT9+prT/oLo+r83a9c7Ha+/EvRr8dlH56PrrSXXIpU2XT2KvrGns9UfKhyfuN7rEPTq5ro9P6+JqveaEB8GZ46/2d+dmysaz/9Y8ef/l68/xmORwL+RTOW9IuT22rw+rkH1QAbyMmL3h+u6IYpNiY+HNsiLP3LzmPYjMKRNKO9jbSGARebSxNEA9+xySURBXVGsCqcR2ideCEd4dfIKSjJU5SJhnB6E3LsLRFN+Q07R61SkqiC7Ocjo0kJM4sxw0zmND60GvBo0lMgiZ8iDmcoOqOAk54EecGG2O5kGq8Oj6yiKEiczZmc9zt3ZZh2o7XDyVwejwcMwDyqDdpAteVPz01y2Ks3RKG55IXiqiyrDTZh18AGZbkzVK1P9RP6nJLijwS4C4FlKRqU5ZPiIk4jdcRGiO7p9aTPAoSd5ne+Zo1cQJ4Pm3UcQtLRMokO6OstEghSMYvR9dwaNteRk8jZWXSPuDvrX6oWsvbVacg2hxxnBGOZewuWZJrm0c0ETtbTywVpYlIms6fjGe6Vys34FZyY63ztIu3aY43UoessYE5PF/+YhKsRRQ7OxOIhz5kVpAzBBION7r2fmd7vzPbnC8W51dXV8PSrYNtc6+xavZ5soYnz07OD3frfMrj0/Xz19u9b747e3lauvxt65O/vr98qdDgd2damNzc0z1htfnd9frT03m/3d1MFg87rQ/utA87C8Kx2q1/crn+kv9ISR3Aubp5t1k/X06uFtP14PJSQKXfu9ntXY4nh9pht1fd6rk6gtejmxcXg4PzJ1/t7k+uN49/+MJEFd7nqUSSQukX6o4siGcTpST4h9yJJT9iDyIjvurCAiI2iAhIkfZM8dZOS48Mnn41ib2IV58BbGFHwoMcVQsvdoiRYlI1OwGYtkuLEdKt1s7oz14PeIZ/pcSxpHFjwYRarIpeoRpJMbAocmJjGIbCv27PMQ6edFC4FVER2Nbiji7CUxKjHJcoInWO8wVoDSFzcHoxuTjkvIkH0Dnx2m50qqVl3RRczf9YnnIxsYUThflRrKuD2svJg93O5fWLZmdvGrOksMxDES4ZxxGai+9LghM9oPyM2RMhslbmgOq8X2QxyBJaiq3Z0PHLvrMWkjbh1ymPi62ZurkFv00FeiP4XP2m0ehgk6YuOc3mbMoK6IU1ACn3FBlp1Nrtlmxv1VWa/+HssMZyyknMcW0jkn3CYNqs+JeYyoouID3Lxnt2eTIZz2eL3YOD+WZx+vJk5+ZQdO5ay7S3387eRs8UANd742KL7x996GLYqK7Hq/hunSrNGmW0KWuu8dH+vLYenTx/Mbw8bdzaq965r4P0nWmztXNx+uXv5rNRdz8TJ8+Hq8Fsl9DYn1ye/fgvvlZ6CTb/+iRR/XeOhdbnn5wPBwhC5LY07ksckrNTW5R73bPh5EqElesvrmtu3uvb9dLuzvzto+an0+3ryfVqOtgOOm/X33lw1H+3uti5fH3TGI9b7Wdnk8+eXnytuvj0Z9XPv5iML5u/PJucLG4u+I1tRHLXcnjIDM0jHPxAAugs6ixDBgHDeINiKA6dywygSScc241EyBRZNEZBymcBikpd9M7hY3xKvXY1vZHjiD4Qiv2SxoLSSGK8JlUp2Xs3dRKr3OzQA8QbB7yoMchqHbzKbIX4dyBNBAbxo2bTCdJY8sbRpxOMJrKyLAn59BXGC7Jtlu1UkEbAJgLm3sSkX0EDNEqDNW9ooySiURsGm8wk1DUamk7XBiMRp355ZzIO+wTdUQrxb+SuaspsSmEiMXFEKPQw09qQ10gzDW0n6+K0Jl8kFcHbrdtSxoOxPhwM2pih/tiWACEUw+PGO1lcWcKUIDuL1RO4LjgRqiXw4/lNAIKtw6gmg2w7U6bR6zS7zel47D2EAeSR1aLM1OMQ2GRRnLKSKFhdNs5VA+bo/4RBEsm3JzFIdIxCmToImsiplch2M7get9Xq1TUC5MZKGDkKLvsfeYNtcIONFnJeGgmggZKTT3aj69H/63utzb32Ij3px/J8ShUZEK2jnUl7l1NhfD47edFjnilwQf1X5Ytt88F2dPHrH98rzzQCvpzVn54ODg/vNnaPfvQ3Pz6f7bRL24/3G+plO82GQefX883jq7GxVhqrN9bk/kK8no4/3G9fXIzfvtX7qq7a7dpcKeN01b56ubn6ctY1kqo5WNdfX42+eHb9+rk6+jqW/+Tp4HQg9aqqqWea03uAQiI4IsdtMz1x9J+ypEIqOb03NgCZhgEKclLQo9FJkV5JkwaQcwT6DuqxLd51Iw1J7et4GyC4qY4BYYRNkysAaPV25UvcdJvN+WQ7uWn2+9tWr919ewH4FDUormLPEJ6GJJryxZCLgy1HEYlpOTxvMNJiQlFFV6UYRQpN0cy4laiZPjHK4hOyShCTF15DbF0zqAixvuksgTRPHksQigC34p+aKyZG+2OyutlsF25Vak/JaOD2mZw86bo380DrxVwiqcymwPT0njHioAUaqJzWfRFHRHraTPVxHDPyWGNvIhtL4UKWsjNJ3QO7hJMXr/Dn0I18ZOn/aeciGXBKNYkoAd+p+ZvPxrQVWOoXSqXaXVF5KUYzlC9dr9Xp6mUUrZXQXU3LoNliNBlNOyWtCAQgwD75FGE7Wj/nF3kWwYAhpL5aAcmntlqKuGfNoPsXJ33zYTRoY+7yevFhFgAA5ZhJREFUX5B9lG44VORlqXO9GXFsahIOn5CJ5ZvJ+3vVb+zfdLeb50+fvfrk81cvhs2rRf1J7axf/eYH68XFi9npi25z5+TVNVBwflE7ra+Onv7y49rpznSkZvb16/V4bKRA5e+ePj9baMqw86Cys7+boXBj5dvb+aqlp1NNDP/ijGVttVXZIP1a5eXlpAziDEbNnSbJNxiagMVcMv2jejJejM+uVUCezWenw9XViKja/uL1K6bOkis4BbuxpjxDIdd567NH+T5yNKfue3+8J9red8WPBT8QTjln7A/wByglTkrZkhhB2o4cuav+MnUEMuV3i/FLsCn1IlUwh0lCu42dlltX9o+54NSpMyFUK6j0i+BP00IkbRkJka6Ap4wZcHDojU8T7WIzBxoNAZ5lMc6HoKcNwo5qRpeTcEeegZ2JTeK4pOUiLwu9zl0DOxCQUpdizcb9tWl3avPh1uDcgaH29CK0JY5vOGe71+wxiSMdigiqGJTsI+aPorQ4KwurqS5sRXqLbdglCAa5qB0AwaXL8bBFUBMgwkXB32z82bzWknctQo2PomedaxILY1llndQB9SKEwcdBckeHiI75WpqCtbtcTG2pPQIvd/sGf4mqZICX98lJYYqYOuaWvEo6xVybYeikaF4Oe6EViiPojvwzqyWaNFIvEICzF0sqzB+nqXytsrt3gAfSZ1ncaTjTdElr074Qiq0ra6LvkbbHrfLv3+/snJst8/0nP/rzV08vTO0cvph//uiT5n/2jbn52i+/sIuvL5eToSlKm+fnm/ZX6w92LvdmV+UdxUy9n30+fXQyXw+ulTw/POr3ZvODWuliNBvIei1tWkda2ve3Yx68Tb+51vMe+zZWpFd9NltqaC9Youb201fn8VzrsbXeXqoylQdjHys7ejXpZOV8r8ZRkuKW3AJUGNK3yXY3WS/gRSG3/t77+YbkQz0h/AgNp+P0wu7Bj4XAL0m+lNNMD6do3qL0ouPgiw2MNTbN4E9O0RQAyAmO/pT/gqw0zFAjNRjYWCMAxy+kIGnT8qq2e3vT7lPH9Fi9uytvgELiL3QK5I6FhJB2TKAIOGZKJNwj+JW7xSEFDMAtcvaQrBtbJZbwegSXKefpPnjDs4O2ICopNn7NKCTmLI/paezSmd7MfPJGNe+Uu7sN45WyVRpQZ0A1gSH9lNjDQrZBWKMBi0sHAvqTFEQlaGOcFM9k94S+0vmYAbykglLVj2xxYOSupaO0bUZ6rOebdpk0+Hu4nYeIPzUpzkgT+hnL/VQ6y9FVb08nE6tJ0FBAzsMGn9xQXtKn604h1pzjd7hOxE/STOdgjHmBKq1FnlOWI29EhE/NdXwG8ZGJNuSBrUdiFWqgtFx8LqW2MTyd4PDNnB3SlLOEELBOfbvcv3PQ1gAsgchVtTRvbKt3q7M90b/Z+Hd/+f2MCq3saubws0/OF5Xe124f7JQ01X9GZp2ktrP9anjzi8ez7955fbt2eHM5rrWanz6dP349u15uX1683tvrHleaGdZZr52oZL1zPJ3MDu7cPbseLZc1yVKEoSMkV1mLUl9IjPt7zXvtzUkyUpJXxhOFLJJPry20Vb8RKZ43Zg/XB2G94oQOBRXkTBpglARZRXMj6EPprhDSd/4+U6BhOxpmd66xGeKIdMxQMTqzqwWlJiJGkAq4yqRBerVFaQjB+KB8wLrx7mGdnRRFyQdeKcTn8LCe6Xw0FX/oDlrH8/rRncrBkXhRSqHIJ9IVeWMuEFOBq8Ji0bX44m6ms5nPhsHlAGFdO+b9nBzUWmEmUkGW61OMgkJ9AcnJbBO0QrJkc2JUNqjaE0pabSb1ismItf2Do+X8ZDjVnlE7u/L0apCond/pz3OzwyBN+e6O2kv9vOAwESw1ACoW+eXZz6h9ZgSMBv5sI8rHrmOVzA9zDHaHaMXQCBU8CmRMTY0m19YV+Wu5FhtZY0clA2EK5hIYUDhuETdCRJ9CZrF4yiYd1C2g6I5c0PtGBp2qURMqCWdqgcEUHuNw1tgjiIV0xHWRiXFhBLbmrk4qQo4XVKYhlScjxdoARfDIEwmnqqZGIp1e3zu1/NExk05vy78Qo1iMW5Wbu5zfi+Xf/fDnP/rNkK+qftCqaPA0Wfe/emvv8N528KqyGJ+bIOoZdrYvhsvL8eqoWV1eXdcWlc+uSr/4zEyT1ZW48Xp7cXp9OWvt95oSC7etw3btsNzbPJtUOv17m7au6/EXT+VxdLu66ITMJwODT2R7gm+7e50Z78DCuFsJVEkHBksQsAwr0sAhFOcQckxXb0STQijqgoec59D9AoAcg3+DHDCCfXEYMRHybaxkv3UQts/35TIAzW1jAgUnhnRGUB3IIXSwBfheSGbOrYRJXIUhGWaAQ5P4WeW1V6PAEqQEGjpaOUit3M/Oh6/OFEkl0kOVyJOSKJqx4TkycpBvlZfceljtRG6z1Z2Z9g7isEuTqBQPDxFRIAX4KR52bw5K0mcCcrTwgseZeJD/8d6BORbt/bbOJuvJOZVpyDZlO/A9zzV7RY1LTZboFPCuG72RsoqIBDvCDmHgQjlzJRTRVEx3UyLld7qRe8arjogD/2IcUWHgWzyPlkXU8PhiXLu2aKT8137ai0ZKhOE7XqQ4zfIHzWBiD8cBSepkYCxLyAXXG9XV8qRshbunvpOySzCv0pVJCw4JJmxRsJnNc0Fi++BMIzAIUKrAPdL6RSYWFUswMR+0oNKQmXTQoJMNpLFHkKvNJQlSi5RsqxUTbjUfR9hu9tKQaTLbbV5s6t/84smvfvyjn//s1ex+s/PRh3ffPWoOn4yPv/p2u1qafvI7eux0sr6YAXI3z05vNN7jPxhcrU8/m/zm1frZ1VaPE1MytYcQtb+azAeM3BPthMvlL19ZHKciT0C3Ya2OVLgvyo7jrd3vH+8e9BoHryVN8TXv7kiX0CwWtI/bZVt5/viV/hI6gVQ7lTNzQsMIIf0WXwtaNLDHjWxmAv0uXVy4iANkgwoFQIIhrOxYfPckf7Q1KRJw7h3gZnRC2IN0zaeI3egF3mYb7G9vy9ioWeKdXMDggV7ZBLvpdJURj48mNzKIZ+XVOTw13dYnRv6CL1EyCp60em91RIt1w0X9nX5PPjZftSIBxa/sOqdZCMNkKG23E0X/DMUor8Lo9C9Pt/vD0mxDnOd1H5F27QRjH1hpGsHr5tKdJxt6tBzMPnrnqHOujcG00e11VNyvJiZul/VjbQqZCdO0BnMJCMVXoIQeFdBKIxUplK46UhMbhCM0BBeEiLHu+Oyc7eA0zA7joORz84pVGgrAY5o1al2Xjs8BhETOIenoVuv1DGBPnoNXAJnyD/g0GKjeGWBnGdH0pXVy7ZxnYWiQ9hFQGx2z5x6SJ8TJQHZuynygnwXgcTCIzClUeLroa1ghJeiIApN4G8UaXc9CkDOyNokIHKsyrdvwkXYiyzLLVbObg0Xlzs1CM8tf/OyzwWR5+N6Hq9Ozk0+eTZ5Ubg667dsG0y1efvrpy6vps8GyVTs4OVXsvj0+qF4MVn/z5ejiCS9D9XqyPltthxQ3/IbbgHIGVqSwR4sPkqdSKrixR1SWjUeJIZByebhcXgwaj+uVfrfBBzKdze/c6esiUsh9EUnwIB4xdXrkP6UrgNLr9zjQ0Kzj8BHU7JJxrWgAEdzjfmGE4iYOC0n/vR5ww5iUJJtNDooh5q0w7s4IYGGhmn47RkQXietiTAnn626Y3DC2mHKPcqWLZYqG5pHQJJ1pQGI1+rRIcEQ0Trfa3NVd2MHy/3e6u22pmvhfAwn3cszOJrg+BanKW7Ja6wVtkBZJiVYKLi50fTga1bhTwm72Cwf7PG7wqmycWKEy6qcow2I8quZAxMFOuaMQeLfTRMezyawiI7E015qxLmSxmO4zCzn6Hc2WMtbibUy2COApWqcRXJfD1MbwRuzUj0xzZrR4kCq4lv6W3kdJURrB4Ev1CMAZOyax63goy/VOW76rD2fae7ANiJi88TTuutEhayCt31PQfco30ePa1ETiZMOlwVMWyBQ3Uag2QgvvMDxQTvbS8fsYcqA8oDaeHPEaMsMNivx2v8nmYVQSypkDyrG2bxQ32Uh2AhnJ3Gwp5rw+v2w3BfBLK3Wbw47Gztudv/6X//UXTy+1shQMeuc7H+3X2maZ91vrrz68szl99vr5yflwZzxLr9/Tywk8IJPz5WXpzrxGtb5Yrk42NyN3ZiohI49tmXmAeFZSPGdpcS/CmDbO7sUGk3+bxQpux/xszJfrvVZ9PJwPR8+Tp2kAUL8104tlrWMi8l7rvNkFUVZpNFY8NPW70xJpkM6NMsHXotmum74hfxzwhvSZG/Y1Ri2pRAXb3IR4kzMtDQR7GfzHE2QYa8LGUjrZWPJN6i0v8m0UdSuVeq89FuustZUFgAayeJst4khUj2jT2SYqGInGoK3yifMk4vx4oW0+yUhRSz+DgMArAUtMQH0DupYD1FkpGLLSjWU2zBge8Cl2J+oKIqOR4t0h4aQEhzp2ZtOpGndKSDkkMUoRDQdTwJE/vFbSJ3p3PLw57PQG16srw5Om091UZTbGV4tqvasuxya2WgoVxFV5mdCz1rcINHUwiQ8Bn5z1K+27dVlnkTGO2SqM5CIRKPIVoRb61wcoUtLdIAn9sFIn4YGKGK0p0vwwgro0hvwK+lnOLZWgpCchbQJyvUgnFTTtDFj9HjHz06U9my3ugVNXHsmEYtL4Oy7bSqvj8lasO7W98B7nyt7mJ6F0EBEBH9OYL45DFtxJol4mAdngJJ/IJxlPXHOy1uY6TDt79as7bWj9iGErd18bMS2F9xXtMIPeer8v0by56Oxsf/6rnz47H1xOtrN17epyZCEatpydTW4bjrtZv1ptT0qbYTRxXNFO01EK5vJzOHsy1mGLLxJkjjwSLyHG+GJAQZQUP7STnS9VKvIhF8aVfg2ry4uBDBEIE8Dn5xUY1fWJ3Mb1XowwxFnlyhhLUNB8NUS6DSlo3k1yrq5MUCFpwg7HxWQL6SM9vyFVBUM7/Ua7D8lIOxGqb6vnIgvTtDacrAlWR/MvuTB0t7k3PbWUhF1RmhftWjRzLywwiSuFbMopUDLFqdEpQDuxak1hxAh2nGBJlKH/LCqiM79lEAddMW2RQ8EbRWtOojPlKZHu9gXGBvUcOpLzkdVcojTvWiaZtPu7JGyirrVmt1eWcumCe7u9+smm1W7NpkNDTKYr3dfIoka8aDs7EzY0ASDPL3kZlINZhbwhToqjRzPQrQm309mg2twnL0j26mI248lHPZ5PdRvkmJAXXUSSa2RS9C3A2/rpUc0aAnv4NpYQCPAKDilKNQVSnASpkICesXuajzPejZd0SOkSEzPDvhWWGtjTwpbuDlTYP0e2kQqXAiKxFdQcE9hzqoRACj5KA7hqLl5cPtYqzZv57EtFfvhMsrB4jhqH8rzULy0PKsN689PK9WjV+DabrV2qP9hjfC53W7VDXfWr01a5fNRoTq8nv/3lb+T3n022r8fL0USGfvxuCcatd8R6T3ZKKV0rzEz0BdTaDuggQD/ROlskQRHOAIUren4AIDA1SvLAFFtC/IiXxFtU5IRK9Y6nBrEy3Iqxpj5AqceCAh58b4hiq87/PtcQ/FoRSDbP9aWfC0LHLZBOWN6KwpL1gsKIMaKZ7AUbhVrEjzLVIDMvI3EYS4IwjEX9qyqivm0dXWudzi7RkjE26lm5fuhqLRpvtp3kAZHrsf2K9ISwgXntUrz4xAODwSVnr6odWJU2VDws1sSODovXLecbvBYiIf6ocpgGKaZaWSZKDFwiIyxK6HkEexE0EvzD6jR6S2NKiKspQueRIliZdotpc1tfqTes7J0PXhPOg/Hy7EokdOeGm54mWTUIl1ara5gAURPfcvRhVCJM5TJ09DKqJgkaWIA6LHxCXJkSN7OghIokwLSkCiV91ceW7P4JClahl972zZrsF2crZ9ao4esxHRsgE/QmT4njyFiRXXhYCl1m/gTUQrVKCbjIkA1FSoj7CDywkGqWaLIjZ+yikexGaB5joGZKhjrwETrfZgqZYds3+hfBi2ijH/sbTerVFLNBI+EhMdSqqUcq99fLO8NHD2svTufD18NO+713G9r73DxSWtfq9Gqr635Hovf6cL/V3+785V//7Nefn59cbs7nzNytgcGt3UYa3QzXE6uZ5tJZ+03JGGw0xcBv8FhwDlb4DcXKk+uLChmua2YyI4HI9kaEi+5D6klvDNFQEMJf+s8W0pJSTfiPk7tSHhhCHovImyI84RYULtIwnt7QZJkQpQyxWer2moNzQQjEUnj3I2TiOEBxoTkiwE3Etup8I45jJ4Tf2d3rH0Iyu4Y72X8dRqsbyf1mpjFSSXs0LIc4NVGVZIJZZ2wOyI2kr3dG0xCZ4KuAORtU0ZmlEcToleaG8FCagxRIisuDQrYpBL+Co5SssCcjMSzXHw5N6yRRxfKy4PRF6Wg+GM0dLqawiTrFc5k6zIALXkgAKSxOlSjpsVbXx6s84JJ9ZjeJ/+ib54f4D0u6kCQwa+dnXGYgCHmBPikUkiPpPHUpkPbrRmzbyzXDLaoTxd9x5xSFkoRuUkGbIBQ1wR6V4NbBLjyxcp0SXeJqLcBa0HlOKZVmLANqQR/j0ERD6V0gCr3hbDhOlR1kxmucJG4UfcS3gPft92I5JyTwQFJZteZmLHs/gRoYxTDACCn/4fLRq9UmYBn7AaH5HkfkeYgQMLlK9vP4lgeLyW6334fppi+q48fD6ur5686m/oCpdj3+1e3370wWte10/tUP3+Y3rfX22/X9p7/9/N/91W8+P1lfzxRnlqxmTz8aSvZioBiF30ExgiTuNjlVK+3WuUS2Itv6W4KPET+C3LR2YdLYw8kUIRmcRXUyCrcSu8KiMCJkotYpWC2NOMU6sIiFK5xm1CQRBJqgRmg83OLENtshXTedd6ubrjqKauXgNuhWPR+Wh2eRbpBW5GxQGcqJmRllSQ2khHen26S0KwcHBzr6Hx3eQu3AjlvVO61mVIOtCotuq6SsNhn2uqaGHuhHhhYruiIeLKGGXNzf24dbus2u2R2EDm2dLDZ04slD1FFu8g4iwt/I8Cwi7ie+juRbyLMvsmm8GITq3ALvUrGFPEG0oDV/PIiLJzOUIyiGfnxWubyst1SeEw7yPem35WTMKQmsuwbM3Ovu86Zo8Tya2BIsiZPpkyROFm9I/YgzSOQK7Mau8eqvZD3hpGBP5QeYqpZxwn5GnTyA09V4VTHeTTKLGFz22KbQMYB+WitOBwMhW0qWqQrFz1ZL8PdNEA7hFalO3P8UjsA1xe7BPQ1ydTwstYiobIWbZxyaujOCg81bUHuSVuKNLQyplLpjXFoiXmGywSVS8SDYAUtIU6clEoZBcDaOroUc5AlGFCwXD+vX9vR0uKflwnvvHI+vv6ysT1t7D/kk79y+u5o+r3YPDnbv/+qnv/vzf/39Xz6/upqJWUlPIt8tbMoZwjhj+lybPFTaHnTqzXgGZAl75J2+jmvwWEF2SeTlG2AMKHHicW8RgDCcAvvAAaaeYETknid0gZ3SXqflwpJiYQLa4I3odvaiRzR4nj15WkAGtOGU5WKRa7WrsRzPG8CdxGEuFTHhmEqoHgEVxqnvCS25PYaUGY/X6t/qd/b6vYPd3uEBV32jo/Uae0W1GLewDneLvW6fvBTlJapbyVqTqTiLGo5O4CIlqIyJoGnFTfGUpCzqA4/zAop/kuMElhsiVJzsuBNOCNCTICHvIImYYkE86cy2usYIlisVG0t5TxRgocOTssXCTDwBJo+ni+cnsCiJ+SEqexigmdF1AFwFOmPHegjDJ2yOXDLLZggwaHupwF1Llh4vzAcRQQuejEtKgIl7KJYWkwzy4mgFUOP3DNOR0bVk4DMBeNgwLRIIoybTPw7PqAaMRutY0XauErSl07v7ZA3h/gwbIyfCmySKUw+Vx3xA8mid/KbZoAeN8hgeie+mqIDEEiDWf46zPD9iM/IUGHBv7bn5COQzgQ3xrMZAiQ4NSuM1iFyI+0itOjWLASpC0JKelkV3weKhxCt3xtfrYenowbvPzn7HQz16/fTd/fcPb39AxA0Gr4zRapf2/ov/4l9+8svfPX58OoXX3ZiUNhWz3zx4+9aQNfpyup5PcVz8UCLZJEhZeh0bBOnymKMSostriS7haN9ZjTQZqtNqM26rXp/A1BxRvFPIOqVIke09M0bFpmMbwAnkpt8y+nmb40RZFKjPYmB5Mam9tiEoMX7G18tNY7133Ng35+yL5cU1aeX98gkAxeiYyEuniroZLa8G+s/clWfGEbEcI8ydpfiNto57i83AJ9RDEj6A9oDVj9+KEJlkePzgsdp1cRvtrG2LI40Ao2CIBAEDio2iQEQJaCVKgbdD0flyinlfsnqtCXOQuChKCB/hIrWIujj6QAMA0yZFZkdRFHRPrYHstiN8vILLY0LMRlPCD7fM5WItpnfv3e0bLdMWQApkcznUzM+k4ZT8SFp0vhwJnJhFoiuQEKT6E592LkRSHCqR5FaYjYI++t0e2RS1QT4xXPl7NEF/8xCL2dyvCA77l23Vw34mfSssolmSOJHqA44qih0l4H1fnp12oQ0gctqUcuHan4+HEq3sIVTHlo+iBnOxWag5JT+40Ma4aiES4uuWe5eFJOaT0icrJmMRhKQO6jMGfNwdVncjRZanWLpzkh/sEV9p2N5Aoc3k2fLu/m1R4heD6Z9wqp/3PnzrOxejUaW9Pj8ffPKzF7/85Oc/+82j4Eq39PCBMxk6ZJEXPJ4yoe0RRaD4j1VawvsEswT68mq2HKSPE80fbxgeB1mcgBXhZJ7gAp4FX/Cb2BllhtPyymyI4kYMpKB5mku9j0dHLv7qtsq7QPR2ZzSD79Oxjt0vAQbyjXemsnPQroL16IXAqHRuOkdleIYLcz3iWPRarBGHQMzgRnJzO1iNF5dzJs3y5u56xlVxfHzUbXd3RtIkjXGhU+vXdqPVF9wF57jbiDDHEnrd8gxOdELmRDZHGfu6chGhRbs9xZHezLiJPHB80r/eGGRIoUwOJuwjvYCOZkkLDxPGKA9lpBLAJ7xZOEoDFe2ayTYbiDyl1onLOlGPwlGkIp4+tmEl4Z2GjaA5UYushyL1QPHuLEmWtieDgLGlaQpbo+slIJisw56ZRGqyO1XkyidVijiRc6ptkQMNABFpQcfYATW+MTLCBvqtE3i0AE0ZaJvjTftO9RwaUQSe43n6touP7ZhGUiC9V2tVSQ2mpDFaIXRdIK2HeIv4Rq4oGKHy7ZTXkhgkhQSN0ZVIRp7pG/ni8dZkTZnJ0YLePLqdsgQSLmpEiQUms3fpZRKlEPe2ZHVjGoTxxQtrCrF5fyvdartQL9v6TPZBaf/huy/Op3t796sYWSHizs3+g1ufvXjyf/+v/s2zL84moBvhSafrjylNrV4dShVoNdPR6fXQroKMYCoj7+3D1oNu5fxc78Dk8FDt8/kcgdtJxIvyCpegPSPO0W6qbHNiiYvcCF/LSWRqtIoYuAczSufqUmuwRPICcIUnd0r7egfJttNDOQ0d0JvcLIBHGDGVih3l1KXF4WF1p1P+3antcXbKvkuXY5l+2YdC8luP43CkyDLSSGzn7ORSne58u+52m+pYB73trf3e/mHPIVyvJgpgDlrV1+dnTx+dXZ1fy9wtwvhae9xMhyNI2kQ6bIScb9+5o8asd+fwzsP3mGfS5lBC6NPpQwIR4TFd5Deq7cKEjpe3iHr3rkazLQufD7eI0kT0sVfjCiZDZA6BfPAPwvEHfPJjSId5zNDg2IEJ7WgwnrvB+t1uyyN2ZKfqJLJSQN+ulWZv39v75aebaqs90hylxXSU+lZ+0xvGrUJK5BMOZi3C0pxoujuA1jHns2nkkP8cYjyLMVDtnxc4ATLeVa/qcF9MhDxEeTGeSJ9m/TKgXFkas9+PxqPdfpf7CoPGPIrXLhYGb5M8NgY7kwg2MHXUBaTuCEtAlR4J56BtmN5exjdYIAOyzCctLa4BMXZtXpJEbQ/oeUuzO74Fiuxf8i5hcX03PCHOzRCn7c37h60773x756D16x/+zeSy8ssf/+R2+1at1X9+Nvo//5/+y09+9zSYLsIVdK8eVMoHte1bdw6+PB08AnEop+GEZOGssneoizP0akhGljjqUuum6g2BUZuR6fHzkCbRstFmIUXq3574wSKpJIVDBuZonaXHWe+wvXesF6NODcJG2Jy/LSqO/oNRkbYjISdJKaXMylZcdbfXAoH6HfPmbu7dO3x6fv6FlqGxLvP+Zhv2i//UtoRSopki2AJJCKzlZng6hJN39/eMEF4ew/al2XjW6KoKtLe1X/zdz55dTx5/fkl7kilLzZEW683luNPaq7Ta5EXl9tG80hhhLUc4qdReX+zu6Zmg+2WkN1Kn/zyqCALmxwwoHj1x8kTMFyMwoFPzXdRX2DCTFX3FwIuE8LCBwoJCPhElBs0AkPOMObO1eMlGQN7gFh3ijUJDHpXX2xgpVgEIvVjN0NpkPFAngrMkH3E9U4n8V4k8I5n4WnyEx9DGeMlAAuZntopCQDRIym7jM/KeKPRR/pa6B4ttj0TpobQcQ81ite6RK2JRbuUovMJ4FYvmIpxJFnIL16KXUhMvoAPJ3OgiSAaiY028PCdPGg9USa0LyKvXItwfI4EyqcBaNEdM28iXnCGnV9AUWJXiPWgCvoofN8oXlxXkwk5l70RtebhQptG9pfffkmZ9caoOo7q5Oj/9949++8/+6B8/e3X6f/2v/vvf/PpLRMJ72iuXbx11GelKkkVhvzy9ujaxJbgVB6ga0ycoMo7Akd2w4ijkXihtTEJTzFZvyyFJm1eympQLCATbilxV+0ga2i2sihDzX7k8jZ9706abzdQab7qN6rVhGKuQL1nICtrtVAfA+BtjQnagrXZlZ7MtXQ6XVjsal65UdzYr02Fsr33dVEDxdU06gIQn5IT/nUhB+mFL9w0il2Qoei2wcTU5a5ycvGi/PD7a2+ck2zk67J7Ot6/NyDACdTaGod+6d7dc7nUqld1vlN96794NN8jhXTFWPrmiTsWhSh5VURoJ6ZhDMo6PvCW4TbQI8xObypxSshKeTA0KRdKQyPDGwcvxZDccbaG0YrrQRRZL6JZBmuSJRniiuwKvR/JKBS6sO1IGOqnwRurZzRc5NxgjBoCC482dO7V+WQ+50ZINt+nygbgATwSySQqQgFs8S7hG+JXwlf2Eq2xXHMgYeS23EhSTNZFsEJ4yzrhYo5S7KgnOiRjXfOY4gQmP8yrKjsGVbluEP/qfs5hzxD8IWd7FXI4RwGq61lI7uwyBy+XZ3Yq/4jMml5YuzpxHENxbyMd2MSpSkMC+wrru6VraMDpHNAYEJ94O/ke30oyEjJp6QVm9t+BehOoVgTwPy3fAjSMxSk72iD1Ye352Ko33v/zv/tX6//X/ff7iggO7Vy3fatXutCHFkrmK7nax0MKwcjkTzAaJZGWWD3du+q26MW1MspleUeoQoBfuWnWl5Z3v/cG3NWS6vhg9/fwLhWBcKvRr1JNsfmZ/GCf2QGR7Xi3SWm82TO0vn1+dnVcPu81dDZXNxN5rmli/26sc75aHr6EVTJPniRgNPZG6iYw1umb4IrDGi+eX4+ms2S13ugyM3KQupLHcTOxIoUm8lK1D/VEEUeS2j/SGfDWEXYznw8sxnSXhAi0KPrN2ReB3ZmPXHz560d0/PPjuN/du9Sq1FR8S5/Wi1IVNC+vuRltfjinecLlJAK+oLP4kkuEUMNU/NHBMwcxiIatyd+8nJ96EUIoAgfezUSJgwweWh8lVpWGyLNTPoU85GBzlCItAQnSWqraj8GHyUK0NWTJ8OyZl2K1F1PZ21rcO2sN5/QLx4YwUl8uuJFixaFw4kr5xuYuTNrV6O/6l0FB8bmjLgfJ4AnAJhFmK/B8+H7KQm8ZYDil93AJJ8UeD0gBCpsDBhgGMUp0RfOKwAmnANxapsnqygguZWuZ2onBYXOCTpvLERRS/xnrxOaPgaEwoKFlD2UkPnDeg8XjcYKyo8bQniFDkCKNjPQoSicUZ+ymSIim4UBOrTMJ8ozT/2r3Dg/32i8H40e8+v/hyuNg2kps2vRkOBoiy16p2a7yEO72j9pdnU5EzkuAwOVUC+PXpIvNJ39qLh+nJSOM7TM2PnHQtyLyXpt/g284/+iff7r59X+/y81evhC3J17/9ix+fPjknWNSMh1yi3u23T8bqscnBi0BdXCLb86sJy0EIbHg9m65Wpul5hZPR/otA2jnyx+54T5HPVVKLengkIYOgX94vlS8m4XOPzE5wlnx6O62qedWkMlgYsFLAMWwQhuImLiySwHT4lHar3AxnQ7fb1hQ58OBTrXFlnF8B1bNbAuHDs+1m9r1/8PV9m6UesIwHajecQzx4BYeFQeMHExT0wB6JWz7exrABsikge/JTIpiIUSWBks3SJkcmiBwyMhPEYXObAOB8KW80KNSQqxbmVOEdAWZQE+eUwCsXNw0BR0jy3SBeldYs/TweoA6Zmt1Xbh7eap1ONyeD1FbYIGHnpeh1liBagMGwome3EpMIJZwG4WMx2VmgFDiRQgBXlcQJ5WjBiNQLDybQEd2EQGOie2M8V4a/txyn3VA5EB6KbPafrfB2KhKnBRH6TBE4SzIzVuYNskmxJXjZOM7hDaUqqL1w0EKAybvz0owDIZmh2DElYWRGbJR4g6eLWSMVkORFLcnW0InF2YAdlvjyXmX93n79QW38ya9fv3g+5mL+8IO3f/DZE41gK5PlXga/0bbhlUeT1TWXpooimgTsNMrxZtveVA/3dXdPquvpYDrMLHByNTob8VLiBwKh9uO4+4d/+vGqV74e7rz/la99+dmXt/oP/tE//ua//R/+4s//Pz8rDzFofeHekcUWTh4HTMH7RYQAbxTd+nREpVbsEzV9oXW36FwkYCg2x0d5xMghoxQLTWY3x9sb5h8/0C0HMVGexFm1o1RsNhEkqnC3F/kgBAyfRdJjARsLIFUDinxZRK6WuIqlvfmZxGK2ghGFqhKELzGFJQsRksvl2Gr+9B/9UadTbZVmCioN4uLeYDqyEYxUMNwJZ6GtJFFLj3FW9F/yGuUEJP0pUh6RuQdExmorojQhkmJBluhbAk3gWHZ5cuWsrbB/cKRqeaAqpgLTW9gnjiZpBmQGr5oI8Ayo5vNIzKu6osJ2qv3LTf9sYkqhY8x7g8Ai3UWUAeRMiClUk9/OkXtunpCOnLSYpwBLklU9QqEVQP3oYBH0nEH2jLgBl3QUyFMmLdMRM/fnN/Ly85TgDT72kMWREwmCZXafOc0vEgHPjnSMsRQ1jSVvUF0eKtSBLXzWJ+m2JSVp6TA2KJXAxCrjOZj6bCPkb3WJA6gpKOA1mWoh6mNEUTgp5w9K5a+uhu3LXHlwIh29Udut/eJnn5Z1l6WbZK1stTSdHPXk+DfEygYyOURBt+s7B3iqI0Vnu9woEdXl+FxzfoNt9cQs4ufoB4jrNGttY6tqpbG+/aPZ7YcPD/b2bOy9O3c5OMi0dz+490d/8NV/8X/5Fz/55CKOK+fOK+PO1H5w0XriB4wbpIjOY8hoyMTf3pO2hVwK3IIIDMr1hFF+/ueK4f0flVpn87fvVo8PzSYoffZ0wfs1nghnKqOrTpgoZG/ae7KgOMQK2yh3cW7+D0853QBFN3XF3IpSL9SDk1Pc4LXAAWS48/zTx29//WONaV68OPv808cmXX/w9t23HmaG9LX9ZpVxffl0Gv7oHRAhT2yH3wtJVXg/CdQ8vrsjqV6zg8xGO2NNRtylzSkkTZ8/BRmCd4LgRYpQcsCrUo8YNH4R1ExWQg6FMXBjCuCesnXzePbZSeUvR0LIaGx7uCufS8u9mwupD/U+xN1bzdXSJ5TFlETHMa85IxnTqJPEjU0DBxFqMWn4ZtBlwBc5INcgmFMDeJ5Hg4j1ydRORxVYmnHiRglJQpoc9q7odDyeW+lByVDA12ESoD+1i3CMDbeZorNxVmidEhgg/JHRmmZw0HnOVoOX6Hq7Hg840UVn6UR1sxFqywIiYSAhaAsutiMca0AaXysdklIJmt7J20TpHTzOu6v5QUM1zKrJ62eO3BXz9/XV2XBspJ0g/UbTNz0u68N8aNl0ncX0wV5yhNUOzSdTHR9k8zy50iYCn5P4qfe2S9zCwSJwm9zaevVqPOT2kcN5q/R2MA7NEG829bpiWf/hH79/d/atP/9Xv/sXf/vycpnaBZfAn+JMrlfUcrokHFVYkOSDC9SqAy42oA7FFLPuYFg0QLuTrTAeCD6cVzbnBrLpJKUf0k3/lgzP+s2JJ9p5NTC+zIpWgi3SSSKPkJ4KFXLMg1COTsalfGE+pBCBVbCgOxTEEcFFiSJup7bdGZ9fP/75b+oGPI6Gf35+dvzwHqIwH/r2nduHjd71TXUaKOb9cI3dFh+Mx5yKjNKjfVBYAIEHIHZ1R6u8feuOEl4xRXLAOjwySkcj1kqEzWK7JZhS5JIHvoG2/sFavP52NZOW5O01y/sVDW6GWtqcDEAZB4rVl5u5IYLyldoDCf/1zrsfHK5/91jBQNKMuQfjXre6+Oy8oJ1avOaCA8s5Jys6JBiRGRxNiKrLje5EYYg9fhtE7fcukdtheViNsE19sQcD9QhlfjqLLRlk3BDXWLsk1cV5jzLJPKySjSi8fajEuAyqIAC/DnAP6yzcROak88grCzRCZQ7c37yioQCIKrUXOiqynokSS6O+itPzIjplY2EOqkn3vFp1v5fMoGarMdfv+a9+/stPr78YzJ4NgqJVOlNBeMiqhNZcvr+9OegRQ4LOZbbyXqN+OVq8GMn/x5xOnHzxbhI7pO+5dvf7u+3te3d6r389kTPb1KqRPPG3/bRQoq5aNve3vBnWNhf/9OuN1rz7P/xq8uU4pGZIY+Kr0n2Jy5BAWVY7KqT3wSFiMOrfqK+wgceyYW++4Ef3j4AQEUNsN/PSL+fj/cNGd7d6dTbmNa7VO7Vht3VYm1++7JQ2u+DHzuYyUbSAhsJ8LCg/KsAdXdbt87cl+0VeyS/Ck15FMcXrijcHs/HOiNRr1l588fLTfvuH//77f/ZPvveP/uk/rjf3LzZSz5BpmJpci/s5vUsqSBi5OCuiDw1Q/XXpIKvxy/OBifAOGU0gHhSJeh177L3wY64hMoAb4z22NEExPqXYP5AjW9orMMOkXV019rsX4zVvGb84xtvv9EqzS/66gSlEhqpuZi+/eKqAEwwbxlm5LoJXJIALJGojbE74+Y1mRArK5STmRk21nkR3jHZxH/vgcJLFQftkAFoWa0nU+BtrxvMR5bGl9AjlCSaGpyOOFGRiVfGhsxntCanIDsYYtrjQvVJ3bBBbi0eV5uOXWAm7sm2lMmAE1KzWEXxjbTKPqCoHnyiv5XNpgU/+2WgBSdbHYRAFk3IFYiYMcyONunydWdGr6bMvH6+fnupZezHClak5TB9H+i3AmKQtm4lDWDKs8Nl4sjRW6vFoeWKQuWGRmyVYIss0++HXNU3UGg/fuf/Nb3zl3nHzvdvtn9X+6tc/fSTfRrWAo7M5xV/h8475yiqS99rzJ6//l793u7y9+r/98upcnjhFgFpspI3ln2LkJPIfepS1iiPtJghTuO4CCHyRsOGKvCUyCLwRxCEdSuNSe680OYMpZHrKfVH6XJloYlZrr26mNp2rB86YCdpgpELqF7gnuRvRB8g/YAdsiegL1btL8EzBdnlDuMNN/WvRCeog9ZVmwZf/9l99//J68j/7s+8d3bszXDdXJa2w5WlbSboO0gKOykknW8kTurmJdxUep/H65nYxyZLtGFAHxccjgDiIVw5lNw0HxUrQJ0AaDINYGbwzJkZJRHCawn/QNTthsNInfqt1RVyFxFljNTlUhFZblfer4+fPdmv745vxqwlcUghoYAC5izIHTQEWmVzENM/WFt7O4vZ1vUVgIWuwtkLqWxSBYP0xbnyrwSBuSWoXz5KlOHWucpXR5pTaLxjGWaZ3EA1MZWTr2CDxydnJgkoNNJ6x48lyeIUSbrQ7nj01ZnGTKaWjktLLBGsGC6VdSnBbZOsNByvbuGh0qiovzJdI3putdGge0DlSFPiNF/idzfL5bz558psXbQ2BtuUemKQYDqxEzTuxRD3Ybmlzl4hYzm8J/d7cnJd2hnGdRdDyEFiFMnfeVxYWqU4ed7t73/rud/7Zf/Qnt24bcHl9vN9896Mn6jq5pKHhbFqSu1BxjC+WGdfh88l8OF98/a3GPxk0/+qL6VgvfzvlGDj0kgdcaF27GN3BQqEH8CVBYT9DfUjzDQiKVPBt/g89Sg4ZJYi6c//B7fPh8tWrOIOqzam/oU9pKq9Xi36jJs1bakhiF6v1OBDWZyNYsWoMroLqbYRXnVEOKFfHyAUNROCFpUPE7Bf4l9OPLOzsUfY//cnnrV7rz/7DZre1Nwgs4DDT5aPIC+TOjtq3gUBbCkT1lWuVxuW1sV5Xs1or2kUEVm1A2t/yYBKyLD9SrUgmsOfSiTkiqXp3ni85fXSBbrXas8lUDqrjtMyYqhxx0lfXo/t33tpcXx3Rc+mkOK9vhy9fjZQKTCEG9RgGFtfrZvt67rnOfOtVr9ODlqltVESacnQQQzpkyRKvtZuxNtM6JB6ccGRRMVnEWgM0RLXiwueUSJqXBr84lCiLiMnTdrrIgcZLYYi9VE/tJAF2PbTioskQv2RKpkw7uVuS3KYMQZ3vYAupFtLBXYrLFHkTTh6UFkAMXmSq+AX8L54j7c0FiBFNRCM9ohfpYZYV+4Gn14k1L598cfnFyWRUefxy9Ln0SRaJWX3RGHknCf1Wp3GACY317hEzk6tReSKe4nmzsA2gEm+6IbCVyij+LB+ir2paULaO+zetiUzPdz6+s3p9dv+je3mWgk1sWPJi0okyS0IizYPOzgDQWf3Tt1u10c1vrta6+iexJxEKXBYjPiQYYz/qsRDS8Y74ufjL/vmt/wH6CFa7yJXBASh6NRdMeHGVgLXe5JkxarU7q2hoOwKCZqwJMZOCFzoZtAwOdhdch8ddPyzwhtUcQn4MI74BQcX93ywtQsbCwjCaUjb63YPbd09fPL04Hb1+efbgfbqXWm7S+y0jpZxWnPXCuwApyax3lsYLjoxMAQqEAaUOxBfsfQSbjSAHg/zB6dBGZB2HS1bFF75a8M3KveRpNFZFWvdRg0hfSuKWQptBnal8bGnx0DM5mPCt14fz2d137l18eQZ2aehc+KHF8ZEJZvLkvO2OE4HxI0mvZTwEfXo2IW0Mz2cfnJ/c30IAoXSCH6+w/xAPZeAqKiiCh2PPwc2wmVKGluvnxHgSA5iZBHPBLB4blhfHQoSivQZ95CdMBVGIE3yfTU3+lufW5UiuCPSctsewjc8ktyI8wFPrdxiVruG2xZj8J5Tnmvkiv6a4vMwO1CGgzzBAKuX65fWs0eopg161Vv1y4+VkOU4rl5oB1nIz97Sfa5a7O8vmaNXv9748H15NF+OU1og2huEKR/TmyJaX60OYhP6TVWj85mSiAGOvt24rb3v0ZPTyZbP5h6QcYVL8R6Pn+IKZ5qP5cLJ/dOuL11+KTh21u3/yXnP32eLHz2/O9SMyTCCAApZx5UAa3/jKtuOnAogH2IVCUUTIsVAFtsq39kJTLTmKSb/ptMRHDabWqybCv+CmOON4hWO4JSshLks7CSpA14Vk8XII3R3cONcvdIu7hSf+/3cN83mfPbEQ62OojUx7WzwdTgiEF5+d/Hev/uU3v/3gG//we7r/DkpqzzlvtA5Km7foDAwlluUemKuyt5xPTOEkgFyw8JNG9mOA9LqzSO2o4hRGU6J5NDkByp2o5ZXclnQI26vVjhqrozK6csXq9PL1Xq+vEVzKUso3R/t9+QXXxD9vWOfwNxeTHtmW1mlb0xk5/Au2Iv6wITb3NLCGeKWKlbhhYAkhWYCUQzNlrrwVFk/o2YuwC2EF58SZF/cRpuEstDHcZ4SS55OmNxNGFaqIs2PbajeUU8ritFI0JYYguxywwd02PFiemMU+8bLGzPALPGqIjW+SzuN24VCHJ2rNUghEQOfMKI5DLIDgoADFM5YSJnsDtkSUfXlElsO2qbD2y6eDnz7SLK9xkfhcqdtqpHViq/zwg3cffPx+97he+cHfnPzg+vGT+TgZcolr+KyyIGZIMH+93N7vXJ9PEGiV9dCotls3H717cNwTvbtZf/nixU9+23nwYC0Zq7COwuAxA2z1ylrt1qsvL0avb9r7/clm/uXppLGdv3dM5DQ+u1qfEWTV6mtjk8jXSPgI4JBeaM6/BQ3a+QKCh7e8K2o2NMkxwbNHWQkmxBFdWcjIktA7XdrG9DQwxyowJE6ffLIAP84d7onjpfDbWKgHDuLKOwpphy7zAavI9jr/xCverMm73Ncy8qPL6tVcrb56fqXJ0/jsk09/8+of/PN/2H//u8vKsdZqjk2iJbBp7S4gcZi2K1U7tI/EJ3EDR2QVDpRTx5twTehGe8tkrkbTcpWjmiRShlp4QgROVeyP9hvrdgYLlMZn53pCawTFpag/1i3Ce7EcKqDt3ppPao+vV+VOfzm6GAyvmYrSc6KUbF4ebsNlS+bPxeuAV2K7aLHGHwNr8DNaMhZhkzMTE9nIc/sYb4ksnYIskbuNClgV71IzxRWn7Y954R5O+UWlqWlgPEeV5nrBMg6uBBENXXIpxgz1HCVu7Kvu+Om96kYEQMLfiSkzNI1gKvLhkDXedHMs4EwwSiwgjs5G2sXJYbJVpDJ9k2gdEzji21PSGBvlSovScjjbfvzw3hcX0N2y36/v3z748OO3v/Kdj3bfe5tNM//is+vHLy5H61fzzYAbL4QF6qduwV44OVHu69Gkc9j6+KMHDz9+98E7t4+Pd9/76G2jYmaj6uXrdee9r7z1D39/0dIJp3AuYL1i96xKBnBk4Lrz13/923sf7H3t/ePV+uL0xeLBfufuQrJEfbacCVvoK0vwjAroUVAiwn9Dhm9ozXOH3G00g72gPrvoxYB052B80X572+2QVo3BxLhNlX+iLal7In1tdz5PupIdxdUj8knzAnRhJftFfIXWc818FXyX6xe0TvSF4L3697/F50klS1IrMuTzh7KUImwrs1/827/5xrzcfv/bC4WUvNO4VRelGxUUquTHBgmgj/WNqUnxfyQu5s4MCxavBiRFxY2Vq271elMhsJnbaUEC2cXKjC11s7i7VzZ3rrUtX55dierOSh1TdvWtkyJt2yeTBaU62dSfvrrs7nZvN1fj4YT0JubdrMA4kR02TkaD1/EArkizBYX5zSIQIVogUJZRBUT2xnMWAsTTETOh4VAqDuL3iXAQr6zwkUSGdzr8zv5OFAY7IUS1Ac2Eh2G/bbMjLwL7eDamtGB9TEwRPksR49OtjvaIZoLGRMRg6fqWD5GFbl+CESUGa9aesVG8qws9QVnJ9CMPvnNlzpMHgQQB6daMLigu4cxq+969P/mft04/fykL+Ov399vv3X34e1+9/+EHDIVJo9ye1xa/OBk+XT6/XI+E53cklJOImYTOYhTEvn/QPtrde/DRve/9s9/75h9+rdnXS0X9OjNcbXm9vn90/8/+ie56escjJ3weKmM1Z9fgk7aEx+kFiYVb2//ib86vNzv/i2/dMe/uk99ecmWI/Dzs1QYkBWOo2oDVofmQXwgQE4fefButEKHssd54ahDmGxkcgvUru3rvYe2d++2f/WpQvpHHHe+ut5hpe0BCjwZ84CHnCBGETkrmTAu+sEpskptYOxonj0kVPraIf2+Nd4YiSQw77OBVVoszAaLIHjJsPZcuAI4pg57NZi+ebdZ/+Tf3r86Pv/b7le79umT9rST5KxOkZXQQ+NvEpAy32w0mFohkHAdV46ZEIyAeOEiiTV7gpfH8RTFt9DFn4mKx21rcOy5jpvmVcmC52YsRwmQ67qwPpXezuuo37759NO9Ljpm1qrWTp9PPX5giiAH5O0L/6AOZcb4iHDYx00E+RqRKOX3/lQ5gvxQwOkHe2KTskGA8yIW48PwkCoIsGntF9qDYYp9yEq45wYuCqlzsgUA5pJgvYjwxKbnDNMozBSwiB4J0uMibHsWC9lWKHQMyOCznS6joP+OxfZ/bOKLc1zq5w6zOIcnFSz5d4v8iZq6U+4VsnC4URPhtlC8d376zOjubLgbvfvudzsP33vqj7y60bRZNZN3f1HovrsafPaWIbnEZLdZXpZtxtEpcAVpg3D/u3dpvfvePv/Fn/8k/PLq3S0uzRgA1vjnkS/1nQdXr7fSaLc75ooKscC4lfBbrlqta+VX9oHq095X7jR89Kv3NTy5Azj/4oPX2V/qnr6abIaAgE6lSW+TxyUxIz4My3jEh6I7ussv5KpZly0Lw2aKEs/ySAY2qRDuaN7364v7t6mfP45oQXYQqRX/effj26/FEAmBB2Y5fabivIpJvW7O7MdVYTfbObidvJwxYnKrb2dJCe/vZvuQgvBUiyNvBpxjxCbsQqKWKWT8+Pp/cnH75VMTv4Tf+eIVwN+Y4vnKuzeax1vKz0uJ6uDy4w5qKt8eCyEfiKmKr8Mb4Tj5CcjCxRFZYYvlxGFWni05z9tWHrc3y3GQQxdvSDUHAVB1yNpBZ8B7R1EE126/c7TWWR5+fTgZDjZI5fzRboBoTz0xqM3SVPleJqYBLpt1AI0E+WA5wXM0J5Vju4rzwaRwAtgvoRuvOhZyDGqG0IrgoId0O2cMgIpDNJUxjfsM+RfWaYJYkIVzHNEHAuk3IK8JOyegRTV6PREOK9EBWjtpnGSbIOEQguZpz064D3VREkXApbTvx3RSiRxHh6CTmFAxlXWCi8BfN7zaUc+IEiGMiFXr3VvODzfG3vlW79xYLw13leYio1SfVyZOXrc3k3lLBwPaFoC+6i9SjjpP8//GHd7/7R1+/9/H95q4W0ytN/hgemVRptzgzEMJ6vF6cQoLqfiEBajG5KFZk14S4EZBS897x9Nbwwz8cffjl6EfPR//+l5uL0fybD+p3brWnI5lfleE4gdJjFU2r8hm4kYC9NjTmU+wMV+trN8bvCNHK8o+HQ7KhxYImjXNstDU9DQTdtOXwkMuwRbFzamg/efXS37RxPpyExHgrbHG2LXolPi7MFJuFRhb2iPoK4ds67wtCYQNE3kccetFG22pXk3njLBLt4tLd6NVCY9/EeyH2d1Ud/vyLg/3bu2+/o/NRrdmXN7vbabz68mwwGrBYdMJl36IyC3ONyWgUtAQD82+neMSquL8pD63B1InNZUpUbi7futMdnJyNpvN2rXN2emUSpxTTXrsty2pXwx6ZArVq71Z3cjN9ebr67Iuz354sXl9M0yBZI7QZ1zAFGrsWJScFISWa8braUwzhlp6QR6OwH0ODQTrEWswPGCNbZkU2BqHFE2/1eDgqIXpwwzSUg2X4RU7e7ruqWIb26G/SsFJtuUzLflzncJEYJ2bUiQwN7cLssxaOoIvogda+eD6SSR84FyII/ShAIM7nptHGPLNJQ2JHSmnKPhocixidopNk07gLRsAiWHVd61be+0r37bcrx4e8ZQFJycXaqOurvbjpXi/Wz1/tzlYntA/BzjQRNC2V7hz29nerH3z33W//w983CVLDrE73QKZ+SoOiMPNwhvDeLE9Srlw+lBatdsOqw/yRn9HhoRR2y/5RdTTa/17nj6+WT/7rnz+a3vz1Z/NXr6f/5MP9u/ebI9PA5nK2b8az5Z6wxk1JOr7M8MKV2TisN9D2hemORejMpW0RBZUr5zBoIzqj0u7UT67GPB9Pn8wqxkPI59I7Jy6b0qxQ7z6hPU18KPHhRIr7CjUn2SG8UNAxiSJBxgcjmtFG8S4EH/mcJ/OXe2OPfNA26HuWaJHETEkEfLojBWf6y85vyHyn85Pv/+Abk6ve0d367hHNKTA2H4+Xw6v9483Fyxe93XeZACAJ5cALvJ5NdH3SoS6mqaWJ/awXD/q13cVoPb/S0rDcXj578erFy1F/f0/rMMl12vVGQ81oBpNqFu6wIczKU/6QT0+uf/zp6/NRa3gxBwO04A1xOAvPQtEEhqRKIF0ySFSERYInT0I0LTVeCE7ExFe8KW5CaBS8YtN9QxbI+tYTksDWy14tZlze6NRV9DlLgFh5jh+1oMZBha/JxnM3JpALPaVtDB6ZZPeJ6SJRm9pXeSLFDUpD4PZ5OplacGBy5h7jq/jmmdqqe+S6QWaEdKIJ7kZze7xsm8PDylwjziqRPz+LTlT3dsulvjfHKnO1uMCk/Wx3Li5e/fn3Dy+Gny+3f726eY3pi3TrfrPab5S+972P3/rorYvh1WI5PTo+ol19yoMAWwWKUFoxB7RKpV21QOIdBV2GmmxfLuQPOvGw7WrnwVuj54/uf/3tP3oxGfzk6etZ5el0/bePJg9365qsDK9hlE2n3n41lQ9R3m/UThcGC0iRmlMr2nXdBlwalZP5auwB0G/kdRgschgG0Ad7nfEDg0unVr8iIbmukp2fkZ4o1chSYfUCZxZSPiQfie5wIhPtia0ryFvMTsEtIa/piPdHDIVfCoxUqJ3wRqEH/JvTi7uPkPIWLfqlE3PHlXVy7B3tDYzFudx+8rMvP/x4fa+peUNHgzt1SoDlWH4mJ7OOyC0tQuRQ4v4BRL+EoAiS2qZbWva3Ix10z16/mFwNu8zs8vbF6VAWgaZp8+tZbRuri9+SQ49IJN67u732ngnPfTqVIDJWZ7FtD84hX7kPaAq3wI3xKGJc37JekAhUwkphHiDFRqVFOsD7KaILvGMfSOzTVo4310bERIrk4x9EZ0mIQKd+ikDK4wQXRrIQ/9n6IjrgeIJTUxqhvNdNNN5vpCDaK4CvY3ARITIqW1hZP0o+UHcgy/GU7glMZnfEpiElSVRsplgLAocLbKt9bOA/eU57s5tdyxrdTWPx2Ho4VRFvUrxl2InIlONu9nwitBRhuauFwA//7vD5c80vfrm8eVEuT/i4Usll2nH54VsH+/fu9g4PuzAliEZ83WgDLP6A+5y4g/Pw2rccSWiPlzvKMAZm4WcgS+jPEAae95jlVv/m8G51Pvv2f/DHdu5//MmLwU3td9fL8+G6A2C4nK1Y3+jONmKCKWynDG9uBnFU77RWm+N6ucPlt9iRsJ+skrQMidLGjdLv59yLN6W9npkbG0mp04ARpB1NT1SrKk6NqPXRB8RUpDtkY0MjzTFCtHXhthJ9pX4r+qREhpGu0SAimMRLOCSu2BACmUPeEQXRBbiBsHRM1jvf1koqT5O5VRnZs64kBv6Xk1fjk5Mf3zpsHx50hB2fvbrWyWAwft289aJ1/wFHgvPuyIqdjonefXHX0cX01dPJ6Krbbk8XN8Pr4ZXGSsIOSxU/SqbThs4E23KjnUgW7LCYH/ZkvrVfznfUNE8NY95snp7NtFG9kcRYdDvkQQu1EUl2u1DUHog2xxKUZcCw6LVJQwBLMW4LmYWoOWaT3WCbUB9USXJgIdjfHvKXYH9IJmef3bIjpK+dgSNivandjCZwzwCYlJXZWI7JJDJiorKaA/gRiBSxsat4JtDXB0JFsdnncldiC6EoyNLdQabIe+kXFIAV+MFz2X/HVFC4i5slHPNJ5wX6542YlERBzUb7FSTp4mgHa57/3S9b3/9xZzI7qdbOcaRLhyg2t/utj9/ef/jwVm9Pm7iqlnE2S2zfcbI7yAH3LRCIW3OQ2BpSEkQhKt0Qx9knD+ArhBUfX3K1S+XDY0MbDlvDr529kh70gx+/enFZfWHD7Mx0vZvG6MueCi9ToHOs231Be5lfcng2zID0kIn7GVG7dkGaaNiKPSzsMVlup9NFPVVTSDSHZDUEH3jEocJotWy+ZAzBnODdpUudFVLW1c1Hkigpk8VIzjinuTjtayaHRooAJK6ZowXcI56cBBs1qeuJqURDEE8xY+Hg9LZwOPXpwGjkmtE42051bsdWtS8/Pb/aHxJlQ0U+m5u7d7rT1086+0eVXVxyUbuZtOiS6/OTl8+28ytlPkaQibk8f/z66nKhUIk2steTq9TZ2il4RgJFq91dTK4OSiuz8Qbc2daxnSjeuDidn7wcj86ZuCY3zbXO84tkMwacF4dkQ5JxYPcDSeAMFMt0i3ngcdgCCUvyV8m6l6aWaFxSPW1CmMgOR88TujRaiortMoBuj3zM7s/5ZmODWiqnqKXGcgpDuaTdddNIfcK7qKCNgUdsF9MKbDVusUqBs7RFAOAjm9jjpuREKvEPcAxTEKu5nIool/hJLYvvLLZdxIG4V1o4OppCBMZ9Tm94SnaBsw3TIIHm8mb28romT7JVf7zenIRNrW551Gs8uL37/tfe+9o/+AadTrfKWDq4dZi24DFmbAYt7QamftqpPD0siWR4uXwegwdV2MJQoPfjKs5imjUyYqfVq93ZOfz9D775oL271/vZ37363fnkSrESipQSRa6waRwAfwo5qJU+cMks2ylfbzYjdFPhA0hNcMCLQ3C7NzIZwxRntlB/ZRkRMJwB8d9pjfFmU9P+KqSbCB3/hWXFwvM/XwtHWvZZLVieK4nrGi+DF2njlUItNyl8JnGhZJdQklBtEJEXCs2QaGYEopAMnEkj3Xp4T4Oc1t07srreeWv/+WePmpXGcHq9vBwCz4rbFtt5aaTJ0mf1m1vrx4+aqwUAszRt5vSqt9tRV2Oi4OXg8up8vNvfK9/MHSKqN/9OLxJGb7PVxwXDy7OD2uLunf5VyE+Eigu0/uzz0/G6dXYyXE6tlehxaNJmM4ajEIjZn8IRWpCjwBFBEq+oQ7T1uicxZ8PWEV8+AMkUWMINiDapCl4v2IgwwvaBOvw6a3LGgdAnZLzDcSLubYNsXvxTpBE8LrlNh7ZEPGJnLeYr5OycWFKJ4FiDcuZsq88CKVkfbg/1UBpiIiKH242B9JQEWRy2QgpBRurX2QPoy8kgEvYDeRda8CQMjAhkhF88d0gWQ222k+rmSad81a7255VfTA3WVBBEBgoz1r7xp7/Xedi9Kq8+fPddHYfZ3DKdCltI7W9kL5UECMVpEmODM5JwSBVF0T0KB3gme2V1RQY8YrMvhbUDdhqp1P/gw/rx/d7xvdbuDyY/eHb1m6W+1sPFqknXFlCq0a7q+L1t7HTalTv399rN+mK6GphfIH2QHohdEzvHPmJ6micuuhh4XkxuH9ucNEDs1uZM5Lcf7dd4r8aUanHaMn2JdSP3bPZcQIAiI9m4Xxl/iQEW0DSSwi66NnvPQ0WmeaUwGoKgbDE7jHr2xrwYNY+dFuZKkoxnO8tbX/1m/+GHtf1u9U71Yad29rtntatkA2iqRwq+vty2TWR5+aQ9OpleLZ9esx0GUl2MWmQl99sN/jFZAwe7XQnGlD91bxyBCSzNZscP52fyqOZHrcrbD4/W2tofNiZkYmP3xevLRy8Vfk+XZrlFiKPijVZY1D95HG4lqpycfQaBWDtUUoRiHiHZpDnFDBmSMKJj8Gh4jWoiOSO+7Wf+J3oKUZ4x3wg7ZMVOlTtBUtjxoCNpESn9JGGyBIcQTBN6KAgxIYG8XhbC9hl1OI0M/MBp0gghq2a9Ky6SGiI9vdImya6HiBDHpkjf95lIJVdAjGgLDUg5wSu+DwBNtiZ+zNICzFFVVu/EqDOEgm9CHc1m75sfDWV9PnndfHlZec6nNjNd8MG79zsGBL9z3NzdnWrWW5btgGrtnsdiKoVMwugEPsZGYYFV2N5PpOObTY9myJ7CY5nFLUswwpaiyK5DY+onZGzd7L/1tff+Wa0/Wv+WLffTH/6uJ/1wEvtrlr6K5Xc/2v2jP/nogw8PZ7PJ1cX88mL+7PkpAc8FPh6IuJtAntNlFeepteSrNVi/hHYkT8RZlDstcatT/vb7LcylyfvVkiFhpElGsdgQ64km0Y2LxropCgeN4DUqlDjwSQtO3lq8n9lxMjByhUcVKIgQy0PmVB1rIY4SfuS7rGYGycnloPG0/cEHb33rrUpPuGbdOp9MpouD+lFpc355NR9fN7ilDmkNTLRtGObD4yefglfQI1DqpAABgJC5iTgGxoLmcl5MyDSzfK70orzXaNzabyzELfrdCpS63Dw/O7uc74jozy8XYktkemERAi8rVMyppJIm/kPJxWAwEZZh7P6ITeehhFlRVFA5LvFU601L59PkAxXUSce6itcxECxFJrIbiny5uAPAR3MHIBOQFofkTtmuQmFI8xZb8WO5ovZZFjWG8cElhkvmt01Ltw/1M0Gu0KnIImLWyVn+PRdbwSTkGl9OJI9WKyx3ATB7hwhlGahQ0/tcYHtjAA7zg3yRRJ2SIgQSey0LLqgwSCHgDWPE5EC/vepX/zd/+E+Puk+eXv2///u/e//thx+8c9Rrp6iiuXtQmGfLXq+nSgI2QDAwruxYEjEUXkh5lFAwgOWEFXElSZjuU/kKusw+RMeGIH1PXaT+4vJ8Mx3vdHb3DzcP39rd3bv/2a8/n07ITtubkomjW91/+Gff+L3fu3+zmmhNxZqB5LvtOxfDiYYfm6UZm7otkbsqtK6SsD7bOVcBaLvkV0UJ4HH8qYdJ6eG9yu1bpo8z9cFgo3R15uE30ONbf7jYBqK6HfY00tPQV+chodmGFvm704moZeriYmV5XBsQGcdICKKzGRH/GMCv/I12SBffE9Wma613Ri9f1f/2B6/aldnHHxzZzFsPdNw1GKt9s7/dXA4mpEabmBYg1mVrqppGa5OyWlB8wcSfGunSbjV2hpWzK1Wx2TPYT7FX1PqNJu+t+8dp4XMl1nl11t+0Xj959fTpaKdxMDbEZBrHUhxf2iYUEXoeGMIigjxd46KPFQ8m/mwLgfYUwqN4t6BIZTcDIDE1kQ5hwlKwpU4zai4S1BOGwkQadfdPsjRpEOINtEFfKYH3STC0sDm8buf8l+imjYooccywJgA/nZYwezpzJcyEnDl1HO98ypucHM/Ae3AIccUD0Qz2cgsWWIpgbLvLehi/rwn+hFXtEKFFTuZW0U6Bt9hJ6ZlpZ6latr+B8hF+HSMU2i+fnrx6fQ70/if/2T/t2v7trNXrjB3VYLx3tEuVKUf2v8PnSimADaZLHIH7GBFECkcPhtk8t4BdfGNeTdKlZyn8vmyZgg1zGUk65yev//Ivql25qf2r4eng5fnOvHb71uGXn52mQoD+rMYHtZoM5pOD/aOeUbPcMumwwsVG8qsy2eFJLBlqOx9ZGw+Gz0z3d+tXqxo/anAPNRBDunT/oPrxu2KxM7H51k7raqrFN5FaMVvXbqxlvXKVOm9Bh6RVOUfjYegSdo4Mu9q6IRs4rSZZXHEhoG5cja2xC4J34EU3zwhah4f9ioIn2eyOmy1x9emnV69eHn7rm3e/8bXdw10jJ/j2BiZ07m460smHi4vBFG6Ds+ajGbbBa25hjlCcGZXVcBLLx/MmzpusUI7TnP9ut2NW91sfd0TRpidXjUX18c+ZA+Tc/vWFngZrHiGZP1SbBrOJ0KNMcjnELVwRm9bB6wosXyeYIX5tfdWFiPwExIXONWABKdmEabZgY2B4dBbEiyLBiZy3nzMQ3CuIE5LXGSByITOj6ELEmftSzK4n+Bi/jTrrqoYaUREeiqlK0+C2wpC2KvsgCwp5C1xvZQUlMQi+5TOLwIlXSb0TKxrZMwPsfwE4IvC0YYeKrYJQkeBQ2M7FopSA6BzW1MEljIcMs643wEg3q93+5vDW+fMnqhK3y/FsPNzbv9Pp7bNa+vu3Yh5yQ8nzK6x27CT1PjlZ6CsuGStKMUMEe0BQPDPoIcKQAMBf9shb/Rxw7D8/m+c2Hfzwh40Xj/fPTlfrvdrtOy9Gs4sXo8uz0tmrq6AZD+fvzeb8dPD8kR0pfft7H+4dp2fA8fawcj45GchrHDlN3MXe0TdWHyiSpYtpliutsvSDcwbYllm2W9189aE+oSaWtfQIGpbaLKmD9s1o7A47MiM7u10igYBTV67xp1hGjm1n3d5XlaYBm1zDBk9Aiitim5coeE8YOecAPVaAH7lAJEZARRVG1aeDjsoSgQs7vb0eXfzwJ7MnLzRl32krTVX41FmsdcSjg08zgmk+7tWrpoO6DKkyVhgChXOL31AjDl8L6mQe0GeZpl7edpo39+/daFL0Yjjn+AIIH305uxiKLuzy6m82lEry+tMnys6YN7cjqFrQbKGfuALIBv1ErZDt6m32UTmOAeAW5EYOD+iwidwtJJ0JPMHNIR6nCezE3EoLoIgZXnNiKXk4bhpLirbnx/CexKiiLazbXgeTWANCgaAJTu9nsBF1kZKFoFopnhFFiUrl7KwL6yI47tGglIjN2W5tw6Vb1ADJlXX0ZpXlOsGvUgZTqUUD8HBQSTEGxZ2dSLEIDxbsTQR7CNoL3+U+JJl+cXeP1Y+cv36x1+jzeX356NmHX/2g12gthteZjczTVvQF5oPzvIywPCmZl+dxuehHijHhtpB9QksImCKNTYzPYqMHats5DBHfyuisM3ldemSuKk/Jdtw9ff7iRC3Uy7OLmbkPjCrb6BKV8tn15N3tbSLly08f/8/e+T0hMW0xDg8b19fXl69OJ5pRJSO2ZVPdQpxEGzNphZ26BsA7M6YHIdfY+fodg42k7FfK/Ya50rwPe7t9ARvtt7RJ7fKcLssLyaizeavfJlK6IXSmXWW6Wd29v3tyvhrMtiwDvr4bQ+5155aAqLqyIuNatW5G/xZa1qOGHW2OLYGwKUDEp+eUQRPOEh3OTl81hoPZcjnIIKrjnXY/+Pxm1a2WO8pvubNiMsob55lnfkRiY0uZY1wyAgCwATjalmNWu7l9p2Ww26TUOr2Yyp49Oy+dDirtbuv69dPlYiIi7SgmwyHZkYS/SCW4NN2osCMyDjQxykRftq2RnMRGoIsHoQVQi0OiuyDRZlWLEOI/EVtu9XRBzIHjKl5LfdECBSALBBd+SFg2KoP8j9qPO0VYlOsc88T8wwTECngT+KMfPV0hAyluhYIz4nfz1EtqutpJMbKblGcaOjRTNKM/oWl9DKud9VzHM0X8clDQXKYwh+KjBzhVee3MwKm1wnlJA5bMnKp+TiGSQKdv+1nobcZBasgQZ0gSJm8odhw09SHA6O+984BLFxboNFoug7WVFrGloH738tAo3i6BXfEKFCgO8fuz4qzfYbLbABrWF49QvDCh/UAxG4BDkkIy2yz2mmXFTGfnr56Mr5+/HKqMmkT2YLGkahKrTn+83PzkF8++tbqjyaEWMEJCs6tRq9l+cOcez+ynn76+vuZ2nEa1ph//vKsL0Oxmt1XXDfzVxaxbXX/vo93d8vrx+epKSLMpS7yYMU6wdOqsmuZgoxrw9HS87XRenJ5aWLfTMdOh3d3nB+zUVod3u7ffO/rFz58uL4b7B7s3reXwcihWYmexKAihxVqe04MVp45qaUXKkZ2MDyIUgU62Uw45WlTnchuxo47G5KLuXrnRoq9Hks9r2/ObYVvakwyUmykvIjkqV6gR0JcR8ZIttK3d29scGXuqJde2rA+tnLqTV2qPy8PhtFFe1ccv2xs9yVN7Ag5SAVgx4pxYop4ctleCUS3EYCHYSbQXysIeNyqCBVK8JwflWYogYAxerMjvXExzoubQcV70YD7GdMnBurzOclLbGAUJJRB2cUEXRMlL7r3elEwP3zl+HIly1qsBHMFCoNclUnD9Srjb6+wLTps/YbATbjZENh4mBdTgFPO27A1NM5AXs5EBhvQAQQ8FOYgguCQFIW5NeLAaR6PluQ/e9TKSRb4IkBawMj+zivBeUrsLVJby+4P7d6ZXs5fPnndGg6+897G5CQv1mZFrRDu5YRBiFVek51N2iVoLz0oHcf5RYC7q1jZeKjXjRgphtALxU0TbMVosAaCa6i033304fHLSvN1/9pMnP3jy6uQakzUNxiH6o1RcnmS1S9vt+eX0+z96dude7z+SMqKBfLV+/mrYavQ++No3jORdffpiOAmjj4azg17zcqTObat1zGg8ppfv7Vd0MP7Jq8XL6U21XzrulPqCqE0jHGv9Hie6WW8HjlCHYgHFh/sd+fXHd4+do/SBq+vh7nG7qeFOtfHtP/r41z/7cqzZRKW8e9AZXg/qpYaAneenprT9gLFJSmeAb7O5zgAitWlYwPPTerNpZgLZcs4Wn6HkNIwcXem7aBwL/KzRMqvPiaEEbd52NGknpRMQtJXBNBSjQYFU7YSHdMVgXehRPZ3B79TRql5a1PykNxriYVAqq3ASxbHEWezw+SclEqGJmCjxS0CsVBNuoFVIkCBvoIB1qCY2sz/YYFhWFMRRJnGg8Ajld2kJ6ny8FHbHbqIZ4Qo02YM//ApPBESiRoogzhJSlbAl22ILEoO0MCWwnZiDmakY3tNoNoVYk0NKSUUjaW+vLzl9nb7pdAC2tEaunw9v1T89PRsvD8q9nssTLUCbqrlSN2C7cEgqfTMOg/7RTWSm4W6MVQdhD2NupCSvgGZhCUDdYxqbRHFpbdTstQ8eHJH6ozEXG98XcvQBxicDRKpeyFpwyY08jENx2gUOT4wOJ/EN+j+qy/14CdmCnjr3ISUsANgTcnMKg9ZB66q799mTwdnOLs++3qyj4dxVBHEsO/SfD+4YHEwXcRbcf//e3u3j9fq8d9gYX46W69nR3cPv/uE3xdE/f3R6fY4a1zXZjuVmo1+7HM7e6lTefmufu+TkfP16cHPtPOTL13HZRrEGR0Q//VebZhEvlpND3Xfb1fFoa7b9w/fv8X2MN+UH3TvHd3ZnkmgGq85i89Y//95PfvDb549f1tbl/YM9nU+x6CzdcuxmISbTszpnjsftc0zlYNMEDohzkiEqEgZNDiMSZY03gNKN9D5tOqEcSr+7B2UQTcx9JyuEbIJliSFdqexV2j4VQbbZGY0yGJj8EryKaRyLSQbdtfJPSodLMbKQ0HWiTsS+wx2RUhLMMtIe+eFJ6f/8vBYmdUcnda3EItCLTg7R2CyBxVQbQMcA701no83NOLNNiPNoE0IM5eb4fTlq1cfJVNs2GYVcuGGGSF/r5ewLWaAzC8Uw7HEPnW8FM0G9MGXyWAzoMxBJzIHTR/JP5fZ+XSIUT9T5dDZmisOHNPxO89H15ONe46MHjR9/cqKRnQZ1FmQwlDJQO8JHgVxZnSSv27PaOPpkdWsdya8elBb2jT+S9aKWBQNbJAlBD/psKzmg8eol/4igyvJtez5p9Y4T7eNjWiwOELCJwEOnxIOdo97wRIxBHSbEp5NlQP7hXKIllbjUAO8KXxakNpk/+c3JX/7Nq1/98oUeBfZPNS8wpQEpavJW5OqjPAvHh63jO9Wv/+HbX/v9rx3faW43nEKz2s6t8cVkOR0e7u/90Z/+wXrnp+vt5XX6tDpOjS7GH+2WHvSNU1SGvTystQ4aG10h9LE7P002Yau/023r3dDkuGio6tmtz8ngbWV3sydA2Ts4GEwXR71u/+6uOqJ+f+9on7mFM3f+dPf3f/HjyvPPng7PJvfv7Z28POc7pQT8caAoijii/2EeGxc0wBPNfA1cxNRR/zQbKRZxfIOIpUsSbiIMokdpbUR0o+BU0qudKGRlJlK4Uj29yYCLuNXl2Eep5HopssRPaaZMbtBkrOegr0LWxkrzjZ/tPREOgBStzJIChPqlvjkoVwlgIQ4JreTgBLgKw7G6W90ezoN1cQ+fnpQzgnZJNjOAkY5C0ywDf0UbuFRIIrNLPFn0dxbh1+gfnxTEgSWgDJ1KOUoiPNWjx2WcnnfxI+pI7DPi2/D67HpRGVf2TGhGr/XSkaZW1R2MMNfZZ9v83cv527c7X3v/9hdPzhYnY5bs3VuHGhfPGj2plAl46gAhiJNIdqQAQyoy2FMGIAGU0U4eLcY+GRGjHV1HZ1GUEfdpSRkK9APJJnAdPtHpIiM50tnOejPY1GNHQxYWVTpJuoo/NblXcAuER+s4J0+toIB3fSM69ep8OZqfv3oxfvni5z/68he/uBpwmOlf1dr2D9uXr6R4hkxAxSK+R0QboLX95//Jnzb684++epuKohoVYutOdFDrn758ObkcGgnx4dfeOVdYMAW8anvV+dc/2D2q7ah+WozKcNBVkuLWhko5JKwsi2bYH906bnW1cTETtdfptqvr3WBbh8hCvLi+ZslpEWAWJu0veSolewbA6U/Qb3+z/vH+Yf2LXzy/fD649+D26elgcH1dOD2gzQg7XXLStzbDTYgJWyLJLBSCJOwOlmOsoBckpQcD57/uCYbkSar3aBRnRAmvBnu71mJVqQnMOF4TYZRH+q3aeEwLCjNQMl5cBVWyJJElceHE0Rw/FGNUhI8gRvty0dAAEeZ7Uky9kBGPVeDaTjKlmVt6bN6IStEEPJwKV9PDwdiOYBunmyEDfOGGbsTR6fKRitER0W9YGeQAdQo1nxsyXwIKI+ILKiu0FkHAc8LdxAefJhMuU5CUDWcYJOkNicKLwey8ojrGkQr68ruYEkEKC7rNAKAdNQrq6uRJvD6daxp+r9+4PhnoytA4nVbng+7BvW3nQIKEBbhBlC0RHVq3TCewsc8WXjAiTxv6VuXp9uF9rklcSZn5MAp0jXyGKPYq8nWJQDmmgA1p8AGSFjxDbuEg5EdI+fr08y/V8koL11+/3e+DWZ5yOhlqk7jbPTx7cv6L/+lHF1+8VP0LlnQi/276FFujzBt+ok/QJiHzIm6dHO9C3zjX7ff+9KuHtzoff+0r/X6HmEOLGLm715kP5WU0F8MrRsi9u7e/863Rz2dPNiezr94q326lQp1FdTVdP59tTifJLrKX0csIgWtqshoOluOD5YGpJYi91USvnU4fPscP5cuBB2n3TQ1u8h7YAHshjUQFd3XNQ3IrySoGljfPnz86ax12WfNMVJcHjGlXtOB3qFIYGE/4z74VUADj5id4GCsWKMCP6BN7UM9ijEEreAgvogdpc1bNLJSGhncCY/yKg2E2UU6e2b3rhSWJAFQ1oNcYZ1ZEvJL7Tfh4FBo594u/xRkiVYi+Ump2O6Yg4ze/pzqi/kkb2japJVT0G7HmZNP23C8hyvH5mE6TJfPGVRPaRcS4DM5I8QAaKwgFBZGxPhLq98xhPo8iDzFBXu45Pa3gjagdYrfocGiIY/ROResH8WdOuyVXj9QOjKiimdyigTxvZXYzqC8eaDy73N49rLbLs/Oh1k+GmNYOtD2yK/Oh4ZiN+Wr3rQpVMnUWRgThexoavcQESpAMLrInxFDqj4PiQZQ8vKWGXcMEPErxgiV9lOwOGrJvurbaTXaOM8DjFqyNgIdQy71eDeenTx//7H/8y2dfvBqRubOxhLlmu3t5MULRui6ptuGaTnHpcNlNnQ3ars7K2+67t97u908Hi2e/eK6rlAAUxBDbTXF5NXDCKOK3Prr3v/8//KfVykRqAAPeruJCbulU9FWNBO5cvnolh1fb6rce3ho+e70zv96vmpS6mZWa43Xt4mbzdGJak+53oQeHVRfUwqOj2euzaW9/0dldCrOzdOp9s59duC1x7dZunz2Tpn3hexIqdpVNS7MPGH9tdMKDsobC2y8Ecp49Odk73ge/xXYqM2m7wTfpYEUfVlqrCaImVsgSIDn2Kxlvo7UI6Tgm1Qp6KhVWVmHtx/1LisbyLGw5dFVvtl0RQzAFEzPSlVpcAuFz3Ugk0f/HOArJDgLzHjTs59DCZYRxQYLx5UOgXDqGX8h4Beh1Ms1vo/DCrr6TtYqOtXAI4xVDUeVfyDNgJIwvz9ecxPYvPWttRya05IG8xMjD2bWki0RcEpaKnLnmQSzIBanlbTG+Z8i8cISwfBLEJT/tbe4umcwKzLisVHQK4G2sbXiE0q5Trk2QOhaiine6Giq8vp60StXx5IZ8adUqs4lQN2oodxs9CZXzq4vV+OLmpXrT/qyxC9Pbs7h0BctQlk1B3OR7njCI1tlaZbFbUDpdFyRq5wTaPagn4srzP6shrYxUEyTolsPCJojPb2iP+Wj507/4u7PPn73+7NV4jEI714P545evVA6wxTqOYapg4abKkbKt7tc3zb4SzFZjd69y2HlyOf3xz59ens6SY7bZ9hR/9KsfvHNw56izv9seTkeNve7td98mnQWT+cYDDBJ9E4xqCjRL8WvePRrPps+fPl0X47oPbu2q1ly+UrQjSWJ2PZ0/H69G0Bj2L233PMjNtpu23s2Lxc1+o4L6Lq9GElm6u+s6uxhXNwuvHKwL2MZmIdHg3Bwjfo8VJBm4vmqUN+71ce1rXMK9fvvxl6/QFVt5MtiuhszSpBPGO62bQ7fH+ZMJk0kuEy5kkKU1S9yAmoXaTeVjK7JWpyyKPseN822/5j3SQATFRLBiNob00QwjVas2Eh1bckSYpalWiCWASii5N34SoJ+g8gQgT7BtpLGFKqvt7uI/4Qc1uEH2iXbT9t4dp2UqFosikDwm6LBMm59Yg/AbJa+83ewT8hKREJk+jBIQEAVVIPq84INxsqLq9NyCytgTnjwi04vhzpQMrsA9PErz2frAFLdP9rk159L6TNHW+Inh6GPx1PIy6e2kQDL1+NWrWVmMT1tpSUDJLdvUryStrNb39/rT4WQxvqhfvdq70xlEZaJY2dH8hpxpSIeA51aLjAHIxQUtmB7A28VuRPzQTDgkusEKCqUBW0rxz/JUu3LFVbYNfhMdKGzRZPqX/+LfXb64uD6bvDwxlnSiz6UEzcl8Z7BYqGiZa9gdFq9zWamcf2tX2VjrYrCdX0xe//zlxeWMH4AturOZf/1rt7/1rftf+87DXkeb12Wz2friyYvRfPwHf/SeNhORodllohNhoWh9uQPf+UGq3ebxW7cXV8OnvztTKojYusRGKpf0pSldcgwRQLQGXt5uu+XSUa30J997+NdPpFrsaBEgPPP82YlCsjv791EgcRZK93xx2sQ+C33ko288Or6xQam8ae32dxrtDyrvK3zlQ33yxbN6b7fca2xOysvBQuJ/4fSQE7GAe9G0Th/oPhk4hWEVqB9VTKKa9JAz8Fsv2e2ZcUkQaXQP3kjLt4ZcHdzomBJQqnf3O8gn0pWen3mLRBxWFvr6e5lOohfIh/lGSjvzaHWQh9VJB+g4VFgCxBiB6BHDq+yP8BLZp6EAfuKpo7EQsfxFljqQ2OmzDYqUzPSPDkbOfhGMmCPuRlwWMO0ZggocEqwNQllIQVyWS8Cg9aQB4RL7ybQEJDOKNgYAUFWgvJS6FLohakaiGxjNs8DRwC9SiLDSxXg6Xs1vdSu7QpY7lW63orPA6Kb2yau5xMqtZuAnj2Ce6v5tvWwtB7dbVcCvbaaxbEq20wFpXhAJn63z/uxW8KdT8U0R3xKDoOhiY3k4UA0r42JcvZmuzl+dfvpXP3ny00+vzhcvXk1Or0wcldXnUh4Yq7GrysOA2ohfIzu99nh488uTgcNiWGoAvtet7+11Pvjq7T/9s29+5/fe6rV15kg3MT3b5Yfdqt771t3jgz16yQKwMpZLjyiVok6ipvQMuYYbAbx2r9eGRs5eXr54Xbsa6eKrpOlGE2TZSEF29t3uZUruunzA0Ty4v1f71cW1xO5GS9nh4cuXZ8fvPdQbhszwAUYBEikeNUkEJKgVa5FmX9AGOwqppXNrab17tA8VtXvmIuw8e3ZmUFrl7sGss5hcz8qThcGm0alBweylut4QgvbZxaQRwESEl50t0m8CXahboDPOIG+xaFoBBoBYBGfRBFM5S2EpgPsZyS5PYkfMPpg2eUkRqq5i8+NAKAB/HLFQHx7t72l8affqHa1mY2/ivHjO1ZHbxeSOJJ7dbDcMiLDXbQVoYlEGHsodgTm192nUp8o4UUYWniPGosoUI0vj1QlxRVlak8fCT75XVEbwxlwmU7Kz9oIgSlfrPK5F8qokexR/x1qwfJdA8lYtpdS7pVfAfri3mC6VWoBWdX3UrTXXspcMSFYZHE0pgrvYqV7PusTvvdZ2PrgYehYBNUlfdiMZb25OrbiDv4kxuDC2X9QP6SjBLRuHVKJDvYmxz2EQO0W4E7UCiNEcwXsF6/AerXdbncNO77ejxfnZcGB+qgcvl47lEbApylVZ6Bcq01PDALYQe9uWFuq9am93owj24GBfk5W7h7Vv/f7Db37vK/07e8i7aU8ETDc3h3zy/dLhnV3aO7Wb+ZtwWKPgCE6uXtKH3qWgbuQy6GYUu+Str71d3eudXY0vzid3e73F4FpzHmFCoXGkheSm/Ied0t33jn9zfYUUae/ELAHjTmswHl29PNPnK26ZSCe7lH0jtkL0TENbgmJYcMJVcyUyiERSvgZeyZUqlQd8io7p0ecvb1Rs856kycaoPJP0RTcL+qKGbC1nt/wIZ5Ycqmg09CTNTJYOAQG181pqgo9XEylDMhaQjjUKUZtt2yobXCL1SoEEuvGX/90MgSGmqAT/hvQdquXCEM620dmtQ5b9rsEbDtUCzKhzQCjLAyYpHvTF5RBPhLCrbHut9mQ0McyBjkg6D9HY1jkkkR+ICrINRbpXYgJESLMzl44YCkLD7g4+ceYGOtI8EiGzLCwQU1PMIiM9vOKnqFuEb6EQki0WniKUvSJbkzNBGyuvEA+kPOtPLEz+2HLeKRfjtUFm/FavdUHbXnUiW3Iq91E25MELM9g308uz0c728YOPv2J3YKf4PwX8CjLiKbMRNsgOZRURHhwJjF53dPCx40UDw7Y8+cg5mYB5PW+INefcItUAwvV4cnu3X5qxRk4F6nYPdr/+wTsMbWPqdGl93ZG5nsJBbYWMbm+bgFSvyME8PO70eqW73Ztvf/3eN79JxqMqiZzuiQCQGqEhKybT1u1lHt5YKnuYhA6Z503gOBwaqR6gK1Ol0ZIcBgYsb711+w//UeVfPXlV63HvzXcm22a3PVhMIleFHOUzT9fjkZTDnmGSH3/jg91DImNZadfuPLz7/NGjvdsHe7dvWQCB5mHdVAic7eRbEsIGYKeYUgwiUEx9tnl4/HXL+tFxt964RgI+cnI6xCqT6gJCmGkLXWqX+LdmOgDpc4BhJU2K6Xsa5JWsyeiDnDr5k4Yr7JwQQcRpdHDc9hiBybjh08wcOtgHxAjDRKNr90cr8AqGY6O3nSCY5IB9o0UWVFbv6StY6/LnIl7BB5RWVJMXdFdECJLCrFacIHYtvvHFdCYrqi8ThAeS21TArtGa6qaZxgLR6OkiRKQ4hqB7YgR90TRBjW+YNosI/bI0MGOAlLezgl29wAcoXT5ZRCsZk/QjIpr+peFtsWW2ycxCJSBCx+x7WytRzPQO5/BGD2rWUN+hWHltx32jiCXc3txczXaeT/WW6mHT7engdemL97/6du2wxVqKpCFgUA6EHHuX+LF8Uj4QBV6IeRem4KLUvVS20qbD/RkV2tYWDxnai/hgwrkbXPny08fL8fTIVAwi/XZn1Wz0jm4ZPiB746O33+of9w7v7J2cnWpXdn4xfnirf/nq5Gayfq4/0/xGE94P37338O17u7tH8jREIwNSPGj81A4yBc3sFVwe37zSIIrOESupSdv7QoKk2Xg0bSH0oJZKt1QF8e+/vdf/X33vxz9+pAnvi9nltZTaghjQBz2y1+2QNUcfvdu/dXTv/XvL9figv9eWEdFqiLS0+12Ub3PiBwtdUoZJaVJeTNQWkiK4MZwXGBl4zRdG0Onlwne09+C43m/vPrt+/MmznbMrJtB56Vr2dqndWo/NpjB2O1080HJ8S45jvTZuDPZcTKRtRv+GfDxt2I16i3LwdMJexnghAXcOEMQ5zqZYhTV6rmjC8CtpIFDjR9cAWrTg3i+3jfWptXf3+Ukz3jyHX6g2ycIWoUeIyILkYvC7XJWI0W40eX6my1XveJ8ktgDXqXQ7c/kw+jqnLD2MKjgVWnc/oN7zEJNZX+5c/DaCljpAt1FPEZ6emfIoJqCg9cQXLDKHlw/RMEmNYCvGtyg/ZF6X/lM8CrtFRzviTcCj3mrr0Igw9QDYKgisbjoNIYcEHVo7fCo2j0IujVY7PHJGZq4mo864/PiX5/ffvd08uF3fpcjkDmF83OHxaT/ekTXYG+3uRAgamNOKjRjajvbGJ43rsRqhVfvwuntcanWQP8PF5zkkT794waMvdOJKu20BRXWVdYmB/N8qmkeryTu3D7t7q2avDxt9vfFgt13/2Q+JxqYKvc2T01vEy1G71Y9SJt0IiiJRkV0eH4N6ENsS46pipjkCQ3FepopwR4wVT10ANpo8FBDG5LWsV5YcxqNR3xyU86tfPJqOh87YlclapJotB6BknuHv22/d0w57r3XcMV1UeEd6z907yVAnlVBT6lvlU5E+7h1aDJWx6yyU4EP8uWlECA+XUy8Yt6Lbhfym2829an/v6adfrkdz1HNyds1zuul3laltJwLTumn4MLpJTX4ELmKqc40CH5E+nhdG4Hy0C4UtSR7YJLlG8dEheAtEahQRPkQ/WVqBaf1cGPoVmGHvrXvNXsesPMGdRq8nG5aVT+xzY06HV275RgB6gOQkIwSUwwawRcRvoy4A3NzbmwwvOzywHpnVMZoBDXRBRD6PDWlP6bhMNgfgsWXWZZMoR23SiaZIiUhvxo7nKZ7YPkXMiZgLwFl6OIF4UXWQhtcOl7XqaBdosXgqRqNEUreHqawtbQi4ikT2U0io2lr/hPDuutVpi/QRHCpE90r10XzkyE0E1QzqxdX04X7l5Jef9/qvD+/d7r91f2d3f1lu7dwoADUShh6LgZ/qCsl115JMjYZftzaX7fpIoirBcDatrqoXnY/Km3aDgWtFmtec/u6zJ7/6UrqqMP9sqniv0S2XT3XnWN+YnGtzW70u/0Cl1sEgvZ4EjYWo297d/YPjW6T5zYWUBVVwM4lCWsNynSr5ROI2LEQV+cDI8w2qpmtRHQJNqV7O2sYBKMn0sz9OQFDLj/Qtoar6Zzu6Hl1eXDw9u3p+trqZ8QyGLJxrkINM1Xnp+nJSqr569+27x7t3KHTZuO1aw6XF1Ir3uokTL66YtFn8EzvAYiygoLpiSjRYqGMNh76cDynpeLPQGY1up9GrlluKyFoXL05aJwPW69XlpT5XS9DH+G+4aKJOcVpMhAoVIJqEKgv7DCEFI7FJyS93Luggst2a8kNM19A9ygcJfSbrZCR4+HwIi3dI/U5b+4zh5bXtaXR0n17UyZ3RQNSSJxXEILMpe7smoknW6MEK69Z6fWHl1En7uA59g8uWc2338L1dAEfr9dY44znEKYpwkoXbLwsii2yNI7IaW+Rl+00deaY38soawwyF+ZwPwLIANPsOO3uG8IlHzE4o/xJsxoQInOrF3nje47oAuUt8yZUSG9QRiHcxWiK9tjwPoeRxlF5gHhDONnKOlPWOwP8vx5Pjnco9du7py9OTp51b0Yb1Zk811NlkOJvOqu1eCgaGo75Eqc10/2H77Q8OFYjKXuLHds2ZZqqfftYYL/bv3cG+j37+69GrM17C0eRaBxJ5kik7s5lGj03mu8U2XFyc3Rm0don9NB5d9aCBaumjb7wDBu8eMIbh3CmrqqVPgw3hZF0QzTctc3EK/MsiyxOH4FjAJMMbZOSVggyLXfYtuQhJOmZ+muwwQSgPp1IZ3+gILQzMjc1Y1jdk6joxtsCobeXs5Yg0/dkPf+GYHzw4fvcrHyCX5O8lqinXGCmhZS7W2KCFJRqhlbNyZNi6MA7YcgnbUcV0ZmSyN6RSK+4En+p14WYh5fb+CP5ovjq5Or3auRjCliS4dS9IOnHBcHSB7dJYLXOgIl2bWtgT/gSAkXa6p8W/yVDByZ6AeJZfIiIWIU6xxZEfS52HSh857CeHQeoAQZKssZr5raXp1cW+spv5qEoVUDgmnxZsQ2TbtSh0EYDY5LyjZinMufjEAyOhtdhaz9UJjodjq5Lzl0A4JRlijNRxDqQDrkuc2cfQON8zLJWDiiazE2HcqPWwQvzx4WXbFHVs0XP51TYPechjDO0GEIgrBHey1kkfnmEyMDxhvABVGWVIwbAsube5x8NCWQF5oKUs8342iKJfrbXTqdd6U/gsVfblzfnig8P6rV5z9GqsHGo6esT8mq23/SOJXpcMpN1m3XTUjhbauxpLx7ik8edDs9bKfSGes+sXv3smu1rvO/ZNs1P+8LvfPnl2pt3ZldKE8naK7du1415bPOjqYnh8qBBPthULwz7AMnJ0uOKaHal3b++v/uzrLz77QnM0eC/SgZcHLRDqM72/gy3zo8fK3tL1/orfNRiS0Bd34ftjNfksOBIwF/rLWwEildP11suB/PydLvI72htdzIYaCcWz5YPpQONST74YiBkOzn67v/f0wfsn733n4ztfeRvFg6rWIe3JEjJ4mgqKtP37P7yg+M2drBgthvJitehiQXpRVvFWlYDilMiFCtq9ftOc+/6t9t235lfXX/7mN9eX14kPkeU2uNbKOEmqwRWRiBwLv0g6dCCGQkqi1lAzwsz3ICFlWLA/X4ZJ2AxZsWDmnzyqnFU+ImQWsJCeOrPxTHoy9+pIaVu3ffbsuYPARu1OP9KWj6pW1YgfAdsPMja8lIiA3qPs7AyzkgSB43EKUvd/Gp0stevjg5RiIaim947NwvJkiqcJ1TIUI5ocoSvmWLPl5DoF4RmLqZdIPGRtg6JUC9lPQQtmLMwhzcejPcJO1qeIjvbhbcN1zp6esw43MP8EpMIKBkFjRHEcpCIexCWkFbA0G5iAlNptNK6ux3utJgNJx/TnaqO3q/d22m/fOVIB1++qgppcnZ3SRreOm/3jOwikUVT969s2HUvomUVH3pgMtZovJs9fnF5dLXTHa+/uHr+9f//j24d3umdPn2liXe9zD2tHBWsrYDCWG07kGNkMrka37sm21B0tlOmBIVKAbv9ov/PHe+3dyssXp+iE4o5bGVCgC2WBEYixLoNYsLVvbEjgUIRDoXtjFmd//efttoWvKHrBZjsqZYST5aPXg5oWBqUxk0rHI/n+2rLbXgyUDb4pDUfuJ0F2+Prl+JPfnfybf/mj97/2/le/+ZXf/5Nv1O+IJ7gVFa5EkChwjtpZRH0nThS7MLIRBThhT2Z+OFJUj+aNDCoPm+WVFWQmm0kUAgtsm4em9e7dOXz27NngbDg5ux6enI8HM4fH6YF7A/alUTjdMHMolD4kAz027gjYEzCNyxKA8tjMS9oggUGb1un3+OK5H7lbVTZPB8PZzvYWtNm7hagH81R8qi0z5E0zRkPfiRFUu3f3FueuUgbWtAVARJHOIm4czTKMPOpm0+4e6OJf9C03n2YeZ4u5wHkfhyhmx+YMVs/IWZVoMzbAMJ4FU/IRFIgnj5HDiw6wSJB5hyWtwTxj1dL7hV9JDzohS7/KMUaL6vyWuLcB3wRhYr3z6Zy8cXEFj2x44SYxaO5gaeKBPCb0jMe1/aPRkDcBdiryqxPbK4pBIx7rbAlU+nwgJWPIb/SVD46/8tbBu53tfHSlLcngXPrtjsiR0ap6M/Pki5tfj1enp8OnT885wZIUoIHbqqRzVbld0eDJ9mvLyi05lI5qNj2dSYbAZNqOHvT299vIwdniZinnQSnJRIxEkObdqG/u3D3mILenclnoiILcCV+hmSDC+D8j0FG/36BZ13Eq1LX2fBiJoIwb30kw2WwIhqA1yAliYDa64ha90Dhlunj27FQHiWa7bZ8RDlqyffGYpI+BsIC9jiiyqb/85bPf/Pb13/7tb/7sP/6Thx/ef+f9W+nzbRG21wkXxw16iOX6Sq8C8dqJzt58P7XVdrhZDdWiZKaBSJiE5ZV2vIC1Rv0x+iInG5teo/1R/6OL8+vzV2dHb91WSzC8Gg0vL1aTMcdjF7gt6Ra5ipMgmyBbQM6UKwm4MQwX0tplBMliIFjlcENqwAJK4EDEOvZavjJr/+DWwe//4VfeubtvhI/Zw8szhUuVGb3Fo60SbTip31QWo7HST81WOLIZ5C5f6+BnuyjhOx0BMk8p3daMJxS2vSErPTENKavLnf0XUziixHFF/udsI59WGkPEvchRGb1s++IpsEwL85twM90dMYePcYxsaKhToTqTAWiT4cmxiRh4RchFpqHyjlTiiiW4IaHlHCXK0l/xALoHV6c9QFatTmeoRqxUH6x2BlAcA6lU7rXxkZgiWwE4I9F2zi4Wqf5ulH7525fr6+Y/+tbDcbP65MWs0d4f61N2op5Je4WL3Q5v3fzllbKz5aEAigZUmW4WsgQjXj47U3p3dL48ur1P5Bpw64Gp3XjGPP7Ozv5BOlbt7R6iX99FxMXbnET1nJmFbJYHt/aODvdcEWFyZmeT/C5g3nvoMNwLMZKwBLCbxyPkiZnCfy8bg38Kqa8qNS6D4j03ahCmcm/UQxPYBqgkR0UKc2bLuj7KSV9ZUjXOhjgZrS25UhQFw0wa0NVw9t/8P/7N7n77f/2//Q/++B9/VemqY82pWYEvR7U0V8upC8iUtKN68tvPdBASkTTwyMF29299+K1vvfvR2wT5yZl+vliHqwPt7WCCpBs0qrtH/c7BrmKXXT1drqej82uNagfX54PBuel2jkk6N9s64j+wShRQiQY84sylvjTNakFVuBgOiRlc6RITtVqSF9476H7nux/X1pcPj+vqp3/7xYsxy0zaD4KUxt3qGF4Dr4Ex7JiZSamDKxkYTdmv+3uzq7HuI6D/UnWZ/IAdbSK614NBtVtkr+IxULwwxDCA/eIcDlCJJEH9EfJUAncNfJoYE2LNSTq8N6cv8MIdVZNyiCOwg0z9lobDJsKTbT6vPqrXbYhFuFwMG2ctSogp8Ifsab5Y10FrIlaEUfgrqVUjtM92w2w1iZ/8udsBeVFqRCWBAlkMEKPLBNOKvUAzSOjUjIiFdKPt1NW08v1fP//6N96rzM6vr9F+6eKKIG9b4aS0rLUrb3X38D2BN0uOBvnh0QOCkc6EmfnkQhN8copXsY6MtxonKbYttXc7ouYWQH6l6eOSKcKwtPTCOrSJ+D92V3xcoao47+L6iZwLosyDe7/jpwPyG8Lf23lm4vQJodvu7DNS9gOlgLsjUPJds96bVGqD64E9BMMjeDYGwxhLVZtkfn0OICocSkE+hWm1t7erKtwd5NtE4e5sxuOb/+G/+Yv9/dbXv/PQClDZbL66vtKecH128lp88vzZ69V087Offnbx/FxC12yh8az+xGzu+uc//83d997+2h984+D2QxzLB0CtUgVEl3xHelgnArcW+MhGEfKdpkzjd+/dchsoRdt+Qvn67GI6UgzJO7QzuL6S/Nzt6gCCTDxNqdPVPK3cO7xd4XtLM8tqq9oUBPr43UOdWx/95hWaej3aORlJlRx7RBK3Um/3Ou3h4IxCk/AgCNhu79d3V+vBcG7gwtWE/UAcMC5JX3BP70TVxkaILiaTpnhCuzNfjUSgMZsQILcDyUqcxCFNbjkYVILGihNGJg7Vedhmj5ozIvuB4+V0JJlDLnCQnrhzsiwImB0BhoYBSJXkWuAJHlaqh8KH80gc1CLGJZjueKIVEkh23sK0lKuEwZtJEtoyq49xhaYKByzaoaBoDE4WnoCaPGmOheS7bpraLZvdJS/7ysj3RuvnP3+61y51GyaLz2koyXnHt1s3O0Pd5cvb5uBiMhizwZtaGOQJnVwwHDsGKLw5PRmo24dhCoDnjmLDjHqS9UaFCrpkYfGfcXRq2oQUIcXYlZEA3oy5Qm8eI7zttCVNAHk4yS98F4qPzw/Lu6/vcVcChRJTI64Lron6ZotF2IQzsYZ89vn67v23d/efjU8GhInjIH/4GHyT43BsnBRhKUuJ9sbeVfnxyshwW7gR7ri5vpj8i//2+9TOW28dDserv/iLn37x+SvlmvzCNp2TYaFkmxROR3rBfleV/oCHS88+fXJ5Pvj1z3+3f3j7o9/79jf/9NvSmLiqobQwnfVo2Ji4p2QjtpkxqipsivBk+t9ou6IqceetgwPpRpfnV81qezm5zuAre+J0Gm0SZbcNKU5bvf1a/66meMc1EarB2cvZoy8+l3x2er0albpfPjrRLbTX6sOT/JxxSs5mwElR2TgHCmWTiNGLFcixlE1XBdurO82jg/JoYqyDLaKvGB0s7hiBk5FTi+KhEG1SamcMe0o3DS22gl9tLFImuMLoBBwSJ2Vsp02Ph00IRPsIMnqGpp3nfGL8FZdr7PfoOYnQ07lZVpSHsJ/WGJkVRrilAVNEfig6Vr2sSiUya6P1GkXdGcNB3eqClhZsV5jAJ+pYkR4Kda04uf3FeXHDO08x6UGg9HdhcP3MMMnKdC6KvT0bzt6+a+OJCRZYVQ6DkPj5lDqKWqeBiC4FC5SyclenjuDTdHpdurwYNxZrY9ll16NqvevACbKKTUJlozAgX3IGKcG9y3tGaRcKLP0pojYtNz6fQlgo9yd8ZJp6ZGKINn3DI2+UQKFICRQbWxwMEzl6gA6IpRC1ELqN8bBTena5evpydPeuhrvb8VjTzO217Lu0UqOcSR825RtQyIlMfYleHy1ko/MiwLNFQ6xEZhbbX/7k0Wt9IvgUp3OXIWeNnUm5Fl+4LKmAbthNSNzozabiB/V3MfuQmxqg8fxy+OpstjxbTj/+7rcy9jwmGSikhT8Xyg53sKBKbactfaPRwacx8uk1B0tqojuXT9+qilG77jWnFsuN3fFMnlFLpXu9bxDwLfK31xiTCucX1y9eagakbACcP3rxfEzc8eHDuySLQJv4aVeZA1tOjS/k32yfXYzZAO6z+6CFvVihgFSl0TrcvTW5vNZecDEdK09Hw5IvckL0ZspfkwEA6TCkVvx8fWXRZwORKfZHAH+QJjaxgekmFxUdRRGSJDKSOwjNa3UYG5kd5X1JxLNEUDhQg/r39rzZXzKi0ICfAxoIMA8UJeUHurC83u/UJ1ALKAwrM0CJafI9RjZxiPFcCU1GNgbSsaqSo26FRJaSG73zgb3VlNApb9uGy071GrEm6gtl6lFwY5Sg3dSdCIZIb/YMnWkb8Cq1LSvAFDFmdOnSS4fvdaaOFpU3D1O/Pp4vz0+G61nj1h1WMvNLOQTFC+qZnkJfJYky4QtYTkedQgHE94GEsSsXGeKXLyq3wzsyfiGa1BEEF3mkhUQsiCweklwhNEf5iqORUKnO+Mq3Pj44uD0dMzGvTl5PBoPFaDQ6PRu9eD06P58EidndICMaNt6H89NXsUNcLurdHkrfxmhh0MvX48I9rWeW9st8uZNAW5tZ2HeClEKmXEYffOWt22/pIlGXRKAtEceiudkonvfs9ePT2fDHvJNqij/86kfGjEv9bWpi6I5wBE1Q6DaP57qEYaqOigOczxfGQkoXTnaZbsd4ZDlutffaPRUtVTxRah6W5tfd7eByzqCvH+71PjubtvdvkTPbzXAyUVnqeOJTbtZbquc5SxjJOrhM1VHPVS2Nq8ZFczAaqmtOR3XPsom//F1hiwNgqYYhejWAYvYo5uLUIn2q9+/fMmAxLUxmwzqbxCHs3IhJhZyD0jOEgmQrjiP0DNoyoexawQ/e7KS1ZSKq4jYj5O2FmxJpgkGa9HGwppvFRgqJ3U4QhMcHWxTOAEe83uurLDFNMG10WUG6BgeZSIyhH3K4ub09xBI+xWxPfyU3sI5cRjvVza39vfn1adzFMhkENhR6rRcN2XcKHppSGUpSe/huxiMH6cmTfGv72eURkqwLnJmmBjEfPQyVJYbUsuz1zmw4KvAKR8gGrODn0YNNSS8HhyplqgAgDjlH+juf/GXx8YMy5wNP0ISwevyhiNKviQeSh0ShfbFzVFvUJo20liHpe5ITP/psZEGqO0vtdvXWvf7Fa1Qnq6y1e5x0vuHp+U9+9DlTCmdRxTJbxEZiSQnci0BZCZ52vBQoTRcXY8Ho8xmg7kDlO2A9p0lCIAjLEtgzremjr77rcfYOzP7s8a9UTeeCZVED31RFSymuIFH+0kQHlevRyeklux8QYrVGMrkYAoASc2hkovVmFpsIuW+heWGehT627VqJeVqxA5Nar11tcgT119VdhWbdnYnOvpva3nb1WpYhL6k9MHVSDxgOa21T+3t9AiBZ00qNiT4B0FbNHHk+gFa3y4CcjebzifZHrXT+53ssb03U4O0RvuGAcTQ2is4JJo1IcDSl6sX5FbZM34cV5TOLeOPj0swGE8cXjuxyLoFsxdEiiJgvaM+Pdisiq8AoSS5ViRtjzhn7tBh1OqvA99sFEARvhrvSx5MdqYkiUzjGBlQzY9/xJ0bMp4BQ/plUCXIR1dgRQQcqQP5fkewNSudHfkvmmFwkBp9mgJDruNR+Pd6Mt6t7ezwdvDxlrYflQ3VaErAtjaYWvtpcacxfMmVMDnMej5AlkkKZ+vTFF46CY9Y5KwEkEHkz3/b2+1WTmnfm8G2CdlwQGsGLnCb3oRHvS1QRkRSmjfvLU6OIaDv3iTlsu4lDDOGC5Gx+iNzwe1QSozhuMS4algDXoH8kJvh9NkSAcMHuuffWW5zC3d2Z57i8uNxOh1//2sPOa4V9vEJrvWuU7V2dDU31kmDL4zgeTGcTUom5FtYMG+dOm71+iyWl/qImw6GIWfAxv/XgnjCf+MR7H74dJVqFsla8nJ328mpxM9kWfcY54VWeySeVsTvZ48eS7oqSZosVhnyzhU5TQ4eCE4hq5U7JgIqu4/bP1N0VrBttXu3SuAhqp7Wb+PyOGjG6Fx1vaG4C8vrsUmo3v83/r6X76LU1TdOEvLx32x8XJn1WlukuWkI96QEIgRggISbMQOJf9H9B/AVmiGYCorslakKRWWkjI8OdOOfss93ay/u1uO4vKior4pxtvvV+7/uY+7kf8wJUbtiV9tl6A7GfF1+sXGpCX8m0E1hPVvVOXw24Er5QTHJeOWtaa4ia0oGF5N1GwyHD45rUlN6lTzU8hEOyaNlpgiix4pdw0cAvcWV912YSBQHXd/vlPwOf2C/nmCOLvXM2Gicj3o4tj/KsHwwhwwz5kgdGKQk6sEPBlOCC5LKFbHdskm7VtGIQmo0gotLUK5yLG4wSzaAML8OkkCcGEpCIaQ2pUmT4ZEfFMaFw4jcWrLVoh12SPPSps0U0sHrG9mztuaTmfqlJLSo51w6xlUykENFdwmpXYsBsVTInjcV6xdkEvBYBpTeqHupr9aiH08XNcLvYndq7q/OBjpPtThRVWNVMTwpxyxkk6k0OrMBrisxzMZQ6ogDNIBvBa15FZMM286jFpvlvgRbiCnwpHta3gyyt2MMERb7OfccA6V1tlOfTqdKLZg3XV33xk88r/d7MhV/1FlI3I0mkDogkq7DYTZ4mX/zp7fhxBvXGYClFPpSeZ8uuduF64ye/+MnNmyurG3Tq6kaHvY6Yjls2ydnnjFqwot4PpartykHxrAtaYuBaunWqrmrsm/Wfc/MlMMMCvHXCbosU0adbmkTYR76OYQg/kKcvWZu9FB4ha3NFr4n9sdJSNdI4LlqlCcuzVl9tmwyaOeogaE7cuud2QVeDAOsMrQ6+EkDLj5+Q/u1+2wfyGXpclsvkAs0wp35wrqz98/hJGl83IuKfmHFe4BAIqo4a0FisZ2RLlFrTAeDkoGAwNJNGWR7XZ7sGT2zEaJpEIh7I1DRHlU6GvDQBdqJxDOS80AVS4H8RbxJmFGjcf6y7MZPJJbskglQaU5vDZd+k+pjM5N41x6f0ikdUjN6SLIO5w+/CKOEZs3keZFdjSFLcwbeEEo0v43B5t8iXhIrSRRdorozCczG1bofewGIMO9F5lgsGyryRmDW3qsQTJ5DInLBInT/oCAlsCAnmcqeteYpiI6/GhnnIdnF6vvfa5u5sNzq2D4hIVW9bCzVMk1VJEIHqTVOIbjeZDjooB5CniZSCBmQYpT8LpS0Uml+IUQ6a5KcT4LOSCA7/KWxm4Ym8vZ/LPocj9/KBo61GpQ0VHY4fb8dadtv91tmoh4/qOeOtodS1z1/9dDgaOpbDevHt93dvb2dffXn3j//wu4/f3ZEFpmg4bJNTbciqewBw6xD1QDk89GK1fv/hozmKqicNIUNRrl12v5mjK8F077KGS5s9HWomVAzP+hdMuPO1k06B9sa8Q31WTR5y/OJe7+CP/q5D2bcNJFWqLVmpGo0MAQB2q4lYM2n3WUqibgpc7/xcRmzh4NK9hSEIn8zdeCnjdSNIMMjJoJ0leRBXWCi7VjMRRaqu0dRiM58+kwid50sxk5DPKCWo71Tun/XZeCEcR+rEMwLM+WV+NADkVqLyDmiLbUypP2pABjVAbMc0cs3FWzGH8cyFvMeQBvXmG4TRn8MoslqyHjlRqwvX2GhFRAI3CpdsMzh+w3FVAlCYULU+uFpZ0G4n4y8GyFmVaTy+5/H5FFRnkU1BQTsJTWc/aAnYh3aImTGlNSSMFE632VtXlxRepoAg0VdYh2cBAhHTCvBjIyBlihfD7PpeF9JmbEnE0EZqV6V25FsRBfMnIYvpW6zRdwyvsaJn5x177l5E25RMVLSUqgTQs3bFpQ9gZ+B7UTQR/E17fRhKxh6yOlgkb0pa/I1hiPv1XalW0WFRuGTd0aECXIKAbI+oEUkinQN02d32RfOmeb7YVCYMv03OPWvVlz0t9f2WW8g0KET3Nm9ed1wA/rd///l//d/86//jf/0P//Hf/YMtQpvMN6vf/e73u8pPen2dwH00/la/z2YLXGXC5Wo3HrvFZt2+um61Rkw6/SbWCmxN2kSi9w1Dr6sZD2nlDIMIIv3+EqUBiONEba6+cN5bwUgiAQDElHIeZdDodLeVVhw9EkIwhs1M4/jJUOH2oGcmB4bB6TCeXmo2XcZuEB9cyung3AnIq88/Pbs+/9Pv/9jUllTrocRIauSEsUnYvTa0cTAaik6Y4/l2fCDApUr7/LzW7x4XuUUkIUBADfEPtRw+MHiTtOETYtlTDmIHbb10nUEWwaZUkOATSUC/2sy7ens23GPy2eFAnXyGR9kOQl5TVa8rhf6bxeT3ChNoTSyBr2SWejGyollXMHVY+YXdIOVmefwUJIK+a/okPT9jZYuhS9aSnmKMR+RGm6KeKGEU4ThsO+W9UbOm8LhR1NAnYHAPv+lkDp6uuDQF/M4IULdosXX2Eu4mgiTL+We4XM6NRlADL73didKKuWhJ/+U9N/PVxGapkQRE+oHr8fYJN6SDXFahSqfoxRYspsVQ2sw2VKA1bxwDmciCySfOFm+TgTr/koSxMfGLMQ/iAO5QhCdKplmsJ0KNmfQrpJ4bU3CGSjAYHwaSbDmdzhutNe+2NV+13VW/wVRTS+MZCKD5W7YiXn118aLzb//tf/e//fTqf/mf//fMxjoep7v1999/ePXiRgJkvdagyN3rxrIdlT//4Yvbr966+OXzf/HTnlvpLm+okyO2M6v5RAzTKmMgO94H4Pd1C+fVo6YWyQfa1nx8Cop9bW+SkJcsirwD7EpFCZrKt6M+xsBoV8I7VgCLofAZxIBeLSE5RpsDzkxQxouFZEp2+jR7vVG1360N+pqezZtiREzVDrBM9Z7DDaaxA47Jyc3n82wwG80c84/tJs4cuBIhhTaz2aReEkvoyRxJzSXJRzCyy4kToKtod9ok63vpAziWKAeN43ICXGlcAPMPTqDqKobsAf3NeQFdKHN1sTnEVHsQQJQVUoFohK+Jm8yqMzVD24GxKCFw3emQuIMuRRZFsz8Ag0Kr4pucWFCPHNlOcVc8DoVQtbGcdAajDX9l1mi7O94+to5ToUQoHznjFLuLI9QtOzOvFiMV3ci5kTQaJJeSMdQt0UNK12Wj3XdxNLEMHyZCANgMP56d3Dd8bP/svLjTk5BRExJuswqRKzqYaAUSKFVVNCCRIqfJ10eArSBqFutj9zANtiRHpz6AgFGOwGibXxTMwhCyzqyEV/dj8VdkC4FOwbkrHSbMp2u0jfjO3CFKipzOknxggG2lPp+vGp3azfWgUz1c99b/0//4X/3mn/7y29++a7f71XV5dj//enEYjdTPtgfnPeBBDL+YzwbD/mO3+3B/3/n+dr6YDZab7sVLBefwhfWvZpl1VxBubvVtKTPMR1p5ohdoTxOCPxb0SSSFnMReCpIEdxbYc+X96sGsRlLFThoQJ/FmmFBKISgzwL2dk2r7ANOLZmgm8ilwxE6a+zbo1YfnVCR9OcYtpqupMSzV1UFAoau5aKfo6UnJWXk9mRyXU0iUqYXcAvjTfxwQm7UWMyLSwU9r+V/y2TkbuX2BRBNPoi0adnKmRLi8ztvJ+0ISEfvsNURVRKKRaieLnPQ6AUccX4FTHOTOmBM/T6wwc6acHlQ3ZepLYI03xVGyOhlI4MgVSW3dFmcaTq4I35shV6DO2m7O0wLtNNqWhBfys2QanyAwiP81RIC7qK3Vci1VeJuo0NS49VRqmqUlvSmlpiBWH6P759hXXVDiEvF3mN1E2dbnHVlgsCeBrTiF4rW7dXMZOFZnRLbMdveZLOrBfJ7pfj0hB2ESmXPSbw2F+SkpjFOx33ImNpEZSpEfeINfkJsS1gQtxERTL8cfUOORxJqNEpnndyiPv8RCSJ2Iw2QLvbOf8a9idIF10nyCw8w6Qr/kNQBU1Wq8Da/BHAMwDg05aselu1wV/dlFr1fXWFL77/+H/7bSxmXtMJ1SpvtT/fbD4/2H25UMuSjmZASZS7+a1z/53NPHt88fv/3w9PbDTmnNTLcSjs4crurG0LsFiIL9zvQni2ZRaJw/+grB8RwYwoIV/EApQKIRsd6DoFBwp46PCIun8IFqMAiqEetDNxsRJpuumGChJGu+nswmithOlCRMu1i/zms0BqPUTZSV1plHv3v5o5fdvrKVVu7FqKH9lqxjbwS5ORiHjUddyIjVTenEPS2hhJBuFkiNM0JDDgav5JJiK2Ng5GUcWLgwIZJvp9LBAQl+1sbSammg/H6Ty8uJ5hScVSLR2Ew/SXFTLV38Ek7Bqh1sHB9psL/wUzkVjq7NiS0Xl+9gelyMXUHqh6vMjBc9qYfVocQuEIkAAKfM68QqKOTysWJ/2+fPyPpkFbcH0x7L67lO7S2JW7sYsttblZomjy5UPIJTFhNDjHil7+rKFEmw6eFe/Kuwuoy0aUV0m5UFC+Pr4rUY5nJGoieAt9RTafq0+uL3t48PG4W6HhZzDdSbZrHg8DKMUqI5aUJyiv4vftGSuCGy4u0swocWeDm5uXhHn8KDeI49zJZm+/w2SdJiYYsoZGw/KUsekGz9s57kvEgt3aDCxf6nNWm3MdNEvw4UdjZsnrX3n9+0ew2sP9+3+9nf/PLf/Jf/xtWKSRYTDvpV682mm8njswwgscAKdobnijTffPbZdLxaTGM7np/G87v73fN8M92IoxGc04+qPmFph+mfAuB6ErW1dykuTgW2KVS+FUWnpV5KWiwVZO0TryRD7Dy3rjLD8TekCXn+7O5m+/Hbt0+P40jOcqHhzLWvLhaxsGSlmEv5U4KxUo5R3cwN7qgudtvpyhXjO7MK3RjpJFwUwp24jGb5PEPl++XqcKgl0jIZWTLHXlpUbzQ0y66mjCYDdNEUtlJ2cLPJnNFGM63OvLsUEGKa+3b8TkJSK8PXZJbJZyiMQNUgIPJPLMEK6DaQxH+cd8SfQ3T8XkTkzu4lWojIITHJFKO83q7F2coT1HUAO7x9zzWainXwZkJitln1QeIL/V2adAPHGEZuDMFgX+xsgDSYyJwf9n1tlmmAw9V3T63Rev5ErIrwJLgqgS7wHiGnM+omfCFXVhZLBH/kf2UbEW4UElIxXFpMTj3sofAGlGfqSehhPT6OHwaN9nDidzfm3EWnpCdR+WbdCCgcA8dmaCvPEBjErhNQ4RanSq9ia2xKUJHd8F2SIeKlNURf1ok5sTS/6GAYGL8ol8DA2r9oD/UIp4cJkDpU7qp7x0HFInoRIJj0Szaokhz2Ty/OjI2TLDBlBsCRDyz/5//Zf/L7//s/Tp4OnaaJQ1Oj3lRWdGarznTR12xeAbpYrs3ZzRUg9fWfvuzO97On8am9mHzc1zq9cjetLeV66/awHl2dX75+EWuSNkgikkU6XafCYC1WC8OTaGwE4uAGS5C14PhMJUiWnmdcS+WtscvQnXocO78pdUej8f14txTJZGQDu2CEsSc4qjAfh+PCPQZd27VZL1bVXt/oJEVNy/v7vf8s5sqB+AL+ya+7bcRhCxwvPnnjGLcPU5+SxLyl8s6bpEUlMUSdxJGYoPZyzM5LDpAqg5iB8jl/A8B3Kn5QJFWj9pLuEYARLbe9J68Wq/lDNOBNsNdCNqrCCsTvB+ejHkiBn0o4Fe7DxXfUxXiLNg4uX+GKnJz48nCcTabkAOyGfFJww56Udu6fQqLITdg3hezkptcdiJJWxC54Im9Az+Q+mvvNoN/iRR9S49NJhBM/w18FTvsIbApCEHvDmYQ7YoDFH4EtylohOCodFsPPRfJjcOXgeDV21m5ZOhmsfvHF/Xx17J11nu7Hn35ilGOimuxyYfdhIcMts6mp/+VlGxAYjY98AyleXUkUctngviShqUB6KcWNcaKJDwralL8TYlhK/sv0WFhBMEjG5ncSzbNa8CctsSZPNxeKIe9epA/xbOiWMOEiBKSnY6lO7fb5w+/+/Jtf/vUv//bvf/p//rtfm+DsDnndEbN5eTxftp6fh6NLDyETlxdna5vcKD3fXewmjNP+EWVIAJrTEJuclokGrl9w+8nZ0A6FS2GhjVsKnZpo1omox0oY64V42ZrxBXO7jCLhnpJvrxsfexJFzHdmfBiFu5rPZ0acwphO1fA2Jdc8jJKAIvYxiTl95iaNG9OnUN9njF6jAOoPH95zm//s/CvlTqfLePrMjUFAzixGpKA99tv19JlTtWexiYqcZAPlqdw7wzHLfVS6GJiEfn5N2OHGplLHJRTm9Qss67mDQA8OaEm4M3o/ZRWMewFjCIkv55DIcaQqtEbhD3TWxn6ZdxdW0UmiI+Fll0w4LkAsTJqKoCI0sH0xXwiiYsotgwgx5iI0QYWrnRDGWEcLNomRdpFRbK5UW/TTB8btejHJdrcudXBa2Bilf+V+eql204qrEKwkQiQwL/6DbBGKcLvCcJ9N/lj3fIeFUKQpZ0nwxAaMRCgOywelQAzrJcWzeWk6rX94GOd2oNLpk58rtFo9zl1mQROqw6suW++YPNbOOwRIzsfYl4D2SG2aswJFeTd7FfWKM2Vv8iM0DJKm0YXY2xMRbQSp+CY7whra7azV69jgbJu8TRuLimjix7rN09WooSidE1OJ5IIpE33HH59rq8XjN19ef3qln666rvVq7fHzc6vTmDx/+FSh6OwReSL+0VqFwmeuVuvF9H6iwsDAi40pttHAcFO9/mj58LQaP6nYfvnJj46d6DAc5pr5IrqN9SxiyfSG0AH1UlabDuOkGqkLdLft40mrkq2ZGI92nD0bYb2ZApbpnZKVivBm7DXQY16s+7Vgd5EAPsGFITfXmDcwluyu5/P1TH7QpIjweWv9TErZhXnYAu6qqDuYPH5MCx8wrEInMCRJ8jhfOIbnZazKywwMwhYpGkXyZPAS4YI6cuVXwbOqEIdL2GnPFEHL+Uj+xUbC41y2eDJcP79ZKB4/GImjIj4MS+Fn3JQjfPM08vsD786vIAd8x6NSelUuycIQ00TQvDauWEi0ctWDmjMbJ0XK3qtEcGEwDElK6ioCxc+UkjxYDKFwp6S3S3rNDyfNLa5HeW57kbT4aTLv5cF/ifGkq1OIBl9G2i2Mjjsh0IZeEd8UZNCSoscliIgzSYPfqVN3aWkgS6vevH/YN/vr/rnr2ut/eTfunzV+OoQ7KiaMEGhpV0SbxYpUgSIr9H6y+Fl+xJrSkWt6veGFCuGmCqSdqEkmJEQmVtER6Dp+wJcoSJyXOA9Z7rdtPauUdKu8qMRayVVl7RGqXXJclqlZf/jqw2yy1gJgnMXbr5+NjfsX/+oX//jvv8J1tlPat5YLVm4fEnSNkk+vKLm5PLv8l//pv7z//sP9+/uNSd0GHzADGTebHJXNnD/uv/6n3x4mu9e//Hm131flyB0Bt6yMAN6aqKwbYZbzVA27vNR7slG4PpGdC0oxi8XI/7U8AG+v1p1nRqH049uR8KvUNSENyX86ZdUFqQQruJ9+B3elfvHp3R0PMXsw08BWH3t9+UDPOT0/PlBVZ+/JXP9uMVWuzN6k/JvcJPBzoyL5FlYgImJ40I1Q9Kna1uYC9wAdGrpTp+yiKUMJgnLiyVBGfJxGMvahip1miEgPGSdaPivghihplSjyaYEPSmCTpnE3ZsZqI39QS5ZEkHlJ+CjVfgCd2hti26xpKjNlW97JsXY7LcQQ4VN8mQkuZJbImBrU6k5m7pRyspxuE79fvAH5kCNGpbFQ6m67PoRB0LrTb/RiRSpuWdxYt/XSlxRd7qkl+QdtBM8aazgy7wMVQAFRKS/N8ntLL567E0u7geuK6kbYHufV0pjGQh97c61rH9/OdcI96V7f1SZ3y9nu8RevLxLrmF7fokMeoybKz7oy04AKchT7HtfF9DDS2V5fEDtRkIi4hgeHg9pz4rH3+RrDlH/igY2gqvPYUXxvFk8Q3QDxm8vNqtMpX593ADg4ON8pu/qk/LRYd86Gh9mmutp/Mlr/9L/4xXKy+/Wvv210h+BGtTH87punn/5qYCR5Vyi/3RzVeQbQV2RPMR4fvn/HlDg/ZpOQOF90l+RMZbZ+/Po7vv+Tv/sbyhm+LjOm2FVxaJrMqT0oNxs/qNwUOoTIAC5JSWnTZk/SHaxWeaHAAVxutFxHoFTDSRM6ca8zTRacqDgYAur8wy7DDyvtl4u10o7xmBNxiNevL4x2RBswMO5Jk4gXSBPv7F5REisAZllZvaRqCZvEpnofqhnfG7OhNzolcx4uOk6JPp3K5NROrplEPxyNsKcF4jCsKVDeoDPR9gQN8nOAaZIAySwkzZGiGPKTu9YoE2kjVHixvIM8MXZrbUBZPD0GVUCU8NTDw6whllGuEIf09sGIBjG32A4s4eB0pUqarTWABorLS3BqRNQzLZyzwXUGxizNXdR+qSjDzjCvdILZkQZDnAaikL/ksyqSaEnRUAHmNFIYccIAxY3HUkjtpQQ3QRyIEihYUSBvLYnqpDWrjUGQPXXeH8bfF75DJqfS+PhuW9vOfv7LG5ELytieIqA4NWNA7CPqitXgXOI2Y7FZC39HEGU3gJmimioBny/QGfjMuxJHb/aDv6DojFbyOJZEB0PdMVyiOYa2PsS+hAdNRSWDlRChQHHffPW12Q66PPu5TG7bHlr1srrr6BhU/VWutWczEm5m4ZIk4B6APWEUeVJOg2ZU0qUBo3ACrtyuKy1Rg6lp3b2DWzf62ghJrCIQJ2eEAFGKs5WxizOn88HZAVbxwBTrAJZVF7K+uHCc5n7e0UhVqQ9uLm7f36OaFhVzpF2EUDJuG9FMu1AILJo5t1dXV2wtdDSfzFNlsF33R30ZOkSlFiIcahZgkg4A7phr5cePj+LWAiHEr2ZxlIxA5inUIVaP/AQhl4TGmYhg7H10JzZ7t2l2mgJI5slpIRjYQ7eYozAytCNXGMRoWZzH+VOGQjNLji7PtSOJevyNNlMqOlOEks45FBGx4DC0NVLGnK0EkCFxhkqobqVlZvHC4jSUvKZA+qhviYNz31qrqSggNo+Scim2WKu49ZMUVkPggVeq1Hsy7zuxDjUiHfqYGu3woKeDGhjYzCgzaIdZpWDxicQ+QT/7eiA7NBw2s01qcvl1BKjwiEU14LpdlyCT0HE30rTdHpKMUrN2N3mWSsqQczffHPcfP8510fzkp2dhmgO4HD7XyBZT4UQzBRrLvoeX+GHrAJ10aTDpQUFO0bkUTKfmw3aQE0ADlAoJip+nut7XkQYpBZxA22uTHS+9nerQYFLay3zYLkbdYNsMc2a2lzIj6/Llub5CtU8i4bBJF1cDs1FY0Gmyp0qFQ+GVhNMc8lwnjYaAjJGwCD3mdbeAsikFoT6bzKqNx/100r64ADGcIgJG/QlyHriiwG23iZRKo4GalVBwul8LDU+2C6g0fIltdr6ur5N3Gz88PJlNU+3C8UAG2OG9vKSd89Zno/6p1hkvVs1G1wwo2yTXod92STbGi/65Q4Sr2LzUf82f5i0ThLyM088+VYyXqbaLLKECMB0k2eLw6d6U8WOnoAw0bgrKU2qJoHScuRp5TQea/Y7B2ylKykHQ70Re3oF5yMH0dCL2ym5whjFCWOdEILeQPvaRCRQ8UTAgOJfeYXdohWHUChYAAJDRtkHeoFpoMxPl2XbsRchZsolYTIYf9gybaKla6QTMUJsHO3zv7e9snWNKvcEeMtbssmq6GF2BQLW91t4h1Kan0iUgQQooU/Pjlb2rHQ5Br5g97DuApPwurLav5zBR8fBHbqLCkPjxXJDr8mOwT9axvl3yIsbaIbPd+zt2u9Bme6mAWnJ5sRqn2rzwsYlsPBb/sfAM6DiTcxLVOVf74pyDVnwaU+l//j8GKXUWCcEZeHvho22JXSjIIv6yiA+KLeAjVY4r8uGX14/P9bq7fhmfZGSdLSvmCYhpCqCMAYm5Xe0umpVf/uRGWZbqEKtfLXaET+/L0s1tbuteA5DNQault90nzuZLubZISiJImQBXW80MnQ2wXu3n08U3v/v1+vFOeMtFMnNeyZJDWgh3zPuPufGWxE1D9saFQP3Gpt1l8I6QxmWP7ol3VeTniiTDZ1CTUIN0QepN4tPtXPnlzfXZ+Xl7MCI2yk0oANPD4LWHfWkruqdUU7eA9AY46UOZ0OWzRv0pYbR1oiZLh4h00MkOJBeR0C9sTDSBi8kKHZOjkVfwbm0YJS423Vu+4fEgHHcmOMWyc0/G+DQV/GR0AhPlfk4+tXKaSiYEkliFD8wsCndlnWpy2j6A6c9p8tnGUqUyXq9npItoBTJSX8kY3FIuOMHs+H0Mt80WSmZH2bWYg0ILKWJ0waGgcIXjrCG5wYz5roPf6WcR9ZyqeDHL5oIqeis6Xhz4ETAWQYtfML0jdiABBBIrjyT4yRJYSh4eKLvY7jsuW881IPCOteJ1oXrgpMPo6mgCqnptM9/h8tpKqvpYkp6UYExCACxQ6wiuJPS2Nn05Ot3da9LneQBiki1qtMGBYAlyib8Z6JSO3bKz/DCnAVdmT3GkSBM6H8xpMUURVwBVIjRZiO5g2JrNb90lRvjq9VkGJys/Tvhe1g0smf/8bFpDBzC3uWdnw1ev9t+/M1yxpN+gP2pNZ/fCcZ5nbzDeeNLRoCvmk/W18YVFsFPLpWgedlbGwtCS+A1y7+6Dxf/h5kc/Y074c9NAjfaYL9OKxSRqspvz2K6lF3hVTBUquRhW/ftyIXGi4HQptWMmjukms/ESB07ROS82IsaHE/Syx9NgMDi7uprczTCR46d7BqvdJR4DNkQmeNhSVn2Yr1bFeN+QZswdztwxptIlPetYDUJIDIMsnTwk6chZaZ+ApvILQJijSkab7WMWABTVzHCVNnDFo8CG20GIOx8BF+il8jT5KX5AJouOwwe4Fcl6dRvhW8JN+t22xha/QZicZ4y4zYwkJ2sQoFSAb/KblkJnDawRSbMx2tLD+Jey0SDoK78TFUAJBv/D7qynHl27hd9hPxuaGNGXKt1iMH64gAqiI/nse7x5kwWbHUoQchanGt2JkgJsT676i7GH2wohDP4IXxCXKPOtHinTJIFKrzvHwh3KvfrpoivOkiT0k7yTXeFL82BFfCK6Qct5ntqFw2KSHKPATp/rxfnVw8OjAE2mKNsR5iUu1VazRLFVVM5TopIxO4U/5b0TzBZmleBF8uNWbXjCQ4uMBgmwLs+HnW7517/9/nw4/OTFTbulv9rTHELc48S8sZKZp4s5F6yubrfrj3o/l1hcf3N3twi/cHRbWHkeNkQZYUWSj/0V/R82a3Pw4ofC7ThcKU62MuVVmXrPYBo2u26//fK7yeMj6RKZDK5e0nDVdU6/0+uqoWD8onO7Xc+kFL+BUHQr2VH79zMQ4QjWoLCbQMotLyjcoDbWQWiC3XfHertxO51OStW5bK8M9m43GvY2prdiObhUaMU84wxD0ZsORtpvkWQruootUH8PTgvzEArxgrmrk+ZS7pRDO3kO10fZchEVCOTlJBfI4G66dJek6zQYJoUTufs2Hn2PghVj8G24qu12FoiSmc+lZrWfaED3sSQfQAJfBfJGPglRYoYiSNUkadqBzEaYwBx1inrstSiTqrJ4EQM3LVfbXJGMCHiov5QCWIbNcqLhf2KQUExpvxHR8AP2C+3hIyF4OEidOIgPsNghNpBXRvDwRRSfH9JhmuS2qUm8gFIWGskdKkiXBCR+XKQECk9EsK2xGO6/Nnwq9zTuLl2/VW9ccFrTwwzO5lV5IqIY9KgxWtzfStGtM5ZMd2WL6U0+I+ZowTMHRuR1SwaTrBeLRPysTNQeYMnnFYbeLpDx+ARxSDaT72C8bBFTkyiSHUnuA1tgudjwXrVqYd9+9Q3z9fS47DYmFHh4fslmQQuBeuXa24/uWHLex2bloMBpfP+EiPr09ZAtef+8bVW7w7PLFy/efP31d7ZFXWXojdnCdcTgtrSihdA6p5XxMOyawytQJFFS4MPRrr5/lHdz8N9WvmCWB+dnzd7g81/9TffsAv+imaFVXQ66iabmu5YsnPG0X35ze6XmtFZLHZy6CyYQxxD0RiYkCOL9JCdcgycBpPxKR94ytdK7hXuEtPaa5kCwzSMz9WDOaeP9lNWp1msrD8MI0LztZkYOBEWKuuy21hwLj2s/GGKcMDTDych8LlltdqBB7yi0AM8Zcxk1FEr7qi2XCENWhyO+P2uL/UYQQLKsJ8RMOAWbU/KVqhc3sO+NGwABmWCYNzkgghs3GnzLdagTjrXzcEvzKH9g4iLjdLbj4r2IQebLMguEIP00aqNZEfvPxWTnwWQ/HqYwUBG/ENaPE4tnUJ+TYZLkRzkuENZnJRyYFLksoqt6ADh7Qo8MC/Z8MIxHSy0sk+7JIieyaIlRrdBwWV8yIxyeZQsyd53GoZtMrtMKsBE18ACE16hL6R4gz5AGHuj97XzYqwgBMdpeSbpeKhpgsSveF3vvdaRwfQDFS7AcY5DqoCxLciMlGzFSIZ48AAjkuJn9+CcXq2Gl9W6umamRPO3t3dtv3qoO5QE/vH1QE8KgtgDXAy5grlhjoeEr1DRzkouq0gh5aowPy5s316vDg8oFSsZMvvr0xd37d0ocON3U6qi8YLkIS2qMGAoxbdSVGrA4bVDZKbjTOJWULGe4Oab4tFzqJOn2Z4+A+/mlR5g97+3wTYhX1RNq5FA0b978yEAhr/B8mPsWCBwu0Ak0pVKqi9nMNsj85P9HvbXh3qGGECG8qhPJI5T9xM/nQgAhnI8ob5eIHMn3XGiUGM7icURukgz34EZGoYUlBhF5J7sO28afIi3B+3jCDL6So1ggY1l+uGMxmVb1U9vOKtTr+pMdiWdgCSt3HRESVmpYA31Yan4xZK90RxG1BkukWsWrgbGwti+n4yXJA6ykNQTAk4BolWw5caeNchtOvtFxOW6ocpId9WGCUldj8/QVQYdu0RMx4EHEK6Qpdi5H7CDzacJomwjHGRwpSyo6lr9x793QFiT81EpW8FR1NcUdJntt4mj8bQIj9t/5mwzkwUWeQV0WGsd4Rh9zWCwXbsPA36weeZdYDHGw4BjbjT1RkWAbCCgozI2IHjWmoueRyYRejSIoJVEpJGRHwxyKM7iNmBQvZUs5KL5fqp6dd0Q+gtaQGWvgAIDIJOSd95PUw3LROa27o967x3fYRpdEHJbatQbT5Rrcf/0aYwh86CwxEiINzUi2zqi9Uth8cCleX6kq5zSZzbBa7uj2F/TX+c1Fs1PW974Jdt3rPmcVQB9tZJ6W6hRz6I1zdBEAu2ahEE7ym3QrDfLRbdVau7LOTENV9kZwJrozB3bRgRtMWxSf0OHt7qxX80WihN/bHNuCJxlBJ8PJ5Y75olrE9jpRls+QA3IiYOLjlfoi6OkBSlB3m2snJuN5s4E8JOFobJM2ZykhKK7vDneVKpdMsQQlhc96jdN2nVH1JCpSl9JifcE70zgJH+mVEm7rDAy5DkLqCisLAZjhvfGAzAeEjNAMaE7iAwLOCOiQgGhQNkAACORIGpHL+LPM0fajfMQ2qd9g6+ANgk1KWgY+b1ZmvvmBAAX4PDiLIMtDSzyzK/Bx7KGEbgh5OlA28igFC5WGywScZrwxpp0AFZqUH/Jm1I2dZ7cRpch876kW2/8pweuF5wYfWFzfZLEAY6JoOWjIrNkDe6pZtGbSOyfOCYgEuBdatNte9BAtWvEZ6xSCMZ2klanV6cwbsSKSSxzWiiWJ2Uu8ruqJovKOnArtYAvVoICQJUqZS8FYDPEAp098fJc4Ec6VPziM6EWsFi7QmUCbqaZJwLDbnw9bv/zk08348f5hfvcwGz+vlECOMtF/8OKzNylTVe+4MzTp6JozVJZeH3wWl20WIibQVKfQbat1s1ozlIczWkzGvbP+2fXNQSXt4lF2GoAjvvybWBYbIX7xG4XliqgTORsdFTBwvBtwHAviEnRyLFiZT7Wlm8GE+M7IEtu7F9yhkmWUbbIZo458byDE+OMD9xampK522khb/F+SYk6UNVNQ/TyebJbMCg5Kpk6BSaht+6SaU8uXlAOkJilDX1gxIW5MrX7lwrinCpNRcdG34NhBBjaG+vF1qkUwQWgihvkKqgbxyGsOyvwjITGJyThi9vDIPjA/wQf0JiFjCojlnNGVCh1ikxFBuoAxCc7YP2agplCHkYxIpcFQD2inZ0CuXQq8k4oWHbrwUIeANAmnb56vnAoYkOxFSN3C5AtGwznYiyJ3xOSn5TKoqmpmgxqkECG2stBDWMo/MbcFk7mRQnEepJVyKjtJrKVf/rhTooWelymMoyBPZt4GhomsKG8mbyqkKMh7Pdr0VklFDDAxne0lVe2a34NrSsQs6E3iiDOxNSpnw+2gB7x82Ay7FURBkhA/zlhUlxRWrjI35y5JjLhXyagQ7so8Y0fzrl4WNiJSnm//sCJVlMlO2qjVmU6nF8PKee90OWr88d3zn/707vFpY7Lj5aAfv+6455kC5bxvP4wlciYLwMSQr+bTZKHg52k2/3A79fJsO/PrGq0pa9rvo0fGH576oul2f30cM0RCTm/NOME+DLSLJgweDclK9DLzNNsgshIy6KdJMQsbYhQOuxjW6/TR1dtf/fHV52+YUs2rbZe77Q0vYMIb5ge6KI9vP1SXfUM3hA+S7jQs8KJIOtgyOMDYC4iGQPquuxKQufDI0rr4cIkXbNKMFPHhAh6izqNqmmfmnQT5oZ8AbOqxItWEhKiThYI7qLf6fgjr5SRhUb5b7swWsFGqD8xDgkar3t0vYAMYrvT4hEeSuVWe7YehAeX7mb/jH5lhdl0Fd0JC0UesKZEKkma1QhMV/sxwMJIq2pa3UB4HpoXnQoIXjEiiBWBOwllNXopvrZsqcAjeQ7wrxc2GWwwh8WySTqjZisxL3q2wUGy83Y9mUrzAKYiD2sLuIZIYdTAmtJfluqkJqVEtYT84CTtnvcpunWUh7MUk/qLbg7Z6KKeSiBRlcdx9nJtwQ5OINavhymMriqMPzSr+adaRp3KzPDks5UOD/kLRqnCUErIqYCtwje2E7xM/eB/Z06S6UmRBRBydvEli339Wbz+qWmbnlkT5us8FFm4pWi//4d//h6eZ/KVrGea/+vmP+h3qv0YOzZ6m/auRTNaHP7y/n7niiFUWIzqjGICMuxIONaprkgO1QhKn6nbpwirDaPeGSvTOL2aPM2Qoq3BoHeSr+H+ogggyeRCnqCZbGsXnnYQoJ01ODIgiAyZSsMS51Dvts6tzc+ZyC4rxlG2NRq3SZu7QJot5x15mY8M1KdVX3EjcHFlK6wgpSdPWUBMr2wLyis6UP16UJSlMgBSd+Gx3q4juMCjGKlBHJ7syHDH9Dx7jEJ0pqi2hlFlr2XWMRu5UIWTkKsMm4F2lArHRQaEYfZXlgB8nQ46ZEmeRTLZiniNSUTk0l1yjcy6JoG0WqafdXKtUF+kEyVgZxk9uK7bFi/BE6MIAYy8ayWTcEqbaIC/pqAQGlioSSWWO4I/iFEGgky67JAuNIExP54W0fCg3AfCa6AqFPL1dzB6sqJBw4FweiAC5x6LwiRSApjKFiscxpFq10J1xYJQGOy/SjWohI0QDYj+vTcHYD9uWRQR9gElOOW5YZs2CRIKmzqfyufLxTieD0n+VYa638cPC03hwrCGpgNYyOH5rAAFB5rpgOhonG54JF6hCUMTpR6KVYInQ+T18lUqhJC4LdEhqNElL5K7Xinys0GL9vIyIrpLH6YOri/bPY6WeYsenyXF0dvnpJzeDfm0yeeq03XJ92e6PVvvZt9/dr/ftR/fiyDyqig3bKYJX4XPodVGFldFZ689/ua9U+6jGi5eDv/7FL77+6u3NJ69p/+H1y6dE6TIcp9rWZIBwkDbYHlk7gxcGJTDS3JE1FkFjMnsKzCn/yIyylA8QafAiJShmr5uEnsHcW/5zP0AeuoB4sf/q4+rueW+8k0AxzKfEiX4sshAnQrUoRsCnMoWSWyUXU0qmYt9Wyj5xrpvFlLV2v7xDkL9i2Nig2NONUp0gWGJMMWyj2COSxhyakJPFG3/yQ1TnCOy7M4RRmZzEao6e4SeggUpmqGI2UCuH5aLC+4hztYEIQbZG3uHwGDrGIZYFgZzMGJWFgDo49yQLSCcZSNjrr1KwAf9xH3wdUOETKTShBIJjDkGx7a7VaflgT9wsln1pCKMEgDGEcfZjKZuICjnp1hfhQtOZdcjGNFPsZsEnCUJtLlBOgIMba/glADpskRIJ6SN7mzE+xJVTToTFKzpGBiKuIx8cnQz94jwZhqPLSFo8/WyGNg1hSTeYBTg1hIqi/1AX9jxPtctq+yzE0GMLLh4K7gPPPskH0Ze0yLNNKt7tUpqUDluXcdnMWL6shU2MICiLd3r80Uoa5CTCrgOP7T6nX7968SPAZbJaUFt5BtjmR2+G48fvZuP1Z29eaee0AyZhXp0N3DI2NVdxNospQ4IftmCtuApFIzFFtTz8zc3LyexYP2+fvR62zromZPV6PQNmjhejlUFDpm3tVu1Oq9u/Firv5jOF/nY5/pXhi7X0vmjlVBHYq2ZKzAJU7TI0MZku39/eD29ubi7OqD8cNl2XFiZrnLaz2f7tZH9nfndmfTNrkXUa50mpFcg+FUDWQeDndGupcieNgtdWpziyGl+QxnoKCcOyvEQUDKGLwRGS3/qz01HoH/KMTIM7VarimYKx8Jx6RpHErBTDiLJI/J3qbZQuux4QT5sRfbHm0WzVCutqW9gStsjwL2ID/mq5lGbjDfudNtxJt5j8ytEEq63Z7GJx/3iXkrCNT2v3LBLxFEkniExymvjpKUEkABnVKjgpMs/YavHIwa1sI75OorKrfAV8fTl9fHs8LZ9VbRNFnRUpWCCWxhZ2aKV3L52KRESiTdiNiMWqix+13fuSz0Ueii2zR42ysuWgwNBImvGZLUA0EJSl4wGV2SceKTxC9rFZBwaS7EixlNDUHOqG0htaIyDBJCliTeQgWkA9wX7xZ37QrlBuNA7wd4QCEvptJZF9BoNfep6u2m0XnJN4kRZ8KZ4W7PnJhAWz6epsZBIU7Htq9Y1RVPi2Xzxup7P9h49zvghknz6/dxWAi6Rmi2W12p2NH68bbTXFk+c5aAXibxNBY8PXmhaOx2unj/dmmPq5CbBFa+YVN8Wfg/uvXr9czJdnF+dKvrpX50nPm68lDSV+ckOjq7rMO1/N6bSQSF3W6rSGKpI6D9Y8Ke6ECxcuLbKXHN1OYcLhm+/eXl+nFC9Q1fA2995Nx+/GxwdAnclBJFSls5bF/HYeA7HhNiAKgGiXTWtp7SUfvLcUcwgX95vIstOveCO3sjo9HjWnIG/kmHAzWuNoVChjls7XfYoxD/opkzzh/2Np1EeloFyVskdzAwwbZ8PSpzCUgvsnwkgOYRffzSdief1EIQBqGRS8LEUrDH/mYKK6/RK996Po21YLsCjOPhGDEw/hl/c3I7JlUDGwCIKoByX0XAGl1KAs4gv6MB3fFaUm9aZLZ6tB2tgC1x0fd/3JSSK29er6qg74npp6iEi8hLwnk6pwO7B4THCMN8nVu8AMeCDcZFneBC9jKT7G4vguQm5H4n1AGqafumfDQBqvnrYuTzahzEux+3GbHqwNV1cAJ4ZttrO4UVDAQ3R4wIHGxuaHw6DHwcS4KQdYwlNBoAEhYffJuScJaX0wTj1SYHxj8K4QXEXUUmsjXpb2XXSb16OqK6MUDfoxq3AEszKCFQeemtvh1WCH/eamESOn+tNkPTwfoE2+/e7WJ/qa0avz+e7+YXI9auiQVxr8/KyHofLy1YWuMWHeJhd5VJTCNWpqgdvNbu1RDVxhwzGtKvKnOKDDQimOjK3EkzNxxRC+UHEuAJ/AyLtLLaWNm6+hpXlB0ssEC47Lz5Wvvrn95HrUq8dmKzHzI2EBD66Vt0epAozph9lTvI6HM6TVadlf0W+PR5s+P2d0CUlnfjNeNJfw2jL/S/NMHUZLwh3qDsUtYm930H02FRZmesgtPywy0W2s69cJuwrI1aEq3rxMQkm+OTldKpvbRRvGCzks2lSEtEF8yADWkQ2JZ29poVX61ux0tNWuwS+6FuIKV811JjTYH9yWo9EMbsl+ECPofe3iBG7FKXPEUYZAhABukBGoiHLZnEhPoHpz2E1LwMozYL9Fe9gz3YohM9izfOGGyK745dn1VJuVzq/pbM4Dh3Wx+fURalOLhtIoZVLOz4ZBYolmCr/DcrML/rE4kIhF9Xe2CLiz9sQJfgO08/rZjVgCK+O79DbSJSemEwfxn1CLiBZfYXf8noymSWTCA41OXtH72R851ZzcXtclbnfp7gqrSOeC37GiwGh20MZLMWwMcE2Kae926PrmsBpdHF9cY07UB5nlDwWJ5qzwcH7VmI/PvvhmiiScKEiOAmABNoP28OFucrHmmdvuel1uqx/u53UFSft1QaMFDfAfRf9mQ/HwhS5sI8B2lbPGmYiGcb17fG7jKdOGhe/a8B8Z5mlaFdTUxv9gEbS8t2WImRiT6uiJl4FTzCbFkjCxQESZq8KbZzdLc/3pldL0ZvN2//SjT681K+SiEoYnvYYmKflrzB6na3FEB8iPU9bdog1HRLecM8KDXhc6EWwsF6ZDZMArseciSAqrAbXbQF+IyQdxCi30uJw2sbTmxNX2t2jxyxgBesUIaVbywWo8PC/lshwBFlCmDhgg6mSGp4TAmKqyu22W+6VyQ7+338/M6dLPwHIaouXCgnYzSSvbdhSYg2sEDZ1FvUMsBul7GRX6RPKs0xMdAkFFxJrxron8HTi0ixsPMZB9iwlFmgGpvluAGPnhmHkE2Kn0xR++bHeavaFXWJhPWW11zgaDWe7UM2rS7RgnRPhamyl0wjmZT5bOhPBYTCj0FeaXy+M1U6Mrbok3wCLg20Xrglp/8VvxCjSBeqTeLjscl+t3WawMolNbV1B9J2/GpoSyRLGjuTtkh1vYLGLmkeWbg/K4ubBMR5vcKi4oUFeQRgHjczyYyCc+TqCfqeoUiZo0u7tXN93Xr5q//6d7O1xZKTNmybpo727l8Ly/+6RTMe0ftXy/rv32tx97nfY/fvgnOvXjw7lVfvv9xE+j/pEkqXY+HKf4AM249V4SLBRuV5rP5tC/205cum0Oe3uUIGpnTEOl3LfFNy/uqs3bd7fcdYK2zbrjpnjjzpud+WrsnLCW9hazjtI1NcvdmIwm1hLMY9DZeX6Zhk8zpXRzNrqcLI7DswbI/OFRJTbpSM97Et1y+mx3OoESNnLgRELqhciSCWZI+3+r20ufV0rmVYui/NFv4nItlMXsCHvHny8MMhSvhdRJaBqDCHCmsoFQkR+nTkMtzV/1BK95ZLiXbWOrLMOJFjXQId3xHlFISyAKBWQqGiNILAuEvYR5WmSIloZpUmul/EBQCLN1A6MArngV9E4MBHPIIRpG6Wi9krkFqW9MHxDZwRvZ3Ewtt1rYLh0QvrhbLCBtNXyAPsw3n00sz0UIgg9aqRrEgBoTIbpd9xYZmKE18eJ+vGCqLFEFt+Jn9YU2NQEIVBTzECaUknM3kXnKCfkT6aLUn7EKSPPCFNXNn0RHt9pim/iVwYA10q/E/EJTMdghldm3/FaChBwbWVaVaQZ38Ex2yOa0O435SlLVMny6PJTH5kI12+K8DKZL+BLUz4PEHaaw0KPrZlnuf/ar/s2LXvIt+Lna6azf2q9P376/R1d+ej00JexHnw3X9db/97uP37+dCXfefP7yx6+HUvivX17efhy7ROduspzqE8OSYH8UdnoV3nibi60YFqbtbHQhwLy6OZ8YyrBpSiFzhaasSt9E7PDu1UpvcCYDIAemwMbmmKmCVWTBbB3+OFvhJIP7XPAl67UTr8fsESc9QWb7yKLsDrff3RqGPuxdBXWWjH6CwOM5+NHIgVEOsCKr4CzsZJxjAaAztMyGpA5FyikhVAaK60piqBMj0j3HiXZjfZJW0spu+A7eEnvWCGkewp9hifGTbmF40C1UB+YuGhI5EZAjHxaNgGEiGgyDqhm1Azw01jy8XJJc0s4mydcXWA4rlzTouOGp0W9XTOfdL9c8PhBgVfVOV6ikLtsGExNQihSz+j5VG6+3b7m/OyWo/ERBeEA7rS7sgC3NJQex0iQJZnBxweKH2ROyIbAEMktYXa6rH6kv1/cyqcX9DMJ0nVrP88NSeYiWABQKRBRc4f+5AIgi2Ed9cjhJLpYRtwcAeorfQuYDrOzUPukpRxdhJuaJikSlRbmbAyEDKTryJZbbIn0J1LF/9E2q0mr9uBjGCAXrD0PCUTBgEBi6MC3/R704aWXItoRjdQbJEJROA31PEnPq5iBHDd3lsrr3z3/VOX9JJNbKZgb6+93l+KzavP7wbnL9yRtXR06Nrt0cHhbz6+suTYD47m7fuwlqMOjPPmrKqpz3m7LpQtb546O8i+BDBatrsgK9N9tBf9BpdpF+tWrrm28/KLYJ3Ngcx5PF9dlwnrsr9eFltHJ30BFHZ354qbyYzXvDgUjXNcymVSdEjt+jwuqR2RP0rIEOqGo/6xua1FReCClLBj8cFrPSul3q9JSPGi1BdhmrGGMg0HrhoHh7z5BVZx00u+w1emYKvvvodVSqIuJfE5UZzwq/ZdCVI0Y6sS1kN6wg6jElyad6Vls8m+0LSYl9VDanVouHZfHIKuKnCaMXnko7E2zINnC7DSNJ2D5iGIGWrPT0YCNi5YWKiNu70ZLdZl6uDXNFkbFKsFCrCnJrpICCTWgjp9EaQUyCWvuT4c6h4Hh5M+lkRmMRU/QjGs8LhLZMNsy9Iew/bcS3JlQQ1WZWu1UTX73nm6brFgRPZKMIJzKp8RkKEplLviby9bl6xD0RmiKjQnsvE22MClILO4Clg7h8maU3LZmxiQ9MrELbi7DVOwZBhonngkRe8YbCKrkNeAXI10koASi0OrqhymGVSwv3a5j5vt2K4O2UbwXip/y45o5yqEbQbF85IqFZarzYJgDgWHIFqD6QojOZU9m60Pbv/tXNy1doS/2WrsSKd3Vd1tPdVN680elcnrsC0YMx4YPS0/Lx4XH2XF0umcD2i8/PSIHg/f7xzrHcTzZPa8NAFfwYsZYyF+g6JjeOixVF0SzOb/rru9Vh2ZgvVFe5Sqfe9V3R0W4Fp2aqikmv8lztHq3As4mErBLOcT5Bx44Ff8CbWRFjStvNQg955hx2rmrT47I0vn21vPvum8+u281PrjOCd7FQOWvigxwbkwMehG9OXzzqDFcdCFOUvtgutl9KMNk3gYjPEN8xKtyOjya0vGnyXBlvxTABXWIKHs9jHDVljwPxb/mtJB4Ts5FBypELNpF6S4LA+ZJsCRp8PYemuEthjwBbTxjixvsJbULXhFulTj5ZAL1V40QDF2v32lgKt8S7wrtLjVnioWSHipwrcJsulNCLWYeP16TfGfRBBJ9MN7CkKaBp673kZdVQbgeDtk9C3bngiPR4D+9pGGqGaR/d/LFoBtDgXhK64g1IsjK66mmV4X04FDU2AW5sfbJvwZpgvZ+0KUQj88+L4B7mjionWAoLhWZOyz/URsZDHJRBNkKqwtGRp6ioxAV1HalyL4rt+Mu5qTKGX28VPofQhKZxzX0+v5dxRmQAXg25EdbO5zMrHlotAdwd9L8lYarwsOyf6qBT+epF6ed/0758AfPQSozW6fb90x9+813p0Htxc7Xczl5dv0y4Zy5o5fjw9o5JPO90RUzLvlKI7hdffvzLn784O7/g7aR4FwJ30XOm+5fd5ZhbMMu18XjKujt+lcM8nYzR1etLJr7ZvKr2FfDEHg1a7Q93T+2atvjBh8dppzfcSAiNH0yeknY25dwpdDo9hokm2UDegt20RT6PNPNvRFlJeMrm9NHj5g+H6dhVzbevP/1kvjQnK81pBM8ULDBAAtFAn7AhRvGpzYhAEaZSpC3GNew1uslDeAbwUUGoYoFsqGOJp2X6GFCqFF1Sh8e/+llCDHhHfkXWRjyxfGjQBJn0gAT5WRlcWSLt9DHIDlLgkZcxV5xXokOZ+2U1cTwybRti2kC3i0fziAg98wiZywoo/XEtHs3x1AxC9uG64RG3ARfiBl3L7aLhCLRcH1N9G81n3z1HVJ62sf6oChwtH1cHQ+sDKA2IDbIIUUjyvUVaZIw7Qwiwf4auyhVC9VNDIjRbmL2xXZXqG7ZVnYFUmf3SasLi2al4L2iGyrLCCdIDBAlSvutZwveUH+aiXeZZwQvNsVkEzSYwMHZOdMNIwIV0yeMwO0V+W3p4j/n0Y85MUMi5mCvSbsDMCSW9pVMSIsmSRZtOJzojz2vzCxcTX8w+9g2p6pzqndqPf9G4eU0W4ypQRg5/Mdv1u+d6a5ud4/nNVb/nvRp//O2X4cAXm+8/PEjbX56N3Bb6+998dTf36r2ntd2pz2Vvp9NGeq0PnYF7NHaPj2OR2o8//9xIBbiZMeLs50ujtte94VDBZEnFWatJHAdqdZod4AQSbTfbi32ld95tPrpTdQnQtwcmR3U7w4H7RkWSAQZIetWvxj5zoCmDFCB5vwgmi9zq9RbTKeF89+Hh+w8flVEbW5pSIbbJnTGElYxy1GpVinKbAI2mzEgxVZ2Xoes5Dm2l6QCY76UFnKHqAXRPijpTEJxezUxRUBWnmRl5JbIodpgtSq9p7PwPxGMsYfq9asvZvNPvoZmUoBEyNjCdlVAKpSG/y5mPcfYWkJPTz6bUwbBy593qEHCBnmpD2kkLAhCjmYRZxAHZmDCT2/3gKOGFYEVY533M+FJug2RYuYbKACOzK9JIiGiKArJ2hLPZG6VRVYAV053lIImEIpo5OKUYaHNWaEXm8+decUUiLChWTPWXWqtQTORa/NXsyUYxrYpulWAmWQKchIP2qgVwpCPxjKy1Y0gagz0AhGSykn5IMOy1k55jTCCnoh6qqvhJAM+zWokXZgJNK0gfATLUz6f6M2kNQywKyccCJZQg+EhGQTxlYGBE8RgBwICnySxWYdxB/eXy4ux0OTxvu0Fqn7tiXVSynW8md6vLq7NuvzwZb96/vf3yD3+ZPIqhEEqn9qDz2V999umr62a1OZ0e/upf/+T/+n/+8Mdvt4Ozi/ffffNXf/uzP/zuj6Ny5zQ6CRhK++a7j3PqOplMrEo6SnG8e60vzq7ate7a7YGl1XlTBoAjXE2E2/yS8UZB2bmS63k6kWpQg7BfLByf0sHKkkgV9Ek8GKrTNgJyW1egemd7y60JmLhlfKsCPmFA89R5Gk8vXw5kx4zYIIc49UyHxv6Qm2RzU7jO5FAfAkY0OHKNL6Za+QJDGbDgkjbsNaMD4iYz4/yz2USDRPH09psJVp9OppTJsX1Fg0EgDGfDAZBoRKTfZeD4AcQTAyd9yyq76R6mRjzFtXiy+hdbxlQzucBcMtIqWuLQtBcjCA/NXn+zgI0YlNRZqiEyyg30yKF7oSSGnE6HMZuN7xudoUEafWGGOt2lKhdJtTT1opZTIcNa4oFqlf75hUzpYjqWEJUncwRqufXmL6Q0k/1OUU4YyMDx1BsVeWbmHInp9kbzAD0Vm7sm6iFWDXX0gsWYieSrUDGJboiiPUz9bhHucr9kM1xkIiBuOeEuuxTna38La8bXE+YALiv2RxualhFXUCLvMSaq2VKNxJMWeMuvnbCUwaZhRUUxCeBiy+QTvHRCutDFKR8I/1auDniFGexbbo1oTj5Ytg8nNH0cr+fsSeXHP76sVS8/fnBX3eonP3k9nsw/akyb6xy57w1f/v6r+9/86f7d03woalxNgM3RxfnbPz+hTVwAczsRqkCIlesbA6P7o+GZRL5L0NAGgYERAZlANZlOEK2wWU8W7r8mmtxvruGrVQcXl5LAYqjtcq40eDYZ9xWfIq+EUx5gxKfQtshLMWf4QFJMwPgHWEsq0N6ZdPbwMBucY/jcW+HgAItABpKvBCaHknoEnjpEqGVkE5JLSfpld1jBtMSTlMIhzin8P63zP5IdA6RleZ7jQWS1dVcykl4xl8VjIeFrb5rIVkjgDJCB6I4IN2sGAtM74w5Q/6s5OKpywVAjNRrcJ+wRzN0ku31XSrPcRlCtNlMKKzXtDVuDy2Pt2djrYNycl4Ro2ueRHMCdo5X0opXuMt3Mt93yGVnzdqpqeTVlO8wfxFYprbPZQmmJ9PnKtePd6xemv7gTzsnwpIkWkidDqJijxnoXw0MzUDoz8IpX8oLzGCwKC+6Irdlt8usMAsAoOOF0TMYR0F4blg3wX3qYWClRMz+AgvghJ8CuFHGWatmoQQxGylXIhmKQ4MPYE24t37M8tcEiVh8fMBCvhPt0rYt9JU6iDD/n09mIxGoUPbF9bJ61KmLjfTi0m8sX8/mkpewhCXiGajd5nPJXY33u0GRPMDgzIdxCXr60V2PHdn87X82U9Oz/8Of/99dfPU43+1YXhln2quUJpyBKcSLuCQVqD5lRqYNC/NbtdlDqjOlkJrWd0fwcZrz0bt+rVJ9mE4m8Yb9jbanTVOBcbarDjAle/5C7RQoQLs7fizteG2W1KbAlLSIgewniUVmSFkOYSp6EOo7eneSV5ofR1VkKrE+aIgxiOXU0P0HKSvstotIsJmPb4OAcVp+dSsEPWlOuTUdB29RXrsmUwjjbYs9jctCEdICYbLfL5Mf2J1NlFYZEAzPTToTl5OkS88dDaU5T1QRAmJ4QnyDrmfYfbgHscXt4+Wj1qSrTSiOacKToHuv78Y8+/3B3Tw4Uf5m1sj1O+pfXNCGzRpT+LmUZ24r/RF8MqkNdu62yGO3GtlvK4nk8HJ0xzWx5WuntsSo/9xdJqCgfEEHjVhysEFxnTavLAshBxi4o4PVKqJV2xAkxR3uTO8MbMMsJSepqNbUvtIqxY+wv9BYAVsCTIuxhVo+uCgnNnGoYtqBAwdLpfC4qW51+NId/s+nhmZLiKLKGFMnpsS3k0kkU2WUKEJsVF1F81yqcthguWLKCDe4kxkg2JSUDWE5EEHKMa4mxAkQ5sOPJDeevXnb0uHYUOJ80nxIZNEvGkbmX69svJ6ddezgcOEtezFhv0O/1p58vnh8ykPRJQFH63Xcfv39Y3N+VMcFre1c7Gm9y8fpsZQLFsdlpiDrs8fb1zeXSOKmnpdk7DLD6tO7ABJ6mKfqNboc5pcVsPezYbdUMGCYk+pZLesCbKnCC8jqd1iTxEsUxG8CBqcPbqHE2mD8dQfJiixVQ0ullKmEAUb2e+8wRNSy8EmFW3LbvSpOHiWtPUdY8LeADZ7IXuMvop/XTDEP+zM0iJQioXLMLOsZnCiUl8pT0UF/Gs3A7iX3pHRNmAaC+SlvXv3JJEnqkV7LMFwvDz+xAIklHUsnoIjkqJlYwWkGwXI6n+IBtdd/oNVy5lUt39U8NzO8FxaagB5l5eLhlRfxYjCCbYCjA5Ig7y11dTlelF4mACH0XjRTN2+1mc/NbMKSSoD5FkY+wlhdLzl+hq9oU0paAepkigtoo5TVxX3AiZkmxuigu8+e008ltiUKl4tl5WxDhlhf1UcwUXYUxLKqs86Lp27qSSbFIJTU1fpIKhukStrhKPlfEJXEjx6W2Ir1jZpQJFYIn2ZYYe6hK+BXC3j+EuWC6uIvcGKfFSeScVAuJtjZbKG+NI4R2hA10haGx7+J/OvtD6Rhnrb6aytKT6Hiow2N/SPGcfenm+tx47Kubs10m0WYE4naJELtYTtB6S2cINS6WjQ7KIWWk5fns9O070L1TOb8ZtXaz7bK1f35+utdUTUNRsddXZ2+/Hg+1U6ZehQfa9nv15aJ2fjYSIGIstovS/OmZ0RNaioVwi1pG5/MHN8zhmdlCMAHHxlJtRWLO/lQeno0mjw9mmUiDCsv9DPvNitn8+D5sZpwp2UwLJe/nOPk9CQV8K33w7kRq+nHz59Xs53/399xmqlUyCFpGJXSMzCCrgGgi0Qy8m934ys1OVZSvEplu/Lb6ZFWPdjgeOpakgPEpNmFhOxLGZEJ9g49fpZBJ2GDnVdfpLnC1/Ho+ydEEAvHOiCbAiODEQ1tBeeUiowGPhMOuLR6hobwPS2qklRQmmFOfin0OhrmxyNyfDyhvZ43W+UG1bhzYoLqfoB9QtGFJzW6LlljyoaYnFEdiryT7AT7Yw0DjAAlSF7Wk7zbRL4hulN0CpX0Xm4ErBgNos1AcZlKxTiUtahlvLVtJWouclDfwhpqVCao6Vr3LgYcCPdX+lfrG7QHMWwCPBQUiUgfiHFkPFcub2VXYMcCTXuscgExT25i39wPeP24hE+XDarOsEK7fcHYOIZCGmp6Oi4PaqtAGNJbrdzSylUw+yKGYJiqRx1pKEmeGkIoR5b4M8zEa+eLyDFKXBMM8SY9w1FYHungqpuFqNKh3BtuJOftV041CKm8rf/jjYjx38V3vebbQebLaPFy9MD2nox0d52OQBw7NFvTdkbR3N1Zlwuw7kmr19uPdmxcXk+dpu7kTy0xmYXZW2UhBT0mFXaOVmTsW7NJd1aXE1+s7VP2NcV42TEQvDSmWqleMzhVnsfH0nss2WiuRscRTCgUFS5JxyqYEqK0U5bMADApYs0vWiBFmGgRuIijvFEdaFO/CvG6r5I7AJ7kHqqGtgx0BfZ2Jhi9se1ZSHKhEezZL+Cu6q9GZJQaWE3egDB4QrDqruEIBrMxdRahIXbjYv4y6gOFoEhFP5aiXj5RQQa8QBGqtoZIUN9djL525AEljM2ZGFbRCwDSYmpmcuegrqR3j+Ay/WDmWZg+TwPdjp8Qd6vdSo5fMlfBa8k8QjzoMpCQobnSnuTwhmzs460UwYTMLENMsVJLVjLZodSBM/IxEMj63sW+rVzFBmo6kKBpfSnTxxOQQ/ZeiDridsOmdEIITPnZYK3rYVXylz0caORzG44DS9kk2AC1gh1loP0rp7YR/gmuTuvc7LCJ2z69FYfItC3UI4goqzEnDqQWYJCCoausqYBlTQ2sKjrSwNdgtl5CgQTmBZuM4GuqiLCtHcz2FN/CTvDkhFa6mb8dY+PWaLRoN+989rh9mx+f5QkPg6rCSbOo0ZM+Oz2M94rsv//ynFxe90dXIhPHlnGCWlEDc3j26H+s4NxZKjbudrpsqi1KbTkvvK3BaJhy3j/OuKUalTaN39jR5dkDOYqHqpNc2pdmgkrmeSSW3SmQKo2lqcZkBDf1gMMTB9gpGI4kMVQ7R4kuqsJpYCyEVR4r/NRJBQZLZqOn2lLznJ5E6u7vv352/eElDCB7XIJ0oaoIZzJBmRzN0RxEXxaGKyVtlfBMRDxGh7IV7SUVGenHCH/m+CM8hhUqN0ijDAW8lR4vxEInGnaUUHltM7BI3s2ExktAAXdHynIq1jM5i1foMk8Km4yovjSzOJIywOmQyVQ1IKFjRuXlt0lJE1iqgoPCK1Hrl0Lu4yFz82tyv5ZJkYxy5F3hq6do2nBe/r5ultdb0CMGDDS5hYD0SvYT3tbCYUwCG2ojFqWcQyLHv3mIzsjXjtMx8FJYjWudpBXDn62FrqDMpJcr5ZS354Dz6zUUzJpc5AIchlC93uDsiBifFsOQGGvxDMYBRRF46zDXvysOnRicKIsqihOh84a9XcQBos0XIZkUpfEViZV+P80yLBc/DbrJSRTlgXcJSTOb0ouSEIP4dXsuMpS4bVG9VXEfEcLSbutBPnXZpMt32huYWLpy5F2b/kQGkota6fP+0/v5usi5hwhrffvdU3VXe38/t5Jub3ukByXuqXjbPuwO5AvSKFAgjTeTlJO8elm1V5BsXVp76o8F2v+y2Owp2idPD87g6bw9claHA6TQWx63ULasrXuI5l/2LUanShU7Nm4Ix7TJvnzyPfGQSBfxFILsEnDH7NsG+x25wbobkuXZdX+vORXaKV2XxlYUn9M/5pppcXKJWrjJ5enaB+fWLV4wMCOtRnMFmPtaPqDSGxKbKLI6XtXJTxVZBHnvHtcSKqU+DpmAcdwGG31CYFBzBlFuU841GAN+ghxFXSgSQDb7L/iu+IFBhby3cn2QWlCbBsqxpQBRqCkmXi56bfaTnrEJ6eQtPhJMAPopAKrwJVATNYNrJ36bcq61M9yrvWrXumZ5vVq/dGeKx/V6n0nOasrx8BVpZuKzeIEF2lMoDyAg/4vk0wD+VtSvZkhxWVqWhgHetJ04QiS6KaxuVhu2FKKn5cGWauoPJ8wQUssQkDVl+PLsqDOszIhmKBUJskOuBhFbxdbJnmaeDEor/Ac1MTs/QJcWMDdy+YfDMub0g/sJQx5DQIZEpJ+Gn/Ihb35gN9j9aUaRU6Jxv68GAWgPxEi6AmMr2fcOfUn0UXwKAckqTxbrfbY7OO28+745nCz8FCU5nrvbZu5OY4oIamn+ozfv3T6PB+cfn02yxAh0WMj3GH4iB0i6wH3V6ull+3qv9+esPaXQVGey388fJN/cG1lbPusPaJD0ANzrcq0fduGdXA1GFlxEYvvn0hqN993GhtAxfM12s399Ro9O1KT6dXI18f/vQ1nouZWk3FiFeFssl2yc2ViQKg9oZkYU2bNKYkqagELiQukMHHXRNLDHHy2bEgBMVMgdkqoFLAzGUwp2ife5vP+DK0hzCL/sZEsOooQEUSoAcwGoSMpX+cIRxsZUMTiZUgo88u3GAIhxkAbtJRomU43NQpG3DxTlrH52gmT3LEZPzdB0RNAeG9S9sqzI8aTHXJTgi5+mh4bAWYr1qq9dBvMtYiONZ5DAuoLHbHqNEMKKnmDFF2Wh5eDx3ViFnT62hV1R+AGL7SK0L+Zwsy30z6iwYj+TTxHiZO8J6KiL44UKDOJnAxtRTpPJJb7haFN3xDGt9G1yH61qxpn4wUnVK6WX1ojqfiBM5YuCHHbISzimILvDEKSTpYjKhyxHNKm6xIEmqpLZIrilolJ8Kr6x+ItSpz+RzJWBYOG4gjwjXJm5REaR9It4o9UaxMtwKlIiaqFU7wbJazHXHIvLYinoK/vITPzB10T8LSgmAvE4ok/T+B5vGUulwDEfJa4m9HNvSSLaqIvj+3beLic6NQ6k/aL267J3fGABX200//uXtHz9/8+n4/r0Q8advXv3luwkoP+wbRNh8ddN69dmL6XjGkGltQrIIpQamimubyrW7gpzGCh/dbPzs04bxsc+TydVolOr+U+XDu+d3qbcJOnrxUhvNGGth4r57DV0YqmSe7NgzWFQaJ8nzrbt4mNAARS9NxOMI3NLWwLcQO5ADf0bkWG2nw0yxUejUBBKJfflb02oTcBMS/OySNTQOkBQxRzQKkSeal/+Br5icBNbqVc2oTU0ESB1rzbWSFBNCkQrFcEFgOIxtkbWDb92qyyhhUMLCcSoOnasiS34bEI0LZ181jbM9gjYrjPGEEw+tWq/evRot76eEyQdqd2F2QduIKVkp/s3ZRhoyCM3qw28YERcAwhd2ujuNTaqUOAd9OOWB14jNFDIkbRXQzKiIQ9SB0kA645onRSahIlGKoDz5taWbVIDIZwl87WW2e+f2JAp8QhSFuXNXTPpQ/UoQnuickCXaiuKTNEQPysrw6W2rhwDvAGEIFVESFuAHMEPliCKdLaCdcb2OLV7PgTNtidwthIlJO2jiGS0hiV/yJX4sobMN9VOQQGYGpwzFplDhOAQnUdgmL+/I9n1MBiKrUU4doSaKZDSQHIqH8Raul+1EI7a7Tr896FceKkuPiOFLluJ4++H92aD34xf9lzfDL7/409VIR1f34Wnz7bvnZqeq0uxnv/ixAYhqK7uvzn/35TsENMULutMWbIf5xNLh4elx2G+/uhqOx09/9Xe/eLi/A4P0HVnL27ueaYDCXWMbv/v+XnITikCMMtLpNm8xK1TKGOfU37KTqqSUHDBzsB1Fl/i0H5arsNT+qYUu+ptylUpReRkOEIDmt4Mm7Cy1WgLRmmlIQUowdXIhQbmO5WxiJjmXp+iM1pEEcNQBCC08xBMgEnl44hofFILOW4baju1LslhlT2C/swhUJ0wFlamzyNOUQdFAspf8Efn1O4YGji77q9KSVWbGjuXORsnSrtS9GLUG/eV4xpNZQ0o1ROM0t9nW1sjvw97MjM8kspQRpYu5kK/zyHKn3h71yZ08i742l3dIQhlYw3mCghBOQB/WQ8jD8NGQVh39bF9iqRiUSG+asJCium+UYgKCmlAN6BD1pgjBnSs8AG5UBd1RQw9DXMSbSYMR5dglm8wv92ijW9ZMtlguVfzSgnq/s9saFCUo3YqCQH0e1h8C/PUI6ZVrtshziFbrEXWB+3TMuQV6RhvgJ7vsQ3yocaXAOuli5sQUBSkeZoEKpigmIJZCOHLHs9U3HDh42jMytkaNPHHjSBgGvksJwXKl48QIBZ0QBzXL85SdpRgJbvQgoSf/+umba+lNQPIf/rj85nb18s351bk4vTJ7WsCItw8PC11/u+OLqxHRcPHuWa86Ni6zpdR3+uLl2Wz2dH3xKee2LOrYzwcoafCv0bt+NZ4f3D3xdPeIYZ09G2JaUnwFIevbJFJQt15iQILUKB0Gvtl+Bsare09WH5ghDcwKEXF80jWMOxFkGoV8Ii9ciLQUJe+rIVBH5OQEJfoKAJaUCKxNAkUmM2UQO0PGRWNcU8fGIiXukjeVIEggYCgPntpgJQvbuxaXx2NuCk6C7ItJs+spREfWxUyxUjSjYO0CX5MdsO5UtwbTHJ8eJ06a989ZZCqloav71e1YJRMC3lElQnC/ZrAO3MM0q75grgS7gANa03tz8tFO2m+qPPtX6SMFzRaWNyEGLrbQaLDARSJPSTlBFaqHTUEy1SrGp3lJmAWRrTLdPrr7TfYHnjPu3a+Qv6U0B8gMcCO7QzQc6qSJLLrfKfOxQkp7hhcnyd4OQhSognCOyz6x05oMWFiXw9FjRJ8UBhJOss1OWAmvsg4utyxb62YsATAaxJjEpG1oFI/AwACdPFAsCBXJzZWAXhPxG61Nki0pd2dURM9ZSIo9w7Ieri7RI6xVLBn7p7bQsagmPJh4AMNVayoqgg+IgyFjVS1HuUBEKQs8A1gLPx4eph19b5PD3cPpm6fFh1X94pPPjtXp2/vFejXr6HC/7Lx6dfP7d3cq86azlWbC7mC0wGDKM/LaRd2BvtWv3t1qIX1795SM8Mx9ry2ldcvJx87oKj1jn758eHp2aIruh8PhfLddzVZADMDT66hQkmoRNLsNIE8sCAWUv47SACRyLCqO40r4JFRwXw2zonpAn0CcJq6NjRdUGLOFxpE059M12LJDGC1VrB3XTWycThi2WFX4kFgaJWYwWKgIRklp5tzhpiKL3CVOYPEy+Z4GEAucEM5/pzInaCJlp1wZZ00bwqWSM89Jrp/EJO8T6Ox7fjrxc5iouYQuFQlC3201wjlYEhcvFAcDwxJgf24lLnS7GrkihYkGrangYJhVF7Pt79G29d5FpdELYjIsqTRYT8AksUi8mbWyn1xAYiYkmpJjrHTBbaUIyKQGMNEmc1LwBZ1E3W+Wkhoi6WgbRF2vdFLrQUWRKnG/TBIy3rPsH0EsBhvTNLO1ctGVEXep+pdoxAEZRcNsdtpIS7Qa7ImkS9ujJqrZtG4AbrutfJLV8dHsN48bG+b9E9zYygRzztrHsiviUE8Mw+BzvaztgVxQOrycUF5RZNOvHCW4TfqxmSrO5Jcwnt0hOh4opOBVFUXsynaRFzWeETaQCJwqHNuXnpcGLhi7ksbTb77++Kd3u/vV6vzmnDlvZ8rUxXYz/vu/vj7vVn799YNM2ME0rFrlaWJu+eGTqzOt7yqKijDMRcL98Wp5pl0tTqz8OF4cpgu5eRWgB4VFqNhKaUQKt8cP6t5yM0OSNMlVek/ZD04arJT4AsrxJaDpD2YxA0AgAHIebEEBCKjTZTjKbaSkWiC1ZKn7kBUtLrpdeSDNpy064B2xHVYeThR7ve5kPKZffpYnERcEzpk/h3xnUkP5m3FREB/AU9LfaPTElSxUjeFyC0O6bcpGLFv0ejFTmB1wxNYX4gEh//8KCqoCvSDhrwAAAABJRU5ErkJggg==", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "--------------------------------------------------------------------------------\n", "Editor:\n", "APPROVE\n" ] } ], "source": [ "from autogen_core.application import SingleThreadedAgentRuntime\n", "from autogen_core.components.models import OpenAIChatCompletionClient\n", "\n", "runtime = SingleThreadedAgentRuntime()\n", "\n", "await EditorAgent.register(\n", " runtime,\n", " \"editor\",\n", " lambda: EditorAgent(\n", " OpenAIChatCompletionClient(\n", " model=\"gpt-4o\",\n", " # api_key=\"YOUR_API_KEY\",\n", " )\n", " ),\n", ")\n", "await WriterAgent.register(\n", " runtime,\n", " \"writer\",\n", " lambda: WriterAgent(\n", " OpenAIChatCompletionClient(\n", " model=\"gpt-4o\",\n", " # api_key=\"YOUR_API_KEY\",\n", " )\n", " ),\n", ")\n", "await IllustratorAgent.register(\n", " runtime,\n", " \"illustrator\",\n", " lambda: IllustratorAgent(\n", " openai.AsyncClient(\n", " # api_key=\"YOUR_API_KEY\",\n", " )\n", " ),\n", ")\n", "await GroupChatManager.register(\n", " runtime,\n", " \"group_chat_manager\",\n", " lambda: GroupChatManager(\n", " participant_topic_types=[\"writer\", \"illustrator\", \"editor\"],\n", " ),\n", ")\n", "\n", "runtime.start()\n", "await runtime.publish_message(\n", " GroupChatMessage(\n", " body=UserMessage(content=\"Please write a short poem about a dragon with illustration.\", source=\"User\")\n", " ),\n", " DefaultTopicId(),\n", ")\n", "await runtime.stop_when_idle()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the output, you can see the writer, illustrator, and editor agents\n", "taking turns to speak and collaborate to generate a poem with an illustration." ] } ], "metadata": { "kernelspec": { "display_name": "autogen_core", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.9" } }, "nbformat": 4, "nbformat_minor": 2 }