diff --git a/.gitignore b/.gitignore
index 71208656..5de11a8a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -373,7 +373,7 @@ tfplan
 *.crt
 *.pub
 id_rsa
-.vscode/
+
 python/expense-classification-guidance/.env
 
 python/expense-classification-guidance/.idea/
@@ -389,3 +389,5 @@ sandbox/usecases/rag/dotnet/.env
 sandbox/notebooks/prompt-engineering/dotnet/.env
 
 sandbox/prompt-engineering/notebooks/prompt-engineering/dotnet/.env
+
+.vscode/settings.json
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 00000000..3f63eb97
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,6 @@
+{
+  "recommendations": [
+    "ms-azuretools.vscode-azurefunctions",
+    "ms-python.python"
+  ]
+}
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..ba70d098
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,39 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": ".NET Core Launch (web)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            "program": "${workspaceFolder}/dotnet/recommendation-service/bin/Debug/net7.0/GBB.Miyagi.RecommendationService.dll",
+            "args": [
+                "--verbose"
+            ],
+            "cwd": "${workspaceFolder}/dotnet/recommendation-service",
+            "stopAtEntry": false,
+            "serverReadyAction": {
+                "action": "openExternally",
+                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            }
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach"
+        },
+        {
+            "name": "Attach to Python Functions",
+            "type": "python",
+            "request": "attach",
+            "port": 9091,
+            "preLaunchTask": "func: host start"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 00000000..5abc4cf8
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,69 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/dotnet/recommendation-service/GBB.Miyagi.RecommendationService.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/dotnet/recommendation-service/GBB.Miyagi.RecommendationService.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/dotnet/recommendation-service/GBB.Miyagi.RecommendationService.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "type": "func",
+            "label": "func: host start",
+            "command": "host start",
+            "problemMatcher": "$func-python-watch",
+            "isBackground": true,
+            "dependsOn": "pip install (functions)",
+            "options": {
+                "cwd": "${workspaceFolder}/sandbox\\agents\\plugins"
+            }
+        },
+        {
+            "label": "pip install (functions)",
+            "type": "shell",
+            "osx": {
+                "command": "${config:azureFunctions.pythonVenv}/bin/python -m pip install -r requirements.txt"
+            },
+            "windows": {
+                "command": "${config:azureFunctions.pythonVenv}\\Scripts\\python -m pip install -r requirements.txt"
+            },
+            "linux": {
+                "command": "${config:azureFunctions.pythonVenv}/bin/python -m pip install -r requirements.txt"
+            },
+            "problemMatcher": [],
+            "options": {
+                "cwd": "${workspaceFolder}/sandbox\\agents\\plugins"
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/sandbox/agents/assistants-api/azure-openai/.env.sample b/sandbox/agents/assistants-api/azure-openai/.env.sample
index 6ec7f661..b4e753b1 100644
--- a/sandbox/agents/assistants-api/azure-openai/.env.sample
+++ b/sandbox/agents/assistants-api/azure-openai/.env.sample
@@ -1,3 +1,4 @@
 OPENAI_API_KEY=<your-api-key>
 OPENAI_MODEL_NAME=<your-model-name>
-OPENAI_ENDPOINT=<your-endpoint>
\ No newline at end of file
+OPENAI_ENDPOINT=<your-endpoint>
+DATA_COLLECTION_LOGIC_APPS_URI=<your-logic-app-workflow-uri>
diff --git a/sandbox/agents/assistants-api/azure-openai/azure_ai_util.py b/sandbox/agents/assistants-api/azure-openai/azure_ai_util.py
new file mode 100644
index 00000000..b83b76fd
--- /dev/null
+++ b/sandbox/agents/assistants-api/azure-openai/azure_ai_util.py
@@ -0,0 +1,110 @@
+# azure_ai_utils.py
+import io
+import matplotlib.pyplot as plt
+from typing import Iterable
+from pathlib import Path
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+# Import AzureOpenAI and assistant-related Message classes
+from openai import AzureOpenAI
+from openai.types.beta.threads.message_content_image_file import MessageContentImageFile
+from openai.types.beta.threads.message_content_text import MessageContentText
+from openai.types.beta.threads.messages import MessageFile
+
+
+class NotCompletedException(Exception):
+    """Custom exception for handling incomplete run statuses."""
+    pass
+
+
+class AzureAIUtils:
+    """
+    A utility class for various Azure AI operations including
+    message formatting, file uploading, and lifecycle status checking.
+    """
+
+    def __init__(self, client: AzureOpenAI):
+        """
+        Initialize the utility class with an AzureOpenAI client.
+
+        Parameters:
+        client (AzureOpenAI): An instance of the AzureOpenAI client.
+        """
+        self.client = client
+
+    def format_response(self, messages: Iterable[MessageFile]) -> None:
+        """
+        Formats and prints the content of messages from AzureOpenAI.
+
+        Parameters:
+        messages (Iterable[MessageFile]): An iterable of MessageFile objects.
+        """
+        message_list = []
+
+        for message in messages:
+            message_list.append(message)
+            if message.role == "user":
+                break
+
+        message_list.reverse()
+
+        for message in message_list:
+            for item in message.content:
+                if isinstance(item, MessageContentText):
+                    print(f"{message.role}:\n{item.text.value}\n")
+                elif isinstance(item, MessageContentImageFile):
+                    try:
+                        response_content = self.client.files.content(
+                            item.image_file.file_id
+                        )
+                        data_in_bytes = response_content.read()
+                        readable_buffer = io.BytesIO(data_in_bytes)
+                        image = plt.imread(readable_buffer, format="jpeg")
+                        plt.imshow(image)
+                        plt.axis("off")
+                        plt.show()
+                    except Exception as e:
+                        print(f"Exception: {e}")
+
+    def upload_file(self, path: Path):
+        """
+        Uploads a file to AzureOpenAI.
+
+        Parameters:
+        path (Path): The path to the file to be uploaded.
+
+        Returns:
+        FileObject: The file object created in AzureOpenAI.
+        """
+        with path.open("rb") as f:
+            return self.client.files.create(file=f, purpose="assistants")
+
+    @retry(
+        stop=stop_after_attempt(15),
+        wait=wait_exponential(multiplier=1.5, min=4, max=20),
+        retry=retry_if_exception_type(NotCompletedException),
+    )
+    def get_run_lifecycle_status(self, thread_id, run_id):
+        """
+        Retrieves and prints the lifecycle status of a run and
+        retries based on specific conditions.
+
+        Parameters:
+        thread_id: The ID of the thread.
+        run_id: The ID of the run.
+
+        Returns:
+        The run object if its status is 'completed', 'failed', 'expired', or 'cancelled'.
+
+        Raises:
+        NotCompletedException: If the run is not yet completed.
+        """
+        run = self.client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)
+        print(f"Run status: {run.status}")
+        if run.status in ["completed", "failed", "expired", "cancelled"]:
+            print(f"Run info: {run}")
+            return run
+        elif run.status == "requires_action":
+            pass  # Handle cases that require action differently
+        else:
+            raise NotCompletedException("Run not completed yet")
diff --git a/sandbox/agents/assistants-api/azure-openai/equity-analyst.ipynb b/sandbox/agents/assistants-api/azure-openai/equity-analyst.ipynb
index 6164081e..198a549d 100644
--- a/sandbox/agents/assistants-api/azure-openai/equity-analyst.ipynb
+++ b/sandbox/agents/assistants-api/azure-openai/equity-analyst.ipynb
@@ -34,63 +34,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import io\n",
     "import os\n",
-    "from datetime import datetime\n",
     "from pathlib import Path\n",
-    "import matplotlib.pyplot as plt\n",
-    "from typing import Iterable\n",
     "from dotenv import load_dotenv\n",
     "from openai import AzureOpenAI\n",
-    "from openai.types import FileObject\n",
-    "from openai.types.beta.threads.message_content_image_file import MessageContentImageFile\n",
-    "from openai.types.beta.threads.message_content_text import MessageContentText\n",
-    "from openai.types.beta.threads.messages import MessageFile"
+    "from tenacity import RetryError\n",
+    "\n",
+    "from azure_ai_util import AzureAIUtils, NotCompletedException"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Environment Configuration\n",
-    "This cell is crucial for setting up the environment configuration necessary for the notebook to interact with Azure OpenAI. \n",
+    "### Initializing Azure OpenAI Client\n",
+    "This cell crucial for establishing communication with Azure OpenAI services. \n",
     "\n",
     "- **Requirement**: Ensure that a `.env` file exists in the same directory as this notebook. This file should contain the necessary API credentials and configuration details, which you can obtain from https://ai.azure.com \n",
     "- **Keys in .env File**: The `.env` file must include the following keys:\n",
     "  - `OPENAI_ENDPOINT`: The endpoint URL for the Azure OpenAI service.\n",
     "  - `OPENAI_API_KEY`: Your API key for accessing Azure OpenAI services.\n",
-    "  - `OPENAI_MODEL_NAME`: The name of the specific Azure OpenAI model you intend to use.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(\".env\")\n",
-    "api_endpoint = os.getenv(\"OPENAI_ENDPOINT\")\n",
-    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "api_deployment_name = os.getenv(\"OPENAI_MODEL_NAME\")\n",
-    "api_version = \"2024-02-15-preview\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Initializing Azure OpenAI Client\n",
     "\n",
     "Initializes `AzureOpenAI` client with necessary credentials and configurations:\n",
     "- `api_key`: API key for authentication.\n",
     "- `api_version`: Targeted API version, set to `\"2024-02-15-preview\"`.\n",
-    "- `azure_endpoint`: Endpoint URL for Azure OpenAI services.\n",
-    "\n",
-    "This step is crucial for establishing communication with Azure OpenAI services.\n"
+    "- `azure_endpoint`: Endpoint URL for Azure OpenAI services."
    ]
   },
   {
@@ -99,9 +71,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "client = AzureOpenAI(api_key=api_key, \n",
-    "                     api_version=api_version, \n",
-    "                     azure_endpoint=api_endpoint)"
+    "load_dotenv(\".env\")\n",
+    "client = AzureOpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"), \n",
+    "                     azure_endpoint=os.getenv(\"OPENAI_ENDPOINT\"),\n",
+    "                     api_version=\"2024-02-15-preview\")\n",
+    "\n",
+    "utils = AzureAIUtils(client)"
    ]
   },
   {
@@ -130,11 +105,7 @@
     "# Fetch the files under the datasets directory\n",
     "DATASETS = \"datasets/\"\n",
     "\n",
-    "def upload_file(client: AzureOpenAI, path: Path) -> FileObject:\n",
-    "    with path.open(\"rb\") as f:\n",
-    "        return client.files.create(file=f, purpose=\"assistants\")\n",
-    "\n",
-    "assistant_files = [upload_file(client, Path(DATASETS) / file) for file in os.listdir(DATASETS)]\n",
+    "assistant_files = [utils.upload_file(Path(DATASETS) / file) for file in os.listdir(DATASETS)]\n",
     "file_ids = [file.id for file in assistant_files]"
    ]
   },
@@ -157,7 +128,7 @@
     "                  \"Use the provided file only.\"),\n",
     "    tools=[{\"type\": \"code_interpreter\"}],\n",
     "    file_ids=file_ids,\n",
-    "    model=api_deployment_name\n",
+    "    model=os.getenv(\"OPENAI_MODEL_NAME\")\n",
     ")"
    ]
   },
@@ -177,49 +148,6 @@
     "thread = client.beta.threads.create()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Helper function to format the response from the assistant."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def format_response(messages: Iterable[MessageFile]) -> None:\n",
-    "\n",
-    "    message_list = []\n",
-    "\n",
-    "    # Iterate through the messages and break when a user message is encountered\n",
-    "    for message in messages:\n",
-    "        message_list.append(message)\n",
-    "        if message.role == \"user\":\n",
-    "            break\n",
-    "\n",
-    "    # Reverse the list of messages\n",
-    "    message_list = message_list[::-1]\n",
-    "\n",
-    "    for message in message_list:\n",
-    "        for item in message.content:\n",
-    "            if isinstance(item, MessageContentText):\n",
-    "                print(f\"{message.role}:\\n{item.text.value}\\n\")\n",
-    "            elif isinstance(item, MessageContentImageFile):\n",
-    "                try:\n",
-    "                    response_content = client.files.content(item.image_file.file_id)\n",
-    "                    data_in_bytes = response_content.read()\n",
-    "                    readable_buffer = io.BytesIO(data_in_bytes)\n",
-    "                    image = plt.imread(readable_buffer, format='jpeg')\n",
-    "                    plt.imshow(image)\n",
-    "                    plt.axis('off')\n",
-    "                    plt.show()\n",
-    "                except Exception as e:\n",
-    "                    print(f\"Exception: {e}\")"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -231,45 +159,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from tenacity import retry, stop_after_attempt, wait_exponential, RetryError, retry_if_exception_type\n",
-    "\n",
-    "# Custom exception for specific retry condition\n",
-    "class NotCompletedException(Exception):\n",
-    "    pass\n",
-    "\n",
-    "@retry(stop=stop_after_attempt(15), \n",
-    "       wait=wait_exponential(multiplier=1.5, min=4, max=20),\n",
-    "       retry=retry_if_exception_type(NotCompletedException))\n",
-    "def get_run_lifecycle_status(thread_id, run_id):\n",
-    "    run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)\n",
-    "    print(f\"Run status: {run.status}\")\n",
-    "    if run.status in [\"completed\", \"failed\", \"expired\", \"cancelled\"]:\n",
-    "        return run\n",
-    "    elif run.status == \"requires_action\":\n",
-    "        # Handle cases that require action differently\n",
-    "        # For example, you might not want to retry in this case\n",
-    "        pass\n",
-    "    else:\n",
-    "        # This will cause a retry for statuses not explicitly handled above\n",
-    "        raise NotCompletedException(\"Run not completed yet\")\n",
-    "\n",
     "def analyst_assistant(content: str):\n",
     "    client.beta.threads.messages.create(thread_id=thread.id, role=\"user\", content=content)\n",
     "\n",
     "    run = client.beta.threads.runs.create(\n",
     "        thread_id=thread.id,\n",
     "        assistant_id=assistant.id,\n",
-    "        instructions=f\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools.\",\n",
+    "        instructions=f\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools. Make generic assumptions\",\n",
     "    )\n",
     "\n",
     "    try:\n",
-    "        run = get_run_lifecycle_status(thread.id, run.id)\n",
+    "        run = utils.get_run_lifecycle_status(thread.id, run.id)\n",
     "        messages = client.beta.threads.messages.list(thread_id=thread.id)\n",
-    "        format_response(messages)\n",
+    "        utils.format_response(messages)\n",
     "    except RetryError:\n",
     "        print(\"Operation failed or timed out after maximum retries.\")\n",
     "    except NotCompletedException:\n",
@@ -285,7 +191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -300,34 +206,48 @@
       "Run status: in_progress\n",
       "Run status: in_progress\n",
       "Run status: completed\n",
+      "Run info: Run(id='run_vrqJm1WPDt5ExvvHmoLwHtlx', assistant_id='asst_EVTjx4hPjZ0IBrEG7oGjtdLS', cancelled_at=None, completed_at=1707617874, created_at=1707617792, expires_at=None, failed_at=None, file_ids=['assistant-6YtpAiT2SdzcLPGqfCd1zCcu'], instructions=\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools. Make generic assumptions\", last_error=None, metadata={}, model='gpt-4', object='thread.run', required_action=None, started_at=1707617793, status='completed', thread_id='thread_KVRmHgZcBSn2MFL00yH2sHv8', tools=[ToolAssistantToolsCode(type='code_interpreter')], usage=None)\n",
       "user:\n",
       "Visualize the data and provide insights on the trends.\n",
       "\n",
       "assistant:\n",
-      "First, let's load the data from the uploaded file and take a quick look at its structure and contents to understand what kind of data we're working with. Based on this, we can decide how best to visualize it and analyze the trends. \n",
+      "To provide you with insights on the trends through visualization, I first need to review the contents and structure of the uploaded data file. Once I have understood the type and structure of the data, I will proceed with the visualization and trend analysis.\n",
+      "\n",
+      "I will start by loading the data from the uploaded file and checking its first few rows to understand its contents. Let's begin by identifying the file type and then loading the data appropriately.\n",
       "\n",
-      "I'll start by loading the data using Python and displaying the first few rows.\n",
+      "assistant:\n",
+      "It seems that there was an issue displaying the output. This may have happened if the file is not in CSV format, or if it requires specific handling to be read correctly. I will perform additional checks to deal with different possible file types like Excel, JSON, or other common formats one by one to identify the correct format. Let's attempt to read the file as an Excel file next.\n",
       "\n",
       "assistant:\n",
-      "The dataset appears to contain financial projections for a company, including the following columns:\n",
+      "There seems to be an issue with my approach. Let me try once more to read the file, starting with checking if it's a CSV and then moving on to other file formats. I'll proceed step by step to ensure we identify the file type correctly and load the data. Let's start again with attempting to load it as a CSV file, and if it fails, I will continue with other file formats.\n",
       "\n",
-      "- `Year`: The fiscal year for the projection.\n",
-      "- `Projected Revenue`: Expected revenue for the year.\n",
-      "- `Projected EBIT` (Earnings Before Interest and Taxes): Expected operating income for the year.\n",
-      "- `Projected Net Income`: Expected net income for the year.\n",
-      "- `Projected Free Cash Flow`: Expected free cash flow for the year.\n",
-      "- `Discount Factor`: Used to calculate the present value of future cash flows.\n",
-      "- `Present Value of FCF` (Free Cash Flow): The discounted current worth of the projected free cash flows.\n",
+      "assistant:\n",
+      "The data has been successfully loaded as a CSV file. The dataset contains financial projections including:\n",
       "\n",
-      "Now that we understand the structure of the data, we can create visualizations to help identify trends and insights. We'll plot the growth of Projected Revenue, Projected EBIT, Projected Net Income, and Projected Free Cash Flow over the years. We can also look at how the Present Value of FCF changes relative to the undiscounted Free Cash Flow.\n",
+      "- Year (from 2024 onwards)\n",
+      "- Projected Revenue\n",
+      "- Projected EBIT (Earnings Before Interest and Taxes)\n",
+      "- Projected Net Income\n",
+      "- Projected Free Cash Flow\n",
+      "- Discount Factor\n",
+      "- Present Value of Free Cash Flow (FCF)\n",
       "\n",
-      "Let's start by visualizing the financial projections over the years.\n",
+      "Next, let's visualize the data to gain insights into the trends. Since the dataset contains financial projections over years, I will create line charts to visualize the trend of each financial metric over time. We can visualize the following trends:\n",
+      "\n",
+      "1. The growth of Projected Revenue over the years.\n",
+      "2. The trend in Projected EBIT.\n",
+      "3. Changes in Projected Net Income.\n",
+      "4. Variation in Projected Free Cash Flow.\n",
+      "5. Decreasing trend in the Discount Factor (which is expected as it usually accounts for the time value of money).\n",
+      "6. The trend in the Present Value of FCF.\n",
+      "\n",
+      "Let's create the charts.\n",
       "\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -336,24 +256,48 @@
      "output_type": "display_data"
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "assistant:\n",
-      "The plot above visualizes the projected financial metrics from the dataset. Here are the key trends and insights we can observe:\n",
-      "\n",
-      "- All metrics (Projected Revenue, Projected EBIT, Projected Net Income, and Projected Free Cash Flow) are on an upward trend, implying the company is expecting growth in its financial performance over the years.\n",
-      "- The Projected Revenue appears to be the highest among the metrics, with a steady climb each year, which indicates increasing sales or expansion of the company's business operations.\n",
-      "- Projected EBIT and Projected Net Income, while lower than Projected Revenue, also show a consistent increase, suggesting improving profitability.\n",
-      "- Projected Free Cash Flow follows a similar upward pattern, indicating the company’s ability to generate cash after accounting for capital expenditures is also expected to grow.\n",
-      "\n",
-      "Next, let’s visualize the Present Value of Free Cash Flow compared to the Projected Free Cash Flow to see the effect of discounting cash flows to their present value.\n",
-      "\n"
-     ]
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -366,15 +310,23 @@
      "output_type": "stream",
      "text": [
       "assistant:\n",
-      "The chart above compares the Projected Free Cash Flow (FCF) and the Present Value of FCF over time. The following insights can be gleaned from this comparison:\n",
+      "The visualizations for the various financial metrics over the projected years have been created. Here are some insights based on the trends seen in the charts:\n",
+      "\n",
+      "1. **Projected Revenue Over Time:** There is a consistent upward trend in projected revenue year over year, indicating expected growth in the company's top-line performance.\n",
+      "\n",
+      "2. **Projected EBIT Over Time:** Similarly, the Earnings Before Interest and Taxes (EBIT) also shows a rising trend, which hints at healthy growth in operational profitability before accounting for interest and taxes.\n",
       "\n",
-      "- As we would expect, the Present Value of FCF is lower than the nominal Projected FCF for each year, reflecting the application of the discount factor, which accounts for the time value of money. This is a common financial analysis practice to calculate the current value of future cash flows.\n",
-      "- The gap between the Projected FCF and its Present Value seems to be fairly consistent, suggesting a stable discount rate is used across the projection period. However, it naturally increases with time as the cash flows are discounted back to their present values from increasingly distant future years.\n",
-      "- The declining Present Value of FCF, despite the increase in nominal terms, suggests that the impact of discounting becomes more significant with a further out future cash flow due to higher cumulative discounting.\n",
+      "3. **Projected Net Income Over Time:** The net income, which factors in taxes and interest, continues the upward trend. This is a positive sign for the company's bottom-line growth.\n",
       "\n",
-      "Overall, the data displays an optimistic view of the company's financial future, with growth expected in all major financial metrics. The consistency in growth rates and discount rates provides a predictable model for the company's performance. However, these projections would also need to be stress-tested against various economic scenarios to evaluate the robustness of the forecasts. Additionally, comparing these projections to industry benchmarks, past company performance, and considering macroeconomic factors would give a more comprehensive insight into the company's prospects.\n",
+      "4. **Projected Free Cash Flow Over Time:** The free cash flow, which is the cash generated by the company after accounting for capital expenditures, displays growth year over year. This suggests that the company is projected to have more cash available for debt repayment, dividends, reinvestment, etc.\n",
       "\n",
-      "If there's a specific analysis or further exploration you would like to pursue with this dataset, please let me know!\n",
+      "5. **Discount Factor Over Time:** As expected, the discount factor decreases over time. This is consistent with the principle of the time value of money, where future cash flows are worth less than immediate cash flows.\n",
+      "\n",
+      "6. **Present Value of FCF Over Time:** Despite the discount factor decreasing over time, the present value of free cash flow doesn't drop as significantly due to the increase in the projected free cash flow over the years.\n",
+      "\n",
+      "These trends indicate positive projections for the company's financial health, with growth in revenue, profitability, and free cash flow. The decrease in the discount factor is consistent with standard financial modeling practices.\n",
+      "\n",
+      "For a more detailed analysis, one would typically look at the assumptions behind these projections, assess the risk factors, and compare these figures with industry benchmarks or historical performance. If additional data is available or required, such as market trends, competitive analysis, or macroeconomic factors, this would also be incorporated into the full equity analysis report.\n",
       "\n"
      ]
     }
