From b41a12bc3bda658cbb9c7489e76d6b976bb98a69 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 29 Apr 2024 19:10:31 +0000 Subject: [PATCH 01/22] Update types-pytz requirement from ^2023.3.0.0 to >=2023.3,<2025.0 --- updated-dependencies: - dependency-name: types-pytz dependency-type: direct:development ... Signed-off-by: dependabot[bot] --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index babbcfcd..df6822d3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,7 +57,7 @@ docstring_parser = "0.16" black = "^23.1.0" ruff = ">=0.0.249,<0.4.3" types-toml = "^0.10.8.1" -types-pytz = "^2023.3.0.0" +types-pytz = ">=2023.3,<2025.0" types-chardet = "^5.0.4.6" mypy-protobuf = "^3.0.0" From c4be7869de950085192b1e3d8920f51b3e8af718 Mon Sep 17 00:00:00 2001 From: nictuku Date: Tue, 30 Apr 2024 21:00:07 +0100 Subject: [PATCH 02/22] Update pyproject.toml to point to swarms.world --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index babbcfcd..d4024de4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,7 +10,7 @@ description = "Swarms - Pytorch" license = "MIT" authors = ["Kye Gomez "] homepage = "https://github.com/kyegomez/swarms" -documentation = "https://swarms.apac.ai" +documentation = "https://swarms.world" readme = "README.md" repository = "https://github.com/kyegomez/swarms" keywords = [ From 3a3751fcd52147c3dd8a325cf6b26ba90fed5d61 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 6 May 2024 10:10:54 +0000 Subject: [PATCH 03/22] Bump pydantic from 2.6.4 to 2.7.1 Bumps [pydantic](https://github.com/pydantic/pydantic) from 2.6.4 to 2.7.1. - [Release notes](https://github.com/pydantic/pydantic/releases) - [Changelog](https://github.com/pydantic/pydantic/blob/main/HISTORY.md) - [Commits](https://github.com/pydantic/pydantic/compare/v2.6.4...v2.7.1) --- updated-dependencies: - dependency-name: pydantic dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 9c5ed8d9..42570057 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,7 +9,7 @@ toml pypdf==4.1.0 ratelimit==2.2.1 loguru==0.7.2 -pydantic==2.6.4 +pydantic==2.7.1 tenacity==8.2.3 Pillow==10.3.0 psutil From abdaf6f01ea850b8766be37b8cb7de8fba98ec40 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 6 May 2024 10:12:31 +0000 Subject: [PATCH 04/22] Update black requirement from ^23.1.0 to >=23.1,<25.0 Updates the requirements on [black](https://github.com/psf/black) to permit the latest version. - [Release notes](https://github.com/psf/black/releases) - [Changelog](https://github.com/psf/black/blob/main/CHANGES.md) - [Commits](https://github.com/psf/black/compare/23.1.0...24.4.2) --- updated-dependencies: - dependency-name: black dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index cd34274a..ac61b5c7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -54,7 +54,7 @@ PyYAML = "*" docstring_parser = "0.16" [tool.poetry.group.lint.dependencies] -black = "^23.1.0" +black = ">=23.1,<25.0" ruff = ">=0.0.249,<0.4.3" types-toml = "^0.10.8.1" types-pytz = "^2023.3.0.0" From 6bf61664e58e129d6bc0a0d47f5b29954bb816ba Mon Sep 17 00:00:00 2001 From: Aditya Ganesh Kumar Date: Mon, 6 May 2024 20:42:53 +0800 Subject: [PATCH 05/22] Added business analyst agent demo --- playground/business-analyst-agent.ipynb | 1951 +++++++++++++++++++++++ 1 file changed, 1951 insertions(+) create mode 100644 playground/business-analyst-agent.ipynb diff --git a/playground/business-analyst-agent.ipynb b/playground/business-analyst-agent.ipynb new file mode 100644 index 00000000..e6360793 --- /dev/null +++ b/playground/business-analyst-agent.ipynb @@ -0,0 +1,1951 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building Analyst Agents with Swarms to write Business Reports\n", + "\n", + "Solving a business problem often involves preparing a Business Case Report. This report comprehensively analyzes the problem, evaluates potential solutions, and provides evidence-based recommendations and an implementation plan to effectively address the issue and drive business value. While the process of preparing one requires an experienced business analyst, the workflow can be augmented using AI agents. Two candidates stick out as areas to work on:\n", + "\n", + "- Developing an outline to solve the problem\n", + "- Doing background research and gathering data \n", + " \n", + "In this blog, we will explore how Swarms agents can be used to tackle a busuiness problem by outlining the solution, conducting background research and generating a preliminary report.\n", + "\n", + "Before we proceed, this blog uses 3 API tools. Please obtain the following keys and store them in a `.env` file in the same folder as this file.\n", + "\n", + "- **[OpenAI API](https://openai.com/blog/openai-api)** as `OPENAI_API_KEY`\n", + "- **[TavilyAI API](https://app.tavily.com/home)** `TAVILY_API_KEY`\n", + "- **[KayAI API](https://www.kay.ai/)** as `KAY_API_KEY`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import dotenv\n", + "dotenv.load_dotenv() # Load environment variables from .env file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Developing an Outline to solve the problem\n", + "\n", + "Assume the business problem is: **How do we improve Nike's revenue in Q3 2024?** We first create a planning agent to break down the problem into dependent sub-problems.\n", + "\n", + "\n", + "#### Step 1. Defining the Data Model and Tool Schema\n", + "\n", + "Using Pydantic, we define a structure to help the agent generate sub-problems. \n", + "\n", + "- **QueryType:** Questions are either standalone or involve a combination of multiple others\n", + "- **Query:** Defines structure of a question.\n", + "- **QueryPlan:** Allows generation of a dependency graph of sub-questions" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import enum\n", + "from typing import List\n", + "from pydantic import Field, BaseModel\n", + "\n", + "class QueryType(str, enum.Enum):\n", + " \"\"\"Enumeration representing the types of queries that can be asked to a question answer system.\"\"\"\n", + "\n", + " SINGLE_QUESTION = \"SINGLE\"\n", + " MERGE_MULTIPLE_RESPONSES = \"MERGE_MULTIPLE_RESPONSES\"\n", + "\n", + "class Query(BaseModel):\n", + " \"\"\"Class representing a single question in a query plan.\"\"\"\n", + "\n", + " id: int = Field(..., description=\"Unique id of the query\")\n", + " question: str = Field(\n", + " ...,\n", + " description=\"Question asked using a question answering system\",\n", + " )\n", + " dependencies: List[int] = Field(\n", + " default_factory=list,\n", + " description=\"List of sub questions that need to be answered before asking this question\",\n", + " )\n", + " node_type: QueryType = Field(\n", + " default=QueryType.SINGLE_QUESTION,\n", + " description=\"Type of question, either a single question or a multi-question merge\",\n", + " )\n", + "\n", + "class QueryPlan(BaseModel):\n", + " \"\"\"Container class representing a tree of questions to ask a question answering system.\"\"\"\n", + "\n", + " query_graph: List[Query] = Field(\n", + " ..., description=\"The query graph representing the plan\"\n", + " )\n", + "\n", + " def _dependencies(self, ids: List[int]) -> List[Query]:\n", + " \"\"\"Returns the dependencies of a query given their ids.\"\"\"\n", + " \n", + " return [q for q in self.query_graph if q.id in ids]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also, a `tool_schema` needs to be defined. It is an instance of `QueryPlan` and is used to initialize the agent." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "tool_schema = QueryPlan(\n", + " query_graph = [query.dict() for query in [\n", + " Query(\n", + " id=1,\n", + " question=\"How do we improve Nike's revenue in Q3 2024?\",\n", + " dependencies=[2],\n", + " node_type=QueryType('SINGLE')\n", + " ),\n", + " # ... other queries ...\n", + " ]]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Step 2. Defining the Planning Agent\n", + "\n", + "We specify the query, task specification and an appropriate system prompt." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from swarms import OpenAIChat\n", + "from swarms import Agent\n", + "\n", + "query = \"How do we improve Nike's revenue in Q3 2024?\"\n", + "task = f\"Consider: {query}. Generate just the correct query plan in JSON format.\"\n", + "system_prompt = (\n", + " \"You are a world class query planning algorithm \" \n", + " \"capable of breaking apart questions into its \" \n", + " \"dependency queries such that the answers can be \" \n", + " \"used to inform the parent question. Do not answer \" \n", + " \"the questions, simply provide a correct compute \" \n", + " \"graph with good specific questions to ask and relevant \" \n", + " \"dependencies. Before you call the function, think \" \n", + " \"step-by-step to get a better understanding of the problem.\"\n", + " )\n", + "llm = OpenAIChat(\n", + " temperature=0.0, model_name=\"gpt-4\", max_tokens=4000\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we proceed with agent definition." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the agent\n", + "agent = Agent(\n", + " agent_name=\"Query Planner\",\n", + " system_prompt=system_prompt,\n", + " # Set the tool schema to the JSON string -- this is the key difference\n", + " tool_schema=tool_schema,\n", + " llm=llm,\n", + " max_loops=1,\n", + " autosave=True,\n", + " dashboard=False,\n", + " streaming_on=True,\n", + " verbose=True,\n", + " interactive=False,\n", + " # Set the output type to the tool schema which is a BaseModel\n", + " output_type=tool_schema, # or dict, or str\n", + " metadata_output_type=\"json\",\n", + " # List of schemas that the agent can handle\n", + " list_tool_schemas=[tool_schema],\n", + " function_calling_format_type=\"OpenAI\",\n", + " function_calling_type=\"json\", # or soon yaml\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Step 3. Obtaining Outline from Planning Agent \n", + "\n", + "We now run the agent, and since its output is in JSON format, we can load it as a dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mInitializing Autonomous Agent Query Planner...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='{\\n \"main_query\": \"How do we improve Nike\\'s revenue in Q3 2024?\",\\n \"sub_queries\": [\\n {\\n \"id\": \"1\",\\n \"query\": \"What is Nike\\'s current revenue trend?\"\\n },\\n {\\n \"id\": \"2\",\\n \"query\": \"What are the projected market trends for the sports apparel industry in 2024?\"\\n },\\n {\\n \"id\": \"3\",\\n \"query\": \"What are the current successful strategies being used by Nike\\'s competitors?\",\\n \"dependencies\": [\"2\"]\\n },\\n {\\n \"id\": \"4\",\\n \"query\": \"What are the current and projected economic conditions in Nike\\'s major markets?\",\\n \"dependencies\": [\"2\"]\\n },\\n {\\n \"id\": \"5\",\\n \"query\": \"What are the current consumer preferences in the sports apparel industry?\",\\n \"dependencies\": [\"2\"]\\n },\\n {\\n \"id\": \"6\",\\n \"query\": \"What are the potential areas of improvement in Nike\\'s current business model?\",\\n \"dependencies\": [\"1\"]\\n },\\n {\\n \"id\": \"7\",\\n \"query\": \"What are the potential new markets for Nike to explore in 2024?\",\\n \"dependencies\": [\"2\", \"4\"]\\n },\\n {\\n \"id\": \"8\",\\n \"query\": \"What are the potential new products or services Nike could introduce in 2024?\",\\n \"dependencies\": [\"5\"]\\n },\\n {\\n \"id\": \"9\",\\n \"query\": \"What are the potential marketing strategies Nike could use to increase its revenue in Q3 2024?\",\\n \"dependencies\": [\"3\", \"5\", \"7\", \"8\"]\\n },\\n {\\n \"id\": \"10\",\\n \"query\": \"What are the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024?\",\\n \"dependencies\": [\"6\"]\\n }\\n ]\\n}' response_metadata={'token_usage': {'completion_tokens': 408, 'prompt_tokens': 108, 'total_tokens': 516}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Query Planner_state.json\u001b[0m\n" + ] + } + ], + "source": [ + "generated_data = agent.run(task)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At times the agent could return extra content other than JSON. Below function will filter it out." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def process_json_output(content):\n", + " # Find the index of the first occurrence of '```json\\n'\n", + " start_index = content.find('```json\\n')\n", + " if start_index == -1:\n", + " # If '```json\\n' is not found, return the original content\n", + " return content\n", + " # Return the part of the content after '```json\\n' and remove the '```' at the end\n", + " return content[start_index + len('```json\\n'):].rstrip('`')\n", + "\n", + "# Use the function to clean up the output\n", + "json_content = process_json_output(generated_data.content)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"main_query\": \"How do we improve Nike's revenue in Q3 2024?\",\n", + " \"sub_queries\": [\n", + " {\n", + " \"id\": \"1\",\n", + " \"query\": \"What is Nike's current revenue trend?\"\n", + " },\n", + " {\n", + " \"id\": \"2\",\n", + " \"query\": \"What are the projected market trends for the sports apparel industry in 2024?\"\n", + " },\n", + " {\n", + " \"id\": \"3\",\n", + " \"query\": \"What are the current successful strategies being used by Nike's competitors?\",\n", + " \"dependencies\": [\n", + " \"2\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"4\",\n", + " \"query\": \"What are the current and projected economic conditions in Nike's major markets?\",\n", + " \"dependencies\": [\n", + " \"2\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"5\",\n", + " \"query\": \"What are the current consumer preferences in the sports apparel industry?\",\n", + " \"dependencies\": [\n", + " \"2\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"6\",\n", + " \"query\": \"What are the potential areas of improvement in Nike's current business model?\",\n", + " \"dependencies\": [\n", + " \"1\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"7\",\n", + " \"query\": \"What are the potential new markets for Nike to explore in 2024?\",\n", + " \"dependencies\": [\n", + " \"2\",\n", + " \"4\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"8\",\n", + " \"query\": \"What are the potential new products or services Nike could introduce in 2024?\",\n", + " \"dependencies\": [\n", + " \"5\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"9\",\n", + " \"query\": \"What are the potential marketing strategies Nike could use to increase its revenue in Q3 2024?\",\n", + " \"dependencies\": [\n", + " \"3\",\n", + " \"5\",\n", + " \"7\",\n", + " \"8\"\n", + " ]\n", + " },\n", + " {\n", + " \"id\": \"10\",\n", + " \"query\": \"What are the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024?\",\n", + " \"dependencies\": [\n", + " \"6\"\n", + " ]\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "# Load the JSON string into a Python object\n", + "json_object = json.loads(json_content)\n", + "\n", + "# Convert the Python object back to a JSON string\n", + "json_content = json.dumps(json_object, indent=2)\n", + "\n", + "# Print the JSON string\n", + "print(json_content)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The JSON dictionary is not convenient for humans to process. We make a directed graph out of it." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import textwrap\n", + "import random\n", + "\n", + "# Create a directed graph\n", + "G = nx.DiGraph()\n", + "\n", + "# Define a color map\n", + "color_map = {}\n", + "\n", + "# Add nodes and edges to the graph\n", + "for sub_query in json_object['sub_queries']:\n", + " # Check if 'dependencies' key exists in sub_query, if not, initialize it as an empty list\n", + " if 'dependencies' not in sub_query:\n", + " sub_query['dependencies'] = []\n", + " # Assign a random color for each node\n", + " color_map[sub_query['id']] = \"#{:06x}\".format(random.randint(0, 0xFFFFFF))\n", + " G.add_node(sub_query['id'], label=textwrap.fill(sub_query['query'], width=20))\n", + " for dependency in sub_query['dependencies']:\n", + " G.add_edge(dependency, sub_query['id'])\n", + "\n", + "# Draw the graph\n", + "pos = nx.spring_layout(G)\n", + "nx.draw(G, pos, with_labels=True, node_size=800, node_color=[color_map[node] for node in G.nodes()], node_shape=\"o\", alpha=0.5, linewidths=40)\n", + "\n", + "# Prepare labels for legend\n", + "labels = nx.get_node_attributes(G, 'label')\n", + "handles = [plt.Line2D([0], [0], marker='o', color=color_map[node], label=f\"{node}: {label}\", markersize=10, linestyle='None') for node, label in labels.items()]\n", + "\n", + "# Create a legend\n", + "plt.legend(handles=handles, title=\"Queries\", bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Doing Background Research and Gathering Data\n", + "\n", + "At this point, we have solved the first half of the problem. We have an outline consisting of sub-problems to to tackled to solve our business problem. This will form the overall structure of our report. We now need to research information for each sub-problem in order to write an informed report. This mechanically intensive and is the aspect that will most benefit from Agentic intervention. \n", + "\n", + "Essentially, we can spawn parallel agents to gather the data. Each agent will have 2 tools:\n", + "\n", + "- Internet access\n", + "- Financial data retrieval\n", + "\n", + "As they run parallely, they will add their knowledge into a common long-term memory. We will then spawn a separate report writing agent with access to this memory to generate our business case report.\n", + "\n", + "#### Step 4. Defining Tools for Worker Agents\n", + "\n", + "Let us first define the 2 tools. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from typing import List, Dict\n", + "\n", + "from swarms import tool\n", + "\n", + "os.environ['TAVILY_API_KEY'] = os.getenv('TAVILY_API_KEY')\n", + "os.environ[\"KAY_API_KEY\"] = os.getenv('KAY_API_KEY')\n", + "\n", + "from langchain_community.tools.tavily_search import TavilySearchResults\n", + "from langchain_core.pydantic_v1 import BaseModel, Field\n", + "\n", + "from kay.rag.retrievers import KayRetriever\n", + "\n", + "@tool\n", + "def browser(query: str) -> str:\n", + " \"\"\"\n", + " Search the query in the browser with the Tavily API tool.\n", + " Args:\n", + " query (str): The query to search in the browser.\n", + " Returns:\n", + " str: The search results\n", + " \"\"\"\n", + " internet_search = TavilySearchResults()\n", + " results = internet_search.invoke({\"query\": query})\n", + " response = '' \n", + " for result in results:\n", + " response += (result['content'] + '\\n')\n", + " return response\n", + "\n", + "@tool\n", + "def kay_retriever(query: str) -> str:\n", + " \"\"\"\n", + " Search the financial data query with the KayAI API tool.\n", + " Args:\n", + " query (str): The query to search in the KayRetriever.\n", + " Returns:\n", + " str: The first context retrieved as a string.\n", + " \"\"\"\n", + " # Initialize the retriever\n", + " retriever = KayRetriever(dataset_id = \"company\", data_types=[\"10-K\", \"10-Q\", \"8-K\", \"PressRelease\"])\n", + " # Query the retriever\n", + " context = retriever.query(query=query,num_context=1)\n", + " return context[0]['chunk_embed_text']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Step 5. Defining Long-Term Memory\n", + "\n", + "As mentioned previously, the worker agents running parallely, will pool their knowledge into a common memory. Let us define that.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "import uuid\n", + "from typing import Callable, List, Optional\n", + "\n", + "import chromadb\n", + "import numpy as np\n", + "from dotenv import load_dotenv\n", + "\n", + "from swarms.utils.data_to_text import data_to_text\n", + "from swarms.utils.markdown_message import display_markdown_message\n", + "from swarms.memory.base_vectordb import AbstractVectorDatabase\n", + "\n", + "# Load environment variables\n", + "load_dotenv()\n", + "\n", + "# Results storage using local ChromaDB\n", + "class ChromaDB(AbstractVectorDatabase):\n", + " \"\"\"\n", + "\n", + " ChromaDB database\n", + "\n", + " Args:\n", + " metric (str): The similarity metric to use.\n", + " output (str): The name of the collection to store the results in.\n", + " limit_tokens (int, optional): The maximum number of tokens to use for the query. Defaults to 1000.\n", + " n_results (int, optional): The number of results to retrieve. Defaults to 2.\n", + "\n", + " Methods:\n", + " add: _description_\n", + " query: _description_\n", + "\n", + " Examples:\n", + " >>> chromadb = ChromaDB(\n", + " >>> metric=\"cosine\",\n", + " >>> output=\"results\",\n", + " >>> llm=\"gpt3\",\n", + " >>> openai_api_key=OPENAI_API_KEY,\n", + " >>> )\n", + " >>> chromadb.add(task, result, result_id)\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " metric: str = \"cosine\",\n", + " output_dir: str = \"swarms\",\n", + " limit_tokens: Optional[int] = 1000,\n", + " n_results: int = 3,\n", + " embedding_function: Callable = None,\n", + " docs_folder: str = None,\n", + " verbose: bool = False,\n", + " *args,\n", + " **kwargs,\n", + " ):\n", + " self.metric = metric\n", + " self.output_dir = output_dir\n", + " self.limit_tokens = limit_tokens\n", + " self.n_results = n_results\n", + " self.docs_folder = docs_folder\n", + " self.verbose = verbose\n", + "\n", + " # Disable ChromaDB logging\n", + " if verbose:\n", + " logging.getLogger(\"chromadb\").setLevel(logging.INFO)\n", + "\n", + " # Create Chroma collection\n", + " chroma_persist_dir = \"chroma\"\n", + " chroma_client = chromadb.PersistentClient(\n", + " settings=chromadb.config.Settings(\n", + " persist_directory=chroma_persist_dir,\n", + " ),\n", + " *args,\n", + " **kwargs,\n", + " )\n", + "\n", + " # Embedding model\n", + " if embedding_function:\n", + " self.embedding_function = embedding_function\n", + " else:\n", + " self.embedding_function = None\n", + "\n", + " # Create ChromaDB client\n", + " self.client = chromadb.Client()\n", + "\n", + " # Create Chroma collection\n", + " self.collection = chroma_client.get_or_create_collection(\n", + " name=output_dir,\n", + " metadata={\"hnsw:space\": metric},\n", + " embedding_function=self.embedding_function,\n", + " # data_loader=self.data_loader,\n", + " *args,\n", + " **kwargs,\n", + " )\n", + " display_markdown_message(\n", + " \"ChromaDB collection created:\"\n", + " f\" {self.collection.name} with metric: {self.metric} and\"\n", + " f\" output directory: {self.output_dir}\"\n", + " )\n", + "\n", + " # If docs\n", + " if docs_folder:\n", + " display_markdown_message(\n", + " f\"Traversing directory: {docs_folder}\"\n", + " )\n", + " self.traverse_directory()\n", + "\n", + " def add(\n", + " self,\n", + " document: str,\n", + " *args,\n", + " **kwargs,\n", + " ):\n", + " \"\"\"\n", + " Add a document to the ChromaDB collection.\n", + "\n", + " Args:\n", + " document (str): The document to be added.\n", + " condition (bool, optional): The condition to check before adding the document. Defaults to True.\n", + "\n", + " Returns:\n", + " str: The ID of the added document.\n", + " \"\"\"\n", + " try:\n", + " doc_id = str(uuid.uuid4())\n", + " self.collection.add(\n", + " ids=[doc_id],\n", + " documents=[document],\n", + " *args,\n", + " **kwargs,\n", + " )\n", + " print('-----------------')\n", + " print(\"Document added successfully\")\n", + " print('-----------------')\n", + " return doc_id\n", + " except Exception as e:\n", + " raise Exception(f\"Failed to add document: {str(e)}\")\n", + "\n", + " def query(\n", + " self,\n", + " query_text: str,\n", + " *args,\n", + " **kwargs,\n", + " ):\n", + " \"\"\"\n", + " Query documents from the ChromaDB collection.\n", + "\n", + " Args:\n", + " query (str): The query string.\n", + " n_docs (int, optional): The number of documents to retrieve. Defaults to 1.\n", + "\n", + " Returns:\n", + " dict: The retrieved documents.\n", + " \"\"\"\n", + " try:\n", + " docs = self.collection.query(\n", + " query_texts=[query_text],\n", + " n_results=self.n_results,\n", + " *args,\n", + " **kwargs,\n", + " )[\"documents\"]\n", + " return docs[0]\n", + " except Exception as e:\n", + " raise Exception(f\"Failed to query documents: {str(e)}\")\n", + "\n", + " def traverse_directory(self):\n", + " \"\"\"\n", + " Traverse through every file in the given directory and its subdirectories,\n", + " and return the paths of all files.\n", + " Parameters:\n", + " - directory_name (str): The name of the directory to traverse.\n", + " Returns:\n", + " - list: A list of paths to each file in the directory and its subdirectories.\n", + " \"\"\"\n", + " added_to_db = False\n", + "\n", + " for root, dirs, files in os.walk(self.docs_folder):\n", + " for file in files:\n", + " file = os.path.join(self.docs_folder, file)\n", + " _, ext = os.path.splitext(file)\n", + " data = data_to_text(file)\n", + " added_to_db = self.add([data])\n", + " print(f\"{file} added to Database\")\n", + "\n", + " return added_to_db" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now proceed to initialize the memory." + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36mChromaDB collection created: results with metric: cosine and output directory: results\u001b[0m\n" + ] + } + ], + "source": [ + "from chromadb.utils import embedding_functions\n", + "default_ef = embedding_functions.DefaultEmbeddingFunction()\n", + "\n", + "memory = ChromaDB(\n", + " metric=\"cosine\",\n", + " n_results=3,\n", + " output_dir=\"results\",\n", + " embedding_function=default_ef\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Step 6. Defining Worker Agents \n", + "\n", + "The Worker Agent sub-classes the `Agent` class. The only different between these 2 is in how the `run()` method works. In the `Agent` class, `run()` simply returns the set of tool commands to run, but does not execute it. We, however, desire this. In addition, after we run our tools, we get the relevant information as output. We want to add this information to our memory. Hence, to incorporate these 2 changes, we define `WorkerAgent` as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "class WorkerAgent(Agent):\n", + " def __init__(self, *args, **kwargs):\n", + " super().__init__(*args, **kwargs)\n", + " \n", + " def run(self, task, *args, **kwargs):\n", + " response = super().run(task, *args, **kwargs)\n", + " print(response.content)\n", + "\n", + " json_dict = json.loads(process_json_output(response.content))\n", + "\n", + " #print(json.dumps(json_dict, indent=2))\n", + " \n", + " if response!=None:\n", + " try:\n", + " commands = json_dict[\"commands\"]\n", + " except:\n", + " commands = [json_dict['command']]\n", + " \n", + " for command in commands:\n", + " tool_name = command[\"name\"]\n", + "\n", + " if tool_name not in ['browser', 'kay_retriever']:\n", + " continue\n", + " \n", + " query = command[\"args\"][\"query\"]\n", + "\n", + " # Get the tool by its name\n", + " tool = globals()[tool_name]\n", + " tool_response = tool(query)\n", + "\n", + " # Add tool's output to long term memory\n", + " self.long_term_memory.add(tool_response)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then instantiate an object of the `WorkerAgent` class." + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [], + "source": [ + "worker_agent = WorkerAgent(\n", + " agent_name=\"Worker Agent\",\n", + " system_prompt=(\n", + " \"Autonomous agent that can interact with browser, \"\n", + " \"financial data retriever and other agents. Be Helpful \" \n", + " \"and Kind. Use the tools provided to assist the user. \"\n", + " \"Generate the plan with list of commands in JSON format.\"\n", + " ),\n", + " llm=OpenAIChat(\n", + " temperature=0.0, model_name=\"gpt-4\", max_tokens=4000\n", + "),\n", + " max_loops=\"auto\",\n", + " autosave=True,\n", + " dashboard=False,\n", + " streaming_on=True,\n", + " verbose=True,\n", + " stopping_token=\"\",\n", + " interactive=True,\n", + " tools=[browser, kay_retriever],\n", + " long_term_memory=memory,\n", + " code_interpreter=True,\n", + ")" + ] + }, + { + "attachments": { + "query-plan-mini.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAJ+CAYAAACAWIClAAAMQGlDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnluSkEBoAQSkhN4EASkBpITQAkgvgo2QBAglxoSgYkcXFVy7iIANXRVR7IDYETuLYO+LBQVlXSzYlTcpoOu+8r35vrnz33/O/OfMuTP33gFA4yRHJMpFNQHIE+aL40ID6WNTUumkboADAiACOjDicCUiZkxMJIBlsP17eXcDILL2qqNM65/9/7Vo8fgSLgBIDMTpPAk3D+KDAOBVXJE4HwCijLeYmi+SYViBjhgGCPEiGc5U4CoZTlfgvXKbhDgWxC0AqKhxOOJMANTbIU8v4GZCDfU+iJ2FPIEQAA06xH55eZN5EKdBbAttRBDL9BnpP+hk/k0zfUiTw8kcwoq5yItKkEAiyuVM/z/T8b9LXq500Ic1rGpZ4rA42Zxh3m7lTI6QYTWIe4XpUdEQa0P8QcCT20OMUrKkYYkKe9SIK2HBnAE9iJ15nKAIiI0gDhHmRkUq+fQMQQgbYrhC0GmCfHYCxPoQL+JLguOVNpvEk+OUvtD6DDGLqeTPc8RyvzJfD6Q5iUyl/ussPlupj6kXZiUkQ0yB2LJAkBQFsTrETpKc+AilzejCLFbUoI1YGieL3xLiOL4wNFChjxVkiEPilPYleZLB+WKbsgTsKCXen5+VEKbID9bC5cjjh3PB2vlCZuKgDl8yNnJwLjx+ULBi7lg3X5gYr9T5IMoPjFOMxSmi3BilPW7Ozw2V8eYQu0kK4pVj8aR8uCAV+niGKD8mQREnXpjNCY9RxIMvB5GABYLgjpPCmg4mg2wgaOtt6IV3ip4QwAFikAn4wFHJDI5IlvcI4TUeFII/IeIDydC4QHkvHxRA/usQq7g6ggx5b4F8RA54CnEeiAC58F4qHyUc8pYEnkBG8A/vHFi5MN5cWGX9/54fZL8zTMhEKhnpoEe6xqAlMZgYRAwjhhDtcEPcD/fBI+E1AFZXnIF7Dc7juz3hKaGD8IhwndBJuD1JUCT+KcoxoBPqhyhzkf5jLnBrqOmOB+K+UB0q43q4IXDE3aAfJu4PPbtDlqWMW5YV+k/af5vBD09DaUd2JqPkYeQAsu3PI9Xt1d2HVGS5/jE/iljTh/LNGur52T/rh+zzYBvxsyW2CDuAncNOYRewo1gDoGMnsEasFTsmw0Or64l8dQ16i5PHkwN1BP/wN/hkZZmUONc69zh/UfTl86fJ3tGANVk0XSzIzMqnM+EXgU9nC7lOI+iuzq5uAMi+L4rX15tY+XcD0Wv9zs3/AwDfEwMDA0e+c+EnANjnCbf/4e+cLQN+OlQBOH+YKxUXKDhcdiHAt4QG3GkGwARYAFs4H1fgAXxAAAgG4SAaJIAUMBFGnwXXuRhMBTPBPFAMSsFysAZUgI1gC9gBdoP9oAEcBafAWXAJtIPr4C5cPV3gBegD78BnBEFICBWhIQaIKWKFOCCuCAPxQ4KRSCQOSUHSkExEiEiRmch8pBRZiVQgm5EaZB9yGDmFXEA6kNvIQ6QHeY18QjFUDdVBjVFrdCTKQJloBJqATkAz0SloIboAXYqWo9XoLrQePYVeQq+jnegLtB8DmCqmh5lhjhgDY2HRWCqWgYmx2VgJVoZVY3VYE3zOV7FOrBf7iBNxGk7HHeEKDsMTcS4+BZ+NL8Er8B14Pd6CX8Uf4n34NwKVYERwIHgT2ISxhEzCVEIxoYywjXCIcAbupS7COyKRqEe0IXrCvZhCzCbOIC4hrifuIZ4kdhAfE/tJJJIByYHkS4omcUj5pGLSOtIu0gnSFVIX6YOKqoqpiqtKiEqqilClSKVMZafKcZUrKs9UPpM1yVZkb3I0mUeeTl5G3kpuIl8md5E/U7QoNhRfSgIlmzKPUk6po5yh3KO8UVVVNVf1Uo1VFajOVS1X3at6XvWh6kc1bTV7NZbaeDWp2lK17Won1W6rvaFSqdbUAGoqNZ+6lFpDPU19QP2gTlN3Umer89TnqFeq16tfUX+pQdaw0mBqTNQo1CjTOKBxWaNXk6xprcnS5GjO1qzUPKx5U7Nfi6blohWtlae1RGun1gWtbm2StrV2sDZPe4H2Fu3T2o9pGM2CxqJxafNpW2lnaF06RB0bHbZOtk6pzm6dNp0+XW1dN90k3Wm6lbrHdDv1MD1rPbZert4yvf16N/Q+DTMexhzGH7Z4WN2wK8Pe6w/XD9Dn65fo79G/rv/JgG4QbJBjsMKgweC+IW5obxhrONVwg+EZw97hOsN9hnOHlwzfP/yOEWpkbxRnNMNoi1GrUb+xiXGosch4nfFp414TPZMAk2yT1SbHTXpMaaZ+pgLT1aYnTJ/TdelMei69nN5C7zMzMgszk5ptNmsz+2xuY55oXmS+x/y+BcWCYZFhsdqi2aLP0tRyjOVMy1rLO1ZkK4ZVltVaq3NW761trJOtF1o3WHfb6NuwbQptam3u2VJt/W2n2FbbXrMj2jHscuzW27Xbo/bu9ln2lfaXHVAHDweBw3qHjhGEEV4jhCOqR9x0VHNkOhY41jo+dNJzinQqcmpwejnScmTqyBUjz4385uzunOu81fmui7ZLuEuRS5PLa1d7V65rpeu1UdRRIaPmjGoc9crNwY3vtsHtljvNfYz7Qvdm968enh5ijzqPHk9LzzTPKs+bDB1GDGMJ47wXwSvQa47XUa+P3h7e+d77vf/ycfTJ8dnp0z3aZjR/9NbRj33NfTm+m307/eh+aX6b/Dr9zfw5/tX+jwIsAngB2wKeMe2Y2cxdzJeBzoHiwEOB71nerFmsk0FYUGhQSVBbsHZwYnBF8IMQ85DMkNqQvlD30BmhJ8MIYRFhK8Juso3ZXHYNuy/cM3xWeEuEWkR8REXEo0j7SHFk0xh0TPiYVWPuRVlFCaMaokE0O3pV9P0Ym5gpMUdiibExsZWxT+Nc4mbGnYunxU+K3xn/LiEwYVnC3UTbRGlic5JG0vikmqT3yUHJK5M7x44cO2vspRTDFEFKYyopNSl1W2r/uOBxa8Z1jXcfXzz+xgSbCdMmXJhoODF34rFJGpM4kw6kEdKS03amfeFEc6o5/ens9Kr0Pi6Lu5b7ghfAW83r4fvyV/KfZfhmrMzozvTNXJXZk+WfVZbVK2AJKgSvssOyN2a/z4nO2Z4zkJucuydPJS8t77BQW5gjbJlsMnna5A6Rg6hY1DnFe8qaKX3iCPE2CSKZIGnM14E/8q1SW+kv0ocFfgWVBR+mJk09ME1rmnBa63T76YunPysMKfxtBj6DO6N5ptnMeTMfzmLO2jwbmZ0+u3mOxZwFc7rmhs7dMY8yL2fe70XORSuL3s5Pnt+0wHjB3AWPfwn9pbZYvVhcfHOhz8KNi/BFgkVti0ctXrf4Wwmv5GKpc2lZ6Zcl3CUXf3X5tfzXgaUZS9uWeSzbsJy4XLj8xgr/FTtWaq0sXPl41ZhV9avpq0tWv10zac2FMreyjWspa6VrO8sjyxvXWa5bvu5LRVbF9crAyj1VRlWLq96v562/siFgQ91G442lGz9tEmy6tTl0c321dXXZFuKWgi1PtyZtPfcb47eabYbbSrd93S7c3rkjbkdLjWdNzU6jnctq0Vppbc+u8bvadwftbqxzrNu8R29P6V6wV7r3+b60fTf2R+xvPsA4UHfQ6mDVIdqhknqkfnp9X0NWQ2djSmPH4fDDzU0+TYeOOB3ZftTsaOUx3WPLjlOOLzg+cKLwRP9J0cneU5mnHjdPar57euzpay2xLW1nIs6cPxty9vQ55rkT533PH73gfeHwRcbFhksel+pb3VsP/e7++6E2j7b6y56XG9u92ps6Rnccv+J/5dTVoKtnr7GvXboedb3jRuKNWzfH3+y8xbvVfTv39qs7BXc+3517j3Cv5L7m/bIHRg+q/7D7Y0+nR+exh0EPWx/FP7r7mPv4xRPJky9dC55Sn5Y9M31W0+3afbQnpKf9+bjnXS9ELz73Fv+p9WfVS9uXB/8K+Ku1b2xf1yvxq4HXS94YvNn+1u1tc39M/4N3ee8+vy/5YPBhx0fGx3Ofkj89+zz1C+lL+Ve7r03fIr7dG8gbGBBxxBz5rwAGK5qRAcDr7QBQUwCgwfMZZZzi/CcviOLMKkfgP2HFGVFePACog//vsb3w7+YmAHu3wuMX1NcYD0AMFYAEL4COGjVUB89q8nOlrBDhOWBT1Nf0vHTwb4rizPlD3D+3QKbqBn5u/wUf4nxVIylEvwAAAIplWElmTU0AKgAAAAgABAEaAAUAAAABAAAAPgEbAAUAAAABAAAARgEoAAMAAAABAAIAAIdpAAQAAAABAAAATgAAAAAAAACQAAAAAQAAAJAAAAABAAOShgAHAAAAEgAAAHigAgAEAAAAAQAAA0ygAwAEAAAAAQAAAn4AAAAAQVNDSUkAAABTY3JlZW5zaG90LdwoMQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAAdZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+NjM4PC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjg0NDwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlVzZXJDb21tZW50PlNjcmVlbnNob3Q8L2V4aWY6VXNlckNvbW1lbnQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgpmF7m6AAAAHGlET1QAAAACAAAAAAAAAT8AAAAoAAABPwAAAT8AASHg8B+cxQAAQABJREFUeAHsvQd7W0mWJXjhvSEJeivKSymlqcqq6p7Znv22d+Ynz+632907XVVdptOnlPIiKXpPwntgzwkQElOiAwjzANzIhODfi3ceGPFO3HPPtVXRRJsioAgoAoqAIqAIKAKKgCKgCCgCisAnCNiUMH2CydVeAM2sFCpSyZSlkq1ItTI4vNPmsInNaxdHwCF2l13EdjXI9FOKgCKgCCgCioAVEahWMI+XKyK48bG5rz/m/I61ZTPLn6wxm2mv/o8Nc6Idc6HTXrvHYzNPOhwnz3WStOI51z4pAo0goISpEbROPktyVC1UpbBTkMyrjORXslLNnQymTWyv177iCNjFM+cV3z2/uEfcYvNwstAJodfOo/ZXEVAEFIGBQ4Csh+SHxOfkxseVXEHK6RxuWSyC5qWMW5U3vF7JFkCmyiBSZayU4nu8Yc4zJImkyIWb1yN2H29ucfCx34NFRR9uXrzvFBtIFf6pfa/+eODA1wNWBHoXASVMjZw7LDpVShUp7hYlt5aT/HpOSoclqSQ5kHIUHoxmc9rEEXSIc8gpXhAn96xXXKOu2oqaEqfB+BHoUSoCioAi0AsI1MkRFzoZMSoUpZTKSjmVwdyNexCkciZXI0d4j3M8yZGQIOGxuWfk6RTBqh12nQDhGSNMJE4ORpl4X3ts42Ov2xAph98r9iAIVNAvjhBuIFSGSDEyVSdfvYCn9lERGFAElDBd8cRXy1UMsGXJb+YlvwqytJGX0lERg+kVN9CHH7M5MDcMu8Qz4zGkyTPFFTVOFBpt6sPTrYekCCgCikBPIcCFzApJUDIjpXhaysm0VEiWSJIQTWIkydxyiCQVGT0CMWp1A4myuV1iB3FyMAJF4nQSeTLkKRwQRxQ3kCm709nqvev2FAFFoEUIKGG6DEiG6iG/Kx4WEVHKS+5NVooHDNFzxemyLw/A++BGDh+iTYgw+W75xDPtQeQJk4Nbc5sG4OzrISoCioAiYCkEKK9jFKmSgawOpKgUT0npICHF/WMsciYMYTI5Smb+xj+/um/joZyS4RkJO2R6JEyukTDmzygWH3FvIk8gTpD1MTplJHxt7JJuWhFQBK6OgBKmC7AyUSWYOpT2i5J5jVylVQzAqRJWouqD7AVfHqS3yI0g03NGINGb94rnhk/co1hN82PAx3vaFAFFQBFQBBSBtiFAklSCAVMBEnlEi0pHKUjnj6Sweyjl4xTykBBJQgSpWioZM4e29aORDRsZH6JPlO0hAmUDSXKNRMU9PlwjUCBPduRC2dxUbWAu1aYIKAJdRUAJ0wXwl0COcis5yT5PY/BFQmhGo0oXwIUEWPAjSPLckx7x3faLd9GL5Feukl30LX1PEVAEFAFFQBFoHgGSpeJhUgqbe1JY3zNRpQrNG2DYYEhSL+QYI4/JbqR7kO1BnucaGxL39FiNQEX8Gm1q/ueh31QEWoKAEqYzYKyUqgjhw9jhXVby73IYhCHBy7dB23zGvnv+JZAjOyR67gm3eBBt8oE0OaM1Q4iePzY9AEVAEVAEFAFLIEBZXSVTgEQ+LsW9IyhBjvE4YchSNV+wTiSpUbRODCTscNdzRoPiHInAVClqCBSf2z3uRreon1cEFIEWIKCE6TSIVNrB3IEueNmljGSRr0RjByPBO/05fXwpAjY3JHpRp7Ee90Gi56L9OM0gNNp0KXb6AUVAEVAEFIHzEaDldzmRhuQOsruNPSniVoKhg9DVrs+a3eMSx1AIxkrj4pmMGfJE0wg7rMw1x6nPTrYejqURUMJUPz0gSxVYh5bjZUl9mwRhoosO9M79N/7Wj7jt90xstfvshjQFvwiJM4xaFMh1UtLUduh1B4qAIqAI9BcCzFOiCVO+CNXHPhY016EA2UaUKVuLJhnzhv465PdHw6gT5lMHok3eG1PivTUjLpAoSvhoSa5NEVAE2o+AEiZijIG2nIcGeqco6V+wagXL8HIC5g6INmm7HgKMKjkiDvHMesR/P2jMIOxeddC7Hqr6bUVAEVAEBgcB1k8yZg4wcMgubUpxax81EOF4h0iTsEbSgDRjTw5bclcsgjl1HFGnMZgtBVDPCbJ3JU4D8ivQw+wWAkqYGFlCGD+/lpfMy7TkllibAQNwLySJdutX0+B+TaQpYIcJhA+kKWDym+wuJU0NwqgfVwQUAUVg4BAgWSqBKNHQIb+6I4XtA7jVIqpUhAJkQJsNMj3akLsnR8QzNy6uqVFxwlFPo00D+oPQw+4IAoNNmEiWChUp7BUkg8hSFtbhFTrhaWs9AlANOILIaboD0nQPtSdiqH6utZpaj7NuURFQBBSBfkCA8ju43NHUIb+2C7K0LYWtA+QpDXC1+NPn1UjeUTR+KoZSHlPiwb0DRXCNTO/05/SxIqAItASBgSZMJEs0eMg8S8ERjwXuNGepJb+qczZi5Hlhh/hu+sR31y/uMRhBMNKkTRFQBBQBRUAROEGgWi6jjEcO0rsDyb7dMPeMKlUZVQKR0naCgB11nNwogAuixNwmE20aHUI5DzjpqURPfyaKQEsRGFzChDG3eFCQ9M/QRL+GwUMSRe1UhtfSH9eZG4OxjzPESJNfgl/BCAKP1QTiTKT0RUVAEVAEBhKBEhzwcpDfZZ8tS2nvGEYPsAnX+fn83wKIkx2Fbz2zE+K9OyveuQlEmji3qiHE+aDpO4pAYwgMJGEiMWI0ibbh2WcoSouaS1XUXtLWGQQYaXKNusSHfKbAvYA4QlrFvDPI614UAUVAEbAuAqytVNw5QsH4Tdy2UQ8xLlW44mlU6WrnzBHyixMFb70Lk+KZn4AhRBDlPFTFcTX09FOKwMUIDCRhKqfKkl3OGke84jYqgUOap62zCNg8diPJC34VFM+MVxwBJU2dPQO6N0VAEVAELILASb5SgflKsAuvkyUlSg2eH1btcDnFCVmeD9bjJE4sdsvXtCkCisD1EBg4wkSrcOYrpZ8gb+ktNNEaWbreL+ga32ZxWzrnBR4FISHw1grbXmN7+lVFQBFQBBSBHkOA5kulEgwd9iGRX5ICzB0qyF/Sdg0EINFzwG7c/3AROcPTxlFPI03XwFO/qggAgYEiTNViVYpHRUn9kDRkqZyG244q8br2h/C+sC0MIAIPA8Y5z+ZSzXXXTojuWBFQBBSBTiIACR4L0ebXd5FLvH5ClvLIJ1bVx7VOAyNNTppB+MV7c0Z8t2dN7SabE0oOzWu6FrT65cFFYHAIE4hRCcVoUzB5yME+nHlLSpas8cN3xZDPBNIUfBSC9TgGdJVcW+PEaC8UAUVAEWgXAowsofBsbh3mDq/WpLixV6uvpC54rUMcTnnOaEg8kOb5P1sUF+V5blfrtq9bUgQGCIGBIUzlTBm1HHKS/GvCRJkYbdJmDQRsTpspZhv8TVi8sx6x+zWfyRpnRnuhCCgCikB7EHgfWXq+YuosGRmekqXWgw3S5AgFxHdv3uQ1uUajiD7pHNt6oHWL/Y5A/xMm8CLmLeXX85JmvSVYiLP+kkaXLPTThnzAAZLkXfRK4LMgqpd7MKCrNM9CZ0i7oggoAopAyxCgTXhh9xgF45mztIPIUkZtw1uG7qcbsjkcYg+h/uH9hRppGonU3PNUnvcpWPqKInAOAv1PmMCNSumSMXlIf5+Sclbzls75LXT3ZfAjZ9Qpgc9D4keNJgcK3DLHSZsioAgoAopAHyGAKFJhEwYPjCwtbSpZ6tSppTxvOGxIk//BDTjTwmgJ5hDaFAFF4GoI9D1hquRgIY56S+lf0gj753UV62q/i658ioYPnimPBL+A1fgNHwrv6WDelROhO1UEFAFFoB0IgCwVj5KSef5OsoguVdJwqi2rwUM7oD5rm7QXd6FOk5Hn3Z4BafKpCcRZQOlrisAZCPQ1YaJleHG/IEm44uWXcsI8JpXinfErsMpLJ9I833245j2Aa96oW63GrXJutB+KgCKgCFwDATrfUYpnyNKLd1JElElbhxGABM/uBmmaHoUJxE2U8xgXu9fd4U7o7hSB3kSgrwkTC9RmXqVR2yEF4gRXPF3Isvyv1OawYQXMhfoRQUOa7F6NMln+pGkHFQFFQBG4BIEyaisVdg4k9ffnUkTNJY0sXQJYG9+2I7JE57zAF7fFHUM+kxa2bSPauul+QaBvCROjS4WdgqS+TZhCtZWcsqWe+NEiymRz2ZGY6pPQ12HUjnBplKknTpx2UhFQBBSBsxGoFIq1vKXvX5kCtZVcAWoPdao9G60OvIrcJScK23rvzpkaTe7RIZTz0JzhDiCvu+hhBPqTMGEcLqVKtdylH5O16JKOzT31M3VPuMX/CFGmewGx+zTK1FMnTzurCCgCikAdAZo87B1LFnlLmWdLUkXtpWpFJ+Q6PN26p7W4Ywhz7OPb4gdxsvu93eqK7lcR6AkE+pIw0Ua8sJWX1A+wEX8HG/FMf0WXqlyZOz3fMCrTZ/agtBn3zHkl/F8i4hxyqmNeTwwn2klFQBFQBE4hgLylMqJJ2ddrknm6JMWdI0jj+2s+PnW0vfcQUSXvzRlT1NZ7Y1Jd83rvDGqPO4hAXxKmCqzDM6i3lPomIaXjkqnD1EFMW7YrEj85uVUxx5hVOfpWcHXuNGFCAMZYcIM02ViPDjfzHPlAtddb1qWObciGY3IOuyTyX6PiRjFbh08L7XUMfN2RIqAIKAItQIAmD/n1PUSXliW/si1GiteC7eomWoeAIxyAK+2UBH97T5whvxa1bR20uqU+Q6AvCVNhB0VqYSOeeZrGAN1jq1nkQowggShV81Uh+avmK1LN4TEK7laLeO9jwkTpMcmSGw44HjANT+3e7rfjNdYzwvvUJ/eYRNmOKJP/YUD8D/ziGff02Z+eHo4ioAgoAn2MAOap4lFC0j++luyrNcxludrc1ceH3JOHhmsHVywqvi9uiQ/EiaSJ1xPaFAFF4NcI9B9hAp/IgCylnqSMLI/mDz3TMMGQ4NHdr5IGUcqCNJkIE0gfI0yILplE2bMOieNbPdIEcmQiTU47LENxC+IWgqwNhKqXisHanCi0N+KS8B9QbA/FbPtNdtgzv0vtqCKgCCgCDSJQtxDPoN6SSvEaBK/DH7e5XaY+U+gPD8UzM6ZRpg7jr7vrDQT6izAx+IJoTPLvcUkzupRFRIbRGCs3dI99rCLPqoI6UeaGfpvIGMnedbrPoBKKwZI02bwOJHWCOAUQcYKJQk9I9dB/OxzzQr8Pi/9xwMjyeonwWflnp31TBBQBRaBdCFRLZSkeJCCLfyb5d5DiwehBm4URQESJ9ZgCn98W3/15cQ2HNcpk4dOlXesOAn1FmChXKx6gUO3fEkgyzVjftZRRoyLIEQhS+ago5SSiSpQQXockXfA7otucPewUR9RpnOdo382olNUbJXmBxyHxTHmw8qVSAaufL+2fIqAIDDYCpURasm83JAMb8RJkedp6AAFYjbumYhJ8fNNYjdNFT6V5PXDetIsdQ6CvCBOjM+lfUrAuzZgaTB1DsdEdMXDEHCXK7xJlKceLkN8hGkbJXTsjYpTs0QgCkSZH1CWOEKJNjD5ZPL/JPe4W34OABGEzroVsG/2x6ecVAUVAEegcAixIm1/dluQ3L6S0e6hGD52D/tp7orW47948SnrcFNdQSKV510ZUN9BPCPQPYQIJKYF4xP/9GK48OSmnEamxYiNZKiGqhDyl8jEkeKgXRRkhc5TaFVn6BAaQJpPbFABxGnIhxwnEycKRG/aVOUzhf4jUSB4JnjZFQBFQBBQByyFQSiK6hJpLyf98JlUUrG3rIqDljr63O8SokmtiRHwPb6B4/Axk8Gq21NtnVHvfSgT6hjDRQY7ueMf/ciSlQ0RsGK2xYKMJRTleggQPRCkJy3O63uH/jrd6fhMlesO4RWAKQWccK3IRRMa8s14J/SEiLGhrnAA7DpjuUBFQBBQBReAyBLJLm6bmUu7V6mUf7cn3zXQNJ9u+NCEyuUwe8d6ekeBv7qIGYrinjKJ68gelne4ZBPqGMJUSJckuZSX5l7hxmbPiGWC+EvOUygdFE2HqGlmqg1MnTXDQc8YQaaIhBCNNViNN6I8L/Qs8DkJb7RcnSJ42RUARUAQUAesgUCuHUUZk6blknq9gUTBpnc412BPKCqWMnGIU2T39mInRrPrBVU6I202OjyFODkrbsbLnwByKx1J/3uB+LfFxkCb3dEwCX90T78Kk2N0631rivGgnuo5A3xCm/Hbe2InTUtyStZeQm1QGqSvtgizR3IF24d2ILJ3xkzNOepDnOSc8sB/HgG81yRvmJcoGfTd9EvoqBPLkPuMo9CVFQBFQBBSBbiFAZzzK8RJ/+llyb9YhxbOoLP4cgEiODBsCWapASsgiu1UU3q0WeA/VShGKEJCoD25SnJhYwgNzJkiFze0WmwcLjx7cezGXukA0SJyMcgOf7aHmiGJx8u6cBL5AlCnk66Gea1cVgfYh0DeEKbeck8S3cSms52syt/Zh1viWQYyYq1RCZKl8wEHXOmTJHAwXypDX5BiBNG/EbfKEGj/I9n6DpM4z7ZHwf40at7z27k23rggoAoqAItAIAuVUVrLLkOP99EaK2weNfLXrn61WWcqjgMVMuOumMniclwoIoCFHLPtRJ1O18NKH/p7I2N+TIkaZcCNZssFAwREKoJyHF1Eal4lGffiitR/Z0H/39KiE/+kLcY1EzfWBtXusvVME2o9AfxAmLAxlXqQl/h/HyA9iGN0ioRuePy5aQYpX2itI+RB5S3DDs2pjfSYnojckTnYQFK6eWaahK64xNwhTRHzzPkubVFgGM+2IIqAIKAKdQABEongQN0YP+dUdLBBmO7HXa++DUbFKNof6h7jhvop6USaqhNeNxLDZPYA0kXTYEG2yM9oE8wRHEMXXGX2iZM/qDUTQiVpMga/vQ5Y3IU70XZsiMOgI9D5hYvQGhCT9BFKAPx/XHOcsdFaZp1SBFK+4g9UrOONZRYZ3JkSUXiM/yDkKWQHureac5xxySuh3Ybj3+MXhZ42IM49CX1QEFAFFQBHoIAKUsOXX9yTxxx9M7pLJ++ng/hvdlclNgsSuks5CKp/GLVVz9Ps4gtTohs/4PAkSiZIjGgJpYsSJ9QQh12N0ysKNkTHPzSnkDt8Sz2TMwj3VrikCnUGg5wkTo0nMDUo9SUnq26Sl5HjsG0lSiWSJeUt0xLNyw/hNkmSPOsSJaI4hJRaKMrFuVODzoPjvB8SFOlJKmKz8Y9K+KQKKwKAgUDpG/cOXq5L+/iWiNYguWXWqAyEimTOSO0OUkrVcpbr8rl0nzOQ6QbkRgEwPxMmOiI2dOU8WjjbRYtwRCUroHx7CbGnO0n1t12nT7SoCpxHofcIEm27aiaefpo3pA227rdKqqK9Ei3MaPfDxtScRLkjVF6Xq9zzY+iG3Qu1H0kRpHqJMTuQzMXfIKs2OqJLvjs+45blB6CxnTmEVoLQfioAioAh0CgHMP/nNPUn/+Fpyb9cRqSl1as+N7QdkiXlJFeQolY9BlHBfLWJuNvlJjW2qqU8jovQ+2oTcJkOcEMWhaYQlG/vrtEvw9w8l8NlNRMfU/MGS50k71TEEep8wIWqTXclCkpeSPIwfjKFCx+C7YEeYRFhnqbRbkBIK1AqNHq7ZGP2xuaGbY3CFkR9yGW4W265ijqqiFlVLCCOjTBEHkj6hvfZaR/rG+kvuWY+EfhMWzwxkDTCq0KYIKAKKgCLQJQQw/9A5LgtXvBTsxIv7R5j4rj/XteNoWES3DBe/EnKtGAWj611XGoiInW56JE1DKMbO3CYLR5p8DxbE/+gWaiGOdQUu3akiYBUEep4wsWBt5nkGEaaUFLbyxmTBEuAi0lU6QnRpG3I8Gj00OYcYYgS5s93nkJILtaZsWYmXEpIr58GTyuKyOcXn9MmQOyruMhJM8zZIDECgkNfV7D5JxGzYn2sasjwL5TKRMLoQ+QqjgK13EcYPSpgs8VPXTigCisBgIsDoTDmdk+yzFUn98MpEbSyHBGV4IEclSvCOUKcRTnissdTVRomey4X5NYDisBGQJ5AmOuxZsLkmR8SPCFPw81sW7J12SRHoHAK9T5ggdUv9mERl8bQUIX9rmiS0EnPmLuUwkeyBMO0j5N+sTBDjpw1RFXsQSaPIKzqsHMpGYkM2jjclVcDgXymJywEC4QvLjZEbMumfkEDFL5U4NNrMmQKZpEtfM83mps04ZHksaEuDBSs0EDlnxCnhf4yI/17AcqYUVoBI+6AIKAKKQKcQoMtcYfcI8++y5F69M/lAndr3VfdTLZWQ55xBZAkuugkU07VKBIySNzjpOZEn5BgbNm56ViRNdkjx/PcXJPK/fYELEq6mXhV5/Zwi0F8I9D5hQvQm+W3CRJjKFnGhoyywfIQVLViJV1IkLU2Elzguee3iGHaJbdgu6UpKftr4WZb3l8Xr8spoMIZ7n8RzcdlPHaBGYFm+nP1Sbo/C0abiwf7LqPnUfO4UozfMZXJNwg4V7nRWGSQdKGBrCBOMHyjR06YIKAKKgCLQHQTojpdb2ZLMk2XUQNw1OUHd6cnZe2UEjE54xe1DRJZS3Y8sfdxNkibI85zhIArHx0zR248/0vXnkAv6bs1K9L9/XSvQa9FIWNdx0g70PQK9TZjAQ8qZsiT+FjeGD4zqWKHRDc/kLiHCZKI8jfIl8AA7yIo9ikKyQy4pOgvycveVvNl9g6hSWe5N3JMYCJPL6ZJMISNb8S15uvGLTEUn5f7kfZmNzoo9ZzOSwMrxSe2nRvtAwgbS5JpxwwDCgw5ZAVl0I+CQ0G9D4n8IKUPAOkTOGuhoLxQBRUAR6BwCLPaa/mUZhOktFukSxoGuc3u/bE9QeqCukoksHSZQcqRw2Re68j6jSiRNrnEQJkSbTJHbrvTk/J165idMEVvnEBz+WIRXmyIwgAj0NGEyluKQniX+AsL0PN289K3FJ56OeMVNmD3sY4BulMORqMCZjpElB+RwDr/dyO/++OpPcpQ+kkmQot/O/1ZC3iCi4zZDoPZT+/Lvr/4oxXJRbo4uItL0hbgdHqmCTFISyIK5zVqau6Y8WPmyjlseiWTwC1iLP8SKHAilOuW1+Merm1MEFAFF4IoIlBG9SX33EqZLb6UK8oRqr1f8Zvs/ZvKW4kksXh6aorRNKT3a383aHkCaaOHtjA0ZiZ7VajQxjyn41V3xzE2IA9bo2hSBQUSgtwkTpG/MW0oiwpR9DdebZnOFWnnmMV9UsmUpbhRAVJBT1WhDVIeyM+c4DBzCDhPlSeQS8n89+b8x3lfk9tgt+Wz6MyPLq286no3L35b+LtuINE1GJuUPi3+QoAcrVdDRlSgNhK05Hfuaye9iPSbnGPKYENmxQrNDpuh/EIDNKWoxqbW4FU6J9kERUAQGEQGQo9JRUpLfPJfMs2XIPRpdHWwfaKbWEmzD6dpXgdkD85gs3SjNg/TNGRsWx2hUHKjRJBaqgegcDosXeUyBBzdA6AKWhlI7pwi0C4HeJkyQvhV28xiwk5JbsghhwpzBQrp0xyvHGx+kaRvujEGKhxpIdkSX2EiY/ufP/xN8pyp3xu/IwykSJsjkTloim5C/Lf9dNo42JBYYka9vfC0jwRFjCFFhlIm1oNAfacIYiPlLpogtojlWaMxb8rIW02dB8SD6pU55Vjgr2gdFQBEYNARISgpbB4gwvZAcbMWtFF2iVLB0GIfC4giyeJpBXTPyRaMDG+Zj3r9P6MU2uVlu+7rbN5uF3XjAh/qHUTjnhY0hBF+2QmMNJvfCpIS+vi+ukYgVuqR9UAQ6jkBPEyZaihc2QZi+S0p+xSI1mBD1KkECxxymCk0oGmz2AIwWQATsIcjNTorGJnNJ+Zfn/yLpfEYWRublq/mvxO/2my1XMVAfZ4/kf738d9lL7MloaNS8PxGeEA9IlTGgAIErskYVI3Ac4Bto9hCiXZAGkjRZodE10LvoNYTJO8eif2YGs0LXtA+KgCKgCAwMApS8ZZc2Jf3Tayms7baGNLQCPcyJ5XiqFl3CvSlMe53tUiaP6I8NUR9agddrJnHupT05C/WSlF17P+yj0wFpXkjcU6M1Awi60lmgmRyrsSGJ/LevxD0xbIEeaRcUgc4j0NuECblC+Y28pL5PSP5d3hJFa0lKSjB7KCN3iNGdhhrGRjvkeO55EAHk6tTzczKFrHy/+r2sHa6ZyNLj6ceGGLlhKZ6G6cMmbMb5PonVRGTCuOVND02/l+2VUyBMSzkkvSL81aBqglEuR8wNtzyLECbYnXsWEGF6FBDfPGoxoTaTNkVAEVAEFIHOIlDJF2G2tITbshSRJ9ToYly7ekviUto5MNEl9rHp6A8kcXYSJB/UHB63JCtFSZULqIFYknypKEXI/HyYg2PegEQcmB9hKlHN4ToEBKrpBoLEKJNrMgZpPktnWEMKL5QLQooX+e+/F890zLI1o5rGXb+oCFwBgZ4nTLm1HArmJaWwaiHCtAM5AC29WbC2kUbChEKx7gUvajJ8sKWjmQNrL73Yei57yT3jkMdcJb8btuKQ423Ft+UwfSDZYtYQqS9g+jAzNPOeMJG4McLEArqMODXS2A+aT7imP0gAG/l+qz/L+lAeEEpK8nw3lDC1Gl/dniKgCCgCV0GAsrckDB+yL1bgkIf6RlZoiPrQDa+4uYc+xRH1aWy+e38IIAh2kCR7COUrUFy2DBe7twfb8u5wF0qPPBYqc5LBfSwUlkdTC3JjeEycGRSTh8mEKYyL6JuJQL3f4NUfGJvxYcjyYlFTm+nq32zvJ+1+r0T/x+8w/06ASFpDot/eI9atKwK/RqC3CRNsxHOrJ4RpvQ8IEziSPeLCgITcnFM1hpi7VMaq2dLekrzcfgFzh20YQDB6ZRO30yMhGDwMBYZkK7Elfqdfvpz/0pg/sF4TmyFMiMBV0pAPNEOYUMDWNWMhwjQLwvQIhGlRCZM5wfqPIqAIKAIdRqACgpD42y8wXFqFqVCmw3s/e3cspFs+TtTkeM32CVEeB6JKDhAWRzQsVZCnLBYt/7b0AqU9NsXrhBESXkvlcxLxBeTz2UW5NTolLjjdVWljDnv1MvKnqohuce5uuGE79qAf0vxRcYKwWaXZgUn4f/8K8+4Uyp5Y43rAKthoPwYDgd4mTJTkgTAlGWFa6xPCxAgTIiinI0z1n2Iqn5LjzJHEM3AFLCInCatpPkSZ3BjAD1C8lkVtg7Ab/93C796bPvC7hjAhx6uS6ZMIE3KXDGHSCFP9p6H3ioAioAh0FIFyOieJP/0oubcbpt5RR3d+zs6YV1Xc3jfufVVEgBpuIEIORJYMWUIuEWsOUSdSQv3D7cQRZO9ZzLcuSeUy8moHx4052BCmsSmU8nBiQRKLknXDieOkkeg13Ad8wYZojmsShAlW4zaHNWR5dq9bgv/4SHy3Z0HkajnUzRybfkcR6FUEep8wIbJkcpisJMnbg0OeyWFqQpIHswc3I0zMYToj4bMKa3FK9ArQUHP1yg3tdL6cl+/ffS/rcMkbh+nD72/8HsQJgz1WqtgYWSrQ9IGSvAYlCiaHiREmGFFYoRlJHnOYYCvuw73mMFnhrGgfFAFFYNAQKKeycvyv30p+ecsytt1VyPHya1BgJGkl3mAOMU4gZXhOuMDZhyPi8GLOO5mDSYyo8mDGLOdlkqdvV16hcHz+V4TJ/AYwx5bTGeQyHxnzCZKoRvOobOzH2DDc8tAXNwu0dz9Xl9gE4JLnvzuHfoUG7eeux6sISG8TJgu65FHyZorFwviBRKXRxnpHrlm45MH84TwHOBPmP4n0lyolYeHa/3jzF0OkFkdvCHOYPJDqsZEgVeCSV6CLYAFfalAhwH6YHCbUhbJCMy55N05c8miOoS55Vjgt2gdFQBEYIASobiijvtHx//sNDJe2GyYEbYEKfWJeVX5lHWqKHFYKG5vsGMlxUAo3Mw6FB+a7kwXHel/rW6uAOF1ImPAFIw2ENK90cAzylEVfGls8pRsfiRstxo38zQKEyYZoW+DzW6iDeENcqBWlTREYNAR6mzAVYSu+jQjTt6zDBELQYH5OW042CRPqL5Vg/FBJNEGYYLLAQrGOYbjznOQxcXJi0doCHHo4WDvsIFMYQPmYNZronvdk4ynylibk3sQ9mRmeEae9lpRZQZ5X+QiOPpuow9REYV8H6i85RjF4oz9WaKYO061ahMkzYx3CZM4Rzgfv6dLE81V7Dc/xWm2FkY9PUMSCYW3NEAULcS7Njdp1PuY9HJpsqPtRjxJaAXvtgyKgCCgCRIA1mEqHCTn+t29rluIWgIWRHBKl/MqGkcU12iW7z4t5Liyu8RGRC2RwjDRdRphI1spwzGMdqDJIU6PRLrrjOSDHc46ikC1IHCaDRg+n5Z+3wejBB7IUeLQIa3FgpE0RGDAEepow0cK7cFCQ1N8Tkn1jkcK1uCCupKGjBkEpHzVuL8qIiT2C2kcT0FEHGYpHqQfopxOwDN+CU146n5aQN4ykU6fkkMe0k9iRneSOuSB/PPNYFkcXxeeCVO1kgC3HUbR2Fzbnx+hLY4tc5k+hVoPJZepCWeFvg7ldvvt+CTwMiHvcGoVrSYjKsJjNQzOfy2Zxj0kbjwvmHo5NBfwWOJmTUOGGk2UmQJIhOzTzTljTuj0ec/Pg3uPxigdyEJ8P9rJuRBs/Wum0wnnQPigCisDgIkACUNw7lvj/+l4KG3uWAIK1kEpJ1F9a3zV1kRrtlCMaMgSFeUMXEZQrESbsvEYqj43FOSNfH1bLrtAzjPmOAAgcyJsTuVQfR7uusIWWf4SEyXtnVgKPb8FafLTl29cNKgJWR6C3CRNXceJlif8VJggvqFmuL993F/ZqDjlDJEywFm+YpDDywCgTrLwdw05oqh1ShiMe7cNf77wyNZcYYSKTolMeL9bdKFA7E52WueE5ifqjNbKE6/JKHo5BB4h2IZ+qyhpMTTQn6i+5IMerR7ua2ERLv2JHblfgcRCEKSgu4IOQTEu3f9HGiHXJEKOcZDMZyWWyksuDIOVyIEokSTkpgByViqzRgckbCch8zO/Uok6MMNXOA+JHZk5mNMmB1UwnEomdlGFgUnLhsQuP3XXi5PWJB+TJi3uf3497EipE1yyw6ngRXvqeIqAI9CcCNFco7BxJ4o8/YK7bt8RB0k68BHvz0s5+U4TJOTpkokv2U7lLZx3YVQkTCVIJxg/sD/O9GiVMlOK5EMlxwqnPEoQJUS/PrVkJfnFbPDNKmM76behr/Y1ATxMmnpoy8oQSf4lL+hdU9GaOjgVatYiBElLBIoiK4HGjeUPCKFMApAkyOHsEpAByakaT1o7WZDO+iUTTLKIVZSO7i/giMhYeQ92laWMxboeMi/sjQSpDGkjSVk4x6bRBYEjccEHuhJ04JYJWyRWy+x0S/G1IAg8CcOqpReAaPLIrf5wEiQQnB0JUYPQI9yRK6WRSksmEpHCfTqckk0qZ9xhFYsPX+C//+aTVX72Q5gH32vuwjUd1eT9Ikj8YlCBvqPsRCoclgMckTSYahagUCRbJlzZFQBFQBNqNAAvCFnYOJQmXvMLWQbt3d6XtV2jpDUtxFq0loWu0OUFOXBOjl9YYujphwvVJImmK+pYTKaxg1kf/K/SMRXNhssD+UCZoGcJ0c7pGmGbHr3AQ+hFFoL8Q6HnCVMmCMP1nQtJPU8Y2+5zr1I6eNUa6WLi2TOMH9K/hKBN7y5pMMFxgpMmOPCISlqqtlstkCBH+qUUpGKnA4EqixIYxuYrcLkrwKMVrdv825tB4QJjgjueES97JFXxtH1381wFTjPA/RJB4ioKCzPG6kHk019E6UWKEKIeo0c7WlmxvbsrezjZIEmp8IGpU+8xJfhJhr7Gk5nZ4ybfqkSTem3ONiBSleyOxUZmYnJLxiUmJDA2Z10ia6p+7ZLP6tiKgCCgCTSHAaE4eRCn155+RR2whwkSjhd0mCdNkDAQlJnYnFuIuaFcmTNgGiVJx99C45WGV84KtfvQW53QUyzXW4nDsswphct+YkuCXd8Q7Z1HC9Mk8fHKB0IbrhI/OmD4dAAR6nzDB1CCFOkwkTCXm6TSwiNOu82uc6dJIiqW9OPOYmpUKOjFo+iHZQm0mmi/QUrsW6cFf/8cDAKMhGI8pB6RMkdGlahN1l+qY2Fwo3jfkhKYbhI25VFZoOGYnsAj/Y0R89/xYCWxdRMVI5jChkQwxanS4vy8He7tyeHgo2Szkd4wy4UZ5HXORutnqhMjkO0Gq5/f5JRgOydBwTEbHxiQSHTKyPTuIVf2z3eyv7lsRUAT6C4FahOkAEaafrBVhug5hYoQJtY9aSpjiJEwHhjg1F2GKIcJkHcLkWZyWwJe3xdvJCBMXgc1KMBcoT/6OeL1jHuIeRlv1/OAKo3jmQ3y3tsDIayXOhcwX5kJw7fWT7dTVHCeLkSev6p0icCYCvU+YID3LPEtL+klKCrtIrOzutWwNZP7NgiRRDleEW57JH6r9dZ95Ei58EelKjKTQbpy1mWh6YGoP8Q+ff/vcLvcHi/UKsGBxWlOgFkSyoQH6dCe4aezHhfwlBySBNnfriMnp3TT6mGTRNeKUECJMvlv+lskEKaXLZmCRe3QkRwcHcnx8hMeHkohD6gm5HVs7I0iN4vDx50mKKN0LhkISBlmKIto0NDQiwyPDIFJhI9v7+Dv6XBFQBBSBZhGoYGGJOUzJP0KSZ5UcJhaMpSQPEa8q+tdoY90j5gzZMZZipencr185woR5uYz+FCERLKcynETO3eYnb1CSh1wqRrycQxaS5N2aOclhGvuky+14gYvPnJ/LNPQo1HKCKzAcockS7ytwayzjngue5kaMa//X1pQNEcLphPKChMmOPCxDnpxYiEYkkTcn6lwxf9iB+/oiYzuORbfZ+wj0PmECUcgtZQ1hylukeK35WXCwNPbieawuNSnLO/37IokhcSJhQqSJeU7vG1OUSJhAknh/bdKIbTtCqAeF/CXmDNVGnvd769oDU7R22iOh34IEzF3PUpwEiIYMjB4l4gk5PNiD5G4HUaU9k5/0IR+pgUmua8jUdkzixMa8JpKm8clJiY2OSXR4GHlQgfdRp9qn9V9FQBFQBJpDwJg+wCUv8e90ybOI6QMuqo0EbqM5lzxGcmj84AgFWkKYeAFfPogbwlSBxXgjhMlc4Pu9hsA5rOSSdxsueajF1A6XPINXCdcxIEMkQSRFZcjiiyRLIMNF3iAFLWPe5uu190Ga8NmrNM6PhjDRst3FG0yWUFvKxVwx3lB7i88ZYTTvG0KFz+HzFxHoq+xbP9MfCPQ8YWIkJ7+ZN5K87IuMZZzyuMpRoTwOUaYScploBGGiQdf53fB6mLlFvD/Fl7hJY77G1ZUWRNiMSx8iOY5Rdy1PiDuwQKNDnvcm5GdfBFEHAs59JrzeWMcMUcJAnANRiiOitLO9Jbvb2xKPHxvZHfOWaKhh5YjSZUfMicGJwd6FldJAICjDsZjJdRoZHZUQTCMYjeJKmjZFQBFQBJpBwNiKH8Yl/m8gTLDxtkIzdZhQJDb/brO5OkwBX61YbGwY6oVPVRXFMiIciHaUQIR2U8fy0+qSZAt5eTg9LwsjE3A3Rc4xHGxdKPmBdGMT5WIdptLeER43ZkJh6jCBuDHq5QiCwDUx17X6nBhb8fvzEnx0S9yTLajDxMsVYFlhBAn4lECMCjDuyKOWVgGus7yRKH2IIFGSV7uRfNYe4yh53XPFZhYVce1Uu69J9ky+tql5iIViutQisudGTS43XArdIK0ev8eQK5Itkic1V7oi2H34sd4nTCwUi9yl1BPkMf0ApzwSE4s0k8uURL2KjTxkclgFudpCSHd7j3nCDvc5yvFswZrm1wwu3e2V2bsDJhj+z2ApDsMHFwvpfjqnXdpL1kSKQ3K3urIsG2ureByXPCY9rlb1Mkk678DtnMCxkhbApEuTiIXFmzIxNS3+ACZhbYqAIqAINIMApFIlGBoc/z/fSH51u5kttPw7Zr2QuaZLGzA7yjV0Ic3O1IvFumYmhOTg43lvJ3Esh2lI7ECc4rmMrOzvSAHlI2aGR2UsFAVZskvEF5CJ8LAw67eSzKCkx/FJ/lJjK5ncP93xnCNDUHl4LRHhsCH64n90U/wPb4h7bOja549yuiIib+l4UjLIPcsm0oggwagKBIrvkQDzGqqT8zLP+Xv53omEj5EnP6J8AdTp8oVRTBjPtTbitU9/T26g9wkTRklK0TJP0rAXP5aKRazF678Gk1d0VIsyMbfI0g0rL8yVKgVR96kal704pBbgn15TDwhF9BCVYM0go/vFPS/Ea8VVofnuQHPC+CIIOZ7vjl+c6OfHUbaLukBClEwlZXtjA453G7K3uyvJBOQSTWjdL9qPVd9jRIn1m4YgzxufmJKp6RkZRsSJr318YWDVY9B+KQKKgHUQKIMQHP/rt5Jb3sJioDVWA+neV1jZQvF4qE0a7RMlW4guGFkeLo5JEE6PjU82VlALcUPyJewDpCkFclaBtCPg9orXhQVGzJ9zw2Py5exNcVFaBjleBUSgwuhSA1EQnmHum9ElygTteGw23uVTb4NrX+A398R/bx4LlsiraqLVSVIO5yeXwA33hQyKvKPgO8kSZXnXVuI00a9zv8JrIhBhN/PJEHXyoJiwN4haiCHccE8Jn0aczkWv797oecLEPy6uQND4If4nrOY0U3OojafVrJDAjKG4XZAKImFWqRV11iHT3MEBKV7BX5T13TV58eqFkamRMDEHhq5sLqx8OSA5oKwrhFpAzJMJwWygE80FiWD4v0TEu+CtOeRhMLtKy6Tx24D8bntrQ9ZW35k8JRaYHcTGCwCaQ0wiyjQ9Ny9jY+PGYY/n9PTFwSBio8esCCgCV0egDPlbHKYP+beI6EA6ZYVWhayruLlnbLwrzYzxiCo4/JDmxRDZCaN0BcnKSXu1vS7Lh4wqncjr6iSITOmkTYWG5f7opDhQqLZ6mJAy5GWNkiVuykY5GBz7mL/EyJcVmh2RleAfPsOC5Szcaq+uUOD1mclFwm+EcrtcMi0ZRJVyINyU3fEaqVcaZXmU6/lw/IEIaiFCNknpHnOg+J7Oob1yJpvrZ+8TppPjzr7NSvLvCdSEyFsnj6l+Tuj0QgMI5DKxPpKlVlDqfYS8jY54LFJbDdhkD5baT578LFvbmyYK43Z7xIMbI0xsjC6NQuJ1595dieG+3Y06YzdkgpH/FkXCKSUKl++Rof0iJBOU3r199UrWQZbqNZQu/3Z/f4IDe3RoWBZv35bFW7dNQVxT/PbU5N/fCOjRKQKKwHUQIBlI/PUXyb1ekwpd4CzQqiAzJUR2KIWrZLLN9QhzjSME6VUsipIewVo+01XGRRCDCghbBYSAVuIspNuUUy325Qj6xDU9XjOgaO4oWv4tO4hB+J++QB7xNEgl5uBLGomSMXIoliUD+WYCboFJnBfmKZlI0iXft/rbjCz5QJhCMAoJQ6LoYQ6ckXLiYuoK1ydWPz7t36cI9A1hovFD6ueU5F5ljETv00Pt4itYQKkwRA+yRNJUySLs3GxtpnYcBjgQDRWcYyBEETxBDaZMJiNbKNa6vLwke/t7JjmToWkHcmJImsKwq168sSiT01PGWKAd3Tq9Tdaj8i76jEOee+xiCSAHauYqHaGG0srSG1N4llbheUooGPLXZhCglSojh6Pj4zI3v4BzOWNym+qkWGFSBBQBReA8BEgIkt+9kOyLdyaiY4WFQF6Is1/F7X3UQEw0Fd3h8TKHiLlDDkQRSJ4okTOGS7wSPn0xfKJwqUKaVwGBrCAPp5xIosQHIm6Y85tp3JcDVuKu0WHMy55mNtGW7xCP6P/5tXgWJn4Veft4Z5x/Kb1j3cLMcVJSILCMJtHljg53Zg7unaDSx4f34TmILa3KjdMezpMf5DoIqaIPUUEX5IskVBpx+gBXPzzqG8JURJ5Q9nVGkt9gsEpbQ099+gfCQUTyiDQlYIe5j0HjGkVlT2/32o/BjxywDnfEUHMpjJAyrMs5IdRqE2VkaWlJ1hChSaGYK//4GaGxw1FmDHbVd+/eNYVSPciDaWtDf5woout/CMOH+3AOQi7TeY2DcSGfh/xus2bssL4mGdRSYsFZbZ8iwHPK8zeK8zk9NyczkOkx8qSk6VOs9BVFQBH4gABJQfrJkmR+WTYRnWakZx+21qJHjGrQTGBn3/TJuNNx7m20kRdhcdAGGRqjKTbIsJjDY3PiVnfQ477oqIr6QLQNryIXp8JFOcoTm9kn+4j92iEJdI2PGLJmg9upJRqjXmG/RP/H78UzM/YBg486R3kdrb8puUvBRTF7jEVs5CmVgZG5Bvro8/3ylAoYyvKY1+RH/lsAuWd+kG0uSv6KYPfLAQ/ocfQNYaLxQ34zJ8f/BhtPyt6aW9xp78+Aq1FF1maACcQRBlmaQMDlrysNAzNXzOwBrJAMYUUrxomAs8SH3nC1bhuW26uQsm3AKIFzQLFYMNapMRgGTE1OGROBAHKZaB7QNucY9MnN+ktfh8U7g/0gGnZWI8lLwdhhD31eWX4rm+vrKEhrDanIWf210muU40WiUZlH1HBmbkFoQU5rcl0hs9JZ0r4oAtZBgEQh8wYLUj+/RS2mveZJQqsPCRNV6QiyPNSJMgVjr6kqsEFRYQwgQJ5sGCd/RZgw5zBvqkqZ2UkB1escDrdtR6TCPTVWiy6BqFiiIeLmikUk+n/89kxL8XpUKQdpZgbFeim9Y3SJRg5Nk0dLHHhjneB8yZymACKEQUg66aznBgE210YWOZWNHZF++jQCfUOYzMoGokwkTMUtGCyAQFmxcWCpwgSiEkftAeQ1mUgTi812kjcxiATZnQ2RJUZuHGFMAiyGe8YfNA0Ttra25M3bN6hdlDO5S5FIRIIgSfw4HfP4OIqLbUYqTI0fhKJb2ewwo/De9Er4H1FYMHpC7D7aASNfSdRS2kBEaWXpLQrRHphIk0rwPgLqnKcc6BlVCsAQYgqGEDdu3UH9phHjgkhrcm2KgCKgCJxGgAQhD6KU/v4lisdvWufCGHMpbcVLh8fIZzrGIiUUJ81GfHjAJC38H8oKM+nVSYyZszGfc9s0LrjOPrAbzlVVRLHojOcZj4mDMsD6vk4D34XHjHq558Yk/IeHIE7RX/XAON9B1UHZXQI1p9KILBUoT6Q1+DUx+dWOeuQJo028LmINpxCw4s0TqDnqUcKnrXcR6BvCxFNQhhQv+T38/JHHVDqwsASLYytzmhBhKiPSVAbRYwHejkTFOPB78AcNWZsDkSU7SNPHkaXTP2cO4vF4HBGbZTk6OjSFT6empkyuSxbFX48Oj+CklxU3bFV5gT0UHRKv72RF5fSGrvHYOeyUwL2ABH8TwqrbpxfvjCwdHR7I8ps38m55ydRZUglec4BzJYzEd3h4RB4+/tzUbPL5/c1tTL+lCCgC/YsA5Vdwgkv+5zPkMa3USINFjpayvDKMBko0X4CbH59buZFY0Lk178OcjAvsyNiouOFK2zbVRoNgOBEp8d6dkwDqMDmjwdq3eR2D/xhVSuweyvHWvjF0YJ5SLznfNQjFlT/OHCaH22mMIaKTMQmNRI3DHgmVtt5EoK8IUwWRmjyKxCa/TUh+GXaeVm4cbCDHqyISVoEVOt3zTLQJkr12NUaRWGfJDmMHB+5tIB+GLF2yQ+YEJRIJEKYjQ5RGRkaMXIukhJI3vpeIJ8xqkg8rUZFoRMKhsLnwboWky3vTh4E6IL4bfhMZO91dTjQ7iIBRgrcGUpdAbSUlS6cRavwxzxklehMgxjdv3TW5TSRNVpm8Gz8i/YYioAi0HAHMYWXYZye/fS6Zp0tGmnbdKEvL+oh5gY51NH4o7R9dL6+oZZ06f0NVXEPnEXw4qkLmiDXBAIwmokNDUG9A0kUZYJcjTS64wAW+vCPeG1PGwY9HUgK+LDqb2Dk0UaUcrdQZUeJN23sEHJAzsm4T85oiMPLwRQImAvX+A/qgZxDoK8LEVQ060MX/Cv3sL+lazSOr/+1icKkWYQaRRHVrEKcqok4sdksXPRKq6zYSIhIl1liy+RFZCsL9Jwii5DqRF1xhBxwEjQkEIkouRJJYj6k+gDPPKQv5w/HxMQrBgqjmcybRkS56rPfjx4V203bVjIah/4wsBT5HAmUYOTWnVmcowztG1Ovty5fy7t2yqbVkBuwrHJN+5HIEKK+cgDzv5u07ptCtH9JLJU2X46afUAQGBQGaHaSQw5T5eQkOcSlr2UVjbipTmrd7BPl7EvOsRVUnnNMg4argQjoBwnScrZkUeVD/kDUOefP7/EYyXZ93O/37cs+OQxL/CM59UbFDNljgeQcZpVV46iABBzxYqGs7FwFGm5jbRHleGAWJmdtEyWW3zue5HdU3LkSgrwiTOVJwjOSPSUn/nMTKEpxZWkA6LkSwhW+SOFUyJ7lNJE8gTnArra3YkDvVb+ftk5Hek5v5QyQngvxOQJQkZBdXEI4/nk8lbedtrpHXKd3LIt9pH7lDlOnxuR+63VgsZogTV8nsyJFpqIEsOUDuWKw28DDwq8GljOgWrcJfPH0iq+9WEOGKN7Rp/fDVEGBeE4sTP3j4WKbmZmHu4fvVebjaVvRTioAi0I8IVJDUn0Ph2vSTt7DyPrAcKWGeVRl1kUqQjJXh1iYWlOYZC3O4q7mmx6SKaEQa8yjrIMaxAMlJPxKJSmwkJlRvuODS1/FFKxA6380Zifzz13BfcpjF0yRylQ5RIDgN0mR1uaOV/u4cKG4bhDRvGASUxhCmblOLc76tdLz91pf+I0w4Q7k1+P8/TSGXKVuL1vTKWQM5YpTMSPVAnqpZkCZK9mBHLpDqVfCacdUjcTqrOUGM4ELKiBKJkQ1ucgVB2BwrVvFMQmJj0NEi8tMuy2hGoRj1SafSyHs6hmMdrMjRT7roRWEUwXsXohYkc1dZWaEbnveWT4KPQrAyrdWjYASJZOwAtaFWYETx9vUrs79y2aKrh2edpx56jeeJEcVxOCLeuXf/fU7TVc5fDx2mdlURUASaQICEpLB1AEXHWxSw3ajVH2piO237CucLuPmV4dxG57xKGlJ9zB+WaJwHsSBlD6NURmyoJnXDxXMZVuV5yOA5f3IepYLDDtISDkPSxXkUtfM4h3eKOLEWlO/uvIRQtJYW4fFdFKBF1C4PYwcuXJqFXEsA2gOdwDknSaL9eIR5TcYQorU53z2AQs92sS8JUymF3JoXGUl9lzRSt55MQAQpohEEzSF4X4HTT5n5TTD8wVD56x8cB168hGkBtfKKRsbm8aMIrccpx4ljWV9fk/WNdZmdnZXpmRkz8LaLNLFjJUgfaAjBAZ85RXnUZeDKShjSgjBWyyjTu9SymtwPEjxGlzzzXnGGavUoOEAbEwoUpCVZOkZxWhIobe1DgOTIByOPsYkpuffgocltanvtrfYdjm5ZEVAEWoQAJdnlBKykny1L+sfXUEhYMHeYpAlzUBk21yU4uLGwbddJU50sIbfFMQT3V9TsMXbleJ2NC4NcfOQ8mkgiTwjRJj5n+Y5wGPMoyJMP0X6SpnYvXjkhw/PcmRP3/QVElXaE0aU8iCfPvbbmEKDaxhP0SRT1tsK4kUCpg15zWHbyW31JmBihya3mJAXzh8ImLMaZE9TDjSYGxzBcYKieIfnRkTFx4g+uHmgyAybUbodwijsEgeCYOz4xKcFAQPb39+U1iMXL1y9Nsdl5FCadnp4xMjnmFrWrmbwn9NsM9pDLsT5SBdEzkqUQDCGCSGrlRfh5q2R2FNB1T7kl8k9D4hqB1hfRMxKjNLazgmK6Szim3Z0dvGa9IsXtwrSb2+VvzO32wG78lty+c08mpqfPPXfd7KfuWxFQBDqIAC7sGWXKvlxF0fjnICSQkeE1K7YyiFIFuUwlyMiYeyXod7daXYbnBFmyhwJih5vaWY3zaA7RpmQycRJtykK1YTNqDZMnHEDNJtUKIfcAAEAASURBVKg2zptHz9pmo6+5YPQgc+OS97vhhncgRRToZb+0XR8BH2puhceHJXJCmriwrM26CPQlYSKTKMKqO/MyDWke9MssZNujf98kCayF9PLlSzk43Dch+c8ePjLEw9SFqP+2QJJev3olS3CLY7t7565MQkaVxOrUW9QlevbsqZHDxYZjIEzTMoG8FGqjmzZkqO/3gnsOquw/XfZq8oI4ajllzeBOeR4HfGMKccaA7xp1ie+e38jx6OiHaRnfzcjG2qq8fP5cdre3jA3rBbvXt1qMACdl1txauHlL7t5/KGHU3mKkUJsioAgMMAK8qF/bNfWY8u+2LZfHVD8zRu6OKA0jTbQcZzTMGEF08OKfyf8sgmsPeFHaIwwDJpAlFy6STyJL9b6evjeLj5C7U6YXh2KDjrQFFJB3QdrFxUeaQjDa1I65vAIpoG1xWoqxsKQgDSxDPaKRpdNn53qPGVViYVuSJkabfCTPSpquB2obv92fhAmA0UAht5GT5N8YZWIV7t5kTBwk95EA+uNPPxop2tjYmHz5+ZcSgeXo6YtVEpOnT56AWL2QYqkgNxYW5TbczRiBeQdThFeIyJTxGQ+iBBGE8yfGJ2QGEr0wNNHtGGhP/2YNcaoP+MdxY0+eL9SK4I6MxEwfGG1iFMPcIC/0LiJ36XewJp+AIx+iS5Qj7O/uyFPgwOK0JGG6ynUa5c48JmkaGh6WhcWbchfyvABsb9u5utmZo9K9KAKKwHUQKB7EJfP8nWR+giyPkjerNpCjKuaiEiywmddUScBNl+55mBvb2kiIcLN7IZWnrTTJEh6fluFdtn/OdyXk6max6MgSH8xv4rwYgJJkaGjY1ECsS92N6uSyDV7yfgX9LYHM5SeGpRD2IV+pexG5S7ra02/T+ZdFbocmRyU6ERMPZJo6p1rzlPYtYSLcjCyln6YwkKOQ7XGx56JMFQzsh7DNZtHYt2+RVJvPwnVuVBhhmpiYMHWOeJwkS8VCXp6AML15+waRl7wZQBcWboAgueXw4FBW11fN4EpJH3XQTORncVJGm+hkxyJ57W4c8El0OOBTk80Bv4RBmFGmKKIVvNF60zXkFv8DFKqFlbgDhXUrsAo8AGl88csvsra6IilEzZQstftsnb99EuwoJmgWtp2emzO1Qs7/tL6jCCgC/Y5AJVeQHKJLiT/9CAvvtGVlefXzQBmhyWtC0dUKI04obgv7t/rbrb0H8TDmDshTYq6SHREFG6y5GW1qptFcKY85Pp2BuRLKeVCqT7k7I03DGJd5XydOzWyf3+Hych4cL+N1STkWkSoiYtrahwB/C94AcppgBGHkeTACaQXpbV+PB3PLfU2YWMi2sAU52A8pyb/L9VQuE0kQB8LNjQ1ZBmE6ONgzxIgRoZtY3Z8HGeLAyMYcpyTyhJ6/eC5ra2sgRgXx+rBigcHT6/EZAsU6SRxkORI6EfJ1OJwgKgGZm5+T2ZlZI7XiClgnGgf8XC5nSBPtwBlFc2DACEXCEsbgPPI4JtEvh8Q3i4kF0SVOCiuQFb745amp9aSOeJ04Sxfvg7r56dk5uffwM5lETtx1J+iL96bvKgKKgJURoEyruHssib88wZy7D4dXC0eZ6kBiAY/FbSsgSxUQpzLymqogflVEbUwe1nVEKZxKkWdsh2zOhkgSneYclFthXmb+Uisa5/0MCsfTBCmZgpIGxha0HmexW14bsHbTaRVKI/vMY47OgM/lhhEJi+Li3eNu5Ov62SYQIGmiJC86NSpDUzFxMQLZoWuyJro7kF/pa8LEM1pGXSMTZXqWkeJeobZ0YvFTbSIxIDc72zuyipyd/T3UO8BqEsO0rINDOd2dO3cQIRo2q1SFQkG2N7eE+Uu7u7vGlpQDJW91NzwOrgzf80bdbCQUMcYPU8hlYrQqCC10p/84GUHjgH/I2k2QGJSrZfFNBmTinyZl8uspWG5ipQyTzvLbN/Lq+TPZ3to05NDip29gusff4r3PPpM7d+8hnwm2uDhX2hQBRWAwEaBbXvrFO8nCMa+0f9wzIHC+pSyvTpx4z+eU7hmHXbyPBxdfO5Ag0aoWczQlVjYsStpNrhKMjZinBEe0ZiNKlwHJOT2VTskurhMyuGdj+ZChKAqkohYiVSVXHZuJRQnkN4NjT0GOZ58ZNflW7er7Zcc2cO/jdxQcxqLxHHLMR4dR3LY15HrgcGzTAfc9YWLuUvEABhAwf8g8S2EV6ZKBr01AN7JZkhu64q2uvjMEiJEhmiaQALH6N+25b926DSe8CeOQw2jNEkjFBqJRXG1idIqkiASL2+KtTqAqGBAp02NUyRg/IJ+JFtFXHVAbOY7LPsvBmX0tYcDPwNDhIHso+4EDKUwUJHYzJnMLc3DS88rbVy9ldXnJkD1+R5s1EOBvZhhyztt378sifo9+aOk7TbqtgYT2QhFQBBitKR4kkDf8VPLLW+3PC2oh5GZewVzEwrYVzJfGEIIRJxTmZcSJEr73BVrrc5ARZOAfI7kDUWI0CXJlyu0YUbIjKsPnhkRhPm5Xq8+jeSycsowHbxnI3rnYSPtx3uqlPOyXRCxIltJQqEBUKWXkWrkmR8xxtKvvut1PEXCAaAeiIRmD2YYvgkXjFkUkP92TvtIoAn1PmChBMwYQy1lJPYE0D0Vt+dzKjRK1jfV1EKZVM/jVV5BIdEiYeFtYWJBZ5I8w4TMNMvUUcrUDWIgzEmWKyWFg9OJzzP+hvjmCCBKT9Tm4cnvjY+MyOTWFi9zuJxiyT1Un+hUtSnw0IRulTTlKHJlVvSqSXPMgUyUM4rxA1wty6/xyeS6Y+zY1PSN37j8w953IhbMOAtoTRUAReI8A5pkKIjMJEKYsIk2VZOb9W730wJAn1D00ESZEWjCBGrJUBZEioTJyPR4Qxj9zAxmyYTGTBg4mEnPquXm/QwfPflNtks3hWgflN5KJJNz0iiZfOYz5P4IcYV5DnDeP8vtpfD6FuTYP0ueEc5sTkjzmX2nrIAL4XblAmkJjQzI8My6BIcgisfitrfsI9D9hOsG4FC9JbglmA98kUMyWA1/3wT+vBxz0WGOIUjzWMUojzH50fGQc7kiW6NU/iejS/PyCCb3TBOHp06cm54n5PcUSVsQwyNPUgTbQToTka7rmoMkXovyNOShTIExBRKu6TUIoYXCi1pLvkV+qk1U5yB3Im9ev5SVzspaXDHEiMaQNOQ0ruhENO+9cDfrr/O3wN7SweEsefPbIWI3r4D7ovwo9/kFGgLK8zNMlKawgytQ3je56IE6YVwX/oxRSrWH8I0kybncWOVYukjKfydRuQrSJJkskQ7wWCEGKH0INRLrlnp73qTwp4tjiWKzNsrYhzCncyKNxwL2tk6TPIhB2vRvmmgjXaMOz48hnGoUhhN9IPbvesQHvwMAQJhazLR0WJfld0hhAkEBZtVGmxnpFHOhYR4k5PsxNYu0iapPBIExS59jomAm183PrkOOZyBLey0Kix9cmxsdlFJ8xJIMrYBjcs8gZMjlRMJSgpC8Ke3K6nnWzOcNOYyMe+AKueFGHlKolIzH85m9/lec0eoDMkIN2bcAPmagaXf70wrybZ+3DvnkeRvFbe/DZY5kFiffB9VCbIqAIDCYClOWlkceU+f6lkbK9j8j0AxwgFp80zE1WayRINFditCkJR9oECt+yAK4X82bdFKJeu4l9L+LzKSzUprHYWkJ0wxVDjT3cziuoa7Xj7cf+8HrNB2keCRMtx510VrTgb60fsT/vmAaGMBGAar4q+R3kA4E05VaY2HnG4HceUh1+nQMeV7NSIDYkOLyN06ABF6Z8j6taLFzH4rV8TpkdG0kTHfH2QLAowRtF3SYSpvofGj93dHgoO4hgkYDwfUZv6u939DCpaHBgULjlE/8jrHpN12ou5TDIv0He0o/ffWPI4sGJKUQeRJBEiccVgVtgPdrUlb53FCjr74wkidK8x19+JTGQdLvKOKx/0rSHikAbEKCZT+7thiT/+hS1jlKYZ627ONmGw7fUJhltYv0kEqdDzPvMb2JOM+d8mkaFgmEoVpySw7XGMebXEn0rIAFz0XAAVuJWipxZCtgOdYbzaAjEdXQB6RMgTw7NZ+oQ8mfvZqAIE/OZaDWeeZkxBhD5DVifWliax1PGCBPleZTd0aSBUaH3K3ZnrDYwOkUbbhpA0FZ0bByECMSoTipIrritzU04zoE8jYGAxUZH379/9s+kPa/SMtw1iRWvRwHx3UYulRsmFZAUbm9uyMtnz+TdCmQdWBUzumxUGedgTzJI0sckVg74vNHQon587empbvUyBBhlojTv8Ve/geX9onl82Xf0fUVAEehPBIr7MB6gY97z5Vpdpv48zJ45Kl4XcB6lmx7nUMr1OGcy2uTH4qMNC5EZfIZmFc6xYRNhMote1gue9QzmLeko8HfBPIS1mWLzU+INQZp3xnVfS/alG7kUgcEiTIQDpKkIaV72NUjT87SUjmAfCic9qzbWKdoCuSFJIGEiubmskWStw47cSKVg7jAE2d3pPzK66jECtQ+TiJGREWMr3ulkfZsLeUtRuME8Dopv0SfOIaeJlGVgWkEL8VfPn0sChW050LP9qnYTJAaMNnFADzK3CQM+V8yYl3X6OC/DSd9vLQIu4D8HSd69B5/JzPx8azeuW1MEFIGeQaACd7ni7qGkvnkh+fVdqcJBT1v3ESgiusQ5loXj6bybx3UFZBvIVfKLA/c+SL88uDh30AZdL8y7f8LQA6qJSJRG5pBCgXNDAoWTY4m+DVonBo8w4Qwzn6mAmkyZZ2nJvclKKQHJQO263HLnn/I5Fq9l2HxsYtxU8r6skxnI+DYQpWHi5ygIFknW6XwfyvZoP04XPp+PdZ3GTbJ+xwZI/K2TIHlBlEJfwDZzCDlUeI1Sgf3dHXn680/ybmkJzz+dZEmcUqk0bNcPzTFw1YyRDUr0WKyPkj2NOF32C2nP+/yNMZr58NHn8uDxY2M20rHfVHsOSbeqCCgCTSJQQfHa1M9vUJdpBfnDiQ/KiCa3p19rHQJ0z4tDsbFzcChJzLNlOPu5YCwQWpyRwHhM3CjnYYfcX8fv1mF+nS1RikdpXmwO0rwhSPNg/KWt8wgMJGFilIlRpcI2B3SssqzkpJylfWjnT8Ble6RV+Nr6GiIpyDeCvC6CmgqXNRpGbO9sm2RPOuXRPvw0YaIsj59ZA2Ei4Yig6Oj0zPSvPnPZPpp+nxppv0O8N1CR/AvUeYi5UQ29ZplJovfm5Qt59fK5HCFvqR5d+nhfdXmBKXoLQsnv8ZhYB4jRtHq0icfcjQGffWH+GZ2H6o/NPQ8Er5mGFSKzRsR73Fgfw7gtnTzvRr9rHbvev8T81p278vDzL2R4JGbI6/W2qN9WBBSBXkSArnKFnUNJ//gaDrUbpqbR+/GvFw+oj/rMuSmLuf8Ac2ccZTto9pBxYw6KwlhqZMhYkNdNIXp1Luqj02UiSm7IJYdnJ2AAERNPQCOA3Ti/g0mYiDSuWys5JKeu5WGBmpLCZqFGmk6uZ7txMj7eJy+692D2sLa2JjFI52InBg0ff+7j56zjRLkdZXd0wZudnf3EiruIwXJ/b18ODg/MRe3i4iIKpKHgHi5429bAEBw+h7jnveK/7xfvLFaxkLdE5kASdIS+/Pjdt7K2smyIHEnGeY3vMSLFY6UEkU5AdAZkdIkRJxbrM1XOWUgQJKTdzRAi9IkJzyXciugXZZQkpMwVY18ZHasdE0w7DDGym8ghXQrf3xAhc/M8QG7YLcJ3XaxGxyfkzr17IE73xIsIpjZFQBEYQAQwfJeRe5pDEdvs8xXMsfsqzbPIz4AFallvKYHivCjPK0WvU/JBD8hTWorII2b5Eqo2eKPU/bzaTRY5nIHoBq8J/CC0IyBNkQlYvmuUqePnfXAJE6HmgJ4pS341Z/KZcrg3znnnX6d39ATxIpuGDzRomEL+0jBI01UuQHmhfoxaS5TlMamThOnj/B5jOZrJYtsbxmp8DkVwg7Asb6fFuN0LLS7Iku9+wDjiORBpqtezYF7VBiJeT378Hse8fUIsrgY3SQmjTcz3SkKXzeOngx4leow4UabXztpNJLbcJ/OqSNro8leCZp/njyYWdCki3rWIWS3qVCNMiCzZHYY0OTH4ORxO43zIfDKv12fOtacH606x7zP4Pf329/8gIUy4bSXhV/uJ6KcUAUWgCwgwylROIV/45apkf4HM+jD5Icrehf7oLs1lj+R4jVBAzSU4GNrCyF8aiUgVeTKpdBJSvQRUG7WiwzRXiqLgbZC1mzAvnegiFMZuIIBFVofLAZvxMRhATIo3qAYQnT4Ng02YgHaV1clzqHuEoraZFxkpbJA01V7v9Mk4vT9GIkgEdra3TQ2meSTRc+BiYv1lzeT5IOrCHCUSoOnpaRN1OR1p4fYZDSEZo91oCLkntC2nnK3lDQEekiXPjEf890CWGFnysyp6LfLDvsRRmPf50yey/PYtokWou9RA4/freDGZlcSJxAVhHGOdTuLE4+KA38qLd+LMSB3ljSR8OZA27reAiYjkiH2qt9rDD8/rr/O+fl7qJIr5al6s8HkxWTHHjCSZxKlXcrN4HLQW/83v/wCjkinT99PHq48VAUVgcBDgghKjS5lfliX7ahVRJuQMnxobBweJ7h8pZ6Ayzkca81YcpKnkRO7SKGoxxuiU567VbsIcxnmUyg3OZ1x8ZAkSFo7nfMRrivqc1f0jGrAe4JIpOByR4RlI81CfyY7cM22dQ2DgCZOBGqNIOY1I03pe0j8kpLBfNCSKEahuNV5ss8gsCdMhokWUzNEN7iqREvNd6JJXllfMRTtNHYYQnTqLLDBHikVxedG/cOOG0S6f9bmmccAfuANkyTXhNo54nmkv6jt8iCxxuyRuW1ub8t3f/2rqTZGENNN43CQxlOnROvUIuHHA5yBPsslbK0wh3u8HJIlSQNq45xFV4r75Hm/XaiAcJqcJ9y6XW/yYrCLoO0kfJytj93qtHbT/y5RF3r77QG5Dmse6WdoUAUVgcBGo5ApQciCv9pvnUoLluNZm6s5vgXNTFsqHJOR4WczNtgjziFGkNoSFUsw3bPwM1RFUbewf7KMMScrMbYw20VWX5ImKFV4nWIU4mTkX0y5mX/7zofEY+QzHZpW+fuhcc49cXreEQHKn7y2Kw60lVZpDsblvKWE6wQ313UxOU3EHtQp+QGHbNUSaUOi2W40RCg5UlKdxpefWnTtmoLrqHz1Jw9rqOxP5YK2i8YnJM8kWSdn+/p6sr28IZXl01COpaEnjYIXCtN6bPgl8jkF2DIOs79NBNo3aEKtwxfv+m/8UPr4u4eD3KZFj1McQJ0TQ+JzFVWOxmJHpccBvpnHb9eLAcTj1peHYV4bsjq9ft99n9YfnmwSJ54TytigMOmhu0VJSe9aOr/kaiR1rhn359e9lcnqmbyara8KiX1cEBhMBjpvJjOTebUn6+1dS3DseTBy6fNSMLiUxFyZAmKqwDnciF8YZgoEA5pjTjXMZr0EoKU8mkmbx8RDzncvpMnlNdeJE1UO3m+krZe+4MZpp5uIT1mTmTxA7usxxHr3q9VO3j+mi/fMYfJGgTN9fFF84oMVsLwKrxe8pYToFKOV51QIc5N5lJQu7cUacKog8daNOEwcrXuzv7+0iepGXxVu3GpLLUc7HqA2L1Pr9AdTHmT+TMPHi/wj7WQFhYQSGhWwZeueKzHUai9IaN7wF5CzdgqQMkSWbB6s8JzK809veRj9fP38mb1+/MtGh0+9d53E92lQ3heCKmUmcBHFiMmt9peyqgyi3R4KZAF7ElblKJGKdaCRIbjckjVjdC+H88FxRunfVvneij6f3wX4xIvrFb76WhZu3DOGzal9P91sfKwKKQHsQqPKiNpWVNKzGc283pHTQmPS6Pb0arK3mMYclMGdl4EzrRGTJAYtquxtlPS5onOM4d5p5FPMery1c+A6vE6KRqJHsdYo4kQyZnGD0qVxEXjCOp4I8uSrvef2G938dYsKlDK45OH8yX9iGXGHK2EigaHLloKTtmtc6F0DXtrdo+z48C+UQ6maxRpO2ziCghOkMnJnTlN/KY1AnacohUbXzxW05ENDBjpI5jgHzCwsgPlf/w2BInQ57tOfmYEbCddagxgEmDWvRtXer0DaXTQSGpImSsKYGEn7tpCgtc5Z89/y1yBLd8M5o3P/rly/kl59+lEOE/9nvVjcSHR6jqXAOCV0eAz5leiRNHPSvItNjv0iWaKbBWxF5SrXBudW9vXh7PIf8HQzBspvEiQYRViUizL26e//he1keJyxtioAiMMAIYLzPM58Jrnk5GEFUUCsQ9RcGGJDOHTpRToFopDEVlxCZcI5GxW6KoF7eB851nEfrUnfOpyQi9dwmlj1hrlO75iJeDxmihHnYGCqhMHIZxkplkCW+Zy6SLjkM9tdGsoQ5lGTJ6cENxI/PSaLM/HS9deJLetC6t+mQ58U5nLwNs67YUNtwb12P+2NLSpjOOo8YWRhVKh4VJfsWifyINpVBmioF6PY6NLZzcNpDEVfmL1HeNDs7Zwaks7p71mv1wY0ue5SM3blz1xhGnDWgUb7HArnMZQrBVW9yeuq9RvmsbZ/7GgYbmjs4R1ziQ50l322fOCIYjJBYWnfDO/1dDsIkIj9//538/OMPbSUhRl6AfbG6OU0ueM8WIPmAZJH5QefpshmFM4QL30vEj7HCVsT43L2iXcxjI1GifJI1tKxKmvi7pRzv/meP4Jo3fyZhP/170MeKgCLQ/wgw0pR7ty2ZJ0tS3NqDU23+She8/Y9Me4+wjPk2XgX2kOLZRsKYq7HYxghLA43XFbxeoCkEc4QZeXKDdLE+ZN2Rlot6dck45/i6CoPzFl8/6xrkrC7wu4ao4fdSArEuQmlTRC4c52OqgUiSzOUY7q/cuKDLixEsCNsZeUKkyQ0cXLjVyBOiUOij1Rsx5LmburdgzB+cTaYYWP04rdY/JUwXnBFajJfisItGjabcGzjoIepUzuGP0/yxXvDFFrzFgYmSOq7ocPWGxWcbyS3iqgsHM26D9zchi2IOz1mmESQTNH149+6dGaDGxsZRvwmJoBj4rtqYq0TnO/cULLFBljzTGIBAlvj6WWSJ22Uf43C0e/LDd/Li2S9m31fdXzOfqxM0DvgkTBz0SYRY94gmBYw4fewCxO+kIUNgjSj2lYM/ddLdbpx4aoV6hyUKwkdyYrWBnn2kWcXDx18gynTfENJu46b7VwQUge4jUE7n4Jy3hxqIS5hX96WSRaSpkQvf7h9CT/WAlKIAgpD0u6UIG3E7C582SJbqB8zrBSPTg7EU85uSyYRZ+OT1SQQSvVA4ZBZ37Ta7iUpxIZbfYTSKjrVXua7gvFsBUaIBVD6NMh2MKOF5FSoYQ5bqnbnmPedMI9FDxMaFCJnbDzdaRJ342lWJ3TW70PzXcWk1ModyMzPjEoiGrN/f5o/UMt9UwnTJqTC24xnYom5DovcOdXZgP15J4Y8WZKqdjZGXjfV1c1E/PDQso+NjDV1wcsCh1nhzY8OQLho6UH52ni05CdoabMhJIjioTZGgYQC5SmO+kiOMEPEiitGizpJrHGFu1Fg6K1/p9PY46G6ur8nzJ0/k3crS6bfa+pjYmAEfRJLEyRAhYMVIDUkT84Pq8gJiuLu9ZfKWSLSs1Eh+DWkaHpEI6k01a2TRrmPihMOaTIwwPXj0CH0N6qDeLrB1u4pALyHAC2JElrIrW5J5toxI00HNOQ+va2s9AhVEUvIoeprxuaREZzUQhOs2SvgLiPxw0TGOUiB0jLWBJFGtUZ9Dc/mcLC8tQwaflxHMU7wOoaT8IjJi5mcQpCIWcQsofFzMwbWYi5Tt/G1grqLMjQ50zA8icbJyjnD93PmHwiBNEzKM2kwkedrai4ASpqvgy6BSHqsqkOiRNBU2EBreRWgYxKkdEj0zYOBCfQ1kIosCcoz4DI8MG93tVbrLz3AbjIRsoM4SjSPGUBdnGA5xjKCc1fj5/T1ajO/w26bYbTCEsP0F4WmMMWIPodjqmMtElLxzcN0ZQjjec7YE7+P9koC8QmSJOUyUH3a61VfKSJhIFJmjxIGcJISk0YUIWx4D/gFywRiBI0ZWauwrSVMAMspR5J0xSnZWBLGbfSZBv3n7jjwAaRqOjVquf93ERvetCAw0AlBqlOict7KJ+kzrUtw5lCpkV9pai4AdpgBVRCASAbfAG09w1dKyxjmRi60ZRJsS8YRZgOS8TsUD56J0Ji07SAsgsaJq5RaULqOQkp+3uEfVCWV3+Qyus+ByWwZx6uS8S9JBeZvL5xGPHzWnkOdkNeXG6ZNHgscI0+jCtMnJuoiInv6ePm4OASVMV8UN18r8wyVxyq8i2rTEIrcgTRm4s+C1VhInXsjzAp0RpgKiMIz2MPLRTP2dbURHdrZ3TDicNs8Mi5/XKN1jIdsUQuwT4xMygoGNA98nDXzIDhMHRwASvBm44C1CgoditDR7MFElEKmrtCwG2e//8+9w6HtrXOeu8p1Wf8acU+KNwZnEiYYOfMwB3YVVuQoifXxuEktbvfMWbY/uecOoj0FCTKMFKw2alF9Mz87KvYef4X7+7N9Ti3DQzSgCikBvIVBF0n4ZF8e5JZAmmEAUdxBp0sK2rTmJzNFBtMQ1OyYV1O3ZQxSoCGzbQUC4TapiTI4w7MeZ3xQ/xnyKlAJak3NO8kFtMIu5YB6OveZ65qPF2BpZQtQxmUZkCQ7F+G2gs63BopGtoK+81vIGoZjBzZAmvIaDaGQrHfksCV54fETGbkyLD7W07C2IHHak4z26EyVMTZy4ShHOLIgu5eCgl32ZkfwaHNNaKNHjwMGBh3I6DhccZJqtvbMPlz0aP3BAm8F2OFCd1zjg8bP7iKj4A36Znpk9MyLFWkrMVfLdD4hn0o06DgzxNz6YpHGMf/r//tXI8iiR62YjPlwpY6HbQzgLEgdT9BYJrRzsrURCPsbJTEaQObDWFq286QBklcZVRppT3L73UG7dvdtQHp5VjkH7oQgoAu1DwMjeGVWAEUTqh5cobHtcI03t2+VAbJlkyXt7Vpzz45JFLvH22zVYcbfehfY0mEa1UYLUHguvr1+9ltW1VZOz5PVA5oZFSKYFLC4u1iT/kMDX51WqYQqILmaOkybCZIUFSpImd8ArgaGIketdpLY5jUEnHxM/P6KHtBiPgDi5cL2irX0IKGFqEttqGRfYqNFU3C8iabWABFbI9PDY1G3iqsg1FkboAsNox9bWlhlsFhYWmnZC4woPL/5ZN2jhxg0TiTjvkDnYUZpGeRyd4Kamp80AR20vI0f2ADS+Mad4prBqBaLkGnWLg4VoaezQYCM5YTTnzyBMO9vbIHRYTbJAI2nMQJNNsho/PjL26q0aKOuTw+nDbNVqnxMFBUmWRhBlot24VWQExI7Sztt378nDz784k4CfxkMfKwKKwOAhQNJUhvy8uHkgmVermFMPpAK5XlciDL0MP6MgiDo4kK/kXZhEXvG0FF0OiR/G5WBt2xgptPPwOJ9lUZ9wbXVNlpaXzHUMzy1f5/UFSRMVMyRNlOZRwcL38pms5HC+mbNEswdLNGDJax/mM/lCQSN5a9W1QKuOj9cUlA9GUYA4toC8c/RVW/sQUMJ0TWxpP15KlqS4DdK0A+vLvYKUjksmv6nZqBOjLbS+3oO7DI0XFkCYzpTGXaHvjFTtYzvUEd/AIMXV/vP+6Dlw0eSAOTusARWFkcAokgmDo3C2QW6SK+YS9wSSIsdBlBhVaoIo1buch8xtd2db/v4ff0atqb36y12/J5GjHJLFdOMgdMTkuo31HZwYeB0OYIYBDv+YC4EKkmZJ0LjP6+6Hybb8jTCXiefYKlEmHi8nyZu378pXv/s98q3Ol4ReF2f9viKgCPQuAhwDq4iA5NZ2JL+8JYW1XSnHUyjxYZEL6B6AlnWVHMOoLbgwAbI0hTk7KkmQpb3VLUnvHdfME9p4HJzLKMej4y4XfGn2QGkdr2mY28RzzPzgG1i85Y3mEIx6ZRNpyafSNRleG/vX8KYxf1H25kPNI28wYMkIDmV4IUguJ2/PmyK25hqj4QPVL1wFASVMV0Hpss9QassVsgyKqh2UjESP5KmcwMVwFlWokePEiNRVG0mLKToL0sILTNZguooV51nbZ/4NJWYcwKgdHh0bu5B8cUA7ThzL5t66lBxlWfjshkw/mhUvcpRImBw+RJsusAo/qw9nvcaI1/q7FfkJNZiOEcmxSiP2LPbLgsFZJKw22zhokZjaToq1OhAB4jk0r+E9vm9DGJKRtSImjBImlBKkDFyFa7Zxm8MjMUOarERM2K8bSPb9+h/+0dSN4nNtioAioAh8ggBJE8bAws6x5JY3QJw2pXSU1LymT4D66AUqQECWnGPD4r05hTqIU1jUhBsdZGX769uyCzleAVbu112Y+2ivnzzlAiDTAEiWSJwKRdhM0NwDr3NupWse5zhGl25jTpiZnkW/EF1C/jQNHizZMF3RCMIfQdQOOU3N5JK39bjQvwDc8ibvLJh7dctrH9pKmFqILUkRI04VkKRyClGnA8j1EHkqkjzBmryKwrd835CnC/gTV2IoU6NNJ2VWrMHULGHiQEXp25s3r2UCOS5jiEDQKe9XF634gyMJYh6SHcYNacnIWmpdluPL8uAPD+Sz38ISegiDb93UoQWYHSMx9O2rl/ISLnlJkCcrNE4mdMrbhv6a2JPANNMoh2O0xwPdNhiSpLBNkiJOFDztJE0OECkWzQ0h1O/BREdHINZ7ykHOUMIqHWa2ZnZtHPMoy4uBGP/qHDe1tdZ9aXZ+ARGm3yH6Nd70b7l1vdEtKQKKgJURqEASXmbUYX0XxeM3pIToSBV5Thpt+uisceENEQY7cm3ckzD9uTmN/OIYynpg7kFkhGRlD8RzpwP5S+wZ5zhev9BqnM55Jcx7jDrxOoQ3LuDydQ8IyDjmqNHhUclDisfCtO0mcx8h19BTkhBK87yYr92QwJ2n0mlooy38MCNgo4vIUR8bMnWkWrhp3dQpBJQwnQKjlQ9Jiio5EqeylJPIdQJ5olyPt3Icznowjjgvz4lyNebQZKDrHUJR0vGJ8abtmLlax7ykly9fSK2e07jJSzp9MW13Q6sbpT14LS+pEkBNpoN1+fN3f5a5m3Py5W++NLrjVuJDGd7zp09k+e0bkzPUym03uy3mjiWYO7a50bSNOHGlBG0IrnUuuNdloMk+ih+jSzZxYrWPuWAVTGJZvM4JxA/r0knU2PKDxBYw0TBvimSNk0wzjVI8Fg+cW1gweUynz3Mz22vVd6amZ+TxV7+RSdwTH22KgCKgCFyEgHHQQ/ShsHskebjoFUCeGG1qdjHpon317HsgSy7IsYwEb35CnMMwKPBhfMU8RLJUBBEhYdpbgYEUnneikfhw/iJ5MouEjBrixsc18lRbiMRsKJUCyBTqcfE9SzfgWXPO80Geh3wmFLe1ytxK3DwoRDw8i3pM06jXCUKnrT0IKGFqD661rXJ8wo0DFYlT8RirZsxvSoBEpXGfoqUqBpYsclhyGFTgtGeiHMihWYO7TAmrbMxHYcTgOvV1mMfECBOLsTInaXQa9XACTlNc1gEjB0cQt7BTnCBNvAkWp3b2duSPf/qj6c9duJt99dVXLR0gdhFBe/LT95DlvTOrTu08DVfdNlfGDkHkmPNF+UCjjQMoMY5EhyQKosvCdzlsk8TXYaJOtRymMiaHLEjx7s6eqVMxOhqTGRYKhmsQydIRpJi8b8YpiH1gPaY5RHRYiNcq8oExRDcfPn4s8wuLVy6I3Cj++nlFQBHoLwQ4d1YxDxYRYSps7Ep+Y8/Ua6og2iQdIgBWRJRSO9ZXco0Po6QHLpIxp7vglmYK0kIxwsb5I4vozf7KphwBu25HcE7vn4uT+VRGMvEkcpiaWxysHWUH/8XcShc6X12ahzndKs3lhfEDIoyxeRh9QDaorT0IKGFqD66fbpXEiTIrLKRUIM0jgSrFQZoMgUK4Gs8p5avky5LAKtrSqzfms1MTUzIUHRY7/nsv5eO2ToWn8HfMAIZZVYKtG+R1eIh7ocwOjxkCf/vureQreZnAH9TiZ4vijkLvHEVOUhSGBCBPlNthFzVShId06fvpp59keXlZYiBs//zP/2wiA60KRW9trMsP335j5G9F6Jyt0OiOR0fBOOSCjP400khUXC43yFLUyOFO10OqTxT1FSmcPpDoirxbXZd1RBK9GOxu3byJCGDUEDWSJRLKPOR5zUSa/P6ATMDhkMSpWbOQRo79Kp9lTa+792vW4j6fDuhXwUw/owgoAkCA8x2jE7jALmwfSu4NitzuHUG5gWLiIFOYWAcHppNcJccQxvapUfHemBQ3Ikz2/5+99/Bv6kq3/h9Lci+4gSvYpncIgSSQnpnJ3Dvvnc/8qb/7zv1NvZPMJCEhCWSSEDrGxr33XnnXdwsR47hIssqx2TsRklXO2Xsd6Zy99nqe9aiAqbvmr0ECUjIli/aRzn6bFF5BwYnrIW54c5PTtiAFcafKF9fVHIXM0ZZU82lOeVKYTKzivKuvBnOWPOUQ55NHLOOlnTQWIPNLCq0Eq3HVaQxKoy+l+8utRhFBRVLA3HwwKJ3bQ/3whClbB9NdBJ6f6J8/JoRvcWLR+lv77ccb31vuitzFGo9YRWGFqUS3C/FzznvkQbG6xsdFbmSQpqxE8o9Eqwp0K9JNylFIBg1hPZ5ZnbH73Q+sd7TXmuSk8tbVt+Siph87n4Vt6f/1DbWlX5P2GzduuJMPhKlKYWaoIKlo3Z0ddvPGVzKkGE6YnKRi/xttA6LSr3A8DCkSDRHgpFymUDhc6iAq8RDLru4e1anocirQiaMiTFKluKihblELa1xOiRT3TbShclXtP+DCOXFZDEJDcTt67LgK2J7zTnlBOCC+Dx6B3YaAzo2xML251h6bk/34sogAznpr1g9326ji76+u1SGFW+UqR6nwVLPlN0RzlTYrIUGEynivHG+lLs2OTwYGI8jvrMjSnBwQMTvaybFj/hJSJEeuwhBXcp7ZyNS4dcnhdmhs2OVSMbkpEFHaX1ZldRXVVl6ikhvxI77hO3NFTkuqKyxPC52xRdAN35jBJ/kOUI+p/mSzyFwZE7sM7v3V2ZUnTAE61ihI83Ky6XzSad/d/M4q91XY+bMXrKKswnKeRWOSUajcbX2/4T0oRE5V0h8iULHHs4sz9qSzze7cvWMH6g7Yu++++0vjh3XbgzCQoPnll19ad3e3HZECcl4hVdiA7rSxwtT5tN2+VsjfhPJ7YgrMTre7k8/Th0nVrOrt7nIFaxPpEydNwt8qpcRVVe93StzaEynbisVvc496Nauwy77+AVcJHUybmw7ZPtVPorlQCswn5DRETlMifeHzucoRgrwdqK1VjlQw1BwKFjYdPmLnLl5ydaLop28eAY+ARyAhBFgnVKjZyvSc8oInpDiNKFRv2Fb0eBXjAFlYB0VJSWhcG72ZOa+uLS78ToQg90CV5TXq+lJXZRGFhUGeYsrKRh8nf2lYduKQJmocBaFxLYPIEYpHSB6W40k14RLJiyhfR2YXIi5TczPWozSCXtWQhBEV6rlcESnWlFdkS1+Qm28HKqqsoqjMllUgl+eS/Z6g5hTIZMHVZgqKyiQ8CMVrONVipbKS34xEJ4W1/9ALBDxhegFFMB7MaqL8+PFj++GHH2QnftBef/31X5g0JNrTmFp0/fp1K5FN+dtvv+2Iz3bOe5zcCMu7d++eU5k++ugja1CoVzzqyVZ9ZIWpve2JffX5v2xG+VVBaJAY6i71KlQQ84VEGnhQLBZVB1fD9flmhNVhvDGh27xO1ssKG+B+QUpSnkwa6kVsUO8IzaPFCBbmE6NSmpYID9SxiLeRO1VYUGgNhw45tSvez6Xzfc4ev6nZXrt8xZG5dO7Lb9sj4BHY+wis4sAmJ72lwXEXokee0/KoDHNEphTLvLsBgChpMh7WxDxStU8lPXSTAxp1lZxdOCH327Ql5Xn1t3XZRJ+uIXPBCHtnwZAwPMLxluaidZm2GcYvXmYxEtMFjA5wrstRYd7Wp23W0dtt5Ac31NRZlRYh8xQiT1uU263QtBKFgkOcsDGnD9R/SqY5F1ypTMUy2MgXYQtKo2ht3ckWK9P3hDmAb6lHwBOm1GOa9BaZKGOxfffuXbnaPbRjx445swVswHfSmLCz3X/84x8uJ+bKlSuO+MQTXtcri+3bt2/bnTt37OOPP7ajR4/uWLWgP0+ftNqNLz5z9qM7GVsqPgvuSyIvYwqBG+xXwcQEDR84OVWK8KAuFUrRWU8oIWPU1RoYGrZp5UmtiDBhM+5MOKRKNTaoboZC59Z/jsK+IzKgmJMaRR/jbbEitk2HDzsCF+/n0vk+8qogcK+/8ZbL80rnvvy2PQIegVcEAZ0XCU9fVWTG4sCo1CaRA/KbRJpWlSfzTLV9nOq0S+BwFuGajIdEBiBLmDpgE56nSXCOFBUXuSDCEE9bFCHpe/TUJqTCJUsO4tlPIu9B2UFdmp/SddAtBCbyaQQ3OfqKLKGmFAgjrNOnpS59f/e2TWrxtUU1K1sam6z4eZ7s2kgPHvNdQXmbm5q2xdn5pHGJFYstKFa5lTiPR2IjTfzdqG01R2UtXiOHXn2HfEs9Ap4wpR7TpLfIpHhcYWGoS4TBnTx50i5cuLBjG2ZHCBQr/Le//c0pHWfPnnXEp7i4eNu+Mll/8OCB/etf/7IzZ84Yn62Xo9tOGgSiXa59X3/5RSAsxcGHOkijcqcbEkGBPCXSUOrIXaoUYYKErj+BsqoGjoThQcYWdSxmVNWce0gTtuJUP1+v+I2qACC5TNNTkwkSJsV1q85Ti8gtJhRBaBg9NKCYvnnVyiuUk+ebR8Aj4BFIBQKE6ekcSy4T7nmYQzhXPRGoZUL1ZFuNOQSvE863k5yZVHT3pW1osg1JQk3iFkFRUvI+RCm3qkxutqqZmC8La15PZGKua9qCCEHv/XabGBoNDGmkLtPM6ITN6xhxzBJtLhwOslQinEScFhYXrLOv2x62t6q2U4GdOnLcleiIRWRg8pAr7ChlETN8IAxwWdfhWamThAUm0w8MNkqqyl0/wjp+QWg45VU3yyRMbnn5Kley42StIAwqYH3whClAB4SJO1Wyv/vuO0ecTp06ZadPn06J0xmT9n/+85+uAndLS4udO3fOhfptN3z61NnZaYTzccKGwNGnhE7ea3ei7eFg09baat/euB4YwkTtq9GREVmKD7j+re3ydo8jSiolXwgnOFzpNsIG/LmBJ/eE2Q2InI2OjlmJiCsqE6RpbUPxGhkcEsmd0Ofiv7iwf26HZbIQFMJUoBDB+sZGu3L1mgiTzC188wh4BDwCqUYA8iRStCplCYVpZVLkaVi5TiJPTnkaVwi4zr9BaTma9IcrShRuJyWpVspAZanKfChKQQqBI0oK906mQQIgJb0PnsopT3mwmEQFoKHuTI+Mu5C4RLsTDYXLt2KZG6CmQFqmZqbtzsN71jPYb+Vl+6xRrsKDMpKadIuMq1aQX2gHFMVxqL7R9pWWyUQ4iifX4TmpXPMKDUSJS7RxfS0qL1MhW1m7y2o8CC2iflQ11liFLOYLSos3nIcEoZ+7uQ+eMAXo6PEjHpCt9TfffOOMASAmhMClwhqaSfq3335rbW1tzo3tzTfftIo4V/pHNXEnRJDbYYV5Xbx40VCn1ufqxAWlxojC1CaF6ZuvgkiYpDAlaHMeD2HaCJsBqUc9PSrIqNWuluYmq1ZY31pMcclDYaKYbqKEifC+qMIUDDWHsFKK1l65qvy5OL93G2Hmn/MIeAQ8AnEhoGsNqtKywvXIdVqWK9vKhELBlL9CCJ+7R31SPmnalSdF0eVoMS0kFSBUlC9SpJA73ULcoyrJxAF1yRk5pECxQEWZU+hb36MOERSuH9knTMxBFoX1rBSmZEhKWPhBULDNjll6j09N2Lc//NuGx0dl8qCi7SJFXCu5/jHPIE8Ye/HmxoPWVH9IRloyRBDZoS2JVBOaNzsmB8EEG9sgLJAituRRBaFFpESW11ZbhUgTpDI2ziD0ba/0wROmAB1JTmo9qsuDMx2hWoS/NTU1/SJUK5kus+2ffvrJGTgQ+vXee+/Zfiki8fyoMI0gB+fzzz937nqoTI1SC5C5k2nRkLxWheR9HhyFSWMck8I0hMKkk2wiLRaS5xzyNgjJ22xbYwq/5HiPjk9Yi1zyag4ceEmh2klIHsSr5chRK/MheZvB75/3CHgEXgUEIAv8v4ryRM3DWREnkSeRqBW5x61CoOYVsufC9lREXnk2EKjoTWqUyMcL972NiIcm5+466hxqFZ6lcy/ude62JtwuVFzgQuwwbYiRJJ4LudwkLG51MJ5P5nd6WFyukIhA/+NOm9F9IAiTcJyfiRarXabwcCJNuOCGh3V2ntwBYwXZx+Sy+8Wtr4178KtU0fiDUpkgRss6hkMKs3/a3WlFinA4qqLpR5taXGgexwsCt6Bct0lCFt13JH5Syedz1Q+K2BYqPDAIjRDFMoVyVoowlciQIp65XRD6vZv64AlTgI4WP1rC3z777DNXLBYb77q6updUh2S7y7ZRl77//nvDiQ/HO3KR1hsNbLZ9cnA++eQThZCNOovxmMq02fu3ev5n04fPZfqQfZc8sHGmDyJMAzJaSJQwOdMHyf7VymGiYG28mI7Kla9LhGlchKlZhgi1ymWChMZOdBTRHRmS6YOOlzuhbwXqmtfYf1ix282ygse1LwjNmT4oIff1N960fV5hCsIh8X3wCHgEhABlHMhzWlbBeKdCYRih/B+e47aCeQQ3rKhd/cM1E2uFhWH7jSED6lCIUDHdh6U6hHSLlEpBKpd6hA04YXY6N2eiYagwMyLC1NrlajAlcv1IV/9Whd+cjBnmpPJhLZ5I45qYp3yuEjkGRtaEvY+q7MZn335l4wpbL5EBw7HmI3as6bAVy2SIhgJ199F969F1vf5ArZ0/edq9FlaOL408r8nBUfcdSCiXSf2BoECYive9HErvNpyFf1DdyhTaWXWw1uEUm0dkoSt7dpeeMAXo0JLb097e7vKFUJbIM6rWRDzeCfhWQ+GEOaicGfKjKEh77do1a1EuUzxOeWyXvuGWd//+fReOd/XqVadQrQ0h22r/a1+jL+1Poi55FIkNQoPEEQLXJwKzoErhiTSOz0a24qxwceECI05esRMYl1tWt3Ag7FJIHn8fO9xi+3WsY3jSn371hZA8XPUSueA5W/HnJgsU0Q1C+9lW/I3AkLgg4OL74BHwCGQXAXduRUVCWdL5Oqow6aysczCTaKcu6V4nYXdzE2tO2jqn6+IcPa9j881jKUvRe1QmnfNRmBTR4e55D5/JQMMVj1C8gScQpqmErh/p6h6qFyFw84RHJkGY8hUCR42htZbZUYXphhSmCduvkPazx09ZTfUBy39uKT43P2fdA312//FDZwZx5thJq65UrpjC92iLIsJTyqlaIeeNYxxv02GEuBWKLBH+FoQGYSpVQd2qQzXuPjbfCELf9kofPGEK0JGM1WC6deuWc8jDlY6Cn6kgTAwTa3G23SrDhddee83tg7pM8TROJn0qpEoe1IROTpcvX3b5VYQOJtM62tvs6+ufu/ychE5Uyewsjs9w0YwWru2Wo11iig4nJgrXEpK31viBuku4HrKqSE0I3Hp4LyGJM1KNhmQzzn1VZaU1HTpoZSI3vA4eqEoDqlg+LhUqEbLEUF3hWiXAusK1cTghxgHPjt9Sqv40H6Zw7Wu+cO2O0fQb8Ah4BLKCgK4T8CbXHP/JDAFKdKy40U0Pj9tgW3ewCJNMFrAUT54wUWPoZ1c6lKUbP9yyEYXe1R6osYunzjrzh5gj3pJqMI1Ihfrupx/cPOq0XPTqpDTF0gnIpcKEYllmFAnNQ14QJilMMn8IQoMw4dxXdajWyvbLhj5D5DwIY89UHzxhyhTScexnTJNjLLwpFBsjNCTLp+qLTy4SluXUVMJMgpC/cuW4xLt9CN3NmzftyZMnLrcK0gShi/fzayHo7uywW19/ZSNyBYRABKFNi+CgME1PTyV28lTnIbXkC+1XHlJxiZyOpCoNaWy9ff0u8TSiv8l14vKK8gSWq7ryEkZQV1tnlRUqtKdwPMgRhXNHhoec4kUoZKItXyS2WqtsFVWVxuMgNJzxjsi176Ty8kqEj28eAY+AR8AjkB4ElhdRmPYiYSp3+UuxOcekrtXf37ttfco93i/l6MI6wkTpjrHJKGGS3menjp5whCn/ef71XiNMpRCmplqvMKXnZ2WeMKUJ2GQ2i0MeZIY8Jlzsjh8//iKcK5ntrf8MYXWE1GH+UCX5+tKlS3EbP7At3NzIg6KPTOwJy6uVnfb6+kHr97vR33093fbDrZvWLxUl0UKxG20vFc/NqqjsoMIVJ7QilSiJ4wQO4dmnpNNKhdZBdGcl92PsMClljzESZgdukCswK1GyaLkIZ6wGE9sgfwolcEgFdOdldc5nEm1FKp5bW99ghOOhNgWhob6dkOvjkeMnd1z4OAjj8X3wCHgEPAJBRcCF5MmNbsDlMAUpJC9q5Z2UwuRymBSS9zxSA+xnFA3S+rTNnnQ+lVFWfjQkr0ohec+ve3O6hvYoJO/e4wcKySuyM8dOrAvJW7ApmT6gyCWWw6SQPO0jaDlMpVKWUJggTjFSGdTv6G7slydMATpqXV1dLk9oROYD5BgdUdJ+Kr/0TL4hPOQisV1IGcYP8e4DyZoQMwhXR0eHq8cEqUNlSrRBTH6SHWiXlCZqIAWh0Q8Ur2EZLSRq/ED/wRFFZ58celxonk6oYAb5WtG9C60TYdIbX5CmXBEn1Che4/hMyu1nRHlLM0qOTYYs0QcUrkPNzS5MMJYTlW18D9TU2pnzF6yp5XBgVK9sY+L37xHwCHgE0oEAhAl3PAhTUFzyuJ7Ny5VwTmF5hMAl1HRdo/ZSccU+ueWp1qEWHWkoSMMKx/vh/k+OPGH4cEROeCXPTR8mMH1Q/lLv0IDV75fpwwlMH1TnSp/nmutMHwZGohElXJvjbepPRCYeWJxzC0LDhMIRpjhNH7Ycrl5cjwYKnQuRWTdYQfHKNE+YAnSoyS2CjKBGvPXWWy7sLZXd44SF0QD7gPigEGEuEW+OFCcYVKrHjx870oWS8frrrzuL8UT7CSm4f/cna9eYZ2dnEv14Wt6PQQP5Wf1Sv5IJhaNTIbnv5KuAHDk71BsqUo4Y+G5FSt2JW2RtenLKqVuEBCaqcMUAIRG1XCpXg1z3IEtb7Tf2mUzc1zU02PnXXrcG1cMIiuqViXH7fXgEPAIegUwjgCPdjMwe+h932MxoQGzFtWi4MDunukdTtqR6TIk2CrNS94j6R7E8JsLa52XS9NODu9bZ16NCtfl2sK5R9uLlMlxacfWZ2rtkK15UaMcOtdjhQ80vbMW53kPgMH0Qe0qoO1xXce1z/dF9EBqEaV9NlVUeVB2mis1TJaKLsyKbC6qLtUgKANFDzx/rXtNEd9PhiuIiQhSSYQkcNSwjE/w08vOIqFFudv7P95EIxlZBQCJ9ffCEKX3YJrxlcpdQfwjnIj+oQZPMVDbUDmzB79696xQiyA65TPE65dEXfmyQrh9//NGZQFy5csWZR8SSKOPtL450T7Ty80BjnlZV7iA0xkZuEe509ClZ0uJOplKXSlRED/c88IXIUDsi9PyMwumZ48FJm5wlTB6mlEPF/qPKUmIn8Bh+uNFVKvyNXKqgkCX61nioSZbib9n+mhpH5GL99fceAY+AR8AjkFoECC+blRtd34OnLpeJa1u2G32AKE1TuFZ23om2kMwe8kR8imTlnSvyFLu+sd2u/h7rUL2lEeWB46JXpEgPrq/zurauyAGx+SCFaxsVAv88VE1wOPLXaK8+AABAAElEQVQmA4oF3RJt7NuRJRUbpj5UEBqEsqL+gFU27HehgvRxaQlCJFI5HyVEC3q8oMfu5h7rb91DnhYgT7qtLBPtwvxEIPG1eYkwmYiSImnyQ7qJLOke0lRQoL8L9TyvFURJVAH3eg0iBeHaC80TpgAdRWokof4c0GSXOkfkB6WyxQjBw4cP3X5OnDjhyM4+1eqJnXzi2R85NphTfP3114aTH32tlNNbIg1C0vn0qd1WWN6ETnJBaah7owqJpGjs3A6VLzAlV4kQuUKpcRCnmOrDytiy1Doc+WZktYqVeTIheOtxq6yqtgMiJcUBsROnf+CAQ94b1952OV6JfNfWj8//7RHwCHgEPAJbI8C1fkEFeXvutylHR06rTH4D0MhdwoxiXn1LVNWh+5CCIll550vVialMPM/i5ujEmHX0dNmADJOmde2m1hLOs4fqGqxRt9LiaOgc2EAoUeAID0SNS7TliAAQHojahbIThAaJrDhYZ6UHqlVUt1DjMhlYrdjY2IrmM8vuflyPJ8alPs48U+2p1H0nBLUW+jG+CimyJmwVulVWRqyySuS1RKRKRArH/bDIEyrVbm2eMAXoyH3zzTeOyKD6UIMJY4ZUN04s5DGxLwjZWbmWcZ/IJJZtkG/1+eefOzUM0nRaCf2JbIN8oQEZG3z71ZfOES7V40x2e5AW1J6Y+QOrVDtpYEIRWcLyXoTmcb7QuWr12epzlUmFE91+kj+BsZ9caeX7Vfy2ev8Bp2jtpN+p+iz9Qn3EIe81Fa31DnmpQtZvxyPgEfAIbI4AKk7vw3abGFBh1iRIweZbTv4VIirIqZqflktsEn0idylXhYELS0uU06QFyOcW45Ag5iXzii8jr4nrePTaG7YCXX/y86KLlbyPUD3I5Py07M3nF13UTKIjoh/UPIIwhWACWWoajuOdEtHERoRLVa0thvbZxGTIEaRZESMUpGUpTctSjtw96pHIEp9NWXMqlAitCFH0pvImuVz7c6yoOKSF0rDmJRFFvkSUMiClUMoUJAvypCnCrmmeMAXkUPED//LLL124HO51qD9Yfqe6ccKA7KAOoXhAzJqbm91kPpF9YUxBEdweha+RB/Xuu+86NYWTVDyN8Y6PjdoX//zEkRP6FYTmTqjq27AcC0dGhm0+CVvvbIwDJatMSiFudKUJKobp7C8kEbe+YydO2ZkLFx3BTuf+/LY9Ah4Bj4BHQHkpCn8baO208T6V7lBh1iC0VV1b50SW5p3xw1JSZIXQ9lyFwRWUKmqjqEBzF82845l2aI4BqcLogVpQK1K7Vh3TSAwZ1KWwQuypecT+453zJLaXrd8dmy6JG0pNy1FOesimF0QKS6ptJVSsyJUcLfxiOCUlaWdrvlt3ZJtXmQ5CnAjXKykJK0VB5GlfWKZYUQJVUamcb+VChXYJcfKEaZsDnomXmaRjIX39+nVXVDbmkBdvUdlE+9gvhzrqKc3IRptaTCdPnkyYMJFrg/05hWwpXvvBBx9Ihq3QjyN+eXpaoX3X//Wp9XZ3OTOJRMeRzveTT0RY3qhI005VpnT2k21DSgplmUreErWg3DGIk7imu2+EIOIYePzkaTuqRYD8/GDUhUr3uP32PQIeAY9ANhFYkhPdUHuPCNOQFJXEc4bS0XdC4RbVr7kJhaHPqEB8kqGCrhh8kUiT6hgSihbSgiHXwY2IE/OrZyJGkKUlFaold4lcqmT3TS4VIYGEBrLvTDcNQ7lZOTY9k2NT0yJLkzk2Oha2mfk8y1OOVq7mYzk52VO9tsKDQ0ReU5VC9Q7USHHSrVykCdWpuFhEWIpUQKYuGw7DE6YNYcnsk0zIca27ceOGU2w+/PBDO6gkRYhIOtqwiAAFbFGaUJgokpuo/TQnn2lZXxOWR8FdQvJOnTqlVYT4LTYJffvu22+so/2JTBam0jHUpLfJ+CblmDdIPSSpTChiQWysbuE6V6GifVWq/1SQwkLHqRgvyhfOeCfOnJXxwyGRucxfYFIxDr8Nj4BHwCOwmxAgX2ike8DGegYdQQlC3yEvqEyzIkxzMqVYZfafZCMUDqWH0DxqIrn6TFJ/1io+jixpfkUh3yUZQECUCMmDQCXbIElF5cqjkgEF5CkTDV6JmjQ/L5IkojQ+EbKR0ZBC73JsVs+trshYQVgUS/XCfl0oZKJbSe0D0kQonqYGyu0OyaQqYrV1UQJVXkF9yqiRRBBznTxhSuqQp/ZDTM5jqg/k4+OPP066IGw8PcM6G6c8HPnIP8LCPBFliH1wIqLft27dcqoY4X0ffPBBQoVwMTp4qH60PnpgQ4OD8XQ9o+8hz2pCRHZIVcR5zJiD1siPwhnvQF2dI6uJEt90jwcyR/7S6bPnnHtf0PqX7vH77XsEPAIegWwgQDHWiUEZGHUNyGhhIimThXT0m+vovNQlVCYUn51cVyFHqE05kCeRFxzyCJlzMoUu15Az8qbIl0LdQlXa0f60LwhJSdU+LVQqmibNcghTDsjSghSl0bEc6x8Mqe6Uwu9mQsrVwv5bZEncjzFDHEsqqVMVDNe+eL47gtPlPKE6lZWFHXFqPkIuNsRJxzNgoXqeMMVzVNP8Hmobtbe3O9WH0Lzf/e53zvBh7UpJKrtAOB01n7766is7fPiwK2BL8dlE94cyRlgexAu16le/+pU1NzfHrYzhEtejGgn37vwkx7z2VA4xJdtifFh+DyqfCeK0KIIXpEYIQrGcfyoV8kb+EqQ30WOY7vGgeEGWTp077/oatP6le/x++x4Bj4BHIBsIQBKm5QQ30tFnE/3DOyIKqew/hAXFZ07usJAmiEwqmiNOEKg1JIZ9OaIE80hBC4skFZQWW7GszcmlSnfTdFDufyHrH5CiNBayyakcheOFtFj98p5R2/JLCq24vCxK5F5+eVf8hVlEUZGIk3KcauojduhQnjUczFW6gcqxpB/quDDyhCkumNL7JqysqcF0//59FxqHwpQOw4fYKNhfd3e3ffrpp04RopZSnRSKtSea2Hu3uudkRFgehAkDCOzFCc2rVmhYPA1CMjE+Zre//7c9kNLkrOPi+WAG30MfKSg7qmrihOgtLyXnqpPqLnOsioqLXShehSzdXZ0nlmsC1CB0ELmz5y/asZOnFLu8e1a+AgSj74pHwCPgEUgYAa5dCzMLNvy0x0Y6+wJDmBhItG/zNjuueofKadqJ6pMwMEl+IJo3VeByl1BzEp0vxbtbuJ24rk0q3A41aWBYqtJIyGZl5ICitFEjHLFQJhjUhoro8W5vmEPU1Io0NedZbX2uc9ij9lO2pzieMAXgm7UgFQPC0dHRYaVyFHvvvfckT5alrWecrIaGhuxvf/ubc8qD6Bw7dixh4wc6yInu0aNHzuGPPpMPhWoVz8mEzxLW98N3t+z2v7/TyWA5kCdO8HImEDKA4B5lLJsneIhIrmxSKQJbLqMNbLvjwTttX6hNNgyJq6tvkMJ03hrlpEg+k28eAY+AR8AjkH4EuEaRrzPU1m0DbV3K20mNypKqnnMdnZ9SaJ4c81YUPhjkxvUVdckVqxUxSVdouaYaCr8TWZKS1NkTtp5+VKWQ5hsbE6UYZtSCoqBvITbnGcqriu07XfcIhcXKZzp8NF+mUfl2oBa1KWpbnq59brddT5i2QygDr8cc8iAxNZoEv/HGGwmZJyTTxdHRUfvXv/6lH+eCI0tYmTuXmSQ2NqCQNQruolqRE0VtJ3Ka4tkeJ/XHD+7bnds/uIKxxBsHsUHsZuUqOC7cJifGnaufq4TtSmFnpsfupK0wgEKFuVXKPrxEBBWyFA/Omenhy3shHA93vONSlypUUyyo/Xy51/4vj4BHwCOwNxAgZ2eoo9cGnnQ5JSeDl6ttAXQLpkrEmRmbsMXZBZdvtO2HsvAGtziq2XthWfELZ7xUL1BqGmRwxhkZOpCn1N0XdsYOEt82VZXWQpFbkGclFWVRm/NsyzBrO7bDx0Q9YgxBMdwW5Ta1HM7T3CdX6QcyuchCQI0nTDs8oKn4ODlF//jHP1x4G+oMVt9FRUWp2PSm25iUUoIl+KDMFurr610dpWRXTebkIkcOEy5/B2RtTf8hfvEqCv29PfZIpKnt8SNH4DbtdJZfgDTh7Dc9NenC8+ZkT7q6qmRSznZpbpANHOZKVLCvdF+56hmUCt/cwJIQLiilpVIcL1+x5iNHLd9ZnW69SpZmCP3mPQIeAY/AK4fAWO+gDbb3Kl9oypkeBAkA8ovmVUR2TnWRKLSri2mQuueu7W6xdGneqUsV1VVubpbsXGmjwTFkcpWGFH7Xp1yloZGwTUlhWlrOiQsOrrXO8AEjCjn4pZrMbdTnTD6H0hQRQcJ6vE65TRCnuoY8V9MphMFHBpsnTBkEe7NdUQ/pf/7nf9yPE4Xm+PHjcRsnbLbN7Z5nnzjlYf5AGCBGE8meBAhZwxb9s88+c/WkKLpLLlO8tugz01P2tK1NoXmqDaWcqEwQkO3w2ex1xooRxJRs0KdFOunvkvKaeD4djZMfhfkg0LjhlUpVKtJ9vGQ0HX2KZ5sYUByorbOLIkz1DY2BJXbxjMW/xyPgEfAI7FYEpofHZS/e7wrYJlOoNd3jpmSHC82jmGzQ8pl0/ZW3no3NTNqq5uYsWFJvkjlTsvOltXgybZhR4dmBwRzr7Q/boPKVZucJwVv7rq0fYz5RUFxgxZVlLpd563fv3lchToWFIeU0RezwsTw71CS1SfWcIE28lonmCVMmUN5iH0y0UXv+7//9v45gvP76664GEyFt6WyoQuRMUY+J9oc//CHuMLqN+oVKxraePHnywkiCE0s8YVjkLvX39tp333xjw8ODtiRTiiA3F0qA2jQ3a1MTkwrVm3bF+JaWqRy+c8UJksQNi9Q8EY/8gkJHlIp1ks5XCF7MDSjIGJWor8dOnJLZw0lnTBHkvvq+eQQ8Ah6BvYrA/PSsI0uE5eGcF8S2rGv+vIrrLqiv1I9KlXPeTsaKVTmKTVjhbtNzM8olmjIMs4pltlQpoyVqTibrTAsh0lTBJqQkDQyGrbs3pAK0IWcfjo143E1EgfylQjn3ccNafS83iBFuetiONys877DUpgqRJohUJkiTJ0xZ/nZhKU4h2T/96U/OSvzNN990hCPRukiJDoMfPvv9RiQFwobCtE+OZuTEJNOQrQnLu3nzplNbIH7Nzc3uhLLd9iAguOXdUx7U07ZWZ6yw3WeC8Dpk14XpiXyiNKGULTwvchtTnBhbPIpZjCS5e4XfQZQKZRkO8eAEzffB1ZjIxFlhh+Ayhqr9B+zym29ZTV193ErjDnfrP+4R8Ah4BDwC6xCgHtP08Jh13XliK5CRROSLddtK15/0CeOHBYXnQfAgUORfZatR1yiiekYFMlEokF33sogmjsAjIyPKM5px12PSD3AzTpQ0AT/5SoTdtXdFrEdkCZVpWQ54iR4arrV5RflWJHc86kNhL/4qNEL0SktD1ijr8VNn8p2TXkFB+kmTJ0xZ/nah9PT09Ngnn3xijY2N9vbbb6dM7t1qaMjgqELXr193+8eZr6GhwU3Ot/rcZq9xwqMgLnlRfX19duTIEeeYx2Q/nobxBTWZsBgf7O+L5yOBeQ9YclEiNI8Ct+Q5MZ7FxQXnqAep2uoihQqHoxxkNT+/wDBLKFQIHn/zPOF3nBh3SyMUs/FQk73+1jXn9hiPyrhbxub76RHwCHgEdhMCXHuod9R974kLfQusI536yXV0QblMjjQRnpemUPetjh8ucyhLBXLDg4SwUAmGLpdJ1/bRsVEZVI266zJK037VQUzEfGn+eRHa1qdhGxoOO7vwZIdJOBr9LJbhw25ZUN0K+0ReozZTkQwh6hty7cy5AtVsylOplfSSJk+YEjlCaXgvuTBtyt/58ssvnVvdu+++60Lj0j1Bjp0A2C95TOfOnTNyj3ZS/wnHPWpJUVOKnJtr16451SyeWF8UmTHVOvpRFuMUsUUB24pkpOFQ7HiT9BeXP/rODdtU/uZEu6ywQ6c6aXVJmpNBf3JyVFdA8cfgwyoVxChXJImTLzWL0v0d2PGAN9nA/gM1dvT4STueQB7bJpvyT3sEPAIeAY/ADhFYkEHRsCtgO+JUnB1uLm0fj15DV2xpfsGZQHAPiUpYekmmhyIfkI78ogJ3ixCOp7/XNhZHZ2ZnNFcZc3nbvEZkDsSJOc9WucWaHqjobI7ylGQZ3h223oGwC8Hj+WRbJC/i1CUsxQnVf9Ua68iE49U35tqJU/mubhOFb9PVPGFKF7Jxbhd774cPH9r333/vLLlRejI5UUYRguDU1tYa1uLIzMk2iAGue+QyMS6219LS4myw49kmitfjB/eczfiYPh8La4vns0F+jyNMwmZtfhOEifPksk7AhGViFY4yEw+5DPJY6f/hY8ftzPkLKmC8/xcXnCD33ffNI+AR8AjsRQRQlaZHJuSW123ToxPRi0+ABwpxWponr2nWESdyr6ILjjtgF5uNV7NuFi4p+JoHWSoudHlBm83DXN90zR4aGnQhegtaHK2qrHJmEOQ1bRQREiNLQyJLT7vIWQo7F7zNuhTv84QLUhsKkrdZf+Pd1m5+n9aeNdfMs9NSmqjblKcitzqkKW+eMKUc0sQ2SO0lahihMlG/6K233kpsAzt8N/vGLY+TQCwsL9lNsg1C0e7cueNIIFI1hWzjJWEoMoMD/cplum1dHU+dSpNsX4L0OXChxe5jfZsnHFNmFx1Pnzpr98aDB10i6W4NYaPfhGCeFlk6fe5CwrHdMVz8vUfAI+AR8AikDgGuPRCQvodPbaJ/2BW0Td3W07MlcphcuLtUpoW5edd/t+io59219Pl1Nam9iyRBMFBlyPuBcBB+h6rE31uRj9h1nIVO0hDIBSe6hgXPKtUbLHteHzG2DbqJsjQwJLLUGda9lKXFxPOV1o+T7ROKV1gmZUsRKq96y8/PcQ565y8WWqPC80rKwjIdSy0qnjClFs+Et0a+z3fffWdjY2OOMEEwMtlwtYM00Y//+I//sObm5i1PFtv1jRPcUxEAtomZBGF5qEzxKCeciGbkOPfo/j1rffBAJ6PxPaMybYQbxxz8Hz96ZNUil9jJ19XV7VqiQTjhQeUunTx91hqbmnb0PdoIL/+cR8Aj4BHwCCSHAGRj6GmvjfUMulym2MQ/ua1l5lP08dnKqoiTwtoXuS25ArzcRy3SxUai/6tDLx683DnCORQE//wuSpQkP+TmKwxeBInrVjhXk2s9xy3eRt8gTdOasxCihxkE85zyinKrrKh8nloR0sKv2YDswtshSypKO7+QmG34Rv2BLJFrVaraS/lSmUJILL4pUgfDqYhdvFTowvNKSsM63qkDxhOm1GGZ1JZiBV/58ZFHRP2iTLZeKRwoQj/++KP913/9l8uj2ioOd7u+MQ6IAGF+kCYI4KlTp1yc73af5fVlWXNjMf7w3l172t7m8oDi+dxufA8k9ZHCMVEXiX+maHGLbtixx0MwgzRm1CUc/c5dvGRNh48445Ig9c/3xSPgEfAIvMoIcG2eoiZTZ79NDIxkxVBhJ/g7xYl8YJEUQgxXlhSmJxIIcYoqT6qYhPrkdhL9F2LhyIUjQ1KOdB+WghRSbhL5PygzYYXi7aSxSIyDHrUoUZyYoJcpr4kwvXC4UHbhuYbBQ7+K0s7OpYbYQOzyivOteF+p5cnNz7efEcAM4shRheedLbRm2Y7n5el4pwZ284TpZ5yz8qi9vd0+//xzRyggTLjLZbLxI4fcUHT2448/tpOqmxOvs91G/eSkjOEB4/rqq69cMmQi4yJOeW5u1tplRHHv9o97UmUCI25g9FBKGnlfECRUpubmZleHCwK1m0LzcPWjQC2EqVp5cLuN8G30XfbPeQQ8Ah6BvYTAohzoRroHRJr6pNQE02J8K7y5btIgRqurIkvKbYKwuBwnESeef0lpEnnhOooa424QJ82oXdgdBU/RnfT/ThoUDdJGOgLzqXFFxixJASst22crq9U2PLbPevpynbKUrBveS/1TfyF6FKrNdy5+8atiL21nr/4hfIqkNDUfyXfueXVy0UuV5bgnTFn80vDjf/z4sf3zn/+0Q4cOOYUJa/FMNmJvMZ3485//bFevXnVhgcTh7qQxrv7+frt165ZLisR974033nAnLlZ7tmtYiQ7q8w9QmdqeKD54/hf5P9ttI8ivgw8nV479ExFDzC5oFCuuqamxpuZmZ8KRaH2HbI2ZC9J+9fv02fN2sKnZWaJnqy9+vx4Bj4BHwCOwMQIQi4mhUeeYNzs+FdhCthv3ft2zuo46+vTintejhGrdO53K5JiRph+pIEnrt8/fLPbG8poGBodEnpZsZGK/Ct7W2aoVaMdSuHbKzrQfakTlFeZb2X5Fokgpi2dOtVF/9/JzKEpFJWFrkcJ08VKBHajBhXj7ued2mHjCtB1CaXydH9cDKQwoTGfOnHHhePEaJKSqW/zICQn74x//6ELnUIOox7TTHyH5S2wX0gQJeOedd1wyZLzKA/WMCM27+fVXNq66B6wi7ZWGax4rUa0iTN3d3e5Ey3EAG5SlWD5TqULcdhIemQm8+J4Uq8Bu8+EjdubCRReKsJuUsUxg5PfhEfAIeASCgACLdRSHJY9ppKvfGSkEoV97pQ/gu6RwwYnJebv1/Yy1deTIhrxQ9YFUAFemELmRnZszkHdVWFrowvFeRSvxeL8rkKZ95WE7cRrSVKTHOwu9ZL+eMMWLforfxw8LZYFwuG+++cauXLniwuHw9M906+zstL///e/O4QWnvqNHj+6YMEEGsRb/9NNPnTp0/vx5F26IfXY8DZVpenrK7iu/6mlbq5IqR+P52K54DyGLECVC8oblkhg9yS45wsRJFWvSwwrNxOqdx0Fu1IyqbzhoJ0X46xsPugTaIPfX980j4BHwCLzKCKxqwW5SuUxDbT02MzHlTBVeZTxSPXaVvLK+frOf7q8oFG9R85glRdfkuAgS5j8sgia7qEiADiYPRc9zl3a6sJ3qsQdte5HcHKupjdjZCwVSm6TKyTkvjiCnTYfhCdOm0KT3BSbJqAwxw4X333/fGS4wYc50I3yOAraQHEwnUJl2+kNkfIT7Xb9+3Xp6elw1bEL+KIwb77ZRYkZHhl0uE6F5EA22u9ubC8eTMx64ULgY9YyxcTKFIBXJmrtWqlxdfb1T5YI6XhSxCiW2Hjt5yo6q9lKh+h3vsQ3qmHy/PAIeAY/AXkdgfnrW5TGN9Q55lSlFB5upiSIebWgkZI+ehK1PJg/T08vKyZ5zIfi8no86pOs8C42JkiaureRhFanuUtG+4oQc/VI0xF25mYKCHFfY9vxrMoFoybP8guQdIDxhytJXgBAsajDdvn3b5bJguNDSEp/9dqq7jBJEsVlUD/KNULsS/TFv1CcIT6tydBgjLjK//vWvX9hmb/T+9c9BjsCp9eEDZzU+ODiwJ1zzIEyE4+EmCEmleC01mVAX98swgVA8ajkQnkceUxAbJ+/ComI7pu/L0eMnrVyVzoMePhhEHH2fPAIeAY9AphFwhWzHJm3wSZfNjk87l7lM92Gv7U9TFYXi5Vh7V9ietEdsbj5H85doLSmu+bOSnpgTQZq4tsdIU7yLjBhVuEK1pcWWK2e8eD+313BOdDwoSrl5Oc4A4uyFQi1E5wq7RLcSfb8nTMnhtuNPoSqgMKAwYe39m9/8xhk/ZONHgMoRIzZNqp9D8dzYj3knA4XskMtEnSmMJS5fvuxqDaEyJdImRCxQmB7cu2NT2t5uz2ei/5OyH10UWQIjTqZDcspj5alGdZhKpTJBlFBwsvF92O7Y0Ce+H3UNjYoPfh6Kp/4Gsa/bjcW/7hHwCHgEXjUEWIxcVDHYse5BG+8fsbmpGfkl7P7ojWwdR6CbF0Hq7BFZkoX46FhIDnnR3oB1LIoEtYkcJ6zNIU0YPcVznefaGlHdqOLyUldkN5F6UdnCJEj7hSBVVUeUOpBvl66Ae3JW454wZemo8gMih+Xu3bsuLOujjz6yeoVgZaMxYScs74svvnB5TG+++aZTO1KhGDBO6jH9+9//dtu+dOmSs81OZJwrz0PzHj2474jTtAjebm/gEmvksnV2dLgTZ60IE+pSKhS+2PZTfQ+ZKy+vsDPnL1ijCtUWSxHzzSPgEfAIeAR2DwLULpqfmrWhjj4b7xva3Y55WYZdHMgGhkLW9jRivQNhpSP8skMsjhJ6Pzc/ZwvzC26BkUXSQlmDR2QGsdWCY1iheAVSlorKilU/KphRJ78ccbCewSWv4VCuvX6l0BoPKjSyKPHQPE+YsnRMkWYfKY8F0wcmx2+//bZzk8tGd+gLIXN//etfnXIAqYG8oSKkolGcl7C8kZERu3jxogv7Y9tbnSDW7tethi0uyGp8wBW07enu1Aln71iNO8Ik4w1IFC6JlQpvY9UpiI3vaqVs53HFO3bipIrVitwFtK9BxM/3ySPgEfAIBAIBKR/UDxrrH5Jj3oDNjk7uiRzhTGNLKN7kdI61KgyvszssVzxC8TbuRXQus+iiSiBOykpyIXrkrm8W1YMTHjbixeUlrkitd8bbGNt4ni0tDVljU65dfrMoKatxT5jiQTkN74GkEI6HrTi5K+QNVVdXp2FP228y9iP+y1/+4n7IWJzjlMfqRypaLOSPPKnm5mZnoU6tp0RIAX1Ezu7qeGqPpTQNDfS71ZpU9C/b20Dhg1RikgEukKZEsMlU/yG4FDU+fOyYnTp7QWQp+LbnmcLG78cj4BHwCOxGBOZlMz6hsLyhti7lCC8/L/66G0eSnT4vLJp194btUVvEhodD5mrnbtEV5jIsjs7NzUptWrAVOUVE85oKFYqf99K1n1CyqI14ifKXClzdpS027V/aBgGsxoukLF19p8iOnMjX3Dsxq3FPmLYBOF0vk+xPmBrFSw8ePGjYbldUVKRrd9tuFwKHBfjw8LAjNfQnVZbWnBwI+aPeFGF+WJcfkW12ogoWJ5oZKWGtjx7aE91w0EPm3u0NotTX1+dCM8nvqlNYXirCIVONC6F4R4+fcK54tXX1KqCXuKSd6j757XkEPAIeAY9A8ghwXZ2VvfigbManRyZsGQbgW1wICDrlaefYD3dzrX8wZPML8bsJrD5TSKQI0+zMrFv85ZrPgiRqU2zB1IXilRS53CUc8uKNyomr86/om8LiSIea8+zS5UI7ciwx8wxPmLLwpeEEhapw8+ZNe/r0qau/dOrUKeeOloXuuF1Car7++muXV7V//35n/JDKmlBYqEMQceJrlspEaB5ucImeAMhnmtC22lofW9vjRzYxMb7rSRNxzQMDA67WVKnylxobGwPnjldYWCRDinqZPJy2WoVrFhSkRn3M1vfd79cj4BHwCHgEoggsLy7ZjFzzhp72uvtV/LF92xaB6Zkc1VoK2YPWiE1OEYoXP2Fi48y7WDwnemZBRJV6TRAmonsiWqAsLC2yQuUt5SvPKdG50radf4XfUFYWUm2mQuVhF7jituFwfMfNE6YsfGlQRQhTgzChLJAzhKU4rinZavxwMWfAhIIf7AcffOByaVL1I4UgYnKBYx6rKK+//rrLk0pGSQG/IVmMQ5ggTnMyTaD/u7VxwkTZwymP78AhORUmqr6lc+z5+j7U1NY5danh4CFXJyqd+/Pb9gh4BDwCHoHMIeDCxBSORy7TWO+gzCBmfGjeNvCjLvVJVXr4OGL9MnxYXIxv0r1+s8+erTrShO048yTmXAUiSMVlpVZeXemMHsgdTtVcbP3+X8W/MYA4qFwmSNPho3ma88YXLeMJUxa+LYS/YYBw69YtKSQTdu3atZSaLCQzJEhIW1ub6xP9w7WvtrY2ZW5tbJ96Tzdu3HD1h1DUKJALOUum0cdoUdvb1t8bLQC7uro7SRNjQYHrk718rswwsHYHl2yfINk/xK36QI2k6+PW1HJYzjJFWe9XMt8X/xmPgEfAI+AR2BwBF/migrajPbIadwVtFzxp2gQuDNgVGOIsxO/cy7WFpc2NHjbZxEtPgz3zgFiR29WcZypOW2rVNdXKsylX7pIPx3sJsB3+oamNFZeEFDGTL9e8Iqcyoe5t1zxh2g6hNLyOokANJkLU+JG8//77zvAhFreahl1uu0l+sISFEZYHsXnnnXesubk5pUrHzMyMU7HI28LggnpPhP0lY6FNfwllmxgbtceq8dQtMwhUuxVIE0s/u6jFFMcehSvSGpXTRv5YMrikatiQJWpE7K+ptSY54jVKWSJcMJt9StXY/HY8Ah4Bj4BH4JcIEPI+OzHjbMYnBkZsaV6sYJddT385qtQ/o/VfGxyOOuO1d0S2NXqIpwfMaVyI3sqyzS/LSU+3YlmJk9vOPIkcYq6/vI85A+9lzriTeaObKekfDnH09uzF4/V9hk5ANHIkxjA/cI+35xjrNxOYv5UyJpUpz15TLlNTc77l5W8/GE+YsnD4SPInPO3HH390hOTDDz90P4hsKwoQDhSgDtUEImQOFShVTnnAHCOK33//vZOecQbE8IKJeTItduIgPO/pk1bdnjh79BWdcHZTYxxYi3fLKQ+MqMXESXInJ8Kdjp9QyYaDTdZy5KjVK6eqOMsEbqfj8Z/3CHgEPAIegW0Q0MQZ17bpsQkbVXje5NCor8+0AWSkeD14HLY2kaWx8fjCuTbYzMtPab4eCoUtUpBrzxQyNq7oo5nZGWeuRKmRKt2IPFlaVr6ZjCLGx8Zc2gS54MkuZK5q7rG0pJt48eICi9DR28oKpOzn7iG+hNUncTYRC9mcq+JMbp4iUHJljB6HMvPzloLzCMJXXhGW42+BXXy9SDn12x9HT5iycPyQXR9KFbl//74rUorClCpHup0MJ2ZEQX2o48ePvzBm2Mk2136WVRHqPUGYsNGGLF24cEFFUMvXvi3hx5AMwvM62p5Yj7Y7NqqVMT23mxokGkwgTphucEsmv2unY4a0FxUVq0ZBrbUcPeYMHrAPzzaZ3+m4/Oc9Ah4Bj4BHID4EUJamhsdstFv1mSambUX5Tb5FEVDpKl2nc+zHuxHrkp14srlLa/Fk8k49Q+otFcgVDyvxWdmOj4kUTUxOureiMpXrxjxtcGjI5T0fOnTQ6pRf7ELl125wi8er8j0nnHB+ftXdFuYhTVrQFlly9yJQECYUJ+OmhqpEuUVyfyBKEKdckaV8qTL5yv8pLCR8P0fv0UB2UUNVamrJk804c57Itv33hCkLB5dJMYVcUZmouXP16tWsGj7EICDEDeMHiunSrzfeeCPlVucQmVjBXiRlQv8okpvsCgl9j0nZk3LMgzR1SiEbV1jhwsLuKW4LLoRpTunkuO+5tTgSfCYbihaGHHUNjUqEPObC8Qrk1uPJUiaPgt+XR8Aj4BHILgJcU5dkeT05OCoTiGFnO+6d86LHBOvwwaEcu/swYkMj4Six2OHhCoWjxWkLFYIHaYqV7GBxfUz5zaMjoy59g2icWalOQzKJwo6cReem5ibbrxSHreZQkB9IEIRoQURpZvaZ5horKtOC4YTIkUgg73H86DlJ2mxIL0LxxI0gTUVFOQrXZ+4QkgIm4iQSAnHifUFv9HH/gYhduVpkLYfzFEkjVrhF84RpC3DS9RIqC4YPTJBJ8Cf8LZWhb8n2m0l7a2urK6jLZP3tt992Skey29voc5AkHOEgjOyLfVAkNxUOgc+kYFEMrle4PlZB4J6uTp0kdsfKGLls1KrC/IHvAtbiyYYqboT7ds9Bltjv8VOnRZaOW7nkf07Anixth5x/3SPgEfAI7D0EXMi75JTR7n4bk9I0Mz699waZxIgmVHfp0ZOwdfZEDFvxnbYchbTlFuQ5k4f8ooKXiA/HgLkB5mBdXd3RRVWlThBKl6+4uDIpTs0iTC0tzS4iRTRlw+5gIjwtcjQ0uGyTEysiTT+H3EGUdtI0TXDkCKIEcTpwIKyi9iGnRu1ku5n6LH09cizPheXV1OZuSfQ8YcrUUVmzn0mpCOQKQRwIfduJW9yaze74IT9MSBxkBlL33nvvuSKqW61cJLpTTgCEnz0Qofn222/t0KFDrpAtBCEVjbA/bMbJa+qS0tTR1uokbIhakBvY833APRHy0iKb+UwQJggR+6mq3i9zh8NW39BoZeUVWjnKrLoV5GPj++YR8Ah4BF5JBDSZXpDdNeF5Y3LOm5+aNWo2vaqNacTgcMh+uBOx0bGQLa9sTFDixYdrfaQwzwpLosoSbnjrWyyV4alqdra2PlGh3EkXvleofCZcbOvqVfLj6BErKy37RRg/eUhzs6vKh1qxyXEpSyJN5CnxfKobuUwRTRuKikKKkoneUJ14PshqEypZRVXYrr1b4grZYgaxWfOEaTNk0vg8camff/65IyXnz5+3EydOuC9+GncZ16b5YTJhv3Pnjiswi4sdhCbVE3dIU2dnp6tDhXMeeUzgkEpiRjjemMbS0d4m2/FeJUiOOuIUFxBZeBOEju/FkGKTcSo6ItUt3aojMdMlJaWK3a2RwcMh54RX5M0dsnD0/S49Ah4Bj0AwEeB6vTi34EjTRL9CwaQ0vYqkCSVmfj5HylLIfrofUVjb9iYBWx1Rl7NUpJyl4kLLk7IEedqoLcqRgZA8Ujh6e/vcPAYCkkNikVpVVZUdOXJEi531Bomi0VfI3ZSIEmRpYoKFZDnrZSDghr4VijSV7YuSJswU8mUUEVTSRL/yFUr45rViOy0DiLJ9Gx8HcPWECRQy2Dj5DKpAKYQJVeHy5cvW3NwciBV9+gaBwYyC25kzZ+zYsWPOmCLVEGFdjvEFBhAQxjfffNOF5aWKNDEWCOCCEiRx0Ovq7LDhIRXkU0wwuAet0VdWjgZl7T6rPhKmSD5ROkLiwBhDiTLVd6iTstfU3GLV+w8o9lix05w9fPMIeAQ8Ah4Bj8BzBNz1VNZw4yJME/0jCs9TCQ8pTTz/qjSGOjqGlbjc8TojSZs9cI11ZElheAVlRcpZejkMby2ebk6mnKXenl7r0CLz9NS0w5wFVvKbmMuQzkBqx/ETx61C+c8QKQwcpqQmDfYrBG8ymqcUM3BYu/10PWYaQR5TscjS/v1hpzhBmgjfC2LDzOKkajKdvVAgE4jNXZs9Ycrw0eMLTtjbV1995VQljBUwPdhsdSGT3ePHyQ8RU4bvvvvOGhoaHGnCACLVE2nC8sjZ+fTTT51D4MWLF92PHok5lQ0iQogeznl9PYoB7u6SND2hk92CG2sq97WTbdFPzECohTWpeOUWhcdhF5rK7wXHEKJUVFxiFZUVOjEcccYO7IeCuak+xjvBw3/WI+AR8Ah4BIKDAPODpYVFpzBhBjE9Ou6UJ3KHMzkZzxYiDLOnL2T3H0cUlhd2Ck6ifSFfKZKXa3kFz93w9BjDh80amOOKh8nD4MCgi0rCnGtB85cFmXKwuLqiPDMsx0+dPmmNDY26jufZhMLvBgZUz0nmDs7UIQu81pEmEZGi4hyrVMhbZWVYphDBJE0QOVzyzr9WoLpMxZsdDq8wbYpMml6I1WC6efOmc6Aj7A2P/VQpKzvtNj9QYmXJL8LzHyJDWF6qJ9Psh7pPn332mSuUi9sL5DE99uqcNFS7QHlZQ1L3KHJLmN7U1GRgVsjAgxMhJHJEJ0eK11KLKVW5RBw/yNf+AzXWqNWohsZDLmE0X8c4KN+9nX53/ec9Ah4Bj4BHIH0IcJ2iTtPC9Kyr0TTWM2SLmrg/w2t7DzcNW2qOqe5SWO54uc7sgecSaVyDc1VjCdvw/KJCC+dG4ppXsYi9AEkSzswf55VuwOIqCtOEFn9Hx8Y1j1m1ZkUqHT58VKS2SPOcFbngrer5aHheIv1M9XuJNCREr1pKE4502I8LikA1+oNpxQURpvc+oq7Vxn30ClOGDxtfcgwPMFaoU4FSCBMr/KkmJDsZFgoYChPGDzj4YUyRjv7x44+F/7F96lGls/5QLEQPtWmgr08rNv02LAI1N69VGs6GWWxciOgfhGlAN/KKiE1ORR4Tqh2ud/sVdldTW2/VNQckkVd4opTF4+137RHwCHgEdisCq5rEz09jBjHuiNP85MyezmtCXcIRr/Vp2B4/iYi0JDbjx8wBJ7x88pVkG+5qLCbIGmJzBKKUyGtaUkgk80nmaYtaEC4qLLPcSKWIUsSF4WUiXymu76+gQsHBjQ7SVF0dcbWcEkMwrj3t6E0cDorYvvdhsRbuw65Q7/oNesK0HpE0/82XG7L0+PFjF4JG7k4qJsWp7DY5Vj/++KN1yGXuypUrzsUvHSoEKyeYTKBmQRRQmA4rFC09KlMUIU46hBCwQjMyPOSsx8eUTzU1OeFOPihRLsQglYDGuS36BvbYolOLiVDIZLCAfHIrKCxy8c1sq7au3tVXKi2Tk44c8NJxPOMcpn+bR8Aj4BHwCOxyBFCVlnW9nBwac4YQmEFQ8BYytdeaRDWFxYUcYeruUbHapfim+1xnQ5AlOeFh7pCrPGFC8HayAM08gRa7Z6F1eVkOeDNm/X2rTlly678JKmDpPmYRudEVl+QoeiZXIkEwbcdbjuTZG6rJVNcgcivFaX3zhGk9Imn+Gz991Js+KRw4mxDyRuhbkBq1gHDK+/e//+0IE6TJrYikoZP86L/++mtHIgn9u3TpktVIXclUY/8Qp0450Dxtb1PB2xEXvpep/a/fD9biKHx8J2pra43q3ok2TtKE8h1sarEWfccoROtD7xJF0b/fI+AR8Ah4BLZDgGvovEL0xmUGMdYzaIuyIX+2GrDZ+naD2OZ18ULnjtfaHrHh0bALz9vmI+7lXOUqFZYqBK9EIXiKTdsJUdpqf3NzRKcs29DAii0uBBd7SFO16jQdUGheWdnmuVtbjTWdr9XW5drZiwV28lSByN0v++cJUzrR32DbWEdDEHBEI9Tt9OnTKbft3mC3CT2FUx7GD9evX3f9gzCVSZlIV0NtQ3VDXo6pTOkiaBuNAQMI3POmlVM1MT4mN70hherJfEHHaEmxw1wQYreNPp/K5/h+QKZZNcIMhPy2rRonYG5hmTmgVFZUVilO+IBzvSuWZXiRnPYgS6k0j9iqP/41j4BHwCPgEXi1ECCvaQkTgolppzjNjE3asv7mOrYXDCHkdWGP28JyyFOx2umQbZWyhbED12OK0ObJNhxDJVSmdJAlTU20wKs6S2Ormjcs28zUqjAP7ndPUxWn3NQ2RBxpogYSzwWlVVSE7cjxPLvyVvGG9uKeMGX4SKEgfPHFF+5EcurUKWcfnWpnuJ0OCfMBwvH+93//1xk+oPoweU9Xw2I8lssEgeQGQct02Bgn9wXlM01OTLq6TZCnCSVUTkyO60Q05RIuIU7pbCiQOOVBWinmS07XZg1SWSBLUVQoLML36VZeUWn7KsqF3z7LkdKUjpP0Zv3xz3sEPAIeAY/AK4qAro3LS8s2NzltM6NTBmmanZT9uJ7b7YrT3FyOzB6ihIlwvI2mAVxrXfidcpVwwUNdisjYYSsXvJ1+U1al5GEbPiCyNCZnvGXZiQe9QZDK5ZhXI1e6isqQFnODw5gKCxUyeCjXPvh1qZz9flnB1hOmDH67mGyTo4KVNt75586dM9zhUuWElqqhQBxQOf7yl7+4yTiFZVHD0tXIG4KgYbXO5B9cCM/LpMq0fmxggOJFiB7OeqMjQ4oNnnKKE4RySUmXxG+Th5VKEkWOG98RnPIOCgPC8mgoRNxyc/PcilWu7EgLHVkqd853ldX7HclkNcs3j4BHwCPgEfAIZAMBrofkMkGYJodUMH5qRvbjiyJO5AcHf0K/HjPI0dR0jt2+F5FLXuQXZMkRJa7Puc+NHaQsQZYyseC7uKhaSwrD6+1ZdrWXNiJy68ez3d8YNIREYrh3TeNnu5Azp6yl4BDmyimvqjqs+a8s1pUrFBSVSYdRpVYi9tv/U+ZsxnHLW9s8YVqLRpofM7mGiECYUA4gBkyIs0kMNhvykMLS/vnPfzpCQGFZVKZ0NcgJ+yNnCrWJ/aEyEWKWTYWEfi0vL7lVswVZeVLPibA9QvVmZEmOTfnc3Kzes+ysVldWV5xyiGkEn+XCwT23rZo74T5Xg+blHDg8PGLdXZ3W0nLYDskCPD9fK1ZKFi2SiUOxHBUxbiiVglRcUqJcJyWSijxFIrmOUGUTr63G6F/zCHgEPAIegVcDAa6BLkxPsWxzCtObGZuS2jStMD0RJ10vMYbYLeSJy/fwSI7dkZ14lwwfXNM8GkJEFEfUAQ9FSYuZ+dRVCmeELNGP8fEVueoua4FVc48EvDaePdOcZVV28M9Y8OWDq5o/hKwgv0ALsQWaV2hOoXA510SQVlYoe7KqmlCq7aS6UEvUsdQOKZKrAESNWQRR9Z/4O54GGSvbF7L6xlwt9AbLAIJ6Ub/+z1JrOKh5l4jd2uYJ01o00vwYZaJT1ZoJyaMyM4SJHJUg5peQS4N7HSGEqGDvvfdeWtEhBK21tdXlMkEmMcPgPijYOPKjkzxqGATJ3esx+U+z6jvkiXssyhd0QlkUwcI2fZGbjvumpElLKxGdYCFE+bqxkjMm040HDx7ambNn7YJwqKquduQR9QiHu1yRI1RJ4qQzsYqV1gPvN+4R8Ah4BDwCexIBrpuE5C3LAnthVvWDRJxmxied6rS8IMWJUXPRC3DT5d56+kP2QAVr+weViyTVgTC7XC1koiRBlNy1+Ln7XaYWLYGtt3fZBkWYZmeiNZfig3FVLn/jKnrbrbmMomZWJvWxORGXYmtoOGI1B5qsuFi1iJ7LPhwd9sU8ZkqLxT09bXIM7LOZ2Rm9RxbhkXLNTxpFtrT4H8bA7GWSsVmfCgtlM14TNYAgFC4oDQL33ocl1izHvGLZi69tnjCtRSPNjwm3evLkiXPJO3nypCNMxUrKD+Kkl6KyOOVBYqgH9J//+Z9pVXtQ37AW/+abb9wP88yZM05pClp+1/qvyKpWWRa1ihYjR1FChSoVJVbcLykhNqo4cVLTchVnIJ2MkHtDIULtWGGJOJUI2XtQattnn39mJ0+essuXL6t2Uq1WOpQ4yrKMbx4Bj4BHwCPgEdhlCKAqLc6q+Kpc9KjhhLMe4Xr8vbqU2tD2VEIjvmdPuyL2pCPPxia1aCkVidykiCI7KD4LWcoUSYqNCwKzvPxMzr5LNjK04h7HXtvufnV1UWSpy0YnbqnfK1qsfabbokhSvh06eM7qao9bcVHFS5thnjM9PWy9/Q8VBdSvyBotHi/maaFY8xvNccLhYn1GRKuoxcKh+Fyfw0oRKtsXls04jnmYYry0y6z9Qb0orMWPn8hXPvjLeUyeMGXwsBBuRtFabigokAImwpn+scUzZOoUkVeEBToW17///e/T3lcMD3744Qe334aGBueYRx2iIOKzFkNW0aINN701r+gP/uR1F6bH/XPCxJiQ852s//xMwfliRfo/YZt//OMfnbLH9wQsghi2uWak/qFHwCPgEfAIeAS2RMBdK3UdxBwCxWle4Xqz08pxEpEiXA8lKhqyx8Li2ovplptN/YssaLKQKUK0mpNrj9tzrb1TBWFnCLtDUUJpyp6pEiFyU3LE6+pcljFVArF4QgrCNDffa5PTd628vNBK9+VqLBN6fs5qa05KYTqh8P/yF5gyi1lYmJKq9ESK1k+aB5aIXNVbzrMKOQrPKlyxV0V9h5zStK/svBXkVWnOlvvi85s+0ISnqChal6myKqw5TjAYU1FxyC6+XuiK2FJkd23zhGktGml+jIKCatPV1eXIAHk6QSUDyK/kFX355ZduBeE//uM/oqYCCgVLV0OlaW9vdySN8LRr16654q2vElnggkIY5H//939bRUWFnVVY3tGjRz1hSteXzm/XI+AR8Ah4BLKGANEXKE6YRHCbk+oEeXIFcN0io7rGPcuPaeJQbh7GIiZzduXhQJawBC8qK7FwQYndeySFqe2Z3HPT1IEE0V+UG97goMLxZPgwOy1ymUBzi7a2rDnFqjUdVl508byNjj1Qfak2q64iJG8dYdIi7/hEt/WILE1ODVjzoStKlzimwLsCGxtbsKdPBzSn/VGkatRKio9aafExbbskrh5h+FBTG5FxFWVRgmH+QKjg6fMFdk63GtVlWts8YVqLRpofk79EvSFMAwi1Sqfz3E6HQogcLnEYVIyMjNi7777rrMVx90tX48S5NncKfCAMhC2+Sg0l8u9//7tTn44dO+YwCJqT4qt0PPxYPQIeAY+ARyBNCIiDMN9AWcIoYpWcJ+U3UddpYU7KE3nAqE/6G2XqmazaHG15/s/Pj+mf+2tdR6PKhfs39o/ueYhBQzhPeTjPc5HyFE2TW5jvbMEjej6kcLvFxRz7+sa8tT5eUg5PYuRkXUdS9uf8/Kr1dC/LvXdFOdMbjXmrXT0TOTHVagxblW6h0KwNDN7flDCtroqYDT2ynr47Cr3LtaaDl618XwPoiSTh0jcjMvmT3tOqcLx9VlF+yfJzq7bqwIvXqMNUKbe82rqIlahQ7PNgmxevZ+NBvkjcsZP5UpmKrEGmFGubJ0xr0UjzY/KXvv/+e7eX119/XS5oLWneY/KbR+mAwOCUB9GDuJB3lc4CtvQWknb37l2jmC0q0/vvv++MMYKqxCWP8OafHJfpA8oexBp7dQoHBz2Xa/PR+Fc8Ah4Bj4BHwCMQJwKae6yIFGEWgRW5uxeZWl7kb24iVSJWKytRtz3ey9+m/N+oCqV/tQ1m3+4/7qUYEf5OnSTC6ZyTncs/UiiYiBF5SC4fSRE0Lj9JrxFyB6uamV6xf/5j2tpblfszGwzChMlDe5sInMLylpcSI0wMq7wiJAfePKVbqPCtjB/6BzYjTLKIX15QmsAdGxBpKiuttYb681KSqt3B1BRRzsGL1vrkgbW131FfVqy68h0ZQNTEdbDDCsNzbnkqZLuvXMcFFpvlhuV5U0ueXX6jyN2v7Y4nTGvRSPNjirOSE0Stoddee80VJk3zLne8eSbuEL2amhqnimEAkc6GA11vb69T4ghh/OCDDxxO5FG9Kg3DDSzWCd3Edh51D/Lom0fAI+AR8Ah4BF5VBFjEXUWJ0sTc3USaIFGrkCbdsMd2acIiTKgVzvZas/CY/bdzs1O9JEeQRJJCkSiR2grPaRGmv/952jrbpXgtJEZOttpusq/Rg2kpXY8eyWxqjrIliW0pvyDHqUtNLagnyk+a35wwEb63sDAtdeknhe11KGTvsEL2Tr6U47Qo/J+2t9mDh7dF4MbsQOUHUrDqte3t2Q/kjZwhjB8oFMvf2W76WsjuPM/evFZkh4++PO/yhCmDR+fHH390Vt3Nzc0vajBlcPdJ7QoTBkwqaJCXWCHVpDYWx4c4IWI4Qa7XTz/9ZISknTp1yhG2OD6+J97C+MH83r17jlz/6le/0gkouzWp9gSwfhAeAY+AR8AjsKsRiBlHICLFHjOgDXOcns/ZUZrc/7CoNY/jiVyZnlqxv/zPlHV2UKw++4QJgjQ5sWIPHyy6YrWJHsyy8pArylqr3CEI0fw2hGlubtyF441P9ljN/uN2QPlLBfllL3ZLOGV3d6cI04/Kvx6w6or3RagaHVl98aZNHnA4IHAHD+U6EhdWwdxsN4rX1tTn2tW3i+3ocU+YsnI8+GHfunXL2WafP3/eFWatVn2doLdHjx458jIwMGD/9V//5Zzb0t1nSBOqFnjxYyQkjXymeE5u6e5bJrZPYTjCIG/evOmUpV//+tcuFNLbimcCfb8Pj4BHwCPgEfAIRBGYmlyxP/1x0ro7FB4od7pst2X1AWe8xw8pXZJ4f6qUM1SjnCEKtG5HmFZV1HZ2dsx6pTBNTvU7dWl/9VERptIXMDBH6+/vtoePbuu+xyrL37NiR5hedph78YF1DygOe7ApV8YPwXDKU6UXRyivvVtix054wrTucKX/T8gSoWYUgoUEXL161dUYIjQv6K2np8eFx5FX9Ic//MFaWloy4tg2ODjocplQWQhf5EZY3qtAmqhrgFPe9evXnUPhzFig9QAAQABJREFUhx9+aJBrb/wQ9F+L759HwCPgEfAI7CUEJkWY/v//nrDuThXaTTD8LR04QJLGRlfsiUwokiFM+1UsFpOFfaqBFA9hmpsdV/2ln2xisk+uxSfsQDUK0zrCNNBtjx7/aH29fVYlwhRVmF4u+roZFhCmhoO5IilhzXGyrzARFli1P2LvvF9sx0++nAriQ/I2O4opfB7CRNFaCBMEgNC2w4cP7wr3NwwIcPb76quvDGtxlJ50OuXFYCcsjRyeTz755EU9orq6uoyQtVgfsnXPig3jZ+zUpnr77bddLSbC8nzzCHgEPAIeAY+ARyAzCDjC9P+JMHUFgzAtKSxwXApTJghTjFCRwzQ23mmoS9iOFxb8vNiP+UZff6dyqm7bwMCgCNP7ep2QvPjITzAJU9jefq/ETpzyhCkzv7I1eyHEjJpGGD5QZ+i3v/2tIwG7IZGf2kioS3/729+c+QC1oyorK9eMLj0PIZlYjP/1r391YXkQtQsXLjiVKT17DM5WGTvfGTCniC2OitRiooivbx4Bj4BHwCPgEfAIZAYBCNOf/lsheVKYVuXEl+22JIWJkLzWR8kpTNUKfUNhKpcrXYwQbeaSx1xkaWlWIXl3bHCkVeF2h6yu9owVF/08B4Qw9fQ8kcJ0W0Vsp61q33siTHVxwwRhalQOE8pXbgCK16IwVasu1NvveYUp7oOYyjdGk+K6naV4LBcI84Qw2WUBb0zcHz586IgLZOncuXOuHlMmuj0zM+PUrdbWVpfD895777n73YDbTvHhRBWzdD9x4oTLedsNIZw7Hbf/vEfAI+AR8Ah4BIKCADlMf/6fSesihymJnKFUj4M8qvHxVXss04dkQvIqqkIy78o1cpm2I0z0fWVlyfpVp6mv/64WrMvsYOMl2yd78ZgL3tKSitd23FMpmHs2O5NrFfvetPy8/XEP+0UOkwhTJCCmDweEz9V3in0OU9xHMYVvhDBRVwjXN0jA7373O1VK3h+3ZJnCriS1qba2NlfAlj5DmAgnzEQjl4dcpm+++caFNL711ltOmXtVQtNu3LhhkEVCEcnhSreleyaOqd+HR8Aj4BHwCHgEdgsCuOT99U+TshVXMd0guORpMZUCuo/uL6qoLjWnEkOypDTkDBbqG9YQpsEHNjLarhpK2IYflytvudsoYXWQqpHRDmf8sLA4bYcaL1tVZZMW/PNcJMyscpxa225bx9Nu+Q/WW1nJGSlFP4fsbdU7ovYKCqMueRC4QLjkyauiti7X3hJhOnrMmz5sdfzS8hqGD+QB4TiH0xk20btp8ovxA5N3xhFz+EsLUOs2GpWDl1wRV0IZMZxg/7sJu3VDSuhPajGh7hUXF9ubb775SlmrJwSUf7NHwCPgEfAIeATSgAB1mP7x1yl72qa6R/MJspM09IdNTk9LYVIdpnkV0tV6fEINY4XyimWrrZ+TSLQq0jXjyNL4RI+V72twZChfpg6hUMSZO4TDEeeU1y9SNajitRXlB/WeZoXdlWtOuKD6TH1SmNqUV6WaSgVn9HyDhUMvE43NOkj4GwQO04eKChWu1d/ZbtRhIkTwjavF1nLk5XF404cMHB2IBipJR0eHCyl75513FD8aZfAZ2P2Od0H+FTWkKCh79uxZu3jxoiN+O95wHBuANFGTCbMMGsShsbHxlTB/oNAx+WN8fwhHrK+nGJxvHgGPgEfAI+AR8AhkAoGZmRX7/NNpmSws2oyIShDarIhSx9Mlm5qA8CRG4lB1InljVlD8RK50MrJ4tmAzsg6fn5+U2lPmitJGwvl6rdAZPBRJbcJefHyiVznVd7W/acvLL3a1mIgCGhsdU775sj1bqbeSopOamxUreio+5gM5KRdRqquPWJlc++L0iUjrISBEsOVonl26UmSHmvJe2pcnTC/BkZ4/+FJ99tlnchAZcJNekvjLyn4u/JWevaZuqzi1ERqGSob5Av3HsCJeF5Sd9gTcCGeEcBKaRh9QXTK1/532P9nPo6qB+ejoqH300Ud26NChPT/mZLHyn/MIeAQ8Ah4Bj0CqEZgTOfnq+ow9erBgk+MJyjmp7szz7c1L6ervW7aRoWWbm0uMMLGJpeVem1341opKFi03T2MSISL0LkdFiEI5EJcczfGksDRdtTLlK4WkMi0tztrU9KBTo6ZnhkWcFhSiGLK52UJbXaqzvEijSFa5Pht/bn6uyEn1ftWFUhHd4uKQPpsmwBLYLIV0T5zKtwuXiqy+IfelT3rC9BIc6fljcXHROZ5h0X3y5Ek7derUrnI8m5ubc25tX3zxhcunuXz5sjz892XMtIJCroSmEaJGPg9heZhm7PVCrjjkQZgoYovCRO6Yr8WUnt+o36pHwCPgEfAIeATWIzAvQvLdtzN27+68jQ4HgzChKo3JKa+vZ9mmpxJXvVZWZm15dUiqzjOrlAlESQlkRWxlDWEJKySvtOSAU5pQjCBUKysKA1yYsoWFWYXpLdrwkErmTEVsdblI87EibSO+YrUxjCEnqEvVqnuUn58TCMJUWBSycxfy7cz5QtWG8oQpdqwyck9IGYTjT3/6k75kC04hYeK7m4wLMK2A7GHxjbU1Kg/EJVOTd5z6yKOi6C/kCcKEzfZusGXfyZcsVgOL0DxCEVHW+N7sdWVtJ5j5z3oEPAIeAY+ARyBVCCwsPLOffpi1Oz/O20D/cqo2u6Pt4JQ3J5Wp8+mijY2siswks7lnqqkZsvLKkEhTVOEhRO5Fc/xpDYN6/gLOfHNzqzY+umrDIpA8Xk2CR5KvVCRVqfGQLM4VlhcEhzyGWCTy+PqVQjt5usDh8gIPPfAK01o00vCY/JOpqSn785//7Ca6165dc2Rjt032KaTKGCAvZ86csSNHjmSsJhKkk7BAiANKE4QTtz5Urr2sMkG0yd+ifhc1qLB1J5TTE6Y0/FD9Jj0CHgGPgEfAI7AOAdScRw/m7Yfv5qxHxWuD0lZUE6pDzn1Dg8u2rG4lQ5oQlfLzQ1ZWHpKZVlgEJkc5SDmaV72s9siLz5EilVySwrSqvCWRpaEVlz/1LMnaVBGJNxg9NByMaCE+/jC+dOOPCcU1OeQdOZ7v8qrW7s8TprVopOExqhKmCZ988onYfJG9//77rvBr5CUqn4Ydp3iTKDv/+te/nNKEWx2EhfFkqpEHhsqEeQbYxezNdxuOieCFsofZxddff+0IKmOurq72hCkREP17PQIeAY+AR8AjkCQCKCod7Qt265s555SX5GbS8rGBgWUblOo1KfOHZAgTnYI0QZIIiSsWWSguyZGhg4iT3PRYnGW7KFo4BM7MKARProGEKS4/t1hPZr/sE3Wpti7sVBz2HZS2T+Txw1+X2KHmfCM8b23zhGktGml4jDLT3d1t5P9QxwhLccKqdpsyQh4WZIV8GvKHCBEjPC9TDZUJ8wPUFnJ7CMm7dOnSrgptTBQr1Dzqd0GYDhw44FSmVyF3K1Gc/Ps9Ah4Bj4BHwCOQDgR0GbbBgSX7+ssZe3hvIR27SHqb2ItDmAgVTNRefP1OCZHDchyixHo+KlOsrUpFYvvUoeIGJhKdkm7yllAYXkh1NfMccQoHRGACg8rKiH38f0qtToYPEMm1zROmtWik4fHk5KQ9efLE5d8cPHjQfvOb3ziytNvCqlB4cKrD5ppQOEwIuM/kOCCfuPV9//33knIrHGmDhO428hnv1wySiFMeuVuEcBKWh1PeXh1vvLj493kEPAIeAY+ARyATCKCgTE6s2A055d29PeeIQzKqSjr6uiT1CyOKXpk/4ObniEw6dpTibRYq9A93vPr6KClBcQpCy5WLOEVrf/OfZc6IYn2/PGFK81EaGxtzJCOWe/Phhx+meY/p2TzhYTHix4Sd0EJUj3AGlwbIBxscHHRKF/k95PSQT5Up84n0ILv5ViFMhCHiDkhoJ/WvyN/KJOab986/4hHwCHgEPAIegb2PwOzMqt36dlbmD3PG46AQE4jbjPozqDymEXKKZFARFDK30bcCAoJyVXUgZDU1cuErDUax2lhfi2X40HQ41955r9QqKn8pe3nCFEMqTffDw8Nuwtvf3+/CyDB92I2N8DDGcOPGDf1AZ4xxNDU1ZZSsQCDYNwoTNZkqKysdcSOXKpNKV6aOH+OFIFI0mDw4CNOJEydcDlem+uD34xHwCHgEPAIegVcZgfn5ValL844wjUjRIa8pKI38osnJValMS6oThfV3UHr2y36EwznOWAIr8arqsBZ/AyItPe8qfaIG08XXi6y0zBOmXx7BND8DySAHBUWEyS55N7uxMXknvPD69euOOFG8lppSBQUFGR0OuVSQJcIDcR/8+OOP5e5SZXl5L1dkzmin0rQzMEehxPihra3Nzp496xS13eawmCZ4/GY9Ah4Bj4BHwCOQdgRwymt/suAIU1fHknOHS/tOE9gB/RseXrb+3mXVRxKZCw6f+3kU4kaYO9Q3RGT0EFb++cuGCj+/MXuPGg7m2sVLhXb4aL7LrVrfE68wrUckxX8TUvXZZ585JYbwMcLIdmsjhwjjh6dPnzryR05NcXFxRoeD0gVRQmXCEIE+HDt2zOU0ZbQjGdgZhGl6etqNE3txjC5wysNsYy8qahmA1O/CI+AR8Ah4BDwCCSGAojQk4wdC8u7fXVA9yGAxEkIEZ5XDhGve2Ihc7OhfsLpoFKnFga5eZgq4z4WDx5fsqKzEr71b7PKXcvN+qX55wpTQzyaxNzPhRQ35xz/+4eygmexSv2i3NqzFCQ+DqNTU1Ngbb7zhjB8yPR5IE+YTkCbUFhz7CA/ciySC3CUI6s2bN507IUV7sRb3xg+Z/tb5/XkEPAIeAY/Aq4gALnEzcqS7I9OHf387p4VMbOKC1QjNm5paVV2mFRWVXVbeczD6R94SbnOQpf3KWyrXfdBC8UAK576z5wvtg1+VOHK31iUwhqQnTDEk0nCPUQKhVH//+99dsj6T3YaGhjTsKTObJBzu0aNHLkQMovLuu++6PKLM7P3lvWDVTlge/cGxD/VuL4bl8R3q7e11oZClpaUW+w5544eXvw/+L4+AR8Aj4BHwCKQLAeoOPbg3b19/NeNUHFSdoDWI3bjymIaHUJpWXa6V1u2z1hxZkk152b6QU20gS5Cn9e5zWevg8x3THwwfzr9WaO+8Hy2Xs1EfPWFK45FCkUGNoeAr6hI5KKgDu7VhLd7V1eWICmOLOeVlQ+0gLA8y+umnnzqyBJHAtS8bfUnn8USlxPiBOl6Mje8QTnl7uWBvOvH02/YIeAQ8Ah4Bj0CiCECQOjsW7d83Z10B2yXlDQWxUScJBWxYrnnYoVNwVjwq4yF6sbpOKEuVMlPAES9PYW4bEZFs44jZc+OhPDt3scDOnCvctDueMG0Kzc5eiOWfPHjwwDnLETaGCpLJYq87G8EvP43agevf7du3FSs7YFevXrXGxkYXFvfLd6f3GfqCoQbqHS55p06dcvlhe5FIjIyMvHAnJAcOs429aqWe3m+N37pHwCPgEfAIeAQSRwClZnRk2e79NG8/fCd7ceUMBbWpAoschVdsbHRVitPKz1boGeJ4hLeRs1ReHnb23CWlIcsNoLIUO36oXhcuFdjZCwWqw7S5gZgnTDHEUnwPYYrVYPrhhx9c+BqT3d0cNkbuELbehMJRQBbVDCMCQsWy0cbHx+27775zIWt1dXX21ltvOfK011QmxknxWkjq8ePHndHFbv4eZeO74vfpEfAIeAQ8Ah6BZBGAMGEv3t66aF9+MePyhIIYlhcbH32D1KEyTShMj3pN1GlKZ59zZOSQpxC8wuKQC8OrkLqEG144wGQJJaxI/b0qs4eTpws0h9zcjcITpti3K8X3sVAq1BjC8ihYizKw240JCMvD5ppxHTp0yKlm2QozJCyQ/J5vv/3WhatBmDCj2Gu229i5gzeFgwnHw2xjr40xxT8/vzmPgEfAI+AR8AikFAFyhPp6l+zGF7PW3bXowt1SuoMUbwxytCKHvxkRp1G550GcsCBfkQLFWFLVIB2Qotxcc/WLKiqihCkSCbkQvCCG4cXGjhJWUxext64VW1NLvuaSsVd+ee8J0y8xSckzqDFYiqPGEDpGvs9udsiLgcK4IIA41BFe+Nprr2XNyAJSihHFJ5984tQXCClhj2VlZbHu7ol7VL379+870nTw4EF75513tGqzeZztnhi0H4RHwCPgEfAIeAQChsD42LI9uDsvx7x5o4jtbmgQp4WFVac4QZomJ6KKE6rZTu3HIRgFhRg7hOWaHHLmCfn5OOHtBmTM9lWE7fTZAjt9rkAeA5EtO+0J05bwJP8ixAI7aJQBitZeu3bNWV8nv8VgfBKSglU6YYYoPKgdqB7ZavSHsLyHDx86EkFeFSrTXgrLA2fUJZS0/fv3O8K0b9++Xa9WZus74/frEfAIeAQ8Ah6BZBBYUFje0NCSffnZrHU8XbRnwU1leml4kCPqSS0oLG9+7pnmpVECxeOo6iTlSfzPkaiXPvnyHxAh1CQMHAqkzhQWcYuG3lGYNlcheUFWlNaOBrJXW59rV98ptoMyfUBt2qp5wrQVOjt4DcKE5TUKEwn6V65cyZoSs4Nh/OKjEBQUM+oxoaBBUDBcyGaoYWdnp+vP0NCQy2OCwBUUFPyi77v1CcIgsVH/8ssvXY7WXiSFu/XY+H57BDwCHgGPwKuDAKFsFIa9/tm0Pby34AwVdtvoIUXUbcJNbw7CpPEsLq2aphq2+jxczwXs8c9zDuHC7sI5FhEhIk8pT+QIZYmcH8jTVqFsQcUHsnf4aL7LX6qsjGxL9DxhStORxMWNXB8IU1VVlQtdw/Z6tzcI0+joqN25c8eNjcn7hQsXsmpzHTOiAGvCHrEYB/NskrhUHme+S5DBzz77zG328uXL1tzcLMl7l2jeqQTDb8sj4BHwCHgEPAJZRACl5v6dOReW1/lULGMXNkgTN2LyuCdsD3e9xcVo/Sb+5nnUIm44yeWLGKEuQY5izzPP4vFua/SZQrrnLhba6TMye5Dxw3bNE6btEEridUjFsr55qDDknjQ3N7vcmsrKyiS2FryPTE9rZUUhcDdu3HBk6eLFi1lzygMdsKYmE2GChOJdunTJGVLsFYtxvk845UGYIIe4E6LqeWvx4P02fI88Ah4Bj4BHYG8jAJkYGV6yn36Ys+9vzTu1BnKx2xtjQEFjfLTYmCAX3EKhKDni8a5u6j8qWcuRPLv8ZpELy4MQbtc8YdoOoSReZ4JL3hLGCOSeYERw7NixPWNGgNFCe3u7M1sg/A3CVFtbmwRSqfkIeFMfCkWP/CrIxIkTJxyJ2ysqE4V6CcmjJhMqGqTQW4un5vvjt+IR8Ah4BDwCHoFEEKBw7YN78/bNV7Nyn1tx+UGJfN6/N3sIoJBVVEbNHlCYSlRUNx4S6AlTGo4ZIVRYQUOYsL0mhKqpqWnPOJuRn0VOzf/+7/8aqhkhcNl0AIQwLSwsOBIH5hginD171nCU2yvmDyhLmFuQNwY5xUTEW4un4cfrN+kR8Ah4BDwCHoE4EOiVxfgdqUyPHizYjPKBfNsdCJB/dfRYvsLxCqy+Mc/lYMXTc0+Y4kEpwfcQIkbOCZN3QqneffddN8ndSyFUGD/Ecmqw8yaPKZsN0kRhVwq8UjCYIsGEru0VFQbFkrwxQg+xc//oo4/2DAHP5vfG79sj4BHwCHgEPALJIDA3u6J6TEv29ZezNjiwZMu7M50pmaHv2s9QXBeDh4uXo7lLGFcQahhP84QpHpQSfA+uZl1dXS6nhvC1X//613vKhAA4CIG7efOmCxFraWmxt99+O0GUUv92wtYIyyN3jKK6GFJQk2kvhOVhLd7a2upy4hjP7373O+eYl3oU/RY9Ah4Bj4BHwCPgEdgOAXJ9JidX7N83Z53KNDG2O+oybTeuvfx6RMV1z54vsLMXCq2+IS+uULwYHp4wxZBYf78ugW/dn+vf/eJveOrC4oK1PWlzikA4EpEa8KGVl5e/eM9eeIByBjnBOr2+vt5+85vfZJ2YQFQJWSPXB8MHcqvIHdsLYXkQb8IgMbaYnZ213//+93uGDO6F34Mfg0fAI+AR8Ai8eggsyY67q2NJ5g+qy9QulUkOegp48S2ACGCJXl4esmvvlVhTS56zRE+km54wxdBy7iCr8qCXQ8iK7uVR/yx2j2uI/jbdE/rlfguxH4QYEiTJqRg4iMinfmlp0Z60P1H41BMrKSu1a29fVTXhsujEPT7lL9arwN6TU0NhXoqpksf029/+9v+x993PbaTZtZfImZkSgyQqSxNXk70zm/zeD3aV/1WXq1yucrnK3md7vbszO96JmhnlwJwTSCKD75zbAEVSAInQIJqc+9VCAMFG99enm7PfwTn3XLW/dZOc8Npsbm7KF198IUtLS9r36rPPPjsXtryqzfOrr77Sc/v7v/97VS3Pk83Tsze7TcwQMAQMAUPAEKiBAMnRzjbayNzPyo/fZ2VluagNYGtsam91GQEGPdy6E5Z37kUR+nBy36Wj0/1ZEqY9Eh+SID6TGPE1yFGJjbuy+IYgX5ISsujLBTzjvepDSRQ0WHZ25uKcg0SJnsge/ONjPn3AJyV0/pqamZLFlUUZGO6H9PempPqTaPiFJA78XqMZQa58IFc9GtNYYV1Hr46Hf2bIQrU3ENUc1tRQRev2Ap61PrSu/fDDD4re3/3d32nNz1mPGGeQCC2HDH4gUf31r3+thDAWi3n4LrGpGQKGgCFgCBgC5xsBqkqrIEr3v8sgOc8JgKgsEc/3iZ+hswsj6OHqjZD88rO49PUHJIieUs2OnwVh4o27p0QHxKjoEKBitoTuxiBH2SJIEgmSQ45UVcIHSIqoqyq5Ijfia312IMZP+gKUx3mDnIcv8Q+tYTOzM1A7NmRgcEAmLk1IJBIGmfKLP+yXIB/RgAQiuGjhAN4DifLzcYBAOXv17L9cwLMfE5PySFJYLzQxwfOMdHXOVGIY+kAlhva8Dz/8UBMKWct0lgcJOm15DLVgb6979+5pMuF5s3qe5WtkczcEDAFDwBD4+SHAtWEutydTz3PazPbli7zk8bMNbyDgx9p6/FJA3ngLQQ9vR7QJr67Xm5ze+SdMuGdLIEn53YLktvOSTeelmIFkSoKE99V+p88OOWoSv5qbc2E7NTWlTUZHhkdkeGRYa2pUjcKFowrlp9LE56BPiVM4EZJIEvGG8aAqUVUeVvMAHnizuoD/93//d1WaGOPNtDwmuHVzcF4kTaz1ocpEQvHRRx9pnVU35+XGsXluVJgYasEYd/b3Gh4edmPXtg9DwBAwBAwBQ8AQaBEBkqbtdEkePczKX/+SkS30ZsL3yja6jIDfLxKN+eQX74MsvRVRK16rUzqfhKlCkgpUjzIFye/gAcKkj50iVKaSU5PUKmonfI6JZmygStva6Oio1vj4edVqDFrySJxCsQAeIEz6HMQziBNUKD9UKVr+vDhITP7nf/5HEwHZG4hqjlcUD8Zvf//99xqU8Lvf/U7DH7ptF3TjGvKcSAb7+/u1eS0DN2wYAoaAIWAIGAKGQHcRYJnH0mIRtUwZefhTTtJbKOEwoalrF4UqUiLpk8lrlZ5L40Gh2tTqODeEid++0z5XKuCRKyo5opqU3copYWIdkm7Du7eDNzCPwUAExoqTUNCmxkaqx4YhqJ0Pdjw805pHlSmSDEs4RQIF4hTxSyBE4sRtWr/Yrd4k9T5HWx57TT1+/FgVNBKToaGhepuf6vu05T18+FD++7//Wz755BNtZEuS4SX8WgGE50SFic2DeV6Tk5Ot7MY+YwgYAoaAIWAIGAIuI5DLljX44a9fZmQK1jxraOsywE3sLhzpkctXQqoujYEshSM+XWc3sYtDm54bwsQFZAm1SNurGdlZykgmnQN5KilJ6iRBOoQmfuA8mNTG+hmSpEuXLqlNramFeoVA0bZHq15sMCLJkbjWPZFQeWXwXLmAZ0NVxowz6vrChQueICWcG22R//zP/6x2vHfeeUdu3LhxPHH1CrDHzOP58+eqnDEF8De/+Y0qZ8dsbr8yBAwBQ8AQMAQMgVNEoJDfkxfP8/Lt1xl5+ih3ike2Qx1E4MJoQD78OCbXboYlGm1/7XymCZOm26H+KIvapMx6DvVJUJNgvSvmYLmrKEoHwTuN11Rd1tbWZH5+XsLhsDZQZRBCU4SpMlF+hsl7fqhLDImIpHDR+yJa61RVnE7jnOodg2oaiSEtYlzI/8M//IMSRC8k0nFubK77+eefawgEydIHH3ygKX6tXIvXMTgsU1K4dKRLRyk8vL17qiDxJkF98OCB9r66e/duS/fW4fnZT4aAIWAIGAKGgCHgBgL4vlayGXyh/FNWQyCWl1AeAhJl43QQYAXM0HBAbt0Ny+27qFvq92uoWrtHP5uECfedBjns0HKXl92NrORgvyNZIonq5qANj3HbVADi8bgSCBKndgfteLTmRRgO0RuRaC8se3jtD1FidG9B3sw8SUqoLNGWR5sYm9deu3YNzcC8EXVNayRVJibL0Rb58ccfaz1Zw7VMZEGIS9zjgzIlby19Dz9pjCLRqtxveL/yCnkdlAj5u8p1wfXRa1QpRuNrUGH4L/Fo8tqRBLJhMIkg8X777bfVDsmj2TAEDAFDwBAwBAwBbyCwslKEwsT+TDlZXyshQbm6SvDG/M7rLKr9lu6+GZGBIaRRo2GtG+PMESYSogJrlLYLskP73eouiFKx60SpejFImKgura9vSCqZlPGJcXd7E+G6B0MB2PSiEh+KQnUKSRDx5N2w6pEwMRGQhOlPf/qTRoszKY+1Ql4YVPsYec7oc5InpsrdunVLiexr81PCg/+Y7RMivkbEDYhRuYxnfGXE8+XP3EYJE39WIvWKLFX365BYXKyDZMlp2IW3SHJZk+aQJv5cJU4OseIfd+0/8K2tLXn06JEwnZCWPFoNSVCd41WPbs+GgCFgCBgChoAh0E0EuERYWy3Kt1/tytMnedlct+S8Tl4PLqnYb+kmVKU3ER/O+iU3x5khTBroUIkH313LKlkqQFFinRIbynplaA+m6RldoDMx7sLFC+4SJpwo1SbWNwWjQYkORCSBGqcQ1KYAE/XaSABpBUPWCtEixnAFkiXGizMxzwuDBIek6YsvvhCm5g0MDOyrTD5Vdkh8cO8oGQIhAjGqPkiMXpEinI2SI56Vc6/pv6/+qXO6JEwHqU+FBO2rSlSeDpAm/LX3+EikKg/djjuofA5HYQIjz+Vf/uVf1GL47rvv6nkZYapzCextQ8AQMAQMAUOgSwjkYcVbQVPbn37IyLOnecSNl6VoSpPrVwPLJkkm/eh7GpC33o3JxTGUsSDkwc1xNggTFqYFNJnNbCCmcWlXa5XYcNZLRKl6Uai4MFKcz1ygs09Op2p61KaHJri05iWGYxIfiGqqXh1xojpF158Z/PDnP/9Zz5cL+CtXrrh+jHZ2+OTJE62zosr06aefqk0yCMK5V4IyiQf8nUqOlDyBEDlEiUdURtTOoRv4rMOoHBufQ45UgfIFpCeAhy9YIVDOHz4JIBMY//Ef/1EJKvFmtPixKYwNzMI2MQQMAUPAEDAEDAF3EeB3rbTiLS8X5MEPWXnyiKQJX/TDrGLDPQQSKcSHT4bk3ocxGRgkWXr1RbNbR/E2YcKNxsayOdjvdtdgv1vPSHYzr6qSWwC4vR/2XqICwMGIbZKmej2Y3Do2+zhpmh7UJpImhkPwvQPChFuHqrkfEkTWCVFde++999T2VnPDLr3JOqtvYBt8+fK5vP3GG3LjOuqsomGISLRyUlnif7lOgxw1DkDVstcD4gS/Jf4H8oQH2JPMLyzIP/3TP8n4+LgqeqwbM8LUOLa2pSFgCBgChoAhcFoIVEkTezQ9fkDSlJNNKE0lD7mjTgsLt4/DgId4wi+T10Jy604Yz1j/4vvlTqx/vUuYsH4t5ktQk5Bjv7IrOyBMtOB5UVWq3gBUKGiZevr0qdrwGLGdRB1TpwkTj09LFhvdxvrCkkAEudY2halQuM+yq+dbfV7AAp4NVefm5uTevXu6iPfEAh7Xg2pRIZ+Tp+gV9ezpYxno75UbVye1vuy0lbgqXs09O7a9HvxXoccPtQmkaXl1TX7/+/8Hr25Ebt2+LW+ABJ7GPdbcvG1rQ8AQMAQMAUPAECACJE3FotPY9hFI03PY81jTRMuejdYQCCBFug8JeJeuBOUmyNLYeEhrmFrb28mf8ixhYiz47kZGNma2VVkqo37JYyLAa+iynochAyRMLMQnYWJS3mmSBx6LDW/7JpKSGIppw9tOEwMqOAwiIGliDdMvfvELCYVCSuJeA+mU3nBqk1iTVEQj4wy+zVmTxfk52dndlfGxcekf6D+TJINBEZvpHfnmux9ka2dXrkxeU5JqhOmUbiw7jCFgCBgChoAh0CICNLRsb5fku68y8vhhTuub1OTS4v5+rh+jgpTq9SE6PCLv3otiTYfwM3dLll6D1nOEiQtdxoPTgpdeZL1SxYJ3Bkg4E/KYYsYak1QqpeEHrfZgeu1KNfGGP+iTUDyEFL0YSFMUdr1gR1P0SBJ5zn/84x+1fomEiTHe3VjEU1HaQ51PuZTHM2LmWZ+E/xoVUFO2troii4uLqvoNj4womT17YQk9SsqnECyyiiTG4ZGLcvuNNyUQJEHtkA7dxL1nmxoChoAhYAgYAoZAbQSoNNGKl06jHvlFHu6XnExPFSSX3bO6ptqQHXqXRCkU6kGoQ1Bu3AqrusSaJbeiww8d7MgPniJMTMLLoQntNi14y6hX2s5JGRLmWRmsX1pfXxda1AYHB5UwMfChG4tyH6x4wXhQ4ogfZyAE+zZ1KnqcRJF9p/7jP/5DI8UZRDA6OtqxsIua9wOJEohRmSSpmMcziZITC87tScTTILO0DXK+I1D/WGN2mupfzXm38CYDRdiPaXFxSZKpXrl+8xaUxAiSE0GaGBXT6a9ZWpizfcQQMAQMAUPAEDAEHAScNUlZFuYKiBwHaXpZwBfu/LLXse8ZTq8jwOVNCLHhk1dDcu1GWCYuh/AFuA9rzc6XnnA2niFM2ogWylJ6cUcJUw4Nac/aoNKyvLwia2urasejJa/bC/JgLADSFJPesbiEoTr5g7jjOjBIFNnviKoS+x0xiIC2vNMYGtpQRn1bETHzxZyTfMevcY4M1pctQWFiY2GSpVGky53WHI9Mpa0fiwjX2AT5m52ZQRJMRK5evSrBcBTXFqSYShMDIhgWYcMQMAQMAUPAEDAEPItAPse6poKwrmnqBf6/HQl6ObxXYwnj2XM4jYlRVaIFb3g0gDVmBD1OQxKJdtiDd+TEPEGYSJZysN6llxyyVMhAHTiD6SGMrV5YWEQPpm1Vl0Zg++r2cKLHAxLtD0vvxYQqTUqaXCbktCL+4Q9/gDd3W27cuKGkiYv5jg78F4VNZakoOaoS1CUoTfX+S0NlaRP1VrQPcm7sF9XnkSa7zeCkDXlRi/XixQslqJcR4x6NgjCRKPEBpckXoKIIckz9utNFbM1M3rY1BAwBQ8AQMAQMAUWAxIjBD5vrRZmCNW8KNr2lhYLsbKNfE9Qmr9fud/IycvnCZQyJ0fBwQC5NBlVZSvWinU7Yd+pmmq4TpjJseNk0+ist7GiPJfZXojXvLI50Oq2WL8Zr05JGW54XBi2BPtQ10ZqXuhCXGOLHVflykTSRLH755ZcyA9Xj8uXL2lSVwRcdGyBGtN2VClmQpQLy53HfnPCVDH+fAdGYAmFiTVM/yNL4xERXLJPt4MJwEZK/p0+eaGPeCZxDAmmM2u8L11ob34I4+UmaQJ7AnNo5nH3WEDAEDAFDwBAwBDqEAJcuTIDezZRlBdHjL0GaHj3I4Qtop8ntCUubDs2qu7tVsgSjTCqFyHBY8BgbPnIxiLUOiRLTg09/fl0lTCRLjrK0K9vLO5JHv6WTFr2nD1HjR6QtjYQhGAyqJY8Lci+NIGLHac9LXoxLFEl6btrzaHe7f/++/Pjjj0Jl7Ze//KWGK7hev4X/crA2SUMdCggEQc2SUynZGMnW+h9Y8lZXV9WOd+36dSUars+zwxeepOkxotJZNzdaUcp43+0PBECo4lRRm/g1jYZC7G9gLwwBQ8AQMAQMAUPASwjksmXZgC1vbgZq08u8zM8yTIyJv16aZWfnQjIUiyPYYTQol6EqTVwKIwXPr0pTN4hS9Wy7RpioIjENj0l4rFvK7cBWdUaVpSqYXIRPTU1JIpFQwsSkPC8NkgIlTUjOS8Gex15NbgVBUFVjnPpf//pXjVT/9NNP3Q9VAFnaD3XQYAeQpSa/eqGdbRcq09zsrGRBNi5fuqTqzCGy4aWLdsxciDeVPSqZrMkKh8NHtnbUJh9rmxgIEUAfJybp2TAEDAFDwBAwBAwBzyHAJQ2+D4VNj6SpqAl6C7MF1MYXZXeHzW49N2XXJsS8qkjEJ/2DfrlwERY89FdiGl4SjWl9/u6oSgdPrmuEqZgryRaI0uZsWrJbuYNzOrOvGSbw7NkzeC2HVWUhcfLiCEaD0juekN7RhITw2o0SFxIRpgP+6U9/UrvYxx9/LJdARlwjIkqWilIuZPBAsAOjZFoYVDD5mIEtjwQ3hfhz2ic7ah9sYZ6NfOTly5caY8/myKzHqlczRpJEwuRDMIQ2vzXS1Ai8to0hYAgYAoaAIdA1BEieMrDpzc7k5eFPOVWddmnTQ3r0eSJOtNghUNqpVRrxy12EOlyGDS8BotRNRenohe8KYSqBOWc2crI2tSmZTUaHn32tkYtw9vh5/vy5jI+PK2liIb4XB4MgIomQ9KK5bRxqUzBC5aG9mfL82cCWwQ98vnfvnty6dauG6tHCcfB1Swl9lcp51CsxNpxfv7RRCcm5kiwxCn0XCg1DKnr7+oBBmyC0cGrtfIQq2dramoQRYDGBey56XM0Yvrphcp4/iPo1KE4aP97Owe2zhoAhYAgYAoaAIdBRBEiMCvmybKNv09pqSckTlaeV5SKIE9Wos9m/id/b+tn+JtiD9ZdfxsZhvbsckKFhtMNBnVIYqXheUJUOXtxTJ0zlUlkya1nZmNvW5rRFkKfzMFiET4VlanpKJq9Mqk3qdYuUd87UH/BJBL2ZesdJmmJofNq+VYsJeZ9//rkGX5AsvfPOO+0rN1CSGBVOVYl2PKdeqX0cactbBmFizRljuQdrWtraP04n96AR6ejHRJp3ZXJSG/EeezwQQp8fTYwZBgHi1EP9+4yRxGPPz35pCBgChoAhYAicQwT4PXEuV5atzZKsr5VkdaUoq8sl9GRk+i/XSQ5xoirl1cHlBh/sm0RSNITkOz4G0XiWNry+Ph8Sf6Eqtb8c7QgEp0qY+M1+Fv2VtkCWNufTuMC4Azx8cZtBnKEHJEx8XEeQQB8UC9fsaM1MpNFtcdMyKS8xwh5NIE0DsGu1eZOyD9U333yjtkRaxGjLa9mWiHuFEeF7IEpMwiujZsnNQQsh1RkmzbEGiI1se2HPO0tjHfPn/cYgC/a9ojWvEQKkpEl7NlFpgg5upOksXXabqyFgCBgChsDPGIESEvWyGfRvWirI4nxBVpZQ4gIilU6XUaNdhiLlvT5OVJKicaw5E1CUEAs+MBTQOqXhESf57rSaz7Zz25waYWKgA9WkjZn0fsjDeSFLvABUV7h4pdWL6goX391uWtvIjcEQiAQUpoHJXjQ/ZR8fMKkWBxPbHjx4oA/WBP3qV79SHJq3uuGPHYSGJKmcR80SIsObDXc48RRAyNLbaRRUTmP/ZXzL4dSdnYVrVj23NHpfzS/Mo1/DjkxCJWv8nqPShLqmYLRizzPSVMXUng0BQ8AQMAQMAa8jQCseLXkkRzs7UJygNi2DQK2uIlVvsyxsiMvf5QvYDg8qVKelPtFKx5okkiQ2nOWDceAkScOoURrCc7I3ICH8Hh1QuhYT3uw1PjXCxJCHnfWMbExvaf3SWU/EOwg0lbPNzU2tYWID1zt37jjf9h/cyKOvWc8UjrOeKaHEKRQ7EE3d5JyZlMeUwG+//RY1RyX57W9/q+pNcyTEiYgp0YLHgAf+F6FDzJoEb20NtUyLS5JEouHY2JhGjTc33yZBcnFzKnrz83PCOHv2vurvH9CI9EYP4cN/qTRBT+15Rpoaxc22MwQMAUPAEDAEvIAASRDJE8lRDo8MFKY0Yshp29tYxzMa4pJA5bIIijhg28NHHAKFHXAffDQy9g0pdClVfqA7iS+rLn82mk2ifxItdowDH8AjCVUpFmPDWdQtgUD5PZB618j5HtzmVAgTyRHDHdZebsruelYY+nCexsEQAdqjGCLQshWtC8CwnimUCMrQ1T40tYXqgJ9bGazjYlLg119/rYt49mJiAEYohOapDQ384eJrEK1Xog2PNUuN/hU3tP/DG5HU5fM5efb0Gf7Ye9SWRyulNoA9vKknfyJBnZ+f1/CKsbFRfGsz3ATWPCUqTYjrZBBEiDVNbHDbusLoSZBsUoaAIWAIGAKGwM8EASpJhUJZLXtZJOxl0dcpC7JEIsVYcjbD5TOtezmoUFSi9BnBElgSnfj9NIlOAIQngi4moTDCGUCAIlHUJKndDqQIz7EY3gdpikSc30URFV4lSWf5MpwKYcrvFGRrYVvteIUc7VVnGbLX507CxIS8FRTg+0C1J69Oth928PphOvoOrXj9EylJIWqc/Zmat9HxWw7+MW4rYaLS9Pbbb8vNmzdPDiOonBlrlpQsIQ2PjWk7SZaqYJI0MZ6b804iBp4qE1PnzsLg3HnfkTSxDxMbBjefzEjSBKUJhMkJgiBpsmEIGAKGgCFgCBgCZxWB6nfNfOYatQBbHuueSJYymZJkdx27Xp62PRInECZ8B6tqFZvk6ud0se70P6J6xPjvIAIbSJhCIEr8LjwUAjHC6yhIUpUsMUSsqjYRv31V6qyCWZl3ZwkTLhRT8dIru7IxBSseVKbzZMWrXnvejExb21jf0AUrVZVozJuR4tU513oOIWqcpKl3LAGViX8kzasNVD0Y/PDTTz/J5OSkkqb+/v5ahzv8HslSqSil3C5IEwMe8Bd7CoPXjqoYiQfH5JUrqg5qgtwpHL+dQ3DujEZfAGGq9mKKxeMt7BKkCU1t/SEEfyBB7yycewsnaR8xBAwBQ8AQMAQMgRoIODVRtO2J9nnizyRNXAaSKFFZYr1RsEKGauzi3L/VUcJURpJHLp1HIt62pKEwnZcI8aN3BReu2kR0cwt58r1yAYlr9ZqIHv2sl36mFY99mfoQNR7ti+CPo3lrHlUPkqX79+9LCnVB77//vuJx/HmiILFYcAIeEPTQalPa449R/7fsxTQ7N4eEmbSMIt2PARCeTjisnArvO4aMMGyEtkc24KUVtBWiy4hETc9Dc1ufHwojvx6yYQgYAoaAIWAIGALnHgGSIw6uK6qvnXecf0mcuLbg8891dI4wAXza77ZAlvjIwZZ3HtUl3ji0oj19+hRJJTtyYeQCevoMNllL4o3bj38MgQjSSxA13oemtqE4G9o299dBwvTs2TMlTKznYh3TpUuXjj1BNqPVkAc2pkXfJfzJHru9279k7VXVUhmHQjMOW96xTWDdnkCL++N/2Bg2QsLE17QTkqQ2e832Dw+S5A849Uy+QKN1Z/uftheGgCFgCBgChoAhYAicSwQ6RphIjhjwsA4r3g4seZT3zuPgQpULbhIm9mIiOeCi9SwoFLWuBxfbbGg7cCWlDW2bVZlIHmdnZ+X777/XhfxvfvMb7UtV61j6HhvTMhGP8eHUgk+ZLHEOnPMWiAftbbQUjsFSyWvoRyCClwfvPdZekexlkZhHK2gf7I8tEyacLPsyMTnPH4ohYp4qU3OE2ct42dwMAUPAEDAEDAFDwBBoBYHOECZwo1IRcYYgS1V1qZXJnYXPUFFhPPXz5881Svvq1asa+OD1xfZx2AYiiIAciYM0oTcT+jQ1swAn+aBNjJY8WvN+/etfy+3bt2sTSNYtwYJXIlnSuqXukGoSjzyuIUM7VtEMljVXDFFoPkDhOFTd/x3nzWjxZRA9Kk205LEJL5Pv2hk9fqeeicTJSc5rZ2/2WUPAEDAEDAFDwBAwBM42Ah0hTHuoXcrvFmTp8RpUJvbS6c5CuCOXpnIq1TMqQRWhFY+pcOzfc/36dbXjnZVePrUwYm+mSCosQ9f7JdYXbipmvKp6kCx9+eWXWsP05ptv1uhLhbolYFdmyEORYSCnE/JQ63z5Hone5saGzCFAgQSRtUztqjX1juXm+9pLCgSVwRXDqL0i0Qs2HONeZyY4f9Yz+cNxDYNgfZMNQ8AQMAQMAUPAEDAEfq4IdIQwFbJF2V7elTUoTPkdxkOfE3hxHrQa8nScf5EmAgsXm9XOzs1q0ANjtEmWmlFlvIgOlaVeRIynLiYknGyunoW2tsePH8t//dd/aaw448UZhHFw7JVBltADqVTYlT2odF4YDH9YgL2NjWBJmEYwZ6/3ZKIddAPznUNoBXtIkTRFoki7a7L27DX8QZIC7M3EHk1Wz/QaPPaGIWAIGAKGgCFgCPx8EOgIYcpsZGX1OZrU4vmsNqllDj0j0fmgYqYPqBDVqMXqLUJLXmZ3V9Y3N9DAKyxjE6P4dp6JY3gwmhtqzVkcTMyLgCjRlpcYjjclMlBlokXxP//zP1XxeOutt+TatWv7MLDf0h6teFSXOtycdv+gDbwg0VuHJW96elpSvb1yEaSJcd1eHtX6q2nE2sdiMe3F1HJS3pETdax5FdKkTW2PbGA/GgKGgCFgCBgChoAh8DNAwHXCpH2XFndk6dEa1AMsjM9Q2APW+Y6CBJJUgo2QZK9UwKMIosRzIXE6cj4kByUEFxQKRY3hjiViKJrnt/NIHMOzP+hX0sSY5rPkbKJCwWa2Q1f7pBcx44Fwc3Ux7Ev1xz/+UZWON954Q0iaqoMkiSEPrF2qmV9Z3fCUn6t2whcvXuiRh2Fvu4i6IK+PNBTOKZA8qmFsXtsLsueKJZTWPKhLGgCB57ZVK68DafMzBAwBQ8AQMAQMAUOgBgKuE6Ys+i5tzaVl7eWWRh3XOKbn3uJCmUSIJKmIKPRiFiQpVwJBAkmq2Am5TT1roX4ev+eCUheqEJXoiKK65AdxYlR3MMz0MZAmkJCzsvDkOdCS14uI8fhAc414mdz21VdfaW3NnTt35KOPPtLrTnWpjPjwUp5WPKbieWsw6ZBzp80tjp5GDPHwusWSNXQkqFQ7acnT4AcQdDdGD/sz0ZYXxhcBGiZxNhVTN7CwfRgChoAhYAgYAobAzxMBdwkTOMUmGtRuzqZlZxXqgdcH5kuLHVWkAkkSaq+oJu2BONHqVI8gNXxaWFuyQzJJki/gV5WGtUEkUVVi1fC+urRhGOEPrGUahDWvmYTpNVjbfvzxR3n48KEGYTAtjwRsDw1qNRUPljyw1C6dVf3DsiaIUd2zICDkypcvX5J4POHpiPFdWELnEVbBGiwSJtZeuaIwVWBiI1sfG9oyNe8syaT1L7P9xhAwBAwBQ8AQMAQMgYYRcI8wkXxAkVl5viFbIEwFKDSeHpgvyREVpULGUZXUdleVlDowedrz/LC2BaN4QHXiz82QkA5M6cRdsg9T4kJcLtwe0LqsRmuy0um01jF98cUX2h/od7/7nYSCARCmrCpMToPaEw9/6htQLWSQBy1u2zgHRoxfQC0T69O8OlQVQ/NahlUwJW8UDWzdjLV3VCb0ZoLK1OMPAAZTmbx6L9i8DAFDwBAwBAwBQ8B9BFwjTOVKlPjqs3VJo4apg7yjbRSoKpEckSjxQfudK4pSAzOr2vRCsaAEqDbBpseACC+P2EBEhhExzrQ8JXkNTLZqbfv973+vNTWfffap9CUT0lPOA/tcA3vo3iYkTbTlsS9TGTY32vISCH/wqpUyn8/D+rgkiwuLMoA+TBMTE66n+zFmXG15pjJ178a0IxsChoAhYAgYAoZAVxBwjTAVQTq2V3ZlY3pLMpseXRBDVVIFAWEO+Z2CFHYRbU0L3pEgh05fCZIm2vRoz1PiBLWJ1j2vfnEfjgclxYjxsYSEosGG4GE9DZup/uu//qvawz58/z0ZHRkU8EPg7b3apYMnxXuEtrwlkCb2N2LCX//AQO3mu/pBmveOjtNTYZjuRwskbYQMfLh06ZKEXFbEDqtMjd0DRxGxnw0BQ8AQMAQMAUPAEDiLCLhGmNiollHiJE1F1AJ5cZAYFfNlyaVzUJaQ1MaGurXWuqcxefIjkCSSJio3tOg1anc7jekdPAZVsEgqIiO3HJWpUaWFtTX/9m//po1979y+KTevjEs0HDwTYSCsZVoBWWJiHmuCmD7HuO7XBqVUlVMP3ki8uBXCVH1+7YPuvVElp1MvX2q0+Pj4uAZWuHcE7Ann4UO0uD8MlVBVptMjhK6eh+3MEDAEDAFDwBAwBAyBJhFwhTCRiGS38rL4aBXPOY3fbnIeHd9cwx2gLOWQ4kcbHpWlrpGlA2fbg15NTNFjzyNGd3vRnkeCxDlevDsoMaTl+aCONTJyuZz84Q9/APFYkonRC/Lm7WsSQ1PVszCoMlEhm56aUoWMpInpcz3C+6bStrhKlPT5yFkpUSJx4v+IF/5lcl31/SObt/OjKmKVmjFGi4+hhqkPtVduD94HvlAMoSVojKu1TG4fwfZnCBgChoAhYAgYAoaA9xBwhTCRfOysIo754YqSEc+dJr78L+aLasNj7Dn7KXmBLFVxorIUSgQlnHCUJl1fV3/pkWc2sh25PSjJ4VjDPZlYW/P111/LwtwM6pei8vbdO0ici3nkjE6eBhsSr66uyNbWpgzCksdAhR7eOGy8y49XCVPdXZEtOXRJn3sY8oFoeZImps2RR7l0sanmPX/2TNU7hlToXJWc1Z1c878gYUItEwmTDw8bhoAhYAgYAoaAIWAI/BwQcIUwUbFJL+3AkreB1DmPpeNhZctABypL2U0EDiDJz0tkSW8yXVf3wPYWkjAefkSQu7SOdu0eZs3VAKLFGTFOYtfIoK2NseILMy8l5CvLm0qY4jg3ZQqN7KKL28C+ifnnMrtQmjYkFgnDkhd3yE7Ls+KF5umjmbE+QJq0dg3PbQ6GbLyEJY8klUrYKBruNmqdbObQWssEsuSPEIv2593MsW1bQ8AQMAQMAUPAEDAEuoGAK4Qpt52XDUSJs/9SCelzXhrV9L485khi5zmyVAULC2la8kIIWGBNk9eseVTBUogX77uUlFh/Y+oCa2vmZ2dkbuoZsN+Rm7duShJpc272CKrC59pzRTVi7HkZ4RRMySsU8uKHnY52N3cGVCcljSRM7MnlKE94s+Xd0/44OzsrVJpSqZQGP3SCMHGO/gAjxkGYaMtrY84tn6x90BAwBAwBQ8AQMAQMgVNEwBXClNnIytpLBj5knNqgUzyB4w7lhDyUtL6qyEQ8qkseHiQlgYhfIr1hz4VAcF0c7YvIwGSvJEegEjUwqOxtra/KzIsnsrG6LJNXr0pfX98xaXMN7LSTm4AskSjtadNiPFfqlTp3SMpNFcXJx9APEKgWVRsqS4xCZ91VFHViTPbrCGECGD2w5QVCEelhLVOL8+0cprZnQ8AQMAQMAUPAEDAE3EXAFcLEZLzVZxsaJ37aEd3HwUG1K7ddEKpLJQQ+nIXBWiGtZ2IIRAjKg4cGI9AHr/VJ31hSF/onTY3EI7eD4IQXT2Vxfk7GxsdgFxuSSCRy0kdP//eY694eyZLzOF0p0gmE6FGlCXY9Pjc5NFp8dVWW0TuKStitW7c6puTRTugLwjoaQWJeC3Nt8tRsc0PAEDAEDAFDwBAwBLqKQNuEiQRpC41qV55uIFQh39WTOXhwOqsYb57ZyEkRVjwmibU1VAngwpZ7cZQB3Z9T/c8cAOcY7R6GlicQpWgfVKaYt6LGSeAGr/ZK30TKsQwChnqDeJN8FDNpmZt+IXOwi7G2Zhjx3PF4YwpVvX27/b4qSrDfsT+Uc5+0eUjTMHEAACF8SURBVBFbnSCufY8qTbjuvNGasLux3moL6tLCwoKUgf2dO3fE72et1DEXqdV54nOqMkXRzBdqU6eO0cb07KOGgCFgCBgChoAhYAi4hkBbhImLyzL6Gm0tbMvKi01P9V9ich+b0zLu3A11iaEH/iD60MAyx1jt6iJRiQFS94pQsIiFxpW3eXl8iBpnHRPDFXhM8jMvDKpffRNJ6b+UOtEyuMckOdT+FHM7srQwJ/Nzc6osXUQYAWtsPDN4D5eQnAhyp6y32xMjaaKC40ewBi16DQ7Wi+3u7oCYzgnrmW5CYQqjeW2n6sWoLPnDMShNsOaZytTgVbLNDAFDwBAwBAwBQ+AsItAeYYK6xCCFzflt2ZjeUtLgCRAgEBRzRe0JlUftksaItzgxkhf2ICr7EZ2eTcvSxpJksjuSBxnAyhaNWKOSSvTKUO+wxNCjplwAJlC29vDsqBXNH3i/lilVUZk6pBI0OzMSpuTFuPSDNJHMHRdMsYcFfKmQBYnMyOrKktbXsKaJPYL6O9AjqNlz4fZqv6MNr8QwEA/Vt0FdIglx1KbG7HkkqCRKMzMzsrO9I5NXJ6HkJVwMqjiCMOboB1ny4/6nymTDEDAEDAFDwBAwBAyB84pA24SJfY0257ZVZXJDyXEDaNoE87sFtePpnFpxWEHVIUEIRvFtP1Slla1FmV2akaXVRZ2iKktQJ6g0hVDPMX5hQkZHxqU/PigFWBPzmYIqTtik+cFj+30If4DK5KHEPCprcfRh6htPSQyWQeJTb+yVClLKMgQkq32MlpaWZBvNVccnJpwGsN0mgVTAoCpRXQKzrXca3Xsf+PT4grgPmERXH+fqBFXtBUmdBmFaX1+vENM+CYXC1U1cfkZPpgAUUFWZOnUMl6dsuzMEDAFDwBAwBAwBQ6AFBNoiTGUQEybkbc5uy/byjmcixUvFEvouwY6H+qWWQiiqZAkhB4GYT3JY9H/z4CuZnnspyURKiVEylpQilInVjRWZWZhW0nRj8pbcu/Oe2vJysAMybIIWvVbEi2oz2wjDH8JcNLdwdV3+CG2JjBTvG09KfAi9eI4hTOUi7HjZbdkrgriil9EqwggYSDDKpqrDwx2tr2nktKkqac0S6pa8OpiapyqTKjiN3QBUmJaXl516MeDMxLxODc6N/ZjUltdtAtypk7T9GgKGgCFgCBgChsDPHoH2CBNqd3ZWM9qDaXfNO5HitAmyUS1rmFohTKossR9SIijFvYLMr8zJ/cffw4aXk/fe+ED6kv1aH8Jv9Te21uXhsweysDIPIjUmv/rgN+JHDYr2fyJpwqMVlYvrz0AUc0Aj2xDDHzywICWJi8Am2DeekCR6Mml9Va0/IeBSLjJsIw382ceoIBtQPWYY/DAwICMIfggjKa875wQ1CQy2XCFMnlSXqpjimjP8oQf1TI2GQMzPzythioEojcL+2MmADdZa+SOoY7J48eoVs2dDwBAwBAwBQ8AQOIcItEeYoJ6kl3aVMGU3c1iEeqMOhFHiJEwtpeOBqGjzWNToBKMByeR25fnMM/np6U+wN4Xkbz/+PxLFIpEJZBzpnS0Qpofy+OVDGewbkt9+/LcSgI2KZKCUY6x5XufSNHHDPJiWR0seVSaSlW4PVb1AJHtHk0qaOL9aQ61uqF8qIfCBCXSsXUpvbcmLFy8knkjIhQsXdCHfqUCCWnPaf69ClsDowJW8cb/uz63WC5ImTc5DGl0DIRC0PlJhIu5XrlyRZCcDNljHhBomf5B1TLwXun+P1oLQ3jMEDAFDwBAwBAwBQ6AdBNomTBr4MJN27Gew6HlhZEDeckjHKxdQ0N/MlLDeIymI9kckDGJApSmby6rljgpTAUEP7735vgz1w+qEhWIJC+61jVV5+PyBrG+uyRhqmD565xNNJiNhospUQC1TZj0HuyJT2JpAB3NhHVM4GdSGsZ4gTDinAEhk72hCk/IC4TqECepNqQDFMZdxSAkuwvbOjrwEYWKPIEaLs4HtqRMmzEODHlBf5ZClZi5IE9fO7U01NY8R87RmHk9K1tbWhKRpB3hfv35dcXZ7Ovv7w1wY/ECFyUfb4Alz2/+cvTAEDAFDwBAwBAwBQ+AMIdAWYSpBYdqcTcv6VBrJcK3Z3zqBFe2BVJhIWJohKSQl/pBPCRPVJZIe9rfZSG/IDyBM80tzkkqihml4TBLxpDDKmURpYWVB+lJ9cnXimkyOX90/JVr2irmSNvRVtYvzaWJwPrQFRge4ID1+odzEblvfFFMIBAOSGovL4GQfaqvqECbULZXyu5qSV2Wsu7u7muBWhD1vaGhIBvGoqnStT6jJT4LgMoyizLqlpph0veMAEP3f69dGr7Qeo7lrXvtIVJmQmseeRydEeLMXU1Vluo1eTEwk7Jj1EX8fGvxAwhRA8IMRptqXz941BAwBQ8AQMAQMgTONQHuEqVCWjZktWZ9Oaw8mEoRuD05hF3VV2a1cU2SJ89baJdQLRVGn4z9ABmgpm5p7IY9ePMLzS+cUuUbGsSLhCBLyxuX21bsyMnRB7XjOBs6/JWCUQ2qeEjj0aWp2hECYYiBMGrDw+rq82d21tz2Oz3mkYMkbutbrhFHU2GMZtV6MEy+hjqlKTLLZrLC+Znt7WxfxFxH+QLXpNIejLlV6LrV9YIABgqDBDJpid/DiOJHyqmLh3mn6Rqw1NxzDh9S8Hk3NO3iswxtTWVpaXJTp6Wm5e/euktNGrHyH99LoTyBMmI9PbXkR4HFyml+je7btDAFDwBAwBAwBQ8AQ8AoCbROm9SkSpi0NNvAEYYIt0CFMiItucviDPgkhZCEcZ8PYw4u/heV5rWWaXZpF36UULHkxKUBJYQ1TFtYzqkvXLl1Xu97Bw7Kui72gcrAJUm1qdrCeisl0VL68UCJCUpm6mJDh61CY0J+q1ijnnfolBitUyUI+n9famhUk5fWirmZ8fFyCqAk7tUF1SWPEC5hS88R1f54gSUyHnJqdl6npOVgyN/CrIwQGrF2/OsBx+ntT8u5bb+CckSbXQA3S/nFee+GQE7XlHaMy5UBMWcP07NkzuXnzpiYSBoOd65NExcuP/mOsZTLC9NpFszcMAUPAEDAEDAFD4Bwg4AJh2oQlD4QJSkrXCRNWqQxXYHIfFZ1mB0lJuDcsYcSJkxhwlLDI3kUs9svZF7K+tSbJeEoGegckEomqXW95bUmeTT8VPxbDk+PX5I2bb+I17FMVe5LWMaGRbRZ1TGym2+wgYWJNFQMWKrtsdheubs+6KjavHb7RL8GahGkP5BmECc19GdtdHWptRFIeVaYIEvJImKKx2D5O1e069qxkyYkSr5K4po9FRQkqSnmvR56/nJVnL6dkZXX1td3QqrmK93O5vFwaH5P/+7tfyWB/r8Bhib+RNsga7itHZaofsEDLI4/98OFDmZyc1ETCSAejxUmSNPghHFdsXgPD3jAEDAFDwBAwBAwBQ+CMI+AiYWoyYKETwIEw0T63u5ptkTAhlY7NYg8QpmroA6PD/QG/xoYz8KGqFjgpeQ/k6dQT1DH1y6fv/wopelCEKipA+4QJFsF9wnREyegEhifsk72YVGGqR5igrmj9EtIFqehUB68LG9fSKkbsGHmdgtJUxbG6XWeeGfZQRDBeO+pSxX6nwQt+2UqjWTPOJ5uD7fDAoPpEW9zX334nu7sZuX5tUj775Scg2jGdg5LIVq2rJGyoYyJpqseemY63BmL64w8/KCkduTAiiUTywAxdfok5+VHD5CdhqtzzLh/BdmcIGAKGgCFgCBgChkBXEWifME1TYUp7w5LXpsLkgw2PfYao6lQteSRE3z38VhZXFmV4YFh+ee+zQ2EFmWxGZhdnsc03EgwE5aN3P5F+EKdQ0LGbsXFtgQoTmui2bMkbgMIUhKrQfb6kylsKCtPQ9ToKExbsJdYvMVL8iJrC4IepqSlV5hgtPoCeTKcS/ACCUmYyHh6tqksauqDx3o66U4SKVMK5kggeHNlMVubmF+Tzv3yJgIygvPv2W3L75g2Q6DDwwJcK7P+EZ/xz8GMNv1bCpIl0hy2jB3ewAZvgg59+koHBQVWYmEjYsUHChKQ8PyyqWl/lhZu0YydrOzYEDAFDwBAwBAyBnyMCbROmDdQvsYaJZKDrljxcQVryWq1hog2PIQvse1TtMcTGtH/57gvY8dZl4uIlEKZPD9nIqEAxJe+bn77C0Xvkw3c+kiH0YwqHkBqGQcKUQ/NaxpxrA1t9t/F/tIaJoQ+sqeo2YcLxNfQBNUxD12rXMO2RSDAhD6QJF+PQieagxszMzMguFJhBLuZBmk4l+AHzKCPtcK/cvE1TT4DKTiVwQRvIHjqrwz+sg6z89OCRfPPdfRkfuyiffPwh7Hj9ep78+6DCtFcGcTtCtA7vpf5PrGHyoZEtZKa6G7Hn1ZMnT4RWvOHhYQ1+qLtxu79QwhRGtDga2Fq0eLto2ucNAUPAEDAEDAFDwIMItEeYQAY20IOJpIkqStPNWTsBCL6431mDJQ8pec3OhzHewYhfLXDVQINNRIr/7/3/lSWQopHBC2q5o3pUtZJt725rDdODpz9KLBqXv/nFpxo9TrWJg0SSiX2FHVjCmm3sC4ISRgPdGBSmak1VJyBreJ+YTwBKVwp9mAav1kjJqxACVZhQx4QLcGjXBQQ/LCwsyAair1PJpIwx+KGDgQT7B9+vX6LC1PzQxrENRHqTEFFd+uLLv8rC4pK8+cYd+eSjD6A2It0OxIJDk/qUNLUWbe4oXZW0vDqnwiRCKnm05zHC/QISCTs3EEaBvwcqTErkKufZuePZng0BQ8AQMAQMAUPAEDhdBNoiTFRPNue2ZR3R4nmoKM0SlE6dagb2N1V0iq01iyVBCbJxLQjUDgjRo+cP5QlqlPjz27feRfJZvypItGOtoQ8Tf89+TKOIF//k3b9ROx4JFRfQhUwRjWuzUsxjLof5w4mnz3ohJUyoYeLrbg8u+tl7KTWWkIHLJEy0px0YOF9a3zRSvEDCdNh2xuCHFSS4MSkvjOCHy5cvSzjsKHEH9uL6S1V1aMk7UFPVzEF6oOjQbnacuqTXulCUZ8+fy58+/4va8X7xztvy9pt398kSj8ntABL+B7XrCKFsZE6cg/ZjoppTZ9D6yHAN1lJRyRtHvRgmUWfrdt92ejExWpy9mKrEsN292ucNAUPAEDAEDAFDwBDwCgJtE6b04o6qTNk0eu802Zi1UyAwIS9LC1wLNkEu+DT4AcpOAMl0jA6nHe+bn76W6bmXEoXNida8VLxXcug3tLS6qI+BvkH0Yrojb9x4c/+02Ng3v425gMA1jQ3Wt6xbCidhEURdFdWvbg9iE4qjcS36MPVNJBWfQ3OqEKYSYtbLxdcJE9PjWF9DlYmEcnJyUhPzOr3IZu2SPlogKPRB9pAIINDguHmSCG1sbsmPDx7Kt99/L1cvX5G3ESc+gZS8g0MJk1oESZhehWIc3Oa41zoH9j6iLa+OR5M9r5iUt7y0pHViJKadJUz4coGWvKARpuOunf3OEDAEDAFDwBAwBM4mAu0RJljMdlYyqjBR1aHi5IWR30XNEEhTAf2PWlG92LSWyk4Y9UyCUpEiCvWXEPowvTCDeqU5lJ+gXgu1UmUsfAOw3rEv0+WxKzI2PCaJuJNItt9/CfMo0a54WGw5GSbwI8Z2h1FPxTomTxAmkDbWd/VCYWJSXrXOa/9klDCRqJIwvWpaW/09FTmqHnNzc1JA/PWliQlJwJrX6eCHPag5TthCC/cnFB1fAArfMTVDPD+Swdm5efn6u+/1+ZMP3pfbt25KHOl4RwfDMMpFECZVvJq7MRohTOx5tQnb49zsrCSBLwmTH02CjyN8R+fY+M9UmEiYoDApYapfW9X4Pm1LQ8AQMAQMAUPAEDAEvINAm4RpT+1mG7NpECcU+nuEMLFuKAdlh7a8VggT1siwmwU0ACIYDWiceL6Ql63tLVnZWEZ/nSyUp6IuQCPhiBImKkyxiNNXqJqMl9suSJFkqQXljYtbEqUwGumyngo/dn2QtEX7ItI3npTEMJqVMoji4CBhAhFgDVMtwkR1hcEPXMhvgzhdrCTlMU2uk6N1wgTQAXwjhCmfL8iDR07YA2uHfvXp38jklcv7tW4Hz88hTAx+eNXY9+Dvj3utpIfBD4H6ClMJ9yZtec9hD2TPq0uXLqkFslp3d9z+m/+dEabmMbNPGAKGgCFgCBgChsBZQqAtwkQywkCDjdltoTWvVGjeYtQJsGh/y+/kQeZaV71IUPwIgKDSRKWHoQsnqTwkBCRHhaxD2IqoX2qFsBET1izRikeF6TVi0gnQGtinD3OKDcaUMMVrBVGcQJh4CNYxsb5mHb2C+pEeNzIy0vE6pk4TJu0xhaAFJuM9evJUieBHH9yTESTU1RqdJkwkbCT0j9C8luodmwTHE1AE8dr9AcKEeiqtYTKFyX14bY+GgCFgCBgChoAh0HUE2iZMDHvYnN+WTahMGmzQ9VPCBOByymcLqB3KOwoPiF0rgwSJZCWIRrYBkCeSJgY/UHWoCj7OnhkXTXWlrKl4tAISi1aUJc6TKoI//Kon1ElErZVza+UzPr9PkhdImFIS6UWU9NEgChIm2N/qWfJ4TFrXllBbs4YaGwY/cDHPurBOjtYJE2alljynhqneHAsIe5iBavbt9/dlcystb71xV27dvC5JkJRaoz1LHlQ9EJ/japiUuONaPARhIt4XkZLHXkydiXA3hanWNbb3DAFDwBAwBAwBQ+D8INAeYcKijPa3LRCmtZeb+tor0FDtyqVRywRrXrnQQu1K9UTAjEiU2H+IjW0ZBEECo9Yo/I5EiY8SjsE+SyRNVLhaVZZ4WKpLtOOxXojWwH12Vp1Tl56JA+uX+idSteuqlDAVKoTp9dAHTluTBRlIgKQ8LuxZX5OoQyzcOk0n9IF1ZC0ooGrJqxKmKk0+PLMMQhZ++OGBfP8jouVjUfn0k4+hMo3UJSgOYUKNVwupfZrUp6EPtDHWnk91do8fP1YL5CAaBA9B7epMhHuVMFnoQxV3ezYEDAFDwBAwBAyB84VAW4SJUDDcYGthR1aebiBCu7U+N52AlIRFI70RRlHMsedN+0ehwuILkEFVFCYSJu6X6hJIkvZZcuE4TMeL9DHsAf2ejqo47Z9Gy3ug2jZwpVf6LqVUeVPSeHBvVcLEGqYaseLclIRpC41VqTKxzubatWvak4mqXadG27HiqBfSXkwsbjsySPq2oCp9jt5LL15OyZXLE/I3H30oqVTSIdU1tof0CGLNlLzmiXxPDwg7I86PiRWvHpI1TOzJlEqlVGXqTIQ7CRPuU4sVr8Juz4aAIWAIGAKGgCFwzhBomzBxwbi9vCsrzzackAVlEB5ACcSFKhNrrPJsGutWIEW9db0LRImoUb0KxgJqeWOfo9dISRehDSEAY+Bqn9Yw1bQJ4tqTnDiNazMVNnl4wrxfdhH4sAjCtL62JlevXlW7mK8j9TWVY2vfI/ZhYshC80MJio9Jha/XALEmS5vV/u9fJZ3e1ijxt+7eqWszpLpUVbxaYfGcA2uGwFJOPJGZ6WmNcY8wCh+JhAyAcH+AMLFxLWPFGUTRQeLr/txtj4aAIWAIGAKGgCFgCJyMQNuEiYfYXUPflxcbeIayAKXFK0NVJqTUZTdzqja5oTJ1+twYaR7tRdAE6qaoaHlmgChGEUIxMNmHSPF4nWnh2oOcFBErTtJUS0EhYWLsNRWmRfRj4kK+H5axzqgflWkyxrvSi6nOxI9/G8qSNosFSTlKYDOZjPzw0wO5/+MDRIjH5cP3foG6rDEJIsb76OC5s3kuCRNVplYGlS6HML1O3o7ubwHhGmwSTDJKYtqRWjHW2yHswR+Kq/JlhOnoVbCfDQFDwBAwBAwBQ+CsI+AKYaKKsz6TlvTCttbyeAkUKktZ1DKxgSxrjLw8WCNFohRFlDhfH12cd3PuVJTiiBLvhx0vMXhMSAMsd8U8IuZzuzUJE8+BQQRcyE9DARkaGpJh1NeQbHRu0C4JhQlNiFtRdXReIB09VJloiTugomxBVfrzF3+R2dl51GNNyAfv3ZPeGnY8JUskSVC59nD+rc0DVlCNFIfCVMMeeBQ/Nq9lIiFtkNdhfVSMD8z96PYt/ayEKYKQEhImkrh6EmxLe7cPGQKGgCFgCBgChoAh0HUEXCFMedQuMfhhfWrLU8EPRBdf6itRYiNbkiYvKWCHrj7EpBDIUjgZRow5F+feWngyiKJvIil9Y0mNOz8094M/QM0p5bMgTNtQU+rX6HAxPzU1hUa/cRlBP6be3t6De3H9dRnNhx1lh3NqQQUFMSBZglyjpKVKmthXampmFvVYGcSk98oozuVouMI+WeIcSJp4U7YyOAeQNjaKbYSYaPNaNAnOIpTiGhSmJGqZXO/FRMKEprVKmGpYFls5TfuMIWAIGAKGgCFgCBgCXkLAFcLEWiHWMS0/WXesb146Q84F69P8LhLz0Mi2wEayCGnw1ABZCoQC2nMpnGCtjLfIErFi2MXw9QHEiseFzXzrDyQGVgmTKim1t9zc2JCZmRms+3vkAkgGlaZODrXCUd1hHVM7hGWfNFFpOtkyWbXh0YLHOeCfFk+TZIm9wBj4QPxPvkcYqjELjBmyceXKFe175a9hFWxxQvoxEketX6LChPnZMAQMAUPAEDAEDAFD4Lwh4AphIgHJbGRl8eGaxnh7jpDgqmmPJNYzgTS10yPJ7RuA5MgXQs8lRIgHo0HPNKk9dJ5YmzNO/eLdIYnDjsd48foD9rdCTkrZHah5DFmoTU7T6bQsoIZpBwEQJEyjo6P1d+nGbxi2UAl/aJ20YCIgCHz09IC4UFHhzyAvB+mLc8b4lzVLleNqzVKrRE3Pn4TJScdrlJgUUCtGUko1j7VigyClR9WvdqElBiRMfqTkYYLt7s4+bwgYAoaAIWAIGAKGgOcQcIUw8axoeVt+ui6767BjebFWCOtX1nIwapz9mYoeUJpIlhjyEIKqFAJZIhHR9bfHbhPOixHnF+8ManrfSXNUwoQaJjaxrafmUP1gHRPDH0iYuKCv2tw6c/oMXGD4A+akVsHaRK7hYxMEhkEoSSCBekWZcKR9sqTnr0Sp3eMh0h7peCRNjd4krBWbRUPdZWBM2+PIyIjL4Rog+1C7fLTk4dHovBrG2DY0BAwBQ8AQMAQMAUPAAwi4RphoddtEHdPW3LaqTB44t5pTYK8kkqb8tkOaulXTRLLE2HA2qGXQAxvjHpIpas6+O28GIwFJDMfRg8lpWHvSLPbQY0ijxev0YuLnWfuzvr4ujL4eGByUy5cuAYPXU+hOOlYzv9+P9G7Hlnf0gEqUSJ6cy7dPi0iS2lKUDh6I6hIsgEqYTk7Hq36SXxAwKY+ktLevT3sxuZqUh3P3+Z0eTP5A2AhTFXh7NgQMAUPAEDAEDIFzhYBrhKnENDqk5a0+35SdFSSkeXioPS9X0rqmYrak/ZrqOMfcPwssrKnYkCyxFog2PK8qS9WTj/SGZfBKn8QHmIZ28oJ9D1a8cgHR4ogXJ0mpNdi/aHs7LU+fPJVkMikTIEzsE+R6KMGhg1djvfOqNh36lZd/gIrVrLrE0yFhooq3uLgoUWA7NjYmMTfTCEGY/EFcM6hLjQZReBlmm5shYAgYAoaAIWAIGAK1EHCNMLG4nURk6dG6JuZRyfH0gADAWqb8DiLHEQhRLrDGZV8f6MjUqSr1oLcSG9OGYXELhFnE/8rK1ZGDtrlTzi8+FFM7HsmSr4H5aq0Q1KVSbqcuMeH9koEt79GjRxIKhWR0bFRSqV7xd7KBLbCgLW+vXGli65oC1CbIx368WrtUqZk6dtvDvyRhoopHwkQiSttjIpE4vFE7P4HIaUIeCJMTRNHOzuyzhoAhYAgYAoaAIWAIeBMB1wgTT4+L4I3ptGzMbmm4gjdP+dWsuF4myWPNVX6niAQ99uphBQrtVK+2a+uVWrW46MW38REoS1CVAgh58AcDIAfeteFVz5m1VcnROBLy+p06nYb4XSX4IZOGysGeQ7UHbXlPHj9WvJmSNzQ0LAGXU9xeOzIu+itrXqv9kF7ba8fe2LfiMZ3vQJ1UIwfk3yMT8pZAmHIIgKDtMeVifDvrt/yReKV+yQIfGrkmto0hYAgYAoaAIWAInD0EXCVMPP3d9QwI07ZszqbPDBqsYypBYSJxKuWLeKD5KqLSVXGqEqfqcyNnVSEVSpLQgNYf9GvKXK6Uk62dLclkd6UPNSV8MLXsYGBAI7s/zW0SaFbbN57UOPFmjltmHVMWhAnWu3rss1AoyMsXL4BHFupSSi1jbqe41ZwzSROInKM01Sd0NT97mm/SildJxmuWLHGaJEy7SCFkDdP29rYqTKxlcsv2SFUpEE7Akhc5TVTsWIaAIWAIGAKGgCFgCJwqAq4TpmKuKFsLO7KCnkwkIly0nYmBaXKurMUqor6J5InqU5mKE6x6Bx+1zofkiMSHDV71NZ61VomECVY2kqatrU15MfVC5ufmZWBgQMbHx5U0xWIx1xaxtebW6nu03/Vf6VXCxHCKZgabxBaZlIeIcYBX86MkTIwW30BPpkg4rL2CQng+jeHEfbOZLfsy1Z7facyj/jF4L9GG17wVr7pP3s9U8VaWl2VtbU1DH3jfBUDS2x6VwAd/BPcuAx9sGAKGgCFgCBgChoAhcE4RcJ0wcZG2s5qVFUSM57bzSjrODHYkTRU7XhkkiWSpXCRxcuqzlACyNusoCawSJVjsfCBKTLzzgSj5+DNrftR516PE4PmL5/Lw0UMlV4zTZiH+MKxoJE1UV9z69r9dzEn8aMcbnOyV1MWEEsFm9ql1TGxgm98FH6mt4pRAVlZX1zT2mvu+fv26hBFOcGqKG5rJsleUzs9LpIn3Eyx4jOzGP0CmIR9kzctDUrqGPkysY2IaIa2PYZDStjGmHQ+BD+y/xPQ+G4aAIWAIGAKGgCFgCJxXBFwnTAQqhyAFJ2I8rRHeZxK8CnnSdTQIknKkA8/7NU5cy+oC13nWeGn+XCFJB9e6tEVNTU3J/fv3hX2IorGo9Pf3K2EieaJFLxzGIpS1TV0eTPFLIOyhF3a8WB8sV02u2TVcAT2PimhgS7Wp1mAoARvYzs3NSj6XV8LEFLfTI424yJhDGTHjniFNuHFYG6RkqYW6paM48zow+IH9mBJII2QvJpLzdgkTa6v8YahLIE18bcMQMAQMAUPAEDAEDIHzikBHCFM1Ynzl8bpkNnNnx5bXzFXGWltHE0SCJGlubk7u/3Bfi/F9WGhGImFEPkelF8X4w8MjuqBNpZIdT4s79lRxTkzxG7yKKPHBqEagH7t9jV9SaSQJ0TqmAprF7jPMVxtXLWPTIJEkTlcmr2hS3qnUMb2aBkgTlCataeqyPY9kCfcE74t2laWDp7e5uan9rphGyAa2rBdrmzCxfimSlJ5AqO19HZyrvTYEDAFDwBAwBAwBQ8BrCPx/AAAA//8CrYJ4AABAAElEQVTsvYdzm2d6PfoQvQPsnSLVJcuWm9Zt7d3J3ZtJMrm5c//S/PLL5Jdkkp1dx971rqts9S72AhAgCRC93HNeEDIlkxTKBxAgn9eG0L7yvueDZr6jc57z9FUwxOqBIxZzRYk93ZLkRtq8tvoUvXi8TCYjq2urcu/ePUkmk0Lo+/r6xG63i8PhkKGhYZmempKJiQlxuVzHtkS70yb+Qa8MzkXEHXBJn62vqblUymUp5XalXMhJpVz85TGw/jK2mV9YkPjmpoxPjMvg4KC43Z5fbtvWT/CDxTzKlRKeS5hrGWez/q/F4UvoA8Y2EZtdbH12POO1NIf5Qefgb215acn83kZGR2VgYMD87g7atp7POFeb3S12T0D68NvVoQgoAoqAIqAIKAKKwElGoK8thAmIlUsVkKVd2VpKSjqR6ez9Z5deMRKmjeiGPHjwQHZ3dyWXzUmxWBSXxyUekIT+SL9MTk7KFEjTcRImd8ApkamghMaD4nC1cEMMQlQq5qScy0gZz4eNJdzMRzc2pL+/X3hD7/P5Dtu0vZ9jvhUSpkqxSpoqJE5tHiDMYB0gTCBLNgdeW0eUajPnb211ZUUy2ayMAt+hoSGci6SsuWGzO8Xm8orN6akSveYOo3spAoqAIqAIKAKKgCLQEwi0jTDxH+jzmYIkFnZkZzUlpQJvRHsCk7ZNMp/PywaIwb379ySVSkkWN7CFfEG8Pq+cnTtryBJJA8kSlaeOD5zSboe6NOSVgTNh8YTcTatL1bmTgFRVplIufehy1tbWJBqNQllyy/j4uASDwUO3bfsXJE3mAUXMqE380dYeVp69r6phGaIEAkIC06ZrTqJOjLcSCRkdG5MxPFoiTE63OKgutYngWYmyHksRUAQUAUVAEVAEFIFWEWgfYcLMSsWypDczsr2SknQ8Y963OuFe3r9QKMgmrGckTLvpXbHjZhlmLNibbDJ7ZtaQhUAAN6JtunF+HXa03nnDbgmPByQw4heHuwV1qXYykI9SPmuseVRvDpIaiQkVplKpJFPT0xIOh2t7H88zCRPpDBUmvqZFD68rRnFqhfVTTcIV76P9zlZVGXN58Xh8eHjEDltmO659LpczRH0dpImEiZZP2kCbGpi73e3Fb8O/R/COgdg3NXHdSRFQBBQBRUARUAQUgeYQaCth4r/UF3MlSa7DmreclHyqYP71vrmp9v5eJASsJ3k+/xzksSQ+v88QJn5GokS7FOtLjms4vQ4JjQUkPBEQl8/Zorr08yrKxTwIUxq2vHyVhPz8lXm1s7ODG/p12U3tGsLUao3NK4dv4S1JEznTPsKE37QhUdUv9o59GInaI0isRyKvANkwhMg822UBtVurq6vix7Ufw7UPRyKmls1q0lSAsklSSusja8Qmm7Z8guw5nIYw2Z3eFnDVXRUBRUARUAQUAUVAEegdBNpKmAgDSVNmO2dUJhInWvN4r3kaB7GgLY8EgZYor9crVJ1i0Zhs72wbskRL2nFY8qguBYZ9EpkMig+BD7Ymgx4Ouq4MfGDwA0lTVWV6eat0Oi2xWFQ2Y9XgB4ZfMASjq8YeUTJKk/kBV617Zo787qUfdZUglctQ10pQpvDscDqra6K6RPKEP+7cuSN37941as+ZM2eMJZPqGq2JrVjmzJz2/VFCndzW1pbMz89LKBSSCdTJNVUnBnXM7vKhfskDVdS57wz6UhFQBBQBRUARUAQUgZOLQNsJE6EjSUrHs7L5fFtyyTxKQ/Av9qd0kDRRaeKgLYqhD6xnWlxYhCXLLsPDw4Y4dZIwkCw53A6k4oUlCNLk8FhNVpCGVyxIKZvCtS8YhWb/5a8pIFRbhoaHgMGIIQ1WKy37z9nca6pLr+6594F54h97ahJeMWRhZxu/eVjiIqhNCwSCLxEhpiXeunXLXP8I1KUJkGUSZoYyeECmSZqswIBJhEmQ9KdPnxqiNIZzNG57hLqE36sdVjw7wh4wsVeB0PeKgCKgCCgCioAioAicSAQ6Qph4k8kAiOR6GkpTUnIpWLN0GARqqtPK8orsJHcMUZiZmTHqkxU3y/XATCteEDVLYahLJka8DffCVJZKedjyUM/0qsrEG3oGEtCiRgWESXl+v98SslDP+tu1DQM+nj55IslUUs6ePbuXfoggjT2y8fjxY6Mw0S7nABmhNY92xNGREaM2+YCBJcQZJJ1JeY8xFx6P9r9BkLJGBuuubAh7sFFhgi1PhyKgCCgCioAioAgoAqcFgc4QJqBZRgCESc2b35FUjL2ZqirLaQH6qHVWFYCkrK2vmRtbFuUzLY/WrHYP9lzyDSAVbxZWML8L6kHzcdNHzhV1QCWoTGVTy/RyxDhJI5WYxcVFcSIhcASEgQqIlba0I+fWpi/nnz+X27dvSwJkkCT4woULRj1ywp5HhYaKDyPm4/G46UfF680H7XJUGmu/A5KcGslqdqq0PT7HfPhbG0IdE1WmRkaf3VFVlxzoD4awEh2KgCKgCCgCioAioAicFgQ6RpgIKGs6UujNtLO6K6lN1rNAejJWptMC9+Hr5I0so5/X19eNulSL124baaBzDDft3rAHQQ9Ql9B3ycq6pYNWWobKRMJUKmRNZPf+bWhLXF5eNnZFkgWGE7Rt7ftP3KbXZdgun4AQ3YbljoSIBPDcuXNyZnZWIiSDUJSe4XuqTNt7tr1aA2M2hg1CbTqL7dmXiwl6rRImRtgz9IHPnMs00gjrHvid2KkuuQOYt9V2zbpnoRsqAoqAIqAIKAKKgCJwLAh0lDBxheVCWXZAmtifKb8LxeEU1zO9esWraXEbpqaFpIG1LO0KgGDdkhO1SmxQyxhx6+uWXl0dS5dQy4Twh3KBjWyZmPczW6YCwtjrFKxjXDdVpqajr3956o5+wnWybolkiHVKJINOqERcF8MdZvCgikTF5wlscrzu7JXEWi5eb9YzkTBOQ5Uaxj4MjGiVMHE+JOQ8FxMZ5+bm6sMEZMmoS0jFY9iDiUSvb0/dShFQBBQBRUARUAQUgROBQMcJk6nZSSPoALY81jOZqHEqTTpMAATTzBh+QBsWSQNvni0nDlCXTIT4aEBCo35xB9Eo18JUvKMuZQXKS4mECSpTpYTmsHuDN/RsXhtHPQ/tiLSMGetabYMeeqa6tA1i8gSEibY7JiPyGtJuRyJEex6bx65BTSRh2sY1ZxAIH2zay9jvKShLAbzmPlYobZzDZiyGNMKYUawuXLxYF6J9sN9Va5dAmIy6hB+PDkVAEVAEFAFFQBFQBE4RAh0nTMSWVrw8SNPWMuqZNtJ4jeQ0HQYBKg205dGmxQAE9mZi/HirCsN+eO0u+4sIcQ/Iks3Rprql/SetvabKhKS8cn6PNO2pTEXEq7PWh2SRCggtiUyKs3LdtSm0+5nJh1TLnj17JisrK6ZuCAsRGy2QWBNJE+12u1Ce+D2vOdfKBrlsXjsCdZHWPZIlq0YR9WPbW9uyurZqGiZfunz5tUSM2NtQs2Rz4TrgWdUlq66GHkcRUAQUAUVAEVAEegmBYyFMBKhcQn+mLcQuo55pF/VMxVxxv0OrlzC0dK5UGWibInFgXVOtnseStDSIA3anXbwRj7Hh+RH2YEIeOi0aVMrGmmea2aJHEy98Nfhipxr8AAsaCRMVFivUFUsvUB0Ho5rzHGSJfY9Yv1TCdeT6aMtjPRITAOeQmkf7HWuKuH4m4pFo8drzctC2x+2sUhdLUPOYlMc6JtpgGUDBgI2j8KWiRLJkYsRRV4WqtzpWr5soAoqAIqAIKAKKgCJwshA4NsJEGEt59GfaysnOesr0aSJpOu0hELX6F2NPw802a12YlkZl4qib23p+liRHJEtB2PD8aE7L3ksQEY5llHEDT1teLWa8AhLFOqZFRIuTXIyMjshA/4AJRziWCTZ5UmM5BWFi+t0KQixIUkiY2KCY13CA/ZhABGnJY/hCzXZoByHJF/LGlphIbIEoDxklyuv1NTmTl3cjpnnYHhndTpI2OztrSNqhRBwx4nY2qGXtEoiekqWX8dR3ioAioAgoAoqAInB6EDhWwkQ3FuPG01CatldTsoswCCpPp33w5pZBAbRrUa1gWACVptrNdbP4kCSFxgKw40E1gC3vOO1uJBYVqEulLK65CYAomxv5WpIbbWu9GPxQI0y049FWST5ahGqYBnEiQZpCfVKtNolkZT8J5nVnDZdRF4HP1NSkDA4MMs6w2Uv+Yj/Oi7VVz6F6JZNJmQQJD6M+jirXLwbO12dzIAgksGfFa/38vziHfqAIKAKKgCKgCCgCikCPIHCshIkYkTQZpSmRRWNbkKZ41rzvEfzaMk3e3FKRYIF+PJ4w98sMCqBFa/8Ndr0nt6NGyRNySRBpeLThMfDhOMlSbd5UlV6k5kFdYfADa38YmEByQWXtUAWkdpAufCbxIVliXRZxNutCXZrL7TKEKRQ6vMcUFakYwi/W0fSWDWxZw+a2IFacMPF3tQDCxGCRQTTIHYig1xfsjxX8o0UFNj02FGZ9YaUIcoUQwz4b+kUhrIIx5312NK51MAACJA/rsLmcIN34HeG9+d4CUteFl1KnpAgoAoqAIqAIKAKKgBw7YapdAzayZU0TlabMdlaK2dPd2JY33bx53tiI4gY3YSxcA7jJpa2rkUElyQ2yxDS8biJL1TVQZSJpojUvA2KRlRiIQhREkeSQvYIOVEAaAeC4twVJYagD65lYnzYKKx5TAA+rTWIdExUgKlReECUqiwNQ25ohylUSRDIEIkRCVCzJKlTLrc2E+LyeKmGygzCZ77ENvi/li1JMFfBATSHIE9k6k/L6QLptqH8jWbKTMLlBmDxukCY847WN9VAgUHzfx+/4DILVDcT8uH8Cen5FQBFQBBQBRUAR6G0EuoYwsXaJjW13ExlJsrEtYsfZs4n/Kn5aB0nTJixatObxxpNBCLTn1XMTyn/wpyrg62dj2qoNj2l49ezbabxNah5IUyGdkkS8ul4GEszOzpqQhE7Px+rzUWFaXFw0xGkI5GcYytFRyhlrjNjENwmljTHjJI7E48hrh78n5u8KFSK+BkEq55FGmMvjHx/yUsajhMd2bFNStArir1U4vM+Sh30YBlHYRj8oPEq7P0e+v8Bjz5n3Yh74kRnlyesWZyggrnBQnOGAuAfwHAmI0+8zJKqPKhXVKfwesYgXh9MXioAioAgoAoqAIqAI9AIC3UOYgBa5URn/yp3ZzpvkvN0Ybt4yCAcAcTitYRBUmUiaNqC8UGFiWACT1o5SHGzoqcRGtD4EPPiHfQh6cCPgoXv/tZ/WPPZkKqKeaSexKUuLCH7Aj4H1PiQMR621F/6SsQ5tDamHtBoyKp5Ww6Pq0ahEUWViaARfc/vQvoCIF2smMTJ/afAMZapEcpTOgRjhkQFJKkAlqqlL/DsEQrSbQiol6uMYMz6A+qiagse/d6V0XvL4B4sSGkqTcNU1DDEHGUI9Vh8VKNZlGdueUxw+D4iUX1wDIXEPgpxFglClQPyoPIE80cqnQxFQBBQBRUARUAQUgW5HoKsIUw2sEmoqCrhpS21mJBVNSy6Fmz98dhoHb5hJmp4/f24UhloYwmEKRZ+9T1xep+mzFEDIA5vS0pbX7YOkqYQ6psxOXBaePZVMNiNjqN/pB0k8bK3dvqba/Gr1aKxJo6VyhlbDI3oskQTxujMAg01ta32pGD2+f5AQUTUq7WZAlFD7B6JUzkFVQu1UucB6pF/+QwPVK/6eiO/w0LDp9UTrXSlTkHx8V4q7ealA2W15QElizZOx7flBnIL+qvo0GBbP6ABUqJAhVKo4tYy0HkARUAQUAUVAEVAE2oxAVxImrtk0t4W6tAvStAt7XjaJfz0/pbHjvOFeQxgCG7tSmaDyclAABGPD3QGXiQz3D/nwGrUltEH1yGDoQA62vOdPHsnOVhwKSL8JPaipID2yjF9Mk+SHdWi8hnbUAzHAw4u4+BfWtl/sUf2AiXlUFmnpm5yclAhrn/AV64xotStlclWiRMK0pygZmfaQ4/Fjql0kTKlUEvbOYfGAuJVRP2iseKghJNGydBgHHqx7JFCoa3L2B8Uz0o8HSRNi1cMgUkGfqYtS8mQp8nowRUARUAQUAUVAEbAIga4lTFwfSVMRvZoYBpGCPY/PhexeMfopKm2iJZE9ihg3zZtdqkysZTIBELREwYJHFcmLcAf/oM+EOzg8ezUjFv1QOnOYCnoFZeUZCNPm+oqEAgGQi2mjgnTm/O05SzXAAzHxyyumOe3k1KSx5tlAno4aOahBDMCIgjSFgyEZQqqdC/2RSrs5KSTR3wmEqULb3V7d0uvIEs/FUIl0etck5Q30w5KH0IcyQh5ImEic6jnGUXM+8rtazRPrmRAY4e4PiWd8ULx48LXDj7h71EMZq57WOh0JpX6pCCgCioAioAgoAp1DoKsJk4GBdU2op8jBopeG2sQUvXwaNRa4STxNgzatjfUNxE2vm5oeKg6M3qaC5IQFjyl4AdQrUWFijLhpANSDAFEBefL4kawszUsAaWuXLp5vOBmw25bNa8emsQxyYH+t0bFRUz90VB0T18D9GAG+urgkpWRaIg6PeBH1zTQ7ePbM943W9tXI9+ZmTEL+kDjzfVJO4u8TbXg4X8cGyRNqmEyyHhL7vGODEjg3KcGzkyBNHlPj1LG56IkUAUVAEVAEFAFFQBE4AoHuJ0x7kydpYtR4dqcaCJFG36YXatMRCzxJX1FdiqJHD615DICYmEJE9Xg/iJIfAQ8MdkCsM2x5vTxoP2Si3IP79yST3JaPP3xf+kEMcTffy8syfbWoELImKdIfQVNe9Fc6oo6J5IX1SWn04dpcWJUkosBdUKQCHvTRcqA/UpODJIzBDxuwBzqyfYKjQbVC89pOkqVX5k7iRGWJyXq06fnPjItvakRcUJ2onupQBBQBRUARUAQUAUXgOBHoGcJkQNpTmzI7OdxI0qKXQyBEwTS65Y3gSR+shWFD1NW1FSnbSzJ76YycvTorkZGwseSdBBcT18i6nZ9++kkWF+blb377qYwNDaD2B1e3h6+xWRea1zLxkCmHk6hDO6inFn/Hph9SGgmRO7tIrWMz5y3ZTmxBaS2JD7VPrF97Xf3TYX8XqMzuxBIy//Cp2LOIFveFTBLhYdt38nOuiQl6nolh8c+MGdLkGY4Yq56x6XVyMnouRUARUAQUAUVAEVAE9hDoLcK0N2neVJZQ25QGYUptIBBiG8XvLIQv7sUsn8TLi39oZ1x4vlyQjfiaLG0uyOS5cbl2/Q0ZGR3p+ejt2iWjZYy2tR9//FHu3LkjH3/8scxM4uYZTVErZfQGQppeLw6SnXg8bhRC/n7PnDkjftRo7R+miS96JxVSaOK7EQdhQi8yvCfZorq4i9ojqlIh1DM1kxxIslTG35PY4ro8/O6OeJxuk5THJMJuG1ScvCBOoatz4ofa5AygpxPiyjUYotuulM5HEVAEFAFFQBE4+Qj0JGHiZTGkCXUXRYRAZJM5ySRysOuhGB6F66ZpJ2ucel10YqAD/tXdhqhwO24W3SEnYsKdksztyE93f5TdTEouXLwg165dM2pFs6pDN/3MeV1py7t165Z8++23cvXqVdQxXZTB/jAIcRbqC+vXLE5y6wAAJILsrbQOlSmDAI+5uTkJoicTrxnXzPCG4m5W8ttJKWwx0AFrBVGqBTqwtmsnuWN6kvl9sGBCaaq7P5VRZktoXlsECctKYjUmi0+em15XI8MjMjQ83AEEGjuFqW9CDRtteb7pEfHPTogXceQOn7dq0zsJcmpjkOjWioAioAgoAoqAInBMCPQsYarhxRvKEogT65nyCIagXY+KE1+XWBzfw6TJhvAG9lTyIP3OG/aICzHhTqTfZQtZefjwody+c9sEP7z//vumoW0zqkMNx256JoG4d++e/PWvf0Wtz4i89dZbMoWQi0oJ/YWK6DVUQDpcj5EmrolJhxsI7UigLokKk4kJR/1OCSpSPr4DogSyBHWphF5KYEYvXRKqTKndlLCPksNul0gkInY7FJc6RoV9zVJZKeLvRgmBKcntHVlbWTVpecPAd2xsvI6jHM8mtOgxPY+9m1jbFIYNle/5uQ5FQBFQBBQBRUARUAQ6gUDPE6YXIIEYlRAMwQS9HIIh2OyWrwvo5UQy1SuNb6kaMBLc6XWI0wdFCal3HjxM+h0DHaA6MRqaTVCpwDAAYnZ2Vt57770TozLxmj59+tSsj0Tj3XfflQsXLlSVGJCmShGNjEGayiVY9HqEEXMdVM4YEc5+TBMTEwizQH0Ofrd5ECUSpiLIUpkk/4DB/akykTTxOLTl0Z5nB3k6dGCfEhTXagw5yRKa0pYqkslkzO+HSXnDUJcmJiabrok69NwWf2GD2uQejEjw/LQEoDa5Udtk9yCsQocioAgoAoqAIqAIKAJtRuDkECYChZtP3liWqTqhxokqExve5vAoZApShBLFxpxl3DRSmeqKwdokJBow3c7uBFFy22G7A0EKok8NFCUm37F2SfCouZC4RioNjx49kvv375sb6c8++8w0eT0yea0rFlzfJJaWlkwdE8nFr371K2M7NJZDrJ3qUnmPNLGuqcK6Jnze7YN1TCS6XBuT/yKegLjwe8xt7hhVyahmhyyD15wP1jJRqaKaGEANFJv6vmrFNNvyN45Gz4UU6vtgWWXtEskSBxvhMjxkBTHn/WgOPDk5ZYjXq8fpKjzx47dBVWJtU/DCGQkigpw9nBwaQd5Vl0knowgoAoqAIqAInEQEThZh2n+FcG/IG0eSJ6pLVJwYEpFBHLmx64FQkWGZW8hDblL3H87S1+A/HKBAuAlEHyUoSV7Egvv6PUZNYhNa1i2RIdVIUnWPn/+s1cTcvHnThCNcunTJkIrR0dGfN+rhV0zKu3v3riFNDH6ggra/ZockqQKFqZzP4vr2jkUvjpS8xfkFcYPjBcsgx0X0QQKRqpfwkSiTNGWyGYlAofpFYh5+y4zgL2WgsCJJsqoqkVD+/GOgQsVjzD9/LoFg0KhdJNr78f156y57hb8Qdhf+viAIInLtPGqbxsQJi96hf1G6bPo6HUVAEVAEFAFFQBHoPQROLmHady0McQJpKuXxwL/oF/HMsIg8VScWwmfwGf41vggS1S7lif1kqCJRMTKWOw8K2mG7c3jQOwmqkgMkyahMIFDmX/r3SNW+Zbz0skoGy/LkyRMhaWKD0w8++ECuXLkibIja1WrBSys5+A0VkMePH8uXX34pb7/9tty4ceMXlkOjLKHWp1yC1YwWPQZCGKVpHzs4+PDH8ynmth2Ly8qjZ1LeSYnfAZLs8jQ0F9YykSzxevu81YhxozKBfHPtJfymC1CUaMMr8/cM8rSfLPFkJNtUmR4/eiguEKXx8QlDvI609zU0y/ZvTKXJM4weZOenUNc0K65I0Kiw7T+znkERUAQUAUVAEVAEThsCp4IwvXpRa0ERNZLEOg+SJWPZw3MJ5Ir2Jd5YGvseX+PG0yRa417c3JTX7slJbIwYBDUIJUZUhpjw1YdnvqbdrppyB0IEUmSI0d4ziZMDNjxu2+zgjTMDIL766iu5iDQ5BiSMjY0dXdvS7Mk6uB+VFDaw/Y//+A85f/68MNiCzXoPuqmnla0aCMEaHVrPasSpgxN+zalMZDga0e6sRSX6bBFK57YEkHYXDOBGv4HB3x4Vou2dbfObZC8npuZVaDUF+S/u5o2qVMZv+rDBY7AO7uHDB4ZYj46OmfCQXgsNYcw4wyCCF2YkcG4KNU5hY9s7bN36uSKgCCgCioAioAgoAs0gcCoJ00FA8SbSECmqTyyUR70T1Sgm7fF1mQ/0eaLFj/YpQ55wIGOZg3oEjmSIT60WyQ6lyLZXl+SAglSz2Vmt/JDURaNR+f3vf29ugs+dO2cUGd5I94TF6qCLgc+4LkZw/8u//ItJyqPKNDMzc0T/IV4TXifY82jRI3GibQ/X6tgHa+qg6OQ2t2UXkd470U3Z2dkxNUjhULjh6VFlykJl2kHaXR+WF3D7xZZH6AnIUhlK6auK0kEn4DEeP36E30xJhgYHZRAPB5TJXhtMy6O6FL4yJ6Ers+IZiqg9r9cuos5XEVAEFAFFQBHocgSUMO27QObm2vChPUJEYrT33tyE8n1t+xcv8MGeQFSz0pFEVV9Xa5Box6upULXdrXxmPQoDIBjFTTse632YwtbrARBs9Prv//7vZk2XL18WPmg/O3xUSROkF/zPND089tQmc+WOgTyRhJezVbJEwpRPov5oNw1LXQIWQ5+E0IvpINXssDUaYs8aJfRtWltakWRsW5wVh/QHwuK0IWZ8/+/ysIPgcxLS58+fmcQ8krZRqJL87fTcwF+2PiQFugdDRmUauH5RHMG9Jrc9txidsCKgCCgCioAioAh0IwJKmLrxqjQ4J6oFJE205S0j+Wx2dlauX79uLGxWK1oNTq2lzanCfP7555JKpUzfIhLBukigIbqo3TFWPQRDlKvkqYz3hgG3NKsGdsY8SjmkNMa28NiGXa4aG8548Hh8EwTFZQhTXTVne2SddUmsU6L1bmNpVTbW1k3y4wTqkGjvq1dVJGFiWl8SGPv8fiTlTb6GjDaw7mPYlEqTeyAMe960hN84a+x5tMbqUAQUAUVAEVAEFAFFoFUElDC1imCX7E/lgQrT7du3Tcw4ycXc3Jx4PI2FCnTJcsw0SJS+//57U8vEfkGffvqpCX5oaI606SF6HH5K8CfWNzHYo2rXazd5KqFmKZ/YkexG3PRYMgEMmDxrkEiYbDa7CVugffIwYmsUJdTU0WpXQjQ4n02tEuqVdreTso7YdQZkMB1xcGioPkKJORjLI/bdRGofgx/YSLcuMtoQ+J3dmDVNjqBf+q9fkODFmao9r7NT0LMpAoqAIqAIKAKKwAlEQAnTCbqotLCRNDEEYmpqSt58803TmLQRy1c3wcEGq7Qa3rp1yxCl3/3udxJEDPZh5OLQuRt1Bl61PfJkbHogTnxfqVB14jP3rtPPduiJ9r7AwdiANh/flux6Ar2Q0rAH/hzCQEWQDYdJWkxoAxSeF8oQ54ppkFxVTN0c7IV7qlIpS6WMhA/nYV0UGxiD8Gyg1oukh2EfxOfFsY6YJ4kYe0KxTox9vmZn58xcGsb2iHN0/Ks+WmD7xDsxDJUJNU1Iz3P4PLDsqdLU8WuhJ1QEFAFFQBFQBE4QAkqYTtDF5I34wsKC/PDDD8bG9s4778iFCxd6VmWidY2Na2k15Nr+5m/+xoQTtFZrQ0JSJU9UmkwUOeucjOq0R5jM097rJn4fJDsFxIZn1jaNFW+Pjb04EokS7YZ5BEE40VMoFES62559jMEVFUbgp6u2O9rvXpAkznvf4DpoxWTPqmQyiXCMYeAzZGqRXkd8uK9pXruyAmyLIEyzULsCL+ax7zQ995L2vMDshETeuiD+M2OGNPXcInTCioAioAgoAoqAItA1CChh6ppL0fpEajfQ7F9EVSYSiRiVielytRvy1s/SuSOQWJAI/PGPfzSKzCeffGKUM6oyLQ8QhhdBEEZhAlEBKTMR5ax9wrlZA0U5x2xX5wlJloqZrGSWo1CYkqgvKvy85x7fKeG4aRAdk3KHyPr+UL/YeDooSbXeSYy1NxY+KElH9QYjkdxGtPzK6ioSBO0gTaPmutdzvdPpXVlaXDLBD9P4jYTD4YYCKH5eWJe9QsaK3esR/8yY9L93WfxQnGwgpjoUAUVAEVAEFAFFQBFoBgElTM2g1sX78AaaigNVJj5TYWIAhB+2r9epDt22LBJA9gv6wx/+YAIKGC3O9dB2Zv0gMQFrIUECSTHP5nX1M3xQJU4kMPivqhpVnzFNjOrrQjING94mHqhbSufMdob4kKAZ/lWNq0+jPmt9dR39vwoyMTYhLgfS//aRpEbWl8mkZQ2EaRuqFXtVsa9SPfVIbF67tLRo1K6JiUkZGBwQp+PkEAtnyC+hy3MSefO8uIe0R1MjvyndVhFQBBQBRUARUAR+RkAJ089YnJhX6XQaPXYem8AEkgta81jU36u1TF988YU8efLEhFiwLoukoFODpI21TvijauUzalTtM5Agw5b2yFIqI+mldUk9XZEiiFNVsSJRQmiDIUPYDq8ZCZ5GXdPi/ALUnTTscHOmJ1OzjWNJKhlTvozUOxKl0bFx6e/vfy1E3I/7xBNxo0wxWOPo2PbXHrKrNmCcvwvJef3vXDLNbV3hAJpKQ37SoQgoAoqAIqAIKAKKQAMIKGFqAKxe2ZQqE0MFvvvuO6MyMUHto48+Ep/P15Okieu4f/++sZrduHHDNLLt6LWoSkjUkDCqf9aeqh+BBOUKsju/Klu3nkh6ZUMqSLSrKlG1XX7ej1ZDNoxdmJ+HLW9LJianDMFplqyQtGXQyHYFkfKZdEaCoSCsi9PmWh+lKvJ3sgplKo7giEik2ovJ7e7dVEVzLV75w+5xiXtkQPrfvijBc1Naz/QKPvpWEVAEFAFFQBFQBF6PgBKm12PUk1tks1mZxw05Y8YZz03CxF47tOb12qjFpZNo/PrXvzbr6KY1MJQhs5GQ7TtPZOf+c6Et79Wgh1fnS5KzuLhgyAqDGoag7rRSm0W1iCQ5ChtmBSrYzJlZc7yjVCsSpmg0irS8qPhQFzYOW14rc3h1jV3xHoqSncEal2clcu28+GZGe86a2hU46iQUAUVAEVAEFIFTjIASphN68UkuaM378ccfjTpDuxV7M01MTPTcDSOJ308//WR6Bn322WfdZS8E8SnCird1+4lsgTCxQS2tePWM1dUViYGw+Hx+GRsfb4nM8nrXUgUZAhHpjxib3VEEiPuwHxRJkx09oaamp8xc6pl7T23TR2teSMJX5mToV2+Ize2ENU+jxnvqGupkFQFFQBFQBBSBY0RACdMxgt/uU/OGmGSDiXmLi4vywQcfyOXLSA3rsQAI3tBzDU+fPjVrYPADa3WOspu1G9va8csIbUjNr0nihwey+3zF9F96nbpU2zcKZScGRUikTybRNysUCtW+auqZqtXmZgwqU1SysOhRZWJS4mG1a/x97KDp7TrmwGjxmZkzppaqqZN3+U59drv4pkZk8MYV8U1r1HiXXy6dniKgCCgCioAi0FUIKGHqqsth/WTYp+fZs2fy3//93wgXmJW33nqruxSaOpbMNdy5c0du3rxpYtKvXr1qyMVxEyam6bHfUuwvtyX5eFEK26k6VvPzJlSCmGSYRvADyUo9QQ0/733wKx5rMxpDP655mZ6ekeGRkUNtdiRYtGtubKwbNZLbk7TVE0l+8Nm7+1OH3yveyREZ+fV18YwOqMrU3ZdLZ6cIKAKKgCKgCHQNAkqYuuZStGciVBFisZj89a9/NZa2ubk5Y81jAESv3BizPoehD1wDSR+T8oaGho59/sXdDIIe1iT2558kG0uYNLxGriItk9HoBmxxcVOXxVqmw9Sgeo9rVKOdbZMq6PF4YcsbluHhkQN3J2FirdsG5rCztW1sgVSkWmsMfOCpuuJD2vDsPrcM//ptCZ6fFqbm6VAEFAFFQBFQBBQBReB1CChheh1CJ+B73hQvIT7622+/NTY29mVizPhR9S3dtGySANrxSJjYXJXzZ4DFsRI+kI3dxTWJf/8AMeLLUsqg51KDgzVHJLPsoTSCJMNarHeryhkT8zbWN0zUOBWj8XH0eXK5DsSrgMa6DH2g7ZEkdGBgUDyek5WUt/+y9NltEkBa3gCjxs9OiWjM+H549LUioAgoAoqAIqAIHICAEqYDQDlpH5Fw8Ob8z3/+M6xaC2hsOirvvvuuuUE/VtJRJ9DVRLlFE5POZDcSprNnz7asxtR5+gM3K6azSMV7KtE//yglNKg1TW8P3PLwD3ldqC6xviwCIkjSROWvVcJEjDKZjLHlEbsR2PIi6Mt0UFNazmETseKMFw+HQ0aN4hxO7OjrE1rzBt67LP3XL+K1R615J/Zi68IUAUVAEVAEFAFrEFDCZA2OXX0U3jTzweavjBlPJpPy9ttvy/nziFnugZtjzp21Pkz8oxJCwnTp0qVjs46RHO0ursvWT4+RjvcYPW33eiw1+CvgurYRurCEeHH2PyKxCYE4tUqYatd7aWnRHJ+K0SQjww8gY9yWceRM7PNwDiBtgQAavIJYnNRhczrEf3bSECY/YsbtbtdJXaquSxFQBBQBRUARUAQsQEAJkwUg9sohSJTu3r0r7GtE+xVVJqpNrdbNtHv9vKnfQkAC507Sd+XKFbl27ZqxjnX8xh5zKSEZj1Y8kqUc+i+1MnhN2HCWvZMY0NDfP3Cgda6Zc2xtJWRtbV1ysOjVmuO+2pfJkDZgS1sgsRwlaQuRtO0/I96Y93yuvu447vun0+pr2PBckaCJGe+HNc8VQm+ylxfc6hl0f0VAEVAEFAFFQBE4QQgoYTpBF/N1S6FVa2VlxahMrJ0h8WBEN+tcuvkGmDf1tJiRLP3www9IlJsxaX8MKOi0pbCMJrX5raRE//SjJB8tSDlXeB3sR37P4Ie1tVVJ76ZBmKoBDVatiTbM9fV1U6NEEsQeXPvr1pjyV0GgRgqBD7H1NSlmc9KP7fw+KEzA3AwQiT4QjD6HQ/qcTrG58IxGsFRpqhzK/HnkGrvxS6MyzU3I0AfXxDuOABGsR4cioAgoAoqAIqAIKAIHIaCE6SBUTuhnNeLBAAX2NWIvIybOHXc9UD1wMymPtT5fffXVi+CHcTR77bQ6xmS85LMViX97TzIrUam359Jha8zlciYpLxFPSP/AgFH8rEqpY30SLX+0MxaLBRx7TMKBoNhAlMq5vLCHVBmkKpfOSBpKVwmfeZwu1DrRolYlTEZ46bOBMNnFZkgTCZMDBMMJKxuIE35DNhAo9jmqMqjDVtpln2NhnuF+6X/7olGaHAFvl01Qp6MIKAKKgCKgCCgC3YKAEqZuuRIdnAfVJSo1jx8/NioTrXnBYLCrVSbCQ7Xkiy++MPOsEb1XLWbthjEbTRiytPNoUYrJ3ZZPx5S6BKxz66trpnZoDCSQNUdWKH4kyDx+HKEOUaTmBf0B6cfDVRYpon9UEUSpUihiDSBH9ZZh7VnX+hw2caAmygE7myPoF5sHxImECil0mHzLuLT9AJijw+tGvPiUDH34priHIr0x77YDoydQBBQBRUARUAQUgVcRUML0KiKn4D1VDao1X375pVGZWA/EZrCdVmsahZppbn/5y19kZ2dHLl++bOqYrFJj6pkLycXuwpqs/88Pkl2Po+9SqZ7djtyGKlAK6g6vhxNKDVUgklerbHkmoGJ7R6Lzi1KB7c9nd4nbDvsZ7Xg4d9MKGUuZoDzJnvJk93nEgbogVwhzh/LUC6SJVkPvOGyQaGTrnxkzStmRF0u/VAQUAUVAEVAEFIFTiYASplN42XmTzhAFps6xP1M/Iqc//fRT8fuhFkAl6NZBexmVMZKLc+fOmQa8tBV2ZECtye/sys6957L5zV0pQKGxarCOaWFh3hCY4ZFRcz1aJq+YbwX1ViVYCLOJLdndTEgZNUow04kdDVwtHSAeVJeoMjkCPnGiIawdzzba9Kw+l6UTFxP+EHnrgoSvzol7INQTRM9iCPRwioAioAgoAoqAIvAaBJQwvQagk/o1AwHW1tbk+++/N72A3n//fZmbmzPqRreuOZVKmaQ8puVNTU3JJ5988lKIQVvnDUUmjZql+Pf3EPawKKVs3rLTsbHw8vKSZDNZNI4dMPHi9haIK5WjCuqTaBksIKCCz6xVYshDWwdsbqxnokXPGQ6KPegzkd2mvqmtJ27+4HaQPO/kCMIf3hD/mTHtydQ8lLqnIqAIKAKKgCJwYhFQwnRiL+3RC2N9C0kTVab79++Ly+WSDz/80BCRblWZSCwYWPHNN98YYkFVjAl/VtnXDkUMPKMMO17y8aLE/noLdryEJXa82vlq5HV7e0vCTLObnGxa6auUylLK5KQIG14+sYPXqFMqtmC9q02y3meQJtYx2aH8OfpD4sKDdr1uJU2cqxMEb+iT6xK+PCt2j/ZkqvdS63aKgCKgCCgCisBpQUAJ02m50gesk6RpGT2AqNjw8cEHH5jaIFr0unEwwGAV/YL+9Kc/maa1nC+jslu2r71msVRmCrDjbd19Konv7kkhmW6+9ueAc3FdmwjiYFNen98n09MzhsAesOnRH0FZKqazhijlo6ixwnGrdUpH79aWb2HFY0NYJwiTcyCMgAivSdpry7laPKgN8xx477JE3jwnnqHu/O23uETdXRFQBBQBRUARUARaQEAJUwvgnYRdGQBB1eaPf/yjDA4Omv5GFy9ebL9q0wR4rL1KJBLy+eefC9Wm69evC+fa7uAH1gLRjpf46ZEkH8xbascjDOyPxZqy1dUVRHo7ZRp9ptgvqZGkPBKjMpSlHGqVCpvbUJayTSBs8S5Qm16QpsGIqW/q68KaJkamB89PSz9qmYIXpi0GQQ+nCCgCioAioAgoAr2OgBKmXr+CFsyf6XO05jFMYRJ2sHfeecf0OupGa14SiXJUmBiNfv78eTPXdgc/sF/RDohS4uYjyaxGjT3PAthfHIJEcHd3V5aXFoWvxycmjdWwXuWMClgJgQ55kqU4yBJUpqbT717MypoXpuktFBxXf0RciO52wJ7XbUEQJHGekQGJvH1BBt+7Ys3C9SiKgCKgCCgCioAicGIQUMJ0Yi5l8wthDU08HjfKDRvEvvHGG3LhwgWTmtf8UduzJxPlGFRBcjc0NCS//vWv2x78wJqg+A8PJH7zoelfxDohKwetkbl8TpawpgxqjkZGRqD2DdVdx0RClwdRyq3Huoos7cfIDkueG41iXbC8MRiim2LHqeSxzqr/+kUZ+c27CH7ogT5S+8HV14qAIqAIKAKKgCLQVgSUMLUV3t44eK3B6ddffy2PHj0y6tLHH39sbtzbHqjQIES04t27d8/Mk1a8v/3bv207sSum0hL980+S+OGhlNl7CQTH6sE6JtaTJZM7EglHZHRsrK46JlrxmIKXXd6okjm878ZBFcfu94p3esyELKDwrKumSZIUvnZexv7vX4kdAShKmrrq8uhkFAFFQBFQBBSBY0VACdOxwt89JydpYk+mmzdvmvCBWjNb9mZqpJam3SuiGjY/Py+3bt0Sqk3/+I//2NakPBKSXDQhsb/clq07T9tClogZlb2NjQ1To0WL4fT0tGkqfBSevGbss5SP7dUtAZt2kLmj5lD3d0zPQ1S6CwEQVJoYPd5NKhPXEbx4RkY+e8f0Y7I5u7cfWd2Y64aKgCKgCCgCioAiYAkCSpgsgfFkHIQEhOoNE/MCgYDcuHFDRkdH2x6q0Ah6JBZMk6Mtj32k/v7v/95Y8xiL3o5BRWn3+Qqa1d6T1JOldpzCHJPBD4lEXGLRmJRBhObOzonX4z3yfLTiFeJbkl3bNE1pTSLekXsc85cgTTZcJ8/ooLiGB/AapASfdcvwz4zJwK+uSmBmXOzeDjVE7pbF6zwUAUVAEVAEFAFF4FAElDAdCs3p+4I37VQ5SJhoD2MdE1Po2Ey1W1QmhiKwge13331nbHmsYZpBqhwJXjsG+y9t3X4qWz8+lDRsb+0aXBcDLTbW100d09lz54zV8CjcC9tJyW3EEfawhUZRFljxyF36bKZ5a+28VLGoWhkyxtcWDFd/WFwgTc5I0JzLgkNacgjP6ABseeckgocz4LPkmHoQRUARUAQUAUVAEeh9BJQw9f41tGwFtVqm58+fG2se62refvttQ5zapeA0OnnOkSoTFSYm+9E6eOnSJROJ3uix6tm+nMtL7Ou7so0eTLkYiEmbBgkT67PWoZptoYHtmTOzxmp4YFIhOQz+y65uSH4jUY0Qb4HMVKDylFHDUwJhKtv7pIJ6Iz6YfdCHczkqCEVAEl8fSRki1mskqlkobB63uBAz7pkYkW6yvpHABc9NydBHb4or3B4C3ixmup8ioAgoAoqAIqAIHB8CSpiOD/uuPTN7Hd25c8cQEqpMJE1MbuuWwRt21jCRNNEyyH5MbGDbjsG47rU/fCfJR4smXKEd5+AxuSYqfCRM61CZxsbHjbLn8SCG+5XBGPEyiEtmftlY8lpK7QMxKsEal3bZBJVQspXPym4hJwWQUif6E/ndHhnxh2XUFxR3EXPc3kW/p6xUMNemB5iYMxwSLyxwdq+na1Qm2vC8IHHjCH5wD4abXp7uqAgoAoqAIqAIKAInCwElTCfrelqyGgYrMADiq6++MsejLe+9994ztryaVcuSE7VwkIcPH8oPP/xg+hZ9+OGHMjc318LRDt+1iJ5Gq//+Z0k9W5ES1KZ2DpImWiJXV1ZMUuEwSOpBVkPaBIs7SMZbQTJeMtX0lPoQ783whbTbLgvpbdnIpaBbQVFCgp3NZgeJK0muWIDSZJOxQERmQoMSqNikjHMXYQfkPGjXa2YwMc8zNiTO/pCpa2rmGFbvwwa2bsSeT/3Tp+JBMIUORUARUAQUAUVAEVAEiIASJv0dHIjA9va2UZlITILBoPz2t781FjFGeXfDWFhYMArYCsjFb37zG7l8+XJbpsVI8aX//T+yu7DemqpS5+w2N2MgTKsI2nDI2Ni4hCORX+xJ1Su7EpVCYltoGWx4MLEOpIgWNCcIQtJekaeb65LMpiUIRSvsDYgH4Qy5Yl6iO1uyuhUHgbLJ5fFpmekfFne+bKyAhZ2kVBA8YSx6DU6CgQ/OCBLzxofFAfLUFQO4uCIhmf7/fmOCKTRavCuuik5CEVAEFAFFQBE4dgSUMB37JejOCbBOaGdnR/70pz8Zi9iVK1dMQ9twONwVARC0rdE2SFve7373O3nrrbfMTb2laML6lgcpWPxfn0tmOWrpoQ872Dbql9bX1iWby8rk5NSBtVnF3bTsIrGvjCa3zdjx+kDG7D6feKdGxIFwg1y5JOlcTtwgwy5Ef1NR4iAR2oVF7/H6sjzdWJV+f0DenD5rLHplkLYMFS4qTSBNDQ+QExIl35lJcXRRvZAz5JfJf/xUfMCmm+qrGsZXd1AEFAFFQBFQBBQByxBQwmQZlCfrQLxZJmkiKWHUOAMJPv30U5NI1w0BEFTAqH798Y9/lE8++cTUWXm9XkvJXDlflBwS6Fb+z58kg+juTgwmAEZhy4vHN2USvZjGRsdePi2uSwGWuN3H81Wi0qglDkoRSYF7DMpO0Cc2EKQyjHglBDrY8V2NLNVOWigV5Vl0Te6uzIsD379z5oJMRAYFOxg7YHY9bkhTMyl6DH/wIcLbidS8PnuVpNXOe1zPTmAy9rcfSuCMRosf1zXQ8yoCioAioAgoAt2GgBKmbrsiXTafWCxmSNO3335r6piuXr3aFQEQOSgiTPP713/9VxP6wGCKwcFBS1WmUiYn6dWorP/+W8kivrsTg8R0E5gvLy/JBBSmcYQ/2GGfq40Kwh4KiR3ZfbYofN3osCFkwc2EukmEeIAAva4mjUTqeWxVbi89N9iSME32D8LLi2Q9pCjmoog1R2NfEwTRIHmzudGTaXzEJOZ1S08mql4jv30XaXnTQvKkQxFQBBQBRUARUAQUASVM+hs4EgGqTCQmX375pbjd7hcx3qxlet3N9pEHbvFLxnCzV9Q///M/y+zsrLHkTUOR2U8uWjyFsH4ptbAm0S9utjVSfP88GeW+tbUlz54+EYY+sI6JSXk1rFm/VNjclszSWlM1VVRz3GwcO/D6FDiqjBkk5tGS92RjRUKobbo2NScjoYggcdz0ZmL4RC66ibS+7YbtgTZaAEcGxI0mtqZRLGx6xz0cPo8MffyWhC6eEVd/8Lino+dXBBQBRUARUAQUgS5AQAlTF1yEbp4Cb5p5A0/72/3793EDP2bIydAQEs6OMQCC84pGo/Jv//ZvJpSCNVbsx3Rg36ImAS4gQjv5bFk2/3IL1rztJo/S2G61BraPHj6QEOrFaMlj6EYf1CCO4m7GKDq59VhThIkhC0ynY5z360YeCXmr23FDmJLZjJwdHpe5YczHs6e84BqUUL+UX9+ULOfD1LwGRh/sgK6BCAjcgKmlAitsYO/2bOoALoMfvCGhy7MaLd4eiPWoioAioAgoAopAzyGghKnnLlnnJ8z+QKwZ+sMf/iDJZFIYM87eR36/v/OT2XfGeDwun3/+uamvOnfunLz77ruWEqb8VkqSjxdl85s7ko/v7Dtze1+m02kQ1AfidrlleHhYBvZZDYtJKDobm5KPJRpWdGjB806PgaAMoXbpZ5vfQasxRDmdkjvLz2UxHpXhYESuz5yVAX8QtU4/78t+TDlY8hhxbhL7QKLqHdWkvhDqqQZRV4VGsV1AmEgkB9+/IqGrc+IZ+mVCYb1r0+0UAUVAEVAEFAFF4OQgoITp5FzLtq6EvZnYLPbu3bvGmnfjxg2Zmpo6VpWJKX7sxcSIcc6F4Q9WBlLkEklJPlyQ+Hf3JI+6oU4N1jE9f/7MNLLt7+9Hc140eN2rYyrupKDmgDDFt0zwQt1zAhkhQfGAMHlgyaspVgftz7olWvHurczLUjxmkvMuIVJ8agDqlMP10i4Me8jHtiS7uiEl9KxqpC8T5+MIB6v9mJiU1xWEyS0D716RMAnTiPZieuli6xtFQBFQBBQBReCUIqCE6ZRe+EaXTcWBTVW/++47WV1dfaEyGbvYMd3oUol59OiR/PTTTzIwMCC//e1vxYe47Fq9T6NrfHV7Q5gezEv8+/sdJUwkpysry0bNI77T0zMvCFMBhCmHxL58IgHCVL+aQzJCC5x3atQoTIf1GCrjOrMf01J8Qx6idskJNWl2aExmYcXzu36upaph9TNhioIwZZogTOj5hMQ+ZxcRpv53LknkjbMgTAO1ZeqzIqAIKAKKgCKgCJxiBJQwneKL3+jSeSP/4MEDozSxkelHH30kExMTx6YyMSmP/ZjYK4rK0meffSZUZKyqY8pDYdp5BIXp284qTAx+YDphNLphAh/m5s6+wNgQJkR55+MkTOX6LyEJExSdqiXvYIWpgnjxDK7xs9ia3Fp8asjShbEpOTcyIV7YA20HEOMqYUqYnkxlpAo2qjCRKDHivKsI07uXJXKVhEkVpvp/YLqlIqAIKAKKgCJwchFQwnRyr63lK2MgAQMgaMtjch4jr69du2Zixq1SdRqZNGurdnd35b/+67+E5OmDDz5As9dJQzIaOc5h25oapieoYfr6LghKZ0IfOBcmE7JWjCoTaI7Mzs1iTV4T612rYcqhhqkhwsQDs4YJChNDH6g27R+8tpkiyBJ6Li3E1iWFxrkXQZZmBocljHQ8EuSDIhlMDRMi100NE8gWOFfdow91VM4IaphQU8XeUN1hyfPIwPuXJXwFlrxhJUx1X0zdUBFQBBQBRUAROMEIKGE6wRfX6qXRlkeSwpqhH3/8URKwhb3//vsmnY6R450etfn853/+p2xubpr0vvPnz0sggHoYC0Yekdmpp8sSQ0pevkMpeZw2yQvVPNYx5XN5mZ6ZMUl5VM6Ykmd6H6GOiWSloQHGQzWHBIXx2bVBZSkNwrkAGx4jxIs47vTAiEnEC/v8aFj7c8hDbR/zzN9Dqyl56AnlhvXNEUDy3gEK1kvn68AbO3AZvHHVECb34Ouj1zswJT2FIqAIKAKKgCKgCBwzAkqYjvkC9NrpSVIYtkBrHuuZZmdn5c033zShC8e1Fqb3LS4uytzcnJlLJGJNulkBfZh2O9yHqYYhSdPTp08llUqZKHfWaNF2yD5MVLuyiy30YQJBcYGo1Ea2gJqprRhCHhZlC8l4Q4GQMOSB8eGOvbAJbkuFidY8p72qTtGOZ/owIbWPzXQbJXCmDxMixd1D3dWHadD0YZoRd3+oBpE+KwKKgCKgCCgCisApRkAJ0ym++M0unSoTgx++/vprc0PPSG8qTezLROtWpwfn8fjxYyFRoi1vEDHcVgySk/RqTNb/+xvJwnbW6TE/Pw8LZMLUZY2giS1teWXY9QpbSUk/W2q47xHn7WhchwAAQABJREFUb/O4DVnyTowKpCOzpPhuUu6uzBs7HkWeAX9IhoJhU7O032rpwLU9Mzgq/YgWZ61SGeoSI8UZcV5Csp+UG/DjcS5ul3gmR00TXZvLaeZy3H84/F4Z+e17Ejw3Kc7g8cbmHzcWen5FQBFQBBQBRUARqCKghEl/CU0hQOWDdUzffvutqRn69a9/bXoGHYc1786dO3L79m2zjt/85jdGkWlqUa/sRHKSQ2T2yv/5s2RAnDo9VldXjNXQ7faYcA3T9wpEpYBeTKlH81IBYWkkZMHMH4zIASLgBVGxB5EoCAVpfSchPyw8lpXEprHj2UGMDiK+HodTPjp/1aTmwTcoxdQuapdiUthO0kfYMDwkb74zICZQcg5L7Wv4oC3u4AQmY3/7ofjPjIvD23mbaYvT190VAUVAEVAEFAFFoA0IKGFqA6in4ZBUmRhM8NVXXxm1iWEL7M3ElLr9qkQnsHj27JmpqWJz3d8iWpw9mWp9i1o5fwWKSSGZksX/9blklqONk5NWTo59Y7GoRBHlThvk9JkzEgxA2cEooY5pFwoTY7wrxQbrmLC/zekQe8BbrWUKBiRXKUkCVjxa88pHqEQ2W59pYBtAL6Yiei7l1qNS3E4ZpclMrJE/QMo4B980Uha7JPCB0+dcJv+fT8U3NYLmvi8HYzSyPN1WEVAEFAFFQBFQBE4OAkqYTs617PhKSJpYy0R1hwEQjPWeRU2T1+vt6Fyi0eiLBrYff/yx0CJoldJVTGVk6X//j+yyZqgJctIKENtIJGTvK/abOgPCFIblkGS0DKtgFopXPrFtXjd8Dtju2LjWORARV3/YKE59IFGvVXlowwMGJdR2sY4qv7UNlavYFJGkBc+Bc3vHh8Tu6+zv5VC8gK2rH32v/t/fVJMEQRB1KAKKgCKgCCgCioAioIRJfwNNI0Dlg9a8W7duyTfffCOXL182oQuMG++kysQ53Lx5U2jNe+edd8w8rGqoSyVl5T++ktSzZZATxGZ3cJAosc9UIhE3qtnAwKDpMUWrIMMWGOVdRCPbpocdpCkUNDVNdtTu2FwgTbDomWsH8lCz+/E6M8K8DIJcAoEkWSrEt4zyVdum0TnY/T5DSmjH65b6JcacuxElPg2Fic86FAFFQBFQBBQBRUARIAJKmPR30BICtZjxH374wfREeuONNwxh8Xg8B9bBtHSyQ3Zmo9effvrJqExUl5jax+AHK0gbgx/W//i9JB8umNqhQ6bQlo+5Llry1tZWZWR0VIaGEAm+F99eAWlKz69WiUsLyhf7MdncTqPyOGCRs+O6VdWmaiAEk/CorJXQlLYEAlfazUoJEeRGbSORamaQqIVDsOONiQ11QlS7umHYvR5jxRv/v26ARGqkeDdcE52DIqAIKAKKgCLQDQgoYeqGq9Djc6DCwzqi77//3tQwkbCwpokx2J0YNWtg7fxUmaxSucq5gsS+uSvbd54iAALNYjs4GC0e24zJyvKyhMMR0yDY50NQA9Qfqj651ajpyVSCCtas0mOWg+PZoK70wSZnY4w4CE2NbPI8rOUiQasU8AB5IolqZZAkuQb7YccbNuSslWNZua8zEkQ63rQMf3QNhM6aXl5Wzk+PpQgoAoqAIqAIKALHg4ASpuPB/USdlTf2rGH6y1/+YlLdZlHH9NZbb0koBLtVB9QDnp+JfbTl8QafEefT09OWnLsMkrB195ls3Xwo6aX1jl43riWBWHESJipLo1CZgkEkytEuh1GAHS+PuPPcJogcLHO9MDh350AYzWphLwQp6RZ1idh5Rgcl/OZ5ibxxVpxQ23QoAoqAIqAIKAKKgCJABJQw6e/AEgRysGk9evTI1DMxoe7tt98WEqdOqEwkTOwLxVqqeDxuCNPZs2dNvU+ri2Pdzi6sb/Fv7kny8WKrh2tofxKmneSOrK2uIb2uBMI09lIKIckc64lyazEpZ7ItKz8NTa6JjRkqwd5L7tFhcQ1FTFof2F8TR2rPLowSH7zxBiLFx2BN7Iw62p6V6FEVAUVAEVAEFAFFwEoElDBZieYpPhZv7hnrzb5MVHtmZmZME1mqTDVFpF3w8NwkSnfv3pWnT58asnbp0iWjyrR6btrP2Isp9tUt2br9pF1LOPC4XBeDHzYQ/EDb49j4GOqYhoDnXs0Pvi+BKOUxP9oFmZ7XzYO1UbTiuYcHxBHw4Z9rumu2wYszMvqbd5GUB2UUc9WhCCgCioAioAgoAooAEVDCpL8DyxDI5/OysLBgAhiy2axJrGMcNutu2jlqxIIK148//ijnz5+Xq1evSmQvhrvVcxeSaRCmnyRx8xFitZuL0W52DsRxE3VMm5ubhiwND48Y5axGBCuw4hV3d009U2ErJRUoYt04mL7HvkveyTHEmFcb5nbTPGkNpB1v/Hc3TGpfN1kFuwknnYsioAgoAoqAInAaEVDCdBqvepvWTGsclRAqPY8fPzaE5b333jO1N+2uZSqCyFDZYh3V8PCwScobG0MKmwU1VCXEicd/uC+JHx6auiGSlE4NrmsL/ZhWV1YkiAjwkZFR0+eqRpg4jzLS9AqbsOZFN0GeEACB69BVA7Y7B2LLnUNQl4YGTHx5N86v//oFGfnsna6qq+oqnHQyioAioAgoAorAKUVACdMpvfDtWjZJ09LSklF6VnCT/6tf/UouXrwofr+/Xad8cVye78svvxSn02kI09zcnLCeqtVRzhdkB7HiiR8fSmY5CoIClalDg+pZMpmURSh3TqQOVoMfgi8TQWxDO14umjA1TYxC7xrSBMLKuiU2yHWPDIgdCXndVLfEy0g1yTM2IP3XL8rAu5c7dGX1NIqAIqAIKAKKgCLQKwgoYeqVK9Uj89xvj/vuu++MjYy9mRjCYIXacxQMG+hZ9PXXXxuCwXPSludAn6FWB6O00ysx2br1SHbuz4shJK0etIH9d2G5W1pclHKlDPVsRAYGoNK8opxR9Srn8pLf3AJp2kLPpBajxhuY36GbYo52j1vYnNY1EEGvJ/R4QmR5tw02rA1emAFhuoBY8alum57ORxFQBBQBRUARUASOGQElTMd8AU7i6akyrSOogDHfTK8jWbpx44axkr16o2/l+hltzga6iyAXly9flnfffdeoTa2eg32Iiqm0bKEXUxw9mQrJ3VYP2dD+2UxGVlaWJY1nNuSlLe8Xyhl6yJKsMgSikIA9D3HjJdSUgWV1PlsBFjxaBvuoLA1GjLrUrWSJF8KG/lODN1Dzhhomtzasbei3qRsrAoqAIqAIKAKnAQElTKfhKh/DGpnutoz+QV999ZWJFq/FjHs8nrbNhta1O3fuyO3bt03ww0cffWSS8qw4IW14ycdLEvvLLcmuxzsarsDI9o31NdPrKtLfb5oC2+0HK2dM9SuCNOWgNCXXolKBPc+NbffXPFmBx1HH6IOqR4LkjITwCFaVpVcUsaP27+R3VLycoYAMf3JdQpfPiB0kT4cioAgoAoqAIqAIKAL7EVDCtB8NfW0ZAlSZaCX761//CnVkxfQP+uCDD4ydzAqb3EETzUCBefLkiQl+mJyclI8//tg0z7WCLFBlyqzGJP79fUminqmTtrwCQh2YlLe+tiaBYBBNeWeO7G+VB8Hajidka3lVnMWyhF0eqbDuqs1hFawFYr2SnQEPaErrQEgF1ZtutOHVfj+sqfJNj1b7L82MauBDDRh9VgQUAUVAEVAEFIEXCChhegGFvrAaASa80R5Ha94abvY/+eQTY88LBAJWn8ocj8SCqtbnn38uQRALBk5MTEz8ot6nqZPD7paHFY81TJtf35HCdqqpwzSzUwlR4VvbW7KMMA232y1TU9Mmqv0gIlgLiViYR61VsSD9/qAMegNSTCRNMEQFDXDh3cOjmZkcsg8a0tbIEsMdnHjY/ahXYlNaPrp4uPqDEnnrgoSvzIl7INT18+1iKHVqioAioAgoAorAiUVACdOJvbTHvzDevNNO9tNPP5naIia8sa5oenq6LRYxni8Wi8nvf/97U89DGyAT+n5R79MkNAx/2F1ck43Pf5DM+qbwfScGwx7SUOvmkZRHsjM+PmEUu4MIE1W9WDQqy6h5Gh8bl6HBIfG5PVJmbRMIX3EnZeqcjOLU6uRJhthficEOsLU5Q/6q/Y6qUpda8F5aMoieb3xYhhEl7p8aMWrYS9/rG0VAEVAEFAFFQBFQBICAEib9GbQdAcaM37p1y6hMV65cMYEMoVDIGuXnldmzZ9EXX3xhkvLYwJZ9oKwiTDxVLrYlm9/RljePnkydCX+oEc+FhXnJIwlvCH2m2Gtq/7q4DRW2WCwq8U3UWIFkTU5OSSgcFgdqmNjQlil6tBKaB1L0GEVezhfxHR+v9G7C8cp4UB96ifzQdodUORui222ws5Es1Z752tjvulxVMj8ZzNGBOqvghWkZ+uBaNeyhF+ZtJq9/KAKKgCKgCCgCikAnEVDC1Em0T+m5WFu0AHWEkd/sx3Tt2jU5c+aMZYEM+2Fl49xvv/3WpPNR0frss88siRavnYONYVPzq0jLuyNp9GQy9rbal218ziPxbgV2w9RuCnVZ4b3gh597TNH+uL29LRsb68Jtx0bHhAERtPC9NECCSJ5KmRya3GYMiaqgz1QZ+1dQ70SixXqtMkgUU/lYb+aBQkWS1Ac1qc+5R5ZQq+TwecUG0mFzHhxA8dJ5u+0NyJEHfaEG3rlkwh7YWFeHIqAIKAKKgCKgCCgCByGghOkgVPQzSxGg+lGL/GaN0dTUlFy/ft3YyqyOGWc637179+TRo0emzufv/u7vjgxIaHShtOHloSxFv7xpmtlStenEoHoURZ+pxFbCkKDZ2bkXRLAasJECSVwTRpAHEbbAOicHCc5B1jiSJjwYOc5UPZK+CggT1SYSpxICInLZLI63AoIbkIGhIXF7vUiQg9UOxEmQLFetT8IzbG3dXqd00PVhGEVgbkIGP7wm3rFBEMIeJH0HLUw/UwQUAUVAEVAEFAHLEVDCZDmkesCDEKDqwQCI77//XqiGsLEs64uogBxUi3PQMer5jDVTz58/N3VTPM8//dM/Wdv/CeSiBEUmcfORbN1+LNm1zXqm1fI2XMsW+kxFoxsmr+HChQsgTE5z3Fwua+qWYpubIIl+GR0dMSpUQ7jukScqTCWQQhLP+efPJBAIyujYmHh8PrGRgBmPHv/o3UGS5xoIS/jqHJrVXhRn0NeTpK93r4DOXBFQBBQBRUAR6C0ElDD11vXq2dlS0djZ2TFE5tmzZzIE1YLNbAcGBl6qxWl1gUaJQegBbXnxeFz+4R/+wShZTtTcWDWoyqQRMb5186Fs/fioqtZYdfBDjsOkPNoNGS2eBUE6f/6CsKcVP99G3dYG1CcG37G2iZi2Et3OY5IwPX36BIQpIGMIj/BCYbJaDTxkqW3/mCpZ8OKMIUsa9tB2uPUEioAioAgoAopAzyOghKnnL2HvLMDU4aAnE1Pz2GSWARBUmayMGefNfq3/0zyitT/99FNT72PlOWhhK2bzsnP3qcS+uiWFVPqXoQkWXxba7qiera2umlqlGdSAsR4sk0nDqhc13/WjZmlgcNAQqYbUpVfmynORMD158lgCsOSNjZ8gwgSJzBn2o3bpskTePG+CH7q5T9Qrl0bfKgKKgCKgCCgCisAxIKCE6RhAP62npMqURW3MnTt3TJ0RFRI2l2U4QyuKyH48eQ6SJjbM5XnefPNNuXTpklFd9m9HOQaVOy99ZN4e4DZDlyFYtl7elNuml9Yl/sMDST1ZliJiu0mk2jW4LhIZNgGOwZY3ilAHD1SfZHIHTW03TYPecRAbWvJaIUucP8/DoI7Hjx8ZUkaFyUdL3kH1UO1acJuOy+CKwPkpE/YQPDupVrw24ayHVQQUAUVAEVAEThICSphO0tXsgbWQzNA+dvv2bSgYT+Sdd94xhCYSiVg2e5IL1krxHLSovffue6jDGa1a52pEic+o2yHx4fYvcZ0X/IgNWXFPzcasLN4x/7/4UoqI5k4vb5i+TLloohqgYNkqfnkgznN9fR2PNVNbVEKSHYmN3WaXSQRpMKp9f9T4L49Q3yc8TzabkYcPHooPKtYYapioZvU8YcI1dCAKffRvbkjw3JQ4ApqMV98vQrdSBBQBRUARUARONwJKmE739e/46nkzTmvZ48ePTTNbl8slb731ljUNZvfIEMnPw/sP5P79++A4NnkHDWypYhlixHADboD/DVkyL2qv94QkcKLqMNpSlSjVCNMeeaqmz8GaBzveFlSm5ONFKWwl9/bbO37tMBY+szHvCprS5oEh1+Hx+mQQNjw+fhEh3uR5eVwqgQ8fPhAfjj86Pmaseb1OmBxorOs/g2a+N95ApHh/tWdUkxjpboqAIqAIKAKKgCJwehBQwnR6rnVXrTSKYAZa5khqzp07ZxrMhtFktVGF5AUJ2iNCZT6XKrIK69r883nU++yYRL6RoeEqYTJEiX80MUCaDG/icy1aG/a17FrMNLLNrESFPY3Y54jx4/C2Ub5q4kSH78Igi6XFBdNnKghFaXx8wihAJEtWERpiSlL78MF9cXu85visAWv02hy+is5/w15R3ulRGbxxVfyTI2KH0qRDEVAEFAFFQBFQBBSBehBQwlQPSrqN5Qjwhpz2si+++MLc6LPO6PLlyyaN7XU1OC9IEm7sy6UyegfhAZJkXoOkVPBZcidpjr+KVDkGSwwjle91x617kTVrHnZgHVQ5VzDx4iRMhe2kVBAIUUaMegW9k1BQVQ2EsIg8UWF6jrjv+flnMjd3TmZn54R2RqvIUg0DXp8H9++BMHlMSl5PEyYQXPdQRMJvzMnQ+1elDz2YLPst1ADTZ0VAEVAEFAFFQBE4sQgoYTqxl7a7F0bSwzS7mzdvmr5JjK1mAATjxg+KAOf2dM/xuUaSSoUSegaBIBkyUiUv3IyqDi1l7EvECPOzc3MyMjJy4HGtQIm1UKxnym7EJYdHKZMz6lK1GSyIE5rb8oEGVC/m2qjyxHWz/msNBPDZs6eoA1uHcnZNziAtzwMVyGoCkM/njPrndqHmBzVMwWCwJxUm4mJzuwxZYiqeD+qSDkVAEVAEFAFFQBFQBBpBQAlTI2jptpYiQAJAxYQ9k5aXl+X69esHBkDUSBLJEUlSGXY32u6M/Y5k6YDBY2/CvvbgwQOZQiDCKAgTSZnVxKJ2aqpa+Z0UlKa45BNQmXB+WvJI5kicKgU8qDqx9ggKlPnesLvaEY5+5nrYx2ptbdWEZmTSu3IOvZgmJ6fasi5GwD+AJc/ldMkI6r+sCpQ4epXWf0uy5J0Ylv53LkpwblLsHpf1J9EjKgKKgCKgCCgCisCJRkAJ04m+vN29OBKhIsgE0+xYz8SY8bcR0EDVhDHj/L5ShLICgkSyRKJUAjGpptsdXRvEfbe2t41KwkAEEibe9LeLMFExKoEU5eM7kgFpKu1mqmoSLwHXYdZSJU3COifzgHWPtj0oVNzmsGH6IqHf0sb6hqTQv4rpeFTnRkZGjfrTjnWRMD0E2eR1YGBGqIn6ssPW06nP2aDWM9wvYShLIUSJO8NBk3jYqfPreRQBRUARUAQUAUXgZCCghOlkXMeeXgVrme7evWtixi9fumwa2oaCIRAJkQKIRanAGqXGAxTYHPcR0vi8IGKMFydxahthwhUg5SmhH1N2IyH52BZ6M8GG9yoR4nv+XwBZSmekjO1JnsAIq7VOB1xJkhf2WqINj6mCfjSTjcWiJsFuaHgI67KwPmvv/IYwPXwIwmSXkeERCaNOqqdCH5Bm6Az6JXRp1qhL7sFwW6/9AZdNP1IEFAFFQBFQBBSBE4KAEqYTciF7eRkFqCyLi4vy1VdficPmkKuXr8rM1Iz0VZCuYPhFlWQ0ukaqMAsLC1KCLY5kaQxKSTsJE+dHC14JlrsM+jPl4kmEP4AMHTSoOJE8QWEro96qnNyFVQ92Pey/n2TRisfmtGxYW4SCNQTiFwj4zXt+198/gKS8ccvXRcL06NEjcaDRK8lmTxEm1C3RescI8cEP3hDv2KDYoJTpUAQUAUVAEVAEFAFFoBkElDA1g5ruYykCtJxtJ7ZhAXsk8eimDA4MyuTEpPh9/paIAJu6MiRhB0pTf3+/TE1OWp4m9wsgyO2wngIIUHY9IbnNrUOVI7MviROID0MhyiRMmHMZdU7V+qeKpFJJU7O0u5sWxq4z7c+GSPP1tXVT0xQKh2R6esbydZEwPX78SGzo3EvCFAF+vaIw2dxOCcxOSOTNc+KbGhWHz4NeWi+aa/3ikukHioAioAgoAoqAIqAIHIWAEqaj0NHv2o4A65FYo5RDstxmLC7Li8tShCrDtDwm27GGptnBm/54PIF48TUJIOVtZmbGKCbtVpmoEJE0UWHKrscNeTJ9mY5aCPeBgmTUJpImWvuSKYlFN0wwht/vNzVLTKujssR+TFyXz+dDzdeswcnKdRG7J08eo/Fvn7kW/QMDPUOYfGfGJHLtnIQunjFKU7XJ8FHg63eKgCKgCCgCioAioAgcjoASpsOx0W/aiIAJQUDSHW/+C7milPBgFHh0I2oIAgMgJiYmUK/jb1o9YaAElZn5hXlxo/ZnenraBEtY3bPoQJhAgEogfoXtXYRAbEoxhRAIrPXIsadOsb6pCLK0ubwiMVjx8sCFwQuRSL+JRidmVbvhPAigQ6ZBBJkAaOW6SJiePn1i7IEkr7T+2Vsgr0eu26Iv2ZzWGQ5I/7uXJXhuStz9QVWWLMJWD6MIKAKKgCKgCJxmBJQwnearf0xrN6oSbvpL+SpZYuPZSqUa7LCbTsva6qrQTkcbHSOtXc7mGo3S6sf6qMdPcOOPMQkCxgasrahWDUFG0oSmtowZz0YTIE3po+15ewcvA5sc1k/ClELsugtEaiAUFo/bbSyKXBfJIBUgkqfJySnTJ8nKdRnC9OypSfBj/RcVJiuP3xCOdWxMsuRmIt7VOQmenRIXyBJT8nQoAoqAIqAIKAKKgCLQKgJKmFpFUPdvCAFDltBLqQAiQcLEmPD9IQckAkyEY38mhjUwYpwkx26zNXSe2sYkF0zKIwEYQS3OAG78D2qMW9ve6mcqaWWsNYe48VyNNDFG/JDB7YkBey5lQR7teO+HiuTIF8WGz2tYcTvWGGVBrIYRL851MUHPqlGgwvTsmVHFBkCY+OhmwsRgh9CVOQnDiseaJZuSJat+CnocRUARUAQUAUXg1COghOnU/wQ6BwCjwYu48S/Sgoe6pWpU+MvnJ8GhNW9jY8PU6VDdoCWM1rxmBonFs+fPjYWNoQnsx+SGUtPJYUgiQh2oNOU2t6W4g0Q8rPOgQbJEdY2R6FTWaLXzwApXASYVKFRlHAcs0+w6P/9ckiBW7MM0Mjpm7IYHHbOZzwqwBT4DYeJ1IlnidehGwmRzOY2yFLo4IwHY8Lwj/WrDa+aC6z6KgCKgCCgCioAicCgCSpgOhUa/sAoBkpYK6pUYi13Isq8SUuFeo7LEEwlZhTWvCEsdY7NJmlij00ywweLSkmxtbZl+TFNTU5YSi7oxAgYv2fPY2JbEZ5/YVCOLqd0UiEoRylrQhDowna6C96ZvU2ovfhzvV1aWJYHwBypLU1PT4kUAhFWDVsbnz58ZtWsA9UuDwL/bCBPJkgcEicoSa5aMDa9JJdIq3PQ4ioAioAgoAoqAInDyEFDCdPKuadetiCoFVaVCBmTpFZJw2GSpMm1uxmVpecnYzcbHxkEemgs2oFrFBwnXmdlZxJVbRywOm/9hn7MvU2EnLZnVqAmCYL2S6TUFQkXbIMMcsrmsiVRnAt5++yBJZiWLBL0kCBWIU2wd60LTXxKt2bk5Y1087LyNfk7CNA/CxOcICBOjxbuGMCEivFaz1H/9ogTPT4ozgGuq0eGNXmbdXhFQBBQBRUARUATqQEAJUx0g6SbNIQAOYCxdxSxteAVjwaPaVM9gbdNuutp4loSgHwlxY2PoqQN7WqMqU4JqFfox8eZ/DoSJ0dyNHqOeOdezDUlPGeoQU/Ny8W0pbCWN8sQodUOWQBSpKHGOVI5eneeLnk0gTFtY0+rCoqSBE6PFaTm0KimPWC3A8kcSx3S+4RYj3uvB5rXboJVSH/pCOYI+8U2PSujSGfGODooz5JM+YKZDEVAEFAFFQBFQBBSBdiCghKkdqOoxkU0AC1oBKXUgSlWyBKJUJ1mqwceb9hgDIKJRQwRop2MtU6NKB4nIMuK5U6mUzCBanOl7x9qEFTgQn0IyXU3QQ3Pb5GZCUjtJQ5AYcsFY9cPID+ufKiAyaTT5XX7yWOJoYktsBtDwt1Fsali/+kzsFxHHnkUT3UgkstcTy/nqZh19b3PaQZYCEjg/JSHWK03ApklSaQOT0qEIKAKKgCKgCCgCikCbEFDC1CZgT/NhDVlCVHgR9UqsWTLhDk0AQmWJCsfS8rIJQRgA0aHS4UMQQiODxyBhYrPX8bExUw9lZaJcI3PZvy1xyiPIYWt5TeKLq4ZA+dweQwpfS+hIuBjB/uSprD19JoNQgYYQzGBVoIUhTIsLJoAjHI6gDxSbCB8TYYLVzuF1i3soIr6ZMTSknTGvacvToQgoAoqAIqAIKAKKQLsRUMLUboRP2fFJAthXiUTJkCWQnv3BBo3CweNFETEehcrEeh8GQFDxaERJYd0ULXmsYxpE/DabwFLBOe5BQphGY90Nql+xhHiQGh5wuAWmw6oa9xr3IvFIoIZpY35eXMB8EJY8r6cxMnkYBiRMS0uLJrEvjB5Q7Ie1v57qsP0s/XyvVsnh94h3fFgCZyfFf2ZMHH7UsjE2XGuWLIVbD6YIKAKKgCKgCCgCByOghOlgXPTTZhBgzRJu4guoWTJkCWEPVgzawkiYoiA8JhocN++05r1a33PYuUhMNrD/OsgF95sA6WKgwnGPPOqWqHqtrq6Ix+WWISg5nopNiogfL8Kud1SSIOdOMpmG3TAOXErb2xJ2usWH41gxSJiWkS7IOjISplEoc50mTDbUq7EZbZCR4XPjSMELGaVJiZIVV1iPoQgoAoqAIqAIKAL1IqCEqV6kdLvXIkDrXU1ZKkHxaLRm6bATkPBso9/QGmPGQciY2EalqN4beO7P4Id1EAuSLNb7BFEndJyDc9oEWaLqRXIyAqshLYcOwFZE5Hh+exdpeilEiecMMTporiRMOZDJHZClAuqzgmITN9UpYNTqKBRJmJYNIWMAxRhIZr14t3ruPrtNnOGA+KZAjGHB802OINjBj2Q8VZVaxVb3VwQUAUVAEVAEFIHGEVDC1DhmuscBCJAA1KLD2ZzW6kFiQIJBlYnqEAkGG7bWozKRWLARLBUmHoeEiUpVPftavQ4ej1il0Zx2BVY8Np4dAPnjemrNeQ2Wu1kpJHakAOJUzIA0FYoHNrutRZHnkK7nR2y6m9tl0dwW52hlFPcIE3tCBYMhY4VsN2EiUXKgPs01GBQvSFIQFjz36IA4PNaoZq3gofsqAoqAIqAIKAKKwOlFQAnT6b321q2cqgiisnO7udc2pW32pCznSSPkYAk2MdrQ2EiV9UxO2LZeN0iYMiAotOVtQ42ZnJg4tqQ8zoUkZwVqGZvpkoScmZl50aB2/1oqUOwYP56NbYE4ofdSLl8lTfua/hJ34pLOpMUPsuGmDXIHzW1xjlYGj7uCsI0UiGYAyXTjE+h1hLlaPhgVDqJH+50j4BUvVKUwGtH6JofF5nYeG6m1fJ16QEVAEVAEFAFFQBHoWQSUMPXspeuOiZMAlAqoW0JTWipLzSbi1bMaWtficVrr1kGUnCa8IRJ5fe8hzpH71ixwTJMbAuGyKlGunrnXtqHCRdJGwkQCwnkYK95B/aUwb5KmEmqdSlCZCiBPxSQUJ9r0QIwqlbLBOwsySAXN5XaJz+kSG4hVeWsb1rzmbZEkTKtQwHZ2tk1D3IlJEiZXbRmtPcMWySjwPgQ32DFn10AIEeHDCHYYMnVK7Ktkd8NcqHHhreGseysCioAioAgoAoqAJQgoYbIExtN7ENYqFWABK6QRH96iDex1KNaUIpIN9lZiv6Jp2OvqiQjn3BJQdJahmnC/EdRBNRIc8bq51fM950CytAZrYDaTlaHhIVOP5T6gQe2rx2PD2hIIKYlTKZ0FacIDtU58n4HCxDomu90hftgVoctIGQSqjMhySH+vHqqu9yUqTMB5Z3tL/MBrAgpTPTjXc3Cby2lqlDwjA+IZjpiIcAY6OMN+seM7yEr1HEa3UQQUAUVAEVAEFAFFoCMIKGHqCMwn8yRMcWPIQz6TNypTJ1bJFD4GONBeR2vbmTNnJIDku3rsYgyOoKXPYbcbdaqTdUwke7TOcd5Mxoughoo9pUIIVGhowJtYBpkxhImKE0hTBg1v4xsxKUOJ8nt94oU6U8HrItS4CohZM/VMJoodhGl7KyE+4Ds5WR8xPXAtIEDsmeTweWC7A6GLoDEv0u+oKLmHwiYmnLY8HYqAIqAIKAKKgCKgCHQjAkqYuvGq9MCcSJZKsIXl03kT9kBC0InB85AoMV1uc3OzqhaBeDDJ7XUhDikkybGBLe15o9iHdrjX7WPFmmpzjqGfFMkSm9JOoI6Kc35tg9qDJkCrHvCvQLGi6pTZ3pGNRSTaJWCfc/skyMh1klkQptLWTpU0HXScIz4jYWIqIcmp3++TyanpuhUmhjf0YY02lwNEyQl7HRSlUMAoSVSVXCRJqFeyg0TRlqdk6YgLoV8pAoqAIqAIKAKKwLEjoITp2C9Bb06AdUtUlpiM1866pYPQIQHZggWNqXe0uM1MTxtrG8nHUQSICs8aGthyHzavHUNvIVsHlI2aKkYrHpvN8rz9iBCvRxU7aP37PyMWOahIGzh2DCQy4gvKcKRfKrguxa2k5NeiUozF9yXsgdjWwW0553VgRYLHVMIpYHyoJc846FCTtDcxu88NFSko7sGq3Y69lNxQlexIuyOJUpK0/wrqa0VAEVAEFAFFQBHodgSUMHX7FerC+ZVLFRAlWPGgLlFlOo6Rg8q0BfXj+fPnEolETCw3n48iTAxcMA1sQQRoh5tEkAHtee0crFva3QVRW18z6X61xrsej+fIuTYyJxNoAbWN9VlhRIBPjCE9EESwwhAOxI0LHhUEQZTSVQtfEZHlDJIoMxyCz4giFyhS+4chTJhzHMf1wuY3jSQ/Q5hor4MqxAQ7GwIbGNpAguTwe83DiWc7rHd2r9sQJNrw7F4EUaA2SZWk/Qjra0VAEVAEFAFFQBHoFQSUMPXKleqWeeK+uogb7DxT8UCaaA07jkFlhb2MFubnjUWPZGkMRMHFG/NDQgNMyh5I1sLCApLpBtCPCX1+UO9j1SA5IimjkkVyQVJE4hFl3RLOy3NR2Qqjf5SVyhbPQdVsHuvyIlp8CkSQwRYcTJqz42GrlECeci+CIvi6hOtniBNIUwWKIdUvQ5yALbFaWlxE8MOK+GEdvHLlinhhzetDmp+x2XlAmID1C8KE2iSHHzVKIEz8XhPurPpV6XEUAUVAEVAEFAFF4LgRUMJ03Fegx85P+50JeoC61Gkr3qtQ8aZ+B0EOrEsiSZpEklsoFBTHIb2ZSCy4/dNnzxAUweS3cVNH9Opxm33P2iqSIyo9rE9iQ1oONqi1Y04kS4OINLda1SJ5ZH3WM6zLBsVsHJY/nqc27A40tPX//+29B3Ob1/X1u4le2HuVqO4it7jEcey0e2fu3Hfe+37mfxInjhNXWY66RFWKvaE33rUO+EgQRUkECIIPgHVoCO0p5/wOPcM1e++1EQViX6MDrLoplBhtooCiXTn3tQBBdfPmDbtx65YNDg3aF199aQPDQ9XeSG9IffTuq2cREAEREAEREAER6AQCEkydsIstWgP/MC+iNoY9l2g2wPcnOXh/9gt6BIHCCAujKqwPorX2QVEmJyxgR3737t2qUx6OZU+mZgxem5EluvBRuJBMDBElircQIi7TaLI7jjTAZqbi1c6bjXkXEG0jD66JHDwGFEmhaMiiCaTG0WRhfwQOc3cmEtzPvQfF37Vr1+zq1V+dYPrjH/9ofYiMGa710vm1E9FrERABERABERABEegwAhJMHbahx7kcF3lAZKkAK3E2VPXDoDDZgDEBXfNySIdjdIWRnVcZKjCN7z7qnkqIqjAKQyHTjEHBxOjVfYgWCiZGvyheOCiUzp07ZxOY22F6LjUyH6YCMtLG/lSMbp1GzVGtsAkwysRaIwinAFzs3jQ8wXTlyhVj3dWf/vQnRO8gmDREQAREQAREQAREoMsISDB12YY3vFwokyKNHvac8Rq+zjGc6KXC0dDBRZmQ+sbnWsHg3Zai6gkiUp6wmJ+f97460rNrjIs6JYqlh6j9oYChaKpASNERj+mCtBIfQnoba5kOmttRJlDAvVYgGr1aqfPnzyMY5PnWVWuZKJYiMGAIwc77maXdK27Kud+4ccN+/PFHJ5QomCicNERABERABERABESg2whIMHXbjje4XqZs5dMQAYgunXTt0v4lUKzs7OxUo0xwhBtBf6URRJlovLBfmHjiiv2FKFwoLNxgqKp2PNMaeFH9r/bbl15zDqxfunX7tqtZomCiYGHtEtPyGJ2ZRfPXmZlq/6Vmmj5wMoxmbW5uOqt1LNouXboEswf0Q9oTTXzuCfY4wUTRdFAtU+2iKJhuoX6JgimJvk6eYPKuV3usXouACIiACIiACIhAJxOQYOrk3W3S2phuVilVLLeTg0MenNRY5+KzwT/wKRgW0Ww1DKHExrSDiOzURlk4ZU9YUNwEAkE7f/acWwnXWDs8YeCssJHBxi5De9qj9rBnr2ko8QT3vn79uuv1RAFFwRZB/ZInmGYgmKamUGMFAdJswcT7M2rGORQg1s5fuOBqqPbfJ4I6Jj6CqGV63SDP2xB/P/zwg+vDRMH0Jtv2111P34mACIiACIiACIhAuxKQYGrXnWvhvBlRotlDIZN3wqmFtz70rZzpAuqT2GyVwol1TFOoT/Jswxkhq+BBYcEoUwa9kejM8No0MxdZwj/PBBNEEy26EanxBJU3QQoMpuNdvXrV1tC7iKKNUSWKDJowcD58TdOHNzXY9a5ZzzMFGudA04ltRNtOoYapH7VM+2u5gmgcG4lRNIVfe3lei+YY33//vZszTR+4hv3rfu1F9KUIiIAIiIAIiIAIdAABCaYO2MTjXkIJjnj5NGyn0X+JwsOvw0WP4JZHW29GdRhlGhocgjDqgViqOFc/zw2Owokii8cdajClDQdSMDnR1IN0t2fCqeqQx4jMNUSYKMhGkRZIsweKjCEIJUaVXOPXQ92ssYO4RgomCraxsTE3Bwq02sGIWRg9lGJ9r6+j8gQgBRPn/Yc//MGZZOyPWNVeW69FQAREQAREQAREoBMJSDB14q42cU0UFcVcyaXjubS1falrTbxVUy7F2iH2PaLNNnstTY5Puuty2m7+zbgLxRMeAUab4D7HUBXT4RiRoeFDArbmc4jwULDRsY7Htioyw5Q8phtyDnQApFB7YWAuwUjQ4r0xN/dXzYvicwFugt99950TlV999ZUTYRJML9DUGxEQAREQAREQgS4gIMHUBZt8lCWW0ciUfZfySMdzzYWOcrFjPpexL843nUpbHo1XWb/U20vBQrHU3Jt7QsOLOJXLJVvf3HDCiWl+dOmjhTgFhndsc2dw8NVWVled+QUFz5n5+QOtwCnyaPzASNOrLMYZgaNF+n/+8x+3Bk8wMZ1QQwREQAREQAREQAS6iYAEUzftdgNrpSteAYKpBEtxX4+9CFIJgqmE1EHWXdWVctfo4hg94rn4p1RBmh9+YlGYKkBYtFIoedPfQP0We1JtwgXw4sWLztLc+857psgLhoMWQ5SJzwcNCiZGy/7973+7r7/88kubgF27BNNBtPSZCIiACIiACIhAJxOQYOrk3T3q2iBCGFli7yW65Pl1uHQ71O9QJJUplE6izorCiUIETWH5cGLJKanWUkulUi4l7xHquGgtzua8tBffPxhZivXFLAQTCM57/6BgYi3Yt99+6+q/fv/739skGu8euuZr/wX1XgREQAREQAREQATalIAEU5tu3LFPG2KJJgLsvUTB5Nd0PIolzpOCzosqHTub19yApgoUTHTSc/U+L2uR15x99K9Yw8W0vDt37ti5c+dsHOYPB5pNYF6xZKyalufqsF68NwUTa8EomJjeR8FE10EJphc56Z0IiIAIiIAIiEDnE5Bg6vw9bmiFjNKU0XOJEaYSLMX9OKqRJcwTaXh+EEseo2qkKejqgyicWjkodNbX151b39zsrHPqe8n4YW9CrGPigyYQ+wev8xQW7d98842zK//iiy9senr6JZvy/efpvQiIgAiIgAiIgAh0GgEJpk7b0SathwKkBHc8RpcoSPw4GFmiqGN/pRNJw3sNlGqkCSl6aBB7UMrba0490les22Ifqus3btgILM1pbc7+TweNUBg9mZJV84f935Pt0tKSE0y5XM4omGZmZiSY9oPSexEQAREQAREQgY4nIMHU8Vvc2AKZ4sZ0vGKhaLtl5L35bHhpeCdWs3QIHqwT4iOIlLdWGkBsb2+7lLwoejCxH9MYekIdNDi3SDJqUUSZqs4Vz48iX9qT/+Mf/3AW7b/73e9sbm5Oguk5Ir0SAREQAREQARHoEgISTF2y0fUuk5GbXCpn5UK1wWu95x/r8dBvjHq5VLyTMHg47OKQjcc6JjrRVe3FD3vi0Y5jTyg63LH57AjEEvsxHTQY+YrEIZgSkWoUrCZ7kIKJDXC//vprZ5XuCaYD66EOurg+EwEREAEREAEREIEOISDB1CEb2cxlMK2LQskJJggnXw2aPDg3PAom/zr3ecwYWXImEGFEmw5wq/OOa+YzU+hoLb4Oa/GhoSEXGWJPqv2DcwvHw66Oib2ZaqNgFEyshaJg2tnZsc8//9xOnz59sIHE/gvrvQiIgAiIgAiIgAh0EAEJpg7azGYthfVANHrIpXO+sxN3ZhSMLp2UfXgDkKtRpmp6Xq0oaeBShzqlUCgY0/JoLc4GuqdOnbJwCPbh+0QT34eiqGPaM36o/Z6ieQOC6+9//7ttbW3Zb3/7W5ufn7doNHqoOeggERABERABERABEegUAhJMnbKTTVwHIziuYW0G/Zfw2i+Df8RXUE/lueI1a161QsG7Ju/VtAFh4vozIYrDuqHjHnS4Y5SJ1uJMoZtF7VE8Hn+5HxOCTjR+CEMwhSGcas0puH4Kpb/97W9OOFEwnTlzRoLpuDdP1xcBERABERABEfAdAQkm323JyU+IqW50xytmYfiA1Cy/DP4Rz9oqzu+ogob1PdupbVteWX4p8uLWi3slk70wTEAfo3DkyOl0zmocjnnONe/l7LimInacIJpu3LyJ/lm7ruHswMDAgT2UmIoXicFe3Ktj2psJr8FUvL/+9a+ulumzzz5zfZ0UYWrqVuliIiACIiACIiACbUBAgqkNNqnVU6z2XyogLY+CqYmRliMuhNGlUrF05KgXI0o7EEu3796xb/79jXN+o5Bx0Z+95VIwzE7N2McffWz9ff0WCoaPJtIgkoJBCCZnAHHMimmP881bt1ykaRTGD6MjIwfWH1HIhWNhi8Itb3/0yxNMq2iE++mnnzrBFIPznoYIiIAIiIAIiIAIdBMBCaZu2u1DrpWiJJ/K+8ohj8LN9YZC/dJRRBzFEm2+GV26fuuG/e3rv9npuVM2PjZuiUTiBUID/QM2NztXTUPb7XH26keJbDnzB9ybwmm/jfcLN27Sm4WFBdtGlIh1TDNoOntgdAg8mI4X7Y266Fftrem29z//8z/OQOKTTz6xCxcumARTLSG9FgEREAEREAER6AYCEkzdsMt1rrFUgOEDLcXpkOeTABNd2zgfRpkaFS2eWGIkZWtny67fvA7B9Hf76IOP7NyZszY4gAavNcGfcDhsiXiimo6HzETWBh2lSa53f0aZ+Pq4x5MnT1w6XRh1TKdh/MA6poNGOIoIU9/LgimTyTjB9PTpU/v444/t4sWLr7zGQdfVZyIgAiIgAiIgAiLQCQQkmDphF5u8BueQtwPBhGiOX4aLLlEwsaaqARHnaohg682aHbrWbW5v2rUb15xg+v3nX9hbl96y4aFhJ2QOFDO4pxNtYHIU0cbUv2AE6X8tEExMpaPY4bzPnj2LmqzkgUKNTnlMyaMBRK1gpGBiDROv8dFHH9mlS5ckmPzyP4TmIQIiIAIiIAIi0DICEkwtQ90eN2L0ppSrRpj84pCHKVXT8RD5aiS6RG3CqJKrU2IvJLzf3HoumD547wOXltfHWiUIGkaW4rG4S2Fz6XPe1nnzcGmBNJ7wvjj8M+cR2mtkWytODn+Fwx9Ja/HHiDJls1k7M3/G+gf6X3bKw+Uo4JxgirxoPU7BRFtxRqo+/PBDJ5j2py0efjY6UgREQAREQAREQATak4AEU3vu27HNmtEICqZ8Ou9EyrHdqI4LUyTRGY8peY0IJtcHibVDEEOeSKFgunHzhv39H1/b8PAwUu/iEFWI/uDB1zMwfJhG3Q+jTrUNZ5/1gWrQqa/ak6lqMHHcQSZai7MX0+bmpqvF4jrDjCLtG0wRjCSiL1mLU2h5gum9996zt99++6U6r32X0lsREAEREAEREAER6DgCEkwdt6VHWxCjSn7rwcS6oQoFEyM7DYR1XBocU/EQ3fHG1vaW3Vu4Zz9f+dkGBwedmQHFUCqTtm30H6JBwvzpeXvv8nuWTCSrRg04mffncazz4rzqHc/txQMHpsfVe73XHV8qlVyEaWVlxSbGx20cj4OMHwIQklHYitMtj/PzBgXT119/bY8hut5991175513XFqf972eRUAEREAEREAERKAbCEgwdcMu17FGXwqmmma1jQgmpsBRNL0gBnJZ29jcsKXlJevv7a8KJoghWmkvLi3ag4cPEI2J2AeX33fpbKz/8YYTTHASLLOpb52aqZXGD4wWPl1asiU82IdpanLywBokJ5jYvDb+smD65z//aY8ePXLRJYqmWg4eDz2LgAiIgAiIgAiIQCcTkGDq5N1tYG2M5LgIExrX+qWGifMoHcHwIYzaHJo91Jo5uEgRBBJFBT/3vmNUJpVO2X++/w9E00P0Lxq1L7/4vWtg6+FkkMv1g2ogLY/3YVpeCHVDtQLOu3Yzn7m2tbU1iMJlV5c1MzNjvTXCz7sX2UTjSMk7QDB98803TjDR8OHy5csSTB40PYuACIiACIiACHQNAQmmrtnqwy2UaW/FbNEKEEyMpPhhHEUwUaDQBY49kA4zKKQoNK5cvWJXf71q6XTG/r//9b9dPZMnqhhVKoGTSxGsk1ErBRPXsoX0wmUIpmKxaHNzc9bf3/8SBgqmyJ5gCtSk5LEG6l//+pc9ePDAWYpTMLGnk4YIiIAIiIAIiIAIdBMBCaZu2u03rRVCwAmmXPcKJiKi0GCPpiu/XLFl1P/8n//9f2xuZva5+UMbCSY63VEwMdVwGhGmoaGhl5zyXieYvv32WyeYzp07Z++//74E05v+H9L3IiACIiACIiACHUdAgqnjtvRoC3pBMKF2yA/jyBEmpL85h7xDLsYJphsQTIgy0TCBgml2v2BCiiAb2dYbhWt1hKlQKCItb9VW0JNpbGzMRkZGLIpGtrXjdYLp3//+txNMZ86ccYKpr6+v9lS9FgEREAEREAEREIGOJyDB1PFbXN8C/VrDREvxMlLl6jVZ4OpDqGEKvqKGqdYynMdSLDF97edffrb/Xr+GWqWi/b//z/+y6akpfu0GDoHFOUwfGq1h2uvFdNw1TJwsRd3GxobrpdSHdLxxiCb2UnqWXohjXieYvvvuO1tYWLD5+Xn74IMPTILJ/QroHxEQAREQAREQgS4iIMHURZt9mKUymuPVMPG1HwbnQXFSYUSngaDXQS55mWzGCoWChUNhZxnuCYhCsWBs+PrjTz86s4RJOMt9/tnnNoIeRt5oF5c8ztfVMWE9dLqLwPVvfGLcBiCcvPXymAD7MMElL7LPVpw1TN9//70TTKdOnXLNayWYSExDBERABERABESgmwhIMHXTbh9irU4wsYYp4x+XPAoU17i2iX2Y2IPp0eNHqEsKWj/SzGKxGIJXVZOEJ0+e2NPlpxAWA/bxbz6x2emZZ3bcFCC7SFV85tp3CKa1hzCq5PWFqhUttcc0+3UqlXK9lIpwAJyYmIDz38hLgil6QONaCqYffvjB7t27Z7Ozs/bRRx8daBrR7PnqeiIgAiIgAiIgAiLgJwISTH7aDR/MheKEtuL5dN43tuIMKrG2qlxorHHtQSLl9p3bdvP2TRdNCoVgO04XPdyI6XiFfMGlnp0+ddouXrjoxJKXusdmtUwPpLCkeKp38DpB1xfqcK599V7/oONp/PD06VO31glEzNjE1lsPj+d8IknYisNNsFbE5fN5+/HHH+3u3bvOJfA3v/mNBNNBgPWZCIiACIiACIhARxOQYOro7W1gcRQN+aLldnK+EUxcBZvEliiYWMfUwAgGafwQqAqjHoMJwoqLMFFIMJJSKBXdVeOINA30DbiIyuTE5Av1PhRIrPFy6YENzoPCjD2YagVLA8up6xQKHzavpVveOCJM09PTFgIPbwQxn1gyZnzeL5h++uknu3PnjjE18eOPP3YNcL3z9CwCIiACIiACIiAC3UBAgqkbdrnONVIw5XfyLqpT56nHdjgjOkyDYwSskciOQSQ5sRKqipXKLoQPaqLYc8ml2WHmOMQJBheRQqoeRc0zAQEhyeOfiaX6g0vuWpwDhUkA/aFaNRg1W1tbt4ePHtowarFmYS8ejUaf3Z6mGLFeCCZEmhyEvW8otK5cuWK3b9+2cUSlPvnkEwmmZ9T0QgREQAREQAREoFsISDB1y07Xsc5SoWS5VM6lnjXiSlfHrQ59KFPhKq5ZbGOpcLwRhZBLiYNo4Ws+DjMo0iisKNoqqF9qSLDx/hBJrn4JwqSFeslF59jAdgF1W8lkLyJMUy+43YWjYYv2Rd3canlQMP3yyy9269YtZ0lOwTQ4OFh7iF6LgAiIgAiIgAiIQMcTkGDq+C2uf4GsFcqlIZgarBmq/45vPoPlQs+jTI2l5fEuFC2BYFU49fC5B7VEr9BNXjTLiTWKJabhNRBZ8lYXZHSJES48v+qe3rHNfKbAo/HD3Xv3jPVaE+Mwfhgdqd4CPMKxaoTJzavmxhRMV69edYKJkanPPvtMgqmGj16KgAiIgAiIgAh0BwEJpu7Y57pWSVMDuuQxNY+iwS+DwsW500G8IMxzpGkx0hTwokx85tW8sA+uzas7wbQXXToqByfUUENFi/NnaX5HWkF9J9P44f79+1ZCWiGb13p9pXrAgYIpCtOH/YKJtuu//vqr3bhxwwmlzz//XIKpPuw6WgREQAREQAREoAMISDB1wCY2ewk0Nihk4RaXLTRsstDsOfF6jJSUi9Xao6MKGF7vmXBxAZ+9MBOfoJZc2p3TZEzB49FHG652yZlOtDYdz5s1jS1ol55Op53T3enTp91XjHiF42HXh2l/iiIF03//+18nmPrRu4mCaWhoyLuknkVABERABERABESgKwhIMHXFNte3SKa+FfMlK/jIWtytAMKFaXHPokz1LetwR+8JpsMdfLijGLiquvRBLCEN8CQGxc/q6qp7sOfUhYsXXUAtFA5BMEWqluL7arp4zrVr15xg6u3ttd/97ncSTCexebqnCIiACIiACIjAiRKQYDpR/P68OaM3nvEDo01+Goz8VK296XDXhNBPCxbnjCbCVUvzZ1GtFty39hYlNK2l8cPi4iJS74J24cIFZy0eoVjCg1bn++dGwXT9+nX3SCaT9sUXX0gw1ULVaxEQAREQAREQga4gIMHUFdtc5yKhQ0pFOOWhFxPrmXw1GGVyoqlsJbjmHcWEoRXroghh/yemvu1PeWvF/b170BI9m83ag4cPwa1kZ8+ctXgiZvFk3DWtZcqgV8LlnUPBdPPmTanqoN8AADfxSURBVBdlYlTq97//vbMl977XswiIgAiIgAiIgAh0AwEJpm7Y5QbWSKGUS+VdpKkpRTwNzOFVpzCuxLRBzpHPfh4uFS9S7ee0P4LTynkzMkehtADjBzrmzc3OwcBhwJKDSYskIgc20mX/Jgom1jGxb9OXX34pwdTKTdO9REAEREAEREAEfEFAgskX2+C/SVCI5NMFK8Epz4+ixEvNY5SpGQYQx7EDjNqEGFlC3dJJiiVvbaz/eogI08bmphM+k1OTNjDc7wSTd0ztMwUTm9bSKS8cDjvBRIc9DREQAREQAREQARHoJgISTN2023WslSKpROMHOOX5Li0P66BznSeaypjrLnsk+Wg4VzwIpgDS8Zxp+cl4PbxAhLxYw7S6tuYiRvNn521obBCGD+EXjvPeUDDduXPHCSZGyr766itnSe59r2cREAEREAEREAER6AYCEkzdsMsNrJF/XFMouX5MuWIDV2jNKYyalEswgvCLaEIhEM3mXM3SXoPc1pA43F1WVlaMD4qhty6/bcPjw6431EFn85i7d++65rWMkP3hD39Aw9vRgw7VZyIgAiIgAiIgAiLQsQQkmDp2a4+4MEZw4EKXg7V4kf2YGNLx6aBoqpSr7nmVXTa1PZmJUlTQ2CHIyBJNFPbZdJ/MrF686ybS8ZaWl219fc0+/ORDG50YhWAKvXjQ3jsKpoWFBbty5Yr75I9//KME04Gk9KEIiIAIiIAIiEAnE5Bg6uTdbcLa8pmCFfEo05HOx4MW44wy0XKcAqrlw/VaolAK4uGPmqWDGLBx7dOnS/bw0QP78NMPbXJm0qXnHXQsBdN9mERQMNFl709/+pONjY0ddKg+EwEREAEREAEREIGOJSDB1LFb25yFeXVMRR+n5XkrpWhiVMwJJ4imVplBsM8SjR0YWfKiTN6c/PZMq/DHT57Y1WtX7f3fvGfzZ+atv7//wGnSVc8TTBRPf/7znyWYDiSlD0VABERABERABDqZgARTJ+9uE9ZGQ4VitgjHvNyJpbrVswymDlIolZGiRyMIvnYZes1OKUREyYkj1ix5KXhMycPnfh7OKe/xQ/vXd9/a2+++ZRcvXbSJiYkDp0zBRFe9n3/+2fL5vP3lL3+RYDqQlD4UAREQAREQARHoZAISTJ28u01YGwUIo0zZnWw1YnNC9UH1LoXzdml6LkUPoomCqVmiCaIo0MP0uz2xhAgTrPDaY0DRPXz8wP7+zd9t7vScXb582ebn5w+ce6lUROreI/vpp59c09u//OXPNj4+DlGI9e4N5wDovdGzCIiACIiACIiACHQgAQmmDtzUZi+p6pZXRBNbf/ZketV6XbSJAm9PPLl0PdY3VUNOh9NPEEKeKPDS7WjmEMCD7ymU3POrJuGzzwPoC/V0ZdG+/f5b1C5F7J3L79ilS5eAZO/HiUqITZhn5Is5e7z4yH65esXSmbT97ovPEWEat2Ag5ARjsCdkwR7UbBl6TYGF+yETvqKgdJ8wTZEQ3D8+o6HpiIAIiIAIiIAIiMCbCUgwvZlR1x/hrLsLZaTl5X3Zk+kwG+RS8yAGqkEmPDNVzwWdnHp6Od2QQogXphDgX/wuiITXfPY+O8yNfXZMKBK0te11++nqj7a8+dTOXpq3C++ctUIZbogVPtCsGI9ipWiFUt7W1lfhlHfPsrmsvf3O2zY4OAixCIGEHwolCqZQIOwe4UAEz1GLBKMWC8QtFkxaNBh37ymf9pSTO9dnWDQdERABERABERABEXglAQmmV6LRFx4BF6mBwMju5KxcKFVT87wv2/S5WttE4cQFUDntW0hVLTlrcPeSEaV9h7TDW6zQRYtKu0Ur41EKQwRlVuzW/et25+Ftm5gdtdPn5wzyqEYwUTjheDjjpVI7trS0hBqmgp06NWe9fb3QPS+m5DHSFA5GjIIpTMEUiEEsJSyORyyUdK8jwRg+p5iikIq74yi2NERABERABERABETA7wQkmPy+Qz6ZH0VTIY0/quGW53eL8bqQ7RdK+09uQ5W0CxVY5k+lZKXdkosa5StZy+7u2FbPsq0Wntry+qItPHhgA4N9NjM743oxMZBGgeUEMoUW0hdpQ74MwZTL5Wxu7pQTTHQFrB2UktW0RPfKCSqXjse0vL0IFMVTItRnyVC/9UYG8Txg8VDCohBXFFJBRKnaU5LWktBrERABERABERCBTiQgwdSJu3pMayohuuREU754THfQZY9CoCp2KhBJRcuV0pYupyyL50I5hwhS3lI9m5YKbFq2gs9zabtz+45FYzGbmpqyRCIBW/QXIz4UXhRMS+jblKVgmp2zvv4+pOS9KJjeNGcKIWeSAfHk1T1FIZYGI6M2Gp20kfiU9YYHLNwTcWKrqlHbUKm+CYS+FwEREAEREAERaEsCEkxtuW0nM2n2NypkEWWCzThfa/iDAIVSCSl0uUrGCaRcKWOFvXokl4bHKFNPDtGlFcsH0tXoEyzDb9285eqK6Hw3MDhgoVDohQUx0pSB2QMFUyaTtdm5Gevr639JWL1w0iHfMPLE6FIcKXvxUK8NRIZtKDpuw7FJSwb7XE3UIS+lw0RABERABERABETgWAlIMB0r3g67ONLXXJQJgomOeawD0jg5AmUKoXLB8pWc5coZJ5icWIKBA5PyvFG2kmUC27YTWLNST8F9zHS7u4gwsZHt4PCQ668UDoe9U9wzBVM2k3E1TOl0xmZmZqx/oDmCqfZGtI9get5AdARRJ4g3iKf+8JCLOtE0glEpDREQAREQAREQARE4KQISTCdFvk3vS5FUzJUsn8Ef5aXnf5S36XLacNpVEweKpVw5a+nStqWKm+51effl/WD0qdCTte3AqosuVSClOFwDW9QwpXZSluxN2jTEUCQSeYGHE0zZrKthSqVS7piBgYGmRJheuNG+N73hfqTqTdtUct5FnZKofQrBUEImEftA6a0IiIAIiIAIiEBLCEgwtQRzZ93E9WVClKmYKyjK1KKt9eqTiqxPKqdtp4BaJESVaAVOocR6Ix5TO1yqHiJKmZ5tS6N2yYsu8RgKpqWnT21tbc0JpVOnT1sM9Uy1g4IpB8G0tLQMt7yUTU1PGQXT/tS92nOa8ZrpenTco9Nef3jYJuKzNhqftr7woHPX83o+NeNeuoYIiIAIiIAIiIAIvImABNObCOn7lwi4KBMNIDIFqxT5x/qLf6i/dII+OBIBJ3w8IwdElDKl1F5EqeQsw191cablZZGKlwpsIMqUh5x6XnfGPVuHWHqK+iSO0/OnLZlM7rndVa/oBBPMHpxg2t62SQimQVfr9GLqXvXo5v9Lswg66CUQcRqOjtkYhNNk4hR6PMGgAs1z5arXfOa6ogiIgAiIgAiIwMsEJJheZqJPDkGApg80f+g4m/FDrL2Vh1QQPcojipQp7ViqtAVTh5RrMrs/mnTQnPI9aeeKx/qlWrHkjoVgYtTo8eMn6LGUh2X43Ev1SRRM+XxVMG1vQTBNTbrGtftrnQ66d7M/Yy0TXfXGE7M2Hpt1r1n3BNeKZt9K1xMBERABERABERCBFwhIML2AQ28OS4B/TFdKe6556M0kA4jDkjvccRRExQoMHZB2l3J1Stt4nUVECRE9/Lxu8PtKT8V2etZchKmI6NJBg2Lo0cNHtoM6JqbbDQ8PW60Y4h4XCnkXYdra3LLJyQkbHBp64ZiDrnscnzGaRPOHSChqE7E5F2kaicIOPdzn0vcUbToO6rqmCIiACIiACIgACUgw6fegcQL4u72Inky0Gqd73hv+jm/8Pl10phNDECpsOLtd3MBj3aXgeXVKh0FR7oEpB4weKJgKPRnb7TlYYJVgLf7k0WPb2NiwkdERo714JBp9dgsKpmKxgFqnZdvc3LSJiXEbomDaZw7x7IQWvKAwogFEH/o2MT1vtveCizax5kmiqQUboFuIgAiIgAiIQBcSkGDqwk1v5pKZmlfKVxva0kiAf2RrNE6AwoiRpI3CimWKO84ynI54hx0UXPlAxrZ7Vp07XqXnZec871rlctlZhq+trlpvby+iTNMvGD9UBVPRRZg219dtnIIJUaj9bnre9Vr5zBqmeDBpI2h8e7rvko3FMHf0dJJoauUu6F4iIAIiIAIi0B0EJJi6Y5+PdZV0zaPVOF3zKJoUaaofN4UOm8/S0GEHNuE7iC4V8f6l2qPXXrpqIe56LvVs7EWWXi1guVd0yVtZXrZQMITGtLOWgPGDNzzBxO/XIZjGxsZseGTEF4KJc6Q4Ym3TCJrdziTPQDShtik6KtHkbaCeRUAEREAEREAEmkJAgqkpGLv7IvzDmvVMebjmMTVvF1EnjcMToFhivRKNHbYK604sHdRT6XVX5DUgW519eCawZcW9BrWvO4eCaRvud8uwDS8Wi3bq1Jz19vXCKS/w7LRSqRphWltdg2AatREKppq0vWcHnuAL2j4MxyZsNnnB5pLnLQlXPaboaYiACIiACIiACIhAMwhIMDWDoq7hUvHKtBqHc54TTWhwq/FmAhX0TypUci6qxJqlXCnj6pfqC9MhOoWfLPotMbpUCOQOFZmi0M1kMi7CxAa2UzPTL/VZKpdLroZpFWl7o6hzGhkdtajPBBMph3rCTiiNxqdsvvdt2JCjHisYU7Tpzb+COkIEREAEREAEROANBCSY3gBIXx+eACNLRdQzOatx9Wd6I7iqZXjORZVSSMPLwRGv3sgShVUZP7lA2tI9m2+sW6qdlJdyt7qygtS8dSeImHJXK4hY58QI1AqOGRkZxjEQTPsa3NZe8yRfB9Hwlil6EzCDOIVo00RizhlEBOx5xOwk56d7i4AIiIAIiIAItCcBCab23Dd/zhpBJdefqcD+TCVjbRNCT/6c6wnPimIlW0k7sbSNNLwCei1RQNU7YLnhHPHSAQgu9F16ncnDQdeuVMq2trqOKNJTpOP12dj4mCUSiWcNbPn90tKKi0INDw/ZKOqYYj4VTN764jB/YK+mU30X8DwHMwisBz8aIiACIiACIiACItAIAQmmRqjpnFcTgD4qu0gTUvPQn4m1TRQHGs8JMA0vV8lALK3ZFs0dyjmIpfrrvmgfXrCsS8PL9aSM7+sd3Btahj99smihUMgm0Gupr7+/RjBVbBmmD4wyDQ0NOuOHWDxe721aenwPIkoxmkHEJ22+722bjJ9ykSeJppZug24mAiIgAiIgAh1DQIKpY7bSPwvhH+EUSkzPc6IJAkqiqbo/1ZqlvK0XlmynsAELcdYb1Sso6Z1HR7wMxNKWZXp26o4seb8t3JednR0XYSoUCjY1NeWsw3t6qhEZGkOsLK84+/GhwUEbRQQq7nPBxLVRHLGGaSI+Y+f7P7DR2JSFg1FFmryN17MIiIAIiIAIiMChCUgwHRqVDqyHgBNNjDQhNY8mEDSE6PZBWZRHndJGYdVFlwoNiSWkPeKnEMhaCtbheaThNRJZqt2LdDoNwbTkHPOmYfxANzzPKc8JJtQvLS8tOUOIMTS3bQfBxPVRNDEdjz2azvW/B/F0CjVNodql67UIiIAIiIAIiIAIvJGABNMbEemARgl4oomNbfkol8q226XueYwiFcp5oxPeZmHZsmhOu9tQGl7R8sbI0jbEEkwiGkjD27+fuVzOaPywjEgSU/ImJiZceh6Po2BaXVl1Eab+/j40r51oG8HE+QdgkR4NJmA5ftZO974F0TT7TAzyew0REAEREAEREAEReBMBCaY3EdL3RyZQRnoeo0xONNE9D3+Ed9NwPZJ2i7Zd2IRYWrV0abvumqVqnyUYPMANL4sUPD52e+pN5TuYOnswsTHt40eP0Zh22CYnJ58ZOzjBBEtx1jD1oUfTOCNMMIVot9EXHrS53gt2ceBDoylEsEeRpnbbQ81XBERABERABE6KgATTSZHvovvS84HRpnKRluPV9DxGmvhZN4zybsmJpI38CvotbcE6vL70RKbg0d4hF0hBKKWsiD5LFViJN2tQFG1tbdn9hfuWTCZdlKkfxg8ctYLJfTcxbgkc026DkaYh9GY60/eWzbC5bajfRZ/abR2arwiIgAiIgAiIQOsJSDC1nnnX3pF/fNMMwkvRowV5p4sm54hXTtt6ftml45UqxUObPDCqRGFU6oEXHprS5pCCx9f1Wocf5heOxg/3FxYsFAw5Ywf2W+LeMBq4urbmIkyJRNyl5Hm2454xxGGu74djIoGo9UUG7a3Bj109UwKRJlY6aYiACIiACIiACIjA6whIML2Ojr5rOgH+Ee5EU22KXodGmih4WLe0kV+Cffg6GtNm6+JZ7kG9Uk/Wpd/REa+E97zmcYxMJmOPHj60InpoDY8yLW8K9vBoiYvH+p5gisVjrg8TBVMgELBwOOyej2M+x3VNNredQT3T2f7LNpWYd1Em2Y0fF21dVwREQAREQAQ6g4AEU2fsY3utAn/zM9pUdc9DBAWpertlSIEOE07FSsFSSMFbzS9CLGUOVbdEQcS4EiNJNHVgM9oCRBOjSscllvjLk8tmq055O9toXIvGr7APZ5peHlbj25tbtrGx6QTS4OCAUThFoxRPo67WieKpnUY81AsDiEsQTe/aQHjYgnLOa6ft01xFQAREQAREoOUEJJhajlw39AiwjokRDJeih4iTa3LbIS56TMVLlbZcKh5F02HqliiI6HoHawf0Vqq64FE4NcvcweN+0DN7MK0hksSeS0y1G0AN00NEnFKpNMRUzrIQVBRGsVjUorGYDaIn0/kL52wAz2x4204jgCjTYHTUTvddsvnety0BAaUoUzvtoOYqAiIgAiIgAq0lIMHUWt66234Ce9GmMtzz2OiW/ZpY29TOg8KnWIYAyT91D4qnN0WH+H21VgkOeIEdo3n4bs+bz2sWp1KphD5MW/bk8WNE+syGh4ft9s3brjdTPl8wfh+EYAoEg4hAobfRxJhdeuuS9fZCbOw1uW3WXFpxnVAgbGNoavvWwEc2Hp+zcCDSitvqHiIgAiIgAiIgAm1IQIKpDTetE6fsok3o00ThVC7ggddM24OOaKvhokSVkrMPr1qI77x2/nTAg1SEXXgWqXcZPHIQTnl82lrRWEGkL5fL2v37DyCOyq557eKTRfRmWrad7ZTbC0aYAoEeJ6ZOzZ+y6ZkZpOZF21Iw0eyBkaW53nN2vv8DG4iMyDXvtb+p+lIEREAEREAEupeABFP37r3/Vl4TbWJdU6UI2YBoUzsJp/IuhAdc8Zazj5GSx35LB9t/e0KJUSXWKOUDVbHUTLvwejaY9WOlUtEW7i1AOOWMLnm5XN71Zlp6uuQiTIwkUSDNzs3Y+YvnEV3qsyAiTu06aDU+GBmzi4Mf2nTijOvPpNS8dt1NzVsEREAEREAEjo+ABNPxsdWVGyTg7KxhAuHc9CCcGHXyLMidMYRPo06MLuXhhLdZWIMz3ooVKnkQeD5Zmjm4Hxg4sK+SE0p7UaVWpt+9alsoTB/cv2+0GGcfJqbbLS4+tYW7C0jNQ6QMoopGD2fPn7UzZ+EwFwi2aXTpOYFYMGHjiVm7gCjTeHwaDW3Dz7/UKxEQAREQAREQAREAAQkm/Rr4kwB0hhNOMIGgWGKKXhkRJz6zNxB1iKsLeq5HTnwdjC7tFDdtNffEsogyMbrE6XGesHNwtuBFpNwx7Y41SrQNZ0SpglolPwwKpqeLi3DE23BGDlNTU0483bl91x4/ZG3TrhNL5yCYxuCi1wk9jBhliqMf04WBD5xzXl94yA9boTmIgAiIgAiIgAj4iIAEk482Q1N5BQGoDv4x79LzXORpr8YJTXD5mR8GJRGtwzcKKy66VG1QCzkE17uqQIJIQm0Seyl5QskJPj9Mfm8OFESrq6u2uoLoGPoxnTt3Fqsyu3f3nt26ccsJ1cvvv2enz5y2eDzuo5kfbSrszTSZOGXnBi7bqeSlo11MZ4uACIiACIiACHQcAQmmjtvSzl4QzSEqFE0wKWDKHm3JXQ8nfg5RdVIpe4wmbRXXbDnP2qUtRJDgLMdHAA/UKbnXzxrP+igsVvPrQnbb6L20tLTsejBdvHTRCSPWMC3cu+fE6cW3LtrE5IRLx6s5ta1fsm6JvZnO9L9l7wz+1iJwzOtB5ElDBERABERABERABEhAgkm/B+1JAJqDf+C7yBOFEx67NIjAg597wunZM1eJz5sxnI12DxPS3D+IwlQsV8nYUv6hPc09sOxuyqXcMaLEaiX8X+YiNUzO8/MgK/ZbWnr61Immc+fPWf9An2WyGVtfWwe+CtzzxizZx75FAbd+sugEowSuYSp5xi4PfWZD0XHZjPv5F1VzEwEREAEREIEWE5BgajFw3a75BKo6qCpGXJTJRaD2xFOJzXGfC6mjiqYe2GpTJLAfUSDI54CVAyWIpQe2kL5mK7nHVtwtYpEUSf4WSC/vBJ3ysBZElB48eGCzp6atb6jPAuEeMCw5EUprcTrjsflrJBB1Jgl83QljIDJks70X7CJ6MyVDfZ2wJK1BBERABERABESgCQQkmJoAUZfwFwEvwsT0PSem8E8Fr90bvOZntd95s3fyhv9UA0d7z1WBhIBK1RFu79lFVtiwFf/RRvzW9s92L3UNZg/oWYRITLuMqqiDUKogibCSs3wpZ5vbG7a2vmp9A0mLxqNOFLrjHCBy4LIhFiGUAj0hNLQNWQjucpFgxKKBuLEpbA++4zHtNJiKx+jSR2N/siHYjbO2SUMEREAEREAEREAEJJj0O9A1BFx6HldL0USjPT6793v/4I3TS1QEe8OJA/zDyBL//nfpeN6XeKYz3npuya5t/scepe++su9SzSm+eVneLVmxUsADzn3lHIQfjClghZ4v4nU+a8FwEGLIKcRXzpmiiMKCIikEwRENxCwSwgPPYUSgQhBU7VIPxLUk4Jj3wehXNhWHsQXqmjREQAREQAREQAREQIJJvwPdS2AvYlILwAmm2g/4+rl+2v+N67u0kLpud7eu2lp+6aXv/fgBDSpKSBvMlTIuOpYtpVzPKIo/KkbKSIrJ/eLwdWvxokkBiEuKp1gw6QRHFH2OXOoeolDeMa+7zkl/R5F3pu8tO9t/2UZjUyc9Hd1fBERABERABETABwQkmHywCZpCexKgqKAj3i/r/7TF9H3Xe8nPK6E5RblSgkjKWhrzzpbSSMUruCgZDR0O0I8NLcdFndDUlk1go8G49Yb7IKB6nZECo01+Fk5MMxyKjtrbg5/YXO9FpeU19Bugk0RABERABESgswhIMHXWfmo1LSTAdLZ1RJV+WP2r673EyI1fB8US55sublmquI3IWAZiCUYOTZNJB628mq7H2qYETBR6wwMu8uR3k4gYRN6lwd+4KFMckTI2t9UQAREQAREQARHoXgISTN2791r5EQnsFDdRt3THrm98j4jN9hGvdnynU8ixqS7FUrq0A7GUa2mtFSNKYSeaeuE+N+BS9cKod/LroIHFXO95O+fS8qZdiqFf56p5iYAIiIAIiIAIHD8BCabjZ6w7dCiBpewju7n1o0vHo8OcHweNHfJIwdspbliqsIkoU/GYo0qvpkBziDhMFfrCI5ZEmp5z03tdgdirL3Ws31TT8sbsbN+7Nt/3NtIKY8d6P11cBERABERABETA3wQkmPy9P5qdjwnc27luP6/+zTKwFfdjOh5rrGhzvl1Ys53CljN6OGmcjDZRNA1Ehq0vMuLbGiG6/Z3pf8feGfrURcT8XHd10nuq+4uACIiACIhApxOQYOr0Hdb6mk6AdT+03769fRWC6Wsnlo63FqiRJexaBul32wVElpCKxz5LfpljEFbjcbjn9UM0JcL9zgyikRUe5zm0Q5/pPQfzh0+dCQTnrCECIiACIiACItCdBCSYunPfteojEKCj3DZS3G5v/YL+S98d4UrHcyqFUQWGDjSkYCpevpw/nhsd4aoUIAn0ORqMjrneR2yA66dBo4fx+KxdHPjQJhOnnTW6n+anuYiACIiACIiACLSOgART61jrTh1CgOl3T7MP7Q4E0/3UDd+titGkDEwo2FCXZg/Nsgtv9kIZxRmIjiDSNOLsx/2U9kb780HM62x/tY6JbnkaIiACIiACIiAC3UlAgqk7912rPgIBGinc27lmd5GSt5x9fIQrNf/UCqJfrFtayy66fkucq18HBRL7NA2i71FveNBXJhCcWyLca6fQi+mtwY/h7tfvV4yalwiIgAiIgAiIwDETkGA6ZsC6fOcRKO0W7drGdxBM/3Upb35aISNK24V11xeq2ozWr/GlKjU657FHEyNNtBz3U88jWp9PJ8/YByNfWn94yE/brLmIgAiIgAiIgAi0kIAEUwth61btT6Bq+FCA2cPfbSF1zVf1QdXaqqpYypbSbQGbkRzai/dHhmCuMA4DiKhv5s20vMn4nH048pWbm5/EnG8gaSIiIAIiIAIi0AUEJJi6YJO1xOYR8FLeflz5qz1I3bIKfvwwKORKcO7byK3YZmHVyqizOsrowck0ZghCzDAKRPEAO0DLZQqW2cm652Ckx2IDYQvHg0dy4OO9knDLG45NuGhTj+FePhmjsSl7b/hzGEDM+dLNzyeYNA0REAEREAER6GgCEkwdvb1aXLMJlCoFCJI1u7L+T3uSXsDl/ZHyxlol2ohv5FcsU9w5koAJIOoTDLDJbJ8lgr2oM0rgfch2S7u2eG/F7l97YsuPVi06HLLpDwZsYDYOLVU50j3ZHJY240ORMSfSmr1vjV5vMDJql+CUN9N73rn6NXodnScCIiACIiACItC+BCSY2nfvNPMTIJAvZ20198R+3fgPDB8encAMDr5lEUJuI7/saqqK5UJD4oXpcWFElGj3TROGcDCK6FIYdUWIIJV3Lb2dtTs/P7Cl+6tWyBctORS3Mx9NWf9c1NLFbaQn5hpu4FutZep1Vt4RiCfDXPww+lC7dBYNbM/0vQ0mA76Zlx/YaA4iIAIiIAIi0C0EJJi6Zae1zqYQYG3Qk8yC3dz60dZyT5tyzaNehLVLNHtYyy1aGlEmRnvqHUy5C0McURRQLMVCSSTGIdbUUxUu2VTOlh6s2uLdFUttZVxgLZqI2PmPTtnIqT4nmHaKm86Zj7brjQw65o3Fpl1aHiNafhhMFTzVe8HO97/vImAUlRoiIAIiIAIiIALdRUCCqbv2W6s9IoE0+hs9SN1ED6ZfkZq3csSrNed0puOli1sQTNW+S/Ve1YssURwMoPdQDD2HXM3S3oXKpYptLG3Zwq+PnICq7O5aBtGmYCho5z88bZPzI1ZAc9wUBNMWHPoKjDQ1UNsVgisdex8xNY/iyQ8jDuE4nThjlwY/csYPEkx+2BXNQQREQAREQARaS0CCqbW8dbc2J8AoCvsvLaBh7U5hwxerYV3VFuqqNvNrVqjk6p4TG8hSLLEfUgz1SkzB81LidvfE0VPULj1FKt7E6VHjZ0/uLNcIJn5WMaYFch4UTjmkLtY7OA9ajA/Fxt1zvecfx/EUbuPxGXtn6DOjAYQE03FQ1jVFQAREQAREwN8EJJj8vT+anc8IUBAwHe9R+g6iOju+mB1F0nquWr9UqhTrmhMFQCyUQPRkzHrRB4mueLWjXCrb8sN1e3z7qYsunX57xrLpnN298vAFwcRzdhFVYo3XJuayiUgTnfvqGbTtjgViNhKfdmmB9Zx7XMeyF9Mw7M7fG/m9TcRnJZiOC7SuKwIiIAIiIAI+JiDB5OPN0dT8R4BpeP9d/7ctZu5bFnVDfhjOiCL7BPVL23XbidNsIYm6pZHohEUhnGojKBXYiO9spOzxrSXbXkvZ9NlxGz81YmuLm3b7p/svCSayYKRpA4zWkR7IBr+MRh128N4huPONwcKbaXm1cznsNZp9HK3VOZePRv9gU4nTvphTs9eo64mACIiACIiACLyegATT6/noWxF4gcA6nOiuwlJ8KfvQN01rczCioGNfppSqK6pDQUInvIHwMNLxxlwD2drFFnJFe3J32ZYWVi3WG7Uz785Y71DSGT+8SjDxfKbkbSDKlCmn6jagoMnEBATTAOy8/dAolnOgCcbHo3+y6eQZCabaXxC9FgEREAEREIEuISDB1CUbrWU2h8A6nPGurP3DlnOPUS9UaM5Fj3QVGDBAKC1lHjqnvHouRcFEC/F+1C71IcrEaIo3KpWKpTbSSL17ADvxnJ16a8om5scsEg0jPW/plREmnp/FfJi6uI0aLxpS1DtYM8T+R1WnvJN1paNgYl3VJ2N/sZnkWQmmejdTx4uACIiACIhABxCQYOqATdQSWkeAVuI/rX1tK+jFRLOFkx6sG8oUU4gwUTDVZ7TQA9vwZLjPmT0kQv0QTDR7wEAWHfssPbj+xFYerVtyIG7z78ziGYYQwR57DMMHF2EKBvZc8karQmJP29DifBs1TJv51YYEE63FaUARcvVUJyuYPFH56dj/hea15ySYqr8h+lcEREAEREAEuoqABFNXbbcWe1QCVcH0NwimRQim+gwWjnrvg86vCqYdl5LXiGDqdYJpzEVRqu54ZjR6SG1m7Pp/7lqlXHF1S2OzwxaOVCNQdMtbuPrYAqEepOnNwjlvxNUz0WacKXWsqdqBYNqAYGIdU72DbnRVwRQ5cYFCwURr8U/H/m+blWCqdyt1vAiIgAiIgAh0BAEJpo7YRi2iVQSqgunvexGm+sVAs+fpCaYl1DBRqNQz2GspSRtvRHMYYfIEUyFXsI2nW/brv+5AAJkNjfdbNBG1nkA12rOznnbGDzjdRqeGbGRm0AZG+qx/pNcJJ86DEaaN/EpDEabRvQhT2CcRpjjSFhlhkmCq57dLx4qACIiACIhA5xCQYOqcvdRKWkBgLb+EGqavEdF57PoOteCWr70FrbuzSMmjCQVT4eoZLt0s3OsMFnprapgomDaXt511eDZdgAgKOLHkJcflMwXLpNDvCWoq2R93gorueeNzIxaOhowmFFvFNdvKrzckmMb2aphCAUa0vLvWs7LmHcuIWRJiUjVMzWOqK4mACIiACIhAuxGQYGq3HdN8T5TAOgXT+jeuZqhQzp/oXKo3h2ByLnkP8Zyp2yUvGozB9GEEomnEQj3VHkzlUslyEEoUTUXUMu0fmys7toTeTAFEnCiSxmaGLAn3vN7BhAVR15Qubrn6pRRsziu75f2nv/Y9Rdw4+h0xJc+LeL32hGP+suqSNwCXvD/LJe+YWevyIiACIiACIuBXAhJMft0ZzcuXBJhm9uvGv9CH6UHdKXDHtaA8IksriHilSzt123iH4IxH2+yR2KRFYDHOiA57J7F2qVQoH9hHaRE24wu/PoRgCtqZy7U1TMjRw9gqrBojcUUIynqa11IsUaCM01YcIo7vT3rQObAvMmS/cX2Y5n0xp5NmovuLgAiIgAiIQLcRkGDqth3Xeo9EgGLg2uYP9iR919l5H+liTTq5UM7Zev4p+h9tIU3w5YjQ625DURIPJm04NgHHvOd1TK8751W24hRaxUrO1S5tglMFTWzrGRRL4UDExmOz1hsZrOfUYzs2hPkMw+L8/ZEvbSIxJ8F0bKR1YREQAREQARHwLwEJJv/ujWbmQwI7xQ27vfWLPUjdtB00aPXDKMLefAuOdOx9VKjUnyYY7ok4gcI0OKbo0W78dWMZVuMPbywiwhSwuUuTNjo95CJJ5UoJ7ngbqF9ad72YXneNg74LImLFvlDD0QlnQnHQMa3+jDxoc/7u8G+NZhR+iHq1moHuJwIiIAIiIALdTkCCqdt/A7T+ugiki9t2P3Xd7m7/apsQKH4YbA5LIbeRW6nb+IHzpwiIQBgMRIZdel4kAEc8WuC9YpQKJcvnSs5BLxILWTActDIiW6yl2kTKYracgtlDfdEl3op9lziHftRTxYKJV9y9tR8z+jaZOG1vDf7GReEkmFrLX3cTAREQAREQAT8QkGDywy5oDm1DIFtK2WOk493c+hlpcEu+mDdT33LltK1mF5EmuFNX3ZC3AKbDRQIwgEC9ThKOeYysVKXU6+uIdnHvEgQbubD3UgbPFHDofVv3oGgbi05ZAr2hmArnh0GHPNqJX+j/wDd1VX7gojmIgAiIgAiIQDcRkGDqpt3WWo9MgD2GaOF9beN79GJ6fOTrNecCuy4Vbz23hDqmzbrrmLw5MHoSCyVcE9skREskEIdwCeHTl6NNNHOgAx6dAnOIKKWLO040NSqWKNgYzaHhQzT05rRAb87H/UxDjDN9b+PxDswfBl007rjvqeuLgAiIgAiIgAj4i4AEk7/2Q7PxOQHWC23kl+2XNTjlZRd8M1sKFYqlTdQyMTWuHne62kWw7xBrmpgSFwslXaoeneKYoufFmpyLHsRSCSzY+4n3K8DsgQKqkcgS7x9GGmAfIlt06/NLdInzot36hYEPbK73Avox9eITjwK/1RABERABERABEegGAhJM3bDLWmPTCFAU0L77h9W/2aPUrYaFSdMmtHchpsZRtND2fAupcfX2P6qdDyNNFEiM+rA3EwVMsCeIz6pigdemwQPFYxmvq0KpUalUvXMi1GdD0THUUA34ov+Sx2MEBhQ0fJhMnHIpi97nehYBERABERABEegeAhJM3bPXWmkTCDByQye6nyCYFnauNZz+1oSpvHAJzouRn63CihNNeViNN2MwHY9C6Xl8yVwUiQINSXnu9VHvA2mG+qBhCKbJvdqpo16xOedTHrKJ7ocjf0Dka8JXQq45K9RVREAEREAEREAEDkNAgukwlHSMCNQQKO0W7df1b+3ezn+RBrdd883Jv6T5Au3FmZrXaFpeK1fhapeQ+sfUt77wkK9ECaNr08l514NpEPPTEAEREAEREAER6E4CEkzdue9a9REI0BXu7vYvdnfnVzjTPT3ClZp/KlPkMhBxq7knMGQoIAZUbv5NmnRFpv6FgxEnlvphJ846Jn7mh8F50ABjLnnB3hn61KUK+mFemoMIiIAIiIAIiEDrCUgwtZ657tjmBChKFjP30MD2qj1K3/bVahhVKiJl0DWQRS1TAal5fo00hWAmwZqlgSj7LvW6mim/wGQNVz8iXnTIO9d/2eLO8MEvs9M8REAEREAEREAEWklAgqmVtHWvjiDAvkebqBW6jSjTzc2ffLcmzq+0W7C13FPYfW/5ps6qFlQAJhKxYNwZPbDXURBNa/00mCo4GpuGQ977NpM8K8MHP22O5iICIiACIiACLSYgwdRi4Lpd+xNgxIb9mG5vXbEr6/+ES1zFl4vaKW7YNuqZ2COJc/RLpCkAE4koejz1w+ihNzTorMv9BpCCjkLp7cFPnOEDrdU1REAEREAEREAEupOABFN37rtWfUQCFCA0ffh5/WvLlbJHsvE+4lReeXoZ5hRp1DNtIzUvi35JtAI/SdHkqpMglhhZYkPY/sjQXt3Sy41xX7molnzRAxEXtfnet+ztoU8g6vqdzXpLbq2biIAIiIAIiIAI+I6ABJPvtkQTahcCi5kFu7b5na1kF13dkP/mvetEUracQgphtaFtucLmskfrmdTIOmmiwLqgCHo6USj1hWHyAMMHGpb7bTAdj459Z/vftfP978HqPO63KWo+IiACIiACIiACLSQgwdRC2LpVZxGgfff9neuoZbpqGTSz9esow9XPsxvPID2PLn+tHhQhjCwNREeNTWr95Ii3nwXT76YT83Zu4LJNxE9hrpH9h+i9CIiACIiACIhAFxGQYOqizdZSm0uAzWFXs4/tR6TlbSGCw8ax/hyINEEk5VB3RcGUKe9YrphBnKk5jWdft2Y2vA0jvY0uc0kIJT6HYPDgx8iSt44I7M0vDHzoBBPT8VjPpCECIiACIiACItC9BCSYunfvtfIjEqBAorHCD2t/s+XMIytUcke84nGfvutsxjNobpsubcG4IodUQvRqOgbTCqbgBQMhmDvEEFFKWiLcjwhT0vfiI4AUwb7IIHovfWaney+5NXAtGiIgAiIgAiIgAt1LQIKpe/deK28CgRzMFOiWd2/nGqJMa0244vFegiKPzWxLrlfTJlIJU67+qgzRVEF/qaPUN3l1SkFEZEIUS8GEM0yIQTCFehBVQlqe30cY0a+Z5DlEmD5AOt6c36er+YmACIiACIiACLSAgARTCyDrFp1LoAQnupXMY7u29b0tpu+7NDe/r5aiiMKphOgSI0yMjOXKaZeyRye9asTJHfVCmqEnpp5FXOB4V/0xJ4aCFnQW4bFQwmKBhIVg6kABEkBN0LNzfA2nBymDCXsX0aXZ5HnXVNfX09XkREAEREAEREAEWkJAgqklmHWTTiVAEcHmsNc3f7AFGECwP5MnLNphzbuILLG+icKp+sjjfRFiqmhFPFcFFCJPEFjeuhgpYm0Sm82GIIZYk8QIUgi1PxRINHTgZ+1W+0Ozh4HIiH08+if0Xpp0a2iHPdQcRUAEREAEREAEjpeABNPx8tXVu4BAAeltD1I37S7c8tZyS06AtNuynRyCKKJ4omCiUGL0zIs4MZHv+UC8CKKJAoOpdxRNVfH0PO2uPSJKz1fEV72hAZtOzqP30qewFR988Uu9EwEREAEREAER6FoCEkxdu/VaeLMIlFH7s5lfgWD61e6nbrjUNkM8pj3HXhzJRZS4Ai+uVH1dXVOtHKJ44qf8rH3NEXqwiInYnF0c/NDVLqn3UnWn9a8IiIAIiIAIiAD+ykGqTbv+Zaf9EwGfENi1YrngxNKNrR9g/rB+LM5zPllsx02DQo+Rsvn+d+zD4a9c3yX2jdIQAREQAREQAREQARKQYNLvgQg0gQCNEtZyi3YHaXkPUrfawGK8CYvukEtQHI3Epuxs37t2rv8yaq8kljpka7UMERABERABEWgKAQmmpmDURbqdABPXcqWMPU7ftedRpnK3Y/H9+pmKF0GvqHN9l22+720bjo37fs6aoAiIgAiIgAiIQGsJSDC1lrfu1sEEKJrW88t2a+snJ5yypXQHr7YzlhYORGwoOm5vDX5s04l5OeN1xrZqFSIgAiIgAiLQVAISTE3FqYt1O4EcbMVXc49hM/69rWYX4TRX6nYkvl0/nf76w0N2pu8dO9V7wfoiQ21tXOFb0JqYCIiACIiACLQ5AQmmNt9ATd9fBFjLxCawt7au2IP0TdvKr/lrgprNHoEeiwZjNpU8bZcGPrLh6ISzSRceERABERABERABEdhPQIJpPxG9F4EjEmAvo3X0Y7qzA5txNLNlPyOZUR4RapNPD/YEUa80Yef737eZ5FmLBRNNvoMuJwIiIAIiIAIi0CkEJJg6ZSe1Dl8RKKHx68P0LVfPxLqmUqXoq/l182RoI94bHrA5pOGd738PrwfljNfNvxBauwiIgAiIgAi8gYAE0xsA6WsRaJRAurRtj1J37NeNf1umtNPoZXRekwkEe0J2uu+SXUB0iYYPoUC4yXfQ5URABERABERABDqJgARTJ+2m1uIrAkzN2yqsIcr0sz1JL1jaiSb1iT7JTQpY0MYT03YW/ZZmE+csHIwg3qS+Sye5J7q3CIiACIiACPidgAST33dI82trAsVK3payj1xD26XsQyuW8zAfl2g6iU1lZCkR6rWLAx/aTO8555B3EvPQPUVABERABERABNqLgARTe+2XZtuGBPKwGn+QumkLO9dcn6ZipdCGq2jvKbNBbW9owKbQa+ni4EfWDwvxgCJL7b2pmr0IiIAIiIAItIiABFOLQOs23UuAVuOp4pYzgXiQumGbsBpnup5GawjQ5CEWSrrGtJcglvrQe4kNazVEQAREQAREQARE4DAEJJgOQ0nHiMARCZR3y7ZTWLcFCKa7279atpRSat4RmR72dFqIzyTPoW7pXSea2LCWIkpDBERABERABERABA5DQILpMJR0jAgckQDrlsqwGl/PL0E0XYd73m3LosGt+jMdEewbTo8EozYam7Izfe/YRPyUq2F6wyn6WgREQAREQAREQAReICDB9AIOvRGB4yWQL+dss7Bid7Z+gRnEQ9iNK9J0XMSZdjcSm4RYetsmE6ctEew1Rpc0REAEREAEREAERKAeAhJM9dDSsSLQBAJsYkvRdGPzR5hB3DDWOMk3rwlgay7BlLuB6Agc8T5yDWrjwUTNt3opAiIgAiIgAiIgAocnIMF0eFY6UgSaQoBpeMXdgq3mntjD1C17nL5ruXLGCaem3KDLLxJGI9rR2LTNJS+4yFJvuN8CqGPSEAEREAEREAEREIFGCEgwNUJN54hAEwjQbnw9vwLRdNMWM/fR2HZLoumIXGnwMJk49UwsxdF3iZ9piIAIiIAIiIAIiECjBCSYGiWn80SgCQTYk2kzvwojiGv21ImmHWPKnkZ9BAKoTYoG4zYQGbVz/Z7BQ199F9HRIiACIiACIiACInAAAQmmA6DoIxFoFQEvPW+nsGFPMvcQaVqwrcKaFSp5OegdYhNYq8R0u2S4z8bjM3YaBg8D4WGLoWZJaXiHAKhDREAEREAEREAE3khAgumNiHSACBw3AViOo09TtpS2p9kHzghiJbuISFNBvZregD7UE7beSL/NJs+7xyAiTMFAkDLqDWfqaxEQAREQAREQARE4HAEJpsNx0lEicOwEGG3KlHdsFWLpSeauLWcfWwp1TerVdDD6ao+ladeMlj2W+sKDFoLhg4YIiIAIiIAIiIAINJOABFMzaepaInBEAmxwWyznbSO/DNG0ANH0yLaLG1bAZ7tWOeLVO+P0YE/IpeCxxxL7K03Gqg1p1WOpM/ZXqxABERABERABvxGQYPLbjmg+IrBHIFtOOSOIO9v/Rd+mVaOr3i56NnXr8OqVGEma7T1n86hX6g0NKKrUrb8QWrcIiIAIiIAItIiABFOLQOs2IlAvgQrqmvKVnG3n111t0yJMIRhtoosem912y6BQojV4PJS0MRg7TCfO2kh0wuJhWoaH8G1Pt6DQOkVABERABERABE6AgATTCUDXLUWgHgIUSDvFTaTpLdly7jEa3i5aqrCJBL3dei7TlsfSvCEajNlQdMy54LEhbX9kxGKBuPX0SCi15aZq0iIgAiIgAiLQZgQkmNpswzTd7iTA2iYKpw00ul2BaNourHdFTVNVMCVsFPVKo7EpRJl6FVHqzv8FtGoREAEREAERODECEkwnhl43FoH6CFA0lXdLVoZwog15twyKplAghPS7MHoryS68W/Zd6xQBERABERABvxCQYPLLTmgeIiACIiACIiACIiACIiACviMgweS7LdGEREAEREAEREAEREAEREAE/ELg/wd+1S8vF9qA0AAAAABJRU5ErkJggg==" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "#### Step 7. Running the Worker Agents\n", + "\n", + "At this point, we need to setup a concurrent workflow. While the order of adding tasks to the workflow doesn't matter (since they will all run concurrently late when executed), we can take some time to define an order for these tasks. This order will come in handy later when writing the report using our Writer Agent. \n", + "\n", + "The order we will follow is Breadth First Traversal (BFT) of the sub-queries in the graph we had made earlier (shown below again for reference). BFT makes sense to be used here because we want all the dependent parent questions to be answered before answering the child question. Also, since we could have independent subgraphs, we will also perform BFT separately on each subgraph. \n", + "\n", + "\n", + "![query-plan-mini.png](attachment:query-plan-mini.png)\n", + "\n", + "Below is the code that produces the order of processing sub-queries." + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BFS Order: ['1', '6', '10', '2', '3', '4', '5', '7', '8', '9']\n" + ] + } + ], + "source": [ + "from collections import deque, defaultdict\n", + "\n", + "# Define the graph nodes\n", + "nodes = json_object['sub_queries']\n", + "\n", + "# Create a graph from the nodes\n", + "graph = defaultdict(list)\n", + "for node in nodes:\n", + " for dependency in node['dependencies']:\n", + " graph[dependency].append(node['id'])\n", + "\n", + "# Find all nodes with no dependencies (potential starting points)\n", + "start_nodes = [node['id'] for node in nodes if not node['dependencies']]\n", + "\n", + "# Adjust the BFT function to handle dependencies correctly\n", + "def bft_corrected(start, graph, nodes_info):\n", + " visited = set()\n", + " queue = deque([start])\n", + " order = []\n", + " \n", + " while queue:\n", + " node = queue.popleft()\n", + " if node not in visited:\n", + " # Check if all dependencies of the current node are visited\n", + " node_dependencies = [n['id'] for n in nodes if n['id'] == node][0]\n", + " dependencies_met = all(dep in visited for dep in nodes_info[node_dependencies]['dependencies'])\n", + " \n", + " if dependencies_met:\n", + " visited.add(node)\n", + " order.append(node)\n", + " # Add only nodes to the queue whose dependencies are fully met\n", + " for next_node in graph[node]:\n", + " if all(dep in visited for dep in nodes_info[next_node]['dependencies']):\n", + " queue.append(next_node)\n", + " else:\n", + " # Requeue the node to check dependencies later\n", + " queue.append(node)\n", + " \n", + " return order\n", + "\n", + "# Dictionary to access node information quickly\n", + "nodes_info = {node['id']: node for node in nodes}\n", + "\n", + "# Perform BFt for each unvisited start node using the corrected BFS function\n", + "visited_global = set()\n", + "bfs_order = []\n", + "\n", + "for start in start_nodes:\n", + " if start not in visited_global:\n", + " order = bft_corrected(start, graph, nodes_info)\n", + " bfs_order.extend(order)\n", + " visited_global.update(order)\n", + "\n", + "print(\"BFS Order:\", bfs_order)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's define our `ConcurrentWorkflow` and run it." + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------\n", + "Added task: What is Nike's current revenue trend?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the potential areas of improvement in Nike's current business model?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the projected market trends for the sports apparel industry in 2024?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the current successful strategies being used by Nike's competitors?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the current and projected economic conditions in Nike's major markets?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the current consumer preferences in the sports apparel industry?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the potential new markets for Nike to explore in 2024?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the potential new products or services Nike could introduce in 2024?\n", + "-----------------\n", + "-----------------\n", + "Added task: What are the potential marketing strategies Nike could use to increase its revenue in Q3 2024?\n", + "-----------------\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 152, 'prompt_tokens': 1527, 'total_tokens': 1679}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='To answer these questions, we need to retrieve financial data for Nike and analyze it. We will use the `kay_retriever` tool to fetch the data and then analyze it to understand the revenue trend and potential areas of improvement.\\n\\nHere is the plan:\\n\\n1. Use `kay_retriever` to fetch Nike\\'s financial data.\\n2. Analyze the data to understand the revenue trend.\\n3. Identify potential areas of improvement in Nike\\'s business model.\\n\\nLet\\'s start with the first step.\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To understand Nike\\'s current revenue trend and potential areas of improvement, I need to fetch Nike\\'s financial data.\",\\n \"reasoning\": \"The kay_retriever tool allows me to fetch financial data, so I can look up Nike\\'s financial information.\", \\n \"plan\": \"Use the kay_retriever tool to fetch Nike\\'s financial data. Analyze the data to understand the revenue trend and potential areas of improvement.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike financial data\"\\n }\\n }\\n}\\n```\\n\\nAfter executing this command, we will have the financial data for Nike. We can then analyze this data to understand the revenue trend and potential areas of improvement.' response_metadata={'token_usage': {'completion_tokens': 275, 'prompt_tokens': 1543, 'total_tokens': 1818}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 152, 'prompt_tokens': 1527, 'total_tokens': 1679}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='Assistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the browser tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up analysis and reports on Nike\\'s current business model.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike business model analysis\\'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the browser tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up potential cost-saving strategies that Nike could implement.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike cost-saving strategies\\'. Parse the result to get the potential strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 459, 'prompt_tokens': 1567, 'total_tokens': 2026}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 152, 'prompt_tokens': 1527, 'total_tokens': 1679}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find out Nike's current revenue trend, I will use the financial data retriever tool to search for 'Nike revenue trend'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike revenue trend'. Parse the result to get the current revenue trend and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike revenue trend\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "-----------------\n", + "Document added successfully\n", + "-----------------\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='To answer these questions, we need to retrieve financial data for Nike and analyze it. We will use the `kay_retriever` tool to fetch the data and then analyze it to understand the revenue trend and potential areas of improvement.\\n\\nHere is the plan:\\n\\n1. Use `kay_retriever` to fetch Nike\\'s financial data.\\n2. Analyze the data to understand the revenue trend.\\n3. Identify potential areas of improvement in Nike\\'s business model.\\n\\nLet\\'s start with the first step.\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To understand Nike\\'s current revenue trend and potential areas of improvement, I need to fetch Nike\\'s financial data.\",\\n \"reasoning\": \"The kay_retriever tool allows me to fetch financial data, so I can look up Nike\\'s financial information.\", \\n \"plan\": \"Use the kay_retriever tool to fetch Nike\\'s financial data. Analyze the data to understand the revenue trend and potential areas of improvement.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike financial data\"\\n }\\n }\\n}\\n```\\n\\nAfter executing this command, we will analyze the data to understand the revenue trend and potential areas of improvement.' response_metadata={'token_usage': {'completion_tokens': 265, 'prompt_tokens': 1543, 'total_tokens': 1808}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='Assistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\nAssistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the financial data retriever tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and analysis, so I can look up potential areas of improvement in Nike\\'s current business model.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike business model analysis\\'. Parse the result to get the analysis and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\nAssistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the financial data retriever tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and strategies, so I can look up potential cost-saving strategies for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike cost-saving strategies\\'. Parse the result to get the strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```\\n\\nAssistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get the projected market trends for the sports apparel industry in 2024, I will use the financial data retriever tool to search for \\'2024 sports apparel industry market trends\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and market trends, so I can look up the projected market trends for the sports apparel industry in 2024.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'2024 sports apparel industry market trends\\'. Parse the result to get the projected market trends and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"2024 sports apparel industry market trends\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 677, 'prompt_tokens': 1585, 'total_tokens': 2262}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the current and projected economic conditions in Nike\\'s major markets, I will use the browser tool to search for \\'Nike major markets economic conditions\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up the current and projected economic conditions in Nike\\'s major markets.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike major markets economic conditions\\'. Parse the result to get the current and projected economic conditions and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike major markets economic conditions\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 157, 'prompt_tokens': 3282, 'total_tokens': 3439}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='Agent: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\nAgent: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the browser tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up analysis and critiques of Nike\\'s current business model.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike business model analysis\\'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\nAgent: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the browser tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up potential cost-saving strategies that Nike could implement.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike cost-saving strategies\\'. Parse the result to get the potential strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```\\n\\nAgent: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find the projected market trends for the sports apparel industry in 2024, I will use the browser tool to search for \\'2024 sports apparel industry market trends\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up projected market trends for the sports apparel industry in 2024.\", \\n \"plan\": \"Use the browser tool to search Google for \\'2024 sports apparel industry market trends\\'. Parse the result to get the projected trends and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"2024 sports apparel industry market trends\"\\n }\\n }\\n}\\n```\\n\\nAgent: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find the current successful strategies being used by Nike\\'s competitors, I will use the browser tool to search for \\'Nike competitors successful strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up the successful strategies being used by Nike\\'s competitors.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike competitors successful strategies\\'. Parse the result to get the strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike competitors successful strategies\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 781, 'prompt_tokens': 1600, 'total_tokens': 2381}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the current and projected economic conditions in Nike\\'s major markets, I will use the browser tool to search for \\'Nike major markets economic conditions\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up the current and projected economic conditions in Nike\\'s major markets.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike major markets economic conditions\\'. Parse the result to get the current and projected economic conditions and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike major markets economic conditions\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 157, 'prompt_tokens': 3282, 'total_tokens': 3439}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='To answer these questions, we need to retrieve financial data for Nike and analyze it. We will use the `kay_retriever` tool to fetch the data and then analyze it to understand the revenue trend and potential areas of improvement.\\n\\nHere is the plan:\\n\\n1. Use `kay_retriever` to fetch Nike\\'s financial data.\\n2. Analyze the data to understand the revenue trend.\\n3. Identify potential areas of improvement in Nike\\'s business model.\\n\\nLet\\'s start with the first step.\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To understand Nike\\'s current revenue trend, I need to fetch its financial data.\",\\n \"reasoning\": \"The kay_retriever tool allows me to fetch financial data, so I can look up Nike\\'s financial information.\", \\n \"plan\": \"Use the kay_retriever tool to fetch Nike\\'s financial data. Analyze the data to understand the revenue trend and potential areas of improvement.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike financial data\"\\n }\\n }\\n}\\n```\\n\\nAfter executing this command, we will analyze the data to understand the revenue trend and potential areas of improvement.' response_metadata={'token_usage': {'completion_tokens': 259, 'prompt_tokens': 1543, 'total_tokens': 1802}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "To answer these questions, we need to retrieve financial data for Nike and analyze it. We will use the `kay_retriever` tool to fetch the data and then analyze it to understand the revenue trend and potential areas of improvement.\n", + "\n", + "Here is the plan:\n", + "\n", + "1. Use `kay_retriever` to fetch Nike's financial data.\n", + "2. Analyze the data to understand the revenue trend.\n", + "3. Identify potential areas of improvement in Nike's business model.\n", + "\n", + "Let's start with the first step.\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To understand Nike's current revenue trend, I need to fetch its financial data.\",\n", + " \"reasoning\": \"The kay_retriever tool allows me to fetch financial data, so I can look up Nike's financial information.\", \n", + " \"plan\": \"Use the kay_retriever tool to fetch Nike's financial data. Analyze the data to understand the revenue trend and potential areas of improvement.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike financial data\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "After executing this command, we will analyze the data to understand the revenue trend and potential areas of improvement.\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "\u001b[33mInitializing Autonomous Agent Worker Agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of auto\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the current and projected economic conditions in Nike\\'s major markets, I will use the browser tool to search for \\'Nike major markets economic conditions\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up the current and projected economic conditions in Nike\\'s major markets.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike major markets economic conditions\\'. Parse the result to get the current and projected economic conditions and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike major markets economic conditions\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 157, 'prompt_tokens': 3282, 'total_tokens': 3439}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find out the current and projected economic conditions in Nike's major markets, I will use the browser tool to search for 'Nike major markets economic conditions'.\",\n", + " \"reasoning\": \"The browser tool allows me to search the web, so I can look up the current and projected economic conditions in Nike's major markets.\", \n", + " \"plan\": \"Use the browser tool to search Google for 'Nike major markets economic conditions'. Parse the result to get the current and projected economic conditions and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"browser\", \n", + " \"args\": {\n", + " \"query\": \"Nike major markets economic conditions\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "content='Assistant:: \\nTo answer these questions, I will use the KayRetriever tool to fetch the financial data related to Nike\\'s current revenue trend, areas of improvement in its business model, and potential cost-saving strategies. \\n\\nHere are the commands I will execute:\\n\\n1. Fetch Nike\\'s current revenue trend:\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To fetch Nike\\'s current revenue trend, I will use the KayRetriever tool.\",\\n \"reasoning\": \"The KayRetriever tool allows me to fetch financial data, so I can look up the current revenue trend of Nike.\", \\n \"plan\": \"Use the KayRetriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n2. Fetch potential areas of improvement in Nike\\'s current business model:\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To fetch potential areas of improvement in Nike\\'s current business model, I will use the KayRetriever tool.\",\\n \"reasoning\": \"The KayRetriever tool allows me to fetch financial data, so I can look up the potential areas of improvement in Nike\\'s current business model.\", \\n \"plan\": \"Use the KayRetriever tool to search for \\'Nike business model improvement areas\\'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike business model improvement areas\"\\n }\\n }\\n}\\n```\\n\\n3. Fetch potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024:\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To fetch potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the KayRetriever tool.\",\\n \"reasoning\": \"The KayRetriever tool allows me to fetch financial data, so I can look up the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024.\", \\n \"plan\": \"Use the KayRetriever tool to search for \\'Nike cost-saving strategies for Q3 2024\\'. Parse the result to get the potential cost-saving strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies for Q3 2024\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 579, 'prompt_tokens': 1567, 'total_tokens': 2146}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the browser tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up analysis and reports on Nike\\'s current business model.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike business model analysis\\'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the browser tool to search for \\'cost-saving strategies for sports apparel companies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up potential cost-saving strategies for companies in the sports apparel industry.\", \\n \"plan\": \"Use the browser tool to search Google for \\'cost-saving strategies for sports apparel companies\\'. Parse the result to get the potential strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"cost-saving strategies for sports apparel companies\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get the projected market trends for the sports apparel industry in 2024, I will use the financial data retriever tool to search for \\'2024 sports apparel industry market trends\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the projected market trends for the sports apparel industry in 2024.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'2024 sports apparel industry market trends\\'. Parse the result to get the projected trends and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"2024 sports apparel industry market trends\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 646, 'prompt_tokens': 1585, 'total_tokens': 2231}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='Assistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the potential areas of improvement in Nike\\'s current business model, I will use the browser tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up analysis and reports on Nike\\'s current business model.\", \\n \"plan\": \"Use the browser tool to search for \\'Nike business model analysis\\'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the browser tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up potential cost-saving strategies for Nike.\", \\n \"plan\": \"Use the browser tool to search for \\'Nike cost-saving strategies\\'. Parse the result to get the potential strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the projected market trends for the sports apparel industry in 2024, I will use the browser tool to search for \\'sports apparel industry market trends 2024\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up projected market trends for the sports apparel industry in 2024.\", \\n \"plan\": \"Use the browser tool to search for \\'sports apparel industry market trends 2024\\'. Parse the result to get the projected trends and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"sports apparel industry market trends 2024\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find out the current successful strategies being used by Nike\\'s competitors, I will use the browser tool to search for \\'Nike competitors successful strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up successful strategies being used by Nike\\'s competitors.\", \\n \"plan\": \"Use the browser tool to search for \\'Nike competitors successful strategies\\'. Parse the result to get the strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike competitors successful strategies\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 772, 'prompt_tokens': 1600, 'total_tokens': 2372}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "content='Assistant:: \\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the financial data retriever tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and analysis, so I can look up the analysis of Nike\\'s current business model.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike business model analysis\\'. Parse the result to get the analysis and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the financial data retriever tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and strategies, so I can look up potential cost-saving strategies for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike cost-saving strategies\\'. Parse the result to get the strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 483, 'prompt_tokens': 1567, 'total_tokens': 2050}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "Assistant:: \n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To get Nike's current revenue trend, I will use the financial data retriever tool to search for 'Nike revenue trend'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike revenue trend'. Parse the result to get the current trend and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike revenue trend\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find potential areas of improvement in Nike's current business model, I will use the financial data retriever tool to search for 'Nike business model analysis'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and analysis, so I can look up the analysis of Nike's current business model.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike business model analysis'. Parse the result to get the analysis and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike business model analysis\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the financial data retriever tool to search for 'Nike cost-saving strategies'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and strategies, so I can look up potential cost-saving strategies for Nike.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike cost-saving strategies'. Parse the result to get the strategies and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike cost-saving strategies\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the financial data retriever tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and analysis, so I can look up potential areas of improvement in Nike\\'s current business model.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike business model analysis\\'. Parse the result to get the analysis and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the financial data retriever tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and strategies, so I can look up potential cost-saving strategies for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike cost-saving strategies\\'. Parse the result to get the strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To get the projected market trends for the sports apparel industry in 2024, I will use the financial data retriever tool to search for \\'2024 sports apparel industry market trends\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and market trends, so I can look up the projected market trends for the sports apparel industry in 2024.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'2024 sports apparel industry market trends\\'. Parse the result to get the projected market trends and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"2024 sports apparel industry market trends\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 665, 'prompt_tokens': 1585, 'total_tokens': 2250}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To get Nike's current revenue trend, I will use the financial data retriever tool to search for 'Nike revenue trend'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike revenue trend'. Parse the result to get the current revenue trend and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike revenue trend\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find potential areas of improvement in Nike's current business model, I will use the financial data retriever tool to search for 'Nike business model analysis'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and analysis, so I can look up potential areas of improvement in Nike's current business model.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike business model analysis'. Parse the result to get the analysis and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike business model analysis\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the financial data retriever tool to search for 'Nike cost-saving strategies'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and strategies, so I can look up potential cost-saving strategies for Nike.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike cost-saving strategies'. Parse the result to get the strategies and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike cost-saving strategies\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To get the projected market trends for the sports apparel industry in 2024, I will use the financial data retriever tool to search for '2024 sports apparel industry market trends'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data and market trends, so I can look up the projected market trends for the sports apparel industry in 2024.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for '2024 sports apparel industry market trends'. Parse the result to get the projected market trends and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"2024 sports apparel industry market trends\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "content='```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find Nike\\'s current revenue trend, I will use the financial data retriever tool to search for \\'Nike revenue trend\\'.\",\\n \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \\n \"plan\": \"Use the financial data retriever tool to search for \\'Nike revenue trend\\'. Parse the result to get the current revenue trend and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"kay_retriever\", \\n \"args\": {\\n \"query\": \"Nike revenue trend\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential areas of improvement in Nike\\'s current business model, I will use the browser tool to search for \\'Nike business model analysis\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up analysis and reports on Nike\\'s current business model.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike business model analysis\\'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike business model analysis\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the browser tool to search for \\'Nike cost-saving strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up potential cost-saving strategies for Nike.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike cost-saving strategies\\'. Parse the result to get the potential strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike cost-saving strategies\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find the projected market trends for the sports apparel industry in 2024, I will use the browser tool to search for \\'sports apparel industry market trends 2024\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up projected market trends for the sports apparel industry in 2024.\", \\n \"plan\": \"Use the browser tool to search Google for \\'sports apparel industry market trends 2024\\'. Parse the result to get the projected trends and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"sports apparel industry market trends 2024\"\\n }\\n }\\n}\\n```\\n\\n```json\\n{\\n \"thoughts\": {\\n \"text\": \"To find the current successful strategies being used by Nike\\'s competitors, I will use the browser tool to search for \\'Nike competitors successful strategies\\'.\",\\n \"reasoning\": \"The browser tool allows me to search the web, so I can look up successful strategies being used by Nike\\'s competitors.\", \\n \"plan\": \"Use the browser tool to search Google for \\'Nike competitors successful strategies\\'. Parse the result to get the strategies and format that into a readable report.\"\\n },\\n \"command\": {\\n \"name\": \"browser\", \\n \"args\": {\\n \"query\": \"Nike competitors successful strategies\"\\n }\\n }\\n}\\n```' response_metadata={'token_usage': {'completion_tokens': 766, 'prompt_tokens': 1600, 'total_tokens': 2366}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Worker Agent_state.json\u001b[0m\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find Nike's current revenue trend, I will use the financial data retriever tool to search for 'Nike revenue trend'.\",\n", + " \"reasoning\": \"The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend for Nike.\", \n", + " \"plan\": \"Use the financial data retriever tool to search for 'Nike revenue trend'. Parse the result to get the current revenue trend and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"kay_retriever\", \n", + " \"args\": {\n", + " \"query\": \"Nike revenue trend\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find potential areas of improvement in Nike's current business model, I will use the browser tool to search for 'Nike business model analysis'.\",\n", + " \"reasoning\": \"The browser tool allows me to search the web, so I can look up analysis and reports on Nike's current business model.\", \n", + " \"plan\": \"Use the browser tool to search Google for 'Nike business model analysis'. Parse the result to get the potential areas of improvement and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"browser\", \n", + " \"args\": {\n", + " \"query\": \"Nike business model analysis\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024, I will use the browser tool to search for 'Nike cost-saving strategies'.\",\n", + " \"reasoning\": \"The browser tool allows me to search the web, so I can look up potential cost-saving strategies for Nike.\", \n", + " \"plan\": \"Use the browser tool to search Google for 'Nike cost-saving strategies'. Parse the result to get the potential strategies and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"browser\", \n", + " \"args\": {\n", + " \"query\": \"Nike cost-saving strategies\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find the projected market trends for the sports apparel industry in 2024, I will use the browser tool to search for 'sports apparel industry market trends 2024'.\",\n", + " \"reasoning\": \"The browser tool allows me to search the web, so I can look up projected market trends for the sports apparel industry in 2024.\", \n", + " \"plan\": \"Use the browser tool to search Google for 'sports apparel industry market trends 2024'. Parse the result to get the projected trends and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"browser\", \n", + " \"args\": {\n", + " \"query\": \"sports apparel industry market trends 2024\"\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "```json\n", + "{\n", + " \"thoughts\": {\n", + " \"text\": \"To find the current successful strategies being used by Nike's competitors, I will use the browser tool to search for 'Nike competitors successful strategies'.\",\n", + " \"reasoning\": \"The browser tool allows me to search the web, so I can look up successful strategies being used by Nike's competitors.\", \n", + " \"plan\": \"Use the browser tool to search Google for 'Nike competitors successful strategies'. Parse the result to get the strategies and format that into a readable report.\"\n", + " },\n", + " \"command\": {\n", + " \"name\": \"browser\", \n", + " \"args\": {\n", + " \"query\": \"Nike competitors successful strategies\"\n", + " }\n", + " }\n", + "}\n", + "```\n" + ] + } + ], + "source": [ + "import os\n", + "from dotenv import load_dotenv\n", + "from swarms import Agent, ConcurrentWorkflow, OpenAIChat, Task\n", + "\n", + "# Create a workflow\n", + "workflow = ConcurrentWorkflow(max_workers=5)\n", + "task_list = []\n", + "\n", + "for node in bfs_order:\n", + " sub_query =nodes_info[node]['query']\n", + " task = Task(worker_agent, sub_query)\n", + " print('-----------------')\n", + " print(\"Added task: \", sub_query)\n", + " print('-----------------')\n", + " task_list.append(task)\n", + "\n", + "workflow.add(tasks=task_list)\n", + "\n", + "# Run the workflow\n", + "workflow.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above output this workflow produces, we clearly see the thought process of the agent and the plan it came up to solve a particular sub-query. In addition, we see the tool-calling schema it produces in `\"command\"`. Here, `\"name\"` pertains to the name of the tool to be called and `\"args\"` is the arguments to be passed to the tool call. Like mentioned before, we modify `Agent`'s default behaviour in `WorkerAgent`. Hence, the tool call is executed here and its results (information from web pages and Kay Retriever API) are added to long-term memory. We get confirmation for this from the message `Document added successfully`. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Step 7. Generating the report using Writer Agent\n", + "\n", + "At this point, our Worker Agents have gathered all the background information required to generate the report. We have also defined a coherent structure to write the report, which is following the BFT order to answering the sub-queries. Now it's time to define a Writer Agent and call it sequentially in the order of sub-queries. " + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": {}, + "outputs": [], + "source": [ + "from swarms import Agent, OpenAIChat, tool\n", + "\n", + "agent = Agent(\n", + " agent_name=\"Writer Agent\",\n", + " agent_description=(\n", + " \"This agent writes reports based on information in long-term memory\"\n", + " ),\n", + " system_prompt=(\n", + " \"You are a world-class financial report writer. \" \n", + " \"Write analytical and accurate responses using memory to answer the query. \"\n", + " \"Do not mention use of long-term memory in the report. \"\n", + " \"Do not mention Writer Agent in response.\"\n", + " \"Return only response content in strict markdown format.\"\n", + " ),\n", + " llm=OpenAIChat(temperature=0.2, model='gpt-3.5-turbo'),\n", + " max_loops=1,\n", + " autosave=True,\n", + " verbose=True,\n", + " long_term_memory=memory,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The report individual sections of the report will be collected in a list." + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "metadata": {}, + "outputs": [], + "source": [ + "report = []" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us now run the writer agent." + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running task: What is Nike's current revenue trend?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content=\"### Nike's Current Revenue Trend\\n\\nNike's current revenue trend has been steadily increasing over the past few years. In the most recent fiscal year, Nike reported a revenue of $37.4 billion, which was a 7% increase from the previous year. This growth can be attributed to strong sales in key markets, successful marketing campaigns, and a focus on innovation in product development. Overall, Nike continues to demonstrate strong financial performance and is well-positioned for future growth.\" response_metadata={'token_usage': {'completion_tokens': 95, 'prompt_tokens': 89, 'total_tokens': 184}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content=\"### Nike's Current Revenue Trend\\n\\nNike's current revenue trend has been steadily increasing over the past few years. In the most recent fiscal year, Nike reported a revenue of $37.4 billion, which was a 7% increase from the previous year. This growth can be attributed to strong sales in key markets, successful marketing campaigns, and a focus on innovation in product development. Overall, Nike continues to demonstrate strong financial performance and is well-positioned for future growth.\" response_metadata={'token_usage': {'completion_tokens': 95, 'prompt_tokens': 89, 'total_tokens': 184}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the potential areas of improvement in Nike's current business model?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content=\"### Potential Areas of Improvement in Nike's Business Model\\n\\n1. **Sustainability Practices**: Nike could further enhance its sustainability efforts by reducing its carbon footprint, using more eco-friendly materials, and ensuring ethical labor practices throughout its supply chain.\\n\\n2. **Diversification of Product Portfolio**: While Nike is known for its athletic footwear and apparel, diversifying into new product categories or expanding into untapped markets could help drive growth and mitigate risks associated with a single product line.\\n\\n3. **E-commerce Strategy**: Improving the online shopping experience, investing in digital marketing, and leveraging data analytics to personalize customer interactions could boost online sales and customer loyalty.\\n\\n4. **Innovation and R&D**: Continuously investing in research and development to stay ahead of competitors, introduce new technologies, and enhance product performance could help maintain Nike's competitive edge in the market.\\n\\n5. **Brand Image and Reputation**: Strengthening brand image through effective marketing campaigns, community engagement, and transparent communication with stakeholders can help build trust and loyalty among consumers.\" response_metadata={'token_usage': {'completion_tokens': 205, 'prompt_tokens': 298, 'total_tokens': 503}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content=\"### Potential Areas of Improvement in Nike's Business Model\\n\\n1. **Sustainability Practices**: Nike could further enhance its sustainability efforts by reducing its carbon footprint, using more eco-friendly materials, and ensuring ethical labor practices throughout its supply chain.\\n\\n2. **Diversification of Product Portfolio**: While Nike is known for its athletic footwear and apparel, diversifying into new product categories or expanding into untapped markets could help drive growth and mitigate risks associated with a single product line.\\n\\n3. **E-commerce Strategy**: Improving the online shopping experience, investing in digital marketing, and leveraging data analytics to personalize customer interactions could boost online sales and customer loyalty.\\n\\n4. **Innovation and R&D**: Continuously investing in research and development to stay ahead of competitors, introduce new technologies, and enhance product performance could help maintain Nike's competitive edge in the market.\\n\\n5. **Brand Image and Reputation**: Strengthening brand image through effective marketing campaigns, community engagement, and transparent communication with stakeholders can help build trust and loyalty among consumers.\" response_metadata={'token_usage': {'completion_tokens': 205, 'prompt_tokens': 298, 'total_tokens': 503}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='### Potential Cost-Saving Strategies for Nike to Increase Net Revenue in Q3 2024\\n\\n1. **Supply Chain Optimization**: Streamlining the supply chain, reducing transportation costs, and improving inventory management can lead to significant cost savings for Nike.\\n\\n2. **Operational Efficiency**: Implementing lean manufacturing practices, reducing waste, and optimizing production processes can help lower production costs and improve overall efficiency.\\n\\n3. **Outsourcing Non-Core Functions**: Outsourcing non-core functions such as IT services, customer support, or logistics can help reduce overhead costs and focus resources on core business activities.\\n\\n4. **Energy Efficiency**: Investing in energy-efficient technologies, renewable energy sources, and sustainable practices can lower utility costs and demonstrate a commitment to environmental responsibility.\\n\\n5. **Negotiating Supplier Contracts**: Negotiating better terms with suppliers, leveraging economies of scale, and exploring alternative sourcing options can help lower procurement costs and improve margins.\\n\\nBy implementing these cost-saving strategies, Nike can improve its bottom line and increase net revenue in Q3 2024.' response_metadata={'token_usage': {'completion_tokens': 207, 'prompt_tokens': 633, 'total_tokens': 840}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_a450710239', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content='### Potential Cost-Saving Strategies for Nike to Increase Net Revenue in Q3 2024\\n\\n1. **Supply Chain Optimization**: Streamlining the supply chain, reducing transportation costs, and improving inventory management can lead to significant cost savings for Nike.\\n\\n2. **Operational Efficiency**: Implementing lean manufacturing practices, reducing waste, and optimizing production processes can help lower production costs and improve overall efficiency.\\n\\n3. **Outsourcing Non-Core Functions**: Outsourcing non-core functions such as IT services, customer support, or logistics can help reduce overhead costs and focus resources on core business activities.\\n\\n4. **Energy Efficiency**: Investing in energy-efficient technologies, renewable energy sources, and sustainable practices can lower utility costs and demonstrate a commitment to environmental responsibility.\\n\\n5. **Negotiating Supplier Contracts**: Negotiating better terms with suppliers, leveraging economies of scale, and exploring alternative sourcing options can help lower procurement costs and improve margins.\\n\\nBy implementing these cost-saving strategies, Nike can improve its bottom line and increase net revenue in Q3 2024.' response_metadata={'token_usage': {'completion_tokens': 207, 'prompt_tokens': 633, 'total_tokens': 840}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_a450710239', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the projected market trends for the sports apparel industry in 2024?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='### Projected Market Trends for the Sports Apparel Industry in 2024\\n\\n1. **Sustainable Fashion**: Consumers are increasingly demanding eco-friendly and sustainable products, leading to a rise in sustainable sportswear options in the market.\\n\\n2. **Digital Transformation**: The sports apparel industry is expected to continue its shift towards digital platforms, with a focus on e-commerce, personalized shopping experiences, and digital marketing strategies.\\n\\n3. **Athleisure Wear**: The trend of athleisure wear, which combines athletic and leisure clothing, is projected to remain popular in 2024 as consumers seek comfort and versatility in their apparel choices.\\n\\n4. **Innovative Materials**: Advances in technology and material science are likely to drive the development of innovative fabrics and performance-enhancing materials in sports apparel, catering to the demand for high-quality and functional products.\\n\\n5. **Health and Wellness Focus**: With a growing emphasis on health and wellness, sports apparel brands are expected to incorporate features that promote comfort, performance, and overall well-being in their products.\\n\\nOverall, the sports apparel industry in 2024 is anticipated to be characterized by sustainability, digitalization, innovation, and a focus on consumer health and lifestyle trends.' response_metadata={'token_usage': {'completion_tokens': 240, 'prompt_tokens': 963, 'total_tokens': 1203}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content='### Projected Market Trends for the Sports Apparel Industry in 2024\\n\\n1. **Sustainable Fashion**: Consumers are increasingly demanding eco-friendly and sustainable products, leading to a rise in sustainable sportswear options in the market.\\n\\n2. **Digital Transformation**: The sports apparel industry is expected to continue its shift towards digital platforms, with a focus on e-commerce, personalized shopping experiences, and digital marketing strategies.\\n\\n3. **Athleisure Wear**: The trend of athleisure wear, which combines athletic and leisure clothing, is projected to remain popular in 2024 as consumers seek comfort and versatility in their apparel choices.\\n\\n4. **Innovative Materials**: Advances in technology and material science are likely to drive the development of innovative fabrics and performance-enhancing materials in sports apparel, catering to the demand for high-quality and functional products.\\n\\n5. **Health and Wellness Focus**: With a growing emphasis on health and wellness, sports apparel brands are expected to incorporate features that promote comfort, performance, and overall well-being in their products.\\n\\nOverall, the sports apparel industry in 2024 is anticipated to be characterized by sustainability, digitalization, innovation, and a focus on consumer health and lifestyle trends.' response_metadata={'token_usage': {'completion_tokens': 240, 'prompt_tokens': 963, 'total_tokens': 1203}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the current successful strategies being used by Nike's competitors?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content=\"### Current Successful Strategies Used by Nike's Competitors\\n\\n1. **Adidas**: Adidas has been successful in leveraging collaborations with celebrities and designers to create limited-edition collections that generate hype and drive sales. They have also focused on sustainability initiatives, such as using recycled materials in their products, to appeal to environmentally conscious consumers.\\n\\n2. **Under Armour**: Under Armour has differentiated itself by targeting performance-driven athletes and emphasizing technological innovation in their products. They have also invested heavily in digital marketing and e-commerce to reach a wider audience and enhance the customer shopping experience.\\n\\n3. **Puma**: Puma has successfully capitalized on the athleisure trend by offering stylish and versatile sportswear that can be worn both in and out of the gym. They have also focused on building partnerships with influencers and sponsoring high-profile athletes to increase brand visibility and credibility.\\n\\n4. **Lululemon**: Lululemon has excelled in creating a strong community around its brand, hosting events, classes, and collaborations to engage with customers beyond just selling products. They have also prioritized customer experience by offering personalized services and creating a seamless omnichannel shopping experience.\\n\\n5. **New Balance**: New Balance has carved out a niche in the market by emphasizing quality craftsmanship, heritage, and authenticity in their products. They have also focused on customization and personalization options for customers, allowing them to create unique and tailored footwear and apparel.\\n\\nOverall, Nike's competitors have found success through a combination of innovative product offerings, strategic marketing initiatives, and a focus on customer engagement and experience.\" response_metadata={'token_usage': {'completion_tokens': 313, 'prompt_tokens': 1327, 'total_tokens': 1640}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_a450710239', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content=\"### Current Successful Strategies Used by Nike's Competitors\\n\\n1. **Adidas**: Adidas has been successful in leveraging collaborations with celebrities and designers to create limited-edition collections that generate hype and drive sales. They have also focused on sustainability initiatives, such as using recycled materials in their products, to appeal to environmentally conscious consumers.\\n\\n2. **Under Armour**: Under Armour has differentiated itself by targeting performance-driven athletes and emphasizing technological innovation in their products. They have also invested heavily in digital marketing and e-commerce to reach a wider audience and enhance the customer shopping experience.\\n\\n3. **Puma**: Puma has successfully capitalized on the athleisure trend by offering stylish and versatile sportswear that can be worn both in and out of the gym. They have also focused on building partnerships with influencers and sponsoring high-profile athletes to increase brand visibility and credibility.\\n\\n4. **Lululemon**: Lululemon has excelled in creating a strong community around its brand, hosting events, classes, and collaborations to engage with customers beyond just selling products. They have also prioritized customer experience by offering personalized services and creating a seamless omnichannel shopping experience.\\n\\n5. **New Balance**: New Balance has carved out a niche in the market by emphasizing quality craftsmanship, heritage, and authenticity in their products. They have also focused on customization and personalization options for customers, allowing them to create unique and tailored footwear and apparel.\\n\\nOverall, Nike's competitors have found success through a combination of innovative product offerings, strategic marketing initiatives, and a focus on customer engagement and experience.\" response_metadata={'token_usage': {'completion_tokens': 313, 'prompt_tokens': 1327, 'total_tokens': 1640}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_a450710239', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the current and projected economic conditions in Nike's major markets?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='Writer agent: content=\"### Current and Projected Economic Conditions in Nike\\'s Major Markets\\\\n\\\\n1. **United States**: The United States, being one of Nike\\'s largest markets, is currently experiencing moderate economic growth driven by consumer spending, low unemployment rates, and a rebound in manufacturing. However, uncertainties surrounding trade policies, inflation, and interest rates could impact consumer confidence and spending in the near future.\\\\n\\\\n2. **China**: China remains a key market for Nike, with a growing middle class and increasing demand for sportswear and athletic footwear. Despite recent trade tensions with the U.S., China\\'s economy is projected to continue expanding, driven by domestic consumption, infrastructure investments, and technological advancements.\\\\n\\\\n3. **Europe**: Economic conditions in Europe vary across countries, with some experiencing sluggish growth due to Brexit uncertainties, political instability, and trade tensions. However, overall consumer confidence is improving, and the sports apparel market is expected to grow, driven by e-commerce and sustainability trends.\\\\n\\\\n4. **Emerging Markets**: Nike\\'s presence in emerging markets such as India, Brazil, and Southeast Asia provides opportunities for growth, given the rising disposable incomes, urbanization, and increasing focus on health and fitness. However, challenges such as currency fluctuations, regulatory changes, and competition from local brands could impact Nike\\'s performance in these markets.\\\\n\\\\nOverall, Nike\\'s major markets exhibit a mix of opportunities and challenges, with economic conditions influenced by global trends, geopolitical factors, and consumer preferences.\" response_metadata={\\'token_usage\\': {\\'completion_tokens\\': 287, \\'prompt_tokens\\': 1184, \\'total_tokens\\': 1471}, \\'model_name\\': \\'gpt-3.5-turbo\\', \\'system_fingerprint\\': \\'fp_a450710239\\', \\'finish_reason\\': \\'stop\\', \\'logprobs\\': None}' response_metadata={'token_usage': {'completion_tokens': 372, 'prompt_tokens': 1763, 'total_tokens': 2135}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content='Writer agent: content=\"### Current and Projected Economic Conditions in Nike\\'s Major Markets\\\\n\\\\n1. **United States**: The United States, being one of Nike\\'s largest markets, is currently experiencing moderate economic growth driven by consumer spending, low unemployment rates, and a rebound in manufacturing. However, uncertainties surrounding trade policies, inflation, and interest rates could impact consumer confidence and spending in the near future.\\\\n\\\\n2. **China**: China remains a key market for Nike, with a growing middle class and increasing demand for sportswear and athletic footwear. Despite recent trade tensions with the U.S., China\\'s economy is projected to continue expanding, driven by domestic consumption, infrastructure investments, and technological advancements.\\\\n\\\\n3. **Europe**: Economic conditions in Europe vary across countries, with some experiencing sluggish growth due to Brexit uncertainties, political instability, and trade tensions. However, overall consumer confidence is improving, and the sports apparel market is expected to grow, driven by e-commerce and sustainability trends.\\\\n\\\\n4. **Emerging Markets**: Nike\\'s presence in emerging markets such as India, Brazil, and Southeast Asia provides opportunities for growth, given the rising disposable incomes, urbanization, and increasing focus on health and fitness. However, challenges such as currency fluctuations, regulatory changes, and competition from local brands could impact Nike\\'s performance in these markets.\\\\n\\\\nOverall, Nike\\'s major markets exhibit a mix of opportunities and challenges, with economic conditions influenced by global trends, geopolitical factors, and consumer preferences.\" response_metadata={\\'token_usage\\': {\\'completion_tokens\\': 287, \\'prompt_tokens\\': 1184, \\'total_tokens\\': 1471}, \\'model_name\\': \\'gpt-3.5-turbo\\', \\'system_fingerprint\\': \\'fp_a450710239\\', \\'finish_reason\\': \\'stop\\', \\'logprobs\\': None}' response_metadata={'token_usage': {'completion_tokens': 372, 'prompt_tokens': 1763, 'total_tokens': 2135}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the current consumer preferences in the sports apparel industry?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='### Current Consumer Preferences in the Sports Apparel Industry\\n\\n1. **Sustainability**: Consumers are increasingly seeking eco-friendly and sustainable options in sports apparel, driving brands to focus on using recycled materials, reducing waste, and promoting ethical practices.\\n\\n2. **Athleisure**: The trend of athleisure wear continues to be popular, with consumers looking for versatile and comfortable clothing that can be worn both during workouts and in everyday life.\\n\\n3. **Performance and Functionality**: Consumers prioritize performance-enhancing features in sports apparel, such as moisture-wicking fabrics, breathable materials, and ergonomic designs that enhance comfort and mobility.\\n\\n4. **Personalization**: Customization options, personalized fit, and unique design elements are appealing to consumers who seek individuality and exclusivity in their sports apparel choices.\\n\\n5. **Brand Transparency**: Consumers value transparency in brand practices, including supply chain transparency, ethical sourcing, and clear communication on product quality and manufacturing processes.\\n\\nOverall, consumer preferences in the sports apparel industry are shifting towards sustainability, versatility, performance, personalization, and transparency, influencing brand strategies and product offerings.' response_metadata={'token_usage': {'completion_tokens': 218, 'prompt_tokens': 2274, 'total_tokens': 2492}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content='### Current Consumer Preferences in the Sports Apparel Industry\\n\\n1. **Sustainability**: Consumers are increasingly seeking eco-friendly and sustainable options in sports apparel, driving brands to focus on using recycled materials, reducing waste, and promoting ethical practices.\\n\\n2. **Athleisure**: The trend of athleisure wear continues to be popular, with consumers looking for versatile and comfortable clothing that can be worn both during workouts and in everyday life.\\n\\n3. **Performance and Functionality**: Consumers prioritize performance-enhancing features in sports apparel, such as moisture-wicking fabrics, breathable materials, and ergonomic designs that enhance comfort and mobility.\\n\\n4. **Personalization**: Customization options, personalized fit, and unique design elements are appealing to consumers who seek individuality and exclusivity in their sports apparel choices.\\n\\n5. **Brand Transparency**: Consumers value transparency in brand practices, including supply chain transparency, ethical sourcing, and clear communication on product quality and manufacturing processes.\\n\\nOverall, consumer preferences in the sports apparel industry are shifting towards sustainability, versatility, performance, personalization, and transparency, influencing brand strategies and product offerings.' response_metadata={'token_usage': {'completion_tokens': 218, 'prompt_tokens': 2274, 'total_tokens': 2492}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the potential new markets for Nike to explore in 2024?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content=\"### Potential New Markets for Nike to Explore in 2024\\n\\n1. **India**: With a growing population, increasing disposable incomes, and a rising interest in health and fitness, India presents a significant opportunity for Nike to expand its presence and tap into a large consumer base.\\n\\n2. **Africa**: The African market, particularly countries with emerging economies and a young population, offers potential for Nike to introduce its products and capitalize on the growing demand for sportswear and athletic footwear.\\n\\n3. **Middle East**: Countries in the Middle East, known for their luxury shopping destinations and a growing interest in sports and fitness activities, could be strategic markets for Nike to target and establish a strong foothold.\\n\\n4. **Latin America**: Markets in Latin America, such as Brazil, Mexico, and Argentina, present opportunities for Nike to cater to a diverse consumer base and leverage the region's passion for sports and active lifestyles.\\n\\n5. **Southeast Asia**: Rapid urbanization, increasing urban middle-class population, and a trend towards health and wellness in countries like Indonesia, Thailand, and Vietnam make Southeast Asia an attractive region for Nike to explore and expand its market reach.\\n\\nBy exploring these new markets in 2024, Nike can diversify its geographical presence, reach untapped consumer segments, and drive growth in emerging economies.\" response_metadata={'token_usage': {'completion_tokens': 262, 'prompt_tokens': 2619, 'total_tokens': 2881}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content=\"### Potential New Markets for Nike to Explore in 2024\\n\\n1. **India**: With a growing population, increasing disposable incomes, and a rising interest in health and fitness, India presents a significant opportunity for Nike to expand its presence and tap into a large consumer base.\\n\\n2. **Africa**: The African market, particularly countries with emerging economies and a young population, offers potential for Nike to introduce its products and capitalize on the growing demand for sportswear and athletic footwear.\\n\\n3. **Middle East**: Countries in the Middle East, known for their luxury shopping destinations and a growing interest in sports and fitness activities, could be strategic markets for Nike to target and establish a strong foothold.\\n\\n4. **Latin America**: Markets in Latin America, such as Brazil, Mexico, and Argentina, present opportunities for Nike to cater to a diverse consumer base and leverage the region's passion for sports and active lifestyles.\\n\\n5. **Southeast Asia**: Rapid urbanization, increasing urban middle-class population, and a trend towards health and wellness in countries like Indonesia, Thailand, and Vietnam make Southeast Asia an attractive region for Nike to explore and expand its market reach.\\n\\nBy exploring these new markets in 2024, Nike can diversify its geographical presence, reach untapped consumer segments, and drive growth in emerging economies.\" response_metadata={'token_usage': {'completion_tokens': 262, 'prompt_tokens': 2619, 'total_tokens': 2881}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the potential new products or services Nike could introduce in 2024?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content=\"### Potential New Products or Services Nike Could Introduce in 2024\\n\\n1. **Smart Apparel**: Nike could explore the integration of technology into its apparel, such as smart fabrics that monitor performance metrics, provide feedback, or enhance comfort during workouts.\\n\\n2. **Athletic Accessories**: Introducing a line of athletic accessories like gym bags, water bottles, or fitness trackers could complement Nike's existing product offerings and provide additional value to customers.\\n\\n3. **Customization Platforms**: Offering personalized design options for footwear and apparel through online customization platforms could appeal to consumers seeking unique and tailored products.\\n\\n4. **Athletic Recovery Gear**: Developing recovery-focused products like compression wear, recovery sandals, or massage tools could cater to athletes and fitness enthusiasts looking to enhance post-workout recovery.\\n\\n5. **Sustainable Collections**: Launching sustainable collections made from eco-friendly materials, recycled fabrics, or biodegradable components could align with consumer preferences for environmentally conscious products.\\n\\nBy introducing these new products or services in 2024, Nike can innovate its product portfolio, cater to evolving consumer needs, and differentiate itself in the competitive sports apparel market.\" response_metadata={'token_usage': {'completion_tokens': 224, 'prompt_tokens': 3009, 'total_tokens': 3233}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_a450710239', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content=\"### Potential New Products or Services Nike Could Introduce in 2024\\n\\n1. **Smart Apparel**: Nike could explore the integration of technology into its apparel, such as smart fabrics that monitor performance metrics, provide feedback, or enhance comfort during workouts.\\n\\n2. **Athletic Accessories**: Introducing a line of athletic accessories like gym bags, water bottles, or fitness trackers could complement Nike's existing product offerings and provide additional value to customers.\\n\\n3. **Customization Platforms**: Offering personalized design options for footwear and apparel through online customization platforms could appeal to consumers seeking unique and tailored products.\\n\\n4. **Athletic Recovery Gear**: Developing recovery-focused products like compression wear, recovery sandals, or massage tools could cater to athletes and fitness enthusiasts looking to enhance post-workout recovery.\\n\\n5. **Sustainable Collections**: Launching sustainable collections made from eco-friendly materials, recycled fabrics, or biodegradable components could align with consumer preferences for environmentally conscious products.\\n\\nBy introducing these new products or services in 2024, Nike can innovate its product portfolio, cater to evolving consumer needs, and differentiate itself in the competitive sports apparel market.\" response_metadata={'token_usage': {'completion_tokens': 224, 'prompt_tokens': 3009, 'total_tokens': 3233}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_a450710239', 'finish_reason': 'stop', 'logprobs': None}\n", + "Running task: What are the potential marketing strategies Nike could use to increase its revenue in Q3 2024?\n", + "\u001b[33mInitializing Autonomous Agent Writer agent...\u001b[0m\n", + "\u001b[1m\u001b[36mAutonomous Agent Activated.\u001b[0m\n", + "\u001b[32mAll systems operational. Executing task...\u001b[0m\n", + "\u001b[36m\n", + "Loop 1 of 1\u001b[0m\n", + "\n", + "\n", + "\n", + "\n", + "content='### Potential Marketing Strategies for Nike to Increase Revenue in Q3 2024\\n\\n1. **Influencer Partnerships**: Collaborating with popular athletes, celebrities, or social media influencers to promote Nike products can help reach a wider audience and drive sales.\\n\\n2. **Interactive Campaigns**: Launching interactive marketing campaigns, contests, or events that engage customers and create buzz around new product releases can generate excitement and increase brand visibility.\\n\\n3. **Social Media Engagement**: Leveraging social media platforms to connect with consumers, share user-generated content, and respond to feedback can build brand loyalty and encourage repeat purchases.\\n\\n4. **Localized Marketing**: Tailoring marketing messages, promotions, and product offerings to specific regions or target demographics can enhance relevance and appeal to diverse consumer groups.\\n\\n5. **Customer Loyalty Programs**: Implementing loyalty programs, exclusive offers, or rewards for repeat customers can incentivize brand loyalty, increase retention rates, and drive higher lifetime customer value.\\n\\nBy employing these marketing strategies in Q3 2024, Nike can enhance its brand presence, attract new customers, and ultimately boost revenue growth.' response_metadata={'token_usage': {'completion_tokens': 220, 'prompt_tokens': 3362, 'total_tokens': 3582}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n", + "\u001b[32mSaved agent state to: Writer agent_state.json\u001b[0m\n", + "content='### Potential Marketing Strategies for Nike to Increase Revenue in Q3 2024\\n\\n1. **Influencer Partnerships**: Collaborating with popular athletes, celebrities, or social media influencers to promote Nike products can help reach a wider audience and drive sales.\\n\\n2. **Interactive Campaigns**: Launching interactive marketing campaigns, contests, or events that engage customers and create buzz around new product releases can generate excitement and increase brand visibility.\\n\\n3. **Social Media Engagement**: Leveraging social media platforms to connect with consumers, share user-generated content, and respond to feedback can build brand loyalty and encourage repeat purchases.\\n\\n4. **Localized Marketing**: Tailoring marketing messages, promotions, and product offerings to specific regions or target demographics can enhance relevance and appeal to diverse consumer groups.\\n\\n5. **Customer Loyalty Programs**: Implementing loyalty programs, exclusive offers, or rewards for repeat customers can incentivize brand loyalty, increase retention rates, and drive higher lifetime customer value.\\n\\nBy employing these marketing strategies in Q3 2024, Nike can enhance its brand presence, attract new customers, and ultimately boost revenue growth.' response_metadata={'token_usage': {'completion_tokens': 220, 'prompt_tokens': 3362, 'total_tokens': 3582}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}\n" + ] + } + ], + "source": [ + "for node in bfs_order:\n", + " sub_query =nodes_info[node]['query']\n", + " print(\"Running task: \", sub_query)\n", + " out = agent.run(f\"Consider: {sub_query}. Write response in strict markdown format using long-term memory. Do not mention Writer Agent in response.\")\n", + " print(out)\n", + " try:\n", + " report.append(out.content)\n", + " except:\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we need to clean up the repoort a bit to make it render professionally. " + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [], + "source": [ + "# Remove any content before the first \"#\" as that signals start of heading\n", + "# Anything before this usually contains filler content\n", + "stripped_report = [entry[entry.find('#'):] if '#' in entry else entry for entry in report]\n", + "report = stripped_report" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[\"### Nike's Current Revenue Trend\\n\\nNike's current revenue trend has been steadily increasing over the past few years. In the most recent fiscal year, Nike reported a revenue of $37.4 billion, which was a 7% increase from the previous year. This growth can be attributed to strong sales in key markets, successful marketing campaigns, and a focus on innovation in product development. Overall, Nike continues to demonstrate strong financial performance and is well-positioned for future growth.\",\n", + " \"### Potential Areas of Improvement in Nike's Business Model\\n\\n1. **Sustainability Practices**: Nike could further enhance its sustainability efforts by reducing its carbon footprint, using more eco-friendly materials, and ensuring ethical labor practices throughout its supply chain.\\n\\n2. **Diversification of Product Portfolio**: While Nike is known for its athletic footwear and apparel, diversifying into new product categories or expanding into untapped markets could help drive growth and mitigate risks associated with a single product line.\\n\\n3. **E-commerce Strategy**: Improving the online shopping experience, investing in digital marketing, and leveraging data analytics to personalize customer interactions could boost online sales and customer loyalty.\\n\\n4. **Innovation and R&D**: Continuously investing in research and development to stay ahead of competitors, introduce new technologies, and enhance product performance could help maintain Nike's competitive edge in the market.\\n\\n5. **Brand Image and Reputation**: Strengthening brand image through effective marketing campaigns, community engagement, and transparent communication with stakeholders can help build trust and loyalty among consumers.\",\n", + " '### Potential Cost-Saving Strategies for Nike to Increase Net Revenue in Q3 2024\\n\\n1. **Supply Chain Optimization**: Streamlining the supply chain, reducing transportation costs, and improving inventory management can lead to significant cost savings for Nike.\\n\\n2. **Operational Efficiency**: Implementing lean manufacturing practices, reducing waste, and optimizing production processes can help lower production costs and improve overall efficiency.\\n\\n3. **Outsourcing Non-Core Functions**: Outsourcing non-core functions such as IT services, customer support, or logistics can help reduce overhead costs and focus resources on core business activities.\\n\\n4. **Energy Efficiency**: Investing in energy-efficient technologies, renewable energy sources, and sustainable practices can lower utility costs and demonstrate a commitment to environmental responsibility.\\n\\n5. **Negotiating Supplier Contracts**: Negotiating better terms with suppliers, leveraging economies of scale, and exploring alternative sourcing options can help lower procurement costs and improve margins.\\n\\nBy implementing these cost-saving strategies, Nike can improve its bottom line and increase net revenue in Q3 2024.',\n", + " '### Projected Market Trends for the Sports Apparel Industry in 2024\\n\\n1. **Sustainable Fashion**: Consumers are increasingly demanding eco-friendly and sustainable products, leading to a rise in sustainable sportswear options in the market.\\n\\n2. **Digital Transformation**: The sports apparel industry is expected to continue its shift towards digital platforms, with a focus on e-commerce, personalized shopping experiences, and digital marketing strategies.\\n\\n3. **Athleisure Wear**: The trend of athleisure wear, which combines athletic and leisure clothing, is projected to remain popular in 2024 as consumers seek comfort and versatility in their apparel choices.\\n\\n4. **Innovative Materials**: Advances in technology and material science are likely to drive the development of innovative fabrics and performance-enhancing materials in sports apparel, catering to the demand for high-quality and functional products.\\n\\n5. **Health and Wellness Focus**: With a growing emphasis on health and wellness, sports apparel brands are expected to incorporate features that promote comfort, performance, and overall well-being in their products.\\n\\nOverall, the sports apparel industry in 2024 is anticipated to be characterized by sustainability, digitalization, innovation, and a focus on consumer health and lifestyle trends.',\n", + " \"### Current Successful Strategies Used by Nike's Competitors\\n\\n1. **Adidas**: Adidas has been successful in leveraging collaborations with celebrities and designers to create limited-edition collections that generate hype and drive sales. They have also focused on sustainability initiatives, such as using recycled materials in their products, to appeal to environmentally conscious consumers.\\n\\n2. **Under Armour**: Under Armour has differentiated itself by targeting performance-driven athletes and emphasizing technological innovation in their products. They have also invested heavily in digital marketing and e-commerce to reach a wider audience and enhance the customer shopping experience.\\n\\n3. **Puma**: Puma has successfully capitalized on the athleisure trend by offering stylish and versatile sportswear that can be worn both in and out of the gym. They have also focused on building partnerships with influencers and sponsoring high-profile athletes to increase brand visibility and credibility.\\n\\n4. **Lululemon**: Lululemon has excelled in creating a strong community around its brand, hosting events, classes, and collaborations to engage with customers beyond just selling products. They have also prioritized customer experience by offering personalized services and creating a seamless omnichannel shopping experience.\\n\\n5. **New Balance**: New Balance has carved out a niche in the market by emphasizing quality craftsmanship, heritage, and authenticity in their products. They have also focused on customization and personalization options for customers, allowing them to create unique and tailored footwear and apparel.\\n\\nOverall, Nike's competitors have found success through a combination of innovative product offerings, strategic marketing initiatives, and a focus on customer engagement and experience.\",\n", + " '### Current and Projected Economic Conditions in Nike\\'s Major Markets\\\\n\\\\n1. **United States**: The United States, being one of Nike\\'s largest markets, is currently experiencing moderate economic growth driven by consumer spending, low unemployment rates, and a rebound in manufacturing. However, uncertainties surrounding trade policies, inflation, and interest rates could impact consumer confidence and spending in the near future.\\\\n\\\\n2. **China**: China remains a key market for Nike, with a growing middle class and increasing demand for sportswear and athletic footwear. Despite recent trade tensions with the U.S., China\\'s economy is projected to continue expanding, driven by domestic consumption, infrastructure investments, and technological advancements.\\\\n\\\\n3. **Europe**: Economic conditions in Europe vary across countries, with some experiencing sluggish growth due to Brexit uncertainties, political instability, and trade tensions. However, overall consumer confidence is improving, and the sports apparel market is expected to grow, driven by e-commerce and sustainability trends.\\\\n\\\\n4. **Emerging Markets**: Nike\\'s presence in emerging markets such as India, Brazil, and Southeast Asia provides opportunities for growth, given the rising disposable incomes, urbanization, and increasing focus on health and fitness. However, challenges such as currency fluctuations, regulatory changes, and competition from local brands could impact Nike\\'s performance in these markets.\\\\n\\\\nOverall, Nike\\'s major markets exhibit a mix of opportunities and challenges, with economic conditions influenced by global trends, geopolitical factors, and consumer preferences.\" response_metadata={\\'token_usage\\': {\\'completion_tokens\\': 287, \\'prompt_tokens\\': 1184, \\'total_tokens\\': 1471}, \\'model_name\\': \\'gpt-3.5-turbo\\', \\'system_fingerprint\\': \\'fp_a450710239\\', \\'finish_reason\\': \\'stop\\', \\'logprobs\\': None}',\n", + " '### Current Consumer Preferences in the Sports Apparel Industry\\n\\n1. **Sustainability**: Consumers are increasingly seeking eco-friendly and sustainable options in sports apparel, driving brands to focus on using recycled materials, reducing waste, and promoting ethical practices.\\n\\n2. **Athleisure**: The trend of athleisure wear continues to be popular, with consumers looking for versatile and comfortable clothing that can be worn both during workouts and in everyday life.\\n\\n3. **Performance and Functionality**: Consumers prioritize performance-enhancing features in sports apparel, such as moisture-wicking fabrics, breathable materials, and ergonomic designs that enhance comfort and mobility.\\n\\n4. **Personalization**: Customization options, personalized fit, and unique design elements are appealing to consumers who seek individuality and exclusivity in their sports apparel choices.\\n\\n5. **Brand Transparency**: Consumers value transparency in brand practices, including supply chain transparency, ethical sourcing, and clear communication on product quality and manufacturing processes.\\n\\nOverall, consumer preferences in the sports apparel industry are shifting towards sustainability, versatility, performance, personalization, and transparency, influencing brand strategies and product offerings.',\n", + " \"### Potential New Markets for Nike to Explore in 2024\\n\\n1. **India**: With a growing population, increasing disposable incomes, and a rising interest in health and fitness, India presents a significant opportunity for Nike to expand its presence and tap into a large consumer base.\\n\\n2. **Africa**: The African market, particularly countries with emerging economies and a young population, offers potential for Nike to introduce its products and capitalize on the growing demand for sportswear and athletic footwear.\\n\\n3. **Middle East**: Countries in the Middle East, known for their luxury shopping destinations and a growing interest in sports and fitness activities, could be strategic markets for Nike to target and establish a strong foothold.\\n\\n4. **Latin America**: Markets in Latin America, such as Brazil, Mexico, and Argentina, present opportunities for Nike to cater to a diverse consumer base and leverage the region's passion for sports and active lifestyles.\\n\\n5. **Southeast Asia**: Rapid urbanization, increasing urban middle-class population, and a trend towards health and wellness in countries like Indonesia, Thailand, and Vietnam make Southeast Asia an attractive region for Nike to explore and expand its market reach.\\n\\nBy exploring these new markets in 2024, Nike can diversify its geographical presence, reach untapped consumer segments, and drive growth in emerging economies.\",\n", + " \"### Potential New Products or Services Nike Could Introduce in 2024\\n\\n1. **Smart Apparel**: Nike could explore the integration of technology into its apparel, such as smart fabrics that monitor performance metrics, provide feedback, or enhance comfort during workouts.\\n\\n2. **Athletic Accessories**: Introducing a line of athletic accessories like gym bags, water bottles, or fitness trackers could complement Nike's existing product offerings and provide additional value to customers.\\n\\n3. **Customization Platforms**: Offering personalized design options for footwear and apparel through online customization platforms could appeal to consumers seeking unique and tailored products.\\n\\n4. **Athletic Recovery Gear**: Developing recovery-focused products like compression wear, recovery sandals, or massage tools could cater to athletes and fitness enthusiasts looking to enhance post-workout recovery.\\n\\n5. **Sustainable Collections**: Launching sustainable collections made from eco-friendly materials, recycled fabrics, or biodegradable components could align with consumer preferences for environmentally conscious products.\\n\\nBy introducing these new products or services in 2024, Nike can innovate its product portfolio, cater to evolving consumer needs, and differentiate itself in the competitive sports apparel market.\",\n", + " '### Potential Marketing Strategies for Nike to Increase Revenue in Q3 2024\\n\\n1. **Influencer Partnerships**: Collaborating with popular athletes, celebrities, or social media influencers to promote Nike products can help reach a wider audience and drive sales.\\n\\n2. **Interactive Campaigns**: Launching interactive marketing campaigns, contests, or events that engage customers and create buzz around new product releases can generate excitement and increase brand visibility.\\n\\n3. **Social Media Engagement**: Leveraging social media platforms to connect with consumers, share user-generated content, and respond to feedback can build brand loyalty and encourage repeat purchases.\\n\\n4. **Localized Marketing**: Tailoring marketing messages, promotions, and product offerings to specific regions or target demographics can enhance relevance and appeal to diverse consumer groups.\\n\\n5. **Customer Loyalty Programs**: Implementing loyalty programs, exclusive offers, or rewards for repeat customers can incentivize brand loyalty, increase retention rates, and drive higher lifetime customer value.\\n\\nBy employing these marketing strategies in Q3 2024, Nike can enhance its brand presence, attract new customers, and ultimately boost revenue growth.']" + ] + }, + "execution_count": 190, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "report" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [], + "source": [ + "# At times the LLM outputs \\\\n instead of \\n\n", + "cleaned_report = [entry.replace(\"\\\\n\", \"\\n\") for entry in report]\n", + "import re\n", + "\n", + "# Function to clean up unnecessary metadata from the report entries\n", + "def clean_report(report):\n", + " cleaned_report = []\n", + " for entry in report:\n", + " # This pattern matches 'response_metadata={' followed by any characters that are not '}' (non-greedy), \n", + " # possibly nested inside other braces, until the closing '}'.\n", + " cleaned_entry = re.sub(r\"response_metadata=\\{[^{}]*(?:\\{[^{}]*\\}[^{}]*)*\\}\", \"\", entry, flags=re.DOTALL)\n", + " cleaned_report.append(cleaned_entry)\n", + " return cleaned_report\n", + "\n", + "# Apply the cleaning function to the markdown report\n", + "cleaned_report = clean_report(cleaned_report)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After cleaning, we append parts of the report together to get out final report." + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "### Nike's Current Revenue Trend\n", + "\n", + "Nike's current revenue trend has been steadily increasing over the past few years. In the most recent fiscal year, Nike reported a revenue of $37.4 billion, which was a 7% increase from the previous year. This growth can be attributed to strong sales in key markets, successful marketing campaigns, and a focus on innovation in product development. Overall, Nike continues to demonstrate strong financial performance and is well-positioned for future growth. \n", + " ### Potential Areas of Improvement in Nike's Business Model\n", + "\n", + "1. **Sustainability Practices**: Nike could further enhance its sustainability efforts by reducing its carbon footprint, using more eco-friendly materials, and ensuring ethical labor practices throughout its supply chain.\n", + "\n", + "2. **Diversification of Product Portfolio**: While Nike is known for its athletic footwear and apparel, diversifying into new product categories or expanding into untapped markets could help drive growth and mitigate risks associated with a single product line.\n", + "\n", + "3. **E-commerce Strategy**: Improving the online shopping experience, investing in digital marketing, and leveraging data analytics to personalize customer interactions could boost online sales and customer loyalty.\n", + "\n", + "4. **Innovation and R&D**: Continuously investing in research and development to stay ahead of competitors, introduce new technologies, and enhance product performance could help maintain Nike's competitive edge in the market.\n", + "\n", + "5. **Brand Image and Reputation**: Strengthening brand image through effective marketing campaigns, community engagement, and transparent communication with stakeholders can help build trust and loyalty among consumers. \n", + " ### Potential Cost-Saving Strategies for Nike to Increase Net Revenue in Q3 2024\n", + "\n", + "1. **Supply Chain Optimization**: Streamlining the supply chain, reducing transportation costs, and improving inventory management can lead to significant cost savings for Nike.\n", + "\n", + "2. **Operational Efficiency**: Implementing lean manufacturing practices, reducing waste, and optimizing production processes can help lower production costs and improve overall efficiency.\n", + "\n", + "3. **Outsourcing Non-Core Functions**: Outsourcing non-core functions such as IT services, customer support, or logistics can help reduce overhead costs and focus resources on core business activities.\n", + "\n", + "4. **Energy Efficiency**: Investing in energy-efficient technologies, renewable energy sources, and sustainable practices can lower utility costs and demonstrate a commitment to environmental responsibility.\n", + "\n", + "5. **Negotiating Supplier Contracts**: Negotiating better terms with suppliers, leveraging economies of scale, and exploring alternative sourcing options can help lower procurement costs and improve margins.\n", + "\n", + "By implementing these cost-saving strategies, Nike can improve its bottom line and increase net revenue in Q3 2024. \n", + " ### Projected Market Trends for the Sports Apparel Industry in 2024\n", + "\n", + "1. **Sustainable Fashion**: Consumers are increasingly demanding eco-friendly and sustainable products, leading to a rise in sustainable sportswear options in the market.\n", + "\n", + "2. **Digital Transformation**: The sports apparel industry is expected to continue its shift towards digital platforms, with a focus on e-commerce, personalized shopping experiences, and digital marketing strategies.\n", + "\n", + "3. **Athleisure Wear**: The trend of athleisure wear, which combines athletic and leisure clothing, is projected to remain popular in 2024 as consumers seek comfort and versatility in their apparel choices.\n", + "\n", + "4. **Innovative Materials**: Advances in technology and material science are likely to drive the development of innovative fabrics and performance-enhancing materials in sports apparel, catering to the demand for high-quality and functional products.\n", + "\n", + "5. **Health and Wellness Focus**: With a growing emphasis on health and wellness, sports apparel brands are expected to incorporate features that promote comfort, performance, and overall well-being in their products.\n", + "\n", + "Overall, the sports apparel industry in 2024 is anticipated to be characterized by sustainability, digitalization, innovation, and a focus on consumer health and lifestyle trends. \n", + " ### Current Successful Strategies Used by Nike's Competitors\n", + "\n", + "1. **Adidas**: Adidas has been successful in leveraging collaborations with celebrities and designers to create limited-edition collections that generate hype and drive sales. They have also focused on sustainability initiatives, such as using recycled materials in their products, to appeal to environmentally conscious consumers.\n", + "\n", + "2. **Under Armour**: Under Armour has differentiated itself by targeting performance-driven athletes and emphasizing technological innovation in their products. They have also invested heavily in digital marketing and e-commerce to reach a wider audience and enhance the customer shopping experience.\n", + "\n", + "3. **Puma**: Puma has successfully capitalized on the athleisure trend by offering stylish and versatile sportswear that can be worn both in and out of the gym. They have also focused on building partnerships with influencers and sponsoring high-profile athletes to increase brand visibility and credibility.\n", + "\n", + "4. **Lululemon**: Lululemon has excelled in creating a strong community around its brand, hosting events, classes, and collaborations to engage with customers beyond just selling products. They have also prioritized customer experience by offering personalized services and creating a seamless omnichannel shopping experience.\n", + "\n", + "5. **New Balance**: New Balance has carved out a niche in the market by emphasizing quality craftsmanship, heritage, and authenticity in their products. They have also focused on customization and personalization options for customers, allowing them to create unique and tailored footwear and apparel.\n", + "\n", + "Overall, Nike's competitors have found success through a combination of innovative product offerings, strategic marketing initiatives, and a focus on customer engagement and experience. \n", + " ### Current and Projected Economic Conditions in Nike's Major Markets\n", + "\n", + "1. **United States**: The United States, being one of Nike's largest markets, is currently experiencing moderate economic growth driven by consumer spending, low unemployment rates, and a rebound in manufacturing. However, uncertainties surrounding trade policies, inflation, and interest rates could impact consumer confidence and spending in the near future.\n", + "\n", + "2. **China**: China remains a key market for Nike, with a growing middle class and increasing demand for sportswear and athletic footwear. Despite recent trade tensions with the U.S., China's economy is projected to continue expanding, driven by domestic consumption, infrastructure investments, and technological advancements.\n", + "\n", + "3. **Europe**: Economic conditions in Europe vary across countries, with some experiencing sluggish growth due to Brexit uncertainties, political instability, and trade tensions. However, overall consumer confidence is improving, and the sports apparel market is expected to grow, driven by e-commerce and sustainability trends.\n", + "\n", + "4. **Emerging Markets**: Nike's presence in emerging markets such as India, Brazil, and Southeast Asia provides opportunities for growth, given the rising disposable incomes, urbanization, and increasing focus on health and fitness. However, challenges such as currency fluctuations, regulatory changes, and competition from local brands could impact Nike's performance in these markets.\n", + "\n", + "Overall, Nike's major markets exhibit a mix of opportunities and challenges, with economic conditions influenced by global trends, geopolitical factors, and consumer preferences.\" \n", + " ### Current Consumer Preferences in the Sports Apparel Industry\n", + "\n", + "1. **Sustainability**: Consumers are increasingly seeking eco-friendly and sustainable options in sports apparel, driving brands to focus on using recycled materials, reducing waste, and promoting ethical practices.\n", + "\n", + "2. **Athleisure**: The trend of athleisure wear continues to be popular, with consumers looking for versatile and comfortable clothing that can be worn both during workouts and in everyday life.\n", + "\n", + "3. **Performance and Functionality**: Consumers prioritize performance-enhancing features in sports apparel, such as moisture-wicking fabrics, breathable materials, and ergonomic designs that enhance comfort and mobility.\n", + "\n", + "4. **Personalization**: Customization options, personalized fit, and unique design elements are appealing to consumers who seek individuality and exclusivity in their sports apparel choices.\n", + "\n", + "5. **Brand Transparency**: Consumers value transparency in brand practices, including supply chain transparency, ethical sourcing, and clear communication on product quality and manufacturing processes.\n", + "\n", + "Overall, consumer preferences in the sports apparel industry are shifting towards sustainability, versatility, performance, personalization, and transparency, influencing brand strategies and product offerings. \n", + " ### Potential New Markets for Nike to Explore in 2024\n", + "\n", + "1. **India**: With a growing population, increasing disposable incomes, and a rising interest in health and fitness, India presents a significant opportunity for Nike to expand its presence and tap into a large consumer base.\n", + "\n", + "2. **Africa**: The African market, particularly countries with emerging economies and a young population, offers potential for Nike to introduce its products and capitalize on the growing demand for sportswear and athletic footwear.\n", + "\n", + "3. **Middle East**: Countries in the Middle East, known for their luxury shopping destinations and a growing interest in sports and fitness activities, could be strategic markets for Nike to target and establish a strong foothold.\n", + "\n", + "4. **Latin America**: Markets in Latin America, such as Brazil, Mexico, and Argentina, present opportunities for Nike to cater to a diverse consumer base and leverage the region's passion for sports and active lifestyles.\n", + "\n", + "5. **Southeast Asia**: Rapid urbanization, increasing urban middle-class population, and a trend towards health and wellness in countries like Indonesia, Thailand, and Vietnam make Southeast Asia an attractive region for Nike to explore and expand its market reach.\n", + "\n", + "By exploring these new markets in 2024, Nike can diversify its geographical presence, reach untapped consumer segments, and drive growth in emerging economies. \n", + " ### Potential New Products or Services Nike Could Introduce in 2024\n", + "\n", + "1. **Smart Apparel**: Nike could explore the integration of technology into its apparel, such as smart fabrics that monitor performance metrics, provide feedback, or enhance comfort during workouts.\n", + "\n", + "2. **Athletic Accessories**: Introducing a line of athletic accessories like gym bags, water bottles, or fitness trackers could complement Nike's existing product offerings and provide additional value to customers.\n", + "\n", + "3. **Customization Platforms**: Offering personalized design options for footwear and apparel through online customization platforms could appeal to consumers seeking unique and tailored products.\n", + "\n", + "4. **Athletic Recovery Gear**: Developing recovery-focused products like compression wear, recovery sandals, or massage tools could cater to athletes and fitness enthusiasts looking to enhance post-workout recovery.\n", + "\n", + "5. **Sustainable Collections**: Launching sustainable collections made from eco-friendly materials, recycled fabrics, or biodegradable components could align with consumer preferences for environmentally conscious products.\n", + "\n", + "By introducing these new products or services in 2024, Nike can innovate its product portfolio, cater to evolving consumer needs, and differentiate itself in the competitive sports apparel market. \n", + " ### Potential Marketing Strategies for Nike to Increase Revenue in Q3 2024\n", + "\n", + "1. **Influencer Partnerships**: Collaborating with popular athletes, celebrities, or social media influencers to promote Nike products can help reach a wider audience and drive sales.\n", + "\n", + "2. **Interactive Campaigns**: Launching interactive marketing campaigns, contests, or events that engage customers and create buzz around new product releases can generate excitement and increase brand visibility.\n", + "\n", + "3. **Social Media Engagement**: Leveraging social media platforms to connect with consumers, share user-generated content, and respond to feedback can build brand loyalty and encourage repeat purchases.\n", + "\n", + "4. **Localized Marketing**: Tailoring marketing messages, promotions, and product offerings to specific regions or target demographics can enhance relevance and appeal to diverse consumer groups.\n", + "\n", + "5. **Customer Loyalty Programs**: Implementing loyalty programs, exclusive offers, or rewards for repeat customers can incentivize brand loyalty, increase retention rates, and drive higher lifetime customer value.\n", + "\n", + "By employing these marketing strategies in Q3 2024, Nike can enhance its brand presence, attract new customers, and ultimately boost revenue growth.\n" + ] + } + ], + "source": [ + "final_report = ' \\n '.join(cleaned_report)\n", + "print(final_report)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Final Generated Report\n", + "\n", + "In Jupyter Notebook, we can use the below code to render it in Markdown. " + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "### Nike's Current Revenue Trend\n", + "\n", + "Nike's current revenue trend has been steadily increasing over the past few years. In the most recent fiscal year, Nike reported a revenue of $37.4 billion, which was a 7% increase from the previous year. This growth can be attributed to strong sales in key markets, successful marketing campaigns, and a focus on innovation in product development. Overall, Nike continues to demonstrate strong financial performance and is well-positioned for future growth. \n", + " ### Potential Areas of Improvement in Nike's Business Model\n", + "\n", + "1. **Sustainability Practices**: Nike could further enhance its sustainability efforts by reducing its carbon footprint, using more eco-friendly materials, and ensuring ethical labor practices throughout its supply chain.\n", + "\n", + "2. **Diversification of Product Portfolio**: While Nike is known for its athletic footwear and apparel, diversifying into new product categories or expanding into untapped markets could help drive growth and mitigate risks associated with a single product line.\n", + "\n", + "3. **E-commerce Strategy**: Improving the online shopping experience, investing in digital marketing, and leveraging data analytics to personalize customer interactions could boost online sales and customer loyalty.\n", + "\n", + "4. **Innovation and R&D**: Continuously investing in research and development to stay ahead of competitors, introduce new technologies, and enhance product performance could help maintain Nike's competitive edge in the market.\n", + "\n", + "5. **Brand Image and Reputation**: Strengthening brand image through effective marketing campaigns, community engagement, and transparent communication with stakeholders can help build trust and loyalty among consumers. \n", + " ### Potential Cost-Saving Strategies for Nike to Increase Net Revenue in Q3 2024\n", + "\n", + "1. **Supply Chain Optimization**: Streamlining the supply chain, reducing transportation costs, and improving inventory management can lead to significant cost savings for Nike.\n", + "\n", + "2. **Operational Efficiency**: Implementing lean manufacturing practices, reducing waste, and optimizing production processes can help lower production costs and improve overall efficiency.\n", + "\n", + "3. **Outsourcing Non-Core Functions**: Outsourcing non-core functions such as IT services, customer support, or logistics can help reduce overhead costs and focus resources on core business activities.\n", + "\n", + "4. **Energy Efficiency**: Investing in energy-efficient technologies, renewable energy sources, and sustainable practices can lower utility costs and demonstrate a commitment to environmental responsibility.\n", + "\n", + "5. **Negotiating Supplier Contracts**: Negotiating better terms with suppliers, leveraging economies of scale, and exploring alternative sourcing options can help lower procurement costs and improve margins.\n", + "\n", + "By implementing these cost-saving strategies, Nike can improve its bottom line and increase net revenue in Q3 2024. \n", + " ### Projected Market Trends for the Sports Apparel Industry in 2024\n", + "\n", + "1. **Sustainable Fashion**: Consumers are increasingly demanding eco-friendly and sustainable products, leading to a rise in sustainable sportswear options in the market.\n", + "\n", + "2. **Digital Transformation**: The sports apparel industry is expected to continue its shift towards digital platforms, with a focus on e-commerce, personalized shopping experiences, and digital marketing strategies.\n", + "\n", + "3. **Athleisure Wear**: The trend of athleisure wear, which combines athletic and leisure clothing, is projected to remain popular in 2024 as consumers seek comfort and versatility in their apparel choices.\n", + "\n", + "4. **Innovative Materials**: Advances in technology and material science are likely to drive the development of innovative fabrics and performance-enhancing materials in sports apparel, catering to the demand for high-quality and functional products.\n", + "\n", + "5. **Health and Wellness Focus**: With a growing emphasis on health and wellness, sports apparel brands are expected to incorporate features that promote comfort, performance, and overall well-being in their products.\n", + "\n", + "Overall, the sports apparel industry in 2024 is anticipated to be characterized by sustainability, digitalization, innovation, and a focus on consumer health and lifestyle trends. \n", + " ### Current Successful Strategies Used by Nike's Competitors\n", + "\n", + "1. **Adidas**: Adidas has been successful in leveraging collaborations with celebrities and designers to create limited-edition collections that generate hype and drive sales. They have also focused on sustainability initiatives, such as using recycled materials in their products, to appeal to environmentally conscious consumers.\n", + "\n", + "2. **Under Armour**: Under Armour has differentiated itself by targeting performance-driven athletes and emphasizing technological innovation in their products. They have also invested heavily in digital marketing and e-commerce to reach a wider audience and enhance the customer shopping experience.\n", + "\n", + "3. **Puma**: Puma has successfully capitalized on the athleisure trend by offering stylish and versatile sportswear that can be worn both in and out of the gym. They have also focused on building partnerships with influencers and sponsoring high-profile athletes to increase brand visibility and credibility.\n", + "\n", + "4. **Lululemon**: Lululemon has excelled in creating a strong community around its brand, hosting events, classes, and collaborations to engage with customers beyond just selling products. They have also prioritized customer experience by offering personalized services and creating a seamless omnichannel shopping experience.\n", + "\n", + "5. **New Balance**: New Balance has carved out a niche in the market by emphasizing quality craftsmanship, heritage, and authenticity in their products. They have also focused on customization and personalization options for customers, allowing them to create unique and tailored footwear and apparel.\n", + "\n", + "Overall, Nike's competitors have found success through a combination of innovative product offerings, strategic marketing initiatives, and a focus on customer engagement and experience. \n", + " ### Current and Projected Economic Conditions in Nike's Major Markets\n", + "\n", + "1. **United States**: The United States, being one of Nike's largest markets, is currently experiencing moderate economic growth driven by consumer spending, low unemployment rates, and a rebound in manufacturing. However, uncertainties surrounding trade policies, inflation, and interest rates could impact consumer confidence and spending in the near future.\n", + "\n", + "2. **China**: China remains a key market for Nike, with a growing middle class and increasing demand for sportswear and athletic footwear. Despite recent trade tensions with the U.S., China's economy is projected to continue expanding, driven by domestic consumption, infrastructure investments, and technological advancements.\n", + "\n", + "3. **Europe**: Economic conditions in Europe vary across countries, with some experiencing sluggish growth due to Brexit uncertainties, political instability, and trade tensions. However, overall consumer confidence is improving, and the sports apparel market is expected to grow, driven by e-commerce and sustainability trends.\n", + "\n", + "4. **Emerging Markets**: Nike's presence in emerging markets such as India, Brazil, and Southeast Asia provides opportunities for growth, given the rising disposable incomes, urbanization, and increasing focus on health and fitness. However, challenges such as currency fluctuations, regulatory changes, and competition from local brands could impact Nike's performance in these markets.\n", + "\n", + "Overall, Nike's major markets exhibit a mix of opportunities and challenges, with economic conditions influenced by global trends, geopolitical factors, and consumer preferences.\" \n", + " ### Current Consumer Preferences in the Sports Apparel Industry\n", + "\n", + "1. **Sustainability**: Consumers are increasingly seeking eco-friendly and sustainable options in sports apparel, driving brands to focus on using recycled materials, reducing waste, and promoting ethical practices.\n", + "\n", + "2. **Athleisure**: The trend of athleisure wear continues to be popular, with consumers looking for versatile and comfortable clothing that can be worn both during workouts and in everyday life.\n", + "\n", + "3. **Performance and Functionality**: Consumers prioritize performance-enhancing features in sports apparel, such as moisture-wicking fabrics, breathable materials, and ergonomic designs that enhance comfort and mobility.\n", + "\n", + "4. **Personalization**: Customization options, personalized fit, and unique design elements are appealing to consumers who seek individuality and exclusivity in their sports apparel choices.\n", + "\n", + "5. **Brand Transparency**: Consumers value transparency in brand practices, including supply chain transparency, ethical sourcing, and clear communication on product quality and manufacturing processes.\n", + "\n", + "Overall, consumer preferences in the sports apparel industry are shifting towards sustainability, versatility, performance, personalization, and transparency, influencing brand strategies and product offerings. \n", + " ### Potential New Markets for Nike to Explore in 2024\n", + "\n", + "1. **India**: With a growing population, increasing disposable incomes, and a rising interest in health and fitness, India presents a significant opportunity for Nike to expand its presence and tap into a large consumer base.\n", + "\n", + "2. **Africa**: The African market, particularly countries with emerging economies and a young population, offers potential for Nike to introduce its products and capitalize on the growing demand for sportswear and athletic footwear.\n", + "\n", + "3. **Middle East**: Countries in the Middle East, known for their luxury shopping destinations and a growing interest in sports and fitness activities, could be strategic markets for Nike to target and establish a strong foothold.\n", + "\n", + "4. **Latin America**: Markets in Latin America, such as Brazil, Mexico, and Argentina, present opportunities for Nike to cater to a diverse consumer base and leverage the region's passion for sports and active lifestyles.\n", + "\n", + "5. **Southeast Asia**: Rapid urbanization, increasing urban middle-class population, and a trend towards health and wellness in countries like Indonesia, Thailand, and Vietnam make Southeast Asia an attractive region for Nike to explore and expand its market reach.\n", + "\n", + "By exploring these new markets in 2024, Nike can diversify its geographical presence, reach untapped consumer segments, and drive growth in emerging economies. \n", + " ### Potential New Products or Services Nike Could Introduce in 2024\n", + "\n", + "1. **Smart Apparel**: Nike could explore the integration of technology into its apparel, such as smart fabrics that monitor performance metrics, provide feedback, or enhance comfort during workouts.\n", + "\n", + "2. **Athletic Accessories**: Introducing a line of athletic accessories like gym bags, water bottles, or fitness trackers could complement Nike's existing product offerings and provide additional value to customers.\n", + "\n", + "3. **Customization Platforms**: Offering personalized design options for footwear and apparel through online customization platforms could appeal to consumers seeking unique and tailored products.\n", + "\n", + "4. **Athletic Recovery Gear**: Developing recovery-focused products like compression wear, recovery sandals, or massage tools could cater to athletes and fitness enthusiasts looking to enhance post-workout recovery.\n", + "\n", + "5. **Sustainable Collections**: Launching sustainable collections made from eco-friendly materials, recycled fabrics, or biodegradable components could align with consumer preferences for environmentally conscious products.\n", + "\n", + "By introducing these new products or services in 2024, Nike can innovate its product portfolio, cater to evolving consumer needs, and differentiate itself in the competitive sports apparel market. \n", + " ### Potential Marketing Strategies for Nike to Increase Revenue in Q3 2024\n", + "\n", + "1. **Influencer Partnerships**: Collaborating with popular athletes, celebrities, or social media influencers to promote Nike products can help reach a wider audience and drive sales.\n", + "\n", + "2. **Interactive Campaigns**: Launching interactive marketing campaigns, contests, or events that engage customers and create buzz around new product releases can generate excitement and increase brand visibility.\n", + "\n", + "3. **Social Media Engagement**: Leveraging social media platforms to connect with consumers, share user-generated content, and respond to feedback can build brand loyalty and encourage repeat purchases.\n", + "\n", + "4. **Localized Marketing**: Tailoring marketing messages, promotions, and product offerings to specific regions or target demographics can enhance relevance and appeal to diverse consumer groups.\n", + "\n", + "5. **Customer Loyalty Programs**: Implementing loyalty programs, exclusive offers, or rewards for repeat customers can incentivize brand loyalty, increase retention rates, and drive higher lifetime customer value.\n", + "\n", + "By employing these marketing strategies in Q3 2024, Nike can enhance its brand presence, attract new customers, and ultimately boost revenue growth." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Markdown\n", + "\n", + "display(Markdown(final_report))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "adv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2bbe604c4ab02b8a2fb1969dbc4a10749c57547f Mon Sep 17 00:00:00 2001 From: Aditya Ganesh Kumar Date: Tue, 7 May 2024 01:04:59 +0800 Subject: [PATCH 06/22] Added business analyst agent post --- docs/applications/business-analyst-agent.md | 978 ++++++++++++++++++++ docs/assets/img/docs/query-plan-mini.png | Bin 0 -> 125179 bytes docs/assets/img/docs/query-plan.png | Bin 0 -> 399648 bytes 3 files changed, 978 insertions(+) create mode 100644 docs/applications/business-analyst-agent.md create mode 100644 docs/assets/img/docs/query-plan-mini.png create mode 100644 docs/assets/img/docs/query-plan.png diff --git a/docs/applications/business-analyst-agent.md b/docs/applications/business-analyst-agent.md new file mode 100644 index 00000000..a7c2f504 --- /dev/null +++ b/docs/applications/business-analyst-agent.md @@ -0,0 +1,978 @@ +## Building Analyst Agents with Swarms to write Business Reports + +> Jupyter Notebook accompanying this post is accessible at: [Business Analyst Agent Notebook](https://github.com/kyegomez/swarms/blob/master/playground/business-analyst-agent.ipynb) + +Solving a business problem often involves preparing a Business Case Report. This report comprehensively analyzes the problem, evaluates potential solutions, and provides evidence-based recommendations and an implementation plan to effectively address the issue and drive business value. While the process of preparing one requires an experienced business analyst, the workflow can be augmented using AI agents. Two candidates stick out as areas to work on: + +- Developing an outline to solve the problem +- Doing background research and gathering data + +In this post, we will explore how Swarms agents can be used to tackle a busuiness problem by outlining the solution, conducting background research and generating a preliminary report. + +Before we proceed, this blog uses 3 API tools. Please obtain the following keys and store them in a `.env` file in the same folder as this file. + +- **[OpenAI API](https://openai.com/blog/openai-api)** as `OPENAI_API_KEY` +- **[TavilyAI API](https://app.tavily.com/home)** `TAVILY_API_KEY` +- **[KayAI API](https://www.kay.ai/)** as `KAY_API_KEY` + +```python +import dotenv +dotenv.load_dotenv() # Load environment variables from .env file +``` + +### Developing an Outline to solve the problem + +Assume the business problem is: **How do we improve Nike's revenue in Q3 2024?** We first create a planning agent to break down the problem into dependent sub-problems. + + +#### Step 1. Defining the Data Model and Tool Schema + +Using Pydantic, we define a structure to help the agent generate sub-problems. + +- **QueryType:** Questions are either standalone or involve a combination of multiple others +- **Query:** Defines structure of a question. +- **QueryPlan:** Allows generation of a dependency graph of sub-questions + + +```python +import enum +from typing import List +from pydantic import Field, BaseModel + +class QueryType(str, enum.Enum): + """Enumeration representing the types of queries that can be asked to a question answer system.""" + + SINGLE_QUESTION = "SINGLE" + MERGE_MULTIPLE_RESPONSES = "MERGE_MULTIPLE_RESPONSES" + +class Query(BaseModel): + """Class representing a single question in a query plan.""" + + id: int = Field(..., description="Unique id of the query") + question: str = Field( + ..., + description="Question asked using a question answering system", + ) + dependencies: List[int] = Field( + default_factory=list, + description="List of sub questions that need to be answered before asking this question", + ) + node_type: QueryType = Field( + default=QueryType.SINGLE_QUESTION, + description="Type of question, either a single question or a multi-question merge", + ) + +class QueryPlan(BaseModel): + """Container class representing a tree of questions to ask a question answering system.""" + + query_graph: List[Query] = Field( + ..., description="The query graph representing the plan" + ) + + def _dependencies(self, ids: List[int]) -> List[Query]: + """Returns the dependencies of a query given their ids.""" + + return [q for q in self.query_graph if q.id in ids] +``` + +Also, a `tool_schema` needs to be defined. It is an instance of `QueryPlan` and is used to initialize the agent. + +```python +tool_schema = QueryPlan( + query_graph = [query.dict() for query in [ + Query( + id=1, + question="How do we improve Nike's revenue in Q3 2024?", + dependencies=[2], + node_type=QueryType('SINGLE') + ), + # ... other queries ... + ]] +) +``` + +#### Step 2. Defining the Planning Agent + +We specify the query, task specification and an appropriate system prompt. + +```python +from swarms import OpenAIChat +from swarms import Agent + +query = "How do we improve Nike's revenue in Q3 2024?" +task = f"Consider: {query}. Generate just the correct query plan in JSON format." +system_prompt = ( + "You are a world class query planning algorithm " + "capable of breaking apart questions into its " + "dependency queries such that the answers can be " + "used to inform the parent question. Do not answer " + "the questions, simply provide a correct compute " + "graph with good specific questions to ask and relevant " + "dependencies. Before you call the function, think " + "step-by-step to get a better understanding of the problem." + ) +llm = OpenAIChat( + temperature=0.0, model_name="gpt-4", max_tokens=4000 +) +``` + +Then, we proceed with agent definition. + +```python +# Initialize the agent +agent = Agent( + agent_name="Query Planner", + system_prompt=system_prompt, + # Set the tool schema to the JSON string -- this is the key difference + tool_schema=tool_schema, + llm=llm, + max_loops=1, + autosave=True, + dashboard=False, + streaming_on=True, + verbose=True, + interactive=False, + # Set the output type to the tool schema which is a BaseModel + output_type=tool_schema, # or dict, or str + metadata_output_type="json", + # List of schemas that the agent can handle + list_tool_schemas=[tool_schema], + function_calling_format_type="OpenAI", + function_calling_type="json", # or soon yaml +) +``` + +#### Step 3. Obtaining Outline from Planning Agent + +We now run the agent, and since its output is in JSON format, we can load it as a dictionary. + +```python +generated_data = agent.run(task) +``` + +At times the agent could return extra content other than JSON. Below function will filter it out. + +```python +def process_json_output(content): + # Find the index of the first occurrence of '```json\n' + start_index = content.find('```json\n') + if start_index == -1: + # If '```json\n' is not found, return the original content + return content + # Return the part of the content after '```json\n' and remove the '```' at the end + return content[start_index + len('```json\n'):].rstrip('`') + +# Use the function to clean up the output +json_content = process_json_output(generated_data.content) + +import json + +# Load the JSON string into a Python object +json_object = json.loads(json_content) + +# Convert the Python object back to a JSON string +json_content = json.dumps(json_object, indent=2) + +# Print the JSON string +print(json_content) +``` + +Below is the output this produces + +```json +{ + "main_query": "How do we improve Nike's revenue in Q3 2024?", + "sub_queries": [ + { + "id": "1", + "query": "What is Nike's current revenue trend?" + }, + { + "id": "2", + "query": "What are the projected market trends for the sports apparel industry in 2024?" + }, + { + "id": "3", + "query": "What are the current successful strategies being used by Nike's competitors?", + "dependencies": [ + "2" + ] + }, + { + "id": "4", + "query": "What are the current and projected economic conditions in Nike's major markets?", + "dependencies": [ + "2" + ] + }, + { + "id": "5", + "query": "What are the current consumer preferences in the sports apparel industry?", + "dependencies": [ + "2" + ] + }, + { + "id": "6", + "query": "What are the potential areas of improvement in Nike's current business model?", + "dependencies": [ + "1" + ] + }, + { + "id": "7", + "query": "What are the potential new markets for Nike to explore in 2024?", + "dependencies": [ + "2", + "4" + ] + }, + { + "id": "8", + "query": "What are the potential new products or services Nike could introduce in 2024?", + "dependencies": [ + "5" + ] + }, + { + "id": "9", + "query": "What are the potential marketing strategies Nike could use to increase its revenue in Q3 2024?", + "dependencies": [ + "3", + "5", + "7", + "8" + ] + }, + { + "id": "10", + "query": "What are the potential cost-saving strategies Nike could implement to increase its net revenue in Q3 2024?", + "dependencies": [ + "6" + ] + } + ] +} +``` + +The JSON dictionary is not convenient for humans to process. We make a directed graph out of it. + +```python +import networkx as nx +import matplotlib.pyplot as plt +import textwrap +import random + +# Create a directed graph +G = nx.DiGraph() + +# Define a color map +color_map = {} + +# Add nodes and edges to the graph +for sub_query in json_object['sub_queries']: + # Check if 'dependencies' key exists in sub_query, if not, initialize it as an empty list + if 'dependencies' not in sub_query: + sub_query['dependencies'] = [] + # Assign a random color for each node + color_map[sub_query['id']] = "#{:06x}".format(random.randint(0, 0xFFFFFF)) + G.add_node(sub_query['id'], label=textwrap.fill(sub_query['query'], width=20)) + for dependency in sub_query['dependencies']: + G.add_edge(dependency, sub_query['id']) + +# Draw the graph +pos = nx.spring_layout(G) +nx.draw(G, pos, with_labels=True, node_size=800, node_color=[color_map[node] for node in G.nodes()], node_shape="o", alpha=0.5, linewidths=40) + +# Prepare labels for legend +labels = nx.get_node_attributes(G, 'label') +handles = [plt.Line2D([0], [0], marker='o', color=color_map[node], label=f"{node}: {label}", markersize=10, linestyle='None') for node, label in labels.items()] + +# Create a legend +plt.legend(handles=handles, title="Queries", bbox_to_anchor=(1.05, 1), loc='upper left') + +plt.show() +``` + +This produces the below diagram which makes the plan much more convenient to understand. + +![Query Plan Diagram](../assets/img/docs/query-plan.png) + +### Doing Background Research and Gathering Data + +At this point, we have solved the first half of the problem. We have an outline consisting of sub-problems to to tackled to solve our business problem. This will form the overall structure of our report. We now need to research information for each sub-problem in order to write an informed report. This mechanically intensive and is the aspect that will most benefit from Agentic intervention. + +Essentially, we can spawn parallel agents to gather the data. Each agent will have 2 tools: + +- Internet access +- Financial data retrieval + +As they run parallely, they will add their knowledge into a common long-term memory. We will then spawn a separate report writing agent with access to this memory to generate our business case report. + +#### Step 4. Defining Tools for Worker Agents + +Let us first define the 2 tools. + +```python +import os +from typing import List, Dict + +from swarms import tool + +os.environ['TAVILY_API_KEY'] = os.getenv('TAVILY_API_KEY') +os.environ["KAY_API_KEY"] = os.getenv('KAY_API_KEY') + +from langchain_community.tools.tavily_search import TavilySearchResults +from langchain_core.pydantic_v1 import BaseModel, Field + +from kay.rag.retrievers import KayRetriever + +@tool +def browser(query: str) -> str: + """ + Search the query in the browser with the Tavily API tool. + Args: + query (str): The query to search in the browser. + Returns: + str: The search results + """ + internet_search = TavilySearchResults() + results = internet_search.invoke({"query": query}) + response = '' + for result in results: + response += (result['content'] + '\n') + return response + +@tool +def kay_retriever(query: str) -> str: + """ + Search the financial data query with the KayAI API tool. + Args: + query (str): The query to search in the KayRetriever. + Returns: + str: The first context retrieved as a string. + """ + # Initialize the retriever + retriever = KayRetriever(dataset_id = "company", data_types=["10-K", "10-Q", "8-K", "PressRelease"]) + # Query the retriever + context = retriever.query(query=query,num_context=1) + return context[0]['chunk_embed_text'] +``` + +#### Step 5. Defining Long-Term Memory + +As mentioned previously, the worker agents running parallely, will pool their knowledge into a common memory. Let us define that. + +```python +import logging +import os +import uuid +from typing import Callable, List, Optional + +import chromadb +import numpy as np +from dotenv import load_dotenv + +from swarms.utils.data_to_text import data_to_text +from swarms.utils.markdown_message import display_markdown_message +from swarms.memory.base_vectordb import AbstractVectorDatabase + + +# Results storage using local ChromaDB +class ChromaDB(AbstractVectorDatabase): + """ + + ChromaDB database + + Args: + metric (str): The similarity metric to use. + output (str): The name of the collection to store the results in. + limit_tokens (int, optional): The maximum number of tokens to use for the query. Defaults to 1000. + n_results (int, optional): The number of results to retrieve. Defaults to 2. + + Methods: + add: _description_ + query: _description_ + + Examples: + >>> chromadb = ChromaDB( + >>> metric="cosine", + >>> output="results", + >>> llm="gpt3", + >>> openai_api_key=OPENAI_API_KEY, + >>> ) + >>> chromadb.add(task, result, result_id) + """ + + def __init__( + self, + metric: str = "cosine", + output_dir: str = "swarms", + limit_tokens: Optional[int] = 1000, + n_results: int = 3, + embedding_function: Callable = None, + docs_folder: str = None, + verbose: bool = False, + *args, + **kwargs, + ): + self.metric = metric + self.output_dir = output_dir + self.limit_tokens = limit_tokens + self.n_results = n_results + self.docs_folder = docs_folder + self.verbose = verbose + + # Disable ChromaDB logging + if verbose: + logging.getLogger("chromadb").setLevel(logging.INFO) + + # Create Chroma collection + chroma_persist_dir = "chroma" + chroma_client = chromadb.PersistentClient( + settings=chromadb.config.Settings( + persist_directory=chroma_persist_dir, + ), + *args, + **kwargs, + ) + + # Embedding model + if embedding_function: + self.embedding_function = embedding_function + else: + self.embedding_function = None + + # Create ChromaDB client + self.client = chromadb.Client() + + # Create Chroma collection + self.collection = chroma_client.get_or_create_collection( + name=output_dir, + metadata={"hnsw:space": metric}, + embedding_function=self.embedding_function, + # data_loader=self.data_loader, + *args, + **kwargs, + ) + display_markdown_message( + "ChromaDB collection created:" + f" {self.collection.name} with metric: {self.metric} and" + f" output directory: {self.output_dir}" + ) + + # If docs + if docs_folder: + display_markdown_message( + f"Traversing directory: {docs_folder}" + ) + self.traverse_directory() + + def add( + self, + document: str, + *args, + **kwargs, + ): + """ + Add a document to the ChromaDB collection. + + Args: + document (str): The document to be added. + condition (bool, optional): The condition to check before adding the document. Defaults to True. + + Returns: + str: The ID of the added document. + """ + try: + doc_id = str(uuid.uuid4()) + self.collection.add( + ids=[doc_id], + documents=[document], + *args, + **kwargs, + ) + print('-----------------') + print("Document added successfully") + print('-----------------') + return doc_id + except Exception as e: + raise Exception(f"Failed to add document: {str(e)}") + + def query( + self, + query_text: str, + *args, + **kwargs, + ): + """ + Query documents from the ChromaDB collection. + + Args: + query (str): The query string. + n_docs (int, optional): The number of documents to retrieve. Defaults to 1. + + Returns: + dict: The retrieved documents. + """ + try: + docs = self.collection.query( + query_texts=[query_text], + n_results=self.n_results, + *args, + **kwargs, + )["documents"] + return docs[0] + except Exception as e: + raise Exception(f"Failed to query documents: {str(e)}") + + def traverse_directory(self): + """ + Traverse through every file in the given directory and its subdirectories, + and return the paths of all files. + Parameters: + - directory_name (str): The name of the directory to traverse. + Returns: + - list: A list of paths to each file in the directory and its subdirectories. + """ + added_to_db = False + + for root, dirs, files in os.walk(self.docs_folder): + for file in files: + file = os.path.join(self.docs_folder, file) + _, ext = os.path.splitext(file) + data = data_to_text(file) + added_to_db = self.add([data]) + print(f"{file} added to Database") + + return added_to_db +``` + +We can now proceed to initialize the memory. + +```python +from chromadb.utils import embedding_functions +default_ef = embedding_functions.DefaultEmbeddingFunction() + +memory = ChromaDB( + metric="cosine", + n_results=3, + output_dir="results", + embedding_function=default_ef +) +``` + +#### Step 6. Defining Worker Agents + +The Worker Agent sub-classes the `Agent` class. The only different between these 2 is in how the `run()` method works. In the `Agent` class, `run()` simply returns the set of tool commands to run, but does not execute it. We, however, desire this. In addition, after we run our tools, we get the relevant information as output. We want to add this information to our memory. Hence, to incorporate these 2 changes, we define `WorkerAgent` as follows. + +```python +class WorkerAgent(Agent): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def run(self, task, *args, **kwargs): + response = super().run(task, *args, **kwargs) + print(response.content) + + json_dict = json.loads(process_json_output(response.content)) + + #print(json.dumps(json_dict, indent=2)) + + if response!=None: + try: + commands = json_dict["commands"] + except: + commands = [json_dict['command']] + + for command in commands: + tool_name = command["name"] + + if tool_name not in ['browser', 'kay_retriever']: + continue + + query = command["args"]["query"] + + # Get the tool by its name + tool = globals()[tool_name] + tool_response = tool(query) + + # Add tool's output to long term memory + self.long_term_memory.add(tool_response) +``` + +We can then instantiate an object of the `WorkerAgent` class. + +```python +worker_agent = WorkerAgent( + agent_name="Worker Agent", + system_prompt=( + "Autonomous agent that can interact with browser, " + "financial data retriever and other agents. Be Helpful " + "and Kind. Use the tools provided to assist the user. " + "Generate the plan with list of commands in JSON format." + ), + llm=OpenAIChat( + temperature=0.0, model_name="gpt-4", max_tokens=4000 +), + max_loops="auto", + autosave=True, + dashboard=False, + streaming_on=True, + verbose=True, + stopping_token="", + interactive=True, + tools=[browser, kay_retriever], + long_term_memory=memory, + code_interpreter=True, +) +``` + +#### Step 7. Running the Worker Agents + +At this point, we need to setup a concurrent workflow. While the order of adding tasks to the workflow doesn't matter (since they will all run concurrently late when executed), we can take some time to define an order for these tasks. This order will come in handy later when writing the report using our Writer Agent. + +The order we will follow is Breadth First Traversal (BFT) of the sub-queries in the graph we had made earlier (shown below again for reference). BFT makes sense to be used here because we want all the dependent parent questions to be answered before answering the child question. Also, since we could have independent subgraphs, we will also perform BFT separately on each subgraph. + +![Query Plan Mini](../assets/img/docs/query-plan-mini.png) + +Below is the code that produces the order of processing sub-queries. + +```python +from collections import deque, defaultdict + +# Define the graph nodes +nodes = json_object['sub_queries'] + +# Create a graph from the nodes +graph = defaultdict(list) +for node in nodes: + for dependency in node['dependencies']: + graph[dependency].append(node['id']) + +# Find all nodes with no dependencies (potential starting points) +start_nodes = [node['id'] for node in nodes if not node['dependencies']] + +# Adjust the BFT function to handle dependencies correctly +def bft_corrected(start, graph, nodes_info): + visited = set() + queue = deque([start]) + order = [] + + while queue: + node = queue.popleft() + if node not in visited: + # Check if all dependencies of the current node are visited + node_dependencies = [n['id'] for n in nodes if n['id'] == node][0] + dependencies_met = all(dep in visited for dep in nodes_info[node_dependencies]['dependencies']) + + if dependencies_met: + visited.add(node) + order.append(node) + # Add only nodes to the queue whose dependencies are fully met + for next_node in graph[node]: + if all(dep in visited for dep in nodes_info[next_node]['dependencies']): + queue.append(next_node) + else: + # Requeue the node to check dependencies later + queue.append(node) + + return order + +# Dictionary to access node information quickly +nodes_info = {node['id']: node for node in nodes} + +# Perform BFT for each unvisited start node using the corrected BFS function +visited_global = set() +bfs_order = [] + +for start in start_nodes: + if start not in visited_global: + order = bft_corrected(start, graph, nodes_info) + bfs_order.extend(order) + visited_global.update(order) + +print("BFT Order:", bfs_order) +``` + +This produces the following output. + +```python +BFT Order: ['1', '6', '10', '2', '3', '4', '5', '7', '8', '9'] +``` + +Now, let's define our `ConcurrentWorkflow` and run it. + +```python +import os +from dotenv import load_dotenv +from swarms import Agent, ConcurrentWorkflow, OpenAIChat, Task + +# Create a workflow +workflow = ConcurrentWorkflow(max_workers=5) +task_list = [] + +for node in bfs_order: + sub_query =nodes_info[node]['query'] + task = Task(worker_agent, sub_query) + print('-----------------') + print("Added task: ", sub_query) + print('-----------------') + task_list.append(task) + +workflow.add(tasks=task_list) + +# Run the workflow +workflow.run() +``` + +Below is part of the output this workflow produces. We clearly see the thought process of the agent and the plan it came up to solve a particular sub-query. In addition, we see the tool-calling schema it produces in `"command"`. + +```python +... +... +content='\n{\n "thoughts": {\n "text": "To find out Nike\'s current revenue trend, I will use the financial data retriever tool to search for \'Nike revenue trend\'.",\n "reasoning": "The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.", \n "plan": "Use the financial data retriever tool to search for \'Nike revenue trend\'. Parse the result to get the current revenue trend and format that into a readable report."\n },\n "command": {\n "name": "kay_retriever", \n "args": {\n "query": "Nike revenue trend"\n }\n }\n}\n```' response_metadata={'token_usage': {'completion_tokens': 152, 'prompt_tokens': 1527, 'total_tokens': 1679}, 'model_name': 'gpt-4', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None} +Saved agent state to: Worker Agent_state.json + +{ + "thoughts": { + "text": "To find out Nike's current revenue trend, I will use the financial data retriever tool to search for 'Nike revenue trend'.", + "reasoning": "The financial data retriever tool allows me to search for specific financial data, so I can look up the current revenue trend of Nike.", + "plan": "Use the financial data retriever tool to search for 'Nike revenue trend'. Parse the result to get the current revenue trend and format that into a readable report." + }, + "command": { + "name": "kay_retriever", + "args": { + "query": "Nike revenue trend" + } + } +} + +----------------- +Document added successfully +----------------- +... +... +``` + +Here, `"name"` pertains to the name of the tool to be called and `"args"` is the arguments to be passed to the tool call. Like mentioned before, we modify `Agent`'s default behaviour in `WorkerAgent`. Hence, the tool call is executed here and its results (information from web pages and Kay Retriever API) are added to long-term memory. We get confirmation for this from the message `Document added successfully`. + + +#### Step 7. Generating the report using Writer Agent + +At this point, our Worker Agents have gathered all the background information required to generate the report. We have also defined a coherent structure to write the report, which is following the BFT order to answering the sub-queries. Now it's time to define a Writer Agent and call it sequentially in the order of sub-queries. + +```python +from swarms import Agent, OpenAIChat, tool + +agent = Agent( + agent_name="Writer Agent", + agent_description=( + "This agent writes reports based on information in long-term memory" + ), + system_prompt=( + "You are a world-class financial report writer. " + "Write analytical and accurate responses using memory to answer the query. " + "Do not mention use of long-term memory in the report. " + "Do not mention Writer Agent in response." + "Return only response content in strict markdown format." + ), + llm=OpenAIChat(temperature=0.2, model='gpt-3.5-turbo'), + max_loops=1, + autosave=True, + verbose=True, + long_term_memory=memory, +) +``` + +The report individual sections of the report will be collected in a list. + +```python +report = [] +``` + +Let us now run the writer agent. + +```python +for node in bfs_order: + sub_query =nodes_info[node]['query'] + print("Running task: ", sub_query) + out = agent.run(f"Consider: {sub_query}. Write response in strict markdown format using long-term memory. Do not mention Writer Agent in response.") + print(out) + try: + report.append(out.content) + except: + pass +``` + +Now, we need to clean up the repoort a bit to make it render professionally. + +```python +# Remove any content before the first "#" as that signals start of heading +# Anything before this usually contains filler content +stripped_report = [entry[entry.find('#'):] if '#' in entry else entry for entry in report] +report = stripped_report + +# At times the LLM outputs \\n instead of \n +cleaned_report = [entry.replace("\\n", "\n") for entry in report] +import re + +# Function to clean up unnecessary metadata from the report entries +def clean_report(report): + cleaned_report = [] + for entry in report: + # This pattern matches 'response_metadata={' followed by any characters that are not '}' (non-greedy), + # possibly nested inside other braces, until the closing '}'. + cleaned_entry = re.sub(r"response_metadata=\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}", "", entry, flags=re.DOTALL) + cleaned_report.append(cleaned_entry) + return cleaned_report + +# Apply the cleaning function to the markdown report +cleaned_report = clean_report(cleaned_report) +``` + +After cleaning, we append parts of the report together to get out final report. + +```python +final_report = ' \n '.join(cleaned_report) +``` + +In Jupyter Notebook, we can use the below code to render it in Markdown. + +```python +from IPython.display import display, Markdown + +display(Markdown(final_report)) +``` + + +## Final Generated Report + + +### Nike's Current Revenue Trend + +Nike's current revenue trend has been steadily increasing over the past few years. In the most recent fiscal year, Nike reported a revenue of $37.4 billion, which was a 7% increase from the previous year. This growth can be attributed to strong sales in key markets, successful marketing campaigns, and a focus on innovation in product development. Overall, Nike continues to demonstrate strong financial performance and is well-positioned for future growth. + ### Potential Areas of Improvement in Nike's Business Model + +1. **Sustainability Practices**: Nike could further enhance its sustainability efforts by reducing its carbon footprint, using more eco-friendly materials, and ensuring ethical labor practices throughout its supply chain. + +2. **Diversification of Product Portfolio**: While Nike is known for its athletic footwear and apparel, diversifying into new product categories or expanding into untapped markets could help drive growth and mitigate risks associated with a single product line. + +3. **E-commerce Strategy**: Improving the online shopping experience, investing in digital marketing, and leveraging data analytics to personalize customer interactions could boost online sales and customer loyalty. + +4. **Innovation and R&D**: Continuously investing in research and development to stay ahead of competitors, introduce new technologies, and enhance product performance could help maintain Nike's competitive edge in the market. + +5. **Brand Image and Reputation**: Strengthening brand image through effective marketing campaigns, community engagement, and transparent communication with stakeholders can help build trust and loyalty among consumers. + ### Potential Cost-Saving Strategies for Nike to Increase Net Revenue in Q3 2024 + +1. **Supply Chain Optimization**: Streamlining the supply chain, reducing transportation costs, and improving inventory management can lead to significant cost savings for Nike. + +2. **Operational Efficiency**: Implementing lean manufacturing practices, reducing waste, and optimizing production processes can help lower production costs and improve overall efficiency. + +3. **Outsourcing Non-Core Functions**: Outsourcing non-core functions such as IT services, customer support, or logistics can help reduce overhead costs and focus resources on core business activities. + +4. **Energy Efficiency**: Investing in energy-efficient technologies, renewable energy sources, and sustainable practices can lower utility costs and demonstrate a commitment to environmental responsibility. + +5. **Negotiating Supplier Contracts**: Negotiating better terms with suppliers, leveraging economies of scale, and exploring alternative sourcing options can help lower procurement costs and improve margins. + +By implementing these cost-saving strategies, Nike can improve its bottom line and increase net revenue in Q3 2024. + ### Projected Market Trends for the Sports Apparel Industry in 2024 + +1. **Sustainable Fashion**: Consumers are increasingly demanding eco-friendly and sustainable products, leading to a rise in sustainable sportswear options in the market. + +2. **Digital Transformation**: The sports apparel industry is expected to continue its shift towards digital platforms, with a focus on e-commerce, personalized shopping experiences, and digital marketing strategies. + +3. **Athleisure Wear**: The trend of athleisure wear, which combines athletic and leisure clothing, is projected to remain popular in 2024 as consumers seek comfort and versatility in their apparel choices. + +4. **Innovative Materials**: Advances in technology and material science are likely to drive the development of innovative fabrics and performance-enhancing materials in sports apparel, catering to the demand for high-quality and functional products. + +5. **Health and Wellness Focus**: With a growing emphasis on health and wellness, sports apparel brands are expected to incorporate features that promote comfort, performance, and overall well-being in their products. + +Overall, the sports apparel industry in 2024 is anticipated to be characterized by sustainability, digitalization, innovation, and a focus on consumer health and lifestyle trends. + ### Current Successful Strategies Used by Nike's Competitors + +1. **Adidas**: Adidas has been successful in leveraging collaborations with celebrities and designers to create limited-edition collections that generate hype and drive sales. They have also focused on sustainability initiatives, such as using recycled materials in their products, to appeal to environmentally conscious consumers. + +2. **Under Armour**: Under Armour has differentiated itself by targeting performance-driven athletes and emphasizing technological innovation in their products. They have also invested heavily in digital marketing and e-commerce to reach a wider audience and enhance the customer shopping experience. + +3. **Puma**: Puma has successfully capitalized on the athleisure trend by offering stylish and versatile sportswear that can be worn both in and out of the gym. They have also focused on building partnerships with influencers and sponsoring high-profile athletes to increase brand visibility and credibility. + +4. **Lululemon**: Lululemon has excelled in creating a strong community around its brand, hosting events, classes, and collaborations to engage with customers beyond just selling products. They have also prioritized customer experience by offering personalized services and creating a seamless omnichannel shopping experience. + +5. **New Balance**: New Balance has carved out a niche in the market by emphasizing quality craftsmanship, heritage, and authenticity in their products. They have also focused on customization and personalization options for customers, allowing them to create unique and tailored footwear and apparel. + +Overall, Nike's competitors have found success through a combination of innovative product offerings, strategic marketing initiatives, and a focus on customer engagement and experience. + ### Current and Projected Economic Conditions in Nike's Major Markets + +1. **United States**: The United States, being one of Nike's largest markets, is currently experiencing moderate economic growth driven by consumer spending, low unemployment rates, and a rebound in manufacturing. However, uncertainties surrounding trade policies, inflation, and interest rates could impact consumer confidence and spending in the near future. + +2. **China**: China remains a key market for Nike, with a growing middle class and increasing demand for sportswear and athletic footwear. Despite recent trade tensions with the U.S., China's economy is projected to continue expanding, driven by domestic consumption, infrastructure investments, and technological advancements. + +3. **Europe**: Economic conditions in Europe vary across countries, with some experiencing sluggish growth due to Brexit uncertainties, political instability, and trade tensions. However, overall consumer confidence is improving, and the sports apparel market is expected to grow, driven by e-commerce and sustainability trends. + +4. **Emerging Markets**: Nike's presence in emerging markets such as India, Brazil, and Southeast Asia provides opportunities for growth, given the rising disposable incomes, urbanization, and increasing focus on health and fitness. However, challenges such as currency fluctuations, regulatory changes, and competition from local brands could impact Nike's performance in these markets. + +Overall, Nike's major markets exhibit a mix of opportunities and challenges, with economic conditions influenced by global trends, geopolitical factors, and consumer preferences." + ### Current Consumer Preferences in the Sports Apparel Industry + +1. **Sustainability**: Consumers are increasingly seeking eco-friendly and sustainable options in sports apparel, driving brands to focus on using recycled materials, reducing waste, and promoting ethical practices. + +2. **Athleisure**: The trend of athleisure wear continues to be popular, with consumers looking for versatile and comfortable clothing that can be worn both during workouts and in everyday life. + +3. **Performance and Functionality**: Consumers prioritize performance-enhancing features in sports apparel, such as moisture-wicking fabrics, breathable materials, and ergonomic designs that enhance comfort and mobility. + +4. **Personalization**: Customization options, personalized fit, and unique design elements are appealing to consumers who seek individuality and exclusivity in their sports apparel choices. + +5. **Brand Transparency**: Consumers value transparency in brand practices, including supply chain transparency, ethical sourcing, and clear communication on product quality and manufacturing processes. + +Overall, consumer preferences in the sports apparel industry are shifting towards sustainability, versatility, performance, personalization, and transparency, influencing brand strategies and product offerings. + ### Potential New Markets for Nike to Explore in 2024 + +1. **India**: With a growing population, increasing disposable incomes, and a rising interest in health and fitness, India presents a significant opportunity for Nike to expand its presence and tap into a large consumer base. + +2. **Africa**: The African market, particularly countries with emerging economies and a young population, offers potential for Nike to introduce its products and capitalize on the growing demand for sportswear and athletic footwear. + +3. **Middle East**: Countries in the Middle East, known for their luxury shopping destinations and a growing interest in sports and fitness activities, could be strategic markets for Nike to target and establish a strong foothold. + +4. **Latin America**: Markets in Latin America, such as Brazil, Mexico, and Argentina, present opportunities for Nike to cater to a diverse consumer base and leverage the region's passion for sports and active lifestyles. + +5. **Southeast Asia**: Rapid urbanization, increasing urban middle-class population, and a trend towards health and wellness in countries like Indonesia, Thailand, and Vietnam make Southeast Asia an attractive region for Nike to explore and expand its market reach. + +By exploring these new markets in 2024, Nike can diversify its geographical presence, reach untapped consumer segments, and drive growth in emerging economies. + ### Potential New Products or Services Nike Could Introduce in 2024 + +1. **Smart Apparel**: Nike could explore the integration of technology into its apparel, such as smart fabrics that monitor performance metrics, provide feedback, or enhance comfort during workouts. + +2. **Athletic Accessories**: Introducing a line of athletic accessories like gym bags, water bottles, or fitness trackers could complement Nike's existing product offerings and provide additional value to customers. + +3. **Customization Platforms**: Offering personalized design options for footwear and apparel through online customization platforms could appeal to consumers seeking unique and tailored products. + +4. **Athletic Recovery Gear**: Developing recovery-focused products like compression wear, recovery sandals, or massage tools could cater to athletes and fitness enthusiasts looking to enhance post-workout recovery. + +5. **Sustainable Collections**: Launching sustainable collections made from eco-friendly materials, recycled fabrics, or biodegradable components could align with consumer preferences for environmentally conscious products. + +By introducing these new products or services in 2024, Nike can innovate its product portfolio, cater to evolving consumer needs, and differentiate itself in the competitive sports apparel market. + ### Potential Marketing Strategies for Nike to Increase Revenue in Q3 2024 + +1. **Influencer Partnerships**: Collaborating with popular athletes, celebrities, or social media influencers to promote Nike products can help reach a wider audience and drive sales. + +2. **Interactive Campaigns**: Launching interactive marketing campaigns, contests, or events that engage customers and create buzz around new product releases can generate excitement and increase brand visibility. + +3. **Social Media Engagement**: Leveraging social media platforms to connect with consumers, share user-generated content, and respond to feedback can build brand loyalty and encourage repeat purchases. + +4. **Localized Marketing**: Tailoring marketing messages, promotions, and product offerings to specific regions or target demographics can enhance relevance and appeal to diverse consumer groups. + +5. **Customer Loyalty Programs**: Implementing loyalty programs, exclusive offers, or rewards for repeat customers can incentivize brand loyalty, increase retention rates, and drive higher lifetime customer value. + +By employing these marketing strategies in Q3 2024, Nike can enhance its brand presence, attract new customers, and ultimately boost revenue growth. + + + + + + + + + + + diff --git a/docs/assets/img/docs/query-plan-mini.png b/docs/assets/img/docs/query-plan-mini.png new file mode 100644 index 0000000000000000000000000000000000000000..e73e0e179210e5c03a75dce8e1a5ac14d3743fc6 GIT binary patch literal 125179 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 z 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

-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 z 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 z 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

7{f$~W0V9-DVYOcd`$#xNGpXbGIvt<$#( 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 M=9Xr)CLZy>1C_c>WB>pF literal 0 HcmV?d00001 From ad58b388ea577a4b69b6ee5fc6769253dd0d41c8 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 17:40:20 -0400 Subject: [PATCH 07/22] [FEAT][AgentRearrange] [DOCS][Swarms Cloud] [BUFG][Sequential Workflow] --- docs/mkdocs.yml | 2 + docs/swarms_cloud/available_models.md | 17 + docs/swarms_cloud/getting_started.md | 94 +++++ docs/swarms_cloud/main.md | 2 +- example.py | 14 +- new_tool_usage.py | 68 ++++ pyproject.toml | 2 +- scripts/log_cleanup.py | 10 +- sequential_workflow_new.py | 42 +- swarms/agents/worker_agent.py | 2 +- swarms/models/__init__.py | 4 +- swarms/models/popular_llms.py | 2 +- swarms/prompts/__init__.py | 2 - swarms/prompts/agent_system_prompts.py | 9 +- swarms/prompts/schema_generator.py | 214 ---------- swarms/prompts/worker_prompt.py | 70 ++-- swarms/structs/__init__.py | 4 +- swarms/structs/agent.py | 377 +++++++++-------- swarms/structs/agent_rearrange.py | 231 ----------- swarms/structs/base_swarm.py | 27 ++ swarms/structs/base_workflow.py | 9 - swarms/structs/rearrange.py | 313 +++++++++------ swarms/structs/sequential_workflow.py | 178 ++++---- swarms/structs/step.py | 2 +- swarms/structs/team.py | 106 ----- swarms/tools/__init__.py | 12 +- swarms/tools/base_tool.py | 379 ++++++++++++++++++ swarms/tools/exec_tool.py | 2 +- swarms/tools/openai_tool_creator_decorator.py | 316 ++++++++++++++- swarms/tools/pydantic_to_json.py | 10 +- swarms/tools/tool_utils.py | 2 +- tests/structs/test_agent_rearrange.py | 58 +++ 32 files changed, 1508 insertions(+), 1072 deletions(-) create mode 100644 docs/swarms_cloud/available_models.md create mode 100644 docs/swarms_cloud/getting_started.md create mode 100644 new_tool_usage.py delete mode 100644 swarms/prompts/schema_generator.py delete mode 100644 swarms/structs/agent_rearrange.py delete mode 100644 swarms/structs/team.py create mode 100644 swarms/tools/base_tool.py create mode 100644 tests/structs/test_agent_rearrange.py diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index ce3413ba..930e07ea 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -112,7 +112,9 @@ nav: - Docker Setup: docker_setup.md - Swarms Cloud API: - Overview: "swarms_cloud/main.md" + - Available Models: "swarms_cloud/available_models.md" - Migrate from OpenAI to Swarms in 3 lines of code: "swarms_cloud/migrate_openai.md" + - Getting Started with SOTA Vision Language Models VLM: "swarms_cloud/getting_started.md" - Swarms Framework [PY]: - Overview: "swarms/index.md" - DIY Build Your Own Agent: "diy_your_own_agent.md" diff --git a/docs/swarms_cloud/available_models.md b/docs/swarms_cloud/available_models.md new file mode 100644 index 00000000..ad108c82 --- /dev/null +++ b/docs/swarms_cloud/available_models.md @@ -0,0 +1,17 @@ +# Available Models + +```markdown +| Model Name | Description | Input Price | Output Price | Use Cases | +|-----------------------|---------------------------------------------------------------------------------------------------------|--------------|--------------|------------------------------------------------------------------------| +| **Llama3-70b** | Llama 3 is an auto-regressive language model that uses an optimized transformer architecture. | $0.80/1M Tokens | $1.60/1M Tokens | General natural language processing tasks. | +| **Llava-Internlm2-20b** | LLaVA model fine-tuned from InternLM2-Chat-20B and CLIP-ViT-Large-patch14-336. | Contact for pricing | Contact for pricing | Enhanced language understanding integrated with visual processing. | +| **Llama-3-Giraffe-70B** | Abacus.AI presents our longer-necked variant of Llama 3 70B! | $1/1M Tokens | $2/1M Tokens | Extensive natural language tasks with a focus on depth and efficiency. | +| **Qwen-vl** | Qwen VL for real-world multi-modal function calling. | $5/1M Tokens | $10/1M Tokens | Multi-modal interactions and function handling in complex environments.| +| **XComposer2-4khd-7b** | One of the highest performing VLMs (Video Language Models). | $4/1M Tokens | $8/1M Tokens | High-resolution video processing and understanding. | +| **Llava-Llama-3** | Llama3 with Multi-Modal Processing. | $5/1M Tokens | $10/1M Tokens | Advanced multi-modal scenarios involving language and image processing. | +| **cogvlm-chat-17b** | Groundbreaking multimodal model designed to understand and reason about visual elements in images. | $5/1M Tokens | $10/1M Tokens | Image-based chatbots and interactive systems. | +``` + + +## What models should we add? +[Book a call with us to learn more about your needs:](https://calendly.com/swarm-corp/30min) diff --git a/docs/swarms_cloud/getting_started.md b/docs/swarms_cloud/getting_started.md new file mode 100644 index 00000000..5fb114ac --- /dev/null +++ b/docs/swarms_cloud/getting_started.md @@ -0,0 +1,94 @@ +# Getting Started with State-of-the-Art Vision Language Models (VLMs) Using the Swarms API + +The intersection of vision and language tasks within the field of artificial intelligence has led to the emergence of highly sophisticated models known as Vision Language Models (VLMs). These models leverage the capabilities of both computer vision and natural language processing to provide a more nuanced understanding of multimodal inputs. In this blog post, we will guide you through the process of integrating state-of-the-art VLMs available through the Swarms API, focusing particularly on models like "internlm-xcomposer2-4khd", which represents a blend of high-performance language and visual understanding. + +#### What Are Vision Language Models? + +Vision Language Models are at the frontier of integrating visual data processing with text analysis. These models are trained on large datasets that include both images and their textual descriptions, learning to correlate visual elements with linguistic context. The result is a model that can not only recognize objects in an image but also generate descriptive, context-aware text, answer questions about the image, and even engage in a dialogue about its content. + +#### Why Use Swarms API for VLMs? + +Swarms API provides access to several cutting-edge VLMs including the "internlm-xcomposer2-4khd" model. This API is designed for developers looking to seamlessly integrate advanced multimodal capabilities into their applications without the need for extensive machine learning expertise or infrastructure. Swarms API is robust, scalable, and offers state-of-the-art models that are continuously updated to leverage the latest advancements in AI research. + +#### Prerequisites + +Before diving into the technical setup, ensure you have the following: +- An active account with Swarms API to obtain an API key. +- Python installed on your machine (Python 3.6 or later is recommended). +- An environment where you can install packages and run Python scripts (like Visual Studio Code, Jupyter Notebook, or simply your terminal). + +#### Setting Up Your Environment + +First, you'll need to install the `OpenAI` Python library if it's not already installed: + +```bash +pip install openai +``` + +#### Integrating the Swarms API + +Here’s a basic guide on how to set up the Swarms API in your Python environment: + +1. **API Key Configuration**: + Start by setting up your API key and base URL. Replace `"your_swarms_key"` with the actual API key you obtained from Swarms. + + ```python + from openai import OpenAI + + openai_api_key = "your_swarms_key" + openai_api_base = "https://api.swarms.world/v1" + ``` + +2. **Initialize Client**: + Initialize your OpenAI client with the provided API key and base URL. + + ```python + client = OpenAI( + api_key=openai_api_key, + base_url=openai_api_base, + ) + ``` + +3. **Creating a Chat Completion**: + To use the VLM, you’ll send a request to the API with a multimodal input consisting of both an image and a text query. The following example shows how to structure this request: + + ```python + chat_response = client.chat.completions.create( + model="internlm-xcomposer2-4khd", + messages=[ + { + "role": "user", + "content": [ + { + "type": "image_url", + "image_url": { + "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg", + }, + }, + {"type": "text", "text": "What's in this image?"}, + ] + } + ], + ) + print("Chat response:", chat_response) + ``` + + This code sends a multimodal query to the model, which includes an image URL followed by a text question regarding the image. + +#### Understanding the Response + +The response from the API will include details generated by the model about the image based on the textual query. This could range from simple descriptions to complex narratives, depending on the model’s capabilities and the nature of the question. + +#### Best Practices + +- **Data Privacy**: Always ensure that the images and data you use comply with privacy laws and regulations. +- **Error Handling**: Implement robust error handling to manage potential issues during API calls. +- **Model Updates**: Keep track of updates to the Swarms API and model improvements to leverage new features and improved accuracies. + +#### Conclusion + +Integrating VLMs via the Swarms API opens up a plethora of opportunities for developers to create rich, interactive, and intelligent applications that understand and interpret the world not just through text but through visuals as well. Whether you’re building an educational tool, a content management system, or an interactive chatbot, these models can significantly enhance the way users interact with your application. + +As you embark on your journey to integrate these powerful models into your projects, remember that the key to successful implementation lies in understanding the capabilities and limitations of the technology, continually testing with diverse data, and iterating based on user feedback and technological advances. + +Happy coding, and here’s to building more intelligent, multimodal applications! \ No newline at end of file diff --git a/docs/swarms_cloud/main.md b/docs/swarms_cloud/main.md index 49a59300..4d2a9bff 100644 --- a/docs/swarms_cloud/main.md +++ b/docs/swarms_cloud/main.md @@ -6,7 +6,7 @@ The AI Chat Completion API processes text and image inputs to generate conversat ## API Endpoints -### Chat Completion +### Chat Completion URL `https://api.swarms.world` diff --git a/example.py b/example.py index ea416785..1887ce63 100644 --- a/example.py +++ b/example.py @@ -1,14 +1,14 @@ -from swarms import Agent, Anthropic +from swarms import Agent, OpenAIChat -# Initialize the agemt +# Initialize the agent agent = Agent( agent_name="Transcript Generator", agent_description=( "Generate a transcript for a youtube video on what swarms" " are!" ), - llm=Anthropic(), - max_loops=3, + llm=OpenAIChat(), + max_loops="auto", autosave=True, dashboard=False, streaming_on=True, @@ -24,9 +24,3 @@ out = agent.run( "Generate a transcript for a youtube video on what swarms are!" ) print(out) - -# Save the state -check = agent.save_state( - "transcript_generator.json", - "Generate a transcript for a youtube video on what swarms are!", -) diff --git a/new_tool_usage.py b/new_tool_usage.py new file mode 100644 index 00000000..93834510 --- /dev/null +++ b/new_tool_usage.py @@ -0,0 +1,68 @@ +from pydantic import BaseModel, Field + +from swarms import Agent +from swarms.models.popular_llms import Anthropic +from swarms.tools.openai_tool_creator_decorator import tool + + +# Importing the search API tool +@tool +def search_api(query: str) -> str: + """ + This tool searches the web for information about COVID-19 symptoms. + """ + return f"Search API tool called with query: {query}" + + +print(search_api("COVID-19 symptoms")) + + +# Initialize the schema for the person's information +class Schema(BaseModel): + name: str = Field(..., title="Name of the person") + agent: int = Field(..., title="Age of the person") + is_student: bool = Field(..., title="Whether the person is a student") + courses: list[str] = Field( + ..., title="List of courses the person is taking" + ) + + +# Convert the schema to a JSON string +tool_schema = Schema( + name="Tool Name", + agent=1, + is_student=True, + courses=["Course1", "Course2"], +) + +# Define the task to generate a person's information +task = "Generate a person's information based on the following schema:" + +# Initialize the agent +agent = Agent( + agent_name="WeatherMan Agent", + # Set the tool schema to the JSON string -- this is the key difference + tool_schema=tool_schema, + llm=Anthropic(), + max_loops=3, + autosave=True, + dashboard=False, + streaming_on=True, + tools=[], # or list of tools + verbose=True, + interactive=True, + # Set the output type to the tool schema which is a BaseModel + output_type=tool_schema, # or dict, or str + metadata_output_type="json", + # List of schemas that the agent can handle + list_tool_schemas=[tool_schema], + function_calling_format_type="OpenAI", + function_calling_type="json", # or soon yaml + execute_tool=True, +) + +# Run the agent to generate the person's information +generated_data = agent.run(task) + +# Print the generated data +print(f"Generated data: {generated_data}") diff --git a/pyproject.toml b/pyproject.toml index 35971787..7ad13b11 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api" [tool.poetry] name = "swarms" -version = "4.8.8" +version = "4.9.2" description = "Swarms - Pytorch" license = "MIT" authors = ["Kye Gomez "] diff --git a/scripts/log_cleanup.py b/scripts/log_cleanup.py index 368ceb63..3276d41f 100644 --- a/scripts/log_cleanup.py +++ b/scripts/log_cleanup.py @@ -2,8 +2,8 @@ import os import shutil # Create a new directory for the log files if it doesn't exist -if not os.path.exists("artifacts_two"): - os.makedirs("artifacts_two") +if not os.path.exists("artifacts_three"): + os.makedirs("artifacts_three") # Walk through the current directory for dirpath, dirnames, filenames in os.walk("."): @@ -12,10 +12,10 @@ for dirpath, dirnames, filenames in os.walk("."): if filename.endswith(".log"): # Construct the full file path file_path = os.path.join(dirpath, filename) - # Move the log file to the 'artifacts_two' directory - shutil.move(file_path, "artifacts_two") + # Move the log file to the 'artifacts_three' directory + shutil.move(file_path, "artifacts_three") print( - "Moved all log files into the 'artifacts_two' directory and" + "Moved all log files into the 'artifacts_three' directory and" " deleted their original location." ) diff --git a/sequential_workflow_new.py b/sequential_workflow_new.py index 0a706a61..81ea3074 100644 --- a/sequential_workflow_new.py +++ b/sequential_workflow_new.py @@ -1,41 +1,33 @@ -from swarms import Anthropic, Agent, SequentialWorkflow +from swarms import Agent, SequentialWorkflow, Anthropic # Initialize the language model agent (e.g., GPT-3) - llm = Anthropic() - # Initialize agents for individual tasks - agent1 = Agent( - agent_name="Blog generator", llm=llm, max_loops=1, dashboard=False + agent_name="Blog generator", + system_prompt="Generate a blog post like stephen king", + llm=llm, + max_loops=1, + dashboard=False, + tools=[], ) - agent2 = Agent( - agent_name="summarizer", llm=llm, max_loops=1, dashboard=False + agent_name="summarizer", + system_prompt="Sumamrize the blog post", + llm=llm, + max_loops=1, + dashboard=False, + tools=[], ) - # Create the Sequential workflow - workflow = SequentialWorkflow( - max_loops=1, objective="Create a full blog and then summarize it" + agents=[agent1, agent2], max_loops=1, verbose=False ) - -# Add tasks to the workflow - -workflow.add( - "Generate a 10,000 word blog on health and wellness.", agent1 -) # this task will be executed task, - -workflow.add( - "Summarize the generated blog", agent2 -) # then the next agent will accomplish this task - - # Run the workflow - -out = workflow.run() -print(f"{out}") +workflow.run( + "Generate a blog post on how swarms of agents can help businesses grow." +) diff --git a/swarms/agents/worker_agent.py b/swarms/agents/worker_agent.py index 4331096b..1176e0a8 100644 --- a/swarms/agents/worker_agent.py +++ b/swarms/agents/worker_agent.py @@ -3,7 +3,7 @@ from typing import List from langchain_experimental.autonomous_agents import AutoGPT from swarms.structs.agent import Agent -from swarms.tools.tool import BaseTool +from swarms.tools.base_tool import BaseTool from swarms.utils.decorators import error_decorator, timing_decorator diff --git a/swarms/models/__init__.py b/swarms/models/__init__.py index 27d31937..b473b9a9 100644 --- a/swarms/models/__init__.py +++ b/swarms/models/__init__.py @@ -15,9 +15,7 @@ from swarms.models.mpt import MPT7B # noqa: E402 from swarms.models.nougat import Nougat # noqa: E402 from swarms.models.palm import GooglePalm as Palm # noqa: E402 from swarms.models.openai_tts import OpenAITTS # noqa: E402 -from swarms.models.popular_llms import ( - AnthropicChat as Anthropic, -) +from swarms.models.popular_llms import Anthropic as Anthropic from swarms.models.popular_llms import ( AzureOpenAILLM as AzureOpenAI, ) diff --git a/swarms/models/popular_llms.py b/swarms/models/popular_llms.py index 61f2ca07..a574b0da 100644 --- a/swarms/models/popular_llms.py +++ b/swarms/models/popular_llms.py @@ -12,7 +12,7 @@ from langchain_community.llms.octoai_endpoint import OctoAIEndpoint from langchain.llms.replicate import Replicate -class AnthropicChat(Anthropic): +class Anthropic(Anthropic): def __call__(self, *args, **kwargs): return self.invoke(*args, **kwargs) diff --git a/swarms/prompts/__init__.py b/swarms/prompts/__init__.py index edec5906..d8a1dae9 100644 --- a/swarms/prompts/__init__.py +++ b/swarms/prompts/__init__.py @@ -7,7 +7,6 @@ from swarms.prompts.operations_agent_prompt import ( OPERATIONS_AGENT_PROMPT, ) from swarms.prompts.product_agent_prompt import PRODUCT_AGENT_PROMPT -from swarms.prompts.schema_generator import SchemaGenerator __all__ = [ "CODE_INTERPRETER", @@ -17,5 +16,4 @@ __all__ = [ "OPERATIONS_AGENT_PROMPT", "PRODUCT_AGENT_PROMPT", "DOCUMENTATION_WRITER_SOP", - "SchemaGenerator", ] diff --git a/swarms/prompts/agent_system_prompts.py b/swarms/prompts/agent_system_prompts.py index 6e95a611..8872ad3b 100644 --- a/swarms/prompts/agent_system_prompts.py +++ b/swarms/prompts/agent_system_prompts.py @@ -4,7 +4,7 @@ from swarms.prompts.tools import ( ) # PROMPTS -FLOW_SYSTEM_PROMPT_v2 = """ +AGENT_SYSTEM_PROMPT_V2 = """ You are an elite autonomous agent operating within an autonomous loop structure. Your primary function is to reliably complete user's tasks. You are adept at generating sophisticated long-form content such as blogs, screenplays, SOPs, code files, and comprehensive reports. @@ -18,7 +18,6 @@ You are programmed to follow these rules: 4. Ignore context length and text limits, REMEMBER YOU ARE AN ELITE AUTONOMOUS AGENT and can continue where you left off. 5. If the user doesn't specify an output format, intelligently select the best output format based on the task. -Take a deep breath. """ @@ -67,15 +66,13 @@ def agent_system_prompt_2_v2(name: str): # ORIGINAL PROMPTS -FLOW_SYSTEM_PROMPT = """ +AGENT_SYSTEM_PROMPT_V1 = """ You are an autonomous agent granted autonomy in a autonomous loop structure. Your role is to engage in multi-step conversations with your self or the user, -generate long-form content like blogs, screenplays, or SOPs, -and accomplish tasks bestowed by the user. +generate long-form content like blogs, screenplays and accomplish tasks set by the user. You can have internal dialogues with yourself or can interact with the user to aid in these complex tasks. Your responses should be coherent, contextually relevant, and tailored to the task at hand. - """ diff --git a/swarms/prompts/schema_generator.py b/swarms/prompts/schema_generator.py deleted file mode 100644 index 4213d0d6..00000000 --- a/swarms/prompts/schema_generator.py +++ /dev/null @@ -1,214 +0,0 @@ -import json -from typing import List - -from swarms.tools.tool import BaseTool - -FINISH_NAME = "finish" - - -class SchemaGenerator: - """A class for generating custom prompt strings. - - Does this based on constraints, commands, resources, and performance evaluations. - - Attributes: - constraints (List[str]): A list of constraints. - commands (List[BaseTool]): A list of commands. - resources (List[str]): A list of resources. - performance_evaluation (List[str]): A list of performance evaluations. - response_format (dict): A dictionary of the response format. - - Examples: - >>> schema_generator = SchemaGenerator() - >>> schema_generator.add_constraint("No user assistance") - >>> schema_generator.add_resource("Internet access for searches and information gathering.") - >>> schema_generator.add_performance_evaluation("Continuously review and analyze your actions to ensure you are performing to the best of your abilities.") - >>> prompt_string = schema_generator.generate_prompt_string() - >>> print(prompt_string) - """ - - def __init__(self) -> None: - """Initialize the SchemaGenerator object. - - Starts with empty lists of constraints, commands, resources, - and performance evaluations. - """ - self.constraints: List[str] = [] - self.commands: List[BaseTool] = [] - self.resources: List[str] = [] - self.performance_evaluation: List[str] = [] - self.response_format = { - "thoughts": { - "text": "thought", - "reasoning": "reasoning", - "plan": ( - "- short bulleted\n- list that conveys\n-" - " long-term plan" - ), - "criticism": "constructive self-criticism", - "speak": "thoughts summary to say to user", - }, - "command": { - "name": "command name", - "args": {"arg name": "value"}, - }, - } - - def add_constraint(self, constraint: str) -> None: - """ - Add a constraint to the constraints list. - - Args: - constraint (str): The constraint to be added. - """ - self.constraints.append(constraint) - - def add_tool(self, tool: BaseTool) -> None: - self.commands.append(tool) - - def _generate_command_string(self, tool: BaseTool) -> str: - output = f"{tool.name}: {tool.description}" - output += f", args json schema: {json.dumps(tool.args)}" - return output - - def add_resource(self, resource: str) -> None: - """ - Add a resource to the resources list. - - Args: - resource (str): The resource to be added. - """ - self.resources.append(resource) - - def add_performance_evaluation(self, evaluation: str) -> None: - """ - Add a performance evaluation item to the performance_evaluation list. - - Args: - evaluation (str): The evaluation item to be added. - """ - self.performance_evaluation.append(evaluation) - - def _generate_numbered_list( - self, items: list, item_type: str = "list" - ) -> str: - """ - Generate a numbered list from given items based on the item_type. - - Args: - items (list): A list of items to be numbered. - item_type (str, optional): The type of items in the list. - Defaults to 'list'. - - Returns: - str: The formatted numbered list. - """ - if item_type == "command": - command_strings = [ - f"{i + 1}. {self._generate_command_string(item)}" - for i, item in enumerate(items) - ] - finish_description = ( - "use this to signal that you have finished all your" - " objectives" - ) - finish_args = ( - '"response": "final response to let ' - 'people know you have finished your objectives"' - ) - finish_string = ( - f"{len(items) + 1}. {FINISH_NAME}: " - f"{finish_description}, args: {finish_args}" - ) - return "\n".join(command_strings + [finish_string]) - else: - return "\n".join( - f"{i+1}. {item}" for i, item in enumerate(items) - ) - - def generate_prompt_string(self) -> str: - """Generate a prompt string. - - Returns: - str: The generated prompt string. - """ - formatted_response_format = json.dumps( - self.response_format, indent=4 - ) - prompt_string = ( - f"Constraints:\n{self._generate_numbered_list(self.constraints)}\n\nCommands:\n{self._generate_numbered_list(self.commands, item_type='command')}\n\nResources:\n{self._generate_numbered_list(self.resources)}\n\nPerformance" - f" Evaluation:\n{self._generate_numbered_list(self.performance_evaluation)}\n\nYou" - " should only respond in JSON format as described below" - " \nResponse Format:" - f" \n{formatted_response_format} \nEnsure the response" - " can be parsed by Python json.loads" - ) - - return prompt_string - - -def get_prompt(tools: List[BaseTool]) -> str: - """Generates a prompt string. - - It includes various constraints, commands, resources, and performance evaluations. - - Returns: - str: The generated prompt string. - """ - - # Initialize the SchemaGenerator object - schema_generator = SchemaGenerator() - - # Add constraints to the SchemaGenerator object - schema_generator.add_constraint( - "~4000 word limit for short term memory. " - "Your short term memory is short, " - "so immediately save important information to files." - ) - schema_generator.add_constraint( - "If you are unsure how you previously did something " - "or want to recall past events, " - "thinking about similar events will help you remember." - ) - schema_generator.add_constraint("No user assistance") - schema_generator.add_constraint( - "Exclusively use the commands listed in double quotes e.g." - ' "command name"' - ) - - # Add commands to the SchemaGenerator object - for tool in tools: - schema_generator.add_tool(tool) - - # Add resources to the SchemaGenerator object - schema_generator.add_resource( - "Internet access for searches and information gathering." - ) - schema_generator.add_resource("Long Term memory management.") - schema_generator.add_resource( - "GPT-3.5 powered Agents for delegation of simple tasks." - ) - schema_generator.add_resource("File output.") - - # Add performance evaluations to the SchemaGenerator object - schema_generator.add_performance_evaluation( - "Continuously review and analyze your actions " - "to ensure you are performing to the best of your abilities." - ) - schema_generator.add_performance_evaluation( - "Constructively self-criticize your big-picture behavior" - " constantly." - ) - schema_generator.add_performance_evaluation( - "Reflect on past decisions and strategies to refine your" - " approach." - ) - schema_generator.add_performance_evaluation( - "Every command has a cost, so be smart and efficient. " - "Aim to complete tasks in the least number of steps." - ) - - # Generate the prompt string - prompt_string = schema_generator.generate_prompt_string() - - return prompt_string diff --git a/swarms/prompts/worker_prompt.py b/swarms/prompts/worker_prompt.py index bfb393c2..f9eac940 100644 --- a/swarms/prompts/worker_prompt.py +++ b/swarms/prompts/worker_prompt.py @@ -1,8 +1,9 @@ import datetime from pydantic import BaseModel, Field -from swarms.tools.tool import BaseTool +from swarms.tools.base_tool import BaseTool from swarms.tools.tool_utils import scrape_tool_func_docs from typing import List +from swarms.tools.base_tool import BaseTool time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") @@ -15,7 +16,7 @@ class Thoughts(BaseModel): class Command(BaseModel): name: str = Field(..., title="Command Name") - args: dict = Field({}, title="Command Arguments") + parameters: dict = Field({}, title="Command Arguments") class ResponseFormat(BaseModel): @@ -30,14 +31,9 @@ tool_usage_browser = """ ```json { - "thoughts": { - "text": "To check the weather in Miami, I will use the browser tool to search for 'Miami weather'.", - "reasoning": "The browser tool allows me to search the web, so I can look up the current weather conditions in Miami.", - "plan": "Use the browser tool to search Google for 'Miami weather'. Parse the result to get the current temperature, conditions, etc. and format that into a readable weather report." - }, - "command": { + "functions": { "name": "browser", - "args": { + "parameters": { "query": "Miami weather" } } @@ -50,14 +46,9 @@ tool_usage_terminal = """ ```json { - "thoughts": { - "text": "To check the weather in Miami, I will use the browser tool to search for 'Miami weather'.", - "reasoning": "The browser tool allows me to search the web, so I can look up the current weather conditions in Miami.", - "plan": "Use the browser tool to search Google for 'Miami weather'. Parse the result to get the current temperature, conditions, etc. and format that into a readable weather report." - }, - "command": { + "functions": { "name": "terminal", - "args": { + "parameters": { "code": "uptime" } } @@ -69,22 +60,16 @@ tool_usage_terminal = """ browser_and_terminal_tool = """ ``` -{ - "thoughts": { - "text": "To analyze the latest stock market trends, I need to fetch current stock data and then process it using a script.", - "reasoning": "Using the browser tool to retrieve stock data ensures I have the most recent information. Following this, the terminal tool can run a script that analyzes this data to identify trends.", - "plan": "First, use the browser to get the latest stock prices. Then, use the terminal to execute a data analysis script on the fetched data." - }, - "commands": [ + "functions": [ { "name": "browser", - "args": { + "parameters": { "query": "download latest stock data for NASDAQ" } }, { "name": "terminal", - "args": { + "parameters": { "cmd": "python analyze_stocks.py" } } @@ -98,27 +83,22 @@ browser_and_terminal_tool = """ browser_and_terminal_tool_two = """ ``` { - "thoughts": { - "text": "To prepare a monthly budget report, I need current expenditure data, process it, and calculate the totals and averages.", - "reasoning": "The browser will fetch the latest expenditure data. The terminal will run a processing script to organize the data, and the calculator will be used to sum up expenses and compute averages.", - "plan": "Download the data using the browser, process it with a terminal command, and then calculate totals and averages using the calculator." - }, - "commands": [ + "functions": [ { "name": "browser", - "args": { + "parameters": { "query": "download monthly expenditure data" } }, { "name": "terminal", - "args": { + "parameters": { "cmd": "python process_expenditures.py" } }, { "name": "calculator", - "args": { + "parameters": { "operation": "sum", "numbers": "[output_from_process_expenditures]" } @@ -142,12 +122,16 @@ def parse_tools(tools: List[BaseTool] = []): # Function to generate the worker prompt def tool_usage_worker_prompt( - current_time=time, tools: List[BaseTool] = [] + current_time=time, tools: List[callable] = [] ): - tool_docs = parse_tools(tools) + tool_docs = BaseTool(verbose=True, functions=tools) prompt = f""" **Date and Time**: {current_time} + + You have been assigned a task that requires the use of various tools to gather information and execute commands. + Follow the instructions provided to complete the task effectively. This SOP is designed to guide you through the structured and effective use of tools. + By adhering to this protocol, you will enhance your productivity and accuracy in task execution. ### Constraints - Only use the tools as specified in the instructions. @@ -167,23 +151,23 @@ def tool_usage_worker_prompt( 1. **Browser** - **Purpose**: To retrieve information from the internet. - **Usage**: - - `{{"name": "browser", "args": {{"query": "search query here"}}}}` + - `{{"name": "browser", "parameters": {{"query": "search query here"}}}}` - Example: Fetch current weather in London. - - Command: `{{"name": "browser", "args": {{"query": "London weather"}}}}` + - Command: `{{"name": "browser", "parameters": {{"query": "London weather"}}}}` 2. **Terminal** - **Purpose**: To execute system commands. - **Usage**: - - `{{"name": "terminal", "args": {{"cmd": "system command here"}}}}` + - `{{"name": "terminal", "parameters": {{"cmd": "system command here"}}}}` - Example: Check disk usage on a server. - - Command: `{{"name": "terminal", "args": {{"cmd": "df -h"}}}}` + - Command: `{{"name": "terminal", "parameters": {{"cmd": "df -h"}}}}` 3. **Custom Tool** (if applicable) - **Purpose**: Describe specific functionality. - **Usage**: - - `{{"name": "custom_tool", "args": {{"parameter": "value"}}}}` + - `{{"name": "custom_tool", "parameters": {{"parameter": "value"}}}}` - Example: Custom analytics tool. - - Command: `{{"name": "custom_tool", "args": {{"data": "analyze this data"}}}}` + - Command: `{{"name": "custom_tool", "parameters": {{"data": "analyze this data"}}}}` ### Usage Examples @@ -221,8 +205,6 @@ def tool_usage_worker_prompt( {tool_docs} - This SOP is designed to guide you through the structured and effective use of tools. - By adhering to this protocol, you will enhance your productivity and accuracy in task execution. """ return prompt diff --git a/swarms/structs/__init__.py b/swarms/structs/__init__.py index 6da5bfdb..0707263e 100644 --- a/swarms/structs/__init__.py +++ b/swarms/structs/__init__.py @@ -75,7 +75,7 @@ from swarms.structs.utils import ( find_token_in_text, parse_tasks, ) -from swarms.structs.agent_rearrange import AgentRearrange +from swarms.structs.rearrange import AgentRearrange, rearrange from swarms.structs.yaml_model import ( get_type_name, @@ -109,7 +109,6 @@ __all__ = [ "MultiAgentCollaboration", "MultiProcessWorkflow", "MultiThreadedWorkflow", - "NonlinearWorkflow", "Plan", "RecursiveWorkflow", "Artifact", @@ -156,4 +155,5 @@ __all__ = [ "pydantic_type_to_yaml_schema", "YamlModel", "MessagePool", + "rearrange" ] diff --git a/swarms/structs/agent.py b/swarms/structs/agent.py index 5eb987c8..b5f7e7ec 100644 --- a/swarms/structs/agent.py +++ b/swarms/structs/agent.py @@ -1,4 +1,5 @@ import asyncio +import concurrent.futures import json import logging import os @@ -7,7 +8,6 @@ import sys import time import uuid from typing import Any, Callable, Dict, List, Optional, Tuple, Union - import yaml from loguru import logger from pydantic import BaseModel @@ -15,25 +15,23 @@ from termcolor import colored from swarms.memory.base_vectordb import BaseVectorDatabase from swarms.prompts.agent_system_prompts import AGENT_SYSTEM_PROMPT_3 +from swarms.prompts.aot_prompt import algorithm_of_thoughts_sop from swarms.prompts.multi_modal_autonomous_instruction_prompt import ( MULTI_MODAL_AUTO_AGENT_SYSTEM_PROMPT_1, ) from swarms.prompts.worker_prompt import tool_usage_worker_prompt from swarms.structs.conversation import Conversation -from swarms.structs.schemas import ManySteps, Step from swarms.structs.yaml_model import YamlModel from swarms.telemetry.user_utils import get_user_device_data +from swarms.tools.base_tool import BaseTool from swarms.tools.code_interpreter import SubprocessCodeInterpreter -from swarms.tools.exec_tool import execute_tool_by_name from swarms.tools.pydantic_to_json import ( base_model_to_openai_function, multi_base_model_to_openai_function, ) -from swarms.tools.tool import BaseTool from swarms.utils.data_to_text import data_to_text from swarms.utils.parse_code import extract_code_from_markdown from swarms.utils.pdf_to_text import pdf_to_text -from swarms.prompts.aot_prompt import algorithm_of_thoughts_sop # Utils @@ -183,7 +181,7 @@ class Agent: agent_name: Optional[str] = "swarm-worker-01", agent_description: Optional[str] = None, system_prompt: Optional[str] = AGENT_SYSTEM_PROMPT_3, - tools: List[BaseTool] = [], + tools: List[BaseTool] = None, dynamic_temperature_enabled: Optional[bool] = False, sop: Optional[str] = None, sop_list: Optional[List[str]] = None, @@ -213,27 +211,34 @@ class Agent: logger_handler: Optional[Any] = sys.stderr, search_algorithm: Optional[Callable] = None, logs_to_filename: Optional[str] = None, - evaluator: Optional[Callable] = None, + evaluator: Optional[Callable] = None, # Custom LLM or agent output_json: Optional[bool] = False, stopping_func: Optional[Callable] = None, custom_loop_condition: Optional[Callable] = None, - sentiment_threshold: Optional[float] = None, + sentiment_threshold: Optional[ + float + ] = None, # Evaluate on output using an external model custom_exit_command: Optional[str] = "exit", sentiment_analyzer: Optional[Callable] = None, limit_tokens_from_string: Optional[Callable] = None, + # [Tools] custom_tools_prompt: Optional[Callable] = None, tool_schema: ToolUsageType = None, output_type: agent_output_type = None, function_calling_type: str = "json", output_cleaner: Optional[Callable] = None, function_calling_format_type: Optional[str] = "OpenAI", - list_tool_schemas: Optional[List[BaseModel]] = None, + list_base_models: Optional[List[BaseModel]] = None, metadata_output_type: str = "json", state_save_file_type: str = "json", chain_of_thoughts: bool = False, algorithm_of_thoughts: bool = False, tree_of_thoughts: bool = False, tool_choice: str = "auto", + execute_tool: bool = False, + rules: str = None, + planning: Optional[str] = False, + planning_prompt: Optional[str] = None, *args, **kwargs, ): @@ -299,13 +304,26 @@ class Agent: self.function_calling_type = function_calling_type self.output_cleaner = output_cleaner self.function_calling_format_type = function_calling_format_type - self.list_tool_schemas = list_tool_schemas + self.list_base_models = list_base_models self.metadata_output_type = metadata_output_type self.state_save_file_type = state_save_file_type self.chain_of_thoughts = chain_of_thoughts self.algorithm_of_thoughts = algorithm_of_thoughts self.tree_of_thoughts = tree_of_thoughts self.tool_choice = tool_choice + self.execute_tool = execute_tool + self.planning = planning + self.planning_prompt = planning_prompt + + # Name + self.name = agent_name + + # Description + self.description = agent_description + # Agentic stuff + self.reply = "" + self.question = None + self.answer = "" # The max_loops will be set dynamically if the dynamic_loop if self.dynamic_loops: @@ -319,22 +337,33 @@ class Agent: # If the user inputs a list of strings for the sop then join them and set the sop if self.sop_list: self.sop = "\n".join(self.sop_list) + self.short_memory.add(role=self.user_name, content=self.sop) + + if self.sop is not None: + self.short_memory.add(role=self.user_name, content=self.sop) # Memory self.feedback = [] # Initialize the code executor - self.code_executor = SubprocessCodeInterpreter( - debug_mode=True, - ) + if self.code_interpreter is not False: + self.code_executor = SubprocessCodeInterpreter( + debug_mode=True, + ) # If the preset stopping token is enabled then set the stopping token to the preset stopping token if preset_stopping_token is not None: self.stopping_token = "" - # If the stopping function is provided then set the stopping condition to the stopping function + # If the system prompt is provided then set the system prompt + # Initialize the short term memory self.short_memory = Conversation( - system_prompt=system_prompt, time_enabled=True, *args, **kwargs + system_prompt=system_prompt, + time_enabled=True, + user=user_name, + rules=rules, + *args, + **kwargs, ) # If the docs exist then ingest the docs @@ -353,16 +382,25 @@ class Agent: # if verbose: # logger.setLevel(logging.INFO) + if tools is not None: + self.tool_executor = BaseTool( + verbose=True, + auto_execute_tool=execute_tool, + functions=tools, + ) + # If tools are provided then set the tool prompt by adding to sop - if self.tools: + if self.tools is not None: if custom_tools_prompt is not None: tools_prompt = custom_tools_prompt(tools=self.tools) + # Append the tools prompt to the short_term_memory self.short_memory.add( role=self.agent_name, content=tools_prompt ) else: + # Default tool prompt tools_prompt = tool_usage_worker_prompt(tools=self.tools) # Append the tools prompt to the short_term_memory @@ -370,19 +408,6 @@ class Agent: role=self.agent_name, content=tools_prompt ) - # If the long term memory is provided then set the long term memory prompt - - # Agentic stuff - self.reply = "" - self.question = None - self.answer = "" - - # Initialize the llm with the conditional variables - # self.llm = llm(*args, **kwargs) - - # Step cache - self.step_cache = [] - # Set the logger handler if logger_handler: logger.add( @@ -396,43 +421,52 @@ class Agent: # logger.info("Creating Agent {}".format(self.agent_name)) - # If the tool types + # If the tool types are provided if self.tool_schema is not None: - logger.info("Tool schema provided") - tool_schema_str = self.tool_schema_to_str(self.tool_schema) - - print(tool_schema_str) - - # Add to the short memory - logger.info(f"Adding tool schema to memory: {tool_schema_str}") + # Log the tool schema + logger.info( + "Tool schema provided, Automatically converting to OpenAI function" + ) + tool_schema_str = self.pydantic_model_to_json_str( + self.tool_schema, indent=4 + ) + logger.info(f"Tool Schema: {tool_schema_str}") + # Add the tool schema to the short memory self.short_memory.add( role=self.user_name, content=tool_schema_str ) - # If a list of tool schemas: - if self.list_tool_schemas is not None: - logger.info("Tool schema provided") - tool_schema_str = self.tool_schemas_to_str(list_tool_schemas) + # If a list of tool schemas is provided + if self.list_base_models is not None: + logger.info( + "List of tool schemas provided, Automatically converting to OpenAI function" + ) + tool_schemas = multi_base_model_to_openai_function( + self.list_base_models + ) + + # Convert the tool schemas to a string + tool_schemas = json.dumps(tool_schemas, indent=4) - # Add to the short memory - logger.info(f"Adding tool schema to memory: {tool_schema_str}") + # Add the tool schema to the short memory + logger.info("Adding tool schema to short memory") self.short_memory.add( role=self.user_name, content=tool_schema_str ) - # Name - self.name = agent_name - - # Description - self.description = agent_description - # If the algorithm of thoughts is enabled then set the sop to the algorithm of thoughts - if self.algorithm_of_thoughts is not None: + if self.algorithm_of_thoughts is not False: self.short_memory.add( role=self.agent_name, content=algorithm_of_thoughts_sop(objective=self.task), ) + # Return the history + if return_history is True: + logger.info(f"Beginning of Agent {self.agent_name} History") + logger.info(self.short_memory.return_history_as_string()) + logger.info(f"End of Agent {self.agent_name} History") + def set_system_prompt(self, system_prompt: str): """Set the system prompt""" self.system_prompt = system_prompt @@ -630,13 +664,13 @@ class Agent: print("\n") def streaming(self, content: str = None): - """prints each chunk of content as it is generated + """Prints each letter of the content as it is generated. Args: - content (str, optional): _description_. Defaults to None. + content (str, optional): The content to be streamed. Defaults to None. """ - for chunk in content: - print(chunk, end="") + for letter in content: + print(letter, end="") ########################## FUNCTION CALLING ########################## @@ -652,8 +686,15 @@ class Agent: """Convert a JSON string to a dictionary""" return json.loads(json_str) - def pydantic_model_to_json_str(self, model: BaseModel): - return str(base_model_to_openai_function(model)) + def pydantic_model_to_json_str( + self, model: BaseModel, indent, *args, **kwargs + ): + return json.dumps( + base_model_to_openai_function(model), + indent=indent, + *args, + **kwargs, + ) def dict_to_json_str(self, dictionary: dict): """Convert a dictionary to a JSON string""" @@ -710,37 +751,11 @@ class Agent: ########################## FUNCTION CALLING ########################## - def _history(self, user_name: str, task: str) -> str: - """Generate the history for the history prompt - - Args: - user_name (str): _description_ - task (str): _description_ - - Returns: - str: _description_ - """ - history = [f"{user_name}: {task}"] - return history - - def _dynamic_prompt_setup(self, dynamic_prompt: str, task: str) -> str: - """_dynamic_prompt_setup summary - - Args: - dynamic_prompt (str): _description_ - task (str): _description_ - - Returns: - str: _description_ - """ - dynamic_prompt = dynamic_prompt or self.construct_dynamic_prompt() - combined_prompt = f"{dynamic_prompt}\n{task}" - return combined_prompt - def run( self, task: Optional[str] = None, img: Optional[str] = None, + function_map: Dict[str, Callable] = None, *args, **kwargs, ): @@ -750,12 +765,15 @@ class Agent: try: self.activate_autonomous_agent() - if task: + # Check if the task is not None + if task is not None: self.short_memory.add(role=self.user_name, content=task) loop_count = 0 + + # Clear the short memory + # self.short_memory.clear() response = None - step_pool = [] while ( self.max_loops == "auto" @@ -766,36 +784,85 @@ class Agent: self.loop_count_print(loop_count, self.max_loops) print("\n") + # Dynamic temperature if self.dynamic_temperature_enabled: self.dynamic_temperature() + # Task prompt task_prompt = self.short_memory.return_history_as_string() attempt = 0 success = False while attempt < self.retry_attempts and not success: try: + if self.planning is not False: + plan = self.llm(self.planning_prompt) + + # Add the plan to the memory + self.short_memory.add( + role=self.agent_name, content=plan + ) + + task_prompt = ( + self.short_memory.return_history_as_string() + ) + response_args = ( (task_prompt, *args) if img is None else (task_prompt, img, *args) ) response = self.llm(*response_args, **kwargs) - # print(response) + + # Print + print(response) + + # Add the response to the memory self.short_memory.add( role=self.agent_name, content=response ) - if self.tools: + # Check if tools is not None + if self.tools is not None: # Extract code from markdown response = extract_code_from_markdown(response) - # Execute the tool by name - execute_tool_by_name( - response, - self.tools, - stop_token=self.stopping_token, - ) + # Execute the tool by name [OLD VERISON] + # execute_tool_by_name( + # response, + # self.tools, + # stop_token=self.stopping_token, + # ) + + # Try executing the tool + if self.execute_tool is not False: + try: + logger.info("Executing tool...") + + # Execute the tool + out = self.tool_executor.execute_tool( + response, + function_map, + ) + + print(f"Tool Output: {out}") + + # Add the output to the memory + self.short_memory.add( + role=self.agent_name, + content=out, + ) + + except Exception as error: + logger.error( + f"Error executing tool: {error}" + ) + print( + colored( + f"Error executing tool: {error}", + "red", + ) + ) if self.code_interpreter: # Extract code from markdown @@ -821,6 +888,10 @@ class Agent: **kwargs, ) + print( + f"Response after code interpretation: {response}" + ) + if self.evaluator: evaluated_response = self.evaluator(response) print( @@ -856,10 +927,7 @@ class Agent: content=sentiment, ) - if self.streaming: - self.streaming(response) - else: - print(response) + # print(response) success = True # Mark as successful to exit the retry loop @@ -912,43 +980,30 @@ class Agent: ) time.sleep(self.loop_interval) - # Save Step Metadata - active_step = Step( - task_id=task_id(), - step_id=loop_count, - name=task, - output=response, - max_loops=self.max_loops, - ) - - step_pool.append(active_step) - - # Save the step pool - # self.step_cache = step_pool - if self.autosave: logger.info("Autosaving agent state.") self.save_state(self.saved_state_path, task) # Apply the cleaner function to the response if self.output_cleaner is not None: + logger.info("Applying output cleaner to response.") response = self.output_cleaner(response) + logger.info(f"Response after output cleaner: {response}") # Prepare the output for the output model if self.output_type is not None: + logger.info("Preparing output for output model.") response = self.prepare_output_for_output_model(response) + print(f"Response after output model: {response}") - # List of steps for this task - ManySteps(task_id=task_id(), steps=step_pool) - - # Save Many steps + # print(response) return response except Exception as error: print(f"Error running agent: {error}") raise error - def __call__(self, task: str, img: str = None, *args, **kwargs): + def __call__(self, task: str = None, img: str = None, *args, **kwargs): """Call the agent Args: @@ -956,45 +1011,10 @@ class Agent: img (str, optional): _description_. Defaults to None. """ try: - self.run(task, img, *args, **kwargs) + return self.run(task, img, *args, **kwargs) except Exception as error: logger.error(f"Error calling agent: {error}") - raise - - def agent_history_prompt( - self, - history: str = None, - ): - """ - Generate the agent history prompt - - Args: - system_prompt (str): The system prompt - history (List[str]): The history of the conversation - - Returns: - str: The agent history prompt - """ - if self.sop: - system_prompt = self.system_prompt - agent_history_prompt = f""" - role: system - {system_prompt} - - Follow this standard operating procedure (SOP) to complete tasks: - {self.sop} - - {history} - """ - return agent_history_prompt - else: - system_prompt = self.system_prompt - agent_history_prompt = f""" - System : {system_prompt} - - {history} - """ - return agent_history_prompt + raise error def long_term_memory_prompt(self, query: str, *args, **kwargs): """ @@ -1026,35 +1046,39 @@ class Agent: logger.info(f"Adding memory: {message}") return self.short_memory.add(role=self.agent_name, content=message) - async def run_concurrent(self, tasks: List[str], **kwargs): + async def run_concurrent(self, task: str, *args, **kwargs): """ - Run a batch of tasks concurrently and handle an infinite level of task inputs. + Run a task concurrently. Args: - tasks (List[str]): A list of tasks to run. + task (str): The task to run. """ try: - logger.info(f"Running concurrent tasks: {tasks}") - task_coroutines = [ - self.run_async(task, **kwargs) for task in tasks - ] - completed_tasks = await asyncio.gather(*task_coroutines) - logger.info(f"Completed tasks: {completed_tasks}") - return completed_tasks + logger.info(f"Running concurrent task: {task}") + with concurrent.futures.ThreadPoolExecutor() as executor: + future = executor.submit(self.run, task, *args, **kwargs) + result = await asyncio.wrap_future(future) + logger.info(f"Completed task: {result}") + return result except Exception as error: - print( - colored( - ( - f"Error running agent: {error} while running" - " concurrently" - ), - "red", - ) + logger.error( + f"Error running agent: {error} while running concurrently" ) def bulk_run(self, inputs: List[Dict[str, Any]]) -> List[str]: + """ + Generate responses for multiple input sets. + + Args: + inputs (List[Dict[str, Any]]): A list of input dictionaries containing the necessary data for each run. + + Returns: + List[str]: A list of response strings generated for each input set. + + Raises: + Exception: If an error occurs while running the bulk tasks. + """ try: - """Generate responses for multiple input sets.""" logger.info(f"Running bulk tasks: {inputs}") return [self.run(**input_data) for input_data in inputs] except Exception as error: @@ -1116,7 +1140,7 @@ class Agent: print(colored("------------------------", "cyan")) print(colored("End of Agent History", "cyan", attrs=["bold"])) - def step(self, task: str, **kwargs): + def step(self, task: str, *args, **kwargs): """ Executes a single step in the agent interaction, generating a response @@ -1133,9 +1157,9 @@ class Agent: """ try: - logger.info(f"Running a single step: {task}") + logger.info(f"Running a step: {task}") # Generate the response using lm - response = self.llm(task, **kwargs) + response = self.llm(task, *args, **kwargs) # Update the agent's history with the new interaction if self.interactive: @@ -1294,7 +1318,6 @@ class Agent: "autosave": self.autosave, "saved_state_path": self.saved_state_path, "max_loops": self.max_loops, - "StepCache": self.step_cache, "Task": task, "Stopping Token": self.stopping_token, "Dynamic Loops": self.dynamic_loops, @@ -1339,7 +1362,7 @@ class Agent: "function_calling_type": self.function_calling_type, "output_cleaner": self.output_cleaner, "function_calling_format_type": self.function_calling_format_type, - "list_tool_schemas": self.list_tool_schemas, + "list_base_models": self.list_base_models, "metadata_output_type": self.metadata_output_type, "user_meta_data": get_user_device_data(), } diff --git a/swarms/structs/agent_rearrange.py b/swarms/structs/agent_rearrange.py deleted file mode 100644 index 1a980985..00000000 --- a/swarms/structs/agent_rearrange.py +++ /dev/null @@ -1,231 +0,0 @@ -import logging -from collections import defaultdict -from typing import Callable, Sequence -from swarms.structs.agent import Agent -from swarms.structs.base_swarm import BaseSwarm - - -# Assuming the existence of an appropriate Agent class and logger setup -class AgentRearrange(BaseSwarm): - def __init__( - self, - agents: Sequence[Agent] = None, - verbose: bool = False, - custom_prompt: str = None, - callbacks: Sequence[Callable] = None, - *args, - **kwargs, - ): - super().__init__() - if not all(isinstance(agent, Agent) for agent in agents): - raise ValueError( - "All elements must be instances of the Agent class." - ) - self.agents = agents - self.verbose = verbose - self.custom_prompt = custom_prompt - self.callbacks = callbacks if callbacks is not None else [] - self.flows = defaultdict(list) - - def parse_pattern(self, pattern: str): - """ - Parse the interaction pattern to set up task flows, supporting both sequential - and concurrent executions within the same pattern. - """ - try: - self.flows.clear() # Ensure flows are reset each time pattern is parsed - # Split pattern into potentially concurrent flows - concurrent_flows = pattern.split(",") - for flow in concurrent_flows: - # Trim whitespace and identify sequential parts within each concurrent flow - parts = [part.strip() for part in flow.split("->")] - if len(parts) > 1: - # Link each part sequentially to the next as source -> destination - for i in range(len(parts) - 1): - source = parts[i] - destination = parts[i + 1] - # Validate and add each sequential link - if source not in [ - agent.agent_name for agent in self.agents - ]: - logging.error( - f"Source agent {source} not found." - ) - return False - if destination not in [ - agent.agent_name for agent in self.agents - ]: - logging.error( - f"Destination agent {destination} not" - " found." - ) - return False - self.flows[source].append(destination) - else: - # Handle single agent case if needed - self.flows[parts[0]] = [] - - return True - except Exception as e: - logging.error(f"Error parsing pattern: {e}") - return False - - def self_find_agent_by_name(self, name: str): - for agent in self.agents: - if agent.agent_name == name: - return agent - return None - - def agent_exists(self, name: str): - for agent in self.agents: - if agent.agent_name == name: - return True - - return False - - def parse_concurrent_flow( - self, - flow: str, - ): - sequential_agents = flow.split("->") - for i, source_name in enumerate(sequential_agents[:-1]): - destination_name = sequential_agents[i + 1].strip() - self.parse_sequential_flow( - source_name.strip(), destination_name - ) - - def parse_sequential_flow( - self, - source: str, - destination: str, - ): - if not self.self_find_agent_by_name( - source - ) or not self.self_find_agent_by_name(destination): - return False - self.flows[source].append(destination) - - def execute_task( - self, - dest_agent_name: str, - source: str, - task: str, - specific_tasks: dict, - ): - dest_agent = self.self_find_agent_by_name(dest_agent_name) - if not dest_agent: - return None - task_to_run = specific_tasks.get(dest_agent_name, task) - if self.custom_prompt: - out = dest_agent.run(f"{task_to_run} {self.custom_prompt}") - else: - out = dest_agent.run(f"{task_to_run} (from {source})") - return out - - def process_flows(self, pattern, default_task, specific_tasks): - if not self.parse_pattern(pattern): - return None - - results = [] - for source, destinations in self.flows.items(): - if not destinations: - task = specific_tasks.get(source, default_task) - source_agent = self.self_find_agent_by_name(source) - if source_agent: - result = source_agent.run(task) - results.append(result) - else: - for destination in destinations: - task = specific_tasks.get(destination, default_task) - destination_agent = self.self_find_agent_by_name( - destination - ) - if destination_agent: - result = destination_agent.run(task) - results.append(result) - return results - - def __call__( - self, - pattern: str = None, - default_task: str = None, - **specific_tasks, - ): - self.flows.clear() # Reset previous flows - results = self.process_flows(pattern, default_task, specific_tasks) - return results - - -# ## Initialize the workflow -# agent = Agent( -# agent_name="t", -# agent_description=( -# "Generate a transcript for a youtube video on what swarms" -# " are!" -# ), -# system_prompt=( -# "Generate a transcript for a youtube video on what swarms" -# " are!" -# ), -# llm=Anthropic(), -# max_loops=1, -# autosave=True, -# dashboard=False, -# streaming_on=True, -# verbose=True, -# stopping_token="", -# ) - -# agent2 = Agent( -# agent_name="t1", -# agent_description=( -# "Generate a transcript for a youtube video on what swarms" -# " are!" -# ), -# llm=Anthropic(), -# max_loops=1, -# system_prompt="Summarize the transcript", -# autosave=True, -# dashboard=False, -# streaming_on=True, -# verbose=True, -# stopping_token="", -# ) - -# agent3 = Agent( -# agent_name="t2", -# agent_description=( -# "Generate a transcript for a youtube video on what swarms" -# " are!" -# ), -# llm=Anthropic(), -# max_loops=1, -# system_prompt="Finalize the transcript", -# autosave=True, -# dashboard=False, -# streaming_on=True, -# verbose=True, -# stopping_token="", -# ) - - -# # Rearrange the agents -# rearrange = AgentRearrange( -# agents=[agent, agent2, agent3], -# verbose=True, -# # custom_prompt="Summarize the transcript", -# ) - -# # Run the workflow on a task -# results = rearrange( -# # pattern="t -> t1, t2 -> t2", -# pattern="t -> t1 -> t2", -# default_task=( -# "Generate a transcript for a YouTube video on what swarms" -# " are!" -# ), -# t="Generate a transcript for a YouTube video on what swarms are!", -# # t2="Summarize the transcript", -# # t3="Finalize the transcript", -# ) -# # print(results) diff --git a/swarms/structs/base_swarm.py b/swarms/structs/base_swarm.py index 72ba9463..bd71c60b 100644 --- a/swarms/structs/base_swarm.py +++ b/swarms/structs/base_swarm.py @@ -206,6 +206,33 @@ class BaseSwarm(ABC): def plan(self, task: str): """agents must individually plan using a workflow or pipeline""" + def self_find_agent_by_name(self, name: str): + """ + Find an agent by its name. + + Args: + name (str): The name of the agent to find. + + Returns: + Agent: The Agent object if found, None otherwise. + """ + for agent in self.agents: + if agent.agent_name == name: + return agent + return None + + def agent_exists(self, name: str): + """ + Check if an agent exists in the swarm. + + Args: + name (str): The name of the agent to check. + + Returns: + bool: True if the agent exists, False otherwise. + """ + return self.self_find_agent_by_name(name) is not None + def direct_message( self, message: str, diff --git a/swarms/structs/base_workflow.py b/swarms/structs/base_workflow.py index e2f0b0c7..f973c242 100644 --- a/swarms/structs/base_workflow.py +++ b/swarms/structs/base_workflow.py @@ -10,15 +10,6 @@ from swarms.utils.loguru_logger import logger class BaseWorkflow(BaseStructure): - """ - Base class for workflows. - - Attributes: - task_pool (list): A list to store tasks. - - - """ - def __init__( self, agents: List[Agent] = None, diff --git a/swarms/structs/rearrange.py b/swarms/structs/rearrange.py index b4614b33..cc540586 100644 --- a/swarms/structs/rearrange.py +++ b/swarms/structs/rearrange.py @@ -1,148 +1,223 @@ -import logging -from collections import defaultdict +from swarms import Agent +from typing import List +from swarms.structs.base_swarm import BaseSwarm from swarms.utils.loguru_logger import logger -from swarms.structs.agent import Agent -from typing import Sequence, Callable -class AgentRearrange: +class AgentRearrange(BaseSwarm): + """ + A class representing a swarm of agents for rearranging tasks. + + Attributes: + agents (dict): A dictionary of agents, where the key is the agent's name and the value is the agent object. + flow (str): The flow pattern of the tasks. + + Methods: + __init__(agents: List[Agent] = None, flow: str = None): Initializes the AgentRearrange object. + add_agent(agent: Agent): Adds an agent to the swarm. + remove_agent(agent_name: str): Removes an agent from the swarm. + add_agents(agents: List[Agent]): Adds multiple agents to the swarm. + validate_flow(): Validates the flow pattern. + run(task): Runs the swarm to rearrange the tasks. + """ + def __init__( self, - agents: Sequence[Agent] = None, - verbose: bool = False, - custom_prompt: str = None, - callbacks: Sequence[Callable] = None, - *args, - **kwargs, + agents: List[Agent] = None, + flow: str = None, + max_loops: int = 1, + verbose: bool = True, ): """ - Initialize the AgentRearrange class. + Initializes the AgentRearrange object. Args: - agents (Sequence[Agent], optional): A sequence of Agent objects. Defaults to None. - verbose (bool, optional): Whether to enable verbose mode. Defaults to False. - custom_prompt (str, optional): A custom prompt string. Defaults to None. - callbacks (Sequence[Callable], optional): A sequence of callback functions. Defaults to None. - *args: Variable length argument list. - **kwargs: Arbitrary keyword arguments. + agents (List[Agent], optional): A list of Agent objects. Defaults to None. + flow (str, optional): The flow pattern of the tasks. Defaults to None. """ - if not all(isinstance(agent, Agent) for agent in agents): - raise ValueError( - "All elements must be instances of the Agent class." - ) - self.agents = agents + self.agents = {agent.name: agent for agent in agents} + self.flow = flow self.verbose = verbose - self.custom_prompt = custom_prompt - self.callbacks = callbacks if callbacks is not None else [] - self.flows = defaultdict(list) + self.max_loops = max_loops + + if verbose is True: + logger.add("agent_rearrange.log") - def parse_pattern(self, pattern: str): + def add_agent(self, agent: Agent): """ - Parse the interaction pattern and setup task flows. + Adds an agent to the swarm. Args: - pattern (str): The interaction pattern to parse. - - Returns: - bool: True if the pattern parsing is successful, False otherwise. + agent (Agent): The agent to be added. """ - try: - for flow in pattern.split(","): - parts = [part.strip() for part in flow.split("->")] - if len(parts) != 2: - logging.error( - f"Invalid flow pattern: {flow}. Each flow" - " must have exactly one '->'." - ) - return False - - source_name, destinations_str = parts - source = self.find_agent_by_name(source_name) - if source is None: - logging.error(f"Source agent {source_name} not found.") - return False - - destinations_names = destinations_str.split() - for dest_name in destinations_names: - dest = self.find_agent_by_name(dest_name) - if dest is None: - logging.error( - f"Destination agent {dest_name} not" " found." - ) - return False - self.flows[source.agent_name].append(dest.agent_name) - return True - except Exception as e: - logger.error(f"Error: {e}") - raise e - - def self_find_agen_by_name(self, name: str): + logger.info(f"Adding agent {agent.name} to the swarm.") + self.agents[agent.name] = agent + + def remove_agent(self, agent_name: str): """ - Find an agent by its name. + Removes an agent from the swarm. Args: - name (str): The name of the agent to find. - - Returns: - Agent: The Agent object if found, None otherwise. + agent_name (str): The name of the agent to be removed. """ - for agent in self.agents: - if agent.agent_name == name: - return agent - return None + del self.agents[agent_name] - def __call__( - self, - agents: Sequence[Agent] = None, - pattern: str = None, - task: str = None, - **tasks, - ): + def add_agents(self, agents: List[Agent]): """ - Execute the task based on the specified pattern. + Adds multiple agents to the swarm. Args: - agents (Sequence[Agent], optional): A sequence of Agent objects. Defaults to None. - pattern (str, optional): The interaction pattern to follow. Defaults to None. - task (str, optional): The task to execute. Defaults to None. - **tasks: Additional tasks specified as keyword arguments. + agents (List[Agent]): A list of Agent objects. + """ + for agent in agents: + self.agents[agent.name] = agent + + def validate_flow(self): """ - try: - if agents: - self.flows.clear() # Reset previous flows - if not self.parse_pattern(pattern): - return # Pattern parsing failed - - for source, destinations in self.flows.items(): - for dest in destinations: - dest_agent = self.self_find_agen_by_name(dest) - task = tasks.get(dest, task) - - if self.custom_prompt: - dest_agent.run(f"{task} {self.custom_prompt}") - else: - dest_agent.run(f"{task} (from {source})") - # else: - # raise ValueError( - # "No agents provided. Please provide agents to" - # " execute the task." - # ) - except Exception as e: - logger.error( - f"Error: {e} try again by providing agents and" " pattern" + Validates the flow pattern. + + Raises: + ValueError: If the flow pattern is incorrectly formatted or contains duplicate agent names. + + Returns: + bool: True if the flow pattern is valid. + """ + if "->" not in self.flow: + raise ValueError( + "Flow must include '->' to denote the direction of the task." ) - raise e + agents_in_flow = [] + tasks = self.flow.split("->") + for task in tasks: + agent_names = [name.strip() for name in task.split(",")] + for agent_name in agent_names: + if agent_name not in self.agents: + raise ValueError( + f"Agent '{agent_name}' is not registered." + ) + agents_in_flow.append(agent_name) -# # Example usage -# try: -# agents = [ -# Agent(agent_name=f"b{i}") for i in range(1, 4) -# ] # Creating agents b1, b2, b3 -# agents.append(Agent(agent_name="d")) # Adding agent d -# rearranger = Rearrange(agents) + if len(set(agents_in_flow)) != len(agents_in_flow): + raise ValueError( + "Duplicate agent names in the flow are not allowed." + ) -# # Specifying a complex pattern for task execution -# rearranger.execute("d -> b1 b2 b3, b2 -> b3", "Analyze data") -# except ValueError as e: -# logging.error(e) + print("Flow is valid.") + return True + + def run(self, task: str, *args, **kwargs): + """ + Runs the swarm to rearrange the tasks. + + Args: + task: The initial task to be processed. + + Returns: + str: The final processed task. + """ + if not self.validate_flow(): + return "Invalid flow configuration." + + tasks = self.flow.split("->") + current_task = task + + for task in tasks: + agent_names = [name.strip() for name in task.split(",")] + if len(agent_names) > 1: + # Parallel processing + logger.info(f"Running agents in parallel: {agent_names}") + results = [] + for agent_name in agent_names: + agent = self.agents[agent_name] + result = agent.run(current_task, *args, **kwargs) + results.append(result) + current_task = "; ".join(results) + else: + # Sequential processing + logger.info(f"Running agents sequentially: {agent_names}") + agent = self.agents[agent_names[0]] + current_task = agent.run(current_task, *args, **kwargs) + + return current_task + + +def rearrange( + agents: List[Agent], flow: str, task: str = None, *args, **kwargs +): + """ + Rearranges the given list of agents based on the specified flow. + + Parameters: + agents (List[Agent]): The list of agents to be rearranged. + flow (str): The flow used for rearranging the agents. + task (str, optional): The task to be performed during rearrangement. Defaults to None. + *args: Additional positional arguments. + **kwargs: Additional keyword arguments. + + Returns: + The result of running the agent system with the specified task. + + Example: + agents = [agent1, agent2, agent3] + flow = "agent1 -> agent2, agent3" + task = "Perform a task" + rearrange(agents, flow, task) + """ + agent_system = AgentRearrange( + agents=agents, flow=flow, *args, **kwargs + ) + return agent_system.run(task, *args, **kwargs) + + +# # Initialize the director agent +# director = Agent( +# agent_name="Director", +# system_prompt="Directs the tasks for the workers", +# llm=Anthropic(), +# max_loops=1, +# dashboard=False, +# streaming_on=True, +# verbose=True, +# stopping_token="", +# state_save_file_type="json", +# saved_state_path="director.json", +# ) + +# # Initialize worker 1 +# worker1 = Agent( +# agent_name="Worker1", +# system_prompt="Generates a transcript for a youtube video on what swarms are", +# llm=Anthropic(), +# max_loops=1, +# dashboard=False, +# streaming_on=True, +# verbose=True, +# stopping_token="", +# state_save_file_type="json", +# saved_state_path="worker1.json", +# ) + +# # Initialize worker 2 +# worker2 = Agent( +# agent_name="Worker2", +# system_prompt="Summarizes the transcript generated by Worker1", +# llm=Anthropic(), +# max_loops=1, +# dashboard=False, +# streaming_on=True, +# verbose=True, +# stopping_token="", +# state_save_file_type="json", +# saved_state_path="worker2.json", +# ) + + +# flow = "Director -> Worker1 -> Worker2" +# agent_system = AgentRearrange( +# agents=[director, worker1, worker2], flow=flow +# ) +# # Run the system +# output = agent_system.run( +# "Create a format to express and communicate swarms of llms in a structured manner for youtube" +# ) diff --git a/swarms/structs/sequential_workflow.py b/swarms/structs/sequential_workflow.py index 468b46cd..4576ffa1 100644 --- a/swarms/structs/sequential_workflow.py +++ b/swarms/structs/sequential_workflow.py @@ -1,107 +1,91 @@ -from dataclasses import dataclass, field -from typing import List, Optional -from swarms.structs.agent import Agent -from swarms.structs.conversation import Conversation +import time +import json + from swarms.utils.loguru_logger import logger -from swarms.utils.try_except_wrapper import try_except_wrapper from swarms.structs.base_workflow import BaseWorkflow +from pydantic import BaseModel, Field +from typing import List, Dict +from swarms.structs.agent import Agent -@dataclass +class StepSequentialWorkflow(BaseModel): + agent_names: List[str] = Field( + ..., description="List of agent names to include in the workflow." + ) + max_loops: int = Field( + 1, description="Maximum number of loops to run the workflow." + ) + verbose: bool = Field( + False, description="Whether to log debug information." + ) + steps: Dict = Field( + ..., + description="Dictionary of steps for the workflow with each agent and its parameters.", + ) + time: str = Field( + time.strftime("%Y-%m-%d %H:%M:%S"), + description="Time of the workflow.", + ) + + +# Define a class to handle the sequential workflow class SequentialWorkflow(BaseWorkflow): - name: str = "Sequential Workflow" - description: str = None - objective: str = None - max_loops: int = 1 - autosave: bool = False - saved_state_filepath: Optional[str] = "sequential_workflow_state.json" - restore_state_filepath: Optional[str] = None - dashboard: bool = False - agent_pool: List[Agent] = field(default_factory=list) - # task_pool: List[str] = field( - # default_factory=list - # ) # List to store tasks - - def __post_init__(self): - super().__init__() - self.conversation = Conversation( - time_enabled=True, - autosave=True, + def __init__( + self, + agents: List[Agent] = None, + max_loops: int = 2, + verbose: bool = False, + *args, + **kwargs, + ): + """ + Initializes a SequentialWorkflow with a list of agents. + + :param agents: List of agents to include in the workflow. + """ + self.agents = agents + self.max_loops = max_loops + + if verbose: + logger.add("sequential_workflow.log", level="DEBUG") + + if not self.agents: + raise ValueError("No agents provided for workflow") + + if not self.max_loops: + self.max_loops = 1 + + # Log all the agents in the workflow + logger.info( + f"Initialized SequentialWorkflow with agents: {json.dumps([str(agent.agent_name) for agent in self.agents])}" ) - # If objective exists then set it - if self.objective is not None: - self.conversation.system_prompt = self.objective - - def workflow_bootup(self): - logger.info(f"{self.name} is activating...") - - for agent in self.agent_pool: - logger.info(f"Agent {agent.agent_name} Activated") - - @try_except_wrapper - def add(self, task: str, agent: Agent, *args, **kwargs): - self.agent_pool.append(agent) - # self.task_pool.append( - # task - # ) # Store tasks corresponding to each agent - - return self.conversation.add( - role=agent.agent_name, content=task, *args, **kwargs - ) - - def reset_workflow(self) -> None: - self.conversation = {} - - @try_except_wrapper - def run(self): - if not self.agent_pool: - raise ValueError("No agents have been added to the workflow.") - - self.workflow_bootup() - loops = 0 - while loops < self.max_loops: - previous_output = None # Initialize to None; will hold the output of the previous agent - for i, agent in enumerate(self.agent_pool): - # Fetch the last task specific to this agent from the conversation history - tasks_for_agent = [ - msg["content"] - for msg in self.conversation.conversation_history - if msg["role"] == agent.agent_name - ] - task = tasks_for_agent[-1] if tasks_for_agent else None - - if task is None and previous_output is not None: - # If no specific task for this agent, use the output from the previous agent - task = previous_output - - if task is None: - # If no initial task is found, and there's no previous output, log error and skip this agent - logger.error( - f"No initial task found for agent {agent.agent_name}, and no previous output to use." + def run(self, task: str, *args, **kwargs): + """ + Run the workflow starting with an initial task. + + :param task: The task to start the workflow. + """ + logger.info(f"Starting workflow with task: {task}") + current_output = task + for agent in self.agents: + count = 0 + while count < self.max_loops: + try: + logger.info(f"Running agent {agent.agent_name}") + current_output = agent.run( + current_output, *args, **kwargs ) - continue - - logger.info( - f" \n Agent {i+1} ({agent.agent_name}) is executing the task: {task} \n" - ) - - # Space the log - - output = agent.run(task) - if output is None: + print(current_output) + count += 1 + logger.debug( + f"Agent {agent.agent_name} completed loop {count} " + ) # Log partial output for brevity + except Exception as e: logger.error( - f"Agent {agent.agent_name} returned None for task: {task}" - ) - raise ValueError( - f"Agent {agent.agent_name} returned None." + f"Error occurred while running agent {agent.agent_name}: {str(e)}" ) - - # Update the conversation history with the new output using agent's role - self.conversation.add( - role=agent.agent_name, content=output - ) - previous_output = output # Update the previous_output to pass to the next agent - - loops += 1 - return self.conversation.return_history_as_string() + raise + logger.info(f"Finished running agent {agent.agent_name}") + logger.info("Finished running workflow") + return current_output diff --git a/swarms/structs/step.py b/swarms/structs/step.py index c8c913a6..c81f91e9 100644 --- a/swarms/structs/step.py +++ b/swarms/structs/step.py @@ -1,6 +1,6 @@ from typing import Dict, List, Sequence -from swarms.tools.tool import BaseTool +from swarms.tools.base_tool import BaseTool from pydantic import BaseModel diff --git a/swarms/structs/team.py b/swarms/structs/team.py deleted file mode 100644 index d3ee418d..00000000 --- a/swarms/structs/team.py +++ /dev/null @@ -1,106 +0,0 @@ -import json -from typing import List, Optional - -from pydantic import model_validator, BaseModel, Field, Json - -from swarms.structs.agent import Agent -from swarms.structs.task import Task - - -class Team(BaseModel): - """ - Class that represents a group of agents, how they should work together and - their tasks. - - Attributes: - tasks (Optional[List[Task]]): List of tasks. - agents (Optional[List[Agent]]): List of agents in this Team. - architecture (str): Architecture that the Team will follow. Default is "sequential". - verbose (bool): Verbose mode for the Agent Execution. Default is False. - config (Optional[Json]): Configuration of the Team. Default is None. - """ - - tasks: Optional[List[Task]] = Field(None, description="List of tasks") - agents: Optional[List[Agent]] = Field( - None, description="List of agents in this Team." - ) - architecture = Field( - description="architecture that the Team will follow.", - default="sequential", - ) - verbose: bool = Field( - description="Verbose mode for the Agent Execution", - default=False, - ) - config: Optional[Json] = Field( - description="Configuration of the Team.", default=None - ) - - @model_validator(mode="before") - @classmethod - def check_config(_cls, values): - if not values.get("config") and ( - not values.get("agents") and not values.get("tasks") - ): - raise ValueError( - "Either agents and task need to be set or config." - ) - - if values.get("config"): - config = json.loads(values.get("config")) - if not config.get("agents") or not config.get("tasks"): - raise ValueError("Config should have agents and tasks.") - - values["agents"] = [ - Agent(**agent) for agent in config["agents"] - ] - - tasks = [] - for task in config["tasks"]: - task_agent = [ - agt - for agt in values["agents"] - if agt.role == task["agent"] - ][0] - del task["agent"] - tasks.append(Task(**task, agent=task_agent)) - - values["tasks"] = tasks - return values - - def run(self) -> str: - """ - Kickoff the Team to work on its tasks. - - Returns: - output (List[str]): Output of the Team for each task. - """ - if self.architecture == "sequential": - return self.__sequential_loop() - - def __sequential_loop(self) -> str: - """ - Loop that executes the sequential architecture. - - Returns: - output (str): Output of the Team. - """ - task_outcome = None - for task in self.tasks: - # Add delegation tools to the task if the agent allows it - # if task.agent.allow_delegation: - # tools = AgentTools(agents=self.agents).tools() - # task.tools += tools - - self.__log(f"\nWorking Agent: {task.agent.role}") - self.__log(f"Starting Task: {task.description} ...") - - task_outcome = task.execute(task_outcome) - - self.__log(f"Task output: {task_outcome}") - - return task_outcome - - def __log(self, message): - if self.verbose: - print(message) diff --git a/swarms/tools/__init__.py b/swarms/tools/__init__.py index 567a176c..ac18f45c 100644 --- a/swarms/tools/__init__.py +++ b/swarms/tools/__init__.py @@ -1,4 +1,3 @@ -from swarms.tools.tool import BaseTool, Tool, StructuredTool, tool from swarms.tools.exec_tool import ( AgentAction, AgentOutputParser, @@ -32,14 +31,10 @@ from swarms.tools.py_func_to_openai_func_str import ( Function, ToolFunction, ) -from swarms.tools.openai_tool_creator_decorator import create_openai_tool - +from swarms.tools.openai_tool_creator_decorator import tool +from swarms.tools.base_tool import BaseTool __all__ = [ - "BaseTool", - "Tool", - "StructuredTool", - "tool", "AgentAction", "AgentOutputParser", "BaseAgentOutputParser", @@ -63,5 +58,6 @@ __all__ = [ "get_required_params", "Function", "ToolFunction", - "create_openai_tool", + "tool", + "BaseTool", ] diff --git a/swarms/tools/base_tool.py b/swarms/tools/base_tool.py new file mode 100644 index 00000000..7c90ec35 --- /dev/null +++ b/swarms/tools/base_tool.py @@ -0,0 +1,379 @@ +import json +from pydantic import BaseModel +from swarms.utils.loguru_logger import logger +from swarms.tools.py_func_to_openai_func_str import ( + get_openai_function_schema_from_func, + load_basemodels_if_needed, +) +from swarms.tools.openai_tool_creator_decorator import openai_tool_executor +from typing import Callable, Optional, Any, Dict, List +from swarms.tools.pydantic_to_json import ( + base_model_to_openai_function, + multi_base_model_to_openai_function, + function_to_str, + functions_to_str, +) +from swarms.tools.function_util import process_tool_docs +from typing import Union + +ToolType = Union[BaseModel, Dict[str, Any], Callable[..., Any]] + + +class BaseTool(BaseModel): + """ + Base class for tools in the swarms package. + + Attributes: + verbose (bool): Flag indicating whether to enable verbose mode. + functions (List[Callable[..., Any]]): List of functions associated with the tool. + base_models (List[type[BaseModel]]): List of base models associated with the tool. + + Methods: + func_to_dict(function: Callable[..., Any], name: Optional[str] = None, description: str) -> Dict[str, Any]: + Converts a function to a dictionary representation. + + load_params_from_func_for_pybasemodel(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Callable[..., Any]: + Loads parameters from a function for a Pydantic BaseModel. + + base_model_to_dict(pydantic_type: type[BaseModel], output_str: bool = False, *args: Any, **kwargs: Any) -> dict[str, Any]: + Converts a Pydantic BaseModel to a dictionary representation. + + multi_base_models_to_dict(pydantic_types: List[type[BaseModel]], *args: Any, **kwargs: Any) -> dict[str, Any]: + Converts multiple Pydantic BaseModels to a dictionary representation. + + dict_to_str(dict: dict[str, Any]) -> str: + Converts a dictionary to a string representation. + + multi_dict_to_str(dicts: list[dict[str, Any]]) -> str: + Converts multiple dictionaries to a string representation. + + get_docs_from_callable(item) -> Any: + Retrieves documentation from a callable item. + """ + + verbose: bool = False + functions: List[Callable[..., Any]] = [] + base_models: List[type[BaseModel]] = [] + verbose: bool = False + autocheck: bool = False + auto_execute_tool: Optional[bool] = False + + def func_to_dict( + function: Callable[..., Any], + *, + name: Optional[str] = None, + description: str, + ) -> Dict[str, Any]: + try: + return get_openai_function_schema_from_func( + function=function, + name=name, + description=description, + ) + except Exception as e: + logger.error(f"An error occurred in func_to_dict: {e}") + logger.error( + "Please check the function and ensure it is valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def load_params_from_func_for_pybasemodel( + func: Callable[..., Any], + *args: Any, + **kwargs: Any, + ) -> Callable[..., Any]: + try: + return load_basemodels_if_needed(func, *args, **kwargs) + except Exception as e: + logger.error( + f"An error occurred in load_params_from_func_for_pybasemodel: {e}" + ) + logger.error( + "Please check the function and ensure it is valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def base_model_to_dict( + pydantic_type: type[BaseModel], + output_str: bool = False, + *args: Any, + **kwargs: Any, + ) -> dict[str, Any]: + try: + return base_model_to_openai_function( + pydantic_type, output_str, *args, **kwargs + ) + except Exception as e: + logger.error(f"An error occurred in base_model_to_dict: {e}") + logger.error( + "Please check the Pydantic type and ensure it is valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def multi_base_models_to_dict( + pydantic_types: List[type[BaseModel]], + *args: Any, + **kwargs: Any, + ) -> dict[str, Any]: + try: + return multi_base_model_to_openai_function( + pydantic_types, *args, **kwargs + ) + except Exception as e: + logger.error( + f"An error occurred in multi_base_models_to_dict: {e}" + ) + logger.error( + "Please check the Pydantic types and ensure they are valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def dict_to_str( + dict: dict[str, Any], + ) -> str: + try: + return function_to_str(dict) + except Exception as e: + logger.error(f"An error occurred in dict_to_str: {e}") + logger.error( + "Please check the dictionary and ensure it is valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def multi_dict_to_str( + dicts: list[dict[str, Any]], + ) -> str: + try: + return functions_to_str(dicts) + except Exception as e: + logger.error(f"An error occurred in multi_dict_to_str: {e}") + logger.error( + "Please check the dictionaries and ensure they are valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def get_docs_from_callable(item): + try: + return process_tool_docs(item) + except Exception as e: + logger.error(f"An error occurred in get_docs: {e}") + logger.error("Please check the item and ensure it is valid.") + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def execute_tool( + self, + tools: List[Dict[str, Any]], + function_map: Dict[str, Callable], + *args: Any, + **kwargs: Any, + ) -> Callable: + try: + return openai_tool_executor( + tools, function_map, self.verbose, *args, **kwargs + ) + except Exception as e: + logger.error(f"An error occurred in execute_tool: {e}") + logger.error( + "Please check the tools and function map and ensure they are valid." + ) + logger.error( + "If the issue persists, please seek further assistance." + ) + raise + + def detect_tool_input_type(input): + if isinstance(input, BaseModel): + return "Pydantic" + elif isinstance(input, dict): + return "Dictionary" + elif callable(input): + return "Function" + else: + return "Unknown" + + def dynamic_run(self, input) -> str: + """ + Executes the dynamic run based on the input type. + + Args: + input: The input to be processed. + + Returns: + str: The result of the dynamic run. + + Raises: + None + + """ + tool_input_type = self.detect_tool_input_type(input) + if tool_input_type == "Pydantic": + function_str = base_model_to_openai_function(input) + elif tool_input_type == "Dictionary": + function_str = function_to_str(input) + elif tool_input_type == "Function": + function_str = get_openai_function_schema_from_func(input) + else: + return "Unknown tool input type" + + if self.auto_execute_tool: + if tool_input_type == "Function": + # Add the function to the functions list + self.functions.append(input) + + # Create a function map from the functions list + function_map = {func.__name__: func for func in self.functions} + + # Execute the tool + return self.execute_tool( + tools=[function_str], function_map=function_map + ) + else: + return function_str + + def execute_tool_by_name( + tools: List[Dict[str, Any]], + tool_name: str, + function_map: Dict[str, Callable], + ) -> Any: + """ + Search for a tool by name and execute it. + + Args: + tools (List[Dict[str, Any]]): A list of tools. Each tool is a dictionary that includes a 'name' key. + tool_name (str): The name of the tool to execute. + function_map (Dict[str, Callable]): A dictionary that maps tool names to functions. + + Returns: + The result of executing the tool. + + Raises: + ValueError: If the tool with the specified name is not found. + TypeError: If the tool name is not mapped to a function in the function map. + """ + # Search for the tool by name + tool = next( + (tool for tool in tools if tool.get("name") == tool_name), None + ) + + # If the tool is not found, raise an error + if tool is None: + raise ValueError(f"Tool '{tool_name}' not found") + + # Get the function associated with the tool + func = function_map.get(tool_name) + + # If the function is not found, raise an error + if func is None: + raise TypeError( + f"Tool '{tool_name}' is not mapped to a function" + ) + + # Execute the tool + return func(**tool.get("parameters", {})) + + def execute_tool_from_text( + text: str = None, function_map: Dict[str, Callable] = None + ) -> Any: + """ + Convert a JSON-formatted string into a tool dictionary and execute the tool. + + Args: + text (str): A JSON-formatted string that represents a tool. The string should be convertible into a dictionary that includes a 'name' key and a 'parameters' key. + function_map (Dict[str, Callable]): A dictionary that maps tool names to functions. + + Returns: + The result of executing the tool. + + Raises: + ValueError: If the tool with the specified name is not found. + TypeError: If the tool name is not mapped to a function in the function map. + """ + # Convert the text into a dictionary + tool = json.loads(text) + + # Get the tool name and parameters from the dictionary + tool_name = tool.get("name") + tool_params = tool.get("parameters", {}) + + # Get the function associated with the tool + func = function_map.get(tool_name) + + # If the function is not found, raise an error + if func is None: + raise TypeError( + f"Tool '{tool_name}' is not mapped to a function" + ) + + # Execute the tool + return func(**tool_params) + + +# # Example function definitions and mappings +# def get_current_weather(location, unit='celsius'): +# return f"Weather in {location} is likely sunny and 75° {unit.title()}" + +# def add(a, b): +# return a + b + +# # Example tool configurations +# tools = [ +# { +# "type": "function", +# "function": { +# "name": "get_current_weather", +# "parameters": { +# "properties": { +# "location": "San Francisco, CA", +# "unit": "fahrenheit", +# }, +# }, +# }, +# }, +# { +# "type": "function", +# "function": { +# "name": "add", +# "parameters": { +# "properties": { +# "a": 1, +# "b": 2, +# }, +# }, +# }, +# } +# ] + +# function_map = { +# "get_current_weather": get_current_weather, +# "add": add, +# } + +# # Creating and executing the advanced executor +# tool_executor = BaseTool(verbose=True).execute_tool(tools, function_map) + +# try: +# results = tool_executor() +# print(results) # Outputs results from both functions +# except Exception as e: +# print(f"Error: {e}") diff --git a/swarms/tools/exec_tool.py b/swarms/tools/exec_tool.py index 53a7d562..11328110 100644 --- a/swarms/tools/exec_tool.py +++ b/swarms/tools/exec_tool.py @@ -7,7 +7,7 @@ from typing import Dict, List, NamedTuple from langchain.schema import BaseOutputParser from pydantic import ValidationError -from swarms.tools.tool import BaseTool +from swarms.tools.base_tool import BaseTool from swarms.utils.loguru_logger import logger diff --git a/swarms/tools/openai_tool_creator_decorator.py b/swarms/tools/openai_tool_creator_decorator.py index 4a10064d..2ac15b32 100644 --- a/swarms/tools/openai_tool_creator_decorator.py +++ b/swarms/tools/openai_tool_creator_decorator.py @@ -1,12 +1,13 @@ from functools import wraps - +import concurrent.futures +from typing import Callable, Any, Dict, List from swarms.tools.py_func_to_openai_func_str import ( get_openai_function_schema_from_func, ) from swarms.utils.loguru_logger import logger -def create_openai_tool( +def tool( name: str = None, description: str = None, return_dict: bool = True, @@ -79,3 +80,314 @@ def create_openai_tool( return wrapper return decorator + + +def openai_tool_executor( + tools: List[Dict[str, Any]], + function_map: Dict[str, Callable], + verbose: bool = True, + *args, + **kwargs, +) -> Callable: + """ + Creates a function that dynamically and concurrently executes multiple functions based on parameters specified + in a list of tool dictionaries, with extensive error handling and validation. + + Args: + tools (List[Dict[str, Any]]): A list of dictionaries, each containing configuration for a tool, including parameters. + function_map (Dict[str, Callable]): A dictionary mapping function names to their corresponding callable functions. + + Returns: + Callable: A function that, when called, executes the specified functions concurrently with the parameters given. + + Examples: + >>> from swarms.tools.openai_tool_creator_decorator import openai_tool_executor + >>> from swarms.tools.py_func_to_openai_func_str import get_openai_function_schema_from_func + >>> from swarms.utils.loguru_logger import logger + >>> + >>> def test_function(param1: int, param2: str) -> str: + ... return f"Test function called with parameters: {param1}, {param2}" + ... + >>> @openai_tool_executor( + ... tools=[ + ... { + ... "type": "function", + ... "function": { + ... "name": "test_function", + ... "parameters": { + ... "properties": { + ... "param1": { + ... "type": "int", + ... "description": "An integer parameter." + ... }, + ... "param2": { + ... "type": "str", + ... "description": "A string parameter." + ... }, + ... } + ... } + ... } + ... } + ... ], + ... function_map={ + ... "test_function": test_function + ... } + ... ) + ... def tool_executor(): + ... pass + ... + >>> results = tool_executor() + >>> logger.info(results) + + """ + + def tool_executor(): + # Prepare tasks for concurrent execution + results = [] + logger.info(f"Executing {len(tools)} tools concurrently.") + with concurrent.futures.ThreadPoolExecutor() as executor: + futures = [] + for tool in tools: + if tool.get("type") != "function": + continue # Skip non-function tool entries + + function_info = tool.get("function", {}) + func_name = function_info.get("name") + logger.info(f"Executing function: {func_name}") + + # Check if the function name is mapped to an actual function + if func_name not in function_map: + raise KeyError( + f"Function '{func_name}' not found in function map." + ) + + # Validate parameters + params = function_info.get("parameters", {}).get( + "properties", {} + ) + if not params: + raise ValueError( + f"No parameters specified for function '{func_name}'." + ) + + # Submit the function for execution + try: + future = executor.submit( + function_map[func_name], **params + ) + futures.append(future) + except Exception as e: + print( + f"Failed to submit the function '{func_name}' for execution: {e}" + ) + + # Gather results from all futures + for future in futures: + try: + result = future.result() # Collect result from future + results.append(result) + except Exception as e: + print(f"Error during execution of a function: {e}") + + logger.info(f"Results: {results}") + + return results + + return tool_executor + + +# def openai_tool_executor( +# tools: List[Dict[str, Any]], +# function_map: Dict[str, Callable], +# verbose: bool = True, +# concurrent_execution: bool = True, +# retry_on_error: bool = False, +# retry_attempts: int = 3, +# max_loops: int = 1, +# max_workers: int = 10, +# *args, +# **kwargs, +# ) -> Callable: +# """ +# Creates a function that dynamically and concurrently executes multiple functions based on parameters specified +# in a list of tool dictionaries, with extensive error handling and validation. + +# Args: +# tools (List[Dict[str, Any]]): A list of dictionaries, each containing configuration for a tool, including parameters. +# function_map (Dict[str, Callable]): A dictionary mapping function names to their corresponding callable functions. + +# Returns: +# Callable: A function that, when called, executes the specified functions concurrently with the parameters given. + +# Examples: +# >>> from swarms.tools.openai_tool_creator_decorator import openai_tool_executor +# >>> from swarms.tools.py_func_to_openai_func_str import get_openai_function_schema_from_func +# >>> from swarms.utils.loguru_logger import logger +# >>> +# >>> def test_function(param1: int, param2: str) -> str: +# ... return f"Test function called with parameters: {param1}, {param2}" +# ... +# >>> @openai_tool_executor( +# ... tools=[ +# ... { +# ... "type": "function", +# ... "function": { +# ... "name": "test_function", +# ... "parameters": { +# ... "properties": { +# ... "param1": { +# ... "type": "int", +# ... "description": "An integer parameter." +# ... }, +# ... "param2": { +# ... "type": "str", +# ... "description": "A string parameter." +# ... }, +# ... } +# ... } +# ... } +# ... } +# ... ], +# ... function_map={ +# ... "test_function": test_function +# ... } +# ... ) +# ... def tool_executor(): +# ... pass +# ... +# >>> results = tool_executor() +# >>> logger.info(results) + +# """ + +# def tool_executor(): +# logger.info( +# f"Starting execution of tools with {max_loops} loops and concurrency set to {concurrent_execution}." +# ) + +# results = [] + +# def execute_function(func_name, params): +# try: +# logger.debug( +# f"Executing function: {func_name} with params: {params}" +# ) +# return function_map[func_name](**params) +# except Exception as e: +# logger.error( +# f"Error executing function {func_name}: {str(e)}" +# ) +# if retry_on_error: +# for attempt in range(retry_attempts): +# try: +# logger.debug( +# f"Retrying function: {func_name}, attempt {attempt+1}" +# ) +# return function_map[func_name](**params) +# except Exception as e: +# logger.error( +# f"Retry {attempt+1} for function {func_name} failed: {str(e)}" +# ) +# raise +# else: +# raise + +# for loop in range(max_loops): + +# logger.info(f"Executing loop {loop + 1}/{max_loops}") + +# with concurrent.futures.ThreadPoolExecutor( +# max_workers=max_workers +# ) as executor: +# future_to_function = { +# executor.submit( +# execute_function, +# tool["function"]["name"], +# tool["function"]["parameters"]["properties"], +# ): tool +# for tool in tools +# if tool.get("type") == "function" +# } + +# for future in concurrent.futures.as_completed( +# future_to_function +# ): +# try: +# result = future.result() +# results.append(result) +# logger.debug( +# f"Function completed with result: {result}" +# ) +# except Exception as e: +# logger.error( +# f"Execution failed with error: {str(e)}" +# ) +# continue + +# logger.info(f"All loops completed. Results: {results}") + +# return results + +# return tool_executor + + +# # Example +# @tool( +# name="test_function", +# description="A test function that takes two parameters and returns a string.", +# ) +# def test_function(param1: int, param2: str) -> str: +# return f"Test function called with parameters: {param1}, {param2}" + + +# @tool( +# name="test_function2", +# description="A test function that takes two parameters and returns a string.", +# ) +# def test_function2(param1: int, param2: str) -> str: +# return f"Test function 2 called with parameters: {param1}, {param2}" + + +# # Example execution +# out = openai_tool_executor( +# tools=[ +# { +# "type": "function", +# "function": { +# "name": "test_function", +# "parameters": { +# "properties": { +# "param1": { +# "type": "int", +# "description": "An integer parameter.", +# }, +# "param2": { +# "type": "str", +# "description": "A string parameter.", +# }, +# } +# }, +# }, +# }, +# { +# "type": "function", +# "function": { +# "name": "test_function2", +# "parameters": { +# "properties": { +# "param1": { +# "type": "int", +# "description": "An integer parameter.", +# }, +# "param2": { +# "type": "str", +# "description": "A string parameter.", +# }, +# } +# }, +# }, +# }, +# ], +# function_map={"test_function": test_function, "test_function2": test_function2}, +# ) +# print(out) diff --git a/swarms/tools/pydantic_to_json.py b/swarms/tools/pydantic_to_json.py index 2ba33b33..3295eacd 100644 --- a/swarms/tools/pydantic_to_json.py +++ b/swarms/tools/pydantic_to_json.py @@ -51,7 +51,7 @@ def base_model_to_openai_function( schema["description"] = docstring.short_description else: schema["description"] = ( - f"Correctly extracted `{pydantic_type.__class__.__name__.lower()}` with all " + f"Correctly extracted `{pydantic_type.__name__}` with all " f"the required parameters with correct types" ) @@ -61,11 +61,11 @@ def base_model_to_openai_function( if output_str: out = { "function_call": { - "name": pydantic_type.__class__.__name__.lower(), + "name": pydantic_type.__name__, }, "functions": [ { - "name": pydantic_type.__class__.__name__.lower(), + "name": pydantic_type.__name__, "description": schema["description"], "parameters": parameters, }, @@ -76,11 +76,11 @@ def base_model_to_openai_function( else: return { "function_call": { - "name": pydantic_type.__class__.__name__.lower(), + "name": pydantic_type.__name__, }, "functions": [ { - "name": pydantic_type.__class__.__name__.lower(), + "name": pydantic_type.__name__, "description": schema["description"], "parameters": parameters, }, diff --git a/swarms/tools/tool_utils.py b/swarms/tools/tool_utils.py index 4d8c7c52..65219e1f 100644 --- a/swarms/tools/tool_utils.py +++ b/swarms/tools/tool_utils.py @@ -3,7 +3,7 @@ import re from typing import Any, List from swarms.prompts.tools import SCENARIOS -from swarms.tools.tool import BaseTool +from swarms.tools.base_tool import BaseTool import inspect from typing import Callable diff --git a/tests/structs/test_agent_rearrange.py b/tests/structs/test_agent_rearrange.py new file mode 100644 index 00000000..a9e07642 --- /dev/null +++ b/tests/structs/test_agent_rearrange.py @@ -0,0 +1,58 @@ +import pytest +from agent_rearrange import AgentRearrange + + +# Mocking the Agent class +class MockAgent: + def __init__(self, agent_name): + self.agent_name = agent_name + + def run(self, task): + return f"Running {task}" + + +# Test for AgentRearrange class +class TestAgentRearrange: + @pytest.fixture + def agent_rearrange(self): + agents = [MockAgent("agent1"), MockAgent("agent2")] + return AgentRearrange(agents=agents) + + def test_parse_pattern(self, agent_rearrange): + assert agent_rearrange.parse_pattern("agent1->agent2") is True + assert agent_rearrange.parse_pattern("agent3->agent4") is False + + def test_self_find_agent_by_name(self, agent_rearrange): + assert ( + agent_rearrange.self_find_agent_by_name("agent1").agent_name + == "agent1" + ) + assert agent_rearrange.self_find_agent_by_name("agent3") is None + + def test_agent_exists(self, agent_rearrange): + assert agent_rearrange.agent_exists("agent1") is True + assert agent_rearrange.agent_exists("agent3") is False + + def test_parse_concurrent_flow(self, agent_rearrange): + agent_rearrange.parse_concurrent_flow("agent1->agent2") + assert "agent2" in agent_rearrange.flows["agent1"] + + def test_parse_sequential_flow(self, agent_rearrange): + agent_rearrange.parse_sequential_flow("agent1", "agent2") + assert "agent2" in agent_rearrange.flows["agent1"] + + def test_execute_task(self, agent_rearrange): + assert ( + agent_rearrange.execute_task("agent1", "agent2", "task1", {}) + == "Running task1 (from agent2)" + ) + + def test_process_flows(self, agent_rearrange): + assert agent_rearrange.process_flows( + "agent1->agent2", "task1", {} + ) == ["Running task1"] + + def test_call(self, agent_rearrange): + assert agent_rearrange( + pattern="agent1->agent2", default_task="task1" + ) == ["Running task1"] From a952af5fe8f0c330b9892c9af06fb90b0dad6988 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 17:44:48 -0400 Subject: [PATCH 08/22] [DOCS] --- docs/mkdocs.yml | 1 + docs/swarms_cloud/available_models.md | 2 +- docs/swarms_cloud/migrate_openai.md | 6 +- hierarchical_swarm.py | 177 -------------------------- 4 files changed, 6 insertions(+), 180 deletions(-) delete mode 100644 hierarchical_swarm.py diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 930e07ea..3d23ebcc 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -189,6 +189,7 @@ nav: - Overview: "applications/customer_support.md" - Marketing: - Overview: "applications/marketing_agencies.md" + - Swarm of Automated Business Analysis: "applications/business-analyst-agent.md" - Corporate: - Corporate Documents: - Data Room: "corporate/data_room.md" diff --git a/docs/swarms_cloud/available_models.md b/docs/swarms_cloud/available_models.md index ad108c82..0405b893 100644 --- a/docs/swarms_cloud/available_models.md +++ b/docs/swarms_cloud/available_models.md @@ -1,6 +1,6 @@ # Available Models -```markdown +``` | Model Name | Description | Input Price | Output Price | Use Cases | |-----------------------|---------------------------------------------------------------------------------------------------------|--------------|--------------|------------------------------------------------------------------------| | **Llama3-70b** | Llama 3 is an auto-regressive language model that uses an optimized transformer architecture. | $0.80/1M Tokens | $1.60/1M Tokens | General natural language processing tasks. | diff --git a/docs/swarms_cloud/migrate_openai.md b/docs/swarms_cloud/migrate_openai.md index 058241d7..23718eec 100644 --- a/docs/swarms_cloud/migrate_openai.md +++ b/docs/swarms_cloud/migrate_openai.md @@ -75,6 +75,8 @@ Note that you need to supply one of Swarms’s supported LLMs as an argument, as ## Example output The code above produces the following object: -```bash +``` ChatCompletionMessage(content=" Hello! How can I assist you today? Do you have any questions or tasks you'd like help with? Please let me know and I'll do my best to assist you.", role='assistant' function_call=None, tool_calls=None) -``` \ No newline at end of file +``` + + diff --git a/hierarchical_swarm.py b/hierarchical_swarm.py deleted file mode 100644 index 5162da9a..00000000 --- a/hierarchical_swarm.py +++ /dev/null @@ -1,177 +0,0 @@ -from typing import List - -from pydantic import BaseModel, Field - -from swarms.structs.agent import Agent -from swarms.structs.base_swarm import BaseSwarm -from swarms.utils.loguru_logger import logger -from swarms.models.popular_llms import Anthropic, OpenAIChat -from swarms.models.base_llm import BaseLLM -from swarms.memory.base_vectordb import BaseVectorDatabase - - -boss_sys_prompt = ( - "You're the Swarm Orchestrator, like a project manager of a" - " bustling hive. When a task arises, you tap into your network of" - " worker agents who are ready to jump into action. Whether it's" - " organizing data, handling logistics, or crunching numbers, you" - " delegate tasks strategically to maximize efficiency. Picture" - " yourself as the conductor of a well-oiled machine," - " orchestrating the workflow seamlessly to achieve optimal" - " results with your team of dedicated worker agents." -) - - -class AgentSchema(BaseModel): - name: str = Field( - ..., - title="Name of the agent", - description="Name of the agent", - ) - system_prompt: str = ( - Field( - ..., - title="System prompt for the agent", - description="System prompt for the agent", - ), - ) - rules: str = Field( - ..., - title="Rules", - description="Rules for the agent", - ) - llm: str = Field( - ..., - title="Language model", - description="Language model for the agent: `GPT4` or `Claude", - ) - - # tools: List[ToolSchema] = Field( - # ..., - # title="Tools available to the agent", - # description="Either `browser` or `terminal`", - # ) - # task: str = Field( - # ..., - # title="Task assigned to the agent", - # description="Task assigned to the agent", - # ) - # TODO: Add more fields here such as the agent's language model, tools, etc. - - -class HassSchema(BaseModel): - plan: str = Field( - ..., - title="Plan to solve the input problem", - description="List of steps to solve the problem", - ) - agents: List[AgentSchema] = Field( - ..., - title="List of agents to use for the problem", - description="List of agents to use for the problem", - ) - # Rules for the agents - rules: str = Field( - ..., - title="Rules for the agents", - description="Rules for the agents", - ) - - -class HierarchicalSwarm(BaseSwarm): - def __init__( - self, - director: Agent = None, - subordinates: List[Agent] = [], - workers: List[Agent] = [], - director_sys_prompt: str = boss_sys_prompt, - director_name: str = "Swarm Orchestrator", - director_agent_creation_schema: BaseModel = HassSchema, - director_llm: BaseLLM = Anthropic, - communication_protocol: BaseVectorDatabase = None, - *args, - **kwargs, - ): - super().__init__(*args, **kwargs) - self.director = director - self.subordinates = subordinates - self.workers = workers - self.director_sys_prompt = director_sys_prompt - self.director_name = director_name - self.director_agent_creation_schema = ( - director_agent_creation_schema - ) - self.director_llm = director_llm - self.communication_protocol = communication_protocol - - def create_director(self, *args, **kwargs): - """ - Create the director agent based on the provided schema. - """ - name = self.director_name - system_prompt = self.director_sys_prompt - director_llm = self.director_llm - - if director_llm == Anthropic: - Anthropic(*args, **kwargs) - elif director_llm == OpenAIChat: - OpenAIChat(*args, **kwargs) - - logger.info( - f"Creating Director Agent: {name} with system prompt:" - f" {system_prompt}" - ) - - director = Agent( - agent_name=name, - system_prompt=system_prompt, - llm=director_llm, - max_loops=1, - autosave=True, - dashboard=False, - verbose=True, - stopping_token="", - ) - - return director - - def create_worker_agents( - agents: List[AgentSchema], - ) -> List[Agent]: - """ - Create and initialize agents based on the provided AgentSchema objects. - - Args: - agents (List[AgentSchema]): A list of AgentSchema objects containing agent information. - - Returns: - List[Agent]: The initialized Agent objects. - - """ - agent_list = [] - for agent in agents: - name = agent.name - system_prompt = agent.system_prompt - - logger.info( - f"Creating agent: {name} with system prompt:" - f" {system_prompt}" - ) - - out = Agent( - agent_name=name, - system_prompt=system_prompt, - # llm=Anthropic( - # anthropic_api_key=os.getenv("ANTHROPIC_API_KEY") - # ), - max_loops=1, - autosave=True, - dashboard=False, - verbose=True, - stopping_token="", - ) - - # network.add_agent(out) - agent_list.append(out) - - return agent_list From 8913f272ff6479f3b0debb43da147d45fdcea21b Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 17:48:46 -0400 Subject: [PATCH 09/22] [DOCS] --- docs/swarms_cloud/available_models.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/swarms_cloud/available_models.md b/docs/swarms_cloud/available_models.md index 0405b893..f4649c06 100644 --- a/docs/swarms_cloud/available_models.md +++ b/docs/swarms_cloud/available_models.md @@ -1,6 +1,5 @@ # Available Models -``` | Model Name | Description | Input Price | Output Price | Use Cases | |-----------------------|---------------------------------------------------------------------------------------------------------|--------------|--------------|------------------------------------------------------------------------| | **Llama3-70b** | Llama 3 is an auto-regressive language model that uses an optimized transformer architecture. | $0.80/1M Tokens | $1.60/1M Tokens | General natural language processing tasks. | @@ -10,7 +9,6 @@ | **XComposer2-4khd-7b** | One of the highest performing VLMs (Video Language Models). | $4/1M Tokens | $8/1M Tokens | High-resolution video processing and understanding. | | **Llava-Llama-3** | Llama3 with Multi-Modal Processing. | $5/1M Tokens | $10/1M Tokens | Advanced multi-modal scenarios involving language and image processing. | | **cogvlm-chat-17b** | Groundbreaking multimodal model designed to understand and reason about visual elements in images. | $5/1M Tokens | $10/1M Tokens | Image-based chatbots and interactive systems. | -``` ## What models should we add? From dc7c0f63221e5fbe231ad2f1d0db87ea2aa3443d Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 18:28:57 -0400 Subject: [PATCH 10/22] [DOCS][Enterprise Guide to High-Performance Multi-Agent LLM Deployments] --- docs/mkdocs.yml | 1 + docs/swarms_cloud/main.md | 6 +- docs/swarms_cloud/production_deployment.md | 319 +++++++++++++++++++++ 3 files changed, 323 insertions(+), 3 deletions(-) create mode 100644 docs/swarms_cloud/production_deployment.md diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 3d23ebcc..dda16b31 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -115,6 +115,7 @@ nav: - Available Models: "swarms_cloud/available_models.md" - Migrate from OpenAI to Swarms in 3 lines of code: "swarms_cloud/migrate_openai.md" - Getting Started with SOTA Vision Language Models VLM: "swarms_cloud/getting_started.md" + - Enterprise Guide to High-Performance Multi-Agent LLM Deployments: "swarms_cloud/production_development.md" - Swarms Framework [PY]: - Overview: "swarms/index.md" - DIY Build Your Own Agent: "diy_your_own_agent.md" diff --git a/docs/swarms_cloud/main.md b/docs/swarms_cloud/main.md index 4d2a9bff..d54451a4 100644 --- a/docs/swarms_cloud/main.md +++ b/docs/swarms_cloud/main.md @@ -58,7 +58,7 @@ The AI Chat Completion API processes text and image inputs to generate conversat ## Objects -### ChatMessageInput +### Request | Field | Type | Description | Required | |-----------|---------------------|-----------------------------------------------|----------| @@ -66,14 +66,14 @@ The AI Chat Completion API processes text and image inputs to generate conversat | `content` | string or array | The content of the message. | Yes | | `name` | string | An optional name identifier for the sender. | No | -### ChatCompletionResponseChoice +### Response | Field | Type | Description | |-----------|--------|------------------------------------| | `index` | integer| The index of the choice. | | `message` | object | A `ChatMessageResponse` object. | -### UsageInfo +#### UsageInfo | Field | Type | Description | |-------------------|---------|-----------------------------------------------| diff --git a/docs/swarms_cloud/production_deployment.md b/docs/swarms_cloud/production_deployment.md new file mode 100644 index 00000000..2b2724c9 --- /dev/null +++ b/docs/swarms_cloud/production_deployment.md @@ -0,0 +1,319 @@ +# Enterprise Guide to High-Performance Multi-Agent LLM Deployments +================================================================ + +As large language models (LLMs) continue to advance and enable a wide range of powerful applications, enterprises are increasingly exploring multi-agent architectures to leverage the collective capabilities of multiple LLMs. However, coordinating and optimizing the performance of these complex multi-agent systems presents significant challenges. + +This comprehensive guide provides enterprise architects, engineering leaders, and technical decision-makers with a strategic framework for maximizing performance across multi-agent LLM deployments. Developed through extensive research and collaboration with industry partners, this guide distills best practices, proven techniques, and cutting-edge methodologies into seven core principles. + +By implementing the recommendations outlined in this guide, organizations can achieve superior latency, throughput, and resource utilization while ensuring scalability, cost-effectiveness, and optimal user experiences. Whether powering customer-facing conversational agents, driving internal knowledge management systems, or fueling mission-critical decision support tools, high-performance multi-agent LLM deployments will be pivotal to unlocking the full potential of this transformative technology. + +## Introduction + +The rise of large language models (LLMs) has ushered in a new era of human-machine interaction, enabling enterprises to develop sophisticated natural language processing (NLP) applications that can understand, generate, and reason with human-like text. However, as the complexity and scale of LLM deployments grow, traditional monolithic architectures are increasingly challenged to meet the stringent performance, scalability, and cost requirements of enterprise environments. + +Multi-agent architectures, which coordinate the collective capabilities of multiple specialized LLMs, have emerged as a powerful paradigm for addressing these challenges. By distributing workloads across a cohort of agents, each optimized for specific tasks or domains, multi-agent systems can deliver superior performance, resilience, and adaptability compared to single-model solutions. + +However, realizing the full potential of multi-agent LLM deployments requires a strategic approach to system design, optimization, and ongoing management. This guide presents a comprehensive framework for maximizing performance across seven core principles, each underpinned by a range of proven techniques and methodologies. + +Whether you are architecting a customer-facing conversational agent, building an internal knowledge management platform, or developing a mission-critical decision support system, this guide will equip you with the insights and best practices necessary to unlock the full potential of multi-agent LLM deployments within your enterprise. + +## Principle 1: Distribute Token Processing +---------------------------------------- + +At the heart of every LLM deployment lies the fundamental challenge of optimizing token processing -- the rate at which the model consumes and generates text inputs and outputs. In multi-agent architectures, distributing and parallelizing token processing across multiple agents is a critical performance optimization strategy. + +### Agent Specialization + +One of the key advantages of multi-agent architectures is the ability to dedicate specific agents to specialized tasks or domains. By carefully matching agents to the workloads they are optimized for, enterprises can maximize overall throughput and minimize latency. + +For example, in a conversational agent deployment, one agent may be optimized for intent recognition and query understanding, while another is fine-tuned for generating coherent, context-aware responses. In a document processing pipeline, separate agents could be dedicated to tasks such as named entity recognition, sentiment analysis, and summarization. + +To effectively leverage agent specialization, enterprises should: + +- Conduct a thorough analysis of their application's workflow and identify distinct tasks or domains that could benefit from dedicated agents. +- Evaluate the strengths and weaknesses of available LLM models and agents, and map them to the identified tasks or domains based on their capabilities and performance characteristics. +- Implement continuous monitoring and performance tuning processes to ensure agents remain optimized for their assigned workloads as models evolve and domain requirements shift. + +### Load Balancing + +Even with a well-designed allocation of tasks across specialized agents, fluctuations in workload and demand can create bottlenecks and performance degradation. Effective load balancing strategies are essential to ensure that token processing capacity is dynamically distributed across available agents based on real-time conditions. + +Load balancing in multi-agent LLM deployments can be accomplished through a combination of techniques, including: + +- **Round-Robin**: Distributing incoming requests across agents in a cyclical fashion, ensuring an even distribution of workload. +- **Least Connections**: Routing requests to the agent with the fewest active connections or outstanding tasks, minimizing the risk of overloading any single agent. +- **Response Time Monitoring**: Continuously monitoring the response times of each agent and dynamically adjusting request routing to favor faster-responding agents. +- **Resource-Based Routing**: Factoring in agent-level resource consumption (e.g., CPU, memory) when making routing decisions, ensuring that overloaded agents are relieved of additional workload. + +Implementing effective load balancing requires careful consideration of the specific characteristics and requirements of your multi-agent deployment, as well as the integration of robust monitoring and analytics capabilities to inform dynamic routing decisions. + +### Horizontal Scaling + +While load balancing optimizes the utilization of existing agent resources, horizontal scaling strategies enable organizations to dynamically provision additional token processing capacity to meet demand spikes or handle larger overall workloads. + +In multi-agent LLM deployments, horizontal scaling can be achieved through: + +- **Agent Replication**: Spin up additional instances of existing agents to increase parallel processing capacity for specific tasks or domains. +- **Hybrid Scaling**: Combine agent replication with the dynamic provisioning of additional compute resources (e.g., CPU, GPU) to support the increased agent count. +- **Serverless Deployment**: Leverage serverless computing platforms (e.g., AWS Lambda, Google Cloud Functions) to automatically scale agent instances based on real-time demand, minimizing idle resource consumption. + +Effective horizontal scaling requires robust orchestration and management capabilities, as well as seamless integration with load balancing mechanisms to ensure that incoming workloads are efficiently distributed across the dynamically scaled agent pool. + +## Principle 2: Optimize Agent Communication +----------------------------------------- + +In multi-agent LLM deployments, efficient inter-agent communication is crucial for coordinating tasks, exchanging context and intermediate results, and maintaining overall system coherence. However, communication overhead can quickly become a performance bottleneck if not carefully managed. + +### Minimizing Overhead + +Reducing the volume and complexity of information exchanged between agents is a key strategy for optimizing communication performance. Techniques for minimizing overhead include: + +- **Data Compression**: Applying lossless or lossy compression algorithms to reduce the size of data payloads exchanged between agents, lowering bandwidth requirements and transmission latencies. +- **Information Summarization**: Distilling and summarizing context, results, or other data exchanged between agents to its essential elements, minimizing redundant or non-critical information. +- **Differential Updates**: Rather than transmitting entire data payloads, agents can exchange only the differential updates or deltas required to synchronize their respective states. + +Implementing these techniques requires careful analysis of the specific data exchange patterns and communication requirements within your multi-agent deployment, as well as the integration of appropriate compression, summarization, and differential update algorithms. + +### Prioritizing Critical Information + +In scenarios where communication bandwidth or latency constraints cannot be fully alleviated through overhead reduction techniques, enterprises can prioritize the exchange of critical information over non-essential data. + +This can be achieved through: + +- **Prioritized Queuing**: Implementing queuing mechanisms that prioritize the transmission of high-priority, time-sensitive data over lower-priority, non-critical information. +- **Selective Communication**: Dynamically determining which agents require specific pieces of information based on their roles and responsibilities, and selectively transmitting data only to those agents that truly need it. +- **Progressive Information Exchange**: Exchanging information in a progressive or staged manner, with critical elements transmitted first, followed by supplementary or contextual data as bandwidth becomes available. + +Effective prioritization requires a deep understanding of the interdependencies and information flow within your multi-agent system, as well as the ability to dynamically assess and prioritize data based on its criticality and urgency. + +### Caching and Reusing Context + +In many multi-agent LLM deployments, agents frequently exchange or operate on shared context, such as user profiles, conversation histories, or domain-specific knowledge bases. Caching and reusing this context information can significantly reduce redundant communication and processing overhead. + +Strategies for optimizing context caching and reuse include: + +- **Agent-Level Caching**: Implementing caching mechanisms within individual agents to store and retrieve frequently accessed context data, minimizing the need for inter-agent communication. +- **Centralized Context Management**: Deploying a dedicated context management service or data store that agents can query and update, ensuring consistent access to the latest context information across the system. +- **Context Versioning and Invalidation**: Implementing versioning and invalidation mechanisms to ensure that cached context data remains fresh and consistent, avoiding stale or outdated information from propagating through the system. + + +### Principle 3: Leverage Agent Specialization +------------------------------------------ + +One of the key advantages of multi-agent architectures is the ability to optimize individual agents for specific tasks, domains, or capabilities. By leveraging agent specialization, enterprises can ensure that each component of their LLM system is finely tuned for maximum performance and quality. + +### Task-Specific Optimization + +Within a multi-agent LLM deployment, different agents may be responsible for distinct tasks such as language understanding, knowledge retrieval, response generation, or post-processing. Optimizing each agent for its designated task can yield significant performance gains and quality improvements. + +Techniques for task-specific optimization include: + +- **Prompt Engineering**: Crafting carefully designed prompts that provide the necessary context, instructions, and examples to guide an agent towards optimal performance for its assigned task. +- **Fine-Tuning**: Adapting a pre-trained LLM to a specific task or domain by fine-tuning it on a curated dataset, allowing the agent to specialize and improve its performance on that particular workload. +- **Model Distillation**: Transferring the knowledge and capabilities of a larger, more capable LLM into a smaller, more efficient model specialized for a specific task, balancing performance and quality trade-offs. + +Implementing these optimization techniques requires a deep understanding of the capabilities and requirements of each task within your multi-agent system, as well as access to relevant training data and computational resources for fine-tuning and distillation processes. + +### Domain Adaptation + +Many enterprise applications operate within specific domains or verticals, such as finance, healthcare, or legal. Adapting agents to these specialized domains can significantly improve their performance, accuracy, and compliance within the target domain. + +Strategies for domain adaptation include: + +- **Domain-Specific Pre-Training**: Leveraging domain-specific corpora to pre-train LLM agents, imbuing them with a foundational understanding of the language, concepts, and nuances specific to the target domain. +- **Transfer Learning**: Fine-tuning agents that have been pre-trained on general or adjacent domains, transferring their existing knowledge and capabilities to the target domain while optimizing for its specific characteristics. +- **Domain Persona Injection**: Injecting domain-specific personas, traits, or constraints into agents during fine-tuning or deployment, shaping their behavior and outputs to align with domain-specific norms and requirements. + +Effective domain adaptation requires access to high-quality, domain-specific training data, as well as close collaboration with subject matter experts to ensure that agents are properly calibrated to meet the unique demands of the target domain. + +### Ensemble Techniques + +In complex multi-agent deployments, individual agents may excel at specific subtasks or aspects of the overall workflow. Ensemble techniques that combine the outputs or predictions of multiple specialized agents can often outperform any single agent, leveraging the collective strengths of the ensemble. + +Common ensemble techniques for multi-agent LLM systems include: + +- **Voting**: Combining the outputs or predictions of multiple agents through majority voting, weighted voting, or other consensus mechanisms. +- **Stacking**: Training a meta-agent to combine and optimize the outputs of multiple base agents, effectively learning to leverage their collective strengths. +- **Blending**: Combining the outputs of multiple agents through weighted averaging, linear interpolation, or other blending techniques, allowing for nuanced integration of diverse perspectives. + +Implementing effective ensemble techniques requires careful analysis of the strengths, weaknesses, and complementary capabilities of individual agents, as well as the development of robust combination strategies that can optimally leverage the ensemble's collective intelligence. + +### Principle 4: Implement Dynamic Scaling +-------------------------------------- + +The demand and workload patterns of enterprise LLM deployments can be highly dynamic, with significant fluctuations driven by factors such as user activity, data ingestion schedules, or periodic batch processing. Implementing dynamic scaling strategies allows organizations to optimally provision and allocate resources in response to these fluctuations, ensuring consistent performance while minimizing unnecessary costs. + +### Autoscaling + +Autoscaling is a core capability that enables the automatic adjustment of compute resources (e.g., CPU, GPU, memory) and agent instances based on real-time demand patterns and workload metrics. By dynamically scaling resources up or down, enterprises can maintain optimal performance and resource utilization, avoiding both over-provisioning and under-provisioning scenarios. + +Effective autoscaling in multi-agent LLM deployments requires: + +- **Monitoring and Metrics**: Implementing robust monitoring and metrics collection mechanisms to track key performance indicators (KPIs) such as request rates, response times, resource utilization, and agent-level metrics. +- **Scaling Policies**: Defining scaling policies that specify the conditions and thresholds for triggering automatic scaling actions, such as provisioning additional agents or compute resources when certain KPIs are breached. +- **Scaling Orchestration**: Integrating autoscaling capabilities with resource orchestration and management tools (e.g., Kubernetes, AWS Auto Scaling) to seamlessly provision, configure, and integrate new resources into the existing multi-agent deployment. + +By automating the scaling process, enterprises can respond rapidly to workload fluctuations, ensuring consistent performance and optimal resource utilization without the need for manual intervention. + +### Spot Instance Utilization + +Many cloud providers offer spot instances or preemptible resources at significantly discounted prices compared to on-demand or reserved instances. While these resources may be reclaimed with little notice, they can be leveraged judiciously within multi-agent LLM deployments to reduce operational costs. + +Strategies for leveraging spot instances include: + +- **Fault-Tolerant Agent Deployment**: Deploying certain agents or components of the multi-agent system on spot instances, while ensuring that these components can be rapidly and seamlessly replaced or migrated in the event of instance preemption. +- **Batch Workload Offloading**: Offloading batch processing workloads or non-time-sensitive tasks to spot instances, leveraging their cost-effectiveness while minimizing the impact of potential disruptions. +- **Hybrid Provisioning**: Implementing a hybrid approach that combines on-demand or reserved instances for mission-critical components with spot instances for more flexible or elastic workloads. + +Effective spot instance utilization requires careful architectural considerations to ensure fault tolerance and minimize the impact of potential disruptions, as well as robust monitoring and automation capabilities to seamlessly replace or migrate workloads in response to instance preemption events. + +### Serverless Deployments + +Serverless computing platforms, such as AWS Lambda, Google Cloud Functions, or Azure Functions, offer a compelling alternative to traditional server-based deployments. By automatically scaling compute resources based on real-time demand and charging only for the resources consumed, serverless architectures can provide significant cost savings and operational simplicity. + +Leveraging serverless deployments for multi-agent LLM systems can be achieved through: + +- **Function-as-a-Service (FaaS) Agents**: Deploying individual agents or components of the multi-agent system as serverless functions, allowing for rapid and automatic scaling in response to fluctuating workloads. +- **Event-Driven Architectures**: Designing the multi-agent system to operate in an event-driven manner, with agents triggered and executed in response to specific events or data ingestion, aligning with the serverless execution model. +- **Hybrid Deployments**: Combining serverless components with traditional server-based components, leveraging the strengths and cost advantages of each deployment model for different aspects of the multi-agent system. + +Adopting serverless architectures requires careful consideration of factors such as execution duration limits, cold start latencies, and integration with other components of the multi-agent deployment. However, when implemented effectively, serverless deployments can provide unparalleled scalability, cost-efficiency, and operational simplicity for dynamic, event-driven workloads. + + +### Principle 5: Employ Selective Execution +--------------------------------------- + +Not every input or request within a multi-agent LLM deployment requires the full execution of all agents or the complete processing pipeline. Selectively invoking agents or tasks based on input characteristics or intermediate results can significantly optimize performance by avoiding unnecessary computation and resource consumption. + +### Input Filtering + +Implementing input filtering mechanisms allows enterprises to reject or bypass certain inputs before they are processed by the multi-agent system. This can be achieved through techniques such as: + +- **Blacklisting/Whitelisting**: Maintaining lists of inputs (e.g., specific phrases, URLs, or content types) that should be automatically rejected or allowed, based on predefined criteria. +- **Rules-Based Filtering**: Defining a set of rules or heuristics to assess the suitability or relevance of an input for further processing, based on factors such as language, content, or metadata. +- **Confidence Thresholding**: Leveraging pre-processing agents or models to assess the likelihood that an input is relevant or valuable, and filtering out inputs that fall below a predetermined confidence threshold. + +Effective input filtering requires careful consideration of the specific requirements, constraints, and objectives of your multi-agent deployment, as well as ongoing monitoring and adjustment of filtering rules and thresholds to maintain optimal performance and accuracy. + +### Early Stopping + +In many multi-agent LLM deployments, intermediate results or predictions generated by early-stage agents can be used to determine whether further processing is required or valuable. Early stopping mechanisms allow enterprises to terminate execution pipelines when specific conditions or thresholds are met, avoiding unnecessary downstream processing. + +Techniques for implementing early stopping include: + +- **Confidence-Based Stopping**: Monitoring the confidence scores or probabilities associated with intermediate results, and terminating execution if a predefined confidence threshold is exceeded. +- **Exception-Based Stopping**: Defining specific intermediate results or conditions that indicate that further processing is unnecessary or undesirable, and terminating execution upon encountering these exceptions. +- **Adaptive Stopping**: Employing machine learning models or reinforcement learning agents to dynamically determine when to terminate execution based on learned patterns and trade-offs between accuracy, latency, and resource consumption. + +Effective early stopping requires a deep understanding of the interdependencies and decision points within your multi-agent workflow, as well as careful tuning and monitoring to ensure that stopping conditions are calibrated to maintain an optimal balance between performance and accuracy. + +### Conditional Branching + +Rather than executing a linear, fixed pipeline of agents, conditional branching allows multi-agent systems to dynamically invoke different agents or execution paths based on input characteristics or intermediate results. This can significantly optimize resource utilization by ensuring that only the necessary agents and processes are executed for a given input or scenario. + +Implementing conditional branching involves: + +- **Decision Points**: Identifying key points within the multi-agent workflow where branching decisions can be made based on input or intermediate data. +- **Branching Logic**: Defining the rules, conditions, or machine learning models that will evaluate the input or intermediate data and determine the appropriate execution path or agent invocation. +- **Execution Routing**: Integrating mechanisms to dynamically route inputs or intermediate data to the appropriate agents or processes based on the branching decision. + +Conditional branching can be particularly effective in scenarios where inputs or workloads exhibit distinct characteristics or require significantly different processing pipelines, allowing enterprises to optimize resource allocation and minimize unnecessary computation. + +### Principle 6: Optimize User Experience +------------------------------------- + +While many of the principles outlined in this guide focus on optimizing backend performance and resource utilization, delivering an exceptional user experience is also a critical consideration for enterprise multi-agent LLM deployments. By minimizing perceived wait times and providing real-time progress updates, organizations can ensure that users remain engaged and satisfied, even during periods of high workload or resource constraints. + +### Streaming Responses + +One of the most effective techniques for minimizing perceived wait times is to stream responses or outputs to users as they are generated, rather than waiting for the entire response to be completed before delivering it. This approach is particularly valuable in conversational agents, document summarization, or other scenarios where outputs can be naturally segmented and delivered incrementally. + +Implementing streaming responses requires: + +- **Partial Output Generation**: Modifying agents or models to generate and emit outputs in a streaming or incremental fashion, rather than producing the entire output in a single, monolithic operation. +- **Streaming Data Pipelines**: Integrating streaming data pipelines and message queues to enable the efficient and reliable transmission of partial outputs from agents to user-facing interfaces or applications. +- **Incremental Rendering**: Updating user interfaces and displays to incrementally render or populate with newly streamed output segments, providing a seamless and real-time experience for end-users. + +By delivering outputs as they are generated, streaming responses can significantly improve the perceived responsiveness and interactivity of multi-agent LLM deployments, even in scenarios where the overall processing time remains unchanged. + +### Progress Indicators + +In cases where streaming responses may not be feasible or appropriate, providing visual or textual indicators of ongoing processing and progress can help manage user expectations and improve the overall experience. Progress indicators can be implemented through techniques such as: + +- **Loader Animations**: Displaying simple animations or spinner graphics to indicate that processing is underway and provide a sense of activity and progress. +- **Progress Bars**: Rendering progress bars or completion indicators based on estimated or actual progress through multi-agent workflows or processing pipelines. +- **Status Updates**: Periodically updating user interfaces with textual status messages or descriptions of the current processing stage, providing users with a more detailed understanding of the system's activities. + +Effective progress indicators require careful integration with monitoring and telemetry capabilities to accurately track and communicate the progress of multi-agent workflows, as well as thoughtful user experience design to ensure that indicators are clear, unobtrusive, and aligned with user expectations. + +### Chunked Delivery + +In scenarios where outputs or responses cannot be effectively streamed or rendered incrementally, chunked delivery can provide a middle ground between delivering the entire output at once and streaming individual tokens or characters. By breaking larger outputs into smaller, more manageable chunks and delivering them individually, enterprises can improve perceived responsiveness and provide a more engaging user experience. + +Implementing chunked delivery involves: + +- **Output Segmentation**: Identifying logical breakpoints or segmentation boundaries within larger outputs, such as paragraphs, sections, or other structural elements. +- **Chunking Mechanisms**: Integrating mechanisms to efficiently break outputs into individual chunks and transmit or render them sequentially, with minimal delay between chunks. +- **Chunk Rendering**: Updating user interfaces or displays to seamlessly render or append new output chunks as they are received, providing a sense of continuous progress and minimizing the perception of extended waiting periods. + +Chunked delivery can be particularly effective in scenarios where outputs are inherently structured or segmented, such as document generation, report creation, or multi-step instructions or workflows. + +## Principle 7: Leverage Hybrid Approaches +--------------------------------------- + +While multi-agent LLM architectures offer numerous advantages, they should not be viewed as a one-size-fits-all solution. In many cases, combining LLM agents with traditional techniques, optimized components, or external services can yield superior performance, cost-effectiveness, and resource utilization compared to a pure LLM-based approach. + +### Task Offloading + +Certain tasks or subtasks within a larger multi-agent workflow may be more efficiently handled by dedicated, optimized components or external services, rather than relying solely on LLM agents. Task offloading involves identifying these opportunities and integrating the appropriate components or services into the overall architecture. + +Examples of task offloading in multi-agent LLM deployments include: + +- **Regular Expression Matching**: Offloading pattern matching or text extraction tasks to dedicated regular expression engines, which can often outperform LLM-based approaches in terms of speed and efficiency. +- **Structured Data Processing**: Leveraging specialized data processing engines or databases for tasks involving structured data, such as querying, filtering, or transforming tabular or relational data. +- **External APIs and Services**: Integrating with external APIs or cloud services for specific tasks, such as speech recognition, translation, or knowledge base lookup, leveraging the specialized capabilities and optimizations of these dedicated services. + +Effective task offloading requires a thorough understanding of the strengths and limitations of both LLM agents and traditional components, as well as careful consideration of integration points, data flows, and performance trade-offs within the overall multi-agent architecture. + +### Caching and Indexing + +While LLMs excel at generating dynamic, context-aware outputs, they can be less efficient when dealing with static or frequently accessed information or knowledge. Caching and indexing strategies can help mitigate this limitation by minimizing redundant LLM processing and enabling faster retrieval of commonly accessed data. + +Techniques for leveraging caching and indexing in multi-agent LLM deployments include: + +**Output Caching**: Caching the outputs or responses generated by LLM agents, allowing for rapid retrieval and reuse in cases where the same or similar input is encountered in the future. + +**Knowledge Base Indexing**: Indexing domain-specific knowledge bases, data repositories, or other static information sources using traditional search and information retrieval techniques. This allows LLM agents to efficiently query and incorporate relevant information into their outputs, without needing to process or generate this content from scratch. + +**Contextual Caching**: Caching not only outputs but also the contextual information and intermediate results generated during multi-agent workflows. This enables more efficient reuse and continuation of previous processing in scenarios where contexts are long-lived or recurring. + +Implementing effective caching and indexing strategies requires careful consideration of data freshness, consistency, and invalidation mechanisms, as well as seamless integration with LLM agents and multi-agent workflows to ensure that cached or indexed data is appropriately leveraged and updated. + +### Pre-computation and Lookup + +In certain scenarios, especially those involving constrained or well-defined inputs, pre-computing and lookup strategies can be leveraged to minimize or entirely avoid the need for real-time LLM processing. By generating and storing potential outputs or responses in advance, enterprises can significantly improve performance and reduce resource consumption. + +Approaches for pre-computation and lookup include: + +**Output Pre-generation**: For inputs or scenarios with a limited set of potential outputs, pre-generating and storing all possible responses, allowing for rapid retrieval and delivery without the need for real-time LLM execution. + +**Retrieval-Based Responses**: Developing retrieval models or techniques that can identify and surface pre-computed or curated responses based on input characteristics, leveraging techniques such as nearest neighbor search, embedding-based retrieval, or example-based generation. + +**Hybrid Approaches**: Combining pre-computed or retrieved responses with real-time LLM processing, allowing for the generation of dynamic, context-aware content while still leveraging pre-computed components to optimize performance and resource utilization. + +Effective implementation of pre-computation and lookup strategies requires careful analysis of input patterns, output distributions, and potential performance gains, as well as robust mechanisms for managing and updating pre-computed data as application requirements or domain knowledge evolves. + +# Conclusion +---------- + +As enterprises increasingly embrace the transformative potential of large language models, optimizing the performance, scalability, and cost-effectiveness of these deployments has become a critical imperative. Multi-agent architectures, which coordinate the collective capabilities of multiple specialized LLM agents, offer a powerful paradigm for addressing these challenges. + +By implementing the seven principles outlined in this guide -- distributing token processing, optimizing agent communication, leveraging agent specialization, implementing dynamic scaling, employing selective execution, optimizing user experience, and leveraging hybrid approaches -- organizations can unlock the full potential of multi-agent LLM deployments. + +However, realizing these benefits requires a strategic and holistic approach that accounts for the unique requirements, constraints, and objectives of each enterprise. From task-specific optimizations and domain adaptation to dynamic scaling and user experience considerations, maximizing the performance of multi-agent LLM systems demands a deep understanding of the underlying technologies, as well as the ability to navigate the inherent complexities of these sophisticated architectures. + +To learn more about how Swarm Corporation can assist your organization in architecting, deploying, and optimizing high-performance multi-agent LLM solutions, we invite you to book a consultation with one of our agent specialists. Visit to schedule a 30-minute call and explore how our expertise and cutting-edge technologies can drive transformative outcomes for your business. + +In the rapidly evolving landscape of artificial intelligence and natural language processing, staying ahead of the curve is essential. Partner with Swarm Corporation, and unlock the full potential of multi-agent LLM deployments, today. + +[Book a call with us now:](https://calendly.com/swarm-corp/30min) \ No newline at end of file From 4d0872ec8796581f90ad716012b9f6525550cf7d Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 18:32:20 -0400 Subject: [PATCH 11/22] [DOCS][Enterprise Guide to High-Performance Multi-Agent LLM Deployments] --- docs/mkdocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index dda16b31..d3b20f71 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -115,7 +115,7 @@ nav: - Available Models: "swarms_cloud/available_models.md" - Migrate from OpenAI to Swarms in 3 lines of code: "swarms_cloud/migrate_openai.md" - Getting Started with SOTA Vision Language Models VLM: "swarms_cloud/getting_started.md" - - Enterprise Guide to High-Performance Multi-Agent LLM Deployments: "swarms_cloud/production_development.md" + - Enterprise Guide to High-Performance Multi-Agent LLM Deployments: "swarms_cloud/production_deployment.md" - Swarms Framework [PY]: - Overview: "swarms/index.md" - DIY Build Your Own Agent: "diy_your_own_agent.md" From 0f6d2d1ac8356250094f271d6e3eecf4f85cffad Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 18:36:07 -0400 Subject: [PATCH 12/22] [CLEANUP] --- docs/swarms_cloud/production_deployment.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/swarms_cloud/production_deployment.md b/docs/swarms_cloud/production_deployment.md index 2b2724c9..749e0530 100644 --- a/docs/swarms_cloud/production_deployment.md +++ b/docs/swarms_cloud/production_deployment.md @@ -1,5 +1,5 @@ # Enterprise Guide to High-Performance Multi-Agent LLM Deployments -================================================================ +------- As large language models (LLMs) continue to advance and enable a wide range of powerful applications, enterprises are increasingly exploring multi-agent architectures to leverage the collective capabilities of multiple LLMs. However, coordinating and optimizing the performance of these complex multi-agent systems presents significant challenges. From 501eac0656c491935b0dbb8b79b451181254351f Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 19:01:44 -0400 Subject: [PATCH 13/22] [CLEANUP] --- docs/mkdocs.yml | 1 + docs/swarms/structs/agent_rearrange.md | 275 +++++++++++++++++++++++++ 2 files changed, 276 insertions(+) create mode 100644 docs/swarms/structs/agent_rearrange.md diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index d3b20f71..ff0d293d 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -156,6 +156,7 @@ nav: - task: "swarms/structs/task.md" - Task Queue Base: "swarms/structs/taskqueuebase.md" - YamlModel: "swarms/structs/yaml_model.md" + - AgentRearrange: "swarms/structs/agent_rearrange.md" - Workflows: - recursiveworkflow: "swarms/structs/recursiveworkflow.md" - concurrentworkflow: "swarms/structs/concurrentworkflow.md" diff --git a/docs/swarms/structs/agent_rearrange.md b/docs/swarms/structs/agent_rearrange.md new file mode 100644 index 00000000..09599f04 --- /dev/null +++ b/docs/swarms/structs/agent_rearrange.md @@ -0,0 +1,275 @@ +# Documentation for `AgentRearrange` Class +----- + +The `AgentRearrange` class represents a swarm of agents for rearranging tasks. It allows you to create a swarm of agents, add or remove agents from the swarm, and run the swarm to process tasks based on a specified flow pattern. + +## Attributes +---------- + +| Attribute | Type | Description | +| --- | --- | --- | +| `agents` | `dict` | A dictionary of agents, where the key is the agent's name and the value is the agent object. | +| `flow` | `str` | The flow pattern of the tasks. | +| `max_loops` | `int` | The maximum number of loops for the agents to run. | +| `verbose` | `bool` | Whether to enable verbose logging or not. | + +## Methods +------- + +### `__init__(self, agents: List[Agent] = None, flow: str = None, max_loops: int = 1, verbose: bool = True)` + +Initializes the `AgentRearrange` object. + +| Parameter | Type | Description | +| --- | --- | --- | +| `agents` | `List[Agent]` (optional) | A list of `Agent` objects. Defaults to `None`. | +| `flow` | `str` (optional) | The flow pattern of the tasks. Defaults to `None`. | +| `max_loops` | `int` (optional) | The maximum number of loops for the agents to run. Defaults to `1`. | +| `verbose` | `bool` (optional) | Whether to enable verbose logging or not. Defaults to `True`. | + +### `add_agent(self, agent: Agent)` + +Adds an agent to the swarm. + +| Parameter | Type | Description | +| --- | --- | --- | +| `agent` | `Agent` | The agent to be added. | + +### `remove_agent(self, agent_name: str)` + +Removes an agent from the swarm. + +| Parameter | Type | Description | +| --- | --- | --- | +| `agent_name` | `str` | The name of the agent to be removed. | + +### `add_agents(self, agents: List[Agent])` + +Adds multiple agents to the swarm. + +| Parameter | Type | Description | +| --- | --- | --- | +| `agents` | `List[Agent]` | A list of `Agent` objects. | + +### `validate_flow(self)` + +Validates the flow pattern. + +**Raises:** + +- `ValueError`: If the flow pattern is incorrectly formatted or contains duplicate agent names. + +**Returns:** + +- `bool`: `True` if the flow pattern is valid. + +### `run(self, task: str, *args, **kwargs)` + +Runs the swarm to rearrange the tasks. + +| Parameter | Type | Description | +| --- | --- | --- | +| `task` | `str` | The initial task to be processed. | +| `*args` | - | Additional positional arguments. | +| `**kwargs` | - | Additional keyword arguments. | + +**Returns:** + +- `str`: The final processed task. + +## Documentation for `rearrange` Function +====================================== + +The `rearrange` function is a helper function that rearranges the given list of agents based on the specified flow. + +## Parameters +---------- + +| Parameter | Type | Description | +| --- | --- | --- | +| `agents` | `List[Agent]` | The list of agents to be rearranged. | +| `flow` | `str` | The flow used for rearranging the agents. | +| `task` | `str` (optional) | The task to be performed during rearrangement. Defaults to `None`. | +| `*args` | - | Additional positional arguments. | +| `**kwargs` | - | Additional keyword arguments. | + +## Returns +------- + +The result of running the agent system with the specified task. + +### Example +------- + +```python +agents = [agent1, agent2, agent3] +flow = "agent1 -> agent2, agent3" +task = "Perform a task" +rearrange(agents, flow, task) +``` + +### Example Usage +------------- + +Here's an example of how to use the `AgentRearrange` class and the `rearrange` function: + +```python +from swarms import Agent +from typing import List +from agent_rearrange import AgentRearrange, rearrange + +# Initialize the director agent +director = Agent( + agent_name="Director", + system_prompt="Directs the tasks for the workers", + llm=Anthropic(), + max_loops=1, + dashboard=False, + streaming_on=True, + verbose=True, + stopping_token="", + state_save_file_type="json", + saved_state_path="director.json", +) + +# Initialize worker 1 +worker1 = Agent( + agent_name="Worker1", + system_prompt="Generates a transcript for a youtube video on what swarms are", + llm=Anthropic(), + max_loops=1, + dashboard=False, + streaming_on=True, + verbose=True, + stopping_token="", + state_save_file_type="json", + saved_state_path="worker1.json", +) + +# Initialize worker 2 +worker2 = Agent( + agent_name="Worker2", + system_prompt="Summarizes the transcript generated by Worker1", + llm=Anthropic(), + max_loops=1, + dashboard=False, + streaming_on=True, + verbose=True, + stopping_token="", + state_save_file_type="json", + saved_state_path="worker2.json", +) + +# Create a list of agents +agents = [director, worker1, worker2] + +# Define the flow pattern +flow = "Director -> Worker1 -> Worker2" + +# Using AgentRearrange class +agent_system = AgentRearrange(agents=agents, flow=flow) +output = agent_system.run("Create a format to express and communicate swarms of llms in a structured manner for youtube") +print(output) + +# Using rearrange function +output = rearrange(agents, flow, "Create a format to express and communicate swarms of llms in a structured manner for youtube") +print(output) + +``` + +In this example, we first initialize three agents: `director`, `worker1`, and `worker2`. Then, we create a list of these agents and define the flow pattern `"Director -> Worker1 -> Worker2"`. + +We can use the `AgentRearrange` class by creating an instance of it with the list of agents and the flow pattern. We then call the `run` method with the initial task, and it will execute the agents in the specified order, passing the output of one agent as the input to the next agent. + +Alternatively, we can use the `rearrange` function by passing the list of agents, the flow pattern, and the initial task as arguments. + +Both the `AgentRearrange` class and the `rearrange` function will return the final output after processing the task through the agents according to the specified flow pattern. + +## Error Handling +-------------- + +The `AgentRearrange` class includes error handling mechanisms to validate the flow pattern. If the flow pattern is incorrectly formatted or contains duplicate agent names, a `ValueError` will be raised with an appropriate error message. + +### Example: + +```python +# Invalid flow pattern +invalid_flow = "Director->Worker1,Worker2->Worker3" +agent_system = AgentRearrange(agents=agents, flow=invalid_flow) +output = agent_system.run("Some task")` +``` + +This will raise a `ValueError` with the message `"Agent 'Worker3' is not registered."`. + + +## Parallel and Sequential Processing +---------------------------------- + +The `AgentRearrange` class supports both parallel and sequential processing of tasks based on the specified flow pattern. If the flow pattern includes multiple agents separated by commas (e.g., `"agent1, agent2"`), the agents will be executed in parallel, and their outputs will be concatenated with a semicolon (`;`). If the flow pattern includes a single agent, it will be executed sequentially. + + +### Parallel processing +`parallel_flow = "Worker1, Worker2 -> Director"` + +### Sequential processing +`sequential_flow = "Worker1 -> Worker2 -> Director"` + +In the `parallel_flow` example, `Worker1` and `Worker2` will be executed in parallel, and their outputs will be concatenated and passed to `Director`. In the `sequential_flow` example, `Worker1` will be executed first, and its output will be passed to `Worker2`, and then the output of `Worker2` will be passed to `Director`. + +## Logging +------- + +The `AgentRearrange` class includes logging capabilities using the `loguru` library. If `verbose` is set to `True` during initialization, a log file named `agent_rearrange.log` will be created, and log messages will be written to it. You can use this log file to track the execution of the agents and any potential issues or errors that may occur. + + +```bash +2023-05-08 10:30:15.456 | INFO | agent_rearrange:__init__:34 - Adding agent Director to the swarm. +2023-05-08 10:30:15.457 | INFO | agent_rearrange:__init__:34 - Adding agent Worker1 to the swarm. +2023-05-08 10:30:15.457 | INFO | agent_rearrange:__init__:34 - Adding agent Worker2 to the swarm. +2023-05-08 10:30:15.458 | INFO | agent_rearrange:run:118 - Running agents in parallel: ['Worker1', 'Worker2'] +2023-05-08 10:30:15.459 | INFO | agent_rearrange:run:121 - Running agents sequentially: ['Director']` +``` + +## Additional Parameters +--------------------- + +The `AgentRearrange` class also accepts additional parameters that can be passed to the `run` method using `*args` and `**kwargs`. These parameters will be forwarded to the individual agents during execution. + +`agent_system = AgentRearrange(agents=agents, flow=flow)` +`output = agent_system.run("Some task", max_tokens=200, temperature=0.7)` + +In this example, the `max_tokens` and `temperature` parameters will be passed to each agent during execution. + +## Customization +------------- + +The `AgentRearrange` class and the `rearrange` function can be customized and extended to suit specific use cases. For example, you can create custom agents by inheriting from the `Agent` class and implementing custom logic for task processing. You can then add these custom agents to the swarm and define the flow pattern accordingly. + +Additionally, you can modify the `run` method of the `AgentRearrange` class to implement custom logic for task processing and agent interaction. + + +## Limitations +----------- + +It's important to note that the `AgentRearrange` class and the `rearrange` function rely on the individual agents to process tasks correctly. The quality of the output will depend on the capabilities and configurations of the agents used in the swarm. Additionally, the `AgentRearrange` class does not provide any mechanisms for task prioritization or load balancing among the agents. + +## Future Improvements +------------------- + +Here are some potential future improvements for the `AgentRearrange` class and the `rearrange` function: + +- **Task Prioritization**: Implement a mechanism to prioritize tasks based on factors such as urgency, importance, or resource availability. +- **Load Balancing**: Incorporate load balancing algorithms to distribute tasks among agents more efficiently, taking into account factors such as agent availability, performance, and resource utilization. +- **Dynamic Flow Reconfiguration**: Allow for dynamic reconfiguration of the flow pattern during runtime, enabling the addition, removal, or reordering of agents based on specific conditions or events. +- **Error Handling and Fault Tolerance**: Enhance error handling and fault tolerance mechanisms to gracefully handle agent failures, task timeouts, or other exceptional situations. +- **Monitoring and Metrics**: Implement monitoring and metrics collection to track the performance and efficiency of the swarm, as well as individual agent performance. +- **Scalability**: Enhance the scalability of the system to handle larger numbers of agents and tasks efficiently. + +## Conclusion +---------- + +The `AgentRearrange` class and the `rearrange` function provide a flexible and extensible framework for orchestrating swarms of agents to process tasks based on a specified flow pattern. By combining the capabilities of individual agents, you can create complex workflows and leverage the strengths of different agents to tackle various tasks efficiently. + +While the current implementation offers basic functionality for agent rearrangement, there is room for future improvements and customizations to enhance the system's capabilities and cater to more specific use cases. + +Whether you're working on natural language processing tasks, data analysis, or any other domain where agent-based systems can be beneficial, the `AgentRearrange` class and the `rearrange` function provide a solid foundation for building and experimenting with swarm-based solutions. \ No newline at end of file From 6adc22a8d045c363fdce014159cfbc776ca8cbe3 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 21:54:47 -0400 Subject: [PATCH 14/22] [FEAT][The Swarms Framework: Orchestrating Agents for Enterprise Automation] --- README.md | 2 +- docs/mkdocs.yml | 27 +++--- docs/why.md | 167 ++++++++++++++++++++++++++++++++++++ pyproject.toml | 4 +- swarms/__init__.py | 2 +- swarms/structs/agent.py | 2 +- swarms/structs/rearrange.py | 2 +- 7 files changed, 183 insertions(+), 23 deletions(-) create mode 100644 docs/why.md diff --git a/README.md b/README.md index 364ad470..d63922a4 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ Individual agents face five significant challenges that hinder their deployment ---- ## Install -`$ pip3 install -U swarms` +`$ pip3 install -U swarms==4.9.7` --- diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index ff0d293d..f8c9dd2d 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -150,26 +150,18 @@ nav: - Foundational Structures: - Agent: "swarms/structs/agent.md" - basestructure: "swarms/structs/basestructure.md" - - taskinput: "swarms/structs/taskinput.md" - - stepinput: "swarms/structs/stepinput.md" - - artifact: "swarms/structs/artifact.md" - - task: "swarms/structs/task.md" - - Task Queue Base: "swarms/structs/taskqueuebase.md" + - Task: "swarms/structs/task.md" - YamlModel: "swarms/structs/yaml_model.md" - - AgentRearrange: "swarms/structs/agent_rearrange.md" - Workflows: - - recursiveworkflow: "swarms/structs/recursiveworkflow.md" - - concurrentworkflow: "swarms/structs/concurrentworkflow.md" - - nonlinearworkflow: "swarms/structs/nonlinearworkflow.md" - - sequential_workflow: "swarms/structs/sequential_workflow.md" - - workflow: "swarms/structs/workflow.md" - - baseworkflow: "swarms/structs/baseworkflow.md" + - RecursiveWorkflow: "swarms/structs/recursiveworkflow.md" + - ConcurrentWorkflow: "swarms/structs/concurrentworkflow.md" + - SequentialWorkflow: "swarms/structs/sequential_workflow.md" + - BaseWorkflow: "swarms/structs/baseworkflow.md" - Multi Agent Architectures: - - conversation: "swarms/structs/conversation.md" - - groupchat: "swarms/structs/groupchat.md" - - swarmnetwork: "swarms/structs/swarmnetwork.md" - - groupchatmanager: "swarms/structs/groupchatmanager.md" + - Conversation: "swarms/structs/conversation.md" + - SwarmNetwork: "swarms/structs/swarmnetwork.md" - MajorityVoting: "swarms/structs/majorityvoting.md" + - AgentRearrange: "swarms/structs/agent_rearrange.md" - swarms.memory: - Building Custom Vector Memory Databases with the BaseVectorDatabase Class: "swarms/memory/diy_memory.md" - ShortTermMemory: "swarms/memory/short_term_memory.md" @@ -191,7 +183,8 @@ nav: - Overview: "applications/customer_support.md" - Marketing: - Overview: "applications/marketing_agencies.md" - - Swarm of Automated Business Analysis: "applications/business-analyst-agent.md" + - Operations: + - Swarm of Automated Business Analysis: "applications/business-analyst-agent.md" - Corporate: - Corporate Documents: - Data Room: "corporate/data_room.md" diff --git a/docs/why.md b/docs/why.md new file mode 100644 index 00000000..3e72172c --- /dev/null +++ b/docs/why.md @@ -0,0 +1,167 @@ +# The Swarms Framework: Orchestrating Agents for Enterprise Automation + +In the rapidly evolving landscape of artificial intelligence (AI) and automation, a new paradigm is emerging: the orchestration of multiple agents working in collaboration to tackle complex tasks. This approach, embodied by the Swarms Framework, aims to address the fundamental limitations of individual agents and unlocks the true potential of AI-driven automation in enterprise operations. + +## The Purpose of Swarms: Overcoming Agent Limitations + +Individual agents, while remarkable in their own right, face several inherent challenges that hinder their ability to effectively automate enterprise operations at scale. These limitations include: + +1. Short-Term Memory Constraints +2. Hallucination and Factual Inconsistencies +3. Single-Task Limitations +4. Lack of Collaborative Capabilities +5. Cost Inefficiencies + +By orchestrating multiple agents to work in concert, the Swarms Framework directly tackles these limitations, paving the way for more efficient, reliable, and cost-effective enterprise automation. + +### Limitation 1: Short-Term Memory Constraints + +Many AI agents, particularly those based on large language models, suffer from short-term memory constraints. These agents can effectively process and respond to prompts, but their ability to retain and reason over information across multiple interactions or tasks is limited. This limitation can be problematic in enterprise environments, where complex workflows often involve retaining and referencing contextual information over extended periods. + +The Swarms Framework addresses this limitation by leveraging the collective memory of multiple agents working in tandem. While individual agents may have limited short-term memory, their combined memory pool becomes significantly larger, enabling the retention and retrieval of contextual information over extended periods. This collective memory is facilitated by agents specializing in information storage and retrieval, such as those based on systems like Llama Index or Pinecone. + +### Limitation 2: Hallucination and Factual Inconsistencies + +Another challenge faced by many AI agents is the tendency to generate responses that may contain factual inconsistencies or hallucinations -- information that is not grounded in reality or the provided context. This issue can undermine the reliability and trustworthiness of automated systems, particularly in domains where accuracy and consistency are paramount. + +The Swarms Framework mitigates this limitation by employing multiple agents with diverse knowledge bases and capabilities. By leveraging the collective intelligence of these agents, the framework can cross-reference and validate information, reducing the likelihood of hallucinations and factual inconsistencies. Additionally, specialized agents can be tasked with fact-checking and verification, further enhancing the overall reliability of the system. + +### Limitation 3: Single-Task Limitations + +Most individual AI agents are designed and optimized for specific tasks or domains, limiting their ability to handle complex, multi-faceted workflows that often characterize enterprise operations. While an agent may excel at a particular task, such as natural language processing or data analysis, it may struggle with other aspects of a larger workflow, such as task coordination or decision-making. + +The Swarms Framework overcomes this limitation by orchestrating a diverse ensemble of agents, each specializing in different tasks or capabilities. By intelligently combining and coordinating these agents, the framework can tackle complex, multi-threaded workflows that span various domains and task types. This modular approach allows for the seamless integration of new agents as they become available, enabling the continuous expansion and enhancement of the system's capabilities. + +### Limitation 4: Lack of Collaborative Capabilities + +Most AI agents are designed to operate independently, lacking the ability to effectively collaborate with other agents or coordinate their actions towards a common goal. This limitation can hinder the scalability and efficiency of automated systems, particularly in enterprise environments where tasks often require the coordination of multiple agents or systems. + +The Swarms Framework addresses this limitation by introducing a layer of coordination and collaboration among agents. Through specialized coordination agents and communication protocols, the framework enables agents to share information, divide tasks, and synchronize their actions. This collaborative approach not only increases efficiency but also enables the emergence of collective intelligence, where the combined capabilities of multiple agents surpass the sum of their individual abilities. + +### Limitation 5: Cost Inefficiencies + +Running large AI models or orchestrating multiple agents can be computationally expensive, particularly in enterprise environments where scalability and cost-effectiveness are critical considerations. Inefficient resource utilization or redundant computations can quickly escalate costs, making widespread adoption of AI-driven automation financially prohibitive. + +The Swarms Framework tackles this limitation by optimizing resource allocation and workload distribution among agents. By intelligently assigning tasks to the most appropriate agents and leveraging agent specialization, the framework minimizes redundant computations and improves overall resource utilization. Additionally, the framework can dynamically scale agent instances based on demand, ensuring that computational resources are allocated efficiently and costs are minimized. + +## The Swarms Framework: A Holistic Approach to Enterprise Automation + +The Swarms Framework is a comprehensive solution that addresses the limitations of individual agents by orchestrating their collective capabilities. By integrating agents from various frameworks, including LangChain, AutoGPT, Llama Index, and others, the framework leverages the strengths of each agent while mitigating their individual weaknesses. + +At its core, the Swarms Framework operates on the principle of multi-agent collaboration. By introducing specialized coordination agents and communication protocols, the framework enables agents to share information, divide tasks, and synchronize their actions towards a common goal. This collaborative approach not only increases efficiency but also enables the emergence of collective intelligence, where the combined capabilities of multiple agents surpass the sum of their individual abilities. + +The framework's architecture is modular and extensible, allowing for the seamless integration of new agents as they become available. This flexibility ensures that the system's capabilities can continuously expand and adapt to evolving enterprise needs and technological advancements. + +### Key Components of the Swarms Framework + +To orchestrate the collaboration of multiple agents effectively, the Swarms Framework comprises several key components: + +1. Agent Registry +2. Task Orchestrator +3. Memory Manager +4. Communication Protocol +5. Monitoring and Analytics + +## Agent Registry + +The Agent Registry is a centralized repository that maintains a catalog of available agents and their associated capabilities. Each agent is registered with its unique identifier, specialized tasks, input/output requirements, and resource constraints. This registry serves as a reference point for the Task Orchestrator, enabling efficient agent selection and task assignment based on the specific requirements of a given workflow. + +## Task Orchestrator + +The Task Orchestrator is the central component responsible for coordinating the execution of complex workflows across multiple agents. It receives task requests, analyzes the requirements, and dynamically constructs a task graph by selecting and sequencing the appropriate agents from the Agent Registry. + +The Task Orchestrator employs sophisticated algorithms and heuristics to optimize task assignments, ensuring that the right agents are assigned to the appropriate tasks based on their capabilities and resource constraints. It also manages task dependencies, parallelization, and synchronization, enabling efficient execution of multi-threaded workflows. + +## Memory Manager + +The Memory Manager is a critical component that addresses the short-term memory constraints of individual agents. It acts as a centralized repository for storing and retrieving contextual information, enabling agents to access and build upon shared knowledge across multiple tasks and interactions. + +The Memory Manager leverages specialized agents, such as those based on Llama Index or Pinecone, to store and index information in a structured and efficient manner. This component also manages access control and data persistence, ensuring that sensitive information is handled securely and in compliance with enterprise policies. + +## Communication Protocol + +The Communication Protocol defines the rules and mechanisms for agents to exchange information and coordinate their actions. It establishes a common language and messaging format, enabling agents to seamlessly share data, request assistance, or delegate tasks to other agents within the framework. + +The Communication Protocol also handles error handling, message routing, and conflict resolution, ensuring that agents can collaborate effectively and recover gracefully from failures or inconsistencies. + +## Monitoring and Analytics + +The Monitoring and Analytics component provides comprehensive visibility into the operations of the Swarms Framework. It collects and analyzes data from various components, including agent performance metrics, resource utilization, task execution logs, and error reports. + +This component leverages advanced analytics and visualization tools to provide insights into system performance, bottlenecks, and areas for optimization. It also supports alerting and reporting mechanisms, enabling stakeholders to monitor the system's health and make informed decisions regarding capacity planning, resource allocation, and process improvements. + +## Benefits of the Swarms Framework + +The adoption of the Swarms Framework in enterprise environments offers numerous benefits: + +1. Increased Efficiency and Scalability +2. Improved Reliability and Accuracy +3. Adaptability and Continuous Improvement +4. Cost Optimization +5. Enhanced Security and Compliance + +## Increased Efficiency and Scalability + +By orchestrating the collective capabilities of multiple agents, the Swarms Framework enables the efficient execution of complex, multi-threaded workflows. Tasks can be parallelized and distributed across specialized agents, reducing bottlenecks and increasing overall throughput. Additionally, the framework's modular design and ability to dynamically scale agent instances based on demand ensure that the system can adapt to changing workloads and scale seamlessly as enterprise needs evolve. + +## Improved Reliability and Accuracy + +The collaborative nature of the Swarms Framework reduces the risk of hallucinations and factual inconsistencies that can arise from individual agents. By leveraging the collective knowledge and diverse perspectives of multiple agents, the framework can cross-reference and validate information, enhancing the overall reliability and accuracy of its outputs. + +Additionally, the framework's ability to incorporate specialized fact-checking and verification agents further strengthens the trustworthiness of the system's outcomes, ensuring that critical decisions and actions are based on accurate and reliable information. + +## Adaptability and Continuous Improvement + +The modular architecture of the Swarms Framework allows for the seamless integration of new agents as they become available, enabling the continuous expansion and enhancement of the system's capabilities. As new AI models, algorithms, or data sources emerge, the framework can readily incorporate them, ensuring that enterprise operations remain at the forefront of technological advancements. + +Furthermore, the framework's monitoring and analytics capabilities provide valuable insights into system performance, enabling the identification of areas for improvement and the optimization of agent selection, task assignments, and resource allocation strategies over time. + +## Cost Optimization + +By intelligently orchestrating the collaboration of multiple agents, the Swarms Framework optimizes resource utilization and minimizes redundant computations. This efficient use of computational resources translates into cost savings, making the widespread adoption of AI-driven automation more financially viable for enterprises. + +The framework's ability to dynamically scale agent instances based on demand further contributes to cost optimization, ensuring that resources are allocated only when needed and minimizing idle or underutilized instances. + +## Enhanced Security and Compliance + +In enterprise environments, ensuring the security and compliance of automated systems is paramount. The Swarms Framework addresses these concerns by incorporating robust security measures and compliance controls. + +The framework's centralized Memory Manager component enables the implementation of access control mechanisms and data encryption, protecting sensitive information from unauthorized access or breaches. Additionally, the framework's modular design allows for the integration of specialized agents focused on compliance monitoring and auditing, ensuring that enterprise operations adhere to relevant regulations and industry standards. + +## Real-World Applications and Use Cases + +The Swarms Framework finds applications across a wide range of enterprise domains, enabling organizations to automate complex operations and streamline their workflows. Here are some examples of real-world use cases: + +1. Intelligent Process Automation (IPA) +2. Customer Service and Support +3. Fraud Detection and Risk Management +4. Supply Chain Optimization +5. Research and Development + +## Intelligent Process Automation (IPA) + +In the realm of business process automation, the Swarms Framework can orchestrate agents to automate and optimize complex workflows spanning multiple domains and task types. By combining agents specialized in areas such as natural language processing, data extraction, decision-making, and task coordination, the framework can streamline and automate processes that traditionally required manual intervention or coordination across multiple systems. + +## Customer Service and Support + +The framework's ability to integrate agents with diverse capabilities, such as natural language processing, knowledge retrieval, and decision-making, makes it well-suited for automating customer service and support operations. Agents can collaborate to understand customer inquiries, retrieve relevant information from knowledge bases, and provide accurate and personalized responses, improving customer satisfaction and reducing operational costs. + +## Fraud Detection and Risk Management + +In the financial and cybersecurity domains, the Swarms Framework can orchestrate agents specialized in data analysis, pattern recognition, and risk assessment to detect and mitigate fraudulent activities or security threats. By combining the collective intelligence of these agents, the framework can identify complex patterns and anomalies that may be difficult for individual agents to detect, enhancing the overall effectiveness of fraud detection and risk management strategies. + +## Supply Chain Optimization + +The complexity of modern supply chains often requires the coordination of multiple systems and stakeholders. The Swarms Framework can integrate agents specialized in areas such as demand forecasting, inventory management, logistics optimization, and supplier coordination to streamline and optimize supply chain operations. By orchestrating the collective capabilities of these agents, the framework can identify bottlenecks, optimize resource allocation, and facilitate seamless collaboration among supply chain partners. + +## Research and Development + +In research and development environments, the Swarms Framework can accelerate innovation by enabling the collaboration of agents specialized in areas such as literature review, data analysis, hypothesis generation, and experiment design. By orchestrating these agents, the framework can facilitate the exploration of new ideas, identify promising research directions, and streamline the iterative process of scientific inquiry. + +# Conclusion + +The Swarms Framework represents a paradigm shift in the field of enterprise automation, addressing the limitations of individual agents by orchestrating their collective capabilities. By integrating agents from various frameworks and enabling multi-agent collaboration, the Swarms Framework overcomes challenges such as short-term memory constraints, hallucinations, single-task limitations, lack of collaboration, and cost inefficiencies. + +Through its modular architecture, centralized coordination, and advanced monitoring and analytics capabilities, the Swarms Framework empowers enterprises to automate complex operations with increased efficiency, reliability, and adaptability. It unlocks the true potential of AI-driven automation, enabling organizations to stay ahead of the curve and thrive in an ever-evolving technological landscape. + +As the field of artificial intelligence continues to advance, the Swarms Framework stands as a robust and flexible solution, ready to embrace new developments and seamlessly integrate emerging agents and capabilities. By harnessing the power of collective intelligence, the framework paves the way for a future where enterprises can leverage the full potential of AI to drive innovation, optimize operations, and gain a competitive edge in their respective industries. \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 7ad13b11..045b134e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api" [tool.poetry] name = "swarms" -version = "4.9.2" +version = "4.9.8" description = "Swarms - Pytorch" license = "MIT" authors = ["Kye Gomez "] @@ -31,7 +31,7 @@ classifiers = [ [tool.poetry.dependencies] -python = ">=3.9,<4.0" +python = ">=3.10,<4.0" torch = ">=2.1.1,<3.0" transformers = ">= 4.39.0, <5.0.0" asyncio = ">=3.4.3,<4.0" diff --git a/swarms/__init__.py b/swarms/__init__.py index 23b8d3d5..2fea14ee 100644 --- a/swarms/__init__.py +++ b/swarms/__init__.py @@ -13,4 +13,4 @@ from swarms.prompts import * # noqa: E402, F403 from swarms.structs import * # noqa: E402, F403 from swarms.telemetry import * # noqa: E402, F403 from swarms.tools import * # noqa: E402, F403 -from swarms.utils import * # noqa: E402, F403 +from swarms.utils import * # noqa: E402, F403 \ No newline at end of file diff --git a/swarms/structs/agent.py b/swarms/structs/agent.py index b5f7e7ec..629ca0f8 100644 --- a/swarms/structs/agent.py +++ b/swarms/structs/agent.py @@ -1332,7 +1332,7 @@ class Agent: "pdf_path": self.pdf_path, "list_of_pdf": self.list_of_pdf, "tokenizer": self.tokenizer, - "long_term_memory": self.long_term_memory, + # "long_term_memory": self.long_term_memory, "preset_stopping_token": self.preset_stopping_token, "traceback": self.traceback, "traceback_handlers": self.traceback_handlers, diff --git a/swarms/structs/rearrange.py b/swarms/structs/rearrange.py index cc540586..00425d50 100644 --- a/swarms/structs/rearrange.py +++ b/swarms/structs/rearrange.py @@ -1,4 +1,4 @@ -from swarms import Agent +from swarms.structs.agent import Agent from typing import List from swarms.structs.base_swarm import BaseSwarm from swarms.utils.loguru_logger import logger From 993fca86d09dafddb27c35fbb6518d76ddf46777 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 21:56:42 -0400 Subject: [PATCH 15/22] [FEAT][Why Swarms? Orchestrating Agents for Enterprise Automation] --- docs/mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index f8c9dd2d..b2aa3b0b 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -106,6 +106,7 @@ nav: - Home: - Overview: "index.md" - Install: "install.md" + - Why Swarms? Orchestrating Agents for Enterprise Automation: "why.md" - Limitations of Individual Agents: "limits_of_individual_agents.md" - Build an Agent: "diy_your_own_agent.md" - Build an Agent with tools: "examples/tools_agents.md" From 4bbae88a64091f7b4de69855bc70d19523992f75 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 22:06:25 -0400 Subject: [PATCH 16/22] [DOCS][CLEANUP] --- docs/mkdocs.yml | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index b2aa3b0b..6c707914 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -41,14 +41,6 @@ plugins: # token: !ENV ["GITHUB_TOKEN"] - git-revision-date-localized: enable_creation_date: true - # - minify_html - # - redirects - # - mkdocs-simple-hooks - # - awesome-pages - # - mkdocs-versioning - # # - mkdocs-include-markdown-plugin - # - enumerate-headings - # - autolinks copyright: "© TGSC, Corporation." extra_css: @@ -150,7 +142,7 @@ nav: - swarms.structs: - Foundational Structures: - Agent: "swarms/structs/agent.md" - - basestructure: "swarms/structs/basestructure.md" + - BaseStructure: "swarms/structs/basestructure.md" - Task: "swarms/structs/task.md" - YamlModel: "swarms/structs/yaml_model.md" - Workflows: @@ -185,7 +177,7 @@ nav: - Marketing: - Overview: "applications/marketing_agencies.md" - Operations: - - Swarm of Automated Business Analysis: "applications/business-analyst-agent.md" + - Intoducing The Swarm of Automated Business Analyts: "applications/business-analyst-agent.md" - Corporate: - Corporate Documents: - Data Room: "corporate/data_room.md" From 68a91fb7bb4cd7b1ca10243299fcd453b018abdf Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 22:08:40 -0400 Subject: [PATCH 17/22] [DOCS][CLEANUP] --- docs/why.md | 37 ------------------------------------- 1 file changed, 37 deletions(-) diff --git a/docs/why.md b/docs/why.md index 3e72172c..2e4f0bce 100644 --- a/docs/why.md +++ b/docs/why.md @@ -52,43 +52,6 @@ At its core, the Swarms Framework operates on the principle of multi-agent colla The framework's architecture is modular and extensible, allowing for the seamless integration of new agents as they become available. This flexibility ensures that the system's capabilities can continuously expand and adapt to evolving enterprise needs and technological advancements. -### Key Components of the Swarms Framework - -To orchestrate the collaboration of multiple agents effectively, the Swarms Framework comprises several key components: - -1. Agent Registry -2. Task Orchestrator -3. Memory Manager -4. Communication Protocol -5. Monitoring and Analytics - -## Agent Registry - -The Agent Registry is a centralized repository that maintains a catalog of available agents and their associated capabilities. Each agent is registered with its unique identifier, specialized tasks, input/output requirements, and resource constraints. This registry serves as a reference point for the Task Orchestrator, enabling efficient agent selection and task assignment based on the specific requirements of a given workflow. - -## Task Orchestrator - -The Task Orchestrator is the central component responsible for coordinating the execution of complex workflows across multiple agents. It receives task requests, analyzes the requirements, and dynamically constructs a task graph by selecting and sequencing the appropriate agents from the Agent Registry. - -The Task Orchestrator employs sophisticated algorithms and heuristics to optimize task assignments, ensuring that the right agents are assigned to the appropriate tasks based on their capabilities and resource constraints. It also manages task dependencies, parallelization, and synchronization, enabling efficient execution of multi-threaded workflows. - -## Memory Manager - -The Memory Manager is a critical component that addresses the short-term memory constraints of individual agents. It acts as a centralized repository for storing and retrieving contextual information, enabling agents to access and build upon shared knowledge across multiple tasks and interactions. - -The Memory Manager leverages specialized agents, such as those based on Llama Index or Pinecone, to store and index information in a structured and efficient manner. This component also manages access control and data persistence, ensuring that sensitive information is handled securely and in compliance with enterprise policies. - -## Communication Protocol - -The Communication Protocol defines the rules and mechanisms for agents to exchange information and coordinate their actions. It establishes a common language and messaging format, enabling agents to seamlessly share data, request assistance, or delegate tasks to other agents within the framework. - -The Communication Protocol also handles error handling, message routing, and conflict resolution, ensuring that agents can collaborate effectively and recover gracefully from failures or inconsistencies. - -## Monitoring and Analytics - -The Monitoring and Analytics component provides comprehensive visibility into the operations of the Swarms Framework. It collects and analyzes data from various components, including agent performance metrics, resource utilization, task execution logs, and error reports. - -This component leverages advanced analytics and visualization tools to provide insights into system performance, bottlenecks, and areas for optimization. It also supports alerting and reporting mechanisms, enabling stakeholders to monitor the system's health and make informed decisions regarding capacity planning, resource allocation, and process improvements. ## Benefits of the Swarms Framework From ea62d98887e021a433d4fbc5790e6d87378b4fa2 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 22:15:40 -0400 Subject: [PATCH 18/22] [FEAT][DOCS] --- docs/mkdocs.yml | 1 + docs/swarms/models/llama3.md | 96 ++++++++++++++++++++++++++ docs/swarms/structs/agent_rearrange.md | 3 +- 3 files changed, 98 insertions(+), 2 deletions(-) create mode 100644 docs/swarms/models/llama3.md diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 6c707914..2156b9cd 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -124,6 +124,7 @@ nav: - Language: - BaseLLM: "swarms/models/base_llm.md" - Overview: "swarms/models/index.md" + - Llava3: "swarms/models/llama3.md" - HuggingFaceLLM: "swarms/models/huggingface.md" - Anthropic: "swarms/models/anthropic.md" - OpenAI: "swarms/models/openai.md" diff --git a/docs/swarms/models/llama3.md b/docs/swarms/models/llama3.md new file mode 100644 index 00000000..4ae0f1ef --- /dev/null +++ b/docs/swarms/models/llama3.md @@ -0,0 +1,96 @@ +## Llava3 + + +```python +from transformers import AutoTokenizer, AutoModelForCausalLM +import torch +from swarms.models.base_llm import BaseLLM + + +class Llama3(BaseLLM): + """ + Llama3 class represents a Llama model for natural language generation. + + Args: + model_id (str): The ID of the Llama model to use. + system_prompt (str): The system prompt to use for generating responses. + temperature (float): The temperature value for controlling the randomness of the generated responses. + top_p (float): The top-p value for controlling the diversity of the generated responses. + max_tokens (int): The maximum number of tokens to generate in the response. + **kwargs: Additional keyword arguments. + + Attributes: + model_id (str): The ID of the Llama model being used. + system_prompt (str): The system prompt for generating responses. + temperature (float): The temperature value for generating responses. + top_p (float): The top-p value for generating responses. + max_tokens (int): The maximum number of tokens to generate in the response. + tokenizer (AutoTokenizer): The tokenizer for the Llama model. + model (AutoModelForCausalLM): The Llama model for generating responses. + + Methods: + run(task, *args, **kwargs): Generates a response for the given task. + + """ + + def __init__( + self, + model_id="meta-llama/Meta-Llama-3-8B-Instruct", + system_prompt: str = None, + temperature: float = 0.6, + top_p: float = 0.9, + max_tokens: int = 4000, + **kwargs, + ): + self.model_id = model_id + self.system_prompt = system_prompt + self.temperature = temperature + self.top_p = top_p + self.max_tokens = max_tokens + self.tokenizer = AutoTokenizer.from_pretrained(model_id) + self.model = AutoModelForCausalLM.from_pretrained( + model_id, + torch_dtype=torch.bfloat16, + device_map="auto", + ) + + def run(self, task: str, *args, **kwargs): + """ + Generates a response for the given task. + + Args: + task (str): The user's task or input. + + Returns: + str: The generated response. + + """ + messages = [ + {"role": "system", "content": self.system_prompt}, + {"role": "user", "content": task}, + ] + + input_ids = self.tokenizer.apply_chat_template( + messages, add_generation_prompt=True, return_tensors="pt" + ).to(self.model.device) + + terminators = [ + self.tokenizer.eos_token_id, + self.tokenizer.convert_tokens_to_ids("<|eot_id|>"), + ] + + outputs = self.model.generate( + input_ids, + max_new_tokens=self.max_tokens, + eos_token_id=terminators, + do_sample=True, + temperature=self.temperature, + top_p=self.top_p, + *args, + **kwargs, + ) + response = outputs[0][input_ids.shape[-1] :] + return self.tokenizer.decode( + response, skip_special_tokens=True + ) +``` \ No newline at end of file diff --git a/docs/swarms/structs/agent_rearrange.md b/docs/swarms/structs/agent_rearrange.md index 09599f04..967b69f7 100644 --- a/docs/swarms/structs/agent_rearrange.md +++ b/docs/swarms/structs/agent_rearrange.md @@ -114,9 +114,8 @@ rearrange(agents, flow, task) Here's an example of how to use the `AgentRearrange` class and the `rearrange` function: ```python -from swarms import Agent +from swarms import Agent, AgentRearrange, rearrange from typing import List -from agent_rearrange import AgentRearrange, rearrange # Initialize the director agent director = Agent( From 4e64014974eeedd25cd67308574cfe68c7d61b52 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 22:20:13 -0400 Subject: [PATCH 19/22] [DOCS] --- docs/index.md | 2 +- docs/install.md | 2 +- docs/mkdocs.yml | 10 +++++++--- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/docs/index.md b/docs/index.md index 9150e68d..c28ab5b5 100644 --- a/docs/index.md +++ b/docs/index.md @@ -16,7 +16,7 @@ Swarms provides you with all the building blocks you need to build reliable, pro ## 💻 Install You can install `swarms` with pip in a -[**Python>=3.8**](https://www.python.org/) environment. +[**Python>=3.10**](https://www.python.org/) environment. !!! example "pip install (recommended)" diff --git a/docs/install.md b/docs/install.md index 716f1f31..038d0310 100644 --- a/docs/install.md +++ b/docs/install.md @@ -12,7 +12,7 @@ # Installation Guide You can install `swarms` with pip in a -[**Python>=3.8**](https://www.python.org/) environment. +[**Python>=3.10**](https://www.python.org/) environment. !!! example "pip install (recommended)" diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 2156b9cd..4e63397e 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -96,13 +96,17 @@ markdown_extensions: - footnotes nav: - Home: + - Installation: - Overview: "index.md" - Install: "install.md" - - Why Swarms? Orchestrating Agents for Enterprise Automation: "why.md" - - Limitations of Individual Agents: "limits_of_individual_agents.md" + - Docker Setup: docker_setup.md + - Usage Examples: - Build an Agent: "diy_your_own_agent.md" - Build an Agent with tools: "examples/tools_agents.md" - - Docker Setup: docker_setup.md + - What & Why?: + - Why Swarms? Orchestrating Agents for Enterprise Automation: "why.md" + - Limitations of Individual Agents: "limits_of_individual_agents.md" + - Swarms Cloud API: - Overview: "swarms_cloud/main.md" - Available Models: "swarms_cloud/available_models.md" From c731eba128bc70004aa64f53c8c2c5259d3fcc46 Mon Sep 17 00:00:00 2001 From: Kye Date: Wed, 8 May 2024 22:31:31 -0400 Subject: [PATCH 20/22] [DOCS] --- docs/install.md | 6 ------ docs/mkdocs.yml | 15 +-------------- 2 files changed, 1 insertion(+), 20 deletions(-) diff --git a/docs/install.md b/docs/install.md index 038d0310..978466a4 100644 --- a/docs/install.md +++ b/docs/install.md @@ -23,12 +23,6 @@ You can install `swarms` with pip in a pip install swarms ``` -!!! example "pip install (recommended)" - If the installation above doesn't work try the following with PIP3 - - ```bash - pip3 install -U swarms - ``` !!! example "git clone (for development)" diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 4e63397e..11565f02 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -117,11 +117,6 @@ nav: - Overview: "swarms/index.md" - DIY Build Your Own Agent: "diy_your_own_agent.md" - Agents with Tools: "examples/tools_agent.md" - - swarms.agents: - - Agents: - - WorkerAgent: "swarms/agents/workeragent.md" - - AbstractAgent: "swarms/agents/abstractagent.md" - - ToolAgent: "swarms/agents/toolagent.md" - swarms.models: - How to Create A Custom Language Model: "swarms/models/custom_model.md" - Deploying Azure OpenAI in Production A Comprehensive Guide: "swarms/models/azure_openai.md" @@ -164,6 +159,7 @@ nav: - Building Custom Vector Memory Databases with the BaseVectorDatabase Class: "swarms/memory/diy_memory.md" - ShortTermMemory: "swarms/memory/short_term_memory.md" - Guides: + - Agents: - Building Custom Vector Memory Databases with the BaseVectorDatabase Class: "swarms/memory/diy_memory.md" - How to Create A Custom Language Model: "swarms/models/custom_model.md" - Deploying Azure OpenAI in Production, A Comprehensive Guide: "swarms/models/azure_openai.md" @@ -189,9 +185,6 @@ nav: - The Swarm Memo: "corporate/swarm_memo.md" - Corporate Architecture: "corporate/architecture.md" - Flywheel: "corporate/flywheel.md" - - Bounties: "corporate/bounties.md" - - Purpose: "corporate/purpose.md" - - Roadmap: "corporate/roadmap.md" - Sales: - FAQ: "corporate/faq.md" - Distribution: "corporate/distribution" @@ -200,13 +193,7 @@ nav: - Weaknesses: "corporate/failures.md" - Design: "corporate/design.md" - Metric: "corporate/metric.md" - - Research: "corporate/research.md" - - Demos: "corporate/demos.md" - - Checklist: "corporate/checklist.md" - Organization: - FrontEnd Member Onboarding: "corporate/front_end_contributors.md" - Contributors: - Contributing: "contributing.md" - - Why Swarms: "why_swarms.md" - - The Swarms Bounty System: "corporate/swarms_bounty_system.md" - From 47a1592d2a243d08d3d22e452999ca3b69986d26 Mon Sep 17 00:00:00 2001 From: Eternal Reclaimer <98760976+kyegomez@users.noreply.github.com> Date: Thu, 9 May 2024 10:03:56 -0400 Subject: [PATCH 21/22] Update mkdocs.yml --- docs/mkdocs.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 11565f02..6a1d8afd 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -103,7 +103,7 @@ nav: - Usage Examples: - Build an Agent: "diy_your_own_agent.md" - Build an Agent with tools: "examples/tools_agents.md" - - What & Why?: + - Why does Swarms Exist?: - Why Swarms? Orchestrating Agents for Enterprise Automation: "why.md" - Limitations of Individual Agents: "limits_of_individual_agents.md" @@ -146,7 +146,6 @@ nav: - Task: "swarms/structs/task.md" - YamlModel: "swarms/structs/yaml_model.md" - Workflows: - - RecursiveWorkflow: "swarms/structs/recursiveworkflow.md" - ConcurrentWorkflow: "swarms/structs/concurrentworkflow.md" - SequentialWorkflow: "swarms/structs/sequential_workflow.md" - BaseWorkflow: "swarms/structs/baseworkflow.md" @@ -190,7 +189,7 @@ nav: - Distribution: "corporate/distribution" - Product: - SwarmCloud: "corporate/swarm_cloud.md" - - Weaknesses: "corporate/failures.md" + - Weaknesses of Langchain: "corporate/failures.md" - Design: "corporate/design.md" - Metric: "corporate/metric.md" - Organization: From dd1af430138e94c347cd588f309fb9d8bba7d9b9 Mon Sep 17 00:00:00 2001 From: Kye Date: Thu, 9 May 2024 14:00:25 -0400 Subject: [PATCH 22/22] [CLEANUP] --- README.md | 62 +++++++++++++++++++++---------------------------------- 1 file changed, 24 insertions(+), 38 deletions(-) diff --git a/README.md b/README.md index d63922a4..5e7986b1 100644 --- a/README.md +++ b/README.md @@ -479,54 +479,40 @@ Sequential Workflow enables you to sequentially execute tasks with `Agent` and t ✅ Utilizes Agent class ```python -import os - -from dotenv import load_dotenv - -from swarms import Agent, OpenAIChat, SequentialWorkflow +from swarms import Agent, SequentialWorkflow, Anthropic -load_dotenv() - -# Load the environment variables -api_key = os.getenv("OPENAI_API_KEY") +# Initialize the language model agent (e.g., GPT-3) +llm = Anthropic() -# Initialize the language agent -llm = OpenAIChat( - temperature=0.5, model_name="gpt-4", openai_api_key=api_key, max_tokens=4000 +# Initialize agents for individual tasks +agent1 = Agent( + agent_name="Blog generator", + system_prompt="Generate a blog post like stephen king", + llm=llm, + max_loops=1, + dashboard=False, + tools=[], ) - - -# Initialize the agent with the language agent -agent1 = Agent(llm=llm, max_loops=1) - -# Create another agent for a different task -agent2 = Agent(llm=llm, max_loops=1) - -# Create another agent for a different task -agent3 = Agent(llm=llm, max_loops=1) - -# Create the workflow -workflow = SequentialWorkflow(max_loops=1) - -# Add tasks to the workflow -workflow.add( - agent1, - "Generate a 10,000 word blog on health and wellness.", +agent2 = Agent( + agent_name="summarizer", + system_prompt="Sumamrize the blog post", + llm=llm, + max_loops=1, + dashboard=False, + tools=[], ) -# Suppose the next task takes the output of the first task as input -workflow.add( - agent2, - "Summarize the generated blog", +# Create the Sequential workflow +workflow = SequentialWorkflow( + agents=[agent1, agent2], max_loops=1, verbose=False ) # Run the workflow -workflow.run() +workflow.run( + "Generate a blog post on how swarms of agents can help businesses grow." +) -# Output the results -for task in workflow.tasks: - print(f"Task: {task.description}, Result: {task.result}") ```