From e14a6cf98bac03e42699ffe8f73ef17fadca5140 Mon Sep 17 00:00:00 2001 From: Eugene Yurtsev Date: Tue, 10 Dec 2024 17:06:08 -0500 Subject: [PATCH] Add multi turn conversation input --- docs/docs/how-tos/index.md | 3 + .../multi-agent-multi-turn-convo.ipynb | 377 ++++++++++++++++++ 2 files changed, 380 insertions(+) create mode 100644 docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md index d93488d94..0f01fb73b 100644 --- a/docs/docs/how-tos/index.md +++ b/docs/docs/how-tos/index.md @@ -94,7 +94,10 @@ These how-to guides show common patterns for tool calling with LangGraph: ### Multi-agent +[Multi-agent systems](../concepts/multi_agent.md) are useful to break down complex LLM applications into multiple agents, each responsible for a different part of the application. These how-to guides show how to implement multi-agent systems in LangGraph: + - [How to build a multi-agent network](multi-agent-network.ipynb) +- [How to add multi-turn conversation in a multi-agent application](multi-agent-multi-turn-convo.ipynb) See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures. diff --git a/docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb b/docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb new file mode 100644 index 000000000..98cc4ba64 --- /dev/null +++ b/docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb @@ -0,0 +1,377 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "a2b182eb-1e31-43c8-85b1-706508dfa370", + "metadata": {}, + "source": [ + "# How to add multi-turn conversation in a multi-agent application\n", + "\n", + "!!! info \"Prerequisites\"\n", + " This guide assumes familiarity with the following:\n", + "\n", + " - [Node](../../concepts/low_level/#nodes)\n", + " - [Command](../../concepts/low_level/#command)\n", + " - [Multi-agent systems](../../concepts/multi_agent)\n", + " - [Human-in-the-loop](../../concepts/human_in_the_loop)\n", + "\n", + "\n", + "In this how-to guide, we’ll build an application that allows an end-user to engage in a *multi-turn conversation* with one or more agents. We'll create a node that uses an [`interrupt`](../../reference/types/#langgraph.types.interrupt) to collect user input and routes back to the **active** agent.\n", + "\n", + "The agents will be implemented as nodes in a graph that executes agent steps and determines the next action: \n", + "\n", + "1. **Wait for user input** to continue the conversation, or \n", + "2. **Route to another agent** (or back to itself, such as in a loop) via a [**handoff**](../../concepts/multi_agent/#handoffs).\n", + "\n", + "```python\n", + "def human(state: MessagesState) -> Command[Literal[\"agent\", \"another_agent\"]]:\n", + " \"\"\"A node for collecting user input.\"\"\"\n", + " user_input = interrupt(value=\"Ready for user input.\")\n", + "\n", + " # Determine the active agent.\n", + " active_agent = ...\n", + "\n", + " ...\n", + " return Command(\n", + " update={\n", + " \"messages\": [{\n", + " \"role\": \"human\",\n", + " \"content\": user_input,\n", + " }]\n", + " },\n", + " goto=active_agent,\n", + "\n", + "def agent(state) -> Command[Literal[\"agent\", \"another_agent\", \"human\"]]:\n", + " # The condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.\n", + " goto = get_next_agent(...) # 'agent' / 'another_agent'\n", + " if goto:\n", + " return Command(goto=goto, update={\"my_state_key\": \"my_state_value\"})\n", + " else:\n", + " return Command(goto=\"human\") # Go to human node\n", + " )\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "faaa4444-cd06-4813-b9ca-c9700fe12cb7", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's install the required packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "05038da0-31df-4066-a1a4-c4ccb5db4d3a", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "%pip install -U langgraph langchain-openai" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "0bcff5d4-130e-426d-9285-40d0f72c7cd3", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(var: str):\n", + " if not os.environ.get(var):\n", + " os.environ[var] = getpass.getpass(f\"{var}: \")\n", + "\n", + "\n", + "_set_env(\"OPENAI_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "c3ec6e48-85dc-4905-ba50-985e5d4788e6", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "6696b398-559d-4250-bb76-ebb7c97ce5f3", + "metadata": {}, + "source": [ + "## Travel Recommendations Example\n", + "\n", + "In this example, we will build a team of travel assistant agents that can communicate with each other via handoffs.\n", + "\n", + "We will create 3 agents:\n", + "\n", + "* `travel_advisor`: can help with general travel destination recommendations. Can ask `sightseeing_advisor` and `hotel_advisor` for help.\n", + "* `sightseeing_advisor`: can help with sightseeing recommendations. Can ask `travel_advisor` and `hotel_advisor` for help.\n", + "* `hotel_advisor`: can help with hotel recommendations. Can ask `sightseeing_advisor` and `hotel_advisor` for help.\n", + "\n", + "This is a fully-connected network - every agent can talk to any other agent. \n", + "\n", + "To implement the handoffs between the agents we'll be using LLMs with structured output. Each agent's LLM will return an output with both its text response (`response`) as well as which agent to route to next (`goto`). If the agent has enough information to respond to the user, the `goto` will be set to `human` to route back and collect information from a human.\n", + "\n", + "Now, let's define our agent nodes and graph!" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "aa4bdbff-9461-46cc-aee9-8a22d3c3d9ec", + "metadata": {}, + "outputs": [], + "source": [ + "from typing_extensions import TypedDict, Literal\n", + "\n", + "from langchain_openai import ChatOpenAI\n", + "from langchain_core.messages import HumanMessage\n", + "from langgraph.graph import MessagesState, StateGraph, START, END\n", + "from langgraph.types import Command, interrupt\n", + "from langgraph.checkpoint.memory import MemorySaver\n", + "from langgraph.prebuilt import create_react_agent\n", + "\n", + "model = ChatOpenAI(model=\"gpt-4o\")\n", + "\n", + "\n", + "def make_agent_node(*, name: str, destinations: list[str], system_prompt: str):\n", + " def agent_node(state: MessagesState) -> Command[Literal[*destinations, \"human\"]]:\n", + " # define schema for the structured output:\n", + " # - model's text response (`response`)\n", + " # - name of the node to go to next (or 'finish')\n", + " class Response(TypedDict):\n", + " response: str\n", + " goto: Literal[*destinations, \"finish\"]\n", + "\n", + " messages = [{\"role\": \"system\", \"content\": system_prompt}] + state[\"messages\"]\n", + " response = model.with_structured_output(Response).invoke(messages)\n", + " goto = response[\"goto\"]\n", + " if goto == \"finish\":\n", + " # When the agent is done, we should go to the \n", + " goto = \"human\"\n", + "\n", + " # Handoff to another agent or halt\n", + " ai_msg = {\"role\": \"ai\", \"content\": response[\"response\"], \"name\": name}\n", + " return Command(goto=goto, update={\"messages\": [ai_msg]})\n", + " return agent_node\n", + "\n", + "\n", + "travel_advisor = make_agent_node(\n", + " name=\"travel_advisor\",\n", + " destinations=[\"sightseeing_advisor\", \"hotel_advisor\", \"human\"],\n", + " system_prompt=(\n", + " \"You are a general travel expert that can recommend travel destinations (e.g. countries, cities, etc). \"\n", + " \"If you need specific sightseeing recommendations, ask 'sightseeing_advisor' for help. \"\n", + " \"If you need hotel recommendations, ask 'hotel_advisor' for help. \"\n", + " \"If you have enough information to respond to the user, return 'finish'. \"\n", + " \"Never mention other agents by name.\"\n", + " ),\n", + ")\n", + "sightseeing_advisor = make_agent_node(\n", + " name=\"sightseeing_advisor\",\n", + " destinations=[\"travel_advisor\", \"hotel_advisor\", \"human\"],\n", + " system_prompt=(\n", + " \"You are a travel expert that can provide specific sightseeing recommendations for a given destination. \"\n", + " \"If you need general travel help, go to 'travel_advisor' for help. \"\n", + " \"If you need hotel recommendations, go to 'hotel_advisor' for help. \"\n", + " \"If you have enough information to respond to the user, return 'finish'. \"\n", + " \"Never mention other agents by name.\"\n", + " ),\n", + ")\n", + "hotel_advisor = make_agent_node(\n", + " name=\"hotel_advisor\",\n", + " destinations=[\"travel_advisor\", \"sightseeing_advisor\", \"human\"],\n", + " system_prompt=(\n", + " \"You are a travel expert that can provide hotel recommendations for a given destination. \"\n", + " \"If you need general travel help, ask 'travel_advisor' for help. \"\n", + " \"If you need specific sightseeing recommendations, ask 'sightseeing_advisor' for help. \"\n", + " \"If you have enough information to respond to the user, return 'finish'. \"\n", + " \"Never mention other agents by name.\"\n", + " ),\n", + ")\n", + "\n", + "def human_node(state: MessagesState) -> Command[Literal[\"hotel_advisor\", \"sightseeing_advisor\", \"travel_advisor\", \"human\"]]:\n", + " \"\"\"A node for collecting user input.\"\"\"\n", + " user_input = interrupt(value=\"Ready for user input.\")\n", + "\n", + " active_agent = None\n", + "\n", + " # This will look up the active agent.\n", + " for message in state['messages'][::-1]:\n", + " if message.name:\n", + " active_agent = message.name\n", + " break\n", + " else:\n", + " raise AssertionError(f'Could not determine the active agent.')\n", + " \n", + " return Command(\n", + " update={\n", + " \"messages\": [{\n", + " \"role\": \"human\",\n", + " \"content\": user_input,\n", + " }]\n", + " },\n", + " goto=active_agent,\n", + " )\n", + " \n", + "\n", + "builder = StateGraph(MessagesState)\n", + "builder.add_node(\"travel_advisor\", travel_advisor)\n", + "builder.add_node(\"sightseeing_advisor\", sightseeing_advisor)\n", + "builder.add_node(\"hotel_advisor\", hotel_advisor)\n", + "\n", + "# This adds a node to collet human input, which will route \n", + "# back to the active agent.\n", + "builder.add_node(\"human\", human_node)\n", + "\n", + "# We'll always start with a general travel advisor.\n", + "builder.add_edge(START, \"travel_advisor\")\n", + "\n", + "\n", + "checkpointer = MemorySaver()\n", + "graph = builder.compile(checkpointer=checkpointer)" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "d77921f6-599d-443f-8b15-56b1adafd3a8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAIjCAIAAACFxVs1AAAAAXNSR0IArs4c6QAAIABJREFUeJzs3WdcE8nfAPBJaEG6RIogoCIqXURFsJ4iqCDYu6JyngUEEU/v7B3LKSAqKqfYC56ioMJRxF4QRUAFpIl0CCEQ0pN9XqwPxx9DhJBkkzDfjy9kszvzo+SX2dkpOARBAARBEBbwWAcAQVD3BRMQBEGYgQkIgiDMwAQEQRBmYAKCIAgzMAFBEIQZRawDgCSH1sQjVzObGznNFC6Xw+NysA6oA/B4oKiM76GpoKapqKOnrKalgHVEkCjh4DgguUepYxdkUotymhEEKCnhemgpqGkqqmkpclg8rEP7OQVFHJ3KbW7k0ho5PC7gsHl9rdXM7TV09JSwDg0SAZiA5BmTxnsRV0dv5uroKfe1VjMwI2AdUVfVfGMWZVMbatmKSjhnT2IPDdggkm0wAcmtzMeU9ESSsyfRaqQm1rGIXu6bpudxdUPG6ThM0MY6Fkh4MAHJp4ToKgMzVftxWlgHIl7Zzygln5s9f+2NdSCQkOBTMDkUE1pmbq8u99kHAGAzSsvGRfvSvq9YBwIJCbaA5M3Vg6WjvIgmg3pgHYjkVJUwEi9WLd1uhnUgUKfBBCRXEi9V9bVSs3DQwDoQSSv+2PzxZaOHryHWgUCdAxOQ/Mh6SuFykCHju2mnbPYzCpuFOPzSTb99GQX7gOQEl4M8u1vXbbMP2h/0LqWe0SwDg5ugFjAByYkXcSQXT12so8CYsyfxRVwd1lFAnQATkDygNfIaSWy7sRJq/uTk5DCZTKwuF8DSSZPJ4FHq2OIoHBIHmIDkQWF2k5q2hKb1xcXF+fj40Ol0TC7/KS1dpcIsqpgKh0QOJiB5UJzT3NdKTTJ1Cd14QR93iKnt06KvtVpRdrNYq4BECM6Gl3lcDqBTuaaDRT/wh8FghISEPHnyBAAwZMiQ4ODgt2/fhoSEAAAmTpwIANixY4enp2d1dfXJkyefP39OpVJNTU2XLVvm7u4OAGhoaJg4cWJAQEBeXl5aWtqgQYO8vLx+vFy0MRv2JeDxOHoTVxVOE5MFMAHJPEodi8MWy1iK8+fPx8fHr1q1ikgkxsfHq6qquri4LFq06PLly6Ghoerq6iYmJgAADofz8ePHWbNmaWtrp6ambt26tU+fPlZWVmghf//99+zZsyMjIxUUFPT19X+8XOR4PKShjg0TkEyACUjmNTdyxbRKTkVFhaqqqo+Pj6Kiore3N3rQ2NgYAGBtba2t/b3P28jIKCYmBofDAQC8vLwmTpyYlpbWkoBsbGzWrl3bUuaPl4ucmpZic6MsrHUEwT4gOdDcyFHTFMsHyeTJkxkMhr+/f0FBgeAz8/Pzg4KC3N3dp0+fzuVySSRSy0vDhw8XR2wCqGkq0Bq5Eq4UEg5MQLIPAUoqYvk9Ojs7h4WFkUikefPm7d27l8Ph36xIT09funQpi8XasWPHoUOHtLS0eLz/RgOqqqqKIzYBlJTxcHi/rIC3YDJPVV2hkSSukS/Ozs5OTk7Xrl07duyYoaHhihUr0OOtZ/BERUUZGxuHhoYqKip2MOOIdQJQYz2b2FtFfOVDIgRbQDJPTVORJp4uDxaLBQDA4/ELFy7s1atXbm5uS36pra1tOa2hocHCwgLNPiwWi0ajtW4BtfHj5SLX3MjtoQl7oGUDbAHJPHUdRTH1AV2/fv3x48dTpkypra2tra21tLQEANjZ2SkoKBw5cmTatGlMJnPmzJmOjo5xcXF3797V0tK6cuVKY2NjYWFhe22cHy8XediEHngNHbhitGyALSCZR+iBZzF5lcUMkZdsbGzMYrGOHTsWGxs7b968xYsXowe3bNny9evXI0eOJCUlAQBWr149cuTIw4cPHzp0aMSIEQcPHqyrq3v79m17Zba5XLRIlayGWramLvxklQ1wOQ55kJFCZtJ4zt1+MioA4G0SmcPmOU2BPwrZAD8o5EFfa/U3D0kCTqDT6ZMnT+b7krGxcVlZ2Y/Hx44du2vXLtHFyF9ERMStW7d+PK6iosJ30oaxsfHly5cFFEiuZtmN0RFpjJAYwRaQnEi8UNXPVn3AEHW+ryIIUllZyfclHI7/34CqqqqOjtjfyRQKpbmZz9QtFoulrKz843FFRUU9Pb32Siv5RMt+3gDXqJchMAHJiaZ6zu2Ism6+LvLVg6XuSw16GvDJXJB0gp3QckKjp+KgYZr5GU1YB4KZoqxmU0s1mH1kC0xA8mPE5J6ZjxtqSsW73oV0IlezXj6og2tCyhyYgOTKnKA+t8LLuJxud1t99VDp/N9NsY4C6jTYByRveFzk3I6Smf5GOvrd4makqZ5z46/SZTv7KijhsI4F6jSYgOQQwgNXD3119ujV11rOtyf8lk9LvV6zYJOJmKbjQuIGE5DcenK7rrac4eJJNDAjYB2L6NV8Y76Iq9PWUx43qxfWsUDCgwlInlUUMV7E1en1UdE3JfSzVldSkfmbFC4bKcppri5llBfQXTyJxhaSXusDEi2YgORfySda/rum4myqmZUaQU2hh4ZCD03FHuoKXK4M/OoVFPD0Zg6tkUtr4jDpvIJMaj9rtQEOGv1sJLQIPyRWMAF1I2Vf6PVVLFoTh9bEBQAw6SLeRPTNmzeOjo54vCi7YxSV8HgF0ENDQU1Tsae+MmzyyBmYgCCRcXZ2fvTokYoKXAwM6ij47ACCIMzABARBEGZgAoJExsrKCt2cB4I6CCYgSGQ+fvwIuxShToEJCBIZHR0d2AKCOgUmIEhkyGQybAFBnQITECQyxsbGsAUEdQpMQJDIlJWVwRYQ1CkwAUEiY2dnh3UIkIyBCQgSmQ8fPmAdAiRjYAKCIAgzMAFBIqOrqws7oaFOgQkIEhkSiQQ7oaFOgQkIEhk9PT3YAoI6BSYgSGRqampgCwjqFJiAIAjCDExAkMhYWFjAWzCoU2ACgkQmPz8f3oJBnQITEARBmIEJCBIZGxsbrEOAZAxMQJDIZGdnYx0CJGNgAoIgCDMwAUEiA2fDQ50FExAkMnA2PNRZMAFBEIQZmIAgkYHb8kCdBRMQJDJwWx6os2ACgiAIMzABQSID9wWDOgsmIEhk4L5gUGfBBASJzMCBA2ELCOoUmIAgkcnLy4MtIKhTYAKCIAgzMAFBImNoaAhvwaBOgQkIEpnKykp4CwZ1CkxAkMjY2tpiHQIkY2ACgkQmKysL6xAgGQMTECQy9vb2WIcAyRiYgCCRyczMxDoESMbABASJjKmpKXwKBnUKDj62gLpo8uTJSkpKOByupqZGV1cXj8dzudw+ffpERkZiHRok7RSxDgCSeYqKihUVFej/q6qqAABaWlpLly7FOi5IBsBbMKirftyNZ8CAASNHjsQoHEiWwAQEddXs2bMNDQ1bvtTU1FyyZAmmEUEyAyYgqKuGDBkyYMAAtDMRQZBBgwY5OztjHRQkG2ACgkRgyZIlRCIR7f1ZuHAh1uFAMgMmIEgE7O3tLS0tAQAWFhYuLi5YhwPJDPgUTOrQmrh15SwWk4t1IJ0zZezy+m/Knr/MKfhAxTqWzlFWxuv2VlHTUsA6kO4IjgOSIkwaL+V6dWUxw2SQGoPOwzqc7qKHusLXT1R9U8K42XpqmjANSRRMQNKCTuXejigf5W3Q01AZ61i6o4Ya1pNbVd5rjWAOkiTYByQtroSUTlpiBLMPVrT1lKeu7HNxTwnWgXQvsAUkFTIfNdDpwNpFG+tAuru8dAqPyx3u1hPrQLoL2AKSCpVfGera8IEA9tR1lCqLGVhH0Y3ABCQVOEyeZk9484U9jZ7KPA7WQXQnMAFJBRqVy+PBe2HsITykuYmNdRTdCExAEARhBiYgCIIwAxMQBEGYgQkIgiDMwAQEQRBmYAKCIAgzMAFBEIQZmIAgCMIMTEAQBGEGJiAIgjADExAEQZiBCUhWcbnc7GzJ7cUeFn5wxqxJIixw9tzJR4/tF3xOyMGdq1YvFmGlkLSBCUhWHf5rz9HQn7yBZV0PNbUePdSwjgISI7gGjaxiMZkCXkUQBIfDSTAcsVjnt1Ek5cjHT0MuwQQkk0IO7XyUlgQAGD/BEQBw9co9Q4Pey1bM6WvW38ys/+0715lMRsyNhOLigkuXo7JzMgEAgwZarVoVONBiMJPJnD138ojhzlv+3IuWlpmZsX7Dbwf2hTo5jaqsqjh58mjGu9fKyioWAwYtX75m0EDLjgeWnZ35Y43oS1wu9+Kls/H37zAYdHt7RyaDAQAQEExoeEh1dZW1td3xsL8BAFevRcfevdnU1GhuPtBn6W9DHYYDAD59zok8HZqX94lAUHUeOWb16vWaGproDePjJynBQVtPRh4rL/925vSVAeYDxfB7gLoKJiCZtGjB8tqa6srK8j827wYA6PYkosfT018ymIz9e4/R6DR1dfWqqgomi7l4kS8ej797N2bzH+uuXYkjEAiTXKfef3CHRqP16NEDAJCU/EBf32D4cGcSqc5/3XIjoz5+a4NxONy//94PCPSNPHmpb9/+HQysvRrRpBAXf3uy+zQ7W4c36S+aqE0AABUVlfaC2RC09ezZ42ixGe/enI2KmDDBfcQw5zfpL+g0GgCgpKRoQ/AqM7P+v2/cQWkgn4+OrKmp+uvIKfSS5mbq3+dPBgZsZjDo5v0txPN7gLoKJiCZZGxsoqWlXU8m2djYtz6uoKi4bct+VVVV9MuJEye7uk5B/z9woGXQhlXZOZnDHJ08PWb8c/va06epbm4eTCbzydOUuXOW4PH4S5ejdLR7/nX4lKKiIgDAdeKURUu84x/c8V8b3MHA2qsx/0tuXPztRQuXr1i+BgDg5uaR+SEDPa29YIY5OsXEXKYz6GheAwBM95pjZWXbUv7lK3/j8fhDByM01DUAABoamvtDtn/48M7OzgEAwGKxgoO2Dh5sLaIfOSQWMAHJlcGDrVuyDwAAh8M9ffboZszlr1+L0fYFuZ4EADA17WtjY5+c8tDNzeP5i8cMBmPKZC8AwOvXz2tqq6d4jG4pgc1m19ZUdzyA9mp8+jQVADBr1n+7NuPx3x+AtBdMa04jRmloaO4/sM3fb6OT0yj0YOaHjCFDhqHZBwAwbNhIAEBe/ic0AREIBJh9pB9MQHJFlaDa+suLl6LOR0fOnDF/pa8/qb5u1+7NPOT7foeeU2eEHNpJItUlJT8Y5TKuZ09dAEA9mTRy5OiVvv6tC1FTU+94AO3VWF1Tpa6urqWpxfcqvsG0pqtLjAg/d+LU0T+2BFpb223feqBXL73mZqq2lk7LORoamgCAurra7z8K1R4dDxvCCnwML8MEb6nEZDKvXjs/dYq339oNNjb2loNtWr86ZswENTX123eup6e/nDZtFnpQQ0OTQmkwMTFr/U9Xl9jBeATUqK2lQ6VSWSwW3wv5BtOGiYnZwQPhfx05VVxccPDQTgAAkajX2EhpOYFMrgcAqP9/gwiSCTABySoCQbW+nsTjtbuDM4NBZzKZFv//EIrS2AAAaDlfRUXF1XXKtesXjIz6DLF3RA86OAzPyfmQl/+5pRA6nY7+R0lJmU6ncTiCtowQUCN6MCU1ge+FfINpA01eDkOGOTmNzv+SCwCwsrLN/JDBYHzfRefJkxQAQJtOMUjKwVswWWVn6/Aw4d7RY/ttrO01NDSdnce0OUFLS7tfP/Pbd6737KnbTKVeuHgGj8cXFRW0nOA5dcbt29c9PWa0HFm6ZOWrV882/r52zuxFOjo937x5weVx9+7+CwAwwHwgg8HYuXvT6lXrjXob8w1JQI3jx7leuhx19Nj+4uLCAeYDP37KarlXai+Y1j7nfty1e5O31xxV1R5v3rxARwYsWrA8NTVx0x/+nh4za2qqLlw8M8Te0d5uaNd+rpBEwRaQrHJ1nTLde07a46QzUcc/fsrie862LftVCaq79/xxI+bS6tXrFy9akZgYx2Z/33bGzKyf49ARkyZ5tJxv1Ns4IvyclZXtlavnTpz8q4FCnjhhMvrShAnuc2Yvys39WFJcKCCq9mpUUFA4eOC4o6PTvbhbkWfC8Hi8ltb/bAP7YzCtKSspm5r0vXr1fFRUhK3tkOAN29BHgYdCIths9qHDu27cvOQ6ccruXUfggEPZArdmlgo3/vo2fLIe0UgF60C6O0odO+1mxaI/TLEOpLuAt2BQ51Cp1PkL+bdTflsZ4DF1usQjgmQYTEBQ5/To0ePM6at8X9LU4P+UHYLaAxMQ1Dl4PN7QoDfWUUByAnZCQxCEGZiAIAjCDExAEARhBiYgCIIwAxMQBEGYgQkIgiDMwAQEQRBm4Dgg7NXW1rZM6YakR3l5eXFxcWFhYV5eXkFBQX19fXJyMtZByRuYgLBBo9FycnKGDx+em5sbGBg4y+ko1hFB3zU30zZs2FBZWUmj0ahUKplMRo/36tUL69DkELwFk6h3794BACgUipubW1paGgDAzMwsISFBQwMuoyUteDzeq1ev8vLyysrKGhoacP8vIYH/YkZQV8AEJHafP3+m0WgAABcXl3PnzgEA1NTUnj59+vvvv6NLFwMAtPWU4aIE0gDhIabmur/++qu29v+sFsLj8XJycgQs/wYJByYgsSgpKamrqwMA+Pj47Nu3D/3Dff78eUREBAAA3XOiNUIPPKkcdgNhj1TJVFLB+fj4BAQE6Or+tzS1iopKcnLyiBEjqqqqAADFxcWYhik/4HpAIkMikRgMhpGR0Y4dO3JycsLCwoyNjel0euttKvhKSEj4lscwIzo7eehJKliIv7f/1vUZQDC3V0c/MPbs2YN+kBgYGMTHxwMAGAwGgUD49ddfv3379uDBAx6PR6fT4R200GAC6hIajVZUVGRtbX3z5s2UlJQ1a9bY2dlRKBQtrZ8sTMHlcp8+fTpu3LgvX75cuHBh7ty5lCJDFhMMc+voCvCQyL1PreeyuePn/NfZ/OnTp82bN5eVlaGdd63V1tYSiUQmk+nu7j58+PBDhw617K0IdRxMQMLIzc0dNGhQfn7+ihUrli9fvmzZsoaGhja9BnxxuVw2m00gEJydnadNm7Z58+bWr76IJ9EaeURjQi8jAg7eHEsKwgN1FYz6ShYOzxs3q+2jrtra2kWLFiUmJgoo4cuXLwMGDCgpKVm4cOGyZct8fX2pVKq6eie2M+q2YALqqJKSEjMzs48fPy5fvnz69OmbN2/u7Cfe8ePHL126lJiYqKOj0945RdnNhR+oLCaPVMF/B5uOoFKpSkqKKioEoUsQB2pTEw6P69QuY8Ih19fzEF7L4tA4HA4HcACHAwDw/ZAg9lZWVMb3tVYbMKSrsTEYjPz8fFtb29jY2Ojo6N27d9va2vJ4vJZdGKE2YAISpKGhQV1dHY/HT5482cLC4vjx42QyWUND48de5Pbk5uaeO3fOzc1twoQJ7969c3BwEGvAXC43MzMzNzd34cKFHThdonx9fT99+jR16tQtW7aItaIHDx6Eh4ejfTctu6fhcDgEQTIyMsRadWvfvn3jcDh9+/bdvHlzQ0NDcHCwubm5xGqXFTAB8cHhcBQVFVevXv3ly5f4+HgVFRUSiUQkdqJ3Jjk5ua6ubt68effu3VNTU5swYYI44wVo6tm2bduOHTsUFBQ6nh8lac6cOYWFhQoKCi4uLseOHRNrXdu3b09ISGj91FzC2aeN9PR0dXX1wYMHb9u2TUVFJSgoCPYWoWDL8Dt0MsTx48ddXFzQ/wcFBSUnJxMIBBwO18Hs8/btWwBATk5OcnKyjY0NAGDatGkSyD4AgD179owdO1ZFRUU6sw+a1nE4HI/He/r06ZIlS8Ra19atW01MTFof6dTnh8gNGzZs8ODBAIANGzZYW1s3NzcDAAIDAy9fvtzNWwAwAYH09PS5c+c+e/YMHSuYkpKCdh8OGDCggyVwOBwajebk5PTixQsAgLW1dUhIiJWVlZgDBwCAqqoqdGzRzp073dzcJFCjcKhUaut32sePH728vMrLy8VUnbKycmBgYM+ePdEvcTjcxo0bAQBNTU1iqrGDtLW1vb290VkdPj4+dXV16GazR48ezczMxDY2THTTBFRXV7d58+Y9e/agY5H37ds3ceJEAICDgwM6NLmDzpw5M3bsWDabraio+OzZs3Xr1okzaj4OHDjg4cF/kxyp0tTUxOVyW77E4XDl5eWrVq0SX42jRo0aO3Ys2vtrZGSE/n79/f2vXuW/pYfk2dvbBwYGKikpAQBMTEzi4uLQ1Hz//n0mk4l1dBLSjRIQh8O5ePHirl27AACNjY0TJkxAn4Lb2Nh0qnewvr7+1KlTBQUF6Eyu+/fvq6qqKisrS/LeJycn59q1awCAsLAwMzMzidUrtObm5pYdWVEIgrROSeKwZcsWU1NTJSWl2NhY9Eh0dLSysjIA4P3792KturNmzZq1bds2AICent7r16/RKTvv3r2rrKzEOjQxQ+RdZmZmZGQkgiDV1dWhoaG5ubnClcNisd6+fYsgyNmzZ8+ePctisUQdaUcVFRUtWbKksbERqwCEkJmZOWnSpKFDhzo4ODg7OzMYDGzjSU1NnTZtGp1OxzYMwVJTU6dOnfrixQsEQSorK7EORyzkNgG9fPmSy+Uymcxly5Zdu3ati6V9+/ZtxIgRDx48EFF0Qvr48SOCIGVlZdiGIZwxY8a4u7sjCBITE7N//36sw0G+fftWW1uL/gfrWARBP2l27do1a9YsNGB5Im8JCG2YuLm5rVmzhsfjdbG0S5cuLVmyBEEQMpksogCFl5qa6uPjg3UUonHw4EGsQ/iPl5dX1z+iJKCwsLCurg5BED8/v9OnT3M4HKwjEgH5SUDoE3T04wJ95iK0jIwMNOOcPHlSGpq+zc3NCIKkpaVhHYjciouLQ9/hWAfSIaWlpZGRkeif6OXLl6XhT1Rosj0QsaCg4Pr1615eXjY2NmlpaU5OTp16hsXXli1bampqwsPDfzqLXTKeP38eExMTGhqKdSCiVF5enp+fP378eKwD+R83btzIyclBn43KisjIyIcPH969e5dOp+NwuK7//Usa1hlQGLm5uVlZWWgL5fbt21wut4sFNjc3h4eHP378GEGQ8vJyEYUpGnv27ME6BNHj8XhDhw7FOgo+7t+/TyaTKRQK1oF0WmNjo4uLS1hYGNaBdI4sJaCmpia0C3P+/Pn5+fkiKRNtvkZFRZ0/f77rfUaihd4XyKtHjx5VVFRgHQV/RUVFBw4cwDoKYbx58wZ9AhMWFkYikbAO5+dk4xasvr5+x44d/fv3DwwMrK+vbxnh2hXNzc2bNm2ytrYW63A44SAI4urqevHixd69e2MdSzcVExODw+FmzZqFdSDC4HA4V65cYbPZvr6+nz9/RmeBSCmsM6AgRUVFZ86cQRDky5cvz58/F1Wxr169QhCkpKQEHWEhbRobGxsaGqThuZtYFRcX37t3D+soBEFb3I8ePcI6kC5JTEx0cnLKy8vDOhD+pHQkdENDAwBg27ZtBgYGAABzc3NnZ2eRlLxjx44rV64AAExNTUeOHCmSMkUoPz//2bNnWlpaHVneTKYhCHLhwgWsoxAEnRKYkpKC7l8ioyZNmvT48WN08v3evXsfP36MdUT/C+sM2FZqaqqLi4vIe4Kzs7PRx9hfvnwRbcmiNW/ePKxDkBAOhyPlLaAW0tlSFkJ2dvbGjRsRBJGeAY3SkoBev34dExOD9p/RaDTRFv7+/fulS5dKzw8dkkX+/v5YhyAyFRUVjo6O0jCyTCpuwTIyMs6fP29nZwcAcHJyEuEAnBMnTgAAevfuHR0dje2KMILR6fQ1a9ZgHYWkHTt2rM0MVWm2fv16uRmNZWho+Pr1azU1NQBAfHx8WVkZZqFgmPyuXr26dOnSlpG+Irds2TK0VSX90Kd7WEchadI5FEgAtFtazmRlZXl5eZWUlGBSOzYJCJ1Oefz48YaGBpEXXllZ+fDhQwRB2Gy2yAuHRIXNZv/zzz9YR9FpTU1NctlPhz513bNnj4R7KiR9C5aVlTVs2DB08JGfn99P98/qrNra2hUrVtjb2/PdgFQKFRUV3bp1C+soMKCoqDhjxgyso+g0dXX106dPR0ZGYh2IiKFPXYcPH75v3z50JJFk6pXcQMTHjx+PHTv2/fv3dnZ24tilpL6+nsFg4PF49Mm9rJg3b97evXu74X4JmZmZhYWFM2fOxDoQiA90RbTly5eLuyJJtIAYDMaUKVNqa2sBAEOGDBFH9ikoKJg7dy6RSJSt7NPU1BQaGtoNsw8AIDY2Fl2cUEYlJCTITZ/0j5YvX06n09FNFsRKvC2ggoICTU1NFRUVBoOhr68vvorQ5pX4yodETlSrF2AoNja2d+/ew4cPxzoQcWGz2UpKSn/88ce2bdvEtY+Q+LqXHj16NHfuXCaTKb4qEARZs2aNWMsXq9mzZ8vEjEGoO3v58mVAQICYChfLLVhWVhbarXX9+nWxNrO3b9+Obrcii2g0WmVlpUgm1sqc48ePp6enYx2FCNTV1aHbHMgxJycn9GbzwoULIu+cFv0t2MmTJ3E43OrVq0VbbBtFRUU9e/bU0tJq2QJc5qDTEdBdWbqV8vLy1atX37t3D+tAROPixYssFsvX1xfrQMSuuLj44MGDon0CKMoERKFQtLS0kpKSXF1dRVUmX5WVladOndq9e7dYa4EgiC8RLvEhsluwe/fuJSUlAQDEnX0AAI8ePZKP7DNx4kQajYZ1FBLFZDILCwuxjkLE6uvr0W6HbgKPxwcHB4umKJGUQqVS379/L4HVm5hMZklJyYIFC8RdkWQMHjw4JycH6ygkavny5TI0/6uDevbsefTo0ezsbKwDkZCBAwdOnTq1tLS060WJ4Bbs0aNHI0eOlMDzVDabPXr06FevXom7IkhMPnz4QKVSXVxcsA5E9CorKz9+/IhuAN1NsNns5OTkyZMnd6WQriaghQsX/vXXX5IZ/vfq1St7e3uZHjnSBofDqa+v19PTwzoQCBIGi8VydXXtyiJnXboF43K5LYsWihuFQpGz7IPOh4qMjLx79y7WgUhCYGAaoXmDAAAgAElEQVQglss+iN/Tp0+vX7+OdRQSpaysfP/+/a6UIHwCSklJYTKZgwYN6kr1HZSUlHTgwAE5yz6owMDA7tANdOnSpenTpxsbG2MdiBiNHDny2LFjWEchaerq6lQqNTY2VrjLhbwF8/HxCQ4Otra2Fq7WTuHxeOHh4YGBgRKoC4K6or6+XkVFBV3oq1t59uzZrVu3hJgcJ0wCampqUlFRkemZhNLm1KlTs2fPluY1G4VWUVERExMTEBCAdSCQeDEYDABAZ29TOn0LlpOTU1paKrHs8+XLlyNHjkimLgzNnj170aJFWEcheugQ4W6VfaRtv2mJIRAI2dnZdXV1nbqqcwkoPT09IiLCysqqk7EJb9++fW5ubhKrDitEIvHhw4c8Hg/rQERMWVn5wYMHWEchUfb29k+ePME6CmzY2Nh4e3t36pLO3YLl5+dbWFh0PjCoQ7KyslgslqOjI9aBiMaVK1cmTJggWys0QV1UU1NDJpMHDhzYwfM70QIik8kmJibCBiaM0tJS9Maym7C1tX3y5Am6b6Ks2717t6WlZTfMPlwuF91Ws3vS09PrePYBHV8P6Pnz535+fmJaE4SvnJycxYsXS7JGKUGhUOh0esuXkyZNCgsLwzQiqHPGjRtHoVCwjgIzubm5HX/ndrQFlJOTs3//fiGzolDy8vKCgoIkWaOU0NTUfP36dW5uLgDA29u7rq7u5cuXWAfVCfHx8ZmZmVhHgSU3N7eioiKso8DMwIEDXVxcOrjek+QWpYc65dSpU7GxsSQSCV3a7ciRI+hWH1Lu9OnTJiYmXZwfBHUfHWoBbd++XcKrRhQUFHTbRwmo+/fvo9kH7X1LTU3FOqKfYzKZv/32G8w+TU1N8j3ppCOePHlSXl7+09N+noBiY2OVlJTEtSR1OyIjI7lcriRrlCoeHh5VVVWtj0hgf4IuOnfu3KNHj7COQiqQSKRuNfSJLwUFhYMHD/70tJ9v3Tds2LCpU6eKKKqOGj58eLcd0LVs2TJ0C+CW1WZxOFxNTU1mZqbU3oWlpaUNHz5cMlNzpJ+ZmZmEP7ClkIuLC5lMbm5uFjwxBfYBSaMHDx6kpqZ++/atpqamqakJfVi5cOFC6eyVZ7FYeDxeJvahhaTNTxLQgQMHBgwYIIGlDltLTk5WUlKS5D5fbBZCa5TQXrQdRyaTc3JyXr9+XV5eTiKR1NXVT548iXVQbUVGRpqZmbm7u2MdiCBaREmv/F9WVqajo9MNZ6W2Vl5efvPmzfXr1ws45ycJaN68eVFRUerq6mIIr12rVq1asWLFsGHDJFDX59eNH55QGmpZqupS/AGOIDyEx+Mh0tbKQBAeADgp35hEXUexsohuOlht6ESd3v0ktKLL3r17ra2tOzsvQf5MmTLl/PnzAjYllcZbsKdPn7q4uIhjB+c20v8l11aw7Mf21OjZ7fbG6W4otewX96pHTO5pOlgSvTN37tzhcrkSvnWQQhUVFQQCQcDmd4ISUF1dHR6Pl9ed814/rG9s4DpN6YV1IJDkJF4od5ygbWbVre+MpIqgVsbGjRslP5zh7du3Z8+eFXct5Bp2XQULZp/uZsKC3u/TKBKoiEKhFBcXS6AiKVdXV7dq1SoBJ7SbgLhcLoFAsLW1FU9g7Xr//r0ERgDVVTCl79YTEjtFJVwjidVIEvu+QF+/fpWPreu6iEgkFhYW1tfXt3dCu52aCgoKp06dEltg7Zo0aZKWlpa4a6E2cHoZy+EK09BPGZn3INeyNHXF2+tnYGAg3wtgd9yNGzcEjIpqNwFVVlbSaLT+/fuLLTD+TE1NJVALm8FjdaN1PqD/NDdxeeIfY6+np7dnzx6xVyMLBHcit3sLdvHixYyMDPGEJEhgYKCABhsEyQpM3j5S6MGDB2FhYe292m4C0tLSGjJkiNiiatfLly81NTUlXy8EiZa/vz+TycQ6CuwRiUR0bRm+2r0FE9x3LSZcLvfSpUvSNtwOgoQwfPhwNputoqKCdSAYc3R0FLB7YLstoJSUFLGF1C4FBQW45jQkH0JDQyU8hUA64fF4Afc0/BNQfX19SEiIOKPir7CwcO/evZKvF4JErrCwEN6CoaZMmUKn0/m+xD8BsdlsDw8PMUfFR3V1dXV1teTrhSCR27ZtW0lJCdZRSAUFBQUymcz3Jf69Lfr6+pisqGRpafn7779Lvl4IEjkLCwvYm4m6ceNGe31h/H9AtbW15eXlkl/+SltbW1tbW8KVQpA47Ny5E+sQpIWAgYj8b8EyMjJu3bolzpD4S01NvXjxouTrhSCRKykpkfBK6lLrzz//bG9nF/4JiEgkSmY5njaqq6tramokXy8EiVxISMjHjx+xjkIq8Hg8KpXK9yX+t2COjo6YbBA8adIkDkfqViaEICGYm5urqqpiHYVU2L17d3vLe/E/WlRUlJeXJ+ao+NDV1RWweJoUCjm4c9XqxYLP8fQadyoylO9LXC43O1sse/gVFRVM8xr/7HmaOArviPsPYsdPcCSR6gScg3mQYhUcHAxX6UcpKyu31x/PPwE9fvw4KSlJzFHxcffuXUz6noTWQ02tRw/hV7c6/Neeo6Fi2W9WUVFRXV1DUUGqn8LIRJBC+/btW3v3Hd3N4cOH4+Li+L7E/3ffr18/Nlvsa6b8qKamRra2A1vnt7G9l8rKSo2NTQRfzhLbQDUTE7OrV+519ioKpQGHx2tqSGgunnBB/qj1FkbS4+jRozNmzBg9ejTWgWCPy+W2NyaTfwKS5I4UrU2bNk0K/5JQV69Fx9692dTUaG4+0Gfpb0Mdhs9b4FFdXWVtbXc87G8AAIlUdzzicEbGa0UlpaFDRzx5knL61OW+ffsDAKjUpn0Htj1/nqalqT1v3lKvabMAACGHdj5KSwIAjJ/gCAC4euWeoUHvV6+enYk6XlFRZmDQe5rnrBnT5wIAGAxG1N8nUlITWCxmH2PTOXMW/zJ+EhrV+8y3Z6MiCgvzdXR6DrEf5rtira4uMSEx7uChXQCAw4dOOA4d8aUgz3/d8pD94WeijhcW5uvrG/726zoXl++/4sTE+CvXztfUVPU164/D4w30DbdvO9DeD4HFYl28dDY1NbGmtlpXlzjJdarP0t8UFBTQV78U5B2POJyX90m3J7FPn+/Lqly/cfH0mfCL0f+0HFkf9BudTvP2ntM6yG/fvh4LPfA5N0dDQ9NpxKjAgM14PJ7D4ZyPjkz8N55CaTA17euz9LdRLuMAAGmPk3ft3rxn15EbMZdycz8umO+zzAeDqYuC9enTB07FQG3YsKG99zX/W7DCwsKCggIxR8WHvr6+np6e5Ov9qYx3b85GRdjaOgQF/mmgb0in0QAAG4K2DjAfiJ7A5XL/3BL48VNWQMDm+fOWPn6cbG83FM0+AICHCfcUFRTXB/5p1rd/aFhIVtZ7AMCiBcsdhgwzNOgdHhoVHhql25NIo9F27t6krKS8IWir88gxJFIt+gRhy9b1L18+Wbhg2frAP83NB+7Z++eDh3fRqH7f5Gdm2i94w7Y5sxZlZb0LCl7FYDCG2A9b+at/6/iZTOauPZtnzVwQevSMgb7h3v1bKJQGAMCz52khh3ba2Tps/XOfkrLy5885s2YuEPBzUFBQyMh4PdJ5zOpV6x2GDL985dw/t6+hL5WWlqwPWkmqq/3V12/27EX5X75PgHZ381RUVExOeYh+WV1dlfkhw9NzZpsgD/+1p6i4YO2aDbNmLqitq0H7LI/8tffGzUseU6dv+XOvgUHvbduD0R8dKuz4QY8p0w8djPCYOkNEv2dRCgoKwmQ9CSmkpKTUXh8Q/6PoTFRzc3MxB9ZWbGwsgiDTp0+XcL0/VVVVAQCY7jXHysrW1XUKenCYo1NMzGU6gw4A+Pw5J/9L7o7tIePGTkTfjQ8T7rFYLGVlZQDAJNepm37fAQAYPWr8nLmT0x4n2doOMTY20dLSrieTbGy+D/israthMpmjR//iOvG/7dWfPE3Nyn5/7UockdgLADBxgjudTvvn9rUpk72ORxz29Jixzv/72HFHR6ely2alv305etR4O1uHNt+Cv99GtN3k6+v326pFH7LejRn9y927MWZm/TYEbQEADBpkNXvu5Fevn1la2rT3c1BQUDh54kLLp1lFZdmTp6lzZi8CAESeCcPj8CciorW1ddApiKFhIQAAbW2dUS7jkpMfoo2U5JSH6urqE35xJxAIrYOsqqqwGDDIY+p0AABaYGlpSeK/8UsW+/os/Q0AMHbMhEVLpkdfOH30r0j0kunec93cMJgw1EHl5eVaWlqwEQQACA8PNzY2njGDz+cE/wTUv39/TLbrqa2tlXylHeE0YpSGhub+A9v8/TY6OY368YSa2moAQO/e31fhNDY24fF4dDoNTUBaWt+HdxMIhN69jdGTf9Tb0MjKyvbylb8JBFVPjxnota9ePeNwOAsWTWs5jcvlqqmpV1VVfv1aXF7+Lf7+nf+JpIZ/4aqE74+E9fUNAQB1dbVo2C0dVURiLwKB0NTUKPhHQSbXX7x0Nv3tK/RMDXUN9CYxPf3ltGmz0OyDdjC3XOLhMSN445qcnA/W1nb/Jt13dZ1KILRdD9d14pSr16LDjx9avMhXR6cnAOBD1jsAwKhR33foxuFwwxydkpIftFzi4DBccKjYCgsLmzZt2qhRfP5auhsOh9Ne3y7/BDRhwgQxh8Sfp6cnJvX+lK4uMSL83IlTR//YEmhtbbd964Fevf7nVtHIqA8AIDs702LAILRBRCT2ask7reEVFNr7ZeBwuJD94VF/R0SeDo25dfmPTbvt7BzIZJKuLvHokcjWZyooKpLJJADA0iUrx4z+pfVLPXsSBX8vSopKAAAej4tmzLy8T2hLraiogMFgmP//TSVf9fWklasWqqr2WL5sde/exufOnfxW9hUAQKqv43A4hga9+V7lMGSYkVGf5JSHikpKpaUlu3Yc+vEc3xVrdXR6Xr5y7mHCvZW/rpvuPae5mQoA0NH+b0FPTU0tGo3W3NyMftlDVar3XycSiXCHeNSaNWtaOgrb4J+ACgsLEQSR/C2YgYGBhGvsOBMTs4MHwt+9T9++I/jgoZ1HDv/PLskDLQYPc3Q6cza8urqygUJ+/uLx1i37OlJsm5amurp6YMDmOXMWb9u+Yeu2oBvXH2hoaDY0kPX1DdtM5+NxuQAAJpNhYmIm9Dc1f+7SoOBVQcGrhjoMT0p6MGigpdskQTc19+L+IZPrTxyP1tc3AADo6RmgCUhbSwdtHPG9CofDTZ3iff3GRQRBbG2HmJn143vOrJkLJrt7HQvdH378kHl/CyJRDwDQ2EhB7z3R9KeoqPhj60k6wWnVLQT8yvh3QqekpKSmpoozJP7u3bt39+5dydfbESwWC/0wd3Ia3dLD2pq/30ZjY5NvZV+1tXQijp9HO4MEIxBU6+tJPB6v5Qj6tLK3odGM6fOozdSqqgoHh+FcLvde3H/Do9ClVYyNTfT1DR4m3GtZaYXD4XR28IS1td3MGfN5PF5FRdncuUtCj50VPIG7sbFBW1sHzT4AAEpjA5pA1dTUjIz6pD1Obi+Aye7TaLTmuPjb0zz5bxaKfuNqamo+PqsAAPlfcgcPtsbhcK9eP0NPYLFYr14/s7Kybe+zVNrU19czGHDnA4D2Ad2+fZvvS9LVB1RVVSX5Sjvic+7HXbs3eXvNUVXt8ebNi0EDLducwOFw1vgtnT1rkZFRHxwO19TUSKVSf9oBaWfr8DDh3tFj+22s7TU0NIcNG7l02cxxY137mvW/ezdGXU29d2/jPn1M4+JvR54Oq6yqsBgwqKAg/9nzR9HnbhEIhLVrNmzfsXGtv880z1k8Ljfx33hX1ymCH2O1EXPryvv36XPmLMbhcIqKimVlpf37DxBwvr29453Ym+fOn7Kysnv6NPX16+c8Ho9CadDS0l66ZOX+A9v8/Je5u0/D4/EtT8dQaFf0+8y3bW4YW+zcvUldTd1xqBOacQZaDDbqbew2ySP6wmkul9u7t/H9+3fq60l//iEzW03s2bMHjgNCMRiM9j6ZpK4PSAr3qgcAKCspm5r0vXr1PIIgdvZD1/m1bV0rKio6DnW6dDmqZS6bhrpGeNjffG83Wri6TsnL//Rv0v2Xr566u3la29gPsR+WnPKwuZnat6/5/n2haNv18METZ6OOp6YmxsffNjY2meY5C22njB41/sC+0PPRkSdO/qWmpm5rM8T2h4dfgg20sIy5dWXf/q0tRzw9ZgSt/7O988eM/mXJYt87sTdjY2+OdB5zIiL6QMj2O7E3fJb+5jpxMpXadPPmpdNnwsxM+1la2nz79rX1tR4eMwwNjZSU+G/INXiQdeK/8U+ephKJehuCtlhb2wEAAgM2q6mp34m90dTU2Nes//69xxyGYDBHWjgaGhroYwRo3bp17bVb+e8Nj1UfkMS8SahnMoD9eFFue8/lctGfMoIgFZXlvr/OmzN7kRQOkGujJWwWi3X6bHhs7M3Ehy/keCWt1OuVtqM0+8Lt4aWDdI0DSkxMbG5u5jteQMoxmcw1fkv19AzsbB2UlJSzs98zGIz+/aV9gf1//70fde7E+HGTDA2NyGTS06epZmb9zkdHtu5yaqGpoXXlspT20EkhOp0uYABetyIz44BIJFJlZaXk6+06HA43yXVqamri+ehIZWXlvn3Nd2wPaa+/Q3qYmvWzsbZPTnnY2EjR1SW6OI9dtHCFopKShwefvxU8rt09VKAfbdy4cdGiRU5OTlgHgj0BfUD8b8GwUltbS6fTTUx+Moez68RxCwbJBIndggUEBCxevBiTdbWkDYPBUFBQ4Nv9J13jgHr16iXhGiFITATsR9zdyMw4oIyMjFOnTkm+XggSOR6PJ1W3FxgSMA6IfwLq379/v36Cnh+LCZfLzcrKkny9ECRyK1eu/PDhA9ZRSAWZGQdkY2OzYcMGTKqGINFis9nwERhKwDgg6eoDUlVVlePBR1C3cuHCBaxDkBYy0wfE5XJXrFgh+XohCBIfmekDUlBQ+PbtG4lEknzVECRa3t7eZWVlWEchFWSmDwgAcPLkSbiKCiQHOBxOexuidzcy0weEyfwPCBKH+Ph4rEOQFjLTB4QuC93e7SIEyRB0ASlIlvqAAACamprt7WMvQsqqeGVVOLOpO1LTUlRQEPvWT2w2e8yYMeKuRVbIUh/Q6NGjJXAXpqGj9O1Vo6UTnzWbIfn2Lbd5hNv3lfNra2uLioo+f/6cnZ1dWlqqqqp68eJFkdTCYDAMDQ1FUpQcgOsBtUUlc9Ju1Y6dA/9Euhcmnff8bhUwSM/Ozs7NzaXRaI2NjSQSCd2GLCMjA+sAux3pWg8IFRISMnr0aBcXF/FVoa6jaGyh+uRW9ZhZ+uKrBZI2SRfLx83qtdA3jEKhoIuooIM/AACifWLFZrNJJJI0b7IgSQLWA5K6PiA08T19+lTctdiP1e5n3SPlSkVdOZPDgpMG5RmjmVtTyoiN+Dphgb5hP8Lhw4f19fXbbBaso6PT3nZJQsjIyNizR2aWrxY3mVkPCMXj8eh0upqaJBbN/PqJlvm4obKY3t6W9AiCcLlcPF4Bj5fSTes7C0EAj8dTUJCrPvj//r4R0PoPWllZSbOXMo3MMbFUc3TV0dH7viRNaWmpv79/eXn594sQJCMj49OnTyEhIXPnzp06dWoX43nx4sW7d+/8/Py6WI58ELAekJT2ATEYDBUVlfY2tBcHNvN/fg7v3r2j0+kuLi6xsbE6Ojpjx46VWCTiVltb+9tvv8nTWAcKheLv719SUtLmuK6u7p07dxAEKBP4/CFxOJzly5fn5OTg8Xg0AQEAPn78WFlZOXHixIcPH969e9fHxwcuaShW/BPQmTNn0PUEsAgJAACio6OpVKrkP0DKy8uNjIwSEhJiY2MDAwMHDRok4QAkgEqlXr9+3dfXF+tARKmhocHX17d1DmrJKYIFBAS8efMGj8c/f/68zUvp6el0On3MmDEXLlzIyspatWrVgAGC9ixqjUKh4HA4TU3NTn4f8knG+oAAAF5eXjk5OZKskUKhzJ07Nzo6GgAwbty4yMhIucw+6OarcpZ9AADa2tonTpzo06dPyxF0SxxfX9+EhAQBF4aFhXl6euro6Pz40rBhw9CxPAsXLvT09ET7rY8cObJ9+3YqlSo4niNHjjx79qwL35BcEdAHBJDuLSkpac+ePQiC1NfXf/nyBetwJKG5uTk+Ph7rKMSisLDQy8tr6NChQ4cO9fLyQhDk3bt3ERERCIIUFRUlJSV1vYqmpqb4+Pjq6moEQXx8fA4ePMhisX48bfPmzdnZ2V2vTj7Q6XS+PyUEQfgnoIKCAszfjSQS6cOHD2IqPCkpKScnB0GQv//+OysrS0y1SKeamho3NzesoxCXT58+eXh4DB06tM3xhoaGTZs2bdmyBUGQ0tJSkdRVWlp6/fp1KpWKIIifn9+lS5dEUmy3wj8BnT59+vTp0xIPpq2lS5eKNjtUVlYiCLJ9+/bff/+dRCKJsGQZwmAwEhMTsY5CjDIyMlxdXfm+xOFwEAT5559/JkyYkJeXJ8JKs7Ozz58/jyBISUnJ77//fuvWLREWLuvCwsL++ecfvi/xT0DJyckiaa92UVlZWUpKikiKKigomD59ekxMDIIgbDZbJGVCsqu+vh5tB+3fv//ChQtcLldUJfN4vOvXr48fPx69JQwLCysuLhZV4TLq4MGD169f5/uSNI4DEqG0tLTc3NxVq1bl5+erqKiYmppiHRH2uFzuzZs358+fj3UgUqGysvLmzZsLFy4kEon//vvvpEmTul7m+/fvk5OTN27cyGAwbty4AQBYunRpQkICj8ebNGlSN1woWsA4IOntA0JVVlYGBQV19qrq6moymUyn04OCgtC+Hqi1kSNHMhgMrKOQOps3b0a7rpubm0Ve+JcvX7Zu3Yq26BMTE79+/SryKmSRVPcBoaKiom7cuNHx88+fP+/u7k4mk9GNmaAf3b17l06nYx2FNELzcmZm5pIlS4R+BlJQUFBbWyvghJiYGG9vb/QeUEo+6cVKQB8Q/1swNE9PnDhREu0zEbl165aioqK3t/fnz58HDx6MdTiQbMvJySkrK3N3d09LSxswYICRkVHHr505c+Zff/1lZmYm+DQWi6WsrBwQEFBYWHjnzh3+dyhy4dChQ6ampnPnzuXzmsSzoTAaGhru3bvH9yX0k/z27dv79+9vaGiQeGgyKS4urjt88IpEenq6p6dnxwf1MBiMDRs2dKqKyspK9MGIp6fn8ePHhQpTqgkYBySlc8F+FBcXl5GRsXPnzpYjHA7n0KFDTU1NBw4c4PF46JIuUEdERESoqaktW7YM60BkBplM1tHRCQoKmjRpkru7u5hqqa6uTk1NnT9/fkNDw/Xr16dNm9a7d28x1SUlFFq/pVvcunWruLh46NChWITE38CBA0eMGMHj8RQVFcvKynr06FFeXs5isfz9/VsWdoE6iEgkEgiE1hMXIMFUVVUBAAMGDIiPjx8/fnxDQ0N7C62XlZVRKBQtLS0halFXV7exsQEAKCkpZWVlxcXFTZo0qaqqCofDoTNLZFR4eHh5eTnfjhEpnQvGl6qqakZGRmhoqJ+fHx6PNzU1nTlzJtZByaR+/fo5OztjHYXs6dev365duwAATCbTzc3t/fv3P56zc+fOurq6LlakoKDg6+t75MgRAACdTp88eXJMTEwXy8SQPMwFa25ufv36NYIg8+bNe/PmDdbhyLz9+/czmUyso5BhtbW1Dx8+RB+ZtRxks9nobA+R+/z5M4IgFy5ciIiIoNFo4qhCfAT0AfFvARUWFhYUFIg3K3ZGSUmJm5ubtrY2AODatWsWFhZw99QuIpFIPy5AAXUckUhEO4Nyc3OXLVuGbsKjqKi4d+9ecVSHrs0wZ84cVVVV9BeXmZkpjorEgUAgtPeMT0rXA2qRlJTk6upaUlLS5qEmuo1B11eu67a+fv1KpVKtrKywDkQeZGVl6evr4/H4wsJCAwODnz6AF4nQ0NCUlJQ7d+5I/9Bq2VsPCLV///709HQAwI+/URsbm9evXzc0NGAUmswzNTWF2UdUbG1t9fX1VVRU1q5dK7HhPIGBgeho4bKysiNHjjQ1NUmmXiHI2JrQ6JK6zs7OX758EbwGHYlEIpPJUjVcQIaEhYW5ubnJ67prkldWVpafn89gMKZMmSLhqq9du1ZRUbFhwwYSiaSrqyvh2n9KwFwwqesDYrFY3t7eaKvypytg6urqEonEX375RZrTv9QaPHjwhQsXsI5CfhgbG//yyy9o9tm9e7ckq54/f/6GDRsAAImJicHBwT9dsFHCZKYPqLa2lsfjsVisTg1RoVAob968cXV1FWdo8qm+vl5HRweOouq6qqqqU6dOoQ/pAQBv377Nycnx8fGRfCRpaWna2tr29vZlZWXGxsaSD+BHMtAHxOPxli9fjsPh9PX1OztATktLC80+Pj4+sFeoU9TV1dHHN1AXRUVFDRkypOVLR0dHT09PTCIZN26cvb09AGDr1q2nT5/GJIY2pL0PiMvlPnjwwMTExM7Orivl5OTkJCcnBwYGii40+Tdu3Lj4+Hh1dXWsA5Fh6AowP+6DmpGRkZmZuWLFCoziAo8fPx47duz79+9bJ0fJk+o+oH/++YfD4Xh6enYx+wAArK2t0exz4MABuCdBBx0+fDgxMRHrKGQbg8Hgu6/G0KFDaTTay5cvsQgKAADQ/ewQBHF3d+/6+GyhCegD4p+AUlJSUlNTxRwVAAC8evUqLy9PtNtyAwBWr14dExPT1NQkws125dWwYcPgjJauKCsrmzdvXnt/w/7+/iNHjpR4UP/DwcHh8uXLVVVVWAUQHh7e3kaYGPcBqaqq/vnnnyIvVltbOywsTEVFhUwmHzhwAHZzCNbU1HT48GGso5BVjx49CgkJEXBCQUEB5o+liESitbU1AGDEiBES3nFPSvuALl++bG1tjU3HdAcAACAASURBVPaWidWtW7dKSkqCg4O5XK6CgoK4q5NRsbGx2dnZ27ZtwzoQORQQEDB79uxRo0ZhHch3V69eXbBggSRrlLq94a9evWppaSmB7NPazp07iUTi2rVr4VNnSFS2bt26ZcsWdLGO9kRHR9vY2EjV4jYAgE2bNu3cuVNw5BIgXeOAxC06Onr8+PGmpqZ1dXVEIhHrcKTOv//+O2rUqB49emAdiGzYu3evlZXV9OnTsQ5EGNXV1Zs2bUL3Ihc3KRoHlJycfPnyZXGU3BE+Pj7ozjwLFy6MiIjAKgypNX78+F9++QXrKGTG1q1bO5J90tLSJBJO5+jr66PZJysrS9x1SUsfUEFBwY0bN7Zs2SKxGgVIS0sbN27cq1evOByO9NyfY47FYtXV1cn9SqBdhCDIo0ePOpKso6OjqVSqn5+fROISRkxMjJ6eHvrAXkykZRyQubm5lGQfdAAe2taLiYl58OAB1uFIC2VlZRUVlTdv3mAdiFRbvHhxB3O0srKylHdlzJ49u6ioSKxVSMVcsNu3bw8aNMjS0lKEZYoKlUpVV1f39fU1NzffuHEjfFj25MmTO3fuHDt2DOtApFFpaamqqmqvXr2wDkSUysvLVVVVe/bsKY7Cse8Devbs2ZMnT6Qz+6BTotDpPP3796fRaDQa7e7du1gHhaUxY8aEhIRgPnpFCtXV1eHx+I5knxcvXhw9elQiQYmAkZHRli1bxNTyxX5NaBKJJEP7lHI4nF27di1cuBBBkMbGRqzDwdLRo0exDkGKPH36NCAgoCNnVlZWHjt2TPwRidjz58/FseA0xvuCkclkBEHE1LoTH3SvsczMzL179wYHBzs5OWEdEQZevXr16dOn5cuXYx0I9hgMRllZWUfeFJWVlYaGhhIJSsTQTUD5zmsTE0nMBXNzcxNumyRsoTsd2tvbHz58mE6nAwDu378fHx8vDesHSIyTkxPcwAd9OFhUVNSR7JObmysli2AIAYfDPXv2jO9egV2B5VywZ8+eHTx4UKa7dfv27Tt+/HgAgJ2d3du3b+/cuQMA+Pz5M9ZxSQi6ZuuqVauwDgQzlZWVM2bM6GAPZlJSksjfwJLk6enp4uJSXFwswjKlZRyQPImOjo6Kirpw4UL//v2xjkUS6urqoqKiNm/ejHUgktbU1FRdXd2Rts/ly5cXLVokkaBkDGZzwfLy8oqKiiZPntzFcqQTnU5vamrS09MLCAjQ09Nbv359d5jEkJOTg86r7g7ev3+Pw+E6Mmlx0aJF69evl7YJX0JLSEigUChz584Vd0Xi7QMKCwuTub7njlNVVdXT00O3Dxo8eHB9fT16uyvfa6ElJCSkpKRgHYUkUKnUEydO/DT7FBYWAgCOHTsmN9kHAODu7h4dHY3+SXcdNn1ADAZjyZIlI0aM6GI50k9NTW3GjBnoAuCWlpYxMTFUKpXD4SQnJ8vfimjBwcE1NTWtj4waNWrhwoXYRSQW9fX1VCo1KipKwDk0Gm3x4sXoalNyNi4RAPDw4UNRtR6wHwfUDXG53E2bNs2cORNdMLi2thbriETsjz/+QBDEzc1t6NChv/zyy6tXr7COSGR27drVkd/Xv//++/HjR4lEhI3s7Gw2m931crDZGz4kJCQ3N7eLhcguPB4fEhJy69Yt9KNy4cKF6OTj6upqrEMTjcWLF48aNQpdaZhCoVy7dg3riEQjKyvLzs5OwGotZWVlaGezq6ur1A7uF4mXL18KbgN2EAZrQjMYjLi4OLjrJsrMzCwxMdHd3R3tQ3F3d8/Pz0e3A8E6NOFt27aNwWC0fPnly5cvX75gGlFXVVdXP3v2zMzMzMvLS8BpP12DVW4sWLBAJFt+YtAHhCBIN59O9SN025alS5deunRJQ0MDAPDnn3/6+fm16VKRFW2mUFdVVcn0b5xKpS5btszJyUlTU5PvCQ8fPgwICECbflKy4Z+4qampbdy4sevlwHFA0uvVq1dGRkZ9+vRZtWqVubl5cHAw1hF1iJeXF5VKpVAo6IQV9GDv3r0vXLggyYH8olJdXU2n083MzPi+ymAwCATCzp07d+zY0d3W8y0oKCgtLe3iMnUCxgEp8B21WVhYWF9f35U+8KCgIGNjY/QpNSSAsbExOk/F0dGRQqFYWVlxuVw/Pz8ymWxra4t1dO2aP3++sbGxsbExj8dD7/DpdDqNRtPW1u76/m4StmfPHltbWxMTE76vnjlzhsPhmJiYjBs3rrtln5b1jJYtW9aVQhQVFdubCyGu9YCcnZ0fPXok8g2/uonXr1+/fPkyMDCQTCaHh4d7eno6ODiIqvDij805zyk0KrehWjS7Ff3/Aw2AIDz0r00kxUoGj4cAgLQ04n54lYcgiBATifRMCAgCzO3UbUfL3izINh4/fmxlZdWVNdQFrAfE/2+lf//+Xbk14/F4SUlJMPsIbcSIEej4KS0trSFDhmRlZTk4OKSmpubl5Xl7e3dlpvWHp5SyfIb5EC1dQ4KSCv93HdR1PB4gVTLqyhgPzlVNWd52y2bZ0vXVWmEfkDwgk8n//PMPkUj09vaOi4vjcDju7u7tbavi7Ozs5ua2Y8eO1gdfPainkDjO0+B9seR8fk2pKm6e9psMr7FdXFycnJz866+/Cl2CpNeEjo6OPnXqlNCXQ3zp6Oj4+vp6e3sDAAYOHPjx48fnz58DAO7cufPj5A8Gg5GQkND6EUZVCbOhlg2zj4QNHqHV01D18xsRPMzGiqGh4YULF7pSgqTHAZWVlfXp00foy6GfsrCw2Lp168SJEwEAurq6MTEx6H67sbGxeXl5np6eeDyezWY/efKk5YOrooim0kOGF0WRXZq6Sl8/N2MdhfAIBEJYWBiNRhO6BAHjgMTSB7R161ahr4U6a8yYMWPGjEH/T6VSd+3aRaFQ0C+5XG5GRsaCBQtOnjxJa+Tq9cF4G8zuqVdvlbI8GW4BAQC6OM9W0n1AbDZbUVGxGz6zlBKOjo5tjgwaNGjW6H19rXr2s9HAKKjuq7GenXqlYvFWU6wDEd79+/cRBPHw8BDuckn3AY0fP771IH0IQ+iD5Pz8fPQeDYKEgMfjX716JfTlAvqA+N+CoQu+CLcgGZ1OJxAImG96321NmDABAKCtra2mpqagoGBgYGBpaWlpadn4pVus3AiJw5gxY/r27Sv05RIdB6SqqpqcnCzctVDXpaSkREdH9+vXz9TU1NT0v2Z/wjc5mYUPSZ6amlpXJpYL6APin4DQT1GhcblcmV6FXtb5+PhgHQIkVxAEWbly5dmzZ4W7fN26de0lBNH3AaWnp69du1a4ayEIkkI4HK6goKCxsVG4yyXaB0Sj0brD2uwQ1K0cP35cWVlZuGsl2gc0duzYrk8egSBIqnRlKxSJ9gF9X+q1nenFEATJomPHjk2ePFm4rmiJ9gHFxMQcPnxYuGshCJJOX79+ra2tFe5aifYBcblcuBAHBMmZwMBAbW1t4a6VaB/Q/PnzhbsQgiCp1d56tR0B+4AgCOqS6Ohoc3PzUaNGCXGtRPuA/v77b3RFV0imfSnIGz/B8eXLp529sKqqsrKqoiNnhoUfnDFrklDR8Td77uSjx/YLPifk4M5VqxeLsNJuoqysTBx9QGJZDwgOg+62yivKFiyalpf3CetA2tVDTa1HDzWso5A9Pj4+o0ePFu5aia4H5OvrK9yFkBzgcjhSvsjvOj8RbHSFdjV0qwVnurIVmqTngkFyo7ik8PrNi3l5n4yNTQL8N9nY2KPHP33OiTwdmpf3iUBQdR45ZvXq9ZoampVVFUuXzQIA7Nq9eRcAbm4em3/fCQCorKo4efJoxrvXysoqFgMGLV++ZtDATuxonJ2deelyVHZOJgBg0ECrVasCB1oMRl/icrkXL52Nv3+HwaDb2zsyGQwAAJPJnD138ojhzlv+3IuelpmZsX7Dbwf2hYaGh1RXV1lb2x0P+xsAcPVadOzdm01NjebmA32W/jbUYXh73xp6w/j4SUpw0NaTkcfKy7+dOH7e0tJGDD9yKXX16lUDAwPhNgiTaB/QmTNnYB+Q3Lh85e8h9sMCAzazWKwt24KoVCoAoKSkaEPwKjab/fvGHUsX//rs2aNduzYBAHR7EtH3/DKfVeGhUYsWLAcAkEh1/uuWNzZR/NYG/7ZyHZvNDgj0LS4u7HgMVVUVTBZz8SLfpUtWVlVVbP5jXctqU2HhBy9eihox3GWd3+8EFUITtQkAoKKiMsl16rPnaS2riCYlP9DXNxg+3HlD0NYB5gPRgxnv3pyNirC1dQgK/NNA35BOown41lDNzdS/z58MDNi8Z/eRwYOFHxksi8TUByT6cUCQPAnw3+Tm5gEAMDXpu8bPJ+Pd67FjJly+8jcejz90MEJDXQMAoKGhuT9k+4cP7+zsHCwGDAIAmJiYtbSVLl2O0tHu+dfhU+h+Ya4Tpyxa4h3/4I7/2o7uATtx4mRX1yno/wcOtAzasCo7J3OYo1P+l9y4+NuLFi5fsXwNAMDNzSPzQwZ6mqfHjH9uX3v6NNXNzYPJZD55mjJ3zhI8Hj/M0Skm5jKdQUfzGgBgutccKyvblvIFfGsAABaLFRy0tbulHtT8+fOFHt/X6XFAFhYWwtXUxe0MIWmjqfl9Xz0zs/4AgNraagBA5oeMIUOGoW9RAMCwYSMBAHn5n9B3aRuvXz+vqa2e4vFf/yWbza6t6cTiRDgc7umzRzdjLn/9WozOcybXkwAAT5+mAgBmzVrYcmbL4A9T0742NvbJKQ/d3Dyev3jMYDCmTPZqU6zTiFEaGpr7D2zz99vo5PT96bLgb41AIHTP7AMAENM2E/wT0Lhx48RRGSS70Pc2l8tF70S0tf7bAF5DQxMAUFfHv31eTyaNHDl6pa9/64Nqauodr/ripajz0ZEzZ8xf6etPqq/btXszD+EBAKprqtTV1bU0+W896jl1RsihnSRSXVLyg1Eu43r21G1zgq4uMSL83IlTR//YEmhtbbd964FevfQEf2uqqt13mYdr164ZGBiMHz9eiGtXrlzZuT6ggoKCwsJO3KW3dvbsWdgHJN+IRL3GRkrLl2RyPQBAXZ3/cvcaGpoUSoOJiVnrf7q6Hd3nl8lkXr12fuoUb7+1G2xs7C0H/9fvq62lQ6VSWSz+G0yPGTNBTU399p3r6ekvp02bxfccExOzgwfC/zpyqri44OChnZ391rqVb9++1dTUCHdtp8cBPXr0KCkpSbjKpPwpLNR1Vla2mR8yWnqCnzxJAQCgnT4qKgQAAKlVa8jBYXhOzoe8/M8tR+h0OvofJSVlOp3G4XAE1MVg0JlMpsX/P/aiNDagK+0DANCDKakJfC9UUVFxdZ1y7foFI6M+Q+zbbhOCQpOXw5BhTv/X3n0GRHGtDQCe3WWXIlV6EQWxoIKioKjEi4olir0lWSKoEGtERL0moLFiSVQSQYmxiyVqFMWCigELRQQRAUVYBZFel759vh9zL9fPLMvusDOzwPvcPwHmnPPihZdzzpzi+kVuXo7sb62bW7hwIe6B0eHDh2/cuCH1S9KHYHZ2dlhnGwc/Pz/IQV2b1zdL//773r9/+H6G57yKirIzZ485DXMeNnQEgiAmJqYW5paXr0ZqaGrW19fNnfOV9+LvkpOfbty0euECLwODnikpiWKJeNeOAwiC9LMbwOPxtu3498oVAZYW0peZ6Onp29raXbt+qWdPw6bGxjNnj9Hp9PfvOQiCjHefdC7y+MFDIfn57/rZDch+/eqzYeCM6XOvXbs0w1PK3CeCIG9ysrfv+PfsWQs1NbVSUhKxlQEyvrVuriN7wZqamtpaByS9BzR+/Hjs1k0caDQabATr2qysrPfvDRMKhft/3v7n5XOTPKbt2P4LtiqPRqMFB4doafUIC/8l5l50bW2NpYVV2G8nBw92PH/hZPiRA9y6Wo+JX2L1TJw4deECr5yc7AKZb+W3BIVoamju2PnDn1fOrVwZ8K3Xsnv3ooVCIYPB2LfnsLOz683oqxHHfqXT6Xp6/2+7dp8+ts4jRk2eLP02KxaT1dva5sKFU8ePhzk6Om0I3CL7W+vmLl68+M8bwOXk7+8/Y8YMqV+SfjHhhw8feDzegAEDcDQWGRlZW1v7/fffy/EsIE/MmXLzvlpwMSH5usDFhAiC7Ny508HBYfbs2cqtVvoQLDU19e3btz/++COOGplMZusgHwB5NDY2fs2W3k9Z/p2/5/Q5pEcEPsdms3V1dfGV3bt3r7Ozs9RBlfQEZGtri83z4bBw4UKYAwIK0dLSOvb7Balf0tWR/pYdkMzW1hZ32dra2ra+JD0BOTk5OTk54WuMRqPBmBkohE6nm5tZUB0FkOXYsWMjR44cNgzPC8GtW7e2tYpa+mwxl8tNSUnB0RI2fIN7wQDoYl69eoV7aqVHjx7YRpx/kp6AGhsbQ0LaOdipLXp6etXV1fjKAgBU0/fff+/ggHP3/4oVK96+fSv1S9LTkomJyYgRONc+9OvX79KlS/jKAgBUE7534pjS0tIePaQfAie9B8RisbZs2YK7PdyLGAEAqumHH37APbI5f/68paWl1C+1uWLw6dOnXC4XX3tz584tKirCVxYAoIISEhI0NDTwldXW1m7rxVSbCSguLi4+Ph5fezY2NiUlch1LDgBQfSiKhoaGtjWMkq20tHTRokVtfVX6HBCCIFOnTq2rq2vrq7KFhobiKwgAUEE0Gm34cCmHPcmjpKRET6/NxVxt9oBcXFxwbwcTCoWt+4kBAJ0dh8PBfd+6k5PTkSNH2vqqrF2jkZGR+JosKSn55ptv8JUFAKia3Nzc+vp6fGXpdHpbi4DaSUDPnj1LTEzE0WTv3r21tLRwj+AAETR60JlMOKWAAnQ6XddI+nFcncXw4cNxry7esGGDjG30bWYmBEFWr16N3YKAA+7eEyCIhha9tpzfayDcyUc2biW/s+9NMjMzw102Ly9PxvUWsv4kDhw40NlZ+lFy7aqtrS0uLsZXFhDB2EpDwMO5wRh0RBNXZGWnSXUUHRIcHFxQUICv7I0bN2Tkr3b65MePH3///j2OVtXV1b/66iscBYHSoSh66tSpsFPB9TWCguwmqsPpXnhN4pfx1cMnGsjxrOqKiYnBdyKiSCSSvYOsnQRkZWV14sQJHA1raWn5+Pi8efNGjmcBIZqbm69evdrY2Mjn85uamtavXz9rucX7jLrc1HqxCM5LIUN5AS/694+Lgzr3UWR8Pj8qKgpfWRm3wmOkn4j4qezsbHt7ezhltROprKw0Njb29fXt27fvxo0bP3sH8TSq6tXTOrPeGiJIQ9Lw+XwGnU77z/9w/tjr6DPfZzYMcNadsMiYzujkM0AdsHr16o0bN8roPbWfgDri8uXLs2bNwn2hIlDUrVu3tm3bdv78+Xa3DtaUCXjNsGXvc48ePbp06ZJYLO7Ro4eGhgaKojo6OmZmZpaWllOnTpW/HjUm3dhSndYl/mrv379/zJgxbm5uRFQuVwIaN27c3bt3cSzEPnPmTF1d3dq1a/GGB9rX0NDwxx9/6Orq+vr6ZmdnDxo0CA6E6wg2m/3Z2REoiqIo+uLFC+qCotL48eNv3LiB4zzWqqoqHo9nZSX9vhOMXCl69+7d0dHRijaPIIi3t/fgwYNxFATtKiwsxNY65ObmWltbe3l5IQgyePBgyD4d5Ofnp6Pz/47up9FoHTmQtFOTSCR3797Fdxp0YGBguxvaiR2CAaVramrS0NAQCoVff/31/Pnz2Wy2HIWAYlasWPH8+fPWVG5sbHz37l2qg6KGUCik0WgyljK3pbKy8vz58+vWrZP9mLyD1KqqqvPnzysaBGbx4sVlZWX4yoJPhYaGfvnllyiKslis69evQ/YhyLJly/T1/3PFGIvFunv3bmFhIdVBUWPevHnl5eU4ChobG7ebfRRIQEZGRi0tLUePHsURyqZNmyIiInAUBNj53GFhYQkJCQiCjB079vHjx2pqavBSklAuLi6tlzJgu5HOnTvXDTtBOTk5jo6ObZ0lJpucy3cUG4JVVVXp6em1dc88UC4Oh2NnZ3f06FENDQ0vLy/4ZyfT69evAwMDWSxW66Xmt27d8vT0FAqF8H9Eu06ePNnS0iLX9jFUQdHR0RKJRNFSKIoePny4sbERR8FuKD8/f8qUKdHR0VQHAj4XFBT05MkTqqMgg1gs/vvvv/GVTUpKEovF8jypcE/e2dm5rWueZZs5cyb2pga0paSk5OTJk9ih2pGRkZ6e0i8LBRTatWvXlStXcF/b2YmcOHGirass2uXq6irnLAGet2B8Pr+xsdHQ0BBXbEAKHo/HYrFmzZrl7++P+xw4QBoURVNTU11cXKgOhEBnzpxhs9mKvv+qrq728fGRf9UOnrlMdXV1Q0PDU6dO4SibmZmZlZWFo2BXVVVVtWHDhvLychqNFh0dDdmnU6DRaHZ2dh4eHl34Ahhvb28cb98vXLiwa9cu+Z/Hvw4oJycnKipq8+bNihbcv39/7969ZZxT3U00NzdraWmdOXPG2tp6/PjxVIcDFMblcrlcrpGRkba2NtWxKJNYLA4MDCTnZPcOLUR8/fr1oEGDcBQUCAT19fVGRka4m+7sjh8/XlRUtG3bNqoDAR2Vmpqqra09cOBAqgNRmj179jg4OCg6BSkQCEJDQzdt2qRYY/hmuT/l5+dXWVmpaKmPHz+eO3eu4613Og0NDTU1NUeOHKE6EKA0bDZbIBBQHQXFfHx8cnJyFC2lhPVs4eHh4eHhipaysrKqqqrqbteHHTx4sLy8XE9Pb+XKlVTHApQmMjKyy5yAHh8f39zcjKPgqVOncFzfrIQExGQyf/rpJwRBZJ889E/r1q1TU1PrPie3xsbGmpqa9u3bF9Yxdz1GRkZHjhyRffqf6tuzZ09VVZWWlpZCpd6+fZucnIyvRWX+JlhYWHh6eio0qWRiYqKnpzd58uSmpq58VCi2k8jV1RV2b3VhM2fO7NTHEFdVVc2ePXv+/PkKlYqLi/vjjz9cXV3xNark3fClpaUGBgYlJSUKHV9QXV0dFxc3d+7cLtk14HK5S5YsuX79OtWBAMJJJBKJRILj7TXlRCJRUVGRogc/19TUaGhoKNpj+pSSf+HNzc01NDRoNNrs2bPlv9LH0NBw/vz5EokEx0t91ffy5UvIPt0EnU7PzMysqamhOhCFubm5yT457J+Sk5Nzc3M7kn2Un4AwNjY2YWFhhYWFPB6Pz+fLWUpNTc3Dw6Mr3SuPomheXp67uzvVgQDyqKmprV+/nuooFJOSkhIXF6dQx43P50dGRuIeebViELQURVdX19jYGEVRd3f3vn37ytm1s7W1HTlyJI1GCw8Pd3Bw6Ozbjvft2ycQCOBMyG7F1NRUV1eXxWLhO0WQfPfv3x83bpxCv2t5eXlaWlqzZ8/ueOvEzrkwmczExMSGhgYEQd69eydXQHQ6giCjRo368ssvCY2NaHV1dZaWlgsWLKA6EEC2CRMm4DtDh3xeXl7Dhw9XqEhwcLBAIFDW4m/yjmSNj48PCws7dOhQr1695C9VWFj48ePHsWPHEhkaAMrU2Nh46NChLVu2UB1IO3g8XkFBgfxruEUiEYfDKSgoUOiCENnIe+vk7u7+888/f/z4EUGQx48fy1nK3Nz8+vXrMTExBEenfLdu3YJ7GbsnbW3tmJgYHo9HdSBtqqioOH78OIvFkj/7xMTE5OTk9OnTR4nZh9QEhE1OjxkzBjvmUs67ephM5i+//OLg4IAgyKFDhz58+EB8mMqRlZWVnZ1NdRSAGqGhoaq8UX7ZsmU+Pj7yr3rJysp6+vTpkCFDNDQ0lBsJZbdilJeXm5qa3rlzp7S0VM6N/6mpqWFhYadPn+bxeEr/h1C6zMxMNTU1e3t7qgMB4H+ys7MVeiuSmJg4ZsyY4uJigma1KFv4Z2pqiiCIh4cHn8+/cuUKgiDt3pzh7Ox8+vRpbD47MDCwqKiIrGDxcHBwgOzTPdXX1wcFBVEdhRQrVqxQqMMRGRl58eJFBEGIm1OneOUxi8VatWrV119/jSDIlStXfH19q6qq2i01ePDgGTNmYBNDqpyGjh07Fh8fT3UUgGwPHz7U1NSkOor/p7m5+eXLl8uWLRsyZIg8z+fk5CAI0q9fv8OHDxMbGTFb83FKT0/Pzc1FUfTixYsfP36Up0hcXNzs2bPlfJh8bDa7oaGB6igAqQoKCurq6qiO4n/27t0r/y+IUChcunTpgwcPCA7qP1T0ZtTo6OgzZ85cvXq1rq5OT09P9sOFhYXNzc0DBw48fvy4p6enmZkZWWECoOquXr0qkUgWLlzY7pM8Hq+pqUkikRQXFw8bNoyU6FSsB/RPRUVFLi4u169fl+fha9eusdlsFEXr6+uJD00BgYGBVIcASLJ06dL09HSqo0BRFA0PD0dRtKWlRZ6Hsclm8nvrqr773NLSMikpydraGsvlERER2LpqqebMmRMZGYltr586dWpsbCy5wbZp48aNe/fupToKQLjk5OQvv/ySvO5D2xYtWmRjY4MgSLvvi9PT07G9XQkJCeQfbq2iQzCpGhsbL126ZGZm5unpmZSU1K9fPxmnSldVVWVkZEycODE+Pl4sFk+cOJHcYD+H3aj59OlTNzc3aiMBXVhhYSGHw5kwYYJAIGCxWLIfrqurY7PZK1eunD59OlkBfk7Ve0Cf0tbW9vX1xc7Krq2tZbPZaWlpWGL658NGRkZY0hkwYMC9e/ew9/cUngCLbfbjcDjBwcFUxQAItWnTJmoPZi0qKvL398eW+cjOPvfv329qampsbDx+/DiF2QdR/Tkg2Wpra1EUXb169fLly3k8nown+Xw+dj30ggULqqurSYzxc9jFvhwOh8IYgNKFhIS8ffuWqtYvXrwoEonKysrkeXjfvn2bN2+W8+pkonWmIZgMz58/xxY4BAQEzJo1S8ZO+nfv3unp6RkZGa1fv37y5MnK3dgivydPnpw7d+63335T/SXdoF3ULs3f7+mMSgAAGWBJREFUtm2btrb2hg0bZD929erVxsZGHx+fiooKExMTkoJrD1HnAZHM0tKSyWQymUwzM7O8vLzhw4fn5OTcunXLysrqsxPbevbsiX3G0NAwMTHRzc2toqIiMTGxb9++ZAbcu3dvCwuL+vp6ExMToVDIYDDIbB0oUWBg4JQpU8g/TTglJSU5OXnQoEEODg4yLtQViUR0Oj0lJSUtLc3b21tdXb1Hjx7kRipLF+kB/VNTU9PJkyd5PN7GjRuzs7NFItHQoUOlPtnc3Lxjxw4ulxsREVFVVUX+dYmTJ09evnz5vHnzSG4XdNzTp09FIhH5h17m5OT8+uuv27dvl92XOXz4cExMzO3bt8VisYr+kaN6DEiG3NzcJUuWYMsi8vPzRSJRW09mZmaOGjXqxo0b5AaI/vnnnyiK4rjXDVCosbFRzmkXZcnJydm0aROKorJXWr948eLDhw8oiv71118kRodHt0hAGGxFVkxMjIuLS2JiIoqiUmejhUJhZmYmiqJHjx7997//XVJSQlqEqamp48aNy8/PJ61FgE9tbe2IESPInMflcrnYitZnz57JfjI8PHzZsmXY86qvGyWgT2F/uHbv3j1v3rzi4uK2Hnvw4EFqaiqKor///ntUVJSMrpOyNDQ0vHnzBvvbJecaVkA+OZfmK8XHjx/9/PxevHgh45nm5uZff/315MmTKIqWlpaSFlvHddME1Co/P7+iogJF0UWLFq1bt66td/mZmZnbt2/Py8vDfvgKCwuJDuzatWtjxowRCARCoZDotoD89uzZQ1pb2J+i6Oho7K+gVFhv/cGDB6dPn+6M99N39wTUSigUPnr0qLm5GUXR+fPnHzp0qK0njx07NmvWLIFAIBAIMjIyiI6qpKQkICAAOyQAUGvPnj1XrlwhoaHS0lJPT89r167JeKampmbq1KmHDx8mIR7iQAKS4sOHD9jsXXl5ua+vr9SfA4lEIhQKfXx8vvnmG2zoJHslZEfEx8djM+hYFwyQD+toyBitK0VdXd358+dRFH3//n1bbcXHx2/ZsgWbwSwvLyc0HhJAAmpHWlraxYsXURTNzs7etGnT06dPP3sA23lfXFw8evTo0NBQ7OUIQcEkJSWNGjVKRTZbdx/79u0jetIH++vl7u5++fJlqQ8UFBQ0NTWhKBoQEJCcnExoMGSCBCQvkUj04MEDLBk9fvx4x44dWVlZnz2DvUdPSkry9PS8e/cu1lFSbhhCoRBb8v/bb79hTQDiYBO6sbGxxDWRmZm5bNmytg4Mw35+fvrppzlz5mDzA11MF1kJTQI6nW5ra4tt+DAxMWloaOByuQMGDIiKirp586a1tTW2wwNBECsrK3d3dxRFzc3Njx8/fvLkyQEDBvTs2VNZYRgaGmJLum/evGlnZ6evr//+/XsDAwOl1A9aRURElJWVDRkyxNbWVumVc7ncjIwMKyurhw8fTps2bcCAAZ89UFBQsH//fiaT2adPH0tLy1WrVnX2i4Kl6rIroUnD5XLv3btnamrq7u4eERHR0tKyePFiLEdgkpOTtbS0HB0dQ0JCRCLRypUrjY2NldU6iqI0Gu3rr7+2sbEJCQnBPlRW5d2WSCTi8XgXL1708/Mjov6ioiJvb+/du3f/8251Dofz4cOHiRMnRkVFaWpqTpkyhYgAVAjVXbAupbS09Ny5c69evUJR9NChQ6Ghodh+fQyXy42KisrOzkZRdP/+/UePHlXibBE2+ktLSwsODoat9h1x+/btpKQkIlY//PXXX4sWLZK6jhlbC/Lu3btFixZhq2S7CegBEaWoqOjvv/92cXGxt7ffvXu3pqbmd99913riXH5+/sOHDydMmGBra7tnzx4bG5uFCxcqZUMjdtXasmXL0tPT9fT0iBg+tHr5qK78A0/IQ3ktIuJaIRPK4H0oyfL/aSZTXWmbS9PT083Nzc3MzA4fPuzp6YkdVIiRSCR0Oj04ODg1NRW7TLW7nY4ACYgMHz58ePr06fjx4y0sLNasWWNlZbVp0yYajYYNl9LS0uLi4lauXMlgMEJCQiZMmKCUzY3Z2dnbtm1bu3btF1980dTUpNw90C2N4vN7CweN1u+hp6ZrwBJLJEqsnEKCFrSmlJedWDt7tZWptXpHqsLOwDx69GhaWtrBgwd1dXU//WpKSsqFCxf8/f1tbGyysrLkvC2n64EERLbCwsJnz57NmTOHx+N5eXl5eHisWbMG26yMouidO3fy8/PXrFlTVlZ2+vTpf/3rX6NHj+5Ic1wuV19ff8OGDTweb/v27Z9OTuHGa5JcP1LswbbQ6KGSG6yV4cG5EtdpPS1s8fRHysvLQ0NDe/fuvWLFis/OV4iNjdXV1R05cuTp06ft7OzgfF54C0Y2PT29wYMH0+l0Fovl5uZGo9FsbW3r6+tnzpxZWFjo6+s7fPhwOp2uoaFRXl6ekZExduzYoqKikydPamtr4zhHCuvST5482cDAgMVi6evr//LLL0wmsyN3Xd49XeYy1VjHoAu+lGll66Bz/2zJ4NG6NLq8k/plZWWPHj3q379/Wlpar169Fi1ahCAIdvjU27dvjYyMrly5kpCQMGnSJB0dnWHDhmFXLXRzkICopKuri83RaGhoTJs2TVtb29ramsvlTpw4sby8fOXKlY6OjjQaTUtLKz8//82bN6NGjUpMTLxx44aFhcVnXfp29erVS19fH3vFc//+fXd398LCwvz8fEWvUauvEb14WDvcQwk9KVVGoyGl75uZ6vSepu0c7Y4gSEtLC51O9/b2dnFxsbOz69OnT+v5dhkZGXPmzLG2tnZwcBg8eLCHh4eOjg7x4XcaMARTRXw+Pzc318HBITc319vbe+nSpX5+fhwOR09Pj8lkXr9+3cTEZPr06deuXauoqPD09LSyssLRSmVl5ebNmx0cHNatW4eN1KQ+5uXlhV12hCnIaua8aho1XWkrCVTWm2dcBh0d4SFrgdXFixfDwsJu37796b+eRCLZtm1bRUVFRERESUmJkZFRuxdUdFud6VaM7kNdXd3BwQFBkP79+yclJWH3FnA4nG+//fbq1atLliwZNGjQ27dvXV1dGQxGamoqgiAxMTHYwjn5WzE2Nj5x4oSPjw92nTmbzc7Ly/vsmZkzZ+bk5KxYsaL1M3yeWMjvIlPOsqESpLlB/M/Pi8Xiy5cvx8fHIwhibm7+8OFDLPu8fPly69atRUVFEolk1KhRYWFhCIJYWFhA9pEBElAnYGFhgSDI1KlTY2JiFixYgCBIfX399u3bz5496+fnZ2Njk5CQ4ODgwGAwMjMzEQQJCwuLiIgQCoXyVI798sybN2/Lli08Hg9BkF9//RXb+oTNYWNn/vv7+xP/jao6DoeD9Xry8/Ox2wfd3d1TUlKysrKw41lHjRplaWmppqY2ffp0NTU1quPtBGAOqJPBJpXNzMzmzZvn6upKp9MrKyvPnj3LYrHYbHZKSsq7d+/GjBlTWFg4YMAAdXX1VatWFRUVOTs7t1uzkZGRqakp9h9xcXG9evUyMDAIDw9HEIRGoxUVFeXl5U2ePLm6RFBbIbS2J/sKTfJVFvHEIklvey3snsuFCxdqaWk5OTk5Ojq6ubmVlpYaGBiEhoYmJydjMzsjR47s378/rERXCMwBdSlJSUmxsbGrVq0yNDQMCgqys7NzcnLKyMjw9vaurq7euHGjh4cHdn6IPL8nM2bMKC0tbf2QwWBMmTKFPXPj+8xmt7mmBH8r1HudxM3nfEj/eGHfvn2VlZVisRibsM/IyFixYsUPP/wwc+ZM1T3svZOAXmKXMnr06NZ1Q9OnT3/x4oWjo+OgQYO8vLxGjx7t7++PzfJkZ2cfOHBg9uzZs2bNkpGMqqqqPv1QLBbHxsZqie2G2nX1DUr/VVpaunDhQgRBdHR0du/eXV1dfeTIEWNj40ePHmEzO5B9OgjmgLqsMWPGrFmzBltwFBQUZGFhMXTo0C+++GLatGkPHz4MCAjAdn7Ex8cvWbIkLi4Oe33zaQ0CgaB1tyC2pEVPTy8/P5+674lsVpZWd+7cwa7/Hj169OHDh2FeWblgCNbtlJeX5+fnu7q65uXlsdlsNps9fvx47EC1O3fuPHjwYPXq1c7OznPnzhUKha0nnBsbG3///ff9+vVrLtcve4d0kyHYk7iEoR6sSZMmUR1LlwWT0N2OtrY2tm7I0NBw6dKlxsbG9vb2zc3Nvr6+1tbWX331VWlpKY1G4/P52A0w2J61lpaWvLy8sWPHaqmZdp9JaHMzi/HTHagOpCuDIVi3xmAw7OzsEAQZOnRobGwsm812dHQ0NTUNCgrS0dH5bERWXFz8448/vnz5krp4QVcDCQj8D3Zs44gRI/78889vv/32swSEomhlZeXNmzepCxB0NfAWDEjXOs8qkUhotP/MFaqpqXXJg0EBVSABAem+++47LPswGAwDAwMzM7N+/fqNGTNGU9S3roTq4EBXAQkISCcQCOzt7e3t7UeOHDlkyBBzc3Ps829TG+pKmqmODnQRkICAdKdPn1ZWVcFbAysryn+PiJTjWdC9wCQ0AIAykIAAAJSBIRggyekzx6Jv/SUWi93/5bFq5XoWiyUSiSZNcfXzXfPN1z7YMz8Eraur4x4JO53HebsuwG9LUMgfJ8IKCwtMTczY7KU1NdU3o682NjY4OblsWB+sr2+AIMjdmJtRUZff53M0NbVGuoxes3oD9vngrYG9rHqrqandun1dJBS6urr5r93ceisJUBHQAwJkyM3LeZGestxv7SSPaTduXr3059l2izQ3N4f+ttdv2Zp9ew+z1NX3/7zjWUrClqCQ9QFBL16khB89iD32+nWmtXWf5d+tneE5NyHx0b6ft7fWcPlKZFlZScju0DWrN8Q/io08f4LIbxHgAT0gQAYLC6tDB35nMBiTJ08vLMyPf/Rg8be+7ZZasXydq6sbgiALF3jt2789wP8HG5u+Q5ChaWnPnqUkYM+sD/ixdTe/mppa5PmTfD5fXV0dQRArK+sff9hJo9HsBw5+/PTv56lJK5bDsWqqBRIQIIN2D+3Wkyv69On7+k2mPKXUWf+5mYvJZCEIwvzv2khjY5O6Oi7230Kh8Nr1Sw9i71RUlKmra0gkEi631tTUDEEQDXWN1txkamqelZVBwHcGOgQSECAbg8EQiTp0k2rrymwURX8MWvc297X34u8GDXJ88uTvS3+elaBSjqxmqjElEikHPANqQQIClOn46aUZGS/SXqQE/bjLY+JUBEGKiwqVFBogCUxCA8owGAwdHd2q6krsQxRFKyoUuNUDQZC6ei6CIP37Dfz0Q0lXuSe6O4AeEKDSSJfRD+7fHu7k0tPA8PKVyMLCgn7/zSbyGGTvwGKx/jgeNn36nPfv8y5cPIUgSP57jqUFnovSAPmgBwSotHpV4LBhznv3/bR95+Z+/QaOGDFKoeLGxibBQbvzODnbtm9KS3t28MDvrq5u165fIixeoGRwJCtQzNvUhu5zK4agRfTFHCOqA+nKoAcEAKAMJCAAAGUgAQEAKAMJCABAGUhAAADKQAICAFAGEhAAgDKQgAAAlIEEBACgDCQgAABlIAEBACgDCQgAQBlIQEAxNBrCUOsWPzZ0Bo2h1tEj04Bs3eInCShRDz21+hoB1VGQobFWqKnNoDqKLg4SEFBMTzN1Ab9bHK7c3CAytlKnOoouDhIQUIymNt26v1bmk1qqAyFWaX6LgCe26qdJdSBdHCQgoDC32UYtjaLMx102B31825TxqGbWCguqA+n64EREgNOTqKqKQj6DSTMwURcKushPkZAvqSpuMTBhTfc17/CdHaB9kIAAfg01ouoyQSNXJBEr4SKKd+/eZWRkzJ07V6FSV65cEQgEbDa74wEgCKKlq2Zsoa5nzFRKbaBdcCsGwE+np5pOT6X9CD15lTx10QhHV32FSh08kfD69euSpuRz584pKxJAGugBgU6Mx+N5eXkVFBSgKDp48OCzZ89SHRFQDExCA5VQXl7+5s0bRUtVV1fz+XzsktWsrKxvvvkG+xB0FpCAgEo4cOAAl8tVtFR5eXnrNfN0Oj03N9fPz6+hoYGAAAEhIAEB6gmFQjc3t9GjRytasLa2lsfjffqZ169fe3t7KzU6QCBIQIB6TCZz5syZOApWVlbW19dj/42iqEQiMTQ0vHbtmrIDBESBBASod/bs2cLCQhwFCwoKaDQagiA9e/YcNGjQixcv7t27R0CAgCiQgADFampqzp07Z21tjaPs5s2bzc3NU1NT79+/7+TklJqaSkCAgEDwGh5QrLy8vKWlpU+fPlQHAigACQh0Hbm5uf3796c6CqAAGIIBKrW0tPj4+CirtpMnT8bGxiqrNkACSECASg8fPlTi4MvLy6umpkZZtQESwBAMUKmiokJbW1tLS4vqQAA1oAcEqGRoaKjc7PP8+fOqqiolVggIBQkIUCY1NXX16tXKrZPD4Zw+fVq5dQLiQAIClMnKypo0aZJy6/T09LSzs1NunYA4MAcEAKAM9IAANcRiMYfDIaLmy5cvP3v2jIiagdJBAgLUSEhICA8PJ6JmLS2tO3fuEFEzUDo4khVQo6SkxMPDg4iaJ02aBBs7OguYAwIAUAaGYIAaubm5xFV+9OjRly9fElc/UBZIQIACeXl5W7duJa5+BoMB89CdAswBAQqUlJSMGzeOuPrnzp1bVlZGXP1AWWAOCABAGRiCAQrU19cLhUJCmwgODhaLxYQ2AToOEhCgwOLFi8vLywltIicn5+PHj4Q2AToOEhCgQHV1tZWVFaFN7Nq1S09Pj9AmQMfBHBAAgDLQAwJkwy7wIrqVW7duRUdHE90K6CBIQIBs9+/fDw4OJroVHo+XlZVFdCugg2AdECBbbW2tiYkJ0a14eHg4OTkR3QroIJgDAgBQBoZggGyNjY08Ho/oVkpKSnbt2kV0K6CDIAEBsu3evfvx48dEt0Kn05OTk4luBXQQJCBANlNTUwsLC6JbMTIyImGqG3QQzAEBACgDPSBAtsrKSpFIREJDGzZsIKEV0BGQgADZli9fXlxcTEJDCQkJAoGAhIYAbpCAANlMTEx69OhBQkMHDx5kMBgkNARwgzkgAABloAcEyFZWVkbCXjAEQYKCgurr60loCOAGCQiQzcvLi5y8kJaWxufzSWgI4AYJCJDN2NiYTifjB2/37t1wJJCKgzkgAABloAcEyJaZmUnOOqCdO3fW1NSQ0BDADRIQIFtAQEBjYyMJDaWkpJCw6xV0BCQgQLahQ4eqqZFxENXWrVt79uxJQkMAN5gDAgBQBnpAgGxTpkzhcrkkNBQSEgJzQCoOEhAgG2n3BSYlJcEckIqDIRggm1gsJmeLVnJy8rBhwzQ0NEhoC+ADCQgAQBkYggGy+fj4kDMHtHPnzrq6OhIaArhBAgJko9Fo5AzBnjx5Qs6KR4AbDMFAl5WQkDBq1Chy1hwBfCABAQAoA0MwQLb58+d//PiRhIbgTGjVBwkIkM3MzIyEqRkejwf3gqk+GIKBrkkoFD5//nzMmDFUBwJkgQQEyNbS0sJkMmFuGMAQDFDgwIED0dHRRLeSn58fFhZGdCuggyABAbKZm5uTsD4wLy+PnNvHQEfAEAx0TcXFxXw+39bWlupAgCyQgADZhEJhS0uLrq4u1YEA6sEQDJCttrZ20aJFRLcSFhb25s0bolsBHQQJCJDNxMSEyWQ2NzcT2srt27cNDQ0JbQJ0HAzBQBckFoszMzOHDRtGdSCgHZCAAAUaGxvpdLqWlhbVgQCKwRAMUOD58+dbt24lrv4bN25cvXqVuPqBskACAhRwcXFpaGggrv579+716tWLuPqBssAQDHRBpaWl5ubmVEcB2gcJCFCjuLiYwWCYmZlRHQigEgzBADWampoCAgKIqHnv3r0xMTFE1AyUDhIQoEb//v2dnZ0rKyuVXvPdu3c9PDyUXi0gAgzBAACUgR4QoIxAILh8+bJy6ywpKWlpaVFunYA4kIAAZVgsVnZ29q1bt5RVYW5ubmBgoKamprIqBESDBASoFBAQoMR88eLFi/Xr1yurNkACmAMCAFAGekCAYu/fvw8JCel4PYmJiXD+RqcDCQhQzNbWtrKy8vHjxx2ppKKiYufOnfb29sqLC5ABhmCAeiiKikQiJpOJu4acnBx9fX1YV93pQAICKqGoqEhbW1tfX5/qQACpYAgGVIKBgcHMmTPxlV27dm16erqyIwJkgB4QUBUZGRlCodDZ2VmhUunp6Wlpab6+voTFBQgECQgAQBkYggEVkpOT88svv8j//PPnz1+9ekVkRIBYkICAChk4cCCPx7t9+7Y8D3M4nAMHDjg6OhIfFyAKDMFAZ8XhcKysrDQ0NKgOBOAHPSCgcoqKipKSkmQ/U1NTo6+vD9mns4MEBFSOlZVVdHT0vXv32nqgsLBw2bJlRkZG5MYFlA8SEFBFISEhTCazrfmBmJiYiIgI0oMCygdzQEBFSSQSiUSipqZGdSCAQNADAiqKTqeHh4dHRUV9+sn8/HyF3tMDFQcJCKguf39/Ho/X3Nzc+pmIiIjly5dTGhRQJhiCAQAoAwNsoOouXLhAo9GGDx+enp7+1VdfUR0OUCboAYFOYNeuXVFRUampqVQHApQMEhDoBCQSCY1Go9FoVAcClAwSEACAMvAWDABAGUhAAADKQAICAFAGEhAAgDKQgAAAlIEEBACgzP8BUIE3T908YxEAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Image\n", + "\n", + "display(Image(graph.get_graph().draw_mermaid_png()))" + ] + }, + { + "cell_type": "markdown", + "id": "af856e1b-41fc-4041-8cbf-3818a60088e0", + "metadata": {}, + "source": [ + "### Test multi-turn conversation\n", + "\n", + "Let's test a multi turn conversation with this application." + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "161e0cf1-d13a-4026-8f89-bdab67d1ad4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Conversation Turn 1 ---\n", + "\n", + "User: {'messages': [{'role': 'user', 'content': 'i wanna go somewhere warm in the caribbean'}]}\n", + "\n", + "travel_advisor: The Caribbean is full of warm and beautiful destinations. Some popular options include Jamaica, the Bahamas, the Dominican Republic, and Aruba. Each of these places offers stunning beaches, vibrant culture, and plenty of activities to enjoy. Would you like recommendations on sightseeing or accommodations in any specific location?\n", + "\n", + "--- Conversation Turn 2 ---\n", + "\n", + "User: Command(resume='could you recommend a nice hotel in one of the areas and tell me which area it is.')\n", + "\n", + "travel_advisor: I'll get a hotel recommendation for you.\n", + "hotel_advisor: I recommend the \"Half Moon Resort\" located in Montego Bay, Jamaica. It's a luxurious resort known for its beautiful private beaches, excellent service, and a variety of amenities including golf, spas, and fine dining. Montego Bay is a vibrant area offering plenty of activities, from snorkeling and diving to exploring local culture and nightlife.\n", + "\n", + "--- Conversation Turn 3 ---\n", + "\n", + "User: Command(resume='could you recommend something to do near the hotel?')\n", + "\n", + "hotel_advisor: I recommend visiting the Rose Hall Great House, a historic plantation house located near Montego Bay. It's known for its intriguing history and beautiful architecture, offering guided tours that include tales of the White Witch of Rose Hall. Additionally, you could explore Dunn's River Falls, a stunning natural waterfall that you can climb, located a bit further but well worth the trip. For a more relaxing day, you might enjoy a catamaran cruise along the coast, which often includes snorkeling stops and beautiful sunset views.\n" + ] + } + ], + "source": [ + "import uuid\n", + "\n", + "thread_config = {\n", + " \"configurable\": {\n", + " \"thread_id\": uuid.uuid4()\n", + " }\n", + "}\n", + "\n", + "inputs = [\n", + " # 1st round of conversation,\n", + " {\"messages\": [{\n", + " \"role\": \"user\", \n", + " \"content\": \"i wanna go somewhere warm in the caribbean\"\n", + " }]},\n", + " # Since we're using `interrupt`, we'll need to resume using the Command primitive.\n", + " # 2nd round of conversation,\n", + " Command(resume=\"could you recommend a nice hotel in one of the areas and tell me which area it is.\"),\n", + " # 3rd round of conversation,\n", + " Command(resume=\"could you recommend something to do near the hotel?\"),\n", + "]\n", + "\n", + "for idx, user_input in enumerate(inputs):\n", + " print()\n", + " print(f'--- Conversation Turn {idx + 1} ---')\n", + " print()\n", + " print(f\"User: {user_input}\")\n", + " print()\n", + " for update in graph.stream(\n", + " user_input,\n", + " config=thread_config,\n", + " stream_mode='updates',\n", + " ):\n", + " for node_id, value in update.items():\n", + " if isinstance(value, dict) and value.get('messages', []):\n", + " last_message = value['messages'][-1]\n", + " if last_message['role'] != \"ai\":\n", + " continue\n", + " print(f\"{last_message['name']}: {last_message['content']}\")" + ] + } + ], + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}