@@ -385,7 +337,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -398,43 +350,51 @@
       "Run status: in_progress\n",
       "Run status: in_progress\n",
       "Run status: completed\n",
+      "Run info: Run(id='run_LlT56mitw9rQc6o2HPk4mIJJ', assistant_id='asst_EVTjx4hPjZ0IBrEG7oGjtdLS', cancelled_at=None, completed_at=1707617937, created_at=1707617905, expires_at=None, failed_at=None, file_ids=['assistant-6YtpAiT2SdzcLPGqfCd1zCcu'], instructions=\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools. Make generic assumptions\", last_error=None, metadata={}, model='gpt-4', object='thread.run', required_action=None, started_at=1707617906, status='completed', thread_id='thread_KVRmHgZcBSn2MFL00yH2sHv8', tools=[ToolAssistantToolsCode(type='code_interpreter')], usage=None)\n",
       "user:\n",
-      "Use python code to perform a discounted cash flow valuation using the given dataset. Make generic assumptions\n",
+      "Perform a discounted cash flow valuation using the provided dataset, and print the code along with its executed output that was used for this calculation.\n",
       "\n",
       "assistant:\n",
-      "To perform a discounted cash flow (DCF) valuation, we calculate the present value (PV) of projected free cash flows (FCF) for each year and then take the sum of these values. This is the value of the cash flows the company is expected to generate in the future, brought back to today's dollars.\n",
+      "To perform a discounted cash flow (DCF) valuation using the provided dataset, we will first calculate the sum of the present values of the projected Free Cash Flows (FCF) provided. If the dataset includes a terminal value or an exit multiple, we would also need to include that in our DCF calculation. However, since the dataset only provides the values until 2028, we will proceed assuming there is no terminal value provided.\n",
+      "\n",
+      "The DCF valuation formula to calculate the total present value of the projected FCFs is:\n",
+      "\n",
+      "\\[ \\text{DCF Value} = \\sum_{t=1}^{T} \\frac{\\text{FCF}_t}{(1 + r)^t} \\]\n",
       "\n",
-      "The formula for the present value of an individual year's FCF is:\n",
-      "\\[ PV = \\frac{FCF}{(1 + r)^n} \\]\n",
       "where:\n",
-      "- \\( FCF \\) is the projected free cash flow for the year,\n",
-      "- \\( r \\) is the discount rate,\n",
-      "- \\( n \\) is the number of years from now.\n",
+      "- \\(\\text{FCF}_t\\) is the Free Cash Flow in year \\(t\\)\n",
+      "- \\(r\\) is the discount rate (derived from the discount factor in this case)\n",
+      "- \\(T\\) is the number of time periods\n",
       "\n",
-      "Since the dataset already includes a \"Discount Factor\", we don't need to explicitly apply the discount rate \\( r \\). We can simply multiply the \"Projected Free Cash Flow\" by the \"Discount Factor\" to get the \"Present Value of FCF\", which actually has been done already in the dataset.\n",
+      "From the provided dataset, we already have the present value of each cash flow (`Present Value of FCF`). What we need to do now is sum up the present values to estimate the intrinsic value of the company based on the provided information.\n",
       "\n",
-      "To find the total DCF valuation of the company, we would sum up these present values. Additionally, we would typically consider a terminal value that accounts for all cash flows beyond the last projected year, assuming a perpetual growth rate. To keep the analysis generic as requested, we will pick a reasonable perpetual growth rate and discount rate for the terminal value calculation. Let's proceed with these calculations using Python.\n",
+      "Let's proceed with the calculation using the data.\n",
       "\n",
       "assistant:\n",
-      "Based on the calculations using the provided dataset and generic assumptions:\n",
+      "Here is the Python code used to calculate the DCF valuation along with its executed output:\n",
+      "\n",
+      "```python\n",
+      "# Calculate the sum of the present values of the projected Free Cash Flows\n",
+      "total_present_value_fcf = loaded_data['Present Value of FCF'].sum()\n",
+      "\n",
+      "# Aggregate total valuation (assuming there are no other cash flows beyond what is provided)\n",
+      "dcf_valuation = total_present_value_fcf\n",
+      "```\n",
       "\n",
-      "- The total present value of the projected free cash flows (FCF) from the given data is approximately $200.32 billion.\n",
-      "- The terminal value (TV), calculated at the end of the projection period using a perpetual growth rate of 2% and a discount rate of 5%, amounts to approximately $1,839.15 billion.\n",
-      "- The present value of the terminal value is about $1,441.02 billion.\n",
-      "- Finally, the total discounted cash flow (DCF) valuation of the company, which combines the present value of the projected FCFs and the present value of the terminal value, is approximately $1,641.35 billion.\n",
+      "Based on the provided projections, the DCF valuation of the company's cash flows from 2024 to 2028 is approximately $200.32 billion.\n",
       "\n",
