From f372df1852f0cd87b49a1d5f010ff2b7afd7b595 Mon Sep 17 00:00:00 2001 From: Julian Risch Date: Thu, 10 Apr 2025 15:23:50 +0200 Subject: [PATCH] add agents example with GitHub components from experimental --- notebooks/agent.ipynb | 708 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 708 insertions(+) create mode 100644 notebooks/agent.ipynb diff --git a/notebooks/agent.ipynb b/notebooks/agent.ipynb new file mode 100644 index 0000000..6f8e1e1 --- /dev/null +++ b/notebooks/agent.ipynb @@ -0,0 +1,708 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d21d72df731e208f", + "metadata": {}, + "source": [ + "# Agent(s) in Haystack\n", + "\n", + "A Haystack `Agent` is a component that can be used in pipelines like any other component. The `Agent` uses the provided \"tools\" to fulfill the users request.\n", + "\n", + "\n", + "\n", + "The `Agent`-class encapsulates lower-level Haystack components like `ChatGenerator` and `ToolInvoker`. It composes these lower-level components into a looping pipeline that runs until a \"handoff\"-condition is met." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "initial_id", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:07.494154Z", + "start_time": "2025-02-21T09:36:06.648242Z" + } + }, + "outputs": [], + "source": [ + "!pip install anthropic-haystack -q" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1ac0641a1523ba57", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:10.264686Z", + "start_time": "2025-02-21T09:36:08.647653Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "from getpass import getpass\n", + "from typing import List\n", + "\n", + "from github_components.issue_viewer import GithubIssueViewer\n", + "\n", + "# We created a set of tools that can interact with GitHub\n", + "from github_components.repo_viewer import GithubRepositoryViewer\n", + "\n", + "# Standard Haystack imports\n", + "from haystack import Pipeline\n", + "from haystack.components.builders import ChatPromptBuilder\n", + "from haystack.components.converters import OutputAdapter\n", + "from haystack.dataclasses import ChatMessage, Document\n", + "from haystack_integrations.components.generators.anthropic.chat.chat_generator import AnthropicChatGenerator\n", + "\n", + "# Experimental imports needed for our Agent\n", + "from haystack_experimental.components.agents import Agent\n", + "from haystack_experimental.tools.component_tool import ComponentTool\n", + "from haystack_experimental.tools.from_function import tool\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "10dfea61ae6c2906", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:10.879963Z", + "start_time": "2025-02-21T09:36:10.875080Z" + } + }, + "outputs": [], + "source": [ + "from agent_prompts import issue_prompt, repo_viewer_prompt, repo_viewer_schema" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fd15936eb6849c53", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:11.929543Z", + "start_time": "2025-02-21T09:36:11.926104Z" + } + }, + "outputs": [], + "source": [ + "def message_handler(documents) -> str:\n", + " \"\"\"\n", + " Handles the tool output before conversion to ChatMessage.\n", + " \"\"\"\n", + " result_str = \"\"\n", + " for document in documents:\n", + " if document.meta[\"type\"] in [\"file\", \"dir\", \"error\"]:\n", + " result_str += document.content + \"\\n\"\n", + " else:\n", + " result_str += f\"File Content for {document.meta['path']}\\n\\n\"\n", + " result_str += document.content\n", + "\n", + " if len(result_str) > 150_000:\n", + " result_str = result_str[:150_000] + \"...(large file can't be fully displayed)\"\n", + "\n", + " return result_str" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "eb055b10c098b309", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:13.520240Z", + "start_time": "2025-02-21T09:36:13.515376Z" + } + }, + "outputs": [], + "source": [ + "repo_viewer_tool = ComponentTool(\n", + " name=\"view_repository\",\n", + " description=repo_viewer_prompt,\n", + " parameters=repo_viewer_schema,\n", + " component=GithubRepositoryViewer(),\n", + " outputs={\n", + " \"message\": {\"source\": \"documents\", \"handler\": message_handler},\n", + " \"documents\": {\"source\": \"documents\"},\n", + " },\n", + " inputs={} # TODO: this prevents automatic overrides of repo (for the multi-agent use case)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "eb31fa163e7d5a11", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:14.255846Z", + "start_time": "2025-02-21T09:36:14.249432Z" + } + }, + "outputs": [], + "source": [ + "@tool\n", + "def create_comment(comment: str) -> str:\n", + " \"\"\"\n", + " Use this to create a Github comment once you finished your exploration.\n", + " \"\"\"\n", + " return comment" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "dd0aff035d9422d", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:25.392067Z", + "start_time": "2025-02-21T09:36:15.367404Z" + } + }, + "outputs": [], + "source": [ + "os.environ[\"ANTHROPIC_API_KEY\"] = getpass(\"Anthropic Key: \")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c9fbe18779fb65b7", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:26.758238Z", + "start_time": "2025-02-21T09:36:26.715690Z" + } + }, + "outputs": [], + "source": [ + "chat_generator = AnthropicChatGenerator(model=\"claude-3-5-sonnet-latest\", generation_kwargs={\"max_tokens\": 8000})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "325806047f4835ec", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:28.082697Z", + "start_time": "2025-02-21T09:36:28.073274Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mathislucka/Library/Application Support/hatch/env/virtual/haystack-experimental/0WxCzKa9/haystack-experimental/lib/python3.12/site-packages/haystack/components/routers/conditional_router.py:195: UserWarning: Unsafe mode is enabled. This allows execution of arbitrary code in the Jinja template. Use this only if you trust the source of the template.\n", + " warn(msg)\n" + ] + } + ], + "source": [ + "agent = Agent(\n", + " chat_generator=chat_generator,\n", + " system_prompt=issue_prompt,\n", + " tools=[repo_viewer_tool, create_comment],\n", + " exit_condition=\"create_comment\",\n", + " state_schema={\"documents\": {\"type\": List[Document]}},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "23ba459d24c3c08a", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:30.499830Z", + "start_time": "2025-02-21T09:36:30.495028Z" + } + }, + "outputs": [], + "source": [ + "issue_template = \"\"\"\n", + "Issue from: {{ url }}\n", + "{% for document in documents %}\n", + "{% if loop.index == 1 %}\n", + "**Title: {{ document.meta.title }}**\n", + "{% endif %}\n", + "\n", + "{{document.content}}\n", + "\n", + "{% endfor %}\n", + " \"\"\"\n", + "\n", + "issue_builder = ChatPromptBuilder(template=[ChatMessage.from_user(issue_template)])\n", + "\n", + "issue_fetcher = GithubIssueViewer()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "10d1cdd669be0d7d", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:32.004647Z", + "start_time": "2025-02-21T09:36:31.999299Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "🚅 Components\n", + " - issue_fetcher: GithubIssueViewer\n", + " - issue_builder: ChatPromptBuilder\n", + " - agent: Agent\n", + "🛤️ Connections\n", + " - issue_fetcher.documents -> issue_builder.documents (List[Document])\n", + " - issue_builder.prompt -> agent.messages (List[ChatMessage])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pp = Pipeline()\n", + "\n", + "pp.add_component(\"issue_fetcher\", issue_fetcher)\n", + "pp.add_component(\"issue_builder\", issue_builder)\n", + "pp.add_component(\"agent\", agent)\n", + "\n", + "pp.connect(\"issue_fetcher.documents\", \"issue_builder.documents\")\n", + "pp.connect(\"issue_builder.prompt\", \"agent.messages\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7a6207bc15f02741", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:34.162977Z", + "start_time": "2025-02-21T09:36:33.484011Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASgAAARaCAYAAAD/1e90AAAAAXNSR0IArs4c6QAAIABJREFUeJzs3Xl4TGf7B/DvTPaNiCQSkYUkgiRIbLGUJimJtUFRFRVaey1F1VZbX2IvWrV2ERSlGmpp0dharyBkX6kEkZVIQhaZzP37482cn2mChIk5JvfnunK1ec6Z59xnTvL1nHMm5wEYY4wxxhhjjDHGGGOMMcYYY4wxxhhj7M0mUXcBTDNs3brVUCqVPiQi+bhx4/TVXQ/TDNrqLoC9+RThNHjwYB2ZTAYAJRxSTBV4BMVeydPhpGiTyWQIDQ0t5ZBir0qq7gLYm6sinPKeDicA0NbWRkBAgN62bdtK1Fcd0wQ8gmIv5alw0n3WOjySYq+KA4rVWHXCSYFDir0KDihWIzUJJwUOKfayOKBYtb1MOClwSLGXwQHFquVVwkmBQ4rVFAcUeyFVhJMChxSrCQ4o9lyqDCcFDilWXRxQ7JlqI5wUOKRYdXBAsSrVZjgpcEixF+GAYpW8jnBS4JBiz8MBxZS8znBS4JBiz8IBxQTqCCcFDilWFQ4oBqg5nBQ4pNi/cUAxUYSTAocUexoHVB0npnBS4JBiChxQdZgYw0mBQ4qBA6ruEnM4KXBIMQ6oOuhNCCcFDqm6jQOqjnmTwkmBQ6ru4meS1yG1HU49evTA0qVLVd4vP+O87uIRVB1Rm+GUkJCAw4cPIzMzE507d0Z8fDzmzZsHPT09lW6HR1J1D8+LVwfU9sgpJSUFx44dQ1ZWFsLDw6GlpYXhw4ejRYsWKt2OYiTF8+7VHVrqLoDVrtdxzcnFxQUPHz6ETCZDYWEhlixZgo4dO9bKtqRSKZo3b67t7Ow897fffvtPrWyEiQZfg9Jgr+uCeElJCf766y/MmzcPo0ePRlhYWG1uTjGS0uFrUpqPr0FpKHXdrSMiSCSv58dKJpPJQ0NDy/h0T3NxQGmgzZs3W+rp6aUEBATUU3cttU0mk8mPHDmSX1paajd58uRH6q6HqRaf4mmgiRMnZsvlcu3S0lJ1l1LrioqKoKWlVcThpJl4BKXBduzY8bhv376Gqr7dLxYFBQXyM2fOZIwePbqJumthtYMDSsNpakhxONUNHFB1gKaFVH5+Ps6ePZvO4aT5OKDqCE0Jqfz8fJw7dy4jKCiosbprYbWPA6oOedNDisOp7uGAqmPe1JDicKqbOKDqoDctpDic6i4OqDrqTQkpDqe6jQOqDhN7SHE4MQ6oOk6sIcXhxMABxSDCkOJwYgocUAwQUUhxOLGncUAxgbpDisOJ/RsHFFOirpDicGJV4YBilbzukOJwYs/CAcWq9LpCisOJPQ8HFHum2g4pDif2IhxQ7LlqK6Q4nFh1cECxF1J1SHE4serigGLVoqqQ4nBiNcEBxartVUOKw4nVFAcUq5GXDSkOJ/YyOKBYjdU0pDic2MvigGIvpbohxeHEGFOLHTt2PM7IyKAHDx5U+XXr1i368ccf76m7TsZYHfWskOJwYoyJwnfffVf0dEhxODHGREURUhxOjDFR2rlzZ+6uXbuS1F0H0xza6i6AaY6jR482NjU13aDuOpjmkKq7AKY5TExM9CQSyQfqroNpDg4opjJyuVwLQLm662CagwOKqYyWlpYUgFzddTDNwQHFVIZHUEzVOKCYyvAIiqkaBxRTGR5BMVXjgGIqI5VKeQTFVIoDiqlMeXm5BMAVddfBNAcHFFMZiUSiA6CNuutgmoMDiqmMlpaWNgCZuutgmoMDiqlMeXm5RC6X31V3HUxzcEAxlZFIJDpSqdRS3XUwzcEBxVRGIpHwXTymUhxQTGU4oJiqcUAxlSkrKwMR3Vd3HUxzcEAxldHT09MGUF/ddTDNwQHFVIaI+E9dmEpxQDGV4WtQTNU4oJjK8AiKqRoHFFMZmUxWLpFIeNIEpjIcUExltLW19YmombrrYJqDA4qpDF+DYqrGAcVUhq9BMVXjgGIqwyMopmoSdRfA3gxElAfAVFX9SSQS/tljL8QjKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKvhZubG95//311l8HeMBxQjDHR4oBitYqI1F0Ce4NxQLFqkclkkEgkWLFihVJ7v3794OXlBQDIzc2FRCLBmjVrEBgYCCMjI3Tv3l1NFTNNoK3uApjmWbZsGSZNmoQzZ85AS0tL3eWwNxgHFFM5Ly8vLFu2TN1lMA3Ap3hM5Xx9fdVdAtMQHFBM5YyNjdVdAtMQHFCsWvhve5k6cECxatHS0oKZmRnu3bsntBERbt++Xa3X6+np4cGDB7VYIdNEHFCs2vz8/LBr1y6Ehobi0qVLGDp0KBITE6v1Wg8PD5w+fRozZszAkydPar1WxlgdQkR5WVlZNHDgQKpXrx7Z2trS8uXLqU+fPtSpUyciIsrJySEAtHnzZvq3rKwsGjRoEJmamtLDhw/505usWvjCAqsWfmAdUwc+xWOMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4qpzF9//YWhQ4equwymQTigmMrs3LkT2trPn8msvLz8tdXDGKsjiChP8XTMzZs3k729PRkaGlLPnj2prKyMJkyYQBKJhPT19cnIyIgOHjxIRESzZs2iHj160MiRI8nKyoq+//57Ip4PnTGmSoqAiomJIQB0/PhxysrKotDQUCIievz4MWlra9Ply5eVHvXr7+9P5ubmFBkZSeXl5VRcXMwBxRhTLUVAXb9+nQDQN998Q3K5XAiic+fOkZ6eHpWWlioFlI2NDa1fv77SM8rVvT+MMQ3y9Cne3r17ydramjw9PSk1NZWIiFatWkVeXl5KIZSXl0cAKCYmhgOKMVZ7ng4oIqKCggJq0aIFTZ48mYiIBg8eTJMmTVIKofPnz5OOjg49efKEA4q9lOffcmHsXzZv3gxvb29oaWmhqKgITk5OAIDs7GwUFhYiIyMDcrkcNjY2iI2NRYsWLaCjo6PushljmoyI8h4/fkxvv/02GRoakrW1NX322Wckk8mIiOinn34iExMTMjAwoA0bNhAR0cSJE2n48OGVRk88gmLVxXOTsWrhefGYOvAHNRljosUBxRgTLQ4oxphocUAxxkSLA4oxJlr8OShWXbkAnvvxgCdPnhhIJBLS0dEpeX1lMcZYNYwbN27V2LFjZ6m7DqY5+BSPqQwRSSQSCX8Ik6kMBxRTpSIApeougmkODiimSoZEpK/uIpjm4IBijIkWBxRjTLQ4oJgq5RJRgbqLYJqDPwfFVMlcIpHwtC1MZXgExRgTLQ4oxphocUAxlam4/lSk7jqY5uBrUExlJBJJPQDF6q6DaQ4eQTHGRIsDiqkMEd2XSCT8MQOmMnyKx1RGIpE0JCKZuutgmoNHUIwx0eKAYoyJFs9Nxl7J2LFjsyQSiWVVy4goffv27U1ef1VMU/AIir0SIjpRVbtcLicAP7/+ipgm4YBir6SsrGy1XC6/8+92iUSSVlxcvFo9VTFNwQHFXsnOnTvjpFJp2NNtRERyufzQ7t27M9RXGdMEHFDslRHRaiK6/VRTallZ2To1lsQ0BAcUe2Xbt2+PI6KzqBg9Afg1JCQkXd11sTcfBxRTCcUoSiKRpJWWlvLoialEnfyYwbZt25praWl9KZVKtdRdiybJz8/vIpVKS0xMTK6puxZNUl5eLpNIJDM++uije+qu5XWrk3/qIpfLrfT19fu5ubkZqrsWDdVU3QVokqioqOLS0tKlADig6gpdXd0yBwcHdZfB2AvFxsaWqbsGdeFrUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBib6SbN29i+/btSEhIUHcprBZxQIlEWFgYHBwcsH37dnWX8lL27NmDjh07onHjxujdu3e1X/fkyRMcPnwYJSUlNdreokWL8Pnnn+P27dvVWJu9qersM8nFJi4uDgUFBbh+/bq6S6mx06dPY8qUKahXrx68vb3RqlWrar+2R48eSEpKwq1bt6Cvr1+rdbI3DweUSIwbNw62trbo0aOHukupsZ9//hkA8MMPP8Db27tGry0sLKylqpgm4FM8EVizZg2sra0xZswYrF69GgBQWlqKOXPmoGXLlrC1tYW3tzdOnDjxwmUxMTEwMzOrdJrl4+MDMzMzJCcnC22hoaHo0aMHrK2t4eLigqlTpyI3N7dGtVtbW+PgwYMAgMGDB6NFixbCspycHEydOhXOzs6wtraGt7c3QkNDheXt2rXDvXv/m0mpadOmMDMzE8IOAI4fP46+ffvCzs4OzZo1w5AhQxATE6O0/UOHDqF9+/awtbWFj48P/vzzT6XlMpkMq1evRtu2bWFlZQVPT0+sXr0aMplMWMfBwQFmZmYIDg6Gu7s7LC0tsWbNmhq9D6x2cECJgJOTE1xdXZXa1q5di23btkFXVxfe3t548OCBcJ3mecuqa8uWLRgzZgxu3LgBT09PGBkZYffu3ejbty8ePXpU7X569uyJBg0aAAC8vLzw9ttvAwDy8vLg7++P3bt3o379+vDw8EBiYiLGjBmDkJAQAICfnx8MDAwAAP3798fAgQNhZ2cn1BcYGIjw8HA4OjrC1tYWYWFhlQL0wIED0NHRgbW1NSIjIzF8+HAkJiYC/5vtGGPGjEFwcDCKi4vRvn17FBQUIDg4GJMmTaq0L1999RW6dOmCbt26Yfjw4TV6P1nt4IASgYCAAHz44YdKbfHx8QCAuXPnIiQkBFevXkXfvn1fuKw6srOzsWTJEpiYmODcuXM4duwYIiIiMGTIEKSkpGDXrl3V7iskJES45rRs2TJs2bIFqBgV3rp1C6NHj8aVK1dw/PhxhIWFQUdHB0uXLkV5eTmWL18uhNvGjRvx3XffwcvLC1lZWViyZAmkUikOHjyIM2fO4Ny5c7h48WKlU8g5c+bgv//9L8LDwzF8+HDIZDLs378fAHDixAkcPXoUrVu3xvXr13H06FFcv34dTk5OOHjwYKXR2MqVK7F161YcOnQINjY21X4PWO3ha1Ai5efnh+PHj2P+/PnIzs5GUFAQ6tWr98Jl1REWFobS0lJYWVlh586dQrvietC1a68+c/nx48cBAI8ePcLChQuFdhMTEzx48AC3bt2Ck5NTla89c+YMSktL4evrK4zIAMDFxaXSum3atAEASCQS9OvXD3v37kVqaipQEVAAYGxsjODgYOE1ilHbtWvX4O7uLrQPHDjwlfebqRYHlEiNHDkSJSUlCA4OxuLFi7F+/Xps27YN77zzznOXVUdWVhYAIC0tDZs2baq0XPEL/CoU2zhw4ECVy5+3DcVrmzat2Qzqurq6AICysv9NxJuZmQkAuHjxIi5evFhp/X/fNTQ2Nq7R9ljt41M8ERs7diwiIyMxceJEPHz4EBMmTBB++Z61TCr93yGVy+XP7Fcx2ho0aBAePHhQ6Wvjxo2vXLtiG+Hh4VVu49+nUE/XW79+feCpgHnVGtatW1dlDcOGDXul/lnt44ASqZKSEmRkZKBevXpYtmyZcGqUl5f33GXm5uYAgBs3bginbNHR0UhJSRH67tKlC1BxCvT06Vx0dDSKiopUUr9iG6tXr8aTJ0+AipHNv08fTUxMhHpR8cFNxWv/+OMPXLlyRam+mtwM6Nq1KwBg69atShfXw8PDX2HP2OvEASVSv/zyCzp27Ij33nsP/fr1Q2FhIZo3bw5LS8vnLmvUqBFatWqFvLw8eHl5oWfPnvD19cXjx4+Fvl1cXDB8+HAUFxfDz88P3t7e6NatG3x9fZWuSb2K2bNnw8jICAcPHkSbNm3g7+8PV1dXjBgxQilkOnToAAAYOnQo3nnnHcyaNQvNmzdHYGAgysrK0KdPH7z11lvo3r07fH19hQvg1fH+++/DxcUFSUlJ8PT0RK9eveDp6YnevXsjOjpaJfvJahcHlEiZm5ujWbNmuHDhAhISEtCnTx/s3bv3hcsAYMeOHejSpQsKCgqQlZWFadOmKX0+CRV3zRYsWAB7e3vExcXhzp076Nq1K9zc3FRSf4sWLXD8+HH06tULRUVFuH79OoyNjTFkyBCl07kvvvgCvXr1gkwmQ3JysjAC/Oqrr7Bo0SI4ODggOTkZ6enp6NatG1q2bFntGgwNDXH06FF8+OGHMDQ0xPXr11FUVIRBgwYJp5FM3CTqLkAdtmzZ0t3U1PRIr169+KeUid7Ro0cLioqKOk+YMCFe3bW8bnwXj1Xps88+w61bt567TseOHTF79uzXVhOrezigWJXCw8MRGxv73HX4j3tZbeOAYlU6f/68uktgjC+SM8bEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQGsDd3V1puqbqioyMhLm5OUpLS2ulLsZeFQeUGsXHx2PChAlwc3ODlZUVXF1d8fvvvwvLV65cqTRpQGZmJgIDA5Geni60FRQUID09HY6OjjXefkJCAuzs7KCnp1fl8lGjRuHjjz+ucb8va9WqVWjWrFml9pEjR8Lf3x+5ublwc3PDr7/++tpqYurFfyysJj///DOmTZuGIUOGYNOmTTAzM0NUVBQcHByEddq0aYPy8nLh+wsXLuDatWtKz/NOSkoCKubWq6n4+PjnBltMTAxGjRpV435floeHBx4+fIi7d++iSZMmAIDLly/jxIkTOHnyJExMTODn5/dSYczeTDyCUoPY2FhMmTIFK1aswMaNG9GjRw+4u7sjMDBQePLl1KlT8cEHH6C4uBgAcPDgQUyePBn379+Hra0t5s2bB1SMgkxMTLBs2TK0atUKLVu2FKZ8ysnJgZmZGa5evSpse/LkyQgMDBReW1JSgs6dO8PBwQFTp04VHsdbWFiItLQ04QmbijnpbGxs0K1bN6SkpCA9PR3Dhg2DnZ0d3N3dcfjwYaBiAs8NGzYI2/zpp5+UZmi5cuUKAgICYGNjAycnJ3z55ZdARUChIhgVFi5ciGHDhsHKygrW1tb44YcfhBB/8uQJ/vOf/8Dd3R3W1tbw8fFBfHw8kpKSYGZmhpycHKBi6qshQ4YIfd66dQvW1tbCLMv79u1D165dYW1tjbZt2wqzH588eRJ2dnZYs2YNOnToIEwIyl4fDig12LhxIzp06PDc0cn69ethY2MjTIr53nvvwcPDAwsWLMCdO3ewfPlyoCJktLW10b17d4SHh+Ptt9/GsmXLAABxcXGQSqVKj8mNi4sTQkcRbocPH8a+fftw9OhRfP3110BFiBIR3N3dQUQICgqCn58fYmJiMGvWLDRr1gzz588HKkY5W7ZsgaenJ0pLS3Hz5k2lRwfHxcUJMydfvnwZAwYMQLdu3RAbG4s9e/bgq6++wp07d2Bubo4mTZoIz6E6cuQI4uLisGDBAjRu3BgbNmyAnZ2dMFtLUFAQjh8/jpCQECQnJ8PKygrffvstnJ2dYWBggISEBKBiEtE///xTODVes2YNBg8ejObNm2PTpk34/PPPMXfuXCQnJyMoKAiLFy8W3p+ioiLY2dnhypUraN68ucp+Blj1cECpwfnz5+Hv7y98X1BQADs7O9ja2mLRokVAxQgmPT1dCKiysjLExMSgXbt2Sn0lJiYKkyeYmJigbdu2wiwq8fHxaNasGYyMjAAA5eXlSE5OhqurK/Ly8pCRkYEZM2bA0tISXl5eCAgIwLlz54CKUUyjRo1gaWkJIkJ5eTnS0tKgr6+PgIAAaGlpoby8HJmZmSgvL0fXrl1ha2uLpKQklJeXK03lHh8fLwTWF198gbfeeguzZs2CsbExIiIi0KBBAzRq1AgA4OnpidjYWMhkMvznP//B9OnTYW1tDVQEhuL9CAsLw++//46NGzfCw8NDmAy0ZcuWQijHx8fjxo0b2L59Oxo2bIg///wTt27dwuHDhzF79mzk5+cjODgYM2bMQL9+/UBEiI2NFQI9Pj4evXv3xtChQwFAmNKLvT78jqtBbm6u0kP7DQwMcPbsWejo6AjXkuLj46GlpSXMphsTE4OysjJhJl2FhIQEpTBISUkR/qWvallJSQnc3NyE/p9eTkSQyWRAxQhKESpSqRSHDh1CUlIS2rVrhzNnzgAVExs0a9YMHTp0EEZe8fHxMDc3h5WVldBvfHw8XF1dUVpaiqtXryIqKgr29vawt7fHkSNHcPDgQWHSzbZt2yI2NhY//vgjSktLMXnyZKV+FAH1999/w9jYGIMHD4aDgwN8fHzQu3dvTJw4EQCEfZwzZw6CgoLw3nvv4fTp01i7di2GDx8OOzs7REREoKioCJs3b0bTpk3RsmVLyOVyYV8SEhLQvXv3Vzza7FXwRXI1sLKywvXr1zFy5EgAgI6ODoyMjPDw4UMhFOLi4tCsWTPhsboRERFwcnISRkMA8ODBA2RnZwu/tKj4Je7WrRtQMbrq2bOnsOzKlSswNjaGg4MD/vjjDzRv3lyY4begoAC///47goKCgIpA9Pb2Fl7bpk0bnD59GpMmTcL8+fNx8eJFmJub44cffsCuXbswbdo0fPDBB0hMTFQ6pfznn3+Qk5OjdMq3fft2tG3bFvr6+kIwKXh4eODLL7/EypUrsXr1aqXHCsfHx+PDDz8Uvldc9yoqKqo09bubmxuWLl2K+vXr48cff0R4eDhGjRoFLS0tXLp0SVhPIpEI8wHWq1dPGCXJZDKkpKQovbfs9eMRlBoEBARg165dWLlyJa5cuYJLly5h8eLF0NLSEi6SPz1aQMWo6/79+0hLS0NqaipQ8S/8v68xPX0aVFxcLEwjHhUVhRUrVqBVq1aQSCS4evUqSkpKcPfuXSQlJWHEiBGoX78+Jk2aBJlMhsTERLi7uwMVE3z+/fffuH//Ph4+fIhmzZohKSkJP//8M+7fv4+MjAw0bNgQ9evXR0lJCR48eICysjJkZ2dj2rRpwn7p6enB3d0dmzdvRkFBAXJycpQm5kTFCAoAnJ2dERAQILRnZWUhNzdX2Lf27dsjIiICJ0+ehFwux9mzZ5Xm23N3d8ejR4+wcuVKGBsbo1u3bpBIJBg5cqRwyuju7g49PT189dVXkMvlSExMxD///AMAuHnzJkpLS2s0zRVTPQ4oNZg/fz6mTJmCffv2YcCAARg/fjweP36MI0eOCCOa+Ph4pV+OgQMHQl9fHx07dsSSJUuAihGSg4ODMKpKT09Hfn6+cNo2ZcoUHDp0CG5ubli/fj0aN24MV1dXyOVyXL58GUOHDhVOjezs7HD06FGYmJggJSUFpaWlwqjn/PnzCAwMRIcOHaCvr4+1a9ciMjISS5cuRZs2bRAWFoa9e/dCW1sbgYGBePToEVq0aIGgoCBYWlrC0dFR2K9Nmzbh/v376NSpE/z8/ISwVahfvz6cnJyEmwAK8fHx0NXVFU6Be/fujcmTJ2PGjBlwc3NDcHCw0ue5WrVqhX79+qFPnz4AAD09PfTu3RvTp08X1rGwsMC3336LAwcOwNXVFWPGjBGu3yUkJMDKygpmZmYqPPKspnhePMZEri7Pi8cjKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0aqz8+IVFRXpXbp06ZG669Awikk4SM11aJQnT57oVWM1jVQnA0pLSyuptLR0YlpamrpL0SiZmZnDtLS0CiwsLE6ouxZNI5VK09VdA2NvtLFjx84dO3bsWHXXwRhjjNU6LXUXwDTHxIkTG7i4uOjGxMSUqrsWphn4Lh5TGZlMNs/Q0HCcuutgmoMDiqnSAwD56i6CMcYYq3V8DYqpDF+DYqrGp3hMZfgaFFM1DiimSnwNijHGWN3A16CYykyYMMGhffv2RlevXi1Udy1MM/ApHlOZ8vLyyeXl5cPVXQfTHBxQTGUkEkkmgFx118EYY4zVOr4GxVRm3Lhxdu3atTOMiIjg52wxleBTPKYyRDSFiEaouw6mOerkA+tY7ZBIJGkVn4VijDHGNBtfg2Iq8/HHHzdyc3PTj4qKKlZ3LUwz8DUopjISiWSWnp7eaHXXwTQHX4NiqhQtlUofqrsIxhhjrNbxNSimMh9//LFXhw4dGkZERGSpuxamGfgaFFMZiUQyWC6X91R3HUxzSKqxjqgREc9iy1jVyiQSia66i3gVPIJijIkWBxRjTLQ4oBhjosUBxRgTrTobUE2aNMGECRPUXcZrU15ejr///lvdZTzXjRs3IJFIsG/fPnWX8toUFBTg+vXr6i5DtOpsQNU1H330EcaPH6/uMti/tG7dGt999526yxAtDqg6oqSkRN0lsCrwcXm+OhFQ5eXlWLhwIaytrVGvXj28++67KCoqUlonMzMTH3zwAUxNTWFkZAQ/Pz/ExsYqrfPXX3+hZ8+eMDExgYmJCfr3749r164BALp16wZ/f3+l9desWQOJRCL8EJqammLXrl3o06cP9PX1YWVlhZkzZyI0NBStW7eGgYEBOnTogIiICKV+zp49Cy8vLxgYGMDe3h5jxoxBRkaGsNzU1BT79u3D0KFDYWxsDBsbGyxdulRYHhQUhP379yMuLg4SiQQSiQSpqakAgJUrV8LW1hbGxsbo1q0b/vzzzxq/v7/99htu3LhR49fl5ORgxIgRMDExgaWlJebPn19pncuXL6N79+4wMDCAubk5xowZg7y8PKV1vv/+e7Rt21Z4T8eNG4fs7GzIZDJIJBKsWLFCaf1+/frBy8sLABAZGYl69erh2LFjaNOmDXR1deHk5IQffvgBwcHBsLOzQ7169RAQEICcnBylfjZv3gxnZ2cYGBigZcuW+PLLL4VjHRkZCUNDQ5w7dw6dO3eGgYEBWrRogSNHjgivd3BwQFZWFjbTaKFbAAAgAElEQVRt2gSJRAIHBwcAQFFREYKCgtCwYUM0bNgQAQEBSEtLq/H7y0SAqmH8+PEEgMaMGUM//vgjvf/++wSAxo8fT0RERUVF1LJlS7K0tKStW7fSrl27yM3NjczNzSkvL4+IiE6ePEna2trUrl072rJlC23atIn8/f3p0qVLRETUtWtX8vPzU9ru6tWrCQAVFxcTEVH9+vVJX1+fvv32W7p8+TK99957BIAaN25Mv/32G505c4ZatmxJTZs2pbKyMiIiOn36NOno6NCYMWNo9+7dtGHDBmrWrBm1aNGCHj9+LPSro6NDy5cvp6tXr9Ls2bMJAB07doyIiJKTk8nX15eaNm1KFy5coAsXLlBJSQmdPn2aANCIESNo165d9MEHH1BoaGh13lIlq1atIh0dHRo1ahTduHGjWq8pKSmhNm3akKGhIS1cuJC+//57at++PQGgvXv3EhFRXFwcGRoaUseOHWnv3r20YcMGMjU1JV9fX6GfRYsWEQAaMmQI/fjjj7Rq1Sry9fWlvLw8KisrIwAUHBystO2+fftSp06diIjo+vXrBIDs7Ozo6NGj9Oeff5KbmxsBoG7dutHff/9Ne/fuJWNjYwoMDBT6WLx4MZmYmND8+fPpp59+ooULF5KJiQmNHDlSqV9LS0vat28fXbp0ifz8/MjQ0JBycnKIiOjKlStkZmZGgwYNogsXLtCVK1eIiGjBggUkkUho6dKltGPHDurWrRvl5ubW+LgQ0RN1/37WeS86QhEREQSA5s+fr9RuZWUlBNTWrVsJAP3555/C8tTUVJJKpbRkyRIiImrRogU5OztTSUlJldupbkBNmjRJWH7r1i0CQN98843QFhISQgAoMTGRiIhatWpFn3zyiVK/iYmJBIAOHTok9DthwgRhuUwmIzMzM5oyZYrQNmzYMHJ1dVXqZ8eOHQSALl68+KK38YViY2Np5MiRZGBgQKNHj6abN28+d/21a9cSADp16pTQlpCQoBRQw4cPJxMTE+EfCSKiXbt2EQA6d+4c3b17l7S1tYVQ+LeaBNTPP/8sLP/hhx8IAMXGxgptY8aMISsrKyIiSk9PJx0dHTp48KBSv1u2bCEA9ODBA6Hfffv2CcuvXbtGAOiXX34R2ho1akSTJ09W6icwMJCMjY3pyZMnz30Pq+GNDyiNP8U7dOgQAGDGjBlK7Vpa//930mfPnoWpqSl8fHyENnt7e7Ro0QJXr15FamoqEhMTMXr0aOjp6b1SPQYGBsL/6+vrA4BSn02aNAEA5ObmIi0tDfHx8di6dSv09fWFrzZt2gAA7t69K7zOyMhIad9sbGxw796959bSt29fmJmZITAwEMeOHXth7SUlJUhNTRW+ysvLhWWurq4ICQlBYmIiioqK4OLigvj4+Gf2dejQIbRu3RrvvPOO0Katrfz0n7Nnz8LHxwempqZCm5+fHwDg6tWrOHXqFGQyGSZOnPjC2l+kOsclN/d/M2qdOnUKZWVlGDFihNJxmTJlCvCc42Jvbw8ALzwuI0aMQFFREXr37o2YmJhX3rc3mcY/D+r27duoX78+zMzMnrlOfn4+LCwsKrWbmZkhPT0dWVn/++N8W1vbWq0V//uDW+B/I0NkZmYCABYvXoxBgwZVWrdx48bP7EdXVxcymey527KyssLFixfx6aefol+/fujatSv2798PGxubKte/dOkSvL29he8zMjJgZWUlfJ+amopVq1bh2LFjGDVq1DP7QcVx8fT0fG59+fn5sLS0VGpTHMf09HSUlZUBr/G4KP7sU3Fcjh49KvyD8jQnJ6dK1y9RcUwAvPC4+Pv749ixY5g1axbatGmDjz76CN9++y10dHRUtDdvDo0PKAsLCxQUFKC0tPSZo58mTZrg0qVLldqzsrJgZ2cn/Auu+MGsiiJYVKlBgwZAxUXTFi1avHJ/Vf1dtYuLC44fP46wsDAMHDgQQUFBOHXqVJWvd3Nzw6+//lqpvuTkZHz55Zc4cOAAhg4disjISDg6Oj63FgsLC2RnZz93nSZNmuD+/ftKbYp/LBo0aKB0XKoKito4JnhqvwHU2nHx9/dHr169sGHDBsyYMQMODg5V3kTQdBp/iteuXTsQEX766adnrtO5c2c8ePAA4eHhQlt0dDRSUlLQrVs3NG/eHE2aNMHOnTuV/vUjIsjlcgCApaVlpaG74k7Zy3J2doa9vT2+//57PH78WGiXyWR48qRmlxeMjIyQmZkp1KtQWloKAPDx8VG6K1kVc3NzBAQECF+KwN+0aRNkMhmioqIQEhLywnBCxXG5cuUKkpOTn7lO586dcfbsWRQX//8jzg8ePAhU3DX19vaGRCLBjh07lF6nOEZaWlowMzNTOi5EhNu3b7+wvufx8fGBVCrF119/rdT+9DGqLiMjo0o/N4pjIpVK8emnn8LGxua5x0WTafwIatiwYfjyyy8xYcIExMbGwsPDA//973+VfigCAwMRHByMIUOG4IsvvoCWlha+/PJLWFpaYtKkSZBIJFi5ciVGjBgBLy8vBAUFQSqVYteuXZg8eTICAwPh5+eHQ4cOYe3atfD29saRI0cq/eLUlEQiwVdffYXBgwfDy8sLEydOhEwmQ0hICAIDAzF9+vRq99W9e3d8//33mDBhArp164YGDRrAysoKQ4YMweTJk2FsbIwTJ06gffv2Na4zODgYhoaGNXrNnDlzEBISgu7du2P69OmwtrbG3r17ldaZP38+9u3bB39/f0yYMAFpaWlYsmQJvL290aNHD0gkEowdOxZbt27F/fv34e/vj5ycHGzduhVnzpyBg4MD/Pz8sGvXLvj4+MDKygpr165FYmLiC08vn8fJyQlTp07F+vXrMWDAAAQEBCAjIwPffPMNjh8/Dg8Pj2r31b17d/z0009YsWIFzMzM0LlzZ/z+++84fPgwRo4ciXv37iE9Pf2ljgsTgercykhNTaV+/fqRgYEBWVlZ0SeffEIWFhbCXTzFOoMGDSITExMyNDQkf39/SkhIUOrn119/JQ8PD9LV1SVra2vq378/hYeHE1XcMZo1axY1atSI6tevTx999BHNmzev0l28mTNnCv1lZGQQANq+fbvQdubMGQJAFy5cENqOHTtG7dq1I11dXTI3N6dBgwbRtWvXhOX/7peIqF27dvTuu+8K35eXl9Mnn3xC9erVIysrK5o7dy5FRUWRv78/NWjQgExNTendd9+lO3fuVO/+kAqcOXOGPD09SU9PjxwdHemzzz5TuotHRHT27Fny8vIiPT09atiwIY0dO5by8/OV9mv58uXk4OBAurq61LRpUxo/fjzdvXuXiIiysrJo4MCBVK9ePbK1taXly5dTnz59Kt3F++2334Q+9+7dSwAoJSVFaFu0aBFpaWkJ38vlclqzZg05ODiQjo4O2dnZ0aRJkygrK+uZ/RYWFhIA+uqrr4S2rKws4eMHDg4OdOjQIfrll1+offv2ZGhoSNbW1jRt2rSXvaP3xt/F4wfWMaa5+IF1jDFWWzigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxQRPP51BXV70rCRWt3BAMQBAWVkZhg4dWmkyiVdV03nfpk+fjsTERJXWwN5cHFAMALBkyRI0atQIxsbGKu23pvO+DRs2DEOGDBGelsnqNg4ohszMTKxduxajR49Wed81nfftrbfeQklJCXbu3KnyWtibhwOKYffu3TAxMUG7du2EtrKyMsybNw82NjbQ09ND27ZtERoaKiyPjIyERCLBqFGj4OLiAn19fbi7uys9dO5Z8769iJ+f3ys/7I9pBg4ohl9++QWurq5KbePGjcPq1asxduxY7NmzBw4ODhg0aBAuXLigtF5qaiq2bt2K3377Dc7Ozvjggw+Ex/IePHgQZmZmwusU7S/i6uqK8PDwV340L2Nq9zKPGWT/r6SkhCQSCY0ePVpoU8y798UXXwhtcrmcnJycyNvbm+gZT4wsLy+nli1bkqenp9BW1bxvL/L7778TAAoJCXnFvavz3vgnavIIqo67e/cuiAgmJiZC27lz5wBAaaoriUSCXr164erVq8/sSyqVomfPnoiMjKzxpA5PU1yov3Pnzkv3wTQDB1Qdp5jW6ekpufLz84GKmWqeZmZmhsLCQhQWFj6zvwYNGkAul7/UDCcKiokz/z3lFKt7OKDqOMVEmE/fbVPMMVfVnHS6urrPncHl7t27MDIyUpo7rqaPjVdMM/W8yVZZ3cABVcc1atQIqJgcVKFjx46QSqU4fvy40FZaWoqjR4+ic+fOStPGP+3hw4c4dOgQunTpIrRVNe8bAJSXl2PHjh1VfohTEVCK2ljdpfHz4rHnMzExgbOzs1KIODo6YtSoUVi0aBFkMhkcHR2xbds2ZGVlYffu3UqvX758Oe7du4fCwkJs3rwZBQUFWLp0qbC8qnnf3N3dcejQIYwdOxaOjo64ceOGUp/p6ekAgA4dOtT6/jNWq9R9m0QTTJkyhZycnJTaiouLafr06dSoUSPS1dUlDw8POnr0qLBccRevd+/e5ODgQHp6etS+fXs6fvy4Uj9VzftGRJSQkECWlpb00UcfVapn/vz51Lhx41rb3zrkjb+L98ZT90+AJrhy5QpJpVK6d+9etV9T1ccMVOWtt96iOXPmqLzfOuiNDyi+BsXQvn17vPfee/j555/VXQrS09ORmJiIzz//XN2lMBHggGIAgI0bN+LgwYM1/ts5VVu+fDm+//57mJqaqrUOJg489TkT3Lt3Dw0aNICBgYHaarh58yYcHR3Vtn0N88ZPfc4BxZjmeuMDik/xGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBVUf16tULEokEEokE+/fvV3c5r11sbKyw//xgPPHigBK5jz76CL17965ymbe3N6ZPn/7CPj755BMcOnRIqS02NhYLFy5ERkYGBg0aBCKCk5MT9PX1YW1tDW9vb6V58N5kGRkZCAgIUJqEoXnz5sjIyMDgwYMrTbnFxIMDSuQiIyPRtm3bKpf5+fnBy8vrua9PT0/Hpk2b4ObmJrTl5eUhIyMDnTp1gpWVFXR0dJCSkoKbN29i3759OHDgANzc3DBw4ECsWLFC5fv0uoWFheHy5cuwtbUV2nR1dWFlZYVbt24pvTeMqZS6nwhWm8rKykhPT4/2799faZmjo6PSA+POnTtHnp6eZGBgQO7u7pSYmEi3b98mPT09kkqlZGRkJMxXd/78eQJAqampQn/79+8nQ0NDKi8vF9omTpxI9evXJ5lMRuXl5bRs2TKys7MjQ0ND6tatGyUkJAjrnjx5kjp06EB6enpkZWVF8fHxtG/fvkp92tvb01dffUVyuZycnZ1p1qxZ5O7uTvr6+tS+fXsKCQkhDw8P0tfXJ29vb3r06BEREZWWltK8efPI1taW9PT0qF27dhQdHU1ERF988QWNHDmSRo8eTfXq1SNzc3Pas2cPERHt2bOHtLW1SUdHh4yMjGjatGlCLeXl5WRgYEBbt25V6XETkTf+gXVvPHX/BNSm6OhoAkBJSUmVliUnJwshI5fLycLCghYuXEi5ubm0f/9+kslkREQ0d+5c6tOnj9Jrv/32WzI2Nia5XC60zZkzhzp16qS03qFDhwgAZWdn09SpU6lt27aUkJBAhYWF1L9/f/Lx8SEioj/++IP09fVp7dq1lJWVRcnJyVRUVETz589X6jM/P58AUFhYGBERWVhY0FtvvUWpqakUHx9Penp61KNHD7p79y799ddfBIBCQ0OJiKh///7k6upKV65coYKCAurfvz8FBQUREdHMmTPJwsKCDh8+TAUFBTRs2DBydXUVttu5c2datWpVpfcwJSWFANBff/31kkdI9Dig1E3dPwG1KSQkhIyNjZVGIAq//vor1atXj6hiJGBmZkYjR46kx48fK63n7e1NS5YsUWqbNGlSpTDy9/en8ePHK7Xt2LGDJBIJRUVFCf9V+P7778nc3JyIiNzd3WnGjBmVahwwYACNGzdO+P7ChQsEgHJzc6moqIikUilduHCBqGKEpK2tTadOnSKqGD1KpVI6efIk/fHHHwSALl26RERE//zzD7Vq1YrWrFkjbGfmzJnCdpYtW0bu7u5ERPTkyRPS19enc+fOVaovNDSUANDDhw8rLdMQb3xA8TUoEYuMjETr1q0hlVY+TDExMcK1E6lUilOnTiE+Ph6Ojo44deoUAEAul+Pq1avo1KmT0mvj4uIqXRiOjIxEmzZtlNqOHTuGtm3bIiwsDObm5mjdurWwLCcnB5aWlsjOzkZMTAzee++9Kmt8us/o6Gg0adIEDRs2RGxsLORyOdzd3QEA8fHxkMlkwjYSExMhl8vh5uaGs2fPwtjYGD179oSpqSnat2+PAQMG4NNPPxX6fbq25ORktGzZUtivsrIytGvXrlJ9cXFxaNKkCerXr//c48DUhwNKxCIjI+Hh4VHlsujoaOGXGwA8PT1x+fJlvPPOO8Ivbnx8PAoLC+Hp6an02n8HVFZWFjIzM5UuxoeGhiI0NBQzZ85Efn4+rK2tlfr45Zdf0KdPH2GW4X9P5vn48WOkpqYqXYC+ePGiEFgxMTFwcHAQwiE6OhpWVlbCbMbR0dEwNzcXtuvh4YEHDx4gLS0N9+/fR3BwMKRSKQoLC5GWlqb0XkRFRQnfh4eHw8XFBUZGRpXew6qCmokLB5SIRUVFwcLCAomJicJXRkYGUPELrvglPHLkCM6dO4fc3Fzk5eXByckJAJCdnQ0AiIiIQEpKCogImZmZyM3NVfrFVEyeKZFIcOHCBcyYMQNDhw7FzJkzMWLECHh4eCAxMRHh4eEoKSnBf/7zH9y+fRuzZs2Cvb09LC0tsWTJEqSnpyMyMhIXL15EaWkpiEiod8+ePdi/f78QUP8e9Tzvey8vL4SHh+PYsWOQy+U4ffq08Oz06OhoSKVStGrVCgAgk8kQHx8vvDfZ2dnIycnBrVu38M8//yi9v7GxsXwHj9UudZ/k15Y7d+4QgEpfc+fOpeLiYtLS0hKuq0ydOpVMTU2pfv36NHjwYMrIyCAioqKiIuratStpa2uTtbU1yeVyOn36NAGgu3fvCtsKDg4mACSVSsnCwoL69+9PJ0+eVKpn9uzZZGFhQaampvTuu+9SSkqKsOzcuXPUpk0b0tPTI3t7e/r999+JiGjy5MlkaGhIjo6ONHv2bDIwMKB9+/YREZGPjw8tWLBA6KNXr140a9Ys4fs+ffrQ9OnThe/nzp1LjRo1IkNDQ+rcubNwgf/bb7+lli1bCuspbizcvHmTiIhiY2PJzs6OdHR0aMiQIcJ6MpmM9PT06IcfflDB0RKtN/4aFD+TvI7ZsGEDFi1ahIcPH6q7FLVKSkpCixYtcPnyZU2ewZifSc7eLLGxsXByckJmZiaKi4vVXc5rJ5fLkZmZif/+97+QSCTCqSETJw6oOiYuLg4RERGwtrbGyZMn1V3Oa3ft2jVYW1tj9OjRaNq0aZUXz5l48CkeY5qLT/EYY6y2cEAxxkRLW90FqECeugtg/1NWVqYvkUjk2trab/ztbQ3Bx4ExhbFjx64eO3bsLHXXwRhjlSxevFiqCTdemHjwNSimMvfu3TOZNGkS37dnKsMBxVSGiBaUlZVNUHcdTHNwQDGVIaJSiUTCF2YZY4wxxqptzJgxJuPGjTOsxqqMVQuf4jGV0dLSWkhEk9RdB9McHFBMlcokEolM3UUwxhhjjL05+BoUUzU+xWMqI5VKJwMIVHcdTHNwQDGVkUgkEn4+F2OMsTpBS90FMM0xceLEBi4uLroxMTGl6q6FaQY+xWMqI5PJ5hkaGo5Tdx1Mc3BAMVV6ACBf3UUwzcHP7mGvZOzYsVkSicSyqmVElL59+/Ymr78qpil4BMVeCRGdqKpdLpcTgJ9ff0VMk3BAsVdSVla2Wi6X3/l3u0QiSSsuLl6tnqqYpuCAYq9k586dcVKpNOzpNiIiuVx+aPfu3Rnqq4xpAg4o9sqIaDUR3X6qKbWsrGydGktiGoIDir2y7du3xxHRWfz/TM+/hoSEpKu7Lvbm44BiKqEYRUkkkrTS0lIePTGVeO7HDLZu3Rqgq6vLf/zJqiU/P7+LVCotMTExuabuWpj4ERE9efJky4QJE/581jovmlm4rbm5+WAbGxvVV8c0WVN1F8DE79atW2W5ubnnALx0QKFBgwZwcHBQeXGMsbrt/v375bm5uc9dh69BMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4q9srt37+LHH3/EtWu18yjyq1evYt68efjrr7+eu15sbCy+/vprvOgpjezNwQElImFhYXBwcMD27dvVXUqNrFu3DjNmzMCNGzdeua+srCy0bt0aH330kdAWEhKCLVu2IDs7+7mvnTRpEhYtWoSCgoJXroOJwwufSc5en7i4OBQUFOD69evqLkVt0tPTcffuXXWXwUSCA0pExo0bB1tbW/To0UPdpaiNp6cnDhw4AFtbW3WXwkSAT/FEYs2aNbC2tsaYMWOwevVqAEBpaSnmzJmDli1bwtbWFt7e3jhx4gQA4M6dOxgxYgQcHBzQrFkzDB48GMnJyQCAzZs3w8zMDMuWLRP6f/ToEczMzNCiRQul7YaGhqJHjx6wtraGi4sLpk6d+tLXcL777js0b94cTZo0wYABAxAeHi4si4mJgZmZGXr37q30Gh8fH5iZmSE5ORmXLl2CmZkZhgwZgo8//vi52yIifPPNN2jXrh2sra3RpUuXKkdeL9q/wMBAmJmZ4fPPP0fnzp1hZWWFwYMHv9T+M9XjgBIJJycnuLq6KrWtXbsW27Ztg66uLry9vfHgwQOUlJQAAMaPH48TJ07A0dERHTt2RGRkJExMTGq0zS1btmDMmDG4ceMGPD09YWRkhN27d6Nv37549OhRjfchOjoaDg4OaNiwIf766y8MGDDghRe2n9agQQN07969WuvOmzcPCxcuxJ07d+Di4oJHjx7h4cOHL71/27dvR+PGjdG7d28EBQVVu2ZWuzigRCIgIAAffvihUlt8fDwAYO7cuQgJCcHVq1fRt29fpWU7d+7Evn37EB0dDWtr62pvLzs7G0uWLIGJiQnOnTuHY8eOISIiAkOGDEFKSgp27dpV431YsWIFTp48iaioKHz22WcoKyvDF198Ue3Xu7i4IDg4+IXrJSYmYuvWrTAwMMCpU6dw9uxZXL9+HU5OTi+9fwMHDsQvv/yCH374Af3796/hnrPawtegRMzPzw/Hjx/H/PnzkZ2djaCgINSrV09YduDAAQwZMgQzZ87EwIEDa9R3WFgYSktLYWVlhZ07dwrthYWFAPBSHxkwMDAQ/n/GjBlYt24doqKiKo1sXtWpU6cAAIMGDUKbNm0AAFpaWtDX1xfWqen+1fT9Y68HB5SIjRw5EiUlJQgODsbixYuxfv16bNu2De+88w7Wr18PExMThISEYNy4cVi7di327dsHe3v7avWdlZUFAEhLS8OmTZsqLX86bF6Gnp4e6tevjwcPHrzU6eLzZGZmAsBz97Wm+2dsbKzSGplq8CmeyI0dOxaRkZGYOHEiHj58iAkTJqCsrAwGBgZYs2YNLl++jLfffhtJSUmYN28eAEAq/d9hlcvlz+xXMRIbNGgQHjx4UOlr48aNr1T3o0ePkJeXB21tbZibm1erpupq1KgR8FRQVaW294+9HhxQIlZSUoKMjAzUq1cPy5Ytg4mJCR48eIC8vDxkZGSguLgYDg4OWLRoEQDg5s2bAAALCwsAQFRUlNDXoUOHlPru0qULAODEiRNKpzvR0dEoKip6qXoVryMirFq1CkSEt956C/r6+jA3NwcA3LhxQzjNio6ORkpKSrX7Ly0tBQC4u7sDAA4cOICEhARhm4rltbV/7PXjUzwR++WXXzBnzhx06tQJJSUlKCwsRPPmzWFpaYlJkybhzJkzaNeunfAJ7q5duwIAvLy8oK+vj7CwMHTu3BkAkJSUpNS3i4sLhg8fjr1798LPzw9ubm4oKytDUlISli5diokTJ9a43rlz52L37t24d+8eMjMzYWBgIIRno0aN0KpVK8THx8PLywuNGzdGZGQkysvLX9iv4vTr9OnTGD58OLy9vdGpUyeEh4ejR48ecHFxQX5+vtLHDGpj/9jrxyMoETM3N0ezZs1w4cIFJCQkoE+fPti7dy8AoHnz5tDV1cXJkydRWFiIsWPHYunSpQCAxo0bY8eOHXBxcUFaWhp0dHSwYsWKSv1v3LgRCxYsgL29PeLi4nDnzh107doVbm5uNa7V1dUVAwYMwM2bN/Ho0SP4+Pjg+PHjaN26tbDOjh070KVLFxQUFCArKwvTpk2r9LmsqgQEBMDU1BSZmZnCn7Hs2rULw4YNg7GxMW7fvo0WLVrAxsam1vaPqYfkeQu3bt262NXVdVGrVq1eX0WMsTohIiKi5J9//vls/Pjx3zxrHT7FY1V6/PgxRo0a9cL1Ro8eLXw2izFV44BiVZLJZAgLC3vher6+vq+lHlY3cUCxKik+w8SYOvFFcsaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDSmQmTpyIqVOnqrsMjfDbb7/B1tb2mU/xlMlksLKyQnR09GuvjVUPB5QaJCYmYvTo0XB2doaVlRW6dOki/BIlJCQozU5SE7Nnz8Zvv/2m1DZ69Gg0btwY1tbWaNOmDWbNmiWaqcFDQkIqPadq2bJlsLe3Fx5wN2HChGrP07dy5Uq8/fbbwvfR0dFwd3cXHjf8bzdu3IBMJoOzs/Mr7gmrLRxQr9n58+fh6+sLuVyOH3/8EWFhYR1dEa8AACAASURBVFi4cCGkUinkcjlSUlLg6OhY437v3buHHTt2oGXLlpW2N336dJw/fx7r1q3D77//Ljy7/N9U8bzwmti4cWOlqbL+/vtv9O/fHxEREdizZw+uXbuGdevWVau/Nm3aoFevXsL3UVFRaNu27TPXT0hIQNOmTWs8QUR1ngLKVIMD6jXKz8/Hxx9/jICAAOzcuRNdu3ZFq1at4O/vDwC4desWiouLce7cOXTs2BH29vZYvny58Pq0tDQEBgbCzs4O9vb26NmzJ5KTk5Geno527dpBKpXC29sb3t7eAIDbt28jLy8P7733HpydneHr6wtfX1/ExsYCFY9KmTZtGgYOHAh7e3vcuXMHcrkc69atQ+vWrdGkSRP06dNHmLF4586dePfddzF+/Hg4OzujWbNmWLVqFWbPno2mTZuiefPmOHjwIABg//798PX1xcyZM+Hs7IyWLVti5cqVwr507twZ//zzDxYsWAA7Ozvk5OSAiBAXFwdvb29YW1tDKpXi8ePHwoSmXl5e2LBhg9DHTz/9hKZNmwIApk6dig8++ADFxcXC8ujoaGFaKlSMmN5//33Y2tqiY8eO+PXXX5We6Llv3z507doV1tbWaNu2LUJDQ4GKCSAaNmwojNA6duyo4p8M9iwcUK/Rnj17UFpa+szJKRMSEiCVSmFtbY1Tp05hyZIlWLNmDe7fv4+cnBz07dsXjo6OSEhIwOnTpxEREQFtbW3Y2Nhg0qRJ8PX1xZ07d3DmzBkAQGRkJBo2bAgHBweUlJTgxIkTOHr0KHx8fCCXy5GUlITExER89913iI+Ph729PebPn4/Dhw/j4MGDSExMhKmpKWbPng1UXLMJDw9H9+7dce3aNbz77rtYu3YtOnTogKioKHTo0AFff/01AKCgoAC3bt1Cr169EBERgc8//xwrV64UpkNftmwZjI2NkZaWhtu3b8PCwgK3bt1CYWEhxo0bBwsLC/j4+GDEiBEYMWIESktLcfPmTaXH9cbFxQnhtX79etjY2EDx9Nd79+4hOztbCKj09HT07t0b9evXx5kzZ/D111/jzJkzwohz06ZN+PzzzzF37lwkJycjKCgIixcvBipOyYkIOTk5OH36NM6fP19rPyNMGT8P6jU6e/YsfH19hSmR/i0xMREuLi749NNPAQAdOnQAADx58gSrV69GkyZNsGTJEqBidNSgQQM0a9YMAHD16lVh0gSF6Oho3L9/H40aNUJ5eTnMzc0xbtw4zJw5E6mpqSgqKsLatWthZmYGAEhOTsa2bdtw/vx5NG/eHADQt29f4Rc1PT0dnTt3xogRIwAAlpaW8PT0xJAhQwAAbm5uuH//vrCut7c3/Pz8AABBQUFYtGgRkpOT0alTJ1y9ehUeHh5K14eio6NhamqKGzduID8/Hxs3bsS6devQr18/oOLU6unp4ePj44XAKvw/9u48Lqp6/x/4awZQiCUWQQFZBdnRRMTSm1tqZrmkWRqWckVNc7m53URUtFz6mqihqbl1M70uSYaoXUBSKy0ZZZmNVRYB2QUUh20+vz+aOT9GVgXkmO/n4+Gj5jNnzvmcWV7zOecMn3dlJXJzc7mASkhIgL6+Prcf27Ztg7W1Nfbu3QuBQAAnJyeYmZnBzc0N5eXl2Lx5M1asWIE333wTFRUVEIvFXHjJZDL06NEDmzdvhra2NrS16WPztNAI6ikqKiqChYVFs/fLZDKND2BqaiqMjIzQq1cvhIeHY+bMmdx96g84VOeO4uPj4ePjo7G++Ph4LFmyBAkJCUhOTkZKSgpWrVoFbW1tyGQymJqaaoxIYmJiYGZmptGHkpISrmSURCJBw/npJRKJxuOTk5M1PtQN11NTU4MHDx5wYSgSiRr1NykpCa6urhAKhTAxMcHatWuhp6eHP//8E1KpFD169ECvXr245aVSKbcNqVQKLS0tuLi4AKqw8/Dw4AIwNjYWb731FgSCv6bhr6ioQE5ODlxdXSESiVBVVYWvv/4aDg4OcHNzg1Kp5EaDMpkMr7zyCnR0dJp97UjnoIB6iiwsLBqVf2pILpc3GiG4u7ujvLwc5eXl3PkWqOq9qQMqOTkZlZWVGudboPrAu7m5wcrKiquV9+i6G6qoqOCKYqpFRERg9OjR3GOaO8R69Paj679w4QJ0dXW5Ud7Nmzc1Kr407K9aWVkZFAoFTExMIJfLNe7LyMhAUVER1x+JRAJHR0eu/PmjYVpWVgYTExPudlRUFLS1tbkrpgKBAImJibh16xZycnJw6NAhLpilUmmjiw/k6aCAeoqmTJmCy5cvY9OmTbh16xaioqK4wgR1dXVIT09vFFAeHh4wMjKCoaEhV/9uz549SExM5OrFFRUVAarDmvT0dDDGkJubi6KiIm5E8SiZTNYooLy9vZGamoq4uDgoFAps27YNd+7cwccff4zy8nLk5uZy/ausrER2djZ3u6qqCrdv34aHhwcqKiqQm5uLqqoqlJWVISIiAitWrMCnn34KY2Nj1NXVoaysDFKpFPn5+SgvLwdUAWVpaYn8/HxER0dj6tSpsLKywpgxY6BQKFBaWora2loUFhZiyZIl0NLS4k5yPxqIJSUlGlfb3N3dcebMGZSXlyMxMRHr1q2Do6MjdHR04OXlhe7duyM0NBRKpRJyuRwZGRktPlfk6aCAeoqmTZuGzZs3Izw8HOPHj8eKFSu4b+a0tDTU1NRofBDUASUUChEaGoovvvgCvr6+iI6Ohp+fHzca8/X1hZ+fH6ZPn4633noLUIWVQCBo9jc+Mpms0ahg3LhxmD9/PmbMmAE3NzfEx8cjMjISFhYWkEql0NbW5gJPLpcDALcOuVwOpVIJDw8PSKVSGBgYYNeuXXB3d8dnn32GoKAgLFy4EACgra2NwMBA7Nq1Cy+//DLS09NRWFiIgoICbNq0CT4+Pli9ejUGDhyIixcvwtDQEP7+/rh//z5cXV0xa9YsWFhYoE+fPtxPBB4d5cydOxcxMTH44YcfAABffvklqqqq4OnpiaCgIHh6enLLm5ubY8+ePTh16hQ8PDwQEBCAmpoaAEBxcTGKiopoBNVFqC4e6XCHDx/G8ePH8b///a+ru0J4rC118WgERTqcVCrlrp4R0h4UUKTDSaVS+vMR0iHoBx2kw0VGRnZ1F8jfBI2gCCG8RQFFCOEtCihCCG9RQBFCeIsCihDCWxRQhBDeooAihPAWBRQhhLcooAghvEUBRQjhLQooQghvUUARQniLAooQwlsUUIQQ3qKAIoTwFgUUIYS3KKAIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJbFFCEEN6igCKE8BYFFCGEtyigCCG8RQFFCOEtCihCCG9RQBFCeIsCihDCWxRQhBDeooAihPAWBRQhhLcooAghvEUBRQjhLQoo0qHKyspgamoKkUjU1V0hfwMUUDxUU1OD7du3w9fXF5aWlhgwYAC2bt2K2traNq9j5cqViIiI0GibMGECVq9e3Qk9/v8SEhKgra0NDw+PJu8vLi6Gp6cnwsPDO7UfAHD9+nXMnj2707dDOo92V3eAaKqvr4e/vz/EYjHWr18PV1dX3Lx5E0FBQQCAVatWtbqOvLw8HDhwAHPnztVoHzlyJGxtbTut7wCQmJgIV1dX6OrqNnm/oaEhxo4diz59+nRqPwDg+PHj0Namt/izjEZQPLNv3z5cuXIF4eHhmDZtGry9vTFr1ixMnz4dP/30EwBgxYoVCAgIwLvvvgs7Ozv4+voiMjISAJCbmwsfHx8IhUKMGDECI0aMAAD4+Phgw4YN0NfXBwAolUps374d3t7e6N27N9544w2kpKQAAKKiojBs2DCEhYXBw8MDNjY2GiOvrKws+Pv7w9bWFnZ2dhg9ejT32Pj4ePTv37/JfcvLy4OlpSUOHz4Me3t7AMDmzZvx0UcfYdGiRbCzs4OzszNOnz4NADhx4gRGjRqFZcuWwdnZGW5ubti6dSsAoKioCKampoiLi+PWv3DhQvj7+wMAli1bhqNHjyIyMhI2Njb46aefUFtbi5UrV8LJyQkODg7YsGEDoBqxDho0CPPnz+/gV5O0FwUUjzDGsHv3bkyfPh0uLi4a91lZWaG4uBhQfTjT09MRHByMW7duwc/PDx999BGqq6thbW2NBQsWYNSoUcjJyUFsbCwA4OTJkwAAd3d3AEBQUBDOnj2L06dPQy6Xw9jYGCtXrgRU4SWVSsEYw7Vr17BmzRrs3bsXJSUlKCoqwvjx49GnTx/IZDJER0dDJBJxI5XExET069evyf2zsrLCzp07YWtrCyMjIwBAVVUVYmJi8MYbb0AsFuPVV1/F9u3bAQAVFRW4ffs2xowZA5FIhFWrVmHr1q34448/IJFIIBQK4ebmxq1fIpHA09MTALBx40ZoaWnh3LlzyMnJwYQJE3DkyBGcP38eFy5cQFRUFMaMGQMAEAqFePHFF7k+Ef6ggOKRtLQ05Ofn46233mp0X3Z2Nnr27AmoRkmzZs2Cp6cnTE1NMWfOHNy/fx+5ubkAgLi4OPj4+Gg8Xi6Xw9DQEDY2NkhJScH+/fuxZ88e9O3bFwYGBhg/fjwkEgkAID09HV5eXli0aBGMjIzw0ksvAaoP8ubNm9G7d2+EhIRAX18f2dnZMDExgaOjIxcozQUUAMhkMi4kASAjIwPvvvsuxo0bB0NDQ3h4eEAoFHL7OWLECIwdOxZGRkaYNWsWDA0NkZKSAqlUCkdHR25EWF9fj5SUFO7cV3x8PLS0tLjAUi9TWVmJsrIyODk5YfDgwQAAbW1tREVF4Ysvvnji1450DgooHlGPkHr37q3RXltbi9jYWAwZMgSMMSQnJ2uchC4rKwMAmJiYQKlUIj4+vlFASaVSbrQRExMDMzMzjXWUlJSgR48e3LIN70tLS4O5uTmMjY0RHh6OmTNncvfFxcVxAZaUlAShUNjsCXL1uhsGlEQi0Vg+PT0dffv2BVRh1vC+mpoaPHjwAKampo3uS01NhUKh4AJJJBLBy8sL3bp145YJDAzEvHnzMHnyZAQGBkKhUDTbT8IPFFA8oh4hpaena7QfOnQIBQUFCAgIQFZWFu7fvw9XV1fu/gsXLmDgwIEwMTFBcnIyKisrG41iGgZDRUUFty21iIgIjB49GlCFxqOHTu7u7igvL0d5eTkcHBw0tq0OKLFYDEdHR+jp6TW7jw37UVlZiZycHI3AEovF3O1Hw+zChQvQ1dXFkCFDIJfLNfp448YNGBgYcOe2RCJRo+dAS0sLq1evxqVLl3D27Fn8/PPPzfaT8AMFFI84ODhg4MCBWLduHWJjYyESiRASEoLg4GBs2rQJzs7OkEql0NfXR0FBAfLz87Fr1y4cO3YMn332GaA6PwXV5f709HQwxoBHPuze3t5ITU1FXFwcFAoFtm3bhjt37uDjjz9GfX19oxGaOjSMjIxgaGiItLQ0AMCePXuQmJgIAwMDAEBpaSmgOpRqSkFBAYqLizUCSCgUcufb6urqkJycDHd3d1RUVCA3NxdVVVUoKytDREQEVqxYgU8//RTGxsZ4+PAhCgoKuH3dsmUL3N3dIRAIuOfh9u3buHv3LvLy8lBdXY3du3cjPz8feXl5UCqVXNAeOnQIgwcPRl5eXie8qqQ9KKB4RCAQ4PDhw3B2dsbs2bMxZcoUJCQk4MSJEwgICABUH2pzc3NMnToVPj4+uHDhAk6dOoVBgwYBAHx9feHn54fp06dz57IUCgUyMjK4YBg3bhzmz5+PGTNmwM3NDfHx8YiMjISFhQXS0tKgUCgaHYa5ublBKBQiNDQUX3zxBXx9fREdHQ0/Pz8kJycDAKZMmQIdHZ1mfwohlUrRrVs3ODk5cet1cnJC9+7dAQApKSmoqamBu7s7pFIpDAwMsGvXLri7u+Ozzz5DUFAQFi5cCABYtGgRzpw5A09PT+zYsQNWVlYaoRoQEIAbN27Ax8cHERERSE1NxdGjR+Hj44NVq1YhLCwM3t7eAID79++jpKTksX5nRp4OQUt37tu3b72Hh8e6hm9W0rX++c9/ws7ODmvXru3qrnSqw4cP4/jx4/jf//7X1V0hnUQkEikyMjJWzJs3L6y5ZWgE9YyRSqVwdnbu6m50OqlUyp0sJ88vCqhnSE1NDdLT05+bgHoe9pO0jP4O4BnSrVs3FBYWdnU3ngr1L+PJ841GUIQQ3qKAIoTwFgUUIYS3KKAIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJbFFCEEN6igCKE8BYFFCGEtyigCCG8RQFFCOEtCihCCG9RQBFCeIsCihDCWxRQhBDeooAihPAWBRQhhLcooAghvEUBRQjhLQooQghvUUARQniLAooQwlsUUIQQ3qKAIoTwFgVUF/j3v/+NadOmtbpceXk57t6926h9zpw5KC8v75C+ZGZmdsh6COkMFFBdICEhAf37929xmfz8fHzwwQfQ1dXVaI+Li0N4eDjEYnGH9EUkEmHHjh0dsi5COtpzGVCpqamYOnUq7OzsMGHCBKSmpj6V7SqVSiiVSkgkEvTr16/Z5RhjCAwMxJIlS2BsbKxxX3BwMBhjSEpK6pA+vfbaa9i5cydqa2s7ZH2EdKTnMqAWL16MS5cuobKyEr/++isWLlz4ROtZtmwZ3nnnHe52dnY2TE1NufAYNWoUlixZgsmTJ8POzg45OTlITU3F/fv3WxxBnT59GpWVlRg5cqRG+9mzZyGRSDBmzBiNEVRUVBSGDRuGsLAweHh4wMbGBqtXrwYADBw4ENu3b+eWrayshJ2dHY4cOQIAePHFF1FbWwuRSPREzwEhnem5DKj4+HiN2086GpFKpfD09ORuSyQS6OjowMXFBUqlEsnJyZDL5Th48CCkUins7OyQmJiIHj16wNrautn17ty5E/7+/hptNTU12LBhAxYsWIDBgwdr9FmpVEIqlYIxhmvXrmHNmjXYu3cvSkpK4ObmhrS0NG7Z77//HlpaWhrnwOrr65GVlfVEzwEhnem5DCg3NzeN2w4ODk+0HplM1iignJ2d0a1bN2RmZqKqqgpffvklTE1Noa+vD6jCsaXDO4lEAqlUiqFDh2q0HzhwAJWVlVi4cCH69OmD5ORk7rAsPT0dXl5eWLRoEYyMjPDSSy8BAIRCIVxdXbmAUiqV+Oabb/DBBx/ghRdeAABUVFSguroaNTU1T/QcENKZnsuACg4OxiuvvAJDQ0MMGjQIn3/++WOv486dO6ioqICHhwfXJpFIuMCSyWQwNTXVCDCoRmstBdTVq1ehr6+Pvn37cm1lZWXYtm0bli9fDkNDQzg5OaGmpgbJycmAaiTXsB9paWkwNzeHiYkJXF1duXNs//vf/5CdnY3AwEBuWfVVPEtLy8d+DgjpbM9lQI0YMQLnzp1DVlYWLl68iBEjRjz2OuRyOXR0dODs7AyoTmzHxcVxgSSVSuHu7t7ocWKxuMl2tYyMDFhbW0NLS4tr27ZtGyorK/H555/D3t4e48aNAxocmkokEo1RoUQi4bbh6uqK8vJyFBUVYd++fXjzzTc1Di//+OMPaGlpYcCAAY/9HBDS2bS7ugPPqocPH0KpVKKwsBCmpqYICQlBbm4uN5KRyWSNgqi2thYVFRWor69vdr11dXUwMjLibmdkZODgwYM4cOAAJk6cyLX369cPYrEY9fX1SE5O1hhBicViLij79u0LPT097NixA5cvX8aFCxc0tnft2jUMHz4cpqamHfCsENKxnssRVEcYOXIkfH194efnh1GjRnHtDQPq0XNdOjo6WLJkCVauXIm8vLwm12tpacmdHwKAkJAQ9OvXTyOcAKBPnz5ISkpCWloaFAqFRhg2HFHp6Ohg1qxZ+Prrr9G/f3/4+flxyz18+BAxMTFYvHhxu58PQjqDoKU79+3bt97Dw2NdS4ckpGPduHEDn3zyCa5evdph6ywpKYGnpyd27typcfXu4MGD+O2333Do0KEO2xYhbSUSiRQZGRkr5s2bF9bcMnSIxzO+vr4wMTFBWVkZTExM2rWu0tJSXLlyBXv27IG9vT0mT57M3ZeVlYWffvoJ3333XQf0mpDOQYd4PLRnzx4UFxe3ez1xcXH45JNPYGZmhhMnTkBHR4e7TywW49tvv9U430UI39AIiod69+7dIesZM2YMMjIymrxv/PjxHbINQjoTjaAIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJbFFCEEN6igCKE8BYFFCGEtyigCCG8RQFFCOEtCqhnWEREBGxsbKBUKru6K4R0Cgqodrp+/Tpmz57dJdtOTEyEl5cXhMK2vYwrV65EREREp/eLkI7yXAZUR9bFO378OLS1u+ZvrttSAFQtLy8PBw4caDSJHiF89lwGVEfWxTt69CgiIyNhY2ODn376CVBVBZ4/fz769OkDGxsb+Pv7o6KiAowx+Pr6Yu3atRg6dCisrKwwatQonDhxAsOHD4eVlRUmTpyIBw8eAAD+8Y9/YPXq1Rg5ciRsbGzw+uuvc4USoBpBNSzAkJWVBX9/f9ja2sLOzg6jR49GSkoKcnNz4ePjA6FQiBEjRmjMwf7f//4XQ4YMgaWlJfr3748ff/yxHc8sIR3ruQyojqqLt3HjRmhpaeHcuXPIycnBhAkTUFpaitdffx0KhQKxsbEQiUS4desWIiMjIRAIUF5eDpFIhOPHjyM2NhZSqRRHjx7FsWPHEB4ejqtXr+Ly5cuAKuiKi4tx9OhRXLlyBdXV1fj0008B1YiosLCQC6iioiKMHz8effr0gUwmQ3R0NEQiEbS1tWFtbY0FCxZg1KhRyMnJQWxsLABg9+7dWLVqFT799FOkpKRg1qxZWL9+fTufXUI6znMZUB1VFy8+Ph5aWloapaV2796NBw8eYPfu3bC1tUVqairKy8vh4uKChw8forS0FMHBwbCxsYGDgwPq6+uxbNkyWFlZcaMcPT09VFVVoaysDMuXL4eVlRUcHBwwdepUpKSkAKrDu4blqTZv3ozevXsjJCQE+vr6yM7OhomJCRwdHQHV5HU+Pj5cP8vLy7F582Z88sknePPNN8EYg1gspkNAwivPZUB1RF08/DWnMry8vNCtWzeu7ddff4VAIICLiwtsbGywePFihIaGYsCAAZDJZFAqlVyBg+TkZNTV1XGFFlJTU6FUKuHm5ga5XI7u3bujT58+3LrLysq46iuJiYnw8PCAUCgEYwzh4eGYOXMmt2xcXBxXwFOpVCI+Pl4joEQiEaqqqvD111/DwcEBbm5uUCqV+Oqrr57ouSCkMzyXM2o+eh7mSYlEoiaLcAYEBGDp0qVQKpVcRWGoauXZ2tpy0+xKJBL07NkT5ubm3G0zMzP06tUL0dHRcHFx4erjKZVKXLx4EWPGjOGWVQddeXk5ysvLNUaCFy5cwOjRowFVEFZWVjbqq0AgQGJiIqqqqmBkZNTmq4GEPC30jmyHoqIi3L59G3fv3uXKSA0cOBCnT59GamoqFAoFfvnlF275RysASySSZm/LZDLo6OiguLgYaWlpWLBgASoqKrBo0SJAValFXV/PyMgIhoaGXInzPXv2IDExEQYGBlw/oTosTE9PB2MMXl5e6N69O0JDQ6FUKiGXy5udHpiQrkIB1Q4BAQG4ceMGfHx8uN8XrVixAl5eXpgwYQJ8fX0RFRXFLf9oQD1a3LPh/VKpFNXV1Vzdverqapw/f56r9DJ37lzExMTghx9+gFAoRGhoKL744gv4+voiOjoafn5+3BU/df2+6dOn46233gIAmJubY8+ePTh16hQ8PDwQEBCAmpqap/TMEdI2VBePp1xdXbF7926NoqCE/J20pS4ejaB4qLi4GIWFhdwVOkKeVxRQPCSVSqGnp9dh5acIeVY9l1fx+O7VV19Fbm5uV3eDkC5HIyhCCG9RQBFCeIsCihDCWxRQhBDeooAihPAWBRQhhLcooAghvEUBRQjhLQooQghvUUARQniLAqqDpKSkgDHW1d1oN/WsnSKRCFBNlGdlZQVTU1OYmpqisLCw07b9559/ctsZPHhwmx7z0UcfYfHixZ3Wp2fRrFmzuOfx0KFDzbbdvn27i3vaOgqoDvDbb79hy5YtEAj+mr2mpqYG27dvh6+vLywtLTFgwABs3boVtbW1bVrf3bt34e/v3+jv8SZMmIDVq1d3yj6oJSQkQFtbm5uXKiMjAwqFAqdOnYJcLoeFhQVOnDjRbMHQrVu3Yvjw4a1u5z//+Q+2bNmi0SaTyaCvrw+ZTIaLFy9y7XK5HLNnz4azszN69eqFV155hdu2TCaDk5PTE+1rU30AgM8++wyHDx/WaFuzZg0OHDjwRNt52kJDQ/Hzzz8Dqml7mmsLCwvDH3/80YU9bR0FVDsVFBRg6dKl3Bu9vr4e/v7+OHDgAFasWIGff/4Zixcvxq5du7B9+/Y2rfPq1au4efMmrK2tNdpHjhyJgQMHdsp+qCUmJsLV1RW6urqAKgAEAgH8/PxgYWEBqKrguLm5NTlFcL9+/bhpiVuya9cuWFpaarTJZDK4uLigZ8+eMDY2BgBcuXIFo0aNglKpxJEjR3Dp0iWsXbsWQqEQSqUSqampGvO2P46m+qBUKnHixAnI5XKu7c6dOzh48CCqq6ufaDsd5eHDh21azsTEBCUlJUCDAiFNtY0cORKhoaGd1t+OQAHVTps2bcLo0aO5D+++fftw5coVhIeHY9q0afD29sasWbMwffp0rm5eS/XuTp8+jYULF6KkpAQ2NjbciMnHxwcbNmzg5jhXKpXYvn07vL290bt3b7zxxhtcxZeoqCgMGzYMYWFh8PDw0FgPWqifB1WlmobFQOVyOWxsbLjpgwFALBbD29u70XOxePFizJgxg/sg1dbWYuXKlXBycoKDgwM2bNgAAHj55ZeRkZGBNWvWwNbWlpuSWC6Xc9/uUM21PmfOHEyaNAnffvsthgwZAnd3d7z++uuA6hDl4cOHuHz5MgYNGgQ7Ozts2rSJe/yDBw+wevVquLi4wNraGU5QBQAAIABJREFUGr6+vtzMp8314fLly8jNzdWoP7hp0yZUV1drBFRztQ+b2+fff/8dI0aMgLW1NYYOHcoVi23ptTh69Cj8/PxgY2OD8ePHY9iwYaiqqgLaUM9QLpejV69e3AysTbX16tULV69ebfPIvitQQLVDQUEBTpw4wVVTYYxh9+7dmD59OlxcXDSWtbKyQnFxMdBKvbupU6fipZdewpo1a5CTk8N94E6ePAkA3BTBQUFBOHv2LE6fPg25XA5jY2OsXLkSUIWXVCoFYwzXrl3DmjVrsHfvXpSUlLRYPw9NFAOVyWQaoQFVQHl5eTV6Pnbs2AFra2uuj0eOHMH58+dx4cIFREVFcSOrzz//HAYGBsjKykJ2djZXNOLRbX3//feorq7G5s2bm3z+ZTIZhEIhLC0tERUVhZCQEGzbtg0lJSVgjOHDDz+EXC7HL7/8gvT0dNTW1uLevXst9uHYsWOwsbHhRlBSqRQ//PADevbsyQVUS7UPm9pnxhhmzZqFsWPHIikpCcuXL4ejo2OLr8X58+cRFBSEr776CqmpqdDS0oKrqyteeOGFNtUzbOp1e7RNqVTi4cOHnXpesb0ooNrhxx9/hIGBATdkTktLQ35+Pjfvd0PZ2dno2bNnq/XuamtrkZSUpFEiCqpvP0NDQ9jY2CAlJQX79+/Hnj170LdvXxgYGGD8+PGQSCQAgPT0dHh5eWHRokUwMjLiyk8JhcIW6+dVVFTg9u3bjQKqYa283NxclJaWNhlQlZWVyM3N5QKqvr4elZWVKCsrg5OTE3fiW10Sq+Ehojo8G27rl19+wahRo7gqOI+Sy+VwcXHBv/71L7z44ovw9fUFVOcAw8PD8eeff+LgwYOwtLREfX09cnNzMWDAgGb7UFFRgfPnz2P9+vUoLCxEWVkZQkJC8N5776Fv375cQLVU+7CpfWaMob6+HllZWdDV1cWkSZOgpaXV4msRHh6OKVOmYNCgQdDV1YWVlRWEQmGb6xnK5fJW29Sjxq4+dG0JBVQ7/Prrr9yHH6qpegE0mgmztrYWsbGxGDJkSKv17pKSklBbW9uoRJRUKuXeXDExMTAzM9MowFBSUoIePXpwyza8Ly0tDebm5jA2Nm6xfl5SUhKEQiH32NraWmRkZGh86yYlJUFLSwtNzVMvlUqhpaXFjR4DAwMxb948TJ48GYGBgVAoFICqXNejASyTyYAGJ3Ch+gCpD52bIpPJNPYzNTUVRkZGsLS0xJkzZ/Dmm29yhzO3bt2Crq4ut/6m+nDmzBmYm5tj0qRJsLS0xKFDh3D9+nUEBQVBR0eH+yC3VPuwqX0WCoU4c+YMkpOT4ePjg9jY2FZrGRoYGHDvJ5FIhLNnz2L8+PFtqmeoPjf36Gjp0bbMzEwIhUL07Nmz2ee4q1FAtUN6ejpsbW252+oXOj09XWO5Q4cOoaCgAAEBAZBKpU3Wu3vttdcA1ZvRyclJo54eVB9+dShUVFQ0elNFRERwdfAkEonGN6W6hl5z9fPUHwqxWAxHR0fo6ekBqmCrra1tFFDOzs7cSfSGJBIJHB0dufu0tLSwevVqXLp0CWfPnuWuIt28ebPROSyZTAZDQ0ONCwMWFhYa54IeJZfLNQKq4XOUlZUFe3t7jf309PTknvem+nDs2DG8//77EAgEcHd3x9atW7F06VJYWFhoBBRUFX1SU1Mhl8shEonwzjvvtLjP/fr1Q3R0NIYNG4agoKBWX4s1a9ZAV1cXgwcPxttvv41ly5Zx21DXM7x16xZycnJw6NAh7ssJqnNzCoVC43Vrqu3PP/+Eh4dHo/can1BAtUN9fT1efPFF7raDgwMGDhyIdevWcecmQkJCEBwcjE2bNsHZ2bnVenfFxcUoKSlBVlYWMjMzuXU3/PB5e3sjNTUVcXFxUCgU2LZtG+7cuYOPP/4Y9fX1SE5O1vjgisViuLu7t1o/r7S0lNsvNDjH07B4g1gs5g4z1f/Uv6dp2Mfq6mrs3r0b+fn5yMvLg1KphIODA+rq6lBWVgapVIr8/HyUl5dz23r0vN2UKVNw+fJlbNq0Cbdu3UJUVBQ+/PBDAEBdXR3S09MbBZT6trW1NbefN27cwOHDh7n9bKoPqampuHXrFmbMmAEA8PDwgKWlJT766CMAQLdu3biAaq72YXP7fOHCBfz2228oKSnBvXv34Ojo2OprYWZmBicnJ+Tm5uLgwYOYN28eALSpnqH6ymvDMHq0jTGG69ev4+233271fd6VKKDawdLSkhttQPXNdvjwYTg7O2P27NmYMmUKEhIScOLECQQEBABtqHc3efJk6OrqYtCgQQgJCQEAKBQKZGRkcB/+cePGYf78+ZgxYwbc3NwQHx+PyMhIWFhYIC0tDQqFQuMQTD2iaq1+3pQpU6Cjo4NVq1YBqhGKvb29xj6KxWJERUVh8ODB3L/58+dz+6YeuaWmpuLo0aPw8fHBqlWrEBYWBm9vb2hrayMwMBC7du3Cyy+/zI02mzpnMm3aNGzevBnh4eEYP348VqxYoXG+r6amptm6gsHBwZBKpejfvz9WrlyJsWPHcuf5murDsWPHMHLkSG4E5+HhgXXr1nGjQR0dHe4Qtbnah83t85UrV+Dv7w9fX1/o6uriyy+/bPW1AIDhw4dj7NixWLJkCXx9fVFZWdmmeoZyuRy9e/eGoaFhs21//PEHqqurucDnK6qL1w6hoaEoLCxs9ipTU56lenczZ84EYwxHjx7t9G05OjpixYoV3IiF/H95eXnw9PTE77//3ujKXFPmzJmDyspKnDhxotm22bNn4x//+Af3xdkVqC5eJ/vggw8glUrbvPyzVu9OJpOhd+/eKCgo4A77OkNeXh7u3buHnj17cieGn2dyuRxbtmyBXC5Heno6QkND4eLiAmdn5xYfV1FRgYKCAo2RbFNt58+fh4GBQZeGU1tRQLWDmZkZlixZ0ubln6V6dwqFApmZmdi/fz/c3Nxw//79TtuW+jdHc+bMwZQpUzptO8+K6upqXLlyBaNHj8Zbb72Furo6nD17ljvB35y5c+fCzc1N43C5qbby8nLs3LnzqexLe9EhHiGkS9AhHiHkmUYBRQjhLQooQghvUUARQniLAooQwlsUUIQQ3qKAIoTwFgUUIYS3KKAIIbxFAUUI4S0KqGdYREREs+Wf/q52796NcePGNXv/0KFDsWvXrqfaJ9J5KKDa6fr165g9e3aXbDsxMRFeXl5Nln9qysqVK7mqJnzS1lp6UM2w0Nxf9SsUCqSkpDSaLpk8u57LgEpNTcXUqVNhZ2eHCRMmcCWAnsTx48e5iihPW0JCgkaJqJbk5eXhwIEDjSaF60rqKVzaWksPqhkhmquDJ5FIUFdXRwH1N/JcBtTixYtx6dIlVFZW4tdff8XChQufaD3Lli3D0aNHERkZCRsbG67uXXM10xhj8PX1xdq1azF06FBYWVlh1KhROHHiBIYPHw4rKytMnDgRDx48AFqpn4cmSkQ1V2MtNzcXPj4+EAqFGDFiBEaMGME9prX6ao+qra2FnZ0dzp07x7XdvHkT5ubmuHXrVou16NauXYu33noLH330Edzc3PDf//63US29lvZDqVQiOTkZcXFx8PDwgLu7O77++mvucQkJCbC3t+eKfkI13e+kSZNgbW0NJycnbNy4EVBVp3n33Xdha2sLLy8vnD179oneA6RzPZcBFR8fr3E7KSnpidazceNGaGlp4dy5c8jJycGECRNarJkmEAhQXl4OkUiE48ePIzY2FlKpFEePHsWxY8cQHh6Oq1ev4vLly0Ar9fPy8vJQWFjIBVRLNdasra2xYMECjBo1Cjk5OYiNjQVU53Naq6/2KB0dHQwfPpzrI1TT63744Yfo379/i7XoZDIZ5HI5Fi5cCIlEgilTpjSqpdfSfqgLdXp7e+O3337Dp59+iqCgIFy7dg1QBVTDwP7zzz8xYcIEDB06FGKxGN9//z1CQ0ORk5ODoKAgbpm9e/dy5agIvzyXAfXoYU7DyhqPIz4+HlpaWvD09OTaWqqZ9vDhQ5SWliI4OBg2NjZwcHBAfX09li1bBisrK26Uo6en12r9vISEBOjr63Ozc7ZUYw2qkkYNyyy1tb5aU1577TUuoCIiIpCamoo1a9a0WotOJpNh2bJl8PT0hFAohK6ubqNaei3th1Qqhb6+PpYtWwZjY2PMnDkTzs7OXF8ePeQNDg7GP/7xDyxfvhwGBgYQiUQwMTFBz549UV9fj7t376K+vh5DhgyBjY3NE70HSOd6LgMqODgYr7zyCgwNDTFo0CB8/vnnT7QekUgELy8vdOvWjWtrqWaaTCaDUqnkPozJycmoq6vjJvpPTU2FUqnkZkBsqX5eYmIiPDw8IBQKW62xplQqER8frxFQbamv1pzRo0cjPT0dt2/fRkhICEJCQmBsbNxiLbry8nLk5eVh2LBhGutqWEuvtf1QF0VoeFGAMYa6ujrU1NRALpdzpaSqq6sRFxeHhIQE2NnZwc7ODj/99BNOnz6Nbt26ITQ0FI6OjvD19W3TPpOu0TVnd7vYo+dhnpRIJGryhGxAQACWLl0KpVKpUXNMKpXC1taWq5QrkUjQs2dPruy2RCKBmZkZevXqhejo6Cbr56lPJqtr3UE1Gmqqxpq6Tl5ycjIqKysb9VVdX62qqgpGRkZtvhrYq1cveHl5Ye7cubCwsMB7770HqM4dNayq3LAWnVQqhY6ODpycnDTW1bCW3r1791rcD7FYrLEPcXFxSE9Px4gRI5CamtqoygsAfPPNN+jfvz90dXU1vkh69OiBw4cP47vvvsOSJUswY8YMmJmZtWn/ydPzXI6gOkpRURFu376Nu3fvIi8vD2ihZhqaqPgrkUiavd1a/bySkhLuKlhrNdbUJa4TEhKQnp4Oxlib6qu1ZPTo0UhISMC2bdsgEPw1c3RLtejUPw/Q0dHRWE/DWnqt7YdIJMLdu3dRXl6Oq1evcqW9hgwZgpKSEqDBlcHu3bvDy8sLX3/9NSoqKlBUVIQbN24AqsA+efIkSkpKkJ+fDzMzM436hoQ/KKDaISAgADdu3ICPjw93paq5mmloIqBkMlmzdd1aq583d+5cxMTE4Icffmi1xpqvry/8/Pwwffp0boTTlvpqLRkzZgzmzp2r0f+WatE1rCrSUMP2lvZDIpFwZc29vLywYMEC+Pv7Y8+ePYDqi2H06NGYNm0at+7du3ejpKQEfn5+GDt2LFcINT4+Hhs2bEC/fv1w6dKlLv2pCGkZFU3gqWepfh4hT6ItRRPoa4OHurp+3j//+U/IZLIm79u5cyd8fX2fep/I84kCioe6un7ewYMHu2S7hDyKAoqHXn31VeTm5nZ1NwjpcnSSnBDCWxRQhBDeooAihPAWBRQhhLcooAghvEUBRQjhLQooQghvUUARQniLAooQwlsUUIQQ3qKA6iApKSlgjHV1N9pNPWunSCQCVBPlWVlZwdTUFKampigsLOz0Pvz555/c9gYPHtzp22tILpdj7dq1HbIumUzG7YeLiwugmkBP3RYQEAAAKCws5AplEE0UUB3gt99+w5YtW7iJ22pqarB9+3b4+vrC0tISAwYMwNatW1FbW9um9d29exf+/v6N/h5vwoQJWL16dafsg1pCQgK0tbW5eakyMjKgUChw6tQpyOVyWFhY4NChQ3BwcEDv3r0xePBgrF69GgUFBdw6iouL4enpifDw8Fa311RdQZlMBn19fchkMly8eLHFx//nP//Bli1bnnh/H7V27dpGRTWelLrww4QJE+Dq6goAmD59OmQyGXr16sW11dXVYdasWR2yzb8b+mPhdiooKMDSpUsRGRkJqGZ09Pf3h1gsxvr16+Hq6oqbN29yVURWrVrV6jqvXr2KmzdvwtraWqN95MiRsLW17aQ9+UtiYiJcXV2hq6sLqMJCIBDAz8+Pm9ny2rVr8PHxwdq1a5GSkoItW7bg7NmzuHr1KkxNTWFoaIixY8c2W7+uoaYmi5PJZHBxcUHPnj1bffyuXbu4WUabo1Qq2zSdcWxsLKKjozXKVrVHt27d0LNnT2RlZcHPzw8AYGBgAMYY7t69y03UZ2VlhYKCAty6dYubf538hUZQ7bRp0yaMHj0aFhYWwF+T/OHKlSsIDw/HtGnT4O3tjVmzZmH69Olc3byW6t2dPn0aCxcuRElJCWxsbLgRk4+PDzZs2MDNca5UKrF9+3Z4e3ujd+/eeOONN7jZK6OiojBs2DCEhYXBw8NDYz1ooe4cVLNNNqyMIpfLYWNjw4UTVHODDx06FN7e3pg6dSrOnj2L0tJSHDt2DHl5ebC0tMThw4dhb28PALh//z5WrlwJFxcXWFlZYdmyZUALdQXlcjk3uoCqFt/KlSvh5OQEBwcHbNiwAQDw8ssvIyMjA2vWrIGtrS03tfGoUaOwZMkSTJ48GXZ2dsjJyWn1dVQqlVi7di0mT56Me/fuaTxm8uTJ2Lp1KyZNmgQrKysMGjQIUqkUp06dgqWlpUbp+a1bt8LT0xN1dXXcelNSUjRmE5XL5cAj1YV69eqFmJiYVvv5vKGAaoeCggKcOHGCq0LCGMPu3bsxffp07pyDmpWVFYqLi4FW6t1NnToVL730EtasWYOcnBxs2rQJAHDy5EkA4KbYDQoKwtmzZ3H69GnI5XIYGxtj5cqVgOpDIZVKwRjDtWvXsGbNGuzduxclJSUt1p1DE8VAZTKZRlg8fPgQaWlp8PLy4trURTGzsrJgZWWFnTt3csUhlEolZsyYAZFIhBMnTkAul2PBggVAM3UFm9rmkSNHcP78eVy4cAFRUVFc4YjPP/8cBgYGyMrKQnZ2NszNzbninnK5HAcPHoRUKoWdnV2rr+X333+PO3fu4P/+7/+gp6enUSuxvLwcFy9exGeffYb4+HgolUocOXIEbm5uqK6u5sKspqYGhw8fxpw5c7jnMzMzEw8fPtTYH7lcDl1dXY3iEEqlEtnZ2a3283lDAdUOP/74IwwMDLhvwrS0NOTn52tUNlHLzs5Gz549W613V1tbi6SkJI0SUVC9qQ0NDWFjY4OUlBTs378fe/bsQd++fWFgYIDx48dDIpEAANLT0+Hl5YVFixbByMiIO2wQCoUt1p2rqKjA7du3GwVUw296iUSC+vp6jVqAUJ1cV1eraTjXemRkJG7duoVjx46hf//+MDIy4g79mqorqA7Rhtusr69HZWUlysrK4OTkxJ04V5ekanj4lpmZiaqqKnz55ZcwNTXVqKrTnAcPHmDz5s1YunQpTE1N4eDgoBFQGRkZ+Pe//w1PT09YWFjAzs4OQqEQzs7O0NLS4oo8nDlzBpWVlfjggw80Xjc8MlqSy+XcY9WKiopQXV3dal+fNxRQ7fDrr79qnDNQj5AenQmztrYWsbGxGDJkSKv17pKSklBbW9uoRFTD4gIxMTEwMzPTKMBQUlKCHj16cMs2vC8tLQ3m5uYwNjZuse5cUlIShEIh99ja2lpkZGRofPuLxWKYm5trnB+SSCTIy8vDwIEDue2rA+ry5cvw8/Nr8nxSU3UF1VMNN9xmYGAg5s2bh8mTJyMwMBAKhYJ7/KNBrr5y9miAtiQsLAxCoRBz584FADg5OUEsFgMAcnJyUFFR0ej57Nu3L7p37w4HBwekpqYCqsP7adOmca8lVGFkZWXFhbe6rWFgMcaQnZ0NS0vLNvf5eUEB1Q7p6ekaJ63VH8L09HSN5Q4dOoSCggIEBARAKpU2We/utddeA1QfOicnp0bf/A0/9BUVFY0+8BEREVz9OIlE0mjU4+7u3mz9PHVAicViODo6Qk9PD1B9EGtrazXCIjExUePw7uHDh1i2bBn69u3Lbb9hX+/fv8+t71FN1RWUyWQwNDTUuECgpaWF1atX49KlSzh79ix+/vlnAMDNmze5Qp1NPU9tkZ+fj7CwMJSVlcHNzQ329vb4+eefuRGUupqM+kunoqICOTk53DZcXV2RlpaG69evIyEhAfPmzdNY/6Pn05pqk8vlKC8vx6BBg9rc7+cFBVQ71NfXa9RTc3BwwMCBA7Fu3TrExsZCJBIhJCQEwcHB2LRpE5ydnVutd1dcXIySkhJkZWVxZZLwyAfP29sbqampiIuLg0KhwLZt23Dnzh18/PHHqK+vR3JyssY3vlgshru7e6t150pLS7n9gioshEKhRvEGsViMHj16QCKR4NSpUxg9ejRyc3Px3XffQVtbGwUFBSguLub6OmDAAMTExCA6Ohp3797F6dOnuXU1VVdQfQVPrbq6Grt370Z+fj7y8vKgVCrh4OCAuro6lJWVQSqVIj8/H+Xl5dzjGwZUXl4eXFxccPTo0SZfw02bNsHe3h45OTnIzMxEZmYmvvzyS2RnZ6O8vFyjQKp6/9HgkM3b2xtXr17F9u3bMXz48EZh9Ogh8r1795Cfn6/Rdu3aNRgbG3dIMdm/GwqodrC0tNQYHQgEAhw+fBjOzs5cUcmEhAScOHGC+1Fea/XuJk+eDF1dXQwaNAghISEAAIVCgYyMDO6DMm7cOMyfPx8zZsyAm5sb4uPjERkZCQsLC6SlpUGhUGh8qNQjqtbq502ZMgU6OjrcTyHkcjns7e25fVSffD958iRGjx6NHTt24I033sDVq1fh7OzM7V+3bt24CsKzZ8/Ge++9h/nz52PQoEH48ccfuX41VVfw0cOf1NRUHD16FD4+Pli1ahXCwsLg7e0NbW1tBAYGYteuXXj55Ze5UeujgWBmZgZLS0tkZWU1ev0kEgmOHz+OkJAQjfNY6sNvsVjcZEBZW1tzX0xTp05FSUkJoqOjMX/+fI3119fXIy0trdUreBEREZg7d26zI83nGdXFa4fQ0FAUFhZi8+bNbX7Ms1TvbubMmWCMNTv66AyOjo5YsWIFPvroow5ZX21tLSZPnozQ0FAuRDvamjVrcPHiRdy4cYP7sS5U4ern54fo6GgMGDAAUF2RXLt2LbKysiAQCCCTyfD+++/j6tWrbTqh/3fSlrp4NIJqhw8++ABSqbTNy3d1vbvHJZPJ0Lt3bxQUFHCHfZ0pLy8P9+7dQ8+ePbkLDu21bds2rF69ulPC6caNG9i2bRv279+PVatWceGkVCpRUFDABZaLiwsUCgUKCgoQHx8PFxcXCAQCKBQKrF+/Ht9+++1zF05tRb8kbwczMzMsWbKkzct3db27x6FQKJCZmYn9+/dj//79uH37tsb5ts6gPvyZM2cOvLy8cPny5XavU/37ss6wdu1aFBcXY+PGjXjnnXe49oSEBG6EbG9vD319fYSFhXF/4+fv7w+oDjFDQkIanbci/x8d4hFCugQd4hFCnmkUUIQQ3qKAIoTwFgUUIYS3KKAIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJbFFCEEN6igCKE8BYFFCGEtyigCCG8RQFFCOEtCihCCG9RQBFCeIsCihDCWxRQhBDeooAihPAWBRQhhLcooAghvEUBRQjhLQooQghvUUARQniLAooQwlsUUIQQ3qKAIoTwFgUUIYS3KKAIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJb2q0tcOfOnZqKioqap9Md8owTqP7Lurgf5BlQWlraav60uIBAIPixrKwss6ysrEM7Rv6e7t69+66WllaFubn5ha7uC3k2CIXC613dB/KcCAwM/L/AwMDlXd0P8vdB56AIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJbFFCEEN6igCIdhjFWJxAI6ru6H+TvgwKKdBiBQKDNGNPq6n6Qvw8KKEIIb1FAkY5UXFdXV9HVnSB/H63+sR4hj6GHtrY2nYMiHYZGUIQQ3qKAIoTwFgUU6UjFjDE6B0U6DJ2DIh2pB/0OinQkGkERQniLAooQwlsUUIQQ3qKAIh1GIBBUAKjq6n6Qvw86SU46DGPMCMDDru4H+fugERQhhLcooAghvEUBRQjhLUEbliENMMaGA4jt6n6QZ9InAoEgtKs78SyhERQhhLcooAghvEUBRQjhLQooQghvUUA9ZyoqKnDr1q2u7gYhbUIB9Zzx9vbGwYMHu7obhLQJBdRTxBjr6i5AoVB0dReeSampqV3dBUJaxxgbHhoaygCwxYsXM0tLS6anp8dGjBjB4uLimNqpU6cYAPbjjz+yIUOGMB0dHbZmzRrGGGP5+fls+vTp7MUXX2QvvPACGzNmDEtKSuIeO3HiRLZq1Sq2aNEiZmRkxAwNDdmkSZPYL7/8wl577TWmp6fHHBwc2Hfffcc9pi19srOzYwC4f3Z2duxx3bx5k126dOmxHnPr1i1maGjIzp07x7y9vZmOjg7r06cPO3ToENu0aROzsbFhhoaGbOLEiaywsFDjsXv27GFOTk5MV1eXubq6sg0bNrCHDx8yxhh78OAB+/DDD5mpqSkzNTVlEydOZJmZmYwxxiIjI5mnpyfT09Nj7u7u7KuvvmKMMaZQKNjq1auZg4MD09bWZjY2NiwoKIjV1dVx28zLy2NTp05lxsbGzMLCgr3//vuse/fuTCwWc8vExsYyPz8/pqury2xtbdns2bNZXl5ea/36V1e/f8nfXMOAmjdvHrt+/Tr74YcfmKenJzM0NGS3b99mrEFAWVtbsyNHjrBLly6xO3fusKqqKubm5sYsLCzYvn372Hfffcc8PT1Zjx49WFlZGWOqgALAFi1axEQiEdu4cSMDwHR0dFhYWBj7888/2dtvv820tLSYXC5nrEFAtdSnGzduMFNTU/b222+zq1evshs3bjx2QF25coXp6emxYcOGsV9++aXNAQWA2drasnPnzrGYmBjm6enJALChQ4ey3377jR0/fpwZGBgwf39/7nHr169nhoaGLCgoiB07doytXbuWGRoaspkzZzLGGFuzZg0TCARsw4YN7MCBA2zo0KGsuLiYVVZWMj09PTZw4EB29OhRtmrVKvbpp58yxhirq6tjvr6+bMmSJWzXrl1s9uzZDADbtm0bd/+AAQOYtbU1+/7779mXX34e8jpDAAAgAElEQVTJdHR02NixY7l+RUdHMx0dHRYQEMCOHj3Kdu7cyRwdHZmrqyt78OBBs/2igCKdrmFAVVZWcm/arKwspqOjwz755BONgNqyZYvGh3Xfvn0MAIuJieHaMjMzmVAoZCEhIYypAsrd3V3jcXZ2dmzq1Knc7ezsbAaA7d27l7EGAdVSnxhjrGfPnmzhwoVtCpbmFBYWsqCgIGZiYsKGDx/OLl++3OLy6oA6efIk13b48GEGQGNUEhAQwHr16sUYYyw3N5fp6Oiw06dPa6xr7969DAArLS1l/v7+zMDAgNXU1Ggsk5aWxgCwTZs2NdkfpVKpcfvVV19lr7zyCmOMsd9++61RXwMDA5mWlhZTKBSMMcbc3d3Zxx9/rLEOuVzOALAzZ8402y8KqMdH56A6iK2tLdzc3PDHH39otI8aNUrj9i+//AJjY2OMHDmSa7Ozs4Orqyvi4uK4Nj09PY3H6erqonv37tzt3r17AwCKi4sfu09tlZmZyf178OAB125ubo7PPvsM2dnZGDVqFEaMGIFvvvmm1fU13CddXV0AaLRP6v2JiopCbW0t3n//fejq6nL/Fi1aBAC4c+cO3n//fVRVVWHcuHFISkri1uPo6IhXXnkFn3/+Ob766itUV1dr9KOwsBALFiyAs7MzzMzMIBaLcffuXQBATk4OAMDJyYlb3tnZGfX19aisrERWVhakUin27dun0a9+/fq12i/y+CigOpCJiQkqKys12gwMDDRul5eXw9zcvNFjTU1NkZub2+ZtCQR//Rllayfem+pTWzk4OHD/IiIiNO6rqKhAWFgYwsLCMHz4cAwZMuSJttGQQCDg9kcdGOfOnUN8fDz3LzExETKZDG5ubnj99dcRGRmJu3fvol+/fggMDERtbS0EAgEuXLiADz/8EMuXL0ffvn1x5coVAEBBQQEGDBiAmJgYbNy4ERcvXoSPjw/q6/+q9aAOpl9//ZXr1x9//AFra2v06NGD69f69es1+hUfHw+ZTIYPP/yw2X6Rx0cT1nWgO3fuwNXVtcVlevfujevXrzdqLygogK2t7VPpU1uvJoaHh3P/7+vrCwC4d+8etm3bht27d8Pb2xsnTpzAsGHDOrjXfwWrWkvP6euvv44xY8Zg586d+OSTT2Bvb4+goCAYGRlh9+7dWL58OSZOnIiJEyciJycHe/fuRUFBAa5du8Y937a2tkhJSQEA+Pj4YOzYsVi5ciUyMzNRVFSEs2fP4vjx4xr9qqqqeqJ+kcdDI6gOcvnyZaSnp+OVV15pcbmXX34ZpaWlGoddiYmJSE1NxdChQzu9T/r6+sjLy2vT4ydNmsT9s7a2BgBER0cjJiYGJ0+exOXLlzslnABg5MiREAqF+OqrrzTaGx5qqg/dhEIh/vWvf8Ha2ho3b94EGvycwsHBAYsXL8a9e/dw+/ZtFBcXw9zcXOPLoLi4GEqlkru9a9cuODs7IyUlBebm5rh27RqmTp0KqA737OzscOjQIY2+1NXVoaamptV+kcdDI6h2mDdvHkaPHo309HTs3LkTvXr14s6RNMff3x+bN2/GO++8g+DgYGhpaWHjxo2wsLDAggULOr1Pr776Ko4dO4YtW7bA1NQUL7/8Mry8vNq8/jfeeIP7sHYmJycnLF68GDt27MCECRMwadIk5OfnIywsDOfPn8dLL72EXbt24ezZs5g5cyby8vKQm5uLgQMHoqamBi4uLnj33Xfh4eGBPXv2wNjYGH369MGIESMQFhaG4OBgDBkyBD/88APOnz8PpVKJkpISvPjiixg0aBCWL18OJycnCAQClJaWoqKiAkZGRhAIBAgNDcWUKVMwePBgfPTRR6irq8N//vMf+Pv7Y+nSpc32i5BO1/Aq3jvvvMN69OjBDAwM2Pjx47lL/qzBVTyZTNboKlJmZiZ7++23maGhIXvhhRfY66+/rrHcxIkTmY+Pj8ZjXFxc2Pvvv6/RBoBt3LiRsQZX8VrqE2OMFRQUsLFjx7IXXniB2dvbszNnzjR5pasjqa/iRUREcG3Hjx9nAFhqairXtm7dOqalpcXdViqVbNu2bcze3p7p6OgwW1tbtmDBAlZQUMAYY+yHH35gAwcOZC+88AKztLRkS5YsYTU1Nay0tJTNnj2bWVpashdeeIH5+fmxq1evcusNDg5mpqamzMTEhH3wwQdMJBIxDw8Ptm7dOsYYY++88w7r1q2bxm/GTExMmEQi4dYRGRnJfHx8WLdu3ViPHj3Y22+/zW7evNliv+gqHul0zf3MoKvxsU/PqoY/2lQqlSw9PZ3p6+uz4ODg9q6aAuox0SEeIQ0oFAr4+fnB1tYWr776KnR1dXHlyhU8ePAA/fv37+ruPXcooAhpQCAQYObMmTh+/DjWrl2L7t27w8vLCydPnsTbb7/d1d177tCc5I+J5iQn7UBzkj8m+pkBIYS3KKAIIbxFAUUI4S0KKEIIb1FAEUJ4iwKKEMJbFFCEEN6igCKE8BYFFCGEtyigCCG8RQH1N/T7779DIBBAIBDAzc2tTY/54IMPMGfOnE7v27Nk6tSp3PP49ddfd3V3nksUUF0oJycHAoGgyaIGP//8M2xsbJCent7iOn799VdMmzZNo00sFkNfXx/5+fn4/fffufaSkhIsXboU9vb26NatGywtLSEWi7nH9O3b94n245tvvsG6desatUdFReG9997TaIuIiMA777zzRNt52vbv349r164BADw8PLq6O88lms2gC8XHx0MoFDY5o6WDgwPGjx8PMzOzFtfx7bffQltb82UUi8Vwd3dHr169uLbc3FwMGzYM+vr62LFjB5ydnSGXy+Hs7AylUgm5XP7EAfXFF19gxYoVjdqPHDkCiUTC3VYqlVi9ejXs7e2faDsd5eHDh42q5jTF1NQURUVFAABPT8+n0DNC2okxNry9s5apbdiwgbm5uTVq/+677xgAblbNmpoatnDhQmZmZsaMjY3Zv//9b8YYY/Pnz2cCgYDp6uoyfX19robcyJEj2axZszTW+dprrzFPT09WUVHRaHspKSkMAFu4cCHr27cvMzIy4qogs//H3n1HRXG2bQC/dum9I1IVKVItKGgsCaiYaOwlUTEWBFNs76cxxpqIscYW9dVYSWxBTaKxxZrYlRJRlm4BEekgTfre3x+Bed2IJkZwB71/53iOOzP7zD2zsxfPzO7OQ0QlJSU0depUMjc3Jy0tLXJ0dKQff/yRiIhcXFwIAOno6JCurq5wt8vCwkLS0tIidXV1qqqqIiKi7du3EwDq1auX0HZ6ejoFBASQsbEx6ejo0IABA6iwsJCIiDZu3Eh2dnakra1NvXr1oqqqKjp37hy1b9+etLS0yMPDQ7hj6J07d2jAgAGkq6tLenp65O3tLdyldNu2beTs7Ew6OjrUrVs3cnJyotLSUiIiunLlCvn5+ZGWlhaZmJgIA3zWWbJkCTVv3vxfvLr14hvWscbVkAE1ePBgGjFixBPT5XI5BQQECCGzbt06sra2poSEBEpMTBRuX1taWkqqqqoUHh6u8Hxzc3NasWKF8DgqKooA0G+//VZvHT/99BNJpVJavHgxFRQUCINj5uTkkFwuJ39/f+rZsyelp6dTWVkZtWjRgrZs2UJERCdOnCBdXV2qqalRaPPbb78lS0tLUlNTo/j4eCorKyMbGxuytrambt26ERFRbm4u2dnZ0ZAhQ+ju3buUmZlJlpaWFBoaSjExMQSAjh07RllZWXTw4EGSy+VkZmZG8+fPp9zcXAoLC6Pq6mrKysoiKysr+vTTT6mkpEQYRDM5OZkOHjxI+vr6dOnSJSorK6O33nqLBg0aRFQ7SKeGhgaFhIRQXl4eXbx4kQAIw6cTEY0aNYp69uz5r1/jv+CAek58DUqJoqOj0a5duyemSyQSxMTECKd+NTU1KCwsRF5eHpycnITRXyIjI6GioiIMGonaEUqys7MVTklOnz4Nc3NzvPXWW/XWERsbC1dXV3z++ecwNDRE586dAQCVlZUICwvD5cuXERYWBktLS9TU1CAtLQ3e3t4AgKtXr6Jjx46QShUPpdDQUIwbNw7Ozs6Ii4vDunXroKOjg3HjxgmjnqxcuRIlJSX47rvv0KJFCyQkJODhw4dwdXVFdXU1AODOnTswMzPDgAEDQESoqanB3bt3oaWlheHDh0NFRQXz58+HnZ0dli9fDh0dHdy9exfGxsZwcHBAWFgYRowYgTfeeAOampqwtrYWap0xYwb8/Pwwd+5c6OnpITw8HMbGxmjevLnCvuHTO+XhgFKS4uJi3L17t97byFZXVyMhIUEIqEmTJmHq1Kno2bMnRo4cKQypdO3aNbRr1w7q6urCc+suej9+UTcrKwvNmjV7ai0ymQyenp7C44SEBBgYGMDS0hI//PADBg8eDGNjYwBAREQENDU1hfavXbsGHx8fhfYSExNx9epVjB8/Hp6enrh06RKWLFmClStXQltbW6j/999/h0Qigbm5OXR1dREYGIjNmzejY8eOaNu2Lfbu3YuvvvoKHTp0QGpqKqRSKU6dOoW4uDi0atUKp06dAhEhLCxM4RPIutAEAD09PWRnZwMAwsPDsX//fgwaNAgVFRW4evUqoqKioK+vD319fRw4cAAnTpwQ9mfdtTkOKNZkNNQp3vnz5wkAZWdnPzFPJpMRAMrIyFCYHhcXR6qqqrR//34iIhoyZAh9/PHHCsusW7eO9PX1FaYtX76c9PT0hOsuf+Xu7k5Lly4VHs+dO5e6du1KRESenp705ZdfCvOmTZtGXbp0ER6bmprSvn37FNqbNWsW+fn5ERHR0qVLSVVVlfz9/YmI6OuvvyZnZ2ciIurcuTPNmzePHj16RCUlJfXWVlRURK1bt6ZPPvlEmFZTU0MBAQHk5uZG+fn5BIDOnTsnzG/Xrh3NmTOHiIhycnJo5MiR1Lp1a9LT0xNGwSkvLyeJREJnzpyhwsJCqqioeGLdddfmrly5Um9t/wKf4j0n7kEpSXR0NExNTZGXl4eEhAThX1VVFWJiYmBqagoLCwtUVFRg5cqVePDgAe7fvw+5XI5WrVoBALKzs3Hr1i1kZGQIw6bXfYL3uEGDBqGyshIjR47ExYsXcf78eUybNg2RkZGorq5GUlKSQg8qJiZGeGxjY4PExEQAwJUrV7Bp0ybo6ekBtT29/Px83Lx5Ew8ePMDDhw8hl8uxc+dOoUfj6ekJIsLKlSsBAOrq6kIPqlOnTtizZw8SEhJQVlaG06dPCzVs3LgRCQkJyMzMxKNHj+Dg4IBffvkF586dQ25uLgoKCuDg4AADAwPo6ekJNa5evRrXr18XajQ1NYWzszPS0tIQFhaGqVOnAgA0NDTQtm1brF69Gg8fPkR2dvYTIz7LZDJIJBL+igFrOhqqBxUYGKgw7hoAkkql9OjRI5o9ezb5+voSEVF0dDS5urqSpqYmOTk50XfffSe0sWfPHtLT0yMtLS1au3YtERF17dqVJkyY8MT6Tp06RR07diRtbW1q1qwZjRw5kgoKCig2NpYA0P3794Vl7e3tadOmTUREdOPGDfLw8KAWLVpQ+/btadiwYWRnZycsO2XKFFJXVycDAwMKDw+n48ePk7GxMZWXlxMR0f3792nixInC8ps2baJmzZoREVF+fj4NGTKEDAwMyMjIiKZNm0ZUe/H/rbfeEsaV+/TTT6m6upqmTJlChoaGZGBgQEOGDBF6mHv37iVra2tydHSknj17UpcuXeiDDz4Q1nnp0iV6//33ydLSkpo1ayZ8knnjxg3y8fEhLS0tsrKyol27dinss5CQEIVtbQDcg2KNqyE/xWsMRkZGtHr1amWXIUr3798nAAoDcD7L+++/T3369GnIEjignhOf4r1C0tPTUVBQAAsLC+ELhq+z2NhYLFiwAHFxcUhOTsbixYvh4uICZ2fnZz6vqKgImZmZiImJ4QvkSsYB9Qqp+9b2iBEj4O/vr+xylK6iogJnz56Ft7c33nzzTVRXV+O3336DiorKM583cuRING/enL9iIAI8Lt5z4nHx2AvgcfGeE/egGGOixQHFGBMtvpvB8ysHUKDsIsSosrJSSyqVylVVVSuUXYtIFSu7AMZeW0FBQSuCgoJmKLsO9urgUzzGmGhxQLGG9AgAn96xBsMBxRqSNgANZRfBXh0cUIwx0eKAYoyJFgcUa0i5RFSk7CLYq4O/B8UakqlEIqlRdhHs1cE9KMaYaHFAMcZEiwOKNZja60+PlF0He3XwNSjWYCQSiT6AMmXXwV4d3INijIkWBxRrMESUJ5FI+GsGrMHwKR5rMBKJxISIqpVdB3t1cA+KMSZaHFCMMdHiQRPYCwkKCsqSSCTm9c0jovQtW7ZYv/yq2KuCe1DshRDR8fqmy+VyArDv5VfEXiUcUOyFVFVVrZDL5Wl/nS6RSFLLyspWKKcq9qrggGIv5LvvvouVSqVnH59GRCSXy3/atWtXhvIqY68CDij2wohoBRHde2xSSlVV1SollsReERxQ7IVt2bIlloh+R23vCcDP33//fbqy62JNHwcUaxB1vSiJRJJaUVHBvSfWIBrkawYbN24crqmpObwh2mJN18OHD99QUVEp19PT+0PZtTDlISKqrq7eHhwcXO8nvM+jQX7qoqam1snc3HxI8+bNG6I51vS1VHYBTHnu3bsnz8rKigAgjoACAGNjY7Ro0aKhmmOMNVGFhYXyrKysBmmLr0ExxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQTFQKCgpw5MgRZZfBRIIDiolGeno6XF1dsXz5cmWXwkSCA4o9t6qqKty8ebPB262oqEBFRUWDt8uaLg6o11x8fDz8/f1hZ2cHS0tL+Pr64tChQwrL7NmzB126dIGlpSXatWuHQYMGoU+fPoiIiAAAVFdXY8WKFWjbti0sLCzQvn17rFixAtXV1UIbLVq0wLBhwzBjxgy4ubmhZcuWeP/995GamgrU9p46dOgAAJDJZDA2NoaxsTHS03mA4tdZgw07xZomfX19pKamwsPDA6Wlpbh58yYCAwNha2uLdu3aYefOnZg6dSo0NDTg7e2N+Ph4XL58Ga6urnB3dwcRYfz48Thy5AjMzMzQoUMHJCQkYMmSJUhOTsbmzZuFdZ05cwaGhoZ49913kZycjJMnTyI1NRUXLlyAtrY2/P39cfLkSRgYGMDPzw8AoK2trcS9w5SNA+o1Z2VlhYSEBEgkfw4yvXHjRsyZMwcHDx5Eu3btsGfPHgDAjh078PbbbyMrKwtt2rRBcnIypFIpjh8/jiNHjsDT0xPHjh2DtrY2iouL0aNHDxw4cACTJ0+Gh4eHsL7Tp0/D3t4eAODn54fo6GhERkaiU6dOWLx4MU6ePAkbGxts27ZNSXuEiQkH1GuurKwMW7duxb59+3Dv3j0QEQAIp15yuRwAIJX+eTVAU1MTRITq6mpUV1fj+PE/B4/V1dXFkiVLhHa1tLQAAH/88YdCQNna2gr/b9u2LaKjo5GSkoJOnTq9lO1lTQsH1Gtu7NixOHXqFGxtbTFgwADk5OTgxIkTKC0tBQAEBwcjIiICEyZMQNeuXREXF4eqqir4+flBR0cHmZmZAIDLly/j8uXLT7Svqan51HXXzauqqmq07WNNGwfUaywlJQWnTp2CpaUlLl++DG1tbVy9ehUnTpwQelKDBw9GaGgoLl26hPPnz0NDQwPDhg3DV199BdRewwKAVatWYezYsQ1SV12vjTH+FO81VlJSAgAwNzcXLkaHh4cDAGpqagAAe/fuxaVLlxAcHIz79+/j9u3b+Pbbb2FqagoA6NKlCwDg22+/RW5urtD2tWvXnrsePT09AMD9+/dRVlYGAKisrHzBrWRNGfegXmMODg4wMzNDdHQ0+vfvD3V1dfz+++8AgFu3boGIhI/5ExMTsWjRIqSmpkJXVxd9+vRBr1698P7772PLli1ITExE+/bt0bp1a+Tm5iIlJQW///47PD09/3E9ZmZmaNmyJe7evQtvb28YGBhg4sSJGD16dKPtAyZu3IN6jWlqamLXrl3o0KEDoqKicOfOHaxevRrDhg1DcXEx4uPjMWLECLRp0wYXL17EqlWr8OOPP+K7777De++9hzNnzkBbWxtHjhzBBx98AG1tbVy/fh2PHj3C4MGDYWBg8Nw1bdmyBZ6ensjJyUFGRgZMTEwaZdtZ0yBpiEa2bt26ys3N7T/Ozs4N0RwTmePHj6Nr167Q09ODXC7HvHnzsHHjRsycOROzZs1SdnlMZG7cuFGdlJQ0Z+LEiS/8myU+xWPPtHnzZsyaNQtqamqwsrJCZWUlHjx4AKlUirfeekvZ5bFXHJ/isWfq0aMHPvjgAzRr1gzp6emorq5Gnz59cPjwYf7uEmt03INiz9SqVSusWbNG2WWw1xT3oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKPZUO3bswLFjx5RdBnuNcUCxehUXF2PZsmWIiYl5Kev7/vvvsXTp0peyLtZ0cECxeq1duxbZ2dmQyWTPXK7u1rwv6ptvvkHz5s0bpC326uCAYk9IT0/Hxo0bMWjQoCd6UOHh4Xj77bdha2sLHx8f9OjRA3/88QcAICIiAgMHDoSVlRUcHBwQEhICAMjNzYW7uzu+++47dO7cGZaWlujfv78wckznzp1x584dzJ07F7a2tsjJyVHCVjMx4oBiTwgJCUG7du3w4Ycf4t69eygsLARqg2vYsGEYPnw4bt++jX79+iEzMxPt27dHeHg4+vfvj65du0Imk2H37t1YvXo10tLSoKmpiQcPHuDKlSv46aefcPz4cVy6dAmnT58GAHz11VfQ1dVFamoq7t27BzMzMyXvASYWfD8opiA6OhoHDhzAr7/+CgcHBwCATCZDly5dcPr0aVhYWGD8+PEAADs7O2FAz3nz5qFbt26YMWMGqqqqEBUVBSMjIzRr1kwYuXjFihXQ09ODhYUF1NTUhOdGRkaiXbt2wmPG6nBAMQXz589H37590aFDBwCAsbExYmJi0KVLF+jq6qK4uBgVFRUoKirC+vXr0bdvX1RUVCAyMhKmpqaws7NDVVUVPD09ceDAAairqyM2Nha2trbCsFJpaWmorKyEk5MTACAqKgpeXl5K3W4mThxQTHDs2DFcunQJOjo6aNGiBQCgtLRUuFA+aNAgxMXFwd/fH3fu3IG/vz8WL14sPH/Lli1o27YtNDU1oa6uLkyPjY2Fq6ur8Fgmk0FDQwOtWrUCaodHHzFixEvcUtZUcJ+aAQCqq6vxxRdfIDAwEPfu3UNKSgpSUlIwfPhw4UK5VCpFt27dkJiYiM8//xyLFy+Gjo4ONDQ04OHhgY0bN6KoqAg5OTmIiIgQ2o6Li4Obm5vwWCaTwcnJCaqqqqiurkZBQQHi4uKQkZEhXO9iDBxQrM727duRlZWFmTNnKky3t7dHYmIiqqqqAABOTk4YNWoUdu3aBQ8PD2Ek4g0bNiAvLw8+Pj7o3bs3UlJShDb+2oN6/LGqqiqCgoLwzTffoHPnzrh9+/ZL2mLWFPC4eOxf69ixIz788EMEBgYquxQmIg05Lh73oNg/Ul5ejjlz5iAiIgLp6ekIDQ1FdnY2/Pz8lF0ae4XxRXL2j5SUlCAzMxMjRoyAXC6Ht7c3fvnlF7Rs2VLZpbFXGAcU+0dMTU2xbds2ZZfBXjN8iscYEy0OKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQLEGVVBQAGNjY0RFRSm7FPYK4IASocrKSqxatQodO3ZE8+bN0b59eyxbtgxVVVX/uI2ZM2fi8OHDCtP69++P2bNnN0LF/3Pjxg2oqqrCzc2t3vm5ublwd3fHzz//3Kh1AMDVq1cxbty4Rl8Pazyqyi6AKaqpqUFAQABkMhm++OILtG7dGn/88QfmzJkDAPjss8/+to0HDx5g69atCA4OVpju5+cHW1vbRqsdAG7evInWrVtDU1Oz3vl6enro3bs3WrVq1ah1AMDevXuhqsqHeFPGPSiR+fbbb3H+/Hn8/PPPGD58ODw9PTF27FiMGDECv/zyCwDg008/xfjx4/Hee+/Bzs4OHTt2xNGjRwEA6enp8PLyglQqha+vL3x9fQEAXl5eWLhwIXR0dAAAcrkcq1atgqenJ6ytrdGnTx8kJSUBAE6dOoU333wT69evh5ubG2xsbBR6XqmpqQgICICtrS3s7OzQq1cv4bnR0dFo27Ztvdv24MEDNG/eHDt27ECLFi0AAEuWLMFHH32EyZMnw87ODo6Ojjhw4AAAICwsDD169MD06dPh6OgIFxcXLFu2DACQk5MDY2NjREZGCu1/8sknCAgIAABMnz4du3btwtGjR2FjY4NffvkFVVVVmDlzJhwcHNCyZUssXLgQqO2xent748MPP2zgV5O9KA4oESEibNiwASNGjICzs7PCPEtLS+Tm5gK1b87bt29j3rx5uH79Onx8fPDRRx+hoqICVlZW+Pjjj9GjRw+kpaXht99+AwDs27cPAODq6goAmDNnDg4dOoQDBw4gISEBhoaGmDlzJlAbXnFxcSAiXLlyBXPnzsWmTZuQl5eHnJwc9O3bF61atUJ8fDxOnz6NqKgooady8+ZNtGnTpt7ts7S0xNq1a2Frawt9fX0AwKNHj3DmzBn06dMHMsy0y+8AACAASURBVJkM3bt3x6pVqwAARUVFuHv3Lvz9/REVFYXPPvsMy5Ytw7Vr1xAbGwupVAoXFxeh/djYWLi7uwMAQkJCoKKigiNHjiAtLQ39+/dHaGgojh07huPHj+PUqVPw9/cHAEilUhgYGAg1MfHggBKRW7duISMjA/369Xti3r1799CsWTOgtpc0duxYuLu7w9jYGBMmTEBJSQnS09MBAJGRkfDy8lJ4fkJCAvT09GBjY4OkpCRs3rwZ//3vf+Hk5ARdXV307dsXsbGxAIDbt2/Dw8MDkydPhr6+Ptq1awfUvpGXLFkCa2trfPnll9DR0cG9e/dgZGQEe3t7IVCeFlAAEB8fL4QkANy5cwfvvfce3nnnHejp6cHNzQ1SqVTYTl9fX/Tu3Rv6+voYO3Ys9PT0kJSUhLi4ONjb2ws9wpqaGiQlJQnXvqKjo6GioiIEVt0yxcXFKCgogIODAzp16gQAUFVVxalTp7B8+fJ//dqxxsEBJSJ1PSRra2uF6VVVVfjtt9/QpUsXEBESExMVLkIXFBQAAIyMjCCXyxEdHf1EQMXFxQm9jTNnzsDExEShjby8PJiamgrLPj7v1q1bMDMzg6GhIX7++WeMHj1amBcZGSkEWExMDKRS6VMvkNe1/XhAxcbGKix/+/ZtODk5AbVh9vi8yspKlJaWwtjY+Il5ycnJKC8vFwIpKioKHh4eUFdXF5YJCgrCxIkTMWjQIAQFBaG8vPypdTJx4IASkboe0u3btxWmb9++HVlZWRg/fjxSU1NRUlKC1q1bC/OPHz+ODh06wMjICImJiSguLn6iF/N4MBQVFQnrqnP48GH06tULqA2Nv546ubq6orCwEIWFhWjZsqXCuusCSiaTwd7eHlpaWk/dxsfrKC4uRlpamkJgyWQy4fFfw+z48ePQ1NREly5dkJCQoFBjREQEdHV1hWtbUVFRT+wDFRUVzJ49G2fPnsWhQ4dw4sSJp9bJxIEDSkRatmyJDh06YMGCBfjtt98QFRWFL7/8EvPmzcPixYvh6OiIuLg46OjoICsrCxkZGfjmm2+wZ88eLFq0CKi9PoXaj/tv374NIgL+8mb39PREcnIyIiMjUV5ejq+//hr379/HpEmTUFNT80QPrS409PX1oaenh1u3bgEA/vvf/+LmzZvQ1dUFAOTn5wO1p1L1ycrKQm5urkIASaVS4XpbdXU1EhMT4erqiqKiIqSnp+PRo0coKCjA4cOH8emnn+Lzzz+HoaEhysrKkJWVJWzr0qVL4erqColEIuyHu3fvIjMzEw8ePEBFRQU2bNiAjIwMPHjwAHK5XAja7du3o1OnTnjw4EEjvKrsRXBAiYhEIsGOHTvg6OiIcePGYciQIbhx4wbCwsIwfvx4oPZNbWZmhqFDh8LLywvHjx/H/v374e3tDQDo2LEjfHx8MGLECOFaVnl5Oe7cuSMEwzvvvIMPP/wQI0eOhIuLC6Kjo3H06FGYm5vj1q1bKC8vf+I0zMXFBVKpFKtXr8by5cvRsWNHnD59Gj4+PkhMTAQADBkyBGpqak/9KkRcXBzU1dXh4OAgtOvg4AANDQ0AQFJSEiorK+Hq6oq4uDjo6urim2++gaurKxYtWoQ5c+bgk08+AQBMnjwZP/30E9zd3bFmzRpYWloqhOr48eMREREBLy8vHD58GMnJydi1axe8vLzw2WefYf369fD09AQAlJSUIC8v77m+Z8ZeDklDNLJ169ZVbm5u//nrJ0+s4QUGBsLOzg7z589XdimNaseOHdi7dy9Onjyp7FLYc7px40Z1UlLSnIkTJ77wpw7cg2pi4uLi4OjoqOwyGl1cXJxwsZy9vjigmpDKykrcvn37tQmo12E72bPx7wCaEHV1dWRnZyu7jJei7pvx7PXGPSjGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDSkmWLVuGUaNGKbsMxkSNA0pJEhIS0Lp1a2WX8cJmzpyJw4cPK7sM9origHoGmUyG/v37w9bWFkOHDkVqamqDtR0fHw8XF5cGa08ZHjx4gK1btzb57WDixQH1DB9//DEuXryIkpISnD17FpMmTfpX7RARNmzYgPbt28PW1hYzZszAnTt3hB5UQkIChgwZAmtra7i4uODrr78Wnnvnzh2MGjUKtra2sLOzQ1hYGACgU6dOWLt2rbDcnj170LJlSwDApEmT8PHHHwvh6unpiZ07d+L999+HpaUlvL29ERcXJzw3IiICAwcOhJWVFRwcHBASEgIAOHXqFN58802sX78ebm5usLGxwezZswEA6enp8PLyglQqha+vL3x9fYXp7733HmxtbeHh4YFDhw79q33GGDignq6kpATx8fEK02JiYv5VWyEhIVizZg2+/PJLREREoLS0FEQER0dHpKSkoE+fPujZsyeSk5OxefNmLF26FFeuXEFmZib69OkDQ0NDnDt3DlFRUejWrRsqKipw+/ZtuLu7C+uIjY2Fm5sbAKC0tBTnzp3D3Llzcf36dRgbG2Pp0qX47LPPEBUVhbKyMuzevRsAEB4ejv79+6Nr166QyWTYvXs3Vq9ejbS0NMjlcsTFxYGIcOXKFcydOxebNm1CXl4erKys8PHHH6NHjx5IS0vDb7/9BgCYM2eO0O6mTZvQvn37f/0aMKaq7ALESldXF46OjkhISBCm/ZtTmfT0dKxbtw6hoaHo27cvAKB79+64fv06NDQ0sGjRInTt2hUfffQRAKBbt26wtLREbGwsDh06BEtLS6xfvx4SiURo8+bNm6ipqRECCQDi4uKEwEpPT8e4cePg7e0NANDR0UGvXr3Qrl07AICtrS20tLQAAPPmzUO3bt0wY8YMVFVVISoqCkZGRmjWrBkOHz4MDw8PTJ48GQCE50ulf/5di4yMRJcuXRS2t6amBpmZmaipqXliHmPPi3tQz/DFF1/A29sburq6eOONN/DFF188dxvnz5+Hqqoq3nnnHWFabGyscHp3+vRpvPnmm8I8IkJ+fj5MTU1x7tw59OvXTyGcUBtGpqamsLCwUJjm5uYGIkJCQsIT4fX446SkJLi4uKCiogKRkZG4ceMG7OzsYGdnh19++QUHDhyAurr6E8+7desWzMzMYGRkBLlcjujoaHh5eSnUtnr1atjb26Njx45Yt27dc+8vxh7HPahn8Pf3h7+//wu1UVBQAH19faHXIZfLcebMGQwcOBByuRylpaVo1qyZsPyZM2dQU1OD7t27Y+7cuUJP53EJCQkKvbk7d+4gJycH7u7uSE1NRUlJidCbun//PgoLC4WgycjIQF5enkLwbNmyBW3btoWmpibU1dWF6bGxsRg2bJjCY1dXVwBAYmIiiouL0aZNG4XaTE1NsWPHDuzcuRNTp07FyJEjYWJi8kL7kL2+uAfVyFxdXZGTk4OjR4+itLQUCxYsQGJiIpydnSGVSuHm5oaff/4ZZWVlSEhIwOeff47//Oc/MDY2hpeXF7Zv3474+Hikpqbi+PHjAIDy8nLk5+ejqqoK2dnZmDp1KlRUVNC6dWvExsZCX18fNjY2QG2oaGlpoVWrVkBtb0pDQwMODg7Q0NCAh4cHNm7ciKKiIuTk5CAiIgKoPVVLTExUCDKZTCYEVE5ODgDgxo0buH37NogIiYmJ2LdvH/Ly8pCRkQETExMYGBi89H3OXh0cUI3srbfewrRp0zBlyhT4+PhARUUFeOx61rp165CamgoHBweMHj0aQUFBmDlzJgBg8eLFsLW1hb+/P3r27ClcDwsICEBJSQlat26NsWPHwtzcHK1atYKWlhbi4uKEEEFtILVu3VrowcXFxcHJyQmqqn92njds2IC8vDz4+Pigd+/eSElJAWpP58rLyxXaio2NFeru2LEjfHx8MGLECPTr1w8AEB0djYULF6JNmzY4e/Ys9u7dK6yHsX9D8g+W+Vtbt25d5ebm9h9nZ+eGaI4x1oTduHGjOikpac7EiROXv2hb3INijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaHFAvWRJSUkgokZrXy6Xw9LSEsbGxjA2NkZ2dnajrUustmzZImz/+PHjAQDZ2dkoLS1VdmnsOXFAvUSXLl3C0qVLIZFIkJ6eDmNjY0RGRj6x3JkzZ+Du7o67d+8+s72rV69i3LhxCtPu3LmD8vJy7N+/HwkJCTA3N8f27dvRsmVLWFtbo1OnTpg9ezaysrIafPuUob59MGLECMTHx8PCwkK4tXJ1dTXGjh2rpCrZv8UB9ZJkZWVh2rRpWLp0KVA7QoxUKlW4IVwdOzs7+Pv7w9jY+Jlt1ndDuPj4eEgkEvj4+MDc3BwAcOXKFXh5eeHYsWOYMWMGTp48CT8/P+Tn5zfoNipDfftAV1cX2trayMzMFG6wZ2lpiaysLFy/fl1JlbJ/gwPqJVm8eDF69eolhEZMTAwcHR2hra2tsNy+ffvg7e2N6Oho4Xa5O3bsQJs2bWBtbY0hQ4aguroa06dPx65du3D06FHY2Njgl19+AWrvV25jYwNdXV2hTZlMhq5du8LT0xNDhw7FoUOHkJ+fjz179gAAHj58iClTpqBVq1Zo2bIlgoKCUFJSIjx/06ZN8PLygoWFBbp16wYiwvTp0xXuV37v3j0YGxsjJiYGMTExcHNzw7Jly9C2bVtYWlpi3Lhx2Lx5Mzw9PRXG10PtfdI//PBDtGrVCjY2NggICEBRUREAYNCgQVi2bBkGDhz4xJh+T9sHdfsBfxmJx8LCAmfOnGmgV5S9DBxQL0FWVhbCwsIwevRoYZpMJlMY167OsGHDMHz4cKFnFR8fj+nTp2PlypW4fv06AgMDoaqqipCQEKioqODIkSNIS0tD//79heUfH1K9rKwMt27dgoeHhzCtboDO1NRUVFZWYsiQIcIILxcuXEB4eDg2btwI1Abr6tWrsWjRIiQmJmLLli2QSCQKw1yh9nbAampqcHZ2hpqaGjIyMlBQUIDff/8dq1atwqFDh5CamooLFy5g+vTp2LRpE4qKipCfn4+3334b5eXl+O233xAVFYXr16/j6NGjAIDCwkL8+uuvWLRoEaKjoyGXyxEaGgrUjjdY3z5AbUBpamoKg5mi9vrcvXv3GuhVZS8DB9RLcPDgQejq6ir8NY+JiYGnp+cTy9a9+esCqrq6GgCQkpICU1NT9OnTB6i9/7eKisoTIffXIdVjY2NRU1PzxHJ1o83s2bNHGLvPyMgI1tbW6NKlC+Li4pCVlYW1a9di7dq1eOedd2BgYCCEX3x8/BMB5ejoCHV1daSnpwtj/hkaGsLS0hIqKiqYN28eDAwM0L59e0ilUqirq2PDhg0oLS3Fhg0bYGtri+TkZBQWFqLu9tF37tzBrFmz4O7uDnNzc9jZ2Qn3V3/aPkBtQDk6Ogr3gEftQA8VFRXP+eoxZeKAegkuXrwoDHoJAMXFxUhNTa33jVVdXY3k5GQhZDw8PLB161asWrUKfn5+SEtLAwBERUXBw8NDYZioqqoqhSHVUdtTMzMzUxjaKjY2Fg8ePECHDh1w+vRpdO7cWaGd3NxcmJqa4sqVK1BRUXli6K379++jqKhIYcSX2NhYYXvi4uLg7OwsXBuKjY2Fg4MDNDU1gdohq+zt7aGpqYmLFy9CIpHA2dkZNjY2mDJlClavXo327dsjLS3tifXcunULTk5OT90Hdf46NBcR4d69e2jevPnfvl5MPDigXoLbt2/D1tZWeCyTyUBECqdddW7duoWKigqFi+eDBw/GtWvXUFZWJgyGGRUV9cSYdLdu3UJVVZVCQN28eVNhPWVlZZg+fTqcnJzQq1cvFBUVKQwAmp+fj0uXLqFXr14oLi6Gpqam0GOpk5CQADU1NTg6OgK1b/7IyEiFgHo8fP86AOjjw7QDwPjx45GcnIyEhARERUUJ17bqhtCytrYGABQVFSEtLU3YN/Xtg8drfHw/JCQkoLCwUBhtmTUNHFAvQU1NjcL4cDExMTAxMUF+fj6SkpKEf1VVVYiLi4OJiYnQ49m+fTuSkpKQnZ2NR48eCddUcnJycPfuXWRmZuLBgwdA7WmXVCoVehioDUNTU1PExsZi//796NWrF9LT07Fz506oqqrCw8MDZ8+eRWZmJvLy8jBlyhR06NABvXr1Qvv27VFYWIhVq1YhJycHv//+O9LS0lBWVga5XI7s7GxUVFRgzpw5SE9PF0Ln8QE+UU8gPX4K26FDBxw4cADJyckoLy/H77//rvC8x9uRyWTAYxe+69sHqL3on5GRodCDunLlCgwNDeHr69sgryl7OTigXoLmzZsrjBAsk8mQl5eHTp06Cf/eeOMNVFdXK7x5Hz16hIMHD8LPzw/9+vXDoEGDEBwcDNT2OiIiIuDl5YXDhw8Dtb2EFi1aCOuSy+WIi4vDvn370KtXL6xZswZ9+vTBhQsXhN7PjBkz4OTkBB8fH3Tt2hXW1tbYvXs3JBIJ3NzcsGLFCoSGhsLT0xPz5s2Dqqoq/Pz8hHHxevToIWyXm5ubcIpaF0hyuVxhANC/Ds3+6aefwsPDA/3790fHjh1x6tQpob36AsrKykoI+/r2AZ7yCd7hw4cRHBxc70jNTLx4XLyXYPXq1cjOzsaSJUsadT2jR48GEWHXrl2Nuh6xCw0Nxfz585GamgqJRIL4+HiMGjUKFy5cgI6OjrLLe+XxuHhNzAcffCB8d6cxxcfHw9raGllZWaipqWn09YlNeXk5srKyEB0dDWdnZ0gkEpSXl+OLL77Ad999x+HUBHFAvQQmJiaYOnVqo66jvLwcKSkp2Lx5M1xcXBS+aPm62Lp1K1xcXPD9998Lp3exsbH48ssv6/1Agomf6j9YhjUAPz+/Rm1fU1MTubm5jboOsZs0aRImTZqkMM3Ly0tp9bAXxz0oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaHFAMcZEiwOKMSZaHFCMMdHigGKMiRYHFGNMtDigGGOixQHFGBMtDijGmGhxQDHGRIsDijEmWhxQjDHR4oBijIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0OKAYY6LFAcUYEy0OKMaYaKk2UDuUmppaWVBQUNlA7bF6EJFEIpGQsutoyngfNr6HDx+qNVRbDRJQRLSnoKAgpqCgoCGaY/XIzs5+l4jUmzVr9pOya2nKMjIyxqmrq98yMTG5oOxaXnGRyi6AvURBQUEpwcHBtsquo6kLDAz0Dg4OvqrsOhh7ZQQFBfUMCgo6qew6XhXBwcE3AwMD3ZVdB/t7fJG8CZBIJMFEtFnZdbxCNkul0mBlF8H+HgeUyI0aNUofgP/WrVsPKLuWV4WGhsYWAEHKroP9PQ4okdPR0Qkioi3KruNVsm7dugqJRHIgKCholLJrYc/GASVyRBQslUr59K6ByeXyzRKJhE/zGPu3JkyY0C04OPicsut4VQUFBSVOnDjRUdl1sKfjHpSISSSSsTU1Nd8qu45XlUQi2SSXy8cpuw72dBxQIhUcHKwGIGDbtm17lF3Lq6qysnKHRCL5UNl1sKfjgBIpIgqSSCR8cbwRhYaGPiSisxMnThys7FpY/TigREoikXSuqanZpOw6XnUSiWRDTU2Nn7LrYKzJCA4Obh0UFBSn7DpeF8HBwfljx441VHYd7EncgxKn0QB2KruI1wUR7VJXVw9Qdh3sSRxQIkREoyQSyW5l1/G6kMvluwBwQIkQB5TIBAYGekskkrObN2++p+xaXhfbtm0LB3A/MDDQTtm1MEUcUCKjoqIylIj4+tPLlyKVSocouwimiANKfPoD+EXZRbxu5HL5IYlEMkDZdTAmWoGBgQ7BwcFJyq7jdRUUFFQQHBxsoOw62P9wD0pEpFIp956U6xci6q/sItj/cECJiEQicauqquJ7jivPfgBeyi6C/Q8HlLh8UFJSck3ZRbyuVFRUwgG8r+w62P9wQInEhAkTOgGI2L9/f42ya3ldbdq0KVsikRQFBgY6KLsW9icOKJGQSqXdiIiHQlIyIjovlUq7K7sO9qeGGriTvSAi6i6RSF7bHwcTUXMAGsqu45tvvokrLCzsQ0RnlV1LI0ttCgOYSpRdAP48ONsAiFZ2Hey5LJNIJLMaqjEiiuQL1C+VoUQiKVR2EX+HT/EYY6LFAcUYEy0OKMaYaHFAMcZEiwOKNVlbt26FRCJBZmamskt5acLDw1FeXq7sMl4aDijGmojQ0FD4+PigpKRE2aW8NBxQIpecnKzsEphIvE49pzqvdECtWbMG3bp1w5YtW2BtbQ1NTU34+Pjg9OnTGDduHIyMjNCsWTPMmDEDNTWKvzDZuHEjHB0doaWlBRcXF4SEhAgHSFJSEnr06AFdXV3Y2Njgww8/hFwuBwAsW7YMNjY20NXVRdeuXXHmzBkAwP379zFmzBiYm5tDQ0MDHh4e2LNHcci7jIwMDBs2TKgrICAAHh4eiI2N/Ud1PXr0CGPHjoWJiQlMTEwwcOBApKamNvp+flmio6PRvXt3aGlpwd7eHj/++KPC/KqqKsyePRtWVlbQ0NBA27ZtcfDgQYVlysrKMHv2bNjb20NDQwNOTk5YtGgRampqMHfuXGhqaiosHxkZCYlEgl9//RUAMHDgQMyaNQtTpkyBgYEB9PX1MWjQIJw7dw69evWCtrY27O3tsWvXLoV2UlJSMHjwYOjp6cHc3Bxvv/02IiMjhfkDBw7EZ599hrlz56JZs2YwMjLCqFGjUFRUBNT2nj766CMAgJmZGSQSCUJDQ4G/OR5ZAyCiNtQIVq9eTQDI19eXLl++TD/88APp6ekRAJo4cSJFRkbSl19+SQBo69atwvO++OIL0tPTozlz5tCePXto/vz5pKenR6NHjyYioq5du5KZmRlt3ryZVq5cSe+++y4REZ0+fZoA0KhRo2jnzp00cuRIOnjwIBER3blzh1q3bk3z58+ntWvX0ptvvkkSiYTCw8OJiKi6uprat29PVlZWtHv3blq5ciWpqalR7969/3Fdc+fOJYlEQgsXLqStW7dS165dKTc3tzF2LRHR0gY+BiKftbKEhATS19cne3t7Wr16Na1fv57Mzc0JAGVkZBAR0dixY0lVVZUWLFhA+/fvpwEDBpBEIqHz588L+9jPz4/U1NRoxowZtHPnTvr8888pICCAiIjmzJlDGhoaCuuNiIggAHT8+HEiIhowYAABoMmTJ1NUVBSFhIQQAFJTU6P169dTeHg4DR48mFRUVCghIYGIiDIyMqh58+bUvXt32rZtG23fvp3eeust0tTUJJlMJrSroqJCI0eOpPDwcAoNDSV1dXX69NNPiYgoKyuLZsyYQQDoyJEjdOHCBcrKyiJ6xvH4N/i+V/9UYwdUdna2MG3MmDFkZmZGcrlcmGZvb0/vv/8+ERGlp6eTmpoaHThwQKGtTZs2EQDKz88na2tr8vf3f2J9W7duJQB0+fLleut5fJ0lJSWkpaVFs2fPJiKiS5cuEQDat2+fsExQUBCpqKhQeXn5P6orICCAdHV1qbKy8l/sref2UgOqX79+ZGRkpPBabty4UQiohIQEAkDz5s0T5svlcnJwcCBfX18iIvrhhx8IAG3btq3edfzTgHJ1dVVYxs7OjoYOHSo8vnfvHgGgTZs2ERHRxx9/TG3btqWqqiphmcrKSrK1taUpU6YI7bq4uCgcI/379ycPD48ntjcnJ0dh/U87Hv9GkwioV/oUr46Wlpbwf01NTairq0Mi+d+vfKytrZGbmwsAOHXqFKqqqjBq1ChoamoK/yZPngzUnqqNHj0aJ0+exOTJk5GdnS2007dvXxgbGyMgIABHjx59oo4bN25gwIABsLKygpOTE2pqaoRPoNLS0gAADg7/+yG9o6MjampqUFxc/I/qGjVqFB49eoR33nkHMTExjbAnlaOsrAy//vorRo8eDTMzM2G6qur/fkp67tw5AMDgwf8bJFgikcDf3184lTp+/Di0tLQwZsyYF6rn8eMJtceUhsb/fkZobW0NAMIxdezYMcTExEBXV1d43fT09JCWlob79+8Lz9PW1lY4Lu3s7PDgwYO/redpx+Or4LUIqL8jkUhA9OfvJusC48iRI4iOjhb+3bx5E/Hx8XBxccFXX32F1atXIywsDPb29tiwYQMAwMLCApcvX4azszPeffdddO3aFenp6QCAs2fPwtvbGxUVFdi+fTsOHDgAY2Nj4dpXXTBdvHhRqOvatWuwsrKCqanpP6rr7bffxtGjR5GZmYk2bdogKCgIVVVVL3lvNryMjAxUVVWhZcuWT12msPDPn5WZm5srTDc2NkZxcTGKi4uRlZUFS0tLqKioNGq9dSHz+DH17rvvKrxu0dHRiIuLE46d+qirq6O6uvpv1/e04/FVwHcz+AsjIyPh/61bt37qctOmTUNgYCAmTpyISZMmoW3btujSpQucnZ1x7NgxnD17FoMGDcLYsWNx6tQphISEwMHBAUeOHBH+8uvo6AjteXl5oXfv3pg5cyZSUlKQk5ODQ4cOYe/evc9V19tvvw1/f3+sXbsW//d//4cWLVpgzpw5L7xflKmu1/Ss3kFdryUvLw+WlpbC9KysLKirq0NbWxuGhobIysp6ahuP914akpGREXJzc5/5uj2PuuCrI5FInno8NnXcg/oLPz8/SKVSrFu3TmF6aWmp8P+6T8309PSwcOFCAMAff/wBAKioqBDa6devnzA9NzcXbdq0EcKpoqICJSUlCp+2fPPNN3B0dERSUhLMzMxwGa5JtwAAHRRJREFU5coVDB069B/XVbduqVSK//znP7CyshLW35Tp6enB0dER+/fvR2VlZb3LeHt7QyqV4tixY8K0iooKHDlyBJ07d4aKigr8/PxQUlKCH374QeG5db0Uc3NzVFRUID8/X5iXkpLywvX37NkTly9fRlRUlML0x1+7f6LuD9pfT/uedTw2ddyD+gsHBwdMmTIFa9asQf/+/TFw4EBkZGRg/fr1OHbsGNq1a4dhw4ZBX18f/v7+whvCy8sLERERGDZsGD755BPo6uri+PHj6NChAwDA19cXoaGh2L59O0xMTLBq1Srk5+dDJpOBiFBTUwNvb2/MmDEDDg4OkEgkyM/PR1FREfT19f9RXd988w0OHTqE0aNH48GDB0hPTxfW39QtWLAAAQEBeOONNzBu3DioqKhgzZo1wvxWrVphzJgxWLBgAaqrq9GqVSts3rwZWVlZwkf+o0ePxoYNGzBmzBiEh4ejTZs2iImJwenTp/HHH3+gZ8+ekEqlmDp1KqZNmwaZTIbPPvvshWv/4osvcPToUfj7+2P69OkwNzfHr7/+iurq6ie+BvEsb7zxBlRVVTF16lSMHz8eZWVlmDhx4lOPR9ZAGvtTvOLiYmHaxIkTycrKSmG5N998k3r06CE8lsvl9PXXX1OLFi1ITU2NbG1t6eOPPxY+1l24cCE5ODiQpqYmOTg40ObNm4mI6MaNG/T222+TkZERGRoa0oABAygtLY2IiAoLC2no0KGkra1N1tbWtHDhQjp06BBZWFjQmTNniIho2LBhpK6uTgCEf0ZGRhQbG/uP6vrxxx+pQ4cOpK2tTc2bN6epU6c25id6L/VTPCKi9evXU4sWLUhLS4s6dOhAY8aMUfiaQVlZGU2bNo2aNWtG6urq1K5dOzpy5IhCG3l5eTRhwgQyNTUlbW1tcnNzo5CQECovLyciou+//55atWpFWlpa5O/vT6GhoU98iufl5aXQprOzM40aNUphGgAKCQkRHsfHx1Pfvn1JW1ubdHV1qXv37rR//35hfn3tTp8+nQwMDBSmbd++nSwsLMjQ0JD8/PyInnE8/o0m8Ske37BORGpqaoQLuESEu3fvwtPTE//3f/8ndN1FhG9Y17Q1iRvW8SmeSJSXl8PHxwe2trbo3r07NDU1cf78eZSWlqJt27bKLo8xpeCAEgmJRILRo0dj7969mD9/vvBzmH379il8t4ex1wmf4rF/i0/xmrYmcYrHXzNgjIkWBxRjTLQ4oBhjosUBxRgTLQ4oxphocUAxxkSLA4oxJlocUIwx0eKAYoyJFgcUY0y0XouAunz5MiQSCSQSCVxcXP7Rcz744ANMmDCh0WtrSoYOHSrsx82bN9spu57n4e/vL9QeFham7HKUwtTUVNgHO3bsUFd2Pf+EqAIqLS0NEokE165de2LeiRMnYGNjg9u3bz+zjS1btmDBggUK02QyGXR0dJCRkYHLly8L02NjYzF8+HCYmZlBQ0MD7u7uwh0uZTIZnJyc/tV21FcDAMyZMwebNm1SmDZ9+vQmcw/pzZs348qVK8CfN/Yrbox1BAYG4p133ql3nq+vL6ZNm/a3bUyaNAk//fSTwjSZTIb58+cjIyMDgwcPBhHBwcEBmpqaaN68OXx9fZ/r5nFilpGRgYEDBwoDcdSRyWRYuXIl1NXVMWjQoCZxs3pRBVR0dDSkUik8PDyemNeyZUv07dsXJiYmz2xj+fLlsLKyUpgmk8ng6uoKCwsL4d7eZ8+eRceOHVFTU4MDBw4gMjISS5YsgVQqhVwuR0JCwr8OqPpqkMvl2Llzp8IgnPfu3cOGDRuUPmJsWVnZP1rO2NgYOTk5AAB3d/dGCajo6Oin3l6md+/e6NSp0zOfn56ejg0bNsDd3V2YVlBQgIyMDPj4+MDCwgJqampITk7G7du38cMPP2D//v1wd3fHoEGDsHRpg96HTynOnj2L8PBw2NjYKEy3sLBAeno6nJ2dYWhoSE9tgCmqu6PmwoULycXF5Ylb/+3cuZMACHccrKyspE8++YRMTEzI0NCQZs2aRURELi4uBIB0dHRIV1dXuNOkn58fjR07VmivoKCAzMzMaMyYMfXeajApKYkA0CeffEJOTk6kr69Pc+fOFeaXlJTQ1KlTydzcnLS0tMjR0ZF+/PHHZ9Zw8uRJAiDcBZGI6IMPPiAA9NVXXwnT0tPTKSAggIyNjUlHR4cGDBhAhYWFRLXjotnZ2ZG2tjb16tWLqqqq6Ny5c9S+fXvS0tIiDw8PYbDIO3fu0IABA0hXV5f09PTI29ub4uPjiYho27Zt5OzsTDo6OtStWzdycnKi0tJSIiK6cuUK+fn5kZaWFpmYmNDnn3+usG+WLFlCzZs3p8a4o2ZVVRVpaGhQWFjYE69Jq1atCAAdPnyYiKje7b537x5paGiQVColHR0dat++PRERnT9/ngBQSkqK0F5YWBhpa2tTTU2NMO2jjz4iAwMDqq6uppqaGvrqq6/I1taWtLW1qWvXrsL+q3s9O3bsSBoaGmRhYUFxcXGUlZVFAOjq1avCcmPGjKEBAwaQXC4nR0dHmjFjBnl4eJCmpiZ16NCBvv/+e2rXrh1pamqSr68vlZSUEBFRRUUFzZ49m2xsbEhDQ4O8vLzo5s2bREQ0b948Gj16NI0bN4709fXJ1NSUdu/eTUREu3fvJlVVVVJTUyMdHR2aOnWqwn7s3bs3jRgxgprKHTVFoS6gBg8eXLfzFMjlcgoICBBCZt26dWRtbU0JCQmUmJhIFy5cICKiEydOkK6ursJBR0Rkbm5OK1asEB6vXLmS9PX1hTf+X/30008klUpp8eLFVFBQIAyOmZOTQ3K5nPz9/alnz56Unp5OZWVl1KJFC9qyZcszaxgxYgTZ2dlRs2bNiIjo5s2bpKamRhYWFsJgk7m5uWRnZ0dDhgyhu3fvUmZmJllaWlJoaCjFxMQQADp27BhlZWXRwYMHSS6Xk5mZGc2fP59yc3MpLCyMqqurKSsri6ysrOjTTz+lkpISYVDL5ORkOnjwIOnr69OlS5eorKyM3nrrLRo0aBBR7eChGhoaFBISQnl5eXTx4sUn3tijRo2inj17UmME1M2bNwkAJSYmPvGa1P3RSElJeep2ExF9/vnn1KdPH4Xn/ve//yVdXV2FQTFnzZpFPj4+T7zudQO9Tpkyhdq2bUvx8fFUXFxM/fr1E/64nDhxgjQ1NWnlypWUlZVFSUlJ9OjRIzp16hRJpVIhZIiI2rVrR/PnzyciIjMzM+rWrRulpKRQXFwcaWho0Jtvvkn3798X9nXdSNT9+vUjNzc3ioiIoKKiIurXr59w/E+fPp3MzMzo0KFDVFRURO+99x65ubkJ6+zcuTMtX7683mPbysqKFi1aRBxQz6EuoOzt7Z+6Y9u0aUMrV64kIqI1a9aQnp4eXbp0SWGZL7/8UhhFtk5OTo7CPaWJiN555x0aPnx4veshIgoJCSF3d3fh8Y0bNwgApaen0969e0lXV5fy8vKIantTKioqdOPGjafW8PDhQ9LS0hJGts3Ly6M+ffrQhAkTyNfXl2bOnElU++YyMTERDvDff///9u49Kqp67QP4d8+AAioggVysdClqWiKwvKa96ol8S83zqqGoZSqzN9br0rxUS0+t8qir1VupvcuTMCOSxgnNDHOp5SUvqSUqCgywwOvRgEARUU7AyDDP+4fMfmcADWGGPZfnsxbLteey97Pn8vW3f3tmnqPk4+NDp0+fpvPnzxMA2rBhg/xGq6+vp4CAAHrttdfkERA1/O76s88+Ky//8MMPFBAQQNQQlAkJCfJ1r776Kk2dOpWo4YX90ksvETWMUteuXUsBAQFkMBjk20dGRtJbb71F9giorVu3NhvuRETp6enk6+v70P0mIho7diytXLnS6rI333yzSRi9+OKLVo8DNXSGFgSBsrOz5X/NNm/eTIGBgURENHDgQFqyZEmTGteuXUt9+/aVl41GI3l5edHOnTupurqaVCqV/J+pwWAgDw8POnjwIBER1dXVkUqlogMHDtD+/futRmJXrlyhAQMG0KeffkrU0HF46dKl8nbWrFkjdyC+d+8eeXl50bFjx5rUV1lZaRmCThFQDjMHVVVVhatXrzY7/2A0GlFQUCDPTS1YsACLFi1CTEwMZs6cKc/hZGRkYNiwYVb3zc3NBQA8/fTT8mVlZWUIDg5+YC25ubmIiIiQlwsKCuDn54ewsDBs27YNU6ZMQUBAAADgzJkz8PLyktffXA3btm1DcHAwpk2bhrCwMGzcuBHHjx/H6tWr0aFDB7n+o0ePQhAEdOvWDZ07d0Z8fDy0Wi2GDBmCyMhIpKWlYc2aNRg8eDCuXbsGlUqFgwcPIj8/H71798bBgwdBRNi+fbvVGchTp05hyJAhQENrInN/udOnT2PHjh2YPHkyDAYDTp06hczMTPj6+sLX1xfffvst9u/fjw4d7p/wMc/NWc7v2FJWVhYiIiKgUjV9Wer1enm7ze23ub6zZ882efzz8vKsnn/ztgYNGmR12d69exEZGYnDhw8jMDDQ6jVw8+ZNdOvWDTdu3IBer5fbgTWu0XKdhYWFqK2txaBBg5CbmwuTySS/hvPz82E0GuVtFBQUwGQy4ZlnnsHRo0fRuXNnvPDCC/D398fgwYMxadIkLF68GACQk5NjVduFCxfks9NZWVmoq6trtquLef7TXs+fPThMQGVlZYGImg2owsJCGAwG+clVq9VYtWoVMjMzsWPHDuzZswdoeMNFR0db3Tc3Nxe+vr5WE4YhISHIz89/YC15eXlWLwC9Xi9v++rVq+jdu7d83ffff4/IyEi52UFzNXz55ZeYN28eBEFAREQEPvzwQyxfvhzBwcHw9PSU+9kBwBtvvIHy8nKUlZXh0qVLmDVrlnxdXFwcCgsLUV1djU8++QQAEB0djdOnTyMmJgaLFy9GZWUlKisrrWrcvXu33H5qzZo18Pb2Rv/+/RETE4P33nvPahtpaWkoKirCnTt3cPLkSau2VZcvX0ZtbW2TN7utZGVlISoqqtnrcnJyrE6eNN5vNLzpq6qqmjz+jQOqrKwMpaWlVq+1Xbt2YdeuXVi6dCnu3LmD0NBQq3Xs3LkT48ePR1XV/XMDPj4+TWrMy8uzevP/8ssv6Ny5M3r16gW9Xo+ePXvCz89P3p+QkBC5E3JOTg4CAwPl7UZFRaGiogLXrl3DrVu35BM4VVVVuHbtmtVjkZ2dLS9nZGSgX79+Vk1hLevz8fF5aIdmR+NQARUYGIhbt26hoKBA/qurq4Ner0dgYCBCQkJgMBjw2WefoaSkBEVFRTCZTOjduzeMRiMqKiqQk5ODkpISVFZWAhZn8CzNmDEDP/30E95//32cPXsW+/btw9SpU4GG0dqFCxeaBJR5+YknnkBhYSEA4Ndff0ViYiK6dOki37dxDYWFhThz5gzmzp0LAIiIiED37t3lN5XlCGr48OH4+uuvUVBQgJqaGhw6dEiuYePGjSgoKEBpaSmqq6sRHh6O3bt349ixYygvL8ft27cRHh4OPz8/dOnSRa5x3bp1OH/+vFxjYGAg+vXrh99++w3bt2/HokWLAAAdO3ZEZGQk1q1bh8rKSty4cQOnTp2yetxyc3MhCILdAio7OxtBQUFWz//vv/8uPwfmN2Fz+w2LzsOZmZm4ePEiiAilpaUoLy+3qvn8+fNAw+/AHz9+HEuWLMG0adOwdOlSzJo1C1FRUSgoKEBGRgZqa2uxevVqXL9+HcuWLUOPHj3QrVs3rFy5EsXFxcjKypI/ulJTUyPXe+7cOXzwwQeIiIiAIAhNRj0PWx4+fDgyMjKwd+9emEwmHDp0SH6N5OTkQKVSya9po9GI/Px8+bG5ceMGbt68iatXr+LKlStWj29ubi769+/f7AiVPQQRDYqPj7fqBweAVCoVVVdX04oVK+R5naysLBowYAB5eXlR3759acuWLfIx9sKFC6lDhw7k5+dHp0+fJiKiUaNGkUajaXI8/vnnn1OfPn3Iy8uLevbsKU9k5uXlEQAqKiqSb9urVy9KTEwkapiPGjhwIPXs2ZOio6MpNjaWevTo8cAa3n33XatJ29TUVEpLS5OX4+LiaPr06UREVFFRQVOnTiU/Pz/q2rWrea6H/vjjDxozZozc7+7tt98mo9FICxcuJH9/f/Lz86OpU6fK/eHS0tLo8ccfpz59+lBMTAyNHDmSZs+eLW/z5MmTFBcXR2FhYRQcHEx3796V923YsGHk7e1N3bt3p9TUVKvHbNWqVZb7atM5qOvXr59t/PwDoOXLl1NNTQ2p1Wp5XuVB+11dXU0jR44kDw8PCg0NJZPJRIcOHWryfH700Ufy6ysoKIhefvllOnDggNW+vvPOOxQUFCT3N7x48aJ83bFjx2jQoEHUsWNH6tGjB/34449EDT31/P39qXv37vTKK6/Q0KFDaf78+UQNZ5ItzwSPGzeOli1bJi+PHz9efr6pYT4yODiYfHx8aMSIEfK84xdffGF1ptt8YuHy5ctERJSbm0tPPvkkeXp6UmxsrNU+Pf/885Znrp1iDsoh2KtxJxFR165dad26dfZavVMrKioiAHJj0D8TFxdnGbbt3rizNdavX9+k+aW7CgkJsTwJ5RQB5dJtp4qLi3H79m2EhITg5s2bCAoKUrokReXl5eGbb77B9OnT4enpifXr16N///7o16/fQ+939+5dVFdXQ6/XY8KECe1Wry3k5uYiPDwcpaWl8PPzg7e3t9Iltbvy8nJUVFSgtLTUqSbI4UhzUPZgPmsxY8YMjBs3TulyFGcwGHD48GEMHToUo0ePhtFoxJEjR+QJ/geZOXMmQkNDm0wCO4O8vDxkZmYiNDQUBw4cULqcdkdE6NWrl/yfkLM9f9wXj7UW98VzbtwXjzHG2oIDijHmsBxlkrwOwG2li3B09+7d8xYEgTw9PZX9+YP7Km28vuMAPG28TitGo9GzqqoqqGvXriX23I6TqFe6AOaCRFG8LUmSU5widjSiKP4kSdJYpetgLceHeE5GpVLNJ6LEFtyUWdBoNH8VBOGuVqs9onQtrOU4oJxMUlLSdkEQwjQazXNK1+JMVCrVP4xG438rXQd7NBxQTshkMs1XqVQ8imohSZLeIaLUzZs389wTY+1BkqS/aTSa2UrX4ejmzJnjJUnSfqXrYK3DIygnpdVq16hUqrXx8fEBStfiyDw9Pb8GsFHpOljrcEA5MZPJNEOtVqcpXYejkiTpv3A/zF2jXYsb4oByYps2bTpIRCWSJL2udC2OiIhSBUF4Vek6GHNroigaJEmy64ccnY0oihslSUpQug7WNjyCcgEqlWoGEfGhXoOEhIQRACK0Wm2S0rWwtuGAcgFJSUnfAbguimLzLXndjMlkWioIwgyl62CMWZAk6d6YMWMc5fuVihBF8RNJkpYqXQezDR5BuZaJffr02aN0EUppOLR7VqvVfqZ0Lcw2OKBciFarPQDgoiRJbvmVDpPJlK5WqycrXQdj7CFEUfyXJElPKl1He5Ik6QtRFOcrXQezLR5BuaYJAPYqXUR7EUUxhojCdTodfz/RxXBAuSCdTpdXX1+flJCQ8J7StbST/xUEwbnazTDm7iRJ2q/RaF5Qug57EkVxlyiKk5SugzHWCpIk1TtK9x5bkyTpDVEU/6F0Hcx++BDPxRHRX0RRPKx0HbY2b968XgCW6nQ6tzxj6S44oFycTqc7BuCEJEl/U7oWW/Lw8DhgNBq5GytjrkCSpB/i4+OHKl2HLYiiuF4UxXlK18Hsj0dQbiIsLGyCSqX6Rek62kqSpFgAoTqdbrPStTDGbEiSpLGiKP6kdB2tNXv27MckSbqpdB2s/fAIyo00tFw6IUnS+/ZY/8aNG3smJyeH2WPdAODl5XWUiMbYa/3M8XBAuRmdTvcBgL6SJI2y5XoTExMHdOrU6azJZCrcsGHDY7ZcN+7PO62sr6//XKfT5dl63YwxByNJUl1sbKzaFutKTEwcsHXr1vKKigqqqKig5OTkf9sypDQazV8lSUq31fqY8+ARlPsa5e/vf6KtK0lMTBzg4+Pz88SJE+VAmjx5cicvL6/rtgipWbNm+apUqi1arZZ/pcANcUC5Ka1WmwFgpyRJ/9PadTQXTmZTpkzxsUVIderU6Uh9ff3YtqyDOS8OKDem0+k+BfCUKIoTH/W+Dwsns7aGlCRJnxLRP5OTk8+35v7M+XFAuTmtVjtJEIStc+bM8TdfptFojKIoLnnQfVoSTmYtDSmNRrMlPj7eYLE8HsBTOp1u7aPtEXMlLvklUvZoEhISBphMpm9MJpO3Wq3u1XDxdq1WG9f4to8STpa+++676tra2icXLFhwq7nrRVE8BWBYw+K/BEHoptVqO7Vmf5jr4BEUQ1JSUj6AHhbhBJPJFN74dq0NJ/zJSCo2NjaAiEIEQUDDX08iMjS/JuZOOKAYRFE0CILQ2fIyQRC6zJ8/v5t5uS3hZPagkPL19Q0H0LHR9rtqNJp7rd0Wcw0cUG5Oo9FcEwShQzNX+RmNxgH4/3A62ZZwMmsupEwmU29BEHwb31YQBM/4+PjStm6TOS8OKPYGgB+I6Hqjy7sKgtDHIpz8H3D/R9Y4pNRqdQQAH8vbNNSzLTk5OcRW22XOhyfJGQAgPj7+RbVa/SYRRQmC8Djufwbpm6ioqHG2DCdL5onz7OzsfwL4T0EQQETXiehnQRA+0+l0WfbYLnMeHFDMSkJCwvMmk2mBt7f3qOjoaP9JkybZtVNxenp6zdmzZ0vq6upUgiD8YjQa16akpJyz5zaZ8+CAYk00HNadmjhxYpf22F56enqNXq+fuH79epf7aWLWNhxQzIo95pxaIj09vaampuaJB31OirknDigmUyqczDikWGMcUAxwgHAy45BiljigmMOEkxmHFDPjgHJzKSkpA9Vq9c+OEk5mHFIMHFDuLSUlZaCHh8eJCRMmNPkUtyPgkGIcUG7K0cPJjEPKvXFAuSFnCSczDin3xQHlZpwtnMzS09Nra2pqHueQci/8ZWE3Yu9wGj16NP7+97/bY9WYPHmyl7e3d5E9Wloxx8UjKDdhz3AqKCjArl27UFpaihEjRiA/Px8rVqxAx44dW3DvR8MjKffCAeUG7D1y2rNnDz7++GOUlZXhscceg1qtxqZNm/DUU0/ZY3McUm7EJo0bmeNqjzmnvn37orKyEkajEVVVVVi5ciWGDh1qr82hf//+HpcuXVo4bty4xH379tXYbUNMcTwH5cLaa0K8trYWJ06cwIoVKzB37lwcPmz/HyXgOSn3wId4Luqrr74aBODn9j5bR0QQhPZ7WfHhnmvjEZQLSkpKGuvj47NPiY8StGc4oWEkFRAQkJ2UlDSwXTfM2gUHlAtKSEg4cvfu3X9XVFS4fOumkpKSKoPBcCUhIUGvdC3M9vgQz4WlpKQUPvfccz0CAgJsf77fAZSUlFSdOXMma+7cuf+hdC3MPjigXJyrhhSHk3vgQzwXN3fu3H7Hjx+/5kqHe8XFxTUcTu6BR1BuwlVGUsXFxTXnzp07//rrr49UuhZmfxxQbsTZQ4rDyf1wQLkZZw0pDif3xAHlhpwtpDic3BcHlJtylpDicHJvHFBuzNFDisOJcUC5OUcNKQ4nBg4oBgcMKQ4nZsYBxQAHCikOJ2aJA4rJlA4pDifWGAcUs6JUSHE4seZwQLEm2jukOJzYg3BAsWa1V0hxOLGH4YBiD2TvkOJwYn+GA4o9lL1CisOJtQQHFPtTtg4pDifWUhxQrEVsFVIcTuxRcECxFmtrSHE4sUfFAcUeSWtDisOJtQYHFHtkjxpSHE6stTigWKu0NKQ4nFhbcFcX1ioW3WKMD7oNhxNjTFEpKSmXLl26VFdRUUGWf3q9vnrLli0nla6PMebmGocUhxNjzKGYQ4rDiTHmkFJTUzNSU1O/V7oOxhhjjDHGGGOMMcYYY4wxxhhjjDHGGGPMUfwfvHhY1wJL4BYAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pp.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7ce734ad5af0c82c", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:36:41.003316Z", + "start_time": "2025-02-21T09:36:41.001145Z" + } + }, + "outputs": [], + "source": [ + "issue_url = \"https://github.com/deepset-ai/haystack-core-integrations/issues/1268\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "961c6d248809c96", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:37:08.036526Z", + "start_time": "2025-02-21T09:36:42.206187Z" + } + }, + "outputs": [], + "source": [ + "result = pp.run({\"url\": issue_url})" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c61e726e2c7d2d17", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:37:11.165861Z", + "start_time": "2025-02-21T09:37:11.162582Z" + } + }, + "outputs": [ + { + "data": { + "text/markdown": "# Comment from Agent\n\nHi there! Thanks for reporting this issue. I've analyzed the code and can confirm this is indeed a bug in how custom queries handle empty filters.\n\nThe problem occurs in the `_prepare_embedding_search_request` method of `OpenSearchDocumentStore` where we unconditionally try to normalize empty filters when using a custom query. Your proposed solution is heading in the right direction - we should only include the `$filters` placeholder in the substitutions if filters actually exist.\n\nHere's the proposed fix for the `_prepare_embedding_search_request` method:\n\n```python\nif isinstance(custom_query, dict):\n query_placeholders = {\"$query_embedding\": query_embedding}\n if filters:\n query_placeholders[\"$filters\"] = normalize_filters(filters)\n body = self._render_custom_query(custom_query, query_placeholders)\n```\n\nThis change means:\n1. We always include the required `$query_embedding` placeholder\n2. We only include and normalize `$filters` if filters are actually provided\n3. Custom queries without filters will work correctly\n4. Custom queries with filters will continue to work as before\n\nThis maintains backward compatibility while fixing the issue with empty filters. It's a more robust implementation that properly handles optional filter parameters in custom queries.\n\nWould you mind creating a PR with this change? I'd be happy to review it.", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Markdown, display\n", + "\n", + "display(Markdown(\"# Comment from Agent\\n\\n\" + result[\"agent\"][\"messages\"][-1].tool_call_result.result))" + ] + }, + { + "cell_type": "markdown", + "id": "43491c00e173588d", + "metadata": {}, + "source": "_Let's see what files our Agent looked at_" + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8778f7d378009251", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:37:15.920512Z", + "start_time": "2025-02-21T09:37:15.915236Z" + } + }, + "outputs": [ + { + "data": { + "text/markdown": "[https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/opensearch/src/haystack_integrations/document_stores/opensearch/document_store.py](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/opensearch/src/haystack_integrations/document_stores/opensearch/document_store.py)", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for document in result[\"agent\"][\"documents\"]:\n", + " if document.meta[\"type\"] in [\"file_content\"]:\n", + " display(Markdown(f\"[{document.meta['url']}]({document.meta['url']})\"))" + ] + }, + { + "cell_type": "markdown", + "id": "9b7ca11f2e268e7b", + "metadata": {}, + "source": [ + "# From Agent to Multi-Agent\n", + "\n", + "Let's make this agent a little more powerful.\n", + "We will pass the issue comments and the generated proposal to a second agent.\n", + "We also fork the original repository so that we can make edits.\n", + "\n", + "The `Agent` will then:\n", + "* view relevant files\n", + "* perform edits commit by commit\n", + "* return a PR title and description once it is ready to go" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6435353f22925580", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:38:50.529255Z", + "start_time": "2025-02-21T09:38:50.518244Z" + } + }, + "outputs": [], + "source": [ + "from github_components.file_editor import GithubFileEditor\n", + "from github_components.repository_forker import GithubRepoForker" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e4ed049b9b95b7ac", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:06.567935Z", + "start_time": "2025-02-21T09:38:51.553173Z" + } + }, + "outputs": [], + "source": [ + "# Either classic token or a fine-grained token that can create repositories and commit code\n", + "os.environ[\"GITHUB_TOKEN\"] = getpass(\"Github Token: \")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "dcb13ab1345602a7", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:07.690838Z", + "start_time": "2025-02-21T09:39:07.688162Z" + } + }, + "outputs": [], + "source": [ + "repo_forker = GithubRepoForker(create_branch=True, auto_sync=True, wait_for_completion=True)\n", + "pp.add_component(\"repo_forker\", repo_forker)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "dfbe9dc0ecfc6626", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:08.636764Z", + "start_time": "2025-02-21T09:39:08.632400Z" + } + }, + "outputs": [], + "source": [ + "from agent_prompts.file_editor_tool import file_editor_prompt, file_editor_schema\n", + "from agent_prompts.pr_system_prompt import system_prompt as pr_prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "5994dc13d66f37ab", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:10.162824Z", + "start_time": "2025-02-21T09:39:10.150173Z" + } + }, + "outputs": [], + "source": [ + "editor_tool = ComponentTool(\n", + " name=\"file_editor\",\n", + " description=file_editor_prompt,\n", + " parameters=file_editor_schema,\n", + " component=GithubFileEditor()\n", + ")\n", + "\n", + "@tool(inputs={\"title\": \"pr_title\"})\n", + "def create_pr(pr_title: str, body: str) -> str:\n", + " \"\"\"\n", + " Use this to create a Github PR once you are done with your changes.\n", + " \"\"\"\n", + " return pr_title + \"\\n\\n\" + body" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "bc3e7450f1626485", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:13.259149Z", + "start_time": "2025-02-21T09:39:13.244996Z" + } + }, + "outputs": [], + "source": [ + "pr_chat_generator = AnthropicChatGenerator(model=\"claude-3-5-sonnet-latest\", generation_kwargs={\"max_tokens\": 8000})" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "16a13b74959a1020", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:25.248844Z", + "start_time": "2025-02-21T09:39:25.236968Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mathislucka/Library/Application Support/hatch/env/virtual/haystack-experimental/0WxCzKa9/haystack-experimental/lib/python3.12/site-packages/haystack/components/converters/output_adapter.py:79: UserWarning: Unsafe mode is enabled. This allows execution of arbitrary code in the Jinja template. Use this only if you trust the source of the template.\n", + " warn(msg)\n" + ] + } + ], + "source": [ + "pr_agent = Agent(\n", + " chat_generator=pr_chat_generator,\n", + " system_prompt=pr_prompt,\n", + " tools=[editor_tool, create_pr, repo_viewer_tool],\n", + " exit_condition=\"create_pr\",\n", + " state_schema={\"repo\": {\"type\": str}, \"branch\": {\"type\": str}, \"title\": {\"type\": str}},\n", + ")\n", + "\n", + "pp.add_component(\"pr_agent\", pr_agent)\n", + "adapter = OutputAdapter(\n", + " template=\"{{issue_messages + [((agent_messages|last).tool_call_result.result)|user_message]}}\",\n", + " custom_filters={\"user_message\": ChatMessage.from_user},\n", + " output_type=List[ChatMessage], unsafe=True\n", + ")\n", + "pp.add_component(\"adapter\", adapter)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7ba94d5c9e8b144e", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:26.881804Z", + "start_time": "2025-02-21T09:39:26.878449Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "🚅 Components\n", + " - issue_fetcher: GithubIssueViewer\n", + " - issue_builder: ChatPromptBuilder\n", + " - agent: Agent\n", + " - repo_forker: GithubRepoForker\n", + " - pr_agent: Agent\n", + " - adapter: OutputAdapter\n", + "🛤️ Connections\n", + " - issue_fetcher.documents -> issue_builder.documents (List[Document])\n", + " - issue_builder.prompt -> agent.messages (List[ChatMessage])\n", + " - issue_builder.prompt -> adapter.issue_messages (List[ChatMessage])\n", + " - agent.messages -> adapter.agent_messages (List[ChatMessage])\n", + " - repo_forker.issue_branch -> pr_agent.branch (str)\n", + " - repo_forker.repo -> pr_agent.repo (str)\n", + " - adapter.output -> pr_agent.messages (List[ChatMessage])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pp.connect(\"repo_forker.issue_branch\", \"pr_agent.branch\")\n", + "pp.connect(\"repo_forker.repo\", \"pr_agent.repo\")\n", + "pp.connect(\"agent.messages\", \"adapter.agent_messages\")\n", + "pp.connect(\"issue_builder.prompt\", \"adapter.issue_messages\")\n", + "pp.connect(\"adapter.output\", \"pr_agent.messages\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "476acf2e3460e298", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:39:28.031720Z", + "start_time": "2025-02-21T09:39:27.926994Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pp.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d9ff042e9fe11634", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:41:59.664422Z", + "start_time": "2025-02-21T09:40:49.053021Z" + } + }, + "outputs": [], + "source": [ + "result = pp.run(data={\"url\": issue_url, \"title\": \"# Agent PR\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "fbe16e1f12b2a3d8", + "metadata": { + "ExecuteTime": { + "end_time": "2025-02-21T09:42:22.738239Z", + "start_time": "2025-02-21T09:42:22.732248Z" + } + }, + "outputs": [ + { + "data": { + "text/markdown": "# Comment from Agent\n\n# Agent PR\n\nThis PR fixes an issue where OpenSearchEmbeddingRetriever's custom_query would fail if no filters were provided.\n\n**Current Behavior**\nCurrently, when using `custom_query` without filters (either empty dict `{}` or `None`), the OpenSearchEmbeddingRetriever errors out with: \n```\nFilterError: 'operator' key missing in {}\n```\n\nThis happens because the code unconditionally tries to normalize filter values, even when no real filters are provided.\n\n**Changes Made**\nModified `_prepare_embedding_search_request` to only process and include filters in the query placeholder dictionary when filters are actually provided.\n\n```diff\n- query_parameters = {\n- \"$query_embedding\": query_embedding,\n- \"$filters\": normalize_filters(filters), # type:ignore\n- }\n+ query_parameters = {\"$query_embedding\": query_embedding}\n+ if filters:\n+ query_parameters[\"$filters\"] = normalize_filters(filters)\n```\n\nThis makes filter inclusion truly optional when using custom queries, as is defined in the code documentation.\n\nFixes #1268", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Markdown, display\n", + "\n", + "display(Markdown(\"# Comment from Agent\\n\\n\" + result[\"pr_agent\"][\"messages\"][-1].tool_call_result.result))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb9ed2b256142d77", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}