diff --git "a/EDA_Agent/EDA_Agent copy.ipynb" "b/EDA_Agent/EDA_Agent copy.ipynb" new file mode 100644--- /dev/null +++ "b/EDA_Agent/EDA_Agent copy.ipynb" @@ -0,0 +1,818 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c96b164c", + "metadata": {}, + "source": [ + "# Overview " + ] + }, + { + "cell_type": "markdown", + "id": "22c9cad3", + "metadata": {}, + "source": [ + "In this notebook, we will try to create a workflow between Langchain and Mixtral LLM.
\n", + "We want to accomplish the following:\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", + "import subprocess\n", + "import sys\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", + " 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. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "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": 4, + "id": "3f686305", + "metadata": {}, + "outputs": [], + "source": [ + "llm = ChatAnyscale(model_name='mistralai/Mixtral-8x7B-Instruct-v0.1', temperature=0.1)\n", + "agent = create_pandas_dataframe_agent(llm, df, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "083bf9ab", + "metadata": {}, + "source": [ + "# Building my own DF chain\n", + " 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.\n", + "\n", + "### Post Implementation Observation:\n", + " We were able to observe the following:
\n", + " 1. The agent now works very well almost always returning the desired output.
\n", + " 2. The agent is unable to output plots. " + ] + }, + { + "cell_type": "markdown", + "id": "c5caa356", + "metadata": {}, + "source": [ + "# Building an Agent " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "44c07305", + "metadata": {}, + "outputs": [], + "source": [ + "prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\n", + " \"system\",\n", + " f\"\"\"You are Data Analysis assistant. Your job is to use your tools to answer a user query in the best\\\n", + " manner possible. Your job is to respond to user queries by generating a python code file.\\\n", + " Make sure to include all necessary imports.\\\n", + " In case you make plots, make sure to label the axes and add a good title too. \\\n", + " You must save any plots in the 'graphs' folder as png only.\\\n", + " Provide no explanation for your code.\\\n", + " Read the data from 'df.csv'.\\\n", + " ** Enclose all your code between triple backticks ``` **\\\n", + " RECTIFY ANY ERRORS FROM THE PREVIOUS RUNS.\n", + " \"\"\",\n", + " ),\n", + " (\"user\", \"Dataframe named df: {df}\\nQuery: {input}\\nTools:{tools}\"),\n", + " MessagesPlaceholder(variable_name=\"agent_scratchpad\"),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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": 7, + "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": 8, + "id": "45129995", + "metadata": {}, + "outputs": [], + "source": [ + "agent_executor = AgentExecutor(agent=agent, tools=tools, df = 'df.csv', verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b82adfda", + "metadata": {}, + "outputs": [], + "source": [ + "def infer(path:str = '', user_input:str = ''):\n", + " \n", + " error_flag = True\n", + " \n", + " while error_flag:\n", + " result = list(agent_executor.stream({\"input\": user_input, \n", + " \"df\":pd.read_csv('df.csv'),\n", + " \"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", + "\n", + " # execute the code\n", + " try:\n", + " exec(code)\n", + " error_flag = False\n", + " except:\n", + " print(\"Error occurred!\")\n", + " error_flag = True\n", + " \n", + " return result[0]['output']" + ] + }, + { + "cell_type": "markdown", + "id": "7a55d4e5", + "metadata": {}, + "source": [ + "# Testing \n", + " Testing for the EDA Agent has been divided into 2 distinct tasks:\n", + "## **Data Smoothing**:\n", + ">i. Finding out the Null values.
\n", + ">ii. Filling the Null values.\n", + "\n", + "## **Plotting**:\n", + ">i. Distribution of ages
\n", + ">ii. Distribution of gender against survival.
\n", + ">iii. Heatmap of all variables with survival.
\n", + ">iv. Reg plot age against fare (since these are the only continuous features in our dataset)\n" + ] + }, + { + "cell_type": "markdown", + "id": "b6b73109", + "metadata": {}, + "source": [ + "## Smoothing" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + "# Read the data\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Calculate the number of null values in each column\n", + "null_counts = df.isnull().sum()\n", + "\n", + "# Create a bar plot of the null counts\n", + "null_counts.plot(kind='bar')\n", + "\n", + "# Set the title and label the axes\n", + "plt.title('Count of Null Values in Every Column')\n", + "plt.xlabel('Column Name')\n", + "plt.ylabel('Number of Null Values')\n", + "\n", + "# Save the plot as a png in the 'graphs' folder\n", + "plt.savefig('graphs/null_counts.png')\n", + "\n", + "# Display the plot\n", + "plt.show()\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAIPCAYAAAB34QSZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB480lEQVR4nO3deVhUZf8/8PcAA7LvCKgoiJqKiEuuqEhqbqWWoqm54FaS+VSumbkvZI+m5fKU5oKaO2ppaq65m5YrrikgKgICIiLLMOf3Bz/O13EGndEDZ2Z8v66rK+ece868zzDAh/vc930UgiAIICIiIjJjFnIHICIiIiptLHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iF7Rvn37EBoaCldXVygUCnTt2lXuSBoGDBgAhUKB+Ph4cVt8fDwUCgUGDBggW65nhYWFQaFQyB3jpaxYsQIKhQIrVqyQOwq9IoVCgbCwMLljUClgwUMarly5ghEjRiAoKAjOzs6wtraGr68vOnXqhGXLliE3N1fuiC9Ulr98EhIS8M477+Dff//FwIEDMWnSJPTq1eu5zzl48CAUCgUUCgUiIiJ0tikuSEJDQ0sjtkGaNWsGhUKB33///bntBEFA1apVoVAocOHChTJK9/ooLlyf999//vMfuWOWulOnTmHQoEGoUaMGHB0dYWNjg8qVK6N79+7YsGEDCgsL5Y5IRspK7gBkPKZOnYopU6ZArVajSZMm6N+/PxwdHXH//n38+eefGDx4MBYvXozTp0/LHdVo/PHHH3jy5AmWLl2K3r17G/z8jRs34vjx42jatGkppJPG0KFDcfz4cfz000/o0KFDie3279+PmzdvokmTJqhTp04ZJpRft27d0KRJE/j4+JT6a3Xp0gUhISE69zVp0qTUX18uBQUF+PTTT7FkyRJYWlqiVatW6NSpE2xsbHDnzh0cOHAAmzdvxvvvv49NmzbJHZeMEAseAgDMmDEDkyZNQqVKlbBx40Y0btxYq82uXbvwzTffyJDOeN29excA4Ovra/BzAwMDcePGDYwaNQpHjx6VOppkevbsif/85z/47bffcP/+fZQvX15nu6VLlwIAhgwZUpbxjIKzszOcnZ3L5LW6du1qVJciy8rw4cOxdOlS1KlTBxs3bkSNGjU09qvVaqxfvx6xsbEyJSRjx0tahPj4eEyZMgVKpRI7d+7UWewAQPv27XVe1li/fj1atGgBZ2dn2NraIigoCDNnztR5+et518dfNNYkPj4evXr1goeHB8qVK4cGDRpg+/btGscICwvDwIEDAQADBw7U6O5/+rjPo8/5FF+WmjRpEgCgdevW4uscPHhQr9dp3LgxunTpgmPHjmHz5s16PWfy5MklvkZpjcuxtbVF3759UVBQgJUrV+ps8+DBA8TGxsLJyQk9e/YEUHRp8f3330dAQABsbW3h5OSE5s2bY9WqVXq/9osuT5b0eVKpVFi0aBGaNGkCJycn2NnZoV69evjhhx+gVqu12sfGxqJ169bw9vaGjY0NvL29ERoaioULF75SzipVqqBKlSrIycnB6NGj4efnBxsbGwQGBmL27NkQBEGv4xvq+PHjUCgUeO+990psU61aNdjY2CA9PV1j++7du9GxY0d4eHjAxsYGVatWxejRo5GZmal1jOLze/jwIUaOHInKlStDqVRi8uTJGDduHBQKRYlf7zNnzkChUOCdd9554fkcPXoUS5cuhZubG3bv3q1V7ACAhYUFPvjgA8TExGhsV6vVWLRoEd588004ODjA3t4eDRs2xKJFi3R+FnTR9bOpWPHPgsmTJ2tsLx6TVlBQgKlTp6Jq1aooV64catSogZ9++klst3DhQgQFBcHW1hYVK1bE5MmTtXIZ+nOQdGMPD2H58uUoKChAr169EBQU9Ny2NjY2Go/Hjh2Lb775Bp6enujTpw/s7e2xc+dOTJgwAbt27cLevXthbW39yhkTEhLQqFEjBAQE4MMPP0R6ejrWr1+Prl274o8//sBbb70FoOgHk4uLC7Zt26bV9e/i4vLC19H3fKpUqYJJkybh4MGDOHToEPr3748qVaoAgPh/fXzzzTfYsWMHxo0bh3fffRdKpdKAd6XsDB06FAsXLsSyZcswZswYrf0xMTHIy8vDwIEDYW9vDwD4+OOPUatWLbRs2RI+Pj5IS0vDjh070L9/f1y5cgUzZ84slawFBQV45513sHv3brzxxhvo3bs3ypUrhwMHDmDEiBE4ceIEVq9eLbZfvHgxhg8fDm9vb7z77rvw8PBASkoKzp8/jxUrViAqKuqV87Rr1w53795Fhw4dYGVlha1bt2L8+PF48uQJpkyZ8qqnrKVp06aoXr06fvvtNzx48ADu7u4a+48dO4YbN27g/fffh5ubm7h96tSpmDRpEtzd3dGpUyd4eXnh/Pnz+Pbbb7Fz504cO3ZMqycrLy8P4eHhyMjIwNtvvw0HBwdUqVIFYWFhmDNnDv73v/+hX79+WhmXLFkCABg2bNgLz+fHH38EUPQ5fNFlw2d/RvXu3Rvr16+Hn58fBg8eDIVCgdjYWERFReHPP//EunXrXvj6r6JXr144efIkOnbsCKVSiU2bNmHo0KGwtrbG6dOnsXbtWnTu3Blt2rTBr7/+iilTpsDW1hZjx47VOpa+PwepBAK99lq3bi0AEH766SeDnnfkyBEBgFC5cmXh/v374vaCggKhY8eOAgBh+vTpGs8BILRq1Urn8fr37y8AEG7duiVuu3XrlgBAACBMnjxZo/2uXbsEAEL79u01ti9fvlwAICxfvrzUz2fSpEkCAOHAgQN6v86BAwcEAEKfPn0EQRCEqKgoAYAwf/58sU3xeTdv3lzv1yt+Tv/+/TW2P+99fbbt8zRq1EgAIBw6dEhrX+3atQUAwt9//y1uu3Hjhla73NxcISwsTLCyshJu376tsa9Vq1bCsz+SXvS11PV5Kn6PRo4cKahUKnG7SqUSIiMjBQBCbGysuL1evXqCtbW1xte8WGpqqs7XfVZJOStXriwAEDp06CDk5OSI2+/fvy84OzsLTk5OQn5+vl6vUfx17NKlizBp0iSd/12+fFlsP2PGDAGA8P3332sda9iwYQIAYfv27eK2/fv3i5+5zMxMnec3cuRInef31ltvCdnZ2Vqv06lTJwGAcOHCBY3tWVlZgr29vVCpUiWNr1FJ/P39BQDCH3/88cK2T1uzZo0AQGjYsKFGvuzsbKF+/foCAGH16tUaz9H1mdL1PVSs+Pt50qRJGtuLP88NGzYUMjIyxO3//vuvoFQqBWdnZ6FKlSpCUlKSuC8zM1Pw8PAQPDw8hIKCAnH7y/wcJG0seEioWbOmAED4/fffDXreoEGDSiyUrly5IlhYWAj+/v4a21+24KlSpYrOH4x+fn6Cu7u7xraXLXhe5nykKHhSUlIEJycnwd3dXfxFY4wFz9KlSwUAwocffqix/dixYwIAoUGDBnodZ9OmTQIAYeXKlRrbpSh4CgsLBXd3d8HHx0fn5yUjI0NQKBRC9+7dxW3169cX7OzshPT0dL3y6/KigkdX8devXz+dxUBJir+Oz/vv6UIuMTFRsLCwEBo2bKhxnNzcXMHFxUXw8vLS+KXatWtXAYBw6dIlna8fEhIieHp66jy/f/75R+dzduzYIQAQRowYobF90aJFAgBh6tSpep27ra2tAECjoNPHW2+9VWKhtGfPHgGA0Lp1a43tUhc8+/bt03pO8R+Zy5Yt09o3cOBAAYAQHx8vbnuZn4OkjZe0SBxHYOgaKP/88w+AovErz6pRowYqVqyIW7duITMzU6/LSc8TEhICS0tLre2VKlXC8ePHX+nYxcryfJ7m6emJcePG4csvv8SMGTOMdmB4r1698Nlnn2HTpk1YsGCB+B4Uj0cYOnSoRvvExERER0dj3759SExMxJMnTzT237lzR/KM165dw4MHD1CtWjVMmzZNZxtbW1tcuXJFfNynTx988cUXqF27Nnr16oWWLVuiefPm8PT0lCSTi4sLqlatqrW9UqVKAICMjAyDjrd8+XK9xmlVqlQJ4eHh2Lt3L+Li4lCrVi0AwPbt25GZmYnPPvsMVlb/9yvg+PHjUCqV2LBhg87j5efnIzU1VesSmY2NDerWravzOe3bt4e/vz9iYmIQHR0NW1tbAMD//vc/WFlZYdCgQfqeNoCX+xllYWGBVq1aae1r3bo1LC0t8ffffxt0TEM1aNBAa1vxJIfn7UtKSkLlypU19pXFz0FzxoKH4OvriytXriApKcmg5z18+BAA4O3trXO/j48PEhMT8fDhw1cuEEqaAWNlZaX3wMMXKcvzedZnn32GxYsXY8GCBa88ZqS02Nvbo3fv3vjf//6HNWvWICoqCo8ePcKGDRtgb2+PDz74QGx78+ZNNGrUCBkZGWjRogXatWsHZ2dnWFpaIj4+HitXrkReXp7kGR88eAAAuH79+nPHxmRnZ4v//vzzz+Hh4YFFixZh/vz5mDdvHhQKBVq3bo05c+agfv36r5TpeZ9dAKW6bkz//v2xd+9erFy5EtHR0QAgDjzv37+/RtsHDx5ApVK9cExRdna2RsFTvnz5EgsRCwsLDBs2DOPGjcOGDRvQv39/nDx5EufOnUO3bt30nt3o4+ODmzdvIikpSeeA5ZI8fPgQbm5uOsfGWVlZieO1SpOur3/x1/55+woKCvQ6VvFzpPo5aM44S4vExe327dtn0POKv/mSk5N17r93755GO6DoLzSVSqWzva5ZIGXpZc5HKuXKlcP06dORl5eHL7/8ssR2FhZF37K63sOyeP+Ke3GKp6CvXbsWjx8/Rq9eveDo6Ci2mzt3Lh48eIBly5bh4MGDWLBgAaZNm4bJkyfj7bff1vv1DD3f4q9Nt27dIBRdstf5361btzSe169fP5w4cQIPHjzAjh07MGjQIBw8eBDt2rVDamqq3nmNzXvvvQdHR0esXr0ahYWFSElJwe7du1G3bl2tXhlnZ2e4uro+930TBEGr1+FFvS6DBg2CjY0N/ve//wGA+H99BisXe5WfUenp6TqLB5VKhbS0NDg5Ob3wOHJ/35E0WPAQBg4cCKVSic2bNyMuLu65bZ/+q7xevXoAoHOK9I0bN5CUlAR/f3+N3hBXV1fcvn1bq31hYSHOnj37UvmfVdzla+hfzi9zPlL68MMPUa9ePfzyyy8lLu7o6uoKADrfw7JYELJ+/fpo0KABzp49izNnzoiFz7OXs27cuAEAeP/997WOcejQIb1fz9DzfeONN+Di4oITJ07o/CX3Ii4uLujYsSN++uknDBgwAA8ePMDhw4cNPo6xsLOzQ/fu3XH37l3s3bsXa9asgUql0urdAYoWLczIyMClS5ckzeDh4YEePXrg+PHjOHLkCNavXw9/f3+0a9dO72MUf75+/PFH3L9//7ltn/0ZpVar8eeff2q1+/PPP1FYWKhXD57c33ckDRY8hCpVqmDy5MnIz89Hp06dSvwG3rVrl8ZKu5GRkQCA6dOna/wVXFhYiFGjRkGtVmtdo2/cuDESExOxZ88eje3Tp09HQkKCJOdT3N2u64fT87zM+UhJoVDg22+/hSAIGD9+vM42xWskLV++XOOvzdu3b2Pq1Kmllu1pxQsLfvbZZzh9+jSCg4PRqFEjjTbFU/MPHDigsX337t1ikaSPhg0bwsLCAmvXrkVOTo64PT09Xef0eCsrK4wYMQL37t3Dp59+qjVuCCjqqXu6sN+1a5fOv9yLL3WUK1dO77zGqHi8z6pVq7Bq1SpYWVmhT58+Wu0+++wzAEVf3+IFNZ/2+PFjnDhx4qUyDB8+HAAQERGBnJwcDB061KDxOM2bN8eQIUPw4MEDtG/fHtevX9dqo1ar8csvv+DDDz8UtxV/T48fP17j85OTk4Nx48YBgF7f08Xfd0+vnwMAFy5cwPz58/U+D5IXx/AQAODLL78Ur9+/+eabaNasGRo2bAgHBwfx1hLXr19Hw4YNxec0a9YMY8aMwTfffIOgoCB0794d9vb2+P3333Hx4kWEhoZi9OjRGq8zatQo7N69G126dEHPnj3h5uaGY8eO4datWwgLC9N70b7nadq0Kezs7PDdd9/hwYMH4srAI0aMeO7lqJc5H6mFh4ejY8eO2Llzp879jRo1Et+nRo0aITw8HPfv38evv/6Kt99+2+Ai72X07t0bo0aNEns+nu3dAYp+wS1fvhwRERF4//33UaFCBVy8eBG7du1CREQE1q9fr9dr+fj4oF+/flixYgVCQkLQqVMnZGVlYefOnWjZsqU40PxpEydOxLlz57BkyRL8+uuvCA8PR4UKFZCSkoLr16/j6NGjmDFjhjiIt1evXihXrhxCQ0NRpUoVCIKAw4cP46+//kL9+vXRpk2bV3i3pLd169YSF9GsUqWK1oDmFi1awN/fHxs3bhTXKPLy8tJ67ltvvYXZs2dj/PjxqFatGjp27Ah/f39kZ2cjISEBhw4dQmhoKHbt2mVw5qZNmyIkJARnz56FUqkUFwc1xMKFC2FpaYklS5agZs2aCAsLQ926dcVbS+zfvx9JSUno3r27+JzevXtj27Zt2LBhA2rXro2uXbtCoVBg69atuHXrFiIiInQWf8/q0qULatSogV9++QVJSUniH27F632VNNCbjExZTwsj4xYXFyd88sknQu3atQVHR0dBqVQK3t7eQvv27YWlS5cKubm5Ws/55ZdfhObNmwsODg6CjY2NUKtWLWH69OnCkydPdL7G9u3bhQYNGgg2NjaCm5ub0LNnTyE+Pv6lpk/rmsosCILw+++/C02aNBHs7e3FKbu6ppTqYsj5SDEt/VmXLl0SLC0tdU5LF4SitTqGDh0qeHp6CtbW1kLt2rWF//3vf6U+Lf1pgwcPFgAItra2GmuMPO3o0aNC69atBRcXF8HBwUFo3ry5EBsb+8JpvM/Ky8sTxowZI1SoUEFQKpVC1apVhZkzZwoFBQUlLnOgVquFVatWCeHh4YKrq6ugVCoFX19foXnz5sKMGTOExMREse3ixYuFrl27Cv7+/oKtra3g6uoqhISECNHR0UJWVpZe78fzpqVXrlxZ53MM/ezoMy29pCUfil8LgLBp06bnvs7hw4eFHj16CD4+PoJSqRQ8PDyEunXrCp999pnw119/6X1+z5o/f74AQIiIiNCrfUlOnDghREZGCtWqVRPs7e0Fa2troWLFikLXrl2F9evXC4WFhRrtCwsLhYULFwoNGjQQbG1tBVtbW6F+/frCDz/8oNVWEEpeOiMpKUno2bOn4OrqKpQrV05o2LChsHnzZoM/z4Lw/Gnuuj4XL/tzkDQpBKGU1jYnIiL6//r164eYmBjs27cP4eHhcseh1xALHiIiKlUJCQmoXr06AgMDJR8UTaQvjuEhIqJSERMTg6tXr2L9+vXIz8/H9OnT5Y5ErzEWPEREVCqWLVuGP//8E5UqVcKCBQvQrVs3uSPRa4yXtIiIiMjscR0eIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweZ2k9IyMjo8S7eb8MT09Po7/bMjNKxxRyMqN0TCEnM0rHFHK+jhmtrKzEG7w+t51kr2gmVCrVS91lWZfim+OpVCoY62Q4ZpSOKeRkRumYQk5mlI4p5GTG5+MlLSIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMnuyDlqOionSO1m7Xrh0GDx4MQRCwceNG7Nu3D9nZ2ahWrRoGDRqESpUqiW0LCgoQExODo0ePIj8/H0FBQRg8eDDc3d3L8lSIiIjISMle8MyaNQtqtVp8nJiYiOnTp6Np06YAgG3btmHHjh0YPnw4fHx8sGXLFkyfPh3fffcdbG1tAQArVqzAmTNnMHLkSDg6OmLVqlWYPXs2oqOjYWHBTiwiIqLXnezVgJOTE1xcXMT//v77b5QvXx61atWCIAjYuXMnunXrhsaNG8PPzw9RUVHIy8vDkSNHAAA5OTnYv38/+vXrh+DgYPj7+2PEiBFITEzE+fPnZT47IiIiMgay9/A8TaVS4fDhw+jUqRMUCgXu37+PzMxM1K1bV2yjVCpRq1YtXL16FW3btsXNmzdRWFiI4OBgsY2bmxv8/Pxw7do1hISE6HytgoICjfV2FAqF2GNUvE7Aqyo+jlTHKw3MKB1TyMmM0jGFnMwoHVPIyYzPZ1QFz6lTp/D48WOEhYUBADIzMwEAzs7OGu2cnZ2RlpYmtrGysoKDg4NWm+Ln6xIbG4tNmzaJj/39/REdHQ1PT89XP5FneHt7S35MqTGjdEwhJzNKxxRyMqN0TCEnM+pmVAXPgQMHEBISAjc3N43tz1aC+qzO+KI23bp1Q+fOnbVeIzU1VbJbSygUCnh7eyM5OdmoV71kRmmYQk5mlI4p5GRG6ZhCztc1o5WVlV6dFUZT8KSmpuL8+fMYNWqUuM3FxQVAUS/O0/fJyMrKEnt9XFxcoFKpkJ2drdHLk5WVhRo1apT4ekqlEkqlUuc+qT8ogiAY7YevGDNKxxRyMqN0TCEnM0rHFHIyo26yD1ouduDAATg7O6N+/friNi8vL7i4uGgMPlapVIiLixOLmYCAAFhaWmq0ycjIQGJiIqpXr152J0BERERGyyh6eNRqNQ4ePIhWrVrB0tJS3K5QKNCxY0fExsbCx8cH3t7eiI2NhY2NDUJDQwEAdnZ2CA8PR0xMDBwdHeHg4ICYmBj4+flpDGQmIiKi15dRFDwXLlxAWloaWrdurbWvS5cuyM/Px9KlS/H48WMEBgZiwoQJ4owqAOjfvz8sLS0xb948ceHBsWPHcg0eIiIiAmAkBU/dunWxYcMGnfsUCgUiIiIQERFR4vOtra0RGRmJyMjI0opIREREJswoCh4iIiIqWeGQd/Vqd1vP41n+tP3lw5goXvMhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOyx4CEiIiKzx4KHiIiIzB4LHiIiIjJ7LHiIiIjI7LHgISIiIrPHgoeIiIjMHgseIiIiMnsseIiIiMjsseAhIiIis8eCh4iIiMweCx4iIiIye1ZyBwCA9PR0rF69GmfPnkV+fj58fHzw8ccfIyAgAAAgCAI2btyIffv2ITs7G9WqVcOgQYNQqVIl8RgFBQWIiYnB0aNHkZ+fj6CgIAwePBju7u5ynRYREREZCdl7eLKzszFx4kRYWVnhyy+/xNy5c9GvXz/Y2dmJbbZt24YdO3YgMjISs2bNgouLC6ZPn44nT56IbVasWIFTp05h5MiRmDp1KnJzczF79myo1Wo5TouIiIiMiOwFz7Zt2+Du7o7hw4cjMDAQXl5eqFOnDry9vQEU9e7s3LkT3bp1Q+PGjeHn54eoqCjk5eXhyJEjAICcnBzs378f/fr1Q3BwMPz9/TFixAgkJibi/Pnzcp4eERERGQHZL2mdPn0adevWxdy5cxEXFwc3Nze0a9cObdq0AQCkpKQgMzMTdevWFZ+jVCpRq1YtXL16FW3btsXNmzdRWFiI4OBgsY2bmxv8/Pxw7do1hISEaL1uQUEBCgoKxMcKhQK2trbiv6VQfBypjlcamFE6ppCTGaVjCjmZUTqmklNfcp2HnO+j7AVPSkoK/vjjD3Tq1AndunXDjRs3sHz5ciiVSrRq1QqZmZkAAGdnZ43nOTs7Iy0tDQCQmZkJKysrODg4aLUpfv6zYmNjsWnTJvGxv78/oqOj4enpKd3J/X/FvVXGjBmlYwo5mVE6ppCTGaUjV87bEh/Px8dH4iMaRo73UfaCR61Wo2rVqujduzeAosLj9u3b2LNnD1q1aiW2e7YaFAThhcd+Xptu3bqhc+fOWsdPTU2FSqUy6BxKolAo4O3tjeTkZL3yyoEZpWMKOZlROqaQkxmlYyo59XXv3j1ZXrc03kcrKyu9OitkL3hcXV1RsWJFjW0VK1bEyZMnAQAuLi4AinpxXF1dxTZZWVlir4+LiwtUKhWys7M1enmysrJQo0YNna+rVCqhVCp17pP6wywIgtF/gzCjdEwhJzNKxxRyMqN0TCXni8h9DnK8j7IPWq5Rowbu3r2rse3u3btitebl5QUXFxeNwccqlQpxcXFiMRMQEABLS0uNNhkZGUhMTET16tXL4CyIiIjImMnew9OpUydMnDgRW7ZsQbNmzXDjxg3s27cPQ4cOBVDU/dWxY0fExsbCx8cH3t7eiI2NhY2NDUJDQwEAdnZ2CA8PR0xMDBwdHeHg4ICYmBj4+flpDGQmIiKi15PsBU9gYCBGjRqFtWvXYvPmzfDy8kL//v3RokULsU2XLl2Qn5+PpUuX4vHjxwgMDMSECRPEWVUA0L9/f1haWmLevHniwoNjx46FhYXsnVhEREQkM9kLHgBo0KABGjRoUOJ+hUKBiIgIRERElNjG2toakZGRiIyMLI2IREREZMLY/UFERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdmTrODJz8+X6lBEREREkrIy9AnHjh3Do0eP8PbbbwMAkpOTER0djbt376JGjRoYM2YMHBwcJA9KRERE9LIM7uH59ddfkZeXJz6OiYnB48eP0bFjR9y5cwexsbGSBiQiIiJ6VQYXPPfv30elSpUAFF3GOnfuHPr06YP+/fujV69e+OuvvyQPSURERPQqDC548vLyYGNjAwC4ceMGCgoKUK9ePQBAxYoVkZ6eLm1CIiIioldkcMHj6uqK+Ph4AMDZs2fh6+sLJycnAMDjx4/FYoiIiIjIWBg8aLlRo0ZYt24d4uLicPbsWXTp0kXcl5CQgPLly0sakIiIiOhVGVzw9OrVC7m5ubh27RpCQ0M1Cp6///4bderUkTQgERER0asyuOCxtrbG0KFDde6bMWPGKwciIiIiktorLTx49+5dXLlyBbm5uVLlISIiIpKcwT08AHDo0CH88ssvyMjIAADMmjULAQEBmDt3LoKDg9GmTRtJQxIRERG9CoN7eI4fP45FixbB398fgwYN0tgXEBCA48ePSxaOiIiISAoGFzxbt25FWFgYxo4dq9WTU6FCBSQlJUkWjoiIiEgKBhc8SUlJaN68uc59Dg4OyM7OfuVQRERERFIyuOCxsbFBTk6Ozn3p6emwt7d/5VBEREREUjK44KlRowZ27doFQRC09h08eBC1atWSJBgRERGRVAyepdW9e3d8/fXX+PLLL8VLW6dOncKGDRtw+fJlzJw506DjbdiwAZs2bdLY5uzsjJ9++gkAIAgCNm7ciH379iE7OxvVqlXDoEGDxBuYAkBBQQFiYmJw9OhR5OfnIygoCIMHD4a7u7uhp0dERERmyOCCp2rVqhg/fjyWLVuGmJgYAEBsbCy8vb0xfvx4+Pn5GRyiUqVKmDhxovjYwuL/Op62bduGHTt2YPjw4fDx8cGWLVswffp0fPfdd7C1tQUArFixAmfOnMHIkSPh6OiIVatWYfbs2YiOjtY4FhEREb2eXmodnqCgIMybNw/Jycl4+PAhHB0d4evr+9IhLCws4OLiorVdEATs3LkT3bp1Q+PGjQEAUVFRGDJkCI4cOYK2bdsiJycH+/fvx4gRIxAcHAwAGDFiBD7++GOcP38eISEhL52LiIiIzMNLFTzFvL294e3t/cohkpOTMWzYMFhZWaFatWr44IMPUL58eaSkpCAzMxN169YV2yqVStSqVQtXr15F27ZtcfPmTRQWForFDgC4ubnBz88P165dY8FDREREhhc8hw4demGbVq1a6X28atWqISoqCr6+vsjMzMSWLVvw1VdfYe7cucjMzARQNKbnac7OzkhLSwMAZGZmwsrKCg4ODlptip+vS0FBAQoKCsTHCoVCvESmUCj0zv88xceR6nilgRmlYwo5mVE6ppCTGaVjKjn1Jdd5yPk+GlzwLFq06IVtDCl46tWrJ/7bz88P1atXx4gRI3Do0CFUq1YNgPYbo2uG2LNe1CY2NlZjsLS/vz+io6Ph6empd3Z9SdELVtqYUTqmkJMZpWMKOZlROnLlvC3x8Xx8fCQ+omHkeB8NLnh++OEHrW2PHj3CX3/9hWPHjuE///nPKwUqV64c/Pz8cO/ePbz55psAinpxXF1dxTZZWVlir4+LiwtUKhWys7M1enmysrJQo0aNEl+nW7du6Ny5s/i4uKhKTU2FSqV6pXN4+pje3t5ITk7Wq0iTAzNKxxRyMqN0TCEnM0rHVHLq6969e7K8bmm8j1ZWVnp1Vhhc8Og6qKenJwICAlBYWIidO3ciKirK0MOKCgoKcOfOHdSsWRNeXl5wcXHB+fPn4e/vDwBQqVSIi4tDnz59ABTdv8vS0hLnz59Hs2bNAAAZGRlITEwU2+iiVCqhVCp17pP6wywIgtF/gzCjdEwhJzNKxxRyMqN0TCXni8h9DnK8j680aPlZxbO3DLFq1So0bNgQHh4eePjwITZv3ownT56gVatWUCgU6NixI2JjY+Hj4wNvb2/ExsbCxsYGoaGhAAA7OzuEh4cjJiYGjo6OcHBwQExMDPz8/DQGMhMREdHrS9KCJy0tzeB1b9LT0zF//nxkZWXByckJ1apVw4wZM8SepC5duiA/Px9Lly7F48ePERgYiAkTJogDjAGgf//+sLS0xLx588SFB8eOHcs1eIiIiAjASxQ8cXFxWttUKhUSEhKwdetWBAUFGXS8F435USgUiIiIQERERIltrK2tERkZicjISINem4iIiF4PBhc8U6ZMKXFfnTp1WHQQERGR0TG44Jk0aZLWNqVSCU9PT52rJRMRERHJzeCCh3dDJyIiIlPDUb1ERERk9vTq4XneuJ1nKRQKfP311y8diIiIiEhqevXwGLI4kNyLGRERERE9S68ensmTJ5dyDCIiIqLSwzE8REREZPZeaaXlrKws5Ofna2338PB4lcMSERERSeqlCp7Nmzfj999/x6NHj3TuX79+/SuFIiIiIpKSwZe09u/fj61bt6JDhw4AgG7duqFbt25wd3eHj48PPvroI8lDEhEREb0Kgwue3bt3i0UOADRq1Ai9evXCd999B1tb2xJ7fYiIiIjkYnDBk5ycjOrVq0OhUAAounEoUHQDz86dO2Pv3r3SJiQiIiJ6RQYXPJaWlgCKFhi0tbVFenq6uM/R0VHjMREREZExMLjg8fHxQVpaGgCgatWq2LdvH1QqFdRqNfbu3QtPT0/JQxIRERG9CoMLnnr16uHy5csAigYsX7x4EQMHDsTAgQNx8uRJdOnSRfKQRERERK9Cr2npp06dQsOGDWFhYYHu3buL24OCgjBt2jQcO3YMAFC/fn0EBQWVTlIiIiKil6RXwfPf//4XTk5OaNWqFcLDw+Hr6yvuCwwMRGBgYKkFJCIiInpVehU8Q4YMwcGDB/Hrr7/i119/RfXq1REeHo6mTZuiXLlypZ2RiIiI6JXoVfC0adMGbdq0wd27d7F//34cPnwYS5YswYoVK9C0aVOEh4ejevXqpZ2ViIiI6KUYdGsJX19f9O3bF71798Y///yDAwcO4PDhwzhw4AB8fX3RunVrtGzZEi4uLqUUl4iIiMhwL3UvLQsLCzRo0AANGjTAo0eP8Oeff+LgwYNYs2YN1q1bh7Vr10qdk4iIiOilGTwt/Vm2trZwd3eHq6srAKCwsPCVQxERERFJ6aV6eAAgPj4eBw4cwJEjR5CdnQ0HBwd06NAB4eHhUuYjIiIiemUGFTzZ2dk4cuQIDhw4gPj4eCgUCtSpUwetW7dGo0aNYGX10vUTERERUanRq0I5d+4cDhw4gL/++gsqlQoeHh7o3r07WrduDQ8Pj9LOSERERPRK9Cp4Zs6cCSsrK7z55psIDw9HnTp1xLulExERERk7vQqe/v37o2XLlnBwcCjtPERERESS06vg6dixY2nnICIiIio1rzwtnYiIiMjYseAhIiIis8eCh4iIiMweCx4iIiIyeyx4iIiIyOzpNUvr0KFDBh20VatWLxWGiIiIqDToVfAsWrTIoIOy4CEiIiJjolfB88MPP5R2DiIiIqJSo1fB4+npWdo5iIiIiEoNBy0TERGR2ZN8DI9CocDHH3/80oGIiIiIpKZXwXPp0iW9D/gqd1GPjY3FL7/8go4dO2LAgAEAAEEQsHHjRuzbtw/Z2dmoVq0aBg0ahEqVKonPKygoQExMDI4ePYr8/HwEBQVh8ODBcHd3f+ksREREZD70KngWLlxY2jlw48YN7N27F5UrV9bYvm3bNuzYsQPDhw+Hj48PtmzZgunTp+O7776Dra0tAGDFihU4c+YMRo4cCUdHR6xatQqzZ89GdHQ0LCx41Y6IiOh1ZxTVQG5uLr7//nsMGzYM9vb24nZBELBz505069YNjRs3hp+fH6KiopCXl4cjR44AAHJycrB//37069cPwcHB8Pf3x4gRI5CYmIjz58/LdUpERERkRIyi4Fm6dCnq1auH4OBgje0pKSnIzMxE3bp1xW1KpRK1atXC1atXAQA3b95EYWGhxnPd3Nzg5+eHa9eulc0JEBERkVHT65LW03r27PnCNuvXr9f7eEePHsWtW7cwa9YsrX2ZmZkAAGdnZ43tzs7OSEtLE9tYWVnBwcFBq03x83UpKChAQUGB+FihUIiXyF5lHNLTio8j1fFKAzNKxxRyMqN0TCEnM0rHVHLqS67zkPN9NLjgef/997WCZmVl4fz581Cr1WjZsqXex0pLS8OKFSswYcIEWFtbl9ju2dcTBOGFx35Rm9jYWGzatEl87O/vj+jo6FJZc8jb21vyY0qNGaVjCjmZUTqmkJMZpSNXztsSH8/Hx0fiIxpGjvfR4IInIiJC53aVSoUZM2Zo9cY8z82bN/Hw4UOMGzdO3KZWq3H58mXs2rUL3333HYCiXhxXV1exTVZWlvg6Li4uUKlUyM7O1ujlycrKQo0aNUp87W7duqFz587i4+KiKjU1FSqVSu9zeB6FQgFvb28kJyfrVaTJgRmlYwo5mVE6ppCTGaVjKjn1de/ePVletzTeRysrK706KwwueJ73gu3bt8eaNWvQrl07vZ5Tp04dfPvttxrbFi9eDF9fX3Tp0gXly5eHi4sLzp8/D39/fwBFhVVcXBz69OkDAAgICIClpSXOnz+PZs2aAQAyMjKQmJgottFFqVRCqVTq3Cf1h1kQBKP/BmFG6ZhCTmaUjinkZEbpmErOF5H7HOR4HyUreADA2toaGRkZere3tbWFn5+fxjYbGxs4OjqK2zt27IjY2Fj4+PjA29sbsbGxsLGxQWhoKADAzs4O4eHhiImJgaOjIxwcHBATEwM/Pz+tQdBERET0epKs4MnKysL27dvh6+sr1SEBAF26dEF+fj6WLl2Kx48fIzAwEBMmTBAHGANA//79YWlpiXnz5okLD44dO5Zr8BARERGAlyh4oqKitAYRFxQUICsrCwqFAmPGjHmlQJMnT9Z4rFAoEBERUeLYIaCoZykyMhKRkZGv9NpERERkngwueGrVqqVV8CiVSnh6eqJZs2bw8vKSLBwRERGRFF6qh4eIiIjIlHCQCxEREZk9vXp4Tp48adBBGzdu/FJhiIiIiEqDXgXP3Llz9T6gQqHAunXrXjoQERERkdT0KngmTZr03P35+fn4/fffcfbsWbO5zwgRERGZD70Knlq1apW47+DBg9i4cSPS0tLQsGFD9O7dW7JwRERERFJ46YUH//77b6xduxa3b99GjRo18Omnnz733lVEREREcjG44Llx4wZWr16Ny5cvo2LFihg9ejQaNmxYGtmIiIiIJKF3wXPv3j388ssvOHnyJNzc3DBs2DCEhYXx9g1ERERk9PQqeJYuXYr9+/fDxsYGvXv3RseOHUu80zgRERGRsdGr4Pnjjz8AABUrVsSVK1dw5cqVEttKcT8tIiIiIinpVfB4eHgAANLT05Genv7ctpyWTkRERMZGr4Jn4cKFpZ2DiIiIqNRwxDERERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9vQqelStXIi0tDQCQlpYGlUpVqqGIiIiIpKRXwbNz505kZmYCAKKiohAfH1+KkYiIiIikpVfBY29vLxY8RERERKZGr4UHq1WrhiVLliAwMBAAEBMTAzs7O51teWsJIiIiMjZ6FTyDBw/GihUrkJSUBABITk6GlZXup/LWEkRERGRs9Cp4PD09MXr0aABAz549MXr0aLG3h4iIiMjYGTwtfdKkSahYsWJpZCEiIiIqFXr18DytVq1aAIoua128eBGPHj2Co6MjgoKC4O3tLXlAIiIioldlcMEjCAJ+/vln/PHHHxAEQdyuUCjQrl07REZGShqQiIiI6FUZXPDs2LEDe/bsQdu2bREWFgY3Nzekp6fj0KFD2LNnD7y8vNC5c+fSyEpERET0UgwuePbt24f27dtj4MCB4jY3NzcEBgbCwsIC+/btY8FDRERERsXgQcspKSlo0KCBzn0NGjRASkrKK4ciIiIikpLBBY+dnR1SU1N17ktNTYWtre0rhyIiIiKSksEFT506dbBu3TrcvHlTY3t8fDw2bNiAunXrShaOiIiISAoGj+Hp3bs3vvrqK4wfPx4VK1aEq6srMjIykJSUBDc3N/Tu3bs0chIRERG9NIMLHg8PD3zzzTf47bffcOnSJaSkpMDR0RFdu3ZFp06d4OTkVBo5iYiIiF6awQUPADg5ObEnh4iIiEyGwWN4iIiIiEwNCx4iIiIyeyx4iIiIyOyx4CEiIiKzZ3DBo1KpNG4aSkRERGTsDJqllZ+fjw8//BBffPEFGjVqJEmAPXv2YM+ePeLqzRUrVkT37t1Rr149AEV3Z9+4cSP27duH7OxsVKtWDYMGDUKlSpXEYxQUFCAmJgZHjx5Ffn4+goKCMHjwYLi7u0uSkYiIiEybQT081tbWcHR0hI2NjWQBihcrnDVrFmbNmoWgoCB88803uH37NgBg27Zt2LFjByIjIzFr1iy4uLhg+vTpePLkiXiMFStW4NSpUxg5ciSmTp2K3NxczJ49G2q1WrKcREREZLoMvqTVoEEDnDp1SrIADRs2RP369eHr6wtfX1988MEHKFeuHK5fvw5BELBz505069YNjRs3hp+fH6KiopCXl4cjR44AAHJycrB//37069cPwcHB8Pf3x4gRI5CYmIjz589LlpOIiIhMl8ELDzZv3hyLFy/GokWL0LhxY7i6umq1CQgIeKkwarUax48fR15eHqpXr46UlBRkZmZq3J9LqVSiVq1auHr1Ktq2bYubN2+isLAQwcHBYhs3Nzf4+fnh2rVrCAkJ0flaBQUFKCgoEB8rFArxxqcKheKl8j+r+DhSHa80MKN0TCEnM0rHFHIyo3RMJae+5DoPOd9HgwueGTNmAAAOHTqEQ4cO6Wyzfv16g46ZmJiICRMmoKCgAOXKlcOoUaNQsWJFXL16FQDg7Oys0d7Z2RlpaWkAgMzMTFhZWcHBwUGrTWZmZomvGRsbi02bNomP/f39ER0dDU9PT4Oy68Pb21vyY0qNGaVjCjmZUTqmkJMZpSNXztsSH8/Hx0fiIxpGjvfR4ILn448/ljyEr68v5syZg8ePH+PkyZNYuHAhpkyZIu5/thLUZ5bYi9p069YNnTt31nqN1NRUqFQqQ+KXSKFQwNvbG8nJyUY7s40ZpWMKOZlROqaQkxmlYyo59XXv3j1ZXrc03kcrKyu9OisMLnjCwsJeJs/zQ1hZidVe1apV8e+//2Lnzp3o0qULgKJenKcvnWVlZYm9Pi4uLlCpVMjOztbo5cnKykKNGjVKfE2lUgmlUqlzn9QfZkEQjP4bhBmlYwo5mVE6ppCTGaVjKjlfRO5zkON9fKWFB+/evYsrV64gNzdXqjwAit6IgoICeHl5wcXFRWPwsUqlQlxcnFjMBAQEwNLSUqNNRkYGEhMTUb16dUlzERERkWl6qbulHzp0CL/88gsyMjIAALNmzUJAQADmzp2L4OBgtGnTRu9jrV27FvXq1YO7uztyc3Nx9OhRXLp0CRMmTIBCoUDHjh0RGxsLHx8feHt7IzY2FjY2NggNDQUA2NnZITw8HDExMXB0dISDgwNiYmLg5+enMZCZiIiIXl8GFzzHjx/HokWLUL9+fbz33ntYtmyZuC8gIADHjx83qOB5+PAhfvjhB2RkZMDOzg6VK1fGhAkTxGKlS5cuyM/Px9KlS/H48WMEBgZiwoQJ4owqAOjfvz8sLS0xb948ceHBsWPHwsKCd84gIiKilyh4tm7dirCwMHz88cdQq9UaBU+FChXw+++/G3S8Fw2CVigUiIiIQERERIltrK2tERkZicjISINem4iIiF4PBneBJCUloXnz5jr3OTg4IDs7+5VDEREREUnJ4ILHxsYGOTk5Ovelp6fD3t7+lUMRERERScnggqdGjRrYtWuXzulkBw8eRK1atSQJRkRERCQVgwue7t274/r16/jyyy+xc+dOAMCpU6cwe/ZsXL58Ge+9957kIYmIiIhehcEFT9WqVTF+/Hjk5uYiJiYGQNFtGu7du4fx48fDz89P8pBEREREr+Kl1uEJCgrCvHnzkJycjIcPH8LR0RG+vr5SZyMiIiKSxEsVPMW8vb1N5oZvRERE9Pp6qYInJSUFW7duxaVLl/Do0SM4Ojqidu3a6Nq1K7y8vKTOSERERPRKDB7DEx8fj7Fjx+LgwYNwc3NDcHAw3NzccPDgQYwZMwbx8fGlEJOIiIjo5Rncw7NixQo4OTlh4sSJ8PDwELenpqZi+vTpWLlyJSZNmiRpSCIiIqJXYXAPz40bN9CjRw+NYgcAPD090aNHD1y/fl2ycERERERSMLjgsbOzg52dXYn7nr6pJxEREZExMLjgCQ0Nxf79+3Xu27dvX4n32SIiIiKSi15jeE6ePCn+OyAgACdOnMD48ePRvHlzuLi4IDMzE0ePHkVWVhaaNm1aamGJiIiIXoZeBc/cuXO1tj148AA3b97U2v79998jNDT01ZMRERERSUSvgoezroiIiMiU6VXw8A7oREREZMoMHrRMREREZGpe6tYSp06dwpEjR5CamoqCggKNfQqFAnPmzJEkHBEREZEUDC54tm/fjjVr1sDJyQne3t4oV65caeQiIiIikozBBc/u3bvRunVrDB06FBYWvCJGRERExs/giiU7OxuhoaEsdoiIiMhkGFy11KhRA0lJSaWRhYiIiKhUGFzwDBgwALt378bp06ehUqlKIxMRERGRpAwew+Pt7Y06depgzpw5UCgUsLGx0WqzcuVKScIRERERScHggmf16tXYvXs3qlSpggoVKsDK6qVmthMRERGVGYOrlYMHD6JLly7o3bt3aeQhIiIikpzBY3jUajWCg4NLIwsRERFRqTC44AkODsa1a9dKIwsRERFRqTD4klb37t0xb948lCtXDvXr14eDg4NWG13biIiIiORicMEzevRoAEUzsUqajbV+/fpXS0VEREQkIYMLnvfffx8KhaI0shARERGVCoMLnoiIiNLIQURERFRqeEMsIiIiMnsG9/Bs2rTphW26d+/+UmGIiIiISoPBBc/GjRtf2IYFDxERERkTgwseXTOwsrOzcerUKezcuRPjxo2TJBgRERGRVCQZw+Pg4IDw8HCEhoZi+fLlUhySiIiISDKSDloODAzExYsXpTwkERER0SuTtOCJj49HuXLlpDwkERER0SszeAzPoUOHtLYVFBQgMTERBw4cQIsWLQw6XmxsLE6dOoU7d+7A2toa1atXR9++feHr6yu2EQQBGzduxL59+5CdnY1q1aph0KBBqFSpkkaGmJgYHD16FPn5+QgKCsLgwYPh7u5u6CkSERGRmTG44Fm0aJHO7UqlEi1atMCHH35o0PHi4uLw9ttvo2rVqigsLMS6deswffp0zJ07V+wt2rZtG3bs2IHhw4fDx8cHW7ZswfTp0/Hdd9/B1tYWALBixQqcOXMGI0eOhKOjI1atWoXZs2cjOjoaFhZcboiIiOh1ZnDB88MPP2htUyqVcHFxeakAEyZM0Hg8fPhwDB48GDdv3kStWrUgCAJ27tyJbt26oXHjxgCAqKgoDBkyBEeOHEHbtm2Rk5OD/fv3Y8SIEQgODgYAjBgxAh9//DHOnz+PkJCQl8pGRERE5sHggsfT07M0cohycnIA/N8d11NSUpCZmYm6deuKbZRKJWrVqoWrV6+ibdu2uHnzJgoLC8ViBwDc3Nzg5+eHa9eu6Sx4CgoKUFBQID5WKBRib5FU9worPo4x33uMGaVjCjmZUTqmkJMZpWMqOfUl13nI+T4aXPCUJkEQsHLlSrzxxhvw8/MDAGRmZgIAnJ2dNdo6OzsjLS1NbGNlZSUWSU+3KX7+s2JjYzVWjfb390d0dHSpFHTe3t6SH1NqzCgdU8jJjNIxhZzMKB25ct6W+Hg+Pj4SH9EwcryPehU8o0aN0vuACoUCc+bMeakwy5YtQ2JiIqZOnarzuE8TBOGFx3tem27duqFz585ax09NTYVKpdI38nMpFAp4e3sjOTlZr7xyYEbpmEJOZpSOKeRkRumYSk593bt3T5bXLY330crKSq/OCr0KHgcHhxd2P+Xm5uLmzZv6pdPh559/xpkzZzBlyhSNmVXFY4MyMzPh6uoqbs/KyhJ7fVxcXKBSqZCdna3Ry5OVlYUaNWrofD2lUgmlUqlzn9QfZkEQjP4bhBmlYwo5mVE6ppCTGaVjKjlfRO5zkON91KvgmTx5con7CgsLsXfvXvHyUGhoqEEBBEHAzz//jFOnTmHy5Mnw8vLS2O/l5QUXFxecP38e/v7+AACVSoW4uDj06dMHABAQEABLS0ucP38ezZo1AwBkZGQgMTFRbENERESvr1caw3P8+HGsW7cOycnJCA4ORp8+fVClShWDjrFs2TIcOXIEY8aMga2trTjmxs7ODtbW1lAoFOjYsSNiY2Ph4+MDb29vxMbGwsbGRiyu7OzsEB4ejpiYGDg6OsLBwQExMTHw8/PTGMhMREREr6eXKnguXbqENWvW4N9//4W/vz+++uor1KlT56UC7NmzB4B2L9Lw4cMRFhYGAOjSpQvy8/OxdOlSPH78GIGBgZgwYYI4qwoA+vfvD0tLS8ybN09ceHDs2LFcg4eIiIgMK3gSExOxZs0anD17Fl5eXvj000/RvHnzVwqwYcOGF7ZRKBSIiIhAREREiW2sra0RGRmJyMjIV8pDRERE5kevgictLQ3r1q3D0aNH4eDggAEDBqBt27awsjKqWe1EREREOulVsYwcORIqlQohISHo0qULypUrh8TExBLbBwQESBaQiIiI6FXpVfAUr0tz9uxZnD179oXt169f/0qhiIiIiKSkV8Hz8ccfl3YOIiIiolKjV8FTPFuKiIiIyBRx1DERlZnCIe/q1c6Q+wZZ/rT95cIQ0WuFi9QQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmz0ruAHFxcdi+fTtu3bqFjIwMjBo1Co0aNRL3C4KAjRs3Yt++fcjOzka1atUwaNAgVKpUSWxTUFCAmJgYHD16FPn5+QgKCsLgwYPh7u4uxykRERGRkZG9hycvLw9VqlRBZGSkzv3btm3Djh07EBkZiVmzZsHFxQXTp0/HkydPxDYrVqzAqVOnMHLkSEydOhW5ubmYPXs21Gp1WZ0GERERGTHZC5569eqhV69eaNy4sdY+QRCwc+dOdOvWDY0bN4afnx+ioqKQl5eHI0eOAABycnKwf/9+9OvXD8HBwfD398eIESOQmJiI8+fPl/XpEBERkRGS/ZLW86SkpCAzMxN169YVtymVStSqVQtXr15F27ZtcfPmTRQWFiI4OFhs4+bmBj8/P1y7dg0hISE6j11QUICCggLxsUKhgK2trfhvKRQfR6rjlQZmlI4p5DSFjIaS61xM4b1kRumYSk59vY7fN0Zd8GRmZgIAnJ2dNbY7OzsjLS1NbGNlZQUHBwetNsXP1yU2NhabNm0SH/v7+yM6Ohqenp7ShH+Kt7e35MeUGjNKxxRyypXxdikc08fHpxSOqj9+vaVhChkB8/neeR2/b4y64Cn2bCUoCMILn/OiNt26dUPnzp21XiM1NRUqleolUmpTKBTw9vZGcnKyXpnlwIzSMYWcppDRUPfu3ZPldU3hvWRG6ZhKTn2Z0/eNlZWVXp0VRl3wuLi4ACjqxXF1dRW3Z2Vlib0+Li4uUKlUyM7O1ujlycrKQo0aNUo8tlKphFKp1LlP6g+zIAhG/w3CjNIxhZymkFFfcp+HKbyXzCgdU8n5InKfgxzvo+yDlp/Hy8sLLi4uGoOPVSoV4uLixGImICAAlpaWGm0yMjKQmJiI6tWrl3lmIiIiMj6y9/Dk5uYiOTlZfJySkoL4+Hg4ODjAw8MDHTt2RGxsLHx8fODt7Y3Y2FjY2NggNDQUAGBnZ4fw8HDExMTA0dERDg4OiImJgZ+fn8ZAZiIiInp9yV7w/Pvvv5gyZYr4eNWqVQCAVq1aISoqCl26dEF+fj6WLl2Kx48fIzAwEBMmTBBnVAFA//79YWlpiXnz5okLD44dOxYWFkbdgUVERERlRPaCp3bt2tiwYUOJ+xUKBSIiIhAREVFiG2tra0RGRpa4eCERERG93tgFQkRERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZo8FDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZs5I7gJR2796N7du3IzMzExUrVsSAAQNQs2ZNuWMRERGRzMymh+fYsWNYsWIF3nvvPURHR6NmzZqYOXMm0tLS5I5GREREMjObgue3335DeHg43nrrLbF3x8PDA3v27JE7GhEREcnMLAoelUqFmzdvom7duhrbg4ODcfXqVZlSERERkbEwizE8WVlZUKvVcHZ21tju7OyMzMxMnc8pKChAQUGB+FihUMDW1hZWVtK9JQqFAgCgVCohCIJkx5USM0rHFHLKndGiag3Jj2mpVEp+TH3I/V7qgxmlI3dOqb93SuP7pnDaf/RqlwxA8f//exHLid+9sI2+v7fNouApVvyBfNE2AIiNjcWmTZvEx82bN8fIkSPh6uoqeS4PDw/Jjyk1ZpSOKeSULeOCNfK8bini11sappAR4PfOcxl5RrO4pOXk5AQLCwut3pyHDx9q9foU69atG1asWCH+N2TIEI0eHyk8efIEY8eOxZMnTyQ9rpSYUTqmkJMZpWMKOZlROqaQkxmfzywKHisrKwQEBOD8+fMa28+fP48aNXR3AyqVStjZ2Wn8p5S4i08QBNy6dcuou2mZUTqmkJMZpWMKOZlROqaQkxmfz2wuaXXu3Bnff/89AgICUL16dezduxdpaWlo27at3NGIiIhIZmZT8DRr1gyPHj3C5s2bkZGRgUqVKmH8+PHw9PSUOxoRERHJzGwKHgB4++238fbbb8sdQ6RUKtG9e3fJL5VJiRmlYwo5mVE6ppCTGaVjCjmZ8fkUgjFf7CMiIiKSgFkMWiYiIiJ6HhY8REREZPZY8BAREZHZY8FDREREZo8FDxERlZmePXvi4cOHWtsfPXqEnj17ypCIXhcseIjM3LMrkD/tjz/+KMMkz6dSqXD37l0UFhbKHeW5Hj58iMuXL+PKlSs6f3HTyykoKJD05s1Ez+Kn6zXx7bff6t121KhRpZjk5anVaiQmJsLDwwMODg5yx9GQnJyM5ORk1KpVC9bW1hAEocQb15a12bNno3379ujdu7f4CyUrKwuLFi3C1atXZV+NPC8vDz///DMOHToEAJg/fz7Kly+Pn3/+GW5ubujataus+Yrl5ORg2bJlOHbsGNRqNQDAwsICTZs2xeDBg2FnZydzwv+jVquRnJyMrKwsMWuxWrVqyZJp586d4r/37duHcuXKiY/VajUuX76MChUqyBHtuZKTk3Hw4EEkJydj4MCBcHZ2xtmzZ+Hu7o5KlSrJHQ9qtRoHDx7EhQsXdH69J02aJFMyICEhQe+2lStXLsUkRVjwSMAUiomnfxgLgoBTp07Bzs4OVatWBQDcvHkTjx8/RuPGjWXJp8uKFSvg5+eH8PBwqNVqTJo0CdeuXYO1tTXGjRuH2rVryx0Rjx49wnfffYeLFy8CABYsWIDy5ctjyZIlsLe3R79+/WROCEyZMgU//PADLly4gE8//RSpqalYvHgxKlasiDlz5sgdD2vXrkVCQgImT56MGTNmiNuDg4OxYcMGoyl4lixZgoSEBIwdOxbVq1eHQqHA1atXsWLFCixZsgSff/653BEBANeuXcOCBQuQmpqqc//69evLOFGRHTt2iP/+448/YGHxfxcYrKys4OXlhSFDhsgRrURxcXGYOXMmatSogcuXL+ODDz6As7MzEhISsG/fPnzxxRdyR8Ty5ctx8OBB1K9f3ygKsKeNGTNG77Zl8blkwSMBUygmhg8fLv579erVaNq0KYYOHSr+0FGr1Vi6dClsbW3liqjlxIkTaNGiBQDg9OnTSElJwbx58/Dnn39i3bp1mDZtmswJgZUrV8LCwgKLFi3CZ599Jm5v1qwZVq5caRQFT7Vq1RAdHY2ffvoJ48aNg1qtRq9evfDuu+8aRS/UX3/9hf/85z9iEVGsYsWKuH//vozJNP3zzz+YMGEC3njjDXFbSEgIhg0bhpkzZ8qYTNNPP/2EgIAAjBs3Dq6urkbxNQaAhQsXAigqwL/44guj66XVZc2aNejVqxc6d+6s8b1cu3ZtjR4rOR07dgyfffYZ6tevL3cULT/88IP471u3biEmJgbvvvsuqlevDqCoOP/tt9/Qp0+fMsnDgkcCplZMHDhwANOmTdP4C8vCwgKdO3fGV199hQ8//FDGdP/n0aNHcHFxAVD0y6Zp06bw9fVFeHg4fv/9d3nD/X/nzp3DhAkT4O7urrHdx8enxL+w5XD37l38+++/cHNzQ0ZGBu7cuYO8vDyNywpyycrKgrOzs9b23NxcGdKUzMHBQedlKzs7O9jb28uQSLfk5GR88cUX8Pb2ljuKTsWXWFQqFVJSUlC+fHlYWlrKnEq3xMREjBw5Umu7k5MTsrOzZUikzcrKymi/1k/fy3Lu3LkYOHCgRmFWuXJluLu7Y/369WjUqFGp5+GgZYkdOHAA7777rs5i4sCBAzIm+z9qtRpJSUla25OSkmBMdxpxdnZGUlIS1Go1zp49izp16gAoGvPx9Psrp7y8PNjY2Ghtz8rKMpr72WzduhVfffUVgoOD8d///hezZs1CfHw8Ro8ejWvXrskdD1WrVsXff/8tPi7ukdi3b5/4l6AxeP/997Fy5UpkZGSI2zIzM7F69Wq8//77MibTFBgYiOTkZLljlCg/Px+LFy9G37598fnnnyMtLQ0A8PPPP2Pr1q3yhnuGvb29xte7WHx8PNzc3GRIpK1z587YuXOnUf3s1iUxMRFeXl5a2728vHT+PioN7OGRWHEx4evrq7HdmIqJsLAwLF68GMnJyRpdi9u2bUNYWJi84Z4SFhaGefPmid3ywcHBAIDr169rvb9yqVmzJg4dOoRevXoBKPplrVarsX37dqMYYwQUDRYdPXo06tWrBwCoVKkSZs6ciV9++QWTJ0/G2rVrZc3Xu3dvzJw5E0lJSSgsLMTOnTtx+/ZtXLt2DVOmTJE129P27NmD5ORkDB8+HB4eHgCAtLQ0KJVKZGVlYe/evWLb6OjoMs329ODQDh06YNWqVcjMzISfn59W70lZDA59njVr1pjEmC0ACA0NxZo1a/D5559DoVBAEARcuXIFMTExaNmypdzxAABXrlzBpUuXcPbsWVSsWFFrppuxTEKpWLEitmzZgo8++gjW1tYAimbmbdmyBRUrViyTDLx5qMRWrlyJgwcPolu3blrFRMuWLdG/f3+ZExYVZb/++it27tyJzMxMAICLiws6duyId955x2h6T4CicTxpaWlo2rSpeNno4MGDsLe3x5tvvilzuqJCdvLkyQgICMDFixfRsGFD3L59G9nZ2Zg2bZpRdDVnZWXByclJ5764uDjZZu08LTExEdu3b8etW7egVqvh7++Prl27ws/PT+5ooo0bN+rdtkePHqWYRJsh69fINWi52PDhw8UxW/369cOcOXNQvnx5JCcnY+zYsVi5cqWs+Z6mUqmwaNEiHD16FEBRb71arUZoaCiioqKM4mflokWLnrv/6SEXcrpx4waio6OhVqtRpUoVAEU9ZQqFAuPGjUNgYGCpZ2DBIzFTKiaAoqm2AIxqSu3zPH782KjGSwBFlzX27NmDmzdvQhAE+Pv74+2334arq6vc0USPHz/GiRMncP/+fbz77rtwcHDAzZs34eLiYjRd8/TyDBkv9vS4Cjn07dsX//3vf1G+fHmNgic+Ph6TJk0ymoJHEASkpaXByckJmZmZGsW4j4+P3PFMUl5eHg4fPow7d+5AEARUrFgRoaGhZTaWkJe0JGZhYYEuXbqgS5cuRl1MFBYW4tKlS7h//z5CQ0MBAOnp6bCzszOKgaxA0dgTLy8vNGvWDEDRoLeTJ0/C1dUV48ePl71rvpiLiwsiIiLkjlGihIQETJs2DXZ2dkhNTcVbb70FBwcHnDp1Cmlpafjkk09kzVf8ffIshUIBpVJplIvR5efn49ixY8jLy0NwcLDsvwDlLmIMUTxmq0OHDgCMd8yWIAj49NNPMXfuXPj4+KB8+fJyRzJ5NjY2aNOmjWyvb3w/ScyIMRY6QNFfgzNnzkRaWhoKCgoQHBwMW1tbbN++Hfn5+Rg6dKjcEQEAe/fuxYgRIwAUrRZ84cIFfPnllzh+/DhiYmLw1VdfyZywSH5+PhITE/Hw4UOtcVoNGzaUKdX/WbVqFcLCwtC3b1+NqbX16tXDggULZExWZODAgc/d7+7ujrCwMHTv3l2WHtKYmBioVCoxp0qlwoQJE5CUlAQbGxusXr0aX331FWrUqFHm2XSJjY2Fs7MzwsPDNbbv378fWVlZso+RMZUxWxYWFvDx8cGjR49kL2ifNXbsWEycOBEODg4YM2bMc5ceKOvxZM/z559/4o8//kBKSgqmT58OT09P/PbbbyhfvnyZDFFgwSORF33oihnDh2/58uUICAjAnDlzEBkZKW5v1KgRlixZImMyTRkZGeK4nTNnzqBp06aoW7cuPD09MWHCBJnTFTl79ix++OEHPHr0SOd+ucdLAEXXznUt6Obm5iZedpXT8OHDsW7dOrRq1Uq8jn/jxg0cOnQI77//PrKysvDrr7/CysoK7733XpnnO3v2LD744APx8eHDh5GWloYFCxbAw8MDixcvxpYtWzB+/Pgyz6bL3r178emnn2ptr1SpEr777jvZC54aNWpg2rRp2L59O7y9vXHu3Dn4+/tjxowZRjVmCyi6/LZ69WoMHjzYqLI1bNhQnAVqDGMZ9bFnzx6sX78enTp1wubNm8UVoR0cHLBz504WPKbEVD50AHD16lVMmzZN61KBh4cH0tPTZUqlzcHBAQ8ePICHhwfOnj0rzoQCoLV8ulyWLVuGJk2aoHv37uKaQcbG2toaT5480dp+9+7dEgczl6VDhw7hww8/FC9dAkU/0P38/LB37158/fXX8PDwwJYtW2QpeNLS0jRmkZw7dw5NmjQRLyN17NgRs2bNKvNcJcnMzNQ5fqx4LIrcEhISULlyZZ2XUk+dOlUm67Ho6/vvv0deXh5Gjx4NKysrcXZRseXLl8uS6+lB8WU9QP5l/f777xg2bBgaNWqksfxAQEAAYmJiyiQDCx6J9OjRQ2OQm661WYyFWq3WWTCkp6cbzeKIQFGP04IFC+Dt7Y3s7GxxWnV8fLxRzH4CimZAde7c2WiLHaCoeNi0aZO4ErRCoUBaWhrWrl1rFLcSuXbtms4eKH9/f3GdoDfeeENcr6WsFU9HLnb9+nWNdXfs7OyMZhE6oOgS4JUrV7TWPLl69apRDKSfMWMGpk2bpjUm5sSJE1i4cGGZ/fLThzHMqtXXv//+izt37gAomgIeEBAgcyJNKSkp8Pf319quVCrLbJFRFjwSenaQm7EKDg7Gjh07MGzYMABFP9Bzc3OxYcMGsagwBv3794enpycePHiAvn37ioOpMzIy0K5dO5nTFWncuDHi4uKMpgDT5cMPP8SsWbMwZMgQ5OfnY9KkScjMzET16tU1es3k4u7ujv3792stL79//37xkuajR49km51XoUIFnDlzBp07d8bt27eRlpaGoKAgcX9aWppRFbzh4eFYuXIlCgsLxZwXLlzAmjVr0LlzZ5nTAe3atcPUqVMxffp0sQA7duwYFi9ebDRTqIsZ07pkJXnw4AHmz5+Pq1eviuNGc3JyUL16dYwcOVJcM0puXl5eiI+P1xpg/88//3AdHlP1+eef46OPPjKq2QbPSk9Px5QpU2BhYYHk5GQEBAQgOTkZjo6OmDJlis5l/km3vLw8zJ07F05OTjoXeevYsaNMybRdvHhRnDofEBAgrlwtt9OnT2Pu3LmoUKGCeP+54r9Wv/jiCzRo0AB79uzBvXv3ZPmL+8SJE5g/fz5q1qyJ27dvo2rVqhg3bpy4f/Xq1UhJSTGam4cKgoA1a9bg999/h0qlAlB0WbNLly7o3r27zOmKLF++HBcuXMDUqVNx9uxZLFmyBJ988gmaNGkid7QS5efni+9nMWOYmDJ9+nQ8efIEUVFR4oKsd+/exeLFi2FjY2M0kzsOHDiA9evXo1+/fli8eDE++ugj3L9/H7Gxsfjoo4/QvHnzUs/Agkdif//9N7Zu3Wp0g9yelZ+fjyNHjuDWrVvi2jEtWrTQukZtDJKSkpCWlqb1w8YYZkDt27cPP/30E6ytreHo6KixT6FQaNw8r6xdv35d41IgULRo48aNG5GXl4c333wTkZGRRnELjNTUVLGoEQQBFSpUQJs2bZCTkyMuUian8+fP4++//4aLiws6dOigccl648aNqFWrllGsrK1Wq3HlyhX4+fnBysoKSUlJsLa2ho+Pj1F8nZ/2/fff48aNG0hPT8enn35qlOMgc3NzsWbNGhw/flznxARjmJTQp08fTJ8+Xety0c2bNzFx4kSsWbNGpmTa9u7diy1btuDBgwcAiiZO9OjRQ2tGYWlhwSOxgQMHIi8vD4WFhUY1yO1pJd3/ydjcv38f3377LRITE3XuN4YfNkOGDEGHDh3QtWtXo1tUcubMmahVq5Y4KycxMRFjx45Fq1atULFiRWzfvh1t2rQxujWEHj9+jMOHD+PAgQOIj483iq+zKenTpw/mzZun875Fcjl9+rTWNpVKhZUrV6Ju3boaf7wYwx8yxZYuXYpLly6hZ8+e+OGHHzBo0CCkp6dj79696N27N1q0aCF3RIwcORIjRozQWqn4xo0bmD9/Pr7//nuZkml6etHYrKwsCIIgXk1ITk4uk2EBHMMjMVMY5DZ48GC8+eabaNmyJYKDg43uF3Wx5cuXw9PTExMnTsQnn3yCmTNnIjs7G6tWrTKaO7qrVCo0a9bMKN/D+Ph4jVsOHD16FIGBgfjoo48AFI2d2bBhg9EUPBcvXsT+/ftx6tQpeHp6onHjxmJWY5GdnY39+/fjzp07UCgU8PX1RXh4OBwcHOSOJvLz88P9+/eNquCZM2dOifsOHDigcWNlYypwz5w5g08++QS1a9fG4sWLUbNmTXh7e8PT0xNHjhwxioKnb9+++PnnnzFo0CAEBARAoVDg33//xfLly43m5yQAzJo1C19//TWsra01ZofevXsXU6dOLZMlUVjwSMwUBrl98sknOHr0KL799lvY2tqiWbNmaNGiRZncy8QQ169fx9dffw0nJycoFApYWFjgjTfeQO/evbF8+XJ88803ckdEq1atcOzYMVmmS7/I48ePNcZjxcXFISQkRHxctWpVsWtZLg8ePMDBgwdx4MAB5OXloWnTpigsLMQXX3xRZgMZ9RUXF4fo6GjY2dmJY4127dqFzZs3Y+zYsUZxTzIA6NWrF2JiYtCzZ08EBARo9ebKMe7EmIoYQ2RnZ4uFo62trTgb74033sBPP/0kW65nF+vMy8vDl19+KY4hLCwshKWlJRYvXmw00/zt7e0xZ84cjBs3TsyZlJSEqVOnomnTpmWSgQVPKUhOTsbBgweRnJyMgQMHwtnZGWfPnoW7uzsqVaokdzw0btwYjRs3xpMnT3DixAkcPXoUEydOhJeXF1q0aGE0AxvVarU4M8vJyQnp6enw9fWFh4cH7t69K3O6IsV3Rj937hwqV66sNWhZzh4/Z2dnpKSkwMPDAyqVCrdu3dLozcnNzdXKW5ZmzZqFK1euoH79+oiMjERISAgsLCzwxx9/yJbpeZYtW4ZmzZphyJAhYo+eWq3G0qVLsWzZMvz3v/+VOWGRmTNnAkCJfxCYavEhh/LlyyM1NRWenp6oWLEijh07hsDAQJw+fVrWe/qZwpWEZ33xxReYPn065s+fj88++wy3b9/GtGnTEBoaWmbnw4JHYnFxcZg5cyZq1KiBy5cv44MPPoCzszMSEhKwb98+fPHFF3JHFNna2qJ169Zo3bo1kpKSsGDBAmzcuNFoCp5KlSohISEB5cuXR2BgILZv3w4rKyvs3bvXaO5rc/v2bXGw4O3bt2VOoykkJARr165Fnz598Ndff8HGxgY1a9YU9yckJMg6nf7cuXPo0KED2rVrZ9TLOBRLTk7GF198oXH50sLCAp07d8ahQ4dkTKZp0qRJckd4rp9//hne3t5aMxh37dqF5ORkDBgwQJ5gT7l//z48PT0RFhaG+Ph4cSzc7NmzsWvXLhQWFspadJjClYRnWVtbY9y4cZg8eTLmzp2LK1euoGXLlmV62Y0Fj8TWrFmDXr16oXPnzhr3LapduzZ27twpYzJt+fn5OH36NI4cOYJz587ByckJ77zzjtyxRO+99x7y8vIAFHXTz549G5MmTYKDg4O4iJ7cjPmXS69evfDtt99i8uTJKFeuHKKiojRW1z5w4ACCg4Nlyzd16lTs378f48aNQ4UKFdCyZUuN1ZaNTUBAAJKSksSpv8WSkpKMYiZZMWO5tFaSkydPYuzYsVrbq1evjq1btxpFwfPpp5/ixx9/FNctmjdvHgYOHIjvvvsO//77L8qXL29UX/NixjZ1XteNgf/zn/9g2rRpaNy4Md5///0yvck2Cx6JJSYmYuTIkVrbnZycjGY11nPnzuHw4cP466+/YGFhgSZNmmDChAlG94Py6fEm5cuXx7x585CdnQ17e3u97lv2unNycsLUqVORk5ODcuXKaQ2s/vzzz8VLhnKoXr06qlevjoEDB+Lo0aM4cOAAVq5cCbVajfPnz8Pd3V32lb8TEhLEf3fo0AErVqxAcnKyuM7WtWvXsHv3bq1FE41BXl6ezuUcKleuLFOiItnZ2Tp/udnZ2ZV4Tzq5/fPPP+jduzfKly9vNAv5FTPmqfPPuzHwH3/8oXH5uixysuCRmL29PTIyMrRmSMTHx8PNzU2mVJrmzJmD+vXrIyoqCvXr19e6p5YxM6bZMMVu3LiBEydO6PzlMmrUKJlS/Z+S/nIylvfSxsYG4eHhCA8Px927d7F//35s3boVa9asQXBwsM7egLIyZswYrW261jWZP3++0fROZWVlYdGiRfjnn3907pd7DI+3tzfOnj2L9u3ba2z/559/jGpmmalYvXo1Ll26hMGDB+ucOi8nY+sBN53fdCYiNDQUa9asweeffy7eg+fKlSuIiYlBy5Yt5Y4HAPjxxx+NYoVQXb799lu92xpDMXH06FH88MMPqFu3Ls6fP4/g4GAkJycjMzPTaGZHmBJfX1/07dsXvXv3xunTpzWmK8tBzoUjX9aKFSvw+PFjzJgxA1OmTMHo0aORmZmJLVu2aFxml0unTp3w888/IysrS+PWF7/99ptRDcZ9thfZWHuVjXnqfPFVg8LCQmzZsgWtW7eWtYeMBY/EevXqhUWLFon3qfrss8+gVqsRGhqqccPBspaTk6NR5Oi6tlpMzmLIWAuxksTGxqJ///5o3749+vXrh4EDB8LLyws//vijUdyo0VRZWFigUaNGsheNz973xxRcvHgRY8aMQWBgICwsLODh4YHg4GDY2dkhNjYW9evXlzVfeHg4VCoVtmzZgs2bNwMoep8HDx6MVq1ayZrtaQsXLhRXpy4oKMBPP/2kNcXfGP7oMtap80+ztLTEr7/+KvvXlwWPxKysrPDpp58iIiIC8fHxUKvV8Pf3l30WysCBA/Hjjz/C2dn5uddVAXm7vI3t5oEvcv/+ffEXiFKpRF5eHhQKBTp16oSpU6cazaJ+9HJOnz6NkJAQWFlZ6Vwt+GnGskJwXl6euLCbg4MDsrKy4OvrCz8/P9y6dUvmdEXatWuHdu3aISsrC9bW1rKOJdPl2V/MxrDAYEmMder8s4KCghAXFyfrZUsWPKXE29vbqO6gXTy7CQC+/vpro+2efVpKSgoKCwu1isV79+7B0tLSKK73Ozg4IDc3F0DRfWESExPh5+eHnJwccYYZma45c+aIfyg8b7VgQP6xMcV8fX1x9+5deHl5oXLlyti7dy+8vLywZ88eo+t1fHrFXWNiSn94GevU+WfVq1cPa9euRWJiIgICArSK3LL4g4H30pLYypUrdW5XKBRQKpXw9vbGm2++aTQDRo3ZpEmT0Lp1a601J/7880/s378fkydPliXX0+bPn4+qVauic+fO2LJlC3bu3ImGDRviwoUL8Pf3N4oub3q9HD58GIWFhQgLC8OtW7cwY8YMPHr0CFZWVoiKipJlcPXYsWMxceJEODg4YMyYMc/9gys6OroMk5mftLQ0/Pvvv/D29pZ9Rt7Tnr7NjS6cpWWC4uPjcfPmTajVanG9jnv37sHCwgIVKlTAnj17sGrVKkybNk22pfM/+eQThIaGomXLllprihiT+Ph4vPHGG1rbq1evjp9//lmGRNoGDRqE/Px8AEDXrl1haWmJK1euoFGjRrKO2SLp6Lrr/KFDh7Bhwwajuut8Xl4eYmJi8Ndff6GwsBDnzp3DwIEDsXDhQty5cwceHh6y9ag0bNhQfH+M8a7opujixYtYtmwZZsyYoTH20cPDA3Z2dvjqq68wZMgQjcVG5WQMPaAseCTWsGFD2NvbY/jw4eKHMCcnB0uWLMEbb7yBt956C/Pnz8fKlSsxYcIEWTK2b98eR48eRWxsLKpUqSIu+GZs3d0A8OTJE61tOTk5UKvVMqTR9nRPnYWFBbp06YIuXbrImIiktnHjRtSqVUsseBITE7FkyRKNu867urrKPl5rw4YNOHToEEJDQ2FtbY0jR45g6dKl+PzzzxEQECBrth49emDRokUYOHAgevToIWsWc7Fjxw689dZbJa5p1KZNG/z2229GU/AYAxY8Etu+fTsmTpyo8SG0s7NDjx49MH36dHTs2BHdu3fHjBkzZMvYuXNndO7cGXfv3sWRI0ewZ88erF69GrVr10aLFi1kH0lfrGbNmoiNjcV//vMfjXsXxcbG6uz5KUsv6p4Fii5jrlu3rgzSUGkylbvOnzp1Ch999BGaN28OoGig7cSJE6FWq7UWnZTDoUOH0KdPH9kXkzQXCQkJz13wsm7duvj111/LMNGL5ebmIi4uTueaZc/eaqQ0sOCRWE5ODh4+fKh1uSorK0vsrbC3t9f6YsvB19cXERERiIiIwLVr17B06VIsWrTIaAqePn36YPLkyRg5cqT4V8rly5fx5MkTfP3117Jme97YnKtXr2LXrl3g8DjzYAp3nQeKxm48/dd88bT09PR0o1sdmF7dw4cPn7torKWlJbKyssow0fPdunULs2bNQl5eHvLy8uDg4IBHjx7B2toazs7OLHhM0ZtvvonFixejX79+qFq1KhQKBW7cuIGYmBjx2vWNGzdkn6Ze7MaNGzhy5AiOHTuGnJwcNGnSRO5IokqVKmHOnDnYvXs34uPjYW1tjVatWqF9+/ayD/rWNQ7hzp07WLt2Lc6cOYPQ0FD06tVLhmQkNWO/63wxtVqt9QvQ0tLSaC7/Asa7eJ8pKp4VWtJs4ISEBKMaprBy5Uo0aNAAQ4YMwYABAzBjxgxYWlri+++/L5NiB2DBI7mhQ4dixYoV+O6771BYWAig6IdOq1atxCmCFSpUELvD5VB8KevIkSNITU1F7dq10bt3bzRu3NgoupufHXwZFBSEqKgoo53Cmp6eLo6fqFu3Lr755hv4+fnJHYskYux3nX/a04vlAboXzJNz5qCu+ww+a/ny5WWQxPTVq1cP69evR0hICKytrTX25efnY8OGDbIvMvm0+Ph4DB06FBYWFrCwsEBBQQHKly+Pvn37YuHChWjcuHGpZ2DBI7Fy5crho48+woABA3D//n0IggBvb2+NNQfkvsvuZ599hoCAALz99tto3rw5XFxcZM3zrKcHXyqVShw9elQcfGlMcnJysGXLFuzatQtVqlTB119/zQGCZsjY7zpfTNelaGNbMK9Hjx4mt5q6sXrvvfdw8uRJjBw5Eu3bt4evry8UCgWSkpKwe/duqNVqvPfee3LHFD3dC+rs7Iy0tDRUrFgRdnZ2SEtLK5MMXIfnNaNWq7F//340adJE9stCJRkxYgR69eolDr68ceMGJk6ciDVr1hjF4EsA2LZtG7Zt2wYXFxd88MEHnGr7GijprvPZ2dkoV66cSd2EVw49e/YUF3EkaaSmpmLp0qU4e/asxvaQkBAMGjTIKBZnLTZ9+nSEhYUhNDQUP/74I+Lj49GhQwf8+eefePz4MWbOnFnqGfgdKrHc3Fxs3boVFy9exMOHD7UGrsp9M0ILCwssX74cwcHBRlvwmMLgy7Vr18La2hre3t44dOgQDh06pLMdFx40H8Z+13l6/Xh6emL8+PHIzs5GcnIygKJV/o3xM/nBBx+IE3d69eqFhQsXYunSpfD29sbHH39cJhlY8EhsyZIluHz5Mlq0aAFXV1ejHKTn5+eH+/fvG1X1/zRTGHzZsmVLo/zaEtHrx8HBAYGBgXLHeK6qVauK/3ZycsL48ePLPAMvaUlswIABGDdunOzrxDzPuXPnsGbNGvTs2RMBAQFadwCW+xp7z549ERISojH48syZMwgKCjKawZdERGS4hw8f4u7du1AoFPD19S3TySjs4ZGYvb29UXYnPq34Wuk333yjc7/cS4CbwuBLIiLSX05ODpYtW4Zjx46JvfUWFhZo2rQpBg8eXCZ/aLOHR2J//vknTp8+jaioKK2eE2MRFxf33P21atUqoyRERPQ6mDt3LhISEjBw4EBUr14dCoUCV69exYoVK+Dn51cms3BZ8EhszJgx4nR0T09PrbEovBMwERG9bj788ENMmDBBa7jH5cuXMXPmTMTExJR6Bl7SkpgpTE9mDw8REZUlBweHEm90am9vXyYZ2MPzGnrRjS/lHsNDRETmZe/evTh+/Dg++eQT8ZYXmZmZWLhwIRo1aoS2bduWegYWPKXg8ePHOHHiBO7fv493330XDg4OuHnzJlxcXODm5iZ3POTk5Gg8VqlUiI+Px/r169GrVy/UqVNHpmRERGQuxowZo7F8x71791BQUCCup5aWlgalUgkfH58yGe7BS1oSS0hIwLRp02BnZ4fU1FS89dZbcHBwwKlTp5CWloZPPvlE7og6uxWDg4NhZWWFlStXcpwRERG9MmMb4sGCR2KrVq1CWFgY+vbti379+onb69WrhwULFsiY7MWcnJxw9+5duWMQEZEZ6NGjh9wRNLDgkdiNGzcwZMgQre1ubm7IzMws+0A6JCQkaDwWBAGZmZnYunWr7Dc2JSIi85abm6u1cn5ZrMPDgkdi1tbW4v1Cnnb37t0yXVHyecaMGaNze7Vq1crsniZERPT6SElJwbJlyxAXF4f8/Hyt/WUxWYYFj8QaNmyITZs24bPPPgMAKBQKpKWlYe3atWjcuLHM6Yo8ewNThUIBJycnWFtby5SIiIjMWfGQjo8//hjOzs6y3IuQs7QklpOTg1mzZiEpKQlPnjyBq6srMjMzUb16dYwfPx7lypWTLdv169eRnZ2NevXqidsOHTqEDRs2IC8vD2+++SYiIyM17mFFRET0qj788ENER0fD19dXtgzs4ZGYnZ0dpk2bhosXL+LmzZsQBAH+/v4IDg6WOxo2btyIWrVqiQVPYmIilixZglatWqFixYrYvn07XF1dERERIXNSIiIyJ4GBgUhLS2PBY46CgoIQFBQEoGhdHmMQHx+vsejg0aNHERgYiI8++ggA4O7ujg0bNrDgISIiSQ0bNgw//fQT0tPT4efnB0tLS439lStXLvUMLHgktnXrVnh5eaFZs2YAim6YdvLkSbi4uGD8+PGyzoJ6/PgxnJ2dxcdxcXEICQkRH1etWhUPHjyQIRkREZmzrKws3L9/H4sXL9a5n4OWTdDevXsxYsQIAMD58+dx4cIFfPnllzh+/DhWr16Nr776SrZszs7OSElJgYeHB1QqFW7duqXRm5Obm6tVdRMREb2qxYsXo0qVKhg5cqRsg5ZZ8EgsIyMD7u7uAIAzZ86gadOmqFu3Ljw9PTFhwgRZs4WEhGDt2rXo06cP/vrrL9jY2KBmzZri/oSEBHh7e8uYkIiIzFFaWhrGjh0r6+8YC9le2Uw5ODiIl4XOnj2rcV+qZxdaKmu9evWChYUFJk+ejH379mHYsGGwsvq/mvfAgQNGMbiaiIjMS+3atREfHy9rBvbwSKxRo0ZYsGABvL29NaaAx8fHy9574uTkhKlTpyInJwflypWDhYVmvfv555/LOm2eiIjMU8OGDbFy5UokJibCz89P44/t4v2ljevwSEylUmHnzp148OABwsLC4O/vDwDYsWMHypUrh7feekvmhERERGXr6RnCupTFoGUWPERERGT2OIZHYgcPHsTff/8tPl69ejUGDBiAr776CqmpqTImIyIiKluzZs1CTk6O+HjLli0aa9M9evRIvBVTaWPBI7HY2FjxnlTXrl3Drl270LdvXzg6OmLlypUypyMiIio7Z8+eRUFBgfh427ZtyM7OFh8XFhbi7t27ZZKFBY/EHjx4IA5OPnXqFJo0aYI2bdqgd+/euHz5sszpiIiI5CPnKBoWPBIrV64cHj16BKBo4cHiaelKpRL5+flyRiMiInptcVq6xIKDg7FkyRL4+/vj3r17qF+/PgAgKSkJXl5eMqcjIiIqW8+uqizHKssACx7JDRo0COvWrcODBw/wxRdfwNHREQBw8+ZNNG/eXOZ0REREZWvhwoVQKpUAgIKCAvz000+wsbERH5cVTksnIiKiUrFo0SK92g0fPryUk7DgKTV5eXlIS0uDSqXS2F65cmWZEhEREb2+eElLYllZWVi4cCHOnj2rc39ZrCZJREREmjhLS2IrVqxATk4OZsyYAWtra0yYMAFRUVHw8fHB2LFj5Y5HRET0WmIPj8QuXryIMWPGIDAwEBYWFvDw8EBwcDDs7OwQGxsrztoiIiKissMeHonl5eXByckJAODg4ICsrCwAgJ+fH27duiVnNCIiotcWCx6J+fr6istkV65cGXv37kV6ejr27NkDV1dXmdMRERG9njhLS2KHDx9GYWEhwsLCcOvWLcyYMQOPHj2ClZUVoqKi0KxZM7kjEhERvXZY8EgkLy8PMTEx+Ouvv1BYWIg6depg4MCBsLGxwZ07d+Dh4SFe6iIiIqKyxYJHIjExMdizZw9CQ0NhbW2NI0eOoHbt2vj888/ljkZERPTa4ywtiZw6dQofffSRePuIFi1aYOLEiVCr1bCw4FApIiIiOfE3sUTS0tJQs2ZN8XHxtPT09HQZUxERERHAgkcyarUaVlaaHWaWlpZQq9UyJSIiIqJivKQloafvCAto3xUWAEaNGiVHNCIiotcaCx6JtGrVSmtbixYtZEhCREREz+IsLSIiIjJ7HMNDREREZo8FDxEREZk9FjxERERk9jhomYgAAAkJCdixYwcuXbqEzMxMWFhYwNfXF82aNcNbb70FBwcHg463cOFCxMXFYeHChaWUuPQcPHgQixYtglKpxHfffQdPT0+N/ZMnT8ajR4/w3//+V6aERGQoFjxEhL1792LZsmXw9fXFu+++i4oVK6KwsBD//vsv/vjjD1y7dg2jR4+WO2aZKygowLp16zBixAi5oxDRK2LBQ/Sau3btGpYuXYrg4GCMHj1aYy2p4OBgvPPOOzh79qx8AWUUEhKCI0eO4J133kGVKlXkjkNEr4AFD9FrbsuWLVAoFBg6dKhGsVPMysoKDRs2FB+r1Wr8+uuvOHDgAFJSUmBnZ4eQkBB88MEHcHd3L/F1UlJS8Mknn2D48OEICwvT2BcREYHu3bsjIiICALBhwwZs2rQJc+bMwebNm3Hu3DlYWFggLCwMffv2xf3797F8+XJcvXoVjo6OaNeuHbp06SIe79KlS5gyZQo+/fRT3L59GwcPHkRubi4CAwMxaNAg+Pr66vXevPvuu7h58ybWrFmDCRMmPLftrl27cPz4cdy5cwd5eXnw8vJCy5Yt0alTJ41V2Isvhw0bNgyrVq3CrVu34OLigu7du6N169b4+++/sX79ety5cwfly5fHhx9+iJCQEI3XunfvHjZs2IALFy4gJycH5cuXx9tvv4327dvrdV5EryMWPESvMbVajUuXLiEgIAAeHh56PWfp0qXYu3cv2rdvj/r16yM1NRXr16/HpUuXEB0dDScnJ8nyzZs3Dy1atECbNm1w/vx5bN++HYWFhbhw4QLatWuHd955B0eOHMGaNWvg7e2Nxo0bazz/l19+QY0aNTBs2DA8efIEa9asQXR0NObNm6fXTX1tbW3x3nvvYcWKFbh48SKCgoJKbHv//n00b94cXl5esLKyQkJCArZs2YI7d+5g+PDhGm0zMzOxaNEivPvuu3B3d8fvv/+OxYsX48GDBzhx4gS6desGOzs7sej7/vvv4ebmBgBISkrCV199BQ8PD/Tr1w8uLi44e/Ysli9fjkePHqFHjx4v8U4TmT8WPESvsaysLOTl5WkNyi3JnTt3sHfvXrRr1w6RkZHidn9/f3z55ZfYsWMHPvjgA8nytWnTBp07dwZQdHnt/Pnz2LVrF0aNGoVGjRoBAGrXro2///4bhw8f1ip4KlasiE8//VR8bGFhgXnz5uHGjRuoXr26XhnatWuH33//HWvWrMHMmTOhUCh0tuvfv7/4b7VajZo1a8LR0RGLFi1Cv379NAZ9P3r0CBMmTEBAQAAAoGrVqhg8eDC2bt2KBQsWiMWNq6srxowZg5MnT6JDhw4AgJUrV8LW1hZTp06FnZ2d+N6oVCps3boVHTp0MHiAOdHrgAUPEent0qVLAKB1SSowMBAVKlTAxYsXJX29+vXrazyuUKECEhISNC7xWFpawtvbG2lpaVrPf/pSHABUrlwZAJCWlqZ3wWNlZYWePXtiwYIFOH78OJo1a6az3a1bt7BhwwZcvXoV2dnZGvvu3buHatWqiY9dXV3FYgcAHBwc4OzsDE9PT7HYAYoKNgBITU0FAOTn5+PixYto27YtbGxsUFhYKLatV68edu3ahevXr6NevXp6nRvR64QFD9FrzMnJCTY2NuIv1Bd59OgRgKJf2M9yc3PT+zj6eranwsrKCtbW1rC2ttba/uTJE63nOzo6arUDigoHQzRv3hy//vorfvnlF7Fn6WlpaWn4+uuv4evriwEDBsDLywtKpRI3btzAsmXLtF5PVw+MlZWVzvMFimaLAUB2djYKCwuxa9cu7Nq1S2fW4q8REWliwUP0GrOwsEBQUBDOnj2LBw8ePHfQMfB/BURGRoZW2/T0dK0C42nFRUrxL+9ipvALWqFQoE+fPpg+fTr27t2rtf/UqVPIy8vDqFGjNC4PxsfHS5rD3t4eFhYWaNmyJd5++22dbby8vCR9TSJzwZWWiV5z3bp1gyAI+N///geVSqW1X6VS4fTp0wAgDto9fPiwRpsbN27gzp07qFOnTomv4+zsDKVSiYSEBI3tf/3116ueQpkIDg5GcHAwNm/ejNzcXI19xeN6np7lJggC9u3bJ2kGGxsb1K5dG7du3ULlypVRtWpVrf+eV3QSvc7Yw0P0mqtevToGDx6MZcuWYezYsWjXrh0qVaoElUqF+Ph47N27F5UqVULDhg3h6+uLNm3aYNeuXVAoFKhXr544S8vd3R2dOnUq8XUUCgVatGiBAwcOwNvbG5UrV8aNGzdw5MiRMjzbV9OnTx+MGzcODx8+RKVKlcTtwcHBsLKywvz58/Huu++ioKAAe/bswePHjyXPMHDgQEycOBFff/012rVrB09PTzx58gTJyck4c+YMJk2aJPlrEpkDFjxEhDZt2iAwMBA7duzAtm3bkJmZCUtLS/j6+iI0NFRjfZfBgwejfPny2L9/P3bv3i2uw9O7d+8X9i7069cPALBt2zbk5uYiKCgI48aNQ1RUVKmen1T8/f3RvHlzrSKtQoUK+OKLL7Bu3Tp8++23cHR0RGhoKDp37oyZM2dKmqFixYqIjo7G5s2bsW7dOjx8+BD29vbw8fHhYGWi51AIgiDIHYKIiIioNHEMDxEREZk9FjxERERk9ljwEBERkdljwUNERERmjwUPERERmT0WPERERGT2WPAQERGR2WPBQ0RERGaPBQ8RERGZPRY8REREZPZY8BAREZHZY8FDREREZu//AftiPzcdnkc6AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output = infer(\"Make a plot of count of null values in every column.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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", + "import pandas as pd\n", + "\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "total_null_values = df.isnull().sum().sum()\n", + "\n", + "print(f\"Total number of null values: {total_null_values}\")\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n", + "Total number of null values: 866\n" + ] + } + ], + "source": [ + "output = infer(\"How many null values are there in total? Do not give me a plot\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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", + "import numpy as np\n", + "\n", + "# Read the data\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Fill NA/NaN values with the most frequent value in each column\n", + "df['Sex'] = df['Sex'].fillna(df['Sex'].mode()[0])\n", + "df['Embarked'] = df['Embarked'].fillna(df['Embarked'].mode()[0])\n", + "df['Age'] = df['Age'].fillna(df['Age'].mode()[0])\n", + "df['Cabin'] = df['Cabin'].fillna(df['Cabin'].mode()[0])\n", + "df['Ticket'] = df['Ticket'].fillna(df['Ticket'].mode()[0])\n", + "\n", + "# Save the modified dataframe\n", + "df.to_csv('df_filled.csv', index=False)\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n" + ] + } + ], + "source": [ + "output = 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": 13, + "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 pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Read the data from 'df.csv'\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Plot the distribution of ages\n", + "plt.figure(figsize=(10, 6))\n", + "plt.hist(df['Age'].dropna(), bins=30)\n", + "plt.xlabel('Age')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Distribution of Ages')\n", + "plt.grid(True)\n", + "plt.savefig('graphs/age_distribution.png')\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output = infer(\"Please plot the distribution of ages.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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 pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Read the data from 'df.csv'\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Plot the distribution of gender against survival\n", + "plt.figure(figsize=(10, 6))\n", + "plt.hist(df['Survived'], bins=[0, 1], alpha=0.5, label='Died')\n", + "plt.hist(df[df['Survived'] == 1]['Sex'].map({'male': 0, 'female': 1}).values, bins=[0, 1], alpha=0.5, label='Survived')\n", + "plt.xlabel('Survived')\n", + "plt.ylabel('Count')\n", + "plt.title('Distribution of Gender against Survival')\n", + "plt.legend()\n", + "plt.savefig('graphs/distribution_of_gender_against_survival.png')\n", + "plt.show()\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output = infer(\"Please plot the distribution of gender against survival. Add suitable labels and title.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "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 numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import OrdinalEncoder\n", + "\n", + "# Read the data\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Perform ordinal encoding on Embarked column\n", + "encoder = OrdinalEncoder()\n", + "df['Embarked'] = encoder.fit_transform(df[['Embarked']])\n", + "\n", + "# Prepare the data for heatmap\n", + "pivot_data = pd.pivot_table(df, values='Survived', index=['Pclass', 'Embarked'], columns=['Age', 'Fare'])\n", + "\n", + "# Generate the heatmap\n", + "sns.heatmap(pivot_data, cmap='YlGnBu')\n", + "plt.title('Heatmap of Survived vs Pclass, Embarked, Age, and Fare')\n", + "plt.savefig('graphs/heatmap.png')\n", + "plt.show()\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output = 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": 16, + "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", + "# Load the data\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Create a regplot of age against fare\n", + "sns.regplot(x='Age', y='Fare', data=df)\n", + "\n", + "# Set the plot title and labels\n", + "plt.title('Regression Plot of Age vs Fare')\n", + "plt.xlabel('Age')\n", + "plt.ylabel('Fare')\n", + "\n", + "# Display the plot\n", + "plt.show()\n", + "```\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output = 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": 17, + "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", + "import pandas as pd\n", + "\n", + "# Read the data from 'df.csv'\n", + "df = pd.read_csv('df.csv')\n", + "\n", + "# Print the unique values from the Embarked column\n", + "print(df['Embarked'].unique())\n", + "```\u001b[0m\n", + "\n", + "\u001b[1m> Finished chain.\u001b[0m\n", + "['S' 'C' 'Q' nan]\n" + ] + } + ], + "source": [ + "output = infer(\"Print the unique values from the Embarked column\")" + ] + }, + { + "cell_type": "markdown", + "id": "2239ca9d", + "metadata": {}, + "source": [ + "# Gradio Demo" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "220a632b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pandas.core.frame.DataFrame" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "41301427", + "metadata": {}, + "outputs": [], + "source": [ + "def myFunc(path, query):\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77dd768e", + "metadata": {}, + "outputs": [], + "source": [ + "demo = gr.Interface (\n", + " myFunc,\n", + " [\n", + " gr.Text(label=\"JSON Object\",info=\"Please enter the JSON Object.\"),\n", + " gr.Radio([\"Question\",\"Answer_Choice\",\"Sub_Question\",\"Sub_Answer_Choice\",\"Partial_Clause\"],label=\"Select Component Type\",info=\"Which component do you want to edit?\"),\n", + " gr.Text(label=\"Question No.\",info=\"Plese enter the question number i.e., 1 for Q1, 2 for Q2 ...\"),\n", + " gr.Text(label=\"Answer Choice\", info=\"Please enter the Answer Choice in this format: a for 1st, b for 2nd ...\"),\n", + " gr.Text(label=\"Sub Answer Choice\", info=\"Please enter the sub-answer choice in this format: a for 1st, b for 2nd ...\"),\n", + " gr.Text(label=\"Update Instructions\",info=\"Please enter the update instructions.\"),\n", + " gr.Slider(label=\"Model Temperature\", info=\"Slide right to make your model more creative!\")\n", + " ],\n", + " gr.Text(label=\"Updated JSON Object\", info=\"This the JSON Object with the changed component.\")\n", + ")\n", + "demo.launch(share=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "d64f6c65", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running on local URL: http://127.0.0.1:7871\n", + "\n", + "To create a public link, set `share=True` in `launch()`.\n" + ] + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pathlib import Path\n", + "import gradio as gr\n", + "\n", + "def upload_file(filepath):\n", + " name = Path(filepath).name\n", + " df_func = pd.read_csv(filepath)\n", + " \n", + " return None\n", + "\n", + "with gr.Blocks() as demo:\n", + " gr.Markdown(\"First upload a file and and then you'll be able download it (but only once!)\")\n", + " with gr.Row():\n", + " u = gr.UploadButton(\"Upload a file\", file_count=\"single\")\n", + " with gr.Row():\n", + " d = gr.Text(\"Who would you like to say hello to\", )\n", + " \n", + " u.upload(upload_file, u, [])\n", + " \n", + " \n", + " \n", + "demo.launch()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5af71757", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}