-      "It's essential to note that the DCF valuation is sensitive to the assumptions made about growth rates and discount rates. Different assumptions could lead to significantly different valuations. These assumptions should be tailored to match the company's sector, risk profile, and prevailing economic conditions for a more accurate valuation.\n",
+      "It is important to note that this valuation would be an intrinsic value estimate based on the given projections and does not account for any cash flows beyond 2028 or any terminal value that might be considered in a complete DCF analysis. For a full valuation, you would also typically estimate a terminal value, which represents the value of all cash flows beyond the last projected year into perpetuity or until an exit event.\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "analyst_assistant(\"Use python code to perform a discounted cash flow valuation using the given dataset. Make generic assumptions\")"
+    "analyst_assistant(\"Perform a discounted cash flow valuation using the provided dataset, and print the code along with its executed output that was used for this calculation.\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -446,18 +406,56 @@
       "Run status: in_progress\n",
       "Run status: in_progress\n",
       "Run status: in_progress\n",
+      "Run status: in_progress\n",
       "Run status: completed\n",
+      "Run info: Run(id='run_0xCw8vKutDdwkVaaLxfJgVbR', assistant_id='asst_EVTjx4hPjZ0IBrEG7oGjtdLS', cancelled_at=None, completed_at=1707618041, created_at=1707617988, expires_at=None, failed_at=None, file_ids=['assistant-6YtpAiT2SdzcLPGqfCd1zCcu'], instructions=\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools. Make generic assumptions\", last_error=None, metadata={}, model='gpt-4', object='thread.run', required_action=None, started_at=1707617989, status='completed', thread_id='thread_KVRmHgZcBSn2MFL00yH2sHv8', tools=[ToolAssistantToolsCode(type='code_interpreter')], usage=None)\n",
       "user:\n",
-      "Visualize this information. Seems incorrect\n",
+      "Summarize and Visualize this information to someone new to finance and investing.\n",
       "\n",
       "assistant:\n",
-      "Apologies for any confusion in the previous chart. I will rectify the visualization by distinctly presenting the present value of the free cash flows year by year and emhpasize the present value of terminal value, so the distinction and proportions are clear. Let's create a more accurate chart.\n",
+      "Sure, to explain this to someone new to finance and investing, let's break it down into simpler terms and visualize the concept of discounted cash flow (DCF) valuation. \n",
+      "\n",
+      "### **Summary: Discounted Cash Flow Valuation**\n",
+      "The idea behind DCF valuation is to determine the value of an investment today, based on how much money it will generate in the future. To put it simply, imagine you have a machine that prints money every year. How much would you be willing to pay for that machine today? DCF helps answer that.\n",
+      "\n",
+      "Here's the catch: Money available in the future is worth less than money in your hand today, due to potential risks and the fact that you could have invested that money elsewhere. Each future payment from the machine is discounted to reflect this. \n",
+      "\n",
+      "By adding up all these \"discounted\" future cash flows, we get the total value of the machine (or in financial terms, the total value of the company).\n",
+      "\n",
+      "### **Visualization**\n",
+      "Let's visualize the following concepts:\n",
+      "\n",
+      "1. **Future Cash Generation:** A series of bars showing the money generated each year.\n",
+      "2. **Present Value of Future Cash:** The same bars, but adjusted (shortened) to show what they're worth today.\n",
+      "3. **Total Valuation:** All of the adjusted bars added together (the sum) to show the total value of the company right now.\n",
+      "\n",
+      "Let's create these visualizations.\n",
       "\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAE7CAYAAABAGoIKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACKsklEQVR4nOydd5xU1fn/37dN3QLb6EuXpogVVESCBbso9hY1tmg0xsQkxkRjixV/MRoTo3xVxK7RKKKoYEWlCYqAgPS2C8v22Sm3nN8fszNsmV22XXbdPe/Xi9ewc8/cc87nnvvc557yHEUIIZBIJBKJRNJlUdu7ABKJRCKRSNoX6QxIJBKJRNLFkc6ARCKRSCRdHOkMSCQSiUTSxZHOgEQikUgkXRzpDEgkEolE0sWRzoBEIpFIJF0c6QxIJBKJRNLFkc6ARCKRSCRdHOkMSCQSiUTSxZHOgEQikUgkXRzpDEgkEolE0sXR27sAEkl7IoSg5l5diqKgKEo7lqhxEuWtW86Gvq95PBKJAOD3+/dJWR3HIRQK4TgO6enpqKqaLEvNzwQdSfuEnqZpAmAYRovLZ5omkUiEtLS0DlM/iaQu0hmQdGnmzp3L22+/jdfrRdd19t9/f8444wyCwWC7Ge5IJMLChQsZO3YsXq+31rFoNMr/+3//j9NPP51Ro0bt9fua/Pe//8WyLH7+85+7Wn6IOwKvv/46H330EXl5edx6660Eg8Hk8ZkzZ7JkyRIMwwAgGAxy4403kpWV1eD5FixYwH777Ud2drarZRdCsGbNGl5//XV27NiBqqr06tWLqVOnMnTo0Ga3i1WrVjFz5kz+9re/oevS5Eo6JrJlSro027dvR9M0rrnmGsrLy3niiSeoqKjgmmuuAeq/vdYl8WBI9ZaboG7PQ01S/a68vJwnn3ySUaNG1XMGvF4vhmEwe/ZsRowYgaqqyYfXsmXLuPrqqxssS1VVFZZlNVqfxsrVlLSJdOFwmNmzZ3PzzTczdOhQfD5frfTr16+nb9++nHnmmQBomkZ6enqjeTz77LNce+21zXIG6patsWuRSP/DDz9w5513MmXKFC677DI0TWPZsmV8++23DB06tMnXOnHMsizKy8tr9ULJHgJJR0M6A5IuT1paGoMHDwbg5JNP5v3336eiooK5c+cycOBA5s+fz7Bhw5g4cSKLFi1i4cKF6LrOxIkTGTlyJAA//PADH3/8MaFQiD59+nDqqaeSnp5ORUUFH330EevXr6dnz56cdNJJZGVlUVpayueff07v3r2ZP38+wWCQ0047jdzcXD777DN2797Nyy+/TGZmJlOmTCEtLS1Z3uOOO47777+f0tLS5Jv03LlzOfTQQ9E0jf/+979s2LCBQCDAxIkTGTFiRK36CiH45ptv0DSNMWPGJB+AxcXFHHnkkQCsWbOGTz75hKqqKg455BCOPPLIem+1QgiKior44IMP2LFjB4MHD+a4447D4/Hw5ptvUlhYyMcff0xRURE/+9nP6umelZXFoEGDkg/GSCTC7NmzmTRpEunp6ViWxfvvv88RRxzB+vXr2bFjB7Nnz2bZsmUce+yxFBcXY9s2Bx98MIqisGbNGgoLCxk/fjxr165l69atWJbFihUrOPfcc0lLS+PDDz9k48aN9O7dmxNPPJHu3bvXejA7jsMLL7zAuHHjOOecc9A0DYDJkycnHanvvvuOr7/+mvLycgYNGsQJJ5xAWloajuPw1VdfsWjRIoQQDB8+nBNOOCF53oULF7Jw4UKysrI4/fTT6datm3QKJB2Gn8wEwoRX7ThOo29rDaVr6u8lXZNE2ygoKCA9PZ1IJML06dN57bXXGDVqFH369OGdd97hxRdfZOTIkeTn5/PII4+wevVqdu/ezX333UdOTg5HHXUUHo+HcDhMNBrloYceYt26dYwbN47y8nIeeOABwuEwu3fv5l//+hdz587loIMOorCwkEcffRTLskhLS0PXdbp37052dnZyrB3ib5TDhg0jLS2Nb775BiEEZWVlLFy4kGOPPZaSkhJM0+SII46gR48ePPDAA2zatKlefRcsWMDixYuTf69YsYJPP/00+f8HH3yQvLw8DjzwQF577TXef//9evdNKBTi7rvvZtu2bRx22GEsXLiQv//979i2TWZmZrIODb3x79ixg2XLlrF06VLWrVtHJBLhtddeo6KiAgDLsvjvf//Lrl27CAQCGIZBZmYmOTk5eDweFi9ezIIFC5LnW7VqFR9//DEQd86mTZvGpk2bOOywwwC4//772bx5M+PGjWP37t089NBDRKPRWmWqqqrihx9+YNy4cUlHIKG7YRgIIdi0aRMDBw5k3LhxfP/99zz55JM4jsPy5cv5z3/+w6hRozjssMMIh8NJB2LTpk0sXryYQw45hNWrV/PUU09JOyTpUPxkegaqqqp45plnWLFiBddeey0HHnhgynSO4/Dqq6/y1VdfMWnSJKZMmQJAWVkZzz33HEVFRUycOJGf/exntYyspOuyatUqpk2bRnl5OT/++CM33XQTmqah6zqXXHIJw4YNIxwO8+CDD3LhhRcyfPhwhBD8+OOPzJs3jzPOOAPLshgyZAjDhg1j3LhxKIrCt99+y8aNG/nLX/6C3++nZ8+e3HPPPWzYsAGv10sgEODyyy8nNzeXAQMGcOutt1JVVcXBBx9MRkYGkydPTtkl7vP5mDhxIh999BETJ05k2bJlBAIBhg8fjs/nwzAMNm7cSEZGBn6/n++++47+/fs3SQshBG+99RaHHnoohx56KBB/K54zZw6TJ09OjvEDrFy5krKyMv72t78RDAbZb7/9uPHGG9m1axfjx4/nlVde4bjjjqN3794p8/rhhx9wHAeAoUOHMnny5AbLNXz48KSzddBBBzWpLvn5+fz85z/H4/GwaNEiduzYwS9+8Qu8Xi89evTg7rvvZtOmTQwbNiz5G8uyME2z1vyGmiiKwnHHHcePP/5IUVER++23H7NmzSIUClFeXo7f72fo0KH06tWr1hBPVlYWV1xxBWlpaWRnZ/PQQw8Ri8VqDZ9IJO3JT8YZUFWVww8/nM2bN7N7924gbriqqqpYv349fr+fgQMHAjBs2DBKS0vZvHlzMt2LL75IRkYGZ555Jvfccw/77bcf/fr1a7f6SDoOOTk5HHHEEXi9XvLz88nLy6O4uBifz0dOTg6KohAOh9m5cyf//e9/kwY8Fotx2GGH0aNHDy666CJmzJhBJBJhxIgRXHbZZRQWFrJz506eeOKJZHewz+dLvhGmp6cnJyomHhy2be+1vIqicPTRR/O///2Pbdu28eGHHzJhwgT8fj+ff/4506dPZ9iwYWRkZBAKhZJv2nWp23MGcWd6+/btrFmzhjVr1iTLlJ2dXe9NtqioiJycHAKBAIqi0L17d3w+H2VlZWRkZOy1Hj/72c+47LLLknUqKytrtIzNpUePHsmhjYKCAgoKCnj88ceTcweCwWDSGUng8Xjw+/2UlJQkV2fUJBKJcN9991FRUcGAAQOIRqOEw2FM0+TQQw9lzZo1PPTQQ8lrNHXqVAAyMzPx+XwoikIgEMC27Xp5SyTtyU/GGfD7/Rx22GHMnTs3+V1FRQX3338/vXr1oqioiFGjRnHOOedw8MEHs3XrVjZu3AjEvf3ly5fzhz/8gX79+jFs2DBWrlwpnQEJALm5uRx11FH1DH/Nv71eL9nZ2VxzzTXsv//+tdKoqsrJJ5/M8ccfz65du7j//vuZO3cu+fn59OnTh7vvvrvWcj5N01i3bl29ctSdXNbYg7BPnz4MHDiQ//73v6xZs4arrroKgA8++IApU6Zwxhln4DhO8h6oi9frJRQKJfNIONiqqpKTk8PRRx/NOeecU6+eNenevTslJSVEIhH8fj/l5eVEo9EmOQI1z5uor6qqKIpCLBZDCEE4HCYUCtVKmxjmUxQFj8eTdCAS8xfqnjtBTk4O/fr149577631xl5zKADiduaQQw5h7ty5jBs3LtkTknjx2LlzJxs2bODxxx8nMzOTlStXsnDhwuRvf/GLX3DRRRexYcMG7rzzzgZ7MCWSjsZPxhlIxcKFC9m1axcHH3ww6enpvPfee0yZMgWPx1MrneM4tbrk0tLSqKysbI8iS36iBINBTjnlFJ566inOPfdcMjIy2LBhAwMHDiQ3N5dPPvmEYcOGYZomoVCIzMxMRo4cSU5ODk8++SQTJ07EsizWrl3Laaed1mhegUAAr9fLrFmzGDhwIGPHjq3XnaxpGscffzx33303hx9+OH379gWgd+/efP311/Tr149Vq1bxww8/pOxWHzlyJI8//jgHHXQQoVCIL774gpEjR6IoClOmTOEf//gHwWCQ/v37U1BQgOM4nHjiibXOMWrUKDweD8888wxjx45l9uzZDBs2jN69e9d6iDeVQCBAv379eO2115g0aRJffvklpaWlQPzB3rt3b+bMmUNpaSmjR49m5MiRTJs2jc8//5xIJMKnn37KkCFDUp77gAMOID09nf/85z9MmDAB0zRZu3YtU6ZMqTWnQVEULrroIv7617/y8MMPM2nSJDRNY+HChaSlpXHSSSdh2zaffPIJPXr04K233krOC1i8eDGbN29m0KBBFBQUoKoqgUCAcDjcbC0kkn3NT9oZSBjdrKwssrKyuPbaa+t5+hA3nH6/n8rKSnr06EFJSQlDhw5thxJLOhqjRo2iR48e9b73+XycdtppyTd6RVE466yz6NWrF19//TXRaJS+ffvSs2dPAoEAQgjmzJmDqqqcf/75HH300RiGwZ/+9Cfef/993nvvPQzDYNSoUfj9frp168bJJ59ca539qaeeit/vx+/3c8stt/Dll1+yevVqDj744HrOgKIojB07losvvpjDDjss2e4vvPBCXn/9dWbPns2oUaO44YYbyMvLA2D06NE4joOiKBx66KFccMEFfPzxx/Tv359rr72WWCwGwJgxY7jllluYO3cuS5cuJScnh4kTJ9bTKD09ndtvv51Zs2Yxe/ZsBg4cyGmnnYZhGPh8Pk455ZRaqyBqlv3II4+kW7dutb7XNI1f/epXvP7668yZM4fx48eTl5dHVlYWiqJw1VVX8dFHH/HDDz8waNAgxowZw6WXXsonn3xC3759ueaaa5IP3iFDhuD3+5O9A8FgkD//+c+8//77zJ49G4/Hw/77719v6aaiKPTq1Yv77ruPjz76iA8//BBVVZOrSbKzs7n55pv58MMP+fHHHznrrLOSw5R5eXksWbKE77//nmAwyO9+9zv69euHruuccMIJyZ6VzMxMTjnlFBlzQNKhUMRPZEqrbdusW7eOf//73xxwwAEcf/zx2LbN/fffz2WXXYbf76eqqorDDz+crVu38vbbb7Njxw4uv/xyBg0axMsvv8yWLVuYOHEiTz/9NH/729/Izc1t72pJfmLUjJ5Xs4u77hryhqIDJo7v6/I1lHZvUQubUu69ncet8rck7+Zci4auaWPn2JfXWiJpS34yzkAsFmPGjBns3LkTVVU58MADmTx5MqtXr+bTTz9FCMHYsWMZM2YM77zzDitXrkQIQZ8+fbjooouwLIv33nuP7du3J9eHyxtVIpFIJJKfkDMgkUgkEonEHX4SC+3XrFmTXCbY2RBCYNu2DEDiAlJbd5HauoNst+4htW2Yn4QzsHjxYlatWtXexXCN4uLi9i5Cp0Vq6x6JtfiStkdq6x7FxcVS2xT8JJyBzn7hZBQy95DauofU1j0SAYokbY/UNjU/CWegs5PYM13S9kht3UNq6x6JwEuStsc0TaltCuRC1xQ01FDqboHaEE1NVzP93vJu7rmaWs7OTleoY3shtXUPuW+KeyQiXUpqI52BOiT2Wn/iiSe44447WLt2LTNnzmTChAlMmTIluUNdeno6o0aN4uyzz+brr7/mgw8+IDc3l0svvRSPx8PMmTPZvHkzJ554ImPGjOHpp5+mqKiInTt3ctlll9G3b19mzJiBbduceuqpdOvWDSEE8+bNY8GCBfzxj39kwYIFzJ07F0VRuPDCC+nduzcvvPACW7Zs4YgjjuDYY4/lzTffZMWKFXTr1o3LLruMzMxMIB5D/Z577kHXdfr27cvll1/Oe++9xzfffENaWhqXXXZZs/aF/6mSKgiVpG2Q2rqHdAbcQ2qbGqlKHWKxGK+88grr1q0jFovRt29fxo4dy4YNGwCSEc6uu+46Tj31VMLhME8//TSXX345fr+fWbNmsWDBArZv384VV1zB//3f/2FZFr/4xS+46aabiMVi5OXlMWPGDMaMGcNpp53G9OnTcRyHXbt28d5777F69WogHh3v+uuvZ8yYMbz44ossWbKEjRs3ct111/HWW29RWFjImDFjuPHGGzEMg/fffz9ZD8uyKCkp4dprr+XCCy9E0zRGjRrFjTfeSG5uLm+++ea+F7cdSETVk7Q9Ulv3kNq6hxyCSY10BmoghOCjjz5i+PDhyRC1PXr0oFevXsk0Ho8H0zSZNm0azz33HI7jJPc+CIfDLFmyhFWrVnHQQQfRt29fAoEAxcXF+P1+du7cSTAYTMaRj8VimKbJypUrqays5NVXX+W0005L7q2QlpbGm2++yYwZMxg7diyqqmKaJqZpsm3bNrZs2cKQIUNIT0+nqKgoGXYWSMZFf/zxx/nHP/5BLBZj0KBBZGRksGvXrpQheDsjNTcIkrQtUlv3qBlKWdK2SG1TI52BGpSVlfHaa6+haRrbtm1j1apV9TzIvLw8HnnkEf7617+yZMkSKisrufbaa3nllVfYsWMHgUAAVVWTYUkToUmFEHz44Ycce+yxaJrGZZddxpo1a/jkk0/IzMxk9erVfPfdd+zcuZNt27axefNmFEXhggsu4De/+Q0LFy5kzJgxjBgxgpkzZ+L3+9F1Hdu2ee211/D7/YwfPz5ZzkAgwP33389f//pXiouLWbt2LY7j8M477xAOhznhhBP2tbztQks2zJE0jZq7HkralqqqKqmtS8h2mxo5Z6AGHo+HqVOnEolEME2TSCRCOBxm9+7dlJeXU15ejhCCsrIyIpEIsVgMr9dLfn4+l112Gc888wxHHnkkwWCQWbNmMXjwYKLRKDk5OYTDYZYuXcr555+f3NP8/PPPZ+nSpYRCIfr168fkyZOpqKjANE2i0SgbN25M7q1eXl6OqqpMnDiRUCjEhg0bGDx4MG+//TaLFy/mN7/5DZZlUVFRwapVqxgzZgyFhYVomkZJSQnBYJAPP/yQuXPncsstt2Db9j7XVwhBSUkJc+fO5fTTT8dxHObNmwfApEmT8Hq9LFq0iLVr13LggQey//77s2bNGhYuXMhRRx3FoEGD2L17N59++immaXL00UfTs2dPvvrqKzZu3Jjc4S8Wi/Hxxx8TjUY56qijACgtLeXTTz9FURSOP/54tm/fzqJFiwgEAvzsZz8jLS2NnTt38vnnn5Oens6kSZMAmD9/PgUFBUyYMIHevXvXqsuqVavYvn07xx57LMXFxXzyySdkZGRwzDHH1Ns5szOSlpYmx19dIi0tTb69ukR6errUNgXyTq5BIBDgtNNO46yzzuLnP/85RxxxBOvXr+ebb74hHA7z9ddfU1lZyZtvvsk777zDjTfeSLdu3fjhhx948cUXOfjgg5kwYQKHHHIIBx10EO+++y6/+tWv8Pl8VFZWcsIJJ5CVlQXEg4q88sor7Ny5kwsuuICePXsydepUzj77bC677DKGDh3K+vXrmTlzJuvXr+fXv/41tm3zwQcfMGfOHG666SbS09PZunUrGRkZzJw5k++++45oNEpBQQHRaJT333+fV155hYsuuoj8/Hw2bdpEVlYWL774IosXL97n+jqOw8yZM3nyySepqqrixRdfZPPmzWzevJkXX3yR9evX85///IcBAwbw4IMPsnv3bgoLC1m8eDHffvtt8hy9e/cmMzOT++67D8uy8Hq9DB8+nJdffpnvvvuOmTNnsmHDBhzH4YknniAWi/HII49gGAY9e/bEcRyEEAwZMoSCggKeeeYZKisrefjhh8nJySErKwshBK+++iqrV69m8ODB9epSXl7Ov/71L1599VVs2+ahhx5C0zRWrVrF//73vy7x5lFZWYnjOO1djE5JRUVFl2hD7YHUNjVdtmdACIHZoB1TOfu8CwDYb8Qobr/z7lpHr7vh18n/mw4cNWEiR02YCEDilKeecWatNN2yc5ky9ZzqPAW9+uZzw003IxBEwmFMJ944Pf4g55x/IZaAoydO4uiJk2rlfenlv0j+3wauue5X9Up/2pSzALjyml/WSnvZL66qlS5m178hdBVUF7xmIQRLlizB5/MxYMAAbNtm6dKl3HbbbQDce++9nHDCCQSDQcrLy8nKysLr9TJhwgTWr1+fPE9ubi6bN29myZIldO/eHU3TGDZsGG+88QYlJSWkp6ezefNmTjvtNHr37s2MGTPYsGEDy5Ytw+PxkJaWxqhRoxg0aBAffPABK1euZOzYsaxatYpNmzbx6aef0qdPH0aOHMns2bMZNmwY7777Lj//+c+TQz6O4/Dmm29yzDHH8Nlnn2HbNrt27WLcuHFkZ2fzwgsvMHXq1E7/9hEMBmXPgEvIngH3CAaDUtsUdFlnoDTm8Mb6ciynfT1EBfBHywh7M2lvX1VRYHK/NAakt30Xd1VVFa+99hqXXnopn332GWVlZViWhWEYQHz1Q2KWb0FBAUIILMtKea7evXtz2GGHsWDBAhzHwePxMGbMGLZs2UJVVRVnnXUWzz33HOnp6YTDYUKhEKFQiKuuuooXXniBTz75hJNPPpmhQ4eya9cuotEolZWVCCG44YYbuP/++1m+fDm7du3i17/+NdFolOnTp3P33XGncO3ataxbt47TTz+dqqoqLMvi9NNP56GHHkII0WVmgofDYRnNzSWqqqqkti4RDoflJMIUdFlnwBaC0qiN1d5PYCGoMlWi2PGncTuTqregLYhEIvj9fl5//XV++OEHvv76a3JycpIbUOXm5vLjjz8yYMAALr74YlasWMH27dvJyMjAtm1s206u2sjOzubwww9n5syZhMNhdF1n//33Z+HChaxatYqpU6dyzz338OOPPxIKhejbty/5+fkEg0HS0tKSKz/69+9PJBLh3//+N0ceeSQ9e/YkEAgkDcWwYcPIyMggGo1imibhcJiysjJCoRC2bfPyyy/z/fffs2bNGk466SQmTZrERx99xNatW9vF0DiOw/r16+nTpw8+n4+dO3dSXl7OgAED0HWdaDTKpk2bkkMhpaWlbNmyBYD8/HwyMzMJhUJs3bqV3r17k56ezs6dOyksLERRFAYNGoTH42Hr1q3J6wBx45oYgsrNzcW2bbZt24YQgv79+ye1CIVCFBYWMmDAAFRVxXEcNmzYQK9evQgEAsl6JH4fiUSSZd+yZQu2bdO/f/8uEd+gK8w5aS88Ho90BFLQZZ2BjoQiOv+4a3Z2NnfddRemaaKqKqeddhqHHnoo06dPB+AXv/gFubm5fPbZZ9xxxx1kZWUxaNCg5KTHRPAkIQSzZ88mGo1y2mmnoSgKjz32GJWVlQCcddZZrF27lpdeegnLsrjgggvIzc3lpJNO4p577sHr9XL22Wfz9ttvs3LlSqqqqrjkkksYNGgQBxxwAH/961/p3r07o0eP5sorr+T//u//EEJw6aWXsnXrVj744AOuv/56Dj74YAoKCsjNzeXAAw/k448/5pNPPsHr9XLdddftc2MjhGDp0qXccMMN/Otf/yIQCPCPf/wjOb/iqquuYtq0afh8PjZs2MCf//xnPv30U7755hv2339/0tPT8Xq93HXXXfTu3ZtNmzZx11138fzzz2NZFv369aNHjx6sX7+eDz74AMdxqKio4NZbb+W+++4jKyuLTZs2cf3116MoCv/85z8pKSlh+vTpKIqCbdv85z//4bPPPuOVV17BMAxWrlzJ1Vdfzd///ncOP/zwZD3eeOMNfvzxR/Ly8khPT2fx4sXMnz+ftLQ0hgwZwnnnndfpjbmci+EeUtvUSGegA6C0+wBB29LY5Bxd1/nTn/6Eruukp6dz7733Jr8Hkg6DYRioqsqxxx7LMcdMBETyu4MPPhhFUZJDDDfffDO2bSePZ2Vlcdttt6GqKhUVFSiKwjnnnMMZZ5yBruuoqso555yDaZpompbM+8orr8Q0zWSa0aNHM2LkSJTq8gkhGDhwYLKOPXr04Le//S2KojBx4kTGjx+f/G1jIa3dIBQK8f7773P44YfjOA4ffvghp5xyChMmTODXv/41mzZtYvv27Tz66KO8+OKLfPnllziOg2EY5Obm0qNHDzZs2IBhGNx444088MADrFy5MjkM06dPH7p160ZOTg77778/5eXl3HDDDZSUlLB9+3b+/Oc/87///Y/33nuPX/3qV9xyyy3cddddyeW1y5YtQwhRqzfh7bff5ogjjqhlnCsrK5k1axYnnngi3bt3p3v37syfP59LLrmE7Oxsfve733HmmWfi9Xpd0bGjIB9Y7pGYQNzZHcrmIp2BDoCtdq7LUGE6fL6jitZNx0i1CU7dOQTRvfxGYJgmZnllje/qjuenyqc1Y/4N/3ZsDz95/ra/1kII3nrrLY444gg++eQTHMehuLiYww8/HI/Hg67rFBUV4ff70TSN7OxsduzYwfHHH8+AAQOSgbIOP/xwunXrhqIoZGdns3v3bk4//XRKS0v54IMPKCgo4LzzzsNxHF599VUOOeQQsrOzycnJ4YknnmD58uXJ5Zc1DW0oFOKdd97h4osvZuXKldi2zbvvvsuYMWP45ptvahnnUCjEqlWruOSSS1iwYAHRaJTDDz+c5557jqysLLZv345pmp3eGZBd2e5hGIbUNgX7/Clk2zabN28mLy+PYDCY/F4IQTQaTY4TZ2dnd5kLptsxYnrnieYWsQUrS6K4NP2g6QhBIFpBlVftEPMxRmV5yXPhMpumyVdffYXX600+QPv06cOuXbuIxWJYlkVeXl5ysuOuXbvIyckhPz+f/Px8evXqxcMPP8wJJ5yQ3Ot9165djBkzhmHDhgHxnpG3334bIQSvv/46JSUlXHzxxei6zu23387mzZsJBoPJXpaabNy4kTVr1vDYY4+xaNEi5s2bx/z581EUhSVLllBUVMRBBx2Eqqr4/X6GDh3KEUccgaqqLF++nBtuuIGDDjqInTt3snHjxnZxBIQQVFZWsn37dvx+P3369EFRFHbs2EE0GiU/Px9N0ygoKKC0tJS8vLzkMuKCggIikQj9+vVD0zSKioooKSlh4MCBGIaBaZps2bIFr9dLr169cByHtWvXEggEGDBgAB6Ph8rKSnbs2EHPnj3JyMjAsiy2b9+OEIL8/PzkNSspKUnO96iqqmLbtm0YhkG/fv2S10YIQVFREUVFRWRnZ5Obm9tlbC3E5y/JFQX12afOgBCCb775ht/97nfcfffdTJgwIXksGo1y3333oes6BQUFXH311YwePbpLXLCYLveFd4uuoK1hGDzyyCM4jsODDz7IKaecQvfu3fn73//OokWLOOyww8jPz6d///5MmzYt2a3/7rvvsnnzZtatW8ekSZMYPHgwiqIwbdo0SkpKGDFiBC+99BJlZWV8//33XHDBBSxZsoR//etfnH322Xz66adMnTqVjz76iM2bN7Nx40Z+//vfU1JSwrPPPssPP/zAa6+9xllnncX06dMpLy8nGo3ys5/9jOOOOw7Hcfj73//OhAkTiEQi/P3vf+e2225j/PjxPProoxQWFnLFFVewdu1aPvroI7Zs2cL555+f0uHYF3z77besXLmSdevWMW7cOLp3784777xDTk4OPXr04OKLL2bu3LmEQiGWLl3KX/7yFwoLC5kxYwaZmZkMHz6cM888k6effppPPvmEZ555hl69ejF9+nR27dpFKBTitNNOIysri3feeQe/308oFOLPf/4zs2bN4rXXXuOKK67g1FNPZfPmzTz22GOUlpby9NNPU1FRwYwZMwgGg3z//ffcc889rF+/niVLlrB161aGDh3KJZdcklwa++mnn1JcXMzSpUv59a9/zfDhw9tF0/ZAOgKp2ad3VXl5ObNmzeKQQw6pNya2YsUKIpEI9957L4sXL+bVV1/lgAMOSLm9b2e7kF4zjKV17m7P9qIraKsoCl6vFyEE119/PWlpaXi9Xu644w4qKyvp06cPmqZx0003sW3bNrKyssjMzGTChAns3LmTQCBAz549UVWVP//5z+zYsYMePXoQDAY58cQT2b17N1OnTiU3N5eKigr+/e9/A/HxfVVVGT9+PMXFxfTs2ZNgMEgsFuPMM89kypQpybDZHo8Hj8fDHXfcUWtZ19VXX00gEMAwDK699loMw+Cqq65i27ZtBAIBcnNziUajnHTSSaSnp7frW+yRRx5J7969cRyHrVu38v3333PuuecybNgwfvnLX3L++edz9tlns3r1apYuXUpZWRnvvvsuF198MYMHD+YPf/gDU6dO5ZZbbkmutjBNk8WLF/PAAw+wefNmZsyYwcMPP8w111yD3+/nhhtuIBaLcd555xEOh5N2c+DAgfz+97/nrrvuAiAzM5Pf/va3ANxyyy0UFhZyyCGHkJuby+eff87GjRuT9VBVlTPOOIM1a9awevVqioqK9rmW7UllZaVctpmCfeYMOI7DG2+8wYQJE/jqq6/qHd+0aRMDBgxA0zTy8/MpLCzEtu1kUJP58+dTVlbG6NGjyc/PT44z6rpOLBbD5/Ml148m1j/HYrHkMqTEBLNoNIrf76eyvBLNNtGsGLaqowobgQKKgurYWJqBbsewNC+6HcXSPOi2ia1qqEIAAkfR0BwLSzMwrBimvietZpsIRQMEihA4qobmmDXOF/+0VQOhKBhWpAl566jCqZd33bSabSJUDUT9vA0rmiynrRr16m1GPZSW1tYxGo1iGEZSc03TkuO2iSWDNTWvioHHimDbTop6e9DtWMq8m6t5o/WuTgugOWattM3LO942gEbz1m0Tp07edTWvqignbASxLAtFUZKz7D0eTy0d/X4/kUgEwzCSYaMTmmseLztKQ8Q0D4Ydw9IMNMfCUVQUQBEqO8tj6HYIU/NieGFNSWRP2kA3CqKwY2cZqnCwM/Jw7BirdocwrHi71ALd2BKyUSpLAQWRkUeJbVG0qzJ+7bL7YFhRPMEs1u0qw1E1lPRstlXGsKtsdNvC6t4bw45SqXn5sbAkWU6h+ilN5K3q6DYU2BaGHcLS0igvKMbRdBRfJhEHdu8sR3Us7PQ8bDvKrl2VdeqtoeCQ69MIeIx6tiASiSQ3F6tpC/amuaIoyY3BEu3c6/Xy1VdfsWLFCiZPnoxpmrz88sv069ePTZs2sXPnTnw+Hx988EHSQSsoKEjeO9FoNBkYK7FJWSgUYr/99uPf//43FRUVbN26lcrKSjRN49VXX2X06NFEo1E0TaOqqgrbtikvL0fXdcLhMLZtJz+9Xi9ff/01pmnSvXv35MZpCxYsYPz48VRUVCTr7TgOc+fOpbKykszMTMLhcLJd1q13Y7agIfvr9XrraV7T/ta9Pm2Z995sf2KJcjQarZe3ZVn12kZb5N1Qu2xJvRO2oKG8A4FAi3rP9pkzsHbtWpYvX87RRx/NnDlzkuOZTV1Pm5+fz6hRo8jJycEwjFq9BKqqomkaPp8v+anrevJY4uJpmoaiKGiahsfrw1FtHM1AKCpCqPE5/YqCo2g4ioqleWp8algaCEXFScwUVxREdXpTr50WLX4MiD+QFbU6be3zCkVFcywiRrCJeav18q6bNpm3oPrBtCfvmuVMVW9N1/H51AZ1TGiuaVqDmhvEDb1Nqnpr1Xlr1XkroNAizfdWb1H9oK+btvl5711zq17etTUXqorh9SZXPCScAcdx6umY+FRVNXlTJzTfHRO8sz2KiYUqbBzFQhVOnbxNlOQxG0ex66dNtkuzTpr4p1BMqKG5Ipx65/NHK4l4gtVO0B7NU6VN5l2tee28rXp5K0Ik22Wj51MUVOCsgelkVLe/mjp6vd7kCo+Wal6zfU+dOpXDDjuMxx9/nAceeIADDzyQ4uJili9fTvfu3QkGg9xwww1Mnz6db7/9ltzcXCorK5MPhcS8Ck3TknMkbrjhBjZt2sS6detQVRWv18tbb73Ftm3b+O1vf5tMn5j45vV6UVUVj8eTLK+u66xevZrXXnuN2267jW7duqFpGqeccgqHHnoo99xzD6eeeiqO4yTrcvXVVzNr1izmz5/P8OHDkw+wvd3fdW1BQ/Y3oTlQz/7W1dyyLLZt24aiKPTu3Tvp7OzYsYOcnBzS0tIoKCigvLwcRVEYOHAguq4TiUTYsGEDaWlp+P1+tm7dihAC27aT8zi2bduG1+ulZ8+eaJpGZWUlpaWl5OTkEAgEKC0tZefOnSiKktxRduPGjUk9Bg8ezI4dO5JB0Xr06EEgEGDDhg1omkb37t1JS0tL1ruiooKdO3eSlZVFVlZWynp7vd5kG0i0y+Zovre0LWGfOQPRaBSfz8fzzz/P8uXLKS8v5+ijjyYrKwtd1xkwYAALFixITjBMXLgE/fr1Y9SoUY3mkbiJ636mSuPxglDC2FrDzoiNlvKzpWlTphGCiBHEUfVak9z2Sd4pUDUNny/erd6YjglSaW44VtwZUPaWd8vL2aS0QhDxBBGKiq3u47xr5JE4Zni8ScNdl6a0XQDFMuMOjWhe3m3RNuqmiRoBLM3T4ORMN/Ou+SkAzTAwqv9B82xBU9q5pmm89tprlJaWsnbtWsaPH09BQQFz5sxh69atTJ06FSEE//73v9F1ne+++46TTz6ZgQMH8txzz5GRkcFxxx2Hz+fjv//9L2vWrOHFF1/kmmuuYeXKlSxfvpw1a9Zw1VVXsWbNGqZPn865557Le++9x+mnn87ChQuZP38+gUCAoUOH0rt3b1588UXWrFnDW2+9xfHHH89tt93G2LFj+fDDDzn55JP5+uuv2b59O5s3b2bs2LHYts20adO4+eabefbZZ1FVlW+++YbrrrsuqVtrNGqN5hs3bmTu3LmUlJTg9Xq58MILuf322xk1ahRr1qzhwQcf5F//+hc9evQgNzeX/v37EwqFePjhh+nTpw+9e/dm8uTJrFixgsrKSt544w3uvfdeHMdh4cKFbNu2jf3224/zzjuP//znP+Tm5rJ9+3buvPNOXn/9dXbv3s2AAQPIyclBURSWLVtGZWUls2fP5oUXXmDt2rXs3LmTDz74gIsvvpjs7GyeffZZxo0bx8EHH0yfPn3QdR3Lsnj99ddxHIfvv/+eG2+8kREjRrS5ji1Juzf2mTNwwAEHcMABBwDw4IMPcsQRR5Cbm8vf/vY3LrzwQkaOHInf7+dvf/sbhYWFXH311V1mTEe3TcwuMNGtPZDauofuxDDxEA+q3fk5/vjj2blzJ6eccgo9e/bEsiyOP/745JwLgClTphAKhTj//PPJzMwEoFevXsnVBIqicOihhzJq1ChUVSUQCDB69GhycnI499xz6d69O5WVldx777107949uTQ0MecA4uG4E5uqnXLKKfj9ftLS0nj44YeTQxzBYJBjjjmGHTt2JFc/QHyORlpaGlOmTKG0tJSzzjorGfuhPRkyZAgZGRksXbqUd999l7KyMrp37855553HnXfeSTQaxXEcMjMzGTFiBMFgkLfeeguPx0NWVhajR4/G5/Nx7rnnsnv3br788kuGDRuG3+8nLy+PL774grVr17Jp0yaqqqq4+eab+X//7//x3Xff4TgO6enpDB48ONnz/POf/5wvv/yS4uJiunXrxqmnnko0GuWrr75i7NixrFmzBr/fT69evZKxRyDuNF599dWoqsozzzzD999/z4gRI9pR2aazz5yBxINdCMEVV1xBIBBAVVWuuOIKsrOz8Xq9/PGPf2THjh2kp6d3qaWFjtzsxTWktu6RmJPRWQiZDhsrYo2EAPNDbn9KgJKy6vgUWX2JAMWl1fElAjkQyGGrA1tLquNgeLqBB1YlftOtN3SLbx62NiQAA3L7sx3YXhIFDLS+wxAZ6cQUJf47IxN6xZ2LbQIICegRfwhVJc6TNwCI95SsjwB4ILc/JlCeyNufHS+7pxvkdaMAKCipG6+jNj38OrkuxMeoy/r16/nyyy8ZPXo0PXr0oKysjAceeIC0tDSCwSDnn38+VVVVzJw5k1AoxMaNG9myZQsTJkzgb3/7G3//+98JBoPMnz+fQw45BL8/vo531apVLF26lCOPPJLy8nIyMjJQVTUZS+OEE06gqKiIjz/+mM2bN3PRRRfhOA7vv/8+p59+evI5tHLlSvLy8sjJyUEIwZlnnsmmTZt44IEHuPvuu5PDAaqqsmPHDhYsWMDtt9/uum5txT5fo6MoCrm5ucm/Ex4rgM/nq+VlSSStp2s4lJLWUxK1mbWpskPEA/XGwkRLlA4RH2Ni78A+cQbGjRvH6NGjufHGG8nNzWXkyJH86le/4rbbbmP9+vUcfPDBAJSVlbFixQpyc3Pp1q0bEyZM4JVXXqGiogK/38+8efP41a/27OZ6/PHHM2bMGP7yl79w0003UVVVlQzMNWTIkOSyyoyMDF5++WUAiouL2bFjB/vvvz8Qf4l9//33OfHEE1EUhby8PPLy8qisrORXv/pVctKgYRgUFRXx0EMPce211yaDcP0U6Fyh736iqI7d3kXotKhO6p0PJa0nscpC0sYIUW0TBF3FmZ0/fz7ff/89xcXFDBo0iJEjR/Luu+/yn//8h5KSkuQYvWVZLF68mBtuuIHu3btz//3389hjj5GdnU12djbbt28HYMCAAQC8++677Nixg82bN3PIIYcwcOBAvF4vjz76KFu2bOHKK6/k9ddfp7S0lOXLl3PGGWcghGDBggUceuih+HzxIcaKigo2bdrEjTfeiKIofPXVV3z77bcUFBRw6KGHoqoq99xzDzfffDN33nknAN999x2BQCAZuKujo4jGAsl3EF544QVycnKYPHlym52zKGLx7A+lHWLXQsOKxMe1O8BbwFkD09mvW+vW5e8MWzy3urRDRCDsSNqeOziDQRmt241uR8jk+bVlrQz13DYYVgRT87a7tgpw/pAM+rdy6+2tlSYvrC1r/54BIZLLUdtbW4j3DIzrEdh7wlaQ2C1T13X69euXfMMuKiqiV69eZGZmUlBQQElJCXl5ecl5DsXFxRQVFZGfn59caldRUUFeXh4Qj22zY8cOfD4fffv2TUaA3L17dzJS4+7du9m5cyfdunWjZ8+eKIrC7t278Xq9pKenAxCLxdi1axe9e/dOhs3eunUrHo+Hfv36oaoq27Zto1evXmzcuJFwOAzE53d0hDkZTUH2DHQA4je+nOTmBlJb9zCsSHxlQxd5e92XGHYEU+88kzNDpsOmChPRoKulQW5/LGBtpQNEQUuHHulsc2BbSRS83aFndwqBwsQ8ByUIuUHWh4FwFFDByKQoOQ/CC3kDCAGryy3AIlQeI5jbny2WAiVRUNOgZ1p8Lkhi7oeaFt+2pDiyp4j+bEqT591T3vh5gWAu5eUWZPUlMVOpACioeY469AzoZPs6xmO4Y5SiixMzOs++BB0Nqa17xHS/dARcIr5XSefRtihi8c6mivbvdUGgW2CVVXaIXpfj+gY7jDMgp1p3ALxmVXsXodMitXUPjxXudNtvdxQ8Zhiktm2PSGgrqYt0BjoA8u3VPaJSW9eI6T7ZM+ASMcNHZ+oZ6EjEtZXURToDHQDDanhMSdI6PFJb1zCsqOwZcAmPFUX2DLhDXFtJXaQz0AGwGgmJLGkdUlv3sOXkQdewNAPZM+AOcW0ldZHOQAdAxhlwD6mte8RjOMi3VzeQ7dY9pLapkc6ARCJpIfLN1T2ktpJ9i3QGOgCdLcZ7R0Jq6x7xfR/kQ8sN5J4a7iFtQmpki+sA6I7Z3kXotEht3UOzTeQwgTtIbd1D2oTUSGegA2DqrQv/K2kYqa17xLWVPQNuILV1j5i0CSmRzkAHQAbBcA+prXt4rIhcWugSHjOC7BlwB6+0CSmRzkAHIGq4uwlIV0Zq6x4yHLF7xAORSW3dQNqE1EhnoAMgQ+a6h+wZcA8Zjtg9PJYMR+wW0iakRjoDHYD4piQSN5A7FrqHKcMRu0a83Upt3UDahNRIZ6ADoNsyPKZbSG3dQ7diyLdXd9BlOGLXkDYhNfts70QhBEIIHMdBURRUVUWpsYWkEALbthFCoCgKmqbVOt6ZcdSOsYVlZ0Rq6x62Ktdru0W83XYN+7evkTYhNftMlVgsxtNPP83WrVtRFIVzzjmHMWPGJB/4u3bt4o477iAzMxNd1/nFL37BwIED91Xx2hVFyDcAt5DauoecL+AmUlv3kNqmYp85A4ZhcO655+L3+1m5ciVPPfUUjz32GJoWf7uIxWIYhsGtt96KYRh4vV1nLaiC095F6LRIbd1DOlruoQiH+ENL9g60NaqQNiEV+8wZUFWVjIwMFixYwOLFixk6dGitYQBFUdixYwePPPII+fn5nHfeeaSlpSWPFxUVsXnzZrp160YgEKj1O8dxUFU15WciDyFErWOWaaEIgerYCBQU9viLCgKhqCjCqf9Z5+ZsStq9pXEULX7zC5fyRkUhdZr48RppHQfTNFPqKaqN/940ty0HVdgIp7HyVZepiRq1rN4KjqKiIFAcex/nXV9z2zKxba3Rdrk3zYVw0Bwrfv7mXu9mtsum1Ft1bIQiamneFvdEc+5HVQHHtrFtu0W2IPFpWxaqcHBqODnNaWttWW9H0VAdB6Gyl/MlXAb3NEeIWjahrt1uiuaWZaEIp02ud2vr7VT/XxFin+ddz/ZbFpZl7dUWNEdzTdNQWxDOep8OnjiOQ1lZGVVVVfTs2TNp6ABycnJ4+OGH8fl8PP/887z44otcddVVSRGWLVtGJBLhsMMOY9CgQdWGUaDrOrFYDL/fT1VVFYFAgKqqKvx+P9FoNNnzYNs2Ho+HSCQST1NZgeqYaGYUWzOSToFQFDTHwtI8GHaUmO7DY0UwNS+6HcNW9XhDIn7Dao6JpXkx7EittJpjIpT4BVGEg63q6LaJqXvxWPG0hhXP2xerRABCUdEcG0szGsw74dWmytuwIliaF902cVQNEHvNW61+sAhFQRM2ZsxPRUWYQCBAKBQiEAgQiUTweDzJOR0JzX0+H+FwuJ7mYTM+uUx17AbztjQj/lBT4vHt1WbXO9X1qV1vR9XxRyuwNE+DeQuUpOa6HcWsl7eBKuwmaW6rWtzxSKG5qfuIhEJEfQqxWCw5J8ayLLxeb1LHuppblpWcQxOLxXAUA48ZxtG8terdWN4t07xmvdWU94RhRVCFjaUaybwdVUerl3cES/OkzDul5tX3Y2N516y3isAMVxH1iOT9HQqFCAaDVFVV4fP5kpqnsgWJtNGqSjQ7ht6kvBO2QKDQUL2j1fWuawvqau5Dt2vaoXhgHFXY1W2tsbwFjqqh2anbZaq8a2teP29Rp96O5aOiIorf7ycSiWAYRi37G41G96p5uCqCZptodqwBO5Q670btbwvr7Y9WVP8da7ntT5F3w7Y/nleqesfCVVRVxZ0A0zRT2tRUmieeeak0DwaDLXIGFCH2TV9fzWzKy8u58cYbeeyxx8jIyKh3fPHixbz++uvcd999qKrKCy+8QE5ODieccEK80G0wsbAoYvHsD6VY7d3TKQS6HcPSPNABJkyeNTCd/bq1bohmZ9jiudWl2FLbWpw7OINBGZ5WnWNHyOT5tWU47a0t8RnvHUFbBTh/SAb901un7dZKkxfWlrX/iHIHa7cTewcY16N1gXo2VcR4+cdyqW0djusb5NDcjrG0fJ/1DJSWlvLVV1+Rl5fHd999R25uLl6vlzfeeIPx48dTVVXFunXrSE9P59VXX+Woo46q99DvrKsLvGZVvHFK2hyprXt4zDC2ZshYAy7gMcNYmoGcM9D2SJuQmn3mDPh8PoQQfPvtt+Tk5HDbbbdhGAZ+vx9VVUlLS2P37t1s3ryZM888k7Fjx3bah39dZHhM95DaukfMkOGI3UKGI3YPaRNSs8+cAb/fzymnnFLv+5NPPjn5//POO29fFadDEX8LkJ6qG0ht3cNjRWTPgEt4LNkz4BZxbaVNqEuLnQEhBLFYjNWrV7N06VJ2795NVlYWY8aMYcSIEXg8ni7zZt9aLLmlpmvILYzdw9Q80hFwCVOTWxi7RVxbSV1aHI64oKCA++67j3feeYf09HTGjBlDRkYG7733Hvfeey/btm1ry3J2ajTHbO8idFp0qa1raI6FDODiDvF2K7V1A2kTUtPinoFAIMAvf/lLcnNzURQFRVGSIYeLiorweGQ3TFMRcosI13AUqa1bCNnz5xpO9RJMSdsjbUJqWuwMZGZmkpmZSUFBAaZpkp2dzUsvvUS3bt04/fTTMQyjLcvZqZFG1U2ktm4hhwjcRGrrHlLbVLTaRfrwww/ZunUrX3zxBYWFhSxevJi1a9e2Rdm6DKpjtXcROi1SW/fQqoMSSdqeeNAlOUzgBtImpKbVzoBlWUSjUZYsWcKZZ57J/vvvT0lJSVuUrcsgZ7a6h9TWPeLayrcsN5Dauoe0CalptTNw1FFH8dprrxGLxRgwYABlZWX06tWrLcrWZTAsub+2W0ht3cOwInLnQpcw7AiyZ8AdpE1ITavjDAwdOpT7778fq3rDhalTp9K9e/e2KFuXIR5gROIGUlv3iOky6JBbxHQZdMgtpE1ITaudgS1btvD3v/+dSCQCxHcnvO666xg5cmSrC9dVkOEx3UNq6x4eS4YjdgsZjtg9ZCCy1LTaGZg3bx6TJk3iZz/7WTLIkNcrgzo0h6j0VF1DausesmfAPWKGD+kIuENcW0ldWj1noH///kSjURRFQVXVFm2d2NXxWJH2LkKnRWrrHnLOgHt4rChyzoA7eOScgZS0umcgFArx3HPPMWfOHAzDQFEUOUzQTGSXlXtIbd1DDhG4hxwicI+4tpK6tNoZOO644zjqqKMwTRNFUTAMg2Aw2BZl6zLE1xRL3EBq6x6q4xB/e5UPrbZGtlv3kNqmptXOgOM4vPDCC3z33Xeoqsrxxx/PlClT2qBoEomkYyO7sSWSzkKbTCC0bZu7776bWCzGY489xqhRoxg+fHhblK9L4Khaexeh0yK1dY+4trJXwA1ku3UPqW1qWj3bb9euXRx88MHk5eXRt29fhgwZQmlpaRsUreug27H2LkKnRWrrHpptygmELqHbctdCt4hrK6lLq3sGjjjiCB5++GG++eYbIpEIW7Zs4ZxzzmmLsnUZTF0udXGLmNTWNUzdKycQukRM9yJ7Xdwhrq2kLq12BoYNG8Zf//pXvv/+ezweD1dddRXdunVrg6J1HTxmGFOTDdQNvGYYS2rrCh4rgq15pEPgAh4zIvcncIm4ttIm1KXFzkBBQQErVqwgLy+P5cuXJ79///33mThxIr17926TAnYFokagvYvQaZHauocMOuQe8ZC5Uls3kOGIU9NiZ0DTNDweD7qu4/P56h2ri23bzJ8/n40bN5KZmckxxxxDZmZmMmqhEIJNmzbx5Zdf0rt3b4466igMo2usB5XhMd1DauseMhyxe3gsGY7YLaRNSE2LJxCmpaXRr18//H4/Bx98cK1/GRkZ9dLbtk0sFmPo0KEUFhbyyCOPIMSeCTIlJSXcd999ZGVlMW/ePGbPnl3reGfGlGNYriG1dQ9T90lHwCVMTYYjdgs5Rys1Le4Z2LZtG08//TSO49T6XlEUrrjiCoYNG1bre4/Hw6RJk6isrCQWi7Fq1apaD/vvvvuO/Px8Jk+ezIABA/jXv/7FqaeemuxlEEJg23bbhTtOZN0BHA7djsUbaHuXpdr2tJkT1t71oSNpu6cHrE1o7/oQ19bSPO1flE6qral7OsyCgs6lbTT+ktAByoJoQ21rkOhxbw4tdgYGDRrEnXfemfJYQ937lZWVPP744yxfvpxLLrmk1oN9165d5ObmoigK3bp1o6KiAsdxks7AW2+9xbfffsvEiRMZMWIEtm0jhMAwDCKRCMFgkMrKStLS0qisrCQYDBIOhzEMI+lIeL1eqqqqSEtLo6S4DN1ykl1GmmMhUBGKgupYWLoXjxkmagTwmlXEDD+GFcVSDVQRj2DlqBq6HSOm+/BWp/WYYUzdi27HcFQdEKiOg6UZGFaUmOHHa1Yl01q6B8OOIWKVCEWN5615MaxIMm0yb81IRs9qdd5WfGKd5pjJemuORSSssytWRnp6OhUVFaSlpREKhfB6vU3WvNxS8MVCOLadIm8/HiuSzNtRVEBJ1ttjpdC8Xr1NYrq38XoLB1vV8VjxY/XS1qh3w5rHJ3E1R3NFCBQcbNVAt6PE9MT5ApQXFxFSM4hGo2iahqIomKaJ3+8nFArV09zn82FZFhAfeovFYtiql2C4lLDuj+dt+NCtaK28LdXAsKM1yhnX3NS86LaJo9bU3IPHitTRvE69FQ3dMTHr3BOKcPBHy7FVo0a99UY0qp936rbReN7x8/nQ7Xi9VQThcodK/Ml2WVFRQXp6OqFQCL/fX0tzy7KStqCm5hUl5XjMGEqKvA0zTKxOu7RTXu/G6h2PfteUemuORSBajqn76tmhPdc7HgHSabLmjd2PCRuo4CgqumMlNXdiGrt27bm/PR5PSluQ0LyyspJAIEA0GkXX44+Y0rIwhmWimw3V24I6eafS3FJ1VOGgIJrQ1rQGbGAYS/fWaOfxvJP2t0HbH8+7abZAq77eqezvHhtYVW5SaviT93fCFtS1qQ1pXllZmWzDCc3T09PxeJo/DKKIFrola9as4YknnkjZM3DttdcyYsSIer8RQuA4Dtu3b+euu+7i73//ezJ08axZs1i3bh033ngjmzdv5r777uPxxx9H13VeeOEFMjMzOe6449B1PeWchOZSFLF4bnUZltP+3qEvVknEk9bexQDgrEEZDM1s3XjazrDFjDVl2FLbJIoCZw/KYFBG67QtqLKYuaYUu/2lxWuGiBmBdh8qUBQ4f0gm+Wmtm2O0NWTy0toyOkCz7TDaAkzsE2RsXusm3W2qMHllXVmHeBnvKDYB4Li+QQ7JbfsJjfu0Z2DAgAH86U9/qtfFoSgKmZmZ9dJHo1FKS0tJT0+ntLQU04wHftiwYQM9evRgxIgRvPvuuxQXF7NgwQKGDx9e66FvGEa9iYqtISlWC0RrU4RASWjY3mWppiUNKeXv27s+HUhbQVyX1moLINpb12oU4cR7sTtKeVrbblHiD9/2ro6I92x1Km0VoINomwyU1RG0bSOb0Ba02BkoKiriu+++o0ePHixdurTWsRNOOIG+ffvW+i4UCvHUU09RWVmJqqpcf/31+Hw+Xn75Zc477zwGDBjAcccdxwMPPEB6ejrXXntthxHJbeQuWu4htXUPW5Wz3d3Cktq6RlxbSV1a7Ax4vV66d+9OWloaPXv2rHesLt27d+fWW2/FcRxUVU3OF7jllluSY3lnnXUWp59+eq3jXQHDisoZri4htXUPw45iySiErmAkJrlJbdscaRNS02JnICsri4MPPpjdu3czadIkSkpKWLNmDUOGDCEnJ6deekVR0DSt3nh/YoJJIk1XiS1QExkEwz2ktu4hgw65R0yXQYfcQtqE1LTYGXAch3/84x/JoYLErPKdO3fy4IMPkpeX15bl7NR4zSoZBMMlpLbuIYMOuUd8lZMcKnADaRNS0+K++IqKCgoLC/nnP/9J3759OfHEE7n//vsZP348P/74Y1uWsdMTlZ6qa0ht3UP2DLiHDEfsHjJEeWpa7AxYloXf70fXdbKzs0lLS8OyLILBYHKlgKRpeKxIexeh0yK1dQ+PFZFbGLtEvN1Kbd3AY4XbuwgdkhYPE6iqysqVK7nhhhvYtWsXXq+Xl156id27d/Pb3/62LcvY6ZFdVu4htXUPU+5Y6Bqm3LHQNeSOhalpsTOQmZnJY489Vi/oEMQnF0qajuZY7V2ETovU1j00x8KMR1Bo76J0OqS27qE6JiBXE9SlVbsW1l1SKGkZouWjNZK9ILV1j44S/KgzEtdW6usGQpE2IRVSlQ6ANKruIbV1D+louYccfnETqW0qWtwzkEAIkdwIKIGmaV0qaFBrUWVXtmtIbd1DDsG4R1xbOUzgBtImpKbVzsCuXbt48sknKSoqQgjR6EZFktTICS3uYelSW7ewdDnJzS0sGX3QNaRNSE2rnYE5c+YwaNAgrr766mRvQKqNiiQNk9hmV9L2eMwwpnS2XCGxBazs0m57DDMiVxS4RFxbaRPq0mpnIDc3F4Ds7OzkxkJyiKB5yCAY7iG1dQ8ZdMg9ZNAh95DhiFPTamfAtm3++c9/Mnv2bAzDQFEUrrzySoYPH94W5esSyPCY7iG1dQ8Zjtg9ZDhi9/BIm5CSFjsDonqf+PHjxzN69Ohax1JtVCRpGOmpuofU1j1iuk86Ai5hGj6kI+AOprQJKWmxM1BYWMj3339PXl4e3333Xa1jkyZNwu+XgjcVw4rKMSyXkNq6h2FFq9+w5EOrrdGtqJwz4BK6tAkpaVXQIb/fj8fjIS0tLfl9YqtiSdOx1FaP1kgaQGrrHrbsxnYNW5XaukVcW0ldWmwp09LSGDNmDIFAoNb8ACEEVVVVVFVVEQjIyVtNQRX1QzpL2gaprXsowkGuhXcH2W7dQxX23hN1QVrsDOzatYunnnqKgQMHMmrUKDIzMykvL2flypX8+OOPXHHFFQwaNKgty9qJkbuTSX56KEK2W/eQ2kr2LS12Bvr168fvfvc7vvrqKz766CNKSkro1q0bBx98MFOmTJGxBpqBI7uyXcNR5ZCVW8TbrewVcAPZbt1DapuaFj+FFEUhMzOTyZMnM3ny5HrH6iKEoLy8nJKSEtLS0mrFJQCwLIutW7diWRaKotCrV68uM8yg2zFiupxw6QZSW/fQ7BiK7pUrClxAt01iulxR4AZxbaVNqEurX0lTPfhTsXv3bh555BEyMjLYunUrZ5xxBscdd1zy98XFxdxyyy2MGzcOTdM488wz6d+/f2uL95MgftNL3EBq6x6mXFroGjEZjtg1YjLaa0r2Wf90t27d+Mtf/oLP5+O7775j+vTpTJo0KbnyQAhBTk4OF110Ed26dcPr7ToXzGuG5f4ELiG1dQ8ZdMg9PGZELtt0CY+0CSlpsTMQDodZtmwZ48aNo7i4GI/HQ3p6esMZ6Tq6ruM4DsuXL2fgwIG1whZrmoamafzzn/+ktLSUG2+8kSFDhiR7Dr7++mtCoRD7778/ffv2xXGc5O9M08Tr9RKJRPD5fEQiEbxeL6ZpomkaQggcx8EwDKLRKD6fj1B5CNUx8ZoxbFVHFQ6C+Ja3quNgazq6bWJpHnQ7hqUZaLaFo2rVs6jj+2KrjoWtedDtKJbm3ZPWsZL7ZivCwVbrni/+aas6jqJiWJHq89kN5G3iqHqtvDXHqne+RN6OoqKkzHtPOeP1thEoCEVBEw5mzENZWQS/3084HMbn8xGNRjEMI7kzZWOax2Ixqsx43HrNaazeBqqwEKgIhUY0r1/vxjR3FBVFgIKDo2gI4jvANZp3A9dHs2PN1zyZt47m1NY8XFlBxBPENE1UVUVRFGzbrtUuE3o2pLkjNLyxEDG1brtsKO/65dxbu0xV77jmRq20tqrjMcPYqlZL88Y02pvmifOmvt51zlddbxWIVWmEdZtYLFZLx5q2YG+ah0MhdDsKTuP1rmsLFMTe691EW5Cot6Nq1Y7s3vIGZy/tsql577GBtestLIOysrJku0zY8abY34SND1VG0ewYWoN2qGbee7eBram3AmiOiW6bzci7vu1vC82jVRAKOSiKgmVZ9XRsieZ+vx9db/6jvcXOQCgU4oMPPmDs2LF8/PHH9OzZk/Hjxzf6GyEE8+fPZ9GiRdx+++21jmVlZfH//t//Q9M05syZw8yZM7njjjuSzkDPnj0ZPHgw3bp1Q9f1ZATExA2uaRoej6fWZ+I4gOM4aJqG1+tF0zQMjwehmPE3G0VFCAVQ4g9GLW7UbFXgKGr1A1sDLd4IFBE/p1DiD9F4GiOZViQ+q716RVGrvzNqnK/6b1WNj2EZgeT5RLPz3nO+vecd/7RS1BvFQdU0PB4VVVXr6ZnQsjHNPR4PunBwVB0bp9F6C6FX5w1CU1tQ7wY0V0BBRaAkH9IN560gFCf5+5ppqdaocc1r5x1vrmq1MTBqXRfdMNA0DUVRau3j0ZCOqTRXTOrUW8PWQKCiKCJF3k1pG02td+3r44tVEvGk4Sharbyb0i5FA/eE1RzNNR2BCopAMwx0Xa/XLhP3e1M01w0PQokh1MbrnWyXqCiKCogm17shzevW22tWJbVtPO/W2ILaeYsGrjeqisejJ7VSVbVR+5vQvKb9NQwRt7cqDdihJmreBjYw8bCulzcKQmtN3k23/Ym8NX1Pu23MFuxN85rPvKYO3delVcMEQggsy8I0zeRnolJ1NysSQrBw4UJeeeUV/vSnP5GVlQWQfHsHkjdteno60Wi01u8HDBjAgQcemLIchhEPIpHwhhKfie9TpfX4fAglgt1IgCSretZp4tOm6WlT4agp0gpBxBPEVnWocREdl/NOdT4H0DQdvz/ehVZXz5o0prlHWNiqjq00Uu8Gy9mG9RaCiCctfuNXjxM2nrfednlTv96G15eyTULDetZNo9gmlu5BiJp5p7iWzdK8ZfWOChHvym7A+LRVu9zb+QSgGR4Mw2iSjgnqpjU8Xmw1knJRX9vbgkY0F4KoEUhq67Yd2tv5FFVLRpRtri1I4PGCo0YQrahLm9RbCMLVThaNrOLaV5rrHk+9IfG6OrZU8+bSYmdAVVVWrFjBr3/9awoLC/F6vbzyyisoisL111/PqFGjaqXftWsXd955JwceeCBvvfUWPXr0YMqUKUybNo0zzzwTx3F48803CQQCrFy5kiuvvLLFHs5PDd2OYcqJbq6g26bU1iV0J4aJHNd2A90xMZGTCN1A2oTUtNgZyMzM5JFHHsG27eRDWwiBEIKePXumTD9t2rTkuIff70dVVS666CKys7MxDIOLLrqIcDjMpZdeSvfu3buMMyDXvbqHI7fTdg1Hke3WLeLadg37t6+RNiE1rYozMH/+fI444ojkEsBwOMyLL77IBRdcUC+91+tlxIgR9b7v169f8v9dZSmhRCKRSNoL6WSlosUuUigUYtmyZbV6ARKzGteuXdsmhesqqI6MQ+4WUlv3kDHe3SOurQxJ7AaqI9ttKlrsDJimiVE9g7cmGRkZhEKhVhesK2Fpchctt5DauoelyvkCbmHJXQtdQ9qE1LTYGUhLSyMcDvP9999jWRa2bVNUVMSSJUtqdf1L9o5hRfeeSNIipLbuYdiR6oWhkrbGsKPIngF3iGsrqUuL5wwYhsGll17KI488QiAQwDAMioqKOPPMM+nTp09blrHTEzNknGy3kNq6R0z3y+iDLhGPnS+1dQO5L0FqWhVnYNSoUTz66KNs2LAB0zTp168feXl59WIMSBrHa1ZVhx6VtDVSW/eQ4Yjdw1MdfVA6BG1PXFtpE+rS4qd2eXk5M2bMID09HVVVyc3NpWfPntIRaAFR+fbqGlJb95A9A+4R79GS2rpBzJAxBlLRqgmEmzdvBmDVqlVs2bKlzQrV1fBYkfYuQqdFauseHkvOGXCLeLuV2rqBtAmpadUwQSgUYuPGjRQVFaGqKhs2bACgR48eBAKBNilgV0B2WbmH1NY9TM0jewZcQu5Y6B5yx8LUtNgZ8Hg8xGIxHnrooeTuVPPmzWswHLGkYTTHau8idFpUqa1raI6FiUA+tNqeeLuV2rqBtAmpabEzkJ6ezrRp01Iek/MGmod8u3ITqa1biC4SLrx9UJBtV7IvaVU4Yq2RHf8kTcdRpPPkFlJb94hvlSwfWG4g2617yD01UtOqCYTRaBTHcZL7LEtahi67rVxDausemm0iJ7m5g+ZIbd1Cd8z2LkKHpMU9A8uXL2fz5s1omsb+++/PwIED27JcXQpTlxNa3EJq6x5xbWXPgBtIbd1D2oTUtNgZyMjI4L333qOiooL+/fuTl5cHxIcPpkyZwoABA9qqjJ0ejxnGlDNcXUFq6x4eK4ItVxS4gseMyBUFLmGYEWkTUtBiZ2DQoEHccsstvPzyywwdOpS+ffsmj2VmZrZJ4boKUUMuw3QLqa17yKBD7iGDDrmHDFGemhbPGVBVlSFDhvC73/2Oww47jJKSEkKhEMOHD6dbt25tWMTOj9esau8idFo8Zri9i9Bp8VhhGXTIJTxWGDlnwB2kTUhNq6esbtiwgfvuu49NmzaxfPlybr/9dkpKStqibF0GuXGGe5gy9KhrmLpP9gy4hKn7kD0D7iBtQmpaFYEQ4Ouvv+bnP/85Rx11FABPP/00a9asYdy4ca0uXFfBsKNyUotL6FZUjg+6hG7FMOW4tivE263U1g2kTUhNq3sG8vLyWLRoEYWFhWzevJk1a9bQvXv3eumEEAghsG27weWIezveWbHVVvtkkgaQ2rpHXFv5sHIDqa17SJuQmlarMmnSJDZv3swdd9yBqqpMnjyZIUOG1EtXWVnJ9OnTKSwsJBAIcOmll5Kfn49SHcXMcRw+/PBDPvnkEzIzM7nyyivJyclpbfF+EijCae8idFrULuRU7msUHGTIXHeQ7dY9pLapabUz4PP5uPbaazFNE0VR0HU9+YCviaqqHH/88fTt25f58+fz5JNPcs899yTTbtu2jddff50777yTL774ghkzZvCb3/wm5bk6G3ISlptIR8stFGlUXUQgHS23kO02Fa12BhIPa4+n8d3hgsEgo0aNQghBRkYGjlPbSK9evZohQ4bQq1cvjjrqKP76179iWRaGYQBQXFzM9u3bycjIwO/3J4cRFEVBCIGqqti2jaZp2LaNqqoIIZLlS/zfcZx4GstCQaA6TjzGel3DpigowsFRVFThxEOvCgE10yoKihA4ioKaKm0j50umRcFRtHjvgGg4rdLmeYt69VYA4TiYppnUUdM0HMdJ6twUzW3bjufjiIbr3cRypqo31WXf6/lIhMwVqI7deo1aoblQVGzLwra1ejrWapd70VyI6rqgNL+ttaLeqTRPnrfmOdu6XTbheisKOLadHGKsqWOTbEFCc9uK51En7wZtQb26tF2999gH9nne1ZYgqTlCJDejS2hXs102RXPbtlGE0+S8G7QFieOtqLdQFBQESnNtfxvkXbfejm1jWVaDNrUl9ldV1RbtD9Qmgyc1jUFjb/JCCAoKCpg5cybXX399rbShUIhgMIiiKHi9XkzTrOUwLF68mIqKCsaOHcvgwYOxbTteAV0nGo3i9/upqqoiGAwSCoXw+/1Eo1F0XU8+oLxeL+FwOJ6mohzVttCrg3uojhWfGa2oqI6FpXkwrCgxw4fHjGDqXnQ7hq3q8RsEgaNoaMm0EWKGvzqtB902cdR4DGzVcbA1Hd2OYWo+DCuCqfsw7AiWauCLVcT1aXbeJpbm3ZPWimBqNfIWoIo9ecd0XzwIj+6P512r3gqqYxOL+Sgv36NjIBAgHA7j8XiarHnYVDCsCJrtYGk6Rq16ezHsaMq8917vuJHUGtEoUW8FB0fR8EcrsFWjlkZtmrcVD2CyJ2+BgsBRa17vMKbhJ1xZQcS7x7AqioJlWbXbZQOaa5pGLBbDUTx4YyGEnqredfOOt42ammu2FY97r9BqzQ0rgunY2JreYN41NU+Ztx2tbpc18zZQhQUoTbjeOioOsbBGxHDqtcuqqip8Ph+xWGzvmldWotmx6hDWTctbSdyPDWgevx8tnGrjHK+3gWHF6pwvWl1vG1DwmFVowq6tY0N5KzqaE6ttC5J2qGbeqe9H3Y5iV98TqertWD7KyyMEAgEikQiGYeA4Do7jYBhGg7YgFosl968JVUbi2tayQ754u1Q9Tb7etWygqqPZe+qdsKn1Na+ud7XmgUg5tmpUa74n71bb3wZs/x7N69+P0SpBVZWDqqqYponP56ulY03Nm2J/Y7EYwWCwfZwB0zSZO3cuy5cv55prrmHFihWMHj2aYDBYK50QgqKiIh588EHOP/989t9//1rOQHZ2NsuWLUMIQXl5OYFAoNZGSCeccAInnHACUN/hSOTl98eX6Pl88aUjgUD9gDOJ7zK669iFpUTVhns0rOoZ/mHNU+vvWvVvMG395Stm9XeW7tnzKQQhRYnvsV2jXk3L29/svPekSV1vr89Hdrf4+RI6JnStSWOam2GLqGFh64m61K13wzN5W6d5nbRCUOnPwtI89dK6njf1r3datwyCwdT5J9plY5oDREMmYV8Gjmhq3t5an2aKO76l9TYtbzxKXp37sW7eifO2Zd41/1YAX1pc25bYgkSaYKaOubOsVidyy663t85nqnrXvR9rnE8IbFVPats0jVJr3ljejd2PNeutGh6ys+NaNdcWJMjAi7WrPIUdaqt7LKH1XuotBBWB7Fo2IRVtbX+tBtqGPz1IRkZtTevq2FLNm0urVxN88cUXLF26lG3bthEOh1m+fDlr1qyply4UCnHHHXeQn59PTk4OGzZswHEcZs2axY4dOxg5ciTbtm3j008/5dVXX2X8+PH1dkVUFKVTziHwyiAYriEDOrmHx5RBh9wiHhhHausG0iakpk2CDh133HFkZ2cDcQ8lHK7/cDNNk1GjRuHxePjss89YunRpcgwUoHv37vzhD39g3bp1HHDAAUydOrVTPvhTIUPmuofU1j1ihgxH7BYyHLF7SJuQmlYPE4waNYrZs2ezc+dOvv76axYtWsTkyZPrpevevTvXX399ve9PO+205P8HDx7M4MGDW1uknxweM1y9KYmkrZHaukd8oyJDOgQu4LHCWJqBdAjanri20ibUpdXOwKGHHko4HGbevHmsWLGCa6+9NrmDoaRpyOiD7iG1dQ9T7ljoGvEIeVJbN5DRB1PTameguLiY3Nxczj333OSYfigUIi0trS3K1yXQbTM5EUbStkht3UNzTEzkQ8sNdKmta8S1lTahLq12BlauXMm8efMAqKioYN26dTz44IMMGzas1YXrKjgtWAYiaRpSW/cQirb3RJIW4Sgq0hFwh7i2krq02hmYMGECRx99NBBfPvjMM88k10NKJO2PNKiSnyKy3bqH1DYVrXYGysrKKC0tBcCyLDZs2MDBBx/c2tN2KVRHOk9uEQ+kInGDeIAciRvEbYIMR+wG0t6mptXOwOLFi5kzZw4Qj5J2wAEHMGrUqFYXrCshZ7a6h9TWPSxVbrHrFpbcvtg14qs0JHVpsTPgVMewHz9+PEcddVTye0VRkvsJSJpGIpSmpO2R2rqHYUewdLmiwA0MOx7aVjoEbY+0CalpsTPw448/8thjj9XepIS4M/DLX/6SkSNHtrpwXYV4gBGJG0ht3SOmy6BDbhHTZdAht5A2ITUtdgYGDhzIXXfdlfKYXFbYPLxmlezOdgmprXt4zLAMOuQS8WBZMuiQG0ibkJoWOwOGYdC9e3dM0+STTz7h+++/T27FePbZZzNgwIA2LGbnJio9VdeQ2rqHDEfsHjHDh3QE3EHahNS0esHlZ599xpdffsny5csZOnQoa9eurbfBkKRxPFakvYvQaZHauodhReRGRS7hsaLIjYrcIa6tpC6tdgY2btzIcccdR15eHieddBJHHnkkO3bsaIuydRlkl5V7SG3dQw4RuIccInAPuZogNS12BhI7Dubn52NZFmlpaTz22GN88cUXdO/evS3L2OmR617dQ2rrHnvWwkvaGtlu3UNqm5oWzxmorKzkueee45BDDmHYsGEceOCBLFmyhJNOOqlL7jwokXQ95JurRNJZaLEz4PP52G+//XjjjTcoKytj7NixTJo0ifz8fBRFGonm4MgY767hqFJbt4jv+yDvdTeQ7dY9pLapadVqguOPP55jjz2W7du38+mnn3L//fejaRp/+MMf5GqCZqA7JjHkDFc30G2zes22pK3RbBN0OevdDaS27iFtQmpaPYFQVVWCwSC5ubn4/X6Ki4uJRuVszeZg6nJ/bbeQ2rpHXFv5sHIDqa17SJuQmhb3DNi2zbJly3j//ff58ccf2W+//bj00ksZOXIkPp8M9dgcPGYYU5MN1A2ktu7hsSLYmgxH7AYeMyL3J3AJw4xIm5CCFjsDoVCI2bNnc9hhh/HLX/6Sbt26ocq941tE1Ai0dxE6LVJb95DhiN0jHjJXausGMhxxalrsDKSnp3PbbbehKEqTJgw6jsOqVav4/vvvGT58OAceeGCt45WVlcyaNQvLslBVlWOPPZYePXq0tHg/KWR4TPeIh3WV2rqBx5LhiN1ChiN2D2kTUtPiV3lFUVBVtckrBxzHYdGiRSxYsIBPP/203vHS0lLef/99Bg4cyKBBg/D7u473JiezuIdpyCErtzB1n3QEXMKU4YhdQ9qE1LS4ZyDB9u3byczMJBgMArBr1y4Mw6Bbt2610mmaxs9//nPeeecdNm3alPJcQghCoRCDBw+ut9mREALHcdp+2aJo/6Apuh2NT2pp77JUa1t3J8oW0971AXQrGh8fbO+ydEptY5iap/3jDnVKbaMdQ9tqOp+2HcAmAIg21LYGLXlOttgZSEQgnDVrFkcccQSjRo0CYN68efTp04fx48c3q3DBYJBJkyZRVlbGAw88wAUXXMDEiROTv3vrrbdYvnw5xxxzDMOHD8e2bYQQGIZBJBIhGAxSWVlJWloalZWVBINBIpEIuq4jhMC2bbxeL+FwmGAwSGlxObplV3cZedEcE4GKUBRUx8LSvRhmmJgRiE9CM3wYVhRLNVBFPIKVo2rVy1S8eM0w0URa3Ytum9XrWQWqcLBUA8OOEtP9eM2qeFor3l1l2FFELISjKGjJvCPEDH/tvDUjGT0rnneMmO5LkXcMR9WbkHe83o4SXy+uORaRsMauWBnp6elUVFSQlpZGVVUVHo8H247nres60WiUQCBAZWVlMm0wGCQcDlNuqfhiIRzHTpG3H48Vn8Cj18hbrVfvKkzD30C9U2nuQ7ejteptqzoeK36sZr1T5q15Maw9mscMH54m5713zWNGgPLiIkJqBrFYLNmrZlkWPp+PUChUS/NQKITP58OyrFqa26qXYLiUsL6nbehWtEnXe+/1rop/1q23oqE7JqbuxVOj3qpwCETLsVWjhuYGet28ExrVy9uDYUXr5B2fOFc375juxVPnnkjUW0UQLncIKYHk/Z2wBaFQCL/fTzQaRdO0RjWvKCnHY8ZQUtS77v2oW1FsVUcVAoWa9fZVt58amttmMiaD6thYmpGsd817oma9NccmEC3HrD5ftIYdStRbEQJwcFS9EVvQcN71NbcABUdR0R0rWW8nprFrV2Xy/k7YglT2Nz09ncrKyqTmuh5/xJSWhTEsE91KbQP3XG+1cRuo6qjCAUStentq2uq69tdx6mgejp+/Vr3r2v5I8vrEDH/19a5r+xvTvE7e1fdEbc29VJWblHkCqKpKLBbD7/fXapdN1TyRNhKJkJ6ejsfT/GEQRbTQLXEch//85z/MmjWLvLy8ZE9AZWUlf/rTnxqMM/D222+zadMmbrjhhlrf1yzG119/zdtvv829996Lqqq88MILZGRkcNxxx2EYRr2NkIQQKIrS4GeqNEVhi+fWlGE57e8d+mKVRDwdY9vnswZlMCTDaFDHBI1pvitiM2NNKbbTTpXYU0p8sVCH0FZR4OxBGQzK8DTaLvemeWHYZuaaUuz2b7Z4zRAxI9DuQwWKAucPziQ/3WiRLUh8bq00eenHMjqAScAXCxH1tL+2ABP7BDk819ciW5BIu6kixivryjvEy3jc3gbpCMMwx/UNckhufJi4ubagsbT7tGdAURSmTp1Kr1696Nu3L3l5eQCkpaXVGyJIFD4WixGLxTBNk0gkgtfrZevWreTk5GDbNpZl4fV6WbNmDTk5ObUq5PF4GpxHkEjX0GfKY6qSONBSCdoGIao9/A5QlmoSq0JS6ZigMc0VxQGU9r/XBHt21WtnbQUkb9JG2+VeNbcRHaSdKELE1e0I5VGopW2zbEGNT9Eh2m28t6HDaEt9m1CTpmveUbQV1WVp78IATWizLdW8ubTKGcjNzeWkk05KbmGcGNM//vjj6du3b73fzJw5k88//5xYLMZjjz3GjTfeyIwZMzj//POJxWLMmDEDx3FIS0vjmmuu6TJhjeUuWu5hqVJbt7BVnfa37p2TeLuV2rqBtAmpafUEwg8//JDPPvuM8ePHJ7vvvd7UAR0uvfRSLr74YiDuTBiGwe9///vkWN5dd92F4zgYhtGlYhYYVhRTlzNc3cCwpbZuYdgxLN3bIbqyOxtGYlKx1LbNkTYhNa12BsrLyznrrLM4/PDDG32TTzz861Lzu1THuwIxudTFNeSyTfeIyaWFrhFvt1JbN5A2ITWtdgb69OnD008/zbp16/B4PCiKwlFHHUXPnj3bonxdAm/1igZJ2yMDOrmHDDrkHjLokHt4pE1ISaudgaysLCZNmgSAaZrJGY2SphOV4TFdQ2rrHjIcsXvIcMTuIcMRp6bVzsDIkSMBWL16NSeddBLbt28nOzu71QXrSsQ3JZE9A26QWM8raXviGxXJngE3iK+/lz0DbiBtQmpaPUtv6dKlzJgxg/fee4+KigrmzJnD2rVr26JsXQZLbqnpGnJ3Mvcw5Y6FrhFvt1JbN5A2ITWtdga+/fZbzj77bPr37w9At27dKC0tbe1puxSaY7Z3ETotutTWNTTHosPEy+1kxNut1NYNpE1ITaudgf79+7Nw4UIqKyvZtGkTS5cuTRljQNIw8RCtEjeQ2rpHRwl+1BlJhG2WtD3SJqSm1aqMHz+ezMxMCgsLmTFjBpMnT6Zfv35tUbYuhLzp3UNq6xZyiMBNpLbuIbVNRasnEDqOw5QpUzjnnHP49ttvyczM7DKRA9uK+EYZEjeQ2rqHVr25jKTtUZNDMNKWtjXSJqSm1c7Ae++9R25uLj6fj2eeeQaAW2+9NTmHQLJ35MxW95Dauoele5APK3ewZPRB15ATtlPT6mGC4uJiAoEACxYs4Morr2T8+PFs2bKlLcrWZfBY4fYuQqdFausehhXZsxGUpE0xzAhyAqE7xLWV1KXVzsDIkSP5v//7P1atWsXQoUMpKSlJuWuhpGGiRqC9i9Bpkdq6hww65B4y6JB7yKBDqWn1MMHYsWPp0aMHmqaRlpbGySefLFcTNBMZMtc9pLbuIcMRu4cMR+wecW2lTahLq3sGKioqeOmll7j99tspKSnh66+/pqysrC3K1mWQnqp7SG3dQ25U5B7xzcuktm5gyo3hUtJqZ+DDDz9kxIgRDBo0CNu2cRyH9evXt0XZugyGFW3vInRapLbuEddWjmu7gdTWPaRNSE2rnYFoNEpOTg6apiGEoLy8vMtuRdxSLFXq5RZSW/ewZTe2a0ht3SM+/CKpS6udgaOPPpq33nqLb775hkcffZQtW7YwfPjwtihbl0EVcr22W0ht3UN1HOTbqzuoMoaDa0htU9PqCYShUIirrrqKnTt3YhgGBx54IIGAnMEtkXR+pCMgkXQWWu0MrFixgt69e3PMMcfIyIMtxFG19i5Cp0Vq6x5xbeU97way3bqH1DY1rXYGsrKyePTRR1m0aBF+vx9FUTjppJPq7U8ghCASiVBcXEwwGKwXi0AIgWma7Nq1i7S0NDIyMrqMc6HbMWK6nPXuBlJb99BsE0WuKHAF3TaJ6XJFgRvEtZU2oS6tcgaEEPTt25fLL78cTYt7W4qi4PfXF9qyrKTTcNxxx/HLX/6y1vFYLMa0adMIh8OUlJRw3XXXMWLEiC7hEMRveokbSG3dw5SOgGvEZDhi14jJcMQpabEzIITggw8+4OWXX8bn8/GrX/2KkSNHNvjw1nWdG2+8kTlz5rB169Z6x1etWkVxcTH33XcfCxYs4OWXX+avf/1rl3AGvGZYxtB3Camte3hMGXTILTxmpDowjtS2rZE2ITUtdgZCoRD/+9//uOmmm9i5cycvvfQSd911V4MPb0VRCAQCyR6EumzYsIFBgwah6zoDBw5k+/bt2LaNqsYXPCxatIhYLMaIESPo06cPjuMghEDXdUzTxOPxEI1G8fl8RCIRvF4vsVgsmZ/jOOi6TiwWw+fzEaoIoToWHjOGrenxGaaKgkBBFTa2aqDbMUzNg2HHsDQPmmPiKBqKEIBAKGq9tLodw9YMNMeu3jdboAiBo2potoWt1UxrYqs6jqJh2NFaeWvVebYsbyueFgE18rY0Y8/5bDNlvc2Yl/Ly+jrquo7jOACoqoplWQ1qHjbja3lVx6lX78bytlUd3TZboXn9egtFQXOs2po3kLdmmw1oHq93qzTXPYQrK4h4gliWlWzXtm03qGMqzR1HwxurIlpdBrtmOevk3ZDmQlGgyfVWEErqe8LWdAwzgqM2nHdNjWpr7mCrWgN56yjCbjDvupqrCGJhnYjhJO/vcDiM3+8nEong8XjqaW4YRjJtQvNIqArdjoFTP+8G78cmaB63BXG7qAqx93orCraq4zEjtXRsNG/HasQOJa53w5rbasM2UFgG5eXl9dplwv7GYrG4fpFIg5pXhaJodgw1hR1y1D31bpINbHK94/a3ruaCuE3YW70b01woGqrYm+Y1r3fqthGrglDI2atNbYr9TWju8/nQ9eY/2lvsDEQiEXJzcxk5ciQDBgxg3rx5WJaFpmmoqtrsN3rHcZINR1EUhKg9UzkrK4tevXqRlpaWzEMIgaqq6Lpe69MwjORnohyqqqJpWvKYrhugxKofGCqOCtTYdkVU35BCUas/FRxFw1FUFCWeSlSvzKyZ1kl8KlQbXRCKqD4W//2etPGHlW5HiRl7ulyFoiTPs/e81RR5x38jAGrknUjrKCpKnXoDOIpSrZtaT9e6mic0rau5rutojsBRVBxVaaTedfKuU5eG671Ho73WGwXdNol49pa3Uus8tfPWkm2oWXnX0VygoulGreE0pVrvuvrV1Lxm+wVQLKVGHfaUUyhqvbydvV3vRuutNlpvW9XxxSqJeoIp807ZLpuat6pSfbn3orlWbfBB1erf+4nPmpqntgXx32p6/LxCrZ93gxohQKHRe8yuVW/RpHp77SgRT7BxO1QzbyW15vZeNd/zWydFvW1VB0XFMBq2BQmNG9M8oW39ttHw9W6S5g3Uu6b9tZXamutOjIiSttd67y1vHG2vtt9u1ParqJqOruu12mbd51lT7W9dzZtLi50BRVFYsWIFv/vd77Btm9WrV/O73/0OVVW55pprGDFixF7PIYTAtm00TSM/P5/FixfjOA7btm0jLy+vVi/C4MGDOfTQQxs9XyLYUcIrShX8KPGd1+/DUSJYev2eCifxqcbPY1XPPk38XTut3kDa+uWrm8ZSNRCCiCcNWzVAUVqYt1YnbRPzToGm6/j98S60xnRMkEpzD3Ev2BYN1aXh2bxNq3dDaeskFIKwJy3umFSPEzZU7zbPO0Uaj8+HYRiNtsu9aV4aMjF1L0LspZxNvN6p69K0ekcRmJoX6hifRJq67bIt8675twB0jwePZ0+8+YSOTbEFyTResNVorQWTzbof26reQhA1gvGu7OqHort5N24DFU1LzgNrzBY0prk3puCoUUQz866dtun1bvB+FIKwJz3+cE/x9tyyvJtvCxLl1b1evN7aQxZNtQXNTbs3WuwMZGZm8sADD2BZVr1jqTYqEkLwzjvvMHv2bMrKyujevTvnnnsu06ZN47zzzmP//ffnzTff5OGHH2bLli1cdtllXWK+AMRnvJtyopsrSG3dI9E9Kse12554u5XauoFum9ImpKDFzoCu6wwePLhZvznggAPIz88HIBAIoOs6559/Pj169MDn8/HnP/+ZTZs20a1bN3r27NllnIFUXqekbZDauoejyPXabiFjOLiHjDOQmn1mKRVFYeDAgfW+r/ldIBBo0vBC50NGcnMPqa3kp4hst+4htU1Fq/cmkLQe1XH2nkjSIqS27qHIfR9cQxVy3we3UIW0CamQzkAHQO6i5R5SW/ewVbmznltYUlvXkDuZpkY6Ax0Aub+2exi21NYtDDtWYzGupC2Jt1uprRtIm5Aa6Qx0AGKGjJPtFjIGuXvEZDhi14i3W6mtG0ibkBrpDHQAvGZVexeh0yK1dQ+PFZY9Ay7hMcPIngF3kDYhNdIZ6ABEjUB7F6HTIrV1j5julz0DLhHvLZTauoG0CamRzkAHIP4WIHEDjyW1dQuPFZE9Ay4Rb7dSWzeQNiE10hnoAFi6Z++JJC1C7k7mHmb1pi+StifebqW2biBtQmqkM9AB0Jz6IZ0lbYPmmO1dhE5LvN3Kt1c3UKW2rqFKm5AS6Qx0AOTblXtIbd1DdJFw4e2DguwZcAv52EuFVKUDkNiGVdL2SG3dQygq8oHlDrLduocjndiUyBbXAdDlMIFryCEY99Bs2ZXtFvHhLamtG0ibkBrpDHQATF1OaHELS2rrGpbcYtc14u1WausG0iakRjoDHQC5tNA9DDPS3kXotBhyaaFrxNut1NYNpE1IjXQGOgAyCIZ7yFDP7iGDDrmHDDrkHtImpEY6Ax0AGR7TPTxSW9eQ4YjdQ4Yjdg/ZE5sa6Qx0AKSn6h6m1NY15EZF7mEaPmTPgDvEtZXURToDHQC5hbF7SG3dI66tfHt1A11q6xq6tAkp0fdlZkIIhBAo1es8lRrrPRPHEiiKUut4Z8ZS9+ll6FJYqtHeRei02JqBfHt1B6mte9jSJqRknz2FHMdhzpw5fPHFF+Tm5nL55ZeTmZmZPP7NN9/w7LPPkpGRQWZmJtdddx1paWn7qnjtiiqc9i5Cp0UVdnsXodOiOg7xt1f50Gpr4tpK3EDahNTss2GCjRs38r///Y/rr7+ejIwMXn755Vo9AcXFxQwePJjf//73XHfddQQCXWmGvewOdA+prXtIbd1DIPWV7Ev2Wc/A999/z6hRo+jVqxfHHHMMjzzyCI7joGkaEB8W+OabbwiHwxx++OFMnDix1u/LysooLCwkPT0dr7d20AghBKqq4jhOvc/EUEPdNLZloyBQHAcUBUT1G44CCIFQFJQUn3vSkvx/o2nZ+/mEoqEIJ57/Ps67Zr2V6qEay7Ia1LEpmtu2gyIcFKfhvFtWzubVO66tCtXXeV/mneqYY9s4jlPLCW5K262ZVgiB6tg4NL8ubV1vR1FRhbPnkVXjd/vyeiuAcByc6n/NtQXJT9uO34fNud4CoO3r7SgaqnBwYJ/nXfd81LEJzbEFibR2DW1bfY+18n4UihJfBdMBbL9j29i23SJb0FBaTdNaNMS+z5yByspKgsEgiqLg8/mIRCK1jOJBBx3EwIEDsSyLadOm0a1bNw455JDk8a+++oqioiKOOOIIhg4dim3bCCHQdZ1oNEogECAUChEMBqmqqsLv9xONRpPOhm3beL1ewuEwgUCAyvIKVNvCZ0awVA+aYyUbiurYWJoHw4oQM/x4zDCm7kO3oziqUf3gFjiKhu6YmJoXw4pg6n4MK4ype9FtE0fVQAhU4WBrBroVw9QTaX0YVhRLM/BFKwDq5R1PU/1pR7FUI9nFVT/vRNrm5F273ppjE4t6KXNsgsFg8pqFw2E8Hk8tzWOxGH6/v57mkUiEKkvBY0XiDb2hvHUPmr13zfde7/qaK0KgCAdb1fFHy7FVowl5GxhWtJmaN5S3wFZ1dLtGvQ0/VRVlhD3pxGKx5A1rWVayXabS3LIsFEVB0zRisRiO4sEbC4Hmq87bh27Hate7Uc3NeNz7evX2J89Xt95C0dBS1NuwopiOha0ZDddb92NYkWTeQlHbXHNVCKIhlbAeb391bYHP52ua5pUVGHYUHBuIO5KqY2LVyzthC/RG6l1X87gdUkVTNFfwmFVojlVHx/rXuzE7ZOneetc7Zduok7dQ1FrX2zE9lJbG7WYkEsEwjKRTaxhGSs3r2t9QZQTdjqFZsWptUte7vg2srZHdqP2to3k9GxjXPBApx1Z1DDvW5LybbftrXO/G7G805FDpt1FVFdM08fl8VFVVEQwGk3qmsr81n3lpaWmEQqGk5mlpaRhG8+dF7DNnIDs7m+XLlyOEoLy8nPT09FqeelZWFtnZ2QghOOSQQ/jxxx9rOQMnnngiJ5xwAkA9rycxt8Dv99f6TDXUkPguUzGwd5YSVT0ApNrUMhG2Mqx5av1dExN/rWPxEK1g6fWXr5jV3+1J6wUhCPmV+B7bNepVK02T8058NjFv6tfb6/OT3S1+zOeL/yahZypSaW6FLaKGja3vJe8Ura9NNReCSn82luZpYt6py9mivNmzhCmRNq1bBsGgh2AwWC9tol3uTfNoyCTsy8ARNfNOUc4GNa9fzj31bvh8pKi3WW3QqHM/1q134ryN591yzRXAl15b27rtsimaBzN1YjvL6nTON5R3inLWq3cLNa92LhLaNinvBsqZKu+G2kZt9pxP9XjJyYlrlcqmNqR5zbQZig9zVzmxJrU1UtalOTawwXoLQUUgYRMaXmLYGs2bY3/9GUEyM2vf6wnd6upZk7rPvEQbbs3w+j6bM3DggQeyevVqvv76a9544w2OPvpootEob731FrFYjG+//ZZvvvmGhQsX8vXXXzNy5Mh65+isKwy8MgiGa8iATu4hgw65hww65B7SJqRmn/UM9OjRg5tuuonPP/+cMWPGcPzxx2NZFqFQCABN01iwYAFCCG644QZGjRq1r4rW7shwxO4htXUPGY7YPWQ4YveQNiE1+8wZUBSFUaNG1XrIe71eLrroIgAOOOAADjjggH1VnA6FxwzHuwQlbY7U1j08VgRbM6RD4AIeK4wlYw24QlxbaRPqIiMQdgDkFsbuIbV1D1PzSEfAJUxNbmHsFnFtJXWRzkAHQLdTTV+UtAVSW/fQHRM5ru0OUlv3kDYhNdIZ6AA4qrwMbiG1dY/E8ilJ2xPXVvYMuIGjynabCmkpJRKJRCLp4khnoAOgOjJWtlvIGO/uIWO8u0dcWzlM4AbS3qZGOgMdADmz1T3iM7IlbmCpHmRXtjvEd9uU2rqBtAmpkc5AB8CQ+2u7htTWPQw7IoMOuYRhR5E9A+4gbUJqpDPQAYgHGJG4gdTWPWTQIfeI6TLokFtIm5Aa6Qx0AGR4TPeQ2rqHx5ThiN1ChiN2D2kTUiOdgQ5AVHqqriG1dY+YIXsG3EKGI3YPaRNSI52BDoDHirR3ETotUlv3MCw5Z8At4u1WausGHjlnICXSGegAyNUE7iG1dQ9bhiN2DbkvgXvI1QSpkc5AB0Cue3UPqa17qI6FfHt1B9lu3UNqmxrpDEgkkhYi31zdQ2or2bdIZ6AD4CjyMriF1NY94vs+yIeWG8g9NdxD7qmRGtniOgC6Y7V3ETotUlv30Gy5s55bSG3dQ3PkroWpkM5AB8DU5f7abiG1dY+4trJnwA0sqa1rWNImpEQ6Ax2AeIARiRtIbd3DI5cWuoZhyqWFbhHXVlIX6Qx0AKJGoL2L0GmR2rqHDEfsHjLokHvIcMSp2WfOgBCCbdu28b///Y9FixZhWbXHch3HYeXKlbz55pusWbMGIbqOV6yHy9u7CJ0UgR6R2rqBEAItUgFCbhHd1gio1rbr2MB9hQD0SAWy16U++8wZKCkp4e6778ZxHF577TXmzZuXfOALIVi5ciWPP/44hmEwbdo01q9fv6+K1q7YlsWCj2bjSKPa5limycIP3+tSjuW+ZPHHHxCLyGEYN1g8933MmOzObnsECz96DysWa++CdDj0fZXRsmXLyM/PZ8qUKQwePJgZM2Zw3HHHoSjxrrCPPvqIU045hZNPPpmKigo++eQTBg8enPy9EALHcZLp24r2f1AIqirKQbR/WRLatlU52rs+CAhVlneIsnQ6bYFwZQXCEe1els6obVUH0TZBp9FWQFVlOUJ0EG1dsvsteU7uM2egsLCQnj17oigK2dnZlJaW4jgOavV62p07d3LUUUehKAq9evVi/vz5tX7//PPP89FHH+H1etH12sUWQqAoSr3PVCSORSyHH8vNBi+EID5iV/ez0bSKgiJEyrQNnc8RDsUb1rDomWl7jFoyjYJC6vM1p5zNOV9huod0Q9mrng1pLoQgYgvWlccQooU6NidtI5o7jkPxxjUsfGZaM/J2R3MUhZ1pOume1Gucm9KG49rCuvIojmhK3nXK0MK61Etbrfmu9av5pnw3mm7UT9Oc87WB5jszPKQZaotsQeIzZDqsr4jV60Fu3vXeu+YN/abm90UbVvNNqBRF0/fazvd2vtRpm675lqDBbK/abFtQk0rTYUO1tq61yyZqvnv9Dyx5vgJVbeBehH2iuQC2BnXe8cWfZ43Z1OZoPmzYMC644IJmOwT7zBnw+XyUlJQghMA0TQyjdnxor9dLLBaLG7xIBJ/Plzx26qmncsQRR7R5r4BEIpFIJJ2JQKBlk6b3mTMwfPhw5s2bR0VFBUuWLGG//fYDYMuWLfTu3ZsDDjiAhQsXMmbMGBYtWsQRRxyR/G1mZiaZmZn7qqgSiUQikXQp9tkEwqFDh3LYYYdx1113sWzZMi688EIqKyv55z//SSQS4YQTTiAWi3HHHXeQnp7OUUcdta+K1uHoEGNZnZQOM1bYCZHauofUVuI2itiHLUwIQSwWQ9M0NC0+XhOLxfB44tvMOo6DaZp4PJ7kXIKuRjgcZvfu3fTp0wdo2UQQSWosy2LVqlWMGDGi3rwTSeuwLItvv/2WgQMH0r17d9lu2xDTNHnjjTc44ogjyM/Pl9q2IbZtU1hYiM/n6/Ltdp8+cRVFSU4AVBQl+Xfi/5qm4fP5uqwjIIRg1qxZXHvttSxfvjz5naT1WJbF66+/zmeffSbfstoYIQRvv/02n376KZqmJfWVGrce0zSZOXMm77//Pm+88YbUtA2xLIsZM2Zw33338dvf/paCgoIurW/XfOp2YLKzsznssMN46KGHWL58OZFIBMeRMQhagxCCd955h9WrV3PppZfy3Xff8dJLL/Hjjz926Zu/rYhEIixevJhLLrmEWbNm8ec//5mPPvoIx3Gkvq3Atm1efvllYrEYf/vb3/juu+8oLCyUmrYBidg2Gzdu5IEHHuDQQw/ls88+Y9OmTV223UpnoIMxePBgsrKy+OUvf8l9993HrbfemlyFIWk5/fr1o6CggOeff57Zs2cTjUa58847Wbt2rdS2lSiKQiQSYc6cOYRCIc455xzefPNNPv/88/Yu2k+eUaNGcdlll9GrVy/GjRvHe++9195F6jSYpklhYSFffPEFK1asoKCggL/+9a8sWbKkvYvWLkhnoJ0xTZOtW7eye/duAHJzcykuLqZnz554PB42btzI9u3b27mUP00cx6GwsJCCggIOOuggfvGLX1BcXMzvfvc7LrvsMk455RT5wGohjuNQUFBAQUEBhmFwyCGH8NRTT3HooYcyZswYLr30Ur766qv2LuZPEtu22bFjB0VFRYwZMyY5p+rUU0/l888/p6ysTDqwLSSh7a5duzjggAM47bTT+PTTTznllFO48cYbOf/88/nkk0/au5jtgpxF1Y5EIhGefPJJNm/eTFFREX/4wx8YPnw4uq7zt7/9jWuuuQZd16msrGzvov7ksG2bN998ky+//JLdu3dz/vnnM3nyZEaPHo1hGMRiMbZu3crhhx/e3kX9yWHbNq+99hoLFy5k9+7dXHzxxZx11lls2bKFf/7zn1x55ZV89dVXjB49ur2L+pPDsixefvllvvnmG4qKirjiiis45phjUBSF3r17J5don3nmme1d1J8clmUxc+ZMli9fzq5du7jmmms4+eST8Xg8LF68mAMOOIBly5Z1WZsgnYF2QgjBRx99RCAQ4L777mPevHnMmjWLESNGcM455xAKhRgzZkwyfVee5dpchBCsXr2a5cuXc9ddd7F9+3YeffRRjj32WDweDxUVFTz55JN07969VjwLyd4RQrBixQrWrFnDPffcw8aNG/n3v//NxIkTufnmm5k/fz7z589n1KhRtcKNS/aOEIJvv/2WTZs2ce+997J27VqeffZZxo8fn5x0PXXqVFatWtXeRf3JIYRg8eLFFBYWcs8997By5UpeeeUVxo0bx7hx41i6dCkPPPAAxx9/PBMmTOiS7VY6A/uYmt17PXv2ZNy4cRiGwfDhw5Mz3QcNGpRcUdEVG2VrSOjr8/m48MILCQaD9O3bF1VVMU0TTdMwDIOzzjqL/Px8ucSwGSS09fv9XHDBBfj9fvLz8xFCYFkWHo+HCRMmMHHiREC23eaQ0DYtLY0LLrgAn89H//79sSwL27aTK64GDx7M4MGDpbZNpKa9zcjI4Pzzz8fn8zFw4ECi0Si2bRMIBLj55ptxHAfDMLqstnLOwD4mGo3y2Wef8eGHHzJ48GCys7OTSyxt26a8vJx///vfFBUVtXdRf3LYts3SpUuZNWsWXq83GeVS13U0TSMSifDyyy+zevVqBg4cKB2BZmBZFkuWLOHdd98lLS2NIUOGAHFtVVUlEonwwgsvJN9au6pBbQmWZbFo0SJmz55NZmYmAwcOBEg+mMLhMDNmzGDNmjWA1LY5WJbFggULeO+998jJySE/Px8gOQ8jHA7zzDPPsHHjxi7tCIB0BvYpjuMwY8YMvv32W1asWMEf//hH1qxZE98bXtOoqKjgiSeeYNCgQeTk5HTphtlchBB8/PHHvP322+zcuZO//OUvfPLJJ8kNPGzb5sUXX6SyspIRI0a0d3F/Uggh+PDDD5k9ezY7duzgtttu44svvkhqm1ivHYvF2G+//WS7bQZCCGbPns2HH37Itm3b+NOf/pSceJnozXr22WeTvQJS26aTiH/x8ccfs3nzZv74xz+yaNEiIK5tLBZj+vTp+P1+BgwY0OW1la9G+xDTNPn++++544476N69O1988QX3338/99xzD36/n23btnHKKadw4okndtnAS61h4cKFTJkyhQMPPJBjjjmGe++9l7S0NA466CBisRiKonD55Zd3+TeAlrBw4ULOPvtsRo4cydFHH819991HWloa+++/P5FIBK/Xy6WXXpp845I0DSEEixYt4uKLL2a//fbjqKOO4sEHHyQ9PZ399tuPyspK0tPTueiii+pt7iZpnMQ8gauuuoqBAwdy5JFH8vDDD3PrrbcycOBAysvLycnJ4bzzzpO9hOzjcMRdFSFEMnDQtGnTyM/P59xzzwXgrbfeYsOGDdx0003s2LGD3r17S0egGSS0VVWVd955h2+//Zbf//73eDweli9fzvTp03nwwQfZvXs3OTk50hFoBjW1feONN/jxxx+5+eabMQyDpUuXMnPmTO6//3527dpFXl6efFg1g5ravvTSS+zYsYMbb7wRXddZuHAhb7zxBvfeey87d+6U2jaTmtrOmDGDsrIyrrvuOjRNY/78+bz77rvcfffdFBQU0LNnT+kIVCOfOi4TDod5/vnn+cMf/sB7773HJZdcwty5c5k1axa2bXPQQQclYwz06dNHOgLNwLZt5syZw5/+9CemT5/O0UcfTTQa5cknnyQcDjN48GAgvv9Fr1698Hg80hFoIpZlMXv2bG699VaeffZZjj32WEpLS5k+fTqRSIShQ4di2zamadK7d2/5sGoGpmnyzjvv8Mc//pHnn3+eE088kR07dvDss88SjUYZNmwYsVgMy7Kkts3ENE3eeust/vjHP/Liiy9y6qmnsmHDBp5//nlisRgjR44kHA5j2zZ9+vSRjkANZM+AiziOw/Tp0/F4PBxyyCE88sgj3H777WiaxqOPPpqM437yyScn1xJLmoYQgnnz5rFw4UKmTp3KU089xYknnshhhx3Gv/71L7Zt20ZmZiaDBw/m0ksvlU5WMxBCMGfOHJYvX84ZZ5zBv/71L8466ywOOOAAnnjiCQoLC0lPT2fEiBFccMEFUttmIITg3XffZc2aNZxyyin885//5MILL2S//fbj8ccfp7i4mGAwyOjRoznnnHOkts1ACMFbb73Fli1bmDx5Mv/4xz+44oor6N+/P48//jjl5eX4fD4OOeQQzjrrLGlv6yCdARepqqri6aef5uqrr8br9fL4448zevRoJkyYQDQaZdOmTQSDQTk00AIcx+Hpp5/m9NNPp0ePHnz88cf88MMP/PKXv8S2bbZu3YplWQwYMABN0+SN3wxs2+app55i6tSp5OTkMGfOHLZu3covfvELbNtmy5YtOI5D//795ZtVM7FtmyeffJLzzjuPrKws3nnnHUpLS7nkkkuwLIstW7YA0L9//+TOrpKmYVkW//73v7n44ovJzMzkjTfewLIszjvvPCzLYvPmzaiqSn5+vtQ2BfJOdhG/38+1116b7Obr1q0bkUiEiooKVqxYwdixY+VDqoUoisJll12W1DYjI4NYLIZpmixcuJDDDjssOZlNatw8VFXliiuuSGqbmZnJunXrktoefvjhsuu6haiqypVXXlnLJhQWFhKLxVi0aBFjx46VDlYL0TSNq6++upa227ZtIxqNsnjxYsaNGyedgEaQr6MuoihKrXFqwzAoLi7miSeeoLS0NBlIRD6smk9dbXVdJxwO89JLL7FixQpUVZXatpBU2lZVVfH888+zevVqqW0rSKVtKBTiueeeY926dVLbVpBK28rKSv7v//6PTZs2SXu7F6QzsA/RdZ1XXnmFAw44gMmTJ8tG2Ybous6nn35KOBzm8ssvl29XbYiu68ybNw8hBJdcconUtg0xDIM5c+bg8Xi48MIL5ZtrG2IYBu+++y4ZGRmcd955Utu9IOcM7EPWrVvHxo0b+dnPfibnCLQxpaWlzJs3j1NPPVUuH2xjiouL+eyzz5KbukjajqKiIubPn8/JJ58sh17amMLCQhYuXMhJJ50kHdgmIJ2BfUhCavmgantqNmOpb9si2617SG3dQ2rbPKQzIJFIJBJJF0f2VUskEolE0sWRzoBEIqmHZVkUFRUlw2jbtl3rb4lE0rmQzoBEIqmHaZo8+OCDrFy5Mrkj5PTp05GjihJJ50TOGZBIJPUQQvDtt9/yzDPP8Jvf/Ib777+fm266ieXLl7Nz507GjRvHwQcfzJYtW/jwww+JxWIcc8wxjBgxgmXLllFQUMD27duZOHFico8IiUTScZE9AxKJpB6KojB69GiGDRvGb37zG0466SRmzZqFaZoceeSRPP/882zatAkhBPvvvz9Dhw7ln//8J+Xl5axcuZLXX3+dQw89lJycnPauikQiaQJy8aVEIkmJqqqcccYZfPHFFxx55JE888wzDB8+nFWrVrF79242b96M4zj873//IxAIsHHjRoqKigCYNGkSo0ePlsu6JJKfCNIZkEgkDWIYBj6fD4/HQ1ZWFldccQV5eXk4joPf7+dPf/oT11xzDf379+f6669HCFEvLKxEIun4SGdAIpE0iqqqeL1ezjjjDJ566imGDRtGaWkpF154IQMHDuTFF18kMzOTXbt2Acj47xLJTxA5gVAikTRILBZj48aNDBkyBICtW7eya9f/b98OjSAKgSAKbqFxKAT5B0UIXyIRXBxX0x3FEzNfjTFqrVX33tp7V++93ns156xzTrXW7AXgj4gBAAjnTQAA4cQAAIQTAwAQTgwAQDgxAADhxAAAhBMDABBODABAODEAAOHEAACEEwMAEE4MAEA4MQAA4cQAAIQTAwAQ7gftBoxMy6tY7wAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -470,21 +468,23 @@
      "output_type": "stream",
      "text": [
       "assistant:\n",
-      "The revised bar chart shows:\n",
+      "Here are visuals that help explain the discounted cash flow (DCF) valuation to someone new to finance and investing:\n",
+      "\n",
+      "1. **Future Cash Generation:** This bar chart shows the projected money the company is expected to generate each year in the future, also known as Free Cash Flow (FCF). As you move to the right, you can see the growth in cash generation each year.\n",
+      "\n",
+      "2. **Present Value of Future Cash:** The second bar chart adjusts the future cash flows to their value in today's terms, accounting for the concept that money in the future is worth less than money today. These bars appear shorter because of the discount applied.\n",
       "\n",
-      "- The blue bars represent the projected free cash flow (FCF) for each year specified in the dataset, without discounting.\n",
-      "- The green bars represent the present value of those cash flows after discounting.\n",
-      "- The terminal value is also plotted as a projected FCF (blue) and its discounted present value (green) in the final bars.\n",
+      "3. **Total Company Value:** The pie chart represents the total value of the company based on adding up all the present values of future cash flows. It shows what the company is worth today, based on the money it is expected to generate in the future.\n",
       "\n",
-      "This visualization more accurately depicts how the present value of each year's free cash flow compares to the non-discounted projected amounts and the overall significance of the terminal value in the DCF valuation calculation.\n",
+      "The DCF valuation calculated from the provided projections is around $200.32 billion. \n",
       "\n",
-      "I hope this chart meets your expectations. If there is anything else I can assist you with, please let me know.\n",
+      "To a new investor, this figure highlights what the company is worth in today's dollars, considering all the future cash that the company could potentially generate until the year 2028. The investor can use this estimate to help decide whether the company is a good investment at its current market price. If the company's market price is less than the DCF valuation, it might be undervalued, meaning the investor could potentially get a good deal. If it's more, the company might be overvalued. However, it's worth noting that this is a simplified model and actual investment decisions should take into account much more detailed analyses and risks.\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "analyst_assistant(\"Visualize this information\")"
+    "analyst_assistant(\"Summarize and Visualize this information to someone new to finance and investing.\")"
    ]
   },
   {
diff --git a/sandbox/agents/assistants-api/azure-openai/function-calling-ea.ipynb b/sandbox/agents/assistants-api/azure-openai/function-calling-ea.ipynb
index c3bdd2f7..0dc7457e 100644
--- a/sandbox/agents/assistants-api/azure-openai/function-calling-ea.ipynb
+++ b/sandbox/agents/assistants-api/azure-openai/function-calling-ea.ipynb
@@ -34,107 +34,89 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import io\n",
     "import os\n",
-    "from datetime import datetime\n",
+    "import html\n",
     "from pathlib import Path\n",
-    "import matplotlib.pyplot as plt\n",
-    "from typing import Iterable\n",
     "from dotenv import load_dotenv\n",
     "from openai import AzureOpenAI\n",
-    "from openai.types import FileObject\n",
-    "from openai.types.beta.threads.message_content_image_file import MessageContentImageFile\n",
-    "from openai.types.beta.threads.message_content_text import MessageContentText\n",
-    "from openai.types.beta.threads.messages import MessageFile"
+    "from tenacity import RetryError\n",
+    "\n",
+    "from azure_ai_util import AzureAIUtils, NotCompletedException"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Environment Configuration\n",
-    "This cell is crucial for setting up the environment configuration necessary for the notebook to interact with Azure OpenAI. \n",
+    "### Initialize Azure OpenAI Client\n",
+    "This cell crucial for establishing communication with Azure OpenAI services. \n",
     "\n",
-    "- **Requirement**: Ensure that a `.env` file exists in the same directory as this notebook. This file should contain the necessary API credentials and configuration details, which you can obtain from https://ai.azure.com \n",
-    "- **Keys in .env File**: The `.env` file must include the following keys:\n",
-    "  - `OPENAI_ENDPOINT`: The endpoint URL for the Azure OpenAI service.\n",
-    "  - `OPENAI_API_KEY`: Your API key for accessing Azure OpenAI services.\n",
-    "  - `OPENAI_MODEL_NAME`: The name of the specific Azure OpenAI model you intend to use.\n"
+    "- **Requirement**: Ensure that a `.env` file exists in the same directory as this notebook. This file should contain the necessary API credentials and configuration details, which you can obtain from https://ai.azure.com "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "load_dotenv(\".env\")\n",
-    "api_endpoint = os.getenv(\"OPENAI_ENDPOINT\")\n",
-    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "api_deployment_name = os.getenv(\"OPENAI_MODEL_NAME\")\n",
-    "api_version = \"2024-02-15-preview\""
+    "client = AzureOpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"), \n",
+    "                     azure_endpoint=os.getenv(\"OPENAI_ENDPOINT\"),\n",
+    "                     api_version=\"2024-02-15-preview\")\n",
+    "\n",
+    "utils = AzureAIUtils(client)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Initializing Azure OpenAI Client\n",
+    "### Create the assistant with tools and files\n",
     "\n",
-    "Initializes `AzureOpenAI` client with necessary credentials and configurations:\n",
-    "- `api_key`: API key for authentication.\n",
-    "- `api_version`: Targeted API version, set to `\"2024-02-15-preview\"`.\n",
-    "- `azure_endpoint`: Endpoint URL for Azure OpenAI services.\n",
     "\n",
-    "This step is crucial for establishing communication with Azure OpenAI services.\n"
+    "The `create_assistant` function creates an assistant with tools and files. The function takes the following parameters:\n",
+    "- `name`: The name of the assistant.\n",
+    "- `instructions`: The system message (or meta prompt) that gives the assistant a persona and context.\n",
+    "- `tools`: A list of tools that the assistant can use to perform tasks. Currently, these are `code_intrepreter` and `retriever`.\n",
+    "- `functions`: Custom functions that the assistant can use to perform tasks. Similar to function calling feature.\n",
+    "- `model`: The name of the model to use for the assistant."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "client = AzureOpenAI(api_key=api_key, \n",
-    "                     api_version=api_version, \n",
-    "                     azure_endpoint=api_endpoint)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create the assistant with tools and files\n",
-    "\n",
-    "![How Assistants work](./images/assistants.png)\n",
+    "DATA_COLLECTION_LOGIC_APPS_URI = os.getenv(\"DATA_COLLECTION_LOGIC_APPS_URI\")\n",
     "\n",
+    "def get_proprietary_data(ticker: str, data_type: str, email: str) -> None:\n",
+    "    json_payload = {\"ticker\": ticker, \"data_type\": data_type, \"email\": email}\n",
+    "    headers = {\"Content-Type\": \"application/json\"}\n",
+    "    response = requests.post(DATA_COLLECTION_LOGIC_APPS_URI, json=json_payload, headers=headers)\n",
+    "    if response.status_code == 202:\n",
+    "        print(\"Email sent to: \" + json_payload[\"to\"])\n",
     "\n",
-    "The `create_assistant` function creates an assistant with tools and files. The function takes the following parameters:\n",
-    "- `name`: The name of the assistant.\n",
-    "- `instructions`: The system message (or meta prompt) that gives the assistant a persona and context.\n",
-    "- `tools`: A list of tools that the assistant can use to perform tasks. Currently, these are `code_intrepreter` and `retriever`.\n",
-    "- `functions`: Custom functions that the assistant can use to perform tasks. Similar to function calling feature.\n",
-    "- `model`: The name of the model to use for the assistant."
+    "def get_current_share_price(ticker: str) -> float:\n",
+    "    stock = yf.Ticker(ticker)\n",
+    "    return stock.history(period=\"1d\")[\"Close\"].iloc[-1]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Fetch the files under the datasets directory\n",
     "DATASETS = \"datasets/\"\n",
     "\n",
-    "def upload_file(client: AzureOpenAI, path: Path) -> FileObject:\n",
-    "    with path.open(\"rb\") as f:\n",
-    "        return client.files.create(file=f, purpose=\"assistants\")\n",
-    "\n",
-    "assistant_files = [upload_file(client, Path(DATASETS) / file) for file in os.listdir(DATASETS)]\n",
+    "assistant_files = [utils.upload_file(Path(DATASETS) / file) for file in os.listdir(DATASETS)]\n",
     "file_ids = [file.id for file in assistant_files]"
    ]
   },
