From 4d4d4ec2954b08247c6a2e1c847767b2f60ba246 Mon Sep 17 00:00:00 2001 From: Vishnu Satis Date: Sun, 17 Nov 2024 12:37:19 +0530 Subject: [PATCH] Facade changes for agent by code (#56) * facade changes for edit by code * Code facade example * Re-arraging the example files * Futher improving facade * Naming to_flo back to what it was * Fix build method issue * Fix for creating routed team * Simplified facade using create method * Fix for delegator facade --- examples/agentic_rag.ipynb | 6 +- examples/build_agents_by_code.ipynb | 170 ++++++------------ examples/{ => data}/rag_document.txt | 0 examples/email_reply_agent.ipynb | 4 +- examples/{ => python}/delegator_example.py | 0 .../hierarchical_blogging_team.py | 0 examples/{ => python}/linear_router_team.py | 0 examples/{ => python}/llm_extensibility.py | 0 examples/{ => python}/rag_tool.py | 2 +- examples/{ => python}/rag_with_reranking.py | 0 examples/{ => python}/reflection_example.py | 0 examples/{ => python}/simple_blogging_team.py | 0 examples/{ => python}/tool_agent.py | 0 examples/{ => python}/tool_error_handling.py | 0 flo_ai/__init__.py | 12 +- flo_ai/builders/yaml_builder.py | 10 +- flo_ai/core.py | 32 +++- flo_ai/models/flo_agent.py | 24 ++- flo_ai/models/flo_delegation_agent.py | 18 ++ flo_ai/models/flo_llm_agent.py | 18 ++ flo_ai/models/flo_rag.py | 76 -------- flo_ai/models/flo_reflection_agent.py | 20 +++ flo_ai/models/flo_team.py | 10 +- flo_ai/models/flo_tool_agent.py | 14 ++ flo_ai/router/flo_linear.py | 4 + flo_ai/router/flo_llm_router.py | 18 +- flo_ai/router/flo_router.py | 2 +- flo_ai/router/flo_supervisor.py | 16 ++ flo_ai/state/flo_session.py | 2 - 29 files changed, 237 insertions(+), 221 deletions(-) rename examples/{ => data}/rag_document.txt (100%) rename examples/{ => python}/delegator_example.py (100%) rename examples/{ => python}/hierarchical_blogging_team.py (100%) rename examples/{ => python}/linear_router_team.py (100%) rename examples/{ => python}/llm_extensibility.py (100%) rename examples/{ => python}/rag_tool.py (97%) rename examples/{ => python}/rag_with_reranking.py (100%) rename examples/{ => python}/reflection_example.py (100%) rename examples/{ => python}/simple_blogging_team.py (100%) rename examples/{ => python}/tool_agent.py (100%) rename examples/{ => python}/tool_error_handling.py (100%) delete mode 100644 flo_ai/models/flo_rag.py diff --git a/examples/agentic_rag.ipynb b/examples/agentic_rag.ipynb index 09f3b3f..a32b2ab 100644 --- a/examples/agentic_rag.ipynb +++ b/examples/agentic_rag.ipynb @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -66,7 +66,7 @@ ], "source": [ "# load the document and split it into chunks\n", - "loader = TextLoader(\"./rag_document.txt\")\n", + "loader = TextLoader(\"./data/rag_document.txt\")\n", "documents = loader.load()\n", "\n", "# split it into chunks\n", @@ -229,7 +229,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, diff --git a/examples/build_agents_by_code.ipynb b/examples/build_agents_by_code.ipynb index fa113b7..5af3e1a 100644 --- a/examples/build_agents_by_code.ipynb +++ b/examples/build_agents_by_code.ipynb @@ -26,7 +26,7 @@ } ], "source": [ - "from flo_ai import FloSupervisor, FloAgent, FloSession, FloTeam, FloLinear\n", + "from flo_ai import FloSupervisor, FloAgent, FloSession, FloTeam, FloLinear, Flo, FloLLMAgent\n", "from langchain_openai import ChatOpenAI\n", "from flo_ai.models.flo_reflection_agent import FloReflectionAgent\n", "from flo_ai.models.delegate import Delegate\n", @@ -47,17 +47,7 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Edge : Researcher to Head-of-Marketing\n", - "Edge : BlogWriter to Head-of-Marketing\n", - "Edge : __start__ to Head-of-Marketing\n" - ] - } - ], + "outputs": [], "source": [ "llm = ChatOpenAI(temperature=0, model_name='gpt-4o')\n", "session = FloSession(llm).register_tool(\n", @@ -65,23 +55,25 @@ " tool=TavilySearchResults()\n", ")\n", "\n", - "researcher = FloAgent.Builder(\n", + "researcher = FloAgent.create(\n", " session,\n", - " \"Researcher\", \n", - " \"Do a research on the internet and find articles of relevent to the topic asked by the user\", \n", - " [TavilySearchResults()]\n", - ").build()\n", + " name=\"Researcher\", \n", + " role=\"Internet Researcher\", # optional\n", + " job=\"Do a research on the internet and find articles of relevent to the topic asked by the user\", \n", + " tools=[TavilySearchResults()]\n", + ")\n", "\n", - "blogger = FloAgent.Builder(\n", + "blogger = FloAgent.create(\n", " session, \n", - " \"BlogWriter\", \n", - " \"Able to write a blog using information provided\", \n", - " [TavilySearchResults()]\n", - ").build()\n", + " name=\"BlogWriter\", \n", + " role=\"Thought Leader\", # optional\n", + " job=\"Able to write a blog using information provided\", \n", + " tools=[TavilySearchResults()]\n", + ")\n", "\n", - "marketing_team = FloTeam.Builder(session, \"Marketing\", [researcher, blogger]).build()\n", - "r1 = FloSupervisor.Builder(session, \"Head-of-Marketing\", marketing_team).build()\n", - "marketing_flo = r1.to_flo()\n" + "marketing_team = FloTeam.create(session, \"Marketing\", [researcher, blogger])\n", + "head_of_marketing = FloSupervisor.create(session, \"Head-of-Marketing\", marketing_team)\n", + "marketing_flo = Flo.create(session, routed_team=head_of_marketing)\n" ] }, { @@ -101,9 +93,7 @@ } ], "source": [ - "from IPython.display import Image, display\n", - "\n", - "display(Image(marketing_flo.draw()))" + "marketing_flo.draw()" ] }, { @@ -117,28 +107,27 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Edge : Senior-Editor to Editor-Team-Routing\n", - "Edge : __start__ to Editor-Team-Routing\n" - ] - } - ], + "outputs": [], "source": [ - "chief_editorial = FloAgent.Builder(\n", + "chief_editorial = FloLLMAgent.create(\n", + " session, \n", + " name=\"Senior-Editor\", \n", + " job=\"Have a look at the article created and give editorial suggestions\"\n", + ")\n", + "\n", + "edit_team = FloTeam.create(\n", " session, \n", - " \"Senior-Editor\", \n", - " \"Have a look at the article created and give editorial suggestions\", \n", - " [TavilySearchResults()]\n", - ").build()\n", + " name=\"Editorial-Team\", \n", + " members=[chief_editorial]\n", + ")\n", "\n", - "edit_team = FloTeam.Builder(session, \"Editorial-Team\", [chief_editorial]).build()\n", - "r2 = FloSupervisor.Builder(session, \"Editor-Team-Routing\", edit_team).build()\n", + "editor = FloSupervisor.create(\n", + " session, \n", + " name=\"Editor-Team-Routing\", \n", + " team=edit_team\n", + ")\n", "\n", - "editorial_flo = r2.to_flo()" + "editorial_flo = Flo.create(session, routed_team=editor)" ] }, { @@ -158,38 +147,24 @@ } ], "source": [ - "from IPython.display import Image, display\n", - "\n", - "display(Image(editorial_flo.draw()))" + "editorial_flo.draw()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Edge : __start__ to Marketing\n", - "Marketing\n", - "Editorial-Team\n", - "Edge : Marketing to Editorial-Team\n", - "Edge : Editorial-Team to __end__\n" - ] - } - ], + "outputs": [], "source": [ - "journal_company = FloTeam.Builder(session, \"Newspaper\", [marketing_flo, editorial_flo])\n", + "journal_company = FloTeam.create(session, \"Newspaper\", [marketing_flo, editorial_flo])\n", "\n", - "r3 = FloLinear.Builder(\n", + "r3 = FloLinear.create(\n", " session,\n", " \"linear-router\",\n", " journal_company\n", - ").build()\n", + ")\n", "\n", - "master_flo = r3.to_flo()" + "master_flo = Flo.create(session, routed_team=r3)" ] }, { @@ -209,9 +184,7 @@ } ], "source": [ - "from IPython.display import Image, display\n", - "\n", - "display(Image(master_flo.draw()))" + "master_flo.draw()" ] }, { @@ -225,71 +198,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Edge : __start__ to Marketing\n", - "Marketing\n", - "Editorial-Team\n", - "Edge : Marketing to Editorial-Team\n", - "Editorial-Team\n", - "journal-reflection\n", - "next node\n", - "__end__\n", - "add node\n", - "f/ReflectionManager\n", - "Edge : M to f/ReflectionManager\n", - "Edge : journal-reflection to M\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Found edge starting at unknown node 'M'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[9], line 16\u001b[0m\n\u001b[1;32m 8\u001b[0m journal_company_with_reflection \u001b[38;5;241m=\u001b[39m FloTeam\u001b[38;5;241m.\u001b[39mBuilder(session, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNewspaper\u001b[39m\u001b[38;5;124m\"\u001b[39m, [marketing_flo, editorial_flo, reflection_agent])\n\u001b[1;32m 10\u001b[0m r4 \u001b[38;5;241m=\u001b[39m FloLinear\u001b[38;5;241m.\u001b[39mBuilder(\n\u001b[1;32m 11\u001b[0m session,\n\u001b[1;32m 12\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlinear-router\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 13\u001b[0m journal_company_with_reflection\n\u001b[1;32m 14\u001b[0m )\u001b[38;5;241m.\u001b[39mbuild()\n\u001b[0;32m---> 16\u001b[0m master_flo_with_reflection \u001b[38;5;241m=\u001b[39m \u001b[43mr4\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_flo\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/hub/flo/flo_ai/router/flo_router.py:42\u001b[0m, in \u001b[0;36mFloRouter.to_flo\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_flo\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m FloRoutedTeam:\n\u001b[0;32m---> 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuild_graph\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/hub/flo/flo_ai/router/flo_linear.py:57\u001b[0m, in \u001b[0;36mFloLinear.build_graph\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m end_node\u001b[38;5;241m.\u001b[39mkind \u001b[38;5;241m!=\u001b[39m ExecutableType\u001b[38;5;241m.\u001b[39mdelegator:\n\u001b[1;32m 55\u001b[0m workflow\u001b[38;5;241m.\u001b[39madd_edge(end_node\u001b[38;5;241m.\u001b[39mname, END)\n\u001b[0;32m---> 57\u001b[0m workflow_graph \u001b[38;5;241m=\u001b[39m \u001b[43mworkflow\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m FloRoutedTeam(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mflo_team\u001b[38;5;241m.\u001b[39mname, workflow_graph)\n", - "File \u001b[0;32m~/Documents/hub/flo/.venv/lib/python3.11/site-packages/langgraph/graph/state.py:431\u001b[0m, in \u001b[0;36mStateGraph.compile\u001b[0;34m(self, checkpointer, store, interrupt_before, interrupt_after, debug)\u001b[0m\n\u001b[1;32m 428\u001b[0m interrupt_after \u001b[38;5;241m=\u001b[39m interrupt_after \u001b[38;5;129;01mor\u001b[39;00m []\n\u001b[1;32m 430\u001b[0m \u001b[38;5;66;03m# validate the graph\u001b[39;00m\n\u001b[0;32m--> 431\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalidate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 432\u001b[0m \u001b[43m \u001b[49m\u001b[43minterrupt\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 433\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43minterrupt_before\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minterrupt_before\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m!=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m*\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43minterrupt_after\u001b[49m\n\u001b[1;32m 434\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minterrupt_after\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m!=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m*\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 435\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 436\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 437\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 439\u001b[0m \u001b[38;5;66;03m# prepare output channels\u001b[39;00m\n\u001b[1;32m 440\u001b[0m output_channels \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 441\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__root__\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 442\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mschemas[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput]) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 448\u001b[0m ]\n\u001b[1;32m 449\u001b[0m )\n", - "File \u001b[0;32m~/Documents/hub/flo/.venv/lib/python3.11/site-packages/langgraph/graph/graph.py:370\u001b[0m, in \u001b[0;36mGraph.validate\u001b[0;34m(self, interrupt)\u001b[0m\n\u001b[1;32m 368\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m source \u001b[38;5;129;01min\u001b[39;00m all_sources:\n\u001b[1;32m 369\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m source \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnodes \u001b[38;5;129;01mand\u001b[39;00m source \u001b[38;5;241m!=\u001b[39m START:\n\u001b[0;32m--> 370\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFound edge starting at unknown node \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00msource\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 372\u001b[0m \u001b[38;5;66;03m# assemble targets\u001b[39;00m\n\u001b[1;32m 373\u001b[0m all_targets \u001b[38;5;241m=\u001b[39m {end \u001b[38;5;28;01mfor\u001b[39;00m _, end \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_all_edges}\n", - "\u001b[0;31mValueError\u001b[0m: Found edge starting at unknown node 'M'" - ] - } - ], + "outputs": [], "source": [ - "\n", - "reflection_agent = FloReflectionAgent.Builder(\n", + "reflection_agent = FloReflectionAgent.create(\n", " session,\n", " \"journal-reflection\",\n", " \"You are critic who looks are the article and create a list of improvements that can be done.\",\n", " Delegate(to=[\"Marketing\"], retry=1)\n", - ").build()\n", + ")\n", "\n", - "journal_company_with_reflection = FloTeam.Builder(session, \"Newspaper\", [marketing_flo, editorial_flo, reflection_agent])\n", + "journal_company_with_reflection = FloTeam.create(session, \"Newspaper\", [marketing_flo, editorial_flo, reflection_agent])\n", "\n", - "r4 = FloLinear.Builder(\n", + "company = FloLinear.create(\n", " session,\n", " \"linear-router\",\n", " journal_company_with_reflection\n", - ").build()\n", + ")\n", "\n", - "master_flo_with_reflection = r4.to_flo()" + "company_flo = Flo.create(session, routed_team=company)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhUAAAM+CAIAAAAimmRoAAAAAXNSR0IArs4c6QAAIABJREFUeJzs3XVcFPn/B/D3Brt0d6uIgSIqimILFnYXdrdn1xlnnGef3d1dp6InJiZ2oSAKonTXsvn7Y/xy/hRrhB12eT0f/rE7OzP7Ztfd187n85nP8FQqFQEAAPwkPtcFAACARkJ+AAAAG8gPAABgA/kBAABsID8AAIAN5AcAALAh5LoAKBI5mfLUeFlOpjwnQyGXqxRyDRilzeeTUIevbyzQNxKYWOoYmelwXREAfAsP539ok/QkWcSjrDdPsuVypUiXr28k1DcWGBoL5TINeJcFQl5OljwnQ5GTqSBSSSWq0pUNSlc2sLATc10aABQA+aEl8nIVN04lZ2fKza1FpSob2LnqcV3Rr0p4J4l8kp2WJBPweb5tLAyMcawMULwgP7TBwyupd86l+ra2qORrwnUthS8sNOPGyWTP+ibe/uZc1wIA/0F+aLxzO+JsnMVVG5lxXUjRenYj/fWT7DZD7LkuBAA+wvgrzXZ0VUwZTwOtDw8i8vA1qVLfZPuct1wXAgAf4fhDg+1bFO0TYF66kiHXhahPQozkn82x/WaX4roQAEB+aKzzu+JcKhqUq27EdSHqFvUi+9HVdDRkAXAO+aGRHl9LU8hUVRtrf7NVgZ6GpOflKqqjOx2AU+j/0DwKuer6iaQSGx5EVKmOycMr6TmZcq4LASjRkB+a58bpJN9WllxXwTHf1hY3TiVzXQVAiYb80DA5WfL0RJlXQ1OuC+FYhZrGcpkyJT6P60IASi7kh4aJfJKtzjOxnz59mpfH/jv6Fzf/NhMLUeST7CLaOQB8F/JDw7x5kl2qsoF6nuvUqVN9+/bNzc3lZPPvKlXJ4M1T5AcAZ5AfmkQuU+ZkKlwrqik/WB86MIP6iu7Ig2HrqssX8LIzZEX6LADwNZiTTpNkJMvlMmVR7FkikSxcuPDq1atEVLVq1QkTJoSGhi5cuJCI/P39iWjWrFmtW7eOj49fu3ZtSEhIVlaWi4tLv379mjdvTkRpaWn+/v5jxox5+fLl5cuXy5cv37Zt2y83L/SyVUrKSJYbGGOmdwAOID80SXaGvIg6P7Zt23b69OmhQ4daWlqePn1aT0+vTp06gYGBu3fvXrFihaGhobOzMxHJ5fJnz5516tTJ1NQ0ODh4xowZTk5OHh4ezE62bNnSuXPn9evXCwQCGxubLzcvdAbGguwMRVHsGQC+C/mhSYouPz58+KCnp9e3b1+hUNiuXTtmoaOjIxFVqlTJ1PTjcC8HB4dDhw7xeDwiatu2rb+//+XLl/Pzo3LlyiNGjMjf55ebFzp9Y2FOBs4CAeAG+j80iUpJOrq8othzixYtJBLJqFGjIiIivr3mq1evxo0b17x58/bt2ysUiuTk/07CqFmzZlHU9g0iMQ/zJwBwBfmhSfSNBBnJRfJz29fX9++//05OTu7Wrdu8efPk8oKf5e7du3369JFKpbNmzVq0aJGJiYlS+V9/jJ6eui9alZEi1zMUqPlJAYCB9itNYmAszC6y5hpfX99atWrt27dv+fLldnZ2AwYMYJZ/OkPa5s2bHR0dV6xYIRQKfzAwinSCtaJr0AOA78LxhyYxNBUYGBfJz22pVEpEfD6/Z8+eVlZWYWFh+fGQmJiYv1paWpq7uzsTHlKpNCcn59Pjj898uXmh09UXGJrh+AOAG/jtpkl0DYSyPNWHyFz70oXcUrR///4rV64EBAQkJiYmJiZWrFiRiKpUqSIQCJYsWdKmTZu8vLyOHTt6e3ufOnXqxIkTJiYme/bsycjIeP369deOML7cvHBrTo7NS0uUmViICne3APCDBLNnz+a6BvgJeTmKhHd5zuX1C3e3ycnJ9+7dO3v2bGRkZJs2bYYMGcLn842NjW1sbC5cuHDt2rWMjIxWrVpVqVIlMjJy//79oaGhTZo06dq1a1BQUPny5S0sLHbu3Fm3bl0meBhfbl64Nb+4nWlkLnRyL+SXAgB+EK7/oWFSE6Q3TycH9LfjuhDu/bs3vpKvia2rLteFAJRQaL/SMGbWIoEO79W9TPevXHlQIpEw54R/ydHRMSYm5svlDRo0mDNnTmFX+rnVq1cfPnz4y+VisbjAmU7s7e337t37tb1Fh+VkZ8gRHgAcwvGH5slMlR1Z+b7vLNcCH1WpVLGxsQU+xOMV/Hbr6emZmRX51ajS09OzswuY7lAqlYpEBfRhMCexf21v+xZHN+lhY+kgLuwyAeBHIT800u2zySZWOuW9jbkuhBuRT7I+vM6t286K60IASjSM39VIPi0sHl9Lj4+ScF0IB9ISpSEnkxEeAJxDfmiqLr85HVvzXiYtkul4i7N9i951n+TEdRUAgPYrTaZQqLbNetN+hIOFXYnoBshKk+9bHN1vlqtQhN89ANxDfmi8vX9F12ppXrqSIdeFFK2YVzkX9sb3mOws1sMJ5wDFAvJDG1w9mpgYk+fb2sKulLpnMFSDxJi8G6eSjC10GnWx5roWAPgP8kNLfIjMvXEq2cpBZOuqV6qSgUhX41t4FHJV5JOshHeSd69yfVtbOpfDeeYAxQvyQ6tEvch+eS/zzdNs5/L6+kZCA2OBgYlQz1Dw9UkOixE+n5ebJc/JUGRnyKV5ylf3MktXNixbzbBMZS1vmgPQUMgP7RQTkZMSK83OUGSny4koL7eQA+T+/fteXl58fmEe5eiIeHwBT99YYGAsNLPWcS5vUIg7B4BCh/wANnx9fS9duiQWl4hxXwBQII1vJQcAAE4gPwAAgA3kB7Dh4eHB4/G4rgIAuIT8ADaePXuGnjOAEg75AWyYmZnh+AOghEN+ABupqak4/gAo4ZAfwIazszOOPwBKOOQHsBEdHY3jD4ASDvkBbHh6enJdAgBwDPkBbDx+/JjrEgCAY8gPAABgA/kBbLi6uqL/HKCEQ34AG2/fvkX/OUAJh/wAAAA2kB/AhkgkQvsVQAmH/AA2pFIp2q8ASjjkBwAAsIH8AAAANpAfAADABvIDAADYQH4AG4aGhhh/BVDCIT+AjaysLIy/AijhkB8AAMAG8gPYwPWjAAD5AWzg+lEAgPwAAAA2kB8AAMAG8gMAANhAfgAAABvID2DD09OT6xIAgGPID2Dj8ePHXJcAABxDfgAAABvIDwAAYAP5AQAAbCA/AACADeQHsFGlShWuSwAAjiE/gI1Hjx5xXQIAcAz5AQAAbCA/AACADeQHAACwgfwAAAA2kB/Ahr6+Pq4/CFDCIT+AjZycHFx/EKCEQ34AAAAbyA8AAGAD+QEAAGwgP4ANMzMz9J8DlHDCApdmZr7NyHir9mJAY6SmJsfEXBGLdbguBAD+Y23traNjqLanKzg/oqOD3r07Y2TkoLY6QLMolYqoqMMikYDrQgDgo4SEp40bbzUxcVPbMxacH0Tk5OTr4dFFbXWAZuHze/j6jhOLRVwXAgAfnT8/Uc3PiP4PYKNKlXJEOP8DoERDfgAbjx69JEL/OUCJhvwAAAA2kB9QjFy/fm/y5KWfLjl69MKKFTtZ7Grv3tPe3p1zcnJ/aqusrOywsMhPl5w4EezvPyAuLpFFDQDaDfkBbJiZGRfF6R/h4dEhIQ/y8qT5S0JCHoSFvSn8Z/qKbt0mnDgR/OkSsVjH0FCfz8cnBeBz+FQAG6mpGUUxfWJ4eJREknf79mPmrkwmu3PnyWcHBD+C9dyOUqnssyXNm9c7fnyVtbXFT+0nOvoDuwIANMhXx+8CqF9ERDQRXb58p359byK6d+95bq6EiN6/j3dwsCGikyeDDx4MioiI1tfXrV3ba8KEvmZmJkT011+bL168NWPG0OXLd7x7F7d27e//f7dRfftOb9WqwZQpg4hIIslbs2bvuXPX8/JkLi52vXq1adq0DhG1ajUsJSX90KGgQ4eCbG0tT59eN3v2mtOnLxPRrVv7hELh+PGLXFzshULBsWP/ymTyunWrTZky0NDQgIiSklIXL956+/ZjHR2hj4/nxYu3Tp5cY2Vlzt1rCVDkkB/ARunSjoXefiWTyaKiPjg52V69ek+hUAgEguvX79vbW8fFJYWFvWHy48mTcFdX+4CAeikp6fv3n83OzlmxYiqzeVZWztq1+6ZMGZSbK6lRozITRUSUnZ0zefIyNzfn8eP7EpFSqfztt4UfPiT269fe3NwkNPTZtGkrcnPz2rZtvGjR+JEj51evXrFnz1YikQ4RdevWQqlUnjlzNb/I3btPNW3qu2LF1DdvYubN22BlZT5mTC+FQjF27MLk5LQpUwYmJaWtXr3X29sD4QFaD/kBbERGxhR6+1VkZIxCoRg4sNOsWasfPXpZrVrFkJD7TZv6Xr589+XLN35+tYho2rTB+fNuCYXCrVuP5uVJmdMYpVLZjBlDK1Uq+9lu585dn5GRtW7dTB0dHSIKDr794EHYqVMfDw6aN6+XkyPZt++ftm0bV6zoJhQKLC3NvLwqMNuWL1+6dGnHT/fm7Gw3d+5oHo/n4eEWHHz75s2HY8b0evo0PCwscuHCcf7+tYno7dv3J09eksvlQiE+X6DN8P8bigvmiKFOnaqVKpW9dOm2lZXZu3dxjRr5vHsXl9+FLpPJ9u8/e+bM1bi4JF1dsVKpTE1Nt7W1IiJdXfGX4bF//9l//705alTP/A6M69fvy+XyNm1G5K+jUCgNDfV/sEhdXXF+gNnZWT169JKI4uOTicjR0YZZ7uxsp1QqpVIZ8gO0G/5/AxsCgaDQ26/Cw6PMzU1MTY39/WsfOHDW3t7a1tbSw8PNzc350KEgpld87NiFz5+/Hjy4s6dnueDg2zt3nlAqPx4H6evrfrnPjRsPubk5HzhwrmvXFrq6YiJKTk6ztDRbv37Wp6sJhWwm8tLRESoUCiJycrIloocPw8qXL01ET5+GW1mZ6+vrsX0lADQD8gPYUCgUhd5+FRERXbq0ExH5+9dasWLnnj2nGzasSURubs4pKelJSalRUR/u3Hkyb97o5s3rEVF0dOx39zlqVE8/P59OnX7buvXo8OHdicjY2DA1NcPOzuprk3exGLtVoUKZWrWqrFy5OzY2MTU148qV0Pnzx/zsTgA0DsbvAhteXuVVKmXh7jMiItrNzZmIbG2tKlUqGxeXxPR5MAvDwiLT0jKZPglm/bS0DKY//Bv7bN/ez9bWqk+ftrt2nYyJiSOimjUrKxSKw4fP56/DDPFi6OnpJiWlsSh+4sT+zs52UVEfzMyMt22bx3SEAGg35Aew8fBhGI9XmP95pFJpUlJqmTJOzF1//9rm5iZVqpQjIgcHG11dcVjYm8qVy4pEOqtX7w0Jub99+7ENGw7l95p8W+/ebS0tzZYt20FEAQH1PDzc/v571+LFW0+durR06bbOnX+TSPKYNatWrXD9+v3t248dPXohIiLqB4uXy+V9+kz196/dokU9Dw+3jIzsrKzsX3gxADQD2q+ADQ+PMoXb/5GRkU1E+fnh51crOjqWOeubz+eXLu0YFvZm4MBO8+ePWbp0+6RJDz093TdsmLV+/YH9+88yzVzfIBaLxo7tPXny0hs3Hvj6Vl2zZsaqVXuDgkKOHr3g7GzfqVPT/P6P0aN7JiWlbt58xMzMeNy4Pm5uLj9SvFAorFWryubNR+RyObPEyMjg4MFlGMIL2o1XYGvvs2cbiNJw/Q/4TEDAEB0dIRG9f59ga2spEPAVCqW9vfXGjXO4Lo1jzAkrTPfJ+/fx3bpNmDdv9HeDDaAQnT8/0cdnYbG4fhTAl/h8wfv3CcztuLgkZtTT5MkDua6LY3l50j59ptraWlarVlEk0nnw4IVEkmdra8l1XQBFC/kBP6Fy5bKfzURbpoxzvXrVuauoWODxqGXLBkFBIevXHxCJdNzcnBcuHJffzw+grZAf8BO6dWvx9Gl4bOzHCDExMezTpx3XRXFPJBL16tWmV682XBcCoFYYfwU/oUqV8uXKueb3mbm7uzZsWIProgCAG8gP+DmBgW0sLc2YE/F69mzFdTkAwBnkB/wcL6/ylSq5qVQqd3eXunVLes8HQEmG/g8NI5WoEt9T3s9dlbWQtWjQIzHKoI1/QOTTIriG1A8TicnSnnQNiuA6iADwA5AfmiRol+rtM5V9aXFRXPvvZ5Tu1OQ3eTI9DeGyCB0xL+aVxLEcr2mgSiBAigCoG/JDM8hlqqOreBVqW/q2Mea6luIlNjLnwNL4TqNVIl1ECIBaof9DMxxbS9X8rV0rIjw+Z1dav157+0MruK4DoORBfmiAiEdKc1t9GxcDrgsppkytxU7ljJ7fKeT5gAHg25AfGiAxhsT6BV+sAhh6RqKEKLRfAagV8kMD5OXyTS2QH99iaqmTl4v/zABqhY+cBpDlkkLO8YirYk6hIEk2XiIAtUJ+AAAAG8gPAABgA/kBAABsID8AAIAN5AcAALCB/AAAADaQHwAAwAbyAwAA2EB+AAAAG8gPAABgA/kBAABsID/gW56/eJqXl8fV5gBQnCE/4KvOBZ0aMbKvRMLyYuu/uDkAFHPID/gq1ocOKpXqVzYHAI2A658DEZFEIlmxcuGNG1eJyNOz6sjhEx4+Cl3x90IiatfBn4gmT5rVvFnrhIT4LdvW3r4dkp2d5eTk0qN7P3+/5kSUnp7WroP/0CFjwiNehoRcLlu2fECLtl9uzvVfCQCFCfkBRER7920LCjrdr+9QCwvLoPOn9fT0fGrW6dI58OCh3X/OX2FgYOjo6ExEcoU8LOxZ2zadTIxNr14Pnr9ghoODU4XyHsxOdu/e0rZt56VL1gsEAmsrmy83BwBtgvwAIqLYuA96eno9uvcVCoUtA9oxC+3tHYmoQoVKJiamH5fYOWzfeojH4xFRixZt23f0Dwm5nJ8fFStWHjhgRP4+v9wcALQJ+j+AiMjfr4VEIpk8ZVRkZMS314x4/Wr67+M6dWneq097hUKRkpKc/1C1ajWLvlIAKC6QH0BE5FPT988Ff6ekJg8Y1G3J0nlyubzA1e4/uDt8RB+ZVDpp4qw5sxYZG5soVcr8R3V19dRYMgBwDO1X8JFPTd8a3rWOHN23dt1yGxu7XoEDmOXMYCrGrl2b7e0dF8xfIRQKiUjvBwLj080BQJvg+AOIiKRSKRHx+fzOnXpaWlqFh4flx0NSUmL+aukZaW5l3JnwkEqlObk5SqXya/v8cnMA0CY4/gAioqPH9ofcuNLEPyA5OTEpKbFcuYpE5FGpikAgWL12SYtmbfKkeW1ad/Ty8g4KOnXm7AljI5NDR/ZkZma8ffP6a0cYX26u9j8LAIoQjj+AmLFSMql03frl/5w53qFDt65dehGRg73j+HHT372LWr1myeXLF4iof99hNbxrr1q9eOXqRdWr+cye+VdyStKDh6EF7vPLzQFAm/AK/PH47NkGojQPjy5clASfu7CLrF0sS1cx4rqQ4ut9RM7LO/Fth3FdBwB3zp+f6OOz0MTETW3PiPYrbSORSDp3bV7gQ/Z2jh9iY75c7uvbYOrkOUVd2KbNq0+eOvzlcpGOWCorYKYTWxv7TRv3FnVVAMAa8kPbiMXijRsK/trl8Qo+3PyRYVS/rkuXXq1adfhyuUwq1RGJvlwu4AvUUBUAsIb80DY8Hs/O1p7rKgpgYmxiYmzCdRUAUGjQfw4AAGwgPwAAgA3kBwAAsIH8AAAANpAfAADABvIDAADYQH4AAAAbyA8AAGAD+QEAAGwgPwAAgA3khwYwMCUe5oL6Jh6RsSXXRQCUMMgPDWBgokyIzuW6imIt4V2uvhEulAugVsgPDeBUjrLTC5jhHPKlJ0tcKyI/ANQK+aEBzG34pTwUVw/Hcl1IMRVyIs7GSWbjjP/MAGqF+ds1g2c9lY4479y26DJVTC0cdMW6+K4khUyZECOJCc90dJNVbYiDDwB1Q35ojAo1VeY2sic3kqOe89KTlNwWkyeRinULuOiTOpnZCPSNlF71lU7uSFMADiA/NImNC9/GhYhURDxuK/H17Xfp0naxmNsIYUIU4QHADXz2AACADeQHAACwgfwANry8yhOhyxqgREN+ABsPH4Zx3gcDANxCfgAb5cqV4iE+AEo25Aew8fLlGxWarwBKNuQHsOHh4YbjD4ASDvkBbDx7FoHjD4ASDvkBbFSsWAbHHwAlHPID2Hj+/DWOPwBKOOQHAACwgfwANqytzXH+IEAJh/wANhISUnD+IEAJh/wANnD+IAAgP4ANnD8IAMgPAABgA/kBbJQvj/YrgJIO+QFshIWh/QqgpEN+ABvW1hY4/gAo4ZAfwEZCQjKOPwBKOOQHAACwgfwANnD+BwAgP4ANnP8BAMgPAABgA/kBAABsID+ADU9Pd8y/C1DCIT+AjcePX2H+XYASDvkBAABsID8AAIAN5AewgfM/AAD5AWzg/A8AQH4AAAAbyA9go0qVchi/C1DCIT+AjUePXmL8LkAJh/wAAAA2kB/AhqurA8ZfAZRwyA9g4+3b9xh/BVDCIT+AjQoVSuP4A6CEQ34AGy9eROL4A6CEQ34AG9bWFjj+ACjhhFwXAJqkS5dxYrEOn8+PiYnr3Xuqjo6Qx+MZGRmsWfM716UBgLohP+AnvH4dzfvfcUdERDQRiUTCceP6cV0XAHAA7VfwE6pXr6j6//0eLi72nTo15a4iAOAM8gN+QmBga1NT4/y7Ojo6Xbu24LQiAOAM8gN+Qv36NUqXdsw/BHF2tmvXzp/rogCAG8gP+Dn5hyBisU7PngFclwMAnEF+wM9p0KCGm5uzSqVydLRt08aP63IAgDMYf1XIpHmqvBwtPzOiU7v2Ua/Tu3funJnKdSlFTKRLYj2uiwAorpAfhebxNdXDKyqFnMfjaf2Z2Z7d6i1Le0ZHnmn5XyoU8RQyZaU6vOp+Wv6bAIAF5EfhuH5cIMkR+/U0MzYXcV0LFKbMVFnEg7Tzu3Ka9lJyXQtA8YL+j0Jw9SjJlfo+LW0QHtrHyEynamMrY0vjoJ04BAH4f5AfvyouSpmTJaruZ8l1IVCEPHzNhCLdqBc4BAH4D/LjVyXFkECAZkDtJxQJE2O4LgKgOEF+/KrsTJ6loz7XVUCRs7DXzc0RcF0FQDGCH86/SpJNPD6aNbSfXKbKydDy8WYAPwXHHwAAwAbyAwAA2EB+AAAAG8gPAABgA/kBAABsID8AAIAN5AcAALCB/AAAADaQHwAAwAbyAwAA2EB+AAAAG8gPDvQb0GX8hGGfLgm9d7uRn/fNm9cKZf8x79818vO+GBzEYtuIiFejxw5s0bLuhInDC1whJyenY+dmSuV/U37FxEQPGRrI4rnCI16y+KuzsrJehYd9uuTM2RPtOvjHx8exqAEAWEN+wH9kMtmMmeNUKtWsmX/16zu0wHXevIlISUl+9uxx/pJbt6+/eftaLperp8iBg7udPXvi0yUikdjAwJDPx39mALXCRw7+8zYqMj4+bujgMbV86nh4eBa4zuvIcCK6dv1S/pJbt67LZLK3byN/6rlUKpZz2Uql0s+W+Ps137PruJWV9U/tJyYmml0BAMDA/O3FUWzch7Vrl927f1skEruXLd+///Dy5SoS0ZMnD3ft3vzk6UMiKl/OY+jQseXcKzCbpKWlrlm7NOTGFZFIXNXL+9v7P3/+nz37tn34EGNhYdkyoH3PHv34fP7OXZu3bV9PRCNH9zc2Njlx7GKB2755E0FEISGXhw/7jWnOevT4PhGFR4S5ubkT0dlzJ48fPxj5JkJPT79mjdojR0wwNTUjostX/p3zx5S5c5YcOLQrLOxZ92596tVrnL/b3NzcocN7iUXiVSu3isViiUSyecuai8HnpNI8J0eXLl16NW7UlIi69WiVmppy/MSh4ycO2djY7t97euGi2UFBp4noQtAtoVB4+Mje4EvnO3fquWXLmuSUpLJly08YN8PZ2ZWIkpOTVq1efO/ebaGOTvXqPlevXty8cR/zEACwgPzghkwuS0iIz7+bnp6Wfzs5OWnU6P4ODk4jR0zg8Xjnz/8zZuzA9Wt3lSpVJi7uQ540r1fgQD6ff+LEoSlTR+/bc0pXV1cqlU6YNPz9+3ddOgfa2tqfOHHoG08dFHR64aLZfn7NB/Qf/vz5k63b1hFRr8ABjRo2UalU23dsGDxoVKlSbl/b/HVkuIOD0/v3716/Di9Tpuz9B3fkcrmDvWN4eFiL5m2I6PnzJ87Ork2aBKSmphw9tj87J/vP+SvyN/971V8D+4/o32+Yo4NzWnpq/vJly+enpqZsWL9bLBYrlcrpM36Li/vQs0c/U1Pzhw9D586bJpHkBrRoO3vWokmTR3pVqd65U08dkYiIOrTvplQqL1w4k7+rFy+eHjy4a/z4GXK5fNmy+X/+NWvdmh0KhWLa9LEpqcljxkxJSUnatHl1VS9vhAfAr0B+cOPJk4ddu7cs8KFduzebmZovXbxOKBQSURP/gMDe7U6fOTZqxAR//xZNmgQwq5UrV3Hc+KFPnj6s4V3r+ImDr1+HL160xru6DxF5VPTs069TgTtXqVSbt66pXNlrxrR5RFS/XuPMzIz9B3Z07NDdycmFabOq4lmtYsXKX6v8TWREx47d//337PWQy2XKlL1163qFCpXKupULj3jJrDDut2k8Ho+5LRQKd+/ZmpeXJxaLmSXt23Vt1qwVczs/P46fOHQxOGjhnyvtbO2J6Oq14MdPHuzbc8rS0oppnsrNzTlydF9Ai7bly1UUCoUWFpaVK3sx27qXLe/qUvqzIufPW25ubkFEHTp0W7tueXpG+rvot6/Cw2bNXNiwgT8RRUe/PXvupFQqFYlEP/ymAcD/g/zgRpkyZQf0+2+AU8TrV8xxABHdvh2SkBgf0Kpe/qMymSwxIZ6IeDzeteuXDh7aHRX1Rl9fn4hSU5KZ3ojSpd2Y8CAivuC/y6zm5eWlpCYzt62tbD58iElKSuzapVf+CjVq1D5z9kTM+2j3suW/rDM27gNzw9TETE9PLz4+Lis7y9W1TIMG/tevX+rTe9DtOyEdO3QXi3Uv/HtGqVTy+XyZTHb02P4L/55IHd5LAAAgAElEQVRJSIgTi3WVSmVaWqqNjS2zn2rVan72FC9fPd+7b3uNGrVr1qjNLLl167pcLu8R2CZ/HYVCYWBg+OMvr66uHnPDxsaOiJKTEhMS44nI3t6RWe7o6KxUKnNzc5AfAKwhP7hhYmxau/Z/CaHzybdYSmpy7dr1Bg8c9en6zLcn00XRsUP3wQNHJackzfljilKlJKKEhLiyBX37E9HzF0/Gjf84kurwwXNZ2VlEZGpqnr+CkZExESUlJhSYHz16fvwSnzF9vl/jZkznR+lSbvb2jnv3bb9+/XJSUmK9eo2TEhNyc3NjYqKdnFymTR/78tXzPr0HV6zoee1a8P4DO5kiGfp6n18rftfuLaVKlbl792Z4xMuybuWIKDU12cLCctmS9Z+uJhCy+b+qI9QhIoVS4eDgxBz2MX/mixdPLS2tTExMWewTABjIj2LHyMg4PT3ty6b5vLy8vfu2tQxoN3LEeCL6tPvE1MQsNTWlwL2VLuU2948l+Xtmbnza3cJsmP/QZ/K3Ledeken80NHRsbd3FAqF9nYOq9cuKVOmrIO9I7P5q/CwlJTke/fvTJ82z9+vORG9/4ExTr6168+auXDo8F6rVi9euWIzU0xaWqqNjV1+q9dnWIzdKudeoYZ3rY2bVsbHx6alp4bcuDJj+vyf3QkAfArjd4udatVqPn366OWrF/lLcnNziUgiyc3Ly3P/34Cr9Iw0ImLO4ytbtvzLl8/fvYv6cm8mJqZ16zRk/olEIgsLS1sbuzt3QvJXuHLlX11dXTe3cgUWk78tMzr2zZsIJycXpmOmQQP/+Pi4+vX8iMjYyNjS0io8PIypKv9Q5tMivyagRVuhUDhqxMQnTx5e+Pcs8wooFIqTpw5/9gow9HT1kpOTfuYV/WjUyImOjs7vYqJMTcxWr9rGdIQAAGs4/ih2+vQefOvW9YmTRnTpHGhmZn7nzg2FUjHvj6UmJqalS7sdPbbf3NwiOytrx86NfD4/MjKCiLp373v+wj9jfhvUqWMPC3PLi8HnvrH/vn2GLFw0e/GSuTVq1L5//871kMt9eg/W09P7kdpeR4a7lXFnbjdo4L9v/456dRsxd0uXcgsPD+vUsYdIJNq0eXXLlu0jI8P37tvGdLk7/K/j4WuqVKnWqGGTDRv/ruPboIl/wKnTR9dv+Ds27oN72fIREa+uh1zavvWwrq4uEVWuXPVi8Lm9+7YbGRl7VPQsXfqrQ8U+JZfLh4/s07lToIODE4/Hy8zMyMrKMjT8iT4VAPgMjj+KHQd7x9Urt3p4eO7Zu3XN2qVp6an+fi2Yh36fvkBPV++PuVMPHNo1bNhvvQIHBAWdkslkDvaOfy1cZWVpvX3Hhl27N5cuXfYb+2/WrNXYMVMePb4/f8GMu3dvDh40qk/vQT9SmEwmi4mJdnUtw9wt516hZo3apUp9vFuqlFtExEsrK+sZ0+eHR4TNnjPp3r3by5ZuqFWr7tFj+39k/0MGj8nOztq9Z4uOjs7iv9a0atk+ODho2fIF9x/cadO6k/B//R9DBo+u6uW9a/fmvXu3vf/w7kf2zIwE865ea9fuzfPmT587b9qkySN79GwdHf32BzcHgC/xCmxKfvZsA1Gah0cXLkrSMFeOqPSMLCr4mHBdCHyHQqEQCARM98mH2PcDB3UL7DmgZ49+P7j568eZ8W+TmvX6gVUBuHD+/EQfn4UmJj90RF4o0H4FJUJeXt7wkX2srW2reFbT0RE9efJAIpGU+t+xFACwgPyAEoHH4zVt0jI4OGjb9vUikahUKbdZMxf6+tbnui4ADYb8gBJBJBJ17dLr0xMnAeAXof8cAADYQH4AAAAbyA8AAGAD+QEAAGwgPwAAgA3kBwAAsIH8AAAANpAfAADABvIDAADYQH4A/KiEhORXrzBlL8BHyI9fpWdAIjGP6yqgyAmEPIksfdas1Skp6US0Y8eJe/eecV0UAJeQH7/KwFQVH53DdRVQ5JLeS6rXdN23b4mZmTFzQaotW44QUU5O7rJlO27ffsR1gQDqhvz4VTbOpJTLua4CipxcKrVxJmYqXyIaMKDj2rUziUgsFtnYmF+4cJOI3r2L/eOPddev3+O6WAB1QH78Kkt7vpmN9ObpeK4LgSJ0/2KSUChxcCvg8yIQCHr2bD1jxlAisrW1rFLF/eXLt0QUGvp04sTF164hS0BrYf72QlArgHc/OOfq4ZgKtSwt7MV8PrpDtEfyB0nEwxQ9g7w6Hb7/turo6LRt68fcrlKlXEZGdkZGFhH988+VkyeDe/duV6dOValUJhLpFH3hAEUO+VE4qjWmV/fzQs+/z0whxfdas1RECoWCiIQCgZrq+xkyuVxH+NX/GAqlks/n8UizM1Iml3965eZPL+Is/uTLXaTL1zNUVqqj8qj10++Ujo5O48Y+zO2AgPq2tpZyuZyIVqzYef/+80WLJjg72yUnp1lYmP7qHwPAEeRHoXGvxnevRqSiPMlX17l162GtWl7h4VEhIfc7dGhibGyo1hK/JzExdebMVW/exMyePaJWrSoFrjNgwMxp04aUKeOk9uoK08OHrxct2hIbm/TZchsby/37l+TfFekSj1cIbbw8Hq96dQ/m9qRJA8LDo/T0xET0xx/rXr+OXr9+lqOjbVxcoq2t1a8/F4DaID8KG4/Eep8vY5osWrQY4uvr1aCRVyVPl0qeLtyU93VXr4YuX74jOjrWwECfJ5B9+VcwGvlVdXY1/9qjmsKndoWRo7ssWrQlMTElf6FKpTp2Yrsanr1s2Y/v/t9/T42NTWSyZMeOE2fOXD1y5G9LS7PHj196epZTQyUAvwL950Xr/v3nAwf+/uFDAhEdOrT899+HcV1RwTZtOrxw4aZ37+J4PB6PR/KvjygbMKCjoaGBeqsrEo0a1Rw8uJO5uUn+EoGAP2jQzAMHzubm5qmtDDs7K1NTYyKaPHngP/+sNzTUJ6INGw76+HQjIqVSee3avawsDBCH4gj5USRevHjNDOIMD48aMaKHq6sDETFfDcXQpElL9u49nZDw8Ze4QqFUKlUFrqlUKo8f/1e91RWh9u2b9OzZknlfVCrVnTsHJ07sHxX1oXPnsVOmLLt1S92ndBga6uvqiolozZrfb9/ezzR8HTlyvmXLoUSUmys5fz4kLS1TzVUBfA3yozDJ5QoievDgxfz5G83NTYmoa9cWVatW4Lqub+nS5bcrV0IzM7PzlyiVSpms4OOPpKTUDRsOqbG6ItenT/vWrRvp6+vx+Xwicnd3nTRpwOnT6/z8au3adXL06AUbNhyIi/u8m0RteDzeihVTr1zZSUR8Pv/SpTuzZ69mfqCcPHkpLS2Dq8IA0P9RaBQKxZw5a5OS0tau/b1sWZfdu//iuqIfdfDg8rp1A+VyOXNaHPNLnBke9iVdXfGUKQPVW2CRGz++b2ZmdkjI/U8XNmni26SJb3x88okTwQMGzChXrlSzZnWbNavDXZkkFov+/PM35rapqfGDB8/j45MGDer87783k5JSmzWrY2Zm8r19ABQm3qejGPM9e7aBKM3DowsXJWkSqVR2+PD51q0bCgT8S5futGzZgOuK2KtevRMTIXw+7/ffh7du3ZDrioqRO3ceHz9+8cqV0K5dWzRt6lu+fGmuK/pPZOS7I0cuVK5ctnnzegcPnpPJZK1aNTQxMeK6LlC38+cn+vgsNDFxU9szov2KpdTUdCIaMGBGbGyCvr6uvr6eRofHgQNnBwzoGBp6yMzMWCaTfy083r+Pv3Dhhtqr417Nmp4LFvx28eJWJyfbuXPX9+gx8dSpSxKJ+rrZv6F0aaeJE/s3b16PiLy8ysfHpzx9GkFEO3Yc37HjeHo6+kugqOD446e9fv3u999XDhnSpUGDGlzXUmj8/PodObLS1PQ7P1qvXLl74kTwsmWT1VVXMfXy5ZurV0O3bz/eoEGN9u39atSozHVFBXj16u25c9fr1KlavbrHpk2H+Hx+x45Nv/sWg+ZS//GHYPbs2V8uTUy8RySxtvZQWx3F39u37y9cuOnh4fbmTUzTpr75p4NpgWPH/jUw0G/a9PuN+zwez87OysXFXi11FV+WlmbVq3sMGNBRLpcfOHBu7dr9OTm5Tk62BgbFaIidhYWpj4+nvb01EZmYGL569VZfX9fe3nrTpkMPH4aVKePEjPUCrfH69QVHR39dXXO1PSP6z39IYmLK+PGLxo7tTUTalByMI0cuLFo04UfWdHGxR3h8qlmzus2a1Y2LSzx+PLhPn2l161atWdOzSRNfruv6nJubi5vbx5MWGzWqef78jcjImKpVK6xbt18sFnXu3MzISBvO6QE1Q//Htxw6FNSu3SgiMjIyOHLk73r1qnNdUeE7d+6ai4u9vf0PzZzx5k1Myez/+DZbW6uhQ7uePbuhadM6Fy/eqls3cPHirRER0VzXVTA3N5fhw7szw8obN/bJzZVERX0gopUrd+3YcSI39+vT7wD8fzj+KEBU1AeRSMfOzio9PXPjxtnMuFWuiyoqwcG3hw3r9oMrx8Ymnjx5qRj+vi4matSoXKNG5dxcyYkTwdu2HYuK+tC+vV/bto2FX5+PklvlypUqV64Uc7tx41rBwbfev09wc3NetGiLi4t9x45NhcLiOMUnFBPF9L81h7ZvP3by5KWtW+cR0cCBnbgup2hduXJXLleUKuX4g+uXLu3o51eriIvSeHp6ut26BXTrRi9evD527GKdOoHduwf4+dWqXNmd69K+pVKlspUqlWVu+/nVunjxVnp6poWF6R9/rK1e3UOjhxdCEcH4q4+Cgq7n5cnatGn04sXrChXKcF2OmvTpM23q1IHF6mwGrXT+/I29e0/n5Uk7dWrWsWMTrsv5Of/+ezM09OmUKYOio2P37j3dqlXD/JiBYgXnf3Dj0qXbV66E1q1bjYhKTniEhNyvXLnsT4WHVCrbvftUURalnZo29d2+fcGcOSNfvoysVy9w1ao9GjT1iL9/7SlTBhGRnZ1lmTLOoaFPiejMmaubNh2Ki0vkujrgUonOj1OnLvXoMZGIatf2WrBg7KdTsZYECxZsDAxs/VObiEQ627cfZ86dhJ/l7u46bdqQS5d2GBnpd+w4dtWqPQkJyVwX9RN0dHQ6d27Wt297IqpRo5JCobxyJZRpBT158hI63kugEpof0dGxzOWStL57/Gs2bz7cqlVDW1vLn91wxIjueXnSoimqRBAKBX37tr94cWv58qX69Jn211+bs7Kyf2C74sXKynzo0K5du7ZgRnU/ePD81KnLRHT+fMi9e8+4rg7UpMTlR0RElJ9fP6lUSkT9+3fQjktZ/KzY2MRnzyJ+fNjVp9q398dl8gpFkya+Z89uKFXKcfjwufv2/cN1Oey5ujrMmjWiS5fmRKSvr7tx48GnT8OZ4xLMnqLdSlB+MD+LkpPTjhxZmX8uVck0YsRc5lxIFiIios+fDynsikquLl2a79y58P37hH79pmtBd0LdutU3bJjj4eFGRI8fv2rffnRMTDwzcxrXpUHhKyn5MX78ojNnrhKRj0+VEj4F0IYNB/r378j6NHIHB+s//lhX2EWVdBMm9Pvtt96LF2978uQV17UUAmYi51GjegYHb7O0NCWiuXPXd+06nrkKFtfVQaHR/vmvwsOjLCxMjY0Nevb8ub5irXTw4Lm4uKT+/Tuw3oOOjrBMGSdDQ319fQ2/BnoxY2Nj2axZncmTl5Yr52plpb4pjIoac+5kq1YNa9SoZGpqHBX1YebMVTk5uRUrqm+YaQmh/vmvtPn4QyaTjRmzQKlUMiOsuC6He/fvP3/x4vXkyb96AagGDWpYWpoVUlHw/2zfvmDNmn3h4VFcF1L4mKs4u7k5T58+hJlu69Gjlxs2HNCgoczwGa3Nj8zM7Pv3n48Y0SN/eoYS7sGD50uXbps1a0Sh7G3y5KWfXvIWCtH8+WOGDCmgVUBr2NlZNWtWl4jKlXPl8fgHDwYR0e3b6r7aPPw67cyPs2evZWXl+PhUcXd35bqWYuHlyzcnTlzas2dxYe2wbt1qS5duL6y9wadMTIxGjeq5ZcsRrgspcrq64sGDOw8e3JmI3r79UKNGl2I76SQUSAvzIyEhOSTkvp0dxph+FBn5burU5bNnF86RB6N160bTpw8ucPIb+HWlSjncuPGQ6yrUqmvXFrdv7zc01COi2bPXPH78kuuK4Pu0MD8yMrLnzRvDdRXFxZ07T5Yu3X706MpC37NCobxz53Gh7xaIyNOzHJ/PUygUXBeiVnw+nzm1qF07P2a0JLpGijlty489e065uTlzXUVxcerUpW3bjq5Z83tR7FxXV5yenjV16vKi2HkJFxMTn5SUKhCU0LnTvbzKMzNuJSSkDBkyGychFltalR/79v3D42nVX/Qr9u8/c+/e83XrZhXdUzRtWmfEiO7x8Zo0iZNGePXqLbrumBnDBg3q9ODBC64LgYJp1betmZlxq1a4SgER0bRpy5VKZeH2eRTI0dHWxsaCaW2AwnLt2j1cZ4Xh7V2pYcOaRDRq1PyS1qBX/GlVfjRvXs/Y2JDrKrjXvfuEBg1q9ujRSm3PGBn5DrPmFZa3b98/fRretGkdrgspXsaP7zt//kauq4D/R6vyY86cNSV8avGIiKhBg2bOmTOyWTO1fvuMHNkzKytHnc+oxY4fvzhiRHeuqyh2XF0dZs4cxnUV8P9oVX7w+XzmggQl06lTl6ZPX7l27UxOms4bNKjBnFeo/qfWJmfOXE1OTmvcGI1XBbt9+/GkSUu4rgI+0qr8GDUq0MurPNdVcOPvv3feu/f8wIGlOjpcXtO+e/eAWbNWc1iARktKSv37711z547mupDiy8fHk2kv5boQICLi8rum0JmaGpXAuXWlUln//jM6dGgyZow/17WQl1cF5oK4V67cZY5I4MdNn/73tm3zua6iuFu0aALXJcBHWnX8QURxcYktW5agRtLQ0KcNGvSePn1whw7chweDuZhjXFzSn39u4roWTRIYOHns2F729tZcF1LcZWZmJyencV0FkBbmh62t1fTpQ4KCrnNdiDrs3n1q06bDN2/uq1ChDNe1fK5r1xaNG/sQEc4O+REjR86bOLF/MXwfi6GrV0MPHjzLdRVAWpgfROTr68XM7qndhg6do1AoNmwovhO1Mk3VDx48X7t2H9e1FGvDhs2ZMKFflSrluC5EMyiVytzcPK6rANLO/CAiuVy+bNkOrqsoKk+evKpZs+uAAR369GnHdS3f17x5PbFYFBYWickWC9Snz9R+/Tow18aAH9G6daNx4/pyXQWQ1uaHUCj08HCbNk0Lp2batOnQ0aMXbt7cW6NGZa5r+VEDBnR0crJLSkrFhdM/0737hIkT+9esqTFvZXEgk8kkEhx/FAvamR9E1KxZnZkzh8vlcq4LKTRKpXLQoJkKhXLWrBEaN7OegYGelZX5pUt3QkLuc11LsfD+fYK3d+clSyZWqlSW61o0zMmTl7S4dUGzaG1+MAOBgoJCZDIZc7du3Z5cV8TezZsPhwyZPWxYt6FDu3JdC3t//vmbjY2FRJJXwsfvX758Z8GCDaGhhxwcbLiuRfMIBAKhUMN+P2krrTr/40v29tbDhv2RlJT67l0cEf311+Zfv/q3+q1YsTMiInrTpj+4LqQQuLm5qFSqyZOXjR3bu06dqvnLGzXqs3jxJG9vD06rU4f16w+Eh0cV0aT6WqxXr8kvXnzsRePxeAcPnlOpVA4ONidPruG6tJJLm48/iKhq1QphYZExMfE8Ho+I3ryJ4bqin5OSkj5t2goLC9PVq2dwXUuh4fF4hw4tz8zMyl/SoEHvzMycLVsOc1qXOixYsFEg4C9dOonrQjRPr16t9fTEPB6P+Swz8xU1b679Iy2LM23Oj3btRlav3kkikeYvSUvTpAvRXLhwo2vXcf37d+jVqw3XtRS+5s3rEdGQIbMDAoZmZ+cSUURE9PXr97iuq6h8+BDv7z+gYcMagwZ15roWjdS0ad3SpR0/XeLsbNu1awvuKgLtzY8hQ2ZlZeV+uoTH40mlspQUzZigd+bMVffuPbtwYYt2X05xw4bZCQkfTzBMSUnfvPkQ1xUViXPnri1fvuvQoWW+vlV/YHUoWGBga3193fy7jRrVsrAw5bSikk5r82PDhjnjxvUuU8ZZT++//3A5OZLY2ERO6/q+V6/eNmkywMfHk7mEp3arXfu/icp5PF5UVOyFCzc4rajwLVq05dq1+4sXTzAzM+G6Fs3WpEmd/BNlXFzsu3ZtznVFJZ3W5gcRBQQ0OHhw2fDh3VxdHcRiERFlZeXExRXr/Nix48SsWasPHFjWsqX2X0jRz6+fTPb/BlhnZGRv3XqUu4oKmVwuDwyc7OJiP3/+GK5r0RKBga1NTIyIqFGjmlZW5lyXU9Jpc34wundvuX37/D592jo720kkee/fJ3BdUcGUSuXQoXPS0zP27Vtibl4ifqhWruzu7u5qa2tpZmasqytmhta8exd36tQlrksrBE+fhtepEzh9+mC00Reipk3ruLjYOzradOsWwHUtQLwCZ5V49mwDUZqHRxe11ZH4XvUgmB8frczNKqpZLlSkkssVOsJiOmRZrlDw+Xz+/8aWfJuhKZ/HIwc3nk8LpVjvhzbhUOQT1fNb/NxsSo0v4PrVKiLV/0M8HhXbt+nHyeTyn/orTK34BiY8z3oqJ/eiLKswZKer7gTxY98oFXIqug/s1yiUSpVKJeTiFFojc76JBVVtRHal1P/k33f+/EQfn4UmJm5qe8Zi8Sl9+5x34xTfs4FFRV+RnmGxKKmY4/MpI0WWmSLb8Ud8l3E8UyuuC/q6+8G82DfiUp7GFva6OiLtP95lTSpRJMfmhV5Iy0iRe9QqvnOFJcbwTm5U1WxhWcZLx9BUp0TNapaXo0iJz7t2LMWrgdK9ekn6y7+C+y/rsLuq53d0Wg91/IF14T/mtmJzW7FLRcPjq9+26Ke0tC+ORyEhJyk7U69+J5xl/X0iXb6hqY5LBcOrR2NzMyXeTbguqCDvI1RXj/K7jC/NdSHcEOnyjcx1XCoYXj7wITdbUqV+cfzQqRPHvwclOcrntwVNAhEe7Pn3crhxqjj+ro99o8xMFdVuhfD4OfU72MVFCZNjlVwXUoA7Qfxm/Zy4roJ7Dbvav30uzEgpju+ROnH8vRMbyRNofks3twxNdJJjlZmpxe5o+v1r0jUUc12FRhLriz+85rqILyR/UOVkEhohGSJdUTF8j9SM4/8KGclk46LPbQ1awKWCYfKHYpcfuZl8Kyc9rqvQSDYueplpxa5tJDVB5VDWgOsqigtrV/3MlJIepRz//XkSlVxa7L74NE5OpkIuL3ZfN1nppFTgzWVDKaec4jdPglzGk2QVMIKuZFLKVDlqH3tW3JT0/AQAAHaQHwAAwAbyAwAA2EB+AAAAG8gPAABgA/kBAABsID8AAIAN5AcAALCB/AAAADaQHwAAwAbyAwAA2EB+AAAAG5qXH2PHDW7k593Iz7tJs1qBvdtv2bpWIpFwXdTnZswcP2RoINdVaJj09DTmnW3k5922vd+EicNfvHia/2i/AV3+mDuV3Z537NzUyM87Li42f8mFf8/u2Lkp/65UKm3Rsu6ff836clu5XB7Yu/269SuYuwqF4smTh+zKAPWIef+ukZ/3xeAgrgvRfpqXH0Rkamo2oP/wLp0DTUxMd+/Z+tei2VxXBIWmfr3Gs2YuHDRwZEpq8sTJI+Lj4359n7Vr1yOiu6E385fcuHHl5s2r+XcfPb4vkUhq16r35bY8Hs/IyFhXV5e5u3jp3GUrFvx6SQBaQCOv3WRhYRnYsz9ze9qM3y5f+XdUSrK5uYU6a1CpVDxeEU6ZXtT7L7bKlHFv2MCfiNzdKwwZGhh671bLgHas9/b+Q4y9nYN72fJWVtZ3795s3aoDc0hxN/RmdnZ2cnKShYUlEd29e1MoFHpXr/XptsxbIBAI1q3Zkb9QmpfHrpIS+4aCFtPI/PiUV5XqN29ei0+IMze3kEgkm7esuRh8TirNc3J06dKlV+NGTYno3buo5Sv+fBH21MjIuJZP3bFjpvD5/K+tnJAQv2Xb2tu3Q7Kzs5ycXHp07+fv15x5rn4DupRyLePqWubosf15eZJDB84ZGho+efJwx86Nz188IaIqVar36zvUvWx5Zv3tOzaeOn1EoVA0bOA/fNg4kUjELD9x8vDBQ7uTkhJsbe39Gjfv2qWXWCy+fOXfOX9MmTtnyYFDu8LCnnXv1qd/v2Hcva7c0xXrfuPR5y+ert+w4uXL57q6er616w8b9puxkTERyWSyrdvW/XvxbG5ujqdntVevXvQKHNi2TafateoFXwqSy+VCofDBw9Ds7GwiunnrWquW7Ynozt0blSt5GRoafvYWr165beDg7kQU2LP/gP7DFy6afenyBSJq5OdNRHv3nLSztSeiBw9DN21e/fr1KzMz86peNQYOGMHE0qd7s7O1X7d2pxpfPw1W4AckPOLlqNH9Fy5YuXHzqtevX9nY2A0ZNLpOnQbMJmlpqWvWLg25cUUkElf18ub6LygpND4/4uI+EJG1lY1SqZw+47e4uA89e/QzNTV/+DB07rxpEkluQIu2i5fOjY5+O2L4+Jyc7AcPQ/l8/jdWlivkYWHP2rbpZGJsevV68PwFMxwcnCqU92Ce7u7dm5I8yYJ5y3NycwwNDe+G3po6bUyZ0mWHDhmrVCpv3ryqkMuZNV+Fh4l1dYcMGh0e8fLwkb3m5pa9ew1kQuXQ4d0d2ndzcSn97t3bAwd3xryPnjblD2arv1f9NbD/iP79hjk6OHP3onJJqVQoFIqkpMSNm1e5uJRq3KjZl+u8fRs5fsJQV9cykybOSk9L3bZ9fUJC3NIl64ho/ca/T548PHDACEtL63Xrl+flSVo0b0NEtWvVO3nqyIsXTytX9rp582o59wp8geDGzautWraPj4+LinqTf5Tz6Vvs4OA0948lc47cAUEAACAASURBVP6YwjwU2KN/YkJ8bOz7qVP+ICILc0siunf/zpSpo5v4B7Rv1zUzI/3I0X3jJgzdsG430+SVvzf1vooa7BsfkLy8vDlzp4waOdHO1n7b9vXzFkzfv/e0iYmpVCqdMGn4+/fvunQOtLW1P3HiENd/REmhkfkhk8kSEuKlMunDh6H/nDlet05DCwvLy1f+ffzkwb49pywtrYjI3695bm7OkaP7Alq0jYv74F62PPNLs0vnQCK6ei34ayvb2zls33qIaWpo0aJt+47+ISGX8/NDIBT+Pn2Bnt7Hy7KuXrPE1tZ+1cqtzLFFu7ad84u0t3dcvnSDQCBo2rRldPSby1cu9O41MCkpcc/erTOmz29Q349ZzcLCavmKP0eOmMDcbd+ua7NmrdT+ihYjO3ZuYnq2jYyMf5/x30v9qd17tvD5/EV/rTYyNGLWXLBw5qNH9ytVqnL69NGWAe26dunFNBnNXzDjydOH1avVrFq1hq6ubui9W5Ure924ebVlQHuxWLx12zqJRHLn7g0mYJidf/YW163TML/dydHR2cTENCU1uXJlr/xiVq1e3LpVh9GjJjF3vb1r9enX6W7ozXp1G325N/i2735ARo2cyLQTDBw4csjQwEeP79ev1/j4iYOvX4cvXrTGu7oPEXlU9OzTrxOnf0dJoZH5ER39tmv3lsztOnUaTJ40m4hu3boul8t7BLbJX02hUBgYGBJRE/+Avfu2r1y1qFfgQDMz82+vTEQRr19t37Hh5cvnzPKUlOT81SpUqJT/XRAb9yE6+u3AASPyG6Y+ZWhgKBAImNuurmWYBq57927L5fL5C2bMXzCDeUilUhFRUmICc7datZqF/WppmHZtOwcEtEtPTwsNvTV5yqihQ8Ywkf+ph4/uVa1agwkPIqpRozYRvXz13MnJRSqVOjg4McuZG5mZGUQkFourV/e5c/dmvbqN4+Pj6tZpqK9vsG79igcP7t65c8PR0dnR8eMB36dv8XfFxcVGRb15//7d6X+Ofbo8ISGexd7gux8QPd2PL6aNjR2TN0R07fql0qXdmPAgIv7/PndQ1DQyPxzsHceOnfrixdOt29bVr9vY0NCQiFJTky0sLJctWf/pmgKhkIgGDhhhZma+e8/Ws+dODh40un27Lt9Y+f6Du5OnjKrq5T1p4iwDfYOZsycqVcr8dfL/+xJRWmoK03T23YIFAoFcLiei5JQkIlowf8VnW9nbO0a/e0tE+nr6v/baaDwzM4uybuWIyLu6T3Jy4tZt69q07pQ//ImRnZ1lamKWf9fIyJj5KjExMTU0MHzy5GHnTj2JiBn+W6Z0WWa12rXqLV02/2zQSXt7x1KlyjBf7levBT94eDegxX9d9J++xd+VmppMRH16D65fr/Gny83NLVnsDb7xAXnz9vWnS3SEOkxrJxElJMSV/V+nI6iTRuaHrp6ed3Uf7+o+jx7dW712qbd3LXNzCyMj47S0VBsbO7FY/Nn6PB6vU8ceLZq3Xb5iwcpVi9zKuH9j5V27NtvbOy6Yv0IoFH77888cr6SkJn9thS8x33RE5Ozs+jN/cQnl4OCcl5eXkBD32ctlaWmdkZGefzc1NYWIDA2NBAJB9+59N21ePW/+dEtL6xMnD3Xs0N3JyYVZrXateiqV6uTJwx3ad2OWNGrYZMPGlQqFghng+4OYX8QMQ0MjIsrLk+ANLRTsPiCmJmbM/wFQM408/yPfuHHTZTLp3yv/Ylp+FArFyVOH8x/Nzc1lbuTl5RGRgYFB375DmZ7tb6ycnpHmVsadCQ+pVJqTm6NUKr94ZiIiJycXKyvroPOn5f/rM1epVF9bmVG1ag0ej3fs+IEvnxe+9PTpQx6PZ2JqRkQiHRHTEkVEHh6eDx/dyz9v9OrVi0TE9Em0a9ulhnet1NSUrKzM6dPmjRwxPn9v5uYW5ct7yOXyunUaMksa1PdXKBSGhoaVK3kV9PwF0NXVS0lJzn+XHR2dbWxsz547mf8+yuVymUxWeK9BycLuA1K2bPmXL5+/exdVxNXB5zTy+COfvZ1D/37D1q5bfvnKv038A06dPrp+w9+xcR/cy5aPiHh1PeTS9q2HdXV1Z/8x2dDA0Lt6rVu3rxNROfcK5cpV/NrKXl7eQUGnzpw9YWxkcujInszMjLdvXhc4eJ/H4w0eNHr+ghkjRvZt1qw1n88/f+Gf9m27NGkS8LWCHR2cOrTvduTovmkzfqtbp2FyctLxEwf/XPC3O46+/+f161dXrl7MzMy4cfPqvft32rTuaGJsQkRubuXOnD2xZu2ywYNGBfboHxwcNHnqqNatOiYkxO3YubGql7dXlepENHf+NGNjk9q16xMRj3jx8XE2Nrb5O69dq15c3AcPD0/mrrW1jYeHp5WlNfNz4UdU8ax29tzJZcsXVK7kZWRk7Otbf8Tw8TNnTRwxqm+b1p2UCkXQ+dNNmgR06tijaF4eLcfuA9K9e9/zF/4Z89ugTh17WJhbXgw+p8aSSzTNzg8i6tih+6XLF1auWlTVy3vxX2s2bV4VHBx0+vRRR0fnNq07Md8LFcpXCjp/+uq1YEtL6/HjpleqVIWIvrZy/77DUpKTVq1ebGRk3Kplhy6dApetWPDgYWi1qjW+fHZ/v+a6uro7d25at365iYmpu3sFB8fvjLsdMXyctbXNsWMH7t69aWFhWa9uIytL6yJ7eTTP1WvBV68F6+rqOjm6/DZ2av6w2oEDRmRmZpw7d7JP78GOjs6LFq7euHnVosVz9PT0m/gHDB0ylgn4alVrbN+xIX/uCoFAMGnCzKZNP4628K1dPyEhjs//77C7UYMm+W0mP6JJk4CXr56fv/DPzVvXmjdr7etbv17dRn/OX7Ft+/o1a5caGBh6Vq7q6VmtUF+SkoXFB8TB3vGvhavWr1+xfccGayubunUb3Q29pa56SzTep425+Z4920CU5uHRpaif/k6QUioxq9LQvKifSLtdORRbvkauW5XidXrz2e3kWM7KtaKhOp9UoVDkD3vLyMyYMnW0UChcuWKzOmv4da8fZibFJPr3LF5vaNhd1dvn+nXa2f7Autov7E56TkZyg47F6D06f36ij89CExM3tT2jxh9/AHxq6bL5r1+/ql27vqmpWfS7t5GR4S1btue6qBJq9pzJ9+7f/nK5lZVNYmL8l8uNjUz27D5RiAWMHjvwzZuIL5eXLVshPPxFgZscO/LvjzdmAl4p0Co1a/omJMQdObpXJpPZ2Tn07jWIGcsL6jd61KQ8aQHThcllMqGOzpfL+bxCHs4zc8afMnkBYxn4PJ6yoHYXpsGzcGvQbsgP0CoNG/gz0y8C59Q8pemXmNkloOho9vhdAADgCvIDAADYQH4AAAAbyA8AAGAD+QEAAGwgPwAAgA3kBwAAsIH8AAAANpAfAADABsfnnwt1SKkqRhOQaSg9Qz6PpyIqXq+krj4JML8BK3whifSK17tJRDyeSqyPX5wfCUU8HXGx+9Cp2f+1d99hUZwLF8Df2b7sAkvvRRHFgr1GsXeNBQsa0cQS47X3GKMxid0YSyyxd43dWBPrtSb22K69C0jvsGyd74/x7sdVFBiBd3Y5vydPntlhZ/bsgnN2OuW/BpUjSX6dQzeDDYh9rnV0FdzfsdzOnBqPOynxkRKns7P/0I3IqHBwYRKi8K/1jaTXOSp72iFoo9wfLp6ENRvpZrB2LMvKlcQ5/7uwlzQ3H6LT6mmnsEqGHL2bH+0Q73DyYMUSwbUaLUa9wdWXdgjaKPeHq49IrTHcPFuIW4jDW87ujqlUzywSC279I7iGKCU2O+pRFu0gVubxjTSdVhcQIrgtRQo7Udkq5r8OxNIOQt+9y6kiRucTJLjfUQmj//6bdGP02qxrJxKNBny1KRy9znx65+uAisZK9QVXHpzO/2L/cyHh8Y30PG9TBm8xm9i7l1Je3U/tMJB2lPeo0Yxx8dKd2xdr0JXSf60mE3vrXHJSdFrrvgL9R1eSBLF/s3lP05Vjab8vTZVIxUp7QUQSOIWdKCFKZ+9MQj9hK9Sm/yXgfcRipvso9szuxE0/xvuUk5uwqfIDGDb+uT60EdPpK+H+QgkhtVua7/yddXzzc20mcfaS6XNK+psBy7Isy+a+CXGJMRnMKXGGqo1F7b5AeRCh9AchpE5rUa2WbFoim52OZUxBsA4uRO1IGBr/igqrSXemSXdxQrRBr8W/uvdS2LEu3tZx86IqDUSV6rGZqSQ9SccU9U2f8nX27JVXr2L79Pm0hF+XEKJQERcv6/gdlQyh9AchRCRinNyJkzvtHNbB+hbEbj7Wl7lkWdPnIxIxDs7EwZlCZtnNFGPsa5+Su8k3vJcVfHsFAAABQn8AgDURiUQymYA2nJRm6A8AsCZms1mvx15SQUB/AIA1UShkGk2pP/NbGNAfAGBNcnL0qakZtFMAQX8AgJWRy2VqtR3tFEDQHwBgZXQ6fWZmNu0UQNAfAADAE/oDAKyJRCK2s5PTTgEE/QEAVsZoNGVn62inAIL+AAArI5NJ7e1VtFMAQX8AgJXR6w0ZGbipjCCgPwAAgA/0BwBYE6VS4ezsQDsFEPQHAFgZrTYnOTmddgog6A8AAOAJ/QEA1kSplDs7O9JOAQT9AQBWRqvVJSen0U4BBP0BAAA8oT8AwJrI5TInJ9z/QxDQHwBgTXQ6fUoK7v8hCOgPAADg4723oX/+/ExCwv2SDQMAkI+nT5OTk3NOn/6RdhDBycyMLeFXzLs/AgM/dXevVcJRAADy9fz52YyMV5Ur96EdRIhUKp+SfLm8+0Ol8lapvEsyBwBAQdjbv1AoctzcatMOAtj/AQAAvKA/AACAD/QHAADwgf4AAAA+0B8AAMAH+gMAAPhAfwAAAB/oDwAA4AP9AQAAfKA/AACAD/QHAADwgf4AAAA+0B8AAMAH+gMAAPhAfwAAAB/oDwAA4AP9AQAAfKA/AACAD/QHAADwgf4AAAA+0B8AAMAH+gMAAPhAfwCANZHL5Wq1mnYKIOgPALAyOp0uMzOTdgog6A8AAOAJ/QEAAHygPwAAgA/0BwAA8IH+AABrwjCMWCymnQII+gMArAzLsiaTiXYKIOgPAADgCf0BAAB8oD8AAIAP9AcAAPCB/gAAa8IwDO0I8Ab6AwCsCcuytCPAG+gPAADgA/0BAAB8oD8AAIAP9AcAAPCB/gAAa6JQKJycnGinAIL+AAArk5OTk5KSQjsFEPQHAADwhP4AAAA+0B8AAMAH+gMArIlCodBoNLRTAEF/AICVycnJSU1NpZ0CCCFEQjsACNGZM/9iWQPtFAB5ePgwMSZGe/r0U9pBShFHx+AaNb5+dzz6A/KQkPBPWNg3IhHuMg2C8/z5Fa02tnLlT2kHKS3S0l6+fHklzx+hPyBvbm4VRSIp7RQAb3NwiFEo9G5ulWkHKS0YRvS+/sD+DwCwJrh+u3CgPwAAgA/0BwAA8IH9HwCUpaamt2w58K2R1aqFrF07/a2Rv/9+csaMFX/+ucrV1cloNPboMaZJkzqjR/cjhJhMptu3H1avXpFfhv37Ty1ZsnXLljmenm4fzjlp0qDu3du8+9MjR85+992SPCds1eqT2bPH8Av2LoVCptHYF9Xc4GOgPwAEoW7d0Jo1K1keenq6fvj5DMM4OKgVCjn3cPr0FXfvPtm5cwG/V5fLpWq1nUjEf4NE+fIBQ4ZEcMOHD5/JyMju1asd9zAoyI/3bN+Vk6NPTc0owhkCb+gPAEGoWbPSoEHdC/58sVi8ceNsy0OdTs/vdVmWZRimbduwtm3D+M2BU65cQLlyAdzwjRv3X79OKNTbAWuE/gAQtAcPnv3007q7d5+4ujoFBHhzI2Ni4jt1GkYIGTAgfOjQ3t9/v+z48b8IIbVr9yCEHDiwzNvb3Wg0rlix49ChM6mpGWXK+Hz1Vc+mTetaNkONGtX3wYNnp09fCQkp4+vreejQaULIxYu/SSSSuLjE5cu3X7jwT2ZmdkCAd//+XT6yWnJydMuWbfvzz/M6nSEgwKtv306tWzckhLzvhR48ePbll9NmzRq1dOm2589jPD1dBwzompSUtnv3sYyMLF9fj+rVQ4ro04WPgv4AEISsLG1cXCI37OTkIJPJCCHPn0cPHvy9RmM/fPhnEolk9epd3BOcnR3nz58wadJC7uGAAV3j4hKjo+N//HE4IcTVVUMImTFj5R9/nBswIDwoyO+PP86NH//T6tU/1qjxZgfJ2rV7evRos2LFNLFYxDCM2Ww+cuQs9yOj0fSf/zzu3r21RmN/6tSlKVN+8fPzqly5HL/3ZTabx4yZExOT0L9/V2dnx6tX/zN58iKtVte5c/MPvFB2tnbOnDWTJg2Sy2Xz52/48cdfq1cPmTVrVGxs4rRpy7TanI/+vKEIoD8ABGHz5gObNx/ghpctm1qvXlVCyOLFm0UiZsOGmU5OjoQQkYiZM2cNIUShkDdtWpdh3kzr7++t0TgkJaVZ9p8/fx596NDpQYO6f/VVT0JIixb1u3YduXLlzhUrpnFPCA0tP2zYZ5ZXL1vW1zLs4+Oxa9dChmEIIZ07N2/ZcuDp05d598epU5f++ef+wYPL3NycCSFt24ZlZ+f89tvhzp2bf/iFRo/u16hRLUJIZGTHH35Y/s03XwYF+VerRnbs+OPBg+f8wkDRQn8ACEK7dmHcVh1CSIUKgdxmn7//vtm9e2uuPAghEklB/8Fev36XENKsWV3uIcMw9etXPXLknOUJdeuGfmDyhw+fr1y58+7dJ4QQk8mclJTH9Qp1Or1lvIeHi1ic99Vuzp+/bjQaua1tHJPJrFbb5ftCcrmMG5DJpJb/E0I0GnveO3ugaKE/AAQhIMA7LKxW7jGJiSlGo9Hb+70H1H5AZmY2t5nLMsbR0T47W5uVlc09VCrl75v2ypXbI0bMql278rRpQ1Uq5YQJ883mPE75vn374ZAhP3DD3CHFec4tKSnV1dXJst7DkUjEBX+ht5hMOP9cKNAfAALl5ORACElOTivg83Nf2MPd3ZkQkpaWwW014pbjEolEoZAbDMYPz2fNmj2+vh6LFk3iVneUSkWeTytXzn/+/AncsIOD6n1zc3BQp6Ske3m5WdYnCvtCIFg4/xxAoFQqOz8/zxMnLhoM+V9LX6mUJyWlms1m7mGVKsEMw5w/f517qNfrz5+/XrVq+fdtZcotNTWjfPlAbpmu1+uzs7XcbKVSCSEkPT2Le5pG49C0aV3uP25vf57q1g01mUy7dx+zjLHs/X7fC32YSMTk+xwoGVj/ABCE69fvrlmz2/KwTBnfFi3qDx7cc+rUX/r3n9KpUzORiPnttyPvm7xmzUoHDvx71qxV1auHODioGzeu3bFjk5Urd5pMZl9fj337TiYlpU6fPqIgSWrXrnzw4On9+085Oqq3bj2Unp715MkrlmVVKjtfX88tWw5qNPbh4a0K+L7atw/bu/f44sWbY2LiQ0LKPHz4/N//vrx79yKFQv6+F/rwDAuyjQtKBvoDQBAuX759+fJty8Pmzeu1aFG/XbuwjIyszZsPLF68uWxZ39DQ8i9exOQ5efv2je/efXL48Nlz5659+mnTxo1rT5r0pVptt2PHH+npWUFBfgsXfl2nzof2mVv8618RiYkpP/20zsFBHR7eMjLy01mzVl29eqdOndCZM0f99NO6Q4fOFLw/pFLpsmVTlizZdvTohb17j/v7e3fv3prb//G+F3JwUH9ghmIxtpoIBYOLIcO7du+uHx6+Cff/AOHo3Hl4dHTcWyOdnR2PHVtDKVFpkZh479atXc2br3/3R2hyALACkZEd5fK3v9B88kkNSnGAoD8AwDqEh7f28fHIPcbDw+XzzzvTSwToDwCwBmKxqGfPNpaDgFmWrVWrcpkyvvlNB8UI/QEA1qFLl1aWVRCsfAgB+gMArINEIu7evZVcLmVZtm7d0KAgf9qJSjv0BwBYjS5dWvr7e3t4uPTr14l2FsD5HwBQMA+vmV8/YwwGUXoSxYP+pS0rTc3R6m4ccb9BL4RSzUhlrEeAObRhqf4Kjv4AgHywLHtgJaNxd1A6Sn095Wz+FxkpVp50X54QwohIWpIhLdmweWZaxDgiU5TSS6qgPwAgHwdXif1CnIJrONAOIiDu/kpCSGAl+x0Lovt8zYrEpbFCSvXKFwDk6+px1t3fHuWRJ0dXWZ027id+K43lgf4AgHzcu0J8y3/oglSlnE851ZObJqO+NF4ICv0BAO9l0LMyucjR9b2XZwdCiH9FZXwU7RA0oD8A4L1MBiYj2UQ7hdDpc1iDjnYIGtAfAADAB/oDAAD4QH8AAAAf6A8AAOAD/QEAAHygPwAAgA/0BwAA8IH+AAAAPtAfAADAB/oDAAD4QH8AAAAf6A8AAOAD/QEAQmQymW7f5n+P2o+cHAoC/QEAQvTTz9MXLJpFa3IoCPQHAAiRXsfzkugsy37M5FBwuP85AFB28eL5VWuWxMREeXp6d/q0e3jXiDnzvv/36eOEkGYtahNCtm094OXp/cefB37/fefTZ4+VSru6dRoMHzZeo3EihJw+c+KHHydN/2H+jl2b79//T+9en8cnxL07Oe13aYPQHwBAU3Z29vc/fh0YUHbc2CnPnj1OSkoghER+NiAhPu716+hvJv1ICHFxdiWE3L17298/sFWr9ikpyXv3bc/Kzpo9c5FlPouXzB00YNiA/v/y9fHX6XLenRyKHPoDAGhKSU3W6XRhYc1btWxnGenr6+/oqElOSQoNrW4ZOXbMZIZhuGGJRLJl6zqdTieXy7kxXbtEtGnT0fLkdyeHIof+AACavL18KleuumXrWoVC+WnHcJnsvfdaNxgMe/dtP37iSHx8rFyuMJvNqakpHh6e3E9r1qxbgqmBYP85AFDGMMycWb+0ad1xxcpF/b4Iv3nzep5PY1l28rejt25b165tp7lzlrZq2Z4QYmbNlifYKe1KMDUQ9AcA0KdWq0ePmrRxwx6VSj1l6tjs7GxuPHckFefmzevXrl8eNXJS926fVapYpWyZcvnONvfkUBzQHwBAmU6n4zZkhXftlZmVGRsbQwhRKJTJyUlm85s1jLT0VEJI+eCQ3A8tP33XW5NDccD+DwCgyWAwfN6/W9MmrcoEBu3fv0utUnt7+xJCqlWt+cefBxYsnBVapbq9vUOliqEymWz1mqUdOnR9+vTRtt/WE0KePX3s4+2b52zfmvyTTxqX+DuzfVj/AACatDnaGtXrnDj5x6Jf5kik0lkzFykUCkJIq1btu3bpefrM8VVrlvzn7i03N/cp38589Pj+9z9MvHbt0oKfV9av32jvvu3vm+1bk5fseyotGGwihHft3l0/PHyTSCSlHQQoy8kiW2aZIyYG0Q4iaCe2RtVspg+oyNAOUiwSE+/durWrefP17/4I268AoMhcuHBmzrxp746XSeV6Q94XFFn6y/qAgDLFmiozM7N3n455/qhSxap37+WxdjJ86PjcZ5NAntAfAFBkatWqt2rltnfHG/R66XtO7HBzdS/uVHZ2dnmmIoQQlpC8VhscHTTFncoGoD8AoMgoFAoBXmlKJBIJMJUNwP5zAADgA/0BAAB8oD8AAIAP9AcAAPCB/gAAAD7QHwAAwAf6AwAA+EB/AAAAH+gPAADgA/0BAO/HshK5bV4WsAiJJQxDSuOFaNEfAPBeCjWTnW42GUvjwrHg0pMMKk1pbFn0BwB8iG+wOC0x70vnAiHEbGLNJrOm2C8CKUToDwD4kGpN2KvHEminEK4rxxMqN2DEYqx/AAD8r4AQpnID86ntMbSDCNG1E4lyhbZWC9o5KMH12wEgHyG1zWaj9uS2F0aDyKuMOifbRDsRZXKlKDE6mxCTh7+pQYfSuObBQX8AQP4q1RcFVTMmRDFpiSkGPc0kt249iI9PbtmyAcUMYgnxLUecPVkH51K9CQf9AQAFIleKfIOJbzDlGE8SX+oznldv8gnlHITkfefC0qRUlycAAPCG/gAAAD7QHwBgTcRikUwmpZ0CCPoDAKyMSCQSi7HgEgT8GgDAmhgMRq0W58MLAvoDAKyJSCSSyXDgqCCgPwDAmpjNZr3eSDsFEPQHAADwhP4AAGsik0nVajvaKYCgPwDAyuj1hszMbNopgKA/AMDKKBRyR0c17RRA0B8AYGVycnRpaZm0UwBBfwAAAE/oDwCwJnK5DNuvBAL9AQDWRKfTY/uVQKA/AMCaiMVipVJOOwUQ9AcAWBmTyYTrXwkE+gMAAPhAfwCANVEoZM7ODrRTAEF/AICVycnRJyen004BBP0BAFZGKpVg/7lAoD8AwJrg/lHCgf4AAAA+0B8AAMAH+gMAAPhAfwCANZFKpSqVknYKIOgPALAyBoMhK0tLOwUQ9AcAAPCE/gAAa4LzP4QD/QEA1gTnfwgH+gMAAPhAfwCANWEYhnYEeAP9AQDWhGVZ2hHgDfQHAADwgf4AAGsik0nt7VW0UwBBfwCAldHrDRkZWbRTAEF/AAAAT+gPALAmcrnM3t6Odgog6A8AsDI6nT4jI5t2CiDoDwCwMgqFzNnZgXYKIIQQCe0AAAD5a9ducHx8Mnf+oNlsXr16Nzf+2rXdtKOVXlj/AAAr0LFjU5FIxJ18bhn45JPqtHOVaugPALACvXt38PX1zD3G0dH+iy+60ksE6A8AsAbOzo6tWjWwXPyKZdnKlYNq1apMO1ephv4AAOvQq1d7f38vbtjBQf35511oJyrt0B8AYB2cnR2bN68nEokIIZUqBdWuXYV2otIO/QEAViMiop2fn6eDg3rgwHDaWQDH7wJYoef/MSfFkuwM2jkocGxUcVByclrWy4rnXppphylpdvbE0ZUpU5mIJYK4CQr6A8CaZKaye5cSR1e5s5dSphTTjkPBJ2GNaUegxmwi9y5nXzysaxbB+gTRrxD0B4DVyEwlRzeJW/TxcnCW0c4CdITU05jN7Kltr+q3M3mVpRwG+z8ArMbepeb6n6I8SjuRFzU59wAAIABJREFUiGkZ6b9/hcmgo3wrRvQHgHV4ftfs4CJDeQCn0ieaG2fQHwBQAEkxxMUb1y2HN1y9lEkxlHeBoD8ArEN2JiNTlMYd5pAnuZ04Kw39AQAAVgj9AQAAfKA/AACAD/QHAADwgf4AAAA+0B8AAMAH+gMAAPhAfwAAAB/oDwAA4AP9AQAAfKA/AACAD/QHAADwgftHAdis/gN7Pn/+9K2Rx49elEj+5x9+VPSrvv26Tvl2ZovmbQghc+Z+//z5kxW/buZ+evfenaCywXK5/OPzRPbtEh0TleePNq7f7e8f+PEvka9/blwdO24IN2yvtg8Jqdw3clBoaHXeM8zMzIx5HVU+OMQy5unTx6PHfDlx4rRGDZsWRWThQn8A2DIfb9/WrTvmHiMW53MRXzuVys5OxQ3/efTg3Hk//L73RJH0R/fufdLT0wghiYnxBw/tbdqkZZky5bgfOTpqPn7+BdesaasyZcrFxsacPXdy7Pghy5dtDC5Xgd+sBg3u1aB+WO7+kEgkarW9RGz7S1fbf4cApZmHh1e/voMKNcnI4RMswzqdjt/rsizLMG9fXbxL5x7cwN27tw8e2tuoUTNujafkNW/ehls56Ny5x1dDIg8d2jtm9Df8ZqXX698a4+8fuG3rgcLOJzomytvL590PTcjQHwClUWpqyrLlP1/464xMJq9RvbZlfK/POsbFxVapUm3J4rV/Hj24aPEcQkiX8JaEkK8nTmvb5lNCyLFjh7f+tj4mJsrFxbVD+659PusvEom4zWVlAoMCA4P27tuu0+Xs2vGnWq0uYJ5/blxdvWbpkycPnZyca1SvM2jgMBcXV0LIH38e+P33nU+fPVYq7erWaTB82HiNxokQsnvPtrPnTrVu1WHjplVpaalBQeUHDhh64sQfFy6clkilrVt1GPzliHzXtAgh5YND7Ozs4uJjuYd5vrWr1y5NmDhs2ZL1lSqFck9r16FR1y4Rg78c0euzjikpyb/v3/X7/l0eHp7btx3i1tgIIT/NW1a7Vr3de7ad+vexHt37rF27LCk5MTg4ZPzYKdyWOoPBsG79rydO/qHVZletWvPhw3t9Iwd17tSd1++TDvQHgC0zGA3x8XHcsJ2dilug6/X68ROHRke/6tkj0tPTe//+XZbnjxs7ZfXqJdxwvboNe/aI3Llry+yZi1Qqta+vPyHk6NFDc+Z936JF24EDht69e3vd+l8JIX0jB3KTXLnyd44uZ9aMhdna7IKXx7Xrlyd9M7JVy/Zdu0RkpKft2fvb2PFDVv66RaFQ3L17298/sFWr9ikpyXv3bc/Kzpo9cxE31e3bNyRiyfffzY2Lj/15wYwJE4d92jF8/vxfL148v2HjSn//wA7tu+T70mlpqdnZ2R7unvm+tTx9P23exK+HV69Wq0f3PlKZjBBSo3qdwV+OWPXfz5AQcu/enZ07N48bN8VoNC5YMHP23Gm/LttICFmxavGBA7sHDRzm6ur+64qFOl1Ou7adCviJCQT6A8CW3b59I6J3B244ss+AgQOGEkJ+37/zyZNH3BdkQkjlSlU/7//ma2+d2vV37dqizdESQpycnL29fQkhFStW4fZPsCy7Zt2y0NDqUybPIIQ0DmuekZG+fcfGbuG97ezsCCFiiWTqt7OUSmWhQi5Z+tOnHcNHjpjIPaxdu/7n/btfufp3WKNmY8dMtmzSkUgkW7au0+l0lp0x302drdE4Va5c9fKVvy5ePD9m9DcMw1QoX/HYsUPXr1/+QH8kJSUmJibExb3euGmVSCTq0KHrB97aB5KHVKgkkUhcXFwte+A9PDyrVa351tNmzljo7OxCCAkP77X814Vp6WlqlfrQob0d2neJ6NmX+2Bnzppy+86NWjXrFuqjowv9AWDLgoKCB/Yfyg37+PhxA+fO/7ts2XJceRBCRAXYzsOJinqZmJjALfI4deo0OPLH/qjol9wO5IoVq+Quj4zMjMzMDEKIRCxxc3PPc56xsa9fvHgWHf3q0OF9ucdzq00Gg2Hvvu3HTxyJj4+VyxVmszk1NcXDw5N7jkz2pkhkUplUKrU0jaube1paKjf8OjaGG9A4OlmyLVo8h9s05+Tk/O3kGeWDQ169evG+t1bAD+cDFIo3r+vh4UUISUpMMBmNer3e8hvhBjIy0j/+tUoS+gPAljk6aBo0CHtrZHx8bHCu44UKLjMrkxCi0ThbxtjbOxBCEhPiuf5QKv5nzWPPnm0bN60mhPj5BWzasCfPeaakJBFCPu83uHFY89zjnZ1dWZad/O3oBw/vft5vcKVKVc+dO7V9xyYza843J8MwLMtyw5/1ebNRyHKAMiHki8+/qly56uJf5opEIm5H+gfemqwojj3jSCVSQojJbHJ01KhV6tu3b/To3ofbxkUICSobXFQvVDLQHwCljsbRKSUlueDPtyyL3d08uH0Glh9x8+EWte9q3qxNuXIVCCFKpd37Zq5W2xNCdLqcd8//uHHj2rXrl7+dPKNli7aEkOgoPqsC03+czw1UKF/JMjIoKLh2rXoTxk0dNebLTZtXDxo47ANvTW94+wirt1g+n4ITi8W9e3+xes3SGTO/dXV1339gV7fw3n5+AYWdD104/xyg1AkODnnw4O6rVy/yfSa3PpGYmMA9dHFx9fTwunz5guUJZ86cUCgU5d5z8oS/f2Cjhk0bNWz6gc36vr7+Hh6ef/x5QKvVcmOMRqPBYCCEpKWncodIceO5h2Zz/usfuXEBGjVs+u4GtKpVa3Tu1H37jk0PH93/wFtz0jgTQhKT3nwISUmJXDzLR5SUlFioSJwunXvWqV0/JSU5MzPj28kzhg8bx2MmdGH9A8CWxcW93rR5jeWhQqHo2SOyd+8vjh0/PGrMl927febi7Hry1J/vm7xylWpisXjp8vnt2nTS6XWdPu32xedfzZn3/U/zp9ep0+D69cvnL5z+vN/gwu4wz41hmGFDx303bcKwEV90+rS72WQ6euxQq1btu3f7rFLFUJlMtnrN0g4duj59+mjbb+sJIc+ePvbx9uX9cm/5ctCIvy+e++mnH39dvul9b83fP9DDw3PLlrVOGudsbfbatctyd1hoaI2Tp/7c9tsGe3uHypWqli1broAvPX3mZAcHxwYNGhNCGMLExcVa9utYC/QHgC2Ljolav2GF5aGDg2PPHpE+3r5z5yxZsWLRho0r3d08GjVqduXqxTwn9/H2HTf22zVrly1dNj84OKTTp93atOmYo8vZtXvrseOHXV3cBn85oldEv48MGdao2eyZi9ZvWLFs+c8qlbpqaI2qVWsSQtzc3Kd8O3PZ8p+//2Fi5UpVF/y8cv2GFXv3bW/UqMiuC6JSqcaM+uabb0dv+21Dv76D8nxrEonk+2nzFv8yd8LXw3x8/Pp/PmTm7CmWOXw1eGRycuLmLWs0jk5Dh44teH/UrFFnw8aVJ08d5R6KxeKJ479r3bpDUb21EsDw2HIHNm/37vrh4ZtEIintIPD/zv3OypTOleqX6HU+oPiYTCbLGY7pGemTvhkpkUh+WbQmv+neiH+Zc+PU626jijMiIYSQxMR7t27tat58/bs/wvoHAAAFPy+Y+eTJwwYNGms0Ti9fPX/69FGHDl1phyoc9AcAAAV1634SHx+7Z+82g8Hg5eXTr++X3LG8VgT9AQBAQdMmLZs2aUk7xUfB8bsAAMAH+gMAAPhAfwAAAB/oDwAA4AP9AQAAfKA/AACAD/QHAADwgf4AAAA+0B8AAMAH+gMAAPhAfwBYB5WamPSFu3US2DC9zqR2YuhmQH8AWAcnT5IQraWdAoQiISrHyYPy9wn0B4B1KFOFSU3IyUo30g4CgvD4elpoQ8p3b0J/AFiNzkOY8/titJmokNLu5LboVpGMUk15AY7rtwNYDY0b0+oz4+7FLzzLKF297eR2YtqJoESxLIl9npUUow3rwvqVp7zzA/0BYGUcXZnOo1KTX7JH9l015sgqVgqSSYV1m+HMrOysLG1GRmZmhtZkNtWqWZl2orc9exblqLF3dnKkHaTQ1BoSGGJqHkHkCkFsOkJ/AFiBnBydQiE/ePDfM2as/PXX72rWdHIN9Hd25paAlDeCcw4cOHX58u0HD55lZWlTUzN0Oj0hpEaNipMip9OO9i6ftWv3NGza0NfXk3YSHgTRHBz0B4CgPXr0YvbsVY0a1RowIDwkpOyFC1skEgkh5L/lIQgREWOfPHlFCGFZlmEYQgjDMGKxuEOHxrSj5W3gwG60I9gCAVUZAHAyM7PmzVs7Y8YKQohebxg1qt+AAeGEkODgAK48hGbHjgX+/l5cbVhGeni4tGsn0P7gVul69RpHO4V1Q38ACMXRoxcmT15ECElMTA0I8B4+/DNCSOXK5apVq0A7Wv727v3F09M195imTWsrFHJ6ifKhUMiXLZu6Y8cftINYMfQHAE0xMfEbN+7PzMwihNy8eb91608IIYGBPhER7TQaB9rpCqdatRCVSskNu7o6d+zYjHaifLi4aCIi2tFOYcXQHwAUXL165+nTV4SQBQs2pqWlKxQKQsjEiQObNq1LOxofBoOhbdvBvXq1O3Nmk1wuI4QEBfmULx9IO1eBbN16aMGCDbRTWCX0B0AJMZlMMTHxhJDp039dvXo3t5ydP3/CyJF9JRIrPpPj5cuYsLB+mzfPCQ0tTwi5cGGrnZ2ya9eWtHMVVJ8+HStVCrp69Q7tINZHiPviAGxJVpZWpVKePXt1/Pifli2b4u3t/vXXg2QyYZ20wdvFizcXLNh48eJvuUeePbuJXiI+2rYNox3BKmH9A6C4JCWlDhw4Ze7cNYSQoCC/y5d31KkTSgixmfI4dOj05s0Hdu5cQDtI0Rg4cGpiYgrtFNYE/QFQlMxm89q1e0aPnk0IMRpNI0ZE/vjjCEKIj48H7WhFbOnSrU+fRi1bNpV2kCKzfPnUZcu20U5hTdAfAEXg2bOolSt3mEwmvd6g0+lHjIjkToCoXj2EdrRiMXnyQpXKbuTISNpBipJcLps2bRjtFNYE/QHA3+PHLzIysrhd4gwjEovFCoV86NDeQUF+tKMVo+HDZzRpUrd//660gxSLM2eubNt2mHYK64D+ACg07uJOo0bN/vbbX7gTrtetmzl4cA/auYpdTo6udetBQ4ZEtGnTkHaW4tKkSZ3U1PRTpy7RDmIFcPwVQCGcOPH3mjW7Z84cHRTkN2HCAF9fW9ur8QFPnrzq12/SgQPLXFw0tLMUr6FDe9OOYB2w/gGQD7PZvH//yb//vkEIyc7OmT59JLd5qlSVx19//fPNNwsuXNhq8+XBMRpNOKkwX+gPgPe6f/8pIWTTpv03bz4MDg4ghHTq1IwbKFV27PjjxIm/d+5cSDtIyZFIxA0aVB8+fAbtIIKG7VcAb2NZVqvN6dx5eEREu5CQsl98YZs7igto0aJNer3hu++G0g5S0ho0qF6vXlXLFenhXVj/APh/589fGzLkB6PRyDDMjh0LBg3qTjsRZdOmLXVx0UycOJB2EDpEItHFize5Q+zgXegPAJKcnPbsWRQh5K+/bgwcGC6VSpVKhaBu0ERF375fN21ap2/fTrSD0FSmjE+vXuNppxAo9AeUdidPXoyIGCsSibgr4HKXGCnlsrK0LVr0/+abwc2a1aOdhTJPT7dly6bcufOIdhAhwv4PKKWuX7/74MGz3r07BAR4Hz++lnYcAXn06MXAgVMOHFiu0djTziIIgYE+tCMIFNY/oNQxmUyxsQm//rq9QYPqhJBy5fxpJxKQc+euTZ36y9mzm1EeuT1/Ht2nzwTaKQQH/QGliNFo+u67JTqdXqNxWL36R3yvfMtvvx0+fvyv7dt/ph1EcAIDfT79tNnZs1doBxEWbL+CUuS7735p2LCmnZ2SdhAhmj9/PSGEu1owvKtXr/a0IwgO1j+gVNi69RAhZNasMR06NKGdRYjGjp3r4+M+fnx/2kEE7datB9wppcBBf4DtW7Jka2CgN+0UwtW79/jOnZv37t2BdhCh8/R0HTNmLu0UAoLtV2D7mjWrW6VKMO0UQpSWltG379fz508sXz6QdhYr4O7usmDBxMTEFFdXJ9pZBAH9Abbs8eMXWVk51apVoB1EiO7ffzp06PSDB5epVHa0s1iNihWDaEcQEGy/Alu2dOk2f39P2imE6OTJi0uWbD11aj3Ko1D0esPYsdiE9Qb6A2xWVpa2WbN6Tk6l/TIk79qy5eDRo+dt6dblJUYmkyYkJN+9+4R2EEHA9iuwWSqVsnPn5rRTCM7y5b/pdPp583BNJ56WLJkiFuObN8H6B9i4Vat2RUXF0k4hIGPGzPHychsz5nPaQayYRmNvb6+inUIQ0B9gy+rXrzp16hLaKYQiImJs164tu3ZtSTuIdbt588HmzQdopxAE9AfYsqpVK8ybNy4tLZN2EMpSUzP69Zs0c+boxo1r085i9bKztZcu3aKdQhDQH2Dj3NycZTLJpUs3aQeh5u7dJ926jVyx4ntcKbJIhIYGDxkSQTuFIKA/wPYplYqNGw/ExyfRDkLBmTNXZs9edfLkejs7Be0sNkKtVuF0VA76A0qF5cunPnsWbTAYaAcpURs37r906dbmzThfoSg9fPj8669xiWKC/oBSpF69qnq98ciRs7SDlJBZs1ampaWX2luXFx+93hAXVxrXZd+F/oBSRKVS/v33jefPo2kHKXazZq2sUKHsyJF9aQexQYGB3uPGfUE7hSCgP6B0mT59ZHJyWnJyGu0gxSg8fGTr1g27dWtFO4htUqtVoaHlaacQBPQHlDo1a1bS6w1r1+6hHaToJSam1K/fe+HCSbVrV6GdxWY9fvxiypTFtFMIAq5fAqWRp6erTqePjo7z8fHgxrRo0b9x4zrTpg2lHY2/W7ceLFq0+dy5TVKplHYWGxQRMVanMxDC5uTo09MzunR5TAir1eYcPbqGdjRqsP4BpdTQob3FYlFKShohpGPHIWlpmf/8czczM5t2Lp7+/e9LCxduWrduBsqjmHTq1DwmJi4qKi4xMUWvN0ZFxUZFxZXyqxejP6D08vR0E4vFTZr0i41NIoQkJaX+/fc/tEPxsX79vps3H6xfP5N2EFvWs2dbf3+vt0a2bduQUhxBQH9AqRYZ+XVWlpYb1mp1J05cpJ2o0Fas2J6VlT16dD/aQWycVCrp2rVV7ivv+vp6RESU6pv+oj+g9OrSZURMTHzuMffvP7OuQ/uHDZvu7+89fHgf2kFKhYiIdpYdZoSQdu3CHB3VVBNRhv6AUmr48OmpqRksy7IsaxmZmJj8119WswkrPHxk376d2rdvTDtIaSGRiHv0aM2tgvj5efTs2Y52IsrQH1BKLV06dcGCiZ991jEoyE+jsedaJCdHf/KkFWzCshynW79+NdpZSpfu3dv6+LhzKx9OTg6041CG43fByqTEs8mxxKBjPn5WdqRSh8aVOjQmr18nPHjw7N69pxkZmdlx5P6VoghabLRa7bJl+9Yu2qyNl9yPL8AEBSOVs86exMm9CD7YEqDLMSfHMhlJxGwu4cCSTs0GXrjwT92KXUr+70SqYF08icZNKL8jJvfKOwBn9+764eGbRCJhHQmansye2sGkJxG/Ckpdtrk4XsJkMhkMRoVCXhwzLyoGg1EqLfpvfnKl6NVDraMLaRbBOjgLZQmVp9vn2Uc3RUYd4xGo0GaYaMcpOVIFE/0wx9GNtPyMVTmU0O8oMfHerVu7mjdf/+6PsP4B1iE9SXx4Hdu4u5eDs4x2FptVuw1JT9YfWhvTcYDIwUWgy+WbZ6XRj8WtIt8+lLa0aEtS4nQHVr7uOIixdyqWb1EFh/0fYB22ztG37e+H8ihuDs6ydv39t87R0w6StwfXyMsHorBupbU8CCGEOHnIW/bx2/GzkXYQ9AdYg6snzDVauEik+HMtCRKpqEYLl2snBLdlm2XZ2+dJvfbutIPQp1CJQ+pqbpzF+gdAfuJeiNQaYe2MsW32TtLXz2mHeIcum6TEmZVqbHUnhBB7J1n8C8q7qdAfYAUMOoL+KEn2TlJDjuB2oWemss5e2ID5hr2TVKelvABHf4AV0GkJjhMsSSzL6LKF94kzIn22QPfqlzyWJXot5d8R+gMAAPhAfwAAAB/oDwAA4AP9AQAAfKA/AACAD/QHAADwgf4AAAA+0B8AAMAH+gMAAPhAfwAAAB/oDwAA4AP9Abbp6rVL/xrar027Tz7t3HTCxGEpKcm8Z3Xkj/1dwlvGxcV+fKr+A3s2a1H7rf+Mxjxu5NAjot2ChbO44Tlzvx/yr76WH8XGvn4dG/PxYaCYREW/atai9slTR2kHKXa4EjLYoEePH3wzeVRQ2eCBA4bGxcdev35ZpVLznptMJlep1CJR0XzZ8vH2bd26Y+4xYrH4w5PYqVR2dipuODomqm+/rt9Nne3l6V0keQB4Q3+ADTp9+rjJZJo7d6mjgyN33yGG4X818pYt2rZs0bZQk3zgFT08vPr1HVSouY0cPsEybDIaWV7XIv7IDwHgXegPsEE5uhyGYWTSN/eKyL3cfB0bs3z5gmvXL8lk8vLBIQMGDA2pUIkQMuW7cX6+ARKJ5NDhfUaDoX79RqNGTlKr1XPmfX/06CFCyPGjFyUSCSHk7r07K1YuevDgrkKh/KRB43/9a4yDvQO3bapMYFBgYNDefdt1upxdO/5Uqwux0mMymTZtXn3o8L6cHG316rV1OTnc+F6fdYyLi61SpdqSxWtfx8Z83r87IeSHHyf9QEibNh0nTfy+4JH27TmhUCiK+sO2QfsP7N65a0tiYrynp3eL5m0jevaVy+WPHj8YMXLAnFm/rFqz5MmThx4eXl99ObJhwybcJKmpKcuW/3zhrzMymbxG9dq030EJQX+ADapTu8Hevdvn/fTDmDGTuSUpJykpccTIAT4+fsOHjWcY5tixw6NGD1qxfHOZMkGEkJ27tjRv1nrWzEUvXzybv2CGi4vbkK9GhXftZTabjx8/ws3h+fOn48YPCQwMmjhhWlpqyvoNK+LjY3+e/yv30ytX/s7R5cyasTBbm/2+8jAYDfHxcdywnZ3K8rTFv8w9eGhvu7adqlWtefnKXxmZGdz4cWOnrF69hBt2cXb9dvKMmbOm9P9iSI3qtZ2cnAsVCeVREBs2rtq1e0t4114BAWVfvXq+Y+emqOiXkyf9SAjR6XQ/TJ80YvgEL0/v9RtWzJj17fZthxwdNXq9fvzEodHRr3r2iPT09N6/fxftN1FC0B9gg+rXazhwwNCNm1Zdufp3eNdevXt9oVQqCSGbt6xx0jj//NOv3JpEq5btI/t1OXRk34hh4wkhvr7+k7+ZzjBMxZDKZ8+funL17yFfjSofHBIYUNYy5y1b14pEonlzl9qr7Qkh9vYOs+Z8d/Pm9WrVahJCxBLJ1G9nca/1Prdv34jo3YEbjuwzYOCAoYSQh4/uHzy01/KwTZuON25e455Tp3b9Xbu2aHO0hBCZTFY+OIQQ4u8fGBpavagigUViYsLWbeumfDuzSeMW3BgXF7eFi2YPHzaeezhi+ITmzVoTQgYNGv7VkMibt643Dmv++/6dT548+mnestq16hFCKleqyq0m2jz0B9imyD4DmjZttWXL2i1b1508dfSXRWtcXFwvXboQnxDXvmOY5WkGgyHhv2sDCrnCsqXLw8Przp2b7872xs1rNWrU4ZbUhJA6dRoQQh48vMstrCtWrJJ7SZ2RmZGZmUEIkYglbm7u3MigoOCB/Ydywz4+ftzAuXOnCCHdu/exTFvw3fWFigQfdu3aJaPROHPWlJmzpnBjuL1NiQnx3EOl4s2H6eHhxfUNIeTc+X+XLVuOKw9CiCi/AyJsBvoDbJavj9+kr79v06bj+AlDt23fMGLY+OSUpAYNwgYPGpH7aXkemiWVSM3mPG6VmpWVqXF0sjy0t3ewLERyL1w4e/Zs27hpNSHEzy9g04Y93EhHB02DBmH/O1cSFx+rVqu5vf2FVahI8GFJyYmEkFkzF7m7eeQe7+3t++z5k9xjpBIpIYT7I4mPjw0ODinxsPShP8DG1aheu0KFSg8f3uOWrWlpqf7+gbzn5urqnp6eZnnInVai/u93/7c0b9amXLkKhBCl0u7Ds9U4OmVmZur1eplMVqyR4MPs/7u3rFB/JBpHp485wch64fxBsEEmkykrK4sbzszMjImJ4r6G16xZ986dmw8e3rM8U6vVFmrOlStXvXHzWs5/D446e/YkIcSyK+It/v6BjRo2bdSwaa2adT882/LlKxJCTp76M98AcrmCEJL039WLwkaCD6tRow7DMPt+32EZU5C/kODgkAcP7r569aKY0wkO1j/ABl26dGHOvO8/adDY2dnl/IXT6elp4eG9CSGf9xt88eL5CROH9ewR6eTkfPnyXyazacaPPxd8zpGfDTh16ujX34z4tGO3+PjYjZtW1aheu3q1WgWfQ1zc602b11geKhSKnj0imzVttXnLmgULZz179iS4XIX/3L2VmKshcnN39/D28tm5e4tCqUxPTwvv2uvjI4GFr49feNdee/b+NnnKmEYNmyYlJf6+f+fsWYvLf3DzVO/eXxw7fnjUmC+7d/vMxdm1IN8DbAP6A2yQg4NjuaDyFy6cZhgmKKj82NGTq1evxZ37vfSXdb+uXLR12zqGYYKDQ7p2iSjUnH19/efNWbpqzZJ5P/2gVNq1atl+yFejC3VeXnRM1PoNK3JH7dkjUiwWz529ZPGSuQcO7lap1E0at3B01OQ5OcMwU6bMmvfTD0uXzXd392zWtPXHR4Lchg0d6+7usW/fjitX/nZxcQ1r1MzN1f3Dk/h4+86ds2TFikUbNq50d/No1KjZlasXSyovTQy/c1nBtu3eXT88fJNIJKUd5I0dP5O67b1dveW0g5QWybH6v/dH9ZoorBJKjCHHNzMdh/DffWVL4l/m3Dj1utuoYn+hxMR7t27tat58/bs/wvoHANim1WuWHji4+93xwcH50ovuAAAMj0lEQVQVHz26l9cUZOkv6wMCyhR3AJlUrjfo8pxk+7bDKpWqqAIUN/QHANimnj37duwY/u54EcOY37PdJd9NVUUSwKDXS99zoJ11nayD/gAA2+To4MjvlBqbCVDccPwuAADwgf4AAAA+0B8AAMAH+gMAAPhAfwAAAB/oDwAA4AP9AQAAfKA/AACAD/QHAADwgf4AAAA+0B9gBRzdGbMZF4ouOWaT2dFdcAsHsdhspykttxbPl5llHdwoXyBZcH8iAO9S2pmTonNopyhFEqNzlGoz7RRvc/IQxTzWGQ2CC0ZFwiutnb2Jbgb0B1iBsqFsYnQW7RSlSEJUVrmqQlzhq1hPHP0YfwmEEJIUkxUUSjkD+gOsgF95kZuP/uLhONpBSoWLh+PcfPS+5YW4cGjanfxzMiE5Nu+bZ5Qef+2P9Q02eAZS/h3h+u1gHeq0JleOZZ3f98rFR+3uqxSJhbh0s2pmkzkhWpv4KtPVx1CntbDuPJhb7wlk+89R5WrY29krnTzkbGnammUymhOitHEvMvwrGKs1pv87Qn+A1ajTmol6qH9yO/nBZVFyXGlabJQIJw+RUmWu0pD4CXLNw0IiYyK/YW6dy3j9JOPVA1F6Ykn/JRiNpqwsraOjuoRflxDi7MEo7dnaLYhXWUH8jtAfYE18y4t8y3ODgvj3Y3Os5lOtGiaqGsYNlnTmO3eezJ+/fsPMWSX8uv9Ff7XDwmr+XAAAQFDQHwAAwAf6AwCgEEQiJiDAm3YKQUB/AAAUgtnMvngRQzuFIKA/AAAKgWEYNzdn2ikEAf0BAFAILMsmJCTTTiEI6A8AgEIQiRgfH3faKQQB/QEAUAhmMxsdHU87hSCgPwAACkEkYry93WinEAT0BwBAIZjNbExMAu0UgoD+AAAAPtAfAACFgP3nFugPAIBCwP5zC/QHAADwgf4AACgEhmGcnBxopxAE9AcAQCGwLJuSkk47hSCgPwAAgA/0BwBAITAMcXBQ0U4hCOgPAIBCYFmSnp5FO4UgoD8AAIAP9AcAQCEwDOPi4kg7hSCgPwAACoFl2aSkNNopBEFCOwAIVFraC4bBnwfA2zIyXptMutTU57SDlJDMzLj3/QgLCMiDRlPuypU1tFMACNGrVzlSaerlyytoByk5Tk4heY5nWJYt8TAAANbqzp078+fP37BhA+0g9GH/BwAA8IH+AAAAPtAfAADAB/oDAAD4QH8AABSCSCQKCAignUIQ0B8AAIVgNptfvHhBO4UgoD8AAIAP9AcAAPCB/gAAAD7QHwAAwAf6AwCgEHD8lQX6AwCgEHD8lQX6AwAA+EB/AAAAH+gPAADgA/0BAAB8oD8AAAqBYRhnZ2faKQQB/QEAUAgsyyYnJ9NOIQjoDwAA4AP9AQAAfKA/AACAD/QHAEAhMAzj5uZGO4UgoD8AAAqBZdmEhATaKQQB/QEAAHygPwAAgA/0BwBAIeD67RboDwCAQsD12y3QHwAAwAf6AwAA+EB/AAAUAs7/sEB/AAAUAs7/sEB/AAAAH+gPAIBCEIlEfn5+tFMIAvoDAKAQzGbzq1evaKcQBPQHAADwgf4AACgEhmE0Gg3tFIKA/gAAKASWZVNTU2mnEAT0BwBAIWD/uQX6AwCgELD/3AL9AQBQCAzDuLq60k4hCAzLsrQzAAAIXWRkZEpKCsuyer0+IyPD1dWVGz5x4gTtaNRg/QMAIH9hYWHx8fHx8fGpqakmkykuLi4+Pl4ikdDORRP6AwAgf926dfP19c09hmXZsLAweonoQ38AAOTP1dW1devWDMNYxri7u/ft25dqKMrQHwAABdKzZ0/LKgjLsp988om/vz/tUDShPwAACsTFxcWyCuLr69uvXz/aiShDfwAAFFSPHj18fX1Zlm3QoEFAQADtOJSV6oMHAKCU0GaatBkmcxGcreDQIqzrmTNnPm3TJzFG/5HzYllWphDZ2YulMqv8Ko/zPwDABpkM5md3sx9cy8xIMSZG50hlIkcPpTb9Y5f4RYsRM0adWa81MSLi7m/nVUYeXE3l5iunnaug0B8AYFP0OvPZPUlPb2cqHeVqNzu1i1IiE+c+bkqATEazQWtIi8vOSsp2cJZU+cQ+pLY97VD5Q38AgO04fzD59tkU93LOLv4OtLPwpM8xJjxONukNTXu4+pe3ox3nQ9AfAGAjtsx+Kdeo3AJt4eYc2gxdWkx6UGV5nVZOtLO8F/oDAKyeNtO47rvnZet5Kx2sZudBQcQ9SrK3Z9v396AdJG/oDwCwbplpxr3LXvtV82JEgt7JwU/c42QPH3HTcGfaQfJglQeNAQBYbJn5wifU0ybLgxDiUc45MdZ8fn8S7SB5QH8AgBXbvSTGr4anWGLLizLXMk4vn+gf/pNBO8jbbPlDBwDbdvNsqtEkVmkUtIMUO88Kbse3xNFO8Tb0BwBYq78OJbkFCXHHQJETiRj3spoLB4W1FQv9AQBW6crxFLcyGtvecpWbW1mnB1cz9Dkm2kH+X2n56AHAxty+kObgrqKdIg+JSa/GT633z61jRT5nOye7u5cEtBcE/QEA1ifptY4QRmYnpR2kRKld7R7dyKKd4v+hPwDA+jy9naVyFvS1PYqD2kWZ8CrHaDDTDvIGrt8OANYn7qVO6VhcG6/+urznzIVtaenxzk7eNaq2btowUiqVR8c8WLrmy4F9Fx45tjwm9qGTxqtD6+FVKjbmJsnMStl/ZOF/7p+VSuRBZWoVUzBCiL2rIu6lzidIWXwvUXDoDwCwPhkpRkdfcXHM+dip1WcubGvUIMLDrUx84ovT57YkJr7q3f17QojBoNuy49suHcY5abyOnlq1bdfUb8ftV6k0BqN+5YYRSUmvGjfs4+zk9delPcURjCOWiLLSjMU3/0JBfwCA9cnOMLnIi37xlZaecPLshj7dp1et0pwb42jvuufg3M7tx3IPu3QYVz20FSGkfauhi379/Mnzf6pWbnbh4q7XsY8Gf76kfLm6hJBAv9B5v0QUeTaOSCrOThfKIVjoDwCwPnYOUkkx3LPv0ZPLJpNx6+7vtu7+7r/jWEJIWkY890AmfbPhyEnjRQhJz0gghNy5d8bLoxxXHoQQkahYVow4UoXEZBLKRQvRHwBgfXIyDQadSW5XxBWSnpFICBkYuUDj6J57vIuzb2zck9xjJGIpIcRsNhFCUtNifbwqFG2S99FrDVKZUK4xjP4AAOtjZy8x6kzyoj5+V6l8c9cpd7fAgk+lVjllZqUUbZL3MRtMdg5CWW7j+F0AsD4uXjKToeh3AwSXrc0wzPlLOy1jdHptvlP5eFV4FX03PuFFked5l1jMqByLcftYoaA/AMD6uPvLspLyX7IXlquLX6P6EXfvn1u3ZdylawdOnF43Z2G3qJj7H56qWVg/hhEtXzfk1NmNV/85vPfQT0UejGM2s8nRWV6Bgjh4F9uvAMAqla2ivvhHilcxzLlTu9EaR/fzF3c9eHzRwd61SqWmjg7uH57E1cX3y36LDx395eip1RpHj9CKTR8+vlQM0UhGQrZvBQFdsgX3HwQAq/Tb/CiNn7ON3bD2w17fS6gRZhdSx4F2kDew/gEAVqlamMPNC+lKB7f3PeHIseV/XcnjVD5fr5Co13lvkhrx5RoP9zJFlfDI8eV/Xc4jgFQiNxh1eU4yZdwBhSLvNQyTwZQWlx1Sx7Oo4n08rH8AgLXaOP2FR4i7Qi3L86dZ2Wk6XR5XG2SY9y73HB3cxeIi+1b9vgBGo0EiyfvIMY2jp0iU927p1/cTq9RVhDZ0LKp4Hw/9AQDW6umdzEvHMrwq5rN/wgbotcb4h/GRk/xoB/kfOP4KAKxV2SpqF3dxSnQ67SDF7tWN2PZfCK4m0R8AYMVaR7rnpGRmJRf9sbzCEX0nrlFnZ2dPwR0pgO1XAGD1di2OsXN1UDkL5cSIIvTqZlzDjo5lqwjosF0LrH8AgNXrMco7PSYl1eY2ZL28HlOlvp0wywPrHwBgO45vjU+INbsEOMpVeR+RZUWSozJ0qZmNw519goR7m0X0BwDYjsc3M8/9niRXy538HJT2gtthkC+WZTMSs+MfJfuUUzbv6SpXCuVSV3lCfwCArfnPxfSb59Ky0kxqFzu1q1IsFUvlYolczDAM7WhvMxnNRp3RqDMZcowZCVlpcdqQeo61Wzhq3KxgFQr9AQC2KT3Z8PR2VuxLfVKMTptptHOQJsfk0A71PyQyEWFZhVpiZy9291cEVlQGVhLoro48oT8AAIAPHH8FAAB8oD8AAIAP9AcAAPCB/gAAAD7QHwAAwAf6AwAA+EB/AAAAH/8H6DYavTilPrcAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "" ] @@ -299,9 +237,7 @@ } ], "source": [ - "from IPython.display import Image, display\n", - "\n", - "display(Image(master_flo_with_reflection.draw()))" + "company_flo.draw()" ] } ], diff --git a/examples/rag_document.txt b/examples/data/rag_document.txt similarity index 100% rename from examples/rag_document.txt rename to examples/data/rag_document.txt diff --git a/examples/email_reply_agent.ipynb b/examples/email_reply_agent.ipynb index 30c2c1e..bb352de 100644 --- a/examples/email_reply_agent.ipynb +++ b/examples/email_reply_agent.ipynb @@ -116,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -127,7 +127,7 @@ "from langchain_text_splitters import CharacterTextSplitter\n", "\n", "# load the document and split it into chunks\n", - "loader = TextLoader(\"./rag_document.txt\")\n", + "loader = TextLoader(\"./data/rag_document.txt\")\n", "documents = loader.load()\n", "\n", "# split it into chunks\n", diff --git a/examples/delegator_example.py b/examples/python/delegator_example.py similarity index 100% rename from examples/delegator_example.py rename to examples/python/delegator_example.py diff --git a/examples/hierarchical_blogging_team.py b/examples/python/hierarchical_blogging_team.py similarity index 100% rename from examples/hierarchical_blogging_team.py rename to examples/python/hierarchical_blogging_team.py diff --git a/examples/linear_router_team.py b/examples/python/linear_router_team.py similarity index 100% rename from examples/linear_router_team.py rename to examples/python/linear_router_team.py diff --git a/examples/llm_extensibility.py b/examples/python/llm_extensibility.py similarity index 100% rename from examples/llm_extensibility.py rename to examples/python/llm_extensibility.py diff --git a/examples/rag_tool.py b/examples/python/rag_tool.py similarity index 97% rename from examples/rag_tool.py rename to examples/python/rag_tool.py index 6df5ccf..d98bbb7 100644 --- a/examples/rag_tool.py +++ b/examples/python/rag_tool.py @@ -21,7 +21,7 @@ session = FloSession(llm, log_level='ERROR') # load the document and split it into chunks -loader = TextLoader('./examples/rag_document.txt') +loader = TextLoader('./examples/data/rag_document.txt') documents = loader.load() # split it into chunks diff --git a/examples/rag_with_reranking.py b/examples/python/rag_with_reranking.py similarity index 100% rename from examples/rag_with_reranking.py rename to examples/python/rag_with_reranking.py diff --git a/examples/reflection_example.py b/examples/python/reflection_example.py similarity index 100% rename from examples/reflection_example.py rename to examples/python/reflection_example.py diff --git a/examples/simple_blogging_team.py b/examples/python/simple_blogging_team.py similarity index 100% rename from examples/simple_blogging_team.py rename to examples/python/simple_blogging_team.py diff --git a/examples/tool_agent.py b/examples/python/tool_agent.py similarity index 100% rename from examples/tool_agent.py rename to examples/python/tool_agent.py diff --git a/examples/tool_error_handling.py b/examples/python/tool_error_handling.py similarity index 100% rename from examples/tool_error_handling.py rename to examples/python/tool_error_handling.py diff --git a/flo_ai/__init__.py b/flo_ai/__init__.py index d7f3fe3..2ec5d57 100644 --- a/flo_ai/__init__.py +++ b/flo_ai/__init__.py @@ -1,9 +1,13 @@ from flo_ai.core import Flo as Flo -from flo_ai.models.flo_agent import FloAgent as FloAgent -from flo_ai.router.flo_supervisor import FloSupervisor as FloSupervisor from flo_ai.models.flo_team import FloTeam as FloTeam +from flo_ai.models.flo_agent import FloAgent as FloAgent from flo_ai.router.flo_linear import FloLinear as FloLinear +from flo_ai.router.flo_router import FloRouter as FloRouter from flo_ai.state.flo_session import FloSession as FloSession +from flo_ai.models.flo_llm_agent import FloLLMAgent as FloLLMAgent +from flo_ai.models.flo_tool_agent import FloToolAgent as FloToolAgent +from flo_ai.router.flo_llm_router import FloLLMRouter as FloLLMRouter +from flo_ai.router.flo_supervisor import FloSupervisor as FloSupervisor from flo_ai.retrievers.flo_retriever import FloRagBuilder as FloRagBuilder -from flo_ai.common.flo_logger import get_logger as get_logger -from flo_ai.common.flo_langchain_logger import FloLangchainLogger as FloLangchainLogger +from flo_ai.models.flo_delegation_agent import FloDelegatorAgent as FloDelegatorAgent +from flo_ai.models.flo_reflection_agent import FloReflectionAgent as FloReflectionAgent diff --git a/flo_ai/builders/yaml_builder.py b/flo_ai/builders/yaml_builder.py index e5da427..5f72cbb 100644 --- a/flo_ai/builders/yaml_builder.py +++ b/flo_ai/builders/yaml_builder.py @@ -1,3 +1,4 @@ +from typing import Union from flo_ai.models.flo_team import FloTeam from flo_ai.yaml.config import ( FloRoutedTeamConfig, @@ -14,9 +15,10 @@ from flo_ai.common.flo_logger import get_logger -def build_supervised_team(session: FloSession) -> ExecutableFlo: +def build_supervised_team( + session: FloSession, flo_config: Union[FloRoutedTeamConfig, FloAgentConfig] +) -> ExecutableFlo: name_set = set() - flo_config = session.config if isinstance(flo_config, FloRoutedTeamConfig): team_config: TeamConfig = flo_config.team team = parse_and_build_subteams(session, team_config, name_set) @@ -41,7 +43,7 @@ def parse_and_build_subteams( members = [AgentFactory.create(session, agent) for agent in team_config.agents] flo_team = FloTeam.Builder(session, team_config.name, members=members).build() router = FloRouterFactory.create(session, team_config, flo_team) - flo_routed_team = router.to_flo() + flo_routed_team = router.build_routed_team() else: flo_teams = [] for subteam in team_config.subteams: @@ -49,7 +51,7 @@ def parse_and_build_subteams( flo_teams.append(flo_subteam) flo_team = FloTeam.Builder(session, team_config.name, members=flo_teams).build() router = FloRouterFactory.create(session, team_config, flo_team) - flo_routed_team = router.to_flo() + flo_routed_team = router.build_routed_team() return flo_routed_team diff --git a/flo_ai/core.py b/flo_ai/core.py index 19b2e62..c817605 100644 --- a/flo_ai/core.py +++ b/flo_ai/core.py @@ -2,9 +2,11 @@ import warnings import logging from typing import Optional +from langchain_core.runnables import Runnable from flo_ai.yaml.config import to_supervised_team -from flo_ai.builders.yaml_builder import build_supervised_team, FloRoutedTeamConfig +from flo_ai.builders.yaml_builder import build_supervised_team from typing import Any, Iterator, Union +from flo_ai.router.flo_router import FloRouter from flo_ai.state.flo_session import FloSession from flo_ai.models.flo_executable import ExecutableFlo from flo_ai.error.flo_exception import FloException @@ -20,11 +22,9 @@ class Flo: - def __init__(self, session: FloSession, config: FloRoutedTeamConfig) -> None: + def __init__(self, session: FloSession, executable: Runnable) -> None: self.session = session - self.config = config - session.config = config - self.runnable: ExecutableFlo = build_supervised_team(session) + self.runnable: ExecutableFlo = executable self.langchain_logger = session.langchain_logger get_logger().info('Flo instance created ...', session) @@ -50,7 +50,12 @@ def async_invoke(self, query, config=None) -> Iterator[Union[dict[str, Any], Any return self.runnable.ainvoke(query, config) @staticmethod - def build(session: FloSession, yaml: str, log_level: Optional[str] = None): + def build( + session: FloSession, + yaml: Optional[str] = None, + routed_team: Optional[FloRouter] = None, + log_level: Optional[str] = None, + ): if log_level: warnings.warn( '`log_level` is deprecated and will be removed in a future version. ' @@ -59,8 +64,19 @@ def build(session: FloSession, yaml: str, log_level: Optional[str] = None): stacklevel=2, ) Flo.set_log_level(log_level) - get_logger().info('Building Flo instance from YAML ...', session) - return Flo(session, to_supervised_team(yaml)) + if yaml is not None: + get_logger().info('Building Flo instance from YAML ...', session) + executable: ExecutableFlo = build_supervised_team( + session, to_supervised_team(yaml) + ) + return Flo(session, executable) + if routed_team is not None: + return Flo(session, routed_team.build_routed_team()) + raise FloException("""Either yaml or routed_team should be not None""") + + @staticmethod + def create(session: FloSession, routed_team: FloRouter): + return Flo(session, routed_team.build_routed_team()) @staticmethod def set_log_level(log_level: str): diff --git a/flo_ai/models/flo_agent.py b/flo_ai/models/flo_agent.py index b098823..89ddc77 100644 --- a/flo_ai/models/flo_agent.py +++ b/flo_ai/models/flo_agent.py @@ -23,6 +23,28 @@ def __init__( self.agent: Runnable = (agent,) self.executor: AgentExecutor = executor + @staticmethod + def create( + session: FloSession, + name: str, + job: str, + tools: list[BaseTool], + role: Optional[str] = None, + on_error: Union[str, Callable] = True, + llm: Union[BaseLanguageModel, None] = None, + ): + model_name = 'default' if llm is None else llm.name + return FloAgent.Builder( + session=session, + name=name, + job=job, + tools=tools, + role=role, + on_error=on_error, + llm=llm, + model_name=model_name, + ).build() + class Builder: def __init__( self, @@ -31,7 +53,7 @@ def __init__( job: str, tools: list[BaseTool], role: Optional[str] = None, - verbose: bool = True, + verbose: bool = False, llm: Union[BaseLanguageModel, None] = None, on_error: Union[str, Callable] = True, model_name: Union[str, None] = 'default', diff --git a/flo_ai/models/flo_delegation_agent.py b/flo_ai/models/flo_delegation_agent.py index 93294bd..57abe31 100644 --- a/flo_ai/models/flo_delegation_agent.py +++ b/flo_ai/models/flo_delegation_agent.py @@ -28,6 +28,24 @@ def __init__( self.executor = executor self.model_name = model_name + @staticmethod + def create( + session: FloSession, + name: str, + job: str, + to: Delegate, + llm: Optional[BaseLanguageModel] = None, + ): + model_name = 'default' if llm is None else llm.name + return FloDelegatorAgent.Builder( + session=session, + name=name, + job=job, + delegate=to, + llm=llm, + model_name=model_name, + ).build() + class Builder: def __init__( self, diff --git a/flo_ai/models/flo_llm_agent.py b/flo_ai/models/flo_llm_agent.py index 125133b..1b79901 100644 --- a/flo_ai/models/flo_llm_agent.py +++ b/flo_ai/models/flo_llm_agent.py @@ -14,6 +14,24 @@ def __init__(self, name: str, executor: Runnable, model_name: str) -> None: self.executor: Runnable = executor self.model_name: str = model_name + @staticmethod + def create( + session: FloSession, + name: str, + job: str, + role: Optional[str] = None, + llm: Union[BaseLanguageModel, None] = None, + ): + model_name = 'default' if llm is None else llm.name + return FloLLMAgent.Builder( + session=session, + name=name, + job=job, + role=role, + llm=llm, + model_name=model_name, + ).build() + class Builder: def __init__( self, diff --git a/flo_ai/models/flo_rag.py b/flo_ai/models/flo_rag.py deleted file mode 100644 index 3c3468f..0000000 --- a/flo_ai/models/flo_rag.py +++ /dev/null @@ -1,76 +0,0 @@ -from typing import Optional -from langchain_core.language_models import BaseLanguageModel -from langchain.tools import Tool -from langgraph.graph import END, StateGraph -from langgraph.graph.graph import CompiledGraph -from langgraph.prebuilt import ToolNode -from flo_ai.state.flo_state import TeamFloAgentState -from langgraph.prebuilt import tools_condition -from flo_ai.models.flo_executable import ExecutableFlo -from langchain import hub -from langchain.prompts import ChatPromptTemplate - - -class FloRag(ExecutableFlo): - def __init__(self, name: str, graph: CompiledGraph) -> None: - super().__init__(name, 'team') - self.graph = graph - - def draw(self, xray=True): - return self.graph.get_graph(xray=xray).draw_mermaid_png() - - -class FloRagBuilder: - def __init__( - self, - name: str, - tools: list[Tool], - llm: BaseLanguageModel, - prompt: Optional[ChatPromptTemplate] = None, - ) -> None: - self.name = name - self.llm = llm - self.tools = tools - self.prompt = hub.pull('rlm/rag-prompt') if prompt is None else prompt - - def retriever_agent(self, state: TeamFloAgentState): - messages = state['messages'] - model = self.llm.bind_tools(self.tools) - response = model.invoke(messages) - # We return a list, because this will get added to the existing list - return {'messages': [response]} - - def generate(self, state: TeamFloAgentState): - messages = state['messages'] - question = messages[0].content - last_message = messages[-1] - - question = messages[0].content - docs = last_message.content - - rag_chain = self.prompt | self.llm - response = rag_chain.invoke({'context': docs, 'question': question}) - return {'messages': [response]} - - def build(self) -> FloRag: - retrieve = ToolNode(self.tools) - - workflow = StateGraph(TeamFloAgentState) - workflow.add_node('agent', self.retriever_agent) - workflow.add_node('retrieve', retrieve) # retrieval - workflow.add_node('generate', self.generate) - workflow.add_conditional_edges( - 'agent', - tools_condition, - { - 'tools': 'retrieve', - END: END, - }, - ) - - workflow.add_edge('retrieve', 'generate') - workflow.add_edge('generate', END) - - workflow.set_entry_point('agent') - graph = workflow.compile() - return FloRag(self.name, graph=graph) diff --git a/flo_ai/models/flo_reflection_agent.py b/flo_ai/models/flo_reflection_agent.py index 4da9e52..f49293b 100644 --- a/flo_ai/models/flo_reflection_agent.py +++ b/flo_ai/models/flo_reflection_agent.py @@ -17,6 +17,26 @@ def __init__( self.model_name = model_name self.delegate = delegate + @staticmethod + def create( + session: FloSession, + name: str, + job: str, + to: Delegate, + role: Optional[str] = None, + llm: Optional[BaseLanguageModel] = None, + ): + model_name = 'default' if llm is None else llm.name + return FloReflectionAgent.Builder( + session=session, + name=name, + job=job, + to=to, + role=role, + llm=llm, + model_name=model_name, + ).build() + class Builder: def __init__( self, diff --git a/flo_ai/models/flo_team.py b/flo_ai/models/flo_team.py index 781c3c6..66fd926 100644 --- a/flo_ai/models/flo_team.py +++ b/flo_ai/models/flo_team.py @@ -10,13 +10,21 @@ def __init__( self.members = members self.session = session + @staticmethod + def create(session: FloSession, name: str, members: list[FloMember]): + return FloTeam.Builder(session=session, name=name, members=members).build() + class Builder: def __init__( self, session: FloSession, name: str, members: list[FloMember] ) -> None: + from flo_ai import Flo + self.name = name self.session = session - self.members = members + self.members = list( + map(lambda x: x.runnable if isinstance(x, Flo) else x, members) + ) self.member_names = list(map(lambda x: x.name, self.members)) def build(self): diff --git a/flo_ai/models/flo_tool_agent.py b/flo_ai/models/flo_tool_agent.py index e95ef20..6610e38 100644 --- a/flo_ai/models/flo_tool_agent.py +++ b/flo_ai/models/flo_tool_agent.py @@ -10,6 +10,20 @@ def __init__(self, name: str, executor: Runnable, model_name: str) -> None: self.executor: Runnable = executor self.model_name: str = model_name + @staticmethod + def create( + session: FloSession, + name: str, + tool_runnable: Runnable, + ): + model_name = 'default' + return FloToolAgent.Builder( + session=session, + name=name, + tool_runnable=tool_runnable, + model_name=model_name, + ).build() + class Builder: def __init__( self, diff --git a/flo_ai/router/flo_linear.py b/flo_ai/router/flo_linear.py index 492a24e..6d5f8b8 100644 --- a/flo_ai/router/flo_linear.py +++ b/flo_ai/router/flo_linear.py @@ -56,6 +56,10 @@ def build_graph(self): return FloRoutedTeam(self.flo_team.name, workflow_graph) + @staticmethod + def create(session: FloSession, name: str, team: FloTeam): + return FloLinear.Builder(session=session, name=name, flo_team=team).build() + class Builder: def __init__(self, session: FloSession, name: str, flo_team: FloTeam) -> None: self.name = name diff --git a/flo_ai/router/flo_llm_router.py b/flo_ai/router/flo_llm_router.py index 40536e1..e5bc0ed 100644 --- a/flo_ai/router/flo_llm_router.py +++ b/flo_ai/router/flo_llm_router.py @@ -48,13 +48,29 @@ def build_graph(self): workflow_graph = workflow.compile() return FloRoutedTeam(self.flo_team.name, workflow_graph) + @staticmethod + def create( + session: FloSession, + name: str, + team: FloTeam, + router_prompt: str = None, + llm: Union[BaseLanguageModel, None] = None, + ): + return FloLLMRouter.Builder( + session=session, + name=name, + flo_team=team, + router_prompt=router_prompt, + llm=llm, + ).build() + class Builder: def __init__( self, session: FloSession, name: str, flo_team: FloTeam, - router_prompt: ChatPromptTemplate = None, + router_prompt: str = None, llm: Union[BaseLanguageModel, None] = None, ) -> None: self.name = name diff --git a/flo_ai/router/flo_router.py b/flo_ai/router/flo_router.py index b9d34bc..1dc74e3 100644 --- a/flo_ai/router/flo_router.py +++ b/flo_ai/router/flo_router.py @@ -38,7 +38,7 @@ def __init__( self.executor = executor self.model_name = model_name - def to_flo(self) -> FloRoutedTeam: + def build_routed_team(self) -> FloRoutedTeam: return self.build_graph() @abstractmethod diff --git a/flo_ai/router/flo_supervisor.py b/flo_ai/router/flo_supervisor.py index 31f957c..96a5628 100644 --- a/flo_ai/router/flo_supervisor.py +++ b/flo_ai/router/flo_supervisor.py @@ -35,6 +35,22 @@ def __init__( model_name=model_name, ) + @staticmethod + def create( + session: FloSession, + name: str, + team: FloTeam, + llm: Union[BaseLanguageModel, None] = None, + ): + model_name = 'default' if llm is None else llm.name + return FloSupervisor.Builder( + session=session, + name=name, + flo_team=team, + llm=llm, + model_nick_name=model_name, + ).build() + class Builder: def __init__( self, diff --git a/flo_ai/state/flo_session.py b/flo_ai/state/flo_session.py index ed1b8b1..1985275 100644 --- a/flo_ai/state/flo_session.py +++ b/flo_ai/state/flo_session.py @@ -4,7 +4,6 @@ from langchain_core.tools import BaseTool from flo_ai.common.flo_logger import get_logger from flo_ai.common.flo_langchain_logger import FloLangchainLogger -from flo_ai.yaml.config import FloRoutedTeamConfig, FloAgentConfig from flo_ai.helpers.utils import random_str from flo_ai.state.flo_callbacks import ( FloToolCallback, @@ -54,7 +53,6 @@ def __init__( self.on_agent_error = on_agent_error self.langchain_logger = FloLangchainLogger(self.session_id) self.callbacks: list = [] - self.config: Union[FloRoutedTeamConfig, FloAgentConfig] = None get_logger().info('New session created ...', self) def resolve_llm(