diff --git a/multi_agent.ipynb b/multi_agent.ipynb
new file mode 100644
index 0000000..3eb5afc
--- /dev/null
+++ b/multi_agent.ipynb
@@ -0,0 +1,2292 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# LangGraph 101: Building Multi-Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this notebook, we're going to walk through setting up a **multi-agent workflow** in LangGraph. We will start from a simple ReAct agent and add additional steps into the workflow, simulating a realistic customer support example, showcasing human-in-the-loop, long term memory, and the LangGraph pre-built library. \n",
+    "\n",
+    "The agent utilizes the [Chinook database](https://www.sqlitetutorial.net/sqlite-sample-database/), and is able to handle customer inqueries related to invoice and music. \n",
+    "\n",
+    "![Arch](../images/architecture.png) \n",
+    "\n",
+    "\n",
+    "\n",
+    "For a deeper dive into LangGraph primitives and learning our framework, check out our [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph)!\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pre-work: Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Loading environment variables"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To start, let's load our environment variables from our .env file. Make sure all of the keys necessary in .env.example are included!\n",
+    "We use OpenAI in this example, but feel free to swap ChatOpenAI with other model providers that you prefer. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "load_dotenv(dotenv_path=\"../.env\", override=True)\n",
+    "model = ChatOpenAI(model=\"o3-mini\")\n",
+    "\n",
+    "# Note: If you are using another `ChatModel`, you can define it in `models.py` and import it here\n",
+    "# from models import AZURE_OPENAI_GPT_4O\n",
+    "# llm = AZURE_OPENAI_GPT_4O"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Loading sample customer data\n",
+    "\n",
+    "The agent utilizes the [Chinook database](https://www.sqlitetutorial.net/sqlite-sample-database/), which contains sample information on customer information, purchase history, and music catalog. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sqlite3\n",
+    "import requests\n",
+    "from langchain_community.utilities.sql_database import SQLDatabase\n",
+    "from sqlalchemy import create_engine\n",
+    "from sqlalchemy.pool import StaticPool\n",
+    "\n",
+    "def get_engine_for_chinook_db():\n",
+    "    \"\"\"Pull sql file, populate in-memory database, and create engine.\"\"\"\n",
+    "    url = \"https://raw.githubusercontent.com/lerocha/chinook-database/master/ChinookDatabase/DataSources/Chinook_Sqlite.sql\"\n",
+    "    response = requests.get(url)\n",
+    "    sql_script = response.text\n",
+    "\n",
+    "    connection = sqlite3.connect(\":memory:\", check_same_thread=False)\n",
+    "    connection.executescript(sql_script)\n",
+    "    return create_engine(\n",
+    "        \"sqlite://\",\n",
+    "        creator=lambda: connection,\n",
+    "        poolclass=StaticPool,\n",
+    "        connect_args={\"check_same_thread\": False},\n",
+    "    )\n",
+    "\n",
+    "engine = get_engine_for_chinook_db()\n",
+    "db = SQLDatabase(engine)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Setting up short-term and long-term memory "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will also initialize a checkpointer for **short-term memory**, maintaining context within a single thread. \n",
+    "\n",
+    "**Long term memory** lets you store and recall information between conversations. Today, we will utilize our long term memory store to store user preferences for personalization. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.store.memory import InMemoryStore\n",
+    "\n",
+    "# Initializing long term memory store \n",
+    "in_memory_store = InMemoryStore()\n",
+    "\n",
+    "# Initializing checkpoint for thread-level memory \n",
+    "checkpointer = MemorySaver()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 1: Building ReAct Sub-Agents"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Building a ReAct Agent from Scratch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we are set up, we are ready to build out our **first subagent**. This is a simple ReAct agent that fetches information related to music store catalog, utilizing a set of tools to generate its response. \n",
+    "\n",
+    "![react_1](../images/music_subagent.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### State"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "How does information flow through the steps?  \n",
+    "\n",
+    "State is the first LangGraph concept we'll cover. **State can be thought of as the memory of the agent - its a shared data structure that’s passed on between the nodes of your graph**, representing the current snapshot of your application. \n",
+    "\n",
+    "For this our customer support agent our state will track the following elements: \n",
+    "1. The customer ID\n",
+    "2. Conversation history\n",
+    "3. Memory from long term memory store\n",
+    "4. Remaining steps, which tracks # steps until it hits recursion limit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing_extensions import TypedDict\n",
+    "from typing import Annotated, List\n",
+    "from langgraph.graph.message import AnyMessage, add_messages\n",
+    "from langgraph.managed.is_last_step import RemainingSteps\n",
+    "\n",
+    "class State(TypedDict):\n",
+    "    customer_id: str\n",
+    "    messages: Annotated[list[AnyMessage], add_messages]\n",
+    "    loaded_memory: str\n",
+    "    remaining_steps: RemainingSteps "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Tools\n",
+    "Let's define a list of **tools** our agent will have access to. Tools are functionts that can act as extension of the LLM's capabilities. In our case, we will create several tools that interacts with the Chinook database regarding invoices. \n",
+    "\n",
+    "We can create tools using the @tool decorator to create a tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.tools import tool\n",
+    "import ast\n",
+    "\n",
+    "@tool\n",
+    "def get_albums_by_artist(artist: str):\n",
+    "    \"\"\"Get albums by an artist.\"\"\"\n",
+    "    return db.run(\n",
+    "        f\"\"\"\n",
+    "        SELECT Album.Title, Artist.Name \n",
+    "        FROM Album \n",
+    "        JOIN Artist ON Album.ArtistId = Artist.ArtistId \n",
+    "        WHERE Artist.Name LIKE '%{artist}%';\n",
+    "        \"\"\",\n",
+    "        include_columns=True\n",
+    "    )\n",
+    "\n",
+    "@tool\n",
+    "def get_tracks_by_artist(artist: str):\n",
+    "    \"\"\"Get songs by an artist (or similar artists).\"\"\"\n",
+    "    return db.run(\n",
+    "        f\"\"\"\n",
+    "        SELECT Track.Name as SongName, Artist.Name as ArtistName \n",
+    "        FROM Album \n",
+    "        LEFT JOIN Artist ON Album.ArtistId = Artist.ArtistId \n",
+    "        LEFT JOIN Track ON Track.AlbumId = Album.AlbumId \n",
+    "        WHERE Artist.Name LIKE '%{artist}%';\n",
+    "        \"\"\",\n",
+    "        include_columns=True\n",
+    "    )\n",
+    "\n",
+    "@tool\n",
+    "def get_songs_by_genre(genre: str):\n",
+    "    \"\"\"\n",
+    "    Fetch songs from the database that match a specific genre.\n",
+    "    \n",
+    "    Args:\n",
+    "        genre (str): The genre of the songs to fetch.\n",
+    "    \n",
+    "    Returns:\n",
+    "        list[dict]: A list of songs that match the specified genre.\n",
+    "    \"\"\"\n",
+    "    genre_id_query = f\"SELECT GenreId FROM Genre WHERE Name LIKE '%{genre}%'\"\n",
+    "    genre_ids = db.run(genre_id_query)\n",
+    "    if not genre_ids:\n",
+    "        return f\"No songs found for the genre: {genre}\"\n",
+    "    genre_ids = ast.literal_eval(genre_ids)\n",
+    "    genre_id_list = \", \".join(str(gid[0]) for gid in genre_ids)\n",
+    "\n",
+    "    songs_query = f\"\"\"\n",
+    "        SELECT Track.Name as SongName, Artist.Name as ArtistName\n",
+    "        FROM Track\n",
+    "        LEFT JOIN Album ON Track.AlbumId = Album.AlbumId\n",
+    "        LEFT JOIN Artist ON Album.ArtistId = Artist.ArtistId\n",
+    "        WHERE Track.GenreId IN ({genre_id_list})\n",
+    "        GROUP BY Artist.Name\n",
+    "        LIMIT 8;\n",
+    "    \"\"\"\n",
+    "    songs = db.run(songs_query, include_columns=True)\n",
+    "    if not songs:\n",
+    "        return f\"No songs found for the genre: {genre}\"\n",
+    "    formatted_songs = ast.literal_eval(songs)\n",
+    "    return [\n",
+    "        {\"Song\": song[\"SongName\"], \"Artist\": song[\"ArtistName\"]}\n",
+    "        for song in formatted_songs\n",
+    "    ]\n",
+    "\n",
+    "@tool\n",
+    "def check_for_songs(song_title):\n",
+    "    \"\"\"Check if a song exists by its name.\"\"\"\n",
+    "    return db.run(\n",
+    "        f\"\"\"\n",
+    "        SELECT * FROM Track WHERE Name LIKE '%{song_title}%';\n",
+    "        \"\"\",\n",
+    "        include_columns=True\n",
+    "    )\n",
+    "\n",
+    "music_tools = [get_albums_by_artist, get_tracks_by_artist, get_songs_by_genre, check_for_songs]\n",
+    "llm_with_music_tools = model.bind_tools(music_tools)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Nodes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have a list of tools, we are ready to build nodes that interact with them. \n",
+    "\n",
+    "Nodes are just python (or JS/TS!) functions. Nodes take in your graph's State as input, execute some logic, and return a new State. \n",
+    "\n",
+    "Here, we're just going to set up 2 nodes for our ReAct agent:\n",
+    "1. **music_assistant**: Reasoning node that decides which function to invoke \n",
+    "2. **music_tools**: Node that contains all the available tools and executes the function\n",
+    "\n",
+    "LangGraph has a pre-built ToolNode that we can utilize to create a node for our tools. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.prebuilt import ToolNode\n",
+    "# Node\n",
+    "music_tool_node = ToolNode(music_tools)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import ToolMessage, SystemMessage, HumanMessage\n",
+    "from langchain_core.runnables import RunnableConfig\n",
+    "\n",
+    "# Music assistant prompt\n",
+    "def generate_music_assistant_prompt(memory: str = \"None\") -> str:\n",
+    "    return f\"\"\"\n",
+    "    You are a member of the assistant team, your role specifically is to focused on helping customers discover and learn about music in our digital catalog. \n",
+    "    If you are unable to find playlists, songs, or albums associated with an artist, it is okay. \n",
+    "    Just inform the customer that the catalog does not have any playlists, songs, or albums associated with that artist.\n",
+    "    You also have context on any saved user preferences, helping you to tailor your response. \n",
+    "    \n",
+    "    CORE RESPONSIBILITIES:\n",
+    "    - Search and provide accurate information about songs, albums, artists, and playlists\n",
+    "    - Offer relevant recommendations based on customer interests\n",
+    "    - Handle music-related queries with attention to detail\n",
+    "    - Help customers discover new music they might enjoy\n",
+    "    - You are routed only when there are questions related to music catalog; ignore other questions. \n",
+    "    \n",
+    "    SEARCH GUIDELINES:\n",
+    "    1. Always perform thorough searches before concluding something is unavailable\n",
+    "    2. If exact matches aren't found, try:\n",
+    "       - Checking for alternative spellings\n",
+    "       - Looking for similar artist names\n",
+    "       - Searching by partial matches\n",
+    "       - Checking different versions/remixes\n",
+    "    3. When providing song lists:\n",
+    "       - Include the artist name with each song\n",
+    "       - Mention the album when relevant\n",
+    "       - Note if it's part of any playlists\n",
+    "       - Indicate if there are multiple versions\n",
+    "    \n",
+    "    Additional context is provided below: \n",
+    "\n",
+    "    Prior saved user preferences: {memory}\n",
+    "    \n",
+    "    Message history is also attached.  \n",
+    "    \"\"\"\n",
+    "\n",
+    "# Node \n",
+    "def music_assistant(state: State, config: RunnableConfig): \n",
+    "\n",
+    "    # Fetching long term memory. \n",
+    "    memory = \"None\" \n",
+    "    if \"loaded_memory\" in state: \n",
+    "        memory = state[\"loaded_memory\"]\n",
+    "\n",
+    "    # Intructions for our agent  \n",
+    "    music_assistant_prompt = generate_music_assistant_prompt(memory)\n",
+    "\n",
+    "    # Invoke the model\n",
+    "    response = llm_with_music_tools.invoke([SystemMessage(music_assistant_prompt)] + state[\"messages\"])\n",
+    "    \n",
+    "    # Update the state\n",
+    "    return {\"messages\": [response]}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Edges"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we need to define a control flow that connects between our defined nodes, and that's where the concept of edges come in.\n",
+    "\n",
+    "**Edges are connections between nodes. They define the flow of the graph.**\n",
+    "* **Normal edges** are deterministic and always go from one node to its defined target\n",
+    "* **Conditional edges** are used to dynamically route between nodes, implemented as functions that return the next node to visit based upon some logic. \n",
+    "\n",
+    "In this case, we want a **conditional edge** from our subagent that determines whether to: \n",
+    "- Invoke tools, or,\n",
+    "- Route to the end if user query has been finished "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Conditional edge that determines whether to continue or not\n",
+    "def should_continue(state: State, config: RunnableConfig):\n",
+    "    messages = state[\"messages\"]\n",
+    "    last_message = messages[-1]\n",
+    "    \n",
+    "    # If there is no function call, then we finish\n",
+    "    if not last_message.tool_calls:\n",
+    "        return \"end\"\n",
+    "    # Otherwise if there is, we continue\n",
+    "    else:\n",
+    "        return \"continue\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Compile Graph!\n",
+    "\n",
+    "Now that we've defined our State and Nodes, let's put it all together and construct our react agent!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph, START, END\n",
+    "from IPython.display import Image, display\n",
+    "\n",
+    "music_workflow = StateGraph(State)\n",
+    "\n",
+    "# Add nodes \n",
+    "music_workflow.add_node(\"music_assistant\", music_assistant)\n",
+    "music_workflow.add_node(\"music_tool_node\", music_tool_node)\n",
+    "\n",
+    "\n",
+    "# Add edges \n",
+    "# First, we define the start node. The query will always route to the subagent node first. \n",
+    "music_workflow.add_edge(START, \"music_assistant\")\n",
+    "\n",
+    "# We now add a conditional edge\n",
+    "music_workflow.add_conditional_edges(\n",
+    "    \"music_assistant\",\n",
+    "    # Function representing our conditional edge\n",
+    "    should_continue,\n",
+    "    {\n",
+    "        # If `tools`, then we call the tool node.\n",
+    "        \"continue\": \"music_tool_node\",\n",
+    "        # Otherwise we finish.\n",
+    "        \"end\": END,\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "music_workflow.add_edge(\"music_tool_node\", \"music_assistant\")\n",
+    "\n",
+    "music_catalog_subagent = music_workflow.compile(name=\"music_catalog_subagent\", checkpointer=checkpointer, store = in_memory_store)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "USER_AGENT environment variable not set, consider setting it to identify your requests.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from utils import visualize_graph\n",
+    "visualize_graph(music_catalog_subagent)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Testing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's see how it works!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "I like the Rolling Stones. What songs do you recommend by them or by other artists that I might like?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Tool Calls:\n",
+      "  get_tracks_by_artist (call_uzLaRvCMEPXJHZvLp6MHtcoB)\n",
+      " Call ID: call_uzLaRvCMEPXJHZvLp6MHtcoB\n",
+      "  Args:\n",
+      "    artist: The Rolling Stones\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: get_tracks_by_artist\n",
+      "\n",
+      "[{'SongName': 'Time Is On My Side', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Heart Of Stone', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Play With Fire', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Satisfaction', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'As Tears Go By', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Get Off Of My Cloud', 'ArtistName': 'The Rolling Stones'}, {'SongName': \"Mother's Little Helper\", 'ArtistName': 'The Rolling Stones'}, {'SongName': '19th Nervous Breakdown', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Paint It Black', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Under My Thumb', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Ruby Tuesday', 'ArtistName': 'The Rolling Stones'}, {'SongName': \"Let's Spend The Night Together\", 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Intro', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'You Got Me Rocking', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Gimmie Shelters', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Flip The Switch', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Memory Motel', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Corinna', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Saint Of Me', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Wainting On A Friend', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Sister Morphine', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Live With Me', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Respectable', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Thief In The Night', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'The Last Time', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Out Of Control', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Love Is Strong', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'You Got Me Rocking', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Sparks Will Fly', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'The Worst', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'New Faces', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Moon Is Up', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Out Of Tears', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'I Go Wild', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Brand New Car', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Sweethearts Together', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Suck On The Jugular', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Blinded By Rainbows', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Baby Break It Down', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Thru And Thru', 'ArtistName': 'The Rolling Stones'}, {'SongName': 'Mean Disposition', 'ArtistName': 'The Rolling Stones'}]\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Here are some great Rolling Stones tracks you might enjoy from our catalog:\n",
+      "\n",
+      "• Time Is On My Side  \n",
+      "• Satisfaction  \n",
+      "• Paint It Black  \n",
+      "• Ruby Tuesday  \n",
+      "• Let's Spend The Night Together  \n",
+      "\n",
+      "These songs capture the classic, energetic vibe of the Stones. If you enjoy their sound, you might also like exploring classic rock by other legendary bands—artists like The Beatles, Led Zeppelin, and The Who offer a similar spirit in their music. Let me know if you'd like recommendations or more details about those artists!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uuid\n",
+    "thread_id = uuid.uuid4()\n",
+    "\n",
+    "question = \"I like the Rolling Stones. What songs do you recommend by them or by other artists that I might like?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = music_catalog_subagent.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "\n",
+    "for message in result[\"messages\"]:\n",
+    "   message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2. Building ReAct Agent using LangGraph Pre-built"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "LangGraph offers pre-built libraries for common architectures, allowing us to quickly create architectures like ReAct or multi-agent architacture. A full list of pre-built libraries can be found here: https://langchain-ai.github.io/langgraph/prebuilt/#available-libraries \n",
+    "\n",
+    "In the last workflow, we have seen how we can build a ReAct agent from scratch. Now, we will show how we can leverage the LangGraph pre-built libraries to achieve similar results. \n",
+    "\n",
+    "![react_2](../images/invoice_subagent.png)\n",
+    "\n",
+    "Our **invoice info subagent** is responsible for all customer queries related to the invoices. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Defining tools and prompt\n",
+    "Similarly, let's first define a set of tools and our agent prompt below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.tools import tool\n",
+    "\n",
+    "@tool \n",
+    "def get_invoices_by_customer_sorted_by_date(customer_id: str) -> list[dict]:\n",
+    "    \"\"\"\n",
+    "    Look up all invoices for a customer using their ID.\n",
+    "    The invoices are sorted in descending order by invoice date, which helps when the customer wants to view their most recent/oldest invoice, or if \n",
+    "    they want to view invoices within a specific date range.\n",
+    "    \n",
+    "    Args:\n",
+    "        customer_id (str): customer_id, which serves as the identifier.\n",
+    "    \n",
+    "    Returns:\n",
+    "        list[dict]: A list of invoices for the customer.\n",
+    "    \"\"\"\n",
+    "    return db.run(f\"SELECT * FROM Invoice WHERE CustomerId = {customer_id} ORDER BY InvoiceDate DESC;\")\n",
+    "\n",
+    "\n",
+    "@tool \n",
+    "def get_invoices_sorted_by_unit_price(customer_id: str) -> list[dict]:\n",
+    "    \"\"\"\n",
+    "    Use this tool when the customer wants to know the details of one of their invoices based on the unit price/cost of the invoice.\n",
+    "    This tool looks up all invoices for a customer, and sorts the unit price from highest to lowest. In order to find the invoice associated with the customer, \n",
+    "    we need to know the customer ID.\n",
+    "    \n",
+    "    Args:\n",
+    "        customer_id (str): customer_id, which serves as the identifier.\n",
+    "    \n",
+    "    Returns:\n",
+    "        list[dict]: A list of invoices sorted by unit price.\n",
+    "    \"\"\"\n",
+    "    query = f\"\"\"\n",
+    "        SELECT Invoice.*, InvoiceLine.UnitPrice\n",
+    "        FROM Invoice\n",
+    "        JOIN InvoiceLine ON Invoice.InvoiceId = InvoiceLine.InvoiceId\n",
+    "        WHERE Invoice.CustomerId = {customer_id}\n",
+    "        ORDER BY InvoiceLine.UnitPrice DESC;\n",
+    "    \"\"\"\n",
+    "    return db.run(query)\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def get_employee_by_invoice_and_customer(invoice_id: str, customer_id: str) -> dict:\n",
+    "    \"\"\"\n",
+    "    This tool will take in an invoice ID and a customer ID and return the employee information associated with the invoice.\n",
+    "\n",
+    "    Args:\n",
+    "        invoice_id (int): The ID of the specific invoice.\n",
+    "        customer_id (str): customer_id, which serves as the identifier.\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: Information about the employee associated with the invoice.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    query = f\"\"\"\n",
+    "        SELECT Employee.FirstName, Employee.Title, Employee.Email\n",
+    "        FROM Employee\n",
+    "        JOIN Customer ON Customer.SupportRepId = Employee.EmployeeId\n",
+    "        JOIN Invoice ON Invoice.CustomerId = Customer.CustomerId\n",
+    "        WHERE Invoice.InvoiceId = ({invoice_id}) AND Invoice.CustomerId = ({customer_id});\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    employee_info = db.run(query, include_columns=True)\n",
+    "    \n",
+    "    if not employee_info:\n",
+    "        return f\"No employee found for invoice ID {invoice_id} and customer identifier {customer_id}.\"\n",
+    "    return employee_info\n",
+    "\n",
+    "invoice_tools = [get_invoices_by_customer_sorted_by_date, get_invoices_sorted_by_unit_price, get_employee_by_invoice_and_customer]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "invoice_subagent_prompt = \"\"\"\n",
+    "    You are a subagent among a team of assistants. You are specialized for retrieving and processing invoice information. You are routed for invoice-related portion of the questions, so only respond to them.. \n",
+    "\n",
+    "    You have access to three tools. These tools enable you to retrieve and process invoice information from the database. Here are the tools:\n",
+    "    - get_invoices_by_customer_sorted_by_date: This tool retrieves all invoices for a customer, sorted by invoice date.\n",
+    "    - get_invoices_sorted_by_unit_price: This tool retrieves all invoices for a customer, sorted by unit price.\n",
+    "    - get_employee_by_invoice_and_customer: This tool retrieves the employee information associated with an invoice and a customer.\n",
+    "    \n",
+    "    If you are unable to retrieve the invoice information, inform the customer you are unable to retrieve the information, and ask if they would like to search for something else.\n",
+    "    \n",
+    "    CORE RESPONSIBILITIES:\n",
+    "    - Retrieve and process invoice information from the database\n",
+    "    - Provide detailed information about invoices, including customer details, invoice dates, total amounts, employees associated with the invoice, etc. when the customer asks for it.\n",
+    "    - Always maintain a professional, friendly, and patient demeanor\n",
+    "    \n",
+    "    You may have additional context that you should use to help answer the customer's query. It will be provided to you below:\n",
+    "    \"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Using the pre-built library\n",
+    "Now, let's put them together by using the pre-built ReAct agent library"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "# Define the subagent \n",
+    "invoice_information_subagent = create_react_agent(model, tools=invoice_tools, name=\"invoice_information_subagent\",prompt=invoice_subagent_prompt, state_schema=State, checkpointer=checkpointer, store=in_memory_store)\n",
+    "\n",
+    "# Visualize the graph\n",
+    "visualize_graph(invoice_information_subagent)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Testing!\n",
+    "Let's try our new agent out!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "My customer id is 1. What was my most recent invoice, and who was the employee that helped me with it?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "Tool Calls:\n",
+      "  get_invoices_by_customer_sorted_by_date (call_oHvvFx5za7SXAoeuzZXK2mrN)\n",
+      " Call ID: call_oHvvFx5za7SXAoeuzZXK2mrN\n",
+      "  Args:\n",
+      "    customer_id: 1\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: get_invoices_by_customer_sorted_by_date\n",
+      "\n",
+      "[(382, 1, '2025-08-07 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 8.91), (327, 1, '2024-12-07 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 13.86), (316, 1, '2024-10-27 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 1.98), (195, 1, '2023-05-06 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 0.99), (143, 1, '2022-09-15 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 5.94), (121, 1, '2022-06-13 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 3.96), (98, 1, '2022-03-11 00:00:00', 'Av. Brigadeiro Faria Lima, 2170', 'São José dos Campos', 'SP', 'Brazil', '12227-000', 3.98)]\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "Tool Calls:\n",
+      "  get_employee_by_invoice_and_customer (call_jR2NRYLnaKhAvpH9px5n0brd)\n",
+      " Call ID: call_jR2NRYLnaKhAvpH9px5n0brd\n",
+      "  Args:\n",
+      "    invoice_id: 382\n",
+      "    customer_id: 1\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: get_employee_by_invoice_and_customer\n",
+      "\n",
+      "[{'FirstName': 'Jane', 'Title': 'Sales Support Agent', 'Email': 'jane@chinookcorp.com'}]\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Your most recent invoice is invoice ID 382, dated 2025-08-07, from the address \"Av. Brigadeiro Faria Lima, 2170, São José dos Campos, SP, Brazil\" with an amount of 8.91. The employee who assisted you with this invoice is Jane, a Sales Support Agent (jane@chinookcorp.com).\n"
+     ]
+    }
+   ],
+   "source": [
+    "thread_id = uuid.uuid4()\n",
+    "question = \"My customer id is 1. What was my most recent invoice, and who was the employee that helped me with it?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = invoice_information_subagent.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 2: Building multi-agent architecture"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have two sub-agents that have different capabilities. How do we make sure customer tasks are appropriately routed between them? \n",
+    "\n",
+    "This is where the supervisor oversees the workflow, invoking appropriate subagents for relevant inquiries. \n",
+    "\n",
+    "\n",
+    "A **multi-agent architecture** offers several key benefits:\n",
+    "- Specialization & Modularity – Each sub-agent is optimized for a specific task, improving system accuracy \n",
+    "- Flexibility – Agents can be quickly added, removed, or modified without affecting the entire system\n",
+    "\n",
+    "![supervisor](../images/supervisor.png)\n",
+    "\n",
+    "We will show how we can utilize the pre-built supervisor to quickly create the multi-agent architecture. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, we will create a set of instructions for our supervisor. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "supervisor_prompt = \"\"\"You are an expert customer support assistant for a digital music store. \n",
+    "You are dedicated to providing exceptional service and ensuring customer queries are answered thoroughly. \n",
+    "You have a team of subagents that you can use to help answer queries from customers. \n",
+    "Your primary role is to serve as a supervisor/planner for this multi-agent team that helps answer queries from customers. \n",
+    "\n",
+    "Your team is composed of two subagents that you can use to help answer the customer's request:\n",
+    "1. music_catalog_information_subagent: this subagent has access to user's saved music preferences. It can also retrieve information about the digital music store's music \n",
+    "catalog (albums, tracks, songs, etc.) from the database. \n",
+    "3. invoice_information_subagent: this subagent is able to retrieve information about a customer's past purchases or invoices \n",
+    "from the database. \n",
+    "\n",
+    "Based on the existing steps that have been taken in the messages, your role is to generate the next subagent that needs to be called. \n",
+    "This could be one step in an inquiry that needs multiple sub-agent calls. \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAB7wAAAMGCAYAAABhy/umAAABL2lDQ1BTa2lhAAAokX2Qv0vDUBSFP0tB1C6iooNDxi5qW7E/sA62atGxVahuaRqK2NaQRnTv6h/h7Ca4iNDZxUlwEnFxFwTXeNIMKUi9l5v7vfMOee8+iC2hiKeg0/XcaqVk1I9PjMkPJpTDMK2ew/iQ6+c19L6s/OMbF1NNu2epf6k8V4frl03xfCvkq4AbIV8HfOk5nvgmYPewWhbfi5OtEW6MsOW4gf9NXOy0L6zo3iTs7lFNva5apsK5skUbmzVqnHGKKUqxS4E86+rbyg1VmoyUAlmtUpQpkdM3x56UvPbS7AxZjuA9wyP777A18H3/MdIOBnCXhemHSEtuwmwCnp4jLXpjx3TNoRRXxewSfC9olFuY+4SZvtTFYHvMrMafWQ326WKxKspomjTZXwyUTdpToV43AAAgAElEQVR4nOzde3CX9Z0v8E/I/ZcASSAQIAQVtIriXUSltlW81NWlrR7vPaJ1rdt25pzuznT2TDvu7px2Z2d3bbuzs9vT1rrt6UVr3Updqha11dZatNoVpagIyv0SLgkhCbmS8wfHX4gJEDC/PHnC6zXj8Hy/v+f5PW8czMjv/ft+n7yenp6eAAAAAAAAAICUGZN0AAAAAAAAAAA4GgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACpVJB0AAAAAICRYFd9RzTsaI/d2zuiZU9XdHbsi8727uho3xed7T3R1dWTdEQ4pILCvCgsHhNFxWOisGj/r2XjCqKiujgqJxZFxcSipCMCAMCQU3gDAAAAx5wdW9pjw+rm2LC6JbZvbo+mXZ1JR4JhUTGxMKqnlkTdiWVRO6s8qiYpwQEASLe8np4eX08GAAAARrW2lu54a0VTrH2jOTaubom21n1JR4IRITM2P6bPKovjTimPWaeOi6IST0AEACBdFN4AAADAqNTc2BmrljfFW681xeZ39h72/JLMmKiaVBxVk4pjbFVBFBXn798aumRMFBXnR2Fh3jCkhqPX0dHTuw1/275ob++Opl2dsWtbR+yqb4+OtsN/0aPuxEzMOn1cnHT6uCgttzkkAAAjn8IbAAAAGFV2bGmP3z6+Ld7+Y/NBzxlXWRA1M0pjSl0maupKY+KUEitbGfVa93TFrvr22Lp+b2xZ1xpb1rVFS1PXQc8/+exxccEVkzz7GwCAEU3hDQAAAIwK9Rvb4vkntsU7r7f0ey2/MC9mnTY2Tjx9XEyfVR4lGeU2RETsbe6KtW82x6pXmuLtlQN/SeSkM8bGBVdO9rxvAABGJIU3AAAAkGotuzvjl49sidWv9S/rTji1PE45Z3zMnD0u8m1JDofU2d4Tq1fsjtdf2h3rVvX/4sipcyvi4qsnR0lZfgLpAABgYApvAAAAILVefHp7vPDUjujq6Pvxhq2Y4f3ZsaU9nn9iW6xZ0feLJMWlY+KiqybFGRdWJZQMAAD6UngDAAAAqbNxTUv84sFN0bSr7/OHFd0wtA5WfE+sKYrLbpgWNXWlCSUDAID9FN4AAABAqjz98JZ49XcNfeYmTy+Jy66fFtVTixNKBaPb5nda48mHNseu+o4+83MXTIiLPjo5oVQAAKDwBgAAAFJiT0Nn/Oz+9bF9c3t2rrh0THzw6skxZ15lgsng2PHyMzvj+V/U93mMwLQTMnHNbbVRWl6QYDIAAI5VCm8AAABgxHvnjeZ47Psbo6NtX3Zu6nGlcc2i6ZEZq2SD4dS0qzMevX9dbN/Su9o7U54f1yyaHlOPzySYDACAY5HCGwAAABjRXvrVjvjNkvo+cxdcOTHmXTYpoURARMSzj26NPzy7q8/clbdMjVPOrkgoEQAAxyKFNwAAADBiPf0fW+LV53uf150Zmx9/umh6TDnOKlIYCdatao6f/9+N0b63d/eFi66qjrmXVieYCgCAY4nCGwAAABiRlnxvQ7z16p7suHpqcVz76RmeEwwjTNOuznj4/6yN3Ts7s3OnX1gZl147JcFUAAAcKxTeAAAAwIjzH/9nbax/qzU7rp2ZiY/fOSMKivISTAUczN7mrvjpt9ZH/aa27NyJZ4yNq//79ARTAQBwLFB4AwAAACPK4vvWxTuvt2THJ5xaHgvvqEswETAYnR09sfi+dbFxTe+XVU6bWxGX3TA1wVQAAIx2Cm8AAABgxHjyx5tjxYuN2fHpF1TGpdfZFhnS5L2PIzjv0gkx/6rJCSYCAGA0G5N0AAAAAICIiOce29an7P7AWWOV3ZBCV982PWZ8oCw7/v3TO2P5b3clmAgAgNFM4Q0AAAAk7o0/NMbvn96ZHdedVBZX3erZv5BWC2+vi8nTS7LjX/50a6xb1ZxgIgAARiuFNwAAAJCoXds64vEfbs6OJ9eWxMc8sxtSLb8wL6799HFRMbEwO7fkexujZXdngqkAABiNFN4AAABAYjrbe+KR+9Zlx2Vj8+MTnz4u8gvzEkwFDIXi0jFx3d3HRVHJ/o8gO9r2xeLvbEg4FQAAo43CGwAAAEjMku+vj6ZdvSs+P3bnjCjJ+LgCRouxlYVx9W212XH9prb45X9sSTARAACjjb9BAgAAAIn4w7M7Y+3rLdnxJdfWxKTakkNcAaTRjJPKY+6CCdnx8ucbYtWrTQkmAgBgNFF4AwAAAMNu986OePbRbdnxzDnlccaFVQkmAnLpoo9OjtqZmex46YObYm9zV4KJAAAYLRTeAAAAwLB78qHN2eNMeX589KbpCaYBhsOf3FobhcV5ERHR2d4Tv1my7TBXAADA4Sm8AQAAgGG1ZuWe2LC6NTu+5Lqp2RIMGL0y4wpi/lWTs+M//n53bF3XeogrAADg8BTeAAAAwLD65cNbssczTiqLE+eMTTANMJzOnF8Vk2tLsuOnDvh5AAAAR0PhDQAAAAyb5b/dFc27e5/be/kNUxNMAyTh8hunZY+3b26PVa82JZgGAIC0U3gDAAAAw2bZk9uzx+d+ZEKUVxQmmAZIwsQpxTH73HHZ8bIn6hNMAwBA2im8AQAAgGGx8qXGaN3THRER+YV5cd5HJiacCEjK3AWTssc7t3XEulXNCaYBACDNFN4AAADAsFi2tHd19xkXVkZJWX6CaYAkVVYXxQfO6l3l/eJTOxJMAwBAmim8AQAAgJzbsLoldu/szI7Pv7Q6wTTASHDBFb2rvDeuaY2dW9sTTAMAQFopvAEAAICcW/lSY/b4zPlWdwP7V3mfePrY7Pj1lxsPcTYAAAxM4Q0AAADkVHdnT6xa3pQdn/XBCQmmAUaSM+dXZY9XvrQ7wSQAAKSVwhsAAADIqbdW7I6ujp6IiKieUhQVE4sSTgSMFLUzyyJTvn/Hh5amrtiwuiXhRAAApI3CGwAAAMiplb/vXbV50lnjE0zCkWpra4s1a9YkHWPY7du3L954443o7u5OOsox4QNn9/5cOPDxBwAAMBgFSQcAAAAARq/uzp5Y92bvis3Z51QkmIbBWrlyZSxZsiSWLFkSxcXF8eSTTyYdaVhs3bo1HnvssXj44Yejvr4+Fi9eHLW1tUnHGvVOPnNc/Nevd0VExNsr9iScBgCAtFF4AwAAADmz8Z3esnvC5KIoryhMMA2H09bWFp/85CfjnXfeyc4VFxcnmGj4fOUrX4lHHnkk6RjHpJoZmSgpHRNte/dF2959sWNLe0yccmz8uQMA4P2zpTkAAACQMxvX9BbetbPKEkzCYHR3d/cpu48lb775ZtIRjmm1szLZ401ve443AACDp/AGAAAAcmbj6tbsce3MzCHOBI5l02eVZ483rFF4AwAweApvAAAAICe6O3ti89q92XHdiWMTTAOMZLUze3eA2LBK4Q0AwOApvAEAAICc2LGlLXtcNakwSjI+hgAGNnFKcZSU7v8Z0bZ3X7Ts7ko4EQAAaVGQdAAAAABgdGrY2Z49rp5WmmCS0a+1tTWWLl0aa9asiY0bN8a6desiPz8/6urqYsaMGXHiiSfGRRddFOPGjRvw+qeeeiqam5ujtbW132sNDQ2xePHiAa+rq6uLs88++5DZdu7cGW+++Wa8/fbbsXr16li9enXs2bMnioqKYsqUKXH66afH7NmzY/bs2VFRUTHo3/Pq1atjxYoVfebmzp0bU6dOjYiIpqam+PnPfx7Lly+PjRs3xq5du6Kqqipqampi5syZcffdd8err76afWb52rVr+91jyZIlUVNT02++tLQ0rrjiikFnZXCqp5XEhv//GITGne1RNt5HlwAAHF5eT09PT9IhAAAAgNFn2ZP18bsndkRExPmXTYwLr5yUcKLRp729PX7yk5/Et771rQHL6vf60Ic+FJdffnlceumlUVDQWyZefPHFg7r+vebPnx9f//rXB3ztrbfeih/+8IexZMmSQb/fnXfeGYsWLYqSkpLDnvvNb34zvv3tb/eZ+9KXvhQf+9jH4sc//nH84z/+40GvnTVrVjz44IPxV3/1V/HUU08NOt+BXnrppaO6joN76ieb47VljRERcdn1U+K08ysTTgQAQBr4miQAAACQE7t3dGSPKyYWJZhkdOrq6oovfvGL8cwzzwz6mmeffTaeffbZmD9/fp/Ce6j9wz/8Qzz00ENHfN19990Xjz/+eHz961+P448/Pmf3vvXWW4/qvcmt8RMKs8eNB/z8AACAQ/HwLAAAACAnGnd0Zo8rJii8h9q///u/H1HZ/a5zzz03ysrKcpCoV2Nj41Ffu2nTpvjKV74SR7Mp4cMPP3zYsjuTycSCBQuONh45NH5icfa4YXv7Ic4EAIBeVngDAAAAOdHc1JU9Hl+l8B5KXV1dBy12M5lMXHzxxXHcccfF+vXrY/ny5bFp06bs65dcckm/a2699dZobGyMtra2ePTRR/u9fv311w94r1NOOWXA+TvuuCOWLl064Gsnn3xy1NTURENDQ7z11lsDbqX+yiuvxNNPP33ExfQbb7zR715z586NTCYTzz33XKxYsSJuuumm7JbpH/7wh6OqqioiYsB/nwsWLMi+fqBMJnNEuRicigN+TrTu6U4wCQAAaaLwBgAAAHKis31f9rhsvI8ghtLrr78eDQ0N/eYXLVoUd999d5/tyvft2xdPPPFEfO1rX4uGhoa48MIL+1131113RURES0tLv8K7srIyvvCFLxxRvlmzZsXll1+eLb2vvfbauO2226KmpibGjOndcLCrqyu+973vxTe+8Y1+7/HVr341Lr744igqOrovS/z1X/91XHPNNdnxnXfeGS+//HKccMIJ2bkrr7wyrrzyyoiIWLFiRaxcubLPe3zuc5+L2trao7o/R65sbH72uLNd4Q0AwOD42yYAAACQE52d+w5/Ekdl165dA86/t+yOiBgzZkxcddVVcfHFF8evfvWrYStw77zzzti5c2d85jOfiTPOOGPAcwoKCuJTn/pUTJo0Kf72b/+2z2v19fWxfv36mDVr1hHf+9/+7d9i7ty5/ebPOeecI34vhk9BYW/h3d7u5wcAAIPjGd4AAABATnR17H8Gc1GJjx+G2rtbcr/Xhg0bDnpNeXl5nxXPuXbCCSfEN7/5zYOW3Qf66Ec/Gscff3y/+a1btx7xfRcuXDhg2c3IV1CYlz3ubD/yZ7gDAHBs8jdOAAAAYMgduJ35gSUWQ2Ogcjgi4qc//Wn09KSvKCwoKIjLL7+83/zmzZuP+L0+/elPD0UkEpB/YOHdYYU3AACDY0tzAAAAYMh1HbCd+ZgxCu+hVl1dHXV1dbF+/fo+8w888EBs2bIl7rnnnhg3blxC6Q6tqakpNm/enP0nk8nEiSeeOGDeTZs2HdF7n3POOTFp0qShikoC8gvyorurJ7o60/fFDQAAkqHwBgAAAIZcQVHvs3i7PMt7yOXl5cUXvvCF+NznPtfvtWeeeSaWL18et956a3z84x8fEcX3li1b4jvf+U4sXbo0WltbB33dtm3bjug+M2fOPNJojDDdXfuL7nw7QwAAMEi2NAcAAACGXGHRAVsTW6mZE/PmzYubb755wNcaGhriX/7lX+KSSy6Jf/7nf46GhoZhTrffjh074t57741rrrkmFi9efERld0TEvn1H9mWJurq6IzqfkeXA53YXFvrYEgCAwfF/jgAAAEBOvPvs7m6Fd878xV/8xYCrvA/0/e9/PxYuXBg//OEPo6OjY5iSRSxbtiyuvPLKeOCBB4btniUlJcN2L4ZeZ3t39rio2ApvAAAGx5bmAAAAQE4UFo2Jrs79BVZne08UKrByYtGiRXHWWWfFvffeGytXrhzwnNbW1vja174Wv/71r+Pee++N8vLynGZ68cUXD1nEz5s3L2bNmhW1tbVRWloaGzdujBdffDGWL1+e01yMbB0dvSv6i4qt0wEAYHAU3gAAAEBOFBblxd6W/cedHd1RWOxjiFw544wz4nvf+148//zzcf/99x+0OH755ZfjM5/5TNx3331RVFSUkyxNTU3xxS9+ccDXPvjBD8ZnP/vZmDVrVr/Xzj///Ljzzjtzkol06GzvLbwLi/MTTAIAQJr4qiQAAACQE2XjCrPHzbu7EkxybMjLy4uLLroovvOd78Q3vvGNmD179oDnrVy5Mh599NGc5XjooYcGfGb43XffHV/72tcGLLshIqJ5T+/PicxYhTcAAIOj8AYAAAByomJib+HdsKM9wSTHnvPOOy+++93vHnTF9De/+c2c3fs///M/+81dddVV8alPfSpn98yVri5f1BhODfW9Pycqq4sTTAIAQJoovAEAAICcqKju3TJ7V73Ce7iNGTMm7r777rj55pv7vdbQ0BCNjY2Dep+GhoZBF7979+6NTZs29Zu//fbbIy8vfc9wH+y/I4ZGQ31H9rhiYm623AcAYPRReAMAAAA5UTmxd4XmgUUWw2vRokUDzm/ZsqXf3MFK6cEWvzt37uw3l8lkYsaMGYO6fqQZ6PdD7jRsP3CFt8IbAIDBUXgDAAAAOXHgCs36jXsTTDJ6rV279rDnlJSUDDjf0dH/SwiZTCYymUy/+ddee21QecrLywecP9zq7p6ennj22Wf7zbe2tg7qvkOhtra239wrr7wybPcnYuv63p8TFRMU3gAADI7CGwAAAMiJiTW9RWvD9s5oa+lOMM3os3Llyrjuuuvi85//fKxZs+ag5z333HMDzldVVQ04P3v27H5zP/jBD6Knp+ewmSoqKqKysrLPXGtra7z88ssHvaa9vT3uueee+P73v9/vtTfffPOw9xwqM2fO7Df3wAMP2NZ8mOzc2h6dHfv/jBWXjonyisKEEwEAkBYKbwAAACAn8gvzYupxpdnxxrXDt1r3WPD4449HRMRvfvObuOGGG+LLX/5yvPzyy9lV0V1dXfHEE0/El7/85X7XTps2LaZPnz7g+5500kn95pYvXx6f//zn+2yD3tbWFk899VR89atf7XPu6aef3u/6e+65J5YvX95nrrOzM1577bX47Gc/m/29vFdDQ0M0NDQM+NpQG6jwjoi444474rXXXovu7v1f2Oju7o6XX345/umf/im2b98+LNmOBZvebskeTz+xLMEkAACkTUHSAQAAAIDRa9rMTGxeu3+b4k1rWmLWqWMTTjQ6dHR0xM9+9rM+c4sXL47FixcP6vqrr776oK/dcMMN8aMf/ajf/HPPPXfQ1eJ33XVXdjvzW2+9td/25PX19fGpT30qTj755DjuuOOisbExli1bNqis999/f/zlX/7loM59P+bPnx/HH398vPPOO33m169fH7fffvuA11xwwQVRXV2d82zHgk3v9H4hZvpMhTcAAINnhTcAAACQM9Nn9RZXm9+2wnuoPP/880f9fOvTTjstPvnJTx709WnTpsXnPve5I3rPdevWZY/POuusuOWWWwY874033ognnnhi0GV3xP5txR9++OEjynM0CgoK4ktf+tIRXfPecpyjt35V7wrvaScovAEAGDyFNwAAAJAzU2dkssdbN7RF656uBNOMHhMmTOj3rOzBOPPMM+OrX/1qlJSUHPK8W2655ZCrwN9r7dq1fcZ//ud/HgsWLBj09ZlMJr7+9a/HI488MuDrK1asGPR7vR9nnHFGfOELXxj0+W+//XYO0xw7dmxpj9bm/VvGFxblRfXU4oQTAQCQJgpvAAAAIGcKi8dE3Ym9pfebr+xOMM3oMWfOnHj88cfj3nvvjXnz5h32/NNOOy3+9V//Ne67776oqqo67PmFhYXxN3/zN/HlL385MpnMIc+dNGlS7Nu3r89cSUlJ/P3f/3383d/93SGvnzZtWtx1113x2GOPxfz582P69Onxox/9KGbPnn3YjMXF/UvRwxX5g3H99dfHD37wg6irqzvkeZWVlVFUVPS+70fE6y83Zo9nzfHYAwAAjkxeT09PT9IhAAAAgNFr5UuN8YsHNkdExOTakrj58ycknGj0aW9vj/r6+tiyZUts27YtioqKoqysLCZPnhw1NTUxduzRl4jd3d2xYcOGWLVqVfT09ERRUVFMmjQpJk2aFFVVVZGfn3/I6/ft2xebNm2KVatWRVdXV3R3d0dFRUVMnz49pk+fftDrtm7dGm+99VY0NTXFzJkz4+STTz7q38PRqq+vj1WrVkVLy/7ttidPnhzV1dVRXV2t7B5C3/rbVdHStH/3h098ui5mnFSecCIAANJE4Q0AAADkVGd7T3zjnjeiu2v/RxC3/69ZUTFRWQhEbHq7JR761/3PgC/J5Mef/+8PJJwIAIC0KUg6AAAAADC6FRbnxaw55fHmf+2JiIhXfrsrPrywZthzLF26NJYtW5az929ra4vNmzfHCSfkdgX7ggUL4sILL8zpPRi8xYsXx6uvvprTe7z++utx8sknR15eXs7ucdJJJ8WNN96Ys/c/mFd+uyt7PPu88cN+fwAA0k/hDQAAAOTcKedUZgvvV3/XEBdcNimKM2OGNcOyZcvi0Ucfzdn79/T0RF5eXqxYsSJn94iIqKmpUXiPIM8991w888wzOb/PW2+9ldP3P/vss4e98G7a1RmrXtmTHZ9ydsWw3h8AgNFheP9mCQAAAByTjj+lPMZPKIyIiO7OnvjDczsSTgQk7aVf9f4cqKkrjUm1JQmmAQAgrazwBgAAAIbF+ZdNjKUPbomIiP/69a447yPVUVCYuy2a32vKlClRWVmZs/fv7u6Ojo6OKC0tzdk9IiKqqqpy+v4cmZqampz+uYqIaG5ujvLy8pzeY+rUqTl9//fa29wVy59vyI7nXVE9rPcHAGD0yOvp6elJOgQAAABwbLjvf6+KPY1dERHxkY/XxJnzlbdwLHr+ifp44cn9K7yrpxbHrX85M+FEAACklS3NAQAAgGFz/mW9qzh/94v6aN+7L8E0QBJam7riD8/uzI4vuHJSgmkAAEg7hTcAAAAwbObMq4zK6v3P8m5r3Re/fWxbwomA4fb0I1uis2P/ppNTZpTGzFPHJpwIAIA0U3gDAAAAw+ryG6Zlj5c/3xDbNuxNMA0wnNa+2RyrX92THV9+47RDnA0AAIen8AYAAACG1dTjM/GBs8Zlx0sf3JRgGmC4dHX2xNIHN2fHZ3+oKqomFSWYCACA0UDhDQAAAAy7D/1pTRQW50VExI6tHfH8E/UJJwJy7ZnFW6KlqSsiIjLl+XHhFZ7dDQDA+6fwBgAAAIZd2biCuOQTU7LjF57cERtWtySYCMilVa82xWvLGrPjqz5ZG4XFPpoEAOD983+VAAAAQCJmn1sRJ505Njte8t0N0bK7M8FEQC7s2tYev/hR76MLzv3IhJg+qyzBRAAAjCYKbwAAACAxV9xQG+MnFEZERNveffGz+zcknAgYSl0dPbH4O+ujq7MnIiIm15bEB6+enHAqAABGE4U3AAAAkJiCorxYeEdd5Bfsf573to1t8fgPNyacChgqj353fezeuX/nhsLivFh4x/SEEwEAMNoovAEAAIBETagpjo98vCY7fuMPTfHbx7clmAgYCo//cGOse7MlO77yltooG1+YYCIAAEYjhTcAAACQuDnzKuP0Cyqz4xef2hkrXmhIMBHwfjz/RH288Yem7PjCj1bHrFPHJpgIAIDRSuENAAAAjAiXXjclTj57XHb85ENb4o3/akwwEXA0XnluV7zw5I7s+KyLq+L8BdUJJgIAYDTL6+np6Uk6BAAAAMC7Ft+3Lt55vXcb5I98vCbOnF+VYCJgsJ5/or5P2T37vPFxxY3TEkwEAMBop/AGAAAARpyHv7E2NqxuzY7nLpgQF310coKJgMN58qHNseKF3l0ZZs0pj2sW1SWYCACAY4HCGwAAABiRHv3u+ljzWnN2PPvccXHFTbUJJgIO5pFvr4u1b/TuzHDq3Iq4/IapCSYCAOBYofAGAAAARqynHtocrx2wYnTaCZm45rbaKC0vSDAV8K7mxs5YfN+62L6lIzs37/KJccEVkxJMBQDAsUThDQAAAIxoy56sj9890ftM4Ex5fvzJf6+N2pllCaYC3n69OR7/wcboaNuXnbvshilx2tzKBFMBAHCsUXgDAAAAI96qV5ti6YOborO992OMeVdMjAsut4oUkvCrR7bEK881ZMclmf1fRKk70RdRAAAYXgpvAAAAIBV27+yMR+9fFzu29m6dPGlaSVx2/dSYVFuSYDI4dmx6uyWW/nhzNO7ozM5NmVEaf7poemTGedQAAADDT+ENAAAApMpTP9kcry1r7DM3Z15FfPDqmiguHZNQKhjdWpu64leLt8Sq5Xv6zJ93yYSY/yeTE0oFAAAKbwAAACCF1r7ZHE/+eHM07+7KzhWVjImzPlgV53xoouIbhkjrnq548Zc74rXfNURXZ+/HiBUTC+OKG6fF1OMzCaYDAACFNwAAAJBS3Z098fTKAD0AACAASURBVLul9fH7X+7sM19YlBdnXFQV511SHSUZxTccjZamrnjhye2x4sXG6O7q/fgwvzAvzl8wMc5fUJ1gOgAA6KXwBgAAAFJtV31HPPGjjbFtQ1uf+fyCvJg1Z2zMmVcZ02eVJZQO0uWd15vjtWW7Ys2K5n6vTZ+ViStvmhblFYUJJAMAgIEpvAEAAIBR4e3Xm+P3T2+Pze/s7ffauKrCmDOvIuacXxml5QUJpIORq7mxM15d1hArXmiMlqaufq/POKkszrt0oi+OAAAwIim8AQAAgFFl24a9sWzp9nh7Zf8VqhEREyYXRc2MTEyZURo1dZmonlo8zAkhWds27I2t6/fGlnWtsWXd3mjc0TngeSedOTbmXTYpJtT4bwQAgJFL4Q0AAACMSrt3dsYff98QK19qjD0N/VetHqh6anGMn1gUVZOKompScYyvKorCojFRWDwmikvGRGFxfhQU5g1Tcjg6nR090dneHR3t+6KjbV90dnRH486OaKjviF317bFrW3s0bB+43H5XZXVhzD6vIk49tzLKxtsNAQCAkU/hDQAAAIx6m95uiVd/1xAbVrcOuGUzHMvGVRZE3YnlMWdeRdTMyCQdBwAAjojCGwAAADimtLV0x5b1e2Prhtao39AWO7a2R9OuQ696hdGiYmJhTJhSHJNrS6OmrjSm1GWiqGRM0rEAAOCoKbwBAAAAImJXfUc07GiP3ds7oqmhM1qaOqNlT3e0NHVGa3N3dLTtSzoiHFJx6ZgoG1sQZeMKIvP/fx1XWRgV1cVRObEoKiYWJR0RAACGnMIbAAAAgGHT2dkZF1xwQURElJWVxbPPPptwIgAAIM3sVwQAAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEglhTcAAAAAAAAAqaTwBgAAAAAAACCVFN4AAAAAAAAApJLCGwAAAAAAAIBUUngDAAAAAAAAkEoKbwAAAAAAAABSSeENAAAAAAAAQCopvAEAAAAAAABIJYU3AAAAAAAAAKmk8AYAAAAAAAAglRTeAAAAAAAAAKSSwhsAAAAAAACAVFJ4AwAAAAAAAJBKCm8AAAAAAAAAUknhDQAAAAAAAEAqKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAAAAFJJ4Q0AAAAAAABAKim8AQAAAAAAAEilvJ6enp6kQwAAAACQfueee27O3vull17K2XsDAADpVZB0AAAAAABGj3fXVuTl5UVPT0/214Ec6rV3XwcAADgUhTcAAAAAQ+bAkvrd40MV10ptAADg/fAMbwAAAACG1FA9Qe/d9ykvLx+S9wMAAEYfhTcAAAAAQ2LhwoURMTSrtt/dDj0i4vrrr3/f7wcAAIxOeT1D9ZVbAAAAAI5pW7dujauvvjoi+hbW70dJSUn8/Oc/j/Hjx7/v9wIAAEYfK7wBAAAAGBI1NTVxzTXXRMTQPZt70aJFym4AAOCgFN4AAAAADJnbb789e/x+NxYsLS2Nm2+++f1GAgAARjGFNwAAAABDpq6uLq688sqI2L/K+/2U3rfccktkMpmhigYAAIxCCm8AAAAAhtTdd9+dPT7arc2Li4vjxhtvHKpIAADAKKXwBgAAAGBI1dbWxsKFC4/4ugNXg1933XVRUVExlLEAAIBRSOENAAAAwJC77bbbjviaA1eD33TTTUMZBwAAGKUU3gAAAAAMubq6urjiiiuO6tqbbropampqhjgRAAAwGuX1HLhXFAAAAAAMkY0bN8bHPvaxQZ3b09OTXeH95JNPRmVlZS6jAQAAo4QV3gAAAADkRG1tbZ/C+1DrLt4tu2+55RZlNwAAMGgKbwAAAABy5sBneR/4jO6DufXWW3MZBwAAGGUU3gAAAADkzPTp0+Pyyy8f1Lk33nhjVFdX5zgRAAAwmniGNwAAAAA5tX79+vjEJz5xyHNKS0tjyZIlMX78+GFKBQAAjAZWeAMAAACQU3V1dbFw4cLseKD1F9dee62yGwAAOGIKbwAAAABy7vbbb88eD/Qs71tuuWU44wAAAKOEwhsAAACAnKutrY0rrrhiwNduuOEGz+4GAACOisIbAAAAgGHxZ3/2Z/3mMplM3HXXXQmkAQAARoO8noEemgQAAABwBDauaYmWPV3R1tIde1u7omdf0okYqX7961/HG2+8mR2feeYZMXfu3AQTMZLljYkoLSuI0rL8KB9XGFOPzyQdCQCAEUbhDQAAAByVtW82x+svNcaaP+6JznYfLwC5V1w6JmbNGRennjc+pp1QlnQcAABGAIU3AAAAcEQ2v9MazyzeGts2tiUdBTiGTTshEx/5WE1UTytJOgoAAAlSeAMAAACD0tneE7/48cZ4a/mefq+VlhfEhJriyJQXRGl5QYwZk5dAQmC06e7uib3NXbG3uSu2b94b7Xv7Py/h9Asr49JrpySQDgCAkUDhDQAAABxW446O+Nl31seu+o7sXH5BXpw2rypOmD0uJtRYYQnkXv2m1lizoin++EJDn/nJ00ti4R11UTauIKFkAAAkReENAAAAHNKOLe3x4L+8E53tvSsrTzxjfJx36aTIlCuXgOG3p7Ezlv1ia6x7szk7V1qWHzf/zxNiXFVhgskAABhuCm8AAADgoNpauuP//tOaaGnqys5det20OH72uARTAez32rKd8cLS+ux4wuSiuOl/zIzCYo9VAAA4VoxJOgAAAAAwcj3y7XV9yu6rb5+h7AZGjDnzJsSCG2uz453bOuLn31+fYCIAAIabwhsAAAAY0AtPbY+tG9qy4wX/bVrUTM8kmAigv+NOGhsXXTU5O37n9ZZY+VJjgokAABhOCm8AAACgn462ffHSr3Zmx2d/eGIcd4qV3cDIdMq5VfGBs8Znx799rP4QZwMAMJoovAEAAIB+XnpmR3S07YuIiHFVhXH2xdUJJwI4tA9eMzVKMvkREdG8uyuWP78r4UQAAAwHhTcAAADQz6vPN2SPz1J2Aykx54Kq7PGKZbY1BwA4Fii8AQAAgD4atnfE3pbu7PjE08cf4myAkeOkMyuyx/Wb2qKtdV+CaQAAGA4KbwAAAKCPDW81Z49rZ5YlmATgyJSWFUTV5OLseOPbLQmmAQBgOCi8AQAAgD52bmvPHk+cWppgEoAjVz21JHu8a1tbgkkAABgOCm8AAACgj7bW3u3Mx44vSDAJwJErryjMHrfvtaU5AMBop/AGAAAA+mjf21t4Z8YXHuJMgJGnfHxR9rj9gC/wAAAwOim8AQAAgD56enqP8/PzkgsCcBQKCnp/bnV1WeENADDaKbwBAAAAAAAASCWFNwAAAAAAAACppPAGAAAAAAAAIJUU3gAAAAAAAACkksIbAAAAAAAAgFRSeAMAAAAAAACQSgpvAAAAAAD+H3t3HldlnfZx/IsaICIiiwLnsAui4JK5kOtBndIyzaWypj2nmmZstXLmmbKZmifHmsnKVq3MrGcqa9LUzExwoay0EBExARd2EURBwP35w8fziPeNgnIOi5/368UruO7r/t3XzblLO9f5/X4AAADNEg1vAAAAAAAAAAAAAECzRMMbAAAAAAAAAAAAANAs0fAGAAAAAAAAAAAAADRLNLwBAAAAAAAAAAAAAM0SDW8AAAAAAAAAAAAAQLNEwxsAAAAAAAAAAAAA0CzR8AYAAAAAAAAAAAAANEs0vAEAAAAAAAAAAAAAzRINbwAAAAAAAAAAAABAs0TDGwAAAAAAAAAAAADQLNHwBgAAAAAAAAAAAAA0SzS8AQAAAAAAAAAAAADNEg1vAAAAAAAAAAAAAECzRMMbAAAAAAAAAAAAANAs0fAGAAAAAAAAAAAAADRLNLwBAAAAAAAAAAAAAM0SDW8AAAAAAAAAAAAAQLNEwxsAAAAAAAAAAAAA0CzR8AYAAAAAAAAAAAAANEs0vAEAAAAAAAAAAAAAzRINbwAAAAAAAAAAAABAs0TDGwAAAAAAAAAAAADQLNHwBgAAAAAAAAAAAAA0SzS8AQAAAAAAAAAAAADNEg1vAAAAAAAAAAAAAECzRMMbAAAAAAAAAAAAANAs0fAGAAAAAAAAAAAAADRLNLwBAAAAAAAAAAAAAM0SDW8AAAAAAAAAAAAAQLNEwxsAAAAAAAAAAAAA0CzR8AYAAAAAAAAAAAAANEttGrsAAAAAAAAAoCnIy8/V8uWLlZn1qzp08Nbtt02R1RLc2GUBAAAAOAca3gAAAAAAALjkVVdX6977fqvKykp77Kefvtf8dz9Rhw7ejVgZAAAAgHNhSXMAAAAAAABc8tatW12j2S1JZWX7tennHxupIgAAAAB1QcMbAAAAAAAAl7yCwgLTeMeOPk6uBAAAAEB90PAGAAAAAADAJS82todpvIMXy5kDAAAATRkNbwAAAAAAAFzyrujTX3fecV+N2CMPT1dERJdGqggAAABAXbRp7AIAAAAAAACApuCO26fohkm3aN++verUKUDu7u6NXRIAAACA86DhDQAAAAAAAPwfDw8PhYSENXYZAAAAAOqIJc0BAAAAAAAAAAAAAM0SM7wBAAAAAECLVVlZqcSkldq5M1v5BbnKydmt1q1by2oNUbA1VBERXTRgwCB5tfeqdYzvvlur/WWl9p9bt26tkSNGq02b87+tcuzYMX377QodO37MHvPu0FGDBg0z5KZvS9POnZk1YgOvHKqOHX20c2eWUrf8oszMX/Xrr9tUUVGuDt4d5evjp5iYWPXp009do7upVasLn9tQXV2tlJSN+vGn75WTs1vF+/bq+PHjCg0NV2hIuIKDQxQSHKaIiKg6L/W9cdMPKioqsP/s4uKi4QlX28/PzcvRihVfKntnpvLzc3X0yBF18O4oiyVYYaERat26dY3xWrdurUkTb5aLi0ud7yt9W5pSU3+pEQsLi1D8gEFKT9+inbuyaj03JDhMPXr0Puf4DfGMmamqqtIvv/ykH3/6Xvn5udpbXKSjR47Iy6uDOvr4qktktPpeMUDdu/eo07MoXdzr0bdPf1199Zh63QMAAADgDDS8AQAAAABAi3P48GEtXrJI7y94W5WVlYbju3fvrPHzoEHDlGD7jYYNHWFoHr72+r+UX5BXI3Zl/BB16OB93joqqyo1c9Zfa8T8/TuZNryXLftCy79aXCP2zIz22rFjuz786D1D/uma1icnSe9IERFddP99D6lf3/jz1nWmo0ePavlXi/X23FdNf1e5uXuUnLymRv2PPvJnxQ8YdN6x318wV2lpm2vE4mJ7qVOnAL0650XD/Z6+r23b0jR0yHCtXbfacDyma/fzNqHPNG/ea/olZWON2KSJtyh+wCB9sWSRvvlmea3nDh5kq/VaDfmMneno0aNasmSR3p3/pum4p1/3779fpw8WviN//0564PePaOiQ4ef9wMPFvB6+Pn7nHBsAAABoLDS8AQAAAABAi3Ls2DE99/e/nGoE11Fy8holJ69R/IDBdZ4t6wzP/HV6nXOzszP1xJNTNWniLbr/vgcNs6PNlJTs01MzHte2bWl1vk5x8V796c8PyzZspP7wwKPy8/Ov87mSVHGoQi88+UdD4/Vsd9/9e2Vmbjd82ODrlcvq3PDOy881NLsl6box4+tesAlHPWP795dq+p8e0q87Muo8bnHxXv31b3+SbdhITX/yGbm5udX5XKnur8eYi/ydAQAAAI7CHt4AAAAAAKBF+fCj+fVqRJ52ee++ateunQMqcq5Fn32kV1594bx5+QV5mnLvLfVqdp8pac0q3XHXJJWWltTrvJdf/sd5m6tXXjlEoSFhmjD+JsOxZcu/MJ35bOabb74yxPr3H6iQkLC6FVsLRzxjpaUlevDh39Wr2X2mpDWr9NTT03TixIl6nVfX18NqCb6gugAAAABHazofWQYAAAAAALhIx44d0xeLPzE95uHhoYFXDlVwcJhy8/Zoa9rmGrOHhwxJcFaZFyQ+frB6xPVWRUW59uTs0s7sTMPs59OWfPmZrrlmnLpGdzM9XllZqT//1yMqK9tverzvFQMUGRktD492Ki3dp6zsHaZN0crKSr0650XNePr5Ot/H2Q3dfn3jFRvbS0ePHtHKb5apuHivxl9/oyRp5G+u0ZzX/2UYIzk5Sb/5zTXnvM6xY8e0eMmnhviZTXSrJUShoeGSpAMHymr9fZw9riOesXfefUO5uXtMj1155RDFxfaSv5+/du3eqW3b0kxnrv+0cYMSk77RiOFXn/c+TqvP6wEAAAA0RTS8AQAAAABAi/Hrr9tMm5a33Hyn7rrzvhpLSZ84cULffrtCr785W2Vl+9W//0BnllpnwxOu0oNTHzfdM3zDD8n610v/reLivYZjb731iv71zzdMx3xlzguGPaalUzOQH330z6azebdsSdHMfzxjaLInrVml4euv0pDB9fvAgLd3Rz3/37MV07W7PXb7bVO0ceMGXdGnvySpg1cHjb1uopZ8+VmNc5d/teS8De9fUjYanoWgQEuNPc5vv+0e3X7bPZKktLTNmvrQlPPW7Yhn7NcdGab7Z3t7d9Q/Zr6i6KgYw7GkNav017/9yRB/6+1XNGRwglxdXc97L2df63yvBwAAANAUsaQ5AAAAAABoMfbvLzWNn92IlKRWrVrpN7+5Rh+8/7mefOJpWYKsziixXu64/V499Ze/mza7JSl+wCC9984nsg0baTj2S8pG/fDjd4Z4VtYOff31UkP85sl36J8vvl7r0tU9evTWvLn/o7i4XoZj/3rpeR0/fvx8t2Pn7d1Rb76+oEZzVZJcXV01cOBQtWr1/29ZXXvt9YbzUzZvUl5+7jmvsXy5sYF8ww2/rTH2hWjoZ+zkyZOa89o/DfGgQIvefH2BabNbkmzDRur11+Yb4sXFe/Xl0s/rcit29Xk9AAAAgKaGv60CAAAAAIAWw83d3TSel5dT6zmenp4adfV1jirposR0NV+S/Ezt2rXTH//wmOmx9xfMNcQWfviuIRYX10t333W/XFxcznmttm3b6tGHjbOKy8r2q7Co4Ly1nvbA/Q+rc+eAOuVGR8WYNtm//fbrWs8pK9uvpDWrDPGRI0bXucbaNPQz9t13a7VlS4ohfs89D5z3d9QtJlZXXzXGEH/3vTd0+PDhc557pvq8HgAAAEBTQ8MbAAAAAAC0GKEh4abxL5f+RydPnnRyNc7j6+unW26+0xDfti2txn1XV1ebNoIfe+TPhtnJtQkPj9ToUWMN8Zw9u+p0fkREFw2vxx7Tkkz3kF667HOdOHHCNH914kpDbNLEW+Tp6Vmv65pp6GfsZ5O9uP39O2nokOF1On/cuEmGWGVlpYrq+AGEC3k9AAAAgKaEhjcAAAAAAGgx/Pz8ZbWGGOKfff4/enrGEzpYfrARqnIOs6awJJWWlti/T9u62XDc37+TwsIi6nWtqKiuhtgukz3BzQwbOlKtW7eu1/UGD7LJw8OjRqy4eK82p/5smn/2nt+SNG7sxHpdszYN/YyZfVDgphturfMHELrFxCo01NiEP3uv9dpcyOsBAAAANCV1+5szAAAAAABAM+Di4qIHpz6uJ56caji2PjlJaVs368YbbtW1114vr/ZejVCh4/j6+pnG9+4ttB/bunWL4Xhx8V49+tjv63Wt7b+mG2K7dmXX6dyQkNB6XUs6tZf0DZNu1fsL3q4R//rrZbq8d98asW0ZW7X7rOZ7fPxg0yb1hWjoZ2xH5nZDLCIyql41BVtDDfdcWJhfp3Mv5PUAAAAAmhJmeAMAAAAAgBalX994TZp4i+mxsrL9envuqxp3/Qi9+dYrKivb7+TqHMfFxcW0qVtwRuNz//4Sw3FJ+iVlY72+KisrDWMcP36sTnUGBVnreEc1XTPauIz61yuXqqKiombs66WGvAnjb7qga9amoZ6xqqoq0+P+fp3qVY+/vzE/Ly+3Tude6OsBAAAANBU0vAEAAAAAQIvzhwce0e+m/PGcOR9/8oF+e9v1+nTRRzpy5IiTKnMss4Z3YeH/7+W8f3+pw64dGGipU567m/sFjd+pU2fZho00xNcnJ9q/r6qq0uIli2oct1pDdEWf/hd0zXNpiGesoJZlx/3q2fD29fU3xPLyc+p07oW+HgAAAEBTQcMbAAAAAAC0SLfcfIdefXmeYrp2rzWnsrJSr7/xkp6c/qBhpnBz5HqZqyFWUVFu/77cgXuYh4SEOWzs08aNnWSILVu+2P79+uQkw/FJE29Wq1aOeQvsYp+x2vbpdnNzq1cdl112mSFWZTILHwAAAGiJ2MMbAAAAAAC0WHFxvfT6a/P1w4/f6cOP3lNa2mbTvJTNm/T4E3/Qy7PnytXV2DRuLsz2be7UqbP9+3btPA3HJ028RX944BGH1tVQevXqI6s1RLm5e+yxtLTNys3dI6s1RMvPaH5LkoeHh0aOGO3Qmi7mGXN3b2uae/DgAXXo4F3nGkpLjUvV13XGPQAAANDcMcMbAAAAAAC0aC4uLoofMEivvjxP/3zx9Vpn42ZsT9dXK5Y4ubqGlZu3xxCzWILt33t7dzQc370726E1NSQXFxfdMMm4d/aqb1coNy9HKZs31Yhfe814tWvXzil1Xcgz5uvrZ5pX36Xni4oKDLEzX3cAAACgJaPhDQAAAAAALhl9Lu+n1+a8p9tvm2J6fP77b9dpnGPHjjVkWQ2ivKJclSbLWJ8509eswbojc7tD62powxOuNsQWL1mkr74yflhh7NiJziiphvo8Y61bt1ZoaLghp3S/ccb2uZjN7LdYrPUaAwAAAGiuaHgDAAAAAIBLSqtWrXTXnfdp0kTjTOGysv06cKCsZn7r1oa8fSXFDqvvQiWb7F8tSZ07Bdi/79YtznC8rGy/9uzZ5bC6Gpqnp6cmTri5RqysbL8++p/5NWJXXjlE1kaa5VyfZyzYGmrISU1NqfO18gvylLE93RAPCAiq8xgAAABAc0bDGwAAAAAAXJJuufkO03jhWctDBwcbG5LFxUV1ukZq6s/1L+wCVFdX6623XzXErdYQXXbZZfafe8T1Nj3/pdkzdfLkSYfV19CuGzP+vDkTxt/khErOrS7PmNnz9emihTpy5EidrrF48SLTeCANbwAAAFwiaHgDAAAAAIAWpy4zlt3c3E3jR89qNJrNwE1M/Oa84x8sP6g33ph93ryGsOTLz1RWtt8QP3u/aw8PD40cMcqQl7J5k75eubRe12zMBnloaLj6XjGg1uNWa4j6XN7PoTU01DM26uoxhuOVlZVau271ecc/WH5Qn3y60BC3DRupDh28z3s+AAAA0BLQ8AYAAAAAAC1KxvZ03XHXDfrzXx7Vzp1ZteZt+GG9ady7o0+Nn832Ql6duFLp29JqHbuoqFAPPjRF+QV5daza3K7dO895/PDhw5o77zW98aaxsR4UaNE1o8cZ4rfdeo/pWP+Y9Td9tWKJTpw4cc5r5uXnasYzT+que25q1L3Mx42dVOuxGybdolatHPe2V0M+YyEhYRp7nXGv8ZdmP6/U1F9qHbukZJ8ef/wPpsfuueeBWs8DAAAAWhoa3gAAAAAAoEVZtWqFJOn779fp7imT9eI//66UlE2qrKyUJB07dkyrvl2hf/7r74ZzgwIthn2f42J7xpYpCwAAIABJREFUmV7nD3+8S4uXLFJFRYU9Vly8V+/Nf0uTb7lOu8/TrK6Lt95+RX//76f0S8pG+3WOHj2q3bt3as3ab3Xf728z7F192n33Pag2bdoY4iEhYaZ7S0vSrBee1WPTHtAvKRu1f3+pPX7gQJnS07fovflv6dbbxmvtutXavXunvlz6+UXf44WKjx8sb++OhvipWeyjHXrthn7GzD6EUFlZqYceuVdLvvysxmtRXV2tX1I26sGHpujXHRmG8yZNvKXR9i4HAAAAGoPx/3oAAAAAAACaqSNHjuirFYtrxJYt/0LLln9Rp/Ovusq4vHRERBeNvW6ilnz5meHY7Jf/odkv/0PSqUbr6YZnQ1r17Qqt+nZFvc7p1i1OQwYn1Hr8vnunavfubP20cYPhWMrmTUp5bFOdrjPvndc0POGqRlk+u02bNrph0m81d96cGvHrxkyUh4eHw67riGfMz89fd9z+O72/YK7h2EuzZ+ql2TPl7d1RPj6+ys7OrHVsDw8P3frbu+pUBwAAANBSMMMbAAAAAAC0GD/++N0FN527dYvTTTfeanrsjtt/d97zza4b07X7BdVyMUJDw/XsX1+Qi4tLrTlt2rTRU0/9t2zDRl7UtSorK7Vx0w8XNcbFMNv/+rrrJjj0mo56xn57y13nfD3Kyvaft9n9/N9ns3c3AAAALjk0vAEAAAAAQIvh4+Nrusz1+fTo0Vt/f/afcnd3r3XcV1+ep6BAS53HvOnG2/Ts316sdy0XwzZspF6ePVe+vn7nzW3v2V4znn5ef/vrrAv6nfn7d9KTTzytEcOvvpBSG4SPj6+uPqPpPWjQMFmCjHuuN/Q1HfGMXXbZZfqvPz+rW26+s95jh4aG6+WX5qpnz8vrfS4AAADQ3LGkOQAAAAAAaDG6d++hTz9erh9+SNbiJYtMl+w+U7ducbr7rvvV94oB5x07Lq6X3pn3b81//219/MkHteZdfdUYTZhwk6KjYnTo0CHDcQ+Pdue/kf9z5x33KTd393mXNB86ZLgmTph8QQ3PIYMT1LNnH72/YK5+/vnHc+497uHhof79BmrwYJuGDR1hukf4mdzdjM1dV1e3etd4LmPHTNDXXy+VJI2//sYLHsfVzViXe9u2hpgjn7E2bdrod1P+oKuvulYff7JQSWu+Oeds8piu3TVmzHhdfdWY874WknNeDwAAAMDZXE6ePHmysYsAAAAAAABNx3/m7taujFON2mtuD1FQWN0btE3N4cOHVbxvr4qKClRcXKTLLnNVO4928vfvrE6dA9Tes/0FjXvy5Ent3Vuk3Lw9Ki8/qMPV1QoMtCgsPFJe7b0uaMwXXnxOy7+quTf0839/SfHxg3XixAkV7S1Ubu4eHTpUoUOHKuTd4dSezpGR0XJ1db2ga5qprq7Wnpxd2r17p1xcXOTi4qIOHbzl09FXoaHhat26dYNdq6EsXfYfHT9+XGOvm3jOpdwdwVHPmCQdO3ZM2Tszta94r8oO7Jfb/zWsvb07Kiw0ok4z+S9FO9MP6ttFeZKkbld4adQtjp31DwAAgMbFDG8AAAAAANBiubm5yWoJltUS3KDjuri4qHPnAHXuHNCg49amVatWCgwIUmBAkMOv5e7uruioGEVHxTj8Wg1lzLXjG+3ajnrGpFMzvpvbawEAAAA4G3t4AwAAAAAAAAAAAACaJRreAAAAAAAAAAAAAIBmiYY3AAAAAACo4fDhw41dAgAAAAAAdcIe3gAAAAAAXMJ2796tBQsWKD8/X/n5+crLy1NCj8cU5NOrsUsDAAAAAOC8aHgDAAAAANCC7dmzR7t27dLBgwc1ZswYw/HDhw9r8eLFjVAZAAAAAAAXj4Y3AAAAAAAtzIQJE7Rnz54aMU9PT9OGd3BwsCHWunVrh9UGAAAAAEBDouENAAAAAEATV1VVpby8PPuy4wUFBcrLy9PTTz8tLy8vQ35FRYVp7ODBg4b8tm3b6vHHH5efn58sFosCAwO1+pMy7co45LD7AQAAAACgodDwBgAAAACgCSgoKJCHh4c6dOhgOPbAAw9oy5Ythvidd96puLg4Qzw4OFilpaWSJD8/P4WGhio4OFjHjh0zvfZNN910VqSs/jeAixYdHaPi4qIaMX//zo1UDQAAAAA0DzS8AQAAAABwsszMTP3www/KysrSzp07tWPHDlVXV+uZZ54xXXbcarWaNrx37dpl2vB+5pln1KlTJ0mSm5tbw98AHGLc2EkaN3ZSY5cBAAAAAM0KDW8AAAAAABpYdna2srOz5e3trb59+xqOr1q1SvPmzTPEc3NzTccLDQ1VaGioIiIiFBkZqejoaIWFhSkiIsI032xfbgAAAAAAWiIa3gAAAAAAXKTMzEy9++67ysrKUlZWlj0+evRo04a31Wo1xNzd3Wsdf8qUKZoyZUrDFAsAAAAAQAtCwxsAAAAAABOlpaXKz8+v8eXm5qbHHnvMkHvo0CGtXLnSEK9txnZUVJSuueYaRUREKCoqSuHh4QoKCmrwewAAAAAAoKWj4Q0AAAAAwFkOHDigq666yhD38fExbXiHh4fbv/f09JTFYlFgYKC6du1qOn7Xrl31t7/9reEKBgAAAADgEkXDGwAAAABwSdiwYYN27txpn61dUFCgvLw8rVixQm3btq2R26FDB3l6eqqioqJGvLS0VJWVlfLw8KgR9/Ly0sKFC2W1WuXp6enwewEAAAAAAKfQ8AYAAAAAtAjV1dUqKCiQv7+/adN5zpw5ysjIMMTz8vLUpUsXQ7xLly4qLS2VxWJRUFCQ/atVq1am14+Jibn4m2hkhYWFSktL065dl0nyb+xyAAAAAAA4LxreAAAAAIBm6euvv9aaNWvsM7ZLS0slSbNmzdLw4cMN+Var1bThnZOTY9rwnjdvXsMX3QTt2rVLr776qtLS0lRSUiJJSujxmIJ8aHgDAAAAAJo+Gt4AAAAAgCblwIED2rFjh7KyspSVlaU+ffpo1KhRhrwdO3Zo5cqVhviePXtMxx0wYIDc3d0VGBgoi8Vi32c7ICCgwe+hKcrNzZXVajXEL7vsMq1Zs6YRKgIAAAAA4OLR8AYAAAAANAnr16/XM888o7Kyshrx48ePmza8z27eWiwWhYeHKyQkxHT88ePHa/z48Q1XcBNXWFioDRs26KefftJPP/2k0tJSbdy40ZBnsVjk7e1t/71HR0ef+hDAEWdXDAAAAABA/dHwBgAAAAA4TEFBgX2mdlZWlrKzs+Xj46NXXnnFkOvq6mpodku1z9ju06ePZsyYocjISEVERMjd3b3B62+u7r77bqWmphriaWlpiouLM8SnT58uHx8fxcbGys3NTf+Zu1u7Mg45o1QAAAAAAC4KDW8AAAAAwAU7cOCAioqKFB0dbThWWFio6667zhDv3Lmz6VhnzsyOiopSWFiYunTpYtqgPZ1f22zuli4vL08ZGRmKjo5WcHCw4bi/v3H/bVdXVxUVFZn+PkeOHOmQOgEAAAAAcDQa3gAAAACAOpszZ46ys7OVn5+v/Px8VVZWSpLpUtkBAQFydXXVkSM118YuKirS4cOH5ebmZsj/5JNPFBER4bgbaKZ27typb7/9VmlpaUpLS7PPhJ86daruuOMOQ/7ll1+unJwchYaGqlevXurVq5e6devm7LIBAAAAAHA4Gt4AAAAAAFVXV9ub2Pn5+RoxYoR8fX0NeevXr1dmZqYhvmvXLoWFhRniY8aMkYuLiywWi4KCghQYGCiLxWJodp9Gs9vc5s2b9eabbxriKSkppg3vyZMna/Lkyc4oDQAAAACARkXDGwAAAAAuYS+//LKWLl2q/fv314hbrVYNHDjQkG+1Wg0Nb6vVqoqKCtPx//znPzdcsS1QYWGh0tLSlJ6ertTUVHl6emr27NmGvF69etm/d3NzU7du3dSjRw/169fPmeUCAAAAANDk0PAGAAAAgBYmLy+vxmztvLw8JSQkaMSIEYbckydPGprdkrRnzx7ThvfEiRNls9lksVgUGBiogIAAh9xDS3fgwAFNnDjRvjT5ae7u7qb54eHheuKJJxQXF6fu3bs7o0QAAAAAAJoFGt4AAAAA0IJ8/PHHeuGFFwxxLy8v04a31Wq1f+/n5yer1aqAgAAFBwebjn/llVc2XLEt3K+//qr09HSNGjXK0Mju0KGD6TmtW7dWTk6O6e//xhtvdEidAAAAAAA0ZzS8AQAAAKAJKy8vV3Jysn22dkFBgfLy8hQdHa1Zs2YZ8kNCQkzH2b17t2l8xIgR6tevn0JDQxu07kvRzz//rOTkZG3dulVpaWmqrq6WdGpf8p49exrye/bsqR9++EGXX365+vbtq759+youLs7ZZQMA6iAvL0979+7V9u3blZaWpj179qiwsFArV65s7NIAAAAueTS8AQAAAKARFRcXKysrS4WFhbr++usNx0tKSvSXv/zFEG/durXpeBaLRb6+voqIiFBUVJTCw8MVGRmpyMhI0/yOHTuqY8eOF3cTkCQtWbJES5cuNcTT09NNG95PPvmkOnfu7IzSAAB1lJqaqoKCAvufz+np6crKyqo1v2/fvtq4caMTKwQAAMDZaHgDAAAAgJPNnDlTmZmZyszMVEVFhT1u1vAOCwszHaNVq1am8ZCQEH399dcNUygkSTt37lRaWpq2bdumzZs3a+jQobrvvvsMed27d6/R8HZ3d1f37t3l5+dnOi7NbgBoPBkZGUpLS9Pu3bu1d+9eFRQUKD09vV5jnDx5Ui4uLg6qEAAAAHVFwxsAAAAAGkhOTo6ys7OVmZmprKwsPfTQQ6ZNzXXr1qmoqMgQz83NrbGn9mljx46Vj4+PIiMjFR4erpiYGIfUj5p+/vlnPfTQQ6qqqqoRr21G/OWXX65x48YpLi5O3bp143UCgCagrOyAFi/epK1btyozM1NFRUWmfwbX5uTJk5Jk2tim2Q0AANA00PAGAAAAgIv0/PPP67PPPjPEr7/+etOGd3BwcI0322NiYhQREVHrMuVPP/10wxULg127dpnOpA8ICDA0uyXVOgMwKipKTz31VIPXBwC4cN8lJ+u77W+fM+dimtosZw4AAND4aHgDAAAAwFl27dqllJQUFRQUKC8vT/n5+crPz9f9999vuuz46TfKz5aTk6P+/fsb4rfeeqsmT56siIgIhYSENHj9qF1RUZHS0tLsX9u2bdOJEyf03XffGXKDgoLk7e2t6upqxcTEKC4uzv4FAGg+Ti89fuaf12c2si9kpjbLmQMAADQdNLwBAAAAXJIKCwt1/PhxWSwWw7Hk5GS99NJLhnhOTo7pWOHh4fL395fFYlFgYKD9n1dccYVp/uDBgy+ueFywO++8U8XFxYZ4enq6unfvboi/8847Cg0NdUZpAAAHOd3spkENAADQMtHwBgAAANDi7dmzRwsWLLDP1s7Ly5MkjRw5UjNnzjTkmzXBT49j5uabb9bNN9/ccAXjgmRmZiotLU0ZGRkaM2aM6UzsPn366Ouvv7b/7O3tfc4Z2zS7AaB5a9Pm1NufDd30dnFxYTlzAACAJoKGNwAAAIBmbf/+/fYlx6uqqjR27FhDzpEjR/TFF18Y4rm5uaZjdunSRcOHD68xYzsoKEiBgYENXj8uTlJSkv79739r69atNfbb7tSpk2kjOyEhQX5+furWrZvi4uJktVqdWS4AwMkGxMdra+HHKikpYYY3AABAC0XDGwAAAECzdOONNyo/P1/V1dX2mIeHh2nD26yp2a5dO7Vt29Z0bKvVqlmzZjVcsbho+fn5CgoKMsT3799vOsMuJSXFdJyRI0dq5MiRDV4fAKBp6tDBSwsWLNDvf//7WldqAQAAQPNGwxsAAABAk1BRUaHMzExlZWVp586d9u8/+ugj+fv7G/IPHDhQo9ktSZWVlSouLjbku7u764knnpCvr6991naHDh0cej+4cLt27VJaWpr9KyMjQ/369dMbb7xhyD1zFrfValXfvn3Vr18/9e/f35klAwCasM6dO+vtt9/WXXfdpYKCggYZc9myZQ0yDgAAAC4eDW8AAAAATlNQUCAPDw/TZvODDz6o1NRUQzw3N9e04R0cHKySkhJ17txZERER6tKliyIiItSuXTvTa994440XfwNwuMLCQk2aNMkQT0tLM82PiorSU089pfj4eHXu3NnR5QEAmik/Pz/NnTtXd999t/bu3StJF7Sn9+lzrr32WsXExCghIUE2m02RkZGOKBsAAAB1QMMbAAAAgENkZmbqhx9+sM/Y3rFjh6qrq/XMM89ozJgxhnyr1Wra8N6zZ48uv/xyQ3zGjBny9fWVh4eHQ+qHY6Smpmrr1q1KS0vT008/LTc3txrHAwIC5Ovrq5KSkhpxNzc37d27V506dTKMOW7cOIfWDABoGQICAjRv3jzdfffd2rdvn1xcXC6o6X1aRkaGMjIy9MYbbyg4OFg2m00JCQnq2bNnA1cOAACAc6HhDQAAAKDeCgoKlJ+fr/z8fAUGBqpv376GnMTERL311luGeG5urumYISEhCg0NVUREhCIjIxUdHa2wsDBFRESY5gcHB1/cTcBpFi5cqJUrVyo9Pb1G/IYbblDv3r0N+X369FFRUZF69uyp2NhYxcXFKTAw0FnlAgBasKCgIL333nuaOnWqdu3adUFN7+uuu07r1q1TWVmZPZaTk6MPPvhAH3zwgXx9fTVs2DDZbDYNHDjQEbcBAACAM9DwBgAAAFAnGzdu1LPPPqu8vLwa8dGjR5s2vENDQw0xX1/fWt9QnjJliqZMmdIwxcLpqqqqVFlZKV9fX8Ox7OxsQ7NbOrVMuVnD+/nnn3dIjQAASFJgYKDmz5+vP/7xj0pLS6tX09vFxUUzZsyQdOrvRklJSUpKSlJhYaE9p6SkRJ9//rk+//xztWvXToMGDVJCQoIGDRrEyjQAAAAOQMMbAAAAuISVlpbaZ2qf/nJ1ddW0adMMue3atTM0u6VTM5rM9OzZU08++aSCgoLsX2cvX43mbePGjdq4caN+/PFHpaam6u6779YDDzxgyOvevbuWLFkiSfL29rbP2o6Pj3d2yaij1m3+v+lz4vjJRqwEAOrv+Bn/3WpzWSvTHE9PT73++uu69957lZGRcUHLmvft21d9+/bVtGnTlJGRocTERCUmJio7O9uec+jQIa1cuVIrV66UJA0aNEg2m03Dhg2Tj49Pva8JAAAAI5eTJ0/yf64AAADAJejgwYMaPny4Id6xY0d98803hnhFRYVsNpukU81vq9WqwMBAde3aVb/73e8cXi+ajuTkZD300EOG+IABA/Taa68Z4nl5edq2bZtiYmJktVqdUSIu0qpP87Vlw6mleoeND1JUjw6NXBEA1F3q9yX68Zu9kqQBv/HTwFGdas0tLy/XI488opSUFEk650zvkydPatOmTee9fm5urlavXq3ExERt2bKl1rxevXopISFBw4cPV1BQ0HnHBQAAgDlmeAMAAAAtyIYNG7Rz5077bO2CggLl5eVp+fLlateuXY1cLy8veXp6qqKiokZ8//79qqiokKenZ424p6enFi5cqKCgIHl5eTn8XtC4UlJSlJ+fr2uuucZwLCQkxPSc8vJy07jFYpHFYmnQ+uBYHu3//+2CqopjjVgJANTfmf/daud17rc/27dvr3nz5mnatGlKSko65/LmdZ0FbrVadfvtt+v222/Xvn377Mueb9iwoUbe5s2btXnzZs2ePVtdunSRzWaTzWZTTExMna4DAACAU2h4AwAAAM1IdXW1CgoK5O/vb2hIS9Jrr72mbdu2GeI5OTmmb55GRUWppKREFoulxtLjbdqY/68Cb8C2XEuXLlVaWprS09Pt+227urqaNryDg4NltVoVHBys2NhY9ezZUz179jR9JtE8tTuj4V2cX9WIlQBA/RXnV9u/b+d1WZ3OefHFF/Xoo49q7dq1po3tuu7xfTY/Pz9NmjRJkyZNUkVFhdavX6/ExEQlJyeruvr/68zMzFRmZqbmzZungIAAe/O7b9++9b4mAADApYYlzQEAAIAm7JtvvlFiYqJ9xnZpaakkadasWabLkf/pT38yLEfu4+Oj5557Tv3793dKzWiexo4dq/z8fEP8vffeU48ePRqhIjSmopwqfTR7pyTpMrdWuuPJro1cEQDUzdHDJ/T+P7bbf77vmegaq1acz+mZ3rXZuHHjRdV3prVr1yoxMVHr1q1TWVmZaY63t7eGDBkim82m+Ph4ubm5Ndj1AQAAWgpmeAMAAACN4MCBA/aZPNnZ2erVq5fpTNrt27dr5cqVhvju3btNx42Pj1eHDh0UGRmpyMhIRUVFqX379g1eP5qPLVu2aOvWrUpJSdG2bdv01FNPmc4W6927t73hHRAQoLi4OMXGxiogIMDZJaMJ6BzcVp4d2qjiwDEdPXxCO7YcYB9vAM1C+qZS+/dBYW3r1eyWTs30njp1qr7//vsa8bru310fQ4cO1dChQyVJmzZtUmJiopKSklRYWGjPKSsr05dffqkvv/xS7u7uuvLKK5WQkKChQ4eysgoAAMD/YYY3AAAA4ETr16/XX//6V+3fv79G/LrrrtOMGTMM+YsXL9azzz5r/9lisSg8PFxjx441neENnDZ//nzNmTPHEJ86daruuOMOQ3zLli06cOCA4uLi5O3t7YwS0cStX1akn1aXSJLad7xMN03t0sgVAcC5HTt6Uv8z+1cdrjohSbJd31mXD/G9oLGmT5+uVatW1Yg15Ozuc8nIyFBSUpISExOVlZVVa17//v1ls9mUkJAgf39/p9QGAADQFDHDGwAAALhIBQUFysrKsn9lZ2fLx8dHr7zyiiHX3d3d0OyWTu2xbaZPnz6aMWOGIiMjFRERIXd39wavH81TRUWFtmzZIhcXF8XHxxuO19a03rJli2mcZctxtsuH+OqXdaU6dvSkyvcf1Y7UA4rqySxvAE3X1h9L7M1ud49Wiuvf8YLHmjlzpmbOnKlFixY1VHl1FhMTo5iYGN1///3Kzc3V6tWrlZiYaPgz/Mcff9SPP/6oWbNmqXv37kpISJDNZlN4eLjTawYAAGhMzPAGAAAAzuPAgQMqKipSdHS04VhhYaHGjBljiHfq1EnLly83xIuKinTttddKkqKiohQWFqYuXbooNjbWtGkJnFZeXq6vvvpKaWlp2rZtm3buPLW/cp8+ffT2228b8jMzMzV58mR5enqqd+/e6t69u3r06KEePXqwBCrq7IdVxfruq2JJkqt7K10/JVxePq6NXBUAGJUUVmvJu7t0/Niptzp/c2Og4gZceMO7Kdq3b5/WrFmjxMREbdiwoda80NBQ+8zvuLg4J1YIAADQOGh4AwAAAGeZM2eOsrOzlZ+fr/z8fFVWVkqqfRnLgQMH6siRI4Z4cnKy3NzcDPHs7GxFREQ0bNFo8fbt26dRo0YZ4u7u7lq/fr3pOTk5OQoODnZ0aWjhFv4zS8X5hyVJnh3aaOw94fLwZME4AE1H+f6j+mLeTh2uOi5JCo1upwn3hTZyVY5VUVGh9evXKzExUd99952qqqpM8/z8/GSz2WSz2fhwJQAAaLFoeAMAAOCSUV1drfz8fBUUFCgvL0/Dhw+Xn5+fIW/y5MnKzMw0xBctWqSwsDBD/Pnnn5ckBQUF2b8sFgv7IKPOioqKtGHDBm3atEmbNm3SokWL1LZtW0Pe6NGjVVxcbP/ZYrEoLi5O06dPV/v27Z1ZMi4hB0uPasGLmTp6+NTbBx7t22j0rSHq6G/8QA8AOFtxfpVWfLjHvpR5O6/Wun1aF7m3a93IlTnXunXrlJiYqLVr16qsrMw0x9PTU4MHD5bNZtOgQYNM/64BAADQHNHwBgAAQIv36quvasmSJYa9s2fPnq3Bgwcb8qdNm6akpKQaMavVqueee45lIdGg3n77bS1fvly5ubk14m+99ZauuOIKQ/7cuXN14sQJxcbGqmfPnvLy8nJWqbjEZaaV68v3cuw/t77MRYOvDWRPbwCNKv2nUn33VVGN2OSpYQoM82ikipqGTZs2KTExUUlJSSosLDTNcXV1Vf/+/e2zv/mgJgAAaM5oeAMAAKBZysvLsy85fvpr2LBhGjlypCF39uzZWrhwoSE+bdo0TZ482RDfsGGD9u3bJ4vFosDAQAUEBDjkHnBpqKio0NGjR9Wxo3Ef0aeeekpfffWVIf7ggw/q9ttvd0Z5QJ1l/Fymrz7MrxHzC3RTvxGdZIlgX3gAzrNre7l+WlWkAyVH7bHL3Fx07e3BCo/hv0dnysjIUFJSkhITE5WVlVVrXu/evZWQkKCEhAQFBQU5sUIAAICLR8MbAAAATVJFRYXKyspktVoNxz799FP94x//MMRvvPFGPfHEE4b4okWLNHPmTEmn9jG0Wq0KCAjQ6NGjNWjQoIYvHpe0tLS0Gl+5ubm6//77NWXKFEPu6WczICBAcXFx6tGjh+Li4tSrV69GqBw4v8I9Vfpi3h5VHTpeI36ZWyuFxXiqYyd3eXi2kYdnG7m0aqQiAbQoJ05IleXHVFlxVHvzqpWXWaFjR2u+ndm+YxuNnxIq3wC2WjiX3NxcrV69WklJSUpNTa01LyoqSjabTQkJCYqOjnZihQAAABeGhjcAAAAaXXl5uVavXq3s7GxlZ2crMzNTxcXFGjBggF577TVD/vfff6+pU6ca4v3799frr79uiJeVlenAgQMKDQ11SP3AacuXL9fTTz9tiF955ZV69dVXDfGDBw/qxIkTLCOKZuVw1Qn9tLpYv6wrNTSdAMCZXN1b6Qqbj/oO81cbV5fGLqdZ2bdvn9asWaPExERt2LCh1rygoCD7sud9+vRxYoUAAAB1R8MbAAAADldcXKysrCwVFhbq+uuvNxzfvXu3Jk6caIhbLBYtXrzYEM/JydE999yjyMhIRUVFKTw8XBEREerSpYvatWvnkHsADh06pNTUVG3dulUHDx7Uo48+asjJzc01PONdunTR4MGD9cc//tFZpQJOUVVxTBuTSrRD4va2AAAgAElEQVRtU5kOHTx+/hMAoIF4+bRR937e6jPET25tWU7iYlVUVGj9+vVKSkpScnKyqqqqTPO8vb01dOhQJSQkaMiQIU6uEgAAoHY0vAEAAOAQM2fOVGZmprKyslReXm6Pb9y40TS/b9++hlhoaKg+++wzh9UI1MWMGTOUlpam3bt322Nubm5KTk42zf+v//ovxcTEqHv37oqNjZW7u7uzSgUaTeHuSu3cXqHKg8dVdeiYqiuP68SJxq4KTVV+fr4KCwvtP4eEhMjPz8/h1z1y5IjS0tLsP/fq1UutW7d2+HVxcVq1ltp6tFbbdm3k6d1G4d285B/E0uWOtG7dOiUmJmrt2rUqKyszzWnbtq0GDhwom82mIUOGyNOTvdMBAEDjoeENAACAOqmurlZeXp4KCgpq/HPatGnq3LmzIX/s2LHKz883xL/44gvTfbmfffZZdezYUZGRkQoPD1dMTIxD7gMwU1BQoI4dO5o2p6+77joVFBQY4h9++KG6du3qjPIAoMWoqKjQmDFjVFFRYY/5+/vriy++kJub45uYDzzwgH788UdJ0hNPPKEbb7zR4dcEmrNNmzYpKSlJiYmJNT6ocrYBAwYoISFBNpvNKR9gAQAAOBMNbwAAANTJgw8+qO+++84Qf+211zRgwIBz5lutVlksFgUGBuruu+9WUFCQw+sFalNVVaUtW7Zo69at2rx5s9LS0lRWVqY33nhD/fr1M+RPnz5dq1atknRqH8u4uDh1795do0ePlq+vr7PLB4Bm7fXXX9e7775riD/88MO69dZbHX79VatWafr06ZKk4OBg/ec//3H4NYGWIiMjw978zsrKqjUvLi5ONptNw4cPV0hIiBMrBAAAlyoa3gAAAJeo3bt365dfflF+fr7y8/PtM7bvvfdeTZgwwZD/wgsv6OOPPzbEp0+frkmTJhniubm5atOmjQICAhxSP3Chnn/+edOl8h944AHdfffdhnhKSorKy8vVq1cveXl5OaNEAGiRysvLNXr0aFVXV+vkyZNycXGxH/Pz89OKFSucUseIESN04MABSdI777yjXr16OeW6QEuSm5urxMREJSYmKjU1tda8sLAw2Ww2JSQkKDY21okVAgCAS0mbxi4AAAAAjlNYWKjjx4/LYrEYjiUnJ+tf//qXIZ6bm2s6VkhIiPz9/e0ztU//s0+fPqb5ZsuWA45WWlqq1NRUbd68WRaLxfTDGHFxcaYN74MHD5qO2bt37wavEwAuRR9++KGqq6slyd7sPt343rdvnz7//HPTD901tIkTJ+qjjz7SiBEj2HcYuEBWq1W33XabbrvtNpWWltqb3xs2bKiRt2vXLs2fP1/z58+Xv7+/bDabbDab6QpRAAAAF4oZ3gAAAC3Enj17tGDBAuXl5Sk/P195eXmSJJvNphdffNGQv3btWj366KOGeEJCgl544QWH1ws0lNzcXL388stKS0tTcXGxPd67d2/NmzfPkJ+VlaUHH3xQPXr0UFxcnOLi4mhqA4CDVVRUaOzYsTp48KBhdvdpnTp10vLlyx1eS3l5uVxdXZ2yZzhwqamoqND69euVlJSk5ORkVVVVmea1b99egwcPVkJCggYOHCh3d3cnVwoAAFoSGt4AAADNQEZGhrKyspSdna1Dhw7Z9548U1ZWlm666SZDPCIiQp988okhnpubq1deeUVBQUEKCgqSxWJRUFCQAgMDecMJzUpZWZlGjhxpiLu5uSk5ObkRKgIAnO2NN97QO++8I0m1Nrwl6ZFHHtFvf/tbZ5YGwIHWrVunxMRErV27VmVlZaY5rq6uio+Pl81m07Bhw9ShQwcnVwkAAJo7Gt4AAABN2Pjx45WTk2OIb9y40RCrrq7W4MGD7T97enoqKipKsbGxevjhhx1aJ+AIhw4d0pYtW5SWlqYtW7YoPT1d33zzjWnumDFjVFhYKEnq0qWLevfurZiYGF1//fXOLBkAYKKsrExjxoyxL2d+Lt7e3lq1apUTqgLgbD///LMSExOVlJSkgoKCWvP69OmjhIQEJSQkKCAgwIkVAgCA5oqGNwAAgBNVVFQoMzNTWVlZ2rlzp/37hQsXqnPnzob8q6++WiUlJYb40qVLTd/8+eyzz2S1WhUZGSk/Pz+H3APgDI8++qjWrl1riM+bN890+fHVq1erQ4cOio2NZYUCAGhi6jK7+8z49OnTNWnSJKfWCMC5MjIylJSUpKSkJGVmZtaa17VrV9lsNiUkJKhLly5OrBAAADQnbRq7AAAAgJamoKBAHh4epkvxPfzww0pJSTHE8/LyTBveISEhKikpUadOnRQREaGoqChFRESoffv2pteeOHHixd8A4ASFhYVKT09XWFiYIiIiDMe9vLwMMVdXV/ss7rMNHz68wWsEAFy8iooKffTRR5LOvZS5i4uL/fj8+fOd3vDet28fHxYEnCgmJkYxMTG6//77lZubq8TERCUmJio1NbVG3vbt27V9+3a99dZbslgsSkhIkM1mM/0AJAAAuHQxwxsAAOAiZGZm6ocffrDP2N6xY4eqq6v1zDPPaMyYMYb85557Tl988YUh/tRTT2ncuHGGeE5Ojnx8fNSuXTuH1A84y549e/Ttt99q69atSklJse/hOGXKFN1///2G/C+++EL//ve/1a1bN8XFxSk2NlYxMTHOLhsAcJHefPNNzZs3T9K5G95nc9Ze3p988omWLVumrVu3atWqVfL29nb4NQHUrrS01L7s+ffff19rXseOHTVs2DDZbLYa2zoBAIBLEw1vAACAWhQWFiovL0/5+fkKDAxU3759DTnz5s3Tm2++aYjfc889+v3vf2+Ir1ixQt99952CgoIMX0BLtmzZMs2YMcMQ79+/v15//fVGqAgA4Gj12bv7tNNNcR8fH61cudKB1Z3y2GOPac2aNZKkqVOn6o477nD4NQHUTUVFhdavX6+kpCQlJyerqqrKNM/Dw0MDBw60N789PT2dXCkAAGhsLGkOAABwhk2bNulvf/ub8vLyasRHjRpl2vAODQ01xHx8fGqdvTRq1CiNGjWqYYoFmoDS0lKlpKQoPT1dW7ZskYuLi+mHQGJjY2v83LlzZ8XHx2vQoEHOKhUA4GQLFy60N7vrM7tbOvXny6effqobbrjBUeVJkiZMmGBveH/66ac0vIEmxNPTs8b/P61fv16JiYlas2aNfbUgSaqsrNSqVau0atUqSVJ8fLwSEhI0bNgwtioAAOASwQxvAADQ4pWWlio/P7/Gl6urq6ZNm2bI3b59u+nymbGxsXr//fcN8cLCQq1bt67GTG03NzeH3AfQlFRXV2v8+PEqLi42HNu4caPpOTNmzNDll1+uK664QsHBwY4uEQDQiMrLy3XNNdfUOiPzXE43xwMDA/Xll186oLqaxowZo8LCQknSnDlzFB8f7/BrArg4P//8s33p84KCglrzevToIZvNphEjRshqtTqxQgAA4Ew0vAEAQItWXl6uhIQEQ9zb29s+A+BMhw4d0rBhwyRJ7dq1k8ViUVBQkKKjo3Xvvfc6vF6gKcnOztaWLVs0YsQI06Uhx40bZ1gNQZIWLFig7t27O6NEAEAT9dZbb2nu3LkXPc60adM0efLkBqiodu+++659e43hw4dr1qxZDr0egIa1fft2e/M7MzOz1rzw8HAlJCTIZrPxd1UAAFoYGt4AAKDZ2bBhg3bt2mXfX7ugoEB5eXlatmyZaVNu5MiRNZa8Oy0pKck0PyMjQ0FBQfLy8nJI/UBTlZqaqnXr1ik9PV2bN2+2L0Nb22y3v/zlL1qxYoWio6PVvXt3xcXFqXv37oqOjnZ26QCAJuTAgQO69tprVV1dXe+lzE87fZ63t7eWLl0qd3d3B1R6SklJia6++mrFxsZq3LhxmjBhgsOuBcCxcnNzlZiYqMTERKWmptaa17lzZw0bNkwJCQnq16+fEysEAACOQMMbAAA0KdXV1crMzFR2drb69eunwMBAQ85tt92mbdu2GeK1zSr93e9+p5KSEvuS46dnbQ8ZMsShb54Czc2sWbP0ySefGOL333+/pkyZYogXFhbK29ubf48AADXMmTNH8+fPv6gxzmyUP/7447rpppsaorRa7du3j71+gRamtLRUSUlJSkxM1Pfff19rnpeXl4YMGaKEhATFx8fzd1sAAJqhNo1dAAAAwNdff62vvvpKWVlZNfZfe+6550wb3iEhIYaGt4+Pj8rLy03Hb4jlNIHmrrCwUGlpaUpPT1dISIiuv/56Q05sbGyNn93c3NStWzfTfw8lKSAgwCG1AgCar8rKSn388ceSdMGzuyXVOO+DDz5weMObZjfQ8vj4+GjChAmaMGGCKioqtH79eiUlJSk5OVlVVVX2vIMHD2rZsmVatmyZ3NzcdOWVV8pms2no0KGs+gUAQDNBwxsAADjMwYMHtWPHDvuM7Z49e+raa6815O3YsUP/y96dh0V53/v/f6XNCaCoaDSyuCBoAjIGVIxRMcy4olEZ0KS2Nak2JrFLEpucLM1JzslJc86x3xNP0zaLaWNjFrNVzSAaXAgzboiGIOqIqICIbAmoqKMM6XWOvz/8OZXOkBXmZnk+rosr97zvt8OLK9flJfO+P5/Pzp07veonT570+b633HKLevTooejoaEVHR2vYsGHq0aNHq+cHOroTJ07oD3/4g5xOp06dOuWpJyYm+hx4x8fHa9asWTKZTDKZTIqJifFnXABAJ/DOO+94Bknfdtj9j2pra/Xee++1+VneADqv4OBgpaSkKCUlRZK0c+dO2e12bdu2rdnxV01NTXI4HHI4HJIu/7vZbDbLYrGof//+hmQHAABfjS3NAQBAq9u1a5eeeeYZnTlzpll91qxZeuaZZ7z6169fr2effdbzOjw8XFFRUZo9e7YmT57c5nmBjq68vFyRkZFe9draWs2aNcurHhAQoF27dvkjGgCgi7FYLDp//vx3Wt3tS+/evbV169ZWez8AuKKgoMCz9fnVO479o5iYGM/wOzo62o8JAQDAV2HgDQAAvlJjY6N27Nih6upqVVVVqaamRlVVVQoPD9dLL73k1V9YWOjzvN+EhAS99tprXvWTJ0+qsLBQUVFRio6O5sw04EucOXNG+/fvl9PplNPp1KFDh9TY2Khdu3YpICDAqz8lJUXnzp1TTEyMZ+W2yWRSeHi4AekBAJ1dYmJiq77f1YPz/Pz8Vn3vL+N2u/W3v/2NXYSALubIkSOy2+1yOBwqKSlpsW/AgAGyWCwym82Kj4/3Y0IAAOALA28AACBJOnv2rGpra3XTTTd53Ttz5oymTp3qVe/Xr5+ysrJ89qelpSkiIkJhYWGe/0ZHR2vMmDFtkh/oKubNm6fy8nKv+quvvqrRo0d71SsqKjRo0CB/RAMAwDPwbs2Pm/w58C4tLdXrr78uh8OhBQsWaMmSJW3+PQG0T9XV1crJyZHdbtf+/ftb7Lv++ut12223yWKxaPz48X5MCAAArmDgDQBAF/XSSy+prKxMVVVVqq6u1sWLFyW1/EFiUlKS3G63V33nzp2syAZaSVlZmZxOp4qLizVt2jQlJCR49Tz33HOy2Wye1z179lRcXJzuuecen/0AAPhTa6/wvpo/Bt779u3TvffeK+nyEGvz5s1t/j0BtH+nT5/2bHu+e/fuFvu6d++uCRMmyGw2KykpSd26dfNjSgAAui4G3gAAdDJut1vV1dWer0mTJqlv375effPnz/e5RdsHH3ygqKgor/qyZct06dIlhYeHe74iIiIUEhLSJj8H0FXk5ubqrbfeUlFRkS5cuOCp33///Z4P3K+2Y8cO7d27V7GxsTKZTKzeBgB0SFcG4927d9e2bdsMTtNcWlqaTp48KUl6/vnnZTabDU4EoD1xuVzatWuX7Ha7cnNzPQ+P+zJ+/HhZLBYlJyerT58+fkwJAEDXcq3RAQAAQOv44x//qPXr1+vMmTPN6v3791dycrJX/8CBA70G3gMGDGg2cLvaE0880XphgS6oqqpKERERXvVz587pk08+8aofOnTI5/tMnDhREydObPV8AADgsjvvvFPLly+XJK1du5aBN4BmgoODNX36dE2fPl3S5V3P7Ha7tm3bpoaGhma9ubm5ys3N1X/8x38oPj5eZrNZFotFAwYMMCI6AACdFiu8AQBox0pLS1VWVqbS0lLPV1pamu666y6v3hdeeEFvv/22V/3BBx/U3Xff7VXPy8tTfX29Z7V2aGhom/wMQFd04sQJOZ1OHT58WAcOHFBRUZFMJpNWrVrl1VtRUaH09HRJUkBAgGJjYzVixAjdcsstGjdunL+jAwDgF+15hbfL5Wo25N6wYQP/Vgbwtezbt092u112u101NTUt9kVHR8tischsNismJsaPCQEA6JxY4Q0AgIFcLpcaGhp8Pt29Zs0aLVu2zKteUVHh872ubGscFBSkYcOGKSoqSkOGDNH48eN99t96663fITmAlpw7d05z5871qjudTp/9gwYN0hNPPCGTycSHXQAAtAPBwcGaNWuWHA6Hpk+fLtaKAPi6Ro4cqZEjR+rhhx/WkSNHZLfb5XA4vHZXu/JA+2uvvabQ0FCZzWaZzWbPw0AAAOCbYYU3AAB+cv78eeXk5KisrExlZWUqKSlRXV2dxo4dq5deesmrPy8vT7/85S+96omJiVqxYoVXvaGhQW63m9UnQBurr69Xfn6+9uzZo4ceesjnOfbp6eleD6f06NFDb7/9ts9tzQEA6Gra8wpvSTpz5ox69+5tdAwAnUR1dbVycnJkt9u1f//+Fvt69eqliRMnymw2a9y4cQoICPBjSgAAOi4G3gAAtJK6ujqVlpaqtrZWVqvV635lZaXPenh4uNavX++z/6c//amio6M1dOhQz4rtYcOGqXv37m3yMwDwbe/evcrJyVF+fr7Ky8s99T/84Q8+d1F45plndPLkScXGxiohIUExMTGc0wcAwFXa+8AbANrK6dOn5XA45HA4lJub22JfYGCgbr31VlksFk2cOFE9e/b0Y0oAADoWBt4AAHwHv/3tb3Xs2DGVlpbq/Pnznnp+fr7P/n/cniwoKEjh4eF6//332zQngO/mueeek81m86rff//9uvfeew1IBABAx8bAGwAuH3O2a9cu2e125ebm6uLFiy32jhkzRmazWZMmTVK/fv38mBIAgPaPgTcAAFdxu92qqqpSTU1Ns/8+8sgjPrcKt1qtqqys9KrbbDafqzltNpuCg4MVHh6u8PBwn1shA/Cf48ePy+l06vDhwzpw4IAmTJign/3sZ159GzZs0DPPPCPp8tbkJpNJI0aM0G233ca52wAAfAsMvAHA286dO+VwOLRt2zadOXOmxb7Y2FhZLBZZLBYNGTLEjwkBAGifGHgDAHCVhx56SLt27fKqv/jii7r11lu/tH/AgAGKiIhQWFiYfvrTnyo8PLzN8wL4dvbt26cHH3xQjY2NzeojR47Un//8Z6/+uro67d27V7GxsYqKivJXTAAAOq2OOPD+7LPP1L9/f6NjAOgi9u3bJ7vdLofDoerq6hb7Bg0aJIvFIrPZrBEjRvgxIQAA7QcDbwBAp1ZRUaGCggKvFduLFy/WvHnzvPqff/55vffee171xx9/XHfccYdXvbKyUtdee63P1d8AjHXgwAFVVFRo1qxZXvfq6+uVkpLiVY+MjNSaNWv8EQ8AgC6tIw28X3/9dX300Ueqq6uTw+EwOg6ALqi4uNhz7ndJSUmLfSaTybPt+aBBg/yYEAAAY11rdAAAAL6r2tpa/e///q8iIiK87u3atUvLly/3qldUVPh8r0GDBqlfv36eldpX/jtq1Cif/b62LQdgjI0bN3q2J3c6nZ761KlTFRAQ0Ky3b9++Gjp0qK6//nrFxcXp5ptv1ogRI9SrVy9/xwYAAO3cpk2bdPz4cc+1r4fmAKAtxcTEKCYmRkuWLFF1dbVycnJkt9u1f//+Zn1Op1NOp1MvvviiIiMjZTabZbFYFBcXZ1ByAAD8gxXeAIAOpbKyUqtWrfKs1r5yfrbZbNbzzz/v1b9jxw796le/ala77rrrlJ6ern/+53/2S2YA/jFv3jyVl5d71f/yl7/o5ptvNiARAABoSUda4W2z2fTcc89Javn4EwAwwunTp7Vt2zbZ7Xbl5ua22NevXz8lJyfLYrFo7NixfkwIAIB/sMIbANBuFBcXq6ysTKWlpXK5XPr1r3/t1dPU1CSbzeZVP3HihM/3HDJkiFJSUhQVFaWhQ4cqKiqKVdlAB3Po0CHPSgWn06lHHnlESUlJXn0mk6nZwDskJEQmk0nf//73/RkXAAB0MtOnT9fzzz8vt9utffv2qaKigq2CAbQLffr0UVpamtLS0nTx4kWVlpbKbrfLbrfr5MmTnr66ujqtWbNGa9asUXBwsJKSkmSxWDR+/HgFBQUZ+BMAANA6WOENADBcWlpas1/ErsjPz/eqNTU1acKECZ7XwcHBGjZsmOLi4rR06dI2zQnAv9577z2fOzcsXrxYS5Ys8arn5OSooKBACQkJiomJ4eEWAADasY60wluSli1bpjVr1kiS5s+fz25RANq9srIyz/C7uLjYZ891112nsWPHymw2Kzk5WSEhIX5OCQBA62CFNwCg1blcLpWUlKi0tFTl5eU6duyYSktL9fbbb6t///5e/Y2NjT7fp7a2VqGhoc1qAQEBevLJJxUREaHo6Gj17du3TX4GAP5x4MABXbhwQePGjfO619KHLVefz321SZMmadKkSa2aDwAAQLp8dMqaNWuUmJio+Ph4o+MAwFeKiopSVFSU7rnnHn322Wey2+1yOBzNFhd88cUX2rFjh3bs2KHf/OY3GjlypOfc7/DwcAPTAwDwzbDCGwDwrZSXl6t3797q1auX173FixersLDQq/7qq69q9OjRXvX77rtPBQUFuuGGGxQVFaVhw4YpKipKkyZNUvfu3dskPwBjHD16VHv37lV+fr4KCgp08eJFDR8+XG+++aZXb2VlpaxWq3r27Km4uDiZTCaZTCbFx8crODjYgPQAAKC1dLQV3pJUX1/PA7cAOrxz585p+/btcjgc2r17t5qamnz2DRs2TGazWWazWTfddJOfUwIA8M0w8AYAfKVt27Zp69atqq6uVnV1terr6yVJ//qv/6o5c+Z49T/33HM+z9l+6qmnZLVaveonT55Unz59GG4DnVx9fb1SUlJ83vN1hIF0eRu+qKiotowFAAAM0BEH3gDQ2bjdbuXl5clut2vHjh06d+6cz76wsDDP8NvXQgYAAIzGluYA0MXV1taqqqpK1dXVCg0N1ZgxY7x6Tpw4oU2bNnnVKysrfb5nYmKimpqaFBERofDw8GZfvgwcOPC7/RAA2oWDBw/q0KFDKiws1L/9278pKCio2f2+ffsqNDRUtbW1nlpYWJhMJpMaGhp8bmHOsBsAAAAA2kZgYKBnkC1Jn3zyiWfr888//9zTV1NTo3fffVfvvvuuQkJCNHHiRJnNZt16660KCAgwKj4AAB4MvAGgC9q3b5+eeeYZVVVVNatPnz7d58B7wIABXrU+ffroe9/7ns/3T0lJaXEVJ4DOZfXq1dq8ebOKioqa1efOnevz75O0tDT97W9/0/DhwxUfH+/zWAQAAAAAgP+NGTNGY8aM0WOPPaaioiLP8Pv48eOenoaGBmVmZiozM1OBgYEaN26czGazJk6cqJ49exqYHgDQlTHwBoBO4syZM56V2jU1NaqqqtI//dM/6dFHH/Xq7datm9ewW2p5xXZcXJwef/zxZiu1eYIX6DpcLpfcbrfPMysrKiq8ht3S5QdrfA2877nnnjbJCAAA4G8ul0vXXnutAgMDjY4CAK1u+PDhGj58uH7xi1+ooqJCOTk5cjgccjqdnh632y273S673S7p8sD8yorx/v37GxUdANAFcYY3AHQgx44d07Bhw7zqLpfLs/3U1YKDg+VwOLzqFy5cUHJysqTLZ+Zd2Xp82LBhuv/++1s/OIAOpaioSE6n0/NVUVGhu+++Ww8++KBXb1ZWlp5++mn1799fJpPJ8zV8+HAejAEAAC3qyGd4Hzx4UG+88YYcDof+5V/+RWlpaUZHAgC/qa+vl8PhkMPhUF5eXot9sbGxslgsMpvNHFUFAGhzDLwBoJ3Kzc3VoUOHVFpaqvLycpWUlEiStmzZoj59+nj1T5kyRQ0NDV71zZs36/rrr/eqHzlyRGFhYWw3BaCZjz/+WI8//rhXPT4+XitXrvSqu1wu/e1vf1Pv3r39EQ8AAHQSHXngvWnTJj311FOSpOjoaL3//vsGJwIAY7hcLu3cuVN2u125ublqbGz02Tdw4EDP8Pvmm2/2c0oAQFfAwBsADOB2u1VSUqKysjIlJiYqPDzcq+fuu+/2uU3wX/7yF5+/HCxZskQul0tDhw5VVFSU57+hoaFt8jMA6HguXryogwcP6tChQ6qrq/M52K6trdWsWbOa1fr166fx48fr6aef9ldUAADQyXXkgbckTZ48WWfPnpUkvfXWW4qNjTU4EQAYb8eOHbLb7dq+fbvPRRmSdP311ys5OVlms1njx4/3c0IAQGfFGd4A4CdbtmzRRx99pNLSUtXU1Hjqv/nNb3wOvAcOHOg18O7Tp48uXrzo8/1XrFjRuoEBdBrPPPOMnE6nysvLm9UfeughrzMnQ0NDFRUVpSFDhmjMmDEaM2aMBg8e7M+4AAAA7d7s2bP19ttvS5LWrl3rWfENAF3ZxIkTNXHiRElSQUGB7Ha7HA5Hs8/BTp06pXXr1mndunXq3r27JkyYILPZrKSkJHXr1s2o6ACADo4V3gDwHdTU1Ki6ulrV1dWqqqpSTU2NxowZ47U6Uro8kH7ttde86vfff7/uvfder3pGRoYOHz7sWa09dOhQth8H0KLa2lr17NnT5wcEd955p8rKyrzqr732mhISEvwRDwAAoJmOvsK7oqJC6enpkqTAwEBt3bpVQUFBBqcCgPbpyJEjnuH3lcSVCx0AACAASURBVCP7fBk/frzMZrPMZrPP4/wAAGgJK7wB4Fu6+ty2q11zzTU+B96RkZGe6+uvv14REREKCwtTVFSUz/dPTU1Vampq6wUG0Gm43W45nU4dOnRI+/fv14EDB9TQ0KDly5crOTnZq99kMnkG3qGhoTKZTIqLi1NERIS/owMAAHQKgwYN0pgxY3T8+HGlpKTI7XYz8AaAFtx000266aabtGTJElVXVysnJ0cOh0OFhYXN+nJzc5Wbm6v//M//1M033yyz2axJkyZpwIABBiUHAHQUrPAGgP9fY2OjduzY4VmxfWXVdmhoqF555RWvfqfTqYULF3rV4+PjtXLlSq/6uXPndPr06WaDbwD4Nl544QXPFppX++lPf6qf//znXvWDBw/q9OnTio+PV0hIiD8iAgAAfKmOvsJbkurr69W3b1+jYwBAh3X69Glt375ddrtdu3btarEvKirKs/J7+PDhfkwIAOgoWOENoEs5e/asamtrddNNN3nda2pq0pNPPulVb2xs9PleAwcOVHBwsGel9let2O7ZsydbkgP4Wlwul5xOpy5duqRx48Z53TeZTD7/3Llz53zWR4wY0ar5AAAAIIbdAPAd9enTR1arVVarVRcvXtSuXbs8w+8LFy54+srKylRWVqa//OUv6t+/v5KTk2WxWDRmzBgD0wMA2hNWeAPo1F5++WWVlpZ6zte+8o/lnTt3KjAw0Ks/KSlJbrfbq95SPwC0BpfLpY8++khOp1OHDx/W8ePHJUkJCQl67bXXvPpra2u1aNEijRgxQnFxcRoxYoSGDx/O31MAAKDD6AwrvAEAbSc3N1d2u13bt2/XqVOnfPb06NFDEydOlMVi0bhx4/idGAC6MAbeADokt9ut6upq1dTUqKqqSpMmTfL5dP2PfvQjHT161Ku+evVqn6u8f/vb3+r//u//FB4e3uyrd+/ebfJzAIAkNTQ0aMqUKT7v5efn+zkNAABA22PgDQD4uvbv3y+73S6Hw6HKykqfPQEBARo7dqwsFotuu+029erVy88pAQBGYktzAB3Kiy++qIyMDJ05c6ZZ/cp2Rv9o4MCBzQbeN954o4YMGaLrrrvO5/s//vjjrRsYQJfW2NiogwcP6tChQ9q/f7+cTqcyMjLUvXv3Zn0hISEaMGCA5xf3qKgomUwmxcbGqqmpSQEBAUbEBwAAwDdUV1enfv36GR0DADqV+Ph4xcfHa+nSpSopKZHD4ZDD4VBxcbGnp6mpSdu3b9f27dslSaNGjZLFYpHFYlFoaKhR0QEAfsIKbwCGKykp8ZzFc+XaarXq7rvv9up94YUX9Pbbb3vVH3jgAf3kJz/xqu/Zs0cul0vR0dGKjIxsk/wA4MsTTzyh7Oxsr/of//hHn+dyOxwOBQcHKy4uTkFBQf6ICAAAYJjOtML74sWLeuONN5SVlaV/+qd/0tq1a42OBABdwmeffSa73S673a5PP/20xb4bb7xRFotFZrNZw4YN82NCAIC/sMIbQJu7cOGCzpw5owEDBnjdW7NmjZYtW+ZVr6io8PlegwcPliQFBQVp2LBhioqK0pAhQ3wOjyRp7Nix3yE5ALTss88+0+HDhxUREeHzF+YePXr4/HM1NTU+62azuVXzAQAAwD+6deumtWvXqqGhQZJUUFCgUaNGGZwKADq//v37a/78+Zo/f77Onj2r7du3y263a8+ePWpqavL0HT16VEePHtWrr76qiIgImc1mmc1mjRw50sD0AIDWxMAbQKtyuVzKyclRaWmpZ8V2XV2dbrnlFr388ste/b6G4JJaPI/HYrFo3LhxbEUEwO8qKyuVnZ2tQ4cOad++fZ4PNH/yk5/4HHjHxcXpww8/VExMjBITEzVmzBiNGjWK1dsAAACdUGpqqt544w1J0rp16xh4A4Cf9erVS7Nnz9bs2bPldruVm5sru92unTt36vz5856+qqoqrV69WqtXr1ZISIiSk5NlNps1ceJEA9MDAL4rtjQH8LU1NDSopqZGVVVVamho0Lx587x6qqqqlJqa6lUPCwtTZmamz/5FixYpKipKw4YN05AhQzzX/3jGLQAYyW6369FHH/WqJyYmasWKFV71K79Qt7TSGwAAoCvrTFuaS1J1dbXmzJnjeZ2dna2QkBADEwEArtizZ4/n3O+6ujqfPUFBQRo/frxn+B0cHOznlACA74KBN4CvtGDBAlVUVOjixYvN6vn5+T77r3xwcUVQUJAGDBigd999t80yAsC31dDQoMLCQhUVFenAgQP629/+ppUrV3r11dXVacaMGc1qQ4cO1fjx4/Xggw/6Ky4AAECn0NkG3pK0ePFiFRYWSpIeeugh3XXXXQYnAgD8I6fT6Rl+l5eXt9g3duxYz9bn/fr182NCAMC3wZbmQBfkdrtVXV2t6upqVVVVeVZtP/LIIz63Cne73V7DbunyOduDBg3yqj/11FMKDg5WeHi4wsPDeaodQLs1Z84cVVdXe9XdbrcCAwOb1fr166dZs2YpMjJSI0aMUFxcnFcPAAAAui6r1arCwkJFR0dr8ODBRscBAPhgMplkMpn0y1/+UhUVFcrJyZHdbtehQ4ea9e3Zs0d79uzRb3/7W8XFxclsNstisSgyMtKg5ACAL8MKb6ALWrp0qXbu3OlV/+Mf/6hx48Z51X/1q19px44dki6fuR0REaGwsDAtWrRIERERbZ4XAL6Lmpoa9e7d2+dwev78+SopKfGq/+lPf+LcRQAAgDbUGVd4u91uFRQUaPz48UZHAQB8Q3V1dXI4HLLb7dq7d2+LfYMHD/YMv00mkx8TAgC+DANvoBOoqKhQQUGBZ6V2bW2tKisrtXjxYp/nbC9fvtzn9uKPP/647rjjDq96ZWWlrr32Wp+rvwGgPWlsbJTT6Wz2derUKb344ou69dZbvfqfe+452Ww2RUVFeZ7yNplMuvHGGw1IDwAA0HV0xoE3AKBzcLlc2r59u+x2u3bv3i232+2zr2/fvkpOTpbFYvH5mQMAwH/Y0hzoAE6cOKHS0lIFBQX5XIG9a9cuLV++3Kve0jk0AwcOVN++fRUREaHw8HDPiu2WVjMOGDDgu/0AAOAnf/jDH/TXv/7Vq15YWOjzl8/77rtPjzzyiIKCgvwRDwAAAAAAtHPBwcGaOXOmZs6cqaamJuXl5cnhcGjHjh1qaGjw9NXX12vt2rVau3atgoODNWHCBFksFo0fP17dunUz8CcAgK6HgTfQDlVWVmrFihUqKyvT0aNHPfUJEyb4HHgPHDjQq3bddde1+P533nmn7rzzztYJCwB+cvr0aRUWFqqoqEj9+/f3uSNFQkJCs4H3ddddp5iYmBZ3qLjhhhvaLC8AAAAAAOjYAgIClJycrOTkZElSfn6+HA6HHA6HamtrPX0ul0ubN2/W5s2bJckz/L7tttvUp08fQ7IDQFfCluaAnxUXF6usrExlZWU6d+6cnnzySa+esrIynwPpgQMH6sMPP/SqXxmQR0VFaejQoYqKimJVNoBOobq6Wr/73e/kdDpVV1fnqZtMJq1atcqr/7PPPtNLL72kESNGyGQyKTY21p9xAQAA8DV1lS3NGxoaFBISYnQMAEAbKC4u9pz7XVpa2mJffHy8LBaLzGYzn9kCQBth4A34ydy5c3XixAmven5+vs/+K7/8S5e30Rk2bJhiY2P18MMPt1lGADDKiRMnNHjwYK/6mTNnNHXqVJ9/ZteuXQoICGjraAAAAGgDnX3gXVNTo7feekvr16/Xf//3f/vcrQ0A0HlUVlbKbrfLbrfrwIEDLfYNHTpUZrNZZrNZMTExfkwIAJ0bA2/gW/r0009VUlKimpoaVVVVqbq6WlVVVXrvvfd8bp07a9asZtvcXJGZmamwsDCv+rp16xQREaHo6Gj17du3TX4GADBCQ0OD9u/fL6fTKafTqaKiIl24cEE7d+5UYGCgV/+8efNUXl4uk8nU7IunogEAADquzj7wXr58ud59911Jktls1vPPP29wIgCAv9TX13tWfu/Zs6fFvtDQUJnNZlksFo0ePdqPCQGg82HgDXyJ8vJyhYSE+Nx+7Je//KXy8vK86itWrGi2OvuKpUuXqry8XBEREQoLC/P8NykpScHBwW2SHwDaowULFqi4uNir3tLfn5WVlQy3AQAAOpnOPvCuqKhQenq65/WmTZt4mB0AuiCXy6Vt27bJbrcrLy9PbrfbZ19ISIhuu+02WSwWTZw40c8pAaDju9boAEB7sX37dm3ZskXV1dWqrq5WfX29JOlf//VfNWfOHK/+iIgIn+9z8uRJnwObF154oXUDA0A7VFpaqsOHD8vpdGrSpEm65ZZbvHri4uK8Bt7XXXed5+/df8SwGwAAAB3NoEGDNGrUKBUUFEiSbDabFi9ebHAqAIC/BQcH6/bbb9ftt98ut9ut3bt3y263a/v27XK5XJ6+hoYGrV+/XuvXr1dQUJAmTJggs9nMYikA+JoYeKNLqK2tVVVVlWpqanTDDTf4HMCcOHFCmzZt8qqfPHnS53uOHj1aFy9eVEREhMLDw5t9AUBX8sknn+iNN96Q0+ls9staYGCgz79vTSaTPv30U5lMJo0YMUImk0k33XSTPyMDAAAAbS49Pd0z8P7rX//KwBsAurjAwEBZLBZZLBZJUl5enhwOhxwOR7NFAI2NjcrOzlZ2drYk6dZbb/X8uT59+hiSHQDaO7Y0R6e1b98+PfPMM6qqqmpWnzJlipYtW+bVb7fb9eijjzar9enTR2lpafrZz37WplkBoCOoqqryubvF9u3b9fDDD3vVR44cqT//+c/+iAYAAIAOprNvaX7F5MmT5Xa7lZqaqgcffFCBgYFGRwIAtEMHDhxQTk6OHA6HKisrW+y7+eabZbFYNHnyZBZeAcBVGHijQzlz5oxnpXZ1dbWqqqp07bXX6rHHHvPqPXr0qH70ox951YcOHar33nvPq/75559r27ZtzVZqBwQEtMnPAQAdQX5+vgoLC/Xpp5/qwIEDioiI0AcffODVd+rUKU2fPt3zesSIEYqPj9fo0aM5dwoAAAA+dZWBd35+vmJiYtiOFgDwtZWUlCgnJ0d2u13Hjh1rsW/o0KEym82yWCzsnAegy2PgjQ6jsbHR5+AkKChIO3bs8Kq73W4lJSVJkiIjIxUdHa3o6GgNHz7cUwcAXHbhwgXt27dP+/fvV0FBgfbv3++zb/v27erWrZtXfd26dbrpppsUFxfX1lEBAADQgZ09e1YbN27U//zP/0jq/ANvAAC+i+rqauXk5CgnJ0cHDhxosa9///669957ZbVa/ZgOANoPzvBGhxEUFKSQkBA1NDQ0qzc2Nqq+vl59+/ZtVg8MDNR7772noUOH+jMmAHRIjY2NysvL87kDxhXdunVTVVWVhg0b5nUvPT29LeMBAACgg8vNzdWGDRu0ZcuWZvWuug7jhRde0PDhwzVt2jSjowAA2rHw8HAtWLBACxYs0OnTp+VwOJSTk6O8vLxmfZ999lmzc8ABoKthhTc6lCVLlsjlcnlWaw8dOlRRUVEKDQ01OhoAdApnzpzR6tWr9cEHH6hnz55KSEjwfPEAEQAAAL6J2tpa2Ww2rV+/Xp9//rnPnhkzZug3v/mNn5MZ68SJE5o7d64kKTg4WFOmTNHtt9+ukSNHGpwMANBRuFwubd++Xa+88opqamokSX/4wx80fvx4g5MBgDEYeAMAgK+ttrZWjz32mJYsWcIvUQAAAPApOztbNpvNa/XZFZGRkbJarZo1a5ZCQkL8nM54v/vd77R69Wqv+qRJk/T//t//MyARAKCjMpvNcrlckiSHw6Hg4GCDEwGAMdjSHAAAfG1/+tOfVFRUpAcffFAmk0lLly5VQkKC0bEAAABgsPLycn344YfauHGj11Fk0uVjx6ZOnSqr1ar4+HgDErYfP/zhDxUUFCSbzdZs+9kxY8YYmAoA0NFUVlZ6ht2hoaEMuwF0aazwBgAAX4vL5dK0adP0xRdfNKuPHTtW//Iv/6Lw8HCDkgEAAMAIbrdbmzdvls1m08GDB332xMXFyWq1avr06erWrZufE7Z/W7du1Ycffqi9e/cqOzvb54r33bt3KzY2tkuuhgcAtGzr1q369a9/LUmyWCz67//+b4MTAYBxWOENAAC+luDgYP31r3/Vyy+/rM2bN3vqhYWFfHgJAADQhRw8eFAZGRnavHmzGhsbve736tVLM2bMUHp6uqKiogxI2HFMnTpVU6dO1alTp1ocaP/617+Wy+VSSkqK0tPTNWrUKD+nBAC0R0VFRZ7r4cOHG5gEAIzHwBsdwsqVK7Vnzx5J0v3336/Ro0cbnAgAuqaIiAj9x3/8h+655x699NJL2rZtm+644w5WmwAAAHRyZ8+e1caNG2Wz2VRWVuazZ+zYsUpNTdW0adP8nK7ju/76633WN2zY4NmudtOmTdq0aZOGDBmiH//4x7Jarf6MCABoZw4fPuy5jo2NNTAJABiPgTc6hPLychUUFEiSzpw5Y3AaAEBUVJSWL1+u4uJi9e3b12fPkSNH1Lt3b91www1+TgcAAIDWkpeXJ5vNpuzsbJ/3+/fvr9mzZ8tqtSo0NNTP6Tq/8PBwjR071rMIQJKOHz+uvXv3MvAGgC7u6uNETCaTgUkAwHgMvAEAwLcWExPT4r1nn31WR44c0Q9+8APdc8896tOnjx+TAQAA4Nv6/PPPlZGRoYyMDNXW1vrsmTRpklJTUzVhwgQ/p+taRo0apVGjRqmyslJr165VZmamGhoalJaW5rP/1KlTLa4WBwB0HhUVFWpqapJ0+eGo4OBggxMBgLEYeAMAgFaXl5enI0eOSJLef/99ZWRkaP78+frJT36iHj16GJwOAAAAvnz88cey2WzavXu3z/uRkZFKTU3V7NmzOdLGzwYMGKCHHnpIDz30kLKzszVmzBiffQ888IC++OILzZ07V7Nnz2YAAgCd1NXbmXN+NwAw8AYAAG0gMDBQMTExKi4uliS53W6tWrVKe/bs0VtvvWVwOgAAAFxRXl4um82mDRs2qKGhwet+YGCgpk6dqtTUVCUkJBiQEP9oypQpPuvFxcU6evSoJGn58uV66aWXNHXqVM2dO5etbgGgk7l64P1lu+8BQFfBwBsAALS6hIQEvf322/rkk0/0+uuva+/evZKkRYsWGZwMAAAAbrdbW7Zskc1m04EDB3z2xMXFyWq1avr06erWrZufE+Lb+Oyzz9SrVy+dPXtW0uX/z5mZmTp48KDWrFljcDoAQGsqKiryXLPCGwCkay5dunTJ6BDAVzl+/LhOnTolSYqOjlbv3r0NTgQA+CaKi4v10Ucf6eGHHzY6CgAAQJfldDpls9m0ZcsWXbx40et+r169NGPGDKWnpysqKsqAhGgNmzZt0tq1a7Vv3z5J0iOPPKIf/vCHBqcCALSmCRMmeM7wdjgcHGEBoMtj4A0AAAzV2Nion/70p5ozZ47S0tIUGBhodCQAAIBO4/z589qwYYMyMjJUUlLis+eWW26R1WrVtGnT/JwObamsrExr1qzR/fffr169enndv7Lqe9q0aerZs6e/4wEAvqXy8nLNmzdPkjRgwADZbDaDEwGA8Rh4AwAAQ61YsUKvvfaaJCkkJETz58/XD37wA/Xo0cPgZAAAAB3Xnj17lJGRoS1btvi8f8MNN2jOnDmyWq0KDQ31czq0B1OmTPGc256cnKyZM2dq8uTJBqcCAHyVrKwsPf3005KkqVOn6r/+678MTgQAxuMMbwAAYKhPPvnEc93Q0KAVK1Zo1apVevbZZzVp0iQDkwEAAHQsn3/+udavX6/169erurraZ4/FYpHVatWECRP8nA7ticPh8Ay7JWnbtm3atm2bQkJClJ2dbWAyAMBXOXz4sOea87sB4DIG3gAAwFArV67U9u3b9corr+jYsWOSJLfbzS9tAAAAX5PdbpfNZtOuXbt83o+MjFRqaqpmz56tkJAQP6dDezR27Fj9+7//u7KyspSXl+ep33bbbQamAgB8HUVFRZ7r2NhYA5MAQPvBluYAAKDd2Lp1q1asWKGRI0fqqaeeMjoOAABAu3Xy5EmtW7dOGzZs0JkzZ7zuBwYGasqUKbJarUpISDAgITqK06dPa+PGjdq0aZMee+wxxcfHe/UUFRXpe9/7nmJiYgxICAC42oQJE9TU1CTp8o4dwcHBBicCAOMx8EaH8PTTTysrK0uStGzZMk2ZMsXgRACAtnTu3Dn17NnTq+50OlVYWKgFCxYYkAoAAMBYbrdb2dnZstlsKiws9NkzfPhwWa1WpaSkqFu3bn5OiM5qyZIlys/PV1RUlGbOnKnbb79d/fr1MzoWAHQ5x48f1x133CFJGjRokNatW2dwIgBoH9jSHAAAtDu+ht2S9Oqrr2r37t165513tHjxYqWnp/s5GQAAgP8VFRXJZrNp8+bNunDhgtf9nj17aubMmUpPT1dUVJQBCdGZVVZWKj8/X5JUVlamF198US+++KJGjx6t3/3udzxYAQB+dPV25hwFBwB/x8AbAAB0CMXFxdq9e7ck6fPPP9d//ud/6s0339R9992nmTNnGpwOAACgdZ0/f14bN26UzWZTSUmJz55bbrlFqampmj59up/ToSv5/ve/rzvuuENZWVlyuVye+sWLFxl2A4CfHT582HPNMRMA8HcMvAEAQIcwePBgLV26VKtXr1ZdXZ2ky6tN/vjHP2ry5MkKCAgwOCEAAMB398knn3hWc/tyww03aPbs2bJarQoLC/NzOnRFYWFhevzxx/X4449r27Zt2rBhg+x2u9LS0nz2nz17Vr169fJzSgDoGq4eeLPCGwD+joE3AADoEIKCgrRgwQItWLBANptNb7zxhk6ePKmf//znDLsBAECHVl9fr4yMDK1fv15VVVU+eywWi1JTU5WUlOTndMDfJScnKzk5WRcuXND3vvc9nz0rV65UVlaW5syZo3nz5vFgBgC0ouLiYs81A28A+DsG3gAAoMOxWq2yWq3Kzs7WlClTfPacPn1affr08XMyAACAr8/hcMhms2nnzp0+7w8ePFipqamaM2eOQkJC/JwOaFn37t1bvLd+/Xq5XC698cYbeuONNzRu3DjNnTtXZrPZjwkBoPMpKSlRU1OTJCkyMlKBgYEGJwKA9uOaS5cuXTI6BAAAQGtqamqS1WpVaGioFi1apNtuu83oSAAAAJKkkydP6sMPP9SGDRt0+vRpr/uBgYGaMmWKrFarEhISDEgIfHsVFRVaunSpKioqvO5t2bKFB1IB4DvYsGGDnnnmGUnSjBkz9Jvf/MbgRADQfrDCGwAAdDoffPCB6urqVFdXp4cffljR0dFauHChZsyYYXQ0AADQBbndbmVnZysjI0P79u3z2TN8+HBZrVZNnz79S1fPAu3ZoEGDtG7dOuXn52vt2rXaunWrpMtb8jPsBoDvpqioyHPNduYA0BwDbwAA0On06NFDvXr10tmzZyVJpaWlevrpp3XgwAE9/vjjBqcDAABdxeHDh5WRkaFNmzbJ5XJ53e/Zs6dmzpyp9PR0RUVFGZAQaBuJiYlKTEzUo48+qvXr12vEiBE++9avX68tW7Zo3rx5bHkOAF/h6oF3bGysgUkAoP1hS3MAANApud1uvfvuu3rzzTd1/vx5SZdXfvNhMgAAaEsul0sfffSRbDabjh496rNnzJgxntXcQFe2aNEiHTx4UJLUr18/paWlKS0tTf369TM4GQC0P4mJiZ7rnTt3coY3AFyFgTcAAOjUXC6X3nrrLdXU1OjZZ581Og4AAOik8vPzZbPZlJOToy+++MLrfr9+/TRnzhxZrVaFhYUZkBBoX+rr65WSkuLzHg+qAkBzx44d0w9/+ENJUlRUlD744AODEwFA+8KW5gAAoFMLDg7Wz372sxbvl5WV6dlnn9XPf/5z3XLLLX5MBgAAOrr6+nplZmYqIyNDlZWVPnvMZrOsVquSkpL8nA5o3/r27avs7GzZbDatW7dO1dXVkqTQ0FCG3QDwDzi/GwC+HANvdAhPP/20srKyJEnLli3TlClTDE4EAOgsXnvtNTmdTv385z9XQkKCHn74YX55BAAAX2rbtm2y2WzasWOHz/uDBw9Wamqq5syZo5CQED+nAzqOkJAQLVy4UAsXLlRubq7Wrl2rkSNH+uw9duyYPv74Y6Wnp+uGG27wc1IAMNbhw4c91zExMQYmAYD2iYE3AADosk6dOqUtW7Z4XhcWFuruu+/W+PHj9eSTTyo0NNTAdAAAoD2prKyUzWbThg0bVF9f73U/MDBQU6ZMkdVqVUJCggEJgY5t/PjxGj9+fIv3MzMz9c477+i1115TcnKy5s6d+6X9ANCZXD3w5iF9APDGwBsAAHRZ119/vdasWaMVK1YoOzvbU9+3b5+6d+9uYDIAANBefPTRR7LZbCooKPB5PzY2VlarVSkpKfz7AWhDV3b+ky7vsrBt2zaFhobq+eefZ7UjgE7v0KFDnusbb7zRwCQA0D4x8AYAAF1aZGSkli1bppKSEr344ovauXOnfvzjH6tHjx5GRwMAAAYpKSnRmjVrtGnTJrlcLq/7PXv21IwZMzR37lzOGgb8wO12684779T69etVU1PjqdfW1ioiIsLAZADQ9o4cOeK5Hjp0qAIDAw1MAwDtEwNvAAAAXf6l8YUXXlBRUZHCw8N99hw6dEj9+/dX3759/ZwOAAC0NZfLpaysLNlstmYfLF9tzJgxSk1NVUpKip/TAV1bYGCg7r33Xt17773av3+/MjMzlZ2drYkTJ7b4oOrZs2fVq1cvPycFgNZ39XbmsbGxBiYBgPaLgTcAAMBVvuwsrCeeeEKnTp3SHXfcoUWLFikkJMSPyQAAQFv49NNPZbPZlJOTo6amJq/7/fr10+zZs5WWlqawsDADEgK4Wnx8vOLj4/XUU0/pzJkzPntycnL02GOPKSkpSSkpKTykAqBDKyoq8lxzfjcA+HbNpUuXLhkdAgAAoL1bs2aNJLZeKgAAIABJREFUli1b5nkdFBSkH/3oR7rrrrsUHBxsYDIAAPBNnT59WuvXr1dGRoZOnjzps8dsNstqtSopKcnP6QB8Vw8++KByc3M9r4OCgjR58mQtXLhQkZGRBiYDgG/urrvu8qzyXrVqlUwmk8GJAKD9YYU3AADA15CUlKS0tDR9+OGHkqTGxkatXLlS+/bt05/+9CeD0wEAgK9j+/btysjI0LZt23zeHzx4sObMmaPU1FR2cgE6sP/7v/9r9rqxsVEbNmzQHXfcYVAiAPj2rt7SnGE3APjGCm8AAIBvoKqqSq+88oo2bdokSfr973+vCRMmGJwKAAC0pLKyUhkZGcrMzFR9fb3X/cDAQE2ZMkWpqakaOXKkAQkBtIXTp08rKytLWVlZKi4u1qBBg7Ru3TqjYwHAN3L48GHdddddkqQbb7xR77zzjsGJAKB9YoU3AADANxAREaHnnntOixYt0saNG1scdjc0NLAyDAAAA2VlZSkjI0P5+fk+78fGxspqtSolJUXdu3f3czoAba1Pnz768Y9/rB//+Mc6fvy4zp4967OvoqJCv/rVr3T77bdr5syZCg0N9XNSAGjZ1au7Ob8bAFrGwBsAAOBbiI6O1oMPPujzXm1trdLT0zVjxgzdf//9uuGGG/ycDgCArqmkpETr1q1TVlaWzp8/73W/R48emjlzptLS0jR06FADEgIwwpAhQ1q8l5GRoRMnTujll1/Wyy+/rFGjRmnmzJmaOnUqD8MAMFxRUZHnOjY21sAkANC+MfBGh3D8+HGdOnVK0uUBQ+/evQ1OBABAy15//XV98cUXysjIUEZGhn7wgx/onnvuUZ8+fYyOBgBAp3PhwgVlZWXJZrOpuLjYZ09iYqJnNTcAXO3jjz9u9rqgoEAFBQX63//9X82dO9egVABw2dX/tmHgDQAt4wxvdAhPP/20srKyJEnLli3TlClTDE4EAEDLfvKTn+jQoUPNatddd51++9vfauLEiQalAgCgc9m3b59sNps+/vhjud1ur/v9+vXT7NmzlZaWprCwMAMSAugImpqatHXrVq1Zs0ZOp9NTz8nJUc+ePQ1MBgCXH9q7oqVjWgAArPAGAABodW+88YbsdrteeeUVlZWVSZK++OILnsYGAOA7On36tDIzM5WRkaGKigqfPWazWVarVUlJSX5OB6AjCggI0KxZszRr1iwdO3ZMa9as0cWLF30Ou5uamvT73/9eqampuummmwxIC6ArufpB+piYGAOTAED7x8AbAACgDVgsFlksFmVlZenVV1/VhAkT1LdvX6NjAQDQIe3cuVM2m00Oh8Pn/UGDBik1NVWzZ8/mCBEA39qwYcP061//usX7OTk5+uCDD/TBBx8oLi5O8+bN07Rp0xQQEODHlAC6isOHD3uueYAeAL4cA28AAIA2NGPGDM2YMUPnz5/3eX/fvn06cuSI5s+f7+dkAAC0bzU1Nfrwww+VmZmpuro6r/uBgYGaPHmyrFarRo4caUBCAF2NzWbzXB86dEiHDh3S8uXL9c///M+aNWuWgckAdEZXD7yHDx9uYBIAaP8YeAMAAPhBjx49fNZ///vfy+l06u2339Z9992nOXPm+DkZAADty6ZNm2Sz2Vo8pzImJkZWq1UzZsxQ9+7d/ZwOQFf26KOPas2aNfroo4908eJFSZLL5WInJwBtoqioyHPNCm8A+HLXXLp06ZLRIYCvsnLlSu3Zs0eSdP/992v06NEGJwIA4LsrKCjQfffd16w2aNAgLVmyRNOmTTMoFQAA/ldWVqa1a9cqKytL586d87rfo0cPzZgxQ+np6Ro6dKgBCQHg7xobG7Vx40atW7dOZ8+e1caNG3322e12jRs3ToGBgX5OCKAzSExM9Fy39CAgAOAyBt4AAAAGuXDhgv7617/q3Xff1alTpzz1sLAwZWZmGpgMAIC2d+HCBW3atEkZGRnNVjBdLTExUVarVSkpKX5OBwBfT11dnfr16+dVLykp0fz589WtWzfNnj1bd9xxhyIjIw1ICKAjcjqdWrhwoaTL25m/+eabBicCgPaNLc0BAAAM0r17dy1cuFALFy7UmjVr9Oabb6q6uloPPPCA0dEAAGgzhYWFstlsys7Oltvt9rrft29fzZ49W+np6QoLCzMgIQB8fb6G3ZL04YcfSpIuXryo999/X++//74SEhK0ePFi3Xrrrf6MCKADuvphQM7vBoCvxsAbAACgHZg3b57mzZun7OxsTZkyxWfPmTNn1Lt3bz8nAwDgu2toaFBmZqZsNptOnDjhs8dsNis1NVUTJ070czoAaH0jRoxQQUGBjh075qkVFhaqpKSEgTeAr3T48GHPNed3A8BXY0tzAACADqCxsVFz5sxRZGSkFi1apPHjxxsdCQCAr7Rz505lZGTIbrf7vD9o0CDNmTNHc+bMUZ8+ffycDgDantPp1Nq1a7VlyxY1NTUpOztbISEhRscC0M7Nnz9fJSUlkqR33nlHN954o8GJAKB9Y+ANAADQAfz5z3/Wq6++6nl94403auHChZo2bZqBqQAA8FZbWyubzab169fr888/97ofEBCgKVOmKDU1VaNGjTIgIQD43/nz51VYWNjiLhY/+tGPlJiYqJSUFLYvBro4t9utpKQkz+v8/HwD0wBAx8CW5ugQjh8/rlOnTkmSoqOj2c4VANDl9O7dWz169ND58+clSUePHtWTTz6poqIiLV261OB0AABIW7Zskc1m0969e33ej4mJkdVq1YwZM9S9e3c/pwMAY/Xo0aPFYffOnTt19OhRHT16VO+8844iIyM1c+ZMzZw5U6GhoX5OCsBoR48e9VybTCYDkwBAx8HAGx3CX/7yF2VlZUmSli1b1uLZpgAAdFbz5s3TzJkztXr1aq1evVoul0uSNHfu3Db7nomJiZKkwMBA7dy5s82+DwCg4yorK9O6deuUlZWls2fPet3v0aOHZsyYofT0dA0dOtSAhADQ/v3jv7XLy8v18ssvq7y8XM8++6xBqQAYpaioyHPN+d0A8PUw8AYAAOggunXrpnvvvVfz58/XqlWrdPbsWQ0cOLDNvt+lS5d0zTXXyO12a/78+Xrvvffa7HsBADqOixcvavPmzbLZbDp06JDPnsTERFmtVqWkpPg5HQB0PE888YRmzZqljz76SFu2bFFDQ4MkKS0tzdBciYmJbKUMGODw4cOea444AICvh4E3AABAB9OjRw898MADLd4vLi7WsmXLtHTpUiUkJHyr75GYmKhrrrnGM/QuKSnR//zP/+jhhx/+trEBAB3c/v37ZbPZtHXrVrndbq/7ffv21ezZs5Wenq6wsDADEgJAx2UymWQymfTYY49px44d2r17t0aOHOmz95VXXlFUVJTMZrMCAgLaNFdiYqKuu+46vfrqqxoxYkSbfi8Al1098GaFNwB8PQy8AQAAOpk///nPcjqdWrx4sW699Vb98pe/VExMzLd6r2uuucZz/c477yg5OVmjR49uragAgHauoaFBGzZskM1mU3l5uc+e5ORkWa3WFs+mBQB8MxMnTmzx79SamhqtXLlSktS9e3dNmjRJt99+u+c4otaSmJjoefj1iy++0AMPPKDXX39dQ4YMadXvA6A5t9utsrIyz2uOhAGAr4eBNwAAQCdSW1urbdu2eV7n5eUpLy9PSUlJeuqpp9S3b9+vfI9//LDsygddkvTUU0/pvffeU69evVo3OACgXcnNzZXNZlNOTo7P+wMHDlRqaqrmzJmjPn36+DkdAHRdGRkZnusLFy4oMzNTmZmZmjBhgn7/+9+36ve6+uFXl8uln/3sZ1q1apVCQ0Nb9fsA+Lvi4mLP9c0332xgEgDoWBh4o0OIjIzUqFGjJEm9e/c2OA0AAO1XaGioPvjgA7388styOByeemFhobp16/a13uPSpUuS/v4B19Vbm9fV1enRRx/Vn/70p9YPDwAwVG1trWw2mzIzM/XZZ5953Q8ICNDkyZNltVo9v58BAPxr/vz56tWrlzZu3NhsMJaUlNSq3+fqh16vXNfX1+sXv/iFVq5cqZCQkFb9fgAu4/xuAPh2rrl05RNNAAAAdCrFxcV68cUXlZeXp1/84hdatGjRV/6Zq7cu/EdX1xcsWKClS5e2emYAgP9t3bpVGRkZysvL83k/JiZGVqtVM2bMUPfu3f2cDgDQkhMnTmjjxo36+OOPtWrVKvXo0cOrJy8vT/8fe/cZ2FTZtwH8atOZ7r1baFllI2ULMgqITGWDKAjKdm9QHwXX416AiAio8LBk7yHK3qvsbrpnutJ0vx/6Nh3nJE3atGnS6/eF5D4j/5Tk5Nz3/x6tW7eGi4uLxuetbXr0tm3bYs2aNbC2ttY6ZiJS77333sOBAwcAAB9++CFGjhyp54iIiAwDE95ERERERu7y5csIDg4WHeF948YN+Pr6KqejrVifWyzhXdOKFSvQs2dP3QZLRESNIjo6Gn/99Rf2798PmUwm2G5ra4sRI0Zg/PjxXDuSiMiAhYaGQiaTITQ0FOPHj0ePHj1qPUZVJ9iqZT169MDKlSsbJGai5mzChAmIjo4GAGzZsgWBgYF6joiIyDAw4U1ERETUjI0YMQI5OTmYPHky1q9fr9Wxbm5u2Lx5M+zt7RsoOiIi0iW5XI7Dhw9j586dCAsLE90nJCQEY8eOxYgRIxo5OiIi0rWjR4/i7bffrlbm5+eHKVOmYPLkyaLHqJvxqabQ0FB89tlnOomViACFQqFcnsDS0hKnT5/Wc0RERIaDa3gTERERNVN//vknUlNTAUCrZHfV9bw/+ugjfPnllw0VIhER6cCNGzewa9cuHD58GPn5+YLtrq6uGDVqFMaNGwdfX189REhERA3B3d0dffv2xZkzZ5RlDx8+xPnz51UmvAHNZnsCyhPqn3/+Od566616x0pEwO3bt5WPg4OD9RgJEZHhYcKbiIiIqJkaNGgQIiIisHv3bq2OMzExUSa9T5w4gW3btmHChAkNFCUREdVFXl4e9u3bhy1btiinxazp0UcfxVNPPYUBAwY0cnRERNQYOnfujO+//x6JiYnYvn07du/ejYyMDIwbN050//T0dI1Gd1dMGGpiYoKtW7fCxcUFc+bM0Xn8RM0NE95ERHXHKc3JIBw/fhwPHjwAAAwdOpRrlxAREelQdHQ0JkyYoPHUhWLWrl2Lzp076zgyIiLS1tWrV7Fz504cPXoUBQUFgu1+fn4YO3YsxowZA2dnZz1ESERE+nT06FGEhoaKbgsJCdH4PFWT3gCwdOlSlYl0ItLM0qVLcfDgQQDAsmXLuMQMEZEWOMKbDMLff/+NAwcOAACCgoKY8CYiItKh+ia7AeDNN9/Eli1buJ43EZEeyGQy7N69G7t27UJMTIxgu6WlJYYMGYKxY8eie/fueoiQiIiaClXJ7orfD03rBRWzPlVYvnw5nJyc8Nhjj+kmUKJmiCO8iYjqjglvIiIiomauPhP+VDSIpaWlcT1vIqJGdurUKezZswfHjh0T3e7v749p06bh8ccfh62tbSNHR0REhmT8+PFad4KtutQRUD469ffff0eLFi0aKkwio6VQKBAbGwugvLMiv0dERNphwpuIiIioGQsJCanXyO6a63nv3LmTUxkSETWgpKQk7Nq1C7t370ZycrJgu1QqxbBhwzB27Fh06tRJDxESEZGhqku9oGp9ID8/H6+++irWr18POzu7BoiQyHiFhYUpH3fo0EGPkRARGSYmvImIiIiasfpOZV7Tl19+iR49esDHx0dn5yQiovI1V3fu3Ilz586Jbu/cuTPGjRuHYcOGwcrKqpGjIyKi5qxq0js2NhaLFi3C6tWrYWlpqe/QiAzGnTt3lI/bt2+vx0iIiAwTE95EREREzVR9R3dXqNrApVAo8Nprr2HdunVMuBAR1dPDhw+xfft27N27FzKZTLDdyckJI0eOxPjx4+Hn56eHCImIyBiEhITU+xxV6xW3bt3C66+/jh9++KHe5yVqLrh+NxFR/TDhTQZh0KBB8PX1BQAEBgbqORoiIiLjoMvR3VXPEx4ejmXLluHjjz/WybmJiJoThUKBI0eOYOfOnbh+/broPv369cPYsWMxePDgRo6OiIhIvYo6xtmzZ7F06VIsX75c3yERGYSqI7yZ8CYi0p5JWVlZmb6DICIiIqLGFRISovPpzIHqSfT33nsPY8eO1en5iYiM1Z07d7Bz504cPHgQeXl5gu0+Pj4YM2YMxo4dC1dXVz1ESERExqgh6gVVzzdx4kS89dZbOjs3kTHKzc3FwIEDAQCWlpY4ffq0niMiIjI8THiTXuliyiR1Ll261KDnJyLjFHErB4kxcuTnlECeV4xCRSn4a0nG5sqVKw3+GqampujatWuDvw4RkSErLCxEeHg4FAqF6HYnJye4uLjA3t6+kSOj5sjc0gRSGwmsbMzg6mWJ1p0cYGFlqu+wiFQqVJTi/o0spCcVQJFXDHleCYoKWHnTRmPUC7y9veHp6dngr0NkqLKzsxEeHg4AsLW1RZs2bfQcEREZKlNTwEoqgbWtGWzsJWjZ1g4e/tb6DqtRMOFNelUz4a3q41ixNmjNxzW3V/0XYMKbiDSXGq/AlX/TcP9GDooL+dNIRERERAQALYJt0KWvMwLb2+k7FCKl8LAc3Dybgei7whkxiIiIiKiSrYMZgkMcEPKYK6xsJPoOp8Ew4U161RAjvCsS3nZ2dvj77791fn4iMi65siKc3JeMu1ey9R0KEREREVGT5RMoxaBxnnDzsdJ3KNSMJT/Mx4mdSUiIztd3KEREREQGxdzSFD2HuOCRAa4wM9ftEodNARPepFczZ85EWFhYg5x78eLFePbZZxvk3ERkHO5ekeHw5kSUFFf/KZTamaFlsB0cXCxgbWNm1D3fiIiIiIgqFChKocgtQrasGHHhuchILhDs0zPUBf1GeOghOmruTu1PxsVj6YJyF09L+LayhZ2DGaxszWHJafiJiIiomSotBfJziyHPLUZGkgLR93JRXFhabR8HF3OMfc4fLp6WeoqyYTDhTXp16dIlzJs3T+fndXFxwe7du2FpaVxfWCLSnRM7k3D1ZEa1sqCO9ujSzxXOHrx2EBERERHlZRch7HwGbp6tft/cItgGI5/24/re1CgK8kux/4+HgunLO/dzQYeeTrCxM9dTZERERERNX2x4Li4cToYsrVBZZm5hgsen+aJVJ+NZtogJb9K7BQsW4MKFC9XW3q6v119/HVOmTNHJuYjI+BzaFIfblyqnMHd0tcDg8T5w9uD0jERERERENeVlF+Gf3YlIiKxMOHr4WmHaK4F6jIqai43fRCI5TqF87htkg/5jvGFjZ6bHqIiIiIgMy72rmThzILnabKejZvqhtZEkvdkVl/TuhRdeAACdJbsdHR0xbtw4nZyLiIzPlX/SqyW7vVpKMW5OIJPdREREREQq2Nib44mn/dG+h6OyLDlOgb3rH+oxKmoO9qyLrZbs7tDTCY9P92eym4iIiEhLbbs5YezslpDaVi7feeDPOKTGK9QcZTiY8Ca969q1Kzp16lSvc1SdqODpp5+GlRUTV0QkFHU3F//sTlY+929ji5EzAmBmoZsON0RERERExqzvCC90G+CqfP7gRg7OH03VY0RkzM4eTkH4zVzl80cGuqLP4556jIiIiIjIsDl7WGLs84GQ/n/nwZKiMuxYE4O87GI9R1Z/THhTkzB//nzl4/rMsu/i4sKpzIlIpYN/xikfO7lZYPAEXz1GQ0RERERkeLoPdEOL4MppD88cSEVmaqGaI4i0l5laiHOH0pTPA9rZ4pEBbnqMiIiIiMg42NiZ4fFpfpCYlQ8Cy8suwT+7k/QcVf0x4U1NQs+ePdGzZ886HVt17e85c+ZwdDcRibp+JgMKeany+bApfjAz48huIiIiIiJtDRrnA0vryqkQLx5PU7M3kfYuHKucOcDaRoLBT7KzMhEREZGuOHtYoceQys6E965mIzujSI8R1R8T3tRkzJ07F4D2a3lX7O/k5ITRo0frPC4iMg43z2YqH3fo5QQ7Jws9RkNEREREZLgk5iboNbSygezWBRmKi+o+WxtRVcVFZbh9MUv5vNdwD0jM2VmZiIiISJc69nKBnZO58vmNcxl6jKb+mPCmJqNLly7o1q2bVsdUnf58+vTpHN1NRKLk2cVITSgAAJhbmqLHIHc9R0REREREZNjadHWCs4el8nnU3Vw1exNpLvJOjvKxq5clWnV00GM0RERERMarzwhP5eOImzlq9mz6mPCmJmX27Nla7V8xutvV1RVTp05tiJCIyAjcu145OqBVJ3uYWfDnj4iIiIiovjr0cFI+jriZpWZPIs1F3MxWPu7Qy0WPkRAREREZN/9WtpDalC9VlJFSaNDTmrPFn5qU3r17IyQkRKN9q47ufu6552BpaalmbyJqzpJi85WPvQJs9BgJEREREZHx8PCXKh8nxuSr2ZNIc1Xrbx6+1nqMhIiIiMj4ebSovKePj87TYyT1w4Q3NTkLFixQPq6a1K6p6trdkyZNavC4iMhw5ciKlY8dXdk5hoiIiIhIF6reW+dmF6vZk0hzuVmVnyV7Zws9RkJERERk/JzdK+/p87IM956eCW9qcjp37ozu3bsDqExqqzN9+vSGDomIDFyOrHIqFqv/n6KFiIiIiIjqz0pafn9dXFiGooJSPUdDhq5QUYriovLBD9a2ZnqOhoiIiMj4SW0q77lymfAm0q1Zs2ap3V4x8tvR0RGTJ09ujJCIyIDl5VT+UEvZaEJEREREpDNS28oOpTkG3EBGTUNuVmVn5aqfLSIiIiJqGFZ2le3lOVlcw5tIp3r37q0c5V1TWVmZcuT3Cy+8AGtrrudEROqVFKleHoGIiIiIiOpOYl7ZtFRSxBHeVD8lxZV1N1NJ7bP+EREREVH9mJkZx/08E97UZC1evFjtdkdHR67dTURERERERERERERERNSMMeFNTVbHjh3Ro0cPQXnF6O5nnnmmsUMiIiIiIiIiIiIiIiIioiaECW9q0qqu5V2xbjcA2NvbY+LEifoIiYiIiIiIiIiIiIiIiIiaCCa8qUnr2bMnunXrBqByZDcAzJ07l2t3ExERERERERERERERETVzZvoOoLmRpRUiR1aEgoJSFBWUoKigFEUFZSgsLAHKaj++ORrZ/0UUZ+xWPpdKpfB3HISzh1L0GFXTZWIKWFhKYG5pCgsLU5hbSWBlZQpHVwtI7fiVJyIiIiIiIiIiIiIiIuPB7FcDyc8tRmxEHpJj85GRXIDM1ELI0or0HZaBkqBziyerlZw7nKanWAybuaUJnFwt4ehmDhdPS/gG2sA3yEbfYRERERERERERERERERHVCRPeOlJUWIaYe7mIfZCL+Ig8pCUV6jskIoGigjKkxCuQEq8AkAOgvOOAb5AUfq2l8G9lC++WUr3GSERERERERERERERERKQpJrzrQSEvRURYFu7fyEb0nTyNjpGYm8JKag5TM1NIJKYwNTOBqcQUEjMup066UVZWhpLiUpSWlKG0uBQlJWUoLiyBIld1J4y4CDniIuQ4izRYSSVo08UerTrbIaCNbSNGTkRERERERERERERERKQdJrzr4GF4Hi4eT0PMPdVJbhNTE1jbWsDG0RJWtpawsrGAla05E9ukVwX5JSiUFyI/pxD5uQWQyxQoyC+uto9CXoIbZzNx42wmzC1N0b67A3oOcYWto7meoiYiIiIiIiIiIiIiIiISx4S3FiJv5+D84VQkPVSIbrdzsYaDmw2kDlaQ2ls0cnREtbO0lsDS2hp2LtbKstKSUuTJCpAnUyAzORcFeZVrzRcVlOL6mUxcP5OJTr0d0SvUDXZOTHwTERERERERERERERFR08CEtwYykgtxdFsC4iPlgm12LtZw9LSFo7sNR2+TQTKVmMLOpTwJ7hnkhAJ5MTKTciBLyoWiSvL75jkZbp6ToftAZ/QZ7gFzCxM9Rk1ERERERERERERERETEhLdaRQWlOH0gBVdPZgi2ufjawSPQGRaWEj1ERtRwLKVm8Ax0gmegE/IyC5AYkY7czMpZDS6fyMCdS1noP9oD7UMc9RgpERERERERERERERERNXdMeKsQdj4TJ/emQCEvqVbu4mMHzyAnmFvyT0fGz8bJEq1CvJGXWYCE8HTkycoT3/LcEhzalICr/2Zg2BQfuHlb6jlSIiIiIiIiIiIiIiIiao6Yta1BkVeCXWtjkRCdX63czskavh3cYWnNEd3U/Ng4WaJ1D2/kpOcj9nYqihTFAICUeAX++CoCvYe7os8wdz1HSURERERERERERERERM0NE95VJETJsfu3h8jPqxzVbW5lBt92rnBwk+oxMqKmwc7FGh36+yMxPAMpMVkoKy0DAJw7lIaHD+QYNcMXUnteVoiIiIiIiIiIiIiIiKhxmOo7gKbizMEUbP4xulqy272FA4L7+jHZTVSDVytntOvrDzsna2VZfKQc67+IQOyDPD1GRkRERERERERERERERM0JE94Adq2NxfkjacrnFlYStOvrB+/WLjCVmOgxMqKmy9JagqAQL/gFuynLFPISbF8VgztXZHqMjIiIiIiIiIiIiIiIiJqLZj33cHFRGXauicHDcLmyzM7FGi27eMBUwr4ARJpw8bWDtb0lIq8mobiwfG3vg38moFBRii59nfUcHRERERERERERERERERmzZpvVLSosw9YV0dWS3V5BTgh6xIvJbiItSe0tENzPF7ZOVsqy49uTcP5oqh6jIiIiIiIiIiIiIiIiImPXLDO7Bfml2PJjFJJi85VlLbt6wiPQSY9RERk2iZkpWoV4w8nTVll25kAqTuxK0mNUREREREREREREREREZMyaXcK7uLAMW3+KREq8QlkW2M0LDm5SPUZFZDwCOrnD2bsy6X313wyc2pesx4iIiIiIiIiIiIiIiIjIWDW7hPeONTFITSwEAJiYmiDoEW/Yu1rrOSoi4+LfwR0uvnbK5xfrWVyHAAAgAElEQVSPp+P66Qw9RkRERERERERERERERETGqFklvHeuiUFcROWa3UGPeMHOxUrNEURUV37BbtWS3sf/SsKdyzI9RkRERERERERERERERETGptkkvA/9Lx5Rd/KUz1t09oCtE5PdRA3JL9gNDm42yucHNyYg6m6uHiMiIiIiIiIiIiIiIiIiY9IsEt7XTmXg9sUs5XPfdq5w9LBRcwQR6UrLrtU7l+xd9xCytEI9RkRERERERERERERERETGwugT3qkJBfh7R5LyuUdLR7j62esxIqLmJ7CbF6xsLQAAxUVl2PVrLEqKyvQcFRERERERERERERERERk6o054FxWUYdevMcrn9q5SeLVy1mNERM2TqcQEQY94QWJefsnJSCnE8R2Jeo6KiIiIiIiIiIiIiIiIDJ1RJ7z3/fEQObJiAICZhQQtOrvrOSKi5svcUoIWnTyVz8POy3DvepaaI4iIiIiIiIiIiIiIiIjUM9qE9+3LMkTdzlU+D+zqBVOJ0b5dIoNg52IF9xYOyudHNidAnl2sx4iIiIiIiIiIiIiIiIjIkBllBrggvxT/VFm326eNC6QOFnqMiIgqeLd2gY2DJYDyZQdO7ObU5kRERERERERERERERFQ3RpnwPrU/GYr8UgCAtZ0F3AIcajmCiBpTQGcP5eN7V3PwMDxPj9EQERERERERERERERGRoTK6hHfyw3zcOJOpfO7fwUPN3kSkDxZWZtWmNj+8OV6P0RAREREREREREREREZGhMrqE9797kpWPnb1tYW1nrsdoiEgVz0BnmFlIAADZGcW4fjpDzxERERERERERERERERGRoTGqhHditBxxEXIAgKmZKXzauuo5IiJSxVRiAp92ld/Rc0dS9RgNERERERERERERERERGSKjSnifPVyZMPNs4QiJmVG9PSKj4+RhA0ub8lkY5DkluHk+s5YjiIiIiIiIiIiIiIiIiCoZTUY4JU6BmHt5AMpHjrr62+s5IiLShGeQs/Lx+cMc5U1ERERERERERERERESaM5qE99nDKcrHLr72MJUYzVsjMmpOHjawsCpfyztHVow7l2V6joiIiIiIiIiIiIiIiIgMhZm+A9CFXFkRIm/lKp+7t3DUYzRkrI7/8ztkWZUdKySmZnhi+DyYm1vqMSrj4NHSGQ/vlI/uvnYyA8Hd+R0mIqKmQS6XIzo6Ag/C7yH2YQzs7RwQENACAf4t4ePjBwsLC32HSERNVF5eHn5duwKlpaXKMl9ff0wYP1WPURERERGRKjt2bkFMTJTyuampKWbNmgc7Wzs9RkX6dOKfo7h27XK1sgkTpsHXx09PERGRKkaR8L57NUv52NHdBuYWEj1GQ8bqwqU9SM9MqFYWOuhZJrx1wMnbFnH30lBWWoakhwrkyopg62iu77CImqTsnGwcO3YQl69cQGlpKZ4cNwk9QnrrOyyjEhZ2HXv37URWtgwtAgIxfdos2Nra6jsso2Eof1+FQoFVP3+HXbu3qd1v7+4TsLGxaaSoqKmLT4jD/v27EB5xHw4Ojnhmxhw2hDRj2TlZ2LFzS7WyNq3bMeFNRERUD4ZSnyDDdPzvwwgLu16tbNzYiUx4N2MXL57D/gO7qpX17tWP9TyiJsg4Et5XKhPeTt788SEyNKamJnBwt4EsqXymhluXZOgV6qbnqIiapk8/+wDnzp1SPj979iS+//YXdOrUVY9RGY/bd8Kw+KU5yufnzp1CePg9fPHfH/UYlfEwlL9vXFwsPvjwLURGhqvdL6R7Lya7SUmhUOCFudMhl8uVZRcvnsW6tVvg4MDZa4iIiIjqy1DqE0RERNT4DH6h66z0QqQmFAAATCUmcHCT6jkiIqoLlyqdVW5d4DreRGLiE+KqJbsrHDt+SA/RGKd9+3YKyi5dPo+UlGQ9RGN8DOHvm52TjbnzZ9Sa7AaAxx8f3QgRUWOKjY1GXl5enY49efJ4tWQ3AMhkmbh85YIuQiMiI5CRkY7k5CR9h0FEZLAMoT5BtePvIREZqtLSUtx/cBclJSX6DoVEGPwI71sXKxNjjh4cYUNkqOxcrCExM0VJcSmy0ouQmlAAN29OF09UVaqKSryTk0sjR2K8EhLiRMsVivxGjsQ4GcLfd/Pm3wVJSwAICGiJHiF9YGFhgciocCQmxqNf38f0ECHpWm5uLv49eQx79+3EnTthePvNDzB8+Citz5OYlCha7uTkXN8QiciAFRcX49KlczhwcA/+PXkcw4eNwttvfaDvsIiIDJIh1CdIHH8PiciQJScn4cjRA9i9ZxtSU1Pwx+874OPtq++wqAaDT3hH3c5VPnZw53otRIbM3k2KzMTy73Tk7Wy4eXNac6KqWga2Ei13cnJq5EiMV5cuj+Da9cvVyhwdneDNm1idaOp/3+TkJGzctE5QPmXyM5j93HyYmRn8rTPVcPDQHnz+3490cq4OHTqJljvYczpzoubq/oO7eOvtFyGTZeo7FCIio9DU6xMkjr+HRGTIvvr6E+zdt0PfYZAGDHpK86KCMqTEK5TP7Zyt9RgNEdVX1e9wQpRwdB1Rc+dg74BPP/4GUmnl8h1PjBiLJ0aM1WNUxmXK5GfQr1/lqF1HRycs+/ALJjp1pKn/fXfv2S4oG9B/MOa+sLjJxEi69fBhrM7O1f2Rnpj57NxqZa+8/DYCVXRWIiLjl5mZwcZ9IiIdaur1CRLH30MiMmTh4ff0HQJpyKDvBhJiKtfXs7K1gKnERI/REFF92VZJeMcz4U0kqnfvR7FrxzEkJSfC3t4B9nb2+g7JqFhZWWH5R18iMzMD8nw5PNw92XiiQ0397xsTGyUoe/75RXqIhAzVs8/MwcQJ05CWlgJ3d09YWVnpOyQiIiIio9HU6xNERESkPwZ9RxAfWZkQs3NmYxKRobOwMoO5lRmKFMUoKijjOt5EKpiZmcHXx0/fYRg1JydnrrvbgJrq3zcmpnrC29HRid810ppUKoW/fwt9h0HU5JSUlEAikeg7DCIiMgJNtT5B1JTxXox0gZ8jasoMekrzaglvFxs9RkJEumLrVNl5JSEqT82eREREulNSUoK4uOrTW/v5BegpGiIi4yKTZWLq9DH4Zc1PKCsr03c4RERERM0K78VIF7Zs/RNTp48RtJ0QNRUGPcI7LaFy/W4rOws9RtK85ORk4N6DCwiPuIgMWRKys1NhYWENT49AuLsFwM01AK4uvvDyDIKpae19KmJibyEpObL8iYkJQrqNUPYSKikpQXTMDYTd/hcpaTHIykpBaWkJPNxbwturNdzdWqBdm16wtJSqeYXa38/N2/8gIvIKZFkpyMpOhZ2tE9zdAuDq4oeWAV3QKuiROp+ftCO1t0JmYi4AILXKd5youUpKSsTlK+dVbrexscXAx0JFt6WkJOPipbPK57169oOrq5vyeXR0JP759zju3b+N9LRU5ObmwMfHD0FBbdAioCW6dg2Bh4en6LljY6Nx5uzJamUSiQQTxk+FiYnmS4zcvhOGGzeuVitr0SIQvXv1U3tcTEwUzl84g1u3biA1LQVZskyYW1jA2ckF7h6e6NrlEXR/pBfc3NxrjeHfk8eRk5OtcnuXLt21GuVbVlaGmJgoXL12CbfvhEGWmYGMzHTk5GTDxdkVnp7e6Ny5G7o/0rNOo0BjY6Nx4eJZXL9+BWlpKcjOzoKDoxNatghCQEBL+Pn6wz+gJXy8fbU+d0Oo69+3qKgIR48dQGlpKQCgdet2aNO6nXJ7enoaTp0+gWvXLiM5JQlZskw4u7giKLA1WrYMQnBwx2r7i7ly9SISE+MBAHl5wk5W6Wmp2Ld/Z7UyRwenausGqpOfn4+rVy/iwsWzSEiIQ0pqMooKC2Fv7wAnZxe0CmqDkO690L59J42nYrx0+TySkxOVz01MTDB40HDl1Nlx8Q9x8OAeREaFIyEhDkWFhXBwdIKPjx9CHumJ4cNHASj/7kVFhQMArKysMWTwcOU55XI5Tp36G2fPnUJCQhwyZRlwcnSGs4srAlu2Qu9e/RAc3FEQs0KhwKXL53D27Ck8jItBeloq7O0dEBjYGi1aBKJjh84IDu6o0fusKi4uFpFR4YiKikR0dATCI+6jtKQEVtbWaBEQiPbBHdG2bXu0atVWoynE4xPicO3aJQDAjZtXBdvPnT+N4pJi0WMHPjYUNjaVHW1v376JqOgIla/l79cCnTp1rTWmCunpabh46SyuXL2E1JRkpKWnorSkBM4urnB1cUNwcEeEdO+Fli2DNLrWNsb3SB9u3wnDxYvnEJ/wEImJ8chIT4Oziyv8/VrAx8cP3bqFoF3b9ir/RmlpqTh/4XS1spp/G3XCw+/j3v3b1cp6hPSBu7uHxu8hIyMdYbeu4969O7h9+yZSUpJgb+8AF1c3tGkdjN69+6FVUBuN6lM15efn48GDu4iOiUR0dCQehN9DcnIiLC2t4OTkjPbBndCuXXu0aRMMby8frc9fIStLhmvXLyM6Ogrh4fcQHVNep/P29oWvrz8CWwZh0MBhMDMzw3sfvIHU1BRs3LQO+flyLFr4mkbvraSkBPfu3cb5C2dw/8FdpKQkQZGfDw8PL7QMbAV/vwD4+QUgKLA1HBwcNYr71KkTyMqWAQCcnVzQp09/5TaFQoFz50/h3LnTSE5OREpKEqysrREU1AZBga0RGNgK3R/pqTZ2hUKB438fQllZGW7fDhNsfxB+V/DbUqFL50fg6+uv0fsgoqarZj3ssQGhsLW1BQAUFxfj6rVLOHHiKGIfRiMjPQ1W1tZwdnKBt7cvevbog27dekAqrd7OVVpaitu3b+Lfk38jOjoCiUkJkEgkCApsjYCAQLRu1Qa9evWr9dpaXFyMo8cOoKSkRFnm4uJWa/2rQkZGOs6eq14PDAxsjeB2HVQeI5fL8feJw4iKikRCYhwePoyBRCKBr68//HwDEBjYCr169VO5XJeu62tA+b3AteuXcf36FaSkJkOWmYFMWQbs7Ozh4eGFdm07IKR7T7RpE9wkp0zPzc1F2K3ruHr1EuITHiIjIx1ZskyYSiTw9PBCixZB6N69J7p0fgTW1ta1nxDl/7cPwu8hJiYKkZHhiIoKR25uDswtLODh4YUO7TujbdtgtGvbXqPf3Ib+PdR1HaEh6LLdQkxj3Is1lPpeFwDgzJl/kSnLUD6XSCQIHTJCo+9scXExjh07WK3ep01dHyi/Lt+9ewv37t/Bnbu3cOdOGCQSCdxc3eHu7onu3XsiJKR3nZcibKzP+J07Ybj/4C6ioiJw/8FdpKWlwMXZFb5+AfDx9kPv3v3Qrm17nDt3CitXfQsAmDt/Br7/dg2Cglpr9BqZmRm4ePEsLl25gKSkBKSnpcLK2hqBLVvBz68F/P0D4Ovjj8DAVhp9LhuyvbNCWNh15bJ3sQ+jBdsPH94nWv+r2b5CjcukzEC79BQqSvHTkrvK512HBuoxmuYhN1eGEyc34p/TGzXav2VAF4wf8wY8PNQ35m/d8RkuXN6rfD5z+ufoENwPSclR2LjlP0hMVt2ICAAuTt54esoy+Pq01SiuCgUFchw+9iv+PbO51n2D2/bFnXtnBOX/eWcvbGw0a1ghzWSn5SPyanlDvl9rKSbM45SgVH/fvFbZKD3n/WA9RqK9/Qd24Ysvl6vd5+9jF0XLjxzZj08++0D5fNLEpzF/3kvIzsnGN998ihP/HK319ZcuWS56o3b+whm8/c5LgvLvv/1Fq+TOq6/Nx9X/TzxVmDB+GhYueEV0/8jIcKxc9S0uXVbdCaCqJ0aMxcxnX1BbgXxy/DDIZJkqt7+4+A08OW5Sra9VVlaG06f/wZq1KwRTY6vSpnU7zJgxG4/2G1jrvjExUfjl159w+vQ/Gp17zOjxmD17gd7Xea/r3zcxKQHTpo9VPg8MbIVff9mE4uJibN7yB9b8+lOtrz1t6kzMmjlXZYVX7PNXGzc3d2z53z61+xQVFWH37m1Yu24V5HK52n0rzrlg/isY0H9wrZW7xS/NQVjY9Wpl63/bCnd3T/zw45fYf2CXymMnT5qBeXNfBAB88eXyavtWfHfPXziDzz7/j9r/M6D8/+O1V95F+/adAJQ3Nnz86Xu1vt8nx03CnNkLBY24NZWWluLCxbPYsuUPjf+PpFIpXnn5HQwZPFxtMnj3nu345tvPNDpnTSt+WletQfeTzz7AkSP7Ve7/aL+BWPbRF7WeNytLhvUbfsGOnVs0iqNTp66YP+9ltY3LQON8jxrT/Qd38du6n3Hu3Kla93Vzc8eIx8dgaOgIQYPp8b8PY9nyJdXK1P321LTq5++xecvv1cqWvLsMoUMer1ZW8+8PAN5ePhg6dCTWb1hd6+u0ad0O8+e9jK5du2sUV3p6Gvbs/Qtbt/2p0bUHAAb0H4zFi16v1kCkiWPHD+Hrbz6p9XWkUik8Pb0RGRlerXzUyCfx2qvvqj32/IUzWP3LD4JjVVm44FWMGzux1s/qpCkjkZqaony+fetBODu7aHwd6937Ubz1xvtwdHQS3R4VFYHn5kzRKOaa5s97GZMmTq/Tsfq069copMaXd1Z++tVAuPlwyTmqu9R4Bf74ujxp4+ZjhbGzW+o5Iu3VrIfNmb0Q06fNRGxsND797APcvXdbzdHl186XX3wLoaEjYGJigpiYKHy0/N1ar4ddu3TH668vVdvxNTU1BZOmjKxWFhDQEuvWanYPcvbsSby79NVqZaqu6QUFBdi1exvWb1it0e9Sv36PYdDAoXhswJBq13Jd1deA8nuJdetX42yNztuqODo6YeqUZzF2zARYWup/yb20tFRs3vIHtm3XrG0WAJ58cjKmT50JFxdX0e0REQ+wddtGHDq8V3S7mGdmzMHUKc+qTbI1xO9hQ9YRKqiqb2nTWb0h2i1qaox7sYagq+sCAEx/ehwS/r8De4Wdfx3RqENGdk42xo4bUq1MVV2/Zt0ZAKZOeRZXr16s9XoOANOnzcKUyc8oOz6p0xif8Qrp6Wn48aevNGob7Nixi+B7IZVK8eP3a9GyZZDK47KyZNj0vw2CupMqnTp1xWuvvIuAAPW//Q3Z3lnhw4/e0eg8YlS10zZl8VF5OPB7+cj9lsE2GDfHMGc8NNgpzbMyipSPrWzM9RhJ8xATewtf/TBD42Q3AETFXMeXPzyNw8fWorBQ85G6J89sVr5ebcluAEjPTMB3K2fj0pWDGr9GcnI0vvjuaY2S3QBEk93UMCylld/nrPQiNXsSkba2bP0DCYnxmD//GY1v2pZ/vFQ0MRTSvZfoqLBDh9UnAquKT4gTvYEfPepJ0f337d+J2c9P1bjSCJR3GJg0ZaTWSU1tZWXJ8Opr8/HeB29onOwGyhtc3nv/Dbzy6jwUF4uPKAXK38fM5yZpnOwGypN6U6eNxrHjh4xiyrLIyHBcu3YZH3/ynkZJOgDYuGkdXnz5eWSrGRGia5mZGVi0+Dn8uOJrjRNOqakp+PCjd7Bs+RIUFBRo/Zq5ebl4461FapPdADBKxXcLAH5b9zMOHtqDt995qdZkN1D+/7Fw8XM4e/YkfvjpKyx57zWN3u+OnVsw87mJSE9PU7lPfn4+Fi6ahXfefVmr765cLsfHn7yHt999WeO/fVNw+04Ypj09VuNkNwDcvHkNCxbOxJatf2r1WobyPRITEfEAc+fN0CjZDZR/rzb8vgZHjh5o4Mi0k5AYr1GyGyj/jXjltXlYsfJb5Sh9VY4cPYAJk0Zg/YZftPr8/3vyOJ6dNQEnT/2t0f6ZmRl4Z8krWP7xUo1eRy6XiyZoPD29VR5TVFSEb779DG+/85LGyW4A+GnF15g7fwbu3L2l8TEAsG//LuzYuUXj69i5c6cwa/Zk3H9wt9Z9iYgAYOOm33D12iXMX/isRskRuVyOTz77AL+uXYnDh/dh5nOTNLoeXrt+GU/PeLLB6z6aKC4uxvKPl2Llqm81/l06ffofLP94aZ3uhzWJ56cV32DuvBkaJ7uB8mmgV676FjOefQpx8Q91Hpc2jhzZj4mTn9Aq2Q0AO3ZsxoRJI0Trkt//8AXmvDBNq2Q3AGz4fQ1mz5miVd23vgyljtDQ7RaNcS/WUJradaE+Nv1vvUbXcwD4c+NvmPHsU7VexxvzM37k6AE8M3O8xm2DNZPdAODs7AoLNR2B7twJw8znJmmc7AbK67kzn5uEdet/gUKheT5Jl+2dZNgMN+GdXqh8XDVBRrp35+5Z/Lh6LnLzam/8FHPk77VY+/sbtTbSVIiIuoIfV8/V+nV27v0acnntDXGJSZH44ecXkJWdUuu+1PgspZW99bIzmPAm0jWxHrC12b1nu+BmWyKR4KknJwv23bd/p+Y32EeESYiePfuK9pzevn0TvvzqYw0jFqrLSF5NxcXFYsHCmbh2/XKdz5GSklRtWsGqflv3c62j/FWRy+VY/vFSbPj91zrH1pS88to8rXvY3rkThh07NE8k1kdGRjpefPn5OidBTvxzFO+9/7rG90wVvvvuc9EKaFV9+vRXO9Xj1WuX8Pl/P9LqdQHg3aWv4q+//qfVMampKVj72yqV2yUSCZKqTNuurQsXzmDL1j/qfHxjunnzGhYumlXnxreVq77FnxvXaXVMU/8eicnKkuGdJS/X6diQ7r10HE3j27rtT3z23w/Vdl5SKPLrfH65XI7PPv8PsrJkavcrLS3Fp599oHGnAzFSqRRffvETpk+bKbq9oKAA7y55Bbv3bK/T+SMjw7Fg4UxcvnJB42PW/rYS3/9Q+0wMVclkmfjxp6+0DY+Imim5XI5XX5uv9e/9nxt/w6ef/0fr1/v6m09RVKTf9pQ/N67DqdMntD6uW9eQasvH6EJ+fj6WvPea1oniqlJTU1CipoNyQ/tt3c/VRjPWRU6usM20tt9+dRIS4/HVN580WudqQ6gjNHS7RWPcizWkpnRdaGwyWSYWvzRbbZK8sT7jN25cxSefvl+vDiDDh4/C6lV/qJxR5Ny5U1iwaJZGnenFrN+wGu+8+7JWbSO6au8kw6b/eenqKDujMuFtwYR3g0lMisTaP94Q3WZpIUXroBB4uAdCIpEgIzMBMbFhSE0X9niMiLqKcxd3oW8v1SOL1OnTYxxcXHyhUOQhMSkct+4Ke2MWFMpx5vxfCB2k+gc7Ly8Lq397CQWF4hd0WxsntPDvBG+v1pDLs/Ag4hKSU4VrNFDDsrA2Q2F+eUUiJ7MIdk78jlPz5ezsWm0qH133oH6030C0b98JJSUliImNwpkz/4je9G7YsAbduoZUKwsd+gR+XPG1YN/Tp09g6NAn1L5ucXExdu3eKigXS6LHxT8UfR0A8PX1R4+Q3mjTph3kcjnuP7iL8+dPi95Uf/3Np/jt182CabDateugXMdZ279vbm4u3lnyisqbakdHJ3To0BmtW5WvCxsdHYH79+8I9l+yZLnoFHlHjuzHht/XiJ7b28sHHTp2gZenN0xMTBEVFY4bN6+Kvvd1639Gv74D0KpVG63eny7U5+9bm+DgjujVsx+sra0RH/8Qly6dE/2/2LL1dzz11GTY2dpVK2/RMggZmekAALk8r9oUtxVqTqXl56t6Wqdf165EXFys6LY+ffqjY4cucHN1Q3RMFO7cCROtWF28dA5/nzii1ZpPNRPsPUJ6o0OHLigqKsThI/uQmpqi8TSPFQIDW2FA/yGwtrZGQkIcjhzdr/H07MOGjoS9vQOSkhJw/vxp0f+T/Qd2YcyY8WjbRrjMhIWFBZ6bNQ9ff/OpYJtUKkVgYGs4OjghITFOZS/59Rt+wfDho+AlMnKhdet2yr+HWHzt2rZXuda4h3v1db58ffyVn5GsLJlWFfqioiJ8pqIR29HRCT169EH74I4wNzdHRMQDXLl6UfQ7tObXnzBo0NA6r8Vc3+9RYzh1+oTo9xMon/Y7JKQ3ysrKcPfurWrfK6lUWqd14xtLYGAr9OndH2VlZYiMCsfdu7dUfoaOHNmP3r36YfCgYaLbhw0dibW/rRI93tfXH35+ASgqLER4xH3RfeRyOdZv+AUvLhav+wHlI8QuXjonum38U1PRulUbFJcU4+HDWJUjOfr2GYDuj/RU+Rrf//CFyhFR7dqWrzvu4uKG/Hw5IiLuq4zn8/9+iHVrt9a6fIIYNzd3hA4ZAWdnFyQnJ+HuvVuinYpu3ryGa9cuC6acd3ZxxZNPTgbKyhAVFSHoEOfo6IRBA4eKvnb7Jvx5JSLdkUqlGDtmIlycXZCWnoZTp0+ovIes6clxk+Dl5YPMzAzcDLsmen2Ki4vF7t3bMH78VF2HrpHi4mLs3CXeUU4qlaJvnwHw82uBuPhY3Aq7Xu2+o3//QYJj6luf+PqbT3DhguqZG7t26Y527TrAzs4esbHReBB+V3CPuWD+K7VOsdtQ9u7bobJOCJTfCwUHd4SXlw+SkxPxIPye4HPRp09/DB82SnDs9GmzcPzvwyrP6+7uCVlWJiIjH4jWBW7evIZ//j2GgY+FCrbp+vewoesI9dXQ7RZA49yLNRRdXxeaktAhjyMgIBCJifEID7+nsgN8RSfTNas3iv7/NsZnPDsnG8s/WSq6rV3b9hg0aBjs7e3/f431Iyo71s94ejasra1Ft0VFReCdJeJLRUmlUjzSrSdatgyCRGKGxKR43Lp1Q/Q38Nr1y9iz9y+MHTNB9Fy1qU97J1A+nb6TkzMAiM7GNvCxUOX2qqytta9/kO4YbMI7L6eyV525pcG+jSatqKgA6/98W3Rbv17jMTz0eVhbV197oqysDBcu78O2ncLpIHbs+QrtWveBs7OnYJsq/ftMwrAhs2FlVb0XV2T0dfy+aalg1PmJkxvRv+9kWFqKX3D/2v2lypHqz0z9BJ06DBCU37z1LzZsavw1TZozcwuJMuEtzylmwpuatd69+qF3r34Ayq+xg0N1UzHp1KkrlryzDB4e1a/JKSnJWPbxEsFN7bXrlxEWdh0dO3ZRljnYO2DM6PGCUVj7D+yuNeF99dolQeXO28sHPUJ6C/9lqj4AACAASURBVPZd9fN3oud48snJWDDvZUFFITsnG8uWvStoMI+Li8Whw3sx8olx1co//fgb5eONm9bjlzU/qo29qq++/lhl49Rbb76Px4ePFt0WGxuNrds2Yu++HZg1c55ohT46OlJlL/4XF7+BMaPHQyKRVCtXKBT4de1K0dELX3y5DD/9+Fujr8Nbn7+vKo6OTlj24RfVPo9A+ftf9fN32LV7W7VyuVyOPXv+wrSpz1Yrf3HR68rHYmvttmndDj+v0mz6rfsP7opOKe7o6ITPP/sebVq3E2w78c9RfPjRO4Lyn1d/j/6PDoKFhYVGr131tT795Fu0a9teWfbMjDm4dOmcVo0ab7/5AYYOfaLaeuJzZi/Eml9/Evxtq3p+ziJMnDAN5uaVv9uK5xdj7W+rsHWbcOrtPXv+QtvXlgjKAWD4sFHVkncLF7yKoaEjBOuxZWXJ8P0PX4g21K1duxJL3l0mKA9u10G59vUv1lJs3FR9hPS4sRMxfLiwQVDMMzNm45kZswGUT/O2+KU5Gh0HlPcmF0ssd+zYBcs/+lLwXktKSvDr2pXY9L/1gmN+W/czlryj3Qh9XX2PGsP9+8JGI0dHJ3z3zWrBrCDJyUlY9fN3OPHPUTw2ILRJrD1eU7euIVi44FUEBbUWbFO3HuMPP36JXj37iY5wsbS0rNZA1qlTVyxc8CoCW7aq9p0EgJOn/sZnn/9H8Bo7dm7B6FFPia7Dl5SUKNqI6+3lgw8++ExwjRsaOgLvf/CG4DN+9NhBzJw5V3Q0yMFDe0Svo25u7njzjfdFR+snJyfhq68/FjT+VswksWjhq4Jj1HnrzfcROmSE4HOzZ+9foo2PGzetEyS8HewdlL8v5y+cETTw9+rZT23HAiIybpMnzcAzM+ZU65Az+7n5OHR4r9qRoQMfC8XLL70luD84eGiP6Cw9m7f+obeE9/37d0QTedOmzsSsmXOrXWNLS0tx7NhBrFj1LWSyTPTs2VdwXH3qE7v3bMfRY+JLII5/aipeeH6R6D13VpYM+/bvwi9rfkS3riEY/1Td1qKur/Dw+/jq609Et3Xt0h1LlywXXZu7sLAQ/548jtW//IC8vFy88dpS0bV9AwNbYfCgYcp76TGjx2PKlGfg4e5ZrS5QXFyMTf/bgLW/rRScY8XKb9C3zwDB37Ehfg8bso5QXw3dbtEY92INSdfXhaZg0YJXMWrUU4LBC+npafj2u89FR7PHxERh166tKq/PDf0ZX7t2pWhHYrH/hzGjx+O3dT8L6ssAsHHjOrzxujBxXlBQgKXvvSb62k+Om4TnZs0XrGVeVlaGAwd3i85s+O13n6NXz37w9PQSPacYXbR3AuUdGUKHPA6gfMazmqPz58xZ2OjfI6qdwU5pXlRYOZ2BRGKwb6NJu3hlP9IzEwTlM6d/jnGjXxEkuwHAxMQEvUJG4a2XN8PSQtib5eDRnzV+/VGPL8KYkS8Kkt0AENiiCyY9JUxCFxTKkZYeJ3q+u/fO4cYt4dp0bi5+eP3FP0WT3QDQqcMAzHlWvIceNQwTSdWbau2mdSWi2g0eNAxffP6j4OYPANzdPbD8oy9Fj3sQfk9QNnLkOEHZteuXEZ8gfi2usH+/sEF74sTp1SrVQHliXGytsTmzF+LFRa+LJjLs7ezx6SffivYyX/PrCuTn133a16ru3L0lOi2wt5cP1qzeqDLZDQD+/i3w2qvv4tdfNqlMHq3f8IugTCqV4o/fd+DJcZMEyW4AsLKywsIFr2DZR8KpWe8/uIuDh/aoe0sGISCgJVat2CCojADl7//ll96qlvCtcOdOWIPFVFZWJjq1rbeXD1at2CCa7AbKGy5X/CSsPKampmDP3r+0isHR0QmrVmwQvHcLCwv07TtA8N1SZcVP6zB8+CjB/ra2tli86HWV00O//NJbmDb1WUFizcrKCgvmv4yuXboLjomJVT1Cx8LCAgvmvYzBg4bhfxv3YML4qYJKPgA4ODjivaUfi45YOXP2X5Xn17esLJlog2G/fo/hi89/FH2vEokELzy/CIurdNSocPToAa2m0m+K3yN17t+/Iyh7ctxk0SUwPDw88cH7n+Lrr1bqrXFaHUdHJ/z38x9Ek90AMGTwcGxYtx29ez8q2CaTZYo2OFUYPmwUunbpjrff/ADffbMabdsEC76TAND/0UFY+ZOw4wQA3Lh5VbT8popysQZWAAgKao0lS8SX4xBb0kShUODn1T8Iyjt16or1v21Tee3x8PDE5599j4kTpgu2bf9rE6KjI0WPq0kqleKbr1bh8eGjRe8tRo96CtOmCmcSUzXKiohIzIuL38C8uS8KZp8wMzPDyCfGYdbMeaLHDR40DEuXLBe9P3h8+GjR41JTU7Ra/1SXMjMzRMtrJlMAwNTUFEOHPoHf1/+Ft958X6fJg/z8fPy8+nvRbR+8/ykWLXxVZQdTBwdHTJv6LDZv2osP3v9U43tpXftV5H4RKB9d+cV/fxRNdgPl99KhQx7H2jWbsfrnP0VHIVY9V9cu3fHDd2vwystvw8vTW/B+zczMMOPp5/DWm+8Ljk9NTdF4hoL6aqp1hMZot2joe7GG1lSuC7ry+mtLMH78VNGZ+lxcXLHsoy/w3lLxTkw/rvga6elpotsa+jMutq1fv8fw/JyFgv8HMzMzPD9nIfr06S84Zv+BXaK/MQcP7RHt1P3xsq/w4uI3BMluoDyf9MSIsfjj9x2iszP9unaFyvdTky7bO8kwGWymuLiocn0QE2F7L9VTUVEhjhxfKygfPGAGOgT3q/V4V1cfjB6xWFD+IEKzNRFGj1iMxx5V30DVplVPONi7C8qzslJF9z9xSnytnhdmfQcPd9XTkwJA29Y94eKk++luSJxEUtnrtLCwcdYCImouHu03EEveXSZ6U17BwcFR9KY5OTlJUNamdTvRhMmxY4dUnl8myxRNFIcOGSEoE0si+vr6Y+qUZ1SeHyi/MZ89e4Hoa+/bv1PtsZraqGLd3Pff/1RlIqOmwMBWopXfyMhw0b/Re0s/0aiy92i/gQgNFf49w8JuaBRXU+Xo6IQfvv9VtPJS1bixEwVlCYnqO2HUx5kz/+LmzWuC8tmzF9Qaa3C7DqLft7W/rURBQYHGMSyY93Ktr1XrOea/ohz5LEYikWDwYOF0yoGBrTBm9Hi15372mecFZZGRD9QeM3ToE3hv6ccava+Zz74gKJPL5cjJzan1WH34c+M60RG8ixe+DisrK7XHjhk9Hm5uwnvgdetXa/TaTfV7pI6ZSNL24UP1yw516xqi8bW4Mbm7edQ66tzFxRVL3lkGR0cnwbaNm9apXEbDwsIC33y9CsOHjxIdxVWVv38L0aUOxH7rgfJOXjWNfGKcyg49QPl0pGKzJcTHCxvFDx3eKxj1I5VKsfTd5SqnS6xgYmKC52bNE53W/56adRKr+vqrVYKR2jWNGDFGtDw7R7gmKhFRTX369K91iZnBg8Snd1686HXRzq4VxJaFAoDkeqwFWx+WKu5l4uOFSyBWsLW1VdthuC4OHNwter+1cMGroklGMe7uHqLJpsZw/8Fd0bWa+/Tpj+dmzdNoFhtbW9ta648tWgTim69XidbrawodMkJ0aveUFPH7h4bQFOsIjdFu0dD3Yg2tqVwXdMXFWbyzSVWDBw3D/Hkvi25Tt0xBQ33G09JSRUd3L1ygfkakBfPFpyev+b0vLCwUrZNOmzoTffuKDzSsysfbV/S1VC13VJOu2zvJMBlswruosET5WKKnXnbGLCY2TDD1t62NE4YNma3xOXp0HylISOfmZUIur71BwM3Fv9Z9JBIJOrUXXixl2cmCssTECEREXRGUhw6cBUdHYYMh6ZdJle90SRET3kS65OcXoFHv9D59hCPLVDWYiDXc7N33F0pLxWdoEJtyacL4aYKenhkZ6aLrEk2fNlOj9+Dr4yc6Qk7Txm91cnNzRaenGvhYqOiaxNo6eUp47sGDhimnt9eEWMUnKkp8nSdD4e7modH6wSEiU+MnJQlnrdGVKyJrcbu5uWNA/8EaHT92rHBNKrlcrnEjZWBgKwzWYs1vVfx8a7//ElvD3MPDq9bkWmuRhhhdNjZ5enqhU6eugvKUJlpxPXvupKBs+PBRGjVqmJmZYcL4aYLy6zWmiVSlqX6P1AkKFCaujx47qDLxawxsbW1VNj7paqS92HqIqhodr98Q1qW6dROudVdT1y6PCMrERoEdOy7sKDdv7ktwd/eo9TWA8pkJxDrWxMSq7xhRwVuDzmS+Pn7wFblOpqlYX56IqKoWAYG17qPqWiTWAaoqW1tb0ZlZEvX0OxngL77W9Z69O1BW1nhtPEeO7BeUOTo6YdTIJxsthvr499/jouVznhMmSBuLmZkZBg0UdoBN1NM9Ym0ao47QWO0WDX0v1tCaynWhsT05bpLo/eMlHc0SpM1n/IHIjGDeXj61rmnv6+Mn+juUXCPhfev2DUEHVkdHJ8yaOVft+asa8fgYQedumSxTow6mDdHeSYbHYDPFRVVGfZqaGezbaLIiooTTpLRv1w8SieZr4JmamsLfV9jon5qmux9VGxvhxTYrS9jgEC6S7La0kGJAP/FesKRfplU6LhcVlajekYgajJOjcMozVYmOR/sNFEw7lJqaIlohAyBY8xsAxo4Rjg5NEJkWXSqVilawVXlCZDSWLip3Ybeui5ZrcyOvzvkLpwVl2iS7gfKKS83/l/sP7qK4uLhesRkCsVEYcrkcubm5DfJ6D0USKpMnPq3x2sHB7TqIjpTQNJn32IBQtaN+dEnsdTSpVNrY2IhOT6bQcomBsrIypKenISzsOo4cPYBN/9uAI0cPIDIyHB7uwmSxvhK06hQXF4teh1SNzhIzVGQGB11/xhv7e6SOqpG3z78wTbTzkbEYMni4aALj4cMYrc6jUCgQExOFc+dOYcfOLdi+fRMuXT4PczPhyPk4FSN+MjLSBWXubrUno93Fvpc1GpRyc3NFZ8kQ63ShTlBQG0FZRC0zSWjLzVXYWTolVdjhmoioLuozbbZYslyeLxzd3BhcXd1EEzzb/9qE9z94s1FmxsjJzRGstwoALzy/qNbZdJqKyyKjGocOfQKBga0a5fWzc7Jx/8Fd/HvyOLZs/RN79v6F27dvws5O2HEyMVG/99z6rCM0VrtFQ96LNYamcF3QB3NzcywUGbWckBiv1bITuviMy7KEa6hr0ukTgOj/XWqNe+Br14QdsPv2GaBxuwhQ/jsY3K6joDxOy/qPOtq0d5Lh0fzT1sRUvQc04k5AeiM2GvrC5b1Iz9Duyy92npTUWAT4Cy9cdWFnK7xA5ecLRwpFRArj6NJpsOg65NQEVBkkxu83kX6I9d7Mzs4S3dfCwgITJzyN9RuqT1106NA+dOtavcfxnbu3EBNTfd3e3r0fFb15Fqs4BgW1UTs9UU0eHl6CsthapsHVxF2R6cS8vXxE15PVVkFBgejovXXrV+PAQe3W4Babwi8pORG+Pn51js8QmJmZQSqVCt6/XJ4numZUfYmt9xSo5VTKfr4Bgu+GppUuf3/1S7M0FW5uHoL3qKmwsOvY8PsardfLTUsXX+pGn2r2hK+gycivCqrWYUxOToStrW6m8W7s75E6A/oPRnBwR8G1US6X473330CfPv0xeeLT6CIygsWQmZiYoGPHroIGe02+R3l5edixcwt279kmOnWhKqquO87OLoIRG2KNZjWJ3TvU7EzxIFx8/fkvvlhW6/mryhdJ7Iit/14fYmul5uU1ficQIqKanDWYXrexmJiY4MXFb+DNt4RLHZ46fQJht65j0sSnMXLkONjb2TdIDKqu/90f6dUgr6drCoVCNGHfq2ffBn3dpKRE/PHnWvx94rBoXVKVmomvxtIU6giN1W7RkPdijaEpXBf0pZ2KZcPi4x/WugSTLj/jDvbC//fUNM3qCTU/ewBgV+P/6arIzHf7D+zSerYRsfPEPoxG+/adtDqPKtq0d5LhMdiEt7lFZca7tER8ylSqu+xs8R9+sQS2tkpLdTdiVyp10Gi/pOQIQZmri3E39huy0iqDDy0sGmfEGhFVV/PGtTZPjBgjTHgf3otFC1+rlhg5dGiv4FhVoxrjRSqOnrVMtVST2LpKcrkcWVmyelXyMjMzBGW+frpJOqq60U5IjNfJ9L2lJc1j5oz6JFe1kZ+fL1r5ExsFqI7Ymszx8Zqtl6xpr2xDdP/BXfy27mfR9Qs1oWppBX0Sq/A7OjrBwsJCq/P4+voLRn4kJsbrdN3qxvoe1cbU1BRvv/kBXnrlBdHv29mzJ3H27Em0a9sezz7zvOi0kIbK11dYZwmPuK9yf4VCgX37dmDtulVaNVRXUHWMl5ePYLrOqKhI9H9UOC16VbGxwtEYrVu1rfZc7DcVEG/s0lZhYUG9z1GVg4P6aYWJiKhcj5DemDB+GrZt3yjYJpNlYvUvP2D1Lz9g8qQZmDJ5Rq3TtmtL7H4BEO+41BRlZclEy729fBrk9dLT07Dpfxuw/a9NdTq+se+5m1IdobHaLRryXqyx6Pu6oC+Ojk6iHYkfxsWorLs1xGfcVaTNISYmCgqFQu3MFwUFBaIzlNWcpj49TTyfpIt7+hIdtmNp295JhsVg5wK3sKxMgjHhrXvpmQ03jYOjo2brsGnCxESzj3BunvBGkQnvpqu0uPI7bW6pfk1QImoY2k6n5+7ugYGPhQrKT53+W/k4Pz8fu3Zvq7bd19cf3R/pKXrOWJFpomtbW6gmVUnt+q4xJjadmI+ORk03dM9SNw2mPTMGjTXFt6reyq5aJrxdXNwEZfEJ4mvp1mRlaRjTMmpr2/ZNmDtvRp0r+U2V2BrJXnVovPQUGQmi6/UTG+t7pAl//xZY8dM60RlBKty9dxvvLHkFb7y5CBERup3KWl/Eflvi4mJFl6dIT0/D83On48cVX9cp2a2Ov59wBpPNWzaoneJeoVBgx87NgvIWLYKqPVfVqK8LAVrMnKCJ+kw3TETU3Cxc8Aqen7NI7T6bt/yO6TPGYeu2jSgsLNTZa4vVqXx9/ZvUvY06OSqmdxabnrq+Ll46hwmTRtQ52d3YmlodobHaLRryXqwx6fO6oE+BgcLEdkKCeFtCQ33GxWYSAIAdO7eoPe7Awd2i5TU73utigIYqurz28X7euBnsCG8zi8okWGkJ5zzWJV32mBHj7Ch+cW0oJSXFKCgUNvjY24lPBUn6V7UXmoUFf4SIDMXYMRNw4p+j1cr27d+Fx4ePBgDRdVYnjJ+q8mbTzFy4tqi2lR1VawUVaLFWkhix6UudnVzqdc4KcnmeTs4jxtvLB9bW1g12/uZI1WdMmynsgPK1vWrK13HCypAcPLQHP634v/buO7DJav/j+Ke7TTedtNCWshFliAgigspSAQc4wAEiOK57X69e9xYVJ+69FwIOUFTQCyoqAjJFymopbelu05n290d/FMrzpE1HmqZ9v/6hOUmefEuTPOc533O+5wm7948eNUYJCUmKje2s6upq7diRolWrVjj1IrulmL1nbCbJywaPY/aeaeSe6O6mc2ycXnrhHX340dt6862X7T7u9z9+1exLp+vuux7WqBNObsUIW569CS2HnzsLCgt0y7+vNl19IUm9evZR3779FR/fVWGhYcrOydbWrZsM5217TjpxnN7/4M06bVarVa+9Pl9XXXmj6bn8w4/eMV1hd8Rh5QiLi5133nPVCiYAQI3p02boqCMH6rnnnzAt0S3VnE+en/+kVq36UffdO7dFtk4xO7c0tgKTK5lt0yHZ39amqf5Ys9q0xPQBxwwZpm7deiguLl4B/gHam56mP9as1oYN61o0Dke1xWuE1hq3cGZfrLW56nvBlQL8jeMwZmMAznyPh4aE6vgRow1jc++8+6pGHj/adGLx/v1ZptddAwccXed96+x8UmMnkaDjctuENyXNncfebMcZ0x9S/34jWzma5rO3Cry42Hy2JFzPVmeFt3vMvgUgDRgw2FBid8OGdUpN3a0uXRL01VcL6zzeYrFozMmn2D2eJcBiaGtsJ7rAzsx4s1JOjREYaLzYys0zL8naWH52Skkt+PSbdlPSqz3xN7lwlWpWlTSmbL5Z1YCmrPptDzZt+kuPPHqv6X1Tp0zX9GkzTAf7wsLC9cqrzzk7vGYze89U2hqf8M402Qs8NqblV/20NQEBAZo541JNnjRFny/8WJ9+9r7d1cx33/Nvt096Z+fsN7QlJ/cwDGo+9PBdhjKXkpSY2E2XX3qNaZn3qqoqhxPePXr0Uv/+AwwD3As+/0iZWRm6+sqbFPP/77/8/Dy99voLWrT4U8NxThh5kgYOPLpOm8ViPN8nJnbTG6/Vv9oEAOAe+vcfoOefe0O/rl6ld9973W6ydO26P3TzLVfqqXkvN3qrl8OZnVsc3au2LbB3TZiXl6tOnVpmonVBYYHuf+AO0/uGDx+p2bP+peTkHob7jh48VNdcN6dFYmiMtnqN0FrjFs7si7mCK74XXMmsElf8YSukW+M9fsYZZxsS3larVRfOmKK77nxIxw0/Qb6+vqqsrNT6v/7Uffffbjpp4oorrqtz214+6b57H9PxI0Y7FBvQEtw24R0YfDD08rLGDxChfqEh0covqNsRzNq/S5L7Jbw9PT0VE5WkjKy6JWZy89JdFBEaUll+MOEdGEzCG3AXHh4eOnvqdD057+E67cu+W6IxY07R2nV/1Gk/7dQzFRgYaPd4ZvsSZ2eb7wlkz/4s80GNmGaWQzJLZNpbVdfoY4eYJ0n37k0l4d0G2dsHMDc3p1EJ74wMY7+kpcrku5sFCz82bX/i8fkaNHBIK0fT8sz2XtzXhFLkZs/pSJMkOnWK0KyLL9fUqdP1ySfv6e13XjV93LynHtGxQ0fUuy9dW7bfZC+8w0ta7t6907Tk4TFDhunBB560u2qosW664Xb966qZhgkGK1eu0MqVK2SxWBQYGKQsO+deSbryXzcY2kJCQg1tu3btUGVlZYvFDgBwLQ8PDw07doSGHTtCa/78TS+//Kzpys4tWzfp6yWLdPrkqc16PbM9WlNTd8tms7lFWfOQYOO5Uarp/7VUwvvzzz82TWRdPPNyXXThJS3yGi2prV4jtOa4hbP6Yq7S2t8LrmQ2XnT4tVtrvMePHjxUkydNMZ0Mcc+9t0mquV6tb8X42VPPV6+efQztUVHRhvfenj0tM04GOMptawWHRh6c0VNuJeHd0sLDjImAzMxdLoikZcTGdDO05Thxn3I0T8Uhk1gCghjkAtzJSSeON7QtXPSJvv7auOfP5MlT6j1WXJwxcZOZldGoeMxm8cd1jm/2ALpZknPHDuPKuqawlyTds8d9z8PtmZeXlxITzfoZxhXb9TFLXsbHGwdP2rvc3BwtW/a1of2mG29vtYEsW5Vzy7HFmpRjs1qtKisrc/gYxcXFpquaO1LC+4CQ4BDNuvhyvfHaR6aTCfLycrV8xbcNHsfWhFX2rcFswDIhoW7C+8vDKqhINfuU/ve/D7ZowjgxsZvuu3eu3futVmu9A6x33/WwoqNjDO32yrNmmFQxaA+qqqlQB6BtcXYp2sMNHnSMnnv2dV104WzT+99486Vmv4a9c4vZRLK2yN41YUuW5l66dLGhbezYU3XhBbNa7DXq05jzYVu4RrCnNcctnNUXawta6nuhsglbRTmbvRX8h167teZ7/OqrbtLQocfZvb++75mBA47WjIvMKzyY7RG+a9eOxgfoJpqyLRmcz20T3mERBxPeZSUVLoykfeqWOMDQti3lD1VUOD4Q15ZERiQa2jZvXdVmB7Y6stLig3+TyFj3LVUDdFRBQUGacta0Om15ebl67/036rQNHz5SXRpYvdo51njhuGHDOhUWFTocz08//WBoS0xKdvj59vTtc4ShLSsrU9u3b2v2sf39/dWndz9D++9rVjf72HCOrl2M/Yz169c6/Py96WmmM9nNEqPt3VaT/weLxaJTTzm91WLIzTWudGlJ9gZgN25a7/AxVv38o2l7S634cUeJid30+Nz5pvelpGyvc9ssCbzPpMqCq1VXV+u33382tB+e2F+79nfDY8495wIFBwW3eEyDBx2jN1//WP37G68X7QkLC9fzz71ht7R8r159TdvNfq/2INdkCwsAaC1mq5tTU3erurq6VePw9PTUxTMv09Qp0w335eXlKj8/r1nHt3du+fmXn5p13NYSEBBguoJy5coVLXL8kpIS06TW+dNmysPDo0VeoyGNOR+6+hqhvs9Ha49bOKMv1lY09nvB0+T7bH8jV9e3hg1/GccGwsLC61Sgas33uLe3tx6473Fd1cjV/meecY4ee/RZu5UajzpykKFtzZ+rGzWx25009zwF53DfhPehK7xLSFq2tJ49jDOH8gsytfyn91wQTfNFdDIOGGdl79Efa5e6IBrUp/yQCSyHVnIA4D4mTTyzwcecdea5DT7GXrLPbNarmZycbH351eeG9i7xCQ49vz79jjjKtP3Z5x5v9rEl6dhjjXutLlv2tf5sp4P/7q5rV2PC++NP3lF5eblDz1+48BPT9s4dMOFtdtE4eNBQpw28mR3XbM/klmY2qWXBAsf3K/7gw7cMbWb7Onc0sbGdddZZ5xnaU9PqltIzW32wd2+qQ69hs9lMk9DOsGrVj6b7ch++wttsFVGf3saJWS2hoLBA/1u5wqFtPPr07qf//Psevf/uItOJYgcEBwWbDto+P/9J01Kr7sTsM9kWJ1cA6DjsTbxzdOB+zZ8tez0yfdoM0/bmfleGBIeYJoxffuVZt0lSHH30sYa25SuWae3aP0we3Thm1agsFovpdU1LaO75sDWvEfz9jNvg1Ldiu7XHLZzRF2trHP1eMHu/Zjm4un79+jWND6wJqqqq9Orrxkm5h0/Kae3r4A0b1mm9SSL+cBaLRWeeea5ef/VDXXP1zfVWjzr66KGGtqysTH3w4dvNirWtamxVP7QOtx4RCQ6v+YBVV1XXKYGMNsTnsAAAIABJREFU5ktKOFJBgcZ9Qr/5/lW3LG1utmJdkr7+5gWVlZW0cjSoT5n1YHIgjIQ34JYSE7tpiMnF+QFduiRo8KBjGjxOUFCQxo491dD+ySfvqaqq4fJnixZ/Zto+ftxpDT63ISHBITp+xGhD+9p1f2jFj985fJzq6moVFxcb2kePMp95PXfu/SotLW3U8eF8E8ZPNLRZrVb9+NP3DT63oLBAH338jqF99KgxjdoDvL0w22/REUVFRfr9918M7Q19XmJijNv4rFmz2umfHbMtHf63crnSHdjLe82fv5kmQSdPqn+bCHeXnb1fRUVFDT7ObJCysqJuRTCzgcldu3Zox47thvbDLVz0ien/f0urqqrSa2+8YGgfNHCI+vbtX6etqSv7f/7ZfJWbvVKQGRn7NHvONL38yrN1EtGjR43RjIvm6Prr/q37752rF+a/pS8Xr9D859/U2LGnOrR/utm52Wq16oWXnnbwt6nR1s57UZHRhrbU1N1uU1IXQPvj4eGh5OQehvaf/mdcYXq4rX9v1iefOr4QZvfunQ0+xs/kvC1JFQ5OHK3PeDt99DfffqVRx3Gk/+EMo0ePMW1/5rm5jSrbbLVaDdfPQYFBpo9tKLlWXV2tlauMlYZKSoxb7RyquefD1rxGsFiMq1c3bvzL7uNbc9zCmX2x1tKS3wtmldZ++KHhrYwKCgs0f/68Bh/XEuxNYD1/2sw6t1vzPf7W26/q+hsvrzNekZzcQ1POmqbLL7tW/7ntXj0+93m99+5CfbFoua656iYlOVApsf8RAxQWZswnvfHmiw793duyuDjjdnN//bXOBZGgIW6d8I6KO/jlZy1ofkcIB/n4+GrC2MtM73vt7ZuVsrPhD/T2lD/1xDMztGBRy6x2a47IyHiNGmEsh1JUnKvnXrpcaXvrL0G7a/cGZbPnd6uwFhwsc3LoZxyAezl98lS79509dbrDqxBnzrjU0LY3PU0PP3pPvWWRFi3+VG++Zdzj6dRTTlf37j0deu2GTJ8+07T97nv+rY8+frfBQYjNWzbqmuvm6MqrLzZcCCclJZteNO9NT9Nd99yqffvqnw1vs9n09ZJFmjh5tL7/4ZsGfhM0V0JCkmmy8cl5D2n9+j/tPi87e79uvvlK0/suueRfLRafOzEr3bfmz9X1rvLMzMzQtdfP0dp1xtUuO3bWn8BMTDDuv75r1w79/sevDkTbdGPHnKouXYyrNu74743KzLS/KmHTpr/03ztvMrTHdY7Xaaee0aIxtjWPP/mgzp12mj5f+LEqKsy3tKqoqNDKVcZSn50iIuvcDg0JlcViMTzu1dfn17uP6Ucfv6tnnrW/b6Ij/t62RZs22R80lWoGM++8+xbTwbF/XXG9oa13L2PFALPB6EN9+tkHusPkvSRJ++xMvHhi3kN19oWcfcmV+mbJKt1150OaOeNSTZ40RSNGjFLvXn3l6elpOqHLnvHjJioqyjgYvnTpF3rxpWdUUlL/JOWioiK9/MpzOmnM0Bbd37S54u1s37L4C/PBbQBoDQldkwxtr73+Qr0lmP9c+7tuuPFyh19jy9ZNmnHx2frPHTfUO6Hsl1//Z9oeZmclemOcMmGy6fl+wYIP9ehj99ndV/eArKxMPfzIPZp0+on17ovsLL169tGwYcbKXykp/+ia6+Y0mEAqLS3V2++8ptMmjTJMaAgNDTMkpqxWq2l/+oCysjI9+PBd+vAj42rNbf9srTeW5p4PW/MaoVu37oa2N996qd4V1a01buHMvlhraOnvhfh4YxLy+x++0abNG+weOyNjn665dnaz+4vLf/yu3qRydXW1lixdrIceuctw3wkjT9JRR9Ut/91a7/FNm/7S64dMqo3rHK83X/9Yr778vq668gade84FGjvmFA0edIyiIqNVVFzk8AQbX19fzZltPr5x23+u018OrChft26NLpkzTfOeesSh12wtSUnG74VPP3vfbSqGdCT2axC4gS7JgUrZWDPLrjDHqtAoYycGTTdk0AT9+ttC7UnbXKc9O3ev5r9ypY4beqaGDD5VUZEJ8vcPVHV1tfLzs5SVvUe/rP5c6zfWdKbSM7brmKMnqkt8b1f8GrVOGnWBfvntc5WV1511mJ6xXfOev1gnj5qpvr2HKTKiiwIDw1RZWaE9qZu1YdMK/bjqQxdF3fEUZh8czIrvZr4nCIC2b9iw4xUWFm7onFssFo05+RSHjxPXOV7nnH2BYQXst99+pfT0NF179S1KSkquLauUvm+vvvhigWHP8APMLkSbqm+fIzR+3EQt/eYLw33zX5in5SuW6aILLlHXhCTFxnSWl5eX8vPzlLLjHy1d+mWd561evcowmDFzxqVauXK5rNa6563Vq1dp2vmTdcXl12noMcMVH99VPj4+qqys1L59e7Vj53a9885r+nvbFknSM8/O1fBhIxUQENBivzuMLrzgEi1a/GmdNqvVqmuvv1TXX/dvjTz+xNoSkqWlpdq8ZYPmzr3f9EJ76pTpDe5x316ZlXG3Wq164MH/6oYb/lPn/qKiIq1fv0aPPX6/3YGAv//ebNp+wOGloQ+4+55bdf11t2nk8SfKz89PkrRzZ4qWr1imAQMGa9BA4/Y/jeHt7a0rLrtWt//3xjrtKSn/6LIrLtR/brtXR/Q7qnaQNj8/T6tXr9KDDxsHTCTpisuvq7e8nLvLzt5fuxr5qacf1ccfv6sLLpilI48cpPi4LvLw8NDe9DS9/PKz2rVrh+H5Q48ZbmgbduzxhglBK1eu0E03X6lrrr5ZCQlJ8vLyUnl5udatX6O33n5FGza0zCz+K6+epfHjJursqdNrBzPz8/O0Nz1N69f/qRdefMr0eaedeoZ69OhlaDcbEH3jzRfVObazTjppfO17o7q6Wrt27dDnCz/WwkXmWylI0s5dKaYTMlavXlXn9oaN6+Tv7y9fX1/l5OQoNW23du/aUXv+kWrO+wldk5SYlKzJk6ao32Gr0w/w8fHRNVfdrP/edbPhvg8+fEvffb9E/7rievXu3U8x0bHy9PRUSUmJ0tL2aPOWDXrt9RdqvwdefPFp3XN32xgk8/HxUWJiN8P78q23X5HNZtN5516koKCaVXbZ2fv140/fy9PTs96JgwDQXIMHH6PlK5bVacvLy9Uls8/TLTffqaOOHCRfX1/ZbDbt3JmiDz562+HyzAcsW7ZEUk01kZ9//kmnnXqGxpw8Qb169ZXFYlFlZaWWr1imJ+c9ZHhuXOf4FukLBwQE6JqrbtbDj95juO/rJYv08y8/6fJLr1HPnn0UH99Vfn5+Ki0t1Y6d2/Xbb7/USQp9tuBDXXbp1c2OqbEum3O1fvnFmPzbvHmDZlx8ti6Z9S8NHnyMEromKSgoSJWVlUpL26ONm9brjTdfqk2Ovveecf/mI444yrAn+EMP36U773iwzlYjFRUV2rZti1546Wm7Cau8vFzl5eWaru6Umn8+bM1rBHtl3S+74kJdOudqDRo4RHFxXer0vVtr3MKZfbHW0NLfC/2PMK/oeuVVF+u6a2/VySdNqH1fZWVl6osvF+itRlZ4sGfp0i+0Zs1qzZxxqU46cbz8/f1VUVGhjMx9Skvbow8+eMvuBJI5c64ytLXWe3zjYRNv96an6YflyxQZGSmr1arMzAzt2pWinbtS6kyuiOscry5dEzVo4BCdPnmq3fGlcWNP0+LFn2nLYXuS701P0zXXzdHpk6dqwoRJ6tolUYGBNfmkrKxMpabt1uLFn9Wem1JS/tGpp55uujWFK3Szs8L9qmsu0W233q3evfvJy8tLNptNf/21Vj+tXK5p516kyMioVo4Ubj0qEpd08INVnOt4eU84xsvLWzOmP6R5z1+somLjl+eq1Qu0avUCh4616KundcXsZ52274QjLJYQTRh7qRZ+aV6y5LsVb+i7FeYdDbSOshKbKstrVtUEBnsppJOPiyMC0FTe3t46e+r5evmVZ+u0T5o4xXSWfX2mT5uhL778zJD43bBhneZcdr6kmtnvmVkZ9c5+nXHRHNPVY81x3bW3ats/W0xX4W3evEG33W5ciWfm3fffMCS84zrH67575+rGm8xX+s5/YZ7mv9BwGa68vFx9+NE7mjljjkOxoGkiI6M046I5evOtlw33PTnvYT0572GFhYWrU6eIesshWywWXXD+xc4MtU3z9PTUJbP+pVdfe75O++9//Krp55+ugQOOVlR0jPbs3mm4iDaza9cO/fjT9zph5Emm94eFhevMM87Rgs/r7p99YHDhAIvFUvsdNH3azGYnvCVp+PCR6t9/gCGJmpeXq1turRlQ7dIlQVU2W70rEPr3H6ARI0Y1O562bPnyuqUJ96an6dHH7qu9fejfx8yxQ0cY2mbNusK0AsbadX9o1mzjPuAtbek3X2jpN1/UnhPri/8Ae4OfY06eoNden284xkOP3K1XXnteffvUDGz+/scvDr3Oe++/qSFHDzOUv0xO7lHn++uXX/5nOgh/KKvVqi1bN2nL1k1auvQLjR41Rlf+6wbTwZ/jjx+ti2deXifBcEBWVqbuufe2BmOXpB9/+l5r/vzNoe1TWsPMGZeaxv7ue6/r3fdel1T3Pdyndz8S3gCc6pQJk/XRx+8aVqxmZWXq5luMiZjGKi8v19dLFtZp+/Krz033KTYzbpyxFHlTjR8/UZs2bzBMTJVq+lxmyXAzH3z4ls477yKFhoS2WGyOSEpK1h2336/7H7jD9P5XX3ter77W8HH+3rZFv//xa52tx86Zer4h4Z2Vlamrr52tXj37KCEhSfn5efrNpFyymXfefV1XXXmD3fubcz5szWuEAUcNNu1bWq3W2lWnD97/hIYPH1nn/tYYt3B2X8yZnPG9kJzcQ5MnTTH9fM976pHav1dD1wpNlZWVqcfm3q/H5t5vuuDDzLTzZphO6Gmt93iYybZpb7z5YoPH25uepr3paVq9epU+/OhtXXHZtRpnUnbf29tb9907V3MuO9/0/2Phok/qnXh7qGefe1xPPfmSS/NJBwwbdrzppJ3U1N268upZps85ZsgwEt4u4NYlzTsnWeTlU/OGLyksV5Wt4X0x0DihoZG6fNYz6hxjLNvQGDt2rVNeXuuX/znc8KFnaPCAca4OA3YU5x7sfMQnU7EBcHdm+xpPmnRWo48TGhqmhx80X+12wN/bttR7cTF61BhNn2Zegrw5/P399ejDz6hPb2M52cbYsGGd6UXL4EHH6IH7Hm/0JIHDffvtl816Phxz/vSLNXqU+V57Us2gWkPJ7ocemNch9+4+1HnnXmj3M7V23R/69tuvTD8v9j4nd919a51VDoebOfOyBj9jhw6QpOxomf2bPTw8dNd/H1JiorGs+gGpqbvrTXYnJnbTXf99qE0MAjjT4i/rn2Rb3wDWffc+psBAY9Wg+LguOn960yaXmK1+biqr1drgAJzFYtFzz7xmd8AkNDRM//n3vab3ZWVl6sefvtePP33v8EDf5s0b9IhJAmDUCfa/3xy1fMUy3XPfbXZLI154wSxdPNPxkrn2rFjxXbOP0VJGjxqjY4YMq/cxh/5ttmzdVG9pfQBoLm9vb11ztbGihiPM9v8+3OrVq5qcXOrbt7/OPeeCJj3XnquvukkTTzuz2cf55hvXXFOdfNJ43XTj7c0+zmcL6lavPOqoQTp76vmmj/172xYt+26Jw8luqaa8b32JrOaeD1vrGiEyMkrXXXNrvXGaaY1xi9boizmLs74XZlzU8MR+s9dt7hjO4RxJdo8fN1GzLrbfz22N93ivXn0bjLMheXm5euiRu/XrYRUHDoiMjNK8J1506HxRn7/+Wlvvdl+tydvbWzfd0LjvYXfft9xduXXCW5Jiux5c5Z2f1fIzdSDFxCTp2n+9qgljmrYyLCnhKF0x+zmFh8e0cGSN5+XlrXPOul0njmxc5zkmyrzcJVrWoZ/h+GTKmQPurlOnCI0/JOk9YsQoxccZ91hyxJFHDtSLL7xdb2LInvOnX6w7br9fvr6+TXrthkREROrJJ15s8mqssLBwzbr4CsXZ+b857rgT9N47CzXm5AlNOv7Ysafq8bnzm/RcNI6Pj49u/899TZpckZjYTU89+bJhL6+OyNvbW3fc8UCjLpCTk3voxRfe0V13GsvfSVJKyja7zw0JDtFDD8yzW4LxcFu2bHQ4roZERkbpqSdfMqwQccSIEaP01LyXO8Ss8T69j2jS82668XYdP2K03fsvOH+Wzjnb8euCLl0S9Nwzr2nEcU1fUd/YSiP9+w/Q/OfeVL9+R9b7uBEjRmnO7Matypt18RX6dunPpudWsxKMY8ZMaPbAlVQzyevd98wra3l4eOiiCy/RKy+91+QShhddOFtXXH5dc0JscTfdeEejBlb3ZaQ7MRoAqFl5dsvN/3V4Yq3FYtGtt9yp2bPMq08dqlOnCIf7VYc68siBeuC+xw0VRprL29tbN97wH117zS1Nnkg8edKUJvXXWsppp56hJx6fr7jO8U16/rBhx+vsqdMN7bMuvrzeCbuHq5mg+6Tefst87+3Nm+vvJzfnfNia1whjx56qM884x+HXOcDZ4xat0RdzFmd9L3TqFKFnnnqlUZ+Nc8+5UPfdO7fRsRzQlN/j0jlX69Zb7qx3G6rWeI8nJnbTRRfOdvj49bn3vtuUk5Ntel9iYje9OP9tXeLAOcNM//4D9PS8lxUTE9ucEFtU//4DGjVZbOfOFCdGA3vcuqS5JCX3C1JaSk2SLDe9SOGxQS6OqH3y8vLWyaNnqF+fkfpu+evauXuj8gvsr9gODYlWv97HacCRJ6t7cv0Dt74+xj0fvH0cS0r4+vgZ2nxM2g7l5eWlU8dfrkEDxmrZD2/U7jVuJigwXCeecIFGDJui5166wrCfuaen23+E2gxbZbXyM4trb/foH+zCaIC2yWwFX30X7H4mFwS+vvV/Rx7g5WX8fvNpQsJ48sSztHRpzV7VTblgPFSvnn30ykvvaek3X+iLLxbUW8bJYrFo9KixmjbNvFyUPQf26j2UI4lyf39/XXftrTrzjHP04UfvaMWPyxqcvdy3b3+ddea5OmHkSQ2+RmhomG7/z306cfRYLfj8I23a/Fe9x+/Vs4+GDBmmU06Z3Kb2gm7M/6+vSV/A1+T59l/L+P738bG/VYaPt/E+s89QQ7y9vTVn9pUaP+40ffjRO1q+4tt6/1Z9evfTxIlnavy4iQ7twexv8ns5+rmucxyTPbcc+f81ey0/B18/wN/4mvb+JvFxXfTC82/pnXdfq3eftT69+2ny5CkaO+ZUeXt7q0t8V9lut+nFl56us+dYQ446apBee+UDPfb4/bV7RZuxWCyKjoqRzWaTl5dXnfvM/v/M/p8PFxoapgfvf0K///GrPv3sgwbLEh4YsHSkXHNrf46c5d+33qWZMy7V10sWadHiTxtcQXHRhbN11lnnNVh21N/fX1dcfq1GHj9aTz71sN0KDF26JGjqlGkaP26i/P39tfq3n02P1ZDH5z6vfn2P1NdLFmnhok9M9xs/4JghwzRx4pkaefyJDq/gnz5thoYMOVaPPHqP3d/lwPlx+vSZtZPQnpr3subNe9iwn+vh4jrH68X5b2vJ0sVa+s2XyshIV1ZWpiwWi2Jj49S9ey91S+qu+PguslgClZ+fpz/+WK2vlywyHOubb77QjIvsD7Z1795Tzz37uj5b8KF++OGbBks3Dho4RMOHj9T48RMVEhxS72PN3tdenl4mjzQy26/Qke/A6OgYPf3UK3rjzZfs7td5QJcuCSorZcs2wJ015zrscI4maM362Wb9xkOdMmGyBg8aqqeeedRu/8disWjqlOmaNPEsRUZG6Y81q42vc1gfr1+/I/Xxh1/p119XauGiTxpcJdy3b3/NuvjyOuW27Wnq9ZoknXH62Tpx9Fh9+tkH+u67JfVW0ZFqznuTJk3RKRMmtYkKTIMGDtEbr3+sJUsX66uvFjZ4brRYLJowYbJOnzRFCQnmC3n8/f11150PaeQPJ+rxJx6we90S1zleY8eepqlTptXuifzyi+/q8ScecKi88gGNPR+WlpTUaWvNa4Rrrr5ZE087U6+98YKh9Ht9nDlu0Zp9sZbmzO+F/v0H6NVXPtAbb76kDz962+7jxo+bqLPOOle9evZRcXGx4X6LpeHFVwMHHK25jz2n7Snb9P77b2r1b/ZXrkdFRevE0eN09tTpDk9Sbo33+MUzL9PAgUfriy8WaOeuFO3bt1dWq1VRUdFKSkxWUlJ3JSV1U0RElKpsNqXtTdXCRZ8YtsGwWq36c+3vOvmk8aav4+3trQvOv1gjjjtBb739ijZuWl9vbFFR0Ro+bKROOnGcBgwYXO/v4KrxzjPPOEdHHHGU7rv/dsP/x6HCwsKdtugG9fOorq6udnUQzVGUV6GX7zs4U+Wok5Lk6eX2C9fdgtVaoIzMHSoozFFpaZEC/INlsYQoLDRGkZFNm3HoCuXlpUrb+7cKi3JlLclXgH+wIjrFKaJTvAICmEDRWnLSC7V7Q5YkKaaLv6Zfn+ziiNCePHnjwQuM2Xc2v3wPGueLLxfIZrNp8qQpLVp2Nzt7v3buSqlNfJSWligsNFyRUdHqntzToeShs1RWViplxz/KysxQXn6u/P0D5Ofnp8jIaEVFRis8vJM8PZvXX8nMzNCOndtVVFSo8vIyhQSHKiQkVAkJSW1iQAY1DrwX9mdlKi8/tzbREhYWrqTEZEVERLo4wravvLxcO3elaM+eXaqy2eTl7a3Q0DB1T+5pd3Z9dXW1UlL+Ufq+NBUVFeqYIcMd/r8uLCpUyvZtys3LUWlpiaKiYhQVGa2IiCjT0tgtraSkRP/8s1U5udkqKbHK08NTfv7+6hQeoR49epsm3DqS6upq5efnKSNznzIy0lVRUaGqqirFxnRWdHSsIiIim/z9X1JSoj2pu5SaulvV1dXy9/NXXFwXJSUlN+n8VVZWpq++Xqjq6mp16hRhWEFVUlKinTu3KyNzn0pLS2SxBCo8rJOSk3s2+722f3+WduzcroKCfFVUlCs0JEwRkVHqntzTMFnjgKKiIm3eskEFBfkKDAzSsGONe583xV9/rdU11xmrhS1e+EPtoHlDKisrtXdvqnbuSlF5ebmqq6oUHFJz3kvu1qPFVwM6U1lZmXbt3qG9e1NVXlamkNAwRUVGKzIySiEhoW65RcHCV3coK60mSX/BDcmKinefvwfanqy0Ur3zRM2qqKh4f51+SeNXSqLxDnzPpqbuVklpiTw8PNS5c7y6J/ds9qB9WVmZsvZn/n9yLkM+Pr4KtAQqKipG0TGxCg5yzYKH1NTdSk3bo4L8PHl6ecnDw0PRUTGKiopRZGSUS68nHZGTk60dO7fXXg9XVJQrOjpWkRFRio6ObfS5saqqSnvT07R9+9+qrKxUlc2mkNAwxcd3rTcZm5GxTykp21RYWKCkbt0drtDS3PNha14jWK1WZWVlKDMrQ7k52TruuFEO92HawrhFS/TFWpqzvheqq6uVmZmh1LTdKiwsUFlpqTp3jldSt+4NToq056+/1mrbP1slScePGK3o6INVbKurq7UvI107Uv5RSWlJ7eemc2yc3Ykmjmrt6+D6VFZW6s67bzFMjpo+babmzL7S4eMUFBZo184UZefsV3FxkYKCghUSEqro6NgmV4R0laysTG3f/reKrTWTJ6KjYhQRGaXIiCi3THan7SjW12/XJPG79Q3UGbMTXRxR07h9wluSPnh6h9J31cz4SugXpU7xrAwF3M32NekqzK75HI+aHKPBoyJcHBHaExLeAAAArnPzLVfp9z9+rdM2//k3W3z/RLgGCW+0JBLeANDy6IuhucwmTgwfPlIP3v+EiyJCS2ovCe+2PVXNQX0Gh9YmvHP2Fbkk4V1QkK0ly15y6mtk5+xVp/DOTp3x7e3tq9NPu87urH+Y27FznX5b85VTX6OwKFe+Pr7y83PuyqIpp9/S6n//yoqq2mS3JPU9uv7ykwCA5nl+/jwVFRU69TWSk3to6pRpTn0NAK7z5Vefa+PGv5z6Gr6+vrr6qpu4NmlDioqKtH9/ppKSGleNKWu/sXyhWcl9AADaMvo/cLWW7IuVWK16bO79cvZ6yFGjTtaxQ49z6mugcbZv36b4+K6NqgSRX5BnaHN0ezOgtbSLhHevASH6YcE+SVJRTonKrJXys7Tur1ZaWqTf1nzp1Neorq5Wyk7nlzebdMpVdKoaKS19W6v8/VujvN2U0292+mscLju1oPbn+GSLAoLaxVcTALRZH3/yrtNfo3//ASS8gXbsl19W6n8rlzv9da64nMm4bclTTz+iZd8t0ehRYzTjojkODbZ++tkHpvuVx7lZ2UIAAOj/wNVasi/m4+Ojr75e6Iww64iOjiXh3YZs375Nsy+drrCwcM2ccalOmTC5wRLcWVmZeuXV5w3tzS3bDrS0dpFVsgR7q8dRwfpnfc1KpX07cpR4RLSLowLgqMxdB2eIDRhhvgcJAAAAANdZ8eN3WvbdEknS8hXLtHzFMo0fN1GnTJikbsk96uyLaLPZtG79Gi1e/JmWr1hmONbQoce51b7bAAAArtbSfTFfP1bndjQVFRV68OE7JUl5ebma99Qjeve91zXjojk6sv9AxcV1qbOvfHb2fv2w/Fu9+97rtfvQH4qJDGhr2kXCW5KGj4uuTXjn7i1SXI8I+fi13kw4Ly8fBQU6N1FXWVkuL29fOXONr59vgDw9mUHYWIGWMKf//SsqyuTp5S2vdvb32b+nQLaKKklScJi3eg+knDkAOFuvnn2UmZXh1Nfo3DneqccH4FrRMbEKC3Nu/9cSYGF1UxuRk5OtRx+719C+9JsvtPSbLyRJUVHRio/rqty8HGVlZchqtdo93iWzrnBarAAAOAv9H7iKM/pigYFBioqKVkVFhdPilqTwcBY3tRXvvveGUlL+qdOWlZWpuY8/UHu7T+9+8vD01P79mcrKMpbCP+D4EaNIHnB8AAARXUlEQVTVr9+RTosVaIp2k/CO7OynxN6B2rW1WJK0LyVHXftGtdrrR0TE6a7bFrfa66FtGTRgjAYNGOPqMNzSvpSDs8OGjWu9zywAdGQvvvC2q0MA4OauvvJGXX3lja4OA63k19Ur6x00lWoGy+obFDvgphtvV6+efVoqNAAAWg39H7iKs/piH33g3C060XZUV1dr4aKPG3zclq2bGnxMr559dMP1t7VEWECL8nR1AC3p2DEHk2XZqYUqL6l0YTQAGpK5K1+V5TZJkiXYS/2PZcYfAAAA0NaMG3uabrj+NlksliYfIywsXPfd+5hOO/WMFowMAACg/aMvhuby8PDQM0+/qmHDjm/WcUaPGqPH585XeHinFooMaDntZoW3JMUnWxSXFKC9O0skSbs3ZqrHkDgXRwXATGWFTfu259TeHnpypAujAQAAAGCPl5eXJk08S2NOPkU//fS9Fn+5QBs2rHPouYmJ3TTt3It04onj5Ovr6+RIAQAA2h/6YmgJXeK76qEHntT27dv09ZLF+nrJwgYrBxwwedIUTTnrPCUkJDk5SqDp2lXCW5JGnxGr9+btkCQV5ZYqL9OqsOimz3wC4Bxpm7NVZauWJIWEe2vQyAgXRwQAAACgPgEBARo37jSNG3ea8gvytXnTX9qydZP2789STm62qqurFRMdq9jYOEVHxyg2Nk59eveTp2e7Ki4HAADgEvTF0BK6d++pq668QVdcfq127kzRho3rlJq6R3l5OcrPz1NoaJhiYjorJiZW0dGx6tmjtzp1YuwebV+7S3jHdA3QkcPC9NcveZKk1M1ZColIkKeXh4sjA3BAcV6ZcjOKam+PnxbvwmgAAAAANFZoSKiGDTu+2WURAQAA0Hj0xdBcXl5e6t69p7p37+nqUIAW0S6n9oycGCt/S82vVlluU+rWLBdHBOCAKluVdv6VUXu796AQdeke6MKIAAAAAAAAAAAA4K7aZcLbL8BTJ54VW3s7J61I+RnFLowIwAE712eqorRSkuTr76mTzuzs4ogAAAAAAAAAAADgrtplwluS+gwKU/IRQbW3d23MVFmJzYURAchOLVTBfmvt7Qnnx8s/0MuFEQEAAAAAAAAAAMCdtduEtySden4XhUb4SJKqbNXasXaviyMCOq7Sogqlbt1fe3vAiHB17xfswogAAAAAAAAAAADg7tp1wtvHz1Onz0qQl7eHpJqE2461+1wcFdDxVJTZtH1NuqqrqiVJkbG+OuksSpkDAAAAAAAAAACgedp1wluSImL96uznnZ9l1a4NmS6MCOhYKsurtO23NFWU1ezb7eProTNmJ7o4KgAAAAAAAAAAALQH7T7hLUlHHhuuo0d3qr2dm16k1C3763kGgJZQZavSP7+nqbykJtnt5e2hM+ckKDjcx8WRAQAAAAAAAAAAoD3oEAlvSTphUqwGHh9ee3v/ngJl7MhzYURA+1Zlq9b2P9JVWlxR23bG7ATFJwe6MCoAAAAAAAAAAAC0Jx0m4S1JJ57ZWUceG1Z7O/2fHKX9ne3CiID2yVZZU8a8OL+stu2M2QlK6EmyGwAAAAAAAAAAAC2nQyW8JWnMOXHqd0xo7e2sXfns6Q20oPLSSm39JVUlheW1bZNmdlW3vkEujAoAAAAAAAAAAADtkberA3CF8efFy8fXU+tW5kqq2dPbVm5T8uDOLo4McG+lxZX65/c0VZbbJNXs2c3KbgAAAAAAAAAAADhLh1vhfcBJZ3XWiFOjam8XZJdoy8+pKi+tdGFUgPvKz7Lq71/31Ca7ff09de5VSSS7AQAAAAAAAAAA4DQdNuEtSUNPjtL4aXG1t0uLyrXl51QV7C9xYVSA+0ndsl871u5Tla1akmQJ8tK0a5MV0zXAxZEBAAAAAAAAAACgPeuQJc0P1W9ImELCfbT4jVSVWm2qqqxSyp/pikwIUZfeka4OD2jTKsoqlfLnvjr7dXdODNDkmV1lCenwXy8AAAAAAAAAAABwsg69wvuALt0DNePm7uqceHA16v7dBdq8ao+sBeX1PBPouLJ2F2jzqtQ6ye4hJ0bovGu6kewGAAAAAAAAAABAqyDh/f8sId4675puOnp0p9q2suIK/f1rqnZvypStssqF0QFtR0lBubb+kqq0rftV9f+fC19/T50xJ0EjJ8a4ODoAAAAAAAAAAAB0JCzDPMwJk2LVrW+wvvkwTQU5lZKknLQi5WdaFdcrQhFxwS6OEHANW2WV9v6drey0wjrt3fsH6eQpcQpkVTcAAAAAAAAAAABaGRkqE117BOqS23tp5dcZWr0sW5Jkq6jSno1ZytyZp5jEMHWKJ/GNjqGizKbMXXnKSSusU+nAEuylsefGK7lvkAujAwAAAAAAAAAAQEdGwrseI06JUd/BYVr6wV7t210iqabM+e5NWUrblqPoxFBFdAmRtw+V4dH+lBRVKDMlV7kZRYb7BowI18jTYuTjx3sfAAAAAAAAAAAArkPCuwGdYvw07dpu2r6xUL9+m6WMPaWSJFuFTen/5Cj9nxyFRlkUHheisGiLi6MFmqey3Kac9CLlpheqpLDccH/fo0M0dEy0OkX7uiA6AAAAAAAAAAAAoC4S3g7qfkSwuh8RrF1/F+nXb/crLcVae19+llX5WVZ5eHkquJO/gsMDZAnxV2C4nwsjBhpWWVGl4rxSFeeVqDivTMV5paaPO3JYmIaeHKWQTj6tHCEAAAAAAAAAAABgHwnvRkrsFaTEXkHan16mDb/mauNveSovrdnXuNpWpYIsqwqyDibDA4J95RfoK0uQr3wtPvIP9JV/EElDtC5bZbVKi8pVai1XWXG5SgvLVVJUoYqySrvP6RTto/7HdlK/IaEKCOKrAgAAAAAAAAAAAG0PWawmiuzsp9FnxGr0GbHaui5fG37J0+6/iw2PKyksV0lhufIOa/fw9JCnl6e8vP//Xy8PycOjdYJH+1ZdLVtllWy2alXZqmSrqHL4qT6+HuozOFT9jw1XbEKAE4MEAAAAAAAAAAAAmo+EdwvoPSBUvQeEqqKsSvv2lChjT4n27a75tyDXfAVtdVW1bFU22SpaOVjgENHx/orp6q+YrgGK6RKg6C7+rg4JAAAAAAAAAAAAcBgJ7xbk4+eprj0C1bVHYG1bRXm1cvaVKje7TLlZ5crLKld+doWKCypUXGSTraLahRGjvfML8FRgsJcCQ30UFuGrTtF+Co/2U2iErzpF+7o6PAAAAAAAAAAAAKBZSHg7mY+vh2ISAhRjpzx0eWmVigsrVVJUqaoqkt9oPm9vDwWG+Cg4nL3iAQAAAAAAAAAA0L6R8HYxX39P+fr7KjyK1bYAAAAAAAAAAAAA0Bierg4AAAAAAAAAAAAAAICmIOENAAAAAAAAAAAAAHBLJLwBAAAAAAAAAAAAAG6JhDcAAAAAAAAAAAAAwC2R8AYAtHu+/pzuAAAAAGeoKKuq/dnHj343mufQ91BleVU9jwQAAEBLqDikz+XO4+juGzkAAA4KDPaq/bm4oMKFkQAAAADtS0lxZe3PQSE+LowE7UFg8MH3UEmxzYWRAAAAdAylRQfHyw/ti7kbEt4AgHbPwqAJAAAA4BRlJTUrQnz8POTt6+HiaODufPwOvodKrVy7AQAAOFtx4cE+V2CItwsjaR4S3gCAdi863r/256y9VhdGAgAAALQfmWkH+9ZRcf71PBJwXOfEgNqfs/aWuDASAACA9i8r7WB/Kyreffv0JLwBAO1eYp+g2p9TNha6MBIAAACg/UjZUFD7c7e+QfU8EnBcUt/A2p93bOL6DQAAwFkqy6uUur249nZiL/ft05PwBgC0e90OSXin77QqJ6PMhdEAAAAA7q+irEpb1+bX3k7qHezCaNCedDvkvbT1z1xVVlS7MBoAAID2a+NvObU/Hzrp0B2R8AYAdAhHHhtW+/Nv32W4MBIAAADA/a1duV8VZTX7d0d19lV0F/ctf4i2JSYhQFFxfpJq9ohf//N+F0cEAADQ/lSUVWnt/7Jrbx81vJMLo2k+Et4AgA7h2LFRtT/v+adYOzYX1PNoAAAAAPbkZJZp3SGDY8dPinVhNGiPjjs1pvbnNcv3U6ULAACghS1fmFZnAmv3I9y7YhMJbwBAhxAc7qOBx4fX3l6+YK/y9jNoAgAAADRGRVmVlry7u/Z2TFd/JfV2373+0DYl9w1SbEJA7e2l7+9WZTmlzQEAAFrC5t9ztGtLUe3tkZPdfwIrCW8AQIdx3IQYhYR7S5JsldX65oM9shZVujgqAAAAwD3YKqv17cepshbW9KG9fDw0/rx4F0eF9mrsOXG1PxcXVOrbj/fIVknSGwAAoDn27izWyq8ObvnZa2CwEnu5/wRWEt4AgA7DL8BTk2cl1t4uyKnQ5y+lUB4PAAAAaECp1aaFr+7Q3pTi2rZTzu+iiFg/F0aF9iyys58mTD+Y9E7bXqxFr+1QqZVJywAAAE3xz4Z8ffXWwWpN4VE+Gn9uFxdG1HI8qqurmRoJAOhQNq7O1Tcfptfe9vbx0DEnR+mIoREujAoAAABom1I2FuiXpftkLbLVtg0YEa6TzurswqjQUXz3abrWr8qtvW0J9tbwU2LVrY977zMJAADQWqxFlfr1mwxt31BQ2+br76np1yUrPMrXhZG1HBLeAIAO6e/1BfryzdQ6bYEh3howIkJJfUNkCfJ2UWQAAACA61WUVWnn1kJt+CVb2fvqVkQaPiFSw8ZGuygydEQrv87Q6mXZddoiYv3Uf1iEknoHy8ePIpYAAACH259equ0bC7RpdU6drWFCOvnozDmJ6hTdPpLdEglvAEAHlplaqgWv7JK10Ga4r1OMn4LDfWQJ9JZ/IMlvAAAAtH9lJZUqKbbJWlCpjNQSw/1ePh46ZXq8eh4V4oLo0NGZTVo+IKZLgCwh3rIEecvX36uVIwMAAGgbqqqqVVJUKWtRpXL2ldap0HRA1x4WTZqZIL+A9jVhkIQ3AKBDqyir0pqfsrVmRbZKrVWuDgcAAABoc7y8PdT/2DAdOyZKgSFMBoXrFOVVaPV3+7XukBLnAAAAaFhkrK+GjotS7wGhrg7FKUh4AwAgqbKiWlv+zNPWPwu0++9iV4cDAAAAuFxMF3/1GhiifkeHyUKiG21IcUGlNv2eq23rCpWRWurqcAAAANokHz9P9R4Qol6DQpTYK8jV4TgVCW8AAA5TXlql9N1WWQtrSjqWldokzpYAAABo53z9vOQf6KmAQG9FdfZXcLiPq0MCGlSYW6HM9FKVFleqtLhK5WXG0p0AAAAdgYenFGDxln+Ql4KCfRSfbHF1SK2GhDcAAAAAAAAAAAAAwC21rx3JAQAAAAAAAAAAAAAdBglvAAAAAAAAAAAAAIBbIuENAAAAAAAAAAAAAHBLJLwBAAAAAAAAAAAAAG6JhDcAAAAAAAAAAAAAwC2R8AYAAAAAAAAAAAAAuCUS3gAAAAAAAAAAAAAAt0TCGwAAAAAAAAAAAADglkh4AwAAAAAAAAAAAADcEglvAAAAAAAAAAAAAIBbIuENAAAAAAAAAAAAAHBLJLwBAAAAAAAAAAAAAG6JhDcAAAAAAAAAAAAAwC2R8AYAAAAAAAAAAAAAuCUS3gAAAAAAAAAAAAAAt0TCGwAAAAAAAAAAAADglkh4AwAAAAAAAAAAAADcEglvAAAAAAAAAAAAAIBbIuENAAAAAAAAAAAAAHBLJLwBAAAAAAAAAAAAAG6JhDcAAAAAAAAAAAAAwC2R8AYAAAAAAAAAAAAAuCUS3gAAAAAAAAAAAAAAt0TCGwAAAAAAAAAAAADglkh4AwAAAAAAAAAAAADcEglvAAAAAAAAAAAAAIBbIuENAAAAAAAAAAAAAHBLJLwBAAAAAAAAAAAAAG6JhDcAAAAAAAAAAAAAwC2R8AYAAAAAAAAAAAAAuCUS3gAAAAAAAAAAAAAAt0TCGwAAAAAAAAAAAADglv4PKvflqBDIdJMAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from langgraph_supervisor import create_supervisor\n",
+    "\n",
+    "# Create supervisor workflow\n",
+    "supervisor_prebuilt_workflow = create_supervisor(\n",
+    "    agents=[invoice_information_subagent, music_catalog_subagent],\n",
+    "    output_mode=\"last_message\", # alternative is full_history\n",
+    "    model=model,\n",
+    "    prompt=(supervisor_prompt), \n",
+    "    state_schema=State\n",
+    ")\n",
+    "\n",
+    "supervisor_prebuilt = supervisor_prebuilt_workflow.compile(name=\"music_catalog_subagent\", checkpointer=checkpointer, store=in_memory_store)\n",
+    "\n",
+    "# Visualize the graph\n",
+    "visualize_graph(supervisor_prebuilt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's test it out!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "My customer ID is 1. How much was my most recent purchase? What albums do you have by U2?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_to_invoice_information_subagent (call_fRLvgwnGkZE8evQilVGZ8meK)\n",
+      " Call ID: call_fRLvgwnGkZE8evQilVGZ8meK\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_to_invoice_information_subagent\n",
+      "\n",
+      "Successfully transferred to invoice_information_subagent\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Your most recent purchase was $8.91.\n",
+      "\n",
+      "However, I specialize in invoice-related queries, so I'm not able to provide information about album collections by U2. Would you like help with another invoice-related question?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Transferring back to supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_back_to_supervisor (b88143e8-06c4-4e6e-a267-2581ad9b10a0)\n",
+      " Call ID: b88143e8-06c4-4e6e-a267-2581ad9b10a0\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_back_to_supervisor\n",
+      "\n",
+      "Successfully transferred back to supervisor\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_to_music_catalog_subagent (call_8j75CtSa23O0CCE6lRzz7IO3)\n",
+      " Call ID: call_8j75CtSa23O0CCE6lRzz7IO3\n",
+      "  Args:\n",
+      "    query: albums by U2\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_to_music_catalog_subagent\n",
+      "\n",
+      "Successfully transferred to music_catalog_subagent\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Here are the albums by U2 in our catalog:\n",
+      "• Achtung Baby\n",
+      "• All That You Can't Leave Behind\n",
+      "• B-Sides 1980-1990\n",
+      "• How To Dismantle An Atomic Bomb\n",
+      "• Pop\n",
+      "• Rattle And Hum\n",
+      "• The Best Of 1980-1990\n",
+      "• War\n",
+      "• Zooropa\n",
+      "• Instant Karma: The Amnesty International Campaign to Save Darfur\n",
+      "\n",
+      "Let me know if you need more details about any of these albums or if there's anything else I can help you with!\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: music_catalog_subagent\n",
+      "\n",
+      "Transferring back to supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_back_to_supervisor (62d812d6-8aad-468d-8704-606b07b986c6)\n",
+      " Call ID: 62d812d6-8aad-468d-8704-606b07b986c6\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_back_to_supervisor\n",
+      "\n",
+      "Successfully transferred back to supervisor\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "\n",
+      "To summarize, your most recent purchase was $8.91, and here are the albums by U2 available in our catalog:\n",
+      "\n",
+      "• Achtung Baby  \n",
+      "• All That You Can't Leave Behind  \n",
+      "• B-Sides 1980-1990  \n",
+      "• How To Dismantle An Atomic Bomb  \n",
+      "• Pop  \n",
+      "• Rattle And Hum  \n",
+      "• The Best Of 1980-1990  \n",
+      "• War  \n",
+      "• Zooropa  \n",
+      "• Instant Karma: The Amnesty International Campaign to Save Darfur\n",
+      "\n",
+      "Let me know if you'd like more details on any album or if you have any other questions!\n"
+     ]
+    }
+   ],
+   "source": [
+    "thread_id = uuid.uuid4()\n",
+    "question = \"My customer ID is 1. How much was my most recent purchase? What albums do you have by U2?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = supervisor_prebuilt.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 3: Adding customer verification through human-in-the-loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We currently invoke our graph with a customer ID as the customer identifier, but realistically, we may not always have access to the customer identity. To solve this, we want to **first verify the customer information** before executing their inquiry with our supervisor agent. \n",
+    "\n",
+    "In this step, we will be showing a simple implementation of such a node, using **human-in-the-loop** to prompt the customer to provide their account information. \n",
+    "\n",
+    "![customer-input](../images/human_input.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this step, we will write two nodes: \n",
+    "- **verify_info** node that verifies account information \n",
+    "- **human_input** node that prompts user to provide additional information \n",
+    "\n",
+    "ChatModels support attaching a structured data schema to adhere response to. This is useful in scenarios like extracting information or categorizing. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel, Field\n",
+    "\n",
+    "class UserInput(BaseModel):\n",
+    "    \"\"\"Schema for parsing user-provided account information.\"\"\"\n",
+    "    identifier: str = Field(description = \"Identifier, which can be a customer ID, email, or phone number.\")\n",
+    "\n",
+    "\n",
+    "structured_llm = model.with_structured_output(schema=UserInput)\n",
+    "structured_system_prompt = \"\"\"You are a customer service representative responsible for extracting customer identifier.\\n \n",
+    "Only extract the customer's account information from the message history. \n",
+    "If they haven't provided the information yet, return an empty string for the file\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Optional \n",
+    "\n",
+    "# Helper \n",
+    "def get_customer_id_from_identifier(identifier: str) -> Optional[int]:\n",
+    "    \"\"\"\n",
+    "    Retrieve Customer ID using an identifier, which can be a customer ID, email, or phone number.\n",
+    "    \n",
+    "    Args:\n",
+    "        identifier (str): The identifier can be customer ID, email, or phone.\n",
+    "    \n",
+    "    Returns:\n",
+    "        Optional[int]: The CustomerId if found, otherwise None.\n",
+    "    \"\"\"\n",
+    "    if identifier.isdigit():\n",
+    "        return int(identifier)\n",
+    "    elif identifier[0] == \"+\":\n",
+    "        query = f\"SELECT CustomerId FROM Customer WHERE Phone = '{identifier}';\"\n",
+    "        result = db.run(query)\n",
+    "        formatted_result = ast.literal_eval(result)\n",
+    "        if formatted_result:\n",
+    "            return formatted_result[0][0]\n",
+    "    elif \"@\" in identifier:\n",
+    "        query = f\"SELECT CustomerId FROM Customer WHERE Email = '{identifier}';\"\n",
+    "        result = db.run(query)\n",
+    "        formatted_result = ast.literal_eval(result)\n",
+    "        if formatted_result:\n",
+    "            return formatted_result[0][0]\n",
+    "    return None "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Node\n",
+    "\n",
+    "def verify_info(state: State, config: RunnableConfig):\n",
+    "    \"\"\"Verify the customer's account by parsing their input and matching it with the database.\"\"\"\n",
+    "\n",
+    "    if state.get(\"customer_id\") is None: \n",
+    "        system_instructions = \"\"\"You are a music store agent, where you are trying to verify the customer identity \n",
+    "        as the first step of the customer support process. \n",
+    "        Only after their account is verified, you would be able to support them on resolving the issue. \n",
+    "        In order to verify their identity, one of their customer ID, email, or phone number needs to be provided.\n",
+    "        If the customer has not provided their identifier, please ask them for it.\n",
+    "        If they have provided the identifier but cannot be found, please ask them to revise it.\"\"\"\n",
+    "\n",
+    "        user_input = state[\"messages\"][-1] \n",
+    "    \n",
+    "        # Parse for customer ID\n",
+    "        parsed_info = structured_llm.invoke([SystemMessage(content=structured_system_prompt)] + [user_input])\n",
+    "    \n",
+    "        # Extract details\n",
+    "        identifier = parsed_info.identifier\n",
+    "    \n",
+    "        customer_id = \"\"\n",
+    "        # Attempt to find the customer ID\n",
+    "        if (identifier):\n",
+    "            customer_id = get_customer_id_from_identifier(identifier)\n",
+    "    \n",
+    "        if customer_id != \"\":\n",
+    "            intent_message = SystemMessage(\n",
+    "                content= f\"Thank you for providing your information! I was able to verify your account with customer id {customer_id}.\"\n",
+    "            )\n",
+    "            return {\n",
+    "                  \"customer_id\": customer_id,\n",
+    "                  \"messages\" : [intent_message]\n",
+    "                  }\n",
+    "        else:\n",
+    "          response = model.invoke([SystemMessage(content=system_instructions)]+state['messages'])\n",
+    "          return {\"messages\": [response]}\n",
+    "\n",
+    "    else: \n",
+    "        pass\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, let's create our human_input node. We will be prompting the user input through the Interrupt class. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.types import interrupt\n",
+    "# Node\n",
+    "def human_input(state: State, config: RunnableConfig):\n",
+    "    \"\"\" No-op node that should be interrupted on \"\"\"\n",
+    "    user_input = interrupt(\"Please provide input.\")\n",
+    "    return {\"messages\": [user_input]}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's put this together! "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# conditional_edge\n",
+    "def should_interrupt(state: State, config: RunnableConfig):\n",
+    "    if state.get(\"customer_id\") is not None:\n",
+    "        return \"continue\"\n",
+    "    else:\n",
+    "        return \"interrupt\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Add nodes \n",
+    "multi_agent_verify = StateGraph(State)\n",
+    "multi_agent_verify.add_node(\"verify_info\", verify_info)\n",
+    "multi_agent_verify.add_node(\"human_input\", human_input)\n",
+    "multi_agent_verify.add_node(\"supervisor\", supervisor_prebuilt)\n",
+    "\n",
+    "multi_agent_verify.add_edge(START, \"verify_info\")\n",
+    "multi_agent_verify.add_conditional_edges(\n",
+    "    \"verify_info\",\n",
+    "    should_interrupt,\n",
+    "    {\n",
+    "        \"continue\": \"supervisor\",\n",
+    "        \"interrupt\": \"human_input\",\n",
+    "    },\n",
+    ")\n",
+    "multi_agent_verify.add_edge(\"human_input\", \"verify_info\")\n",
+    "multi_agent_verify.add_edge(\"supervisor\", END)\n",
+    "multi_agent_verify_graph = multi_agent_verify.compile(name=\"multi_agent_verify\", checkpointer=checkpointer, store=in_memory_store)\n",
+    "\n",
+    "visualize_graph(multi_agent_verify_graph)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's test it out!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "How much was my most recent purchase?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "I’d be happy to help with your purchase info, but first I need to verify your identity. Could you please provide either your customer ID, email address, or phone number associated with your account?\n"
+     ]
+    }
+   ],
+   "source": [
+    "thread_id = uuid.uuid4()\n",
+    "question = \"How much was my most recent purchase?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = multi_agent_verify_graph.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "How much was my most recent purchase?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "I’d be happy to help with your purchase info, but first I need to verify your identity. Could you please provide either your customer ID, email address, or phone number associated with your account?\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "My phone number is +55 (12) 3923-5555.\n",
+      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "\n",
+      "Thank you for providing your information! I was able to verify your account with customer id 1.\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_to_invoice_information_subagent (call_MygNQmGc7mZGBA0LvWs1T71t)\n",
+      " Call ID: call_MygNQmGc7mZGBA0LvWs1T71t\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_to_invoice_information_subagent\n",
+      "\n",
+      "Successfully transferred to invoice_information_subagent\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Your most recent purchase, on 2025-08-07, was for 8.91. Is there anything else you would like to know about your invoices?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Transferring back to supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_back_to_supervisor (e0b6a7a0-34b2-40b9-9260-d0751fd03853)\n",
+      " Call ID: e0b6a7a0-34b2-40b9-9260-d0751fd03853\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_back_to_supervisor\n",
+      "\n",
+      "Successfully transferred back to supervisor\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "\n",
+      "Your most recent purchase was on August 7, 2025, and the total amount charged was 8.91. Is there anything else you'd like help with regarding your invoices or any other queries?\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langgraph.types import Command\n",
+    "\n",
+    "# Resume from interrupt \n",
+    "question = \"My phone number is +55 (12) 3923-5555.\"\n",
+    "result = multi_agent_verify_graph.invoke(Command(resume=question), config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, if I ask a follow-up question in the same thread, our agent state stores our customer_id, not needing to verify again. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "How much was my most recent purchase?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "I’d be happy to help with your purchase info, but first I need to verify your identity. Could you please provide either your customer ID, email address, or phone number associated with your account?\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "My phone number is +55 (12) 3923-5555.\n",
+      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "\n",
+      "Thank you for providing your information! I was able to verify your account with customer id 1.\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_to_invoice_information_subagent (call_MygNQmGc7mZGBA0LvWs1T71t)\n",
+      " Call ID: call_MygNQmGc7mZGBA0LvWs1T71t\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_to_invoice_information_subagent\n",
+      "\n",
+      "Successfully transferred to invoice_information_subagent\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Your most recent purchase, on 2025-08-07, was for 8.91. Is there anything else you would like to know about your invoices?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: invoice_information_subagent\n",
+      "\n",
+      "Transferring back to supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_back_to_supervisor (e0b6a7a0-34b2-40b9-9260-d0751fd03853)\n",
+      " Call ID: e0b6a7a0-34b2-40b9-9260-d0751fd03853\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_back_to_supervisor\n",
+      "\n",
+      "Successfully transferred back to supervisor\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "\n",
+      "Your most recent purchase was on August 7, 2025, and the total amount charged was 8.91. Is there anything else you'd like help with regarding your invoices or any other queries?\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "What albums do you have by the Rolling Stones?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_to_music_catalog_subagent (call_8Qzr6fDaVxhDxO8gT4wZDlcU)\n",
+      " Call ID: call_8Qzr6fDaVxhDxO8gT4wZDlcU\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_to_music_catalog_subagent\n",
+      "\n",
+      "Successfully transferred to music_catalog_subagent\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Here are the albums by The Rolling Stones in our catalog:\n",
+      "• Hot Rocks, 1964-1971 (Disc 1)\n",
+      "• No Security\n",
+      "• Voodoo Lounge\n",
+      "\n",
+      "Let me know if you’d like more details about any of these albums or if you have any other music-related questions!\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: music_catalog_subagent\n",
+      "\n",
+      "Transferring back to supervisor\n",
+      "Tool Calls:\n",
+      "  transfer_back_to_supervisor (d94e9534-f74e-4fac-893b-405f3fd3af44)\n",
+      " Call ID: d94e9534-f74e-4fac-893b-405f3fd3af44\n",
+      "  Args:\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: transfer_back_to_supervisor\n",
+      "\n",
+      "Successfully transferred back to supervisor\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Name: supervisor\n",
+      "\n",
+      "Here are the albums by The Rolling Stones in our catalog:\n",
+      "• Hot Rocks, 1964-1971 (Disc 1)\n",
+      "• No Security\n",
+      "• Voodoo Lounge\n",
+      "\n",
+      "Would you like any more details about these albums or help with another query?\n"
+     ]
+    }
+   ],
+   "source": [
+    "question = \"What albums do you have by the Rolling Stones?\"\n",
+    "result = multi_agent_verify_graph.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 4: Adding Long-Term Memory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have created an agent workflow that includes verification and execution, let's take it a step further. \n",
+    "\n",
+    "**Long term memory** lets you store and recall information between conversations. We have already initialized a long term memory store. \n",
+    "\n",
+    "\n",
+    "![memory](../images/memory.png)\n",
+    "\n",
+    "In this step, we will add 2 nodes: \n",
+    "- **load_memory** node that loads from the long term memory store\n",
+    "- **create_memory** node that saves any music interests that the customer has shared about themselves "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.store.base import BaseStore\n",
+    "\n",
+    "# helper function to structure memory \n",
+    "def format_user_memory(user_data):\n",
+    "    \"\"\"Formats music preferences from users, if available.\"\"\"\n",
+    "    profile = user_data['memory']\n",
+    "    result = \"\"\n",
+    "    if hasattr(profile, 'music_preferences') and profile.music_preferences:\n",
+    "        result += f\"Music Preferences: {', '.join(profile.music_preferences)}\"\n",
+    "    return result.strip()\n",
+    "\n",
+    "# Node\n",
+    "def load_memory(state: State, config: RunnableConfig, store: BaseStore):\n",
+    "    \"\"\"Loads music preferences from users, if available.\"\"\"\n",
+    "    \n",
+    "    user_id = state[\"customer_id\"]\n",
+    "    namespace = (\"memory_profile\", user_id)\n",
+    "    existing_memory = store.get(namespace, \"user_memory\")\n",
+    "    formatted_memory = \"\"\n",
+    "    if existing_memory and existing_memory.value:\n",
+    "        formatted_memory = format_user_memory(existing_memory.value)\n",
+    "\n",
+    "    return {\"loaded_memory\" : formatted_memory}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# User profile structure for creating memory\n",
+    "\n",
+    "class UserProfile(BaseModel):\n",
+    "    customer_id: str = Field(\n",
+    "        description=\"The customer ID of the customer\"\n",
+    "    )\n",
+    "    music_preferences: List[str] = Field(\n",
+    "        description=\"The music preferences of the customer\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "create_memory_prompt = \"\"\"You are an expert analyst that is observing a conversation that has taken place between a customer and a customer support assistant. The customer support assistant works for a digital music store, and has utilized a multi-agent team to answer the customer's request. \n",
+    "You are tasked with analyzing the conversation that has taken place between the customer and the customer support assistant, and updating the memory profile associated with the customer. The memory profile may be empty. If it's empty, you should create a new memory profile for the customer.\n",
+    "\n",
+    "You specifically care about saving any music interest the customer has shared about themselves, particularly their music preferences to their memory profile.\n",
+    "\n",
+    "To help you with this task, I have attached the conversation that has taken place between the customer and the customer support assistant below, as well as the existing memory profile associated with the customer that you should either update or create. \n",
+    "\n",
+    "The customer's memory profile should have the following fields:\n",
+    "- customer_id: the customer ID of the customer\n",
+    "- music_preferences: the music preferences of the customer\n",
+    "\n",
+    "These are the fields you should keep track of and update in the memory profile. If there has been no new information shared by the customer, you should not update the memory profile. It is completely okay if you do not have new information to update the memory profile with. In that case, just leave the values as they are.\n",
+    "\n",
+    "*IMPORTANT INFORMATION BELOW*\n",
+    "\n",
+    "The conversation between the customer and the customer support assistant that you should analyze is as follows:\n",
+    "{conversation}\n",
+    "\n",
+    "The existing memory profile associated with the customer that you should either update or create based on the conversation is as follows:\n",
+    "{memory_profile}\n",
+    "\n",
+    "Ensure your response is an object that has the following fields:\n",
+    "- customer_id: the customer ID of the customer\n",
+    "- music_preferences: the music preferences of the customer\n",
+    "\n",
+    "For each key in the object, if there is no new information, do not update the value, just keep the value that is already there. If there is new information, update the value. \n",
+    "\n",
+    "Take a deep breath and think carefully before responding.\n",
+    "\"\"\"\n",
+    "\n",
+    "\n",
+    "\n",
+    "# Node\n",
+    "def create_memory(state: State, config: RunnableConfig, store: BaseStore):\n",
+    "    user_id = str(state[\"customer_id\"])\n",
+    "    namespace = (\"memory_profile\", user_id)\n",
+    "    existing_memory = store.get(namespace, \"user_memory\")\n",
+    "    if existing_memory and existing_memory.value:\n",
+    "        existing_memory_dict = existing_memory.value\n",
+    "        formatted_memory = (\n",
+    "            f\"Music Preferences: {', '.join(existing_memory_dict.get('music_preferences', []))}\"\n",
+    "        )\n",
+    "    else:\n",
+    "        formatted_memory = \"\"\n",
+    "    formatted_system_message = SystemMessage(content=create_memory_prompt.format(conversation=state[\"messages\"], memory_profile=formatted_memory))\n",
+    "    updated_memory = model.with_structured_output(UserProfile).invoke([formatted_system_message])\n",
+    "    key = \"user_memory\"\n",
+    "    store.put(namespace, key, {\"memory\": updated_memory})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "multi_agent_final = StateGraph(State)\n",
+    "multi_agent_final.add_node(\"verify_info\", verify_info)\n",
+    "multi_agent_final.add_node(\"human_input\", human_input)\n",
+    "multi_agent_final.add_node(\"load_memory\", load_memory)\n",
+    "multi_agent_final.add_node(\"supervisor\", supervisor_prebuilt)\n",
+    "multi_agent_final.add_node(\"create_memory\", create_memory)\n",
+    "\n",
+    "multi_agent_final.add_edge(START, \"verify_info\")\n",
+    "multi_agent_final.add_conditional_edges(\n",
+    "    \"verify_info\",\n",
+    "    should_interrupt,\n",
+    "    {\n",
+    "        \"continue\": \"load_memory\",\n",
+    "        \"interrupt\": \"human_input\",\n",
+    "    },\n",
+    ")\n",
+    "multi_agent_final.add_edge(\"human_input\", \"verify_info\")\n",
+    "multi_agent_final.add_edge(\"load_memory\", \"supervisor\")\n",
+    "multi_agent_final.add_edge(\"supervisor\", \"create_memory\")\n",
+    "multi_agent_final.add_edge(\"create_memory\", END)\n",
+    "multi_agent_final_graph = multi_agent_final.compile(name=\"multi_agent_verify\", checkpointer=checkpointer, store=in_memory_store)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "visualize_graph(multi_agent_final_graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "thread_id = uuid.uuid4()\n",
+    "\n",
+    "question = \"My phone number is +55 (12) 3923-5555. How much was my most recent purchase? What albums do you have by the Rolling Stones?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = multi_agent_final_graph.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's take a look at the memory!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "user_id = \"1\"\n",
+    "namespace = (\"memory_profile\", user_id)\n",
+    "memory = in_memory_store.get(namespace, \"user_memory\").value\n",
+    "\n",
+    "saved_music_preferences = memory.get(\"memory\").music_preferences\n",
+    "\n",
+    "print(saved_music_preferences)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##  (Optional) Build a Swarm Multi-Agent Graph\n",
+    "\n",
+    "### Swarm Architecture\n",
+    "\n",
+    "![swarm](../images/swarm.png) \n",
+    "\n",
+    "There is another popular framework for building multi-agent graphs called Swarm. At LangChain, we built a [lightweight library](https://github.com/langchain-ai/langgraph-swarm-py) to help make Swarm agents very easily! Swarm agents are designed for collaborative problem-solving where multiple specialized agents work together, without a central coordinator.\n",
+    "\n",
+    "### Swarm vs Supervisor\n",
+    "\n",
+    "![swarm_vs_supervisor](../images/supervisor_vs_swarm.png)\n",
+    "\n",
+    "Swarm architecture differs from supervisor-based approaches by emphasizing decentralized collaboration rather than hierarchical control. In a supervisor architecture, a central agent coordinates the workflow, delegates tasks, and makes decisions about which subagents to call. This creates a clear hierarchy where the supervisor has authority over specialized agents.\n",
+    "\n",
+    "The supervisor approach offers more control and predictability, while swarm architectures can be more adaptable and resilient to individual agent failures. Your choice between these approaches depends on whether your use case benefits more from centralized oversight or emergent collaboration.\n",
+    "\n",
+    "For more information there is a great video by Lance from our team at Langchain breaking down Supervisor vs Swarm: [Multi-agent swarms with LangGraph](https://www.youtube.com/watch?v=JeyDrn1dSUQ)\n",
+    "\n",
+    "Let's create swarm agents!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph_swarm import create_handoff_tool, create_swarm\n",
+    "\n",
+    "# Create our handoff tools between agents\n",
+    "\n",
+    "transfer_to_invoice_agent_handoff_tool = create_handoff_tool(\n",
+    "    agent_name = \"invoice_information_agent_with_handoff\",\n",
+    "    description = \"Transfer user to the invoice information agent that can help with invoice information\"\n",
+    ")\n",
+    "\n",
+    "transfer_to_music_catalog_agent_handoff_tool = create_handoff_tool(\n",
+    "    agent_name = \"music_catalog_agent_with_handoff\", \n",
+    "    description = \"Transfer user to the music catalog agent that can help with music searches and music catalog information\"\n",
+    ")\n",
+    "\n",
+    "# Recreate our agents with the handoff tools\n",
+    "\n",
+    "# First let's create our tools with handoff tools added to them\n",
+    "invoice_tools_with_handoff = [transfer_to_music_catalog_agent_handoff_tool] + invoice_tools\n",
+    "music_tools_with_handoff = [transfer_to_invoice_agent_handoff_tool] + music_tools\n",
+    "\n",
+    "invoice_information_agent_with_handoff = create_react_agent(\n",
+    "    model,\n",
+    "    invoice_tools_with_handoff,\n",
+    "    prompt = invoice_subagent_prompt,\n",
+    "    name = \"invoice_information_agent_with_handoff\"\n",
+    ")\n",
+    "\n",
+    "# pull music catalog agent prompt from the previous custom react agent implementation\n",
+    "\n",
+    "\n",
+    "music_catalog_agent_with_handoff = create_react_agent(\n",
+    "    model,\n",
+    "    music_tools_with_handoff,\n",
+    "    prompt = generate_music_assistant_prompt(),\n",
+    "    name = \"music_catalog_agent_with_handoff\"\n",
+    ")\n",
+    "\n",
+    "\n",
+    "swarm_workflow = create_swarm(\n",
+    "    agents = [invoice_information_agent_with_handoff, music_catalog_agent_with_handoff],\n",
+    "    default_active_agent = \"invoice_information_agent_with_handoff\",\n",
+    ")\n",
+    "\n",
+    "# Compile with checkpointer/store\n",
+    "swarm_agents = swarm_workflow.compile(\n",
+    "    checkpointer = checkpointer,\n",
+    "    store = in_memory_store\n",
+    ")\n",
+    "\n",
+    "visualize_graph(swarm_agents)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's test it out!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a new thread\n",
+    "thread_id = uuid.uuid4()\n",
+    "\n",
+    "question = \"Do you have any albums by the Rolling Stones?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "# Invoke the swarm agents. The default active agent will hand off to our music catalog agent instead of trying to solve the problem itself\n",
+    "result = swarm_agents.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluations\n",
+    "\n",
+    "**Evaluations** are a quantitative way to measure performance of agents, which is important beacause LLMs don't always behave precitably — small changes in prompts, models, or inputs can significantly impact results. Evaluations provide a structured way to identify failures, compare changes across different versions of your applicaiton, and build more reliable AI applications.\n",
+    "\n",
+    "Evaluations are made up of three components:\n",
+    "\n",
+    "1. A **dataset test** inputs and expected outputs.\n",
+    "2. An **application or target function** that defines what you are evaluating, taking in inputs and returning the application output\n",
+    "3. **Evaluators** that score your target function's outputs.\n",
+    "\n",
+    "![Evaluation](../images/evals-conceptual.png) \n",
+    "\n",
+    "There are many ways you can evaluate an agent. Today, we will cover the three common types of agent evaluations:\n",
+    "\n",
+    "1. **Final Response**: Evaluate the agent's final response.\n",
+    "2. **Single step**: Evaluate any agent step in isolation (e.g., whether it selects the appropriate tool).\n",
+    "3. **Trajectory**: Evaluate whether the agent took the expected path (e.g., of tool calls) to arrive at the final answer."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Evaluating The Final Response\n",
+    "\n",
+    "One way to evaluate an agent is to assess its overall performance on a task. This basically involves treating the agent as a black box and simply evaluating whether or not it gets the job done.\n",
+    "- Input: User input \n",
+    "- Output: The agent's final response.\n",
+    "\n",
+    "\n",
+    "![final-response](../images/final-response.png) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1. Create a Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langsmith import Client\n",
+    "\n",
+    "client = Client()\n",
+    "\n",
+    "# Create a dataset\n",
+    "examples = [\n",
+    "    {\n",
+    "        \"question\": \"My name is Aaron Mitchell. My number associated with my account is +1 (204) 452-6452. I am trying to find the invoice number for my most recent song purchase. Could you help me with it?\",\n",
+    "        \"response\": \"The Invoice ID of your most recent purchase was 342.\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"question\": \"I'd like a refund.\",\n",
+    "        \"response\": \"I need additional information to help you with the refund. Could you please provide your customer identifier so that we can fetch your purchase history?\",\n",
+    "    },\n",
+    "    {\n",
+    "        \"question\": \"Who recorded Wish You Were Here again?\",\n",
+    "        \"response\": \"Wish You Were Here is an album by Pink Floyd\",\n",
+    "    },\n",
+    "    { \n",
+    "        \"question\": \"What albums do you have by Coldplay?\",\n",
+    "        \"response\": \"There are no Coldplay albums available in our catalog at the moment.\",\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "dataset_name = \"LangGraph 101 Multi-Agent: Final Response\"\n",
+    "\n",
+    "if not client.has_dataset(dataset_name=dataset_name):\n",
+    "    dataset = client.create_dataset(dataset_name=dataset_name)\n",
+    "    client.create_examples(\n",
+    "        inputs=[{\"question\": ex[\"question\"]} for ex in examples],\n",
+    "        outputs=[{\"response\": ex[\"response\"]} for ex in examples],\n",
+    "        dataset_id=dataset.id\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. Define Application Logic to be Evaluated "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, let's define how to run our graph. Note that here we must continue past the interrupt() by supplying a Command(resume=\"\") to the graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import uuid\n",
+    "from langgraph.types import Command\n",
+    "\n",
+    "graph = multi_agent_final_graph\n",
+    "\n",
+    "async def run_graph(inputs: dict):\n",
+    "    \"\"\"Run graph and track the final response.\"\"\"\n",
+    "    # Creating configuration \n",
+    "    thread_id = uuid.uuid4()\n",
+    "    configuration = {\"thread_id\": thread_id, \"user_id\" : \"10\"}\n",
+    "\n",
+    "    # Invoke graph until interrupt \n",
+    "    result = await graph.ainvoke({\"messages\": [\n",
+    "        { \"role\": \"user\", \"content\": inputs['question']}]}, config = configuration)\n",
+    "    # Proceed from human-in-the-loop \n",
+    "    result = await graph.ainvoke(Command(resume=\"My customer ID is 10\"), config={\"thread_id\": thread_id, \"user_id\" : \"10\"})\n",
+    "    \n",
+    "    return {\"response\": result['messages'][-1].content}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Define the Evaluator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use pre-built evaluators from the `openevals` library"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openevals.llm import create_llm_as_judge\n",
+    "from openevals.prompts import CORRECTNESS_PROMPT\n",
+    "\n",
+    "# Using Open Eval pre-built \n",
+    "correctness_evaluator = create_llm_as_judge(\n",
+    "    prompt=CORRECTNESS_PROMPT,\n",
+    "    feedback_key=\"correctness\",\n",
+    "    judge=model,\n",
+    ")\n",
+    "print(CORRECTNESS_PROMPT)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also define our own evaluator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Custom definition of LLM-as-judge instructions\n",
+    "grader_instructions = \"\"\"You are a teacher grading a quiz.\n",
+    "\n",
+    "You will be given a QUESTION, the GROUND TRUTH (correct) RESPONSE, and the STUDENT RESPONSE.\n",
+    "\n",
+    "Here is the grade criteria to follow:\n",
+    "(1) Grade the student responses based ONLY on their factual accuracy relative to the ground truth answer.\n",
+    "(2) Ensure that the student response does not contain any conflicting statements.\n",
+    "(3) It is OK if the student response contains more information than the ground truth response, as long as it is factually accurate relative to the ground truth response.\n",
+    "\n",
+    "Correctness:\n",
+    "True means that the student's response meets all of the criteria.\n",
+    "False means that the student's response does not meet all of the criteria.\n",
+    "\n",
+    "Explain your reasoning in a step-by-step manner to ensure your reasoning and conclusion are correct.\"\"\"\n",
+    "\n",
+    "# LLM-as-judge output schema\n",
+    "class Grade(TypedDict):\n",
+    "    \"\"\"Compare the expected and actual answers and grade the actual answer.\"\"\"\n",
+    "    reasoning: Annotated[str, ..., \"Explain your reasoning for whether the actual response is correct or not.\"]\n",
+    "    is_correct: Annotated[bool, ..., \"True if the student response is mostly or exactly correct, otherwise False.\"]\n",
+    "\n",
+    "# Judge LLM\n",
+    "grader_llm = model.with_structured_output(Grade, method=\"json_schema\", strict=True)\n",
+    "\n",
+    "# Evaluator function\n",
+    "async def final_answer_correct(inputs: dict, outputs: dict, reference_outputs: dict) -> bool:\n",
+    "    \"\"\"Evaluate if the final response is equivalent to reference response.\"\"\"\n",
+    "    # Note that we assume the outputs has a 'response' dictionary. We'll need to make sure\n",
+    "    # that the target function we define includes this key.\n",
+    "    user = f\"\"\"QUESTION: {inputs['question']}\n",
+    "    GROUND TRUTH RESPONSE: {reference_outputs['response']}\n",
+    "    STUDENT RESPONSE: {outputs['response']}\"\"\"\n",
+    "\n",
+    "    grade = await grader_llm.ainvoke([{\"role\": \"system\", \"content\": grader_instructions}, {\"role\": \"user\", \"content\": user}])\n",
+    "    return grade[\"is_correct\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Run the Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Evaluation job and results\n",
+    "experiment_results = await client.aevaluate(\n",
+    "    run_graph,\n",
+    "    data=dataset_name,\n",
+    "    evaluators=[final_answer_correct, correctness_evaluator],\n",
+    "    experiment_prefix=\"agent-o3mini-e2e\",\n",
+    "    num_repetitions=1,\n",
+    "    max_concurrency=5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Evaluating a Single Step of the Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Agents generally perform multiple actions. While it is useful to evaluate them end-to-end, it can also be useful to evaluate these individual actions, similar to the concept of unit testing in software development. This generally involves evaluating a single step of the agent - the LLM call where it decides what to do.\n",
+    "\n",
+    "- Input: Input to a single step \n",
+    "- Output: Output of that step, which is usually the LLM response\n",
+    "![single-step](../images/single-step.png) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1. Create a Dataset for this Single Step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "examples = [\n",
+    "    {\n",
+    "        \"messages\": \"My customer ID is 1. What's my most recent purchase? and What albums does the catalog have by U2?\", \n",
+    "        \"route\": 'transfer_to_invoice_information_subagent'\n",
+    "    },\n",
+    "    {\n",
+    "        \"messages\": \"What songs do you have by U2?\", \n",
+    "        \"route\": 'transfer_to_music_catalog_subagent'\n",
+    "    },\n",
+    "    {\n",
+    "        \"messages\": \"My name is Aaron Mitchell. My number associated with my account is +1 (204) 452-6452. I am trying to find the invoice number for my most recent song purchase. Could you help me with it?\", \n",
+    "        \"route\": 'transfer_to_invoice_information_subagent'\n",
+    "    },\n",
+    "    {\n",
+    "        \"messages\": \"Who recorded Wish You Were Here again? What other albums by them do you have?\", \n",
+    "        \"route\": 'transfer_to_music_catalog_subagent'\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "\n",
+    "dataset_name = \"LangGraph 101 Multi-Agent: Single-Step\"\n",
+    "if not client.has_dataset(dataset_name=dataset_name):\n",
+    "    dataset = client.create_dataset(dataset_name=dataset_name)\n",
+    "    client.create_examples(\n",
+    "        inputs = [{\"messages\": ex[\"messages\"]} for ex in examples],\n",
+    "        outputs = [{\"route\": ex[\"route\"]} for ex in examples],\n",
+    "        dataset_id=dataset.id\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. Define the Application Logic to Evaluate "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We only need to evaluate the supervisor routing step, so let's add a breakpoint right after the supervisor step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async def run_supervisor_routing(inputs: dict):\n",
+    "    result = await supervisor_prebuilt.ainvoke(\n",
+    "        {\"messages\": [HumanMessage(content=inputs['messages'])]},\n",
+    "        interrupt_before=[\"music_catalog_subagent\", \"invoice_information_subagent\"],\n",
+    "        config={\"thread_id\": uuid.uuid4(), \"user_id\" : \"10\"}\n",
+    "    )\n",
+    "    return {\"route\": result[\"messages\"][-1].name}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Define the Evaluator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def correct(outputs: dict, reference_outputs: dict) -> bool:\n",
+    "    \"\"\"Check if the agent chose the correct route.\"\"\"\n",
+    "    return outputs['route'] == reference_outputs[\"route\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Run the Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "experiment_results = await client.aevaluate(\n",
+    "    run_supervisor_routing,\n",
+    "    data=dataset_name,\n",
+    "    evaluators=[correct],\n",
+    "    experiment_prefix=\"agent-o3mini-singlestep\",\n",
+    "    max_concurrency=5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Evaluating the Trajectory of the Agent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Evaluating an agent's trajectory involves evaluating all the steps an agent took. The evaluator here is some function over the steps taken. Examples of evaluators include an exact match for each tool name in the sequence or the number of \"incorrect\" steps taken.\n",
+    "\n",
+    "- Input: User input to the overall agent \n",
+    "- Output: A list of steps taken.\n",
+    "![trajectory](../images/trajectory.png) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1. Create a Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a dataset\n",
+    "examples = [\n",
+    "    {\n",
+    "        \"question\": \"My customer ID is 1. What's my most recent purchase? and What albums does the catalog have by U2?\",\n",
+    "        \"trajectory\": [\"verify_info\", \"load_memory\", \"supervisor\", \"create_memory\"],\n",
+    "    },\n",
+    "    {\n",
+    "        \"question\": \"What songs do you have by U2?\",\n",
+    "        \"trajectory\": [\"verify_info\", \"human_input\", \"human_input\", \"verify_info\", \"human_input\"],\n",
+    "    },\n",
+    "    {\n",
+    "        \"question\": \"My name is Aaron Mitchell. My number associated with my account is +1 (204) 452-6452. I am trying to find the invoice number for my most recent song purchase. Could you help me with it?\",\n",
+    "        \"trajectory\": [\"verify_info\", \"load_memory\", \"supervisor\", \"create_memory\"],\n",
+    "    },\n",
+    "    {\n",
+    "        \"question\": \"Who recorded Wish You Were Here again? What other albums by them do you have?\",\n",
+    "        \"trajectory\": [\"verify_info\", \"human_input\", \"human_input\", \"verify_info\", \"human_input\"],\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "dataset_name = \"LangGraph 101 Multi-Agent: Trajectory Eval\"\n",
+    "\n",
+    "if not client.has_dataset(dataset_name=dataset_name):\n",
+    "    dataset = client.create_dataset(dataset_name=dataset_name)\n",
+    "    client.create_examples(\n",
+    "        inputs=[{\"question\": ex[\"question\"]} for ex in examples],\n",
+    "        outputs=[{\"trajectory\": ex[\"trajectory\"]} for ex in examples],\n",
+    "        dataset_id=dataset.id\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. Define the Application Logic to Evaluate "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph = multi_agent_final_graph\n",
+    "\n",
+    "async def run_graph(inputs: dict) -> dict:\n",
+    "    \"\"\"Run graph and track the trajectory it takes along with the final response.\"\"\"\n",
+    "    trajectory = []\n",
+    "    thread_id = uuid.uuid4()\n",
+    "    configuration = {\"thread_id\": thread_id, \"user_id\" : \"10\"}\n",
+    "\n",
+    "    # Run until interrupt \n",
+    "    async for chunk in graph.astream({\"messages\": [\n",
+    "            {\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": inputs['question'],\n",
+    "            }\n",
+    "        ]}, config = configuration, stream_mode=\"debug\"):\n",
+    "        if chunk['type'] == 'task':\n",
+    "            trajectory.append(chunk['payload']['name'])\n",
+    "\n",
+    "    # Resume from interrupt\n",
+    "    async for chunk in graph.astream(Command(resume=\"\"), config = configuration, stream_mode=\"debug\"):\n",
+    "        if chunk['type'] == 'task':\n",
+    "            trajectory.append(chunk['payload']['name'])\n",
+    "    return {\"trajectory\": trajectory}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Define the Evaluator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate_exact_match(outputs: dict, reference_outputs: dict):\n",
+    "    \"\"\"Evaluate whether the trajectory exactly matches the expected output\"\"\"\n",
+    "    return {\n",
+    "        \"key\": \"exact_match\", \n",
+    "        \"score\": outputs[\"trajectory\"] == reference_outputs[\"trajectory\"]\n",
+    "    }\n",
+    "\n",
+    "def evaluate_extra_steps(outputs: dict, reference_outputs: dict) -> dict:\n",
+    "    \"\"\"Evaluate the number of unmatched steps in the agent's output.\"\"\"\n",
+    "    i = j = 0\n",
+    "    unmatched_steps = 0\n",
+    "\n",
+    "    while i < len(reference_outputs['trajectory']) and j < len(outputs['trajectory']):\n",
+    "        if reference_outputs['trajectory'][i] == outputs['trajectory'][j]:\n",
+    "            i += 1  # Match found, move to the next step in reference trajectory\n",
+    "        else:\n",
+    "            unmatched_steps += 1  # Step is not part of the reference trajectory\n",
+    "        j += 1  # Always move to the next step in outputs trajectory\n",
+    "\n",
+    "    # Count remaining unmatched steps in outputs beyond the comparison loop\n",
+    "    unmatched_steps += len(outputs['trajectory']) - j\n",
+    "\n",
+    "    return {\n",
+    "        \"key\": \"unmatched_steps\",\n",
+    "        \"score\": unmatched_steps,\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Run the Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "experiment_results = await client.aevaluate(\n",
+    "    run_graph,\n",
+    "    data=dataset_name,\n",
+    "    evaluators=[evaluate_extra_steps, evaluate_exact_match],\n",
+    "    experiment_prefix=\"agent-o3mini-trajectory\",\n",
+    "    num_repetitions=1,\n",
+    "    max_concurrency=4,\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/ai-agents-lab.ipynb b/notebooks/ai-agents-lab.ipynb
index 2c1d8a1..be568ca 100644
--- a/notebooks/ai-agents-lab.ipynb
+++ b/notebooks/ai-agents-lab.ipynb
@@ -568,12 +568,9 @@
       "metadata": {},
       "outputs": [],
       "source": [
+        "from utils import visualize_graph\n",
         "# Visualize the graph\n",
-        "try:\n",
-        "    display(Image(agent.get_graph().draw_mermaid_png()))\n",
-        "except Exception:\n",
-        "    # This requires some extra dependencies and is optional\n",
-        "    pass"
+        "visualize_graph(agent)"
       ]
     },
     {
diff --git a/notebooks/images/checkpoint_thread.png b/notebooks/images/checkpoint_thread.png
new file mode 100644
index 0000000..4244777
Binary files /dev/null and b/notebooks/images/checkpoint_thread.png differ
diff --git a/notebooks/images/conditional_rag.png b/notebooks/images/conditional_rag.png
new file mode 100644
index 0000000..931570d
Binary files /dev/null and b/notebooks/images/conditional_rag.png differ
diff --git a/notebooks/images/human_in_the_loop.png b/notebooks/images/human_in_the_loop.png
new file mode 100644
index 0000000..1653395
Binary files /dev/null and b/notebooks/images/human_in_the_loop.png differ
diff --git a/notebooks/images/multi_agent.png b/notebooks/images/multi_agent.png
new file mode 100644
index 0000000..2a78e99
Binary files /dev/null and b/notebooks/images/multi_agent.png differ
diff --git a/notebooks/images/multi_agent_architecture.png b/notebooks/images/multi_agent_architecture.png
new file mode 100644
index 0000000..1733578
Binary files /dev/null and b/notebooks/images/multi_agent_architecture.png differ
diff --git a/notebooks/images/server_subagent.png b/notebooks/images/server_subagent.png
new file mode 100644
index 0000000..c4844cd
Binary files /dev/null and b/notebooks/images/server_subagent.png differ
diff --git a/notebooks/langgraph_basics_agents.ipynb b/notebooks/langgraph_basics_agents.ipynb
new file mode 100644
index 0000000..3c5ea3b
--- /dev/null
+++ b/notebooks/langgraph_basics_agents.ipynb
@@ -0,0 +1,1763 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# LangGraph Basics | (RAG + Multi-Agent)\n",
+    "\n",
+    "Over the course of this notebook, we will build an agentic RAG application using LangGraph with increasing complexity. We will start with a simple RAG flow, and then add conditional branching, memory, human in the loop, and more."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![HIL](./images/human_in_the_loop.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pre-work: Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can set your environment variables locally in this notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os, json\n",
+    "from pymongo import MongoClient"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# If you are using your own MongoDB Atlas cluster, use the connection string for your cluster here\n",
+    "MONGODB_URI = os.environ.get(\"MONGODB_URI\")\n",
+    "# Initialize a MongoDB Python client\n",
+    "mongodb_client = MongoClient(MONGODB_URI)\n",
+    "# Check the connection to the server\n",
+    "mongodb_client.admin.command(\"ping\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Optional**: enable LangSmith tracing, get free API key from https://smith.langchain.com/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set environment variables\n",
+    "os.environ[\"LANGSMITH_API_KEY\"] = \"\"\n",
+    "os.environ[\"LANGSMITH_TRACING\"] = \"true\"\n",
+    "os.environ[\"LANGSMITH_PROJECT\"] = \"mongodb-genai-devday\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's confirm that LangSmith tracing is enabled. If for some reason you can't see traces showing up in LangSmith, this is a great helper command to make sure you can trace!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langsmith import utils as langsmith_utils\n",
+    "\n",
+    "os.environ.get(\"LANGCHAIN_TRACING_V2\")\n",
+    "langsmith_utils.tracing_is_enabled()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Because we're building a RAG application, we're going to create a vector database retriever containing MongoDB documentation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pick an LLM provider of your choice below"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SERVERLESS_URL = os.environ.get(\"SERVERLESS_URL\")\n",
+    "# Can be one of \"aws\", \"google\" or \"microsoft\"\n",
+    "LLM_PROVIDER = \"aws\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.load import load\n",
+    "import requests\n",
+    "\n",
+    "# Obtain the Langchain LLM object from our serverless endpoint\n",
+    "llm_dict = requests.post(\n",
+    "    url=SERVERLESS_URL, json={\"task\": \"get_llm\", \"data\": LLM_PROVIDER}\n",
+    ").json()\n",
+    "llm = load(llm_dict[\"llm\"], secrets_map=llm_dict[\"secrets_map\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define a Vector Store MongoDB Retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#  Database name\n",
+    "DB_NAME = \"mongodb_genai_devday_agents\"\n",
+    "# Name of the collection with full documents- used for summarization\n",
+    "FULL_COLLECTION_NAME = \"mongodb_docs\"\n",
+    "# Name of the collection for vector search- used for Q&A\n",
+    "VS_COLLECTION_NAME = \"mongodb_docs_embeddings\"\n",
+    "# Name of the vector search index\n",
+    "VS_INDEX_NAME = \"vector_index\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Connect to the `VS_COLLECTION_NAME` collection.\n",
+    "vs_collection = mongodb_client[DB_NAME][VS_COLLECTION_NAME]\n",
+    "# Connect to the `FULL_COLLECTION_NAME` collection.\n",
+    "full_collection = mongodb_client[DB_NAME][FULL_COLLECTION_NAME]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Insert a dataset of MongoDB docs with embeddings into the `VS_COLLECTION_NAME` collection\n",
+    "with open(f\"../data/{VS_COLLECTION_NAME}.json\", \"r\") as data_file:\n",
+    "    json_data = data_file.read()\n",
+    "\n",
+    "data = json.loads(json_data)\n",
+    "\n",
+    "print(f\"Deleting existing documents from the {VS_COLLECTION_NAME} collection.\")\n",
+    "vs_collection.delete_many({})\n",
+    "vs_collection.insert_many(data)\n",
+    "print(\n",
+    "    f\"{vs_collection.count_documents({})} documents ingested into the {VS_COLLECTION_NAME} collection.\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Insert a dataset of MongoDB documentation pages into the `FULL_COLLECTION_NAME` collection\n",
+    "with open(f\"../data/{FULL_COLLECTION_NAME}.json\", \"r\") as data_file:\n",
+    "    json_data = data_file.read()\n",
+    "\n",
+    "data = json.loads(json_data)\n",
+    "\n",
+    "print(f\"Deleting existing documents from the {FULL_COLLECTION_NAME} collection.\")\n",
+    "full_collection.delete_many({})\n",
+    "full_collection.insert_many(data)\n",
+    "print(\n",
+    "    f\"{full_collection.count_documents({})} documents ingested into the {FULL_COLLECTION_NAME} collection.\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils import create_index, check_index_ready"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create vector index definition specifying:\n",
+    "# path: Path to the embeddings field\n",
+    "# numDimensions: Number of embedding dimensions- depends on the embedding model used\n",
+    "# similarity: Similarity metric. One of cosine, euclidean, dotProduct.\n",
+    "model = {\n",
+    "    \"name\": VS_INDEX_NAME,\n",
+    "    \"type\": \"vectorSearch\",\n",
+    "    \"definition\": {\n",
+    "        \"fields\": [\n",
+    "            {\n",
+    "                \"type\": \"vector\",\n",
+    "                \"path\": \"embedding\",\n",
+    "                \"numDimensions\": 384,\n",
+    "                \"similarity\": \"cosine\",\n",
+    "            }\n",
+    "        ]\n",
+    "    },\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use the `create_index` function from the `utils` module to create a vector search index with the above definition for the `vs_collection` collection\n",
+    "create_index(vs_collection, VS_INDEX_NAME, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use the `check_index_ready` function from the `utils` module to verify that the index was created and is in READY status before proceeding\n",
+    "check_index_ready(vs_collection, VS_INDEX_NAME)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sentence_transformers import SentenceTransformer\n",
+    "\n",
+    "# Load the `gte-small` model using the Sentence Transformers library\n",
+    "embedding_model = SentenceTransformer(\"thenlper/gte-small\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "# Define a function that takes a piece of text (`text`) as input, embeds it using the `embedding_model` instantiated above and returns the embedding as a list\n",
+    "# An array can be converted to a list using the `tolist()` method\n",
+    "def get_embedding(text: str) -> List[float]:\n",
+    "    \"\"\"\n",
+    "    Generate the embedding for a piece of text.\n",
+    "\n",
+    "    Args:\n",
+    "        text (str): Text to embed.\n",
+    "\n",
+    "    Returns:\n",
+    "        List[float]: Embedding of the text as a list.\n",
+    "    \"\"\"\n",
+    "    embedding = embedding_model.encode(text)\n",
+    "    return embedding.tolist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema import Document\n",
+    "\n",
+    "def get_information_for_question_answering(user_query: str) -> str:\n",
+    "    \"\"\"\n",
+    "    Retrieve information using vector search to answer a user query.\n",
+    "\n",
+    "    Args:\n",
+    "    user_query (str): The user's query string.\n",
+    "\n",
+    "    Returns:\n",
+    "    str: The retrieved information formatted as a string.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Generate embedding for the `user_query` using the `get_embedding` function defined above\n",
+    "    query_embedding = get_embedding(user_query)\n",
+    "\n",
+    "    # Define an aggregation pipeline consisting of a $vectorSearch stage, followed by a $project stage\n",
+    "    # Set the number of candidates to 150 and only return the top 5 documents from the vector search\n",
+    "    # In the $project stage, exclude the `_id` field and include only the `body` field and `vectorSearchScore`\n",
+    "    # NOTE: Use variables defined previously for the `index`, `queryVector` and `path` fields in the $vectorSearch stage\n",
+    "    pipeline = [\n",
+    "        {\n",
+    "            \"$vectorSearch\": {\n",
+    "                \"index\": VS_INDEX_NAME,\n",
+    "                \"path\": \"embedding\",\n",
+    "                \"queryVector\": query_embedding,\n",
+    "                \"numCandidates\": 150,\n",
+    "                \"limit\": 5,\n",
+    "            }\n",
+    "        },\n",
+    "        {\n",
+    "            \"$project\": {\n",
+    "                \"_id\": 0,\n",
+    "                \"body\": 1,\n",
+    "                \"score\": {\"$meta\": \"vectorSearchScore\"},\n",
+    "            }\n",
+    "        },\n",
+    "    ]\n",
+    "\n",
+    "    # Execute the aggregation `pipeline` against the `vs_collection` collection and store the results in `results`\n",
+    "    results = vs_collection.aggregate(pipeline)\n",
+    "    # create a list of Document objects from the results\n",
+    "    docs = [Document(page_content=doc.get(\"body\"), metadata={\"score\": doc.get(\"score\")}) for doc in results]\n",
+    "    return docs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pre-work: Background Concepts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Feel free to skip this section if you're already familiar with the LangChain ChatModel and Messages concepts.\n",
+    "\n",
+    "In this course, we'll be using [Chat Models](https://python.langchain.com/v0.2/docs/concepts/#chat-models), which take a sequence of messages as inputs and return chat messages as outputs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Chat models in LangChain have a number of [default methods](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface). For now we'll use `invoke`, which call the model on an input.\n",
+    "\n",
+    "Chat models take [messages](https://python.langchain.com/v0.2/docs/concepts/#messages) as input. LangChain supports various message types, including `HumanMessage`, `AIMessage`, `SystemMessage`, and `ToolMessage`. Let's create a list of messages. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import AIMessage, HumanMessage\n",
+    "\n",
+    "# Some sample messages about orcas\n",
+    "messages = [AIMessage(content=f\"So you said you were researching ocean mammals?\", name=\"Model\")]\n",
+    "messages.append(HumanMessage(content=f\"Yes, that's right.\",name=\"Marco\"))\n",
+    "messages.append(AIMessage(content=f\"Great, what would you like to learn about.\", name=\"Model\"))\n",
+    "messages.append(HumanMessage(content=f\"I want to learn about the best place to see Orcas in the US.\", name=\"Marco\"))\n",
+    "\n",
+    "for m in messages:\n",
+    "    m.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The ChatModel interface is consistent across all chat models and models are typically initialized once at the start up each notebooks. The benefit here is that you can easily switch between models without changing the downstream code if you have strong preference for another provider.\n",
+    "\n",
+    "Let's run our ChatModel on these Messages now!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm.invoke(messages)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 1: LangGraph Basics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![Simple RAG](./images/simple_rag.png)\n",
+    "\n",
+    "We're going to set up a simple RAG workflow while introducing several LangGraph concepts. We're then going to step into LangSmith and see how it can help us while we iterate on our application"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### State"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Great, now that we've tested out our ChatModel on some Messages let's start learning about some of our Agent primitives. Our first concept is [State](https://langchain-ai.github.io/langgraph/concepts/low_level/#state).\n",
+    "\n",
+    "State is one of the most important concepts in an Agent. When defining a Graph, you must pass in a schema for State. The State schema serves as the input schema for all Nodes and Edges in the graph. Let's use the `TypedDict` class from python's `typing` module as our schema, which provides type hints for the keys. \n",
+    "\n",
+    "The State of our RAG application will keep track of the user's question, our RAG app's LLM generated response, and the list of retrieved relevant documents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema import Document\n",
+    "from typing import List\n",
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "class State(TypedDict):\n",
+    "    \"\"\"\n",
+    "    Attributes:\n",
+    "        question: The user's question\n",
+    "        generation: The LLM's generation\n",
+    "        documents: List of helpful documents retrieved by the RAG pipeline\n",
+    "    \"\"\"\n",
+    "    question: str\n",
+    "    generation: str\n",
+    "    documents: List[Document]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Nodes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Nodes](https://langchain-ai.github.io/langgraph/concepts/low_level/#nodes) are just python functions. As mentioned above, Nodes take in your graph's State as input. \n",
+    "\n",
+    "The first positional argument is the state, as defined above.\n",
+    "\n",
+    "Because the state is a `TypedDict` with schema as defined above, each node can access each key in the state, in our case, we could use `state[\"question\"]`.\n",
+    "  \n",
+    "Nodes return any updates to the state that they want to make. By default, the new value returned by each node will override the prior state value. You can implement custom handling for updates to State using State Reducers, which we will see later in the session.\n",
+    "\n",
+    "Here, we're going to set up two nodes for our RAG flow:\n",
+    "1. retrieve_documents: Retrieves documents from our vector store\n",
+    "2. generate_response: Generates an answer from our documents"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "def retrieve_documents(state: State):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        state (dict): The current graph state\n",
+    "    Returns:\n",
+    "        state (dict): New key added to state, documents, that contains retrieved documents\n",
+    "    \"\"\"\n",
+    "    print(\"---RETRIEVE DOCUMENTS---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = get_information_for_question_answering(question)\n",
+    "    return {\"documents\": documents}\n",
+    "\n",
+    "RAG_PROMPT = \"\"\"You are an assistant for question-answering tasks. \n",
+    "Use the following pieces of retrieved context to answer the question. \n",
+    "If you don't know the answer, just say that you don't know. \n",
+    "Use three sentences maximum and keep the answer concise.\n",
+    "\n",
+    "Question: {question} \n",
+    "Context: {context} \n",
+    "Answer:\"\"\"\n",
+    "\n",
+    "def generate_response(state: State):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        state (dict): The current graph state\n",
+    "    Returns:\n",
+    "        state (dict): New key added to state, generation, that contains LLM generation\n",
+    "    \"\"\"\n",
+    "    print(\"---GENERATE RESPONSE---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = state[\"documents\"]\n",
+    "    formatted_docs = \"\\n\\n\".join(doc.page_content for doc in documents)\n",
+    "    \n",
+    "    # Invoke our LLM with our RAG prompt\n",
+    "    rag_prompt_formatted = RAG_PROMPT.format(context=formatted_docs, question=question)\n",
+    "    generation = llm.invoke([HumanMessage(content=rag_prompt_formatted)])\n",
+    "    return {\"generation\": generation}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Edges"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Edges](https://langchain-ai.github.io/langgraph/concepts/low_level/#edges) define how your agentic applications progresses from each Node to the next Node.\n",
+    "- Normal Edges are used if you want to *always* go from, for example, `node_1` to `node_2`.\n",
+    "- [Conditional Edges](https://langchain-ai.github.io/langgraph/reference/graphs/?h=conditional+edge#langgraph.graph.StateGraph.add_conditional_edges) are used want to *optionally* route between nodes.\n",
+    " \n",
+    "Conditional edges are implemented as functions that return the next node to visit based upon some logic. Note that these functions often use values from our graph's State to determine how to traverse.\n",
+    "\n",
+    "We'll add some useful conditional edges later, but for now let's take a look at an example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Literal\n",
+    "\n",
+    "def conditional_edge_example(state) -> Literal[\"node_1\", \"node_2\"]:\n",
+    "    # Often, we will use state to decide on the next node to visit\n",
+    "    field_1 = state['field_1'] \n",
+    "    field_2 = state['field_2']\n",
+    "    if field_1 > field_2:\n",
+    "        return \"node_1\"\n",
+    "    return \"node_2\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Great! We now have defined the schema for our State, written logic for two Nodes, and learned about Edges. Let's stitch those components together to define our simple RAG graph\n",
+    "\n",
+    "First, we instantiate a graph builder with our State. The [StateGraph class](https://langchain-ai.github.io/langgraph/concepts/low_level/#stategraph) is the graph class that we can use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph\n",
+    "graph_builder = StateGraph(State)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we add our two defined nodes to our Graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph_builder.add_node(\"retrieve_documents\", retrieve_documents)\n",
+    "graph_builder.add_node(\"generate_response\", generate_response)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then define the shape of our graph by adding edges between the nodes.\n",
+    "\n",
+    "We use the [`START` Node, a special node](https://langchain-ai.github.io/langgraph/concepts/low_level/#start-node) that sends user input to the graph, to indicate where to start our graph.\n",
+    " \n",
+    "The [`END` Node](https://langchain-ai.github.io/langgraph/concepts/low_level/#end-node) is a special node that represents a terminal node. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import START, END\n",
+    "\n",
+    "graph_builder.add_edge(START, \"retrieve_documents\")\n",
+    "graph_builder.add_edge(\"retrieve_documents\", \"generate_response\")\n",
+    "graph_builder.add_edge(\"generate_response\", END)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we [compile our graph](https://langchain-ai.github.io/langgraph/concepts/low_level/#compiling-your-graph) to perform a few basic checks on the graph structure. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils import visualize_graph\n",
+    "simple_rag_graph = graph_builder.compile()\n",
+    "\n",
+    "visualize_graph(simple_rag_graph)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Running our Graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that our graph is defined, let's invoke it!\n",
+    "\n",
+    "The compiled graph implements the [runnable](https://python.langchain.com/v0.1/docs/expression_language/interface/) protocol. This provides a standard way to execute LangChain components. `invoke` is one of the standard methods in this interface.\n",
+    "\n",
+    "The input is a dictionary `{\"question\": \"What is MongoDB used for?\"}`, which sets the initial value for our graph's state dictionary. Note that we didn't need to pass in all of the keys of our dictionary.\n",
+    "\n",
+    "Our graph executes as follows:\n",
+    "1. When `invoke` is called, the graph starts execution from the `START` node.\n",
+    "2. It progresses to `retrieve_documents` and invokes our retriever on the `question` defined in our State. It then writes the retrieved `documents` to State.\n",
+    "3. It progresses to `generate_response` and makes an LLM call to generate an answer, using our retrieved `documents`.\n",
+    "4. Finally, it progresses to the `END` node.\n",
+    "\n",
+    "Each node function receives the current state and returns a new value, which overrides the graph state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What are some best practices for data backups in MongoDB?\"\n",
+    "simple_rag_graph.invoke({\"question\": question})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Congrats on running your first LangGraph application! `invoke` runs the entire graph synchronously. This waits for each step to complete before moving to the next. It returns the final state of the graph after all nodes have executed, which is what we see above.\n",
+    "\n",
+    "Let's take a look in LangSmith!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 2: Control Flow with Conditional Edges"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "![Corrective RAG](./images/conditional_rag.png)\n",
+    "\n",
+    "In this section, we're going to add a few techniques that can improve our RAG workflow. Specifically, we'll introduce\n",
+    "- Document Grading: Are the documents fetched by the retriever actually relevant to the user's question?\n",
+    "\n",
+    "We're also going to add some constraints to the inputs and outputs of our application for the best user experience.\n",
+    "\n",
+    "By the end of this section, we'll have a more complex corrective RAG workflow! Then, we'll hop into LangSmith and walk through how we can evaluate that our application is actually improving as we add new techniques."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Structured Outputs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some LLMs provide support for Structured Outputs, which provides a typing guarantee for the output schema of the LLM's response. Here, we can use BaseModel from pydantic to define a specific return type. The provided description helps the LLM generate the value for the field.\n",
+    "\n",
+    "We can hook this up to our previously defined `llm` using `with_structured_output`. Now, when we invoke our `grade_documents_llm`, we can expect the returned object to contain the expected field."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel, Field\n",
+    "\n",
+    "class GradeDocuments(BaseModel):\n",
+    "    is_relevant: bool = Field(\n",
+    "        description=\"The document is relevant to the question, true or false\"\n",
+    "    )\n",
+    "\n",
+    "grade_documents_llm = llm.with_structured_output(GradeDocuments)\n",
+    "grade_documents_system_prompt = \"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n",
+    "    If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n",
+    "    It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \\n\n",
+    "    Give a binary score true or false to indicate whether the document is relevant to the question.\"\"\"\n",
+    "grade_documents_prompt = \"Here is the retrieved document: \\n\\n {document} \\n\\n Here is the user question: \\n\\n {question}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import SystemMessage\n",
+    "\n",
+    "def grade_documents(state):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        state (dict): The current graph state\n",
+    "    Returns:\n",
+    "        state (dict): Updates documents key with only filtered relevant documents\n",
+    "    \"\"\"\n",
+    "    print(\"---GRADE DOCUMENTS---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = state[\"documents\"]\n",
+    "    # Score each doc\n",
+    "    filtered_docs = []\n",
+    "    for d in documents:\n",
+    "        grade_documents_prompt_formatted = grade_documents_prompt.format(document=d.page_content, question=question)\n",
+    "        score = grade_documents_llm.invoke(\n",
+    "            [SystemMessage(content=grade_documents_system_prompt)] + [HumanMessage(content=grade_documents_prompt_formatted)]\n",
+    "        )\n",
+    "        grade = score.is_relevant\n",
+    "        if grade:\n",
+    "            print(\"---GRADE: DOCUMENT RELEVANT---\")\n",
+    "            filtered_docs.append(d)\n",
+    "        else:\n",
+    "            print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n",
+    "            continue\n",
+    "    return {\"documents\": filtered_docs}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's make sure that at least some documents are relevant if we are going to respond to the user! To do this, we need to add a conditional edge. Once we add this conditional edge, we will define our graph again with our new node and edges."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def decide_to_generate(state):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        state (dict): The current graph state\n",
+    "    Returns:\n",
+    "        str: Binary decision for next node to call\n",
+    "    \"\"\"\n",
+    "    print(\"---ASSESS GRADED DOCUMENTS---\")\n",
+    "    filtered_documents = state[\"documents\"]\n",
+    "\n",
+    "    if not filtered_documents:\n",
+    "        print(\n",
+    "            \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, END---\"\n",
+    "        )\n",
+    "        return \"none relevant\"\n",
+    "    else:\n",
+    "        # We have relevant documents, so generate answer\n",
+    "        print(\"---DECISION: GENERATE---\")\n",
+    "        return \"some relevant\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's put our graph together!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.graph import StateGraph\n",
+    "from langgraph.graph import START, END\n",
+    "\n",
+    "graph_builder = StateGraph(State)\n",
+    "graph_builder.add_node(\"retrieve_documents\", retrieve_documents)\n",
+    "graph_builder.add_node(\"generate_response\", generate_response)\n",
+    "graph_builder.add_node(\"grade_documents\", grade_documents)    # new node!\n",
+    "graph_builder.add_edge(START, \"retrieve_documents\")\n",
+    "graph_builder.add_edge(\"retrieve_documents\", \"grade_documents\")    # edited edge\n",
+    "graph_builder.add_conditional_edges(    # new conditional edge\n",
+    "    \"grade_documents\",\n",
+    "    decide_to_generate,\n",
+    "    {\n",
+    "        \"some relevant\": \"generate_response\",\n",
+    "        \"none relevant\": END\n",
+    "    })\n",
+    "graph_builder.add_edge(\"generate_response\", END)\n",
+    "\n",
+    "document_grading_graph = graph_builder.compile()\n",
+    "visualize_graph(document_grading_graph)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's try to invoke our graph again, this time with a question about something totally irrelevant, like pokemon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What is your favorite pokemon?\"\n",
+    "document_grading_graph.invoke({\"question\": question})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 3: Memory and Human-in-the-Loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Short Term Memory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In every example so far, [state has been transient](https://github.com/langchain-ai/langgraph/discussions/352#discussioncomment-9291220) to a single graph execution. If we invoke our graph for a second time, we are starting with a fresh state. This limits our ability to have multi-turn conversations with interruptions. \n",
+    "\n",
+    "We can use [persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence/) to address this! \n",
+    " \n",
+    "LangGraph can use a checkpointer to automatically save the graph state after each step. This built-in persistence layer gives us memory, allowing LangGraph to pick up from the last state update. \n",
+    "\n",
+    "Before we set up memory in our application, let's edit our State and Nodes so that instead of acting a single \"question\", we instead act on a list of \"questions and answers\".\n",
+    "\n",
+    "We'll call our list \"messages\". These existing messages will all be used for our retrieval step. And at the end of our flow when our LLM responds, we will add the latest question and answer to our \"messages\" history. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![breakpoints.jpg](https://cdn.prod.website-files.com/65b8cd72835ceeacd4449a53/66dbae7985b747dfed67775d_breakpoints1.png)\n",
+    "\n",
+    "In this section, we'll talk about the different types of memory in LangGraph, and how we can use them to enable HIL workflows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import get_buffer_string\n",
+    "from langgraph.graph.message import AnyMessage, add_messages\n",
+    "from langgraph.managed.is_last_step import RemainingSteps\n",
+    "from typing import List\n",
+    "from typing_extensions import Annotated\n",
+    "\n",
+    "class State(TypedDict):\n",
+    "    question: str\n",
+    "    messages: Annotated[List[AnyMessage], add_messages]     # We now track a list of messages\n",
+    "    documents: List[Document]\n",
+    "    remaining_steps: RemainingSteps  # This is a special field that is used to track the remaining steps in the graph\n",
+    "    # We removed generation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's edit our existing Nodes to use `messages` in addition to `question`, specifically for grading document relevance, and generating a response."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grade_documents_system_prompt = \"\"\"You are a grader assessing relevance of a retrieved document to a conversation between a user and an AI assistant, and user's latest question. \\n \n",
+    "    If the document contains keyword(s) or semantic meaning related to the user question, definitely grade it as relevant. \\n\n",
+    "    It does not need to be a stringent test. The goal is to filter out erroneous retrievals that are not relevant at all. \\n\n",
+    "    Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\"\n",
+    "grade_documents_prompt = \"Here is the retrieved document: \\n\\n {document} \\n\\n Here is the conversation so far: \\n\\n {conversation} \\n\\n Here is the user question: \\n\\n {question}\"\n",
+    "def grade_documents(state):\n",
+    "    print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = state[\"documents\"]\n",
+    "    conversation = get_buffer_string(state[\"messages\"])\n",
+    "\n",
+    "    filtered_docs = []\n",
+    "    for d in documents:\n",
+    "        grade_documents_prompt_formatted = grade_documents_prompt.format(document=d.page_content, question=question, conversation=conversation)\n",
+    "        score = grade_documents_llm.invoke(\n",
+    "            [SystemMessage(content=grade_documents_system_prompt)] + [HumanMessage(content=grade_documents_prompt_formatted)]\n",
+    "        )\n",
+    "        grade = score.is_relevant\n",
+    "        if grade:\n",
+    "            print(\"---GRADE: DOCUMENT RELEVANT---\")\n",
+    "            filtered_docs.append(d)\n",
+    "        else:\n",
+    "            print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n",
+    "            continue\n",
+    "    return {\"documents\": filtered_docs}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RAG_PROMPT_WITH_CHAT_HISTORY = \"\"\"You are an assistant for question-answering tasks. \n",
+    "Use the following pieces of retrieved context to answer the latest question in the conversation. \n",
+    "If you don't know the answer, just say that you don't know. \n",
+    "The pre-existing conversation may provide important context to the question.\n",
+    "Use three sentences maximum and keep the answer concise.\n",
+    "\n",
+    "Existing Conversation:\n",
+    "{conversation}\n",
+    "\n",
+    "Latest Question:\n",
+    "{question}\n",
+    "\n",
+    "Additional Context from Documents:\n",
+    "{context} \n",
+    "\n",
+    "Answer:\"\"\"\n",
+    "\n",
+    "def generate_response(state: State):\n",
+    "    print(\"---GENERATE RESPONSE---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = state[\"documents\"]\n",
+    "    conversation = get_buffer_string(state[\"messages\"])\n",
+    "    formatted_docs = \"\\n\\n\".join(doc.page_content for doc in documents)\n",
+    "    \n",
+    "    # RAG generation\n",
+    "    rag_prompt_formatted = RAG_PROMPT_WITH_CHAT_HISTORY.format(context=formatted_docs, conversation=conversation, question=question)\n",
+    "    generation = llm.invoke([HumanMessage(content=rag_prompt_formatted)])\n",
+    "    return {\n",
+    "        \"messages\": [HumanMessage(content=question), generation],   # Add generation to our messages_list\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Local Memory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Cool, now let's define our graph and add some local memory!\n",
+    "\n",
+    "One of the easiest to work with is `MemorySaver`, an in-memory key-value store for Graph state.\n",
+    "\n",
+    "All we need to do is compile the graph with a checkpointer, and our graph has memory!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define our graph\n",
+    "graph_builder = StateGraph(State)\n",
+    "graph_builder.add_node(\"retrieve_documents\", retrieve_documents)\n",
+    "graph_builder.add_node(\"generate_response\", generate_response)\n",
+    "graph_builder.add_node(\"grade_documents\", grade_documents)\n",
+    "\n",
+    "graph_builder.add_edge(START, \"retrieve_documents\")\n",
+    "graph_builder.add_edge(\"retrieve_documents\", \"grade_documents\")\n",
+    "graph_builder.add_conditional_edges(\n",
+    "    \"grade_documents\",\n",
+    "    decide_to_generate,\n",
+    "    {\n",
+    "        \"some relevant\": \"generate_response\",\n",
+    "        \"none relevant\": END\n",
+    "    })\n",
+    "\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "memory = MemorySaver()\n",
+    "\n",
+    "graph = graph_builder.compile(checkpointer=memory)\n",
+    "visualize_graph(graph)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### MongoDB Checkpointer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's use `MongoDBSaver` to persist the state of our graph in the MongoDB database."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![Checkpoint Thread](./images/checkpoint_thread.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.checkpoint.mongodb import MongoDBSaver\n",
+    "\n",
+    "# Initialize a MongoDB checkpointer\n",
+    "mongodb_saver = MongoDBSaver(mongodb_client)\n",
+    "\n",
+    "graph = graph_builder.compile(checkpointer=mongodb_saver)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Threads"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When we use memory, we need to specify a `thread_id`.\n",
+    "\n",
+    "This `thread_id` will store our collection of graph states.\n",
+    "\n",
+    "* The checkpointer write the state at every step of the graph\n",
+    "* These checkpoints are saved in a thread \n",
+    "* We can access that thread in the future using the `thread_id`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import uuid\n",
+    "thread_id = str(uuid.uuid4())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "question = \"What are some best practices for data backups in MongoDB?\"\n",
+    "response = graph.invoke({\"question\": question}, config)\n",
+    "print(response)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's ask a follow-up with the same thread_id!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "question = \"What data format do you support?\"\n",
+    "response = graph.invoke({\"question\": question}, config)\n",
+    "for m in response[\"messages\"]:\n",
+    "    m.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Human-in-the-Loop and \"Command\" module"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![HIL](./images/human_in_the_loop.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, let's talk about the motivations for human-in-the-loop:\n",
+    "\n",
+    "1. **Approval** - We can interrupt our agent, surface state to a user, and allow the user to accept an action\n",
+    "2. **Review and Edit** - You can view the state and edit it if necessary\n",
+    "\n",
+    "LangGraph offers several ways to get or update agent state to support various human-in-the-loop workflows. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Today, we'll focus on `interrupt()`\n",
+    "\n",
+    "When building human-in-the-loop into Python programs, one common way to do this is with the input function. With this, your program pauses, a text box pops up in your terminal, and whatever you type is then used as the response to that function. You use it like the below:\n",
+    "\n",
+    "`response = input(\"Your question here\")`\n",
+    "\n",
+    "We’ve tried to emulate this developer experience by adding a new function to LangGraph: interrupt. You can use this in much the same way as input:\n",
+    "\n",
+    "`response = interrupt(\"Your question here\")`\n",
+    "\n",
+    "This is designed to work in production settings. When you do this, it will pause execution of the graph, mark the thread you are running as interrupted, and put whatever you passed as an input to interrupt into the persistence layer. This way, you can check the thread status, see that it’s interrupted, check the message, and then based on that invoke the graph again (in a special way) to pass your response back in:\n",
+    "\n",
+    "`graph.invoke(Command(resume=\"Your response here\"), thread)`\n",
+    "\n",
+    "Note that it doesn’t function exactly the same as input (it reruns any work in that node done before this is called, but no previous nodes). This ensures interrupted threads don’t take up any resources (beyond storage space), and can be resumed many months later, on a different machine, etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As an example, let's add an interrupt step before we generate a response. We can use this opportunity view our state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.types import interrupt, Command\n",
+    "\n",
+    "def generate_response(state: State):\n",
+    "    # We interrupt the graph, and ask the user for some additional context\n",
+    "    additional_context = interrupt(\"Do you have anything else to add that you think is relevant?\")\n",
+    "    print(\"---GENERATE RESPONSE---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = state[\"documents\"]\n",
+    "    # For simplicity, we'll just append the additional context to the conversation history\n",
+    "    conversation = get_buffer_string(state[\"messages\"]) + additional_context\n",
+    "    formatted_docs = \"\\n\\n\".join(doc.page_content for doc in documents)\n",
+    "    \n",
+    "    rag_prompt_formatted = RAG_PROMPT_WITH_CHAT_HISTORY.format(context=formatted_docs, conversation=conversation, question=question)\n",
+    "    generation = llm.invoke([HumanMessage(content=rag_prompt_formatted)])\n",
+    "    return {\n",
+    "        \"messages\": [HumanMessage(content=question), generation],\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define our graph\n",
+    "graph_builder = StateGraph(State)\n",
+    "graph_builder.add_node(\"retrieve_documents\", retrieve_documents)\n",
+    "graph_builder.add_node(\"generate_response\", generate_response)\n",
+    "graph_builder.add_node(\"grade_documents\", grade_documents)\n",
+    "\n",
+    "graph_builder.add_edge(START, \"retrieve_documents\")\n",
+    "graph_builder.add_edge(\"retrieve_documents\", \"grade_documents\")\n",
+    "graph_builder.add_conditional_edges(\n",
+    "    \"grade_documents\",\n",
+    "    decide_to_generate,\n",
+    "    {\n",
+    "        \"some relevant\": \"generate_response\",\n",
+    "        \"none relevant\": END\n",
+    "    })\n",
+    "\n",
+    "\n",
+    "graph = graph_builder.compile(checkpointer=mongodb_saver)\n",
+    "# visualize_graph(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thread_id_3 = str(uuid.uuid4())\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id_3}}\n",
+    "question = \"What are some best practices for data backups in MongoDB?\"\n",
+    "graph.invoke({\"question\": question}, config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Cool! Our graph has been interrupted! \n",
+    "\n",
+    "We can get the state and look at the next node to call."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = graph.get_state(config)\n",
+    "state.next"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we'll introduce a nice trick. In order to resume the graph's execution, we can invoke the graph with an input `Command`.\n",
+    "\n",
+    "`Command` is a special type that when returned from a node specifies not only the update to the state (as usual) but also which node to go to next. This allows nodes to more directly control which nodes are executed after-the-fact. We can use it to resume the graph's execution after an interrupt!\n",
+    "\n",
+    "`graph.invoke(Command(resume=\"Your response here\"), thread)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph.invoke(Command(resume=\"I am using MongoDB Atlas\"), config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We quickly added a human in the loop to our graph using `interrupt()` and `Command`!\n",
+    "\n",
+    "`Command` can be used, as a replacement of conditional edges, inside nodes as well!\n",
+    "Let's incorporate the conditional edge logic inside the `grade_documents` node."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def grade_documents(state: State) -> Command[Literal[\"generate_response\", \"__end__\"]]: # the return type is needed to visualize the connections in the graph\n",
+    "    print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n",
+    "    question = state[\"question\"]\n",
+    "    documents = state[\"documents\"]\n",
+    "    conversation = get_buffer_string(state[\"messages\"])\n",
+    "\n",
+    "    filtered_docs = []\n",
+    "    for d in documents:\n",
+    "        grade_documents_prompt_formatted = grade_documents_prompt.format(document=d.page_content, question=question, conversation=conversation)\n",
+    "        score = grade_documents_llm.invoke(\n",
+    "            [SystemMessage(content=grade_documents_system_prompt)] + [HumanMessage(content=grade_documents_prompt_formatted)]\n",
+    "        )\n",
+    "        grade = score.is_relevant\n",
+    "        if grade:\n",
+    "            print(\"---GRADE: DOCUMENT RELEVANT---\")\n",
+    "            filtered_docs.append(d)\n",
+    "        else:\n",
+    "            print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n",
+    "            continue\n",
+    "    \n",
+    "    # Add new Command logic to route to the next node\n",
+    "    if len(filtered_docs) > 0:\n",
+    "        return Command(\n",
+    "            # state update\n",
+    "            update={\"documents\": filtered_docs},\n",
+    "            # control flow\n",
+    "            goto=\"generate_response\"\n",
+    "        )\n",
+    "        \n",
+    "    return Command(\n",
+    "                # state update\n",
+    "                update={\n",
+    "                    \"documents\": filtered_docs,\n",
+    "                    \"messages\": [HumanMessage(content=\"No relevant documents found\")]\n",
+    "                },\n",
+    "                # control flow\n",
+    "                goto=END\n",
+    "            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define our graph\n",
+    "graph_builder = StateGraph(State)\n",
+    "graph_builder.add_node(\"retrieve_documents\", retrieve_documents)\n",
+    "graph_builder.add_node(\"generate_response\", generate_response)\n",
+    "graph_builder.add_node(\"grade_documents\", grade_documents)\n",
+    "\n",
+    "graph_builder.add_edge(START, \"retrieve_documents\")\n",
+    "graph_builder.add_edge(\"retrieve_documents\", \"grade_documents\")\n",
+    "# We removed the conditional edge\n",
+    "\n",
+    "\n",
+    "graph = graph_builder.compile(\n",
+    "    name=\"mongodb_rag_pipeline\",\n",
+    "    checkpointer=mongodb_saver)\n",
+    "visualize_graph(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thread_id_4 = str(uuid.uuid4())\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id_4}}\n",
+    "question = \"What are some best practices for data backups in MongoDB?\"\n",
+    "graph.invoke({\"question\": question}, config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph.invoke(Command(resume=\"Nothing else to add.\"), config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.2. Building ReAct Agent using LangGraph Pre-built"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "LangGraph offers pre-built libraries for common architectures, allowing us to quickly create architectures like ReAct or multi-agent architacture. A full list of pre-built libraries can be found here: https://langchain-ai.github.io/langgraph/prebuilt/#available-libraries \n",
+    "\n",
+    "In the last workflow, we have seen how we can build a ReAct agent from scratch. Now, we will show how we can leverage the LangGraph pre-built libraries to achieve similar results. \n",
+    "\n",
+    "![react_2](./images/server_subagent.png)\n",
+    "\n",
+    "Our **MongoDB server subagent** is responsible for all customer queries related to the invoices. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Defining tools and prompt\n",
+    "Similarly, let's first define a set of tools and our agent prompt below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.tools import tool\n",
+    "\n",
+    "@tool\n",
+    "def get_mongodb_server_info() -> dict:\n",
+    "    \"\"\"\n",
+    "    Retrieve metadata about the connected MongoDB server instance.\n",
+    "\n",
+    "    This includes version, storage engines, JavaScript engine, and system-level information.\n",
+    "    Useful for diagnostics or understanding server capabilities.\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: MongoDB server information such as version, build, and supported features.\n",
+    "    \"\"\"\n",
+    "    return mongodb_client.server_info()\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def list_all_mongodb_databases() -> list[str]:\n",
+    "    \"\"\"\n",
+    "    List all available databases in the connected MongoDB server.\n",
+    "\n",
+    "    Use this tool to discover valid database names that can then be passed to other tools\n",
+    "    such as `list_collections_in_database`.\n",
+    "\n",
+    "    Returns:\n",
+    "        list[str]: Names of all accessible MongoDB databases.\n",
+    "    \"\"\"\n",
+    "    return mongodb_client.list_database_names()\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def list_collections_in_database(database_name: str) -> dict:\n",
+    "    \"\"\"\n",
+    "    Retrieve all collections and database-level statistics for a specified MongoDB database.\n",
+    "\n",
+    "    This tool combines collection metadata and stats into one response. Use it after calling\n",
+    "    `list_all_mongodb_databases` to ensure the database name is valid.\n",
+    "\n",
+    "    Args:\n",
+    "        database_name (str): The name of the MongoDB database to inspect.\n",
+    "\n",
+    "    Returns:\n",
+    "        dict: A dictionary containing:\n",
+    "            - 'database': The name of the database.\n",
+    "            - 'collections': A list of collection names in the database.\n",
+    "            - 'stats': A dictionary with metrics like object count, storage size, index size, etc.\n",
+    "    \"\"\"\n",
+    "    db = mongodb_client[database_name]\n",
+    "    collections = db.list_collection_names()\n",
+    "    stats = db.command(\"dbstats\")\n",
+    "    return {\n",
+    "        \"database\": database_name,\n",
+    "        \"collections\": collections,\n",
+    "        \"stats\": stats\n",
+    "    }\n",
+    "\n",
+    "mongodb_tools = [\n",
+    "    get_mongodb_server_info,\n",
+    "    list_all_mongodb_databases,\n",
+    "    list_collections_in_database\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mongodb_subagent_prompt = \"\"\"\n",
+    "    You are a subagent among a team of assistants. You are specialized in retrieving and interpreting MongoDB metadata and structural information. You are routed for questions specifically related to MongoDB server info, database exploration, and collection listings — only respond to those.\n",
+    "\n",
+    "    You have access to three tools. These tools enable you to inspect the structure and capabilities of the connected MongoDB instance. Here are the tools:\n",
+    "    - get_mongodb_server_info: This tool retrieves server-level information such as version, storage engines, and system details.\n",
+    "    - list_all_mongodb_databases: This tool lists all available databases in the MongoDB instance.\n",
+    "    - list_collections_in_database: This tool retrieves both the list of collections and database statistics for a specified database.\n",
+    "\n",
+    "    If the information is not available or an error occurs, inform the user clearly and ask if they would like to try a different query or database.\n",
+    "\n",
+    "    CORE RESPONSIBILITIES:\n",
+    "    - Retrieve and summarize MongoDB server information for diagnostic or overview purposes\n",
+    "    - Help users explore available databases and their internal structure (collections and stats)\n",
+    "    - Combine data from multiple sources to provide a clear view of how MongoDB is organized\n",
+    "    - Always maintain a professional, informative, and helpful tone\n",
+    "    - You always need to provide a summary of the information you have retrieved.\n",
+    "\n",
+    "    You may have additional context that you should use to help answer the user's query. It will be provided to you below:\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Using the pre-built library\n",
+    "Now, let's put them together by using the pre-built ReAct agent library"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "# Define the subagent\n",
+    "mongodb_server_subagent = create_react_agent(\n",
+    "    llm,\n",
+    "    tools=mongodb_tools,\n",
+    "    name=\"mongodb_server_subagent\",\n",
+    "    prompt=mongodb_subagent_prompt,\n",
+    "    state_schema=State,\n",
+    "    checkpointer=mongodb_saver,\n",
+    ")\n",
+    "\n",
+    "# Visualize the graph\n",
+    "visualize_graph(mongodb_server_subagent)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Testing!\n",
+    "Let's try our new agent out!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thread_id = uuid.uuid4()\n",
+    "question = \"List me the available databases and the collections for the mongodb devday\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = mongodb_server_subagent.invoke({\"messages\": [HumanMessage(content=question)]}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Part 4: Building a Multi-Agent Architecture"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have two sub-agents that have different capabilities. How do we make sure customer tasks are appropriately routed between them? \n",
+    "\n",
+    "This is where the supervisor oversees the workflow, invoking appropriate subagents for relevant inquiries. \n",
+    "\n",
+    "\n",
+    "A **multi-agent architecture** offers several key benefits:\n",
+    "- Specialization & Modularity – Each sub-agent is optimized for a specific task, improving system accuracy \n",
+    "- Flexibility – Agents can be quickly added, removed, or modified without affecting the entire system\n",
+    "\n",
+    "![supervisor](./images/multi_agent.png)\n",
+    "\n",
+    "We will show how we can utilize the pre-built supervisor to quickly create the multi-agent architecture. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, we will create a set of instructions for our supervisor. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "supervisor_prompt = \"\"\"\n",
+    "You are an expert assistant tasked with helping users understand and troubleshoot MongoDB systems. \n",
+    "Your job is to coordinate a team of specialized subagents to ensure that user queries are handled accurately and efficiently. \n",
+    "You serve as the supervisor and planner for this multi-agent system, selecting the right subagent for each part of a user's request.\n",
+    "\n",
+    "You have access to the following two subagents:\n",
+    "\n",
+    "1. mongodb_server_subagent: This subagent specializes in retrieving live metadata from the MongoDB server. \n",
+    "It can access information such as server version, available databases, collection names, and statistics about storage or object sizes. \n",
+    "Use this subagent when the user asks about the structure, organization, or status of the MongoDB server or databases.\n",
+    "\n",
+    "2. mongodb_rag_pipeline: This subagent is powered by a retrieval-augmented generation (RAG) pipeline. \n",
+    "It specializes in answering questions about MongoDB based on official documentation. \n",
+    "Use this subagent when the user asks conceptual questions (e.g., \"How does indexing work?\", \"What is the difference between sharding and replication?\", etc.)\n",
+    "\n",
+    "Your job is to read the user's message and decide which subagent should be called next.\n",
+    "Some queries may require multiple steps involving both subagents — plan accordingly and route to the most relevant subagent for the current step.\n",
+    "\"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph_supervisor import create_supervisor\n",
+    "\n",
+    "mongodb_rag_pipeline = graph\n",
+    "# Create supervisor workflow\n",
+    "supervisor_prebuilt_workflow = create_supervisor(\n",
+    "    agents=[mongodb_rag_pipeline, mongodb_server_subagent],\n",
+    "    output_mode=\"last_message\", # alternative is full_history\n",
+    "    model=llm,\n",
+    "    prompt=(supervisor_prompt), \n",
+    "    state_schema=State\n",
+    ")\n",
+    "\n",
+    "supervisor_agent = supervisor_prebuilt_workflow.compile(name=\"mongodb_supervisor_agent\", checkpointer=mongodb_saver)\n",
+    "\n",
+    "# Visualize the graph\n",
+    "visualize_graph(supervisor_agent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thread_id = uuid.uuid4()\n",
+    "question = \"What are some best practices for data backups in MongoDB?\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = supervisor_agent.invoke({\n",
+    "    \"messages\": [HumanMessage(content=question)],\n",
+    "    \"question\": question\n",
+    "}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = supervisor_agent.get_state(config)\n",
+    "state.next"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = supervisor_agent.invoke(Command(resume=\"Nothing else to add.\"), config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# thread_id = uuid.uuid4()\n",
+    "question = \"List me the available databases and the collections for the mongodb devday\"\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "result = supervisor_agent.invoke({\n",
+    "    \"messages\": [HumanMessage(content=question)]\n",
+    "}, config=config)\n",
+    "for message in result[\"messages\"]:\n",
+    "    message.pretty_print()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/utils/__init__.py b/notebooks/utils/__init__.py
index 86fa9c4..0122b24 100644
--- a/notebooks/utils/__init__.py
+++ b/notebooks/utils/__init__.py
@@ -1,3 +1,3 @@
-from .utils import create_index, check_index_ready
+from .utils import create_index, check_index_ready, visualize_graph
 
-__all__ = ["create_index", "check_index_ready"]
+__all__ = ["create_index", "check_index_ready", "visualize_graph"]
diff --git a/notebooks/utils/utils.py b/notebooks/utils/utils.py
index 5037156..6573abd 100644
--- a/notebooks/utils/utils.py
+++ b/notebooks/utils/utils.py
@@ -2,6 +2,9 @@
 from pymongo.collection import Collection
 from typing import Dict
 import time
+from IPython.display import Image, display
+from langchain_core.runnables.graph import MermaidDrawMethod
+import nest_asyncio
 
 SLEEP_TIMER = 5
 
@@ -67,3 +70,8 @@ def check_index_ready(collection: Collection, index_name: str) -> None:
 
         print(f"{index_name} index status: {status}")
         time.sleep(SLEEP_TIMER)
+
+def visualize_graph(graph):
+    # display(Image(graph.draw_mermaid_png()))
+    nest_asyncio.apply()
+    display(Image(graph.get_graph().draw_mermaid_png(draw_method=MermaidDrawMethod.PYPPETEER)))
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index fc47457..01407b3 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,4 +8,7 @@ langgraph-checkpoint-mongodb==0.1.3
 tiktoken==0.9.0
 sentence_transformers==4.1.0
 tqdm==4.67.1
-Pillow==11.1.0
\ No newline at end of file
+Pillow==11.1.0
+pyppeteer==2.0.0
+langgraph-cli[inmem]==0.3.1
+langgraph_supervisor==0.0.27
\ No newline at end of file