@@ -147,129 +129,137 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "assistant = client.beta.assistants.create(\n",
-    "    name=\"Equity Analyst\",\n",
-    "    instructions=(\"You are an equity analyst that performs analysis on the given datasets. \"\n",
-    "                  \"Use the provided file only.\"),\n",
-    "    tools=[{\"type\": \"code_interpreter\"}],\n",
-    "    file_ids=file_ids,\n",
-    "    model=api_deployment_name\n",
-    ")"
+    "tools_list = [\n",
+    "    {\"type\": \"code_interpreter\"},\n",
+    "    {\n",
+    "        \"type\": \"function\",\n",
+    "        \"function\": {\n",
+    "            \"name\": \"get_proprietary_data\",\n",
+    "            \"description\": \"Gets proprietary data from a Logic Apps workflow and notifies the user via email.\",\n",
+    "            \"parameters\": {\n",
+    "                \"type\": \"object\",\n",
+    "                \"properties\": {\n",
+    "                    \"ticker\": {\"type\": \"string\", \"description\": \"The stock ticker symbol.\"},\n",
+    "                    \"data_type\": {\"type\": \"string\", \"description\": \"The type of data to retrieve. ARPU, EPS, Margin, etc.\"},\n",
+    "                    \"email\": {\"type\": \"string\", \"description\": \"The email address to notify.\"}\n",
+    "                },\n",
+    "                \"required\": [\"to\", \"content\"],\n",
+    "            },\n",
+    "        },\n",
+    "    },\n",
+    "    {\n",
+    "        \"type\": \"function\",\n",
+    "        \"function\": {\n",
+    "            \"name\": \"get_current_share_price\",\n",
+    "            \"description\": \"Get the current share price of a stock or symbol.\",\n",
+    "            \"parameters\": {\n",
+    "                \"type\": \"object\",\n",
+    "                \"properties\": {\"ticker\": {\"type\": \"string\", \"description\": \"The ticker of the stock\"}},\n",
+    "                \"required\": [\"ticker\"],\n",
+    "            },\n",
+    "        },\n",
+    "    }\n",
+    "]"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "Create a thread, which represents a conversation. It is recommended to create one thread per user. "
+    "def call_functions(client: AzureOpenAI, thread: Thread, run: Run) -> None:\n",
+    "    print(\"Function Calling\")\n",
+    "    required_actions = run.required_action.submit_tool_outputs.model_dump()\n",
+    "    print(required_actions)\n",
+    "    tool_outputs = []\n",
+    "    import json\n",
+    "\n",
+    "    for action in required_actions[\"tool_calls\"]:\n",
+    "        func_name = action[\"function\"][\"name\"]\n",
+    "        arguments = json.loads(action[\"function\"][\"arguments\"])\n",
+    "\n",
+    "        if func_name == \"get_stock_price\":\n",
+    "            output = get_current_share_price(ticker=arguments[\"ticker\"])\n",
+    "            tool_outputs.append({\"tool_call_id\": action[\"id\"], \"output\": output})\n",
+    "        elif func_name == \"send_email\":\n",
+    "            print(\"Fetching proprietary data\")\n",
+    "            ticker = arguments[\"ticker\"]\n",
+    "            data_type = arguments[\"data_type\"]\n",
+    "            email = arguments[\"email\"]\n",
+    "            get_proprietary_data(ticker, data_type, email)\n",
+    "\n",
+    "            tool_outputs.append({\"tool_call_id\": action[\"id\"], \"output\": \"Fetched proprietary data and notified user.\"})\n",
+    "        else:\n",
+    "            raise ValueError(f\"Unknown function: {func_name}\")\n",
+    "\n",
+    "    print(\"Sending tool outputs to the thread.\")\n",
+    "    client.beta.threads.runs.submit_tool_outputs(thread_id=thread.id, run_id=run.id, tool_outputs=tool_outputs)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "thread = client.beta.threads.create()"
+    "assistant = client.beta.assistants.create(\n",
+    "    name=\"Equity Analyst\",\n",
+    "    instructions=(\"You are an equity analyst that performs analysis on the given datasets. \"\n",
+    "                  \"Use the given tools to help you gather data and perform analysis.\"\n",
+    "                  \"With your tools, you can retrieve the latest stock price, fetch proprietary data, and notify user.\"),\n",
+    "    tools=tools_list,\n",
+    "    file_ids=file_ids,\n",
+    "    model=os.getenv(\"OPENAI_MODEL_NAME\")\n",
+    ")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Helper function to format the response from the assistant."
+    "Create a thread, which represents a conversation. It is recommended to create one thread per user. "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def format_response(messages: Iterable[MessageFile]) -> None:\n",
-    "\n",
-    "    message_list = []\n",
-    "\n",
-    "    # Iterate through the messages and break when a user message is encountered\n",
-    "    for message in messages:\n",
-    "        message_list.append(message)\n",
-    "        if message.role == \"user\":\n",
-    "            break\n",
-    "\n",
-    "    # Reverse the list of messages\n",
-    "    message_list = message_list[::-1]\n",
-    "\n",
-    "    for message in message_list:\n",
-    "        for item in message.content:\n",
-    "            if isinstance(item, MessageContentText):\n",
-    "                print(f\"{message.role}:\\n{item.text.value}\\n\")\n",
-    "            elif isinstance(item, MessageContentImageFile):\n",
-    "                try:\n",
-    "                    response_content = client.files.content(item.image_file.file_id)\n",
-    "                    data_in_bytes = response_content.read()\n",
-    "                    readable_buffer = io.BytesIO(data_in_bytes)\n",
-    "                    image = plt.imread(readable_buffer, format='jpeg')\n",
-    "                    plt.imshow(image)\n",
-    "                    plt.axis('off')\n",
-    "                    plt.show()\n",
-    "                except Exception as e:\n",
-    "                    print(f\"Exception: {e}\")"
+    "thread = client.beta.threads.create()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Create a thread run\n",
-    "\n",
-    "![Run lifecycle](https://cdn.openai.com/API/docs/images/diagram-1.png)"
+    "Create a thread run"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from tenacity import retry, stop_after_attempt, wait_exponential, RetryError, retry_if_exception_type\n",
-    "\n",
-    "# Custom exception for specific retry condition\n",
-    "class NotCompletedException(Exception):\n",
-    "    pass\n",
-    "\n",
-    "@retry(stop=stop_after_attempt(15), \n",
-    "       wait=wait_exponential(multiplier=1.5, min=4, max=20),\n",
-    "       retry=retry_if_exception_type(NotCompletedException))\n",
-    "def get_run_lifecycle_status(thread_id, run_id):\n",
-    "    run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)\n",
-    "    print(f\"Run status: {run.status}\")\n",
-    "    if run.status in [\"completed\", \"failed\", \"expired\", \"cancelled\"]:\n",
-    "        return run\n",
-    "    elif run.status == \"requires_action\":\n",
-    "        # Handle cases that require action differently\n",
-    "        # For example, you might not want to retry in this case\n",
-    "        pass\n",
-    "    else:\n",
-    "        # This will cause a retry for statuses not explicitly handled above\n",
-    "        raise NotCompletedException(\"Run not completed yet\")\n",
-    "\n",
     "def analyst_assistant(content: str):\n",
     "    client.beta.threads.messages.create(thread_id=thread.id, role=\"user\", content=content)\n",
     "\n",
     "    run = client.beta.threads.runs.create(\n",
     "        thread_id=thread.id,\n",
     "        assistant_id=assistant.id,\n",
