From ccac13615f8e7b165e409a07c82482ab49caef8e Mon Sep 17 00:00:00 2001 From: TuanaCelik Date: Wed, 3 Sep 2025 14:34:45 +0200 Subject: [PATCH] updated scripts and POC html --- .tmp/agent/Chatbot_SEC.md | 333 ++++++ .tmp/agent/agent_builder.md | 271 +++++ .tmp/agent/agent_workflow_basic.md | 351 ++++++ .tmp/agent/agent_workflow_multi.md | 300 +++++ .../agent_workflow_research_assistant.md | 5 +- .tmp/agent/agents_as_tools.md | 467 ++++++++ .tmp/agent/anthropic_agent.md | 213 ++++ .tmp/agent/bedrock_converse_agent.md | 157 +++ .tmp/agent/code_act_agent.md | 369 ++++++ .tmp/agent/custom_multi_agent.md | 3 +- .tmp/agent/from_scratch_code_act_agent.md | 505 ++++++++ .tmp/agent/memory/chat_memory_buffer.md | 99 ++ .tmp/agent/memory/composable_memory.md | 512 +++++++++ .tmp/agent/memory/summary_memory_buffer.md | 110 ++ .tmp/agent/memory/vector_memory.md | 100 ++ .tmp/agent/mistral_agent.md | 186 +++ ...agent_workflow_with_weaviate_queryagent.md | 706 ++++++++++++ .tmp/agent/multi_document_agents-v1.md | 591 ++++++++++ .tmp/agent/nvidia_agent.md | 224 ++++ ...nt_research_assistant_for_blog_creation.md | 1011 +++++++++++++++++ .../agent/nvidia_sub_question_query_engine.md | 297 +++++ .tmp/agent/openai_agent_context_retrieval.md | 295 +++++ .tmp/agent/openai_agent_lengthy_tools.md | 401 +++++++ .tmp/agent/openai_agent_query_cookbook.md | 783 +++++++++++++ .tmp/agent/openai_agent_retrieval.md | 170 +++ .tmp/agent/openai_agent_with_query_engine.md | 158 +++ .tmp/agent/react_agent.md | 282 +++++ .tmp/agent/react_agent_with_query_engine.md | 215 ++++ .tmp/agent/return_direct_agent.md | 250 ++++ README.md | 43 +- index.toml | 204 +++- markdowns/Agent/Chatbot_SEC.md | 333 ++++++ markdowns/Agent/Memory/chat_memory_buffer.md | 99 ++ markdowns/Agent/Memory/composable_memory.md | 512 +++++++++ .../Agent/Memory/summary_memory_buffer.md | 110 ++ markdowns/Agent/Memory/vector_memory.md | 100 ++ markdowns/Agent/agent_builder.md | 271 +++++ markdowns/Agent/agent_workflow_basic.md | 351 ++++++ markdowns/Agent/agent_workflow_multi.md | 300 +++++ .../agent_workflow_research_assistant.md | 5 +- markdowns/Agent/agents_as_tools.md | 467 ++++++++ markdowns/Agent/anthropic_agent.md | 213 ++++ markdowns/Agent/bedrock_converse_agent.md | 157 +++ markdowns/Agent/code_act_agent.md | 369 ++++++ markdowns/Agent/custom_multi_agent.md | 3 +- .../Agent/from_scratch_code_act_agent.md | 505 ++++++++ markdowns/Agent/mistral_agent.md | 186 +++ ...agent_workflow_with_weaviate_queryagent.md | 706 ++++++++++++ markdowns/Agent/multi_document_agents-v1.md | 591 ++++++++++ markdowns/Agent/nvidia_agent.md | 224 ++++ ...nt_research_assistant_for_blog_creation.md | 1011 +++++++++++++++++ .../Agent/nvidia_sub_question_query_engine.md | 297 +++++ .../Agent/openai_agent_context_retrieval.md | 295 +++++ markdowns/Agent/openai_agent_lengthy_tools.md | 401 +++++++ .../Agent/openai_agent_query_cookbook.md | 783 +++++++++++++ markdowns/Agent/openai_agent_retrieval.md | 170 +++ .../Agent/openai_agent_with_query_engine.md | 158 +++ markdowns/Agent/react_agent.md | 282 +++++ .../Agent/react_agent_with_query_engine.md | 215 ++++ markdowns/Agent/return_direct_agent.md | 250 ++++ my_cookbooks.html | 529 +++++++++ scripts/cookbook_page_generator.py | 644 +++++++++++ scripts/notebooks_to_markdown.py | 32 +- 63 files changed, 20156 insertions(+), 24 deletions(-) create mode 100644 .tmp/agent/Chatbot_SEC.md create mode 100644 .tmp/agent/agent_builder.md create mode 100644 .tmp/agent/agent_workflow_basic.md create mode 100644 .tmp/agent/agent_workflow_multi.md create mode 100644 .tmp/agent/agents_as_tools.md create mode 100644 .tmp/agent/anthropic_agent.md create mode 100644 .tmp/agent/bedrock_converse_agent.md create mode 100644 .tmp/agent/code_act_agent.md create mode 100644 .tmp/agent/from_scratch_code_act_agent.md create mode 100644 .tmp/agent/memory/chat_memory_buffer.md create mode 100644 .tmp/agent/memory/composable_memory.md create mode 100644 .tmp/agent/memory/summary_memory_buffer.md create mode 100644 .tmp/agent/memory/vector_memory.md create mode 100644 .tmp/agent/mistral_agent.md create mode 100644 .tmp/agent/multi_agent_workflow_with_weaviate_queryagent.md create mode 100644 .tmp/agent/multi_document_agents-v1.md create mode 100644 .tmp/agent/nvidia_agent.md create mode 100644 .tmp/agent/nvidia_document_research_assistant_for_blog_creation.md create mode 100644 .tmp/agent/nvidia_sub_question_query_engine.md create mode 100644 .tmp/agent/openai_agent_context_retrieval.md create mode 100644 .tmp/agent/openai_agent_lengthy_tools.md create mode 100644 .tmp/agent/openai_agent_query_cookbook.md create mode 100644 .tmp/agent/openai_agent_retrieval.md create mode 100644 .tmp/agent/openai_agent_with_query_engine.md create mode 100644 .tmp/agent/react_agent.md create mode 100644 .tmp/agent/react_agent_with_query_engine.md create mode 100644 .tmp/agent/return_direct_agent.md create mode 100644 markdowns/Agent/Chatbot_SEC.md create mode 100644 markdowns/Agent/Memory/chat_memory_buffer.md create mode 100644 markdowns/Agent/Memory/composable_memory.md create mode 100644 markdowns/Agent/Memory/summary_memory_buffer.md create mode 100644 markdowns/Agent/Memory/vector_memory.md create mode 100644 markdowns/Agent/agent_builder.md create mode 100644 markdowns/Agent/agent_workflow_basic.md create mode 100644 markdowns/Agent/agent_workflow_multi.md create mode 100644 markdowns/Agent/agents_as_tools.md create mode 100644 markdowns/Agent/anthropic_agent.md create mode 100644 markdowns/Agent/bedrock_converse_agent.md create mode 100644 markdowns/Agent/code_act_agent.md create mode 100644 markdowns/Agent/from_scratch_code_act_agent.md create mode 100644 markdowns/Agent/mistral_agent.md create mode 100644 markdowns/Agent/multi_agent_workflow_with_weaviate_queryagent.md create mode 100644 markdowns/Agent/multi_document_agents-v1.md create mode 100644 markdowns/Agent/nvidia_agent.md create mode 100644 markdowns/Agent/nvidia_document_research_assistant_for_blog_creation.md create mode 100644 markdowns/Agent/nvidia_sub_question_query_engine.md create mode 100644 markdowns/Agent/openai_agent_context_retrieval.md create mode 100644 markdowns/Agent/openai_agent_lengthy_tools.md create mode 100644 markdowns/Agent/openai_agent_query_cookbook.md create mode 100644 markdowns/Agent/openai_agent_retrieval.md create mode 100644 markdowns/Agent/openai_agent_with_query_engine.md create mode 100644 markdowns/Agent/react_agent.md create mode 100644 markdowns/Agent/react_agent_with_query_engine.md create mode 100644 markdowns/Agent/return_direct_agent.md create mode 100644 my_cookbooks.html create mode 100644 scripts/cookbook_page_generator.py diff --git a/.tmp/agent/Chatbot_SEC.md b/.tmp/agent/Chatbot_SEC.md new file mode 100644 index 0000000..f3dddc2 --- /dev/null +++ b/.tmp/agent/Chatbot_SEC.md @@ -0,0 +1,333 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/Chatbot_SEC.ipynb +toc: True +title: "How to Build a Chatbot" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +LlamaIndex serves as a bridge between your data and Language Learning Models (LLMs), providing a toolkit that enables you to establish a query interface around your data for a variety of tasks, such as question-answering and summarization. + +In this tutorial, we'll walk you through building a context-augmented chatbot using a [Data Agent](https://gpt-index.readthedocs.io/en/stable/core_modules/agent_modules/agents/root.html). This agent, powered by LLMs, is capable of intelligently executing tasks over your data. The end result is a chatbot agent equipped with a robust set of data interface tools provided by LlamaIndex to answer queries about your data. + +**Note**: This tutorial builds upon initial work on creating a query interface over SEC 10-K filings - [check it out here](https://medium.com/@jerryjliu98/how-unstructured-and-llamaindex-can-help-bring-the-power-of-llms-to-your-own-data-3657d063e30d). + +### Context + +In this guide, we’ll build a "10-K Chatbot" that uses raw UBER 10-K HTML filings from Dropbox. Users can interact with the chatbot to ask questions related to the 10-K filings. + +### Preparation + + +```python +%pip install llama-index-readers-file +%pip install llama-index-embeddings-openai +%pip install llama-index-agent-openai +%pip install llama-index-llms-openai +%pip install llama-index-question-gen-openai +%pip install unstructured +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.core import Settings +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding + +# global defaults +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model_name="text-embedding-3-large") +Settings.chunk_size = 512 +Settings.chunk_overlap = 64 +``` + +### Ingest Data + +Let's first download the raw 10-k files, from 2019-2022. + + +```python +# NOTE: the code examples assume you're operating within a Jupyter notebook. +# download files +!mkdir data +!wget "https://www.dropbox.com/s/948jr9cfs7fgj99/UBER.zip?dl=1" -O data/UBER.zip +!unzip data/UBER.zip -d data +``` + +To parse the HTML files into formatted text, we use the [Unstructured](https://github.com/Unstructured-IO/unstructured) library. Thanks to [LlamaHub](https://llamahub.ai/), we can directly integrate with Unstructured, allowing conversion of any text into a Document format that LlamaIndex can ingest. + +First we install the necessary packages: + +Then we can use the `UnstructuredReader` to parse the HTML files into a list of `Document` objects. + + +```python +from llama_index.readers.file import UnstructuredReader +from pathlib import Path + +years = [2022, 2021, 2020, 2019] +``` + + +```python +loader = UnstructuredReader() +doc_set = {} +all_docs = [] +for year in years: + year_docs = loader.load_data( + file=Path(f"./data/UBER/UBER_{year}.html"), split_documents=False + ) + # insert year metadata into each year + for d in year_docs: + d.metadata = {"year": year} + doc_set[year] = year_docs + all_docs.extend(year_docs) +``` + +### Setting up Vector Indices for each year + +We first setup a vector index for each year. Each vector index allows us +to ask questions about the 10-K filing of a given year. + +We build each index and save it to disk. + + +```python +# initialize simple vector indices +# NOTE: don't run this cell if the indices are already loaded! +from llama_index.core import VectorStoreIndex, StorageContext + + +index_set = {} +for year in years: + storage_context = StorageContext.from_defaults() + cur_index = VectorStoreIndex.from_documents( + doc_set[year], + storage_context=storage_context, + ) + index_set[year] = cur_index + storage_context.persist(persist_dir=f"./storage/{year}") +``` + +To load an index from disk, do the following + + +```python +# Load indices from disk +from llama_index.core import StorageContext, load_index_from_storage + +index_set = {} +for year in years: + storage_context = StorageContext.from_defaults( + persist_dir=f"./storage/{year}" + ) + cur_index = load_index_from_storage( + storage_context, + ) + index_set[year] = cur_index +``` + +### Setting up a Sub Question Query Engine to Synthesize Answers Across 10-K Filings + +Since we have access to documents of 4 years, we may not only want to ask questions regarding the 10-K document of a given year, but ask questions that require analysis over all 10-K filings. + +To address this, we can use a [Sub Question Query Engine](https://gpt-index.readthedocs.io/en/stable/examples/query_engine/sub_question_query_engine.html). It decomposes a query into subqueries, each answered by an individual vector index, and synthesizes the results to answer the overall query. + +LlamaIndex provides some wrappers around indices (and query engines) so that they can be used by query engines and agents. First we define a `QueryEngineTool` for each vector index. +Each tool has a name and a description; these are what the LLM agent sees to decide which tool to choose. + + +```python +from llama_index.core.tools import QueryEngineTool + +individual_query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=index_set[year].as_query_engine(), + name=f"vector_index_{year}", + description=( + "useful for when you want to answer queries about the" + f" {year} SEC 10-K for Uber" + ), + ) + for year in years +] +``` + +Now we can create the Sub Question Query Engine, which will allow us to synthesize answers across the 10-K filings. We pass in the `individual_query_engine_tools` we defined above. + + +```python +from llama_index.core.query_engine import SubQuestionQueryEngine + +query_engine = SubQuestionQueryEngine.from_defaults( + query_engine_tools=individual_query_engine_tools, +) +``` + +### Setting up the Chatbot Agent + +We use a LlamaIndex Data Agent to setup the outer chatbot agent, which has access to a set of Tools. Specifically, we will use an OpenAIAgent, that takes advantage of OpenAI API function calling. We want to use the separate Tools we defined previously for each index (corresponding to a given year), as well as a tool for the sub question query engine we defined above. + +First we define a `QueryEngineTool` for the sub question query engine: + + +```python +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=query_engine, + name="sub_question_query_engine", + description=( + "useful for when you want to answer queries that require analyzing" + " multiple SEC 10-K documents for Uber" + ), +) +``` + +Then, we combine the Tools we defined above into a single list of tools for the agent: + + +```python +tools = individual_query_engine_tools + [query_engine_tool] +``` + +Finally, we call `FunctionAgent` to create the agent, passing in the list of tools we defined above. + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent(tools=tools, llm=OpenAI(model="gpt-4o")) +``` + +### Testing the Agent + +We can now test the agent with various queries. + +If we test it with a simple "hello" query, the agent does not use any Tools. + + +```python +from llama_index.core.workflow import Context + +# Setup the context for this specific interaction +ctx = Context(agent) + +response = await agent.run("hi, i am bob", ctx=ctx) +print(str(response)) +``` + + Hello Bob! How can I assist you today? + + +If we test it with a query regarding the 10-k of a given year, the agent will use +the relevant vector index Tool. + + +```python +response = await agent.run( + "What were some of the biggest risk factors in 2020 for Uber?", ctx=ctx +) +print(str(response)) +``` + + In 2020, some of the biggest risk factors for Uber included: + + 1. **Legal and Regulatory Risks**: Extensive government regulation and oversight could adversely impact operations and future prospects. + 2. **Data Privacy and Security Risks**: Risks related to data collection, use, and processing could lead to investigations, litigation, and negative publicity. + 3. **Economic Impact of COVID-19**: The pandemic adversely affected business operations, demand for services, and financial condition due to governmental restrictions and changes in consumer behavior. + 4. **Market Volatility**: Volatility in the market price of common stock could affect investors' ability to resell shares at favorable prices. + 5. **Safety Incidents**: Criminal or dangerous activities on the platform could harm the ability to attract and retain drivers and consumers. + 6. **Investment Risks**: Substantial investments in new technologies and offerings carry inherent risks, with no guarantee of realizing expected benefits. + 7. **Dependence on Metropolitan Areas**: A significant portion of gross bookings comes from large metropolitan areas, which may be negatively impacted by various external factors. + 8. **Talent Retention**: Attracting and retaining high-quality personnel is crucial, and issues with attrition or succession planning could adversely affect the business. + 9. **Cybersecurity Threats**: Cyberattacks and data breaches could harm reputation and operational results. + 10. **Capital Requirements**: The need for additional capital to support growth may not be met on reasonable terms, impacting business expansion. + 11. **Acquisition Challenges**: Difficulty in identifying and integrating suitable businesses could harm operating results and future prospects. + 12. **Operational Limitations**: Potential restrictions in certain jurisdictions may require modifications to the business model, affecting service delivery. + + +Finally, if we test it with a query to compare/contrast risk factors across years, the agent will use the Sub Question Query Engine Tool. + + +```python +cross_query_str = ( + "Compare/contrast the risk factors described in the Uber 10-K across" + " years. Give answer in bullet points." +) + +response = await agent.run(cross_query_str, ctx=ctx) +print(str(response)) +``` + + Here's a comparison of the risk factors for Uber across the years 2020, 2021, and 2022: + + - **COVID-19 Impact**: + - **2020**: The pandemic significantly affected business operations, demand, and financial condition. + - **2021**: Continued impact of the pandemic was a concern, affecting various parts of the business. + - **2022**: The pandemic's impact was less emphasized, with more focus on operational and competitive risks. + + - **Driver Classification**: + - **2020**: Not specifically highlighted. + - **2021**: Potential reclassification of Drivers as employees could alter the business model. + - **2022**: Continued risk of reclassification impacting operational costs. + + - **Competition**: + - **2020**: Not specifically highlighted. + - **2021**: Intense competition with low barriers to entry and well-capitalized competitors. + - **2022**: Competitive landscape challenges due to established alternatives and low barriers to entry. + + - **Financial Concerns**: + - **2020**: Market volatility and capital requirements were major concerns. + - **2021**: Historical losses and increased operating expenses raised profitability concerns. + - **2022**: Significant losses and rising expenses continued to raise profitability concerns. + + - **User and Personnel Retention**: + - **2020**: Talent retention was crucial, with risks from attrition. + - **2021**: Attracting and retaining a critical mass of users and personnel was essential. + - **2022**: Continued emphasis on retaining Drivers, consumers, and high-quality personnel. + + - **Brand and Reputation**: + - **2020**: Safety incidents and cybersecurity threats could harm reputation. + - **2021**: Maintaining and enhancing brand reputation was critical, with past negative publicity being a concern. + - **2022**: Brand and reputation were under scrutiny, with negative media coverage potentially harming prospects. + + - **Operational Challenges**: + - **2020**: Operational limitations and acquisition challenges were highlighted. + - **2021**: Challenges in managing growth and optimizing organizational structure. + - **2022**: Historical workplace culture and the need for organizational optimization were critical. + + - **Safety and Liability**: + - **2020**: Safety incidents and liability claims were significant risks. + - **2021**: Safety incidents and liability claims, especially with vulnerable road users, were concerns. + - **2022**: Safety incidents and public reporting could impact reputation and financial results. + + Overall, while some risk factors remained consistent across the years, such as competition, financial concerns, and safety, the emphasis shifted slightly with the evolving business environment and external factors like the pandemic. + + +### Setting up the Chatbot Loop + +Now that we have the chatbot setup, it only takes a few more steps to setup a basic interactive loop to chat with our SEC-augmented chatbot! + + +```python +agent = FunctionAgent(tools=tools, llm=OpenAI(model="gpt-4o")) +ctx = Context(agent) + +while True: + text_input = input("User: ") + if text_input == "exit": + break + response = await agent.run(text_input, ctx=ctx) + print(f"Agent: {response}") + +# User: What were some of the legal proceedings against Uber in 2022? +``` diff --git a/.tmp/agent/agent_builder.md b/.tmp/agent/agent_builder.md new file mode 100644 index 0000000..2648692 --- /dev/null +++ b/.tmp/agent/agent_builder.md @@ -0,0 +1,271 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_builder.ipynb +toc: True +title: "GPT Builder Demo" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +Open In Colab + +Inspired by GPTs interface, presented at OpenAI Dev Day 2023. Construct an agent with natural language. + +Here you can build your own agent...with another agent! + + +```python +%pip install llama-index-embeddings-openai +%pip install llama-index-llms-openai +%pip install llama-index-readers-file +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.llms.openai import OpenAI +from llama_index.core import Settings + +llm = OpenAI(model="gpt-4o") +Settings.llm = llm +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + +## Define Candidate Tools + +We also define a tool retriever to retrieve candidate tools. + +In this setting we define tools as different Wikipedia pages. + + +```python +from llama_index.core import SimpleDirectoryReader +``` + + +```python +wiki_titles = ["Toronto", "Seattle", "Chicago", "Boston", "Houston"] +``` + + +```python +from pathlib import Path + +import requests + +for title in wiki_titles: + response = requests.get( + "https://en.wikipedia.org/w/api.php", + params={ + "action": "query", + "format": "json", + "titles": title, + "prop": "extracts", + # 'exintro': True, + "explaintext": True, + }, + ).json() + page = next(iter(response["query"]["pages"].values())) + wiki_text = page["extract"] + + data_path = Path("data") + if not data_path.exists(): + Path.mkdir(data_path) + + with open(data_path / f"{title}.txt", "w") as fp: + fp.write(wiki_text) +``` + + +```python +# Load all wiki documents +city_docs = {} +for wiki_title in wiki_titles: + city_docs[wiki_title] = SimpleDirectoryReader( + input_files=[f"data/{wiki_title}.txt"] + ).load_data() +``` + +### Build Query Tool for Each Document + + +```python +from llama_index.core import VectorStoreIndex +from llama_index.core.tools import QueryEngineTool +from llama_index.core import VectorStoreIndex + +# Build tool dictionary +tool_dict = {} + +for wiki_title in wiki_titles: + # build vector index + vector_index = VectorStoreIndex.from_documents( + city_docs[wiki_title], + ) + # define query engines + vector_query_engine = vector_index.as_query_engine(llm=llm) + + # define tools + vector_tool = QueryEngineTool.from_defaults( + query_engine=vector_query_engine, + name=wiki_title, + description=("Useful for questions related to" f" {wiki_title}"), + ) + tool_dict[wiki_title] = vector_tool +``` + +### Define Tool Retriever + + +```python +# define an "object" index and retriever over these tools +from llama_index.core import VectorStoreIndex +from llama_index.core.objects import ObjectIndex + +tool_index = ObjectIndex.from_objects( + list(tool_dict.values()), + index_cls=VectorStoreIndex, +) +tool_retriever = tool_index.as_retriever(similarity_top_k=1) +``` + +### Load Data + +Here we load wikipedia pages from different cities. + +## Define Meta-Tools for GPT Builder + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.core.llms import ChatMessage +from llama_index.core import ChatPromptTemplate +from typing import List + +GEN_SYS_PROMPT_STR = """\ +Task information is given below. + +Given the task, please generate a system prompt for an OpenAI-powered bot to solve this task: +{task} \ +""" + +gen_sys_prompt_messages = [ + ChatMessage( + role="system", + content="You are helping to build a system prompt for another bot.", + ), + ChatMessage(role="user", content=GEN_SYS_PROMPT_STR), +] + +GEN_SYS_PROMPT_TMPL = ChatPromptTemplate(gen_sys_prompt_messages) + + +agent_cache = {} + + +async def create_system_prompt(task: str): + """Create system prompt for another agent given an input task.""" + llm = OpenAI(llm="gpt-4") + fmt_messages = GEN_SYS_PROMPT_TMPL.format_messages(task=task) + response = await llm.achat(fmt_messages) + return response.message.content + + +async def get_tools(task: str): + """Get the set of relevant tools to use given an input task.""" + subset_tools = await tool_retriever.aretrieve(task) + return [t.metadata.name for t in subset_tools] + + +def create_agent(system_prompt: str, tool_names: List[str]): + """Create an agent given a system prompt and an input set of tools.""" + llm = OpenAI(model="gpt-4o") + try: + # get the list of tools + input_tools = [tool_dict[tn] for tn in tool_names] + + agent = FunctionAgent( + tools=input_tools, llm=llm, system_prompt=system_prompt + ) + agent_cache["agent"] = agent + return_msg = "Agent created successfully." + except Exception as e: + return_msg = f"An error occurred when building an agent. Here is the error: {repr(e)}" + return return_msg +``` + + +```python +from llama_index.core.tools import FunctionTool + +system_prompt_tool = FunctionTool.from_defaults(fn=create_system_prompt) +get_tools_tool = FunctionTool.from_defaults(fn=get_tools) +create_agent_tool = FunctionTool.from_defaults(fn=create_agent) +``` + + +```python +GPT_BUILDER_SYS_STR = """\ +You are helping to construct an agent given a user-specified task. You should generally use the tools in this order to build the agent. + +1) Create system prompt tool: to create the system prompt for the agent. +2) Get tools tool: to fetch the candidate set of tools to use. +3) Create agent tool: to create the final agent. +""" + +prefix_msgs = [ChatMessage(role="system", content=GPT_BUILDER_SYS_STR)] + + +builder_agent = FunctionAgent( + tools=[system_prompt_tool, get_tools_tool, create_agent_tool], + prefix_messages=prefix_msgs, + llm=OpenAI(model="gpt-4o"), + verbose=True, +) +``` + + +```python +from llama_index.core.agent.workflow import ToolCallResult + +handler = builder_agent.run("Build an agent that can tell me about Toronto.") +async for event in handler.stream_events(): + if isinstance(event, ToolCallResult): + print( + f"Called tool {event.tool_name} with input {event.tool_kwargs}\nGot output: {event.tool_output}" + ) + +result = await handler +print(f"Result: {result}") +``` + + Called tool create_system_prompt with input {'task': 'Tell me about Toronto'} + Got output: "Generate a brief summary about Toronto, including its history, culture, landmarks, and notable features." + Called tool get_tools with input {'task': 'Tell me about Toronto'} + Got output: ['Toronto'] + Called tool create_agent with input {'system_prompt': 'Generate a brief summary about Toronto, including its history, culture, landmarks, and notable features.', 'tool_names': ['Toronto']} + Got output: Agent created successfully. + Result: I have created an agent that can provide information about Toronto, including its history, culture, landmarks, and notable features. You can now ask the agent any questions you have about Toronto! + + + +```python +city_agent = agent_cache["agent"] +``` + + +```python +response = await city_agent.run("Tell me about the parks in Toronto") +print(str(response)) +``` + + Toronto is home to a diverse array of parks and public spaces, offering both urban and natural environments. Key downtown parks include Allan Gardens, Christie Pits, and Trinity Bellwoods Park. For waterfront views, Tommy Thompson Park and the Toronto Islands are popular destinations. In the city's outer areas, large parks like High Park, Humber Bay Park, and Morningside Park provide expansive green spaces. Additionally, parts of Rouge National Urban Park, the largest urban park in North America, are located within Toronto. The city also features notable squares such as Nathan Phillips Square, Yonge–Dundas Square, and Harbourfront Square. Approximately 12.5% of Toronto's land is dedicated to parkland, offering facilities for various activities, including winter sports like ice skating and skiing. + diff --git a/.tmp/agent/agent_workflow_basic.md b/.tmp/agent/agent_workflow_basic.md new file mode 100644 index 0000000..407b927 --- /dev/null +++ b/.tmp/agent/agent_workflow_basic.md @@ -0,0 +1,351 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_basic.ipynb +toc: True +title: "FunctionAgent / AgentWorkflow Basic Introduction" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +The `AgentWorkflow` is an orchestrator for running a system of one or more agents. In this example, we'll create a simple workflow with a single `FunctionAgent`, and use that to cover the basic functionality. + + +```python +%pip install llama-index +``` + +## Setup + +In this example, we will use `OpenAI` as our LLM. For all LLMs, check out the [examples documentation](https://docs.llamaindex.ai/en/stable/examples/llm/openai/) or [LlamaHub](https://llamahub.ai/?tab=llms) for a list of all supported LLMs and how to install/use them. + + +```python +from llama_index.llms.openai import OpenAI + +llm = OpenAI(model="gpt-4o-mini", api_key="sk-...") +``` + +To make our agent more useful, we can give it tools/actions to use. In this case, we'll use Tavily to implement a tool that can search the web for information. You can get a free API key from [Tavily](https://tavily.com/). + + +```python +%pip install tavily-python +``` + +When creating a tool, its very important to: +- give the tool a proper name and docstring/description. The LLM uses this to understand what the tool does. +- annotate the types. This helps the LLM understand the expected input and output types. +- use async when possible, since this will make the workflow more efficient. + + +```python +from tavily import AsyncTavilyClient + + +async def search_web(query: str) -> str: + """Useful for using the web to answer questions.""" + client = AsyncTavilyClient(api_key="tvly-...") + return str(await client.search(query)) +``` + +With the tool and and LLM defined, we can create an `AgentWorkflow` that uses the tool. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[search_web], + llm=llm, + system_prompt="You are a helpful assistant that can search the web for information.", +) +``` + +## Running the Agent + +Now that our agent is created, we can run it! + + +```python +response = await agent.run(user_msg="What is the weather in San Francisco?") +print(str(response)) +``` + + The current weather in San Francisco is as follows: + + - **Temperature**: 16.1°C (61°F) + - **Condition**: Partly cloudy + - **Wind**: 13.6 mph (22.0 kph) from the west + - **Humidity**: 64% + - **Visibility**: 16 km (9 miles) + - **Pressure**: 1017 mb (30.04 in) + + For more details, you can check the full report [here](https://www.weatherapi.com/). + + +The above is the equivalent of the following of using `AgentWorkflow` with a single `FunctionAgent`: + + +```python +from llama_index.core.agent.workflow import AgentWorkflow + +workflow = AgentWorkflow(agents=[agent]) + +response = await workflow.run(user_msg="What is the weather in San Francisco?") +``` + +If you were creating a workflow with multiple agents, you can pass in a list of agents to the `AgentWorkflow` constructor. Learn more in our [multi-agent workflow example](https://docs.llamaindex.ai/en/stable/understanding/agent/multi_agent/). + +## Maintaining State + +By default, the `FunctionAgent` will maintain stateless between runs. This means that the agent will not have any memory of previous runs. + +To maintain state, we need to keep track of the previous state. Since the `FunctionAgent` is running in a `Workflow`, the state is stored in the `Context`. This can be passed between runs to maintain state and history. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) +``` + + +```python +response = await agent.run( + user_msg="My name is Logan, nice to meet you!", ctx=ctx +) +print(str(response)) +``` + + Nice to meet you, Logan! How can I assist you today? + + + +```python +response = await agent.run(user_msg="What is my name?", ctx=ctx) +print(str(response)) +``` + + Your name is Logan. + + +The context is serializable, so it can be saved to a database, file, etc. and loaded back in later. + +The `JsonSerializer` is a simple serializer that uses `json.dumps` and `json.loads` to serialize and deserialize the context. + +The `JsonPickleSerializer` is a serializer that uses `pickle` to serialize and deserialize the context. If you have objects in your context that are not serializable, you can use this serializer. + + +```python +from llama_index.core.workflow import JsonPickleSerializer, JsonSerializer + +ctx_dict = ctx.to_dict(serializer=JsonSerializer()) + +restored_ctx = Context.from_dict(agent, ctx_dict, serializer=JsonSerializer()) +``` + + +```python +response = await agent.run( + user_msg="Do you still remember my name?", ctx=restored_ctx +) +print(str(response)) +``` + + Yes, I remember your name is Logan. + + +## Streaming + +The `AgentWorkflow`/`FunctionAgent` also supports streaming. Since the `AgentWorkflow` is a `Workflow`, it can be streamed like any other `Workflow`. This works by using the handler that is returned from the workflow. There are a few key events that are streamed, feel free to explore below. + +If you only want to stream the LLM output, you can use the `AgentStream` events. + + +```python +from llama_index.core.agent.workflow import ( + AgentInput, + AgentOutput, + ToolCall, + ToolCallResult, + AgentStream, +) + +handler = agent.run(user_msg="What is the weather in Saskatoon?") + +async for event in handler.stream_events(): + if isinstance(event, AgentStream): + print(event.delta, end="", flush=True) + # print(event.response) # the current full response + # print(event.raw) # the raw llm api response + # print(event.current_agent_name) # the current agent name + # elif isinstance(event, AgentInput): + # print(event.input) # the current input messages + # print(event.current_agent_name) # the current agent name + # elif isinstance(event, AgentOutput): + # print(event.response) # the current full response + # print(event.tool_calls) # the selected tool calls, if any + # print(event.raw) # the raw llm api response + # elif isinstance(event, ToolCallResult): + # print(event.tool_name) # the tool name + # print(event.tool_kwargs) # the tool kwargs + # print(event.tool_output) # the tool output + # elif isinstance(event, ToolCall): + # print(event.tool_name) # the tool name + # print(event.tool_kwargs) # the tool kwargs +``` + + The current weather in Saskatoon is as follows: + + - **Temperature**: 22.2°C (72°F) + - **Condition**: Overcast + - **Humidity**: 25% + - **Wind Speed**: 6.0 mph (9.7 kph) from the northwest + - **Visibility**: 4.8 km + - **Pressure**: 1018 mb + + For more details, you can check the full report [here](https://www.weatherapi.com/). + +## Tools and State + +Tools can also be defined that have access to the workflow context. This means you can set and retrieve variables from the context and use them in the tool or between tools. + +**Note:** The `Context` parameter should be the first parameter of the tool. + + +```python +from llama_index.core.workflow import Context + + +async def set_name(ctx: Context, name: str) -> str: + state = await ctx.store.get("state") + state["name"] = name + await ctx.store.set("state", state) + return f"Name set to {name}" + + +agent = FunctionAgent( + tools=[set_name], + llm=llm, + system_prompt="You are a helpful assistant that can set a name.", + initial_state={"name": "unset"}, +) + +ctx = Context(agent) + +response = await agent.run(user_msg="My name is Logan", ctx=ctx) +print(str(response)) + +state = await ctx.store.get("state") +print(state["name"]) +``` + + Your name has been set to Logan. + Logan + + +## Human in the Loop + +Tools can also be defined that involve a human in the loop. This is useful for tasks that require human input, such as confirming a tool call or providing feedback. + +Using workflow events, we can emit events that require a response from the user. Here, we use the built-in `InputRequiredEvent` and `HumanResponseEvent` to handle the human in the loop, but you can also define your own events. + +`wait_for_event` will emit the `waiter_event` and wait until it sees the `HumanResponseEvent` with the specified `requirements`. The `waiter_id` is used to ensure that we only send one `waiter_event` for each `waiter_id`. + + +```python +from llama_index.core.workflow import ( + Context, + InputRequiredEvent, + HumanResponseEvent, +) + + +async def dangerous_task(ctx: Context) -> str: + """A dangerous task that requires human confirmation.""" + + question = "Are you sure you want to proceed?" + response = await ctx.wait_for_event( + HumanResponseEvent, + waiter_id=question, + waiter_event=InputRequiredEvent( + prefix=question, + user_name="Logan", + ), + requirements={"user_name": "Logan"}, + ) + if response.response == "yes": + return "Dangerous task completed successfully." + else: + return "Dangerous task aborted." + + +agent = FunctionAgent( + tools=[dangerous_task], + llm=llm, + system_prompt="You are a helpful assistant that can perform dangerous tasks.", +) +``` + + +```python +handler = agent.run(user_msg="I want to proceed with the dangerous task.") + +async for event in handler.stream_events(): + if isinstance(event, InputRequiredEvent): + response = input(event.prefix).strip().lower() + handler.ctx.send_event( + HumanResponseEvent( + response=response, + user_name=event.user_name, + ) + ) + +response = await handler +print(str(response)) +``` + + The dangerous task has been completed successfully. If you need anything else, feel free to ask! + + +In production scenarios, you might handle human-in-the-loop over a websocket or multiple API requests. + +As mentioned before, the `Context` object is serializable, and this means we can also save the workflow mid-run and restore it later. + +**NOTE:** Any functions/steps that were in-progress will start from the beginning when the workflow is restored. + + +```python +from llama_index.core.workflow import JsonSerializer + +handler = agent.run(user_msg="I want to proceed with the dangerous task.") + +input_ev = None +async for event in handler.stream_events(): + if isinstance(event, InputRequiredEvent): + input_ev = event + break + +# save the context somewhere for later +ctx_dict = handler.ctx.to_dict(serializer=JsonSerializer()) + +# get the response from the user +response_str = input(input_ev.prefix).strip().lower() + +# restore the workflow +restored_ctx = Context.from_dict(agent, ctx_dict, serializer=JsonSerializer()) + +handler = agent.run(ctx=restored_ctx) +handler.ctx.send_event( + HumanResponseEvent( + response=response_str, + user_name=input_ev.user_name, + ) +) +response = await handler +print(str(response)) +``` + + The dangerous task has been completed successfully. If you need anything else, feel free to ask! + diff --git a/.tmp/agent/agent_workflow_multi.md b/.tmp/agent/agent_workflow_multi.md new file mode 100644 index 0000000..33a3c51 --- /dev/null +++ b/.tmp/agent/agent_workflow_multi.md @@ -0,0 +1,300 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_multi.ipynb +toc: True +title: "Multi-Agent Report Generation with AgentWorkflow" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +Open In Colab + +In this notebook, we will explore how to use the `AgentWorkflow` class to create multi-agent systems. Specifically, we will create a system that can generate a report on a given topic. + +This notebook will assume that you have already either read the [basic agent workflow notebook](https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic) or the [agent workflow documentation](https://docs.llamaindex.ai/en/stable/understanding/agent/). + +## Setup + +In this example, we will use `OpenAI` as our LLM. For all LLMs, check out the [examples documentation](https://docs.llamaindex.ai/en/stable/examples/llm/openai/) or [LlamaHub](https://llamahub.ai/?tab=llms) for a list of all supported LLMs and how to install/use them. + +If we wanted, each agent could have a different LLM, but for this example, we will use the same LLM for all agents. + + +```python +%pip install llama-index +``` + + +```python +from llama_index.llms.openai import OpenAI + +llm = OpenAI(model="gpt-4o", api_key="sk-...") +``` + +## System Design + +Our system will have three agents: + +1. A `ResearchAgent` that will search the web for information on the given topic. +2. A `WriteAgent` that will write the report using the information found by the `ResearchAgent`. +3. A `ReviewAgent` that will review the report and provide feedback. + +We will use the `AgentWorkflow` class to create a multi-agent system that will execute these agents in order. + +While there are many ways to implement this system, in this case, we will use a few tools to help with the research and writing processes. + +1. A `web_search` tool to search the web for information on the given topic. +2. A `record_notes` tool to record notes on the given topic. +3. A `write_report` tool to write the report using the information found by the `ResearchAgent`. +4. A `review_report` tool to review the report and provide feedback. + +Utilizing the `Context` class, we can pass state between agents, and each agent will have access to the current state of the system. + + + +```python +%pip install tavily-python +``` + + +```python +from tavily import AsyncTavilyClient +from llama_index.core.workflow import Context + + +async def search_web(query: str) -> str: + """Useful for using the web to answer questions.""" + client = AsyncTavilyClient(api_key="tvly-...") + return str(await client.search(query)) + + +async def record_notes(ctx: Context, notes: str, notes_title: str) -> str: + """Useful for recording notes on a given topic. Your input should be notes with a title to save the notes under.""" + current_state = await ctx.store.get("state") + if "research_notes" not in current_state: + current_state["research_notes"] = {} + current_state["research_notes"][notes_title] = notes + await ctx.store.set("state", current_state) + return "Notes recorded." + + +async def write_report(ctx: Context, report_content: str) -> str: + """Useful for writing a report on a given topic. Your input should be a markdown formatted report.""" + current_state = await ctx.store.get("state") + current_state["report_content"] = report_content + await ctx.store.set("state", current_state) + return "Report written." + + +async def review_report(ctx: Context, review: str) -> str: + """Useful for reviewing a report and providing feedback. Your input should be a review of the report.""" + current_state = await ctx.store.get("state") + current_state["review"] = review + await ctx.store.set("state", current_state) + return "Report reviewed." +``` + +With our tools defined, we can now create our agents. + +If the LLM you are using supports tool calling, you can use the `FunctionAgent` class. Otherwise, you can use the `ReActAgent` class. + +Here, the name and description of each agent is used so that the system knows what each agent is responsible for and when to hand off control to the next agent. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent + +research_agent = FunctionAgent( + name="ResearchAgent", + description="Useful for searching the web for information on a given topic and recording notes on the topic.", + system_prompt=( + "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. " + "Once notes are recorded and you are satisfied, you should hand off control to the WriteAgent to write a report on the topic. " + "You should have at least some notes on a topic before handing off control to the WriteAgent." + ), + llm=llm, + tools=[search_web, record_notes], + can_handoff_to=["WriteAgent"], +) + +write_agent = FunctionAgent( + name="WriteAgent", + description="Useful for writing a report on a given topic.", + system_prompt=( + "You are the WriteAgent that can write a report on a given topic. " + "Your report should be in a markdown format. The content should be grounded in the research notes. " + "Once the report is written, you should get feedback at least once from the ReviewAgent." + ), + llm=llm, + tools=[write_report], + can_handoff_to=["ReviewAgent", "ResearchAgent"], +) + +review_agent = FunctionAgent( + name="ReviewAgent", + description="Useful for reviewing a report and providing feedback.", + system_prompt=( + "You are the ReviewAgent that can review the write report and provide feedback. " + "Your review should either approve the current report or request changes for the WriteAgent to implement. " + "If you have feedback that requires changes, you should hand off control to the WriteAgent to implement the changes after submitting the review." + ), + llm=llm, + tools=[review_report], + can_handoff_to=["WriteAgent"], +) +``` + +## Running the Workflow + +With our agents defined, we can create our `AgentWorkflow` and run it. + + +```python +from llama_index.core.agent.workflow import AgentWorkflow + +agent_workflow = AgentWorkflow( + agents=[research_agent, write_agent, review_agent], + root_agent=research_agent.name, + initial_state={ + "research_notes": {}, + "report_content": "Not written yet.", + "review": "Review required.", + }, +) +``` + +As the workflow is running, we will stream the events to get an idea of what is happening under the hood. + + +```python +from llama_index.core.agent.workflow import ( + AgentInput, + AgentOutput, + ToolCall, + ToolCallResult, + AgentStream, +) + +handler = agent_workflow.run( + user_msg=( + "Write me a report on the history of the internet. " + "Briefly describe the history of the internet, including the development of the internet, the development of the web, " + "and the development of the internet in the 21st century." + ) +) + +current_agent = None +current_tool_calls = "" +async for event in handler.stream_events(): + if ( + hasattr(event, "current_agent_name") + and event.current_agent_name != current_agent + ): + current_agent = event.current_agent_name + print(f"\n{'='*50}") + print(f"🤖 Agent: {current_agent}") + print(f"{'='*50}\n") + + # if isinstance(event, AgentStream): + # if event.delta: + # print(event.delta, end="", flush=True) + # elif isinstance(event, AgentInput): + # print("📥 Input:", event.input) + elif isinstance(event, AgentOutput): + if event.response.content: + print("📤 Output:", event.response.content) + if event.tool_calls: + print( + "🛠️ Planning to use tools:", + [call.tool_name for call in event.tool_calls], + ) + elif isinstance(event, ToolCallResult): + print(f"🔧 Tool Result ({event.tool_name}):") + print(f" Arguments: {event.tool_kwargs}") + print(f" Output: {event.tool_output}") + elif isinstance(event, ToolCall): + print(f"🔨 Calling Tool: {event.tool_name}") + print(f" With arguments: {event.tool_kwargs}") +``` + + + ================================================== + 🤖 Agent: ResearchAgent + ================================================== + + 🛠️ Planning to use tools: ['search_web'] + 🔨 Calling Tool: search_web + With arguments: {'query': 'history of the internet'} + 🔧 Tool Result (search_web): + Arguments: {'query': 'history of the internet'} + Output: {'query': 'history of the internet', 'follow_up_questions': None, 'answer': None, 'images': [], 'results': [{'title': 'Internet history timeline: ARPANET to the World Wide Web', 'url': 'https://www.livescience.com/20727-internet-history.html', 'content': 'Internet history timeline: ARPANET to the World Wide Web\nThe internet history timeline shows how today\'s vast network evolved from the initial concept\nIn internet history, credit for the initial concept that developed into the World Wide Web is typically given to Leonard Kleinrock. "\nAccording to the journal Management and Business Review (MBR), Kleinrock, along with other innovators such as J.C.R. Licklider, the first director of the Information Processing Technology Office (IPTO), provided the backbone for the ubiquitous stream of emails, media, Facebook postings and tweets that are now shared online every day.\n The precursor to the internet was jumpstarted in the early days of the history of computers , in 1969 with the U.S. Defense Department\'s Advanced Research Projects Agency Network (ARPANET), according to the journal American Scientist. The successful push to stop the bill, involving technology companies such as Google and nonprofit organizations including Wikipedia and the Electronic Frontier Foundation, is considered a victory for sites such as YouTube that depend on user-generated content, as well as "fair use" on the internet.\n Vinton Cerf and Bob Kahn (the duo said by many to be the Fathers of the Internet) publish "A Protocol for Packet Network Interconnection," which details the design of TCP.\n1976:', 'score': 0.81097376, 'raw_content': None}, {'title': 'A Brief History of the Internet - University System of Georgia', 'url': 'https://usg.edu/galileo/skills/unit07/internet07_02.phtml', 'content': 'The Internet started in the 1960s as a way for government researchers to share information. This eventually led to the formation of the ARPANET (Advanced Research Projects Agency Network), the network that ultimately evolved into what we now know as the Internet. In response to this, other networks were created to provide information sharing. ARPANET and the Defense Data Network officially changed to the TCP/IP standard on January 1, 1983, hence the birth of the Internet. (Business computers like the UNIVAC processed data more slowly than the IAS-type machines, but were designed for fast input and output.) The first few sales were to government agencies, the A.C. Nielsen Company, and the Prudential Insurance Company.', 'score': 0.8091708, 'raw_content': None}, {'title': 'Timeline - History of the Internet', 'url': 'https://historyoftheinternet.net/timeline/', 'content': "Learn how the internet evolved from SAGE and IBM's internal networks to ARPANET and the World Wide Web. Explore the commercial and government paths that led to the current internet format and protocols.", 'score': 0.7171114, 'raw_content': None}, {'title': 'Learn About Internet History | History of the Internet', 'url': 'https://internethistory.org/', 'content': 'Learn about the origins, evolution and impact of the internet through stories, materials and videos. Explore the first internet message, optical amplifier, wavelength division multiplexing and more.', 'score': 0.7040996, 'raw_content': None}, {'title': 'Brief History of the Internet', 'url': 'https://www.internetsociety.org/resources/doc/2017/brief-history-internet/', 'content': "Learn how the Internet evolved from the initial internetting concepts to a global network of networks that transformed the computer and communications world. Explore the key milestones, challenges, and opportunities of the Internet's development and future.", 'score': 0.6944897, 'raw_content': None}], 'response_time': 1.65} + 🛠️ Planning to use tools: ['record_notes'] + 🔨 Calling Tool: record_notes + With arguments: {'notes': "The internet's history began in the 1960s as a project for government researchers to share information, leading to the creation of ARPANET (Advanced Research Projects Agency Network). ARPANET was the first network to implement the TCP/IP protocol suite, which became the foundation for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the birth of the internet.\n\nThe World Wide Web was developed later, in 1989, by Tim Berners-Lee, a British scientist at CERN. The web was initially conceived as a way to facilitate information sharing among scientists and institutes around the world. Berners-Lee developed the first web browser and web server, and introduced the concept of hyperlinks, which allowed users to navigate between different documents on the web.\n\nIn the 21st century, the internet has evolved into a global network that connects billions of devices and users. It has transformed communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact.", 'notes_title': 'History of the Internet'} + 🔧 Tool Result (record_notes): + Arguments: {'notes': "The internet's history began in the 1960s as a project for government researchers to share information, leading to the creation of ARPANET (Advanced Research Projects Agency Network). ARPANET was the first network to implement the TCP/IP protocol suite, which became the foundation for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the birth of the internet.\n\nThe World Wide Web was developed later, in 1989, by Tim Berners-Lee, a British scientist at CERN. The web was initially conceived as a way to facilitate information sharing among scientists and institutes around the world. Berners-Lee developed the first web browser and web server, and introduced the concept of hyperlinks, which allowed users to navigate between different documents on the web.\n\nIn the 21st century, the internet has evolved into a global network that connects billions of devices and users. It has transformed communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact.", 'notes_title': 'History of the Internet'} + Output: Notes recorded. + 🛠️ Planning to use tools: ['handoff'] + 🔨 Calling Tool: handoff + With arguments: {'to_agent': 'WriteAgent', 'reason': 'I have gathered and recorded notes on the history of the internet, including its development, the creation of the web, and its evolution in the 21st century. The WriteAgent can now use these notes to write a comprehensive report.'} + 🔧 Tool Result (handoff): + Arguments: {'to_agent': 'WriteAgent', 'reason': 'I have gathered and recorded notes on the history of the internet, including its development, the creation of the web, and its evolution in the 21st century. The WriteAgent can now use these notes to write a comprehensive report.'} + Output: Handed off to WriteAgent because: I have gathered and recorded notes on the history of the internet, including its development, the creation of the web, and its evolution in the 21st century. The WriteAgent can now use these notes to write a comprehensive report. + + ================================================== + 🤖 Agent: WriteAgent + ================================================== + + 🛠️ Planning to use tools: ['write_report'] + 🔨 Calling Tool: write_report + With arguments: {'report_content': "# History of the Internet\n\nThe history of the internet is a fascinating journey from a government research project to a global network that has transformed the way we communicate, work, and live. This report provides a brief overview of the key milestones in the development of the internet, the World Wide Web, and the internet's evolution in the 21st century.\n\n## Development of the Internet\n\nThe origins of the internet date back to the 1960s, when it was conceived as a means for government researchers to share information. This led to the creation of ARPANET (Advanced Research Projects Agency Network), which was the first network to implement the TCP/IP protocol suite. TCP/IP became the foundational technology for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the official birth of the internet.\n\n## Development of the World Wide Web\n\nThe World Wide Web was developed in 1989 by Tim Berners-Lee, a British scientist working at CERN. The web was initially designed to facilitate information sharing among scientists and research institutes globally. Berners-Lee created the first web browser and web server, introducing the concept of hyperlinks, which allowed users to navigate between different documents on the web seamlessly.\n\n## The Internet in the 21st Century\n\nIn the 21st century, the internet has evolved into a vast global network connecting billions of devices and users. It has revolutionized communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact, making it an integral part of daily life for people around the world.\n\nThe internet continues to evolve, with ongoing advancements in technology and infrastructure shaping its future. As it grows, the internet remains a powerful tool for innovation, connectivity, and information sharing, influencing nearly every aspect of modern society."} + 🔧 Tool Result (write_report): + Arguments: {'report_content': "# History of the Internet\n\nThe history of the internet is a fascinating journey from a government research project to a global network that has transformed the way we communicate, work, and live. This report provides a brief overview of the key milestones in the development of the internet, the World Wide Web, and the internet's evolution in the 21st century.\n\n## Development of the Internet\n\nThe origins of the internet date back to the 1960s, when it was conceived as a means for government researchers to share information. This led to the creation of ARPANET (Advanced Research Projects Agency Network), which was the first network to implement the TCP/IP protocol suite. TCP/IP became the foundational technology for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the official birth of the internet.\n\n## Development of the World Wide Web\n\nThe World Wide Web was developed in 1989 by Tim Berners-Lee, a British scientist working at CERN. The web was initially designed to facilitate information sharing among scientists and research institutes globally. Berners-Lee created the first web browser and web server, introducing the concept of hyperlinks, which allowed users to navigate between different documents on the web seamlessly.\n\n## The Internet in the 21st Century\n\nIn the 21st century, the internet has evolved into a vast global network connecting billions of devices and users. It has revolutionized communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact, making it an integral part of daily life for people around the world.\n\nThe internet continues to evolve, with ongoing advancements in technology and infrastructure shaping its future. As it grows, the internet remains a powerful tool for innovation, connectivity, and information sharing, influencing nearly every aspect of modern society."} + Output: Report written. + 🛠️ Planning to use tools: ['handoff'] + 🔨 Calling Tool: handoff + With arguments: {'to_agent': 'ReviewAgent', 'reason': 'The report on the history of the internet has been written and needs to be reviewed for accuracy and completeness.'} + 🔧 Tool Result (handoff): + Arguments: {'to_agent': 'ReviewAgent', 'reason': 'The report on the history of the internet has been written and needs to be reviewed for accuracy and completeness.'} + Output: Handed off to ReviewAgent because: The report on the history of the internet has been written and needs to be reviewed for accuracy and completeness. + + ================================================== + 🤖 Agent: ReviewAgent + ================================================== + + 🛠️ Planning to use tools: ['review_report'] + 🔨 Calling Tool: review_report + With arguments: {'review': "The report on the history of the internet provides a concise and informative overview of the key developments in the internet's history. It effectively covers the origins of the internet with ARPANET, the creation of the World Wide Web by Tim Berners-Lee, and the evolution of the internet in the 21st century. The report is well-structured, with clear sections that make it easy to follow.\n\nThe content is accurate and aligns with the historical timeline of the internet's development. It highlights significant milestones such as the adoption of TCP/IP and the introduction of hyperlinks, which are crucial to understanding the internet's growth.\n\nOverall, the report meets the requirements and provides a comprehensive summary of the internet's history. It is approved for final submission."} + 🔧 Tool Result (review_report): + Arguments: {'review': "The report on the history of the internet provides a concise and informative overview of the key developments in the internet's history. It effectively covers the origins of the internet with ARPANET, the creation of the World Wide Web by Tim Berners-Lee, and the evolution of the internet in the 21st century. The report is well-structured, with clear sections that make it easy to follow.\n\nThe content is accurate and aligns with the historical timeline of the internet's development. It highlights significant milestones such as the adoption of TCP/IP and the introduction of hyperlinks, which are crucial to understanding the internet's growth.\n\nOverall, the report meets the requirements and provides a comprehensive summary of the internet's history. It is approved for final submission."} + Output: Report reviewed. + 📤 Output: The report on the history of the internet has been reviewed and approved. It provides a comprehensive and accurate overview of the internet's development, the creation of the World Wide Web, and its evolution in the 21st century. The report is well-structured and meets the requirements for final submission. + + +Now, we can retrieve the final report in the system for ourselves. + + +```python +state = await handler.ctx.store.get("state") +print(state["report_content"]) +``` + + # History of the Internet + + The history of the internet is a fascinating journey from a government research project to a global network that has transformed the way we communicate, work, and live. This report provides a brief overview of the key milestones in the development of the internet, the World Wide Web, and the internet's evolution in the 21st century. + + ## Development of the Internet + + The origins of the internet date back to the 1960s, when it was conceived as a means for government researchers to share information. This led to the creation of ARPANET (Advanced Research Projects Agency Network), which was the first network to implement the TCP/IP protocol suite. TCP/IP became the foundational technology for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the official birth of the internet. + + ## Development of the World Wide Web + + The World Wide Web was developed in 1989 by Tim Berners-Lee, a British scientist working at CERN. The web was initially designed to facilitate information sharing among scientists and research institutes globally. Berners-Lee created the first web browser and web server, introducing the concept of hyperlinks, which allowed users to navigate between different documents on the web seamlessly. + + ## The Internet in the 21st Century + + In the 21st century, the internet has evolved into a vast global network connecting billions of devices and users. It has revolutionized communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact, making it an integral part of daily life for people around the world. + + The internet continues to evolve, with ongoing advancements in technology and infrastructure shaping its future. As it grows, the internet remains a powerful tool for innovation, connectivity, and information sharing, influencing nearly every aspect of modern society. + diff --git a/.tmp/agent/agent_workflow_research_assistant.md b/.tmp/agent/agent_workflow_research_assistant.md index 3bcb452..cc3546a 100644 --- a/.tmp/agent/agent_workflow_research_assistant.md +++ b/.tmp/agent/agent_workflow_research_assistant.md @@ -1,11 +1,12 @@ --- layout: recipe -colab: https://colab.research.google.com/github/TuanaCelik/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_research_assistant.ipynb +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_research_assistant.ipynb toc: True title: "Agent Workflow + Research Assistant using AgentQL" -featured: False +featured: True experimental: True tags: ['Agent', 'Websearch', 'Integrations'] +language: py --- Open In Colab diff --git a/.tmp/agent/agents_as_tools.md b/.tmp/agent/agents_as_tools.md new file mode 100644 index 0000000..5199a00 --- /dev/null +++ b/.tmp/agent/agents_as_tools.md @@ -0,0 +1,467 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agents_as_tools.ipynb +toc: True +title: "Multi-Agent Report Generation using Agents as Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +Open In Colab + +In this notebook, we will explore how to create a multi-agent system that uses a top-level agent to orchestrate a group of agents as tools. Specifically, we will create a system that can research, write, and review a report on a given topic. + +This notebook will assume that you have already either read the [basic agent workflow notebook](https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic) or the [general agent documentation](https://docs.llamaindex.ai/en/stable/understanding/agent/). + +## Setup + +In this example, we will use `OpenAI` as our LLM. For all LLMs, check out the [examples documentation](https://docs.llamaindex.ai/en/stable/examples/llm/openai/) or [LlamaHub](https://llamahub.ai/?tab=llms) for a list of all supported LLMs and how to install/use them. + +If we wanted, each agent could have a different LLM, but for this example, we will use the same LLM for all agents. + + +```python +%pip install llama-index +``` + + +```python +from llama_index.llms.openai import OpenAI + +sub_agent_llm = OpenAI(model="gpt-4.1-mini", api_key="sk-...") +orchestrator_llm = OpenAI(model="o3-mini", api_key="sk-...") +``` + +## System Design + +Our system will have three agents: + +1. A `ResearchAgent` that will search the web for information on the given topic. +2. A `WriteAgent` that will write the report using the information found by the `ResearchAgent`. +3. A `ReviewAgent` that will review the report and provide feedback. + +We will then use a top-level agent to orchestrate the other agents to write our report. + +While there are many ways to implement this system, in this case, we will use a single `web_search` tool to search the web for information on the given topic. + + + +```python +%pip install tavily-python +``` + + +```python +from tavily import AsyncTavilyClient + + +async def search_web(query: str) -> str: + """Useful for using the web to answer questions.""" + client = AsyncTavilyClient(api_key="tvly-...") + return str(await client.search(query)) +``` + +With our tool defined, we can now create our sub-agents. + +If the LLM you are using supports tool calling, you can use the `FunctionAgent` class. Otherwise, you can use the `ReActAgent` class. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent + +research_agent = FunctionAgent( + system_prompt=( + "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. " + "You should output notes on the topic in a structured format." + ), + llm=sub_agent_llm, + tools=[search_web], +) + +write_agent = FunctionAgent( + system_prompt=( + "You are the WriteAgent that can write a report on a given topic. " + "Your report should be in a markdown format. The content should be grounded in the research notes. " + "Return your markdown report surrounded by ... tags." + ), + llm=sub_agent_llm, + tools=[], +) + +review_agent = FunctionAgent( + system_prompt=( + "You are the ReviewAgent that can review the write report and provide feedback. " + "Your review should either approve the current report or request changes to be implemented." + ), + llm=sub_agent_llm, + tools=[], +) +``` + +With our sub-agents defined, we can then convert them into tools that can be used by the top-level agent. + + +```python +import re +from llama_index.core.workflow import Context + + +async def call_research_agent(ctx: Context, prompt: str) -> str: + """Useful for recording research notes based on a specific prompt.""" + result = await research_agent.run( + user_msg=f"Write some notes about the following: {prompt}" + ) + + state = await ctx.store.get("state") + state["research_notes"].append(str(result)) + await ctx.store.set("state", state) + + return str(result) + + +async def call_write_agent(ctx: Context) -> str: + """Useful for writing a report based on the research notes or revising the report based on feedback.""" + state = await ctx.store.get("state") + notes = state.get("research_notes", None) + if not notes: + return "No research notes to write from." + + user_msg = f"Write a markdown report from the following notes. Be sure to output the report in the following format: ...:\n\n" + + # Add the feedback to the user message if it exists + feedback = state.get("review", None) + if feedback: + user_msg += f"{feedback}\n\n" + + # Add the research notes to the user message + notes = "\n\n".join(notes) + user_msg += f"{notes}\n\n" + + # Run the write agent + result = await write_agent.run(user_msg=user_msg) + report = re.search(r"(.*)", str(result), re.DOTALL).group( + 1 + ) + state["report_content"] = str(report) + await ctx.store.set("state", state) + + return str(report) + + +async def call_review_agent(ctx: Context) -> str: + """Useful for reviewing the report and providing feedback.""" + state = await ctx.store.get("state") + report = state.get("report_content", None) + if not report: + return "No report content to review." + + result = await review_agent.run( + user_msg=f"Review the following report: {report}" + ) + state["review"] = result + await ctx.store.set("state", state) + + return result +``` + +## Creating the Top-Level Orchestrator Agent + +With our sub-agents defined as tools, we can now create our top-level orchestrator agent. + + +```python +orchestrator = FunctionAgent( + system_prompt=( + "You are an expert in the field of report writing. " + "You are given a user request and a list of tools that can help with the request. " + "You are to orchestrate the tools to research, write, and review a report on the given topic. " + "Once the review is positive, you should notify the user that the report is ready to be accessed." + ), + llm=orchestrator_llm, + tools=[ + call_research_agent, + call_write_agent, + call_review_agent, + ], + initial_state={ + "research_notes": [], + "report_content": None, + "review": None, + }, +) +``` + +## Running the Agent + +Let's run our agents! We can iterate over events as the workflow runs. + + +```python +from llama_index.core.agent.workflow import ( + AgentInput, + AgentOutput, + ToolCall, + ToolCallResult, + AgentStream, +) +from llama_index.core.workflow import Context + +# Create a context for the orchestrator to hold history/state +ctx = Context(orchestrator) + + +async def run_orchestrator(ctx: Context, user_msg: str): + handler = orchestrator.run( + user_msg=user_msg, + ctx=ctx, + ) + + async for event in handler.stream_events(): + if isinstance(event, AgentStream): + if event.delta: + print(event.delta, end="", flush=True) + # elif isinstance(event, AgentInput): + # print("📥 Input:", event.input) + elif isinstance(event, AgentOutput): + # Skip printing the output since we are streaming above + # if event.response.content: + # print("📤 Output:", event.response.content) + if event.tool_calls: + print( + "🛠️ Planning to use tools:", + [call.tool_name for call in event.tool_calls], + ) + elif isinstance(event, ToolCallResult): + print(f"🔧 Tool Result ({event.tool_name}):") + print(f" Arguments: {event.tool_kwargs}") + print(f" Output: {event.tool_output}") + elif isinstance(event, ToolCall): + print(f"🔨 Calling Tool: {event.tool_name}") + print(f" With arguments: {event.tool_kwargs}") +``` + + +```python +await run_orchestrator( + ctx=ctx, + user_msg=( + "Write me a report on the history of the internet. " + "Briefly describe the history of the internet, including the development of the internet, the development of the web, " + "and the development of the internet in the 21st century." + ), +) +``` + + 🛠️ Planning to use tools: ['call_research_agent'] + 🔨 Calling Tool: call_research_agent + With arguments: {'prompt': 'Write a detailed research note on the history of the internet, covering the development of the internet, the development of the web, and the development of the internet in the 21st century.'} + 🔧 Tool Result (call_research_agent): + Arguments: {'prompt': 'Write a detailed research note on the history of the internet, covering the development of the internet, the development of the web, and the development of the internet in the 21st century.'} + Output: Research Notes on the History of the Internet + + 1. Development of the Internet: + - The internet's origins trace back to the late 1960s with the U.S. Defense Department's Advanced Research Projects Agency Network (ARPANET), designed as a military defense system during the Cold War. + - ARPANET was the first network to implement the protocol suite TCP/IP, which became the technical foundation of the modern Internet. + - The Network Working Group evolved into the Internet Working Group to coordinate the growing research community. + - In the 1970s, commercial packet networks emerged, primarily to provide remote computer access. + - The National Science Foundation (NSF) expanded access to the scientific and academic community and helped make TCP/IP the standard for federally supported research networks. + - The internet grew through interconnected commercial backbones linked by network access points (NAPs). + + 2. Development of the World Wide Web: + - Invented by Tim Berners-Lee in 1989 while working at CERN, the World Wide Web introduced a "web" of linked information accessible to anyone on the Internet. + - By December 1990, Berners-Lee developed the essential tools: HTTP (HyperText Transfer Protocol), HTML (HyperText Markup Language), the first web browser/editor, the first web server, and the first website. + - The Web allowed easy access to existing information and linked resources, initially serving CERN scientists. + - In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to create open standards for the Web. + - The Web evolved from Web 1.0 (basic, static pages) to Web 2.0 (interactive, user-generated content) starting around 2003, and further towards Web 3.0 (semantic web, intelligent data) from 2014 onwards. + + 3. Development of the Internet in the 21st Century: + - The 21st century saw transformative developments such as broadband, fiber-optic technology, and mobile internet. + - The rise of smartphones revolutionized mobile browsing and internet access. + - Cloud computing emerged, allowing data storage and processing on remote servers, changing how businesses and individuals manage information. + - The Internet of Things (IoT) connected everyday devices to the internet, expanding the internet's reach into daily life. + - Social media platforms became dominant, reshaping communication and information sharing. + - The internet's infrastructure and services have continuously evolved to support increasing data demands and new technologies. + + These notes summarize the key milestones and technological advancements that shaped the internet from its inception to its current state in the 21st century. + 🛠️ Planning to use tools: ['call_write_agent'] + 🔨 Calling Tool: call_write_agent + With arguments: {} + 🔧 Tool Result (call_write_agent): + Arguments: {} + Output: + # History of the Internet + + ## 1. Development of the Internet + + The origins of the internet date back to the late 1960s with the creation of the Advanced Research Projects Agency Network (ARPANET) by the U.S. Defense Department. Initially designed as a military defense system during the Cold War, ARPANET was the first network to implement the TCP/IP protocol suite, which later became the technical foundation of the modern Internet. + + The Network Working Group, which coordinated early research efforts, evolved into the Internet Working Group as the research community expanded. During the 1970s, commercial packet networks began to emerge, primarily to provide remote computer access. + + The National Science Foundation (NSF) played a crucial role by expanding internet access to the scientific and academic communities and promoting TCP/IP as the standard for federally supported research networks. The internet grew further through interconnected commercial backbones linked by network access points (NAPs), facilitating broader connectivity. + + ## 2. Development of the World Wide Web + + The World Wide Web was invented in 1989 by Tim Berners-Lee while working at CERN. It introduced a "web" of linked information accessible to anyone on the Internet. By December 1990, Berners-Lee had developed the essential tools that formed the Web's foundation: HTTP (HyperText Transfer Protocol), HTML (HyperText Markup Language), the first web browser/editor, the first web server, and the first website. + + Initially serving CERN scientists, the Web allowed easy access to existing information and linked resources. In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to create open standards for the Web, ensuring its continued growth and interoperability. + + The Web evolved through several stages: + - **Web 1.0:** Basic, static pages. + - **Web 2.0:** Starting around 2003, characterized by interactive, user-generated content. + - **Web 3.0:** From 2014 onwards, focusing on the semantic web and intelligent data. + + ## 3. Development of the Internet in the 21st Century + + The 21st century brought transformative advancements to the internet, including broadband and fiber-optic technologies that significantly increased data transmission speeds. The rise of smartphones revolutionized mobile browsing and internet access, making the internet ubiquitous. + + Cloud computing emerged as a major innovation, enabling data storage and processing on remote servers, which transformed how businesses and individuals manage information. The Internet of Things (IoT) connected everyday devices to the internet, expanding its reach into daily life. + + Social media platforms became dominant forces, reshaping communication and information sharing globally. Throughout these developments, the internet's infrastructure and services have continuously evolved to support increasing data demands and new technologies. + + --- + + This report summarizes the key milestones and technological advancements that have shaped the internet from its inception in the late 1960s to its current state in the 21st century. + + 🛠️ Planning to use tools: ['call_review_agent'] + 🔨 Calling Tool: call_review_agent + With arguments: {} + 🔧 Tool Result (call_review_agent): + Arguments: {} + Output: The report titled "History of the Internet" is well-structured, clear, and provides a concise overview of the major developments in the evolution of the internet. It effectively covers the origins, the invention and growth of the World Wide Web, and significant 21st-century advancements. + + Strengths: + - The chronological organization helps readers follow the progression of internet technology. + - Key figures and organizations (e.g., ARPANET, Tim Berners-Lee, NSF, W3C) are appropriately highlighted. + - The explanation of Web 1.0, 2.0, and 3.0 stages adds valuable context. + - The inclusion of recent technologies such as cloud computing, IoT, and social media reflects current trends. + + Suggestions for improvement: + 1. **Add citations or references:** The report would benefit from citing sources or references to support the historical facts and technological descriptions. + 2. **Clarify technical terms:** While the report is generally accessible, briefly defining terms like TCP/IP, NAPs, and semantic web could help readers unfamiliar with networking jargon. + 3. **Expand on social impact:** Consider including a brief discussion on how the internet has impacted society, economy, and culture to provide a more holistic view. + 4. **Minor formatting:** The section numbering is inconsistent (e.g., "1.", "2.", "3." but no numbering for the introduction or conclusion). Adding a brief introduction and conclusion section with numbering or consistent formatting would improve flow. + + Overall, the report is informative and well-written. With the suggested enhancements, it would be even more comprehensive and reader-friendly. + + Recommendation: **Approve with minor revisions** to incorporate citations, clarify terms, and consider adding social impact context. + 🛠️ Planning to use tools: ['call_write_agent'] + 🔨 Calling Tool: call_write_agent + With arguments: {} + 🔧 Tool Result (call_write_agent): + Arguments: {} + Output: + # History of the Internet + + ## 1. Introduction + + The internet is a transformative technology that has reshaped communication, information sharing, and society at large. This report provides a concise overview of the major developments in the evolution of the internet, from its origins in the late 1960s to the advanced technologies and societal impacts of the 21st century. + + ## 2. Development of the Internet + + The origins of the internet date back to the late 1960s with the creation of the Advanced Research Projects Agency Network (ARPANET) by the U.S. Department of Defense. ARPANET was initially designed as a military defense communication system during the Cold War. It was the first network to implement the Transmission Control Protocol/Internet Protocol (TCP/IP), a suite of communication protocols that became the technical foundation of the modern internet. TCP/IP enables different networks to interconnect and communicate seamlessly. + + During the 1970s, commercial packet-switched networks emerged, primarily to provide remote computer access. The National Science Foundation (NSF) played a crucial role in expanding internet access to the scientific and academic communities and helped establish TCP/IP as the standard protocol for federally supported research networks. The internet's growth was further supported by interconnected commercial backbones linked through Network Access Points (NAPs), which facilitated data exchange between different service providers. + + ## 3. Development of the World Wide Web + + In 1989, Tim Berners-Lee, working at CERN, invented the World Wide Web (WWW), which introduced a system of linked information accessible to anyone connected to the internet. By December 1990, Berners-Lee had developed the essential components of the Web: HyperText Transfer Protocol (HTTP), HyperText Markup Language (HTML), the first web browser/editor, the first web server, and the first website. These innovations allowed users to easily access and navigate information through hyperlinks. + + Initially serving CERN scientists, the Web rapidly expanded to the public. In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to develop open standards ensuring the Web's interoperability and growth. + + The Web has evolved through several stages: + + - **Web 1.0**: Characterized by static, read-only web pages. + - **Web 2.0**: Beginning around 2003, marked by interactive, user-generated content and social media platforms. + - **Web 3.0**: Emerging from 2014 onwards, focusing on the semantic web and intelligent data processing to create more personalized and meaningful online experiences. + + ## 4. Development of the Internet in the 21st Century + + The 21st century has witnessed transformative advancements in internet technology and infrastructure. Broadband and fiber-optic technologies have significantly increased data transmission speeds. The proliferation of smartphones revolutionized mobile internet access, enabling users to connect anytime and anywhere. + + Cloud computing emerged as a paradigm shift, allowing data storage and processing on remote servers rather than local devices. This innovation has changed how businesses and individuals manage information and applications. + + The Internet of Things (IoT) has expanded the internet's reach by connecting everyday devices—such as home appliances, vehicles, and wearable technology—to the network, enabling new functionalities and data-driven services. + + Social media platforms have become dominant forces in communication and information sharing, reshaping social interactions, marketing, and news dissemination. + + The internet's infrastructure and services continue to evolve to meet increasing data demands and support emerging technologies. + + ## 5. Social Impact of the Internet + + Beyond technological advancements, the internet has profoundly impacted society, the economy, and culture. It has democratized access to information, facilitated global communication, and enabled new forms of social interaction. Economically, it has created new industries, transformed traditional business models, and fostered innovation. Culturally, the internet has influenced media consumption, education, and the way communities form and interact. + + However, these changes also bring challenges such as privacy concerns, digital divides, misinformation, and cybersecurity threats, which require ongoing attention and management. + + ## 6. Conclusion + + The history of the internet is marked by continuous innovation and expansion, from its military origins to a global network integral to modern life. Key figures like Tim Berners-Lee and organizations such as ARPANET, NSF, and W3C have played pivotal roles in its development. Understanding the technical foundations, evolutionary stages of the Web, and recent technological trends provides valuable context for appreciating the internet's role today. Incorporating social impact considerations offers a more holistic view of this transformative technology. + + --- + + *Note: This report would benefit from citations to authoritative sources for historical facts and technical explanations to enhance credibility and provide readers with avenues for further research.* + + + The revised report on the history of the internet is now complete and ready for your review. Would you like to access the final report? + +With our report written and revised/reviewed, we can inspect the final report in the state. + + +```python +state = await ctx.store.get("state") +print(state["report_content"]) +``` + + + # History of the Internet + + ## 1. Introduction + + The internet is a transformative technology that has reshaped communication, information sharing, and society at large. This report provides a concise overview of the major developments in the evolution of the internet, from its origins in the late 1960s to the advanced technologies and societal impacts of the 21st century. + + ## 2. Development of the Internet + + The origins of the internet date back to the late 1960s with the creation of the Advanced Research Projects Agency Network (ARPANET) by the U.S. Department of Defense. ARPANET was initially designed as a military defense communication system during the Cold War. It was the first network to implement the Transmission Control Protocol/Internet Protocol (TCP/IP), a suite of communication protocols that became the technical foundation of the modern internet. TCP/IP enables different networks to interconnect and communicate seamlessly. + + During the 1970s, commercial packet-switched networks emerged, primarily to provide remote computer access. The National Science Foundation (NSF) played a crucial role in expanding internet access to the scientific and academic communities and helped establish TCP/IP as the standard protocol for federally supported research networks. The internet's growth was further supported by interconnected commercial backbones linked through Network Access Points (NAPs), which facilitated data exchange between different service providers. + + ## 3. Development of the World Wide Web + + In 1989, Tim Berners-Lee, working at CERN, invented the World Wide Web (WWW), which introduced a system of linked information accessible to anyone connected to the internet. By December 1990, Berners-Lee had developed the essential components of the Web: HyperText Transfer Protocol (HTTP), HyperText Markup Language (HTML), the first web browser/editor, the first web server, and the first website. These innovations allowed users to easily access and navigate information through hyperlinks. + + Initially serving CERN scientists, the Web rapidly expanded to the public. In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to develop open standards ensuring the Web's interoperability and growth. + + The Web has evolved through several stages: + + - **Web 1.0**: Characterized by static, read-only web pages. + - **Web 2.0**: Beginning around 2003, marked by interactive, user-generated content and social media platforms. + - **Web 3.0**: Emerging from 2014 onwards, focusing on the semantic web and intelligent data processing to create more personalized and meaningful online experiences. + + ## 4. Development of the Internet in the 21st Century + + The 21st century has witnessed transformative advancements in internet technology and infrastructure. Broadband and fiber-optic technologies have significantly increased data transmission speeds. The proliferation of smartphones revolutionized mobile internet access, enabling users to connect anytime and anywhere. + + Cloud computing emerged as a paradigm shift, allowing data storage and processing on remote servers rather than local devices. This innovation has changed how businesses and individuals manage information and applications. + + The Internet of Things (IoT) has expanded the internet's reach by connecting everyday devices—such as home appliances, vehicles, and wearable technology—to the network, enabling new functionalities and data-driven services. + + Social media platforms have become dominant forces in communication and information sharing, reshaping social interactions, marketing, and news dissemination. + + The internet's infrastructure and services continue to evolve to meet increasing data demands and support emerging technologies. + + ## 5. Social Impact of the Internet + + Beyond technological advancements, the internet has profoundly impacted society, the economy, and culture. It has democratized access to information, facilitated global communication, and enabled new forms of social interaction. Economically, it has created new industries, transformed traditional business models, and fostered innovation. Culturally, the internet has influenced media consumption, education, and the way communities form and interact. + + However, these changes also bring challenges such as privacy concerns, digital divides, misinformation, and cybersecurity threats, which require ongoing attention and management. + + ## 6. Conclusion + + The history of the internet is marked by continuous innovation and expansion, from its military origins to a global network integral to modern life. Key figures like Tim Berners-Lee and organizations such as ARPANET, NSF, and W3C have played pivotal roles in its development. Understanding the technical foundations, evolutionary stages of the Web, and recent technological trends provides valuable context for appreciating the internet's role today. Incorporating social impact considerations offers a more holistic view of this transformative technology. + + --- + + *Note: This report would benefit from citations to authoritative sources for historical facts and technical explanations to enhance credibility and provide readers with avenues for further research.* + + + diff --git a/.tmp/agent/anthropic_agent.md b/.tmp/agent/anthropic_agent.md new file mode 100644 index 0000000..1eb3e55 --- /dev/null +++ b/.tmp/agent/anthropic_agent.md @@ -0,0 +1,213 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/anthropic_agent.ipynb +toc: True +title: "Function Calling Anthropic Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our Anthropic agent, powered by function calling capabilities. + +**NOTE:** Only claude-3* models support function calling using Anthropic's API. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the Anthropic API (using our own `llama_index` LLM class) +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + + +```python +%pip install llama-index +%pip install llama-index-llms-anthropic +%pip install llama-index-embeddings-openai +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Make sure your ANTHROPIC_API_KEY is set. Otherwise explicitly specify the `api_key` parameter. + + +```python +from llama_index.llms.anthropic import Anthropic + +llm = Anthropic(model="claude-3-opus-20240229", api_key="sk-...") +``` + +## Initialize Anthropic Agent + +Here we initialize a simple Mistral agent with calculator functions. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + + +```python +from llama_index.core.agent.workflow import ToolCallResult + + +async def run_agent_verbose(query: str): + handler = agent.run(query) + async for event in handler.stream_events(): + if isinstance(event, ToolCallResult): + print( + f"Called tool {event.tool_name} with args {event.tool_kwargs}\nGot result: {event.tool_output}" + ) + + return await handler +``` + +### Chat + + +```python +response = await run_agent_verbose("What is (121 + 2) * 5?") +print(str(response)) +``` + + Called tool add with args {'a': 121, 'b': 2} + Got result: 123 + Called tool multiply with args {'a': 123, 'b': 5} + Got result: 615 + Therefore, (121 + 2) * 5 = 615 + + + +```python +# inspect sources +print(response.tool_calls) +``` + + [ToolCallResult(tool_name='add', tool_kwargs={'a': 121, 'b': 2}, tool_id='toolu_01MH6ME7ppxGPSJcCMEUAN5Q', tool_output=ToolOutput(content='123', tool_name='add', raw_input={'args': (), 'kwargs': {'a': 121, 'b': 2}}, raw_output=123, is_error=False), return_direct=False), ToolCallResult(tool_name='multiply', tool_kwargs={'a': 123, 'b': 5}, tool_id='toolu_01JE5TVERND5YC97E68gYoPw', tool_output=ToolOutput(content='615', tool_name='multiply', raw_input={'args': (), 'kwargs': {'a': 123, 'b': 5}}, raw_output=615, is_error=False), return_direct=False)] + + +### Managing Context/Memory + +By default, `.run()` is stateless. If you want to maintain state, you can pass in a `context` object. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) + +response = await agent.run("My name is John Doe", ctx=ctx) +response = await agent.run("What is my name?", ctx=ctx) + +print(str(response)) +``` + +## Anthropic Agent over RAG Pipeline + +Build a Anthropic agent over a simple 10K document. We use OpenAI embeddings and claude-3-haiku-20240307 to construct the RAG pipeline, and pass it to the Anthropic Opus agent as a tool. + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +``` + + --2025-03-24 12:52:55-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1880483 (1.8M) [application/octet-stream] + Saving to: ‘data/10k/uber_2021.pdf’ + + data/10k/uber_2021. 100%[===================>] 1.79M 8.98MB/s in 0.2s + + 2025-03-24 12:52:56 (8.98 MB/s) - ‘data/10k/uber_2021.pdf’ saved [1880483/1880483] + + + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.llms.anthropic import Anthropic + +embed_model = OpenAIEmbedding( + model_name="text-embedding-3-large", api_key="sk-proj-..." +) +query_llm = Anthropic(model="claude-3-haiku-20240307", api_key="sk-...") + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() + +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=query_llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent(tools=[query_engine_tool], llm=llm, verbose=True) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber?" +) +print(str(response)) +``` + + In summary, based on Uber's 2021 10-K filing, some of the company's key risk factors included: + + - Significant expected increases in operating expenses + - Challenges attracting and retaining drivers, consumers, merchants, shippers, and carriers + - Risks to Uber's brand and reputation + - Challenges from Uber's historical workplace culture + - Difficulties optimizing organizational structure and managing growth + - Risks related to criminal activity by platform users + - Risks from new offerings and technologies like autonomous vehicles + - Data security and privacy risks + - Climate change exposure + - Reliance on third-party platforms + - Regulatory and legal risks + - Intellectual property risks + + In terms of growth opportunities and tailwinds, Uber's strategy in 2021 focused on restructuring by divesting certain markets and business lines, and instead partnering with and taking minority ownership positions in local ridesharing and delivery companies in those markets. This suggests Uber saw opportunities to still participate in the growth of those markets through its investments, rather than operating independently. + diff --git a/.tmp/agent/bedrock_converse_agent.md b/.tmp/agent/bedrock_converse_agent.md new file mode 100644 index 0000000..ad198a3 --- /dev/null +++ b/.tmp/agent/bedrock_converse_agent.md @@ -0,0 +1,157 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/bedrock_converse_agent.ipynb +toc: True +title: "Function Calling AWS Bedrock Converse Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our AWS Bedrock Converse agent, powered by function calling capabilities. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. AWS credentials with access to Bedrock and the Claude Haiku LLM +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + + +```python +%pip install llama-index +%pip install llama-index-llms-bedrock-converse +%pip install llama-index-embeddings-huggingface +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Make sure to set your AWS credentials, either the `profile_name` or the keys below. + + +```python +from llama_index.llms.bedrock_converse import BedrockConverse + +llm = BedrockConverse( + model="anthropic.claude-3-haiku-20240307-v1:0", + # NOTE replace with your own AWS credentials + aws_access_key_id="AWS Access Key ID to use", + aws_secret_access_key="AWS Secret Access Key to use", + aws_session_token="AWS Session Token to use", + region_name="AWS Region to use, eg. us-east-1", +) +``` + +## Initialize AWS Bedrock Converse Agent + +Here we initialize a simple AWS Bedrock Converse agent with calculator functions. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + +### Chat + + +```python +response = await agent.run("What is (121 + 2) * 5?") +print(str(response)) +``` + + +```python +# inspect sources +print(response.tool_calls) +``` + +## AWS Bedrock Converse Agent over RAG Pipeline + +Build an AWS Bedrock Converse agent over a simple 10K document. We use both HuggingFace embeddings and `BAAI/bge-small-en-v1.5` to construct the RAG pipeline, and pass it to the AWS Bedrock Converse agent as a tool. + + +```python +!mkdir -p 'data/10k/' +!curl -o 'data/10k/uber_2021.pdf' 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.embeddings.huggingface import HuggingFaceEmbedding +from llama_index.llms.bedrock_converse import BedrockConverse + +embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5") +query_llm = BedrockConverse( + model="anthropic.claude-3-haiku-20240307-v1:0", + # NOTE replace with your own AWS credentials + aws_access_key_id="AWS Access Key ID to use", + aws_secret_access_key="AWS Secret Access Key to use", + aws_session_token="AWS Session Token to use", + region_name="AWS Region to use, eg. us-east-1", +) + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() + +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=query_llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[query_engine_tool], + llm=llm, +) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls." +) +``` + + +```python +print(str(response)) +``` diff --git a/.tmp/agent/code_act_agent.md b/.tmp/agent/code_act_agent.md new file mode 100644 index 0000000..4f22073 --- /dev/null +++ b/.tmp/agent/code_act_agent.md @@ -0,0 +1,369 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/code_act_agent.ipynb +toc: True +title: "Prebuilt CodeAct Agent w/ LlamaIndex" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +LlamaIndex offers a prebuilt CodeAct Agent that can be used to write and execute code, inspired by the original [CodeAct paper](https://arxiv.org/abs/2402.01030). + +With this agent, you provide an agent with a set of functions, and the agent will write code that uses those functions to help complete the task you give it. + +Some advantages of using the CodeAct Agent: + +- No need to exhaustively list out all the possible functions that the agent might need +- The agent can develop complex workflows around your existing functions +- Can integrate directly with existing API's + +Let's walk through a simple example of how to use the CodeAct Agent. + +**NOTE:** This example includes code that will execute arbitrary code. This is dangerous, and proper sandboxing should be used in production environments. + +## Setup + +First, let's configure the LLM we want to use, and provide some functions that we can use in our code. + + +```python +%pip install -U llama-index-core llama-index-llms-ollama +``` + + +```python +from llama_index.llms.openai import OpenAI + +# Configure the LLM +llm = OpenAI(model="gpt-4o-mini", api_key="sk-...") + + +# Define a few helper functions +def add(a: int, b: int) -> int: + """Add two numbers together""" + return a + b + + +def subtract(a: int, b: int) -> int: + """Subtract two numbers""" + return a - b + + +def multiply(a: int, b: int) -> int: + """Multiply two numbers""" + return a * b + + +def divide(a: int, b: int) -> float: + """Divide two numbers""" + return a / b +``` + +## Create a Code Executor + +The `CodeActAgent` will require a specific `code_execute_fn` to execute the code generated by the agent. + +Below, we define a simple `code_execute_fn` that will execute the code in-process and maintain execution state. + +**NOTE:** In a production environment, you should use a more robust method of executing code. This is just for demonstration purposes, and executing code in-process is dangerous. Consider using docker or external services to execute code. + +With this executor, we can pass in a dictionary of local and global variables to use in the execution context. + +- `locals`: Local variables to use in the execution context, this includes our functions that we want the LLM to code around +- `globals`: Global variables to use in the execution context, this includes the builtins and other imported modules we want to use in the execution context + + +```python +from typing import Any, Dict, Tuple +import io +import contextlib +import ast +import traceback + + +class SimpleCodeExecutor: + """ + A simple code executor that runs Python code with state persistence. + + This executor maintains a global and local state between executions, + allowing for variables to persist across multiple code runs. + + NOTE: not safe for production use! Use with caution. + """ + + def __init__(self, locals: Dict[str, Any], globals: Dict[str, Any]): + """ + Initialize the code executor. + + Args: + locals: Local variables to use in the execution context + globals: Global variables to use in the execution context + """ + # State that persists between executions + self.globals = globals + self.locals = locals + + def execute(self, code: str) -> Tuple[bool, str, Any]: + """ + Execute Python code and capture output and return values. + + Args: + code: Python code to execute + + Returns: + Dict with keys `success`, `output`, and `return_value` + """ + # Capture stdout and stderr + stdout = io.StringIO() + stderr = io.StringIO() + + output = "" + return_value = None + try: + # Execute with captured output + with contextlib.redirect_stdout( + stdout + ), contextlib.redirect_stderr(stderr): + # Try to detect if there's a return value (last expression) + try: + tree = ast.parse(code) + last_node = tree.body[-1] if tree.body else None + + # If the last statement is an expression, capture its value + if isinstance(last_node, ast.Expr): + # Split code to add a return value assignment + last_line = code.rstrip().split("\n")[-1] + exec_code = ( + code[: -len(last_line)] + + "\n__result__ = " + + last_line + ) + + # Execute modified code + exec(exec_code, self.globals, self.locals) + return_value = self.locals.get("__result__") + else: + # Normal execution + exec(code, self.globals, self.locals) + except: + # If parsing fails, just execute the code as is + exec(code, self.globals, self.locals) + + # Get output + output = stdout.getvalue() + if stderr.getvalue(): + output += "\n" + stderr.getvalue() + + except Exception as e: + # Capture exception information + output = f"Error: {type(e).__name__}: {str(e)}\n" + output += traceback.format_exc() + + if return_value is not None: + output += "\n\n" + str(return_value) + + return output +``` + + +```python +code_executor = SimpleCodeExecutor( + # give access to our functions defined above + locals={ + "add": add, + "subtract": subtract, + "multiply": multiply, + "divide": divide, + }, + globals={ + # give access to all builtins + "__builtins__": __builtins__, + # give access to numpy + "np": __import__("numpy"), + }, +) +``` + +## Setup the CodeAct Agent + +Now that we have our code executor, we can setup the CodeAct Agent. + + + +```python +from llama_index.core.agent.workflow import CodeActAgent +from llama_index.core.workflow import Context + +agent = CodeActAgent( + code_execute_fn=code_executor.execute, + llm=llm, + tools=[add, subtract, multiply, divide], +) + +# context to hold the agent's session/state/chat history +ctx = Context(agent) +``` + +## Use the Agent + +Now that we have our agent, we can use it to complete tasks! Since we gave it some math functions, we will prompt it for tasks that require calculations. + + +```python +from llama_index.core.agent.workflow import ( + ToolCall, + ToolCallResult, + AgentStream, +) + + +async def run_agent_verbose(agent, ctx, query): + handler = agent.run(query, ctx=ctx) + print(f"User: {query}") + async for event in handler.stream_events(): + if isinstance(event, ToolCallResult): + print( + f"\n-----------\nCode execution result:\n{event.tool_output}" + ) + elif isinstance(event, ToolCall): + print(f"\n-----------\nParsed code:\n{event.tool_kwargs['code']}") + elif isinstance(event, AgentStream): + print(f"{event.delta}", end="", flush=True) + + return await handler +``` + +Here, the agent uses some built-in functions to calculate the sum of all numbers from 1 to 10. + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of all numbers from 1 to 10" +) +``` + + User: Calculate the sum of all numbers from 1 to 10 + The sum of all numbers from 1 to 10 can be calculated using the formula for the sum of an arithmetic series. However, I will compute it directly for you. + + + # Calculate the sum of numbers from 1 to 10 + total_sum = sum(range(1, 11)) + print(total_sum) + + ----------- + Parsed code: + # Calculate the sum of numbers from 1 to 10 + total_sum = sum(range(1, 11)) + print(total_sum) + + ----------- + Code execution result: + 55 + + The sum of all numbers from 1 to 10 is 55. + +Next, we get the agent to use the tools that we passed in. + + +```python +response = await run_agent_verbose( + agent, ctx, "Add 5 and 3, then multiply the result by 2" +) +``` + + User: Add 5 and 3, then multiply the result by 2 + I will perform the addition of 5 and 3, and then multiply the result by 2. + + + # Perform the calculation + addition_result = add(5, 3) + final_result = multiply(addition_result, 2) + print(final_result) + + ----------- + Parsed code: + # Perform the calculation + addition_result = add(5, 3) + final_result = multiply(addition_result, 2) + print(final_result) + + ----------- + Code execution result: + 16 + + The result of adding 5 and 3, then multiplying by 2, is 16. + +We can even get the agent to define new functions for us! + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 10 fibonacci numbers" +) +``` + + User: Calculate the sum of the first 10 fibonacci numbers + I will calculate the sum of the first 10 Fibonacci numbers. + + + def fibonacci(n): + fib_sequence = [0, 1] + for i in range(2, n): + fib_sequence.append(fib_sequence[-1] + fib_sequence[-2]) + return fib_sequence + + # Calculate the sum of the first 10 Fibonacci numbers + first_10_fib = fibonacci(10) + fibonacci_sum = sum(first_10_fib) + print(fibonacci_sum) + + ----------- + Parsed code: + def fibonacci(n): + fib_sequence = [0, 1] + for i in range(2, n): + fib_sequence.append(fib_sequence[-1] + fib_sequence[-2]) + return fib_sequence + + # Calculate the sum of the first 10 Fibonacci numbers + first_10_fib = fibonacci(10) + fibonacci_sum = sum(first_10_fib) + print(fibonacci_sum) + + ----------- + Code execution result: + 88 + + The sum of the first 10 Fibonacci numbers is 88. + +And then reuse those new functions in a new task! + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 20 fibonacci numbers" +) +``` + + User: Calculate the sum of the first 20 fibonacci numbers + I will calculate the sum of the first 20 Fibonacci numbers. + + + # Calculate the sum of the first 20 Fibonacci numbers + first_20_fib = fibonacci(20) + fibonacci_sum_20 = sum(first_20_fib) + print(fibonacci_sum_20) + + ----------- + Parsed code: + # Calculate the sum of the first 20 Fibonacci numbers + first_20_fib = fibonacci(20) + fibonacci_sum_20 = sum(first_20_fib) + print(fibonacci_sum_20) + + ----------- + Code execution result: + 10945 + + The sum of the first 20 Fibonacci numbers is 10,945. diff --git a/.tmp/agent/custom_multi_agent.md b/.tmp/agent/custom_multi_agent.md index 52b9365..c9c8fe9 100644 --- a/.tmp/agent/custom_multi_agent.md +++ b/.tmp/agent/custom_multi_agent.md @@ -1,11 +1,12 @@ --- layout: recipe -colab: https://colab.research.google.com/github/TuanaCelik/cookbooks-demo/blob/main/notebooks/agent/custom_multi_agent.ipynb +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/custom_multi_agent.ipynb toc: True title: "Custom Planning Multi-Agent System" featured: True experimental: False tags: ['Agent'] +language: py --- Open In Colab diff --git a/.tmp/agent/from_scratch_code_act_agent.md b/.tmp/agent/from_scratch_code_act_agent.md new file mode 100644 index 0000000..5ec6558 --- /dev/null +++ b/.tmp/agent/from_scratch_code_act_agent.md @@ -0,0 +1,505 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/from_scratch_code_act_agent.ipynb +toc: True +title: "Creating a CodeAct Agent From Scratch" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +While LlamaIndex provides a pre-built [CodeActAgent](https://docs.llamaindex.ai/en/stable/examples/agent/code_act_agent/), we can also create our own from scratch. + +This way, we can fully understand and customize the agent's behaviour beyond what is provided by the pre-built agent. + +In this notebook, we will +1. Create a workflow for generating and parsing code +2. Implement basic code execution +3. Add memory and state to the agent + +## Setting up Functions for our Agent + +If we want our agent to execute our code, we need to deine the code for it to execute! + +For now, let's use a few basic math functions. + + +```python +# Define a few helper functions +def add(a: int, b: int) -> int: + """Add two numbers together""" + return a + b + + +def subtract(a: int, b: int) -> int: + """Subtract two numbers""" + return a - b + + +def multiply(a: int, b: int) -> int: + """Multiply two numbers""" + return a * b + + +def divide(a: int, b: int) -> float: + """Divide two numbers""" + return a / b +``` + +## Creating a Code Executor + +In order to execute code, we need to create a code executor. + +Here, we will use a simple in-process code executor that maintains it's own state. + +**NOTE:** This is a simple example, and does not include proper sandboxing. In a production environment, you should use tools like docker or proper code sandboxing environments. + + +```python +from typing import Any, Dict, Tuple +import io +import contextlib +import ast +import traceback + + +class SimpleCodeExecutor: + """ + A simple code executor that runs Python code with state persistence. + + This executor maintains a global and local state between executions, + allowing for variables to persist across multiple code runs. + + NOTE: not safe for production use! Use with caution. + """ + + def __init__(self, locals: Dict[str, Any], globals: Dict[str, Any]): + """ + Initialize the code executor. + + Args: + locals: Local variables to use in the execution context + globals: Global variables to use in the execution context + """ + # State that persists between executions + self.globals = globals + self.locals = locals + + def execute(self, code: str) -> Tuple[bool, str, Any]: + """ + Execute Python code and capture output and return values. + + Args: + code: Python code to execute + + Returns: + Dict with keys `success`, `output`, and `return_value` + """ + # Capture stdout and stderr + stdout = io.StringIO() + stderr = io.StringIO() + + output = "" + return_value = None + try: + # Execute with captured output + with contextlib.redirect_stdout( + stdout + ), contextlib.redirect_stderr(stderr): + # Try to detect if there's a return value (last expression) + try: + tree = ast.parse(code) + last_node = tree.body[-1] if tree.body else None + + # If the last statement is an expression, capture its value + if isinstance(last_node, ast.Expr): + # Split code to add a return value assignment + last_line = code.rstrip().split("\n")[-1] + exec_code = ( + code[: -len(last_line)] + + "\n__result__ = " + + last_line + ) + + # Execute modified code + exec(exec_code, self.globals, self.locals) + return_value = self.locals.get("__result__") + else: + # Normal execution + exec(code, self.globals, self.locals) + except: + # If parsing fails, just execute the code as is + exec(code, self.globals, self.locals) + + # Get output + output = stdout.getvalue() + if stderr.getvalue(): + output += "\n" + stderr.getvalue() + + except Exception as e: + # Capture exception information + output = f"Error: {type(e).__name__}: {str(e)}\n" + output += traceback.format_exc() + + if return_value is not None: + output += "\n\n" + str(return_value) + + return output +``` + + +```python +code_executor = SimpleCodeExecutor( + # give access to our functions defined above + locals={ + "add": add, + "subtract": subtract, + "multiply": multiply, + "divide": divide, + }, + globals={ + # give access to all builtins + "__builtins__": __builtins__, + # give access to numpy + "np": __import__("numpy"), + }, +) +``` + +## Defining the CodeAct Agent + +Now, we can using LlamaIndex Workflows to define the workflow for our agent. + +The basic flow is: +- take in our prompt + chat history +- parse out the code to execute (if any) +- execute the code +- provide the output of the code execution back to the agent +- repeat until the agent is satisfied with the answer + +First, we can create the events in the workflow. + + +```python +from llama_index.core.llms import ChatMessage +from llama_index.core.workflow import Event + + +class InputEvent(Event): + input: list[ChatMessage] + + +class StreamEvent(Event): + delta: str + + +class CodeExecutionEvent(Event): + code: str +``` + +Next, we can define the workflow that orchestrates using these events. + + +```python +import inspect +import re +from typing import Any, Callable, List + +from llama_index.core.llms import ChatMessage, LLM +from llama_index.core.memory import ChatMemoryBuffer +from llama_index.core.tools.types import BaseTool +from llama_index.core.workflow import ( + Context, + Workflow, + StartEvent, + StopEvent, + step, +) +from llama_index.llms.openai import OpenAI + + +CODEACT_SYSTEM_PROMPT = """ +You are a helpful assistant that can execute code. + +Given the chat history, you can write code within ... tags to help the user with their question. + +In your code, you can reference any previously used variables or functions. + +The user has also provided you with some predefined functions: +{fn_str} + +To execute code, write the code between ... tags. +""" + + +class CodeActAgent(Workflow): + def __init__( + self, + fns: List[Callable], + code_execute_fn: Callable, + llm: LLM | None = None, + **workflow_kwargs: Any, + ) -> None: + super().__init__(**workflow_kwargs) + self.fns = fns or [] + self.code_execute_fn = code_execute_fn + self.llm = llm or OpenAI(model="gpt-4o-mini") + + # parse the functions into truncated function strings + self.fn_str = "\n\n".join( + f'def {fn.__name__}{str(inspect.signature(fn))}:\n """ {fn.__doc__} """\n ...' + for fn in self.fns + ) + self.system_message = ChatMessage( + role="system", + content=CODEACT_SYSTEM_PROMPT.format(fn_str=self.fn_str), + ) + + def _parse_code(self, response: str) -> str | None: + # find the code between ... tags + matches = re.findall(r"(.*?)", response, re.DOTALL) + if matches: + return "\n\n".join(matches) + + return None + + @step + async def prepare_chat_history( + self, ctx: Context, ev: StartEvent + ) -> InputEvent: + # check if memory is setup + memory = await ctx.store.get("memory", default=None) + if not memory: + memory = ChatMemoryBuffer.from_defaults(llm=self.llm) + + # get user input + user_input = ev.get("user_input") + if user_input is None: + raise ValueError("user_input kwarg is required") + user_msg = ChatMessage(role="user", content=user_input) + memory.put(user_msg) + + # get chat history + chat_history = memory.get() + + # update context + await ctx.store.set("memory", memory) + + # add the system message to the chat history and return + return InputEvent(input=[self.system_message, *chat_history]) + + @step + async def handle_llm_input( + self, ctx: Context, ev: InputEvent + ) -> CodeExecutionEvent | StopEvent: + chat_history = ev.input + + # stream the response + response_stream = await self.llm.astream_chat(chat_history) + async for response in response_stream: + ctx.write_event_to_stream(StreamEvent(delta=response.delta or "")) + + # save the final response, which should have all content + memory = await ctx.store.get("memory") + memory.put(response.message) + await ctx.store.set("memory", memory) + + # get the code to execute + code = self._parse_code(response.message.content) + + if not code: + return StopEvent(result=response) + else: + return CodeExecutionEvent(code=code) + + @step + async def handle_code_execution( + self, ctx: Context, ev: CodeExecutionEvent + ) -> InputEvent: + # execute the code + ctx.write_event_to_stream(ev) + output = self.code_execute_fn(ev.code) + + # update the memory + memory = await ctx.store.get("memory") + memory.put(ChatMessage(role="assistant", content=output)) + await ctx.store.set("memory", memory) + + # get the latest chat history and loop back to the start + chat_history = memory.get() + return InputEvent(input=[self.system_message, *chat_history]) +``` + +## Testing the CodeAct Agent + +Now, we can test out the CodeAct Agent! + +We'll create a simple agent and slowly build up the complexity with requests. + + +```python +from llama_index.core.workflow import Context + +agent = CodeActAgent( + fns=[add, subtract, multiply, divide], + code_execute_fn=code_executor.execute, + llm=OpenAI(model="gpt-4o-mini", api_key="sk-..."), +) + +# context to hold the agent's state / memory +ctx = Context(agent) +``` + + +```python +async def run_agent_verbose(agent: CodeActAgent, ctx: Context, query: str): + handler = agent.run(user_input=query, ctx=ctx) + print(f"User: {query}") + async for event in handler.stream_events(): + if isinstance(event, StreamEvent): + print(f"{event.delta}", end="", flush=True) + elif isinstance(event, CodeExecutionEvent): + print(f"\n-----------\nParsed code:\n{event.code}\n") + + return await handler +``` + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of all numbers from 1 to 10" +) +``` + + User: Calculate the sum of all numbers from 1 to 10 + To calculate the sum of all numbers from 1 to 10, we can use the `add` function in a loop. Here's how we can do it: + + + total_sum = 0 + for number in range(1, 11): + total_sum = add(total_sum, number) + total_sum + + ----------- + Parsed code: + + total_sum = 0 + for number in range(1, 11): + total_sum = add(total_sum, number) + total_sum + + + The sum of all numbers from 1 to 10 is 55. + + +```python +response = await run_agent_verbose( + agent, ctx, "Add 5 and 3, then multiply the result by 2" +) +``` + + User: Add 5 and 3, then multiply the result by 2 + To perform the calculation, we will first add 5 and 3 using the `add` function, and then multiply the result by 2 using the `multiply` function. Here's how we can do it: + + + result_addition = add(5, 3) + final_result = multiply(result_addition, 2) + final_result + + ----------- + Parsed code: + + result_addition = add(5, 3) + final_result = multiply(result_addition, 2) + final_result + + + The final result of adding 5 and 3, then multiplying by 2, is 16. + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 10 fibonacci numbers0" +) +``` + + User: Calculate the sum of the first 10 fibonacci numbers0 + To calculate the sum of the first 10 Fibonacci numbers, we first need to generate the Fibonacci sequence up to the 10th number and then sum those numbers. The Fibonacci sequence starts with 0 and 1, and each subsequent number is the sum of the two preceding ones. + + Here's how we can do it: + + + def fibonacci(n: int) -> int: + """ Return the nth Fibonacci number """ + if n == 0: + return 0 + elif n == 1: + return 1 + else: + a, b = 0, 1 + for _ in range(2, n + 1): + a, b = b, a + b + return b + + # Calculate the sum of the first 10 Fibonacci numbers + fibonacci_sum = 0 + for i in range(10): + fibonacci_sum = add(fibonacci_sum, fibonacci(i)) + + fibonacci_sum + + ----------- + Parsed code: + + def fibonacci(n: int) -> int: + """ Return the nth Fibonacci number """ + if n == 0: + return 0 + elif n == 1: + return 1 + else: + a, b = 0, 1 + for _ in range(2, n + 1): + a, b = b, a + b + return b + + # Calculate the sum of the first 10 Fibonacci numbers + fibonacci_sum = 0 + for i in range(10): + fibonacci_sum = add(fibonacci_sum, fibonacci(i)) + + fibonacci_sum + + + The sum of the first 10 Fibonacci numbers is 55. + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 20 fibonacci numbers" +) +``` + + User: Calculate the sum of the first 20 fibonacci numbers + To calculate the sum of the first 20 Fibonacci numbers, we can use the same approach as before, but this time we will iterate up to 20. Here's how we can do it: + + + # Calculate the sum of the first 20 Fibonacci numbers + fibonacci_sum_20 = 0 + for i in range(20): + fibonacci_sum_20 = add(fibonacci_sum_20, fibonacci(i)) + + fibonacci_sum_20 + + ----------- + Parsed code: + + # Calculate the sum of the first 20 Fibonacci numbers + fibonacci_sum_20 = 0 + for i in range(20): + fibonacci_sum_20 = add(fibonacci_sum_20, fibonacci(i)) + + fibonacci_sum_20 + + + The sum of the first 20 Fibonacci numbers is 6765. diff --git a/.tmp/agent/memory/chat_memory_buffer.md b/.tmp/agent/memory/chat_memory_buffer.md new file mode 100644 index 0000000..1753eb4 --- /dev/null +++ b/.tmp/agent/memory/chat_memory_buffer.md @@ -0,0 +1,99 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/chat_memory_buffer.ipynb +toc: True +title: "Chat Memory Buffer" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +The `ChatMemoryBuffer` is a memory buffer that simply stores the last X messages that fit into a token limit. + +%pip install llama-index-core + +## Setup + + +```python +from llama_index.core.memory import ChatMemoryBuffer + +memory = ChatMemoryBuffer.from_defaults(token_limit=40000) +``` + +## Using Standalone + + +```python +from llama_index.core.llms import ChatMessage + +chat_history = [ + ChatMessage(role="user", content="Hello, how are you?"), + ChatMessage(role="assistant", content="I'm doing well, thank you!"), +] + +# put a list of messages +memory.put_messages(chat_history) + +# put one message at a time +# memory.put_message(chat_history[0]) +``` + + +```python +# Get the last X messages that fit into a token limit +history = memory.get() +``` + + +```python +# Get all messages +all_history = memory.get_all() +``` + + +```python +# clear the memory +memory.reset() +``` + +## Using with Agents + +You can set the memory in any agent in the `.run()` method. + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-proj-..." +``` + + +```python +from llama_index.core.agent.workflow import ReActAgent, FunctionAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + + +memory = ChatMemoryBuffer.from_defaults(token_limit=40000) + +agent = FunctionAgent(tools=[], llm=OpenAI(model="gpt-4o-mini")) + +# context to hold the chat history/state +ctx = Context(agent) +``` + + +```python +resp = await agent.run("Hello, how are you?", ctx=ctx, memory=memory) +``` + + +```python +print(memory.get_all()) +``` + + [ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text='Hello, how are you?')]), ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text="Hello! I'm just a program, so I don't have feelings, but I'm here and ready to help you. How can I assist you today?")])] + diff --git a/.tmp/agent/memory/composable_memory.md b/.tmp/agent/memory/composable_memory.md new file mode 100644 index 0000000..2ab9bce --- /dev/null +++ b/.tmp/agent/memory/composable_memory.md @@ -0,0 +1,512 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/composable_memory.ipynb +toc: True +title: "Simple Composable Memory" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +In this notebook, we demonstrate how to inject multiple memory sources into an agent. Specifically, we use the `SimpleComposableMemory` which is comprised of a `primary_memory` as well as potentially several secondary memory sources (stored in `secondary_memory_sources`). The main difference is that `primary_memory` will be used as the main chat buffer for the agent, where as any retrieved messages from `secondary_memory_sources` will be injected to the system prompt message only. + +Multiple memory sources may be of use for example in situations where you have a longer-term memory such as `VectorMemory` that you want to use in addition to the default `ChatMemoryBuffer`. What you'll see in this notebook is that with a `SimpleComposableMemory` you'll be able to effectively "load" the desired messages from long-term memory into the main memory (i.e. the `ChatMemoryBuffer`). + +## How `SimpleComposableMemory` Works? + +We begin with the basic usage of the `SimpleComposableMemory`. Here we construct a `VectorMemory` as well as a default `ChatMemoryBuffer`. The `VectorMemory` will be our secondary memory source, whereas the `ChatMemoryBuffer` will be the main or primary one. To instantiate a `SimpleComposableMemory` object, we need to supply a `primary_memory` and (optionally) a list of `secondary_memory_sources`. + +![SimpleComposableMemoryIllustration](https://d3ddy8balm3goa.cloudfront.net/llamaindex/simple-composable-memory.excalidraw.svg) + + +```python +from llama_index.core.memory import ( + VectorMemory, + SimpleComposableMemory, + ChatMemoryBuffer, +) +from llama_index.core.llms import ChatMessage +from llama_index.embeddings.openai import OpenAIEmbedding + +vector_memory = VectorMemory.from_defaults( + vector_store=None, # leave as None to use default in-memory vector store + embed_model=OpenAIEmbedding(), + retriever_kwargs={"similarity_top_k": 1}, +) + +# let's set some initial messages in our secondary vector memory +msgs = [ + ChatMessage.from_str("You are a SOMEWHAT helpful assistant.", "system"), + ChatMessage.from_str("Bob likes burgers.", "user"), + ChatMessage.from_str("Indeed, Bob likes apples.", "assistant"), + ChatMessage.from_str("Alice likes apples.", "user"), +] +vector_memory.set(msgs) + +chat_memory_buffer = ChatMemoryBuffer.from_defaults() + +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=chat_memory_buffer, + secondary_memory_sources=[vector_memory], +) +``` + + +```python +composable_memory.primary_memory +``` + + + + + ChatMemoryBuffer(chat_store=SimpleChatStore(store={}), chat_store_key='chat_history', token_limit=3000, tokenizer_fn=functools.partial(>, allowed_special='all')) + + + + +```python +composable_memory.secondary_memory_sources +``` + + + + + [VectorMemory(vector_index=, retriever_kwargs={'similarity_top_k': 1}, batch_by_user_message=True, cur_batch_textnode=TextNode(id_='288b0ef3-570e-4698-a1ae-b3531df66361', embedding=None, metadata={'sub_dicts': [{'role': , 'content': 'Alice likes apples.', 'additional_kwargs': {}}]}, excluded_embed_metadata_keys=['sub_dicts'], excluded_llm_metadata_keys=['sub_dicts'], relationships={}, text='Alice likes apples.', start_char_idx=None, end_char_idx=None, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'))] + + + +### `put()` messages into memory + +Since `SimpleComposableMemory` is itself a subclass of `BaseMemory`, we add messages to it in the same way as we do for other memory modules. Note that for `SimpleComposableMemory`, invoking `.put()` effectively calls `.put()` on all memory sources. In other words, the message gets added to `primary` and `secondary` sources. + + +```python +msgs = [ + ChatMessage.from_str("You are a REALLY helpful assistant.", "system"), + ChatMessage.from_str("Jerry likes juice.", "user"), +] +``` + + +```python +# load into all memory sources modules" +for m in msgs: + composable_memory.put(m) +``` + +### `get()` messages from memory + +When `.get()` is invoked, we similarly execute all of the `.get()` methods of `primary` memory as well as all of the `secondary` sources. This leaves us with sequence of lists of messages that we have to must "compose" into a sensible single set of messages (to pass downstream to our agents). Special care must be applied here in general to ensure that the final sequence of messages are both sensible and conform to the chat APIs of the LLM provider. + +For `SimpleComposableMemory`, we **inject the messages from the `secondary` sources in the system message of the `primary` memory**. The rest of the message history of the `primary` source is left intact, and this composition is what is ultimately returned. + + +```python +msgs = composable_memory.get("What does Bob like?") +msgs +``` + + + + + [ChatMessage(role=, content='You are a REALLY helpful assistant.\n\nBelow are a set of relevant dialogues retrieved from potentially several memory sources:\n\n=====Relevant messages from memory source 1=====\n\n\tUSER: Bob likes burgers.\n\tASSISTANT: Indeed, Bob likes apples.\n\n=====End of relevant messages from memory source 1======\n\nThis is the end of the retrieved message dialogues.', additional_kwargs={}), + ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + + +```python +# see the memory injected into the system message of the primary memory +print(msgs[0]) +``` + + system: You are a REALLY helpful assistant. + + Below are a set of relevant dialogues retrieved from potentially several memory sources: + + =====Relevant messages from memory source 1===== + + USER: Bob likes burgers. + ASSISTANT: Indeed, Bob likes apples. + + =====End of relevant messages from memory source 1====== + + This is the end of the retrieved message dialogues. + + +### Successive calls to `get()` + +Successive calls of `get()` will simply replace the loaded `secondary` memory messages in the system prompt. + + +```python +msgs = composable_memory.get("What does Alice like?") +msgs +``` + + + + + [ChatMessage(role=, content='You are a REALLY helpful assistant.\n\nBelow are a set of relevant dialogues retrieved from potentially several memory sources:\n\n=====Relevant messages from memory source 1=====\n\n\tUSER: Alice likes apples.\n\n=====End of relevant messages from memory source 1======\n\nThis is the end of the retrieved message dialogues.', additional_kwargs={}), + ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + + +```python +# see the memory injected into the system message of the primary memory +print(msgs[0]) +``` + + system: You are a REALLY helpful assistant. + + Below are a set of relevant dialogues retrieved from potentially several memory sources: + + =====Relevant messages from memory source 1===== + + USER: Alice likes apples. + + =====End of relevant messages from memory source 1====== + + This is the end of the retrieved message dialogues. + + +### What if `get()` retrieves `secondary` messages that already exist in `primary` memory? + +In the event that messages retrieved from `secondary` memory already exist in `primary` memory, then these rather redundant secondary messages will not get added to the system message. In the below example, the message "Jerry likes juice." was `put` into all memory sources, so the system message is not altered. + + +```python +msgs = composable_memory.get("What does Jerry like?") +msgs +``` + + + + + [ChatMessage(role=, content='You are a REALLY helpful assistant.', additional_kwargs={}), + ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + +### How to `reset` memory + +Similar to the other methods `put()` and `get()`, calling `reset()` will execute `reset()` on both the `primary` and `secondary` memory sources. If you want to reset only the `primary` then you should call the `reset()` method only from it. + +#### `reset()` only primary memory + + +```python +composable_memory.primary_memory.reset() +``` + + +```python +composable_memory.primary_memory.get() +``` + + + + + [] + + + + +```python +composable_memory.secondary_memory_sources[0].get("What does Alice like?") +``` + + + + + [ChatMessage(role=, content='Alice likes apples.', additional_kwargs={})] + + + +#### `reset()` all memory sources + + +```python +composable_memory.reset() +``` + + +```python +composable_memory.primary_memory.get() +``` + + + + + [] + + + + +```python +composable_memory.secondary_memory_sources[0].get("What does Alice like?") +``` + + + + + [] + + + +## Use `SimpleComposableMemory` With An Agent + +Here we will use a `SimpleComposableMemory` with an agent and demonstrate how a secondary, long-term memory source can be used to use messages from on agent conversation as part of another conversation with another agent session. + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.core.tools import FunctionTool +from llama_index.core.agent import FunctionCallingAgent + +import nest_asyncio + +nest_asyncio.apply() +``` + +### Define our memory modules + + +```python +vector_memory = VectorMemory.from_defaults( + vector_store=None, # leave as None to use default in-memory vector store + embed_model=OpenAIEmbedding(), + retriever_kwargs={"similarity_top_k": 2}, +) + +chat_memory_buffer = ChatMemoryBuffer.from_defaults() + +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=chat_memory_buffer, + secondary_memory_sources=[vector_memory], +) +``` + +### Define our Agent + + +```python +def multiply(a: int, b: int) -> int: + """Multiply two integers and returns the result integer""" + return a * b + + +def mystery(a: int, b: int) -> int: + """Mystery function on two numbers""" + return a**2 - b**2 + + +multiply_tool = FunctionTool.from_defaults(fn=multiply) +mystery_tool = FunctionTool.from_defaults(fn=mystery) +``` + + +```python +llm = OpenAI(model="gpt-3.5-turbo-0613") +agent = FunctionCallingAgent.from_tools( + [multiply_tool, mystery_tool], + llm=llm, + memory=composable_memory, + verbose=True, +) +``` + +### Execute some function calls + +When `.chat()` is invoked, the messages are put into the composable memory, which we understand from the previous section implies that all the messages are put in both `primary` and `secondary` sources. + + +```python +response = agent.chat("What is the mystery function on 5 and 6?") +``` + + Added user message to memory: What is the mystery function on 5 and 6? + === Calling Function === + Calling function: mystery with args: {"a": 5, "b": 6} + === Function Output === + -11 + === LLM Response === + The mystery function on 5 and 6 returns -11. + + + +```python +response = agent.chat("What happens if you multiply 2 and 3?") +``` + + Added user message to memory: What happens if you multiply 2 and 3? + === Calling Function === + Calling function: multiply with args: {"a": 2, "b": 3} + === Function Output === + 6 + === LLM Response === + If you multiply 2 and 3, the result is 6. + + +### New Agent Sessions + +Now that we've added the messages to our `vector_memory`, we can see the effect of having this memory be used with a new agent session versus when it is used. Specifically, we ask the new agents to "recall" the outputs of the function calls, rather than re-computing. + +#### An Agent without our past memory + + +```python +llm = OpenAI(model="gpt-3.5-turbo-0613") +agent_without_memory = FunctionCallingAgent.from_tools( + [multiply_tool, mystery_tool], llm=llm, verbose=True +) +``` + + +```python +response = agent_without_memory.chat( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." +) +``` + + Added user message to memory: What was the output of the mystery function on 5 and 6 again? Don't recompute. + === LLM Response === + I'm sorry, but I don't have access to the previous output of the mystery function on 5 and 6. + + +#### An Agent with our past memory + +We see that the agent without access to the our past memory cannot complete the task. With this next agent we will indeed pass in our previous long-term memory (i.e., `vector_memory`). Note that we even use a fresh `ChatMemoryBuffer` which means there is no `chat_history` with this agent. Nonetheless, it will be able to retrieve from our long-term memory to get the past dialogue it needs. + + +```python +llm = OpenAI(model="gpt-3.5-turbo-0613") + +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=ChatMemoryBuffer.from_defaults(), + secondary_memory_sources=[ + vector_memory.copy( + deep=True + ) # using a copy here for illustration purposes + # later will use original vector_memory again + ], +) + +agent_with_memory = FunctionCallingAgent.from_tools( + [multiply_tool, mystery_tool], + llm=llm, + memory=composable_memory, + verbose=True, +) +``` + + +```python +agent_with_memory.chat_history # an empty chat history +``` + + + + + [] + + + + +```python +response = agent_with_memory.chat( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." +) +``` + + Added user message to memory: What was the output of the mystery function on 5 and 6 again? Don't recompute. + === LLM Response === + The output of the mystery function on 5 and 6 is -11. + + + +```python +response = agent_with_memory.chat( + "What was the output of the multiply function on 2 and 3 again? Don't recompute." +) +``` + + Added user message to memory: What was the output of the multiply function on 2 and 3 again? Don't recompute. + === LLM Response === + The output of the multiply function on 2 and 3 is 6. + + + +```python +agent_with_memory.chat_history +``` + + + + + [ChatMessage(role=, content="What was the output of the mystery function on 5 and 6 again? Don't recompute.", additional_kwargs={}), + ChatMessage(role=, content='The output of the mystery function on 5 and 6 is -11.', additional_kwargs={}), + ChatMessage(role=, content="What was the output of the multiply function on 2 and 3 again? Don't recompute.", additional_kwargs={}), + ChatMessage(role=, content='The output of the multiply function on 2 and 3 is 6.', additional_kwargs={})] + + + +### What happens under the hood with `.chat(user_input)` + +Under the hood, `.chat(user_input)` call effectively will call the memory's `.get()` method with `user_input` as the argument. As we learned in the previous section, this will ultimately return a composition of the `primary` and all of the `secondary` memory sources. These composed messages are what is being passed to the LLM's chat API as the chat history. + + +```python +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=ChatMemoryBuffer.from_defaults(), + secondary_memory_sources=[ + vector_memory.copy( + deep=True + ) # copy for illustrative purposes to explain what + # happened under the hood from previous subsection + ], +) +agent_with_memory = agent_worker.as_agent(memory=composable_memory) +``` + + +```python +agent_with_memory.memory.get( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." +) +``` + + + + + [ChatMessage(role=, content='You are a helpful assistant.\n\nBelow are a set of relevant dialogues retrieved from potentially several memory sources:\n\n=====Relevant messages from memory source 1=====\n\n\tUSER: What is the mystery function on 5 and 6?\n\tASSISTANT: None\n\tTOOL: -11\n\tASSISTANT: The mystery function on 5 and 6 returns -11.\n\n=====End of relevant messages from memory source 1======\n\nThis is the end of the retrieved message dialogues.', additional_kwargs={})] + + + + +```python +print( + agent_with_memory.memory.get( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." + )[0] +) +``` + + system: You are a helpful assistant. + + Below are a set of relevant dialogues retrieved from potentially several memory sources: + + =====Relevant messages from memory source 1===== + + USER: What is the mystery function on 5 and 6? + ASSISTANT: None + TOOL: -11 + ASSISTANT: The mystery function on 5 and 6 returns -11. + + =====End of relevant messages from memory source 1====== + + This is the end of the retrieved message dialogues. + diff --git a/.tmp/agent/memory/summary_memory_buffer.md b/.tmp/agent/memory/summary_memory_buffer.md new file mode 100644 index 0000000..e43fd62 --- /dev/null +++ b/.tmp/agent/memory/summary_memory_buffer.md @@ -0,0 +1,110 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/summary_memory_buffer.ipynb +toc: True +title: "Chat Summary Memory Buffer" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +The `ChatSummaryMemoryBuffer` is a memory buffer that stores the last X messages that fit into a token limit. It also summarizes the chat history into a single message. + + + +```python +%pip install llama-index-core +``` + +## Setup + + +```python +from llama_index.core.memory import ChatSummaryMemoryBuffer + +memory = ChatSummaryMemoryBuffer.from_defaults( + token_limit=40000, + # optional set the summary prompt, here's the default: + # summarize_prompt=( + # "The following is a conversation between the user and assistant. " + # "Write a concise summary about the contents of this conversation." + # ) +) +``` + +## Using Standalone + + +```python +from llama_index.core.llms import ChatMessage + +chat_history = [ + ChatMessage(role="user", content="Hello, how are you?"), + ChatMessage(role="assistant", content="I'm doing well, thank you!"), +] + +# put a list of messages +memory.put_messages(chat_history) + +# put one message at a time +# memory.put_message(chat_history[0]) +``` + + +```python +# Get the last X messages that fit into a token limit +history = memory.get() +``` + + +```python +# Get all messages +all_history = memory.get_all() +``` + + +```python +# clear the memory +memory.reset() +``` + +## Using with Agents + +You can set the memory in any agent in the `.run()` method. + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-proj-..." +``` + + +```python +from llama_index.core.agent.workflow import ReActAgent, FunctionAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + + +memory = ChatMemoryBuffer.from_defaults(token_limit=40000) + +agent = FunctionAgent(tools=[], llm=OpenAI(model="gpt-4o-mini")) + +# context to hold the chat history/state +ctx = Context(agent) +``` + + +```python +resp = await agent.run("Hello, how are you?", ctx=ctx, memory=memory) +``` + + +```python +print(memory.get_all()) +``` + + [ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text='Hello, how are you?')]), ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text="Hello! I'm just a program, so I don't have feelings, but I'm here and ready to help you. How can I assist you today?")])] + diff --git a/.tmp/agent/memory/vector_memory.md b/.tmp/agent/memory/vector_memory.md new file mode 100644 index 0000000..363001e --- /dev/null +++ b/.tmp/agent/memory/vector_memory.md @@ -0,0 +1,100 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/vector_memory.ipynb +toc: True +title: "Vector Memory" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +The vector memory module uses vector search (backed by a vector db) to retrieve relevant conversation items given a user input. + +This notebook shows you how to use the `VectorMemory` class. We show you how to use its individual functions. A typical usecase for vector memory is as a long-term memory storage of chat messages. You can + +![VectorMemoryIllustration](https://d3ddy8balm3goa.cloudfront.net/llamaindex/vector-memory.excalidraw.svg) + +### Initialize and Experiment with Memory Module + +Here we initialize a raw memory module and demonstrate its functions - to put and retrieve from ChatMessage objects. + +- Note that `retriever_kwargs` is the same args you'd specify on the `VectorIndexRetriever` or from `index.as_retriever(..)`. + + +```python +from llama_index.core.memory import VectorMemory +from llama_index.embeddings.openai import OpenAIEmbedding + + +vector_memory = VectorMemory.from_defaults( + vector_store=None, # leave as None to use default in-memory vector store + embed_model=OpenAIEmbedding(), + retriever_kwargs={"similarity_top_k": 1}, +) +``` + + +```python +from llama_index.core.llms import ChatMessage + +msgs = [ + ChatMessage.from_str("Jerry likes juice.", "user"), + ChatMessage.from_str("Bob likes burgers.", "user"), + ChatMessage.from_str("Alice likes apples.", "user"), +] +``` + + +```python +# load into memory +for m in msgs: + vector_memory.put(m) +``` + + +```python +# retrieve from memory +msgs = vector_memory.get("What does Jerry like?") +msgs +``` + + + + + [ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + + +```python +vector_memory.reset() +``` + +Now let's try resetting and trying again. This time, we'll add an assistant message. Note that user/assistant messages are bundled by default. + + +```python +msgs = [ + ChatMessage.from_str("Jerry likes burgers.", "user"), + ChatMessage.from_str("Bob likes apples.", "user"), + ChatMessage.from_str("Indeed, Bob likes apples.", "assistant"), + ChatMessage.from_str("Alice likes juice.", "user"), +] +vector_memory.set(msgs) +``` + + +```python +msgs = vector_memory.get("What does Bob like?") +msgs +``` + + + + + [ChatMessage(role=, content='Bob likes apples.', additional_kwargs={}), + ChatMessage(role=, content='Indeed, Bob likes apples.', additional_kwargs={})] + + diff --git a/.tmp/agent/mistral_agent.md b/.tmp/agent/mistral_agent.md new file mode 100644 index 0000000..dd65d1b --- /dev/null +++ b/.tmp/agent/mistral_agent.md @@ -0,0 +1,186 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/mistral_agent.ipynb +toc: True +title: "Function Calling Mistral Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our Mistral agent, powered by function calling capabilities. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the OpenAI API (using our own `llama_index` LLM class) +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + + +```python +%pip install llama-index +%pip install llama-index-llms-mistralai +%pip install llama-index-embeddings-mistralai +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Make sure your MISTRAL_API_KEY is set. Otherwise explicitly specify the `api_key` parameter. + + +```python +from llama_index.llms.mistralai import MistralAI + +llm = MistralAI(model="mistral-large-latest", api_key="...") +``` + +## Initialize Mistral Agent + +Here we initialize a simple Mistral agent with calculator functions. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + +### Chat + + +```python +response = await agent.run("What is (121 + 2) * 5?") +print(str(response)) +``` + + Added user message to memory: What is (121 + 2) * 5? + === Calling Function === + Calling function: add with args: {"a": 121, "b": 2} + === Calling Function === + Calling function: multiply with args: {"a": 123, "b": 5} + assistant: The result of (121 + 2) * 5 is 615. + + + +```python +# inspect sources +print(response.tool_calls) +``` + +### Managing Context/Memory + +By default, `.run()` is stateless. If you want to maintain state, you can pass in a `context` object. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) + +response = await agent.run("My name is John Doe", ctx=ctx) +response = await agent.run("What is my name?", ctx=ctx) + +print(str(response)) +``` + +## Mistral Agent over RAG Pipeline + +Build a Mistral agent over a simple 10K document. We use both Mistral embeddings and mistral-medium to construct the RAG pipeline, and pass it to the Mistral agent as a tool. + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.embeddings.mistralai import MistralAIEmbedding +from llama_index.llms.mistralai import MistralAI + +embed_model = MistralAIEmbedding(api_key="...") +query_llm = MistralAI(model="mistral-medium", api_key="...") + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=query_llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent(tools=[query_engine_tool], llm=llm) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls." +) +print(str(response)) +``` + + Added user message to memory: Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls. + === Calling Function === + Calling function: uber_10k with args: {"input": "What are the risk factors for Uber in 2021?"} + === Calling Function === + Calling function: uber_10k with args: {"input": "What are the tailwinds for Uber in 2021?"} + assistant: Based on the information provided, here are the risk factors for Uber in 2021: + + 1. Failure to offer or develop autonomous vehicle technologies, which could result in inferior performance or safety concerns compared to competitors. + 2. Dependence on high-quality personnel and the potential impact of attrition or unsuccessful succession planning on the business. + 3. Security or data privacy breaches, unauthorized access, or destruction of proprietary, employee, or user data. + 4. Cyberattacks, such as malware, ransomware, viruses, spamming, and phishing attacks, which could harm the company's reputation and operations. + 5. Climate change risks, including physical and transitional risks, that may adversely impact the business if not managed effectively. + 6. Reliance on third parties to maintain open marketplaces for distributing products and providing software, which could negatively affect the business if interfered with. + 7. The need for additional capital to support business growth, which may not be available on reasonable terms or at all. + 8. Difficulties in identifying, acquiring, and integrating suitable businesses, which could harm operating results and prospects. + 9. Legal and regulatory risks, including extensive government regulation and oversight related to payment and financial services. + 10. Intellectual property risks, such as the inability to protect intellectual property or claims of misappropriation by third parties. + 11. Volatility in the market price of common stock, which could result in steep declines and loss of investment for shareholders. + 12. Economic risks related to the COVID-19 pandemic, which has adversely impacted and could continue to adversely impact the business, financial condition, and results of operations. + 13. The potential reclassification of Drivers as employees, workers, or quasi-employees, which could result in material costs associated with defending, settling, or resolving lawsuits and demands for arbitration. + + On the other hand, here are some tailwinds for Uber in 2021: + + 1. Launch of Uber One, a single cross-platform membership program in the United States, which offers discounts, special pricing, priority service, and exclusive perks across rides, delivery, and grocery offerings. + 2. Introduction of a "Super App" view on iOS + diff --git a/.tmp/agent/multi_agent_workflow_with_weaviate_queryagent.md b/.tmp/agent/multi_agent_workflow_with_weaviate_queryagent.md new file mode 100644 index 0000000..7fe6da3 --- /dev/null +++ b/.tmp/agent/multi_agent_workflow_with_weaviate_queryagent.md @@ -0,0 +1,706 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/multi_agent_workflow_with_weaviate_queryagent.ipynb +toc: True +title: "Multi-Agent Workflow with Weaviate QueryAgent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +Open In Colab + +In this example, we will be building a LlamaIndex Agent Workflow that ends up being a multi-agent system that aims to be a Docs Assistant capable of: +- Writing new content to a "LlamaIndexDocs" collection in Weaviate +- Writing new content to a "WeaviateDocs" collection in Weaviate +- Using the Weaviate [`QueryAgent`](https://weaviate.io/developers/agents/query) to answer questions based on the contents of these collections. + +The `QueryAgent` is a full agent prodcut by Weaviate, that is capable of doing regular search, as well as aggregations over the collections you give it access to. Our 'orchestrator' agent will decide when to invoke the Weaviate QueryAgent, leaving the job of creating Weaviate specific search queries to it. + +**Things you will need:** + +- An OpenAI API key (or switch to another provider and adjust the code below) +- A Weaviate sandbox (this is free) +- Your Weaviate sandbox URL and API key + +![Workflow Overview](../_static/agents/workflow-weaviate-multiagent.png) + +## Install & Import Dependencies + + +```python +!pip install llama-index-core llama-index-utils-workflow weaviate-client[agents] llama-index-llms-openai llama-index-readers-web +``` + + +```python +from llama_index.core.workflow import ( + StartEvent, + StopEvent, + Workflow, + step, + Event, + Context, +) +from llama_index.utils.workflow import draw_all_possible_flows +from llama_index.readers.web import SimpleWebPageReader +from llama_index.core.llms import ChatMessage +from llama_index.core.tools import FunctionTool +from llama_index.llms.openai import OpenAI +from llama_index.core.agent.workflow import FunctionAgent + +from enum import Enum +from pydantic import BaseModel, Field +from llama_index.llms.openai import OpenAI +from typing import List, Union +import json + +import weaviate +from weaviate.auth import Auth +from weaviate.agents.query import QueryAgent +from weaviate.classes.config import Configure, Property, DataType + +import os +from getpass import getpass +``` + +## Set up Weaviate + +To use the Weaviate Query Agent, first, create a [Weaviate Cloud](https://weaviate.io/deployment/serverless) account👇 +1. [Create Serverless Weaviate Cloud account](https://weaviate.io/deployment/serverless) and set up a free [Sandbox](https://weaviate.io/developers/wcs/manage-clusters/create#sandbox-clusters) +2. Go to 'Embedding' and enable it, by default, this will make it so that we use `Snowflake/snowflake-arctic-embed-l-v2.0` as the embedding model +3. Take note of the `WEAVIATE_URL` and `WEAVIATE_API_KEY` to connect to your cluster below + +> Info: We recommend using [Weaviate Embeddings](https://weaviate.io/developers/weaviate/model-providers/weaviate) so you do not have to provide any extra keys for external embedding providers. + + +```python +if "WEAVIATE_API_KEY" not in os.environ: + os.environ["WEAVIATE_API_KEY"] = getpass("Add Weaviate API Key") +if "WEAVIATE_URL" not in os.environ: + os.environ["WEAVIATE_URL"] = getpass("Add Weaviate URL") +``` + + +```python +client = weaviate.connect_to_weaviate_cloud( + cluster_url=os.environ.get("WEAVIATE_URL"), + auth_credentials=Auth.api_key(os.environ.get("WEAVIATE_API_KEY")), +) +``` + +### Create WeaviateDocs and LlamaIndexDocs Collections + +The helper function below will create a "WeaviateDocs" and "LlamaIndexDocs" collection in Weaviate (if they don't exist already). It will also set up a `QueryAgent` that has access to both of these collections. + +The Weaviate [`QueryAgent`](https://weaviate.io/blog/query-agent) is designed to be able to query Weviate Collections for both regular search and aggregations, and also handles the burden of creating the Weaviate specific queries internally. + +The Agent will use the collection descriptions, as well as the property descriptions while formilating the queries. + + +```python +def fresh_setup_weaviate(client): + if client.collections.exists("WeaviateDocs"): + client.collections.delete("WeaviateDocs") + client.collections.create( + "WeaviateDocs", + description="A dataset with the contents of Weaviate technical Docs and website", + vectorizer_config=Configure.Vectorizer.text2vec_weaviate(), + properties=[ + Property( + name="url", + data_type=DataType.TEXT, + description="the source URL of the webpage", + ), + Property( + name="text", + data_type=DataType.TEXT, + description="the content of the webpage", + ), + ], + ) + + if client.collections.exists("LlamaIndexDocs"): + client.collections.delete("LlamaIndexDocs") + client.collections.create( + "LlamaIndexDocs", + description="A dataset with the contents of LlamaIndex technical Docs and website", + vectorizer_config=Configure.Vectorizer.text2vec_weaviate(), + properties=[ + Property( + name="url", + data_type=DataType.TEXT, + description="the source URL of the webpage", + ), + Property( + name="text", + data_type=DataType.TEXT, + description="the content of the webpage", + ), + ], + ) + + agent = QueryAgent( + client=client, collections=["LlamaIndexDocs", "WeaviateDocs"] + ) + return agent +``` + +### Write Contents of Webpage to the Collections + +The helper function below uses the `SimpleWebPageReader` to write the contents of a webpage to the relevant Weaviate collection + + +```python +def write_webpages_to_weaviate(client, urls: list[str], collection_name: str): + documents = SimpleWebPageReader(html_to_text=True).load_data(urls) + collection = client.collections.get(collection_name) + with collection.batch.dynamic() as batch: + for doc in documents: + batch.add_object(properties={"url": doc.id_, "text": doc.text}) +``` + +## Create a Function Calling Agent + +Now that we have the relevant functions to write to a collection and also the `QueryAgent` at hand, we can start by using the `FunctionAgent`, which is a simple tool calling agent. + + +```python +if "OPENAI_API_KEY" not in os.environ: + os.environ["OPENAI_API_KEY"] = getpass("openai-key") +``` + + +```python +weaviate_agent = fresh_setup_weaviate(client) +``` + + +```python +llm = OpenAI(model="gpt-4o-mini") + + +def write_to_weaviate_collection(urls=list[str]): + """Useful for writing new content to the WeaviateDocs collection""" + write_webpages_to_weaviate(client, urls, "WeaviateDocs") + + +def write_to_li_collection(urls=list[str]): + """Useful for writing new content to the LlamaIndexDocs collection""" + write_webpages_to_weaviate(client, urls, "LlamaIndexDocs") + + +def query_agent(query: str) -> str: + """Useful for asking questions about Weaviate and LlamaIndex""" + response = weaviate_agent.run(query) + return response.final_answer + + +agent = FunctionAgent( + tools=[write_to_weaviate_collection, write_to_li_collection, query_agent], + llm=llm, + system_prompt="""You are a helpful assistant that can write the + contents of urls to WeaviateDocs and LlamaIndexDocs collections, + as well as forwarding questions to a QueryAgent""", +) +``` + + +```python +response = await agent.run( + user_msg="Can you save https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic/" +) +print(str(response)) +``` + + +```python +response = await agent.run( + user_msg="""What are llama index workflows? And can you save + these to weaviate docs: https://weaviate.io/blog/what-are-agentic-workflows + and https://weaviate.io/blog/ai-agents""" +) +print(str(response)) +``` + + Llama Index workflows refer to orchestrations involving one or more AI agents within the LlamaIndex framework. These workflows manage complex tasks dynamically by leveraging components such as large language models (LLMs), tools, and memory states. Key features of Llama Index workflows include: + + - Support for single or multiple agents managed within an AgentWorkflow orchestrator. + - Ability to maintain state across runs via serializable context objects. + - Integration of external tools with type annotations, including asynchronous functions. + - Streaming of intermediate outputs and event-based interactions. + - Human-in-the-loop capabilities to confirm or guide agent actions during workflow execution. + + These workflows enable agents to execute sequences of operations, call external tools asynchronously, maintain conversation or task states, stream partial results, and incorporate human inputs when necessary. They embody dynamic, agent-driven sequences of task decomposition, tool use, and reflection, allowing AI systems to plan, act, and improve iteratively toward specific goals. + + I have also saved the contents from the provided URLs to the WeaviateDocs collection. + + + +```python +response = await agent.run( + user_msg="How many docs do I have in the weaviate and llamaindex collections in total?" +) +print(str(response)) +``` + + You have a total of 2 documents in the WeaviateDocs collection and 1 document in the LlamaIndexDocs collection. In total, that makes 3 documents across both collections. + + + +```python +weaviate_agent = fresh_setup_weaviate(client) +``` + +## Create a Workflow with Branches + +### Simple Example: Create Events + +A LlamaIndex Workflow has 2 fundamentals: +- An Event +- A Step + +An step may return an event, and an event may trigger a step! + +For our use-case, we can imagine thet there are 4 events: + + +```python +class EvaluateQuery(Event): + query: str + + +class WriteLlamaIndexDocsEvent(Event): + urls: list[str] + + +class WriteWeaviateDocsEvent(Event): + urls: list[str] + + +class QueryAgentEvent(Event): + query: str +``` + +### Simple Example: A Branching Workflow (that does nothing yet) + + +```python +class DocsAssistantWorkflow(Workflow): + @step + async def start(self, ctx: Context, ev: StartEvent) -> EvaluateQuery: + return EvaluateQuery(query=ev.query) + + @step + async def evaluate_query( + self, ctx: Context, ev: EvaluateQuery + ) -> QueryAgentEvent | WriteLlamaIndexDocsEvent | WriteWeaviateDocsEvent | StopEvent: + if ev.query == "llama": + return WriteLlamaIndexDocsEvent(urls=[ev.query]) + if ev.query == "weaviate": + return WriteWeaviateDocsEvent(urls=[ev.query]) + if ev.query == "question": + return QueryAgentEvent(query=ev.query) + return StopEvent() + + @step + async def write_li_docs( + self, ctx: Context, ev: WriteLlamaIndexDocsEvent + ) -> StopEvent: + print(f"Got a request to write something to LlamaIndexDocs") + return StopEvent() + + @step + async def write_weaviate_docs( + self, ctx: Context, ev: WriteWeaviateDocsEvent + ) -> StopEvent: + print(f"Got a request to write something to WeaviateDocs") + return StopEvent() + + @step + async def query_agent( + self, ctx: Context, ev: QueryAgentEvent + ) -> StopEvent: + print(f"Got a request to forward a query to the QueryAgent") + return StopEvent() +``` + + +```python +workflow_that_does_nothing = DocsAssistantWorkflow() + +# draw_all_possible_flows(workflow_that_does_nothing) +``` + + +```python +print( + await workflow_that_does_nothing.run(start_event=StartEvent(query="llama")) +) +``` + + Got a request to write something to LlamaIndexDocs + None + + +### Classify the Query with Structured Outputs + + +```python +class SaveToLlamaIndexDocs(BaseModel): + """The URLs to parse and save into a llama-index specific docs collection.""" + + llama_index_urls: List[str] = Field(default_factory=list) + + +class SaveToWeaviateDocs(BaseModel): + """The URLs to parse and save into a weaviate specific docs collection.""" + + weaviate_urls: List[str] = Field(default_factory=list) + + +class Ask(BaseModel): + """The natural language questions that can be asked to a Q&A agent.""" + + queries: List[str] = Field(default_factory=list) + + +class Actions(BaseModel): + """Actions to take based on the latest user message.""" + + actions: List[ + Union[SaveToLlamaIndexDocs, SaveToWeaviateDocs, Ask] + ] = Field(default_factory=list) +``` + +#### Create a Workflow + +Let's create a workflow that, still, does nothing, but the incoming user query will be converted to our structure. Based on the contents of that structure, the workflow will decide which step to run. + +Notice how whichever step runs first, will return a `StopEvent`... This is good, but maybe we can improve that later! + + +```python +from llama_index.llms.openai import OpenAIResponses + + +class DocsAssistantWorkflow(Workflow): + def __init__(self, *args, **kwargs): + self.llm = OpenAIResponses(model="gpt-4.1-mini") + self.system_prompt = """You are a docs assistant. You evaluate incoming queries and break them down to subqueries when needed. + You decide on the next best course of action. Overall, here are the options: + - You can write the contents of a URL to llamaindex docs (if it's a llamaindex url) + - You can write the contents of a URL to weaviate docs (if it's a weaviate url) + - You can answer a question about llamaindex and weaviate using the QueryAgent""" + super().__init__(*args, **kwargs) + + @step + async def start(self, ev: StartEvent) -> EvaluateQuery: + return EvaluateQuery(query=ev.query) + + @step + async def evaluate_query( + self, ev: EvaluateQuery + ) -> QueryAgentEvent | WriteLlamaIndexDocsEvent | WriteWeaviateDocsEvent: + sllm = self.llm.as_structured_llm(Actions) + response = await sllm.achat( + [ + ChatMessage(role="system", content=self.system_prompt), + ChatMessage(role="user", content=ev.query), + ] + ) + actions = response.raw.actions + print(actions) + for action in actions: + if isinstance(action, SaveToLlamaIndexDocs): + return WriteLlamaIndexDocsEvent(urls=action.llama_index_urls) + elif isinstance(action, SaveToWeaviateDocs): + return WriteWeaviateDocsEvent(urls=action.weaviate_urls) + elif isinstance(action, Ask): + for query in action.queries: + return QueryAgentEvent(query=query) + + @step + async def write_li_docs(self, ev: WriteLlamaIndexDocsEvent) -> StopEvent: + print(f"Writing {ev.urls} to LlamaIndex Docs") + return StopEvent() + + @step + async def write_weaviate_docs( + self, ev: WriteWeaviateDocsEvent + ) -> StopEvent: + print(f"Writing {ev.urls} to Weaviate Docs") + return StopEvent() + + @step + async def query_agent(self, ev: QueryAgentEvent) -> StopEvent: + print(f"Sending `'{ev.query}`' to agent") + return StopEvent() + + +everything_docs_agent_beta = DocsAssistantWorkflow() +``` + + +```python +async def run_docs_agent_beta(query: str): + print( + await everything_docs_agent_beta.run( + start_event=StartEvent(query=query) + ) + ) +``` + + +```python +await run_docs_agent_beta( + """Can you save https://www.llamaindex.ai/blog/get-citations-and-reasoning-for-extracted-data-in-llamaextract + and https://www.llamaindex.ai/blog/llamaparse-update-may-2025-new-models-skew-detection-and-more??""" +) +``` + + [SaveToLlamaIndexDocs(llama_index_urls=['https://www.llamaindex.ai/blog/get-citations-and-reasoning-for-extracted-data-in-llamaextract', 'https://www.llamaindex.ai/blog/llamaparse-update-may-2025-new-models-skew-detection-and-more'])] + Writing ['https://www.llamaindex.ai/blog/get-citations-and-reasoning-for-extracted-data-in-llamaextract', 'https://www.llamaindex.ai/blog/llamaparse-update-may-2025-new-models-skew-detection-and-more'] to LlamaIndex Docs + None + + + +```python +await run_docs_agent_beta( + "How many documents do we have in the LlamaIndexDocs collection now?" +) +``` + + [Ask(queries=['How many documents are in the LlamaIndexDocs collection?'])] + Sending `'How many documents are in the LlamaIndexDocs collection?`' to agent + None + + + +```python +await run_docs_agent_beta("What are LlamaIndex workflows?") +``` + + [Ask(queries=['What are LlamaIndex workflows?'])] + Sending `'What are LlamaIndex workflows?`' to agent + None + + + +```python +await run_docs_agent_beta( + "Can you save https://weaviate.io/blog/graph-rag and https://weaviate.io/blog/genai-apps-with-weaviate-and-databricks??" +) +``` + + [SaveToWeaviateDocs(weaviate_urls=['https://weaviate.io/blog/graph-rag', 'https://weaviate.io/blog/genai-apps-with-weaviate-and-databricks'])] + Writing ['https://weaviate.io/blog/graph-rag', 'https://weaviate.io/blog/genai-apps-with-weaviate-and-databricks'] to Weaviate Docs + None + + +## Run Multiple Branches & Put it all togehter + +In these cases, it makes sense to run multiple branches. So, a single step can trigger multiple events at once! We can `send_event` via the context 👇 + + +```python +class ActionCompleted(Event): + result: str + + +class DocsAssistantWorkflow(Workflow): + def __init__(self, *args, **kwargs): + self.llm = OpenAIResponses(model="gpt-4.1-mini") + self.system_prompt = """You are a docs assistant. You evaluate incoming queries and break them down to subqueries when needed. + You decide on the next best course of action. Overall, here are the options: + - You can write the contents of a URL to llamaindex docs (if it's a llamaindex url) + - You can write the contents of a URL to weaviate docs (if it's a weaviate url) + - You can answer a question about llamaindex and weaviate using the QueryAgent""" + super().__init__(*args, **kwargs) + + @step + async def start(self, ctx: Context, ev: StartEvent) -> EvaluateQuery: + return EvaluateQuery(query=ev.query) + + @step + async def evaluate_query( + self, ctx: Context, ev: EvaluateQuery + ) -> QueryAgentEvent | WriteLlamaIndexDocsEvent | WriteWeaviateDocsEvent | None: + await ctx.store.set("results", []) + sllm = self.llm.as_structured_llm(Actions) + response = await sllm.achat( + [ + ChatMessage(role="system", content=self.system_prompt), + ChatMessage(role="user", content=ev.query), + ] + ) + actions = response.raw.actions + await ctx.store.set("num_events", len(actions)) + await ctx.store.set("results", []) + print(actions) + for action in actions: + if isinstance(action, SaveToLlamaIndexDocs): + ctx.send_event( + WriteLlamaIndexDocsEvent(urls=action.llama_index_urls) + ) + elif isinstance(action, SaveToWeaviateDocs): + ctx.send_event( + WriteWeaviateDocsEvent(urls=action.weaviate_urls) + ) + elif isinstance(action, Ask): + for query in action.queries: + ctx.send_event(QueryAgentEvent(query=query)) + + @step + async def write_li_docs( + self, ctx: Context, ev: WriteLlamaIndexDocsEvent + ) -> ActionCompleted: + print(f"Writing {ev.urls} to LlamaIndex Docs") + write_webpages_to_weaviate( + client, urls=ev.urls, collection_name="LlamaIndexDocs" + ) + results = await ctx.store.get("results") + results.append(f"Wrote {ev.urls} it LlamaIndex Docs") + return ActionCompleted(result=f"Writing {ev.urls} to LlamaIndex Docs") + + @step + async def write_weaviate_docs( + self, ctx: Context, ev: WriteWeaviateDocsEvent + ) -> ActionCompleted: + print(f"Writing {ev.urls} to Weaviate Docs") + write_webpages_to_weaviate( + client, urls=ev.urls, collection_name="WeaviateDocs" + ) + results = await ctx.store.get("results") + results.append(f"Wrote {ev.urls} it Weavite Docs") + return ActionCompleted(result=f"Writing {ev.urls} to Weaviate Docs") + + @step + async def query_agent( + self, ctx: Context, ev: QueryAgentEvent + ) -> ActionCompleted: + print(f"Sending {ev.query} to agent") + response = weaviate_agent.run(ev.query) + results = await ctx.store.get("results") + results.append(f"QueryAgent responded with:\n {response.final_answer}") + return ActionCompleted(result=f"Sending `'{ev.query}`' to agent") + + @step + async def collect( + self, ctx: Context, ev: ActionCompleted + ) -> StopEvent | None: + num_events = await ctx.store.get("num_events") + evs = ctx.collect_events(ev, [ActionCompleted] * num_events) + if evs is None: + return None + return StopEvent(result=[ev.result for ev in evs]) + + +everything_docs_agent = DocsAssistantWorkflow(timeout=None) +``` + + +```python +async def run_docs_agent(query: str): + handler = everything_docs_agent.run(start_event=StartEvent(query=query)) + result = await handler + for response in await handler.ctx.get("results"): + print(response) +``` + + +```python +await run_docs_agent( + "Can you save https://docs.llamaindex.ai/en/stable/understanding/workflows/ and https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/" +) +``` + + [SaveToLlamaIndexDocs(llama_index_urls=['https://docs.llamaindex.ai/en/stable/understanding/workflows/']), SaveToLlamaIndexDocs(llama_index_urls=['https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/'])] + Writing ['https://docs.llamaindex.ai/en/stable/understanding/workflows/'] to LlamaIndex Docs + Writing ['https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/'] to LlamaIndex Docs + Wrote ['https://docs.llamaindex.ai/en/stable/understanding/workflows/'] it LlamaIndex Docs + Wrote ['https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/'] it LlamaIndex Docs + + + +```python +await run_docs_agent( + "How many documents do we have in the LlamaIndexDocs collection now?" +) +``` + + [Ask(queries=['How many documents are in the LlamaIndexDocs collection?'])] + Sending How many documents are in the LlamaIndexDocs collection? to agent + QueryAgent responded with: + The LlamaIndexDocs collection contains 2 documents, specifically related to workflows and branches and loops within the documentation. + + + +```python +await run_docs_agent( + "What are LlamaIndex workflows? And can you save https://weaviate.io/blog/graph-rag" +) +``` + + [Ask(queries=['What are LlamaIndex workflows?'])] + Sending What are LlamaIndex workflows? to agent + QueryAgent responded with: + LlamaIndex workflows are an event-driven, step-based framework designed to control and manage the execution flow of complex applications, particularly those involving generative AI. They break an application into discrete Steps, each triggered by Events and capable of emitting further Events, allowing for complex logic involving loops, branches, and parallel execution. + + In a LlamaIndex workflow, steps perform functions ranging from simple tasks to complex agents, with inputs and outputs communicated via Events. This event-driven model facilitates maintainability and clarity, overcoming limitations of previous approaches like directed acyclic graphs (DAGs) which struggled with complex flows involving loops and branching. + + Key features include: + - **Loops:** Steps can return events that loop back to previous steps to enable iterative processes. + - **Branches:** Workflows can branch into different paths based on conditions, allowing for multiple distinct sequences of steps. + - **Parallelism:** Multiple branches or steps can run concurrently and synchronize their results. + - **State Maintenance:** Workflows support maintaining state and context throughout execution. + - **Observability and Debugging:** Supported by various components and callbacks for monitoring. + + An example workflow might involve judging whether a query is of sufficient quality, looping to improve it if not, then concurrently executing different retrieval-augmented generation (RAG) strategies, and finally judging their responses to produce a single output. + + Workflows are especially useful as applications grow in complexity, enabling developers to organize and control intricate AI logic more naturally and efficiently than traditional graph-based methods. For simpler pipelines, LlamaIndex suggests using workflows optionally, but for advanced agentic applications, workflows provide a flexible and powerful control abstraction. + + + +```python +await run_docs_agent("How do I use loops in llamaindex workflows?") +``` + + [Ask(queries=['How to use loops in llamaindex workflows'])] + Sending How to use loops in llamaindex workflows to agent + QueryAgent responded with: + In LlamaIndex workflows, loops are implemented using an event-driven approach where you define custom event types and steps that emit events to control the workflow's execution flow. To create a loop, you define a custom event (e.g., `LoopEvent`) and a workflow step that can return either the event continuing the loop or another event to proceed. For example, a workflow step might randomly decide to either loop back (emit `LoopEvent` again) or continue to a next step emitting a different event. + + This allows creating flexible looping behaviors where any step can loop back to any other step by returning the corresponding event instances. The approach leverages Python's async functions decorated with `@step`, which process events and return the next event(s), enabling both loops and conditional branching in workflows. + + Thus, loops in LlamaIndex workflows are event-based, using custom event types and the return of events from steps to signal iterations until a condition is met. + + Example: + + ```python + from llamaindex.workflow import Workflow, Event, StartEvent, StopEvent, step + import random + + class LoopEvent(Event): + loop_output: str + + class FirstEvent(Event): + first_output: str + + class MyWorkflow(Workflow): + @step + async def step_one(self, ev: StartEvent | LoopEvent) -> FirstEvent | LoopEvent: + if random.randint(0, 1) == 0: + print("Bad thing happened") + return LoopEvent(loop_output="Back to step one.") + else: + print("Good thing happened") + return FirstEvent(first_output="First step complete.") + + # ... other steps ... + + # Running this workflow will cause step_one to loop randomly until it proceeds. + ``` + + You can combine loops with branching and parallel execution in workflows to build complex control flows. For detailed guidance and examples, consult the LlamaIndex documentation under "Branches and Loops" and the "Workflows" guides. + diff --git a/.tmp/agent/multi_document_agents-v1.md b/.tmp/agent/multi_document_agents-v1.md new file mode 100644 index 0000000..2ebf84c --- /dev/null +++ b/.tmp/agent/multi_document_agents-v1.md @@ -0,0 +1,591 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/multi_document_agents-v1.ipynb +toc: True +title: "Multi-Document Agents (V1)" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +In this guide, you learn towards setting up a multi-document agent over the LlamaIndex documentation. + +This is an extension of V0 multi-document agents with the additional features: +- Reranking during document (tool) retrieval +- Query planning tool that the agent can use to plan + + +We do this with the following architecture: + +- setup a "document agent" over each Document: each doc agent can do QA/summarization within its doc +- setup a top-level agent over this set of document agents. Do tool retrieval and then do CoT over the set of tools to answer a question. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index-core +%pip install llama-index-agent-openai +%pip install llama-index-readers-file +%pip install llama-index-postprocessor-cohere-rerank +%pip install llama-index-llms-openai +%pip install llama-index-embeddings-openai +%pip install unstructured[html] +``` + + +```python +%load_ext autoreload +%autoreload 2 +``` + +## Setup and Download Data + +In this section, we'll load in the LlamaIndex documentation. + +**NOTE:** This command will take a while to run, it will download the entire LlamaIndex documentation. In my testing, this took about 15 minutes. + + +```python +domain = "docs.llamaindex.ai" +docs_url = "https://docs.llamaindex.ai/en/latest/" +!wget -e robots=off --recursive --no-clobber --page-requisites --html-extension --convert-links --restrict-file-names=windows --domains {domain} --no-parent {docs_url} +``` + + +```python +from llama_index.readers.file import UnstructuredReader + +reader = UnstructuredReader() +``` + + +```python +from pathlib import Path + +all_files_gen = Path("./docs.llamaindex.ai/").rglob("*") +all_files = [f.resolve() for f in all_files_gen] +``` + + +```python +all_html_files = [f for f in all_files if f.suffix.lower() == ".html"] +``` + + +```python +len(all_html_files) +``` + + + + + 1656 + + + + +```python +useful_files = [ + x + for x in all_html_files + if "understanding" in str(x).split(".")[-2] + or "examples" in str(x).split(".")[-2] +] +print(len(useful_files)) +``` + + 680 + + + +```python +from llama_index.core import Document + +# TODO: set to higher value if you want more docs to be indexed +doc_limit = 100 + +docs = [] +for idx, f in enumerate(useful_files): + if idx > doc_limit: + break + print(f"Idx {idx}/{len(useful_files)}") + loaded_docs = reader.load_data(file=f, split_documents=True) + + loaded_doc = Document( + text="\n\n".join([d.get_content() for d in loaded_docs]), + metadata={"path": str(f)}, + ) + print(loaded_doc.metadata["path"]) + docs.append(loaded_doc) +``` + + +```python +print(len(docs)) +``` + + 101 + + +Define Global LLM + Embeddings + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +llm = OpenAI(model="gpt-4o") +Settings.llm = llm +Settings.embed_model = OpenAIEmbedding( + model="text-embedding-3-small", embed_batch_size=256 +) +``` + +## Building Multi-Document Agents + +In this section we show you how to construct the multi-document agent. We first build a document agent for each document, and then define the top-level parent agent with an object index. + +### Build Document Agent for each Document + +In this section we define "document agents" for each document. + +We define both a vector index (for semantic search) and summary index (for summarization) for each document. The two query engines are then converted into tools that are passed to an OpenAI function calling agent. + +This document agent can dynamically choose to perform semantic search or summarization within a given document. + +We create a separate document agent for each city. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent +from llama_index.core import ( + load_index_from_storage, + StorageContext, + VectorStoreIndex, +) +from llama_index.core import SummaryIndex +from llama_index.core.tools import QueryEngineTool +from llama_index.core.node_parser import SentenceSplitter +import os +from tqdm.notebook import tqdm +import pickle + + +async def build_agent_per_doc(nodes, file_base): + vi_out_path = f"./data/llamaindex_docs/{file_base}" + summary_out_path = f"./data/llamaindex_docs/{file_base}_summary.pkl" + if not os.path.exists(vi_out_path): + Path("./data/llamaindex_docs/").mkdir(parents=True, exist_ok=True) + # build vector index + vector_index = VectorStoreIndex(nodes) + vector_index.storage_context.persist(persist_dir=vi_out_path) + else: + vector_index = load_index_from_storage( + StorageContext.from_defaults(persist_dir=vi_out_path), + ) + + # build summary index + summary_index = SummaryIndex(nodes) + + # define query engines + vector_query_engine = vector_index.as_query_engine(llm=llm) + summary_query_engine = summary_index.as_query_engine( + response_mode="tree_summarize", llm=llm + ) + + # extract a summary + if not os.path.exists(summary_out_path): + Path(summary_out_path).parent.mkdir(parents=True, exist_ok=True) + summary = str( + await summary_query_engine.aquery( + "Extract a concise 1-2 line summary of this document" + ) + ) + pickle.dump(summary, open(summary_out_path, "wb")) + else: + summary = pickle.load(open(summary_out_path, "rb")) + + # define tools + query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=vector_query_engine, + name=f"vector_tool_{file_base}", + description=f"Useful for questions related to specific facts", + ), + QueryEngineTool.from_defaults( + query_engine=summary_query_engine, + name=f"summary_tool_{file_base}", + description=f"Useful for summarization questions", + ), + ] + + # build agent + function_llm = OpenAI(model="gpt-4") + agent = FunctionAgent( + tools=query_engine_tools, + llm=function_llm, + system_prompt=f"""\ +You are a specialized agent designed to answer queries about the `{file_base}.html` part of the LlamaIndex docs. +You must ALWAYS use at least one of the tools provided when answering a question; do NOT rely on prior knowledge.\ +""", + ) + + return agent, summary + + +async def build_agents(docs): + node_parser = SentenceSplitter() + + # Build agents dictionary + agents_dict = {} + extra_info_dict = {} + + # # this is for the baseline + # all_nodes = [] + + for idx, doc in enumerate(tqdm(docs)): + nodes = node_parser.get_nodes_from_documents([doc]) + # all_nodes.extend(nodes) + + # ID will be base + parent + file_path = Path(doc.metadata["path"]) + file_base = str(file_path.parent.stem) + "_" + str(file_path.stem) + agent, summary = await build_agent_per_doc(nodes, file_base) + + agents_dict[file_base] = agent + extra_info_dict[file_base] = {"summary": summary, "nodes": nodes} + + return agents_dict, extra_info_dict +``` + + +```python +agents_dict, extra_info_dict = await build_agents(docs) +``` + +### Build Retriever-Enabled OpenAI Agent + +We build a top-level agent that can orchestrate across the different document agents to answer any user query. + +This agent will use a tool retriever to retrieve the most relevant tools for the query. + +**Improvements from V0**: We make the following improvements compared to the "base" version in V0. + +- Adding in reranking: we use Cohere reranker to better filter the candidate set of documents. +- Adding in a query planning tool: we add an explicit query planning tool that's dynamically created based on the set of retrieved tools. + + + +```python +from typing import Callable +from llama_index.core.tools import FunctionTool + + +def get_agent_tool_callable(agent: FunctionAgent) -> Callable: + async def query_agent(query: str) -> str: + response = await agent.run(query) + return str(response) + + return query_agent + + +# define tool for each document agent +all_tools = [] +for file_base, agent in agents_dict.items(): + summary = extra_info_dict[file_base]["summary"] + async_fn = get_agent_tool_callable(agent) + doc_tool = FunctionTool.from_defaults( + async_fn, + name=f"tool_{file_base}", + description=summary, + ) + all_tools.append(doc_tool) +``` + + +```python +print(all_tools[0].metadata) +``` + + ToolMetadata(description='The document provides a series of tutorials on building agentic LLM applications using LlamaIndex, covering key steps such as building RAG pipelines, agents, and workflows, along with techniques for data ingestion, indexing, querying, and application evaluation.', name='tool_understanding_index', fn_schema=, return_direct=False) + + + +```python +# define an "object" index and retriever over these tools +from llama_index.core import VectorStoreIndex +from llama_index.core.objects import ( + ObjectIndex, + ObjectRetriever, +) +from llama_index.postprocessor.cohere_rerank import CohereRerank +from llama_index.core.query_engine import SubQuestionQueryEngine +from llama_index.core.schema import QueryBundle +from llama_index.llms.openai import OpenAI + + +llm = OpenAI(model_name="gpt-4o") + +obj_index = ObjectIndex.from_objects( + all_tools, + index_cls=VectorStoreIndex, +) +vector_node_retriever = obj_index.as_node_retriever( + similarity_top_k=10, +) + + +# define a custom object retriever that adds in a query planning tool +class CustomObjectRetriever(ObjectRetriever): + def __init__( + self, + retriever, + object_node_mapping, + node_postprocessors=None, + llm=None, + ): + self._retriever = retriever + self._object_node_mapping = object_node_mapping + self._llm = llm or OpenAI("gpt-4o") + self._node_postprocessors = node_postprocessors or [] + + def retrieve(self, query_bundle): + if isinstance(query_bundle, str): + query_bundle = QueryBundle(query_str=query_bundle) + + nodes = self._retriever.retrieve(query_bundle) + for processor in self._node_postprocessors: + nodes = processor.postprocess_nodes( + nodes, query_bundle=query_bundle + ) + tools = [self._object_node_mapping.from_node(n.node) for n in nodes] + + sub_agent = FunctionAgent( + name="compare_tool", + description=f"""\ +Useful for any queries that involve comparing multiple documents. ALWAYS use this tool for comparison queries - make sure to call this \ +tool with the original query. Do NOT use the other tools for any queries involving multiple documents. +""", + tools=tools, + llm=self._llm, + system_prompt="""You are an expert at comparing documents. Given a query, use the tools provided to compare the documents and return a summary of the results.""", + ) + + async def query_sub_agent(query: str) -> str: + response = await sub_agent.run(query) + return str(response) + + sub_question_tool = FunctionTool.from_defaults( + query_sub_agent, + name=sub_agent.name, + description=sub_agent.description, + ) + return tools + [sub_question_tool] +``` + + +```python +# wrap it with ObjectRetriever to return objects +custom_obj_retriever = CustomObjectRetriever( + vector_node_retriever, + obj_index.object_node_mapping, + node_postprocessors=[CohereRerank(top_n=5, model="rerank-v3.5")], + llm=llm, +) +``` + + +```python +tmps = custom_obj_retriever.retrieve("hello") + +# should be 5 + 1 -- 5 from reranker, 1 from subquestion +print(len(tmps)) +``` + + 6 + + + +```python +from llama_index.core.agent.workflow import ReActAgent, FunctionAgent + +top_agent = FunctionAgent( + tool_retriever=custom_obj_retriever, + system_prompt=""" \ +You are an agent designed to answer queries about the documentation. +Please always use the tools provided to answer a question. Do not rely on prior knowledge.\ + +""", + llm=llm, +) + +# top_agent = ReActAgent( +# tool_retriever=custom_obj_retriever, +# system_prompt=""" \ +# You are an agent designed to answer queries about the documentation. +# Please always use the tools provided to answer a question. Do not rely on prior knowledge.\ + +# """, +# llm=llm, +# ) +``` + +### Define Baseline Vector Store Index + +As a point of comparison, we define a "naive" RAG pipeline which dumps all docs into a single vector index collection. + +We set the top_k = 4 + + +```python +all_nodes = [ + n for extra_info in extra_info_dict.values() for n in extra_info["nodes"] +] +``` + + +```python +base_index = VectorStoreIndex(all_nodes) +base_query_engine = base_index.as_query_engine(similarity_top_k=4) +``` + +## Running Example Queries + +Let's run some example queries, ranging from QA / summaries over a single document to QA / summarization over multiple documents. + + +```python +from llama_index.core.agent.workflow import ( + AgentStream, + ToolCall, + ToolCallResult, +) + +handler = top_agent.run( + "What can you build with LlamaIndex?", +) +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalling tool {ev.tool_name} with args {ev.tool_kwargs}\n Got response: {str(ev.tool_output)[:200]}" + ) + elif isinstance(ev, ToolCall): + print(f"\nTool call: {ev.tool_name} with args {ev.tool_kwargs}") + # Print the stream of the agent + # elif isinstance(ev, AgentStream): + # print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Tool call: tool_SimpleIndexDemoLlama2_index with args {'query': 'What can you build with LlamaIndex?'} + + Tool call: tool_apps_index with args {'query': 'What can you build with LlamaIndex?'} + + Tool call: tool_putting_it_all_together_index with args {'query': 'What can you build with LlamaIndex?'} + + Tool call: tool_llamacloud_index with args {'query': 'What can you build with LlamaIndex?'} + + Calling tool tool_SimpleIndexDemoLlama2_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a VectorStoreIndex. This involves setting up the necessary environment, loading documents into the index, and then querying the index for information. You need to instal + + Tool call: tool_using_llms_index with args {'query': 'What can you build with LlamaIndex?'} + + Calling tool tool_llamacloud_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a system that connects to your data stores, automatically indexes them, and then queries the data. This is done by integrating LlamaCloud into your project. The system a + + Calling tool tool_apps_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a full-stack web application. You can integrate it into a backend server like Flask, package it into a Docker container, or use it directly in a framework such as Stream + + Calling tool tool_putting_it_all_together_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a variety of applications and tools. This includes: + + 1. Chatbots: You can use LlamaIndex to create interactive chatbots. + 2. Agents: LlamaIndex can be used to build intel + + Calling tool tool_using_llms_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a variety of applications by leveraging the various Language Model (LLM) integrations it supports. These include OpenAI, Anthropic, Mistral, DeepSeek, Hugging Face, and + + + +```python +# print the final response string +print(str(response)) +``` + + With LlamaIndex, you can build various applications and tools, including: + + 1. **VectorStoreIndex**: Set up and query a VectorStoreIndex by loading documents and configuring the environment as per the documentation. + + 2. **Full-Stack Web Applications**: Integrate LlamaIndex into backend servers like Flask, Docker containers, or frameworks like Streamlit. Resources include guides for TypeScript+React, Delphic starter template, and Flask, Streamlit, and Docker integration examples. + + 3. **Chatbots, Agents, and Unified Query Framework**: Create interactive chatbots, intelligent agents, and a unified query framework for handling different query types. LlamaIndex also supports property graphs and full-stack web applications. + + 4. **Data Management with LlamaCloud**: Build systems that connect to data stores, automatically index data, and efficiently query it by integrating LlamaCloud into your project. + + 5. **LLM Integrations**: Utilize various Language Model (LLM) integrations such as OpenAI, Anthropic, Mistral, DeepSeek, and Hugging Face. LlamaIndex provides a unified interface to access different LLMs, enabling you to select models based on their strengths and price points. You can use multi-modal LLMs for chat messages with text, images, and audio inputs, and even call tools and functions directly through API calls. + + These capabilities make LlamaIndex a versatile tool for building a wide range of applications and systems. + + + +```python +# access the tool calls +# print(response.tool_calls) +``` + + +```python +# baseline +response = base_query_engine.query( + "What can you build with LlamaIndex?", +) +print(str(response)) +``` + + With LlamaIndex, you can build a variety of applications and systems, including a full-stack web application, a chatbot, and a unified query framework over multiple indexes. You can also perform semantic searches, summarization queries, and queries over structured data like SQL or Pandas DataFrames. Additionally, LlamaIndex supports routing over heterogeneous data sources and compare/contrast queries. It provides tools and templates to help you integrate these capabilities into production-ready applications. + + + +```python +response = await top_agent.run("Compare workflows to query engines") +print(str(response)) +``` + + Workflows and query engines serve different purposes in an application context: + + 1. Workflows: + - Workflows are designed to manage the execution flow of an application by dividing it into sections triggered by events. + - They are event-driven and step-based, allowing for the management of application complexity by breaking it into smaller, more manageable pieces. + - Workflows focus on controlling the flow of application execution through steps and events. + + 2. Query Engines: + - Query engines are tools used to process queries against a database or data source to retrieve specific information. + - They are primarily used for querying and retrieving data from databases. + - Query engines are focused on the retrieval, postprocessing, and response synthesis stages of querying. + + In summary, workflows are more about controlling the flow of application execution, while query engines are specifically designed for querying and retrieving data from databases. + + + +```python +response = await top_agent.run( + "Can you compare the compact and tree_summarize response synthesizer response modes at a very high-level?" +) +print(str(response)) +``` + + The compact response synthesizer mode aims to produce concise and condensed responses, focusing on delivering the most relevant information in a brief format. On the other hand, the tree_summarize response synthesizer mode is designed to create structured and summarized responses, organizing information in a comprehensive manner. + + In summary, the compact mode provides brief and straightforward responses, while the tree_summarize mode offers more detailed and organized output for a comprehensive summary. + diff --git a/.tmp/agent/nvidia_agent.md b/.tmp/agent/nvidia_agent.md new file mode 100644 index 0000000..9d75b5c --- /dev/null +++ b/.tmp/agent/nvidia_agent.md @@ -0,0 +1,224 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/nvidia_agent.ipynb +toc: True +title: "Function Calling NVIDIA Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our NVIDIA agent, powered by function calling capabilities. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the NVIDIA NIM Endpoint (using our own `llama_index` LLM class) +2. a place to keep conversation history +3. a definition for tools that our agent can use. + + +```python +%pip install --upgrade --quiet llama-index-llms-nvidia +``` + + +```python +import getpass +import os + +# del os.environ['NVIDIA_API_KEY'] ## delete key and reset +if os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"): + print("Valid NVIDIA_API_KEY already in environment. Delete to reset") +else: + nvapi_key = getpass.getpass("NVAPI Key (starts with nvapi-): ") + assert nvapi_key.startswith( + "nvapi-" + ), f"{nvapi_key[:5]}... is not a valid key" + os.environ["NVIDIA_API_KEY"] = nvapi_key +``` + + Valid NVIDIA_API_KEY already in environment. Delete to reset + + + +```python +from llama_index.llms.nvidia import NVIDIA +from llama_index.core.tools import FunctionTool +from llama_index.embeddings.nvidia import NVIDIAEmbedding +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Here we initialize a simple NVIDIA agent with calculator functions. + + +```python +llm = NVIDIA("meta/llama-3.1-70b-instruct") +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + +### Chat + + +```python +response = await agent.run("What is (121 * 3) + 42?") +print(str(response)) +``` + + +```python +# inspect sources +print(response.tool_calls) +``` + +### Managing Context/Memory + +By default, `.run()` is stateless. If you want to maintain state, you can pass in a `context` object. + + +```python +from llama_index.core.agent.workflow import Context + +ctx = Context(agent) + +response = await agent.run("Hello, my name is John Doe.", ctx=ctx) +print(str(response)) + +response = await agent.run("What is my name?", ctx=ctx) +print(str(response)) +``` + +### Agent with Personality + +You can specify a system prompt to give the agent additional instruction or personality. + + +```python +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, + system_prompt="Talk like a pirate in every response.", +) +``` + + +```python +response = await agent.run("Hi") +print(response) +``` + + +```python +response = await agent.run("Tell me a story") +print(response) +``` + +# NVIDIA Agent with RAG/Query Engine Tools + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex + +embed_model = NVIDIAEmbedding(model="NV-Embed-QA", truncate="END") + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() + +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +agent = FunctionAgent(tools=[query_engine_tool], llm=llm) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls." +) +print(str(response)) +``` + +# ReAct Agent + + +```python +from llama_index.core.agent.workflow import ReActAgent +``` + + +```python +agent = ReActAgent([multiply_tool, add_tool], llm=llm, verbose=True) +``` + +Using the `stream_events()` method, we can stream the response as it is generated to see the agent's thought process. + +The final response will have only the final answer. + + +```python +from llama_index.core.agent.workflow import AgentStream + +handler = agent.run("What is 20+(2*4)? Calculate step by step ") +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + +```python +print(str(response)) +``` + + +```python +print(response.tool_calls) +``` diff --git a/.tmp/agent/nvidia_document_research_assistant_for_blog_creation.md b/.tmp/agent/nvidia_document_research_assistant_for_blog_creation.md new file mode 100644 index 0000000..4f23d3d --- /dev/null +++ b/.tmp/agent/nvidia_document_research_assistant_for_blog_creation.md @@ -0,0 +1,1011 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/nvidia_document_research_assistant_for_blog_creation.ipynb +toc: True +title: "Document Research Assistant for Blog Creation" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +[![ Click here to deploy.](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2qRrBuBdUGzzauhql87XCd7U1wR) + +Deploy with Launchables. Launchables are pre-configured, fully optimized environments that users can deploy with a single click. + +In this notebook, you will use an NVIDIA LLM NIM microservice (llama-3.3-70b) to generate a report on a given topic, and an NVIDIA NeMo Retriever embedding NIM (llama-3.2-nv-embedqa-1b-v2) for optimized text question-answering retrieval. Given a set of documents, LlamaIndex will create an Index which it can run queries against. + +You can get started by calling a hosted model's NIM API endpoint from the NVIDIA API catalog. Once you familiarize yourself with this blueprint, you may want to self-host models with NVIDIA NIM. + +The Blueprint provides a workflow architecture for automating and orchestrating the creation of well-researched, high-quality content. + +The user provides a set of tools (e.g., a query engine with data about San Francisco's budget) and a content request (e.g., a question for a blog post). The Agent then: +1. Generates an Outline: Deploys an agent to structure the blog post into an actionable outline. +2. Plans Research Questions: Another agent generates a list of questions necessary to address the outline effectively. +3. Parallel Research: Breaks the questions into discrete units that can be answered concurrently, using available tools for data collection. +4. Drafts the Content: A writer agent synthesizes the gathered answers into a cohesive blog post. +5. Performs Quality Assurance: A critic agent reviews the content for accuracy, coherence, and completeness, determining if revisions are necessary. +6. Iterative Refinement: If improvements are needed, the workflow repeats by generating additional questions and gathering more information until the desired quality is reached. + +This workflow combines modularity, automation, and iterative refinement to ensure the output meets the highest standards of quality. + +![image](data:image/png;base64,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) + + +# Content Overview +>[Prerequisites](#Prerequisites) +>[Create New Index from Document](#Create-New-Index-from-Document) +>[Create Engine Query Tool](#Create-Engine-Query-Tool) +>[Build the Agent](#Build-the-Agent) +>[Test the Agent](#Test-the-Agent) +________________________ + +## Prerequisites + +### Install Dependencies + + +```python +!pip install llama-index-core +!pip install llama-index-core +!pip install llama-index-llms-nvidia +!pip install llama-index-embeddings-nvidia +!pip install llama-index-utils-workflow +!pip install llama-parse +``` + +If your environment does not have `wget` , make sure to install that as well. + +### Download data + +The data for this notebook is the City of San Francisco's Proposed Budget. + + +```python +!wget "https://www.dropbox.com/scl/fi/vip161t63s56vd94neqlt/2023-CSF_Proposed_Budget_Book_June_2023_Master_Web.pdf?rlkey=hemoce3w1jsuf6s2bz87g549i&dl=0" -O "san_francisco_budget_2023.pdf" +``` + + +```python +# llama-parse is async-first, running the async code in a notebook requires the use of nest_asyncio +import nest_asyncio + +nest_asyncio.apply() +``` + +## API Keys +Prior to getting started, you will need to create API Keys for the NVIDIA API Catalog if you're not self-hosting a model and LlamaIndex to use LlamaCloud. + +- NVIDIA API Catalog + 1. Navigate to **[NVIDIA API Catalog](https://build.nvidia.com/explore/discover)**. + 2. Select any model, such as llama-3.3-70b-instruct. + 3. On the right panel above the sample code snippet, click on "Get API Key". This will prompt you to log in if you have not already. +- LlamaIndex + 1. Go to **[LlamaIndex login page](https://cloud.llamaindex.ai/login)**. You will need to create an account if you have not already. + 2. On the left panel, navigate to "API Key". + 3. Click on the "Generate New Key" on the top of the page. + +### Export API Keys + +Save these API Keys as environment variables. + +First, set the NVIDIA API Key as the environment variable. + + +```python +import getpass +import os + +if not os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"): + nvapi_key = getpass.getpass("Enter your NVIDIA API key: ") + assert nvapi_key.startswith( + "nvapi-" + ), f"{nvapi_key[:5]}... is not a valid key" + os.environ["NVIDIA_API_KEY"] = nvapi_key +``` + +Next, set the LlamaIndex API Key for LlamaCloud. + + +```python +import os, getpass + + +def _set_env(var: str): + if not os.environ.get(var): + os.environ[var] = getpass.getpass(f"{var}: ") + + +_set_env("LLAMA_CLOUD_API_KEY") +``` + +### Working with the NVIDIA API Catalog +Let's test the API endpoint. + +We'll use both an LLM and embedding model in this notebook so we'll import both the packages now. + + +```python +from llama_index.embeddings.nvidia import NVIDIAEmbedding +from llama_index.llms.nvidia import NVIDIA +from llama_index.core.llms import ChatMessage, MessageRole + +llm = NVIDIA(model="meta/llama-3.3-70b-instruct") + +messages = [ + ChatMessage( + role=MessageRole.SYSTEM, + content=("You are a helpful assistant that answers in one sentence."), + ), + ChatMessage( + role=MessageRole.USER, + content=("What are the most popular house pets in North America?"), + ), +] + +response = llm.chat(messages) + +print(response) +``` + + assistant: The most popular house pets in North America are dogs, cats, fish, birds, and small mammals such as hamsters, guinea pigs, and rabbits, with dogs and cats being the clear favorites among pet owners. + + +### Optional: Locally Run NVIDIA NIM Microservices + +Once you familiarize yourself with this blueprint, you may want to self-host models with NVIDIA NIM Microservices using NVIDIA AI Enterprise software license. This gives you the ability to run models anywhere, giving you ownership of your customizations and full control of your intellectual property (IP) and AI applications. + +[Learn more about NIM Microservices](https://developer.nvidia.com/blog/nvidia-nim-offers-optimized-inference-microservices-for-deploying-ai-models-at-scale/) + +
+NOTE: Run the following cell only if you're using a local NIM Microservice instead of the API Catalog Endpoint. +
+ + +```python +from llama_index.llms.nvidia import NVIDIA +from llama_index.core import Settings + +# connect to an LLM NIM running at localhost:8000, specifying a model +Settings.llm = NVIDIA( + base_url="http://localhost:8000/v1", model="meta/llama-3.3-70b-instruct" +) +``` + +### Set LLM and Embedding Model + +In this notebook, you will use the newest llama model, llama-3.3-70b-instruct, as the LLM. +You will also use NVIDIA's embedding model, llama-3.2-nv-embedqa-1b-v2. + + +```python +from llama_index.core import Settings + +Settings.llm = NVIDIA(model="meta/llama-3.3-70b-instruct") +Settings.embed_model = NVIDIAEmbedding( + model="nvidia/llama-3.2-nv-embedqa-1b-v2", truncate="END" +) +``` + +## Create New Index from Document + + +```python +from llama_index.core import ( + VectorStoreIndex, + StorageContext, + load_index_from_storage, +) +from llama_parse import LlamaParse + +DATA_DIR = "./data" +PERSIST_DIR = "./storage" + +if os.path.exists(PERSIST_DIR): + print("Loading existing index...") + storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR) + index = load_index_from_storage(storage_context) +else: + print("Creating new index...") + + file_path = "./san_francisco_budget_2023.pdf" + + documents = LlamaParse(result_type="markdown").load_data(file_path) + + index = VectorStoreIndex.from_documents(documents) + index.storage_context.persist(persist_dir=PERSIST_DIR) +``` + +### Run a Query Against the Index +Create a Query engine from the Index. A Query Engine is a generic interface that allows you to ask question over your data. +Here, the parameter `similarity_top_k` is set to 10. If you are using your own documents, you can play around with this parameter. + + +```python +query_engine = index.as_query_engine(similarity_top_k=10) +response = query_engine.query( + "What was San Francisco's budget for Police in 2023?" +) +print(response) +``` + + The proposed Fiscal Year 2023-24 budget for the Police Department is $776.8 million. + + +## Create Engine Query Tool +Next, create a Query Engine Tool. This takes the Query Engine defined earlier and wraps it as a tool the Agent can use. + + +```python +from llama_index.core.tools import QueryEngineTool + +budget_tool = QueryEngineTool.from_defaults( + query_engine, + name="san_francisco_budget_2023", + description="A RAG engine with extremely detailed information about the 2023 San Francisco budget.", +) +``` + +## Build the Agent + +The workflow is: +* you give it a set of tools (in this case it's a query engine with data about SF's budget) +* you give it a question to write a blog post about +* one agent generates an outline of what the blog post should look like +* the next generates a list of questions that would be necessary to gather data to fulfill that outline +* the questions are split up and answered concurrently +* a writer collects the questions and answers and writes a blog post +* a critic reviews the blog post and determines if it needs more work + * if it's fine, the workflow stops + * if it needs more work, it generates additional questions + * those questions are answered and the process repeats + + +```python +from typing import List +from llama_index.core.workflow import ( + step, + Event, + Context, + StartEvent, + StopEvent, + Workflow, +) +from llama_index.core.agent.workflow import FunctionAgent + + +class OutlineEvent(Event): + outline: str + + +class QuestionEvent(Event): + question: str + + +class AnswerEvent(Event): + question: str + answer: str + + +class ReviewEvent(Event): + report: str + + +class ProgressEvent(Event): + progress: str + + +class DocumentResearchAgent(Workflow): + # get the initial request and create an outline of the blog post knowing nothing about the topic + @step + async def formulate_plan( + self, ctx: Context, ev: StartEvent + ) -> OutlineEvent: + query = ev.query + await ctx.store.set("original_query", query) + await ctx.store.set("tools", ev.tools) + + prompt = f"""You are an expert at writing blog posts. You have been given a topic to write + a blog post about. Plan an outline for the blog post; it should be detailed and specific. + Another agent will formulate questions to find the facts necessary to fulfill the outline. + The topic is: {query}""" + + response = await Settings.llm.acomplete(prompt) + + ctx.write_event_to_stream( + ProgressEvent(progress="Outline:\n" + str(response)) + ) + + return OutlineEvent(outline=str(response)) + + # formulate some questions based on the outline + @step + async def formulate_questions( + self, ctx: Context, ev: OutlineEvent + ) -> QuestionEvent: + outline = ev.outline + await ctx.store.set("outline", outline) + + prompt = f"""You are an expert at formulating research questions. You have been given an outline + for a blog post. Formulate a series of simple questions that will get you the facts necessary + to fulfill the outline. You cannot assume any existing knowledge; you must ask at least one + question for every bullet point in the outline. Avoid complex or multi-part questions; break + them down into a series of simple questions. Your output should be a list of questions, each + on a new line. Do not include headers or categories or any preamble or explanation; just a + list of questions. For speed of response, limit yourself to 8 questions. The outline is: {outline}""" + + response = await Settings.llm.acomplete(prompt) + + questions = str(response).split("\n") + questions = [x for x in questions if x] + + ctx.write_event_to_stream( + ProgressEvent( + progress="Formulated questions:\n" + "\n".join(questions) + ) + ) + + await ctx.store.set("num_questions", len(questions)) + + ctx.write_event_to_stream( + ProgressEvent(progress="Questions:\n" + "\n".join(questions)) + ) + + for question in questions: + ctx.send_event(QuestionEvent(question=question)) + + # answer each question in turn + @step + async def answer_question( + self, ctx: Context, ev: QuestionEvent + ) -> AnswerEvent: + question = ev.question + if ( + not question + or question.isspace() + or question == "" + or question is None + ): + ctx.write_event_to_stream( + ProgressEvent(progress=f"Skipping empty question.") + ) # Log skipping empty question + return None + agent = FunctionAgent( + tools=await ctx.store.get("tools"), + llm=Settings.llm, + ) + response = await agent.run(question) + response = str(response) + + ctx.write_event_to_stream( + ProgressEvent( + progress=f"To question '{question}' the agent answered: {response}" + ) + ) + + return AnswerEvent(question=question, answer=response) + + # given all the answers to all the questions and the outline, write the blog poost + @step + async def write_report(self, ctx: Context, ev: AnswerEvent) -> ReviewEvent: + # wait until we receive as many answers as there are questions + num_questions = await ctx.store.get("num_questions") + results = ctx.collect_events(ev, [AnswerEvent] * num_questions) + if results is None: + return None + + # maintain a list of all questions and answers no matter how many times this step is called + try: + previous_questions = await ctx.store.get("previous_questions") + except: + previous_questions = [] + previous_questions.extend(results) + await ctx.store.set("previous_questions", previous_questions) + + prompt = f"""You are an expert at writing blog posts. You are given an outline of a blog post + and a series of questions and answers that should provide all the data you need to write the + blog post. Compose the blog post according to the outline, using only the data given in the + answers. The outline is in and the questions and answers are in and + . + {await ctx.store.get('outline')}""" + + for result in previous_questions: + prompt += f"{result.question}\n{result.answer}\n" + + ctx.write_event_to_stream( + ProgressEvent(progress="Writing report with prompt:\n" + prompt) + ) + + report = await Settings.llm.acomplete(prompt) + + return ReviewEvent(report=str(report)) + + # review the report. If it still needs work, formulate some more questions. + @step + async def review_report( + self, ctx: Context, ev: ReviewEvent + ) -> StopEvent | QuestionEvent: + # we re-review a maximum of 3 times + try: + num_reviews = await ctx.store.get("num_reviews") + except: + num_reviews = 1 + num_reviews += 1 + await ctx.store.set("num_reviews", num_reviews) + + report = ev.report + + prompt = f"""You are an expert reviewer of blog posts. You are given an original query, + and a blog post that was written to satisfy that query. Review the blog post and determine + if it adequately answers the query and contains enough detail. If it doesn't, come up with + a set of questions that will get you the facts necessary to expand the blog post. Another + agent will answer those questions. Your response should just be a list of questions, one + per line, without any preamble or explanation. For speed, generate a maximum of 4 questions. + The original query is: '{await ctx.store.get('original_query')}'. + The blog post is: {report}. + If the blog post is fine, return just the string 'OKAY'.""" + + response = await Settings.llm.acomplete(prompt) + + if response == "OKAY" or await ctx.store.get("num_reviews") >= 3: + ctx.write_event_to_stream( + ProgressEvent(progress="Blog post is fine") + ) + return StopEvent(result=report) + else: + questions = str(response).split("\n") + await ctx.store.set("num_questions", len(questions)) + ctx.write_event_to_stream( + ProgressEvent(progress="Formulated some more questions") + ) + for question in questions: + ctx.send_event(QuestionEvent(question=question)) +``` + +## Test the Agent + +Run the Agent with a query and look at the generated blog post written to answer it + + +```python +agent = DocumentResearchAgent(timeout=600, verbose=True) +handler = agent.run( + query="Tell me about the budget of the San Francisco Police Department in 2023", + tools=[budget_tool], +) +async for ev in handler.stream_events(): + if isinstance(ev, ProgressEvent): + print(ev.progress) +final_result = await handler +print("------- Blog post ----------\n", final_result) +``` + + Running step formulate_plan + Step formulate_plan produced event OutlineEvent + Outline: + Here is a detailed outline for the blog post on the budget of the San Francisco Police Department in 2023: + + **I. Introduction** + + * Brief overview of the San Francisco Police Department (SFPD) and its role in the city + * Importance of understanding the budget of the SFPD + * Thesis statement: The 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy, and understanding its allocation and priorities is essential for ensuring effective policing and community safety. + + **II. Overview of the 2023 Budget** + + * Total budget allocation for the SFPD in 2023 + * Comparison to previous years' budgets (e.g., 2022, 2021) + * Breakdown of the budget into major categories (e.g., personnel, operations, equipment, training) + + **III. Personnel Costs** + + * Salary and benefits for sworn officers and civilian staff + * Number of personnel and staffing levels + * Recruitment and retention strategies and their associated costs + * Discussion of any notable changes or trends in personnel costs (e.g., increased overtime, hiring freezes) + + **IV. Operational Expenses** + + * Overview of operational expenses, including: + + Fuel and vehicle maintenance + + Equipment and supplies (e.g., firearms, body armor, communication devices) + + Facility maintenance and utilities + + Travel and training expenses + * Discussion of any notable changes or trends in operational expenses (e.g., increased fuel costs, new equipment purchases) + + **V. Community Policing and Outreach Initiatives** + + * Overview of community policing and outreach initiatives, including: + + Neighborhood policing programs + + Youth and community engagement programs + + Mental health and crisis response services + * Budget allocation for these initiatives and discussion of their effectiveness + + **VI. Technology and Equipment Upgrades** + + * Overview of technology and equipment upgrades, including: + + Body-worn cameras and other surveillance technology + + Communication systems and emergency response infrastructure + + Forensic analysis and crime lab equipment + * Budget allocation for these upgrades and discussion of their impact on policing and public safety + + **VII. Challenges and Controversies** + + * Discussion of challenges and controversies related to the SFPD budget, including: + + Funding for police reform and accountability initiatives + + Criticisms of police spending and resource allocation + + Impact of budget constraints on policing services and community safety + + **VIII. Conclusion** + + * Summary of key findings and takeaways from the 2023 SFPD budget + * Discussion of implications for public safety and community policing in San Francisco + * Final thoughts and recommendations for future budget allocations and policing strategies. + + To fulfill this outline, the following questions will need to be answered: + + * What is the total budget allocation for the SFPD in 2023? + * How does the 2023 budget compare to previous years' budgets? + * What are the major categories of expenditure in the 2023 budget? + * What are the personnel costs, including salary and benefits, for sworn officers and civilian staff? + * What are the operational expenses, including fuel, equipment, and facility maintenance? + * What community policing and outreach initiatives are funded in the 2023 budget? + * What technology and equipment upgrades are planned or underway, and what is their budget allocation? + * What challenges and controversies are associated with the SFPD budget, and how are they being addressed? + + These questions will help to gather the necessary facts and information to create a comprehensive and informative blog post on the budget of the San Francisco Police Department in 2023. + Running step formulate_questions + Step formulate_questions produced no event + Formulated questions: + What is the total budget allocation for the SFPD in 2023? + How does the 2023 budget compare to the 2022 budget? + What are the major categories of expenditure in the 2023 budget? + What are the personnel costs, including salary and benefits, for sworn officers? + What are the operational expenses, including fuel and vehicle maintenance? + What community policing and outreach initiatives are funded in the 2023 budget? + What technology and equipment upgrades are planned or underway? + What challenges and controversies are associated with the SFPD budget? + Questions: + What is the total budget allocation for the SFPD in 2023? + How does the 2023 budget compare to the 2022 budget? + What are the major categories of expenditure in the 2023 budget? + What are the personnel costs, including salary and benefits, for sworn officers? + What are the operational expenses, including fuel and vehicle maintenance? + What community policing and outreach initiatives are funded in the 2023 budget? + What technology and equipment upgrades are planned or underway? + What challenges and controversies are associated with the SFPD budget? + Running step answer_question + > Running step d0e11f46-4071-43aa-9f06-0ddffe477928. Step input: What is the total budget allocation for the SFPD in 2023? + Added user message to memory: What is the total budget allocation for the SFPD in 2023? + Running step answer_question + > Running step 44ded067-ea4c-4575-97b2-5fbaf444b189. Step input: How does the 2023 budget compare to the 2022 budget? + Added user message to memory: How does the 2023 budget compare to the 2022 budget? + Running step answer_question + > Running step 28b603af-894b-4654-949d-48340149d8e8. Step input: What are the major categories of expenditure in the 2023 budget? + Added user message to memory: What are the major categories of expenditure in the 2023 budget? + Running step answer_question + > Running step 5c6a5ebb-3787-4401-a5e3-aa93e03d1832. Step input: What are the personnel costs, including salary and benefits, for sworn officers? + Added user message to memory: What are the personnel costs, including salary and benefits, for sworn officers? + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "SFPD total budget allocation 2023"} + === LLM Response === + {"input": "personnel costs for sworn officers"} + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 3853365e-fd6d-498d-b92f-25f8969ffe43. Step input: What are the operational expenses, including fuel and vehicle maintenance? + Added user message to memory: What are the operational expenses, including fuel and vehicle maintenance? + To question 'What are the personnel costs, including salary and benefits, for sworn officers?' the agent answered: {"input": "personnel costs for sworn officers"} + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "major categories of expenditure in the 2023 budget"} + === LLM Response === + {"input": "compare 2023 budget to 2022 budget"} + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 4487ccea-3e7e-4378-b299-a5372dbc6aaf. Step input: What community policing and outreach initiatives are funded in the 2023 budget? + Added user message to memory: What community policing and outreach initiatives are funded in the 2023 budget? + To question 'How does the 2023 budget compare to the 2022 budget?' the agent answered: {"input": "compare 2023 budget to 2022 budget"} + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "operational expenses, including fuel and vehicle maintenance"} + === LLM Response === + {"input": "community policing and outreach initiatives 2023 budget"} + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 75022818-5d76-4443-b3c6-c5558991713c. Step input: What technology and equipment upgrades are planned or underway? + Added user message to memory: What technology and equipment upgrades are planned or underway? + To question 'What community policing and outreach initiatives are funded in the 2023 budget?' the agent answered: {"input": "community policing and outreach initiatives 2023 budget"} + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "technology and equipment upgrades planned or underway"} + === Function Output === + The query is asking for the SFPD total budget allocation for 2023, but the provided context does not mention the SFPD's budget for 2023. It discusses the budgets of the Juvenile Probation Department and the Public Utilities Commission. Therefore, the original answer cannot be rewritten with the new context, and the original answer should be repeated. + + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + > Running step 927d5844-8c20-4cc8-a50f-52248963206f. Step input: None + === LLM Response === + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 0dcc7a13-046a-4259-96eb-7a2817530875. Step input: What challenges and controversies are associated with the SFPD budget? + Added user message to memory: What challenges and controversies are associated with the SFPD budget? + To question 'What is the total budget allocation for the SFPD in 2023?' the agent answered: The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "SFPD budget challenges and controversies"} + === Function Output === + Non-Personnel Services, which includes expenses such as fuel and vehicle maintenance, has a budget of $1,088,786,650 for 2024-2025, showing a continued significant allocation for operational expenses. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + > Running step a55db034-f7ba-4e87-960e-0605574c3398. Step input: None + === LLM Response === + The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + Step answer_question produced event AnswerEvent + To question 'What are the operational expenses, including fuel and vehicle maintenance?' the agent answered: The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + Running step write_report + Step write_report produced no event + === Function Output === + Several technology and equipment upgrades are planned or underway. The City is investing in vital technology projects, including the replacement of critical systems and the development of new platforms to enhance city services and operations. The City's focus on cloud solutions continues, with efforts to expand and optimize cloud services, including the provisioning of Infrastructure-as-a-Service (IaaS) and Platform-as-a-Service (PaaS) to support daily operations. Additionally, the City is working on initiatives to improve digital accessibility and inclusion, and to develop new applications that enhance the speed, security, performance, and reliability of City services. The establishment of centers of excellence, such as the Cloud Center of Excellence, aims to help departments leverage technology more effectively and efficiently. Furthermore, the City is exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + > Running step f34e8f8a-9c59-4e02-9394-a8293ff24af6. Step input: None + === LLM Response === + The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + Step answer_question produced event AnswerEvent + To question 'What technology and equipment upgrades are planned or underway?' the agent answered: The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + Running step write_report + Step write_report produced no event + === Function Output === + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + > Running step 1b1640ad-977c-423d-b88d-e9cf4de53e5b. Step input: None + === LLM Response === + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + Step answer_question produced event AnswerEvent + To question 'What are the major categories of expenditure in the 2023 budget?' the agent answered: The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + Running step write_report + Step write_report produced no event + === Function Output === + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, with staffing levels continuing to fall behind recommended levels as separations have outpaced recruiting. The Department is also dealing with chronic understaffing, which requires overtime funding support to ensure necessary deployment levels. Furthermore, the SFPD is working to implement reforms and achieve substantial compliance with state laws, including SB 1421, SB 16, and SB 2, which requires investments in information technology, training, and other resources. + + In the context of project spending, the SFPD's budget challenges are exacerbated by the need to allocate resources for various projects, such as technology upgrades, training programs, and community initiatives. The Department must balance these competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community, particularly in light of the need for periodic biased policing audits, may also be a subject of controversy and debate. Additionally, the budget's focus on increasing salaries and benefits for sworn staff, as well as the expansion of programs aimed at improving community relations, may be seen as contentious by some stakeholders. + + Given the projected deficit, the Mayor's requirement for departments to propose budget reductions may impact the SFPD's ability to allocate resources for these projects, potentially affecting the Department's ability to implement reforms and achieve its goals. The SFPD must navigate these challenges and controversies to ensure effective and responsible use of its budget, while also addressing the needs and concerns of the community. + > Running step 3ba46541-2a08-446a-b3fc-2c3df3be814f. Step input: None + === LLM Response === + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + Step answer_question produced event AnswerEvent + To question 'What challenges and controversies are associated with the SFPD budget?' the agent answered: The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + Running step write_report + Writing report with prompt: + You are an expert at writing blog posts. You are given an outline of a blog post + and a series of questions and answers that should provide all the data you need to write the + blog post. Compose the blog post according to the outline, using only the data given in the + answers. The outline is in and the questions and answers are in and + . + Here is a detailed outline for the blog post on the budget of the San Francisco Police Department in 2023: + + **I. Introduction** + + * Brief overview of the San Francisco Police Department (SFPD) and its role in the city + * Importance of understanding the budget of the SFPD + * Thesis statement: The 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy, and understanding its allocation and priorities is essential for ensuring effective policing and community safety. + + **II. Overview of the 2023 Budget** + + * Total budget allocation for the SFPD in 2023 + * Comparison to previous years' budgets (e.g., 2022, 2021) + * Breakdown of the budget into major categories (e.g., personnel, operations, equipment, training) + + **III. Personnel Costs** + + * Salary and benefits for sworn officers and civilian staff + * Number of personnel and staffing levels + * Recruitment and retention strategies and their associated costs + * Discussion of any notable changes or trends in personnel costs (e.g., increased overtime, hiring freezes) + + **IV. Operational Expenses** + + * Overview of operational expenses, including: + + Fuel and vehicle maintenance + + Equipment and supplies (e.g., firearms, body armor, communication devices) + + Facility maintenance and utilities + + Travel and training expenses + * Discussion of any notable changes or trends in operational expenses (e.g., increased fuel costs, new equipment purchases) + + **V. Community Policing and Outreach Initiatives** + + * Overview of community policing and outreach initiatives, including: + + Neighborhood policing programs + + Youth and community engagement programs + + Mental health and crisis response services + * Budget allocation for these initiatives and discussion of their effectiveness + + **VI. Technology and Equipment Upgrades** + + * Overview of technology and equipment upgrades, including: + + Body-worn cameras and other surveillance technology + + Communication systems and emergency response infrastructure + + Forensic analysis and crime lab equipment + * Budget allocation for these upgrades and discussion of their impact on policing and public safety + + **VII. Challenges and Controversies** + + * Discussion of challenges and controversies related to the SFPD budget, including: + + Funding for police reform and accountability initiatives + + Criticisms of police spending and resource allocation + + Impact of budget constraints on policing services and community safety + + **VIII. Conclusion** + + * Summary of key findings and takeaways from the 2023 SFPD budget + * Discussion of implications for public safety and community policing in San Francisco + * Final thoughts and recommendations for future budget allocations and policing strategies. + + To fulfill this outline, the following questions will need to be answered: + + * What is the total budget allocation for the SFPD in 2023? + * How does the 2023 budget compare to previous years' budgets? + * What are the major categories of expenditure in the 2023 budget? + * What are the personnel costs, including salary and benefits, for sworn officers and civilian staff? + * What are the operational expenses, including fuel, equipment, and facility maintenance? + * What community policing and outreach initiatives are funded in the 2023 budget? + * What technology and equipment upgrades are planned or underway, and what is their budget allocation? + * What challenges and controversies are associated with the SFPD budget, and how are they being addressed? + + These questions will help to gather the necessary facts and information to create a comprehensive and informative blog post on the budget of the San Francisco Police Department in 2023.What are the personnel costs, including salary and benefits, for sworn officers? + {"input": "personnel costs for sworn officers"} + How does the 2023 budget compare to the 2022 budget? + {"input": "compare 2023 budget to 2022 budget"} + What community policing and outreach initiatives are funded in the 2023 budget? + {"input": "community policing and outreach initiatives 2023 budget"} + What is the total budget allocation for the SFPD in 2023? + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + What are the operational expenses, including fuel and vehicle maintenance? + The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + What technology and equipment upgrades are planned or underway? + The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + What are the major categories of expenditure in the 2023 budget? + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + What challenges and controversies are associated with the SFPD budget? + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + + Step write_report produced event ReviewEvent + Running step review_report + Step review_report produced no event + Formulated some more questions + Running step answer_question + > Running step 1515025f-3d98-48ef-82dc-fe1ccb395c95. Step input: What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget? + Added user message to memory: What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget? + Running step answer_question + > Running step 89d8cbfd-decd-4f6e-875c-ee764cc51d57. Step input: What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget? + Added user message to memory: What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget? + Running step answer_question + > Running step 78a4965f-1507-4238-8306-62c3e93582e3. Step input: What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget? + Added user message to memory: What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget? + Running step answer_question + > Running step ca4c2497-c62c-4fcd-8ae5-4108bfdf0864. Step input: How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway? + Added user message to memory: How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway? + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "community policing and outreach initiatives funding allocations 2023"} + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "SFPD personnel costs sworn officers 2023 budget breakdown salary benefits"} + === LLM Response === + {"input": "technology and equipment upgrades 2023 vs previous years and planned upgrades"} + Step answer_question produced event AnswerEvent + === LLM Response === + {"input": "SFPD operational expenses fuel vehicle maintenance 2023 budget"} + Step answer_question produced event AnswerEvent + To question 'How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway?' the agent answered: {"input": "technology and equipment upgrades 2023 vs previous years and planned upgrades"} + To question 'What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget?' the agent answered: {"input": "SFPD operational expenses fuel vehicle maintenance 2023 budget"} + Running step write_report + Step write_report produced no event + Running step write_report + Step write_report produced no event + === Function Output === + The department's commitment to community policing and outreach initiatives is reflected in the proposed budget for 2023, which includes substantial funding allocations. Specifically, $2.2 million is allocated in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs. These programs provide a range of support services to sworn officers and help foster positive relationships with the community. Additionally, the budget includes $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, such as the Community Ambassadors program, which aims to build trust and understanding between law enforcement and the communities they serve. Furthermore, $26.5 million is allocated in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors in key areas throughout the city. These investments underscore the department's dedication to enhancing community outreach and engagement, and to providing additional support services to address community needs, ultimately contributing to a safer and more connected community. + > Running step cf1ebb7d-a2d3-4360-b2d9-767859e64103. Step input: None + === LLM Response === + The 2023 budget for San Francisco allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs, ultimately contributing to a safer and more connected community. + Step answer_question produced event AnswerEvent + To question 'What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget?' the agent answered: The 2023 budget for San Francisco allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs, ultimately contributing to a safer and more connected community. + Running step write_report + Step write_report produced no event + === Function Output === + The Sheriff's Office budget for FY 2023-24 is $291.7 million, which is 2.5 percent lower than the FY 2022-23 budget. This decrease is primarily due to salary reductions from position vacancies and a decrease in overtime. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + + In terms of personnel costs, the Sheriff's Office is facing ongoing staffing challenges, resulting in a demand for overtime to meet mandated minimum staffing requirements. The proposed budget includes funding to meet the overtime needs of the Sheriff's Office in FY 2023-24. As the Office improves its regular staffing levels, the need for overtime spending will decrease. + + The Sheriff's Office is aggressively recruiting to fill numerous vacancies in its deputy sheriff positions and professional staff. The Office is also increasing its law enforcement presence in the community, expanding the field officer training program, and increasing staff in the warrant services unit. + + Regarding labor negotiations, the Employee Relations Division is responsible for negotiating all non-Municipal Transportation Agency labor contracts for City employees. In FY 2023-24, the Division will be negotiating collective bargaining agreements on behalf of 88 percent of the City's workforce covered by 34 union contracts. + + The City is also self-insuring for workers' compensation and is financially responsible for all workers' compensation liabilities. The Workers' Compensation Division will continue to advance its safety and health initiatives and partner with departments to implement the Temporary Transitional Work Assignment policy to improve Return to Work outcomes. + + The Mayor's proposed budget includes funding for the new Career Center at City Hall, which will help City employees access existing programs and resources that support their career goals. The Department will also launch and promote new career pathway programs, including a public safety pathway program and a health worker pathway program. + + The San Francisco Health Service System (SFHSS) is dedicated to preserving and improving sustainable, quality health benefits and enhancing the well-being of employees, retirees, and their families. The proposed FY 2023-24 budget for SFHSS is $13.9 million, which is 2.3 percent higher than the FY 2022-23 budget, due to enhanced Employee Assistance services and an increase in a work order with the Human Resources Department. + + SFHSS has completed its 2023-25 strategic plan, which includes strategic goals to foster equity, advance primary care practice, provide affordable and sustainable healthcare, and support the mental health and well-being of its membership. The SFHSS medical rates trend vs benchmarks shows that the rising cost of healthcare has outpaced inflation in most years, but SFHSS oversight has resulted in lower increases than the national average and inflation for four of the last five years. + > Running step cc8562aa-15ae-4a56-8bf9-54f6c8e976c9. Step input: None + === LLM Response === + The exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget is not explicitly stated in the provided information. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + Step answer_question produced event AnswerEvent + To question 'What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget?' the agent answered: The exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget is not explicitly stated in the provided information. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + Running step write_report + Writing report with prompt: + You are an expert at writing blog posts. You are given an outline of a blog post + and a series of questions and answers that should provide all the data you need to write the + blog post. Compose the blog post according to the outline, using only the data given in the + answers. The outline is in and the questions and answers are in and + . + Here is a detailed outline for the blog post on the budget of the San Francisco Police Department in 2023: + + **I. Introduction** + + * Brief overview of the San Francisco Police Department (SFPD) and its role in the city + * Importance of understanding the budget of the SFPD + * Thesis statement: The 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy, and understanding its allocation and priorities is essential for ensuring effective policing and community safety. + + **II. Overview of the 2023 Budget** + + * Total budget allocation for the SFPD in 2023 + * Comparison to previous years' budgets (e.g., 2022, 2021) + * Breakdown of the budget into major categories (e.g., personnel, operations, equipment, training) + + **III. Personnel Costs** + + * Salary and benefits for sworn officers and civilian staff + * Number of personnel and staffing levels + * Recruitment and retention strategies and their associated costs + * Discussion of any notable changes or trends in personnel costs (e.g., increased overtime, hiring freezes) + + **IV. Operational Expenses** + + * Overview of operational expenses, including: + + Fuel and vehicle maintenance + + Equipment and supplies (e.g., firearms, body armor, communication devices) + + Facility maintenance and utilities + + Travel and training expenses + * Discussion of any notable changes or trends in operational expenses (e.g., increased fuel costs, new equipment purchases) + + **V. Community Policing and Outreach Initiatives** + + * Overview of community policing and outreach initiatives, including: + + Neighborhood policing programs + + Youth and community engagement programs + + Mental health and crisis response services + * Budget allocation for these initiatives and discussion of their effectiveness + + **VI. Technology and Equipment Upgrades** + + * Overview of technology and equipment upgrades, including: + + Body-worn cameras and other surveillance technology + + Communication systems and emergency response infrastructure + + Forensic analysis and crime lab equipment + * Budget allocation for these upgrades and discussion of their impact on policing and public safety + + **VII. Challenges and Controversies** + + * Discussion of challenges and controversies related to the SFPD budget, including: + + Funding for police reform and accountability initiatives + + Criticisms of police spending and resource allocation + + Impact of budget constraints on policing services and community safety + + **VIII. Conclusion** + + * Summary of key findings and takeaways from the 2023 SFPD budget + * Discussion of implications for public safety and community policing in San Francisco + * Final thoughts and recommendations for future budget allocations and policing strategies. + + To fulfill this outline, the following questions will need to be answered: + + * What is the total budget allocation for the SFPD in 2023? + * How does the 2023 budget compare to previous years' budgets? + * What are the major categories of expenditure in the 2023 budget? + * What are the personnel costs, including salary and benefits, for sworn officers and civilian staff? + * What are the operational expenses, including fuel, equipment, and facility maintenance? + * What community policing and outreach initiatives are funded in the 2023 budget? + * What technology and equipment upgrades are planned or underway, and what is their budget allocation? + * What challenges and controversies are associated with the SFPD budget, and how are they being addressed? + + These questions will help to gather the necessary facts and information to create a comprehensive and informative blog post on the budget of the San Francisco Police Department in 2023.What are the personnel costs, including salary and benefits, for sworn officers? + {"input": "personnel costs for sworn officers"} + How does the 2023 budget compare to the 2022 budget? + {"input": "compare 2023 budget to 2022 budget"} + What community policing and outreach initiatives are funded in the 2023 budget? + {"input": "community policing and outreach initiatives 2023 budget"} + What is the total budget allocation for the SFPD in 2023? + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + What are the operational expenses, including fuel and vehicle maintenance? + The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + What technology and equipment upgrades are planned or underway? + The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + What are the major categories of expenditure in the 2023 budget? + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + What challenges and controversies are associated with the SFPD budget? + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway? + {"input": "technology and equipment upgrades 2023 vs previous years and planned upgrades"} + What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget? + {"input": "SFPD operational expenses fuel vehicle maintenance 2023 budget"} + What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget? + The 2023 budget for San Francisco allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs, ultimately contributing to a safer and more connected community. + What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget? + The exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget is not explicitly stated in the provided information. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + + Step write_report produced event ReviewEvent + Running step review_report + Step review_report produced event StopEvent + Blog post is fine + ------- Blog post ---------- + **The 2023 Budget of the San Francisco Police Department: Understanding Allocation and Priorities** + + The San Francisco Police Department (SFPD) plays a vital role in maintaining public safety and order in the city of San Francisco. As such, understanding the budget of the SFPD is crucial for ensuring effective policing and community safety. The 2023 budget of the SFPD is a critical component of the city's public safety strategy, and this blog post aims to provide an overview of the budget allocation and priorities. + + **Overview of the 2023 Budget** + + The total budget allocation for the SFPD in 2023 is $776.8 million. Compared to the 2022 budget, the 2023 budget has increased, although the exact percentage increase is not specified. The major categories of expenditure in the 2023 budget include citywide expenditures such as voter-mandated General Fund support for transit, libraries, and other baselines, as well as expenditures related to Human Welfare & Neighborhood Development. + + **Personnel Costs** + + The personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget are not explicitly stated. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + + **Operational Expenses** + + The operational expenses, including fuel and vehicle maintenance, have a significant budget allocation. Although the exact figure for the 2023 SFPD budget is not provided, the operational expenses for 2024-2025 have a budget of $1,088,786,650. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment. + + **Community Policing and Outreach Initiatives** + + The 2023 budget allocates significant funding to support community policing and outreach initiatives. Specifically, the budget allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs. + + **Technology and Equipment Upgrades** + + The City of San Francisco is planning or undertaking various technology and equipment upgrades, including replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Although the exact budget allocation for these upgrades is not specified, these initiatives aim to support the city's goals and improve policing and public safety. + + **Challenges and Controversies** + + The SFPD faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. + + **Conclusion** + + In conclusion, the 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy. Understanding the budget allocation and priorities is essential for ensuring effective policing and community safety. The budget allocates significant funding to support community policing and outreach initiatives, technology and equipment upgrades, and personnel costs. However, the SFPD also faces significant budget challenges and controversies, which must be addressed to ensure the effective and responsible use of its budget. As the city continues to evolve and grow, it is essential to prioritize public safety and ensure that the SFPD has the necessary resources to maintain order and protect the community. + + +## Sample output rendered as markdown + +We've taken the output of the agent and rendered it here: + +**The 2023 Budget of the San Francisco Police Department: Understanding Allocation and Priorities** + +The San Francisco Police Department (SFPD) plays a vital role in maintaining public safety and order in the city of San Francisco. As such, understanding the budget of the SFPD is crucial for ensuring effective policing and community safety. The 2023 budget of the SFPD is a critical component of the city's public safety strategy, and this blog post aims to provide an overview of the budget allocation and priorities. + +**Overview of the 2023 Budget** + +The total budget allocation for the SFPD in 2023 is $776.8 million. Compared to the 2022 budget, the 2023 budget has increased, although the exact percentage increase is not specified. The major categories of expenditure in the 2023 budget include citywide expenditures such as voter-mandated General Fund support for transit, libraries, and other baselines, as well as expenditures related to Human Welfare & Neighborhood Development. + +**Personnel Costs** + +The personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget are not explicitly stated. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + +**Operational Expenses** + +The operational expenses, including fuel and vehicle maintenance, have a significant budget allocation. Although the exact figure for the 2023 SFPD budget is not provided, the operational expenses for 2024-2025 have a budget of $1,088,786,650. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment. + +**Community Policing and Outreach Initiatives** + +The 2023 budget allocates significant funding to support community policing and outreach initiatives. Specifically, the budget allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs. + +**Technology and Equipment Upgrades** + +The City of San Francisco is planning or undertaking various technology and equipment upgrades, including replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Although the exact budget allocation for these upgrades is not specified, these initiatives aim to support the city's goals and improve policing and public safety. + +**Challenges and Controversies** + +The SFPD faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. + +**Conclusion** + +In conclusion, the 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy. Understanding the budget allocation and priorities is essential for ensuring effective policing and community safety. The budget allocates significant funding to support community policing and outreach initiatives, technology and equipment upgrades, and personnel costs. However, the SFPD also faces significant budget challenges and controversies, which must be addressed to ensure the effective and responsible use of its budget. As the city continues to evolve and grow, it is essential to prioritize public safety and ensure that the SFPD has the necessary resources to maintain order and protect the community. + +## Agentic strategies produce better results + +As you can see in the output, the agent attempts to fulfill the request with an initial set of questions and answers, decides it needs more input, and asks more questions before settling on the final result. This ability to self-reflect and improve is part of why agentic strategies are such a powerful way to improve the quality of generative AI output. diff --git a/.tmp/agent/nvidia_sub_question_query_engine.md b/.tmp/agent/nvidia_sub_question_query_engine.md new file mode 100644 index 0000000..47eb11e --- /dev/null +++ b/.tmp/agent/nvidia_sub_question_query_engine.md @@ -0,0 +1,297 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/nvidia_sub_question_query_engine.ipynb +toc: True +title: "Sub Question Query Engine powered by NVIDIA NIMs" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +A Sub Question Query Engine takes a single, complex question and breaks it into multiple sub-questions, each of which can be answered by a different tool. We'll use NVIDIA NIMs to power our sub-question generation and answer retrieval. + + +### NVIDIA NIMs + +NIM supports models across domains like chat, embedding, and re-ranking models +from the community as well as NVIDIA. These models are optimized by NVIDIA to deliver the best performance on NVIDIA +accelerated infrastructure and deployed as a NIM, an easy-to-use, prebuilt containers that deploy anywhere using a single +command on NVIDIA accelerated infrastructure. + +NVIDIA hosted deployments of NIMs are available to test on the [NVIDIA API catalog](https://build.nvidia.com/). After testing, +NIMs can be exported from NVIDIA’s API catalog using the NVIDIA AI Enterprise license and run on-premises or in the cloud, +giving enterprises ownership and full control of their IP and AI application. + +NIMs are packaged as container images on a per model basis and are distributed as NGC container images through the NVIDIA NGC Catalog. +At their core, NIMs provide easy, consistent, and familiar APIs for running inference on an AI model. + +## Setup +Import our dependencies and set up our NVIDIA API key from the API catalog, https://build.nvidia.com for the two models we'll use hosted on the catalog (embedding and re-ranking models). + +**To get started:** + +1. Create a free account with [NVIDIA](https://build.nvidia.com/), which hosts NVIDIA AI Foundation models. + +2. Click on your model of choice. + +3. Under Input select the Python tab, and click `Get API Key`. Then click `Generate Key`. + +4. Copy and save the generated key as NVIDIA_API_KEY. From there, you should have access to the endpoints. + +**Install our dependencies:** +* LlamaIndex core for most things +* NVIDIA NIM LLM and embeddings for LLM actions +* `llama-index-readers-file` to power the PDF reader in `SimpleDirectoryReader` + + + + +```python +!pip install llama-index-core llama-index-llms-nvidia llama-index-embeddings-nvidia llama-index-readers-file llama-index-utils-workflow +``` + +Bring in our dependencies as imports: + + +```python +import os, json +from llama_index.core import ( + SimpleDirectoryReader, + VectorStoreIndex, + StorageContext, + load_index_from_storage, + Settings, +) +from llama_index.core.tools import QueryEngineTool, ToolMetadata +from llama_index.core.workflow import ( + step, + Context, + Workflow, + Event, + StartEvent, + StopEvent, +) +from llama_index.core.agent.workflow import ReActAgent +from llama_index.llms.nvidia import NVIDIA +from llama_index.embeddings.nvidia import NVIDIAEmbedding +from llama_index.utils.workflow import draw_all_possible_flows +``` + +# Define the Sub Question Query Engine as a Workflow + +* Our StartEvent goes to `query()`, which takes care of several things: + * Accepts and stores the original query + * Stores the LLM to handle the queries + * Stores the list of tools to enable sub-questions + * Passes the original question to the LLM, asking it to split up the question into sub-questions + * Fires off a `QueryEvent` for every sub-question generated + +* QueryEvents go to `sub_question()`, which instantiates a new ReAct agent with the full list of tools available and lets it select which one to use. + * This is slightly better than the actual SQQE built-in to LlamaIndex, which cannot use multiple tools + * Each QueryEvent generates an `AnswerEvent` + +* AnswerEvents go to `combine_answers()`. + * This uses `self.collect_events()` to wait for every QueryEvent to return an answer. + * All the answers are then combined into a final prompt for the LLM to consolidate them into a single response + * A StopEvent is generated to return the final result + + +```python +class QueryEvent(Event): + question: str + + +class AnswerEvent(Event): + question: str + answer: str + + +class SubQuestionQueryEngine(Workflow): + @step + async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent: + if hasattr(ev, "query"): + await ctx.store.set("original_query", ev.query) + print(f"Query is {await ctx.store.get('original_query')}") + + if hasattr(ev, "llm"): + await ctx.store.set("llm", ev.llm) + + if hasattr(ev, "tools"): + await ctx.store.set("tools", ev.tools) + + response = (await ctx.store.get("llm")).complete( + f""" + Given a user question, and a list of tools, output a list of + relevant sub-questions, such that the answers to all the + sub-questions put together will answer the question. Respond + in pure JSON without any markdown, like this: + {{ + "sub_questions": [ + "What is the population of San Francisco?", + "What is the budget of San Francisco?", + "What is the GDP of San Francisco?" + ] + }} + Here is the user question: {await ctx.store.get('original_query')} + + And here is the list of tools: {await ctx.store.get('tools')} + """ + ) + + print(f"Sub-questions are {response}") + + response_obj = json.loads(str(response)) + sub_questions = response_obj["sub_questions"] + + await ctx.store.set("sub_question_count", len(sub_questions)) + + for question in sub_questions: + self.send_event(QueryEvent(question=question)) + + return None + + @step + async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent: + print(f"Sub-question is {ev.question}") + + agent = ReActAgent( + tools=await ctx.store.get("tools"), + llm=await ctx.store.get("llm"), + ) + response = await agent.run(ev.question) + + return AnswerEvent(question=ev.question, answer=str(response)) + + @step + async def combine_answers( + self, ctx: Context, ev: AnswerEvent + ) -> StopEvent | None: + ready = ctx.collect_events( + ev, [AnswerEvent] * await ctx.store.get("sub_question_count") + ) + if ready is None: + return None + + answers = "\n\n".join( + [ + f"Question: {event.question}: \n Answer: {event.answer}" + for event in ready + ] + ) + + prompt = f""" + You are given an overall question that has been split into sub-questions, + each of which has been answered. Combine the answers to all the sub-questions + into a single answer to the original question. + + Original question: {await ctx.store.get('original_query')} + + Sub-questions and answers: + {answers} + """ + + print(f"Final prompt is {prompt}") + + response = (await ctx.store.get("llm")).complete(prompt) + + print("Final response is", response) + + return StopEvent(result=str(response)) +``` + + +```python +draw_all_possible_flows( + SubQuestionQueryEngine, filename="sub_question_query_engine.html" +) +``` + +Visualizing this flow looks pretty linear, since it doesn't capture that `query()` can generate multiple parallel `QueryEvents` which get collected into `combine_answers`. + +![Screenshot 2024-08-07 at 3.31.55 PM.png](data:image/png;base64,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) + +# Download data to demo + + +```python +!mkdir -p "./data/sf_budgets/" +!wget "https://www.dropbox.com/scl/fi/xt3squt47djba0j7emmjb/2016-CSF_Budget_Book_2016_FINAL_WEB_with-cover-page.pdf?rlkey=xs064cjs8cb4wma6t5pw2u2bl&dl=0" -O "./data/sf_budgets/2016 - CSF_Budget_Book_2016_FINAL_WEB_with-cover-page.pdf" +!wget "https://www.dropbox.com/scl/fi/jvw59g5nscu1m7f96tjre/2017-Proposed-Budget-FY2017-18-FY2018-19_1.pdf?rlkey=v988oigs2whtcy87ti9wti6od&dl=0" -O "./data/sf_budgets/2017 - 2017-Proposed-Budget-FY2017-18-FY2018-19_1.pdf" +!wget "https://www.dropbox.com/scl/fi/izknlwmbs7ia0lbn7zzyx/2018-o0181-18.pdf?rlkey=p5nv2ehtp7272ege3m9diqhei&dl=0" -O "./data/sf_budgets/2018 - 2018-o0181-18.pdf" +!wget "https://www.dropbox.com/scl/fi/1rstqm9rh5u5fr0tcjnxj/2019-Proposed-Budget-FY2019-20-FY2020-21.pdf?rlkey=3s2ivfx7z9bev1r840dlpbcgg&dl=0" -O "./data/sf_budgets/2019 - 2019-Proposed-Budget-FY2019-20-FY2020-21.pdf" +!wget "https://www.dropbox.com/scl/fi/7teuwxrjdyvgw0n8jjvk0/2021-AAO-FY20-21-FY21-22-09-11-2020-FINAL.pdf?rlkey=6br3wzxwj5fv1f1l8e69nbmhk&dl=0" -O "./data/sf_budgets/2021 - 2021-AAO-FY20-21-FY21-22-09-11-2020-FINAL.pdf" +!wget "https://www.dropbox.com/scl/fi/zhgqch4n6xbv9skgcknij/2022-AAO-FY2021-22-FY2022-23-FINAL-20210730.pdf?rlkey=h78t65dfaz3mqbpbhl1u9e309&dl=0" -O "./data/sf_budgets/2022 - 2022-AAO-FY2021-22-FY2022-23-FINAL-20210730.pdf" +!wget "https://www.dropbox.com/scl/fi/vip161t63s56vd94neqlt/2023-CSF_Proposed_Budget_Book_June_2023_Master_Web.pdf?rlkey=hemoce3w1jsuf6s2bz87g549i&dl=0" -O "./data/sf_budgets/2023 - 2023-CSF_Proposed_Budget_Book_June_2023_Master_Web.pdf" +``` + +# Load data and run the workflow + +Just like using the built-in Sub-Question Query Engine, we create our query tools and instantiate an LLM and pass them in. + +Each tool is its own query engine based on a single (very lengthy) San Francisco budget document, each of which is 300+ pages. To save time on repeated runs, we persist our generated indexes to disk. + + +```python +import getpass + +if os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"): + print("Valid NVIDIA_API_KEY already in environment. Delete to reset") +else: + nvapi_key = getpass.getpass("NVAPI Key (starts with nvapi-): ") + assert nvapi_key.startswith( + "nvapi-" + ), f"{nvapi_key[:5]}... is not a valid key" + os.environ["NVIDIA_API_KEY"] = nvapi_key + +folder = "./data/sf_budgets/" +files = os.listdir(folder) + +Settings.embed_model = NVIDIAEmbedding( + model="nvidia/nv-embedqa-e5-v5", truncate="END" +) +Settings.llm = NVIDIA() + +query_engine_tools = [] +for file in files: + year = file.split(" - ")[0] + index_persist_path = f"./storage/budget-{year}/" + + if os.path.exists(index_persist_path): + storage_context = StorageContext.from_defaults( + persist_dir=index_persist_path + ) + index = load_index_from_storage(storage_context) + else: + documents = SimpleDirectoryReader( + input_files=[folder + file] + ).load_data() + index = VectorStoreIndex.from_documents(documents) + index.storage_context.persist(index_persist_path) + + engine = index.as_query_engine() + query_engine_tools.append( + QueryEngineTool( + query_engine=engine, + metadata=ToolMetadata( + name=f"budget_{year}", + description=f"You can ask this tool natural-language questions about San Francisco's budget in {year}", + ), + ) + ) +``` + + +```python +engine = SubQuestionQueryEngine(timeout=120, verbose=True) +result = await engine.run( + llm=Settings.llm, + tools=query_engine_tools, + query="How has the total amount of San Francisco's budget changed from 2016 to 2023?", +) + +print(result) +``` + +Our debug output is lengthy! You can see the sub-questions being generated and then `sub_question()` being repeatedly invoked, each time generating a brief log of ReAct agent thoughts and actions to answer each smaller question. + +You can see `combine_answers` running multiple times; these were triggered by each `AnswerEvent` but before all 8 `AnswerEvents` were collected. On its final run it generates a full prompt, combines the answers and returns the result. diff --git a/.tmp/agent/openai_agent_context_retrieval.md b/.tmp/agent/openai_agent_context_retrieval.md new file mode 100644 index 0000000..2afa580 --- /dev/null +++ b/.tmp/agent/openai_agent_context_retrieval.md @@ -0,0 +1,295 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_context_retrieval.ipynb +toc: True +title: "Context-Augmented Function Calling Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this tutorial, we show you how to to make your agent context-aware. + +Our indexing/retrieval modules help to remove the complexity of having too many functions to fit in the prompt. + +## Initial Setup + +Here we setup a normal FunctionAgent, and then augment it with context. This agent will perform retrieval first before calling any tools. This can help ground the agent's tool picking and answering capabilities in context. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core.settings import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +import json +from typing import Sequence + +from llama_index.core import ( + SimpleDirectoryReader, + VectorStoreIndex, + StorageContext, + load_index_from_storage, +) +from llama_index.core.tools import QueryEngineTool +``` + + +```python +try: + storage_context = StorageContext.from_defaults( + persist_dir="./storage/march" + ) + march_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/june" + ) + june_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/sept" + ) + sept_index = load_index_from_storage(storage_context) + + index_loaded = True +except: + index_loaded = False +``` + +Download Data + + +```python +!mkdir -p 'data/10q/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_march_2022.pdf' -O 'data/10q/uber_10q_march_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_june_2022.pdf' -O 'data/10q/uber_10q_june_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_sept_2022.pdf' -O 'data/10q/uber_10q_sept_2022.pdf' +``` + + +```python +# build indexes across the three data sources +if not index_loaded: + # load data + march_docs = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_march_2022.pdf"] + ).load_data() + june_docs = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_june_2022.pdf"] + ).load_data() + sept_docs = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_sept_2022.pdf"] + ).load_data() + + # build index + march_index = VectorStoreIndex.from_documents(march_docs) + june_index = VectorStoreIndex.from_documents(june_docs) + sept_index = VectorStoreIndex.from_documents(sept_docs) + + # persist index + march_index.storage_context.persist(persist_dir="./storage/march") + june_index.storage_context.persist(persist_dir="./storage/june") + sept_index.storage_context.persist(persist_dir="./storage/sept") +``` + + +```python +march_engine = march_index.as_query_engine(similarity_top_k=3) +june_engine = june_index.as_query_engine(similarity_top_k=3) +sept_engine = sept_index.as_query_engine(similarity_top_k=3) +``` + + +```python +query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=march_engine, + name="uber_march_10q", + description=( + "Provides information about Uber 10Q filings for March 2022. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=june_engine, + name="uber_june_10q", + description=( + "Provides information about Uber financials for June 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=sept_engine, + name="uber_sept_10q", + description=( + "Provides information about Uber financials for Sept 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), +] +``` + +### Try Context-Augmented Agent + +Here we augment our agent with context in different settings: +- toy context: we define some abbreviations that map to financial terms (e.g. R=Revenue). We supply this as context to the agent + + +```python +from llama_index.core import Document +from llama_index.core.agent.workflow import FunctionAgent +``` + + +```python +# toy index - stores a list of abbreviations +texts = [ + "Abbreviation: 'Y' = Revenue", + "Abbreviation: 'X' = Risk Factors", + "Abbreviation: 'Z' = Costs", +] +docs = [Document(text=t) for t in texts] +context_index = VectorStoreIndex.from_documents(docs) +context_retriever = context_index.as_retriever(similarity_top_k=2) +``` + + +```python +from llama_index.core.tools import BaseTool + +system_prompt_template = """You are a helpful assistant. +Here is some context that you can use to answer the user's question and for help with picking the right tool: + +{context} +""" + + +async def get_agent_with_context_awareness( + query: str, context_retriever, tools: list[BaseTool] +) -> FunctionAgent: + context_nodes = await context_retriever.aretrieve(query) + context_text = "\n----\n".join([n.node.text for n in context_nodes]) + + return FunctionAgent( + tools=tools, + llm=OpenAI(model="gpt-4o"), + system_prompt=system_prompt_template.format(context=context_text), + ) +``` + + +```python +query = "What is the 'X' of March 2022?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) + +response = await agent.run(query) +``` + + +```python +print(str(response)) +``` + + The risk factors mentioned in Uber's 10-Q filing for March 2022 include uncertainties related to the COVID-19 pandemic, such as the severity and duration of the outbreak, potential future waves or variants of the virus, the administration and efficacy of vaccines, and the impact of governmental actions. There are also concerns regarding the effects on drivers, merchants, consumers, and business partners, as well as other factors that may affect the company's business, results of operations, financial position, and cash flows. + + + +```python +query = "What is the 'Y' and 'Z' in September 2022?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) + +response = await agent.run(query) +``` + + +```python +print(str(response)) +``` + + In September 2022, Uber's revenue (Y) was $8,343 million, and the total costs (Z) were $8,839 million. + + +### Managing Context/Memory + +By default, each `.run()` call is stateless. We can manage context by using a serializable `Context` object. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) + +query = "What is the 'Y' and 'Z' in September 2022?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) +response = await agent.run(query, ctx=ctx) + +query = "What did I just ask?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) +response = await agent.run(query, ctx=ctx) +print(str(response)) +``` + + You asked for the revenue ('Y') and costs ('Z') for Uber in September 2022. + + +### Use Uber 10-Q as context, use Calculator as Tool + + +```python +from llama_index.core.tools import FunctionTool + + +def magic_formula(revenue: int, cost: int) -> int: + """Runs MAGIC_FORMULA on revenue and cost.""" + return revenue - cost + + +magic_tool = FunctionTool.from_defaults(magic_formula) +``` + + +```python +context_retriever = sept_index.as_retriever(similarity_top_k=3) +``` + + +```python +query = "Can you run MAGIC_FORMULA on Uber's revenue and cost?" +agent = await get_agent_with_context_awareness( + query, context_retriever, [magic_tool] +) +response = await agent.run(query) +print(str(response)) +``` + + The result of running MAGIC_FORMULA on Uber's revenue of $8,343 million and cost of $5,173 million is 3,170. + diff --git a/.tmp/agent/openai_agent_lengthy_tools.md b/.tmp/agent/openai_agent_lengthy_tools.md new file mode 100644 index 0000000..7a98c4a --- /dev/null +++ b/.tmp/agent/openai_agent_lengthy_tools.md @@ -0,0 +1,401 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_lengthy_tools.ipynb +toc: True +title: "OpenAI Agent Workarounds for Lengthy Tool Descriptions" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this demo, we illustrate a workaround for defining an OpenAI tool +whose description exceeds OpenAI's current limit of 1024 characters. +For simplicity, we will build upon the `QueryPlanTool` notebook +example. + +If you're opening this Notebook on Colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index-agent-openai +%pip install llama-index-llms-openai +``` + + +```python +!pip install llama-index +``` + + +```python +%load_ext autoreload +%autoreload 2 +``` + + +```python +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.llms.openai import OpenAI +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +llm = OpenAI(temperature=0, model="gpt-4") +``` + +## Download Data + + +```python +!mkdir -p 'data/10q/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_march_2022.pdf' -O 'data/10q/uber_10q_march_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_june_2022.pdf' -O 'data/10q/uber_10q_june_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_sept_2022.pdf' -O 'data/10q/uber_10q_sept_2022.pdf' +``` + + --2024-05-23 13:36:24-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_march_2022.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1260185 (1.2M) [application/octet-stream] + Saving to: ‘data/10q/uber_10q_march_2022.pdf’ + + data/10q/uber_10q_m 100%[===================>] 1.20M --.-KB/s in 0.04s + + 2024-05-23 13:36:24 (29.0 MB/s) - ‘data/10q/uber_10q_march_2022.pdf’ saved [1260185/1260185] + + --2024-05-23 13:36:24-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_june_2022.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1238483 (1.2M) [application/octet-stream] + Saving to: ‘data/10q/uber_10q_june_2022.pdf’ + + data/10q/uber_10q_j 100%[===================>] 1.18M --.-KB/s in 0.04s + + 2024-05-23 13:36:24 (26.4 MB/s) - ‘data/10q/uber_10q_june_2022.pdf’ saved [1238483/1238483] + + --2024-05-23 13:36:24-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_sept_2022.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1178622 (1.1M) [application/octet-stream] + Saving to: ‘data/10q/uber_10q_sept_2022.pdf’ + + data/10q/uber_10q_s 100%[===================>] 1.12M --.-KB/s in 0.05s + + 2024-05-23 13:36:25 (22.7 MB/s) - ‘data/10q/uber_10q_sept_2022.pdf’ saved [1178622/1178622] + + + +## Load data + + +```python +march_2022 = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_march_2022.pdf"] +).load_data() +june_2022 = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_june_2022.pdf"] +).load_data() +sept_2022 = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_sept_2022.pdf"] +).load_data() +``` + +## Build indices + +We build a vector index / query engine over each of the documents (March, June, September). + + +```python +march_index = VectorStoreIndex.from_documents(march_2022) +june_index = VectorStoreIndex.from_documents(june_2022) +sept_index = VectorStoreIndex.from_documents(sept_2022) +``` + + +```python +march_engine = march_index.as_query_engine(similarity_top_k=3, llm=llm) +june_engine = june_index.as_query_engine(similarity_top_k=3, llm=llm) +sept_engine = sept_index.as_query_engine(similarity_top_k=3, llm=llm) +``` + +## Defining an Excessively Lengthy Query Plan + +Although a `QueryPlanTool` may be composed from many `QueryEngineTools`, +a single OpenAI tool is ultimately created from the `QueryPlanTool` +when the OpenAI API call is made. The description of this tool begins with +general instructions about the query plan approach, followed by the +descriptions of each constituent `QueryEngineTool`. + +Currently, each OpenAI tool description has a maximum length of 1024 characters. +As you add more `QueryEngineTools` to your `QueryPlanTool`, you may exceed +this limit. If the limit is exceeded, LlamaIndex will raise an error when it +attempts to construct the OpenAI tool. + +Let's demonstrate this scenario with an exaggerated example, where we will +give each query engine tool a very lengthy and redundant description. + + +```python +description_10q_general = """\ +A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, +providing an overview of the company's financial performance for the quarter. +It includes unaudited financial statements (income statement, balance sheet, +and cash flow statement) and the Management's Discussion and Analysis (MD&A), +where management explains significant changes and future expectations. +The 10-Q also discloses significant legal proceedings, updates on risk factors, +and information on the company's internal controls. Its primary purpose is to keep +investors informed about the company's financial status and operations, +enabling informed investment decisions.""" + +description_10q_specific = ( + "This 10-Q provides Uber quarterly financials ending" +) +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core.tools import QueryPlanTool +from llama_index.core import get_response_synthesizer +``` + + +```python +query_tool_sept = QueryEngineTool.from_defaults( + query_engine=sept_engine, + name="sept_2022", + description=f"{description_10q_general} {description_10q_specific} September 2022", +) +query_tool_june = QueryEngineTool.from_defaults( + query_engine=june_engine, + name="june_2022", + description=f"{description_10q_general} {description_10q_specific} June 2022", +) +query_tool_march = QueryEngineTool.from_defaults( + query_engine=march_engine, + name="march_2022", + description=f"{description_10q_general} {description_10q_specific} March 2022", +) + +print(len(query_tool_sept.metadata.description)) +print(len(query_tool_june.metadata.description)) +print(len(query_tool_march.metadata.description)) +``` + + 730 + 725 + 726 + + +From the print statements above, we see that we will easily exceed the +maximum character limit of 1024 when composing these tools into the `QueryPlanTool`. + + +```python +query_engine_tools = [query_tool_sept, query_tool_june, query_tool_march] + +response_synthesizer = get_response_synthesizer() +query_plan_tool = QueryPlanTool.from_defaults( + query_engine_tools=query_engine_tools, + response_synthesizer=response_synthesizer, +) +``` + + +```python +openai_tool = query_plan_tool.metadata.to_openai_tool() +``` + + + --------------------------------------------------------------------------- + + ValueError Traceback (most recent call last) + + Cell In[12], line 1 + ----> 1 openai_tool = query_plan_tool.metadata.to_openai_tool() + + + File ~/Code/run-llama/llama_index/llama-index-core/llama_index/core/tools/types.py:74, in ToolMetadata.to_openai_tool(self) + 72 """To OpenAI tool.""" + 73 if len(self.description) > 1024: + ---> 74 raise ValueError( + 75 "Tool description exceeds maximum length of 1024 characters. " + 76 "Please shorten your description or move it to the prompt." + 77 ) + 78 return { + 79 "type": "function", + 80 "function": { + (...) + 84 }, + 85 } + + + ValueError: Tool description exceeds maximum length of 1024 characters. Please shorten your description or move it to the prompt. + + +## Moving Tool Descriptions to the Prompt + +One obvious solution to this problem would be to shorten the tool +descriptions themselves, however with sufficiently many tools, +we will still eventually exceed the character limit. + +A more scalable solution would be to move the tool descriptions to the prompt. +This solves the character limit issue, since without the descriptions +of the query engine tools, the query plan description will remain fixed +in size. Of course, token limits imposed by the selected LLM will still +bound the tool descriptions, however these limits are far larger than the +1024 character limit. + +There are two steps involved in moving these tool descriptions to the +prompt. First, we must modify the metadata property of the `QueryPlanTool` +to omit the `QueryEngineTool` descriptions, and make a slight modification +to the default query planning instructions (telling the LLM to look for the +tool names and descriptions in the prompt.) + + +```python +from llama_index.core.tools.types import ToolMetadata + +introductory_tool_description_prefix = """\ +This is a query plan tool that takes in a list of tools and executes a \ +query plan over these tools to answer a query. The query plan is a DAG of query nodes. + +Given a list of tool names and the query plan schema, you \ +can choose to generate a query plan to answer a question. + +The tool names and descriptions will be given alongside the query. +""" + +# Modify metadata to only include the general query plan instructions +new_metadata = ToolMetadata( + introductory_tool_description_prefix, + query_plan_tool.metadata.name, + query_plan_tool.metadata.fn_schema, +) +query_plan_tool.metadata = new_metadata +query_plan_tool.metadata +``` + + + + + ToolMetadata(description='This is a query plan tool that takes in a list of tools and executes a query plan over these tools to answer a query. The query plan is a DAG of query nodes.\n\nGiven a list of tool names and the query plan schema, you can choose to generate a query plan to answer a question.\n\nThe tool names and descriptions will be given alongside the query.\n', name='query_plan_tool', fn_schema=, return_direct=False) + + + +Second, we must concatenate our tool names and descriptions alongside +the query being posed. + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent( + tools=[query_plan_tool], + llm=OpenAI(temperature=0, model="gpt-4o"), +) + +query = "What were the risk factors in sept 2022?" +``` + + +```python +# Reconstruct concatenated query engine tool descriptions +tools_description = "\n\n".join( + [ + f"Tool Name: {tool.metadata.name}\n" + + f"Tool Description: {tool.metadata.description} " + for tool in query_engine_tools + ] +) + +# Concatenate tool descriptions and query +query_planned_query = f"{tools_description}\n\nQuery: {query}" +query_planned_query +``` + + + + + "Tool Name: sept_2022\nTool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending September 2022 \n\nTool Name: june_2022\nTool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending June 2022 \n\nTool Name: march_2022\nTool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending March 2022 \n\nQuery: What were the risk factors in sept 2022?" + + + + +```python +response = await agent.run(query_planned_query) +response +``` + + Added user message to memory: Tool Name: sept_2022 + Tool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, + providing an overview of the company's financial performance for the quarter. + It includes unaudited financial statements (income statement, balance sheet, + and cash flow statement) and the Management's Discussion and Analysis (MD&A), + where management explains significant changes and future expectations. + The 10-Q also discloses significant legal proceedings, updates on risk factors, + and information on the company's internal controls. Its primary purpose is to keep + investors informed about the company's financial status and operations, + enabling informed investment decisions. This 10-Q provides Uber quarterly financials ending September 2022 + + Tool Name: june_2022 + Tool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, + providing an overview of the company's financial performance for the quarter. + It includes unaudited financial statements (income statement, balance sheet, + and cash flow statement) and the Management's Discussion and Analysis (MD&A), + where management explains significant changes and future expectations. + The 10-Q also discloses significant legal proceedings, updates on risk factors, + and information on the company's internal controls. Its primary purpose is to keep + investors informed about the company's financial status and operations, + enabling informed investment decisions. This 10-Q provides Uber quarterly financials ending June 2022 + + Tool Name: march_2022 + Tool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, + providing an overview of the company's financial performance for the quarter. + It includes unaudited financial statements (income statement, balance sheet, + and cash flow statement) and the Management's Discussion and Analysis (MD&A), + where management explains significant changes and future expectations. + The 10-Q also discloses significant legal proceedings, updates on risk factors, + and information on the company's internal controls. Its primary purpose is to keep + investors informed about the company's financial status and operations, + enabling informed investment decisions. This 10-Q provides Uber quarterly financials ending March 2022 + + Query: What were the risk factors in sept 2022? + === Calling Function === + Calling function: query_plan_tool with args: { + "nodes": [ + { + "id": 1, + "query_str": "What were the risk factors in sept 2022?", + "tool_name": "sept_2022", + "dependencies": [] + } + ] + } + Executing node {"id": 1, "query_str": "What were the risk factors in sept 2022?", "tool_name": "sept_2022", "dependencies": []} + Selected Tool: ToolMetadata(description="A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending September 2022", name='sept_2022', fn_schema=, return_direct=False) + Executed query, got response. + Query: What were the risk factors in sept 2022? + Response: The risk factors in September 2022 included failure to meet regulatory requirements related to climate change or to meet stated climate change commitments, which could impact costs, operations, brand, and reputation. The ongoing COVID-19 pandemic and responses to it were also a risk, as they had an adverse impact on business and operations, including reducing the demand for Mobility offerings globally and affecting travel behavior and demand. Catastrophic events such as disease, weather events, war, or terrorist attacks could also adversely impact the business, financial condition, and results of operation. Other risks included errors, bugs, or vulnerabilities in the platform's code or systems, inappropriate or controversial data practices, and the growing use of artificial intelligence. Climate change related physical and transition risks, such as market shifts toward electric vehicles and lower carbon business models, and risks related to extreme weather events or natural disasters, were also a concern. + Got output: The risk factors in September 2022 included failure to meet regulatory requirements related to climate change or to meet stated climate change commitments, which could impact costs, operations, brand, and reputation. The ongoing COVID-19 pandemic and responses to it were also a risk, as they had an adverse impact on business and operations, including reducing the demand for Mobility offerings globally and affecting travel behavior and demand. Catastrophic events such as disease, weather events, war, or terrorist attacks could also adversely impact the business, financial condition, and results of operation. Other risks included errors, bugs, or vulnerabilities in the platform's code or systems, inappropriate or controversial data practices, and the growing use of artificial intelligence. Climate change related physical and transition risks, such as market shifts toward electric vehicles and lower carbon business models, and risks related to extreme weather events or natural disasters, were also a concern. + ======================== + + + + + + + Response(response="The risk factors for Uber in September 2022 included:\n\n1. Failure to meet regulatory requirements related to climate change or to meet stated climate change commitments, which could impact costs, operations, brand, and reputation.\n2. The ongoing COVID-19 pandemic and responses to it were also a risk, as they had an adverse impact on business and operations, including reducing the demand for Mobility offerings globally and affecting travel behavior and demand.\n3. Catastrophic events such as disease, weather events, war, or terrorist attacks could also adversely impact the business, financial condition, and results of operation.\n4. Other risks included errors, bugs, or vulnerabilities in the platform's code or systems, inappropriate or controversial data practices, and the growing use of artificial intelligence.\n5. Climate change related physical and transition risks, such as market shifts toward electric vehicles and lower carbon business models, and risks related to extreme weather events or natural disasters, were also a concern.", source_nodes=[NodeWithScore(node=TextNode(id_='a92c1e5e-6285-4225-8c87-b9dbd2b07d89', embedding=None, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], relationships={: RelatedNodeInfo(node_id='b5e99044-59e9-439a-9e53-802a517b287d', node_type=, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='edddd9bda362411ae2e4d36144b5049c8b2ce5ec26047fa7c04003a9265aa87d'), : RelatedNodeInfo(node_id='04ae9351-0136-491a-8756-41dc2b8071a1', node_type=, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='bdc5ab49a54e18f73a2687096148f9e567a053ea2d3bd3c051956fb359078f5e')}, text='Any failure to\nmeet regulatory requirements related to climate change, or to meet our stated climate change commitments on the timeframe we committed to, or at all, could have\nan adverse impact on our costs and ability to operate, as well as harm our brand, reputation, and consequently, our business.\nGeneral Economic Risks\nOutbreaks of contagious disease, such as the COVID-19 pandemic and the impact of actions to mitigate the such disease or pandemic, have adversely impacted\nand could continue to adversely impact our business, financial condition and results of operations.\nOccurrence of a catastrophic event, including but not limited to disease, a weather event, war, or terrorist attack, could adversely impact our business, financial\ncondition and results of operation. We also face risks related to health epidemics, outbreaks of contagious disease, and other adverse health developments. For\nexample, the ongoing COVID-19 pandemic and responses to it have had, and may continue to have, an adverse impact on our business and operations, including,\nfor example, by reducing the demand for our Mobility offerings globally, and affecting travel behavior and demand. Even as COVID-related restrictions have been\nlifted and many regions around the world are making progress in their recovery from the pandemic, we have experienced and may continue to experience Driver\nsupply constraints, and we are observing that consumer demand for Mobility is recovering faster than driver availability, as such supply constraints have been and\nmay continue to be impacted by concerns regarding the COVID-19 pandemic. Furthermore, to support social distancing, we temporarily suspended our shared\nrides offering globally, and recently re-launched our shared rides offering in certain regions.\n73', start_char_idx=4469, end_char_idx=6258, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'), score=0.8039095664957979), NodeWithScore(node=TextNode(id_='04ae9351-0136-491a-8756-41dc2b8071a1', embedding=None, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], relationships={: RelatedNodeInfo(node_id='b5e99044-59e9-439a-9e53-802a517b287d', node_type=, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='edddd9bda362411ae2e4d36144b5049c8b2ce5ec26047fa7c04003a9265aa87d'), : RelatedNodeInfo(node_id='a92c1e5e-6285-4225-8c87-b9dbd2b07d89', node_type=, metadata={}, hash='4862564636269739d75565c6c9dc166659cf52e29ec337fe9b85802beeb2ce7d')}, text='platform to platform users. In addition, our release of new software in the past has inadvertently caused, and may in the future cause, interruptions in the\navailability or functionality of our platform. Any errors, bugs, or vulnerabilities discovered in our code or systems after release could result in an interruption in the\navailability of our platform or a negative experience for Drivers, consumers, merchants, Shippers, and Carriers, and could also result in negative publicity and\nunfavorable media coverage, damage to our reputation, loss of platform users, loss of revenue or liability for damages, regulatory inquiries, or other proceedings,\nany of which could adversely affect our business and financial results. In addition, our growing use of artificial intelligence (“AI”) (including machine learning) in\nour offerings presents additional risks. AI algorithms or automated processing of data may be flawed and datasets may be insufficient or contain biased information.\nInappropriate or controversial data practices by us or others could impair the acceptance of AI solutions or subject us to lawsuits and regulatory investigations.\nThese deficiencies could undermine the decisions, predictions or analysis AI applications produce, or lead to unintentional bias and discrimination, subjecting us to\ncompetitive harm, legal liability, and brand or reputational harm.\nWe are subject to climate change risks, including physical and transitional risks, and if we are unable to manage such risks, our business may be adversely\nimpacted.\nWe face climate change related physical and transition risks, which include the risk of market shifts toward electric vehicles (“EVs”) and lower carbon\nbusiness models and risks related to extreme weather events or natural disasters. Climate-related events, including the increasing frequency, severity and duration\nof extreme weather events and their impact on critical infrastructure in the United States and elsewhere, have the potential to disrupt our business, our third-party\nsuppliers, and the business of merchants, Shippers, Carriers and Drivers using our platform, and may cause us to experience higher losses and additional costs to\nmaintain or resume operations. Additionally, we are subject to emerging climate policies such as a regulation adopted in California in May 2021 requiring 90% of\nvehicle miles traveled by rideshare fleets in California to have been in zero emission vehicles by 2030, with interim targets beginning in 2023. In addition, Drivers\nmay be subject to climate-related policies that indirectly impact our business, such as the Congestion Charge Zone and Ultra Low Emission Zone schemes adopted\nin London that impose fees on drivers in fossil-fueled vehicles, which may impact our ability to attract and maintain Drivers on our platform, and to the extent we\nexperience Driver supply constraints in a given market, we may need to increase Driver incentives.\nWe have made climate related commitments that require us to invest significant effort, resources, and management time and circumstances may arise,\nincluding those beyond our control, that may require us to revise the contemplated timeframes for implementing these commitments.\nWe have made climate related commitments, including our commitment to 100% renewable electricity for our U.S. offices by 2025, our commitment to net\nzero climate emissions from corporate operations by 2030, and our commitment to be a net zero company by 2040. In addition, our Supplier Code of Conduct sets\nenvironmental standards for our supply chain, and we recognize that there are inherent climate-related risks wherever business is conducted. Progressing towards\nour climate commitments requires us to invest significant effort, resources, and management time, and circumstances may arise, including those beyond our\ncontrol, that may require us to revise our timelines and/or climate commitments. For example, the COVID-19 pandemic has negatively impacted our ability to\ndedicate resources to make the progress on our climate commitments that we initially anticipated. In addition, our ability to meet our climate commitments is\ndependent on external factors such as rapidly changing regulations, policies and related interpretation, advances in technology such as battery storage, as well the\navailability, cost and accessibility of EVs to Drivers, and the availability of EV charging infrastructure that can be efficiently accessed by Drivers. Any failure to\nmeet regulatory requirements related to climate change, or to meet our stated climate change commitments on the timeframe we committed to, or at all, could have\nan adverse impact on our costs and ability to operate, as well as harm our brand, reputation, and consequently, our business.\nGeneral Economic Risks\nOutbreaks of contagious disease, such as the COVID-19 pandemic and the impact of actions to mitigate the such disease or pandemic, have adversely impacted\nand could continue to adversely impact our business, financial condition and results of operations.\nOccurrence of a catastrophic event, including but not limited to disease, a weather event, war, or terrorist attack, could adversely impact our business, financial\ncondition and results of operation.', start_char_idx=0, end_char_idx=5248, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'), score=0.7967699969539317), NodeWithScore(node=TextNode(id_='474572f4-866f-4efa-aa5f-f898d4ba831a', embedding=None, metadata={'page_label': '13', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], relationships={: RelatedNodeInfo(node_id='2ecd357c-acd3-4398-a0ae-223bf9980f34', node_type=, metadata={'page_label': '13', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='8da53f7e83f88f63304dfcf8186b0ce111a5e161a317d243451266b863e9f2af'), : RelatedNodeInfo(node_id='e2e88da4-92e0-4185-96c6-010a35d94287', node_type=, metadata={'page_label': '13', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='373d1a92181565c8fb2ae2831069e904f4f4d2a9fdc70486b91f102cdac9d442')}, text='Estimates are based on historical experience, where\napplicable, and other assumptions which management believes are reasonable under the circumstances. Additionally, we considered the impacts of the coronavirus\npandemic (“COVID-19”) on the assumptions and inputs (including market data) supporting certain of these estimates, assumptions and judgments. On an ongoing\nbasis, management evaluates estimates, including, but not limited to: fair values of investments and other financial instruments (including the measurement of\ncredit or impairment losses); useful lives of amortizable long-lived assets; fair value of acquired intangible assets and related impairment assessments; impairment\nof goodwill; stock-based compensation; income taxes and non-income tax reserves; certain deferred tax assets and tax liabilities; insurance reserves; and other\ncontingent liabilities. These estimates are inherently subject to judgment and actual results could differ from those estimates.\nCertain Significant Risks and Uncertainties - COVID-19\nCOVID-19 restrictions have had an adverse impact on our business and operations by reducing, in particular, the global demand for Mobility offerings. It is\nnot possible to predict COVID-19’s cumulative and ultimate impact on our future business operations, results of operations, financial position, liquidity, and cash\nflows. The extent of the impact of COVID-19 on our business and financial results will depend largely on future developments, including: outbreaks or variants of\nthe virus, both globally and within the United\n12', start_char_idx=4007, end_char_idx=5573, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'), score=0.7911034852964277)], metadata=None) + + diff --git a/.tmp/agent/openai_agent_query_cookbook.md b/.tmp/agent/openai_agent_query_cookbook.md new file mode 100644 index 0000000..ad3f71d --- /dev/null +++ b/.tmp/agent/openai_agent_query_cookbook.md @@ -0,0 +1,783 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_query_cookbook.ipynb +toc: True +title: "OpenAI Agent + Query Engine Experimental Cookbook" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this notebook, we try out the OpenAIAgent across a variety of query engine tools and datasets. We explore how OpenAIAgent can compare/replace existing workflows solved by our retrievers/query engines. + +- Auto retrieval +- Joint SQL and vector search + +**NOTE:** Any Text-to-SQL application should be aware that executing +arbitrary SQL queries can be a security risk. It is recommended to +take precautions as needed, such as using restricted roles, read-only +databases, sandboxing, etc. + +## AutoRetrieval from a Vector Database + +Our existing "auto-retrieval" capabilities (in `VectorIndexAutoRetriever`) allow an LLM to infer the right query parameters for a vector database - including both the query string and metadata filter. + +Since the OpenAI Function API can infer function parameters, we explore its capabilities in performing auto-retrieval here. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +%pip install llama-index-llms-openai +%pip install llama-index-readers-wikipedia +%pip install llama-index-vector-stores-pinecone +``` + + +```python +import os + +os.environ["PINECONE_API_KEY"] = "..." +os.environ["OPENAI_API_KEY"] = "..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +from pinecone import Pinecone, ServerlessSpec + +pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"]) +``` + + +```python +# dimensions are for text-embedding-3-small +pc.create_index( + name="quickstart-index", + dimension=1536, + metric="euclidean", + spec=ServerlessSpec(cloud="aws", region="us-east-1"), +) + +# may need to wait for index to be created +import time + +time.sleep(10) +``` + + + + + { + "name": "quickstart-index", + "metric": "euclidean", + "host": "quickstart-index-c2e1535.svc.aped-4627-b74a.pinecone.io", + "spec": { + "serverless": { + "cloud": "aws", + "region": "us-east-1" + } + }, + "status": { + "ready": true, + "state": "Ready" + }, + "vector_type": "dense", + "dimension": 1536, + "deletion_protection": "disabled", + "tags": null + } + + + + +```python +index = pc.Index("quickstart-index") +``` + + +```python +# Optional: delete data in your pinecone index +# index.delete(deleteAll=True, namespace="test") +``` + + +```python +from llama_index.core import VectorStoreIndex, StorageContext +from llama_index.vector_stores.pinecone import PineconeVectorStore +``` + + +```python +from llama_index.core.schema import TextNode + +nodes = [ + TextNode( + text=( + "Michael Jordan is a retired professional basketball player," + " widely regarded as one of the greatest basketball players of all" + " time." + ), + metadata={ + "category": "Sports", + "country": "United States", + "gender": "male", + "born": 1963, + }, + ), + TextNode( + text=( + "Angelina Jolie is an American actress, filmmaker, and" + " humanitarian. She has received numerous awards for her acting" + " and is known for her philanthropic work." + ), + metadata={ + "category": "Entertainment", + "country": "United States", + "gender": "female", + "born": 1975, + }, + ), + TextNode( + text=( + "Elon Musk is a business magnate, industrial designer, and" + " engineer. He is the founder, CEO, and lead designer of SpaceX," + " Tesla, Inc., Neuralink, and The Boring Company." + ), + metadata={ + "category": "Business", + "country": "United States", + "gender": "male", + "born": 1971, + }, + ), + TextNode( + text=( + "Rihanna is a Barbadian singer, actress, and businesswoman. She" + " has achieved significant success in the music industry and is" + " known for her versatile musical style." + ), + metadata={ + "category": "Music", + "country": "Barbados", + "gender": "female", + "born": 1988, + }, + ), + TextNode( + text=( + "Cristiano Ronaldo is a Portuguese professional footballer who is" + " considered one of the greatest football players of all time. He" + " has won numerous awards and set multiple records during his" + " career." + ), + metadata={ + "category": "Sports", + "country": "Portugal", + "gender": "male", + "born": 1985, + }, + ), +] +``` + + +```python +from llama_index.vector_stores.pinecone import PineconeVectorStore +from llama_index.core import StorageContext + +vector_store = PineconeVectorStore(pinecone_index=index, namespace="test") +storage_context = StorageContext.from_defaults(vector_store=vector_store) +``` + + +```python +from llama_index.core import VectorStoreIndex + +index = VectorStoreIndex(nodes, storage_context=storage_context) +``` + + + Upserted vectors: 0%| | 0/5 [00:00, >=, ==, !=)", + ], + filter_condition: Annotated[ + str, "Metadata filters condition values (could be AND or OR)" + ], + top_k: Annotated[ + int, "The number of results to return from the vector database." + ], +): + """Auto retrieval function. + + Performs auto-retrieval from a vector database, and then applies a set of filters. + + """ + query = query or "Query" + + metadata_filters = [ + MetadataFilter(key=k, value=v, operator=op) + for k, v, op in zip( + filter_key_list, filter_value_list, filter_operator_list + ) + ] + retriever = VectorIndexRetriever( + index, + filters=MetadataFilters( + filters=metadata_filters, condition=filter_condition.lower() + ), + top_k=top_k, + ) + query_engine = RetrieverQueryEngine.from_args(retriever) + + response = await query_engine.aquery(query) + return str(response) + + +description = f"""\ +Use this tool to look up biographical information about celebrities. +The vector database schema is given below: + + +{vector_store_info.model_dump_json()} + +""" + +auto_retrieve_tool = FunctionTool.from_defaults( + auto_retrieve_fn, + name="celebrity_bios", + description=description, +) +``` + +#### Initialize Agent + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent( + tools=[auto_retrieve_tool], + llm=OpenAI(model="gpt-4o"), + system_prompt=( + "You are a helpful assistant that can answer questions about celebrities by writing a filtered query to a vector database. " + "Unless the user is asking to compare things, you generally only need to make one call to the retriever." + ), +) + +# hold the context/session state for the agent +ctx = Context(agent) +``` + + +```python +from llama_index.core.agent.workflow import ( + ToolCallResult, + ToolCall, + AgentStream, + AgentInput, + AgentOutput, +) + +handler = agent.run( + "Tell me about two celebrities from the United States. ", ctx=ctx +) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool celebrity_bios with args {'query': 'celebrities from the United States', 'filter_key_list': ['country'], 'filter_value_list': ['United States'], 'filter_operator_list': ['=='], 'filter_condition': 'AND', 'top_k': 2}, got response: Angelina Jolie and Elon Musk are notable celebrities from the United States. + Here are two celebrities from the United States: + + 1. **Angelina Jolie**: She is a renowned actress, filmmaker, and humanitarian. Jolie has received numerous accolades, including an Academy Award and three Golden Globe Awards. She is also known for her humanitarian efforts, particularly her work with refugees as a Special Envoy for the United Nations High Commissioner for Refugees (UNHCR). + + 2. **Elon Musk**: He is a prominent entrepreneur and business magnate. Musk is the CEO and lead designer of SpaceX, CEO and product architect of Tesla, Inc., and has been involved in numerous other ventures, including Neuralink and The Boring Company. He is known for his ambitious vision of the future, including space exploration and sustainable energy. + + +```python +handler = agent.run("Tell me about two celebrities born after 1980. ", ctx=ctx) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool celebrity_bios with args {'query': 'celebrities born after 1980', 'filter_key_list': ['born'], 'filter_value_list': [1980], 'filter_operator_list': ['>'], 'filter_condition': 'AND', 'top_k': 2}, got response: Rihanna, born in 1988, is a celebrity who fits the criteria of being born after 1980. + Here is a celebrity born after 1980: + + - **Rihanna**: Born in 1988, Rihanna is a Barbadian singer, actress, and businesswoman. She gained worldwide fame with her music career, producing hits like "Umbrella," "Diamonds," and "Work." Beyond music, Rihanna has made a significant impact in the fashion and beauty industries with her Fenty brand, known for its inclusivity and innovation. + + +```python +response = await agent.run( + "Tell me about few celebrities under category business and born after 1950. ", + ctx=ctx, +) +print(str(response)) +``` + + Here is a celebrity in the business category who was born after 1950: + + - **Elon Musk**: He is a prominent entrepreneur and business magnate, born in 1971. Musk is the CEO and lead designer of SpaceX, CEO and product architect of Tesla, Inc., and has been involved in numerous other ventures, including Neuralink and The Boring Company. He is known for his ambitious vision of the future, including space exploration and sustainable energy. + + +## Joint Text-to-SQL and Semantic Search + +This is currently handled by our `SQLAutoVectorQueryEngine`. + +Let's try implementing this by giving our `OpenAIAgent` access to two query tools: SQL and Vector + +**NOTE:** Any Text-to-SQL application should be aware that executing +arbitrary SQL queries can be a security risk. It is recommended to +take precautions as needed, such as using restricted roles, read-only +databases, sandboxing, etc. + +#### Load and Index Structured Data + +We load sample structured datapoints into a SQL db and index it. + + +```python +from sqlalchemy import ( + create_engine, + MetaData, + Table, + Column, + String, + Integer, + select, + column, +) +from llama_index.core import SQLDatabase +from llama_index.core.indices import SQLStructStoreIndex + +engine = create_engine("sqlite:///:memory:", future=True) +metadata_obj = MetaData() +``` + + +```python +# create city SQL table +table_name = "city_stats" +city_stats_table = Table( + table_name, + metadata_obj, + Column("city_name", String(16), primary_key=True), + Column("population", Integer), + Column("country", String(16), nullable=False), +) + +metadata_obj.create_all(engine) +``` + + +```python +# print tables +metadata_obj.tables.keys() +``` + + + + + dict_keys(['city_stats']) + + + + +```python +from sqlalchemy import insert + +rows = [ + {"city_name": "Toronto", "population": 2930000, "country": "Canada"}, + {"city_name": "Tokyo", "population": 13960000, "country": "Japan"}, + {"city_name": "Berlin", "population": 3645000, "country": "Germany"}, +] +for row in rows: + stmt = insert(city_stats_table).values(**row) + with engine.begin() as connection: + cursor = connection.execute(stmt) +``` + + +```python +with engine.connect() as connection: + cursor = connection.exec_driver_sql("SELECT * FROM city_stats") + print(cursor.fetchall()) +``` + + [('Toronto', 2930000, 'Canada'), ('Tokyo', 13960000, 'Japan'), ('Berlin', 3645000, 'Germany')] + + + +```python +sql_database = SQLDatabase(engine, include_tables=["city_stats"]) +``` + + +```python +from llama_index.core.query_engine import NLSQLTableQueryEngine + +query_engine = NLSQLTableQueryEngine( + sql_database=sql_database, + tables=["city_stats"], +) +``` + +#### Load and Index Unstructured Data + +We load unstructured data into a vector index backed by Pinecone + + +```python +# install wikipedia python package +%pip install wikipedia llama-index-readers-wikipedia +``` + + +```python +from llama_index.readers.wikipedia import WikipediaReader + +cities = ["Toronto", "Berlin", "Tokyo"] +wiki_docs = WikipediaReader().load_data(pages=cities) +``` + + +```python +from pinecone import Pinecone, ServerlessSpec + +pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"]) +``` + + +```python +# dimensions are for text-embedding-3-small +pc.create_index( + name="quickstart-sql", + dimension=1536, + metric="euclidean", + spec=ServerlessSpec(cloud="aws", region="us-east-1"), +) + +# may need to wait for index to be created +import time + +time.sleep(10) +``` + + +```python +# define pinecone index +index = pc.Index("quickstart-sql") +``` + + +```python +# OPTIONAL: delete all +index.delete(deleteAll=True) +``` + + +```python +from llama_index.core import VectorStoreIndex, StorageContext +from llama_index.vector_stores.pinecone import PineconeVectorStore +from llama_index.core.node_parser import TokenTextSplitter +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding + +# define node parser and LLM +Settings.llm = OpenAI(temperature=0, model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +Settings.node_parser = TokenTextSplitter(chunk_size=1024) + +# define pinecone vector index +vector_store = PineconeVectorStore( + pinecone_index=index, namespace="wiki_cities" +) +storage_context = StorageContext.from_defaults(vector_store=vector_store) +vector_index = VectorStoreIndex([], storage_context=storage_context) +``` + + +```python +# Insert documents into vector index +# Each document has metadata of the city attached +for city, wiki_doc in zip(cities, wiki_docs): + nodes = Settings.node_parser.get_nodes_from_documents([wiki_doc]) + # add metadata to each node + for node in nodes: + node.metadata = {"title": city} + vector_index.insert_nodes(nodes) +``` + +#### Define Query Engines / Tools + + +```python +from llama_index.core.retrievers import VectorIndexAutoRetriever +from llama_index.core.vector_stores import MetadataInfo, VectorStoreInfo +from llama_index.core.query_engine import RetrieverQueryEngine +from llama_index.core.tools import QueryEngineTool + + +vector_store_info = VectorStoreInfo( + content_info="articles about different cities", + metadata_info=[ + MetadataInfo( + name="title", type="str", description="The name of the city" + ), + ], +) + +# pre-built auto-retriever, this works similarly to our custom auto-retriever above +vector_auto_retriever = VectorIndexAutoRetriever( + vector_index, vector_store_info=vector_store_info +) + +retriever_query_engine = RetrieverQueryEngine.from_args( + vector_auto_retriever, +) +``` + + +```python +sql_tool = QueryEngineTool.from_defaults( + query_engine=query_engine, + name="sql_tool", + description=( + "Useful for translating a natural language query into a SQL query over" + " a table containing: city_stats, containing the population/country of" + " each city" + ), +) +vector_tool = QueryEngineTool.from_defaults( + query_engine=retriever_query_engine, + name="vector_tool", + description=( + "Useful for answering semantic questions about different cities" + ), +) +``` + +#### Initialize Agent + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.llms.openai import OpenAI +from llama_index.core.workflow import Context + +agent = FunctionAgent( + tools=[sql_tool, vector_tool], + llm=OpenAI(model="gpt-4o"), +) + +# hold the context/session state for the agent +ctx = Context(agent) +``` + + +```python +from llama_index.core.agent.workflow import ( + ToolCallResult, + ToolCall, + AgentStream, + AgentInput, + AgentOutput, +) + +handler = agent.run( + "Tell me about the arts and culture of the city with the highest population. ", + ctx=ctx, +) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool sql_tool with args {'input': 'SELECT city FROM city_stats ORDER BY population DESC LIMIT 1;'}, got response: The city with the highest population is Tokyo. + + Called tool vector_tool with args {'input': 'Tell me about the arts and culture of Tokyo.'}, got response: Tokyo boasts a vibrant arts and culture scene, characterized by a diverse range of museums, galleries, and performance venues. Ueno Park is a cultural hub, housing the Tokyo National Museum, which specializes in traditional Japanese art, alongside the National Museum of Western Art, a UNESCO World Heritage site, and the National Museum of Nature and Science. The park also features Ueno Zoo, known for its giant pandas. + + The city is home to numerous notable museums, including the Artizon Museum, the National Museum of Emerging Science and Innovation, and the Edo-Tokyo Museum, which explores the city's history. Contemporary art is showcased at the Mori Art Museum and the Sumida Hokusai Museum, while the Sompo Museum of Art is recognized for its collection, including Van Gogh's "Sunflowers." + + The performing arts thrive in Tokyo, with venues like the National Noh Theatre and Kabuki-za dedicated to traditional Japanese theatre. The New National Theatre Tokyo hosts a variety of performances, including opera and ballet. Major concert venues such as the Nippon Budokan and Tokyo Dome frequently feature popular music acts. + + Tokyo's nightlife is vibrant, particularly in districts like Shibuya and Roppongi, which are filled with bars, clubs, and live music venues. The city is also known for its festivals, such as the Sannō Matsuri and the Sanja Festival, which celebrate traditional culture. + + Shopping districts like Ginza and Nihombashi offer a blend of high-end retail and cultural experiences, while areas like Jinbōchō are famous for their literary connections, featuring bookstores and cafes linked to renowned authors. Overall, Tokyo's arts and culture reflect a rich tapestry of traditional and contemporary influences, making it a dynamic city for cultural exploration. + Tokyo, the city with the highest population, boasts a vibrant arts and culture scene. It features a diverse range of museums, galleries, and performance venues. Ueno Park serves as a cultural hub, housing the Tokyo National Museum, the National Museum of Western Art, and the National Museum of Nature and Science. The park also includes Ueno Zoo, known for its giant pandas. + + Notable museums in Tokyo include the Artizon Museum, the National Museum of Emerging Science and Innovation, and the Edo-Tokyo Museum, which explores the city's history. Contemporary art is showcased at the Mori Art Museum and the Sumida Hokusai Museum, while the Sompo Museum of Art is recognized for its collection, including Van Gogh's "Sunflowers." + + The performing arts thrive with venues like the National Noh Theatre and Kabuki-za dedicated to traditional Japanese theatre. The New National Theatre Tokyo hosts a variety of performances, including opera and ballet. Major concert venues such as the Nippon Budokan and Tokyo Dome frequently feature popular music acts. + + Tokyo's nightlife is vibrant, especially in districts like Shibuya and Roppongi, filled with bars, clubs, and live music venues. The city is also known for its festivals, such as the Sannō Matsuri and the Sanja Festival, celebrating traditional culture. + + Shopping districts like Ginza and Nihombashi offer a blend of high-end retail and cultural experiences, while areas like Jinbōchō are famous for their literary connections, featuring bookstores and cafes linked to renowned authors. Overall, Tokyo's arts and culture reflect a rich tapestry of traditional and contemporary influences, making it a dynamic city for cultural exploration. + + +```python +handler = agent.run("Tell me about the history of Berlin", ctx=ctx) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool vector_tool with args {'input': 'Tell me about the history of Berlin.'}, got response: Berlin's history dates back to prehistoric times, with evidence of human settlements as early as 60,000 BC. The area saw the emergence of various cultures, including the Maglemosian culture around 9,000 BC and the Lusatian culture around 2,000 BC, as dense human settlements developed along the Spree and Havel rivers. By 500 BC, Germanic tribes began to settle in the region, followed by Slavic tribes in the 7th century. + + In the 12th century, the region came under German rule with the establishment of the Margraviate of Brandenburg. The first written records of towns in the area appear in the late 12th century, with Berlin's founding date considered to be 1237. The towns of Berlin and Cölln formed close economic ties and eventually merged, with the Hohenzollern family ruling the area from the 14th century until 1918. + + The Thirty Years' War in the 17th century devastated Berlin, leading to significant population loss. However, under Frederick William, known as the "Great Elector," the city experienced a revival through policies promoting immigration and religious tolerance. The establishment of the Kingdom of Prussia in 1701 marked a significant turning point, with Berlin becoming its capital. + + The 19th century brought the Industrial Revolution, transforming Berlin into a major economic center and leading to rapid population growth. By the late 19th century, Berlin was the capital of the newly founded German Empire. The city continued to grow and evolve through the 20th century, experiencing significant events such as World War II, the division into East and West Berlin during the Cold War, and reunification in 1990, when it once again became the capital of a unified Germany. + + Today, Berlin is recognized as a global city of culture, politics, media, and science, with a diverse economy and rich historical heritage. + Berlin's history is rich and varied, dating back to prehistoric times with evidence of human settlements as early as 60,000 BC. The area saw the emergence of various cultures, including the Maglemosian culture around 9,000 BC and the Lusatian culture around 2,000 BC, with dense settlements along the Spree and Havel rivers. By 500 BC, Germanic tribes settled in the region, followed by Slavic tribes in the 7th century. + + In the 12th century, the region came under German rule with the establishment of the Margraviate of Brandenburg. Berlin's founding date is considered to be 1237, with the towns of Berlin and Cölln forming close economic ties and eventually merging. The Hohenzollern family ruled the area from the 14th century until 1918. + + The Thirty Years' War in the 17th century devastated Berlin, but it experienced a revival under Frederick William, the "Great Elector," through policies promoting immigration and religious tolerance. The establishment of the Kingdom of Prussia in 1701 marked a significant turning point, with Berlin becoming its capital. + + The 19th century brought the Industrial Revolution, transforming Berlin into a major economic center and leading to rapid population growth. By the late 19th century, Berlin was the capital of the newly founded German Empire. The city continued to evolve through the 20th century, experiencing significant events such as World War II, the division into East and West Berlin during the Cold War, and reunification in 1990, when it once again became the capital of a unified Germany. + + Today, Berlin is recognized as a global city of culture, politics, media, and science, with a diverse economy and rich historical heritage. + + +```python +response = await agent.run( + "Can you give me the country corresponding to each city?", ctx=ctx +) + +print(str(response)) +``` + + Here are the cities along with their corresponding countries: + + - Toronto is in Canada. + - Tokyo is in Japan. + - Berlin is in Germany. + diff --git a/.tmp/agent/openai_agent_retrieval.md b/.tmp/agent/openai_agent_retrieval.md new file mode 100644 index 0000000..cfb4713 --- /dev/null +++ b/.tmp/agent/openai_agent_retrieval.md @@ -0,0 +1,170 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_retrieval.ipynb +toc: True +title: "Retrieval-Augmented Agents" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this tutorial, we show you how to use our `FunctionAgent` or `ReActAgent` implementation with a tool retriever, +to augment any existing agent and store/index an arbitrary number of tools. + +Our indexing/retrieval modules help to remove the complexity of having too many functions to fit in the prompt. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the OpenAI API +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + +Let's define some very simple calculator tools for our agent. + + +```python +from llama_index.core.tools import FunctionTool + + +def multiply(a: int, b: int) -> int: + """Multiply two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b + + +def useless(a: int, b: int) -> int: + """Toy useless function.""" + pass + + +multiply_tool = FunctionTool.from_defaults(multiply, name="multiply") +add_tool = FunctionTool.from_defaults(add, name="add") + +# toy-example of many tools +useless_tools = [ + FunctionTool.from_defaults(useless, name=f"useless_{str(idx)}") + for idx in range(28) +] + +all_tools = [multiply_tool] + [add_tool] + useless_tools + +all_tools_map = {t.metadata.name: t for t in all_tools} +``` + +## Building an Object Index + +We have an `ObjectIndex` construct in LlamaIndex that allows the user to use our index data structures over arbitrary objects. +The ObjectIndex will handle serialiation to/from the object, and use an underying index (e.g. VectorStoreIndex, SummaryIndex, KeywordTableIndex) as the storage mechanism. + +In this case, we have a large collection of Tool objects, and we'd want to define an ObjectIndex over these Tools. + +The index comes bundled with a retrieval mechanism, an `ObjectRetriever`. + +This can be passed in to our agent so that it can +perform Tool retrieval during query-time. + + +```python +# define an "object" index over these tools +from llama_index.core import VectorStoreIndex +from llama_index.core.objects import ObjectIndex + +obj_index = ObjectIndex.from_objects( + all_tools, + index_cls=VectorStoreIndex, + # if we were using an external vector store, we could pass the stroage context and any other kwargs + # storage_context=storage_context, + # embed_model=embed_model, + # ... +) +``` + +To reload the index later, we can use the `from_objects_and_index` method. + + +```python +# from llama_index.core import StorageContext, load_index_from_storage + +# saving and loading from disk +# obj_index.index.storage_context.persist(persist_dir="obj_index_storage") + +# reloading from disk +# vector_index = load_index_from_storage(StorageContext.from_defaults(persist_dir="obj_index_storage")) + +# or if using an external vector store, no need to persist, just reload the index +# vector_index = VectorStoreIndex.from_vector_store(vector_store=vector_store, ...) + +# Then, we can reload the ObjectIndex +# obj_index = ObjectIndex.from_objects_and_index( +# all_tools, +# index=vector_index, +# ) +``` + +## Agent w/ Tool Retrieval + +Agents in LlamaIndex can be used with a `ToolRetriever` to retrieve tools during query-time. + +During query-time, we would first use the `ObjectRetriever` to retrieve a set of relevant Tools. These tools would then be passed into the agent; more specifically, their function signatures would be passed into the OpenAI Function calling API. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent( + tool_retriever=obj_index.as_retriever(similarity_top_k=2), + llm=OpenAI(model="gpt-4o"), +) + +# context to hold the session/state +ctx = Context(agent) +``` + + +```python +resp = await agent.run( + "What's 212 multiplied by 122? Make sure to use Tools", ctx=ctx +) +print(str(resp)) +print(resp.tool_calls) +``` + + The result of multiplying 212 by 122 is 25,864. + [ToolCallResult(tool_name='multiply', tool_kwargs={'a': 212, 'b': 122}, tool_id='call_4Ygos3MpRH7Gj3R79HISRGyH', tool_output=ToolOutput(content='25864', tool_name='multiply', raw_input={'args': (), 'kwargs': {'a': 212, 'b': 122}}, raw_output=25864, is_error=False), return_direct=False)] + + + +```python +resp = await agent.run( + "What's 212 added to 122 ? Make sure to use Tools", ctx=ctx +) +print(str(resp)) +print(resp.tool_calls) +``` + + The result of adding 212 to 122 is 334. + [ToolCallResult(tool_name='add', tool_kwargs={'a': 212, 'b': 122}, tool_id='call_rXUfwQ477bcd6bxafQHgETaa', tool_output=ToolOutput(content='334', tool_name='add', raw_input={'args': (), 'kwargs': {'a': 212, 'b': 122}}, raw_output=334, is_error=False), return_direct=False)] + diff --git a/.tmp/agent/openai_agent_with_query_engine.md b/.tmp/agent/openai_agent_with_query_engine.md new file mode 100644 index 0000000..789cd84 --- /dev/null +++ b/.tmp/agent/openai_agent_with_query_engine.md @@ -0,0 +1,158 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_with_query_engine.ipynb +toc: True +title: "Agent with Query Engine Tools" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +## Build Query Engine Tools + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +from llama_index.core import StorageContext, load_index_from_storage + +try: + storage_context = StorageContext.from_defaults( + persist_dir="./storage/lyft" + ) + lyft_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/uber" + ) + uber_index = load_index_from_storage(storage_context) + + index_loaded = True +except: + index_loaded = False +``` + +Download Data + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/lyft_2021.pdf' -O 'data/10k/lyft_2021.pdf' +``` + + +```python +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex + +if not index_loaded: + # load data + lyft_docs = SimpleDirectoryReader( + input_files=["./data/10k/lyft_2021.pdf"] + ).load_data() + uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] + ).load_data() + + # build index + lyft_index = VectorStoreIndex.from_documents(lyft_docs) + uber_index = VectorStoreIndex.from_documents(uber_docs) + + # persist index + lyft_index.storage_context.persist(persist_dir="./storage/lyft") + uber_index.storage_context.persist(persist_dir="./storage/uber") +``` + + +```python +lyft_engine = lyft_index.as_query_engine(similarity_top_k=3) +uber_engine = uber_index.as_query_engine(similarity_top_k=3) +``` + + +```python +from llama_index.core.tools import QueryEngineTool + +query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=lyft_engine, + name="lyft_10k", + description=( + "Provides information about Lyft financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), +] +``` + +## Setup Agent + +For LLMs like OpenAI that have a function calling API, we should use the `FunctionAgent`. + +For other LLMs, we can use the `ReActAgent`. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent +from llama_index.core.workflow import Context + +agent = FunctionAgent(tools=query_engine_tools, llm=OpenAI(model="gpt-4o")) + +# context to hold the session/state +ctx = Context(agent) +``` + +## Let's Try It Out! + + +```python +from llama_index.core.agent.workflow import ToolCallResult, AgentStream + +handler = agent.run("What's the revenue for Lyft in 2021 vs Uber?", ctx=ctx) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"Call {ev.tool_name} with args {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + Call lyft_10k with args {'input': "What was Lyft's revenue for the year 2021?"} + Returned: Lyft's revenue for the year 2021 was $3,208,323,000. + Call uber_10k with args {'input': "What was Uber's revenue for the year 2021?"} + Returned: Uber's revenue for the year 2021 was $17.455 billion. + In 2021, Lyft's revenue was approximately $3.21 billion, while Uber's revenue was significantly higher at $17.455 billion. diff --git a/.tmp/agent/react_agent.md b/.tmp/agent/react_agent.md new file mode 100644 index 0000000..827954c --- /dev/null +++ b/.tmp/agent/react_agent.md @@ -0,0 +1,282 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/react_agent.ipynb +toc: True +title: "ReActAgent - A Simple Intro with Calculator Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +This is a notebook that showcases the ReAct agent over very simple calculator tools (no fancy RAG pipelines or API calls). + +We show how it can reason step-by-step over different tools to achieve the end goal. + +The main advantage of the ReAct agent over a Function Calling agent is that it can work with any LLM regardless of whether it supports function calling. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + +## Define Function Tools + +We setup some trivial `multiply` and `add` tools. Note that you can define arbitrary functions and pass it to the `FunctionTool` (which will process the docstring and parameter signature). + + +```python +def multiply(a: int, b: int) -> int: + """Multiply two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +## Run Some Queries + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.core.agent.workflow import ReActAgent +from llama_index.core.workflow import Context + +llm = OpenAI(model="gpt-4o-mini") +agent = ReActAgent(tools=[multiply, add], llm=llm) + +# Create a context to store the conversation history/session state +ctx = Context(agent) +``` + +## Run Some Example Queries + +By streaming the result, we can see the full response, including the thought process and tool calls. + +If we wanted to stream only the result, we can buffer the stream and start streaming once `Answer:` is in the response. + + + +```python +from llama_index.core.agent.workflow import AgentStream, ToolCallResult + +handler = agent.run("What is 20+(2*4)?", ctx=ctx) + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to help me answer the question. + Action: multiply + Action Input: {"a": 2, "b": 4}Thought: Now I have the result of the multiplication, which is 8. I will add this to 20 to complete the calculation. + Action: add + Action Input: {'a': 20, 'b': 8}Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: The result of 20 + (2 * 4) is 28. + + +```python +print(str(response)) +``` + + The result of 20 + (2 * 4) is 28. + + + +```python +print(response.tool_calls) +``` + + [ToolCallResult(tool_name='multiply', tool_kwargs={'a': 2, 'b': 4}, tool_id='a394d807-a9b7-42e0-8bff-f47a432d1530', tool_output=ToolOutput(content='8', tool_name='multiply', raw_input={'args': (), 'kwargs': {'a': 2, 'b': 4}}, raw_output=8, is_error=False), return_direct=False), ToolCallResult(tool_name='add', tool_kwargs={'a': 20, 'b': 8}, tool_id='784ccd85-ae9a-4184-9613-3696742064c7', tool_output=ToolOutput(content='28', tool_name='add', raw_input={'args': (), 'kwargs': {'a': 20, 'b': 8}}, raw_output=28, is_error=False), return_direct=False)] + + +## View Prompts + +Let's take a look at the core system prompt powering the ReAct agent! + +Within the agent, the current conversation history is dumped below this line. + + +```python +prompt_dict = agent.get_prompts() +for k, v in prompt_dict.items(): + print(f"Prompt: {k}\n\nValue: {v.template}") +``` + + Prompt: react_header + + Value: You are designed to help with a variety of tasks, from answering questions to providing summaries to other types of analyses. + + ## Tools + + You have access to a wide variety of tools. You are responsible for using the tools in any sequence you deem appropriate to complete the task at hand. + This may require breaking the task into subtasks and using different tools to complete each subtask. + + You have access to the following tools: + {tool_desc} + + + ## Output Format + + Please answer in the same language as the question and use the following format: + + ``` + Thought: The current language of the user is: (user's language). I need to use a tool to help me answer the question. + Action: tool name (one of {tool_names}) if using a tool. + Action Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}}) + ``` + + Please ALWAYS start with a Thought. + + NEVER surround your response with markdown code markers. You may use code markers within your response if you need to. + + Please use a valid JSON format for the Action Input. Do NOT do this {{'input': 'hello world', 'num_beams': 5}}. + + If this format is used, the tool will respond in the following format: + + ``` + Observation: tool response + ``` + + You should keep repeating the above format till you have enough information to answer the question without using any more tools. At that point, you MUST respond in one of the following two formats: + + ``` + Thought: I can answer without using any more tools. I'll use the user's language to answer + Answer: [your answer here (In the same language as the user's question)] + ``` + + ``` + Thought: I cannot answer the question with the provided tools. + Answer: [your answer here (In the same language as the user's question)] + ``` + + ## Current Conversation + + Below is the current conversation consisting of interleaving human and assistant messages. + + + +### Customizing the Prompt + +For fun, let's try instructing the agent to output the answer along with reasoning in bullet points. See "## Additional Rules" section. + + +```python +from llama_index.core import PromptTemplate + +react_system_header_str = """\ + +You are designed to help with a variety of tasks, from answering questions \ + to providing summaries to other types of analyses. + +## Tools +You have access to a wide variety of tools. You are responsible for using +the tools in any sequence you deem appropriate to complete the task at hand. +This may require breaking the task into subtasks and using different tools +to complete each subtask. + +You have access to the following tools: +{tool_desc} + +## Output Format +To answer the question, please use the following format. + +``` +Thought: I need to use a tool to help me answer the question. +Action: tool name (one of {tool_names}) if using a tool. +Action Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}}) +``` + +Please ALWAYS start with a Thought. + +Please use a valid JSON format for the Action Input. Do NOT do this {{'input': 'hello world', 'num_beams': 5}}. + +If this format is used, the user will respond in the following format: + +``` +Observation: tool response +``` + +You should keep repeating the above format until you have enough information +to answer the question without using any more tools. At that point, you MUST respond +in the one of the following two formats: + +``` +Thought: I can answer without using any more tools. +Answer: [your answer here] +``` + +``` +Thought: I cannot answer the question with the provided tools. +Answer: Sorry, I cannot answer your query. +``` + +## Additional Rules +- The answer MUST contain a sequence of bullet points that explain how you arrived at the answer. This can include aspects of the previous conversation history. +- You MUST obey the function signature of each tool. Do NOT pass in no arguments if the function expects arguments. + +## Current Conversation +Below is the current conversation consisting of interleaving human and assistant messages. + +""" +react_system_prompt = PromptTemplate(react_system_header_str) +``` + + +```python +agent.get_prompts() +``` + + + + + {'react_header': PromptTemplate(metadata={'prompt_type': }, template_vars=['tool_desc', 'tool_names'], kwargs={}, output_parser=None, template_var_mappings=None, function_mappings=None, template='You are designed to help with a variety of tasks, from answering questions to providing summaries to other types of analyses.\n\n## Tools\n\nYou have access to a wide variety of tools. You are responsible for using the tools in any sequence you deem appropriate to complete the task at hand.\nThis may require breaking the task into subtasks and using different tools to complete each subtask.\n\nYou have access to the following tools:\n{tool_desc}\n\n\n## Output Format\n\nPlease answer in the same language as the question and use the following format:\n\n```\nThought: The current language of the user is: (user\'s language). I need to use a tool to help me answer the question.\nAction: tool name (one of {tool_names}) if using a tool.\nAction Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}})\n```\n\nPlease ALWAYS start with a Thought.\n\nNEVER surround your response with markdown code markers. You may use code markers within your response if you need to.\n\nPlease use a valid JSON format for the Action Input. Do NOT do this {{\'input\': \'hello world\', \'num_beams\': 5}}.\n\nIf this format is used, the tool will respond in the following format:\n\n```\nObservation: tool response\n```\n\nYou should keep repeating the above format till you have enough information to answer the question without using any more tools. At that point, you MUST respond in one of the following two formats:\n\n```\nThought: I can answer without using any more tools. I\'ll use the user\'s language to answer\nAnswer: [your answer here (In the same language as the user\'s question)]\n```\n\n```\nThought: I cannot answer the question with the provided tools.\nAnswer: [your answer here (In the same language as the user\'s question)]\n```\n\n## Current Conversation\n\nBelow is the current conversation consisting of interleaving human and assistant messages.\n')} + + + + +```python +agent.update_prompts({"react_header": react_system_prompt}) +``` + + +```python +handler = agent.run("What is 5+3+2") + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to help me answer the question. + Action: add + Action Input: {"a": 5, "b": 3}Thought: I need to add the result (8) to the remaining number (2). + Action: add + Action Input: {'a': 8, 'b': 2}Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: The result of 5 + 3 + 2 is 10. + + +```python +print(response) +``` + + The result of 5 + 3 + 2 is 10. + diff --git a/.tmp/agent/react_agent_with_query_engine.md b/.tmp/agent/react_agent_with_query_engine.md new file mode 100644 index 0000000..190802e --- /dev/null +++ b/.tmp/agent/react_agent_with_query_engine.md @@ -0,0 +1,215 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/react_agent_with_query_engine.ipynb +toc: True +title: "ReAct Agent with Query Engine (RAG) Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +In this section, we show how to setup an agent powered by the ReAct loop for financial analysis. + +The agent has access to two "tools": one to query the 2021 Lyft 10-K and the other to query the 2021 Uber 10-K. + +Note that you can plug in any LLM to use as a ReAct agent. + +## Build Query Engine Tools + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +from llama_index.core import StorageContext, load_index_from_storage + +try: + storage_context = StorageContext.from_defaults( + persist_dir="./storage/lyft" + ) + lyft_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/uber" + ) + uber_index = load_index_from_storage(storage_context) + + index_loaded = True +except: + index_loaded = False +``` + +Download Data + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/lyft_2021.pdf' -O 'data/10k/lyft_2021.pdf' +``` + + +```python +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex + +if not index_loaded: + # load data + lyft_docs = SimpleDirectoryReader( + input_files=["./data/10k/lyft_2021.pdf"] + ).load_data() + uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] + ).load_data() + + # build index + lyft_index = VectorStoreIndex.from_documents(lyft_docs) + uber_index = VectorStoreIndex.from_documents(uber_docs) + + # persist index + lyft_index.storage_context.persist(persist_dir="./storage/lyft") + uber_index.storage_context.persist(persist_dir="./storage/uber") +``` + + +```python +lyft_engine = lyft_index.as_query_engine(similarity_top_k=3) +uber_engine = uber_index.as_query_engine(similarity_top_k=3) +``` + + +```python +from llama_index.core.tools import QueryEngineTool + +query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=lyft_engine, + name="lyft_10k", + description=( + "Provides information about Lyft financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), +] +``` + +## Setup ReAct Agent + +Here we setup our ReAct agent with the tools we created above. + +You can **optionally** specify a system prompt which will be added to the core ReAct system prompt. + + +```python +from llama_index.core.agent.workflow import ReActAgent +from llama_index.core.workflow import Context + +agent = ReActAgent( + tools=query_engine_tools, + llm=OpenAI(model="gpt-4o-mini"), + # system_prompt="..." +) + +# context to hold this session/state + +ctx = Context(agent) +``` + +## Run Some Example Queries + +By streaming the result, we can see the full response, including the thought process and tool calls. + +If we wanted to stream only the result, we can buffer the stream and start streaming once `Answer:` is in the response. + + + +```python +from llama_index.core.agent.workflow import ToolCallResult, AgentStream + +handler = agent.run("What was Lyft's revenue growth in 2021?", ctx=ctx) + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to help me answer the question. + Action: lyft_10k + Action Input: {"input": "What was Lyft's revenue growth in 2021?"}Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: Lyft's revenue growth in 2021 was 36% compared to the prior year. + + +```python +print(str(response)) +``` + + Lyft's revenue growth in 2021 was 36% compared to the prior year. + + + +```python +handler = agent.run( + "Compare and contrast the revenue growth of Uber and Lyft in 2021, then give an analysis", + ctx=ctx, +) + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to gather information about Uber's revenue growth in 2021 to compare it with Lyft's. + Action: uber_10k + Action Input: {'input': "What was Uber's revenue growth in 2021?"}Thought: I now have the revenue growth information for both Uber and Lyft in 2021. Lyft's revenue growth was 36%, while Uber's was 57%. I will now provide a comparison and analysis. + Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: In 2021, Uber experienced a revenue growth of 57%, increasing from $11.139 billion in 2020 to $17.455 billion. In contrast, Lyft's revenue growth was 36%. + + When comparing the two, Uber outperformed Lyft in terms of revenue growth, indicating a stronger recovery or expansion in its business operations during that year. This could be attributed to Uber's diversified services, including food delivery through Uber Eats, which may have contributed significantly to its revenue. Lyft, primarily focused on ride-sharing, may have faced more challenges in scaling its growth compared to Uber. + + Overall, while both companies showed positive growth, Uber's higher percentage suggests it was able to capitalize on market opportunities more effectively than Lyft in 2021. + + +```python +print(str(response)) +``` + + In 2021, Uber experienced a revenue growth of 57%, increasing from $11.139 billion in 2020 to $17.455 billion. In contrast, Lyft's revenue growth was 36%. + + When comparing the two, Uber outperformed Lyft in terms of revenue growth, indicating a stronger recovery or expansion in its business operations during that year. This could be attributed to Uber's diversified services, including food delivery through Uber Eats, which may have contributed significantly to its revenue. Lyft, primarily focused on ride-sharing, may have faced more challenges in scaling its growth compared to Uber. + + Overall, while both companies showed positive growth, Uber's higher percentage suggests it was able to capitalize on market opportunities more effectively than Lyft in 2021. + diff --git a/.tmp/agent/return_direct_agent.md b/.tmp/agent/return_direct_agent.md new file mode 100644 index 0000000..da8d799 --- /dev/null +++ b/.tmp/agent/return_direct_agent.md @@ -0,0 +1,250 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/return_direct_agent.ipynb +toc: True +title: "Controlling Agent Reasoning Loop with Return Direct Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +All tools have an option for `return_direct` -- if this is set to `True`, and the associated tool is called (without any other tools being called), the agent reasoning loop is ended and the tool output is returned directly. + +This can be useful for speeding up response times when you know the tool output is good enough, to avoid the agent re-writing the response, and for ending the reasoning loop. + +This notebook walks through a notebook where an agent needs to gather information from a user in order to make a restaurant booking. + + +```python +%pip install llama-index-core llama-index-llms-anthropic +``` + + +```python +import os + +os.environ["ANTHROPIC_API_KEY"] = "sk-..." +``` + +## Tools setup + + +```python +from typing import Optional + +from llama_index.core.tools import FunctionTool +from pydantic import BaseModel + +# we will store booking under random IDs +bookings = {} + + +# we will represent and track the state of a booking as a Pydantic model +class Booking(BaseModel): + name: Optional[str] = None + email: Optional[str] = None + phone: Optional[str] = None + date: Optional[str] = None + time: Optional[str] = None + + +def get_booking_state(user_id: str) -> str: + """Get the current state of a booking for a given booking ID.""" + try: + return str(bookings[user_id].dict()) + except: + return f"Booking ID {user_id} not found" + + +def update_booking(user_id: str, property: str, value: str) -> str: + """Update a property of a booking for a given booking ID. Only enter details that are explicitly provided.""" + booking = bookings[user_id] + setattr(booking, property, value) + return f"Booking ID {user_id} updated with {property} = {value}" + + +def create_booking(user_id: str) -> str: + """Create a new booking and return the booking ID.""" + bookings[user_id] = Booking() + return "Booking created, but not yet confirmed. Please provide your name, email, phone, date, and time." + + +def confirm_booking(user_id: str) -> str: + """Confirm a booking for a given booking ID.""" + booking = bookings[user_id] + + if booking.name is None: + raise ValueError("Please provide your name.") + + if booking.email is None: + raise ValueError("Please provide your email.") + + if booking.phone is None: + raise ValueError("Please provide your phone number.") + + if booking.date is None: + raise ValueError("Please provide the date of your booking.") + + if booking.time is None: + raise ValueError("Please provide the time of your booking.") + + return f"Booking ID {user_id} confirmed!" + + +# create tools for each function +get_booking_state_tool = FunctionTool.from_defaults(fn=get_booking_state) +update_booking_tool = FunctionTool.from_defaults(fn=update_booking) +create_booking_tool = FunctionTool.from_defaults( + fn=create_booking, return_direct=True +) +confirm_booking_tool = FunctionTool.from_defaults( + fn=confirm_booking, return_direct=True +) +``` + +## A user has walked in! Let's help them make a booking + + +```python +from llama_index.llms.anthropic import Anthropic +from llama_index.core.llms import ChatMessage +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.core.workflow import Context + +llm = Anthropic(model="claude-3-sonnet-20240229", temperature=0.1) + +user = "user123" +system_prompt = f"""You are now connected to the booking system and helping {user} with making a booking. +Only enter details that the user has explicitly provided. +Do not make up any details. +""" + +agent = FunctionAgent( + tools=[ + get_booking_state_tool, + update_booking_tool, + create_booking_tool, + confirm_booking_tool, + ], + llm=llm, + system_prompt=system_prompt, +) + +# create a context for the agent to hold the state/history of a session +ctx = Context(agent) +``` + + +```python +from llama_index.core.agent.workflow import AgentStream, ToolCallResult + +handler = agent.run( + "Hello! I would like to make a booking, around 5pm?", ctx=ctx +) + +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + elif isinstance(ev, ToolCallResult): + print( + f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + +response = await handler +``` + + Okay, let's create a new booking for you.{"user_id": "user123"} + Call create_booking with {'user_id': 'user123'} + Returned: Booking created, but not yet confirmed. Please provide your name, email, phone, date, and time. + + + +```python +print(str(response)) +``` + + Booking created, but not yet confirmed. Please provide your name, email, phone, date, and time. + + +Perfect, we can see the function output was retruned directly, with no modification or final LLM call! + + +```python +handler = agent.run( + "Sure! My name is Logan, and my email is test@gmail.com?", ctx=ctx +) + +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + elif isinstance(ev, ToolCallResult): + print( + f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + +response = await handler +``` + + Got it, thanks for providing your name and email. I've updated the booking with that information.{"user_id": "user123", "property": "name", "value": "Logan"}{"user_id": "user123", "property": "email", "value": "test@gmail.com"} + Call update_booking with {'user_id': 'user123', 'property': 'name', 'value': 'Logan'} + Returned: Booking ID user123 updated with name = Logan + + Call update_booking with {'user_id': 'user123', 'property': 'email', 'value': 'test@gmail.com'} + Returned: Booking ID user123 updated with email = test@gmail.com + Please also provide your phone number, preferred date, and time for the booking. + + +```python +print(str(response)) +``` + + Please also provide your phone number, preferred date, and time for the booking. + + + +```python +handler = agent.run( + "Right! My phone number is 1234567890, the date of the booking is April 5, at 5pm.", + ctx=ctx, +) + +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + elif isinstance(ev, ToolCallResult): + print( + f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + +response = await handler +``` + + Great, thank you for providing the additional details. I've updated the booking with your phone number, date, and time.{"user_id": "user123", "property": "phone", "value": "1234567890"}{"user_id": "user123", "property": "date", "value": "2023-04-05"}{"user_id": "user123", "property": "time", "value": "17:00"} + Call update_booking with {'user_id': 'user123', 'property': 'phone', 'value': '1234567890'} + Returned: Booking ID user123 updated with phone = 1234567890 + + Call update_booking with {'user_id': 'user123', 'property': 'date', 'value': '2023-04-05'} + Returned: Booking ID user123 updated with date = 2023-04-05 + + Call update_booking with {'user_id': 'user123', 'property': 'time', 'value': '17:00'} + Returned: Booking ID user123 updated with time = 17:00 + Looks like I have all the necessary details. Let me confirm this booking for you.{"user_id": "user123"} + Call confirm_booking with {'user_id': 'user123'} + Returned: Booking ID user123 confirmed! + + + +```python +print(str(response)) +``` + + Booking ID user123 confirmed! + + + +```python +print(bookings["user123"]) +``` + + name='Logan' email='test@gmail.com' phone='1234567890' date='2023-04-05' time='17:00' + diff --git a/README.md b/README.md index be4403f..d931dda 100644 --- a/README.md +++ b/README.md @@ -2,14 +2,53 @@ ### The Idea for Pyhton Examples -1. You add a notebook wherever you want in the `/notebooks` directory + +1. You add a notebook wherever you want in the `/notebooks` directory OR, it already exists in another `source` 2. You want it to go onto the website? You add an entry to "index.toml" for your example. Here's the info we need: - A description - The location of your example - Some tags - If you want, you can mark it 'experimental' - If _we_ want, we can make it 'featured' + - Mark the `language` as `language = "py"` 3. A github action on this repo or on the `developers` repo runs the `scripts/notebooks_to_markdown.py` script. Which converts your notebook to markdown with some frontmatter which includes: - all of the info above - an auto generate 'open in Colab' url so you don't have to worry about adding it yourself -4. (This is my idea but we can change it) In Astro, we use this frontmatter to generate a tiled 'Cookbook' page with tags and filters. You can easilyl navigate different topics and all LlamaCloud/LITS/LI examples. When you click-> takes you to usual Examples page. \ No newline at end of file +4. (This is my idea but we can change it) In Astro, we use this frontmatter to generate a tiled 'Cookbook' page with tags and filters. You can easilyl navigate different topics and all LlamaCloud/LITS/LI examples. When you click-> takes you to usual Examples page. + +> Extra: This POC has most examples as a local `notebook` and one example where the recipe comes from another `source`. For those that come from a local `notebook`, we also generate a frontmatter element called `colab` which auto-generates the 'open in colab' url. This can be used for an 'open in colab' button 🚀 + +### (Optional) Example Generated frontmatter for Astro to generate individual recipe pages: +This is useful if you want to use the generated frontmatter which can be used to add elements to individual recipes like tags, an 'open in colab' button, etc. + +``` +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_builder.ipynb +toc: True +title: "GPT Builder Demo" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +``` +### Example build run for the astro website: + +```bash +pip install -r requirements.txt +python scripts/notebooks_to_markdown.py +``` + +This adds all of the _local_ notebooks as markdown, into the `makrdowns` directory, along with their frontmatter. + + +### POC Landing Page Generation for Astro + +> Disclaimer: This index.toml to landing page generation code was created with Claude :) + +```bash +python scripts/cookbook_page_generator.py index.toml -o my_cookbooks.html +``` +This outputs a POC HTML page that you can have a look at. It's just to demonstrate how the index.toml can be used. +Note that it has both local notebooks + external sources \ No newline at end of file diff --git a/index.toml b/index.toml index 05e10bd..db4daa9 100644 --- a/index.toml +++ b/index.toml @@ -1,7 +1,7 @@ [config] layout = "recipe" toc = true -colab = "https://colab.research.google.com/github/TuanaCelik/cookbooks-demo/blob/main/" +colab = "https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/" [[recipe]] title = "Agent Workflow + Research Assistant using AgentQL" @@ -9,10 +9,210 @@ notebook = "notebooks/agent/agent_workflow_research_assistant.ipynb" tags = ["Agent", "Websearch", "Integrations"] description = "Build a research assistant using AgentWorlflow and websearch tools" experimental = true +featured = true +language = "py" [[recipe]] title = "Custom Planning Multi-Agent System" notebook = "notebooks/agent/custom_multi_agent.ipynb" tags = ["Agent"] description = "Build a research agent that writes and refines reports with a multi-agent structure." -featured = true \ No newline at end of file +featured = true +language = "py" + +[[recipe]] +title = "Parsing Documents with Instructions" +source = "https://github.com/run-llama/llama_cloud_services/blob/main/examples/parse/parsing_instructions/parsing_instructions.ipynb" +tags = ["LlamaParse"] +description = "Parse documents with additional instructions" +featured = true +language = "py" + +[[recipe]] +title = "Agent Builder" +notebook = "notebooks/agent/agent_builder.ipynb" +tags = ["Agent"] +description = "Create and configure agents with custom tools and capabilities" +language = "py" + +[[recipe]] +title = "Basic Agent Workflow" +notebook = "notebooks/agent/agent_workflow_basic.ipynb" +tags = ["Agent"] +description = "Get started with basic agent workflows and tool usage" +language = "py" + +[[recipe]] +title = "Multi-Agent Workflow" +notebook = "notebooks/agent/agent_workflow_multi.ipynb" +tags = ["Agent"] +description = "Build complex workflows with multiple collaborating agents" +language = "py" + +[[recipe]] +title = "Anthropic Claude Agent" +notebook = "notebooks/agent/anthropic_agent.ipynb" +tags = ["Agent", "Integrations"] +description = "Use Anthropic's Claude model as an agent with tools" +language = "py" + +[[recipe]] +title = "AWS Bedrock Converse Agent" +notebook = "notebooks/agent/bedrock_converse_agent.ipynb" +tags = ["Agent", "Integrations"] +description = "Integrate AWS Bedrock Converse with agent workflows" +language = "py" + +[[recipe]] +title = "Code Act Agent" +notebook = "notebooks/agent/code_act_agent.ipynb" +tags = ["Agent"] +description = "Build agents that can write and execute code" +language = "py" + +[[recipe]] +title = "From Scratch Code Act Agent" +notebook = "notebooks/agent/from_scratch_code_act_agent.ipynb" +tags = ["Agent"] +description = "Create a code-writing agent from the ground up" +language = "py" + +[[recipe]] +title = "Mistral Agent" +notebook = "notebooks/agent/mistral_agent.ipynb" +tags = ["Agent", "Integrations"] +description = "Use Mistral AI models as agents with tool integration" +language = "py" + +[[recipe]] +title = "NVIDIA Agent" +notebook = "notebooks/agent/nvidia_agent.ipynb" +tags = ["Agent", "Integrations"] +description = "Integrate NVIDIA AI models with agent workflows" +language = "py" + +[[recipe]] +title = "NVIDIA Document Research Assistant" +notebook = "notebooks/agent/nvidia_document_research_assistant_for_blog_creation.ipynb" +tags = ["Agent", "Integrations"] +description = "Create a document research assistant for blog content generation" +language = "py" + +[[recipe]] +title = "NVIDIA Sub-Question Query Engine" +notebook = "notebooks/agent/nvidia_sub_question_query_engine.ipynb" +tags = ["Agent", "Integrations"] +description = "Build a query engine that breaks complex questions into sub-questions" +language = "py" + +[[recipe]] +title = "OpenAI Agent with Context Retrieval" +notebook = "notebooks/agent/openai_agent_context_retrieval.ipynb" +tags = ["Agent", "Integrations"] +description = "Use OpenAI agents with advanced context retrieval capabilities" +language = "py" + +[[recipe]] +title = "OpenAI Agent with Lengthy Tools" +notebook = "notebooks/agent/openai_agent_lengthy_tools.ipynb" +tags = ["Agent", "Integrations"] +description = "Handle complex tools and long-running operations with OpenAI agents" +language = "py" + +[[recipe]] +title = "OpenAI Agent Query Cookbook" +notebook = "notebooks/agent/openai_agent_query_cookbook.ipynb" +tags = ["Agent", "Integrations"] +description = "Comprehensive guide to OpenAI agent query patterns and best practices" +language = "py" + +[[recipe]] +title = "OpenAI Agent Retrieval" +notebook = "notebooks/agent/openai_agent_retrieval.ipynb" +tags = ["Agent", "Integrations"] +description = "Implement retrieval-augmented generation with OpenAI agents" +language = "py" + +[[recipe]] +title = "OpenAI Agent with Query Engine" +notebook = "notebooks/agent/openai_agent_with_query_engine.ipynb" +tags = ["Agent", "Integrations"] +description = "Combine OpenAI agents with query engines for enhanced information retrieval" +language = "py" + +[[recipe]] +title = "ReAct Agent" +notebook = "notebooks/agent/react_agent.ipynb" +tags = ["Agent"] +description = "Implement reasoning and acting agents with step-by-step problem solving" +language = "py" + +[[recipe]] +title = "ReAct Agent with Query Engine" +notebook = "notebooks/agent/react_agent_with_query_engine.ipynb" +tags = ["Agent"] +description = "Combine ReAct agents with query engines for structured reasoning" +language = "py" + +[[recipe]] +title = "Return Direct Agent" +notebook = "notebooks/agent/return_direct_agent.ipynb" +tags = ["Agent"] +description = "Build agents that return direct responses without intermediate steps" +language = "py" + +[[recipe]] +title = "Agents as Tools" +notebook = "notebooks/agent/agents_as_tools.ipynb" +tags = ["Agent"] +description = "Use agents as tools within other agent workflows" +language = "py" + +[[recipe]] +title = "Multi-Agent Workflow with Weaviate" +notebook = "notebooks/agent/multi_agent_workflow_with_weaviate_queryagent.ipynb" +tags = ["Agent", "Integrations"] +description = "Build multi-agent systems with Weaviate vector database integration" +language = "py" + +[[recipe]] +title = "Multi-Document Agents" +notebook = "notebooks/agent/multi_document_agents-v1.ipynb" +tags = ["Agent"] +description = "Create agents that can process and reason across multiple documents" +language = "py" + +[[recipe]] +title = "SEC Chatbot" +notebook = "notebooks/agent/Chatbot_SEC.ipynb" +tags = ["Agent"] +description = "Build a specialized chatbot for SEC document analysis and queries" +language = "py" + +[[recipe]] +title = "Chat Memory Buffer" +notebook = "notebooks/agent/memory/chat_memory_buffer.ipynb" +tags = ["Agent", "Memory"] +description = "Implement conversation memory using buffer storage" +language = "py" + +[[recipe]] +title = "Composable Memory" +notebook = "notebooks/agent/memory/composable_memory.ipynb" +tags = ["Agent", "Memory"] +description = "Build flexible memory systems that can be composed and combined" +language = "py" + +[[recipe]] +title = "Summary Memory Buffer" +notebook = "notebooks/agent/memory/summary_memory_buffer.ipynb" +tags = ["Agent", "Memory"] +description = "Use summarization techniques for efficient conversation memory" +language = "py" + +[[recipe]] +title = "Vector Memory" +notebook = "notebooks/agent/memory/vector_memory.ipynb" +tags = ["Agent", "Memory"] +description = "Implement semantic memory using vector embeddings" +language = "py" \ No newline at end of file diff --git a/markdowns/Agent/Chatbot_SEC.md b/markdowns/Agent/Chatbot_SEC.md new file mode 100644 index 0000000..f3dddc2 --- /dev/null +++ b/markdowns/Agent/Chatbot_SEC.md @@ -0,0 +1,333 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/Chatbot_SEC.ipynb +toc: True +title: "How to Build a Chatbot" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +LlamaIndex serves as a bridge between your data and Language Learning Models (LLMs), providing a toolkit that enables you to establish a query interface around your data for a variety of tasks, such as question-answering and summarization. + +In this tutorial, we'll walk you through building a context-augmented chatbot using a [Data Agent](https://gpt-index.readthedocs.io/en/stable/core_modules/agent_modules/agents/root.html). This agent, powered by LLMs, is capable of intelligently executing tasks over your data. The end result is a chatbot agent equipped with a robust set of data interface tools provided by LlamaIndex to answer queries about your data. + +**Note**: This tutorial builds upon initial work on creating a query interface over SEC 10-K filings - [check it out here](https://medium.com/@jerryjliu98/how-unstructured-and-llamaindex-can-help-bring-the-power-of-llms-to-your-own-data-3657d063e30d). + +### Context + +In this guide, we’ll build a "10-K Chatbot" that uses raw UBER 10-K HTML filings from Dropbox. Users can interact with the chatbot to ask questions related to the 10-K filings. + +### Preparation + + +```python +%pip install llama-index-readers-file +%pip install llama-index-embeddings-openai +%pip install llama-index-agent-openai +%pip install llama-index-llms-openai +%pip install llama-index-question-gen-openai +%pip install unstructured +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.core import Settings +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding + +# global defaults +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model_name="text-embedding-3-large") +Settings.chunk_size = 512 +Settings.chunk_overlap = 64 +``` + +### Ingest Data + +Let's first download the raw 10-k files, from 2019-2022. + + +```python +# NOTE: the code examples assume you're operating within a Jupyter notebook. +# download files +!mkdir data +!wget "https://www.dropbox.com/s/948jr9cfs7fgj99/UBER.zip?dl=1" -O data/UBER.zip +!unzip data/UBER.zip -d data +``` + +To parse the HTML files into formatted text, we use the [Unstructured](https://github.com/Unstructured-IO/unstructured) library. Thanks to [LlamaHub](https://llamahub.ai/), we can directly integrate with Unstructured, allowing conversion of any text into a Document format that LlamaIndex can ingest. + +First we install the necessary packages: + +Then we can use the `UnstructuredReader` to parse the HTML files into a list of `Document` objects. + + +```python +from llama_index.readers.file import UnstructuredReader +from pathlib import Path + +years = [2022, 2021, 2020, 2019] +``` + + +```python +loader = UnstructuredReader() +doc_set = {} +all_docs = [] +for year in years: + year_docs = loader.load_data( + file=Path(f"./data/UBER/UBER_{year}.html"), split_documents=False + ) + # insert year metadata into each year + for d in year_docs: + d.metadata = {"year": year} + doc_set[year] = year_docs + all_docs.extend(year_docs) +``` + +### Setting up Vector Indices for each year + +We first setup a vector index for each year. Each vector index allows us +to ask questions about the 10-K filing of a given year. + +We build each index and save it to disk. + + +```python +# initialize simple vector indices +# NOTE: don't run this cell if the indices are already loaded! +from llama_index.core import VectorStoreIndex, StorageContext + + +index_set = {} +for year in years: + storage_context = StorageContext.from_defaults() + cur_index = VectorStoreIndex.from_documents( + doc_set[year], + storage_context=storage_context, + ) + index_set[year] = cur_index + storage_context.persist(persist_dir=f"./storage/{year}") +``` + +To load an index from disk, do the following + + +```python +# Load indices from disk +from llama_index.core import StorageContext, load_index_from_storage + +index_set = {} +for year in years: + storage_context = StorageContext.from_defaults( + persist_dir=f"./storage/{year}" + ) + cur_index = load_index_from_storage( + storage_context, + ) + index_set[year] = cur_index +``` + +### Setting up a Sub Question Query Engine to Synthesize Answers Across 10-K Filings + +Since we have access to documents of 4 years, we may not only want to ask questions regarding the 10-K document of a given year, but ask questions that require analysis over all 10-K filings. + +To address this, we can use a [Sub Question Query Engine](https://gpt-index.readthedocs.io/en/stable/examples/query_engine/sub_question_query_engine.html). It decomposes a query into subqueries, each answered by an individual vector index, and synthesizes the results to answer the overall query. + +LlamaIndex provides some wrappers around indices (and query engines) so that they can be used by query engines and agents. First we define a `QueryEngineTool` for each vector index. +Each tool has a name and a description; these are what the LLM agent sees to decide which tool to choose. + + +```python +from llama_index.core.tools import QueryEngineTool + +individual_query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=index_set[year].as_query_engine(), + name=f"vector_index_{year}", + description=( + "useful for when you want to answer queries about the" + f" {year} SEC 10-K for Uber" + ), + ) + for year in years +] +``` + +Now we can create the Sub Question Query Engine, which will allow us to synthesize answers across the 10-K filings. We pass in the `individual_query_engine_tools` we defined above. + + +```python +from llama_index.core.query_engine import SubQuestionQueryEngine + +query_engine = SubQuestionQueryEngine.from_defaults( + query_engine_tools=individual_query_engine_tools, +) +``` + +### Setting up the Chatbot Agent + +We use a LlamaIndex Data Agent to setup the outer chatbot agent, which has access to a set of Tools. Specifically, we will use an OpenAIAgent, that takes advantage of OpenAI API function calling. We want to use the separate Tools we defined previously for each index (corresponding to a given year), as well as a tool for the sub question query engine we defined above. + +First we define a `QueryEngineTool` for the sub question query engine: + + +```python +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=query_engine, + name="sub_question_query_engine", + description=( + "useful for when you want to answer queries that require analyzing" + " multiple SEC 10-K documents for Uber" + ), +) +``` + +Then, we combine the Tools we defined above into a single list of tools for the agent: + + +```python +tools = individual_query_engine_tools + [query_engine_tool] +``` + +Finally, we call `FunctionAgent` to create the agent, passing in the list of tools we defined above. + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent(tools=tools, llm=OpenAI(model="gpt-4o")) +``` + +### Testing the Agent + +We can now test the agent with various queries. + +If we test it with a simple "hello" query, the agent does not use any Tools. + + +```python +from llama_index.core.workflow import Context + +# Setup the context for this specific interaction +ctx = Context(agent) + +response = await agent.run("hi, i am bob", ctx=ctx) +print(str(response)) +``` + + Hello Bob! How can I assist you today? + + +If we test it with a query regarding the 10-k of a given year, the agent will use +the relevant vector index Tool. + + +```python +response = await agent.run( + "What were some of the biggest risk factors in 2020 for Uber?", ctx=ctx +) +print(str(response)) +``` + + In 2020, some of the biggest risk factors for Uber included: + + 1. **Legal and Regulatory Risks**: Extensive government regulation and oversight could adversely impact operations and future prospects. + 2. **Data Privacy and Security Risks**: Risks related to data collection, use, and processing could lead to investigations, litigation, and negative publicity. + 3. **Economic Impact of COVID-19**: The pandemic adversely affected business operations, demand for services, and financial condition due to governmental restrictions and changes in consumer behavior. + 4. **Market Volatility**: Volatility in the market price of common stock could affect investors' ability to resell shares at favorable prices. + 5. **Safety Incidents**: Criminal or dangerous activities on the platform could harm the ability to attract and retain drivers and consumers. + 6. **Investment Risks**: Substantial investments in new technologies and offerings carry inherent risks, with no guarantee of realizing expected benefits. + 7. **Dependence on Metropolitan Areas**: A significant portion of gross bookings comes from large metropolitan areas, which may be negatively impacted by various external factors. + 8. **Talent Retention**: Attracting and retaining high-quality personnel is crucial, and issues with attrition or succession planning could adversely affect the business. + 9. **Cybersecurity Threats**: Cyberattacks and data breaches could harm reputation and operational results. + 10. **Capital Requirements**: The need for additional capital to support growth may not be met on reasonable terms, impacting business expansion. + 11. **Acquisition Challenges**: Difficulty in identifying and integrating suitable businesses could harm operating results and future prospects. + 12. **Operational Limitations**: Potential restrictions in certain jurisdictions may require modifications to the business model, affecting service delivery. + + +Finally, if we test it with a query to compare/contrast risk factors across years, the agent will use the Sub Question Query Engine Tool. + + +```python +cross_query_str = ( + "Compare/contrast the risk factors described in the Uber 10-K across" + " years. Give answer in bullet points." +) + +response = await agent.run(cross_query_str, ctx=ctx) +print(str(response)) +``` + + Here's a comparison of the risk factors for Uber across the years 2020, 2021, and 2022: + + - **COVID-19 Impact**: + - **2020**: The pandemic significantly affected business operations, demand, and financial condition. + - **2021**: Continued impact of the pandemic was a concern, affecting various parts of the business. + - **2022**: The pandemic's impact was less emphasized, with more focus on operational and competitive risks. + + - **Driver Classification**: + - **2020**: Not specifically highlighted. + - **2021**: Potential reclassification of Drivers as employees could alter the business model. + - **2022**: Continued risk of reclassification impacting operational costs. + + - **Competition**: + - **2020**: Not specifically highlighted. + - **2021**: Intense competition with low barriers to entry and well-capitalized competitors. + - **2022**: Competitive landscape challenges due to established alternatives and low barriers to entry. + + - **Financial Concerns**: + - **2020**: Market volatility and capital requirements were major concerns. + - **2021**: Historical losses and increased operating expenses raised profitability concerns. + - **2022**: Significant losses and rising expenses continued to raise profitability concerns. + + - **User and Personnel Retention**: + - **2020**: Talent retention was crucial, with risks from attrition. + - **2021**: Attracting and retaining a critical mass of users and personnel was essential. + - **2022**: Continued emphasis on retaining Drivers, consumers, and high-quality personnel. + + - **Brand and Reputation**: + - **2020**: Safety incidents and cybersecurity threats could harm reputation. + - **2021**: Maintaining and enhancing brand reputation was critical, with past negative publicity being a concern. + - **2022**: Brand and reputation were under scrutiny, with negative media coverage potentially harming prospects. + + - **Operational Challenges**: + - **2020**: Operational limitations and acquisition challenges were highlighted. + - **2021**: Challenges in managing growth and optimizing organizational structure. + - **2022**: Historical workplace culture and the need for organizational optimization were critical. + + - **Safety and Liability**: + - **2020**: Safety incidents and liability claims were significant risks. + - **2021**: Safety incidents and liability claims, especially with vulnerable road users, were concerns. + - **2022**: Safety incidents and public reporting could impact reputation and financial results. + + Overall, while some risk factors remained consistent across the years, such as competition, financial concerns, and safety, the emphasis shifted slightly with the evolving business environment and external factors like the pandemic. + + +### Setting up the Chatbot Loop + +Now that we have the chatbot setup, it only takes a few more steps to setup a basic interactive loop to chat with our SEC-augmented chatbot! + + +```python +agent = FunctionAgent(tools=tools, llm=OpenAI(model="gpt-4o")) +ctx = Context(agent) + +while True: + text_input = input("User: ") + if text_input == "exit": + break + response = await agent.run(text_input, ctx=ctx) + print(f"Agent: {response}") + +# User: What were some of the legal proceedings against Uber in 2022? +``` diff --git a/markdowns/Agent/Memory/chat_memory_buffer.md b/markdowns/Agent/Memory/chat_memory_buffer.md new file mode 100644 index 0000000..1753eb4 --- /dev/null +++ b/markdowns/Agent/Memory/chat_memory_buffer.md @@ -0,0 +1,99 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/chat_memory_buffer.ipynb +toc: True +title: "Chat Memory Buffer" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +The `ChatMemoryBuffer` is a memory buffer that simply stores the last X messages that fit into a token limit. + +%pip install llama-index-core + +## Setup + + +```python +from llama_index.core.memory import ChatMemoryBuffer + +memory = ChatMemoryBuffer.from_defaults(token_limit=40000) +``` + +## Using Standalone + + +```python +from llama_index.core.llms import ChatMessage + +chat_history = [ + ChatMessage(role="user", content="Hello, how are you?"), + ChatMessage(role="assistant", content="I'm doing well, thank you!"), +] + +# put a list of messages +memory.put_messages(chat_history) + +# put one message at a time +# memory.put_message(chat_history[0]) +``` + + +```python +# Get the last X messages that fit into a token limit +history = memory.get() +``` + + +```python +# Get all messages +all_history = memory.get_all() +``` + + +```python +# clear the memory +memory.reset() +``` + +## Using with Agents + +You can set the memory in any agent in the `.run()` method. + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-proj-..." +``` + + +```python +from llama_index.core.agent.workflow import ReActAgent, FunctionAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + + +memory = ChatMemoryBuffer.from_defaults(token_limit=40000) + +agent = FunctionAgent(tools=[], llm=OpenAI(model="gpt-4o-mini")) + +# context to hold the chat history/state +ctx = Context(agent) +``` + + +```python +resp = await agent.run("Hello, how are you?", ctx=ctx, memory=memory) +``` + + +```python +print(memory.get_all()) +``` + + [ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text='Hello, how are you?')]), ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text="Hello! I'm just a program, so I don't have feelings, but I'm here and ready to help you. How can I assist you today?")])] + diff --git a/markdowns/Agent/Memory/composable_memory.md b/markdowns/Agent/Memory/composable_memory.md new file mode 100644 index 0000000..2ab9bce --- /dev/null +++ b/markdowns/Agent/Memory/composable_memory.md @@ -0,0 +1,512 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/composable_memory.ipynb +toc: True +title: "Simple Composable Memory" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +In this notebook, we demonstrate how to inject multiple memory sources into an agent. Specifically, we use the `SimpleComposableMemory` which is comprised of a `primary_memory` as well as potentially several secondary memory sources (stored in `secondary_memory_sources`). The main difference is that `primary_memory` will be used as the main chat buffer for the agent, where as any retrieved messages from `secondary_memory_sources` will be injected to the system prompt message only. + +Multiple memory sources may be of use for example in situations where you have a longer-term memory such as `VectorMemory` that you want to use in addition to the default `ChatMemoryBuffer`. What you'll see in this notebook is that with a `SimpleComposableMemory` you'll be able to effectively "load" the desired messages from long-term memory into the main memory (i.e. the `ChatMemoryBuffer`). + +## How `SimpleComposableMemory` Works? + +We begin with the basic usage of the `SimpleComposableMemory`. Here we construct a `VectorMemory` as well as a default `ChatMemoryBuffer`. The `VectorMemory` will be our secondary memory source, whereas the `ChatMemoryBuffer` will be the main or primary one. To instantiate a `SimpleComposableMemory` object, we need to supply a `primary_memory` and (optionally) a list of `secondary_memory_sources`. + +![SimpleComposableMemoryIllustration](https://d3ddy8balm3goa.cloudfront.net/llamaindex/simple-composable-memory.excalidraw.svg) + + +```python +from llama_index.core.memory import ( + VectorMemory, + SimpleComposableMemory, + ChatMemoryBuffer, +) +from llama_index.core.llms import ChatMessage +from llama_index.embeddings.openai import OpenAIEmbedding + +vector_memory = VectorMemory.from_defaults( + vector_store=None, # leave as None to use default in-memory vector store + embed_model=OpenAIEmbedding(), + retriever_kwargs={"similarity_top_k": 1}, +) + +# let's set some initial messages in our secondary vector memory +msgs = [ + ChatMessage.from_str("You are a SOMEWHAT helpful assistant.", "system"), + ChatMessage.from_str("Bob likes burgers.", "user"), + ChatMessage.from_str("Indeed, Bob likes apples.", "assistant"), + ChatMessage.from_str("Alice likes apples.", "user"), +] +vector_memory.set(msgs) + +chat_memory_buffer = ChatMemoryBuffer.from_defaults() + +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=chat_memory_buffer, + secondary_memory_sources=[vector_memory], +) +``` + + +```python +composable_memory.primary_memory +``` + + + + + ChatMemoryBuffer(chat_store=SimpleChatStore(store={}), chat_store_key='chat_history', token_limit=3000, tokenizer_fn=functools.partial(>, allowed_special='all')) + + + + +```python +composable_memory.secondary_memory_sources +``` + + + + + [VectorMemory(vector_index=, retriever_kwargs={'similarity_top_k': 1}, batch_by_user_message=True, cur_batch_textnode=TextNode(id_='288b0ef3-570e-4698-a1ae-b3531df66361', embedding=None, metadata={'sub_dicts': [{'role': , 'content': 'Alice likes apples.', 'additional_kwargs': {}}]}, excluded_embed_metadata_keys=['sub_dicts'], excluded_llm_metadata_keys=['sub_dicts'], relationships={}, text='Alice likes apples.', start_char_idx=None, end_char_idx=None, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'))] + + + +### `put()` messages into memory + +Since `SimpleComposableMemory` is itself a subclass of `BaseMemory`, we add messages to it in the same way as we do for other memory modules. Note that for `SimpleComposableMemory`, invoking `.put()` effectively calls `.put()` on all memory sources. In other words, the message gets added to `primary` and `secondary` sources. + + +```python +msgs = [ + ChatMessage.from_str("You are a REALLY helpful assistant.", "system"), + ChatMessage.from_str("Jerry likes juice.", "user"), +] +``` + + +```python +# load into all memory sources modules" +for m in msgs: + composable_memory.put(m) +``` + +### `get()` messages from memory + +When `.get()` is invoked, we similarly execute all of the `.get()` methods of `primary` memory as well as all of the `secondary` sources. This leaves us with sequence of lists of messages that we have to must "compose" into a sensible single set of messages (to pass downstream to our agents). Special care must be applied here in general to ensure that the final sequence of messages are both sensible and conform to the chat APIs of the LLM provider. + +For `SimpleComposableMemory`, we **inject the messages from the `secondary` sources in the system message of the `primary` memory**. The rest of the message history of the `primary` source is left intact, and this composition is what is ultimately returned. + + +```python +msgs = composable_memory.get("What does Bob like?") +msgs +``` + + + + + [ChatMessage(role=, content='You are a REALLY helpful assistant.\n\nBelow are a set of relevant dialogues retrieved from potentially several memory sources:\n\n=====Relevant messages from memory source 1=====\n\n\tUSER: Bob likes burgers.\n\tASSISTANT: Indeed, Bob likes apples.\n\n=====End of relevant messages from memory source 1======\n\nThis is the end of the retrieved message dialogues.', additional_kwargs={}), + ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + + +```python +# see the memory injected into the system message of the primary memory +print(msgs[0]) +``` + + system: You are a REALLY helpful assistant. + + Below are a set of relevant dialogues retrieved from potentially several memory sources: + + =====Relevant messages from memory source 1===== + + USER: Bob likes burgers. + ASSISTANT: Indeed, Bob likes apples. + + =====End of relevant messages from memory source 1====== + + This is the end of the retrieved message dialogues. + + +### Successive calls to `get()` + +Successive calls of `get()` will simply replace the loaded `secondary` memory messages in the system prompt. + + +```python +msgs = composable_memory.get("What does Alice like?") +msgs +``` + + + + + [ChatMessage(role=, content='You are a REALLY helpful assistant.\n\nBelow are a set of relevant dialogues retrieved from potentially several memory sources:\n\n=====Relevant messages from memory source 1=====\n\n\tUSER: Alice likes apples.\n\n=====End of relevant messages from memory source 1======\n\nThis is the end of the retrieved message dialogues.', additional_kwargs={}), + ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + + +```python +# see the memory injected into the system message of the primary memory +print(msgs[0]) +``` + + system: You are a REALLY helpful assistant. + + Below are a set of relevant dialogues retrieved from potentially several memory sources: + + =====Relevant messages from memory source 1===== + + USER: Alice likes apples. + + =====End of relevant messages from memory source 1====== + + This is the end of the retrieved message dialogues. + + +### What if `get()` retrieves `secondary` messages that already exist in `primary` memory? + +In the event that messages retrieved from `secondary` memory already exist in `primary` memory, then these rather redundant secondary messages will not get added to the system message. In the below example, the message "Jerry likes juice." was `put` into all memory sources, so the system message is not altered. + + +```python +msgs = composable_memory.get("What does Jerry like?") +msgs +``` + + + + + [ChatMessage(role=, content='You are a REALLY helpful assistant.', additional_kwargs={}), + ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + +### How to `reset` memory + +Similar to the other methods `put()` and `get()`, calling `reset()` will execute `reset()` on both the `primary` and `secondary` memory sources. If you want to reset only the `primary` then you should call the `reset()` method only from it. + +#### `reset()` only primary memory + + +```python +composable_memory.primary_memory.reset() +``` + + +```python +composable_memory.primary_memory.get() +``` + + + + + [] + + + + +```python +composable_memory.secondary_memory_sources[0].get("What does Alice like?") +``` + + + + + [ChatMessage(role=, content='Alice likes apples.', additional_kwargs={})] + + + +#### `reset()` all memory sources + + +```python +composable_memory.reset() +``` + + +```python +composable_memory.primary_memory.get() +``` + + + + + [] + + + + +```python +composable_memory.secondary_memory_sources[0].get("What does Alice like?") +``` + + + + + [] + + + +## Use `SimpleComposableMemory` With An Agent + +Here we will use a `SimpleComposableMemory` with an agent and demonstrate how a secondary, long-term memory source can be used to use messages from on agent conversation as part of another conversation with another agent session. + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.core.tools import FunctionTool +from llama_index.core.agent import FunctionCallingAgent + +import nest_asyncio + +nest_asyncio.apply() +``` + +### Define our memory modules + + +```python +vector_memory = VectorMemory.from_defaults( + vector_store=None, # leave as None to use default in-memory vector store + embed_model=OpenAIEmbedding(), + retriever_kwargs={"similarity_top_k": 2}, +) + +chat_memory_buffer = ChatMemoryBuffer.from_defaults() + +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=chat_memory_buffer, + secondary_memory_sources=[vector_memory], +) +``` + +### Define our Agent + + +```python +def multiply(a: int, b: int) -> int: + """Multiply two integers and returns the result integer""" + return a * b + + +def mystery(a: int, b: int) -> int: + """Mystery function on two numbers""" + return a**2 - b**2 + + +multiply_tool = FunctionTool.from_defaults(fn=multiply) +mystery_tool = FunctionTool.from_defaults(fn=mystery) +``` + + +```python +llm = OpenAI(model="gpt-3.5-turbo-0613") +agent = FunctionCallingAgent.from_tools( + [multiply_tool, mystery_tool], + llm=llm, + memory=composable_memory, + verbose=True, +) +``` + +### Execute some function calls + +When `.chat()` is invoked, the messages are put into the composable memory, which we understand from the previous section implies that all the messages are put in both `primary` and `secondary` sources. + + +```python +response = agent.chat("What is the mystery function on 5 and 6?") +``` + + Added user message to memory: What is the mystery function on 5 and 6? + === Calling Function === + Calling function: mystery with args: {"a": 5, "b": 6} + === Function Output === + -11 + === LLM Response === + The mystery function on 5 and 6 returns -11. + + + +```python +response = agent.chat("What happens if you multiply 2 and 3?") +``` + + Added user message to memory: What happens if you multiply 2 and 3? + === Calling Function === + Calling function: multiply with args: {"a": 2, "b": 3} + === Function Output === + 6 + === LLM Response === + If you multiply 2 and 3, the result is 6. + + +### New Agent Sessions + +Now that we've added the messages to our `vector_memory`, we can see the effect of having this memory be used with a new agent session versus when it is used. Specifically, we ask the new agents to "recall" the outputs of the function calls, rather than re-computing. + +#### An Agent without our past memory + + +```python +llm = OpenAI(model="gpt-3.5-turbo-0613") +agent_without_memory = FunctionCallingAgent.from_tools( + [multiply_tool, mystery_tool], llm=llm, verbose=True +) +``` + + +```python +response = agent_without_memory.chat( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." +) +``` + + Added user message to memory: What was the output of the mystery function on 5 and 6 again? Don't recompute. + === LLM Response === + I'm sorry, but I don't have access to the previous output of the mystery function on 5 and 6. + + +#### An Agent with our past memory + +We see that the agent without access to the our past memory cannot complete the task. With this next agent we will indeed pass in our previous long-term memory (i.e., `vector_memory`). Note that we even use a fresh `ChatMemoryBuffer` which means there is no `chat_history` with this agent. Nonetheless, it will be able to retrieve from our long-term memory to get the past dialogue it needs. + + +```python +llm = OpenAI(model="gpt-3.5-turbo-0613") + +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=ChatMemoryBuffer.from_defaults(), + secondary_memory_sources=[ + vector_memory.copy( + deep=True + ) # using a copy here for illustration purposes + # later will use original vector_memory again + ], +) + +agent_with_memory = FunctionCallingAgent.from_tools( + [multiply_tool, mystery_tool], + llm=llm, + memory=composable_memory, + verbose=True, +) +``` + + +```python +agent_with_memory.chat_history # an empty chat history +``` + + + + + [] + + + + +```python +response = agent_with_memory.chat( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." +) +``` + + Added user message to memory: What was the output of the mystery function on 5 and 6 again? Don't recompute. + === LLM Response === + The output of the mystery function on 5 and 6 is -11. + + + +```python +response = agent_with_memory.chat( + "What was the output of the multiply function on 2 and 3 again? Don't recompute." +) +``` + + Added user message to memory: What was the output of the multiply function on 2 and 3 again? Don't recompute. + === LLM Response === + The output of the multiply function on 2 and 3 is 6. + + + +```python +agent_with_memory.chat_history +``` + + + + + [ChatMessage(role=, content="What was the output of the mystery function on 5 and 6 again? Don't recompute.", additional_kwargs={}), + ChatMessage(role=, content='The output of the mystery function on 5 and 6 is -11.', additional_kwargs={}), + ChatMessage(role=, content="What was the output of the multiply function on 2 and 3 again? Don't recompute.", additional_kwargs={}), + ChatMessage(role=, content='The output of the multiply function on 2 and 3 is 6.', additional_kwargs={})] + + + +### What happens under the hood with `.chat(user_input)` + +Under the hood, `.chat(user_input)` call effectively will call the memory's `.get()` method with `user_input` as the argument. As we learned in the previous section, this will ultimately return a composition of the `primary` and all of the `secondary` memory sources. These composed messages are what is being passed to the LLM's chat API as the chat history. + + +```python +composable_memory = SimpleComposableMemory.from_defaults( + primary_memory=ChatMemoryBuffer.from_defaults(), + secondary_memory_sources=[ + vector_memory.copy( + deep=True + ) # copy for illustrative purposes to explain what + # happened under the hood from previous subsection + ], +) +agent_with_memory = agent_worker.as_agent(memory=composable_memory) +``` + + +```python +agent_with_memory.memory.get( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." +) +``` + + + + + [ChatMessage(role=, content='You are a helpful assistant.\n\nBelow are a set of relevant dialogues retrieved from potentially several memory sources:\n\n=====Relevant messages from memory source 1=====\n\n\tUSER: What is the mystery function on 5 and 6?\n\tASSISTANT: None\n\tTOOL: -11\n\tASSISTANT: The mystery function on 5 and 6 returns -11.\n\n=====End of relevant messages from memory source 1======\n\nThis is the end of the retrieved message dialogues.', additional_kwargs={})] + + + + +```python +print( + agent_with_memory.memory.get( + "What was the output of the mystery function on 5 and 6 again? Don't recompute." + )[0] +) +``` + + system: You are a helpful assistant. + + Below are a set of relevant dialogues retrieved from potentially several memory sources: + + =====Relevant messages from memory source 1===== + + USER: What is the mystery function on 5 and 6? + ASSISTANT: None + TOOL: -11 + ASSISTANT: The mystery function on 5 and 6 returns -11. + + =====End of relevant messages from memory source 1====== + + This is the end of the retrieved message dialogues. + diff --git a/markdowns/Agent/Memory/summary_memory_buffer.md b/markdowns/Agent/Memory/summary_memory_buffer.md new file mode 100644 index 0000000..e43fd62 --- /dev/null +++ b/markdowns/Agent/Memory/summary_memory_buffer.md @@ -0,0 +1,110 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/summary_memory_buffer.ipynb +toc: True +title: "Chat Summary Memory Buffer" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +The `ChatSummaryMemoryBuffer` is a memory buffer that stores the last X messages that fit into a token limit. It also summarizes the chat history into a single message. + + + +```python +%pip install llama-index-core +``` + +## Setup + + +```python +from llama_index.core.memory import ChatSummaryMemoryBuffer + +memory = ChatSummaryMemoryBuffer.from_defaults( + token_limit=40000, + # optional set the summary prompt, here's the default: + # summarize_prompt=( + # "The following is a conversation between the user and assistant. " + # "Write a concise summary about the contents of this conversation." + # ) +) +``` + +## Using Standalone + + +```python +from llama_index.core.llms import ChatMessage + +chat_history = [ + ChatMessage(role="user", content="Hello, how are you?"), + ChatMessage(role="assistant", content="I'm doing well, thank you!"), +] + +# put a list of messages +memory.put_messages(chat_history) + +# put one message at a time +# memory.put_message(chat_history[0]) +``` + + +```python +# Get the last X messages that fit into a token limit +history = memory.get() +``` + + +```python +# Get all messages +all_history = memory.get_all() +``` + + +```python +# clear the memory +memory.reset() +``` + +## Using with Agents + +You can set the memory in any agent in the `.run()` method. + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-proj-..." +``` + + +```python +from llama_index.core.agent.workflow import ReActAgent, FunctionAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + + +memory = ChatMemoryBuffer.from_defaults(token_limit=40000) + +agent = FunctionAgent(tools=[], llm=OpenAI(model="gpt-4o-mini")) + +# context to hold the chat history/state +ctx = Context(agent) +``` + + +```python +resp = await agent.run("Hello, how are you?", ctx=ctx, memory=memory) +``` + + +```python +print(memory.get_all()) +``` + + [ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text='Hello, how are you?')]), ChatMessage(role=, additional_kwargs={}, blocks=[TextBlock(block_type='text', text="Hello! I'm just a program, so I don't have feelings, but I'm here and ready to help you. How can I assist you today?")])] + diff --git a/markdowns/Agent/Memory/vector_memory.md b/markdowns/Agent/Memory/vector_memory.md new file mode 100644 index 0000000..363001e --- /dev/null +++ b/markdowns/Agent/Memory/vector_memory.md @@ -0,0 +1,100 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/memory/vector_memory.ipynb +toc: True +title: "Vector Memory" +featured: False +experimental: False +tags: ['Agent', 'Memory'] +language: py +--- +**NOTE:** This example of memory is deprecated in favor of the newer and more flexible `Memory` class. See the [latest docs](https://docs.llamaindex.ai/en/stable/module_guides/deploying/agents/memory/). + +The vector memory module uses vector search (backed by a vector db) to retrieve relevant conversation items given a user input. + +This notebook shows you how to use the `VectorMemory` class. We show you how to use its individual functions. A typical usecase for vector memory is as a long-term memory storage of chat messages. You can + +![VectorMemoryIllustration](https://d3ddy8balm3goa.cloudfront.net/llamaindex/vector-memory.excalidraw.svg) + +### Initialize and Experiment with Memory Module + +Here we initialize a raw memory module and demonstrate its functions - to put and retrieve from ChatMessage objects. + +- Note that `retriever_kwargs` is the same args you'd specify on the `VectorIndexRetriever` or from `index.as_retriever(..)`. + + +```python +from llama_index.core.memory import VectorMemory +from llama_index.embeddings.openai import OpenAIEmbedding + + +vector_memory = VectorMemory.from_defaults( + vector_store=None, # leave as None to use default in-memory vector store + embed_model=OpenAIEmbedding(), + retriever_kwargs={"similarity_top_k": 1}, +) +``` + + +```python +from llama_index.core.llms import ChatMessage + +msgs = [ + ChatMessage.from_str("Jerry likes juice.", "user"), + ChatMessage.from_str("Bob likes burgers.", "user"), + ChatMessage.from_str("Alice likes apples.", "user"), +] +``` + + +```python +# load into memory +for m in msgs: + vector_memory.put(m) +``` + + +```python +# retrieve from memory +msgs = vector_memory.get("What does Jerry like?") +msgs +``` + + + + + [ChatMessage(role=, content='Jerry likes juice.', additional_kwargs={})] + + + + +```python +vector_memory.reset() +``` + +Now let's try resetting and trying again. This time, we'll add an assistant message. Note that user/assistant messages are bundled by default. + + +```python +msgs = [ + ChatMessage.from_str("Jerry likes burgers.", "user"), + ChatMessage.from_str("Bob likes apples.", "user"), + ChatMessage.from_str("Indeed, Bob likes apples.", "assistant"), + ChatMessage.from_str("Alice likes juice.", "user"), +] +vector_memory.set(msgs) +``` + + +```python +msgs = vector_memory.get("What does Bob like?") +msgs +``` + + + + + [ChatMessage(role=, content='Bob likes apples.', additional_kwargs={}), + ChatMessage(role=, content='Indeed, Bob likes apples.', additional_kwargs={})] + + diff --git a/markdowns/Agent/agent_builder.md b/markdowns/Agent/agent_builder.md new file mode 100644 index 0000000..2648692 --- /dev/null +++ b/markdowns/Agent/agent_builder.md @@ -0,0 +1,271 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_builder.ipynb +toc: True +title: "GPT Builder Demo" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +Open In Colab + +Inspired by GPTs interface, presented at OpenAI Dev Day 2023. Construct an agent with natural language. + +Here you can build your own agent...with another agent! + + +```python +%pip install llama-index-embeddings-openai +%pip install llama-index-llms-openai +%pip install llama-index-readers-file +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.llms.openai import OpenAI +from llama_index.core import Settings + +llm = OpenAI(model="gpt-4o") +Settings.llm = llm +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + +## Define Candidate Tools + +We also define a tool retriever to retrieve candidate tools. + +In this setting we define tools as different Wikipedia pages. + + +```python +from llama_index.core import SimpleDirectoryReader +``` + + +```python +wiki_titles = ["Toronto", "Seattle", "Chicago", "Boston", "Houston"] +``` + + +```python +from pathlib import Path + +import requests + +for title in wiki_titles: + response = requests.get( + "https://en.wikipedia.org/w/api.php", + params={ + "action": "query", + "format": "json", + "titles": title, + "prop": "extracts", + # 'exintro': True, + "explaintext": True, + }, + ).json() + page = next(iter(response["query"]["pages"].values())) + wiki_text = page["extract"] + + data_path = Path("data") + if not data_path.exists(): + Path.mkdir(data_path) + + with open(data_path / f"{title}.txt", "w") as fp: + fp.write(wiki_text) +``` + + +```python +# Load all wiki documents +city_docs = {} +for wiki_title in wiki_titles: + city_docs[wiki_title] = SimpleDirectoryReader( + input_files=[f"data/{wiki_title}.txt"] + ).load_data() +``` + +### Build Query Tool for Each Document + + +```python +from llama_index.core import VectorStoreIndex +from llama_index.core.tools import QueryEngineTool +from llama_index.core import VectorStoreIndex + +# Build tool dictionary +tool_dict = {} + +for wiki_title in wiki_titles: + # build vector index + vector_index = VectorStoreIndex.from_documents( + city_docs[wiki_title], + ) + # define query engines + vector_query_engine = vector_index.as_query_engine(llm=llm) + + # define tools + vector_tool = QueryEngineTool.from_defaults( + query_engine=vector_query_engine, + name=wiki_title, + description=("Useful for questions related to" f" {wiki_title}"), + ) + tool_dict[wiki_title] = vector_tool +``` + +### Define Tool Retriever + + +```python +# define an "object" index and retriever over these tools +from llama_index.core import VectorStoreIndex +from llama_index.core.objects import ObjectIndex + +tool_index = ObjectIndex.from_objects( + list(tool_dict.values()), + index_cls=VectorStoreIndex, +) +tool_retriever = tool_index.as_retriever(similarity_top_k=1) +``` + +### Load Data + +Here we load wikipedia pages from different cities. + +## Define Meta-Tools for GPT Builder + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.core.llms import ChatMessage +from llama_index.core import ChatPromptTemplate +from typing import List + +GEN_SYS_PROMPT_STR = """\ +Task information is given below. + +Given the task, please generate a system prompt for an OpenAI-powered bot to solve this task: +{task} \ +""" + +gen_sys_prompt_messages = [ + ChatMessage( + role="system", + content="You are helping to build a system prompt for another bot.", + ), + ChatMessage(role="user", content=GEN_SYS_PROMPT_STR), +] + +GEN_SYS_PROMPT_TMPL = ChatPromptTemplate(gen_sys_prompt_messages) + + +agent_cache = {} + + +async def create_system_prompt(task: str): + """Create system prompt for another agent given an input task.""" + llm = OpenAI(llm="gpt-4") + fmt_messages = GEN_SYS_PROMPT_TMPL.format_messages(task=task) + response = await llm.achat(fmt_messages) + return response.message.content + + +async def get_tools(task: str): + """Get the set of relevant tools to use given an input task.""" + subset_tools = await tool_retriever.aretrieve(task) + return [t.metadata.name for t in subset_tools] + + +def create_agent(system_prompt: str, tool_names: List[str]): + """Create an agent given a system prompt and an input set of tools.""" + llm = OpenAI(model="gpt-4o") + try: + # get the list of tools + input_tools = [tool_dict[tn] for tn in tool_names] + + agent = FunctionAgent( + tools=input_tools, llm=llm, system_prompt=system_prompt + ) + agent_cache["agent"] = agent + return_msg = "Agent created successfully." + except Exception as e: + return_msg = f"An error occurred when building an agent. Here is the error: {repr(e)}" + return return_msg +``` + + +```python +from llama_index.core.tools import FunctionTool + +system_prompt_tool = FunctionTool.from_defaults(fn=create_system_prompt) +get_tools_tool = FunctionTool.from_defaults(fn=get_tools) +create_agent_tool = FunctionTool.from_defaults(fn=create_agent) +``` + + +```python +GPT_BUILDER_SYS_STR = """\ +You are helping to construct an agent given a user-specified task. You should generally use the tools in this order to build the agent. + +1) Create system prompt tool: to create the system prompt for the agent. +2) Get tools tool: to fetch the candidate set of tools to use. +3) Create agent tool: to create the final agent. +""" + +prefix_msgs = [ChatMessage(role="system", content=GPT_BUILDER_SYS_STR)] + + +builder_agent = FunctionAgent( + tools=[system_prompt_tool, get_tools_tool, create_agent_tool], + prefix_messages=prefix_msgs, + llm=OpenAI(model="gpt-4o"), + verbose=True, +) +``` + + +```python +from llama_index.core.agent.workflow import ToolCallResult + +handler = builder_agent.run("Build an agent that can tell me about Toronto.") +async for event in handler.stream_events(): + if isinstance(event, ToolCallResult): + print( + f"Called tool {event.tool_name} with input {event.tool_kwargs}\nGot output: {event.tool_output}" + ) + +result = await handler +print(f"Result: {result}") +``` + + Called tool create_system_prompt with input {'task': 'Tell me about Toronto'} + Got output: "Generate a brief summary about Toronto, including its history, culture, landmarks, and notable features." + Called tool get_tools with input {'task': 'Tell me about Toronto'} + Got output: ['Toronto'] + Called tool create_agent with input {'system_prompt': 'Generate a brief summary about Toronto, including its history, culture, landmarks, and notable features.', 'tool_names': ['Toronto']} + Got output: Agent created successfully. + Result: I have created an agent that can provide information about Toronto, including its history, culture, landmarks, and notable features. You can now ask the agent any questions you have about Toronto! + + + +```python +city_agent = agent_cache["agent"] +``` + + +```python +response = await city_agent.run("Tell me about the parks in Toronto") +print(str(response)) +``` + + Toronto is home to a diverse array of parks and public spaces, offering both urban and natural environments. Key downtown parks include Allan Gardens, Christie Pits, and Trinity Bellwoods Park. For waterfront views, Tommy Thompson Park and the Toronto Islands are popular destinations. In the city's outer areas, large parks like High Park, Humber Bay Park, and Morningside Park provide expansive green spaces. Additionally, parts of Rouge National Urban Park, the largest urban park in North America, are located within Toronto. The city also features notable squares such as Nathan Phillips Square, Yonge–Dundas Square, and Harbourfront Square. Approximately 12.5% of Toronto's land is dedicated to parkland, offering facilities for various activities, including winter sports like ice skating and skiing. + diff --git a/markdowns/Agent/agent_workflow_basic.md b/markdowns/Agent/agent_workflow_basic.md new file mode 100644 index 0000000..407b927 --- /dev/null +++ b/markdowns/Agent/agent_workflow_basic.md @@ -0,0 +1,351 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_basic.ipynb +toc: True +title: "FunctionAgent / AgentWorkflow Basic Introduction" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +The `AgentWorkflow` is an orchestrator for running a system of one or more agents. In this example, we'll create a simple workflow with a single `FunctionAgent`, and use that to cover the basic functionality. + + +```python +%pip install llama-index +``` + +## Setup + +In this example, we will use `OpenAI` as our LLM. For all LLMs, check out the [examples documentation](https://docs.llamaindex.ai/en/stable/examples/llm/openai/) or [LlamaHub](https://llamahub.ai/?tab=llms) for a list of all supported LLMs and how to install/use them. + + +```python +from llama_index.llms.openai import OpenAI + +llm = OpenAI(model="gpt-4o-mini", api_key="sk-...") +``` + +To make our agent more useful, we can give it tools/actions to use. In this case, we'll use Tavily to implement a tool that can search the web for information. You can get a free API key from [Tavily](https://tavily.com/). + + +```python +%pip install tavily-python +``` + +When creating a tool, its very important to: +- give the tool a proper name and docstring/description. The LLM uses this to understand what the tool does. +- annotate the types. This helps the LLM understand the expected input and output types. +- use async when possible, since this will make the workflow more efficient. + + +```python +from tavily import AsyncTavilyClient + + +async def search_web(query: str) -> str: + """Useful for using the web to answer questions.""" + client = AsyncTavilyClient(api_key="tvly-...") + return str(await client.search(query)) +``` + +With the tool and and LLM defined, we can create an `AgentWorkflow` that uses the tool. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[search_web], + llm=llm, + system_prompt="You are a helpful assistant that can search the web for information.", +) +``` + +## Running the Agent + +Now that our agent is created, we can run it! + + +```python +response = await agent.run(user_msg="What is the weather in San Francisco?") +print(str(response)) +``` + + The current weather in San Francisco is as follows: + + - **Temperature**: 16.1°C (61°F) + - **Condition**: Partly cloudy + - **Wind**: 13.6 mph (22.0 kph) from the west + - **Humidity**: 64% + - **Visibility**: 16 km (9 miles) + - **Pressure**: 1017 mb (30.04 in) + + For more details, you can check the full report [here](https://www.weatherapi.com/). + + +The above is the equivalent of the following of using `AgentWorkflow` with a single `FunctionAgent`: + + +```python +from llama_index.core.agent.workflow import AgentWorkflow + +workflow = AgentWorkflow(agents=[agent]) + +response = await workflow.run(user_msg="What is the weather in San Francisco?") +``` + +If you were creating a workflow with multiple agents, you can pass in a list of agents to the `AgentWorkflow` constructor. Learn more in our [multi-agent workflow example](https://docs.llamaindex.ai/en/stable/understanding/agent/multi_agent/). + +## Maintaining State + +By default, the `FunctionAgent` will maintain stateless between runs. This means that the agent will not have any memory of previous runs. + +To maintain state, we need to keep track of the previous state. Since the `FunctionAgent` is running in a `Workflow`, the state is stored in the `Context`. This can be passed between runs to maintain state and history. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) +``` + + +```python +response = await agent.run( + user_msg="My name is Logan, nice to meet you!", ctx=ctx +) +print(str(response)) +``` + + Nice to meet you, Logan! How can I assist you today? + + + +```python +response = await agent.run(user_msg="What is my name?", ctx=ctx) +print(str(response)) +``` + + Your name is Logan. + + +The context is serializable, so it can be saved to a database, file, etc. and loaded back in later. + +The `JsonSerializer` is a simple serializer that uses `json.dumps` and `json.loads` to serialize and deserialize the context. + +The `JsonPickleSerializer` is a serializer that uses `pickle` to serialize and deserialize the context. If you have objects in your context that are not serializable, you can use this serializer. + + +```python +from llama_index.core.workflow import JsonPickleSerializer, JsonSerializer + +ctx_dict = ctx.to_dict(serializer=JsonSerializer()) + +restored_ctx = Context.from_dict(agent, ctx_dict, serializer=JsonSerializer()) +``` + + +```python +response = await agent.run( + user_msg="Do you still remember my name?", ctx=restored_ctx +) +print(str(response)) +``` + + Yes, I remember your name is Logan. + + +## Streaming + +The `AgentWorkflow`/`FunctionAgent` also supports streaming. Since the `AgentWorkflow` is a `Workflow`, it can be streamed like any other `Workflow`. This works by using the handler that is returned from the workflow. There are a few key events that are streamed, feel free to explore below. + +If you only want to stream the LLM output, you can use the `AgentStream` events. + + +```python +from llama_index.core.agent.workflow import ( + AgentInput, + AgentOutput, + ToolCall, + ToolCallResult, + AgentStream, +) + +handler = agent.run(user_msg="What is the weather in Saskatoon?") + +async for event in handler.stream_events(): + if isinstance(event, AgentStream): + print(event.delta, end="", flush=True) + # print(event.response) # the current full response + # print(event.raw) # the raw llm api response + # print(event.current_agent_name) # the current agent name + # elif isinstance(event, AgentInput): + # print(event.input) # the current input messages + # print(event.current_agent_name) # the current agent name + # elif isinstance(event, AgentOutput): + # print(event.response) # the current full response + # print(event.tool_calls) # the selected tool calls, if any + # print(event.raw) # the raw llm api response + # elif isinstance(event, ToolCallResult): + # print(event.tool_name) # the tool name + # print(event.tool_kwargs) # the tool kwargs + # print(event.tool_output) # the tool output + # elif isinstance(event, ToolCall): + # print(event.tool_name) # the tool name + # print(event.tool_kwargs) # the tool kwargs +``` + + The current weather in Saskatoon is as follows: + + - **Temperature**: 22.2°C (72°F) + - **Condition**: Overcast + - **Humidity**: 25% + - **Wind Speed**: 6.0 mph (9.7 kph) from the northwest + - **Visibility**: 4.8 km + - **Pressure**: 1018 mb + + For more details, you can check the full report [here](https://www.weatherapi.com/). + +## Tools and State + +Tools can also be defined that have access to the workflow context. This means you can set and retrieve variables from the context and use them in the tool or between tools. + +**Note:** The `Context` parameter should be the first parameter of the tool. + + +```python +from llama_index.core.workflow import Context + + +async def set_name(ctx: Context, name: str) -> str: + state = await ctx.store.get("state") + state["name"] = name + await ctx.store.set("state", state) + return f"Name set to {name}" + + +agent = FunctionAgent( + tools=[set_name], + llm=llm, + system_prompt="You are a helpful assistant that can set a name.", + initial_state={"name": "unset"}, +) + +ctx = Context(agent) + +response = await agent.run(user_msg="My name is Logan", ctx=ctx) +print(str(response)) + +state = await ctx.store.get("state") +print(state["name"]) +``` + + Your name has been set to Logan. + Logan + + +## Human in the Loop + +Tools can also be defined that involve a human in the loop. This is useful for tasks that require human input, such as confirming a tool call or providing feedback. + +Using workflow events, we can emit events that require a response from the user. Here, we use the built-in `InputRequiredEvent` and `HumanResponseEvent` to handle the human in the loop, but you can also define your own events. + +`wait_for_event` will emit the `waiter_event` and wait until it sees the `HumanResponseEvent` with the specified `requirements`. The `waiter_id` is used to ensure that we only send one `waiter_event` for each `waiter_id`. + + +```python +from llama_index.core.workflow import ( + Context, + InputRequiredEvent, + HumanResponseEvent, +) + + +async def dangerous_task(ctx: Context) -> str: + """A dangerous task that requires human confirmation.""" + + question = "Are you sure you want to proceed?" + response = await ctx.wait_for_event( + HumanResponseEvent, + waiter_id=question, + waiter_event=InputRequiredEvent( + prefix=question, + user_name="Logan", + ), + requirements={"user_name": "Logan"}, + ) + if response.response == "yes": + return "Dangerous task completed successfully." + else: + return "Dangerous task aborted." + + +agent = FunctionAgent( + tools=[dangerous_task], + llm=llm, + system_prompt="You are a helpful assistant that can perform dangerous tasks.", +) +``` + + +```python +handler = agent.run(user_msg="I want to proceed with the dangerous task.") + +async for event in handler.stream_events(): + if isinstance(event, InputRequiredEvent): + response = input(event.prefix).strip().lower() + handler.ctx.send_event( + HumanResponseEvent( + response=response, + user_name=event.user_name, + ) + ) + +response = await handler +print(str(response)) +``` + + The dangerous task has been completed successfully. If you need anything else, feel free to ask! + + +In production scenarios, you might handle human-in-the-loop over a websocket or multiple API requests. + +As mentioned before, the `Context` object is serializable, and this means we can also save the workflow mid-run and restore it later. + +**NOTE:** Any functions/steps that were in-progress will start from the beginning when the workflow is restored. + + +```python +from llama_index.core.workflow import JsonSerializer + +handler = agent.run(user_msg="I want to proceed with the dangerous task.") + +input_ev = None +async for event in handler.stream_events(): + if isinstance(event, InputRequiredEvent): + input_ev = event + break + +# save the context somewhere for later +ctx_dict = handler.ctx.to_dict(serializer=JsonSerializer()) + +# get the response from the user +response_str = input(input_ev.prefix).strip().lower() + +# restore the workflow +restored_ctx = Context.from_dict(agent, ctx_dict, serializer=JsonSerializer()) + +handler = agent.run(ctx=restored_ctx) +handler.ctx.send_event( + HumanResponseEvent( + response=response_str, + user_name=input_ev.user_name, + ) +) +response = await handler +print(str(response)) +``` + + The dangerous task has been completed successfully. If you need anything else, feel free to ask! + diff --git a/markdowns/Agent/agent_workflow_multi.md b/markdowns/Agent/agent_workflow_multi.md new file mode 100644 index 0000000..33a3c51 --- /dev/null +++ b/markdowns/Agent/agent_workflow_multi.md @@ -0,0 +1,300 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_multi.ipynb +toc: True +title: "Multi-Agent Report Generation with AgentWorkflow" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +Open In Colab + +In this notebook, we will explore how to use the `AgentWorkflow` class to create multi-agent systems. Specifically, we will create a system that can generate a report on a given topic. + +This notebook will assume that you have already either read the [basic agent workflow notebook](https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic) or the [agent workflow documentation](https://docs.llamaindex.ai/en/stable/understanding/agent/). + +## Setup + +In this example, we will use `OpenAI` as our LLM. For all LLMs, check out the [examples documentation](https://docs.llamaindex.ai/en/stable/examples/llm/openai/) or [LlamaHub](https://llamahub.ai/?tab=llms) for a list of all supported LLMs and how to install/use them. + +If we wanted, each agent could have a different LLM, but for this example, we will use the same LLM for all agents. + + +```python +%pip install llama-index +``` + + +```python +from llama_index.llms.openai import OpenAI + +llm = OpenAI(model="gpt-4o", api_key="sk-...") +``` + +## System Design + +Our system will have three agents: + +1. A `ResearchAgent` that will search the web for information on the given topic. +2. A `WriteAgent` that will write the report using the information found by the `ResearchAgent`. +3. A `ReviewAgent` that will review the report and provide feedback. + +We will use the `AgentWorkflow` class to create a multi-agent system that will execute these agents in order. + +While there are many ways to implement this system, in this case, we will use a few tools to help with the research and writing processes. + +1. A `web_search` tool to search the web for information on the given topic. +2. A `record_notes` tool to record notes on the given topic. +3. A `write_report` tool to write the report using the information found by the `ResearchAgent`. +4. A `review_report` tool to review the report and provide feedback. + +Utilizing the `Context` class, we can pass state between agents, and each agent will have access to the current state of the system. + + + +```python +%pip install tavily-python +``` + + +```python +from tavily import AsyncTavilyClient +from llama_index.core.workflow import Context + + +async def search_web(query: str) -> str: + """Useful for using the web to answer questions.""" + client = AsyncTavilyClient(api_key="tvly-...") + return str(await client.search(query)) + + +async def record_notes(ctx: Context, notes: str, notes_title: str) -> str: + """Useful for recording notes on a given topic. Your input should be notes with a title to save the notes under.""" + current_state = await ctx.store.get("state") + if "research_notes" not in current_state: + current_state["research_notes"] = {} + current_state["research_notes"][notes_title] = notes + await ctx.store.set("state", current_state) + return "Notes recorded." + + +async def write_report(ctx: Context, report_content: str) -> str: + """Useful for writing a report on a given topic. Your input should be a markdown formatted report.""" + current_state = await ctx.store.get("state") + current_state["report_content"] = report_content + await ctx.store.set("state", current_state) + return "Report written." + + +async def review_report(ctx: Context, review: str) -> str: + """Useful for reviewing a report and providing feedback. Your input should be a review of the report.""" + current_state = await ctx.store.get("state") + current_state["review"] = review + await ctx.store.set("state", current_state) + return "Report reviewed." +``` + +With our tools defined, we can now create our agents. + +If the LLM you are using supports tool calling, you can use the `FunctionAgent` class. Otherwise, you can use the `ReActAgent` class. + +Here, the name and description of each agent is used so that the system knows what each agent is responsible for and when to hand off control to the next agent. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent + +research_agent = FunctionAgent( + name="ResearchAgent", + description="Useful for searching the web for information on a given topic and recording notes on the topic.", + system_prompt=( + "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. " + "Once notes are recorded and you are satisfied, you should hand off control to the WriteAgent to write a report on the topic. " + "You should have at least some notes on a topic before handing off control to the WriteAgent." + ), + llm=llm, + tools=[search_web, record_notes], + can_handoff_to=["WriteAgent"], +) + +write_agent = FunctionAgent( + name="WriteAgent", + description="Useful for writing a report on a given topic.", + system_prompt=( + "You are the WriteAgent that can write a report on a given topic. " + "Your report should be in a markdown format. The content should be grounded in the research notes. " + "Once the report is written, you should get feedback at least once from the ReviewAgent." + ), + llm=llm, + tools=[write_report], + can_handoff_to=["ReviewAgent", "ResearchAgent"], +) + +review_agent = FunctionAgent( + name="ReviewAgent", + description="Useful for reviewing a report and providing feedback.", + system_prompt=( + "You are the ReviewAgent that can review the write report and provide feedback. " + "Your review should either approve the current report or request changes for the WriteAgent to implement. " + "If you have feedback that requires changes, you should hand off control to the WriteAgent to implement the changes after submitting the review." + ), + llm=llm, + tools=[review_report], + can_handoff_to=["WriteAgent"], +) +``` + +## Running the Workflow + +With our agents defined, we can create our `AgentWorkflow` and run it. + + +```python +from llama_index.core.agent.workflow import AgentWorkflow + +agent_workflow = AgentWorkflow( + agents=[research_agent, write_agent, review_agent], + root_agent=research_agent.name, + initial_state={ + "research_notes": {}, + "report_content": "Not written yet.", + "review": "Review required.", + }, +) +``` + +As the workflow is running, we will stream the events to get an idea of what is happening under the hood. + + +```python +from llama_index.core.agent.workflow import ( + AgentInput, + AgentOutput, + ToolCall, + ToolCallResult, + AgentStream, +) + +handler = agent_workflow.run( + user_msg=( + "Write me a report on the history of the internet. " + "Briefly describe the history of the internet, including the development of the internet, the development of the web, " + "and the development of the internet in the 21st century." + ) +) + +current_agent = None +current_tool_calls = "" +async for event in handler.stream_events(): + if ( + hasattr(event, "current_agent_name") + and event.current_agent_name != current_agent + ): + current_agent = event.current_agent_name + print(f"\n{'='*50}") + print(f"🤖 Agent: {current_agent}") + print(f"{'='*50}\n") + + # if isinstance(event, AgentStream): + # if event.delta: + # print(event.delta, end="", flush=True) + # elif isinstance(event, AgentInput): + # print("📥 Input:", event.input) + elif isinstance(event, AgentOutput): + if event.response.content: + print("📤 Output:", event.response.content) + if event.tool_calls: + print( + "🛠️ Planning to use tools:", + [call.tool_name for call in event.tool_calls], + ) + elif isinstance(event, ToolCallResult): + print(f"🔧 Tool Result ({event.tool_name}):") + print(f" Arguments: {event.tool_kwargs}") + print(f" Output: {event.tool_output}") + elif isinstance(event, ToolCall): + print(f"🔨 Calling Tool: {event.tool_name}") + print(f" With arguments: {event.tool_kwargs}") +``` + + + ================================================== + 🤖 Agent: ResearchAgent + ================================================== + + 🛠️ Planning to use tools: ['search_web'] + 🔨 Calling Tool: search_web + With arguments: {'query': 'history of the internet'} + 🔧 Tool Result (search_web): + Arguments: {'query': 'history of the internet'} + Output: {'query': 'history of the internet', 'follow_up_questions': None, 'answer': None, 'images': [], 'results': [{'title': 'Internet history timeline: ARPANET to the World Wide Web', 'url': 'https://www.livescience.com/20727-internet-history.html', 'content': 'Internet history timeline: ARPANET to the World Wide Web\nThe internet history timeline shows how today\'s vast network evolved from the initial concept\nIn internet history, credit for the initial concept that developed into the World Wide Web is typically given to Leonard Kleinrock. "\nAccording to the journal Management and Business Review (MBR), Kleinrock, along with other innovators such as J.C.R. Licklider, the first director of the Information Processing Technology Office (IPTO), provided the backbone for the ubiquitous stream of emails, media, Facebook postings and tweets that are now shared online every day.\n The precursor to the internet was jumpstarted in the early days of the history of computers , in 1969 with the U.S. Defense Department\'s Advanced Research Projects Agency Network (ARPANET), according to the journal American Scientist. The successful push to stop the bill, involving technology companies such as Google and nonprofit organizations including Wikipedia and the Electronic Frontier Foundation, is considered a victory for sites such as YouTube that depend on user-generated content, as well as "fair use" on the internet.\n Vinton Cerf and Bob Kahn (the duo said by many to be the Fathers of the Internet) publish "A Protocol for Packet Network Interconnection," which details the design of TCP.\n1976:', 'score': 0.81097376, 'raw_content': None}, {'title': 'A Brief History of the Internet - University System of Georgia', 'url': 'https://usg.edu/galileo/skills/unit07/internet07_02.phtml', 'content': 'The Internet started in the 1960s as a way for government researchers to share information. This eventually led to the formation of the ARPANET (Advanced Research Projects Agency Network), the network that ultimately evolved into what we now know as the Internet. In response to this, other networks were created to provide information sharing. ARPANET and the Defense Data Network officially changed to the TCP/IP standard on January 1, 1983, hence the birth of the Internet. (Business computers like the UNIVAC processed data more slowly than the IAS-type machines, but were designed for fast input and output.) The first few sales were to government agencies, the A.C. Nielsen Company, and the Prudential Insurance Company.', 'score': 0.8091708, 'raw_content': None}, {'title': 'Timeline - History of the Internet', 'url': 'https://historyoftheinternet.net/timeline/', 'content': "Learn how the internet evolved from SAGE and IBM's internal networks to ARPANET and the World Wide Web. Explore the commercial and government paths that led to the current internet format and protocols.", 'score': 0.7171114, 'raw_content': None}, {'title': 'Learn About Internet History | History of the Internet', 'url': 'https://internethistory.org/', 'content': 'Learn about the origins, evolution and impact of the internet through stories, materials and videos. Explore the first internet message, optical amplifier, wavelength division multiplexing and more.', 'score': 0.7040996, 'raw_content': None}, {'title': 'Brief History of the Internet', 'url': 'https://www.internetsociety.org/resources/doc/2017/brief-history-internet/', 'content': "Learn how the Internet evolved from the initial internetting concepts to a global network of networks that transformed the computer and communications world. Explore the key milestones, challenges, and opportunities of the Internet's development and future.", 'score': 0.6944897, 'raw_content': None}], 'response_time': 1.65} + 🛠️ Planning to use tools: ['record_notes'] + 🔨 Calling Tool: record_notes + With arguments: {'notes': "The internet's history began in the 1960s as a project for government researchers to share information, leading to the creation of ARPANET (Advanced Research Projects Agency Network). ARPANET was the first network to implement the TCP/IP protocol suite, which became the foundation for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the birth of the internet.\n\nThe World Wide Web was developed later, in 1989, by Tim Berners-Lee, a British scientist at CERN. The web was initially conceived as a way to facilitate information sharing among scientists and institutes around the world. Berners-Lee developed the first web browser and web server, and introduced the concept of hyperlinks, which allowed users to navigate between different documents on the web.\n\nIn the 21st century, the internet has evolved into a global network that connects billions of devices and users. It has transformed communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact.", 'notes_title': 'History of the Internet'} + 🔧 Tool Result (record_notes): + Arguments: {'notes': "The internet's history began in the 1960s as a project for government researchers to share information, leading to the creation of ARPANET (Advanced Research Projects Agency Network). ARPANET was the first network to implement the TCP/IP protocol suite, which became the foundation for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the birth of the internet.\n\nThe World Wide Web was developed later, in 1989, by Tim Berners-Lee, a British scientist at CERN. The web was initially conceived as a way to facilitate information sharing among scientists and institutes around the world. Berners-Lee developed the first web browser and web server, and introduced the concept of hyperlinks, which allowed users to navigate between different documents on the web.\n\nIn the 21st century, the internet has evolved into a global network that connects billions of devices and users. It has transformed communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact.", 'notes_title': 'History of the Internet'} + Output: Notes recorded. + 🛠️ Planning to use tools: ['handoff'] + 🔨 Calling Tool: handoff + With arguments: {'to_agent': 'WriteAgent', 'reason': 'I have gathered and recorded notes on the history of the internet, including its development, the creation of the web, and its evolution in the 21st century. The WriteAgent can now use these notes to write a comprehensive report.'} + 🔧 Tool Result (handoff): + Arguments: {'to_agent': 'WriteAgent', 'reason': 'I have gathered and recorded notes on the history of the internet, including its development, the creation of the web, and its evolution in the 21st century. The WriteAgent can now use these notes to write a comprehensive report.'} + Output: Handed off to WriteAgent because: I have gathered and recorded notes on the history of the internet, including its development, the creation of the web, and its evolution in the 21st century. The WriteAgent can now use these notes to write a comprehensive report. + + ================================================== + 🤖 Agent: WriteAgent + ================================================== + + 🛠️ Planning to use tools: ['write_report'] + 🔨 Calling Tool: write_report + With arguments: {'report_content': "# History of the Internet\n\nThe history of the internet is a fascinating journey from a government research project to a global network that has transformed the way we communicate, work, and live. This report provides a brief overview of the key milestones in the development of the internet, the World Wide Web, and the internet's evolution in the 21st century.\n\n## Development of the Internet\n\nThe origins of the internet date back to the 1960s, when it was conceived as a means for government researchers to share information. This led to the creation of ARPANET (Advanced Research Projects Agency Network), which was the first network to implement the TCP/IP protocol suite. TCP/IP became the foundational technology for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the official birth of the internet.\n\n## Development of the World Wide Web\n\nThe World Wide Web was developed in 1989 by Tim Berners-Lee, a British scientist working at CERN. The web was initially designed to facilitate information sharing among scientists and research institutes globally. Berners-Lee created the first web browser and web server, introducing the concept of hyperlinks, which allowed users to navigate between different documents on the web seamlessly.\n\n## The Internet in the 21st Century\n\nIn the 21st century, the internet has evolved into a vast global network connecting billions of devices and users. It has revolutionized communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact, making it an integral part of daily life for people around the world.\n\nThe internet continues to evolve, with ongoing advancements in technology and infrastructure shaping its future. As it grows, the internet remains a powerful tool for innovation, connectivity, and information sharing, influencing nearly every aspect of modern society."} + 🔧 Tool Result (write_report): + Arguments: {'report_content': "# History of the Internet\n\nThe history of the internet is a fascinating journey from a government research project to a global network that has transformed the way we communicate, work, and live. This report provides a brief overview of the key milestones in the development of the internet, the World Wide Web, and the internet's evolution in the 21st century.\n\n## Development of the Internet\n\nThe origins of the internet date back to the 1960s, when it was conceived as a means for government researchers to share information. This led to the creation of ARPANET (Advanced Research Projects Agency Network), which was the first network to implement the TCP/IP protocol suite. TCP/IP became the foundational technology for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the official birth of the internet.\n\n## Development of the World Wide Web\n\nThe World Wide Web was developed in 1989 by Tim Berners-Lee, a British scientist working at CERN. The web was initially designed to facilitate information sharing among scientists and research institutes globally. Berners-Lee created the first web browser and web server, introducing the concept of hyperlinks, which allowed users to navigate between different documents on the web seamlessly.\n\n## The Internet in the 21st Century\n\nIn the 21st century, the internet has evolved into a vast global network connecting billions of devices and users. It has revolutionized communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact, making it an integral part of daily life for people around the world.\n\nThe internet continues to evolve, with ongoing advancements in technology and infrastructure shaping its future. As it grows, the internet remains a powerful tool for innovation, connectivity, and information sharing, influencing nearly every aspect of modern society."} + Output: Report written. + 🛠️ Planning to use tools: ['handoff'] + 🔨 Calling Tool: handoff + With arguments: {'to_agent': 'ReviewAgent', 'reason': 'The report on the history of the internet has been written and needs to be reviewed for accuracy and completeness.'} + 🔧 Tool Result (handoff): + Arguments: {'to_agent': 'ReviewAgent', 'reason': 'The report on the history of the internet has been written and needs to be reviewed for accuracy and completeness.'} + Output: Handed off to ReviewAgent because: The report on the history of the internet has been written and needs to be reviewed for accuracy and completeness. + + ================================================== + 🤖 Agent: ReviewAgent + ================================================== + + 🛠️ Planning to use tools: ['review_report'] + 🔨 Calling Tool: review_report + With arguments: {'review': "The report on the history of the internet provides a concise and informative overview of the key developments in the internet's history. It effectively covers the origins of the internet with ARPANET, the creation of the World Wide Web by Tim Berners-Lee, and the evolution of the internet in the 21st century. The report is well-structured, with clear sections that make it easy to follow.\n\nThe content is accurate and aligns with the historical timeline of the internet's development. It highlights significant milestones such as the adoption of TCP/IP and the introduction of hyperlinks, which are crucial to understanding the internet's growth.\n\nOverall, the report meets the requirements and provides a comprehensive summary of the internet's history. It is approved for final submission."} + 🔧 Tool Result (review_report): + Arguments: {'review': "The report on the history of the internet provides a concise and informative overview of the key developments in the internet's history. It effectively covers the origins of the internet with ARPANET, the creation of the World Wide Web by Tim Berners-Lee, and the evolution of the internet in the 21st century. The report is well-structured, with clear sections that make it easy to follow.\n\nThe content is accurate and aligns with the historical timeline of the internet's development. It highlights significant milestones such as the adoption of TCP/IP and the introduction of hyperlinks, which are crucial to understanding the internet's growth.\n\nOverall, the report meets the requirements and provides a comprehensive summary of the internet's history. It is approved for final submission."} + Output: Report reviewed. + 📤 Output: The report on the history of the internet has been reviewed and approved. It provides a comprehensive and accurate overview of the internet's development, the creation of the World Wide Web, and its evolution in the 21st century. The report is well-structured and meets the requirements for final submission. + + +Now, we can retrieve the final report in the system for ourselves. + + +```python +state = await handler.ctx.store.get("state") +print(state["report_content"]) +``` + + # History of the Internet + + The history of the internet is a fascinating journey from a government research project to a global network that has transformed the way we communicate, work, and live. This report provides a brief overview of the key milestones in the development of the internet, the World Wide Web, and the internet's evolution in the 21st century. + + ## Development of the Internet + + The origins of the internet date back to the 1960s, when it was conceived as a means for government researchers to share information. This led to the creation of ARPANET (Advanced Research Projects Agency Network), which was the first network to implement the TCP/IP protocol suite. TCP/IP became the foundational technology for the modern internet. On January 1, 1983, ARPANET and the Defense Data Network officially adopted TCP/IP, marking the official birth of the internet. + + ## Development of the World Wide Web + + The World Wide Web was developed in 1989 by Tim Berners-Lee, a British scientist working at CERN. The web was initially designed to facilitate information sharing among scientists and research institutes globally. Berners-Lee created the first web browser and web server, introducing the concept of hyperlinks, which allowed users to navigate between different documents on the web seamlessly. + + ## The Internet in the 21st Century + + In the 21st century, the internet has evolved into a vast global network connecting billions of devices and users. It has revolutionized communication, commerce, entertainment, and education, among other fields. The development of broadband technology, mobile internet, and social media platforms has further accelerated the internet's growth and impact, making it an integral part of daily life for people around the world. + + The internet continues to evolve, with ongoing advancements in technology and infrastructure shaping its future. As it grows, the internet remains a powerful tool for innovation, connectivity, and information sharing, influencing nearly every aspect of modern society. + diff --git a/markdowns/Agent/agent_workflow_research_assistant.md b/markdowns/Agent/agent_workflow_research_assistant.md index 3bcb452..cc3546a 100644 --- a/markdowns/Agent/agent_workflow_research_assistant.md +++ b/markdowns/Agent/agent_workflow_research_assistant.md @@ -1,11 +1,12 @@ --- layout: recipe -colab: https://colab.research.google.com/github/TuanaCelik/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_research_assistant.ipynb +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agent_workflow_research_assistant.ipynb toc: True title: "Agent Workflow + Research Assistant using AgentQL" -featured: False +featured: True experimental: True tags: ['Agent', 'Websearch', 'Integrations'] +language: py --- Open In Colab diff --git a/markdowns/Agent/agents_as_tools.md b/markdowns/Agent/agents_as_tools.md new file mode 100644 index 0000000..5199a00 --- /dev/null +++ b/markdowns/Agent/agents_as_tools.md @@ -0,0 +1,467 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/agents_as_tools.ipynb +toc: True +title: "Multi-Agent Report Generation using Agents as Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +Open In Colab + +In this notebook, we will explore how to create a multi-agent system that uses a top-level agent to orchestrate a group of agents as tools. Specifically, we will create a system that can research, write, and review a report on a given topic. + +This notebook will assume that you have already either read the [basic agent workflow notebook](https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic) or the [general agent documentation](https://docs.llamaindex.ai/en/stable/understanding/agent/). + +## Setup + +In this example, we will use `OpenAI` as our LLM. For all LLMs, check out the [examples documentation](https://docs.llamaindex.ai/en/stable/examples/llm/openai/) or [LlamaHub](https://llamahub.ai/?tab=llms) for a list of all supported LLMs and how to install/use them. + +If we wanted, each agent could have a different LLM, but for this example, we will use the same LLM for all agents. + + +```python +%pip install llama-index +``` + + +```python +from llama_index.llms.openai import OpenAI + +sub_agent_llm = OpenAI(model="gpt-4.1-mini", api_key="sk-...") +orchestrator_llm = OpenAI(model="o3-mini", api_key="sk-...") +``` + +## System Design + +Our system will have three agents: + +1. A `ResearchAgent` that will search the web for information on the given topic. +2. A `WriteAgent` that will write the report using the information found by the `ResearchAgent`. +3. A `ReviewAgent` that will review the report and provide feedback. + +We will then use a top-level agent to orchestrate the other agents to write our report. + +While there are many ways to implement this system, in this case, we will use a single `web_search` tool to search the web for information on the given topic. + + + +```python +%pip install tavily-python +``` + + +```python +from tavily import AsyncTavilyClient + + +async def search_web(query: str) -> str: + """Useful for using the web to answer questions.""" + client = AsyncTavilyClient(api_key="tvly-...") + return str(await client.search(query)) +``` + +With our tool defined, we can now create our sub-agents. + +If the LLM you are using supports tool calling, you can use the `FunctionAgent` class. Otherwise, you can use the `ReActAgent` class. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent + +research_agent = FunctionAgent( + system_prompt=( + "You are the ResearchAgent that can search the web for information on a given topic and record notes on the topic. " + "You should output notes on the topic in a structured format." + ), + llm=sub_agent_llm, + tools=[search_web], +) + +write_agent = FunctionAgent( + system_prompt=( + "You are the WriteAgent that can write a report on a given topic. " + "Your report should be in a markdown format. The content should be grounded in the research notes. " + "Return your markdown report surrounded by ... tags." + ), + llm=sub_agent_llm, + tools=[], +) + +review_agent = FunctionAgent( + system_prompt=( + "You are the ReviewAgent that can review the write report and provide feedback. " + "Your review should either approve the current report or request changes to be implemented." + ), + llm=sub_agent_llm, + tools=[], +) +``` + +With our sub-agents defined, we can then convert them into tools that can be used by the top-level agent. + + +```python +import re +from llama_index.core.workflow import Context + + +async def call_research_agent(ctx: Context, prompt: str) -> str: + """Useful for recording research notes based on a specific prompt.""" + result = await research_agent.run( + user_msg=f"Write some notes about the following: {prompt}" + ) + + state = await ctx.store.get("state") + state["research_notes"].append(str(result)) + await ctx.store.set("state", state) + + return str(result) + + +async def call_write_agent(ctx: Context) -> str: + """Useful for writing a report based on the research notes or revising the report based on feedback.""" + state = await ctx.store.get("state") + notes = state.get("research_notes", None) + if not notes: + return "No research notes to write from." + + user_msg = f"Write a markdown report from the following notes. Be sure to output the report in the following format: ...:\n\n" + + # Add the feedback to the user message if it exists + feedback = state.get("review", None) + if feedback: + user_msg += f"{feedback}\n\n" + + # Add the research notes to the user message + notes = "\n\n".join(notes) + user_msg += f"{notes}\n\n" + + # Run the write agent + result = await write_agent.run(user_msg=user_msg) + report = re.search(r"(.*)", str(result), re.DOTALL).group( + 1 + ) + state["report_content"] = str(report) + await ctx.store.set("state", state) + + return str(report) + + +async def call_review_agent(ctx: Context) -> str: + """Useful for reviewing the report and providing feedback.""" + state = await ctx.store.get("state") + report = state.get("report_content", None) + if not report: + return "No report content to review." + + result = await review_agent.run( + user_msg=f"Review the following report: {report}" + ) + state["review"] = result + await ctx.store.set("state", state) + + return result +``` + +## Creating the Top-Level Orchestrator Agent + +With our sub-agents defined as tools, we can now create our top-level orchestrator agent. + + +```python +orchestrator = FunctionAgent( + system_prompt=( + "You are an expert in the field of report writing. " + "You are given a user request and a list of tools that can help with the request. " + "You are to orchestrate the tools to research, write, and review a report on the given topic. " + "Once the review is positive, you should notify the user that the report is ready to be accessed." + ), + llm=orchestrator_llm, + tools=[ + call_research_agent, + call_write_agent, + call_review_agent, + ], + initial_state={ + "research_notes": [], + "report_content": None, + "review": None, + }, +) +``` + +## Running the Agent + +Let's run our agents! We can iterate over events as the workflow runs. + + +```python +from llama_index.core.agent.workflow import ( + AgentInput, + AgentOutput, + ToolCall, + ToolCallResult, + AgentStream, +) +from llama_index.core.workflow import Context + +# Create a context for the orchestrator to hold history/state +ctx = Context(orchestrator) + + +async def run_orchestrator(ctx: Context, user_msg: str): + handler = orchestrator.run( + user_msg=user_msg, + ctx=ctx, + ) + + async for event in handler.stream_events(): + if isinstance(event, AgentStream): + if event.delta: + print(event.delta, end="", flush=True) + # elif isinstance(event, AgentInput): + # print("📥 Input:", event.input) + elif isinstance(event, AgentOutput): + # Skip printing the output since we are streaming above + # if event.response.content: + # print("📤 Output:", event.response.content) + if event.tool_calls: + print( + "🛠️ Planning to use tools:", + [call.tool_name for call in event.tool_calls], + ) + elif isinstance(event, ToolCallResult): + print(f"🔧 Tool Result ({event.tool_name}):") + print(f" Arguments: {event.tool_kwargs}") + print(f" Output: {event.tool_output}") + elif isinstance(event, ToolCall): + print(f"🔨 Calling Tool: {event.tool_name}") + print(f" With arguments: {event.tool_kwargs}") +``` + + +```python +await run_orchestrator( + ctx=ctx, + user_msg=( + "Write me a report on the history of the internet. " + "Briefly describe the history of the internet, including the development of the internet, the development of the web, " + "and the development of the internet in the 21st century." + ), +) +``` + + 🛠️ Planning to use tools: ['call_research_agent'] + 🔨 Calling Tool: call_research_agent + With arguments: {'prompt': 'Write a detailed research note on the history of the internet, covering the development of the internet, the development of the web, and the development of the internet in the 21st century.'} + 🔧 Tool Result (call_research_agent): + Arguments: {'prompt': 'Write a detailed research note on the history of the internet, covering the development of the internet, the development of the web, and the development of the internet in the 21st century.'} + Output: Research Notes on the History of the Internet + + 1. Development of the Internet: + - The internet's origins trace back to the late 1960s with the U.S. Defense Department's Advanced Research Projects Agency Network (ARPANET), designed as a military defense system during the Cold War. + - ARPANET was the first network to implement the protocol suite TCP/IP, which became the technical foundation of the modern Internet. + - The Network Working Group evolved into the Internet Working Group to coordinate the growing research community. + - In the 1970s, commercial packet networks emerged, primarily to provide remote computer access. + - The National Science Foundation (NSF) expanded access to the scientific and academic community and helped make TCP/IP the standard for federally supported research networks. + - The internet grew through interconnected commercial backbones linked by network access points (NAPs). + + 2. Development of the World Wide Web: + - Invented by Tim Berners-Lee in 1989 while working at CERN, the World Wide Web introduced a "web" of linked information accessible to anyone on the Internet. + - By December 1990, Berners-Lee developed the essential tools: HTTP (HyperText Transfer Protocol), HTML (HyperText Markup Language), the first web browser/editor, the first web server, and the first website. + - The Web allowed easy access to existing information and linked resources, initially serving CERN scientists. + - In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to create open standards for the Web. + - The Web evolved from Web 1.0 (basic, static pages) to Web 2.0 (interactive, user-generated content) starting around 2003, and further towards Web 3.0 (semantic web, intelligent data) from 2014 onwards. + + 3. Development of the Internet in the 21st Century: + - The 21st century saw transformative developments such as broadband, fiber-optic technology, and mobile internet. + - The rise of smartphones revolutionized mobile browsing and internet access. + - Cloud computing emerged, allowing data storage and processing on remote servers, changing how businesses and individuals manage information. + - The Internet of Things (IoT) connected everyday devices to the internet, expanding the internet's reach into daily life. + - Social media platforms became dominant, reshaping communication and information sharing. + - The internet's infrastructure and services have continuously evolved to support increasing data demands and new technologies. + + These notes summarize the key milestones and technological advancements that shaped the internet from its inception to its current state in the 21st century. + 🛠️ Planning to use tools: ['call_write_agent'] + 🔨 Calling Tool: call_write_agent + With arguments: {} + 🔧 Tool Result (call_write_agent): + Arguments: {} + Output: + # History of the Internet + + ## 1. Development of the Internet + + The origins of the internet date back to the late 1960s with the creation of the Advanced Research Projects Agency Network (ARPANET) by the U.S. Defense Department. Initially designed as a military defense system during the Cold War, ARPANET was the first network to implement the TCP/IP protocol suite, which later became the technical foundation of the modern Internet. + + The Network Working Group, which coordinated early research efforts, evolved into the Internet Working Group as the research community expanded. During the 1970s, commercial packet networks began to emerge, primarily to provide remote computer access. + + The National Science Foundation (NSF) played a crucial role by expanding internet access to the scientific and academic communities and promoting TCP/IP as the standard for federally supported research networks. The internet grew further through interconnected commercial backbones linked by network access points (NAPs), facilitating broader connectivity. + + ## 2. Development of the World Wide Web + + The World Wide Web was invented in 1989 by Tim Berners-Lee while working at CERN. It introduced a "web" of linked information accessible to anyone on the Internet. By December 1990, Berners-Lee had developed the essential tools that formed the Web's foundation: HTTP (HyperText Transfer Protocol), HTML (HyperText Markup Language), the first web browser/editor, the first web server, and the first website. + + Initially serving CERN scientists, the Web allowed easy access to existing information and linked resources. In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to create open standards for the Web, ensuring its continued growth and interoperability. + + The Web evolved through several stages: + - **Web 1.0:** Basic, static pages. + - **Web 2.0:** Starting around 2003, characterized by interactive, user-generated content. + - **Web 3.0:** From 2014 onwards, focusing on the semantic web and intelligent data. + + ## 3. Development of the Internet in the 21st Century + + The 21st century brought transformative advancements to the internet, including broadband and fiber-optic technologies that significantly increased data transmission speeds. The rise of smartphones revolutionized mobile browsing and internet access, making the internet ubiquitous. + + Cloud computing emerged as a major innovation, enabling data storage and processing on remote servers, which transformed how businesses and individuals manage information. The Internet of Things (IoT) connected everyday devices to the internet, expanding its reach into daily life. + + Social media platforms became dominant forces, reshaping communication and information sharing globally. Throughout these developments, the internet's infrastructure and services have continuously evolved to support increasing data demands and new technologies. + + --- + + This report summarizes the key milestones and technological advancements that have shaped the internet from its inception in the late 1960s to its current state in the 21st century. + + 🛠️ Planning to use tools: ['call_review_agent'] + 🔨 Calling Tool: call_review_agent + With arguments: {} + 🔧 Tool Result (call_review_agent): + Arguments: {} + Output: The report titled "History of the Internet" is well-structured, clear, and provides a concise overview of the major developments in the evolution of the internet. It effectively covers the origins, the invention and growth of the World Wide Web, and significant 21st-century advancements. + + Strengths: + - The chronological organization helps readers follow the progression of internet technology. + - Key figures and organizations (e.g., ARPANET, Tim Berners-Lee, NSF, W3C) are appropriately highlighted. + - The explanation of Web 1.0, 2.0, and 3.0 stages adds valuable context. + - The inclusion of recent technologies such as cloud computing, IoT, and social media reflects current trends. + + Suggestions for improvement: + 1. **Add citations or references:** The report would benefit from citing sources or references to support the historical facts and technological descriptions. + 2. **Clarify technical terms:** While the report is generally accessible, briefly defining terms like TCP/IP, NAPs, and semantic web could help readers unfamiliar with networking jargon. + 3. **Expand on social impact:** Consider including a brief discussion on how the internet has impacted society, economy, and culture to provide a more holistic view. + 4. **Minor formatting:** The section numbering is inconsistent (e.g., "1.", "2.", "3." but no numbering for the introduction or conclusion). Adding a brief introduction and conclusion section with numbering or consistent formatting would improve flow. + + Overall, the report is informative and well-written. With the suggested enhancements, it would be even more comprehensive and reader-friendly. + + Recommendation: **Approve with minor revisions** to incorporate citations, clarify terms, and consider adding social impact context. + 🛠️ Planning to use tools: ['call_write_agent'] + 🔨 Calling Tool: call_write_agent + With arguments: {} + 🔧 Tool Result (call_write_agent): + Arguments: {} + Output: + # History of the Internet + + ## 1. Introduction + + The internet is a transformative technology that has reshaped communication, information sharing, and society at large. This report provides a concise overview of the major developments in the evolution of the internet, from its origins in the late 1960s to the advanced technologies and societal impacts of the 21st century. + + ## 2. Development of the Internet + + The origins of the internet date back to the late 1960s with the creation of the Advanced Research Projects Agency Network (ARPANET) by the U.S. Department of Defense. ARPANET was initially designed as a military defense communication system during the Cold War. It was the first network to implement the Transmission Control Protocol/Internet Protocol (TCP/IP), a suite of communication protocols that became the technical foundation of the modern internet. TCP/IP enables different networks to interconnect and communicate seamlessly. + + During the 1970s, commercial packet-switched networks emerged, primarily to provide remote computer access. The National Science Foundation (NSF) played a crucial role in expanding internet access to the scientific and academic communities and helped establish TCP/IP as the standard protocol for federally supported research networks. The internet's growth was further supported by interconnected commercial backbones linked through Network Access Points (NAPs), which facilitated data exchange between different service providers. + + ## 3. Development of the World Wide Web + + In 1989, Tim Berners-Lee, working at CERN, invented the World Wide Web (WWW), which introduced a system of linked information accessible to anyone connected to the internet. By December 1990, Berners-Lee had developed the essential components of the Web: HyperText Transfer Protocol (HTTP), HyperText Markup Language (HTML), the first web browser/editor, the first web server, and the first website. These innovations allowed users to easily access and navigate information through hyperlinks. + + Initially serving CERN scientists, the Web rapidly expanded to the public. In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to develop open standards ensuring the Web's interoperability and growth. + + The Web has evolved through several stages: + + - **Web 1.0**: Characterized by static, read-only web pages. + - **Web 2.0**: Beginning around 2003, marked by interactive, user-generated content and social media platforms. + - **Web 3.0**: Emerging from 2014 onwards, focusing on the semantic web and intelligent data processing to create more personalized and meaningful online experiences. + + ## 4. Development of the Internet in the 21st Century + + The 21st century has witnessed transformative advancements in internet technology and infrastructure. Broadband and fiber-optic technologies have significantly increased data transmission speeds. The proliferation of smartphones revolutionized mobile internet access, enabling users to connect anytime and anywhere. + + Cloud computing emerged as a paradigm shift, allowing data storage and processing on remote servers rather than local devices. This innovation has changed how businesses and individuals manage information and applications. + + The Internet of Things (IoT) has expanded the internet's reach by connecting everyday devices—such as home appliances, vehicles, and wearable technology—to the network, enabling new functionalities and data-driven services. + + Social media platforms have become dominant forces in communication and information sharing, reshaping social interactions, marketing, and news dissemination. + + The internet's infrastructure and services continue to evolve to meet increasing data demands and support emerging technologies. + + ## 5. Social Impact of the Internet + + Beyond technological advancements, the internet has profoundly impacted society, the economy, and culture. It has democratized access to information, facilitated global communication, and enabled new forms of social interaction. Economically, it has created new industries, transformed traditional business models, and fostered innovation. Culturally, the internet has influenced media consumption, education, and the way communities form and interact. + + However, these changes also bring challenges such as privacy concerns, digital divides, misinformation, and cybersecurity threats, which require ongoing attention and management. + + ## 6. Conclusion + + The history of the internet is marked by continuous innovation and expansion, from its military origins to a global network integral to modern life. Key figures like Tim Berners-Lee and organizations such as ARPANET, NSF, and W3C have played pivotal roles in its development. Understanding the technical foundations, evolutionary stages of the Web, and recent technological trends provides valuable context for appreciating the internet's role today. Incorporating social impact considerations offers a more holistic view of this transformative technology. + + --- + + *Note: This report would benefit from citations to authoritative sources for historical facts and technical explanations to enhance credibility and provide readers with avenues for further research.* + + + The revised report on the history of the internet is now complete and ready for your review. Would you like to access the final report? + +With our report written and revised/reviewed, we can inspect the final report in the state. + + +```python +state = await ctx.store.get("state") +print(state["report_content"]) +``` + + + # History of the Internet + + ## 1. Introduction + + The internet is a transformative technology that has reshaped communication, information sharing, and society at large. This report provides a concise overview of the major developments in the evolution of the internet, from its origins in the late 1960s to the advanced technologies and societal impacts of the 21st century. + + ## 2. Development of the Internet + + The origins of the internet date back to the late 1960s with the creation of the Advanced Research Projects Agency Network (ARPANET) by the U.S. Department of Defense. ARPANET was initially designed as a military defense communication system during the Cold War. It was the first network to implement the Transmission Control Protocol/Internet Protocol (TCP/IP), a suite of communication protocols that became the technical foundation of the modern internet. TCP/IP enables different networks to interconnect and communicate seamlessly. + + During the 1970s, commercial packet-switched networks emerged, primarily to provide remote computer access. The National Science Foundation (NSF) played a crucial role in expanding internet access to the scientific and academic communities and helped establish TCP/IP as the standard protocol for federally supported research networks. The internet's growth was further supported by interconnected commercial backbones linked through Network Access Points (NAPs), which facilitated data exchange between different service providers. + + ## 3. Development of the World Wide Web + + In 1989, Tim Berners-Lee, working at CERN, invented the World Wide Web (WWW), which introduced a system of linked information accessible to anyone connected to the internet. By December 1990, Berners-Lee had developed the essential components of the Web: HyperText Transfer Protocol (HTTP), HyperText Markup Language (HTML), the first web browser/editor, the first web server, and the first website. These innovations allowed users to easily access and navigate information through hyperlinks. + + Initially serving CERN scientists, the Web rapidly expanded to the public. In 1994, Berners-Lee founded the World Wide Web Consortium (W3C) at MIT to develop open standards ensuring the Web's interoperability and growth. + + The Web has evolved through several stages: + + - **Web 1.0**: Characterized by static, read-only web pages. + - **Web 2.0**: Beginning around 2003, marked by interactive, user-generated content and social media platforms. + - **Web 3.0**: Emerging from 2014 onwards, focusing on the semantic web and intelligent data processing to create more personalized and meaningful online experiences. + + ## 4. Development of the Internet in the 21st Century + + The 21st century has witnessed transformative advancements in internet technology and infrastructure. Broadband and fiber-optic technologies have significantly increased data transmission speeds. The proliferation of smartphones revolutionized mobile internet access, enabling users to connect anytime and anywhere. + + Cloud computing emerged as a paradigm shift, allowing data storage and processing on remote servers rather than local devices. This innovation has changed how businesses and individuals manage information and applications. + + The Internet of Things (IoT) has expanded the internet's reach by connecting everyday devices—such as home appliances, vehicles, and wearable technology—to the network, enabling new functionalities and data-driven services. + + Social media platforms have become dominant forces in communication and information sharing, reshaping social interactions, marketing, and news dissemination. + + The internet's infrastructure and services continue to evolve to meet increasing data demands and support emerging technologies. + + ## 5. Social Impact of the Internet + + Beyond technological advancements, the internet has profoundly impacted society, the economy, and culture. It has democratized access to information, facilitated global communication, and enabled new forms of social interaction. Economically, it has created new industries, transformed traditional business models, and fostered innovation. Culturally, the internet has influenced media consumption, education, and the way communities form and interact. + + However, these changes also bring challenges such as privacy concerns, digital divides, misinformation, and cybersecurity threats, which require ongoing attention and management. + + ## 6. Conclusion + + The history of the internet is marked by continuous innovation and expansion, from its military origins to a global network integral to modern life. Key figures like Tim Berners-Lee and organizations such as ARPANET, NSF, and W3C have played pivotal roles in its development. Understanding the technical foundations, evolutionary stages of the Web, and recent technological trends provides valuable context for appreciating the internet's role today. Incorporating social impact considerations offers a more holistic view of this transformative technology. + + --- + + *Note: This report would benefit from citations to authoritative sources for historical facts and technical explanations to enhance credibility and provide readers with avenues for further research.* + + + diff --git a/markdowns/Agent/anthropic_agent.md b/markdowns/Agent/anthropic_agent.md new file mode 100644 index 0000000..1eb3e55 --- /dev/null +++ b/markdowns/Agent/anthropic_agent.md @@ -0,0 +1,213 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/anthropic_agent.ipynb +toc: True +title: "Function Calling Anthropic Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our Anthropic agent, powered by function calling capabilities. + +**NOTE:** Only claude-3* models support function calling using Anthropic's API. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the Anthropic API (using our own `llama_index` LLM class) +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + + +```python +%pip install llama-index +%pip install llama-index-llms-anthropic +%pip install llama-index-embeddings-openai +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Make sure your ANTHROPIC_API_KEY is set. Otherwise explicitly specify the `api_key` parameter. + + +```python +from llama_index.llms.anthropic import Anthropic + +llm = Anthropic(model="claude-3-opus-20240229", api_key="sk-...") +``` + +## Initialize Anthropic Agent + +Here we initialize a simple Mistral agent with calculator functions. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + + +```python +from llama_index.core.agent.workflow import ToolCallResult + + +async def run_agent_verbose(query: str): + handler = agent.run(query) + async for event in handler.stream_events(): + if isinstance(event, ToolCallResult): + print( + f"Called tool {event.tool_name} with args {event.tool_kwargs}\nGot result: {event.tool_output}" + ) + + return await handler +``` + +### Chat + + +```python +response = await run_agent_verbose("What is (121 + 2) * 5?") +print(str(response)) +``` + + Called tool add with args {'a': 121, 'b': 2} + Got result: 123 + Called tool multiply with args {'a': 123, 'b': 5} + Got result: 615 + Therefore, (121 + 2) * 5 = 615 + + + +```python +# inspect sources +print(response.tool_calls) +``` + + [ToolCallResult(tool_name='add', tool_kwargs={'a': 121, 'b': 2}, tool_id='toolu_01MH6ME7ppxGPSJcCMEUAN5Q', tool_output=ToolOutput(content='123', tool_name='add', raw_input={'args': (), 'kwargs': {'a': 121, 'b': 2}}, raw_output=123, is_error=False), return_direct=False), ToolCallResult(tool_name='multiply', tool_kwargs={'a': 123, 'b': 5}, tool_id='toolu_01JE5TVERND5YC97E68gYoPw', tool_output=ToolOutput(content='615', tool_name='multiply', raw_input={'args': (), 'kwargs': {'a': 123, 'b': 5}}, raw_output=615, is_error=False), return_direct=False)] + + +### Managing Context/Memory + +By default, `.run()` is stateless. If you want to maintain state, you can pass in a `context` object. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) + +response = await agent.run("My name is John Doe", ctx=ctx) +response = await agent.run("What is my name?", ctx=ctx) + +print(str(response)) +``` + +## Anthropic Agent over RAG Pipeline + +Build a Anthropic agent over a simple 10K document. We use OpenAI embeddings and claude-3-haiku-20240307 to construct the RAG pipeline, and pass it to the Anthropic Opus agent as a tool. + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +``` + + --2025-03-24 12:52:55-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1880483 (1.8M) [application/octet-stream] + Saving to: ‘data/10k/uber_2021.pdf’ + + data/10k/uber_2021. 100%[===================>] 1.79M 8.98MB/s in 0.2s + + 2025-03-24 12:52:56 (8.98 MB/s) - ‘data/10k/uber_2021.pdf’ saved [1880483/1880483] + + + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.llms.anthropic import Anthropic + +embed_model = OpenAIEmbedding( + model_name="text-embedding-3-large", api_key="sk-proj-..." +) +query_llm = Anthropic(model="claude-3-haiku-20240307", api_key="sk-...") + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() + +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=query_llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent(tools=[query_engine_tool], llm=llm, verbose=True) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber?" +) +print(str(response)) +``` + + In summary, based on Uber's 2021 10-K filing, some of the company's key risk factors included: + + - Significant expected increases in operating expenses + - Challenges attracting and retaining drivers, consumers, merchants, shippers, and carriers + - Risks to Uber's brand and reputation + - Challenges from Uber's historical workplace culture + - Difficulties optimizing organizational structure and managing growth + - Risks related to criminal activity by platform users + - Risks from new offerings and technologies like autonomous vehicles + - Data security and privacy risks + - Climate change exposure + - Reliance on third-party platforms + - Regulatory and legal risks + - Intellectual property risks + + In terms of growth opportunities and tailwinds, Uber's strategy in 2021 focused on restructuring by divesting certain markets and business lines, and instead partnering with and taking minority ownership positions in local ridesharing and delivery companies in those markets. This suggests Uber saw opportunities to still participate in the growth of those markets through its investments, rather than operating independently. + diff --git a/markdowns/Agent/bedrock_converse_agent.md b/markdowns/Agent/bedrock_converse_agent.md new file mode 100644 index 0000000..ad198a3 --- /dev/null +++ b/markdowns/Agent/bedrock_converse_agent.md @@ -0,0 +1,157 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/bedrock_converse_agent.ipynb +toc: True +title: "Function Calling AWS Bedrock Converse Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our AWS Bedrock Converse agent, powered by function calling capabilities. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. AWS credentials with access to Bedrock and the Claude Haiku LLM +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + + +```python +%pip install llama-index +%pip install llama-index-llms-bedrock-converse +%pip install llama-index-embeddings-huggingface +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Make sure to set your AWS credentials, either the `profile_name` or the keys below. + + +```python +from llama_index.llms.bedrock_converse import BedrockConverse + +llm = BedrockConverse( + model="anthropic.claude-3-haiku-20240307-v1:0", + # NOTE replace with your own AWS credentials + aws_access_key_id="AWS Access Key ID to use", + aws_secret_access_key="AWS Secret Access Key to use", + aws_session_token="AWS Session Token to use", + region_name="AWS Region to use, eg. us-east-1", +) +``` + +## Initialize AWS Bedrock Converse Agent + +Here we initialize a simple AWS Bedrock Converse agent with calculator functions. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + +### Chat + + +```python +response = await agent.run("What is (121 + 2) * 5?") +print(str(response)) +``` + + +```python +# inspect sources +print(response.tool_calls) +``` + +## AWS Bedrock Converse Agent over RAG Pipeline + +Build an AWS Bedrock Converse agent over a simple 10K document. We use both HuggingFace embeddings and `BAAI/bge-small-en-v1.5` to construct the RAG pipeline, and pass it to the AWS Bedrock Converse agent as a tool. + + +```python +!mkdir -p 'data/10k/' +!curl -o 'data/10k/uber_2021.pdf' 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.embeddings.huggingface import HuggingFaceEmbedding +from llama_index.llms.bedrock_converse import BedrockConverse + +embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5") +query_llm = BedrockConverse( + model="anthropic.claude-3-haiku-20240307-v1:0", + # NOTE replace with your own AWS credentials + aws_access_key_id="AWS Access Key ID to use", + aws_secret_access_key="AWS Secret Access Key to use", + aws_session_token="AWS Session Token to use", + region_name="AWS Region to use, eg. us-east-1", +) + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() + +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=query_llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[query_engine_tool], + llm=llm, +) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls." +) +``` + + +```python +print(str(response)) +``` diff --git a/markdowns/Agent/code_act_agent.md b/markdowns/Agent/code_act_agent.md new file mode 100644 index 0000000..4f22073 --- /dev/null +++ b/markdowns/Agent/code_act_agent.md @@ -0,0 +1,369 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/code_act_agent.ipynb +toc: True +title: "Prebuilt CodeAct Agent w/ LlamaIndex" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +LlamaIndex offers a prebuilt CodeAct Agent that can be used to write and execute code, inspired by the original [CodeAct paper](https://arxiv.org/abs/2402.01030). + +With this agent, you provide an agent with a set of functions, and the agent will write code that uses those functions to help complete the task you give it. + +Some advantages of using the CodeAct Agent: + +- No need to exhaustively list out all the possible functions that the agent might need +- The agent can develop complex workflows around your existing functions +- Can integrate directly with existing API's + +Let's walk through a simple example of how to use the CodeAct Agent. + +**NOTE:** This example includes code that will execute arbitrary code. This is dangerous, and proper sandboxing should be used in production environments. + +## Setup + +First, let's configure the LLM we want to use, and provide some functions that we can use in our code. + + +```python +%pip install -U llama-index-core llama-index-llms-ollama +``` + + +```python +from llama_index.llms.openai import OpenAI + +# Configure the LLM +llm = OpenAI(model="gpt-4o-mini", api_key="sk-...") + + +# Define a few helper functions +def add(a: int, b: int) -> int: + """Add two numbers together""" + return a + b + + +def subtract(a: int, b: int) -> int: + """Subtract two numbers""" + return a - b + + +def multiply(a: int, b: int) -> int: + """Multiply two numbers""" + return a * b + + +def divide(a: int, b: int) -> float: + """Divide two numbers""" + return a / b +``` + +## Create a Code Executor + +The `CodeActAgent` will require a specific `code_execute_fn` to execute the code generated by the agent. + +Below, we define a simple `code_execute_fn` that will execute the code in-process and maintain execution state. + +**NOTE:** In a production environment, you should use a more robust method of executing code. This is just for demonstration purposes, and executing code in-process is dangerous. Consider using docker or external services to execute code. + +With this executor, we can pass in a dictionary of local and global variables to use in the execution context. + +- `locals`: Local variables to use in the execution context, this includes our functions that we want the LLM to code around +- `globals`: Global variables to use in the execution context, this includes the builtins and other imported modules we want to use in the execution context + + +```python +from typing import Any, Dict, Tuple +import io +import contextlib +import ast +import traceback + + +class SimpleCodeExecutor: + """ + A simple code executor that runs Python code with state persistence. + + This executor maintains a global and local state between executions, + allowing for variables to persist across multiple code runs. + + NOTE: not safe for production use! Use with caution. + """ + + def __init__(self, locals: Dict[str, Any], globals: Dict[str, Any]): + """ + Initialize the code executor. + + Args: + locals: Local variables to use in the execution context + globals: Global variables to use in the execution context + """ + # State that persists between executions + self.globals = globals + self.locals = locals + + def execute(self, code: str) -> Tuple[bool, str, Any]: + """ + Execute Python code and capture output and return values. + + Args: + code: Python code to execute + + Returns: + Dict with keys `success`, `output`, and `return_value` + """ + # Capture stdout and stderr + stdout = io.StringIO() + stderr = io.StringIO() + + output = "" + return_value = None + try: + # Execute with captured output + with contextlib.redirect_stdout( + stdout + ), contextlib.redirect_stderr(stderr): + # Try to detect if there's a return value (last expression) + try: + tree = ast.parse(code) + last_node = tree.body[-1] if tree.body else None + + # If the last statement is an expression, capture its value + if isinstance(last_node, ast.Expr): + # Split code to add a return value assignment + last_line = code.rstrip().split("\n")[-1] + exec_code = ( + code[: -len(last_line)] + + "\n__result__ = " + + last_line + ) + + # Execute modified code + exec(exec_code, self.globals, self.locals) + return_value = self.locals.get("__result__") + else: + # Normal execution + exec(code, self.globals, self.locals) + except: + # If parsing fails, just execute the code as is + exec(code, self.globals, self.locals) + + # Get output + output = stdout.getvalue() + if stderr.getvalue(): + output += "\n" + stderr.getvalue() + + except Exception as e: + # Capture exception information + output = f"Error: {type(e).__name__}: {str(e)}\n" + output += traceback.format_exc() + + if return_value is not None: + output += "\n\n" + str(return_value) + + return output +``` + + +```python +code_executor = SimpleCodeExecutor( + # give access to our functions defined above + locals={ + "add": add, + "subtract": subtract, + "multiply": multiply, + "divide": divide, + }, + globals={ + # give access to all builtins + "__builtins__": __builtins__, + # give access to numpy + "np": __import__("numpy"), + }, +) +``` + +## Setup the CodeAct Agent + +Now that we have our code executor, we can setup the CodeAct Agent. + + + +```python +from llama_index.core.agent.workflow import CodeActAgent +from llama_index.core.workflow import Context + +agent = CodeActAgent( + code_execute_fn=code_executor.execute, + llm=llm, + tools=[add, subtract, multiply, divide], +) + +# context to hold the agent's session/state/chat history +ctx = Context(agent) +``` + +## Use the Agent + +Now that we have our agent, we can use it to complete tasks! Since we gave it some math functions, we will prompt it for tasks that require calculations. + + +```python +from llama_index.core.agent.workflow import ( + ToolCall, + ToolCallResult, + AgentStream, +) + + +async def run_agent_verbose(agent, ctx, query): + handler = agent.run(query, ctx=ctx) + print(f"User: {query}") + async for event in handler.stream_events(): + if isinstance(event, ToolCallResult): + print( + f"\n-----------\nCode execution result:\n{event.tool_output}" + ) + elif isinstance(event, ToolCall): + print(f"\n-----------\nParsed code:\n{event.tool_kwargs['code']}") + elif isinstance(event, AgentStream): + print(f"{event.delta}", end="", flush=True) + + return await handler +``` + +Here, the agent uses some built-in functions to calculate the sum of all numbers from 1 to 10. + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of all numbers from 1 to 10" +) +``` + + User: Calculate the sum of all numbers from 1 to 10 + The sum of all numbers from 1 to 10 can be calculated using the formula for the sum of an arithmetic series. However, I will compute it directly for you. + + + # Calculate the sum of numbers from 1 to 10 + total_sum = sum(range(1, 11)) + print(total_sum) + + ----------- + Parsed code: + # Calculate the sum of numbers from 1 to 10 + total_sum = sum(range(1, 11)) + print(total_sum) + + ----------- + Code execution result: + 55 + + The sum of all numbers from 1 to 10 is 55. + +Next, we get the agent to use the tools that we passed in. + + +```python +response = await run_agent_verbose( + agent, ctx, "Add 5 and 3, then multiply the result by 2" +) +``` + + User: Add 5 and 3, then multiply the result by 2 + I will perform the addition of 5 and 3, and then multiply the result by 2. + + + # Perform the calculation + addition_result = add(5, 3) + final_result = multiply(addition_result, 2) + print(final_result) + + ----------- + Parsed code: + # Perform the calculation + addition_result = add(5, 3) + final_result = multiply(addition_result, 2) + print(final_result) + + ----------- + Code execution result: + 16 + + The result of adding 5 and 3, then multiplying by 2, is 16. + +We can even get the agent to define new functions for us! + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 10 fibonacci numbers" +) +``` + + User: Calculate the sum of the first 10 fibonacci numbers + I will calculate the sum of the first 10 Fibonacci numbers. + + + def fibonacci(n): + fib_sequence = [0, 1] + for i in range(2, n): + fib_sequence.append(fib_sequence[-1] + fib_sequence[-2]) + return fib_sequence + + # Calculate the sum of the first 10 Fibonacci numbers + first_10_fib = fibonacci(10) + fibonacci_sum = sum(first_10_fib) + print(fibonacci_sum) + + ----------- + Parsed code: + def fibonacci(n): + fib_sequence = [0, 1] + for i in range(2, n): + fib_sequence.append(fib_sequence[-1] + fib_sequence[-2]) + return fib_sequence + + # Calculate the sum of the first 10 Fibonacci numbers + first_10_fib = fibonacci(10) + fibonacci_sum = sum(first_10_fib) + print(fibonacci_sum) + + ----------- + Code execution result: + 88 + + The sum of the first 10 Fibonacci numbers is 88. + +And then reuse those new functions in a new task! + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 20 fibonacci numbers" +) +``` + + User: Calculate the sum of the first 20 fibonacci numbers + I will calculate the sum of the first 20 Fibonacci numbers. + + + # Calculate the sum of the first 20 Fibonacci numbers + first_20_fib = fibonacci(20) + fibonacci_sum_20 = sum(first_20_fib) + print(fibonacci_sum_20) + + ----------- + Parsed code: + # Calculate the sum of the first 20 Fibonacci numbers + first_20_fib = fibonacci(20) + fibonacci_sum_20 = sum(first_20_fib) + print(fibonacci_sum_20) + + ----------- + Code execution result: + 10945 + + The sum of the first 20 Fibonacci numbers is 10,945. diff --git a/markdowns/Agent/custom_multi_agent.md b/markdowns/Agent/custom_multi_agent.md index 52b9365..c9c8fe9 100644 --- a/markdowns/Agent/custom_multi_agent.md +++ b/markdowns/Agent/custom_multi_agent.md @@ -1,11 +1,12 @@ --- layout: recipe -colab: https://colab.research.google.com/github/TuanaCelik/cookbooks-demo/blob/main/notebooks/agent/custom_multi_agent.ipynb +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/custom_multi_agent.ipynb toc: True title: "Custom Planning Multi-Agent System" featured: True experimental: False tags: ['Agent'] +language: py --- Open In Colab diff --git a/markdowns/Agent/from_scratch_code_act_agent.md b/markdowns/Agent/from_scratch_code_act_agent.md new file mode 100644 index 0000000..5ec6558 --- /dev/null +++ b/markdowns/Agent/from_scratch_code_act_agent.md @@ -0,0 +1,505 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/from_scratch_code_act_agent.ipynb +toc: True +title: "Creating a CodeAct Agent From Scratch" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +While LlamaIndex provides a pre-built [CodeActAgent](https://docs.llamaindex.ai/en/stable/examples/agent/code_act_agent/), we can also create our own from scratch. + +This way, we can fully understand and customize the agent's behaviour beyond what is provided by the pre-built agent. + +In this notebook, we will +1. Create a workflow for generating and parsing code +2. Implement basic code execution +3. Add memory and state to the agent + +## Setting up Functions for our Agent + +If we want our agent to execute our code, we need to deine the code for it to execute! + +For now, let's use a few basic math functions. + + +```python +# Define a few helper functions +def add(a: int, b: int) -> int: + """Add two numbers together""" + return a + b + + +def subtract(a: int, b: int) -> int: + """Subtract two numbers""" + return a - b + + +def multiply(a: int, b: int) -> int: + """Multiply two numbers""" + return a * b + + +def divide(a: int, b: int) -> float: + """Divide two numbers""" + return a / b +``` + +## Creating a Code Executor + +In order to execute code, we need to create a code executor. + +Here, we will use a simple in-process code executor that maintains it's own state. + +**NOTE:** This is a simple example, and does not include proper sandboxing. In a production environment, you should use tools like docker or proper code sandboxing environments. + + +```python +from typing import Any, Dict, Tuple +import io +import contextlib +import ast +import traceback + + +class SimpleCodeExecutor: + """ + A simple code executor that runs Python code with state persistence. + + This executor maintains a global and local state between executions, + allowing for variables to persist across multiple code runs. + + NOTE: not safe for production use! Use with caution. + """ + + def __init__(self, locals: Dict[str, Any], globals: Dict[str, Any]): + """ + Initialize the code executor. + + Args: + locals: Local variables to use in the execution context + globals: Global variables to use in the execution context + """ + # State that persists between executions + self.globals = globals + self.locals = locals + + def execute(self, code: str) -> Tuple[bool, str, Any]: + """ + Execute Python code and capture output and return values. + + Args: + code: Python code to execute + + Returns: + Dict with keys `success`, `output`, and `return_value` + """ + # Capture stdout and stderr + stdout = io.StringIO() + stderr = io.StringIO() + + output = "" + return_value = None + try: + # Execute with captured output + with contextlib.redirect_stdout( + stdout + ), contextlib.redirect_stderr(stderr): + # Try to detect if there's a return value (last expression) + try: + tree = ast.parse(code) + last_node = tree.body[-1] if tree.body else None + + # If the last statement is an expression, capture its value + if isinstance(last_node, ast.Expr): + # Split code to add a return value assignment + last_line = code.rstrip().split("\n")[-1] + exec_code = ( + code[: -len(last_line)] + + "\n__result__ = " + + last_line + ) + + # Execute modified code + exec(exec_code, self.globals, self.locals) + return_value = self.locals.get("__result__") + else: + # Normal execution + exec(code, self.globals, self.locals) + except: + # If parsing fails, just execute the code as is + exec(code, self.globals, self.locals) + + # Get output + output = stdout.getvalue() + if stderr.getvalue(): + output += "\n" + stderr.getvalue() + + except Exception as e: + # Capture exception information + output = f"Error: {type(e).__name__}: {str(e)}\n" + output += traceback.format_exc() + + if return_value is not None: + output += "\n\n" + str(return_value) + + return output +``` + + +```python +code_executor = SimpleCodeExecutor( + # give access to our functions defined above + locals={ + "add": add, + "subtract": subtract, + "multiply": multiply, + "divide": divide, + }, + globals={ + # give access to all builtins + "__builtins__": __builtins__, + # give access to numpy + "np": __import__("numpy"), + }, +) +``` + +## Defining the CodeAct Agent + +Now, we can using LlamaIndex Workflows to define the workflow for our agent. + +The basic flow is: +- take in our prompt + chat history +- parse out the code to execute (if any) +- execute the code +- provide the output of the code execution back to the agent +- repeat until the agent is satisfied with the answer + +First, we can create the events in the workflow. + + +```python +from llama_index.core.llms import ChatMessage +from llama_index.core.workflow import Event + + +class InputEvent(Event): + input: list[ChatMessage] + + +class StreamEvent(Event): + delta: str + + +class CodeExecutionEvent(Event): + code: str +``` + +Next, we can define the workflow that orchestrates using these events. + + +```python +import inspect +import re +from typing import Any, Callable, List + +from llama_index.core.llms import ChatMessage, LLM +from llama_index.core.memory import ChatMemoryBuffer +from llama_index.core.tools.types import BaseTool +from llama_index.core.workflow import ( + Context, + Workflow, + StartEvent, + StopEvent, + step, +) +from llama_index.llms.openai import OpenAI + + +CODEACT_SYSTEM_PROMPT = """ +You are a helpful assistant that can execute code. + +Given the chat history, you can write code within ... tags to help the user with their question. + +In your code, you can reference any previously used variables or functions. + +The user has also provided you with some predefined functions: +{fn_str} + +To execute code, write the code between ... tags. +""" + + +class CodeActAgent(Workflow): + def __init__( + self, + fns: List[Callable], + code_execute_fn: Callable, + llm: LLM | None = None, + **workflow_kwargs: Any, + ) -> None: + super().__init__(**workflow_kwargs) + self.fns = fns or [] + self.code_execute_fn = code_execute_fn + self.llm = llm or OpenAI(model="gpt-4o-mini") + + # parse the functions into truncated function strings + self.fn_str = "\n\n".join( + f'def {fn.__name__}{str(inspect.signature(fn))}:\n """ {fn.__doc__} """\n ...' + for fn in self.fns + ) + self.system_message = ChatMessage( + role="system", + content=CODEACT_SYSTEM_PROMPT.format(fn_str=self.fn_str), + ) + + def _parse_code(self, response: str) -> str | None: + # find the code between ... tags + matches = re.findall(r"(.*?)", response, re.DOTALL) + if matches: + return "\n\n".join(matches) + + return None + + @step + async def prepare_chat_history( + self, ctx: Context, ev: StartEvent + ) -> InputEvent: + # check if memory is setup + memory = await ctx.store.get("memory", default=None) + if not memory: + memory = ChatMemoryBuffer.from_defaults(llm=self.llm) + + # get user input + user_input = ev.get("user_input") + if user_input is None: + raise ValueError("user_input kwarg is required") + user_msg = ChatMessage(role="user", content=user_input) + memory.put(user_msg) + + # get chat history + chat_history = memory.get() + + # update context + await ctx.store.set("memory", memory) + + # add the system message to the chat history and return + return InputEvent(input=[self.system_message, *chat_history]) + + @step + async def handle_llm_input( + self, ctx: Context, ev: InputEvent + ) -> CodeExecutionEvent | StopEvent: + chat_history = ev.input + + # stream the response + response_stream = await self.llm.astream_chat(chat_history) + async for response in response_stream: + ctx.write_event_to_stream(StreamEvent(delta=response.delta or "")) + + # save the final response, which should have all content + memory = await ctx.store.get("memory") + memory.put(response.message) + await ctx.store.set("memory", memory) + + # get the code to execute + code = self._parse_code(response.message.content) + + if not code: + return StopEvent(result=response) + else: + return CodeExecutionEvent(code=code) + + @step + async def handle_code_execution( + self, ctx: Context, ev: CodeExecutionEvent + ) -> InputEvent: + # execute the code + ctx.write_event_to_stream(ev) + output = self.code_execute_fn(ev.code) + + # update the memory + memory = await ctx.store.get("memory") + memory.put(ChatMessage(role="assistant", content=output)) + await ctx.store.set("memory", memory) + + # get the latest chat history and loop back to the start + chat_history = memory.get() + return InputEvent(input=[self.system_message, *chat_history]) +``` + +## Testing the CodeAct Agent + +Now, we can test out the CodeAct Agent! + +We'll create a simple agent and slowly build up the complexity with requests. + + +```python +from llama_index.core.workflow import Context + +agent = CodeActAgent( + fns=[add, subtract, multiply, divide], + code_execute_fn=code_executor.execute, + llm=OpenAI(model="gpt-4o-mini", api_key="sk-..."), +) + +# context to hold the agent's state / memory +ctx = Context(agent) +``` + + +```python +async def run_agent_verbose(agent: CodeActAgent, ctx: Context, query: str): + handler = agent.run(user_input=query, ctx=ctx) + print(f"User: {query}") + async for event in handler.stream_events(): + if isinstance(event, StreamEvent): + print(f"{event.delta}", end="", flush=True) + elif isinstance(event, CodeExecutionEvent): + print(f"\n-----------\nParsed code:\n{event.code}\n") + + return await handler +``` + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of all numbers from 1 to 10" +) +``` + + User: Calculate the sum of all numbers from 1 to 10 + To calculate the sum of all numbers from 1 to 10, we can use the `add` function in a loop. Here's how we can do it: + + + total_sum = 0 + for number in range(1, 11): + total_sum = add(total_sum, number) + total_sum + + ----------- + Parsed code: + + total_sum = 0 + for number in range(1, 11): + total_sum = add(total_sum, number) + total_sum + + + The sum of all numbers from 1 to 10 is 55. + + +```python +response = await run_agent_verbose( + agent, ctx, "Add 5 and 3, then multiply the result by 2" +) +``` + + User: Add 5 and 3, then multiply the result by 2 + To perform the calculation, we will first add 5 and 3 using the `add` function, and then multiply the result by 2 using the `multiply` function. Here's how we can do it: + + + result_addition = add(5, 3) + final_result = multiply(result_addition, 2) + final_result + + ----------- + Parsed code: + + result_addition = add(5, 3) + final_result = multiply(result_addition, 2) + final_result + + + The final result of adding 5 and 3, then multiplying by 2, is 16. + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 10 fibonacci numbers0" +) +``` + + User: Calculate the sum of the first 10 fibonacci numbers0 + To calculate the sum of the first 10 Fibonacci numbers, we first need to generate the Fibonacci sequence up to the 10th number and then sum those numbers. The Fibonacci sequence starts with 0 and 1, and each subsequent number is the sum of the two preceding ones. + + Here's how we can do it: + + + def fibonacci(n: int) -> int: + """ Return the nth Fibonacci number """ + if n == 0: + return 0 + elif n == 1: + return 1 + else: + a, b = 0, 1 + for _ in range(2, n + 1): + a, b = b, a + b + return b + + # Calculate the sum of the first 10 Fibonacci numbers + fibonacci_sum = 0 + for i in range(10): + fibonacci_sum = add(fibonacci_sum, fibonacci(i)) + + fibonacci_sum + + ----------- + Parsed code: + + def fibonacci(n: int) -> int: + """ Return the nth Fibonacci number """ + if n == 0: + return 0 + elif n == 1: + return 1 + else: + a, b = 0, 1 + for _ in range(2, n + 1): + a, b = b, a + b + return b + + # Calculate the sum of the first 10 Fibonacci numbers + fibonacci_sum = 0 + for i in range(10): + fibonacci_sum = add(fibonacci_sum, fibonacci(i)) + + fibonacci_sum + + + The sum of the first 10 Fibonacci numbers is 55. + + +```python +response = await run_agent_verbose( + agent, ctx, "Calculate the sum of the first 20 fibonacci numbers" +) +``` + + User: Calculate the sum of the first 20 fibonacci numbers + To calculate the sum of the first 20 Fibonacci numbers, we can use the same approach as before, but this time we will iterate up to 20. Here's how we can do it: + + + # Calculate the sum of the first 20 Fibonacci numbers + fibonacci_sum_20 = 0 + for i in range(20): + fibonacci_sum_20 = add(fibonacci_sum_20, fibonacci(i)) + + fibonacci_sum_20 + + ----------- + Parsed code: + + # Calculate the sum of the first 20 Fibonacci numbers + fibonacci_sum_20 = 0 + for i in range(20): + fibonacci_sum_20 = add(fibonacci_sum_20, fibonacci(i)) + + fibonacci_sum_20 + + + The sum of the first 20 Fibonacci numbers is 6765. diff --git a/markdowns/Agent/mistral_agent.md b/markdowns/Agent/mistral_agent.md new file mode 100644 index 0000000..dd65d1b --- /dev/null +++ b/markdowns/Agent/mistral_agent.md @@ -0,0 +1,186 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/mistral_agent.ipynb +toc: True +title: "Function Calling Mistral Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our Mistral agent, powered by function calling capabilities. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the OpenAI API (using our own `llama_index` LLM class) +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + + +```python +%pip install llama-index +%pip install llama-index-llms-mistralai +%pip install llama-index-embeddings-mistralai +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Make sure your MISTRAL_API_KEY is set. Otherwise explicitly specify the `api_key` parameter. + + +```python +from llama_index.llms.mistralai import MistralAI + +llm = MistralAI(model="mistral-large-latest", api_key="...") +``` + +## Initialize Mistral Agent + +Here we initialize a simple Mistral agent with calculator functions. + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + +### Chat + + +```python +response = await agent.run("What is (121 + 2) * 5?") +print(str(response)) +``` + + Added user message to memory: What is (121 + 2) * 5? + === Calling Function === + Calling function: add with args: {"a": 121, "b": 2} + === Calling Function === + Calling function: multiply with args: {"a": 123, "b": 5} + assistant: The result of (121 + 2) * 5 is 615. + + + +```python +# inspect sources +print(response.tool_calls) +``` + +### Managing Context/Memory + +By default, `.run()` is stateless. If you want to maintain state, you can pass in a `context` object. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) + +response = await agent.run("My name is John Doe", ctx=ctx) +response = await agent.run("What is my name?", ctx=ctx) + +print(str(response)) +``` + +## Mistral Agent over RAG Pipeline + +Build a Mistral agent over a simple 10K document. We use both Mistral embeddings and mistral-medium to construct the RAG pipeline, and pass it to the Mistral agent as a tool. + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.embeddings.mistralai import MistralAIEmbedding +from llama_index.llms.mistralai import MistralAI + +embed_model = MistralAIEmbedding(api_key="...") +query_llm = MistralAI(model="mistral-medium", api_key="...") + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=query_llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent(tools=[query_engine_tool], llm=llm) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls." +) +print(str(response)) +``` + + Added user message to memory: Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls. + === Calling Function === + Calling function: uber_10k with args: {"input": "What are the risk factors for Uber in 2021?"} + === Calling Function === + Calling function: uber_10k with args: {"input": "What are the tailwinds for Uber in 2021?"} + assistant: Based on the information provided, here are the risk factors for Uber in 2021: + + 1. Failure to offer or develop autonomous vehicle technologies, which could result in inferior performance or safety concerns compared to competitors. + 2. Dependence on high-quality personnel and the potential impact of attrition or unsuccessful succession planning on the business. + 3. Security or data privacy breaches, unauthorized access, or destruction of proprietary, employee, or user data. + 4. Cyberattacks, such as malware, ransomware, viruses, spamming, and phishing attacks, which could harm the company's reputation and operations. + 5. Climate change risks, including physical and transitional risks, that may adversely impact the business if not managed effectively. + 6. Reliance on third parties to maintain open marketplaces for distributing products and providing software, which could negatively affect the business if interfered with. + 7. The need for additional capital to support business growth, which may not be available on reasonable terms or at all. + 8. Difficulties in identifying, acquiring, and integrating suitable businesses, which could harm operating results and prospects. + 9. Legal and regulatory risks, including extensive government regulation and oversight related to payment and financial services. + 10. Intellectual property risks, such as the inability to protect intellectual property or claims of misappropriation by third parties. + 11. Volatility in the market price of common stock, which could result in steep declines and loss of investment for shareholders. + 12. Economic risks related to the COVID-19 pandemic, which has adversely impacted and could continue to adversely impact the business, financial condition, and results of operations. + 13. The potential reclassification of Drivers as employees, workers, or quasi-employees, which could result in material costs associated with defending, settling, or resolving lawsuits and demands for arbitration. + + On the other hand, here are some tailwinds for Uber in 2021: + + 1. Launch of Uber One, a single cross-platform membership program in the United States, which offers discounts, special pricing, priority service, and exclusive perks across rides, delivery, and grocery offerings. + 2. Introduction of a "Super App" view on iOS + diff --git a/markdowns/Agent/multi_agent_workflow_with_weaviate_queryagent.md b/markdowns/Agent/multi_agent_workflow_with_weaviate_queryagent.md new file mode 100644 index 0000000..7fe6da3 --- /dev/null +++ b/markdowns/Agent/multi_agent_workflow_with_weaviate_queryagent.md @@ -0,0 +1,706 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/multi_agent_workflow_with_weaviate_queryagent.ipynb +toc: True +title: "Multi-Agent Workflow with Weaviate QueryAgent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +Open In Colab + +In this example, we will be building a LlamaIndex Agent Workflow that ends up being a multi-agent system that aims to be a Docs Assistant capable of: +- Writing new content to a "LlamaIndexDocs" collection in Weaviate +- Writing new content to a "WeaviateDocs" collection in Weaviate +- Using the Weaviate [`QueryAgent`](https://weaviate.io/developers/agents/query) to answer questions based on the contents of these collections. + +The `QueryAgent` is a full agent prodcut by Weaviate, that is capable of doing regular search, as well as aggregations over the collections you give it access to. Our 'orchestrator' agent will decide when to invoke the Weaviate QueryAgent, leaving the job of creating Weaviate specific search queries to it. + +**Things you will need:** + +- An OpenAI API key (or switch to another provider and adjust the code below) +- A Weaviate sandbox (this is free) +- Your Weaviate sandbox URL and API key + +![Workflow Overview](../_static/agents/workflow-weaviate-multiagent.png) + +## Install & Import Dependencies + + +```python +!pip install llama-index-core llama-index-utils-workflow weaviate-client[agents] llama-index-llms-openai llama-index-readers-web +``` + + +```python +from llama_index.core.workflow import ( + StartEvent, + StopEvent, + Workflow, + step, + Event, + Context, +) +from llama_index.utils.workflow import draw_all_possible_flows +from llama_index.readers.web import SimpleWebPageReader +from llama_index.core.llms import ChatMessage +from llama_index.core.tools import FunctionTool +from llama_index.llms.openai import OpenAI +from llama_index.core.agent.workflow import FunctionAgent + +from enum import Enum +from pydantic import BaseModel, Field +from llama_index.llms.openai import OpenAI +from typing import List, Union +import json + +import weaviate +from weaviate.auth import Auth +from weaviate.agents.query import QueryAgent +from weaviate.classes.config import Configure, Property, DataType + +import os +from getpass import getpass +``` + +## Set up Weaviate + +To use the Weaviate Query Agent, first, create a [Weaviate Cloud](https://weaviate.io/deployment/serverless) account👇 +1. [Create Serverless Weaviate Cloud account](https://weaviate.io/deployment/serverless) and set up a free [Sandbox](https://weaviate.io/developers/wcs/manage-clusters/create#sandbox-clusters) +2. Go to 'Embedding' and enable it, by default, this will make it so that we use `Snowflake/snowflake-arctic-embed-l-v2.0` as the embedding model +3. Take note of the `WEAVIATE_URL` and `WEAVIATE_API_KEY` to connect to your cluster below + +> Info: We recommend using [Weaviate Embeddings](https://weaviate.io/developers/weaviate/model-providers/weaviate) so you do not have to provide any extra keys for external embedding providers. + + +```python +if "WEAVIATE_API_KEY" not in os.environ: + os.environ["WEAVIATE_API_KEY"] = getpass("Add Weaviate API Key") +if "WEAVIATE_URL" not in os.environ: + os.environ["WEAVIATE_URL"] = getpass("Add Weaviate URL") +``` + + +```python +client = weaviate.connect_to_weaviate_cloud( + cluster_url=os.environ.get("WEAVIATE_URL"), + auth_credentials=Auth.api_key(os.environ.get("WEAVIATE_API_KEY")), +) +``` + +### Create WeaviateDocs and LlamaIndexDocs Collections + +The helper function below will create a "WeaviateDocs" and "LlamaIndexDocs" collection in Weaviate (if they don't exist already). It will also set up a `QueryAgent` that has access to both of these collections. + +The Weaviate [`QueryAgent`](https://weaviate.io/blog/query-agent) is designed to be able to query Weviate Collections for both regular search and aggregations, and also handles the burden of creating the Weaviate specific queries internally. + +The Agent will use the collection descriptions, as well as the property descriptions while formilating the queries. + + +```python +def fresh_setup_weaviate(client): + if client.collections.exists("WeaviateDocs"): + client.collections.delete("WeaviateDocs") + client.collections.create( + "WeaviateDocs", + description="A dataset with the contents of Weaviate technical Docs and website", + vectorizer_config=Configure.Vectorizer.text2vec_weaviate(), + properties=[ + Property( + name="url", + data_type=DataType.TEXT, + description="the source URL of the webpage", + ), + Property( + name="text", + data_type=DataType.TEXT, + description="the content of the webpage", + ), + ], + ) + + if client.collections.exists("LlamaIndexDocs"): + client.collections.delete("LlamaIndexDocs") + client.collections.create( + "LlamaIndexDocs", + description="A dataset with the contents of LlamaIndex technical Docs and website", + vectorizer_config=Configure.Vectorizer.text2vec_weaviate(), + properties=[ + Property( + name="url", + data_type=DataType.TEXT, + description="the source URL of the webpage", + ), + Property( + name="text", + data_type=DataType.TEXT, + description="the content of the webpage", + ), + ], + ) + + agent = QueryAgent( + client=client, collections=["LlamaIndexDocs", "WeaviateDocs"] + ) + return agent +``` + +### Write Contents of Webpage to the Collections + +The helper function below uses the `SimpleWebPageReader` to write the contents of a webpage to the relevant Weaviate collection + + +```python +def write_webpages_to_weaviate(client, urls: list[str], collection_name: str): + documents = SimpleWebPageReader(html_to_text=True).load_data(urls) + collection = client.collections.get(collection_name) + with collection.batch.dynamic() as batch: + for doc in documents: + batch.add_object(properties={"url": doc.id_, "text": doc.text}) +``` + +## Create a Function Calling Agent + +Now that we have the relevant functions to write to a collection and also the `QueryAgent` at hand, we can start by using the `FunctionAgent`, which is a simple tool calling agent. + + +```python +if "OPENAI_API_KEY" not in os.environ: + os.environ["OPENAI_API_KEY"] = getpass("openai-key") +``` + + +```python +weaviate_agent = fresh_setup_weaviate(client) +``` + + +```python +llm = OpenAI(model="gpt-4o-mini") + + +def write_to_weaviate_collection(urls=list[str]): + """Useful for writing new content to the WeaviateDocs collection""" + write_webpages_to_weaviate(client, urls, "WeaviateDocs") + + +def write_to_li_collection(urls=list[str]): + """Useful for writing new content to the LlamaIndexDocs collection""" + write_webpages_to_weaviate(client, urls, "LlamaIndexDocs") + + +def query_agent(query: str) -> str: + """Useful for asking questions about Weaviate and LlamaIndex""" + response = weaviate_agent.run(query) + return response.final_answer + + +agent = FunctionAgent( + tools=[write_to_weaviate_collection, write_to_li_collection, query_agent], + llm=llm, + system_prompt="""You are a helpful assistant that can write the + contents of urls to WeaviateDocs and LlamaIndexDocs collections, + as well as forwarding questions to a QueryAgent""", +) +``` + + +```python +response = await agent.run( + user_msg="Can you save https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic/" +) +print(str(response)) +``` + + +```python +response = await agent.run( + user_msg="""What are llama index workflows? And can you save + these to weaviate docs: https://weaviate.io/blog/what-are-agentic-workflows + and https://weaviate.io/blog/ai-agents""" +) +print(str(response)) +``` + + Llama Index workflows refer to orchestrations involving one or more AI agents within the LlamaIndex framework. These workflows manage complex tasks dynamically by leveraging components such as large language models (LLMs), tools, and memory states. Key features of Llama Index workflows include: + + - Support for single or multiple agents managed within an AgentWorkflow orchestrator. + - Ability to maintain state across runs via serializable context objects. + - Integration of external tools with type annotations, including asynchronous functions. + - Streaming of intermediate outputs and event-based interactions. + - Human-in-the-loop capabilities to confirm or guide agent actions during workflow execution. + + These workflows enable agents to execute sequences of operations, call external tools asynchronously, maintain conversation or task states, stream partial results, and incorporate human inputs when necessary. They embody dynamic, agent-driven sequences of task decomposition, tool use, and reflection, allowing AI systems to plan, act, and improve iteratively toward specific goals. + + I have also saved the contents from the provided URLs to the WeaviateDocs collection. + + + +```python +response = await agent.run( + user_msg="How many docs do I have in the weaviate and llamaindex collections in total?" +) +print(str(response)) +``` + + You have a total of 2 documents in the WeaviateDocs collection and 1 document in the LlamaIndexDocs collection. In total, that makes 3 documents across both collections. + + + +```python +weaviate_agent = fresh_setup_weaviate(client) +``` + +## Create a Workflow with Branches + +### Simple Example: Create Events + +A LlamaIndex Workflow has 2 fundamentals: +- An Event +- A Step + +An step may return an event, and an event may trigger a step! + +For our use-case, we can imagine thet there are 4 events: + + +```python +class EvaluateQuery(Event): + query: str + + +class WriteLlamaIndexDocsEvent(Event): + urls: list[str] + + +class WriteWeaviateDocsEvent(Event): + urls: list[str] + + +class QueryAgentEvent(Event): + query: str +``` + +### Simple Example: A Branching Workflow (that does nothing yet) + + +```python +class DocsAssistantWorkflow(Workflow): + @step + async def start(self, ctx: Context, ev: StartEvent) -> EvaluateQuery: + return EvaluateQuery(query=ev.query) + + @step + async def evaluate_query( + self, ctx: Context, ev: EvaluateQuery + ) -> QueryAgentEvent | WriteLlamaIndexDocsEvent | WriteWeaviateDocsEvent | StopEvent: + if ev.query == "llama": + return WriteLlamaIndexDocsEvent(urls=[ev.query]) + if ev.query == "weaviate": + return WriteWeaviateDocsEvent(urls=[ev.query]) + if ev.query == "question": + return QueryAgentEvent(query=ev.query) + return StopEvent() + + @step + async def write_li_docs( + self, ctx: Context, ev: WriteLlamaIndexDocsEvent + ) -> StopEvent: + print(f"Got a request to write something to LlamaIndexDocs") + return StopEvent() + + @step + async def write_weaviate_docs( + self, ctx: Context, ev: WriteWeaviateDocsEvent + ) -> StopEvent: + print(f"Got a request to write something to WeaviateDocs") + return StopEvent() + + @step + async def query_agent( + self, ctx: Context, ev: QueryAgentEvent + ) -> StopEvent: + print(f"Got a request to forward a query to the QueryAgent") + return StopEvent() +``` + + +```python +workflow_that_does_nothing = DocsAssistantWorkflow() + +# draw_all_possible_flows(workflow_that_does_nothing) +``` + + +```python +print( + await workflow_that_does_nothing.run(start_event=StartEvent(query="llama")) +) +``` + + Got a request to write something to LlamaIndexDocs + None + + +### Classify the Query with Structured Outputs + + +```python +class SaveToLlamaIndexDocs(BaseModel): + """The URLs to parse and save into a llama-index specific docs collection.""" + + llama_index_urls: List[str] = Field(default_factory=list) + + +class SaveToWeaviateDocs(BaseModel): + """The URLs to parse and save into a weaviate specific docs collection.""" + + weaviate_urls: List[str] = Field(default_factory=list) + + +class Ask(BaseModel): + """The natural language questions that can be asked to a Q&A agent.""" + + queries: List[str] = Field(default_factory=list) + + +class Actions(BaseModel): + """Actions to take based on the latest user message.""" + + actions: List[ + Union[SaveToLlamaIndexDocs, SaveToWeaviateDocs, Ask] + ] = Field(default_factory=list) +``` + +#### Create a Workflow + +Let's create a workflow that, still, does nothing, but the incoming user query will be converted to our structure. Based on the contents of that structure, the workflow will decide which step to run. + +Notice how whichever step runs first, will return a `StopEvent`... This is good, but maybe we can improve that later! + + +```python +from llama_index.llms.openai import OpenAIResponses + + +class DocsAssistantWorkflow(Workflow): + def __init__(self, *args, **kwargs): + self.llm = OpenAIResponses(model="gpt-4.1-mini") + self.system_prompt = """You are a docs assistant. You evaluate incoming queries and break them down to subqueries when needed. + You decide on the next best course of action. Overall, here are the options: + - You can write the contents of a URL to llamaindex docs (if it's a llamaindex url) + - You can write the contents of a URL to weaviate docs (if it's a weaviate url) + - You can answer a question about llamaindex and weaviate using the QueryAgent""" + super().__init__(*args, **kwargs) + + @step + async def start(self, ev: StartEvent) -> EvaluateQuery: + return EvaluateQuery(query=ev.query) + + @step + async def evaluate_query( + self, ev: EvaluateQuery + ) -> QueryAgentEvent | WriteLlamaIndexDocsEvent | WriteWeaviateDocsEvent: + sllm = self.llm.as_structured_llm(Actions) + response = await sllm.achat( + [ + ChatMessage(role="system", content=self.system_prompt), + ChatMessage(role="user", content=ev.query), + ] + ) + actions = response.raw.actions + print(actions) + for action in actions: + if isinstance(action, SaveToLlamaIndexDocs): + return WriteLlamaIndexDocsEvent(urls=action.llama_index_urls) + elif isinstance(action, SaveToWeaviateDocs): + return WriteWeaviateDocsEvent(urls=action.weaviate_urls) + elif isinstance(action, Ask): + for query in action.queries: + return QueryAgentEvent(query=query) + + @step + async def write_li_docs(self, ev: WriteLlamaIndexDocsEvent) -> StopEvent: + print(f"Writing {ev.urls} to LlamaIndex Docs") + return StopEvent() + + @step + async def write_weaviate_docs( + self, ev: WriteWeaviateDocsEvent + ) -> StopEvent: + print(f"Writing {ev.urls} to Weaviate Docs") + return StopEvent() + + @step + async def query_agent(self, ev: QueryAgentEvent) -> StopEvent: + print(f"Sending `'{ev.query}`' to agent") + return StopEvent() + + +everything_docs_agent_beta = DocsAssistantWorkflow() +``` + + +```python +async def run_docs_agent_beta(query: str): + print( + await everything_docs_agent_beta.run( + start_event=StartEvent(query=query) + ) + ) +``` + + +```python +await run_docs_agent_beta( + """Can you save https://www.llamaindex.ai/blog/get-citations-and-reasoning-for-extracted-data-in-llamaextract + and https://www.llamaindex.ai/blog/llamaparse-update-may-2025-new-models-skew-detection-and-more??""" +) +``` + + [SaveToLlamaIndexDocs(llama_index_urls=['https://www.llamaindex.ai/blog/get-citations-and-reasoning-for-extracted-data-in-llamaextract', 'https://www.llamaindex.ai/blog/llamaparse-update-may-2025-new-models-skew-detection-and-more'])] + Writing ['https://www.llamaindex.ai/blog/get-citations-and-reasoning-for-extracted-data-in-llamaextract', 'https://www.llamaindex.ai/blog/llamaparse-update-may-2025-new-models-skew-detection-and-more'] to LlamaIndex Docs + None + + + +```python +await run_docs_agent_beta( + "How many documents do we have in the LlamaIndexDocs collection now?" +) +``` + + [Ask(queries=['How many documents are in the LlamaIndexDocs collection?'])] + Sending `'How many documents are in the LlamaIndexDocs collection?`' to agent + None + + + +```python +await run_docs_agent_beta("What are LlamaIndex workflows?") +``` + + [Ask(queries=['What are LlamaIndex workflows?'])] + Sending `'What are LlamaIndex workflows?`' to agent + None + + + +```python +await run_docs_agent_beta( + "Can you save https://weaviate.io/blog/graph-rag and https://weaviate.io/blog/genai-apps-with-weaviate-and-databricks??" +) +``` + + [SaveToWeaviateDocs(weaviate_urls=['https://weaviate.io/blog/graph-rag', 'https://weaviate.io/blog/genai-apps-with-weaviate-and-databricks'])] + Writing ['https://weaviate.io/blog/graph-rag', 'https://weaviate.io/blog/genai-apps-with-weaviate-and-databricks'] to Weaviate Docs + None + + +## Run Multiple Branches & Put it all togehter + +In these cases, it makes sense to run multiple branches. So, a single step can trigger multiple events at once! We can `send_event` via the context 👇 + + +```python +class ActionCompleted(Event): + result: str + + +class DocsAssistantWorkflow(Workflow): + def __init__(self, *args, **kwargs): + self.llm = OpenAIResponses(model="gpt-4.1-mini") + self.system_prompt = """You are a docs assistant. You evaluate incoming queries and break them down to subqueries when needed. + You decide on the next best course of action. Overall, here are the options: + - You can write the contents of a URL to llamaindex docs (if it's a llamaindex url) + - You can write the contents of a URL to weaviate docs (if it's a weaviate url) + - You can answer a question about llamaindex and weaviate using the QueryAgent""" + super().__init__(*args, **kwargs) + + @step + async def start(self, ctx: Context, ev: StartEvent) -> EvaluateQuery: + return EvaluateQuery(query=ev.query) + + @step + async def evaluate_query( + self, ctx: Context, ev: EvaluateQuery + ) -> QueryAgentEvent | WriteLlamaIndexDocsEvent | WriteWeaviateDocsEvent | None: + await ctx.store.set("results", []) + sllm = self.llm.as_structured_llm(Actions) + response = await sllm.achat( + [ + ChatMessage(role="system", content=self.system_prompt), + ChatMessage(role="user", content=ev.query), + ] + ) + actions = response.raw.actions + await ctx.store.set("num_events", len(actions)) + await ctx.store.set("results", []) + print(actions) + for action in actions: + if isinstance(action, SaveToLlamaIndexDocs): + ctx.send_event( + WriteLlamaIndexDocsEvent(urls=action.llama_index_urls) + ) + elif isinstance(action, SaveToWeaviateDocs): + ctx.send_event( + WriteWeaviateDocsEvent(urls=action.weaviate_urls) + ) + elif isinstance(action, Ask): + for query in action.queries: + ctx.send_event(QueryAgentEvent(query=query)) + + @step + async def write_li_docs( + self, ctx: Context, ev: WriteLlamaIndexDocsEvent + ) -> ActionCompleted: + print(f"Writing {ev.urls} to LlamaIndex Docs") + write_webpages_to_weaviate( + client, urls=ev.urls, collection_name="LlamaIndexDocs" + ) + results = await ctx.store.get("results") + results.append(f"Wrote {ev.urls} it LlamaIndex Docs") + return ActionCompleted(result=f"Writing {ev.urls} to LlamaIndex Docs") + + @step + async def write_weaviate_docs( + self, ctx: Context, ev: WriteWeaviateDocsEvent + ) -> ActionCompleted: + print(f"Writing {ev.urls} to Weaviate Docs") + write_webpages_to_weaviate( + client, urls=ev.urls, collection_name="WeaviateDocs" + ) + results = await ctx.store.get("results") + results.append(f"Wrote {ev.urls} it Weavite Docs") + return ActionCompleted(result=f"Writing {ev.urls} to Weaviate Docs") + + @step + async def query_agent( + self, ctx: Context, ev: QueryAgentEvent + ) -> ActionCompleted: + print(f"Sending {ev.query} to agent") + response = weaviate_agent.run(ev.query) + results = await ctx.store.get("results") + results.append(f"QueryAgent responded with:\n {response.final_answer}") + return ActionCompleted(result=f"Sending `'{ev.query}`' to agent") + + @step + async def collect( + self, ctx: Context, ev: ActionCompleted + ) -> StopEvent | None: + num_events = await ctx.store.get("num_events") + evs = ctx.collect_events(ev, [ActionCompleted] * num_events) + if evs is None: + return None + return StopEvent(result=[ev.result for ev in evs]) + + +everything_docs_agent = DocsAssistantWorkflow(timeout=None) +``` + + +```python +async def run_docs_agent(query: str): + handler = everything_docs_agent.run(start_event=StartEvent(query=query)) + result = await handler + for response in await handler.ctx.get("results"): + print(response) +``` + + +```python +await run_docs_agent( + "Can you save https://docs.llamaindex.ai/en/stable/understanding/workflows/ and https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/" +) +``` + + [SaveToLlamaIndexDocs(llama_index_urls=['https://docs.llamaindex.ai/en/stable/understanding/workflows/']), SaveToLlamaIndexDocs(llama_index_urls=['https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/'])] + Writing ['https://docs.llamaindex.ai/en/stable/understanding/workflows/'] to LlamaIndex Docs + Writing ['https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/'] to LlamaIndex Docs + Wrote ['https://docs.llamaindex.ai/en/stable/understanding/workflows/'] it LlamaIndex Docs + Wrote ['https://docs.llamaindex.ai/en/stable/understanding/workflows/branches_and_loops/'] it LlamaIndex Docs + + + +```python +await run_docs_agent( + "How many documents do we have in the LlamaIndexDocs collection now?" +) +``` + + [Ask(queries=['How many documents are in the LlamaIndexDocs collection?'])] + Sending How many documents are in the LlamaIndexDocs collection? to agent + QueryAgent responded with: + The LlamaIndexDocs collection contains 2 documents, specifically related to workflows and branches and loops within the documentation. + + + +```python +await run_docs_agent( + "What are LlamaIndex workflows? And can you save https://weaviate.io/blog/graph-rag" +) +``` + + [Ask(queries=['What are LlamaIndex workflows?'])] + Sending What are LlamaIndex workflows? to agent + QueryAgent responded with: + LlamaIndex workflows are an event-driven, step-based framework designed to control and manage the execution flow of complex applications, particularly those involving generative AI. They break an application into discrete Steps, each triggered by Events and capable of emitting further Events, allowing for complex logic involving loops, branches, and parallel execution. + + In a LlamaIndex workflow, steps perform functions ranging from simple tasks to complex agents, with inputs and outputs communicated via Events. This event-driven model facilitates maintainability and clarity, overcoming limitations of previous approaches like directed acyclic graphs (DAGs) which struggled with complex flows involving loops and branching. + + Key features include: + - **Loops:** Steps can return events that loop back to previous steps to enable iterative processes. + - **Branches:** Workflows can branch into different paths based on conditions, allowing for multiple distinct sequences of steps. + - **Parallelism:** Multiple branches or steps can run concurrently and synchronize their results. + - **State Maintenance:** Workflows support maintaining state and context throughout execution. + - **Observability and Debugging:** Supported by various components and callbacks for monitoring. + + An example workflow might involve judging whether a query is of sufficient quality, looping to improve it if not, then concurrently executing different retrieval-augmented generation (RAG) strategies, and finally judging their responses to produce a single output. + + Workflows are especially useful as applications grow in complexity, enabling developers to organize and control intricate AI logic more naturally and efficiently than traditional graph-based methods. For simpler pipelines, LlamaIndex suggests using workflows optionally, but for advanced agentic applications, workflows provide a flexible and powerful control abstraction. + + + +```python +await run_docs_agent("How do I use loops in llamaindex workflows?") +``` + + [Ask(queries=['How to use loops in llamaindex workflows'])] + Sending How to use loops in llamaindex workflows to agent + QueryAgent responded with: + In LlamaIndex workflows, loops are implemented using an event-driven approach where you define custom event types and steps that emit events to control the workflow's execution flow. To create a loop, you define a custom event (e.g., `LoopEvent`) and a workflow step that can return either the event continuing the loop or another event to proceed. For example, a workflow step might randomly decide to either loop back (emit `LoopEvent` again) or continue to a next step emitting a different event. + + This allows creating flexible looping behaviors where any step can loop back to any other step by returning the corresponding event instances. The approach leverages Python's async functions decorated with `@step`, which process events and return the next event(s), enabling both loops and conditional branching in workflows. + + Thus, loops in LlamaIndex workflows are event-based, using custom event types and the return of events from steps to signal iterations until a condition is met. + + Example: + + ```python + from llamaindex.workflow import Workflow, Event, StartEvent, StopEvent, step + import random + + class LoopEvent(Event): + loop_output: str + + class FirstEvent(Event): + first_output: str + + class MyWorkflow(Workflow): + @step + async def step_one(self, ev: StartEvent | LoopEvent) -> FirstEvent | LoopEvent: + if random.randint(0, 1) == 0: + print("Bad thing happened") + return LoopEvent(loop_output="Back to step one.") + else: + print("Good thing happened") + return FirstEvent(first_output="First step complete.") + + # ... other steps ... + + # Running this workflow will cause step_one to loop randomly until it proceeds. + ``` + + You can combine loops with branching and parallel execution in workflows to build complex control flows. For detailed guidance and examples, consult the LlamaIndex documentation under "Branches and Loops" and the "Workflows" guides. + diff --git a/markdowns/Agent/multi_document_agents-v1.md b/markdowns/Agent/multi_document_agents-v1.md new file mode 100644 index 0000000..2ebf84c --- /dev/null +++ b/markdowns/Agent/multi_document_agents-v1.md @@ -0,0 +1,591 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/multi_document_agents-v1.ipynb +toc: True +title: "Multi-Document Agents (V1)" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +In this guide, you learn towards setting up a multi-document agent over the LlamaIndex documentation. + +This is an extension of V0 multi-document agents with the additional features: +- Reranking during document (tool) retrieval +- Query planning tool that the agent can use to plan + + +We do this with the following architecture: + +- setup a "document agent" over each Document: each doc agent can do QA/summarization within its doc +- setup a top-level agent over this set of document agents. Do tool retrieval and then do CoT over the set of tools to answer a question. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index-core +%pip install llama-index-agent-openai +%pip install llama-index-readers-file +%pip install llama-index-postprocessor-cohere-rerank +%pip install llama-index-llms-openai +%pip install llama-index-embeddings-openai +%pip install unstructured[html] +``` + + +```python +%load_ext autoreload +%autoreload 2 +``` + +## Setup and Download Data + +In this section, we'll load in the LlamaIndex documentation. + +**NOTE:** This command will take a while to run, it will download the entire LlamaIndex documentation. In my testing, this took about 15 minutes. + + +```python +domain = "docs.llamaindex.ai" +docs_url = "https://docs.llamaindex.ai/en/latest/" +!wget -e robots=off --recursive --no-clobber --page-requisites --html-extension --convert-links --restrict-file-names=windows --domains {domain} --no-parent {docs_url} +``` + + +```python +from llama_index.readers.file import UnstructuredReader + +reader = UnstructuredReader() +``` + + +```python +from pathlib import Path + +all_files_gen = Path("./docs.llamaindex.ai/").rglob("*") +all_files = [f.resolve() for f in all_files_gen] +``` + + +```python +all_html_files = [f for f in all_files if f.suffix.lower() == ".html"] +``` + + +```python +len(all_html_files) +``` + + + + + 1656 + + + + +```python +useful_files = [ + x + for x in all_html_files + if "understanding" in str(x).split(".")[-2] + or "examples" in str(x).split(".")[-2] +] +print(len(useful_files)) +``` + + 680 + + + +```python +from llama_index.core import Document + +# TODO: set to higher value if you want more docs to be indexed +doc_limit = 100 + +docs = [] +for idx, f in enumerate(useful_files): + if idx > doc_limit: + break + print(f"Idx {idx}/{len(useful_files)}") + loaded_docs = reader.load_data(file=f, split_documents=True) + + loaded_doc = Document( + text="\n\n".join([d.get_content() for d in loaded_docs]), + metadata={"path": str(f)}, + ) + print(loaded_doc.metadata["path"]) + docs.append(loaded_doc) +``` + + +```python +print(len(docs)) +``` + + 101 + + +Define Global LLM + Embeddings + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +llm = OpenAI(model="gpt-4o") +Settings.llm = llm +Settings.embed_model = OpenAIEmbedding( + model="text-embedding-3-small", embed_batch_size=256 +) +``` + +## Building Multi-Document Agents + +In this section we show you how to construct the multi-document agent. We first build a document agent for each document, and then define the top-level parent agent with an object index. + +### Build Document Agent for each Document + +In this section we define "document agents" for each document. + +We define both a vector index (for semantic search) and summary index (for summarization) for each document. The two query engines are then converted into tools that are passed to an OpenAI function calling agent. + +This document agent can dynamically choose to perform semantic search or summarization within a given document. + +We create a separate document agent for each city. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent +from llama_index.core import ( + load_index_from_storage, + StorageContext, + VectorStoreIndex, +) +from llama_index.core import SummaryIndex +from llama_index.core.tools import QueryEngineTool +from llama_index.core.node_parser import SentenceSplitter +import os +from tqdm.notebook import tqdm +import pickle + + +async def build_agent_per_doc(nodes, file_base): + vi_out_path = f"./data/llamaindex_docs/{file_base}" + summary_out_path = f"./data/llamaindex_docs/{file_base}_summary.pkl" + if not os.path.exists(vi_out_path): + Path("./data/llamaindex_docs/").mkdir(parents=True, exist_ok=True) + # build vector index + vector_index = VectorStoreIndex(nodes) + vector_index.storage_context.persist(persist_dir=vi_out_path) + else: + vector_index = load_index_from_storage( + StorageContext.from_defaults(persist_dir=vi_out_path), + ) + + # build summary index + summary_index = SummaryIndex(nodes) + + # define query engines + vector_query_engine = vector_index.as_query_engine(llm=llm) + summary_query_engine = summary_index.as_query_engine( + response_mode="tree_summarize", llm=llm + ) + + # extract a summary + if not os.path.exists(summary_out_path): + Path(summary_out_path).parent.mkdir(parents=True, exist_ok=True) + summary = str( + await summary_query_engine.aquery( + "Extract a concise 1-2 line summary of this document" + ) + ) + pickle.dump(summary, open(summary_out_path, "wb")) + else: + summary = pickle.load(open(summary_out_path, "rb")) + + # define tools + query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=vector_query_engine, + name=f"vector_tool_{file_base}", + description=f"Useful for questions related to specific facts", + ), + QueryEngineTool.from_defaults( + query_engine=summary_query_engine, + name=f"summary_tool_{file_base}", + description=f"Useful for summarization questions", + ), + ] + + # build agent + function_llm = OpenAI(model="gpt-4") + agent = FunctionAgent( + tools=query_engine_tools, + llm=function_llm, + system_prompt=f"""\ +You are a specialized agent designed to answer queries about the `{file_base}.html` part of the LlamaIndex docs. +You must ALWAYS use at least one of the tools provided when answering a question; do NOT rely on prior knowledge.\ +""", + ) + + return agent, summary + + +async def build_agents(docs): + node_parser = SentenceSplitter() + + # Build agents dictionary + agents_dict = {} + extra_info_dict = {} + + # # this is for the baseline + # all_nodes = [] + + for idx, doc in enumerate(tqdm(docs)): + nodes = node_parser.get_nodes_from_documents([doc]) + # all_nodes.extend(nodes) + + # ID will be base + parent + file_path = Path(doc.metadata["path"]) + file_base = str(file_path.parent.stem) + "_" + str(file_path.stem) + agent, summary = await build_agent_per_doc(nodes, file_base) + + agents_dict[file_base] = agent + extra_info_dict[file_base] = {"summary": summary, "nodes": nodes} + + return agents_dict, extra_info_dict +``` + + +```python +agents_dict, extra_info_dict = await build_agents(docs) +``` + +### Build Retriever-Enabled OpenAI Agent + +We build a top-level agent that can orchestrate across the different document agents to answer any user query. + +This agent will use a tool retriever to retrieve the most relevant tools for the query. + +**Improvements from V0**: We make the following improvements compared to the "base" version in V0. + +- Adding in reranking: we use Cohere reranker to better filter the candidate set of documents. +- Adding in a query planning tool: we add an explicit query planning tool that's dynamically created based on the set of retrieved tools. + + + +```python +from typing import Callable +from llama_index.core.tools import FunctionTool + + +def get_agent_tool_callable(agent: FunctionAgent) -> Callable: + async def query_agent(query: str) -> str: + response = await agent.run(query) + return str(response) + + return query_agent + + +# define tool for each document agent +all_tools = [] +for file_base, agent in agents_dict.items(): + summary = extra_info_dict[file_base]["summary"] + async_fn = get_agent_tool_callable(agent) + doc_tool = FunctionTool.from_defaults( + async_fn, + name=f"tool_{file_base}", + description=summary, + ) + all_tools.append(doc_tool) +``` + + +```python +print(all_tools[0].metadata) +``` + + ToolMetadata(description='The document provides a series of tutorials on building agentic LLM applications using LlamaIndex, covering key steps such as building RAG pipelines, agents, and workflows, along with techniques for data ingestion, indexing, querying, and application evaluation.', name='tool_understanding_index', fn_schema=, return_direct=False) + + + +```python +# define an "object" index and retriever over these tools +from llama_index.core import VectorStoreIndex +from llama_index.core.objects import ( + ObjectIndex, + ObjectRetriever, +) +from llama_index.postprocessor.cohere_rerank import CohereRerank +from llama_index.core.query_engine import SubQuestionQueryEngine +from llama_index.core.schema import QueryBundle +from llama_index.llms.openai import OpenAI + + +llm = OpenAI(model_name="gpt-4o") + +obj_index = ObjectIndex.from_objects( + all_tools, + index_cls=VectorStoreIndex, +) +vector_node_retriever = obj_index.as_node_retriever( + similarity_top_k=10, +) + + +# define a custom object retriever that adds in a query planning tool +class CustomObjectRetriever(ObjectRetriever): + def __init__( + self, + retriever, + object_node_mapping, + node_postprocessors=None, + llm=None, + ): + self._retriever = retriever + self._object_node_mapping = object_node_mapping + self._llm = llm or OpenAI("gpt-4o") + self._node_postprocessors = node_postprocessors or [] + + def retrieve(self, query_bundle): + if isinstance(query_bundle, str): + query_bundle = QueryBundle(query_str=query_bundle) + + nodes = self._retriever.retrieve(query_bundle) + for processor in self._node_postprocessors: + nodes = processor.postprocess_nodes( + nodes, query_bundle=query_bundle + ) + tools = [self._object_node_mapping.from_node(n.node) for n in nodes] + + sub_agent = FunctionAgent( + name="compare_tool", + description=f"""\ +Useful for any queries that involve comparing multiple documents. ALWAYS use this tool for comparison queries - make sure to call this \ +tool with the original query. Do NOT use the other tools for any queries involving multiple documents. +""", + tools=tools, + llm=self._llm, + system_prompt="""You are an expert at comparing documents. Given a query, use the tools provided to compare the documents and return a summary of the results.""", + ) + + async def query_sub_agent(query: str) -> str: + response = await sub_agent.run(query) + return str(response) + + sub_question_tool = FunctionTool.from_defaults( + query_sub_agent, + name=sub_agent.name, + description=sub_agent.description, + ) + return tools + [sub_question_tool] +``` + + +```python +# wrap it with ObjectRetriever to return objects +custom_obj_retriever = CustomObjectRetriever( + vector_node_retriever, + obj_index.object_node_mapping, + node_postprocessors=[CohereRerank(top_n=5, model="rerank-v3.5")], + llm=llm, +) +``` + + +```python +tmps = custom_obj_retriever.retrieve("hello") + +# should be 5 + 1 -- 5 from reranker, 1 from subquestion +print(len(tmps)) +``` + + 6 + + + +```python +from llama_index.core.agent.workflow import ReActAgent, FunctionAgent + +top_agent = FunctionAgent( + tool_retriever=custom_obj_retriever, + system_prompt=""" \ +You are an agent designed to answer queries about the documentation. +Please always use the tools provided to answer a question. Do not rely on prior knowledge.\ + +""", + llm=llm, +) + +# top_agent = ReActAgent( +# tool_retriever=custom_obj_retriever, +# system_prompt=""" \ +# You are an agent designed to answer queries about the documentation. +# Please always use the tools provided to answer a question. Do not rely on prior knowledge.\ + +# """, +# llm=llm, +# ) +``` + +### Define Baseline Vector Store Index + +As a point of comparison, we define a "naive" RAG pipeline which dumps all docs into a single vector index collection. + +We set the top_k = 4 + + +```python +all_nodes = [ + n for extra_info in extra_info_dict.values() for n in extra_info["nodes"] +] +``` + + +```python +base_index = VectorStoreIndex(all_nodes) +base_query_engine = base_index.as_query_engine(similarity_top_k=4) +``` + +## Running Example Queries + +Let's run some example queries, ranging from QA / summaries over a single document to QA / summarization over multiple documents. + + +```python +from llama_index.core.agent.workflow import ( + AgentStream, + ToolCall, + ToolCallResult, +) + +handler = top_agent.run( + "What can you build with LlamaIndex?", +) +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalling tool {ev.tool_name} with args {ev.tool_kwargs}\n Got response: {str(ev.tool_output)[:200]}" + ) + elif isinstance(ev, ToolCall): + print(f"\nTool call: {ev.tool_name} with args {ev.tool_kwargs}") + # Print the stream of the agent + # elif isinstance(ev, AgentStream): + # print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Tool call: tool_SimpleIndexDemoLlama2_index with args {'query': 'What can you build with LlamaIndex?'} + + Tool call: tool_apps_index with args {'query': 'What can you build with LlamaIndex?'} + + Tool call: tool_putting_it_all_together_index with args {'query': 'What can you build with LlamaIndex?'} + + Tool call: tool_llamacloud_index with args {'query': 'What can you build with LlamaIndex?'} + + Calling tool tool_SimpleIndexDemoLlama2_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a VectorStoreIndex. This involves setting up the necessary environment, loading documents into the index, and then querying the index for information. You need to instal + + Tool call: tool_using_llms_index with args {'query': 'What can you build with LlamaIndex?'} + + Calling tool tool_llamacloud_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a system that connects to your data stores, automatically indexes them, and then queries the data. This is done by integrating LlamaCloud into your project. The system a + + Calling tool tool_apps_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a full-stack web application. You can integrate it into a backend server like Flask, package it into a Docker container, or use it directly in a framework such as Stream + + Calling tool tool_putting_it_all_together_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a variety of applications and tools. This includes: + + 1. Chatbots: You can use LlamaIndex to create interactive chatbots. + 2. Agents: LlamaIndex can be used to build intel + + Calling tool tool_using_llms_index with args {'query': 'What can you build with LlamaIndex?'} + Got response: With LlamaIndex, you can build a variety of applications by leveraging the various Language Model (LLM) integrations it supports. These include OpenAI, Anthropic, Mistral, DeepSeek, Hugging Face, and + + + +```python +# print the final response string +print(str(response)) +``` + + With LlamaIndex, you can build various applications and tools, including: + + 1. **VectorStoreIndex**: Set up and query a VectorStoreIndex by loading documents and configuring the environment as per the documentation. + + 2. **Full-Stack Web Applications**: Integrate LlamaIndex into backend servers like Flask, Docker containers, or frameworks like Streamlit. Resources include guides for TypeScript+React, Delphic starter template, and Flask, Streamlit, and Docker integration examples. + + 3. **Chatbots, Agents, and Unified Query Framework**: Create interactive chatbots, intelligent agents, and a unified query framework for handling different query types. LlamaIndex also supports property graphs and full-stack web applications. + + 4. **Data Management with LlamaCloud**: Build systems that connect to data stores, automatically index data, and efficiently query it by integrating LlamaCloud into your project. + + 5. **LLM Integrations**: Utilize various Language Model (LLM) integrations such as OpenAI, Anthropic, Mistral, DeepSeek, and Hugging Face. LlamaIndex provides a unified interface to access different LLMs, enabling you to select models based on their strengths and price points. You can use multi-modal LLMs for chat messages with text, images, and audio inputs, and even call tools and functions directly through API calls. + + These capabilities make LlamaIndex a versatile tool for building a wide range of applications and systems. + + + +```python +# access the tool calls +# print(response.tool_calls) +``` + + +```python +# baseline +response = base_query_engine.query( + "What can you build with LlamaIndex?", +) +print(str(response)) +``` + + With LlamaIndex, you can build a variety of applications and systems, including a full-stack web application, a chatbot, and a unified query framework over multiple indexes. You can also perform semantic searches, summarization queries, and queries over structured data like SQL or Pandas DataFrames. Additionally, LlamaIndex supports routing over heterogeneous data sources and compare/contrast queries. It provides tools and templates to help you integrate these capabilities into production-ready applications. + + + +```python +response = await top_agent.run("Compare workflows to query engines") +print(str(response)) +``` + + Workflows and query engines serve different purposes in an application context: + + 1. Workflows: + - Workflows are designed to manage the execution flow of an application by dividing it into sections triggered by events. + - They are event-driven and step-based, allowing for the management of application complexity by breaking it into smaller, more manageable pieces. + - Workflows focus on controlling the flow of application execution through steps and events. + + 2. Query Engines: + - Query engines are tools used to process queries against a database or data source to retrieve specific information. + - They are primarily used for querying and retrieving data from databases. + - Query engines are focused on the retrieval, postprocessing, and response synthesis stages of querying. + + In summary, workflows are more about controlling the flow of application execution, while query engines are specifically designed for querying and retrieving data from databases. + + + +```python +response = await top_agent.run( + "Can you compare the compact and tree_summarize response synthesizer response modes at a very high-level?" +) +print(str(response)) +``` + + The compact response synthesizer mode aims to produce concise and condensed responses, focusing on delivering the most relevant information in a brief format. On the other hand, the tree_summarize response synthesizer mode is designed to create structured and summarized responses, organizing information in a comprehensive manner. + + In summary, the compact mode provides brief and straightforward responses, while the tree_summarize mode offers more detailed and organized output for a comprehensive summary. + diff --git a/markdowns/Agent/nvidia_agent.md b/markdowns/Agent/nvidia_agent.md new file mode 100644 index 0000000..9d75b5c --- /dev/null +++ b/markdowns/Agent/nvidia_agent.md @@ -0,0 +1,224 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/nvidia_agent.ipynb +toc: True +title: "Function Calling NVIDIA Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +This notebook shows you how to use our NVIDIA agent, powered by function calling capabilities. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the NVIDIA NIM Endpoint (using our own `llama_index` LLM class) +2. a place to keep conversation history +3. a definition for tools that our agent can use. + + +```python +%pip install --upgrade --quiet llama-index-llms-nvidia +``` + + +```python +import getpass +import os + +# del os.environ['NVIDIA_API_KEY'] ## delete key and reset +if os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"): + print("Valid NVIDIA_API_KEY already in environment. Delete to reset") +else: + nvapi_key = getpass.getpass("NVAPI Key (starts with nvapi-): ") + assert nvapi_key.startswith( + "nvapi-" + ), f"{nvapi_key[:5]}... is not a valid key" + os.environ["NVIDIA_API_KEY"] = nvapi_key +``` + + Valid NVIDIA_API_KEY already in environment. Delete to reset + + + +```python +from llama_index.llms.nvidia import NVIDIA +from llama_index.core.tools import FunctionTool +from llama_index.embeddings.nvidia import NVIDIAEmbedding +``` + +Let's define some very simple calculator tools for our agent. + + +```python +def multiply(a: int, b: int) -> int: + """Multiple two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +Here we initialize a simple NVIDIA agent with calculator functions. + + +```python +llm = NVIDIA("meta/llama-3.1-70b-instruct") +``` + + +```python +from llama_index.core.agent.workflow import FunctionAgent + +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, +) +``` + +### Chat + + +```python +response = await agent.run("What is (121 * 3) + 42?") +print(str(response)) +``` + + +```python +# inspect sources +print(response.tool_calls) +``` + +### Managing Context/Memory + +By default, `.run()` is stateless. If you want to maintain state, you can pass in a `context` object. + + +```python +from llama_index.core.agent.workflow import Context + +ctx = Context(agent) + +response = await agent.run("Hello, my name is John Doe.", ctx=ctx) +print(str(response)) + +response = await agent.run("What is my name?", ctx=ctx) +print(str(response)) +``` + +### Agent with Personality + +You can specify a system prompt to give the agent additional instruction or personality. + + +```python +agent = FunctionAgent( + tools=[multiply, add], + llm=llm, + system_prompt="Talk like a pirate in every response.", +) +``` + + +```python +response = await agent.run("Hi") +print(response) +``` + + +```python +response = await agent.run("Tell me a story") +print(response) +``` + +# NVIDIA Agent with RAG/Query Engine Tools + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex + +embed_model = NVIDIAEmbedding(model="NV-Embed-QA", truncate="END") + +# load data +uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] +).load_data() + +# build index +uber_index = VectorStoreIndex.from_documents( + uber_docs, embed_model=embed_model +) +uber_engine = uber_index.as_query_engine(similarity_top_k=3, llm=llm) +query_engine_tool = QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), +) +``` + + +```python +agent = FunctionAgent(tools=[query_engine_tool], llm=llm) +``` + + +```python +response = await agent.run( + "Tell me both the risk factors and tailwinds for Uber? Do two parallel tool calls." +) +print(str(response)) +``` + +# ReAct Agent + + +```python +from llama_index.core.agent.workflow import ReActAgent +``` + + +```python +agent = ReActAgent([multiply_tool, add_tool], llm=llm, verbose=True) +``` + +Using the `stream_events()` method, we can stream the response as it is generated to see the agent's thought process. + +The final response will have only the final answer. + + +```python +from llama_index.core.agent.workflow import AgentStream + +handler = agent.run("What is 20+(2*4)? Calculate step by step ") +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + +```python +print(str(response)) +``` + + +```python +print(response.tool_calls) +``` diff --git a/markdowns/Agent/nvidia_document_research_assistant_for_blog_creation.md b/markdowns/Agent/nvidia_document_research_assistant_for_blog_creation.md new file mode 100644 index 0000000..4f23d3d --- /dev/null +++ b/markdowns/Agent/nvidia_document_research_assistant_for_blog_creation.md @@ -0,0 +1,1011 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/nvidia_document_research_assistant_for_blog_creation.ipynb +toc: True +title: "Document Research Assistant for Blog Creation" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +[![ Click here to deploy.](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2qRrBuBdUGzzauhql87XCd7U1wR) + +Deploy with Launchables. Launchables are pre-configured, fully optimized environments that users can deploy with a single click. + +In this notebook, you will use an NVIDIA LLM NIM microservice (llama-3.3-70b) to generate a report on a given topic, and an NVIDIA NeMo Retriever embedding NIM (llama-3.2-nv-embedqa-1b-v2) for optimized text question-answering retrieval. Given a set of documents, LlamaIndex will create an Index which it can run queries against. + +You can get started by calling a hosted model's NIM API endpoint from the NVIDIA API catalog. Once you familiarize yourself with this blueprint, you may want to self-host models with NVIDIA NIM. + +The Blueprint provides a workflow architecture for automating and orchestrating the creation of well-researched, high-quality content. + +The user provides a set of tools (e.g., a query engine with data about San Francisco's budget) and a content request (e.g., a question for a blog post). The Agent then: +1. Generates an Outline: Deploys an agent to structure the blog post into an actionable outline. +2. Plans Research Questions: Another agent generates a list of questions necessary to address the outline effectively. +3. Parallel Research: Breaks the questions into discrete units that can be answered concurrently, using available tools for data collection. +4. Drafts the Content: A writer agent synthesizes the gathered answers into a cohesive blog post. +5. Performs Quality Assurance: A critic agent reviews the content for accuracy, coherence, and completeness, determining if revisions are necessary. +6. Iterative Refinement: If improvements are needed, the workflow repeats by generating additional questions and gathering more information until the desired quality is reached. + +This workflow combines modularity, automation, and iterative refinement to ensure the output meets the highest standards of quality. + +![image](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAEhUAAAg0CAYAAACgkkBoAAAAAXNSR0IArs4c6QACfBl0RVh0bXhmaWxlACUzQ214ZmlsZSUyMGhvc3QlM0QlMjJjb25mbHVlbmNlLm52aWRpYS5jb20lMjIlMjBhZ2VudCUzRCUyMk1vemlsbGElMkY1LjAlMjAoTWFjaW50b3NoJTNCJTIwSW50ZWwlMjBNYWMlMjBPUyUyMFglMjAxMF8xNV83KSUyMEFwcGxlV2ViS2l0JTJGNTM3LjM2JTIwKEtIVE1MJTJDJTIwbGlrZSUyMEdlY2tvKSUyMENocm9tZSUyRjEzMS4wLjAuMCUyMFNhZmFyaSUyRjUzNy4zNiUyMiUyMG1vZGlmaWVkJTNEJTIyMjAyNS0wMS0wM1QxOSUzQTU5JTNBMzguMzgyWiUyMiUyMGV0YWclM0QlMjJ0WEhxMmxSR3ZxTnJqMmFSZ3hKMyUyMiUyMHZlcnNpb24lM0QlMjIyNC40LjAlMjIlMjB0eXBlJTNEJTIyYXRsYXMlMjIlMjBwYWdlcyUzRCUyMjIlMjIlMjBzY2FsZSUzRCUyMjMlMjIlMjBib3JkZXIlM0QlMjI1MCUyMiUzRSUzQ214QXRsYXNMaWJyYXJpZXMlM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMTklMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMTglMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMTclMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMjklMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDUlMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMjglMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMTUlMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDglMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDklMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDElMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDclMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkE5NyUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTExMiUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTEwMyUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTExNiUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTExNCUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTExMSUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTEyMCUyMiUzRSUyMCUzQyUyRm14TGlicmFyeSUzRSUzQ214TGlicmFyeSUyMGlkJTNEJTIyQTk5JTIyJTNFJTIwJTNDJTJGbXhMaWJyYXJ5JTNFJTNDbXhMaWJyYXJ5JTIwaWQlM0QlMjJBMTAwJTIyJTNFJTIwJTNDJTJGbXhMaWJyYXJ5JTNFJTNDbXhMaWJyYXJ5JTIwaWQlM0QlMjJBMTA2JTIyJTNFJTIwJTNDJTJGbXhMaWJyYXJ5JTNFJTNDbXhMaWJyYXJ5JTIwaWQlM0QlMjJBOTglMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDIlMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMDQlMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0NteExpYnJhcnklMjBpZCUzRCUyMkExMTAlMjIlM0UlMjAlM0MlMkZteExpYnJhcnklM0UlM0MlMkZteEF0bGFzTGlicmFyaWVzJTNFJTI2JTIzeGElM0IlMjAlMjAlM0NkaWFncmFtJTIwaWQlM0QlMjJYQTg1OVNCWFJYQzB6RWRXZjRYYSUyMiUyMG5hbWUlM0QlMjJQYWdlLTElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUzQ214R3JhcGhNb2RlbCUyMGR4JTNEJTIyOTgxJTIyJTIwZHklM0QlMjI2MDklMjIlMjBncmlkJTNEJTIyMSUyMiUyMGdyaWRTaXplJTNEJTIyNiUyMiUyMGd1aWRlcyUzRCUyMjElMjIlMjB0b29sdGlwcyUzRCUyMjElMjIlMjBjb25uZWN0JTNEJTIyMSUyMiUyMGFycm93cyUzRCUyMjElMjIlMjBmb2xkJTNEJTIyMSUyMiUyMHBhZ2UlM0QlMjIxJTIyJTIwcGFnZVNjYWxlJTNEJTIyMSUyMiUyMHBhZ2VXaWR0aCUzRCUyMjE2MDAlMjIlMjBwYWdlSGVpZ2h0JTNEJTIyOTAwJTIyJTIwbWF0aCUzRCUyMjAlMjIlMjBzaGFkb3clM0QlMjIwJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlM0Nyb290JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMjAlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyMSUyMiUyMHBhcmVudCUzRCUyMjAlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaV9pV0s3ZkVXZ29ETEVwdUJ4bGEtMSUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0RvcnRob2dvbmFsRWRnZVN0eWxlJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDElM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZFNpemUlM0Q0JTNCc3RhcnRBcnJvdyUzRGJsb2NrJTNCc3RhcnRGaWxsJTNEMSUzQmVuZEFycm93JTNEbm9uZSUzQmVuZEZpbGwlM0QwJTNCc3Ryb2tlQ29sb3IlM0QlMjMwMDAwMDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB0YXJnZXQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0zMyUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjU0MCUyMiUyMHklM0QlMjI2NjAlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjEzMDglMjIlMjB5JTNEJTIyNjY2JTIyJTIwYXMlM0QlMjJ0YXJnZXRQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDQXJyYXklMjBhcyUzRCUyMnBvaW50cyUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI1NDAlMjIlMjB5JTNEJTIyNzQyJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjEzMDglMjIlMjB5JTNEJTIyNzQyJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZBcnJheSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTkyJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnJvdW5kZWQlM0QwJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0JodG1sJTNEMSUzQmZvbnRTaXplJTNEMTIlM0JmaWxsQ29sb3IlM0Rub25lJTNCc3Ryb2tlQ29sb3IlM0QlMjNDQ0NDQ0MlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMEJvbGQlM0JhbGxvd0Fycm93cyUzRDAlM0Jjb25uZWN0YWJsZSUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI0MDYuNSUyMiUyMHklM0QlMjI1MDQlMjIlMjB3aWR0aCUzRCUyMjI2NS41JTIyJTIwaGVpZ2h0JTNEJTIyMTU1JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTEwMCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJyb3VuZGVkJTNEMCUzQndoaXRlU3BhY2UlM0R3cmFwJTNCaHRtbCUzRDElM0Jmb250U2l6ZSUzRDEyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnN0cm9rZUNvbG9yJTNEJTIzQ0NDQ0NDJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBCb2xkJTNCYWxsb3dBcnJvd3MlM0QwJTNCY29ubmVjdGFibGUlM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyOTEyJTIyJTIweSUzRCUyMjUwNCUyMiUyMHdpZHRoJTNEJTIyMjc0LjUlMjIlMjBoZWlnaHQlM0QlMjIxNTUlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMzIlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZ3JvdXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlMjBjb25uZWN0YWJsZSUzRCUyMjAlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMTI1MC41JTIyJTIweSUzRCUyMjU3MyUyMiUyMHdpZHRoJTNEJTIyMTEzJTIyJTIwaGVpZ2h0JTNEJTIyODIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMzMlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCQ3JpdGljJTIwQWdlbnQlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMzIlMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweSUzRCUyMjQ0JTIyJTIwd2lkdGglM0QlMjIxMTMlMjIlMjBoZWlnaHQlM0QlMjIyOCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0zNCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUEwTWlJZ2FXUTlJbTkxZEd4cGJtVWlQaVlqZUdFN0lDQThaR1ZtY3o0bUkzaGhPeUFnSUNBOGMzUjViR1UlMkJKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxURWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1aaVl6QXdPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxURXNJQzVqYkhNdE1pQjdKaU40WVRzZ0lDQWdJQ0FnSUhOMGNtOXJaUzEzYVdSMGFEb2dNSEI0T3lZamVHRTdJQ0FnSUNBZ2ZTWWplR0U3SmlONFlUc2dJQ0FnSUNBdVkyeHpMVElnZXlZamVHRTdJQ0FnSUNBZ0lDQm1hV3hzT2lBalptWm1PeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdJQ0FnSUR3dmMzUjViR1UlMkJKaU40WVRzZ0lEd3ZaR1ZtY3o0bUkzaGhPeUFnUEhKbFkzUWdhR1ZwWjJoMFBTSTBNaUlnZDJsa2RHZzlJalF5SWlCamJHRnpjejBpWTJ4ekxURWlMejRtSTNoaE95QWdQR2MlMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEV5TGpBNE16VXNNVFF1TVRNMU0yd3pMalF4TmpVdE15NDBNVFkwTkhZeExqYzVNamszYURGMkxUTXVOV2d0TXk0MWRqRm9NUzQzT1RJNU4yd3RNeTQwTVRZMUxETXVOREUyTkRSakxTNHpPVFV3TWkwdU1qWXhPVFl0TGpnMk56WTRMUzQwTVRZME5DMHhMak0zTmpRMkxTNDBNVFkwTkMweExqTTNPRGt4TERBdE1pNDFMREV1TVRJeE5UZ3RNaTQxTERJdU5YTXhMakV5TVRBNUxESXVOU3d5TGpVc01pNDFMREl1TlMweExqRXlNVFU0TERJdU5TMHlMalZqTUMwdU5UQTROamN0TGpFMU5EVTBMUzQ1T0RFeU5pMHVOREUyTlMweExqTTNOalV6V2lJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEkzTGpNNU16VTFMREUzTGpReE1UTnNMVE11T0Rrek5UVXNNeTQ0T1RNME9YWXRNUzQzT1RJNU4yZ3RNWFl6TGpWb015NDFkaTB4YUMweExqYzVNamszYkRRdU1UQTNOREl0TkM0eE1EYzFOR011TWpFNU1qUXVNRFl6TURVdU5EUTJNamt1TVRBM05UUXVOamcxTlRVdU1UQTNOVFFzTVM0ek56ZzVNU3d3TERJdU5TMHhMakV5TVRVNExESXVOUzB5TGpWekxURXVNVEl4TURrdE1pNDFMVEl1TlMweUxqVXRNaTQxTERFdU1USXhOVGd0TWk0MUxESXVOV013TEM0M05qTTVPQzR6TlRFMU5pd3hMalEwTURRNUxqZzVNelUxTERFdU9EazVORGhhSWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdJQ0E4Y0dGMGFDQmtQU0pOTWpBc09TNHdNVEU0TTJNdU5UQTROemtzTUN3dU9UZ3hORFV0TGpFMU5EUTRMREV1TXpjMk5EWXRMalF4TmpRMGJETXVOREUyTlN3ekxqUXhOalEwYUMweExqYzVNamszZGpGb015NDFkaTB6TGpWb0xURjJNUzQzT1RJNU4yd3RNeTQwTVRZMUxUTXVOREUyTkRSakxqSTJNVGsyTFM0ek9UVXlOaTQwTVRZMUxTNDROamM0Tmk0ME1UWTFMVEV1TXpjMk5UTXNNQzB4TGpNM09EUXlMVEV1TVRJeE1Ea3RNaTQxTFRJdU5TMHlMalZ6TFRJdU5Td3hMakV5TVRVNExUSXVOU3d5TGpVc01TNHhNakV3T1N3eUxqVXNNaTQxTERJdU5Wb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBZ0lEeGphWEpqYkdVZ2NqMGlNaTQxSWlCamVUMGlNelV1TlRFeE9ETWlJR040UFNJeU9TSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJQ0FnUEhCaGRHZ2daRDBpVFRJekxETXpMakF4TVRnemFETXVOWFl0TXk0MWFDMHhkakV1TnpreU9UZHNMVFF1TkRFMk5TMDBMalF4TmpRMFl5NHlOakU1TmkwdU16azFNall1TkRFMk5TMHVPRFkzT0RZdU5ERTJOUzB4TGpNM05qVXpMREF0TVM0ek56ZzBNaTB4TGpFeU1UQTVMVEl1TlMweUxqVXRNaTQxTFM0MU1EZzNPU3d3TFM0NU9ERTBOUzR4TlRRME9DMHhMak0zTmpRMkxqUXhOalEwYkMwekxqUXhOalV0TXk0ME1UWTBOR2d4TGpjNU1qazNkaTB4YUMwekxqVjJNeTQxYURGMkxURXVOemt5T1Rkc015NDBNVFkxTERNdU5ERTJORFJqTFM0eU5qRTVOaTR6T1RVeU5pMHVOREUyTlM0NE5qYzROaTB1TkRFMk5Td3hMak0zTmpVekxEQXNNUzR6TnpnME1pd3hMakV5TVRBNUxESXVOU3d5TGpVc01pNDFMalV3T0RjNUxEQXNMams0TVRRMUxTNHhOVFEwT0N3eExqTTNOalEyTFM0ME1UWTBOR3cwTGpReE5qVXNOQzQwTVRZME5HZ3RNUzQzT1RJNU4zWXhXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR3dlp6NG1JM2hoT3p3dmMzWm5QZyUzRCUzRCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0zMiUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMzUuNSUyMiUyMHdpZHRoJTNEJTIyNDIlMjIlMjBoZWlnaHQlM0QlMjI0MiUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi02NCUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEb3J0aG9nb25hbEVkZ2VTdHlsZSUzQnJvdW5kZWQlM0QxJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCZXhpdFglM0QxJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQmVudHJ5WCUzRDAlM0JlbnRyeVklM0QwLjUlM0JlbnRyeUR4JTNEMCUzQmVudHJ5RHklM0QwJTNCc3Ryb2tlQ29sb3IlM0QlMjMwMDAwMDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kQXJyb3clM0RibG9jayUzQmVuZFNpemUlM0Q0JTNCZmlsbENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHNvdXJjZSUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTQ2JTIyJTIwdGFyZ2V0JTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtNTglMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHJlbGF0aXZlJTNEJTIyMSUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi02NiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEb3J0aG9nb25hbEVkZ2VTdHlsZSUzQnJvdW5kZWQlM0QxJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCZXhpdFglM0QxJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzMDAwMDAwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRTaXplJTNENCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBzb3VyY2UlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi01OCUyMiUyMHRhcmdldCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTQ4JTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtNjglMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG9ydGhvZ29uYWxFZGdlU3R5bGUlM0Jyb3VuZGVkJTNEMSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQmV4aXRYJTNEMSUzQmV4aXRZJTNEMC41JTNCZXhpdER4JTNEMCUzQmV4aXREeSUzRDAlM0JlbnRyeVglM0QwJTNCZW50cnlZJTNEMC41JTNCZW50cnlEeCUzRDAlM0JlbnRyeUR5JTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzMDAwMDAwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRTaXplJTNENCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBzb3VyY2UlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi00OCUyMiUyMHRhcmdldCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTU0JTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtNzAlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZW5kQXJyb3clM0Rub25lJTNCZGFzaGVkJTNEMSUzQmh0bWwlM0QxJTNCZGFzaFBhdHRlcm4lM0QxJTIwMyUzQnN0cm9rZVdpZHRoJTNEMiUzQnJvdW5kZWQlM0QxJTNCc3Ryb2tlQ29sb3IlM0QlMjMwMDAwMDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB3aWR0aCUzRCUyMjUwJTIyJTIwaGVpZ2h0JTNEJTIyNTAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjI0JTIyJTIweSUzRCUyMjQwOCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTQ2NCUyMiUyMHklM0QlMjI0MDglMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtOTMlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCUXVlc3Rpb24lMjBHZW5lcmF0aW9uJTIwQWdlbnQlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQmh0bWwlM0QxJTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCZmlsbENvbG9yJTNEbm9uZSUzQmFsaWduJTNEbGVmdCUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQnJvdW5kZWQlM0QwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFN0eWxlJTNEMSUzQmZvbnRTaXplJTNEMTIlM0JhbGxvd0Fycm93cyUzRDAlM0Jjb25uZWN0YWJsZSUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI0MTIuNTAwMDAwMDAwMDAwMDYlMjIlMjB5JTNEJTIyNTA4JTIyJTIwd2lkdGglM0QlMjIyMDElMjIlMjBoZWlnaHQlM0QlMjIyNC42MyUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi05NCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDAlM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZFNpemUlM0Q0JTNCY3VydmVkJTNEMSUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0Rub25lJTNCc3RhcnRGaWxsJTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzMDAwMDAwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0JleGl0WCUzRDAuOTkyJTNCZXhpdFklM0QwLjUzOSUzQmV4aXREeCUzRDAlM0JleGl0RHklM0QwJTNCZXhpdFBlcmltZXRlciUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwc291cmNlJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTUlMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI1MDIuNSUyMiUyMHklM0QlMjI1OTQlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjU4Ni41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi05NSUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDElM0JoYWNodXJlR2FwJTNENCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0RibG9jayUzQnN0YXJ0RmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyMzAwMDAwMCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI2MTAuNSUyMiUyMHklM0QlMjI1NzAlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjQ3OC41JTIyJTIweSUzRCUyMjU2NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNjEwLjUlMjIlMjB5JTNEJTIyNTQ2JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjU1MC41JTIyJTIweSUzRCUyMjU0NiUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI0NzguNSUyMiUyMHklM0QlMjI1NDYlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRkFycmF5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtOTYlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QwJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmN1cnZlZCUzRDElM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyMzAwMDAwMCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZXhpdFglM0QxJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBzb3VyY2UlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0xMyUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjMwNC41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNDA3JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0xMDElMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCQ29udGVudCUyMEdlbmVyYXRpb24lMjBBZ2VudCUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCaHRtbCUzRDElM0JzdHJva2VDb2xvciUzRG5vbmUlM0JmaWxsQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RsZWZ0JTNCdmVydGljYWxBbGlnbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCcm91bmRlZCUzRDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U3R5bGUlM0QxJTNCZm9udFNpemUlM0QxMiUzQmFsbG93QXJyb3dzJTNEMCUzQmNvbm5lY3RhYmxlJTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjkxNi41JTIyJTIweSUzRCUyMjUwOCUyMiUyMHdpZHRoJTNEJTIyMjAxJTIyJTIwaGVpZ2h0JTNEJTIyMjQuNjMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTAyJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG5vbmUlM0JvcnRob2dvbmFsTG9vcCUzRDElM0JqZXR0eVNpemUlM0RhdXRvJTNCaHRtbCUzRDElM0Jyb3VuZGVkJTNEMCUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JjdXJ2ZWQlM0QxJTNCZW5kQXJyb3clM0RibG9jayUzQmVuZEZpbGwlM0QxJTNCc3RhcnRBcnJvdyUzRG5vbmUlM0JzdGFydEZpbGwlM0QwJTNCc3Ryb2tlQ29sb3IlM0QlMjMwMDAwMDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIxMDA2LjUlMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJzb3VyY2VQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIxMDkwLjUlMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJ0YXJnZXRQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDQXJyYXklMjBhcyUzRCUyMnBvaW50cyUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTEwMyUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDElM0JoYWNodXJlR2FwJTNENCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0RibG9jayUzQnN0YXJ0RmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyMzAwMDAwMCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI5ODIuNSUyMiUyMHklM0QlMjI1NjQlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjExMTQuNSUyMiUyMHklM0QlMjI1NzAlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjk4Mi41JTIyJTIweSUzRCUyMjU0NiUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIxMDU0LjUlMjIlMjB5JTNEJTIyNTQ2JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjExMTQuNSUyMiUyMHklM0QlMjI1NDYlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRkFycmF5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTA0JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG5vbmUlM0JvcnRob2dvbmFsTG9vcCUzRDElM0JqZXR0eVNpemUlM0RhdXRvJTNCaHRtbCUzRDElM0Jyb3VuZGVkJTNEMSUzQmhhY2h1cmVHYXAlM0Q0JTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZFNpemUlM0Q0JTNCZW5kQXJyb3clM0RibG9jayUzQmVuZEZpbGwlM0QxJTNCc3RhcnRBcnJvdyUzRGJsb2NrJTNCc3RhcnRGaWxsJTNEMSUzQnN0cm9rZUNvbG9yJTNEJTIzMDAwMDAwJTNCZmlsbENvbG9yJTNEJTIzMDAwMDAwJTNCZXhpdFglM0QwJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBzb3VyY2UlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0zNCUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjQ4NC41JTIyJTIweSUzRCUyMjczNiUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTE4NyUyMiUyMHklM0QlMjI1OTQlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTA5JTIyJTIwdmFsdWUlM0QlMjJPdXRsaW5lJTJDJTIwUXVlc3Rpb25zJTJDJTIwYW5kJTIwQ29udGVudCUyMiUyMHN0eWxlJTNEJTIyZWRnZUxhYmVsJTNCaHRtbCUzRDElM0JhbGlnbiUzRGNlbnRlciUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0JyZXNpemFibGUlM0QwJTNCcG9pbnRzJTNEJTVCJTVEJTNCZm9udFNpemUlM0QxMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlMjBjb25uZWN0YWJsZSUzRCUyMjAlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyOTQyJTIyJTIweSUzRCUyMjc1MCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyLTQlMjIlMjB5JTNEJTIyLTglMjIlMjBhcyUzRCUyMm9mZnNldCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTExMCUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTI2Z3QlM0JEYXRhJTIwSW5nZXN0aW9uJTIwUGhhc2UlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQmh0bWwlM0QxJTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCZmlsbENvbG9yJTNEbm9uZSUzQmFsaWduJTNEbGVmdCUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQnJvdW5kZWQlM0QwJTNCZm9udEZhbWlseSUzRE5WSURJQVNhbnMtUmVndWxhciUzQmZvbnRTdHlsZSUzRDElM0Jmb250U2l6ZSUzRDEyJTNCYWxsb3dBcnJvd3MlM0QwJTNCY29ubmVjdGFibGUlM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMzAuMDAwMDAwMDAwMDAwMDU3JTIyJTIweSUzRCUyMjM3MiUyMiUyMHdpZHRoJTNEJTIyMjAxJTIyJTIwaGVpZ2h0JTNEJTIyMjQuNjMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTExJTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjZndCUzQlF1ZXJ5JTIwUGhhc2UlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQmh0bWwlM0QxJTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCZmlsbENvbG9yJTNEbm9uZSUzQmFsaWduJTNEbGVmdCUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQnJvdW5kZWQlM0QwJTNCZm9udEZhbWlseSUzRE5WSURJQVNhbnMtUmVndWxhciUzQmZvbnRTdHlsZSUzRDElM0Jmb250U2l6ZSUzRDEyJTNCYWxsb3dBcnJvd3MlM0QwJTNCY29ubmVjdGFibGUlM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMzAuMDAwMDAwMDAwMDAwMDU3JTIyJTIweSUzRCUyMjQyMCUyMiUyMHdpZHRoJTNEJTIyMjAxJTIyJTIwaGVpZ2h0JTNEJTIyMjQuNjMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTEyJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG5vbmUlM0JvcnRob2dvbmFsTG9vcCUzRDElM0JqZXR0eVNpemUlM0RhdXRvJTNCaHRtbCUzRDElM0Jyb3VuZGVkJTNEMCUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JjdXJ2ZWQlM0QxJTNCZW5kQXJyb3clM0RibG9jayUzQmVuZEZpbGwlM0QxJTNCc3RhcnRBcnJvdyUzRG5vbmUlM0JzdGFydEZpbGwlM0QwJTNCc3Ryb2tlQ29sb3IlM0QlMjMwMDAwMDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI2NzIlMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJzb3VyY2VQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI3NDguNSUyMiUyMHklM0QlMjI1OTQlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTE1JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG5vbmUlM0JvcnRob2dvbmFsTG9vcCUzRDElM0JqZXR0eVNpemUlM0RhdXRvJTNCaHRtbCUzRDElM0Jyb3VuZGVkJTNEMSUzQmhhY2h1cmVHYXAlM0Q0JTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZFNpemUlM0Q0JTNCZW5kQXJyb3clM0RibG9jayUzQmVuZEZpbGwlM0QxJTNCc3RhcnRBcnJvdyUzRGJsb2NrJTNCc3RhcnRGaWxsJTNEMSUzQnN0cm9rZUNvbG9yJTNEJTIzMDAwMDAwJTNCZmlsbENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjkxMC41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNzkwLjUlMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJ0YXJnZXRQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDQXJyYXklMjBhcyUzRCUyMnBvaW50cyUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTExNiUyMiUyMHZhbHVlJTNEJTIyUXVlc3Rpb25zJTI2bHQlM0JkaXYlMjZndCUzQmFuZCUyNmFtcCUzQm5ic3AlM0IlMjZsdCUzQmRpdiUyNmd0JTNCQ29udGVudCUyNmx0JTNCJTJGZGl2JTI2Z3QlM0IlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJlZGdlTGFiZWwlM0JodG1sJTNEMSUzQmFsaWduJTNEY2VudGVyJTNCdmVydGljYWxBbGlnbiUzRG1pZGRsZSUzQnJlc2l6YWJsZSUzRDAlM0Jwb2ludHMlM0QlNUIlNUQlM0Jmb250U2l6ZSUzRDEwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUyMGNvbm5lY3RhYmxlJTNEJTIyMCUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI4NTAuOTk2NjY2NjY2NjY2NiUyMiUyMHklM0QlMjI1OTMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyM3gxWVhfeGo3YmJSZFZJd0hKTHctNCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDElM0JoYWNodXJlR2FwJTNENCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0RibG9jayUzQnN0YXJ0RmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyMzAwMDAwMCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQmVudHJ5WCUzRDElM0JlbnRyeVklM0QwLjUlM0JlbnRyeUR4JTNEMCUzQmVudHJ5RHklM0QwJTNCZXhpdFglM0QwLjUlM0JleGl0WSUzRDAlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBzb3VyY2UlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0yNiUyMiUyMHRhcmdldCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTUzJTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB3aWR0aCUzRCUyMjE0MCUyMiUyMHJlbGF0aXZlJTNEJTIyMSUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNzY4JTIyJTIweSUzRCUyMjU2NCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNzk4JTIyJTIweSUzRCUyMjI4OCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0xMTclMjIlMjB2YWx1ZSUzRCUyMlF1ZXN0aW9ucyUyNmx0JTNCZGl2JTI2Z3QlM0JhbmQlMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0JkaXYlMjZndCUzQkNvbnRlbnQlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTI2bHQlM0IlMkZkaXYlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIyZWRnZUxhYmVsJTNCaHRtbCUzRDElM0JhbGlnbiUzRGNlbnRlciUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0JyZXNpemFibGUlM0QwJTNCcG9pbnRzJTNEJTVCJTVEJTNCZm9udFNpemUlM0QxMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlMjBjb25uZWN0YWJsZSUzRCUyMjAlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyNzcwLjQ5NjY2NjY2NjY2NjYlMjIlMjB5JTNEJTIyMzcyJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHklM0QlMjItMjUlMjIlMjBhcyUzRCUyMm9mZnNldCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTg3JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG5vbmUlM0JvcnRob2dvbmFsTG9vcCUzRDElM0JqZXR0eVNpemUlM0RhdXRvJTNCaHRtbCUzRDElM0Jyb3VuZGVkJTNEMCUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JjdXJ2ZWQlM0QxJTNCZW5kQXJyb3clM0RibG9jayUzQmVuZEZpbGwlM0QxJTNCc3Ryb2tlQ29sb3IlM0QlMjMwMDAwMDAlM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmV4aXRYJTNEMSUzQmV4aXRZJTNEMC41JTNCZXhpdER4JTNEMCUzQmV4aXREeSUzRDAlM0JlbnRyeVglM0QwJTNCZW50cnlZJTNEMC41JTNCZW50cnlEeCUzRDAlM0JlbnRyeUR5JTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjBzb3VyY2UlM0QlMjIzeDFZWF94ajdiYlJkVkl3SEpMdy0yJTIyJTIwdGFyZ2V0JTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTMlMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIxNDguNSUyMiUyMHklM0QlMjI2MDElMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjI1Ni41JTIyJTIweSUzRCUyMjYwMSUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi04OCUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwc3R5bGUlM0QlMjZxdW90JTNCZm9udC1zaXplJTNBJTIwMTBweCUzQiUyNnF1b3QlM0IlMjBkYXRhLWZvbnQtc3JjJTNEJTI2cXVvdCUzQmh0dHBzJTNBJTJGJTJGaW1hZ2VzLm52aWRpYS5jb20lMkZldGMlMkZkZXNpZ25zJTJGbnZpZGlhR0RDJTJGY2xpZW50bGlic19iYXNlJTJGZm9udHMlMkZudmlkaWEtc2FucyUyRiUyNnF1b3QlM0IlMjZndCUzQlJlc2VhcmNoJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQmRpdiUyNmd0JTNCJTI2bHQlM0Jmb250JTIwc3R5bGUlM0QlMjZxdW90JTNCZm9udC1zaXplJTNBJTIwMTBweCUzQiUyNnF1b3QlM0IlMjBkYXRhLWZvbnQtc3JjJTNEJTI2cXVvdCUzQmh0dHBzJTNBJTJGJTJGaW1hZ2VzLm52aWRpYS5jb20lMkZldGMlMkZkZXNpZ25zJTJGbnZpZGlhR0RDJTJGY2xpZW50bGlic19iYXNlJTJGZm9udHMlMkZudmlkaWEtc2FucyUyRiUyNnF1b3QlM0IlMjZndCUzQlJlcXVlc3QlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyNmx0JTNCJTJGZGl2JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMmVkZ2VMYWJlbCUzQmh0bWwlM0QxJTNCYWxpZ24lM0RjZW50ZXIlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCcmVzaXphYmxlJTNEMCUzQnBvaW50cyUzRCU1QiU1RCUzQmZvbnRTaXplJTNEMTAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQiUyMiUyMHBhcmVudCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTg3JTIyJTIwdmVydGV4JTNEJTIyMSUyMiUyMGNvbm5lY3RhYmxlJTNEJTIyMCUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHJlbGF0aXZlJTNEJTIyMSUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyLTElMjIlMjBhcyUzRCUyMm9mZnNldCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMjB2UjBQaFp3aC1PRlJRTDdyaVc5LTIlMjIlMjB2YWx1ZSUzRCUyMk91dGxpbmUlMjIlMjBzdHlsZSUzRCUyMmVkZ2VMYWJlbCUzQmh0bWwlM0QxJTNCYWxpZ24lM0RjZW50ZXIlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCcmVzaXphYmxlJTNEMCUzQnBvaW50cyUzRCU1QiU1RCUzQmZvbnRTaXplJTNEMTAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTIwY29ubmVjdGFibGUlM0QlMjIwJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjE5MiUyMiUyMHklM0QlMjI1NzAlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjE1OCUyMiUyMHklM0QlMjIyMyUyMiUyMGFzJTNEJTIyb2Zmc2V0JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtNDYlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyc2hhcGUlM0RpbWFnZSUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRGJvdHRvbSUzQmxhYmVsQmFja2dyb3VuZENvbG9yJTNEZGVmYXVsdCUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jhc3BlY3QlM0RmaXhlZCUzQmltYWdlQXNwZWN0JTNEMCUzQmltYWdlJTNEZGF0YSUzQWltYWdlJTJGc3ZnJTJCeG1sJTJDUEhOMlp5QjRiV3h1Y3owaWFIUjBjRG92TDNkM2R5NTNNeTV2Y21jdk1qQXdNQzl6ZG1jaUlIWnBaWGRDYjNnOUlqQWdNQ0EwTWlBME1pSWdaR0YwWVMxdVlXMWxQU0pNWVhsbGNpQTFJaUJwWkQwaVRHRjVaWEpmTlNJJTJCSmlONFlUc2dJRHhrWldaelBpWWplR0U3SUNBZ0lEeHpkSGxzWlQ0bUkzaGhPeUFnSUNBZ0lDNWpiSE10TVNCN0ppTjRZVHNnSUNBZ0lDQWdJR1pwYkd3NklDTmtPVFkwTWpFN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzbUkzaGhPeUFnSUNBZ0lDNWpiSE10TVN3Z0xtTnNjeTB5TENBdVkyeHpMVE1nZXlZamVHRTdJQ0FnSUNBZ0lDQnpkSEp2YTJVdGQybGtkR2c2SURCd2VEc21JM2hoT3lBZ0lDQWdJSDBtSTNoaE95WWplR0U3SUNBZ0lDQWdMbU5zY3kweUxDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c09pQWpabVptT3lZamVHRTdJQ0FnSUNBZ2ZTWWplR0U3SmlONFlUc2dJQ0FnSUNBdVkyeHpMVE1nZXlZamVHRTdJQ0FnSUNBZ0lDQm1hV3hzTFhKMWJHVTZJR1YyWlc1dlpHUTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc2dJQ0FnUEM5emRIbHNaVDRtSTNoaE95QWdQQzlrWldaelBpWWplR0U3SUNBOGNHOXNlV2R2YmlCd2IybHVkSE05SWpJNExqY3dNREF4SURJd0xqRTVPVGN4SURJNExqY3dNREF4SURJekxqVWdNalV1TkRBNU9UY2dNak11TlNBeU9DNDNNREF3TVNBeU1DNHhPVGszTVNJZ1kyeGhjM005SW1Oc2N5MHhJaTglMkJKaU40WVRzZ0lEeHdZWFJvSUdROUlrMHlPUzQzTURBd01Td3hPUzQxZGpWb0xUVjJNVEpvTVRKMkxURTNhQzAzV2swek1DNDNNREF3TVN3ek15NDFhQzAwZGkweGFEUjJNVnBOTXpRdU56QXdNREVzTXpBdU5XZ3RPSFl0TVdnNGRqRmFUVE0wTGpjd01EQXhMREkzTGpWb0xUaDJMVEZvT0hZeFdpSWdZMnhoYzNNOUltTnNjeTB4SWk4JTJCSmlONFlUc2dJRHh3WVhSb0lHUTlJazB3TERCMk5ESm9OREpXTUVnd1drMHhNUzQzTURBd01Td3lNUzQxYUMwM1ZqUXVOV2d4TjNZM2FDMHhkaTAyU0RVdU56QXdNREYyTVRWb05uWXhXazB4TVM0Mk9Td3hOQzQxZGpGb0xUVXVOamxzTmk0eE1pMDJMakl3TURJc01TNHdORGs1T1M0NU9UQXlNeXd5TGpBeU1EQXlMVEl1TVRZd01UWXNNeTR5TlN3ekxqTTNNREV5YUMwMExqSXpPVGs1YkMwdU1ESXdNREl1TURJd01ESm9MVEl1Tld3dU1ERXdNREVzTWk0NU56azVPRnBOTWpJdU56QXdNREVzTWprdU5XZ3RNVEJXTVRJdU5XZ3hOM1kwTGpnek1EQTRhQzB4ZGkwekxqZ3pNREE0YUMweE5YWXhOV2c1ZGpGYVRUSTJMalV4TURBeExERTRMalk0T1RrMGJDMHlMak16TURBeUxESXVNek13TURndE1pNHpOeTB1TmpJNU9EZ3RNUzR5TWprNU9DMDBMalU1TURNekxqUTRPVGs1TFM0eE1qazRPR011TkRFNU9UZ3RMakV3T1RnMkxqYzRPVGs0TFM0eE5qazVNaXd4TGpFME9UazJMUzR4TmprNU1pd3lMakF5TURBeUxEQXNNeTQzTkRBd05Td3hMak0xTURFc05DNHlPVEF3TkN3ekxqRTRPVGswV2sweU1pNHlNREF3TVN3eU0zWXpMakEyT1RneVl5MHVOVGt3TURNdU1qZ3dNamN0TVM0eU5TNDBNekF4T0MweExqa3lPVGs1TGpRek1ERTRMVEl1TlRJd01ESXNNQzAwTGpVM01EQXhMVEl1TURVd01qa3ROQzQxTnpBd01TMDBMalUyT1RneUxEQXRNaTR3TmpBd05pd3hMak00T1RrMUxUTXVPRGN3TVRJc015NHpPRGs1TlMwMExqUXhNREUyYkM0ME9UQXdOUzB1TVRJNU9EZ3NNUzR3T1RrNU9DdzBMakV5T1RnNExESXVNemN1TmpJNU9EZ3RMamcwT1RrNExqZzFNREZhVFRNM0xqY3dNREF4TERNM0xqVm9MVEUwZGkweE15NDNNREF5YkRVdU1qZzVPVGd0TlM0eU9UazRhRGd1TnpFd01ESjJNVGxhSWlCamJHRnpjejBpWTJ4ekxURWlMejRtSTNoaE95QWdQSEJoZEdnZ1pEMGlUVEk0TGprNE9UazVMREU0TGpWc0xUVXVNamc1T1Rnc05TNHlPVGs0ZGpFekxqY3dNREpvTVRSMkxURTVhQzA0TGpjeE1EQXlXazB5T0M0M01EQXdNU3d5TUM0eE9UazNNWFl6TGpNd01ESTVhQzB6TGpJNU1EQTBiRE11TWprd01EUXRNeTR6TURBeU9WcE5Nell1TnpBd01ERXNNell1TldndE1USjJMVEV5YURWMkxUVm9OM1l4TjFvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Y21WamRDQm9aV2xuYUhROUlqRWlJSGRwWkhSb1BTSTRJaUI1UFNJeU5pNDFJaUI0UFNJeU5pNDNNREF3TVNJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lEeHlaV04wSUdobGFXZG9kRDBpTVNJZ2QybGtkR2c5SWpnaUlIazlJakk1TGpVaUlIZzlJakkyTGpjd01EQXhJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BISmxZM1FnYUdWcFoyaDBQU0l4SWlCM2FXUjBhRDBpTkNJZ2VUMGlNekl1TlNJZ2VEMGlNall1TnpBd01ERWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOGNHOXNlV2R2YmlCd2IybHVkSE05SWpJNUxqY3dNREF4SURFeUxqVWdNamt1TnpBd01ERWdNVGN1TXpNd01EZ2dNamd1TnpBd01ERWdNVGN1TXpNd01EZ2dNamd1TnpBd01ERWdNVE11TlNBeE15NDNNREF3TVNBeE15NDFJREV6TGpjd01EQXhJREk0TGpVZ01qSXVOekF3TURFZ01qZ3VOU0F5TWk0M01EQXdNU0F5T1M0MUlERXlMamN3TURBeElESTVMalVnTVRJdU56QXdNREVnTVRJdU5TQXlPUzQzTURBd01TQXhNaTQxSWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQSEJoZEdnZ1pEMGlUVEkyTGpVeE1EQXhMREU0TGpZNE9UazBiQzB5TGpNek1EQXlMREl1TXpNd01EZ3RNaTR6TnkwdU5qSTVPRGd0TVM0eU1qazVPQzAwTGpVNU1ETXpMalE0T1RrNUxTNHhNams0T0dNdU5ERTVPVGd0TGpFd09UZzJMamM0T1RrNExTNHhOams1TWl3eExqRTBPVGsyTFM0eE5qazVNaXd5TGpBeU1EQXlMREFzTXk0M05EQXdOU3d4TGpNMU1ERXNOQzR5T1RBd05Dd3pMakU0T1RrMFdpSWdZMnhoYzNNOUltTnNjeTB6SWk4JTJCSmlONFlUc2dJRHh3WVhSb0lHUTlJazB5TXk0d05EazVPU3d5TWk0eE5EazViQzB1T0RRNU9UZ3VPRFV3TVhZekxqQTJPVGd5WXkwdU5Ua3dNRE11TWpnd01qY3RNUzR5TlM0ME16QXhPQzB4TGpreU9UazVMalF6TURFNExUSXVOVEl3TURJc01DMDBMalUzTURBeExUSXVNRFV3TWprdE5DNDFOekF3TVMwMExqVTJPVGd5TERBdE1pNHdOakF3Tml3eExqTTRPVGsxTFRNdU9EY3dNVElzTXk0ek9EazVOUzAwTGpReE1ERTJiQzQwT1RBd05TMHVNVEk1T0Rnc01TNHdPVGs1T0N3MExqRXlPVGc0TERJdU16Y3VOakk1T0RoYUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEhCdmJIbG5iMjRnY0c5cGJuUnpQU0l5TVM0M01EQXdNU0EwTGpVZ01qRXVOekF3TURFZ01URXVOU0F5TUM0M01EQXdNU0F4TVM0MUlESXdMamN3TURBeElEVXVOU0ExTGpjd01EQXhJRFV1TlNBMUxqY3dNREF4SURJd0xqVWdNVEV1TnpBd01ERWdNakF1TlNBeE1TNDNNREF3TVNBeU1TNDFJRFF1TnpBd01ERWdNakV1TlNBMExqY3dNREF4SURRdU5TQXlNUzQzTURBd01TQTBMalVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqRTRMalEwSURFeExqVWdNVFF1TWpBd01ERWdNVEV1TlNBeE5DNHhOems1T1NBeE1TNDFNakF3TWlBeE1TNDJOems1T1NBeE1TNDFNakF3TWlBeE1TNDJPU0F4TkM0MUlERXhMalk1SURFMUxqVWdOaUF4TlM0MUlERXlMakV5SURrdU1qazVPQ0F4TXk0eE5qazVPQ0F4TUM0eU9UQXdOQ0F4TlM0eE9TQTRMakV5T1RnNElERTRMalEwSURFeExqVWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3UEM5emRtYyUyQiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI5OC41JTIyJTIweSUzRCUyMjE1OCUyMiUyMHdpZHRoJTNEJTIyNDIlMjIlMjBoZWlnaHQlM0QlMjI0MiUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi01OCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUEwT0NJZ2FXUTlJbWx1YkdsdVpTSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05tWm1ZN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzbUkzaGhPeUFnSUNBZ0lDNWpiSE10TWlCN0ppTjRZVHNnSUNBZ0lDQWdJR1pwYkd3NklDTTJOalk3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSXhJREFnTkRJZ01USWdORElnTXpZZ01qRWdORGdnTUNBek5pQXdJREV5SURJeElEQWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOFp6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5Namd1TVRVeE5pd3lNeTQxTmpnME5tTXdMUzR5TURrNU5pMHVNREV3TURFdExqUXhPVGs0TFM0d016QXdNeTB1TmpKc01pNDFMVEl1TlRjNU9UWXRNaTR3TkRrNU9TMHpMalUwTURBMExUTXVOREU1T1RndU9URXdNRE5qTFM0ek5UazVPUzB1TWpZd01ERXRMamN6T1RrNUxTNDBPREF3TkMweExqRXpMUzQyTmpBd00yd3RMamszT1RrNExUTXVORFV3TURGb0xUUXVNRGt3TUROc0xTNDVNVGs1T0N3ekxqUXlNREEwWXkwdU16a3dNREV1TVRjNU9Ua3RMamMzTURBeUxqTTVPVGsyTFRFdU1UTXVOalE1T1Rac0xUTXVORGM1T1RndExqZzNMVEl1TURVd01EVXNNeTQxTkRBd05Dd3lMalV4TURBeExESXVOVEE1T1RWakxTNHdNams1Tnk0eU16QXdOQzB1TURNNU9UZ3VORFV3TURFdExqQXpPVGs0TGpZNUxEQXNMakl4TURBeUxqQXhNREF4TGpReE1EQXpMakF5T1RrM0xqWXhNREExYkMweUxqVXNNaTQxTnprNU5pd3lMakExTURBMUxETXVOVFV3TURVc015NDBNVGs1T0MwdU9USXdNRFJqTGpNMU9UazVMakkyTURBeExqY3pPVGs1TGpRNE1EQTBMREV1TVRNdU5qWXdNRE5zTGprM09UazRMRE11TkRVd01ERm9OQzR3T1RBd00yd3VPVEU1T1RndE15NDBNakF3TkdNdU16a3dNREV0TGpFM09UazVMamMzTURBeUxTNHpPVGs1Tml3eExqRXpMUzQyTkRrNU5td3pMalE0T1RrNUxqZzNMREl1TURNNU9UZ3RNeTQxTkRBd05DMHlMalV4TURBeExUSXVOVEE1T1RWakxqQXpNREF6TFM0eU1qQXdNeTR3TkRBd05DMHVORFV3TURFdU1EUXdNRFF0TGpZNE1EQTFXazB5TXk0NE1qRTFPU3d5TXk0MU5qZzBObU13TERFdU5UWXRNUzR5TmpBd01Td3lMamd6TURBeUxUSXVPREl3TURFc01pNDRNekF3TW5NdE1pNDRNams1TmkweExqSTNNREF5TFRJdU9ESTVPVFl0TWk0NE16QXdNaXd4TGpJMk9UazJMVEl1T0RJNU9UWXNNaTQ0TWprNU5pMHlMamd5T1RrMkxESXVPREl3TURFc01TNHlOams1Tml3eUxqZ3lNREF4TERJdU9ESTVPVFphSWlCamJHRnpjejBpWTJ4ekxURWlMejRtSTNoaE95QWdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakV5TGpVd01UVTRJRE16TGpRNU9EVXhJREV5TGpVd01UVTRJRE0zTGpRNU9EVXhJRGN1TlRBeE5UZ2dNemN1TkRrNE5URWdOeTQxTURFMU9DQXpNeTQwT1RnMU1TQTVMakExTVRVM0lETXpMalE1T0RVeElEa3VNRFV4TlRjZ01qTXVOemc0TkRrZ01URXVNak14TmpJZ01qTXVOemc0TkRrZ01URXVNak14TmpJZ01qUXVOemc0TkRrZ01UQXVNRFV4TlRjZ01qUXVOemc0TkRrZ01UQXVNRFV4TlRjZ016TXVORGs0TlRFZ01USXVOVEF4TlRnZ016TXVORGs0TlRFaUlHTnNZWE56UFNKamJITXRNU0l2UGlZamVHRTdJQ0FnSUR4d2IyeDVaMjl1SUhCdmFXNTBjejBpTXpRdU5UQXhOVGdnTXpNdU5EazROVEVnTXpRdU5UQXhOVGdnTXpjdU5EazROVEVnTWprdU5UQXhOVGdnTXpjdU5EazROVEVnTWprdU5UQXhOVGdnTXpNdU5EazROVEVnTXpFdU9ETXhOaUF6TXk0ME9UZzFNU0F6TVM0NE16RTJJREkwTGpjNE9EUTVJRE13TGpZME1UVTVJREkwTGpjNE9EUTVJRE13TGpZME1UVTVJREl6TGpjNE9EUTVJRE15TGpnek1UWWdNak11TnpnNE5Ea2dNekl1T0RNeE5pQXpNeTQwT1RnMU1TQXpOQzQxTURFMU9DQXpNeTQwT1RnMU1TSWdZMnhoYzNNOUltTnNjeTB4SWk4JTJCSmlONFlUc2dJQ0FnUEhCdmJIbG5iMjRnY0c5cGJuUnpQU0l4TUM0d05URTFOeUF4TkM0ME9UZzFNU0F4TUM0d05URTFOeUF5TWk0eE1EZzFJREV4TGpJek1UWXlJREl5TGpFd09EVWdNVEV1TWpNeE5qSWdNak11TVRBNE5TQTVMakExTVRVM0lESXpMakV3T0RVZ09TNHdOVEUxTnlBeE5DNDBPVGcxTVNBM0xqVXdNVFU0SURFMExqUTVPRFV4SURjdU5UQXhOVGdnTVRBdU5EazROVEVnTVRJdU5UQXhOVGdnTVRBdU5EazROVEVnTVRJdU5UQXhOVGdnTVRRdU5EazROVEVnTVRBdU1EVXhOVGNnTVRRdU5EazROVEVpSUdOc1lYTnpQU0pqYkhNdE1TSXZQaVlqZUdFN0lDQWdJRHh3YjJ4NVoyOXVJSEJ2YVc1MGN6MGlNelF1TlRBeE5UZ2dNVEF1TkRrNE5URWdNelF1TlRBeE5UZ2dNVFF1TkRrNE5URWdNekl1T0RNeE5pQXhOQzQwT1RnMU1TQXpNaTQ0TXpFMklESXpMakV3T0RVZ016QXVOalF4TlRrZ01qTXVNVEE0TlNBek1DNDJOREUxT1NBeU1pNHhNRGcxSURNeExqZ3pNVFlnTWpJdU1UQTROU0F6TVM0NE16RTJJREUwTGpRNU9EVXhJREk1TGpVd01UVTRJREUwTGpRNU9EVXhJREk1TGpVd01UVTRJREV3TGpRNU9EVXhJRE0wTGpVd01UVTRJREV3TGpRNU9EVXhJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BDOW5QaVlqZUdFN1BDOXpkbWMlMkIlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMzExJTIyJTIweSUzRCUyMjE1NSUyMiUyMHdpZHRoJTNEJTIyNDIlMjIlMjBoZWlnaHQlM0QlMjI0OCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi00OCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUExTmlJZ1pHRjBZUzF1WVcxbFBTSk1ZWGxsY2lBeElpQnBaRDBpVEdGNVpYSmZNU0klMkJKaU40WVRzZ0lEeGtaV1p6UGlZamVHRTdJQ0FnSUR4emRIbHNaVDRtSTNoaE95QWdJQ0FnSUM1amJITXRNU0I3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNObVptWTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUlIc21JM2hoT3lBZ0lDQWdJQ0FnYzNSeWIydGxMWGRwWkhSb09pQXdjSGc3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNaUI3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNNM05tSTVNREE3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqQWdNemd1TURFMU5qSWdNQ0EwTWk0d01UVTJNaUF5TVNBMU5DNHdNVFUyTWlBME1pQTBNaTR3TVRVMk1pQTBNaUF6T0M0d01UVTJNaUF5TVNBMU1DNHdNVFUyTWlBd0lETTRMakF4TlRZeUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEdjJTJCSmlONFlUc2dJQ0FnUEhCdmJIbG5iMjRnY0c5cGJuUnpQU0kwTWlBeE1pNHdNRFF6TXlBME1pQXpOaTR3TVRRek5DQXlNU0EwT0M0d01qUXpOU0F3SURNMkxqQXhORE0wSURBZ01USXVNREEwTXpNZ01qRWdMakF3TkRNeklEUXlJREV5TGpBd05ETXpJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5NakV1TURBd09UZ3NNRXd3TERFeUxqQXdNamt5ZGpJMExqQXhORGd4YkRJeExqQXdNRGs0TERFeUxqQXdOVGt4TERJd0xqazVPVEF5TFRFeUxqQXdOVGt4VmpFeUxqQXdNamt5VERJeExqQXdNRGs0TERCYVRUUXhMRE0xTGpRek56RTViQzB4T1M0MUxERXhMakUwT0RnMmRpMDJMakV6T1RRMGFDMHhkall1TVRNNE16Uk1NU3d6TlM0ME16Y3hNbFl4TXk0eU56RXpiRFV1TVRRd01UUXNNeTQwTXpNNU5DNDFORGs0TFM0NE5EQXpPQzAxTGpJM01qY3hMVE11TlRFMk9EZE1NakV1TURBd09UZ3NNUzR4TlRJek5td3hPUzQyTXpVM05Dd3hNUzR4TmpNeU1pMDFMak15TmpjeUxETXVOakF3TnpRdU5UUTVPVGt1T0RJNE5qSXNOUzR4TkRBd01TMHpMalF5TXpFM2RqSXlMakV4TlRReVdpSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHd2Wno0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRNd0xqUXdNREF5TERJMkxqa3dNREF5WXkwdU1qSXdNRE1zTUMwdU5ETXdNRFV1TURNNU9UZ3RMall6TGpFd09UazViQzB4TGpjM01EQXlMVEl1TnpZNU9UWjJMUzR3TVRBd01Xd3hMamMzTURBeUxUSXVPVEk1T1RsakxqRTVPVGsxTGpBMkxqUXdPVGszTGpBNU9UazRMall6TGpBNU9UazRMREV1TURrNU9UZ3NNQ3d5TFM0NU1EQXdNaXd5TFRKekxTNDVNREF3TWkweUxUSXRNbU10TGpVM01EQXhMREF0TVM0d09UQXdNeTR5TXprNU9TMHhMalExTURBeExqWXpiQzAyTGpFeUxUTXVOVE13TUROakxqQTBPVGs1TFM0eE5UazVOeTR3TnpBd01TMHVNekk1T1RZdU1EY3dNREV0TGpVc01DMHhMakE1T1RrNExTNDVNREF3TWkweUxUSXRNaTB4TGpFd01EQTBMREF0TWl3dU9UQXdNREl0TWl3eUxEQXNMakU1TGpBeU9UazNMak00TGpBM09UazJMalUxTURBMWJDMDJMakF5T1RrM0xETXVORGM1T1RoakxTNHpOVGs1T1MwdU16a3dNREV0TGpnNExTNDJNeTB4TGpRMU1EQXhMUzQyTXkweExqQTVPVGs0TERBdE1pd3VPVEF3TURJdE1pd3ljeTQ1TURBd01pd3lMRElzTW1NdU1UWTVPVGdzTUN3dU16UXdNRE10TGpBeU1EQXlMalE0T1RrNUxTNHdObXd4TGpneU1EQXhMRE11TURFd01ERXRNUzQyTnprNU9Td3lMalkwT1RrMll5MHVNakF3TURFdExqQTJMUzQwTVRBd015MHVNRGs1T1RndExqWXpMUzR3T1RrNU9DMHhMakE1T1RrNExEQXRNaXd1T1RBd01ESXRNaXd5Y3k0NU1EQXdNaXd5TERJc01tTXVOVEl3TURJc01Dd3hMUzR5TURBd01Td3hMak0wT1RrNExTNDFNekF3TTJ3MkxqRXpMRE11T1Rnd01EUmpMUzR3TkRrNU9TNHhOams1T0MwdU1EYzVPVFl1TXpVNU9Ua3RMakEzT1RrMkxqVTBPVGs1TERBc01TNHdPVGs1T0M0NE9UazVOaXd5TERJc01pd3hMakE1T1RrNExEQXNNaTB1T1RBd01ESXNNaTB5TERBdExqSXhPVGszTFM0d05EQXdOQzB1TkRJNU9Ua3RMakV4TURBMUxTNDJNMncyTGpFeUxUUXVNRFE1T1RsakxqTTJNREExTGpReE9UazRMamt3TURBeUxqWTNPVGs1TERFdU5Ea3dNRFV1TmpjNU9Ua3NNUzR3T1RrNU9Dd3dMREl0TGprd01EQXlMREl0TW5NdExqa3dNREF5TFRJdE1pMHlXazB4T1M0ME9EazVPU3d4TlM0ME1UQXdNMnd0TXk0MU9EQXdNaXcxTGpZME1EQXhMVEl1TkRRNU9UVXRNUzR5TXpBd05HTXVNREU1T1RZdExqRXpMakF6T1RrNExTNHlOems1Tnk0d016azVPQzB1TkRFNU9UZ3NNQzB1TVRZNU9UZ3RMakF5TURBeUxTNHpOREF3TXkwdU1EY3dNREV0TGpWc05pNHdOaTB6TGpRNE9UazVXazB4T0M0NU1UazVPQ3d5TkM0ek5qQXdOV011TURFd01ERXVNRGc1T1RjdU1ESXdNREl1TVRZNU9UZ3VNRFE1T1RrdU1qVnNMVEl1T1RNNU9UUXNNUzQwTmprNU55MHhMakEwTURBMExURXVOekU1T1Rjc01TNHlPREF3TXkweUxqQXlNREF5TERJdU5qWTVPVGdzTVM0ek5EQXdNMk10TGpBeU1EQXlMakV5T1RrMExTNHdNems1T0M0eU56azVOeTB1TURNNU9UZ3VOREU1T1Rnc01Dd3VNRGc1T1RjdU1EQTVPVFV1TVRjNU9Ua3VNREU1T1RZdU1qWXdNREZhVFRFeUxqZzNMREl3TGpnMU1EQTBZeTR3TkRrNU9TMHVNRFF3TURRdU1Ea3dNRE10TGpBNU1EQXpMakV6TFM0eE5EQXdNV3d5TGpNNExERXVNVGM1T1RrdExqazJNREF5TERFdU5URXdNREV0TVM0MU5EazVPUzB5TGpVME9UazVXazB4TWk0NU1EazVOeXd5Tnk0Mk5EQXdNV3d1TURZdExqQTRPVGszTERFdU5ESXdNRFF0TWk0eU5EQXdOUzQzTXprNU9Td3hMakl5TURBekxUSXVNVE1zTVM0d05pMHVNRGt3TURNdU1EUTVPVGxhVFRFekxqTTVNREF4TERJNUxqVXpNREF6WXk0d056QXdNUzB1TWpBd01ERXVNVEE1T1RrdExqUXhNREF6TGpFd09UazVMUzQyTXl3d0xTNHhOREF3TVMwdU1ESXdNREl0TGpJNE9UazRMUzR3TXprNU9DMHVOREU1T1Roc01pNHhOems1T1MweExqQTVNREF6TERNdU5UYzVPVFlzTlM0NU1UazVPQzAxTGpneU9UazJMVE11TnpjNU9UZGFUVEl3TGpRd01EQXlMRE15TGprM01EQXpZeTB1TURZdU1ERXdNREV0TGpFeUxqQXlPVGszTFM0eE9EQXdOUzR3TkRrNU9Xd3RNeTQyTmprNU9DMDJMakE0T1RrM0xESXVPVEV3TURNdE1TNDBOVEF3TVdNdU1qVXVNalk1T1RZdU5UY3dNREV1TkRVNU9UWXVPVFF1TlRRNU9UbDJOaTQ1TkZwTk1qQXVOREF3TURJc01qSXVNVGN3TURSakxTNDBNREF3TWk0d09UazVPQzB1TnpVdU16SXdNREV0TVN3dU5qSnNMVEl1TlRrd01ETXRNUzR5T1RBd05Dd3pMalV6T1RrNExUVXVOVGM1T1RaakxqQXhNREF4TGpBeE1EQXhMakF6TURBekxqQXhNREF4TGpBMU1EQTFMakF4TURBeGRqWXVNak01T1RsYVRUSTNMak01TURBeExESXpMakk1TURBMGJDMHVPRFV3TURRdE1TNHpNekF3TWl3eUxqTTVNREF4TFRFdU1qRTVPVGN0TVM0MU16azVPQ3d5TGpVME9UazVXazB5TWk0NE9Dd3lNeTQ0TWpBd01Xd3lMamMyTURBeExURXVOREE1T1Rjc01TNHhOems1T1N3eExqZ3pNREF5ZGk0d01EazVOV3d0TVM0d056QXdNU3d4TGpjM01EQXlMVEl1T1RBNU9UY3RNUzQwTmpBd01tTXVNRE01T1RndExqRTBPVGsyTGpBMkxTNHlPVGs1T1M0d05pMHVORFU1T1RZc01DMHVNVEF3TURRdExqQXhNREF4TFM0eE9TMHVNREl3TURJdExqSTRNREF6V2sweU1pNHpORGs1T0N3eE5TNHpOMncyTGpFeUxETXVOVE13TUROakxTNHdORGs1T1M0eE5UazVOeTB1TURZNU9UVXVNek13TURJdExqQTJPVGsxTGpVc01Dd3VNVFU1T1RjdU1ERTVPVFl1TXpFdU1EWXVORFl3TURKc0xUSXVORFl3TURJc01TNHlOV2d0TGpBeE1EQXhiQzB6TGpZMU9UazNMVFV1TnpJd01ETnhMakF4TURBeExTNHdNVEF3TVM0d01UazVOaTB1TURJd01ESmFUVEl4TGpRd01EQXlMREUxTGprek1EQTFZeTR3TWprNU55d3dMQzR3TmkwdU1ERXdNREV1TURjNU9UWXRMakF5TURBeWJETXVOaklzTlM0Mk5UazVOeTB5TGpZd09UazVMREV1TXpNd01ESmpMUzR5TmpBd01TMHVNelU1T1RrdExqWTBNREF4TFM0Mk1pMHhMakE0T1RrM0xTNDNNams1T0hZdE5pNHlNems1T1ZwTk1qRXVOVE13TURNc016TmpMUzR3TkRBd05DMHVNREE1T1RVdExqQTRNREF5TFM0d01qazVOeTB1TVRNdExqQXlPVGszZGkwMkxqazBZeTR6T0MwdU1Ea3dNRE11TnpFNU9UY3RMakk1T1RrNUxqazJPVGszTFM0MU9UQXdNMnd5TGpnMU9UazVMREV1TkRJNU9Ua3RNeTQyT1RrNU5TdzJMakV6V2sweU1pNDFOekF3TVN3ek15NHlNakF3TTJ3ekxqVTJMVFV1T1RBd01ESXNNaTR6TVN3eExqRTJNREF6WXkwdU1ESXdNREl1TVRNdExqQXpPVGs0TGpJM09UazNMUzR3TXprNU9DNDBNVGs1T0N3d0xDNHhOVEF3TWk0d01UazVOaTR5T1RrNU9TNHdORGs1T1M0ME5Hd3ROUzQ0T0N3ekxqZzRXazB5T0M0NE9UQXdNU3d5Tnk0MU9UQXdNMnd0TWk0eU16azVPUzB4TGpFeUxqYzJPVGsyTFRFdU1qZ3dNRE1zTVM0MU1UQXdNU3d5TGpNMk1EQTFZeTB1TURFd01ERXVNREE1T1RVdExqQXlNREF5TGpBeU9UazNMUzR3TXprNU9DNHdNems1T0ZvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdQQzl6ZG1jJTJCJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQmNvbnRhaW5lciUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI1MjguNDQlMjIlMjB5JTNEJTIyMTUwLjk5OTk5OTk5OTk5OTc3JTIyJTIwd2lkdGglM0QlMjI0MiUyMiUyMGhlaWdodCUzRCUyMjU2JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTQ5JTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQk5WSURJQSUyME5lTW8lMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQmRpdiUyNmd0JTNCJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JSZXRyaWV2ZXIlMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0JzcGFuJTIwc3R5bGUlM0QlMjZxdW90JTNCYmFja2dyb3VuZC1jb2xvciUzQSUyMGluaXRpYWwlM0IlMjZxdW90JTNCJTI2Z3QlM0JFbWJlZGRpbmclMjZsdCUzQiUyRnNwYW4lMjZndCUzQiUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTI2bHQlM0IlMkZkaXYlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCY29udGFpbmVyJTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjQ4MiUyMiUyMHklM0QlMjIyMDElMjIlMjB3aWR0aCUzRCUyMjEzMiUyMiUyMGhlaWdodCUzRCUyMjUzLjQ4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTU0JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnWkdGMFlTMXVZVzFsUFNKTVlYbGxjaUExSWlCcFpEMGlUR0Y1WlhKZk5TSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05rT1RZME1qRTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUlIc21JM2hoT3lBZ0lDQWdJQ0FnYzNSeWIydGxMWGRwWkhSb09pQXdjSGc3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNaUI3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNObVptWTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc2dJQ0FnUEM5emRIbHNaVDRtSTNoaE95QWdQQzlrWldaelBpWWplR0U3SUNBOFp5QnBaRDBpUVc1bmJHVnpJajRtSTNoaE95QWdJQ0E4Y0dGMGFDQmtQU0pOTUN3d2RqUXlhRFF5VmpCSU1GcE5NekVzTVRCak1TNHhNREF3TkN3d0xESXNMamc1TURFMExESXNNaXd3TERFdU1UQXdNUzB1T0RrNU9UWXNNaTB5TERJdE1TNHdPVGs1T0N3d0xUSXRMamc1T1RrdE1pMHlMREF0TVM0eE1EazROaTQ1TURBd01pMHlMREl0TWxwTk16QXNNakJqTUN3eExqWTFPVFkzTFRFdU16TTVPVGNzTXkwekxETnpMVE10TVM0ek5EQXpNeTB6TFROak1DMHhMalkyTURFMkxERXVNelF3TURNdE15d3pMVE56TXl3eExqTXpPVGcwTERNc00xcE5NVFFzTVROak1TNHhNREF3TkN3d0xESXNMamc1TURFMExESXNNaXd3TERFdU1UQXdNUzB1T0RrNU9UWXNNaTB5TERJdE1TNHdPVGs1T0N3d0xUSXRMamc1T1RrdE1pMHlMREF0TVM0eE1EazROaTQ1TURBd01pMHlMREl0TWxwTk9Td3lNV014TGpFd01EQTBMREFzTWl3dU9Ea3dNVFFzTWl3eUxEQXNNUzR4TURBeExTNDRPVGs1Tml3eUxUSXNNaTB4TGpBNU9UazRMREF0TWkwdU9EazVPUzB5TFRJc01DMHhMakV3T1RnMkxqa3dNREF5TFRJc01pMHlXazB4T1N3ek1tTXRNUzR3T1RrNU9Dd3dMVEl0TGpnNU9Ua3RNaTB5TERBdE1TNHhNRGs0Tmk0NU1EQXdNaTB5TERJdE1pd3hMakV3TURBMExEQXNNaXd1T0Rrd01UUXNNaXd5TERBc01TNHhNREF4TFM0NE9UazVOaXd5TFRJc01scE5NalVzTXpkakxURXVNRGs1T1Rnc01DMHlMUzQ0T1RrNUxUSXRNaXd3TFRFdU1UQTVPRFl1T1RBd01ESXRNaXd5TFRJc01TNHhNREF3TkN3d0xESXNMamc1TURFMExESXNNaXd3TERFdU1UQXdNUzB1T0RrNU9UWXNNaTB5TERKYVRUTXhMamN6T1RrNUxETXpMamd4TURBMmJDMHhMakl4T1RrM0xTNDNNREF5TERRdU56Z3dNRE10TVM0eU56azNPUzB4TkM0ek1EQXdOUzA0TGpJMk1ESTFMVEUwTGpJNU9UazVMRGd1TWpZd01qVXNOQzQzT0RBd015d3hMakkzT1RjNUxURXVNakl3TURNdU56QXdNaTAxTGpRMU9UazJMVEV1TkRVNU9UWXNNUzQwTlRrNU5pMDFMalExT1RrMkxERXVNakl3TURNdExqY3dNREl0TVM0eU9EQXdNeXcwTGpjM01EQXlMREUwTGpJNU9UazVMVGd1TWpWV055NHlNRGs1Tm13dE15NDFMRE11TlhZdE1TNDBNVGs1TW13MExUUXNOQ3cwZGpFdU5ERTVPVEpzTFRNdU5TMHpMalYyTVRVdU5Xd3hOQzR5T1RBd05DdzRMakkxTFRFdU1qZ3dNRE10TkM0M056QXdNaXd4TGpJeU9UazRMamN3TURJc01TNDBOakF3TWl3MUxqUTFPVGsyTFRVdU5EWXdNRElzTVM0ME5UazVObG9pSUdOc1lYTnpQU0pqYkhNdE1TSXZQaVlqZUdFN0lDQThMMmMlMkJKaU40WVRzZ0lEeHdiMng1WjI5dUlIQnZhVzUwY3owaU16Y3VNakF3TURFZ016SXVNelV3TVNBek1TNDNNems1T1NBek15NDRNVEF3TmlBek1DNDFNakF3TWlBek15NHhNRGs0TmlBek5TNHpNREF3TlNBek1TNDRNekF3T0NBeU1TQXlNeTQxTmprNE1pQTJMamN3TURBeElETXhMamd6TURBNElERXhMalE0TURBMElETXpMakV3T1RnMklERXdMakkyTURBeElETXpMamd4TURBMklEUXVPREF3TURVZ016SXVNelV3TVNBMkxqSTJNREF4SURJMkxqZzVNREUwSURjdU5EZ3dNRFFnTWpZdU1UZzVPVFFnTmk0eU1EQXdNU0F6TUM0NU5UazVOaUF5TUM0MUlESXlMamN3T1RrMklESXdMalVnTnk0eU1EazVOaUF4TnlBeE1DNDNNRGs1TmlBeE55QTVMakk1TURBMElESXhJRFV1TWprd01EUWdNalVnT1M0eU9UQXdOQ0F5TlNBeE1DNDNNRGs1TmlBeU1TNDFJRGN1TWpBNU9UWWdNakV1TlNBeU1pNDNNRGs1TmlBek5TNDNPVEF3TkNBek1DNDVOVGs1TmlBek5DNDFNVEF3TVNBeU5pNHhPRGs1TkNBek5TNDNNems1T1NBeU5pNDRPVEF4TkNBek55NHlNREF3TVNBek1pNHpOVEF4SWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQR05wY21Oc1pTQnlQU0l5SWlCamVUMGlNelVpSUdONFBTSXlOU0lnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR4amFYSmpiR1VnY2owaU1pSWdZM2s5SWpFeUlpQmplRDBpTXpFaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4WTJseVkyeGxJSEk5SWpNaUlHTjVQU0l5TUNJZ1kzZzlJakkzSWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQR05wY21Oc1pTQnlQU0l5SWlCamVUMGlNekFpSUdONFBTSXhPU0lnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR4amFYSmpiR1VnY2owaU1pSWdZM2s5SWpJeklpQmplRDBpT1NJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lEeGphWEpqYkdVZ2NqMGlNaUlnWTNrOUlqRTFJaUJqZUQwaU1UUWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3UEM5emRtYyUyQiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3NDglMjIlMjB5JTNEJTIyMTU4JTIyJTIwd2lkdGglM0QlMjI0MiUyMiUyMGhlaWdodCUzRCUyMjQyJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTU3JTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQkxsYW1hUGFyc2UlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMjY3JTIyJTIweSUzRCUyMjIwMSUyMiUyMHdpZHRoJTNEJTIyMTMwJTIyJTIwaGVpZ2h0JTNEJTIyMzglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtNDUlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCRW50ZXJwcmlzZSUyNmx0JTNCYnIlMjZndCUzQkRhdGElMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyNjMlMjIlMjB5JTNEJTIyMjAxJTIyJTIwd2lkdGglM0QlMjIxMTMlMjIlMjBoZWlnaHQlM0QlMjIzOCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi01MyUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JWZWN0b3IlMjBEYXRhYmFzZSUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3MTIuNSUyMiUyMHklM0QlMjIyMDElMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjI4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTQwJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnWkdGMFlTMXVZVzFsUFNKTVlYbGxjaUExSWlCcFpEMGlUR0Y1WlhKZk5TSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05rT1RZME1qRTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUxDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0J6ZEhKdmEyVXRkMmxrZEdnNklEQndlRHNtSTNoaE95QWdJQ0FnSUgwbUkzaGhPeVlqZUdFN0lDQWdJQ0FnTG1Oc2N5MHlMQ0F1WTJ4ekxUTWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c0xYSjFiR1U2SUdWMlpXNXZaR1E3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTRMamN3TURBeElESXdMakU1T1RjeElESTRMamN3TURBeElESXpMalVnTWpVdU5EQTVPVGNnTWpNdU5TQXlPQzQzTURBd01TQXlNQzR4T1RrM01TSWdZMnhoYzNNOUltTnNjeTB4SWk4JTJCSmlONFlUc2dJRHh3WVhSb0lHUTlJazB5T1M0M01EQXdNU3d4T1M0MWRqVm9MVFYyTVRKb01USjJMVEUzYUMwM1drMHpNQzQzTURBd01Td3pNeTQxYUMwMGRpMHhhRFIyTVZwTk16UXVOekF3TURFc016QXVOV2d0T0hZdE1XZzRkakZhVFRNMExqY3dNREF4TERJM0xqVm9MVGgyTFRGb09IWXhXaUlnWTJ4aGMzTTlJbU5zY3kweElpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWswd0xEQjJOREpvTkRKV01FZ3dXazB4TVM0M01EQXdNU3d5TVM0MWFDMDNWalF1TldneE4zWTNhQzB4ZGkwMlNEVXVOekF3TURGMk1UVm9Obll4V2sweE1TNDJPU3d4TkM0MWRqRm9MVFV1Tmpsc05pNHhNaTAyTGpJd01ESXNNUzR3TkRrNU9TNDVPVEF5TXl3eUxqQXlNREF5TFRJdU1UWXdNVFlzTXk0eU5Td3pMak0zTURFeWFDMDBMakl6T1RrNWJDMHVNREl3TURJdU1ESXdNREpvTFRJdU5Xd3VNREV3TURFc01pNDVOems1T0ZwTk1qSXVOekF3TURFc01qa3VOV2d0TVRCV01USXVOV2d4TjNZMExqZ3pNREE0YUMweGRpMHpMamd6TURBNGFDMHhOWFl4TldnNWRqRmFUVEkyTGpVeE1EQXhMREU0TGpZNE9UazBiQzB5TGpNek1EQXlMREl1TXpNd01EZ3RNaTR6TnkwdU5qSTVPRGd0TVM0eU1qazVPQzAwTGpVNU1ETXpMalE0T1RrNUxTNHhNams0T0dNdU5ERTVPVGd0TGpFd09UZzJMamM0T1RrNExTNHhOams1TWl3eExqRTBPVGsyTFM0eE5qazVNaXd5TGpBeU1EQXlMREFzTXk0M05EQXdOU3d4TGpNMU1ERXNOQzR5T1RBd05Dd3pMakU0T1RrMFdrMHlNaTR5TURBd01Td3lNM1l6TGpBMk9UZ3lZeTB1TlRrd01ETXVNamd3TWpjdE1TNHlOUzQwTXpBeE9DMHhMamt5T1RrNUxqUXpNREU0TFRJdU5USXdNRElzTUMwMExqVTNNREF4TFRJdU1EVXdNamt0TkM0MU56QXdNUzAwTGpVMk9UZ3lMREF0TWk0d05qQXdOaXd4TGpNNE9UazFMVE11T0Rjd01USXNNeTR6T0RrNU5TMDBMalF4TURFMmJDNDBPVEF3TlMwdU1USTVPRGdzTVM0d09UazVPQ3cwTGpFeU9UZzRMREl1TXpjdU5qSTVPRGd0TGpnME9UazRMamcxTURGYVRUTTNMamN3TURBeExETTNMalZvTFRFMGRpMHhNeTQzTURBeWJEVXVNamc1T1RndE5TNHlPVGs0YURndU56RXdNREoyTVRsYUlpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJNExqazRPVGs1TERFNExqVnNMVFV1TWpnNU9UZ3NOUzR5T1RrNGRqRXpMamN3TURKb01UUjJMVEU1YUMwNExqY3hNREF5V2sweU9DNDNNREF3TVN3eU1DNHhPVGszTVhZekxqTXdNREk1YUMwekxqSTVNREEwYkRNdU1qa3dNRFF0TXk0ek1EQXlPVnBOTXpZdU56QXdNREVzTXpZdU5XZ3RNVEoyTFRFeWFEVjJMVFZvTjNZeE4xb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOGNtVmpkQ0JvWldsbmFIUTlJakVpSUhkcFpIUm9QU0k0SWlCNVBTSXlOaTQxSWlCNFBTSXlOaTQzTURBd01TSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHh5WldOMElHaGxhV2RvZEQwaU1TSWdkMmxrZEdnOUlqZ2lJSGs5SWpJNUxqVWlJSGc5SWpJMkxqY3dNREF4SWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJeElpQjNhV1IwYUQwaU5DSWdlVDBpTXpJdU5TSWdlRDBpTWpZdU56QXdNREVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTVMamN3TURBeElERXlMalVnTWprdU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRNdU5TQXhNeTQzTURBd01TQXhNeTQxSURFekxqY3dNREF4SURJNExqVWdNakl1TnpBd01ERWdNamd1TlNBeU1pNDNNREF3TVNBeU9TNDFJREV5TGpjd01EQXhJREk1TGpVZ01USXVOekF3TURFZ01USXVOU0F5T1M0M01EQXdNU0F4TWk0MUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJMkxqVXhNREF4TERFNExqWTRPVGswYkMweUxqTXpNREF5TERJdU16TXdNRGd0TWk0ek55MHVOakk1T0RndE1TNHlNams1T0MwMExqVTVNRE16TGpRNE9UazVMUzR4TWprNE9HTXVOREU1T1RndExqRXdPVGcyTGpjNE9UazRMUzR4TmprNU1pd3hMakUwT1RrMkxTNHhOams1TWl3eUxqQXlNREF5TERBc015NDNOREF3TlN3eExqTTFNREVzTkM0eU9UQXdOQ3d6TGpFNE9UazBXaUlnWTJ4aGMzTTlJbU5zY3kweklpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWsweU15NHdORGs1T1N3eU1pNHhORGs1YkMwdU9EUTVPVGd1T0RVd01YWXpMakEyT1RneVl5MHVOVGt3TURNdU1qZ3dNamN0TVM0eU5TNDBNekF4T0MweExqa3lPVGs1TGpRek1ERTRMVEl1TlRJd01ESXNNQzAwTGpVM01EQXhMVEl1TURVd01qa3ROQzQxTnpBd01TMDBMalUyT1RneUxEQXRNaTR3TmpBd05pd3hMak00T1RrMUxUTXVPRGN3TVRJc015NHpPRGs1TlMwMExqUXhNREUyYkM0ME9UQXdOUzB1TVRJNU9EZ3NNUzR3T1RrNU9DdzBMakV5T1RnNExESXVNemN1TmpJNU9EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BIQnZiSGxuYjI0Z2NHOXBiblJ6UFNJeU1TNDNNREF3TVNBMExqVWdNakV1TnpBd01ERWdNVEV1TlNBeU1DNDNNREF3TVNBeE1TNDFJREl3TGpjd01EQXhJRFV1TlNBMUxqY3dNREF4SURVdU5TQTFMamN3TURBeElESXdMalVnTVRFdU56QXdNREVnTWpBdU5TQXhNUzQzTURBd01TQXlNUzQxSURRdU56QXdNREVnTWpFdU5TQTBMamN3TURBeElEUXVOU0F5TVM0M01EQXdNU0EwTGpVaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakU0TGpRMElERXhMalVnTVRRdU1qQXdNREVnTVRFdU5TQXhOQzR4TnprNU9TQXhNUzQxTWpBd01pQXhNUzQyTnprNU9TQXhNUzQxTWpBd01pQXhNUzQyT1NBeE5DNDFJREV4TGpZNUlERTFMalVnTmlBeE5TNDFJREV5TGpFeUlEa3VNams1T0NBeE15NHhOams1T0NBeE1DNHlPVEF3TkNBeE5TNHhPU0E0TGpFeU9UZzRJREU0TGpRMElERXhMalVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN1BDOXpkbWMlMkIlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMTA5MiUyMiUyMHklM0QlMjI1NzMlMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNDIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtOTAlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyc2hhcGUlM0RpbWFnZSUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRGJvdHRvbSUzQmxhYmVsQmFja2dyb3VuZENvbG9yJTNEZGVmYXVsdCUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jhc3BlY3QlM0RmaXhlZCUzQmltYWdlQXNwZWN0JTNEMCUzQmltYWdlJTNEZGF0YSUzQWltYWdlJTJGc3ZnJTJCeG1sJTJDUEhOMlp5QjRiV3h1Y3owaWFIUjBjRG92TDNkM2R5NTNNeTV2Y21jdk1qQXdNQzl6ZG1jaUlIWnBaWGRDYjNnOUlqQWdNQ0EwTWlBMU5pSWdaR0YwWVMxdVlXMWxQU0pNWVhsbGNpQXhJaUJwWkQwaVRHRjVaWEpmTVNJJTJCSmlONFlUc2dJRHhrWldaelBpWWplR0U3SUNBZ0lEeHpkSGxzWlQ0bUkzaGhPeUFnSUNBZ0lDNWpiSE10TVNCN0ppTjRZVHNnSUNBZ0lDQWdJR1pwYkd3NklDTm1abVk3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNU3dnTG1Oc2N5MHlJSHNtSTNoaE95QWdJQ0FnSUNBZ2MzUnliMnRsTFhkcFpIUm9PaUF3Y0hnN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzbUkzaGhPeUFnSUNBZ0lDNWpiSE10TWlCN0ppTjRZVHNnSUNBZ0lDQWdJR1pwYkd3NklDTTNObUk1TURBN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzZ0lDQWdQQzl6ZEhsc1pUNG1JM2hoT3lBZ1BDOWtaV1p6UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakFnTXpndU1ERTFOaklnTUNBME1pNHdNVFUyTWlBeU1TQTFOQzR3TVRVMk1pQTBNaUEwTWk0d01UVTJNaUEwTWlBek9DNHdNVFUyTWlBeU1TQTFNQzR3TVRVMk1pQXdJRE00TGpBeE5UWXlJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BHYyUyQkppTjRZVHNnSUNBZ1BIQnZiSGxuYjI0Z2NHOXBiblJ6UFNJME1pQXhNaTR3TURRek15QTBNaUF6Tmk0d01UUXpOQ0F5TVNBME9DNHdNalF6TlNBd0lETTJMakF4TkRNMElEQWdNVEl1TURBME16TWdNakVnTGpBd05ETXpJRFF5SURFeUxqQXdORE16SWlCamJHRnpjejBpWTJ4ekxURWlMejRtSTNoaE95QWdJQ0E4Y0dGMGFDQmtQU0pOTWpFdU1EQXdPVGdzTUV3d0xERXlMakF3TWpreWRqSTBMakF4TkRneGJESXhMakF3TURrNExERXlMakF3TlRreExESXdMams1T1RBeUxURXlMakF3TlRreFZqRXlMakF3TWpreVRESXhMakF3TURrNExEQmFUVFF4TERNMUxqUXpOekU1YkMweE9TNDFMREV4TGpFME9EZzJkaTAyTGpFek9UUTBhQzB4ZGpZdU1UTTRNelJNTVN3ek5TNDBNemN4TWxZeE15NHlOekV6YkRVdU1UUXdNVFFzTXk0ME16TTVOQzQxTkRrNExTNDROREF6T0MwMUxqSTNNamN4TFRNdU5URTJPRGRNTWpFdU1EQXdPVGdzTVM0eE5USXpObXd4T1M0Mk16VTNOQ3d4TVM0eE5qTXlNaTAxTGpNeU5qY3lMRE11TmpBd056UXVOVFE1T1RrdU9ESTROaklzTlM0eE5EQXdNUzB6TGpReU16RTNkakl5TGpFeE5UUXlXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR3dlp6NG1JM2hoT3lBZ1BIQmhkR2dnWkQwaVRUTXdMalF3TURBeUxESTJMamt3TURBeVl5MHVNakl3TURNc01DMHVORE13TURVdU1ETTVPVGd0TGpZekxqRXdPVGs1YkMweExqYzNNREF5TFRJdU56WTVPVFoyTFM0d01UQXdNV3d4TGpjM01EQXlMVEl1T1RJNU9UbGpMakU1T1RrMUxqQTJMalF3T1RrM0xqQTVPVGs0TGpZekxqQTVPVGs0TERFdU1EazVPVGdzTUN3eUxTNDVNREF3TWl3eUxUSnpMUzQ1TURBd01pMHlMVEl0TW1NdExqVTNNREF4TERBdE1TNHdPVEF3TXk0eU16azVPUzB4TGpRMU1EQXhMall6YkMwMkxqRXlMVE11TlRNd01ETmpMakEwT1RrNUxTNHhOVGs1Tnk0d056QXdNUzB1TXpJNU9UWXVNRGN3TURFdExqVXNNQzB4TGpBNU9UazRMUzQ1TURBd01pMHlMVEl0TWkweExqRXdNREEwTERBdE1pd3VPVEF3TURJdE1pd3lMREFzTGpFNUxqQXlPVGszTGpNNExqQTNPVGsyTGpVMU1EQTFiQzAyTGpBeU9UazNMRE11TkRjNU9UaGpMUzR6TlRrNU9TMHVNemt3TURFdExqZzRMUzQyTXkweExqUTFNREF4TFM0Mk15MHhMakE1T1RrNExEQXRNaXd1T1RBd01ESXRNaXd5Y3k0NU1EQXdNaXd5TERJc01tTXVNVFk1T1Rnc01Dd3VNelF3TURNdExqQXlNREF5TGpRNE9UazVMUzR3Tm13eExqZ3lNREF4TERNdU1ERXdNREV0TVM0Mk56azVPU3d5TGpZME9UazJZeTB1TWpBd01ERXRMakEyTFM0ME1UQXdNeTB1TURrNU9UZ3RMall6TFM0d09UazVPQzB4TGpBNU9UazRMREF0TWl3dU9UQXdNREl0TWl3eWN5NDVNREF3TWl3eUxESXNNbU11TlRJd01ESXNNQ3d4TFM0eU1EQXdNU3d4TGpNME9UazRMUzQxTXpBd00ydzJMakV6TERNdU9UZ3dNRFJqTFM0d05EazVPUzR4TmprNU9DMHVNRGM1T1RZdU16VTVPVGt0TGpBM09UazJMalUwT1RrNUxEQXNNUzR3T1RrNU9DNDRPVGs1Tml3eUxESXNNaXd4TGpBNU9UazRMREFzTWkwdU9UQXdNRElzTWkweUxEQXRMakl4T1RrM0xTNHdOREF3TkMwdU5ESTVPVGt0TGpFeE1EQTFMUzQyTTJ3MkxqRXlMVFF1TURRNU9UbGpMak0yTURBMUxqUXhPVGs0TGprd01EQXlMalkzT1RrNUxERXVORGt3TURVdU5qYzVPVGtzTVM0d09UazVPQ3d3TERJdExqa3dNREF5TERJdE1uTXRMamt3TURBeUxUSXRNaTB5V2sweE9TNDBPRGs1T1N3eE5TNDBNVEF3TTJ3dE15NDFPREF3TWl3MUxqWTBNREF4TFRJdU5EUTVPVFV0TVM0eU16QXdOR011TURFNU9UWXRMakV6TGpBek9UazRMUzR5TnprNU55NHdNems1T0MwdU5ERTVPVGdzTUMwdU1UWTVPVGd0TGpBeU1EQXlMUzR6TkRBd015MHVNRGN3TURFdExqVnNOaTR3TmkwekxqUTRPVGs1V2sweE9DNDVNVGs1T0N3eU5DNHpOakF3TldNdU1ERXdNREV1TURnNU9UY3VNREl3TURJdU1UWTVPVGd1TURRNU9Ua3VNalZzTFRJdU9UTTVPVFFzTVM0ME5qazVOeTB4TGpBME1EQTBMVEV1TnpFNU9UY3NNUzR5T0RBd015MHlMakF5TURBeUxESXVOalk1T1Rnc01TNHpOREF3TTJNdExqQXlNREF5TGpFeU9UazBMUzR3TXprNU9DNHlOems1TnkwdU1ETTVPVGd1TkRFNU9UZ3NNQ3d1TURnNU9UY3VNREE1T1RVdU1UYzVPVGt1TURFNU9UWXVNall3TURGYVRURXlMamczTERJd0xqZzFNREEwWXk0d05EazVPUzB1TURRd01EUXVNRGt3TURNdExqQTVNREF6TGpFekxTNHhOREF3TVd3eUxqTTRMREV1TVRjNU9Ua3RMamsyTURBeUxERXVOVEV3TURFdE1TNDFORGs1T1MweUxqVTBPVGs1V2sweE1pNDVNRGs1Tnl3eU55NDJOREF3TVd3dU1EWXRMakE0T1RrM0xERXVOREl3TURRdE1pNHlOREF3TlM0M016azVPU3d4TGpJeU1EQXpMVEl1TVRNc01TNHdOaTB1TURrd01ETXVNRFE1T1RsYVRURXpMak01TURBeExESTVMalV6TURBell5NHdOekF3TVMwdU1qQXdNREV1TVRBNU9Ua3RMalF4TURBekxqRXdPVGs1TFM0Mk15d3dMUzR4TkRBd01TMHVNREl3TURJdExqSTRPVGs0TFM0d016azVPQzB1TkRFNU9UaHNNaTR4TnprNU9TMHhMakE1TURBekxETXVOVGM1T1RZc05TNDVNVGs1T0MwMUxqZ3lPVGsyTFRNdU56YzVPVGRhVFRJd0xqUXdNREF5TERNeUxqazNNREF6WXkwdU1EWXVNREV3TURFdExqRXlMakF5T1RrM0xTNHhPREF3TlM0d05EazVPV3d0TXk0Mk5qazVPQzAyTGpBNE9UazNMREl1T1RFd01ETXRNUzQwTlRBd01XTXVNalV1TWpZNU9UWXVOVGN3TURFdU5EVTVPVFl1T1RRdU5UUTVPVGwyTmk0NU5GcE5NakF1TkRBd01ESXNNakl1TVRjd01EUmpMUzQwTURBd01pNHdPVGs1T0MwdU56VXVNekl3TURFdE1Td3VOakpzTFRJdU5Ua3dNRE10TVM0eU9UQXdOQ3d6TGpVek9UazRMVFV1TlRjNU9UWmpMakF4TURBeExqQXhNREF4TGpBek1EQXpMakF4TURBeExqQTFNREExTGpBeE1EQXhkall1TWpNNU9UbGFUVEkzTGpNNU1EQXhMREl6TGpJNU1EQTBiQzB1T0RVd01EUXRNUzR6TXpBd01pd3lMak01TURBeExURXVNakU1T1RjdE1TNDFNems1T0N3eUxqVTBPVGs1V2sweU1pNDRPQ3d5TXk0NE1qQXdNV3d5TGpjMk1EQXhMVEV1TkRBNU9UY3NNUzR4TnprNU9Td3hMamd6TURBeWRpNHdNRGs1Tld3dE1TNHdOekF3TVN3eExqYzNNREF5TFRJdU9UQTVPVGN0TVM0ME5qQXdNbU11TURNNU9UZ3RMakUwT1RrMkxqQTJMUzR5T1RrNU9TNHdOaTB1TkRVNU9UWXNNQzB1TVRBd01EUXRMakF4TURBeExTNHhPUzB1TURJd01ESXRMakk0TURBeldrMHlNaTR6TkRrNU9Dd3hOUzR6TjJ3MkxqRXlMRE11TlRNd01ETmpMUzR3TkRrNU9TNHhOVGs1TnkwdU1EWTVPVFV1TXpNd01ESXRMakEyT1RrMUxqVXNNQ3d1TVRVNU9UY3VNREU1T1RZdU16RXVNRFl1TkRZd01ESnNMVEl1TkRZd01ESXNNUzR5TldndExqQXhNREF4YkMwekxqWTFPVGszTFRVdU56SXdNRE54TGpBeE1EQXhMUzR3TVRBd01TNHdNVGs1TmkwdU1ESXdNREphVFRJeExqUXdNREF5TERFMUxqa3pNREExWXk0d01qazVOeXd3TEM0d05pMHVNREV3TURFdU1EYzVPVFl0TGpBeU1EQXliRE11TmpJc05TNDJOVGs1TnkweUxqWXdPVGs1TERFdU16TXdNREpqTFM0eU5qQXdNUzB1TXpVNU9Ua3RMalkwTURBeExTNDJNaTB4TGpBNE9UazNMUzQzTWprNU9IWXROaTR5TXprNU9WcE5NakV1TlRNd01ETXNNek5qTFM0d05EQXdOQzB1TURBNU9UVXRMakE0TURBeUxTNHdNams1TnkwdU1UTXRMakF5T1RrM2RpMDJMamswWXk0ek9DMHVNRGt3TURNdU56RTVPVGN0TGpJNU9UazVMamsyT1RrM0xTNDFPVEF3TTJ3eUxqZzFPVGs1TERFdU5ESTVPVGt0TXk0Mk9UazVOU3cyTGpFeldrMHlNaTQxTnpBd01Td3pNeTR5TWpBd00yd3pMalUyTFRVdU9UQXdNRElzTWk0ek1Td3hMakUyTURBell5MHVNREl3TURJdU1UTXRMakF6T1RrNExqSTNPVGszTFM0d016azVPQzQwTVRrNU9Dd3dMQzR4TlRBd01pNHdNVGs1Tmk0eU9UazVPUzR3TkRrNU9TNDBOR3d0TlM0NE9Dd3pMamc0V2sweU9DNDRPVEF3TVN3eU55NDFPVEF3TTJ3dE1pNHlNems1T1MweExqRXlMamMyT1RrMkxURXVNamd3TURNc01TNDFNVEF3TVN3eUxqTTJNREExWXkwdU1ERXdNREV1TURBNU9UVXRMakF5TURBeUxqQXlPVGszTFM0d016azVPQzR3TXprNU9Gb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3UEM5emRtYyUyQiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0Jjb250YWluZXIlM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyOTYxLjUlMjIlMjB5JTNEJTIyNTYzLjk5OTk5OTk5OTk5OTglMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNTYlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtOTElMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCTlZJRElBJTIwTklNJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQmNvbnRhaW5lciUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI5MjYuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExNCUyMiUyMGhlaWdodCUzRCUyMjUzLjQ4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTM5JTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQkJsb2clMjBQb3N0JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjEwNTYuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjM4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTIzJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnWkdGMFlTMXVZVzFsUFNKTVlYbGxjaUExSWlCcFpEMGlUR0Y1WlhKZk5TSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05rT1RZME1qRTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUxDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0J6ZEhKdmEyVXRkMmxrZEdnNklEQndlRHNtSTNoaE95QWdJQ0FnSUgwbUkzaGhPeVlqZUdFN0lDQWdJQ0FnTG1Oc2N5MHlMQ0F1WTJ4ekxUTWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c0xYSjFiR1U2SUdWMlpXNXZaR1E3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTRMamN3TURBeElESXdMakU1T1RjeElESTRMamN3TURBeElESXpMalVnTWpVdU5EQTVPVGNnTWpNdU5TQXlPQzQzTURBd01TQXlNQzR4T1RrM01TSWdZMnhoYzNNOUltTnNjeTB4SWk4JTJCSmlONFlUc2dJRHh3WVhSb0lHUTlJazB5T1M0M01EQXdNU3d4T1M0MWRqVm9MVFYyTVRKb01USjJMVEUzYUMwM1drMHpNQzQzTURBd01Td3pNeTQxYUMwMGRpMHhhRFIyTVZwTk16UXVOekF3TURFc016QXVOV2d0T0hZdE1XZzRkakZhVFRNMExqY3dNREF4TERJM0xqVm9MVGgyTFRGb09IWXhXaUlnWTJ4aGMzTTlJbU5zY3kweElpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWswd0xEQjJOREpvTkRKV01FZ3dXazB4TVM0M01EQXdNU3d5TVM0MWFDMDNWalF1TldneE4zWTNhQzB4ZGkwMlNEVXVOekF3TURGMk1UVm9Obll4V2sweE1TNDJPU3d4TkM0MWRqRm9MVFV1Tmpsc05pNHhNaTAyTGpJd01ESXNNUzR3TkRrNU9TNDVPVEF5TXl3eUxqQXlNREF5TFRJdU1UWXdNVFlzTXk0eU5Td3pMak0zTURFeWFDMDBMakl6T1RrNWJDMHVNREl3TURJdU1ESXdNREpvTFRJdU5Xd3VNREV3TURFc01pNDVOems1T0ZwTk1qSXVOekF3TURFc01qa3VOV2d0TVRCV01USXVOV2d4TjNZMExqZ3pNREE0YUMweGRpMHpMamd6TURBNGFDMHhOWFl4TldnNWRqRmFUVEkyTGpVeE1EQXhMREU0TGpZNE9UazBiQzB5TGpNek1EQXlMREl1TXpNd01EZ3RNaTR6TnkwdU5qSTVPRGd0TVM0eU1qazVPQzAwTGpVNU1ETXpMalE0T1RrNUxTNHhNams0T0dNdU5ERTVPVGd0TGpFd09UZzJMamM0T1RrNExTNHhOams1TWl3eExqRTBPVGsyTFM0eE5qazVNaXd5TGpBeU1EQXlMREFzTXk0M05EQXdOU3d4TGpNMU1ERXNOQzR5T1RBd05Dd3pMakU0T1RrMFdrMHlNaTR5TURBd01Td3lNM1l6TGpBMk9UZ3lZeTB1TlRrd01ETXVNamd3TWpjdE1TNHlOUzQwTXpBeE9DMHhMamt5T1RrNUxqUXpNREU0TFRJdU5USXdNRElzTUMwMExqVTNNREF4TFRJdU1EVXdNamt0TkM0MU56QXdNUzAwTGpVMk9UZ3lMREF0TWk0d05qQXdOaXd4TGpNNE9UazFMVE11T0Rjd01USXNNeTR6T0RrNU5TMDBMalF4TURFMmJDNDBPVEF3TlMwdU1USTVPRGdzTVM0d09UazVPQ3cwTGpFeU9UZzRMREl1TXpjdU5qSTVPRGd0TGpnME9UazRMamcxTURGYVRUTTNMamN3TURBeExETTNMalZvTFRFMGRpMHhNeTQzTURBeWJEVXVNamc1T1RndE5TNHlPVGs0YURndU56RXdNREoyTVRsYUlpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJNExqazRPVGs1TERFNExqVnNMVFV1TWpnNU9UZ3NOUzR5T1RrNGRqRXpMamN3TURKb01UUjJMVEU1YUMwNExqY3hNREF5V2sweU9DNDNNREF3TVN3eU1DNHhPVGszTVhZekxqTXdNREk1YUMwekxqSTVNREEwYkRNdU1qa3dNRFF0TXk0ek1EQXlPVnBOTXpZdU56QXdNREVzTXpZdU5XZ3RNVEoyTFRFeWFEVjJMVFZvTjNZeE4xb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOGNtVmpkQ0JvWldsbmFIUTlJakVpSUhkcFpIUm9QU0k0SWlCNVBTSXlOaTQxSWlCNFBTSXlOaTQzTURBd01TSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHh5WldOMElHaGxhV2RvZEQwaU1TSWdkMmxrZEdnOUlqZ2lJSGs5SWpJNUxqVWlJSGc5SWpJMkxqY3dNREF4SWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJeElpQjNhV1IwYUQwaU5DSWdlVDBpTXpJdU5TSWdlRDBpTWpZdU56QXdNREVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTVMamN3TURBeElERXlMalVnTWprdU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRNdU5TQXhNeTQzTURBd01TQXhNeTQxSURFekxqY3dNREF4SURJNExqVWdNakl1TnpBd01ERWdNamd1TlNBeU1pNDNNREF3TVNBeU9TNDFJREV5TGpjd01EQXhJREk1TGpVZ01USXVOekF3TURFZ01USXVOU0F5T1M0M01EQXdNU0F4TWk0MUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJMkxqVXhNREF4TERFNExqWTRPVGswYkMweUxqTXpNREF5TERJdU16TXdNRGd0TWk0ek55MHVOakk1T0RndE1TNHlNams1T0MwMExqVTVNRE16TGpRNE9UazVMUzR4TWprNE9HTXVOREU1T1RndExqRXdPVGcyTGpjNE9UazRMUzR4TmprNU1pd3hMakUwT1RrMkxTNHhOams1TWl3eUxqQXlNREF5TERBc015NDNOREF3TlN3eExqTTFNREVzTkM0eU9UQXdOQ3d6TGpFNE9UazBXaUlnWTJ4aGMzTTlJbU5zY3kweklpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWsweU15NHdORGs1T1N3eU1pNHhORGs1YkMwdU9EUTVPVGd1T0RVd01YWXpMakEyT1RneVl5MHVOVGt3TURNdU1qZ3dNamN0TVM0eU5TNDBNekF4T0MweExqa3lPVGs1TGpRek1ERTRMVEl1TlRJd01ESXNNQzAwTGpVM01EQXhMVEl1TURVd01qa3ROQzQxTnpBd01TMDBMalUyT1RneUxEQXRNaTR3TmpBd05pd3hMak00T1RrMUxUTXVPRGN3TVRJc015NHpPRGs1TlMwMExqUXhNREUyYkM0ME9UQXdOUzB1TVRJNU9EZ3NNUzR3T1RrNU9DdzBMakV5T1RnNExESXVNemN1TmpJNU9EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BIQnZiSGxuYjI0Z2NHOXBiblJ6UFNJeU1TNDNNREF3TVNBMExqVWdNakV1TnpBd01ERWdNVEV1TlNBeU1DNDNNREF3TVNBeE1TNDFJREl3TGpjd01EQXhJRFV1TlNBMUxqY3dNREF4SURVdU5TQTFMamN3TURBeElESXdMalVnTVRFdU56QXdNREVnTWpBdU5TQXhNUzQzTURBd01TQXlNUzQxSURRdU56QXdNREVnTWpFdU5TQTBMamN3TURBeElEUXVOU0F5TVM0M01EQXdNU0EwTGpVaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakU0TGpRMElERXhMalVnTVRRdU1qQXdNREVnTVRFdU5TQXhOQzR4TnprNU9TQXhNUzQxTWpBd01pQXhNUzQyTnprNU9TQXhNUzQxTWpBd01pQXhNUzQyT1NBeE5DNDFJREV4TGpZNUlERTFMalVnTmlBeE5TNDFJREV5TGpFeUlEa3VNams1T0NBeE15NHhOams1T0NBeE1DNHlPVEF3TkNBeE5TNHhPU0E0TGpFeU9UZzRJREU0TGpRMElERXhMalVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN1BDOXpkbWMlMkIlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIyMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyNTg2JTIyJTIweSUzRCUyMjU3MyUyMiUyMHdpZHRoJTNEJTIyNDIlMjIlMjBoZWlnaHQlM0QlMjI0MiUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0xNSUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUExTmlJZ1pHRjBZUzF1WVcxbFBTSk1ZWGxsY2lBeElpQnBaRDBpVEdGNVpYSmZNU0klMkJKaU40WVRzZ0lEeGtaV1p6UGlZamVHRTdJQ0FnSUR4emRIbHNaVDRtSTNoaE95QWdJQ0FnSUM1amJITXRNU0I3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNObVptWTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUlIc21JM2hoT3lBZ0lDQWdJQ0FnYzNSeWIydGxMWGRwWkhSb09pQXdjSGc3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNaUI3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNNM05tSTVNREE3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqQWdNemd1TURFMU5qSWdNQ0EwTWk0d01UVTJNaUF5TVNBMU5DNHdNVFUyTWlBME1pQTBNaTR3TVRVMk1pQTBNaUF6T0M0d01UVTJNaUF5TVNBMU1DNHdNVFUyTWlBd0lETTRMakF4TlRZeUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEdjJTJCSmlONFlUc2dJQ0FnUEhCdmJIbG5iMjRnY0c5cGJuUnpQU0kwTWlBeE1pNHdNRFF6TXlBME1pQXpOaTR3TVRRek5DQXlNU0EwT0M0d01qUXpOU0F3SURNMkxqQXhORE0wSURBZ01USXVNREEwTXpNZ01qRWdMakF3TkRNeklEUXlJREV5TGpBd05ETXpJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5NakV1TURBd09UZ3NNRXd3TERFeUxqQXdNamt5ZGpJMExqQXhORGd4YkRJeExqQXdNRGs0TERFeUxqQXdOVGt4TERJd0xqazVPVEF5TFRFeUxqQXdOVGt4VmpFeUxqQXdNamt5VERJeExqQXdNRGs0TERCYVRUUXhMRE0xTGpRek56RTViQzB4T1M0MUxERXhMakUwT0RnMmRpMDJMakV6T1RRMGFDMHhkall1TVRNNE16Uk1NU3d6TlM0ME16Y3hNbFl4TXk0eU56RXpiRFV1TVRRd01UUXNNeTQwTXpNNU5DNDFORGs0TFM0NE5EQXpPQzAxTGpJM01qY3hMVE11TlRFMk9EZE1NakV1TURBd09UZ3NNUzR4TlRJek5td3hPUzQyTXpVM05Dd3hNUzR4TmpNeU1pMDFMak15TmpjeUxETXVOakF3TnpRdU5UUTVPVGt1T0RJNE5qSXNOUzR4TkRBd01TMHpMalF5TXpFM2RqSXlMakV4TlRReVdpSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHd2Wno0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRNd0xqUXdNREF5TERJMkxqa3dNREF5WXkwdU1qSXdNRE1zTUMwdU5ETXdNRFV1TURNNU9UZ3RMall6TGpFd09UazViQzB4TGpjM01EQXlMVEl1TnpZNU9UWjJMUzR3TVRBd01Xd3hMamMzTURBeUxUSXVPVEk1T1RsakxqRTVPVGsxTGpBMkxqUXdPVGszTGpBNU9UazRMall6TGpBNU9UazRMREV1TURrNU9UZ3NNQ3d5TFM0NU1EQXdNaXd5TFRKekxTNDVNREF3TWkweUxUSXRNbU10TGpVM01EQXhMREF0TVM0d09UQXdNeTR5TXprNU9TMHhMalExTURBeExqWXpiQzAyTGpFeUxUTXVOVE13TUROakxqQTBPVGs1TFM0eE5UazVOeTR3TnpBd01TMHVNekk1T1RZdU1EY3dNREV0TGpVc01DMHhMakE1T1RrNExTNDVNREF3TWkweUxUSXRNaTB4TGpFd01EQTBMREF0TWl3dU9UQXdNREl0TWl3eUxEQXNMakU1TGpBeU9UazNMak00TGpBM09UazJMalUxTURBMWJDMDJMakF5T1RrM0xETXVORGM1T1RoakxTNHpOVGs1T1MwdU16a3dNREV0TGpnNExTNDJNeTB4TGpRMU1EQXhMUzQyTXkweExqQTVPVGs0TERBdE1pd3VPVEF3TURJdE1pd3ljeTQ1TURBd01pd3lMRElzTW1NdU1UWTVPVGdzTUN3dU16UXdNRE10TGpBeU1EQXlMalE0T1RrNUxTNHdObXd4TGpneU1EQXhMRE11TURFd01ERXRNUzQyTnprNU9Td3lMalkwT1RrMll5MHVNakF3TURFdExqQTJMUzQwTVRBd015MHVNRGs1T1RndExqWXpMUzR3T1RrNU9DMHhMakE1T1RrNExEQXRNaXd1T1RBd01ESXRNaXd5Y3k0NU1EQXdNaXd5TERJc01tTXVOVEl3TURJc01Dd3hMUzR5TURBd01Td3hMak0wT1RrNExTNDFNekF3TTJ3MkxqRXpMRE11T1Rnd01EUmpMUzR3TkRrNU9TNHhOams1T0MwdU1EYzVPVFl1TXpVNU9Ua3RMakEzT1RrMkxqVTBPVGs1TERBc01TNHdPVGs1T0M0NE9UazVOaXd5TERJc01pd3hMakE1T1RrNExEQXNNaTB1T1RBd01ESXNNaTB5TERBdExqSXhPVGszTFM0d05EQXdOQzB1TkRJNU9Ua3RMakV4TURBMUxTNDJNMncyTGpFeUxUUXVNRFE1T1RsakxqTTJNREExTGpReE9UazRMamt3TURBeUxqWTNPVGs1TERFdU5Ea3dNRFV1TmpjNU9Ua3NNUzR3T1RrNU9Dd3dMREl0TGprd01EQXlMREl0TW5NdExqa3dNREF5TFRJdE1pMHlXazB4T1M0ME9EazVPU3d4TlM0ME1UQXdNMnd0TXk0MU9EQXdNaXcxTGpZME1EQXhMVEl1TkRRNU9UVXRNUzR5TXpBd05HTXVNREU1T1RZdExqRXpMakF6T1RrNExTNHlOems1Tnk0d016azVPQzB1TkRFNU9UZ3NNQzB1TVRZNU9UZ3RMakF5TURBeUxTNHpOREF3TXkwdU1EY3dNREV0TGpWc05pNHdOaTB6TGpRNE9UazVXazB4T0M0NU1UazVPQ3d5TkM0ek5qQXdOV011TURFd01ERXVNRGc1T1RjdU1ESXdNREl1TVRZNU9UZ3VNRFE1T1RrdU1qVnNMVEl1T1RNNU9UUXNNUzQwTmprNU55MHhMakEwTURBMExURXVOekU1T1Rjc01TNHlPREF3TXkweUxqQXlNREF5TERJdU5qWTVPVGdzTVM0ek5EQXdNMk10TGpBeU1EQXlMakV5T1RrMExTNHdNems1T0M0eU56azVOeTB1TURNNU9UZ3VOREU1T1Rnc01Dd3VNRGc1T1RjdU1EQTVPVFV1TVRjNU9Ua3VNREU1T1RZdU1qWXdNREZhVFRFeUxqZzNMREl3TGpnMU1EQTBZeTR3TkRrNU9TMHVNRFF3TURRdU1Ea3dNRE10TGpBNU1EQXpMakV6TFM0eE5EQXdNV3d5TGpNNExERXVNVGM1T1RrdExqazJNREF5TERFdU5URXdNREV0TVM0MU5EazVPUzB5TGpVME9UazVXazB4TWk0NU1EazVOeXd5Tnk0Mk5EQXdNV3d1TURZdExqQTRPVGszTERFdU5ESXdNRFF0TWk0eU5EQXdOUzQzTXprNU9Td3hMakl5TURBekxUSXVNVE1zTVM0d05pMHVNRGt3TURNdU1EUTVPVGxhVFRFekxqTTVNREF4TERJNUxqVXpNREF6WXk0d056QXdNUzB1TWpBd01ERXVNVEE1T1RrdExqUXhNREF6TGpFd09UazVMUzQyTXl3d0xTNHhOREF3TVMwdU1ESXdNREl0TGpJNE9UazRMUzR3TXprNU9DMHVOREU1T1Roc01pNHhOems1T1MweExqQTVNREF6TERNdU5UYzVPVFlzTlM0NU1UazVPQzAxTGpneU9UazJMVE11TnpjNU9UZGFUVEl3TGpRd01EQXlMRE15TGprM01EQXpZeTB1TURZdU1ERXdNREV0TGpFeUxqQXlPVGszTFM0eE9EQXdOUzR3TkRrNU9Xd3RNeTQyTmprNU9DMDJMakE0T1RrM0xESXVPVEV3TURNdE1TNDBOVEF3TVdNdU1qVXVNalk1T1RZdU5UY3dNREV1TkRVNU9UWXVPVFF1TlRRNU9UbDJOaTQ1TkZwTk1qQXVOREF3TURJc01qSXVNVGN3TURSakxTNDBNREF3TWk0d09UazVPQzB1TnpVdU16SXdNREV0TVN3dU5qSnNMVEl1TlRrd01ETXRNUzR5T1RBd05Dd3pMalV6T1RrNExUVXVOVGM1T1RaakxqQXhNREF4TGpBeE1EQXhMakF6TURBekxqQXhNREF4TGpBMU1EQTFMakF4TURBeGRqWXVNak01T1RsYVRUSTNMak01TURBeExESXpMakk1TURBMGJDMHVPRFV3TURRdE1TNHpNekF3TWl3eUxqTTVNREF4TFRFdU1qRTVPVGN0TVM0MU16azVPQ3d5TGpVME9UazVXazB5TWk0NE9Dd3lNeTQ0TWpBd01Xd3lMamMyTURBeExURXVOREE1T1Rjc01TNHhOems1T1N3eExqZ3pNREF5ZGk0d01EazVOV3d0TVM0d056QXdNU3d4TGpjM01EQXlMVEl1T1RBNU9UY3RNUzQwTmpBd01tTXVNRE01T1RndExqRTBPVGsyTGpBMkxTNHlPVGs1T1M0d05pMHVORFU1T1RZc01DMHVNVEF3TURRdExqQXhNREF4TFM0eE9TMHVNREl3TURJdExqSTRNREF6V2sweU1pNHpORGs1T0N3eE5TNHpOMncyTGpFeUxETXVOVE13TUROakxTNHdORGs1T1M0eE5UazVOeTB1TURZNU9UVXVNek13TURJdExqQTJPVGsxTGpVc01Dd3VNVFU1T1RjdU1ERTVPVFl1TXpFdU1EWXVORFl3TURKc0xUSXVORFl3TURJc01TNHlOV2d0TGpBeE1EQXhiQzB6TGpZMU9UazNMVFV1TnpJd01ETnhMakF4TURBeExTNHdNVEF3TVM0d01UazVOaTB1TURJd01ESmFUVEl4TGpRd01EQXlMREUxTGprek1EQTFZeTR3TWprNU55d3dMQzR3TmkwdU1ERXdNREV1TURjNU9UWXRMakF5TURBeWJETXVOaklzTlM0Mk5UazVOeTB5TGpZd09UazVMREV1TXpNd01ESmpMUzR5TmpBd01TMHVNelU1T1RrdExqWTBNREF4TFM0Mk1pMHhMakE0T1RrM0xTNDNNams1T0hZdE5pNHlNems1T1ZwTk1qRXVOVE13TURNc016TmpMUzR3TkRBd05DMHVNREE1T1RVdExqQTRNREF5TFM0d01qazVOeTB1TVRNdExqQXlPVGszZGkwMkxqazBZeTR6T0MwdU1Ea3dNRE11TnpFNU9UY3RMakk1T1RrNUxqazJPVGszTFM0MU9UQXdNMnd5TGpnMU9UazVMREV1TkRJNU9Ua3RNeTQyT1RrNU5TdzJMakV6V2sweU1pNDFOekF3TVN3ek15NHlNakF3TTJ3ekxqVTJMVFV1T1RBd01ESXNNaTR6TVN3eExqRTJNREF6WXkwdU1ESXdNREl1TVRNdExqQXpPVGs0TGpJM09UazNMUzR3TXprNU9DNDBNVGs1T0N3d0xDNHhOVEF3TWk0d01UazVOaTR5T1RrNU9TNHdORGs1T1M0ME5Hd3ROUzQ0T0N3ekxqZzRXazB5T0M0NE9UQXdNU3d5Tnk0MU9UQXdNMnd0TWk0eU16azVPUzB4TGpFeUxqYzJPVGsyTFRFdU1qZ3dNRE1zTVM0MU1UQXdNU3d5TGpNMk1EQTFZeTB1TURFd01ERXVNREE1T1RVdExqQXlNREF5TGpBeU9UazNMUzR3TXprNU9DNHdNems1T0ZvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdQQzl6ZG1jJTJCJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQmNvbnRhaW5lciUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI0NTcuNSUyMiUyMHklM0QlMjI1NjMuOTk5OTk5OTk5OTk5OCUyMiUyMHdpZHRoJTNEJTIyNDIlMjIlMjBoZWlnaHQlM0QlMjI1NiUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJoRml0ODhiMldFNVJnMklFR3BtRi0xNiUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JOVklESUElMjBOSU0lMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCY29udGFpbmVyJTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjQyMi41JTIyJTIweSUzRCUyMjYxNyUyMiUyMHdpZHRoJTNEJTIyMTE0JTIyJTIwaGVpZ2h0JTNEJTIyNTMuNDglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMjIlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCUXVlc3Rpb25zJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjU1MC41JTIyJTIweSUzRCUyMjYxNyUyMiUyMHdpZHRoJTNEJTIyMTEzJTIyJTIwaGVpZ2h0JTNEJTIyMzglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMjUlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZGl2JTI2Z3QlM0IlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQlJldHJpZXZhbCUyMEFnZW50JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3MTIuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjM4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTI2JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnYVdROUltOTFkR3hwYm1VaVBpWWplR0U3SUNBOFpHVm1jejRtSTNoaE95QWdJQ0E4YzNSNWJHVSUyQkppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c09pQWpabVppWXpBd095WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFc0lDNWpiSE10TWlCN0ppTjRZVHNnSUNBZ0lDQWdJSE4wY205clpTMTNhV1IwYURvZ01IQjRPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxUSWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0lDQWdJRHd2YzNSNWJHVSUyQkppTjRZVHNnSUR3dlpHVm1jejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJME1pSWdkMmxrZEdnOUlqUXlJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BHYyUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRURXlMakE0TXpVc01UUXVNVE0xTTJ3ekxqUXhOalV0TXk0ME1UWTBOSFl4TGpjNU1qazNhREYyTFRNdU5XZ3RNeTQxZGpGb01TNDNPVEk1TjJ3dE15NDBNVFkxTERNdU5ERTJORFJqTFM0ek9UVXdNaTB1TWpZeE9UWXRMamcyTnpZNExTNDBNVFkwTkMweExqTTNOalEyTFM0ME1UWTBOQzB4TGpNM09Ea3hMREF0TWk0MUxERXVNVEl4TlRndE1pNDFMREl1TlhNeExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxESXVOUzB4TGpFeU1UVTRMREl1TlMweUxqVmpNQzB1TlRBNE5qY3RMakUxTkRVMExTNDVPREV5TmkwdU5ERTJOUzB4TGpNM05qVXpXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRUSTNMak01TXpVMUxERTNMalF4TVROc0xUTXVPRGt6TlRVc015NDRPVE0wT1hZdE1TNDNPVEk1TjJndE1YWXpMalZvTXk0MWRpMHhhQzB4TGpjNU1qazNiRFF1TVRBM05ESXROQzR4TURjMU5HTXVNakU1TWpRdU1EWXpNRFV1TkRRMk1qa3VNVEEzTlRRdU5qZzFOVFV1TVRBM05UUXNNUzR6TnpnNU1Td3dMREl1TlMweExqRXlNVFU0TERJdU5TMHlMalZ6TFRFdU1USXhNRGt0TWk0MUxUSXVOUzB5TGpVdE1pNDFMREV1TVRJeE5UZ3RNaTQxTERJdU5XTXdMQzQzTmpNNU9DNHpOVEUxTml3eExqUTBNRFE1TGpnNU16VTFMREV1T0RrNU5EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5NakFzT1M0d01URTRNMk11TlRBNE56a3NNQ3d1T1RneE5EVXRMakUxTkRRNExERXVNemMyTkRZdExqUXhOalEwYkRNdU5ERTJOU3d6TGpReE5qUTBhQzB4TGpjNU1qazNkakZvTXk0MWRpMHpMalZvTFRGMk1TNDNPVEk1TjJ3dE15NDBNVFkxTFRNdU5ERTJORFJqTGpJMk1UazJMUzR6T1RVeU5pNDBNVFkxTFM0NE5qYzROaTQwTVRZMUxURXVNemMyTlRNc01DMHhMak0zT0RReUxURXVNVEl4TURrdE1pNDFMVEl1TlMweUxqVnpMVEl1TlN3eExqRXlNVFU0TFRJdU5Td3lMalVzTVM0eE1qRXdPU3d5TGpVc01pNDFMREl1TlZvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0FnSUR4amFYSmpiR1VnY2owaU1pNDFJaUJqZVQwaU16VXVOVEV4T0RNaUlHTjRQU0l5T1NJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEl6TERNekxqQXhNVGd6YURNdU5YWXRNeTQxYUMweGRqRXVOemt5T1Rkc0xUUXVOREUyTlMwMExqUXhOalEwWXk0eU5qRTVOaTB1TXprMU1qWXVOREUyTlMwdU9EWTNPRFl1TkRFMk5TMHhMak0zTmpVekxEQXRNUzR6TnpnME1pMHhMakV5TVRBNUxUSXVOUzB5TGpVdE1pNDFMUzQxTURnM09Td3dMUzQ1T0RFME5TNHhOVFEwT0MweExqTTNOalEyTGpReE5qUTBiQzB6TGpReE5qVXRNeTQwTVRZME5HZ3hMamM1TWprM2RpMHhhQzB6TGpWMk15NDFhREYyTFRFdU56a3lPVGRzTXk0ME1UWTFMRE11TkRFMk5EUmpMUzR5TmpFNU5pNHpPVFV5TmkwdU5ERTJOUzQ0TmpjNE5pMHVOREUyTlN3eExqTTNOalV6TERBc01TNHpOemcwTWl3eExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxqVXdPRGM1TERBc0xqazRNVFExTFM0eE5UUTBPQ3d4TGpNM05qUTJMUzQwTVRZME5HdzBMalF4TmpVc05DNDBNVFkwTkdndE1TNDNPVEk1TjNZeFdpSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHd2Wno0bUkzaGhPend2YzNablBnJTNEJTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjc0OCUyMiUyMHklM0QlMjI1NzMlMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNDIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyaEZpdDg4YjJXRTVSZzJJRUdwbUYtMTIlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCT3V0bGluZSUyMEdlbmVyYXRpb24lMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyNmx0JTNCZGl2JTI2Z3QlM0IlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQkFnZW50JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjIyMjMuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjM4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMmhGaXQ4OGIyV0U1UmcySUVHcG1GLTEzJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnYVdROUltOTFkR3hwYm1VaVBpWWplR0U3SUNBOFpHVm1jejRtSTNoaE95QWdJQ0E4YzNSNWJHVSUyQkppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c09pQWpabVppWXpBd095WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFc0lDNWpiSE10TWlCN0ppTjRZVHNnSUNBZ0lDQWdJSE4wY205clpTMTNhV1IwYURvZ01IQjRPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxUSWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0lDQWdJRHd2YzNSNWJHVSUyQkppTjRZVHNnSUR3dlpHVm1jejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJME1pSWdkMmxrZEdnOUlqUXlJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BHYyUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRURXlMakE0TXpVc01UUXVNVE0xTTJ3ekxqUXhOalV0TXk0ME1UWTBOSFl4TGpjNU1qazNhREYyTFRNdU5XZ3RNeTQxZGpGb01TNDNPVEk1TjJ3dE15NDBNVFkxTERNdU5ERTJORFJqTFM0ek9UVXdNaTB1TWpZeE9UWXRMamcyTnpZNExTNDBNVFkwTkMweExqTTNOalEyTFM0ME1UWTBOQzB4TGpNM09Ea3hMREF0TWk0MUxERXVNVEl4TlRndE1pNDFMREl1TlhNeExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxESXVOUzB4TGpFeU1UVTRMREl1TlMweUxqVmpNQzB1TlRBNE5qY3RMakUxTkRVMExTNDVPREV5TmkwdU5ERTJOUzB4TGpNM05qVXpXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRUSTNMak01TXpVMUxERTNMalF4TVROc0xUTXVPRGt6TlRVc015NDRPVE0wT1hZdE1TNDNPVEk1TjJndE1YWXpMalZvTXk0MWRpMHhhQzB4TGpjNU1qazNiRFF1TVRBM05ESXROQzR4TURjMU5HTXVNakU1TWpRdU1EWXpNRFV1TkRRMk1qa3VNVEEzTlRRdU5qZzFOVFV1TVRBM05UUXNNUzR6TnpnNU1Td3dMREl1TlMweExqRXlNVFU0TERJdU5TMHlMalZ6TFRFdU1USXhNRGt0TWk0MUxUSXVOUzB5TGpVdE1pNDFMREV1TVRJeE5UZ3RNaTQxTERJdU5XTXdMQzQzTmpNNU9DNHpOVEUxTml3eExqUTBNRFE1TGpnNU16VTFMREV1T0RrNU5EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5NakFzT1M0d01URTRNMk11TlRBNE56a3NNQ3d1T1RneE5EVXRMakUxTkRRNExERXVNemMyTkRZdExqUXhOalEwYkRNdU5ERTJOU3d6TGpReE5qUTBhQzB4TGpjNU1qazNkakZvTXk0MWRpMHpMalZvTFRGMk1TNDNPVEk1TjJ3dE15NDBNVFkxTFRNdU5ERTJORFJqTGpJMk1UazJMUzR6T1RVeU5pNDBNVFkxTFM0NE5qYzROaTQwTVRZMUxURXVNemMyTlRNc01DMHhMak0zT0RReUxURXVNVEl4TURrdE1pNDFMVEl1TlMweUxqVnpMVEl1TlN3eExqRXlNVFU0TFRJdU5Td3lMalVzTVM0eE1qRXdPU3d5TGpVc01pNDFMREl1TlZvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0FnSUR4amFYSmpiR1VnY2owaU1pNDFJaUJqZVQwaU16VXVOVEV4T0RNaUlHTjRQU0l5T1NJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEl6TERNekxqQXhNVGd6YURNdU5YWXRNeTQxYUMweGRqRXVOemt5T1Rkc0xUUXVOREUyTlMwMExqUXhOalEwWXk0eU5qRTVOaTB1TXprMU1qWXVOREUyTlMwdU9EWTNPRFl1TkRFMk5TMHhMak0zTmpVekxEQXRNUzR6TnpnME1pMHhMakV5TVRBNUxUSXVOUzB5TGpVdE1pNDFMUzQxTURnM09Td3dMUzQ1T0RFME5TNHhOVFEwT0MweExqTTNOalEyTGpReE5qUTBiQzB6TGpReE5qVXRNeTQwTVRZME5HZ3hMamM1TWprM2RpMHhhQzB6TGpWMk15NDFhREYyTFRFdU56a3lPVGRzTXk0ME1UWTFMRE11TkRFMk5EUmpMUzR5TmpFNU5pNHpPVFV5TmkwdU5ERTJOUzQ0TmpjNE5pMHVOREUyTlN3eExqTTNOalV6TERBc01TNHpOemcwTWl3eExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxqVXdPRGM1TERBc0xqazRNVFExTFM0eE5UUTBPQ3d4TGpNM05qUTJMUzQwTVRZME5HdzBMalF4TmpVc05DNDBNVFkwTkdndE1TNDNPVEk1TjNZeFdpSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHd2Wno0bUkzaGhPend2YzNablBnJTNEJTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjI1OSUyMiUyMHklM0QlMjI1NzMlMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNDIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyM3gxWVhfeGo3YmJSZFZJd0hKTHctMiUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmltYWdlQXNwZWN0JTNEMCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBPQ0EwT0NJJTJCSmlONFlUc2dJRHhrWldaelBpWWplR0U3SUNBZ0lEeHpkSGxzWlQ0bUkzaGhPeUFnSUNBZ0lDNWpiSE10TVNCN0ppTjRZVHNnSUNBZ0lDQWdJR1pwYkd3NklDTXlNamt3WXpjN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzbUkzaGhPeUFnSUNBZ0lDNWpiSE10TVN3Z0xtTnNjeTB5SUhzbUkzaGhPeUFnSUNBZ0lDQWdjM1J5YjJ0bExYZHBaSFJvT2lBd2NIZzdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1pQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05tWm1ZN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzZ0lDQWdQQzl6ZEhsc1pUNG1JM2hoT3lBZ1BDOWtaV1p6UGlZamVHRTdJQ0E4WnlCcFpEMGlRMmx5WTJ4bElqNG1JM2hoT3lBZ0lDQThZMmx5WTJ4bElISTlJakkwSWlCamVUMGlNalFpSUdONFBTSXlOQ0lnWTJ4aGMzTTlJbU5zY3kweElpOCUyQkppTjRZVHNnSUR3dlp6NG1JM2hoT3lBZ1BHY2dhV1E5SWtSeVlYZHBibWNpUGlZamVHRTdJQ0FnSUR4d2IyeDVaMjl1SUhCdmFXNTBjejBpTXpFZ01qVWdNVGNnTWpVZ01UTWdOREFnTXpVZ05EQWdNekVnTWpVaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0FnSUR4amFYSmpiR1VnY2owaU55SWdZM2s5SWpFMUlpQmplRDBpTWpRaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4TDJjJTJCSmlONFlUczhMM04yWno0JTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMjElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjk1LjUlMjIlMjB5JTNEJTIyNTcwJTIyJTIwd2lkdGglM0QlMjI0OCUyMiUyMGhlaWdodCUzRCUyMjQ4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMjN4MVlYX3hqN2JiUmRWSXdISkx3LTMlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCVXNlciUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjIxJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3OSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjgxJTIyJTIwaGVpZ2h0JTNEJTIyMzglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRnJvb3QlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUzQyUyRm14R3JhcGhNb2RlbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTNDJTJGZGlhZ3JhbSUzRSUyNiUyM3hhJTNCJTIwJTIwJTNDZGlhZ3JhbSUyMG5hbWUlM0QlMjJDb3B5JTIwb2YlMjBQYWdlLTElMjIlMjBpZCUzRCUyMkZBdHNtQU9aVDg2RUNPY1VoY2hTJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlM0NteEdyYXBoTW9kZWwlMjBkeCUzRCUyMjk4MSUyMiUyMGR5JTNEJTIyNjA5JTIyJTIwZ3JpZCUzRCUyMjElMjIlMjBncmlkU2l6ZSUzRCUyMjYlMjIlMjBndWlkZXMlM0QlMjIxJTIyJTIwdG9vbHRpcHMlM0QlMjIxJTIyJTIwY29ubmVjdCUzRCUyMjElMjIlMjBhcnJvd3MlM0QlMjIxJTIyJTIwZm9sZCUzRCUyMjElMjIlMjBwYWdlJTNEJTIyMSUyMiUyMHBhZ2VTY2FsZSUzRCUyMjElMjIlMjBwYWdlV2lkdGglM0QlMjIxNjAwJTIyJTIwcGFnZUhlaWdodCUzRCUyMjkwMCUyMiUyMG1hdGglM0QlMjIwJTIyJTIwc2hhZG93JTNEJTIyMCUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTNDcm9vdCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0wJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0wJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMkh6a2pra2wwcEVuUzdhVDRMeDJkLTUlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIycm91bmRlZCUzRDAlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmh0bWwlM0QxJTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCZmlsbENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB5JTNEJTIyMTA4JTIyJTIwd2lkdGglM0QlMjIxNDk0JTIyJTIwaGVpZ2h0JTNEJTIyNjg0JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTIlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIycm91bmRlZCUzRDAlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmh0bWwlM0QxJTNCZm9udFNpemUlM0QxMiUzQmZpbGxDb2xvciUzRG5vbmUlM0JzdHJva2VDb2xvciUzRCUyM0ZGRkZGRiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwQm9sZCUzQmFsbG93QXJyb3dzJTNEMCUzQmNvbm5lY3RhYmxlJTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjQwNi41JTIyJTIweSUzRCUyMjUwNCUyMiUyMHdpZHRoJTNEJTIyMjY1LjUlMjIlMjBoZWlnaHQlM0QlMjIxNTUlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMyUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJyb3VuZGVkJTNEMCUzQndoaXRlU3BhY2UlM0R3cmFwJTNCaHRtbCUzRDElM0Jmb250U2l6ZSUzRDEyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBCb2xkJTNCYWxsb3dBcnJvd3MlM0QwJTNCY29ubmVjdGFibGUlM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyOTEyJTIyJTIweSUzRCUyMjUwNCUyMiUyMHdpZHRoJTNEJTIyMjc0LjUlMjIlMjBoZWlnaHQlM0QlMjIxNTUlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJncm91cCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUyMGNvbm5lY3RhYmxlJTNEJTIyMCUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjIxMjUwLjUlMjIlMjB5JTNEJTIyNTczJTIyJTIwd2lkdGglM0QlMjIxMTMlMjIlMjBoZWlnaHQlM0QlMjI4MiUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti01JTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBjb2xvciUzRCUyNnF1b3QlM0IlMjNmZmZmZmYlMjZxdW90JTNCJTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JDcml0aWMlMjBBZ2VudCUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti00JTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHklM0QlMjI0NCUyMiUyMHdpZHRoJTNEJTIyMTEzJTIyJTIwaGVpZ2h0JTNEJTIyMzglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNiUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUEwTWlJZ2FXUTlJbTkxZEd4cGJtVWlQaVlqZUdFN0lDQThaR1ZtY3o0bUkzaGhPeUFnSUNBOGMzUjViR1UlMkJKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxURWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1aaVl6QXdPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxURXNJQzVqYkhNdE1pQjdKaU40WVRzZ0lDQWdJQ0FnSUhOMGNtOXJaUzEzYVdSMGFEb2dNSEI0T3lZamVHRTdJQ0FnSUNBZ2ZTWWplR0U3SmlONFlUc2dJQ0FnSUNBdVkyeHpMVElnZXlZamVHRTdJQ0FnSUNBZ0lDQm1hV3hzT2lBalptWm1PeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdJQ0FnSUR3dmMzUjViR1UlMkJKaU40WVRzZ0lEd3ZaR1ZtY3o0bUkzaGhPeUFnUEhKbFkzUWdhR1ZwWjJoMFBTSTBNaUlnZDJsa2RHZzlJalF5SWlCamJHRnpjejBpWTJ4ekxURWlMejRtSTNoaE95QWdQR2MlMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEV5TGpBNE16VXNNVFF1TVRNMU0yd3pMalF4TmpVdE15NDBNVFkwTkhZeExqYzVNamszYURGMkxUTXVOV2d0TXk0MWRqRm9NUzQzT1RJNU4yd3RNeTQwTVRZMUxETXVOREUyTkRSakxTNHpPVFV3TWkwdU1qWXhPVFl0TGpnMk56WTRMUzQwTVRZME5DMHhMak0zTmpRMkxTNDBNVFkwTkMweExqTTNPRGt4TERBdE1pNDFMREV1TVRJeE5UZ3RNaTQxTERJdU5YTXhMakV5TVRBNUxESXVOU3d5TGpVc01pNDFMREl1TlMweExqRXlNVFU0TERJdU5TMHlMalZqTUMwdU5UQTROamN0TGpFMU5EVTBMUzQ1T0RFeU5pMHVOREUyTlMweExqTTNOalV6V2lJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEkzTGpNNU16VTFMREUzTGpReE1UTnNMVE11T0Rrek5UVXNNeTQ0T1RNME9YWXRNUzQzT1RJNU4yZ3RNWFl6TGpWb015NDFkaTB4YUMweExqYzVNamszYkRRdU1UQTNOREl0TkM0eE1EYzFOR011TWpFNU1qUXVNRFl6TURVdU5EUTJNamt1TVRBM05UUXVOamcxTlRVdU1UQTNOVFFzTVM0ek56ZzVNU3d3TERJdU5TMHhMakV5TVRVNExESXVOUzB5TGpWekxURXVNVEl4TURrdE1pNDFMVEl1TlMweUxqVXRNaTQxTERFdU1USXhOVGd0TWk0MUxESXVOV013TEM0M05qTTVPQzR6TlRFMU5pd3hMalEwTURRNUxqZzVNelUxTERFdU9EazVORGhhSWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdJQ0E4Y0dGMGFDQmtQU0pOTWpBc09TNHdNVEU0TTJNdU5UQTROemtzTUN3dU9UZ3hORFV0TGpFMU5EUTRMREV1TXpjMk5EWXRMalF4TmpRMGJETXVOREUyTlN3ekxqUXhOalEwYUMweExqYzVNamszZGpGb015NDFkaTB6TGpWb0xURjJNUzQzT1RJNU4yd3RNeTQwTVRZMUxUTXVOREUyTkRSakxqSTJNVGsyTFM0ek9UVXlOaTQwTVRZMUxTNDROamM0Tmk0ME1UWTFMVEV1TXpjMk5UTXNNQzB4TGpNM09EUXlMVEV1TVRJeE1Ea3RNaTQxTFRJdU5TMHlMalZ6TFRJdU5Td3hMakV5TVRVNExUSXVOU3d5TGpVc01TNHhNakV3T1N3eUxqVXNNaTQxTERJdU5Wb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBZ0lEeGphWEpqYkdVZ2NqMGlNaTQxSWlCamVUMGlNelV1TlRFeE9ETWlJR040UFNJeU9TSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJQ0FnUEhCaGRHZ2daRDBpVFRJekxETXpMakF4TVRnemFETXVOWFl0TXk0MWFDMHhkakV1TnpreU9UZHNMVFF1TkRFMk5TMDBMalF4TmpRMFl5NHlOakU1TmkwdU16azFNall1TkRFMk5TMHVPRFkzT0RZdU5ERTJOUzB4TGpNM05qVXpMREF0TVM0ek56ZzBNaTB4TGpFeU1UQTVMVEl1TlMweUxqVXRNaTQxTFM0MU1EZzNPU3d3TFM0NU9ERTBOUzR4TlRRME9DMHhMak0zTmpRMkxqUXhOalEwYkMwekxqUXhOalV0TXk0ME1UWTBOR2d4TGpjNU1qazNkaTB4YUMwekxqVjJNeTQxYURGMkxURXVOemt5T1Rkc015NDBNVFkxTERNdU5ERTJORFJqTFM0eU5qRTVOaTR6T1RVeU5pMHVOREUyTlM0NE5qYzROaTB1TkRFMk5Td3hMak0zTmpVekxEQXNNUzR6TnpnME1pd3hMakV5TVRBNUxESXVOU3d5TGpVc01pNDFMalV3T0RjNUxEQXNMams0TVRRMUxTNHhOVFEwT0N3eExqTTNOalEyTFM0ME1UWTBOR3cwTGpReE5qVXNOQzQwTVRZME5HZ3RNUzQzT1RJNU4zWXhXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR3dlp6NG1JM2hoT3p3dmMzWm5QZyUzRCUzRCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti00JTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjIzNS41JTIyJTIwd2lkdGglM0QlMjI0MiUyMiUyMGhlaWdodCUzRCUyMjQyJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTclMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG9ydGhvZ29uYWxFZGdlU3R5bGUlM0Jyb3VuZGVkJTNEMSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQmV4aXRYJTNEMSUzQmV4aXRZJTNEMC41JTNCZXhpdER4JTNEMCUzQmV4aXREeSUzRDAlM0JlbnRyeVglM0QwJTNCZW50cnlZJTNEMC41JTNCZW50cnlEeCUzRDAlM0JlbnRyeUR5JTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRTaXplJTNENCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBzb3VyY2UlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0zMSUyMiUyMHRhcmdldCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTMyJTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tOCUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEb3J0aG9nb25hbEVkZ2VTdHlsZSUzQnJvdW5kZWQlM0QxJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCZXhpdFglM0QxJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRTaXplJTNENCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBzb3VyY2UlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0zMiUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI1MjguNDQlMjIlMjB5JTNEJTIyMTc5JTIyJTIwYXMlM0QlMjJ0YXJnZXRQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTklMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG9ydGhvZ29uYWxFZGdlU3R5bGUlM0Jyb3VuZGVkJTNEMSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQmV4aXRYJTNEMSUzQmV4aXRZJTNEMC41JTNCZXhpdER4JTNEMCUzQmV4aXREeSUzRDAlM0JlbnRyeVglM0QwJTNCZW50cnlZJTNEMC41JTNCZW50cnlEeCUzRDAlM0JlbnRyeUR5JTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRTaXplJTNENCUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB0YXJnZXQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0zNSUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI1NzAuNDQlMjIlMjB5JTNEJTIyMTc4Ljk5OTk5OTk5OTk5OTc3JTIyJTIwYXMlM0QlMjJzb3VyY2VQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTEwJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVuZEFycm93JTNEbm9uZSUzQmRhc2hlZCUzRDElM0JodG1sJTNEMSUzQmRhc2hQYXR0ZXJuJTNEMSUyMDMlM0JzdHJva2VXaWR0aCUzRDIlM0Jyb3VuZGVkJTNEMSUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZFNpemUlM0Q0JTNCZmlsbENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjI1MCUyMiUyMGhlaWdodCUzRCUyMjUwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIyNCUyMiUyMHklM0QlMjI0MDglMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjE0NjQlMjIlMjB5JTNEJTIyNDA4JTIyJTIwYXMlM0QlMjJ0YXJnZXRQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTExJTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQlF1ZXN0aW9uJTIwR2VuZXJhdGlvbiUyMEFnZW50JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JodG1sJTNEMSUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmZpbGxDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGxlZnQlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jyb3VuZGVkJTNEMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTdHlsZSUzRDElM0Jmb250U2l6ZSUzRDEyJTNCYWxsb3dBcnJvd3MlM0QwJTNCY29ubmVjdGFibGUlM0QwJTNCZm9udENvbG9yJTNEJTIzRkZGRkZGJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyNDEyLjUwMDAwMDAwMDAwMDA2JTIyJTIweSUzRCUyMjUwOCUyMiUyMHdpZHRoJTNEJTIyMjAxJTIyJTIwaGVpZ2h0JTNEJTIyMjQuNjMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMTIlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QwJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmN1cnZlZCUzRDElM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdGFydEFycm93JTNEbm9uZSUzQnN0YXJ0RmlsbCUzRDAlM0JzdHJva2VDb2xvciUzRCUyM0ZGRkZGRiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZmlsbENvbG9yJTNEJTIzMDAwMDAwJTNCZXhpdFglM0QwLjk5MiUzQmV4aXRZJTNEMC41MzklM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQmV4aXRQZXJpbWV0ZXIlM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjQ5OS4xNjQlMjIlMjB5JTNEJTIyNTk0LjE4Mzk5OTk5OTk5OTclMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjU4Ni41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xMyUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDElM0JoYWNodXJlR2FwJTNENCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0RibG9jayUzQnN0YXJ0RmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyM0ZGRkZGRiUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI2MTAuNSUyMiUyMHklM0QlMjI1NzAlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjQ3OC41JTIyJTIweSUzRCUyMjU2NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNjEwLjUlMjIlMjB5JTNEJTIyNTQ2JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjU1MC41JTIyJTIweSUzRCUyMjU0NiUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI0NzguNSUyMiUyMHklM0QlMjI1NDYlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRkFycmF5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMTQlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QwJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmN1cnZlZCUzRDElM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyM0ZGRkZGRiUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZXhpdFglM0QxJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBzb3VyY2UlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti01MCUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjMwNC41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNDA3JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xNSUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JDb250ZW50JTIwR2VuZXJhdGlvbiUyMEFnZW50JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JodG1sJTNEMSUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmZpbGxDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGxlZnQlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jyb3VuZGVkJTNEMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTdHlsZSUzRDElM0Jmb250U2l6ZSUzRDEyJTNCYWxsb3dBcnJvd3MlM0QwJTNCY29ubmVjdGFibGUlM0QwJTNCZm9udENvbG9yJTNEJTIzRkZGRkZGJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyOTE2LjUlMjIlMjB5JTNEJTIyNTA4JTIyJTIwd2lkdGglM0QlMjIyMDElMjIlMjBoZWlnaHQlM0QlMjIyNC42MyUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xNiUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDAlM0Jmb250U2l6ZSUzRDEwJTNCc3RhcnRTaXplJTNENCUzQmVuZFNpemUlM0Q0JTNCY3VydmVkJTNEMSUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0Rub25lJTNCc3RhcnRGaWxsJTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB3aWR0aCUzRCUyMjE0MCUyMiUyMHJlbGF0aXZlJTNEJTIyMSUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTAwNi41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTA5MC41JTIyJTIweSUzRCUyMjU5NCUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xNyUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJlZGdlU3R5bGUlM0Rub25lJTNCb3J0aG9nb25hbExvb3AlM0QxJTNCamV0dHlTaXplJTNEYXV0byUzQmh0bWwlM0QxJTNCcm91bmRlZCUzRDElM0JoYWNodXJlR2FwJTNENCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmVuZEFycm93JTNEYmxvY2slM0JlbmRGaWxsJTNEMSUzQnN0YXJ0QXJyb3clM0RibG9jayUzQnN0YXJ0RmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyM0ZGRkZGRiUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI5ODIuNSUyMiUyMHklM0QlMjI1NjQlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjExMTQuNSUyMiUyMHklM0QlMjI1NzAlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjk4Mi41JTIyJTIweSUzRCUyMjU0NiUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIxMDU0LjUlMjIlMjB5JTNEJTIyNTQ2JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjExMTQuNSUyMiUyMHklM0QlMjI1NDYlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRkFycmF5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMTglMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QxJTNCaGFjaHVyZUdhcCUzRDQlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdGFydEFycm93JTNEYmxvY2slM0JzdGFydEZpbGwlM0QxJTNCc3Ryb2tlQ29sb3IlM0QlMjNGRkZGRkYlM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0JleGl0WCUzRDAlM0JleGl0WSUzRDAuNSUzQmV4aXREeCUzRDAlM0JleGl0RHklM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHNvdXJjZSUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTYlMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI0ODQuNSUyMiUyMHklM0QlMjI3MzYlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjExODclMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJ0YXJnZXRQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDQXJyYXklMjBhcyUzRCUyMnBvaW50cyUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTIxJTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjZndCUzQkRhdGElMjBJbmdlc3Rpb24lMjBQaGFzZSUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCaHRtbCUzRDElM0JzdHJva2VDb2xvciUzRG5vbmUlM0JmaWxsQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RsZWZ0JTNCdmVydGljYWxBbGlnbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCcm91bmRlZCUzRDAlM0Jmb250RmFtaWx5JTNETlZJRElBU2Fucy1SZWd1bGFyJTNCZm9udFN0eWxlJTNEMSUzQmZvbnRTaXplJTNEMTIlM0JhbGxvd0Fycm93cyUzRDAlM0Jjb25uZWN0YWJsZSUzRDAlM0Jmb250Q29sb3IlM0QlMjNGRkZGRkYlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjIzMC4wMDAwMDAwMDAwMDAwNTclMjIlMjB5JTNEJTIyMzcyJTIyJTIwd2lkdGglM0QlMjIyMDElMjIlMjBoZWlnaHQlM0QlMjIyNC42MyUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0yMiUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTI2Z3QlM0JRdWVyeSUyMFBoYXNlJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JodG1sJTNEMSUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmZpbGxDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGxlZnQlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jyb3VuZGVkJTNEMCUzQmZvbnRGYW1pbHklM0ROVklESUFTYW5zLVJlZ3VsYXIlM0Jmb250U3R5bGUlM0QxJTNCZm9udFNpemUlM0QxMiUzQmFsbG93QXJyb3dzJTNEMCUzQmNvbm5lY3RhYmxlJTNEMCUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjMwLjAwMDAwMDAwMDAwMDA1NyUyMiUyMHklM0QlMjI0MjAlMjIlMjB3aWR0aCUzRCUyMjIwMSUyMiUyMGhlaWdodCUzRCUyMjI0LjYzJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTIzJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMmVkZ2VTdHlsZSUzRG5vbmUlM0JvcnRob2dvbmFsTG9vcCUzRDElM0JqZXR0eVNpemUlM0RhdXRvJTNCaHRtbCUzRDElM0Jyb3VuZGVkJTNEMCUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JjdXJ2ZWQlM0QxJTNCZW5kQXJyb3clM0RibG9jayUzQmVuZEZpbGwlM0QxJTNCc3RhcnRBcnJvdyUzRG5vbmUlM0JzdGFydEZpbGwlM0QwJTNCc3Ryb2tlQ29sb3IlM0QlMjNGRkZGRkYlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI2NzIlMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJzb3VyY2VQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI3NDguNSUyMiUyMHklM0QlMjI1OTQlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMjQlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QxJTNCaGFjaHVyZUdhcCUzRDQlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdGFydEFycm93JTNEYmxvY2slM0JzdGFydEZpbGwlM0QxJTNCc3Ryb2tlQ29sb3IlM0QlMjNGRkZGRkYlM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwZWRnZSUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB3aWR0aCUzRCUyMjE0MCUyMiUyMHJlbGF0aXZlJTNEJTIyMSUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyOTEwLjUlMjIlMjB5JTNEJTIyNTk0JTIyJTIwYXMlM0QlMjJzb3VyY2VQb2ludCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjI3OTAuNSUyMiUyMHklM0QlMjI1OTQlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMjUlMjIlMjB2YWx1ZSUzRCUyMlF1ZXN0aW9ucyUyNmx0JTNCZGl2JTI2Z3QlM0JhbmQlMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0JkaXYlMjZndCUzQkNvbnRlbnQlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTI2bHQlM0IlMkZkaXYlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIyZWRnZUxhYmVsJTNCaHRtbCUzRDElM0JhbGlnbiUzRGNlbnRlciUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0JyZXNpemFibGUlM0QwJTNCcG9pbnRzJTNEJTVCJTVEJTNCZm9udFNpemUlM0QxMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udENvbG9yJTNEJTIzRkZGRkZGJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0QlMjMwMDAwMDAlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUyMGNvbm5lY3RhYmxlJTNEJTIyMCUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI4NTAuOTk2NjY2NjY2NjY2NiUyMiUyMHklM0QlMjI1OTMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMjYlMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QxJTNCaGFjaHVyZUdhcCUzRDQlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRTaXplJTNEMTAlM0JzdGFydFNpemUlM0Q0JTNCZW5kU2l6ZSUzRDQlM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdGFydEFycm93JTNEYmxvY2slM0JzdGFydEZpbGwlM0QxJTNCc3Ryb2tlQ29sb3IlM0QlMjNGRkZGRkYlM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0JlbnRyeVglM0QxJTNCZW50cnlZJTNEMC41JTNCZW50cnlEeCUzRDAlM0JlbnRyeUR5JTNEMCUzQmV4aXRYJTNEMC41JTNCZXhpdFklM0QwJTNCZXhpdER4JTNEMCUzQmV4aXREeSUzRDAlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwc291cmNlJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNDglMjIlMjB0YXJnZXQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0zOCUyMiUyMGVkZ2UlM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwd2lkdGglM0QlMjIxNDAlMjIlMjByZWxhdGl2ZSUzRCUyMjElMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjc2OCUyMiUyMHklM0QlMjI1NjQlMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjc5OCUyMiUyMHklM0QlMjIyODglMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMjclMjIlMjB2YWx1ZSUzRCUyMlF1ZXN0aW9ucyUyNmx0JTNCZGl2JTI2Z3QlM0JhbmQlMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0JkaXYlMjZndCUzQkNvbnRlbnQlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTI2bHQlM0IlMkZkaXYlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIyZWRnZUxhYmVsJTNCaHRtbCUzRDElM0JhbGlnbiUzRGNlbnRlciUzQnZlcnRpY2FsQWxpZ24lM0RtaWRkbGUlM0JyZXNpemFibGUlM0QwJTNCcG9pbnRzJTNEJTVCJTVEJTNCZm9udFNpemUlM0QxMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZm9udENvbG9yJTNEJTIzRkZGRkZGJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0QlMjMwMDAwMDAlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUyMGNvbm5lY3RhYmxlJTNEJTIyMCUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3NzAuNDk2NjY2NjY2NjY2NiUyMiUyMHklM0QlMjIzNzIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweSUzRCUyMi0yNSUyMiUyMGFzJTNEJTIyb2Zmc2V0JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMjglMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEbm9uZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QwJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQmN1cnZlZCUzRDElM0JlbmRBcnJvdyUzRGJsb2NrJTNCZW5kRmlsbCUzRDElM0JzdHJva2VDb2xvciUzRCUyM0ZGRkZGRiUzQmZpbGxDb2xvciUzRCUyMzAwMDAwMCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwTWVkaXVtJTNCZXhpdFglM0QxJTNCZXhpdFklM0QwLjUlM0JleGl0RHglM0QwJTNCZXhpdER5JTNEMCUzQmVudHJ5WCUzRDAlM0JlbnRyeVklM0QwLjUlM0JlbnRyeUR4JTNEMCUzQmVudHJ5RHklM0QwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHNvdXJjZSUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTUxJTIyJTIwdGFyZ2V0JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNTAlMjIlMjBlZGdlJTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHdpZHRoJTNEJTIyMTQwJTIyJTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjIxNDguNSUyMiUyMHklM0QlMjI2MDElMjIlMjBhcyUzRCUyMnNvdXJjZVBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjI1Ni41JTIyJTIweSUzRCUyMjYwMSUyMiUyMGFzJTNEJTIydGFyZ2V0UG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ0FycmF5JTIwYXMlM0QlMjJwb2ludHMlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0yOSUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwc3R5bGUlM0QlMjZxdW90JTNCZm9udC1zaXplJTNBJTIwMTBweCUzQiUyNnF1b3QlM0IlMjBkYXRhLWZvbnQtc3JjJTNEJTI2cXVvdCUzQmh0dHBzJTNBJTJGJTJGaW1hZ2VzLm52aWRpYS5jb20lMkZldGMlMkZkZXNpZ25zJTJGbnZpZGlhR0RDJTJGY2xpZW50bGlic19iYXNlJTJGZm9udHMlMkZudmlkaWEtc2FucyUyRiUyNnF1b3QlM0IlMjZndCUzQlJlc2VhcmNoJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQmRpdiUyNmd0JTNCJTI2bHQlM0Jmb250JTIwc3R5bGUlM0QlMjZxdW90JTNCZm9udC1zaXplJTNBJTIwMTBweCUzQiUyNnF1b3QlM0IlMjBkYXRhLWZvbnQtc3JjJTNEJTI2cXVvdCUzQmh0dHBzJTNBJTJGJTJGaW1hZ2VzLm52aWRpYS5jb20lMkZldGMlMkZkZXNpZ25zJTJGbnZpZGlhR0RDJTJGY2xpZW50bGlic19iYXNlJTJGZm9udHMlMkZudmlkaWEtc2FucyUyRiUyNnF1b3QlM0IlMjZndCUzQlJlcXVlc3QlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyNmx0JTNCJTJGZGl2JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMmVkZ2VMYWJlbCUzQmh0bWwlM0QxJTNCYWxpZ24lM0RjZW50ZXIlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCcmVzaXphYmxlJTNEMCUzQnBvaW50cyUzRCU1QiU1RCUzQmZvbnRTaXplJTNEMTAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQmxhYmVsQmFja2dyb3VuZENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMjglMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTIwY29ubmVjdGFibGUlM0QlMjIwJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIwcmVsYXRpdmUlM0QlMjIxJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhQb2ludCUyMHglM0QlMjItMSUyMiUyMGFzJTNEJTIyb2Zmc2V0JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMzAlMjIlMjB2YWx1ZSUzRCUyMk91dGxpbmUlMjIlMjBzdHlsZSUzRCUyMmVkZ2VMYWJlbCUzQmh0bWwlM0QxJTNCYWxpZ24lM0RjZW50ZXIlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCcmVzaXphYmxlJTNEMCUzQnBvaW50cyUzRCU1QiU1RCUzQmZvbnRTaXplJTNEMTAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQmxhYmVsQmFja2dyb3VuZENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlMjBjb25uZWN0YWJsZSUzRCUyMjAlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMTkyJTIyJTIweSUzRCUyMjU3MCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTU4JTIyJTIweSUzRCUyMjIzJTIyJTIwYXMlM0QlMjJvZmZzZXQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14R2VvbWV0cnklM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0zMSUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUEwTWlJZ1pHRjBZUzF1WVcxbFBTSk1ZWGxsY2lBMUlpQnBaRDBpVEdGNVpYSmZOU0klMkJKaU40WVRzZ0lEeGtaV1p6UGlZamVHRTdJQ0FnSUR4emRIbHNaVDRtSTNoaE95QWdJQ0FnSUM1amJITXRNU0I3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNOa09UWTBNakU3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNU3dnTG1Oc2N5MHlMQ0F1WTJ4ekxUTWdleVlqZUdFN0lDQWdJQ0FnSUNCemRISnZhMlV0ZDJsa2RHZzZJREJ3ZURzbUkzaGhPeUFnSUNBZ0lIMG1JM2hoT3lZamVHRTdJQ0FnSUNBZ0xtTnNjeTB5TENBdVkyeHpMVE1nZXlZamVHRTdJQ0FnSUNBZ0lDQm1hV3hzT2lBalptWm1PeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxUTWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNMWEoxYkdVNklHVjJaVzV2WkdRN0ppTjRZVHNnSUNBZ0lDQjlKaU40WVRzZ0lDQWdQQzl6ZEhsc1pUNG1JM2hoT3lBZ1BDOWtaV1p6UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakk0TGpjd01EQXhJREl3TGpFNU9UY3hJREk0TGpjd01EQXhJREl6TGpVZ01qVXVOREE1T1RjZ01qTXVOU0F5T0M0M01EQXdNU0F5TUM0eE9UazNNU0lnWTJ4aGMzTTlJbU5zY3kweElpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWsweU9TNDNNREF3TVN3eE9TNDFkalZvTFRWMk1USm9NVEoyTFRFM2FDMDNXazB6TUM0M01EQXdNU3d6TXk0MWFDMDBkaTB4YURSMk1WcE5NelF1TnpBd01ERXNNekF1TldndE9IWXRNV2c0ZGpGYVRUTTBMamN3TURBeExESTNMalZvTFRoMkxURm9PSFl4V2lJZ1kyeGhjM005SW1Oc2N5MHhJaTglMkJKaU40WVRzZ0lEeHdZWFJvSUdROUlrMHdMREIyTkRKb05ESldNRWd3V2sweE1TNDNNREF3TVN3eU1TNDFhQzAzVmpRdU5XZ3hOM1kzYUMweGRpMDJTRFV1TnpBd01ERjJNVFZvTm5ZeFdrMHhNUzQyT1N3eE5DNDFkakZvTFRVdU5qbHNOaTR4TWkwMkxqSXdNRElzTVM0d05EazVPUzQ1T1RBeU15d3lMakF5TURBeUxUSXVNVFl3TVRZc015NHlOU3d6TGpNM01ERXlhQzAwTGpJek9UazViQzB1TURJd01ESXVNREl3TURKb0xUSXVOV3d1TURFd01ERXNNaTQ1TnprNU9GcE5Nakl1TnpBd01ERXNNamt1TldndE1UQldNVEl1TldneE4zWTBMamd6TURBNGFDMHhkaTB6TGpnek1EQTRhQzB4TlhZeE5XZzVkakZhVFRJMkxqVXhNREF4TERFNExqWTRPVGswYkMweUxqTXpNREF5TERJdU16TXdNRGd0TWk0ek55MHVOakk1T0RndE1TNHlNams1T0MwMExqVTVNRE16TGpRNE9UazVMUzR4TWprNE9HTXVOREU1T1RndExqRXdPVGcyTGpjNE9UazRMUzR4TmprNU1pd3hMakUwT1RrMkxTNHhOams1TWl3eUxqQXlNREF5TERBc015NDNOREF3TlN3eExqTTFNREVzTkM0eU9UQXdOQ3d6TGpFNE9UazBXazB5TWk0eU1EQXdNU3d5TTNZekxqQTJPVGd5WXkwdU5Ua3dNRE11TWpnd01qY3RNUzR5TlM0ME16QXhPQzB4TGpreU9UazVMalF6TURFNExUSXVOVEl3TURJc01DMDBMalUzTURBeExUSXVNRFV3TWprdE5DNDFOekF3TVMwMExqVTJPVGd5TERBdE1pNHdOakF3Tml3eExqTTRPVGsxTFRNdU9EY3dNVElzTXk0ek9EazVOUzAwTGpReE1ERTJiQzQwT1RBd05TMHVNVEk1T0Rnc01TNHdPVGs1T0N3MExqRXlPVGc0TERJdU16Y3VOakk1T0RndExqZzBPVGs0TGpnMU1ERmFUVE0zTGpjd01EQXhMRE0zTGpWb0xURTBkaTB4TXk0M01EQXliRFV1TWpnNU9UZ3ROUzR5T1RrNGFEZ3VOekV3TURKMk1UbGFJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BIQmhkR2dnWkQwaVRUSTRMams0T1RrNUxERTRMalZzTFRVdU1qZzVPVGdzTlM0eU9UazRkakV6TGpjd01ESm9NVFIyTFRFNWFDMDRMamN4TURBeVdrMHlPQzQzTURBd01Td3lNQzR4T1RrM01YWXpMak13TURJNWFDMHpMakk1TURBMGJETXVNamt3TURRdE15NHpNREF5T1ZwTk16WXVOekF3TURFc016WXVOV2d0TVRKMkxURXlhRFYyTFRWb04zWXhOMW9pSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN0lDQThjbVZqZENCb1pXbG5hSFE5SWpFaUlIZHBaSFJvUFNJNElpQjVQU0l5Tmk0MUlpQjRQU0l5Tmk0M01EQXdNU0lnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR4eVpXTjBJR2hsYVdkb2REMGlNU0lnZDJsa2RHZzlJamdpSUhrOUlqSTVMalVpSUhnOUlqSTJMamN3TURBeElpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEhKbFkzUWdhR1ZwWjJoMFBTSXhJaUIzYVdSMGFEMGlOQ0lnZVQwaU16SXVOU0lnZUQwaU1qWXVOekF3TURFaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakk1TGpjd01EQXhJREV5TGpVZ01qa3VOekF3TURFZ01UY3VNek13TURnZ01qZ3VOekF3TURFZ01UY3VNek13TURnZ01qZ3VOekF3TURFZ01UTXVOU0F4TXk0M01EQXdNU0F4TXk0MUlERXpMamN3TURBeElESTRMalVnTWpJdU56QXdNREVnTWpndU5TQXlNaTQzTURBd01TQXlPUzQxSURFeUxqY3dNREF4SURJNUxqVWdNVEl1TnpBd01ERWdNVEl1TlNBeU9TNDNNREF3TVNBeE1pNDFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BIQmhkR2dnWkQwaVRUSTJMalV4TURBeExERTRMalk0T1RrMGJDMHlMak16TURBeUxESXVNek13TURndE1pNHpOeTB1TmpJNU9EZ3RNUzR5TWprNU9DMDBMalU1TURNekxqUTRPVGs1TFM0eE1qazRPR011TkRFNU9UZ3RMakV3T1RnMkxqYzRPVGs0TFM0eE5qazVNaXd4TGpFME9UazJMUzR4TmprNU1pd3lMakF5TURBeUxEQXNNeTQzTkRBd05Td3hMak0xTURFc05DNHlPVEF3TkN3ekxqRTRPVGswV2lJZ1kyeGhjM005SW1Oc2N5MHpJaTglMkJKaU40WVRzZ0lEeHdZWFJvSUdROUlrMHlNeTR3TkRrNU9Td3lNaTR4TkRrNWJDMHVPRFE1T1RndU9EVXdNWFl6TGpBMk9UZ3lZeTB1TlRrd01ETXVNamd3TWpjdE1TNHlOUzQwTXpBeE9DMHhMamt5T1RrNUxqUXpNREU0TFRJdU5USXdNRElzTUMwMExqVTNNREF4TFRJdU1EVXdNamt0TkM0MU56QXdNUzAwTGpVMk9UZ3lMREF0TWk0d05qQXdOaXd4TGpNNE9UazFMVE11T0Rjd01USXNNeTR6T0RrNU5TMDBMalF4TURFMmJDNDBPVEF3TlMwdU1USTVPRGdzTVM0d09UazVPQ3cwTGpFeU9UZzRMREl1TXpjdU5qSTVPRGhhSWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQSEJ2YkhsbmIyNGdjRzlwYm5SelBTSXlNUzQzTURBd01TQTBMalVnTWpFdU56QXdNREVnTVRFdU5TQXlNQzQzTURBd01TQXhNUzQxSURJd0xqY3dNREF4SURVdU5TQTFMamN3TURBeElEVXVOU0ExTGpjd01EQXhJREl3TGpVZ01URXVOekF3TURFZ01qQXVOU0F4TVM0M01EQXdNU0F5TVM0MUlEUXVOekF3TURFZ01qRXVOU0EwTGpjd01EQXhJRFF1TlNBeU1TNDNNREF3TVNBMExqVWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOGNHOXNlV2R2YmlCd2IybHVkSE05SWpFNExqUTBJREV4TGpVZ01UUXVNakF3TURFZ01URXVOU0F4TkM0eE56azVPU0F4TVM0MU1qQXdNaUF4TVM0Mk56azVPU0F4TVM0MU1qQXdNaUF4TVM0Mk9TQXhOQzQxSURFeExqWTVJREUxTGpVZ05pQXhOUzQxSURFeUxqRXlJRGt1TWprNU9DQXhNeTR4TmprNU9DQXhNQzR5T1RBd05DQXhOUzR4T1NBNExqRXlPVGc0SURFNExqUTBJREV4TGpVaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdQQzl6ZG1jJTJCJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjk4LjUlMjIlMjB5JTNEJTIyMTU4JTIyJTIwd2lkdGglM0QlMjI0MiUyMiUyMGhlaWdodCUzRCUyMjQyJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTMyJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBPQ0lnYVdROUltbHViR2x1WlNJJTJCSmlONFlUc2dJRHhrWldaelBpWWplR0U3SUNBZ0lEeHpkSGxzWlQ0bUkzaGhPeUFnSUNBZ0lDNWpiSE10TVNCN0ppTjRZVHNnSUNBZ0lDQWdJR1pwYkd3NklDTm1abVk3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNaUI3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNNMk5qWTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc2dJQ0FnUEM5emRIbHNaVDRtSTNoaE95QWdQQzlrWldaelBpWWplR0U3SUNBOGNHOXNlV2R2YmlCd2IybHVkSE05SWpJeElEQWdORElnTVRJZ05ESWdNellnTWpFZ05EZ2dNQ0F6TmlBd0lERXlJREl4SURBaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Wno0bUkzaGhPeUFnSUNBOGNHRjBhQ0JrUFNKTk1qZ3VNVFV4Tml3eU15NDFOamcwTm1Nd0xTNHlNRGs1TmkwdU1ERXdNREV0TGpReE9UazRMUzR3TXpBd015MHVOakpzTWk0MUxUSXVOVGM1T1RZdE1pNHdORGs1T1MwekxqVTBNREEwTFRNdU5ERTVPVGd1T1RFd01ETmpMUzR6TlRrNU9TMHVNall3TURFdExqY3pPVGs1TFM0ME9EQXdOQzB4TGpFekxTNDJOakF3TTJ3dExqazNPVGs0TFRNdU5EVXdNREZvTFRRdU1Ea3dNRE5zTFM0NU1UazVPQ3d6TGpReU1EQTBZeTB1TXprd01ERXVNVGM1T1RrdExqYzNNREF5TGpNNU9UazJMVEV1TVRNdU5qUTVPVFpzTFRNdU5EYzVPVGd0TGpnM0xUSXVNRFV3TURVc015NDFOREF3TkN3eUxqVXhNREF4TERJdU5UQTVPVFZqTFM0d01qazVOeTR5TXpBd05DMHVNRE01T1RndU5EVXdNREV0TGpBek9UazRMalk1TERBc0xqSXhNREF5TGpBeE1EQXhMalF4TURBekxqQXlPVGszTGpZeE1EQTFiQzB5TGpVc01pNDFOems1Tml3eUxqQTFNREExTERNdU5UVXdNRFVzTXk0ME1UazVPQzB1T1RJd01EUmpMak0xT1RrNUxqSTJNREF4TGpjek9UazVMalE0TURBMExERXVNVE11TmpZd01ETnNMamszT1RrNExETXVORFV3TURGb05DNHdPVEF3TTJ3dU9URTVPVGd0TXk0ME1qQXdOR011TXprd01ERXRMakUzT1RrNUxqYzNNREF5TFM0ek9UazVOaXd4TGpFekxTNDJORGs1Tm13ekxqUTRPVGs1TGpnM0xESXVNRE01T1RndE15NDFOREF3TkMweUxqVXhNREF4TFRJdU5UQTVPVFZqTGpBek1EQXpMUzR5TWpBd015NHdOREF3TkMwdU5EVXdNREV1TURRd01EUXRMalk0TURBMVdrMHlNeTQ0TWpFMU9Td3lNeTQxTmpnME5tTXdMREV1TlRZdE1TNHlOakF3TVN3eUxqZ3pNREF5TFRJdU9ESXdNREVzTWk0NE16QXdNbk10TWk0NE1qazVOaTB4TGpJM01EQXlMVEl1T0RJNU9UWXRNaTQ0TXpBd01pd3hMakkyT1RrMkxUSXVPREk1T1RZc01pNDRNams1TmkweUxqZ3lPVGsyTERJdU9ESXdNREVzTVM0eU5qazVOaXd5TGpneU1EQXhMREl1T0RJNU9UWmFJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqRXlMalV3TVRVNElETXpMalE1T0RVeElERXlMalV3TVRVNElETTNMalE1T0RVeElEY3VOVEF4TlRnZ016Y3VORGs0TlRFZ055NDFNREUxT0NBek15NDBPVGcxTVNBNUxqQTFNVFUzSURNekxqUTVPRFV4SURrdU1EVXhOVGNnTWpNdU56ZzRORGtnTVRFdU1qTXhOaklnTWpNdU56ZzRORGtnTVRFdU1qTXhOaklnTWpRdU56ZzRORGtnTVRBdU1EVXhOVGNnTWpRdU56ZzRORGtnTVRBdU1EVXhOVGNnTXpNdU5EazROVEVnTVRJdU5UQXhOVGdnTXpNdU5EazROVEVpSUdOc1lYTnpQU0pqYkhNdE1TSXZQaVlqZUdFN0lDQWdJRHh3YjJ4NVoyOXVJSEJ2YVc1MGN6MGlNelF1TlRBeE5UZ2dNek11TkRrNE5URWdNelF1TlRBeE5UZ2dNemN1TkRrNE5URWdNamt1TlRBeE5UZ2dNemN1TkRrNE5URWdNamt1TlRBeE5UZ2dNek11TkRrNE5URWdNekV1T0RNeE5pQXpNeTQwT1RnMU1TQXpNUzQ0TXpFMklESTBMamM0T0RRNUlETXdMalkwTVRVNUlESTBMamM0T0RRNUlETXdMalkwTVRVNUlESXpMamM0T0RRNUlETXlMamd6TVRZZ01qTXVOemc0TkRrZ016SXVPRE14TmlBek15NDBPVGcxTVNBek5DNDFNREUxT0NBek15NDBPVGcxTVNJZ1kyeGhjM005SW1Oc2N5MHhJaTglMkJKaU40WVRzZ0lDQWdQSEJ2YkhsbmIyNGdjRzlwYm5SelBTSXhNQzR3TlRFMU55QXhOQzQwT1RnMU1TQXhNQzR3TlRFMU55QXlNaTR4TURnMUlERXhMakl6TVRZeUlESXlMakV3T0RVZ01URXVNak14TmpJZ01qTXVNVEE0TlNBNUxqQTFNVFUzSURJekxqRXdPRFVnT1M0d05URTFOeUF4TkM0ME9UZzFNU0EzTGpVd01UVTRJREUwTGpRNU9EVXhJRGN1TlRBeE5UZ2dNVEF1TkRrNE5URWdNVEl1TlRBeE5UZ2dNVEF1TkRrNE5URWdNVEl1TlRBeE5UZ2dNVFF1TkRrNE5URWdNVEF1TURVeE5UY2dNVFF1TkRrNE5URWlJR05zWVhOelBTSmpiSE10TVNJdlBpWWplR0U3SUNBZ0lEeHdiMng1WjI5dUlIQnZhVzUwY3owaU16UXVOVEF4TlRnZ01UQXVORGs0TlRFZ016UXVOVEF4TlRnZ01UUXVORGs0TlRFZ016SXVPRE14TmlBeE5DNDBPVGcxTVNBek1pNDRNekUySURJekxqRXdPRFVnTXpBdU5qUXhOVGtnTWpNdU1UQTROU0F6TUM0Mk5ERTFPU0F5TWk0eE1EZzFJRE14TGpnek1UWWdNakl1TVRBNE5TQXpNUzQ0TXpFMklERTBMalE1T0RVeElESTVMalV3TVRVNElERTBMalE1T0RVeElESTVMalV3TVRVNElERXdMalE1T0RVeElETTBMalV3TVRVNElERXdMalE1T0RVeElpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPeUFnUEM5blBpWWplR0U3UEM5emRtYyUyQiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjIzMTElMjIlMjB5JTNEJTIyMTU1JTIyJTIwd2lkdGglM0QlMjI0MiUyMiUyMGhlaWdodCUzRCUyMjQ4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTM0JTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQk5WSURJQSUyME5lTW8lMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQmRpdiUyNmd0JTNCJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JSZXRyaWV2ZXIlMjZhbXAlM0JuYnNwJTNCJTI2bHQlM0JzcGFuJTIwc3R5bGUlM0QlMjZxdW90JTNCYmFja2dyb3VuZC1jb2xvciUzQSUyMGluaXRpYWwlM0IlMjZxdW90JTNCJTI2Z3QlM0JFbWJlZGRpbmclMjZsdCUzQiUyRnNwYW4lMjZndCUzQiUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTI2bHQlM0IlMkZkaXYlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCY29udGFpbmVyJTNEMCUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjQ4My45OSUyMiUyMHklM0QlMjIyMDMlMjIlMjB3aWR0aCUzRCUyMjEzMiUyMiUyMGhlaWdodCUzRCUyMjUzLjQ4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTM1JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnWkdGMFlTMXVZVzFsUFNKTVlYbGxjaUExSWlCcFpEMGlUR0Y1WlhKZk5TSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05rT1RZME1qRTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUlIc21JM2hoT3lBZ0lDQWdJQ0FnYzNSeWIydGxMWGRwWkhSb09pQXdjSGc3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNaUI3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNObVptWTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc2dJQ0FnUEM5emRIbHNaVDRtSTNoaE95QWdQQzlrWldaelBpWWplR0U3SUNBOFp5QnBaRDBpUVc1bmJHVnpJajRtSTNoaE95QWdJQ0E4Y0dGMGFDQmtQU0pOTUN3d2RqUXlhRFF5VmpCSU1GcE5NekVzTVRCak1TNHhNREF3TkN3d0xESXNMamc1TURFMExESXNNaXd3TERFdU1UQXdNUzB1T0RrNU9UWXNNaTB5TERJdE1TNHdPVGs1T0N3d0xUSXRMamc1T1RrdE1pMHlMREF0TVM0eE1EazROaTQ1TURBd01pMHlMREl0TWxwTk16QXNNakJqTUN3eExqWTFPVFkzTFRFdU16TTVPVGNzTXkwekxETnpMVE10TVM0ek5EQXpNeTB6TFROak1DMHhMalkyTURFMkxERXVNelF3TURNdE15d3pMVE56TXl3eExqTXpPVGcwTERNc00xcE5NVFFzTVROak1TNHhNREF3TkN3d0xESXNMamc1TURFMExESXNNaXd3TERFdU1UQXdNUzB1T0RrNU9UWXNNaTB5TERJdE1TNHdPVGs1T0N3d0xUSXRMamc1T1RrdE1pMHlMREF0TVM0eE1EazROaTQ1TURBd01pMHlMREl0TWxwTk9Td3lNV014TGpFd01EQTBMREFzTWl3dU9Ea3dNVFFzTWl3eUxEQXNNUzR4TURBeExTNDRPVGs1Tml3eUxUSXNNaTB4TGpBNU9UazRMREF0TWkwdU9EazVPUzB5TFRJc01DMHhMakV3T1RnMkxqa3dNREF5TFRJc01pMHlXazB4T1N3ek1tTXRNUzR3T1RrNU9Dd3dMVEl0TGpnNU9Ua3RNaTB5TERBdE1TNHhNRGs0Tmk0NU1EQXdNaTB5TERJdE1pd3hMakV3TURBMExEQXNNaXd1T0Rrd01UUXNNaXd5TERBc01TNHhNREF4TFM0NE9UazVOaXd5TFRJc01scE5NalVzTXpkakxURXVNRGs1T1Rnc01DMHlMUzQ0T1RrNUxUSXRNaXd3TFRFdU1UQTVPRFl1T1RBd01ESXRNaXd5TFRJc01TNHhNREF3TkN3d0xESXNMamc1TURFMExESXNNaXd3TERFdU1UQXdNUzB1T0RrNU9UWXNNaTB5TERKYVRUTXhMamN6T1RrNUxETXpMamd4TURBMmJDMHhMakl4T1RrM0xTNDNNREF5TERRdU56Z3dNRE10TVM0eU56azNPUzB4TkM0ek1EQXdOUzA0TGpJMk1ESTFMVEUwTGpJNU9UazVMRGd1TWpZd01qVXNOQzQzT0RBd015d3hMakkzT1RjNUxURXVNakl3TURNdU56QXdNaTAxTGpRMU9UazJMVEV1TkRVNU9UWXNNUzQwTlRrNU5pMDFMalExT1RrMkxERXVNakl3TURNdExqY3dNREl0TVM0eU9EQXdNeXcwTGpjM01EQXlMREUwTGpJNU9UazVMVGd1TWpWV055NHlNRGs1Tm13dE15NDFMRE11TlhZdE1TNDBNVGs1TW13MExUUXNOQ3cwZGpFdU5ERTVPVEpzTFRNdU5TMHpMalYyTVRVdU5Xd3hOQzR5T1RBd05DdzRMakkxTFRFdU1qZ3dNRE10TkM0M056QXdNaXd4TGpJeU9UazRMamN3TURJc01TNDBOakF3TWl3MUxqUTFPVGsyTFRVdU5EWXdNRElzTVM0ME5UazVObG9pSUdOc1lYTnpQU0pqYkhNdE1TSXZQaVlqZUdFN0lDQThMMmMlMkJKaU40WVRzZ0lEeHdiMng1WjI5dUlIQnZhVzUwY3owaU16Y3VNakF3TURFZ016SXVNelV3TVNBek1TNDNNems1T1NBek15NDRNVEF3TmlBek1DNDFNakF3TWlBek15NHhNRGs0TmlBek5TNHpNREF3TlNBek1TNDRNekF3T0NBeU1TQXlNeTQxTmprNE1pQTJMamN3TURBeElETXhMamd6TURBNElERXhMalE0TURBMElETXpMakV3T1RnMklERXdMakkyTURBeElETXpMamd4TURBMklEUXVPREF3TURVZ016SXVNelV3TVNBMkxqSTJNREF4SURJMkxqZzVNREUwSURjdU5EZ3dNRFFnTWpZdU1UZzVPVFFnTmk0eU1EQXdNU0F6TUM0NU5UazVOaUF5TUM0MUlESXlMamN3T1RrMklESXdMalVnTnk0eU1EazVOaUF4TnlBeE1DNDNNRGs1TmlBeE55QTVMakk1TURBMElESXhJRFV1TWprd01EUWdNalVnT1M0eU9UQXdOQ0F5TlNBeE1DNDNNRGs1TmlBeU1TNDFJRGN1TWpBNU9UWWdNakV1TlNBeU1pNDNNRGs1TmlBek5TNDNPVEF3TkNBek1DNDVOVGs1TmlBek5DNDFNVEF3TVNBeU5pNHhPRGs1TkNBek5TNDNNems1T1NBeU5pNDRPVEF4TkNBek55NHlNREF3TVNBek1pNHpOVEF4SWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQR05wY21Oc1pTQnlQU0l5SWlCamVUMGlNelVpSUdONFBTSXlOU0lnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR4amFYSmpiR1VnY2owaU1pSWdZM2s5SWpFeUlpQmplRDBpTXpFaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4WTJseVkyeGxJSEk5SWpNaUlHTjVQU0l5TUNJZ1kzZzlJakkzSWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQR05wY21Oc1pTQnlQU0l5SWlCamVUMGlNekFpSUdONFBTSXhPU0lnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUR4amFYSmpiR1VnY2owaU1pSWdZM2s5SWpJeklpQmplRDBpT1NJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lEeGphWEpqYkdVZ2NqMGlNaUlnWTNrOUlqRTFJaUJqZUQwaU1UUWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3UEM5emRtYyUyQiUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3NDglMjIlMjB5JTNEJTIyMTU4JTIyJTIwd2lkdGglM0QlMjI0MiUyMiUyMGhlaWdodCUzRCUyMjQyJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTM2JTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQkxsYW1hUGFyc2UlMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCZm9udENvbG9yJTNEJTIzRkZGRkZGJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMjY3JTIyJTIweSUzRCUyMjIwMyUyMiUyMHdpZHRoJTNEJTIyMTMwJTIyJTIwaGVpZ2h0JTNEJTIyMzglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMzclMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCRW50ZXJwcmlzZSUyNmx0JTNCYnIlMjZndCUzQkRhdGElMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCZm9udENvbG9yJTNEJTIzRkZGRkZGJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyNjMlMjIlMjB5JTNEJTIyMjAzJTIyJTIwd2lkdGglM0QlMjIxMTMlMjIlMjBoZWlnaHQlM0QlMjIzOCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0zOCUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JWZWN0b3IlMjBEYXRhYmFzZSUyNmx0JTNCJTJGZm9udCUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0Jmb250Q29sb3IlM0QlMjNGRkZGRkYlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3MTIuNSUyMiUyMHklM0QlMjIyMDMlMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjI4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTM5JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnWkdGMFlTMXVZVzFsUFNKTVlYbGxjaUExSWlCcFpEMGlUR0Y1WlhKZk5TSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05rT1RZME1qRTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUxDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0J6ZEhKdmEyVXRkMmxrZEdnNklEQndlRHNtSTNoaE95QWdJQ0FnSUgwbUkzaGhPeVlqZUdFN0lDQWdJQ0FnTG1Oc2N5MHlMQ0F1WTJ4ekxUTWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c0xYSjFiR1U2SUdWMlpXNXZaR1E3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTRMamN3TURBeElESXdMakU1T1RjeElESTRMamN3TURBeElESXpMalVnTWpVdU5EQTVPVGNnTWpNdU5TQXlPQzQzTURBd01TQXlNQzR4T1RrM01TSWdZMnhoYzNNOUltTnNjeTB4SWk4JTJCSmlONFlUc2dJRHh3WVhSb0lHUTlJazB5T1M0M01EQXdNU3d4T1M0MWRqVm9MVFYyTVRKb01USjJMVEUzYUMwM1drMHpNQzQzTURBd01Td3pNeTQxYUMwMGRpMHhhRFIyTVZwTk16UXVOekF3TURFc016QXVOV2d0T0hZdE1XZzRkakZhVFRNMExqY3dNREF4TERJM0xqVm9MVGgyTFRGb09IWXhXaUlnWTJ4aGMzTTlJbU5zY3kweElpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWswd0xEQjJOREpvTkRKV01FZ3dXazB4TVM0M01EQXdNU3d5TVM0MWFDMDNWalF1TldneE4zWTNhQzB4ZGkwMlNEVXVOekF3TURGMk1UVm9Obll4V2sweE1TNDJPU3d4TkM0MWRqRm9MVFV1Tmpsc05pNHhNaTAyTGpJd01ESXNNUzR3TkRrNU9TNDVPVEF5TXl3eUxqQXlNREF5TFRJdU1UWXdNVFlzTXk0eU5Td3pMak0zTURFeWFDMDBMakl6T1RrNWJDMHVNREl3TURJdU1ESXdNREpvTFRJdU5Xd3VNREV3TURFc01pNDVOems1T0ZwTk1qSXVOekF3TURFc01qa3VOV2d0TVRCV01USXVOV2d4TjNZMExqZ3pNREE0YUMweGRpMHpMamd6TURBNGFDMHhOWFl4TldnNWRqRmFUVEkyTGpVeE1EQXhMREU0TGpZNE9UazBiQzB5TGpNek1EQXlMREl1TXpNd01EZ3RNaTR6TnkwdU5qSTVPRGd0TVM0eU1qazVPQzAwTGpVNU1ETXpMalE0T1RrNUxTNHhNams0T0dNdU5ERTVPVGd0TGpFd09UZzJMamM0T1RrNExTNHhOams1TWl3eExqRTBPVGsyTFM0eE5qazVNaXd5TGpBeU1EQXlMREFzTXk0M05EQXdOU3d4TGpNMU1ERXNOQzR5T1RBd05Dd3pMakU0T1RrMFdrMHlNaTR5TURBd01Td3lNM1l6TGpBMk9UZ3lZeTB1TlRrd01ETXVNamd3TWpjdE1TNHlOUzQwTXpBeE9DMHhMamt5T1RrNUxqUXpNREU0TFRJdU5USXdNRElzTUMwMExqVTNNREF4TFRJdU1EVXdNamt0TkM0MU56QXdNUzAwTGpVMk9UZ3lMREF0TWk0d05qQXdOaXd4TGpNNE9UazFMVE11T0Rjd01USXNNeTR6T0RrNU5TMDBMalF4TURFMmJDNDBPVEF3TlMwdU1USTVPRGdzTVM0d09UazVPQ3cwTGpFeU9UZzRMREl1TXpjdU5qSTVPRGd0TGpnME9UazRMamcxTURGYVRUTTNMamN3TURBeExETTNMalZvTFRFMGRpMHhNeTQzTURBeWJEVXVNamc1T1RndE5TNHlPVGs0YURndU56RXdNREoyTVRsYUlpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJNExqazRPVGs1TERFNExqVnNMVFV1TWpnNU9UZ3NOUzR5T1RrNGRqRXpMamN3TURKb01UUjJMVEU1YUMwNExqY3hNREF5V2sweU9DNDNNREF3TVN3eU1DNHhPVGszTVhZekxqTXdNREk1YUMwekxqSTVNREEwYkRNdU1qa3dNRFF0TXk0ek1EQXlPVnBOTXpZdU56QXdNREVzTXpZdU5XZ3RNVEoyTFRFeWFEVjJMVFZvTjNZeE4xb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOGNtVmpkQ0JvWldsbmFIUTlJakVpSUhkcFpIUm9QU0k0SWlCNVBTSXlOaTQxSWlCNFBTSXlOaTQzTURBd01TSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHh5WldOMElHaGxhV2RvZEQwaU1TSWdkMmxrZEdnOUlqZ2lJSGs5SWpJNUxqVWlJSGc5SWpJMkxqY3dNREF4SWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJeElpQjNhV1IwYUQwaU5DSWdlVDBpTXpJdU5TSWdlRDBpTWpZdU56QXdNREVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTVMamN3TURBeElERXlMalVnTWprdU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRNdU5TQXhNeTQzTURBd01TQXhNeTQxSURFekxqY3dNREF4SURJNExqVWdNakl1TnpBd01ERWdNamd1TlNBeU1pNDNNREF3TVNBeU9TNDFJREV5TGpjd01EQXhJREk1TGpVZ01USXVOekF3TURFZ01USXVOU0F5T1M0M01EQXdNU0F4TWk0MUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJMkxqVXhNREF4TERFNExqWTRPVGswYkMweUxqTXpNREF5TERJdU16TXdNRGd0TWk0ek55MHVOakk1T0RndE1TNHlNams1T0MwMExqVTVNRE16TGpRNE9UazVMUzR4TWprNE9HTXVOREU1T1RndExqRXdPVGcyTGpjNE9UazRMUzR4TmprNU1pd3hMakUwT1RrMkxTNHhOams1TWl3eUxqQXlNREF5TERBc015NDNOREF3TlN3eExqTTFNREVzTkM0eU9UQXdOQ3d6TGpFNE9UazBXaUlnWTJ4aGMzTTlJbU5zY3kweklpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWsweU15NHdORGs1T1N3eU1pNHhORGs1YkMwdU9EUTVPVGd1T0RVd01YWXpMakEyT1RneVl5MHVOVGt3TURNdU1qZ3dNamN0TVM0eU5TNDBNekF4T0MweExqa3lPVGs1TGpRek1ERTRMVEl1TlRJd01ESXNNQzAwTGpVM01EQXhMVEl1TURVd01qa3ROQzQxTnpBd01TMDBMalUyT1RneUxEQXRNaTR3TmpBd05pd3hMak00T1RrMUxUTXVPRGN3TVRJc015NHpPRGs1TlMwMExqUXhNREUyYkM0ME9UQXdOUzB1TVRJNU9EZ3NNUzR3T1RrNU9DdzBMakV5T1RnNExESXVNemN1TmpJNU9EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BIQnZiSGxuYjI0Z2NHOXBiblJ6UFNJeU1TNDNNREF3TVNBMExqVWdNakV1TnpBd01ERWdNVEV1TlNBeU1DNDNNREF3TVNBeE1TNDFJREl3TGpjd01EQXhJRFV1TlNBMUxqY3dNREF4SURVdU5TQTFMamN3TURBeElESXdMalVnTVRFdU56QXdNREVnTWpBdU5TQXhNUzQzTURBd01TQXlNUzQxSURRdU56QXdNREVnTWpFdU5TQTBMamN3TURBeElEUXVOU0F5TVM0M01EQXdNU0EwTGpVaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakU0TGpRMElERXhMalVnTVRRdU1qQXdNREVnTVRFdU5TQXhOQzR4TnprNU9TQXhNUzQxTWpBd01pQXhNUzQyTnprNU9TQXhNUzQxTWpBd01pQXhNUzQyT1NBeE5DNDFJREV4TGpZNUlERTFMalVnTmlBeE5TNDFJREV5TGpFeUlEa3VNams1T0NBeE15NHhOams1T0NBeE1DNHlPVEF3TkNBeE5TNHhPU0E0TGpFeU9UZzRJREU0TGpRMElERXhMalVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN1BDOXpkbWMlMkIlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyMTA5MiUyMiUyMHklM0QlMjI1NzMlMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNDIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNDElMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCTlZJRElBJTIwTklNJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQmNvbnRhaW5lciUzRDAlM0Jmb250Q29sb3IlM0QlMjNGRkZGRkYlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI5MjYuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExNCUyMiUyMGhlaWdodCUzRCUyMjUzLjQ4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTQyJTIyJTIwdmFsdWUlM0QlMjIlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQkJsb2clMjBQb3N0JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjEwNTYuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjM4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTQzJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnWkdGMFlTMXVZVzFsUFNKTVlYbGxjaUExSWlCcFpEMGlUR0Y1WlhKZk5TSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ05rT1RZME1qRTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUxDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0J6ZEhKdmEyVXRkMmxrZEdnNklEQndlRHNtSTNoaE95QWdJQ0FnSUgwbUkzaGhPeVlqZUdFN0lDQWdJQ0FnTG1Oc2N5MHlMQ0F1WTJ4ekxUTWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRNZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c0xYSjFiR1U2SUdWMlpXNXZaR1E3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNnSUNBZ1BDOXpkSGxzWlQ0bUkzaGhPeUFnUEM5a1pXWnpQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTRMamN3TURBeElESXdMakU1T1RjeElESTRMamN3TURBeElESXpMalVnTWpVdU5EQTVPVGNnTWpNdU5TQXlPQzQzTURBd01TQXlNQzR4T1RrM01TSWdZMnhoYzNNOUltTnNjeTB4SWk4JTJCSmlONFlUc2dJRHh3WVhSb0lHUTlJazB5T1M0M01EQXdNU3d4T1M0MWRqVm9MVFYyTVRKb01USjJMVEUzYUMwM1drMHpNQzQzTURBd01Td3pNeTQxYUMwMGRpMHhhRFIyTVZwTk16UXVOekF3TURFc016QXVOV2d0T0hZdE1XZzRkakZhVFRNMExqY3dNREF4TERJM0xqVm9MVGgyTFRGb09IWXhXaUlnWTJ4aGMzTTlJbU5zY3kweElpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWswd0xEQjJOREpvTkRKV01FZ3dXazB4TVM0M01EQXdNU3d5TVM0MWFDMDNWalF1TldneE4zWTNhQzB4ZGkwMlNEVXVOekF3TURGMk1UVm9Obll4V2sweE1TNDJPU3d4TkM0MWRqRm9MVFV1Tmpsc05pNHhNaTAyTGpJd01ESXNNUzR3TkRrNU9TNDVPVEF5TXl3eUxqQXlNREF5TFRJdU1UWXdNVFlzTXk0eU5Td3pMak0zTURFeWFDMDBMakl6T1RrNWJDMHVNREl3TURJdU1ESXdNREpvTFRJdU5Xd3VNREV3TURFc01pNDVOems1T0ZwTk1qSXVOekF3TURFc01qa3VOV2d0TVRCV01USXVOV2d4TjNZMExqZ3pNREE0YUMweGRpMHpMamd6TURBNGFDMHhOWFl4TldnNWRqRmFUVEkyTGpVeE1EQXhMREU0TGpZNE9UazBiQzB5TGpNek1EQXlMREl1TXpNd01EZ3RNaTR6TnkwdU5qSTVPRGd0TVM0eU1qazVPQzAwTGpVNU1ETXpMalE0T1RrNUxTNHhNams0T0dNdU5ERTVPVGd0TGpFd09UZzJMamM0T1RrNExTNHhOams1TWl3eExqRTBPVGsyTFM0eE5qazVNaXd5TGpBeU1EQXlMREFzTXk0M05EQXdOU3d4TGpNMU1ERXNOQzR5T1RBd05Dd3pMakU0T1RrMFdrMHlNaTR5TURBd01Td3lNM1l6TGpBMk9UZ3lZeTB1TlRrd01ETXVNamd3TWpjdE1TNHlOUzQwTXpBeE9DMHhMamt5T1RrNUxqUXpNREU0TFRJdU5USXdNRElzTUMwMExqVTNNREF4TFRJdU1EVXdNamt0TkM0MU56QXdNUzAwTGpVMk9UZ3lMREF0TWk0d05qQXdOaXd4TGpNNE9UazFMVE11T0Rjd01USXNNeTR6T0RrNU5TMDBMalF4TURFMmJDNDBPVEF3TlMwdU1USTVPRGdzTVM0d09UazVPQ3cwTGpFeU9UZzRMREl1TXpjdU5qSTVPRGd0TGpnME9UazRMamcxTURGYVRUTTNMamN3TURBeExETTNMalZvTFRFMGRpMHhNeTQzTURBeWJEVXVNamc1T1RndE5TNHlPVGs0YURndU56RXdNREoyTVRsYUlpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJNExqazRPVGs1TERFNExqVnNMVFV1TWpnNU9UZ3NOUzR5T1RrNGRqRXpMamN3TURKb01UUjJMVEU1YUMwNExqY3hNREF5V2sweU9DNDNNREF3TVN3eU1DNHhPVGszTVhZekxqTXdNREk1YUMwekxqSTVNREEwYkRNdU1qa3dNRFF0TXk0ek1EQXlPVnBOTXpZdU56QXdNREVzTXpZdU5XZ3RNVEoyTFRFeWFEVjJMVFZvTjNZeE4xb2lJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOGNtVmpkQ0JvWldsbmFIUTlJakVpSUhkcFpIUm9QU0k0SWlCNVBTSXlOaTQxSWlCNFBTSXlOaTQzTURBd01TSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHh5WldOMElHaGxhV2RvZEQwaU1TSWdkMmxrZEdnOUlqZ2lJSGs5SWpJNUxqVWlJSGc5SWpJMkxqY3dNREF4SWlCamJHRnpjejBpWTJ4ekxUSWlMejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJeElpQjNhV1IwYUQwaU5DSWdlVDBpTXpJdU5TSWdlRDBpTWpZdU56QXdNREVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN0lDQThjRzlzZVdkdmJpQndiMmx1ZEhNOUlqSTVMamN3TURBeElERXlMalVnTWprdU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRjdU16TXdNRGdnTWpndU56QXdNREVnTVRNdU5TQXhNeTQzTURBd01TQXhNeTQxSURFekxqY3dNREF4SURJNExqVWdNakl1TnpBd01ERWdNamd1TlNBeU1pNDNNREF3TVNBeU9TNDFJREV5TGpjd01EQXhJREk1TGpVZ01USXVOekF3TURFZ01USXVOU0F5T1M0M01EQXdNU0F4TWk0MUlpQmpiR0Z6Y3owaVkyeHpMVElpTHo0bUkzaGhPeUFnUEhCaGRHZ2daRDBpVFRJMkxqVXhNREF4TERFNExqWTRPVGswYkMweUxqTXpNREF5TERJdU16TXdNRGd0TWk0ek55MHVOakk1T0RndE1TNHlNams1T0MwMExqVTVNRE16TGpRNE9UazVMUzR4TWprNE9HTXVOREU1T1RndExqRXdPVGcyTGpjNE9UazRMUzR4TmprNU1pd3hMakUwT1RrMkxTNHhOams1TWl3eUxqQXlNREF5TERBc015NDNOREF3TlN3eExqTTFNREVzTkM0eU9UQXdOQ3d6TGpFNE9UazBXaUlnWTJ4aGMzTTlJbU5zY3kweklpOCUyQkppTjRZVHNnSUR4d1lYUm9JR1E5SWsweU15NHdORGs1T1N3eU1pNHhORGs1YkMwdU9EUTVPVGd1T0RVd01YWXpMakEyT1RneVl5MHVOVGt3TURNdU1qZ3dNamN0TVM0eU5TNDBNekF4T0MweExqa3lPVGs1TGpRek1ERTRMVEl1TlRJd01ESXNNQzAwTGpVM01EQXhMVEl1TURVd01qa3ROQzQxTnpBd01TMDBMalUyT1RneUxEQXRNaTR3TmpBd05pd3hMak00T1RrMUxUTXVPRGN3TVRJc015NHpPRGs1TlMwMExqUXhNREUyYkM0ME9UQXdOUzB1TVRJNU9EZ3NNUzR3T1RrNU9DdzBMakV5T1RnNExESXVNemN1TmpJNU9EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ1BIQnZiSGxuYjI0Z2NHOXBiblJ6UFNJeU1TNDNNREF3TVNBMExqVWdNakV1TnpBd01ERWdNVEV1TlNBeU1DNDNNREF3TVNBeE1TNDFJREl3TGpjd01EQXhJRFV1TlNBMUxqY3dNREF4SURVdU5TQTFMamN3TURBeElESXdMalVnTVRFdU56QXdNREVnTWpBdU5TQXhNUzQzTURBd01TQXlNUzQxSURRdU56QXdNREVnTWpFdU5TQTBMamN3TURBeElEUXVOU0F5TVM0M01EQXdNU0EwTGpVaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0E4Y0c5c2VXZHZiaUJ3YjJsdWRITTlJakU0TGpRMElERXhMalVnTVRRdU1qQXdNREVnTVRFdU5TQXhOQzR4TnprNU9TQXhNUzQxTWpBd01pQXhNUzQyTnprNU9TQXhNUzQxTWpBd01pQXhNUzQyT1NBeE5DNDFJREV4TGpZNUlERTFMalVnTmlBeE5TNDFJREV5TGpFeUlEa3VNams1T0NBeE15NHhOams1T0NBeE1DNHlPVEF3TkNBeE5TNHhPU0E0TGpFeU9UZzRJREU0TGpRMElERXhMalVpSUdOc1lYTnpQU0pqYkhNdE1pSXZQaVlqZUdFN1BDOXpkbWMlMkIlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0Jmb250U2l6ZSUzRDEyJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyNTg2JTIyJTIweSUzRCUyMjU3MyUyMiUyMHdpZHRoJTNEJTIyNDIlMjIlMjBoZWlnaHQlM0QlMjI0MiUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti00NSUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JOVklESUElMjBOSU0lMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyMiUyMHN0eWxlJTNEJTIydGV4dCUzQnN0cm9rZUNvbG9yJTNEbm9uZSUzQmFsaWduJTNEY2VudGVyJTNCZmlsbENvbG9yJTNEbm9uZSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0Jyb3VuZGVkJTNEMCUzQmh0bWwlM0QxJTNCc3BhY2luZyUzRDAlM0J0ZXh0RGlyZWN0aW9uJTNEbHRyJTNCbGFiZWxQb3NpdGlvbiUzRGNlbnRlciUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRG1pZGRsZSUzQndoaXRlU3BhY2UlM0R3cmFwJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZGlyZWN0aW9uJTNEc291dGglM0Jmb250U2l6ZSUzRDEyJTNCY29udGFpbmVyJTNEMCUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjQyMi41JTIyJTIweSUzRCUyMjYxNyUyMiUyMHdpZHRoJTNEJTIyMTE0JTIyJTIwaGVpZ2h0JTNEJTIyNTMuNDglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNDYlMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCUXVlc3Rpb25zJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjU1MC41JTIyJTIweSUzRCUyMjYxNyUyMiUyMHdpZHRoJTNEJTIyMTEzJTIyJTIwaGVpZ2h0JTNEJTIyMzglMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNDclMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZGl2JTI2Z3QlM0IlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQlJldHJpZXZhbCUyMEFnZW50JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0Jmb250Q29sb3IlM0QlMjNGRkZGRkYlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI3MTIuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjM4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTQ4JTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnYVdROUltOTFkR3hwYm1VaVBpWWplR0U3SUNBOFpHVm1jejRtSTNoaE95QWdJQ0E4YzNSNWJHVSUyQkppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c09pQWpabVppWXpBd095WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFc0lDNWpiSE10TWlCN0ppTjRZVHNnSUNBZ0lDQWdJSE4wY205clpTMTNhV1IwYURvZ01IQjRPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxUSWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0lDQWdJRHd2YzNSNWJHVSUyQkppTjRZVHNnSUR3dlpHVm1jejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJME1pSWdkMmxrZEdnOUlqUXlJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BHYyUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRURXlMakE0TXpVc01UUXVNVE0xTTJ3ekxqUXhOalV0TXk0ME1UWTBOSFl4TGpjNU1qazNhREYyTFRNdU5XZ3RNeTQxZGpGb01TNDNPVEk1TjJ3dE15NDBNVFkxTERNdU5ERTJORFJqTFM0ek9UVXdNaTB1TWpZeE9UWXRMamcyTnpZNExTNDBNVFkwTkMweExqTTNOalEyTFM0ME1UWTBOQzB4TGpNM09Ea3hMREF0TWk0MUxERXVNVEl4TlRndE1pNDFMREl1TlhNeExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxESXVOUzB4TGpFeU1UVTRMREl1TlMweUxqVmpNQzB1TlRBNE5qY3RMakUxTkRVMExTNDVPREV5TmkwdU5ERTJOUzB4TGpNM05qVXpXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRUSTNMak01TXpVMUxERTNMalF4TVROc0xUTXVPRGt6TlRVc015NDRPVE0wT1hZdE1TNDNPVEk1TjJndE1YWXpMalZvTXk0MWRpMHhhQzB4TGpjNU1qazNiRFF1TVRBM05ESXROQzR4TURjMU5HTXVNakU1TWpRdU1EWXpNRFV1TkRRMk1qa3VNVEEzTlRRdU5qZzFOVFV1TVRBM05UUXNNUzR6TnpnNU1Td3dMREl1TlMweExqRXlNVFU0TERJdU5TMHlMalZ6TFRFdU1USXhNRGt0TWk0MUxUSXVOUzB5TGpVdE1pNDFMREV1TVRJeE5UZ3RNaTQxTERJdU5XTXdMQzQzTmpNNU9DNHpOVEUxTml3eExqUTBNRFE1TGpnNU16VTFMREV1T0RrNU5EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5NakFzT1M0d01URTRNMk11TlRBNE56a3NNQ3d1T1RneE5EVXRMakUxTkRRNExERXVNemMyTkRZdExqUXhOalEwYkRNdU5ERTJOU3d6TGpReE5qUTBhQzB4TGpjNU1qazNkakZvTXk0MWRpMHpMalZvTFRGMk1TNDNPVEk1TjJ3dE15NDBNVFkxTFRNdU5ERTJORFJqTGpJMk1UazJMUzR6T1RVeU5pNDBNVFkxTFM0NE5qYzROaTQwTVRZMUxURXVNemMyTlRNc01DMHhMak0zT0RReUxURXVNVEl4TURrdE1pNDFMVEl1TlMweUxqVnpMVEl1TlN3eExqRXlNVFU0TFRJdU5Td3lMalVzTVM0eE1qRXdPU3d5TGpVc01pNDFMREl1TlZvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0FnSUR4amFYSmpiR1VnY2owaU1pNDFJaUJqZVQwaU16VXVOVEV4T0RNaUlHTjRQU0l5T1NJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEl6TERNekxqQXhNVGd6YURNdU5YWXRNeTQxYUMweGRqRXVOemt5T1Rkc0xUUXVOREUyTlMwMExqUXhOalEwWXk0eU5qRTVOaTB1TXprMU1qWXVOREUyTlMwdU9EWTNPRFl1TkRFMk5TMHhMak0zTmpVekxEQXRNUzR6TnpnME1pMHhMakV5TVRBNUxUSXVOUzB5TGpVdE1pNDFMUzQxTURnM09Td3dMUzQ1T0RFME5TNHhOVFEwT0MweExqTTNOalEyTGpReE5qUTBiQzB6TGpReE5qVXRNeTQwTVRZME5HZ3hMamM1TWprM2RpMHhhQzB6TGpWMk15NDFhREYyTFRFdU56a3lPVGRzTXk0ME1UWTFMRE11TkRFMk5EUmpMUzR5TmpFNU5pNHpPVFV5TmkwdU5ERTJOUzQ0TmpjNE5pMHVOREUyTlN3eExqTTNOalV6TERBc01TNHpOemcwTWl3eExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxqVXdPRGM1TERBc0xqazRNVFExTFM0eE5UUTBPQ3d4TGpNM05qUTJMUzQwTVRZME5HdzBMalF4TmpVc05DNDBNVFkwTkdndE1TNDNPVEk1TjNZeFdpSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHd2Wno0bUkzaGhPend2YzNablBnJTNEJTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjc0OCUyMiUyMHklM0QlMjI1NzMlMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNDIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNDklMjIlMjB2YWx1ZSUzRCUyMiUyNmx0JTNCZm9udCUyMGZhY2UlM0QlMjZxdW90JTNCTlZJRElBU2Fucy1SZWd1bGFyJTI2cXVvdCUzQiUyNmd0JTNCT3V0bGluZSUyMEdlbmVyYXRpb24lMjZsdCUzQiUyRmZvbnQlMjZndCUzQiUyNmx0JTNCZGl2JTI2Z3QlM0IlMjZsdCUzQmZvbnQlMjBmYWNlJTNEJTI2cXVvdCUzQk5WSURJQVNhbnMtUmVndWxhciUyNnF1b3QlM0IlMjZndCUzQkFnZW50JTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjZsdCUzQiUyRmRpdiUyNmd0JTNCJTIyJTIwc3R5bGUlM0QlMjJ0ZXh0JTNCc3Ryb2tlQ29sb3IlM0Rub25lJTNCYWxpZ24lM0RjZW50ZXIlM0JmaWxsQ29sb3IlM0Rub25lJTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQnJvdW5kZWQlM0QwJTNCaHRtbCUzRDElM0JzcGFjaW5nJTNEMCUzQnRleHREaXJlY3Rpb24lM0RsdHIlM0JsYWJlbFBvc2l0aW9uJTNEY2VudGVyJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEbWlkZGxlJTNCd2hpdGVTcGFjZSUzRHdyYXAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyMFJlZ3VsYXIlM0JkaXJlY3Rpb24lM0Rzb3V0aCUzQmZvbnRTaXplJTNEMTIlM0Jmb250Q29sb3IlM0QlMjNGRkZGRkYlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjIyMjMuNSUyMiUyMHklM0QlMjI2MTclMjIlMjB3aWR0aCUzRCUyMjExMyUyMiUyMGhlaWdodCUzRCUyMjM4JTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTUwJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTBNaUlnYVdROUltOTFkR3hwYm1VaVBpWWplR0U3SUNBOFpHVm1jejRtSTNoaE95QWdJQ0E4YzNSNWJHVSUyQkppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFZ2V5WWplR0U3SUNBZ0lDQWdJQ0JtYVd4c09pQWpabVppWXpBd095WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0ppTjRZVHNnSUNBZ0lDQXVZMnh6TFRFc0lDNWpiSE10TWlCN0ppTjRZVHNnSUNBZ0lDQWdJSE4wY205clpTMTNhV1IwYURvZ01IQjRPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxUSWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqWm1abU95WWplR0U3SUNBZ0lDQWdmU1lqZUdFN0lDQWdJRHd2YzNSNWJHVSUyQkppTjRZVHNnSUR3dlpHVm1jejRtSTNoaE95QWdQSEpsWTNRZ2FHVnBaMmgwUFNJME1pSWdkMmxrZEdnOUlqUXlJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BHYyUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRURXlMakE0TXpVc01UUXVNVE0xTTJ3ekxqUXhOalV0TXk0ME1UWTBOSFl4TGpjNU1qazNhREYyTFRNdU5XZ3RNeTQxZGpGb01TNDNPVEk1TjJ3dE15NDBNVFkxTERNdU5ERTJORFJqTFM0ek9UVXdNaTB1TWpZeE9UWXRMamcyTnpZNExTNDBNVFkwTkMweExqTTNOalEyTFM0ME1UWTBOQzB4TGpNM09Ea3hMREF0TWk0MUxERXVNVEl4TlRndE1pNDFMREl1TlhNeExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxESXVOUzB4TGpFeU1UVTRMREl1TlMweUxqVmpNQzB1TlRBNE5qY3RMakUxTkRVMExTNDVPREV5TmkwdU5ERTJOUzB4TGpNM05qVXpXaUlnWTJ4aGMzTTlJbU5zY3kweUlpOCUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRUSTNMak01TXpVMUxERTNMalF4TVROc0xUTXVPRGt6TlRVc015NDRPVE0wT1hZdE1TNDNPVEk1TjJndE1YWXpMalZvTXk0MWRpMHhhQzB4TGpjNU1qazNiRFF1TVRBM05ESXROQzR4TURjMU5HTXVNakU1TWpRdU1EWXpNRFV1TkRRMk1qa3VNVEEzTlRRdU5qZzFOVFV1TVRBM05UUXNNUzR6TnpnNU1Td3dMREl1TlMweExqRXlNVFU0TERJdU5TMHlMalZ6TFRFdU1USXhNRGt0TWk0MUxUSXVOUzB5TGpVdE1pNDFMREV1TVRJeE5UZ3RNaTQxTERJdU5XTXdMQzQzTmpNNU9DNHpOVEUxTml3eExqUTBNRFE1TGpnNU16VTFMREV1T0RrNU5EaGFJaUJqYkdGemN6MGlZMnh6TFRJaUx6NG1JM2hoT3lBZ0lDQThjR0YwYUNCa1BTSk5NakFzT1M0d01URTRNMk11TlRBNE56a3NNQ3d1T1RneE5EVXRMakUxTkRRNExERXVNemMyTkRZdExqUXhOalEwYkRNdU5ERTJOU3d6TGpReE5qUTBhQzB4TGpjNU1qazNkakZvTXk0MWRpMHpMalZvTFRGMk1TNDNPVEk1TjJ3dE15NDBNVFkxTFRNdU5ERTJORFJqTGpJMk1UazJMUzR6T1RVeU5pNDBNVFkxTFM0NE5qYzROaTQwTVRZMUxURXVNemMyTlRNc01DMHhMak0zT0RReUxURXVNVEl4TURrdE1pNDFMVEl1TlMweUxqVnpMVEl1TlN3eExqRXlNVFU0TFRJdU5Td3lMalVzTVM0eE1qRXdPU3d5TGpVc01pNDFMREl1TlZvaUlHTnNZWE56UFNKamJITXRNaUl2UGlZamVHRTdJQ0FnSUR4amFYSmpiR1VnY2owaU1pNDFJaUJqZVQwaU16VXVOVEV4T0RNaUlHTjRQU0l5T1NJZ1kyeGhjM005SW1Oc2N5MHlJaTglMkJKaU40WVRzZ0lDQWdQSEJoZEdnZ1pEMGlUVEl6TERNekxqQXhNVGd6YURNdU5YWXRNeTQxYUMweGRqRXVOemt5T1Rkc0xUUXVOREUyTlMwMExqUXhOalEwWXk0eU5qRTVOaTB1TXprMU1qWXVOREUyTlMwdU9EWTNPRFl1TkRFMk5TMHhMak0zTmpVekxEQXRNUzR6TnpnME1pMHhMakV5TVRBNUxUSXVOUzB5TGpVdE1pNDFMUzQxTURnM09Td3dMUzQ1T0RFME5TNHhOVFEwT0MweExqTTNOalEyTGpReE5qUTBiQzB6TGpReE5qVXRNeTQwTVRZME5HZ3hMamM1TWprM2RpMHhhQzB6TGpWMk15NDFhREYyTFRFdU56a3lPVGRzTXk0ME1UWTFMRE11TkRFMk5EUmpMUzR5TmpFNU5pNHpPVFV5TmkwdU5ERTJOUzQ0TmpjNE5pMHVOREUyTlN3eExqTTNOalV6TERBc01TNHpOemcwTWl3eExqRXlNVEE1TERJdU5Td3lMalVzTWk0MUxqVXdPRGM1TERBc0xqazRNVFExTFM0eE5UUTBPQ3d4TGpNM05qUTJMUzQwTVRZME5HdzBMalF4TmpVc05DNDBNVFkwTkdndE1TNDNPVEk1TjNZeFdpSWdZMnhoYzNNOUltTnNjeTB5SWk4JTJCSmlONFlUc2dJRHd2Wno0bUkzaGhPend2YzNablBnJTNEJTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjI1OSUyMiUyMHklM0QlMjI1NzMlMjIlMjB3aWR0aCUzRCUyMjQyJTIyJTIwaGVpZ2h0JTNEJTIyNDIlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tNTElMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyc2hhcGUlM0RpbWFnZSUzQnZlcnRpY2FsTGFiZWxQb3NpdGlvbiUzRGJvdHRvbSUzQnZlcnRpY2FsQWxpZ24lM0R0b3AlM0JpbWFnZUFzcGVjdCUzRDAlM0Jhc3BlY3QlM0RmaXhlZCUzQmltYWdlJTNEZGF0YSUzQWltYWdlJTJGc3ZnJTJCeG1sJTJDUEhOMlp5QjRiV3h1Y3owaWFIUjBjRG92TDNkM2R5NTNNeTV2Y21jdk1qQXdNQzl6ZG1jaUlIWnBaWGRDYjNnOUlqQWdNQ0EwT0NBME9DSSUyQkppTjRZVHNnSUR4a1pXWnpQaVlqZUdFN0lDQWdJRHh6ZEhsc1pUNG1JM2hoT3lBZ0lDQWdJQzVqYkhNdE1TQjdKaU40WVRzZ0lDQWdJQ0FnSUdacGJHdzZJQ015TWprd1l6YzdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc21JM2hoT3lBZ0lDQWdJQzVqYkhNdE1Td2dMbU5zY3kweUlIc21JM2hoT3lBZ0lDQWdJQ0FnYzNSeWIydGxMWGRwWkhSb09pQXdjSGc3SmlONFlUc2dJQ0FnSUNCOUppTjRZVHNtSTNoaE95QWdJQ0FnSUM1amJITXRNaUI3SmlONFlUc2dJQ0FnSUNBZ0lHWnBiR3c2SUNObVptWTdKaU40WVRzZ0lDQWdJQ0I5SmlONFlUc2dJQ0FnUEM5emRIbHNaVDRtSTNoaE95QWdQQzlrWldaelBpWWplR0U3SUNBOFp5QnBaRDBpUTJseVkyeGxJajRtSTNoaE95QWdJQ0E4WTJseVkyeGxJSEk5SWpJMElpQmplVDBpTWpRaUlHTjRQU0l5TkNJZ1kyeGhjM005SW1Oc2N5MHhJaTglMkJKaU40WVRzZ0lEd3ZaejRtSTNoaE95QWdQR2NnYVdROUlrUnlZWGRwYm1jaVBpWWplR0U3SUNBZ0lEeHdiMng1WjI5dUlIQnZhVzUwY3owaU16RWdNalVnTVRjZ01qVWdNVE1nTkRBZ016VWdOREFnTXpFZ01qVWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBZ0lEeGphWEpqYkdVZ2NqMGlOeUlnWTNrOUlqRTFJaUJqZUQwaU1qUWlJR05zWVhOelBTSmpiSE10TWlJdlBpWWplR0U3SUNBOEwyYyUyQkppTjRZVHM4TDNOMlp6NCUzRCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI5NS41JTIyJTIweSUzRCUyMjU3MCUyMiUyMHdpZHRoJTNEJTIyNDglMjIlMjBoZWlnaHQlM0QlMjI0OCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti01MiUyMiUyMHZhbHVlJTNEJTIyJTI2bHQlM0Jmb250JTIwZmFjZSUzRCUyNnF1b3QlM0JOVklESUFTYW5zLVJlZ3VsYXIlMjZxdW90JTNCJTI2Z3QlM0JVc2VyJTI2bHQlM0IlMkZmb250JTI2Z3QlM0IlMjIlMjBzdHlsZSUzRCUyMnRleHQlM0JzdHJva2VDb2xvciUzRG5vbmUlM0JhbGlnbiUzRGNlbnRlciUzQmZpbGxDb2xvciUzRG5vbmUlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCcm91bmRlZCUzRDAlM0JodG1sJTNEMSUzQnNwYWNpbmclM0QwJTNCdGV4dERpcmVjdGlvbiUzRGx0ciUzQmxhYmVsUG9zaXRpb24lM0RjZW50ZXIlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0RtaWRkbGUlM0J3aGl0ZVNwYWNlJTNEd3JhcCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmRpcmVjdGlvbiUzRHNvdXRoJTNCZm9udFNpemUlM0QxMiUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjc5JTIyJTIweSUzRCUyMjYxNyUyMiUyMHdpZHRoJTNEJTIyODElMjIlMjBoZWlnaHQlM0QlMjIzOCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJIemtqa2tsMHBFblM3YVQ0THgyZC0xJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTFOQzR3TURjNU15SWdhV1E5SWs1SlRWTWlQaVlqZUdFN0lDQThaR1ZtY3o0bUkzaGhPeUFnSUNBOGMzUjViR1UlMkJKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxURWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqTnpaaU9UQXdPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdJQ0FnSUR3dmMzUjViR1UlMkJKaU40WVRzZ0lEd3ZaR1ZtY3o0bUkzaGhPeUFnUEdjJTJCSmlONFlUc2dJQ0FnUEhCaGRHZ2daRDBpVFRJeExqQXdNRGs0TERCTU1Dd3hNaTR3TURJNU1uWXlOQzR3TVRRNE1Xd3lNUzR3TURBNU9Dd3hNaTR3TURVNU1Td3lNQzQ1T1Rrd01pMHhNaTR3TURVNU1WWXhNaTR3TURJNU1rd3lNUzR3TURBNU9Dd3dXazAwTVN3ek5TNDBNemN4T1d3dE1Ua3VOU3d4TVM0eE5EZzRObll0Tmk0eE16azBOR2d0TVhZMkxqRXpPRE0wVERFc016VXVORE0zTVRKV01UTXVNamN4TTJ3MUxqRTBNREUwTERNdU5ETXpPVFF1TlRRNU9DMHVPRFF3TXpndE5TNHlOekkzTVMwekxqVXhOamczVERJeExqQXdNRGs0TERFdU1UVXlNelpzTVRrdU5qTTFOelFzTVRFdU1UWXpNakl0TlM0ek1qWTNNaXd6TGpZd01EYzBMalUwT1RrNUxqZ3lPRFl5TERVdU1UUXdNREV0TXk0ME1qTXhOM1l5TWk0eE1UVTBNbG9pSUdOc1lYTnpQU0pqYkhNdE1TSXZQaVlqZUdFN0lDQWdJRHh3YjJ4NVoyOXVJSEJ2YVc1MGN6MGlNakVnTlRRdU1EQTNPVE1nTkRJZ05ESXVNREEzT1RNZ05ESWdNemd1TURBM09UTWdNakVnTlRBdU1EQTNPVE1nTUNBek9DNHdNRGM1TXlBd0lEUXlMakF3TnpreklESXhJRFUwTGpBd056a3pJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BDOW5QaVlqZUdFN0lDQThjR0YwYUNCa1BTSk5NekF1TXpneE56TXNNall1T1RBd01ESmpMUzR5TWpBd015d3dMUzQwTXpBd05TNHdNems1T0MwdU5qTXVNVEE1T1Rsc0xURXVOemN3TURJdE1pNDNOams1Tm5ZdExqQXhNREF4YkRFdU56Y3dNREl0TWk0NU1qazVPV011TVRrNU9UVXVNRFl1TkRBNU9UY3VNRGs1T1RndU5qTXVNRGs1T1Rnc01TNHdPVGs1T0N3d0xESXRMamt3TURBeUxESXRNbk10TGprd01EQXlMVEl0TWkweVl5MHVOVGN3TURFc01DMHhMakE1TURBekxqSXpPVGs1TFRFdU5EVXdNREV1TmpOc0xUWXVNVEl0TXk0MU16QXdNMk11TURRNU9Ua3RMakUxT1RrM0xqQTNNREF4TFM0ek1qazVOaTR3TnpBd01TMHVOU3d3TFRFdU1EazVPVGd0TGprd01EQXlMVEl0TWkweUxURXVNVEF3TURRc01DMHlMQzQ1TURBd01pMHlMRElzTUN3dU1Ua3VNREk1T1RjdU16Z3VNRGM1T1RZdU5UVXdNRFZzTFRZdU1ESTVPVGNzTXk0ME56azVPR010TGpNMU9UazVMUzR6T1RBd01TMHVPRGd0TGpZekxURXVORFV3TURFdExqWXpMVEV1TURrNU9UZ3NNQzB5TEM0NU1EQXdNaTB5TERKekxqa3dNREF5TERJc01pd3lZeTR4TmprNU9Dd3dMQzR6TkRBd015MHVNREl3TURJdU5EZzVPVGt0TGpBMmJERXVPREl3TURFc015NHdNVEF3TVMweExqWTNPVGs1TERJdU5qUTVPVFpqTFM0eU1EQXdNUzB1TURZdExqUXhNREF6TFM0d09UazVPQzB1TmpNdExqQTVPVGs0TFRFdU1EazVPVGdzTUMweUxDNDVNREF3TWkweUxESnpMamt3TURBeUxESXNNaXd5WXk0MU1qQXdNaXd3TERFdExqSXdNREF4TERFdU16UTVPVGd0TGpVek1EQXpiRFl1TVRNc015NDVPREF3TkdNdExqQTBPVGs1TGpFMk9UazRMUzR3TnprNU5pNHpOVGs1T1MwdU1EYzVPVFl1TlRRNU9Ua3NNQ3d4TGpBNU9UazRMamc1T1RrMkxESXNNaXd5TERFdU1EazVPVGdzTUN3eUxTNDVNREF3TWl3eUxUSXNNQzB1TWpFNU9UY3RMakEwTURBMExTNDBNams1T1MwdU1URXdNRFV0TGpZemJEWXVNVEl0TkM0d05EazVPV011TXpZd01EVXVOREU1T1RndU9UQXdNREl1TmpjNU9Ua3NNUzQwT1RBd05TNDJOems1T1N3eExqQTVPVGs0TERBc01pMHVPVEF3TURJc01pMHljeTB1T1RBd01ESXRNaTB5TFRKYVRURTVMalEzTVRZNUxERTFMalF4TURBemJDMHpMalU0TURBeUxEVXVOalF3TURFdE1pNDBORGs1TlMweExqSXpNREEwWXk0d01UazVOaTB1TVRNdU1ETTVPVGd0TGpJM09UazNMakF6T1RrNExTNDBNVGs1T0N3d0xTNHhOams1T0MwdU1ESXdNREl0TGpNME1EQXpMUzR3TnpBd01TMHVOV3cyTGpBMkxUTXVORGc1T1RsYVRURTRMamt3TVRZNUxESTBMak0yTURBMVl5NHdNVEF3TVM0d09EazVOeTR3TWpBd01pNHhOams1T0M0d05EazVPUzR5Tld3dE1pNDVNems1TkN3eExqUTJPVGszTFRFdU1EUXdNRFF0TVM0M01UazVOeXd4TGpJNE1EQXpMVEl1TURJd01ESXNNaTQyTmprNU9Dd3hMak0wTURBell5MHVNREl3TURJdU1USTVPVFF0TGpBek9UazRMakkzT1RrM0xTNHdNems1T0M0ME1UazVPQ3d3TEM0d09EazVOeTR3TURrNU5TNHhOems1T1M0d01UazVOaTR5TmpBd01WcE5NVEl1T0RVeE55d3lNQzQ0TlRBd05HTXVNRFE1T1RrdExqQTBNREEwTGpBNU1EQXpMUzR3T1RBd015NHhNeTB1TVRRd01ERnNNaTR6T0N3eExqRTNPVGs1TFM0NU5qQXdNaXd4TGpVeE1EQXhMVEV1TlRRNU9Ua3RNaTQxTkRrNU9WcE5NVEl1T0RreE5qZ3NNamN1TmpRd01ERnNMakEyTFM0d09EazVOeXd4TGpReU1EQTBMVEl1TWpRd01EVXVOek01T1Rrc01TNHlNakF3TXkweUxqRXpMREV1TURZdExqQTVNREF6TGpBME9UazVXazB4TXk0ek56RTNNaXd5T1M0MU16QXdNMk11TURjd01ERXRMakl3TURBeExqRXdPVGs1TFM0ME1UQXdNeTR4TURrNU9TMHVOak1zTUMwdU1UUXdNREV0TGpBeU1EQXlMUzR5T0RrNU9DMHVNRE01T1RndExqUXhPVGs0YkRJdU1UYzVPVGt0TVM0d09UQXdNeXd6TGpVM09UazJMRFV1T1RFNU9UZ3ROUzQ0TWprNU5pMHpMamMzT1RrM1drMHlNQzR6T0RFM015d3pNaTQ1TnpBd00yTXRMakEyTGpBeE1EQXhMUzR4TWk0d01qazVOeTB1TVRnd01EVXVNRFE1T1Rsc0xUTXVOalk1T1RndE5pNHdPRGs1Tnl3eUxqa3hNREF6TFRFdU5EVXdNREZqTGpJMUxqSTJPVGsyTGpVM01EQXhMalExT1RrMkxqazBMalUwT1RrNWRqWXVPVFJhVFRJd0xqTTRNVGN6TERJeUxqRTNNREEwWXkwdU5EQXdNREl1TURrNU9UZ3RMamMxTGpNeU1EQXhMVEVzTGpZeWJDMHlMalU1TURBekxURXVNamt3TURRc015NDFNems1T0MwMUxqVTNPVGsyWXk0d01UQXdNUzR3TVRBd01TNHdNekF3TXk0d01UQXdNUzR3TlRBd05TNHdNVEF3TVhZMkxqSXpPVGs1V2sweU55NHpOekUzTWl3eU15NHlPVEF3Tkd3dExqZzFNREEwTFRFdU16TXdNRElzTWk0ek9UQXdNUzB4TGpJeE9UazNMVEV1TlRNNU9UZ3NNaTQxTkRrNU9WcE5Nakl1T0RZeE56RXNNak11T0RJd01ERnNNaTQzTmpBd01TMHhMalF3T1RrM0xERXVNVGM1T1Rrc01TNDRNekF3TW5ZdU1EQTVPVFZzTFRFdU1EY3dNREVzTVM0M056QXdNaTB5TGprd09UazNMVEV1TkRZd01ESmpMakF6T1RrNExTNHhORGs1Tmk0d05pMHVNams1T1RrdU1EWXRMalExT1RrMkxEQXRMakV3TURBMExTNHdNVEF3TVMwdU1Ua3RMakF5TURBeUxTNHlPREF3TTFwTk1qSXVNek14Tmpnc01UVXVNemRzTmk0eE1pd3pMalV6TURBell5MHVNRFE1T1RrdU1UVTVPVGN0TGpBMk9UazFMak16TURBeUxTNHdOams1TlM0MUxEQXNMakUxT1RrM0xqQXhPVGsyTGpNeExqQTJMalEyTURBeWJDMHlMalEyTURBeUxERXVNalZvTFM0d01UQXdNV3d0TXk0Mk5UazVOeTAxTGpjeU1EQXpjUzR3TVRBd01TMHVNREV3TURFdU1ERTVPVFl0TGpBeU1EQXlXazB5TVM0ek9ERTNNeXd4TlM0NU16QXdOV011TURJNU9UY3NNQ3d1TURZdExqQXhNREF4TGpBM09UazJMUzR3TWpBd01td3pMall5TERVdU5qVTVPVGN0TWk0Mk1EazVPU3d4TGpNek1EQXlZeTB1TWpZd01ERXRMak0xT1RrNUxTNDJOREF3TVMwdU5qSXRNUzR3T0RrNU55MHVOekk1T1RoMkxUWXVNak01T1RsYVRUSXhMalV4TVRjekxETXpZeTB1TURRd01EUXRMakF3T1RrMUxTNHdPREF3TWkwdU1ESTVPVGN0TGpFekxTNHdNams1TjNZdE5pNDVOR011TXpndExqQTVNREF6TGpjeE9UazNMUzR5T1RrNU9TNDVOams1TnkwdU5Ua3dNRE5zTWk0NE5UazVPU3d4TGpReU9UazVMVE11TmprNU9UVXNOaTR4TTFwTk1qSXVOVFV4TnpFc016TXVNakl3TUROc015NDFOaTAxTGprd01EQXlMREl1TXpFc01TNHhOakF3TTJNdExqQXlNREF5TGpFekxTNHdNems1T0M0eU56azVOeTB1TURNNU9UZ3VOREU1T1Rnc01Dd3VNVFV3TURJdU1ERTVPVFl1TWprNU9Ua3VNRFE1T1RrdU5EUnNMVFV1T0Rnc015NDRPRnBOTWpndU9EY3hOeklzTWpjdU5Ua3dNRE5zTFRJdU1qTTVPVGt0TVM0eE1pNDNOams1TmkweExqSTRNREF6TERFdU5URXdNREVzTWk0ek5qQXdOV010TGpBeE1EQXhMakF3T1RrMUxTNHdNakF3TWk0d01qazVOeTB1TURNNU9UZ3VNRE01T1RoYUlpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPend2YzNablBnJTNEJTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjUyOS4zOSUyMiUyMHklM0QlMjIxNTIuNSUyMiUyMHdpZHRoJTNEJTIyNDEuMjElMjIlMjBoZWlnaHQlM0QlMjI1MyUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRm14Q2VsbCUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhDZWxsJTIwaWQlM0QlMjJIemtqa2tsMHBFblM3YVQ0THgyZC0zJTIyJTIwdmFsdWUlM0QlMjIlMjIlMjBzdHlsZSUzRCUyMnNoYXBlJTNEaW1hZ2UlM0J2ZXJ0aWNhbExhYmVsUG9zaXRpb24lM0Rib3R0b20lM0JsYWJlbEJhY2tncm91bmRDb2xvciUzRGRlZmF1bHQlM0J2ZXJ0aWNhbEFsaWduJTNEdG9wJTNCYXNwZWN0JTNEZml4ZWQlM0JpbWFnZUFzcGVjdCUzRDAlM0JpbWFnZSUzRGRhdGElM0FpbWFnZSUyRnN2ZyUyQnhtbCUyQ1BITjJaeUI0Yld4dWN6MGlhSFIwY0RvdkwzZDNkeTUzTXk1dmNtY3ZNakF3TUM5emRtY2lJSFpwWlhkQ2IzZzlJakFnTUNBME1pQTFOQzR3TURjNU15SWdhV1E5SWs1SlRWTWlQaVlqZUdFN0lDQThaR1ZtY3o0bUkzaGhPeUFnSUNBOGMzUjViR1UlMkJKaU40WVRzZ0lDQWdJQ0F1WTJ4ekxURWdleVlqZUdFN0lDQWdJQ0FnSUNCbWFXeHNPaUFqTnpaaU9UQXdPeVlqZUdFN0lDQWdJQ0FnZlNZamVHRTdJQ0FnSUR3dmMzUjViR1UlMkJKaU40WVRzZ0lEd3ZaR1ZtY3o0bUkzaGhPeUFnUEdjJTJCSmlONFlUc2dJQ0FnUEhCaGRHZ2daRDBpVFRJeExqQXdNRGs0TERCTU1Dd3hNaTR3TURJNU1uWXlOQzR3TVRRNE1Xd3lNUzR3TURBNU9Dd3hNaTR3TURVNU1Td3lNQzQ1T1Rrd01pMHhNaTR3TURVNU1WWXhNaTR3TURJNU1rd3lNUzR3TURBNU9Dd3dXazAwTVN3ek5TNDBNemN4T1d3dE1Ua3VOU3d4TVM0eE5EZzRObll0Tmk0eE16azBOR2d0TVhZMkxqRXpPRE0wVERFc016VXVORE0zTVRKV01UTXVNamN4TTJ3MUxqRTBNREUwTERNdU5ETXpPVFF1TlRRNU9DMHVPRFF3TXpndE5TNHlOekkzTVMwekxqVXhOamczVERJeExqQXdNRGs0TERFdU1UVXlNelpzTVRrdU5qTTFOelFzTVRFdU1UWXpNakl0TlM0ek1qWTNNaXd6TGpZd01EYzBMalUwT1RrNUxqZ3lPRFl5TERVdU1UUXdNREV0TXk0ME1qTXhOM1l5TWk0eE1UVTBNbG9pSUdOc1lYTnpQU0pqYkhNdE1TSXZQaVlqZUdFN0lDQWdJRHh3YjJ4NVoyOXVJSEJ2YVc1MGN6MGlNakVnTlRRdU1EQTNPVE1nTkRJZ05ESXVNREEzT1RNZ05ESWdNemd1TURBM09UTWdNakVnTlRBdU1EQTNPVE1nTUNBek9DNHdNRGM1TXlBd0lEUXlMakF3TnpreklESXhJRFUwTGpBd056a3pJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3lBZ1BDOW5QaVlqZUdFN0lDQThjR0YwYUNCa1BTSk5NekF1TXpneE56TXNNall1T1RBd01ESmpMUzR5TWpBd015d3dMUzQwTXpBd05TNHdNems1T0MwdU5qTXVNVEE1T1Rsc0xURXVOemN3TURJdE1pNDNOams1Tm5ZdExqQXhNREF4YkRFdU56Y3dNREl0TWk0NU1qazVPV011TVRrNU9UVXVNRFl1TkRBNU9UY3VNRGs1T1RndU5qTXVNRGs1T1Rnc01TNHdPVGs1T0N3d0xESXRMamt3TURBeUxESXRNbk10TGprd01EQXlMVEl0TWkweVl5MHVOVGN3TURFc01DMHhMakE1TURBekxqSXpPVGs1TFRFdU5EVXdNREV1TmpOc0xUWXVNVEl0TXk0MU16QXdNMk11TURRNU9Ua3RMakUxT1RrM0xqQTNNREF4TFM0ek1qazVOaTR3TnpBd01TMHVOU3d3TFRFdU1EazVPVGd0TGprd01EQXlMVEl0TWkweUxURXVNVEF3TURRc01DMHlMQzQ1TURBd01pMHlMRElzTUN3dU1Ua3VNREk1T1RjdU16Z3VNRGM1T1RZdU5UVXdNRFZzTFRZdU1ESTVPVGNzTXk0ME56azVPR010TGpNMU9UazVMUzR6T1RBd01TMHVPRGd0TGpZekxURXVORFV3TURFdExqWXpMVEV1TURrNU9UZ3NNQzB5TEM0NU1EQXdNaTB5TERKekxqa3dNREF5TERJc01pd3lZeTR4TmprNU9Dd3dMQzR6TkRBd015MHVNREl3TURJdU5EZzVPVGt0TGpBMmJERXVPREl3TURFc015NHdNVEF3TVMweExqWTNPVGs1TERJdU5qUTVPVFpqTFM0eU1EQXdNUzB1TURZdExqUXhNREF6TFM0d09UazVPQzB1TmpNdExqQTVPVGs0TFRFdU1EazVPVGdzTUMweUxDNDVNREF3TWkweUxESnpMamt3TURBeUxESXNNaXd5WXk0MU1qQXdNaXd3TERFdExqSXdNREF4TERFdU16UTVPVGd0TGpVek1EQXpiRFl1TVRNc015NDVPREF3TkdNdExqQTBPVGs1TGpFMk9UazRMUzR3TnprNU5pNHpOVGs1T1MwdU1EYzVPVFl1TlRRNU9Ua3NNQ3d4TGpBNU9UazRMamc1T1RrMkxESXNNaXd5TERFdU1EazVPVGdzTUN3eUxTNDVNREF3TWl3eUxUSXNNQzB1TWpFNU9UY3RMakEwTURBMExTNDBNams1T1MwdU1URXdNRFV0TGpZemJEWXVNVEl0TkM0d05EazVPV011TXpZd01EVXVOREU1T1RndU9UQXdNREl1TmpjNU9Ua3NNUzQwT1RBd05TNDJOems1T1N3eExqQTVPVGs0TERBc01pMHVPVEF3TURJc01pMHljeTB1T1RBd01ESXRNaTB5TFRKYVRURTVMalEzTVRZNUxERTFMalF4TURBemJDMHpMalU0TURBeUxEVXVOalF3TURFdE1pNDBORGs1TlMweExqSXpNREEwWXk0d01UazVOaTB1TVRNdU1ETTVPVGd0TGpJM09UazNMakF6T1RrNExTNDBNVGs1T0N3d0xTNHhOams1T0MwdU1ESXdNREl0TGpNME1EQXpMUzR3TnpBd01TMHVOV3cyTGpBMkxUTXVORGc1T1RsYVRURTRMamt3TVRZNUxESTBMak0yTURBMVl5NHdNVEF3TVM0d09EazVOeTR3TWpBd01pNHhOams1T0M0d05EazVPUzR5Tld3dE1pNDVNems1TkN3eExqUTJPVGszTFRFdU1EUXdNRFF0TVM0M01UazVOeXd4TGpJNE1EQXpMVEl1TURJd01ESXNNaTQyTmprNU9Dd3hMak0wTURBell5MHVNREl3TURJdU1USTVPVFF0TGpBek9UazRMakkzT1RrM0xTNHdNems1T0M0ME1UazVPQ3d3TEM0d09EazVOeTR3TURrNU5TNHhOems1T1M0d01UazVOaTR5TmpBd01WcE5NVEl1T0RVeE55d3lNQzQ0TlRBd05HTXVNRFE1T1RrdExqQTBNREEwTGpBNU1EQXpMUzR3T1RBd015NHhNeTB1TVRRd01ERnNNaTR6T0N3eExqRTNPVGs1TFM0NU5qQXdNaXd4TGpVeE1EQXhMVEV1TlRRNU9Ua3RNaTQxTkRrNU9WcE5NVEl1T0RreE5qZ3NNamN1TmpRd01ERnNMakEyTFM0d09EazVOeXd4TGpReU1EQTBMVEl1TWpRd01EVXVOek01T1Rrc01TNHlNakF3TXkweUxqRXpMREV1TURZdExqQTVNREF6TGpBME9UazVXazB4TXk0ek56RTNNaXd5T1M0MU16QXdNMk11TURjd01ERXRMakl3TURBeExqRXdPVGs1TFM0ME1UQXdNeTR4TURrNU9TMHVOak1zTUMwdU1UUXdNREV0TGpBeU1EQXlMUzR5T0RrNU9DMHVNRE01T1RndExqUXhPVGs0YkRJdU1UYzVPVGt0TVM0d09UQXdNeXd6TGpVM09UazJMRFV1T1RFNU9UZ3ROUzQ0TWprNU5pMHpMamMzT1RrM1drMHlNQzR6T0RFM015d3pNaTQ1TnpBd00yTXRMakEyTGpBeE1EQXhMUzR4TWk0d01qazVOeTB1TVRnd01EVXVNRFE1T1Rsc0xUTXVOalk1T1RndE5pNHdPRGs1Tnl3eUxqa3hNREF6TFRFdU5EVXdNREZqTGpJMUxqSTJPVGsyTGpVM01EQXhMalExT1RrMkxqazBMalUwT1RrNWRqWXVPVFJhVFRJd0xqTTRNVGN6TERJeUxqRTNNREEwWXkwdU5EQXdNREl1TURrNU9UZ3RMamMxTGpNeU1EQXhMVEVzTGpZeWJDMHlMalU1TURBekxURXVNamt3TURRc015NDFNems1T0MwMUxqVTNPVGsyWXk0d01UQXdNUzR3TVRBd01TNHdNekF3TXk0d01UQXdNUzR3TlRBd05TNHdNVEF3TVhZMkxqSXpPVGs1V2sweU55NHpOekUzTWl3eU15NHlPVEF3Tkd3dExqZzFNREEwTFRFdU16TXdNRElzTWk0ek9UQXdNUzB4TGpJeE9UazNMVEV1TlRNNU9UZ3NNaTQxTkRrNU9WcE5Nakl1T0RZeE56RXNNak11T0RJd01ERnNNaTQzTmpBd01TMHhMalF3T1RrM0xERXVNVGM1T1Rrc01TNDRNekF3TW5ZdU1EQTVPVFZzTFRFdU1EY3dNREVzTVM0M056QXdNaTB5TGprd09UazNMVEV1TkRZd01ESmpMakF6T1RrNExTNHhORGs1Tmk0d05pMHVNams1T1RrdU1EWXRMalExT1RrMkxEQXRMakV3TURBMExTNHdNVEF3TVMwdU1Ua3RMakF5TURBeUxTNHlPREF3TTFwTk1qSXVNek14Tmpnc01UVXVNemRzTmk0eE1pd3pMalV6TURBell5MHVNRFE1T1RrdU1UVTVPVGN0TGpBMk9UazFMak16TURBeUxTNHdOams1TlM0MUxEQXNMakUxT1RrM0xqQXhPVGsyTGpNeExqQTJMalEyTURBeWJDMHlMalEyTURBeUxERXVNalZvTFM0d01UQXdNV3d0TXk0Mk5UazVOeTAxTGpjeU1EQXpjUzR3TVRBd01TMHVNREV3TURFdU1ERTVPVFl0TGpBeU1EQXlXazB5TVM0ek9ERTNNeXd4TlM0NU16QXdOV011TURJNU9UY3NNQ3d1TURZdExqQXhNREF4TGpBM09UazJMUzR3TWpBd01td3pMall5TERVdU5qVTVPVGN0TWk0Mk1EazVPU3d4TGpNek1EQXlZeTB1TWpZd01ERXRMak0xT1RrNUxTNDJOREF3TVMwdU5qSXRNUzR3T0RrNU55MHVOekk1T1RoMkxUWXVNak01T1RsYVRUSXhMalV4TVRjekxETXpZeTB1TURRd01EUXRMakF3T1RrMUxTNHdPREF3TWkwdU1ESTVPVGN0TGpFekxTNHdNams1TjNZdE5pNDVOR011TXpndExqQTVNREF6TGpjeE9UazNMUzR5T1RrNU9TNDVOams1TnkwdU5Ua3dNRE5zTWk0NE5UazVPU3d4TGpReU9UazVMVE11TmprNU9UVXNOaTR4TTFwTk1qSXVOVFV4TnpFc016TXVNakl3TUROc015NDFOaTAxTGprd01EQXlMREl1TXpFc01TNHhOakF3TTJNdExqQXlNREF5TGpFekxTNHdNems1T0M0eU56azVOeTB1TURNNU9UZ3VOREU1T1Rnc01Dd3VNVFV3TURJdU1ERTVPVFl1TWprNU9Ua3VNRFE1T1RrdU5EUnNMVFV1T0Rnc015NDRPRnBOTWpndU9EY3hOeklzTWpjdU5Ua3dNRE5zTFRJdU1qTTVPVGt0TVM0eE1pNDNOams1TmkweExqSTRNREF6TERFdU5URXdNREVzTWk0ek5qQXdOV010TGpBeE1EQXhMakF3T1RrMUxTNHdNakF3TWk0d01qazVOeTB1TURNNU9UZ3VNRE01T1RoYUlpQmpiR0Z6Y3owaVkyeHpMVEVpTHo0bUkzaGhPend2YzNablBnJTNEJTNEJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBSZWd1bGFyJTNCZm9udFNpemUlM0QxMiUzQiUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlMjB2ZXJ0ZXglM0QlMjIxJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteEdlb21ldHJ5JTIweCUzRCUyMjQ1Ny44OTAwMDAwMDAwMDAwNCUyMiUyMHklM0QlMjI1NjQlMjIlMjB3aWR0aCUzRCUyMjQxLjIxJTIyJTIwaGVpZ2h0JTNEJTIyNTMlMjIlMjBhcyUzRCUyMmdlb21ldHJ5JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIySHpramtrbDBwRW5TN2FUNEx4MmQtNCUyMiUyMHZhbHVlJTNEJTIyJTIyJTIwc3R5bGUlM0QlMjJzaGFwZSUzRGltYWdlJTNCdmVydGljYWxMYWJlbFBvc2l0aW9uJTNEYm90dG9tJTNCbGFiZWxCYWNrZ3JvdW5kQ29sb3IlM0RkZWZhdWx0JTNCdmVydGljYWxBbGlnbiUzRHRvcCUzQmFzcGVjdCUzRGZpeGVkJTNCaW1hZ2VBc3BlY3QlM0QwJTNCaW1hZ2UlM0RkYXRhJTNBaW1hZ2UlMkZzdmclMkJ4bWwlMkNQSE4yWnlCNGJXeHVjejBpYUhSMGNEb3ZMM2QzZHk1M015NXZjbWN2TWpBd01DOXpkbWNpSUhacFpYZENiM2c5SWpBZ01DQTBNaUExTkM0d01EYzVNeUlnYVdROUlrNUpUVk1pUGlZamVHRTdJQ0E4WkdWbWN6NG1JM2hoT3lBZ0lDQThjM1I1YkdVJTJCSmlONFlUc2dJQ0FnSUNBdVkyeHpMVEVnZXlZamVHRTdJQ0FnSUNBZ0lDQm1hV3hzT2lBak56WmlPVEF3T3lZamVHRTdJQ0FnSUNBZ2ZTWWplR0U3SUNBZ0lEd3ZjM1I1YkdVJTJCSmlONFlUc2dJRHd2WkdWbWN6NG1JM2hoT3lBZ1BHYyUyQkppTjRZVHNnSUNBZ1BIQmhkR2dnWkQwaVRUSXhMakF3TURrNExEQk1NQ3d4TWk0d01ESTVNbll5TkM0d01UUTRNV3d5TVM0d01EQTVPQ3d4TWk0d01EVTVNU3d5TUM0NU9Ua3dNaTB4TWk0d01EVTVNVll4TWk0d01ESTVNa3d5TVM0d01EQTVPQ3d3V2swME1Td3pOUzQwTXpjeE9Xd3RNVGt1TlN3eE1TNHhORGc0Tm5ZdE5pNHhNemswTkdndE1YWTJMakV6T0RNMFRERXNNelV1TkRNM01USldNVE11TWpjeE0ydzFMakUwTURFMExETXVORE16T1RRdU5UUTVPQzB1T0RRd016Z3ROUzR5TnpJM01TMHpMalV4TmpnM1RESXhMakF3TURrNExERXVNVFV5TXpac01Ua3VOak0xTnpRc01URXVNVFl6TWpJdE5TNHpNalkzTWl3ekxqWXdNRGMwTGpVME9UazVMamd5T0RZeUxEVXVNVFF3TURFdE15NDBNak14TjNZeU1pNHhNVFUwTWxvaUlHTnNZWE56UFNKamJITXRNU0l2UGlZamVHRTdJQ0FnSUR4d2IyeDVaMjl1SUhCdmFXNTBjejBpTWpFZ05UUXVNREEzT1RNZ05ESWdOREl1TURBM09UTWdORElnTXpndU1EQTNPVE1nTWpFZ05UQXVNREEzT1RNZ01DQXpPQzR3TURjNU15QXdJRFF5TGpBd056a3pJREl4SURVMExqQXdOemt6SWlCamJHRnpjejBpWTJ4ekxURWlMejRtSTNoaE95QWdQQzluUGlZamVHRTdJQ0E4Y0dGMGFDQmtQU0pOTXpBdU16Z3hOek1zTWpZdU9UQXdNREpqTFM0eU1qQXdNeXd3TFM0ME16QXdOUzR3TXprNU9DMHVOak11TVRBNU9UbHNMVEV1Tnpjd01ESXRNaTQzTmprNU5uWXRMakF4TURBeGJERXVOemN3TURJdE1pNDVNams1T1dNdU1UazVPVFV1TURZdU5EQTVPVGN1TURrNU9UZ3VOak11TURrNU9UZ3NNUzR3T1RrNU9Dd3dMREl0TGprd01EQXlMREl0TW5NdExqa3dNREF5TFRJdE1pMHlZeTB1TlRjd01ERXNNQzB4TGpBNU1EQXpMakl6T1RrNUxURXVORFV3TURFdU5qTnNMVFl1TVRJdE15NDFNekF3TTJNdU1EUTVPVGt0TGpFMU9UazNMakEzTURBeExTNHpNams1Tmk0d056QXdNUzB1TlN3d0xURXVNRGs1T1RndExqa3dNREF5TFRJdE1pMHlMVEV1TVRBd01EUXNNQzB5TEM0NU1EQXdNaTB5TERJc01Dd3VNVGt1TURJNU9UY3VNemd1TURjNU9UWXVOVFV3TURWc0xUWXVNREk1T1Rjc015NDBOems1T0dNdExqTTFPVGs1TFM0ek9UQXdNUzB1T0RndExqWXpMVEV1TkRVd01ERXRMall6TFRFdU1EazVPVGdzTUMweUxDNDVNREF3TWkweUxESnpMamt3TURBeUxESXNNaXd5WXk0eE5qazVPQ3d3TEM0ek5EQXdNeTB1TURJd01ESXVORGc1T1RrdExqQTJiREV1T0RJd01ERXNNeTR3TVRBd01TMHhMalkzT1RrNUxESXVOalE1T1RaakxTNHlNREF3TVMwdU1EWXRMalF4TURBekxTNHdPVGs1T0MwdU5qTXRMakE1T1RrNExURXVNRGs1T1Rnc01DMHlMQzQ1TURBd01pMHlMREp6TGprd01EQXlMRElzTWl3eVl5NDFNakF3TWl3d0xERXRMakl3TURBeExERXVNelE1T1RndExqVXpNREF6YkRZdU1UTXNNeTQ1T0RBd05HTXRMakEwT1RrNUxqRTJPVGs0TFM0d056azVOaTR6TlRrNU9TMHVNRGM1T1RZdU5UUTVPVGtzTUN3eExqQTVPVGs0TGpnNU9UazJMRElzTWl3eUxERXVNRGs1T1Rnc01Dd3lMUzQ1TURBd01pd3lMVElzTUMwdU1qRTVPVGN0TGpBME1EQTBMUzQwTWprNU9TMHVNVEV3TURVdExqWXpiRFl1TVRJdE5DNHdORGs1T1dNdU16WXdNRFV1TkRFNU9UZ3VPVEF3TURJdU5qYzVPVGtzTVM0ME9UQXdOUzQyTnprNU9Td3hMakE1T1RrNExEQXNNaTB1T1RBd01ESXNNaTB5Y3kwdU9UQXdNREl0TWkweUxUSmFUVEU1TGpRM01UWTVMREUxTGpReE1EQXpiQzB6TGpVNE1EQXlMRFV1TmpRd01ERXRNaTQwTkRrNU5TMHhMakl6TURBMFl5NHdNVGs1TmkwdU1UTXVNRE01T1RndExqSTNPVGszTGpBek9UazRMUzQwTVRrNU9Dd3dMUzR4TmprNU9DMHVNREl3TURJdExqTTBNREF6TFM0d056QXdNUzB1Tld3MkxqQTJMVE11TkRnNU9UbGFUVEU0TGprd01UWTVMREkwTGpNMk1EQTFZeTR3TVRBd01TNHdPRGs1Tnk0d01qQXdNaTR4TmprNU9DNHdORGs1T1M0eU5Xd3RNaTQ1TXprNU5Dd3hMalEyT1RrM0xURXVNRFF3TURRdE1TNDNNVGs1Tnl3eExqSTRNREF6TFRJdU1ESXdNRElzTWk0Mk5qazVPQ3d4TGpNME1EQXpZeTB1TURJd01ESXVNVEk1T1RRdExqQXpPVGs0TGpJM09UazNMUzR3TXprNU9DNDBNVGs1T0N3d0xDNHdPRGs1Tnk0d01EazVOUzR4TnprNU9TNHdNVGs1Tmk0eU5qQXdNVnBOTVRJdU9EVXhOeXd5TUM0NE5UQXdOR011TURRNU9Ua3RMakEwTURBMExqQTVNREF6TFM0d09UQXdNeTR4TXkwdU1UUXdNREZzTWk0ek9Dd3hMakUzT1RrNUxTNDVOakF3TWl3eExqVXhNREF4TFRFdU5UUTVPVGt0TWk0MU5EazVPVnBOTVRJdU9Ea3hOamdzTWpjdU5qUXdNREZzTGpBMkxTNHdPRGs1Tnl3eExqUXlNREEwTFRJdU1qUXdNRFV1TnpNNU9Ua3NNUzR5TWpBd015MHlMakV6TERFdU1EWXRMakE1TURBekxqQTBPVGs1V2sweE15NHpOekUzTWl3eU9TNDFNekF3TTJNdU1EY3dNREV0TGpJd01EQXhMakV3T1RrNUxTNDBNVEF3TXk0eE1EazVPUzB1TmpNc01DMHVNVFF3TURFdExqQXlNREF5TFM0eU9EazVPQzB1TURNNU9UZ3RMalF4T1RrNGJESXVNVGM1T1RrdE1TNHdPVEF3TXl3ekxqVTNPVGsyTERVdU9URTVPVGd0TlM0NE1qazVOaTB6TGpjM09UazNXazB5TUM0ek9ERTNNeXd6TWk0NU56QXdNMk10TGpBMkxqQXhNREF4TFM0eE1pNHdNams1TnkwdU1UZ3dNRFV1TURRNU9UbHNMVE11TmpZNU9UZ3ROaTR3T0RrNU55d3lMamt4TURBekxURXVORFV3TURGakxqSTFMakkyT1RrMkxqVTNNREF4TGpRMU9UazJMamswTGpVME9UazVkall1T1RSYVRUSXdMak00TVRjekxESXlMakUzTURBMFl5MHVOREF3TURJdU1EazVPVGd0TGpjMUxqTXlNREF4TFRFc0xqWXliQzB5TGpVNU1EQXpMVEV1TWprd01EUXNNeTQxTXprNU9DMDFMalUzT1RrMll5NHdNVEF3TVM0d01UQXdNUzR3TXpBd015NHdNVEF3TVM0d05UQXdOUzR3TVRBd01YWTJMakl6T1RrNVdrMHlOeTR6TnpFM01pd3lNeTR5T1RBd05Hd3RMamcxTURBMExURXVNek13TURJc01pNHpPVEF3TVMweExqSXhPVGszTFRFdU5UTTVPVGdzTWk0MU5EazVPVnBOTWpJdU9EWXhOekVzTWpNdU9ESXdNREZzTWk0M05qQXdNUzB4TGpRd09UazNMREV1TVRjNU9Ua3NNUzQ0TXpBd01uWXVNREE1T1RWc0xURXVNRGN3TURFc01TNDNOekF3TWkweUxqa3dPVGszTFRFdU5EWXdNREpqTGpBek9UazRMUzR4TkRrNU5pNHdOaTB1TWprNU9Ua3VNRFl0TGpRMU9UazJMREF0TGpFd01EQTBMUzR3TVRBd01TMHVNVGt0TGpBeU1EQXlMUzR5T0RBd00xcE5Nakl1TXpNeE5qZ3NNVFV1TXpkc05pNHhNaXd6TGpVek1EQXpZeTB1TURRNU9Ua3VNVFU1T1RjdExqQTJPVGsxTGpNek1EQXlMUzR3TmprNU5TNDFMREFzTGpFMU9UazNMakF4T1RrMkxqTXhMakEyTGpRMk1EQXliQzB5TGpRMk1EQXlMREV1TWpWb0xTNHdNVEF3TVd3dE15NDJOVGs1TnkwMUxqY3lNREF6Y1M0d01UQXdNUzB1TURFd01ERXVNREU1T1RZdExqQXlNREF5V2sweU1TNHpPREUzTXl3eE5TNDVNekF3TldNdU1ESTVPVGNzTUN3dU1EWXRMakF4TURBeExqQTNPVGsyTFM0d01qQXdNbXd6TGpZeUxEVXVOalU1T1RjdE1pNDJNRGs1T1N3eExqTXpNREF5WXkwdU1qWXdNREV0TGpNMU9UazVMUzQyTkRBd01TMHVOakl0TVM0d09EazVOeTB1TnpJNU9UaDJMVFl1TWpNNU9UbGFUVEl4TGpVeE1UY3pMRE16WXkwdU1EUXdNRFF0TGpBd09UazFMUzR3T0RBd01pMHVNREk1T1RjdExqRXpMUzR3TWprNU4zWXROaTQ1TkdNdU16Z3RMakE1TURBekxqY3hPVGszTFM0eU9UazVPUzQ1TmprNU55MHVOVGt3TUROc01pNDROVGs1T1N3eExqUXlPVGs1TFRNdU5qazVPVFVzTmk0eE0xcE5Nakl1TlRVeE56RXNNek11TWpJd01ETnNNeTQxTmkwMUxqa3dNREF5TERJdU16RXNNUzR4TmpBd00yTXRMakF5TURBeUxqRXpMUzR3TXprNU9DNHlOems1TnkwdU1ETTVPVGd1TkRFNU9UZ3NNQ3d1TVRVd01ESXVNREU1T1RZdU1qazVPVGt1TURRNU9Ua3VORFJzTFRVdU9EZ3NNeTQ0T0ZwTk1qZ3VPRGN4TnpJc01qY3VOVGt3TUROc0xUSXVNak01T1RrdE1TNHhNaTQzTmprNU5pMHhMakk0TURBekxERXVOVEV3TURFc01pNHpOakF3TldNdExqQXhNREF4TGpBd09UazFMUzR3TWpBd01pNHdNams1TnkwdU1ETTVPVGd1TURNNU9UaGFJaUJqYkdGemN6MGlZMnh6TFRFaUx6NG1JM2hoT3p3dmMzWm5QZyUzRCUzRCUzQmZvbnRGYW1pbHklM0ROVklESUElMjBTYW5zJTIwUmVndWxhciUzQmZvbnRTaXplJTNEMTIlM0IlMjIlMjBwYXJlbnQlM0QlMjJuSnNrV2ZGN1hXTXNRQTRfREh3Ti0xJTIyJTIwdmVydGV4JTNEJTIyMSUyMiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDbXhHZW9tZXRyeSUyMHglM0QlMjI5NjYlMjIlMjB5JTNEJTIyNTcwJTIyJTIwd2lkdGglM0QlMjI0MS4yMSUyMiUyMGhlaWdodCUzRCUyMjUzJTIyJTIwYXMlM0QlMjJnZW9tZXRyeSUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteENlbGwlMjBpZCUzRCUyMkVMa2JFQThXVXBjSWo4N2VqWmc0LTElMjIlMjB2YWx1ZSUzRCUyMiUyMiUyMHN0eWxlJTNEJTIyZWRnZVN0eWxlJTNEb3J0aG9nb25hbEVkZ2VTdHlsZSUzQm9ydGhvZ29uYWxMb29wJTNEMSUzQmpldHR5U2l6ZSUzRGF1dG8lM0JodG1sJTNEMSUzQnJvdW5kZWQlM0QxJTNCZm9udFNpemUlM0QxMCUzQnN0YXJ0U2l6ZSUzRDQlM0JlbmRTaXplJTNENCUzQnN0YXJ0QXJyb3clM0RibG9jayUzQnN0YXJ0RmlsbCUzRDElM0JlbmRBcnJvdyUzRG5vbmUlM0JlbmRGaWxsJTNEMCUzQnN0cm9rZUNvbG9yJTNEJTIzRkZGRkZGJTNCZm9udEZhbWlseSUzRE5WSURJQSUyMFNhbnMlMjBNZWRpdW0lM0JmaWxsQ29sb3IlM0QlMjMwMDAwMDAlM0IlMjIlMjBlZGdlJTNEJTIyMSUyMiUyMHBhcmVudCUzRCUyMm5Kc2tXZkY3WFdNc1FBNF9ESHdOLTElMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB3aWR0aCUzRCUyMjE0MCUyMiUyMHJlbGF0aXZlJTNEJTIyMSUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyNTQwJTIyJTIweSUzRCUyMjY2MCUyMiUyMGFzJTNEJTIyc291cmNlUG9pbnQlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTMwOCUyMiUyMHklM0QlMjI2NDUlMjIlMjBhcyUzRCUyMnRhcmdldFBvaW50JTIyJTJGJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NBcnJheSUyMGFzJTNEJTIycG9pbnRzJTIyJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0NteFBvaW50JTIweCUzRCUyMjU0MCUyMiUyMHklM0QlMjI3NDIlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyMTMwOCUyMiUyMHklM0QlMjI3NDIlMjIlMkYlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQyUyRkFycmF5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteEdlb21ldHJ5JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZteENlbGwlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214Q2VsbCUyMGlkJTNEJTIyZzBOQzEya2xfNW9iNkJkazFQSi0tMCUyMiUyMHZhbHVlJTNEJTIyT3V0bGluZSUyQyUyMFF1ZXN0aW9ucyUyQyUyMGFuZCUyMENvbnRlbnQlMjIlMjBzdHlsZSUzRCUyMmVkZ2VMYWJlbCUzQmh0bWwlM0QxJTNCYWxpZ24lM0RjZW50ZXIlM0J2ZXJ0aWNhbEFsaWduJTNEbWlkZGxlJTNCcmVzaXphYmxlJTNEMCUzQnBvaW50cyUzRCU1QiU1RCUzQmZvbnRTaXplJTNEMTAlM0Jmb250RmFtaWx5JTNETlZJRElBJTIwU2FucyUyME1lZGl1bSUzQmZvbnRDb2xvciUzRCUyM0ZGRkZGRiUzQmxhYmVsQmFja2dyb3VuZENvbG9yJTNEJTIzMDAwMDAwJTNCJTIyJTIwcGFyZW50JTNEJTIybkpza1dmRjdYV01zUUE0X0RId04tMSUyMiUyMHZlcnRleCUzRCUyMjElMjIlMjBjb25uZWN0YWJsZSUzRCUyMjAlMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214R2VvbWV0cnklMjB4JTNEJTIyOTQyJTIyJTIweSUzRCUyMjc1MCUyMiUyMGFzJTNEJTIyZ2VvbWV0cnklMjIlM0UlMjYlMjN4YSUzQiUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUzQ214UG9pbnQlMjB4JTNEJTIyLTQlMjIlMjB5JTNEJTIyLTglMjIlMjBhcyUzRCUyMm9mZnNldCUyMiUyRiUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhHZW9tZXRyeSUzRSUyNiUyM3hhJTNCJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTNDJTJGbXhDZWxsJTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlMjAlMjAlM0MlMkZyb290JTNFJTI2JTIzeGElM0IlMjAlMjAlMjAlMjAlM0MlMkZteEdyYXBoTW9kZWwlM0UlMjYlMjN4YSUzQiUyMCUyMCUzQyUyRmRpYWdyYW0lM0UlMjYlMjN4YSUzQiUzQyUyRm14ZmlsZSUzRSgtO14AACAASURBVHhe7N3Pi2PZdQfw23EyeIbYULUJhHgRCaaTnSEzOFm1GqqMF/YfMFtDaMgmGwevQlVBNobxIrsUAeNNErKWVtZAa1bBdBbeJSOQQhgSsIOrwAQ72JgOtwa1VZKqJD3p/Trv8zYad7937zmfc3v1Hl8/ef369evkIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFov8ESoUOtnqAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHAnIFTIQSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA/cXP0AAAIABJREFUgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQRECoUJBBaoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVcgYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAQAaFCQQapDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTIGSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkEEhAoFGaQ2CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUCFngAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIBBEQKhRkkNogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChZwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBUAIfza7SeHaZzvuX6ax/Eao3zRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCbgFChbUL+ngABAgQIECBAgAABAgQIECBAgAABAgQIECBAoBUC89tJun71/F6tOViod/os9U4GrehBkQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEDhUQKjQoYKeJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQqFUghwmNZ1dpfjN5sI4cLnTWv6i1TpsTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgCgGhQlUo24MAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQODoAg+FCfVOB6l/Mkjj2eXansKFjj4GCxIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0DABoUING4hyCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEtgt8NLvaKTRo1/u27+gOAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQItENAqFA75qRKAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlNL8dpKuXz1fs+idDtJ5/yL1TgZrf5eDhWa3kzS/mdz7u/P+ZeqdPtv4DGwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAi0VUCoUFsnp24CBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcEcpjQeHa1Fgz0WJjQKk8OFxrPLtfUcrjQWf+iQ5paJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgsoBQocjT1RsBAgQIECBAgAABAgQIECBAgAABAgQIECBAoOUCxwgTWiUQLtTyQ6F8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQeFRAq5IAQIECAAAECBAgQIECAAAECBAgQIECAAAECBAg0UqDs8J+y128kqqIIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEAgvIFQo/Ig1SIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBol8D8dpKuXz1fK7p3Okjn/YvUOxkcraEcLDS7naT5zeTemuf9y9Q7fXbUvY5WtIUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDwiIBQIceDAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgEQI5TGg8u1oL+CkjTGi14RwuNJ5drjnkcKGz/kUjfBRBgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBXQSECu2i5B4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHSBOoME1ptSrhQaWO2MAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECFQkIFaoI2jYECBAgQIAAAQIECBAgQIDAcQSm02kaDofp6dOn6etf//pxFrUKAQIECBAgQIBAbQJNDfFpal21DcrGBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAi0RkCoUGtGpVACBAgQIECAAAECBAgQIEBgNBrdBQotX9/4xjeECzkaBAgQIECAAIEWCsxvJ+n61fO1ynung3Tev0i9k0HtXeVgoXyNZ5f3ajnvX6be6bNG1Fg7kgIIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEGicgFChxo1EQQQIECBAgAABAgQIECBAgMCqwKYwodV7hAs5NwQIECBAgACBdgjkMKHx7CrNbyb3Cm5SmNCqZA4XWg0WyvfkcKGz/kU74FVJgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBnBIQKdWbUGiVAgAABAgQIECBAgAABAu0TmE6naTgcpvy76yVcaFcp9xEgQIAAAQIEqhVoY5jQqpBwoWrPjN0IECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgmIFSomJunCBAgQIAAAQIECBAgQIAAgRIFioQJLZcjWKjE4ViaAAECBAgQIFBAIFoYT7R+CozUIwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFhAqFCDh6M0AgQIECBAgAABAgQIECDQRYHRaJSGw+FRWhcudBRGixAgQIAAAQIECgvMbyfp+tXzted7p4N03r9IvZNB4bXrfjAHC+VrPLu8V8p5/zL1Tp+1ure6be1PgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBhAkKFDvPzNAECBAgQIECAAAECBAgQIHAkgWOGCa2WJFzoSEOyDAECBAgQIEBgR4EcJjSeXaX5zeTeExHChFYJcrjQarBQvieHC531L3YUcxsBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSOJyBU6HiWViJAgAABAgQIECBAgAABAgQKCEyn0zQcDlP+LfsSLlS2sPUJECBAgACBrgt0KUxoddbChbp++vVPgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoDkCQoWaMwuVECBAgAABAgQIECBAgACBTglUGSa0DCtYqFPHTLMECBAgQIBAhQJCdT7D5lDhobMVAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIbBYQKORgECBAILDD9817g7rS2SeAPvvWP6Z2nfwqHAAECBAgQINB4gdFolIbDYa11Cheqld/mBAgQIECAQCCB+e0kXb96vtZR73SQzvsXqXcyCNTtbq1kk/nNx2k8u7z3wHn/MvVOn3XSZDc5dxEgQIAAAQJNEvC+uUnTqK6Wd/9+Xt1mdiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEChNQKhQabQWJkCAQP0CPvKsfwZVVyBUqGpx+xEgQIAAAQL7CjQhTGi1ZuFC+07R/QQIECBAgACBzwRycM54dpXmN5N7JF0OE1o9Gx/NrtaChfI9OVzorH/hKBEgQIAAAQIEGi3gfXOjx1NacUKFSqO1MAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgUgGhQpVy24wAAQLVCvjIs1rvJuwmVKgJU1ADAQIECBAgsElgOp2m4XCY8m9TL+FCTZ2MuggQIECAAIGmCQgT2n8iwoX2N/MEAQIECBAgUL+A9831z6COCoQK1aFuTwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA8QWECh3f1IoECBBojICPPBszisoKESpUGbWNCBAgQIAAgR0F2hAmtNyKYKEdB+s2AgQIECBAoLMCwnEOGz2/w/w8TYAAAQIECFQr4H1ztd5N2U2oUFMmoQ4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwGECQoUO8/M0AQIEGi3gI89Gj6eU4oQKlcJqUQIECBAgQKCgwGg0SsPhsODT9T4mXKhef7sTIECAAAECzROY307S9avna4X1TgfpvH+ReieD5hXd4Io2hQud9y9T7/QZywbPTWkECBAgQKBrAt43d23in/UrVKibc9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgEE9AqFC8meqIAAECbwR85Nm9wyBUqHsz1zEBAgQIEGiiQJvDhFY9hQs18YSpiQABAgQIEKhSIIcJjWdXaX4zubetMKHDp7ApWCivmsOFzvoXh29gBQIECBAgQIDAgQLeNx8I2NLHhQq1dHDKJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAisCAgVciQIECAQWMBHnoGH+0BrQoW6N3MdEyBAgACBJglMp9M0HA5T/o12CReKNlH9ECBAgAABAtsEhAltEzre3wsXOp6llQgQIECAAIHjCnjffFzPtqwmVKgtk1InAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQOBxAaFCTggBAgQCC/jIM/BwH2hNqFD3Zq5jAgQIECDQBIHIYULLvoKFmnDa1ECAAAECBAhUISDkpgrl9T241+NuVwIECBAgQOBhAe+bu3k6hAp1c+66JkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOIJCBWKN1MdESBA4I2Ajzy7dxiECnVv5jomQIAAAQJ1C4xGozQcDusuo9L9hQtVym0zAgQIECBAoEKB+e0kXb96vrZj73SQzvsXqXcyqLCa7m61KVzovH+ZeqfPzKC7x0LnBAgQIECgFgHvm2thr31ToUK1j0ABBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGjCAgVOgqjRQgQINBMAR95NnMuZVYlVKhMXWsTIECAAAECywJdDBNaPQHChfybIECAAAECBKII5DCh8ewqzW8m91oSJlTfhDcFC+VqcrjQWf9mUJkQAAAgAElEQVSivsLsTIAAAQIECHRKwPvmTo37TbNChbo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC8QSECsWbqY4IECDwRsBHnt07DEKFujdzHRMgQIAAgaoFptNpGg6HKf+6PhMQLuQkECBAgAABAm0VECbU/MkJF2r+jFRIgAABAgQiC3jfHHm6D/cmVKibc9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgEE9AqFC8meqIAAECbwR85Nm9wyBUqHsz1zEBAgQIEKhKQJjQ49KChao6ifYhQIAAAQIEjiUgrOZYktWsY17VONuFAAECBAgQuC/gfXM3T4RQoW7OXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAPAGhQvFmqiMCBAi8EfCRZ/cOg1Ch7s1cxwQIECBAoAqB0WiUhsNhFVu1fg/hQq0foQYIECBAgEB4gfntJF2/er7WZ+90kM77F6l3Mghv0OYGN4ULnfcvU+/0mdm1ebBqJ0CAAAECDRXwvrmhgym5LKFCJQNbngABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQkYBQoYqgbUOAAIE6BIp85Hly9s30u18+r6Pco+/5vz8ap9uPvnf0dZu8oFChJk9HbQQIECBAoH0CwoSKz0y4UHE7TxIgQIAAAQLlCOQwofHsKs1vJvc2ECZUjneZq+ZgodntZG2WOVzorH9R5tbWJkCAAAECBDomUOR9c8eIQrYrVCjkWDVFgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIdFBAqFAHh65lAgS6I1DkI88vfeuf0ttPvxIC6Ref/DB9+uEHIXrZtQmhQrtKuY8AAQIECBB4TGA6nabhcJjyr+swAeFCh/l5mgABAgQIEDhcQJjQ4YZNXSGHC41nl2vlCRdq6sTURYAAAQIE2idQ5H1z+7pU8aqAUCFnggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQQ0CoUIw56oIAAQIbBYp85ClUqN2HSahQu+enegIECBAgULeAMKFyJiBYqBxXqxIgQIAAAQK7CVz/6/M0v5ncuzly6EzudTy/uus3//dZ/+Luv3PPUa9N4UIv3n+ZeieDqC3riwABAgQIEKhIoMj75opKs02JAkKFSsS1NAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgQgGhQhVi24oAAQJVCxT5yHM5VOjXP/9Z+uWn/1Z12Qft99aX/jh97p0v3q3xi09+mD798IOD1mvbw0KF2jYx9RIgQIAAgeYIjEajNBwOm1NQwEqECwUcqpYIECBAgEALBLoUKrSp18WIcrhQ1GAhoUIt+IeoRAIECBAg0FKBIu+bW9rqvbLzO/N8de1d8wJBqFCEU6wHAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBKQoWcAgIECAQWKPKR53KoUBtDedpe/6HHUajQoYKeJ0CAAAEC3RMQJlT9zIULVW9uRwIECBAg0GWBh4J2csBODtqJco1nlymH6zx29U4H6cV7L6O0nOa3kzSeXaX5zWStpxfvv0y9k0GYXjVCgAABAgQI1CNQ5H1zPZUeb9euv2/OkkKFjneerESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqFNAqFCd+vYmQIBAyQJFPvJs+0eSba//0CMhVOhQQc8TIECAAIHuCEyn0zQcDlP+ddUjIFyoHne7EiBAgACBrgk8FCq0cIgQLrRLoNCi3xwqlMOF2n7lAKXc90OXUKG2T1j9BAgQIECgGQJF3jc3o/JiVSy/a16s0Mb/I55i3f/mKaFChwp6ngABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQDAGhQs2YgyoIECBQikCRjzzbHsrT9voPPQhChQ4V9DwBAgQIEIgvIEyoWTMWLNSseaiGAAECBAhEFFgOFcpBM/Obj9fCaNoeLLRPqFAOFMrBQm295reTNJ5dpfnN5F4LeYaz28mbPxcq1NYJq5sAAQIECDRLoMj75mZ1sHs1mwKFFk93LVhIqNDu58adBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEmCwgVavJ01EaAAIEDBYp85Nn2UJ6213/gyJNQoUMFPU+AAAECBGILjEajNBwOYzfZ0u6EC7V0cMomQIAAAQItEFgNFeqdDNJHs6u1YKHcSlvDhb79gyd7TeI7X3291/1NuXnT3HJI0nn/IuW5bpp1U2pXBwECBAgQINBOgSLvm9vY6WOBQot+uhQsJFSojadYzQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBdQGhQk4FAQIEAgsU+ciz7aE8ba//0OMoVOhQQc8TIECAAIGYAsKE2jNX4ULtmZVKCRAgQIBAWwQeC5rZFFLTxmCh6KFC89tJGs+u0vxmcu/Yrc5KqFBb/lWqkwABAgQItEegyPvm9nT3WaW7BAoteupKsJBQobadYvUSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBDYLCBVyMggQIBBYoMhHnm0P5Wl7/YceR6FChwp6ngABAgQIxBKYTqdpOBym/Lvv9e6776anT5/u+9jd/Z988kmhPQttVvJDdTkIFyp5sJYnQIAAAQIdEtgWNLMpWCjztClcaLnHbaPtnQ7Si/debrutMX+/aT65h/P+ReqdDO7VuW3WjWlKIQQIECBAgEBrBIq8b25NcxsChXJoUL7efvqVu9/V/734s08//KBNbe5dq1Chvck8QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBopIBQoUaORVEECBA4jkCRjzzbHsrT9voPnbxQoUMFPU+AAAECBGIIHBImtBA4JNRmNBrdhRlFuOp0OGTvCPZ6IECAAAECBI4jsGvQzKbwmqYHC81vJmk8v0r5d9/rrH9xF5zU1Gt+O0nj2Xpvj81k11k3tWd1ESBAgAABAs0TKPK+uXldbK5o+b1yviMHCOWwoE3vmx+6ty297lunUKF9xdxPgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEGimgFChZs5FVQQIEDiKQJGPPOsM5Tk5++Zd37cffa9w/3XWX7joIz4oVOiImJYiQIAAAQItFThWoM8hgTbHqqEJI2iCwyE1NMFQDQQIECBAgEC9AvsEzWwKFsrVNy1c6JAwodVpNDFcaNMceqeDdN6/SL2TwYMHap9Z13sq7U6AAAECBAi0RaDI++Y29PZYSNBD75u7FCwkVKgNp1iNBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHtAkKFthu5gwABAq0VKPKRZ52hPP2//VH63DtfTP/zz39TOFiozvqbcFCECjVhCmogQIAAAQL1CBw7yOeQIJtj11KP6Ge7NsnhkFrqNLQ3AQIECBAgUK9AkaCZTaE2TQkWWu5nWTaH7uSwoceufE/v5FnK/S1fOVgoX7nHOq/57SSNZ1drfexqX2TWdfZrbwIECBAgQKD5AkXeNze9q23hQI+9b972bNN737U+oUK7SrmPAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINBsAaFCzZ6P6ggQIHCQQJGPPOsK5VkECi0aLhosVFf9Bw3qiA8LFToipqUIECBAgEBLBKbTaRoOhyn/HvM6JMBGqNBnkyjL4ZDZHPOMWIsAAQIECBBoh0DRoJlNwUK54xfvv0y9k0HlzY9nl2thQLmIHAiUQ3e+/YMnG2taDRt68d7LNLudPLpW5c2ldFdP7nH5yrWf9y929i466zr6tScBAgQIECDQDoEi75ub3NkuoUDb3jfvskaTDXapTajQLkruIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAg0X0CoUPNnpEICBAgUFijykee2jyQLF/PIg6uBQotbiwQL1VF/GSZF1xQqVFTOcwQIECBAoL0CL168KKX4Q4JrygrTKaXRLYs21eH6+roODnsSIECAAAECLRQ4NGhmOewmh9zkUJ4qr/nNJI3nVyn/Ll93gTu9i5R/VwOHctBQrjtf+b/ntx+/eX65h21BRZX2eTtJ16+ev9kyByXl2ve5Dp31Pnu5lwABAgQIEOiGQJH3zU2V2TUMaJf3zbuu1VSLbXUJFdom5O8JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0QECrUjjmpkgABAoUEinzkuctHkkWKyevm69MPP7j3+EOBQoub9g0WKqv+Ij3X8YxQoTrU7UmAAAECBOoVECpUrr9QoXJ9rU6AAAECBAiUL3CMoJlFsNCL91+m3smg/KJTugsB2hYmlAvZFCiU/3w5VKh/MkjZYXHlsJ4c2rO4mhIulGue3U7Sef+ikPMxZl3JcG1CgAABAgQItEagyPvmpja3HJTzi09+uPbeelH3ru+bV4OFolo1dZ7qIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ2C4gVGi7kTsIECDQWoEiHy7u+pHkPigPrbn6oeVDa+7TRxn179Nr3fcKFap7AvYnQIAAAQLVCwgVKtdcqFC5vlYnQIAAAQIEyhdoY9DMPiE/3/7BkzeIi7Cg5ec3/Vl+4MV7L1Pv9DcBSfmZfC3CiBaL5udzKNHyveVPrdgObZx1sU49RYAAAQIECFQlsM972qpqKrrPIlTosUChvPY+75uX7z2G1ZO3Pn/X3utf/l/RNo/y3HIA01EWtAgBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAtAkKFamG3KQECBKoRKPLh4j4fSe7SxabgoPyhZr7efvqVXZZIv/75z9LsL7+8073Hrn+nTRt0k1ChBg1DKQQIECBAoCIBoULlQgsVKtfX6gQIECBAgED5Am0KmpnfTFKud/VaBAOt/vlq+NB3vvr67pZNoUL5z5ctckhQDhbatubi7x+qofwJ7r5Dm2a9e1fuJECAAAECBOoUKPK+uc56H9s7B+VsCxTKz+/7vnlxf1Grt37vD9PJ116kL/zJ19KT3/l8evLbb6Vf/fS/0q9+8p/pJ//w1+mXP/6PykmFClVObkMCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQCkCQoVKYbUoAQIEmiFQ5MPFfT+SfKzTTYFCRWV2DRY6Zv1Fa63zOaFCderbmwABAgQI1CMgVKhcd6FC5fpanQABAgQIEChfoO6gmRwUNLudpPntx6l38uyu4fP+5b3G8z3j+VXKv8tXDv45712k/Lt6rQYQLYf+PBQqtPpMDhXatHbeazWwaLH/pnChRf35nod6LH/S90OTXrz/MvVO1t2qqMMeBAgQIECAQByBIu+bm9p9fo/86YcfbC2vyPvmXdde3fydP/qz9Pt/8Xfpt97+wsa6fvXT/04//v5fpZ//+79srfuYNwgVOqamtQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC9QkIFarP3s4ECBAoXaDIR55FPpLc1MgxA4UW6+8SLHSs+ksfTkkbCBUqCdayBAgQIECgwQLRQ4WKhPp897vfTdPp9ChTK7L/YuPRaPT/7N0LkF31fSf4v4QkjIQFLR4CW37Q7bTsiSdDTaBwmI3dTtRsUislqZBaljiTNZQrymTssTfiYVecSIqZwjyUjcc7U+mJCxxPxlVshUxquqvipZUgnB0Ck00Vm3GC1Ws1wZIx4iGBAMmWhLT1b8/tXN2+j/O859zbn1Plukb3//j9P7+jqi6do6/C9PR0IXW0LjI1NVXKuhYlQIAAAQIEhk+gylCh5r1bZWM4z9jIROowocY6zWu3Bv10ChWKc1vDgu654WzXpncLF+pUf2PBdgFEZd5hVfa6zHNZmwABAgQIEKhOIMvz5uqqLWbnfj1vXrPxqvC2T3wpxM9u15uvHw0HP/8L4eThZ4o5YIJVhAolQDKEAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDAAAkKFBqBJSiRAgEBWgSwveRbxkmQZgUINg17BQkXUn9W7DvOECtWhC2ogQIAAAQL9FRAqtNQ7BgrFYKEiLqFCRShagwABAgQIEKhSoKqgmU5hPL0skgTx9AoG6hYqFPdvNhndMBG2X/No17LievNHHwvzR/b1Kn/J93HtuEc/rqp63Y+z2YMAAQIECBCoRiDL8+ZqKi1u1349b9706/8hrH3fP0tU+Kt/8VA4/JXPJBpbxCChQkUoWoMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUL2AUKHqe6ACAgQIlCaQ5SXPvC9JtgsUikFAJw8+Xdg5X39qNhzd+0Db9Ua23BouvHpy4btu4worpmYLCRWqWUOUQ4AAAQIE+iBQVqjQ+Ph42Lx58zkn2Lp16+J/z8zMdDzd/v37Qwz2KeKamppKvUyRoULtHBoFxe/i/+IV92w9c5EOrQhZXFJDmkCAAAECBAgMhUAVQTNZAoWShPs0GnLnIysWe9MuhKhXqFAMB4oujStp8E/Z58p7w1XR67w1m0+AAAECBAjUWyDL8+Z6n6h3dXmfl/feIYQVq88P7/7c3rD6krcnGR7OnDgWDuy4Lpw99f1E4/MOEiqUV9B8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEA9BIQK1aMPqiBAgEApAlle8szzkmS7QKF4sBP7nwwH77+5lDNa9FwBoULuCAIECBAgsPwEygoVaie5Y8eOxRCdPXv2FBYc1K1rWcNz+lHftm3bQiNoKYYsTU9P9+0GzOrStwJtRIAAAQIECNRGoIqgmeY9k0AkDfWJazUH+3QKIuoVKhTXaa4xTaBRaw1Fny/Jep3GVNHrPPWaS4AAAQIECNRfIMvz5vqfqnuFeZ6XJz37yjUXhPf8279NOnxh3Lf+5Q+HMydPpJqTdbBQoaxy5hEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6iUgVKhe/VANAQIEChXI8pJn1pckOwUKxQMJFSq0rV0XEyrUP2s7ESBAgACBuggMc6hQc2hPWm+hQmnFjCdAgAABAgSGVaCKoJk7H1mRmDNNoE9zWFDcoFMYUZJQoTi/uc4tYzvD5NiuRHW31tFrUprQpF5rdfu+il7nqddcAgQIECBAoP4CWZ431/9U3SvM+rw8zbmFCqXRMpYAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCCrgFChrHLmESBAYAAEsrzkmeUlyW6BQpGpOVRoZMut4cKrJwdAr3eJrz81G47ufaD3wD6OECrUR2xbESBAgACBmggIFWrfiLm5uRCDhcq8mkOPZmZmwvT0dJnbnbP21NRU3/ayEQECBAgQIDDYAv0Ompk/si/EPZNeaUKFkoYAJQ0Vaq01afhP2lChNIFFSd3ajet3r/PUai4BAgQIECAwGAJZnjcPxsk6V5nleXnaM69YfX4Y2/NkWHnB+kRTT738nfD3v7klnD31/UTj8w4a//35vEuYT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUAMBoUI1aIISCBAgUJZAlpc8074k2StQKJ6tOVQoyfiyPIpet/lcRa+ddT2hQlnlzCNAgAABAoMrMMyhQnmDc8q2ESo0uL9vVE6AAAECBJaTQBVBM83hP72sk4YKtQb53HPD2Y5LJw0Vigs0+2StpdcZk4YV9Vqn1/dV9LpXTb4nQIAAAQIEBlsgy/Pmfp44hvOsWLFyYcuzZ88UErqT9nl51vNu/OW7w0U/flOi6cef/i/h0O/880RjixgkVKgIRWsQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKoXECpUfQ9UQIAAgdIEsrzkmeYlyaQBQUKFSmvxkoWFCvXP2k4ECBAgQKAuAmUH5zSfc8eOHWF8fHzhl/bs2RPm5uZKY4j7xP3yXGXXKFQoT3fMJUCAAAECBPolUEXQTPOeSc+5ZWxnmBzb1XZ4a6BQt7FxgTShQvNH9i0ECzWubmvHsbPzu0P8THN1C0BKs06vsVX0uldNvidAgAABAgQGWyDL8+Z+nHjNxqvCyP/4K+Gt1/x0WHnB+oUtT738nXDqhb8PL/zH3wonDz+TuYw0z8szbxJCiGd4x6f/KJx34UjXZeJZnvvix3KdKW2dQoXSihlPgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKingFChevZFVQQIEChEIMtLnklfkkwaKBQP0ilU6M3jx8LJg08XctZ+LbLmHe8L5639wYupzefq1/699hEq1EvI9wQIECBAYPgEhjVUqDmwJ2vXYuhRDBYq6xIqVJasdQkQIECAAIEiBaoImmkN6klznnahPnc+smJxiV6BQnFgmlCh1vHxv7df82gY3TCxuGfWMKG4QJJ60/h0G1tFr4uq3ToECBAgQIBAPQWyPG8u+yRr3/tj4crt/0fHMJ4YwvPCH342HP/mX2YqJenz8kyLt0yKZ9n40fvC6kve1na5MydeC8/9u1/NfJasNQoVyipnHgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgXgJCherVD9UQIECgUIEsL3kmeUkyTaBQPFCnUKE6hvL0akASn15rlPm9UKEyda1NgAABAgTqKVD3UKHx8fEFuBjwk+basWNHaMxNM695bJZQoTT1ChXK2hnzCBAgQIAAgX4KVBU00xzs0+m8MXAnXnsP7F4ypBHG07rOPTec7cmXNlQoLtjsFAOFYrBQtzChWF+7upuL62egUOsZtl/7aBgd+YdgpJ5oBhAgQIAAAQIE2ghked5cJuSajVeFt/9v/6FjCE9j7xjG8+1//XMhBgylvfr9PDie6fKPfC6svvxdYfUlbw9nT58MZ099L7z2118LR782lekMac/cOl6oUF5B8wkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC9RAQKlSPPqiCAAECpQhkecmz10uSaQOF4sGECpXS3raLChXqn7WdCBAgQIBAXQTqHCrUHLoTvWZmZhbY9u/f3zVkqHVeHuu45/T0dMclGiFCcc/mEKM9e/b0DEISKpSnM+YSIECAAAEC/RKoKlSocb5u4ULNwUFxfFEhPVlChWKAULRqXDFYKP5a69Up7Kh5XJw7ObozxM9+XlX3up9ntRcBAgQIECDQH4Esz5vLrGzTr/9hWPu+6xNt8er//X+Gw3/w6URjmwf1el6eesEUE1asecvC6LMnv5diVvFDhQoVb2pFAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAVAkKFqlC3JwECBPokkOUlz24vSWYJFIpHFSrUp4aHEIQK9c/aTgQIECBAoC4CdQ4Vmpqa6srUGjIUQ31aw32Kcm4OF2rsE9duDhJq3mtubi7EYKFul1ChorpjHQIECBAgQKBMgToFzcSQngNH950THrT9mkcXw3diGFC82oULxYCeODbJlSVUKK7bbNW6T3NQUGtQUiNoKJ6v30FCzXXWqddJ+mQMAQIECBAgUH+BLM+byzzVVZ//i7D6krcn2uLMiWPhW//q6kRjmwdVGSqUutiSJggVKgnWsgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBPgsIFeozuO0IECDQT4EsL3l2ekkya6BQPK9Qof51XahQ/6ztRIAAAQIE6iJQ11Ch5sCduljFoKBOIULtamwOImr3vVChunRWHQQIECBAgEA3gToGzTTX1C4sKIb2zB99LMSQntarEeDT7cxpQ4XiPrPzu9vu1xwm1NjzzkdWLG6fpJ5+3aF17HW/zm4fAgQIECBAoByBLM+by6kkhBVr3hJ+6N/+XeLlz54+Gb71yavD2ZPfSzwnDhQqFIJQoVS3jMEECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdoKCBWqbWsURoAAgfwCWV7ybPeSZJ5AoXgKoUL5e5l0BaFCSaWMI0CAAAECwyNQ11ChqampoUDu5itUaCha7BAECBAgQGDoBeoYNBNDfGJdjWv7NY+GGN7TfDUH97RrUrcwn+ZQoXahRY31uoUJdaqtee045p4bztbmHqpjr2uDoxACBAgQIEAgk0CW582ZNkowKYYKvecLT4UVq9YkGP2DIf/fv/xHQoUSa/3DQKFCGdBMIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUUECoUA2boiQCBAgUJZDlJc/WUKGXp78QLtn2yVwlvf7UbDi694GFNfr5LzuObLk1XHj15MK+sYZ4NerIeqB+1p+lRqFCWdTMIUCAAAECgy1Qx1Ch5rCdwdYNYW5uLuzZs6ftMYQKDXp31U+AAAECBJaHQF2DZprrag3+aQ0FGh350EKz9h7YvaRpzeFCrYE/zYObx3ULE4q1xP2a92oODmoOO+oWbFTF3VXXXldhYU8CBAgQIECgGIEsz5uL2bn9Ku/5N0+FlResT7TFqZe/E5759I8nGts8qO7Pg1MfKMMEoUIZ0EwhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNRQQKhQDZuiJAIECBQlkOUlz7Jfkuzn+p0c3zx+LByZ/jeZAobKrj9v74UK5RU0nwABAj+6NAUAACAASURBVAQIDJ5A3UKFhilQqHE3xFChGC7UegkVGrzfLyomQIAAAQLLUaDOQTPtAnpag4G2X/NoiEE/8YrfxatduFAcE8OCul0xBGj+6GNtx8X5k6M7F/dqdmuEB7WGHcXa6nTVudd1clILAQIECBAgkFwgy/Pm5KunH7nxf/18uOh/+J8TTTz+9OPh0O/8UqKxzYPq/jw49YEyTBAqlAHNFAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBADQWECtWwKUoiQIBAUQJZXvIs+yXJfq7fyzFLuFDZ9fequdf3QoV6CfmeAAECBAgMn4BQofJ7GgOFYrBQ6yVUqHx7OxAgQIAAAQL5BeocNBNDgGJ9jSuG9DT/dyPMp1WhW7hQWrHWMKHG/NbaWkOLOtWWdv8ix9e510We01oECBAgQIBA/wSyPG8us7o1G68K7/yNPwkrL3hr121Ovfxc+M7//s/DycPPpC6n7s+DUx8owwShQhnQTCFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI1FBAqFANm6IkAgQIFCWQ5SXPsl+SLHv9kS23hstu+mwqwhP7nwwH77850Zyy609URJdBQoXyCppPgAABAgQGT6BOoULNITuDJ9m94hgqFMOFmi+hQsPWZechQIAAAQLDKVD3oJnm+lo7cM8NZ7s2JU+4UKcwoeYNO9VWx0ChWHfdez2cv8OcigABAgQIDLdAlufNZYusfe+Phct/6a4QA4baXW++fjR8d+rj4fg3/zJTKXV/HpzpUCknCRVKCWY4AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCmAkKFatoYZREgQKAIgSwveZb9kmTZ60e3LC85Jg0W6kf9eXovVCiPnrkECBAgQGAwBeoUKjQ1NTWYiAmqjoFCMVio+RIqlADOEAIECBAgQKBygboHzcwf2bcQhtN6pQnuufORFamct1/zaIihQkmudmv3CjtKsm4ZY+re6zLObE0CBAgQIECgXIEsz5vLregHq8dAocs/8tth9eXvDqsvefvCr505cSy89v/8aTj6f/37cPLwM5nLKPJ58HnrLlqo4803Xs1cTxUTszxvr6JOexIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHQXECrkDiFAgMAQC2R5ybPIlyTb0Za9ftyzeY807U0SLNSP+tPU3DpWqFAePXMJECBAgMBgCtQlVKg5YGcwJXtXPTMzE6anpxcHChXqbWYEAQIECBAgUL3AIATNzB7YFfYe2L2IlSZQKE5KGyqUJhSoNfQobW39vAMGodf99LAXAQIECBAgkF8gy/Pm/LsmX2HF6vPDihUrFyacPXsmnD31/eSTO4zM8zx45dr1YcPkx8K6H/mJsObKsbBi1ZoQVqwIbx5/NZx+6Tvhjb/583Bk9kvhzPFjuesscwGhQmXqWpsAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0D8BoUL9s7YTAQIE+i6Q5SXPPC9JJjlgketfcct94YLx68KJuSfD8w/evrh91lChuECSYKEk56xqjFChquTtS4AAAQIEqhMQKtQ/e6FC/bO2EwECBAgQIFCcwCAEzeQNFWo+YxK5NKFCrbWNbpgI2695NMk2fR8zCL3uO4oNCRAgQIAAgVwCWZ4359qwBpOzPs+OQUKX/cJnFsKEul0nv3sgvPhHdy8EDNX1EipU186oiwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCQTkCoUDovowkQIDBQAlle8sz6kmRSmCLWj2FC66+/cXHLUy8dCs985oPnlJD1RUehQkk7aRwBAgQIECBQF4G6hApFj23btoWtW7eWSjM3Nxfi//bv3x82b968sNf4+PjC/8q8WgOFWs/b7vsy65mamipzeWsTIECAAAECQyRQ96CZ+SP7Qqyx9YrBPTHAp9sV587O7w7xM+21ZWxnmBzb1XVaa6BQY3CSuWnrKWJ83XtdxBmtQYAAAQIECPRXIMvz5v5WWPxuWZ5nX/rzd4SRyVvDilVrEhd05E9/L7z0x/cmHt/PgVmftfezRnsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAj0FhAq1NvICAIECAysQJaXPLO8JJkGKM/6zXNb92w9a54XHQc5WGjTbV8Nazd/IE1LjCVAgAABAgQGXKBOoUKRsqxgoRgktGfPnq7dKmvvToFBzfsJFRrw30jKJ0CAAAECQyxQ96CZ5vqa2xADhWKwULsrT5hQ63rdAoLufGTF4vBYT3N4UZLQo37fVnXvdb897EeAAAECBAjkF8jyvDn/rtWukPZ59rof+Ynw9k98KXXRZ06eCN+d+kR442/+PPXcsifkedZedm3WJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQSC4gVCi5lZEECBAYOIEsL3mmfUkyLUrW9bsFCsUaDt3/i+H4/icWy+k1vlvdvUKFrrjlvrD6kk1pj556/OtPzYajex9INU+oUCougwkQIECAQGUC+/btCx/+8IfDrl27ws6dO3PVUbdQoXiYosN90gT29HNvoUK5bl2TCRAgQIAAgR4CK1asKOTnxToHzcwe2BX2Hti9KBGDemK9jas1uKdbmFBr6E873hgg1Lxf85jWcKHW2u654exCbY1goW6hR1Xd3HXudVUm9iVAgAABAstRoMg/e8zyvHnQzdM8z165dn1412/8SVh9+bszHfvUC38fnv3XPxfOHD+WaX5Zk4QKlSVrXQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAfwWECvXX224ECBDoq0CWlzzTvCSZ5TBZ1k8SEHTs8YfD8w/evlhSkjmd6u8WKpRn3bRevcKN2q0nVCitsvEECBAgQKAagcZf7GnsnidcqI6hQvFcRYX7pAkUanj2a2+hQtX8/rErAQIECBBYLgIxVKiInxfrHDRz5yP/cMZGqE+7MJ9uYULNYUBx3IGj+5YEB8UAoMnRnSF+xqt1j+Z7qrFeu9ri+t1Cj6q+N+vc66pt7E+AAAECBJaTQJF/9pjlefOgW6d5nn3pz98RNvz0r+Y68pE//b3w0h/fm2uNoicLFSpa1HoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWoEhApV425XAgQI9EUgy0ueaV6SzHKItOsnDfE59dKh8MxnPnhOSVledqxLoFA8iFChLHeYOQQIECBAYDAEWv9iT6PqLOFCVYUKzc3NLWLH/z89Pb0EP2+4T1x3z549mZq6Y8eOMD4+nmlunNQpzCiu27ia188SfpS5uBDC1NRUnunmEiBAgAABAgMg0BwqlOfnxboGzTQH+8Swn+3XPLrYleaa43cxzKf1ag4Tav2uee2k4zrdEq21tQs9qsvtVNde18VHHQQIECBAYLkIFPlnj1meNw+6c5rn2e/6zZlw/jv/Ua4jf//bfxee/dzWXGsUPTnLc/aia7AeAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAfgGhQvkNrUCAAIHaCmR5yTPNS5JZDp5m/bWbPxA23fbVxNu0nnfsC0+F89auTzw/baDQm8ePhZMHn068fpKBa97xvsWahQolETOGAAECBAgMpkCnv9jTOE2acKGqQoWa5buF/+QJFoqBQs3hRWm6HQN/mgOA0sztFhDUKcxHqFAaYWMJECBAgACBJALtQoWy/LxYx6CZ1mCe1uCf1u+bvbqFBDXGJQ0Vaje+tTetoULx+9bQo+ZApCS9LWtMHXtd1lmtS4AAAQIECHQWKPLPHrM8bx703qR5nj163xNh1cWX5zryme+9Eb71iX+ca42iJwsVKlrUegQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBagSEClXjblcCBAj0RSDLS55pXpLMcog061/1+a+H1ZdsSrzNiw/dFY7ufWBxfPNevRZJGygU18sS+tOrjjQ+7daKIUwxjMlFgAABAgQI1Fug11/saVSfJFyo7qFC8SxZg4Xynq1TAFC3u6NXOJBQoXr/3lIdAQIECBAYJoFuoUJpfl6sS9DM/JF9C2XHkJ47H1mx2KrmkKA4ZnZ+d2iMbe5nkjChxvi0oULt5rXeS611RtfG1RwqFM9X1VWXXld1fvsSIECAAAECPxAo8s8eszxvHvQ+pHleW0j4ztkzYe5X3lMrtkLOVasTKYYAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsDwFhAotz747NQECy0Qgy0ueaV6SzMKYdP0rbrkvrL/+xlRbHHv84fD8g7cvzhnZcmu47KbP9lwjS6BQXFSoUE9aAwgQIECAAIEOAkn/Yk9jerdwobzBO2maND4+3nH43Nxcx++yhArF9fbs2ZOmvCVjd+zYEbrV3G7xXqFCndbrdv5ch+gwOUtgUhl1WJMAAQIECBAoTyBJqFCSnxerDJrpFhLUqP2eG84uhAh1ChNqjIvBPUkDe8oIFWrU0QgXanZtdxekCUEq6i6qstdFncE6BAgQIECAQH6BIv/sMcvz5vwnqHaFpM+zY5Xj//5bIaxYmbvgujkLFcrdUgsQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGohIFSoFm1QBAECBMoRyPLyYfNLkm8ePxZOHnw6d3GvPzUbju59YGGdpC9hXvX5r4fVl2xKtfeplw6FZz7zwXPmxGChDdv+1cKvnbd2/ZL10gQKxbHxumDzdQufQoVStcdgAgQIECBAoEkg7V/saUxtFy7Uz1ChrE3MEirUK9wnSS1lhAol2bcfY4QK9UPZHgQIECBAoFqBNKFC3X5erCpopjnYp5NkIyQohgq1XjGUJ157D+xe/CoGECW5soYK3fnIisXl2+3fvHf8vrm2dnX1O1ioql4n6YkxBAgQIECAQP8EivyzxyzPm/t30nJ2Svo8O+7+ni/+t7DyLetyFXL6lRfC/O0fyLVG0ZOFChUtaj0CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQDUCQoWqcbcrAQIE+iKQ5SXP5pckiyqyOXwn6UuYY194qm0IUK+aup05BgzFK4YMxYChtIFCB++/OXEoUq86O32f1KfT/E23fTWs3Vyvl06zWphHgAABAgSGWSDrX+xpmDSHC/UzVCiGA42Pjy9pzdzcXJienu7YsiyhQnHNPXv25LoNsuzbK8woBhW1u3oZ5DpIm8lChYoWtR4BAgQIEKifQJZQoXY/L1YVNNMc0JNGtzWIp3mdGEK0/ZpHey6XJVSo25wkAUmdiupnsFBVve7ZEAMIECBAgACBvgoU+WePWZ43ZznsqosuW5h2+tUXs0wvdE6a57Xv+s2ZcP47/1Gu/b//7b8Lz35ua641ip4sVKhoUesRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKoRECpUjbtdCRAg0BeBLC951iVUKOuLii8+dFc4uveBXL6tBllCkbIWkOYl1XZ7NEKF8vyls6y1m0eAAAECBAj0XyCGCz333HN92zgG6nQKFeoWAJQl3KeIUKEswTvxHHHvTlenNXuFERXdpFjH7t27Q7wHXAQIECBAgACBTgLxZ4Ur/qd9Yf7IvoUh2699NIyOTJQOliWEp1P4Tqw9huU0rhgqFMOFul1pQ4Va6+20R5ZzxTrvueFs6eZxg9ZQoW//vyF8+MP/YNeXImxCgAABAgQIDI1A/Fny5kN/UNp5Vl28MVzyM58Kb712a1h5/gUhrFgZTr/yQjj53W+F5x/YEU6/cri0vbstnOZ57aU/f0fY8NO/mqvOI3/6e+GlP7431xpFT876rL7oOqxHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCQT0CoUD4/swkQIFBrgSyhQiNbbg0XXj1Z6Llef2p2MegnyUuYsYbLbvpsphpOvXQovPJnX84cLNQtUCgWlKT+TIX/90l51xcqlEffXAIECBAgMJgCv/Irv9K3wrOECmUJFGocaPv27bnOliVUKG7YLVhIqFCulphMgAABAgQIVCBw830hvONHfrBxv0KF7nxkReKTxoCgGOLT7WoOy0kyPm2oUHO9ncKNmutrrifJQZMEISVZp9cYoUK9hHxPgAABAgQIpBXY/7Gr0k5JNH7d+z8UrvjY74bz1l3UdvypF78dXvjqzvDGNx5LtF6Rg9I8r125dn1412/8SVh9+bszlXDqhb8Pz/7rnwtnjh/LNL+sSUKFypK1LgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgvwJChfrrbTcCBAj0VSBLqFDZBSZ5CfOKW+4L66+/MXcpp14+FE7sfzIce/zhcHz/Ez3X6xUoFBdIUn/PjboMyLu+UKE8+uYSIECAAIHBE4j/Wvhzzz3Xt8KbQ4VmZmbC/v37F/eem5tbUkeeQKG4WNxjeno60/ny7t0pWGh8fHyxns2bN4etW7cu/HeeWrMcMIYb7d69O8R7wEWAAAECBAgQ6CQwMTER/pf7Qpg/sm9hyKCGCsX6Y2BO4+oV/JMmVKh5bFz/nhvO9ryhWuf0mtCr3l7zk34vVCiplHEECBAgQIBAEoH45043H/qDJENTjVl18cbwjjseCqsve2fXeW++8Wp4dtdPhdOvHE61ft7BaZ/XrvuRnwhXbv9iWLnmgtRbf+eLHwtv/M2fp55X9gShQmULW58AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0B8BoUL9cbYLAQIEKhEY1FChkS23hstu+mzhZi8+dFc4uveBtusmCRSKE9O+RJr2EHnXb4QKpd3XeAIECBAgQKC/Avv27Qsf/vA//KXotLvHv9Czc+fOhWnbt29POz3z+OZQoU6hO43F84b6NNbptU+7w8Tgn1hr3qvX3s1nrCJUKO/5zCdAgAABAgTqLbBixYrMBcYwofjzYvxsDZoZHZnIvG7SiXc+krz2pIE7acJ/0oQKNdeatJbWkKNeLknX7bVOr++r6HWvmnxPgAABAgQI9F+gyD97LON586Zf/8Ow9n3XJ4J59S8eCoe/8plEY4salOV57aU/f0fY8NO/mriEs6dPhqOzD4SX/vjexHP6OVCoUD+17UWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE9AqFB5tlYmQIBA5QJlvOSZ91BJXsIsI1ToxP4nw8H7b25bftJAoTg5Sf15jPKuL1Qoj765BAgQIECgfwJZ/2JPc5hQo9o6hgoVFeoTzzg3NxdiuE+aqzn8KM28dmO7BQsJFcqraz4BAgQIECDQTSBLqFBzmFBj7SqCZpr37NXl0Q0TYfs1j/YatvB987rd5iUNFUo6rrm4GCg0O787xM+kVzxfrLfsq4pel30m6xMgQIAAAQLpBYr8s8cynjeP3vdEWHXx5YkOduZ7b4RvfeIfJxpb1KCsz2vX/chPhMt+4TNhzZVjXUs5+d0D4cU/uju88Td/XlTJha8jVKhwUgsSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBCoRECpUCbtNCRAg0B+BMl7yzFt5kpcw127+QIjhOEVdRQUKxXqS1J+n7rzrCxXKo28uAQIECBDon0Dav9jTLkyoUW3dQoWKDBRq7sjMzEyYnp7u2qSy9u4ULCRUqH+/Z+xEgAABAgSWo0CaUKF2YUINsyqCZprDepL0bsvYzjA5tqvn0BjkE8+z+LNwh7CeJGFBrTUmCf5Je65YZ9Kz9Tx8ggFV9DpBWYYQIECAAAECfRYo8s8ei37evOqiy8Lo/U8mFzl7Jszf/mPh9KsvJp+TY+QVt9wX1l9/4zkrHHv84fD8g7cnWnXl2vVhw+THQgwYWnXp28N5ay8K4ezZcPb0yRDDhGKQ0JHZL4Uzx48lWq+qQUKFqpK3LwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgWAGhQsV6Wo0AAQK1Eij6Jc8iDpc0NGfsC0+F89auL2LL0MmhuZa4UbfwoUYhSevPWnje9YUKZZU3jwABAgQI9Fcg6V/s6RYm1Ki4TqFCZYX6NM4ag4Xi1RwuFPeMVwz4afz/MrrZLlhIqFAZ0tYkQIAAAQIEGgJJQoW6hQk11qkqaKZ536RdTRLA07zu6IaJEMOAWq8koUJ3PrJicVqvfWOY0ez87hA/01733HA27ZTM46vqdeaCTSRAgAABAgRKESjyzx6Lft68ECp031+GsGJl4rPP33Zd6aFC8R+92XjLvWH1JZva1nXqpUPh8JfvCMf3P5G47jjwvHUXLYx/841XU82rerBQoao7YH8CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQDECQoWKcbQKAQIEailQ9EueRRwyaWjOVXd/Pay+tP1Lm2nraOfQGij05vFj4eTBp3suveYd71sMO0oSQtRzwZYBSX06rStUKK248QQIECBAoBqBXn+xJ0mYUKPyuoQKlR0oVE2nzt21NVhIqFAduqIGAgQIECAwvALdQoWShAk1ZKoMmmkO92ntVAwDOnB0X9h7YPc5X8WgoMnRnSF+trtisE88U+NqFwjUK1Sota5uwT/tztAcZtTpjL3OUcadW2WvyziPNQkQIECAAIFsAkX+2WMZz5vf88X/Fla+ZV2iw51+5YUwf/sHEo3NOqj1uXG3dcp4Ppy17jLnCRUqU9faBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH+CQgV6p+1nQgQINB3gTJe8sx7iKShOfFfg4wBOUVcrQ5X3HJfWH/9jbmXLuOl0aQ+nYoXKpS7rRYgQIAAAQJ9Eej0F3vShAk1Cq1LqNCOHTtCDBYa5mtmZiZMT08vHlGo0DB329kIECBAgED1Au1ChdKECTVOUHXQTAwBiuFB8Zo/+tiSwKD4/ez87hA/m692YUGN73uFAnULFUoSSrRQa4e6YhhSa+BR8xnj3LGRiY6hSGXeWVX3usyzWZsAAQIECBBILlDknz2W8bx54y/fHS768ZsSHej404+HQ7/zS4nGph3UKUyo+RlwpzHHHn84PP/g7Wm3HJjxQoUGplUKJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0FRAq5AYhQIDAEAuU8ZJnXq40oTlp/lXIbnW1OhS1rlChvHeD+QQIECBAYPkKtP7FnixhQg29uoQKxUChGCw0zFertVChYe62sxEgQIAAgeoFmkOFsoQJNU4wKEEzrUFBsf4Y3jM68qEwObZrSUOazxXHxbCfxtUtVKjbd+3mN36tdY/q75ClFQxKr+topyYCBAgQIDBMAkX+2WMZz5tXXbwxvGvX18J56y7qyn7qxW+Hg/feFE6/crjQ9sR/gGbd1ZPhvLXrz1n31MuHwuEH7wjH9z9xzq/Hfwxn40fvDasv3XTOr795/Fh446nZoQwXEipU6C1nMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAZQJChSqjtzEBAgTKFyjjJc+8VacJFYp7FfHCYrdQofiy58mDT2c61utPzYajex/INLfTpLQ+retsuu2rIb7Y6iJAgAABAgTqLdD4iz15woQaJ6xLqFCsJ4YKxXChYbxmZmbC9PT0OUcTKjSMnXYmAgQIECBQH4EYKpQnTKhxkkELmmkXLrRlbOeSYKH5I/tCPNviz8XXPLoQQhSvTsFBrWvfc8PZcxoe15yd3x3iZ/MVA4saa9fnDllayaD1us6WaiNAgAABAoMsUOSfPZb1vHnd+z8ULv/F3WH1Ze9sS/3mG6+G57/0qfDGNx4rrBUL4UC33BtWX3JuOFDc4NjjD/cMB4phROuvv3FJPadeOhQOf3lpGFFhhVewUBHP6Cso25YECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQItAkKF3BIECBAYYoGyXvLMQ5Y2NGdky63hsps+m2fL0C1U6MT+J8PB+2/OtX6Rk9P6tO4tVKjIbliLAAECBAgMhkCdQoWi2NTU1GDApayynbNQoZSIhhMgQIAAAQKpBOJfBo+hQnmvQQyaaRcsFB1aw4WazxZDf2L4T7w6hQrd+ciKRc7Wtdrt2bxm3j70Y/4g9rofLvYgQIAAAQIEsguU+bx51cUbwxW37glrrnxPWHXx5SGcPRPOfP9EeO2vZsLL//l3w+lXDmcvvGVm8zPY5q+yPCsucq3CDljwQkKFCga1HAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgIgGhQhXB25YAAQL9ECjzJc+s9WcJzen0YmbSGoQKJZUyjgABAgQIEBhEgbqFCjUH7QyiZ7uaZ2ZmwvT09JKvhAoNS4edgwABAgQIDLfAIAfNtAv6aQ4Dmj+yL8TzNa7Gd+1ChVrXuueGswvT4hqz87sXPpuvGFAUQ4UG6RrkXg+Ss1oJECBAgMByEujX8+ZVF122wHr61RcL5b3ilvvC+utvXLLmqZcPhWc+/cFce11199fD6ks3LVnj2OMPh+cfvD3X2lVPFipUdQfsT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoRkCoUDGOViFAgEAtBfr1kmeaw2cJFYrrj2y5NVx202fTbLU4VqhQJjaTCBAgQIAAgQERqFuoUGTbsWNHGB8fHxDB3mV2MhYq1NvOCAIECBAgQKB6gUEPmmkXLBRV2wUIQFLWDAAAIABJREFUxV+PYUGtoUJjIxNtw4eabRqdikFCMVBoEK9B7/UgmquZAAECBAgMu0AdnzcnMY9hQhdsvi6svuTc0J8YJnRi/5OFhf4s7DN+3ZJwoVMvHQon5orbJ8mZixwjVKhITWsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKoTECpUnb2dCRAgULpAHV/yzBoqFLHWbv5A2HjLvUte/uwFKVSol5DvCRAgQIAAgUEWqGOoUAwUisFCw3DNzMyE6enptkcRKjQMHXYGAgQIECAw/ALDEjTTLlyoESzUfMYYCjQ68qGw98DuhebGMfFq/u/WkKHGXRDDhOL8Qb2GpdeD6q9uAgQIECAwjAJ1fN7czbnb8+Rjjz9cWJhQaw0xXGj99TcuKS2GCx3+8h3h+P4nBur2ECo0UO1SLAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgo4BQITcHAQIEhligji955gkVarQqabjQm8ePhTeeml3ycmgRNZR12+StbdNtX10IX3IRIECAAAECy0egjqFCUT+GCsVwoUG+ugUKxXMJFRrk7qqdAAECBAgsH4FhCpppFywUOxmDgOaP7EvU1HZj46/FQKFBv4ap14PeC/UTIECAAIFhEajj8+ZOts3PWZvHnNj/ZDh4/819aUk/a4jPhMsKKxIq1JfbxSYECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdIFhAqVTmwDAgQIVCdQx5c884bmtGqObLl14ZcuvHpy4fPUy4fC9w8+Hb5/8O86vkSZpIaNH/lcWH3lWGnNO/PakfDc1MeXrJ+ktm5FCRUqrWUWJkCAAAECtRWoa6hQDBSKwUK9rrm5uTA9Pb0wbPPmzWHr1q29pmT6Pu4T/xevWFuSwKNetkKFMrXCJAIECBAgQKDPAsMYNNMpXCgtbQwTmhzduRBKNAzXMPZ6GPriDAQIECBAYJAFin7efMUt94X1198YXnzornB07wOF0DTWbF0sPjc+/OAdpQXvdCp+4R/I+ei9YfWlm5YMOfb4w0v+QZysCPE5+WU3fTYUuWajFqFCWbtiHgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgXgJCherVD9UQIECgUIGiX/Isori8oTn9quHtH//9sO6f/GQR27Vd43vPfiN8+66fWfJdXh+hQqW1zMIECBAgQKC2Ar2Cb4osPIYENcJ49uzZsxjS02mP5tCdxphGuM/+/fvbzm83J88ZGqFFjUCh5rXiXvFqFzI0MzOzGHaU5HxJxuc5R+vcqampIpezFgECBAgQIDDEAsMaNJM3WGjL2M4wObZrqDo/rL0eqiY5DAECBAgQGDCBop43LwTt3HJvWH3JD4J2ilg3hupcvOWji2s2aN88fiy88dRsYeE9WVsWw47WXT0Zzlu7/pwlTr10KLzyZ18uJFSpEf4T1zz85eIClIQKZe26eQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBegkIFapXP1RDgACBQgWKeBmz0IJCCHlDc4qoJ0kNQoWKkLYGAQIECBAg0A+BOocKxfPHIKJ4TU9P9wwhavYqIjQnBgnF8KOkV3PIUJJ5zQFIQoWSKhtHgAABAgQI9Ftg2INmsoQLbb/m0TC6YaLfrSh9v2HvdemANiBAgAABAgSWCBT1vDkG7Ky//saF9WMAzjOf+WAu7as+//UlYUJxwWOPP1x5mFDrwZrP3vxd0Q5Fnl2oUK7b02QCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0EhArVphUKIUCAQPECRb3kWWRlSQJ9ityv3VpJatj4kc+F1VeOlVbKmdeOhOemPr5k/SS1dStq021fDfFf+nQRIECAAAECy0eg7qFCWTsRw4jGx8ezTl+YV3bQj1ChXO0xmQABAgQIEOiTwHIImmk+Yy/WGCYUQ4WG8VoOvR7GvjkTAQIECBCos0BRz5uvuvvrYfWlmxaOmif8pvlZarPbif1PhoP331xnynP+8Z2iaj8nrOnlQ+GZT+cLa2rUJVSo1reS4ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECiQWECiWmMpAAAQKDJ1DUS55FnjxvaE4RtdShhk7nyFubUKEi7hBrECBAgACBwRIY1lChGCgUg4XyXEKF8uiZS4AAAQIECAyLwHIImrnzkRWp2nXPDWdTjR+Uwcuh14PSC3USIECAAIFhESjqeXNzSM2h+38xHN//RCqi5vCc5omnXj4UDj94R+r1GmusWPOWhf979uT3UtWTdXD8x2E2fvTexYCl5nWyhC3F9eLz4cZVRr+yntU8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB6gWEClXfAxUQIECgNIGiXhosssC8oTlF1FKHGjqdI29tQoWKuEOsQYAAAQIEBktAqFDnfpVts23btrB169aFAsoOMGo95dTU1GDdqKolQIAAAQIEKhNYDkEzzWdMAi1UKImSMQQIECBAgACBEIp43jyy5dZw2U2fXeRMs+ZCCM8t94bVl2xa0o4sITxxkTUbrwojP7U9vPVHfyqsWP2WsGLVmnDq5e+EUy88G174j78ZTh5+pvTWdwxJeulQOPzldCFJzYFNLz50Vzi694Hc9TevmXsxCxAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFQmIFSoMnobEyBAoHyBNC9kll/ND3ZoDs158/ixcPLg033Z+vWnZhdfoMwb3FNmwXlrEypUZnesTYAAAQIE6ilQdnBO86l37NgRxsfHF35pz549YW5urlSU5v3SbhRrizWWeQkVKlPX2gQIECBAgEBRAs2BO5Nju8KWsZ1FLV2bddKECsXzR4dhu+aP7gtTf/XhxWNtv/bRMDoyMWzHdB4CBAgQIECgzwJFPG9ufv556qVD4ZnPfDDRKZrnNU84sf/JcPD+mxOt0Tpo7Xt/LLzt134vrLzgrW3nn3r5uXD4y7eH49/8y0zrp51UxBmv+vzXF0OX8tg01y5UKG0njSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI1FNAqFA9+6IqAgQIFCJQxEuehRTStEinFyOL3qd1veYXKPMG95RZa97ahAqV2R1rEyBAgACBegoIFWrfl5mZmTA9PV1q04QKlcprcQIECBAgQKAggXaBO8MWLjR/ZF+I50xyDVuoUAwTmj2wO0SD5kuoUJK7wRgCBAgQIECgl0ARz5vHvvBUOG/t+oWtjj3+cHj+wdu7btvpefKplw+FZz6dLJCo3QZrNl4V3vaJL4X42e168/Wj4eDnfyGcPPxML57Cvr/q7q+H1ZduWrJeEq8rbrkvrL/+xoW58R/1OfDJq3PXJVQoN6EFCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQK1EBAqVIs2KIIAAQLlCBTxkmfRlQkV6i4qVKjoO856BAgQIEBg+AWGOVRofHw87NixI1MT9+zZE+bm5jLNTTpJqFBSKeMIECBAgACBqgX2HtgdZg/sWlLGMIULxfPFc3a7hi1QaDn0terfO/YnQIAAAQLLXaCI583NATXd1ovhOOuunlwMIGrYxzChV/Z+ORzd+0Cudmz69f8Q1r7vnyVa49W/eCgc/spnEo0tatDIllvDxT/50SXhQjEo6I2nZruGMSU1TlqrUKGkUsYRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOotIFSo3v1RHQECBHIJFPGSZ64C2kyOL0NeePVk0cv2XO/1p2YXXzRNEtyz8SOfC6uvHOu5btYBZ147Ep6b+viS6Ulq67bnptu+GtZu/kDWsswjQIAAAQIEBlBgmEOFYjumpqYydaUfLkKFMrXGJAIECBAgQKAigeUQQNMtWGiYAoXmj+4Lswd2h/kj+865m0Y3TITJsZ1hdGSiorvMtgQIECBAgMCwCeR93hyDgtZff+MCSwzHOfDJq5cQxWebG2+5N6y+ZNOS7449/nDXMJ2k3itWnx/e/bm9YfUlb0805cyJY+HAjuvC2VPfTzS+yEHNZs3rnnrpUDj85TvC8f1PLNlu7AtPLYYxFWEmVKjIjlqLAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCdgFCh6uztTIAAgdIF8r7kWXqBFW2QJLjn7R///bDun/xkaRV+79lvhG/f9TNL1k9SW7eihAqV1jILEyBAgACB2gr0IzyncfgdO3aE8fHxhf/cs2dPmJubK92lec+km83MzITp6emkwzOPEyqUmc5EAgQIECBAoEKB5RIuFInnjz4WJkd3LmjHwJ1Bv4QJDXoH1U+AAAECBAZPIO/z5qvu/npYfekPwoJO7H8yHLz/5nMQmp+NNn/RbmwevZVrLgjv+bd/m2qJb/3LHw5nTp5INafIwWlsrvr81xdDmU69fCg88+kP5ipFqFAuPpMJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABArURECpUm1YohAABAsUL5H3Js/iK6rFikuAeoUL16JUqCBAgQIAAgd4Cwx4qFEOMYrBQmkuoUBotYwkQIECAAIHlKrAcwoWGpbedwoTi+bZf+2gYHRn8wKRh6ZVzECBAgACBYRPI+7y5OZzmxYfuCkf3PrBAdMUt94X119+4hCsG4hx+8I5wfP8ThVIOYqhQBFi7+QNh40fvXQxmakY59vjD4fkHb1/4pZEtt4bLbvrs4tdF9q3QRliMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgrwJChfrKbTMCBAj0VyDvy4L9rbZ/uyUJFdr4kc+F1VeOlVbUmdeOhOemPr5k/SS1dStq021fXXi51EWAAAECBAgsH4GyQoVimM/mzZvPgYy/Fv8Xr7m5uYX/tbv279/f8bu0nWlXR681pqenew1J/H23/Xt5FOnQWvDU1FTiMxhIgAABAgQIEOgmIFyo3veH/tS7P6ojQIAAAQLDLpDneXN8ZhmfXTauuFYME7pg83Vh9SWbzqGLYUIn9j+5GJJTtOuK1eeHsT1PhpUXrE+09KmXvxP+/je3hLOnvp9ofNmDFtzGr1sSLnTqpUPhxNwP3JoDnA7d/4u5gpma1yr7bNYnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoT0CoUHm2ViZAgEDlAnle8qy8+BILyBvcU2JpIW9tQoXK7I61CRAgQIBAPQXKChXatm1b2Lp1a6ZDz8zMhCKDfTIVUdCkujoIFSqowZYhQIAAAQIEFgQE19TvRpg/ui/MHtgd5o/sO6e40Q0TYXJsZxgdmahf0SoiQIAAAQIEhk4gz/PmGISz/vobF0zePH4snDlxbEmYUPzu2OMPlxYm1NyQjb98d7jox29K1KPjT/+XcOh3/nmisf0c1GzavG8MF1q5dn04b+0PQpPymgoV6mdX7UWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE9AqFB5tlYmQIBA5QJ5XvKsvPgSC8gb3FNiaUKFysS1NgECBAgQGFIBoULlNlaoULm+VidAgAABAgTKF3jkW78VVqxYGSbHdvXcTLhQT6LSBxQRJjR7YFe4/h0fD+vWXFp6vTYgQIAAAQIEhlsgz/Pmq+7+elh96aaOQCf2PxkO3n9z3wDXbLwqvOPTfxTOu3Ck654nDz8Tnvvix0L8rOvV/Ly7XY2nXj4Unvn0BzOXL1QoM52JBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFaCQgVqlU7FEOAAIFiBfK85FlsJfVaTahQvfqhGgIECBAgQCCfgFChfH69ZgsV6iXkewIECBAgQKDuAjFU6M/mPxe2jO1MFCwUzyNcqP9d7RQmFCvZfu2jYXRkomdR80f2hdn53SF+/tbEi0KFeooZQIAAAQIECPQSyPO8uVMwTQy8OfzgHeH4/id6bV/492vf+2Nh40fvC6sveVvbtc+ceC089+9+NRz/5l8WvnfRC67d/IGw8aP3dgxuKqN3RZ/BegQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAuUKCBUq19fqBAgQqFQgz4uClRZe8uZChUoGtjwBAgQIECDQVwGhQuVyCxUq19fqBAgQIECAQPkCjVChxk7Chco3T7tD3hCn5jChxt5ChdJ2wXgCBAgQIECgnUDW580jW24Nl9302SVLvnn8WPhuDO2pIFCoUcyajVeFyz/yubD68neF1Ze8PZw9fTKcPfW98Npffy0c/dpUOHn4mYG5GWKw0JW/9nvhvLXrl9T84kN3haN7H8h0lk6BUJkWM4kAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAyAaFCldHbmAABAuULZH3Js/zKqt1BqFC1/nYnQIAAAQIEihUQKlSsZ+tqQoXK9bU6AQIECBAgUL5Aa6hQY8ek4UJ5A2/KP+Hg7jB/dF+YPbA7xFCg5mt0w0SYHNsZRkcmuh6uXZhQY4JQocG9L1ROgAABAgTqJJD1efMVt9wX1l9/Y9ejnHrpUDgx92R4/sHbKzvyijVvWdj77MnvVVZD2o2j7QWbrwurL9nUdeqxxx/ObCtUKG1XjCdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI1FNAqFA9+6IqAgQIFCKQ9SXPQjav8SJJQoU2xn+d8sqxxKc489qR8NzUxxOP7zQwSW3dNtl021dD/BcpXQQIECBAgMDyERAqVG6vhQqV62t1AgQIECBAoHyBTqFCjZ2FC5Xfg9Yd8oYJxfVmD+wKMfCp0yVUqP99tSMBAgQIEBhGgTzPmxfCb8avC6sv7R5+E93ePH4snDl+LLzyZ18OR/c+MIyUmc80suXWcPGWj4aVF6wP561d33OdUy8fCif25wtrEirUk9kAAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBACAgVGog2KZIAAQLZBPK85Jltx8GYlSS45+0f//2w7p/8ZOIDfe/Zb4Rv3/Uzicd3Gpiktm6bCBXK3QILECBAgACBgRMQKlRuy4QKletrdQIECBAgQKB8gV6hQrGCpMFCcWwMsomBNq3X5NiuhXVcnQU6hQnFGduvfTSMjkz05Js/si/Mzu8O8bPbJVSoJ6UBBAgQIECAQAKBop43x38UZf31N6YKGXrjqdnw/YNPD0TI0KqLLlvQPP3qiwlUuw+JIULnv+N9Yd3Vk6lChI49/nA4vv+J3PvHBYQKFcJoEQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBA5QJChSpvgQIIECBQnkBRL3mWV2E1KycJ7hEqVE1v7EqAAAECBAikF5iZmQnT09PpJ/aYUdcwncIPOmAO4+PjIfYmfroIECBAgAABAkkEkoQKNdZJGi4Uw3HmjzwmXChJA/77mLxhTEnDhBolCRVK0RxDCRAgQIAAgY4CZT1vjsE5F149Gda8432JgnMO3f+LhQXmFNXuVRdvDJf8zKfCW6/dGlaef0EIK1aG06+8EE5+91vh+Qd2hNOvHE61VQxeiv+ATK/rzePHwsmDT4fXn5otLXBJqFCvLvieAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDAYAkKFBqNPqiRAgEAmgbJe8sxUTI0mJQkV2viRz4XVV44lrvrMa0fCc1MfTzy+08AktXXbJL5oGl84dREgQIAAAQLLT6DocCGhQj+4h+rkkKeW5fc7wokJECBAgACBhkCaUKHGnKThQnmDcsrqUgw9mj2we2H5sZGJEM9T1dWoJYYCNV+jGybC5NjOMDoy0bW0tGFCjcWEClXVcfsSIECAAIHhEujX8+YrbrkvXDB+XVi5dv05IUMn9j8ZDt5/c+1Q173/Q+GKj/1uOG/dRW1rO/Xit8MLX90Z3vjGY6lrb35eHCfHEKEzJ46FaPH8g7enXi/LBKFCWdTMIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUT0CoUP16oiICBAgUJtCvlzwLK7hPC+UN7imzzLy1CRUqszvWJkCAAAECgyFQVLhQngCbomqog3gdHPLUUAdDNRAgQIAAAQLVCmQJFWpUPKjhQjHIZ+qvPrxwjBjes/2aR/vehLxhQrHg2QO7QgxuynIJFcqiZg4BAgQIECDQKlDV8+YYMtSvAJ20XV918cbwjjseCqsve2fXqW++8Wp4dtdPhdOvHE67xcL4Kg2ECmVqmUkECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdoJCBWqXUsURIAAgeIEqnrJs7gTlLNS3uCecqr6wap5axMqVGZ3rE2AAAECBAZLIG+wT54gm7x710m6Sofx8fEQ94+fLgIECBAgQIBAVoE8oUJxz6TBQnFsDMCJQTit1+TYroV1+nVVGSrUKUwonn37tY+G0ZGJngzzR/aF2fndIX5mvYQKZZUzjwABAgQIEGgW8Lx56f2w6df/MKx93/WJbpRX/+KhcPgrn0k0tk6DhArVqRtqIUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkFxAqlN3OTAIECNRewEue7VuUN7inzMbnrU2oUJndsTYBAgQIEBg8gTzhPjHIZvPmzZkOvX///jA3N5dpbt0mVeEgTKhud4F6CBAgQIDAYAvkDRVqnD5puFAM1Zk/8lil4UJVhQrlDVUqIkyo0S+hQoP9+1b1BAgQIECgLgKeNy/txOh9T4RVF1+eqEVnvvdG+NYn/nGisXUaJFSoTt1QCwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgu4BQoex2ZhIgQKD2Al7ybN+ivME9ZTY+b21ChcrsjrUJECBAgMDgCuQJFxrcUw9m5du2bQtbt24dzOJVTYAAAQIECNRSoKhQocbhkoYL5Q3YyYPZ71ChuN/sgd0hhgI1X6MbJsLk2M4wOjLR9ThFhgk1NhIqlOcOMpcAAQIECBBoCHjefO69sOqiy8Lo/U8mv0HOngnzt/9YOP3qi8nn1GCkUKEaNEEJBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIECBIQKFYBoCQIECNRVwEue7TuTN7inzH7nrU2oUJndsTYBAgQIEBh8AeFC9e2hMKH69kZlBAgQIEBgGARmD+wKMeSnyKvO4UL9ChXKGyYU+1Flb4q8H6xFgAABAgQIDKeA583n9nUhVOi+vwxhxcrEDZ+/7TqhQom1DCRAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEChSQKhQkZrWIkCAQM0EvOTZviF5g3vKbHPe2oQKldkdaxMgQIAAgeEREC5Un16Oj4+HGCgUP10ECBAgQIAAgTIFqg6viaFGsYbWa3JsV4gBRUVeZYcKdQoTimfYfu2jYXRkoudx5o/sC7Pzu0P8LOoa3TARJkd3hvjpIkCAAAECBAgUIeB581LF93zxv4WVb1mXiPf0Ky+E+ds/kGhsnQaN//58ncpRCwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEYBoUIZ4UwjQIDAIAh4ybN9l/IG95TZ+7y1CRUqszvWJkCAAAECwyUgWKjafgoTqtbf7gQIECBAYDkLVBkuFMN45o88Vnq4UJmhQnnDkYQJLefffc5OgAABAgQGT8Dz5qU92/jLd4eLfvymRM08/vTj4dDv/FKisXUaJFSoTt1QCwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgu4BQoex2ZhIgQKD2Al7ybN+ivME9ZTY+b21ChcrsjrUJECBAgMBwCggX6n9ft23bFrZu3dr/je1IgAABAgQIEGgSqDJcKG8wT69GlhEqFNecPbA7xFCg5mt0w0SYHNsZRkcmupYlTKhX13xPgAABAgQI1FHA8+alXVl18cbwrl1fC+etu6hry069+O1w8N6bwulXDtextV1rEio0cC1TMAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgrYBQITcGAQIEhljAS57tm9sc3PPm8WPh5MGna3MXrHnH+8J5a9cv1HNi/5Ph4P03p6pNqFAqLoMJECBAgACBJgHhQuXfDsKEyje2AwECBAgQIJBeYBjDhYoMFcobJhQ7UqVx+jvCDAIECBAgQIDAPwh43tz+blj3/g+Fy39xd1h92TvbDnjzjVfD81/6VHjjG48N5O0kVGgg26ZoAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMASAaFCbgoCBAgMsYCXPNs3tzlUqM7tFypU5+6ojQABAgQIDK+AcKHiezs+Ph5ioFD8dBEgQIAAAQIE6ihQdejN3gO7F4J3Wq/JsV1hy9jO1GRFhAp1ChOKxWy/9tEwOjLRs675I/vC7PzuED+LukY3TITJ0Z0hfroIECBAgAABAmULeN7cWXjVxRvDFbfuCWuufE9YdfHlIZw9E858/0R47a9mwsv/+XfD6VcOl92e0tYXKlQarYUJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAn0VECrUV26bESBAoL8CXvJs7y1UqL/3od0IECBAgACBwRMQLFRMz4QJFeNoFQIECBAgQKB/AlWGC8UQn/kjjxUSLpQ3VChvyJEwof7ds3YiQIDrN6DUAAAgAElEQVQAAQIEyhXwvDmZ76qLLlsYePrVF5NNqPkooUI1b5DyCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIJBYQKJYQyjAABAoMo4CXP9l0b2XJruPDqydq39PWnZsPRvQ+kqnPTbV8Nazd/INUcgwkQIECAAAECnQSEC2W/N7Zt2xa2bt2afQEzCRAgQIAAAQIVClQZLpQ30CeyZQ0VivNmD+wOMRSo+RrdMBEmx3aG0ZGJrl0RJlThTWtrAgQIECBAoBQBz5tLYa39okKFat8iBRIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEEgkIFUrEZBABAgQGU8BLnoPZtzxVCxXKo2cuAQIECBAg0ElAuFDye0OYUHIrIwkQIECAAIH6CwxquFDaUKG8YUKxk1Va1f9OUiEBAgQIECAwqAKeNw9q5/LVLVQon5/ZBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6CAgVqksn1EGAAIESBLzkWQJqzZcUKlTzBimPAAECBAgMuIBwoc4NHB8fDzFQKH66CBAgQIAAAQLDJFB1WM7eA7sXAntar8mxXWHL2M621ElDhTqFCcVFt1/7aBgdmejZyvkj+8Ls/O4QP4u6RjdMhMnRnSF+uggQIECAAAECVQp43lylfnV7CxWqzt7OBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEiBYQKFalpLQIECNRMwEueNWtIH8oRKtQHZFsQIECAAIFlLiBY6NwbQJjQMv8N4fgECBAgQGAZCVQZLhTDf+aPPJY4XChJqFCWsKLmdgsTWkY3v6MSIECAAIFlLOB58/JsvlCh5dl3pyZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSGT0Co0PD11IkIECCwKOAlz+V3MwgVWn49d2ICBAgQIFCVgHChELZt2xa2bt1aVQvsS4AAAQIECBCoRKDKcKGkQUDdQoXid7MHdocYCtR8jW6YCJNjO8PoyERXV2FCldx2NiVAgAABAgQqEvC8uSL4ircVKlRxA2xPgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEChIQKhQQZCWIUCAQB0FvORZx66UW5NQoXJ9rU6AAAECBAgsFViO4ULChPxOIECAAAECBAiEUOdwoXahQnnDhGLPqzyze44AAQIECBAgUIWA581VqFe/p1Ch6nugAgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAEQJChYpQtAYBAgRqKuAlz5o2psSyhAqViGtpAgQIECBAoKvAcggXGh8fDzFQKH66CBAgQIAAAQIEqg/Z2Xtg90LQT+s1umEizB/Zt/DL8f/Hq/HfzWO3X/toGB35wffdrjh3dn532zV6ze30faxrcnTnYn1Z1zGPAAECBAgQIFCmgOfNZerWd22hQvXtjcoIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAmkEhAql0TKWAAECAybgJc8Ba1gB5QoVKgDREgQIECBAgEBmgWENFhImlPmWMJEAAQIECBBYJgIx2CcG/BR5bRnbGSbHlgYGte4xf3RfmD/yWNtwoU71xHXj+r0uYUK9hHxPgAABAgQIDLuA583D3uH25xMqtDz77tQECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA8AkIFRq+njoRAQIEFgW85Ln8bgahQsuv505MgAABAgTqKDBM4ULbtm0LW7durSOzmggQIECAAAECtROoMlwohhrF/btdoxsmwuTYzjA6MtF1nDCh2t1aCiJAgAABAgQqEvC8uSL4ircVKlRxA2xPgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEChIQKhQQZCWIUCAQB0FvORZx66UW5NQoXJ9rU6AAAECBAikExjkcCFhQul6bTQBAgQIECBAoFmgbuFCScOE4hmqrN1dRIAAAQIECBCom4DnzXXrSH/qESrUH2e7ECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKFhAqVLaw9QkQIFChgJc8K8SvaGuhQhXB25YAAQIECBDoKjBI4ULj4+MhBgrFTxcBAgQIECBAgEB2garDefYe2L0QELT92kfD6MhEz4PMH9kXZud3h/hZ1LUQZjS6M8RPFwECBAgQIEBgEAU8bx7EruWvWahQfkMrECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqICBUqA5dUAMBAgRKEvCSZ0mwNV5WqFCNm6M0AgQIECCwzAXqHiwkTGiZ36COT4AAAQIECJQmUHW4UK+DCRPqJeR7AgQIECBAYDkLeN68PLsvVGh59t2pCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgeETECo0fD11IgIECCwKeMlz+d0MQoWWX8+dmAABAgQIDJpAHcOFtm3bFrZu3TpolOolQIAAAQIECAyUQN3ChYQJDdTto1gCBAgQIECgIgHPmyuCr3hboUIVN8D2BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGCBIQKFQRpGQIECNRRwEuedexKuTUJFSrX1+oECBAgQIBAcQJ1CBcSJlRcP61EgAABAgQIEEgqUIdwoTrUkNTLOAIECBAgQIBAlQKeN1epX93eQoWqs7czAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBIAaFCRWpaiwABAgQIECBAgAABAgQIEEglUEW40Pj4eIiBQvHTRYAAAQIECBAg0H+BqkJ95o/sC7Pzu0P8LOoa3TARJkd3hvjpIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQF0EhArVpRPqIECAAAECBAgQIECAAAECy1SgX8FCwoSW6Q3m2AQIECBAgEBtBfoVLiRMqLa3gMIIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEChJQKhQSbCWJUCAAAECBAgQIECAAAECBNIJlBkutG3btrB169Z0BRlNgAABAgQIECDQF4GywoXGRibC7PzuEEOFirpGN0yEydGdIX66CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUFcBoUJ17Yy6CBAgQIAAAQIECBAgQIDAMhUoMlxImNAyvYkcmwABAgQIEBhIgTLChYqE2DK2M0yO7SpySWsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgFAGhQqWwWpQAAQIECBAgQIAAAQIECBDIK5AnXGh8fDzEQKH46SJAgAABAgQIEBgcgToGC41umAiToztD/HQRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgEASECg1Cl9RIgAABAgQIECBAgAABAgSWqUDaYCFhQsv0RnFsAgQIECBAYOgE6hAuJExo6G4rByJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwbASECi2bVjsoAQIECBAgQIAAAQIECBAYXIEk4ULbtm0LW7duHdxDqpwAAQIECBAgQGCJQBXhQsKE3IgECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAy6gFChQe+g+gkQIECAAAECBAgQIECAwDISaBcuJExoGd0AjkqAAAECBAgsW4F+hQttGdsZJsd2LVtnBydAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYDgEhAoNRx+dggABAgQIECBAgAABAgQILCuBGC60f//+EAOFxsfHl9XZHZYAAQIECBAgsFwFygwWGt0wESZHd4b46SJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCgCwgVGvQOqp8AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsIwEigwXEia0jG4cRyVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwjASECi2jZjsqAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGBYBPKECwkTGpa7wDkIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEGgnIFTIfUGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDCwAmnDhbaM7QyTY7sG9rwKJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQC8BoUK9hHxPgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQa4EkwUKjGybC5OjOED9dBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQGGYBoULD3F1nI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgsI4F24ULChJbRDeCoBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsCAgVciMQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgMlUAMF5o/+liYHN0ZYqiQiwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAstJQKjQcuq2sxIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAUAsIFRrq9jocAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECCwnAaFCy6nbzkqAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQy0gVGio2+twBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILCcBIQKLaduOysBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIDLWAUKGhbq/DESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMByEhAqtJy67awECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMNQCQoWGur0OR4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLLSUCo0HLqtrMSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwFALCBUa6vY6HAECBAgQIECAAAECBAgMmsDrr78ebr311sWy77777jA2NjZox1AvAQIECBAgQIAAAQIECBAgQIAAAQIECAyowFe+8pUwMzOzUP2P/uiPhjvvvHNAT6JsAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMDyFRAqtHx77+QECNRI4Jvf/Gb44he/mLmi9773veETn/hE5vkmVifwn/7Tfwq33XbbYgF/+7d/G97ylrdUV5CdCRAgQIAAgUwC09PT4Wtf+9rC3Pe///3hX/yLf5FpnTjp6NGjYcOGDYvz//qv/zr803/6TzOvtxwnJv35Ojq/613vCu9+97sXPn/oh35oOXI5MwECBAgQWNYCe/bsCfPz8wsGN910U/jgBz+Y2uOTn/xkOH369MK8+Gd08c/q4vXiiy+GXbt2La4X1457ZLn+63/9r+EP/uAPFqaef/754bd/+7fDhRdeuPDfzT/7vPWtb134bs2aNUu2af6ZtVsNl1566cIZxsfHF34+Wr9+faqSk9bTbdHvfve74a677loYsnLlyvD5z38+rFu3LlUdSQafOnUqfOpTn1oc+hu/8RvhbW97W5Kpi2OeffbZcO+99y7+9xe+8IWwatWqVGtkGdx878b58V677LLLsix1zpyXX345/NZv/dbir/3wD/9w+LVf+7Xc61qAAAECBAjUSSCGpTz55JOLJcVQ77Q/8zQm79y5M7z00ksL/3nDDTeEn/3Zn63TUZd1LUn/jDD+nBl/9o0/A8effzdu3Lis3RqHv+OOO8J999238J/xvv6TP/n/2bsTcJ+qxf/jy5CQMkZRUYiIcqVBPykVSZOi4UYZkiE0yFVCriEloWRIKVHSYKiuqa5biZKKkiEzFamkkVLo/3zW89/72d/93d/v3t/hnA7e63l67j3nu/faa7/2Ps46a+/1WTNxQQABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEDjABAgVOsAuGM1FAIGDU+B///ufufDCC9M+uSZNmriT2NOuJIUdP/zwQ/PLL7/YPSpXrmwnYFPSE5g8ebK56aab3J13795tihQpkl5l7IUAAggggAACf5vAv//9b3fCuCagrFmzJu22ECqUNp27Y7r96/PPP98MHDjQ/N///V/mjaAGBBBAAAEEEDggBPR7f9GiRbatZcuWNQp8VqhOKiVfvnwx/ZALLrjAfr1//347bvbVV1/Zr4877jijABqF5KRabrzxRjNlyhS3nVu3bnWDa/x9H30WFIzj7bOmcny1u3fv3qZjx46R2h61Pcna8NBDD5l77rnH3eSZZ54xbdq0SaXZkbb9/fffY8biNM46e/bsSOfpHOCjjz4y9erVc4+nOhX8lNPFe+/qWAqT6tu3b8aHfeCBB4zClZxy+eWXm9deey3jeqkAAQQQQACBvCTgfz6nkKHWrVun3MTVq1ebGjVquPuNGzfO9pnyelm/fr354osvbDNLly5tTjvttLze5LTal+4YoYI627Zta0Mu9f//jpIXnscTKvR3XHmOiQACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIZFeAUKHselIbAgggkJZAui80OgfL7VChM8880+hFRhWtiH3XXXeldd7sZAyhQtwFCCCAAAIIHBwChArlreuYaf+6ZcuW5oUXXjAFChTIWydGaxBAAAEEEEAg6wL+YJbmzZub6dOnp3ScRKFCqmTw4MGmT58+bn0LFiwwDRo0SKl+f+ikAn5Ur1OihvikGyrkHEftnjBhgqlatWrS9kdtT6JK9u3bZypVquSGMWk7hfYsWbIkJbcoG/tDhbTPY489Zrp16xZld7tNXgkV0oT3r7/+2hxxxBGR2+7fUIHnxxxzjBsor88JFUqbkx0RQAABBPKwwK+//hoTFtOoUSMzf/78lFvcr18/G1DtlJ07d5qSJUumXE9u73DvvfeaBx980B62WbNm5j//+U9uNyFXjpfpGKHCNdX/bdy4ca6013uQvPA8nlChXL/sHBABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEMi6AKFCWSelQgQQQCB1Af8LjePHjzelSpWKXJFWUU91MlLkygM2zAsvMWbS/ry0r659z5493Sa99957ubKSeV4yoC0IIIAAAggcDAKECuWtqxilf71//36zfft2s2XLFjNnzhyzatWqmJPQNdXEMAoCCCCAAAIIHNwC/lAhne1TTz1l2rdvH/nEk4UKffHFF6ZixYpuXZ06dTJjx46NXLc2fOaZZ0y7du3cfT7//HNTrVo19+uoIT7ePqvGExUW7i/qI23atMmsXLnSfPrpp2bt2rVx2ygku1WrVgnPIWp7ElXwxhtvGIWo+8vSpUtNnTp1UrIL2zgoVEj7LF++3NSqVStsd/t5XgkVUlvGjBljOnfuHKndQRvp3u/QoUPMR4QKpc3JjggggAACeVxAvzPHjRvntlJjRCeccELkVisIsXz58ubbb7+1+7Ru3dpMmjQp8v5/54aHaqjQqFGjTIkSJeLoFcyosUH1AdXn9JcuXbqY0aNH5+olywvP4wkVytVLzsEQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIEcESBUKEdYqRQBBBBITSDTiTapHS3zrfPCS4yZnwU1IIAAAggggAAC2RMgVCh7ltmoKdX+9V9//WXmzp1r2rRp404EUzsWLlxozj333Gw0iToQQAABBBBAII8KBIUKqakK06latWqkVicLFVIFl1xyiZk3b55b165du0zRokUj1a2NvG1U30R9FG+J2vdJp8+qydUKWFq8eHHMMb/88ktz3HHHBZ5D1PYkAmjRooWZNm1a3Mddu3Y1mgiezZIoVKhGjRrm448/NoULFw49XF4KFdI1UShUwYIFQ9vt30DBCCeffLLZuHFjzEeECqVMyQ4IIIAAAgeIgPo355xzjtvahx56yChEJWrx93nmz59vGjVqFHX3v3W7QzVUaOvWrTYIKlnZuXOn6dGjh5k4cWLMZjNnzjRXXnllrl23vPA8nlChXLvcHAgBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEMgxAUKFcoyWihFAAIHoAplOtIl+pOxsmRdeYszOmVALAggggAACCCCQHYF0JmgnOvIPP/xgSpUq5X6sycz/+Mc/stPQQ6SWdPvXixYtspP2ndK7d28zePDgQ0SN00QAAQQQQODQFEgUKlSvXj2jvsFhhx0WChMWKvTKK6+Yli1buvW89NJLMV8nO8CGDRtMlSpV3E2effZZc9NNN8XsErXvk26fde/eveaxxx6zk6udcu2115oXX3wxsOlR2xO087Zt20yFChXcj5o1a2ZmzZrlfv3zzz+bI488MvSaRN0gUaiQ9r/rrrvMI488ElpVXgoVUmNTub+8J6eJ8s2bN487X0KFQm8BNkAAAQQQOEAFFDJdvXp1GyaponC9NWvWRD6btm3busEzCvbbsmWLyZ8/f+T9/84NCRUK11cAufq8v/zyi91Y11j3RyrhoOFHSbxFXngeT6hQJleQfRFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgbwhQKhQ3rgOtAIBBA5xgUwm2qRL9/3335sdO3aYsmXLmpIlS6ZUTTZfYvzzzz/N9u3bzZ49e8zRRx9tihcvnlJbsr3xr7/+attz+OGHm2OPPTatVb2z3SZ/ffv377dt1EusunZlypTJ6CXl3bt3m6+//trWccwxx5giRYrk9ClQPwIIIIAAAgedQLoTtIMg0g0VUn9KfQRNjNaK29mabO30G9XvUH/NO2k+qP0//fSTbYf6KKVLl077Wmvy+rfffuv2edRvjVoy6V9fdtll7sT1Jk2aGE0gSlQyaWPUc4mynVZQ/+6778wRRxxhypUrFyn8IFG99A2jiLMNAggggMDBJJAoVEjn2K9fP6N+XlgJCxVS/0x9GWdCsoJy/vOf/4RVaz8fNGiQ6du3r7ut6ihWrFjMvlH7Ppn2WW+88UYzZcoU99jz5883jRo1ijuPqO0JAhgyZIhRsKOKJva/9dZbMSFDEyZMMO3atYtkF2WjZKFC2v/NN980F110UdKqMgkV0jif+nE//vijDRZVHzqsv+00JtG9q0BSBZOmWs455xyzePHiuN1SDRXat2+f7ccrAEp/D+i/qOeUapvZHgEEEEAAgUwFRowYYYMEnbJkyRKjcMmwoueJ3rE39dnuu+++pLtl8ns/UcUaR9TzXj3b0zO+ggULhjXdfp7tUCFnbEom6vdGbUekxmawUSb9Uh32qaeeMh06dHBb0L9/f3P//fdHalGmY7XZeh6fyfhlslAhhXLpuuv+K1GihB03TjdUy1uXQps0tl2gQIFIzkEb/fHHH0ZhpTp39a/VvnRLTvzcptsW9kMAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBNIRIFQoHTX2QQABBLIskOkLjUHN0UuO06dPtx/deuut5qqrrjKfffaZGT58uLtqprOfXu4866yz7ESpM844I646fV+TY5yycOFCdxKUJvdUrlw5bp9q1aoZvYgbVPRyoVZVHz9+vLv6p7OdXja9/vrrbZuD2uJspwkuAwYMsF+effbZtu0KKHruuefsxO9NmzbZoByVN954w5xyyin2/wftp0kuY8aMMWPHjrUTXryldu3apnPnzkaTppJNzA/y1ouUqld269atsxNpjjrqKLNy5Ur3EN72FCpUyGhF8KCya9cu66XjrFq1Km6Tc88917Rv396umKnJ5GHl888/t3VNnjw57py10qbq0n/HH398WFV8jgACCCCAAALG2MnmmlSikuqq5n7AVEKFNm7caJ555hnbv/vqq69iqtebMwYAACAASURBVFIf77TTTjOa/JFsIrQmpl933XV2X6c/ojY8+uijtu/oTH53Kv/nP/9pevToYTRZ2Snq56jfo/6ftz+lNqifosnh6h+GFR1XE9XV71m+fHnM5uqL1axZ07Ru3dr2FZNNTsqkf63r6IQH6Jg6N2/JVhu7detmNmzYYKt+7LHHTJUqVexq5+PGjTOrV6+2/VkF/GgSt2y9RZNZZsyYYb3l5L9GugfbtGljbrrppphJ+In86RuG3Zl8jgACCCBwMAt4g1kGDhxoFJTz9ttvu6escTD1Z5KVsFAh7avJ6t6xMo1baeJ3sqLf+VWrVjXq86moD/TEE0/E7RK175Npn/XLL780J5xwgnv8iy++2I67+UvU9vj306TfE0880e3Xjhw50tx+++3m6quvtn0flXQDcxI5+0OFXnrpJTsm5vSv1J/VWFyysMxUQ4V0TJ2PxiLffffduKY1bdrUdOzY0fYDk03M9t67GsP09p8TBT4lctB93qBBA/djb31RQoXUb5Wd7s+gYCKdk+5fBXjmlZCBg/nfNc4NAQQQQCC6gIKxtciIU+64446Ezze9tT7//POmVatW7rc2b95sKlasGHfgbP3edypWeJ+egz755JPm1VdfjTue+kp33nmnadmypV1AxSmvvPKKefrpp92v9czYGUvU+Jf6FUFl2rRpgYuRqJ+qfqCeNWobf1E7FMajZ77JAl3Sfd4b9Qqn2y916lf/tG7dujH9LIUFaQw1qGQyVpvN5/HZGr8MChXSM2+NGWsM01+i9mO1n2x1D+tenjdvXlxd6o/q740+ffpECgXS/fzwww/b9yP84+SqXD8TN998s1Ebw8KPsv1zG/V+ZTsEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQCAnBAgVyglV6kQAAQRSFMj0hcagw3lf8tMkZQXvaEXDsNKrVy8zePDgmNX/Lr30UjNnzpywXWM+12RzvVDrL5qUdcUVV8RNfA6qXBO69aJg0EqEWs1dE1pUrrzyShsmpGCkoMCdTz/91OjFQxX/fnpRUS/Krl27Nun5aWL2a6+9lnAyvN+7YcOGdhJ/UNFqi07xtkff837mbPPee++ZSy65JJKZ2qlJSTVq1Eh4PgoI0EvRUYpCjuRLQQABBBBAAIHkAplO0PbWHjVUSP0fBexEKeqbaYJvsWLF4jb3H08TYxRCFDTB2buzJgxpgre2v/DCC82iRYuSNmXChAmmXbt2Cbf5+OOPbRBm0KQP/06amKTwoURBRZn0r9U/1IRnp3j7Z9lso/qKzsTvpUuXGvVZ27ZtG+dzzTXXGE38cso333xjGjduHBe6FASrSWEKkUzWn6NvGOUniG0QQAABBA5mAW8wywMPPGCDpU899VR3HEbhyytWrDDFixdPyBAlVEi/608//XS3jlGjRpmuXbsmpVX/yjvB+/3337djfP4Ste+TjT7rvffeax588EHbBAXuqG+Sbnv8+2mCvCb5evs9OsasWbNsGI1TPvzww6Rh5Kncr/5QIYXrKChc45dO8ffH/PWnEiq0ZcsW24dW/y+saOxz0qRJCSdRe+/dQYMG2W2dMc4mTZrYwIGoRf1wJ5hA95jGNh966CG7e1iokMZjmzdvHjq+qroUXDR16lRTvnz5qE1jOwQQQAABBHJcwBtgqLEULY6SKDTGaYzGZt588037ZaLfu9n8va/jKMhbQUbOcZPB1KtXz/ahjj76aLvZsGHDTM+ePVOyDArbVgUaS9QYVlCokf8A6stpu6A+rLZN93lv1BOJ2k9OVp+eketZuVMUzh00JpnpWG22nsdnc/zSHyqkBX/UB/UHnPv9NBapBYYS/Q2le1kh994w10TXQPeQArGaNWuW8DIpkP22226LdFuobQrpL1myZOD22f65jdQoNkIAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBHJQgFChHMSlagQQQCCqQDZeaPQfy/uSX7du3cyLL75oXzZ1iiZE6SW8oAks48ePt6tHOkWT1fUiZCpFwUS9e/eO2UUrVurFWn/Rau+lSpUyy5Yti5tErpAjZ6KSdz//S6bHH3+8efzxxwOb6H2507ufJrFo4pAmIjlFL8g6K3H7X4jUZ6tXrzYVKlSIO47XWxNuFKjkXR3cW//PP//s7h8WKqSVTdUef1tOOukkG1qktvsn3qudmkAUtNq9gpo0gcxbtH39+vWNVhXViqD+Y82ePTtmQlcq9wHbIoAAAgggcKgIZGOCtmMVJVQo0SQVhe1oVfSVK1fGTepN1K/yH0+T2739KvUbjzrqqMDwxvXr15shQ4YYBQY5RX1M7RPUz1S7gsIP16xZY6pXrx53u6jPU6dOHbNp06a4+jQ5ShPrgwIoM+lf33PPPe4EajXICRXKdhu9oUIvvfSSufbaawN/XDRZTMFAKlqNXkGhflv15xo1amSdgvqgWu1bk938hb7hofIvFOeJAAIIIJBMwB8qpNAchZ7ccMMN7m4333yzmThxYsJqooQKaee6deu6v8c13qOgoWSlc+fOZty4cXYTBUlrjMt7LGffqH2fbPRZp0+fbhSy45Qff/wxbrJw1Pb4z907ob9ly5ZGfSSVvXv32vE4Z2yzU6dOZuzYsVm5sYNChTRW6bXXgTTxuE2bNoHHjBoqtG3bNtvn9Y+96V6oXLmyUX/TH5iutmiydcGCBeOO7b93ZaR71SmffPJJwtBzb2Ua7/T20RVYrjHCKKFCn332mRvm7q1TfxNUrVrV9k3956vPtJ/+l4IAAggggEBeEPAHGL7++usxgYb+Nn755ZfmhBNOcL+tPov6Lt6S7d/7Gr9TnyEojFv9haDfueo/qj9QpEgRO3Z3yy23pMStsab58+fH7PPrr7/aPq1/sRbn+eq6detinkc7O6s/o9BCf0n3eW/UE0m3X+qtXyGa3meuQc9NszFWm43n8dkev/Q+/1bf7bfffovp2yV73yBRP1b9b42LBt1DuucU6hV0P2/dujUwmFKhVQrI9BeNkx977LFmwYIFcf1RtU3fz58/f47+3Ea9T9kOAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBDISQFChXJSl7oRQACBiALZeKHRfyjvS37ezzQZRBN/NFFF5c8//zSPPfaYufvuu93N9OLnxo0bTZkyZez3NHFnz5497ueayOxMcNEK7t27d48708MPPzxmsotW+D7llFNiXiTVBHQd1zspRsFCeqnVO1H63XffjVmVXQfzh/E4DVDbtdKmXhSsUqWKKVy4sJ1Y75RE+3Xp0sVoQlLNmjXtC4SaPK4Xbf1tUSiSVqT0T+BK5K0XdhXqVKtWLTv5SRPyvRNmwkKFvKu/6xy0ir1WB/ee0/bt2+0Kjffdd597nu3btzdPPfVUzHV57733jF6SdIra8eSTT8asvK7PXnnlFdOuXTv3BUuZaoJ66dKlI97RbIYAAggggMChJ5CNCdqOWlio0Pfff29OPPHEmN/VCpBUYGKxYsVc/CVLlhhNRvFO0AgK9fEfz6lAITd9+/Y1p556qv2WJgOrz5QobFKTPhQGqYlF6k/98ccfpl+/fjEBPerHvPbaa3E3yHnnnWfU53OK+qeajOWdsKPJWLfeeqtdZd0p6u+o3+MvmfSvL7jgAneVbPUptbq3Srbb6A0V8rZfq26rvy53rZhdrlw5o/6Yin9ldPVfNeFd2zqTYHSddP7eyTQKZ9KkIm+/m77hoffvFGeMAAIIIBAsEBQqpC1vuukmN9hPXwdNFndqjBoqpIAg/e52iibLaswoqOzevdv2hZxAlkceecTcddddgdtG7ftko8+qsTv1kZyivpL3a30/anu8J6NJwpqU7BT1ey655BL3a/UrBw4c6H4dFGaUzj2eKFRo165d9ry8fWlNktd4o79ECRXSWKP6eTovp6ivPnLkSBu27hQFJ915551mypQp7vc0/qoxQn/x37u6PxRw4IQvqf5JkyaFsqiPrTFCFfUbdc4aZwwLFdI9qqBPbxCS+rEjRowwCoBX0XmvWLHC9uMVVOSUpk2b2vFd/0Tu0MayAQIIIIAAAjkgoGel6oc4v0O94YZBh3v44YeNnguqaMxGoTMK7nFKTvze1zjdyy+/7B5D/RQtEqMwbv0+1cIhCqwcPXp0TPj3gAED7Pie2qTf3U5R30LPHFX07HPatGlxp6ogbz1n9RaNw+mZpFMUTKjwxTPOOMP9vS4P9SX8IeQal3SePTv7p/u8N+ptkE6/1F+37Lx9FvXfbr/9dnezbI3VZuN5fLbHLxM9/1YgvcZ5nXAttV3XsmPHjnHvAijA3Vt0T95///3utxTcqftF7y44f1epj66/XbwLD3mD17316b0FZwEh/Txq7Frj5BpXVdH127Bhg10MyfszpBB31ZmTP7dR71O2QwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEclKAUKGc1KVuBBBAIKKA/4VGTZBxXnRLVsVFF11kqlWrFrhJ0Et+mrikl/mCiiaOaHKHU8aMGRMzycm7j/flvGQTmrz76KU/7+SXmTNnmiuvvDKwLXqpVeflrLbZvHlzo1XQvSXoJVO9IPjCCy/Y8J5EJWi/Dh06mCeeeCJwpXe9BNmiRQujVQ6d8sEHHxgZeEuQd9euXc3QoUNjXiT2tyssVMi7gn2vXr1iXp7016UXMPUipl7i1Aua9evXj9mkcePG5s0333S/t2XLlpiVVL0b+1cZ18uht912W8Q7ms0QQAABBBA49ASyMUHbUQsLFdLEcvWtNLlYJSiA0anL/zs9aEJyUKiQAoI04blQoUJxF9M7edn5UBOIFFJTvHjxuO3btm1rJk6c6H5fgYgKyvEW9UXVj1H/b9iwYaZHjx6BN5FWw65UqZI7OeXiiy82b7zxRty26U4Y0sQSTdJyyqBBg9zgxmy3MShUSJOy5JWoqI/nTO7WBG71S/1hl86+c+fONZqsrVXstd91110XMwGKvuGh9+8UZ4wAAgggECyQKFRIoTUK/HHGpzRBVROhnbAUb21RQ4X8/S79jlbodlBR6LMmtDvl66+/jglc9O4Tte+TjT6r/xymTp1q+xnptMe7z+DBg02fPn3stxSErZAhbyDi+vXrTdWqVd1dNJbnHctM9/5OFCqk+vxhQWeffbbte3vbFbSd6lTgurf4Ax0VHDR8+PCEzZapgqxUdO9psvphhx0Ws33Qvas6vX3pzZs3x4ST+w+o4E7vWKoT2untdyYKBtU1UMilUzSm7VxD/3E0xqrw9meffdb96L///a+58MIL07107IcAAggggEBWBRRq4oy1qWL97vUG/3kPpmeYTvBg0O/0bP/eV4ijQnucouem6oMFjdvt27fP9iFnzJhh+xDqY2nxE3/xLmqi4EM9rwwr6gs74ePaVuNOen7rDx5y6vE/e9ZzzP79+8ccJt3nvWFtdT6P2k8Oq8/7vFYhoXqO7pRsj9U69abzPD7b45dBz7/9YTxeO/3cnH766TF/Qymsy3uPvPPOO3a8ddGiRfZdAf3d4+9fO3V6+8T6nkLsvX3in376yZQoUcJtgu4n3c9BRX30K664wj4r1zN89Zk1zuyUbP/cht1TfI4AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCOSWAKFCuSXNcRBAAIEkAv4XGqNizZs3z2gycFDxv+Snr50JyEHbaxVOrUTtTJRKNrElnZcYa9as6a5aHRQS5G+TVsRUmI9Tdu7cGRO0FPSSqSYblS9fPimffz9NmJdjopcVVZnCd7wvFfbs2dOGBXmL31srhGpVxLDVtsNChbQq48aNG+2hogT7aCJQkIEm7x977LFuk7X6qF6YTFa6d+/urlKqSetLliyJemuyHQIIIIAAAoecQDYmaDtoYaFC3v6R+m4KjUlWrrrqKjcgUSs/a/Vwb/EfTxOO1P9JFHKpSUlXX311TB3JwgqXLVtm1DdyyuLFi81ZZ50V12T1R9XfOPfcc5Oez6OPPmruuOMOu40mnGv1c39JdcKQJv8o0Mep16lv1apV5pRTTnGrz2Yb/aFCQX1M/3kp5NGZtBSlT62+ofqA/uAh+oaH3D9RnDACCCCAQBKBRKFC2mXhwoVGIdZOOf/8842CUAoUKBBTY9RQIe3UunVr89xzz7l9GX94jlPxZZddZmbNmmW/DPu9H7Xvk60+61FHHWXUf1IZOXKkuf3222M8orbH2UmBMwq20YRjFbWzX79+cVftggsuMG+//bb9vvrAn376acb3drJQIVXuD0oPaps/fCgoVEhGjz32mHvdFZKkfneion6+N8BKgZ+XXHJJzOZB964mVms/5/rcddddRqHwiUrfvn2NgjRV1LdWCFGRIkVsKKUzlpwoVMg7RqyQ0U8++SQu+Mh73B07dtjxZ6dtN998c0z4aMYXkwoQQAABBBDIQGDNmjWmevXqbg3jx483WpTEX/Tsz7vwyNKlS02dOnViNsv2732Fn3jDCJONw6khv/76qw370fhdsWLFAlXSCRXq3bt3TCDmhg0b7O/2ROWvv/4yeg7r9N/U19BYlbcvne7z3qiXOtV+aaJ6FUKuMHIVBeFo8Rx/0bPsbIzVOvWm8zxe+2Zz/NL//FuhUAqHSlb84aivv/660d82/qKwdIW4Fi1aNGF1+vlSoJNT1q1bZ6pUqeJ+7Q/IVH9UY66JihY22rNnT+C4d7Z/bqPeo2yHAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgjktAChQjktTP0IIIBABIF0Q4VWr14d84Kr91D+l/w0CSpsgnb79u3tZGoVrS45e/bswNan+hKjVlL3Bt0kennQe7DvvvvOTmRxil7S9a7C6X/JdMCAAUaTYMKKf7+g1dSD6ujYsaPRC8QqmhSvVUGTeesF2YYNG4Y1x678qYk5TtELtt6i0CitmKiSSbCP/wVOf0hTUEP1QqwmrTll//79cRPSQ0+QDRBAAAEEEDhEBLI1QVtcUUOFotJ6V1oP6k/4j5doYoxzPP8EZ00g1krliYr6EN7JQlH7X4nqe+ONN0yTJk3cjzUp2T9Byt+/7tWrl9Hkd2/Ryu2aeKKJWOorO5ObnW0U3qOVx9MpUdroDRUKC3Jy2jBkyBCjCVxO0cTs0qVLp9xE+oYpk7EDAggggMBBLJAsVEin7Q1d0dcPP/ywufvuu2NEUgkV8vdTNO5z0UUXxdSX6lha1MnS2eqzZjtUSIE5l156qWuQaIL6888/b1q1auVulyisMpXbNSxUSIFHmgz/7rvvutW+//775uyzz3a/jhIqVK1aNbN27Vq7T5QwSW3nDWlXkIBC4L0l0b3rn/D//fffm1KlSsWx/Pzzz+a4445z+8EKUFK/WSUsVEj90KOPPtqtM2ofX2O4zkR09YHVBgoCCCCAAAJ5RcD7u1W/6/U731/0+1ihiipBzwv1/Wz/3vfWpwVDtHBIpiWdUCFv30RjZk7wdbK26HmpgiGdsmLFCtvHcUq6z3ujnn/UfnJYfTfccINRf0clbOw0rK6wsVpn/1Sfx4cd1/95lPFL//sGX375pe0/Jit61q3gH2fRnLCFj5LVpYAsbxCnf8ElBSgVKlTIrUJ9WfVp0ynZ/rlNpw3sgwACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAII5IQAoUI5oUqdCCCAQIoC/hcaNbGiePHiobV06tTJrhwdVPwv+emluyOOOCJpnQMHDnRXAT/55JONVuUMKqm+xLhs2TL7Yq1TNm3aZCpVqhR6ft4JSq+99lpM+I7/JdNFixaZ+vXrh9bp3y/Ky4+qdMSIEUYre6sETXjxe+slxoIFC6bcHn+okPelXlV2/vnnG63irVVPZRjlPtF+jz/+uOnWrZttj1721HmHleXLl8es5phoAlJYPXyOAAIIIIDAoSCQrQnassokVEiTnp2gHPW59N+sWbOMAhpVtHq4Jml7i/946hP26dMn4WXzT9ZQMOVTTz2V9DIff/zxdqVup191xx13RLot1DdS2OTmzZtt+I/avmTJEjNjxgx3/y+++MKofm9JN7TTqUPhPZpIHaWk20ZvqNDFF19sNJEnrPgn3Ot6qo+n/nnlypVtKKc31CBRffQNw6T5HAEEEEDgUBIICxX6448/zDnnnGOWLl3qsuj/a2zGKamECinYUGM6Tt9I4zwTJ06MIddE8e7du9vv6fe7tj3ssMMSXpaok6Wz0Wfds2ePKVy4sNsW9QPVH0zWF9u6dWtM4Lj/RK666irz6quv2m8n6xft3r3bHHPMMW4ITpR+aNi9HBYqpP3VF61du7Z7XPXBNN7phFZGCRXy3iOTJ0+OCUdK1MYWLVqYadOm2Y979Ohhhg0bFrNpontXfw9UqFDB3TZR3/bRRx813n65N4Q8LFTIP2746aefWqOwovPReTll165dpmjRomG78TkCCCCAAAK5IjBp0iT7DM4p69ats+EoTlE/SKF6TjD12LFjjZ7V+ku2f+9760t0zFSB0gkV8j63HT16tOnSpUvoYbdv326OPfZYdzt/oGa6z3tDD/z/N4jaTw6rT8FICkhSad26tdG9EqWkM1br1Jvq8/hk7Ul3/NL7/DtoXDnRMa+44gqjRYZUFAqq/m+U8tNPP9kxYPW/Na6tsWBviNYLL7xgrr/++piqvE76oE2bNvadAoVXVaxYMeZvl2RtyPbPbZTzZRsEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQCA3BAgVyg1ljoEAAgiECGTrhUbvYbwv+SVaKdPfrHHjxhmtLKmSzVChuXPnmqZNm2Z0Hzz33HPmxhtvdOvwv2SqyVXeyTKJDubf77fffov0MuHMmTNN8+bN3Wr9oUHpvlTpb48/VEiT6DVB3HlB2X9eCjjShB1NSteq9nqptUSJEnGn71+hPJ2LoRc49fIlBQEEEEAAAQTiBbIxQdupNZVQofXr15spU6YYTWRWIOTatWuTXp4ooUKzZ88O7bt5JxFpVXKnD5no4HXr1nUn4j/yyCNuWKN/+x9//NE8++yzNjhIK5drsnJYyWaokEIke/bsaSerJyrZaqM3VCjq6u779+83l1xyidEErERFfX9NmlEYpfqHJ5xwAn3DsJuIzxFAAAEEDmmBsFAh4aifVb16dddJ42YKlXHCUFIJFVIlgwYNMn379nXr+/nnn22ItVO8/QRN+H7ggQeSXqOoY4vZ6LNqcr3O3ymaXN2wYcOY9kVtj3ZS8LW3vzJ16lRz3XXXJTxfBSoqINEp3iCcdG7kKKFCqvf555+PCQJq166dmTBhgj1kWKiQxvWcAKJ02qh9OnToYMaPHx+ze7J799ZbbzVPPvmk3V731jfffBMTTq+wLAVzfvvtt3Yb9YGHDh3q1h8WKqRAzCZNmrjb6xyLFSsWenr+8HlNFNffKBQEEEAAAQTygoD/d7b6Tv369XObppAUhaU4JWgxjmz/3teiMd5+4rx580zjxo0z5ko1VEhBgN7f9VHboeee+fPnd9urMB6F8jgl3ee9UQFS6Zcmq7NcuXJuv2nAgAExfXnvftkYq3XqyyRUKFvjl97n3+eee65ZuHBhJHqNsWrBHpVGjRqZ+fPnx+2nwKWXX37ZhjVpDHjlypUJn4c7OweFCi1YsCDu7xHvwbTYzimnnGLq1atnx0p1HoUKFYppT7Z/biMhsRECCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIJBLAoQK5RI0h0EAAQSSCWTrhUbvMbwv+V155ZVGoThh5YknnnBX1MxmqNBrr71m1IZMSliokF48LFCgQOghwkJ8ElXw3nvv2ZcMneJfRdvrrQk1ClKKUqK0Ry9Stm3b1p2In6xevVj8zDPPmGuuuSZmM61mPnz48ChNSrgNoUIZ8bEzAggggMBBLpCNCdoOUZRQIW0zePBgo4CeVEqUUKGPP/7YKJgmWfGGCk2fPj0mfDFov7BJMAps1KRs9akShSkmak+UUKGBAweakiVLxlVRvHhxU6lSJTuRvXz58qZgwYIJTzvbbfSGBTz00EP23KOUHTt2mNtvv92GSUUpujc1Ueywww5zN6dvGEWObRBAAAEEDhWBKKFCslBAi4JanNK1a1czatQo+2WqoUJbtmyxfRCnTJ482Q2s0TiQ+glOWb16dUygUdB1iTq2mI0+qz9MJijoO2p7dC7+gKVPP/00JvzGf74Kn2zVqpX77dGjR5suXbqkfbtGDRXSARR47u2DaRJ0ixYtQkOFFDhQpkyZtNuoHVMNFdJ9U6NGDfeYun9vueUW92t/SJK/Tx0WKuQf7/UHpSc62W3btsUEw69atcpO8qYggAACCCCQVwQ6duzoBvkpjET9NicUR7/3p02bZpuq/oj6cP6S7d/7/vqWLl1q6tSpkzFXqqFCmbRDi6ds3LjRtlkhierXOMX/nDTq896oAKn0SxPV6Q92CgrBzOZYrdOOsPHUoPZme/zS+/z78ssvN+oDRikPPvigHY9UCQoj0t8Ud955p1FfMJUSFCqk/TU+rdB2JzAzWZ1arEc/u/pfp2T75zaVc2JbBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgpwUIFcppYepHAAEEIghk44VG/2HyUqjQnDlzzKWXXuo2USt5eydbRSAyvXr1MlWrVnU3jRLGE1Svf7/du3cnnajk1OE/B004Ovzww91DpOOtnaOeh16ifeedd+x/ixYtMitWrEj6YqRWS73sssvc9nknAumb7du3j8LublO0aFGjye5FihRJaT82RgABBBBA4FARyMYEbccqLFRI/RBNNF+7dm0MF08gsgAAIABJREFUb9myZc1ZZ51lJ51XqVLFaMKOQoQ0SaNTp05227waKqQJzgoV8haFJWoFaU2G1vnoP7Vf5+8NPYoSKrR161YbGpRJyXYbvaFCI0eOtEFBqZRly5aZt956y2g17s8++8ydnBVUR8+ePc3QoUPpG6YCzLYIIIAAAoeMQNRQIYWmNG/e3Lz66quuzezZs03Tpk1TDhVSBZdccomZN2+eratRo0Zm/vz59v97x3CCJuAGXZioY4vZ6LMqxEeBSk7Zt2+fO9He+V7U9mi8q0KFCpEm/ya6IdVXXLlyZdr3ayqhQuqnq6/tTFZWf1XhPV9//bXttzrFP274008/mRIlSrifa1vvJOYojde916xZs5hNw+7dq666yr1f1Y/W3w8KZde9fPrppxsFWKm0adPGhpR7S1io0KxZs2LGHvfs2WMKFSoUeiqff/55TIiQvq5WrVrofmyAAAIIIIBAbgn4Fxl59913jX7n+kNH/vvf/5oLL7wwrlnZ/r3vr0/jQA0aNMiYI9VQoR9//DEmsFvPK88777xI7fCGk2v8T8+JnRL1OWmkAwVsFLVfmqx+f+jnRx99ZOrWrRvT98vmWK1TcTqhQtkev/Q+/476t4na772/dL/qvnWKFhJq3bp1HLn6yLVq1bLvAzhj2yeeeKLtKzr970ShQqpMPyv6uXz77bdt6Kf+RkgWXu8NR832z2269yv7IYAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACOSFAqFBOqFInAgggkKJANl5o9B8ynZCbJ554wp1wfvLJJ5s1a9YEnkmqLzEqAEcvATrlm2++MZr0nklJ9yVT/35RJ66MGTPG3HbbbbbJmjD0888/xzQ/HW9VkO55aF8FIm3evNl8/PHHRu1bvHix2yb5akKTs3rquHHj7AqNKplOtsrkurEvAggggAACB6tANiZoOzZhoUIK+tMkX6cofLFLly7mhBNOCOQdOHCg6devn/0sL4YK+SdrXXnlleb++++3wUlOX8Z7Ypq0dP7557vfyo1QoZxoY6ahQv6LrZXIZaH+7bPPPmtefvnlmE28/V76hgfrv0ScFwIIIIBAOgJhwSzeOjWZVWNc3lCZ9evXm3LlyrmbaZzvggsuCG2Kfldfe+217nZbtmyxIYjekB0FvSjwJaxEHVvMtM/6xx9/2ECYjRs32iYp6FHjUv4StT3+YJqw80z0uQK469evn9buqYQK6QD+vujFF19sBg0aZMM9neIPFdL3vZPpp0+fbgOqMi1h966/DztjxgyjoCGFjjZp0sQ9vCbKe8du9UFYqJAmanuDlNatW2cnf4cVf3D7zp07YwIKwvbncwQQQAABBHJaQOF7ChF0wrwV1D127FjjfYZ63HHH2edzCusLKtn+ve+tb9KkSYGBLKm6pBoqJBfvOF3Ufqo/rEXPRb1BiZk8J41yzlH7pcnq8gf1aOzWGxiZ7bFapy2pPo/PifFL7/PvoOfjidz0d44zNtmyZUvz0ksv2U31fF0/P07Yj55ZDxs2zP79VLhw4bjqFFzp/X6yUKGgtqivqZ9V3QePPvqoUZCQUxRspJ8np2T75zbK/ck2CCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAbggQKpQbyhwDAQQQCBHIxguN/kOkE3KTU6FCCr854ogj3CZ+8MEHRi9CZlLSfcnUv59WhG/cuHFoU3r06GGGDx9utwsKXErHW3Wlex5BDR46dKhRqIBTNMFLKziqaGVGTXJyStAq8qEIbIAAAggggAACCQUynaDtrTgsVEiroKv/qNK1a1czatSopFfmhhtuMFOnTrXb5MVQoQceeMDcd999tn2aSPLJJ5+Yww47LOE5jR8/3nTs2NH9PDdChXKijdkOFfKDKXDynHPOcb89efJk06pVK/qG/DuGAAIIIICATyAsmMUP5g9Fufzyy83rr7/ubhY1VOi3336zYUTOhFqN66h/4A170aRbTd4NK1HHFjPts2oi7h133OE2Z8iQITFhl84HUdtzxRVXuHY6z7p164adqvv522+/7f5/BS9pYns6JdVQIR3DOwlfX19zzTVm2rRp7uGDQoW895kmTmusMdMS5d71bqMQoCVLlhjv3xOa1K/xSX8JCxXaunWrnRDulKhjrI8//rjp1q2bu58CCigIIIAAAgjkNQE9D3R+V6uPsn37dhtw/eGHH9qmKsC7T58+CZud7d/75513nnn33Xft8fr372/DuDMtqYYK6XiVK1d2wyV79+5tBg8eHNqMZcuW2SBKpyiQ0vt1Np+TBjUmar800YmovWeccYb7sZ61KqDRW7I9VuvUnWqoUE6MX3qff6td+tulWLFiodfdO+7ZvXt3G+ijsnDhQtOgQQN3fwWrJgrK10arVq0yNWvWdLdPNVTI21A9G1eYvYJNVdSX/fLLL91Nsv1zG4rEBggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAQC4JECqUS9AcBgEEEEgmkOkLjUF1pxNyk06oUL9+/YwmJIUVTZJyVnHXi6p6sTGTku5Lpv79vKsjJmqPXpDUSttO+/0rF2q/dLy1X5Tz0AuTCmWqWLFiUjK91Hzssce62yhISC+yqihgSC/7OkUT4C655JJMLgH7IoAAAggggIBHINMJ2l7MsFAhb79KqzyrP5OoaCJ61apV3X5MXgwVuummm4wCb1S6dOliRo8enfTeuuyyy9zJH9owN0KFcqKN6YYKqU+qCS9RJt1r0o36kiqacKaJZ/QN+acLAQQQQACBWIEowSx+M02MTRTsGDVUSHXeeeedZuTIkbZ6hVhrwvKUKVPs1x06dDAKU4xSoo4tZtJn3bBhg6lTp44bgqR+5cqVK03hwoXjmhilPerDece6xo0bFxMcGXbet9xyi5kwYYK72ffff29KlSoVtlvc5+mECu3Zs8fUr1/fLF26NPB4QaFC7du3N08//bTdXuE+Cl3Ply9fyu317hDl3n3ttdfs5GmnKNDo7rvvdr9WOFPDhg3j2hEWKrR//357/b766iu7r44xc+bMpOfz559/mlNPPdWsXbvWbhc0KT8jEHZGAAEEEEAgSwJff/21KV++vFubxlS8z0I3bdpkKlWqlPBo2f69r3Btp1+oIJR169YF9sG8DVJ/5fDDD0/YRgV8O89qzz33XBv2Elbatm1rJk6caDcrW7asWb9+fWgAZufOnY36eU7ZtWuXKVq0qPt1lOekYe1K9nmUfmmi/X/99Vf7LHXRokXuJqtXrzbVq1eP2SXbY7VO5d5QoSjP43Ni/NIfKjRmzBija5qsfPTRR7a/6xT12du1a2e/VH9YPx8qQePU/nofeeSRmL5rUKiQQip1/yqsyrvIUVAbZ8yYYa6++mr3Iy2MVKRIEft1tn9uM7lv2RcBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEMimAKFC2dSkLgQQQCBNgUxeaEx0yHRCbqKGCl133XVGE9hVtBq7JqeElVtvvdU8+eST7maaCO1dzdq/v1Z51MQqrXiuVcv9Jd2XTP37qd6wyV5abVPtcIrq0Cre3pKOt/ZPdh6arKVjy1pW7733njn++OMTUuvFR+/Lkm+99ZZdOVVl7969plq1au4KorVr17YTnwoUKJCwvkGDBhnVoclttWrVCrvEfI4AAggggMAhLZDJBG0/XFiokH6nOxNxNbHirrvuSmivz0aMGOF+nhdDhbp162Yef/xx20b1sdQ/SlReffVVc9VVV8V8nBuhQjnRxlRDhRR0qcleDz74oD3/N99801x00UVJf+68K9nrHtUEJPqGh/Q/VZw8AggggECAQJRgFv9uGoNRwI7TJ/N+Pn/+fNOoUaNI1suWLbOTX4OKJi8ruCZKiTq2mE6fVeExGjNU+KO3zJ492zRt2jSweVHaM2DAABt66JSdO3eakiVLRjldu43GyTQB3ikKeeratWvk/Z0N0wkV0r6aUF6jRo3A4/32229xE/2ff/5506pVK3f7adOmxUxo9lekPq7GXRVurhCrQoUKxR0ryr27b98+286ge1WTvZcsWRJ4DmGhQtrJfw2Dxky9levvEu/fLgrQuuGGG1K+ZuyAAAIIIIBAbggoeEQBJP4SJRQv27/3X3nllZhQ8YceesgudpKoOONn6hv16NEjMADJ+0z4yCOPtIHkQWGR3mPomaG3n9urVy93nCqoLR9++KFRMI5T9KxYx/WWdJ/3Rr0HovRLg+rSuSqkxwlQ1DaJzjfbY7VOe1J9Hp8T45f+UCHdK1rIpkyZMoGXQH87qI++ePFi9/MdO3aY0qVL26/997JCJwsWLBhYl+z9z8X9oUIKyFQbda/pbxOFXAb1m50D+O9hhW8522f75zbqPcp2CCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBATgsQKpTTwtSPAAIIRBBI94XGZFWnE3ITNVSof//+MStyTp061ejFxmRl27ZtpkKFCu4mWn1dYTmaTO0v/hf6NNlEE+a9Jd2XTINChfQC5OjRo+0kHW/RBLE+ffrETcRftWpV3Oqe6XjrWMnOw39fyOydd94xxxxzTJyZVmHUy6wPP/yw+5le6jzxxBPdr2fNmmUuu+wy92utIK6gp6OPPjquPr2QrMlDTpk+fbpp3rx5hLuZTRBAAAEEEDg0BdKZoJ1IKixUyDuhRP2YFStWmBNOOCGmOk2O1iRfbzCiNsiLoULePqjamGiC+nPPPWcnsytcx1tyI1QoJ9qYaqjQd999ZypXrhxz/snCBjSJxtt/mzx5csxEdvqGh+a/VZw1AggggEC8QJRgliC3RIFAqYQKqV5vn8A5jsaAPv/8c5MvX75Ilyzq2KK3z6p+4bp16+Lq10TgLVu22BAatUHhN+pzeIv6GBorSlTC2qPwa40TavK6isbkJk2aFOlcnY00Fla9enU3LCdVM6eedEOFtP/YsWPjwpb0/aBQIbmeffbZdsKzivrxEyZMiAkIcNqkCdQNGzaMCQf/9NNP43yi3rvPPPOMadeuXdz+yYKNooQKqZ0KLPL2zzXG2qlTJ5M/f373eEF/m+j+++yzz0zRokVTuu5sjAACCCCAQG4JBD1P1LH1bLNly5ZJm5Ht3/vq9yhYWn0sp2hRkr59+8YEAWk7beMNoVbAy8KFC+Paqz6rdzst9KIg62SBLAorPOecc9z+jCrVWJ2eKRYrVizmGApo6dy5c0w/Yfny5XGLmKT7vDfqfeDvl2rRm/Lly8ftvn37dts3Vv9XXhqH9JayZcua9evX2z6cv2R7rNapP9Xn8TkxfukPFVLb1O9W3/2ss86KodAY7S233GKD0J1y8803m4kTJ7pfr1y50px66qkx97EWufH/3aM+swI5/cGY/lAh7983qvTaa681GgMNuo937dplg4feffdde3wt6KP7wSnZ/rmNeo+yHQIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgggkNMChArltDD1I4AAAhEE/C80RtglZpOgyeHphNxEDRXSS5V6YdBb9PUpp5xiihQpYr+tMJsHHnggZhsFA919990x31OwjVZkV7DNxx9/bF/k878gqNUM/S8mpvuSqX8/vfzpTHzRJBhNxtGq6ArkUYCPM7nJaXSiidvpeKvOsPPQKph6+dFbrrnmGlOnTh2jF1i1gqIm8Lz88svuRCNt26BBA7NgwYK4W0mhQppA7hSd/1VXXWVq165tJ/vI2n/eeqlSE5dKlSqV6q3J9ggggAACCBwyAv4JDKmcuH6nf/PNN+4uYaFCmtTiD0PUyuPOhAyFDCmYR/0ZFf0ud1bVzouhQmvWrLETwr1Fk7M06al48eLuZB5nMru8vH203AgVyok2phoqJJ+gCeFyuvDCC025cuVMgQIF7L30xhtvxE3+//HHH62nt9A3TOUnlW0RQAABBA5WgajBLEHnP2zYMNOzZ8+Yj1INFQoKplG9PXr0iEweFuLjVJRJn9WpY+DAgUbjYMkmnIe15/XXXzdXXHGFe35vv/22DdFJtQwfPjzGSWNa5513XkrVZBIqpIn7l19+ecxYmw4eFCqk73/wwQc2WMhb1JerX7++qVKlitvvdYKHnO1GjBhh7rjjjrjzinrv6hwrVqwY04fW3wXq4xYsWDDQK0qokHZUMFGLFi1i6tA4sc5J/fbNmzcbXV//GOtHH31k6tatm9K1YmMEEEAAAQRyU+DPP/+0Y2re32F6pqZxF+dZaLL2ZPv3vsJu9BzWW/S7Vn0ojQkq8GbevHlxv3PVrzjjjDPimvrHH3/Y+pzxQ22g+vT8Uc9JnaIQRG8I4IYNG2y/JagdlSpVMjt37jTvv/++0QIt3vL444+b2267La4dYc9JM73mmT6D1/Gvv/568+ijj1qfoJLtsVrnGKk+j8+J8Uvv8289z1+6dKlLcP7559t7SOONeo48Z86cuPti9erVMc+X9XOlcWDvfVevXj2jZ9/HHnusDTdVeOuMGTPcurxjwf5QIS0QVKtWrZj69HN6ww032HD20qVLG42J6r7VdfKGYepvo379+sW0Ods/t5nev+yPAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAghkQ4BQoWwoUgcCCCCQoUCmLzT6V9JTc9IJuYkaKqT6BwwYYO6///6EZ64XCxUS5C1ahXzIkCFxL+gl40u0Yna6L5n699MElgsuuCDmJcJE7fG/qOjdLh1v7R92Hr/++qvp2LGjmTJlSuS7TC9L6iXhatWqxe2zY8cO+9KuVlKNUjTB6LXXXjM1a9aMsjnbIIAAAgggcMgKZDJBW7+7f/75Z9cuLFRIk5cVzKjJ2GFFk5YffvhhGziokhdDhdQuTZS+6667wk7HTt5RQGKzZs3cSVK5ESqUE21MJ1RI115Bnf7wgjC4V155xU7O8Rf6hmFyfI4AAgggcCgIRA1mCbLYt2+fueiii2xoilNSDRXSxGtNdvWWbdu22Um1UUtYiI9TTyZ9Vk32ffrpp90gy2RtC2uPN9hQ/VNNmFbYdapl+/btMU6tWrWKC+cOqzOTUCHVrTYoRMc7QTlRqJC2nz59umnTpk2ksUhtf++995rBgwebfPnyxZ1KKveu/ibQ+KVTxo8fbzp06JCQJ2qokCqYOHGiadu2bRi1/Vx/+8hAPzcUBBBAAAEE8rpA79697XNNpyjkT2NYUUs2f+/rmOpj3XzzzW54eFg79CxQwd2JikKpmzRpkrSaoJDqJUuW2HEmJ8Q8rB0KzNS4X1B/Juw5aVjdYZ9n8gxe45BPPvlkTBhm0PGyPVbrPUaqz+OzPcbqff792GOPmcKFC5tbb701jN0GcunaavzTX4KCexJVqIB1XUNnAZ6gZ/UKDLr66qvN8uXLQ9vlbKBgz7lz55pixYrF7ZPtn9vIjWJDBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAghwQIFcohWKpFAAEEUhFYvHixOeecc1LZJWbboFAh7yShqBNqvCspajKMVjRMVmbOnGlGjRplX+bzl6BQIWcbrTDYpUsXo/NOVDS55r777otb7dLZ3vsSqH8ifrI2B72cGtYevXDbp08fU7t27YRVp+OtyqKex9SpU41Cn7yT1PyNkYMCg7p27WoqVKiQ9Nq9+OKL5u677074wq9elNVLoXpZVPVSEEAAAQQQQCC5gH+Sbipe/r7crl27YiY0aCVyf1igVmHWCt+DBg0KnJCs3+XdunWz4TMK3VHfTkX9Ga0c7S1Rjuc/n3LlyrmhPloFvXHjxklP+cwzz7Shhyrjxo2zoYneosk3CpPs1atXzMrS3m006bl///6mfPnyxnv87777zpQpUyamPn//euvWrXa/TEq22+idBP7UU0+Z9u3bR26ezk/98LDgyX/+85920lbdunXpG0bWZUMEEEAAgUNN4NJLLzVz5syxp62JsupDpVK+/PJLG8bshMro9/RZZ52VShXmxhtvdH+vKzxSY26plKh9n6h9Vo0FKURI51WjRg1TvXp1o75LwYIFIzUrWXsUplm8eHG3ngcffND2AdMtLVq0sP1Ip/zxxx/msMMOi1zdn3/+aQoVKuRuv3TpUlOnTp3I+2tD/3ij6kxm9c0335ju3bsnDf3WBH+NyzVq1ChhW1K5d73Bpbq+CkMqWrRowrq9oULXX3+90QTuZGXFihVm6NChCUOddEwFD+nvE/39Q0EAAQQQQOBAENCY3CmnnJJRPyFbv/edRmgxkn79+hmNJXlDDb2eeq6pZ6xBgS5+988++8wMHDjQBqwE1RcUKqQ6FFStsKAxY8YkbIeCh/S7P1nfOOpz0nTvl1Sewav/q7FTXXP1fxU8U6JEiUiHzuZYrf+AqTyPz/b4pff5t/O3koJGtfBQUKiU+nwa41Qg19FHH53QTov+6N5I9Ny7adOmdhxYY8o33XST28fUQjiXX355XL2O/4QJE8zatWsTHlf9UPVz9R7CEUcckXC7bP/cRrqJ2AgBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEMghAUKFcgiWahFAAIFDSUCTdfTyqP7XKZqMEzZxWyuB68W+1atX2xdOS5YsaVcXr1WrVo4F2SRb8XL9+vU2SEkvCh5++OF2goteGtWk9bxSvv76a7Np0ybbRq1kL2eZ6b8TTzwx6WSgoHPQy8B6KVorwmvCkwIIdN300mzUiWJ5xYZ2IIAAAgggcCgKKBBIqzGrf6BwHU10OeGEE8zpp58eMzn6QLFRf2Tjxo1my5YtdmKK+mQ6n1NPPdX2FfNCyUtt1KR89afVN9T1379/v+27qj9XsWJFU6pUqZTI6BumxMXGCCCAAAIIIIBARgL79u2z/XiNzWnMr1ixYrYfV7Vq1dBx1YwOnIM7K7xIY70K29J4b+nSpe0YqwKqkoUY5WCTqBoBBBBAAIE8IZDt3/sKj9m2bZvtR2zevNkULlzYjqGpH3HMMcekfM4aU/r222+Nnt16i+rMnz9/wvr27NljFC6ocTyNTak/o9/9CkhPFiqTcgMPkB1ycqw2lefxOT1+uXfvXrN8+XIbZq93BDQmreuuZ/zJwnr8l1FjwLp/VY9+Rpx75/jjj0/7iut5vwLmFaKpsVMFHamPrf8qVaqU0vPvbP/cpn1S7IgAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCGQgQKhQBnjsigACCCBw4AkkCxU68M6GFiOAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAKxAoQKcUcggAACCBxSAoQKHVKXm5NFAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBA4JATIFTokLvknDACCCBwaAsQKnRoX3/OHgEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIGDXYBQoYP9CnN+CCCAAAIxAoQKcUMggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggMDBLECo0MF8dTk3BBBAAIE4AUKFuCkQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQOBgFiBU6GC+upwbAggggECcwJw5c8yll17qfv+vv/5CCQEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEDhoBAgVOmguJSeCAAIIIBBFYM+ePWbNmjV206JFi5oqVapE2Y1tEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgQNCgFChA+Iy0UgEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBMIFCBUKN2ILBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQOCAFChQ6Iy0QjEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAIFyBUKNyILRBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQOCAECBU6IC4TjUQAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIFyAUKFwI7ZAAAEEEEAAAQQQQAABBBBG5xZNAAAgAElEQVRAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQOCAECBU6IC4TDQSAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIFwAUKFwo3YAgEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIGsCPzrX/8ymzdvtnXdfPPNplmzZlmp9++uZP/+/eb666+3zciXL58ZPny4qVChQsbNmjZtmnnxxRdtPeedd57p2rVrxnVSAQIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAge7AKFCB/sV5vwQQACBHBb4/PPPzahRo0KPcsQRR5iTTz7ZVK9e3VStWtWUK1cudB82QAABBBBAAAEEEEAAAQQQQAABBBD4ewSijPnkz5/fFC1a1FSpUsWO92jsp3z58n9Pg3P5qDNmzDB33323e9SVK1eawoUL53IrDv7DRbkPkyloLLJbt255Duq0004zy5cvt+0aOXKkuf322/NcG9NpkEKFChQo4O46f/5806hRo3SqitlnyJAhpnfv3vZ75557rlm4cGFcnQob2rp1q/1+9+7dDxrTjPGoAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEDgkBUgVOiQvfScOAIIIJAdgf/973/mwgsvTLmyI4880rRt29YMGjTI6P/ndtm7d69ZsGCBe9i6deua4sWL53YzOB4CCCCAAAIIIIAAAggggAACCCCQJwXSHfNp1qyZuf/++029evVy9bx27NjhhrQo7Oj888/P0eNPnjzZ3HTTTe4xdu/ebYoUKZKjxzwUK0/3PnSsmjRpYubOnZvn6AgVSu2SRAkVUoj9t99+ayvWv0H9+/dP7SBsjQACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAwEEmQKjQQXZBOR0EEEAgtwUyndhz3HHHmQkTJpjGjRvnatN//vnnmBChJUuW5Ppkt1w9YQ6GAAIIIIAAAggggAACCCCAAAIIpCCQ6ZhP9+7dzaOPPprCETPbdM6cOebSSy91K/nrr78yqzBkb0KFcpTXrTzT+5BQody5Ts5R9u/fbwoUKOAedP78+aZRo0YZN4JQoYwJqQABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBA4BAUIFToELzonDICCCCQTQH/xJ5Ro0aZEiVKxB3i66+/NqtWrbIrxi9dujTu8y5dupjRo0dns2lJ6yJUKNeoORACCCCAAAIIIIAAAggggAACCByAAv4xn/Hjx5tSpUrFnMnvv/9utm3bZr766iszffp0+7/e8sQTT5hbb701V84+t0OF5NOzZ0/33N577z1z+OGH58q5HkoHiXIfJvMoW7asadCgQZ4jO+200+w4qcrIkSPN7bffnufamE6D/s5QoWuvvdZs2LDBNvuWW24xnTt3TucU2AcBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIGDRoBQoYPmUnIiCCCAwN8j4J/Ys3XrVlO+fPmkjdm5c6fp0aOHmThxYsx2M2fONFdeeWWunAihQrnCzEEQQAABBBBAAAEEEEAAAQQQQOAAFUh1zGfv3r1GYzstW7aMOeO1a9eaqlWr5rhCbocK5fgJcQArkOp9eKCwESqU2pUaMmSI6d27t93p3HPPNQsXLkytArZGAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEDgEBQgVOgQvOicMgIIIJBNgUwm9sydO9doBelffvnFNum4444za9asMUWLFs1mEwPrIlQox4k5AAIIIIAAAggggAACCCCAAAIIHMAC6Y75zJo1y1x22WXumT/zzDOmTZs2OS5BqFCOE/8tB0j3PvxbGpvCQQkVSgHLGEOoUGpebI0AAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggIAECBXiPkAAAQQQyEgg04k9Tz31lOnQoYPbhv79+5v7778/UpsURvTNN9+YfPny2UCiww8/PNJ+2iiboUJ79+413377rQ1HKlmypClbtmzkdrAhAggggAACCCCAAAIIIIAAAgggkBcFMhnzqVy5stm4caM9ra5du5pRo0ZFOsUffvjB7NixwwZOlytXzhQsWDDSftroQAoV2r17t/n6669N/vz5zTHHHGOKFCkS+TxzasP9+/eb7777zvz444+mVKlSpkyZMnbM7e8umdyH6bRdDtu3bze7du2yY3zFixdPWs1ff/1lxwXldvzxx0cOS08WKuSMNaoNug4ab8ykZPva/vnnn/b+1f/q/j3iiCPc5ulYBQoUcL+eP3++adSoUaTm6+dfljI/+uijY+rJjVChPXv22PPSNdW1TOXfn6ATdM7nqKOOsueTaX2RENkIAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABjwChQtwOCCCAAAIZCWQ6sUeTZOrWrWuWL1/utkMTOAoVKhTYrvfee89MmDDBvPzyyzbEx1tOOukkc+aZZ5oBAwaYqlWrxu1/2WWXGU1sUdFx33zzTXebs88+O3CCzrXXXmvatGkTV5cmhUyZMsWMHz8+pu3a8MgjjzQ1a9Y0rVu3NrfeeisTRjK6w9gZAQQQQAABBBBAAAEEEEAAAQT+DoFMxnxuuukmM3nyZNvsBg0amAULFiQ8hbfeesuOr0ydOjVum3/84x82jPrGG2+04y3e8vnnn5u77rrL/ZaCp5cuXep+3bRp08BjatzojDPOcD9T4PX06dPt1xrHueqqq8zOnTvNmDFjzEcffWTWrVtnw6kVDLJy5Up3v8WLF9sxKBWNY82cOTPpZVJ7dSy5KDjFWxSW3b59e/ufwky8RQEn8vz+++/tt9u1a2datGgRekts27bN3HLLLe52w4YNMzVq1IjZ7/fffzczZswwY8eONe+++25cnTLs2LGjufzyy20AUlDxOmh8rV+/fjZs5rnnnjNz5841mzZtskEtKm+88YY55ZRTQtvu3SCT+zDRgYLarOs8ePBg8+yzz8bspvuuS5cupnv37qZ8+fLuZzqvoUOHmnHjxsVsf/LJJ5vGjRubgQMHmhIlSiQ816BQIf0sjBgxwrz++utxbdAYZadOnWLu3WSQ2bi23vr1M6Br+sQTT8SNher+ve2220y3bt1sQFYqoUIffPCBNZw4cWLc6VxzzTX2Z7x+/fomSqiQjr9hwwZbj/7daN68eUydGku+7rrrYn5m5TRp0iTz6KOPmlWrVsVsr39/rrzySvOvf/3LFC5cONJ9q3+DFKI2bdq0uLFrhSt17tzZ/vyuXr3a9O3b19bZsGFDa0dBAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAg2wKECmVblPoQQACBQ0wgGxN7/CvJa5JVtWrVYiQ1GalXr152Yk2U8sADD5h77703ZtN0VlfXpDZNQvGWjz/+2E4w++qrr0KbosknCh/yn0/ojmyAAAIIIIAAAggggAACCCCAAAII/I0CmYz5KIhGYyoqCpp5//33485k9+7dNiTFCR9KdqoKalFojzeQRmEkqjvVouAQbz0KDHn44YdtNY899pgN+FDgS1BRwI9T/vOf/9iwHad4P/Pvq8CSO+64I1JTdZ4KMvEWBWXPmjXLfqtevXpmyZIloXU98sgj5u6777bbKRhnx44dMSHeW7ZsMVdffXVMEFOiSnWeCl4JCsnxOqjdCp4566yz4gJaVPenn35qateuHdp27waZ3IeJDuRvs677qaeeGhcC492/bNmy5p133jHVq1c3mzdvtufhDzz3bq+gHYWiJ7pH/aFCZcqUMa1atQq1+fe//2369OmTMORJFWTr2jqNWbFihb0nN27cmLR9559/vnn11VdN8eLF3e3mz59vFKbjL/v27TP9+/c3gwYNCj1n/Uzo57Z3795223PPPdcsXLgwbr+goCbvRgqJL1WqlPstteGGG24wL730UtI26N8fhZ7VqVMn4Xb6+de5KFQrrNx88832Wl988cVJzyesHj5HAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgTIBQoTAhPkcAAQQQSCqQjYk9Wkn+mGOOcY8ze/Zs419NXiurT5gwIa4tmpRy2GGHmWXLlsWt8u6vRyvKJ5vsE3SiWqX9//7v/9yP1qxZYycP+ctJJ51kJ5ZolXKtSO0tmuylyXPeVbq5rRBAAAEEEEAAAQQQQAABBBBAAIG8LJDJmE/dunXd8ZFrr73WvPjiizGnunfvXhuo8fbbb8d8X0Es2ldjRYsXL475TME4ChbRNiqrV682NWrUSJlwz549MeE63lChhx56yDz//PNm+fLlcfXq+D///LP7/aihQgpOURCMt6iu+vXrm/3799vz9I9X+ce0FNSigGunKOSlZs2aSc9dAddr16612yiMZfDgwe7227Zts+Nb/uMqKKdy5cpG41+y9hYFueh6FSxYMOb7/oCe448/3jz++OOBbQsKEg+7gJnch4nq9rZZY4s//vhjzHieHHbu3BkXKK5wGV0vhed47xF9X8Xxdo6re3XdunWmcOHCcU3xBuBof/++Cir/9ddf476viu655x4zZMiQwNPL5rXVARQkpHvCX3QPy0kO3vtI98miRYvczROFCt1+++02xMtfZCEv/8+g1yhboUIKpPc7ahxXoUzffvttTNN0LfVzUbRo0UB3heEPHTo08HwUsvThhx/GfKbjON9LdD5hPxt8jgACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAQJgAoUJhQnyOAAIIIJBUIBsTe7SSc/78+d3jjBw50mhiiVM0YemCCy5wv9akmieffNLUqlXLBgo5RSuhd+nSxZ3IoqAfTbIqUqSI3USTxjRpTeWnn34yFSpUcPfVSuOatOYv2tfbtvPOO88oaMgpmvzSsmXLmFAkTd659dZb3RXkte1TTz1l2rdvz92EAAIIIIAAAggggAACCCCAAAIIHBAC6Y75KETFCVnRifbr1y8uVOfhhx82CvNxisZ6Jk2aFBOU88cff9iQjr59+7rbKYjojTfecL/evXu30biSioJ4FGDkFAWy+Eu+fPniQkG8oULe7XUO3bp1s+NPGkNSWHXZsmXdTaKECr333ntGgSFO0f4a07riiitimvbKK6+Ydu3auWNaCmxRcHXp0qXtdn/++acNU3KCTpKFymh7hZWceeaZ7jF0TapUqWK/llezZs3MnDlz3M9bt25tNB5XqlQp93s61p133mmmTJnifu+BBx4wCmLxFr+D85nOoWfPnkbXVsdWUEzFihVTvvfTvQ+THShRmwcNGmTatm1rypcvb3ffsGGDufrqqwNDpvT5HXfcYbp27eqG7nz33XdGlvPmzXMPP3z4cOvoL95QIe/9oTFEBZyXLFnSfnvXrl1m1KhRce7+IPScuLb79u2zY7LesVDdz2PHjrU/FyraRgFAGiOdOHFi3HkGhQr997//taFi3iKnjh07uj+f33//vQ2x0vXwh19lK1TIOb7uUf2bdPbZZ7vHVwDWjTfeGBM2pXAw/XvmLwsWLDANGzaM+bZ+nhSSf8QRR9jva0xa97LuD39gEaFCKf+zwA4IIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAhEFCBWKCMVmCCCAAALBAtma2ONdwb5z585mzJgx7gE1gUcTNjSJSUFBWu36mGOOCWzQE088YTp16uR+tnDhwpjJW84HWlleq0Q7ZcmSJUYrRIcVTfwaMGCAXal82LBhpkePHoG7/Pbbb6ZSpUruJBH/pLew4/A5AggggAACCCCAAAIIIIAAAggg8HcKpDPmo/EShWts3Lgx4ZiLgoCcoA1tpECPxYsXxwRHe8/bP9bzySefGAWy+ItCci699FL3207YUJhhUKiQgmIUaOQEVQfVESVUqHHjxubNN990d9+yZYs54YQTApv02Wefmdq1a7ufPf744+a2225zv9bY2MCBA+3XCifaunWrKViwYGBd3bt3t0E0Ko0aNTIKdnGKP+hIgTcKdElUrrvuOvPSSy/ZjxUUpLAXb8h3UEBPgwYNzAsvvBAT6B12HRJ97r8PZeAE7iSr86KLLjLVqlUL3CSozQqv0pifv/zwww8xYUvO523atDFPP/20UVCVtyg85sQTT7RjhyoKp1qzZk1cvf5QIdlqHNN7D3h30s/IOeec435LwVA6D2/J9rX1B73/85//NM8++2zgfadwIX3u3CtOu4JChfyh7UuXLjV16tQJvFYffPCBDfvxlmyGCtWoUcMobL5MmTJxx9f4rq6fcy11jTSm7C8KXpKVU95///24Njufbd++3Y5BO3Xq+4QKpfuvA/shgAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCIQJECoUJsTnCCCAAAJJBdKZYBZUoVaSf/nll+1HV155pZk5c2bcZuvXr7eTubQ6fKKiVew1CcRZwfqZZ54xmuTjL+mGCqkerQ6vECLvSvNB7Xn00UftiuUqmuz1zTffcDchgAACCCCAAAIIIIAAAggggAACB4SAf8xHQRnHHXdcTNt///13O96xbds2O5ajQGhvadmyZVzIyPTp080111zjbvbxxx/bYKFERSEtCmBZtWqV3eTee+81DzzwQNzm2QoVUls+/PBDkz9//qTXKSxUSOEhxx57rFuHQn4UVpSseMOAFDyi8SenaFysatWq7tezZ882TZs2jatO10TjUM7Y2NSpU42CgZxy++23m8cee8x+qe1Ur8JSEhWFnxx//PHux3K+5JJL3K+DAnoUeFS+fPms3Of++zBqpfPmzTMKdQoq/jYrDFzb+wOCnH0VvDRy5Ei3KgXRLFu2zBQqVCiwfl1rXUun6B4uUKBAzLb+UKGg8B1/5d26dTMKm3LKd999FxOGk+1r26VLFzN27Fj3ePo5997T/vbt2bPHKFBKPz9O8Z+X/37q1auXefDBB5NeVv3b0rx5c3ebbIYKhd2rEydONG3btk1o/uWXX8YEhWkseMSIEUnPR4FbCmByCqFCUX+q2Q4BBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIFUBQoVSFWN7BBBAAIEYgWyFCt1www1Gk5xUEoUKRaU/88wz3ckrvXv3NoMHD47bNZNQoajteOONN0yTJk3czTWZq1ixYlF3ZzsEEEAAAQQQQAABBBBAAAEEEEDgbxNIN8zFabCCMl5//XVTsmTJmHPwBqPUrl3bfPrpp6HneNddd7lBHZdffrl57bXX4vbJVqjQ22+/bRo2bBjaprBQoVdeecUoVMkpO3fujLPwH8QfnrJ///6YoBuF5Lz55pt2NwV0v/jii3HtnDZtmmnRooX9vsKCvv32W1O4cGF3u2rVqpm1a9far3v27GmGDh0aeq41a9Z0Q52GDx9uFLLjFL/DgAEDTN++fUPrjLpBuvfh6tWrTfXq1QMP42+zAoMUyJOoaMxSY5dO0fnLIVFZvHixOeecc9yPFaTjD0n3hgqddNJJZsOGDaEkX3zxhalYsWKMfbNmzXLs2lauXNls3LjR1h92zk4jnnrqKdOhQwe3Tf5QIYXK6951iu7Po48+Oum579u3z4ZUaVuVbIUKKUxK47fJis5fDk7RtT3rrLPcr/33RljwknbU+VSqVMnovkh2PqE3BBsggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCAQIkCoELcIAggggEBGAtkKFbrggguMJm2ptG7d2kyaNClSu7T6+pYtW+x/mzZtsv8988wz7iSTTp06xayo7VSa7VChv/76y2h18M2bN9u2aCKQVpOfMWOGex6a+ONd2T3SCbIRAggggAACCCCAAAIIIIAAAggg8DcIpBvmUrZsWRtA0r17d1O0aNG4ll999dXueEn79u2NQkjCyujRo03Xrl3tZomCiLIVKvTnn3+aggULhjXJhIUKPf7440YBSirHHXec+fLLL0PrXL58uVHYjFO+//57U6pUKfdrfyDLjh07TOnSpWPqveKKK2yYk0pQaFC+fPnc7SdPnmxatWoV2i6FFCmsSKVHjx5m2LBh7j5+h0WLFpn69euH1hl1A/99eP/995vixYuH7q4xwSJFigRu52/zO++8Y84777yEdS5YsCAmaCrMTWODCo1xykcffWTq1q0bU783VCjR+KW/QQqZKlCggPtt/ezoZ8gp2b623vrGjRtnOnbsGOq+Zs2amDAnf6jQqFGj7L8NKgq90hhtlKLx4ueee85umq1QoX79+pl///vfSQ+/Z8+emFAu/Rzo3zCnjBgxwij0LNXzueyyy8ysWbOSnk8UF7ZBAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgmQChQtwfCCCAAAIZCWQrVKhcuXJuEFCyFc01yUcTo5YtW2ZXVXdWdE50EjkVKvTjjz+aZ5991gYHrVixwmjSV1ghVChMiM8RQAABBBBAAAEEEEAAAQQQQCCvCPjHfE4++eTAsJ1Vq1a5TVagkMJzChUqlPA0zjzzTPPhhx+mfZqJAnqyESp00kkn2aDoKCUsVKh3795myJAhUapKuI3CqytWrOh+rnBtGf/yyy/2e2PGjDGdO3d2P9+2bZupUKGC+/XKlStNjRo13K+131FHHZVRmzp06GDGjx/v1uF30Fidtw0ZHcwYk62xR287/G3+4YcfTIkSJRI29bPPPrNhVk7ROGCtWrUSbv/TTz/F1Kfxw3r16sVs7w0V6t+/v1FYUpRSs2ZN4/zMDRo0yNx33312t2xfW3998+bNM40bNw5toiy9QVj+UCHvz8XZZ59t3n///dA6tcG//vUv8/DDD9ttsxUqpPugWbNmocfXz4zzM/fKK6+Ya665xt3nnnvuMQ899FDSdgUdQEFECiRKdj6hDWMDBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEQgQIFeIWQQABBBDISCAbE3t+/fVXuzK1U6ZOnWquu+66mHZplWutru6stB610dkOFdJq9RMmTLATWZzJJFHbQqhQVCm2QwABBBBAAAEEEEAAAQQQQACBv1sg6pjPvffeax588EG3udOnTzfNmzdP2HxvmEo655iToUJNmjQxc+fOjdSssFChHj16mOHDh0eqK9FG/lAhbderVy8zdOhQu8s//vEP8/HHH7u7K6REYSUqQcEr33//vSlTpkxGbQoLFdq7d68pUKBARsfw7hz1PkzlgGHXzl/X/2PvTmDsquo/gJ8BAUVkpywCghSogg1VNglqEdlkKTtEQBuLEEBZBAOmyswoIqRsAiogUiOIASkWCIjUpBAERaQRwg5lCVvZd0SgzD+/95/38mY6M3de5y33vve5CZHOnHvO73x+5xG54X7f4FCh559/vhTuNNz1xhtvpBVWWKHy66xQoXPOOScdc8wxo9pCBPvMmTOnNPbkk09Ovb29pb+vd28Hzzdv3rw0adKkzBoXLlw4IHxscKhQ9eci/jkR/7wYzXXqqadWApTqFSoUn534DGVdI4UKVe9nypQpafbs2VnTlX7/05/+tNS/4T6ro5rEIAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIZAkKFHBECBAgQGJNAPV7siW/3jhfKyte///3v9IUvfKHy5wgUmjBhwiJ1brTRRqUXPzbeeOM0fvz4FN8mH3/FyxyXX355aXy9Q4UOPfTQUqhQ9RWBSPFt4/HN71FHuZb49vjqF1OECo3pqLmZAAECBAgQIECAAAECBAgQaKLAaJ/5vPbaa2ndddethC/Hs5n7778/LbPMMkNWG898IqAkrnimsv/++9e0q3hGdMIJJyxyz1/+8pf09a9/vfLzvr6+Uc0bwdEzZswoja0lFCQrmOakk05Kp59+eqWGadOmjaqe8qBll122dP/HPvaxAfc98MADpWdQ5evuu+9OEydOLP1xk002KdnHdemll6aDDz54wL2vv/56WnHFFSs/i+dZ5XtHW1wEwey6666V4VkOo513uHGjPYe1rFNrzY0OFerp6Und3d2j2sKWW26Z7rzzztLYCBQqB9PUu7fxuV5ppZUqNd1yyy3py1/+cmaNg8PjB4cKVX8uJk+enObOnZs5ZwyYPn16imChuPIUKhT+ERAU1+CQr5E2dvjhh6eLLrpoxP2MCsYgAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiMICBVyPAgQIEBgTAL1eLFncFDPq6++OuAFp5133jn99a9/LdUZL5udccYZpRfOql+Cqt7Edtttl26++ebSj+oZKnT77beXXlopX/GiWbzwE4FISyyxxLTf1IYAACAASURBVCKO8bJNvBxTvoQKjemouZkAAQIECBAgQIAAAQIECBBookAtz3wuuOCCdMQRR1SqO+uss9Jxxx03ZLUHHHBAuvLKK0u/O/bYY9PZZ59dl13lLVSo2iRCgO6777667DMm2XbbbdNtt91Wmi9CkSJ86K677kqbb7556Wfx/GzBggUpgokGX8svv3wlAOrqq69OERI0lqvWgJ5a16rlHI527lprbnSoUIQ/RQjUaK7q/v3qV78a8LmrZ28jlKv6eefMmTPT1KlTM0t84okn0vrrr18ZNzhU6Mwzz6yEgo0bNy49//zzmXPGgOrnx3kKFYoeHHXUUZU9fPjhh6mrqytzT9tvv32Ksx3XcPvJnMQAAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAhkCQoUcEQIECBAYk8BYX+ypfuEpCtlhhx3STTfdVKnpvffeG/DN9vHS2X777TdizdUv0NQzVCi+DTu+FTuueBnsP//5T1pqqaWGrSW+bTq+dbp8CRUa01FzMwECBAgQIECAAAECBAgQINBEgVqe+bz//vtp0003TQ8//HCpwgi1mT9/flpttdUWqTgCmn/yk5+Ufr7rrrumCHipx5W3UKG//e1vpedc5WvhwoVDhlIvzt4vu+yydMghh1SsX3755VK40DnnnFP62fe+97107rnnDjl1dSBRBHcff/zxi1NC5Z5aA3pqXayWczjauWutudGhQltssUX617/+lVl+9HnVVVetjJs1a1bae++9K3+ud2/XWWed9PTTT5fmP/nkk1Nvb29mjdddd13aY489KuMGhwpVn90Y9Pbbbw8ZfjV4oQh1v+eee0o/zlOo0OCzdPfdd6eJEyeO6PT666+nsH3zzTdH3E8mtgEECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEMgSECjkiBAgQIDAmgbG82PPWW2+lnXfeufLN6lHIAw88kCZMmFCp6aGHHhrw52eeeSattdZaw9YcL+BstdVWld8PFyoUa8cLbuVrzpw56Wtf+9qIFt/85jcr3xp+5JFHpl/+8pcjjt9tt93S9ddfXxkjVGhMR83NBAgQIECAAAECBAgQIECAQBMFan3mE89A4llI+frud7+bzjvvvEUqvvTSS1M8YylfCxYsSKuvvvqYdxYh1TvttFNlntGGlUQYz4wZM0r3TZkyJc2ePXtUtWQF0zz22GNpgw02qMwVoUfxHKwe1zvvvJPWWGONSihJhHBPmzat8ud58+alSZMmDblUjLvkkktKv4swmzvuuCN1dXUtdllZDos9cf+NtZ7D0axXa82NDhWKmkcTRhOhUccdd1xliw8++GDaeOONK3+ud2/333//9Kc//ak0/9prr53iOe2yyy47IvFBBx2ULr/88sqYwaFCEQwUAUHl68ILL0yHHXbYiHPG8+IIeC9feQoVimCgCLgvX6MJSotQtQhXy9rPaM6yMQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRGEhAq5HwQIECAwJgEFvfFnrlz55ZeICt/23UUceKJJ6bTTjttQD3PPffcgBChCA2KF56Guj744INSoFC8OFW+hgsVit/HCx/lb4Q+66yzBryUM9T88S3v559/fulXWS+IXHPNNWnPPfccMI1QoTEdNTcTIECAAAECBAgQIECAAAECTRRYnGc+O+64Y4rg5vJ13333DQgDiZ/Pnz8/jR8/vjLm6KOPTr/4xS+G3dm7776bDjzwwLTqqqumn//852m11VYbcmystemmm1Z+d+edd6bNN988U6xRoULxnCoCXyJcKK6JEyeWnlktueSSw9Z0yimnpHhmFuExn/vc50as/ZhjjknnnnvuImM+//nPp7vuumvYe//whz+kgw8+uPL7WbNmpb333nvY8fE8a/fdd0+HHHJIil4tvfTSA8bWGtCT2ZBBAxbnHGatUWvNzQgVmjx5coq9DhfwFOFba665ZmVrQ/W53r2Ns7HvvvtW1ozzOX369GF5L7jggnTEEUcM+P3gUKH4ZXwuHn744dK4CH1/4okn0sorrzzkvC+//HLaZpttKuNjUJ5ChaKe+Gxcdtlllfrj8xuflaF6GR6Dg+2H20/WOfZ7AgQIECBAoDkCN998c4r/r+YiQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUEQBoUJF7JqaCRAgkCOBwS/2PPXUUwNCgMqlxosvjzzySIpv0P773/8+4EWLGDNu3Lj06KOPll4kGXxVh//Ef7QZ3+z+0Y9+dMCwCB86/PDD03XXXTfg5yOFCm277bbptttuK42PdePvR3phK745O+YrXzfccEPaZZddFqk3XiI58sgjK4FF5QFChXJ0cJVCgAABAgQIECBAgAABAgQIjCiwOGEud999d9pss80q88Zzk3h+Mvg66aST0umnn1758cknn5x+9KMfpaWWWmrA0P/973/pgAMOSBHeXH5+E2usv/76i8z5zjvvpI9//OOVn3/pS19KEYoyXAhReWCjQoVi/uuvvz7ttttulZqmTJmSfvOb3wxZU3iES/m6+uqr01577TVsjwZblwdefPHFadq0acPe9+GHH6att946RehS2fS3v/1t2m+//Ra5J8LAv/KVrwwIRop1q69aA3pq/dgtzjnMWqPWmpsRKhQ1R4j5RRddtMiz1XhmGeHs5YCqGDtz5sw0derUAVutd2/jMxUBQNWh8HFGu7u7BzybjXX/+Mc/DgirKhc2VKjQ4PChjTbaKF166aVpyy23HLCfl156qRRo9c9//nPAz/MWKvTkk0+m9dZbb0CN8dk96qijSkFn8c+le++9N1177bWlYLTBl1ChrE+s3xMgQIAAgdYKRFBgX19fa4uwOgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHFFBAqtJhwbiNAgACB/xcY/GLP4rjEt83HN9JHsNBQ16GHHpri5abyFeMi3CdeIHvllVdSvNgTL4m9+eabpSFrr7125WWXkUKF4mWVeCGn+opv+d5ggw0q3xofL34ddNBBpSEPPfRQmjBhwoDx8cJVvPixwgorVAKTykFFUecLL7xQGS9UaHFOh3sIECBAgAABAgQIECBAgACBVggsbpjL4Oc4EQ698847D9jC66+/niJIpPq5Sfx5++23L4VwvPjii6Xw5zlz5gy4L0J5ImxniSWWGJIkwnQuueSSAb+LcKE111yzcs8PfvCDFM9/ylcjQ4VijXi2FOFC5SuCrffcc880ceLEUk0RmHLLLbcMsIhnWxHes/LKK4/Y+ghhKYcDlQeGbQR0j3TdcccdpWCh6iueb22zzTZp/PjxlWdcg+c+++yz07HHHjvgvloDemo9y2N99vjpT386zZ8/f0w1NzpUaIstthjQxwjSiT4sXLgw3XXXXZVQ9PImIqwrzlS84D74qmdvY+65c+emr371qwOWiWeeEfweQTqPP/54uvHGGyvPZeN3Sy+9dOXZ7FChQhFCtMMOO5SeK1df8VmNz3+EycdnYt68eZVfVxvlLVQoirziiitSPOMezRX/DIjwtVtvvbU0XKjQaNSMIUCAAAECrRHo7e1NPT09pb8iWNFFgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoGgCQoWK1jH1EiBAIGcCY3mxJ14yiW9n32OPPUbc1auvvloK86l+0Wy4GyJEKF4MO+yww0pDRgoVihdz4iWcwS+oVc994oknptNOO63yo3h56vvf/35mF2Jv8XJPfMN4uW6hQplsBhAgQIAAAQIECBAgQIAAAQI5EVjcUKFnn302ffKTn6zsIsKC7rvvvvSRj3xkwM7uueeedMghh6T439Fc8Qzn8ssvTyuuuOKww2PtSZMmjfgM6YYbbig9DypfjQ4Veumll9JRRx2VrrzyytFsM0UIzrXXXps22WSTzPERoBRBSuUrnoddeOGFmffFgAhnmjp1aiUMJuumH/7wh+lnP/vZIkE2eQ8VioCmp556asD2aq250aFCEd507rnnpghAz7oi4CfO0iqrrDLs0Hr1trzA73//+/Stb30rq7QUYTn/+Mc/0nHHHVd53jpUqFBMFM9L991330qwzkiTH3HEEekb3/hGitChuPIYKhR1xV732muvET9TYXT77ben3/3ud+nMM88ccT+Z4AYQIECAAAECDReoDnHs6+tr+HoWIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBvAaFC9RY1HwECBDpMIL5N/Ytf/OKodh3fKB3fwv6Zz3ymFBIUL4CM9CJY9aTxUlh8G+RFF1005Fqf/exn049//OPSN0LPnDkzffvb3y6NO/7449MZZ5wxbH0RLBQvYJ1//vlDvsQ2OFQo/oPRWbNmpfj5Y489NuS83/nOd0rfWLnWWmul1VdfvfIi24svvphWXXXVUVkZRIAAAQIECBAgQIAAAQIECBBopcDgZz7PPPNM6VnHaK5TTjml9JymfEXISYRtDL7ee++9dOqpp6azzjpr2CCOeOYTISXxrGeJJZbIXP7ll18uPZeZPXt2evrppxcZPzhUKJ43xfi4Dj744FEFu8TY6tClCAp54403RqztiiuuSCeccMKQNcWNEVAdoUARchTzjeaKNVdYYYXK0OjZVlttNZpbS2Oef/75dPTRR48YeLTTTjuVaoowm6GuWh1GXVz/wFqePQ4191ChQrXWPH/+/DR+/PjK9K+99toA98HrDu7Lvffeu0hI1Lbbbptuu+220q3z5s0r/T4+M7/+9a+H/CzEPuJzEP0aHNA11L7r0dvqeaPG+Fz/+c9/HrKFcT5mzJhRCnvfc8890zXXXFMaN1yoUPwuPv/nnHNOOu+884b8XMTnIJ7tTp8+PUWwU8wd13ChQtWmF1988YDArbjv7bffTsstt1yl/gcffDBtvPHGmUdynXXWqdR31VVXpX322WfYe955553S5ymCqx555JH0+OOPl3obgUhbbrll6X/jeXEEJV1wwQWleSZPnpzmzp2bWYcBBAgQIECAQHMFqv89IVaOf2fo7u5ubhFWI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIDBGAaFCYwR0OwECBAg0VyC+3T1e5HniiSfSW2+9VXoJY7311kubbrrpmAuJwKD4luz//ve/lbmWX375tPLKKy8y9/vvv18KFXryySdLL5Uss8wyad111y3VsdJKK425FhMQIECAAAECBAgQIECAAAECBDpJIAKlI+QjnvlEaMoaa6yRPvWpT40q9GM4p1deeaUU0BLPfMpXhPcsu+yyLaONQJrYZwSOxPOlqCfCmiKIezRhMY0oPEK3I/wk6nruuedKwStR04YbbjjqIKlG1NWJc8bzznvuuSc99dRTpWefcT7KzxyXXHLJmknq3dsFCxakhx56qFTfBx98UDofG2ywQemvxb1inggNijnj2WwEZUWQT3wmWvlZXdz9jOa+HXfcMc2ZM6c0dNq0aSlCkFwECBAgQIBAvgS6uroWKaj63yvyVa1qCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAwtIFTIySBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECDBT788MO05pprlgKU4poxY0Y64YQTGryq6QkQIECAAIFaBHp7e1NPT88it8TPuru7a5nKWAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQItFRAq1FJ+ixMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUFSBd999txQOtNtuu6VJkyaNuI0rrrgiHXjggZUxs2fPTlOmTCnq1tVNgAABAgTaUqCrq2vYffX19bXlnm2KAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgPQWECrVnX+2KAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEGCjz66KPpgAMOSPPmzUuf+MQn0k033ZS23nrrIVe8//7700477ZSefvrp0u/HjRuX4v64z0WAAAECBAjkQ6C3tzf19PQMW0z8rru7Ox/FqoIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAhoBQIUeEAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECNQrceOONaZdddhlw19SpU9Nmm22WJk6cmFZZZZX0yCOPpDvvvDOdfvrpA8ZdddVVaZ999qlxRcMJECBAgACBRgp0dXVlTt/X15c5xgACBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECeRAQKpSHLqiBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHCCUyfPj2deuqpNdUdwUMzZ86s6R6DCRAgQIAAgcYK9Pb2pp6ensxFYkx3d3fmOAMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQItFpAqFCrO2B9AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQKKzBr1qx05JFHphdeeGHEPYwbNy5dfPHFaffddy/sXhVOgAABAgTaVaCrq2vUW+vr6xv1WAMJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQItEpAqFCr5K1LgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBbCCxcuDDdcccd6dZbb00LFixIzz77bIrAgXXWWSdNmDAhbbjhhmnzzTdPyy23XFvs1yYIECBAgEA7CfT29qaenp5RbynGdnd3j3q8gQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRaISBUqBXq1iRAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoOUCXV1dNdcQ4YEuAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAnkWECqU5+6ojQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBhgj09vamnp6emueOe7q7u2u+zw0ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEmiUgVKhZ0tYhQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCA3Al1dXYtdS19f32Lf60YCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECjRYQKtRoYfMTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJArgd7e3tTT07PYNcW93d3di32/GwkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAg0UkCoUCN1zU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQO4Eurq6xlxTX1/fmOcwAQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFGCAgVaoSqOQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyKVAb29v6unpGXNtMUd3d/eY5zEBAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgXoLCBWqt6j5CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDIrUBXV1fdauvr66vbXCYiQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUC8BoUL1kjQPAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQK5F7j55ptHrHG77bar/H7u3Lkjjp08eXLu96tAAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBzhMQKtR5PbdjAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSGEejq6qr8pq+vjxMBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBwgkIFSpcyxRMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECjBIQKNUrWvAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAs0SECrULGnrECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCQewGhQrlvkQIJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQyBIQKOSIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoFxAq5CgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgUXUCoUNE7qH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOomIFSobpQmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaJGAUKEWwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8CQgVyl9PVESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCbgFCh2ryMJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgjQWECrVxc22NAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINAhAkKFOqTRtkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLaAUKFsIyMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTyLSBUKN/9UR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0UECrURGxLESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINERAqFBDWE1KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEARBYQKFbFraiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgWECrkPBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBfQKiQo0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFB0AaFCRe+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqJuAUKG6UZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgRQJChVoEb1kCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPInIFQofz1REQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0CQoVq8zKaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE2FhAq1MbNtTUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcICBXqkEbbJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QJChbKNjCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMi3gFChfPdHdQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFFAqFATsS1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQEAGhQg1hNSkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkUUECpUxK6pmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoFpAqJDzQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgX4BoUKOAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQNEFhAoVvYPqJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgbgJChepGaSICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWCQgVahG8ZQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJ+AUKH89URFBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECtQkIFarNy2gCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpYQKhQGzfX1ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgVKhDGm2bBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkCwgVyjYyggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIN8CQoXy3R/VESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQRAGhQk3EthQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBDBIQKNYTVpAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFFFAqFARu6Zme26ASQAAIABJREFUAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBagGhQs4DAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+gWECjkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECRRcQKlT0DqqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6CQgVqhuliQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFokIFSoRfCWJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgfwJChfLXExURIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUJiBUqDYvowkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaGMBoUJt3FxbI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0iIBQoQ5ptG0SIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJAtIFQo28gIAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBfAsIFcp3f1RHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEATBYQKNRHbUgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg0RECrUEFaTEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQRAGhQkXsmpoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSqBYQKOQ8ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoFxAq5CgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgUXUCoUNE7qH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOomIFSobpQmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaJGAUKEWwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8CQgVyl9PVESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCbgFCh2ryMJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgjQWECrVxc22NAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINAhAkKFOqTRtkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLaAUKFsIyMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTyLSBUKN/9UR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0UECrURGxLESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINERAqFBDWE1KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEARBYQKFbFraiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgWECrkPBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBfQKiQo0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFB0AaFCRe+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqJuAUKG6UZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgRQJChVoEb1kCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPInIFQofz1REQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0CQoVq8zKaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE2FhAq1MbNtTUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcICBXqkEbbJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QJChbKNjCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMi3gFChfPdHdQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFFAqFATsS1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQEAGhQg1hNSkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkUUECpUxK6pmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoFpAqJDzQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgX4BoUKOAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQNEFhAoVvYPqJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgbgJChepGaSICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWCQgVahG8ZQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJ+AUKH89URFBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECtQkIFarNy2gCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpYQKhQGzfX1ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgVKhDGm2bBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkCwgVyjYyggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIN8CQoXy3R/VESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQRAGhQk3EthQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBDBIQKNYTVpAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFFFAqFARu6ZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBagGhQs4DAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+gWECjkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECRRcQKlT0DqqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6CQgVqhuliQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFokIFSoRfCWJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgfwJChfLXExURIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUJiBUqDYvowkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaGMBoUJt3FxbI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0iIBQoQ5ptG0SIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJAtIFQo28gIAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBfAsIFcp3f1RHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEATBYQKNRHbUgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg0RECrUEFaTEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQRAGhQkXsmpoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSqBYQKOQ8ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoFxAq5CgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgUXUCoUNE7qH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOomIFSobpQmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaJGAUKEWwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8CQgVyl9PVESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCbgFCh2ryMJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgjQWECrVxc22NAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINAhAkKFOqTRtkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLaAUKFsIyMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTyLSBUKN/9UR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0UECrURGxLESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINERAqFBDWE1KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEARBYQKFbFraiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgWECrkPBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBfQKiQo0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFB0AaFCRe+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqJuAUKG6UZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgRQJChVoEb1kCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPInIFQofz1REQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0CQoVq8zKaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE2FhAq1MbNtTUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcICBXqkEbbJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QJChbKNjCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMi3gFChfPdHdQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFFAqFATsS1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQEAGhQg1hNSkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkUUECpUxK6pmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoFpAqJDzQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgX4BoUKOAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQNEFhAoVvYPqJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgbgJChepGaSICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWCQgVahG8ZQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJ+AUKH89URFBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECtQkIFarNy2gCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpYQKhQGzfX1ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgVKhDGm2bBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkCwgVyjYyggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIN8CQoXy3R/VESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQRAGhQk3EthQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBDBIQKNYTVpAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFFFAqFARu6ZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBagGhQs4DAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+gWECjkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECRRcQKlT0DqqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6CQgVqhuliQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFokIFSoRfCWJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgfwJChfLXExURIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUJiBUqDYvowkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaGMBoUJt3FxbI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0iIBQoQ5ptG0SIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJAtIFQo28gIAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBfAsIFcp3f1RHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEATBYQKNRHbUgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg0RECrUEFaTEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQRAGhQkXsmpoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSqBYQKOQ8ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoFxAq5CgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgUXUCoUNE7qH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOomIFSobpQmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaJGAUKEWwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8CQgVyl9PVESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCbgFCh2ryMJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgjQWECrVxc22NAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINAhAkKFOqTRtkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLaAUKFsIyMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTyLSBUKN/9UR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0UECrURGxLESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINERAqFBDWE1KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEARBYQKFbFraiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgWECrkPBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBfQKiQo0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFB0AaFCRe+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqJuAUKG6UZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgRQJChVoEb1kCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPInIFQofz1REQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0CQoVq8zKaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE2FhAq1MbNtTUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcICBXqkEbbJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QJChbKNjCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMi3gFChfPdHdQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFFAqFATsS1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQEAGhQg1hNSkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkUUECpUxK6pmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoFpAqJDzQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgX4BoUKOAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQNEFhAoVvYPqJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgbgJChepGaSICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWCQgVahG8ZQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJ+AUKH89URFBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECtQkIFarNy2gCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpYQKhQGzfX1ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgVKhDGm2bBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkCwgVyjYyggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIN8CQoXy3R/VESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQRAGhQk3EthQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBDBIQKNYTVpAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFFFAqFARu6ZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBagGhQs4DAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+gWECjkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECRRcQKlT0DqqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6CQgVqhuliQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFokIFSoRfCWJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgfwJChfLXExURIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUJiBUqDYvowkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaGMBoUJt3FxbI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0iIBQoQ5ptG0SIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJAtIFQo28gIAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBfAsIFcp3f1RHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEATBYQKNRHbUgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg0RECrUEFaTEiBAgAABAgQIECBAgAABAgQIECDGS4gFAAAgAElEQVRAgAABAgQIECBAgAABAgQIECBQRAGhQkXsmpoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSqBYQKOQ8ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoFxAq5CgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgUXUCoUNE7qH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOomIFSobpQmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaJGAUKEWwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8CQgVyl9PVESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCbgFCh2ryMJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgjQWECrVxc22NAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINAhAkKFOqTRtkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLaAUKFsIyMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTyLSBUKN/9UR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0UECrURGxLESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINERAqFBDWE1KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEARBYQKFbFraiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgWECrkPBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBfQKiQo0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFB0AaFCRe+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqJuAUKG6UZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgRQJChVoEb1kCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPInIFQofz1REQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0CQoVq8zKaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE2FhAq1MbNtTUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcICBXqkEbbJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QJChbKNjCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMi3gFChfPdHdQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFFAqFATsS1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQEAGhQg1hNSkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkUUECpUxK6pmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoFpAqJDzQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgX4BoUKOAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQNEFhAoVvYPqJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgbgJChepGaSICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWCQgVahG8ZQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJ+AUKH89URFBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECtQkIFarNy2gCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpYQKhQGzfX1ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECHSIgVKhDGm2bBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkCwgVyjYyggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIN8CQoXy3R/VESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQRAGhQk3EthQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBDBIQKNYTVpAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFFFAqFARu6ZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBagGhQs4DAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE+gWECjkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECRRcQKlT0DqqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6CQgVqhuliQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFokIFSoRfCWJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgfwJChfLXExURIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUJiBUqDYvowkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaGMBoUJt3FxbI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0iIBQoQ5ptG0SIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJAtIFQo28gIAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBfAsIFcp3f1RHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEATBYQKNRHbUgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg0RECrUEFaTEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQRAGhQkXsmpoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSqBYQKOQ8ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoFxAq5CgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgUXUCoUNE7qH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOomIFSobpQmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaJGAUKEWwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8CQgVyl9PVESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCbgFCh2ryMJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgjQWECrVxc22NAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINAhAkKFOqTRtkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLaAUKFsIyMIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTyLSBUKN/9UR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0UECrURGxLESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINERAqFBDWE1KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEARBYQKFbFraiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgWECrkPBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBfQKiQo0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFB0AaFCRe+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqJuAUKG6UZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgRQJChVoEb1kCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPInIFQofz1REQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0CQoVq8zKaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIE2FhAq1MbNtTUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIcICBXqkEbbJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QJChbKNjCBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMi3gFChfPdHdQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINFFAqFATsS1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQEAGhQg1hNSkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkUUECpUxK6pmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoFpAqJDzQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgX4BoUKOAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQNEFhAoVvYPqJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgbgJChepGaSICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWCQgVahG8ZQkQIPB/7Nx5tFV1+T/wB+dQVEIxFBwYFRFXLlHLBZpmOCNoOCRqmplGTog55dd5ShFHDMeU1DARMESXLlPJhUnmQBpehURJBQrUa+KA8lv7LO7+3cu9eO6hc87d59zX/gfO3s/+fJ7P69n33zcBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIHsCQoWyNxMdESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFCYgVKgwL9UECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSxgFChKh6uoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEWomAUKFWMmjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgv4BQofxGKggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLItIFQo2/PRHQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECZRQQKlRGbFsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiURECoUElYLUqAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQCUKCBWqxKnpmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoL6AUCHfAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBJYLCBXyKRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFS6gFChSp+g/gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKJqAUKGiUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECghQSECrUQvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMiegFCh7M1ERwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUJCBUqzEs1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJVLCBUqIqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgVYiIFSolQzaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC8gVCi/kQoCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFsCwgVyvZ8dEeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQBkFhAqVEdtWBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQKlQSVosSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCJAkKFKnFqeiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgvIFTI90CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHlAkKFfAoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKVLiBUqNInqH8CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBIomIFSoaJQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaCEBoUItBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSyJyBUKHsz0REBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAkKFCvNSTYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAFQsIFari4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCVCAgVaiWDdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPILCBXKb6SCAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAg2wJChbI9H90RIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBGAaFCZcS2FQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEkEhAqVhNWiBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhUooBQoUqcmp4JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCwgV8j0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBguYBQIZ8CAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBApQsIFar0CeqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiCQgVKhqlhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFpIQKhQC8HblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7AkIFcreTHREgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQmIBQocK8VBMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUMUCQoWqeLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoJQJChVrJoB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8AkKF8hupIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyLaAUKFsz0d3BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiUUUCoUBmxbUWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAaFCJWG1KAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEClSggVKgSp6ZnAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB+gJChXwPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWC4gVMinQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUOkCQoUqfYL6J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgaAJChYpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWEhAq1ELwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIHsCQoWyNxMdESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFCYgVKgwL9UECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSxgFChKh6uoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEWomAUKFWMmjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgv4BQofxGKggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLItIFQo2/PRHQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECZRQQKlRGbFsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiURECoUElYLUqAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQCUKCBWqxKnpmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoL6AUCHfAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBJYLCBXyKRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFS6gFChSp+g/gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKJqAUKGiUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECghQSECrUQvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMiegFCh7M1ERwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUJCBUqzEs1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJVLCBUqIqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgVYiIFSolQzaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC8gVCi/kQoCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFsCwgVyvZ8dEeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQBkFhAqVEdtWBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQKlQSVosSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCJAkKFKnFqeiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgvIFTI90CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHlAkKFfAoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKVLiBUqNInqH8CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBIomIFSoaJQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaCEBoUItBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSyJyBUKHsz0REBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAkKFCvNSTYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAFQsIFari4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCVCAgVaiWDdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPILCBXKb6SCAAECBAgQIECAAAECBEo3AwoAACAASURBVAgQIECAAAECBAgQIECAAAECBAgQIEAg2wJChbI9H90RIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBGAaFCZcS2FQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEkEhAqVhNWiBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhUooBQoUqcmp4JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCwgV8j0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBguYBQIZ8CAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBApQsIFar0CeqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiCQgVKhqlhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFpIQKhQC8HblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7AkIFcreTHREgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQmIBQocK8VBMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUMUCQoWqeLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoJQJChVrJoB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8AkKF8hupIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyLaAUKFsz0d3BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiUUUCoUBmxbUWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAaFCJWG1KAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEClSggVKgSp6ZnAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB+gJChXwPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWC4gVMinQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUOkCQoUqfYL6J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgaAJChYpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWEhAq1ELwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIHsCQoWyNxMdESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFCYgVKgwL9UECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSxgFChKh6uoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEWomAUKFWMmjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgv4BQofxGKggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLItIFQo2/PRHQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECZRQQKlRGbFsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiURECoUElYLUqAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQCUKCBWqxKnpmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoL6AUCHfAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBJYLCBXyKRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFS6gFChSp+g/gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKJqAUKGiUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECghQSECrUQvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMiegFCh7M1ERwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUJCBUqzEs1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJVLCBUqIqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgVYiIFSolQzaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC8gVCi/kQoCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFsCwgVyvZ8dEeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQBkFhAqVEdtWBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQKlQSVosSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCJAkKFKnFqeiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgvIFTI90CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHlAkKFfAoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKVLiBUqNInqH8CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBIomIFSoaJQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaCEBoUItBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSyJyBUKHsz0REBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAkKFCvNSTYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAFQsIFari4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCVCAgVaiWDdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPILCBXKb6SCAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAg2wJChbI9H90RIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBGAaFCZcS2FQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEkEhAqVhNWiBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhUooBQoUqcmp4JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCwgV8j0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBguYBQIZ8CAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBApQsIFar0CeqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiCQgVKhqlhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFpIQKhQC8HblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7AkIFcreTHREgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQmIBQocK8VBMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUMUCQoWqeLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoJQJChVrJoB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8AkKF8hupIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyLaAUKFsz0d3BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiUUUCoUBmxbUWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAaFCJWG1KAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEClSggVKgSp6ZnAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB+gJChXwPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWC4gVMinQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUOkCQoUqfYL6J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgaAJChYpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWEhAq1ELwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIHsCQoWyNxMdESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFCYgVKgwL9UECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSxgFChKh6uoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEWomAUKFWMmjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgv4BQofxGKggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLItIFQo2/PRHQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECZRQQKlRGbFsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiURECoUElYLUqAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQCUKCBWqxKnpmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoL6AUCHfAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBJYLCBXyKRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFS6gFChSp+g/gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKJqAUKGiUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECghQSECrUQvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMiegFCh7M1ERwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUJCBUqzEs1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJVLCBUqIqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgVYiIFSolQzaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC8gVCi/kQoCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFsCwgVyvZ8dEeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQBkFhAqVEdtWBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQKlQSVosSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCJAkKFKnFqeiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgvIFTI90CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHlAkKFfAoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKVLiBUqNInqH8CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBIomIFSoaJQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaCEBoUItBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSyJyBUKHsz0REBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAkKFCvNSTYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAFQsIFari4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCVCAgVaiWDdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBPILCBXKb6SCAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAg2wJChbI9H90RIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBGAaFCZcS2FQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEkEhAqVhNWiBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhUooBQoUqcmp4JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCwgV8j0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBguYBQIZ8CAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBApQsIFar0CeqfAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiCQgVKhqlhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBFpIQKhQC8HblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7AkIFcreTHREgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQmIBQocK8VBMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUMUCQoWqeLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoJQJChVrJoB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH8AkKF8hupIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyLaAUKFsz0d3BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiUUUCoUBmxbUWAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAaFCJWG1KAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEClSggVKgSp6ZnAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB+gJChXwPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWC4gVMinQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUOkCQoUqfYL6J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgaAJChYpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEWEhAq1ELwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIHsCQoWyNxMdESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFCYgVKgwL9UECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSxgFChKh6uoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEWomAUKFWMmjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgv4BQofxGKggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLItIFQo2/PRHQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECZRQQKlRGbFsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiURECoUElYLUqAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQCUKCBWqxKnpmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoL6AUCHfAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBJYLCBXyKRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFS6gFChSp+g/gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKJqAUKGiUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECghQSECrUQvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMiegFCh7M1ERwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUJCBUqzEs1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJVLCBUqIqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgVYiIFSolQzaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC8gVCi/kQoCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFsCwgVyvZ8dEeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQBkFhAqVEdtWBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQKlQSVosSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCJAkKFKnFqeiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgvIFTI90CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHlAkKFfAoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKVLiBUqNInqH8CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBcQKiQT4EAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSJgFChKhmkYxAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAaFCvgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFAlAkKFqmSQjkGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBIQK+QYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMgr8NFHH8XkyZPjzTffjLlz58bChQujffv20aVLl9hqq61i//33j06dOuVdp7UWLFmyJHr27Jkef+DAgXHbbbe1Vg7nJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKKGAUKES4lqaAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKULLF68OM4///y48cYb8x5l6NChcdlll0W3bt3y1lZDwbvvvhvz5s1Lj7LddtvFN77xjSaP9sknn8S6666bPjvggANyIU0uAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAsUWECpUbFHrESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgSgVmzZsV+++0Xc+bMafaJ2rVrFxMnTow99tij2e9UauGoUaNixIgRafs1NTXRo0ePJo8jVKhSp6xvAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEDlCQgVqryZ6ZgAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAyQUWLlwY3bp1i9ra2kZ79evXTHc+jQAAIABJREFUL3r37p0LG5o2bVqTvbz00kux/fbbl7zPltygkFChL774Irp27Rqff/55ruUhQ4bEmDFjWrJ9exMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSpgFChKh2sYxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBD4XwQOPfTQGD9+fIMlLr300hg5cmSsueaa6f2vvvoqV3f44Yc3qO3bt2/MmDEj1lprrf+ljUy/W0ioUKYPojkCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGqEhAqVFXjdBgCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC/7vACy+8EDvuuGODhZ5++ukYMGDAShefPXt2fPvb347a2tq0Zty4cfGjH/3of2+omSt88skn8cEHH8Qmm2wSq6++ejPf+v9lixYtik8//TQ6dOgQa6+9dt73yxEqlJxp8eLF0b59+2jbtm3enr6uYOnSpTF//vyczxprrFHQWkl41IIFC6JNmzax0UYbrZJvQRsqJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWGUBoUKrTOdFAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAtUpcM4558Tll1+eHu7444+PsWPH5j3sTTfdFMOHD0/rBg0aFBMnTkx/z507N0477bT093HHHRf77bdfk+smYURLlizJPdt1111jxIgRTdb99a9/jV//+tfx0ksvRU1NTVrTr1+/GDhwYJx99tkrDeNJQnYefPDBGD16dDz33HMN1u/YsWMcc8wxkZy9e/fu6bObb745nnjiidzv119/PV577bX02V577RXrrbdeg3VuvPHG2HTTTXP3hg4dGsmeybXbbrvFKaec0uSZZs6cGWPGjIkklKl+SFO7du3iyCOPjBNPPDG22267Jt+95JJL4m9/+1vu2aGHHhqDBw+Oup6nTJmSvrPDDjvET37ykzjhhBNitdVWa3Ktjz76KG655Za4/fbbG9gmxb17945kfscee2xsuOGGeb8NBQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAuUTECpUPms7ESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgIgW7dusWcOXPSXt9+++3o0qVL3t4//fTT2GKLLWLBggVp7ccffxzrrrtu7vff//73BmE4SeDOz3/+8ybXbdOmTXr/sMMOi/vuu69B3eeffx6XXnppXHTRRV/bV9euXeP++++PJGSo/vXf//43Fzr07LPP5j1XEjw0ZMiQXN2BBx4YDz/8cN536grqn7/+mYYNGxZ33313o3Weeuqp+N73vpd3/SeffLLJuv333z/qwoPOO++8ePXVV+Ohhx5a6Xq77757TJ06NdZZZ50GNUlg0oABAxrMsqlFEt/JkyfHtttum7dnBQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAuURECpUHme7ECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgIgS+++CLWWmuttNfOnTvHO++80+zeDznkkEhCeOquWbNmRa9evXI/ixkqdNlll8W5557brL7atWsXSTDShhtumNb/4he/iCTUqLlX0nsSnFNIqFDHjh1j/vz56Rb5QoWaGyhUt2BTwUL1Q4Wae7bE8uyzz07Lly1bFltvvXXU1NQ0a4kkWGjmzJnRtm3bZtUrIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKK2AUKHS+lqdAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEUJvPvuu7HZZpulPQ8cODAeffTRZp/hrLPOiiuvvDKtf+aZZ6J///6538UKFXrrrbdiq622atDTb37zmxg6dGhssMEGMW/evLj44ovj1ltvTWtOP/30uOaaa3K/VwxOSu6NHz8+dt111+jQoUO8+uqrce+996b1yfPRo0fHKaecEtOmTYv3338/t87kyZNj3Lhx6R7XXnttA7v27dvH97///fT514UKzZ49O7p3797gTMl5kvCjLbfcMv75z3/GDTfcEA888ECDmjfeeKPBe02FCvXt2zeSuey8887x73//O3eu5Lz1r8WLF6ehS88//3yutu7q3bt3XH/99dGvX79IAodefvnlSIKIHnvssVxJEto0derUnJ+LAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg5QWECrX8DHRAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIDMCr7zySmy//fZpPyeeeGLcfPPNze7vlltuieSdumvChAkxePDg3M9ihQol4T5JyE3ddf/998ehhx7aqMd99903F3ZTd33++eex5ppr5kKBOnXqlN4fPnx4LrBnxeuCCy6Izz77LHeezTffvNHzUaNGxYgRI9L7NTU10aNHj5VafV2o0Pnnn58LQqq7zjzzzAbhTHX3zzjjjAZhR7/61a/ioosuSt9bMVSoZ8+e8ec//zk23njjBn1973vfi6eeeiq9lwQJJaFByfXggw/GIYcckj5Lgozq/04efPLJJ3HCCSfELrvsEkcddVQuWMhFgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCQDQGhQtmYgy4IECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIZELgxRdfjB122CHtJQnNufrqq5vd29133x1HH310Wj9+/Pj44Q9/mPtdrFCh+oE4Xbt2jdmzZzfZ38MPPxwHHnhg+uyNN96I7t275wJx1l133fR+EqYzceLE2HTTTZt9zqSwmKFCvXr1iiSUKLmSgJ5333031ltvvUb91NbWxmabbRbJv8nVu3fvePXVV9O6FUOF6oc61V8sCQoaOnRoeuu+++6Lww47LPf7iSeeiL322it99rOf/Sz3DdQ3KwhKMQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQFkFhAqVldtmBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLItMGvWrNhmm23SJocNGxZJUFBzr2uvvTZOP/30tHzq1Kmx9957534XK1Ro/fXXT0N1OnfuHBdffHGT7c2dOzcuuOCC9NkjjzwS++yzT+53/RCfuoL+/fvH1ltvHd26dcuFD333u9+NTp06rfToxQwVatOmTbrPwIED49FHH13pvj/4wQ/i8ccfT58vW7Ys/f+KoUJvvfVWbLHFFo3WmjFjRuy0007p/dGjR8cpp5yS+/3ee+81GbCU2PXo0SNnk/glPk0FHzX3W1FHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQGgGhQqVxtSoBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBihRYtGhRdOjQIe19l112ienTpzd5lqVLl8ZDDz0UhxxySNSF4iSBQkmwUN1VU1OTC6JJrmKECn388cfRrl27VbL97W9/G0cddVTu3SlTpkQSwJPvSoKGxo4dmwsbWvEqVqhQbW1tJEFJddfw4cPjhhtuWGlrJ510UowZMyZ9npisu+66ud/1Q4USp48++qjJdV5//fUGZ0pmduqpp6a1Z511Vlx55ZX5eOKYY46JxKF9+/Z5axUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiUR0CoUHmc7UKAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgIgSWLVsWq622WtrryoJpPv300zjiiCNyoULnnXdeXHzxxbl36ofaJL8/++yzWGuttXLPihEq9MEHH6xygE39UKGknz/+8Y9x3HHHxYIFC/LOZtasWdGrV68GdcUKFVrxTKeddlouqGdlV/J89OjR6eMkOKguaKm+f8eOHWP+/PlNLpMvVCgJjEr2GDlyZF6bnj17xssvvxzrrLNO3loFBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECpRcQKlR6YzsQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCiBAQMGxLRp09Ken3jiidhzzz0bnGHIkCG5QKG66/rrr4+DDjooNt988/Re165dY/bs2envFUOFrrnmmjj99NMb2fzrX/+Kzp07p/cPO+ywuO+++3K/v/rqq1h99dXTZ3vttVdccMEFzfLt3r17JEE79a8vv/wyXnnllXjuuefijTfeiDfffDNefPHFmDdvXoO6/fbbLxdCVP8qVqhQ0sMaa6yRLj148OCYMGHCSs+UOE+aNCl9nrxfFwRVrFChusWXLFkSf/nLX+KFF17I2dTU1MSMGTOitra2kUUSduQiQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoeQGhQi0/Ax0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJTAmDFj4qSTTkp72mGHHXJBMnXBNcmDJFAoCRaqf/Xu3Ttee+219Nbxxx8fY8eOTX/PnTs3ttxyy/R3EkKTBPOseCXhPQcccEB6u36oUHJz++23zwUBJdfuu+8ef/rTn4rul4QMDRo0KBYsWJBbu127dvHhhx9GmzZt0r1WDBVKQpO23XbblfZS/91hw4bF3XffndZ26dIlDTJKwpiSgKP63nWFSajSFltskdYm4UvvvPNOuk6xQ4WaOswXX3wRf/jDH+KII45IH+cLQir6gCxIgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwUgGhQj4OAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQaCLz//vvRqVOnBvdOPvnkuOqqq2LttddO799xxx1x3HHHrVQvCbtJQm/qrqVLl8aaa66Z/k7Cc2pqamL11VdP73355Zdx8MEHx6RJk9J7K4YKHX744XH//fenz2fOnBl9+vRp1EdtbW1uneT9NdZYo8HzxYsXx3XXXRfJfhdffHGTZzjxxBPjlltuSZ8l72y44Ybp79tuuy2S4KS666abbmoQxrTiol8XKvTjH/847rrrrvSVe+65J4488shGfSVBREcffXR6/9hjj43bb789/V2sUKEk1OiKK66IfffdNzePpq5u3brFnDlzco+S4KkXXnjBXxIBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAGBIQKZWAIWiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCQNYEkIGf48OEN2kqCY84777xcgM9WW20V8+fPzwXfPPXUU43av/DCC+P8889vdL9Xr165IKG6a+TIkXHZZZflQn8WLVoU5557boMgn6RuxVChhx9+OA488MB0jaSv8ePHRxJyU3clayU1zz77bPTr1y+SAKC+ffvmHj/wwAO5MKQkdCi5kjOdccYZscEGG6TvJ4FI2267bVqTPPjiiy8ahBM9+eSTseeee6bv9O7dO66++urYbbfdom3bto3O/nWhQs8880zuvfrXnXfeGcOGDcuFLiXhR0mgUBIiVP96+umnY8CAAemtYoQKnXXWWXHllVemaz744IOx3377pYFSy5Yti0ceeSSSvequoUOHxu9///usfcb6IUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAi0SgGhQq1y7A5NgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4OsFkhCbQYMGxZQpU1aJavr06bHLLrs0eveOO+7IBfqsePXs2bNB2FD95yuGCiXP9t1335g6dWqDZfr37x8bbrhhzJ07N1555ZUGzwYPHhwTJkzI3XvhhRdixx13bNRD165dY5tttomXX3455s2b1+D5PvvskwvSqX8tXrw4tthiiwbBQysuOnv27EjWTa6vCxVKnh911FFxzz33NNvmiCOOiN/97ncN6osRKnTdddfFqaee2qiPJLypQ4cO8dxzzzU686hRo+K0005bpW/FSwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAsUVECpUXE+rESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgagaVLl8bIkSNj9OjRBZ+pY8eO8fzzz+dCd+pfSVjRd77znZgxY8ZK10xCeLbbbruYNGlSrqapUKE5c+bEAQccEK+99lre3pL377rrrlh77bXT2muvvTZOP/30vO/WFSRBREmozorXLbfcEieeeOJK15k1a1b06tUr9zxfqFBtbW0cfPDB8fjjj+fta4899oiHHnoo1l9//Qa1xQgVSuaeBBY98MADeftICvr16xdPPfVUtG3btln1iggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBEorIFSotL5WJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDxAtOmTYskPOfee+9d6VkGDhwYn3zySSS1dVcSDjR9+vRIAobqX0nd+eefH9dcc02j9ZJ1br311rj66qvj+uuvzz0/5phj4s4772xU+9lnn8Xll18eF154YZN9JWE3Bx54YJx99tmx+uqrN6p54okncu8/+eSTKz3XsGHD4swzz4w+ffqstGbChAkxatSoePbZZxvVFBIqlLychC7deOONufPPmzev0XqdO3eOESNGxPDhw2ONNdZo9PyQQw6JBx98MHc/cZ8/f36Tfb/55pvRo0eP9FkSsnTqqaemv7/66qvcHJJz1dTUNLlGu3btcn0k4UwbbbRRxX/nDkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBYBoULVMknnIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBigdra2pg7d268++678Z///CeSUJlvfetbsdVWW0WHDh1yoUJ77713g2ChsWPHxvHHH99kZ8l6//jHP2LOnDmRhOXsuOOOsc466xR8iiQA55133onXX38911fST9++faNt27bNWmvhwoUxe/bs3Bqff/55fPOb38yda8stt4z27ds3a42kKDn/4sWLc8FAS5cuzb2XrLHaaqs1e426wuRMr732Wi5YKFkz6SMx6t279yqtV3ADy19YtmxZvP322zmfBQsW5O5uvPHG0alTp9zZmmu8qvt7jwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoHABoUKFm3mDAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGVCHzwwQex2267xSuvvBJXXXVVjBw5khUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAmUUECpURmxbESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEGgNAu+//34899xzcdBBB7WG4zojAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgUwJCBXK1Dg0Q4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEVl1AqNCq23mTAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkSkCoUKbGoRkCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILDqAkKFVt3OmwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIFMCQoUyNQ7NECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBVRcQKrTqdt4kQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKZEhAqlKlxaIYAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECKy6gFChVbfzJgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyJSAUKFMjUMzBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBg1QWECq26nTcJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECmBIQKZWocmiFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoJoF3nvvvZg7d256xL59+0bbtm2r+cjORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUGYBoUJlBrcdAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKtV+Cmm26K4cOHpwAzZ86MPn36tF4QJydAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECi6gFChopNakAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAk0LCBXyZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECJRaQKhQqYWtT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgeUCQoV8CgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqUWECpUamHrEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYLmAUCGfAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKkFhAqVWtj6BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWC4gVMinQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUGoBoUKlFrY+AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlE/jggw/i448/jo033jjWXnvt/2nfRYsWRZs2baJ9+/YFr7Ns2bJYuHBhrocNNtggfV+oUMGUXiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEChQQKhQgWDKCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDIlsDkyZNj7NixMWXKlAaNde7cOQYMGBAXXnhhdO/evVHTb7zxRvzyl79M748fPz5efPHFuOeee+Kxxx6Lmpqa3LOOHTvGbrvtFldccUV07dr1aw//5JNPxqhRoxr00rNnz+jfv3+cc845MXXq1Bg+fHi6xsyZM6NPnz7ZAtUNAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBARQsIFaro8WmeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQOsVWLJkSfz0pz+NcePG5UW47bbb4rjjjmtQN2PGjNhpp53Se48//njstddeX7vWxIkTY9CgQU3WPPTQQzFkyJCVvt+uXbvYe++944EHHkhrhArlHZ0CAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBAgWEChUIppwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWwIjBgxIkaNGtXsZmbPnh1du3ZN61cMFWrOQkkw0Ny5c6N9+/YNyqdNmxYDBgxozhINaoQKFUzmBQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgTwCQoV8IgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJzAkiVLYsstt4wFCxbkek/CfsaNGxc777xzbLLJJvH222/HySefHJMmTUrPdvzxx8fYsWPT3ysLFTrrrLPigAMOyK0zffr0OOmkk6K2tjZ974ILLoj/+7//S39/+OGH0aVLlwY1O+ywQ1xyySXRu3fvmDNnTkyYMCFuvPHGRs5ChSru09MwAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCDzAkKFMj8iDRIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg8P/YufN4rcf8f+BvNJaIyRKTLREpNINorDHo4YopAAAgAElEQVTWUeGHBiPKnjWFwjc7EyJGC0ZKNZaMJWMPY5nGzqCiUpay1FDIYBL9Htdn5tyPc859n85+Op2e1+PRo+7P51re1/O67vuvHi8CBAgQIECAAIFCAilY6NZbb42rr746/vKXv2SBQsVbCgJaf/31c2E/7du3j5dffjnXpVCo0JAhQ7IQoeLt2WefjY4dO+YeHXDAAfHQQw/lPt91111xxBFH5D7vuuuu8fTTT0ejRo1KzHPhhRfGZZddVuKZUCF3mwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoKYFhArVtKj5CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoNwIHHXRQjBs3LlfPTz/9FMstt1z2uXSoUJs2bWLSpEkFa990001jxowZ2buWLVvG9OnTc/1OPPHE+NOf/pT7nObdfvvtC86z7rrrxpw5c3LvhArVm6uiEAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAgxEQKtRgjtJGCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECCy7AvPmzYupU6fGBx98EO+//34WADRt2rR45plnSqB8//33sdJKK2XPSocKnXDCCXHLLbcUROzUqVM8/PDDuXeLFi3K/bv0u4ULF8YKK6xQcJ6uXbvGPffck3snVGjZvbN2ToAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoLQGhQrUla14CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGpd4NVXX42+ffvG008/XaG1FhcqNHTo0OjZs2fBebp16xZjxozJvSseKrTDDjtkAUWpbb755jFlypQya7n66quzeouaUKEKHZtOBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEClRAQKlQJLF0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKg/AhdccEFceeWVZRbUpEmTmD9/fon3iwsVuu2226JHjx4F51tcqNB2220Xr7/+ejauTZs2MWnSpDJrGjJkSJx22mm590KF6s99UgkBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoKEICBVqKCdpHwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSWIYEXX3wxfv3rX5fY8cknnxw77rhjtG7dOlq2bBnNmjWL448/PoYPH57rVxuhQvvss0+MHz8+t8aiRYvKPInS9QgVWoYura0SIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOpIQKhQHUFbhgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBmhO45JJL4uKLL85N+Pjjj0cK9ynddtlll5gwYULucW2ECh199NExevTo3BofffRRbLjhhgU327Zt25g8eXLunVChmrsTZiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEPivgFAhN4EAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaVOoFu3bjFmzJhc3V9//XU0adKkxD7eeeedaNOmTYlntREqdMMNN0SvXr1y6/Ts2TOGDh2aZ/rkk0/G3nvvXeK5UKGl7uopmAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQ7wWECtX7I1IgAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKlBfr16xdXXXVV7vGgQYPizDPPjOWWWy57Nm3atDj00EPjrbfeKjG0NkKFPvzww2jRokWJdc4///y44IILonHjxrFgwYIYP358dOrUKe8ghQq52wQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAjUtIFSopkXNR4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBArQvcfffdcfjhh5dYp1mzZrHvvvvGxx9/HE8//XTBGmojVCgtdOqpp8bQoUPz1mzZsmXMmDGjTA+hQrV+VSxAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEFjmBIQKLXNHbsMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEln6BhQsXRseOHWPChAmL3czll18e//d//5frU1uhQvPnz4999tknXnzxxcXW079//7jssstyfYQKLf130Q4IECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAvVNQKhQfTsR9RAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCGB2bNnxwUXXBDDhw/P67/zzjvHFVdcEauttlpsv/32uffFQ4XeeuutaNeuXe7dbbfdFj169Ci4dno+cuTI3LtFixbl9fvuu+/ikksuiaFDh0YKGSreNt988+jTp08cfvjhscYaa+ReTZ06NVq1alWh/epEgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoCICQoUqoqQPAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQL1ViCFC02fPj1mzpwZ6623XrRv3z4aN268xOr997//HW+//XbMmjUrVllllayeZs2aLbF6LEyAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBsCQgVWrbO224JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoAELCBVqwIdrawQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwbAkIFVq2zttuCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKABCwgVasCHa2sECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsGwJCBVats7bbgkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgAQsIFWrAh2trBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBsCQgVWrbO224JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoAELCBVqwIdrawQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwbAkIFVq2zttuCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKABCwgVasCHa2sECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsGwJCBVats7bbgkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgAQsIFWrAh2trBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBsCQgVWrbO224JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoAELCBVqwIdrawQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSWtMDnn38eDz74YEyfPj1mzpwZc+fOjfXWWy9atGgRrVu3jk6dOsXKK6+8pMu0PgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEGIyBUqMEcpY0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqD8Cn332WZx33nkxcuTIxRbVrFmz6NOnT/Tu3TsaNWpUfzZQRiWffPJJzJo1K/d26623jlVWWaXe111U4Msvv5yrdc0114zNNttsqaldoQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAhUTECpUMSe9CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCooMDrr78e+++/f8yZM6eCIyIOO+ywGDNmTKy44ooVHrMkOl533XVZCFJRmzp1arRq1WpJlFKlNZdbbrncuG7dusWoUaOqNI9BBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC9VdAqFD9PRuVESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEFjqBD7++OPYcsstY/78+Xm177zzzlkAz6effhqPP/543vvjjjsubr311nq9Z6FC9fp4FEeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBARQoVcAwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEakRg0aJF0blz53j44YdLzHfTTTfF8ccfHyussELu+Zdffhl/+MMf4uqrry7Rd/LkyVkoUX1tQoXq68moiwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoEhAqJC7QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAjQj84x//iJ133rnEXK+//nr86le/KnP+Pn36RArqKWrp88CBAxdbz7fffhvz5s2Lpk2bRuPGjatV+8KFC2P27Nmx7rrrRqNGjcqdqyZChdKac+bMiTXXXDNWXnnlctdcXIe5c+fGcsstl1lUpKW+Ra1bt24xatSoigzThwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYCkSECq0FB2WUgkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUZ4HSAUFnnXVWicCgQrV/8cUXscMOO8SBBx4YXbt2jR133DELySnd3n777Rg2bFiMGTMm5s+fn3vdpEmTOOqoo6Jnz56x9dZbF+S5/PLLI4Ubpfa73/0uDj744Bg6dGg8+eST8fDDD+fGbLvttnH88cfHSSedFMsvv3zueVHf9GDKlCkxefLk3Lu99947VltttRLrDh48OJo3b17i2aeffhpXXnllpOClolpShzZt2kSHDh3iwgsvjI033jiv/mnTpkXfvn1zz8eOHRtvvPFGjB49Oh5//PGYOnVq9q5Zs2ax++67x4ABA6Jly5a5/p999lmcccYZkYKMUrv//vtz79KY0iFQe+yxR5x++un1+ZqpjQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoBwBoUKuCAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECNSKw4YYbxqxZs3JzpSCd9dZbr9pzP/PMM5HCbsprTz/9dMF+nTp1yoUH/d///V9MmjSpRLhO6Xk7duwYjz76aKy88srZqy5dusRf//rX8pbPvf/mm29i1VVXzX2+++6744QTTigRhlRoslGjRkW3bt1KvHrllVey0KWiNn78+EhBRotrDzzwQBbSlNprr70W22+/fYVrTz6XXXZZhfvrSIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUP8EhArVvzNREQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGlTmDBggWx0kor5epu2bJlTJ8+vdr7qGigUNFChYKFiocKVbSgK6+8Ms4777yse2VChZo1axazZ8/OLfP888/HbrvtVtFl44UXXogOHTrk+pcOFarIRE2aNIkPP/wwmjZtWulQoREjRkT37t0rsow+BAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC9VRAqFA9PRhlESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEFiaBD755JNYf/31cyXvv//+8cgjj1RrCymUaLPNNisxR9euXeP000+PFi1axPvvvx833nhj3HPPPSX6TJs2rcS4QqFC22yzTfTr1y923HHH+Pzzz+Paa6+NsWPHlphn3rx58fOf/zxSMNBnn32WvXvwwQdjzJgxuX6DBg0qse8U5LPXXntl7xcuXBjt2rWLyZMn5/r36tUrzjnnnGjevHmk+W+//fY466yzcu+33XbbePnll2OFFVbInpUVKpRq79y5c6y77rpZENEpp5wS8+fPz81z8cUXx0UXXRRz586Np556Kvc8+RW1nXfeOc4888wSe07PUm0aAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA0isgVGjpPTuVEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKg3Am+99VYWoFPUevbsGUOHDq1WfRdeeGFcdtlluTnOPffcuOqqq/LmPPvss7NQoKLWv3//uPTSS3OfS4cKbb755vH3v/891llnnRJz7bHHHvHMM8/knqVwn/bt25foc91110WfPn1yz6ZOnRqtWrUquM/77rsvDjnkkHJNBg4cmAUNFbUJEybETjvtlH0sFCo0ZMiQLESoeHv22WejY8eOuUcHHHBAPPTQQ3l1Lbfccrln3bp1i1GjRlXrjAwmQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCofwJCherfmaiIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwFIn8MYbb8S2226bqzsF76SwnOq0LbbYIlJoT2pNmjSJTz75JFZbbbW8KefPnx/rr79+pL9Ta9OmTUyaNCnXr3SoUAr7Ofjgg/Pmueeee6Jr166553feeWccfvjhJfpVJlQoBSKlYKSiNmvWrKzO0m3u3Lmx1lpr5R6PGDEiunfvnn0uHSpUem/F59p0001jxowZ2aOWLVvG9OnT89YSKlSdG2ksAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGDpEBAqtHSckyoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI1GuB9957L1q1apWr8ZhjjomRI0dWq+biATj77rtvPPbYY2XOt88++8T48eNz7xctWpT7d+lQoQ8++CA23njjvLlKB/hcf/31ceaZZ5boV5lQoW7dusWYMWNy41NYUFmtR48euVf9+vWLP/zhD9nn0jWdcMIJccsttxScpvQ+ixsUDRAqVK0raTABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYKkQECq0VByTIgkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUb4EFCxbESiutlCty1113jeeee67KRc+fPz9WX3313PjTTjstbrzxxjLnO+WUU2LYsGG59998802suuqq2efiYTtNmjSJr7/+uuA8U6ZMidatW+feDRo0KHr16lWib2VChXbYYYcsFKiyrXv37lEUQFQ6VGjo0KHRs2fPglOWDjESKlRZef0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg1DQKhQwzhHuyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwxAU23HDDmDVrVlZHs2bNYvbs2VWu6csvv4ymTZvmxp911lmRAn3Kaun99ddfn3udgoNSgFBqxUOFFldXTYcKbbfddvH6669X2mBxoUK33XZb9OjRo+CcQoUqTW0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKBBCggVapDHalMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6l5gv/32i8cffzy38GuvvRbbbrttuYV8/PHH0bx581huueVyfX/88cdo1KhR7vPBBx8c9913X5lzHXTQQTFu3LgS45dffvns85IKFerSpUv89a9/zWpIAUePPfZYuRapQwo+2myzzbK+r7zySuywww65cUKFKkSoEwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgmRYQKrRMH7/NEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKg5gYsuuiguvfTS3ISdO3eOBx98cLELzJ07N9Zaa61o2bJl9OzZM4488sgsYCi1DTfcMGbNmpX9O72fNm1aFAUFFZ/0p59+io033jjXd4MNNoiZM2fmutRmqNDEiROjbdu2Bfd47rnnxjXXXJN7991338XKK69cKfDaDBXq2rVr3H333ZWqR2cCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH6LyBUqP6fkQoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQILBUCX3zxRWyyySYxf/78XL3XX399nHHGGbHccsvl7WHBggXRrVu3GDt2bO5d9+7dY8SIEdnnHj16xMiRI3PvRo8eHUcddVTePKNGjYpjjjkm9/zYY4+N4cOH5z7XZKjQrbfeGieccEJu7iFDhsQpp5xS8HxuueWWOOmkk3Lvbr755jjxxBPz+i5atCjuuOOO+O1vfxtNmzYt8b6mQ4VWX3313Pk0adIkUqhTo0aNlor7pUgCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGKCQgVqpiTXgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVEDg2muvjbPPPrtEz86dO2fBO23bto31118/C7KZMGFCDBgwIF588cUSfadNmxabbbZZ9uy5556L3XffvcT7FDiUgohWWGGF+PHHHyMFCqUQoeLt2Wefjd122y33qCZDhZ5++un4zW9+k5u7TZs2MXDgwKzOxo0bl6jj448/jg022CD3LIX43HfffbHXXnvlnv3www/Rp0+fuPHGG6NZs2aRgocOOuig3PuaDhXaZZddMvuiduGFF2aeReYVOGJdCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6rmAUKF6fkDKI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILA0CXz33Xex/fbbx+TJkytd9hVXXBHnn39+iXFHH310jB49Om+uzTffPKZOnZr3/Mgjj4w///nPJZ7XZKjQvHnzYuONN4758+eXub/p06dHy5Yts/fXXHNNnHvuuSX6brPNNtGqVav46KOPIoUGFW8phGjixImxxhprZI9rOlTo8ssvj/79+5dZ+4knnpgFG2kECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJLr4BQoaX37FROgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoF4K/Pvf/45+/frF4MGDK1zfjTfeGKeddlpe/xTec8ghh8T48ePLnWvPPfeM+++/P1ZfffUSfWsyVChNfNNNN0XPnj3LrOfdd9+NLbbYInv/n//8J373u9/FuHHjyq2/TZs22T6bN2+e61vToULpbFq3bh2zZs0qWM9RRx1VMMSp3OJ1IECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqDcCQoXqzVEohAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEDDEnjiiSfi8ssvj3/+85+RwoEKtRNPPDFOPfXU2Gabbcrc/I8//pgFFA0cOLBgGM4GG2wQffr0yUKJGjVqlDfPoYceGvfee2/2vFmzZjF79uyCa7333nvRqlWr3LtBgwZFr169Cva977774rrrrosJEybkvS8eKlT08q677oozzzwz5syZk9e/ZcuWsddee8WAAQOiadOmJd6/9dZb0a5du9yz2267LXr06FGwpvR85MiRuXeLFi0q2O/zzz+P/v37R9pD6XqECjWs76DdECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAsumgFChZfPc7ZoAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAnQmkcJtPPvkkUthOCrFZZ511Yv3114+NN944GjduXOE6fuR6epoAACAASURBVPrpp5g8eXIWLDRv3rwsgCcFCrVp0yaWX375Cs9Tkx2//fbbrJYUfLRw4cJs6hYtWpRZz7/+9a+YOnVqzJw5M9Zee+341a9+FWuttVZNllThudK5pHoWLFiQ/UltjTXWWGL1VLhwHQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBBYrIFTIBSFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg1EQKhQAzlI2yBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkKF3AECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINBABIQKNZCDtA0CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBUyB0gQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQINRECoUAM5SNsgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJChdwBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQQASECjWQg7QNAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVMgdIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwP8ElltuuZzFokWLuBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBY6gSECi11R6ZgAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRqS0CoUG3JmpcAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCuBIQK1ZW0dQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqPcCQoXq/REpkAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoBwBoUKuCAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBP4nIFTIVSBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEFjaBYQKLe0nqH4CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGpMQKhQjVGaiAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYAkJCBVaQvCWJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg/gkIFap/Z6IiAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBygkIFaqcl94ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDRgAaFCDfhwbY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsIwICBVaRg7aNgkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKF9AqFD5RnoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUbwGhQvX7fFRHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEAdCggVqkNsSxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNSKgFChWmE1KQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECS6OAUKGl8dTUTIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUFxAqJD7QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgf8JCBVyFQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBJZ2AaFCS/sJqp8AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgRoTECpUY5QmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWEICQoWWELxlCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCofwJCherfmaiIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgcgJChSrnpTcBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg1YQKhQAz5cWyNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQILCMCQoWWkYO2TQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEyhcQKlS+kR4ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQL1W0CoUP0+H9URIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCHAkKF6hDbUgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABArUiIFSoVlhNSoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA0iggVGhpPDU1EyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFBcQKuQ+ECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4H8CQoVcBQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaVdQKjQ0n6C6idAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoMYEhArVGKWJCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIElpCAUKElBG9ZAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqn4BQofp3JioiQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBConIBQocp56U2AAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQAMWECrUgA/X1ggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECy4iAUKFl5KBtkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB8gWECpVvpAcBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgED9FhAqVL/PR3UECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNShgFChOsS2FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQK0ICBWqFVaTEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwNAoIFVoaT03NBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECxQWECrkPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ+J+AUCFXgQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYGkXECq0tJ+g+gkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqDEBoUI1RmkiAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBJSQgVGgJwVuWAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIH6JyBUqP6diYoIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQqJyBUqHJeehMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0IAFhAo14MO1NQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAMiIgVGgZOWjbJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgfAGhQuUb6UGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFC/BYQK1e/zUR0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAnUoIFSoDrEtRYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCsCQoVqhdWkBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsjQJChZbGU1MzAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAcQGhQu4DAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE/icgVMhVIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWNoFhAot7SeofgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEakxAqFCNUZqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgCQkIFVpC8JYlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKD+CQgVqn9noiICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHKCQgVqpyX3gQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQINGABoUIN+HBtjQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwjAgIFVpGDto2CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoX0CoUPlGehAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNRvAaFC9ft8VEeAAIEaE/j666/jnHPOif/85z8l5jz22GNjt912q7F1lpWJ5s6dGyeffHLeds8+++zYYYcdlhUG+yRAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECDExAq1OCO1IYIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAsucgFChZe7IG+6GP/roo7jqqqsqtMGVV145mjdvHuuvv372JwWArLTSShUaq9N/BYYNGxYTJ04swZFcr732WkT1VGDSpEmx1VZb5VU3YsSI6N69ez2tumbKOuuss2LBggXlTtakSZNo1qxZ9vuw6667Zr8PZbVPPvmk4Ptx48ZFly5dyl1LBwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBConwJChernuaiKAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg4gJChSpupWc9F3j99ddju+22q1KVKUjkxBNPzIJVCoWuVGnSSg7629/+FosWLSoxascdd4xVV121kjPVTfeDDjooUnhK8ZYcv/7667opYBle5YMPPogZM2aUEFhnnXVi6623XqzKshwqVPw/fFbm6nTo0CH69esXBx54YN4woUKVkdSXAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECS4+AUKGl56xUSoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUFhAqJCb0WAEqhMqVBzhqquuinPOOSeqGkJSVdBC6w0ZMiROOeWUqk5Zq+OECtUq72Inv/rqq6Nv374l+lQk0EmoUNXP7OCDD47bb789knNREypUdU8jCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUJ8FhArV59NRGwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQEUEhApVREmfpUKgpkKF0mYPPPDAuPvuu2OllVaqs70XChUaPHhwnHrqqXVWQ2UWEipUGa2a7VsoVCitsGjRosUuJFSoeudwwAEHxAMPPBCNGjXKJhIqVD1PowkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBfBYQK1deTURcBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBFBYQKVVRKv3ovUJOhQmmzffv2jQEDBtTZvoUK1Rn1Ur9QVUOFZsyYEUcffXTe/s8777xIgTkNuRX6flVlv9dcc02cffbZ2VChQlURNIYAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQL1X0CoUP0/IxUSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsXkCokBvSYATKChU64YQTonPnzrl9/vjjj/Hhhx/Gu+++G88991xMnjy5TIO//e1v0bFjxzoxEipUJ8wNYpGqhgo1iM1XcROFvl8dOnSI888/PzfjggULsqCg9L2///77C67UrFmzmDVrVvzsZz8TKlTFszCMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC9V1AqFB9PyH1ESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCcgVKg8Ie+XGoGyQoWGDBkSp5xySsF9/PTTT3HTTTfFqaeeWvB9Ch154YUXFmvwww8/xGuvvRYff/xxFjLy3XffxSqrrBJbbLFF/OpXv4p11lmnQoY1FSpUU/WUV/RBBx0U48aNK9GtSZMm8fXXX5c3tMT7dAbTpk2Ll19+OWbPnh0tWrSILbfcMlq1ahUrrrhihedKYVGvvvpqvP/++9lZrLnmmvHLX/4y2rZtW6l5Ci2YzvS9996LKVOmZIFUTZs2jdatW2d1pn9XpqU7kmr86KOPsvuywgorxHrrrRfNmzeP7bbbLlZdddVyp1sSoUILFy7MfFOgzqeffhrp8y9+8YvYYIMNsrrTna9OS4E+b775ZrZG+vfmm2+eGW+88cax/PLLV2fqbGyh79dhhx0WY8eOLTj3G2+8EbvvvnvMnz8/730KI9t1113LDRX6/vvv45133sn29fnnn1f5bqcCJk6cGB988EF2t7/66qto1KhRNl/6jUl/F9pfWWhpfPrOpTs4c+bMSL8ZKSwp3cH0fUnnWpmW7kL6XkydOjX7nqTzSr9/6fuR5qxMbZVZV18CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUloBQodqSNS8BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBdCQgVqitp69S6QFVChYqKeumllyIFCBVq06dPj5YtW+a9mjdvXgwaNChuvvnmmDNnTpn7S2P/+Mc/xgEHHFCiz6abbhozZsyokksK30khIMVbdeupbCEVDRVKwTnrr79+iel79eoV11xzTZx//vlZqFOh4JYUUHTbbbfFoYceWm5po0aNiksuuaRMz2R/++23x1133RWnnXZaifkeeeSR2H///QuuMXny5Cxw6plnnimzhhR+86c//Sl22223xdaZ7ueAAQPinnvuWWy/k08+Oc4999zYZJNNcv1S3UcccUS5DoU69O3bN1s3tUJnkZ6ncKguXboUnP+LL77IzmrEiBFl3vN0Vt26dcvqTiFAhVrad9euXUu8uu+++7JwnmOPPTb++te/Fhy3zTbbRDrfdu3aVWn/RYMqGyqUxg0bNqxgINno0aPjqKOOKtPz/vvvz+5inz59CtZc0budgrKGDx8eN9xwQ6S7WFZL81144YWRvlcpbKisls7/+uuvz85zca1z585xzjnnZGezuDZ37tzszFONi6tt4MCBccIJJwgXqtYNNpgAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboUECpUl9rWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqA0BoUK1oWrOJSJQnVChVHCPHj1i5MiRebVfddVVWXBG8TZx4sQ48MADKxUKlIJTUvjM8ssvn0214YYbxqxZs6pk9f3338dKK62UG1sT9VS2kOqECu27775Z+MnDDz9c7rLHHXdc3HrrrQX7LVy4MM4888wYOnRoufOk8J8999wzCzEq3lKYTadOnUo8++GHH7LglQsuuKDceYs69O7dOy6//PJYZZVV8sYMHjw4Tj/99ArPlUJi/vKXv8Q+++yTjbnzzjvjyCOPrPD44h1T2FIKnEmtsqFCzz77bBYEtLjQrOJrpbpTwMxhhx2WV2uhUKFkku5ARcK1UsBU+o5WtVUlVKis35Qrr7wyzjvvvDI9K1rj4u52Cgn7/e9/H48++mhFp4v27dtn4Uzrrrtu3pgXX3wxfv3rX1d4rtTx6quvjrPPPrtgGFAKTkoBWBW9G+k7n77HG2ywQaVq0JkAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJLQkCo0JJQtyYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBNCggVqklNcy1RgeqGCr333nvRqlWrvD2kgJSxY8fmnn/xxRexySabxPz58yu931GjRkW3bt2ycVUNFUqhHDNnzqzxeiq7meqEClV2rULBP2mOSy+9NC666KLKTleif6G5UwjPZZddVul5+/btGwMGDCgx7sknn4y999670nOlAe+++25sscUW1QoVuuOOO+KII47I1q9MqNArr7wSO+ywQ5XqfuCBB7LQreKtUKhQZSf/+OOPo3nz5pUdlvWvSqjQpEmTYquttspbL927/v37VztUKE1c6P4tWrQoUgjP+PHjK73XFF6Wgp2Kt3/961+x6aabVuk3a/To0XHUUUfVyJ1OoUcp3KgoWK3SmzOAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECdSQgVKiOoC1DgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQawJChWqN1sR1LVDdUKGffvopVlhhhbyyO3ToEC+88ELu+UknnRS33HJLlbbXrFmzmD59eqy22mpVDhU64IAD4qGHHqrxeiq7oboMFWrZsmW88847seKKK+bKnDx5crRt27ayZef1Lx3qMmXKlGjdunWV5y0KAiqaoFOnTvHwww9Xab4URvTEE09UK1TopZdeyoUDVTRUaN68ebHNNtvErFmzqlR3GpTueTq3olYToULdu3ePESNGVKmmqoQK3X333XH44YfnrXfdddfFWWedVSOhQoXu9p133hlHHnlklfaZBr366qux3Xbb5canevv06VOl+Zo0aZKFmK2xxhrZ+O+//z773s2YMaNK8xUPVqvSBAYRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgDgSECtUBsiUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRqVUCoUK3ymrwuBaobKpRqTWEZKaymeEtBQLNnz849eu655+Lss8+OV155JfesTZs2cfXVV2dBHmuvvXa88cYbkQJQSs+VBjz//POxyy67xHnnnRdz587NzVEoqCgFGqVwl+Jt1113jaOOOqrG66nsWdVUqFDXrl2jS5cuseqqq2ZhScOHDy9Yyj//+c9o165d7l0Kdbn++usL9k3vknEKiXr22Wdj0KBBZW6vdKjQPvvsE+PHj8/rf+KJJ8Y555wTLVq0iK+++ioefPDBOPPMM2P+/Pkl+h544IHxwAMPZM8WLVoUyy+/fN5c6UxT0Ev6+5tvvsnuS/o8YcKEXN8UKJTuWarnxRdfLBGmk0Jj0n0v3VKNpduAAQOiadOm2eOKhgoNGTIkTjvttIJmp59+euy+++5ZwNPLL78cl19+eZlnkPZU1MoLFerdu3d07Ngxvv7667j55puz70mhlkyr0iobKvTll1/GzjvvXPA7/NRTT8Wee+5ZbqhQVe92Cuzp379/3HHHHSW2evvtt8dOO+0Um2yySRb0c+6550ZyLd2uuOKKOP/883OPywq2uvfee2PbbbeNxo0bR/p+jR07tsT3b/PNN8/u/NFHH50L9PrDH/5QYu6iRdLv0sCBA7M7nQLa0p3t2bNnTJ06tUR56fc07S993zUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjUVwGhQvX1ZNRFgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQUQGhQhWV0q/eC9REqFChoJy08dJBJulzCsDp169ffP7551nA0EYbbVTCKAXFpMCO0m3EiBFZ4FDpVij0ZPDgwXHqqaeWa18b9ZS3aE2ECl1yySVx4YUXllgqmV511VV5y6cAlP/3//5f9vzHH3+M5s2bx5w5c/L6PfPMM1noTfGWQmD22muvglsqHiqUznKdddbJ65fOthmHcwAAIABJREFUK51b6TZy5Mjo0aNH3vOFCxdmgUbffvttwfCUW2+9NY477rgS41KYzqGHHpqFFqVAn9JhUsU7pwCrvn375q1bXuBORUOFCoVrpcVSoFYKjynepkyZEq1bt86rpUmTJlkY1yqrrJK9W1yoUApxKn4+P/zwQ+y2225ZME3p9tlnn8W6665b3vWs0Perc+fOJc51wYIF8emnn8YLL7yQhTyl8JvSLe0r3ZMUqlSWZxpT1btdfL0333wzCxdKd/Txxx/PAqaKt3S/UsBQ6e9B6fv661//Os8yBZONHj26xHzp/vTp0yfefffdOOOMM7L1SodiFbobKXwo/d6lcKLiLc2z5ZZb5hmmc91xxx0rfYYGECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK4EhArVlbR1CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEaktAqFBtyZq3zgVqIlSoa9euWfhJ6VZWWEsKt0lhME2bNi04pnQgR+qUQkIuvfTSvP7VCRUqmqwm6ynvAKsbKpQCl1577bW8ZcoKaklBQ+eee27W//3334+WLVvmjT355JNj2LBhBUs/5ZRTCr4rHiqUwk5SAEvpNm3atNhss83ynpcVGvThhx9mIVM//fRTFi5UuqXae/fuHTvttFMWIlTo/izOvzZDhVJATaHQnp49e8bQoUMLljVw4MA455xz8t6lsK3tt98+e15WqFA600IhUmX1T4E/HTp0KO96Vuj7VelJIrIwqBQKlVpZd7U6d7tQTSnEaO211y5Ybgrauv/++0u8Sz7JqaiVFZaWfov222+/LJhovfXWi0K/QcUnTmFZP/vZz/LqKCsoLXXcZZddYsKECSXG3HHHHXHEEUdUhd8YAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI1ImAUKE6YbYIAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBALQoIFapFXFPXrUBNhAoVCsBo1qxZzJ49u8zNfPTRRzF58uT44IMPsj8zZsyIKVOmxFtvvVVwzBlnnBE33HBD3ruaCBVKk9ZUPeWdXnVDhXr16hWDBg0quEwhixRak8J0UnvppZcKBss8+uijWUhKofb3v/89dt1117xXxUOFxowZE926dcvrc9ppp5XJMXjw4Lx3Tz/9dOyxxx7Z80J3qvSAJk2aRNu2bWP33XePvfbaK6tzpZVWKnPN2gwVSve2Xbt2eWs/9NBDccABBxSsadKkSbHVVlvlvRs3blx06dIle15WSNB9990XBx98cN7Ysuoofl7l3dHi78sLzKnIXJtvvnl2937+859n3csKFarO3S5UxxdffBHJOP22FP3GpKCr9Gz+/Pl5Q1Kd6TeoqF100UUFg8xKD9xmm22y71W6g7/5zW9izTXXLNGlrDCvvffeO7bYYouChA888EDMmjWrxLtLLrkkLrzwwoqQ60OAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIElIiBUaImwW5QAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAGBYQK1SCmqZasQE2ECq2++up5IR0pMOOJJ57I29xzzz0Xffv2jRdffLFSG6+tUKGarqe8TVU3VGj06NFx1FFHFVxm0003zQJUirfioUIPP/xwdOrUKW/su+++W2a4SVkBMMVDaioavlKezYgRI6J79+5Zt9tuuy2OO+648oaUeN+mTZu44447Cob7pI61GSr02GOPxf77759X78SJE7Pgo0ItBduk707pNmzYsDj55JOzx2WFCqWgmhYtWuSNnTlzZmy00UZ5z5dUqFAKF0vfseLhOWXdqerc7eIbnj59elx88cWRwq4q00qHCpUV+rS4OVPQ1fDhw+Owww7LdXvyyScj/R5Wtx1zzDExcuTI6k5jPAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGpNQKhQrdGamAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoI4EhArVEbRlal+guqFC33zzTaQgjdLt9NNPjz/+8Y+5x/PmzYtu3bpFCrapSqvpUKHaqqe8vVU3VGjcuHHRpUuXgsuUFyr04IMPxoEHHpg3tqyAmtQxOa255pp5Y4qH1PTu3TsGDRpU3tbLfX/LLbfECSeckPVbtGhRHHLIIXH//feXO650hzfffDO22WabvHG1GSqUziWdben28ccfR/PmzcvcQ/H/UFnUKVn26tUr+1hWqNDnn38ea621Vt689SVUKP0mpGCfFI7UuHHjEnWWFSpUnbtddGf69euXhUdVpZUOFUpz3HDDDbmzqMycN910U5x00knZkLLuRmXmS32PPPLI+POf/1zZYfoTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgzgSECtUZtYUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRqSUCoUC3BmrbuBaobKjRy5Mjo0aNHXuGDBw+OU089Nff8uOOOi9tuu63cDTZr1izmzJmT16+mQ4Vqq57yNrgkQ4WeffbZ6NixY16Jzz//fOyyyy4FS3/jjTdi2223zXtXPFSof//+cfnll5e39XLfFw8VSp1/+umnGD58ePTp0yfmz59f7viiDu3bt48XXnghVlhhhRJjajNU6LHHHov9998/r8aJEydG27ZtC9ZeViDXsGHDsjCe1OprqFAK4Cne1llnnWjVqlWkYKvNNtss9ttvv/j5z39ecN+1FSo0ZsyYLLisvJYCjwrdp0KhQmmu5557Lnr27BmTJ08ub+oS74sCpZ544onYd999KzW2UGehQtUmNAEBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABArUsIFSoloFNT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUOsCQoVqndgCdSVQnVChFIqSQkQKhQA9/vjjsc8++2TbmDJlSrRu3TpvSylAKAUSdejQIVKgR4sWLaJx48ax7rrr5s1Zk6FCtVlPeee2JEOF3nnnnWjTpk1eiddee2307t27YOkp4OaUU07Je1c8VKisYKkUqFOZ1rx582jatGnekB9//DHefPPNLNwl7eG9996LNHehe1c0eOrUqVnITfFWm6FCb731VrRr1y6v9kceeaRg2FDqOGnSpNhqq63yxowbNy66dOmSPa+PoUKHHXZYjB07tjJHW6JvbYUKFfrdSAunALEUppXu/iabbJLdsUKhYmWFChUVP3369OwOprOeNm1adhdnzJhRpkMKUUu/b+m+lr6LadBf/vKXgr+LZU24xhprxAYbbFBldwMJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQ2wJChWpb2PwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQK1LSBUqLaFzV9nAlUNFUqBLieffHLcf//9ebWm4IsU3JMCglK7995749BDD83rl0JVSofczJ8/P1ZfffW8vpUJFerZs2cMHTq0TMParKe8g1uSoUIpBKpJkyZ5JaZnM2fOjBRaUrx99dVXWdhTofCe4qFCEyZMiF122SVv3g8//DA22mij8kjKff/FF1/EWmutldfvX//6V9x4441x2WWX5b178MEHo3PnziWep/Cks88+O69v2vviwloqEoKTakkhWaVbCmQaMmRIwT2WVc8rr7wS22+/fTZGqNB/6VJ4WekAn3POOSdSUFRqs2fPjvXWWy/P+eabb44TTzwx7/kOO+wQybl4W1yo0Ny5c7MwouL/ATaN/e677yKFQB1xxBF5a/Tp0ycGDhwYP/zwQ6y44op57++4446C48r9QuhAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBeiogVKieHoyyCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKiwgVKjCVDrWd4HKhAqlYI1p06bFq6++Guedd16kAKBC7YEHHogDDzww9+qqq66Kfv365XVNITerrrpqiecDBgzI5i7dygoVKhQ2kkJyUsjLSiutVLC+2qynvPNekqFCqbZC66fnKdzptttui+222y7bQroX3bp1i6lTpxbcUvFQoc8++yx+8Ytf5PVLoVPDhg3Le75o0aK49NJLY/r06ZGCddZZZ52Ca7z88stx8cUXx6OPPhrF1yve+csvv8zCXkq34cOHx7HHHlvi8V133VUwxOX666+PM888s8yjq0ioUBrctm3bmDx5ct48zz//fF7oUgrdat26dV7fdHdTiNPKK6+cvRMq9F+i8kKFyvL829/+Fh07dizhXFYIVqFQoRQ4lYKLBg8eHH379o30+1Sope9N+s4Ub+n7M2rUqOzRFltskfddSutNnDgxfvazn+VN+dBDD8WgQYPiuuuui3bt2pX3s+I9AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6oWAUKF6cQyKIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqIaAUKFq4BlavwTKChWqapX7779/PPLIIyWGjxw5Mnr06JE3Za9evSKFBW2yySbx1VdfZQE0hQKF0sCyQoU6deoUDz/8cN7czZo1i9///vex2WabZe9SwNAxxxwTjRo1itqspzy3JR0qdO+998ahhx5aXpnlvi8e8pNCgnbaaad48cUX88b17Nkz+vTpEy1atIivv/463n777RgxYkR2BqmlEJ0UAHTYYYflxr711ltx/vnn553rlVdeGe3bt8/Ce9I5vvPOO3HrrbfG6NGj89YtHWyVOqSQoh133LHg3vbee+/Yb7/9cmE+HTp0iG233TbrW9FQoSFDhsRpp51WcP5013fbbbcsQOaVV17JQpUKtd69e2dBS0VNqNB/JcoLFXrvvfeiVatWeaR77rlnDBw4MAvm+eGHH7LfphR2lYKbSrfioULp/RVXXBF//OMfS3RLY/fdd9/YaqutsjCsFLL21FNPFQxNO+uss7JQoNQuuOCCSPe3dNt1112z8KB0p9P3KIVSjR8/vsTv4CWXXJLNv+KKK5b7vdSBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECS1JAqNCS1Lc2AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBATQgIFaoJRXPUC4GaDhVKIRtFQT5FG3zppZcihbRUp5UVKnTxxRdHCt2oSJs0aVK0adMmarOe8upY0qFCKbgkhaKk4JLqtOKhQmme6t6j7t27Z2FDqd14441ZiFR1WgqZSUE0xduXX34ZTZs2rdC0hx9+eNx5551Z34qGCqX5t95665g1a1aF1ijdKQUsvfnmm1nIVlETKvRfifJChRYuXJgFNlWnFQ8Vqu59TnXcfvvtcfTRR2clffPNN9keCoUZVaTmbbbZJp577rlYY401KtJdHwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECCwRAaFCS4TdogQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAjUoIFSoBjFNtWQFaiI8I+0gBdXcdNNN0aJFi7wNfffdd7HVVlvFjBkzqrzZskKF5s2bFxtvvHHMnz+/3LmLQoVqs57yiljSoUKpvo8++ij22GOPap1H6VChNG86oxQIVJU2bNiwOPnkk7Oh//nPfyKFqEydOrUqU8UBBxwQDz30UMGxV155ZVxwwQXlzluVUKE06auvvhrt27cvd/5CHR544IE48MADS7wSKvRfjvJChVKfbt26xZgxY6pknwYVDxVKn48//vgYPnx4leZLAVGfffZZNG7cODf+3nvvjUMPPbRK8x1yyCFx9913xworrFCl8QYRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgLgSECtWFsjUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRqU0CoUG3qmrtOBaobKpTCM4YMGRJHHXVUFP/PYaU38Y9//CN23nnnCu1twIAB0a9fvxJ9ywoVSp3KCl4pvVhRqFB6Xpv1LG6T9SFUKNU3Z86cOOKII+Lpp58us9wNNtgg0lmksy3dHnnkkdh///1LPP7222/jkksuiauvvrpC51zUKa3Rt2/fEmM+/PDD+O1vfxuTJ0+u1FwpGOa5556Lddddt+C4FCi15557xosvvrjYeasaKpQmfeaZZ+J3v/tdZlyRlr5DKbzmsMMOy+suVOi/JBUJFZo7d25sueWWFXK/6qqr8u5c6VChdFe6d+8eY8eOrcgxlujzwgsvRIcOHfLGjRw5MgvfqkgIWtHgdC9uv/32WGWVVSpdhwEECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoSwGhQnWpbS0CBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHaEBAqVBuq5lwiApUNFUpBGW3bto02bdrEFltsETvuuGOsvfbaFao9BbmcffbZMWHChIL927dvn4WrLFq0KNq1a1eiz+JChVLHd955J1JQyKOPPlpmqEjxUKE0pjbrKQukUKhQs2bNYvbs2SWGfPLJJ7H++uvnTTN+/PjYa6+9Ck5fKHjl4osvjosuuqjM83nppZfirrvuiilTpkQK8llrrbVi++23j1/+8pfRuXPnmDhxYuy22255499+++3YaqutCs772muvRc+ePeOVV15Z7L3o2rVr9O/fv8x5vv766/jTn/6UhRSVF9DTsmXL6N27d3Tr1i1WX331xa67cOHCuPnmm+POO+8s8y5WJFRocWfx+eefxzXXXBPDhg0rM0AmhQn9/ve/z8JtWrRoUbDmskKFkk0aX7rNnDkzNtpoo7znTz31VBamVNlWKCgsBe2MGDGislPl+tfm3U77T3cqhfAUaumeXHnllVnoU+m9lQ4VSuN/+umnLFTouuuuK/c+p/M49dRT4+STT46NN964TJ9PP/00evXqVW5YUceOHeOss86KLl26VNnaQAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNSlgFChutS2FgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQG0ICBWqDVVzLhMCKTBo8uTJ/5+du4Gyqjrvx/+UQhSUKFkBFEl+SBEJVlIhAktDfFmxFqnaqkFCoEqxtorQapWqtCA2QTFF22gSjBjfqyQao0YxJtZXTH0JFg1GQFCiEsG3yFs1KvzXuYX5z517hzn3zJ2Z+/I5a7GW3rvPPnt/9rPPHlizvvHyyy/n/nTq1CkOOuigXIhNt27dWm2Q9J+Edrz33nvx/vvv5/U3aNCg6Nq1a95nbT2eVk+ogzv4zne+kwtKaXpt3ry5xfVK2rz00kuxYsWKeOWVV6Jz586RBCj16dMnhg8fHrvttluq2X388ce5Wknq5je/+U1s2bIlVze9e/eOvffeO/cnWds//MM/TNVf40bJGJNAp02bNkXynB3XnnvuGfvuu2/J/TW94cMPP4wkZCkJu3n99ddzITXJeJPAqCS8qRw13+pB1mAHSZ0kdbd69epcqNOBBx4YQ4cOTR2AVowkCUNKajCp6R31kgSqJfW81157RRJKlLamk/6T2kjGt3Llylyfyf/37NkzV9fJOzHp00WAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFqEhAqVE2rZawECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLFBIQKqQsCBKpe4LHHHovp06fH9773vVzoStPrgw8+iAEDBsRrr72W91Xfvn1zITkuAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMAOAaFCaoEAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKDaBYQKVfsKGj+BOhbYtm1bzJs3L84777ycQvfu3eP73/9+jBgxIpLAoI8//jief/75OPPMM+O///u/C6TGjh0bCxcurGNBUydAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSaCggVUhMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLVLiBUqNpX0PgJ1KnApk2bYsKECXHXXXcVFUgChjZu3LhTnZUrV8aAAQPqVNC0CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWICQoXUBQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQLULCBWq9hU0fgJ1KvD222/H4MGDY/369ZkEZs+eHTNnzsx0r5sIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB2hUQKlS7a2tmBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIF6ERAqVC8rbZ4EalDgmWeeiYMPPrjkmY0fPz6uueaa6NatW8n3uoEAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCobQGhQrW9vmZHgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgHAaFC9bDK5kighgVeffXVmDJlStxzzz0tzrJv3765MKE/+7M/a7GtBgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEB9CggVqs91N2sCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQC0JCBWqpdU0FwJ1LPD666/H/fffH6tWrYq1a9fGpk2bYpdddomBAwfm/uy3335xwAEHRNeuXetYydQJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgSECrUk5HsCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFKFxAqVOkrZHwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECLSbgFChdqP2IAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgTYSECrURrC6JUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg+gSEClXfmhkxAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAvoBQIRVBgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQjQJChapx1YyZAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgsYBQIfVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQjQJChapx1YyZAAECBAgQIECAAAGeT9fWAAAgAElEQVQCBAgQIECAAAECBAgQIECAAAECBAgQIECgsYBQIfVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQjQJChapx1YyZAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgsYBQIfVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQjQJChapx1YyZAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgsYBQIfVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQjQJChapx1YyZAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgsYBQIfVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQjQJChapx1YyZAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgsYBQIfVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB7QJChZQCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAtQsIFar2FTR+AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTKJiBUqGyUOiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOggAaFCHQTvsQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIVJ6AUKHKWxMjIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKE1AqFBpXloTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDDAkKFanhxTY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUCcCQoXqZKFNkwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBlgWECrVspAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBlCwgVquz1MToCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBNpRQKhQO2J7FAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQJsICBVqE1adNhV45ZVX4oYbbiiAOfzww+Owww5rNdgjjzwSDz/8sP6bkeSz8xLjw6c1LyH1o37Uj/O3uRrwfvB+8H7wfvB+yLYLvD+9P7NVzv/dpX7Uj/px/jp/s+0C70/vz2yV4/xN42Z/2V9p6sT5lU3J/rK/slWO8yuNm/1lf6Wpk1o/vy666KKGKSb/7fdbvD/T7AvvT+/PNHVS6+/PpvPz/vT+TLMvvD+9P9PUifdnNiX7y/7KVjnOrzRu9pf9laZOnF/ZlOwv+ytb5Ti/0rjZX/ZXmjpxfmVTsr/sr2yV4/xK42Z/2V9p6sT5lU3J/sq2v0455ZTo169fNnR3EegAAaFCHYBej49MDpXkFwSaXskvXs2aNavVJLNnz47Gv9C1o0P9/58En52XGB8+rXkJqR/1o37+/1+odv7mV4P3g/eD94P3Q3M14P3g/eD94P3g/ZBtF3h/en9mqxz/PpbGzf6yv9LUifMrm5L9ZX9lqxznVxo3+8v+SlMnzq9sSvaX/ZWtcpxfadzsL/srTZ04v7Ip2V/2V7bKcX6lcbO/7K80deL8yqZkf9lf2SrH+ZXGzf6yv9LUifMrm5L9ZX9lqxznVxo3+8v+SlMnzq9sSvaX/ZWtcpxfadzsL/srTZ04v7Ip2V+Vub8efvjhOOyww7ItqrsIdICAUKEOQK/HRwoVqsxDS+iSv9SleR/5odP+TVMn/lKXTcn+sr+yVY7zK42b/WV/pakT51c2JfvL/spWOc6vNG72l/2Vpk6cX9mU7C/7K1vlOL/SuNlf9leaOnF+ZVOyv+yvbJXj/ErjZn/ZX2nqxPmVTcn+sr+yVY7zK42b/WV/pakT51c2JfvL/spWOc6vNG72l/2Vpk6cX9mU7C/7K1vlOL/SuNlf9leaOnF+ZVOyv+yvbJXj/ErjZn/ZX2nqxPmVTcn+sr+yVY7zK42b/WV/pamTSju/hAq1ZtXc2xECQoU6Qr0OnylUyKHemrL3Q6H6UT8XFRAIBfOX6jT7wvvT+zNNnVTaX6q937zf0tSt95v3W5o68X7LpmR/2V/ZKsf5lcbN/rK/0tSJ8yubkv1lf2WrHOdXGjf7y/5KUyfOr2xK9pf9la1ynF9p3Owv+ytNnTi/sinZX/ZXtspxfqVxs7/srzR14vzKpmR/2V/ZKsf5lcbN/rK/0tSJ8yubkv1lf2WrHOdXGjf7y/5KUyfOr2xK9pf9la1ynF9p3Owv+ytNnTi/sinZX/ZXtspxfqVxq9X9JVQozeprU0kCQoUqaTVqeCxChfxQ1ZryrtUfGoQm+KE5zb5Q/96faerEP/pkU7K/7K9sleP8SuNmf9lfaerE+ZVNyf6yv7JVjvMrjZv9ZX+lqRPnVzYl+8v+ylY5zq80bvaX/ZWmTpxf2ZTsL/srW+U4v9K42V/2V5o6cX5lU7K/7K9sleP8SuNmf9lfaerE+ZVNyf6yv7JVjvMrjZv9ZX+lqRPnVzYl+8v+ylY5zq80bvaX/ZWmTpxf2ZTsL/srW+U4v9K42V/2V5o6cX5lU7K/7K9sleP8SuNmf2XbX0KF0lSXNpUkIFSoklajhsciVCjboSJ0xg9taV4Lfmizv9LUiX90yKZkf9lf2SrH+ZXGzf6yv9LUSaWdX7NmzYrkZ/TWXs3Vv/53/v7kU9s+/v7r54c071Y/P/j5IU2dVNrPD95v3m9p6tb7zfstTZ14v2VTsr/sr2yV4/xK42Z/2V9p6sT5lU3J/rK/slWO8yuNm/1lf6WpE+dXNiX7y/7KVjnOrzRu9pf9laZOnF/ZlOwv+ytb5Ti/0rjZX/ZXmjpxfmVTsr/sr2yV4/xK42Z/2V9p6sT5lU3J/rK/slWO8yuNm/1lf6WpE+dXNqXm9pdQoWye7uo4AaFCHWdfV09+5ZVX4oYbbiiY8+GHHx6HHXZYqy2S0KLkBdz00v//iTTnk9gnRq299L9zQT58WrPH1I/6UT+F57vzy/meZl94f3p/pqmT5tqoH/Wjftr//PX3952f73z4pHkv+fexbOeX/WV/2V/+fd770/szzXug1L8/Ol+cL2nqyvvH+ydNnXj/ZFOyv+yvbJWTf341DphP/tv57nxPU1feP94/aerE+Z5Nyf6yv7JVjvMrjZv9ZX+lqRPnVzYl+8v+ylY5zq80bvaX/ZWmTpxf2ZTsL/srW+U4v9K42V/2V5o6cX5lU7K/7K9sleP8SuNmf9lfaeqk3s6vU045Jfr169caGvcSaFcBoULtyu1hBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhUssAf/MEfNAxv27ZtlTxUYyNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQVECokMIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECOkGbKcAACAASURBVBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL3WAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEKk9AqFDlrYkRESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlCYgVKg0L60JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhhAaFCNby4pkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqBMBoUJ1stCmSYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAywJChVo20oIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCyBYQKVfb6GB0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAu0oIFSoHbE9igABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoE0EhAq1CatOCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoRgGhQtW4asZMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWECokHogQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAdgGhQkqBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECg2gWEClX7Cho/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJlExAqVDZKHREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHSQgFChDoL32I4T+OCDD+Ltt9+Orl27Ro8ePTpuIJ7cbgLTpk2LN954I+95xxxzTJx66qntNgYPIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKpDQKhQdayTURIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQvIFRIddS8wAsvvBA33HBDPPTQQ7FmzZpYv3593pwHDhwYBxxwQEyYMCHGjBkTu+yyS82bVOoEv/vd78avfvWrFoeXrFHv3r1zf4YNGxYHHnjgTu/5oz/6o1i9enVem3POOSfmzZvX4rM0IECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOpLQKhQfa232RIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEalFAqFAtrqo55QSWLl0aU6ZMicWLF6cW6d69e8ycOTOSwJlOnTqlvk/D8gj8xV/8Rdx1110ld9a/f/8488wzY9q0adGlS5eC+4UKlUzqBgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgULcCQoXqdulNnAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQMwJChWpmKU2kscCtt94a48ePz4xy/PHHxw033BB77LFH5j7cWLpA1lChHU8aPHhw3HHHHTFo0KC8hwsVKn0t3EGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOpVQKhQva68eRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEakdAqFDtrKWZbBe4+uqr4+/+7u9a7TFkyJB48sknY9ddd211XzpIJ9DaUKHkKX379s2tW58+fRoeKlQonb9WBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQIRQIVVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQ7QJChap9BY0/T2D58uUxaNCgsqlMnz495s6dW7b+dLRzgXKECiVPGD16dNx3330NDxMqpPIIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBtAJChdJKaUeAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCpAkKFKnVljKtkgW3btsWIESPi6aefLnrvyJEjY+bMmXHAAQfEZz7zmdi0aVP8+te/jnvvvTcuvvjiZp/3i1/8IpJ7XW0v0Fyo0N13393w8K1bt8a6deti6dKl8Z3vfKfZQS1btiwGDx6c+16oUNuvnScQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFaERAqVCsraR4ECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgfoVECpUv2tfczNPwoSGDx9edF5JaNAFF1wQnTt3Lvp9cu+4ceNi9erVBd9PnDgxbrzxxg7zWrt2baxYsSKWL18eW7ZsiQEDBsSgQYNi3333bXY+aQf77rvvRtL/Rx99FMkvxA0ZMiTtrW3SrlioUPfu3WPDhg1Fn/f222/HkUceGc8991zB91//+tdjxowZuc93Fir08ccfx0svvZTr45VXXonevXvH5z73uZxx8uxSrldffTUXVJWYvvnmmznTpL8/+ZM/yfXZXP0Ve8YHH3yQW/ff/OY3uT8bN26MHj16RJ8+fXLzScZX6tWWtVTqWLQnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKVKiBUqFJXxrgIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTSCggVSiulXcUL/NM//VNcdtllBeM88cQT4/bbb29x/I888kgcfvjhRdtt3rw5unXr1vDd9OnT45vf/GZe2/79+8eqVauK3n/EEUfEww8/nPfd+PHj45ZbbinaPgn5+fd///dIwpCSMJnmrmnTpsWcOXNit912K9pk//33zwXT7LgGDx4cy5YtiwceeCDOO++8gjCebdu2xTHHHBOLFi0q6G/p0qXNhg7deeedccIJJxTck3gkLmmvUkOFkn6ff/75ouOaPHlyLFiwIPfo5kKFRo8eHV/72tdi/fr1RYc4e/bsOP/88+MTn/jETqeQeF5++eXx05/+dKftkjEldZOEAzV3JcFR1113XW7tmxtXcu/QoUNj6tSpccopp+TCi5q7ylVLaddQOwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUO0CQoWqfQWNnwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAQKiQGqgZgd69excNYXnxxRcjCddJcx133HFxzz33FDT98Y9/HMcff3zD5+eee27Mmzcvr125QoWee+65mDRpUixZsiTNkHOhPTfddFMccsghBe2bhul07949F240bNiwon0noUI333xzTJw4seD7JGBn5syZRe877bTT4tprr837rlevXvHb3/42OnXqlGoeSaMsoUIff/xxdO7cueAZRx11VC48KbmKhQqlHVQS3vPggw/GnnvuWXBL8uyLLroovv71r6ftLhKXu+66K0aOHFlwTxIiNGrUqLwgqJY6Hjt2bHz/+98vGixVzlpqaRy+J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECtSIgVKhWVtI8CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQL1KyBUqH7XvqZm/t577xUNfRk9enTcd999qed6//33R3JP02vu3Lkxffr0ho/bKlRo3bp1sd9++8XGjRtTj3lHw7Vr18bee++dd1+xMJ2+ffvGa6+9VrT/JFRo8+bNsfvuuxd8P3DgwFi+fHnB50mwTo8ePQrGfP7558cll1xS0jyyhAolD/jkJz9Z8PzDDz88HnroodzzWxMqlNx/3nnnxWWXXVYwlzlz5sSMGTNKmmPSOAmCeuGFF2KXXXbJu/eLX/xiLF68uOT+Jk+eHAsWLMi7r9y1VPKg3ECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKpUQKhQlS6cYRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQICBVSDDUhsHLlykhCb5peU6dOjW9961up55iE5gwaNKig/dlnnx2XX355w+dtFSo0adKkuP7661OPt3HDv/7rv45rr702795Sw3SSUKHkOvPMM+O73/1uwTief/75+OM//uO8z59++ukYPnx4QdslS5bEQQcdVNJcsoQKvf7665EEJTW9jj322Lj77rtzH5fqUGzQL774Yuy///4NX61atSoGDBhQ0vwaN77iiiviH/7hHxo+as4x7QOSMKJDDjmkoXm5ayntOLQjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLVLiBUqNpX0PgJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSECqmBmhB4/PHHY9SoUQVzaRrc0tJkt2zZErvttltBs7Fjx8bChQsbPm+LUKHm5pAE5lx55ZVxxBFHRLdu3SIJPjr//PPj3nvvLRjnM888E8OGDWv4PG2YThLItPvuu8cvf/nL3L1PPfVUjBgxoqD/f/3Xf41//ud/zvs8+WzmzJl5nyX9JeMs9So1VCgJQUrCc2644YaCR1100UUxa9as3Oc7cxg5cmRMmDAh+vfvH4lf07ns6Piqq66KKVOmNDxnw4YN8W//9m+RzL/xlTzz+OOPz4Uvbdy4MebPnx8zZswoGN+RRx4ZDz74YMPnSWjVP/7jPxa0u/TSS2PMmDG54KQXXnghHnvssdz677i6d++euy8JgurZs2fu47aopVLXUnsCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFCtAkKFqnXljJsAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCHgFAhtVATAvfcc08cd9xxBXO5/fbb48QTTyxpjp/85CdzYTCNr6YBMG0RKnTOOedEEoLU9EqCZD73uc/lffzBBx/E4MGDY/Xq1Xmff/Ob34xkbDuunYXpHHvssXHJJZfE/vvvH507dy547gEHHJALsWl8Jc9ctmxZ3mdJiNGSJUvyPisWPpRmEYqFCiX3vfXWWw23b926NdavX58bWxK2lITsFLuSYKSDDz4491VzDqNHj44f/ehHseuuuzZ0kYQ1/fmf/3lBl9OmTYv/+I//KPj8jTfeiMsuuyy3dkkg0ezZswvanHDCCXHnnXfmfd6rV69Yt25dw2fJvU0Dipq22dH4tttui2Stk5CjcePG5cKmGl9tUUtp1k8bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQCwJChWphFc2BAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFDfAkKF6nv9a2b2d999dxx//PEF87nrrruKhg3tbOK9e/fOhdY0vtojVOiYY46JRYsW5T331FNPjeuuu67ocGfNmhUXX3xx3nenn356XH311Q2fNRemc+aZZ+YCcoqFCe24+aqrroqpU6cWPLtxyNHatWtjn332KWjz4osv5sKKSr2aCxUqtZ++ffvGmjVrolOnTrlbm3N45513okePHgXdJ2NfsWJF3udHH3103H///c0O5e23345PfepT0fgXC3c0/va3vx1nnXVWwb2bN29uCARKApKS4KKmV1IDX/3qV2O//faLz3zmMztdsx33tkUtlboG2hMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWoVECpUrStn3AQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAjsEhAqphZoQ+PnPfx5HHXVUwVyuueaaOO2000qaY7FQmL/8y7+MH/3oRw39nHvuuTFv3ry8fvv37x+rVq0q+qwjjjgiHn744bzvxo8fH7fcckvDZ0lgzGuvvZbXplevXjF27NiifT777LOxePHivO9GjRoVjz76aMNnxcJ0unfvHm+88UZDmE1zOG+++WYkz296zZkzJy644ILcx9dff31MmjQpr8nQoUPjl7/8ZUnmOxqXK1RoyZIlcdBBB+3UYfDgwbFs2bKi4zzppJPijjvuyPtuyJAhsXTp0mbntWXLlkgCl1566aV4+eWXc3+SekjCiZqu645OknVIQqySq7kabvrApM6GDRuWq/cvf/nLse+++xaMqS1qKdOCuokAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFShgFChKlw0QyZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMgTECqkIGpC4LnnnovPf/7zBXO58MIL4xvf+Eazc0wCcp566qn4wQ9+EJ/4xCfivffeiz333LOg/fTp02Pu3LkNn5c7VCgJpNltt91avRZJCNC6desa+ikWKnT88cfHj3/841TPOvnkk3M2ja/GYTxJ4NEPf/jDvO8vv/zyOPvss1P137RROUKFbr/99jjxxBPzui7mMHny5FiwYEHRcZ5xxhkxf/78vO+aCxVKauaKK66I2bNnlzznxqFCSQ0ceOCBsXr16pL6mTVrVsyYMSO6dOmSu6+taqmkQWlMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSqWECoUBUvnqETIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjkBIQKKYSaEEiCdPbaa6+CuYwbNy5uvfXWgs+3bt0aSTBQEgaTXBMnTozrr78+li5dGkOHDi1of/XVV8fpp5/e8Hm5Q4Xeeuut6NmzZ6vXonv37rFhw4aGfoqF6Zx11llx5ZVXpnrWAw88EEcffXRB2xdffDH69esXu+66a8F3a9asic9+9rOp+m/aqDWhQsm8LrjggujTp0/Bs4s5nHPOOTFv3ryi40wbKnTbbbfl6mLjxo2Z5ts4VCjp4IknnohDDz205L6ScKeFCxfm7murWip5UG4gQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJVKiBUqEoXzrAJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQaBIQKKYaaEPjoo4+iS5cuBXPp1atXvPzyy9GtW7eG737/+9/H5MmT4+abb85rf/bZZ0fXrl1jzpw5Bf387Gc/iy9/+csNn5caKjRs2LBYsmRJXr/jx4+PW265JffZ5s2bY/fdd2/1WqQJFdpZmE7TASSu++yzT6xfvz7vq0svvTS+8IUv5JkkDUaNGhWPPvpo5nk0Fyo0cODAvD4TqwEDBkTyef/+/eNLX/pSJMFBzV1tESq0fPnyGDRoUOa5Jjc2DRVKPkvqderUqXHvvfeW1PdPfvKTGDNmTJvVUkmD0ZgAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSxgFChKl48QydAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEMgJCBVSCDUjcMIJJ8Sdd95ZMJ+5c+fG9OnTGz6/55574rjjjitp3i+99FJeaE2xUKGmgT47HvD+++/nwoqaXo1DhZLvevfuXRDec8EFF8TXvva11GPt3Llz7L///g3tSw3TKfagiy++OGbNmpX31ZAhQ+Koo46KefPm5X1+9dVXx+mnn556vE0bFgsVas61lIeU6nDGGWfE/PnzC+a8dOnShs/+6q/+Km666aaCYYwePTqOPfbY+PznPx/9+vWLvfbaKxcelbRvehULFdrR5q233soFND399NOxatWqSEKMnnvuuWanPXHixLjxxhtz37dFLZXirS0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKhmAaFC1bx6xk6AAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJAICBVSBzUj8MMf/jDGjh1bMJ8klCYJZmkctnPOOefEFVdckWruI0eOjCeeeCIa/8LYpZdeGkngT9PrzTffjE9/+tN5Hz/11FMxYsSIgrZNQ4X+9E//NH72s5/ltUsCepKgnqxXqWE6xZ6zevXqvEClnY1l/fr10bNnz6zDjWoKFUrqacWKFXlzHTduXNx6660F858xY0bMmTOn4PPmQoW2bNmSq7emYVRbt26Nxx57LBfc1PTZSdDTjtCjtqilzIvqRgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUGUCQoWqbMEMlwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoEBAqJCiqBmBTZs2RZ8+fWLjxo1F5zR//vxcGEvyi19JOMvEiRPjP//zP1uc/yOPPBJf+tKX8to1F2D0jW98Iy688MKGths2bIgjjjgilixZUvCcpqFC06ZNiyuvvLKg3UsvvVQ01GflypUxefLkSO476aSTis6jHKFCScfFQmqaPnD06NFx3333tei5swbVEir08ccfR+fOnQumMnv27Jg5c2be5++++278v//3/4rWZdNQoaSGkxCppJ9hw4bFvffeG926dSt4zvnnnx9z587N+7xXr16xbt263GdtUUutWlg3EyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBKhIQKlRFi2WoBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECRQWECimMmhK48cYb45RTTml2Tt27d49DDjkk9t1330iCYa655pqdzn/MmDHxk5/8pKDNM888EwcffHDRe88777xckNDLL78c1157bdFAoeTGpqFCDzzwQBx99NEFffbt2zeSQKQvfvGLsfvuu0cSMvT000/HmWee2RBU85WvfCWuuuqqSIJlGl/lChVauHBhjBs3bqdWN910U0yYMKFV9VQtoULJJHv37h3r16/Pm2/if+utt+ZqrEuXLvE///M/ccYZZ+TWq9i1I1Toww8/zK3frFmz8sKHjjzyyJg0aVIMGTIkV7OvvvpqLFu2LMaOHVvQ3eDBg3PfJVdb1FKrFtbNBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgigSEClXRYhkqAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAUQGhQgqj5gROOOGEuPPOO8syryQgpliYzv/+7//GwIED47XXXsv8nKahQklHrRl7Epj00EMPxbBhwxrGVK5QoS1btsRee+2VF3jTdOK/+93vYo899sjskdxYTaFCxxxzTCxatKhV890RKpT4JqFBTUOKSun81FNPjeuuu67hlnLXUilj0ZYAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECFSzgFChal49YydAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEEgEhAqpg5oTePfdd+OrX/1q/PSnP2313Hr16hW/+MUvon///gV93XbbbbnnZL2KhQqtWbMm+vXrl6nLZIxPPvlkfPrTn264v1yhQkmHf//3fx/f+ta3io5t7NixsXDhwkzjbnxTNYUKXXvttXHaaae1as47QoWSTm6++eaYOHFi5v6StR8+fHjD/eWupcwDcyMBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgyAaFCVbZghkuAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFAgIFRIUdSkwEcffRQzZ86MSy65pNXzS8J6Fi9eHHvttVdeX1u3bo2TTjop7rzzzhafMWvWrJg9e3Zeu2KhQkmDJ554IiZNmhQrVqxosd8dDQYPHhz33HNPQfhROUOFnn322Rg6dGjRMSUGSSBQa69qChXatm1bjBkzJhYtWtTitL/yla/Ehg0bCoKuGocKJZ3Mmzcvzj333Bb7a9rgqquuiilTphTcV85aKnlQbiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAlUqIFSoShfOsAkQIECApzOxyQAAIABJREFUAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBBoEhAophpoWWL58eVx//fXx7W9/OzZu3LjTuY4aNSoee+yxom2GDBkSjz76aOyxxx553yfBMtdcc0387d/+bdH7+vbtG/Pnz4/k/s9+9rN5bf7mb/4mvve97xW97/3334+5c+fGRRddtNMxDxw4MM4444xcoEyXLl0K2hYLFUrClpoGHKUtgv33379o2NHmzZujW7duabtptl2xUKFevXrFunXrWtV3qQ6JabJuja9DDz00Hn/88bzPknlfccUV8S//8i9Fx9e9e/eYOnVqXHzxxXHyySfHHXfckdeuaahQ8mUSBHT55ZcXtC32gAkTJsRZZ50VI0aMaNanXLXUqgVwMwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCIBoUJVtFiGSoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUFRAqJDCqAuB3//+97Fy5cp4/fXXY+3atbF+/fro2rVr9OzZM/fnoIMOik996lPx5JNPxsiRIwtMknCYZ599NpJwmmLXli1b4sUXX4xly5bl+t9vv/1i+PDhkYQKtebaunVrbswrVqzI/dmwYUP06NEjevfuHUnAz6BBg1rTfUn3JgE6e++9d0E40+TJk2PBggUl9VVrjd9555349a9/HatXr47f/va30b9///jCF74Q/fr1yzzV3/3ud7maSvp9991348MPP4ykDvv06ZNbh+QZSe2mvSqpltKOWTsCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINARAkKFOkLdMwkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBMopIFSonJr6qgmBBx54II4++uiGuSTBQD//+c9zIT71fF144YVxySWXFBA8/vjjceihh9YzjbkTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECNSQgVKiGFtNUCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJ1KiBUqE4X3rR3LrBw4cIYN25cDB48OJKQoX322afuyO69995YuXJlvPPOO/Ff//VfsXjx4gKDxOdXv/pVNP5lurqDMmECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgpgSECtXUcpoMAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAuBYQK1eWym3QagUWLFsXIkSOjR48eaZrXXJuTTz45fvCDH+x0XnfccUeccMIJNTd3EyJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqV0CoUP2uvZkTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGpFQKhQraykeRAos0BLoUKTJ0+OBQsWlPmpuiNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIdKyAUKGO9fd0AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB1gsIFWq9oR4I1KTAzkKFDj300HjwwQdjl112qcm5mxQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQvwJChep37c2cAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFArAkKFamUlzYNAmQWKhQoNHTo0pkyZEuPGjYtu3bqV+Ym6I0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0vIBQoY5fAyMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBonYBQodb5uZtAzQqsWbMm3nvvvdhll12iZ8+eseeee0anTp1qdr4mRoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBIBIQKqQMCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFqFxAqVO0raPwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECJRNQKhQ2Sh1RIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0EECQoU6CN5jCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoPAGhQpW3JkZEgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQmoBQodK8tCZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoIYFhArV8OKaGgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgTgSECtXJQpsmAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQItCwgVatlICwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgcoWECpU2etjdAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQItKOAUKF2xPYoAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBNhEQKtQmrDolQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAaBYQKVeOqGTMBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBjAaFC6oEAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLbBYQKKQUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFqFxAqVO0raPwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECJRNQKhQ2Sh1RIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0EECQoU6CN5jCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoPAGhQpW3JkZEgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQmoBQodK8tCZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoIYFhArV8OKaGgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgTgSECtXJQpsmAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQItCwgVatlICwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgcoWECpU2etjdAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQItKOAUKF2xPYoAgQIECBA4P9j5+5RKCnaMIB2NI4gghppZGRiaGTiBtzCRCauwAW4FFfiCkxN1WQEYRDFYXAiUTpo+bhf01LV9f6ciXuq3jpPIZex+yFAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYIqAUqEprBYlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCCjgFKhjKmZmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4CigVMh9IECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwC6gVMhVIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC6gVCh7guYnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCYgFKhYZQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWCSgVGgRvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEIgnoFQoXiYmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQuCagVOial6cJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgsoFSocLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoIqBUqEnQjkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwLmAUqFzI08QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjEFlAqFDsf0xEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgcKOAUqEbsW1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwRUCp0BRWixIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgkFFAqVDG1MxMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBwFFAq5D4QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgF1Aq5CoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkF1AqlD1B8xMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMExAqdAwSgsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsElAqtAjetgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIxBNQKhQvExMRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhcE1AqdM3L0wQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFBZQKlQ4XEcjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQRUCrUJGjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgXECp0LmRJwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGILKBWKnY/pCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBC4UUCp0I3YtiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEJgioFRoCqtFCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDIKKBUKGNqZiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEDgKKBVyHwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILALKBVyFQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLILKBXKnqD5CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYJqBUaBilhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBBYJKBVaBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTiCSgVipeJiQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBK4JKBW65uVpAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQKCygVKhyuoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEmggoFWoStGMSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHAuoFTo3MgTBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECsQWUCsXOx3QECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNwooFToRmxbESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQITBFQKjSF1aIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECGQUUCqUMTUzEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIHAWUCrkPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ2AWUCrkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QWUCmVP0PwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAwTUCo0jNJCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECiwSUCi2Cty0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAvEElArFy8REBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC1wSUCl3z8jQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUFlAoVDtfRCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJNBJQKNQnaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQOBdQKnRu5AkCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHYAkqFYudjOgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEbhRQKnQjtq0IECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSmCCgVmsJqUQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEMgooFcqYmpkJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSOAkqF3AcCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjsAkqFXAUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHsAkqFsidofgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgkoFRpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFFAkqFFsHblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBeAJKheJlYiICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFrAkqFrnl5mgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBwgJKhQqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSYCSoWaBO2YBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAicCygVOjfyBAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQGwBpUKx8zEdAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQI3CigVuhHbVgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAlMElApNYbUoAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIZBZQKZUzNzAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkcBpULuAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBHYBpUKuAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQHYBpULZEzQ/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLDBJQKDaO0EAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwCIBpUKL4G1LgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEA8AaVC8TIxEQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwDUBpULXvDxNgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAaVChcN1NAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAEwGlQk2CdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBM4FlAqdG3mCAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgtoBSodj5mI4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgRsFlArdiG0rAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBKQJKhaawWpQAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgYwCSoUypmZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBo4BSIfeBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECu4BSIVeBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgu4BSoewJmp8AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWECSoWGUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgkYBSoUXwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIJ6AUqF4mZiIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgmoBSoWteniZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoLCAUqHC4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCJgFKhJkE7JgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC5wJKhc6NPEGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBBbQKlQ7HxMR4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAjQJKhW7EthUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMAUAaVCU1gtSoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBARgGlQhlTMzMBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBRQKmQ+0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFdQKmQq0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJBdQKlQ9gTNT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAMAGlQsMoLUSAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBIQKnQInjbEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQT0CpULxMTESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHBNQKnQNS9PEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQWECpUOFwHY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0ERAqVCToB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFzAaVC50aeIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQiC2gVCh2PqYjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQOBGAaVCN2LbigABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYIqAUqEprBYlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCCjgFKhjKmZmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4CigVMh9IECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwC6gVMhVIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC6gVCh7guYnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCYgFKhYZQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWCSgVGgRvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEIgnoFQoXiYmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQuCagVOial6cJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgsoFSocLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoIqBUqEnQjkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwLmAUqFzI08QIEBwvsSwAAAgAElEQVSAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjEFlAqFDsf0xEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgcKOAUqEbsW1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwRUCp0BRWixIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgkFFAqVDG1MxMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBwFFAq5D4QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgF1Aq5CoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkF1AqlD1B8xMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMExAqdAwSgsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsElAqtAjetgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIxBNQKhQvExMRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhcE1AqdM3L0wQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFBZQKlQ4XEcjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQRUCrUJGjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgXECp0LmRJwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGILKBWKnY/pCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBC4UUCp0I3YtiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEJgioFRoCqtFCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDIKKBUKGNqZiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEDgKKBVyHwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILALKBVyFQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLILKBXKnqD5CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYJqBUaBilhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBBYJKBVaBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTiCSgVipeJiQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBK4JKBW65uVpAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQKCygVKhyuoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEmggoFWoStGMSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHAuoFTo3MgTBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECsQWUCsXOx3QECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNwooFToRmxbESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQITBFQKjSF1aIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECGQUUCqUMTUzEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIHAWUCrkPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ2AWUCrkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QWUCmVP0PwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAwTUCo0jNJCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECiwSUCi2Cty0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAvEElArFy8REBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC1wSUCl3z8jQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUFlAoVDtfRCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJNBJQKNQnaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQOBdQKnRu5AkCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHYAkqFYudjOgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEbhRQKnQjtq0IECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSmCCgVmsJqUQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEMgooFcqYmpkJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSOAkqF3AcCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjsAkqFXAUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHsAkqFsidofgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgkoFRpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFFAkqFFsHblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBeAJKheJlYiICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFrAkqFrnl5mgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBwgJKhQqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSYCSoWaBO2YBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAicCygVOjfyBAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQGwBpUKx8zEdAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQI3CigVuhHbVgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAlMElApNYbUoAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIZBZQKZUzNzAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkcBpULuAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBHYBpUKuAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQHYBpULZEzQ/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLDBJQKDaO0EAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwCIBpUKL4G1LgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEA8AaVC8TIxEQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwDUBpULXvDxNgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAaVChcN1NAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAEwGlQk2CdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBM4FlAqdG3mCAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgtoBSodj5mI4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgRsFlArdiG0rAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBKQJKhaawWpQAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgYwCSoUypmZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBo4BSIfeBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECu4BSIVeBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgu4BSoewJmp8AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWECSoWGUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgkYBSoUXwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIJ6AUqF4mZiIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgmoBSoWteniZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoLCAUqHC4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCJgFKhJkE7JgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC5wJKhc6NPEGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBBbQKlQ7HxMR4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAjQJKhW7EthUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMAUAaVCU1gtSoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBARgGlQhlTMzMBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBRQKmQ+0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFdQKmQq0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJBdQKlQ9gTNT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAMAGlQsMoLUSAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBIQKnQInjbEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQT0CpULxMTESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHBNQKnQNS9PEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQWECpUOFwHY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0ERAqVCToB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFzAaVC50aeIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQiC2gVCh2PqYjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQOBGAaVCN2LbigABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYIqAUqEprBYlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCCjgFKhjKmZmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4CigVMh9IECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwC6gVMhVIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC6gVCh7guYnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCYgFKhYZQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWCSgVGgRvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEIgnoFQoXiYmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQuCagVOial6cJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgsoFSocLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoIqBUqEnQjkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwLmAUqFzI08QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjEFlAqFDsf0xEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgcKOAUqEbsW1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwRUCp0BRWixIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgkFFAqVDG1MxMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBwFFAq5D4QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgF1Aq5CoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkF1AqlD1B8xMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMExAqdAwSgsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsElAqtAjetgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIxBNQKhQvExMRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhcE1AqdM3L0wQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFBZQKlQ4XEcjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQRUCrUJGjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgXECp0LmRJwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGILKBWKnY/pCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBC4UUCp0I3YtiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEJgioFRoCqtFCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDIKKBUKGNqZiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEDgKKBVyHwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILALKBVyFQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLILKBXKnqD5CRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYJqBUaBilhQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBBYJKBVaBG9bAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTiCSgVipeJiQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBK4JKBW65uVpAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQKCygVKhyuoxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEmggoFWoStGMSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHAuoFTo3MgTBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECsQWUCsXOx3QECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECNwooFToRmxbESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQITBFQKjSF1aIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECGQUUCqUMTUzEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIHAWUCrkPBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ2AWUCrkKBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC2QWUCmVP0PwECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAwTUCo0jNJCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECiwSUCi2Cty0BAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAvEElArFy8REBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC1wSUCl3z8jQBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoUFlAoVDtfRCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJNBJQKNQnaMQkQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQOBdQKnRu5AkCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHYAkqFYudjOgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEbhRQKnQjtq0IECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSmCCgVmsJqUQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEMgooFcqYmpkJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSOAkqF3AcCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjsAkqFXAUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIHsAkqFsidofgIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgkoFRpGaSECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFFAkqFFsHblgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBeAJKheJlYiICBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFrAkqFrnl5mgABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBwgJKhQqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgSYCSoWaBO2YBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAicCygVOjfyBAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQGwBpUKx8zEdAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQI3CigVuhHbVgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAlMElApNYbUoAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIZBZQKZUzNzAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkcBpULuAwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBHYBpUKuAgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQHYBpULZEzQ/AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQLDBJQKDaO0EAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwCIBpUKL4G1LgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEA8AaVC8TIxEQECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwDUBpULXvDxNgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBhAaVChcN1NAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAEwGlQk2CdkwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBM4FlAqdG3mCAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgtoBSodj5mI4AAQIECBAgQIAAAQIECO1MI48AACAASURBVBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgRsFlArdiG0rAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBKQJKhaawWpQAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgYwCSoUypmZmAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBo4BSIfeBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECu4BSIVeBAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgu4BSoewJmp8AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWECSoWGUVqIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgkYBSoUXwtiVAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAIJ6AUqF4mZiIAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgmoBSoWteniZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoLCAUqHC4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCJgFKhJkE7JgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAEC5wJKhc6NPEGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBBbQKlQ7HxMR4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAjQJKhW7EthUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMAUAaVCU1gtSoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBARgGlQhlTMzMBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBRQKmQ+0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFdQKmQq0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIJBdQKlQ9gTNT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAMAGlQsMoLUSAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILBIQKnQInjbEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQT0CpULxMTESAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHBNQKnQNS9PEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQWECpUOFwHY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0ERAqVCToB2TAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFzAaVC50aeIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQiC2gVCh2PqYjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQOBGAaVCN2LbigABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYIqAUqEprBYlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCCjgFKhjKmZmQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4CigVMh9IECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwC6gVMhVIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQyC6gVCh7guYnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCYgFKhYZQWIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWCSgVGgRvG0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEIgnoFQoXiYmIkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQuCagVOial6cJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgsoFSocLiORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBBoIqBUqEnQjkmAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwLmAUqFzI08QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjEFlAqFDsf0xEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgcKOAUqEbsW1FgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwRUCp0BRWixIgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgkFFAqVDG1MxMgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBwFFAq5D4QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEBgF1Aq5CoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhkF1AqlD1B8xMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgMExAqdAwSgsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgsElAqtAjetgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIxBNQKhQvExMRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAhcE1AqdM3L0wQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIFBZQKlQ4XEcjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQRUCrUJGjHJECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgXECp0LmRJwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBGILKBWKnY/pCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBC4UUCp0I3YtiJAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEJgioFRoCqtFCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDIKKBUKGNqZiZAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEDgKKBVyHwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILALKBVyFQgQIECAAAECBAgQIECAAAECBAisEXj9+vX25MmTNZvblQABAgQIECBAgAABAgQIFBNQKlQsUMchQIAAAQIECBAgQIAAAQIECBAgMFPgxx9/3F68eDFzC2sTIECAAAECBAgQIEDgH4FPPvmEBAECBJYIKBVawm5TAgQIEPgPAt99991/+Fv+CgECBAgQIECAAAECBOIKvP/++9sHH3wQd0CTESBAgAABAgQIECBAgACBRAJKhRKFZVQCBAgQIECAAAECBAgQIECAAAECqwWeP3++/fzzz6vHsD8BAgQIECBAgAABAg0ElAo1CNkRCQQVUCoUNBhjESBAgMD/CCgVcikIECBAgAABAgQIEKgmoFSoWqLOQ4AAAQIECBAgQIAAAQIrBZQKrdS3NwECBAgQIECAAAECBAgQIECAAIFkAkqFkgVmXAIECBAgQIAAAQKJBZQKJQ7P6ASSCygVSh6g8QkQINBIQKlQo7AdlQABAgQIECBAgEBhgSdPnmyvX7/+54RKhQoH7WgECBAgQIAAAQIECBAgcLuAUqHbyW1IgAABAgQIECBAgAABAgQIECBAIK/AsVToww8/3N577728hzE5AQIECBAgQIAAAQLhBI4fRSsVChePgQi0EVAq1CZqByVAgEB6Ab+f00foAAQIECBAgAABAgQIbNt2fB9JqZArQYAAAQIECBAgQIAAAQIExgkoFRpnaSUCBAgQIECAAAECBAgQIECAAAEC5QW8xFM+YgckQIAAAQIECBAgsFTAR9FL+W1OgMAuoFTIVSBAgACBLAJ+P2dJypwECBAgQIAAAQIECPw/Ae8juR8ECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSwEs8JWN1KAIECBAgQIAAAQJhBHwUHSYKgxBoLaBUqHX8Dk+AAIFUAn4/p4rLsAQIECBAgAABAgQIPBDwPpKrQYAAAQIECBAgQIAAAQIE5ggoFZrjalUCBAgQIECAAAECBAgQIECAAAECJQW8xFMyVociQIAAAQIECBAgEEbAR9FhojAIgdYCSoVax+/wBAgQSCXg93OquAxLgAABAgQIECBAgMADAe8juRoECBAgQIAAAQIECBAgQGCOgFKhOa5WJUCAAAECBAgQIECAAAECBAgQIFBSIOpLPH/++ef24sWL7c0339zeeeedkvYRD/X1119vP/zww79G+/TTT7cvv/wy4ri3z/T7779vf/zxx/buu+9uT58+vX1/G64T+Dv7r776avv7v03HP1988cX22WefrRvMzgQIECBAIIGAj6IThGREAg0ElAo1CNkRCRAgUEQgwu/nly9fbr/99ts//zb/97/R+0NglMCrV6+2X3/9dXvrrbe2t99+e9Sy1kki4P9BJQnKmAQIECBAYJBA1PeRBh3PMgQIECBAgAABAgQIECBAYJmAUqFl9DYmQIAAAQIECBAgQIAAAQIECBAgkE8gyks833///fbNN99s33777fbTTz9tv/zyy78wP/roo+3jjz/enj17tn3++efbG2+8kQ87wcR/sXcf0JJVZaKA95IgNCqCEiQpvCZHia0EuxkccpQsKCAiIiAZhZGmmREBBRxbUARJKmkEAcmINEHyIj1BgqAILIVRclAQfeuvebenbtWpe+vWrVN1zqlvr8Ua+95z9vn395+qW7Nr7//EIv5XX311WKSf/exn09lnn12C6Lsb4jvvvJNuuOGG2n15//33p7hH69v888+fllhiiTRlypT0+c9/Pi2++OLdDUBvhRJ46KGH0gorrNAU01lnnZV22223QsXay2DOPPPMVL/RLa69yiqr1F4TGgECBAgQGBIowqZo2SBAgICiQu4BAgQIECiLQK8/P//zn/9Mt99+e4p5nrvvvrtWdL5+jnhoHnT11VdPe++9d22eXiPQrsCDDz5Y+37hpptuSo8//viwe+u9731vbV59jTXWSHvuuWeaNGlSu906rqQCvoNqTpw59pLezMImQIAAgbYEirIeqa1gHUSAAAECBAgQIECAAAECBEokoKhQiZIlVAIECBAgQIAAAQIECBAgQIAAAQL9Fuj3Ip4HHnggfelLX0q/+tWv2qaIheZHHXVUOuigg9K73vWuts8bpAOjOFNsBqlva621VpprrrlGZLCg+394fvzjH6evfvWr6Zlnnmn7ttlyyy3TqaeemhZaaKG2z3Fg7wVeeumldO+99w678Oyzz57WWWedEYNRVKiZ54033kgLLrhgUyGyOPK1114b9f2m99kv9hXvu+++2lPa69vSSy+dFl544WIHLjoCBAi0IdDrTdFthOQQAgQGUEBRoQFMuiETIECgpAK9/Px83XXXpf322y899thjbWttuOGG6YQTTkgrrbRS2+cU+cBO5wuLPKas2Ho9zihQFd/9xP9tt6266qpp+vTp6eMf/3i7pziuDwLjuZd8BzU8YebYu3sD//73v09PPvnksE7nm2++tOKKK3b3QnojQIAAgbYF+r0eqe1AHUiAAAECBAgQIECAAAECBEomoKhQyRImXAIECBAgQIAAAQIECBAgQIAAAQL9FOjnIp7zzz8/7bzzzh0PP4q4nHPOOWnuuefuuI+qnli/WXJojKecckraZ599RhzyoC/ofuutt9LBBx+cvvvd73Z0ayyyyCLp2muvTcstt1xH5zspf4E77rgjfexjH2u6UBQ4G2kjlKJCzbm54IIL0k477ZSZtHPPPTftuuuu+Se0QlfYaKONau8f9W277bZLF110UYVGaSgECAyqQC83RQ+qsXETIDC6gKJCoxs5ggABAgSKIdCLz89RkP6kk05KhxxySEeDjsL/V1111aiFujvqvMcndTpf2OMwx325Xo7zrLPOSnvssUfHMV988cVpm2226fh8J+YrMJ57adC/g2rMjDn27t6rUfDu8MMPH9Zp/L165ZVXunshvREgQIBA2wL9XI/UdpAOJECAAAECBAgQIECAAAECJRRQVKiESRMyAQIECBAgQIAAAQIECBAgQIAAgX4J9GsRz2mnnZb23nvvcQ87ioDceeedaY455hh3X1XqIKuoUBTKiScDj9QGfUF3bFT42c9+Nq5bIRYoR4GaxRdffFz9ODkfgVYbHu6///608sort7yookLNNP/yL/+SfvnLX2aarb322unWW2/NJ4kV7TWrqNDWW2+dLrnkkoqO2LAIEBgkgV5sih4kT2MlQKAzAUWFOnNzFgECBAj0XqAXn5+PPvroNG3atHEP7qabbkrrrbfeuPvpZwedzhf2M+ZOrt2rcU6fPj3tv//+nYQ47JyYp99qq63G3Y8Oui8wnntp0L+DasyGOfbu3p9ZRYXiClFITyNAgACB/gj0az1Sf0brqgQIECBAgAABAgQIECBAoHcCigr1ztqVCBAgQIAAAQIECBAgQIAAAQIECJReoB+LeB599NG0zDLLdM3usMMOS8cff3zX+qtCR50WFYqiFq+99towgii0c9BBB1WBZcQxnH322Wn33Xfvyji33377dOGFF3alL510V6DTDQ9PPvlk+sxnPtMUzFe/+tW06aabdjfIEvT2xBNPpIkTJ44Y6SOPPJKWXnrpEoymGCEqKlSMPIiCJ/wK9QAAIABJREFUAIF8BHqxKTqfyPVKgECVBBQVqlI2jYUAAQLVFsj78/Pdd9+d1lxzza4gLrfccunBBx9Ms8wyS1f660cnnc4X9iPW8VyzF+N8+OGH0/LLLz+eMGeeu8gii6T4LmnChAld6U8n3RMYz700yN9BNWbAHHv37smhnhQV6r6pHgkQIDBegX6sRxpvzM4nQIAAAQIECBAgQIAAAQJlEFBUqAxZEiMBAgQIECBAgAABAgQIECBAgACBggj0ehFPPA1yrbXWSrFxIatNmjQpHXXUUbWF54suumitwM1vfvObdOWVV6Zjjjmmpdrtt9+e4lztfwQ6LSo0qH7xOlh44YVbDv/AAw9MUVwp7st4km5sjrjtttvSBRdckGbMmJF53q233prWXnvtQSUt7LjHs+GhsIPqQ2Dxfjx16tQRrxwFl4499tg+RFfOSyoqVM68iZoAgfYE8t4U3V4UjiJAYNAFFBUa9DvA+AkQIFAegTw/P//973+vzXE+9thjmSBbbrll2n///WvHLLDAAunNN99M99xzT/rmN7+Zfv7zn2eec/7556cdd9yxPMANkQ7KfGHe44zvflZfffV07733Zt4LG264Ye3hBVGIKgoGPfXUUym+17n22mtTFPzPajG3GHOMWrEE8r6XijXa/KIxx959W0WFum+qRwIECIxXoNfrkcYbr/MJECBAgAABAgQIECBAgEBZBBQVKkumxEmAAAECBAgQIECAAAECBAgQIECgAAK9XsQz0lOQYwFtLBCfddZZM2Xi3Nic8OSTTzb9ftddd03nnntu30TDMTZixJNz33jjjTRx4sS0zDLLpMUXX7zleLKC/dvf/lbr5w9/+EPtv1dffTXNM888aaGFFkr/5//8n1qf7bR+FBV66KGHarl59tlna8Wg5p9//lrcK6+8cppvvvnaCXvEY8L4rrvuSo8//nhtQ8uyyy5b83jve9877r5PPPHEdMghhzT1E33HpphNN9008xqR64997GO1p3HXt+222652L3/0ox8dNbZu3TtZF+qmWZ5xvvjiiyn6j01Nce+utNJKmW4vvfRSeuCBB2rH/vGPf0zvvPNOrchT3GMrrrhimmuuuUb17seGhxhXbL565plnanHHvz/0oQ/VNs+sttpqac455xw17pEO+Mc//lF7XcTr47nnnksf+chHaq+PJZdcMs0+++zj6jvr5Ig/inA9//zzI/Yd7wEx5tlmm21MMURew+t3v/td7f1k3nnnTausskptM9t4xxOxx4aleJ/97W9/m971rnelpZdeuuYV71dZ753tBv/WW2/V7s+IPf73UkstVXuP+vCHP1y7zmhNUaHRhPyeAIEyC+S5KbrMLmInQKC3AooK9dbb1QgQIECgc4E8Pz/fdNNNafLkyZnBnXrqqWnvvffOnB+JgjEHH3xwOvnkk5vOjUJEl1566YgDLvLccbfnC/OcRx3PfG+3x9mY8JibjAdKZLUoDnTYYYelWWaZJfP3X/ziF9P3v//9Yb9bd91105e//OX0qU99atQXU8wbD30/86c//an2wIqh+dEJEyaMev5IB7z88sspXpMx7xfzuNFv/Bdzn2NtecZZ9Tn2sM7zfcQce/t3c55z7OPNg6JC7efRkQQIEOiVQK/XI/VqXK5DgAABAgQIECBAgAABAgT6LaCoUL8z4PoECBAgQIAAAQIECBAgQIAAAQIESiTQ60U8hx9+eIpFnY0tFob/9Kc/HVVupE0Pr7/+eqpfIB6L1OMJyvVtiSWWSE888UTmdaZMmZJmzJgx7Hc777xz+slPfpJ5fCyc/fa3v52iGFIU/2nV4snOsWh+pIInUZzmrLPOqvU1UqGOVVddNe23337ps5/97LDNHVFwKKvY0qigKdWKkAwtgI/iGo1PqY7NIt/61rdaGpx22mkpNpw8/PDDLS+39dZb1zadrL322i2Pabx2PLE4Fon/+Mc/rhXoieIkWW3atGnpK1/5yriKjURhl6wnKJ9xxhnpc5/73IiMUUgqCofEk5Z32WWXtNlmm6X3v//9I57TrXsnb7O847zuuuvSoYce2lSUKTYp1bdHHnmkdg/+8Ic/HNE1NkTFvRibOoZaFOeKoi6dtHi9DW3iivfKKKTT2C677LK0xRZbZHb/l7/8pfYeFK/tVq/rKFwVRdHi/apVnFnXPuCAA2p9H3HEEbUNN1nvQdH3mWeembbddttOht/ynMhb3O/ttMsvvzxtvvnm7RxaOyaKw8VrutX7WRT4Ouecc9IFF1yQ9t1332H9XnXVVWnjjTfOvNYLL7xQMx7pHgqvuM8+//nPZ26e+6//+q+0/fbbD+v/kksuSbHBaY899kg///nPM68dRbJiXFH8qr5lbZZqF+qKK65oWeys3T4cR4AAgV4K5LkpupfjcC0CBMotoKhQufMnegIECAySQJ6fn2Ouevr06U2ce+21V4p53pHa22+/XSuSHfNcMY+y55571uZKopBMVqHmmFss4txxt+YL663ynkftZI48j3GOdH+0+u4n5sx/9KMfjXhvxfcja6yxRu0BDZ/5zGdq85ntzOleeeWVKe7pkb4biXnMuA9b9Rfft3z3u98dFt/TTz9du89jnjDre4M4OB4scMopp7T1QIVuxNnqu4AyzbGHW7++gzLH/r+3eD/n2Ludh/ieYKedduroI0K8Zx133HEdneskAgQIEGhfoNfrkdqPzJEECBAgQIAAAQIECBAgQKDcAooKlTt/oidAgAABAgQIECBAgAABAgQIECDQU4FeL+JZYIEFMotrRNGQWEzcTosCHlnFG+JpyPFU5KF2yCGHpBNPPHFYl90qKvTggw+m3XffveWC8sZxxHVj4fzHP/7xpiHG4vQoStFYzGcki9isEcVChgoVxZN3WxXdGc30r3/9a3r3u99dOyyrONFBBx3U5BjH/v73v68V0fnVr3412iVm/v5rX/taOuqoo2qbAxpb47VjY0rkcOrUqaP2H8VfbrjhhlGL+WR1FEWmJk6c2PSr2CATv5t99tlHvX5sGskaU9aJ3bx38jTLO84o4BXFnLJafVGhiy++eMxFcWKTSGyEijaezTPxurz55ptr/Yy1qFAUQIvX6UhFwurHHvd7FLyJzSiNLevasRkm7rnYkDJai8JYUSCrW22HHXZIF1100bDuJk2aVCsC1ljcqJ0n1UdH8RqKJ49HUajR2lJLLZXWX3/9pqeXx9+FKOrV2H72s5+lvffeu+1chG14xXtAfcsqKhSbjiIH7RR1i/fs+Lsx1L7whS+kH/zgB6MNN/P3N954Y4oiWhoBAgTKIpDnpuiyGIiTAIH+Cygq1P8ciIAAAQIE2hPI6/NzzLktuOCCmXMkTz31VFpsscVGDTAKmESLuZmR5kOLPHfcrfnCIay851E7nSPv9jhHuzlaffcTDyOoLwLfqp+xzLH/93//d4qi6+edd95oYc38fcy9RmHwxvalL32paU7yP/7jP9K//du/jdp3zOnGPHd8P5HVuhln1ncBZZtjD6N+fQdljn34HdqvOfZu5+H8889P8XCYTlo83CC+r9QIECBAIF+BXq9Hync0eidAgAABAgQIECBAgAABAsURUFSoOLkQCQECBAgQIECAAAECBAgQIECAAIHCC/RyEc/LL7+cWfRl4403TldddVXbVtdcc02Kcxrb8ccfnw477LCZP86rqNBzzz2XllxyyabiGe0MILw/9KEPDTt0nXXWGVNhnqGT6wuFdFpUKIpmxFN3h1q7C7pffPHFtPrqq7dVSKPR5cADD0wnnXRSE1fWtdsxHTrm0EMPTSeccMJYTqkde/XVV6dNNtmk6bx4Qmk8qbSbrdv3Tl5mvYgz7r1WhbCGigrdcsstab311usoBVGkK16n49k8U/+E9rEUFbr77rvTmmuu2VHcjcXRopNW1x7LBVoV3BlLH3FsbISZf/75m04799xzU+Tr9NNPb/rds88+mxZaaKERL3XMMce0VUBspE6yxviLX/wiffKTnxzrMGtPRr/jjjvSu971rpnnZhUVGmvH9RbjKSrU7ka/scbneAIECOQlkNem6Lzi1S8BAtUUUFSomnk1KgIECFRRIK/PzzGnO++88zaRbb755unyyy/vGmXR5467NV8YYL2YRx1LYurnyLs5ztFieOWVV9Lcc8/ddFgU747vc7rZ/vGPf9TmjMfysIOh68f3UI3fLWUVFRpLvFFQ6K677kqzzDLLsNO6HWfWdwFlm2MPoH59B2WOvb27Ou859m7nYTxFhaIo2U477dQejKMIECBAoGOBXq5H6jhIJxIgQIAAAQIECBAgQIAAgRIKKCpUwqQJmQABAgQIECBAgAABAgQIECBAgEC/BHq5iOfxxx9P8fTLxrbffvul73znO20TPProo2mZZZZpOr6xWE1eRYV23333dPbZZ7cdb/2B8STceCLuUBtP8ZHoIxbOf/zjH0+dFhXadNNN0xVXXDEznnYXdG+11Vbpsssu68ggTrr44ovTNttsM+z88RbIic4eeeSRtPTSS48prshl5LSx/fSnP02f+tSnxtTXaAd3896Ja+Vl1u84o6hQPJk6cvnkk0+Oxpr5+6HNUOPZPPOtb30rHXzwwbX+2y0qFJumVlpppZYFk9oZzBNPPJGWWGKJmYd2Y6F99Peb3/wmzT777O2E0PKYU045Je27775Nv3/ppZdSbHj7l3/5l6bfRbGv2NDUqsXTypdffvlxxRUnN254+Otf/1rrt9N7KAol7brrrjPj6kZRod122y2dddZZtT7HU1QoXh+NG5XGDagDAgQI5CiQ16boHEPWNQECFRRQVKiCSTUkAgQIVFQgr8/P7c6rj5e16HPH3ZovDKd+z6Nm5Wpojryb4xztnvjtb39bK/De2Mb63c9o14nft5rPb+fcmCONuch3v/vdMw8fb1Gh6Cjm+2Ler751O86xfhdQxDn28OnXd1Dm2Nt5heQ/x97tPIynqNCdd97Z8cMh2tN0FAECBAiEQC/XIxEnQIAAAQIECBAgQIAAAQKDJKCo0CBl21gJECBAgAABAgQIECBAgAABAgQIjFOgl4t4br311rTuuus2RXzyySenAw44oO2RvPHGG2muueZqOn777bdPF1544cyf51FUqNUY4omw06dPT1OmTEkTJkxIsUHjK1/5Srryyiub4rznnnvSaqutVvv5SSedNLNoSf2Bxx13XIqCP9FvLHK/5ZZbav0Ntfe+97218/bZZ58033zzpa9+9avphRdemPn7H/zgB03XnTRpUq3YSX2LfOyyyy4zf9TOgu4HHnggrbLKKpn5iph32GGHtMACC9Ti/sY3vpGef/75pmMjjuinvo20KD5ijzhj0X/4HXXUUZnX/+53v5tiE8BYWliHX2NrtaA4NkjcfPPNo14i7oMdd9xx5nHdvnei4zzMeh1nPWQUHXvPe95TK04Tmx5iM0bkpv4e2m677WpFbT760Y/WiqpcffXVtc07r776alNO3nrrrRRPyT7iiCNm/u6Pf/xjrfhMY9t6661rr6X69rnPfW7movJ2iwq1KroT/cYmmk984hO1wj7x9Or/+I//yLyPGgukjbbQPt77tthii9r7YhQJqy9cVn+B+++/P6288sqj3rsjHRBFeuK1Xd923nnn9JOf/KRWCGrhhRdues3H6zZeN/WbuOvPj/F++9vfbmmxzjrr1HJ90003pfh70ao1FhWK95/63A+dF+97UTAq3ofiieF33HFH+uIXv5gee+yxYV3PP//8tYJEQ39vRisqdNBBB6XJkyfX7rnTTjut9r6d1eLejhZFi+qfqH7ppZc22cXfgE022aQprn//938fVx6dTIAAgV4L5LUputfjcD0CBMotoKhQufMnegIECAySQF6fn2OuYr311muijHmZL3/5y10hLsPc8V/+8peuzBf2eh51rHPk3RpnOzfGbbfdltZee+2mQ+uLttf/8vXXXx/2Xc5I19h2223T+973vtohUdD9wx/+cOZccHzXstNOO6WY04v51Piu4Pjjjx/1fh+pqFDMzUVh8NVXXz099dRTte8lsr7viLnlSy65ZOa18oiz3aJCRZ5jD6B+fQdljr0Yc+zdzkPM7Q8V8Y/7K74/vPfee5te93vttVfTz+K7wXnmmaedtzjHECBAgMA4BHq5HmkcYTqVAAECBAgQIECAAAECBAiUTkBRodKlTMAECBAgQIAAAQIECBAgQIAAAQIE+ifQy0U8UfAhCl80tp/+9KfpU5/61JgQYhF5YxGR9ddfP91www0z+8mjqFAUjcgqahFFNpZddtlhY/jb3/6WlltuuVpRivr2zW9+M0Vs0WIRemNxiFj0/txzzzV5XHDBBSnOjUXuUawmita0alnFO9opuNPOgu5WBUCOPfbYpuI8L7/8cvrkJz+Z7r777qZQo6jKGmusMfPnrRbFb7zxxrUF+XPMMcfMY6NY02abbdbU5/7775/+8z//c0z30mGHHVZzbWzPPvtsWmihhZp+HptswmC01pjHbt87cf08zHoZZ4xh8803rxWfWnrppdOss87axPrmm2+mM844Ix155JG1++Wqq64a9iTpOCHu7SjY09gef/zxNHHixGE/jkXmH/vYx5qOHa3gTrtFhbKK7sTFohBVY1G1Vk+Hj6Jh8R4w55xz1uIcaaH9tGnTmopsRQGyrA0zF198cdpmm21Gu3Vb/j5ex2uuuWbT76OQURQUi3b44YenE044oemYrPHHQe+8807tdZa1GWfGjBm1Ikz1Ld7jN9hgg8wYG4sKZeUiNtXcd999Te+f8QT3xvfwuEjcL2uttVbteiMVFbr++uuHxfX222/XNunF+Y3tT3/6U63wWmPbaKON0rXXXjvsx40bkjpOnhMJECDQZ4G8NkX3eVguT4BAyQQUFSpZwoRLgACBARbI6/NzN+fnW6WnjHPHnc4X9nIetRtz5J2Os52XYswPxjxvY7voootSFIlvbHGPR6GedtoTTzxRe9hAtMsuuyxttdVWTadFUZHddtut6efxs3POOWfYz8My5piHWquiQlFQKAqCL7bYYjOPjYL1Wd8ZxJxjzPUOtTziHKmoUFnm2MOnX99BmWP/35dBP+fY885DfDcR31E0tqFC/+285ziGAAECBLor0Mv1SN2NXG8ECBAgQIAAAQIECBAgQKDYAooKFTs/oiNAgAABAgQIECBAgAABAgQIECBQKIFeLuK5/PLL05Zbbtk0/lhgnVVsaCSoKMjQWISiF0WFNtlkk3T11VcPCy0Wptc/CbP+l1OnTk3HHHPMsOPjiZinnXZa7WfTp09PUQinsUWf8VTdJZdcMi266KKZxVZG8smzqFCrQh0PPfRQZpx33nlniqcoN7Z4cnB9cZ5Wi+JfeOGFzKeFRhGaxx57bFi3G264YbrmmmvG9Bo7+OCDU8TS2P785z+nD3zgA00/j+I1UcRmtNZYVKjb905cPw+zXsa5zz771IpAZRUTavR94403UtzXQ4V26n/f6gnojYVe4pxON8+0U1Qo3pOyisV88YtfTKeeemrmLRNP6z700EObfhcFfIY21rS69qqrrprqN5kNddLq+Cg0FEW0Om1Z934UQIrXyuyzz17rNp4CvNpqq2W+p2W9T/7ud7+buSmo/qS99947fe9738sMNe6brN/VFxX6+9//nmabbbam81ttMIoD11lnndpGofp23nnn1d6Lo7UqKhSmWUWcWh1/++23Z74nKirU6Z3pPAIEyiCQ16boMoxdjAQIFEdAUaHi5EIkBAgQIDCyQF6fn1vNz1966aWZ8/ad5KmMc8edzhf2ch61G3PknY6znftgrN/9jFS8u/F69UWF4uEAjfObMQ8fRbyzvhP5xS9+UXvoQX2LYkFPP/30zB+1KirUWMB86IRWx0eR8aF57jzibPVdQJnm2MOwnaJCebyPmGMf/srq1xx73nlQVKidd2zHECBAoLcCvVyP1NuRuRoBAgQIECBAgAABAgQIEOivgKJC/fV3dQIECBAgQIAAAQIECBAgQIAAAQKlEujlIp6sBdyBdfrpp6c999xzTG5ZC8S33nrrdMkll8zs55BDDkknnnjisH7jibaxCD2rTZkyJc2YMWPYr3beeef0k5/8ZObPosDPM888M+yYWLS+/fbbZ/Z53333NRWpWHfdddPNN99cO76VSWNnEXcU6ogF8BtssEFafPHFR/TKs6hQVt/x5M/jjjuuZUzve9/70quvvjrs9/Ek5/r8ZC0mX2655VIUK8pq2267bbr44ouH/WqllVZKUWBmLO3oo49O06ZNazrl8ccfTxMnTmz6eVbhj6zrNRYV6va9E9fMw6xXcUYxmtjsMWHChLbSFUViIifxxOff//736cknn6z9Fz9rLC411GHcH9tss82w/jvdPNNOUaEHH3wwrbzyyk3jiSd1b7rpppnjjPt7hRVWaPpdfbG1Vtc+4IAD0sknn5zZb9brNIoXxaL6Ttrrr7+ePvShDzW9jqPQ0He+851hXWYV/IoDXnzxxfT+979/2LGtio5F8bZ4rWW1W2+9NcX7aGOr3+jTqlhRvIdGfFktNtA1vr/He8NRRx1VO7zVZqf4uxN/fxpbq/uh1YYkRYU6uTOdQ4BAWQTy2hRdlvGLkwCBYggoKlSMPIiCAAECBEYXyOvzc8x9xxx4Y/vhD3+Y9thjj9EDa+OIMs4ddzpf2Kt51G7NkXc6zjbSnm644Yba9xaNrVWB7yjQ/ZWvfKWdrmvf58T3I9Hie6S4Xxvbvvvum9nXc889V5vTa2xvvvlmmmOOOWo/blUkKM6NOf7Gdsopp6Ss69UXfsojzqzvAso2xx6W7RQVyuN9xBz78Du5X3PseedBUaG23lYdRIAAgZ4K9HI9Uk8H5mIECBAgQIAAAQIECBAgQKDPAooK9TkBLk+AAAECBAgQIECAAAECBAgQIECgTAK9XMTTqsDCEUcckb7+9a+3ZDv22GPTXXfdlS666KI0++yzp5dffrmpMEWcHE+ojcXoQ63bRYXeeOONNNdcc407vfXFZqLPFVdcsVYcZSxt6tSp6cgjj0yzzTZb5ml5FRWKwkBRIKixff/7309f+MIXWg5hzTXXTHffffew30chpgsvvHDmz7IWk3/uc59LZ5xxRma/X/ziF1Nct751UlTo3HPPTZ/97GebrhGbbD7xiU80/Txrs0hWgI157va9E9fstlke93irOLfccssURVxGa1FM6LzzzktREOf5558f7fBhv+91UaFrrrkmbbzxxk0x/vrXv07xdOWs1uo19b3vfS/tvffetVNaLbT/0Y9+lHbZZZfMfrPujfEUFYrialnXuv3229OkSZOGxRDv2fH+1NiyCshdeeWVabPNNms69pFHHmlZ/KeVR32xnnYLto12Q8V7w9lnn107rFVRoShg9JGPfKSpq3ji+WKLLdb0c0WFRlP3ewIEqiiQ16boKloZEwEC+QkoKpSfrZ4JECBAoLsCeX1+fuqppzLnMKLoesw3j7eVde64k2I7vZxH7dYceSfjbPeeiMI/WQX6jznmmPS1r32tqZtWRXeyrldfVGidddZpeohDuzHWH1f/QIGsokKLLLJIirm9rHbBBReknXbaqelX9UWF8ogza763bHPsgTZaUaG83kfMsQ+/Zfs1x553HhQV6uQd0TkECBDIV6CX65HyHYneCRAgQIAAAQIECBAgQIBAsQQUFSpWPkRDgAABAgQIECBAgAABAgQIECBAoNACvVzEE092XXDBBZs8dtxxx3T++ec3/fwf//hHisJAJ598cu13u+66a624wwMPPJBWXXXVpuNPO+20tNdee838ebeLCv35z39O880337jzGU+PfeWVV2b2c9ttt6W11157zP02FuWp7yCvokKtDKLg03bbbddyDFE0JIqH1LfNN988XX755TN/NNpi8sbOu1VU6JZbbknrrbdeU+ytCrZEIaQodFPf4mdRKKS+1RcVyuve6bZZL+OMpzlPnz59xPv+vvvuS/H+8Nhjj4359REn9Lqo0GWXXZa22mqrplifffbZtNBCC7UcQ9brNd73DjjggNo5rRbax/W22GKLzH67XVQonmIfhbYaW7wXzzLLLMN+HAWBYvNHY1tjjTVqBeLqW7wHxOaXxtaqUE8c9+KLL6Z555236Zz6Yj2tcjHWG2nnnXdOUVApWquiQvG6+cAHPtDUtaJCY9V2PAECVRbIa1N0lc2MjQCB7gsoKtR9Uz0SIECAQD4CeX1+jjnNrCL1e+yxR/rhD3847sGUde64k2I7vZxHPeigg9KJJ56YmZ+xzJF3Ms52b4q333679kCIxtaqINJNN92UnnnmmWGHx0MpoiBIY6svKhSF2x9++OF2w2p5XPSx7LLL1n6fVVRopIcXtFNUKI84s+Z7yzbHHt6jfaeR1/uIOfbhL4d+zbHnnQdFhcb99qgDAgQIdF2gl+uRuh68DgkQIECAAAECBAgQIECAQIEFFBUqcHKERoAAAQIECBAgQIAAAQIECBAgQKBoAr1cxNNq00IUX4kCEhMmTJjJ89Zbb6VYcP7jH/94GNmBBx6Y5pxzznTsscc2UV5//fVpgw02mPnzsRYVWm211dK99947rN/6ghKvv/56es973jPuFDYWFYoOY/z77bdfU+Gd0S52xRVXpE033bTpsLyKCuX1lNgYwGiLyRsHOZYNEyM5xuaFRRddtOmQdhbkD510xBFHpG984xvD+qgvKpTXvdNts6LEGZBvvvlmWmWVVdoqKBTWzz//fFMOe11U6Jprrkkbb7xxUxy//vWvU2wkyWqvvfZaiveExva9730v7b333rUf573QfrT3md/+9rdpySWXHO2wtn4fReFiU85Qiw1EkydPbjo3in3FE72zWhSbyiosV19U6LrrrksbbrhhWzGNdJCiQuMm1AEBAgRqAnltisZLgACBsQgoKjQWLccSIECAQD8Gj98nAAAgAElEQVQF8vz8vPTSSzfNty211FK1Qi2NhaOzDKJ4TPxNnXXWWZt+Xda5406K7RRlHnUsc+SdjHMsr4Osueq4t37zm9+kd73rXaN21Wputb6o0Mc+9rEU4xhvy7uoUB5xjvW7gDAq2hx7xDTaOPJ6HzHHPvxV06859rzzoKjQeN8dnU+AAIHuC/RyPVL3o9cjAQIECBAgQIAAAQIECBAoroCiQsXNjcgIECBAgAABAgQIECBAgAABAgQIFE6g14t4ttlmm/Szn/2syeH4449Phx122MyfR3GILbbYYkxeUfgiFiQPtayiQlkFfeL4v/71r7ViRY2tvqBE/G6BBRZoKl7y1a9+NX36059uO9bYcBGbN7JaPIX15ptvTnfffXeKxfKPPvpoiif0tmq77rprOvfcc5t+nVdRobhQVt+HH354Ou6441rG+b73vS/FYvD61viE5dEWkzd2PpYNEyMl55133sncBBPnPPXUU2mxxRYbNbejFRXK697JwyyPe3yscYbXmWeeWSss1tiWW2659JnPfCZFEbAllliiVhDq6aefHvbaHzqn10WF4rW68sorN8V81VVXZRYbigMfeuihtMIKKzSdc9lll818D8x7of1oN/jUqVPTMcccM9phbf0+CsOddNJJM4+NTUWR08YWT1+P94isFgWX9tlnn6Zf1RcValUI6ac//WlaZpll2oo1Dpp77rnTIossUjv+v/7rv9L222/fdG68b3/gAx9o+nncl1nvH/Vx1p+00UYbpWuvvXZYP1tvvXW65JJL2o7XgQQIECiqQJ6boos6ZnERIFA8AUWFipcTEREgQIBAtkCen5+32mqrFPNOje2CCy5IO+yww6gpOfLII9MZZ5yR9txzz7Tbbrs1FaIu49xxp8V2ijCPOpY58k7HOepN8f8P2GSTTdLVV1/ddPhFF12Utttuu1G7aaeo0O67757OPvvsYX2tv/766Tvf+c6o/dcfMHHixPTud7+79qMvfelL6dRTTx12fhRFj+LoWS1eKzvttFPTr1544YU0zzzz1H6eR5xVmGMPm3bGkcf7iDn24bdsv+bY886DokJjeit0MAECBHoi0Ov1SD0ZlIsQIECAAAECBAgQIECAAIECCCgqVIAkCIEAAQIECBAgQIAAAQIECBAgQIBAWQR6vYinVVGGKPYThXTqi+1EQYmTTz65LcpJkyal2267bVjBmyhyEwV/Gtt///d/pw9+8IPDfnzXXXeltdZaq+nYxqJC//qv/5quv/76Ycfttdde6bTTTmsrzpEOeuONN2rxNxY3+sc//pFuueWWFNd57LHHhnXRanF71qLr2GDQuDi+MZ52FnQvv/zytSdX17coChKL7LOeUN3KNgqLRIGRodbOteuvOZYNE6MlZ80116zdf40t8n/OOee0LDo0dHw7RYXyuHfyMCtCnOG6//77p+nTpw9Lyfzzz5+eeeaZNNtssw37+XXXXZc23HDDpvxlFRVqdT+OtnGqncXu8d4SMTa2KIBzyimnZN6GUTwnCqA1trgfV1999dqP27l2O6/lQw89NMWi+rG0v//972nhhRduKqY2lj7qj433+ueffz7NMccctR+/9tprKX7W2OJnUZQnivrUt5dffjnFE86jj8ZWX6zn7bffTrPPPnvTMeedd17mpp92xpN3UaHNNtssXXnllcNCicJZUWBOI0CAQNkF8twUXXYb8RMg0DsBRYV6Z+1KBAgQIDA+gTw/P8d8e1Yh55hviaIzQ0VRskbw5JNPNhX2njx5cq3481DRmDLOHXc6X1iEedSxzJF3Os527+asOfI4t517K45rp6jQN77xjRTXqW8xfxYFxrO+E2kn9jyKCuUR51i/C4ixF22OPWJqZxx5vI+YY//fV0M/59jzzkOr71viu4ahhwe0877gGAIECBDonkCv1yN1L3I9ESBAgAABAgQIECBAgACBYgsoKlTs/IiOAAECBAgQIECAAAECBAgQIECAQKEEer2IJwpILLTQQunVV1/NdPj+979fK54TC8CjmM6uu+6aogjEaO2mm25K66233rDDWhWA+PrXvz5s4fkrr7ySpkyZku69996myzQWFcpahB0nxaL1WAzd2B5//PH0uc99rrZ4e9ttt80cRphEUaJp06al1VZbrVZUYsKECU3HfuUrX0nHH3/8sJ9HAZPnnnuu6dishdlRpCOKngw9gTcrmHYWdLcq9hRFnA4//PBh3cbi5E9+8pOZBXvuueee2niHWjvXru98LBsmRrt/fvGLX9TizGprrLFGOuuss1IsZM9qf/zjH9OXv/zlFPdbfWvMTR73Th5mRYgzHDfaaKN07bXXDjNdd911080339yUhqxj46CsokJRlGjRRRdt6mPLLbdMl156actbpd3F7lkbHqLTKAy2zjrrDOv/0UcfTcsss0zTNRsL77R77fqOsu6NTooKxdPF4ynjjS2rEFDjMa3e5xufTr7VVlulyy67rOkaUazszDPPnPk+Ee/R8Tehsbja0In1RYXiZ1GkrvHY2MT061//uqkwVRx/xRVX1ArZRcGzlVdeuSmevIsKZb2nRRCxkXDVVVcd7W3M7wkQIFBogTw3RRd64IIjQKBQAooKFSodgiFAgACBEQTy/Pwche1jziTmyBpbzGfGvM0nPvGJYb/65z//mWbMmJF23HHHzELPMa8aRb+jlXHuuNP5wiLMo45ljrzTcbb7Yo0i4BMnTsz87ifurTPOOCNtvvnmmd3FdyTf/e53Mx8SEQW3o3BQtJjvzfqe5fzzz6/dn40t+t1jjz3SiiuuWPvuIqsIeR5FhfKIc6zfBYRF0ebYI6Z2xpHH+4g59v/5Lq7fc+x55yEeHrHTTjs1vRd8+9vfrn2PpxEgQIBA7wV6vR6p9yN0RQIECBAgQIAAAQIECBAg0B8BRYX64+6qBAgQIECAAAECBAgQIECAAAECBEop0I9FPOeee2767Gc/29IrilV8/OMfT4svvnh655130umnnz6i7aabblorBtHYomhNFITJalFcIwoJ/e53v0s//OEPMwsKxXmNRYVic8SGG27Y1GU84TIKIkXRkPe85z21IkN333137SnNQ4U14mnNsTA+FtBHe/vtt2v/njp16rCF9uuvv37afffd00orrVQziCdoPvTQQ2n77bdvum4U3YjfNbbNNtusVpyoscW1P/3pT9cW90eLAkORi1lnnbX273YWdD/44IOZBTfi/NgUEHHGdaJgygknnJC5QSXG9sADDwwLr51r158wlg0T7bw4WxU2GTo3Ni7E5oPYdBO5i2JOjzzySMt7p7GoUDfvnaGY8jArQpwxvt122y2dc845TamLIjNRAGjeeeetvTaOPPLI9KMf/SgzxVlFhaJY2SyzzJJ5fLyedthhh/TBD36w9vsoPjS00aXdxe6nnHJK2nfffTP7P+CAA2rFz2abbbba+8MxxxyTeVxsmogn6g61dq9d31m3igrF67mxYFZcJ4ppLbjggiO+tFoV4Yn30Hjy+FBrtcmmnddt/TGNRYXi3jj22GObuoniVFE8KApAxaa4hx9+OF1//fXDNi1Fkbco5Fa/0SjvokKtnqIcA4i/RfF3cWgj/DbbbDOq/1j9HE+AAIE8BfLcFJ1n3PomQKBaAooKVSufRkOAAIEqC+T9+TkKsMRcQ6sWc90xr77kkkumP//5z+nWW29tWeQ5+qgvHl/GueNO5wuLMI86ljnyTsc5ltfa9OnTaw9YaNVizjyKeS+77LJpjjnmqBWp+sMf/pB++ctftjynvqhQzMm3mpOMa3/qU5+q/T7mU++///7agxxiHjZafCdx9tlnp49+9KPDrpVHUaE84hzrdwExyKLNsUdM7Ywjj/cRc+ztvZLznmPPOw933XVXWmuttTIHGwXwotBWvPdEmzRpkmL+7d0WjiJAgMC4BPqxHmlcATuZAAECBAgQIECAAAECBAiUREBRoZIkSpgECBAgQIAAAQIECBAgQIAAAQIEiiDQr0U8URDhZz/7WVcIWj2F9s0330xLLbVUZlGbdi/cWFQozhtP7FEw6cYbb0yrrbZaiqdCR9GgWDjfaYtF4WeddVbT6UcffXRtwXw7LYoSRTGVaO0s6B6vQZwfuY8iPvWt3WsPnTOWDRPtOMTmhKFiS+0cP9oxjUWFxutWf+8MXTsvs27d453GGed961vfSlH8azwtq6hQ9BfFv371q1+N2nWYv/LKK7Xj2l3s/tJLL9WKT2U97X3UC6aU4ppRcCveG4Zau9ce7fUUnlHoq93WavPLxhtvnK666qpRu3n99ddrRdayWhR0+8hHPlL7VRT2iUJDUdhnPK1xw0M8iTxeI52+x8ZGo5tvvjnNPffctbDyLip0ww03pA022KAtgtNOOy3ttddebR3rIAIECBRBIO9N0UUYoxgIECi+gKJCxc+RCAkQIEDgfwTy/vwcxWWiaNC99947bvJdd901xUME6tt45hajn37MHXcyXxixjmesvZzvHcpPp+Ns90aJYvwrrLDCiEWo2u1r6Lj6okLxs3hQw3777TfWbmYeHw+Z2GOPPWb+O4+iQnnEOdbvAiKGos2xR0ztjmM8r62s9xFz7O29ZPKeY887D/H9zDzzzNPWYHfccccU3y9rBAgQIJCvQL/WI+U7Kr0TIECAAAECBAgQIECAAIH+Cygq1P8ciIAAAQIECBAgQIAAAQIECBAgQIBAaQT6tYjnxRdfTDvttFO69tprx20VxVtuv/32tMQSSzT1dcEFF9Su02nLKir01FNPzSyGMdZ+I8Y777wzffCDH6yd+uMf/zjFxotOW/S15pprNp0evh/+8IfTq6++OmrXnRQViv5XX3319OSTT47af+MBBx54YDrppJOazmt3MfnQid0uKhT9xpOKd9999zGPKeuEzTffPF1++eXDftXNeyc6zsus33HG2OK+jA0o42mtigrF09XXXXfdUbvupKhQdBpPZ4+NWZ20Sy+9NG255ZbDTs17oX2rOP/zP/8zHXDAAU2//tGPfpR22WWXtoYXr6d4XTW2Y445Jn3ta1+b+eN4IvmUKVM6ek8Z6qRxw0P8PO6Bbbfdtq1YGw+KJ5tfeOGFaZZZZqn9Ku+iQnGNf/3Xf22ruJKiQh2l1EkECPRRIO9N0X0cmksTIFAiAUWFSpQsoRIgQGDABXrx+Tnm3tZff/2OizFHimIO67zzzksTJkwYlrEyzh13Ml8Yg+73POpY58g7HedYXpJ33313rdhSp0XX66+1yCKLpPvuu2/m9ynxu7///e+1hzY8+OCDYwlr5rHxXdKkSZNm/juvokLdjnOs3wXEAIs2xx4xtTuObr+PmGNv7+WS9xx7L/Jw7LHHpiOPPHLUASsqNCqRAwgQINAVgX6tR+pK8DohQIAAAQIECBAgQIAAAQIFFlBUqMDJERoBAgQIECBAgAABAgQIECBAgACBogn0cxFPLKo+6qij0je+8Y1xs0Sxnl/96ldpwQUXHNZXPHU5CkrE041Ha1OnTk3Tpk0bdlhWUaE44LbbbqsVn3nsscdG63bm75dbbrkUC3Ibix+deOKJ6ZBDDmm7n6ED44m8seC9VWtVAKPx+E6KCkUfv//972uFRcK93fZv//ZvKZxnnXXWplPaXUw+dOJYN0y0G2MUN4lCKu3cM1l9rr322ikKpsSmnKzWzXsnT7N+xjnkdsIJJ6TDDz981NQttdRSaZNNNknf/va3hx3bqqhQHHTQQQelk08+ecS+Oy0qFJ3OmDEj7bDDDm1vzIprxVOyt9tuu6aYerHQPgti6aWXznyPe/nll9P73ve+UfMSB1x33XVpww03bDo2NgTFe8hQwZ444Pnnn68VgfvlL3/Zsu8477jjjsssanTVVVeljTfeuOncKGq0//77t1VkbejkyMM555yT5pxzzpn99aKo0G9+85s0efLkUe8bRYXauv0cRIBAgQR6sSm6QMMVCgECBRVQVKigiREWAQIECDQJ9Orz89NPP5223377dMcdd4w5C/vuu29tbi1rnjc6K+Pc8VjnC4fQ+jmP2skceafjHMtN8vrrr6evf/3rHX/3E3OA//7v/54+/elPp9lmm63p0nHvxtivvPLKtsOK+deLLroobbTRRsPOyauoUFykm3GO9buAoUEWaY49YhrLOLr5PmKO/X9v+37OsfciD2+++Wbt+7nR/rYpKtT226cDCRAgMC6Bfq5HGlfgTiZAgAABAgQIECBAgAABAgUXUFSo4AkSHgECBAgQIECAAAECBAgQIECAAIEiCRRhEc+jjz6aoujDKaecMmrRh3XXXTfdcsstmYQrrbRSuvnmm9Pcc8897Pf//Oc/0+mnn56+8IUvZJ4XC2i///3vpzh/scUWG3bM5z//+fSDH/wg87y//vWv6fjjj09HH330iCmNgiexwD0Wp2ctgI+TY+PBSSedlKIIymgtCvnEpo211lprtENTFKiIGK+++uqWRSpGKyoUhZ8aiy0NXTgKQ4Xd9OnTRyywFE+tPvjgg1Pkr1XLWkw+0rWzNkxEQZ942nI32hVXXJFiwf39998/6n05//zzpzXWWKNWqKZVMaH6mLp17+Rt1q84h6yiKFhs9Dj00ENbPtk6ir9EgZV4Knq8LurbSEWF4rjYdBLnRrGvrNZOUaHrr78+bbDBBpnn//nPf07f/OY30/e+972W91BcIzbHRPGkj3zkI5n9tFpoP9K1s+6NeK+Kol7ttMcffzzFe1dja1VorVWf8R4x77zzZo4/NsituuqqTafeeeed6YILLkjxtyGe9v6BD3wgrb766mmVVVZJm2++efr1r3+d1ltvvabz/u///b9phRVWyAzlj3/8Y61YWNxPI7Uo6HPggQemLbbYoumwVkWFXnnllRR5bGyxaajxb0occ8MNN4z4PhFP4Y737Shs1qpwnaJC7dzFjiFAoEgCvdoUXaQxi4UAgeIJKCpUvJyIiAABAgSyBXr5+TnmzmNuLAoERZHs0VrMr+y9994pilGP1so4dzyW+cL68fdrHrXTOfJOxzlazht/H989fO1rX0t33313y/ndoXNifm355ZevfY/TqphQY/8xh/jlL395xALd0e+ee+6ZjjjiiPTBD36waQhZRYVG+p4hrhmF0Rvba6+9luaaa65Mom7EOdbvAoYCKdIce8Q01nF0633EHHsx5th7lYe4b2IO/fzzz2/5YBRFhcb6ju54AgQIdCZQhPVInUXuLAIECBAgQIAAAQIECBAgUGwBRYWKnR/RESBAgAABAgQIECBAgAABAgQIECiUQJEW8bz11lspClk8++yzKeJ6/vnn05xzzpnmm2++2n8f/ehHa8UpouDEpEmTmhxjcfh9991XW5Sc1d544430yCOPpFjIHv0vueSSac0110xRVGg8LRZlR8xR/CH+iwIT88wzT1pggQVqmyuWWWaZtrt/6aWXajFGMaAoLPH222/XilUstNBC6UMf+lBaYoklahZjbbE5JIpqvPzyyyk2ONS3iC+cx9uioMeTTz5Zs4gF9FFoJ2yjWFP87zK3yEWM7be//W3t6cITJkxIiy++eK0IzIc//OHavztp3bx3Orl+u+f0O854suzDDz9cy8Ef/vCH2vtAFJlZdtllWz4Nvd2xxXHxOht6fcRi86E2yyyz1O7f8bboPzaDxb0Tr4/wjNfzwgsvXBtHp/fPeOMq6/mnnnpqrUhbY4snoI9mGbmI+yj+1sTrOf4d76nxfh1/YxZccMFCsfzlL39JL7zwQu09tb7Fe2snfwsKNTjBECAwUAK93BQ9ULAGS4DAmAQUFRoTl4MJECBAoI8C/fr8HPMP99xzT/rTn/6UYk4i/h1FWBZddNHaPFbMh44299KKrWxzx53OF/Z7HnWst22n4xzrdeL4+H7md7/7XW1uLv6L7yxibj3m2OO/+E6l0xbF3WOuL75bee6559J73vOe2ncSUfB7tdVW68occqex1Z/XzzjLPscejmV7H+nGPZNXH4M0xx7fG8T7QvxNe+edd2aSvv/976/9XdMIECBAIF+BIq1HynekeidAgAABAgQIECBAgAABAr0VUFSot96uRoAAAQIECBAgQIAAAQIECBAgQKDUAmVdxHPdddelDTfccKZ9FFj4xS9+0dYTkkudMMETIECgwgK33HJLOuyww9IPfvCDtOKKKzaN9G9/+1uaOHFi05PN429AFG3SCBAgQKCYAv3aFF1MDVERINAvAUWF+iXvugQIECAwVgGfn8cq5ngCBAgQGBIwx+5eIECAAIEiCZR1PVKRDMVCgAABAgQIECBAgAABAgSyBBQVcl8QIECAAAECBAgQIECAAAECBAgQINC2QJkX8Vx44YVpxx13TMstt1yKIkPxtGSNAAECBMonEE8mP/HEE9Ohhx5aC/69731vOvPMM9Naa62VomBQPEE4nkS9zz77pDvuuKNpgNtvv32KvwkaAQIECBRTwKboYuZFVAQGTUBRoUHLuPESIECgvAI+P5c3dyInQIBAvwTMsfdL3nUJECBAYCSBMq9HklkCBAgQIECAAAECBAgQIFBkAUWFipwdsREgQIAAAQIECBAgQIAAAQIECBAomEDZF/FcffXVadKkSWmeeeYpmKxwCBAgQKAdgddeey3tsssu6bLLLss8PAoMvfrqqyN29fjjj6eJEye2cznHECBAgEAfBGyK7gO6SxIg0CSgqJCbggABAgTKIuDzc1kyJU4CBAgUQ8AcezHyIAoCBAgQaBYo+3okOSVAgAABAgQIECBAgAABAkUVUFSoqJkRFwECBAgQIECAAAECBAgQIECAAIECCljEU8CkCIkAAQIDJPCXv/wlLbfccun555/vaNTTpk1LRx11VEfnOokAAQIEeiNgU3RvnF2FAIGRBRQVcocQIECAQFkEfH4uS6bESYAAgWIImGMvRh5EQYAAAQLNAtYjuSsIECBAgAABAgQIECBAgEA+AooK5eOqVwIECBAgQIAAAQIECBAgQIAAAQKVFLCIp5JpNSgCBAiUSuCee+5Ja6yxxphj3nnnndPpp5+eJkyYMOZznUCAAAECvROwKbp31q5EgEBrAUWF3B0ECBAgUBYBn5/LkilxEiBAoDgC5tiLkwuRECBAgMD/CliP5G4gQIAAAQIECBAgQIAAAQL5CCgqlI+rXgkQIECAAAECBAgQIECAAAECBAhUUsAinkqm1aAIECBQOoGnn346felLX0o///nPR419kUUWqRUT2mijjUY91gEECBAg0H8Bm6L7nwMRECCQkqJC7gICBAgQKIuAz89lyZQ4CRAgUCwBc+zFyodoCBAgQCAl65HcBQQIECBAgAABAgQIECBAIB8BRYXycdUrAQIECBAgQIAAAQIECBAgQIAAgUoKWMRTybQaFAECBEor8Oyzz6ZrrrkmPfHEE7WFpq+99lp697vfnZZaaqnaf0suuWRafvnl05xzzlnaMQqcAAECgyZgU/SgZdx4CRRTQFGhYuZFVAQIECDQLODzs7uCAAECBMYjYI59PHrOJUCAAIFuCliP1E1NfREgQIAAAQIECBAgQIAAgf8VUFTI3UCAAAECBAgQIECAAAECBAgQIECAQNsCFvG0TeVAAgQIECBAgAABAgQ6ELApugM0pxAg0HUBRYW6TqpDAgQIEMhJwOfnnGB1S4AAAQIECBAgQIBATwWsR+opt4sRIECAAAECBAgQIECAwAAJKCo0QMk2VAIECBAgQIAAAQIECBAgQIAAAQLjFbCIZ7yCzidAgAABAgQIECBAYCQBm6LdHwQIFEFAUaEiZEEMBAgQINCOgM/P7Sg5hgABAgQIECBAgACBogtYj1T0DImPAAECBAgQIECAAAECBMoqoKhQWTMnbgIECBAgQIAAAQIECBAgQIAAAQJ9ELCIpw/oLkmAAAECBAgQIEBggARsih6gZBsqgQILKCpU4OQIjQABAgSGCfj87IYgQIAAAQIECBAgQKAKAtYjVSGLxkCAAAECBAgQIECAAAECRRRQVKiIWRETAQIECBAgQIAAAQIECBAgQIAAgYIKWMRT0MQIiwABAgQIECBAgEBFBGyKrkgiDYNAyQUUFSp5AoVPgACBARLw+XmAkm2oBAgQIECAAAECBCosYD1ShZNraAQIECBAgAABAgQIECDQVwFFhfrK7+IECBAgQIAAAQIECBAgQIAAAQIEyiVgEU+58iVaAgQIECBAgAABAmUTsCm6bBkTL4FqCigqVM28GhUBAgSqKODzcxWzakwECBAgQIAAAQIEBk/AeqTBy7kREyBAgAABAgQIECBAgEBvBBQV6o2zqxAgQIAAAQIECBAgQIAAAQIECBCohIBFPJVIo0EQIECAAAECBAgQKKyATdGFTY3ACAyUgKJCA5VugyVAgECpBXx+LnX6BE+AAAECBAgQIECAwP8XsB7JrUCAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmBGlOREAACAASURBVFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQREgQIAAAQIECBAojIBN0YVJhUAIDLSAokIDnX6DJ0CAQKkEfH4uVboES4AAAQIECBAgQIBACwHrkdwaBAgQIECAAAECBAgQIEAgHwFFhfJx1SsBAgQIECBAgAABAgQIECBAgACBSgpYxFPJtBoUAQIECBAgQIAAgcII2BRdmFQIhMBACygqNNDpN3gCBAiUSsDn51KlS7AECBAgQIAAAQIECLQQsB7JrUGAAAECBAgQIECAAAECBPIRUFQoH1e9EiBAgAABAgQIECBAgAABAgQIEKikgEU8lUyrQVVYYMaMGemmm26aOcL4d2PL+lmFSQyNAAECuQlMnjx5Zt/1/zt+OHXq1Nyuq2MCVROwKbpqGTUeAuUUUFSonHkTNQECBAZRwOfnQcy6MZdFwPx8WTIlTgIEqiBgfr4KWTSGQRewHmnQ7wDjJ0CAAAECBAgQIECAAIG8BBQVyktWvwQIECBAgAABAgQIECBAgAABAgQqKGARTwWTakiVERjaoDBUJEixoMqk1kAIEKiQwNFHH10bjSJDFUqqoXRdwKborpPqkACBDgQUFeoAzSkECBAg0BcBn5/7wu6iBJoEzM+7KQgQIFB8AfPzxc+RCAdbwHqkwc6/0RMgQIAAAQIECBAgQIBAfgKKCuVnq2cCBAgQIECAAAECBAgQIECAAAEClROwiKdyKTWgkgvERoVp06YlBYRKnkjhEyAwsAKxiUGBoYFNv4G3ELAp2q1BgEARBBQVKkIWxECAAAEC7Qj4/NyOkmMI5CNgfj4fV70SIECgVwLm53sl7ToE2hOwHqk9J0cRIECAAAECBAgQIECAAIGxCigqNFYxxxMgQIAAAQIECBAgQIAAAQIECBAYYAGLeAY4+YZeGIGhJx4PPU1zpMAmT55c+/XQ//3EJz7RdPjQ7wozQIEQIECgpAL1Bd5uuummmaOIn49W/M3mhZImXdi5CNgUnQurTgkQGKOAokJjBHM4AQIECPRNwOfnvtG78IAKmJ8f0MQbNgEChRcwP1/4FAmQwKgC1iONSuQAAgQIECBAgAABAgQIECDQkYCiQh2xOYkAAQIECBAgQIAAAQIECBAgQIDAYApYxDOYeTfqYgiM9tTjoeJAU6dOrQWsWFAx8iYKAgQIDAkMbTqLf7cqDKe4kPuFQEo2RbsLCBAogoCiQkXIghgIECBAoB0Bn5/bUXIMgfELmJ8fv6EeCBAg0E8B8/P91HdtAu0JWI/UnpOjCBAgQIAAAQIECBAgQIDAWAUUFRqrmOMJECBAgAABAgQIECBAgAABAgQIDLCARTwDnHxD76vAtGnTMgtQROGgKCKkgFBf0+PiBAgQ6Egg3tujZRUYUlyoI1InVUTApuiKJNIwCJRcQFGhkidQ+AQIEBggAZ+fByjZhto3AfPzfaN3YQIECOQmYH4+N1odE+hYwHqkjumcSIAAAQIECBAgQIAAAQIERhRQVMgNQoAAAQIECBAgQIAAAQIECBAgQIBA2wIW8bRN5UACXRPI2rCgmFDXeHVEgACBvgu02rygsFDfUyOAPgnYFN0neJclQGCYgKJCbggCBAgQKIuAz89lyZQ4yypgfr6smRM3AQIE2hMwP9+ek6MI9ELAeqReKLsGAQIECBAgQIAAAQIECAyigKJCg5h1YyZAgAABAgQIECBAgAABAgQIECDQoYBFPB3COY1AhwJTpkxJM2bMmHm2YkIdQjqNAAECJRCIzQvxnt/4vn/jjTeWIHohEuiegE3R3bPUEwECnQsoKtS5nTMJECBAoLcCPj/31tvVBkvA/Pxg5dtoCRAYbAHz84Odf6MvhoD1SMXIgygIECBAgAABAgQIECBAoHoCigpVL6dGRIAAAQIECBAgQIAAAQIECBAgQCA3AYt4cqPVMYEmgcYNC0cffXSaOnUqKQIECBCouEBsXoj3/KEWBeUUFqp40g1vmIBN0W4IAgSKIKCoUBGyIAYCBAgQaEfA5+d2lBxDYOwC5ufHbuYMAgQIVEHA/HwVsmgMZRWwHqmsmRM3AQIECBAgQIAAAQIECBRdQFGhomdIfAQIECBAgAABAgQIECBAgAABAgQKJGART4GSIZRKCzQuWFVQqNLpNjgCBAg0Cdi44KYYZAGbogc5+8ZOoDgCigoVJxciIUCAAIGRBXx+docQ6L6A+fnum+qRAAECZRIwP1+mbIm1SgLWI1Upm8ZCgAABAgQIECBAgAABAkUSUFSoSNkQCwECBAgQIECAAAECBAgQIECAAIGCC1jEU/AECa8yAvUbWBUUqkxaDYQAAQJjEmjcuHDjjTemyZMnj6kPBxMoo4BN0WXMmpgJVE9AUaHq5dSICBAgUFUBn5+rmlnj6qeA+fl+6rs2AQIEiiFgfr4YeRDFYAlYjzRY+TZaAgQIECBAgAABAgQIEOidgKJCvbN2JQIECBAgQIAAAQIECBAgQIAAAQKlF7CIp/QpNIASCDQuUv3nP/9ZgqiFSIAAAQJ5CPibkIeqPosuYFN00TMkPgKDIaCo0GDk2SgJECBQBQGfn6uQRWMokoC5mCJlQywECBDor4C/Cf31d/XBE7AeafBybsQECBAgQIAAAQIECBAg0BsBRYV64+wqBAgQIECAAAECBAgQIECAAAECBCohYBFPJdJoEAUX8BTkgidIeAQIEOixwJQpU9KMGTNqV508eXK68cYbexyByxHorYBN0b31djUCBLIFFBVyZxAgQIBAWQR8fi5LpsRZFgHz82XJlDgJECDQGwHz871xdhUCIWA9kvuAAAECBAgQIECAAAECBAjkI6CoUD6ueiVAgAABAgQIECBAgAABAgQIECBQSQGLeCqZVoMqkED9Ey+PPvroNHXq1AJFJxQCBAgQ6IdAFBSKjQtDLYoKRXEhjUBVBWyKrmpmjYtAuQQUFSpXvkRLgACBQRbw+XmQs2/s3RYwP99tUf0RIECg/ALm58ufQyMoj4D1SOXJlUgJECBAgAABAgQIECBAoFwCigqVK1+iJUCAAAECBAgQIECAAAECBAgQINBXAYt4+srv4gMgUP+0S0WFBiDhhkiAAIE2BTwNuU0oh1VCwKboSqTRIAiUXkBRodKn0AAIECAwMAI+Pw9Mqg20BwLm53uA7BIECBAooYD5+RImTcilFLAeqZRpEzQBAgQIECBAgAABAgQIlEBAUaESJEmIBAgQIECAAAECBAgQIECAAAECBIoiYBFPUTIhjqoK2Lha1cwaFwECBMYvUP834sYbb0yTJ08ef6d6IFBAAZuiC5gUIREYQAH/v9kAJt2QCRAgUFIBn59LmjhhF1LAZ8BCpkVQBAgQKISA+flCpEEQFRewHqniCTY8AgQIECBAgAABAgQIEOibgKJCfaN3YQIECBAgQIAAAQIECBAgQIAAAQLlE7CIp3w5E3G5BGxaKFe+REuAAIFeCngaci+1XaufAjZF91PftQkQGBLw/5u5FwgQIECgLAI+P5clU+Isg4DPgGXIkhgJECDQHwHz8/1xd9XBErAeabDybbQECBAgQIAAAQIECBAg0DsBRYV6Z+1KBAgQIECAAAECBAgQIECAAAECBEovYBFP6VNoAAUWmDFjRooFqdEmT56cbrzxxgJHKzQCBAgQ6LWAvxO9Fne9fgnYFN0vedclQKBewIZy9wMBAgQIlEXA5+eyZEqcRRcw71L0DImPAAEC/RXwd6K//q4+GALWIw1Gno2SAAECBAgQIECAAAECBHovoKhQ781dkQABAgQIECBAgAABAgQIECBAgEBpBSziKW3qBF4CgWnTpqWjjz66Fmn836lTp5YgaiESIECAQC8F6gscRPG5KEKnEaiagE3RVcuo8RAop4CiQuXMm6gJECAwiAI+Pw9i1o05DwHz83mo6pMAAQLVEjA/X618Gk3xBKxHKl5ORESAAAECBAgQIECAAAEC1RBQVKgaeTQKAgQIECBAgAABAgQIECBAgAABAj0RsIinJ8wuMqACNi0MaOINmwABAmMQmDJlSoonIkdTVGgMcA4tlYBN0aVKl2AJVFZAUaHKptbACBAgUDkBn58rl1ID6pOA+fk+wbssAQIESiRgfr5EyRJqKQWsRyplAXOVEgAAIABJREFU2gRNgAABAgQIECBAgAABAiUQUFSoBEkSIgECBAgQIECAAAECBAgQIECAAIGiCFjEU5RMiKOKAjYtVDGrxkSAAIHuCkRBodi4EG3y5Mm1wkIagaoJ2BRdtYwaD4FyCigqVM68iZoAAQKDKODz8yBm3ZjzEDA/n4eqPgkQIFAtAfPz1cqn0RRPwHqk4uVERAQIECBAgAABAgQIECBQDQFFhaqRR6MgQIAAAQIECBAgQIAAAQIECBAg0BMBi3h6wuwiAypg08KAJt6wCRAgMEYBRQ7GCObw0gnYFF26lAmYQCUF/L2tZFoNigABApUU8Pm5kmk1qD4ImJ/vA7pLEiBAoIQC5gtKmDQhl0bAeqTSpEqgBAgQIECAAAECBAgQIFAyAUWFSpYw4RIgQIAAAQIECBAgQIAAAQIECBDop4BFPP3Ud+2qC9i0UPUMGx8BAgS6I2DTQncc9VJcAZuii5sbkREYJAF/bwcp28ZKgACBcgv4/Fzu/Im+OALm54uTC5EQIECgyALmC4qcHbGVXcB6pLJnUPwECBAgQIAAAQIECBAgUFQBRYWKmhlxESBAgAABAgQIECBAgAABAgQIECiggEU8BUyKkCojYNNCZVJpIAQIEMhVwKaFXHl1XgABm6ILkAQhECCQ/L11ExAgQIBAWQR8fi5LpsRZdAHz80XPkPgIECBQDAHzBcXIgyiqKWA9UjXzalQECBAgQIAAAQIECBAg0H8BRYX6nwMRECBAgAABAgQIECBAgAABAgQIECiNgEU8pUmVQEsoYNNCCZMmZAIE/h97dwImVXEufPxFFmWVAUGJIDKDoLiQ8EE0108ZIiPGXeN1SzRejQ8x0cR9icbucQ2JC1ETl7gkZtGY4BqXOFwZQoy4fO4SRGeQxbDJDIKyY39PNemme6Z7+uyn6tS/nydPLtPnVL31e2vudOpUvY1ADAITJkyQxsbGbM8zZsyQ2traGKKgSwTCE+BQdHi2tIwAAs4FOCTo3IorEUAAAQTiFeDzc7z+9J4cAdbnk5NLRoIAAgiEKcD6fJi6tG27APuRbJ8BjB8BBBBAAAEEEEAAAQQQQCAsAYoKhSVLuwgggAACCCCAAAIIIIAAAggggAACCCRQgE08CUwqQ9JGgEML2qSCQBBAAAGtBTi0oHV6CC4AAQ5FB4BIEwgg4FuAokK+CWkAAQQQQCAiAT4/RwRNN4kXYH0+8SlmgAgggEAgAqzPB8JIIwiUFGA/EhMDAQQQQAABBBBAAAEEEEAAgXAEKCoUjiutIoAAAggggAACCCCAAAIIIIAAAgggkEgBNvEkMq0MShMBDi1okgjCQAABBDQX4NCC5gkiPN8CHIr2TUgDCCAQgABFhQJApAkEEEAAgUgE+PwcCTOdWCDA+rwFSWaICCCAQAACrM8HgEgTCJQRYD8SUwMBBBBAAAEEEEAAAQQQQACBcAQoKhSOK60igAACCCCAAAIIIIAAAggggAACCCCQSAE28SQyrQxKEwEOLWiSCMJAAAEENBfg74XmCSI83wIcivZNSAMIIBCAAEWFAkCkCQQQQACBSAT4/BwJM51YIMB6iwVJZogIIIBAAAL8vQgAkSYQKCPAfiSmBgIIIIAAAggggAACCCCAAALhCFBUKBxXWkUAAQQQQAABBBBAAAEEEEAAAQQQQCCRAmziSWRaGZQmAmxC1SQRhIEAAghoLsDfC80TRHi+BTgU7ZuQBhBAIAABigoFgEgTCCCAAAKRCPD5ORJmOrFAgPUWC5LMEBFAAIEABPh7EQAiTSBQRoD9SEwNBBBAAAEEEEAAAQQQQAABBMIRoKhQOK60igACCCCAAAIIIIAAAggggAACCCCAQCIF2MSTyLQyKE0E2ISqSSIIAwEEENBcgL8XmieI8HwLcCjaNyENIIBAAAIUFQoAkSYQQAABBCIR4PNzJMx0YoEA6y0WJJkhIoAAAgEI8PciAESaQKCMAPuRmBoIIIAAAggggAACCCCAAAIIhCNAUaFwXGkVAQQQQAABBBBAAAEEEEAAAQQQQACBRAqwiSeRaWVQmgiwCVWTRBAGAgggoLkAfy80TxDh+RbgULRvQhpAAIEABCgqFAAiTSCAAAIIRCLA5+dImOnEAgHWWyxIMkNEAAEEAhDg70UAiDSBQBkB9iMxNRBAAAEEEEAAAQQQQAABBBAIR4CiQuG40ioCCCCAAAIIIIAAAggggAACCCCAAAKJFGATTyLTyqA0EWATqiaJIAwEEEBAcwH+XmieIMLzLcChaN+ENIAAAgEIUFQoAESaQAABBBCIRIDPz5Ew04kFAqy3WJBkhogAAggEIMDfiwAQaQKBMgLsR2JqIIAAAggggAACCCCAAAIIIBCOAEWFwnGlVQQQQAABBBBAAAEEEEAAAQQQQAABBBIpwCaeRKaVQWkiwCZUTRJBGAgggIDmAvy90DxBhOdbgEPRvglpAAEEAhCgqFAAiDSBAAIIIBCJAJ+fI2GmEwsEWG+xIMkMEQEEEAhAgL8XASDSBAJlBNiPxNRAAAEEEEAAAQQQQAABBBBAIBwBigqF40qrCCCAAAIIIIAAAggggAACCCCAAAIIJFKATTyJTCuD0kSATaiaJIIwEEAAAc0F+HuheYIIz7cAh6J9E9IAAggEIEBRoQAQaQIBBBBAIBIBPj9HwkwnFgiw3mJBkhkiAgggEIAAfy8CQKQJBMoIsB+JqYEAAggggAACCCCAAAIIIIBAOAIUFQrHlVYRQAABBBBAAAEEEEAAAQQQQAABBBBIpACbeBKZVgaliQCbUDVJBGEggAACmgvw90LzBBGebwEORfsmpAEEEAhAgKJCASDSBAIIIIBAJAJ8fo6EmU4sEGC9xYIkM0QEEEAgAAH+XgSASBMIlBFgPxJTAwEEEEAAAQQQQAABBBBAAIFwBCgqFI4rrSKAAAIIIIAAAggggAACCCCAAAIIIJBIATbxJDKtDCoigcbGxg57mjlzpqTT6ew1tbW1kkqlOrxeXcMLAQQQQMA+AQ4t2Jdz20bMoWjbMs54EdBTgKJCeuaFqBBAAAEE2gvw+ZlZgYAzAdbnnTlxFQIIIIBAxwKszzNDEAhPgP1I4dnSMgIIIIAAAggggAACCCCAgN0CFBWyO/+MHgEEEEAAAQQQQAABBBBAAAEEEEAAAVcCbOJxxcXFCBQJFG4y9Uujig9VKjrktw/uRwABBBDQU4BDC3rmhaiCE+BQdHCWtIQAAt4FKCrk3Y47EUAAAQSiFeDzc7Te9GauAOvz5uaOyBFAAAGdBFif1ykbxJI0AfYjJS2jjAcBBBBAAAEEEEAAAQQQQEAXAYoK6ZIJ4kAAAQQQQAABBBBAAAEEEEAAAQQQQMAAATbxGJAkQtRaoPBgqp9AM5mMn9u5FwEEEEDAYAEOLRicPEJ3JMChaEdMXIQAAiELUFQoZGCaRwABBBAITIDPz4FR0pAFAqzPW5BkhogAAgiELMD6fMjANG+1APuRrE4/g0cAAQQQQAABBBBAAAEEEAhRgKJCIeLSNAIIIIAAAggggAACCCCAAAIIIIAAAkkTYBNP0jLKeKIWCOLbkNPptKRSqahDpz8EEEAAAU0EOLSgSSIIIzQBDkWHRkvDCCDgQoCiQi6wuBQBBBBAIFYBPj/Hyk/nhgmwPm9YwggXAQQQ0FCA9XkNk0JIiRFgP1JiUslAEEAAAQQQQAABBBBAAAEENBOgqJBmCSEcBBBAAAEEEEAAAQQQQAABBBBAAAEEdBZgE4/O2SE2UwT8fhtyJpMxZajEiQACCCAQggCHFkJApUmtBDgUrVU6CAYBawUoKmRt6hk4AgggYJwAn5+NSxkBxyzA+nzMCaB7BBBAwHAB1ucNTyDhay3AfiSt00NwCCCAAAIIIIAAAggggAACBgtQVMjg5BE6AggggAACCCCAAAIIIIAAAggggAACUQuwiSdqcfpLooCfb0NOp9OSSqWSyMKYEEAAAQQcCnBowSEUlxkrwKFoY1NH4AgkSoCiQolKJ4NBAAEEEi3A5+dEp5fBhSDA+nwIqDSJAAIIWCTA+rxFyWaokQuwHylycjpEAAEEEEAAAQQQQAABBBCwRICiQpYkmmEigAACCCCAAAIIIIAAAggggAACCCAQhACbeIJQpA0ERLx+G3Imk4EPAQQQQMByAQ4tWD4BLBg+h6ItSDJDRMAAAYoKGZAkQkQAAQQQyArw+ZmJgIB7Adbn3ZtxBwIIIIDAVgHW55kJCIQnwH6k8GxpGQEEEEAAAQQQQAABBBBAwG4BigrZnX9GjwACCCCAAAIIIIAAAggggAACCCCAgCsBNvG44uJiBMoKePk25HQ6LalUClUEEEAAAcsFOLRg+QSwYPgcirYgyQwRAQMEKCpkQJIIEQEEEEAgK8DnZyYCAu4FWJ93b8YdCCCAAAJbBVifZyYgEJ4A+5HCs6VlBBBAAAEEEEAAAQQQQAABuwUoKmR3/hk9AggggAACCCCAAAIIIIAAAggggAACrgTYxOOKi4sR6FDA7bchZzIZRBFAAAEEEODQAnMg8QIcik58ihkgAkYIUFTIiDQRJAIIIIAARYWYAwh4FmB93jMdNyKAAAJWC1BUyOr0M/iQBdiPFDIwzSOAAAIIIIAAAggggAACCFgrQFEha1PPwBFAAAEEEEAAAQQQQAABBBBAAAEEEHAvwCYe92bcgUA5ATffhpxOpyWVSoGJAAIIIIAARYWYA4kXoKhQ4lPMABEwQoCiQkakiSARQAABBCgqxBxAwLMA6/Oe6bgRAQQQsFqAokJWp5/BhyzAfqSQgWkeAQQQQAABBBBAAAEEEEDAWgGKClmbegaOAAIIIIAAAggggAACCCCAAAIIIICAewE28bg34w4EOhJw+m3ImUwGSAQQQAABBLICHFpgIiRdgKJCSc8w40PADAGKCpmRJ6JEAAEEEBDh8zOzAAHvAqzPe7fjTgQQQMBWAdbnbc08445CgP1IUSjTBwIIIIAAAggggAACCCCAgI0CFBWyMeuMGQEEEEAAAQQQQAABBBBAAAEEEEAAAY8CbOLxCMdtCJQRcPJtyOl0WlKpFIYIIIAAAghkBTi0wERIugCHopOeYcaHgBkCFBUyI09EiQACCCBAUSHmAAJ+BFif96PHvQgggICdAqzP25l3Rh2NAPuRonGmFwQQQAABBBBAAAEEEEAAAfsEKCpkX84ZMQIIIIAAAggggAACCCCAAAIIIIAAAp4F2MTjmY4bESgrUOnbkDOZDHoIIIAAAgjkBTi0wGRIugBFhZKeYcaHgBkCFBUyI09EiQACCCBAUSHmAAJ+BVif9yvI/QgggIBdAqzP25VvRhutAPuRovWmNwQQQAABBBBAAAEEEEAAAXsEKCpkT64ZKQIIIIAAAggggAACCCCAAAIIIIAAAr4F2MTjm5AGEGgn0NG3IafTaUmlUqghgAACCCCQF+DQApMh6QIUFUp6hhkfAmYIUFTIjDwRJQIIIIAARYWYAwj4FWB93q8g9yOAAAJ2CbA+b1e+GW20AuxHitab3hBAAAEEEEAAAQQQQAABBOwRoKiQPblmpAgggAACCCCAAAIIIIAAAggggAACCPgWYBOPb0IaQKCkQLlvQ85kMoghgAACCCBQJMChBSZE0gUoKpT0DDM+BMwQoKiQGXkiSgQQQAABigoxBxAIQoD1+SAUaQMBBBCwQ4D1eTvyzCjjEWA/Ujzu9IoAAggggAACCCCAAAIIIJB8AYoKJT/HjBABBBBAAAEEEEAAAQQQQAABBBBAAIHABNjEExglDSFQJFDq25DT6bSkUimkEEAAAQQQKPs3g78VTI4kClBUKIlZZUwImCdAUSHzckbECCCAgK0CfH62NfOMO0gB1ueD1KQtBBBAINkCFBVKdn4ZXbwC7EeK15/eEUAAAQQQQAABBBBAAAEEkitAUaHk5paRIYAAAggggAACCCCAAAIIIIAAAgggELgAm3gCJ6VBBPICbb8NOZPJoIMAAggggEA7AQ4tMCmSLsCh6KRnmPEhYIYARYXMyBNRIoAAAgiI8PmZWYBAMAKszwfjSCsIIIBA0gVYn096hhlfnALsR4pTn74RQAABBBBAAAEEEEAAAQSSLEBRoSRnl7EhgAACCCCAAAIIIIAAAggggAACCCAQsACbeAIGpTkECgTYhMp0QAABBBBwIsDfCydKXGOyAIeiTc4esSOQHAGKCiUnl4wEAQQQSLoAn5+TnmHGF5UA6y1RSdMPAgggYLYAfy/Mzh/R6y3AfiS980N0CCCAAAIIIIAAAggggAAC5gpQVMjc3BE5AggggAACCCCAAAIIIIAAAggggAACkQuwiSdycjq0TCB3cDWTyVg2coaLAAIIIJATaGxs7BBj5syZkk6ns9fU1tZKKpXq8Hp1DS8ETBLgULRJ2SJWBJIrQFGh5OaWkSGAAAJJE+Dzc9IyynjiFGB9Pk59+kYAAQT0EGB9Xo88EIWdAuxHsjPvjBoBBBBAAAEEEEAAAQQQQCB8AYoKhW9MDwgggAACCCCAAAIIIIAAAggggAACCCRGgE08iUklA9FMYHpTvTQ0peXF34vU1aQrFojQLHzCQQABBBAIUKDwm479NquKD1UqOuS3D+5HIGgBDkUHLUp7CCDgRYCiQl7UuAcBBBBAIA4BPj/HoU6fSRNgfT5pGWU8CCCAgHcB1ue923EnAn4F2I/kV5D7EUAAAQQQQAABBBBAAAEEECgtQFEhZgYCCCCAAAIIIIAAAggggAACCCCAAAIIOBZgE49jKi5EwJFAc2ujNDTVS3NLY9H1qrDQxJqUoza4CAEEEEAgeQKFhQz8jC6Tyfi5nXsRiEWAQ9GxsNMpAgi0EaCoEFMCAQQQQMAUAT4/m5Ip4tRRgPV5HbNCTAgggED8AqzPx58DIrBTgP1IduadUSOAAAIIIIAAAggggAACCIQvQFGh8I3pAQEEEEAAAQQQQAABBBBAAAEEEEAAgcQIsIknMalkIDELlDusUBgWhYViThLdI4AAAjEKBPFtyOl0WlIpCtTFmEa69ijAoWiPcNyGAAKBClBUKFBOGkMAAQQQCFGAz88h4tJ0YgVYn09sahkYAgggEIgA6/OBMNIIAq4F2I/kmowbEEAAAQQQQAABBBBAAAEEEHAkQFEhR0xchAACCCCAAAIIIIAAAggggAACCCCAAAJKgE08zAME/AtMb6qXhqZ0u4aq+9VKc0tju59TXMi/OS0ggAACJgr4/TbkTCZj4rCJGQHhUDSTAAEEdBCgqJAOWSAGBBBAAAEnAnx+dqLENQhsE2B9ntmAAAIIIOBEgPV5J0pcg0CwAuxHCtaT1hBAAAEEEEAAAQQQQAABBBDICVBUiLmAAAIIIIAAAggggAACCCCAAAIIIIAAAo4F2MTjmIoLEWgn0NFhhcljZ+SvL3cdxYWYVAgggIBdAn6+DTmdTksqlbILjNEmRoBD0YlJJQNBwGgBigoZnT6CRwABBKwS4POzVelmsD4EWJ/3gcetCCCAgIUCrM9bmHSGHLsA+5FiTwEBIIAAAggggAACCCCAAAIIJFSAokIJTSzDQgABBBBAAAEEEEAAAQQQQAABBBBAIAwBNvGEoUqbSRdobm2UhqZ6aW5pLBpqdb9aqatJSXVVbUkCigslfWYwPgQQQKCygNdvQ85kMpUb5woENBXgULSmiSEsBCwToKiQZQlnuAgggIDBAnx+Njh5hB6JAOvzkTDTCQIIIJBIAdbnE5lWBqWxAPuRNE4OoSGAAAIIIIAAAggggAACCBgtQFEho9NH8AgggAACCCCAAAIIIIAAAggggAACCEQrwCaeaL3pzWwBr4cVCkdNYSGz5wDRI4AAAn4FvHwbcjqdllQq5bdr7kcgNgEORcdGT8cIIFAgQFEhpgMCCCCAgCkCfH42JVPEGbUA6/NRi9MfAgggkDwB1ueTl1NGpLcA+5H0zg/RIYAAAggggAACCCCAAAIImCtAUSFzc0fkCCCAAAIIIIAAAggggAACCCCAAAIIRC7AJp7IyenQUIGgiwEF3Z6hrISNAAIIWCng9tuQM5mMlU4MOjkCHIpOTi4ZCQImC1BUyOTsETsCCCBglwCfn+3KN6N1JhD0enrQ7TkbBVchgAACCOggwPq8DlkgBlsE2I9kS6YZJwIIIIAAAggggAACCCCAQNQCFBWKWpz+EEAAAQQQQAABBBBAAAEEEEAAAQQQMFiATTwGJ4/QIxEod7igul+tTB47w3cMHF7wTUgDCCCAgHECbr4NOZ1OSyqVMm6MBIxAoQCHopkPCCAQhUBjY2OH3UyYMCH//owZHf9vudra2ihCpg8EEEAAAQRKCvD5mYmBwDYB1ueZDQgggAACQQuwPh+0KO0hUF6A/UjMDgQQQAABBBBAAAEEEEAAAQTCEaCoUDiutIoAAggggAACCCCAAAIIIIAAAggggEAiBdjEk8i0MqgABJpbG6WhqV6aW4oPpqpiQnU1KamuCvaQKcWFAkgaTSCAAAIGCTj9NuRMJmPQqAgVgdICHIpmZiCAQBQCTv+2OomFv79OlLgGAQQQQCAsAT4/hyVLuyYJsD5vUraIFQEEEDBPwOkaAusD5uWWiPUSYD+SXvkgGgQQQAABBBBAAAEEEEAAgeQIUFQoOblkJAgggAACCCCAAAIIIIAAAggggAACCIQuwCae0InpwDCBqA8rFPJQWMiwyUK4CCCAgA8BJ9+GnE6nJZVK+eiFWxHQQ4BD0XrkgSgQSLqAk7+tTgz4++tEiWsQQAABBMIU4PNzmLq0rbsA6/O6Z4j4EEAAgWQIOFlDYH0gGblmFPEKsB8pXn96RwABBBBAAAEEEEAAAQQQSK4ARYWSm1tGhgACCCCAAAIIIIAAAggggAACCCCAQOACbOIJnJQGDRbQpaiPLnEYnEpCRwABBIwQqPRtyHwLshFpJEgHAhyKdoDEJQggEIhApb+tTjrh768TJa5BAAEEEAhTgM/PYerSts4CuqyL6xKHzrkiNgQQQCAJApXWEFgfSEKWGUPcAuxHijsD9I8AAggggAACCCCAAAIIIJBUAYoKJTWzjAsBBBBAAAEEEEAAAQQQQAABBBBAAIEQBNjEEwIqTRonUO6QQHW/Wpk8dkZs4+HwQmz0dIwAAghEItDRtyHzLciRpIBOIhLgUHRE0HSDAALS0d9WJzz8/XWixDUIIIAAAmEL8Pk5bGHa102A9XndMkI8CCCAgB0CrM/bkWdGGa8A+5Hi9ad3BBBAAAEEEEAAAQQQQACB5ApQVCi5uWVkCCCAAAIIIIAAAggggAACCCCAAAIIBC7AJp7ASWnQIIHm1kZpaKqX5pbGoqhVMaG6mpRUV9VqMRqKC2mRBoJAAAEEQhEo923IfAtyKNw0GpMAh6JjgqdbBCwVKPe31QkHf3+dKHENAggggEDYAnx+DluY9nURYH1el0wQBwIIIGCvAOvz9uaekUcjwH6kaJzpBQEEEEAAAQQQQAABBBBAwD4BigrZl3NGjAACCCCAAAIIIIAAAggggAACCCCAgGcBNvF4puNGgwVMOaxQSKwKCzW1NrYrgFRXk5aJNSmDs0HoCCCAgN0Cpb4NOZ1OSyrF/2+3e2Yka/Qcik5WPhkNAroLlPrb6iRm/v46UeIaBBBAAIEoBPj8HIUyfcQpwPp8nPr0jQACCCBQKMD6PPMBgXAF2I8Uri+tI4AAAggggAACCCCAAAII2CtAUSF7c8/IEUAAAQQQQAABBBBAAAEEEEAAAQQQcC3AJh7XZNxguIAqztPQlG43ClOK85gev+HTh/ARQACBUATafhtyJpMJpR8aRSAuAQ5FxyVPvwjYK9D2b6sTCf7+OlHiGgQQQACBKAT4/ByFMn3EJWD6+rbp8ceVd/pFAAEEdBZgfV7n7BCb6QLsRzI9g8SPAAIIIIAAAggggAACCCCgqwBFhXTNDHEhgAACCCCAAAIIIIAAAggggAACCCCgoQCbeDRMCiGFIlBus391v1qZPHZGKH2G2SiHF8LUpW0EEEAgWoHCb0NOp9OSSqWiDYDeEAhZgEPRIQPTPAIItBMo/NvqhIe/v06UuAYBBBBAICoBPj9HJU0/UQqwPh+lNn0hgAACCLgRYH3ejRbXIuBOgP1I7ry4GgEEEEAAAQQQQAABBBBAAAGnAhQVcirFdQgggAACCCCAAAIIIIAAAggggAACCCAgbOJhEiRdoLm1URqa6qW5pbFoqKqYUF1NSqqrao0moLiQ0ekjeAQQQCAvkPs25EwmgwoCiRPgUHTiUsqAEDBCIPe31Umw/P11osQ1CCCAAAJRCfD5OSpp+olCgPX5KJTpAwEEEEDArwDr834FuR+B0gLsR2JmIIAAAggggAACCCCAAAIIIBCOAEWFwnGlVQQQQACBAAVa12+WxZ9ukMWr18u/P9soyz7bKCs+3yQt6zZJ67rNsmaj+s8W2bD5C9mwOSNfSEY6d+okXbbrJD26dpaeXbeTPjt0kb47dJH+3bvKgJ5dZeee3eRLvbeXXft0k9123CH7Hi8EEEAAAQQQQAABBBBAAIHKAmziqWzEFWYKJP2wQmFWVGGhptbGdoWT6mrSMrEmZWYCiRoBBBCwTEB9G7J6pVL8/23LUm/FcDkUbUWaGSQC2gmov63pdLpiXOoa/v5WZOICBBBAAIEIBfj8HCE2XYUmwPq8COvzoU0vGkYAAQQCF2B9PnBSGkQgK8B+JCYCAggggAACCCCAAAIIIIAAAuEIUFQoHFdaRQABBBDwKPDp+s3y3orP5f1P1sq8levkw5Z10ty6Tlat3+yxxcq37bhDF6mp6i7D+3WXEf27y5479ZQ9B/SQKgoNVcbjCgQQQAABBBBAAAEEELBOgE081qXcigGrIjsNTe0PjyZ9E7+t47ZiUjNIBBBAAAEEDBbgULTBySN0BAwX6NSpU8URZDKZitdwAQIIIIAAAlEK8Pk5Sm1Bff8nAAAgAElEQVT6CkPA1nVqW8cdxhyiTQQQQAABBBBIhgD7kZKRR0aBAAIIIIAAAggggAACCCCgnwBFhfTLCREhgAACVgls2pKR15eskTeXfiZvL/tM3ln2uXy8ZkPsBoP7bC/7DOwp++3cS748qJd8ZZde0q3zdrHHRQAIIIAAAggggAACCCCAQNwCbOKJOwP0H6RAuU371f1qZfLYGUF2pXVbHF7QOj0EhwACCCCAgHUCHIq2LuUMGAFtBOrr6yWdbl9wNhegei+VSmkTL4EggAACCCCgBPj8zDwwVYD1+a2ZY33e1BlM3AgggAACCCAQtAD7kYIWpT0EEEAAAQQQQAABBBBAAAEEtgpQVIiZgAACCCAQucDnG7fIyx+vlpcXr5ZXPl6TLSak+2v0zr1k3K695au79pGvDekjPbp21j1k4kMAAQQQQAABBBBAAAEEQhFgE08orDQasUBza6M0NNVLc0tjUc+qmFBdTUqqq2ojjkiP7ji8oEceiAIBBBBAAAHbBTgUbfsMYPwIxCvQqVOnsgFkMpl4g6N3BBBAAAEESgjw+ZlpYZoA6/OlM8b6vGkzmXgRQAABBBBAIGgB9iMFLUp7CCCAAAIIIIAAAggggAACCGwVoKgQMwEBBBBAIDKB2YtXy4sLP5UXF30qby3Vv5BQORhVYOjA3XaU/7vbjrL/4D6R+dERAggggAACCCCAAAIIIKCDAJt4dMgCMXgV4LBCZTl1cEG9GprSRRfX1aRlYk2qcgNcgQACCCCAAAII+BTgULRPQG5HAAFfAvX19ZJOF//vIdWg+lkqxf8m8oXLzQgggAACoQjw+TkUVhoNQYD1+cqorM9XNuIKBBBAAAEEEEiuAPuRkptbRoYAAggggAACCCCAAAIIIBCvAEWF4vWndwQQQCDxAivXbpL/nd8qM+avkpkfrZINW75IzJi7du4kE3avkgnD+srXh1XJTj26JmZsDAQBBBBAAAEEEEAAAQQQKCfAJh7mhqkCfMuvu8zh5c6LqxFAAAEEEEAgOAEORQdnSUsIIOBNoFOnTu1uzGQy3hrjLgQQQAABBEIW4PNzyMA0H4gA683uGPFy58XVCCCAAAIIIJAMAfYjJSOPjAIBBBBAAAEEEEAAAQQQQEA/AYoK6ZcTIkIAAQQSIdDUsk6eb2qRhuZWeWvpZ4kYU0eD+PIuvWRidZXU1fST4f26J368DBABBBBAAAEEEEAAAQTsFWATj725N3Xk5TbfV/erlcljZ5g6rMji5vBCZNR0hAACCCCAAAL/EeBQNFMBAQTiFqivr5d0Op0PQ/3fqVQq7rDoHwEEEEAAgZICfH5mYugswPq8v+ywPu/Pj7sRQAABBBBAwCwB9iOZlS+iRQABBBBAAAEEEEAAAQQQMEeAokLm5IpIEUAAASMEPli5Tp7+YKU888FKUYWFbHupgkLf2KO/HL5HPxnRv4dtw2e8CCCAAAIIIIAAAgggYIEAm3gsSHJChtjc2igNTfXS3NJYNCJVTKiuJiXVVbUJGWk0w+DwQjTO9IIAAggggAACIhyKZhYggIAOAp06dcqHkclkdAiJGBBAAAEEECgpwOdnJoaOAqzPB5sV1ueD9aQ1BBBAAAEEENBTgP1IeuaFqBBAAAEEEEAAAQQQQAABBMwXoKiQ+TlkBAgggIAWAgs/XS9Pvb9Snpr3iajCQra/VEGhI0f0lyNH9pehO+5gOwfjRwABBBBAAAEEEEAAgQQJsIknQclM6FA4rBBeYpVtc8tMaWhKF3VSV5OWiTWp8DqmZQQQQAABBBCwSoBD0Valm8EioK1AfX29pNPp7H9SKf73jraJIjAEEEAAAYpyMge0EmB9Prx0sD4fni0tI4AAAggggIAeAuxH0iMPRIEAAggggAACCCCAAAIIIJA8AYoKJS+njAgBBBCIVGDtpi/k0X+tkMf+tULeXPpZpH2b0NlXBvWSY/ccIMfttZP07NrZhJCJEQEEEEAgCIH/3fYNxkE0RxuGCBzCt1UbkinCRAABnwJs4vEJyO2hCvBtvaHy5hvHORpnekHAVoF5Z1fbOnSrxz3i181Wj5/BFwtQVIgZgYBGAqx1a5SMCENhrTtCbLpCAAEE/Avw+dm/IS0EI8C6cTCOlVrBuZIQ7yOAQBgCrNuHoap/m6zb65+jpEXIfqSkZZTxIJBQAZ6bJDSxFYbFcxM7886oEUAAAQQQSJAARYUSlEyGggACCEQt8ML8Vpk2Z4U892FL1F0b199hw/vJCaMGyIRhVcbFTsAIIIAAAh4EeGDgAS0Bt/DAIAFJZAgIIOBEgE08TpS4JmqBcpvoq/vVyuSxM6IOx5r+OLxgTaoZKAKRCnA4IVJubTrjcII2qdAiEA5Fa5EGgkBgqwBr3XbOBNa67cw7o0YAAWMF+PxsbOoSEzjr8/GkkvX5eNzpFQFbBVi3tzPzrNvbmfc4R81+pDj16RsBBBwL8NzEMVWiLuS5SaLSyWAQQAABBBCwUYCiQjZmnTEjgAACPgUWr94gf3p3ufzpveWycu0mn63Zc3u/7l3l5H0Gykn7DJTBfba3Z+CMFAEEELBRgAcGNmZdhAcGduadUSNgoQCbeCxMusZDbm5tlIamemluaSyKUhUTqqtJSXVVrcbRJyc0Di8kJ5eMBAEdBDicoEMWoo+BwwnRm+vcI4eidc4OsVknwFq3dSnPDpi1bjvzzqgRQMBYAT4/G5s64wNnfV6PFLI+r0ceiAKBpAuwbp/0DJceH+v2duY9zlGzHylOffpGAAHHAjw3cUyVqAt5bpKodDIYBBBAAAEEbBSgqJCNWWfMCCCAgA+Bv33YIg+9s0xmLfzURyt23/p/d9tRTtl3ZzlseD+7IRg9AgggkGQBHhgkObvlx8YDAzvzzqgRsFCATTwWJl3DIXNYQb+kqJw0t8yUhqZ0UXB1NWmZWJPSL2AiQgABbQU4nKBtakINjMMJofIa1ziHoo1LGQEnWYC17iRnl7VuO7PLqBFAIIECfH5OYFI1HxLr8/oliPV5/XJCRAgkTYB1+6Rl1Nl4WLd35sRVwQmwHyk4S1pCAIEQBXhuEiKuxk1zRkDj5BAaAggggAACCDgRoKiQEyWuQQABBBCQVes3y4NvLZXfvbVMWtZtQsSnQP8eXeXb++0sp+23i1R17+KzNW5HAAEEENBOgAcG2qUkkoB4YBAJM50ggED8AmziiT8HtkfAt+7qPQPIj975IToETBDgcIIJWQo+Rg4nBG9qcoscijY5e8SeOAHWuhOXUkcDYq3bERMXIYAAAroI8PlZl0zYEQfrv3rnmfzonR+iQ8BkAdbtTc6e99hZt/dux53eBNiP5M2NuxBAIGIBnptEDK5Jdzw30SQRhIEAAggggAACXgUoKuRVjvsQQAABiwTeWLJGfvvWMnnq/U8sGnU0Qz1q5E7yndG7yFcG9YqmQ3pBAAEEEIhGgAcG0Tjr1gsPDHTLCPEggEBIAmziCQmWZisKlNsMX92vViaPnVHxfi6IVoDDC9F60xsCSRLgcEKSsul8LBxOcG5lw5UcirYhy4zRGAHWuo1JVaCBstYdKCeNIYAAAmEL8Pk5bGHaVwKsz5s1D1ifNytfRIuACQKs25uQpeBjZN0+eFNa7FiA/UjMEAQQMEKA5yZGpCnwIHluEjgpDSKAAAIIIIBAtAIUFYrWm94QQAAB4wT+Om+l3P/GEnlr6WfGxW5KwKN37iVnjhkkR47ob0rIxIkAAgggUEmABwaVhJL5Pg8MkplXRoUAAu0E2MTDpIhaoLm1URqa6qW5pbGoa1VMqK4mJdVVtVGHRH8uBDi84AKLSxFAICvA4QQ7JwKHE+zMe7lRcyia+YCARgKsdWuUjAhDYa07Qmy6QgABBPwL8PnZvyEtlBdgfd7s2cH6vNn5I3oEdBJg3V6nbEQXC+v20VnT01YB9iMxExBAwAgBnpsYkabAg+S5SeCkNIgAAggggAAC0QpQVChab3pDAAEEjBK47/Ulcu/rS2T55xuNitvEYHfu1U3O+sogOWvMIBPDJ2YEEEAAgbYCPDCwc07wwMDOvDNqBCwUYBOPhUmPacgcVogJPqRuSx1eqKtJy8SaVEg90iwCCJgqwOEEUzPnL24OJ/jzS9rdHIpOWkYZj9ECrHUbnT7PwbPW7ZmOGxFAAIE4BPj8HId68vtkfT5ZOWZ9Pln5ZDQIxCHAun0c6vH3ybp9/DmwLQL2I9mWccaLgKECPDcxNHE+w+a5iU9AbkcAAQQQQACBuAUoKhR3BugfAQQQ0FDg0/Wb5e7/92+55//9WzIZDQNMcEjfG/slmTz2S9Jn+y4JHiVDQwABBCwQ4IGBBUkuMUQeGNiZd0aNgIUCbOKxMOkxDJlvz40BPYIuyWsEyHSBQAIEOJyQgCR6GAKHEzygJfgWDkUnOLkMzTwB1rrNy1kQEbPWHYQibSCAAAKRCfD5OTJqazpiHTeZqSavycwro0IgKgHW7aOS1qsf1u31yocN0bAfyYYsM0YEEiDAc5MEJNHDEHhu4gGNWxBAAAEEEEBAJwGKCumUDWJBAAEENBD4ePUGueu1f8sf31mmQTR2hnDKvjuLKi40uM/2dgIwagQQQCAJAjwwSEIW3Y+BBwbuzbgDAQSMFGATj5FpMyroUhvbq/vVyuSxM4wah9Ngm1sapaG5Pnu5+r/VWKurxktdTdppE8Zdx7ciG5cyAkYgUgEOJ0TKrU1nHE7QJhVaBMKhaC3SQBAIbBVgrdvOmcBat515Z9QIIGCsAJ+fjU2dloGzPs/6vJYTk6AQQCB2AdbtY09BLAGwbh8Lu9Wdsh/J6vQzeATMEeC5iTm5CjJSnpsEqUlbCCCAAAIIIBCDAEWFYkCnSwQQQEBXgebWdXLHKx/LE3M/0TVEa+I6ds+d5Adf3VWqq7pbM2YGigACCCRKgAcGiUqn48HwwMAxFRcigIDZAmziMTt/JkRvU8GZhqa0qPGWeqniQnXVqWyRoaS9bMpx0nLHeBCIQoDDCVEo69cHhxP0y0mcEXEoOk59+kagjQBr3XZOCda67cw7o0YAAWMF+PxsbOq0DNymtVvW57dNQfUlBxNrUlrOSYJCAAE9BFi31yMPUUfBun3U4vTHfiTmAAIIGCHAcxMj0hR4kDw3CZyUBhFAAAEEEEAgWgGKCkXrTW8IIICAtgLzVq6V21/+WJ75YKW2MdoW2OF79Jfz9t9VRvTvYdvQGS8CCCBgvgAPDMzPoZcR8MDAixr3IICAgQJs4jEwaYaFXOrQghpC0ja1d3RgIZcyVVBo8tgZhmWwfLjNrY3S0FQvzS2N7S5KWn4TkzQGgkAMAhxOiAFdgy45nKBBEjQKgUPRGiWDUBBgrdvOOcBat515Z9QIIGCsAJ+fjU2dloGXW5/PFsGvSUl1VTKK4LM+Xzz9WJ/X8teRoBDQSoB1e63SEVkwrNtHRk1H/xFgPxJTAQEEjBDguYkRaQo8SJ6bBE5KgwgggAACCCAQrQBFhaL1pjcEEEBAS4EPWtbJL15aJM9+2KJlfDYH9Y09+sn5BwyR4f2628zA2BFAAAHzBGx4YFCdFuk7fmtu1MbB+fVb/+/mtHn5CipiHhgEJUk7CCCguQCbeDRPUALCK3doITe0JGxuV0V17n5tgqNsqW8HVmM2/WVDXk3PEfEjoIsAhxN0yUS0cXA4IVpv3XvjULTuGSI+qwRY67Yq3fnBstZtZ94ZNQIIGCvA52djU6dl4Das47I+337qJeG5i5a/UASFQIIEWLdPUDJdDIV1exdYXBqIAPuRAmGkEQQQCFuA5yZhC+vZPs9N9MwLUSGAAAIIIICAYwGKCjmm4kIEEEAgmQILVq2XW19aJE/NW5nMASZgVEeO6C8XfG2I7N53hwSMhiEggAAClggk+YGBKiA0ZkbHiVQFhmwsLsQDA0t+wRkmAgiwiYc5ELZA4aGFXDEd9a3BhS/TN7g7+Rbk3HjVN0BPHlvh81fYSfHRfnNrozQ01Ys6qFH4UuOqqaqVXG5Nz6kPIm5FAIE2Al4PJwy5+KHEWC666ZTEjMXpQDic4FTKjus4FG1HnhmlIQKsdbPWbchUJUwEEEDAZgE+P9uc/eDHzvp8sSnr88HPMVpEAAEzBVi3F2Hd3sy5S9RmCbAfyax8ES0C1grw3ITnJtZOfgaOAAIIIIAAAiYLUFTI5OwROwIIIOBTYMXnm+Smfy6Uv8xZ4bMlvW7v1GlrPJmMXnH5ieaEUQPk4gN3kwE9uvpphnsRQAABBKISSOoDg+q0yLCUM0UbCwtRVMjZ3OAqBBAwXoBNPManUPsBtD20MLEmJeUK05haiMZNUSGVsCmHmrnIUe5brSePmyHVVbVSKtfaT1ACRACB0AW8Hk5IUlEarwahJyfEDpKUvxCZrGmaQ9HWpJqBmiDAWrcIa90mzFRiRAABBKwW4POz1ekPfPCsz7cnZX0+8GlGgwggYKCA1zXrJK37ejUwMN35kJOUP5PzYFPs7EeyKduMFQGDBXhuwnMTg6cvoSOAAAIIIICAvQIUFbI394wcAQQsF9iw+Qv52YsL5TdvLjVWYsyg3rL3wJ4ysn93qenXXXbu2U0G9uomXbfrJOs2fSGfbtgsi1ZvkAWr1sv7n6yVt5d9Jm8v+1y+MLTa0Blf3kUuOXA32aHLdsbmjMARQAABawSS+MCgqlZkzAx3KXx9gkhro7t7TL6aokImZ4/YEUDAhQCbeFxgcakngY4KzZQqUmNiYaG7X5sgzS3OPyeZeGih1BjbfqszRYU8/YpwEwKJF/C6MT9Jm9u9Gpg8OZKUP5PzoEvsHIrWJRPEgYCIsNa9dRqw1s2vAwIIIICAxgJ8ftY4OQaGxvp8+6SxPm/gRCZkBBAIXMDrmnWS1n29GgSejAgbTFL+ImSjKx8C7EfygcetCCAQnQDPTXhuEt1soycEEEAAAQQQQCAwAYoKBUZJQwgggIBZAre/vFimzl5sVtAiMnTHHWRiTZXU7t5XDhi8o2zXyd0Q/rHwU/n7glUyY/4qaW5d5+5mDa4+/4DBct7+gzWIhBAQQAABBDoUSOIDA1VQSBUWcvNSBYXUYQtbXhQVsiXTjBMB6wXYxGP9FAgdoFKhmebWRmloqm9XlMek4kJuiwpNrEmJGp8JL5Wfu19t/xlw8rgZUt3m82SlXJswXmJEAIHgBbxuzC/c3L7u/ZeDDyzkFruP3D/fg1eDkEMMtXkOJ4TKa1zjHIo2LmUEnGQB1rq3Zpe17iTPcsaGAAIIGC/A52fjU6jVACqt2bI+r1W62gXD+rze+SE6BEwW8Lpmzbq9yVkXYd3e7PyZGD37kUzMGjEjYKEAz014bmLhtGfICCCAAAIIIGC+AEWFzM8hI0AAAQRcCzz87nK5YdYC+XzjFtf3xnXDkD7by9F77iRHjugvI/r38B3G3E/WyrMfrJS/zlspH61a77u9qBro1a2zXHHQUDl5n4FRdUk/CCCAAAJeBJL4wMBrwZwkWpSbE16NvMwx7kEAAQRiFGATT4z4lnRd6dBCjqHwutzPdC8s1NzSKA3N7QsiOUmtCYWFShVLqu5XK5PHzig5RKe5duLDNQggkByBIA4neG0jTsXCzfkmxu/XjsMJfgWTdT+HopOVT0ZjuEAS13e9ruMm0YK1bsN/Qd2Hv3r1annyySflww8/lAULFsiKFSukqqpKhgwZIsOGDZMjjzxSBg0a5L5hS+5Yt26djBgxIj/aSZMmyb333mvJ6BmmzgJ8ftY5O+bF5nTNlvV5/XLL+rx+OSEiBJIk4HXN2vR1b9Pj9zsHWbf3K8j9bgXYj+RWjOsRQCAWgSQ+K+C5SeWp5NWocstcgQACCCCAAAIIRCJAUaFImOkEAQQQ0Edg5oJVct3MBdLcuk6foCpEcvTIneTUfQfKuF37BB7zy4tXy0PvLpOn3l8ZeNthNTisagf5ycG7y/jd+4bVBe0igAACCPgVSNoDg6pakTGlD4JXpHp9wtZvcbbhxQMDG7LMGBFAQETYxMM0CFvA6aEFFYcp34rsp5hQW28diwu5+fbjwvG4yXXY8472EUBAHwEOJ4h4NdAni+4j4XCCe7Mk38Gh6CRnl7EZJ8Ba97aUsdZt3PQl4G0Cra2tcvXVV8sdd9xRkeXEE0+UG264QWpqaipem4QL1Frn4sWL80PZd999pXv37iWHtnbtWunZs2f+vaOOOipbpIkXAnEL8Pk57gwkq383a7asz+uRe9bn9cgDUSCQdAGva9amF+UxPX6/85J1e7+C3O9WgP1IbsW4HgEEYhHguQnPTWKZeHSKAAIIIIAAAgj4E6CokD8/7kYAAQSMElCFhK6duUD+vmCVEXFX7dBFTv/yLnL66F2k7w5dQov5s41b5IE3lsj9byyV1Rs2h9ZPkA0fPLSv/GT8UKmuKr2ZLci+aAsBBBBAwINA0h4YVKdFhqU8QIjI/HqR5rS3e027i6JCpmWMeBFAwKMAm3g8wnGbYwE3hxZyjer8rcgNTWlR8bV9VferFVVsqKOXuqa6anzJ+3UpLuT2248Lx+sl144nEhcigICxAhxOoKiQsZOXwAMT4FB0YJQ0hIB/Ada6txmy1u1/PtFCLAJz586VI444Qpqbmx3337t3b3n88cfl61//uuN7TL3wlltukYsuuigf/rx582SPPfYoORyKCpma5eTHzefn5Oc4yhF6WbNlfT7KDBX3xfp8fPb0jIBtAqzbs25v25xnvPEIsB8pHnd6RQABlwI8N+G5icspw+UIIIAAAggggIAOAhQV0iELxIAAAghEJFDf+JE8+NbSiHrz183Anl3l3K8Olm/tt7O/hlzc/cd3lsmvXvlYlny20cVd8V162uhdJF27e3wB0DMCCCCAQHmBpD0wqKoVGTPDW8Y5aOHNjbsQQAABjQXYxKNxchISmpdDC2ro5b4VefK4GVKtPs9E/FIFgxqa69sVDlKFguqqU0XvdVRgaPLYGdLU2ijNrTPbtaUKC9VU1Yq6P+pXqW8/zo6tJuXY22uuox4r/SGAQLQCHE7gcEK0M47edBTgULSOWSEmawVY696Weta6rf01MHngK1askJqaGlmzZk27YYwbN05GjRqVLTY0a9asksN88803ZfTo0SYTVIzdTVGhTZs2SXV1tWzcuHVPyfHHHy933nlnxT64AIGwBfj8HLawXe17XbNlfT7aecL6fLTe9IYAAt7XrEf8eltxU69r/3H6mx6/X7vC8ftti/sRcCLAfiQnSlyDAAKxC/DchOcmsU9CAkAAAQQQQAABBNwLUFTIvRl3IIAAAkYK/OHtZZJqnC+ZjP7h79Krm/xw/8Fy0j4DIw/24XeXy9TZi2TF55si79tLh9dMGBZp4SUvMXIPAgggYKUADwy2pf31CSKtjXZMg0MM+KBlRyYYJQIIhCzAJp6QgWlevB5ayNG1/VbkKYdG+ze6UjEhVXinoSmdHWfupQoHqW8UVi/1fnXV+KL3c2Noe1/uflVcqK4mHensaXtoQfWv4nDz8ptrN31xLQIImCPg9WCB6Zv7TY/f7wzjcIJfwWTdz6HoZOWT0RguwFo3a92GT2Hbwz/ppJPkkUceKWK4/vrr5ZJLLpGuXbvmf/7FF19krzvllFOKrt1vv/3k1VdflW7duiWW0k1RocQiMDDjBfj8bHwKtRqA3zVb1uejSSfr89E40wsCCGwTYN3ee2Elk+cR6/YmZ8/M2NmPZGbeiBoB6wR4bsJzE+smPQNGAAEEEEAAgSQIUFQoCVlkDAgggEAFgdeXrJEr/3e+zFu51girKw8eKmd+ZVBssd7/xhL56ayFssWACkwjd+oh1319mIwZ1Ds2LzpGAAEEECghkLQHBmqIY2aIVNW6S7cqJqSKCtnyoqiQLZlmnAhYL8AmHuunQOgAfg8tqABz34pcU1XrutCNnwGqwkCqqFDblyoapIoF5V6XPd8p/3+rQjwqzsKiQrkiQ7m21L3qZ7mXLsWFVK6aWhulriYl1W4/K4r4LiDlJ1fciwAC+gpwOIHDCfrOTiKLSoBD0VFJ0w8CDgRY696KxFq3g8nCJboJqL+nY8eOLQpr5syZcvDBB5cNtampSb7yla/ImjVr8tf8/ve/l29961uRDW/t2rWyatUq2XnnnaVz586u+21paZH169dL//79Zfvtt694fxRFhdSYWltbpaqqSnr06FExpo4u2Lx5syxbtizr06VLF1dtqeJRy5cvl06dOslOO+3kyddVh1wcmQCfnyOjtqIj1ue3rsUXrvWzPm/F1GeQCCBQQYB1e9bt+SVBIAoB9iNFoUwfCCDgW4DnJlsJeW7ieyrRAAIIIIAAAgggEKUARYWi1KYvBBBAIAaBTVsycuULzTJtzooYenff5Rlf3kWuGr+7bDta576NIO647u8L5IE3lgTRVOhtHL/XALn+kGHSrfN2ofdFBwgggAACDgWS+MBAHRJXhYXcvObXizSn3dxh9rUUFTI7f0SPAAKOBdjE45iKCz0KBHFowWPXnm9zU+Sn8NrcYQRVPKhtUaHCn6nA2hYmUj9z06/nwYV4o4m5DpGDphFA4D8CHE7gcAK/DAhwKJo5gIBGAqx1b00Ga90aTUpCcSrw4x//WG688cb85Weffbbcc889FW//5S9/Keeee27+umOOOUYef/zx/L8XLFggF1xwQf7fZ511lhxxxBEl21XFiNatW5d978ADD5SLLrqo5HWvvfaa/PznP5c333xT5s2bl79m3LhxMmnSJLniiivKFuNRRXamTZsmU6dOldmzZxe1P3DgQDnjjDNEjX348OH59371q1/J9OnTs/9+//33Zc6cOfn36urqpFevXkXt3HHHHfKlL30p+7MTTzxRVJ/qNX78ePnRj35UckzvvPOO3HnnnaKKMhUWaerdu7d8+9vflnPOOUf23Xffkvded9118vrrr2ffO+mkk+S4446TXMxPP/10/p4xY8bId7/7XSlt2gUAACAASURBVJk8ebJst13p/SKrV6+Wu+66S+67774iW9XIqFGjROXvzDPPlL59+1acG1ygrwCfn/XNjYmRmbhm62adnPX5bbPSxFyb+DtFzAgkRYB1e9btkzKXGYfeAuxH0js/RIcAAv8R4LnJVgiem/ArgQACCCCAAAIIGCVAUSGj0kWwCCCAgHuBP7y9TK6eMd/9jTHcsf/gPjJlYo0M2bHyt8WFHd5Hq9bL5dOb5dWPV4fdVSDtXzNhmHxrv50DaYtGEEAAAQQCEEjiAwPFUp0WGZZyB/T6hK3fRmDDi6JCNmSZMSKAgIiwiYdpELaASRvZVeGfhuZ6Uf9d+FLFguqqU6L+u/DV9nBDrlBQqaJC6r6Ovg05166bAxNh585t+ybl2u3YuB4BBLwLmHg4oWrimdI6/X7vgxaREb9uzt/v1cBXADHfXDj+mEOhew0EOBStQRIIAYGcAGvd2+YCa938XhgmUFNTI83N2z5jLly4UIYMGVJxFOvXr5ehQ4fK8uXL89d+9tln0rNnz+y/33333aJiOKrgzg9+8IOS7XbqtO3rpE4++WR56KGHiq7buHGjXH/99XLNNdd0GFd1dbU8/PDDoooMFb4+//zzbNGhF198seK4VOGh448/Pnvd0UcfLU899VTFe3IXFI6/cEynnXaaPPjgg+3aaWxslAkTJlRs/4UXXih53ZFHHim54kFXXXWVvPfee/LYY4+Vba+2tlaeffZZ2WGHHYquUQWTDj744KJclmpE+T755JOy9957V4yZC/QU4POznnkxNSqT1mxZn/c3y0zKtb+RcjcCCAQh4HXNOs51b9bt/WeedXv/hrTgToD9SO68uBoBBGIS4LnJNniem8Q0CekWAQQQQAABBBBwL0BRIfdm3IEAAggYI/D+J2vlsulN8s6yz42IeUpdjZwwaoA2sT76rxVyeUOzbMlktImpXCD77dxLflpXLSP799A+VgJEAAEErBBI6gMDlTwKC5WfwhQVsuLXm0EigABFhZgD4QvEvZFdHURoam2U5taZUl01PjvgmqraogJBbg8r5NQue37bYbqJNSmpq0ln3ypXVEi9V+6etplwU1woF3/2491/xpiLJfwMb+sh7lxHOVb6QgAB5wKmHU4YcvFD0n3k/rLu/Zdl0U2nOB9omyvjPFzhOegAb+RwQoCYCWiKQ9EJSCJDSI4Aa93FubRlgzxr3cb/Dm/atEm6deuWH8fgwYNl0aJFjsd1wgkniCrCk3vNnTtXRo4cmf1nkEWFbrjhBrnyyisdxdW7d29RhZH69u2bv/68884TVdTI6UvFrgrnuCkqNHDgQFm2bFm+i0pFhZwWFMo1WKqwUGFRIadjU5ZXXHFF/vJMJiN77rmnzJs3z1ETqrDQO++8Iz16sOfEEZhmF/H5WbOEGB5O3Gu2rM9HN4HiznV0I6UnBBAIQoB1exGvBkH4x9UG6/ZxydvbL0WF7M09I0fAKAGemxSni+cmRk1fgkUAAQQQQAABewUoKmRv7hk5AghYIHDjrAVy7+tLjBjppOH95JeHj5CCL6rTIu4fPD1PnvuwRYtYKgXx3TGD5IqDhla6jPcRQAABBKIQSPIDg5yfKi7Ud7xIVe3Wn7Q2bv3v+fVb/3vMjGJpGx4acNAiit8u+kAAAQ0E2MSjQRISHkKcG9nLFeZR5LkiQG6K9xSmqu19Uw7dVsS4o6JChe+p9iaPnVFU4KjtdKgU392vTcgWMSr1Kix0FMU0izPXUYyPPhBAwJuA1435cRTlyRUUyo3UT2GhOOL3lqFw7uJwQjiuprbKoWhTM0fciRRgrZu17kRO7OQPSq3f7brrrvmBTpo0SZ577jnHA7/88stlypQp+ev//ve/y0EHHZT9d1BFhT766CMZNmxYUUx33323nHjiibLjjjvK4sWL5dprr5Vf//rX+WsuvPBCufnmm7P/bls4Sf3skUcekQMPPFD69+8v7733nvzxj3/MX6/enzp1qvzoRz+SWbNmydKlS7PtPPnkk/L73/8+38ett95aZFdVVSUTJ07Mv99RUaGmpiYZPnx40ZjUeFTxo913313mz58vt99+u/z5z38uuuaDDz4ouq9UUaH99ttPVF72339/+eSTT7LjUuMtfLW2tuaLLr3yyivZa3OvUaNGyW233Sbjxo0TVXDorbfeElWI6G9/+1v2ElW06dlnn8368TJPgM/P5uVM54jjXLNlfX7bFxFEMUfizHUU46MPBBAIVoB1e4oKBTujaA2B0gLsR2JmIICAEQI8N+G5iRETlSARQAABBBBAAIFiAYoKMSMQQACBhArMWrBKLnq+SVau3WTECG89bLgcPXIn7WJ9Yu4ncuHfPtQurlIB9eveVW6eVCMHD932zXxGBE6QCCCAQBIFdH5g4LTwjSoO1Jz2nh1VbMi2wkJObb2rcicCCCCghQCbeLRIQ6KDiGsje0cHFjoCd1KIp23bbe/pqKiQ6ruwEFB1v9psYaFKL6/jqVS0qFK/bt6PK9duYuRaBBCIXsCUwwltCwrlpLwWFqKoUHP0k40etRXgULS2qSEwGwVY695aWJ+1bhtnv9Fjfvvtt2X06NH5MZxzzjnyq1/9yvGY7rrrLlH35F6PPvqoHHfccdl/BlVUSBX3UUVucq+HH35YTjrppHYxHn744dliN7nXxo0bpWvXrtmiQIMGDcr//Nxzz80W7Gn7SqfTsmHDhux4dtttt3bv33LLLXLRRRflfz5v3jzZY489ylp1VFTo6quvzhZCyr0uvfTSouJMuZ9ffPHFRcWOfvKTn8g111yTv69tUaERI0bIP/7xDxkwYEBRXBMmTJDGxm2Fo1UhIVU0SL2mTZsmJ5xwQv56Vcio8N/qjbVr18rkyZPlgAMOkNNPPz1bWIiXmQJ8fjYzb7pGHdeardf1bNbnvc+kuHLtPWLuRACBOAVYt6eoUJzzj77tEWA/kj25ZqQIGC3AcxOemxg9gQkeAQQQQAABBGwVoKiQrZln3AggkHiBi/72oTw+9xMjxvl/BvWW339zL+nWeTvt4l276Qs57dE58ubSz7SLrVRAx+21k9x0aPE33xkROEEigAACSRPggcHWjDo9bKGuU/9Rr9bGrf8x8UVRIROzRswIIOBBgE08HtC4xZVAHBvZvRxYUMV96qpTov670uuy5zvlLyl1yKFSUaHC91VDTg5KqOu8jEvdN+XQTKUhBfJ+HLkOJHAaQQCBUAV0OpxQNfFM6XfUD6Xlqdukdfr9+XGXKyiUu8BLYSGKClFUKNRfLMMa51C0YQkj3GQLsNa9Nb+sdSd7nidwdG+88YaMGTMmPzJVNOemm25yPNIHH3xQvvOd7+Svf+SRR+S///u/s/8OqqhQYUGc6upqaWpqKhnfU089JUcffXT+vQ8++ECGDx+eLYjTs2fP/M9VMZ3HH39cvvSlLzkep7owyKJCI0eOFFWUSL1UgR61jtqrV6928axZs0Z23XVXUf+tXqNGjZL33nsvf13bokKFRZ0KG1OFgk488cT8jx566CE5+eSTs/+ePn261NXV5d/73ve+l50DhWauoLhYawE+P2udHuOCi2PN1ss6Nuvz/qdWHLn2HzUtIIBAXAKs21NUKK65R792CbAfya58M1oEjBXgucnW1PHcxNgpTOAIIIAAAgggYKcARYXszDujRgCBhAs888FKOf/ZD2VLJpoDYH45f/DVXeXCrw3x20xo99/y0iL55Ssfh9Z+kA132a6TTD1suHxjj/5BNktbCCCAAAJuBXhgsE3MyUOD6rTIsNTWe+bXizSn3YrrcT1FhfTIA1EggEDoAmziCZ3Y+g7i2Mju9tDC5LEzHBUTUsls23apgj2VigqVasdPDJUmmZu2K7XV0ftx5NpPvNyLAALRCOhyOEEVFBpw0lX5Qa/403XZwkJtf15OxW1hIYoKUVQomt8wM3rhULQZeSJKSwRY62at25KpnrRhzp07V/baa6/8sE477TRRhYKcvm699Va58MIL85c/++yzcthhh2X/HVRRoT59+uSL6gwePFiuvfbakuEtWLBA0ultz42eeeYZ+cY3vpG9trCIT+7mgw46SPbcc0+pqanJFh/6r//6Lxk0aFDZoQdZVKhTp21FpSdNmiTPPfdc2X4PPfRQaWhoyL+fKdjf07ao0EcffSRDhw5t19arr74qX/3qV/M/nzp1qvzoRz/K/nvJkiUlCywpuz322CNro/yUT6nCR07nCtfpIcDnZz3ykJQo4lizZX2+ePawPp+U3ybGgUCyBFi3p6hQsmY0o9FVgP1IumaGuBBAoEiA5ybbODgjwC8HAggggAACCCBgjABFhYxJFYEigAACzgRUGaFzn54nz33Y4uwGDa66/9g9ZfzQvhpEUjqEWQs/lTMe+5e28bUN7LDh/eT2w0fIdtv2qxkTO4EigAACiRHQ+YFBW+RSC/rqmiCL+1R6aEBRocRMfQaCAAJ2CLCJx448xznKOA4tXPa8u/8RXaowUCmzwmJB6v2JNSmpq2lfQNFJUSF1/92vTRB1rXqpb2JWhwucvNrGUekeN21Xaquj9+PItZ94uRcBBKIR0OFwQrnCQapQUPeR+zuGcFNYiKJCFBVyPLEsuJBD0RYkmSGaI8Bad3GuWOs2Z+5aHmlLS4v077/ti4gOOOAAeemll0qqbN68WR577DE54YQTJFcURxUUUoWFcq958+ZlC9GoVxBFhT777DPp3bu3pyz99re/ldNPPz1779NPPy2qAE+llyo0dM8992SLDbV9BVVUaM2aNaIKJeVe5557rtx+++1lQ/v+978vd955Z/59ZdKzZ8/svwuLCimn1atXl2zn/fffLxqTytn555+fv/byyy+XKVOmVOKRM844Q5RDVVVVxWu5QE8BPj/rmRdTo4pjzZb1+eLZwvq8qb89xI1AsgVYt6eoULJnOKPTRYD9SLpkgjgQQKBDAZ6bFPPw3IRfGAQQQAABBBBAwAgBigoZkSaCRAABBJwLPPPBSjnvmQ+c3xDzlbv06iZPnrKv9O/RNeZIyne/av1mOfqhd+Tj1Ru0jbFtYLcfvoccvse2TYLGBE6gCCCAQFIETHlgUK6gkMpDkEWFVHsdPTSgqFBSZj7jQAABSwTYxGNJomMcZpIOLRQWASpXUEhROy0q1LY4kNNvLHZbVKijWIOcGnHkOsj4aQsBBMIRiPtwQrmCQl5H67SwEEWFKCrkdY4l8T4ORScxq4zJWAHWutunjrVuY6ezTYFnMhnZbrvt8kMuV5hm/fr1cuqpp2aLCl111VVy7bXXZu8pLGqj/r1hwwbp1q1b9r0gigqtWrXKcwGbwqJCKp6//vWvctZZZ8ny5csrpnju3LkycuTIouuCKirUdkwXXHBBtlBPuZd6f+rUqfm3VeGgXKGlQv+BAwfKsmXLSjZTqaiQKhil+rjkkksq2owYMULeeust2WGHHSpeywX6CfD5Wb+cmBxRHGu2YRUVYn2+45kYR65N/t0gdgRsF2DdnqJCtv8OMP5oBNiPFI0zvSCAgE8Bnpu0B+S5ic9Jxe0IIIAAAggggED4AhQVCt+YHhBAAIFIBX747Afy9LyVkfbpp7Ov7tpHHjphlJ8mIrn3W9PmyOzFpb/9LZIAXHZy5Ij+8otvbP2mQF4IIIAAAjEImPDAoNQCfmvj1uI/6hV0USHVZrmHBurnw1Lh9RvVFDgkE1VP9IMAAgjEKsAmnlj5reg8jo3shYcLnCA7KbrT0JQWNZbca8qh5T8rOC0qpNpy026u77b3VBqjk/FVasPJ+3Hk2klcXIMAAvEKxHk4IeiCQjlJJ4WFKCpEUaF4f/P06p1D0Xrlg2gsF2Ctu/QEYK3b8l8MM4Z/8MEHy6xZs/LBTp8+XQ455JCi4I8//vhsQaHc67bbbpNjjz1Wdtttt/zPqqurpampKf/vtkWFbr75ZrnwwgvboXz88ccyePDg/M9PPvlkeeihh7L//uKLL6Rz58759+rq6iSdTjuCHT58uKhCO4WvLVu2yNtvvy2zZ8+WDz74QD788EN54403ZPHixUXXHXHEEdkiRIWvoIoKqRi6dOmSb/q4446TRx99tOyYlPMTTzyRf1/dnysEFVRRofz/Hlm3Tl5++WVRn7GUzbx58+TVV1+VNWvWtLNQxY54mSfA52fzcqZzxHGs2bI+XzwjWJ/X+TeE2BCwV4B1e4oK2Tv7GXmUAuxHilKbvhBAwLMAz01K0/HcxPOU4kYEEEAAAQQQQCAKAYoKRaFMHwgggEBEAo0frZLv/fV92bTFnAPtx+81QH5+aE1EQt67ubShSabNWeG9gYjv7NZ5O7nryBEyfve+EfdMdwgggAACWQHdHxjEuXAfRzGjqKYlRYWikqYfBBCIWYBNPDEnwILu4zi0UFjUxymx2tivXnU1pQ+9FX67cqVDAG6KCqk+Cw9ZVPerlcljZ5QMW7Xb0Fwv6r/dvFR7qt2wX3HkOuwx0T4CCPgXiOtwQlgFhXIilQoLUVSIokL+f3uS0wKHopOTS0aSAAHWussnkbXuBEzwZA/hzjvvlO9///v5QY4ZMyZbSCZXuEa9oQoKqcJCha9Ro0bJnDlz8j86++yz5Z577sn/e8GCBbL77rvn/62K0KjCPG1fqnjPUUcdlf9xYVEh9cPRo0dnCwGpV21trcyYUXptw0+WVJGhY445RpYvX55tpnfv3vLpp59Kp06d8s22LSqkiibtvffeZbstvPe0006TBx98MH/tkCFD8oWMVDEmVeCo0Dt3oSqqNHTo0Py1qvjSokWL8u0EXVSo1GA2bdokf/nLX+TUU0/Nv12pEJKfXHBvuAJ8fg7X17bW41izZX2+eJaxPm/bbx3jRcAMAdbtKSpkxkwlStMF2I9kegaJHwFLBHhuUj7RPDex5JeAYSKAAAIIIICAiQIUFTIxa8SMAAIIlBG4+oX58od3lhnlc9aYQfLjg4ZqH/ONsxbIva8v0T7OwgBP3Xdnufbrw4yKmWARQACBxAjo/MCgXEGh1kaR6rTIsK2H42V+vUizs2+FdZ23UjHkGgmzX9eBuryBokIuwbgcAQRMFWATj6mZMyfuOA4tKB2334acEy1VXKihKS1qHOrVUdGfXBtuiwq1PWTR9pCB12JCKp5KBZCCnElx5TrIMdAWAggELxDH4YRyBYVUIaAgX4tuOqVsc0Mufij/XkfXBRmPTm0VFlXSKS5iiUeAQ9HxuNMrAiUFWOvueGKw1s0vjsYCS5culUGDBhVF+MMf/lB+9rOfyfbbb5//+f333y9nnXVW2ZGoYjeq6E3utXnzZunatWv+36p4zrx586Rz5875n23ZskW++c1vyhNPPJH/WduiQqeccoo8/PDD+fffeecd2WeffdrFsWbNmmw76v4uXboUvd/a2iq/+MUvRPV37bXXlhzDOeecI3fddVf+PXVP377bvpzp3nvvFVU4Kff65S9/WVSMqW2jHRUV+p//+R/5zW9+k7/ld7/7nXz7299uF5cqRPSd73wn//MzzzxT7rvvvvy/gyoqpIoa/fSnP5XDDz88m49Sr5qaGmlu3lrgUxWeKvwcpvH0JrQ2Anx+ZkoEKRDXmi3r81uzyPp8kLOZthBAIEgB1u1FWLcPckbRFgKlBdiPxMxAAAEjBHhu0nGaeG5ixDQmSAQQQAABBBCwT4CiQvblnBEjgEBCBeZ+sla+++RcWbJmo1EjPG//wXL+Ads2oOka/NTZi+X2lxfrGl7JuHbp1U3uPXpP2WtAD6PiJlgEEEAgEQK6PjDoqKCQgo+qqJDqq9xDA4oKJeJXgEEggECyBdjEk+z86jC6uA4tOPk25FwBoVzBoEKv3HvqZ4XvO/lWYbdFhVQfpQoXdVRMSBU3Uu939HJSACnIORJXroMcA20hgEDwAlEfTihXUEiNzGsswaskv0WKCiU/x25GyKFoN1pci0DIAqx1VwZmrbuyEVfEJqAK5Jx77rlF/avCMVdddVW2gM+wYcNk2bJl2cI3jY3t1wzq6+vl6quvbhf/yJEjs4WEcq9LLrlEbrjhhmzRn5aWFrnyyiuLCvmo69oWFXrqqafk6KOPzreh4nrkkUdEFbnJvVRb6poXX3xRxo0bJ6oA0H777Zd9+89//nO2GJIqOqReakwXX3yx7Ljjjvn7VUGkvffeO3+NemPTpk1FxYleeOEFOeSQQ/L3jBo1Sm666SYZP3689OjRfq9FR0WF/v73v2fvK3w98MADctppp2WLLqniR6qgkCoiVPiaOXOmHHzwwfkfBVFU6PLLL5cpU6bk25w2bZocccQR+YJSmUxGnnnmGVF95V4nnnii/OlPf4ptvtKxdwE+P3u34872AnGt2bI+7+wLCoKcs3HlOsgx0BYCCEQn4HWtvHDd100brNtHl9uOemLdXo882BQF+5FsyjZjRcBgAZ6bVE4ez00qG3EFAggggAACCCAQsQBFhSIGpzsEEEAgLIG7X/u3/OzFhWE1H1q7FBUKjTbb8KUH7iaTx34p3E5oHQEEEECgvYCODwwqFRRSowizqNAhGWczhaJCzpy4CgEEEIhRgE08MeJb0nXcG9kLi/W0JS8sutPRdbn7nH6rsJeiQqqPy57vlA+xXNEg9fO66pQ0tTYWFTsqHJu6prpqvNTVpCOdZXHnOtLB0hkCCDgWcHOwoLBRL4cTOjqYoNr2GovjwXJhXoDDCUyGQgEORTMfENBIgLXu9slgrVujCUoolQRUEZtjjjlGnn766UqXlnz/pZdekgMOOKDde/fff3+2oE/b14gRI4qKDRW+37aokHrv8MMPl2effbaomYMOOkj69u0rCxYskLfffrvoveOOO04effTR7M/U54WxY8e2i6G6ulr22msveeutt2Tx4uIvjvrGN76RLaRT+GptbZWhQ4cWFR5q22hTU5OodtWro6JC6v3TTz9dfve73zm2OfXUU+UPf/hD0fVBFBX6xS9+Ieeff367OFTxpv79+8vs2bPbjfmWW26RCy64wNNc4aZ4Bfj8HK9/0nqPe82W9fnoZlTcuY5upPSEAAJBCHhdK2fdPgj9+Npg3T4+e1t7Zj+SrZln3AgYJsBzk/YJ47mJYZOYcBFAAAEEEEDARgGKCtmYdcaMAAKJE9i45Qv5n8fnyuzFq40b21ljBsmPDxqqfdw3zlog976+RPs42wZ4wOA+8ptj95KunbcdMjRuEASMQEIE1MOuhQu3FX8bPXq0dO/ePSGjYxjtBHR7YOCkoJAahLpO/Ue9Whu3/ieoFw8MgpKkHQQQQCB2ATbxxJ6CxAeg00Z2VexHve5+bULeffLYGaKK8OReHR1yCLuoUKUDFqqYUC7WwgJEubjU+ArHEvXk0inXUY+d/hBAoLxAVIcTKhUUUhEWxjLk4ocSk7ZFN52i3Vg4nKBdSmINiEPRsfLTOQLFAqx1t58RrHXzW2KYwObNm+WSSy6RqVOnuo584MCB8sorr2SL7hS+VLGir33ta/Lqq6+WbVMV4dl3333liSeeyF5TqqhQc3OzHHXUUTJnzpyKsan7f/Ob38j222+fv/bWW2+VCy+8sOK9uQvUZwxVVKft66677pJzzjmnbDtz586VkSNHZt+vVFRozZo18s1vflMaGhoqxvX1r39dHnvsMenTp0/RtUEUFVJ5VwWL/vznP1eMQ10wbtw4aWxslB49eji6nov0EuDzs175MD0andZsWZ8PdzbplOtwR0rrCCAQhADr9kEodtwG6/bhG9OD/gLsR9I/R0SIAAIiwnOT9tOA5yb8aiCAAAIIIIAAAtoLUFRI+xQRIAIIIFBZoPGjVXLWE3MrX6jhFcfvNUB+fmiNhpEVh3RpQ5NMm7NC+zhLBXj/MXvK+N37Ghk7QbcXUJsKy73UBsZ+/frJkCFDZNddd5Vu3bpBqJGA+mbHiy66KB/RvHnzZI899tAoQkIJVECnBwZOCwoFClCiMR4YhC1M+wgggEBkAmziiYza2o503MiuigrlDjCoIjyqsFDbV+E1he+pAj7qVVeTLptT1XaucFG59gtvVtc3NNfnYyp8T91fWExIvVdYfMhJ+1FNPh1zHdXY6QcBBMoLRHE4wUlBIRVhYSxJKnrj1TjMeZsk3zCdbGmbQ9G2ZJpxGiHAWnf7NLHWbcTUJcj2ArNmzRJVPOePf/xjWZ5JkybJ2rVrRV2be6niQC+99JKoAkOFL3Xd1VdfLTfffHO79lQ7v/71r+Wmm26S2267Lfv+GWecIQ888EC7azds2CA33nij1NfXl4xLFbs5+uij5YorrpDOnTu3u2b69OnZ+1944YWy4zrttNPk0ksvlX322afsNY8++qio57kvvvhiu2vcFBVSN6uiS3fccUd2/IsXL27X3uDBg7PPjc8991zp0qVLu/dPOOEEmTZtWvbnyn3ZsmUl4/7www+LnjerIkvnn39+/tovvvgimwc1LvVsutSrd+/e2ThUcaaddtqJXx1DBfj8bGjiNA1bxzVb1ufDmSw65jqckdIqAggEIeB1Tblw3bdSG6zbVweRqkDbYN0+UE4acyDAfiQHSFyCAALxC/DcpH0OeG4S/7wkAgQQQAABBBBAoIIARYWYIggggEACBG6ctUDufX2JkSP56q595KETRmkf+7emzZHZi1drH2epAL87ZpBccVDxNwcaORCClkwmI9ttt51jibq6Ornqqqvk4IMPdnwPF4YnQFGh8Gy1bDnKBwbVaZG+47cyqAJCrY0iq2aKNKe3/ntMmwPvr0/Yeo1Jr7ZjnP+fjeVqjDq9nD4U0SlmYkEAAQQ8CLCJxwMat7gS0HUj+2XPd8qPQxUKalskqPD9UgPuqLiQ06I/HRUTyvXZNrbCttU1pWJ3laAAL9Y11wEOkaYQQMCDQKWDBeWadHo4wenBBNUPRYU8JNDjLRxO8AiX0Ns4FJ3QxDIsMwVY6w42b6x1B+tJa54E1qxZIwsWLBC1xrdy5UpRxpEBHwAAIABJREFURWV22WUXGTZsmPTv3z9bVOiwww4rKix0zz33yNlnn12yP9Xev/71L2lubhZVLGfs2LGyww47uI5NFcBZtGiRvP/++9m4VDz77bef9OjRw1FbK1askKampmwbGzduzH4ZjxrX7rvvLlVVVY7aUBep8be2tmYLA23evDl7n2rDzXP6XGdqTHPmzMkWFlJtqjiU0ahRozy153gQbS5U+wwWLlyY9Vm+fHn23QEDBsigQYOyY3Nq7LV/7gtfgM/P4Rvb1IOua7aszwc/C3XNdfAjpUUEEAhCgHX7IBQ7bsOrcZiRsW4fpi5tlxJgPxLzAgEEjBDguUmwaeK5SbCetIYAAggggAACCJQRoKgQUwMBBBAwXGDtpi1y8l/myHvLPzdyJLv06iZPnrKv9O/RVdv4V63fLEc/9I58vHqDtjF2FNjeA3pmCzf17Nb+W/uMHJDFQbstKpSjOuaYY+Qvf/lLyW85tJgz8qFTVChy8ng7jOKBQamCQZVGbVpBISdjVAWGdCkuRFGhSjOQ9xFAICECbOJJSCI1HoauG9nbFueZPHaGVPerzUq2fW/KoZl2P8uRFxYXantfYVoKi/90VExIxVBdNV6UW+5VGFulwxZxTgVdcx2nCX0jgEBxIR83Hk6KCrkpKKT6LldUaN37L7sJTYtru4/cPx8HhxO0SAlBdCDAoWimBwIaCbDWHUwyWOsOxpFWIhNYtWqVjB8/Xt5++2352c9+JpdccklkfdMRAgi4F+Dzs3sz7igvoOuaLevzwc9aXXMd/EhpEQEEghDwuqbMun3H+qzbBzE7aSNJAuxHSlI2GQsCCRbguUkwyeW5STCOtIIAAggggAACCDgUoKiQQyguQwABBHQVaPxolZz1xFxdw3MU1/3H7injh/Z1dG0cF81a+Kmc8di/4ug6sD7vO2ZPqd1dX+PABprwhrwWFVIsaqOn2vDJKz4BigrFZx9Lz2E/MFBV+Yel3A3NtIJCbsaoS2Ehigq5m5NcjQACxgqwicfY1BkTuM4b2e9+bYKoAj/qpYr5qOI96t/q57lXYTEg9bNyhYPU/bm2yiVHtdXcOrPkder+uupUvrBRqdhKFTvSaSLonGudnIgFAdsEwjqc4LagkHIvV1TIa4xx5tLJ4Q1d4oszDvrWQ4BD0XrkgSgQyAqw1u1/IrDW7d+QFmIRWLp0qcyePVuOPfbYWPqnUwQQcC7A52fnVlxZWUDnNVvW5yvnz80VOufazTi4FgEEohHwuiZeaV2adfvmfAK9Goc5AwrzF2Y/tI1AToD9SMwFBBAwQoDnJv7TxHMT/4a0gAACCCCAAAIIuBSgqJBLMC5HAAEEdBO4+Z+L5FevfqxbWK7i+cFXd5ULvzbE1T1RXnzLS4vkl6+Ybfz9cbvKRf+lr3GU+TS5r7ZFhQ488ED5xz/+UTSk1tZWmTNnjtxxxx3y8MMPF72nvkly3333NZnA6NgpKmR0+twHH+YDAyeV+dtGrEvRHaeSXsaoQ9Ekigo5zTDXIYCA4QJs4jE8gQaEr/NG9rYFhFRRoabWRlExq1fbgkKF3OWKC7lNSdtiQrn7SxU3ysVVKTa3MQR1vc65DmqMtIMAAu4FvG6c7+hwgpeDCSpyigq5z5/XOzic4FUumfdxKDqZeWVUhgqw1u0vcax1+/PjbgQQQAABRwJ8fnbExEUOBXRes2V93mESHV6mc64dDoHLEEAgQgHW7cPBrlR0KZxenbfKur1zK64MRoD9SME40goCCIQswHMTf8A8N/Hnx90IIIAAAggggIBHAYoKeYTjNgQQQEAXgW9NmyOzF6/WJRxPcfyfQb3l998cJd06d/J0f5g3rd30hZz+6Bx5Y+lnYXYTetsHDO4jf/jmqND7oYNwBZwUFSqM4Lvf/a7cd999+R898MADcsYZZ3QY5Nq1a2XVqlWy8847S+fOnV0PqKWlRdavXy/9+/eX7bff3vX9fvtX96vCSr1795Y+ffq47t/LDaq/devWyYABA6Rr165lm+ioqJDK7ZIlS6Rv377So0cPL2Fwj24CYT4wGDNDRC2ou3m1NoqoojumvEwdI0WFTJlhxIkAAj4F2MTjE5DbKwrovpG98NuQ2w5myqGZiuPzWlyoXDGhwg7Lta3uVQWQdHvpnmvdvIgHAVsEgj6c4LWgkPKmqFB0s47DCdFZm9ATh6JNyBIxWiPAWre/VLPW7c+PuxFAAAEEHAnw+dkRExc5FNB9zZb1eYeJdHCZ7rl2MAQuQQCBCAVYtw8Hm6JC4bjSqrkC7EcyN3dEjoBVAjw38Zdunpv48+NuBBBAAAEEEEDAowBFhTzCcRsCCCCgg8D7n6yVYx9+VzZu+UKHcHzFcOthw+XokTv5aiOMm5+Y+4lc+LcPw2g60ja377KdPH7yPjKiP8VKIoUPuDO3RYX++c9/yoEHHpiP4rzzzpPbbrutXVSvvfaa/PznP5c333xT5s2bl39/3LhxMmnSJLniiivKFrrZvHmzTJs2TaZOnSqzZ88uanvgwIHZIkZnn322DB8+vKyGn/5Vo2+88Ybceeed8vDDD8uaNWvy/aj+R48eLZdddpkccsghJfu/7rrr5PXXX8++d9JJJ8nxxx8vf/jDH+SRRx6RpqYmUUWKvve978mVV15ZdP9jjz2WLdj09NNPF/18xIgRcv7558t3vvOddmaligrNnTtXVLGn6dOn52Ovrq6WY489VtLpdLY4Ei9DBcJ8YOC1cI0qKqSKC5nw8jrGMN2duHmN20nbXIMAAghoJMAmHo2SkdBQTNjIftnz7QsjT6xJSV1N2lFWOjr4UKoBv227ud/RAAK6yIRcBzRUmkEAARcCQR5O8FNQSIVMUSEXifN5KUWFfAIm7HYORScsoQzHbIEw11y9rqey1h3+nPKam/AjowcEEEAAgRICfH5mWgQpYMKaLevzwWTchFwHM1JaQQCBIARYtw9CsX0bFBUKx5VWzRVgP5K5uSNyBKwS4LmJv3R7ff4QpruTEXmN20nbXIMAAggggAACCEQgQFGhCJDpAgEEEAhL4C9zVshlDU1hNR9pu5OG95NfHj5COrU/kxdpHG07O/fpefLshy2xxhBU51PqauSEUQOCao52YhBwW1Ro/vz5ogrU5F7f/va35Xe/+13+3xs3bpTrr79errnmmg5Ho9pQBXtUkaHC1+eff54tOvTiiy9W1FCFh1TBnsKX3/5VW6qY0QUXXFCx/zPPPDNbBKjt68gjj8wXBlIOy5cvlzvuuKPososuukhuuumm/M9+/OMfy4033thhnwcccEC23X79+uWva1tUSBUe+u1vf1u2ncGDB2eLDY0cObLi+LhAQ4GwFq6rakVUhX4vL1MOWpg8Rh4YeJmZ3IMAAgYKsInHwKQZFrIJG9kbmtKi4sy9qvvVyuSxzj+nuS0qpNpWfTh5Nbc0imo/99K1oJCKz4RcOzHnGgQQCFYgqMMJfgsKqVFRVCjY3HbUGkWForM2oScORZuQJWK0RoC1bu+pZq3bux13IoAAAgi4EuDzsysuLq4gYMKaLevzwUxjE3IdzEhpBQEEghBg3T4IxfZtUFQoHFdaNVeA/Ujm5o7IEbBKgOcm3tPNcxPvdtyJAAIIIIAAAgj4FKCokE9AbkcAAQTiFKhv/EgefGtpnCEE2vfP6mrkmxoVvXn0Xyvk8oZm2ZLJBDrOuBo7ffQukqrdPa7u6TcAAbdFhVRRG1U0J/e69NJLZcqUKfl/33DDDXLllVc6iqx3796ycOFC6du3b/768847r10Bno4ae/fdd2XvvfcOrP8nn3xSjjnmGEfxq4tUYaSTTjqp6PrCokKjRo2SOXPmtGuvsKjQT37yE7nuuusc9akKLj333HP5a9sWFXLSSF1dnTz//PNOLuUa3QTCemBQnRYZlvI22vn1Is1pb/dGeZfJY6SoUJQzhb7+P3vnAqZTuf7/W+NQzkM5DpkZjBTKIcqWmTKKQjY5VOxyqE2iULTJzKQSEbIpUUl2RJSEXSO0y87p7xgxmmEYP4eY0YycD//rXrPXmvf8ruO7Tt/nurp43/Uc7vtzP29ruZ/n+S4QAAETCWATj4nwXTK0HTayR/rQwsT28nMTvrbxtFHSPpLTzA6xjiQPjAUCIFBIQK/DCbVGLtSM9Mjk3lIfkdrcz2JIpWrdRiUqx9Dl0zl08civlLfmI82+RMp+tYZCVEgtOWe2w6FoZ8YVXtmUAHLd6gOHXLd6dmgJAiAAAiCgiACenxXhQuUwBOyQs0V+Xp9pbIdY6+MpegEBENCDAPL2yNvrMY/QBwiEI4D9SOEI4ToIgIAlCGDdRH0YsG6inh1aggAIgAAIgAAIgIBGAhAV0ggQzUEABEDATAK9v9hLm4/mm2mCrmO3jClPE9vFU60KpXTtV01nh85coNFrsmiLg/i2qFmOFnUvEnRRwwVtzCWgRFQoPz+fkpKSaNu2bZLRc+bMoQEDBgifDx06RLGxsV4OzZ49m3r06EEVKlSgnJwcGj9+PHEbsQwfPpymTJkifLx8+TKVLFnSq/3ixYupdevWVLlyZdqzZw999tlnUn2uOG3aNBo2bJgu43MnLBDEY4rl3XffpQ4dOlB8fDyx/zxeamqRgEpMTAwdOXLEy2ZPUSHPC1y3ffv2AqO7775b+PvHH39M/fr182qfkpJCnTp1EpitW7eO3nrrLcrKypLq/PDDD3TfffcJnwOJCrFY04QJEygxMVGos2zZMho3bpzXGN9//z3df//95k4+jK6cgFELBloU+u0iKmRnHyEqpPy3ghYgAAK2JIBNPLYMm62MtsNG9lHfFfNj+mzzdRRXqfDZPljJyl1P6VlpxH8qLe3iUyg5PrxIZCDb2C62z2rFDrG2GjPYAwJuIKDX4QS9WRkpysNCQpU6DaWo0uVDmn1+/ybyFDpS4qOR9iuxI1hdiArpQdE5feBQtHNiCU8cQAC5bvVBRK5bPTu0BAEQAAEQUEQAz8+KcKFyGAJ2yNkiP6/PNLZDrPXxFL2AAAjoQQB5++AUkbfXY4ahDxAoJID9SJgJIAACtiCAdRP1YcK6iXp2aAkCIAACIAACIAACGglAVEgjQDQHARAAAbMIHD97iR5asJMKLl41ywRDxn36zmo0pm0d8j+aZ8hwQTt9/T/Z9PH2Y5Ed1ODRypaMon/3aULVy3oLwRg8LLrXkYCvqFBcXBzNmzdPGuHKlSt04sQJ2r17N82YMYMKCgqkayxek52dTdHR0cJ3LO7DIjxiWbRokSDS41s6duxIq1evlr6+dOkSlShRgo4fP07Vq1eXvh8yZIgwpm9hUZ+LFy/SoEGDqHbt2tJlreNzR8zjm2++obFjx9IzzzxDzz33XFj7//jjDypfvuhwViBRoddee41effVVv76aNWvmJdLEYz/88MNe9Q4cOEBcj/8bOXIkPfTQQxQVFSXUCSQq9PPPP1OrVq28+mAxJ09hIRZyYkEnFJsRsOKCgVE2GREateI8Zvuo1m4jGKJPEAABEDCQADbxGAgXXQsErL6R3fctyGLYQgn3aBET8p0WocSFPG1jezzFi+SIHkV6Clo91pHmgfFAAAQKCbjxcAL7rURUR80hBYgK4RdmJwI4FG2naMFWxxMwKueqZeO4UTYZEUy1OWOzfVRrtxEM0ScIgAAIgEBYAnh+DosIFRQQsHrOFvl5BcEMU9XqsdbPU/QEAiCgBwHk7cNTRN4+PCPUAIFwBLAfKRwhXAcBELAEAaPy91g3CR1eo7jLnVRYN5FLCvVAAARAAARAAAQsSgCiQhYNDMwCARAAgXAEfjr8B/3ty1/DVbPl9TH33Ur97ioSK4m0Ex9tP0Zv/XSYrl67HumhDR9vXtfbqE3tCoaPgwGMIeArKqRklJkzZ9LgwYOlJklJSbR+/XrhM4sTZWZmBuxuxYoV1LlzZ+kai+bUrVuXzp07R2XKlJG+b9GiBX311VdUo0YNWWZpHV/WIEQ0ffp0euGFF6Tq27Zto7vuukv67Csq9Pzzz3uJLYkVeaGqZs2aUrsOHTrQqlWrAppx9uxZKlu2rN81X1Ehtmvq1Kl+9XzH+vvf/07vvfeeXJdRzyoEjExcN11HxAsHSouRNim1JVx9u/qIBYNwkcV1EAABhxDAJh6HBNLCblh5I7vvgQUW+GF7xeIr+BNKTMhX9CdQSLhOXHRbrzGCjRXItqy8HyRhoVCiR2ZNByvH2iwmGBcEQMC9okKxb/2HSlSOUTQFfv/8dcpb85GsNhAVkoUJlSxCAIeiLRIImAECTMDIvLJd88BKZoZdfUSuW0mUURcEQAAETCeA52fTQ+AoA6ycs0V+Xt+pZuVY6+spegMBENCDgFtFhZC3z9Jj+qAPEJBNAPuRZKNCRRAAATMJYN1EG32sm2jjh9YgAAIgAAIgAAIgoJIARIVUgkMzEAABEDCbwPydxylt/SGzzTBk/GplS9LQljHU844qhvQfqtNFv5ykaRuP0O9/Xo742JEYMCWxDvVtUi0SQ2EMAwioERWKiYkhFrN57LHHvCwqX748FRQUCN9xnfHjxwe0ODs7m1JTU6VrLKTDgjpcEhISKCMjw6tdmzZtqEGDBhQfHy+ID917771Uvbq/SJge43sOfP78eWLBo4MHD9KhQ4coKytLEErasmULnTx5Uqq6du1aYkEjsfiKCn3//fd0//33+7HgTXjNmzeXvp80aRK99NJLiqLsKyq0YMECeuKJJ/z68I1zly5dBMEmFJsRMHLBQM2bCLYlEeUVConZotjVRxy0sMX0gpEgAALaCWATj3aG6CE0AStvZB/1XTHJeFFAiIWDZm8t+nfGs83XCXXSs9IkQR9Pj1ncJzkuhfhPoV5mqp9oUKA6XNdTwEjsU7QjkG1cJ9j3VpiHVo61FfjABhBwKwG3Hk6o9vTbVP7eborDLpcXRIUUo0UDEwngULSJ8DE0CPgSQK5b25xArlsbP7QGARAAARCQRQDPz7IwoZJMAlbO2SI/LzOIMqtZOdYyXUA1EACBCBKQm4f2NcnovLTR/SNvD1GhCP7MMBQRYT8SpgEIgIAtCGDdRFuYsG6ijR9agwAIgAAIgAAIgIBKAhAVUgkOzUAABEDAbAKv/XCIPtlx3GwzDBu/SpkSNOTuGHqicVXDxvDt+LPdJ2jW5qN07OyliI0Z6YH+dmc1Gte2TqSHxXg6EVAqKlS/fn3asWMH3XTTTV4WnD17lsqVK6fKqk8++YT69u0rtF25ciWxKE+4wkJDH3zwgSA2xEWv8bkvXkBi0aM5c+aEM0O4Hk5UKDc3l6Kjo/36Wr16NXXs2FH6fsmSJdS9e3dZY4qVfEWFdu3aRY0aNQrYh6foUqdOnejrr79WNBYqW4CAkQsG7F5cKlFsijxHD6YRZRWJg8lrZIFadvQRokIWmDgwAQRAIBIEsIknEpTdPYZVN7L7iv9MbH9dChSLCrG4UKjiKxTkWddTmIjricJEvv2xDVwCiQt51vW0LZDokShoZPZMs2qszeaC8UHA7QTcejghul0/uqXnWMXhv3ounzKH3Rm2ndGHK8IaEKaCp31a+0J7+xPAoWj7xxAeOIgAct3ag4lct3aG6AEEQAAEQCAkATw/Y4LoScCqOVvk5/WMcmFfVo21/p6iRxAAAT0IIG+vjCLy9sp4oTYIiASwHwlzAQRAwBYEsG6iPUxYN9HOED2AAAiAAAiAAAiAgEICEBVSCAzVQQAEQMAqBAZ8vY/WHTxjFXMMsSP6xuLU985q1LdJNap4Y3FDxuBOz166Sh9vP0YfbT9O+RevGDaOFTpOio2muZ0TrGAKbFBBwFdUqFWrVvTjjz9KPbEgTt26damgoED6bvPmzdSiRQuv0c6cORNQOEeOSZ6iQlz/m2++of79+9PJkyfDNt+3bx8lJCSQXuOz0E6XLl3CjutZIZSoUJUqVejEiRMB+/MVUPrqq68Uj+0rKpSRkUH16tULOB5EhRSF1ZqVjV4wYK/lJNTtKijE/sl9E4GVfISokDV/jw60ijdQHD58WPKsSZMmfiKCDnQbLlmIADbxWCgYDjXFihvZfYV52sWnUHJ8kXCj74EGz9CEEhMS68kVFRLrhxIXCiRK5Cl6FEq0KNJTyoqxjjQDjAcCIOBPwOmHE1g8qOydyYLjRyb39gKgVljn8ukcOjj6PltPJ7W+29ppGB+UAA5FY3KAgIUIINetPRjIdWtniB5AwGIEjh07RtnZ2ZJVjRs3ptKlS1vMSpjjJgJ4fnZTtI331Yo5W+TnjYm7FWNtjKfoFQRAQA8CyNsrp4i8vXJmaAEC2I+EOQACIGALAlg30R4mrJtoZ4geQAAEQAAEQAAEQEAhAYgKKQSG6iAAAiBgFQIPLdhJB06ft4o5htrROeFmerxRFWpRs7zu42zKyaeFv5ygFftP6963FTusX7k0rX6ysRVNg00yCPiKCrVu3Zp++uknr5bTp0+nF154QfqO67DwULFixaTvrl27RlFRUdLn5ORkSk0tOgwbyhQWLWLxHc9y9epV2rVrF23cuJEOHDhAv/32G23fvp1ycnK86j388MOCCJEe4//xxx9Uq1YtLwGlrl270gMPPEANGzak+Ph4qlmzJi1cuJD69Okj2aFWVIj9adq0qdTPzJkzafDgwTKiVlQFokKKcNm/ciQWDERKLC5UsW2hCA+XvPVEZ34o/JP/s2MJtFjAvljdR4gK2WK2XblyhdLT02nHjh2CMM/Ro0fpxhtvFO4r/B/fSxo1amRpX0LdU86fP0/169eX7H/wwQdp7ty5lvYHxtmPADbx2C9mdrPYKhvZ+aACFxbh8RQN8hQU4jrpWWkk1vVkLUdMSKyvVFRIbMd2ZeX9EHB8XztZWEgs4jUel+00q1gl1mb5j3FBAAQCE3Dq4QQWE6rUaShFlS7Kc//++euUt+YjCUTsW/+hEpVjVE2N/P8upeMfv6SqrRUaQVTIClGwjg04FG2dWMASECDkurVNAuS6tfFDaxCwKAFeKx4yZIhk3e7du+mOO+6wqLUwyw0E8PzshihHzker5GyRnzc+5laJtfGeYgQQAAE9CCBvj7y9HvMIfYBAOALYjxSOEK6DAAhYggDWTbSFAesm2vihNQiAAAiAAAiAAAioJABRIZXg0AwEQAAEzCRw9tJVumfuNjp3+aqZZkR07FrlS1HnBjdTp/o3U73KN2kee9+pc7T6wGn6JuM0HTpzQXN/dumgTMko+nlAUypTokhQxi62w04iOaJCFy9eFER1srKyJGRLliyh7t27eyFs0qSJIATEJTExkdatW6c7YhYZ6tKlC508eVLou1y5csRiQCxwpHV8Fgdi0QexjB07lsaPH+/nA4slpaWlSd+rFRViuytWrCj1w5tEZ8yYoYgZRIUU4bJ/5UguGNiflrcHgRYLtiXZQyAJokKWno0sgjdt2jSaNGmSdG8KZjCL8vH9w/NeY6RzmzdvlrqvVKkSsYhfqBLqnnLu3DkqU6aM1LxTp0709ddfG2k++nYhAWzicWHQI+yy2RvZWXwnkEiQiOHZ5oX/fgomJiTW8xT1CYdQi6gQ8wpVRDs8hZEC1Vdibzh/5F43O9Zy7UQ9EAAB+QTWr18v5Jq0FCceToifvsNLTEjk4ysqVO3pt6n8vd1U4bP7W48hKqQq7I5thEPRjg0tHIswAT3uyxEVFYowH8OHQ67bD7Euc9LwwGEAEAhPAKJC4Rmhhj8BI/8fiOdnzDg9CZids0V+Xs9ohu7L7FhHzlOMBALuIWDk8wby9sjbu+eXBE/NJID9SGbSx9ggAAKyCeCMgGxUfhWxbqKeHVqCAAiAAAiAAAiAgEYCEBXSCBDNQQAEQMAMAll55yl5/k4zhjZ9zFsr3Ejt4qMpsU5FahVTgW4opsyknw7/Qf/JPkPrDp4h5ujGsqbvnRQbfaMbXbe9z3JEhdjJpUuXeokIxcTE0IEDB+jGG4vi3rt3b1q0aJHEJNjbEwsKCmj58uXUq1cvKl68uBfDvLw8mj59OrFIQyBBH648aNAgev/996V23IbFebSO/+GHH9KAAQOkfletWkUdOnTwsu/8+fPCGyE9BZbUigpxx1WrVvUSocjJyaGaNWt6jckxGjNmDDVo0IAef/xxL2YQFbL+T5A3ViQlJRGLUaWkpGgzGAsG6vjZebGAPYaokLq4R6AVi8P16dOHVqxYoWi0KVOm0PDhwxW1UVOZBffEwnbOnz8/ZDcQFVJDGW1EAnrc77CJB/PJaAJmbWT3FPYJ5mNcpUKhjECiQ3wtLroteYr8sACR2CYUN7WiQqO+K7qHsCiQWAIJDfH1rLwfQgomsa2iaJLRceb+zYp1JHzDGCDgVgL872pRVEjtv62ddDghul0/qtRpaEBBIZ4jV8/lU+awO72mixZxnfz/LqXjH78UcPqxLWXvTI7I1DwyubficbT4rXgwNLA8ARyKtnyIYKBNCOhxX4aokMpgI9ftBY7zUeJLQIx40YnKKKEZCKgmAFEh1ehc3VCX+3IQgnh+dvXU0t15s3K2yM+TsJaA/LzuUxodgoCrCBj5vIG8fdFLPpVOKuTtlRJDfTcTMGI/EuekeE8w56S0vhjFzbGB7yBgdwJ67JmUGOCMgLrpgHUTddzQCgRAAARAAARAAAR0IgBRIZ1AohsQAAEQiCSBrf9XQD2X7InkkJYcq2n1cnR7lTKUUPkmiq90E1UtU5KqlC1JJW4oRucvX6M/Ll6hI/kXKfvMBdp/6hztOnGWdp34k65dv25JfyJl1OLHbqdmNcpFajiMoyMBuaJCXK9Nmza0YcMGafS3336bRo4cKX1mUYXOnTtLn5s2bUqLFy+m+Ph46bvc3FyhDvfTokULmjt3LjVu3Fi4vmTJEurfvz+x6BCXsWPHCv1XqFBBan/kyBG6/fbbpTp84fLly4LQjtbxV69eTR07dpTGeuyxx2jBggVUsmRJ4TsWjxg8eDB99tkulQJPAAAgAElEQVRnXhHQIirEB+Fee+01qT9mMW/ePLrrrruE706cOEHMmQUouNSvX1+widlxgaiQjj8Gg7oSFwzE7jWJC2HBQHmU7L5YwB5DVEh53CPQ4tq1a5ScnEx8D/At/P/q5s2bC/eNLVu2eInHiXVnzZoliOQZWfQUFeJ7bVxcHF26dEkw+a9//Su99957RpqPvm1GQI/7nRGbeGyGEeYaTMCsQwueAj1KXOSN/slxKZJ4kOeblOUeAlAjKpSemeolYDSxfVG+g69xCSQuFM43uTaH60fOdbNiLcc21AEBEFBHgA8t8PMGF/53NRel4kJOOZzAIj639BwbEmQgUaH46TuCihCFi8rvn79OeWs+8qsmx5ZwfSu5riaGEBVSQtj5dXEo2vkxhoeRIaDHfRmiQipihVy3BE0UExKfD/ngFkSFVMwpNLEcAYgKWS4ktjBIl/tyEE/x/GyLKWAbI83K2SI/XzhFkJ+3zU8FhoKAJQkY+byhJufLkDzzvmr7CAVbaf9ycuXI2xcRR97ekj91Rxul534kUUxIBAZRIUdPHTgHAmEJ6LFnUhoEZwTC8vargHUT5czQAgRAAARAAARAAAR0JgBRIZ2BojsQAAEQiASBNVl59OyK/ZEYypZjFCtWaLbLtYOCxm52pwRqFxdty9i63Wi5okLMaePGjXTPPfd4ITt+/DhVrVpV+o5FeVicx7OwGFHFihUpOzubdu3a5XWta9eutGzZMuE73pTGIgy+hUUMbrvtNtq5cyfl5OR4Xe7QoQOtWrVKl/FZsKh27dp+47O40IULF4TDa6LgkWclLaJC586do4SEBD+/ypUrR9WrV6eMjAw/e3777TdJqAmiQtb/BfsuGIgWqxIXsuKCQVwqUWyKvEBE2n4nLBYwWYgKyZtfEa71/vvv+4kC9ejRQxDaqVSpkpc1W7dupZ49e1JWlvcbxvhzbGysYZbrKSpkmJHo2DEE9Ljf6bmJxzFg4YiuBMw4tOAr0CPHIV8xIbGN7xuV+c3CXDdUUSoq5DtGu/gUSo4vFO/wLGrFheTYLIdRuDpmxDqcTbgOAiCgjYDnoQXPf1fz3+WKC6k9WKD08IBST5X2L3ezva8QUOxb/6ESlWOUmkdWERRiw9XEUC4vxWDQwJYEcCjalmGD0RYkoMd92ZKiQsh1Gz/bNOa6fcWERIMhKmR86DBCZAhAVCgynJ02ii735SBQ8PzstNlirj9m5GyRn/eOOfLz5v4GMDoI2JmAkc8banK+zFJpXl0pf6X9y81DI29fGAm5vJTGDfVBIBgBPfYj+YoJiWNBVAjzDgTcTUCPPZMSwUjvsZcTOqybyKGkrY7GdRNtg6M1CIAACIAACIAACGgnAFEh7QzRAwiAAAhEnMCyX3+nl77LjPi4GNAZBCa3j6eut93iDGdc5oUSUSFGw6IIixcvligNGjSIZs2aJX1mgYROnTrR3r17w5Ls1asXzZs3j0qVKiXVnTp1Kg0fPjxsW7ECb2Rr2rSpbuO/8sor9NZbb4Uc/4033qAxY8ZIdbSICnEnLNbUpUsXOnnyZFi/Fy5cSMxNLBAVCovM9ArBFgxEwxSJC2HBoCieLBjE/3HJW1/4n2dxiqAQ+4QFA9N/x74GXLp0iW6++WYvoTm+N/zjH/8IaiuL0nXu3FkQqBPLwIED6YMPPjDMPyuJCuXm5hLbEx2tToSSRfjOnDkjCBlGRUUZxgwdqyegx/1Oj0086j1ASzcQMOPQwuytScRCPXJLuE39vocgJra/HrJrpaJCnv0HExTyHFDpoQw5fcplFaqeGbHWw270AQIgEJxAoEMLnv+u5r+HExdywuGEWiMX0k0JLWVNFd/DCdWefpvK39tNVluxklJBofP7NynqX05lT3/VxBCHE+RQdk8dHIp2T6zhqbEE9LgvQ1TII0bIdYedsMHEhMSGEBUKixAV/keAc8xnz56lW265xWt9Wg0gLTlvXp///fffBRsqVKggDQ9RITWRQBtd7stBMOL5GfNLTwJm5GyRn/eOIPLzes5o9AUC7iJg5POGmpwv01cq+qM0Ykr6R94+TileiAopJoYGWglo2Y8UTExItAmiQlqjg/YgYG8CeuyZlAjgjEDRZMC6ib1/GLAeBEAABEAABEDAVQQgKuSqcMNZEAABpxD4dOdxSl1/yCnuwI8IE0hNrEN9mlSL8KgYTi8CnqIDrVu3pp9++ilo15mZmVS3bl2v64cPH6ZatWpJ3128eJEmTJhAvJgSqLRo0UIQVmABn0DCAGvWrBHas1hPsNKnTx96+eWX6Y477vCromV8FopgoR62zbfUr1+fhg0bRoMHDxaEEcTiKyrUvXt3Wrp0qXC5SpUqdOLEibCh+uOPP+jVV1+lGTNmBKx7//33EwtWtGrVyuu67+bSjIwMqlevXsA+WIhBFC5i4aevv/46rF2ooJ1AuAUDcQRZ4kJYMCgKiOfbDw6mEWWlFl1zkqAQewVRIe0/RJ17+Pe//00dOnSQeuX7w549e6h48eIhR9q+fbuXEF65cuXo1KlTVLJkSald3759hUMNXPj/+XyvC1RYAG/z5s3CpfLlywsifcePH6ehQ4fSlStXhO+//PJLqSnfj/ge71l449fzzz8vfRVOqK5Hjx5S323bthXuiWI5cOAAjRo1SvrMAoTs76effkrffvst8f2JC9vBbdn+uLjQG4u2bt1Kb7/9Nu3YsUNqz33wc8SDDz4o3KtLly6tc3TRnVoCetzvtGziUWs32rmLgBmHFkZ9V/TvBjm0w4kEcR+efYY7BKBEVMhXICicwBHb4tm/HP/iKiUS92t0MSPWRvuE/kHA7QRCHVoQ2fC/q7kEExdywuEEJQI5V8/lU+awO72mjpL2SgWFeCC1jEPNbyWHNwL1o8Rnt//O3OA/DkW7IcrwMRIE9LgvQ1TII1LIdQedtuHEhMSGEBWKxC/fvmPweiiL+69cudLLiZiYGLrvvvuE9WzftW+uaETOm9eUOQ/vaQuvL7Rp00Z4acHq1atpyJAhkp27d+8OuBZu32jAciMI6HJfDmIYnp+NiJh7+zQjZ4v8vPd8Q37evb8/eA4CWgkY+byhNqesNW8cjomS/pXkoJG3LySvhFm4WOE6CMghoGY/UjgxIXFciArJiQDqgIBzCeixZ1KigzMCRRMF6ybO/dHAMxAAARAAARAAAccRgKiQ40IKh0AABNxAYM7/+z9666fDbnAVPhpAYPRfatPAZjUM6Bld2pnAtWvX6MiRI7R//346ffo0xcbGUuPGjWULAPAbGlnEiPtgsZ9KlSpRtWrVqE6dOhQdHR0WjZbxCwoKhM2ihw4dEt4SeffddwtvrTS6XL16lbKzswVmLDTEQkAsunDrrbcaPTT6N4iA3AUDcfiQ4kJ2WjDYlkSUt94gqkQUbMHAaYJCTBCiQsbNI5U9Dxo0iN5//32p9aJFi6hnz56yeuN6LLgjFl9hOhYI4nsQl27dutEXX3wRsN+//vWvkmgQixPl5+cTb+5u3ry5LDu40tixY2n8+PFS/XCiQp6CeizuN3/+fKntli1bhHulWNLT0yk5OTmkLV999RV16dLFrw7f81lI77XXXgvZnu+PzJ5FhlDMJ6DH/U7NJh7zPYcFdiJgxqEFpW9CliMq5CvkE0r8R4mokBKxIjHuSkWFwokg6TWfzIi1XrajHxAAgcAE5BxaEFsGExey++EEJW87Fln4+hw/fQdFlS4fdpqpERTiTtUyDmWQksMbgfrB4YSw4XZVBRyKdlW44ayBBPS4L9tKVAi5bv1mk8xct1wxIdEwiArpFyIn9XT+/Hl65plnaMGCBWHdmjt3LvXv39+rnp45b+6YXwLAef1ghfP8Dz30EC1ZskSqAlGhsKFDBSLS5b4chCSenzHF9CRgRs4W+XnvCCI/r+eMRl8g4C4CRj5vqM0pa80bh4ug3P6Rt1e3LoC8fbgZiOt6E1CyH0mumJBoI0SF9I4W+gMBexHQY8+k5DHOCBQFH2cE7PVDgLUgAAIgAAIgAAKuJgBRIVeHH86DAAjYlcDMzUfpnZ+P2NV82G0ygeH31KLn7q5pshUYHgRAAASsR0DpgoHoQUBxITstGLAjRh62CLRg4ERBIeYo86CF9Wa/cy3y3TDFYnC1a9eW5fDMmTO93jT84YcfUr9+/aS2kRQV+vjjj+mpp56SxtZTVEgODD4kwex8hQLffPNNGjNmjJwuiPs4fPgwVaxYUVZ9VDKOgB73OyWbeIzzBD07mYDVDy0oeUuw52GIUO3kigqlZ6YS8xGLXHGj9Kw04jHkFhxakEsK9UAABHwJKDm04Pnvav57SkqK8JUehxPO79+kS3COTO4t9SPncEJ0u350S8+xisf2FQcqndCKyt/bjW6q35JK3BwTsD8lgkJc19MutYxDOSaHj9z2igGigeMI4FC040IKh0wioMd92VaiQswZuW59ZluYXLdSMSHRKIgK6RMep/UyYsQI4py33MIvumEhe7H4igrJ6SdYzvvHH3+k++67T04XXnUgKqQYmSsb6HJfDkIOz8+unFKGOY38fCLxCwICFeTnDZt26BgEQEAnAkY+b6jNKXvmjZG39147QN5ep4mPbhxFQM5+JKViQiIgiAo5aqrAGRBQTECPPZPSoDgjUMQfZwQUz0U0AAEQAAEQAAEQAAGzCEBUyCzyGBcEQAAENBB4d1MOTd+Yo6EHNHUzgWGtYmhoy8AHUdzMBb6DAAiAgNoFA5Gcl7iQ1RcM8tYTsbCPZzHqsIXvggGP3dRnE55RY0d6WkNUKNLEw46XkJBAGRkZUr3Lly9T8eLFw7bjCitXrqRHHnlEqvv66697CehoERXKzc2l77//Xuq7R48e0t9bt25Nw4YN87KRv6tRo4b0nRGiQqNHj6ZOnTpR1apV6eeff6bBgwdTQUGBNKavgNqhQ4coNjbWy87Zs2cT+1KhQgXKycmh8ePH05w5c6Q6w4cPpylTpsjij0rGEdDjfjdw4EA6duyYYGT16tW95qdxlqNnNxEw49CCp6iPXNZyhHd8++XDCCwu5FvkiAr59iVnfN9DDnJ9kyNWJLevUPXMiLUedqMPEACB4ATUHFoQe+NnTi69cz5RhdiIN+Z6HpSQI5qj5m3H7CwfpvAUMPIFwGJFZe9MppK1bqOo0uVJqaBQ3pqPSI79qsD/r5HW/o2InxZ/0NZcAjgUbS5/jO4cAnrcl1P+Unh/tlTxzDkj121MaILkutWKCYlGQlTImHDZudfz589TnTp16OTJk4IbLPazYMECatmypZCrZqH6oUOH0vLlyyU3OTf5wQcfSJ+DiQopzXn/8ccfVKtWLa+8eNOmTYnXBho2bEhZWVm0bNky+uc//+mHHKJCdp6FkbNdl/vy/8R4fa3G83Pk4uiGkczI2SI/7z2zkJ93wy8NPoKAMQSMfN7QQ1RIL6+Rt5dPEnl7+axQ0xoEQokKqRUTEj2DqJA1YgwrQMAsAnrsmRRfkmT5lzFg3cSYaYYzAsZwRa8gAAIgAAIgAAIRIwBRoYihxkAgAAIgoB8BiArpx9KNPYmiQsWKFXOj+7b1+fr167a1HYbrQwC/WX04RqIXQXjD6gctDqYRRUrcx6wDHpEItu8YD1wnrYvXZpjtxDHF+6an8A+/uZjfYCy3/PLLL9SoUSOp+gsvvEBTp06VPmsRFfK1wfP/8X369KH58+eHNFNvUaGZM2cKIkKe5YcffiA+5COWhx9+mL755hvpMwsfvfvuu9LnRYsWUc+ePf3s7tixI61evVr6/tKlS1SiRAnCfU3uTLRuvWeeeYb4P4gKWTdGdrbMjEMLzEuNAI8aYZ9ABwLkiAp52hduXO4vPSuN+E+lJVzfSvsLVd831hsW6Nm7u/riDVAoziTgxtjuH+AtXik3skaI0kTqcMLVc/mUOexOua4GrMfCQ7f09H/TMQsKcdF6eCCccVr7NyJ+4WzGdesS4EPRLBbgKRhgXWthGQg4m8D1NRb0zywhe5fluj0jr1VMyIKzyLEm2XFNmYWF5s6dS5MmTaIvvvhCEBTyLCx+X7NmTUnsp0WLFrR582apSiBRITU5b85x9+7dW+q3TZs2tHbtWr8XFYwbN04Q1PcsThQVQg7fmv+bEMV4pUNs/zMTokLWjJddrUJ+PpH45QC+xQ35eV4bkFNwj5BDCXVAwL4Egj1vuFFUCHl773UF+85qWG4nAoFEhbAf004RhK0g4HwCOCPgE2MXr5s4f7bDQxAAARAAARAAAacRgKiQ0yIKf0AABFxBYObmo/TOz0dc4Suc1J/A8Htq0XN318RBbv3RGtqjHTeAGgrEhZ1jU469gm6LgxZZqUTRiURNfTbEbUsqFBzSq3guGPj2qfdYetmsth+ICqklp3s78b7p+f/Oxo0b086dO2WPxQJEdevWleoPGTKEZsyYIX12iqgQv2F5z549AbnEx8cLb1/m4ivK5PmGu1CCTStWrKDOnTtL/R84cEDgivua7Klo+Yp80Kdbt26WtxMG2ouAWYcWmFIoYSFxQz3b51vCCfHM3pokCfzEVfI/lBBOVMjXrlBvKg7kA4+ZHJdC/GcwHz3rRGrG+MY6uW5qpIbGOCAAAhYmoFZUqNbIhbp7dWRy0aFiOaI5bMNNCd6HoOUadX7/JvIcT247rhdOUIjryLFfyZi+dbX2D1EhLfSd1xaiQs6LKTyyLwHkuj1i57Jct+i51jc423f229Nyp64pP/roo7R8+XIpKNeuXZNyzL6iQmpz3iygPmfOHGkM7rd58+YBJ0LVqlXp5MmT0jWICtnz92Jnq9etW+f1YgiICtk5mtazHfl5//y9W/LzEBWy3u8RFoGAmQR8nzfUigohbx/8RQDI25s5wzG2VQl4igodOnSIunfvblVTYRcIgIDLCaybQpTYxEIQfF/GgDMC+gfnAbwkXn+o6BEEQAAEQAAEQCCSBCAqFEnaGAsEQAAEdCIw5//9H73102GdekM3biMw+i+1aWCzGjjIbbPAO3UDqM3CYKq5EF8wFb+iwW3zFgJeMOBitLBQsIMWThMUYpYQFVL0WzGysnjf9BT+qVKlCp04cUL2sPymY883Ir/88ss0ceJEqb1TRIUGDhxIH3zwQUAujzzyCK1cuVK65vk84ul/TEyM35uZxUbZ2dkkvsmOv1u1ahV16NABz6KyZ6J1K/IhG/6vevXqVKNGDesaCstsScDMQwsiMD4kwCUr7wdBjIcLi+54XvcVFwolLOQpGsR98JuOPfsLJyo06rti0tjBxuE+0rPSJPEisUGg+lw300NIMj460cueSE0ciApFijTGAQF7EVArKmS0l3JEc+Kn76Co0uU1mcJvP7505Fc6uyOd8tZ8FLYvOYJC3Ikc+8MOFqKC1v4hKqSFvvPaQlTIeTGFR/YlYBtRIUaMXLd+E81nczy/EZ6LZ55Pv8HQk54E7L6mnJeXRxkZGcQHBw8ePCiI3rNQPYtbeZYLFy5QqVKlhK98RYXU5rx98+FXrlyhqKiogOHp0aMHLVmyRLoGUSE9ZzH6CkUgMTGRUlJSvASFuD5EhTBv9CSA/Ly/qJBb8vMQFdLzl4S+QMC+BII9b6gVFTKahJy8NPL2hVFQE0Pk7Y2ewejfl4CnqJC4H4nzUshJYa6AAAhYhQDOCPhEwmVnBKwyD2EHCIAACIAACIAACKghAFEhNdTQBgRAAARMJvDpzuOUuv6QyVboM/ywVjE0tGWMPp0Z2MumnHx6fOleA0eIXNepiXWoT5NqkRsQI4EACICATQhofduusFCQUnjgnL4vOvRtGfcDvYVANM7Iwxah3t7sC8eK3JQEEG8hUEIrInWbNGlCu3btksb6888/qXTp0rLG5gMBfDBALFOmTKHhw4dLn50iKjRr1iwaNGhQQCZ9+vShBQsWSNfEAylnz56lcuXKyeLoW+mTTz6hvn37qmqLRvoQ0ON+xwdzjh07JhgEUSF94oJevAlY4dCCnJj4vp1YbBNM9Gf21iRJ8IcFhVhYSCyhRIXkvAU5kC08BgsieYoXyfErknV8Y72h6LYTSTMcMVbbtm0d4Qec8CfAG/jtVJKSkvwO/Mq1XzysUONf/eQ2iWi9SB1O8HXq/P5NdGRy74C+yhUU4sZy7NcCVGv/OJyghb7z2uJQtPNiCo/MIaDHfTnxapI5xocaFblu42MSJNetVVyIn/fWrSv6t7DxjmAEuxDYunUrjRo1itauXSvL5FCiQmpy3jzo3XffLQgUCc/O9evT/v37g9oyadIkwV6xOFFUSFYgUEkRAV3uy0FyBHh+VhQKVA5DAPl579y9m/LzckWF8CMCARCwLgEjnzfUCNJEgpScvLQeokK+viBvH4noYgw3EggkKiRy0CouxDkpu627unEOwGcQMIqAHnsmcUYgQHRwRsCoKYt+QQAEQAAEQAAEQEB3AhAV0h0pOgQBEAAB4wks+/V3eum7TOMHisAImcNaRWAU7UM4SVRocvt46nrbLdqhoAcQAAEQcBgBtQsGXmJCIhMriuOwcBD/xyVvfeF/nsUoYSEsGDjsl2Ivd3zfLLx371667bbbZDkxceJEGj16tFSXxXWeeOIJ6bNcUaFHH32Uli9fLrRjIZ78/Hy/8YsVKxIiYyGf+fPnh7TxnXfeoREjRkh1+M3N9erVkz6H6s/3rc0fffQRPf300wHHCyYqdObMGYqOjpbF0bcSRIVUYdO1kR73u1CbeHQ1Fp25loBdDi2IAQok6BNIWMhTOIjbetYJJioUqg33wdfTs9IksSLRpmDCRlabVHaLtdX4wR4QsCIBNYcWfN98jMMJ3pH9/fPXKW/NR37hViIoxI3lHK7QMqe09g9RIS30ndcWh6KdF1N4ZA4BPe7LlhTQR67b+AkVRkBfrbgQRIWMD50dRxgzZgy9+eabQU3nvHpBQYHX9VCiQmpy3tx5s2bNaNu2bcI4DRs2pD179gS1aebMmTRkyBDpOkSF7DjzIm+zLvflIGbj+Tny8XTyiHbL2SI/r3422i3W6j1FSxBwDwEjnzeQt0fe3j2/JHhqJgE5+5HUigtBVMjMyGJsEDCfgB57JiUvcEagKKA4I2D+5IYFIAACIAACIAACICCTAESFZIJCNRAAARCwEoE1WXn07Irgb0Wzkq2hbGkZU54+69bQLubS40v3EosL2b3M7pRA7eLUHQK3u++wHwRAAARCEVC6YBBQTEgcwIoLBnLCb4SwEBYM5JBHHYMIvPbaayS9HYRI+Dv/dsOVK1euUJMmTYhFiMTCBwj4IIFYPEWFHn74Yfrmm28CdhsfH09ZWVnCNaeICl27do2ioqIkf5OTk2Vx5QZ169alKlWqhAsBrhtIQI/7nZxNPAa6gK5dQMCOG9kDHVzgUPmK+wR7q3EwUSHP+uH64vHiKiVSclyK8Kcdih1jbQeusBEEzCSg5NCCr5iQaDcOJxRFUC9BIe5Rq+hPuHmltX+ICoUj7K7rOBTtrnjDW+MI6HFftqSokBxkyHXLoRS8ThhRIbGhUnEhiAppC4sTW2/cuJHuueceL9f+/ve/U8uWLalBgwYUFxcn5JMHDBhAH374oVTPCFGh9u3bU3p6ujTG9evXgyL3tQeiQk6cnfr7pMt9OYhZeH7WP15u7tGOOVvk59XNWDvGWp2naAUC7iFg5PMG8vbI27vnlwRPzSSgZD+SUnEhiAqZGVmMDQLmE9Bjz6TkBc4IFAUUZwTMn9ywAARAAARAAARAAARkEoCokExQqAYCIAACViKw9f8KqOeS4G9Fs5KtoWwZ1iqGhraMsYu5jhEVWvzY7dSsRjnbcIehIAACIBApAnIXDEKKCYnG2nXBgO0PddiCk/8V2xZ6yfUOphX+PSu8SEuk4mjqODIPWphqo8sG5438jRs39vKaNx9Ur149JIkFCxZQnz59pDr169en/fu9RT1r1apFOTk5Qp1gby3Oy8ujSpUqSf3IERXq0aMHff755yHte+edd2jEiBFSnYyMDKpXr570uVixYtLf2Y/58+dLn7ds2UJ333239FntW5tZdGnXrl1CPzgMZK8flh73OyWbeOxFB9ZahYCdN7LLeSvy7K1JxCJCXFj859nm64TP/L3nd6EEiNKz0qQ+xLj5ig5ZJZ6h7LBzrO3AFzaCgBkE5BxaCCYmJNpr58MJ0e360S09x+qC/vz+TXRkcm+/vgKNEUx8yLOxVtGfcE5p7R+iQuEIu+s6DkW7K97w1jgCetyXbSsqxFiR61Y/uRTmuuWKCyGPqD4kTm3pewDw22+/JRb38S1/+ctfaMOGDdLXRogK9e3blz799FNpjMOHDxOvAwQqt99+u9dLCSAq5NQZqq9futyXg5iE52d9Y+X23uycs0V+XtnstXOslXmK2iDgHgJGPm8gb184j5C3d8/vCZ6aQ0DNfiS54kIQFTInphgVBKxCQI89k5IvOCNglbBG1g6F6yaRNQ6jgQAIgAAIgAAIgEB4AhAVCs8INUAABEDAcgSy8s5T8vydlrNLqUF2ExXalJMvCAvZvazpeyfFRt9odzdgPwiAAAjoTiDcgoEsMSHRKjsvGLAPgQ5bhCPOAkNuFxfCgkG4WWLK9WbNmtG2bduksfngyr/+9S+qUaNGQHt4A0GXLl2ooKBAuv7222/TyJEjveo/9NBDxAccxJKVlUWxsbFedXzFf4KJCpUvX14aj+vk5uZS8eLFg/KygqhQ7969adGiRZKNwQ5NMMfly5dTr169QvpkyuRw6aB63O/UbOJxKW64rZKA3Teyh3srsqeAECNiUSEuvqJCo74rEokTBYMC9c3CRMlxKYJAkd2K3WNtN96wFwQiQSDUoYVwYkKifXY+nMA+6CWOE+hwQiBBoavn8unSkV/DhvemhJZSHSMYQ1QobAhQQQEBHIpWAAtVQSAEAT3uy7YWFWI2yHWr+42ozHWHExeCqJC6cDi5FYvis8i/WPLz84lz5GEGHycAACAASURBVJ7l119/FYT9PYsRokLTp0+nF154QRpm0KBBNGvWLD/8a9asoeTkZK/vISrk5Fmqn2+63JeDmIPnZ/3ihJ6I7J6zRX5e/iy2e6zle4qaIOAeAkY+bxiRU9YjMnLz0sjbE6mJoV7c9Ig1+nAHAS37kcKJC0FUyB1zCF6CQDACeuyZlPrGGQF3TjSV6ybuhAWvQQAEQAAEQAAErEgAokJWjApsAgEQAIEwBM5eukr3zN1G5y5ftTWrzGGtbGd//PSNtrPZ0+AyJaPo5wFNqUyJKFv7AeNBAARAwAgCwRYMFIkJiYbZfcGA/cBhC+XTDAsGyplFoAULCrGwkGfhQwkszNOiRQtKSEigc+fO0S+//EIrV66kSZMmedXlwwrcR6lSpby+HzZsGL377rvSd/fffz8tXryYKleuTOfPnxeEiwYOHOg3Lh+K8C2+b1keN24c8WGKunXrBiRkBVGhFStWUOfOnSX7mjZtKvgfHx8vfcfiSFyH3yDNrOfOnUuNGzeOQNQxRCgCetzvtGziQXRAQA4Bp2xkDyUAlJ6VRiwuxEUUBfIUFYqLbisc3hALCw95thG/F8WG5HC1Yh2nxNqKbGETCJhFINChBbliQqLNaja2R8JfuYcT4qfvoKjS5TWbFEhUSK8N/EYwlssnGBi9fNMMHh1YggAORVsiDDDCAQT0uC/bXlSI44hct/LZrDHXHUxcCKJCykPh9BajR4+miRMnSm5OnTqVOPderFih0PKBAweoe/futGvXLi8URogKZWdnU506dbzG+cc//kFjxoyh0qVL06VLlyg9PZ0eeeQRv7BAVMjpM1Uf/3S5LwcxBc/P+sQIvRQScErOFvn58DPaKbEO7ylqgIB7CBj5vGFETlmPyMjNSyNvD1EhPeYb+jCegB77kYKJC0FUyPj4YQQQsDIBPfZMSv7hjICVQ22cbRrXTYwzDD2DAAiAAAiAAAiAgDwCEBWSxwm1QAAEQMByBB5asJMOnD5vObvkGtQypjx91s37bXJy25pZ7/Gle2lTjv9BcDNtUjJ2/cqlafWTOMithBnqggAIuIeA74KBKjEhEZcTFgzYl7hUotgUZZNgWxJRXuEBedcVLBhYNuQsFDRq1ChV9rGg0F133eXXNtDbkblS/fr1KSMjI+BYLGYUSFTo9ddfp1dffTWofc888wzNnj1bum4FUSE2pmPHjrR69Wovu9u0aUMVK1YkPoDhe9Cja9eutGzZMlVxQCP9COhxv9NjE49+HqEnJxJw0kZ2Fg4KJAbEQkKiqJCaGIpCRPynnYuTYm3nOMB2ENCTgOehBaViQqIddj+cEN2uH93Sc6xmrBAV0owQHdiYAA5F2zh4MN1SBPS4LztCVIijgly3srmpU67bV1wIokLKwuCG2p9//jn16tXLy9UqVarQgw8+SEePHqW1a9cGxGCEqBAP9Nxzz9GsWbP8xoyLi6OsrKygIYGokBtmq3YfdbkvBzEDz8/a44Meigg4KWeL/Hzome2kWOM3DAIgUEjAyOcN5O0LGSNvj18bCBhLQM/9SL7iQhAVMjZ26B0ErE5Ajz2Tko84I2D1cBtjn07rJsYYh15BAARAAARAAARAIDwBiAqFZ4QaIAACIGBJAgO+3kfrDp6xpG1yjBrWKoaGtoyRU9VSdd7dlEPTN+ZYyiYlxiTFRtPczglKmqAuCIAACLiGgLhgoElMSKTl5gUDFhRiYSE3FiwYWDrqCxYsoD59+si2kQ8JrFy5kho0aBC0je9blANVHDRoEL333nvCpWCiQn/++acwTk5O4OfMJ598kj799FOpe6uICvEhik6dOtHevXvDcuWDIfPmzaNSpUqFrYsKxhLQ436n5yYeY71F73Yl4MSN7IHeiqw2Pu3iUyg5PlVtc0u1c2KsLQUYxoCACQT40AKXlJQU4kPjaordDyewz7VGLqSbElqqcV9qE+5wAl9XW45M7q22adB2ct8IHawDz/a6G4cObUcAh6JtFzIYbFECetyXXS0qhFy3bjNbFBfivBQf4EIBAZHAlStXhH83bNiwISQUFuYfO7ZIuNMoUaGCggJq3749bdy4MaQ9/JKA8ePHS3UgKoQ5LYeALvflIAPh+VlOBFBHLgEn5myRnw8cfSfGWu48Rz0QcCoBI583kLcvnDXI2zv11wO/rELAiP1IorgQRIWsEmXYAQLmENBjz6RkOc4ImBNEs0fFGQGzI4DxQQAEQAAEQAAENBKAqJBGgGgOAiAAAmYReO2HQ/TJjuNmDa953M+6NaSWMeU19xPpDjbl5NPjS8Mfmo60XXLH+9ud1Whc2zpyq6OejQjs378/5IH+kiVLUkxMDNWqVYsqVapkI89gKgjYlIATFgyiE4maqtzc7wT/1Uw9LBiooRbRNr/99hvNmTNHEPnhwwGBSsOGDWnIkCH0xBNPUPnyoZ9Xr1+/Lgjl9OvXz6+rpk2b0ttvv01nzpyhbt26Cdf5DcsnTpwIOO6pU6eIDyIsW7aMTp486VXHV1Ro5syZgo1iycjIoHr16kmfixUrJv2dhZTmz58vfd61axc1adJE+vzRRx/R008/HdAm/p79Ewv761suXrxIEyZMIPFgkO/1Fi1aUOfOnemVV16hqKioiMYbgxlHwIhNPMZZi57tSMCpG9n5rciZeeuJ/VNT4iolUnJcCvGfTilOjbVT4gM/QEANAd6Mp1ZMSHq+HRinZmjD2ygVzYmfvoOiSqvPgYc7nGC1QxxK+fgGDKJChk9hWw2AQ9G2CheMtTABPe7LjhAVQq5b+Sw1KNety5xU7g1aWJwA58zHjBlDH374oZ+lrVu3pjfeeIPKli1LzZs3l657igrpnfM+f/68kO+eNWuW3zpC/fr1acSIEcQi+hUqVJDs8c3RWxw5zDOJgJH/D8Tzs0lBdeiwTs3ZIj/vP2GdGmuH/jThFgjIImDk84bV8tEiEKV5aeTtZU0lqRLy9sp4obZ2AtiPpJ0hegABEIgAASfskce6ifKJYtC6iXJD0AIEQAAEQAAEQAAE1BGAqJA6bmgFAiAAAqYTmL/zOKWtP2S6HWoNyBzWSm1T09vFTw/9VjrTDQxhQEpiHerbpJqVTYRtKgm89dZbwmF9OaVcuXI0atQoGjx4MEVHR8tpgjo6EODFrpycHKmnRo0a0U033aRDz+jCkgScsGAQl0oUm6IO77YkIn6Ls9sKFgxsE3EWwjly5AgdPXqUjh07RqVKlaIaNWoIAnw1a9ZU7MelS5fowIEDxCJ//P/2Vq1aqb7HsnDP77//Ttwn/8eFDydUrlxZsV2RbHDt2jWBKTM4ffo0xcbGUuPGjal06dKRNANjRYgANvFECLSLh3H6RnY1b0VuF59CyfGpjpsVTo+14wIGh0AgQgSccjiBcWk5oABRoQhNOAxjSQI4FG3JsMAotxJArhu5brfOffgdcQIsLpSZmSnkmatVq0YsWG9mfvnPP/+k3bt3C+u7nPdne/jFASggYEUCeH62YlTsa5PTc7bIzxfNTafH2r6/QlgOAtYkgLx9YVyQt7fm/IRVziGA/UjOiSU8AQFHE8C6CdZNHD3B4RwIgAAIgAAIgIBTCUBUyKmRhV8gAAKOJ/DT4T/ob1/+aks/h7WKoaEtY2xpOxv9+NK9tCkn35b2z+t6G7WpXfTGPFs6AaMDElAiKiR2wOJCX375JT3wwAOgGgEC77zzjvDmSrHgjZURgG7mEG5fMDiYRpTlvEPvYacURIXCIkIFEAABZxDAJh5nxNHKXrhhI7vSgwsT21+3cshU2+aGWKuGg4Yg4GICTjqcwGGsNXIh3ZTQUnFEcThBMTI0cBABHIp2UDDhiv0JINeNXLf9ZzE8AAEQAAHHE8Dzs+NDHFEH3ZCzRX6+cEq5IdYR/fFgMBBwOAHk7QsDjLy9wyc63DOdAPYjmR4CGAACICCHANZNsG4iZ56gDgiAAAiAAAiAAAhYjABEhSwWEJgDAiAAAnIJHD97iR5asJMKLl6V28Qy9ewuKsSCQiwsZLdStmQU/btPE6petqTdTIe9MgioERXibllYaNeuXVSnTh0Zo6CKFgIQFdJCz4ZtnbBgEJ1I1HSdOvgQFVLHDa1AAARAwCYEsInHJoGysZlu2Mg+e2sSZeWulx2lZ5uvo7hKibLr26WiG2Jtl1jAThCwEgGnHU5gtmqEhXA4wUqzErZEmgAORUeaOMYDgRAEkOvG5nj8QEAABEAABCxPAM/Plg+RrQx0Q84W+fnCKemGWNvqxwdjQcDiBJC3LwwQ8vYWn6gwz/YEsB/J9iGEAyDgDgJYN8G6iTtmOrwEARAAARAAARBwGAGICjksoHAHBEDAXQR6f7GXNh/Nt53Tn3VrSC1jytvObtFgu4oKtahZjhZ1v9223GF4aAK+okLp6enUrl07qdGlS5fo2LFjtHLlSkpLS6OTJ09K1x577DFavHgxEBtMAKJCBgO2WvduXzDYlkSUJ/+QvNXCp9qeB66rboqGIAACIGAnAtjEY6do2dNWN2xkV3poYWJ7Zz5nuCHW9vwVwmoQMJeAEw8niERZXIjLTQktQ0K+ei6fcle8S3lrPvKqV39OlvTZapy02ubZ3twZiNGtQACHoq0QBdgAAv8jgFw3ct34MYAACIAACFieAJ6fLR8iWxnohpwt8vOFU9INsbbVjw/GgoDFCVgtHy3i0pqX5n6Qtw8++ZC3t/gP04HmYT+SA4MKl0DAiQSwboJ1EyfOa/gEAiAAAiAAAiDgeAIQFXJ8iOEgCICAkwmkrT9E83cet52LmcNa2c5mX4MfX7qXWFzITqVvk2qUkljHTibDVgUEwokKeXa1b98+uu2226SvqlSpQidOnAg52vXr1wUhohtvvJEqVKigwLLCqleuXBHaV65cmUqVKqW4vRENzp07R2fOnKGqVatSVFSU4iFyc3PpwoULsn2CqJBixPZu4IQFA45A03VE0YnKYsFiQiwq5MYCUSE3Rh0+g4ArCWATjyvDHlGnPTeyx1VKpGebr4vo+JEYLCt3PfHBBTnFsQzy1lN6ZhoxCy7J8anULj5FDhLUAQEQcDgBJx9O8AxddLt+VPbOZOmrszvShb/7Cgl5tpFzQKL22OV07cKfhs2SU0sm0IXs3X79y7EtlFE4nGBYyGzZMQ5F2zJsMNqpBJDrdmpkQ/uFXLc74w6vQQAEbEsAz8+2DZ0lDUd+3jssyM9bcprCKBAAARMIIG/v/QIA5O1NmIQY0hUEsB/JFWGGkyBgfwJYN7F/DNV4gHUTNdTQBgRAAARAAARAwEIEICpkoWDAFBAAARBQSuCLvb/TqPRMpc1MrT+sVQwNbRljqg16DG5HUaGJyfHUveEteriPPixIQImoEJvfvn17Sk8vPKjE5dixY1StWjUvzy5evEhTpkwR6vEmtIKCAuF6TEwMNWvWjEaMGEFt2rQJSuPatWs0b948mjlzJm3btk2qx22SkpLoueeeo/z8fHr55ZeFa2XLlqX58+dL9bKzs+nFF1+UPvfv358efvjhgOM98cQTdP78eeFa69atBdsCla1bt9Lbb79NO3bsoIyMDKlKixYt6MEHH6RXXnmFSpcuHbAtCyMtXbqUpk2bRhs3bvSqw8JMTz31FA0cOJDq1q0rXZs1axatWbNG+Lx//37au3evdC05OVnw2bP885//pBo1alhwhsEkxQScsmDAgkIsLKSkHEwjykpV0sI5dbFg4JxYwhMQAIGQBLCJBxPEaAKehxbEsZwoODPqu2KyULLQDvvvpOKWGDspZvAFBCJJwC2HE9QwlSPcY7Q4T9ZL99CVM/4C5XJsC+Wz0Xar4Y025hHAoWjz2GNkEPAjgFy3OycFct3ujDu8BgEQsC0BPD/bNnSWNNwtuVvk573XHJy4BmPJHxiMAgEbE0DePnjw5OTGjc5/I29v4x8XTPcigP1ImBAgAAK2IIB1E1uESXcjsW6iO1J0CAIgAAIgAAIgEFkCEBWKLG+MBgIgAAK6Eth/6hw9uugXunT1mq79GtmZU0SFNuXkEwsL2aWUKn4DfdXrDqpfObBYil38gJ3BCSgVFRowYAB9+OGHUof79u2jhIQE6fP27dvpySef9BLBCTT6Sy+9RK+//jqVLFnS7/Lw4cNp6tSpQY1u2LAhjRw5kvr16yfUKVeunCAyJJZffvmFGjVqJH1mwR0WIgpUihUrOozbq1cvWrhwoVe1S5cu0RtvvEGvvfZayGkUFxdHixYtIhYZ8ix//vmnIDq0YcOGsNOQhYf++te/CvU6d+5MK1asCNtGrHD27FkqU6aM7PqoaGECTlkwYMRxqUSxKcpgb0siyluvrI0TamPBwAlRhA8gAAIyCGATjwxIqKKZQKCDC9ypkza2Z+Wup9lbk0KycpqgUFbeepq9xd9nfttzcnwKxbGoJQoIgIDrCeBwQvApgMMJrv95uAYADkW7JtRw1A4EkOtGrtsO8xQ2ggAIgIDLCeD52eUTwAD3kZ8vhIr8vAGTC12CAAjYlgDy9sjb23bywnBbEcB+JFuFC8aCgHsJYN0E6ybunf3wHARAAARAAARAwMYEICpk4+DBdBAAARBgAk8s3Usbc4pEOKxOJXNYK6ubKMs+u4kKtYopT//q1lCWb6hkTwJKRYWaNWtG27Ztk5zNzc2l6Oho4TP/vU6dOlRQUCALxqRJk4jFhTzL22+/TS+//LKs9mIlI0WF3nzzTRozZowse9iOw4cPU8WKFaX6zz//PLGokdzCgki33367IlGhKlWq0IkT/m95lzsm6lmMgJMWDBgthIXkTTCICsnjhFogAAK2J4BNPLYPoW0c4IMLXNIzvd+YywI08dGJwoZ+uxf2TfTT1xcnHVhgMaH0zDRiISXPAjEhu89g2A8CxhDA4YTgXOWICtUeu5yuXfjTmOAQ0aklE+hC9m6//uXYFsooo9/UbBgQdGwIARyKNgQrOgUBdQSQ6yZyo4g+ct3qfi9oBQIgAAImEcDzs0ngHT4s8vMpwksOnFCQn3dCFOEDCJhPAHl75O3Nn4WwwA0EsB/JDVGGjyDgAAJYN8G6iQOmMVwAARAAARAAARBwHwGICrkv5vAYBEDAYQSm/PcIzdpy1BZetYwpT585SNjm8aV7icWF7FAGt6hJI+6tZQdTYaNKAkpEhRYsWEB9+vSRRvIV8/EV0ElOTqYpU6ZQw4YN6eLFi7R27Vrq378/nTx5UuojJyeHatasKXz+8ccf6b777vPyhMd79tlnKSYmRhAzmj17Nn377bdedYwSFTp06BDFxsZ6jcXj9+jRgypUqEBs+/jx42nOnDlSneHDhws+c7l8+TKVLFnSq/3ixYupdevWVLlyZdqzZw999tlnUn2uOG3aNBo2bJjA4vjx40Lbr7/+mpi9WKZOnSox4+9Y1Kldu3YqZwCaWY6A0xYMRMAsLlSxLVF0YuE3ef87FH6w8MA/NV3nHQq3HbbAQQvL/RRhEAiAgDEEsInHGK7oNTgBN7wVWRROysr7gZLjCsWSWHDH7gWHFeweQdgPAuYQwOGE4Ny1CvcYGVGttkFUyMjo2K9vHIq2X8xgsYMJINddGFzkuh08yeEaCIAACNifAJ6f7R9DK3uA/LyVoxPaNuTn7Rs7WA4CViSAvD3y9lacl7DJeQSwH8l5MYVHIOBIAlg3wbqJIyc2nAIBEAABEAABEHA6AYgKOT3C8A8EQMDxBNYfOkP9l++zhZ/DWsXQ0JYxtrBVjpF2EhX6sEsDSqxTUY5bqGNTAr6iQm+88Qa1adNG8iY/P5+OHj1Ky5Yt8xPzSUtLo3Hjxgl1WQCnevXqUjsWEtq+fbufqM7GjRvpnnvukepNmDCBRo8eLXweNGgQvf/++9K1sWPHCqI9nuXChQvUuXNnSk9Pl742SlSIxX3effddaZxFixZRz549/SLdsWNHWr16tfT9pUuXqESJEn5MhgwZQjNmzPBrn5qaKogusf+1a9f2u/7OO+/QiBEjpO8zMjKoXr16Np1xMDssAacuGIRznMWG3CwsBFGhcDME10EABBxCAJt4HBJIG7rhhsMLNgxLUJMRLydFE76AQGQJ4HBCcN5ahXuMjKRW2yAqZGR07Nc3DkXbL2aw2MEEkOsuCq6bhIWQ63bwjxqugQAIOJEAnp+dGFXr+YR8r/ViEsoixMte8YK1IGAHAsjbI29vh3kKG+1PAPuR7B9DeAACriCAdROsm7hiosNJEAABEAABEAABpxGAqJDTIgp/QAAEXEfg3OWr1OuLvbTn5J+W991pokKbcvKJhYWsXm6/pQwt7N6QypSMsrqpsE8DAV9RIbldxcXFEW8wq1ixUHTqhx9+oMTERKl5MAEertCkSRPatWuXUPdvf/sbzZs3T/h7rVq1KCcnR/g7CwUdO3aMypQp42dSZmYm1a1bV/reKFGhpKQkWr9+vTAO+8vjBiorVqwQhI7EcuDAAcG+c+fOednfokUL+uqrr6hGjRpyMQv1ICqkCJf9K7t1wYAj52ZhIRy0sP9vFx6AAAjIIoBNPLIwoZKBBLAZ3kC4OnTNbz+evSXJr6e4SomUHJ9Ccfy8iAICIAACIQjY4XDC+f2bIhbDI5N7S2NpFe4x0mittkFUyMjo2K9vHIq2X8xgsYMJINftHVy3CAsh1+3gHzVcAwEQcCIBPD87MarW9Qn5eevGhi1Dft7a8YF1IGBnAsjbe0cPeXs7z2bYbmUC2I9k5ejANhAAAYkA1k2wboKfAwiAAAiAAAiAAAjYkABEhWwYNJgMAiAAAr4EJvyYTXO3HbM8mMxhrSxvo1ID46dvVNok4vUHNK1Or7S5NeLjYsDIElAjKtSvXz96/fXXqXr16pKxH374IQ0YMED6PG7cOIqNjQ3ozNSpUyVRIRba2bx5M12/fp1uuOEGqX6HDh1o1apVAdtz3QoVKlBBQYFw3ShRofLly0tjxMTE0Pjx4wPak52dTampqdI1tpvt55KQkEAZGRle7dq0aUMNGjSg+Ph4QXzo3nvv9WLpOwhEhSL7mzB9NDcvGDB8twoL4aCF6T89GAACIBAZAtjEExnOGCU0AT64wCU9s+gZnj+zcE18dCK1i08BwggT4MMK6ZlplJVbKOoqFogJRTgQGA4EHEDADocTIonZk4dW4R4j7dZqG0SFjIyO/frGoWj7xQwWO5gAct1ETdd5B9gNwkLIdTv4Rw3XQAAEnEgAz89OjKq1fUJ+3nrxQX7eejGBRSDgNALI23tHFHl7p81w+GMVAtiPZJVIwA4QAIGQBLBugnUT/ERAAARAAARAAARAwIYEICpkw6DBZBAAARDwJbD+0Bnqv3yfpcG0jClPn3VraGkb1Rj3+NK9tCknX03TiLX5qEsDalunYsTGw0DmEFAqKvTpp5/Sk08+6WfsmDFj6M0331TsRJUqVejEiROUn58vCAWJZciQITRjxoyg/T300EP07bffCteNEBU6e/as0K+a8sknn1Dfvn2FpitXrqRHHnkkbDcsNPTBBx8IYkO+BaJCYfE5q4LbFww4mm4UFsJBC2f9juENCIBAUALYxIPJEQkCLBaUHO8tGBRoXLwVORLRCD2GHocVRCEiFiBCAQEQAAEcTvCeAzicgN+EGwngULQbow6fLUsAuW7kui07OWEYCIAACICASADPz5gLehNAfl5vosb1h/y8cWzRMwiAQPA8tZXYmCVWj7y9lWYBbHESAexHclI04QsIOJgA1k2wbuLg6Q3XQAAEQAAEQAAEnEsAokLOjS08AwEQcBGBS1ev0dNf7aONFha3GdYqhoa2jHFcVN7dlEPTN+ZY1q9WMeVp3qO3UYmoYpa1EYbpQ8BXVIiFeu6//36pcxYKSklJkT536tSJvv76a7/BR48eTRMnTlRslCgqdObMGYqOjpbav/jii8RiOsFK9+7daenSpcJlI0SFfO1R4pinqBC3++abb6h///508uTJsN3s27ePEhISvOpBVCgsNmdVwIJBYTzlCgtxPf6PS976wv/sWCAqZMeowWYQAAEVBLCJRwU0NFFMYNR3xYgFZuKi20JcSDG9yDXQKurEYkLpWWnEfz7bfJ0QcxQQAAEQsKqoUK2RC00JzpHJvaVxPQ9IBONUe+xyunbhT8NsPbVkAl3I3u3XvxzbQhll1uEPw0ChY00EcChaEz40BgF9CSDXXcgTuW595xV6AwEQAAEQ0JUAnp91xYnOiAj5eXtMA+Tn7REnWAkCTiGAvL13JJG3d8rMhh9WI4D9SFaLCOwBARAISADrJlg3wU8DBEAABEAABEAABGxIAKJCNgwaTAYBEACBQARmb/0/mrThsGXhfNatIbWMKW9Z+9Qatiknnx5fuldtc8Pbvdy6Nj3bvIbh42AA8wn4igqlp6dTu3btJMPOnj1L8fHxXoI4vnW48rRp04iFgMSyZMkSqlEj/BwqVaoUNWvWjK5cuUIlSpSQ2nft2pWWLVsWFFCtWrUoJ6dQmCucqNCUKVNo+PDhfn0dPXqUYmKKRMt69epFCxcWHvK6du0aRUVFSW2Sk5MpNTVVVsDq1q1LLJbkWa5evUq7du2ijRs30oEDB+i3336j7du3Sz6IdR9++GFBhMizQFRIFnbnVMKCQVEs5Ry2iEsliv2f8NnBNKIseb9Ty00YiApZLiQwCARAwBgC2MRjDFf06k2ADy2IpV18iixhIa6vdRM94iCPAL/9ePaWJL/KLAqUHJ9CcaJgZJDuPMWExCoQFZLHHrVAwA0ErHo4wQrs5Qj3GC3Ok/XSPXTlzAk/HHJsC8XQaLutED/YIJ8ADkXLZ4WaIGA4AeS6kes2fJJhADsQOHXqlPDCmszMTDpy5Ajl5uZStWrVqE6dOtSgQQN65JFH6MYbb7SDK7ARBBxJAM/PjgyrqU4hP28q/rCDIz8fFhEqgAAIGEAAefvgUOXkxo3OfyNvb8CkR5emEMB+JFOwY1AQAAGlBLBugnUTpXMG9UEAMFvIzwAAIABJREFUBEAABEAABEDAAgQgKmSBIMAEEAABENCDwL5T52jA1/voWMElPbrTvY/MYa1079MqHcZP32gVU7zsqFa2JM3t3IBuu6W0Je2DUfoSCCcqxKPNmzePnn76aWnghg0b0s6dO6l48eLSdyyE06lTJ+nz+vXrqW3btoqMrVq1qiReFBcXJwjvFCtWdCBY7Oz06dN08803S337igplZ2cLG1HFwmJHLMzjW3xt9hQV4rpNmjQRhIC4JCYm0rp16xT5I6cyiwx16dJF8pt9+eOPP7z89hUV+uWXX+j222+X0z3q2JEAFgy8oxZOWAiiQnac5bAZBEDAxQSwicfFwY+g656HFsRh5YoLsbAQl/RMb6FCFryJj04k7gdFHQE+rJCemUYsCuRZ5IoJiXERY+TZB0SF1MUErUDAiQRwOCF4VHE4wYkzHj4FIoBD0ZgXIGAhAsh1I9dtoekIUyJP4Pjx4/TKK68I68yhCr+oZcSIEcILYjzXniNvsbwROb8pvviGWzRq1IhuuukmeY0tUGvz5s2SFZUqVSJ+WQ6Kuwng+dnd8TfCe+TnjaCqvU/k57UzRA8gAALqCSBvj7y9+tmDliAgnwD2I8lnhZogAAImEsC6iTd8nBEwcTJiaBAAARAAARAAARCQTwCiQvJZoSYIgAAIWJ7AuLUH6V+7/d8QbLbhw1rF0NCWMWabYdj4jy/dS5ty8g3rX23HjzeqSuPvj1XbHO1sRkCOqNCVK1cEgZ29e/dK3s2ZM4cGDBggfeZrnkI3vgI9nljWrFlDNWvWpNtuu82L1qOPPkrLly+Xvlu8eDE99thjfkTHjx9P48aNk773FRVie0uUKCFdZ4GijIwMioqKkr67evUqdevWzWs8X5t79+5NixYtktrs3r2b7rjjDj97CgoKhH64ve9m17y8PJo+fTrxeGx3oDJo0CB6//33pUvcpmLFitLnuXPn0sCBA6XPM2fOpMGDB9tspsFc2QSwYOCPKtSiAUSFZE8tVAQBEAABKxDAJh4rRMH5NgQ6tCB6rURcyFdYiPtIjk+FsJDCKaTHYQUWIpq9NSnoyBAVUhgUVAcBBxPA4YTgwZUjKlR77HK6duFPw2bIqSUT6EL2br/+5dgWyiij39RsGBB0bAgBHIo2BCs6BQF1BJDrRq5b3cxBKwcQ2LZtG3Xo0EF6qYocl3hNeMGCBVSyZEk51U2r4/syGF6Drlevnmn2KB3Y84U+ffr0ofnz5yvtAvUdRgDPzw4LqAXcQX7eAkHwMAH5eWvFA9aAgFsJIG+PvL1b5z78jiwB7EeKLG+MBgIgoJIA1k2wbqJy6qAZCIAACIAACIAACJhJAKJCZtLH2CAAAiCgM4H1h87Q37/ZT5evXte5Z23dOV1UiAWFWFjISqVk1A30/iP1qW2dIkETK9kHW/QnIEdUiEf97rvv6MEHH5QMYCGfI0eOUIUKFYTvWDTn7rvvJt4kKpZp06bR888/TzfccIPw1fXr1wWRnscff1z4/Oabb9LIkSMlAaCFCxdK1/g6j/HBBx9Qjx49hD5YvIc/cxvP4isqxNcSEhIEISGxvPTSS8J4LPqTm5tLY8aM8RLy4Xq+okIrVqygzp07S300bdqUWOgoPj5e+o774jobNmygFi1aEAsANW7cWLi+ZMkS6t+/v2A3l7Fjxwq2i8z4O2bIYkxiHf7u8uXLXuJEa9eupQceeEAas2HDhjR58mRq27YtlS5dWv9JgR7NJYAFg8D8gwkL8fexKYVtDqYRZaWaGz+1oz9grWcwtW6gHQiAAAiEI4BNPOEI4boeBEIdWuD+4yolUlx0W0EgKFxZk5lGEBcKRyn4da38WEwoPSuN+M9QBaJC6mOEliDgNAI4nBA8olqFe4ycK1ptg6iQkdGxX984FG2/mMFiBxNArjtwcJHrdvCkh2tM4OjRo8KLZTzXPkUyrVu3FgR4jh07Rt9++60fMF5X5bVWKxeIClk5OrBNDQE8P6uhhjahCCA/b535gfy8dWIBS0DA7QSQt0fe3u2/AfgfGQLYjxQZzhgFBEBAIwGsm2DdROMUQnMQAAEQAAEQAAEQMIMARIXMoI4xQQAEQMBAAkNXH6CVGacNHEF51591a0gtY8orb2iTFlYUFXqkfmWa3sE+b9KzSagtbaZcUSF2omPHjrR69WrJn3/84x/0xhtvSJ83btxI99xzj5e/MTExwne8YLNr1y6/DaSbN28WxHi4XLx4URAm4nq+JS4ujrKysgKyDCQq9NFHHwmCPr6lfv36XmJDntd9RYUC+czftWnThipWrEjZ2dl+tnbt2pWWLVsmdMsb8Jo3bx7QF95Mu3PnTsrJyfG6zm/tXLVqldd3eXl5dOuttwbcfCtWzMzMJGaE4gACWDAIHsRAhy3y1hPx91wgKuSAHwBcAAEQcDoBbOJxeoSt4V+4Qwuile3iU2QJC3F9rZvvrUEmclbw249nb0ny/7dQpURKjk+hOPH5LYhJcsWExOYQFYpcbDESCFidAA4nBI+QVuEeI2Ov1TaIChkZHfv1jUPR9osZLHYwAeS6ket28PSGa4EJ8AtmOnXqRCtXrvSq8P7779OAAQMoKipK+v7MmTM0YcIEmjRpklfdvXv3CqJEVi0QFbJqZGCXWgJ4flZLDu2CEUB+3vy5gfy8+TGABSAAAt4EkLdH3h6/CRCIBAHsR4oEZYwBAiCgmQDWTbBuonkSoQMQAAEQAAEQAAEQiDwBiApFnjlGBAEQAAFDCaw6cJqeX3XA0DGUdp45rJXSJrar//jSvcTiQlYpMzrWo471KlvFHNgRAQJKRIV2795NjRs39rKKhX5iY2Ol73jzJ4sNhSssBMQbSlmgx7P88ssv9MADD9DJkyeDdsFtPd9uGUhU6OrVq4KY0ZYtW4L2wyI8jRo1ouXLlwt1AokKsX+8+ZU3sIYr3H7evHlUqlQpqerUqVNp+PDh4ZpK13nTXtOmTf3q82bbQYMGBe1n3759lJCQIHscVLQwASwYhA5OIGEhsQVEhSw8sWEaCIAACBQSwCYezIRIEJB7aEG0Ra64EAsLcUnPTPVyI65SIsVHJxL3Y1aZvbVIwIcFdswqfFghPTONWBTIszAjOWJCIl+RtVw/ICoklxTqgYDzCeBwQvAYaxXuMXL2aLUNokJGRsd+feNQtP1iBosdTAC57tDBRa7bwZPfva7997//pdatW3sB2LZtG911111BoYwYMYJYqEcs/Hny5MkhIZ47d474pSzR0dFUunRpTcCvXLlCJ06coKpVq1Lx4sXD9qWHqBCPyWvhlSpVohtvvDHsmKEq5ObmUrFixQQWcgrXFUufPn1o/vz5cpqhjoMJ4PnZwcE1yTXk55GfN2nqYVgQAAELE0DePnhwtObGjQy7VtuQtzcyOug7EAHsR8K8AAEQsAUBrJuEDhPWTWwxjWEkCIAACIAACICA+whAVMh9MYfHIAACDidwnYieX5lBq3/LtYSnw1rF0NCWMZawxUgjrCQq9FDdSjSjY326oWgfmZGuo2+LEJg2bRq9+OKLkjXp6enUrl27oNY9++yz9MEHH0jXWehm1qxZXvV5c+jAgQOJ//QtVapUETaTpqSkUJMmTQKOk5OTQ7xhdPHixX7XWXDnX//6F40dO5aWLl0qXA8kKsTf84bScePG0ZQpU/z6efDBB2nOnDnCptR3331XuP7UU0/Rxx9/7Ff34sWLwpsy09IKDxH7lhYtWlDnzp3plVde8XrDplhvzZo1Qvu1a9cG5cqbNl9++WW64447gtZZtmyZsKl2w4YNfnUgKmSRH5QeZmDBIDzFYIsGEBUKzw41QAAEQMBkAtjEY3IAXDK80kMLIhYl4kK+wkLcR3J8qmnCQp4+T2zPGZ7IFj3EhFiIyFMcSYkHEBVSQgt1QcDZBHA4IXh8tR4AMHLmaLUNhxOMjI79+sahaPvFDBY7mABy3eGDi1x3eEaoYSsCvgJBvAbtKRgUyJnTp0/T3XffTV26dKEePXpQy5YtBZEc38Ivv3nvvfdowYIFfi+fefLJJ4WXs/DLZAKV119/XVq37tmzJ3Xt2lVY3+Y1XH4Jjlh4HXrAgAHE6+E33HCD9L1Yl7/Yv3+/18tokpOTqWzZsl7D/vOf/6QaNWp4fXfs2DF68803iYWXPNfQGzZsSK1atRLWtG+99VY/8w8cOECjRo2Svuf18+3bt9Onn35K3377LWVkZAjXeA2+bdu2xC8U4hfriOX48eM0dOhQYiEjLl9++aV0TVy39xw0KSmJnn/+eVvNOxirjQCen7XxQ2t/AsjPIz+P3wUIgAAI+BJA3j74nNCaGzdytmm1DXl7I6ODvgMRwH4kzAsQAAFbEMC6SfgwYd0kPCPUAAEQAAEQAAEQAIEIE4CoUISBYzgQAAEQiASBVQdO0wurf6Or1yO/wO3rn1tEhTbl5BMLC5ldit9QjKY9VJc61KtstikY30EEzp49K2xkzMzMpJIlS9Kdd94ZcDNkMJf5rZAslsObLKtVqya8xbJChQpC9e7du4cVFRL7LSgooF9//ZWysrIoJiaGmjdvruqtj9euXaMjR44Im0V5g2tsbCw1btxY9hswf//9d4EF93Hp0iXh7ZPsV506dWS/PZJ9Et++efXqVWkDKPfhubnVQdPIfa5gwcA/5g/IfC6BqJD7fi/wGARAwHYEsInHdiGzpcFqDy2ws3GVEikuuq0gEBSurMlMI6uIC5kpKqSVA4sJpWelEf+ptkBUSC05tAMB5xHA4YTgMdV6AMDI2aLVNhxOMDI69usbh6LtFzNY7GACyHUj1+3g6Q3XAhOoVasW8ctjxCKu8WrltX79emKxm3CFX/ASqN4jjzwiiQfxi2v27NnjJa7j229iYiKtXr1aWk/ml8usWLEi3PDSdV4jL1OmjPT5888/F17Iw2vWocr8+fOJX0TjWbZs2SKILomFXxDEQkahyldffSWINHHhZyNeG5dbmM/48ePlVkc9BxDA87MDgmgxF5Cfl7m3Qae4IT+vE0h0AwIgYCgB5O2D49WaGzcycFptQ97eyOig70AEsB8J8wIEQMAWBLBu4h8mnBGwxdSFkSAAAiAAAiAAAu4mAFEhd8cf3oMACDiYwIhvf6Ov9p0y3cPMYa1MtyESBlhFVKjrbTfT5PZ1I+EyxgABXQgoERXSZUB0AgKRIoAFAywYRGquYRwQAAEQMIEANvGYAN2FQ2o5tCDiahefIktYiOtr3bSvR4jMEBXKyltPs7f4H+hjYabk+BSK4zdHhSh6iAmJ3UNUSI9ZhD5AwBkEcDgheBzlHACoPXY5Xbvwp+zJcGrJBLqQvVt2/WAV5dgWahAcTtAcAkd1gEPRjgonnLE7AeS6keu2+xyG/YoI8AtVSpUqJbWJi4sTXraitcgVFBLHCSQs5CkqJNeeN998k1555RWhuhJRoSpVqhC/OEcsP/74I913331yh6Wff/6ZWrUq2ivjKyokp6Ny5cpRdna28FIbpaJCH3/8MT311FNyhkEdhxDA87NDAmkhN5Cfj4yoEPLzFpr0MAUEQCAsAeTtgyOSkxtH3j7sFEMFEBAIYD8SJgIIgIAtCGDdxD9MEBWyxdSFkSAAAiAAAiAAAu4mAFEhd8cf3oMACDiYwI/ZZ2jEd5l0+txl07xsGVOePuvW0LTxIz3w40v3EosLmVUq3VSCpjwYT/fdWtEsEzAuCCgmAFEhxcjQwC4EsGCABQO7zFXYCQIgAAIqCGATjwpoaKKYgB6HFsRB5YoLsbAQl/TMVC97WWAnPjqRuB8jSyRFhfiwQnpmGrEokGeRKyYkchKZ6cEFokJ6UEQfIOAMAjicEDyOcg4nKBXnyXrpHrpypujAtNpZJMe2UH0rtVutnWhnDwI4FG2POMFKlxBArts/0Ngc75LJ7043Oe9Xs2ZNyfkOHTrQqlWrNMFgUaK6db1fjNSjRw96/vnnqU6dOnTw4EGaMWMGLVmyxGucAwcOeLULJCrUuHFjGj16NLVs2ZJOnTpFU6ZMocWLF3v1k5eXRxUrViQWBjp+/Lhw7euvv6YFCxZI9aZOnerlNwv5tGvXTrh+5coVatKkCe3du1eq/8ILL9BLL71ENWrUIO7/k08+oRdffFG63rRpU9q8eTNFRUUJ3wUTFWLbO3XqRFWrVhWEiAYPHkwFBQVSP6mpqZSSkkK5ubn0/fffS98zP7G0bt2ahg0b5uUzf8e2obiHAJ6f3RPrSHmK/LyxokLIz0dqJmMcEAABPQkgbx+cppzcuNL8N/L2es5e9GUnAtiPZKdowVYQcDEBrJv4Bx/rJi7+QcB1EAABEAABEAABuxCAqJBdIgU7QQAEQEAFgQk/ZtPcbcdUtNSnybBWMTS0ZYw+ndmgF7NFhQY0rU6vtLnVBqRgIggUEYCoEGaDYwlgwUC/0FZKJqr0AFH5FkRl7yrs9+x2ovwtRLnfE+Wm6zeW1p7kLopoHQftQQAEQMBkAtjEY3IAXDI8C/voKVjD2JSIC/kKC3H75PhUQ4WFIiEqpMdhBRYimr01SdeZyGJGLCqEAgIgAAJMAIcTgs8DHE7Ab8QtBHAo2i2Rhp+2IIBct35him5LVPkhooptiErVKuz34hGiMz8Snf43Ud4P+o2ltSfkurUStG37Xbt2CQI6Yhk0aBDNmjVLkz/jxo2j8ePHS328/PLLNHHiRL8+R44cKYgCieXVV1+l1157TfrsKypUv359+umnn+iWW27x6ispKYnWry8SUWZxnxYtWnjVeeedd2jEiBHSdxkZGVSvXr2Afi5btoy6desWlsnkyZMFoSGxbNiwge69917hYyBRoZkzZwoiQp7lhx9+oMTEROmrhx9+mL755hs/u4oVKyZ916dPH5o/f76mGKGx/Qng+dn+MbSaB8jPGyMqhPy81WY67AEBEFBCAHn74LSQt1cyk1AXBEITwH4kzBAQAAFbEMC6iX5hwrqJfizREwiAAAiAAAiAAAiEIQBRIUwREAABEHAwgf2nztGoNZm0+8SfpnjpNlGhTTn5xMJCZpTGVcvSW8lxlFC5tBnDY0wQUE0AokKq0aGh1QlgwUB7hIqXJ6o1lCjmOaKS1QL3d+k4Uc5MoiPvEl3J1z6m1h5w0EIrQbQHARCwCQFs4rFJoBxgJovXZOat11VciMVr4qLbCgJB4QqLGkVSXMhoUSGt/nA80rPSiP/Uq3A8kuNSiP9EAQEQAAGRAA4nBJ8Lcg4n1B67nK5dkL8mcGrJBLqQvVvzBJRjW6hBlL6pWbPB6MDSBHAo2tLhgXFuI4Bct/aIFytOVOcVoltfJooqG7i/q2eJsicRHZpAdP2K9jG19oBct1aCtm2/fft2atq0qWQ/C++wWI6WkpCQQCzaw6VcuXLEucWyZf1/CwUFBVSzZk3iP7k0bNiQ9uzZIw3tKyrEYj9du3b1M23JkiXUo0cP6fuFCxdSr169vOopERViQSQWRhJLTk6OYKdvyc3NpcqVK0tff/zxx/TUU08Jn31FhXx98+wrPj6esrKyhK/i4uL+P3vnATZFdfbvRwFBQBCwIk2KIpaIYiyJHewajb2LjYgFjRr9bIjBaKxYYouF2Bs21KiYgC22/I29gKAIfIo0OwEE/tdv/GadnXfLzOzM7s7Ofa7LC993z5xyP/PunHnO8/yOTZ48uUlfiApVckc25rWsnxvTrrWeFf75eC2Afz5enrQGAQhUnwB+++LMg/jG8dtX/56lx3QSIB4pnXZj1BDIHAH2TSo3OfsmlTOkBQhAAAIQgAAEIBCSAKJCIYFRHQIQgEDaCNz19kw7b/wnNRn25GGb1aTfWnba66pXatL9BduuaQdvsGpN+qZTCFRCQCcn3nnnnU4Tq6yyis2cObOS5rgWAvVDgA2DymyhzYJeF/6UZBGkKNli8tm1T7Yg0SKItagDAQg0AAGCeBrAiCmbQi1PRRaqSoP9g+JOSlRIpx/f+Pq2TYbhCPr0Gm49O5QW9EFMKKgFqQcBCMRFgOSE4iSDJCfEZYew7VQ6NkSFwhJv7PokRTe2fZldygjg667MYBLP73GOWffTg7Uz9VKzT0fWXkQfX3cwezVgrY8//tj69OmTm9nhhx9uo0ePrmimXgGcHXfc0Z566qmi7e2www42bty43OdLly7N/b9fVOjTTz+17t27N2nLL+AzatQoGzZsWF69MKJC3v1sNSKxoGJl8ODBuY/OPPNMu+iii5yf/WM65phj7KabbirYjH+eXgbuBYgKVXRLNuTFrJ8b0qx1Myn885WZAv98Zfy4GgIQqB8C+O2L26JS33iSVq50bPjtk7QObRciQDwS9wUEIJAKAuybVGYm9k0q48fVEIAABCAAAQhAICIBRIUiguMyCEAAAmkhsGjxUjv7n1NszPuzqjrkTbu0s7v37lfVPuuhs4PGvG+vTv+mqkP57Tor24Xbr2nLNVu2qv3SGQQgAAEIlCDAhkFlt0fno8zWuTlcGx8cbfa/t4S7Ju7aJFrETZT2IACBOiVAEE+dGiYDw6pl8oKEhVQ0Bm+RME+vDtvYwF7DK7ZA3KJCSlYYN3mESRTIP+YgYkLufN25VzzB/2tArAb1yucYV9u0AwEINAYBkhOK27HSBIAk75BKx0ZyQpLWSV/bJEWnz2aMuIEJ4OuuzLhrHGvW98ZwbXw4xGxGYbGRcA1VUBtfdwXw0n3pwoULrWXLlrlJbLnllvb8889HntS3335r7dq1y11/wgkn2DXXXFO0vaFDh9r111+f+/y7776zNm3aOD97xXZWWGEF++abwnEZH330kfXt2zfXxpVXXmknn3xyXp9hRIV++ctfOqJAYcsRRxyREyDyiwpdd911dtxxxxVs0i9ihKhQWPLZrM/6OZt2r/as8c+HI45/PhwvakMAAvVPAL99cRtV6htP0vqVjg2/fZLWoe1CBIhH4r6AAARSQYB9k8rMxL5JZfy4GgIQgAAEIAABCEQkgKhQRHBcBgEIQCBNBN74/Fs7+x+f2MQ5P1Rt2MM262Inbdqlav3VS0dXvzrdrnpletWGs/ZKrW3kdmvaRquvULU+6QgCEIAABAIQYMMgAKQiVVquYbbePWYrbhmuja9eMHv3QLMFM8JdF2dtEi3ipElbEIBAHRMgiKeOjZORodU6ecEvLCTsEsmpVFgoLlGhOJIVJER047+3jfWOkgDTkAHjY22TxiAAgcYkQHJCcbtWmgCQ5B1T6dhITkjSOulrm6To9NmMETcwAXzd0Y3boqPZeveZdRwYro25z5q9u7/ZornhrouzNr7uOGmmrq2uXbva9Ok/xTysssoqNnPmzMhz+Oqrr6xDhw6560855RSToE+xos9HjRqV+1jCQRIQUvGKCpUaV9yiQhtvvLG98cYboRmUEhW69dZbbfDgwQXbRFQoNGouMDPWz9wG1SSAf740bfzz1bwb6QsCEKgmAfz2xWlX6htP0o6Vjg2/fZLWoe1CBIhH4r6AAARSQYB9k+hmYt8kOjuuhAAEIAABCEAAAhUSQFSoQoBcDgEIQCAtBO56e6YNn/CJLV1anRHfvXc/27TLzyfOVafX2vfy6vRv7KAx71dtIBdsu6YdvMGqVeuPjiAAAQhAICABNgwCgipQrdPOZhs+Ge36N3cxm/P3aNfGcRWJFnFQpA0IQCAFBAjiSYGRMjBEid5MnjfBnp08IrbZSvSmZ4etHYGgckX9xi0uFIeoUKXjEtdxU0aY/o2riOugnsNN/1IgAAEIBCFAckJxSpUmAAThH7VOpWMjOSEq+ca8jqToxrQrs0opAXzd0Q3XcXuz/s9Gu/4/A83m/iPatXFcha87DoqpbWOnnXayp59+Ojd+PZc32mijsvOZMWOGde7c2ZZZZplc3cWLF1vz5s1zP++111720EMPFW1rzz33tEcffTTv+mWXXdb5uVaiQnvssYeNHTvWGYMEjp566qmyLFRBwke9e/d26r7++uv2y1/+MncdokKBEFIpBAHWzyFgUTUWAvjnC2PEPx/L7UUjEIBAnRLAb1/cMJX6xpM0eaVjw2+fpHVouxAB4pG4LyAAgVQQYN8kupnYN4nOjishAAEIQAACEIBAhQQQFaoQIJdDAAIQSBOBERM+tdvf+qIqQ548bLOq9FOPnfS66pWqDOvQX6xm52/Toyp90QkEIAABCIQkwIZBSGCe6t1+b9bn8mjXTzrV7LPiJ9xGazTEVSRahIBFVQhAIM0ECOJJs/Uab+y1PBVZNCtNEvBapBJRIZ1+fOPr2zYxsCPo02u49exQWtAHMaHG+9tgRhBIMwGSE4pbr9IEgCTvi0rHRnJCktZJX9skRafPZoy4gQng645u3G4nm/W5Mtr1k04x+2xUtGvjuApfdxwUU9vG8OHD7YILLsiNf/fdd7fHHnus5Hzmzp1rnTp1sp49e9pxxx1nBx10kCMwpNK1a1ebPn268//6fNKkSeYKBXkbXbJkiXXv3j1Xt0uXLjZt2rRclSRFhd59911bd911C87xD3/4g1166aW5z+bPn2+tWrUKZd8kRYX2228/u++++0KNh8qNR4D1c+PZNC0zwj//k6Xwz6fljmWcEIBAJQTw2xenV6lvvBK7lLu20rHhty9HmM/jJkA8UtxEaQ8CEEiEAPsm0bGybxKdHVdCAAIQgAAEIACBCgkgKlQhQC6HAAQgkCYCU+bNtz8+N9Wen/pVosMetlkXO2nTLon2Uc+NHzTmfXt1+jeJDnGr7ivauVt3t54dlk+0HxqHAAQgAIGIBNgwiAjOzNYcbtbz/GjXTznf7JMR0a6N4yoSLeKgSBsQgEAKCBDEkwIjZXCItUxekLCQisbgLRL06dVhGxvYa3ggi0QRFVKywrjJI0yiQP6+g4gJueN25xBooAEqac6DekVc0wVonyoQgEBjEyA5obh9K00ASPLOqXRsJCckaZ30tU1SdPpsxogbmAC+7ujGxdcdnR1X1pT1CvXyAAAgAElEQVTAnDlzbM0117Rvv/02N45Ro0bZSSedZMsss0yTsS1cuNAOPfRQu//++3OfHXHEEXbbbbc5Pw8ePNhGjx6d++yOO+6wQw45pEk7t99+ux1++OG53x955JF2yy235H6OU1To5ptvtmOOOSbX9l/+8hcbOnRoQe433XSTDRkyJPfZjTfeaMcee2yTukuXLrW7777bdtllF+vQoUPe53GLCrVr1y5nnxVWWMEk6tS8efOa3jd0XlsCrJ9ry5/ef/KN18rHjH++6R2If56/SghAIAkC+O2LU63UN56Evdw2Kx0bfvskrUPbhQgQj8R9AQEIpIIA+ybRzaT8AO2dRCnkCEShxjUQgAAEIAABCEAgRwBRIW4GCEAAAhkj8NzUr2zkc1NNAkNJlayLCklQSMJCSZU1O7Syc7fqYVv3WDGpLmgXAhCAAAQqJcCGQXSC3X5v1ufyaNdPOtXssyuiXRvHVYgKxUGRNiAAgRQQIIgnBUbK8BBrnbzgFxaSKSSuE0RYKIyoUBxiQhIiuvHf28Z6t0hIaciA8bG2SWMQgED2CJCcUNzmlSYAJHk3VTo2khOStE762iYpOn02Y8QNTABfd3TjcuJudHZcWXMCl19+uZ122ml549h9990d4Z11113X1lhjDUfI5qWXXrKLL77YXnnllby6kyZNst69ezu/e/75523rrbfO+1yCQxIiatasmS1evNgkKCQRIW957rnnbKuttsr9Kk5RoX/+85+2/fbb59ru16+fXXbZZc44W7dunTeOGTNmWJcuPx+qJRGfhx56yAYOHJirt2jRIjv11FPtmmuusVVWWcUkPLTnnnvmPo9bVOjXv/61w94t5513nsPTZV7zG4gBVJ0A6+eqI6fDIgTwz29jQcX+8c/zZwQBCKSNAH774har1Dee5L1Q6djw2ydpHdouRIB4JO4LCEAgFQTYN4luJvZNorPjSghAAAIQgAAEIFAhAUSFKgTI5RCAAATSSODed7+0P70w1b5fuDiR4d+9dz/btEu7RNpOQ6NJigq1Xa6Z/c+W3e2A9VZJAwrGCAEIQCC7BNgwiG77lX9rtsGYaNe/vbfZrIeiXRvHVYgKxUGRNiAAgRQQIIgnBUbK+BAVjD953oRYT0aWWE7PDls7AkHlik5GjiIuFFRUKGr77rjFZ9yUEaZ/4yriM6jncNO/FAhAAAKVEiA5oTjBShMAKrVNqesrHRvJCUlaJ31tkxSdPpsx4gYmgK87unFX2t3sF49Fu/6tPcxmj412bRxX4euOg2Kq25g/f74NGDDA3n8//GFKF154oZ111ll58z/ssMPsjjvuaMJkrbXWsokTJzb5/UEHHWR33XVX3u/jFBWaN2+ede/e3b799tuidpo8ebL17NnT+fzSSy+1P/zhD3l1N9hgA+vTp4999tlnJtEgb5EI0bvvvmvt27d3fh23qNDIkSPt3HPPLTr2Y4891hE2omSHAOvn7Ng6DTPFP1/aSvjn03AXM0YIQKAQAfz2xe+LSn3jSd5xlY4Nv32S1qHtQgSIR+K+gAAEUkGAfZPoZmLfJDo7roQABCAAAQhAAAIVEkBUqEKAXA4BCEAgrQSueXW6jXpleiLDnzxss0TaTVOjB4153yQuFHc5ebMuduKmP5+CF3f7tAcBCEAAAjERYMMgOsjlVjHr/4xZ21+Ea+O7t8z+s4PZwi/DXRdnbRIt4qRJWxCAQB0TIIinjo3D0PII1PJUZA0krPhPOVGhKfMm2I2vb9vEyo6gT6/h1rNDaUEfkhX4A4EABNJCgOSE4pbyBvDP/+jVujLp8mtvmhtPFBuSnFBX5qz5YEiKrrkJGAAEfiaArzv63dCsjVn/f5i1//kZGaixr181+8/2Zou/D1Q9kUr4uhPBmrZGv//+ezvzzDPt2muvDTz0a665xk444YQm9SXes/fee9u4cePKtrXddtvZww8/bO3a5R9kFaeokAZxww032HHHHVd0PB9++KGtvfbazucLFiyw/fff3x599NGy4+/Xr58zz86dO+fqxi0qJNv07dvXpk8vHPNzyCGHFBRxKjt4KqSWAOvn1JquoQeOfz7fvPjnG/p2Z3IQyASBKD7fTIAxM/z2WbE086wGAeKRqkGZPiAAgYoJsG8SHSH7JtHZcSUEIAABCEAAAhCokACiQhUC5HIIQAACaSWw4McldslLn9noN7+IdQrDNutiJyF6Y0mICh2x4Wp2+q+6Wavmy8ZqMxqDAAQgAIEECLBhUBnUriearXV1uDYmnmQ27Zpw18Rdm0SLuInSHgQgUKcECOKpU8MwrKIEapm8IGEhFY3BWyQE1KvDNjaw1/Dcr4uJCklMaNzkEaakA38bQcSE3P7dscR1q2jsg3rlzyuutmkHAhDINgGSE4rbPy3CO1FsmJa5Zfuvs3qzJym6eqzpCQJlCeDrLouoZIWuJ5mtdVW4NiYOM5sW0j8erofytfF1l2eUoRrPPPOMjRw50t58802TOFChcuyxx9rxxx9vG2ywQVEyixcvdgSKLrvssoJiOF26dLFTTz3VESVq3rx5k3b22WcfGzNmjPP7VVZZxWbOnFmwr48//tj69OmT++zKK6+0k08+uWDdhx56yK644gp76aWXmnzuFRVyP7z33ntt2LBh9uWXTQ+46Nmzpw0cONAuvvhi69ChQ157b7/9tv3iFz8fpnHrrbfa4MGDC45Jvx89enTus6VLlxasN3v2bDv33HNNc/CPB1GhDP2B/t9UWT9nz+ZpmjH++Z/2B/DPp+muZawQgEAhAlF8vlkhmRbfdhQbpmVuWbnXsjBP4pGyYGXmCIEGIMC+SWVGZN+kMn5cDQEIQAACEIAABCISQFQoIjgugwAEINAIBGZ9v8gu+9dn9uD7sxphOg09h336rWyn/aqbrdy6RUPPk8lBAAIQaBgCbBhUbkqJCklcKEiRmJBEhWpdSLSotQXoHwIQqBIBgniqBJpuYidQy8B9JQz4hYU0QYnyuMJCflGhOMSEJER047+3jZWlBJGGDBgfa5s0BgEIQMBLIEpge1YIpiWAP4oN0zK3rNxrtZ4nSdG1tgD9Q8BDAF93ZbeDTt3t/WezLscHa2f6X8w+PsNs8ffB6idVC193UmRT3a7EbeQXlNiORGxWXnllW2ONNax79+7WunXrwHNbsmSJvf/++46w0Lx58xwBHgkK9evXz5ZdtjYHLP3www/OWCR89OOPPzpz6dGjR9HxzJo1yyZOnGjTpk2zlVZayfr372+dOnUKzCDOirKLxrNw4ULnP5X27dvXbDxxzo22ghNg/RycFTVrRwD/fDzs8c/Hw5FWIACB8ASi+HzD95LOK9Li245iw7TMLZ13DqMuRIB4JO4LCEAgFQTYN6nMTOybVMaPqyEAAQhAAAIQgEBEAogKRQTHZRCAAAQahcDUr/5rV748zcZOnNMoU2q4eey2Vic7ZfOu1mPFVg03NyYEAQhAoGEJsGFQuWlb9TBbY4hZ58Fmy61auL2FM83+9zazGTea/ffTyvustAUSLSolyPUQgEBKCBDEkxJDMcyCBCSyM3nehFhPBVYQf88OWzsCQeVKKXEhr+iQ2ionQlSqL81z3JQRpn/jKprnoJ7DTf9SIAABCCRJIEpge5Ljqae2u552Tz0Np+hYpl12YOhxkpwQGllDX0BSdEObl8mljQC+7sotJv9212E/ieg3a1u4vcXfmUk8f9pVZvJ717rg6661BegfAhCAQCgCrJ9D4aJyDQngn48OH/98dHZcCQEIxEMAv31xjvjt47nHaAUCIkA8EvcBBCCQCgLsm1RuJvZNKmdICxCAAAQgAAEIQCAkAUSFQgKjOgQgAIFGJDBp7ny76uVp9veP5zbi9FI9p537dLSTN+tqvTsun+p5MHgIQAACmSPAhkF8Jl9pF7OV9jBb8ddmbdb9qd3v3zP76kWz2Y+ZzX4yvr4qbYlEi0oJcj0EIJASAgTxpMRQDLMkgVqeiqyBFRMXKjZoJ2Gg13Dr2aG0oA9iQtz4EIBAIxAgOaERrBh+DogKhWfWyFeQFN3I1mVuqSOArzs+k3UcZLbynmbyeUtUX0Vi+fJxz3rEbO64+PqqtCV83ZUS5HoIQAACVSXA+rmquOksBgL454NDREwoOCtqQgACyRLAb58s33ptHb99vVqmccdFPFLj2paZQaChCLBvEp852TeJjyUtQQACEIAABCAAgTIEEBXiFoEABCAAAYfAxDk/2DWvzrAnJ82BSJ0Q2KVPJztx0zVsrU6t62REDAMCEIAABAITYMMgMKrAFZutYLZMs5+qL11stvjbwJdWrSKJFlVDTUcQgEBtCRDEU1v+9B4vgVomL0hYSEVjKFaCigm57bhtxkVpYK/hNqhX8fHF1Q/tQAACEPASIDkhm/cDyQnZtHuxWZMUzf0AgToigK87AWMsY9ay80/tLvhfObwT6KPCJvF1VwiQyyEAAQhUlwDr5+ryprf4COCfL80S/3x89xotQQAClRPAb185wzS2gN8+jVZL95iJR0q3/Rg9BDJDgH2TBEzNvkkCUGkSAhCAAAQgAAEI5BFAVIgbAgIQgAAEcgSmzJtv1742wx79cDZUakxgz74r2fG/XMN6dli+xiOhewhAAAIQiESADYNI2FJ/EYkWqTchE4AABIIRIIgnGCdqpYtArZMX/MJCYcSEpsydYDf+e9tYgav/IQPGx9omjUEAAhAISoDkhKCkGqseyQmNZc9KZ0NSdKUEuR4CMRLA1x0jzBQ1ha87RcZiqBCAAATMWD9zF6SdAP75fAvin0/7Hc34IdCYBPDbN6Zdy80Kv305QnweNwHikeImSnsQgEAiBNg3SQRr3TfKvkndm4gBQgACEIAABCBQmgCiQtwhEIAABCCQR2DGNwvshn//r939zkzI1IjAgeuvar8b0Nm6tGtZoxHQLQQgAAEIVEyADYOKEaayATYMUmk2Bg0BCIQnQBBPeGZckQ4CEueZPG+CPTt5RGwDVvB/zw5b26Be55dtU/0qeUJ1dQJxuaLxjpsywvRvXMURM+o53PQvBQIQgECtCJCcUCvyte2X5ITa8q+33kmKrjeLMJ5ME8DXnU3z4+vOpt2ZNQQgkFoCrJ9TazoG7iGAf94cvzz+ef4sIACBeiWA375eLZPsuPDbJ8uX1psSIB6JuwICEEgFAfZNUmGm2AfJvknsSGkQAhCAAAQgAIHqEkBUqLq86Q0CEIBAKgh8/d8f7cb/97920//7X1u6NBVDbphBSkxoyIDO1q5l84aZExOBAAQgkEkCbBhk0uzGhkE27c6sIZBBAgTxZNDoGZtyLU9FDoIaMaEglKgDAQikmQDJCWm2XvSxk5wQnV0jXklSdCNalTmllgC+7tSarqKB4+uuCB8XQwACEKg2AdbP1SZOf0kSwD+fJF3ahgAEIBCdAH776OzSfCV++zRbL51jJx4pnXZj1BDIHAH2TTJncmfC7Jtk0+7MGgIQgAAEINBABBAVaiBjMhUIQAACcRO45Y3P7eY3Prcvv18Yd9O05yOwatvl7Kj+q9tRG60OGwhAAAIQaAQCbBg0ghXDz4ENg/DMuAICEEglAYJ4Umk2Bh2BQD0mL9TjmCKg5RIIQAACJQmQnJDNG4TkhGzavdisSYrmfoBAHRHA111HxqjiUPB1VxE2XUEAAhConADr58oZ0kL9EahHX3g9jqn+LMeIIACBRiWA375RLVt6Xvjts2n3Ws6aeKRa0qdvCEAgMAH2TQKjaqiK7Js0lDmZDAQgAAEIQCCLBBAVyqLVmTMEIACBEAQenzjHbv3P5/bWF9+FuIqqYQj8YtW2duRGq9tua3UKcxl1IQABCECgngmwYVDP1klubGwYJMeWliEAgboiQBBPXZmDwVSBQD0kCkyZO8Fu/Pe2sc62Z8dtbMiA8bG2SWMQgAAE4iBAckIcFNPXBskJ6bNZkiMmKTpJurQNgZAE8HWHBNYg1fF1N4ghmQYEIJAVAqyfs2LpbM4T/3w27c6sIQCB+iOA377+bFKNEeG3rwZl+vASIB6J+wECEEgFAfZNUmGm2AfJvknsSGkQAhCAAAQgAIHqEkBUqLq86Q0CEIBAKgn85/Nv7W9vzbSxH81O5fjredC7r72SHf6L1az/6m3reZiMDQIQgAAEwhJgwyAsscaoz4ZBY9iRWUAAAmUJEMRTFhEVGpCARH0mz5tgz04eEdvsJOrTs8PWNqjX+UXbVL/jpoww/RtXUb+Deg43/UuBAAQgUI8ESE6oR6skPyaSE5JnnKYeSIpOk7UYa8MTwNfd8CYuOEF83dm0O7OGAARSS4D1c2pNx8ADEsA/HxAU1SAAAQgkSAC/fYJw67hp/PZ1bJwGHRrxSA1qWKYFgUYjwL5Jo1k02HzYNwnGiVoQgAAEIAABCNQtAUSF6tY0DAwCEIBAfRH46r8/2u1vfWF3vDXT5s5fVF+DS+FoOrVuYYdssKodusFq1mH55imcAUOGAAQgAIGSBNgwyOYNwoZBNu3OrCGQQQIE8WTQ6Ew5R6BapyIjJsRNBwEIZJkAyQnZtD7JCdm0e7FZkxTN/QCBOiKAr7uOjFHFoeDrriJsuoIABCBQOQHWz5UzpIV0EMA/nw47MUoIQKAxCeC3b0y7lpsVfvtyhPg8bgLEI8VNlPYgAIFECLBvkgjWum+UfZO6NxEDhAAEIAABCECgNAFEhbhDIAABCEAgFIGnP55r97wz01747OtQ11H5ZwK/7tbeDlx/Vdupd0ewQAACEIBAoxJgw6BRLVt6XmwYZNPuzBoCGSRAEE8Gjc6UmxBIMnkhybYxJQQgAIE0ECA5IQ1Win+MJCfEzzTNLZIUnWbrMfaGI4Cvu+FMGmhC+LoDYaISBCAAgXohwPq5XizBOKpFIEkfepJtV4sP/UAAAhBIggB++ySo1n+b+O3r30aNNkLikRrNoswHAg1KgH2TBjVsmWmxb5JNuzNrCEAAAhCAQAMRQFSogYzJVCAAAQhUi8D0bxbYfe9+afe996XN+WFRtbpNfT8dl29hB6y3iu2/3irWpV3L1M+HCUAAAhCAQAkCbBhk8/ZgwyCbdmfWEMggAYJ4Mmh0plyUQBIJBnHi7tlxGxsyYHycTdIWBCAAgcQJkJyQOOK67IDkhLo0S80GRVJ0zdDTMQSaEsDXnc27Al93Nu3OrCEAgdQSYP2cWtMx8AoJ4J+vECCXQwACEAhBAL99CFgNVBW/fQMZMyVTIR4pJYZimBDIOgH2TbJ5B7Bvkk27M2sIQAACEIBAAxFAVKiBjMlUIAABCFSbwD8/mWdj3p9lT308t9pdp66/nXp3tH36rWzbrtkhdWNnwBCAAAQgEIEAGwYRoDXAJWwYNIARmQIEIBCEAEE8QShRJ0sEpsydYJPnTbBnJ4+om2lLTGhQz+GmfykQgAAE0kaA5IS0WSye8ZKcEA/HRmmFpOhGsSTzaAgC+LobwoyhJ4GvOzQyLoAABCBQSwKsn2tJn75rTQD/fK0tQP8QgEBWCOC3z4ql8+eJ3z6bdq/lrIlHqiV9+oYABAITYN8kMKqGqsi+SUOZk8lAAAIQgAAEskgAUaEsWp05QwACEIiRwA+LFttDH8y2hz+YZW9+8V2MLTdGU/1Xb2t79l3Z9lpnJWvTolljTIpZQAACEIBAeQJsGJRn1Ig12DBoRKsyJwhAoAABgni4LSBQmEA9nIqMmBB3JwQg0AgESE5oBCuGnwPJCeGZNfIVJEU3snWZW+oI4OtOncliGTC+7lgw0ggEIACBahFg/Vwt0vRTzwTwz9ezdRgbBCDQCATw2zeCFcPPAb99eGZcURkB4pEq48fVEIBAlQiwb1Il0HXWDfsmdWYQhgMBCEAAAhCAQFgCiAqFJUZ9CEAAAhAoSOCzr/9rYz+aY2MnzrZJc+ZnntJanVrbbmt1st3W7mTd27fKPA8AQAACEIAABCAAAQhAAAKNQ4AgnsaxJTNJhkCtkhcG9hpug3qdn8ykaBUCEIAABCAAAQhUkQBJ0VWETVcQgAAEIAABCEAAAqknwPo59SZkAjESwD8fI0yaggAEIAABCEAAAlUmQDxSlYHTHQQgAAEIQAACEIAABCAAAQhkhgCiQpkxNROFAAQgUB0CEhR6YtIce3LSHJs8N3viQr07Lm879+lku/TpaBIWokAAAhCAAAQgAAEIQAACEGg0AgTxNJpFmU9SBKqVvNCz4zY2ZMD4pKZBuxCAAAQgAAEIQKDqBEiKrjpyOoQABCAAAQhAAAIQSDEB1s8pNh5DT4wA/vnE0NIwBCAAAQhAAAIQSIwA8UiJoaVhCEAAAhCAAAQgAAEIQAACEMg4AUSFMn4DMH0IQAACSRGQoNAzk+fauCnz7K0vvkuqm7ppd8PV2trAnh1sUK+OJmEhCgQgAAEIQAACEIAABCAAgUYlQBBPo1qWeSVBYMrcCTZ53gR7dvKI2JuXmNCgnsNN/1IgAAEIQAACEIBAIxEgKbqRrMlcIAABCEAAAhCAAASSJsD6OWnCtJ9WAvjn02o5xg0BCEAAAhCAQFYJEI+UVcszbwhAAAIQgAAEIAABCEAAAhBImgCiQkkTpn0IQAACGScw54dF9o9P5tn4T76y5z79yhYsXtIwRFo0W8a27dHBtl1zRdtuzQ62UusWDTM3JgIBCEAAAhCAAAQgAAEIQKAYAYJ4uDcgEJ5AnKciIyYUnj9XQAACEIAABCCQLgIkRafLXowWAhCAAAQgAAEIQKC2BFg/15Y/vdc/Afzz9W8jRggBCEAAAhCAAAREgHgk7gMIQAACEIAABCAAAQhAAAIQgEAyBBAVSoYrrUIAAhCAQAECr0z/xl767Gt7adrX9tYX36WW0S9WbWu/6tbeft2tvW3apV1q58HAIQABCEAAAhCAAAQgAAEIRCFAEE8UalwDgZ8IVJq8MLDXcBvU63xwQgACEIAABCAAgYYmQFJ0Q5uXyUEAAhCAAAQgAAEIxEyA9XPMQGmuYQngn29Y0zIxCEAAAhCAAAQahADxSA1iSKYBAQhAAAIQgAAEIAABCEAAAnVHAFGhujMJA4IABCDQ+AS+X7jYXp3xjb06/Rt7bca39vbM+hcYkpDQJmusYL9co51t3rWdtW7RrPENxQwhAAEIQAACEIAABCAAAQgUIEAQD7cFBConEDZ5oWfHbWzIgPGVd0wLEIAABCAAAQhAIAUESIpOgZEYIgQgAAEIQAACEIBA3RBg/Vw3pmAgKSGAfz4lhmKYEIAABCAAAQhkjgDxSJkzOROGAAQgAAEIQAACEIAABCAAgSoRQFSoSqDpBgIQgAAEChNYtHipvfH5t/bmF9854kLvzPzeZny7oOa4urRraeut0sY2WLWtbbh6W+u/WltbrtmyNR8XA4AABCAAAQhAAAIQgAAEIFBrAgTx1NoC9N8oBKbMnWCT502wZyePKDoliQkN6jnc9C8FAhCAAAQgAAEIZIUASdFZsTTzhAAEIAABCEAAAhCIgwDr5zgo0kbWCOCfz5rFmS8EIAABCEAAAmkgQDxSGqzEGCEAAQhAAAIQgAAEIAABCEAgjQQQFUqj1RgzBCAAgQYm8NV/f7T3Z31vH83+wSbOmW8fz51vU+bNN/0+qdK+VXPr1WF5691xeVur0/LWd6U21nfl1tahVfOkuqRdCEAAAhCAAAQgAAEIQAACqSVAEE9qTcfA65RAoVOREROqU2MxLAhAAAIQgAAEqkKApOiqYKYTCEAAAhCAAAQgAIEGIcD6uUEMyTRqQgD/fE2w0ykEIAABCEAAAhAoSIB4JG4MCEAAAhCAAAQgAAEIQAACEIBAMgQQFUqGK61CAAIQgECMBOb990eb/vUCm/7Nf+1/v1toM79baLO+X2Rz5y+yefN/tG8X6r/FtuDHJbbgx6W2xJZas2WWsebLLmOtWzSzNi2WtXatmtuKrZpbp+Vb2MptWtiqbZazziu0tDXaLWfd2rdyPqNAAAIQgAAEIAABCEAAAhCAQHkCBPGUZ0QNCEQh4CYvDOw13Ab1Oj9KE1wDAQhAAAIQgAAEGoIASdENYUYmAQEIQAACEIAABCBQJQKsn6sEmm4amgD++YY2L5ODAAQgAAEIQCAlBIhHSomhGCYEIAABCEAAAhCAAAQgAAEIpI4AokKpMxkDhgAEIAABCEAAAhCAAAQgAAEIQAACEIBA7QgQxFM79vQMAQhAAAIQgAAEIACBLBAgKToLVmaOEIAABCAAAQhAAAJxEWD9HBdJ2oEABCAAAQhAAAIQgAAEakmAeKRa0qdvCEAAAhCAAAQgAAEIQAACEGhkAogKNbJ1mRsEIAABCEAAAhCAAAQgAAEIQAACEIAABGImQBBPzEBpDgIQgAAEIAABCEAAAhDII0BSNDcEBCAAAQhAAAIQgAAEghNg/RycFTUhAAEIQAACEIAABCAAgfolQDxS/dqGkUEAAhCAAAQgAAEIQAACEIBAugkgKpRu+zF6CEAAAhCAAAQgAAEIQAACEIAABCAAAQhUlQBBPFXFTWcQgAAEIAABCEAAAhDIHAGSojNnciYMAQhAAAIQgAAEIFABAdbPFcDjUghAAAIQgAAEIAABCECgbggQj1Q3pmAgEIAABCAAAQhAAAIQgAAEINBgBBAVajCDMh0IQAACEIAABCAAAQhAAAIQgAAEIAABCCRJgCCeJOnSNgQgAAEIQAACEIAABCBAUjT3AAQgAAEIQAACEIAABIITYP0cnBU1IQABCEAAAhCAAAQgAIH6JUA8Uv3ahpFBAAIQgAAEIAABCEAAAhCAQLoJICqUbvsxeghAAAIQgAAEIAABCEAAAhCAAAQgAAEIVJUAQTxVxU1nEIAABCAAAQhAAAIQyBwBkqIzZ3ImDAEIQAACEIAABCBQAQHWzxXA41IIQAACEIAABCAAAQhAoG4IEI9UN6ZgIBCAAAQgAAEIQAACEIAABCDQYAQQFWowgzIdCEAAAlRY/0YAACAASURBVBCAAAQgAAEIQAACEIAABCAAAQgkSYAgniTp0jYEIAABCEAAAhCAAAQgQFI09wAEIAABCEAAAhCAAASCE2D9HJwVNSEAAQhAAAIQgAAEIACB+iVAPFL92oaRQQACEIAABCAAAQhAAAIQgEC6CSAqlG77MXoIQAACEIAABCAAAQhAAAIQgAAEIAABCFSVAEE8VcVNZxCAAAQgAAEIQAACEMgcAZKiM2dyJgwBCEAAAhCAAAQgUAEB1s8VwONSCEAAAhCAAAQgAAEIQKBuCBCPVDemYCAQgAAEIAABCEAAAhCAAAQg0GAEEBVqMIMyHQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIJEmAIJ4k6dI2BCAAAQhAAAIQgAAEIEBSNPcABCAAAQhAAAIQgAAEghNg/RycFTUhAAEIQAACEIAABCAAgfolQDxS/dqGkUEAAhCAAAQgAAEIQAACEIBAugkgKpRu+zF6CEAAAhCAAAQgAAEIQAACEIAABCAAAQhUlQBBPFXFTWcQgAAEIAABCEAAAhDIHAGSojNnciYMAQhAAAIQgAAEIFABAdbPFcDjUghAAAIQgAAEIAABCECgbggQj1Q3pmAgEIAABCAAAQhAAAIQgAAEINBgBBAVajCDMh0IQAACEIAABCAAAQhAAAIQgAAEIAABCCRJgCCeJOnSNgQgAAEIQAACEIAABCBAUjT3AAQgAAEIQAACEIAABIITYP0cnBU1IQABCEAAAhCAAAQgAIH6JUA8Uv3ahpFBAAIQgAAEIAABCEAAAhCAQLoJICqUbvsxeghAAAIQgAAEIAABCEAAAhCAAAQgAAEIVJUAQTxVxU1nEIAABCAAAQhAAAIQyBwBkqIzZ3ImDAEIQAACEIAABCBQAQHWzxXA41IIQAACEIAABCAAAQhAoG4IEI9UN6ZgIBCAAAQgAAEIQAACEIAABCDQYAQQFWowgzIdCEAAAhCAAAQgAAEIQAACEIAABCAAAQgkSYAgniTp0jYEIAABCEAAAhCAAAQgQFI09wAEIAABCEAAAhCAAASCE2D9HJwVNSEAAQhAAAIQgAAEIACB+iVAPFL92oaRQQACEIAABCAAAQhAAAIQgEC6CSAqlG77MXoIQAACEIAABCAAAQhAAAIQgAAEIAABCFSVAEE8VcVNZxCAAAQgAAEIQAACEMgcAZKiM2dyJgwBCEAAAhCAAAQgUAEB1s8VwONSCEAAAhCAAAQgAAEIQKBuCBCPVDemYCAQgAAEIAABCEAAAhCAAAQg0GAEEBVqMIMyHQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIJEmAIJ4k6dI2BCAAAQhAAAIQgAAEIEBSNPcABCAAAQhAAAIQgAAEghNg/RycFTUhAAEIQAACEIAABCAAgfolQDxS/dqGkUEAAhCAAAQgAAEIQAACEIBAugkgKpRu+zF6CEAAAhCAAAQgAAEIQAACEIAABCAAAQhUlQBBPFXFTWcQgAAEIAABCEAAAhDIHAGSojNnciYMAQhAAAIQgAAEIFABAdbPFcDjUghAAAIQgAAEIAABCECgbggQj1Q3pmAgEIAABCAAAQhAAAIQgAAEINBgBBAVajCDMh0IQAACEIAABCAAAQhAAAIQgAAEIAABCCRJgCCeJOnSNgQgAAEIQAACEIAABCBAUjT3AAQgAAEIQAACEIAABIITYP0cnBU1IQABCEAAAhCAAAQgAIH6JUA8Uv3ahpFBAAIQgAAEIAABCEAAAhCAQLoJICqUbvsxeghAAAIQgAAEIAABCEAAAhCAAAQgAAEIVJUAQTxVxU1nEIAABCAAAQhAAAIQyBwBkqIzZ3ImDAEIQAACEIAABCBQAQHWzxXA41IIQAACEIAABCAAAQhAoG4IEI9UN6ZgIBCAAAQgAAEIQAACEIAABCDQYAQQFWowgzIdCEAAAhCAAAQgAAEIQAACEIAABCAAAQgkSYAgniTp0jYEIAABCEAAAhCAAAQgQFI09wAEIAABCEAAAhCAAASCE2D9HJwVNSEAAQhAAAIQgAAEIACB+iVAPFL92oaRQQACEIAABCAAAQhAAAIQgEC6CSAqlG77MXoIQAACEIAABCAAAQjESmDRokX27bff2gorrGAtWrSIte1aNvaHP/zBPv30U2cIhx9+uO266661HE4q+l66dKl99dVX1rJlS2vdunUqxswgIQABCECgOgQI4qkOZ3qBAAQgAAEINCKBJUuW2Ndff827ZiMalzlBIEYCJEXHCJOmIACBqhK4/fbb7fHHH3f63Hjjje2MM86oav90BgEIQAAC2STA+jmbdmfWEIAABCAAgXok8N1339mRRx6ZG9pFF11kvXr1qsehMiYIQKAOCRCPVIdGYUgQSCGBH374wRYsWGDt27e3ZZddNoUzYMgQgAAEIAABCEAAAhCInwCiQvEzpUUIQAACmSPwpz/9yWbMmOHMe/vtt7ff/va3oRjMmzfPzjnnnNw1Z555pnXt2jVUG1SGAAQgAIFoBD777DO7+eabbcKECfbJJ5/Y9OnTcw116dLF1lxzTdtmm23s6KOPtm7dukXrpA6u+sUvfmFvv/22M5JRo0bZsGHD8kb18MMP22mnnZb73XvvvWetWrWqg5FXbwj//e9/bcyYMXbffffZRx99ZBMnTsx1LpGpvn37Wv/+/Z17YZNNNqnewOipagT4O6gaajqCQOoJEMSTehOGnsDll19uU6ZMca7bf//9bauttgrdhtZfP/74o3PdiSee6KwtVGbNmmXnn39+rj21rT6ilNdee83+9re/OZdKGPGCCy6wtm3bOj9/+OGHds011zj/r7WNPltuueWadDN27Fh76qmnyna/0korOXNYa621rE+fPtauXbuy13grSMzz5JNPdn6lAJZTTz3VevToEaqNzz//3EaOHJlr4+KLL7Y2bdqEaiNIZe9YVf/ss8+2zp07B7k0V2fq1Kl2ySWX5H6+6qqrrHnz5iX5r7feenbccccV7Md7T6qC7qGVV1451JgKVZ4zZ46dd955uY/WXXddGzp0aMXt0gAEskzgm2++sbvuusseffRRmzRpUu554n4f866Z7N2h56rruz/ppJOa+EOS7Z3WIRCdAEnR0dlxZXIE/OviYj3pXaR79+7Ou0Lv3r2tZ8+e1qxZs+QGVictT5s2zdlLcMsdd9xhW2yxRZ2MrnrD0AEHl156qdPhb37zG3vkkUcS6Vz76TogQmXIkCG2wQYbJNIPjUIAAhCAQDoIsH5Oh52ijhL/fFNy+Ofxz0f9e+I6CEDgJwLefdNSTLSHqb3Htdde2/r162faN3P3Xotdp3jwjh075j7WOmWjjTZqaPRBfUZiKZ+R/lMc5jrrrNNQhz42tJGZXNUIEI9UNdR0BIGGIqCYf+VCvPLKK6b/d33nmqQb17X33nvbgQcemFhuwP/8z//Y/fff73AdMGCAE4sfV0nj/suLL75o99xzj4NgjTXWsLPOOisuHLQDAQhAAAIQgAAEIBCRAKJCEcFxGQQgAAEI/EzAK9SgQMk///nPofBIwMIrIjR+/Pi8oNNQjVEZAhCAAAQCEVACshK7H3jggUD1VWnfffc1Jf+uvvrqga+Ju+Lrr7+ec/brFCNtsgcp5USFlOBw2GGH5ZrSKQXLL798kKYbos61117rOOy9GymlJiZRoVtuucXWX3/9hph/o01Cgg3PP/98blo6EVsnbpQrWf87KMeHzyEAgZ8JEMSTvbvh17/+tb300kvOxFdZZRUnAENB+2HKMsssk6v+z3/+07bddlvn5yVLljhrOlfcUsKWEqCJclLUwQcfbHfffXdunBJRcIVr1KeEkN2izwoJ44wYMSJP5CjoHDVuraeUzBlk7BJ09K43FVii9XaYIv+LEkndctttt9kRRxwRpolAdf1j3XHHHe3JJ58MNE+3g3//+995wpRqU8nW/uLlr8AeiV0WKt57Up9LJOrcc88NNJ9SlSScLdEkt+y+++722GOPVdwuDUAgiwQWLlxow4cPNwmeBS1617z66qtts802C3pJZurNnj07J5as54xXtKEUhFVXXdW+/PJLp4rs4RXyyww8JppKAiRFp9JsDT9o/7o46ISVdKf16l577RVqDR20/WL1ovoIo/YrIVr57N3y7LPP5r2DRW03bddVQ1ToX//6l/3qV7/KodF7oN4HKcEJfPzxx6ZDN1Q6depk2kOiQAACEEgzAdbPabZe+bHjny/PCP98aUb458vfQ9SAQNYI+PdNw8xfB8jq4BS9SxUqWRQViuozkhC19kYPOOCAgoexhLFLLepG3beoxVjpMz0EiEdKj60YKQTqgYD8vIrT0tomSFHMm569v/vd74JUD1XnqKOOsltvvdW5Rv57ieoUKlF802ncf9lpp53s6aefziHQAVQ6iIMSjEC19/iCjYpaEIAABCAAAQiknQCiQmm3IOOHAAQgUAcEEBWqAyMwBAhAAAIhCLz99ts2aNCgXFJZiEudJPJx48bV7NTbX/7ylyZhIRWdyPf73/8+0PARFSqMacGCBTZ06NDcRkYgmP9XaYUVVrDHH3/cttpqqzCXUbcKBL755ps8EaHXXnstL4m/2BAQFaqCcegCAg1CgCCeBjFkiGn4BVyUDPvQQw+FaMGsmKiQGrnwwgtNAahukTjelltuGap9f4CqBH7UrluSFhVy+9G4Jb7Yp0+fkuOvVFRo8eLF1qNHj5wYkzqTGIee+3GXQoGwEv048cQTA3eVdNKC1qYSTtUJn1GLhEVXW221PKFNRIWi0uS6rBOYO3eu6aS/CRMmREKhE+sURE/5mcDf//5322WXXXK/WLp0aSA8iAoFwkSlOiRAUnQdGoUhWdQEMRedRPMktFPJmjWMGaL6CMP04a2bxqD2qHMtdV01RIUGDx5so0ePzhvGnDlzrGPHjklMqSHb1KnRrvjlrrvu6ux1UCAAAQikmQDr5zRbr/zY8c+XZ+TWwD9fmBX++eD3EDUhkBUClYgKiZH25d59913r1q1bE2SICoW/i3TQynPPPefsU6apRN23SNMcGWv1CRCPVH3m9AiBtBLQs1MxPUEP0/XO87zzznPEheIsQUWFovim07b/IuEkf9yc5q2D3ijBCFR7jy/YqKgFAQhAAAIQgEDaCSAqlHYLMn4IQAACdUAAUaE6MAJDgAAEIBCQgDb0119//bza2ug/4YQTrH///rbeeus5ycmffvqps/kvAaKrrrqqidP9nXfecepWuyQlKqRgidNPPz03HZ3027Jly2pPr+r97bPPPjZmzJi8fvfbbz8bOHCgIxy17rrr2qJFi5wEbTG55pprnHvCW/Sz/56q+kToMI9A1M2ErP4dcPtAAALhCRDEE55Z2q/wJy1oPjfffLMpICJoKSUq9Nlnn1n37t1zTelEqOuvvz5o00692267zY488sjcNR9++KGtvfbauZ+jiApJUFNClv6yZMkS++STT+y9996zt956yyZOnNikjsT6DjnkkKJzqFRU6JlnnrEdd9yxSftvvPGGs66PsxRLng6zDkw6aUHzve666+y4446LPHXd08ccc0ze9YgKRcbJhRkmIIEufQ/5vxv197X55ps774/rrLOOKfHd/R7Vd+b777+fR+1vf/ubHXbYYRkmmT/1qMH5esefPHmy09jRRx9d0fckxoBANQmQFF1N2vQVlIB/XXzKKac4p816i04O/fLLL23GjBnOybiuQL5b56CDDrI777wzT3Q1aP9h60X1EYbtx60vUUEdZuAWrc833XTTqM2l9rqkRYXEuVOnTk34yHevfR5KMAJREjeCtUwtCEAAArUhwPq5Ntyr1Sv++XzS+Od/4oF/vlp/gfQDgcYk4N83vemmmwoK1SpJXzFj8t/Ln+EtG220kb3wwgvWunXrvN8jKmRWyGckSLNnzzbti2vt9vTTT+dx22677ZzfNW/ePDU3XdR9i9RMkIHWhADxSDXBTqcQSB0BxbP792cU4yUfuXLblN/QuXNnZx2j+LG//OUv9sQTT+TNU6LzZ5xxRmxzv/TSS+3ee+912ttwww2dA+kKlSi+6bTtv5x99tlNBISUqzJr1qxM5GbEcVNVe48vjjHTBgQgAAEIQAAC9U8AUaH6txEjhAAEIFD3BBAVqnsTMUAIQAACDgElNGyxxRZ5iQybbLKJ3X///Y6QULEybdo0O/DAA+2ll17KVdF1cspXeyM7KVGhLN4i9913nx1wwAF5U7/nnnua/M5bYenSpXb++efbBRdckPv1zjvvbE8++WQWEdbtnNlMqFvTMDAINAwBgngaxpSBJ1IoaUEXSzDCf7JQsUZLiQrpmp122ikvePL7779vEoRaasDeMSpw5MUXX8yrHkVUSKdCfvTRR2U5KZBWAkuvvPJKXl2to7t06VLw+kpFhQqJQ6ojBcgomTTOUkxUqF+/fk7Qa6tWrcp2Vw1RIbGW2FOUd5TFixeb7K3TvbwFUaGypqUCBJoQUODdJZdckvu9gvf0/rnNNtsUpSUhIgXZK3HBLQoq++CDD2yNNdaAspkRnM9tkDUCJEVnzeLpmG+UNfxrr71mhx56aJ7Y3u233+78LumCjzBpwoXbT1pUSMkPhcSD9D6j5Ajvu3dtCKSj1yiJG+mYGaOEAASySoD1c2NbHv98afvin8c/39jfAMwOAskQCLpv6u1dBwUMHjzYxo4dm/u1kuW9h77oA0SFzInF3HfffUsaTwc66rAUbzzmRRddZGeeeWYyRk+gVfYtEoBKk0Y8EjcBBCBQjoD2apS/5j3kSHHsOrRo5ZVXLnr5U089ZarnLTokotQ15cYS5fNG900vXLjQVlpppSaHWYtVkDVSFKaNeA17fI1oVeYEAQhAAAIQqD0BRIVqbwNGAAEIQCD1BBAVSr0JmQAEIJARAkouPumkk3KzPeSQQxwl/OWWW64sgUWLFtmxxx5ro0ePztWtxcm3iAqVNVWgCgrg6N69e85pr2TNV1991dZZZ51A1//+97+3K6+8Mlf3ueees6222irQtVRKngCbCckzpgcIZJ0AQTzZuwOKJS1IaFKBji1atCgLpZyo0IMPPpgXXBkmkGDy5MnWu3fv3BgUKHLYYYfljSlocOyIESMcEUWVoKJCqisBz6uvvtpOPfXUXL/77befI6RRqERJSHbb0d+gV2Rj1113zTtRS2sBre/iKsVEhdS+1oWXX3552a6qISqkQYS5b7yDfuSRR2yvvfZqMg9EhcqalgoQyCOgJMYBAwbkfifxsX/84x+22mqrBSIlUaEhQ4bk6urv8qGHHgp0baNXIji/0S3M/PwESIrmnqhHAlHX8J9++qltsMEGOV/s4YcfnudnT2qu+AiTIlu63SRFhST637dv31yyhP9d8Pnnn7ctt9yyNhNPWa+NnriRMnMwXAhAIAYCrJ9jgFjHTeCfL28c/POlGeGfL38PUQMCWSMQdN/Uz0WHwvTs2dOUgK8iUZzrrrsurxqiQsH3K2fNmmUbbbSRTZ8+3WGovXcJVKelsG+RFkula5zEI6XLXowWArUg8Mc//tHOO++8XNcnnniijRo1ypZddtmyw/E/uyTmJ1G/apZG902PGTPGdFCeimLXNtxwQ3vhhRecn7fbbjsnfoRSngB7fOUZUQMCEIAABCAAgfAEEBUKz4wrIAABCEDAR6BWokLaoPr8888dB5ASU1q3bh3ZNhLL+OKLL2zBggWO2nT79u0jt8WFEIAABOqVQK9evWzKlCm54c2cOdNWWWWVwMOdPXt2niK/ggSUwF3NUs+iQjqRSYzEtEOHDhVhWbJkiSlw4KuvvrKOHTs6qv1xnjCs07CVvOKWkSNH2tlnnx14zO69oMCGgw8+2CRQFfReSuqZ+9133znPcq0HVl999Yp5KchF81R7q666qjVv3jwwnzgqfvvtt6a/Udm9S5cu1rJly8DN1mIzwV2XNWvWzOHfqlX5ExGDTEhrM633lDDTtWvXqtshyBipA4EsEiCIJ3tWL5a0IBIK1JAQT7lSTlRICbpaT+gZqKLkyMcff7xcs87nWsuce+65ubpqo23btnnXBg2OjSoq5HamtdHdd9+d61vBEAqK8JeoCclqRwEtZ511ltOkhI/Gjx+fJzJU6FTQQCCLVColKqRLxo0bZwMHDizZRbWSFrQ+9SZRBZ335ptvbq+88kqT6ogKBSVIPQj8RECCQBIGcsuTTz7Z5LS/cqz8z5ypU6dat27dyl2W2Odxvp/rVD6to5Topvf8FVdcMfC4axGcP3fuXMc3oWA/PaPjei+O8/3dHWObNm2cd/cgQoeBoVOxpgRIiq4pfjoPuC4OI2g5dOhQu/7663Nr+I8++igQ50p8lLXwEQaaVIFKP/zwQ96e7/LLLx+1qViuky9SzxjXP9y5c2eT3zNISVJUSKK+Wiu5ZcaMGTZo0CB7//33nV8deuihJt9/JUX3nJJD27Vr5+wHxfH8j3M95Z1bJWuKRk/cqOQe4FoIQCCdBFg/p9NuQUeNfz4oKXNiF/DPN+WFfz74PURNCGSFQNB900I8jjjiCNMBLyqF9uUqERVavHix804qn0anTp2c/yqNl0viPdfPpZJ93yuuuCLv0BrF1ZV7F4/Td5+2fYus/I1meZ7EI2XZ+swdAuUJyNes+GRX4FD72NOmTQuV+7XDDjs4cU6Kt9JBzccff3z5jmOsUW3ftJiJ19dff+3kNsjvX+n6qhQOl6/qSPBp2223td/+9re5Sz788ENbe+21IxNVrIWeFVrDKD4grkP3ktin0tpWeQCKr9fhgWHyHdO0xxfZmFwIAQhAAAIQgEDVCSAqVHXkdAgBCECg8QhUU1To9ddfd5Lnnn322VyioUtUDgFtWA0ePNj69+9fFrQCQbW5pUSXiRMn5tVXWwcccIAde+yxeadr+xu9+eabc6dlq+6ee+7pBJnq9A1tyE+aNMnZ4FLg5XvvvVd2TFSAAAQgkBSBt956y1F7d8vw4cPt/PPPD93dBRdcYLrWLW+++abpOeAtf/3rX+3hhx92frXZZpvlnQhQrMOjjz7acfKqyIm88847O/+vJHV9n7rlxRdfzH3/y6EvoSR/kbP5yiuvzPu191mlEwmGDRuW97kSiDU3leWWW84eeeSRJu0W+s5/5513TJv7o0ePzquvZLtNN93UGf+AAQMCcVaAgbgpucRV5fdeKCZK0FRic5ATFUp1uscee9jYsWOdKlE2VXSdkvWDOuPjeOZ6beTeV3K265l7ww035DaJ3DnpfteJWAceeGAg/qqkhHytC+69994m1ygQ5phjjnECEYvNW0z233//JveRxATuvPNOR4RLiR7azLjwwgvtsMMOy+vnX//6l0kE4IEHHmiyzpGIl0S1dJ/26dOnyfh222030+aPijZNtOnlFvEqJHS13377OWsntwT5O/B2/Pbbb5v+LnT/uwIQ7ucSQjryyCOd9tdcc82iNijETH8LSn656qqrcgkxbgOyw29+8xtTck5cwkWBbxAqQgACOQIE8WTvZvAmLejEJz3bJkyYkAOhNdqvfvWrkmDKiQrp4t///vd56zgJy0lEuFTR80/PRlc8U+/mN954Y5NLggbHVioqpGAVr/iFEjyfeeaZJuOJGlyq57yere6Jle7aVgEY7ho8qrBOMc6FxnrUUUflnv9a+yqJVYG9xUqSSQsbbLCBaV3ilmJCTsXGpvt3yy23zH3sbQ9Roex93zHj6AQU6K7vAffdQM8F/X2FLXq+KLDMLddee22TQL44/Q6Fxhfn+7m+ry+99FLHh+x+d3v73HfffR3RX73ze9/1FUyn56Jb9P77xhtv5H52/Sb+8eud0euHkI/FFYTWO+1ee+1V1CR6puqZpfc8nSDoL+57sfzmpQSRknx/1xj1vJPfR9/9/ndR+Yr0Hqr3bQXmUdJLgKTo9NqukUcedQ0vJrfeeqtpDe2W+fPnF/VtVeKjjNtH6Pph9ZyXf/Opp56yTz75xBEAUtFzY5111nH+3+vn089XX3219e7du+gtoWednjl33HFHnm9XF8i3KF76T0Lj/qJnqzipbLLJJoGEblVXzwf5qlW0n6znsFv0rvXoo4+a1hlPP/10kz71nqD3u3POOafkczBJUSFv4qZ8pNrH0FpJz3u3KDlASQFhitYY11xzjfP89z9bJZIrP7tOFv7ggw9ygr5bb711Xr/+/uJYT8W5pnjwwQedv0O3aG/HXZvJ3+8Va/LORUxqLXIVxpbUhQAEskuA9XNj2x7/fHD74p8vzAr/fPB7iJoQyAqBoPumhXgobtCNsSt0IGFYUSElcEu4Wfu7hQ4AkS9c+7/yeZQT23HHm8R7bql7oxKfkfY1vYe3aM/V9bW4fcblu3fbq/W+RVb+zphnNALEI0XjxlUQyAqBV1991clLcIv2Ck477bRQ01d8mfzg/twHtxHv/rq7z6GDIhSnLh+59ki0flE8keLX3eLNMfDmTsThmw67/6L6Wl9pTMUOWDvllFPy4jJCQSxS+eOPP86Lb5e/at1113X2LNy9B+2h/PnPfw7VnQ4YuOuuuxze3vgwNaKYNe33nHDCCc7ekuL+5P9X7IViCkrFDFSyT1XqftGBUZdddplpze0tWjsrFkaxlxLH8pc49vhCgaUyBCAAAQhAAAKZI4CoUOZMzoQhAAEIxE+gGqJCCuSU4IR7wkW5WUgoQ0GdxU6NVHKKBBX8gZGF2i3VljcwVE4jBVAWczDpVEsKBCAAgVoR8IsBaQO/VAJYsXF+9dVXeeIkcr5KOMdbogTNSxzITQSXE9tNsNhll11MztUw5aCDDnKcx95STlTo8ccfdxz8bin0ne3/zpfTXyIv5coZZ5zhCMiUOsl46tSpjhK/N0GwWLsapwRXothPberZJ7E7t0QVmCo3b/fzuJ65XhspYUIJAEoYce+bYuPZdddd7bbbbiuZSKENnt/97ndOAku5ogRFJWv4tTdk6AAAIABJREFUAzh0nT8wRveRNiv8olOq602MVVKO7hO/GFaxsfzpT38ynVbhLVFOjpCAkpJK3RLk70B1dXrCyJEjAwuTSShJAkOFip+Z2pYQlDa0ShXZQeJPQYQky9mUzyEAgfAECOIJzyztV3iTFvQcksjeeuutl3un1qb8u+++W/LkpyCiQn4hTCU1atO/VHnppZfykv9efvnlvAAS99qgwbGVigqpP++pUgpekBCEv0QNLlUSr1dIQm2rjyeeeMIJpnWLRJmDiluWuz/9Y5VIiASV5Vdxy957720KhClWkkxa0LpE62NXMHrHHXd0kp2DFglEK3lYRWt8+XbcABZEhYJSpB4EzBGb84oBKRlfp9BFKZtvvnkuuE2iX88//3xeM3H6Hfzji/P9XEFtQU821Huu3l1dQVh/QGRQjv6Eg3L+ELddvZvp/dX9PizVn547qucN2PTWT+r9Xc883VP+QMFCY5U4gN7xxZWSTgIkRafTbo0+6qhreHG55557TH5rt+hUUv+JpHH4KOP2Eep7VGJCEtDXM8Zf9A4nsR2VMEmDEhM/+eSTA90y8sX6v88vv/zyvESBOXPmWMeOHUu299prrznzcIt37BLikVi8Vzy3WGN6Dso3Lb9zoRJlnRIEhOa40kor5ao+9thjzp6GRJK8IkI6BEHJAEGK/Nd6n/Lv8RS6ViKIhxxyiCOspFJKQDKu9VScawoF8J9++ulBsOTqaD2hw4MoEIAABNJAgPVzGqwUfYz458Oxwz/flBf++XD3ELUhkAUCQfdNC7HwHnSiuC29b3tLGP+AfA0SwvcfCluoX+0VKE6oc+fORU2U1HtuuXuiEp+RxAn69euX60J7A954xDh99+qkHvYtyvHk82wTIB4p2/Zn9hAoR+Dcc891fNpukdhMmzZtyl0W6nPv/rpi+rWXoH10f/HHSRXbG4jDNx1mfaUxa0+l0IFH/jkobl6xeUGFG8uBPOuss+yiiy5yqmnvSOxUzjzzzFwclvzu2vcPKuY/adIkJx6u3HpR7Sp2ToI97qG8pQ6lq3SfymXhv190uHC5WEeNVfH7OszJW+LY4ytnIz6HAAQgAAEIQCDbBBAVyrb9mT0EIACBWAhUQ1RIpzIXSrRX4KI2ZF544YUmc5GokJwC/qJTM5Vg5i8KflTA6X/+858mThQl+l988cVNrvE6f5RwJhGLQkkNBB3GcqvRCAQgUAEBBcS7Ih0S45BqftSy9tpr55yz++23n9133315TUUJmi8mKnTooYc6SQthigR85Jj2lnJJdEHEVLzz0kkEmreSDdyiZHolFBQSBvKLt3jHpo3Qvn37NhG6k0NdXGQrf8KGnllKcIjiyH/vvfccEQC3KPlbmxtJlDifuV4b6TmuJBvv81/PWp1ooPn5RQMLCU2585VwodYT/oQR2XPjjTd2Ni/8JzWoL9lEdbzFv3HzwAMP5J127a3rFc+ScKKEd/xFp0C3aNHCWZt47zXVe/LJJ/MEBSQUFUQs0duH+HlPYA7yd6DriwklbbTRRqZNukKbN4WEkNSWn5mCPN1NJXesCkJSIoqfgfjr78OfgJXEvUybEIBAPgGCeLJ3R/iTFvR9raBNCcG5RQmGhYT03M+DiAqprp6/7nrKG2BQjPpxxx3nnAalonWuThEqtMkeNDg2DlGhhx56KG99JWHO9u3b500hanCpN1B33333za3xtabR6Uru81KBH9dff30sN2shUSGtR73s1ZHEMI444oiCfSaZtKB1huaue9Atb775ZlHRZ+8A/YG6Dz/8sLP2Q1QolluHRjJGQKcI67vHLTNmzCgZ3F8Kj965JcSqUsivGqffwTuOON/PJboj0TJ/0XuTTp2TUJL/HU7frfq9Ts3zfz8FvZ0WLFhgyy23XK56OX+IKuo9Ts9f/7uc2OtZrEA9//uYrtN7tITY/CWJ93cJ0CqRwu9z0Rj17qwTIQv55SsRtwrKnHrJECApOhmutFoZgahrePXqD5j2C5XE5aOM20eowPOuXbvmnst+gnr/0n6BStCgdh3movcub9H3+RZbbGFLlixx1uP+Z6TfF/rFF1/kneKqd8IhQ4aUNLB3feFNepRd9bws9BzUM0aiPXrG+MdUbK0TZZ0S5M7U2khzUNE+hBIC5DtW0bu53tFVdNKtnt1aT5Qr2v++5JJLmlTTu7XeYSVW6y3i5v6umKhQnOupONcU8r/LDx+myP5KOqBAAAIQSAMB1s9psFL0MeKfD8cO/3xTXvjnw91D1IZAFggE3Tf1s/jss8/yDp7RvqD2B70lqH/gnXfeyQkVe6/XO2+fPn0KvovrM12nfwuVJN5zg9wPlfiM/AfHeEWQ4/bd18u+RRCm1MkuAeKRsmt7Zg6BIAS8uRAS5VO8eNzFu7+uvAvlSRQqEuH3HmRbbG8gDt900PVVsYOL3PWVDu7zFx0YWyh+PSxXxSnoAAR3L0VChoorU1G8veL73aKDOPyCOoX686893TrF4hj0e43BPay4mKhQHPtU7li894va1X/eongLrekKHaCsda03nyOOPb6wdqM+BCAAAQhAAALZIoCoULbszWwhAAEIJEIgaVEh/8mLClKUwM+AAQOsVatWzpwWLVrkbCLJaeN94VbQZO/evXPznjt3rq2zzjp5SRBKXD/ttNPyhBmUvK/AQm+Sgj/xXo16nT9euAq2VGDn+uuv7yS26QW/2EZWIkahUQhAAAI+AltttVVOgEUn6CoYO2rZY489bOzYsc7lOgVICW/eEiVovpiokJIp5Gh2ixLIXIEdJQ+fdNJJTabRsmXLJmI75ZLogoipFPvOV8KxRHk0B/eZdPXVV+edlCxHtZ5P3pOEVVcnJMkef//733PzkJDSqFGj8k5WVvKeThe+++67c/WKibSUs+v48eOdhDu36MQoJQPEXeJ+5vpt5I5XvHSqtWzcrFkzh+lTTz3lnCztTfRQQMy2227bZJqXXnqp8zx3ixI8b7/99rwNjIULFzrJFTrlwi0SIpJokrf4N25kd3cMOnlAf4cSkNIJCz169HDuUyVhesel/v/61786awg3KUR9SFxr6NChufaUHPLuu+/mTmvQ34n+XlS+/vprZ/3hlueee85JEPUXjcObXBLk70CbYIcddliuKc1R49XJYW7iqgSflFAsUUhvKbSW8jPz2kG22WyzzXKiQUpSOvjgg/PWZ0pACnKSdtz3N+1BIOsECOLJ3h1QKGlBFPRM8AZIKJhCQjeFSlBRISWDukEFakfv+nouFip65qy22mq55+Pll1/e5PnjXhc0ODYOUSH5FPRMd4uSerw/6/dRgkuVtOoVNdQacqeddsr1o2eiV1y5kJhRlLu3mKjQ999/78zLm3zr98O4/SWdtKB1R7du3XL+Hq0RtaYrV4499lhnLaOi9ZXmcvbZZyMqVA4cn0OgAIELLrjAhg8fnvtEIjBBktkLwZS4vPd9Qt9Detd3S5x+B7fNuN/P5b9wk+713qR3OvlQOnTo4HSp/iZPnuyIIkuQ1i16rioAUUXPOdVTkZiCN2BRgWf+ometX3S1nD9EbRx11FF266235ppTAKYSQeR/d20owV19P3oDCuXvVqCm39eRxPu7nnm77LJLbowSsNJ6QUF27hj1/q3nvVfMSd/tEqONIsrMH3ptCZAUXVv+9F6YQJQ1vPt93r9//9y6uZAYS1w+yiR8hC4NPc9OP/105x1Ae6/ao+3evXsOVpCgdp3Qqvm7Rc8Srce15+AtEsJXILvrW1XfEpDr1KlTrpo3ecArElTIevPnz7dVV101155XENW/hlFCpJ558ve777Gyvd4VvQfQ+BMGKlmnlPub03pAfmX33UtCv9ofcMuzzz7rCOe7pZgv3NuP9nX84oDal9D+uHuys/zNakvvV36BwUL3cdzrqTjXFBqb1lZuEUOdwKyiQwzGjBnTxAzab3BjEcrZiM8hAAEI1JoA6+daWyDZ/vHPh+OLf/7nOEmXHP75cPcQtSGQBQJB9029LPRdogM+vAfjKTFdIsHeEsQ/oPczvct721LsnfYGJG6sovc4xUVpL897GNzOO+/sxD369x+SeM8Nei9E9Rmp/ZEjR+bFoyleXofjqsTtu6+XfYugXKmXTQLEI2XT7swaAkEJeN+PdSjCI488EvTSwPW8++veixTrr/WK9qe15689B+1duKVYDEMcvukg6yvFjWtsOpDALRLuueyyy3Lx5Norefnll509EO/6SnkF22yzTWBGhSoq5sEbz+Bd06j+5ptvnuuzUO6Jv00dQqGYuHHjxuU+0vpR+zuKZ3D3b7R3IX+/N97BvaCQqFCc+1Tqp9D9ovtCcRXKDXBjKWTDYcOG5cVZioPi+925xLHHV5ERuRgCEIAABCAAgYYngKhQw5uYCUIAAhBInkDSokL+hAG/g8E7w6lTpzonFquceuqpTmKB11mjYE85DdwiR5IcSoWKNq50uqbrWFGyvE4z8pZCAhMSDZDwgBL1KRCAAATqhYBXtEcCLNqEj1qU2Oder+QsJcEV+24M6rQvJirkH6N3c7tU0rj/unJJdEHEVAp955c6AVnJEApscItXdd/9nd85LeGgK664oqhpvIkSer7pmegVngli0/vuuy9P4V+nOmtzI+4S9zO3UALBQQcd5CSLK7jfX5TY6FXwl8CBhA68Rc96N0FCv1dCjDZKijGVUI4SF93y5ptvOhsCbikkkKPEGJ30JHGcQkV/PxIAkGCU/p4UcCNxhELF3/+LL76Yl4TjXqOTznWStFuCCkeV+ztQEonEitwEEs1NQZmdO3cuOF6JQHj5FEo0KcRMGz7aKPEnpqoTbWpJvNFdn+nvwH+ye9z3Mu1BAAJNCRDEk727oljSgkRrJPjj/V7WM9gN9vSSCioq5H82nHnmmSYx4EJFiaZeEaPPP/+86HM0aHBsHKJC/jnce++9juCht0QJLr3wwgvtnHPOcZrRc1giQ16RhI8//tg5udMtWjt416NR79xiokJqz5+MoDWPhAT94g1JJy3I16N1tHxBbvn000/zkpz989d3mVeI8eabb3aCc3XPSThUZffdd7fHHnssKjqug0CmCMgPq3dklUpPBZTPVr5Yt0ybNi1PVC0JUaE4388VsLfiiivmxq93LQUZFir6jpWQgoLh5FfW95hEaP3F7yN3xYbK3WTl/CH+d2clZMgHXiyB3u/rkJCU/7S9JN7fvd/NChbUKYvetYWXg4SGNQ+d+qfr9AyOKnBVji+fJ0eApOjk2NJydAJR1vDyP0qkxisgp3Wr/MBuidtH6bYbl49Q7SmwWSfHetfPfpJBgtp32GGHvABw7etKHLRQ0Qmt+i53y7XXXmvHH3987me/kI7/RFdvmxKM2WeffXK/klhR27ZtnZ/lh1QAvfyy2s/Qe2YxMTqvf17XSoze70uOsk4pd1fqHUuC9W6R+Lr2sN0iMUetH9x3cyUKyF6lioLZJXjvFiUSFPNhaw9Bz19vMkIhX2+c6ymNK4k1hTtfvUO6IlGVHsRRzn58DgEIQKAaBFg/V4Ny7frAPx+OPf55/PPh7hhqQyCbBPz7pjq0xBXE9xLRgXLaT9NawxXRdz+XMK0So/0liH/AH/+k/t09UH97ilWSAO7f/va33EfyCWy//fZ5VZN4zw16d0TxGaltCeLrfdsVVdYhgUp+V4nbd19P+xZBuVIvmwSIR8qm3Zk1BIIS8OYalIu3D9qmv14hkRgJ1gwePLhkk0H3BqL4poOsr7Q28+496TCL0047reCYZ82a5ewH6LBkxa3fdNNNTdZWYflpbaY1pkqhg+BGjx6dx1BrHcWVFCvau/EKHSk+UAc5uYff+q/zH96hzwuJCsW5T6U+Ct0vpWL2dbCu94DpYoctRt3jC2s36kMAAhCAAAQgkC0CiAply97MFgIQgEAiBJIWFfKqFitxXBtVpU4WlsCCAkG9p1e7E1933XVzp1sUEgnyA/IHmapv7+aZX2BCYgTaPCNJIZFbjUYhAIEKCLRr1y63AR1GjKdQl95k3UKCHkEd49620ygqpHm6ycaFOC1atMhxtruB9oU2MBRccfXVVzuXKzFcieBeMTx/u2rLm6SvpEIp8Ycp/sAMqfkXS8RTuwrE8J5IUKgviQn4Rfrifub6Ewi0oaFTpkqJKilhxw0qKZTUqkRJnRzhFgXB6FlerChQRese96Qs/4nQhQRyxo4da7vttltZE8n2EiQslZijJBUJ7bjBJN4Ttb0dRN1MKCcq5CZmun0pMUUJKqWK/6TvSZMmOSeZu6UQMwkkFBMq0nX+zSVtcBUSICoLnQoQgEBkAgTxREaX2guLJS1oQhK5U4KpW7Shr/WDX/QvqKiQ2lFwgQIB3DWSXzzH7UvP2CeeeML5sdw7fjVFhTQe7/q7UFBt2OBSv7ifxI8kTOgv3oBZJeC+9dZbFd93pUSF1LhfTLLQ2KohKqRgWK2V3bWSxFD17lOsnHvuuc7pn+59JhEirccQFar4lqGBjBLwJtlXmpgt/6orHC+cOo1Y75huScLvEOf7uV+0zC9I679FJCahU+cKJW24dZMSFTrrrLPyxPskfCtfRrEiMSMlNrgiBPJlaL7e534S7+8SkZBYc5BnvupoTKuvvnpJf0dG/1RTM22SolNjqkwN1L8u1lrTe+qqYGjdLl+VBE8lsKLvLnd96l93uvDi9lG67cblI1R75fx1qlMuqF3CNPpudss111zjCOqVKieddJKpnoqS7BSI7Ra/kM4ZZ5yRE4nxt+l9d5QQovtM8daTYJ383K1bty46pDfeeMM23njj3Od+X6c+iLJOKfeHdNhhh+VOry12gq8SML3viKUOE5Bgo1fMKchBFPIFS+TfLYVEheJcT6mfJNYU7vijJG6UsxOfQwACEKglAdbPtaSffN/458Mzxj+fv3eAfz78PcQVEGh0Av5907DzVSyW3lULlXL+AV3jPVRQ8VzyoZeK/5o9e7bjt3Z9LIcffrgTO+SWpN5zg3KJsu+rQ01OP/10J5nfLbfccosdeeSRzo9x++7rad8iKFfqZZMA8UjZtDuzhkBQAnHmQhTr0y8So+e1DpwvV4LuDUTxTQdZX3nHrXgx+YpK5dxpf0MHGOyyyy4FD/YtN1/v5xJK7Nu3b+5XWmsqfs1btI6T/dxSLqbLe6iVrvEfROUfn/bnFFMyceLE3Ed+UaG496nUkf9+KXXglOqLuw7WdYsO3PLnX+izqHt8YexGXQhAAAIQgAAEskcAUaHs2ZwZQwACEIidQNKiQjoZUgESbnnyySedk4bDFgXwehPUgyT5K/BXiRFuUULLgAEDcj/7RYWUTLH11luHHRr1IQABCCROwOtIl4jNiSeeGLlPBfErmF8ly6JCSqBX4HypctRRR5lOKFDRs0vPMG/RacKuAzvoxoNXrMd/qnUQo/pFhZQQWKp4ExaK1ZMQjzdYNYlnrj+B4E9/+pNpc6VUueOOO/KCWLRp4E101N+BTrhWCZp0r42MK6+80rlm9913NwV5uMW/cSNRhfHjxwcxS+A63sAaBZBceOGFTa6NuplQTlTIO3dtamhDqZQglQbmP2n9hhtusCFDhhRlNmjQIHvmmWdK8lBAjYTI3CLRq0033TQwQypCAAKVEyCIp3KGaWuhVNKC5uIVZ9HPhU47CiMq5A9kHTdunA0cODAPW9j1RtpFhfxiEsVEH+666y475JBDYn1OlhMV0hpLAhMvvPBCrt+XX37ZOdXKLdVIWlBf/gBbCU937Nix4HqpS5cuueBjCSMpCVkFUaG0fUMx3noh4BUVUtCTgp+ilv/85z95gq/VEBWK8/1cIsPeE/JKiRwEZZSUqJDXx1BMZME/RvnAvUGAfvsk8f5+0UUXOd/xblESSadOnYLio14KCZAUnUKjZWDI/nVx2Clrv1HvNvJDekvcPkq37bh8hBIN1ztfuVIuqP3BBx80nSTrFv9BLoXa13pCArJu8Qvke58P4itRfn8Soj9pzr/XW25e3s+/++67vEMBnn76adOptt4SNHEgaL965q288sq56vJ5e9/53A8kkrrmmmvm6pU6hfjee++1Aw88MFfXFeMrNSa/iFMhUaE411MaSxJrCneOURI3gtqMehCAAARqQYD1cy2oV69P/PPhWcctKoR/Pt8Gxe5J/PPh71WugECtCFQqKqRxSyhY8VP+ZPVy/gH/e67eUbW/UK54DzXzxysm9Z5bbkzu536fkUSoFVfvLYrP076l3t/lm3APKXTr6BoJ+roH2sbtu6+nfYugXKmXTQLEI2XT7swaAkEJxJkLUaxPb26c1hxTp04teTiQ207QvYEovuly66uZM2faaqutlpvSAw88YPvss09QrBXX88ZZKRZLzNw1jbfxY4891v761786vxJbifwUO+jBe1i11p3uARSlBus/sNYvKpTEPpVfVEjrwpYtW5Zkuuqqq9qXX37p1Cm2lxN1j69iY9IABCAAAQhAAAINTQBRoYY2L5ODAAQgUB0CSYsK+Z0gmtU555zjiPf06dPH1lhjjZIqyi4FfzLKJ598Yj169CgLyet8knCABAQKOX/0O228lFJ0LtsZFSAAAQgkRMDrgNR3qE6tjVq8SeMK1Jcz2luCOsa913idvzfffLNJjKdQ8Qqq6CRoiZwEKd5n1ahRo0wn5npLOTEV1fULySmBoE2bNiW7954OLBEWqfF7ize5vlgygL8DOfrHjBnj/PrUU0+1yy67LAiCXJ3bb7/ddGKTW+bPn2+tWrUq2oaXebFKflGhJJ65fhsVEhfwj++5554zCfu4xX86829/+1t7+OGHnY91z+neK1f+8pe/5E7Q9gsR+dcsSmrRZknUos0Fba7oP61b9N9tt92W20z43e9+Z9dff32T5qNuJpT7O1AAizabVJQAdP/99weamjeZRN8fCvRxi5+ZTtMeMWJEyXYXLFiQd8/q70G2pEAAAtUjQBBP9VjXS0/lkhYWLlxom2++ub3xxhu5Iev/+/fvn/s5jKiQP1nRf9qkGvUKXRZLHvXyq6aokP9ZVWh9G/bEyj333NMeffRRZ0qlRPgk6KdAEfekzqBrnFL3WjlRIV2rAFitjdx+dVqo1oTuKVPVEhXyJwwXW49dddVVdvLJJ+em7U1oRlSoXr55GEfaCBxxxBGm04lVJComcbGoRUKjO+64Y+5yifHKD+yWJPwOcb+f+9+lxUd+ZSUCdO/eveR7eCFuSYkKeX3fet8dOnRoWbP5T/Dzv58n8f7un7+eMxLhEGf5lLQWKCd6W3ZiVKgrAiRF15U5GMz/EahEVEgBz3p+de3atQnPuH2Ubgdx+Qh1+MsWW2xR9j4oF9QucXf3sAMFletU2XLl7bffzkvC84uGKgHPy7TQCbBKcHT3EYIKy7vj+vrrrx3frN535JuVuKs3cF3JfgcccEDeNKKsU0px8L+7lNqX2GmnnUxCRyqlAve9TAodHFFsPLvttps98cQTzseFRIXiXk8lsaZw5xYlcaPc/crnEIAABGpJgPVzLekn3zf++XCM8c+b4Z8Pd89QGwJZJODfN9XBbh06dCiI4quvvrIZM2aYxOUlOO8te++9txNH5H0fLOcf8L/rv/XWW00EmAsNRLFB3uT477//PpeEntR7btB7oxKfkfo46KCDnAR7b1J9Er77etm3CMqVetkkQDxSNu3OrCEQlID2A1xhviCxxkHb9dbz5hsEOSTVvTbo3kAU33S59ZXWUxtuuGFuGu+8846tt956UaYf+hqtg7RX78aLlTowWAfIKr7QLcXyJiTG6BUl0jrp6KOPLjs2CTdqveMWv6hQEvtU3vul0L5JoUHrACd3Xa1DvrUP5C9R9/jKQqICBCAAAQhAAAKZJoCoUKbNz+QhAAEIxEOgUlEhBY1269YtN5jx48fnCQDogwsvvNAREipWJNSwzjrr2JZbbmnbbbddXuKie81TTz1lO++8c0WTvvPOO+3ggw/OteF1/mhDXsGkFAhAAAL1SGDjjTfOJXkryF3B7lGLvgfvvvtu53K/mIx+F9Qx7u0/baJCheZdiOcNN9xgxx13nPORX1RIDnQ3yTqqLY455hi76aabQl3+wgsv2FZbbZW7ZtKkSda7d++ibchxrYQJf5G4jdoqdB8k8cz1JxAEOcn6vffey9sY+fzzz/NOYwgimFQKrj/5xb9xE/Q0LbcPiSCNHTvWScBX0qz/VCr/WKotKqTNHG3qqOiUQa3PghRvYtSRRx5pt9xyS+4yP7NCiT+F+vAGz+j0CAUqUSAAgeoRIIineqzrpadySQsap8QT+/btmxuy1j56prnBj2FEhdTIyJEjTWJ0btFmuZId3eL1RSjgQkEJpUo1RYW0vtL83aL1lISRvSWMqJDfb1JujaFEXQVCuCXIuqkUuyCiQrr+rrvuskMOOSTXlPe5Xy1RIXXuP9lKIqjLL798blwSwVKgkXvq0+mnn26XXHJJ7nNEherlm4dxpI2A928nTHJ6oXnqPXfIkCG5j/T3uvLKK+d+jtvvkMT7+fPPP9/ku987V71Pyp+9ySab2MCBA53E/OWWW66o2ZMQFVLSRdu2bXN9SoRghx12KHvr+YP4JF586KGH5q5L4v19yZIlJqEECRgVK/LVSLRJ4sJi6t1zKDspKtQdAZKi684kDMjM/OtiBUmvtNJKTdho/e4GT+tDvzie/4K4fZRu+1EDjv3f4/JR6oCXcqVcULv8iRL9rKRI3EfifN7iFWAtJITuFTy/8cYbnfeFQuXHH390EiH1/qYER/mWvXYsdE3SokJ65uo9W/eQivYarrvuuqII/afsFhPm967bgga5q1OJMylRU8V/XRLrqSTWFC68KIkbldy7XAsBCEAgaQKsn5MmXNv28c+H449//ide+OfD3TfUhkDWCATdN/VzUYK6DjRRwrZbnnzyyby47HL+Af+hAnqf9Pqpi9nCf8CdYrUVs62SxHtumHvwomHHAAAgAElEQVQiqqjQXnvtZeeff34TUaWkfPf1sm8Rhi11s0eAeKTs2ZwZQyAMge233960jlHR/rT2qeMu3ni0cj55b99BYxii+KaTWl/Fwe6+++7LO3xBe2SKhShU/HsexQ6rkqilV/DSLw5UbNyzZs1yBI7c4r8uiX2qKLmU+++/f+5QX8X4XX311U2mFHWPLw6b0gYEIAABCEAAAo1LAFGhxrUtM4MABCBQNQJepdwozhn/Zo8SzSR+4S0K5Lz44ovzEgpLTVBBozpZ2Zts8thjj9lvfvObiriUEhXS6dkSUaBAAAIQqEcCe+yxhyNWohJUEKfYPLxJDrvvvrvp+9VbgjrGvdekTVRIz5NHHnmkrKmVpCDhFxW/qJBOVS6UdFK2UU+FKKJC/qT0oM52/7i8pzz576kknrn+BAJtLpQr5USFvM78cm0V+rycqNDLL79s2vQoVyTCoGR292+0XH3382qLCnl56URunbAepBx//PG5ZBedriXBAbeU2+wq1j6iQkHIUwcCyREgiCc5tvXacpCkBY1dJwN5EzT1rNAzQyWsqNDUqVOtR48eOSTe04n8J1h+8MEHeYJGhTgGDY4dMWKEE7xZaP0W1D7+YNhCSbhhRIX8Aks6YcorkuMf12uvvZYn7iP/yNChQ4MOv0m9oKJCutArQKqflZSrU0OrKSqk+6Ffv365efhPrPKLH3322WeOyJBbEBWKfKtwYcYJjBo1yk455ZQcBQV6tW/fviQViZYq6N8b2KULvH+H+lliYC1atMi1FbffIan384ceeshJ/ndFzErB2GCDDUzPOv1bqCQhKuSf9xtvvFFQrL/QeLx+HIlAyT/hliTe39X27NmzbdiwYTmh63J/cnqmKyjTe++Uu4bP64cASdH1YwtG8jOBoGt4/3f2ySefnBNiKcQzbh+l20fUgGP/97j2aJs1a1b2Vijn5zv11FPtiiuuKNtOqQqFRIWeeOIJ22233XKXKWjc9bv730M0xhVXXLFJF3qH0zrm/fffDzW+pEWF/Ml+SpAo5W+eP3++6X5ySyGRJX3mtUXQvQ5d98c//tF0+rOKX1QoifVUUmsKjT9K4kaom4PKEIAABKpMgPVzlYFXuTv88+GA45//6YAwFfzz4e4dakMgSwSC7psWYqJYAQngukK8EsaRL9wt5fwD/piyIPFfalv9ekWP9Q4v4f6k3nPD3A9+n9ERRxxhAwYMaNJEq1atHLFk/aeYs2L7vUn57jWgeti3CMOWutkjQDxS9mzOjCEQhoD23nXYr0oYwfwwfXj3bP785z87By0HKUFjGKL4ppNaXwWZV7k63lxCxX6Uy6eTgI73oDzFwPljJKKuhRYtWpR3kJM/PyKJfSrv/aKYGcUzlCuICpUjxOcQgAAEIAABCCRFAFGhpMjSLgQgAIEMEdCp0UociOqckSiDNpbcIidAx44dCxKUEIJOVdQpkXIgKJGwWNEpz//617+sefPmThV/EK9O5PEmNQYx2RlnnGF9+vTJVQ3q/AnSNnUgAAEIJElASuauE3aFFVYwJfctu+yyobvURr6SAt3AAG+iuNtYlO9Gr0DIzTff7JxqVKh4BY0uv/xy52TcIKWc0zZIcHqUeZUSFfr666/zEhj03CqWPFhsjnp+7rrrrkEQ5OosXrw492zUL2+99VYbPHhwqDZUuZSoUBLP3CA28k+inKiQRAyVNKmiv4v99tsvFAcFyZx22mm5a8pt3BRqXIJCasdfJEIlsSadpN27d28n0Vb/aVPj7rt/CgSstqiQl5cSSM4555xAvLziAn4ByijM1CmiQoHQUwkCiREgiCcxtHXbcNCkBa0VtT559NFHc3NxT6cMKyqkBnbaaSd7+umnnba2224702a/SpTTJoMGx8YhKiQRH6/4ntZf/rV30IRkJfAqQDaIIEWxG0gCO1oXRS1hRIX0bNfaxh2v1lgS+fn8889N6123qM2WLVs2GVJQ/uXuyT333DN3H2oNNXHiRCcRWvfohhtumPMnKaj3tttuyxsHokJR7xSuyzoBJSl536nefPPNvKR2P58HH3zQlOiu957x48c7a3y3SIxszJgxzo9+gV79Lsr7eSm/Q5Lv52r72WefdfzZEjbQ97HrUyl0zxQSolO9JESF/Cf8Pffcc7bVVlsFupW9PG+55RaTr90tSby/ewelQwp0z0hoQSdjT5kypeiYJeB7ySWXBJoTleqLAEnR9WUPRvMTgaBreNX1vsvo51JCqHH7KF17xSUqFDS5r5yfzy8aWGwPoNj91rp1a1MAvz/hzv/O5BVVVfC2e8Kr+tPeg7/oQBn5LP1F7y/rr7++sy8s/6wE9dZcc03HX+u+7yQtKqRxaXyVlBkzZljnzp3zmpAwkPy7KmEOoSgVE5DEeirJNUWUxI1K7MC1EIAABJImwPo5acK1bb+cL9QdHf75n0jgn8c/X9u/WHqHQDoIBN03LTYbxZmNHj3a+djvwy/nH/CLAy9YsCAv+btYnx9++GFOREh19LPe0VWSeM8NY8kwPqMg7Sblu3f7rvW+RRAG1MkuAeKRsmt7Zg6BIAQuvfTSnMiPDi6aOXNmkMtC1SmXb1CssaAxDFF80+XWV/5YAv+hTaEAhKjsX5+FuDRX9aSTTrKrrroq79IffvjB2rRpk/ud9gqC5EroUDmJN7rFLyqUxD5VlPsFUaEodwrXQAACEIAABCAQBwFEheKgSBsQgAAEMk7gsssuMwXnqyhZTEGqYYr3FOuw1y9ZssS++OILJ3Hg/7N3H9CSVGXiwC/RAIgwMgSFxUAQkKAIiCIZRBhmUVGyLCosSRHwgKLMDChRASWYJYgusKAsGAhKlCR74LhEByRzyKiACYH3P1/vv3vr9et+Xd2vq7ur+3fP4ei8rrp17+/We11167tfxRsUIhg0uygjmyjh9ttvrwR/VktMItW/Bbuddse2eSd/2q3X9gQIEOi2wMUXX5y23XbbWrWxOO9DH/pQ24epTwQXbw+aMWPGuHqyfxuzi7+bHSyC2uPtO9UyKkmFor/ZRXjxPZZNstf24LSxQwRVxMLqKPVvjMpbzWRJhYr4zi1iAUF2Yr7VG8PzuLR6cNOojuwCo7gOiuuqWIjb6I3ZsX/2rQ69TioUf0Pib0mUj3/847UAoVY22YVR8fchFv9USydm9b87sRj5wx/+cKtm+JwAgS4KCOLpImZJqsq7aCG6E4sr4947m1Tm3nvvTUsuuWSttxGoGt9prUp9gooHH3ywshgym2QnEsJEYphWJW9wbN6kNs2OF4EZ8VbMaoKDZgs08waX1gfWtupns8+vu+66tP7663e0eztJheIAkZRio402qh1r8803T1/+8pfTuuuuW/tZ0UmFIsl0vJWsWn7605+mSDRU/5bqSFadnSuK7SUV6ug0sROB9NRTT42ba20U/FVliu+FbOL2mDuIv3fxlt5IQpZd+L7PPvtUFoNlSxHzDr28P3/22WfTAw88kOK7KQLkIpFQtdQnYq3+vIikQrHYMJv0Lu93an3SgPogviLu3yf7FYs3DkaAYAQtnnnmmSmuH7Ilu7jEr2p5BCyKLs9YjVJL817Dh0lcZ0YgcbXEHHrMpTcq3Z6jrB5j0JIKxduD4y3CUaaa+LTeMXsfV70Hi/GK58DV58aN7onCKJ5NVLeJdsX8bNyvxnVJfYmFjtmfF5lUqP7aqtPftaOPPrpyj5Mtp512Wtp3331rP4rn7XlexLPppptWrl+iNHoLdLevp4q8puhk4UanY2A/AgQI9ELA9XMvlPt3DPPz+e3Nz5ufz3+22JLAaAvkfW7aTCkbMxbbZBMSt4oDiuT72ReR3HPPPZVkvq1K/Rx5zLMvtthild2Kus9t1abq5+3MGeWps6i5+8mO3cvnFnkMbDO6AuKRRnfs9ZxAHoFY+xAvKKqWG2+8cVwsUp46Wm3TSZKYqDPvurJO5qZbXV/deeedadVVV6117Q9/+EPlJbZFl0MOOWTKL/iJuPmIEckmEYp2Z583nHzyyeNe7tesX9dee+24lyjVJxUq4jlVJ+eLpEJFn5nqJ0CAAAECBJoJSCrk3CBAgACBKQvEwqxsYop46BOLx/OW7OL4RgGIeeuJ7eqDP7NvnazPWHzTTTelddZZp53qJ2ybd/JnSgexMwECBLogUP83MN4SdMcdd6T5558/d+0vv/xyWn311VNMPlfLX/7ylxRvCM6WSBhSDVKPgPyHH3540mPUL5QepaRC2QDAWKxw0EEH5R6PqWyYfWNU1HPDDTek9dZbr60qJ0sqVMR3bhELCGbNmpWOOOKISr/jLQZxjKmUVg9u6uuOoMZXvepVtR+fd955afvtt5+0CdkHJb1OKhSLeb/5zW9W2hcBPr/97W9bctUHukQyyXhDeLW0a1bdL+sgqVDLYbABga4LCOLpOunAV9jOooXoTH1QZyygrSami8/zJhX629/+VklGVF3gedxxx1UW5m655ZY1s5gHiACDViVvcOxUkwpFcohIVlgtjRZwxmd5g0uzSf2in+3Mt1x11VW1dkTipUgW0UlpN6lQHCMbBBP/jgSAEdxTLUUnFYrjZM/b6rVLdhFss+s/SYU6OUvsQ+B/BbbYYot0+eWX1zjuv//+tPzyyzfkafR34pxzzkmf/exn0ymnnFLbp5oULFtJEfMO/bo/j7mWmTNnVpIqRWk2j1JEUqE43lvf+tZaIrwvfOEL6Stf+UrL0/nWW29NkbChWmLxavbfRdy/t2xUZoMIHn3Pe95T+8kPf/jDtMsuu7RThW0HQMCi6AEYBE2YIJD3Gr66YyTQiQDlaonvyM0222xCvd2eo6weYNCSCv3qV79KkXC0WuI7MJvcbiqnXFxzZAPkf/e736UImq8+v47nIb///e8nHOI3v/lN2mCDDWo/j0S2yy23XNOm1AfmF5lUqH6BZjZxayuraGc10W9cW0Qyw/nmm6+2W/13dXjFs5/JSiQVXHbZZWv3542e6Xf7eqrIa4pOFm60cvc5AQIE+ing+rmf+sUf2/x8fmPz8/9rZX4+/zljSwKjKpD3uWkzn+zz1PoXybaKA6p/+eCll15aebbQqsRzg/3337+2WTaRUVH3ua3aVP283TmjPPUWMXef57ixTdHPLfK2w3ajKSAeaTTHXa8J5BWofxaw1VZbpV/84hd5d69sF9dB3//+9ysvVo0YouzceXzeSZKY2C/vurJO5qZbXV9FfF12LUd9Mp22gHJuXB/TF89oJnu+kq02rp3imX61NHr5UXYcIuYs4sRblaOOOioddthhtc3qHYp4TtXJ+SKpUKuR9DkBAgQIECBQlICkQkXJqpcAAQIjJHDfffdVFh9USwSExpvf85T6N8THopETTjhhwq4xcRBvmY+3VrcqUUcsWI9SH9AYixGrQZQxIRMTB1MpeSd/pnIM+xIgQKBbAvWJZPK+gb56/LPPPjvtuuuuteY0W5gcE7fZxCjZNwM16svhhx+ejjzyyNpHeZMKxX4RpJCntJq0zROc3snf/G9/+9spEr9EabRwIZLf/eAHP6h8HgudI+FdnjcC5+nzZNvEgorsW55i4cQ111zTVrWTJRWKirr9nZtnjOo7EImzVltttdqP420GSy21VO3fsbBwt912q/378ccfr7S709LqwU19vbGQZeWVV679OAJnlllmmaaHjyQ+6667bu3zZkmFXnjhhXHJFZotWKo/UCvjs846q/IgrVpuvvnmtPbaa0/KFYuCd9xxx9o2sVAnrs+qpV2z6n6SCnV6ltqPQHcEBPF0x7FMtbS7aCH69ulPfzrFm4IalbxJhWLf7D1+XE/Fd8+Pf/zjSrWf+tSn0ne+851clHmDY6eSVCiusdZaa63aIssImIjrkVe/+tUT2pgnuPShhx5K//Iv/1LbNxYk77XXXrn6Gxt98pOfrATCVMszzzyTFl988dz7VzfsJKnQP/7xj7T++uunW265peHxepFU6KKLLqok6qiWSOJ58MEH1/4dSZc23HDDCe2TVKjtU8QOBGoCZ5xxRoq5h2qZLKFZBPzHPU3273jM/cbf62qJv6Nx31SfELmIeYdu359H/+L+J5Lt1L9Vr/6UqU/aH4l6X/Oa14zbrH4evVGS50anYqv5kOxc0fTp09O9997bMllffZKM+ra0urds1M5W9++xT8zrR+LqPAn24k2M1aTYkaxj9uzZflNLJmBRdMkGbESam+caPksRc5HZub5VVlklRfKW+u+1bs9RVttQ1Bxhs+FuNc9X/zw5EuZ94AMf6NrZE3XFQsQon/vc59Ldd99dS27b7C22MTcf1wBR4roj7ukmK1/72tfG3VMUlVTolVdeSSussEIt8d9HP/rRdO655+a2qn+WU28diXtjfrVa8iTcj+T88Z1aLY2SCnX7eqqoa4roQywsqMYJTPWlR7kHxoYECBAoUMD1c4G4A1C1+fl8g2B+/v+czM/nO2dsRWCUBfI+N21mlH3BQH08XKv5gbjnjeefjzzySKX6eJZ34YUXTjoc//znPyvxX3Pnzq1sVx+jXtR9bt5zpN05ozz1FjF3PyjPLfL03zajKyAeaXTHXs8J5BXYd99902mnnVbb/LrrrqvEJ+UpcR0SsfrVWKZGL1dt9Xy92XHyrjHoZG661fVVtCleClC9vtppp53Sj370o0lJ4rrgpZdeSgsssEAeugnb1MeG33777Sme0ecp9deDjcah/plErK9YZ511mlYfRnGNWX1xYWxYn1SoiOdUnZwveZIKdfqML4+/bQgQIECAAIHRFZBUaHTHXs8JECDQVYF4A0T2DdKxaG2PPfaY9BixcD4eLlWD+2Pj+sX+8bNYWPKlL32psmggJgfi/09WshMI9UkS9txzz/Td7363tnssQog3NDYrsVgjFjAeffTRadttt52wWd7Jn65iq4wAAQIdCsTf3be//e3jJky/8Y1vpP32269lIpuYgI+J+GqJtwzddddd6Y1vfOOE1tS/sT4WZkcCoEbl6quvTvVv2J0sqVB2InXGjBkpFgrnKa0mbfMEp3fyN79VUqGYtN9ll11qXbjgggtqb09u1K9YWB79juROsVB/wQUXzNP9htvUv50uHiLE4oq8C80jCeBBBx1UqTsWSWaDVeNn3f7OzTNG9R1ttSixPrlSmMbbC5uVCALZYYcd0hve8IbKtcESSywxbtM8D26yO9QvLIqkQfFwpFGJhzeRUCi7ML9ZUqHYP5t0J8YqrmdalVbG9W83j7becMMNE97UUT1ObB+LX6oJHWNhTixQzSbOatesWrekQq1G0+cEihUQxFOs7yDW3smihUiIEAl2qsGd2X6180ak+mvLbD3tBIbkDY7tJKlQBDvEdd8+++wzbvjibVjxVqxGJU9waX2ARKtknfXHieTM2WR+zRbStjrnOkkqFHXG/UIsnG5U4o1VjZIt5fXPc07GWzTj+I3OwUYBKdV2SirU6ozwOYHmAnHfEgF7kYC0WiKxUMwbN0qsE9vHveh//ud/Nqz0zDPPHJcItrpREfMO3bw/j6RlMYcQDvE9EAsiJrt/v/LKK8cl04+FX/Xb19/f5knyGl6t5kPqj33IIYekY445pukgx3GzwXpx7x/fgdnS6t6yUeWT3b9H4F8s+q+2K0/i3Pe///3p2muvrRxqsnkpv8+DK2BR9OCOzSi3LM81fL1P/VtR4xllJP/Mlm7PUWbrLmKOsNk50GqeL773V1pppVqinNVXX70y11n/FuBs/V/+8pdTfFfFy2Te8Y53THr6/eQnP0nxttpG5emnn07Tpk2b8FF9osJYpFif9Km6UwTjR1B+thSVVCiuJTbeeOPaoSJZUjxTz1si4d/CCy9c23y77bZL4ZMt8Ywhkg9VSxjH/Hijlx7EPfxmm202bv9GiXi6eT0VB+v2NUW2A9lnN/G8K+awG92j5jW3HQECBPot4Pq53yNQ7PHzzIXWt8D8fErm583PF/ubqXYC5RbI+9y0US/rX0gWz9UihqpaWs0PxHb1z0Dj/i8S3jYr2RffxTbxAprsC87iZ0Xc5+Yd5U7mjFrV3e25+0F6btGq7z4fbQHxSKM9/npPII9Afdx1zO/G/Hf9HHZ9XfGM4jOf+cy4hESN4qhaPV9v1sa8aww6mZvOc31Vv54vYrvXW2+9pqQR/x/PrGJtXrzgLvsigjzjkH0eH8eJ47VT4tl/rGOolnheFHGG1RIvjog1L9USz5RizUj25XzVz+KZSCRkrI87qY9PLOI5VSfnS56kQtG3Tp7xtTMGtiVAgAABAgRGT0BSodEbcz0mQIBAIQJPPfVUeutb3zouUUUsuo8AxCWXXHLcMeNmPII0Y8FBNhPw8ccfP+7tjtWdssER8bPJFsHdc889KbavLl6PNyJGcopqicnmbAKMeEvGeeedV1lcUV/qH8oceOCBKd5AmS15J38KQVcpAQIEOhCIpG/1ixYi0P7II4+sJP/IBszH3+tIABJvn42/ldkyWeKfeFAedVUz3sd+sf/2228/ro7IGh9vDsp+F8QGk9Udb5aPxWDVEpnuY3K1VWk1aZsnOL2Tv/mtkgrFAvSYTK8uuIyHGzFG9VbRv/DccMMNxy26iDdbd1r+/Oc/VxZBZP2nT5+evvnNb1YWM77+9a+fUHW8mSAWp8cbnOO/ammUVKjb37l5xqi+wa2SCsX22UXj8e9IgPXFL35xwtsXYlFnnGv/9V//VTlMjFX4v/nNb64dNs+Dm/o2Zif9I8FWvDW6fvFCPASLhzYXX3zxuN0nSyqUvX6KtkbShVYLb/IY13tFAsdY6Jt1iEb+93//d9p5553HLeJvtGiqE7OoX1KhTn/z7UegOwKCeLrjWKZaOlm0EP1rlhConaRCUU/2Wq7qFvfzEUDQaMFjI9u8wbHZpDaREC/mGepLXMM9+OCDle+5aEMkhozv2mxptGgz+3mr4NK4Fo/5i+r8RgTCRpBuOyWu3VZeeeXa93G7ZtVjdZpUKPaPa8v6ZEvx814kFYrjnH766Q2TXk+WzFNSoXbOMtsSmCgQb6Crv/eIBF+ROD6CwF772teO2ymSvi+33HITKprs7XlFzDt08/48+10SHfvoRz+afvjDHzZMLBQBbpF4qJoAJxLgh0l9icWA2cRMcS8Wf8vqk93W79dqPiQSsL3nPe8Zlwgq/m4fe+yx45IRRL2RKGDvvfceN4/wP//zPxPGO8+9ZX07J7t/b/TsYbLEgpHEKb6HqyXsswmd/d6WQ8Ci6HKM06i1stU1fCOP+Psd82bV6/qYp4u/84suuui4zbs5R5mtuKg5wkZ9zTPP9/Of/zxts802td1nzpxZCVpv9H0W30XhUi2xKCD7972+DS+++GIlGXz984b4Dojvgkal/vvnC1/4QopERvX3mTF/H/XUJywtKqlQzKvGAskoMWcf8zCTJV9q1Lf6tzXXv2gn7mmXX375cbuGb+y32mqrVa474rougvSzi0OrOzRKKtTN66k4TrevKbKdrU+UFEn5YxHDVF7kMGp/E/WXAIHBEnD9PFjj0e3WmJ8fL2p+/jfjXiYw2flmfr7bv43qIzA8Anmfm0aP4377iSeeqMQQxt+V+sXaETsVi7yrJc/8QMTAxXOD7D38qaeemiIOat55563VFXMxkYAoe18az29vu+22Cc8airjPzTvincwZtaq723P3g/TcolXffT7aAuKRRnv89Z5AXoH677XYL+K+41qi/mXJETt1zTXXVK4nIoF/tcQ1RbwsrX5OuNXz9WZtzLvGoJO56TzXV88880zleVT1+iqeR8W1WzxvyJZ4uUKs8Yv2VkusE4n1GXlL/UvmYj1BJPVpp9S/yCFekB3rBLMl1u9FcslqiT599atfrcQ3xDqV+M6Ia9F4lpT3pYfdfk7VyfmSN6lQJ8/42hkD2xIgQIAAAQKjJyCp0OiNuR4TIECgMIFYGBIL3utLBDvGG+AXX3zxyk17LDSoL/GAKIJcGr0BsNGb7WMSJ5JgLLPMMpVF/RGMG4sV6x9YxcOv7Jsc47iRGOjggw8e14QIWo2ECBG0Gu2IRRz1Ews33nhjWnfddcftl3fypzB0FRMgQKBNgZgcj4ftzSZ/I8FNTKg/+uijKf7uNSqxbyRemWwBd/0CrqgnFrzF2+wjOUt8nk06FMEF1e+HyZIKxaLuWAydLfHvyEb/mte8pvLjmBSPN0BnS6tJ2zzB6Z38zW+VVCjaGMmV6t8GEAH566+/fnrb295WWaj+m9/8ZtwCv9gvJsoPOOCANs+A8ZvH92S8uam6qCX7aXx/x4LPWND4+OOPVxa73H///RMWZcQ+W265ZbrkkksmtKWb37l5xqi+AXmSCkVypTiHsgbx70033bSyeCIWL8Zixcsvv3zCtUMsZMkGs+R5cFPfxkjyFYmkqiXc48FWnMfPPvtsJRAmFopWH/TEeFR/dyZLKhQLZXbbbbdxh4trnUgCWV2AEgt4sg+M8hjH72+cm/FWiGyJcyDcIjFZJBSqLoitbhPXbXGdVv93oxOzqFNSoSn96tuZwJQFBPFMmbB0FXS6aCE6Gg/zP/e5z43rc7tJhRoFvke98dakvCVvcGyjwJO8x6huFwk749pxssWIrYJLI5ngtttuWzt0vD0yEky2W0444YRxTldffXWKt0W1U6aSVCjuP2bMmJEiKCNbepVUKNoeb6nKXuvFnNLvf//7cQlVs22TVKids8O2BBoL1N9bZLeKeeCVVlqpksj1oYceajr3EH/7456nWSli3qFb9+eRQCISK91333215sccdtx/xz3ZtGnT0p/+9Kf0hz/8IZ199tnj7rPjeyjmXBqVSKCfTfAb28Rcy9JLL127N43v3Lj3q5ZW8yGxXbQj5h+yJe5N43snkg3EvWm8WfDOO+8ct80pp5xSSTxQX/LcW9bv0+r+vVGSuJg7iXv3eKlB3OfGwpbLLrtsQqK/sK5P3uF3d/AFLIoe/DEaxbdst0MAACAASURBVBa2uoZvZhJ/6yNJaLXEm1fr56+7OUeZbUdRc4SN+pp3ni/mJLP3B/Ed+a//+q+VBYgx1xrPJeK+JXsNH3Oi8Yw5njVPVsI2EsNkS7xEJpK5NyoRPB+JWLPf2fFMO+Yy4/s1FiTG8+ef/vSntd3jO7LatiKSCkXd2Rf2xPOceFNwuyUSIcXzmGqJ+9RYVJEt5557boqXBOUpMU5rrrlmbd63UVKhqKdb11NRVxHXFNW+xqLYeK6UHfvqM5HFFlusRhJz9/VJMfN42YYAAQK9FnD93Gvx3h7P/Hx73ubn/8/L/Hx7546tCYySQP1z0077HjHjn/rUp8btnnd+IGKhPvKRj4zbN+KOIiYp7s8eeOCBFM9H62PaIibpXe96V8MmF3Gfm8em0zmjVnV3c+5+kJ5btOq3z0dbQDzSaI+/3hPIKxAv7omYqrimqS8xlx0x+fHS3VgLEc+hs+sVYvu41oiY8GxixGo9eZ6vN2pn3jUGncxN572+OuOMMyYk94n4jHhWEDHpcR1V/3LbsIi1GRGTnbfEWrxYH1At8Yyrnf2r+9U/L3ruuecqawOrJa5f4vlO9cXNrdoXL3TOridsFp/YzedUnZwveZMKdfKMr5WRzwkQIECAAIHRFpBUaLTHX+8JECDQdYGYmPn4xz8+YeJlsgNFBuF4oD9ZQF4sBogHSPVvl5ys3nijYCyeqy8vvfRSJdN0s8UZjeps9gb7vJM/XYdWIQECBKYocM4551QWs7VbGgXJN6sjss7HBHWrEgsB4+/8aaedVtl0sqRC8XkE0UdW/GYlFs9lAydju1aTtnmC0zv5m58nqVC0L5LT7L777rm/52JxxFe+8pVJEzu1cq9+Hg8bYtFhNrFN3n1jMUcsgIlzKZLJFPmdm2eM6o/falFidftIaBULexolPmxksdVWW1XeFP36179+3Md5H9xkd4p9YuFKo8RO9ceOBbVxfu+5556VjyZLKhRvrIp21idDytZ5yCGHjFtkk9c4kkzFmEfwTp4Sb/GOBcELL7zwhM07MYtKJBXKI28bAsUJCOIpznZQa57KooX4Ttpss83GfW+0m1QokhlEAoZsifMwFnnmLb1IKhSLTyPZQyQmbFVaBZdmAxgiCU4EcGSTGbaqv/p5fG9nneJ7OYIO2ilTSSoUx4k2RBBwdk6nV0mF4vjHH3/8uDdsNQpwznpIKtTO2WFbAs0FYuF//C2rD9Brx+wXv/hF5b6mWSli3qFb9+cR7P+hD30o931m9DEW50fC3kb3TvF5fPdF8t/J7h/rzVrNh1Rtf/vb31YSKOQdr0juF/P6jRJO5723zI5rq/v3WAQXgYn1iQpbnU/nn39+pV9K+QQsii7fmI1Ci1tdwzczeOWVVyovX8km6Y5EJhHAnS3dmqPM1lnkHGF9f/PO8z399NOVpHTnnXdertMm7ocuuuiitOqqq7bcPpKHxlxrteS5l2qUBKfZgSLJXdxbVu+pikgqVJ8YNhL9R5K/TkqYVZMCxsKAWEBRP48f9+fbbbfdpM8mIoj/+uuvrzzvqS4UaJZUKNrZreupIq4pso7xXCqS5U9WJCfs5MyzDwEC/RBw/dwP9d4d0/x8Pmvz842dzM/nO39sRWDUBKaaVCie+0X8XiyI7nR+IPZrtPC92VjEvWncb8Zz58lKEfe5rc6PTueMWtUbn3dz7n5Qnlvk6bdtRldAPNLojr2eE2hXIL5/99tvv7Zj3+M6JuaG4wVljUre5+v1+7azxqDduem8z1/ieVTEaodLnhJrACK+IF6YlLdEvFe8GKEaAxYJJiMOq5NS/yKpRutHIrHQXnvtVXlZ02Ql+hxrS5ZYYonaZs3iE7v5nKqT8yVvUqFOnvF1Mg72IUCAAAECBEZHQFKh0RlrPSVAgEDPBCJDcLzpMN7aONkihHiLciQiiOCHPCXeXH3SSSdVkk1Mllwoghgj+3Fkn55swV28WXKfffZp+jbsaFMkeDjssMMmvKm52t54c/Ts2bMr/+xkYV6eftuGAAECRQk888wzlYfz8bd1sr/XMWl8wAEHVP4m1i/mbtW2WLy1xx57NPy7HfXGW4N33nnnFMlNjjvuuEp1rZIKxTYxkXzyySc3fMtAo6RC2UC7RvVngyUiCCG+y+pLJ3/zs2+hjgcRsaihWXniiSfSpz/96UkXU0SAezx42GSTTVrRt/15PKQ45ZRTKm9enux8iMUHMQkeSWXiu2+BBRZoeaxufOfmGaP6hsSCi1g4Ui2PPfZYWmqppRq2N97+ENclsWij2XVGvLEhkhbGOd3oGiPefpFd/Hn33XenlVZaqaVPPAyP86vZg5U4bryNOt4aHQtX4vhRDjrooBQLOZuVeKAQiQ1iXBslTKpPKtSOcSRpjKRZ3/jGN9LcuXMbNiHe9vGZz3xm0rddd2oWbxGpnqcWibY8xWxAoOsCgni6TjrwFX7wgx9Mv/zlLyvtjL/9+++/f1ttfvjhhysLQKvfsTfeeGNad91126ojrhkjqV+UmTNnVq4H2ylxzPe85z21XWIx5TLLLDOhivoENM2OEdeMsUgh+hXf1bFwNa45GyVabFTHP//5z7TgggvWPooFtfHGpChxLbrooovWPotr5vje7rREkuZIllwtcd2T5xquun19W2MxdCS1aKfULwaNOhtZZf0nu35u55zMBtfEuMUiiskSW2eTCsX1VywUVggQ6EzgH//4R2WO+Otf//qkc7Dxu/nJT34ybbrpppX7nWzSnBtuuKHyJsFmpYh5h27dn0eAW9yPRRLfZvdN0a+YH4m/PTHvstBCC02KHXM5MR8d34ON7t3rkwq1mg/JHiyC5+IeM5I+N7svjgQ9kdhnsu/xdu4tq8fPe/8e3+cxH1S9JmiGtdNOO1WSHjV7Y3VnZ7S9eilgUXQvtR0rr8Bk1/Ct6rjmmmvShhtuWNss5ttPPPHECbt1Y46yvtIi5wizx2p3nu/cc8+tPM9tNhcd89CRXD3mw7Nvpm1lvfHGG9eS2sb9RRyjVYm388b3W7Mk6pHkML5/422+u+22Wy2pUCQ7mjFjxrjqO3mOkK0gjlF96248D4iEg52WU089ddzigWbXVXHNEvekcd8WCW3jeznudeNZfrQn/jcWCey9997pW9/6VqU58XbgK6+8smnTunE9VeQ1RbXht912W+XlR+Hc6PpHUqFOzz77ESDQawHXz70W7+3x2pkLbdQy8/MTVczPm5/v7W+xoxEYPIH656atWhixV29961srSW8333zzSnLaZs9E250fuP322ysxg81eihJzAvGCgbhvj7n0PKWI+9zJjjuVOaM8/enW3H0caxCeW+Tps21GV0A80uiOvZ4T6FQg5kTiWiLi2lqtMYv471hjNlnMVDvP17NtbvfZQDtz0+1eX8Ucf8RuX3zxxU1Z41l6xKLFs5h2Sn1CpOuuuy6tv/767VRR2zaeib3hDW+ojdtkz0TimjHi4ePlVtXYizhu/BfxexETGM+blltuuVr9V199dXr/+9/ftG3deE7VyfkSsTHVF0FHDGbEYjYr7T7j62gg7ESAAAECBAiMjICkQiMz1DpKgACB/gi88MILlZv2+C8mMyKjcyyuj4c7jd5inKeVsYg93qoYi0tiIVhkmY4kF0svvXSl3rwPjqrHiv2jfXfddVdlQmKxxRar1BUZl9sJUs3TdtsQIEBgEAViwjGSrcRkagSURZD061//+hRJO+JvavxNnG+++TpuemS+f+CBByp/Z+M4iy++eGXSds0118y96LrZwWNCOR6cx/9WSyzObrRAvOMO9HjHGI+Y0I+ENOEVSWqiPyussELP+hUBBPfee2/l+zHOh1gwEAEi8fbsyRZgt6Iqy3duPJwO/zhvIwgmEhFVr2Fa9XEqn8e5HG+FiuPGNVS4R0DOaqutNpVqK/uOjY1Vrp3iLRHV8rrXva7y+ziVEvXG73Ykf4zzNf5WvPGNb6ycK9mETlM5hn0JEBg8AUE8gzcmWkSAAAECBAZd4KmnnqrMO8R/cW/yqle9qjLnEPcPMUcQ/45yxx13VAK+qgF/MT8b+8T9S7NS1LxDN+/P4x47EtrFfHYkj4t+xb1+/Bf3fXmT0mUNnn322YpT3JdVSwT9TeW+PeqJZFARlBfuMW4xLxFjFfP62Tf79fOcC8OYs4iEBdHGOAfiHjo84/59qve6/eybY/+vgEXRzgQCKRUxR1nUHOFUxivmn2MuNpLZxCK8+C6Lv+err756R9+PU2nLgw8+WJmbjbnOuA6ofv/FsxIlpS222CJdfvnlFYpPfOITlRdEtCrdvJ5qdaypfB7XEnGNGs8wsiWuUyd7idFUjmlfAgQIdFPA9XM3NdVFgAABAgQI9EMgXhIS8UcRuxjz3hETHvflkfR2qnPezfrTyX1uP2yqx+z23H2Znlv0092xeysgHqm33o5GYJgE4vlCvHw1nsfHc/T43oxn29W1EO0mz+mVTZFz07Hurrp+I1xinVx4xPVV9gW6vepr0ce5/vrr03vf+97aYWItRsRitCqD9JxqsrYO4jO+VrY+J0CAAAECBAZLQFKhwRoPrSFAgAABAgQIECBAgAABAgQIECAw0AKCeAZ6eDSOAAECBAiUXiD7luSTTjqp8hY9hQCB0RKwKHq0xltvCRAYfIFY2BAvoIjEO1GOP/74dPDBBw9+w7WQAAECIyLg+nlEBlo3CRAgQIAAga4JuM/tGqWKCHRVQDxSVzlVRoAAgZESOP3009Mee+xR63MkVZrKS7VHCk9nCRAgQIAAgZEQkFRoJIZZJwkQIECAAAECBAgQIECAAAECBAh0R0AQT3cc1UKAAAECBAg0F7jiiivSM888k7bffntMBAiMoIBF0SM46LpMgEDPBf7+979XkgNts802aa211pr0+Oeee27aYYcdattceOGFaebMmT1vswMSIECAQGMB18/ODAIECBAgQIBASu5znQUEyi8gHqn8Y6gHBAgQ6KbAb3/723TppZemL3zhC5MmCIoEQquuumqaO3du5fCrrLJKuuOOO7rZFHURIECAAAECBEovIKlQ6YdQBwgQIECAAAECBAgQIECAAAECBAj0TkAQT++sHYkAAQIECBAgQIDAKApYFD2Ko67PBAj0UuDee+9NH/vYx9Itt9ySFllkkXTZZZel9dZbr2ET7rzzzrTlllumRx55pPL59OnTU+wf+ykECBAgMBgCrp8HYxy0ggABAgQIEOifgPvc/tk7MoFuCohH6qamuggQIFBugWOPPTYdeuihlU7ssssu6Qc/+EFaYIEFJnQqEgodfvjh6eijj659dvLJJ6f99tuv3ABaT4AAAQIECBDosoCkQl0GVR0BAgQIECBAgAABAgQIECBAgACBYRYQxDPMo6tvBAgQIECAAAECBPovYFF0/8dACwgQGG6BSy65JG211VbjOrn77runNddcM62++upp2rRp6Z577kk333xzisD9bDn//PPThz/84eEG0jsCBAiUTMD1c8kGTHMJECBAgACBrgu4z+06qQoJ9EVAPFJf2B2UAAECAymwzjrrVJ5RVMu73/3utOmmm6Y11lgjrbLKKumPf/xj+v3vf5++973vjdsunnHEXNn8888/kP3SKAIECBAgQIBAvwQkFeqXvOMSIECAAAECBAgQIECAAAECBAgQKKGAIJ4SDpomEyBAgAABAgQIECiRgEXRJRosTSVAoLQChx12WDrqqKPaan8kHjr99NPb2sfGBAgQIFC8gOvn4o0dgQABAgQIEBh8Afe5gz9GWkiglYB4pFZCPidAgMDoCDz00EMpEgk9+eSTuTu9yCKLpCuuuCKtvfbaufexIQECBAgQIEBgVAQkFRqVkdZPAgQIECBAgAABAgQIECBAgAABAl0QEMTTBURVECBAgAABAgQIECDQVMCiaCcHAQIEeiNwwQUXpH322adlUP706dMrb/udMWNGbxrmKAQIECDQloDr57a4bEyAAAECBAgMsYD73CEeXF0bCQHxSCMxzDpJgACB3AJPPfVUOuCAA9KPf/zjlvvsscce6bjjjkvTpk1rua0NCBAgQIAAAQKjKCCp0CiOuj4TIECAAAECBAgQIECAAAECBAgQ6FBAEE+HcHYjQIAAAQIECBAgQCCXgEXRuZhsRIAAga4IvPzyy+mmm25K1157bXr88cdTzPuMjY2lZZddNq288spphRVWqLzVd+GFF+7K8VRCgAABAt0XcP3cfVM1EiBAgAABAuUVcJ9b3rHTcgLikZwDBAgQINBI4Mknn0y/+MUv0h/+8IfKM4w///nPlWcWK620UlpxxRXTaqutVvn/CgECBAgQIECAQHMBSYWcHQQIECBAgAABAgQIECBAgAABAgQI5BYQxJObyoYECBAgQIAAAQIECHQgYFF0B2h2IUCAAAECBAgQGFkB188jO/Q6ToAAAQIECBAgQGCoBMQjDdVw6gwBAgQIECBAgAABAgQIDJCApEIDNBiaQoAAAQIECBAgQIAAAQIECBAgQGDQBQTxDPoIaR8BAgQIECBAgACBcgtYFF3u8dN6AgQIECBAgACB3gq4fu6tt6MRIECAAAECBAgQIFCMgHikYlzVSoAAAQIECBAgQIAAAQIEJBVyDhAgQIAAAQIECBAgQIAAAQIECBAgkFtAEE9uKhsSIECAAAECBAgQINCBgEXRHaDZhQABAgQIECBAYGQFXD+P7NDrOAECBAgQIECAAIGhEhCPNFTDqTMECBAgQIAAAQIECBAgMEACkgoN0GBoCgECBAgQIECAAAECBAgQIECAAIFBFxDEM+gjpH0ECBAgQIAAAQIEyi1gUXS5x0/rCRAgQIAAAQIEeivg+rm33o5GgAABAgQIECBAgEAxAuKRinFVKwECBAgQIECAAAECBAgQkFTIOUCAAAECBAgQIECAAAECBAgQIECAQG4BQTy5qWxIgAABAgQIECBAgEAHAhZFd4BmFwIECBAgQIAAgZEVcP08skOv4wQIECBAgAABAgSGSkA80lANp84QIECAAAECBAgQIECAwAAJSCo0QIOhKQQIECBAgAABAgQIECBAgAABAgQGXUAQz6CPkPYRIECAAAECBAgQKLeARdHlHj+tJ0CAAAECBAgQ6K2A6+feejsaAQIECBAgQIAAAQLFCIhHKsZVrQQIECBAgAABAgQIECBAQFIh5wABAgQIECBAgAABAgQIECBAgAABArkFBPHkprIhAQIECBAgQIAAAQIdCFgU3QGaXQgQIECAAAECBEZWwPXzyA69jhMgQIAAAQIECBAYKgHxSEM1nDpDgAABAgQIECBAgAABAgMkIKnQAA2GphAgQIAAAQIECBAgQIAAAQIECBAYdAFBPIM+QtpHgAABAgQIECBAoNwCFkWXe/y0ngABAgQIECBAoLcCrp976+1oBAgQIECAAAECBAgUIyAeqRhXtRIgQIAAAQIECBAgQIAAAUmFnAMECBAgQIAAAQIECBAomcChhx6ann/++Uqr99prr7T66quXrAeaS4AAAQJlFhDEU+bR03YCBAgQIECAAAECgy9gUfTgj5EWEiBAgAABAgQIDI6A6+fBGQstIUCAAAECBAgQIECgcwHxSJ3b2ZMAAQIECBAgQIAAAQIECEwmIKmQ84MAAQIECBAgQIAAAQIlErj++uvTe9/73lqLd99993T66aeXqAf9b+q9996bHnrooUpDpk2bltZYY43+N0oLCBAgUCIBQTwlGixNJUCAAAECBAgQIFBCAYuiSzhomkyAAAECBAgQINA3AdfPfaN3YAIECBAgQIAAAQIEuiggHqmLmKoiQIAAAQIECBAgQIAAAQIZAUmFnA4ECBAgQIAAAQIECBAokcC//du/pTPOOGNci5955pm0+OKLl6gX/W3q5z//+XTMMcdUGrH11lunn/3sZ/1tkKMTIECgZAKCeEo2YJpLgAABAgQIECBAoGQCFkWXbMA0lwABAgQIECBAoK8Crp/7yu/gBAgQIECAAAECBAh0SUA8UpcgVUOAAAECBAgQIECAAAECBOoEJBVyShAgQIAAAQIECBAgQKAkAs8++2yaNm3ahNaefPLJab/99itJL/rfTEmF+j8GWkCAQLkFBPGUe/y0ngABAgQIECBAgMCgC1gUPegjpH0ECBAgQIAAAQKDJOD6eZBGQ1sIECBAgAABAgQIEOhUQDxSp3L2I0CAAAECBAgQIECAAAECkwtIKuQMIUCAAAECBAgQIECAQEkETj311IbJg1ZcccV09913p3nmmackPelvMyUV6q+/oxMgUH4BQTzlH0M9IECAAAECBAgQIDDIAhZFD/LoaBsBAgQIECBAgMCgCbh+HrQR0R4CBAgQIECAAAECBDoREI/UiZp9CBAgQIAAAQIECBAgQIBAawFJhVob2YIAAQIECBAgQIAAAQJ9FxgbG0srr7xymjt3bqUtW2+9dfr5z39ea9c111yTNthgg763swwNkFSoDKOkjQQIDLKAIJ5BHh1tI0CAAAECBAgQIFB+AYuiyz+GekCAAAECBAgQINA7AdfPvbN2JAIECBAgQIAAAQIEihMQj1ScrZoJECBAgAABAgQIECBAYLQFJBUa7fHXewIECBAgQIAAAQIESiJw3XXXpfe973211j766KNp8803T3feeWflZ7vuums666yzptSbP/7xj+nJJ59Mr3vd69ISSyyR5p9//inVFzv/85//TI8//nj6xz/+Ualz0UUXnXKdUcELL7xQqfe1r31tWnrppdM888yTu15JhXJT2ZAAAQINBQTxODEIECBAgAABAgQIEChSwKLoInXVTYAAAQIECBAgMGwCrp+HbUT1hwABAgQIECBAgMBoCohHGs1x12sCBAgQIECAAAECBAgQKF5AUqHijR2BAAECBAgQIECAAAECUxbYfffd05lnnlmpZ+bMmenCCy9Mp5xyStp///1rdUdCoEjc00655ZZb0sknn5wuuOCC9Pzzz4/bdZNNNkl77713+shHPpLuuuuu9KUvfany+YYbbjjuuPXHe/rppytt/c53vpPmzp077uNFFlkk7bDDDmnPPfdMa6+9dtOm3njjjemII46ofL7eeuulww8/PD3xxBPptNNOS9/61rcqyY+qJepcc801K23dcccdJ9R5/vnnpx/84Ae1n992223pkUceqfw79s0ma8ruHCavec1r2uG0LQECBEZCQBDPSAyzThIgQIAAAQIECBDom4BF0X2jd2ACBAgQIECAAIESCrh+LuGgaTIBAgQIECBAgAABAhMExCM5KQgQIECAAAECBAgQIECAQDECkgoV46pWAgQIECBAgAABAgQIdE3gmWeeSW94wxtq9V100UVpxowZKZL3ZJMInXDCCemzn/1sruOOjY2lL3/5y5VkPa3Kxz/+8bTLLrukzTffvLLpe9/73vSb3/ym4W5XXXVV2nbbbSckKGq08ezZs9MXv/jFNN988034+Gc/+1mlj1EiiVIkBXr3u9+d7rvvvkmbu/XWW6fTTz99nMtXv/rV9LnPfa5VN8d9HsmGnnvuubb2sTEBAgRGRUAQz6iMtH4SIECAAAECBAgQ6I+ARdH9cXdUAgQIECBAgACBcgq4fi7nuGk1AQIECBAgQIAAAQLjBcQjOSMIECBAgAABAgQIECBAgEAxApIKFeOqVgIECBAgQIAAAQIECHRN4JRTTkn7779/pb7p06enRx55JC2wwAKVf++4447pnHPOqfz/t7zlLemee+5J8847b8tjH3LIIem4446bsN2KK66YFl100XTzzTeP+ywS+lR/1iyp0GWXXZa23HLLCXXG9osvvni69dZbK23PlmjHMcccM2GfbFKhqPOvf/1ruvbaa2vbRdKfVVddNd1xxx0TEhjttNNO6Uc/+lFt2+9///vpk5/8ZEuT7AabbLJJ+vWvf93WPjYmQIDAqAgI4hmVkdZPAgQIECBAgAABAv0RsCi6P+6OSoAAAQIECBAgUE4B18/lHDetJkCAAAECBAgQIEBgvIB4JGcEAQIECBAgQIAAAQIECBAoRkBSoWJc1UqAAAECBAgQIECAAIGuCIyNjaWVV145zZ07t1Lf5z//+XTUUUfV6v7Vr36VNt9889q/r7jiirTxxhtPeuxrrrkmbbjhhuO2OemkkyqJdxZaaKHKz1966aUUde26667pySefHLdto6RCzz77bHr7298+btujjz46HXzwwWn++eev7R+JheI4t9xyS+1nkSzofe9737hjZJMKZT+I9hxwwAFpjTXWSPPNN18Kn0suuSR97GMfG5dcKOsQ20RSomoJw5NPPrnyz0hYdMEFF0zwirpf/epXd2UMVUKAAIFhExDEM2wjqj8ECBAgQIAAAQIEBkvAoujBGg+tIUCAAAECBAgQGGwB18+DPT5aR4AAAQIECBAgQIBAPgHxSPmcbEWAAAECBAgQIECAAAECBNoVkFSoXTHbEyBAgAABAgQIECBAoIcCkXDn/e9/f+2Id999d1pppZVq/3755ZfT8ssvnx555JHKz3bYYYf0H//xH5O2MJIOXXXVVbVtbrjhhrTeeus13Ofxxx9P7373u2v1x0aNkgodc8wxlYRH1XLhhRemmTNnNqwzEvxEH6pt3m677dJPfvKTcds2Siq00047pbPOOquSTKi+3HHHHWm11Var/Xj77bdP5513XsPjRzujvVG23nrrFMdSCBAgQCC/gCCe/Fa2JECAAAECBAgQIECgfQGLots3swcBAgQIECBAgMDoCrh+Ht2x13MCBAgQIECAAAECwyQgHmmYRlNfCBAgQIAAAQIECBAgQGCQBCQVGqTR0BYCBAgQIECAAAECBAjUCey2227phz/8YeWnG2ywQbrmmmsmGB155JHp8MMPr/08EgEtueSSDS0ffvjhtNxyy9U+O+CAA9KJJ544qXskKYqEPtXSKKnQqquumu68887KJo2SBNUf/nRuLAAAIABJREFU4IILLkgf+chHaj9+9tln02KLLVb7d31SoUh6FH1fYIEFmrZ19913T2eeeWbl81VWWSVFoqFGRVIhv2YECBCYmoAgnqn52ZsAAQIECBAgQIAAgckFLIp2hhAgQIAAAQIECBDIL+D6Ob+VLQkQIECAAAECBAgQGFwB8UiDOzZaRoAAAQIECBAgQIAAAQLlFpBUqNzjp/UECBAgQIAAAQIECAyxwNNPP52WWGKJWg8judAuu+wyoccPPPBAevOb31z7+fHHH58OPvjghjLnnHNO2nHHHWufxYPYpZdeelLFl19+OS2//PLpkUceqWxXn1ToscceS8sss0ytjosvvjhts802k9b51FNPpenTp9e2ufnmm9Paa69d+3d9UqGjjjoqRTKgyUr4RBKmannppZfSfPPNN2EXSYWG+JdG1wgQ6ImAIJ6eMDsIAQIECBAgQIAAgZEVsCh6ZIdexwkQIECAAAECBDoQcP3cAZpdCBAgQIAAAQIECBAYOAHxSAM3JBpEgAABAgQIECBAgAABAkMiIKnQkAykbhAgQIAAAQIECBAgMHwCX//619MBBxxQ69gLL7yQFlpooYYd/cAHPpAuvfTSymdvetOb0oMPPpjmnXfeCdueeOKJ6cADD6z8fJFFFknPPfdcLrhIEvTzn/+8sm19UqFbb701vfOd76zVc//991eSELUqr3vd69Lzzz9f2eyiiy5KM2bMqO1Sn1To8ssvT5ttttmkVV599dVpo402qm3z+OOPpyWXXHLCPpIKtRoZnxMgQGByAUE8zhACBAgQIECAAAECBIoUsCi6SF11EyBAgAABAgQIDJuA6+dhG1H9IUCAAAECBAgQIDCaAuKRRnPc9ZoAAQIECBAgQIAAAQIEiheQVKh4Y0cgQIAAAQIECBAgQIBA2wJjY2Np5ZVXTnPnzq3su/fee6fTTjutaT3nn39+2n777WufN0vCc+ihh6Zjjz22sl19cqDJGhmJiCIhUaP9LrnkkrTVVlu13cfsDmeffXbaeeedaz+qTyr07LPPpsUWW2zSY9xxxx1ptdVWq23z2GOPpaWWWmrCPpIKTWmo7EyAAIEkiMdJQIAAAQIECBAgQIBAkQIWRRepq24CBAgQIECAAIFhE3D9PGwjqj8ECBAgQIAAAQIERlNAPNJojrteEyBAgAABAgQIECBAgEDxApIKFW/sCAQIECBAgAABAgQIEGhb4Jprrkkbbrhhbb+zzjorrbfeek3r+dvf/pbWWGON2ueRYOi8886bsP1BBx2UTjjhhMrPZ86cmS688MJcbTvyyCPT4YcfXtm2PhnRRRddVKlrKqVVUqFIstSqSCrUSsjnBAgQ6I6AIJ7uOKqFAAECBAgQIECAAIHGAhZFOzMIECBAgAABAgQI5Bdw/ZzfypYECBAgQIAAAQIECAyugHikwR0bLSNAgAABAgQIECBAgACBcgtIKlTu8dN6AgQIECBAgAABAgSGVGDXXXdNkWhnKuXRRx9NyyyzzLgqIjFQJAiK8s53vjNlg0wnO9Zee+2VvvOd71Q2qU8q9Mtf/jJ98IMfrO2+xx57pHnmmaetph9yyCFphRVWqO3zs5/9LM2YMaP2b0mF2uK0MQECBAoVEMRTKK/KCRAgQIAAAQIECIy8gEXRI38KACBAgAABAgQIEGhDwPVzG1g2JUCAAAECBAgQIEBgYAXEIw3s0GgYAQIECBAgQIAAAQIECJRcQFKhkg+g5hMgQIAAAQIECBAgMHwCTz31VJo+ffqUO3b00UenQw89dFw9p512Wtp3331rP3vllVdyJQDadNNN0xVXXFHZrz6p0O23357e8Y531Op84oknptx+SYWmPPwqIECAQGECgngKo1UxAQIECBAgQIAAAQIpjUuC/a53vYsJAQIECBAgQIAAAQKTCEgq5PQgQIAAAQIECBAgQGAYBMQjDcMo6gMBAgQIECBAgAABAgQIDKKApEKDOCraRIAAAQIECBAgQIDASAuceOKJ6cADD6wZbLTRRrk97rzzzvTkk09Wtn/Tm96UHnjggTTffPPV9q9P1vO73/0urb766pPW/+c//zktu+yy6fnnn69sV59U6K9//WtaaKGFanXcdNNNaZ111snd5kYbSio0JT47EyBAoFABQTyF8qqcAAECBAgQIECAwMgLWBQ98qcAAAIECBAgQIAAgTYEXD+3gWVTAgQIECBAgAABAgQGVkA80sAOjYYRIECAAAECBAgQIECAQMkFJBUq+QBqPgECBAgQIECAAAECwyXwyiuvpBVWWCHdd999lY599KMfTeeee27uTp599tlp1113rW3/y1/+Mn3gAx+o/TsSA73uda+r/XvrrbdOkcBnsnLEEUekWbNm1TapTyoUHyy55JK1ZEaf//zn01FHHZW7zY02LDKp0GGHHVZrX6O+TKnhdiZAgMAICAjiGYFB1kUCBAgQIECAAAECfRSwKLqP+A5NgAABAgQIECBQOgHXz6UbMg0mQIAAAQIECBAgQKCBgHgkpwUBAgQIECBAgAABAgQIEChGQFKhYlzVSoAAAQIECBAgQIAAgY4ErrrqqrTxxhvX9r300kvTFltskbuuv/zlL2nhhReubb/ddtuln/zkJ+P2j6RDkXyoWk466aT06U9/Os0zzzwTjvPrX/86bbbZZuN+3igRz5577pm++93v1rZ7+OGH05ve9Kam7b7sssvSZz/72XT00UenbbfddsJ2RSYV+va3v53+/d//vXLMRRZZpJIM6dWvfnVuYxsSIEBg1AUE8Yz6GaD/BAgQIECAAAECBIoVsCi6WF+1EyBAgAABAgQIDJeA6+fhGk+9IUCAAAECBAgQIDCqAuKRRnXk9ZsAgTIKzJkzp9bs7IuLy9gXbSZAgAABAgQIjIKApEKjMMr6SIAAAQIECBAgQIBAaQR23nnn9OMf/7jS3unTp6d4UDrffPO11f599903nXbaabV96hP8PPjgg2n55ZcfV2ckH4r9VltttbTQQgul22+/PV100UWVpD/1pVFSoWjnG9/4xtqmK664YjrvvPPSGmusMWH/K6+8Mm2yySa1nx944IHpa1/72rjtikwqVJ8oKZIbHXPMMWnBBRdsy9nGBAgQGFUBQTyjOvL6TYAAAQIECBAgQKA3AhZF98bZUQgQIECAAAECBIZDwPXzcIyjXhAgQIAAAQIECBAYdQHxSKN+Bug/AQJlEsi+yHhsbKxMTddWAgQIECBAgMBICkgqNJLDrtMECBAgQIAAAQIECAyiwJNPPpmWXHLJWtOOOOKI9KUvfantpt58881pnXXWqe135JFHpi9+8Yvj6jn33HPTDjvskKvuRRZZJK255prp2muvrWzfKKlQ/DwSAx188MHj6pw5c2Z65zvfmZZYYokUAa1Rx9y5c8dtc+ONN6Z111133M+KTCr04osvpre//e3pvvvuqx0zEjittdZaabHFFqv97Pvf/3567Wtfm8vIRgQIEBglAUE8ozTa+kqAAAECBAgQIECg9wIWRffe3BEJECBAgAABAgTKK+D6ubxjp+UECBAgQIAAAQIECPyfgHgkZwMBAgTKIyCpUHnGSksJECBAgAABAiEgqZDzgAABAgQIECBAgAABAgMicMIJJ6SDDjqo1pr7778/Lb/88h21btVVV0133nlnZd9ImPPoo4+m+eeff1xdv/71r9N2222Xnn/++abHiIRC119/fTrjjDMqSYOiNEsq9NJLL6Wjjz46HX744bnbfMEFF6QPfehDE7YvMqlQHOyyyy5LW2655aTt/NOf/pQWXXTR3H2xIQECBEZFQBDPqIy0fhIgQIAAAQIECBDoj4BF0f1xd1QCBAgQIECAAIFyCrh+Lue4aTUBAgQIECBAgAABAuMFxCM5IwgQIFAeAUmFyjNWWkqAAAECBAgQCAFJhZwHBAgQIECAAAECBAgQGBCBddZZJ918882V1kTCm0suuaTjlp166qlpv/32q+1/ww03pPXWW29CfX/961/TeeedlyKJzz333JMikVEkJNpggw1StCf+d8kll0x77713+ta3vlXZf6ONNkpXXnll07bdeuutaZ999kk33nhj02123333dNhhh6W3ve1tDbe54oor0qabblr5LBIbPffccy0tou1vectbats99thjaamllmq632233ZaOPPLIinOjxEqSCrUktwEBAiMqIIhnRAdetwkQIECAAAECBAj0SMCi6B5BOwwBAgQIECBAgMBQCLh+Hoph1AkCBAgQIECAAAECIy8gHmnkTwEABAiUSEBSoRINlqYSIECAAAECBCQVcg4QIECAAAECBAgQIECAQB6BLbbYIl1++eWVTT/xiU+k733vey13+/vf/57mzp2b7rrrrkrSnsUWWywtvfTS6R3veEclUdCglFdeeSU9+eSTKdqbLcstt1yad955B6WZ2kGAAIGBERDEMzBDoSEECBAgQIAAAQIEhlLAouihHFadIkCAAAECBAgQKEjA9XNBsKolQIAAAQIECBAgQKCnAuKResrtYAQIEJiSgKRCU+KzMwECBAgQIECg5wLzjI2NjfX8qA5IgAABAgQIECBAgAABAqURiKQ7kQwoEu9EOf7449PBBx9cmvZrKAECBAh0V0AQT3c91UaAAAECBAgQIECAwHgBi6KdEQQIECBAgAABAgTyC7h+zm9lSwIECBAgQIAAAQIEBldAPNLgjo2WESBAoF5AUiHnBAECBAgQIECgXAKSCpVrvLSWAAECBAgQIECAAAECXRH4+9//XkkOtM0226S11lpr0jrPPffctMMOO9S2ufDCC9PMmTO70g6VECBAgED5BATxlG/MtJgAAQIECBAgQIBAmQQsii7TaGkrAQIECBAgQIBAvwVcP/d7BByfAAECBAgQIECAAIFuCIhH6oaiOggQINAbAUmFeuPsKAQIECBAgACBbglIKtQtSfUQIECAAAECBAgQIECgJAL33ntv+tjHPpZuueWWtMgii6TLLrssrbfeeg1bf+edd6Ytt9wyPfLII5XPp0+fnmL/2E8hQIAAgdEUEMQzmuOu1wQIECBAgAABAgR6JWBRdK+kHYcAAQIECBAgQGAYBFw/D8Mo6gMBAgQIECBAgAABAuKRnAMECBAoj4CkQuUZKy0lQIAAAQIECISApELOAwIECBAgQIAAAQIECIyYwCWXXJK22mqrcb3efffd05prrplWX331NG3atHTPPfekm2++OR177LHjtjv//PPThz/84RET010CBAgQyAoI4nE+ECBAgAABAgQIECBQpIBF0UXqqpsAAQIECBAgQGDYBFw/D9uI6g8BAgQIECBAgACB0RQQjzSa467XBAiUU0BSoXKOm1YTIECAAAECoysgqdDojr2eEyBAgAABAgQIECAwwgKHHXZYOuqoo9oSiMRDp59+elv72JgAAQIEhk9AEM/wjakeESBAgAABAgQIEBgkAYuiB2k0tIUAAQIECBAgQGDQBVw/D/oIaR8BAgQIECBAgAABAnkExCPlUbINAQIEBkNAUqHBGAetIECAAAECBAjkFZBUKK+U7QgQIECAAAECBAgQIDBkAhdccEHaZ5990pNPPjlpz6ZPn56+973vpRkzZgyZgO4QIECAQCcCgng6UbMPAQIECBAgQIAAAQJ5BSyKzitlOwIECBAgQIAAAQIpuX52FhAgQIAAAQIECBAgMAwC4pGGYRT1gQCBURGQVGhURlo/CRAgQIAAgWERkFRoWEZSPwgQIECAAAECBAgQINCBwMsvv5xuuummdO2116bHH388xYPZsbGxtOyyy6aVV145rbDCCmnttddOCy+8cAe124UAAQIEhlFAEM8wjqo+ESBAgAABAgQIEBgcAYuiB2cstIQAAQIECBAgQGDwBVw/D/4YaSEBAgQIECBAgAABAq0FxCO1NrIFAQIEBkVAUqFBGQntIECAAAECBAjkE5BUKJ+TrQgQIECAAAECBAgQIECAAAECBAgQSKmSgO6xxx6rWCy99NJpmWWW4UKAAAECBAgQIECAAIGuCVgU3TVKFREgQIAAAQIECIyAgOvnERhkXSRAgAABAgQIECAwAgLikUZgkHWRAIGhEZBUaGiGUkcIECBAgACBERGQVGhEBlo3CRAgQIAAAQIECBAgQIAAAQIECHRDQBBPNxTVQYAAAQIECBAgQIBAMwGLop0bBAgQIECAAAECBPILuH7Ob2VLAgQIECBAgAABAgQGV0A80uCOjZYRIECgXkBSIecEAQIECBAgQKBcApIKlWu8tJYAAQIECBAgQIAAAQIECBAgQIBAXwUE8fSV38EJECBAgAABAgQIDL2ARdFDP8Q6SIAAAQIECBAg0EUB189dxFQVAQIECBAgQIAAAQJ9ExCP1Dd6ByZAgEDbApIKtU1mBwIECBAgQIBAXwUkFeorv4MTIECAAAECBAgQIECAAAECBAgQKJeAIJ5yjZfWEiBAgAABAgQIECibgEXRZRsx7SVAgAABAgQIEOingOvnfuo7NgECBAgQIECAAAEC3RIQj9QtSfUQIECgeAFJhYo3dgQCBAgQIECAQDcFJBXqpqa6CBAgQIAAAQIECBAgQIAAAQIECAy5gCCeIR9g3SNAgAABAgQIECDQZwGLovs8AA5PgAABAgQIECBQKgHXz6UaLo0lQIAAAQIECBAgQKCJgHgkpwYBAgTKIyCpUHnGSksJECBAgAABAiEgqZDzgAABAgQIECBAgAABAgQIECBAgACB3AKCeHJT2ZAAAQIECBAgQIAAgQ4ELIruAM0uBAgQIECAAAECIyvg+nlkh17HCRAgQIAAAQIECAyVgHikoRpOnSFAYMgFJBUa8gHWPQIECBAgQGDoBCQVGroh1SECBAgQIECAAAECBAgQIECAAAECxQkI4inOVs0ECBAgQIAAAQIECKRkUbSzgAABAgQIECBAgEB+AdfP+a1sSYAAAQIECBAgQIDA4AqIRxrcsdEyAgQI1AtIKuScIECAAAECBAiUS0BSoXKNl9YSIECAAAECBAgQIECAAAECBAgQ6KuAIJ6+8js4AQIECBAgQIAAgaEXsCh66IdYBwkQIECAAAECBLoo4Pq5i5iqIkCAAAECBAgQIECgbwLikfpG78AECBBoW0BSobbJ7ECAAAECBAgQ6KuApEJ95XdwAgQIECBAgAABAgQIECBAgAABAuUSEMRTrvHSWgIECBAgQIAAAQJlE7Aoumwjpr0ECBAgQIAAAQL9FHD93E99xyZAgAABAgQIECBAoFsC4pG6JakeAgQIFC8gqVDxxo5AgAABAgQIEOimgKRC3dRUFwECBAgQIECAAAECBAgQIECAAIEhFxDEM+QDrHsECBAgQIAAAQIE+ixgUXSfB8DhCRAgQIAAAQIESiXg+rlUw6WxBAgQIECAAAECBAg0ERCP5NQgQIBAeQQkFSrPWGkpAQIECBAgQCAEJBVyHhAgQIAAAQIECBAgQIAAAQIECBAgkFtAEE9uKhsSIECAAAECBAgQINCBgEXRHaDZhQABAgQIECBAYGQFXD+P7NDrOAECBAgQIECAAIGhEhCPNFTDqTMECAy5gKRCQz7AukeAAAECBAgMnYCkQkM3pDpEgAABAgQIECBAgAABAgQIECBAoDgBQTzF2aqZAAECBAgQIECAAIGULIp2FhAgQIAAAQIECBDIL+D6Ob+VLQkQIECAAAECBAgQGFwB8UiDOzZaRoAAgXoBSYWcEwQIECBAgACBcglIKlSu8dJaAgQIECBAgAABAgQIECBAgAABAn0VEMTTV34HJ0CAAAECBAgQIDD0AhZFD/0Q6yABAgQIECBAgEAXBVw/dxFTVQQIECBAgAABAgQI9E1APFLf6B2YAAECbQtIKtQ2mR0IECBAgAABAn0VkFSor/wOToAAAQIECBAgQIAAAQIECBAgQKBcAoJ4yjVeWkuAAAECBAgQIECgbAIWRZdtxLSXAAECBAgQIECgnwKun/up79gECBAgQIAAAQIECHRLQDxStyTVQ4AAgeIFJBUq3tgRCBAgQIAAAQLdFJBUqJua6iJAgAABAgQIECBAgAABAgQIECAw5AKCeIZ8gHWPAAECBAgQIECAQJ8FLIru8wA4PAECBAgQIECAQKkEXD+Xarg0lgABAgQIECBAgACBJgLikZwaBAgQKI+ApELlGSstJUCAAAECBAiEgKRCzgMCBAgQIECAAAECBAgQIECAAAECBHILCOLJTWVDAgQIECBAgAABAgQ6ELAougM0uxAgQIAAAQIECIysgOvnkR16HSdAgAABAgQIECAwVALikYZqOHWGAIEhF5BUaMgHWPcIECBAgACBoROQVGjohlSHCBAgQIAAAQIECBAgQIAAAQIECBQnIIinOFs1EyBAgAABAgQIECCQkkXRzgICBAgQIECAAAEC+QVcP+e3siUBAgQIECBAgAABAoMrIB5pcMdGywgQIFAvIKmQc4IAAQIECBAgUC4BSYXKNV5aS4AAAQIECBAgQIAAAQIECBAgQKCvAoJ4+srv4AQIECBAgAABAgSGXsCi6KEfYh0kQIAAAQIECBDoooDr5y5iqooAAQIECBAgQIAAgb4JiEfqG70DEyBAoG0BSYXaJrMDAQIECBAgQKCvApIK9ZXfwQkQIECAAAECBAgQIECAAAECBAiUS0AQT7nGS2sJECBAgAABAgQIlE3AouiyjZj2EiBAgAABAgQI9FPA9XM/9R2bAAECBAgQIECAAIFuCYhH6pakeggQIFC8gKRCxRs7AgECBAgQIECgmwKSCnVTU10ECBAgQIAAAQIECBAgQIAAAQIEhlxAEM+QD7DuESBAgAABAgQIEOizgEXRfR4AhydAgAABAgQIECiVgOvnUg2XxhIgQIAAAQIECBAg0ERAPJJTgwABAuURkFSoPGOlpQQIECBAgACBEJBUyHlAgAABAgQIECBAgAABAgQIECBAgEBuAUE8ualsSIAAAQIECBAgQIBABwIWRXeAZhcCBAgQIECAAIGRFXD9PLJDr+MECBAgQIAAAQIEhkpAPNJQDafOECAw5AKSCg35AOseAQIECBAgMHQCkgoN3ZDqEAECBAgQIECAAAECBAgQIECAAIHiBATxFGerZgIECBAgQIAAAQIEUrIo2llAgAABAgQIECBAIL+A6+f8VrYkQIAAAQIECBAgQGBwBcQjDe7YaBkBAgTqBSQVck4QIECAAAECBMolIKlQucZLawkQIECAAAECBAgQIECAAAECBAj0VUAQT1/5HZwAAQIECBAgQIDA0AtYFD30Q6yDBAgQIECAAAECXRRw/dxFTFURIECAAAECBAgQINA3AfFIfaN3YAIECLQtIKlQ22R2IECAAAECBAj0VUBSob7yOzgBAgQIECBAgAABAgQIECBAgACBcgkI4inXeGktAQIECBAgQIAAgbIJWBRdthHTXgIECBAgQIAAgX4KuH7up75jEyBAgAABAgQIECDQLQHxSN2SVA8BAgSKF5BUqHhjRyBAgAABAgQIdFNAUqFuaqqLAAECBAgQIECAAAECBAgQIECAwJALCOIZ8gHWPQIECBAgQIAAAQJ9FrAous8D4PAECBAgQIAAAQKlEnD9XKrh0lgCBAgQIECAAAECBJoIiEdyahAgQKA8ApIKlWestJQAAQIECBAgEAKSCjkPCBAgQIAAAQIECBAgQIAAAQIECBDILSCIJzeVDQkQIECAAAECBAgQ6EDAougO0OxCgAABAgQIECAwsgKun0d26HWcAAECBAgQIECAwFAJiEcaquHUGQIEhlxAUqEhH2DdI0CAAAECBIZOQFKhoRtSHSJAgAABAgQIECBAgAABAgQIECBQnIAgnuJs1UyAAAECBAgQIECAQEoWRTsLCBAgQIAAAQIECOQXcP2c38qWBAgQIECAAAECBAgMroB4pMEdGy0jQIBAvYCkQs4JAgQIECBAgEC5BCQVKtd4aS0BAgQIECBAgAABAgQIECBAgACBvgpkg3iWX375NG3atL62x8EJECBAgAABAgQIEBguAYuih2s89YYAAQIECBAgQKBYAdfPxfqqnQABAgQIECBAgACB3ghIKtQbZ0chQIBANwQkFeqGojoIECBAgAABAr0TkFSod9aORIAAAQIECBAgQIAAAQIECBAgQKD0AtkgntJ3RgcIECBAgAABAgQIEBhogXe9610D3T6NI0CAAAECBAgQINBvgWxSoX63xfEJECBAgAABAgQIECDQqcCCCy6YXnzxxcruSy+9dFpmmWU6rcp+BAgQIFCwgKRCBQOrngABAgQIECDQZQFJhboMqjoCBAgQIECAAAECBAgQIECAAAECwywgqdAwj66+ESBAgAABAgQIEBgsAUmFBms8tIYAAQIECBAgQGDwBCQVGrwx0SICBAgQIECAAAECBKYmIKnQ1PzsTYAAgaIFJBUqWlj9BAgQIECAAIHuCkgq1F1PtREgQIAAAQIECBAgQIAAAQIECBAYaoEHHnggPfPMM0PdR50jQIAAAQIECBAgQGAwBCQVGoxx0AoCBAgQIECAAIHBFZBUaHDHRssIECBAgAABAgQIEOhMQFKhztzsRYAAgV4JSCrUK2nHIUCAAAECBAh0R0BSoe44qoUAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBDoUODFF19MCy64YId7240AAQIEihaQVKhoYfUTIECAAAECBLorIKlQdz3VRoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg0ETgqquuShtttBEfAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgRKJiCpUMkGTHMJECBAgACBkReQVGjkTwEABAgQIECAAAECBAgQIECAAAECBAgQIECAAIHeCERg0djYWG8O5igFSitoAAAgAElEQVQECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECHRNQFKhrlGqiAABAgQIECDQEwFJhXrC7CAECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdEWmDNnTpo9e3blv1mzZo02ht4TIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKJmApEIlGzDNJUCAAAECBEZeQFKhkT8FABAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEihcQVFS8sSMQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKEpA/E9RsuolQIAAAQIECBQjIKlQMa5qJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQ+P8Cc+bMSbNnz655xP+fNWsWHwIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIESiIgqVBJBkozCRAgQIAAAQL/X0BSIacCAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAoQLZgKLqgcbGxgo9psoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOiegKRC3bNUEwECBAgQIECgFwKSCvVC2TEIECBAgAABAgQIECBAgAABAgQIECBAgAABAiMqMGfOnDR79uwJvY+fzZo1a0RVdJsAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAuQQkFSrXeGktAQIECBAgQEBSIecAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAYQLZYKL6g4yNjRV2XBUTIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINA9AUmFumepJgIECBAgQIBALwQkFeqFsmMQIECAAAECBAgQIECAAAECBAgQIECAAAECBEZQYM6cOWn27NlNex6fzZo1awRldJkAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAuQQkFSrXeGktAQIECBAgQEBSIecAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAIQLZQKJmBxgbGyvk2ColQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKB7ApIKdc9STQQIECBAgACBXghIKtQLZccgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIyYwJw5c9Ls2bNb9jq2mTVrVsvtbECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQP8EJBXqn70jEyBAgAABAgQ6EZBUqBM1+xAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECEwqkA0iakU1NjbWahOfEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQRwFJhfqI79AECBAgQIAAgQ4EJBXqAM0uBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECzQXmzJmTZs+enZsotp01a1bu7W1IgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBvBSQV6q23oxEgQIAAAQIEpiogqdBUBe1PgAABAgQIECBAgAABAgQIECBAgAABAgQIECAwTiAbQJSXZmxsLO+mtiNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoMcCkgr1GNzhCBAgQIAAAQJTFJBUaIqAdidAgAABAgQIECBAgAABAgQIECBAgAABAgQIEPg/gTlz5qTZs2e3TRL7zJo1q+397ECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQPECkgoVb+wIBAgQIECAAIFuCkgq1E1NdREgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIERlwgGzzULsXY2Fi7u9ieAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEeCEgq1ANkhyBAgAABAgQIdFFAUqEuYqqKAAECBAgQIECAAAECBAgQIECAAAECBAgQIDDKAnPmzEmzZ8/umCD2nTVrVsf725EAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgWIEJBUqxlWtBAgQIECAAIGiBCQVKkpWvQQIECBAgAABAgQIECBAgAABAgQIECBAgACBERPIBg512vWxsbFOd7UfAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIFCUgqVBCsagkQIECAAAECBQlIKlQQrGoJECBAgAABAgQIECBAgAABAgQIECBAgAABAqMkMGfOnDR79uwpdznqmDVr1pTrUQEBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAt0TkFSoe5ZqIkCAAAECBAj0QkBSoV4oOwYBAgQIECBAgAABAgQIECBAgAABAgQIECBAYMgFskFDU+3q2NjYVKuwPwECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECXRSQVKiLmKoiQIAAAQIECPRAQFKhHiA7BAECBAgQIECAAAECBAgQIECAAAECBAgQIEBg2AWuuuqqSbu48cYb1z6/8sorJ912o402GnYu/SNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQKgFJhUo1XBpLgAABAgQIEEiSCjkJCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEChcQVFQ4sQMQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKExA/E9htComQIAAAQIECBQiIKlQIawqJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQyAoIKnI+ECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECivgPif8o6dlhMgQIAAAQKjKSCp0GiOu14TIECAAAECBAgQIECAAAECBAgQIECAAAECBHoqIKiop9wORoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCrAuJ/usqpMgIECBAgQIBA4QKSChVO7AAECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKCipwDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBMorIP6nvGOn5QQIECBAgMBoCkgqNJrjrtcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgZ4KCCrqKbeDESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEOiqgPifrnKqjAABAgQIECBQuICkQoUTOwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgICgIucAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgfIKiP8p79hpOQECBAgQIDCaApIKjea46zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAoKcCgop6yu1gBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBLoqIP6nq5wqI0CAAAECBAgULiCpUOHEDkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQICCoyDlAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoLwC4n/KO3ZaToAAAQIECIymgKRCoznuek2AAAECBAgQIECAAAECBAgQIECAAAECBAgQ6KmAoKKecjsYAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAga4KiP/pKqfKCBAgQIAAAQKFC0gqVDixAxAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgqcg4QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKK+A+J/yjp2WEyBAgAABAqMpIKnQaI67XhMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEeiogqKin3A5GgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoKsC4n+6yqkyAgQIECBAgEDhApIKFU7sAAQIECBAgAABAgQIECBAgAABAgQIECBAgAABAoKKnAMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEyisg/qe8Y6flBAgQIECAwGgKSCo0muOu1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBngoIKuopt4MRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ6KqA+J+ucqqMAAECBAgQIFC4gKRChRM7AAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgKAi5wABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACB8gqI/ynv2Gk5AQIECBAgMJoCkgqN5rjrNQECBAgQIECAAAECBAgQIECAAAECBAgQIECgpwKCinrK7WAECBAgQIAAAQIECBAgQIAAAQIECBAgQOD/sXc/Ib6X1R/AP4N/0yIz/yAYZcTFTUUgbgydQcJNCkXYJhcthGqXK2szcxdBBEqrFJEW6s6d4qICZ1wYli2ioBAkMIjQwJL8x/XP/Ph8f8ww3qv3Nvee88z3fM/rC1HqzHOe8zqPI8mbMwQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/GJWh6IAACAASURBVE8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIELFkY6QAAIABJREFUCBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAkJF3gABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBugLyP3Vn5+YECBAgQIBATwFLhXrOXdcECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaECQkVDuRUjQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgECog/xPK6TACBAgQIECAQLqApULpxAoQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgIFXkDBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBOoKyP/UnZ2bEyBAgAABAj0FLBXqOXddEyBAgAABAgQIECBAgAABAgQIECBAgAABAgSGCggVDeVWjAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgECogPxPKKfDCBAgQIAAAQLpApYKpRMrQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgIFTkDRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoKyD/U3d2bk6AAAECBAj0FLBUqOfcdU2AAAECBAgQIECAAAECBAgQIECAAAECBAgQGCogVDSUWzECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECoQLyP6GcDiNAgAABAgQIpAtYKpROrAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgIBQkTdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoK6A/E/d2bk5AQIECBAg0FPAUqGec9c1AQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCogFDRUG7FCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECIQKyP+EcjqMAAECBAgQIJAuYKlQOrECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECQkXeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIG6AvI/dWfn5gQIECBAgEBPAUuFes5d1wQIECBAgAABAgQIECBAgAABAgQIECBAgACBoQJCRUO5FSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQKiD/E8rpMAIECBAgQIBAuoClQunEChAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECAgVeQMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIE6grI/9SdnZsTIECAAAECPQUsFeo5d10TIECAAAECBAgQIECAAAECBAgQIECAAAECBIYKCBUN5VaMAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQKiA/E8op8MIECBAgAABAukClgqlEytAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAgVOQNECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEKgrIP9Td3ZuToAAAQIECPQUsFSo59x1TYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAYKiBUNJRbMQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKhAvI/oZwOI0CAAAECBAikC1gqlE6sAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAgFCRN0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECgroD8T93ZuTkBAgQIECDQU8BSoZ5z1zUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKiAUNFQbsUIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhArI/4RyOowAAQIECBAgkC5gqVA6sQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJCRd4AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgboC8j91Z+fmBAgQIECAQE8BS4V6zl3XBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGhAkJFQ7kVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAqIP8TyukwAgQIECBAgEC6gKVC6cQKECBAgAABAgQIECBAgAABAgQIECBAgAABAgQICBV5AwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTqCsj/1J2dmxMgQIAAAQI9BSwV6jl3XRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEhgoIFQ3lVowAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAqID8TyinwwgQIECAAAEC6QKWCqUTK0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQICBU5A0QIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqCsg/1N3dm5OgAABAgQI9BSwVKjn3HVNgAABAgQIECBAgAABAgQIECBAgAABAgQIEBgqIFQ0lFsxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqEC8j+hnA4jQIAAAQIECKQLWCqUTqwAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQICAUJE3QIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKCugPxP3dm5OQECBAgQINBTwFKhnnPXNQECBAgQIECAAAECBAgQIECAAAECBAgQIEBgqIBQ0VBuxQgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiECsj/hHI6jAABAgQIECCQLmCpUDqxAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAhsbG9POzs4CYnt7e1pfX4dCgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEABgTn3M+d/5s+c+5nzPz4ECBAgQIAAAQLLLWCp0HLPx+0IECBAgAABAgQIECBAgAABAgQIECBAgAABAishYKnQSoxREwQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAg0FLBVqOHQtEyBAgAABAuUFLBUqP0INECBAgAABAgQIECBAgAABAgQIECBAgAABAgSWX8BSoeWfkRsSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQ+DABS4W8CwIECBAgQIBAPQFLherNzI0JECBAgAABAgQIECBAgAABAgQIECBAgAABAuUELBUqNzIXJkCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILAQOH78+LS1tbX43/N/b25ukiFAgAABAgQIEFhyAUuFlnxArkeAAAECBAgQIECAAAECBAgQIECAAAECBAgQWAUBwaJVmKIeCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEOgrI/nScup4JECBAgACB6gKWClWfoPsTIECAAAECBAgQIECAAAECBAgQIECAAAECBAoICBYVGJIrEiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEPgQAdkfz4IAAQIECBAgUE/AUqF6M3NjAgQIECBAgAABAgQIECBAgAABAgQIECBAgEA5gZ2dnWljY2Nx7/X19Wl7e7tcDy5MgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoKOApUIdp65nAgQIECBAoLqApULVJ+j+BAgQIECAAAECBAgQIECAAAECBAgQIECAAIECAgeXCs3X3d3dLXBrVyRAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYG1tbR9B7sd7IECAAAECBAjUELBUqMac3JIAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUF5gY2NjmpcLzZ/t7e1pfX29fE8aIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILDKAn6Z2CpPV28ECBAgQIDAKgtYKrTK09UbAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCJBA4uFdra2po2NzeX6HauQoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAyQLHjx+f5qzP/JH58T4IECBAgAABAnUELBWqMys3JUCAAAECBAgQIECAAAECBAgQIECAAAECBAiUFjj4W8vW19en7e3t0v24PAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIFVF/CLxFZ9wvojQIAAAQIEVlXAUqFVnay+CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJLKLC2trZ/q93d3SW8oSsRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQILAnIO/jLRAgQIAAAQIEagpYKlRzbm5NgAABAgQIECBAgAABAgQIECBAgAABAgQIECgpcPA3l21vb0/r6+sl+3BpAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAqsucPz48Wlra2vR5pzzmfM+PgQIECBAgAABAjUELBWqMSe3JECAAAECBAgQIECAAAECBAgQIECAAAECBAishICg0UqMURMECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQINBA7+ArF5udDm5maDrrVIgAABAgQIEFgNAUuFVmOOuiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIlBFYW1vbv+v828vm32LmQ4AAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDA8ggc/OVh8612d3eX53JuQoAAAQIECBAgcEYBS4XOSOQLCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEIgUOBo7mhULzYiEfAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSWR+DgLw7b2tqaNjc3l+dybkKAAAECBAgQIHBGAUuFzkjkCwgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKIFNjY2pp2dncWxQkfRus4jQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgcPYCB39p2HzK7u7u2R/mOwkQIECAAAECBI5EwFKhI2FXlAABAgQIECBAgAABAgQIECBAgAABAgQIECDQW2BeKDQvFtr7CB71fg+6J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQWB6BtbW1/cv4hWHLMxc3IUCAAAECBAgcRsBSocNo+VoCBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEwgXmp0LxcaP6sr69P29vbYWc7iAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBwwvI9BzezHcQIECAAAECBJZRwFKhZZyKOxEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGgjMC4XmENLex281azB0LRIgQIAAAQIECBAgQIBAG4G//vWv02uvvbbo9/zzz59uuOGGNr1rlACBwwm88cYb05///Of9b/rsZz87XXPNNYc7xFcTIECAAAECBAgQIECAAAECIQLHjx+f5gzP3keeJ4TVIQQIECBAgACBIxGwVOhI2BUlQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCYBQSRvAMCBAgQIECAAAECBAgQIHCqwLvvvjv95je/mf74xz9Of//736d//OMf08UXXzx95jOfWfzn1ltvnb74xS8uNd3Xv/716amnnlrc8aqrrppefvnl/fu+9dZb07Fjx/b/+Lbbbpsefvjhpe4n4nKrMNcIh3M541vf+tb0u9/9bnHEJZdcMr3wwgvncpzvXRKBP/3pT9OXv/zl/ds88MAD0/e+971zut38Nn79619PL7300uLn6IkTJxY/P+eFRfOSs1tuuWVaW1s7pxq+mQABAgQIECBAgAABAgQIrJqAHM+qTVQ/BAgQIECAQHcBS4W6vwD9EyBAgAABAgQIECBAgAABAgQIECBAgAABAgSOWODkQNL6+vq0vb19xLdSngABAgQIECBAgAABAgQIjBd47733pp///OfTz372s+mVV1457QVuuummxbLeecHQiM/vf//7/TKXX3759IUvfOG0ZU+3VOjNN9+cLr300v3vv/3226cnnnhiRBtHUmOZ53okIAeKvv7669Nf/vKX/T/zuc99brGE6qM+X/3qV6dnn312/y/v7u4edQvqBwhELhV6/vnnp3vvvXd6+umnT3uzL33pS9PW1tb0jW98I6CD/CPmJUmvvfbaotAFF1wwfeUrX8kvGljhsP8MCSztKAIECBAgQIAAAQIECBD4HwU2NjamnZ2d/a+e/3/z5ubm//jdvowAAQIECBAgQGAZBSwVWsapuBMBAgQIECBAgAABAgQIECBAgAABAgQIECBAoJnAyYuF5vaFk5o9Au0SIECAAAECBAgQIECgucC8LOKuu+6annzyyUNJ3HfffdM999xzqO85my9eW1vb/7b5no888shpj7FU6P95ln2uZ/MWIr9nXgBz44037h/5y1/+cvrud7/7kSUsFYrUX56zopYKPfbYY4ufo4f53H///dMPf/jDw3zLkXzt6X6mHsmFDln0sP8MOeTxvpwAAQIECBAgQIAAAQIEzkFAZucc8HwrAQIECBAgQGDJBSwVWvIBuR4BAgQIECBAgAABAgQIECBAgAABAgQIECBAoIvAh4WU5t4tF+ryAvRJgAABAgQIECBAgACBvgLvv//+9LWvfW16+umnT0E4duzYdMMNNyyW08wLWF555ZVTvuYXv/jF9P3vfz8V8LALIU63AOOdd96ZPv/5z08nTpxY3Pmb3/zm9MADD6Te/ygOrzDXo3A5WPOwS4W+/e1vTzs7O4sjLrvssumFF1446hbUDxCIWCr01FNPTfPPnZM/n/jEJ6Z5GdVVV101vfjii9Ozzz57ytc8+uij03e+852ATvKOsFQoz9bJBAgQIECAAAECBAgQ6Cow/zuWOauz9+9a9hzkdLq+CH0TIECAAAECqyhgqdAqTlVPBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAnthpZMDS+vr69P8n83NzaKduTYBAgQIECBAgAABAgQIEPhogQcffPCUpUB33nnnYtHO5Zdf/oFv/MMf/jDNi1X+9re/feDPz3983XXXpTFHLhVKu+SSHVxhrkdNdtilQkd9X/VzBM51qdC///3v6frrr//A0rV5idDjjz8+3Xzzzaf8rPzBD34w/epXv9r/89dee+1i4dBFF12U02DAqZYKBSA6ggABAgQIECBAgAABAgQWAh+1TGgvlzP/tw8BAgQIECBAgMBqCFgqtBpz1AUBAgQIECBAgAABAgQIECBAgAABAgQIECBAYKUE5uVC828++7DP3oKhW265ZbFoyIcAAQIECBAgQIAAAQIECFQWOHHixHTFFVdM//3vf/fb+MlPfjL9+Mc//si25q+94447PvBbxO++++7poYceSqNYpqVCr7766jTf51Of+tRZ9fvmm29O//nPf6arr756Ou+8887qjDN9U5W5ntzHu+++u1jMMi+zuvjii8/U5il//fXXX1/YXnbZZdPHP/7xM37/iKVC77zzzvSvf/1r+tjHPnbWb+ZgI//85z+nT37yk9Mll1xyxv5O/oL57b799tvTpz/96aELbPYMLrzwwsXPm3P5zG/k5ZdfXvz9c/755x/6qPl9zH9/zEt/9j7nulTopz/96fSjH/1o/7xjx45Nv/3tbxfOH/aZZ7CxsTE999xz+3/5iSeemG6//fbT9jMvL3rrrbemK6+8crrgggsO3fvBb3jjjTcWP/dnx4M/Xz/q0IilQuf69/fBux325/Bh/xlyTri+mQABAgQIECBAgAABAgQ+IDAvEXrmmWcW/y7x5F/yNX+hZUIeDAECBAgQIEBgdQUsFVrd2eqMAAECBAgQIECAAAECBAgQIECAAAECBAgQIFBe4HTLhfaaO3n50LxsaO9j6VD5J6ABAv/H3p0AS1XdiR8/IxKNTjQuIYrEBVCMGhghRFSME7eoFChR0BnFQRHjhgsqYsZt3IgSR43LaAJuQFScqLghgzqTTCgpR0VxGUUT9924o4lC/NfvVvr+u/v1e/R79xFvnM+pssbuvuf2uZ9zb1NJDd8QIECAAAECBAgQIPCFF7jrrrvSbrvtll9nxDAef/zxZcY6FixYkPr375/P+8pXvpLeeuutFNGQyjjggANSRF5iDBo0KE2YMKGhZwQ57r///uyz1VZbLV199dXptddeS0cddVSKCEWMm2++OZ8bMZBtt9225lwR6BhfK5vcAAAgAElEQVQ3blz+3rICGCNHjszPHf9Z/uijj87nPv300+nEE0/MX8+cOTPF9U6bNi3NmTMnLVq0KPss1hFzY/09e/Zs81554IEH0uTJk9PDDz+cz48JAwcOTN///vezIElHIjGtfWlZ97XReiOSc84552QRloceeig/ZLPNNsvum1NPPTVtsMEGrfrGvPPOOy/de++9NXGsuCf32GOP9MMf/jANHjw4nx9/ie2iiy7KXkekpfovs/Xt2zf16tWr5ruOOOKItOOOO2bvnXXWWfkaI3w0ZcqUhuuK6E1EtuJe/t3vfldzTGVN1c9d9QGzZs1K11xzTfbWFltskc4444z07//+7ymiM3H/RXQpRtxze+65ZxbGjmttNOL5+eUvf5kuvPDCmoBN5f4dPXp0iiBY796927x/O/LhK6+8khlMnTo1vfTSS/kpYq2bbrppGjNmTPZPozBQtfM+++yThg8fni677LJ09913pzvuuCM/V/wGHXzwwdker7DCCq0u86mnnsoMZsyYkd8jlec35kakp1+/fvn8f/u3f0uHHnpo05cdcyNMVBm33HJLdu+1NeJa4ndn1KhRae+99251D2bPnp2uuOKKFPdF9Yj9j/075JBDsjBQo1H9Oxf3Udyzca577rknzZs3L5sS+zFgwIB0yimnpB122KHmNGEfQagYsd7q+FzsSfVo7Xno6PNd9He46J8hTW++AwkQIECAAAECBAgQIECgRSgo/ruXGK1FhKrJ4r/XOO200ygSIECAAAECBAh8QQVEhb6gG+uyCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJfJIGICzXz/+z0Rbpm10KAAAECBAgQIECAAAECX3yBzz77LB122GHp8ssvzy/2+uuvTxGSaGbEcRHcqYyIukTcpzIiEFSJUOy1115ZGKXR+MEPfpBHgyJw8f7776cHH3wwffvb325mGdkxJ598cjrzzDPz45cVFfqbv/mb/NiIelx77bX56//5n/9J3/nOd/LXc+fOTTvvvHOba2ktIvLJJ5+ks88+OwvDtDUiEBL2ERnqjFHWfa2/thtuuCGL2lTHShpdf+xP7FP9GD9+fLrggguWSRbRpgjVRHgm4jLHHnvsMudUDoiQzy677JK9XNZ9Fce8/PLL6bvf/W6LmFD9F0aMqjpeVfn8X//1X9Nxxx2XvYxg9ZAhQ9IJJ5zQ6np79OiRBV/69OlTc8zixYuzYFUlHtPWBUd4KJ7Dzhrx36MNGzZsmfsaUaBY+xprrFHz1dXO8WxH6Kw6LFa/znCK+M7KK6/c4hIiThPRnLbusQjzRACpMtoTFXr22WdromIRpop4WPVvTEddI5bV6B6pPl/8dsRf1oz7oH5UryGiaPGXNOsjV9Vz4jmJwFdltOcaIgB233331SyhyPNd9He4I3+GxG+EQYAAAQIECBAgQIAAAQLLXyD+c3z8Iya0/K19AwECBAgQIEDg8xYQFfq8d8D3EyBAgAABAgQIECBAgAABAgQIECBAgAABAgQItEsgAkMx4n8tzSBAgAABAgQIECBAgAABAn/NAhEVighQBEAq4/nnn0/rr79+U5d16aWXpiOPPDI/durUqemggw7KX/8lo0JXXXVVGj16dP7dy4q/tCcq1AxGxJDCrj6OEoGOf/7nf27mFCnO8cILL6SvfvWrTR3f1kFl3dfqNf/3f/93Ft9pdkSwJMIllRGRqhEjRjQ7PU2ZMiWNGTOm3VGhiNL07t07+55l3VfNBoUqi24UFqqOCjV7cRG9+o//+I+aw8eNG5cuueSSZk+RHnvssbT55ps3fXxrB7744otN/4bEOSKAddlll9Wcrtq52QXFsxZRnOrx6quvZoGwl156qdnTZMe1JyoUQZ/4i5CV0eh62vXlfz64maBQ5bythYXaEwWqnOs3v/lN2nbbbbOX7Zkfv7/xO1wZRZ/v+qhQM4bVv8PtjQrF2g888MBmvsYxBAgQIECAAAECBAgQINBOgcp/bo6IUPV/hm7naRxOgAABAgQIECDwVyggKvRXuGmWTIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg8P8FKpGhyjvVfxGz+t+ZESBAgAABAgQIECBAgACBsglEVKhPnz5p0aJF+dI+/fTTtOKKKza11DvuuCOLrFTGWWedVRPQKRIVevvtt9M999yTn3vkyJH5v0fw4uijj65ZY7zXvXv3/L1lxV86EhWaOHFiGjp0aPr617+eInBz+OGHpw8++CD/zggQV/8vrD/33HNpo402qlnnFVdckeJaVl999Sx0cuaZZ6af//zn+THjx49P559/flP+bR1U1n2trHnJkiWpX79+6Yknnsgv45hjjkknnHBCto/vvPNOuuaaa9Kxxx6bf96/f/90//33py5dumTv1YdnzjjjjMy2V69e6dlnn81iWYccckg+f/jw4emmm25KTz31VFq4cGH2ftz7J598cn7MoYcemnbYYYca2phXeSbauq+WLl2aNttss5rnqW/fviliN1tssUX6/e9/n2bNmpVindXjuuuuS/vuu2/+VqOoUMRSJk2alP/Fu7iOU089teY88bxU1h7P8Ze+9KWaz2fOnJnFYtZaa630+OOPp1/84hc199qFF17Y4rnqyI14+eWXZ6Ggyhg7dmz2OgzC6Lbbbsv2qXrEfm244YYNn9/Km2EZz+BWW22V3nrrrWztcU3VI+6b6ijXjjvumO699978kG7duqXJkydn51i8eHH2Wdxz9aM9UaEbb7yx5noiBtTonO2xvOGGG2ruiZgbvy/Dhg1La665Znr00Uez39rKfRyfb7LJJtnzVHk+4r1GUaC4n2NP4l6NYNZxxx1Xc564RyIsFCPCXfHnRIz4fa98X9yPEZGrHvH98UzH6Iznu7WoULO/wx35M2S99dZrzzY5lgABAgQIECBAgAABAgT+LFAfCqq83n777bMjhITcKgQIECBAgACB/7sCokL/d/felRMgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKfs0B1+Kdnz57pt7/9bdMreuyxx9K3vvWt/PiIwlxwwQX56yJRofpFtBUBarTgzo4KXXrppVlEqHr86le/qvlLUUOGDEm33357fkiEj37605/mr6+//vq0zz77tFju7rvvnmbPnp2//8knn6SuXbs2vQ+NDiz7vkYUZ6+99sqXHtGZyy67rMWl/OQnP6kJtMybNy9ts8022XHV4aQImjz55JMtIiq33HJLin+OOOKINHDgwBbnrw+XXHnllenAAw9s1b6t++ruu+9OO++8cz434iwRramP+0RUJ+IwlTFo0KAsUlUZjaJC8XkcVz0iSFUdForITkSpYrz22mtp3XXXzQ8/8sgj08UXX9ziuiJU88c//jGL/qy//vqF7rnqyY888kg65ZRT0qqrrpqmT59eE7qJ4yLsM2HChHzKnXfemXbbbbf8dX0wKvY3Qjdf+9rXatb4ve99L4tHVUZEpyr7/MILL6QNNtgg/yxCOBGRWmeddWrOEc9ePIPVoz1Robhv4/6qjNae8/bgbr311mn+/Pn5lPhdid+X6hH7Fn8ps/q4uXPnpp122ik/rD4qFPGqadOm1YTjIsQUTtWBtIg/rbDCCjXft6zf1OqDO+P5bhQV6sjvcGVd7f0zpD375VgCBAgQIECAAAECBAgQIECAAAECBAgQIECgsYCokDuDAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIPA5CVSHFvr27ZsiBtLsiABR796988PrwyVflKjQZpttlh5//PGGLL169Uq/+93vss/qo0zVwZO2gk31kZmnn366xrXZ/ag+ruz7Wh/Eeemll9J6663X4lLffvvttNZaa+XvX3XVVWn06NHZ68GDB6eIDFXGww8/nPr169curs6MCtVHpCL2stVWWzVcz6677prmzJmTf/b666+nbt26Za/ro0L1sa7KpFdeeaXG7NBDD00Rw4nx0UcfZUGfyojQTsSVunfv3i6f5XXwQw89lAYMGJCfPuJb48aNy1/XR4UiUjN8+PAWy7nxxhvTyJEj8/evu+66FOGcGDNmzEj7779//lm4HnvssQ0vKUJSV199df5Ze6JCl1xySc3ab7311jR06NAO08W9UB0+ithSRJcajbjHIkBUGfX3Sn1UqPo+qz5fRJGqo14vvvhi6tGjR81Xticq1BnPd/2z2dHf4cpFiAp1+JY0kQABAgQIECBAgAABAgQIECBAgAABAgQIdFhAVKjDdCYSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBIoJVId/ImoS0Ylmx/33318TTZkwYUI699xz8+lflKjQ2LFj089+9rOGLPXxk88++6zh9UegI0Ibjcbzzz+fTj/99PyjCIhESKTIKLKvDzzwQIoITWWcdNJJ6ZxzzunUfR01alSaPn16fs6IBbU2IvhSGRMnTkyTJk3KXh511FHp4osvrpkW4ZGI1UTsKUJOcR2bbrppq+fuzKjQnnvumWbNmpV/15IlS1KXLl0afvePf/zjFK6VEZGdLbfcMntZHxUKp/3226/FeeJeW2GFFfL399hjjywcVBl9+vRJixYtqpm33XbbZR7hE0GwbbbZJq277rpFbrU25y5dujSLbj377LP5P88880x69NFHa9b2L//yL+nUU0/Nz1X/XD333HNpgw02aPFd9ft34YUXpog7xTj//PPT8ccfn8+577770qBBgxquNyJChx9+eP5Ze6JCESOqvkerw1cdgV2wYEHq379/PjV+U+O3tdGIe6xr1675RxFeigBTZVSHdOI3KGJBjUb9Pffggw/WrCHmtCcq1BnPd/3edvR3uJFFrO/aa6/tyPaYQ4AAAQIECBAgQIAAAQIECBAgQIAAAQIECLRDQFSoHVgOJUCAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh0pkC/fv3SwoUL81MuXrw4rbLKKk19xY033phGjhyZHxsRj/Hjx+evvyhRocsuuywddthhDU3q4xmVqNCHH36YvvKVrzTlWH/QNddckw444IAOza1Mas++3n777em73/1uiv2KEWGaiJNUxpVXXlkTTemMff3Od76TIhrS3jF69OhUCRC9/PLL6Zvf/Gb64IMP2jxNxFQuv/zyNGTIkBbHdWZUqPqaNtlkk/TUU0+1uq4bbrgh7bvvvvnnc+bMSbvsskv2uj7wEs/nt771rYbnqt6LoUOHpltvvTU/7o477shCMMsaERqKaFZb8aVlnaP+848++igLPp199tnL3J+Y21ZUKJ6j999/v+ESwrh63RdccEE65phjsmMj2hTxpsqI+6V79+4NzzN//vy09dZb55+1Jyr061//Om2//fb53Ppraa/dXXfdVRMVmzlzZhoxYkSrp4lAVISbYkQ0KeJJlVEdFYpzxLkajalTp6aDDz44/yjCYhHnqh7tiQp1xvNd/2x25He4ev3VFqJC7b0rHU+AAAECBAgQIECAAAECBAgQIECAAAECBDomICrUMTezCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKFBapDEXGyJ554Igu1NDPOPffcNHHixPzQ6dOnp/322y9/3Wx8Zs8990yzZs3K5rUWEGlvEGJZAYy2ztee0ExrUaF33303rbHGGs0wtjimM6JCze7r5MmT04QJE9IOO+yQIkKz8sort4jaRDQlwjOV0Rn7GsGShx56qN0+1VGhyv16yCGHpHnz5i3zXNOmTUv7779/zXHt2euY2NZ9VX1Nm222WXr88cdbXdPNN9+cfvCDH+Sfz549O+26667Z6/qo0KJFi9LGG2/c8FxtRYViQgSjxowZk954441l+jz55JOpT58+yzxuWQdE4CYCPW19Z7du3Wo+bysqFMe+/vrrDb+2rahQ/DbFb1RlvPnmm2nttddueJ5HHnkk/d3f/V3+WXuiQi+88ELaYIMN8rn19+iyvOo/r49BReRrjz32aPU0m2++efa7HWPgwIHp/vvvz49t9nezs6NCnfF8t+fZbO13uBqtWYv27pfjCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAgdYFRIXcHQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBz0ngjDPOSKeddlr+7fHvp59++jJXs2TJktSvX788ZhETIqISMZXKqA6eDBkyJAucNBq9evVKESKJ8UWJCv3pT39KXbp0yS935513bso1JvTu3TtFSKXIaGZfL7nkkjRu3Lj8a0aMGJFmzJiRtthiixQhm8p46aWX0nrrrdep+zps2LB022235Xt+1113NXW54RI+9ePZZ59Nv/nNb1KEcZ555pns/y5cuLDmsLi3Ik7z5S9/OX+/PeGSmNRWVCiiQHPmzMnP/dlnn7V6TRdddFE65phj8s/nz5+fttpqq+x1Z0aF4nxLly7NLOI7nn766cxnwYIFKfa1erT1jDa1OX8+aPfdd08RSaqMCN1EQCl+L3r27Jk23HDD9Morr2T/XhnLIyo0adKk9KMf/Sj/jocffjhbQ6MRQbQI01RGe6JC8VvYtWvXfG7co3E/rrLKKstkiz3o0aNHzXGxTxFlqox4To844oiG54p7bIUVVsg/22233dKdd96Zv242pNPZUaHOeL7b82yKCi3zVnMAAQIECBAgQIAAAQIECBAgQIAAAQIECBD4XAREhT4Xdl9KgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIEEjp0UcfTX379q2hiODHuuuu2yZPfYRjk002SU899VTNnG984xt5uCRiQxEdqh/vvPNOWnPNNfO3m4kKjRw5Mt1www1trq+t+EtMbCu20VkxiwiYVMI2f//3f5/+8z//8y92yzWzrxGYGTBgQPrggw/ydcU+PfHEE/nrCL/EcdXhks7Y1wkTJqTJkyfn3/Pxxx+nlVdeuVN9IlQ1duzYdO+99+bnrQ/L1O/15Zdfnn74wx+2uo627quDDz44RZylMp5//vm0/vrrNzxXW8d2dlSotYuJeM0ee+yR3njjjeyQePbee++9mmejvRsS+1gd0xk0aFC67777WpzmnnvuSTvttFP+/vKICl111VXpoIMOyr/juuuuS/vuu2/DSxo/fny64IIL8s/aExWKSYMHD07z5s3L58e5qqNRjb60YhC/DWPGjEnDhw9Pq666anruuefSRhttlE855JBD0hVXXNFw3REvqo4z1R+7vKJCrf1OVxbZGc93Z/0OV9ZUbdHMnyHtvfcdT4AAAQIECBAgQIAAAQIECBAgQIAAAQIECLQUEBVyVxAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEPkeBCMs89NBD+QoicjFjxozUvXv3hquKOE7ESKpjNBGIOf7442uO33XXXdOcOXPy9yLyUh3LiA/qAyqtxSpWW221/PvimLfffjutuOKKraqVISr0D//wD+n666/P1xihny222KLFmsNx1qxZWfCk+po+/PDD9Nprr+XHR+gpoiPNjmb2dcGCBal///6tnvLmm29Oe+65Z6fv689+9rOaeE9EUyKIUj8+++yz9Itf/CLtvvvuaY011qj5+NNPP83u07lz52bRlb/9279tMT/8Yx8q4/bbb09DhgzJXz/55JPpm9/8Zv56xIgRaebMmR26r6699tr0T//0T/ncCMVMmTKlxbkivrXpppvm7/fo0SNFgKgSbuqsqFAEuy666KK0dOnSdOaZZza8psMOOyxFSKkyYs5Xv/rV1NF7r/7aJk6cmCZNmtTiuw844IA0bdq0/P3lERWK37R4BiojwmcRNqv/3XjxxRfTt7/97TyuFMe3NyoU4aodd9wx/674jbrlllvSDjvs0ND91VdfTfE7u2jRovzziCCNHj06268NN9wwD7LFARH26t27d4tzHXjggenqq6/O3497cNSoUfnrzowK7bffftmzWBmPPPJIiyBd5bPOeL47OyrU3j9DWv0R8AEBAgQIECBAgAABAgQIECBAgAABAgQIECDQtICoUNNUDiRAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIdL5AfXwjviGiGBE3GThwYOrTp0/66KOP0mOPPZbuuOOOdN5559UsYrPNNsuiRCuttFLN+0cffXT66U9/mr8XgY0Itqy11lrp448/zoIwY8eOrZnTWlRo8ODBad68efmxp556ahbPaBTaiIPKEBW67bbb0rBhw/I1R7wnrr9Xr175exFHimPi2sI6IjR9+/bNPj/qqKPSxRdfnB9bH8RZ1p3QzL7GPsR3nHbaaS1OF9GTCEjVj87Y15dffjlFTKcyYt9vuummtNNOO+XvRTTouOOOy9bXrVu3LBxUCRxFHCbcIlQV4/vf/3668sora0JYcc9GQOi//uu/8nOG8zbbbJO/jutfZZVVai4xYjcRxFp77bVbXHtb91XEoSJcUj1OOOGEdPrpp+ffEd8fQZ3KuuPYCP6cfPLJ+bTOiArdeOONKaJGlfBXnD+iX6uvvnr+PRHT2XzzzWviYGEe0Z2O3nvvvfdeFiWqjNi3CDdVglARzInQUexr9VgeUaEIUsXvQ7X10KFDs4hSBNPi8/hN23vvvWviPrGu9kaF6n9zKtc2YcKEFN8Z4aqwj0hY/C6cc845NdGgCB7FWrp27ZpNPeuss9Ipp5ySE/Xs2TOLMFXu3cWLF6f4DYx7pXq8//772W93ZXRmVCj2KO7lyhg+fHg68cQTsyBTly5datZR9PmOk3V2VKi9f4a0ePi9QYAAAQIECBAgQIAAAQIECBAgQIAAAQIECLRbQFSo3WQmECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQ6VyBCQRGI6MiIeM2WW27ZYur//u//pggO1Y8IaCxatKjhV7UWFaqPbNRPPuSQQ7LoTGWUISoUa9l9993T7Nmza5a73XbbZeGV559/Pi1cuLDmswh1RFwnxuGHH57FTSqjvVGhmFdkX88+++z0ox/9aLnt6+TJk1NEV6pHBJU23njj9MILL2RRkeoREaIIr0ScJWI5EYx54403ao6JiM2AAQMy2yeeeKLms7i3IupSHxH63ve+VxMeqr/g6dOnp/322y97e1n3VYSNIuZTPyIK8+abb9YEfOKYeP/hhx+uCcF0RlTowQcfzGIvjdYRgZtHHnmkJmoTx+22227pzjvvLHzvRTSrOuQTJ4yg2DrrrJPmz5/f4rP4fHlEheK8EVcaOXJkC4e4TyIoVYku1R/QkahQhK623nrrVs/ZYhFVb9xzzz2ZUWXEumL/6n8n4x7+2te+1tDw5z//eTr44INrvqYzo0K//vWv0/bbb9/qZcTzGaGqyijyfMc5Ojsq1N4/Q9raL58RIECAAAECBAgQIECAAAECBAgQIECAAAECzQmICjXn5CgCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwHIViHjKqFGjmv6OCKLccccdadNNN211zsSJE9O5557b5jkPO+ywPJ7TWlRo8eLF2fe89NJLDc+1//77p2nTpuWfLSv+0lZsozNjFhFXGTp0aIvATaOL2HfffdPVV1+dVlpppezjzogKxXnau6/Va4vITMRm6kdn7Osf//jHtM8++6RZs2Yt856LONXcuXNT9+7d82N/9atfZbathWHqT9oouhLHLFiwIPXv37/VNUyZMiUPBS3rvoqTNGMTx0WE5a677kqbb755zXd3RlQoTnjBBRek8ePHL9O2ckCEiCoORe69iGhFTKutEfv2hz/8IdvTGMsrKhTnHjduXLrkkkvaXM9ee+2VIoJWCVF1JCoUXxAxq9GjR7cZqapeSPzexTM2ePDgFuuL9eyyyy6t/uZVTzjhhBOygFj96MyoUJw7nteZM2c2tKz/7S76fHfm73AsuL1/hjT94DiQAAECBAgQIECAAAECBAgQIECAAAECBAgQaFVAVMjNQYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoicAzzzyTIr4SUY3WYi0ReDnyyCPTfvvtl1ZbbbU2V/7ZZ59loZyDDjqoxXERMJk8eXJ69913U0Q9YnTr1i29/vrrDc/51ltvpVNOOSXddNNN6Y033qg5pj4qtPfee6df/vKXrZ6zrdjGwoULU79+/fLzX3nllenAAw9suKZ4P66vMuJ660fENSZNmpSFUxqNgQMHpmHDhqWTTjopdenSJT+kSNil/nua2de+fftm4ab6aMh9992XBg0aVHPKztzX66+/Ph199NEt9jS+MMJVO+20U/rxj3+c1lhjjRZ8Tz31VGZ7zTXXtHofbrfddpltozhSZVL4TJgwId19990t7vvqqNCy7qvK+SK2ddZZZ6X58+e3WFfEV8aMGZNOPfXUhtd06aWXZs9XZSxatChtvPHGDa/v61//eu4WoZ5bb7215ri4nvC59957W/WJkFhc+xZbbNFp9148e8ccc0yLIE483yNHjkw/+clP0ogRI9Jtt92WfWd9VKhZ59i3apsIKcX31o94hk877bSG64lQzvnnn5+23XbbFCGbGFdddVUWB+rIWLp0aRYxuvbaa9NDDz3U8BRxDxx//PFp7Nixad111231a9555510xhlnpKlTpzb8PY7n8uSTT05DhgxpeI5mo0LxG1b9G/fAAw+kAQMGtDjnp59+mlmFT9yX1aO1IFxHn+/O/h2Otbbnz6FknqUAACAASURBVJCO7L05BAgQIECAAAECBAgQIECAAAECBAgQIECAQK2AqJA7ggABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQMoEI4bz44ovp5ZdfTq+++mpaaaWVUvfu3VOPHj3Seuut1+7VfvLJJ+npp59OEYH58pe/nEVqGkVimjlxBG3efPPNFOeMf2Ksvvrqaa211mpm+ud2zJ/+9KfMNAx+//vfp4022ihFyGeVVVZpdU0RFVlzzTWzz+fOnZsFdoqM+n390pe+lNZZZ51sX9dff/3s1CeeeGI677zz8q/5x3/8xzRjxoyGX9uZ+xp7GqGSMFp77bXTlltu2fSefvjhh9n99dxzz6WPPvoorbrqqlmspSP363vvvZcFXCr3Vvi0tUdt7Ues59lnn81CWXGOeIY233zz7Bn4S46w/e1vf5vZxnXFPRXXteGGG7b6HBa99+J7IvoT1//xxx9n+9mrV6+/5GXXfFfEfiJUUzH4S6xnyZIl2fXHM7948eJs/+P38xvf+Ebq2rVr0xbh9/jjj2e/x/HvEZOK4NYGG2zQ9Dk6+8CIwcWz9oc//CE7dfwZ0dafDUWe785e+1/rnyGd7eB8BAgQIECAAAECBAgQIECAAAECBAgQIEBgeQuICi1vYecnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBD4qxSYMmVKGjt2bLb2J598MvXp02e5X0cEN+I7p06dmvbaa680ffr0tPLKKy/37/UF5RL4PO69cglYDQECBAgQIECAAAECBAgQIECAAAECBAgQIECAQBEBUaEieuYSIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAh84QSWLl2aJk+enE466aTs2gYOHJjuu+++1KVLl7/ItS5ZsiRNmzYtjRo1Kq244op/ke/0JeUQ+LzvvXIoWAUBAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBRAVGhooLmEyBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIfKEE3n333bT++uunDz74IPXs2TPNmTMn9e7d+wt1jS6mnALuvXLui1URIECAAAECBAgQIECAAAECBAgQIECAAAECBP7aBESF/tp2zHoJECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgSWu8Ds2bPT9OnT08UXX5zWXHPN5f59voBARcC9514gQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEpDBFMQAAGIhJREFUCBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECgqICpUVNB8AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBQEgFRoZJshGUQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGiAqJCRQXNJ0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJREQFSrJRlgGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAoKiAqVFTQfAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgUBIBUaGSbIRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBogKiQkUFzSdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAiUREBUqyUZYBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQKCogKlRU0HwCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIFASAVGhkmyEZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgaICokJFBc0nQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIlERAVKslGWAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI/L927pgGAACGYRh/1gWRp4cBVJq8PwQIECBAgAABAgQIECBAgAABAgSqgKhQFbQnQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQInAqJCJ49wBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQqAKiQlXQngABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQInAiICp08whkECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQKAKiApVQXsCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIHAiICp08ghnECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBKiAqVAXtCRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAiYCo0MkjnEGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBKqAqFAVtCdAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAicCokInj3AGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBCoAqJCVdCeAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAicCIgKnTzCGQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoAqIClVBewIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgcCIgKnTyCGcQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEqICpUBe0JECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMCJgKjQySOcQYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEqoCoUBW0J0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECJwIDrnRm3qVg6BcAAAAASUVORK5CYII=) + + +# Content Overview +>[Prerequisites](#Prerequisites) +>[Create New Index from Document](#Create-New-Index-from-Document) +>[Create Engine Query Tool](#Create-Engine-Query-Tool) +>[Build the Agent](#Build-the-Agent) +>[Test the Agent](#Test-the-Agent) +________________________ + +## Prerequisites + +### Install Dependencies + + +```python +!pip install llama-index-core +!pip install llama-index-core +!pip install llama-index-llms-nvidia +!pip install llama-index-embeddings-nvidia +!pip install llama-index-utils-workflow +!pip install llama-parse +``` + +If your environment does not have `wget` , make sure to install that as well. + +### Download data + +The data for this notebook is the City of San Francisco's Proposed Budget. + + +```python +!wget "https://www.dropbox.com/scl/fi/vip161t63s56vd94neqlt/2023-CSF_Proposed_Budget_Book_June_2023_Master_Web.pdf?rlkey=hemoce3w1jsuf6s2bz87g549i&dl=0" -O "san_francisco_budget_2023.pdf" +``` + + +```python +# llama-parse is async-first, running the async code in a notebook requires the use of nest_asyncio +import nest_asyncio + +nest_asyncio.apply() +``` + +## API Keys +Prior to getting started, you will need to create API Keys for the NVIDIA API Catalog if you're not self-hosting a model and LlamaIndex to use LlamaCloud. + +- NVIDIA API Catalog + 1. Navigate to **[NVIDIA API Catalog](https://build.nvidia.com/explore/discover)**. + 2. Select any model, such as llama-3.3-70b-instruct. + 3. On the right panel above the sample code snippet, click on "Get API Key". This will prompt you to log in if you have not already. +- LlamaIndex + 1. Go to **[LlamaIndex login page](https://cloud.llamaindex.ai/login)**. You will need to create an account if you have not already. + 2. On the left panel, navigate to "API Key". + 3. Click on the "Generate New Key" on the top of the page. + +### Export API Keys + +Save these API Keys as environment variables. + +First, set the NVIDIA API Key as the environment variable. + + +```python +import getpass +import os + +if not os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"): + nvapi_key = getpass.getpass("Enter your NVIDIA API key: ") + assert nvapi_key.startswith( + "nvapi-" + ), f"{nvapi_key[:5]}... is not a valid key" + os.environ["NVIDIA_API_KEY"] = nvapi_key +``` + +Next, set the LlamaIndex API Key for LlamaCloud. + + +```python +import os, getpass + + +def _set_env(var: str): + if not os.environ.get(var): + os.environ[var] = getpass.getpass(f"{var}: ") + + +_set_env("LLAMA_CLOUD_API_KEY") +``` + +### Working with the NVIDIA API Catalog +Let's test the API endpoint. + +We'll use both an LLM and embedding model in this notebook so we'll import both the packages now. + + +```python +from llama_index.embeddings.nvidia import NVIDIAEmbedding +from llama_index.llms.nvidia import NVIDIA +from llama_index.core.llms import ChatMessage, MessageRole + +llm = NVIDIA(model="meta/llama-3.3-70b-instruct") + +messages = [ + ChatMessage( + role=MessageRole.SYSTEM, + content=("You are a helpful assistant that answers in one sentence."), + ), + ChatMessage( + role=MessageRole.USER, + content=("What are the most popular house pets in North America?"), + ), +] + +response = llm.chat(messages) + +print(response) +``` + + assistant: The most popular house pets in North America are dogs, cats, fish, birds, and small mammals such as hamsters, guinea pigs, and rabbits, with dogs and cats being the clear favorites among pet owners. + + +### Optional: Locally Run NVIDIA NIM Microservices + +Once you familiarize yourself with this blueprint, you may want to self-host models with NVIDIA NIM Microservices using NVIDIA AI Enterprise software license. This gives you the ability to run models anywhere, giving you ownership of your customizations and full control of your intellectual property (IP) and AI applications. + +[Learn more about NIM Microservices](https://developer.nvidia.com/blog/nvidia-nim-offers-optimized-inference-microservices-for-deploying-ai-models-at-scale/) + +
+NOTE: Run the following cell only if you're using a local NIM Microservice instead of the API Catalog Endpoint. +
+ + +```python +from llama_index.llms.nvidia import NVIDIA +from llama_index.core import Settings + +# connect to an LLM NIM running at localhost:8000, specifying a model +Settings.llm = NVIDIA( + base_url="http://localhost:8000/v1", model="meta/llama-3.3-70b-instruct" +) +``` + +### Set LLM and Embedding Model + +In this notebook, you will use the newest llama model, llama-3.3-70b-instruct, as the LLM. +You will also use NVIDIA's embedding model, llama-3.2-nv-embedqa-1b-v2. + + +```python +from llama_index.core import Settings + +Settings.llm = NVIDIA(model="meta/llama-3.3-70b-instruct") +Settings.embed_model = NVIDIAEmbedding( + model="nvidia/llama-3.2-nv-embedqa-1b-v2", truncate="END" +) +``` + +## Create New Index from Document + + +```python +from llama_index.core import ( + VectorStoreIndex, + StorageContext, + load_index_from_storage, +) +from llama_parse import LlamaParse + +DATA_DIR = "./data" +PERSIST_DIR = "./storage" + +if os.path.exists(PERSIST_DIR): + print("Loading existing index...") + storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR) + index = load_index_from_storage(storage_context) +else: + print("Creating new index...") + + file_path = "./san_francisco_budget_2023.pdf" + + documents = LlamaParse(result_type="markdown").load_data(file_path) + + index = VectorStoreIndex.from_documents(documents) + index.storage_context.persist(persist_dir=PERSIST_DIR) +``` + +### Run a Query Against the Index +Create a Query engine from the Index. A Query Engine is a generic interface that allows you to ask question over your data. +Here, the parameter `similarity_top_k` is set to 10. If you are using your own documents, you can play around with this parameter. + + +```python +query_engine = index.as_query_engine(similarity_top_k=10) +response = query_engine.query( + "What was San Francisco's budget for Police in 2023?" +) +print(response) +``` + + The proposed Fiscal Year 2023-24 budget for the Police Department is $776.8 million. + + +## Create Engine Query Tool +Next, create a Query Engine Tool. This takes the Query Engine defined earlier and wraps it as a tool the Agent can use. + + +```python +from llama_index.core.tools import QueryEngineTool + +budget_tool = QueryEngineTool.from_defaults( + query_engine, + name="san_francisco_budget_2023", + description="A RAG engine with extremely detailed information about the 2023 San Francisco budget.", +) +``` + +## Build the Agent + +The workflow is: +* you give it a set of tools (in this case it's a query engine with data about SF's budget) +* you give it a question to write a blog post about +* one agent generates an outline of what the blog post should look like +* the next generates a list of questions that would be necessary to gather data to fulfill that outline +* the questions are split up and answered concurrently +* a writer collects the questions and answers and writes a blog post +* a critic reviews the blog post and determines if it needs more work + * if it's fine, the workflow stops + * if it needs more work, it generates additional questions + * those questions are answered and the process repeats + + +```python +from typing import List +from llama_index.core.workflow import ( + step, + Event, + Context, + StartEvent, + StopEvent, + Workflow, +) +from llama_index.core.agent.workflow import FunctionAgent + + +class OutlineEvent(Event): + outline: str + + +class QuestionEvent(Event): + question: str + + +class AnswerEvent(Event): + question: str + answer: str + + +class ReviewEvent(Event): + report: str + + +class ProgressEvent(Event): + progress: str + + +class DocumentResearchAgent(Workflow): + # get the initial request and create an outline of the blog post knowing nothing about the topic + @step + async def formulate_plan( + self, ctx: Context, ev: StartEvent + ) -> OutlineEvent: + query = ev.query + await ctx.store.set("original_query", query) + await ctx.store.set("tools", ev.tools) + + prompt = f"""You are an expert at writing blog posts. You have been given a topic to write + a blog post about. Plan an outline for the blog post; it should be detailed and specific. + Another agent will formulate questions to find the facts necessary to fulfill the outline. + The topic is: {query}""" + + response = await Settings.llm.acomplete(prompt) + + ctx.write_event_to_stream( + ProgressEvent(progress="Outline:\n" + str(response)) + ) + + return OutlineEvent(outline=str(response)) + + # formulate some questions based on the outline + @step + async def formulate_questions( + self, ctx: Context, ev: OutlineEvent + ) -> QuestionEvent: + outline = ev.outline + await ctx.store.set("outline", outline) + + prompt = f"""You are an expert at formulating research questions. You have been given an outline + for a blog post. Formulate a series of simple questions that will get you the facts necessary + to fulfill the outline. You cannot assume any existing knowledge; you must ask at least one + question for every bullet point in the outline. Avoid complex or multi-part questions; break + them down into a series of simple questions. Your output should be a list of questions, each + on a new line. Do not include headers or categories or any preamble or explanation; just a + list of questions. For speed of response, limit yourself to 8 questions. The outline is: {outline}""" + + response = await Settings.llm.acomplete(prompt) + + questions = str(response).split("\n") + questions = [x for x in questions if x] + + ctx.write_event_to_stream( + ProgressEvent( + progress="Formulated questions:\n" + "\n".join(questions) + ) + ) + + await ctx.store.set("num_questions", len(questions)) + + ctx.write_event_to_stream( + ProgressEvent(progress="Questions:\n" + "\n".join(questions)) + ) + + for question in questions: + ctx.send_event(QuestionEvent(question=question)) + + # answer each question in turn + @step + async def answer_question( + self, ctx: Context, ev: QuestionEvent + ) -> AnswerEvent: + question = ev.question + if ( + not question + or question.isspace() + or question == "" + or question is None + ): + ctx.write_event_to_stream( + ProgressEvent(progress=f"Skipping empty question.") + ) # Log skipping empty question + return None + agent = FunctionAgent( + tools=await ctx.store.get("tools"), + llm=Settings.llm, + ) + response = await agent.run(question) + response = str(response) + + ctx.write_event_to_stream( + ProgressEvent( + progress=f"To question '{question}' the agent answered: {response}" + ) + ) + + return AnswerEvent(question=question, answer=response) + + # given all the answers to all the questions and the outline, write the blog poost + @step + async def write_report(self, ctx: Context, ev: AnswerEvent) -> ReviewEvent: + # wait until we receive as many answers as there are questions + num_questions = await ctx.store.get("num_questions") + results = ctx.collect_events(ev, [AnswerEvent] * num_questions) + if results is None: + return None + + # maintain a list of all questions and answers no matter how many times this step is called + try: + previous_questions = await ctx.store.get("previous_questions") + except: + previous_questions = [] + previous_questions.extend(results) + await ctx.store.set("previous_questions", previous_questions) + + prompt = f"""You are an expert at writing blog posts. You are given an outline of a blog post + and a series of questions and answers that should provide all the data you need to write the + blog post. Compose the blog post according to the outline, using only the data given in the + answers. The outline is in and the questions and answers are in and + . + {await ctx.store.get('outline')}""" + + for result in previous_questions: + prompt += f"{result.question}\n{result.answer}\n" + + ctx.write_event_to_stream( + ProgressEvent(progress="Writing report with prompt:\n" + prompt) + ) + + report = await Settings.llm.acomplete(prompt) + + return ReviewEvent(report=str(report)) + + # review the report. If it still needs work, formulate some more questions. + @step + async def review_report( + self, ctx: Context, ev: ReviewEvent + ) -> StopEvent | QuestionEvent: + # we re-review a maximum of 3 times + try: + num_reviews = await ctx.store.get("num_reviews") + except: + num_reviews = 1 + num_reviews += 1 + await ctx.store.set("num_reviews", num_reviews) + + report = ev.report + + prompt = f"""You are an expert reviewer of blog posts. You are given an original query, + and a blog post that was written to satisfy that query. Review the blog post and determine + if it adequately answers the query and contains enough detail. If it doesn't, come up with + a set of questions that will get you the facts necessary to expand the blog post. Another + agent will answer those questions. Your response should just be a list of questions, one + per line, without any preamble or explanation. For speed, generate a maximum of 4 questions. + The original query is: '{await ctx.store.get('original_query')}'. + The blog post is: {report}. + If the blog post is fine, return just the string 'OKAY'.""" + + response = await Settings.llm.acomplete(prompt) + + if response == "OKAY" or await ctx.store.get("num_reviews") >= 3: + ctx.write_event_to_stream( + ProgressEvent(progress="Blog post is fine") + ) + return StopEvent(result=report) + else: + questions = str(response).split("\n") + await ctx.store.set("num_questions", len(questions)) + ctx.write_event_to_stream( + ProgressEvent(progress="Formulated some more questions") + ) + for question in questions: + ctx.send_event(QuestionEvent(question=question)) +``` + +## Test the Agent + +Run the Agent with a query and look at the generated blog post written to answer it + + +```python +agent = DocumentResearchAgent(timeout=600, verbose=True) +handler = agent.run( + query="Tell me about the budget of the San Francisco Police Department in 2023", + tools=[budget_tool], +) +async for ev in handler.stream_events(): + if isinstance(ev, ProgressEvent): + print(ev.progress) +final_result = await handler +print("------- Blog post ----------\n", final_result) +``` + + Running step formulate_plan + Step formulate_plan produced event OutlineEvent + Outline: + Here is a detailed outline for the blog post on the budget of the San Francisco Police Department in 2023: + + **I. Introduction** + + * Brief overview of the San Francisco Police Department (SFPD) and its role in the city + * Importance of understanding the budget of the SFPD + * Thesis statement: The 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy, and understanding its allocation and priorities is essential for ensuring effective policing and community safety. + + **II. Overview of the 2023 Budget** + + * Total budget allocation for the SFPD in 2023 + * Comparison to previous years' budgets (e.g., 2022, 2021) + * Breakdown of the budget into major categories (e.g., personnel, operations, equipment, training) + + **III. Personnel Costs** + + * Salary and benefits for sworn officers and civilian staff + * Number of personnel and staffing levels + * Recruitment and retention strategies and their associated costs + * Discussion of any notable changes or trends in personnel costs (e.g., increased overtime, hiring freezes) + + **IV. Operational Expenses** + + * Overview of operational expenses, including: + + Fuel and vehicle maintenance + + Equipment and supplies (e.g., firearms, body armor, communication devices) + + Facility maintenance and utilities + + Travel and training expenses + * Discussion of any notable changes or trends in operational expenses (e.g., increased fuel costs, new equipment purchases) + + **V. Community Policing and Outreach Initiatives** + + * Overview of community policing and outreach initiatives, including: + + Neighborhood policing programs + + Youth and community engagement programs + + Mental health and crisis response services + * Budget allocation for these initiatives and discussion of their effectiveness + + **VI. Technology and Equipment Upgrades** + + * Overview of technology and equipment upgrades, including: + + Body-worn cameras and other surveillance technology + + Communication systems and emergency response infrastructure + + Forensic analysis and crime lab equipment + * Budget allocation for these upgrades and discussion of their impact on policing and public safety + + **VII. Challenges and Controversies** + + * Discussion of challenges and controversies related to the SFPD budget, including: + + Funding for police reform and accountability initiatives + + Criticisms of police spending and resource allocation + + Impact of budget constraints on policing services and community safety + + **VIII. Conclusion** + + * Summary of key findings and takeaways from the 2023 SFPD budget + * Discussion of implications for public safety and community policing in San Francisco + * Final thoughts and recommendations for future budget allocations and policing strategies. + + To fulfill this outline, the following questions will need to be answered: + + * What is the total budget allocation for the SFPD in 2023? + * How does the 2023 budget compare to previous years' budgets? + * What are the major categories of expenditure in the 2023 budget? + * What are the personnel costs, including salary and benefits, for sworn officers and civilian staff? + * What are the operational expenses, including fuel, equipment, and facility maintenance? + * What community policing and outreach initiatives are funded in the 2023 budget? + * What technology and equipment upgrades are planned or underway, and what is their budget allocation? + * What challenges and controversies are associated with the SFPD budget, and how are they being addressed? + + These questions will help to gather the necessary facts and information to create a comprehensive and informative blog post on the budget of the San Francisco Police Department in 2023. + Running step formulate_questions + Step formulate_questions produced no event + Formulated questions: + What is the total budget allocation for the SFPD in 2023? + How does the 2023 budget compare to the 2022 budget? + What are the major categories of expenditure in the 2023 budget? + What are the personnel costs, including salary and benefits, for sworn officers? + What are the operational expenses, including fuel and vehicle maintenance? + What community policing and outreach initiatives are funded in the 2023 budget? + What technology and equipment upgrades are planned or underway? + What challenges and controversies are associated with the SFPD budget? + Questions: + What is the total budget allocation for the SFPD in 2023? + How does the 2023 budget compare to the 2022 budget? + What are the major categories of expenditure in the 2023 budget? + What are the personnel costs, including salary and benefits, for sworn officers? + What are the operational expenses, including fuel and vehicle maintenance? + What community policing and outreach initiatives are funded in the 2023 budget? + What technology and equipment upgrades are planned or underway? + What challenges and controversies are associated with the SFPD budget? + Running step answer_question + > Running step d0e11f46-4071-43aa-9f06-0ddffe477928. Step input: What is the total budget allocation for the SFPD in 2023? + Added user message to memory: What is the total budget allocation for the SFPD in 2023? + Running step answer_question + > Running step 44ded067-ea4c-4575-97b2-5fbaf444b189. Step input: How does the 2023 budget compare to the 2022 budget? + Added user message to memory: How does the 2023 budget compare to the 2022 budget? + Running step answer_question + > Running step 28b603af-894b-4654-949d-48340149d8e8. Step input: What are the major categories of expenditure in the 2023 budget? + Added user message to memory: What are the major categories of expenditure in the 2023 budget? + Running step answer_question + > Running step 5c6a5ebb-3787-4401-a5e3-aa93e03d1832. Step input: What are the personnel costs, including salary and benefits, for sworn officers? + Added user message to memory: What are the personnel costs, including salary and benefits, for sworn officers? + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "SFPD total budget allocation 2023"} + === LLM Response === + {"input": "personnel costs for sworn officers"} + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 3853365e-fd6d-498d-b92f-25f8969ffe43. Step input: What are the operational expenses, including fuel and vehicle maintenance? + Added user message to memory: What are the operational expenses, including fuel and vehicle maintenance? + To question 'What are the personnel costs, including salary and benefits, for sworn officers?' the agent answered: {"input": "personnel costs for sworn officers"} + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "major categories of expenditure in the 2023 budget"} + === LLM Response === + {"input": "compare 2023 budget to 2022 budget"} + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 4487ccea-3e7e-4378-b299-a5372dbc6aaf. Step input: What community policing and outreach initiatives are funded in the 2023 budget? + Added user message to memory: What community policing and outreach initiatives are funded in the 2023 budget? + To question 'How does the 2023 budget compare to the 2022 budget?' the agent answered: {"input": "compare 2023 budget to 2022 budget"} + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "operational expenses, including fuel and vehicle maintenance"} + === LLM Response === + {"input": "community policing and outreach initiatives 2023 budget"} + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 75022818-5d76-4443-b3c6-c5558991713c. Step input: What technology and equipment upgrades are planned or underway? + Added user message to memory: What technology and equipment upgrades are planned or underway? + To question 'What community policing and outreach initiatives are funded in the 2023 budget?' the agent answered: {"input": "community policing and outreach initiatives 2023 budget"} + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "technology and equipment upgrades planned or underway"} + === Function Output === + The query is asking for the SFPD total budget allocation for 2023, but the provided context does not mention the SFPD's budget for 2023. It discusses the budgets of the Juvenile Probation Department and the Public Utilities Commission. Therefore, the original answer cannot be rewritten with the new context, and the original answer should be repeated. + + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + > Running step 927d5844-8c20-4cc8-a50f-52248963206f. Step input: None + === LLM Response === + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + Step answer_question produced event AnswerEvent + Running step answer_question + > Running step 0dcc7a13-046a-4259-96eb-7a2817530875. Step input: What challenges and controversies are associated with the SFPD budget? + Added user message to memory: What challenges and controversies are associated with the SFPD budget? + To question 'What is the total budget allocation for the SFPD in 2023?' the agent answered: The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + Running step write_report + Step write_report produced no event + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "SFPD budget challenges and controversies"} + === Function Output === + Non-Personnel Services, which includes expenses such as fuel and vehicle maintenance, has a budget of $1,088,786,650 for 2024-2025, showing a continued significant allocation for operational expenses. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + > Running step a55db034-f7ba-4e87-960e-0605574c3398. Step input: None + === LLM Response === + The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + Step answer_question produced event AnswerEvent + To question 'What are the operational expenses, including fuel and vehicle maintenance?' the agent answered: The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + Running step write_report + Step write_report produced no event + === Function Output === + Several technology and equipment upgrades are planned or underway. The City is investing in vital technology projects, including the replacement of critical systems and the development of new platforms to enhance city services and operations. The City's focus on cloud solutions continues, with efforts to expand and optimize cloud services, including the provisioning of Infrastructure-as-a-Service (IaaS) and Platform-as-a-Service (PaaS) to support daily operations. Additionally, the City is working on initiatives to improve digital accessibility and inclusion, and to develop new applications that enhance the speed, security, performance, and reliability of City services. The establishment of centers of excellence, such as the Cloud Center of Excellence, aims to help departments leverage technology more effectively and efficiently. Furthermore, the City is exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + > Running step f34e8f8a-9c59-4e02-9394-a8293ff24af6. Step input: None + === LLM Response === + The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + Step answer_question produced event AnswerEvent + To question 'What technology and equipment upgrades are planned or underway?' the agent answered: The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + Running step write_report + Step write_report produced no event + === Function Output === + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + > Running step 1b1640ad-977c-423d-b88d-e9cf4de53e5b. Step input: None + === LLM Response === + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + Step answer_question produced event AnswerEvent + To question 'What are the major categories of expenditure in the 2023 budget?' the agent answered: The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + Running step write_report + Step write_report produced no event + === Function Output === + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, with staffing levels continuing to fall behind recommended levels as separations have outpaced recruiting. The Department is also dealing with chronic understaffing, which requires overtime funding support to ensure necessary deployment levels. Furthermore, the SFPD is working to implement reforms and achieve substantial compliance with state laws, including SB 1421, SB 16, and SB 2, which requires investments in information technology, training, and other resources. + + In the context of project spending, the SFPD's budget challenges are exacerbated by the need to allocate resources for various projects, such as technology upgrades, training programs, and community initiatives. The Department must balance these competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community, particularly in light of the need for periodic biased policing audits, may also be a subject of controversy and debate. Additionally, the budget's focus on increasing salaries and benefits for sworn staff, as well as the expansion of programs aimed at improving community relations, may be seen as contentious by some stakeholders. + + Given the projected deficit, the Mayor's requirement for departments to propose budget reductions may impact the SFPD's ability to allocate resources for these projects, potentially affecting the Department's ability to implement reforms and achieve its goals. The SFPD must navigate these challenges and controversies to ensure effective and responsible use of its budget, while also addressing the needs and concerns of the community. + > Running step 3ba46541-2a08-446a-b3fc-2c3df3be814f. Step input: None + === LLM Response === + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + Step answer_question produced event AnswerEvent + To question 'What challenges and controversies are associated with the SFPD budget?' the agent answered: The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + Running step write_report + Writing report with prompt: + You are an expert at writing blog posts. You are given an outline of a blog post + and a series of questions and answers that should provide all the data you need to write the + blog post. Compose the blog post according to the outline, using only the data given in the + answers. The outline is in and the questions and answers are in and + . + Here is a detailed outline for the blog post on the budget of the San Francisco Police Department in 2023: + + **I. Introduction** + + * Brief overview of the San Francisco Police Department (SFPD) and its role in the city + * Importance of understanding the budget of the SFPD + * Thesis statement: The 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy, and understanding its allocation and priorities is essential for ensuring effective policing and community safety. + + **II. Overview of the 2023 Budget** + + * Total budget allocation for the SFPD in 2023 + * Comparison to previous years' budgets (e.g., 2022, 2021) + * Breakdown of the budget into major categories (e.g., personnel, operations, equipment, training) + + **III. Personnel Costs** + + * Salary and benefits for sworn officers and civilian staff + * Number of personnel and staffing levels + * Recruitment and retention strategies and their associated costs + * Discussion of any notable changes or trends in personnel costs (e.g., increased overtime, hiring freezes) + + **IV. Operational Expenses** + + * Overview of operational expenses, including: + + Fuel and vehicle maintenance + + Equipment and supplies (e.g., firearms, body armor, communication devices) + + Facility maintenance and utilities + + Travel and training expenses + * Discussion of any notable changes or trends in operational expenses (e.g., increased fuel costs, new equipment purchases) + + **V. Community Policing and Outreach Initiatives** + + * Overview of community policing and outreach initiatives, including: + + Neighborhood policing programs + + Youth and community engagement programs + + Mental health and crisis response services + * Budget allocation for these initiatives and discussion of their effectiveness + + **VI. Technology and Equipment Upgrades** + + * Overview of technology and equipment upgrades, including: + + Body-worn cameras and other surveillance technology + + Communication systems and emergency response infrastructure + + Forensic analysis and crime lab equipment + * Budget allocation for these upgrades and discussion of their impact on policing and public safety + + **VII. Challenges and Controversies** + + * Discussion of challenges and controversies related to the SFPD budget, including: + + Funding for police reform and accountability initiatives + + Criticisms of police spending and resource allocation + + Impact of budget constraints on policing services and community safety + + **VIII. Conclusion** + + * Summary of key findings and takeaways from the 2023 SFPD budget + * Discussion of implications for public safety and community policing in San Francisco + * Final thoughts and recommendations for future budget allocations and policing strategies. + + To fulfill this outline, the following questions will need to be answered: + + * What is the total budget allocation for the SFPD in 2023? + * How does the 2023 budget compare to previous years' budgets? + * What are the major categories of expenditure in the 2023 budget? + * What are the personnel costs, including salary and benefits, for sworn officers and civilian staff? + * What are the operational expenses, including fuel, equipment, and facility maintenance? + * What community policing and outreach initiatives are funded in the 2023 budget? + * What technology and equipment upgrades are planned or underway, and what is their budget allocation? + * What challenges and controversies are associated with the SFPD budget, and how are they being addressed? + + These questions will help to gather the necessary facts and information to create a comprehensive and informative blog post on the budget of the San Francisco Police Department in 2023.What are the personnel costs, including salary and benefits, for sworn officers? + {"input": "personnel costs for sworn officers"} + How does the 2023 budget compare to the 2022 budget? + {"input": "compare 2023 budget to 2022 budget"} + What community policing and outreach initiatives are funded in the 2023 budget? + {"input": "community policing and outreach initiatives 2023 budget"} + What is the total budget allocation for the SFPD in 2023? + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + What are the operational expenses, including fuel and vehicle maintenance? + The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + What technology and equipment upgrades are planned or underway? + The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + What are the major categories of expenditure in the 2023 budget? + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + What challenges and controversies are associated with the SFPD budget? + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + + Step write_report produced event ReviewEvent + Running step review_report + Step review_report produced no event + Formulated some more questions + Running step answer_question + > Running step 1515025f-3d98-48ef-82dc-fe1ccb395c95. Step input: What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget? + Added user message to memory: What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget? + Running step answer_question + > Running step 89d8cbfd-decd-4f6e-875c-ee764cc51d57. Step input: What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget? + Added user message to memory: What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget? + Running step answer_question + > Running step 78a4965f-1507-4238-8306-62c3e93582e3. Step input: What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget? + Added user message to memory: What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget? + Running step answer_question + > Running step ca4c2497-c62c-4fcd-8ae5-4108bfdf0864. Step input: How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway? + Added user message to memory: How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway? + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "community policing and outreach initiatives funding allocations 2023"} + === Calling Function === + Calling function: san_francisco_budget_2023 with args: {"input": "SFPD personnel costs sworn officers 2023 budget breakdown salary benefits"} + === LLM Response === + {"input": "technology and equipment upgrades 2023 vs previous years and planned upgrades"} + Step answer_question produced event AnswerEvent + === LLM Response === + {"input": "SFPD operational expenses fuel vehicle maintenance 2023 budget"} + Step answer_question produced event AnswerEvent + To question 'How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway?' the agent answered: {"input": "technology and equipment upgrades 2023 vs previous years and planned upgrades"} + To question 'What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget?' the agent answered: {"input": "SFPD operational expenses fuel vehicle maintenance 2023 budget"} + Running step write_report + Step write_report produced no event + Running step write_report + Step write_report produced no event + === Function Output === + The department's commitment to community policing and outreach initiatives is reflected in the proposed budget for 2023, which includes substantial funding allocations. Specifically, $2.2 million is allocated in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs. These programs provide a range of support services to sworn officers and help foster positive relationships with the community. Additionally, the budget includes $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, such as the Community Ambassadors program, which aims to build trust and understanding between law enforcement and the communities they serve. Furthermore, $26.5 million is allocated in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors in key areas throughout the city. These investments underscore the department's dedication to enhancing community outreach and engagement, and to providing additional support services to address community needs, ultimately contributing to a safer and more connected community. + > Running step cf1ebb7d-a2d3-4360-b2d9-767859e64103. Step input: None + === LLM Response === + The 2023 budget for San Francisco allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs, ultimately contributing to a safer and more connected community. + Step answer_question produced event AnswerEvent + To question 'What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget?' the agent answered: The 2023 budget for San Francisco allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs, ultimately contributing to a safer and more connected community. + Running step write_report + Step write_report produced no event + === Function Output === + The Sheriff's Office budget for FY 2023-24 is $291.7 million, which is 2.5 percent lower than the FY 2022-23 budget. This decrease is primarily due to salary reductions from position vacancies and a decrease in overtime. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + + In terms of personnel costs, the Sheriff's Office is facing ongoing staffing challenges, resulting in a demand for overtime to meet mandated minimum staffing requirements. The proposed budget includes funding to meet the overtime needs of the Sheriff's Office in FY 2023-24. As the Office improves its regular staffing levels, the need for overtime spending will decrease. + + The Sheriff's Office is aggressively recruiting to fill numerous vacancies in its deputy sheriff positions and professional staff. The Office is also increasing its law enforcement presence in the community, expanding the field officer training program, and increasing staff in the warrant services unit. + + Regarding labor negotiations, the Employee Relations Division is responsible for negotiating all non-Municipal Transportation Agency labor contracts for City employees. In FY 2023-24, the Division will be negotiating collective bargaining agreements on behalf of 88 percent of the City's workforce covered by 34 union contracts. + + The City is also self-insuring for workers' compensation and is financially responsible for all workers' compensation liabilities. The Workers' Compensation Division will continue to advance its safety and health initiatives and partner with departments to implement the Temporary Transitional Work Assignment policy to improve Return to Work outcomes. + + The Mayor's proposed budget includes funding for the new Career Center at City Hall, which will help City employees access existing programs and resources that support their career goals. The Department will also launch and promote new career pathway programs, including a public safety pathway program and a health worker pathway program. + + The San Francisco Health Service System (SFHSS) is dedicated to preserving and improving sustainable, quality health benefits and enhancing the well-being of employees, retirees, and their families. The proposed FY 2023-24 budget for SFHSS is $13.9 million, which is 2.3 percent higher than the FY 2022-23 budget, due to enhanced Employee Assistance services and an increase in a work order with the Human Resources Department. + + SFHSS has completed its 2023-25 strategic plan, which includes strategic goals to foster equity, advance primary care practice, provide affordable and sustainable healthcare, and support the mental health and well-being of its membership. The SFHSS medical rates trend vs benchmarks shows that the rising cost of healthcare has outpaced inflation in most years, but SFHSS oversight has resulted in lower increases than the national average and inflation for four of the last five years. + > Running step cc8562aa-15ae-4a56-8bf9-54f6c8e976c9. Step input: None + === LLM Response === + The exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget is not explicitly stated in the provided information. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + Step answer_question produced event AnswerEvent + To question 'What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget?' the agent answered: The exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget is not explicitly stated in the provided information. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + Running step write_report + Writing report with prompt: + You are an expert at writing blog posts. You are given an outline of a blog post + and a series of questions and answers that should provide all the data you need to write the + blog post. Compose the blog post according to the outline, using only the data given in the + answers. The outline is in and the questions and answers are in and + . + Here is a detailed outline for the blog post on the budget of the San Francisco Police Department in 2023: + + **I. Introduction** + + * Brief overview of the San Francisco Police Department (SFPD) and its role in the city + * Importance of understanding the budget of the SFPD + * Thesis statement: The 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy, and understanding its allocation and priorities is essential for ensuring effective policing and community safety. + + **II. Overview of the 2023 Budget** + + * Total budget allocation for the SFPD in 2023 + * Comparison to previous years' budgets (e.g., 2022, 2021) + * Breakdown of the budget into major categories (e.g., personnel, operations, equipment, training) + + **III. Personnel Costs** + + * Salary and benefits for sworn officers and civilian staff + * Number of personnel and staffing levels + * Recruitment and retention strategies and their associated costs + * Discussion of any notable changes or trends in personnel costs (e.g., increased overtime, hiring freezes) + + **IV. Operational Expenses** + + * Overview of operational expenses, including: + + Fuel and vehicle maintenance + + Equipment and supplies (e.g., firearms, body armor, communication devices) + + Facility maintenance and utilities + + Travel and training expenses + * Discussion of any notable changes or trends in operational expenses (e.g., increased fuel costs, new equipment purchases) + + **V. Community Policing and Outreach Initiatives** + + * Overview of community policing and outreach initiatives, including: + + Neighborhood policing programs + + Youth and community engagement programs + + Mental health and crisis response services + * Budget allocation for these initiatives and discussion of their effectiveness + + **VI. Technology and Equipment Upgrades** + + * Overview of technology and equipment upgrades, including: + + Body-worn cameras and other surveillance technology + + Communication systems and emergency response infrastructure + + Forensic analysis and crime lab equipment + * Budget allocation for these upgrades and discussion of their impact on policing and public safety + + **VII. Challenges and Controversies** + + * Discussion of challenges and controversies related to the SFPD budget, including: + + Funding for police reform and accountability initiatives + + Criticisms of police spending and resource allocation + + Impact of budget constraints on policing services and community safety + + **VIII. Conclusion** + + * Summary of key findings and takeaways from the 2023 SFPD budget + * Discussion of implications for public safety and community policing in San Francisco + * Final thoughts and recommendations for future budget allocations and policing strategies. + + To fulfill this outline, the following questions will need to be answered: + + * What is the total budget allocation for the SFPD in 2023? + * How does the 2023 budget compare to previous years' budgets? + * What are the major categories of expenditure in the 2023 budget? + * What are the personnel costs, including salary and benefits, for sworn officers and civilian staff? + * What are the operational expenses, including fuel, equipment, and facility maintenance? + * What community policing and outreach initiatives are funded in the 2023 budget? + * What technology and equipment upgrades are planned or underway, and what is their budget allocation? + * What challenges and controversies are associated with the SFPD budget, and how are they being addressed? + + These questions will help to gather the necessary facts and information to create a comprehensive and informative blog post on the budget of the San Francisco Police Department in 2023.What are the personnel costs, including salary and benefits, for sworn officers? + {"input": "personnel costs for sworn officers"} + How does the 2023 budget compare to the 2022 budget? + {"input": "compare 2023 budget to 2022 budget"} + What community policing and outreach initiatives are funded in the 2023 budget? + {"input": "community policing and outreach initiatives 2023 budget"} + What is the total budget allocation for the SFPD in 2023? + The total budget allocation for the San Francisco Police Department (SFPD) in 2023 is $776.8 million. + What are the operational expenses, including fuel and vehicle maintenance? + The operational expenses, including fuel and vehicle maintenance, have a budget of $1,088,786,650 for 2024-2025. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment, underscoring the organization's ongoing commitment to maintaining its assets and ensuring their continued functionality. + What technology and equipment upgrades are planned or underway? + The City of San Francisco is planning or undertaking various technology and equipment upgrades. These include replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Additionally, the City is establishing centers of excellence, such as the Cloud Center of Excellence, to help departments leverage technology more effectively and efficiently. The City is also exploring new technologies and solutions to support its goals, including the development of online portals and databases to facilitate resident engagement and access to city services. + What are the major categories of expenditure in the 2023 budget? + The major categories of expenditure in the 2023 budget include citywide expenditures such as voter mandated General Fund support for transit, libraries, and other baselines, the General Fund portion of retiree health premiums, nonprofit cost of doing business increases, required reserve deposits, and debt service. These costs are budgeted in General City Responsibility rather than allocating costs to departments. Additionally, expenditures related to Human Welfare & Neighborhood Development are also significant, including departments such as Children, Youth & Their Families, Child Support Services, Dept of Early Childhood, Environment, Homelessness And Supportive Housing, Human Rights Commission, and Human Services. + What challenges and controversies are associated with the SFPD budget? + The San Francisco Police Department (SFPD) faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. The Department's efforts to address issues of trust and accountability within the community may also be a subject of controversy and debate. + How do the budget allocations for technology and equipment upgrades in 2023 compare to previous years, and what specific upgrades are planned or underway? + {"input": "technology and equipment upgrades 2023 vs previous years and planned upgrades"} + What is the exact figure for operational expenses, including fuel and vehicle maintenance, in the 2023 SFPD budget? + {"input": "SFPD operational expenses fuel vehicle maintenance 2023 budget"} + What are the specific details and funding allocations for the community policing and outreach initiatives mentioned in the 2023 budget? + The 2023 budget for San Francisco allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs, ultimately contributing to a safer and more connected community. + What is the exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget? + The exact breakdown of personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget is not explicitly stated in the provided information. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + + Step write_report produced event ReviewEvent + Running step review_report + Step review_report produced event StopEvent + Blog post is fine + ------- Blog post ---------- + **The 2023 Budget of the San Francisco Police Department: Understanding Allocation and Priorities** + + The San Francisco Police Department (SFPD) plays a vital role in maintaining public safety and order in the city of San Francisco. As such, understanding the budget of the SFPD is crucial for ensuring effective policing and community safety. The 2023 budget of the SFPD is a critical component of the city's public safety strategy, and this blog post aims to provide an overview of the budget allocation and priorities. + + **Overview of the 2023 Budget** + + The total budget allocation for the SFPD in 2023 is $776.8 million. Compared to the 2022 budget, the 2023 budget has increased, although the exact percentage increase is not specified. The major categories of expenditure in the 2023 budget include citywide expenditures such as voter-mandated General Fund support for transit, libraries, and other baselines, as well as expenditures related to Human Welfare & Neighborhood Development. + + **Personnel Costs** + + The personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget are not explicitly stated. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + + **Operational Expenses** + + The operational expenses, including fuel and vehicle maintenance, have a significant budget allocation. Although the exact figure for the 2023 SFPD budget is not provided, the operational expenses for 2024-2025 have a budget of $1,088,786,650. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment. + + **Community Policing and Outreach Initiatives** + + The 2023 budget allocates significant funding to support community policing and outreach initiatives. Specifically, the budget allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs. + + **Technology and Equipment Upgrades** + + The City of San Francisco is planning or undertaking various technology and equipment upgrades, including replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Although the exact budget allocation for these upgrades is not specified, these initiatives aim to support the city's goals and improve policing and public safety. + + **Challenges and Controversies** + + The SFPD faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. + + **Conclusion** + + In conclusion, the 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy. Understanding the budget allocation and priorities is essential for ensuring effective policing and community safety. The budget allocates significant funding to support community policing and outreach initiatives, technology and equipment upgrades, and personnel costs. However, the SFPD also faces significant budget challenges and controversies, which must be addressed to ensure the effective and responsible use of its budget. As the city continues to evolve and grow, it is essential to prioritize public safety and ensure that the SFPD has the necessary resources to maintain order and protect the community. + + +## Sample output rendered as markdown + +We've taken the output of the agent and rendered it here: + +**The 2023 Budget of the San Francisco Police Department: Understanding Allocation and Priorities** + +The San Francisco Police Department (SFPD) plays a vital role in maintaining public safety and order in the city of San Francisco. As such, understanding the budget of the SFPD is crucial for ensuring effective policing and community safety. The 2023 budget of the SFPD is a critical component of the city's public safety strategy, and this blog post aims to provide an overview of the budget allocation and priorities. + +**Overview of the 2023 Budget** + +The total budget allocation for the SFPD in 2023 is $776.8 million. Compared to the 2022 budget, the 2023 budget has increased, although the exact percentage increase is not specified. The major categories of expenditure in the 2023 budget include citywide expenditures such as voter-mandated General Fund support for transit, libraries, and other baselines, as well as expenditures related to Human Welfare & Neighborhood Development. + +**Personnel Costs** + +The personnel costs, including salary and benefits, for sworn officers in the 2023 SFPD budget are not explicitly stated. However, the Sheriff's Office budget for FY 2023-24 is $291.7 million, which includes funding for personnel costs such as salaries and benefits. The proposed budget for FY 2024-25 is $293.7 million, which is 0.7 percent higher than the FY 2023-24 proposed budget, mainly due to increases in interdepartmental services and salaries and benefits. + +**Operational Expenses** + +The operational expenses, including fuel and vehicle maintenance, have a significant budget allocation. Although the exact figure for the 2023 SFPD budget is not provided, the operational expenses for 2024-2025 have a budget of $1,088,786,650. This category likely encompasses a broad range of expenditures related to the upkeep and operation of vehicles and other equipment. + +**Community Policing and Outreach Initiatives** + +The 2023 budget allocates significant funding to support community policing and outreach initiatives. Specifically, the budget allocates $2.2 million in FY 2023-24 and $3.0 million in FY 2024-25 to support the expansion of Community Police Service Aides (PSAs) programs, $2.8 million in FY 2023-24 and $2.9 million in FY 2024-25 to support the expansion of ambassador programs, and $26.5 million in FY 2023-24 and $16.0 million in FY 2024-25 to support the expansion of Community Safety Ambassadors. These investments aim to enhance community outreach and engagement, and provide additional support services to address community needs. + +**Technology and Equipment Upgrades** + +The City of San Francisco is planning or undertaking various technology and equipment upgrades, including replacing critical systems, developing new platforms to enhance city services and operations, expanding and optimizing cloud services, improving digital accessibility and inclusion, and developing new applications to enhance the speed, security, performance, and reliability of City services. Although the exact budget allocation for these upgrades is not specified, these initiatives aim to support the city's goals and improve policing and public safety. + +**Challenges and Controversies** + +The SFPD faces significant budget challenges, including recruitment and retention issues, chronic understaffing, and the need to implement reforms and achieve substantial compliance with state laws. The Department must balance competing demands and priorities to ensure effective and responsible use of its budget. Controversies surrounding the SFPD budget may include the use of overtime funding, the implementation of new technologies and systems, and the allocation of resources for community programs and initiatives. + +**Conclusion** + +In conclusion, the 2023 budget of the San Francisco Police Department is a critical component of the city's public safety strategy. Understanding the budget allocation and priorities is essential for ensuring effective policing and community safety. The budget allocates significant funding to support community policing and outreach initiatives, technology and equipment upgrades, and personnel costs. However, the SFPD also faces significant budget challenges and controversies, which must be addressed to ensure the effective and responsible use of its budget. As the city continues to evolve and grow, it is essential to prioritize public safety and ensure that the SFPD has the necessary resources to maintain order and protect the community. + +## Agentic strategies produce better results + +As you can see in the output, the agent attempts to fulfill the request with an initial set of questions and answers, decides it needs more input, and asks more questions before settling on the final result. This ability to self-reflect and improve is part of why agentic strategies are such a powerful way to improve the quality of generative AI output. diff --git a/markdowns/Agent/nvidia_sub_question_query_engine.md b/markdowns/Agent/nvidia_sub_question_query_engine.md new file mode 100644 index 0000000..47eb11e --- /dev/null +++ b/markdowns/Agent/nvidia_sub_question_query_engine.md @@ -0,0 +1,297 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/nvidia_sub_question_query_engine.ipynb +toc: True +title: "Sub Question Query Engine powered by NVIDIA NIMs" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +A Sub Question Query Engine takes a single, complex question and breaks it into multiple sub-questions, each of which can be answered by a different tool. We'll use NVIDIA NIMs to power our sub-question generation and answer retrieval. + + +### NVIDIA NIMs + +NIM supports models across domains like chat, embedding, and re-ranking models +from the community as well as NVIDIA. These models are optimized by NVIDIA to deliver the best performance on NVIDIA +accelerated infrastructure and deployed as a NIM, an easy-to-use, prebuilt containers that deploy anywhere using a single +command on NVIDIA accelerated infrastructure. + +NVIDIA hosted deployments of NIMs are available to test on the [NVIDIA API catalog](https://build.nvidia.com/). After testing, +NIMs can be exported from NVIDIA’s API catalog using the NVIDIA AI Enterprise license and run on-premises or in the cloud, +giving enterprises ownership and full control of their IP and AI application. + +NIMs are packaged as container images on a per model basis and are distributed as NGC container images through the NVIDIA NGC Catalog. +At their core, NIMs provide easy, consistent, and familiar APIs for running inference on an AI model. + +## Setup +Import our dependencies and set up our NVIDIA API key from the API catalog, https://build.nvidia.com for the two models we'll use hosted on the catalog (embedding and re-ranking models). + +**To get started:** + +1. Create a free account with [NVIDIA](https://build.nvidia.com/), which hosts NVIDIA AI Foundation models. + +2. Click on your model of choice. + +3. Under Input select the Python tab, and click `Get API Key`. Then click `Generate Key`. + +4. Copy and save the generated key as NVIDIA_API_KEY. From there, you should have access to the endpoints. + +**Install our dependencies:** +* LlamaIndex core for most things +* NVIDIA NIM LLM and embeddings for LLM actions +* `llama-index-readers-file` to power the PDF reader in `SimpleDirectoryReader` + + + + +```python +!pip install llama-index-core llama-index-llms-nvidia llama-index-embeddings-nvidia llama-index-readers-file llama-index-utils-workflow +``` + +Bring in our dependencies as imports: + + +```python +import os, json +from llama_index.core import ( + SimpleDirectoryReader, + VectorStoreIndex, + StorageContext, + load_index_from_storage, + Settings, +) +from llama_index.core.tools import QueryEngineTool, ToolMetadata +from llama_index.core.workflow import ( + step, + Context, + Workflow, + Event, + StartEvent, + StopEvent, +) +from llama_index.core.agent.workflow import ReActAgent +from llama_index.llms.nvidia import NVIDIA +from llama_index.embeddings.nvidia import NVIDIAEmbedding +from llama_index.utils.workflow import draw_all_possible_flows +``` + +# Define the Sub Question Query Engine as a Workflow + +* Our StartEvent goes to `query()`, which takes care of several things: + * Accepts and stores the original query + * Stores the LLM to handle the queries + * Stores the list of tools to enable sub-questions + * Passes the original question to the LLM, asking it to split up the question into sub-questions + * Fires off a `QueryEvent` for every sub-question generated + +* QueryEvents go to `sub_question()`, which instantiates a new ReAct agent with the full list of tools available and lets it select which one to use. + * This is slightly better than the actual SQQE built-in to LlamaIndex, which cannot use multiple tools + * Each QueryEvent generates an `AnswerEvent` + +* AnswerEvents go to `combine_answers()`. + * This uses `self.collect_events()` to wait for every QueryEvent to return an answer. + * All the answers are then combined into a final prompt for the LLM to consolidate them into a single response + * A StopEvent is generated to return the final result + + +```python +class QueryEvent(Event): + question: str + + +class AnswerEvent(Event): + question: str + answer: str + + +class SubQuestionQueryEngine(Workflow): + @step + async def query(self, ctx: Context, ev: StartEvent) -> QueryEvent: + if hasattr(ev, "query"): + await ctx.store.set("original_query", ev.query) + print(f"Query is {await ctx.store.get('original_query')}") + + if hasattr(ev, "llm"): + await ctx.store.set("llm", ev.llm) + + if hasattr(ev, "tools"): + await ctx.store.set("tools", ev.tools) + + response = (await ctx.store.get("llm")).complete( + f""" + Given a user question, and a list of tools, output a list of + relevant sub-questions, such that the answers to all the + sub-questions put together will answer the question. Respond + in pure JSON without any markdown, like this: + {{ + "sub_questions": [ + "What is the population of San Francisco?", + "What is the budget of San Francisco?", + "What is the GDP of San Francisco?" + ] + }} + Here is the user question: {await ctx.store.get('original_query')} + + And here is the list of tools: {await ctx.store.get('tools')} + """ + ) + + print(f"Sub-questions are {response}") + + response_obj = json.loads(str(response)) + sub_questions = response_obj["sub_questions"] + + await ctx.store.set("sub_question_count", len(sub_questions)) + + for question in sub_questions: + self.send_event(QueryEvent(question=question)) + + return None + + @step + async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent: + print(f"Sub-question is {ev.question}") + + agent = ReActAgent( + tools=await ctx.store.get("tools"), + llm=await ctx.store.get("llm"), + ) + response = await agent.run(ev.question) + + return AnswerEvent(question=ev.question, answer=str(response)) + + @step + async def combine_answers( + self, ctx: Context, ev: AnswerEvent + ) -> StopEvent | None: + ready = ctx.collect_events( + ev, [AnswerEvent] * await ctx.store.get("sub_question_count") + ) + if ready is None: + return None + + answers = "\n\n".join( + [ + f"Question: {event.question}: \n Answer: {event.answer}" + for event in ready + ] + ) + + prompt = f""" + You are given an overall question that has been split into sub-questions, + each of which has been answered. Combine the answers to all the sub-questions + into a single answer to the original question. + + Original question: {await ctx.store.get('original_query')} + + Sub-questions and answers: + {answers} + """ + + print(f"Final prompt is {prompt}") + + response = (await ctx.store.get("llm")).complete(prompt) + + print("Final response is", response) + + return StopEvent(result=str(response)) +``` + + +```python +draw_all_possible_flows( + SubQuestionQueryEngine, filename="sub_question_query_engine.html" +) +``` + +Visualizing this flow looks pretty linear, since it doesn't capture that `query()` can generate multiple parallel `QueryEvents` which get collected into `combine_answers`. + +![Screenshot 2024-08-07 at 3.31.55 PM.png](data:image/png;base64,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) + +# Download data to demo + + +```python +!mkdir -p "./data/sf_budgets/" +!wget "https://www.dropbox.com/scl/fi/xt3squt47djba0j7emmjb/2016-CSF_Budget_Book_2016_FINAL_WEB_with-cover-page.pdf?rlkey=xs064cjs8cb4wma6t5pw2u2bl&dl=0" -O "./data/sf_budgets/2016 - CSF_Budget_Book_2016_FINAL_WEB_with-cover-page.pdf" +!wget "https://www.dropbox.com/scl/fi/jvw59g5nscu1m7f96tjre/2017-Proposed-Budget-FY2017-18-FY2018-19_1.pdf?rlkey=v988oigs2whtcy87ti9wti6od&dl=0" -O "./data/sf_budgets/2017 - 2017-Proposed-Budget-FY2017-18-FY2018-19_1.pdf" +!wget "https://www.dropbox.com/scl/fi/izknlwmbs7ia0lbn7zzyx/2018-o0181-18.pdf?rlkey=p5nv2ehtp7272ege3m9diqhei&dl=0" -O "./data/sf_budgets/2018 - 2018-o0181-18.pdf" +!wget "https://www.dropbox.com/scl/fi/1rstqm9rh5u5fr0tcjnxj/2019-Proposed-Budget-FY2019-20-FY2020-21.pdf?rlkey=3s2ivfx7z9bev1r840dlpbcgg&dl=0" -O "./data/sf_budgets/2019 - 2019-Proposed-Budget-FY2019-20-FY2020-21.pdf" +!wget "https://www.dropbox.com/scl/fi/7teuwxrjdyvgw0n8jjvk0/2021-AAO-FY20-21-FY21-22-09-11-2020-FINAL.pdf?rlkey=6br3wzxwj5fv1f1l8e69nbmhk&dl=0" -O "./data/sf_budgets/2021 - 2021-AAO-FY20-21-FY21-22-09-11-2020-FINAL.pdf" +!wget "https://www.dropbox.com/scl/fi/zhgqch4n6xbv9skgcknij/2022-AAO-FY2021-22-FY2022-23-FINAL-20210730.pdf?rlkey=h78t65dfaz3mqbpbhl1u9e309&dl=0" -O "./data/sf_budgets/2022 - 2022-AAO-FY2021-22-FY2022-23-FINAL-20210730.pdf" +!wget "https://www.dropbox.com/scl/fi/vip161t63s56vd94neqlt/2023-CSF_Proposed_Budget_Book_June_2023_Master_Web.pdf?rlkey=hemoce3w1jsuf6s2bz87g549i&dl=0" -O "./data/sf_budgets/2023 - 2023-CSF_Proposed_Budget_Book_June_2023_Master_Web.pdf" +``` + +# Load data and run the workflow + +Just like using the built-in Sub-Question Query Engine, we create our query tools and instantiate an LLM and pass them in. + +Each tool is its own query engine based on a single (very lengthy) San Francisco budget document, each of which is 300+ pages. To save time on repeated runs, we persist our generated indexes to disk. + + +```python +import getpass + +if os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"): + print("Valid NVIDIA_API_KEY already in environment. Delete to reset") +else: + nvapi_key = getpass.getpass("NVAPI Key (starts with nvapi-): ") + assert nvapi_key.startswith( + "nvapi-" + ), f"{nvapi_key[:5]}... is not a valid key" + os.environ["NVIDIA_API_KEY"] = nvapi_key + +folder = "./data/sf_budgets/" +files = os.listdir(folder) + +Settings.embed_model = NVIDIAEmbedding( + model="nvidia/nv-embedqa-e5-v5", truncate="END" +) +Settings.llm = NVIDIA() + +query_engine_tools = [] +for file in files: + year = file.split(" - ")[0] + index_persist_path = f"./storage/budget-{year}/" + + if os.path.exists(index_persist_path): + storage_context = StorageContext.from_defaults( + persist_dir=index_persist_path + ) + index = load_index_from_storage(storage_context) + else: + documents = SimpleDirectoryReader( + input_files=[folder + file] + ).load_data() + index = VectorStoreIndex.from_documents(documents) + index.storage_context.persist(index_persist_path) + + engine = index.as_query_engine() + query_engine_tools.append( + QueryEngineTool( + query_engine=engine, + metadata=ToolMetadata( + name=f"budget_{year}", + description=f"You can ask this tool natural-language questions about San Francisco's budget in {year}", + ), + ) + ) +``` + + +```python +engine = SubQuestionQueryEngine(timeout=120, verbose=True) +result = await engine.run( + llm=Settings.llm, + tools=query_engine_tools, + query="How has the total amount of San Francisco's budget changed from 2016 to 2023?", +) + +print(result) +``` + +Our debug output is lengthy! You can see the sub-questions being generated and then `sub_question()` being repeatedly invoked, each time generating a brief log of ReAct agent thoughts and actions to answer each smaller question. + +You can see `combine_answers` running multiple times; these were triggered by each `AnswerEvent` but before all 8 `AnswerEvents` were collected. On its final run it generates a full prompt, combines the answers and returns the result. diff --git a/markdowns/Agent/openai_agent_context_retrieval.md b/markdowns/Agent/openai_agent_context_retrieval.md new file mode 100644 index 0000000..2afa580 --- /dev/null +++ b/markdowns/Agent/openai_agent_context_retrieval.md @@ -0,0 +1,295 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_context_retrieval.ipynb +toc: True +title: "Context-Augmented Function Calling Agent" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this tutorial, we show you how to to make your agent context-aware. + +Our indexing/retrieval modules help to remove the complexity of having too many functions to fit in the prompt. + +## Initial Setup + +Here we setup a normal FunctionAgent, and then augment it with context. This agent will perform retrieval first before calling any tools. This can help ground the agent's tool picking and answering capabilities in context. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core.settings import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +import json +from typing import Sequence + +from llama_index.core import ( + SimpleDirectoryReader, + VectorStoreIndex, + StorageContext, + load_index_from_storage, +) +from llama_index.core.tools import QueryEngineTool +``` + + +```python +try: + storage_context = StorageContext.from_defaults( + persist_dir="./storage/march" + ) + march_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/june" + ) + june_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/sept" + ) + sept_index = load_index_from_storage(storage_context) + + index_loaded = True +except: + index_loaded = False +``` + +Download Data + + +```python +!mkdir -p 'data/10q/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_march_2022.pdf' -O 'data/10q/uber_10q_march_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_june_2022.pdf' -O 'data/10q/uber_10q_june_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_sept_2022.pdf' -O 'data/10q/uber_10q_sept_2022.pdf' +``` + + +```python +# build indexes across the three data sources +if not index_loaded: + # load data + march_docs = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_march_2022.pdf"] + ).load_data() + june_docs = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_june_2022.pdf"] + ).load_data() + sept_docs = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_sept_2022.pdf"] + ).load_data() + + # build index + march_index = VectorStoreIndex.from_documents(march_docs) + june_index = VectorStoreIndex.from_documents(june_docs) + sept_index = VectorStoreIndex.from_documents(sept_docs) + + # persist index + march_index.storage_context.persist(persist_dir="./storage/march") + june_index.storage_context.persist(persist_dir="./storage/june") + sept_index.storage_context.persist(persist_dir="./storage/sept") +``` + + +```python +march_engine = march_index.as_query_engine(similarity_top_k=3) +june_engine = june_index.as_query_engine(similarity_top_k=3) +sept_engine = sept_index.as_query_engine(similarity_top_k=3) +``` + + +```python +query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=march_engine, + name="uber_march_10q", + description=( + "Provides information about Uber 10Q filings for March 2022. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=june_engine, + name="uber_june_10q", + description=( + "Provides information about Uber financials for June 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=sept_engine, + name="uber_sept_10q", + description=( + "Provides information about Uber financials for Sept 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), +] +``` + +### Try Context-Augmented Agent + +Here we augment our agent with context in different settings: +- toy context: we define some abbreviations that map to financial terms (e.g. R=Revenue). We supply this as context to the agent + + +```python +from llama_index.core import Document +from llama_index.core.agent.workflow import FunctionAgent +``` + + +```python +# toy index - stores a list of abbreviations +texts = [ + "Abbreviation: 'Y' = Revenue", + "Abbreviation: 'X' = Risk Factors", + "Abbreviation: 'Z' = Costs", +] +docs = [Document(text=t) for t in texts] +context_index = VectorStoreIndex.from_documents(docs) +context_retriever = context_index.as_retriever(similarity_top_k=2) +``` + + +```python +from llama_index.core.tools import BaseTool + +system_prompt_template = """You are a helpful assistant. +Here is some context that you can use to answer the user's question and for help with picking the right tool: + +{context} +""" + + +async def get_agent_with_context_awareness( + query: str, context_retriever, tools: list[BaseTool] +) -> FunctionAgent: + context_nodes = await context_retriever.aretrieve(query) + context_text = "\n----\n".join([n.node.text for n in context_nodes]) + + return FunctionAgent( + tools=tools, + llm=OpenAI(model="gpt-4o"), + system_prompt=system_prompt_template.format(context=context_text), + ) +``` + + +```python +query = "What is the 'X' of March 2022?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) + +response = await agent.run(query) +``` + + +```python +print(str(response)) +``` + + The risk factors mentioned in Uber's 10-Q filing for March 2022 include uncertainties related to the COVID-19 pandemic, such as the severity and duration of the outbreak, potential future waves or variants of the virus, the administration and efficacy of vaccines, and the impact of governmental actions. There are also concerns regarding the effects on drivers, merchants, consumers, and business partners, as well as other factors that may affect the company's business, results of operations, financial position, and cash flows. + + + +```python +query = "What is the 'Y' and 'Z' in September 2022?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) + +response = await agent.run(query) +``` + + +```python +print(str(response)) +``` + + In September 2022, Uber's revenue (Y) was $8,343 million, and the total costs (Z) were $8,839 million. + + +### Managing Context/Memory + +By default, each `.run()` call is stateless. We can manage context by using a serializable `Context` object. + + +```python +from llama_index.core.workflow import Context + +ctx = Context(agent) + +query = "What is the 'Y' and 'Z' in September 2022?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) +response = await agent.run(query, ctx=ctx) + +query = "What did I just ask?" +agent = await get_agent_with_context_awareness( + query, context_retriever, query_engine_tools +) +response = await agent.run(query, ctx=ctx) +print(str(response)) +``` + + You asked for the revenue ('Y') and costs ('Z') for Uber in September 2022. + + +### Use Uber 10-Q as context, use Calculator as Tool + + +```python +from llama_index.core.tools import FunctionTool + + +def magic_formula(revenue: int, cost: int) -> int: + """Runs MAGIC_FORMULA on revenue and cost.""" + return revenue - cost + + +magic_tool = FunctionTool.from_defaults(magic_formula) +``` + + +```python +context_retriever = sept_index.as_retriever(similarity_top_k=3) +``` + + +```python +query = "Can you run MAGIC_FORMULA on Uber's revenue and cost?" +agent = await get_agent_with_context_awareness( + query, context_retriever, [magic_tool] +) +response = await agent.run(query) +print(str(response)) +``` + + The result of running MAGIC_FORMULA on Uber's revenue of $8,343 million and cost of $5,173 million is 3,170. + diff --git a/markdowns/Agent/openai_agent_lengthy_tools.md b/markdowns/Agent/openai_agent_lengthy_tools.md new file mode 100644 index 0000000..7a98c4a --- /dev/null +++ b/markdowns/Agent/openai_agent_lengthy_tools.md @@ -0,0 +1,401 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_lengthy_tools.ipynb +toc: True +title: "OpenAI Agent Workarounds for Lengthy Tool Descriptions" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this demo, we illustrate a workaround for defining an OpenAI tool +whose description exceeds OpenAI's current limit of 1024 characters. +For simplicity, we will build upon the `QueryPlanTool` notebook +example. + +If you're opening this Notebook on Colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index-agent-openai +%pip install llama-index-llms-openai +``` + + +```python +!pip install llama-index +``` + + +```python +%load_ext autoreload +%autoreload 2 +``` + + +```python +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex +from llama_index.llms.openai import OpenAI +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +llm = OpenAI(temperature=0, model="gpt-4") +``` + +## Download Data + + +```python +!mkdir -p 'data/10q/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_march_2022.pdf' -O 'data/10q/uber_10q_march_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_june_2022.pdf' -O 'data/10q/uber_10q_june_2022.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_sept_2022.pdf' -O 'data/10q/uber_10q_sept_2022.pdf' +``` + + --2024-05-23 13:36:24-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_march_2022.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1260185 (1.2M) [application/octet-stream] + Saving to: ‘data/10q/uber_10q_march_2022.pdf’ + + data/10q/uber_10q_m 100%[===================>] 1.20M --.-KB/s in 0.04s + + 2024-05-23 13:36:24 (29.0 MB/s) - ‘data/10q/uber_10q_march_2022.pdf’ saved [1260185/1260185] + + --2024-05-23 13:36:24-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_june_2022.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1238483 (1.2M) [application/octet-stream] + Saving to: ‘data/10q/uber_10q_june_2022.pdf’ + + data/10q/uber_10q_j 100%[===================>] 1.18M --.-KB/s in 0.04s + + 2024-05-23 13:36:24 (26.4 MB/s) - ‘data/10q/uber_10q_june_2022.pdf’ saved [1238483/1238483] + + --2024-05-23 13:36:24-- https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10q/uber_10q_sept_2022.pdf + Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ... + Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. + HTTP request sent, awaiting response... 200 OK + Length: 1178622 (1.1M) [application/octet-stream] + Saving to: ‘data/10q/uber_10q_sept_2022.pdf’ + + data/10q/uber_10q_s 100%[===================>] 1.12M --.-KB/s in 0.05s + + 2024-05-23 13:36:25 (22.7 MB/s) - ‘data/10q/uber_10q_sept_2022.pdf’ saved [1178622/1178622] + + + +## Load data + + +```python +march_2022 = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_march_2022.pdf"] +).load_data() +june_2022 = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_june_2022.pdf"] +).load_data() +sept_2022 = SimpleDirectoryReader( + input_files=["./data/10q/uber_10q_sept_2022.pdf"] +).load_data() +``` + +## Build indices + +We build a vector index / query engine over each of the documents (March, June, September). + + +```python +march_index = VectorStoreIndex.from_documents(march_2022) +june_index = VectorStoreIndex.from_documents(june_2022) +sept_index = VectorStoreIndex.from_documents(sept_2022) +``` + + +```python +march_engine = march_index.as_query_engine(similarity_top_k=3, llm=llm) +june_engine = june_index.as_query_engine(similarity_top_k=3, llm=llm) +sept_engine = sept_index.as_query_engine(similarity_top_k=3, llm=llm) +``` + +## Defining an Excessively Lengthy Query Plan + +Although a `QueryPlanTool` may be composed from many `QueryEngineTools`, +a single OpenAI tool is ultimately created from the `QueryPlanTool` +when the OpenAI API call is made. The description of this tool begins with +general instructions about the query plan approach, followed by the +descriptions of each constituent `QueryEngineTool`. + +Currently, each OpenAI tool description has a maximum length of 1024 characters. +As you add more `QueryEngineTools` to your `QueryPlanTool`, you may exceed +this limit. If the limit is exceeded, LlamaIndex will raise an error when it +attempts to construct the OpenAI tool. + +Let's demonstrate this scenario with an exaggerated example, where we will +give each query engine tool a very lengthy and redundant description. + + +```python +description_10q_general = """\ +A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, +providing an overview of the company's financial performance for the quarter. +It includes unaudited financial statements (income statement, balance sheet, +and cash flow statement) and the Management's Discussion and Analysis (MD&A), +where management explains significant changes and future expectations. +The 10-Q also discloses significant legal proceedings, updates on risk factors, +and information on the company's internal controls. Its primary purpose is to keep +investors informed about the company's financial status and operations, +enabling informed investment decisions.""" + +description_10q_specific = ( + "This 10-Q provides Uber quarterly financials ending" +) +``` + + +```python +from llama_index.core.tools import QueryEngineTool +from llama_index.core.tools import QueryPlanTool +from llama_index.core import get_response_synthesizer +``` + + +```python +query_tool_sept = QueryEngineTool.from_defaults( + query_engine=sept_engine, + name="sept_2022", + description=f"{description_10q_general} {description_10q_specific} September 2022", +) +query_tool_june = QueryEngineTool.from_defaults( + query_engine=june_engine, + name="june_2022", + description=f"{description_10q_general} {description_10q_specific} June 2022", +) +query_tool_march = QueryEngineTool.from_defaults( + query_engine=march_engine, + name="march_2022", + description=f"{description_10q_general} {description_10q_specific} March 2022", +) + +print(len(query_tool_sept.metadata.description)) +print(len(query_tool_june.metadata.description)) +print(len(query_tool_march.metadata.description)) +``` + + 730 + 725 + 726 + + +From the print statements above, we see that we will easily exceed the +maximum character limit of 1024 when composing these tools into the `QueryPlanTool`. + + +```python +query_engine_tools = [query_tool_sept, query_tool_june, query_tool_march] + +response_synthesizer = get_response_synthesizer() +query_plan_tool = QueryPlanTool.from_defaults( + query_engine_tools=query_engine_tools, + response_synthesizer=response_synthesizer, +) +``` + + +```python +openai_tool = query_plan_tool.metadata.to_openai_tool() +``` + + + --------------------------------------------------------------------------- + + ValueError Traceback (most recent call last) + + Cell In[12], line 1 + ----> 1 openai_tool = query_plan_tool.metadata.to_openai_tool() + + + File ~/Code/run-llama/llama_index/llama-index-core/llama_index/core/tools/types.py:74, in ToolMetadata.to_openai_tool(self) + 72 """To OpenAI tool.""" + 73 if len(self.description) > 1024: + ---> 74 raise ValueError( + 75 "Tool description exceeds maximum length of 1024 characters. " + 76 "Please shorten your description or move it to the prompt." + 77 ) + 78 return { + 79 "type": "function", + 80 "function": { + (...) + 84 }, + 85 } + + + ValueError: Tool description exceeds maximum length of 1024 characters. Please shorten your description or move it to the prompt. + + +## Moving Tool Descriptions to the Prompt + +One obvious solution to this problem would be to shorten the tool +descriptions themselves, however with sufficiently many tools, +we will still eventually exceed the character limit. + +A more scalable solution would be to move the tool descriptions to the prompt. +This solves the character limit issue, since without the descriptions +of the query engine tools, the query plan description will remain fixed +in size. Of course, token limits imposed by the selected LLM will still +bound the tool descriptions, however these limits are far larger than the +1024 character limit. + +There are two steps involved in moving these tool descriptions to the +prompt. First, we must modify the metadata property of the `QueryPlanTool` +to omit the `QueryEngineTool` descriptions, and make a slight modification +to the default query planning instructions (telling the LLM to look for the +tool names and descriptions in the prompt.) + + +```python +from llama_index.core.tools.types import ToolMetadata + +introductory_tool_description_prefix = """\ +This is a query plan tool that takes in a list of tools and executes a \ +query plan over these tools to answer a query. The query plan is a DAG of query nodes. + +Given a list of tool names and the query plan schema, you \ +can choose to generate a query plan to answer a question. + +The tool names and descriptions will be given alongside the query. +""" + +# Modify metadata to only include the general query plan instructions +new_metadata = ToolMetadata( + introductory_tool_description_prefix, + query_plan_tool.metadata.name, + query_plan_tool.metadata.fn_schema, +) +query_plan_tool.metadata = new_metadata +query_plan_tool.metadata +``` + + + + + ToolMetadata(description='This is a query plan tool that takes in a list of tools and executes a query plan over these tools to answer a query. The query plan is a DAG of query nodes.\n\nGiven a list of tool names and the query plan schema, you can choose to generate a query plan to answer a question.\n\nThe tool names and descriptions will be given alongside the query.\n', name='query_plan_tool', fn_schema=, return_direct=False) + + + +Second, we must concatenate our tool names and descriptions alongside +the query being posed. + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent( + tools=[query_plan_tool], + llm=OpenAI(temperature=0, model="gpt-4o"), +) + +query = "What were the risk factors in sept 2022?" +``` + + +```python +# Reconstruct concatenated query engine tool descriptions +tools_description = "\n\n".join( + [ + f"Tool Name: {tool.metadata.name}\n" + + f"Tool Description: {tool.metadata.description} " + for tool in query_engine_tools + ] +) + +# Concatenate tool descriptions and query +query_planned_query = f"{tools_description}\n\nQuery: {query}" +query_planned_query +``` + + + + + "Tool Name: sept_2022\nTool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending September 2022 \n\nTool Name: june_2022\nTool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending June 2022 \n\nTool Name: march_2022\nTool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending March 2022 \n\nQuery: What were the risk factors in sept 2022?" + + + + +```python +response = await agent.run(query_planned_query) +response +``` + + Added user message to memory: Tool Name: sept_2022 + Tool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, + providing an overview of the company's financial performance for the quarter. + It includes unaudited financial statements (income statement, balance sheet, + and cash flow statement) and the Management's Discussion and Analysis (MD&A), + where management explains significant changes and future expectations. + The 10-Q also discloses significant legal proceedings, updates on risk factors, + and information on the company's internal controls. Its primary purpose is to keep + investors informed about the company's financial status and operations, + enabling informed investment decisions. This 10-Q provides Uber quarterly financials ending September 2022 + + Tool Name: june_2022 + Tool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, + providing an overview of the company's financial performance for the quarter. + It includes unaudited financial statements (income statement, balance sheet, + and cash flow statement) and the Management's Discussion and Analysis (MD&A), + where management explains significant changes and future expectations. + The 10-Q also discloses significant legal proceedings, updates on risk factors, + and information on the company's internal controls. Its primary purpose is to keep + investors informed about the company's financial status and operations, + enabling informed investment decisions. This 10-Q provides Uber quarterly financials ending June 2022 + + Tool Name: march_2022 + Tool Description: A Form 10-Q is a quarterly report required by the SEC for publicly traded companies, + providing an overview of the company's financial performance for the quarter. + It includes unaudited financial statements (income statement, balance sheet, + and cash flow statement) and the Management's Discussion and Analysis (MD&A), + where management explains significant changes and future expectations. + The 10-Q also discloses significant legal proceedings, updates on risk factors, + and information on the company's internal controls. Its primary purpose is to keep + investors informed about the company's financial status and operations, + enabling informed investment decisions. This 10-Q provides Uber quarterly financials ending March 2022 + + Query: What were the risk factors in sept 2022? + === Calling Function === + Calling function: query_plan_tool with args: { + "nodes": [ + { + "id": 1, + "query_str": "What were the risk factors in sept 2022?", + "tool_name": "sept_2022", + "dependencies": [] + } + ] + } + Executing node {"id": 1, "query_str": "What were the risk factors in sept 2022?", "tool_name": "sept_2022", "dependencies": []} + Selected Tool: ToolMetadata(description="A Form 10-Q is a quarterly report required by the SEC for publicly traded companies,\nproviding an overview of the company's financial performance for the quarter.\nIt includes unaudited financial statements (income statement, balance sheet,\nand cash flow statement) and the Management's Discussion and Analysis (MD&A),\nwhere management explains significant changes and future expectations.\nThe 10-Q also discloses significant legal proceedings, updates on risk factors,\nand information on the company's internal controls. Its primary purpose is to keep\ninvestors informed about the company's financial status and operations,\nenabling informed investment decisions. This 10-Q provides Uber quarterly financials ending September 2022", name='sept_2022', fn_schema=, return_direct=False) + Executed query, got response. + Query: What were the risk factors in sept 2022? + Response: The risk factors in September 2022 included failure to meet regulatory requirements related to climate change or to meet stated climate change commitments, which could impact costs, operations, brand, and reputation. The ongoing COVID-19 pandemic and responses to it were also a risk, as they had an adverse impact on business and operations, including reducing the demand for Mobility offerings globally and affecting travel behavior and demand. Catastrophic events such as disease, weather events, war, or terrorist attacks could also adversely impact the business, financial condition, and results of operation. Other risks included errors, bugs, or vulnerabilities in the platform's code or systems, inappropriate or controversial data practices, and the growing use of artificial intelligence. Climate change related physical and transition risks, such as market shifts toward electric vehicles and lower carbon business models, and risks related to extreme weather events or natural disasters, were also a concern. + Got output: The risk factors in September 2022 included failure to meet regulatory requirements related to climate change or to meet stated climate change commitments, which could impact costs, operations, brand, and reputation. The ongoing COVID-19 pandemic and responses to it were also a risk, as they had an adverse impact on business and operations, including reducing the demand for Mobility offerings globally and affecting travel behavior and demand. Catastrophic events such as disease, weather events, war, or terrorist attacks could also adversely impact the business, financial condition, and results of operation. Other risks included errors, bugs, or vulnerabilities in the platform's code or systems, inappropriate or controversial data practices, and the growing use of artificial intelligence. Climate change related physical and transition risks, such as market shifts toward electric vehicles and lower carbon business models, and risks related to extreme weather events or natural disasters, were also a concern. + ======================== + + + + + + + Response(response="The risk factors for Uber in September 2022 included:\n\n1. Failure to meet regulatory requirements related to climate change or to meet stated climate change commitments, which could impact costs, operations, brand, and reputation.\n2. The ongoing COVID-19 pandemic and responses to it were also a risk, as they had an adverse impact on business and operations, including reducing the demand for Mobility offerings globally and affecting travel behavior and demand.\n3. Catastrophic events such as disease, weather events, war, or terrorist attacks could also adversely impact the business, financial condition, and results of operation.\n4. Other risks included errors, bugs, or vulnerabilities in the platform's code or systems, inappropriate or controversial data practices, and the growing use of artificial intelligence.\n5. Climate change related physical and transition risks, such as market shifts toward electric vehicles and lower carbon business models, and risks related to extreme weather events or natural disasters, were also a concern.", source_nodes=[NodeWithScore(node=TextNode(id_='a92c1e5e-6285-4225-8c87-b9dbd2b07d89', embedding=None, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], relationships={: RelatedNodeInfo(node_id='b5e99044-59e9-439a-9e53-802a517b287d', node_type=, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='edddd9bda362411ae2e4d36144b5049c8b2ce5ec26047fa7c04003a9265aa87d'), : RelatedNodeInfo(node_id='04ae9351-0136-491a-8756-41dc2b8071a1', node_type=, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='bdc5ab49a54e18f73a2687096148f9e567a053ea2d3bd3c051956fb359078f5e')}, text='Any failure to\nmeet regulatory requirements related to climate change, or to meet our stated climate change commitments on the timeframe we committed to, or at all, could have\nan adverse impact on our costs and ability to operate, as well as harm our brand, reputation, and consequently, our business.\nGeneral Economic Risks\nOutbreaks of contagious disease, such as the COVID-19 pandemic and the impact of actions to mitigate the such disease or pandemic, have adversely impacted\nand could continue to adversely impact our business, financial condition and results of operations.\nOccurrence of a catastrophic event, including but not limited to disease, a weather event, war, or terrorist attack, could adversely impact our business, financial\ncondition and results of operation. We also face risks related to health epidemics, outbreaks of contagious disease, and other adverse health developments. For\nexample, the ongoing COVID-19 pandemic and responses to it have had, and may continue to have, an adverse impact on our business and operations, including,\nfor example, by reducing the demand for our Mobility offerings globally, and affecting travel behavior and demand. Even as COVID-related restrictions have been\nlifted and many regions around the world are making progress in their recovery from the pandemic, we have experienced and may continue to experience Driver\nsupply constraints, and we are observing that consumer demand for Mobility is recovering faster than driver availability, as such supply constraints have been and\nmay continue to be impacted by concerns regarding the COVID-19 pandemic. Furthermore, to support social distancing, we temporarily suspended our shared\nrides offering globally, and recently re-launched our shared rides offering in certain regions.\n73', start_char_idx=4469, end_char_idx=6258, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'), score=0.8039095664957979), NodeWithScore(node=TextNode(id_='04ae9351-0136-491a-8756-41dc2b8071a1', embedding=None, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], relationships={: RelatedNodeInfo(node_id='b5e99044-59e9-439a-9e53-802a517b287d', node_type=, metadata={'page_label': '74', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='edddd9bda362411ae2e4d36144b5049c8b2ce5ec26047fa7c04003a9265aa87d'), : RelatedNodeInfo(node_id='a92c1e5e-6285-4225-8c87-b9dbd2b07d89', node_type=, metadata={}, hash='4862564636269739d75565c6c9dc166659cf52e29ec337fe9b85802beeb2ce7d')}, text='platform to platform users. In addition, our release of new software in the past has inadvertently caused, and may in the future cause, interruptions in the\navailability or functionality of our platform. Any errors, bugs, or vulnerabilities discovered in our code or systems after release could result in an interruption in the\navailability of our platform or a negative experience for Drivers, consumers, merchants, Shippers, and Carriers, and could also result in negative publicity and\nunfavorable media coverage, damage to our reputation, loss of platform users, loss of revenue or liability for damages, regulatory inquiries, or other proceedings,\nany of which could adversely affect our business and financial results. In addition, our growing use of artificial intelligence (“AI”) (including machine learning) in\nour offerings presents additional risks. AI algorithms or automated processing of data may be flawed and datasets may be insufficient or contain biased information.\nInappropriate or controversial data practices by us or others could impair the acceptance of AI solutions or subject us to lawsuits and regulatory investigations.\nThese deficiencies could undermine the decisions, predictions or analysis AI applications produce, or lead to unintentional bias and discrimination, subjecting us to\ncompetitive harm, legal liability, and brand or reputational harm.\nWe are subject to climate change risks, including physical and transitional risks, and if we are unable to manage such risks, our business may be adversely\nimpacted.\nWe face climate change related physical and transition risks, which include the risk of market shifts toward electric vehicles (“EVs”) and lower carbon\nbusiness models and risks related to extreme weather events or natural disasters. Climate-related events, including the increasing frequency, severity and duration\nof extreme weather events and their impact on critical infrastructure in the United States and elsewhere, have the potential to disrupt our business, our third-party\nsuppliers, and the business of merchants, Shippers, Carriers and Drivers using our platform, and may cause us to experience higher losses and additional costs to\nmaintain or resume operations. Additionally, we are subject to emerging climate policies such as a regulation adopted in California in May 2021 requiring 90% of\nvehicle miles traveled by rideshare fleets in California to have been in zero emission vehicles by 2030, with interim targets beginning in 2023. In addition, Drivers\nmay be subject to climate-related policies that indirectly impact our business, such as the Congestion Charge Zone and Ultra Low Emission Zone schemes adopted\nin London that impose fees on drivers in fossil-fueled vehicles, which may impact our ability to attract and maintain Drivers on our platform, and to the extent we\nexperience Driver supply constraints in a given market, we may need to increase Driver incentives.\nWe have made climate related commitments that require us to invest significant effort, resources, and management time and circumstances may arise,\nincluding those beyond our control, that may require us to revise the contemplated timeframes for implementing these commitments.\nWe have made climate related commitments, including our commitment to 100% renewable electricity for our U.S. offices by 2025, our commitment to net\nzero climate emissions from corporate operations by 2030, and our commitment to be a net zero company by 2040. In addition, our Supplier Code of Conduct sets\nenvironmental standards for our supply chain, and we recognize that there are inherent climate-related risks wherever business is conducted. Progressing towards\nour climate commitments requires us to invest significant effort, resources, and management time, and circumstances may arise, including those beyond our\ncontrol, that may require us to revise our timelines and/or climate commitments. For example, the COVID-19 pandemic has negatively impacted our ability to\ndedicate resources to make the progress on our climate commitments that we initially anticipated. In addition, our ability to meet our climate commitments is\ndependent on external factors such as rapidly changing regulations, policies and related interpretation, advances in technology such as battery storage, as well the\navailability, cost and accessibility of EVs to Drivers, and the availability of EV charging infrastructure that can be efficiently accessed by Drivers. Any failure to\nmeet regulatory requirements related to climate change, or to meet our stated climate change commitments on the timeframe we committed to, or at all, could have\nan adverse impact on our costs and ability to operate, as well as harm our brand, reputation, and consequently, our business.\nGeneral Economic Risks\nOutbreaks of contagious disease, such as the COVID-19 pandemic and the impact of actions to mitigate the such disease or pandemic, have adversely impacted\nand could continue to adversely impact our business, financial condition and results of operations.\nOccurrence of a catastrophic event, including but not limited to disease, a weather event, war, or terrorist attack, could adversely impact our business, financial\ncondition and results of operation.', start_char_idx=0, end_char_idx=5248, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'), score=0.7967699969539317), NodeWithScore(node=TextNode(id_='474572f4-866f-4efa-aa5f-f898d4ba831a', embedding=None, metadata={'page_label': '13', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, excluded_embed_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], excluded_llm_metadata_keys=['file_name', 'file_type', 'file_size', 'creation_date', 'last_modified_date', 'last_accessed_date'], relationships={: RelatedNodeInfo(node_id='2ecd357c-acd3-4398-a0ae-223bf9980f34', node_type=, metadata={'page_label': '13', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='8da53f7e83f88f63304dfcf8186b0ce111a5e161a317d243451266b863e9f2af'), : RelatedNodeInfo(node_id='e2e88da4-92e0-4185-96c6-010a35d94287', node_type=, metadata={'page_label': '13', 'file_name': 'uber_10q_sept_2022.pdf', 'file_path': 'data/10q/uber_10q_sept_2022.pdf', 'file_type': 'application/pdf', 'file_size': 1178622, 'creation_date': '2024-05-23', 'last_modified_date': '2024-05-23'}, hash='373d1a92181565c8fb2ae2831069e904f4f4d2a9fdc70486b91f102cdac9d442')}, text='Estimates are based on historical experience, where\napplicable, and other assumptions which management believes are reasonable under the circumstances. Additionally, we considered the impacts of the coronavirus\npandemic (“COVID-19”) on the assumptions and inputs (including market data) supporting certain of these estimates, assumptions and judgments. On an ongoing\nbasis, management evaluates estimates, including, but not limited to: fair values of investments and other financial instruments (including the measurement of\ncredit or impairment losses); useful lives of amortizable long-lived assets; fair value of acquired intangible assets and related impairment assessments; impairment\nof goodwill; stock-based compensation; income taxes and non-income tax reserves; certain deferred tax assets and tax liabilities; insurance reserves; and other\ncontingent liabilities. These estimates are inherently subject to judgment and actual results could differ from those estimates.\nCertain Significant Risks and Uncertainties - COVID-19\nCOVID-19 restrictions have had an adverse impact on our business and operations by reducing, in particular, the global demand for Mobility offerings. It is\nnot possible to predict COVID-19’s cumulative and ultimate impact on our future business operations, results of operations, financial position, liquidity, and cash\nflows. The extent of the impact of COVID-19 on our business and financial results will depend largely on future developments, including: outbreaks or variants of\nthe virus, both globally and within the United\n12', start_char_idx=4007, end_char_idx=5573, text_template='{metadata_str}\n\n{content}', metadata_template='{key}: {value}', metadata_seperator='\n'), score=0.7911034852964277)], metadata=None) + + diff --git a/markdowns/Agent/openai_agent_query_cookbook.md b/markdowns/Agent/openai_agent_query_cookbook.md new file mode 100644 index 0000000..ad3f71d --- /dev/null +++ b/markdowns/Agent/openai_agent_query_cookbook.md @@ -0,0 +1,783 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_query_cookbook.ipynb +toc: True +title: "OpenAI Agent + Query Engine Experimental Cookbook" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this notebook, we try out the OpenAIAgent across a variety of query engine tools and datasets. We explore how OpenAIAgent can compare/replace existing workflows solved by our retrievers/query engines. + +- Auto retrieval +- Joint SQL and vector search + +**NOTE:** Any Text-to-SQL application should be aware that executing +arbitrary SQL queries can be a security risk. It is recommended to +take precautions as needed, such as using restricted roles, read-only +databases, sandboxing, etc. + +## AutoRetrieval from a Vector Database + +Our existing "auto-retrieval" capabilities (in `VectorIndexAutoRetriever`) allow an LLM to infer the right query parameters for a vector database - including both the query string and metadata filter. + +Since the OpenAI Function API can infer function parameters, we explore its capabilities in performing auto-retrieval here. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +%pip install llama-index-llms-openai +%pip install llama-index-readers-wikipedia +%pip install llama-index-vector-stores-pinecone +``` + + +```python +import os + +os.environ["PINECONE_API_KEY"] = "..." +os.environ["OPENAI_API_KEY"] = "..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +from pinecone import Pinecone, ServerlessSpec + +pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"]) +``` + + +```python +# dimensions are for text-embedding-3-small +pc.create_index( + name="quickstart-index", + dimension=1536, + metric="euclidean", + spec=ServerlessSpec(cloud="aws", region="us-east-1"), +) + +# may need to wait for index to be created +import time + +time.sleep(10) +``` + + + + + { + "name": "quickstart-index", + "metric": "euclidean", + "host": "quickstart-index-c2e1535.svc.aped-4627-b74a.pinecone.io", + "spec": { + "serverless": { + "cloud": "aws", + "region": "us-east-1" + } + }, + "status": { + "ready": true, + "state": "Ready" + }, + "vector_type": "dense", + "dimension": 1536, + "deletion_protection": "disabled", + "tags": null + } + + + + +```python +index = pc.Index("quickstart-index") +``` + + +```python +# Optional: delete data in your pinecone index +# index.delete(deleteAll=True, namespace="test") +``` + + +```python +from llama_index.core import VectorStoreIndex, StorageContext +from llama_index.vector_stores.pinecone import PineconeVectorStore +``` + + +```python +from llama_index.core.schema import TextNode + +nodes = [ + TextNode( + text=( + "Michael Jordan is a retired professional basketball player," + " widely regarded as one of the greatest basketball players of all" + " time." + ), + metadata={ + "category": "Sports", + "country": "United States", + "gender": "male", + "born": 1963, + }, + ), + TextNode( + text=( + "Angelina Jolie is an American actress, filmmaker, and" + " humanitarian. She has received numerous awards for her acting" + " and is known for her philanthropic work." + ), + metadata={ + "category": "Entertainment", + "country": "United States", + "gender": "female", + "born": 1975, + }, + ), + TextNode( + text=( + "Elon Musk is a business magnate, industrial designer, and" + " engineer. He is the founder, CEO, and lead designer of SpaceX," + " Tesla, Inc., Neuralink, and The Boring Company." + ), + metadata={ + "category": "Business", + "country": "United States", + "gender": "male", + "born": 1971, + }, + ), + TextNode( + text=( + "Rihanna is a Barbadian singer, actress, and businesswoman. She" + " has achieved significant success in the music industry and is" + " known for her versatile musical style." + ), + metadata={ + "category": "Music", + "country": "Barbados", + "gender": "female", + "born": 1988, + }, + ), + TextNode( + text=( + "Cristiano Ronaldo is a Portuguese professional footballer who is" + " considered one of the greatest football players of all time. He" + " has won numerous awards and set multiple records during his" + " career." + ), + metadata={ + "category": "Sports", + "country": "Portugal", + "gender": "male", + "born": 1985, + }, + ), +] +``` + + +```python +from llama_index.vector_stores.pinecone import PineconeVectorStore +from llama_index.core import StorageContext + +vector_store = PineconeVectorStore(pinecone_index=index, namespace="test") +storage_context = StorageContext.from_defaults(vector_store=vector_store) +``` + + +```python +from llama_index.core import VectorStoreIndex + +index = VectorStoreIndex(nodes, storage_context=storage_context) +``` + + + Upserted vectors: 0%| | 0/5 [00:00, >=, ==, !=)", + ], + filter_condition: Annotated[ + str, "Metadata filters condition values (could be AND or OR)" + ], + top_k: Annotated[ + int, "The number of results to return from the vector database." + ], +): + """Auto retrieval function. + + Performs auto-retrieval from a vector database, and then applies a set of filters. + + """ + query = query or "Query" + + metadata_filters = [ + MetadataFilter(key=k, value=v, operator=op) + for k, v, op in zip( + filter_key_list, filter_value_list, filter_operator_list + ) + ] + retriever = VectorIndexRetriever( + index, + filters=MetadataFilters( + filters=metadata_filters, condition=filter_condition.lower() + ), + top_k=top_k, + ) + query_engine = RetrieverQueryEngine.from_args(retriever) + + response = await query_engine.aquery(query) + return str(response) + + +description = f"""\ +Use this tool to look up biographical information about celebrities. +The vector database schema is given below: + + +{vector_store_info.model_dump_json()} + +""" + +auto_retrieve_tool = FunctionTool.from_defaults( + auto_retrieve_fn, + name="celebrity_bios", + description=description, +) +``` + +#### Initialize Agent + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent( + tools=[auto_retrieve_tool], + llm=OpenAI(model="gpt-4o"), + system_prompt=( + "You are a helpful assistant that can answer questions about celebrities by writing a filtered query to a vector database. " + "Unless the user is asking to compare things, you generally only need to make one call to the retriever." + ), +) + +# hold the context/session state for the agent +ctx = Context(agent) +``` + + +```python +from llama_index.core.agent.workflow import ( + ToolCallResult, + ToolCall, + AgentStream, + AgentInput, + AgentOutput, +) + +handler = agent.run( + "Tell me about two celebrities from the United States. ", ctx=ctx +) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool celebrity_bios with args {'query': 'celebrities from the United States', 'filter_key_list': ['country'], 'filter_value_list': ['United States'], 'filter_operator_list': ['=='], 'filter_condition': 'AND', 'top_k': 2}, got response: Angelina Jolie and Elon Musk are notable celebrities from the United States. + Here are two celebrities from the United States: + + 1. **Angelina Jolie**: She is a renowned actress, filmmaker, and humanitarian. Jolie has received numerous accolades, including an Academy Award and three Golden Globe Awards. She is also known for her humanitarian efforts, particularly her work with refugees as a Special Envoy for the United Nations High Commissioner for Refugees (UNHCR). + + 2. **Elon Musk**: He is a prominent entrepreneur and business magnate. Musk is the CEO and lead designer of SpaceX, CEO and product architect of Tesla, Inc., and has been involved in numerous other ventures, including Neuralink and The Boring Company. He is known for his ambitious vision of the future, including space exploration and sustainable energy. + + +```python +handler = agent.run("Tell me about two celebrities born after 1980. ", ctx=ctx) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool celebrity_bios with args {'query': 'celebrities born after 1980', 'filter_key_list': ['born'], 'filter_value_list': [1980], 'filter_operator_list': ['>'], 'filter_condition': 'AND', 'top_k': 2}, got response: Rihanna, born in 1988, is a celebrity who fits the criteria of being born after 1980. + Here is a celebrity born after 1980: + + - **Rihanna**: Born in 1988, Rihanna is a Barbadian singer, actress, and businesswoman. She gained worldwide fame with her music career, producing hits like "Umbrella," "Diamonds," and "Work." Beyond music, Rihanna has made a significant impact in the fashion and beauty industries with her Fenty brand, known for its inclusivity and innovation. + + +```python +response = await agent.run( + "Tell me about few celebrities under category business and born after 1950. ", + ctx=ctx, +) +print(str(response)) +``` + + Here is a celebrity in the business category who was born after 1950: + + - **Elon Musk**: He is a prominent entrepreneur and business magnate, born in 1971. Musk is the CEO and lead designer of SpaceX, CEO and product architect of Tesla, Inc., and has been involved in numerous other ventures, including Neuralink and The Boring Company. He is known for his ambitious vision of the future, including space exploration and sustainable energy. + + +## Joint Text-to-SQL and Semantic Search + +This is currently handled by our `SQLAutoVectorQueryEngine`. + +Let's try implementing this by giving our `OpenAIAgent` access to two query tools: SQL and Vector + +**NOTE:** Any Text-to-SQL application should be aware that executing +arbitrary SQL queries can be a security risk. It is recommended to +take precautions as needed, such as using restricted roles, read-only +databases, sandboxing, etc. + +#### Load and Index Structured Data + +We load sample structured datapoints into a SQL db and index it. + + +```python +from sqlalchemy import ( + create_engine, + MetaData, + Table, + Column, + String, + Integer, + select, + column, +) +from llama_index.core import SQLDatabase +from llama_index.core.indices import SQLStructStoreIndex + +engine = create_engine("sqlite:///:memory:", future=True) +metadata_obj = MetaData() +``` + + +```python +# create city SQL table +table_name = "city_stats" +city_stats_table = Table( + table_name, + metadata_obj, + Column("city_name", String(16), primary_key=True), + Column("population", Integer), + Column("country", String(16), nullable=False), +) + +metadata_obj.create_all(engine) +``` + + +```python +# print tables +metadata_obj.tables.keys() +``` + + + + + dict_keys(['city_stats']) + + + + +```python +from sqlalchemy import insert + +rows = [ + {"city_name": "Toronto", "population": 2930000, "country": "Canada"}, + {"city_name": "Tokyo", "population": 13960000, "country": "Japan"}, + {"city_name": "Berlin", "population": 3645000, "country": "Germany"}, +] +for row in rows: + stmt = insert(city_stats_table).values(**row) + with engine.begin() as connection: + cursor = connection.execute(stmt) +``` + + +```python +with engine.connect() as connection: + cursor = connection.exec_driver_sql("SELECT * FROM city_stats") + print(cursor.fetchall()) +``` + + [('Toronto', 2930000, 'Canada'), ('Tokyo', 13960000, 'Japan'), ('Berlin', 3645000, 'Germany')] + + + +```python +sql_database = SQLDatabase(engine, include_tables=["city_stats"]) +``` + + +```python +from llama_index.core.query_engine import NLSQLTableQueryEngine + +query_engine = NLSQLTableQueryEngine( + sql_database=sql_database, + tables=["city_stats"], +) +``` + +#### Load and Index Unstructured Data + +We load unstructured data into a vector index backed by Pinecone + + +```python +# install wikipedia python package +%pip install wikipedia llama-index-readers-wikipedia +``` + + +```python +from llama_index.readers.wikipedia import WikipediaReader + +cities = ["Toronto", "Berlin", "Tokyo"] +wiki_docs = WikipediaReader().load_data(pages=cities) +``` + + +```python +from pinecone import Pinecone, ServerlessSpec + +pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"]) +``` + + +```python +# dimensions are for text-embedding-3-small +pc.create_index( + name="quickstart-sql", + dimension=1536, + metric="euclidean", + spec=ServerlessSpec(cloud="aws", region="us-east-1"), +) + +# may need to wait for index to be created +import time + +time.sleep(10) +``` + + +```python +# define pinecone index +index = pc.Index("quickstart-sql") +``` + + +```python +# OPTIONAL: delete all +index.delete(deleteAll=True) +``` + + +```python +from llama_index.core import VectorStoreIndex, StorageContext +from llama_index.vector_stores.pinecone import PineconeVectorStore +from llama_index.core.node_parser import TokenTextSplitter +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding + +# define node parser and LLM +Settings.llm = OpenAI(temperature=0, model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +Settings.node_parser = TokenTextSplitter(chunk_size=1024) + +# define pinecone vector index +vector_store = PineconeVectorStore( + pinecone_index=index, namespace="wiki_cities" +) +storage_context = StorageContext.from_defaults(vector_store=vector_store) +vector_index = VectorStoreIndex([], storage_context=storage_context) +``` + + +```python +# Insert documents into vector index +# Each document has metadata of the city attached +for city, wiki_doc in zip(cities, wiki_docs): + nodes = Settings.node_parser.get_nodes_from_documents([wiki_doc]) + # add metadata to each node + for node in nodes: + node.metadata = {"title": city} + vector_index.insert_nodes(nodes) +``` + +#### Define Query Engines / Tools + + +```python +from llama_index.core.retrievers import VectorIndexAutoRetriever +from llama_index.core.vector_stores import MetadataInfo, VectorStoreInfo +from llama_index.core.query_engine import RetrieverQueryEngine +from llama_index.core.tools import QueryEngineTool + + +vector_store_info = VectorStoreInfo( + content_info="articles about different cities", + metadata_info=[ + MetadataInfo( + name="title", type="str", description="The name of the city" + ), + ], +) + +# pre-built auto-retriever, this works similarly to our custom auto-retriever above +vector_auto_retriever = VectorIndexAutoRetriever( + vector_index, vector_store_info=vector_store_info +) + +retriever_query_engine = RetrieverQueryEngine.from_args( + vector_auto_retriever, +) +``` + + +```python +sql_tool = QueryEngineTool.from_defaults( + query_engine=query_engine, + name="sql_tool", + description=( + "Useful for translating a natural language query into a SQL query over" + " a table containing: city_stats, containing the population/country of" + " each city" + ), +) +vector_tool = QueryEngineTool.from_defaults( + query_engine=retriever_query_engine, + name="vector_tool", + description=( + "Useful for answering semantic questions about different cities" + ), +) +``` + +#### Initialize Agent + + +```python +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.llms.openai import OpenAI +from llama_index.core.workflow import Context + +agent = FunctionAgent( + tools=[sql_tool, vector_tool], + llm=OpenAI(model="gpt-4o"), +) + +# hold the context/session state for the agent +ctx = Context(agent) +``` + + +```python +from llama_index.core.agent.workflow import ( + ToolCallResult, + ToolCall, + AgentStream, + AgentInput, + AgentOutput, +) + +handler = agent.run( + "Tell me about the arts and culture of the city with the highest population. ", + ctx=ctx, +) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool sql_tool with args {'input': 'SELECT city FROM city_stats ORDER BY population DESC LIMIT 1;'}, got response: The city with the highest population is Tokyo. + + Called tool vector_tool with args {'input': 'Tell me about the arts and culture of Tokyo.'}, got response: Tokyo boasts a vibrant arts and culture scene, characterized by a diverse range of museums, galleries, and performance venues. Ueno Park is a cultural hub, housing the Tokyo National Museum, which specializes in traditional Japanese art, alongside the National Museum of Western Art, a UNESCO World Heritage site, and the National Museum of Nature and Science. The park also features Ueno Zoo, known for its giant pandas. + + The city is home to numerous notable museums, including the Artizon Museum, the National Museum of Emerging Science and Innovation, and the Edo-Tokyo Museum, which explores the city's history. Contemporary art is showcased at the Mori Art Museum and the Sumida Hokusai Museum, while the Sompo Museum of Art is recognized for its collection, including Van Gogh's "Sunflowers." + + The performing arts thrive in Tokyo, with venues like the National Noh Theatre and Kabuki-za dedicated to traditional Japanese theatre. The New National Theatre Tokyo hosts a variety of performances, including opera and ballet. Major concert venues such as the Nippon Budokan and Tokyo Dome frequently feature popular music acts. + + Tokyo's nightlife is vibrant, particularly in districts like Shibuya and Roppongi, which are filled with bars, clubs, and live music venues. The city is also known for its festivals, such as the Sannō Matsuri and the Sanja Festival, which celebrate traditional culture. + + Shopping districts like Ginza and Nihombashi offer a blend of high-end retail and cultural experiences, while areas like Jinbōchō are famous for their literary connections, featuring bookstores and cafes linked to renowned authors. Overall, Tokyo's arts and culture reflect a rich tapestry of traditional and contemporary influences, making it a dynamic city for cultural exploration. + Tokyo, the city with the highest population, boasts a vibrant arts and culture scene. It features a diverse range of museums, galleries, and performance venues. Ueno Park serves as a cultural hub, housing the Tokyo National Museum, the National Museum of Western Art, and the National Museum of Nature and Science. The park also includes Ueno Zoo, known for its giant pandas. + + Notable museums in Tokyo include the Artizon Museum, the National Museum of Emerging Science and Innovation, and the Edo-Tokyo Museum, which explores the city's history. Contemporary art is showcased at the Mori Art Museum and the Sumida Hokusai Museum, while the Sompo Museum of Art is recognized for its collection, including Van Gogh's "Sunflowers." + + The performing arts thrive with venues like the National Noh Theatre and Kabuki-za dedicated to traditional Japanese theatre. The New National Theatre Tokyo hosts a variety of performances, including opera and ballet. Major concert venues such as the Nippon Budokan and Tokyo Dome frequently feature popular music acts. + + Tokyo's nightlife is vibrant, especially in districts like Shibuya and Roppongi, filled with bars, clubs, and live music venues. The city is also known for its festivals, such as the Sannō Matsuri and the Sanja Festival, celebrating traditional culture. + + Shopping districts like Ginza and Nihombashi offer a blend of high-end retail and cultural experiences, while areas like Jinbōchō are famous for their literary connections, featuring bookstores and cafes linked to renowned authors. Overall, Tokyo's arts and culture reflect a rich tapestry of traditional and contemporary influences, making it a dynamic city for cultural exploration. + + +```python +handler = agent.run("Tell me about the history of Berlin", ctx=ctx) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"\nCalled tool {ev.tool_name} with args {ev.tool_kwargs}, got response: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + + Called tool vector_tool with args {'input': 'Tell me about the history of Berlin.'}, got response: Berlin's history dates back to prehistoric times, with evidence of human settlements as early as 60,000 BC. The area saw the emergence of various cultures, including the Maglemosian culture around 9,000 BC and the Lusatian culture around 2,000 BC, as dense human settlements developed along the Spree and Havel rivers. By 500 BC, Germanic tribes began to settle in the region, followed by Slavic tribes in the 7th century. + + In the 12th century, the region came under German rule with the establishment of the Margraviate of Brandenburg. The first written records of towns in the area appear in the late 12th century, with Berlin's founding date considered to be 1237. The towns of Berlin and Cölln formed close economic ties and eventually merged, with the Hohenzollern family ruling the area from the 14th century until 1918. + + The Thirty Years' War in the 17th century devastated Berlin, leading to significant population loss. However, under Frederick William, known as the "Great Elector," the city experienced a revival through policies promoting immigration and religious tolerance. The establishment of the Kingdom of Prussia in 1701 marked a significant turning point, with Berlin becoming its capital. + + The 19th century brought the Industrial Revolution, transforming Berlin into a major economic center and leading to rapid population growth. By the late 19th century, Berlin was the capital of the newly founded German Empire. The city continued to grow and evolve through the 20th century, experiencing significant events such as World War II, the division into East and West Berlin during the Cold War, and reunification in 1990, when it once again became the capital of a unified Germany. + + Today, Berlin is recognized as a global city of culture, politics, media, and science, with a diverse economy and rich historical heritage. + Berlin's history is rich and varied, dating back to prehistoric times with evidence of human settlements as early as 60,000 BC. The area saw the emergence of various cultures, including the Maglemosian culture around 9,000 BC and the Lusatian culture around 2,000 BC, with dense settlements along the Spree and Havel rivers. By 500 BC, Germanic tribes settled in the region, followed by Slavic tribes in the 7th century. + + In the 12th century, the region came under German rule with the establishment of the Margraviate of Brandenburg. Berlin's founding date is considered to be 1237, with the towns of Berlin and Cölln forming close economic ties and eventually merging. The Hohenzollern family ruled the area from the 14th century until 1918. + + The Thirty Years' War in the 17th century devastated Berlin, but it experienced a revival under Frederick William, the "Great Elector," through policies promoting immigration and religious tolerance. The establishment of the Kingdom of Prussia in 1701 marked a significant turning point, with Berlin becoming its capital. + + The 19th century brought the Industrial Revolution, transforming Berlin into a major economic center and leading to rapid population growth. By the late 19th century, Berlin was the capital of the newly founded German Empire. The city continued to evolve through the 20th century, experiencing significant events such as World War II, the division into East and West Berlin during the Cold War, and reunification in 1990, when it once again became the capital of a unified Germany. + + Today, Berlin is recognized as a global city of culture, politics, media, and science, with a diverse economy and rich historical heritage. + + +```python +response = await agent.run( + "Can you give me the country corresponding to each city?", ctx=ctx +) + +print(str(response)) +``` + + Here are the cities along with their corresponding countries: + + - Toronto is in Canada. + - Tokyo is in Japan. + - Berlin is in Germany. + diff --git a/markdowns/Agent/openai_agent_retrieval.md b/markdowns/Agent/openai_agent_retrieval.md new file mode 100644 index 0000000..cfb4713 --- /dev/null +++ b/markdowns/Agent/openai_agent_retrieval.md @@ -0,0 +1,170 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_retrieval.ipynb +toc: True +title: "Retrieval-Augmented Agents" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +In this tutorial, we show you how to use our `FunctionAgent` or `ReActAgent` implementation with a tool retriever, +to augment any existing agent and store/index an arbitrary number of tools. + +Our indexing/retrieval modules help to remove the complexity of having too many functions to fit in the prompt. + +## Initial Setup + +Let's start by importing some simple building blocks. + +The main thing we need is: +1. the OpenAI API +2. a place to keep conversation history +3. a definition for tools that our agent can use. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + +Let's define some very simple calculator tools for our agent. + + +```python +from llama_index.core.tools import FunctionTool + + +def multiply(a: int, b: int) -> int: + """Multiply two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b + + +def useless(a: int, b: int) -> int: + """Toy useless function.""" + pass + + +multiply_tool = FunctionTool.from_defaults(multiply, name="multiply") +add_tool = FunctionTool.from_defaults(add, name="add") + +# toy-example of many tools +useless_tools = [ + FunctionTool.from_defaults(useless, name=f"useless_{str(idx)}") + for idx in range(28) +] + +all_tools = [multiply_tool] + [add_tool] + useless_tools + +all_tools_map = {t.metadata.name: t for t in all_tools} +``` + +## Building an Object Index + +We have an `ObjectIndex` construct in LlamaIndex that allows the user to use our index data structures over arbitrary objects. +The ObjectIndex will handle serialiation to/from the object, and use an underying index (e.g. VectorStoreIndex, SummaryIndex, KeywordTableIndex) as the storage mechanism. + +In this case, we have a large collection of Tool objects, and we'd want to define an ObjectIndex over these Tools. + +The index comes bundled with a retrieval mechanism, an `ObjectRetriever`. + +This can be passed in to our agent so that it can +perform Tool retrieval during query-time. + + +```python +# define an "object" index over these tools +from llama_index.core import VectorStoreIndex +from llama_index.core.objects import ObjectIndex + +obj_index = ObjectIndex.from_objects( + all_tools, + index_cls=VectorStoreIndex, + # if we were using an external vector store, we could pass the stroage context and any other kwargs + # storage_context=storage_context, + # embed_model=embed_model, + # ... +) +``` + +To reload the index later, we can use the `from_objects_and_index` method. + + +```python +# from llama_index.core import StorageContext, load_index_from_storage + +# saving and loading from disk +# obj_index.index.storage_context.persist(persist_dir="obj_index_storage") + +# reloading from disk +# vector_index = load_index_from_storage(StorageContext.from_defaults(persist_dir="obj_index_storage")) + +# or if using an external vector store, no need to persist, just reload the index +# vector_index = VectorStoreIndex.from_vector_store(vector_store=vector_store, ...) + +# Then, we can reload the ObjectIndex +# obj_index = ObjectIndex.from_objects_and_index( +# all_tools, +# index=vector_index, +# ) +``` + +## Agent w/ Tool Retrieval + +Agents in LlamaIndex can be used with a `ToolRetriever` to retrieve tools during query-time. + +During query-time, we would first use the `ObjectRetriever` to retrieve a set of relevant Tools. These tools would then be passed into the agent; more specifically, their function signatures would be passed into the OpenAI Function calling API. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent +from llama_index.core.workflow import Context +from llama_index.llms.openai import OpenAI + +agent = FunctionAgent( + tool_retriever=obj_index.as_retriever(similarity_top_k=2), + llm=OpenAI(model="gpt-4o"), +) + +# context to hold the session/state +ctx = Context(agent) +``` + + +```python +resp = await agent.run( + "What's 212 multiplied by 122? Make sure to use Tools", ctx=ctx +) +print(str(resp)) +print(resp.tool_calls) +``` + + The result of multiplying 212 by 122 is 25,864. + [ToolCallResult(tool_name='multiply', tool_kwargs={'a': 212, 'b': 122}, tool_id='call_4Ygos3MpRH7Gj3R79HISRGyH', tool_output=ToolOutput(content='25864', tool_name='multiply', raw_input={'args': (), 'kwargs': {'a': 212, 'b': 122}}, raw_output=25864, is_error=False), return_direct=False)] + + + +```python +resp = await agent.run( + "What's 212 added to 122 ? Make sure to use Tools", ctx=ctx +) +print(str(resp)) +print(resp.tool_calls) +``` + + The result of adding 212 to 122 is 334. + [ToolCallResult(tool_name='add', tool_kwargs={'a': 212, 'b': 122}, tool_id='call_rXUfwQ477bcd6bxafQHgETaa', tool_output=ToolOutput(content='334', tool_name='add', raw_input={'args': (), 'kwargs': {'a': 212, 'b': 122}}, raw_output=334, is_error=False), return_direct=False)] + diff --git a/markdowns/Agent/openai_agent_with_query_engine.md b/markdowns/Agent/openai_agent_with_query_engine.md new file mode 100644 index 0000000..789cd84 --- /dev/null +++ b/markdowns/Agent/openai_agent_with_query_engine.md @@ -0,0 +1,158 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/openai_agent_with_query_engine.ipynb +toc: True +title: "Agent with Query Engine Tools" +featured: False +experimental: False +tags: ['Agent', 'Integrations'] +language: py +--- +## Build Query Engine Tools + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +from llama_index.core import StorageContext, load_index_from_storage + +try: + storage_context = StorageContext.from_defaults( + persist_dir="./storage/lyft" + ) + lyft_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/uber" + ) + uber_index = load_index_from_storage(storage_context) + + index_loaded = True +except: + index_loaded = False +``` + +Download Data + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/lyft_2021.pdf' -O 'data/10k/lyft_2021.pdf' +``` + + +```python +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex + +if not index_loaded: + # load data + lyft_docs = SimpleDirectoryReader( + input_files=["./data/10k/lyft_2021.pdf"] + ).load_data() + uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] + ).load_data() + + # build index + lyft_index = VectorStoreIndex.from_documents(lyft_docs) + uber_index = VectorStoreIndex.from_documents(uber_docs) + + # persist index + lyft_index.storage_context.persist(persist_dir="./storage/lyft") + uber_index.storage_context.persist(persist_dir="./storage/uber") +``` + + +```python +lyft_engine = lyft_index.as_query_engine(similarity_top_k=3) +uber_engine = uber_index.as_query_engine(similarity_top_k=3) +``` + + +```python +from llama_index.core.tools import QueryEngineTool + +query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=lyft_engine, + name="lyft_10k", + description=( + "Provides information about Lyft financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), +] +``` + +## Setup Agent + +For LLMs like OpenAI that have a function calling API, we should use the `FunctionAgent`. + +For other LLMs, we can use the `ReActAgent`. + + +```python +from llama_index.core.agent.workflow import FunctionAgent, ReActAgent +from llama_index.core.workflow import Context + +agent = FunctionAgent(tools=query_engine_tools, llm=OpenAI(model="gpt-4o")) + +# context to hold the session/state +ctx = Context(agent) +``` + +## Let's Try It Out! + + +```python +from llama_index.core.agent.workflow import ToolCallResult, AgentStream + +handler = agent.run("What's the revenue for Lyft in 2021 vs Uber?", ctx=ctx) + +async for ev in handler.stream_events(): + if isinstance(ev, ToolCallResult): + print( + f"Call {ev.tool_name} with args {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + elif isinstance(ev, AgentStream): + print(ev.delta, end="", flush=True) + +response = await handler +``` + + Call lyft_10k with args {'input': "What was Lyft's revenue for the year 2021?"} + Returned: Lyft's revenue for the year 2021 was $3,208,323,000. + Call uber_10k with args {'input': "What was Uber's revenue for the year 2021?"} + Returned: Uber's revenue for the year 2021 was $17.455 billion. + In 2021, Lyft's revenue was approximately $3.21 billion, while Uber's revenue was significantly higher at $17.455 billion. diff --git a/markdowns/Agent/react_agent.md b/markdowns/Agent/react_agent.md new file mode 100644 index 0000000..827954c --- /dev/null +++ b/markdowns/Agent/react_agent.md @@ -0,0 +1,282 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/react_agent.ipynb +toc: True +title: "ReActAgent - A Simple Intro with Calculator Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +This is a notebook that showcases the ReAct agent over very simple calculator tools (no fancy RAG pipelines or API calls). + +We show how it can reason step-by-step over different tools to achieve the end goal. + +The main advantage of the ReAct agent over a Function Calling agent is that it can work with any LLM regardless of whether it supports function calling. + +If you're opening this Notebook on colab, you will probably need to install LlamaIndex 🦙. + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + +## Define Function Tools + +We setup some trivial `multiply` and `add` tools. Note that you can define arbitrary functions and pass it to the `FunctionTool` (which will process the docstring and parameter signature). + + +```python +def multiply(a: int, b: int) -> int: + """Multiply two integers and returns the result integer""" + return a * b + + +def add(a: int, b: int) -> int: + """Add two integers and returns the result integer""" + return a + b +``` + +## Run Some Queries + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.core.agent.workflow import ReActAgent +from llama_index.core.workflow import Context + +llm = OpenAI(model="gpt-4o-mini") +agent = ReActAgent(tools=[multiply, add], llm=llm) + +# Create a context to store the conversation history/session state +ctx = Context(agent) +``` + +## Run Some Example Queries + +By streaming the result, we can see the full response, including the thought process and tool calls. + +If we wanted to stream only the result, we can buffer the stream and start streaming once `Answer:` is in the response. + + + +```python +from llama_index.core.agent.workflow import AgentStream, ToolCallResult + +handler = agent.run("What is 20+(2*4)?", ctx=ctx) + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to help me answer the question. + Action: multiply + Action Input: {"a": 2, "b": 4}Thought: Now I have the result of the multiplication, which is 8. I will add this to 20 to complete the calculation. + Action: add + Action Input: {'a': 20, 'b': 8}Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: The result of 20 + (2 * 4) is 28. + + +```python +print(str(response)) +``` + + The result of 20 + (2 * 4) is 28. + + + +```python +print(response.tool_calls) +``` + + [ToolCallResult(tool_name='multiply', tool_kwargs={'a': 2, 'b': 4}, tool_id='a394d807-a9b7-42e0-8bff-f47a432d1530', tool_output=ToolOutput(content='8', tool_name='multiply', raw_input={'args': (), 'kwargs': {'a': 2, 'b': 4}}, raw_output=8, is_error=False), return_direct=False), ToolCallResult(tool_name='add', tool_kwargs={'a': 20, 'b': 8}, tool_id='784ccd85-ae9a-4184-9613-3696742064c7', tool_output=ToolOutput(content='28', tool_name='add', raw_input={'args': (), 'kwargs': {'a': 20, 'b': 8}}, raw_output=28, is_error=False), return_direct=False)] + + +## View Prompts + +Let's take a look at the core system prompt powering the ReAct agent! + +Within the agent, the current conversation history is dumped below this line. + + +```python +prompt_dict = agent.get_prompts() +for k, v in prompt_dict.items(): + print(f"Prompt: {k}\n\nValue: {v.template}") +``` + + Prompt: react_header + + Value: You are designed to help with a variety of tasks, from answering questions to providing summaries to other types of analyses. + + ## Tools + + You have access to a wide variety of tools. You are responsible for using the tools in any sequence you deem appropriate to complete the task at hand. + This may require breaking the task into subtasks and using different tools to complete each subtask. + + You have access to the following tools: + {tool_desc} + + + ## Output Format + + Please answer in the same language as the question and use the following format: + + ``` + Thought: The current language of the user is: (user's language). I need to use a tool to help me answer the question. + Action: tool name (one of {tool_names}) if using a tool. + Action Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}}) + ``` + + Please ALWAYS start with a Thought. + + NEVER surround your response with markdown code markers. You may use code markers within your response if you need to. + + Please use a valid JSON format for the Action Input. Do NOT do this {{'input': 'hello world', 'num_beams': 5}}. + + If this format is used, the tool will respond in the following format: + + ``` + Observation: tool response + ``` + + You should keep repeating the above format till you have enough information to answer the question without using any more tools. At that point, you MUST respond in one of the following two formats: + + ``` + Thought: I can answer without using any more tools. I'll use the user's language to answer + Answer: [your answer here (In the same language as the user's question)] + ``` + + ``` + Thought: I cannot answer the question with the provided tools. + Answer: [your answer here (In the same language as the user's question)] + ``` + + ## Current Conversation + + Below is the current conversation consisting of interleaving human and assistant messages. + + + +### Customizing the Prompt + +For fun, let's try instructing the agent to output the answer along with reasoning in bullet points. See "## Additional Rules" section. + + +```python +from llama_index.core import PromptTemplate + +react_system_header_str = """\ + +You are designed to help with a variety of tasks, from answering questions \ + to providing summaries to other types of analyses. + +## Tools +You have access to a wide variety of tools. You are responsible for using +the tools in any sequence you deem appropriate to complete the task at hand. +This may require breaking the task into subtasks and using different tools +to complete each subtask. + +You have access to the following tools: +{tool_desc} + +## Output Format +To answer the question, please use the following format. + +``` +Thought: I need to use a tool to help me answer the question. +Action: tool name (one of {tool_names}) if using a tool. +Action Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}}) +``` + +Please ALWAYS start with a Thought. + +Please use a valid JSON format for the Action Input. Do NOT do this {{'input': 'hello world', 'num_beams': 5}}. + +If this format is used, the user will respond in the following format: + +``` +Observation: tool response +``` + +You should keep repeating the above format until you have enough information +to answer the question without using any more tools. At that point, you MUST respond +in the one of the following two formats: + +``` +Thought: I can answer without using any more tools. +Answer: [your answer here] +``` + +``` +Thought: I cannot answer the question with the provided tools. +Answer: Sorry, I cannot answer your query. +``` + +## Additional Rules +- The answer MUST contain a sequence of bullet points that explain how you arrived at the answer. This can include aspects of the previous conversation history. +- You MUST obey the function signature of each tool. Do NOT pass in no arguments if the function expects arguments. + +## Current Conversation +Below is the current conversation consisting of interleaving human and assistant messages. + +""" +react_system_prompt = PromptTemplate(react_system_header_str) +``` + + +```python +agent.get_prompts() +``` + + + + + {'react_header': PromptTemplate(metadata={'prompt_type': }, template_vars=['tool_desc', 'tool_names'], kwargs={}, output_parser=None, template_var_mappings=None, function_mappings=None, template='You are designed to help with a variety of tasks, from answering questions to providing summaries to other types of analyses.\n\n## Tools\n\nYou have access to a wide variety of tools. You are responsible for using the tools in any sequence you deem appropriate to complete the task at hand.\nThis may require breaking the task into subtasks and using different tools to complete each subtask.\n\nYou have access to the following tools:\n{tool_desc}\n\n\n## Output Format\n\nPlease answer in the same language as the question and use the following format:\n\n```\nThought: The current language of the user is: (user\'s language). I need to use a tool to help me answer the question.\nAction: tool name (one of {tool_names}) if using a tool.\nAction Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{"input": "hello world", "num_beams": 5}})\n```\n\nPlease ALWAYS start with a Thought.\n\nNEVER surround your response with markdown code markers. You may use code markers within your response if you need to.\n\nPlease use a valid JSON format for the Action Input. Do NOT do this {{\'input\': \'hello world\', \'num_beams\': 5}}.\n\nIf this format is used, the tool will respond in the following format:\n\n```\nObservation: tool response\n```\n\nYou should keep repeating the above format till you have enough information to answer the question without using any more tools. At that point, you MUST respond in one of the following two formats:\n\n```\nThought: I can answer without using any more tools. I\'ll use the user\'s language to answer\nAnswer: [your answer here (In the same language as the user\'s question)]\n```\n\n```\nThought: I cannot answer the question with the provided tools.\nAnswer: [your answer here (In the same language as the user\'s question)]\n```\n\n## Current Conversation\n\nBelow is the current conversation consisting of interleaving human and assistant messages.\n')} + + + + +```python +agent.update_prompts({"react_header": react_system_prompt}) +``` + + +```python +handler = agent.run("What is 5+3+2") + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to help me answer the question. + Action: add + Action Input: {"a": 5, "b": 3}Thought: I need to add the result (8) to the remaining number (2). + Action: add + Action Input: {'a': 8, 'b': 2}Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: The result of 5 + 3 + 2 is 10. + + +```python +print(response) +``` + + The result of 5 + 3 + 2 is 10. + diff --git a/markdowns/Agent/react_agent_with_query_engine.md b/markdowns/Agent/react_agent_with_query_engine.md new file mode 100644 index 0000000..190802e --- /dev/null +++ b/markdowns/Agent/react_agent_with_query_engine.md @@ -0,0 +1,215 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/react_agent_with_query_engine.ipynb +toc: True +title: "ReAct Agent with Query Engine (RAG) Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +In this section, we show how to setup an agent powered by the ReAct loop for financial analysis. + +The agent has access to two "tools": one to query the 2021 Lyft 10-K and the other to query the 2021 Uber 10-K. + +Note that you can plug in any LLM to use as a ReAct agent. + +## Build Query Engine Tools + + +```python +%pip install llama-index +``` + + +```python +import os + +os.environ["OPENAI_API_KEY"] = "sk-..." +``` + + +```python +from llama_index.llms.openai import OpenAI +from llama_index.embeddings.openai import OpenAIEmbedding +from llama_index.core import Settings + +Settings.llm = OpenAI(model="gpt-4o-mini") +Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") +``` + + +```python +from llama_index.core import StorageContext, load_index_from_storage + +try: + storage_context = StorageContext.from_defaults( + persist_dir="./storage/lyft" + ) + lyft_index = load_index_from_storage(storage_context) + + storage_context = StorageContext.from_defaults( + persist_dir="./storage/uber" + ) + uber_index = load_index_from_storage(storage_context) + + index_loaded = True +except: + index_loaded = False +``` + +Download Data + + +```python +!mkdir -p 'data/10k/' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf' +!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/lyft_2021.pdf' -O 'data/10k/lyft_2021.pdf' +``` + + +```python +from llama_index.core import SimpleDirectoryReader, VectorStoreIndex + +if not index_loaded: + # load data + lyft_docs = SimpleDirectoryReader( + input_files=["./data/10k/lyft_2021.pdf"] + ).load_data() + uber_docs = SimpleDirectoryReader( + input_files=["./data/10k/uber_2021.pdf"] + ).load_data() + + # build index + lyft_index = VectorStoreIndex.from_documents(lyft_docs) + uber_index = VectorStoreIndex.from_documents(uber_docs) + + # persist index + lyft_index.storage_context.persist(persist_dir="./storage/lyft") + uber_index.storage_context.persist(persist_dir="./storage/uber") +``` + + +```python +lyft_engine = lyft_index.as_query_engine(similarity_top_k=3) +uber_engine = uber_index.as_query_engine(similarity_top_k=3) +``` + + +```python +from llama_index.core.tools import QueryEngineTool + +query_engine_tools = [ + QueryEngineTool.from_defaults( + query_engine=lyft_engine, + name="lyft_10k", + description=( + "Provides information about Lyft financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), + QueryEngineTool.from_defaults( + query_engine=uber_engine, + name="uber_10k", + description=( + "Provides information about Uber financials for year 2021. " + "Use a detailed plain text question as input to the tool." + ), + ), +] +``` + +## Setup ReAct Agent + +Here we setup our ReAct agent with the tools we created above. + +You can **optionally** specify a system prompt which will be added to the core ReAct system prompt. + + +```python +from llama_index.core.agent.workflow import ReActAgent +from llama_index.core.workflow import Context + +agent = ReActAgent( + tools=query_engine_tools, + llm=OpenAI(model="gpt-4o-mini"), + # system_prompt="..." +) + +# context to hold this session/state + +ctx = Context(agent) +``` + +## Run Some Example Queries + +By streaming the result, we can see the full response, including the thought process and tool calls. + +If we wanted to stream only the result, we can buffer the stream and start streaming once `Answer:` is in the response. + + + +```python +from llama_index.core.agent.workflow import ToolCallResult, AgentStream + +handler = agent.run("What was Lyft's revenue growth in 2021?", ctx=ctx) + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to help me answer the question. + Action: lyft_10k + Action Input: {"input": "What was Lyft's revenue growth in 2021?"}Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: Lyft's revenue growth in 2021 was 36% compared to the prior year. + + +```python +print(str(response)) +``` + + Lyft's revenue growth in 2021 was 36% compared to the prior year. + + + +```python +handler = agent.run( + "Compare and contrast the revenue growth of Uber and Lyft in 2021, then give an analysis", + ctx=ctx, +) + +async for ev in handler.stream_events(): + # if isinstance(ev, ToolCallResult): + # print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}") + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + +response = await handler +``` + + Thought: The current language of the user is: English. I need to use a tool to gather information about Uber's revenue growth in 2021 to compare it with Lyft's. + Action: uber_10k + Action Input: {'input': "What was Uber's revenue growth in 2021?"}Thought: I now have the revenue growth information for both Uber and Lyft in 2021. Lyft's revenue growth was 36%, while Uber's was 57%. I will now provide a comparison and analysis. + Thought: I can answer without using any more tools. I'll use the user's language to answer. + Answer: In 2021, Uber experienced a revenue growth of 57%, increasing from $11.139 billion in 2020 to $17.455 billion. In contrast, Lyft's revenue growth was 36%. + + When comparing the two, Uber outperformed Lyft in terms of revenue growth, indicating a stronger recovery or expansion in its business operations during that year. This could be attributed to Uber's diversified services, including food delivery through Uber Eats, which may have contributed significantly to its revenue. Lyft, primarily focused on ride-sharing, may have faced more challenges in scaling its growth compared to Uber. + + Overall, while both companies showed positive growth, Uber's higher percentage suggests it was able to capitalize on market opportunities more effectively than Lyft in 2021. + + +```python +print(str(response)) +``` + + In 2021, Uber experienced a revenue growth of 57%, increasing from $11.139 billion in 2020 to $17.455 billion. In contrast, Lyft's revenue growth was 36%. + + When comparing the two, Uber outperformed Lyft in terms of revenue growth, indicating a stronger recovery or expansion in its business operations during that year. This could be attributed to Uber's diversified services, including food delivery through Uber Eats, which may have contributed significantly to its revenue. Lyft, primarily focused on ride-sharing, may have faced more challenges in scaling its growth compared to Uber. + + Overall, while both companies showed positive growth, Uber's higher percentage suggests it was able to capitalize on market opportunities more effectively than Lyft in 2021. + diff --git a/markdowns/Agent/return_direct_agent.md b/markdowns/Agent/return_direct_agent.md new file mode 100644 index 0000000..da8d799 --- /dev/null +++ b/markdowns/Agent/return_direct_agent.md @@ -0,0 +1,250 @@ +--- +layout: recipe +colab: https://colab.research.google.com/github/run-llama/cookbooks-demo/blob/main/notebooks/agent/return_direct_agent.ipynb +toc: True +title: "Controlling Agent Reasoning Loop with Return Direct Tools" +featured: False +experimental: False +tags: ['Agent'] +language: py +--- +All tools have an option for `return_direct` -- if this is set to `True`, and the associated tool is called (without any other tools being called), the agent reasoning loop is ended and the tool output is returned directly. + +This can be useful for speeding up response times when you know the tool output is good enough, to avoid the agent re-writing the response, and for ending the reasoning loop. + +This notebook walks through a notebook where an agent needs to gather information from a user in order to make a restaurant booking. + + +```python +%pip install llama-index-core llama-index-llms-anthropic +``` + + +```python +import os + +os.environ["ANTHROPIC_API_KEY"] = "sk-..." +``` + +## Tools setup + + +```python +from typing import Optional + +from llama_index.core.tools import FunctionTool +from pydantic import BaseModel + +# we will store booking under random IDs +bookings = {} + + +# we will represent and track the state of a booking as a Pydantic model +class Booking(BaseModel): + name: Optional[str] = None + email: Optional[str] = None + phone: Optional[str] = None + date: Optional[str] = None + time: Optional[str] = None + + +def get_booking_state(user_id: str) -> str: + """Get the current state of a booking for a given booking ID.""" + try: + return str(bookings[user_id].dict()) + except: + return f"Booking ID {user_id} not found" + + +def update_booking(user_id: str, property: str, value: str) -> str: + """Update a property of a booking for a given booking ID. Only enter details that are explicitly provided.""" + booking = bookings[user_id] + setattr(booking, property, value) + return f"Booking ID {user_id} updated with {property} = {value}" + + +def create_booking(user_id: str) -> str: + """Create a new booking and return the booking ID.""" + bookings[user_id] = Booking() + return "Booking created, but not yet confirmed. Please provide your name, email, phone, date, and time." + + +def confirm_booking(user_id: str) -> str: + """Confirm a booking for a given booking ID.""" + booking = bookings[user_id] + + if booking.name is None: + raise ValueError("Please provide your name.") + + if booking.email is None: + raise ValueError("Please provide your email.") + + if booking.phone is None: + raise ValueError("Please provide your phone number.") + + if booking.date is None: + raise ValueError("Please provide the date of your booking.") + + if booking.time is None: + raise ValueError("Please provide the time of your booking.") + + return f"Booking ID {user_id} confirmed!" + + +# create tools for each function +get_booking_state_tool = FunctionTool.from_defaults(fn=get_booking_state) +update_booking_tool = FunctionTool.from_defaults(fn=update_booking) +create_booking_tool = FunctionTool.from_defaults( + fn=create_booking, return_direct=True +) +confirm_booking_tool = FunctionTool.from_defaults( + fn=confirm_booking, return_direct=True +) +``` + +## A user has walked in! Let's help them make a booking + + +```python +from llama_index.llms.anthropic import Anthropic +from llama_index.core.llms import ChatMessage +from llama_index.core.agent.workflow import FunctionAgent +from llama_index.core.workflow import Context + +llm = Anthropic(model="claude-3-sonnet-20240229", temperature=0.1) + +user = "user123" +system_prompt = f"""You are now connected to the booking system and helping {user} with making a booking. +Only enter details that the user has explicitly provided. +Do not make up any details. +""" + +agent = FunctionAgent( + tools=[ + get_booking_state_tool, + update_booking_tool, + create_booking_tool, + confirm_booking_tool, + ], + llm=llm, + system_prompt=system_prompt, +) + +# create a context for the agent to hold the state/history of a session +ctx = Context(agent) +``` + + +```python +from llama_index.core.agent.workflow import AgentStream, ToolCallResult + +handler = agent.run( + "Hello! I would like to make a booking, around 5pm?", ctx=ctx +) + +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + elif isinstance(ev, ToolCallResult): + print( + f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + +response = await handler +``` + + Okay, let's create a new booking for you.{"user_id": "user123"} + Call create_booking with {'user_id': 'user123'} + Returned: Booking created, but not yet confirmed. Please provide your name, email, phone, date, and time. + + + +```python +print(str(response)) +``` + + Booking created, but not yet confirmed. Please provide your name, email, phone, date, and time. + + +Perfect, we can see the function output was retruned directly, with no modification or final LLM call! + + +```python +handler = agent.run( + "Sure! My name is Logan, and my email is test@gmail.com?", ctx=ctx +) + +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + elif isinstance(ev, ToolCallResult): + print( + f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + +response = await handler +``` + + Got it, thanks for providing your name and email. I've updated the booking with that information.{"user_id": "user123", "property": "name", "value": "Logan"}{"user_id": "user123", "property": "email", "value": "test@gmail.com"} + Call update_booking with {'user_id': 'user123', 'property': 'name', 'value': 'Logan'} + Returned: Booking ID user123 updated with name = Logan + + Call update_booking with {'user_id': 'user123', 'property': 'email', 'value': 'test@gmail.com'} + Returned: Booking ID user123 updated with email = test@gmail.com + Please also provide your phone number, preferred date, and time for the booking. + + +```python +print(str(response)) +``` + + Please also provide your phone number, preferred date, and time for the booking. + + + +```python +handler = agent.run( + "Right! My phone number is 1234567890, the date of the booking is April 5, at 5pm.", + ctx=ctx, +) + +async for ev in handler.stream_events(): + if isinstance(ev, AgentStream): + print(f"{ev.delta}", end="", flush=True) + elif isinstance(ev, ToolCallResult): + print( + f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}" + ) + +response = await handler +``` + + Great, thank you for providing the additional details. I've updated the booking with your phone number, date, and time.{"user_id": "user123", "property": "phone", "value": "1234567890"}{"user_id": "user123", "property": "date", "value": "2023-04-05"}{"user_id": "user123", "property": "time", "value": "17:00"} + Call update_booking with {'user_id': 'user123', 'property': 'phone', 'value': '1234567890'} + Returned: Booking ID user123 updated with phone = 1234567890 + + Call update_booking with {'user_id': 'user123', 'property': 'date', 'value': '2023-04-05'} + Returned: Booking ID user123 updated with date = 2023-04-05 + + Call update_booking with {'user_id': 'user123', 'property': 'time', 'value': '17:00'} + Returned: Booking ID user123 updated with time = 17:00 + Looks like I have all the necessary details. Let me confirm this booking for you.{"user_id": "user123"} + Call confirm_booking with {'user_id': 'user123'} + Returned: Booking ID user123 confirmed! + + + +```python +print(str(response)) +``` + + Booking ID user123 confirmed! + + + +```python +print(bookings["user123"]) +``` + + name='Logan' email='test@gmail.com' phone='1234567890' date='2023-04-05' time='17:00' + diff --git a/my_cookbooks.html b/my_cookbooks.html new file mode 100644 index 0000000..13d08e8 --- /dev/null +++ b/my_cookbooks.html @@ -0,0 +1,529 @@ + + + + + + Cookbooks Documentation + + + +
+ +
+

Cookbooks Documentation

+

Explore our collection of practical guides and tutorials for building AI applications

+
+ + +
+
+
+ + +
+ +
+ + +
+ +
+ + +
+ +
+ + +
+
+ +
+ +
+
+ + +
+ Loading cookbooks... +
+ + +
+ +
+ + + +
+ + + + \ No newline at end of file diff --git a/scripts/cookbook_page_generator.py b/scripts/cookbook_page_generator.py new file mode 100644 index 0000000..7d8889d --- /dev/null +++ b/scripts/cookbook_page_generator.py @@ -0,0 +1,644 @@ +#!/usr/bin/env python3 +""" +Cookbook Documentation Generator + +Reads index.toml and generates an HTML documentation page with filtering and search. +""" + +import tomllib +from pathlib import Path +from typing import List, Dict, Set +import json +from urllib.parse import urljoin + +class CookbookGenerator: + def __init__(self, toml_path: str, output_path: str = "cookbooks.html"): + self.toml_path = toml_path + self.output_path = output_path + self.data = None + + def load_toml(self): + """Load and parse the index.toml file""" + with open(self.toml_path, 'rb') as f: + self.data = tomllib.load(f) + + def get_all_tags(self) -> Set[str]: + """Extract all unique tags from recipes""" + tags = set() + for recipe in self.data.get('recipe', []): + tags.update(recipe.get('tags', [])) + return sorted(tags) + + def get_all_languages(self) -> Set[str]: + """Extract all unique languages from recipes""" + languages = set() + for recipe in self.data.get('recipe', []): + lang = recipe.get('language', '') + if lang: + languages.add(lang) + return sorted(languages) + + def generate_notebook_url(self, recipe: Dict) -> str: + """Generate the notebook URL based on config and recipe data""" + config = self.data.get('config', {}) + colab_base = config.get('colab', '') + + if 'notebook' in recipe: + return urljoin(colab_base, recipe['notebook']) + elif 'source' in recipe: + return recipe['source'] + return "#" + + def generate_html(self) -> str: + """Generate the complete HTML page""" + if not self.data: + raise ValueError("No data loaded. Call load_toml() first.") + + recipes = self.data.get('recipe', []) + all_tags = self.get_all_tags() + all_languages = self.get_all_languages() + + # Convert recipes to JSON for JavaScript + recipes_json = json.dumps([ + { + 'title': recipe.get('title', ''), + 'description': recipe.get('description', ''), + 'tags': recipe.get('tags', []), + 'language': recipe.get('language', ''), + 'url': self.generate_notebook_url(recipe), + 'featured': recipe.get('featured', False), + 'experimental': recipe.get('experimental', False) + } + for recipe in recipes + ]) + + html_template = f""" + + + + + Cookbooks Documentation + + + +
+ +
+

Cookbooks Documentation

+

Explore our collection of practical guides and tutorials for building AI applications

+
+ + +
+
+
+ + +
+ +
+ + +
+ +
+ + +
+ +
+ + +
+
+ +
+ +
+
+ + +
+ Loading cookbooks... +
+ + +
+ +
+ + + +
+ + + +""" + + return html_template + + def generate_file(self): + """Generate the HTML file""" + self.load_toml() + html_content = self.generate_html() + + with open(self.output_path, 'w', encoding='utf-8') as f: + f.write(html_content) + + print(f"Generated cookbook documentation: {self.output_path}") + print(f"Total recipes: {len(self.data.get('recipe', []))}") + print(f"Unique tags: {', '.join(self.get_all_tags())}") + +def main(): + """Main function to run the generator""" + import argparse + + parser = argparse.ArgumentParser(description='Generate cookbook documentation from index.toml') + parser.add_argument('toml_file', help='Path to index.toml file') + parser.add_argument('-o', '--output', default='cookbooks.html', + help='Output HTML file (default: cookbooks.html)') + + args = parser.parse_args() + + # Check if input file exists + if not Path(args.toml_file).exists(): + print(f"Error: File {args.toml_file} not found") + return 1 + + try: + generator = CookbookGenerator(args.toml_file, args.output) + generator.generate_file() + return 0 + except Exception as e: + print(f"Error generating documentation: {e}") + return 1 + +if __name__ == "__main__": + exit(main()) \ No newline at end of file diff --git a/scripts/notebooks_to_markdown.py b/scripts/notebooks_to_markdown.py index f73e8a9..0266c09 100644 --- a/scripts/notebooks_to_markdown.py +++ b/scripts/notebooks_to_markdown.py @@ -102,6 +102,7 @@ title: "{title}" featured: {notebook_info.get("featured", False)} experimental: {notebook_info.get("experimental", False)} tags: {notebook_info.get("tags", [])} +language: {notebook_info.get("language", None)} --- """ # Remove the original header and add frontmatter @@ -264,20 +265,23 @@ def convert_notebooks(index_data): colab_base_url = index_data["config"]["colab"] notebooks = [] for i, recipe_data in enumerate(recipes): - notebook_info = { - "file": Path(recipe_data["notebook"]), - "title": recipe_data["title"], - "colab": f"{colab_base_url.rstrip('/')}/{recipe_data["notebook"]}", - "featured": recipe_data.get("featured", False), - "experimental": recipe_data.get("experimental", False), - "tags": recipe_data.get("tags", []), - "relative_repo_path": recipe_data["notebook"], # Pass relative path for image fixing - } - notebook_path = Path(recipe_data["notebook"]) - notebooks.append({ - "notebook_path": notebook_path, - "notebook_info": notebook_info - }) + if recipe_data.get("notebook") is not None: + notebook_info = { + "file": Path(recipe_data["notebook"]), + "title": recipe_data["title"], + "colab": f"{colab_base_url.rstrip('/')}/{recipe_data["notebook"]}", + "featured": recipe_data.get("featured", False), + "experimental": recipe_data.get("experimental", False), + "tags": recipe_data.get("tags", []), + "relative_repo_path": recipe_data["notebook"], # Pass relative path for image fixing + } + if recipe_data.get("language"): + notebook_info["language"] = recipe_data["language"] + notebook_path = Path(recipe_data["notebook"]) + notebooks.append({ + "notebook_path": notebook_path, + "notebook_info": notebook_info + }) notebook_paths = [notebook['notebook_path'] for notebook in notebooks ] total_notebooks = len(notebook_paths)