diff --git "a/EDA_Agent/.ipynb_checkpoints/mistral_EDA_agent-checkpoint.ipynb" "b/EDA_Agent/.ipynb_checkpoints/mistral_EDA_agent-checkpoint.ipynb"
new file mode 100644--- /dev/null
+++ "b/EDA_Agent/.ipynb_checkpoints/mistral_EDA_agent-checkpoint.ipynb"
@@ -0,0 +1,748 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c96b164c",
+   "metadata": {},
+   "source": [
+    "# Overview "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22c9cad3",
+   "metadata": {},
+   "source": [
+    "<span style=\"color:red; font-size:18px; font-weight:bold;\">In this notebook, we will try to create a workflow between Langchain and Mixtral LLM.</br>\n",
+    "We want to accomplish the following:</span>\n",
+    "1. Establish a pipeline to read in a csv and pass it to our LLM. \n",
+    "2. Establish a Pandas Agent in our LLM.\n",
+    "3. Connect the CSV pipeline to this agent and enable a end-end EDA pipeline."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bd62bd1",
+   "metadata": {},
+   "source": [
+    "# Setting up the Environment "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "76b3d212",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "####################################################################################################\n",
+    "import os\n",
+    "import re\n",
+    "\n",
+    "from langchain import hub\n",
+    "from langchain.agents.agent_types import AgentType\n",
+    "from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent\n",
+    "from langchain_experimental.utilities import PythonREPL\n",
+    "from langchain.agents import Tool\n",
+    "from langchain.agents.format_scratchpad.openai_tools import (\n",
+    "    format_to_openai_tool_messages,\n",
+    ")\n",
+    "from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser\n",
+    "\n",
+    "from langchain.agents import AgentExecutor\n",
+    "\n",
+    "from langchain.agents import create_structured_chat_agent\n",
+    "from langchain.memory import ConversationBufferWindowMemory\n",
+    "\n",
+    "from langchain.output_parsers import PandasDataFrameOutputParser\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "\n",
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "\n",
+    "from langchain_community.chat_models import ChatAnyscale\n",
+    "import pandas as pd \n",
+    "import matplotlib.pyplot as plt \n",
+    "import numpy as np\n",
+    "\n",
+    "plt.style.use('ggplot')\n",
+    "####################################################################################################"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9da52e1f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# insert your API key here\n",
+    "os.environ[\"ANYSCALE_API_KEY\"] = \"esecret_8btufnh3615vnbpd924s1t3q7p\"\n",
+    "memory_key = \"history\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "edcd6ca7",
+   "metadata": {},
+   "source": [
+    "# Using out of the box agents\n",
+    "<span style=\"font-size:16px;color:red;\"> Over here we simply try to run the Pandas Dataframe agent provided by langchain out of the box. It uses a CSV parser and has just one tool, the __PythonAstREPLTool__ which helps it execute python commands in a shell and display output. </span>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "45f55df2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('../data/train.csv')\n",
+    "df.to_csv('./df.csv', index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64a086f2",
+   "metadata": {},
+   "source": [
+    "# DECLARE YOUR LLM HERE "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3f686305",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ChatAnyscale(model_name='mistralai/Mixtral-8x7B-Instruct-v0.1', temperature=0)\n",
+    "agent = create_pandas_dataframe_agent(llm, df, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "083bf9ab",
+   "metadata": {},
+   "source": [
+    "# Building my own DF chain\n",
+    "<span style=\"font-size:16px;color:red\"> The above agent does not work well or mistral out of the box. The mistral LLM is unable to use the tools properly. It perhaps needs much more hand-held prompts.</span>\n",
+    "\n",
+    "### Post Implementation Observation:\n",
+    "<span style=\"font-size:16px;color:red\"> We were able to observe the following:</br>\n",
+    "    1. The agent now works very well almost always returning the desired output.</br>\n",
+    "    2. The agent is unable to output plots. </span>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f6142b5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is my own parser to display the agent output\n",
+    "def my_parser(response):\n",
+    "    return print(response.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "05fd38b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "FORMAT_INSTRUCTIONS = \"\"\"Use the following format:\n",
+    "\n",
+    "Question: the input question you must answer\n",
+    "Thought: you should always think about what to do, what action to take\n",
+    "Action: python_repl_ast\n",
+    "Action Input: the input to the action, never add backticks \"`\" or backslash \"\\\" around the action input\n",
+    "Observation: the result of the action. This is the result obtained from the execution of a tool only. This should include the whole output of the tool.\n",
+    "... (this Thought/Action/Action Input/Observation can repeat N times)\n",
+    "Code: This is the python code generated by your python_repl tool. In case the tool is not used this should be empty.\n",
+    "Thought: I now know the final answer\n",
+    "Final Answer: the final answer to the original input question\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "00f1ebc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python_repl = PythonREPL()\n",
+    "\n",
+    "repl_tool = Tool(\n",
+    "    name=\"python_repl\",\n",
+    "    description=\"\"\"A Python shell. Shell can dislay charts too. Use this to execute python commands.\\\n",
+    "    You have access to all libraries in python including but not limited to sklearn, pandas, numpy,\\\n",
+    "    matplotlib.pyplot, seaborn etc. Input should be a valid python command. If the user has not explicitly\\\n",
+    "    asked you to plot the results, always print the final output using print(...)\"\"\",\n",
+    "    func=python_repl.run,\n",
+    ")\n",
+    "\n",
+    "tools = [repl_tool]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ebe61b21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Here's an example of a column operation being performed.\n",
+    "# df_query = \"How many columns are there?\"\n",
+    "\n",
+    "# # Set up the prompt.\n",
+    "# prompt = PromptTemplate(\n",
+    "#     template= \"\"\"Answer the user query using the tools at your disposal. YOU ALWAYS NEED TO USE A TOOL TO ANSWER QUERIES.\\n\n",
+    "#     The following dataframe named df is your knowledge base:\\n{dataframe}\\n\n",
+    "#     Query: {query}\\nTools: {tools}\\n{format_instructions}\n",
+    "# \"\"\",\n",
+    "#     input_variables=[\"query\"],\n",
+    "#     partial_variables={\"format_instructions\":FORMAT_INSTRUCTIONS,\n",
+    "#                       \"dataframe\": df,\n",
+    "#                       \"tools\":tools},\n",
+    "# )\n",
+    "\n",
+    "# chain = prompt | llm | my_parser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "64d09443",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# chain.invoke('how many null values are there ?')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4a42de6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# chain.invoke(\"Plot the distribution of age\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5caa356",
+   "metadata": {},
+   "source": [
+    "# Building an Agent "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "44c07305",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"\"\"You are Data Analysis assistant. Your job is to use your tools to answer a user query in the best\\\n",
+    "            manner possible. Always execute code using the python_repl.run() method. \\\n",
+    "            Provide no explanation for your code. Enclose all your code between triple backticks ``` \"\"\",\n",
+    "        ),\n",
+    "        (\"user\", \"Dataframe named df: {df}\\nQuery: {input}\\nTools:{tools}\"),\n",
+    "        MessagesPlaceholder(variable_name=\"agent_scratchpad\"),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "67dae2d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = (\n",
+    "    {\n",
+    "        \"input\": lambda x: x[\"input\"],\n",
+    "        \"tools\": lambda x:x['tools'],\n",
+    "        \"df\": lambda x:x['df'],\n",
+    "        \"agent_scratchpad\": lambda x: format_to_openai_tool_messages(\n",
+    "            x[\"intermediate_steps\"]\n",
+    "        )\n",
+    "    }\n",
+    "    | prompt\n",
+    "    | llm\n",
+    "    | OpenAIToolsAgentOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "45129995",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9602539f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# building an execution chain\n",
+    "\n",
+    "def infer(user_input):\n",
+    "    # fetch the response from the agent\n",
+    "    result = list(agent_executor.stream({\"input\": user_input, \n",
+    "                                         \"df\":pd.read_csv('df.csv'), \"tools\":tools}))\n",
+    "    \n",
+    "    # need to extract the code\n",
+    "    pattern = r\"```python\\n(.*?)\\n```\"\n",
+    "    matches = re.findall(pattern, result[0]['output'], re.DOTALL)\n",
+    "    final_line = \"df.to_csv('./df.csv', index=False)\"\n",
+    "    code = \"\\n\".join(matches)\n",
+    "    exec(code)\n",
+    "    try:\n",
+    "        exec(\"df.to_csv('./df.csv', index=False)\")\n",
+    "    except:\n",
+    "        pass\n",
+    "    # execute the code\n",
+    "    return None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a55d4e5",
+   "metadata": {},
+   "source": [
+    "# Testing \n",
+    "<span style=\"font-size:16px;color:red;\"> Testing for the EDA Agent has been divided into 2 distinct tasks:</span>\n",
+    "## <span style=\"font-size:16px\">**Data Smoothing**:</span>\n",
+    "><span style=\"font-size:16px\">i. Finding out the Null values.</span></br>\n",
+    "><span style=\"font-size:16px\">ii. Filling the Null values.</span>\n",
+    "\n",
+    "## <span style=\"font-size:16px\">**Plotting**:</span>\n",
+    "><span style=\"font-size:16px\">i. Distribution of ages</span></br>\n",
+    "><span style=\"font-size:16px\">ii. Distribution of gender against survival.</span></br>\n",
+    "><span style=\"font-size:16px\">iii. Heatmap of all variables with survival.</span> </br>\n",
+    "><span style=\"font-size:16px\">iv. Reg plot age against fare (since these are the only continuous features in our dataset)</span>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6b73109",
+   "metadata": {},
+   "source": [
+    "## Smoothing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "797796e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "import pandas as pd\n",
+      "import matplotlib.pyplot as plt\n",
+      "\n",
+      "df.isnull().sum().plot(kind='bar')\n",
+      "plt.ylabel('Count of Null Values')\n",
+      "plt.title('Count of Null Values in Every Column')\n",
+      "plt.show()\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAH6CAYAAAADVpauAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABwE0lEQVR4nO3deVxU1f8/8NcAA4LIDgIKCiKmEuKSKypimSmlliKpaaJZSWaWuWTmvqB9My2XUnNBLVfUktTcFTNTcyW3EBAVFRERkWWY+/uDH/fjOAPO6IU7M76ej0ePnHvP3HndYYA3555zrkIQBAFEREREZsxC7gBEREREFY0FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ/RM9q9ezdCQ0Ph7OwMhUKB7t27yx1Jw7vvvguFQoGUlBRxW0pKChQKBd59913Zcj0uLCwMCoVC7hhPZfny5VAoFFi+fLncUegZKRQKhIWFyR2DKgALHtJw/vx5DBs2DEFBQXB0dIS1tTW8vb3RtWtXLF26FPn5+XJHfKLK/OWTmpqK119/Hf/99x8GDhyICRMmICoqqtzn7Nu3DwqFAgqFApGRkTrblBYkoaGhFRHbIK1bt4ZCocDvv/9ebjtBEFCnTh0oFAqcOXOmktI9P0oL1/L+++STT+SOWeGOHj2KQYMGoV69eqhWrRpsbGxQq1Yt9OzZE+vWrUNxcbHcEclIWckdgIzH5MmTMWnSJKjVarRs2RIDBgxAtWrVcPPmTRw4cACDBw/GwoULcezYMbmjGo0//vgDDx8+xJIlS9CnTx+Dn79+/Xr8+eefaNWqVQWkk8aQIUPw559/YvHixXjttdfKbLdnzx4kJyejZcuWePHFFysxofx69OiBli1bwsvLq8Jfq1u3bggJCdG5r2XLlhX++nIpKirCxx9/jEWLFsHS0hLt27dH165dYWNjg2vXrmHv3r3YuHEj3nrrLWzYsEHuuGSEWPAQAGDatGmYMGECfHx8sH79erRo0UKrzfbt2zFr1iwZ0hmv69evAwC8vb0Nfm5AQAAuX76MkSNHIjExUepokunduzc++eQT/Pbbb7h58yaqV6+us92SJUsAAO+9915lxjMKjo6OcHR0rJTX6t69u1FdiqwsQ4cOxZIlS/Diiy9i/fr1qFevnsZ+tVqNtWvXIj4+XqaEZOx4SYuQkpKCSZMmQalUIiEhQWexAwCdO3fWeVlj7dq1aNu2LRwdHWFra4ugoCBMnz5d5+Wv8q6PP2msSUpKCqKiouDm5oYqVaqgadOm2Lp1q8YxwsLCMHDgQADAwIEDNbr7Hz1uefQ5n9LLUhMmTAAAdOjQQXydffv26fU6LVq0QLdu3XD48GFs3LhRr+dMnDixzNeoqHE5tra26NevH4qKirBixQqdbe7cuYP4+Hg4ODigd+/eAEouLb711lvw9/eHra0tHBwc0KZNG6xcuVLv137S5cmyPk8qlQoLFixAy5Yt4eDgADs7OzRu3Bjff/891Gq1Vvv4+Hh06NABnp6esLGxgaenJ0JDQzF//vxnylm7dm3Url0beXl5+Pzzz+Hr6wsbGxsEBARg5syZEARBr+Mb6s8//4RCocCbb75ZZpu6devCxsYGWVlZGtt37NiBLl26wM3NDTY2NqhTpw4+//xzZGdnax2j9Pzu3buH4cOHo1atWlAqlZg4cSLGjBkDhUJR5tf7+PHjUCgUeP311594PomJiViyZAlcXFywY8cOrWIHACwsLPD2228jLi5OY7tarcaCBQvw0ksvwd7eHlWrVkWzZs2wYMECnZ8FXXT9bCpV+rNg4sSJGttLx6QVFRVh8uTJqFOnDqpUqYJ69eph8eLFYrv58+cjKCgItra2qFmzJiZOnKiVy9Cfg6Qbe3gIy5YtQ1FREaKiohAUFFRuWxsbG43Ho0ePxqxZs+Du7o6+ffuiatWqSEhIwLhx47B9+3bs2rUL1tbWz5wxNTUVzZs3h7+/P9555x1kZWVh7dq16N69O/744w907NgRQMkPJicnJ2zZskWr69/JyemJr6Pv+dSuXRsTJkzAvn37sH//fgwYMAC1a9cGAPH/+pg1axa2bduGMWPG4I033oBSqTTgXak8Q4YMwfz587F06VKMGjVKa39cXBwKCgowcOBAVK1aFQDw4YcfokGDBmjXrh28vLyQmZmJbdu2YcCAATh//jymT59eIVmLiorw+uuvY8eOHXjhhRfQp08fVKlSBXv37sWwYcNw5MgRrFq1Smy/cOFCDB06FJ6ennjjjTfg5uaGW7du4fTp01i+fDliYmKeOU+nTp1w/fp1vPbaa7CyssLmzZsxduxYPHz4EJMmTXrWU9bSqlUrBAYG4rfffsOdO3fg6uqqsf/w4cO4fPky3nrrLbi4uIjbJ0+ejAkTJsDV1RVdu3aFh4cHTp8+ja+//hoJCQk4fPiwVk9WQUEBwsPDcffuXbz66quwt7dH7dq1ERYWhtmzZ+OHH35A//79tTIuWrQIAPD+++8/8Xx+/PFHACWfwyddNnz8Z1SfPn2wdu1a+Pr6YvDgwVAoFIiPj0dMTAwOHDiAX3755Ymv/yyioqLw119/oUuXLlAqldiwYQOGDBkCa2trHDt2DGvWrEFERARefvll/Prrr5g0aRJsbW0xevRorWPp+3OQyiDQc69Dhw4CAGHx4sUGPe/QoUMCAKFWrVrCzZs3xe1FRUVCly5dBADC1KlTNZ4DQGjfvr3O4w0YMEAAIFy5ckXcduXKFQGAAECYOHGiRvvt27cLAITOnTtrbF+2bJkAQFi2bFmFn8+ECRMEAMLevXv1fp29e/cKAIS+ffsKgiAIMTExAgBh7ty5YpvS827Tpo3er1f6nAEDBmhsL+99fbxteZo3by4AEPbv36+1r2HDhgIA4cSJE+K2y5cva7XLz88XwsLCBCsrK+Hq1asa+9q3by88/iPpSV9LXZ+n0vdo+PDhgkqlErerVCohOjpaACDEx8eL2xs3bixYW1trfM1L3b59W+frPq6snLVq1RIACK+99pqQl5cnbr9586bg6OgoODg4CIWFhXq9RunXsVu3bsKECRN0/vfvv/+K7adNmyYAEL777jutY73//vsCAGHr1q3itj179oifuezsbJ3nN3z4cJ3n17FjRyE3N1frdbp27SoAEM6cOaOxPScnR6hatarg4+Oj8TUqi5+fnwBA+OOPP57Y9lGrV68WAAjNmjXTyJebmys0adJEACCsWrVK4zm6PlO6vodKlX4/T5gwQWN76ee5WbNmwt27d8Xt//33n6BUKgVHR0ehdu3aQnp6urgvOztbcHNzE9zc3ISioiJx+9P8HCRtLHhIqF+/vgBA+P333w163qBBg8oslM6fPy9YWFgIfn5+GtuftuCpXbu2zh+Mvr6+gqurq8a2py14nuZ8pCh4bt26JTg4OAiurq7iLxpjLHiWLFkiABDeeecdje2HDx8WAAhNmzbV6zgbNmwQAAgrVqzQ2C5FwVNcXCy4uroKXl5eOj8vd+/eFRQKhdCzZ09xW5MmTQQ7OzshKytLr/y6PKng0VX89e/fX2cxUJbSr2N5/z1ayKWlpQkWFhZCs2bNNI6Tn58vODk5CR4eHhq/VLt37y4AEM6dO6fz9UNCQgR3d3ed5/fPP//ofM62bdsEAMKwYcM0ti9YsEAAIEyePFmvc7e1tRUAaBR0+ujYsWOZhdLOnTsFAEKHDh00tktd8OzevVvrOaV/ZC5dulRr38CBAwUAQkpKirjtaX4OkjZe0iJxHIGha6D8888/AErGrzyuXr16qFmzJq5cuYLs7Gy9LieVJyQkBJaWllrbfXx88Oeffz7TsUtV5vk8yt3dHWPGjMEXX3yBadOmGe3A8KioKIwYMQIbNmzAvHnzxPegdDzCkCFDNNqnpaUhNjYWu3fvRlpaGh4+fKix/9q1a5JnvHjxIu7cuYO6detiypQpOtvY2tri/Pnz4uO+ffvis88+Q8OGDREVFYV27dqhTZs2cHd3lySTk5MT6tSpo7Xdx8cHAHD37l2Djrds2TK9xmn5+PggPDwcu3btQlJSEho0aAAA2Lp1K7KzszFixAhYWf3vV8Cff/4JpVKJdevW6TxeYWEhbt++rXWJzMbGBo0aNdL5nM6dO8PPzw9xcXGIjY2Fra0tAOCHH36AlZUVBg0apO9pA3i6n1EWFhZo37691r4OHTrA0tISJ06cMOiYhmratKnWttJJDuXtS09PR61atTT2VcbPQXPGgofg7e2N8+fPIz093aDn3bt3DwDg6empc7+XlxfS0tJw7969Zy4QypoBY2VlpffAwyepzPN53IgRI7Bw4ULMmzfvmceMVJSqVauiT58++OGHH7B69WrExMTg/v37WLduHapWrYq3335bbJucnIzmzZvj7t27aNu2LTp16gRHR0dYWloiJSUFK1asQEFBgeQZ79y5AwC4dOlSuWNjcnNzxX9/+umncHNzw4IFCzB37lzMmTMHCoUCHTp0wOzZs9GkSZNnylTeZxdAha4bM2DAAOzatQsrVqxAbGwsAIgDzwcMGKDR9s6dO1CpVE8cU5Sbm6tR8FSvXr3MQsTCwgLvv/8+xowZg3Xr1mHAgAH466+/cOrUKfTo0UPv2Y1eXl5ITk5Genq6zgHLZbl37x5cXFx0jo2zsrISx2tVJF1f/9KvfXn7ioqK9DpW6XOk+jlozjhLi8TF7Xbv3m3Q80q/+TIyMnTuv3HjhkY7oOQvNJVKpbO9rlkglelpzkcqVapUwdSpU1FQUIAvvviizHYWFiXfsrrew8p4/0p7cUqnoK9ZswYPHjxAVFQUqlWrJrb75ptvcOfOHSxduhT79u3DvHnzMGXKFEycOBGvvvqq3q9n6PmWfm169OgBoeSSvc7/rly5ovG8/v3748iRI7hz5w62bduGQYMGYd++fejUqRNu376td15j8+abb6JatWpYtWoViouLcevWLezYsQONGjXS6pVxdHSEs7Nzue+bIAhavQ5P6nUZNGgQbGxs8MMPPwCA+H99BiuXepafUVlZWTqLB5VKhczMTDg4ODzxOHJ/35E0WPAQBg4cCKVSiY0bNyIpKancto/+Vd64cWMA0DlF+vLly0hPT4efn59Gb4izszOuXr2q1b64uBgnT558qvyPK+3yNfQv56c5Hym98847aNy4MX7++ecyF3d0dnYGAJ3vYWUsCNmkSRM0bdoUJ0+exPHjx8XC5/HLWZcvXwYAvPXWW1rH2L9/v96vZ+j5vvDCC3BycsKRI0d0/pJ7EicnJ3Tp0gWLFy/Gu+++izt37uDgwYMGH8dY2NnZoWfPnrh+/Tp27dqF1atXQ6VSafXuACWLFt69exfnzp2TNIObmxt69eqFP//8E4cOHcLatWvh5+eHTp066X2M0s/Xjz/+iJs3b5bb9vGfUWq1GgcOHNBqd+DAARQXF+vVgyf39x1JgwUPoXbt2pg4cSIKCwvRtWvXMr+Bt2/frrHSbnR0NABg6tSpGn8FFxcXY+TIkVCr1VrX6Fu0aIG0tDTs3LlTY/vUqVORmpoqyfmUdrfr+uFUnqc5HykpFAp8/fXXEAQBY8eO1dmmdI2kZcuWafy1efXqVUyePLnCsj2qdGHBESNG4NixYwgODkbz5s012pROzd+7d6/G9h07dohFkj6aNWsGCwsLrFmzBnl5eeL2rKwsndPjraysMGzYMNy4cQMff/yx1rghoKSn7tHCfvv27Tr/ci+91FGlShW98xqj0vE+K1euxMqVK2FlZYW+fftqtRsxYgSAkq9v6YKaj3rw4AGOHDnyVBmGDh0KAIiMjEReXh6GDBli0HicNm3a4L333sOdO3fQuXNnXLp0SauNWq3Gzz//jHfeeUfcVvo9PXbsWI3PT15eHsaMGQMAen1Pl37fPbp+DgCcOXMGc+fO1fs8SF4cw0MAgC+++EK8fv/SSy+hdevWaNasGezt7cVbS1y6dAnNmjUTn9O6dWuMGjUKs2bNQlBQEHr27ImqVavi999/x9mzZxEaGorPP/9c43VGjhyJHTt2oFu3bujduzdcXFxw+PBhXLlyBWFhYXov2leeVq1awc7ODt9++y3u3Lkjrgw8bNiwci9HPc35SC08PBxdunRBQkKCzv3NmzcX36fmzZsjPDwcN2/exK+//opXX33V4CLvafTp0wcjR44Uez4e790BSn7BLVu2DJGRkXjrrbdQo0YNnD17Ftu3b0dkZCTWrl2r12t5eXmhf//+WL58OUJCQtC1a1fk5OQgISEB7dq1EweaP2r8+PE4deoUFi1ahF9//RXh4eGoUaMGbt26hUuXLiExMRHTpk0TB/FGRUWhSpUqCA0NRe3atSEIAg4ePIi///4bTZo0wcsvv/wM75b0Nm/eXOYimrVr19Ya0Ny2bVv4+flh/fr14hpFHh4eWs/t2LEjZs6cibFjx6Ju3bro0qUL/Pz8kJubi9TUVOzfvx+hoaHYvn27wZlbtWqFkJAQnDx5EkqlUlwc1BDz58+HpaUlFi1ahPr16yMsLAyNGjUSby2xZ88epKeno2fPnuJz+vTpgy1btmDdunVo2LAhunfvDoVCgc2bN+PKlSuIjIzUWfw9rlu3bqhXrx5+/vlnpKeni3+4la73VdZAbzIylT0tjIxbUlKS8NFHHwkNGzYUqlWrJiiVSsHT01Po3LmzsGTJEiE/P1/rOT///LPQpk0bwd7eXrCxsREaNGggTJ06VXj48KHO19i6davQtGlTwcbGRnBxcRF69+4tpKSkPNX0aV1TmQVBEH7//XehZcuWQtWqVcUpu7qmlOpiyPlIMS39cefOnRMsLS11TksXhJK1OoYMGSK4u7sL1tbWQsOGDYUffvihwqelP2rw4MECAMHW1lZjjZFHJSYmCh06dBCcnJwEe3t7oU2bNkJ8fPwTp/E+rqCgQBg1apRQo0YNQalUCnXq1BGmT58uFBUVlbnMgVqtFlauXCmEh4cLzs7OglKpFLy9vYU2bdoI06ZNE9LS0sS2CxcuFLp37y74+fkJtra2grOzsxASEiLExsYKOTk5er0f5U1Lr1Wrls7nGPrZ0WdaellLPpS+FgBhw4YN5b7OwYMHhV69egleXl6CUqkU3NzchEaNGgkjRowQ/v77b73P73Fz584VAAiRkZF6tS/LkSNHhOjoaKFu3bpC1apVBWtra6FmzZpC9+7dhbVr1wrFxcUa7YuLi4X58+cLTZs2FWxtbQVbW1uhSZMmwvfff6/VVhDKXjojPT1d6N27t+Ds7CxUqVJFaNasmbBx40aDP8+CUP40d12fi6f9OUiaFIJQQWubExER/X/9+/dHXFwcdu/ejfDwcLnj0HOIBQ8REVWo1NRUBAYGIiAgQPJB0UT64hgeIiKqEHFxcbhw4QLWrl2LwsJCTJ06Ve5I9BxjwUNERBVi6dKlOHDgAHx8fDBv3jz06NFD7kj0HOMlLSIiIjJ7XIeHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHWVqPuXv3bpl3834a7u7uRn+3ZWaUjinkZEbpmEJOZpSOKeR8HjNaWVmJN3gtt51kr2gmVCrVU91lWZfSm+OpVCoY62Q4ZpSOKeRkRumYQk5mlI4p5GTG8vGSFhEREZk9FjxERERk9ljwEBERkdljwUNERERmT/ZByzExMTpHa3fq1AmDBw+GIAhYv349du/ejdzcXNStWxeDBg2Cj4+P2LaoqAhxcXFITExEYWEhgoKCMHjwYLi6ulbmqRAREZGRkr3gmTFjBtRqtfg4LS0NU6dORatWrQAAW7ZswbZt2zB06FB4eXlh06ZNmDp1Kr799lvY2toCAJYvX47jx49j+PDhqFatGlauXImZM2ciNjYWFhbsxCIiInreyV4NODg4wMnJSfzvxIkTqF69Oho0aABBEJCQkIAePXqgRYsW8PX1RUxMDAoKCnDo0CEAQF5eHvbs2YP+/fsjODgYfn5+GDZsGNLS0nD69GmZz46IiIiMgew9PI9SqVQ4ePAgunbtCoVCgZs3byI7OxuNGjUS2yiVSjRo0AAXLlzAK6+8guTkZBQXFyM4OFhs4+LiAl9fX1y8eBEhISE6X6uoqEhjvR2FQiH2GJWuE/CsSo8j1fEqAjNKxxRyMqN0TCEnM0rHFHIyY/mMquA5evQoHjx4gLCwMABAdnY2AMDR0VGjnaOjIzIzM8U2VlZWsLe312pT+nxd4uPjsWHDBvGxn58fYmNj4e7u/uwn8hhPT0/Jjyk1ZpSOKeRkRumYQk5mlI4p5GRG3Yyq4Nm7dy9CQkLg4uKisf3xSlCf1Rmf1KZHjx6IiIjQeo3bt29LdmsJhUIBT09PZGRkGPWql8woDVPIyYzSMYWczCgdU8j5vGa0srLSq7PCaAqe27dv4/Tp0xg5cqS4zcnJCUBJL86j98nIyckRe32cnJygUqmQm5ur0cuTk5ODevXqlfl6SqUSSqVS5z6pPyiCIBjth68UM0rHFHIyo3RMISczSscUcjKjbrIPWi61d+9eODo6okmTJuI2Dw8PODk5aQw+VqlUSEpKEosZf39/WFpaarS5e/cu0tLSEBgYWHknQEREREbLKHp41Go19u3bh/bt28PS0lLcrlAo0KVLF8THx8PLywuenp6Ij4+HjY0NQkNDAQB2dnYIDw9HXFwcqlWrBnt7e8TFxcHX11djIDMRERE9v4yi4Dlz5gwyMzPRoUMHrX3dunVDYWEhlixZggcPHiAgIADjxo0TZ1QBwIABA2BpaYk5c+aICw+OHj2aa/AQERERACMpeBo1aoR169bp3KdQKBAZGYnIyMgyn29tbY3o6GhER0dXVEQiIiLZFL/3hl7trup5PMvFW58+jIliFwgRERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZs9K7gAAkJWVhVWrVuHkyZMoLCyEl5cXPvzwQ/j7+wMABEHA+vXrsXv3buTm5qJu3boYNGgQfHx8xGMUFRUhLi4OiYmJKCwsRFBQEAYPHgxXV1e5TouIiIiMhOw9PLm5uRg/fjysrKzwxRdf4JtvvkH//v1hZ2cnttmyZQu2bduG6OhozJgxA05OTpg6dSoePnwotlm+fDmOHj2K4cOHY/LkycjPz8fMmTOhVqvlOC0iIiIyIrIXPFu2bIGrqyuGDh2KgIAAeHh44MUXX4SnpyeAkt6dhIQE9OjRAy1atICvry9iYmJQUFCAQ4cOAQDy8vKwZ88e9O/fH8HBwfDz88OwYcOQlpaG06dPy3l6REREZARkv6R17NgxNGrUCN988w2SkpLg4uKCTp064eWXXwYA3Lp1C9nZ2WjUqJH4HKVSiQYNGuDChQt45ZVXkJycjOLiYgQHB4ttXFxc4Ovri4sXLyIkJETrdYuKilBUVCQ+VigUsLW1Ff8thdLjSHW8isCM0jGFnMwoHVPIyYzSMZWc+pLrPOR8H2UveG7duoU//vgDXbt2RY8ePXD58mUsW7YMSqUS7du3R3Z2NgDA0dFR43mOjo7IzMwEAGRnZ8PKygr29vZabUqf/7j4+Hhs2LBBfOzn54fY2Fi4u7tLd3L/X2lvlTFjRumYQk5mlI4p5GRG6ciV86rEx/Py8pL4iIaR432UveBRq9WoU6cO+vTpA6Ck8Lh69Sp27tyJ9u3bi+0erwYFQXjisctr06NHD0RERGgd//bt21CpVAadQ1kUCgU8PT2RkZGhV145MKN0TCEnM0rHFHIyo3RMJae+bty4IcvrVsT7aGVlpVdnhewFj7OzM2rWrKmxrWbNmvjrr78AAE5OTgBKenGcnZ3FNjk5OWKvj5OTE1QqFXJzczV6eXJyclCvXj2dr6tUKqFUKnXuk/rDLAiC0X+DMKN0TCEnM0rHFHIyo3RMJeeTyH0OcryPsg9arlevHq5fv66x7fr162K15uHhAScnJ43BxyqVCklJSWIx4+/vD0tLS402d+/eRVpaGgIDAyvhLIiIiMiYyd7D07VrV4wfPx6bNm1C69atcfnyZezevRtDhgwBUNL91aVLF8THx8PLywuenp6Ij4+HjY0NQkNDAQB2dnYIDw9HXFwcqlWrBnt7e8TFxcHX11djIDMRERE9n2QveAICAjBy5EisWbMGGzduhIeHBwYMGIC2bduKbbp164bCwkIsWbIEDx48QEBAAMaNGyfOqgKAAQMGwNLSEnPmzBEXHhw9ejQsLGTvxCIiIiKZyV7wAEDTpk3RtGnTMvcrFApERkYiMjKyzDbW1taIjo5GdHR0RUQkIiIiE8buDyIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIye5IUPJcuXcLOnTuRnp4uxeGIiIiIJGVl6BMWLVqE4uJixMTEAAASExMxb968koNZWWHChAkIDAyUNiURERHRMzC4h+fcuXMICgoSH2/atAkhISGYNWsWAgMDsWnTJkkDEhERET0rgwue7OxsuLu7AwCysrKQnp6O7t27o1atWujSpQuSk5MlD0lERET0LAwueCwtLVFYWAgAuHDhApRKJerWrQsAqFq1Kh48eCBtQiIiIqJnZHDBU6NGDRw4cAAPHz7Enj17UK9ePVhZlQwFysrKgoODg+QhiYiIiJ6FwQVPREQEEhMT8e677+L06dN47bXXxH1nzpxBrVq1JA1IRERE9KwMnqXVqlUruLq64uLFi6hTpw7q168v7nN1dUWLFi0MOt66deuwYcMGjW2Ojo5YvHgxAEAQBKxfvx67d+9Gbm4u6tati0GDBsHHx0dsX1RUhLi4OCQmJqKwsBBBQUEYPHgwXF1dDT09IiIiMkMGFzwAEBgYqHPqeWRk5FOF8PHxwfjx48XHFhb/63jasmULtm3bhqFDh8LLywubNm3C1KlT8e2338LW1hYAsHz5chw/fhzDhw9HtWrVsHLlSsycOROxsbEaxyIiIqLn01NXAydPnsSaNWuwaNEiZGZmAgAuX76MnJwcw0NYWMDJyUn8r3QckCAISEhIQI8ePdCiRQv4+voiJiYGBQUFOHToEAAgLy8Pe/bsQf/+/REcHAw/Pz8MGzYMaWlpOH369NOeHhEREZkRg3t4CgoKMGvWLJw9e1bc1qlTJ7i5ueHXX3+Fq6sr+vfvb9AxMzIy8P7778PKygp169bF22+/jerVq+PWrVvIzs5Go0aNxLZKpRINGjTAhQsX8MorryA5ORnFxcUIDg4W27i4uMDX1xcXL15ESEiIztcsKipCUVGR+FihUIg9RgqFwqD8ZSk9jlTHqwjMKB1TyMmM0jGFnMwoHVPJqS+5zkPO99Hggufnn39GcnIyPvvsMwQHB2PAgAHivkaNGuH333836Hh169ZFTEwMvL29kZ2djU2bNuHLL7/EN998g+zsbAAlY3oe5ejoKPYqZWdnw8rKCvb29lptSp+vS3x8vMbYIT8/P8TGxoprDEnJ09NT8mNKjRmlYwo5mVE6ppCTGaUjV86rEh/Py8tL4iMaRo730eCC58iRI+jduzeaN28OtVqtsc/NzU0sRPTVuHFj8d++vr4IDAzEsGHDsH//fnF9n8crQUEQnnjcJ7Xp0aMHIiIixMelr3H79m2oVCq985dHoVDA09MTGRkZemWWAzNKxxRyMqN0TCEnM0rHVHLq68aNG7K8bkW8j1ZWVnp1Vhhc8OTk5KBmzZo69ykUCnFRwqdVpUoV+Pr64saNG3jppZcAlPTiODs7a2Qo7fVxcnKCSqVCbm6uRi9PTk4O6tWrV+brKJVKKJVKnfuk/jALgmD03yDMKB1TyMmM0jGFnMwoHVPJ+SRyn4Mc76PBg5ZdXFyQlpamc19qaio8PDyeKVBRURGuXbsGZ2dneHh4wMnJSWPwsUqlQlJSkljM+Pv7w9LSUqPN3bt3kZaWxpuYEhEREYCn6OFp3rw54uPjUb9+fXGRQYVCgdu3b2Pbtm3o0KGDQcdbuXIlmjVrBjc3N9y7dw8bN27Ew4cP0b59eygUCnTp0gXx8fHw8vKCp6cn4uPjYWNjg9DQUACAnZ0dwsPDERcXh2rVqsHe3h5xcXHw9fXVGMhMREREzy+DC55evXrh7Nmz+OKLL8TF/xYsWICbN2/C29sb3bt3N+h4WVlZmDt3LnJycuDg4IC6deti2rRp4vW4bt26obCwEEuWLMGDBw8QEBCAcePGiTOqAGDAgAGwtLTEnDlzxIUHR48ezTV4iIiICMBTFDy2traYOnUqEhIScOLECXh6esLGxgbdu3dH165dYW1tbdDxPvnkk3L3KxQKREZGlruoobW1NaKjoxEdHW3QaxMREdHz4alWWra2tkb37t0N7s0hIiIikgOv+RAREZHZM7iHZ9KkSeXuVygU+Oqrr546EBEREZHUDO7h0TVvPicnB+fPn8eNGzdkn9tPRERE9DiDe3gmTpyoc/v169cxe/Zs9OrV61kzEREREUlKsjE83t7eeP3117Fq1SqpDklEREQkCUkHLXt4eODqValvcUZERET0bCQteI4cOaJxzysiIiIiY2DwGJ4FCxZobVOpVEhNTUV6ejr69esnSTAiIiIiqRhc8Jw7d05rm7W1Ndzd3dGjRw/xHldERERExsLggmf+/PkVkYOIiIiownClZSIiIjJ7evXwZGZmGnRQNze3pwpDREREVBH0KnhiYmIMOujatWufKgwRERFRRdCr4Pnwww8rOgcRERFRhdGr4AkLC6vgGEREREQVh4OWiYiIyOwZPC0dANRqNf755x9cu3YNhYWFWvt79uz5zMGIiIiIpGJwwXP//n189dVXuH79epltWPAQERGRMTH4ktbPP/8Ma2trcQHCadOmYe7cuYiIiIC3tzcWLlwoeUgiIiKiZ2FwwXP27Fl07doVLi4uJQewsICnpyfeeecdvPjii1i5cqXkIYmIiIiehcEFz507d+Dh4QELCwsoFArk5+eL+5o2bYozZ85IGpCIiIjoWRlc8Dg4OCAvLw8A4OzsjKtXr4r7cnNzUVxcLF06IiIiIgkYPGjZz88PV69eRZMmTdC4cWNs2LABtra2sLKyws8//4y6detWRE4iIiKip2ZwwdO5c2fcvHkTABAVFYVLly6JA5irV6+OgQMHSpuQiIiI6BnpVfDMmjULHTt2ROPGjREcHCxud3BwwKxZs8TLWjVq1IClpWXFJCUiIiJ6SnoVPKdPn8bx48fh5OSE9u3bo0OHDvDy8gIAKBQK+Pr6VmhIIiIiomehV8GzePFiJCYmYu/evdiyZQu2bNmCF154AR06dECrVq1gY2NT0TmJiIiInppeBY+trS1efvllvPzyy7h27Rr27t2LgwcPYuHChVi2bBnatGmDDh06cMAyERERGSWDBy3XqFED/fr1Q58+fXDixAns27cP+/btw+7du1GjRg2Eh4cjIiKiIrISERERPZWnunkoULLCcrNmzdCsWTPk5ORgy5Yt+O233xAXF8eCh4iIiIzKUxc8AFBcXIxjx45h7969OHXqFACgdu3aUuQiIiIiksxTFTxpaWnYs2cPDh06hPv376Nq1ap45ZVXEB4ezoKHiIiIjI7eBU9eXh4OHjyIffv2ITk5GQAQFBSEDh06oEWLFlAqlRUWkoiIiOhZ6FXwzJ07F3///TeKiorg4uKCN998Ex06dICHh0dF5yMiIiJ6ZnoVPH/99ReaNWuG8PBwNGrUCAqFoqJzEREREUlGr4Jn0aJFcHBwqOgsRERERBXCQp9GLHaIiIjIlOlV8BARERGZMhY8REREZPaeaeFBqcXHx+Pnn39Gly5d8O677wIABEHA+vXrsXv3buTm5qJu3boYNGgQfHx8xOcVFRUhLi4OiYmJKCwsRFBQEAYPHgxXV1eZzoSIiIiMidH08Fy+fBm7du1CrVq1NLZv2bIF27ZtQ3R0NGbMmAEnJydMnToVDx8+FNssX74cR48exfDhwzF58mTk5+dj5syZUKvVlX0aREREZISMouDJz8/Hd999h/fffx9Vq1YVtwuCgISEBPTo0QMtWrSAr68vYmJiUFBQgEOHDgEoWRBxz5496N+/P4KDg+Hn54dhw4YhLS0Np0+fluuUiIiIyIjodUlr0qRJeh9QoVDgq6++MijEkiVL0LhxYwQHB2PTpk3i9lu3biE7OxuNGjUStymVSjRo0AAXLlzAK6+8guTkZBQXFyM4OFhs4+LiAl9fX1y8eBEhISE6X7OoqAhFRUUauW1tbcV/S6H0OMa8bhEzSscUcjKjdEwhJzNKx1Ry6kuu85DzfdSr4BEEQe9wgiAYFCAxMRFXrlzBjBkztPZlZ2cDABwdHTW2Ozo6IjMzU2xjZWUFe3t7rTalz9clPj4eGzZsEB/7+fkhNjYW7u7uBuXXh6enp+THlBozSscUcjKjdEwhJzNKR66cVyU+npeXl8RHNIwc76NeBc/EiRMr5MUzMzOxfPlyjBs3DtbW1mW2e7zY0qeoelKbHj16ICIiQus1bt++DZVK9cTj60OhUMDT0xMZGRkGF4KVhRmlYwo5mVE6ppCTGaVjKjn1dePGDVletyLeRysrK706K2SdpZWcnIx79+5hzJgx4ja1Wo1///0X27dvx7fffgugpBfH2dlZbJOTkyP2+jg5OUGlUiE3N1ejlycnJwf16tUr87WVSmWZNzyV+sMsCILRf4Mwo3RMISczSscUcjKjdEwl55PIfQ5yvI+yFjwvvvgivv76a41tCxcuhLe3N7p164bq1avDyckJp0+fhp+fHwBApVIhKSkJffv2BQD4+/vD0tISp0+fRuvWrQEAd+/eRVpamtiGiIiInm96FTy9e/fW+4AKhQK//PKLXm1tbW3h6+ursc3GxgbVqlUTt3fp0gXx8fHw8vKCp6cn4uPjYWNjg9DQUACAnZ0dwsPDERcXh2rVqsHe3h5xcXHw9fXVGMhMREREzy+9Cp633npLthHd3bp1Q2FhIZYsWYIHDx4gICAA48aNE2dUAcCAAQNgaWmJOXPmiAsPjh49GhYWRjHrnoiIiGSmV8ETGRlZ0TlEjw+QVigUiIyMLDeDtbU1oqOjER0dXcHpiIiIyBSxC4SIiIjMnsGDlvfv3//ENu3bt3+qMEREREQVweCCZ8GCBU9sw4KHiIiIjInBBc/333+vte3+/fv4+++/cfjwYXzyySdS5CIiIiKSjMEFj67VDN3d3eHv74/i4mIkJCQgJiZGknBEREREUpB00HJQUBCOHTsm5SGJiIiInpmkBU9mZibXviEiIiKjY/AlraSkJK1tKpUKqamp2Lx5M4KCgiQJRkRERCQVgwueSZMmlbnvxRdf5OJ/REREZHQMLngmTJigtU2pVMLd3R1OTk5SZCIiIiKSlMEFT4MGDSoiBxEREVGF4QhjIiIiMnt69fDExsbqfUCFQoFRo0Y9dSAiIiIiqelV8KSlpT2xjSAIuHPnzjMHIiIiIpKaXgXP/Pnzy91/4sQJrFmzBnfu3EG9evUkCUZEREQkFYMHLT/q8uXLWL16NZKSklCjRg2MHDkSL730klTZiIiIiCTxVAVPRkYG1qxZg7/++gvOzs4YMmQIOnTowFWWiYiIyCgZVPDcu3cP69evx549e2BjY4O3334bXbp0gbW1dUXlIyIiInpmehU8+fn52Lp1K7Zt2waVSoXOnTvjzTffhL29fUXnIyIiInpmehU8w4YNQ05ODkJCQhAVFQV3d3cAQG5urs72LISIiIjImOhV8OTk5AAATp48iZMnTz6x/dq1a58pFBEREZGU9Cp4evbsWdE5iIiIiCqMXgVPr169KjoHERERUYXhPHIiIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7ehU8AwcORHJyMgBgw4YNyMrKqtBQRERERFLSq+DJz8+HSqUCAKxfv54FDxEREZkUvdbhcXZ2xsmTJ+Hp6QkAyMvLK/O2EgBvLUFERETGRa+Cp127dti4cSM2btwIAJg2bVq57XlrCSIiIjImehU8UVFRCAgIQFpaGtauXYsOHTrA1dW1orMRERERSUKvggcAmjVrhmbNmmH37t3o3LkzateuXYGxiIiIiKSjd8FTav78+RWRg4iIiKjCGFzwAEBubi5+++03nD17Fvfv34eDgwNefPFFdOnShQOWiYiIyOgYvPBgVlYWRo8ejfj4eOTl5cHNzQ0PHjzAxo0bMXr0aE5ZJyIiIqNjcA/PmjVrUFhYiGnTpiEgIEDcfvnyZcTGxuLnn39GTEyMpCGJiIiInoXBPTynTp1C7969NYodAAgICEDv3r1x8uRJqbIRERERScLggicvLw8eHh4693l4eCAvL++ZQxERERFJyeCCx8PDAydOnNC5759//imzGCIiIiKSi8FjeMLCwrBmzRqo1WqEhYXByckJ2dnZOHDgALZv344+ffoYdLydO3di586duH37NgCgZs2a6NmzJxo3bgwAEAQB69evx+7du5Gbm4u6deti0KBB8PHxEY9RVFSEuLg4JCYmorCwEEFBQRg8eDAXRyQiIiIAT1HwvPHGG7h58yZ27NiBHTt2aOzr2LEj3njjDYOO5+Ligj59+oj36dq/fz9mzZqFWbNmwcfHB1u2bMG2bdswdOhQeHl5YdOmTZg6dSq+/fZb2NraAgCWL1+O48ePY/jw4ahWrRpWrlyJmTNnIjY2FhYWBndiERERkZkxuOBRKBQYMmQIIiIicPbsWeTm5sLe3h5BQUHw9vY2OECzZs00Hr/99tvYuXMnLl26hJo1ayIhIQE9evRAixYtAAAxMTF47733cOjQIbzyyivIy8vDnj17MGzYMAQHBwMAhg0bhg8//BCnT59GSEiIwZmIiIjIvDzVwoMA4O3t/VQFTnnUajX+/PNPFBQUIDAwELdu3UJ2djYaNWoktlEqlWjQoAEuXLiAV155BcnJySguLhaLHaCk18jX1xcXL14ss+ApKipCUVGR+FihUIg9RgqFQpLzKT2OVMerCMwoHVPIyYzSMYWczCgdU8mpL7nOQ8738akLHimlpaVh3LhxKCoqQpUqVTBy5EjUrFkTFy5cAAA4OjpqtHd0dERmZiYAIDs7G1ZWVlorPDs6OiI7O7vM14yPj8eGDRvEx35+foiNjYW7u7tEZ/U/pZfrjBkzSscUcjKjdEwhJzNKR66cVyU+npeXl8RHNIwc76NRFDze3t6YPXs2Hjx4gL/++gvz58/HpEmTxP2PV4KCIDzxmE9q06NHD0RERGi9xu3bt6FSqQyJXyaFQgFPT09kZGTolVkOzCgdU8jJjNIxhZzMKB1TyamvGzduyPK6FfE+WllZ6dVZYRQFj5WVlVjt1alTB//99x8SEhLQrVs3ACW9OM7OzmL7nJwcsdfHyckJKpVKHEv0aJt69eqV+ZpKpRJKpVLnPqk/zIIgGP03CDNKxxRyMqN0TCEnM0rHVHI+idznIMf7aJRTmARBQFFRETw8PODk5ITTp0+L+1QqFZKSksRixt/fH5aWlhpt7t69i7S0NAQGBlZ6diIiIjI+svfwrFmzBo0bN4arqyvy8/ORmJiIc+fOYdy4cVAoFOjSpQvi4+Ph5eUFT09PxMfHw8bGBqGhoQAAOzs7hIeHIy4uDtWqVYO9vT3i4uLg6+urMZCZiIiInl8GFzy9e/fWunFoqeTkZIwdOxZr167V+3j37t3D999/j7t378LOzg61atXCuHHjxGKlW7duKCwsxJIlS/DgwQMEBARg3Lhx4owqABgwYAAsLS0xZ84cceHB0aNHcw0eIiIiAiBxD49arTZ4qtmHH35Y7n6FQoHIyEhERkaW2cba2hrR0dGIjo426LWJiIjo+SBpF0hycjLs7OykPCQRERHRM9OrhychIQEJCQni49mzZ2vNcCosLMS9e/fQsmVLaRMSERERPSO9Ch4HBwfUrFkTQMk6NdWrV9fqyVEqlfD19UWXLl2kT0lERET0DPQqeEJDQ8VZUZMmTcLgwYNRo0aNCg1GREREJBWDBy1PmDChInIQERERVZinmqUlCAL+++8/3L59G4WFhVr727dv/8zBiIiIiKRicMFz/fp1zJo1q9z7cLDgISIiImNicMGzdOlSFBUVYcSIEfD19S3zflRERERExsLggufy5ct4//33Of2ciIiITIbBCw9WqVKFiwsSERGRSTG44OnQoQMOHTpUEVmIiIiIKoTBl7R8fHyQmJiI2NhYNG3aFNWqVdNq06JFC0nCEREREUnB4IJn3rx5AIBbt27hxIkTOtsYcrd0IiIioorGhQeJiIjI7Blc8DRo0KAichARERFVGIMHLRMRERGZGoN7eCZNmlTufoVCga+++uqpAxERERFJzeAeHkEQtLbl5OTg/PnzuHHjhs79RERERHIyuIdn4sSJOrdfv34ds2fPRq9evZ41ExEREZGkJBvD4+3tjddffx2rVq2S6pBEREREkpB00LKHhweuXr0q5SGJiIiInpmkBc+RI0fg7Ows5SGJiIiInpnBY3gWLFigtU2lUiE1NRXp6eno16+fJMGIiIiIpGJwwXPu3DmtbdbW1nB3d0ePHj0QGhoqSTAiIiIiqRhc8MyfP78ichARERFVGK60TERERGbP4B4eAMjNzcVvv/2Gs2fP4v79+3BwcMCLL76ILl26wN7eXuqMRERERM/E4B6erKwsjB49GvHx8cjLy4ObmxsePHiAjRs3YvTo0cjKyqqInERERERPzeAenjVr1qCwsBDTpk1DQECAuP3y5cuIjY3Fzz//jJiYGElDEhERET0Lg3t4Tp06hd69e2sUOwAQEBCA3r174+TJk1JlIyIiIpKEwQVPXl4ePDw8dO7z8PBAXl7eM4ciIiIikpLBBY+HhwdOnDihc98///xTZjFEREREJBeDx/CEhYVhzZo1UKvVCAsLg5OTE7Kzs3HgwAFs374dffr0qYicRERERE/N4ILnjTfewM2bN7Fjxw7s2LFDY1/Hjh3xxhtvSBaOiIiISAoGFzwKhQJDhgxBREQEzp49i9zcXNjb2yMoKAje3t4VkZGIiIjomTzVwoMA4O3tzQKHiIiITIJeg5Zzc3Px9ddf4/jx42W2OX78OL7++mvcv39fsnBEREREUtCr4NmzZw9SU1MREhJSZpuQkBBcvXpVa1wPERERkdz0KngSExPRsWNHWFpaltnG0tISHTt2xLFjxyQLR0RERCQFvQqeGzduoE6dOk9s5+fnhxs3bjxzKCIiIiIp6TVoubi4uNzenVKWlpZQqVQGBYiPj8fRo0dx7do1WFtbIzAwEP369dMYEC0IAtavX4/du3cjNzcXdevWxaBBg+Dj4yO2KSoqQlxcHBITE1FYWIigoCAMHjwYrq6uBuUhIiIi86NXD4+zszPS09Of2C49PR1OTk4GBUhKSsKrr76KadOm4csvv4RarcbUqVORn58vttmyZQu2bduG6OhozJgxA05OTpg6dSoePnwotlm+fDmOHj2K4cOHY/LkycjPz8fMmTOhVqsNykNERETmR6+Cp0GDBti5c2e5vTcqlQo7d+5Ew4YNDQowbtw4hIWFwcfHB7Vr18bQoUORmZmJ5ORkACW9OwkJCejRowdatGgBX19fxMTEoKCgAIcOHQJQcn+vPXv2oH///ggODoafnx+GDRuGtLQ0nD592qA8REREZH70uqTVtWtXjBkzBl9//TWGDBkCFxcXjf1ZWVn44YcfcP36dXz88cfPFKj05qP29vYAgFu3biE7OxuNGjUS2yiVSjRo0AAXLlzAK6+8guTkZBQXFyM4OFhs4+LiAl9fX1y8eFHn7LKioiIUFRWJjxUKBWxtbcV/S6H0OFIdryIwo3RMISczSscUcjKjdEwlp77kOg8530e9Cp5atWph0KBBWLp0KT766CP4+/uLNwm9desWkpOTIQgCBg8eDF9f36cOIwgCVqxYgRdeeEE8TnZ2NgDA0dFRo62joyMyMzPFNlZWVmKR9Gib0uc/Lj4+Hhs2bBAf+/n5ITY2Fu7u7k+dvyyenp6SH1NqzCgdU8jJjNIxhZzMKB25cl6V+HheXl4SH9EwcryPeq+0/PLLL8PX1xebNm3CuXPncOnSJQCAtbU1QkJC0L17dwQGBj5TmKVLlyItLQ2TJ0/W2vd4NSgIwhOPV16bHj16ICIiQuv4t2/fNnjgdVkUCgU8PT2RkZGhV145MKN0TCEnM0rHFHIyo3RMJae+5JpRXRHvo5WVlV6dFQbdWiIwMBBjxoyBWq0WV1SuVq0aLCz0GgpUrp9++gnHjx/HpEmTNGZWlQ6Czs7OhrOzs7g9JydH7PVxcnKCSqUS7+v1aJt69erpfD2lUgmlUqlzn9QfZkEQjP4bhBmlYwo5mVE6ppCTGaVjKjmfRO5zkON9fKpKxcLCAo6OjnB0dHzmYkcQBCxduhR//fUXvvrqK/FSWSkPDw84OTlpDD5WqVRISkoSixl/f39YWlpqtLl79y7S0tKeudeJiIiITN9T3zxUKkuXLsWhQ4cwatQo2NraimNu7OzsYG1tDYVCgS5duiA+Ph5eXl7w9PREfHw8bGxsEBoaKrYNDw9HXFwcqlWrBnt7e8TFxcHX11djIDMRERE9n2QveHbu3AkAmDhxosb2oUOHIiwsDADQrVs3FBYWYsmSJXjw4AECAgIwbtw4cVYVAAwYMACWlpaYM2eOuPDg6NGjJbncRkRERKZN9oJn3bp1T2yjUCgQGRmJyMjIMttYW1sjOjoa0dHRUsYjIiIiM8DuDyIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnuyz9IioudH8Xtv6NXOkPsGWS7e+nRhiOi5wh4eIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7FnJHSApKQlbt27FlStXcPfuXYwcORLNmzcX9wuCgPXr12P37t3Izc1F3bp1MWjQIPj4+IhtioqKEBcXh8TERBQWFiIoKAiDBw+Gq6urHKdERERERkb2Hp6CggLUrl0b0dHROvdv2bIF27ZtQ3R0NGbMmAEnJydMnToVDx8+FNssX74cR48exfDhwzF58mTk5+dj5syZUKvVlXUaREREZMRkL3gaN26MqKgotGjRQmufIAhISEhAjx490KJFC/j6+iImJgYFBQU4dOgQACAvLw979uxB//79ERwcDD8/PwwbNgxpaWk4ffp0ZZ8OERERGSHZL2mV59atW8jOzkajRo3EbUqlEg0aNMCFCxfwyiuvIDk5GcXFxQgODhbbuLi4wNfXFxcvXkRISIjOYxcVFaGoqEh8rFAoYGtrK/5bCqXHkep4FYEZpWMKOU0ho6HkOhdTeC+ZUTqmklNfz+P3jVEXPNnZ2QAAR0dHje2Ojo7IzMwU21hZWcHe3l6rTenzdYmPj8eGDRvEx35+foiNjYW7u7s04R/h6ekp+TGlxozSMYWccmW8WgHH9PLyqoCj6o9fb2mYQkbAfL53nsfvG6MueEo9XgkKgvDE5zypTY8ePRAREaH1Grdv34ZKpXqKlNoUCgU8PT2RkZGhV2Y5MKN0TCGnKWQ01I0bN2R5XVN4L5lROqaSU1/m9H1jZWWlV2eFURc8Tk5OAEp6cZydncXtOTk5Yq+Pk5MTVCoVcnNzNXp5cnJyUK9evTKPrVQqoVQqde6T+sMsCILRf4Mwo3RMIacpZNSX3OdhCu8lM0rHVHI+idznIMf7KPug5fJ4eHjAyclJY/CxSqVCUlKSWMz4+/vD0tJSo83du3eRlpaGwMDASs9MRERExkf2Hp78/HxkZGSIj2/duoWUlBTY29vDzc0NXbp0QXx8PLy8vODp6Yn4+HjY2NggNDQUAGBnZ4fw8HDExcWhWrVqsLe3R1xcHHx9fTUGMhMREdHzS/aC57///sOkSZPExytXrgQAtG/fHjExMejWrRsKCwuxZMkSPHjwAAEBARg3bpw4owoABgwYAEtLS8yZM0dceHD06NGwsDDqDiwiIiKqJLIXPA0bNsS6devK3K9QKBAZGYnIyMgy21hbWyM6OrrMxQuJiIjo+cYuECIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMnpXcAaS0Y8cObN26FdnZ2ahZsybeffdd1K9fX+5YREREJDOz6eE5fPgwli9fjjfffBOxsbGoX78+pk+fjszMTLmjERERkczMpuD57bffEB4ejo4dO4q9O25ubti5c6fc0YiIiEhmZnFJS6VSITk5Gd27d9fYHhwcjAsXLuh8TlFREYqKisTHCoUCtra2sLKS7i1RKBQAAKVSCUEQJDuulJhROqaQU+6MFnXqSX5MS6VS8mPqQ+73Uh/MKB25c0r9vVMR3zfFUz7Rq10GAMX//+9JLMd/+8Q2+v7eNouCJycnB2q1Go6OjhrbHR0dkZ2drfM58fHx2LBhg/i4TZs2GD58OJydnSXP5+bmJvkxpcaM0jGFnLJlnLdantetQPx6S8MUMgL83imXkWc0m0tawP8q8CdtA4AePXpg+fLl4n/vvfeeRo+PFB4+fIjRo0fj4cOHkh5XSswoHVPIyYzSMYWczCgdU8jJjOUzix4eBwcHWFhYaPXm3Lt3T6vXp5RSqYSygrvCBUHAlStXjLqblhmlYwo5mVE6ppCTGaVjCjmZsXxm0cNjZWUFf39/nD59WmP76dOnUa+e9GMGiIiIyLSYRQ8PAEREROC7776Dv78/AgMDsWvXLmRmZuKVV16ROxoRERHJzGwKntatW+P+/fvYuHEj7t69Cx8fH4wdOxbu7u6yZVIqlejZs2eFXzp7FswoHVPIyYzSMYWczCgdU8jJjOVTCMZ8sY+IiIhIAmYxhoeIiIioPCx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiKjS9O7dG/fu3dPafv/+ffTu3VuGRPS8YMFDZOYeX4H8UX/88UclJimfSqXC9evXUVxcLHeUct27dw///vsvzp8/r/MXNz2doqIive96TfQ0+Ol6Tnz99dd6tx05cmQFJnl6arUaaWlpcHNzg729vdxxNGRkZCAjIwMNGjSAtbU1BEEo88a1lW3mzJno3Lkz+vTpI/5CycnJwYIFC3DhwgXZVyMvKCjATz/9hP379wMA5s6di+rVq+Onn36Ci4sLunfvLmu+Unl5eVi6dCkOHz4MtVoNALCwsECrVq0wePBg2NnZyZzwf9RqNTIyMpCTkyNmLdWgQQNZMiUkJIj/3r17N6pUqSI+VqvV+Pfff1GjRg05opUrIyMD+/btQ0ZGBgYOHAhHR0ecPHkSrq6u8PHxkTse1Go19u3bhzNnzuj8ek+YMEGmZEBqaqrebWvVqlWBSUqw4JGAKRQTj/4wFgQBR48ehZ2dHerUqQMASE5OxoMHD9CiRQtZ8umyfPly+Pr6Ijw8HGq1GhMmTMDFixdhbW2NMWPGoGHDhnJHxP379/Htt9/i7NmzAIB58+ahevXqWLRoEapWrYr+/fvLnBCYNGkSvv/+e5w5cwYff/wxbt++jYULF6JmzZqYPXu23PGwZs0apKamYuLEiZg2bZq4PTg4GOvWrTOagmfRokVITU3F6NGjERgYCIVCgQsXLmD58uVYtGgRPv30U7kjAgAuXryIefPm4fbt2zr3r127tpITldi2bZv47z/++AMWFv+7wGBlZQUPDw+89957ckQrU1JSEqZPn4569erh33//xdtvvw1HR0ekpqZi9+7d+Oyzz+SOiGXLlmHfvn1o0qSJURRgjxo1apTebSvjc8mCRwKmUEwMHTpU/PeqVavQqlUrDBkyRPyho1arsWTJEtja2soVUcuRI0fQtm1bAMCxY8dw69YtzJkzBwcOHMAvv/yCKVOmyJwQWLFiBSwsLLBgwQKMGDFC3N66dWusWLHCKAqeunXrIjY2FosXL8aYMWOgVqsRFRWFN954wyh6of7++2988sknYhFRqmbNmrh586aMyTT9888/GDduHF544QVxW0hICN5//31Mnz5dxmSaFi9eDH9/f4wZMwbOzs5G8TUGgPnz5wMoKcA/++wzo+ul1WX16tWIiopCRESExvdyw4YNNXqs5HT48GGMGDECTZo0kTuKlu+//17895UrVxAXF4c33ngDgYGBAEqK899++w19+/atlDwseCRgasXE3r17MWXKFI2/sCwsLBAREYEvv/wS77zzjozp/uf+/ftwcnICUPLLplWrVvD29kZ4eDh+//13ecP9f6dOncK4cePg6uqqsd3Ly6vMv7DlcP36dfz3339wcXHB3bt3ce3aNRQUFGhcVpBLTk4OHB0dtbbn5+fLkKZs9vb2Oi9b2dnZoWrVqjIk0i0jIwOfffYZPD095Y6iU+klFpVKhVu3bqF69eqwtLSUOZVuaWlpGD58uNZ2BwcH5ObmypBIm5WVldF+rR+9l+U333yDgQMHahRmtWrVgqurK9auXYvmzZtXeB4OWpbY3r178cYbb+gsJvbu3Stjsv9Rq9VIT0/X2p6eng5jurWao6Mj0tPToVarcfLkSbz44osASsZ8PPr+yqmgoAA2NjZa23NycozmBn6bN2/Gl19+ieDgYPzf//0fZsyYgZSUFHz++ee4ePGi3PFQp04dnDhxQnxc2iOxe/du8S9BY/DWW29hxYoVuHv3rrgtOzsbq1atwltvvSVjMk0BAQHIyMiQO0aZCgsLsXDhQvTr1w+ffvopMjMzAQA//fQTNm/eLG+4x1StWlXj610qJSUFLi4uMiTSFhERgYSEBKP62a1LWloaPDw8tLZ7eHjo/H1UEdjDI7HSYsLb21tjuzEVE2FhYVi4cCEyMjI0uha3bNmCsLAwecM9IiwsDHPmzBG75YODgwEAly5d0np/5VK/fn3s378fUVFRAEp+WavVamzdutUoxhgBJYNFP//8czRu3BgA4OPjg+nTp+Pnn3/GxIkTsWbNGlnz9enTB9OnT0d6ejqKi4uRkJCAq1ev4uLFi5g0aZKs2R61c+dOZGRkYOjQoXBzcwMAZGZmQqlUIicnB7t27RLbxsbGVmq2RweHvvbaa1i5ciWys7Ph6+ur1XtSGYNDy7N69WqTGLMFAKGhoVi9ejU+/fRTKBQKCIKA8+fPIy4uDu3atZM7HgDg/PnzOHfuHE6ePImaNWtqzXQzlkkoNWvWxKZNm/DBBx/A2toaQMnMvE2bNqFmzZqVkoF3S5fYihUrsG/fPvTo0UOrmGjXrh0GDBggc8KSouzXX39FQkICsrOzAQBOTk7o0qULXn/9daPpPQFKxvFkZmaiVatW4mWjffv2oWrVqnjppZdkTldSyE6cOBH+/v44e/YsmjVrhqtXryI3NxdTpkwxiq7mnJwcODg46NyXlJQk26ydR6WlpWHr1q24cuUK1Go1/Pz80L17d/j6+sodTbR+/Xq92/bq1asCk2gzZP0auQYtlxo6dKg4Zqt///6YPXs2qlevjoyMDIwePRorVqyQNd+jVCoVFixYgMTERAAlvfVqtRqhoaGIiYkxip+VCxYsKHf/o0Mu5HT58mXExsZCrVajdu3aAEp6yhQKBcaMGYOAgIAKz8CCR2KmVEwAJVNtARjVlNryPHjwwKjGSwAllzV27tyJ5ORkCIIAPz8/vPrqq3B2dpY7mujBgwc4cuQIbt68iTfeeAP29vZITk6Gk5OT0XTN09MzZLzYo+Mq5NCvXz/83//9H6pXr65R8KSkpGDChAlGU/AIgoDMzEw4ODggOztboxj38vKSO55JKigowMGDB3Ht2jUIgoCaNWsiNDS00sYS8pKWxCwsLNCtWzd069bNqIuJ4uJinDt3Djdv3kRoaCgAICsrC3Z2dkYxkBUoGXvi4eGB1q1bAygZ9PbXX3/B2dkZY8eOlb1rvpSTkxMiIyPljlGm1NRUTJkyBXZ2drh9+zY6duwIe3t7HD16FJmZmfjoo49kzVf6ffI4hUIBpVJplIvRFRYW4vDhwygoKEBwcLDsvwDlLmIMUTpm67XXXgNgvGO2BEHAxx9/jG+++QZeXl6oXr263JFMno2NDV5++WXZXt/4fpKYEWMsdICSvwanT5+OzMxMFBUVITg4GLa2tti6dSsKCwsxZMgQuSMCAHbt2oVhw4YBKFkt+MyZM/jiiy/w559/Ii4uDl9++aXMCUsUFhYiLS0N9+7d0xqn1axZM5lS/c/KlSsRFhaGfv36aUytbdy4MebNmydjshIDBw4sd7+rqyvCwsLQs2dPWXpI4+LioFKpxJwqlQrjxo1Deno6bGxssGrVKnz55ZeoV69epWfTJT4+Ho6OjggPD9fYvmfPHuTk5Mg+RsZUxmxZWFjAy8sL9+/fl72gfdzo0aMxfvx42NvbY9SoUeUuPVDZ48nKc+DAAfzxxx+4desWpk6dCnd3d/z222+oXr16pQxRYMEjkSd96EoZw4dv2bJl8Pf3x+zZsxEdHS1ub968ORYtWiRjMk13794Vx+0cP34crVq1QqNGjeDu7o5x48bJnK7EyZMn8f333+P+/fs698s9XgIouXaua0E3FxcX8bKrnIYOHYpffvkF7du3F6/jX758Gfv378dbb72FnJwc/Prrr7CyssKbb75Z6flOnjyJt99+W3x88OBBZGZmYt68eXBzc8PChQuxadMmjB07ttKz6bJr1y58/PHHWtt9fHzw7bffyl7w1KtXD1OmTMHWrVvh6emJU6dOwc/PD9OmTTOqMVtAyeW3VatWYfDgwUaVrVmzZuIsUGMYy6iPnTt3Yu3atejatSs2btworghtb2+PhIQEFjymxFQ+dABw4cIFTJkyRetSgZubG7KysmRKpc3e3h537tyBm5sbTp48Kc6EAqC1fLpcli5dipYtW6Jnz57imkHGxtraGg8fPtTafv369TIHM1em/fv345133hEvXQIlP9B9fX2xa9cufPXVV3Bzc8OmTZtkKXgyMzM1ZpGcOnUKLVu2FC8jdenSBTNmzKj0XGXJzs7WOX6sdCyK3FJTU1GrVi2dl1KPHj1aKeux6Ou7775DQUEBPv/8c1hZWYmzi0otW7ZMllyPDoqv7AHyT+v333/H+++/j+bNm2ssP+Dv74+4uLhKycCCRyK9evXSGOSma20WY6FWq3UWDFlZWUazOCJQ0uM0b948eHp6Ijc3V5xWnZKSYhSzn4CSGVARERFGW+wAJcXDhg0bxJWgFQoFMjMzsWbNGqO4lcjFixd19kD5+fmJ6wS98MIL4notla10OnKpS5cuaay7Y2dnZzSL0AEllwDPnz+vtebJhQsXjGIg/bRp0zBlyhStMTFHjhzB/PnzK+2Xnz6MYVatvv777z9cu3YNQMkUcH9/f5kTabp16xb8/Py0tiuVykpbZJQFj4QeH+RmrIKDg7Ft2za8//77AEp+oOfn52PdunViUWEMBgwYAHd3d9y5cwf9+vUTB1PfvXsXnTp1kjldiRYtWiApKcloCjBd3nnnHcyYMQPvvfceCgsLMWHCBGRnZyMwMFCj10wurq6u2LNnj9by8nv27BEvad6/f1+22Xk1atTA8ePHERERgatXryIzMxNBQUHi/szMTKMqeMPDw7FixQoUFxeLOc+cOYPVq1cjIiJC5nRAp06dMHnyZEydOlUswA4fPoyFCxcazRTqUsa0LllZ7ty5g7lz5+LChQviuNG8vDwEBgZi+PDh4ppRcvPw8EBKSorWAPt//vmH6/CYqk8//RQffPCBUc02eFxWVhYmTZoECwsLZGRkwN/fHxkZGahWrRomTZqkc5l/0q2goADffPMNHBwcdC7y1qVLF5mSaTt79qw4dd7f319cuVpux44dwzfffIMaNWqI958r/Wv1s88+Q9OmTbFz507cuHFDlr+4jxw5grlz56J+/fq4evUq6tSpgzFjxoj7V61ahVu3bhnNzUMFQcDq1avx+++/Q6VSASi5rNmtWzf07NlT5nQlli1bhjNnzmDy5Mk4efIkFi1ahI8++ggtW7aUO1qZCgsLxfezlDFMTJk6dSoePnyImJgYcUHW69evY+HChbCxsTGayR179+7F2rVr0b9/fyxcuBAffPABbt68ifj4eHzwwQdo06ZNhWdgwSOxEydOYPPmzUY3yO1xhYWFOHToEK5cuSKuHdO2bVuta9TGID09HZmZmVo/bIxhBtTu3buxePFiWFtbo1q1ahr7FAqFxs3zKtulS5c0LgUCJYs2rl+/HgUFBXjppZcQHR1tFLfAuH37tljUCIKAGjVq4OWXX0ZeXp64SJmcTp8+jRMnTsDJyQmvvfaaxiXr9evXo0GDBkaxsrZarcb58+fh6+sLKysrpKenw9raGl5eXkbxdX7Ud999h8uXLyMrKwsff/yxUY6DzM/Px+rVq/Hnn3/qnJhgDJMS+vbti6lTp2pdLkpOTsb48eOxevVqmZJp27VrFzZt2oQ7d+4AKJk40atXL60ZhRWFBY/EBg4ciIKCAhQXFxvVILdHlXX/J2Nz8+ZNfP3110hLS9O53xh+2Lz33nt47bXX0L17d6NbVHL69Olo0KCBOCsnLS0No0ePRvv27VGzZk1s3boVL7/8stGtIfTgwQMcPHgQe/fuRUpKilF8nU1J3759MWfOHJ33LZLLsWPHtLapVCqsWLECjRo10vjjxRj+kCm1ZMkSnDt3Dr1798b333+PQYMGISsrC7t27UKfPn3Qtm1buSNi+PDhGDZsmNZKxZcvX8bcuXPx3XffyZRM06OLxubk5EAQBPFqQkZGRqUMC+AYHomZwiC3wYMH46WXXkK7du0QHBxsdL+oSy1btgzu7u4YP348PvroI0yfPh25ublYuXKl0dzRXaVSoXXr1kb5HqakpGjcciAxMREBAQH44IMPAJSMnVm3bp3RFDxnz57Fnj17cPToUbi7u6NFixZiVmORm5uLPXv24Nq1a1AoFPD29kZ4eDjs7e3ljiby9fXFzZs3jargmT17dpn79u7dq3FjZWMqcI8fP46PPvoIDRs2xMKFC1G/fn14enrC3d0dhw4dMoqCp1+/fvjpp58waNAg+Pv7Q6FQ4L///sOyZcuM5uckAMyYMQNfffUVrK2tNWaHXr9+HZMnT66UJVFY8EjMFAa5ffTRR0hMTMTXX38NW1tbtG7dGm3btq2Ue5kY4tKlS/jqq6/g4OAAhUIBCwsLvPDCC+jTpw+WLVuGWbNmyR0R7du3x+HDh2WZLv0kDx480BiPlZSUhJCQEPFxnTp1xK5ludy5cwf79u3D3r17UVBQgFatWqG4uBifffZZpQ1k1FdSUhJiY2NhZ2cnjjXavn07Nm7ciNGjRxvFPckAICoqCnFxcejduzf8/f21enPlGHdiTEWMIXJzc8XC0dbWVpyN98ILL2Dx4sWy5Xp8sc6CggJ88cUX4hjC4uJiWFpaYuHChUYzzb9q1aqYPXs2xowZI+ZMT0/H5MmT0apVq0rJwIKnAmRkZGDfvn3IyMjAwIED4ejoiJMnT8LV1RU+Pj5yx0OLFi3QokULPHz4EEeOHEFiYiLGjx8PDw8PtG3b1mgGNqrVanFmloODA7KysuDt7Q03Nzdcv35d5nQlSu+MfurUKdSqVUtr0LKcPX6Ojo64desW3NzcoFKpcOXKFY3enPz8fK28lWnGjBk4f/48mjRpgujoaISEhMDCwgJ//PGHbJnKs3TpUrRu3Rrvvfee2KOnVquxZMkSLF26FP/3f/8nc8IS06dPB4Ay/yAw1eJDDtWrV8ft27fh7u6OmjVr4vDhwwgICMCxY8dkvaefKVxJeNxnn32GqVOnYu7cuRgxYgSuXr2KKVOmIDQ0tNLOhwWPxJKSkjB9+nTUq1cP//77L95++204OjoiNTUVu3fvxmeffSZ3RJGtrS06dOiADh06ID09HfPmzcP69euNpuDx8fFBamoqqlevjoCAAGzduhVWVlbYtWuX0dzX5urVq+JgwatXr8qcRlNISAjWrFmDvn374u+//4aNjQ3q168v7k9NTZV1Ov2pU6fw2muvoVOnTka9jEOpjIwMfPbZZxqXLy0sLBAREYH9+/fLmEzThAkT5I5Qrp9++gmenp5aMxi3b9+OjIwMvPvuu/IEe8TNmzfh7u6OsLAwpKSkiGPhZs6cie3bt6O4uFjWosMUriQ8ztraGmPGjMHEiRPxzTff4Pz582jXrl2lXnZjwSOx1atXIyoqChERERr3LWrYsCESEhJkTKatsLAQx44dw6FDh3Dq1Ck4ODjg9ddflzuW6M0330RBQQGAkm76mTNnYsKECbC3txcX0ZObMf9yiYqKwtdff42JEyeiSpUqiImJ0Vhde+/evQgODpYt3+TJk7Fnzx6MGTMGNWrUQLt27TRWWzY2/v7+SE9PF6f+lkpPTzeKmWSljOXSWln++usvjB49Wmt7YGAgNm/ebBQFz8cff4wff/xRXLdozpw5GDhwIL799lv8999/qF69ulF9zUsZ29R5XTcG/uSTTzBlyhS0aNECb731VqXeZJsFj8TS0tIwfPhwre0ODg5GsxrrqVOncPDgQfz999+wsLBAy5YtMW7cOKP7QfnoeJPq1atjzpw5yM3NRdWqVfW6b9nzzsHBAZMnT0ZeXh6qVKmiNbD6008/FS8ZyiEwMBCBgYEYOHAgEhMTsXfvXqxYsQJqtRqnT5+Gq6ur7Ct/p6amiv9+7bXXsHz5cmRkZIjrbF28eBE7duzQWjTRGBQUFOhczqFWrVoyJSqRm5ur85ebnZ1dmfekk9s///yDPn36oHr16kazkF8pY546X96Ngf/44w+Ny9eVkZMFj8SqVq2Ku3fvas2QSElJgYuLi0ypNM2ePRtNmjRBTEwMmjRponVPLWNmTLNhSl2+fBlHjhzR+ctl5MiRMqX6n7L+cjKW99LGxgbh4eEIDw/H9evXsWfPHmzevBmrV69GcHCwzt6AyjJq1CitbbrWNZk7d67R9E7l5ORgwYIF+Oeff3Tul3sMj6enJ06ePInOnTtrbP/nn3+MamaZqVi1ahXOnTuHwYMH65w6Lydj6wE3nd90JiI0NBSrV6/Gp59+Kt6D5/z584iLi0O7du3kjgcA+PHHH41ihVBdvv76a73bGkMxkZiYiO+//x6NGjXC6dOnERwcjIyMDGRnZxvN7AhT4u3tjX79+qFPnz44duyYxnRlOci5cOTTWr58OR48eIBp06Zh0qRJ+Pzzz5GdnY1NmzZpXGaXS9euXfHTTz8hJydH49YXv/32m1ENxn28F9lYe5WNeep86VWD4uJibNq0CR06dJC1h4wFj8SioqKwYMEC8T5VI0aMgFqtRmhoqMYNBytbXl6eRpGj69pqKTmLIWMtxMoSHx+PAQMGoHPnzujfvz8GDhwIDw8P/Pjjj0Zxo0ZTZWFhgebNm8teND5+3x9TcPbsWYwaNQoBAQGwsLCAm5sbgoODYWdnh/j4eDRp0kTWfOHh4VCpVNi0aRM2btwIoOR9Hjx4MNq3by9rtkfNnz9fXJ26qKgIixcv1pribwx/dBnr1PlHWVpa4tdff5X968uCR2JWVlb4+OOPERkZiZSUFKjVavj5+ck+C2XgwIH48ccf4ejoWO51VUDeLm9ju3ngk9y8eVP8BaJUKlFQUACFQoGuXbti8uTJRrOoHz2dY8eOISQkBFZWVjpXC36UsawQXFBQIC7sZm9vj5ycHHh7e8PX1xdXrlyROV2JTp06oVOnTsjJyYG1tbWsY8l0efwXszEsMFgWY506/7igoCAkJSXJetmSBU8F8fT0NKo7aJfObgKAr776ymi7Zx9169YtFBcXaxWLN27cgKWlpVFc77e3t0d+fj6AkvvCpKWlwdfXF3l5eeIMMzJds2fPFv9QKG+1YED+sTGlvL29cf36dXh4eKBWrVrYtWsXPDw8sHPnTqPrdXx0xV1jYkp/eBnr1PnHNW7cGGvWrEFaWhr8/f21itzK+IOB99KS2IoVK3RuVygUUCqV8PT0xEsvvWQ0A0aN2YQJE9ChQwetNScOHDiAPXv2YOLEibLketTcuXNRp04dREREYNOmTUhISECzZs1w5swZ+Pn5GUWXNz1fDh48iOLiYoSFheHKlSuYNm0a7t+/DysrK8TExMgyuHr06NEYP3487O3tMWrUqHL/4IqNja3EZOYnMzMT//33Hzw9PWWfkfeoR29zowtnaZmglJQUJCcnQ61Wi+t13LhxAxYWFqhRowZ27tyJlStXYsqUKbItnf/RRx8hNDQU7dq101pTxJikpKTghRde0NoeGBiIn376SYZE2gYNGoTCwkIAQPfu3WFpaYnz58+jefPmso7ZIunouuv8/v37sW7dOqO663xBQQHi4uLw999/o7i4GKdOncLAgQMxf/58XLt2DW5ubrL1qDRr1kx8f4zxruim6OzZs1i6dCmmTZumMfbRzc0NdnZ2+PLLL/Hee+9pLDYqJ2PoAWXBI7FmzZqhatWqGDp0qPghzMvLw6JFi/DCCy+gY8eOmDt3LlasWIFx48bJkrFz585ITExEfHw8ateuLS74Zmzd3QDw8OFDrW15eXlQq9UypNH2aE+dhYUFunXrhm7dusmYiKS2fv16NGjQQCx40tLSsGjRIo27zjs7O8s+XmvdunXYv38/QkNDYW1tjUOHDmHJkiX49NNP4e/vL2u2Xr16YcGCBRg4cCB69eolaxZzsW3bNnTs2LHMNY1efvll/Pbbb0ZT8BgDFjwS27p1K8aPH6/xIbSzs0OvXr0wdepUdOnSBT179sS0adNkyxgREYGIiAhcv34dhw4dws6dO7Fq1So0bNgQbdu2lX0kfan69esjPj4en3zyica9i+Lj43X2/FSmJ3XPAiWXMX/55ZdKSEMVyVTuOn/06FF88MEHaNOmDYCSgbbjx4+HWq3WWnRSDvv370ffvn1lX0zSXKSmppa74GWjRo3w66+/VmKiJ8vPz0dSUpLONcsev9VIRWDBI7G8vDzcu3dP63JVTk6O2FtRtWpVrS+2HLy9vREZGYnIyEhcvHgRS5YswYIFC4ym4Onbty8mTpyI4cOHi3+l/Pvvv3j48CG++uorWbOVNzbnwoUL2L59Ozg8zjyYwl3ngZKxG4/+NV86LT0rK8voVgemZ3fv3r1yF421tLRETk5OJSYq35UrVzBjxgwUFBSgoKAA9vb2uH//PqytreHo6MiCxxS99NJLWLhwIfr37486depAoVDg8uXLiIuLE69dX758WfZp6qUuX76MQ4cO4fDhw8jLy0PLli3ljiTy8fHB7NmzsWPHDqSkpMDa2hrt27dH586dZR/0rWscwrVr17BmzRocP34coaGhiIqKkiEZSc3Y7zpfSq1Wa/0CtLS0NJrLv4DxLt5nikpnhZY1Gzg1NdWohimsWLECTZs2xXvvvYd3330X06ZNg6WlJb777rtKKXYAFjySGzJkCJYvX45vv/0WxcXFAEp+6LRv316cIlijRg2xO1wOpZeyDh06hNu3b6Nhw4bo06cPWrRoYRTdzY8PvgwKCkJMTIzRTmHNysoSx080atQIs2bNgq+vr9yxSCLGftf5Rz26WB6ge8E8OWcO6rrP4OOWLVtWCUlMX+PGjbF27VqEhITA2tpaY19hYSHWrVsn+yKTj0pJScGQIUNgYWEBCwsLFBUVoXr16ujXrx/mz5+PFi1aVHgGFjwSq1KlCj744AO8++67uHnzJgRBgKenp8aaA3LfZXfEiBHw9/fHq6++ijZt2sDJyUnWPI97dPClUqlEYmKiOPjSmOTl5WHTpk3Yvn07ateuja+++ooDBM2Qsd91vpSuS9HGtmBer169TG41dWP15ptv4q+//sLw4cPRuXNneHt7Q6FQID09HTt27IBarcabb74pd0zRo72gjo6OyMzMRM2aNWFnZ4fMzMxKycB1eJ4zarUae/bsQcuWLWW/LFSWYcOGISoqShx8efnyZYwfPx6rV682isGXALBlyxZs2bIFTk5OePvttznV9jlQ1l3nc3NzUaVKFZO6Ca8cevfuLS7iSNK4ffs2lixZgpMnT2psDwkJwaBBg4xicdZSU6dORVhYGEJDQ/Hjjz8iJSUFr732Gg4cOIAHDx5g+vTpFZ6B36ESy8/Px+bNm3H27Fncu3dPa+Cq3DcjtLCwwLJlyxAcHGy0BY8pDL5cs2YNrK2t4enpif3792P//v0623HhQfNh7Hedp+ePu7s7xo4di9zcXGRkZAAoWeXfGD+Tb7/9tjhxJyoqCvPnz8eSJUvg6emJDz/8sFIysOCR2KJFi/Dvv/+ibdu2cHZ2NspBer6+vrh586ZRVf+PMoXBl+3atTPKry0RPX/s7e0REBAgd4xy1alTR/y3g4MDxo4dW+kZeElLYu+++y7GjBkj+zox5Tl16hRWr16N3r17w9/fX+sOwHJfY+/duzdCQkI0Bl8eP34cQUFBRjP4koiIDHfv3j1cv34dCoUC3t7elToZhT08EqtatapRdic+qvRa6axZs3Tul3sJcFMYfElERPrLy8vD0qVLcfjwYbG33sLCAq1atcLgwYMr5Q9t9vBI7MCBAzh27BhiYmK0ek6MRVJSUrn7GzRoUElJiIjoefDNN98gNTUVAwcORGBgIBQKBS5cuIDly5fD19e3UmbhsuCR2KhRo8Tp6O7u7lpjUXgnYCIiet688847GDdunNZwj3///RfTp09HXFxchWfgJS2JmcL0ZPbwEBFRZbK3ty/zRqdVq1atlAzs4XkOPenGl3KP4SEiIvOya9cu/Pnnn/joo4/EW15kZ2dj/vz5aN68OV555ZUKz8CCpwI8ePAAR44cwc2bN/HGG2/A3t4eycnJcHJygouLi9zxkJeXp/FYpVIhJSUFa9euRVRUFF588UWZkhERkbkYNWqUxvIdN27cQFFRkbieWmZmJpRKJby8vCpluAcvaUksNTUVU6ZMgZ2dHW7fvo2OHTvC3t4eR48eRWZmJj766CO5I+rsVgwODoaVlRVWrFjBcUZERPTMjG2IBwseia1cuRJhYWHo168f+vfvL25v3Lgx5s2bJ2OyJ3NwcMD169fljkFERGagV69eckfQwIJHYpcvX8Z7772ntd3FxQXZ2dmVH0iH1NRUjceCICA7OxubN2+W/camRERk3vLz87VWzq+MdXhY8EjM2tpavF/Io65fv16pK0qWZ9SoUTq3161bt9LuaUJERM+PW7duYenSpUhKSkJhYaHW/sqYLMOCR2LNmjXDhg0bMGLECACAQqFAZmYm1qxZgxYtWsicrsTjNzBVKBRwcHCAtbW1TImIiMiclQ7p+PDDD+Ho6CjLvQg5S0tieXl5mDFjBtLT0/Hw4UM4OzsjOzsbgYGBGDt2LKpUqSJbtkuXLiE3NxeNGzcWt+3fvx/r1q1DQUEBXnrpJURHR2vcw4qIiOhZvfPOO4iNjYW3t7dsGdjDIzE7OztMmTIFZ8+eRXJyMgRBgJ+fH4KDg+WOhvXr16NBgwZiwZOWloZFixahffv2qFmzJrZu3QpnZ2dERkbKnJSIiMxJQEAAMjMzWfCYo6CgIAQFBQEoWZfHGKSkpGgsOpiYmIiAgAB88MEHAABXV1esW7eOBQ8REUnq/fffx+LFi5GVlQVfX19YWlpq7K9Vq1aFZ2DBI7HNmzfDw8MDrVu3BlByw7S//voLTk5OGDt2rKyzoB48eABHR0fxcVJSEkJCQsTHderUwZ07d2RIRkRE5iwnJwc3b97EwoULde7noGUTtGvXLgwbNgwAcPr0aZw5cwZffPEF/vzzT6xatQpffvmlbNkcHR1x69YtuLm5QaVS4cqVKxq9Ofn5+VpVNxER0bNauHAhateujeHDh8s2aJkFj8Tu3r0LV1dXAMDx48fRqlUrNGrUCO7u7hg3bpys2UJCQrBmzRr07dsXf//9N2xsbFC/fn1xf2pqKjw9PWVMSERE5igzMxOjR4+W9XeMhWyvbKbs7e3Fy0InT57UuC/V4wstVbaoqChYWFhg4sSJ2L17N95//31YWf2v5t27d69RDK4mIiLz0rBhQ6SkpMiagT08EmvevDnmzZsHT09PjSngKSkpsveeODg4YPLkycjLy0OVKlVgYaFZ73766aeyTpsnIiLz1KxZM6xYsQJpaWnw9fXV+GO7dH9F4zo8ElOpVEhISMCdO3cQFhYGPz8/AMC2bdtQpUoVdOzYUeaERERElevRGcK6VMagZRY8REREZPY4hkdi+/btw4kTJ8THq1atwrvvvosvv/wSt2/fljEZERFR5ZoxYwby8vLEx5s2bdJYm+7+/fvirZgqGgseicXHx4v3pLp48SK2b9+Ofv36oVq1alixYoXM6YiIiCrPyZMnUVRUJD7esmULcnNzxcfFxcW4fv16pWRhwSOxO3fuiIOTjx49ipYtW+Lll19Gnz598O+//8qcjoiISD5yjqJhwSOxKlWq4P79+wBKFh4snZauVCpRWFgoZzQiIqLnFqelSyw4OBiLFi2Cn58fbty4gSZNmgAA0tPT4eHhIXM6IiKiyvX4qspyrLIMsOCR3KBBg/DLL7/gzp07+Oyzz1CtWjUAQHJyMtq0aSNzOiIioso1f/58KJVKAEBRUREWL14MGxsb8XFl4bR0IiIiqhALFizQq93QoUMrOAkLngpTUFCAzMxMqFQqje21atWSKREREdHzi5e0JJaTk4P58+fj5MmTOvdXxmqSREREpImztCS2fPly5OXlYdq0abC2tsa4ceMQExMDLy8vjB49Wu54REREzyX28Ejs7NmzGDVqFAICAmBhYQE3NzcEBwfDzs4O8fHx4qwtIiIiqjzs4ZFYQUEBHBwcAAD29vbIyckBAPj6+uLKlStyRiMiInpuseCRmLe3t7hMdq1atbBr1y5kZWVh586dcHZ2ljkdERHR84mztCR28OBBFBcXIywsDFeuXMG0adNw//59WFlZISYmBq1bt5Y7IhER0XOHBY9ECgoKEBcXh7///hvFxcV48cUXMXDgQNjY2ODatWtwc3MTL3URERFR5WLBI5G4uDjs3LkToaGhsLa2xqFDh9CwYUN8+umnckcjIiJ67nGWlkSOHj2KDz74QLx9RNu2bTF+/Hio1WpYWHCoFBERkZz4m1gimZmZqF+/vvi4dFp6VlaWjKmIiIgIYMEjGbVaDSsrzQ4zS0tLqNVqmRIRERFRKV7SktCjd4QFtO8KCwAjR46UIxoREdFzjQWPRNq3b6+1rW3btjIkISIiosdxlhYRERGZPY7hISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIye/8PNAuIM7DHi+AAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infer(\"Make a plot of count of null values in every column.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d5976695",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "print(df.isnull().sum().sum())\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "866\n"
+     ]
+    }
+   ],
+   "source": [
+    "infer(\"How many null values are there in total?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "3d4b5328",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "import pandas as pd\n",
+      "df = df.fillna(df.mode().iloc[0])\n",
+      "print(df)\n",
+      "```\n",
+      "This code imports the pandas library, then fills in the null values in the dataframe with the most occurring value in their respective columns using the `fillna()` and `mode()` functions. The final dataframe is then printed.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "     PassengerId  Survived  Pclass  \\\n",
+      "0              1         0       3   \n",
+      "1              2         1       1   \n",
+      "2              3         1       3   \n",
+      "3              4         1       1   \n",
+      "4              5         0       3   \n",
+      "..           ...       ...     ...   \n",
+      "886          887         0       2   \n",
+      "887          888         1       1   \n",
+      "888          889         0       3   \n",
+      "889          890         1       1   \n",
+      "890          891         0       3   \n",
+      "\n",
+      "                                                  Name     Sex   Age  SibSp  \\\n",
+      "0                              Braund, Mr. Owen Harris    male  22.0      1   \n",
+      "1    Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   \n",
+      "2                               Heikkinen, Miss. Laina  female  26.0      0   \n",
+      "3         Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1   \n",
+      "4                             Allen, Mr. William Henry    male  35.0      0   \n",
+      "..                                                 ...     ...   ...    ...   \n",
+      "886                              Montvila, Rev. Juozas    male  27.0      0   \n",
+      "887                       Graham, Miss. Margaret Edith  female  19.0      0   \n",
+      "888           Johnston, Miss. Catherine Helen \"Carrie\"  female  24.0      1   \n",
+      "889                              Behr, Mr. Karl Howell    male  26.0      0   \n",
+      "890                                Dooley, Mr. Patrick    male  32.0      0   \n",
+      "\n",
+      "     Parch            Ticket     Fare    Cabin Embarked  \n",
+      "0        0         A/5 21171   7.2500  B96 B98        S  \n",
+      "1        0          PC 17599  71.2833      C85        C  \n",
+      "2        0  STON/O2. 3101282   7.9250  B96 B98        S  \n",
+      "3        0            113803  53.1000     C123        S  \n",
+      "4        0            373450   8.0500  B96 B98        S  \n",
+      "..     ...               ...      ...      ...      ...  \n",
+      "886      0            211536  13.0000  B96 B98        S  \n",
+      "887      0            112053  30.0000      B42        S  \n",
+      "888      2        W./C. 6607  23.4500  B96 B98        S  \n",
+      "889      0            111369  30.0000     C148        C  \n",
+      "890      0            370376   7.7500  B96 B98        Q  \n",
+      "\n",
+      "[891 rows x 12 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "infer(\"Fill in most occuring values in the column in place of null values in the dataframe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed4ea91f",
+   "metadata": {},
+   "source": [
+    "## Plotting "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "1943f00e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "import matplotlib.pyplot as plt\n",
+      "\n",
+      "# Extract the 'Age' column from the dataframe\n",
+      "ages = df['Age'].dropna()\n",
+      "\n",
+      "# Create a histogram of the ages\n",
+      "plt.hist(ages, bins=20)\n",
+      "\n",
+      "# Set the labels and title\n",
+      "plt.xlabel('Age')\n",
+      "plt.ylabel('Frequency')\n",
+      "plt.title('Distribution of Ages')\n",
+      "\n",
+      "# Display the plot\n",
+      "plt.show()\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infer(\"Please plot the distribution of ages. Add lables to the figure and a suitable title too.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "00bc4aef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "import matplotlib.pyplot as plt\n",
+      "\n",
+      "# Convert the 'Sex' column to categorical data\n",
+      "df['Sex'] = df['Sex'].astype('category')\n",
+      "\n",
+      "# Group the data by Sex and Survived, then count the number of occurrences\n",
+      "grouped = df.groupby(['Sex', 'Survived']).size().unstack(fill_value=0)\n",
+      "\n",
+      "# Plot the distribution\n",
+      "grouped.plot(kind='bar', rot=0)\n",
+      "\n",
+      "# Add labels and title\n",
+      "plt.xlabel('Survived')\n",
+      "plt.ylabel('Count')\n",
+      "plt.title('Distribution of Gender against Survival')\n",
+      "plt.legend(loc='upper left')\n",
+      "\n",
+      "# Display the plot\n",
+      "plt.show()\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infer(\"Please plot the distribution of gender against survival. Add suitable labels and title.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c611bfd",
+   "metadata": {},
+   "source": [
+    "### This was a very complex prompt. Surprisingly, the model executed it very well!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "29b8dc89",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "import pandas as pd\n",
+      "import seaborn as sns\n",
+      "import matplotlib.pyplot as plt\n",
+      "\n",
+      "# Perform ordinal encoding on Embarked column\n",
+      "df['Embarked'] = df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2})\n",
+      "\n",
+      "# Prepare the data for heatmap\n",
+      "corr_data = df[['Pclass', 'Age', 'Fare', 'Embarked', 'Survived']].corr()\n",
+      "\n",
+      "# Generate the heatmap\n",
+      "plt.figure(figsize=(10, 8))\n",
+      "sns.heatmap(corr_data, annot=True, cmap=\"coolwarm\")\n",
+      "plt.show()\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infer(\"Follow these steps:1. Perform ordinal encoding on Embarked column and 2. Now plot a heatmap of this transformed embarked along with PClass, Age and Fare against Survived. Do both 1 and 2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "bc6b2363",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "import seaborn as sns\n",
+      "import matplotlib.pyplot as plt\n",
+      "\n",
+      "sns.regplot(x='Age', y='Fare', data=df)\n",
+      "plt.title('Regression Plot of Age against Fare')\n",
+      "plt.xlabel('Age')\n",
+      "plt.ylabel('Fare')\n",
+      "plt.show()\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infer(\"Please plot a reg-plot of age against fair. Add a suitable title and labels.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a54f8d18",
+   "metadata": {},
+   "source": [
+    "### The changed dataframe is being passed between inferences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "f6370e88",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m ```python\n",
+      "print(df['Embarked'].unique())\n",
+      "```\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "[ 0.  1.  2. nan]\n"
+     ]
+    }
+   ],
+   "source": [
+    "infer(\"Print the unique values from the Embarked column\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}