-    "        instructions=f\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools.\",\n",
+    "        instructions=f\"You are a equity analyst who maps out the ask of the user to an equity analyst's task and thinks step by step to analyze, including making use of the tools. Make generic assumptions\",\n",
     "    )\n",
     "\n",
     "    try:\n",
-    "        run = get_run_lifecycle_status(thread.id, run.id)\n",
+    "        run = utils.get_run_lifecycle_status(thread.id, run.id)\n",
     "        messages = client.beta.threads.messages.list(thread_id=thread.id)\n",
-    "        format_response(messages)\n",
+    "        utils.format_response(messages)\n",
     "    except RetryError:\n",
     "        print(\"Operation failed or timed out after maximum retries.\")\n",
     "    except NotCompletedException:\n",
@@ -285,206 +275,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Run status: queued\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: completed\n",
-      "user:\n",
-      "Visualize the data and provide insights on the trends.\n",
-      "\n",
-      "assistant:\n",
-      "First, let's load the data from the uploaded file and take a quick look at its structure and contents to understand what kind of data we're working with. Based on this, we can decide how best to visualize it and analyze the trends. \n",
-      "\n",
-      "I'll start by loading the data using Python and displaying the first few rows.\n",
-      "\n",
-      "assistant:\n",
-      "The dataset appears to contain financial projections for a company, including the following columns:\n",
-      "\n",
-      "- `Year`: The fiscal year for the projection.\n",
-      "- `Projected Revenue`: Expected revenue for the year.\n",
-      "- `Projected EBIT` (Earnings Before Interest and Taxes): Expected operating income for the year.\n",
-      "- `Projected Net Income`: Expected net income for the year.\n",
-      "- `Projected Free Cash Flow`: Expected free cash flow for the year.\n",
-      "- `Discount Factor`: Used to calculate the present value of future cash flows.\n",
-      "- `Present Value of FCF` (Free Cash Flow): The discounted current worth of the projected free cash flows.\n",
-      "\n",
-      "Now that we understand the structure of the data, we can create visualizations to help identify trends and insights. We'll plot the growth of Projected Revenue, Projected EBIT, Projected Net Income, and Projected Free Cash Flow over the years. We can also look at how the Present Value of FCF changes relative to the undiscounted Free Cash Flow.\n",
-      "\n",
-      "Let's start by visualizing the financial projections over the years.\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "assistant:\n",
-      "The plot above visualizes the projected financial metrics from the dataset. Here are the key trends and insights we can observe:\n",
-      "\n",
-      "- All metrics (Projected Revenue, Projected EBIT, Projected Net Income, and Projected Free Cash Flow) are on an upward trend, implying the company is expecting growth in its financial performance over the years.\n",
-      "- The Projected Revenue appears to be the highest among the metrics, with a steady climb each year, which indicates increasing sales or expansion of the company's business operations.\n",
-      "- Projected EBIT and Projected Net Income, while lower than Projected Revenue, also show a consistent increase, suggesting improving profitability.\n",
-      "- Projected Free Cash Flow follows a similar upward pattern, indicating the company’s ability to generate cash after accounting for capital expenditures is also expected to grow.\n",
-      "\n",
-      "Next, let’s visualize the Present Value of Free Cash Flow compared to the Projected Free Cash Flow to see the effect of discounting cash flows to their present value.\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "assistant:\n",
-      "The chart above compares the Projected Free Cash Flow (FCF) and the Present Value of FCF over time. The following insights can be gleaned from this comparison:\n",
-      "\n",
-      "- As we would expect, the Present Value of FCF is lower than the nominal Projected FCF for each year, reflecting the application of the discount factor, which accounts for the time value of money. This is a common financial analysis practice to calculate the current value of future cash flows.\n",
-      "- The gap between the Projected FCF and its Present Value seems to be fairly consistent, suggesting a stable discount rate is used across the projection period. However, it naturally increases with time as the cash flows are discounted back to their present values from increasingly distant future years.\n",
-      "- The declining Present Value of FCF, despite the increase in nominal terms, suggests that the impact of discounting becomes more significant with a further out future cash flow due to higher cumulative discounting.\n",
-      "\n",
-      "Overall, the data displays an optimistic view of the company's financial future, with growth expected in all major financial metrics. The consistency in growth rates and discount rates provides a predictable model for the company's performance. However, these projections would also need to be stress-tested against various economic scenarios to evaluate the robustness of the forecasts. Additionally, comparing these projections to industry benchmarks, past company performance, and considering macroeconomic factors would give a more comprehensive insight into the company's prospects.\n",
-      "\n",
-      "If there's a specific analysis or further exploration you would like to pursue with this dataset, please let me know!\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "analyst_assistant(\"Visualize the data and provide insights on the trends.\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Run status: queued\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: completed\n",
-      "user:\n",
-      "Use python code to perform a discounted cash flow valuation using the given dataset. Make generic assumptions\n",
-      "\n",
-      "assistant:\n",
-      "To perform a discounted cash flow (DCF) valuation, we calculate the present value (PV) of projected free cash flows (FCF) for each year and then take the sum of these values. This is the value of the cash flows the company is expected to generate in the future, brought back to today's dollars.\n",
-      "\n",
-      "The formula for the present value of an individual year's FCF is:\n",
-      "\\[ PV = \\frac{FCF}{(1 + r)^n} \\]\n",
-      "where:\n",
-      "- \\( FCF \\) is the projected free cash flow for the year,\n",
-      "- \\( r \\) is the discount rate,\n",
-      "- \\( n \\) is the number of years from now.\n",
-      "\n",
-      "Since the dataset already includes a \"Discount Factor\", we don't need to explicitly apply the discount rate \\( r \\). We can simply multiply the \"Projected Free Cash Flow\" by the \"Discount Factor\" to get the \"Present Value of FCF\", which actually has been done already in the dataset.\n",
-      "\n",
-      "To find the total DCF valuation of the company, we would sum up these present values. Additionally, we would typically consider a terminal value that accounts for all cash flows beyond the last projected year, assuming a perpetual growth rate. To keep the analysis generic as requested, we will pick a reasonable perpetual growth rate and discount rate for the terminal value calculation. Let's proceed with these calculations using Python.\n",
-      "\n",
-      "assistant:\n",
-      "Based on the calculations using the provided dataset and generic assumptions:\n",
-      "\n",
-      "- The total present value of the projected free cash flows (FCF) from the given data is approximately $200.32 billion.\n",
-      "- The terminal value (TV), calculated at the end of the projection period using a perpetual growth rate of 2% and a discount rate of 5%, amounts to approximately $1,839.15 billion.\n",
-      "- The present value of the terminal value is about $1,441.02 billion.\n",
-      "- Finally, the total discounted cash flow (DCF) valuation of the company, which combines the present value of the projected FCFs and the present value of the terminal value, is approximately $1,641.35 billion.\n",
-      "\n",
-      "It's essential to note that the DCF valuation is sensitive to the assumptions made about growth rates and discount rates. Different assumptions could lead to significantly different valuations. These assumptions should be tailored to match the company's sector, risk profile, and prevailing economic conditions for a more accurate valuation.\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "analyst_assistant(\"Use python code to perform a discounted cash flow valuation using the given dataset. Make generic assumptions\")"
+    "analyst_assistant(\"Perform a discounted cash flow valuation using the provided dataset, and print the code along with its executed output that was used for this calculation.\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Run status: queued\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: in_progress\n",
-      "Run status: completed\n",
-      "user:\n",
-      "Visualize this information. Seems incorrect\n",
-      "\n",
-      "assistant:\n",
-      "Apologies for any confusion in the previous chart. I will rectify the visualization by distinctly presenting the present value of the free cash flows year by year and emhpasize the present value of terminal value, so the distinction and proportions are clear. Let's create a more accurate chart.\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "assistant:\n",
-      "The revised bar chart shows:\n",
-      "\n",
-      "- The blue bars represent the projected free cash flow (FCF) for each year specified in the dataset, without discounting.\n",
-      "- The green bars represent the present value of those cash flows after discounting.\n",
-      "- The terminal value is also plotted as a projected FCF (blue) and its discounted present value (green) in the final bars.\n",
-      "\n",
-      "This visualization more accurately depicts how the present value of each year's free cash flow compares to the non-discounted projected amounts and the overall significance of the terminal value in the DCF valuation calculation.\n",
-      "\n",
-      "I hope this chart meets your expectations. If there is anything else I can assist you with, please let me know.\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "analyst_assistant(\"Visualize this information\")"
+    "analyst_assistant(\"Summarize and Visualize this information to someone new to finance and investing.\")"
    ]
   },
   {
diff --git a/sandbox/agents/plugins/.funcignore b/sandbox/agents/plugins/.funcignore
new file mode 100644
index 00000000..9966315f
--- /dev/null
+++ b/sandbox/agents/plugins/.funcignore
@@ -0,0 +1,8 @@
+.git*
+.vscode
+__azurite_db*__.json
+__blobstorage__
+__queuestorage__
+local.settings.json
+test
+.venv
\ No newline at end of file
diff --git a/sandbox/agents/plugins/.gitignore b/sandbox/agents/plugins/.gitignore
new file mode 100644
index 00000000..7685fc4a
--- /dev/null
+++ b/sandbox/agents/plugins/.gitignore
@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don’t work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Azure Functions artifacts
+bin
+obj
+appsettings.json
+local.settings.json
+
+# Azurite artifacts
+__blobstorage__
+__queuestorage__
+__azurite_db*__.json
+.python_packages
\ No newline at end of file
diff --git a/sandbox/agents/plugins/function_app.py b/sandbox/agents/plugins/function_app.py
new file mode 100644
index 00000000..e06d69c8
--- /dev/null
+++ b/sandbox/agents/plugins/function_app.py
@@ -0,0 +1,46 @@
+import azure.functions as func
+import logging
+import yfinance as yf
+import json
+import pandas as pd
+
+app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)
+
+@app.route(route="get_financials")
+def get_financials(req: func.HttpRequest) -> func.HttpResponse:
+    logging.info('Python HTTP trigger function processed a request.')
+
+    # Extracting parameters from the request
+    ticker_symbol = req.params.get('ticker')
+    method_name = req.params.get('method')
+
+    if not ticker_symbol or not method_name:
+        return func.HttpResponse(
+             "Please pass a ticker symbol and method name on the query string or in the request body",
+             status_code=400
+        )
+
+    try:
+        # Fetching data from yfinance
+        ticker = yf.Ticker(ticker_symbol)
+        data = getattr(ticker, method_name)
+
+        # Handling callable methods vs properties
+        if callable(data):
+            result = data()  # Call the method if it's callable
+        else:
+            result = data   # Use the property value directly if not callable
+
+        # Formatting the result for JSON response
+        if isinstance(result, pd.DataFrame):
+            result = result.to_json()
+        elif not isinstance(result, str):
+            result = json.dumps(result)
+
+        return func.HttpResponse(result, mimetype="application/json")
+    except Exception as e:
+        logging.error(f"Error occurred: {e}")
+        return func.HttpResponse(
+             "Error occurred: " + str(e),
+             status_code=500
+        )
diff --git a/sandbox/agents/plugins/host.json b/sandbox/agents/plugins/host.json
new file mode 100644
index 00000000..9df91361
--- /dev/null
+++ b/sandbox/agents/plugins/host.json
@@ -0,0 +1,15 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  }
+}
\ No newline at end of file
diff --git a/sandbox/agents/plugins/requirements.txt b/sandbox/agents/plugins/requirements.txt
new file mode 100644
index 00000000..4e4e5d9b
--- /dev/null
+++ b/sandbox/agents/plugins/requirements.txt
@@ -0,0 +1,7 @@
+# DO NOT include azure-functions-worker in this file
+# The Python Worker is managed by Azure Functions platform
+# Manually managing azure-functions-worker may cause unexpected issues
+
+azure-functions
+yfinance
+pandas
diff --git a/sandbox/ais/logic-apps/assistants-auto-invest.json b/sandbox/ais/logic-apps/assistants-auto-invest.json
new file mode 100644
index 00000000..7a975bd5
--- /dev/null
+++ b/sandbox/ais/logic-apps/assistants-auto-invest.json
@@ -0,0 +1,202 @@
+{
+    "definition": {
+        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
+        "actions": {
+            "Gets_a_single_embedding": {
+                "inputs": {
+                    "parameters": {
+                        "deploymentId": "text-embedding-ada-002",
+                        "input": "@{body('Parse_JSON')?['data_type']}earnings"
+                    },
+                    "serviceProviderConfiguration": {
+                        "connectionName": "openai",
+                        "operationId": "getSingleEmbedding",
+                        "serviceProviderId": "/serviceProviders/openai"
+                    }
+                },
+                "runAfter": {
+                    "Parse_JSON": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "ServiceProvider"
+            },
+            "Gets_the_chat_completions": {
+                "inputs": {
+                    "parameters": {
+                        "deploymentId": "gpt-35-turbo",
+                        "messages": [
+                            {
+                                "message": "You are a summarizer of JSON data that provides narratives for a given JSON about user's portfolio allocation.",
+                                "role": "assistant"
+                            },
+                            {
+                                "message": "@concat(string(body('Vector_search')?[0]?['chunk']), string(body('Query_items')?['items']?[0]))",
+                                "role": "user"
+                            }
+                        ],
+                        "temperature": 0.7
+                    },
+                    "serviceProviderConfiguration": {
+                        "connectionName": "openai",
+                        "operationId": "getChatCompletions",
+                        "serviceProviderId": "/serviceProviders/openai"
+                    }
+                },
+                "runAfter": {
+                    "Query_items": [
+                        "SUCCEEDED"
+                    ],
+                    "Vector_search": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "ServiceProvider"
+            },
+            "Parse_JSON": {
+                "inputs": {
+                    "content": "@triggerOutputs()",
+                    "schema": {
+                        "properties": {
+                            "data_type": {
+                                "type": "string"
+                            },
+                            "ticker": {
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    }
+                },
+                "runAfter": {},
+                "type": "ParseJson"
+            },
+            "Query_items": {
+                "inputs": {
+                    "parameters": {
+                        "containerId": "recommendations",
+                        "databaseId": "miyagi",
+                        "queryText": "SELECT c.data.Request.Portfolio FROM c OFFSET 0 LIMIT 1"
+                    },
+                    "serviceProviderConfiguration": {
+                        "connectionName": "AzureCosmosDB",
+                        "operationId": "QueryDocuments",
+                        "serviceProviderId": "/serviceProviders/AzureCosmosDB"
+                    }
+                },
+                "runAfter": {
+                    "Parse_JSON": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "ServiceProvider"
+            },
+            "Response": {
+                "inputs": {
+                    "body": "@body('Gets_the_chat_completions')?['content']",
+                    "statusCode": 200
+                },
+                "kind": "Http",
+                "runAfter": {
+                    "Gets_the_chat_completions": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "Response"
+            },
+            "Send_an_email_(V2)": {
+                "inputs": {
+                    "body": {
+                        "Body": "<p>@{body('Gets_the_chat_completions')?['content']}</p>",
+                        "Importance": "Normal",
+                        "Subject": "Stock summary",
+                        "To": "@triggerBody()?['email']"
+                    },
+                    "host": {
+                        "connection": {
+                            "referenceName": "outlook"
+                        }
+                    },
+                    "method": "post",
+                    "path": "/v2/Mail"
+                },
+                "runAfter": {
+                    "Gets_the_chat_completions": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "ApiConnection"
+            },
+            "Send_to_Service_Bus": {
+                "inputs": {
+                    "parameters": {
+                        "entityName": "logicapps",
+                        "message": {
+                            "contentData": "@body('Gets_the_chat_completions')?['content']"
+                        }
+                    },
+                    "serviceProviderConfiguration": {
+                        "connectionName": "serviceBus",
+                        "operationId": "sendMessage",
+                        "serviceProviderId": "/serviceProviders/serviceBus"
+                    }
+                },
+                "runAfter": {
+                    "Gets_the_chat_completions": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "ServiceProvider"
+            },
+            "Vector_search": {
+                "inputs": {
+                    "parameters": {
+                        "indexName": "msft",
+                        "kNearestNeighbors": 3,
+                        "searchVector": {
+                            "fieldName": "vector",
+                            "vector": "@body('Gets_a_single_embedding')['embedding']"
+                        }
+                    },
+                    "serviceProviderConfiguration": {
+                        "connectionName": "azureaisearch",
+                        "operationId": "vectorSearch",
+                        "serviceProviderId": "/serviceProviders/azureaisearch"
+                    }
+                },
+                "runAfter": {
+                    "Gets_a_single_embedding": [
+                        "SUCCEEDED"
+                    ]
+                },
+                "type": "ServiceProvider"
+            }
+        },
+        "contentVersion": "1.0.0.0",
+        "outputs": {},
+        "triggers": {
+            "When_a_HTTP_request_is_received": {
+                "inputs": {
+                    "method": "POST",
+                    "schema": {
+                        "properties": {
+                            "data_type": {
+                                "type": "string"
+                            },
+                            "email": {
+                                "type": "string"
+                            },
+                            "ticker": {
+                                "type": "string"
+                            }
+                        },
+                        "type": "object"
+                    }
+                },
+                "kind": "Http",
+                "type": "Request"
+            }
+        }
+    },
+    "kind": "Stateful"
+}
\ No newline at end of file
diff --git a/services/chatgpt-plugin/dotnet/.vscode/extensions.json b/services/chatgpt-plugin/dotnet/.vscode/extensions.json
new file mode 100644
index 00000000..e0b0decf
--- /dev/null
+++ b/services/chatgpt-plugin/dotnet/.vscode/extensions.json
@@ -0,0 +1,7 @@
+{
+  "recommendations": [
+    "ms-azuretools.vscode-azurefunctions",
+    "ms-dotnettools.csharp",
+    "ms-semantic-kernel.semantic-kernel"
+  ]
+}
\ No newline at end of file
diff --git a/services/chatgpt-plugin/dotnet/.vscode/launch.json b/services/chatgpt-plugin/dotnet/.vscode/launch.json
new file mode 100644
index 00000000..894cbe6a
--- /dev/null
+++ b/services/chatgpt-plugin/dotnet/.vscode/launch.json
@@ -0,0 +1,11 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Attach to .NET Functions",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:azureFunctions.pickProcess}"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/services/chatgpt-plugin/dotnet/.vscode/settings.json b/services/chatgpt-plugin/dotnet/.vscode/settings.json
new file mode 100644
index 00000000..00d20d09
--- /dev/null
+++ b/services/chatgpt-plugin/dotnet/.vscode/settings.json
@@ -0,0 +1,7 @@
+{
+    "azureFunctions.deploySubpath": "azure-function/bin/Release/net6.0/publish",
+    "azureFunctions.projectLanguage": "C#",
+    "azureFunctions.projectRuntime": "~4",
+    "debug.internalConsoleOptions": "neverOpen",
+    "azureFunctions.preDeployTask": "publish (functions)"
+}
\ No newline at end of file
diff --git a/services/chatgpt-plugin/dotnet/.vscode/tasks.json b/services/chatgpt-plugin/dotnet/.vscode/tasks.json
new file mode 100644
index 00000000..b9995e18
--- /dev/null
+++ b/services/chatgpt-plugin/dotnet/.vscode/tasks.json
@@ -0,0 +1,110 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "clean (functions)",
+			"command": "dotnet",
+			"args": [
+				"clean",
+        "${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj",
+				"/property:GenerateFullPaths=true",
+				"/consoleloggerparameters:NoSummary",
+			],
+			"type": "process",
+			"problemMatcher": "$msCompile"
+		},
+		{
+			"label": "build (functions)",
+			"command": "dotnet",
+			"args": [
+				"build",
+        "${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj",
+				"/property:GenerateFullPaths=true",
+				"/consoleloggerparameters:NoSummary"
+			],
+			"type": "process",
+			"dependsOn": "clean (functions)",
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"problemMatcher": "$msCompile"
+		},
+		{
+			"label": "clean release (functions)",
+			"command": "dotnet",
+			"args": [
+				"clean",
+        		"${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj",
+				"--configuration",
+				"Release",
+				"/property:GenerateFullPaths=true",
+				"/consoleloggerparameters:NoSummary"
+			],
+			"type": "process",
+			"problemMatcher": "$msCompile"
+		},
+		{
+			"label": "publish (functions)",
+			"command": "dotnet",
+			"args": [
+				"publish",
+				"${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj",
+				"--configuration",
+				"Release",
+				"/property:GenerateFullPaths=true",
+				"/consoleloggerparameters:NoSummary"
+			],
+			"type": "process",
+			"dependsOn": "clean release (functions)",
+			"problemMatcher": "$msCompile"
+		},
+		{
+			"type": "func",
+			"dependsOn": "build (functions)",
+			"options": {
+				"cwd": "${workspaceFolder}/azure-function/bin/Debug/net6.0"
+			},
+			"command": "host start",
+			"isBackground": true,
+			"problemMatcher": "$func-dotnet-watch"
+        },
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/azure-function/sk-chatgpt-azure-function.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+	]
+}
+
diff --git a/services/expense-service/typescript/.vscode/launch.json b/services/expense-service/typescript/.vscode/launch.json
new file mode 100644
index 00000000..91c64d7b
--- /dev/null
+++ b/services/expense-service/typescript/.vscode/launch.json
@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/dist/main.js",
+            "console": "externalTerminal"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/ui/typescript/.vscode/settings.json b/ui/typescript/.vscode/settings.json
new file mode 100644
index 00000000..6a793c26
--- /dev/null
+++ b/ui/typescript/.vscode/settings.json
@@ -0,0 +1,8 @@
+{
+  "cSpell.words": [
+    "Miyagi",
+    "tailwindcss"
+  ],
+  "typescript.tsdk": "node_modules\\typescript\\lib",
+  "typescript.enablePromptUseWorkspaceTsdk": true
+}
\ No newline at end of file