From ab94b6c89245fd46c37287193e6bb297a9f7f198 Mon Sep 17 00:00:00 2001 From: Tuana Celik Date: Thu, 10 Oct 2024 14:50:40 +0200 Subject: [PATCH] adding new cookbook --- README.md | 1 + index.toml | 6 + notebooks/metadata_enrichment.ipynb | 506 ++++++++++++++++++++++++++++ 3 files changed, 513 insertions(+) create mode 100644 notebooks/metadata_enrichment.ipynb diff --git a/README.md b/README.md index a0f932d..382bccc 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,7 @@ For more examples, you may also find our [Blog](https://haystack.deepset.ai/blog | Speaker Diarization with AssemblyAI | Open In Colab| | Advance Prompt Customization for Anthropic | Open In Colab| | Advanced RAG: Query Decomposition and Reasoning | Open In Colab| +| Advanced RAG: Automated Structured Metadata Enrichment | Open In Colab| | Techcrunch News Digest with Local LLMs using TitanML Takeoff | Open In Colab| | Use Gemini Models with Vertex AI| Open In Colab| | Gradient AI Embedders and Generators for RAG | Open In Colab| diff --git a/index.toml b/index.toml index 2de2328..0cebd52 100644 --- a/index.toml +++ b/index.toml @@ -255,3 +255,9 @@ title = "Agentic RAG with Llama 3.2 3B" notebook = "llama32_agentic_rag.ipynb" topics = ["RAG", "Agents", "Web-QA"] new = true + +[[cookbook]] +title = "Advanced RAG: Automated Structured Metadata Enrichment" +notebook = "metadata_enrichment.ipynb" +new = true +topics = ["Advanced Retrieval", "RAG", "Metadata"] \ No newline at end of file diff --git a/notebooks/metadata_enrichment.ipynb b/notebooks/metadata_enrichment.ipynb new file mode 100644 index 0000000..ee95d98 --- /dev/null +++ b/notebooks/metadata_enrichment.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "iYhPbdnTN_9v" + }, + "source": [ + "# Advanced RAG: Automated Structured Metadata Enrichment\n", + "\n", + "by Tuana Celik ([LI](https://www.linkedin.com/in/tuanacelik/), [Twitter](https://x.com/tuanacelik))\n", + "\n", + "In this example, you'll see how you can make use of structured outputs which is an option for some LLMs, and a custom Haystack component, to automate the enrichment of metadata from documents.\n", + "\n", + "You will see how you can define your own metadata fields as a Pydantic Model, as well as the data types each field should have. Finally, you will get a custom `MetadataEnricher` to extract the required fields and add them to the document meta information.\n", + "\n", + "In this example, we will be enriching metadata with information relating the funding announements.\n", + "\n", + "Once we populate the metadata of a document with our own fields, we are able to use Metadata Filtering during the retrieval step of RAG pipelines. We can even combine this with [Metadata Extraction from Queries to Improve Retrieval](https://haystack.deepset.ai/blog/extracting-metadata-filter) to be very precise about what documents we are providing as context to an LLM." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-B7NJJzYZWcv" + }, + "source": [ + "### Install requirements" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9mhsRh7zjCQO", + "outputId": "c898ec01-f4e4-444e-8ea3-ea2368be3358" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: haystack-ai in /usr/local/lib/python3.10/dist-packages (2.6.1)\n", + "Requirement already satisfied: haystack-experimental in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (0.2.0)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (3.1.4)\n", + "Requirement already satisfied: lazy-imports in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (0.3.1)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (10.5.0)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (3.3)\n", + "Requirement already satisfied: numpy<2 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (1.26.4)\n", + "Requirement already satisfied: openai>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (1.51.2)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (2.2.2)\n", + "Requirement already satisfied: posthog in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (3.7.0)\n", + "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (2.8.2)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (6.0.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (2.32.3)\n", + "Requirement already satisfied: tenacity!=8.4.0 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (9.0.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (4.66.5)\n", + "Requirement already satisfied: typing-extensions>=4.7 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (4.12.2)\n", + "Requirement already satisfied: anyio<5,>=3.5.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (3.7.1)\n", + "Requirement already satisfied: distro<2,>=1.7.0 in /usr/lib/python3/dist-packages (from openai>=1.1.0->haystack-ai) (1.7.0)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (0.27.2)\n", + "Requirement already satisfied: jiter<1,>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (0.6.1)\n", + "Requirement already satisfied: pydantic<3,>=1.9.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (2.9.2)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (1.3.1)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->haystack-ai) (2.1.5)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->haystack-ai) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->haystack-ai) (2024.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil->haystack-ai) (1.16.0)\n", + "Requirement already satisfied: monotonic>=1.5 in /usr/local/lib/python3.10/dist-packages (from posthog->haystack-ai) (1.6)\n", + "Requirement already satisfied: backoff>=1.10.0 in /usr/local/lib/python3.10/dist-packages (from posthog->haystack-ai) (2.2.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (2.2.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (2024.8.30)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio<5,>=3.5.0->openai>=1.1.0->haystack-ai) (1.2.2)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->openai>=1.1.0->haystack-ai) (1.0.6)\n", + "Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/lib/python3.10/dist-packages (from httpcore==1.*->httpx<1,>=0.23.0->openai>=1.1.0->haystack-ai) (0.14.0)\n", + "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.10/dist-packages (from pydantic<3,>=1.9.0->openai>=1.1.0->haystack-ai) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.23.4 in /usr/local/lib/python3.10/dist-packages (from pydantic<3,>=1.9.0->openai>=1.1.0->haystack-ai) (2.23.4)\n", + "Requirement already satisfied: trafilatura in /usr/local/lib/python3.10/dist-packages (1.12.2)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from trafilatura) (2024.8.30)\n", + "Requirement already satisfied: courlan>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from trafilatura) (1.3.1)\n", + "Requirement already satisfied: htmldate>=1.8.1 in /usr/local/lib/python3.10/dist-packages (from trafilatura) (1.9.1)\n", + "Requirement already satisfied: justext>=3.0.1 in /usr/local/lib/python3.10/dist-packages (from trafilatura) (3.0.1)\n", + "Requirement already satisfied: lxml>=5.2.2 in /usr/local/lib/python3.10/dist-packages (from trafilatura) (5.3.0)\n", + "Requirement already satisfied: charset-normalizer>=3.2.0 in /usr/local/lib/python3.10/dist-packages (from trafilatura) (3.3.2)\n", + "Requirement already satisfied: urllib3<3,>=1.26 in /usr/local/lib/python3.10/dist-packages (from trafilatura) (2.2.3)\n", + "Requirement already satisfied: babel>=2.16.0 in /usr/local/lib/python3.10/dist-packages (from courlan>=1.2.0->trafilatura) (2.16.0)\n", + "Requirement already satisfied: tld>=0.13 in /usr/local/lib/python3.10/dist-packages (from courlan>=1.2.0->trafilatura) (0.13)\n", + "Requirement already satisfied: dateparser>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from htmldate>=1.8.1->trafilatura) (1.2.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from htmldate>=1.8.1->trafilatura) (2.8.2)\n", + "Requirement already satisfied: pytz in /usr/local/lib/python3.10/dist-packages (from dateparser>=1.1.2->htmldate>=1.8.1->trafilatura) (2024.2)\n", + "Requirement already satisfied: regex!=2019.02.19,!=2021.8.27 in /usr/local/lib/python3.10/dist-packages (from dateparser>=1.1.2->htmldate>=1.8.1->trafilatura) (2024.9.11)\n", + "Requirement already satisfied: tzlocal in /usr/local/lib/python3.10/dist-packages (from dateparser>=1.1.2->htmldate>=1.8.1->trafilatura) (5.2)\n", + "Requirement already satisfied: lxml-html-clean in /usr/local/lib/python3.10/dist-packages (from lxml[html_clean]>=4.4.2->justext>=3.0.1->trafilatura) (0.3.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->htmldate>=1.8.1->trafilatura) (1.16.0)\n" + ] + } + ], + "source": [ + "!pip install haystack-ai\n", + "!pip install trafilatura" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "id": "nYsEFBwnOIb8" + }, + "outputs": [], + "source": [ + "from haystack import Document, component\n", + "from haystack.components.builders import PromptBuilder\n", + "from haystack.components.converters import HTMLToDocument\n", + "from haystack.components.fetchers import LinkContentFetcher\n", + "from haystack.components.generators import OpenAIGenerator\n", + "from haystack.components.generators.openai_utils import _convert_message_to_openai_format\n", + "from haystack.components.preprocessors import DocumentSplitter\n", + "from haystack.dataclasses import ChatMessage, StreamingChunk\n", + "from haystack.document_stores.in_memory import InMemoryDocumentStore\n", + "\n", + "from openai import OpenAI, Stream\n", + "from openai.types.chat import ChatCompletion, ChatCompletionChunk\n", + "from typing import List, Any, Dict, Optional, Callable, Union\n", + "from pydantic import BaseModel" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0m05uf0c-ahX" + }, + "source": [ + "## 🧪 Experimental Addition to the OpenAIGenerator for Structured Output Support\n", + "\n", + "> 🚀 This is the same extension to the `OpenAIGenerator` that was used in the [Advanced RAG: Query Decomposition and Reasoning](https://haystack.deepset.ai/cookbook/query_decomposition) example\n", + "\n", + "Let's extend the `OpenAIGeneraotor` to be able to make use of the [strctured output option by OpenAI](https://platform.openai.com/docs/guides/structured-outputs/introduction). Below, we extend the class to call `self.client.beta.chat.completions.parse` if the user has provides a `respose_format` in `generation_kwargs`. This will allow us to provifde a Pydantic Model to the gnerator and request our generator to respond with structured outputs that adhere to this Pydantic schema." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "id": "6ihGheQx-gSk" + }, + "outputs": [], + "source": [ + "class OpenAIGenerator(OpenAIGenerator):\n", + " def __init__(self, **kwargs):\n", + " super().__init__(**kwargs)\n", + "\n", + " @component.output_types(replies=List[str], meta=List[Dict[str, Any]], structured_reply=BaseModel)\n", + " def run(self, prompt: str, streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, generation_kwargs: Optional[Dict[str, Any]] = None,):\n", + " generation_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}\n", + " if \"response_format\" in generation_kwargs.keys():\n", + " message = ChatMessage.from_user(prompt)\n", + " if self.system_prompt:\n", + " messages = [ChatMessage.from_system(self.system_prompt), message]\n", + " else:\n", + " messages = [message]\n", + "\n", + " streaming_callback = streaming_callback or self.streaming_callback\n", + " openai_formatted_messages = [_convert_message_to_openai_format(message) for message in messages]\n", + " completion: Union[Stream[ChatCompletionChunk], ChatCompletion] = self.client.beta.chat.completions.parse(\n", + " model=self.model,\n", + " messages=openai_formatted_messages,\n", + " **generation_kwargs)\n", + " completions = [self._build_structured_message(completion, choice) for choice in completion.choices]\n", + " for response in completions:\n", + " self._check_finish_reason(response)\n", + "\n", + " return {\n", + " \"replies\": [message.content for message in completions],\n", + " \"meta\": [message.meta for message in completions],\n", + " \"structured_reply\": completions[0].content\n", + " }\n", + " else:\n", + " return super().run(prompt, streaming_callback, generation_kwargs)\n", + "\n", + " def _build_structured_message(self, completion: Any, choice: Any) -> ChatMessage:\n", + " chat_message = ChatMessage.from_assistant(choice.message.parsed or \"\")\n", + " chat_message.meta.update(\n", + " {\n", + " \"model\": completion.model,\n", + " \"index\": choice.index,\n", + " \"finish_reason\": choice.finish_reason,\n", + " \"usage\": dict(completion.usage),\n", + " }\n", + " )\n", + " return chat_message" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7JGz6wd6mZ2M", + "outputId": "fd3c7e1d-95c4-464c-bf4c-5fa4a509f41c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OpenAI API Key:··········\n" + ] + } + ], + "source": [ + "import os\n", + "from getpass import getpass\n", + "\n", + "if \"OPENAI_API_KEY\" not in os.environ:\n", + " os.environ[\"OPENAI_API_KEY\"] = getpass(\"OpenAI API Key:\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TJB0zJayZwBx" + }, + "source": [ + "## Custom `MetadataEnricher`\n", + "\n", + "We create a custom Haystack component that is able ti accept `metadata_model` and `prompt`. If no prompt is provided, it usees the `DEFAULT_PROMPT`.\n", + "\n", + "This component returns `documents` enriched with the requested metadata fileds." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "id": "TXHDmsunFI5V" + }, + "outputs": [], + "source": [ + "from haystack import component, Pipeline, Document\n", + "from haystack.components.builders.prompt_builder import PromptBuilder\n", + "\n", + "DEFAULT_PROMPT = \"\"\"\n", + "Given the contents of the documents, extract the requested metadata.\n", + "The requested metadata is {{ metadata_model }}\n", + "Document:\n", + "{{document}}\n", + "Metadata:\n", + "\"\"\"\n", + "@component\n", + "class MetadataEnricher:\n", + "\n", + " def __init__(self, metadata_model: BaseModel, prompt:str = DEFAULT_PROMPT):\n", + " self.metadata_model = metadata_model\n", + " self.metadata_prompt = prompt\n", + "\n", + " builder = PromptBuilder(self.metadata_prompt)\n", + " llm = OpenAIGenerator(generation_kwargs={\"response_format\": metadata_model})\n", + " self.pipeline = Pipeline()\n", + " self.pipeline.add_component(name=\"builder\", instance=builder)\n", + " self.pipeline.add_component(name=\"llm\", instance=llm)\n", + " self.pipeline.connect(\"builder\", \"llm\")\n", + "\n", + " @component.output_types(documents=List[Document])\n", + " def run(self, documents: List[Document]):\n", + " documents_with_meta = []\n", + " for document in documents:\n", + " result = self.pipeline.run({'builder': {'document': document.content, 'metadata_model': self.metadata_model}})\n", + " metadata = result['llm']['structured_reply']\n", + " document.meta.update(metadata.dict())\n", + " documents_with_meta.append(document)\n", + " return {\"documents\": documents_with_meta}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9Ht7fsHPl_jI" + }, + "source": [ + "## Define Metadata Fields as a Pydantic Model\n", + "\n", + "For automatic metadata enrichment, we want to be able to provide a structure describing what fields we want to extract, as well as what types they should be.\n", + "\n", + "Below, I have defined a `Metadata` model, with 4 fields.\n", + "\n", + "> 💡 **Note:** In some cases, it might make sense to make each field optional, or provide default values." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "id": "qlKb8fwln5ha" + }, + "outputs": [], + "source": [ + "class Metadata(BaseModel):\n", + " company: str\n", + " year: int\n", + " funding_value: int\n", + " funding_currency: str" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bjNyCykWapxU" + }, + "source": [ + "Next, we initialize a `MetadataEnricher` and provide `Metadata` as the `metadata_model` we want to abide by." + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "id": "7kJflm1jGdNg" + }, + "outputs": [], + "source": [ + "enricher = MetadataEnricher(metadata_model=Metadata)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9ZTQrpc7a0gF" + }, + "source": [ + "## Build an Automated Metadata Enrichment Pipeline\n", + "\n", + "Now that we have our `enricher`, we can use it in a pipeline. Below is an example of a pipeline that fetches the contents of some URLs (in this case, urls that contain information about funding announcements). The pipeline then adds the requested metadata fields to each `Document`'s `meta` field 👇" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WiBYhEzhOqTn", + "outputId": "ea8760e4-abf3-4867-c0bc-e3b645522671" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'enricher': {'documents': [Document(id=5844517120556b13f92430ea8af9837714ede1b351580c43c2ddce9b646cb6cb, content: 'Deepset, a platform for building enterprise apps powered by large language models akin to ChatGPT, t...', meta: {'content_type': 'text/html', 'url': 'https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/', 'company': 'Deepset', 'year': 2023, 'funding_value': 30000000, 'funding_currency': 'USD'}),\n", + " Document(id=8cdcb63a4e006b1cac902ebc2e012cd95156d188777e0d0c8bd407a92f4491c7, content: 'Arize AI Raises $38 Million Series B To Scale Machine Learning Observability Platform\n", + " As companies t...', meta: {'content_type': 'text/html', 'url': 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html', 'company': 'Arize AI', 'year': 2022, 'funding_value': 38000000, 'funding_currency': 'USD'})]}}" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipeline = Pipeline()\n", + "pipeline.add_component(\"fetcher\", LinkContentFetcher())\n", + "pipeline.add_component(\"converter\", HTMLToDocument())\n", + "pipeline.add_component(\"enricher\", enricher)\n", + "\n", + "\n", + "pipeline.connect(\"fetcher\", \"converter\")\n", + "pipeline.connect(\"converter.documents\", \"enricher.documents\")\n", + "\n", + "pipeline.run({\"fetcher\": {\"urls\": ['https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/',\n", + " 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html']}})" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 955 + }, + "id": "uIzoahGZREwr", + "outputId": "04125f08-95d1-4791-dafd-fcaff93a180e" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARQAAAOqCAYAAABdL6pVAAAAAXNSR0IArs4c6QAAIABJREFUeJzs3XdcU1f/B/BPEpCNiKKgBGSrgAq4pVpBfXBPbF1VsVq1aoej1Q5HVVzV2pYqahVHtVZ/1brr9mndAwthi6DIEkQF2ZDv74/CfYwgQb0Yxvf9euXV5o5zT27CJ+fcG88BGGOMMcYYY4wxxhhjjDHGGGOMMcYYY+wNCAwMpMDAQNJ0PRhjNVxgYCBlZGRQRkYGhwpj7NU9GyYcKoyxV1ZemHCoMMZeWkVhwqHCKiLRdAVY9RIYGEi+vr6V2nbv3r344IMP+DPEBPxhYIKXCZNSHCrsWfxBYMArhkkpDhVWij8E7LXCpBSHCgMHChMjTEpxqDB+8+swMcOkFIdK3cZvfB1VFWFSikOl7uI3vQ6qyjApxaFSN/EbXse8iTApxaFS9/CbXYe8yTApxaFSt/AbXUdoIkxKcajUHfwm1wGaDJNSHCp1A7/BtVx1CJNSHCq1H7+5tVh1CpNSHCq1G7+xtVR1DJNSHCq1F7+ptVB1DpNSHCq1E7+htUxNCJNSHCq1D7+ZtUhNCpNSHCq1i1TTFWDiqMow6d69OxYvXlwlZfv6+oKHk6w9+JuhFqiqMImIiMAff/yBlJQUdO7cGeHh4Zg/fz50dHREPxa3VGoHLU1XgL2eqmyZxMTE4MiRI0hNTcWVK1cgk8kwcuRItGjRQvRjlbwG4lCp2WSargB7dVV9zcTJyQmPHz9GUVERsrKysGjRInTo0KHKjufs7AxbW9uFhw8fXlRlB2FViq+h1FBv4gJsXl4e/v77b8yfPx8TJkzAmTNnqvR44GsqNR43L2sgTdzNISJIJG/u48LXVGomfsNqkICAAENtbe0Hw4cP19N0Xd6Effv25cpksiYTJ07M0nRdWOVwl6cG+fDDD5/KZLLc7OxsTVelymVnZ0NLSyuXw6Rm4RZKDfTzzz8/7N27t6mBgYGmq1IlsrOzcfLkyQw/P7+Gmq4LezkcKDVUbQ0VDpOajQOlBqttocJhUvNxoNRwtSVUOExqBw6UWqCmhwqHSe3BgVJL1NRQ4TCpXThQapGaFiocJrUPB0otU1NChcOkduJAqYWqe6hwmNReHCi1VHUNFQ6T2o0DpRarbqHCYVL7caDUctUlVDhM6gYOlDpA06HCYVJ3cKDUEVu2bMno1atXgzcdKtnZ2Th16tSjCRMmmL7RAzON4OEL6gg/Pz/TkydPPn6TQx+UtEwec5jUHdxCqWO2bNnyqFevXiZV3VIpDRM/P78GVXogVq1woNRBVR0qHCZ1FwdKHVVVocJhUrdxoNRhYocKhwnjQKnjxAoVDhMGDhQGEUKFw4SV4kBhwGuECocJexYHChO8bKhwmLDncaAwFZUNFQ4TxlilbNmy5VFCQgJlZGSU+0hISKAtW7Y80nQ9GWM1xItChcOEMfZKng8VDhPG2GspDRUOE8aYKLZv335/+/bt9zVdD8ZYLTFp0qStmq4Dq/54PBSm1sKFC6UAxmq6Hqz640BhaiUlJckAFGu6Hqz640BhahUUFMgkEgkHClOLA4WpVVxczC0UVikcKEwtpVLJgcIqhQOFqWVsbCwjIg4UphYHClOLuzyssjhQmFqFhYUSiURySdP1YNUfBwpTS1tbW4uI2mm6Hqz640BhakmlUikApabrwao/LU1XgFV/RUVFEgAJmq4Hq/64hcLU0tLS0pJIJOaarger/jhQmFr8OxRWWRwoTC0i4p/es0rhQGFqFRcXS5RKJY+HwtTiQGFqSSQSbalU2ljT9WDVHwcKU0tLS4t/es8qhQOFqUVEfFGWVQoHClNLIpHwD9tYpXCgMLWKi4sJQLSm68GqPw4UVhnaEonEVtOVYNUfBwpTSyKRSImIuzxMLQ4UphZfQ2GVxYHC1FIqlRKJREKarger/iSargATBxHV5D/4bIlEYqjpSrDXxy0UxphoOFAYY6LhQGGMiYYDhTEmGg4U9tJcXFzw7rvvaroarBriQGGMiYYDhVVazb4zzd4EDpQ6qKioCBKJBMuXL1dZ3r9/f3Tq1AkAkJ6eDolEgtWrV2PMmDEwMDBAt27dyi0vOjoa3t7eMDQ0hFwux5QpU6BU8g9r6yKeRoNVaOnSpZg2bRrOnj0LmUxW7jYTJ05EVFQU1q5di6ysLJw9exb/TuXD6hoOFFahTp06YenSpRVuEx8fDzc3N0yaNAkA8Omnn76h2rHqhr9GWIW8vb3VbjN27FicOHECM2bMwIMHD95IvVj1xIHCKmRoqP6f2CxduhRr167Fnj17YGtri4CAgDdSN1b9cKDUQRKJuP8mVCKR4OOPP0ZsbCwGDhyI6dOn48KFC6Ieg9UMHCh1kEwmg6mpKZKSkoRlRIR79+5Van8dHR1kZGQIz/Py8gAARkZGWLx4MQDg5s2botebVX8cKHXUf/7zH+zYsQMHDhzA5cuXMWLECERGRlZqXzc3N5w6dQqffvopCgoK4Ovri9GjR2Pbtm344osvAAAeHh5V/AoYY1WGXlJqaioNGTKEjI2NSS6X07Jly6hv377UsWNHIiJKS0sjALR+/fpy9x06dCiZmJjQ48ePafHixWRvb0+6urpkb29PGzdufNnqPNX0+WPi4AGWagkeYIlVB9zlYYyJhgOFMSYaDhTGmGg4UBhjouFAYYyJhgOFMSYaDhTGmGg4UBhjouFAYYyJhgOFMSYaDhTGmGg4UBhjouFAYYyJhgOFqaVUKqGnpweJRAKJRILU1FRRyh0+fHhpmQaiFMgYE0fpwCK2tra0fPnyMgOOPHjwgCwtLenXX3+tcGCSpKQkGjRoEN27d09YFhUVRQDo+PHjlJKSUuH+f/31F/n6+lZqEJSHDx/SpUuXCEBNHnqBPYOn0ahFsrKyEBcXh7Zt25ZZZ2xsjP79+8PR0bHCMs6cOYOrV69CLpcLyxQKBSQSCbp27ap20Opt27ZBS6vij1VxcbEwDGVaWpra18UYe8OIiP773/8SAEpNTVVpCdy/f7+0FUBPnjwhIqL169eTtbU16evrU69evaiwsJB++eUX0tLSIm1tbTIwMKCPPvqIiIgWL15MzZs3VymzvP2nTJlCEomEdHV1ycDAgPbt20dERLNnz6bu3bvT2LFjydzcnLZs2SKU4+/vT+bm5jzNIGPVCRHR999/TxYWFuV2LzZt2iSEQmhoKAGgo0ePUmpqKh04cEDYrnPnzrRy5UqVfUeMGEH9+vUTnr9o/+zsbNLS0qKrV6+q7O/j40ONGjWiW7duUXFxMeXm5grrRo8eTV5eXkWaPn9MHHxRtha5desW3Nzcyl2nUCjg6uoKlMxtDAB37tyBmZkZBg0aBAAoLCxEcHAwOnbsWGZfFxcX4fmL9r9+/TpkMhnatGmjsn9oaCi+/PJLtGnTBlKpFLq6usK6sLAwODs7cwuFseqEiMjd3Z3mz59fbgvFy8tLZd3u3bvJwsKC3N3dKT4+noiIrl69SjKZjJ4+fSpsV1BQQNra2rR9+3aV8srbf+XKldSpUyeV7R49ekQAKDQ0tEydiouLSVdXlwIDA/M0ff6YOLiFUksUFRUhLCzshS2U0NBQoYUCAO+++y6ioqKQk5ODVatWAQCuXLkCJycnGBj87y5uVFQUCgsL4ezsrFLei/Z3d3cvc1xtbW04OTmVqVNsbCzy8vLg4uLCLZRagu/y1BIRERHIz8+HgYGByvw6FhYWyM3NRVpamhAo69evR48ePSCTyZCTkwN7e3sAwIMHD5CWloa4uDgQEWxtbaFQKCCVStGyZUuhzIr2z8rKQnJyMpRKJZo1awaFQoEWLVpAW1u7TJ1L7x5xoDBWzezYsUO4k/Ps488//6QTJ05QvXr1qLCwkLKzs+ntt98mfX19srCwoDlz5lBRURERESkUCrKysiJtbW3htyRffvkl2dvbC92UivbftWsXGRkZkZ6eHq1bt46IiKZOnUojR44stxv2zTffkLW1NfG8PLUHz8tTS1AVzcszZMgQEBEOHDggetkjR45EZmYmjhw5wvPy1BJ8DYVVSKFQwMrKCikpKSguLhalzMzMTKSkpCA0NFTl7hFjrJoot0/xmnJzc0kqlQrdp0ePHolSbr9+/YQyS+4ecZenluAuTy1BPBUpqwa4y8MYEw0HCmNMNPw7lNrjUVUVXFRUpENEEm1t7ar6RWtmFZXLGKtuJk+evGDy5MkLNV0PVv1xl4cxJhru8jC1lErlI/7yYZXBgcLUkkqlDfgnBqwy+FuHMSYabqGwysglIm6hMLU4UFhl6EkkEg4UphYHCquMTKVSyd1jphYHCqsMY6lUyi0UphZ/6zDGRMMtFKaWUqnM54uyrDI4UJhaUqlUh3+HwiqDA4WppVQqn0gkEu4eM7U4UJhaUqm0PrdQWGVwoDC1iouLM/kuD6sMDhSmlkwmM+YWCqsM7hezylAqlcqaPGYte0P4W4eVa9KkSUkSicTiBauTN27c2PQNV4nVANxCYeUion3ljaRPRKRUKn/XTK1YdceBwsolkUh+BHCnnFV3CgsL12qgSqwG4EBh5dq0aVM0gD+fb6UQ0fFt27bFaq5mrDrjQGEvJJVKvwMQX/qciO7n5+d/q9laseqMA4W9UGBgYAwRnS59TkRHd+zYEafZWrHqjAOFVYiIVhDRfQCJSqVyhabrw6q3Gn/bePPmzT/LZLL6mq5HbZaZmdkRAIyNja9oui61WXFx8ZP3339/oqbr8Tpq/C9liWiMq6trPamUG1tvgKWmK1BbKZVKBAcHFwDgQNE0uVwObW1tTVeDsVdWVFSE4OBgTVfjtfHXOmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwo7KVdvXoVq1evRn5+vqarwqoZDpQaLj8/H19//TWcnZ0hl8uxcOHCSu/76NEjHD58+KWPOWLECCxbtgyFhYUvvS+r3ThQajh/f3/8+OOPqFevHrp06QJ3d/dK7ZeYmIhWrVph5cqVVV5HVnfUikGq67K9e/dCV1cX58+fh7GxcaX3y8/P5y4LEx23UGqoa9euwdTUFMnJycjLy0Pz5s0xceL/ZmAICQnB8OHDIZfLYW1tDV9fX4SEhAAlrZN27doBABQKBUxNTWFqaorExERh/6NHj6Jfv36wsrKCra0tfH19ERoaqlKHhQsXomXLlrCxsYGvry9u376tsj4tLQ0zZ86Eg4MDLCws0KNHDxw4cEBYHxoaClNTU3Tt2hVTpkyBnZ0dLCwscOHChao6bayKcaDUUCYmJujduzcAQCaToXfv3mjTpg1QEjZ9+vTBmTNn4OTkBFtbW5w+fRp9+/aFQqGAvr6+sG/9+vUxZMgQDBkyBPr6+gCADRs2YMyYMbhy5Qrs7Owgl8tx5swZpKenq9QhKCgIlpaW0NHRwenTp+Hr64u8vDyg5PqMj48Pdu7cifr168PNzQ2RkZHw8/PD9u3bVcqJiIjAmTNn0K9fP/Ts2RNdunR5I+eQiY+7PDWUg4MDfv31V5iamkJXVxe//vqrsG727NnIzc3F5s2bMXToUADAtm3b8Mknn2D58uXYuXMnli1bhhMnTkAul+Pnn38W9k1NTcWiRYsglUqxb98+vP322wCAqKgoODk5qdTh4MGD6NKlC7Kzs9GzZ09ERUXhwoUL8Pb2xurVqxEXF4cJEyZg9erVkEgkiIiIwNtvv43Fixdj9OjRQjkymQwHDx5EixYt3sCZY1WJA6WWuX//PkJDQ6GtrY3g4GBh8qjSlsPNmzcr3P/s2bPIz8+Ht7e3ECYAyoQJALRu3RoAYGBgAC8vL0RFRSE+Ph4o6TIBwNOnT/H1118L+xgZGSEjIwNxcf+bc71FixYcJrUEB0otk5KSAgAoLCxEQEBAmfW6uroV7p+amgoAsLGxeanj1qtXDwBQUFCgUs7evXvL3V5PTw+5ubkAAENDw5c6Fqu+OFBqmdI7Pebm5ggPD1e7vVKpVHlev/6/886XBtPr1CMvLw9XrlyBg4NDudtkZGS81jFY9cMXZWsZe3t7NGnSBCkpKdi8ebOwPC0tDbGxscJzIyMjoKSLVNpSKCgoEC6I/vnnn7h27ZqwfUhIiNBtqozSclatWiW0WgoLC9V2uVjNxoFSy0ilUnz11VcAgLlz56JDhw7o2bMn3N3dsWDBAmE7MzMz2NjYIDMzEx06dICnpyf27NkDR0dHjBkzBoWFhejbty/eeustdOvWDd7e3tizZ0+l6zF37lwYGBhg3759aNOmDXx8fODs7IzRo0e/VDCxmoUDpRYaNWoUgoKC4O7ujoSEBISHh8PW1hbe3t4q223atAmtW7dGWloakpOT0bBhQwDA2rVrsWDBAjRv3hzR0dFITEyEp6cnWrZsWek6tGjRAkePHkXv3r2Rk5OD4OBgGBoawtfXt0w3i9UeEk1X4HVt2rQpf+DAgfW0tbU1XRXGXllRURH++OOPgkmTJuloui6vg1sojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKBUE0VFRTA3N8f169c1XZUaa+rUqZg5c6amq1GncaC8pj179kAul5c7xseKFStUBnquyJ07d1BQUFDhcInz589HmzZt0KRJE7Rs2RIRERGvXf/t27dj+fLlr11OReUtXLhQmPvn2ce2bdvUljd37lwcOnSoUseOiIiAvb39q1adiYDHlH1NoaGhaNmyJaTSstncpk0bFBcXV6qcqKgomJmZqYzpam5uDgBISkrCgAEDoK+vj2XLlsHOzg7R0dGwtbV97fp///33mDFjxmuXU1F5CoUCgwcPxueff66yvGnTphWWlZSUhM2bN2Py5Mlqj6tUKhETEwM7O7tXrPn/EBEkkho/VJBGcAvlNSkUCmE6iWfNnDkTo0aNEsZrTU9Ph4uLC7Zt24bOnTujadOmGDhwILKzswEAkZGRwrfr8ePH8dZbbyEzMxMAMH36dOjq6gqz+bVo0QIDBw6Ejs6/Y/EcOXIEb731Fpo2bYqOHTvi+PHjlTpm586dcefOHXz55ZewsrJCWloaACA5OVmYyU8ul2PMmDHIzMx85fJCQ0PRu3dvODo6qjwMDQ1feKzExER4eHhAKpWiR48e6NGjh3Buz549i549e8LCwgItW7ZEVFQU4uLikJubi/Pnz6NDhw6wtrbGsmXLhH0KCgqwZMkSuLq6wsLCAl5eXsIg3idOnICVlRVWr16N9u3bY//+/VXwSakbOFBek0KhgKura5nl3333HZo1a4ZWrVoBJdNXJCUl4dKlS/j9999x7NgxXLhwAadOnQJKWij29vY4ffo0pkyZgsDAQBgbG+Off/7BuXPnsGLFCmFg6WcdPHgQM2bMwDfffIO4uDi88847+OCDD5CTk6P2mEuXLoWhoSHu3r2Le/fuwczMDBkZGfDx8UFeXh7Onj2LGzduIDg4GEeOHHml8pKTk5GWloZZs2ZBLpdDLpdj7dq1QEk37kXHatasGaZNmwZvb28kJCTg7NmzAIAzZ85g9OjRGDp0KEJCQnD48GFYWVkhIiICUqkUFhYWOHnyJBYtWoTVq1fj4cOHAIDx48fj6NGj2L59O6Kjo2Fubo6ffvoJKOkq5eTkwMrKCteuXUP//v2r6NNS+3GX5zUkJiYiIyOj3EDJyspCYmKiECh37tyBRCLBqlWrYGRkBHNzc2hrawtdpcjISJiZmWHixInYvHkzvLy8AADnz5+HmZkZPD09yxyjuLgY8+fPx2effSZcqxk2bBiWLFmCe/fuoaCgoMJjXr9+HW5ubirdtYCAAGRnZyMgIAAGBga4cOECnjx5AicnJ7WvobzyFAoF9PT08NdffwnLGjVqpPZYpeV17dpV5TV//fXX8PPzw7Rp04CSwbZLz5+TkxM++eQTAED79u2BkpbJmTNncPz4cZw4cQJubm64e/cu4uLihLLDw8PRp08fjBgxAnhmjiH28jhQXkNoaChkMpkQGs8KDw+HTCYT/jjCwsJgZWUltDISEhJQUFAAR0dHFBcXIzY2FuHh4XBxcVG5kPvgwQPhj6a8YyQlJaF79+7CstL5hxs2bIhTp0698JgAcOPGDXh4eKiU+ffff0MikcDJyQkSiQSNGzfG2rVr4e7ujt27d790eSEhIXB0dCz3ek9Fx1Iqlbh165bKXZu0tDSEh4cLLZxnRUREwNnZWXgeExMDY2NjWFhYYPPmzTA0NMSwYcMgkUggk8kwbtw4TJ06Vdh37Nix5Z5j9nK4y/MaQkND4eDgUO5sfGFhYbC1tRXWhYWFqQSPQqGAjo4O7OzsEBcXh/z8fPz+++9ITU3FmjVrhO2aNGmChIQE5OTklDlG6TWW0ou3AHDo0CG4ubnBzMyswmOiZFrS8q7/+Pn5ISYmBpGRkbhx4wZ8fX3VvoYXladQKCqcZvRFx4qKikJWVpYwATxKpjVFyayDz4uMjFQJlPDwcJW6urq6IjY2FiEhIYiNjcXXX38NqVSKoqIixMTElPulwF4eB8prUCgUkMvliI6OFh6lc/Y+/4EODw9X+cArFAo4OjpCS0sLkZGRMDExwdtvv41169bh22+/xa1btwAA/fr1Q0FBASZPnozLly/j4sWLmD9/PoKDg+Ho6AgdHR3s2bMHhYWFOHHiBLZu3SrMJVzRMYuKivDo0SOEh4cjOTkZT548AQC0a9cO+/btQ0xMDPLy8nDu3LlKvYYXlRcSEvLCQKnoWKUXdP/55x/ExsaCiCCXy2FmZoaVK1ciKSkJoaGhuHr1KoqKihAbG1smUEqft2vXDjdu3MCJEyegVCpx7tw5YW6g2NhY5Ofnv9QUIezFOFBeg0KhwMmTJ9GpUyfhMWXKFKDkA/3sh/T5b/dnn0dFRQnb+vj4YOTIkZg6dSry8vJga2uL3bt3IyUlBcOHD4efnx/S09Nha2sLMzMzBAQEIDAwEDY2Nli9ejWCgoKELlBFx9TS0sKkSZPw/fffo3PnzsKsgnPmzIGrqysGDhyI9u3b4+TJk5V6DeWVl5WVhfj4+HInWld3rPbt26Njx44YOXIkBgwYIBxj69atiI+Ph4eHB8aMGYOsrCzcvn0bBQUFLwzwPn364MMPP8Snn34KFxcX+Pv7C3fIIiIiYG5uDlNT01f4BLDn1fib7TwvD6sNeF4exhh7DgcKY0w0HCiMMdFwoDDGRMOBwhgTDQcKY0w0HCiMMdFwoDDGRMOBwhgTDQcKY0w0HCiMMdFwoDDGRMOBwhgTDQcKY0w0HCiMMdFwoDDGRMOBwhgTDQcKY0w0HCiMMdFwoDDGRFPjJ/oiIrp+/Xq2RCIhTdelFisdzJzPcRUhIgkR1fi/xxr/AoqLiyfeu3ePh7yvQmlpaYOISNK4ceMDmq5LLVeo6QowVuUmT568YPLkyQs1XQ9W/fE1FMaYaDhQGGOi4UBhjImGA4UxJhoOFMaYaDhQGGOiqfG/Q2FVj4iKlUolf/kwtThQmFoSiUQmk8kkldiU1XH8rcMYEw23UJhaSqXyEX/5sMrgQGFqSaXSBs/8A0HGXoi/dRhjouFAYYyJhrs8TC2lUvmIbxuzyuBAYWpJpdIGUqmUr6EwtfhbhzEmGg4UxphoOFAYY6LhQGGVoVQqlTxANVOLA4VVhpQvyrLK4EBhjImGA4UxJhr+HQpTi4jy+MuHVQb3iytARL4AftN0PVi1MloikezSdCWqK/7WYYyJhgOFMSYaDhTGmGg4UBhjouFAeU1Xr15FXl6epqvBWLXAgfIagoKC0LFjRzx9+lTTVWGsWuBAeQ0v0zIh4n8K86bwudYcDhQ1oqOj4e3tDUNDQ8jlckyZMgVKpRJBQUGYOnUqAMDMzAwSiQRBQUEAgOnTp8Pc3ByHDh2Co6MjpFIpzpw5AwCIj4/H0KFDYWRkhMaNG8PHxwfXr18XjnfhwgX4+PjA0NAQhoaG6NGjB27cuCGsv3XrFoyNjXHkyBG0adMG9erVg729PbZu3Qp/f39YWVnB2NgYgwcPRlpamrDfihUrIJfLYWhoCE9PT5w+ffqlz8WhQ4dw+/btl9rn6NGjcHV1hb6+PpydnfHjjz8K61JSUjBq1CiYmJjAwMAA//nPf6BQKIT1X375JXR1dVXKu379OiQSCY4fPw6oOdd///03evXqBSMjIxgZGWHAgAG4efOmUNa5c+fQqVMn6OnpwdraGn5+fkhOThb1nDEmICJfT09PMjMzo40bN9K3335L/fv3JyKi1NRUmj17NgGgw4cP019//UWpqalERPThhx+Srq4uubq60smTJ2n//v2kVCopOTmZLCwsqFu3bvTzzz/Tli1b6O233yZdXV1SKBRERLRjxw7q1q0b+fv708qVK6l58+bUuHFjys7OJiKi4OBgAkBWVlZ0+PBhOn36NLm4uBAA8vT0pAsXLtDu3bvJ0NCQxowZQ0REp06dIgA0evRo2rFjB40aNYoOHDhAL2vlypWkra1N48aNo9u3b6vdPisri/T09Khdu3a0c+dO+uyzz2jevHlERJSTk0MtW7akxo0bU2BgIO3YsYNcXFyoUaNG9OjRIyIi+uKLL0hHR0elzGvXrhEAOnbsWIXn+sSJE6SlpUUeHh60YcMGCggIIB8fH7p8+bJwTrS1tcnPz4927txJ69atI1tbW2rRogVlZ2dXdM5GafpzyWooIvK1tLSk3r17l/sHs379egJAaWlpKss//PBDAiB8eEtNmzaN2rZtS4WFhcKygoICsrKyopkzZxIRkVKpVNnnzJkzBIBOnDhB9Eyg/Pbbb8I2W7duJQBCKBER+fn5kbm5ORERbd68mQDQxYsX1YaAOgqFgsaOHUt6eno0YcIEio2NfeG2t2/fJgC0bNmyMusCAwMJAJ0+fVpYFh8fT1Lxry6/AAAgAElEQVSplBYtWkT0EoFS3rlu0aIFOTg4UF5eXrl1a9WqFU2fPl1lWWRkJAGg33//vaJzxoFSAe7yqDF27FicOHECM2bMwIMHDyq9n4GBATp27Kiy7OjRowgNDYWhoSF0dXWhq6sLIyMjJCQk4P79+8C/035i//798PT0RMOGDTFhwgSgpHvwLD09PeH/S7sFOjo6wjJLS0ukp6cDAPr16wdTU1OMGTMGR44cUVv3x48fIz4+HvHx8UhMTFRZ5+zsjO3btyMyMhI5OTlwcnJCeHh4ueXY2tqiS5cuWLp0KX744Qfk5+cL686dOwcTExN4eXkJy6ytrdGiRQuVLmBlPH+u4+PjERkZiQkTJqick1J3795FeHg4AgMDhfdBV1cXbdq0AQDcv3//pc8Z+xcHihpLly7F2rVrsWfPHtja2iIgIKBS+xkaGpZZlpKSgv79++PWrVsqj/DwcKHcJUuWYNiwYWjfvj3++OMPrFq1CgBQXFz8UvWWSCTCxUlzc3NcvHgRTk5O6N+/Pzw9PcsExbO+++472NjYwMbGBt7e3mXWx8fHY/ny5Thy5AjGjRuHZs2avbAOx44dw7hx4zB79mw4Ojriv//9LwDgyZMnMDMzK7OPqalphXUrz/PnOjU1FQAgl8vL3b40nBcuXFjmvYiIiMC4ceNe+pyxf/G/NlZDIpHg448/xsSJE/HBBx9g+vTpaNu2Lbp27SpsU9m7Cg0aNEB6ejpatGhR7vq8vDwsW7YM77//PtauXQuUfFuKwcnJCUePHsWZM2cwZMgQjB8/HidPnix323fffRdt27YFABgZGQnLo6Oj8c0332Dv3r0YMWIEbt26BTs7uwqPa2xsjICAAMyePRuDBg3CoEGDkJCQAEtLS1y+fLnM9qmpqbCysgJKzv2rMDExAcpp1ZVq0KABACAnJ+eF7wVe8pyxf3ELRY3SW8NGRkZYvHgxAAh3CgwMDAAASUlJlSqrZ8+euHjxospdGwDIzs4W/pubmwsPDw9hXWm3RalUvtbrKO1ueHl5lbnb8bwWLVpg8ODBGDx4sEoLJSAgAEVFRfjnn3+wfft2tWGCZ86fjY0NZs6cicePHyMuLg6dO3dGRkYGrly5ImwbEhKCmJgYeHp6AgAaN26M/Px8ZGRkCNvEx8erPaajoyMsLS2xbds2FBUVCcuJCEqlEg4ODrC2tsaWLVuEcw8ARUVFKCgoeKVzxphaROTbv39/GjVqFAUFBdGIESMIAF24cEG46KilpUXdu3enbdu20YYNG4QLhU2aNClzITA2NpZMTU3J1NSUli5dSps2baJhw4bRoEGDhG1cXV2pVatWtH//fgoKCiIbGxuSyWT08ccfEz1zUfbQoUPCPrt37yYAFBMTIyxbsGAByWQyIiK6evUqWVtb08qVK+mnn34iU1PTF15orkjpnabKys/PJysrK5ozZw4FBQWRm5sbmZiYUHZ2NhUWFpKjoyPJ5XLauHEj/fzzz8IdrdK7ZeHh4SSVSmnMmDF0/fp1CgoKoiZNmpS5KFveuf7ll18IAHl4eNAPP/xAAQEB1KlTJ9qxYwcREf3+++8kkUjIxcWFAgICaN26deTh4UFr165Vd874oix7NUTku3jxYrK3tyddXV2yt7enjRs3qnxwt2zZQubm5mRiYkJeXl4VfsiJiCIiIqhfv36kr69PhoaG1K1bN9q7d6+wPiwsjNq3b086Ojrk4uJCv//+Oy1YsIBMTEwoPz//lQLln3/+IR8fH2rQoAGZmJjQoEGDKCEh4aXC4VVkZGTQhAkTyMLCgvT19aljx470119/Cevj4+Np6NChZGRkRPr6+uTj40MREREqZWzfvp3s7OxIT0+PevfuTUFBQZUKFCKi/fv3k5ubG9WrV48sLCxowIABdOXKFWH9kSNHyMPDg+rVq0eNGjWioUOH0s2bN4kqPmccKBXgAZYqwAMssXLwAEsV4GsojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKDUYMuWLYNEIoFEIhGm9GBlKRQK4Tw1adJE09Wp1ThQ3oCJEyeiT58+5a7r0aMHPv74Y7VlTJ8+Hb///rvKMoVCgZ49eyI5ORmrV68WytPX14e+vj4cHBzw5ZdfVmo82uTkZAwePBgJCQmVek1EhMWLF8PKygr16tVDkyZNhDFXX7asqubo6Ijk5GQMGzYMzs7Omq4Oq6uIyFeMgYbc3d3p888/L3edv78/7d69u8L979+/TwAoKipKZbmrqyvNmTNHeJ6Xl0daWlq0YcMGio+Pp6NHj5KWlhbt379fbR137txJFhYWlX5NW7ZsIRMTEzp27Bjdu3eP/vzzz5cqq6ioqNLHEou7uzvNmDHjdYvhAZbYqxEjUAoLC0lHR4f27NlTZp2dnZ3K6GsJCQnUt29fMjQ0JLlcTnv37qV79+6Rjo4OSaVSMjAwIHd3d6HcevXqUVBQkFBe6Zw1SUlJlJubS3v37iU9PT0KDw8ne3t7Wrp0qbBtZmYmGRkZ0YYNG+iXX34hLS0t0tbWJgMDA/roo4+ISoZwnD9/PsnlctLR0SEPDw8KCQkhKpljyNvbu8xrelFZhw8fJkNDQ/rmm2/IwcGBxo0bR0REiYmJNGbMGDI1NSUDAwMaNGgQPXnyhIiInj59Sh999BE1btyY9PT0yMHBgf7v//6PlEolOTg40OzZs8nV1ZV0dXWpXbt2tH37dnJzcyNdXV3q0aMHPX36VKhXcXEx6enpUWBg4Ou+pRwo7NWIESghISHlti6IiKKjowkAxcfHExHRsGHDqG/fvpSUlETnzp0Tls+bN4/69u2rsm94eDgBoGvXrgnLNm3aRABIKpUSADIwMKCDBw8SEdHgwYPpvffeE7b97rvvqEGDBsI4sZ07d6aVK1eqHGPAgAHk7OxM165do8zMTBowYACNHz+eiIgOHDhAMpmMvv/++zKvq7yyli9fTlKpVBjT9enTp5Senk7W1tY0bNgwiouLo5SUFGratCkFBQWRUqmk3r17U8+ePSkxMZFyc3OpefPmtGnTJiIiMjMzo7feeovi4+MpPDycdHR0qHv37nT//n36+++/CYDK7IgxMTEEgP7+++9Kv3cvwIHCXo0YgbJ9+3YyNDSk4uLiMuv2799PxsbGwvPBgwdT27Zt6d69eyrb9ejRQ5hNr9Rvv/1GEolEZeDoadOm0aBBg6i4uJju3LlDPj4+1KRJE8rLy6MvvviCOnbsSFTybW1nZ0dz584lKpm9UFdXl86fPy+U9eeff6rMyHfnzh1q1aoVrV69Wthm586dZGhoSAMHDhTqUV5ZRESjR4+mwYMHqyybN28eNWzYUGhJnDt3jvT19enq1avCdKoPHz4kKgkgmUxG//zzD+Xk5JBUKhXGp83PzyctLS06efIkUUnrTSqVCrMtUkkAAqDHjx+recfU4kBhr0aMQPn000+pS5cu5a5bvHixyroHDx6Qr68v6erqCt/wxcXFZGRkRMePH1fZd8GCBWRra6uyrHPnzvTll18Kz69evSpMUbpr1y4yMTEhIqKDBw+STCYTguvq1askk8lUugjz5s0jQ0NDMjIyovr165OpqSl9/vnnZYIxJiaGmjdvTlOnTn1hWUREbdq0oR9++KFMfRs1akT6+vpkYGBAdnZ2tHPnTiIiGjRokEqL6uzZs2RgYEBFRUXC6yoNh9KBu0tHyw8NDRW6fqWWLl1KlpaW5b4PL4kDpQJ8l6eK3bp1C25ubuWuCwkJgaurq/DczMwMv/32G3744QfMnTsX6enpCA8PR1ZWFtzd3VX2VSgUKncslEolQkJC4OLiIiwrvetiamoKZ2dnPH78GA8ePMC6deswdOhQYWa9K1euwMnJSZhnqJSbmxsyMjJw9+5dPHz4EP7+/pBKVT8y9vb2mDx5Ms6fP//CsoqKihAZGanyWktNnToV6enpSE1Nxe3btzF69GgAQFxcnMq8P3/88Qfatm0LmUyG0NBQNG/eHPXr1xfOo7m5ORo3biw8b9SoESwsLIT9w8LC+A7PG8CBUsX++ecfmJmZITIyUngkJycDAEJDQ4U/soiICOzcuRPp6elISkpCo0aNYGJiIsynfOPGDcTExAizFD4fKDExMcjOzkbjxo0RFxeHoKAgTJ48GUOHDoWFhQVatmwJPT09+Pv74/Tp0/joo4+EfR88eIC0tDTExcXhzp07AIBOnTrhypUrOHLkCJRKJU6dOiVM2pWSkoLAwEBcuXIFf/75J3bs2IF27dq9sKyYmBjk5+erhF3pMXbt2oXIyEjk5ubi1KlTwjq5XI6oqCgAwKVLl7BhwwZhFsOQkBC0bt1a2Fbd89Lz9fzxGXujXrfLk5CQQADKPObNm0e5ubkkk8mEaw3bt2+nZs2akb6+PnXp0kW4dpGTk0Ndu3YlLS0tsrCwIKVSSXl5eSSTyYTuAT0zN49EIiEjIyNyd3enZcuWUV5enrDNxx9/LEx+9SyFQkFWVlakra1Nvr7/e8nz5s2jJk2akL6+PnXu3JmUSiUREV28eJFcXFxIT0+PmjRpQhMnThS6H+WVtWfPnnJvI2dkZNCwYcOofv361KBBA2EyMyqZF8fV1ZWaN29O7u7u5OvrS9bW1kRE5OXlpdK16927N82ePVt43rdvX5WyioqKSEdHh7Zu3fpK7+NzuMvDXo1Yv0MR261btwgABQcHv9R+aWlppKOjI9xpqSsiIyMJAF29elWM4jhQKsBdnhqo9KfkJiYmePLkidrtHz58iL1796J///6wtbXFO++880bqqWlKpRIpKSm4dOkSJBIJWrVqpekq1XocKDVQWFgYiAg2NjZYuHCh2u0vX76MDz74AGZmZjh69Ci0tbXfSD017ebNm7CwsMCECRNgY2NT5qIzEx9PRVoBnoqUlYOnIq0At1AYY6LhQGGMiUZL0xWo5nIAPNJ0JTStqKhIBwC0tLTyNV2XaiBb0xVgrEabPHnygsmTJ6u/+svqPO7yMMZEw10eppZSqXzEXz6sMjhQmFpSqbQB/8SAVQZ/6zDGRMMtFFYZuUTELRSmFgcKqww9iUTCgcLU4kBhlZGpVCq5e8zU4kBhlWEslUq5hcLU4m8dxphouIXC1FIqlfl8UZZVBgcKU0sqlerw71BYZXCgMLWUSuUTiUTC3WOmFgcKU0sqldbnFgqrDA4UplZxcXEm3+VhlcGBwtSSyWTG3EJhlcH9YlYZSqVSSZquBKv++FuHlWvSpElJEonE4gWrkzdu3Nj0DVeJ1QDcQmHlIqJ9VDrvqepyUiqVv2umVqy640Bh5ZJIJD8CuFPOqjuFhYVrNVAlVgNwoLBybdq0KRrAn8+3Uojo+LZt22I1VzNWnXGgsBeSSqXfAYgvfU5E9/Pz87/VbK1YdcaBwl4oMDAwhohOlz4noqM7duyI02ytWHXGgcIqREQriOg+gESlUrlC0/Vh1VuFt40DAwMH16tXb8ybqw6rjjIzMzsCgLGx8RVN14VpVkFBwc4PPvjgwIvWq/ulbNtGjRoNa9asmfg1YzWRpaYrwDQnKSkJiYmJCgCvHCho0KABmjdvLnrlGGM1S3Z2NhITEyvchq+hMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4HCGBMNBwp7Ix49eoTDhw9ruhqsinGgsCqXmJiIVq1aYeXKlZquCqtiHCisyuXn5yM/P1/T1WBvAAdKNRYeHo7x48fDwcEBlpaW8PLywsGDB4X10dHRGDVqFKytrWFpaYmBAwfiypX/TZ2zfv16mJqaYsOGDfD29oZcLkf79u2xceNGYZuBAwfC1NQUv/76q7CMiODu7g5TU1OEhoYCAEJCQjB8+HDI5XJYW1vD19cXISEhZY713nvvYeDAgbC0tISjoyOioqLQrl07AIBCoYCpqSlMTU2F0dOLioqwatUqtG3bFubm5nB3d8eqVatQVFQklN28eXOYmprC398frq6uaNy4MVavXl1l5529Og6UauratWvo1asXDh48iPr168PZ2RnR0dHCH/G9e/fg4+OD48ePw8bGBi4uLvj7778xaNAg3Lx5U6Ws+fPnQ19fH4MHD0ZaWho+//xz7Nu3DwDw/vvvA4BKoJw7dw7x8fHo3LkzXF1dce3aNfTp0wdnzpyBk5MTbG1tcfr0afTt2xcKhULlWIcPH0Z6ejqGDBmC9957D40bN0bv3r0BAPXr18eQIUMwZMgQ6Ovrg4jg5+cHf39/5Obmol27dsjMzIS/vz+mTZtW5pysXbsWXbp0gaenJ0aOHFkFZ529LrXz8jDNmDVrFnJzczFnzhzMmzcPKLkWYWxsDABYuXIlHj9+jAkTJuDbb/+dv3zNmjVYsmQJ/P39sXfvXqEsX19fBAYGAgD69++PkSNH4pdffsHw4cPRr18/NG3aFH/99Rfu378PS0tLbN++HQAwefJkAMDs2bORm5uLzZs3Y+jQoQCAbdu24ZNPPsHy5cuxc+dO4VjW1tY4ffo09PT0hGXLli3DiRMnIJfL8fPPPwvLjx49isOHD6N169Y4evQo9PX1kZWVBW9vb+zbtw8zZsyAq6ursP2KFSswYcKEKjrjTAwcKNXQ/fv3oVAoYGRkhNmzZwvLn53B8dy5cwCASZMmCctGjx6NJUuW4NKlSyrlWVlZCf/ftm1bAEB8fDwAQCaTYfz48Vi2bBn27NmDcePG4dixY2jWrBn69++P+/fvIzQ0FNra2ggODkZwcDAAIC8vDwDKtIZ8fHxUwqQix44dAwAYGhrC399fWF66/82bN1UCZciQIZUql2kOB0o1lJKSApQEiLa2drnbPHz4EADQpEkTYVmjRo0AADk5OS+8CKqrqwsAKCwsFJaNGzcOq1evxq+//gptbW0UFBTg/fffh0wmE+pSWFiIgICAF5ZXytDQ8KVf58WLF3Hx4kVRy2aawYFSDdWvXx8A8ODBAxARJJKyc9o3bNgQSUlJSEtLQ4MGDYBn/kANDQ2ho6NT6eOZmZlh4MCB2LdvH9asWQM9PT289957wL8TpAMAzM3NER4e/lqvS6lUqjwvLXvNmjUYP378a5XNqge+KFsN2dnZwcLCAhkZGfjpp5+E5Q8ePBC6Kp6enkDJtYxSpddJ3nrrrZc+ZmnXKTMzE8OHDxdCyt7eHk2aNEFKSgo2b94sbJ+WlobY2NhKlW1kZASUdOVyc3MBAAUFBejatatQ7/T0dGH7Z+9UsZqFA6Uakkql+PrrrwEAX331Fdzd3dG7d2+4u7tj6dKlQMlFWwMDA6xfvx49evSAl5cXfvzxR+jq6uLzzz9/6WO2b98ebdq0AQB88MEHKnX56quvAABz585Fhw4d0LNnT7i7u2PBggWVKtvMzAw2NjbIzMxEhw4d4OnpiT179uDdd9+Fk5MToqKiVF5jnz59VG5Js5qDA6Waeuedd7Bjxw60a9cOKSkpiIyMhJ2dHXr06AEAcHBwwOHDh9GjRw/cvn0b0dHReOutt3Dw4EGVC5kvY+LEifD09ESrVq1Ulo8aNQpBQUFwd3dHQkICwsPDYWtrC29v70qXvWnTJrRu3RppaWlITk5Gw4YNoa+vj8OHD+O9996Dvr4+goODkZOTg6FDhwrdPlazlO2cPyMwMHChs7Pzguc/YIyxuicsLAzh4eGLPvjgg4Uv2oZbKIwx0XCgMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4HCGBMNBwpjTDQcKIwx0XCgMMZEw4FShYYPH46PP/5YZdmlS5dgamqKpKQkYe6b8h6lI85nZmbCzc1NpYzU1FRhsOlS7u7uWLdunfB85syZLyzb2dn5hXUOCQmBo6MjLCws0LZtW0yYMEGYm6emu3z5Mo+aX8V4TNkqpFAoyozUfv36dTRs2BBNmzbFb7/9BqVSifz8fLz99ttYsWIFunXrBgAwNTUFABw4cAB3795FRkaGsGzlypXIyMgQyszKysLdu3fh4uIiLPvss88wffp0oGTgJFdXVyHcKhqVPjg4GBKJBH/++SfS0tIQEBCAnj17Yv/+/ejSpYuo5+dN2717N7S0+CNflbiFUkVSU1Px4MEDdOjQQWX59evXhRHV7O3t4ejoiMLCQhARvL294ejoCEdHR2EE+127dgEAoqKiAACxsbHYsWOHyqj2CoUCRITWrVsLy5o1awZHR0c4ODjg7t276Ny5s1B2dnY2hg0bBktLS7Rs2VJlFr7Q0FC4urqidevW8Pb2xp49e+Dk5ITvv/8eAPD48WPMnDkTdnZ2sLGxwaRJk/D06VNh/w0bNsDDwwPm5uZ46623QESYNWsWfH19hW3u3bsnzEoYGhoKZ2dnrFixAm3btkXTpk0xYcIEbNy4Ea1bt4ZcLsf8+fOFfZOTkzFlyhTY2dlBLpdjzJgxyMzMBEqm2VixYgUGDx6Mpk2bokOHDsLA2rNmzcLOnTtx5MgRyOVylRkYmXg4UKpIaTfBy8sLcrlceBw5ckSlJYGSQDAyMkLz5s1Vlt++fRvXrl2DpaUlIiMjAQBLlixB48aNUVhYKIwiHxoaCnNzc5iZmZWpx507d/D06VMhxOLj49G3b1/07NkTMTEx2LhxI5YvXy7M5RMSEqIyhKS2tja6du2Ku3fvoqCgAMOGDUN+fj6uX7+Ov/76C1evXsX69euBkgm91q5diyVLliAqKgqbNm2CRCJBeHi4ymsOCwuDtrY2nJycoK2tjeTkZDx69Ajnzp3DmjVr8Mcff+Du3bv466+/MGvWLGzYsAGZmZnIyMiAj48P8vLycPbsWdy4cQPBwcE4cuQIAODJkyc4fvw4lixZglu3bkGpVCIoKAgA8M0330Amk+Hw4cNISEjAwIEDRXmfmSpu/1WR0NBQtGnTRmWmvMzMTHh5eZUZ87X0W/r56TJ2796NDh06oHXr1oiKisLNmzdx/PhxfPvtt5g+fTry8/Ohp6cHhULxwnFkQ0NDoaWlhZYtWwIlgeTp6YmpU6cCJSPkN23aFGFhYejYsSMiIiIwZcoUlTIePXoEY2Nj7Nq1C4mJiTh27Bjq1auHBg0aoGvXrggPD0dqairWrVuHbdu2wcfHB3hmOpCIiAhhylOUBIqDgwPq1auHxMRE6OjoYMmSJdDS0kLTpk0hk8nw1VdfQVdXF+7u7pBKpahXrx7WrVuH7OxsBAQEwMDAABcuXMCTJ0/g5OQElIRnYGCgEF7W1taQSv/9zrx16xZkMlmZMGfi4hZKFSntOtja2gqPgoICACg3UJ5fplQqsWfPHowdOxbOzs6IiorCokWLMHnyZDg4OACA0O0pb/9SCoUCDg4Owjw9p06dQvfu3YX1RISMjAw0atQIsbGxyM7OVrloW1BQgPPnz6Ndu3Y4deoUOnfujHr16gnr09PT0ahRI1y6dAkymUyYx7jU/fv3kZmZqVJmWFiY8IcdHh4OJycn4dpGWFgY7O3thUm+oqKiYGtrC11dXfz999+QSCRwcnKCXC7HzJkzsXbtWmHw7OePc/v2bTg6OgIAbty4AVdXV5W6M/FxoFQRhUKBFi1aqCyLjIyErq6uEAgo+YOOiIgo88159uxZZGVlYdCgQWjVqhUuXLiAiIgIzJo1S5hNMD8/H0VFRYiMjKywhVK6TqlUIjs7W2W2wdOnT6O4uBjdunVDaGgo9PT0YG9vL6xftGgRHj9+jPfffx+ZmZkwNzcX1mVkZODChQvo1asXsrKyoKurK7QInn3N2trawmsmIly/fl0lUJ597eHh4WXC59nnfn5+iImJQWRkJG7cuCFcmwkLC4OxsTEsLS2BktZgQkKCMIL/jRs3hGlCWNXhQKkCOTk5uHPnjtAULxUZGYmWLVtCJpMJy+7cuYOsrKwygbBr1y4MHToUBgYGaNmyJZRKJebNmwdjY2PhWzY/Px/R0dHIz8+HgYEBoqOjhUfphcpnu0NSqRTOzs7Yv38/cnNzERkZiXnz5uGTTz4RLpLK5XJER0fj5MmTGDNmDLZu3YrAwEDY2NjA1dUVZ86cQUpKCh4+fIiZM2eiXbt26NWrF9zd3fHkyROsWbMGaWlpOHfuHBISEpCbmwulUokHDx4gPz8fX3zxBRITE4WQCAsLU5m24/kACQ8PF9a3a9cO+/btQ0xMDPLy8oT5ncsrR6FQAIDQ1UtLS0NcXBxSUlKQlJQkwrvMysOBUgXCwsKgVCrLbaGUd0H22WscKLm4eOzYMYwdOxYAYGBggD59+gjTg5a2UPLy8oQ/nBEjRqBTp07C4/r163j48CGSk5NVjvnDDz/g7t27sLe3x9ixYzFp0iTMnTsXKGnNREdHo3v37pg1axZMTU1x/vx54QLm7Nmz4ejoiI4dO8LT0xOWlpb45ZdfIJFI4OzsjFWrViEoKAitW7fGV199BS0tLXh5eaF9+/bo2LGjyjw+zs7OKCoqQkxMjBAgSqUSUVFRwnMiQmRkpPB8zpw5cHV1xcCBA9G+fXucPHlS5Zw/HyjNmjUTruP4+fnh2rVr8PDwwKFDh17r/WUvxvPyMMYqheflYYy9URwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBwojDHRcKAwxkTDgcIYEw0HCmNMNBworFIePXoEU1NT3LhxQ9NVYdUYB3/PYsUAACAASURBVMobVFBQgDVr1qB9+/awsLCAu7s7VqxYgcLCwkqXMXfuXBw6dEhl2cCBAzF//vwqqPH//PPPP9DS0oKzs3O569PT0+Hi4oL9+/dXaT0A4PLly5gwYUKVH4e9PC1NV6CuKC4uxpgxY6BQKLBw4UK0aNECN2/exBdffAEA+Oyzz9SWkZSUhM2bN2Py5Mkqy728vGBlZVVldQeAkJAQtGjRArq6uuWuNzIywn/+8x/Y2dlVaT0AYPfu3dDS4o9udcQtlDckMDAQ//3vf7F//36MGDECrVu3xvjx4zFy5EgcPHgQADBnzhz4+fnhnXfegbW1Ndq3b48jR44AABITE+Hh4QGpVIoePXqgR48eAAAPDw8sXrwYBgYGAAClUok1a9agdevWsLS0RN++fREdHQ0AOHnyJLp3744ff/wRzs7OkMvlKi2bu3fvYsyYMbCysoK1tTV69eol7Hvr1i20bdu23NeWlJQECwsLbN26Fc2bNwcA+Pv7Y+rUqZgxYwasra3h4OCAffv2AQD27NkDb29vzJo1Cw4ODmjZsiVWrFghlNepUyesW7dOeL5r1y7Y2NgAAGbNmoWdO3fiyJEjkMvlwrnbunUr2rRpA0tLSwwbNgxFRUUoKChAhw4dMGXKFBHfSVYRDpQ3gIgQEBCAkSNHwsnJSWVd06ZNkZ6eDgBIS0tDbGwsvvrqKwQHB6Njx46YOnUq8vPz0axZM0ybNg3e3t5ISEjA2bNnAQC//fYbAKBVq1YAgC+++AJ//PEH9u3bh8jISJiYmGDu3LlASdiEh4eDiHDp0iV8+eWX2LBhAx4+fIi0tDT069cPdnZ2iIiIwKlTp3Djxg2hJRASEoI2bdqU+/qaNm2KdevWwcrKCsbGxgCAnJwcnD59Gn379oVCoUC3bt2wZs0aAEBmZibi4uLQu3dv3LhxA5999hlWrFiBK1euID8/H7GxsXBxcRHKDwsLE7pa33zzDWQyGQ4fPoyEhAQMHDgQERERmDVrFr799lsEBwdj4sSJ0NLSglQqRf369YU6sarHgfIG3L59G8nJyRgwYECZdffu3UOTJk2AklbI+PHj4eLiAlNTU7z//vt4+vQpEhMTAQDXr1+Hh4eHyv6RkZEwMjKCXC5HdHQ0Nm7ciJ9++gmOjo4wNDREv379EBYWBgCIjY2Fq6srZsyYAWNjY7i5uQEApFIp/P39YWlpiUWLFsHAwAD37t1DgwYNYGv7/+ydd1gU1/rHv7sgHQQEpEkTBKSIIqCxYzeWEEnRYOzRaCTeaPTasGv0WlIssUSNLRpzLTGKUdAYosaCImV36SDSOyidfX9/XPb8GEFBXUXj+TwPj+6ZmXPOzOx8zztnZt+vHROAxwkKAEilUiZqAJCUlIQPPvgAQ4cOha6uLlxcXCAWi9l+9uvXD4MHD4aenh4mTJgAXV1dxMXFITY2FrW1tYK5GolEwgQmIiICKioqAsGpqakBAKSkpMDIyAjDhg0DAKiqquLChQtYv379M5w1zrPABeUloIhALC0tBeXV1dW4dOkSevToASJCbGys4EIqLCwEABgYGEAulyMiIqKBoEgkEjg7OwMAQkND0aZNG0Ed+fn5MDIyYuvWX5aQkABjY2Po6+vjxIkTGDduHFt269YtJjhRUVEQi8WPnZBV1F1fUOpHFagTsw4dOgB14lN/WVVVFR4+fAhDQ0NIJBIYGRnB1NRUULdi/fDwcLi5uUFNTY0td3Nzw+7du7Fp0yb4+voiLS3tsf3kvFi4oLwEFBFIYmKioHzPnj3Izs7GpEmTkJqaigcPHsDJyYktDw4ORteuXWFgYIDY2FiUlpY2iBLqX8glJSWsLQWnT5/GwIEDgbqLXCE+is8dO3ZEcXExiouL2TyFom2FoERHR8POzg6ampqP3cf6/SgtLUVaWppAYKKjo9nnR8UnODgYGhoa6NGjB2QymaCPSUlJyM3NZRFJeHh4o5HSu+++i+vXr6O8vBzffffdY/vJebFwQXkJ2NraomvXrli6dCkuXbqE8PBwLF++HEuWLMGaNWvg4OAAiUQCbW1tZGdnIzMzE99++y0OHz6MVatWAXXzK6h7fJuYmAgiAh65ON3d3REfH49bt26hoqICGzZswP379/HZZ5+htra2QQSkuMj19PSgq6uLhIQEAMC2bdsQGRkJHR0dAEBBQQFQ96SqMbKzs5GXlycQDLFYzOaLampqEBsbi44dO6KkpATp6ekoKytDYWEhTp8+jS+//BILFiyAvr4+KioqUFBQgOrqauTk5ODzzz+HiooKE9rc3FwkJycjKysLGRkZQJ0wx8XFIScnB2VlZUwY9+zZg27durH1OC8eLigvAZFIhL1798LBwQETJ07E6NGjcffuXRw9ehSTJk0C6i5CY2Nj+Pv7w9PTE8HBwTh27Bi8vb0BAF5eXvDx8cGYMWPYXExFRQWSkpLYhTx06FBMnz4dY8eOhbOzMyIiInDmzBmYmJggISEBFRUVDW5LnJ2dIRaLsXnzZqxfvx5eXl4ICQmBj48PYmNjAQCjR49Gq1atHvtoWyKRQE1NDfb29qxee3t7qKurAwDi4uJQVVWFjh07QiKRQEdHB99++y06duyIVatWYdGiRZg5cyYAICAggEVqEyZMgImJCdq3b8+io0mTJuHmzZvw9PTE6dOnUVZWhpMnT8LX1xcjRoyAn58fe6z+4MED5OfnP9V7PpznQ/SkhTt27Fjm4uKytP6XkPNimDx5MqytrREUFNTSXXmh7N27Fz/99BPOnz/f0l3hPCUxMTGQSCTLp02btuxx6/AI5RVBIpHAwcGhpbvxwpFIJGxylvPPgwvKK0BVVRUSExPfGEF5E/bzTYW/v/wKoKamhpycnJbuxktB8eYv558Jj1A4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBheUfyAymaylu9CATZs2wdDQEIaGhpgzZ85LaXP06NGszRMnTryUNt90uKC8ImRlZSEgIADp6enPVc93332HkJAQAMC1a9dgaGiI+/fvC9ZxcXHB1q1bm6wrLy8Prq6uSrkYpVIp+vbtC6lUihUrVoCI4OnpCTMzMzg7O2PkyJENfI/XrVuHvn37Nqv+efPm4fTp0w3anDdvHqRSKYYPH/7YbZV17DlvqKDEx8fD398f1tbWGDlyJOLj41u6SwgLC8Pt27dhYWHxzHX88ccfCA4OxowZMwAAUVFRMDQ0hKWlJVsnNzcXmZmZcHNza7I+XV1dDB48GO3bt3/mPimQSqVwc3ND27Ztoa2tjcTERCQnJ2P37t3Yu3cvnJ2dMW7cOHz99ddsm06dOmHQoEFN1p2RkYHdu3fD2dmZlRUVFSErKwuenp5o27YtWrVq9djtm3Psa2trn2p/31TeSEEJDAzExYsXUVpair/++gszZ858pno+++wzzJgxAyNHjoSVlRXc3d1x4MABfPjhhzA3N4e3tzckEglb/8iRI+jRowfMzMzg4eGBkydPAgB++eUXzJw5E/n5+WjXrh0WLlwIAHj48CEWLlwIR0dHWFhYwMvLq8EorKC2thbz58/HzJkzIRb/77RGRUWhU6dOgvUiIyMBAG5ubrhw4QL69OmDLVu2wMXFRdB2RkYGzMzMsHfvXtjY2AB1F2lgYCDat28PW1tbTJ06FQ8ePAAArF27Fp9++ilmzZoFa2trODg44JdffgEA1NTUICEhAU5OTqwf0dHR0NLSwtChQ9GtWzesW7cOkyZNwtdff43a2loEBgZi7NixKC8vZ9tcunQJAwYMYFFNbGws0tPT4enpCbFYjH79+qFfv35AnYABELR59epV9OvXDxYWFujZsyfi4+Mfe+zPnz8PKysrbNiwAV5eXggMDHym78ibxhspKBEREYLPUVFRz1TPw4cPcfnyZSxevBh37tyBoaEhvvrqK8yfPx/h4eEoLy/HoUOHAABbt27F/PnzsWDBAsTFxWHChAlYtmwZAMDf3x+dO3fG4sWLkZaWhjVr1oCIMH78eMhkMvzxxx9ITExEdXU1ioqKGu3L2bNnUVxcjCFDhrCyyMhIuLu7C9aLjIyEpaUlDAwMIJfLIZFIQES4du0aFi9ejO+//x75+fkwNzfHN998AysrK+jp6aGqqgqjR49GZWUlbt26hbCwMNy4cQPbt28HAJSVlSE0NBTDhg1DdHQ0evfujU2bNgEAEhMTUVVVJbi4IyMj0bFjRyZ+ANC3b1+UlJSgsLAQX3/9NSwsLNCxY0cAwMWLF/HRRx/h3XffRWRkJH777TdYWVnBwsICM2bMQP/+/ZGWloZLly4BdYKio6PDojMiwoQJEzB48GBERUVh7ty5sLOza/TYK7YvKyuDlZUVbt68ifXr1z/Td+RN440UlPqhMQDY2to+Uz3p6emYOHEivL290aZNG2hra2Ps2LHo3LkzzMzMYGVlBU1NTRQXF2Pt2rX44osvMHz4cBARoqOjWT+qq6sRFRUFT09PVveJEydw48YN/PDDDzAzM0NtbS3S09PRpUuXRvty7NgxdOvWDSoqKgCAqqoqxMbGNhqhKEQmMTERbm5umDVrFvT09NC5c2cAYBe5VCplF/Thw4eRnp6O7777DgYGBrC0tESPHj1YBJaUlIQPPvgAQ4cOha6uLlxcXAT1iEQiODo6sn5ERUXB1dVV0LfCwkKIRCLo6uqitLQU6enprP2goCBMmjQJM2bMgLGxMdq3bw9NTU0AwK1btwTHTtGmk5MTRCIRUCcotbW1SE1NhYaGBt555x2oqKg0euwBQCKRYOjQoXj//fcBANra2s36TrzpvJGCsmTJErz11lvQ1dWFt7c3Vq9e/dR1EBFkMhlcXFxYmUQiEXyOi4uDs7MzwsPDUVZWhu3bt8PW1hbOzs6Qy+X47rvvgLqLq7q6WnDxHz9+HMOHD4eBgQEA4M6dO9DQ0BCM8vX566+/mCCg7klPVVVVoxGKYv7k0f4mJCTA2NiYtSmRSNgFHRISgu7du0NNTY2tn5eXByMjIwBATEyMoK7ExER06NABABAbGwtra2toaWmx5dHR0Q0E5cKFC3Bzc4O6ujokEglUVFTg6OiI3NxcSCQSjBo1qsF+y+VyRERENBAEmUwmOFZisRjHjx9HbGwsPD09WSTT2LFHnSD17t270WPNeTxvpKD069cPv/32G1JTU3Hu3Dl23/00pKam4sGDB+yiuH//PoqLi9lFlZmZifz8fPZZJBIhMjISd+7cQVpaGvbs2cMuxvDwcNjb2wtGwdTUVDZ3AQDBwcFwdXVlEUh98vPzUVRUBCsrK1aWmJgIAKwN1AlccnIyu1BiYmIE0VpMTAwTEDwiKCUlJTA1NWXLCgoKcOXKFQwcOBClpaVIS0sTbBsdHc0+K6IFBTk5OcjOzhZMDJ85cwZnzpxh81kxMTGws7ODhoYGm6dRRCT1iY2NRWlpaQNBeFRQUDfJGxISgj59+mDRokWPPfY1NTWIj48X7A+nebyRgqIMYmJioKenh3bt2rHPmpqa7ImIRCKBuro67O3t2ai7efNmyOVyyGQyJCUlsbry8vKQn5+P1NRUpKSkAAAsLCyQkJAAALh58yb27t0LHR2dRvtSU1MDANDT02Nl1tbWAIBly5YhMjISZ8+exfjx49GrVy9069YNtbW1iI2NFUQV9UUgOzsbeXl57LObmxsuXryIrKws5OfnIzAwEF27dsXAgQMhkUggFovZLU1NTQ1iY2MfKyj156yuXbuGRYsWYdKkSZg5cybee+89dvwU27dr1w7GxsZYv349MjIyEBUVhRs3bgB1T60A4O7du0hMTAQRITs7G/n5+YJbrODgYFy5coWJr52d3WOPfWJiIiorKwViu2zZMvj4+KC6urpZ3483FS4oz0j9L7zis5OTE5s3kEgk6NChA1RVVWFsbIxt27bh2LFjcHFxwaRJk1BVVcW29fPzg4aGBry9vbF8+XKg7rZMIpHAw8MD8+bNw+DBgxEXF9doX4yMjKCmpia4pejSpQs2btyIy5cvY8iQIVi8eDGGDh2KQ4cOQSQSISEhARUVFYJ9qB+xSCQSqKmpwd7eHgAwd+5cdOjQAT4+PujZsycsLS1ZXTExMbC3t4e6ujpQFwlVVVWhY8eOqKysRFJSkuDiVAjK0KFDMX78eCQnJ+PIkSNYsWKF4HgqtlFVVcXevXuRkpICT09PBAQEoLS0FADg5eUFHx8fjBkzBiNGjADqvdhXv80///wTAQEB8PLygoaGBjZu3PjYYy+VSmFqagpDQ0O2vYeHB5KSkvjj4yYQPWnhjh07lrm4uCzlod+rj7+/PyZMmPDEF7haAsUTn8uXLzfr3Rdl8P333+Orr75iEYcyOHPmDH7//Xd8++23SqvzdSMmJgYSiWT5tGnTlj1uHR6h/EOYOXMm/v7775buRgMUT3hat26NkpKSl9amnZ0dsrOzBe+xPCsJCQkICwvDf/7zH6X0758MF5R/CP369UP//v1buhsNkMlkICJ4eHhg3bp1L63NiIgIODs7s6c5z4O9vT2++uordkvHeTyqLd0BjvJ4lqdVL5olS5ZgyZIlL7XN33///aW2x/l/eITC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBhcUDoejNLigKInKykp8/PHHSqvP3t6eecrExsYqrd5nQS6Xw9zcnPUnJyfnhbd548YN1l63bt1eeHv12bt3L86ePauUunbt2sX2Y9KkSU9VpsxfS78suKAoiR07duD8+fNKS8Bz5coVrFq1Cmpqas22sUhPT4ehoSFu3brVYFloaChcXV2RnJz8xDr+/vtvTJw4UVCWlJSEiooKHDt2DDKZDCYmJtizZw9sbW1haWmJbt26YeHChcjOzmbbPI2nT2NtSqVSaGtrQyqV4ty5c0/cfv/+/fjqq6+abKc5lJaWYt26dc+cuPxRxowZw/KrKJJMNbcsPDxcYCvyOsAFRQnk5+dj06ZNLDG0Mmjbti0yMjJgb28PVdXm/YYzKioKYrG40dSF1tbWGDRokCBpUGP89NNPDdpTpCDw8fGBiYkJUJdpzdPTE2fPnsXcuXNx/vx5+Pr6oqCgAHhKT5/Hteno6Ii2bdtCX1//idt/++23MDMze+I6crm8yX4AwDfffIOcnBxER0c3a/2m0NHRgZaWFrKysljCp+aWDRgwAN98881rlSWOC4oSWLduHezt7WFtbS0Y2Z7ke9O1a1dmM4G6kdHa2hr79u1jZTKZrEGG/icRFRUFBwcHQeY2APj555/h7e2NiIgItG7dGqgL6zt16gRLS0uMHj0aNTU1mDNnDg4ePIgzZ86gXbt2+PXXX1k/2rVrJ0hBGR0djZ49e8Ld3R3+/v44deoUCgoKcPjw4UY9fR48eIB58+bB0dER5ubmzI70SW3WTxtZXV2NefPmwd7eHra2tiy7W/fu3ZGUlITFixfDysqKpYTs378/Pv/8c/j5+cHa2hppaWlNHr/09HRs374dfn5+DSIUPz8/rFu3Du+8847Ac+nYsWMwMzMTCNa6devg6urKUnM2lkGuOWWtW7dGdXU1wsPDm+z7qwIXlOckPj4e+/btw9KlS9G+fXvByPYk3xtnZ2eWMxYADh06BBUVFWbbgMckWn4SjWWSB4D33nsP77//viDH65w5c7Bx40bcuXMHkydPhqqqKlauXAkVFRX89ttvSEtLw8iRI9n69ftRXl6OhIQEQQY2CwsL2NvbIzU1tYGnj1wux9ixYxEeHo6jR49CJpMxd8Pmtrlv3z6cPXsWwcHBuHDhAnMUXL16NXR0dJCamop79+7B2NgYcrkcsbGxkMlk+OGHHyCRSFiO3SexcuVKdO7cGdOnT8e9e/dQXFzMlhUXF+PcuXNYtWoVIiIiIJfLsW/fPjg7O6OyspIJVlVVFfbu3YspU6awqEsmk0FDQ0Ng19LcMoX1x+sCF5TnZOnSpejTpw969eoFe3t7wcj2JN8bJycnJihyuRy7du3Cxx9/zKKLkpISZGRkPHWE8qhtBuoy7tfPgasYOVNSUmBkZIRhw4YBdQZoKioqDURJKpU2yI5fW1vbqK+OIlF2fU+fM2fO4M6dOzh8+DA8PDygp6fHboUaazM/Px+5ubmCNmtra1FaWorCwkLY29uzidpbt26hc+fOAsOwlJQUlJWVYePGjTA0NGyWp05ERAR++eUXLFu2DA4ODkCdQCtISkrCv//9b7i6usLExATW1tYQi8VwcHCAiooKO5fHjx9HaWmpYIJeJpOx9Z6mrKSkBJWVlYL8w686XFCeg7/++gvnz5/H0qVLAaBBhPIk3xsnJyfmqXz+/Hncu3cPU6dOZes2FhI/idLSUqSmpjYaoShsIRR1ubm5Yffu3di0aRN8fX3Z6BoeHg43NzeB9051dTWSkpIa2IgaGxujbdu2rCwmJgYZGRno2rUr23eFoFy+fBk+Pj6C9RU01mZjNqJTp07FtGnT4Ofnh6lTp6KiooJt35jJl6GhYaPH4nEEBQXh7bffRteuXaGvrw9DQ0M2OKSlpaGkpKTBuezQoQPU1dVha2vLzuWOHTvw/vvvC+aqGrt1bU6Z4ilPU/NDrxJcUJ4RIsKSJUugoqKC4cOHw8bGBitWrEBRURG7QJ/ke+Pk5ITi4mLk5uZix44dGD58uMCsWyaTQUtLq1mhOuouciJqNBF0QkICKisrBZO17777Lq5fv47y8nJmOBYeHt7A3yYhIQHV1dUNbETrt1NeXo45c+agQ4cOGDhwIPCIoDx48KBRT53HtSmVSqGrqys4HioqKli4cCEuXryIU6dOsaxst2/fbhCVPepI0BRnz57FlStXcOnSJdjY2MDGxgbFxcVscFBYpihsTUtKSgQ+RIpo8++//8bdu3cxbdo0Qf2N3bo2p+z69etQUVF5rFvkqwgXlGfk6NGjiI2Nxe3bt5GSkoKUlBRcuXIFqLv1aMr3pkOHDtDU1MTXX3+Ny5cvY/r06YL6pVIpOnTowEL5s2fPwsHBgY3ejxIVFYU2bdqgoKAAcXFx7K+6uhoSiQRt2rRhEcKePXsQFxeHnJwclJWVsXv23NxcJCcnIysrCxkZGawfYrGYuQAq9sPIyAgxMTE4duwYBg4ciPT0dBw4cACqqqoNPH26dOmC0NBQhISEICsri5moP6nN+p46lZWV2Lp1KzIzM5GRkQG5XA5bW1vU1NSgsLAQEokEmZmZbM6j/u0W6ozfHR0dcfDgwQbHraamBsuWLcPkyZNx7949di7ff/99FqE8aoCmEBrFYOHu7o6wsDBs2rQJffv2FYhCUVERMjMzBQNLc8uuXbuGvn37Nvlk7lWCC8ozUF5ejlWrVuHTTz8VjKKWlpZQV1dHVFRUk743rVq1woQJE7B9+3Z4eHjAx8dH0Maj4a+rqyvKy8sF73rUJzo6Gvn5+ejWrRv7e+utt1BTUyMYscvKynDy5En4+vpixIgR8PPzwyeffAIAmDRpEm7evAlPT0+cPn2a9cPGxoZFGIqJ5p9//hkDBw7E119/jWHDhiEsLIzNPTzq6TNx4kR8+OGHmD59Ory9vXHy5EnW78e1WX/f4+PjcfDgQXh6emL+/PnYsmUL3N3doaqqiqlTp+Lbb79F9+7dmVvio3M+bdq0gZmZWaOTm3v27EF2djbmzZsnKLezs0NsbCyqq6sbFRQLCwv2xMzf3x/5+fkICQlpMDA86xOe8vJyhIaGIjAwsNHz/arCfXlakPz8fLi6uuKbb74RPN1B3RdrxowZmDVrFlA3ygYEBOD3339Hq1atXlofx40bByJqdHR/UdjZ2eHLL7/Ep59+qpT6qqur4efnh82bNzPRUzaLFy/GuXPncPPmTWbQjrqnU0FBQUhNTWXlzSn74YcfcOXKFezZs+eF9PdZaI4vD8963wIUFBTgzz//xLZt22BjYwM/Pz+2LD8/H4WFhcjOzmajVW1tLVavXo0DBw68VDFB3Wg/YMAAZGdnw8jIqFFvZWWSkZGBoqIitG3bVmDG/jxs2LABCxcufCFicvPmTVy+fBk7d+7E1q1bmUBUVFSguLgYERERcHR0hEgkanZZamoqfv31Vxw4cEDp/X3R8FueFuDWrVv44osv0KZNGxw9epSJBBGhS5cu8Pb2BuqFvyoqKti6davg9uplUFFRgZSUFOzcuRPOzs7MtPxFogj9p0yZgtGjRyulzgULFuCtt95SSl2PEhQUhKNHj2LlypXMlxkAdu/eDWdnZ+zfv5+dx+aWRUdH48cffxR4Vb8u8FseDofTLLgVKYfDealwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwpH6axfv17wuxbOmwMXlBZCmV4yjdGY183TeOU8D7GxsS8sTQDn1eaNFJT4+Hj4+/vD2toaI0eOZPlAXybK9JJpjMa8bp7GK+d5iI2NZcmVioqKWP7XF0FtbW2j5eXl5S+sTc7jeSMFJTAwEBcvXkRpaSn++usvzJw585nrOnLkCHr06AEzMzN4eHiwbGSbN2+Gvb09ysrKQET48MMP8dZbb+HBgwdP7SWza9cudO3aFWZmZnBxccGaNWtY+99//z08PT1hamqKXr16gYga9bppzCunqKgIgYGBaN++PWxtbTF16lSWomDt2rX49NNPMWvWLFhbW8PBwUGQuvFx1NbWIjExEfb29qioqEBAQAC+/fZbxMbGwtDQkO3rgwcPdpPizgAAIABJREFUBLdFycnJMDMzQ1xcHB4+fIiFCxfC0dERFhYW8PLyYtncgoKCMGLECHz66adwdnbGkSNHAAAHDx6Ej48P2rVrh7fffht9+vRBWVkZrl69in79+sHCwgI9e/ZskcHjTeKNFJSIiAjB52e1ndy6dSvmz5+PBQsWIC4uDhMmTMCyZf/7Zfe0adPQqlUr7N+/H9u3b8f169dx8OBB6OjoPJWXzMaNG7Flyxbs2rUL9+/fR8+ePVkqwzVr1mDz5s1YtWoVYmNjsWvXLohEoka9bh71yqmqqsLo0aNRWVmJW7duISwsDDdu3MD27duBulSRoaGhGDZsGKKjo9G7d2+BMdnjSEpKQmVlJaysrDBu3DhoaGhg9uzZcHBwgKamJsuJu2HDBoSGhiI9PZ19Hj16NBwcHDB+/HjIZDL88ccfSExMRHV1NYqKioC6hE8ymQwzZ85ETEwMRo8ejbNnz2LRokX47rvvEB8fDxUVFTg5OUFTUxMTJkzA4MGDERUVhblz58LOzu6ZzjWnebyRGducnZ0FolLfWKm5FBcXY+3atfjyyy8xfPhwlJSUIDo6miXJ0dLSwhdffIENGzbgwYMH+PHHH9mXuTleMgBw//59rF+/Hj/99BPz9ElOTsbo0aORnZ2Nb775Bj/++COGDBkC1DnNoQl/HUVum8OHDyM9PR3BwcFQU1ODgYEBevToAYlEAtQJwwcffIChQ4cCAFxcXJplsyqTyaCmpoYvvvgCYrEYBw8eZBYZzs7OkEgkMDc3x65du9CmTRuEhoaiV69eOHXqFK5evYoTJ07gxo0buHv3LgwMDPDw4UOkp6ezzO8KkzLFvmloaODEiRMYPXo0S0xlbm6OiooKEBEzytLQ0MA777zz1OeZ83S8kRHKkiVL8NZbb0FXVxfe3t5YvXr1U9cRHh6OsrIybN++Hba2tnB2doZcLmeWFADQq1cv5ObmYtCgQRgwYIBg2+Z4yZw+fRpt27aFr68vUJf9PSoqCl26dMG1a9egoqLCHPQe7dujXjd4xF4iJCQE3bt3F6xTP+ViTEyMIGN/YmKiIPP944iNjUVVVRX++OMPFqEocHV1hUQiwb///W9MmDAB/v7+CAkJwcaNGzFmzBhYWVnh+PHjGD58OAwMDAAAd+7cgYaGBrMdycjIQJ8+fQRt6ujoIC8vj+37qVOn8Pbbb0MsFuP48eOIjY2Fp6cnLl261GT/Oc/HGxmh9OvXD/369XvuekQiESIjI1FWVgY9PT1BxPHw4UNMnjwZ1tbWuHDhArKysmBqagrUecmMGTNGUFdjXjL37t0TRE+hoaGorq6Gu7s7s62s36aCxrxuFG0oHO0eNa4qKCjAlStXMGXKFJSWlgp8Z1CXlnDEiBFNHpPY2FiMHDkSTk5OmD9/Pnr27Ik2bdoAdYKyYsUKtG7dGvv27cP169cxfvx4qKio4O+//wYApKamCtoJDg6Gq6srVFRUIJFI0KpVKzbhq2Dx4sVYsGABunXrhszMTMyZM4fNz3Tq1AkhISGYMWMGFi1ahKtXrza5D5xn542MUJSBm5sb1NXVsXnzZsjlcshkMiQlJbHlgYGBUFVVxcWLF6Gnp8ceETfXSwZ1fsFpaWmoqKhATk4Oli1bhlatWkFdXR1dunRBcXExNm3ahNzcXPzxxx9sErcxr5tHvXLc3Nxw8eJFZGVlIT8/H4GBgejatSsGDhwIiUQCsVjMvHFqamoQGxvbLPMsmUyG7t27Y+7cuWjXrh3+9a9/CY7ZgwcPsG7dOujo6KBnz54QiUQYN24ce+JlYWHBbD1v3ryJvXv3MpN2qVQKBweHBom627RpA3t7e6Snp+OHH35gRlvBwcG4cuUK8vPzUVRUxOdPXgJcUJ4RY2NjbNu2DceOHYOLiwsmTZrEPGi3bt2KS5cuYf/+/TAwMMCsWbNw6NAhxMbGNttLBgA+/vhjtG/fHp6enhg1ahR69+6NyspKpKamwsXFBf/5z3+wb98+uLu7Y8mSJewxcWNeN4965cydOxcdOnSAj48PevbsCUtLSxw6dAgikQgxMTGwt7eHuro6ACAuLg5VVVVNCoriCY+zszNUVVXx/fff49KlS/jpp58AAB07dsTw4cOZl7K6ujqGDh2K2bNnszqWLFkCiUQCDw8PzJs3D4MHD0ZcXBzbh8dZs/bt2xeDBw/G559/Di8vL5SWluLPP/9EQEAAvLy8oKGhgY0bNz7TueY0H56kmvOPIiMjA66urrh69WoDq0/O88F9eThKZ/LkyY+1Q/3mm2/g5eX1Uvsjk8lw8uRJvPPOO2jVqhW+//57ODo68jd1WwguKJyn4ocffmjpLgiorKzEn3/+ia1bt7I3gU+dOvXCDck4jcMFhfNa06lTJ5w9e7alu8Gpg0/KcjgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKEoiLi4ORNTS3XhuCgsLYWhoiPDwcKAu8765uTkMDQ1haGiInJycF96HGzdusPa6dev2wturj0wmQ1BQkFLqUmThMzQ0ZLlldu3axcomTZoEAMjJycHDhw+V0mZLwwVFCVy5cgVfffUVRKL/ZYOoqqrCpk2b4OXlBTMzM3Tp0gXr1q1DdXV1s+rLyspCQEAAS+CsYOTIkVi4cOEL2QcFd+/ehaqqKsvmlpSUhIqKChw7dgwymQwmJibYs2cPbG1tYWlpiW7dumHhwoXIzs5mdTyN/09j/kFSqRTa2tqQSqU4d+7cE7dXtr9RUFBQgyTmz0r79u0hlUpZBjsAGDNmDKRSKUxNTVlZTU0NJkyYoJQ2Wxr+48DnJDs7G7Nnz8aZM2eAuiRDAQEBiI6OxrJly+Dk5ITbt29j0aJFAID58+c3WWdYWBhu374NCwsLQbmvry+srKxe0J78j8jISDg5ObFcsFKpFCKRCD4+Pixz2rVr1+Dp6YmgoCDExcXhq6++wqlTpxAWFgZDQ8On8v9pzD9IKpXC0dERbdu2bXL7b7/9FrNmzXriOnK5vNFUmY9y6dIlhISEQF9fv8l1m4Oamhratm2L1NRU+Pj4AHX5b4kIWVlZLFmUubk5srOzcefOHZaM/HWFRyjPyZo1azBw4ECYmJgA/0tKhT///BMnTpzA+++/D3d3d0yYMAFjxozBr7/+CtQlr164cCF8fX3Rrl07DBkyhGWU/+WXXzBz5kzk5+ejXbt2LCLx9PTEihUroK2tDdRdJJs2bYK7uzssLS0xbNgwltnswoUL6NOnD7Zs2QIXFxdBPajL2xoQEAArKytYW1tj4MCBbNuIiAh4eHiwdWUyGdq1a8fEBHX5ZXv27Al3d3f4+/vj1KlTKCgowOHDhxv1/3nw4AHmzZsHR0dHmJubY86cOQDQqH+Qos36yZGqq6sxb9482Nvbw9bWFitWrACAp/Y3ehJyuRxBQUHw8/NDUVGRYBs/Pz+sW7cO77zzDszNzeHt7Q2JRIJjx47BzMxMYMi2bt06uLq6oqamhtUbFxcnyDQnk8mAOhcABaampggNDW2yn686XFCeg+zsbBw9ehTjxo0DABARtm7dijFjxrB7ZgXm5uYsM3tmZiby8vJw8OBB/Pnnn6isrMSCBQsAAP7+/ujcuTMWL16MtLQ0Zur1888/A3VpFAFg0aJFOHXqFH755RfIZDLo6+tj3rx5QN2XWCKRgIhw7do1LF68GN9//z3y8/ORm5uLt99+m4XjISEhCA8PZ1FCZGSkIMG1VCoVXNzl5eVISEiAm5sbK7OwsIC9vT1SU1Mb+P/I5XKMHTsW4eHhOHr0KGQyGWbMmAEAjfoHNdbmvn37cPbsWQQHB+PChQss0//T+Bs1xaFDh3D//n385z//gaampsCrqbi4GOfOncOqVasQEREBuVyOffv2wdnZGZWVlUx8qqqqsHfvXkyZMoUdz5SUFJSXlwv2R5FgvH4Ccrlcjnv37jXZz1cdLijPwcmTJ6Gjo8NGmoSEBGRmZjaaHf7evXto27YtysrKUFhYiLlz58Lc3By2trbw9/dnEUJ1dTWioqIa2GzIZDLo6uqiXbt2iIuLw86dO7Ft2zZ06NABOjo6ePvttxETEwPUWV64ublh1qxZ0NPTY2G0WCzG2rVrYWlpieXLl0NbWxv37t2DgYEB7OzsUFJSguTk5AaCUn8kjYmJQW1tbQPPn8LCQujp6bFtFMJ35swZ3LlzB4cPH4aHhwf09PTYrVBj/kEK0avfZm1tLUpLS1FYWAh7e3s2UdscfyNFRPckHj58iLVr12L27NkwNDSEra2tQFCSkpLw73//G66urjAxMYG1tTXEYjEcHBygoqLCkmofP34cpaWlzFkAj4lGZDIZ21ZBbm4uKisrm+zrqw4XlOfgr7/+EtzzKiIQS0tLwXrV1dW4dOkSevToAZlMBnV1dcH8guLJCupcDKurqxvYYNRP0BwaGoo2bdoIbDDy8/OZp45EIhEsS0hIgLGxMfT19XHixAkWUaHeRaloWywWs22rq6uRlJQkGF2jo6NhbGwsmN+IiYlBRkYGunbtytpXCMrly5fh4+PT6HxIY/5BivSS9ducOnUqpk2bBj8/P0ydOpV5JTfX36gptmzZArFYjE8++QQAYG9vj+joaABAWlpaA8uRhIQEdOjQAerq6rC1tWX2pjt27MD777/PziXqxMPc3JyJraKsvsAQEe7du9ek1/XrABeU5yAxMVEwSaq4aBSZ7BXs2bMH2dnZmDRpEiQSCRwdHdnoJJfLce7cOWYEFh4eDnt7+wYja/2LtKSkpMEFevr0aQwcOBCou8AfjSo6duyI4uJiFBcXC0Lt4OBgJijR0dGws7ODpqYmUHfhVFdXCy7uyMhIwe1OeXk55syZgw4dOrD26/f1wYMHrL5Hacw/SCqVQldXVzAhraKigoULF+LixYs4deoUfv/9d6DO38jd3f2xx6k5ZGZmYsuWLSgsLISzszNsbGzw+++/swglJiYGenp6bJAoKSkReBY5OTkhISEBf//9N+7evcssPBQ8Oh/UWJlMJkNxcTFzPnyd4YLyHNTW1jL7T9RZmnbt2hVLly7FpUuXEB4ejuXLl2PJkiVYs2YNHBwcIJVK0apVK+Tl5SEhIQEzZsxASUkJe1KRl5eH/Px8pKamIiUlhdVd/0Jxd3dHfHw8bt26hYqKCmzYsAH379/HZ599htraWsTGxgpG1OjoaHTs2BF6enrQ1dVlIfq2bdsQGRnJJlwLCgrYfqHu4haLxQLHwOjoaBgZGSEmJgbHjh3DwIEDkZ6ejgMHDkBVVbWB/0+XLl0QGhqKkJAQZGVlCQzXG/MPUjzhUVBZWYmtW7ciMzMTGRkZkMvlsLW1bba/UUZGBhwdHXHw4MFGz+GaNWtgY2ODtLQ0pKSkICUlBRs3bsS9e/dQXFzMxLj+/qPeLYy7uzvCwsKwadMm9O3bt4F4PHrLWFRUhMzMTEHZtWvXoK+vrxTzuZaGC8pzYGZmJhh9RSIR9u7dCwcHB0ycOBGjR4/G3bt3cfToUfYSk0QiQWVlJXx8fNC/f39UVlbi7NmzzHrTz88PGhoa8Pb2xvLlywEAFRUVSEpKYl/soUOHYvr06Rg7dizzaT5z5gxMTEyQkJCAiooKwUWgiFjEYjE2b96M9evXw8vLCyEhIfDx8WFPmEaPHo1WrVqxR9symQw2NjZsHxWTvT///DMGDhyIr7/+GsOGDUNYWBjLMv+o/8/EiRPx4YcfYvr06fD29sbJkydZvxrzD3r0diA+Ph4HDx6Ep6cn5s+fjy1btsDd3b3Z/kZt2rSBmZkZM5ivT0xMDH766ScsX75cMA+juB2Njo5uVFAsLCzYQOLv74/8/HyEhIRg+vTpgvpra2uRkJDQ5BOe06dP45NPPnlsJPc6wX15noPNmzcjJycHa9eubfY2Tk5O2Lp1K/r37/9C+6YMxo0bByJ67Oj+IrCzs8OXX36JTz/9VCn1VVdXw8/PD5s3b35h1hqLFy/GuXPncPPmTfZyI+rE0MfHByEhIczsfd++fQgKCkJqaipEIhGkUik++ugjhIWFNWsCuSVpji8Pj1Ceg48//hgSiaTZ6+fl5SEnJ6dZpuOvAlKpFJaWlsjOzma3QS+SjIwMFBUVoW3btmyC+3nZsGEDFi5c+ELE5ObNm9iwYQN27tyJ+fPnMzGRy+XIzs5mAuPo6IiKigpkZ2cjIiICjo6OEIlEqKiowLJly/Djjz++8mLSXPibss9BmzZt8Pnnnzd7fYlEAk1NzQZPgV5FKioqkJKSgp07d2Lnzp1ITk4WzBe9CBS3A1OmTIGbmxsuX7783HUq3u95EQQFBSEvLw8rV65k5uyo+/mCIgK1sbGBtrY2tmzZwn4jFBAQANSN+MuXL/9HORzyWx4Oh9Ms+C0Ph8N5qXBB4XA4SoMLCofDURpcUDgcjtLggsLhcJQGFxQOh6M0uKBwOBylwQWFw+EoDS4oHA5HaXBB4XA4SoMLCofDURpcUDgcjtLggsLhcJQGFxQOh6M0uKBwOBylwQWFw+EoDS4oHA5HaXBB4XA4SoMLCofDURpcUDgcjtLggsLhcJQGFxQOh6M0uKBwOBylwQWFw+EoDS4oHA5HaXBB4XA4SoMLCofDURpcUDgcjtLggsLhcJQGFxQOh6M0uKBwOBylwQWFw+EoDS4oHA5Haag2tcL9+/erSkpKql5OdzivKKK6f6mF+8FpQUpKStSaWueJgiISiU4WFhamFBYWKrVjnNeL3NzcUUQkMjExOdnSfeG0LCoqKhEt3QfOa84nn3yy9JNPPlnW0v3gvPrwORQOh6M0uKBwOBylwQWFw+EoDS4oHA5HaXBB4XA4SoMLCofDURpNvtjG4RBRrVwu54MPp0m4oHCaRCQSqaioqIiasSrnDYePOhwOR2nwCIXTJHK5vJAPPpzmwAWF0yRisdig3g8EOZzHwkcdDoejNLigcDgcpcFveThNIpfLC/ljY05z4ILCaRKxWGwgFov5HAqnSfiow+FwlAYXFA6HozS4oHA4HKXBBYXTHORyuZwnqOY0CRcUTnMQ80lZTnPggsLhcJQGFxQOh6M0+HsonCYhogo++HCaw2t/X0xEOwB80tL94HCUgINIJEpo6U48D3zU4XA4SoMLCofDURpcUDgcjtLggsLhcJTGP1ZQdu/eDZFIhKysrJbuyksjNTUVKSkpLd2NJxIQEAAnJ6eW7sZLo7a2FleuXGnpbrw0/rGC8qaRmJgIOzs73Lp1q6W7wqnH5MmTMW3atJbuxkuDC8o/hOrqasjl8pbuBucRKioqWroLnKeBiHYQEd25c4d69epFGhoaZGtrS0OGDCEAlJmZSQr2799Pzs7OpKamRtbW1rRq1Sqqra1ly8vKymjBggVka2tLampq5ODgQCtXrqSamhq6cOECAaBr165RfbS1tWn+/PlERLR582bq2bMn7dy5kywsLEhdXZ28vb3pwoULNGHCBNLX1ycTExOaM2cO1dTUsDoePnxIs2fPJhMTE9LV1aWuXbvSkSNH2PLNmzeTj48PHT16lNq3b09aWlrUs2dPkkqlRESUnJxMAAR/48ePJyKi2NhY8vX1JW1tbbK0tKRp06YJ9rk5lJSU0J49e6i6uvqptiMiOnLkCDk5OZGmpiZ17dqVOnfuTI6Ojmx5ZmYmjRkzhlq3bk1aWlo0aNAgioqKEtSRmppKAQEBZGxszI7p0aNHiYho0aJFpK6uLlj/5s2bBICCg4OJiKh169a0f/9+Gjp0KKmrq1Pbtm3piy++oBMnTpCbmxtpaGhQ165d6datW4J6kpOTyc/Pj3R0dMjY2JgGDx5MN2/eZMtHjRpF8+bNo0WLFpGJiQnp6+vT2LFjqbi4mIiIxo8f3+C8JCcnExHRmTNnyNXVlTQ1Naljx4703XffERHZt/T19MZDRDtkMhnp6emRnZ0dbd68mbZs2UImJiYCQdm3bx8BoI8++oj++9//0pdffkkikYhWrVpFREQ1NTXk6+tLrVq1orlz59KBAwdowYIFFBAQQETUbEEBQP369aOrV6/SkSNHSFdXlwDQtGnT6NatW7R8+XICQLt37yYiotraWurfvz/r+6FDh2jKlCkEgH744QdBvV5eXnTx4kU6f/482djYkLe3NxERVVRU0KFDhwgArVy5ksLCwiguLo6IiHr27EnGxsa0c+dO2rhxIw0fPvypRaGkpITMzMyoffv2tG/fPoEYPonDhw+z47F7925atGgRqaioMEEpKysjZ2dnMjExoR07dtCBAwfI1dWVjIyMqLCwkIiIMjIyyMzMjExMTGj9+vW0b98+mjx5Mm3atInoKQRFQ0ODtm3bRjdu3CB/f38CQObm5nT69Gm6dOkSOTs7k62tLRPNzMxMMjMzo969e9MPP/xAe/bsob59+5KGhgZFR0cT1QmKiooKjR07lm7cuEH79u0jNTU1+vLLL4mIKC4ujvr370+2trYUFhZGYWFhVFFRQaWlpUxgDx48SPPnz6cFCxYQF5RXACLaMWLECDIwMKCcnBz2pdq+fTsTFLlcThYWFtSrVy/BF2/y5Mmkq6tLpaWldOTIEcFF/ChPIyj1+zF+/HgyNjYmuVzOyuzs7OjDDz8kIqKff/6Z1NTUKD09XVDvhx9+SO7u7oJ6s7Ky2PJNmzYRAMrPzyciIqlUSgDo2LFjgnosLS1p0KBBje7T01BRUUE7duwgBwcHsre3px9//PGJwlJeXk7GxsbUu3dvwXoffPABE5QdO3YQAAoNDWXLU1JSSCwW0/Lly4mIaPr06aSqqkoymazRdporKDNmzGDLFRHdli1bWNn+/fsJAGtnxowZ5OHhIYjKqqqqyMrKigIDA4nqBMXZ2VlwbkeOHElubm6C/XVxcRH0LyEhgQDQmjVrHt2d115QXvs5lLKyMvG5c+cwbtw4GBsbs3JV1f//mVJ8fDzS09Px7rvvCrYdPHgwSktLERcXh+DgYGhqamL8+PHP3SdNTU32fw0NDaipqUEk+v9fOVhaWiIvLw8AcPbsWVRXV8POzg4aGhrs79ixY7h//76gXm1tbfZ/a2trAEBGRsYT+zJu3DicP38es2bNQk5OTpN9T0lJYX8PHz5k5erq6vjkk08gk8mwatUq/Otf/8LHH3/82Hr++usv5ObmYvbs2VBRUWHl9c/LH3/8AX19ffj6+gr2y8nJiU0uBwcHw9fXF46Ojk32/Uk8ek4U+6TA0tISAATnJSoqCjo6Ouyc6OrqIi0tTXBetLS0BOfW2tq6yXNiZ2eHt956C6tXr8Z3332HysrK59q3V4nX/seBGRkZ6tXV1bC1tX3sOsXFxQAAExMTQbmhoSEAID09HdnZ2TA3Nxd8+V8UIpEIRP/LV5SVlQVTU1NcvHixwXpqamqPrUOxrKam5oltrV69GiYmJlizZg327t2LdevWYebMmY9dv/5x/Omnn/Dhhx+yz7W1tfj555+xdu1aGBkZCZY9yr179xrU9yjFxcWCQUCBoaEh0tPTAQDZ2dkYMGDAE/dRGShEof55GT58OL766qsG6+rr6z+2HjU1tSbPiUgkQnBwMBYsWIC5c+diw4YNOHDgAHr37v3c+9HSvPaCYmxsXAXgiaOvYvTJz88XlGdnZwMADAwMoK+vzz43Rv1RSJkYGBggNzcXNjY2bOR8HhQXhAKRSITZs2ezx5efffYZPDw80KNHj0a3P3HiBPu/l5cX8L90bdi9ezfWr18PIsKSJUswbty4J4qvQiiaOi9///13g/Ls7GxYWVkBdRfvk94lepHnJS8vTynvzDx6TgBAT08PW7duxdy5czFq1CiMGjUKMTExL340e8G89rc8rVu3rnVwcMCxY8dQVVXV6DpmZmawsbHB2bNnBeW//PILtLW10blzZ/j6+uLBgwc4cuSIYB3FaKOIbuqHs1lZWc8drg4YMAA1NTXYvn27oLz+7UZzUNwOPRpuKx5b6urqYsWKFQCA27dvP7aed955h/1ZWFgAAAoKCrB69WrMmzcPMpkMEyZMaDKS8/DwgIqKCg4dOvTYdbp3746CggJcv36dlUVGRiI+Ph49e/YEAPj6+iI0NLTBC3v1z0tlZSUKCgrYMmW83DdgwABcvXoV4eHhgvJnOS9ZWVkNHukrzoutrS0CAwNRVFSEiIgIzcdU89rw2kcoALB06VIEBATgrbfewsSJE6GiooKvv/5asM7y5csxfvx4TJkyBYMHD0ZoaChOnDiBZcuWQVtbG+PGjcPWrVsxfvx43LhxA506dUJUVBRCQkJw+/ZtODk5wdraGqtWrULbtm1RWlqKhQsXPve7HwEBAdixYwe+/PJLJCcno0uXLrh79y5OnDgBqVQquPd/EpaWlrCzs8PGjRuhra2NgoICBAYG4r333oOenh4GDRrEBNXT0/Op+mhgYID4+Pgn3oI9Srt27TBx4kTs3r0b5eXlGDp0KDIzM/Hbb7/B1NSU7fvatWvx3nvvYcmSJVBRUcHKlSthYmKCGTNmAACCgoJw+vRpdO/eHYGBgTA1NcX58+eho6ODXbt2YcCAARCLxfj8888xe/ZsREdHY/78+U+1f42xbNkynDlzBoMGDcKcOXNgYmKCc+fOoaamBidPnmx2Pb1798aePXswffp09OzZEwYGBhg8eDAcHR3xwQcfwMXFBdu2bYO+vj68vb3LnrvjnOdD8R7Kli1byMbGhj2OU7wDUP89lO3bt5ODgwO1atWKbGxsaN26dYIZ+vz8fJoyZQoZGRmRlpYWubi40MqVK6miooI9PfD29iZNTU1yd3enkydPNvqUp7S0lNU5bdo0srCwEEzl9+nTh/r3788+FxcX0/Tp08nIyIjU1dXJ1dWV1q5dS1VVVY+t9/Tp0wSA7ty5w8pu3LhBLi4upK2tTU5OTpSSkkIrVqwge3t70tDQIHt7e9rZy0iyAAAgAElEQVS5c+ejTxZeGOXl5fTZZ5+RoaEhtW7dmoYPH059+vQRvIeSkpJC7777Lunq6pKWlhYNGTKEvV+jIDIykoYMGULa2tpkYGBA3bt3p8OHD7Pl+/fvp/bt25OmpiYNGjSIvSJQ/ynPnDlz2PqZmZkEgHbt2sXKLl26RAAoLCyMlUmlUnr77bdJS0uLdHR0qHfv3oKnaKNGjSJPT09BX+fMmUOtW7dmn2tra+mzzz4jPT09MjU1pQULFlBBQQFNnDiRzMzMSEtLi3x8fBTtvvZPeXiCJQ7n1YEnWOJwOBwFXFA4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEFhcPhKA0uKBwOR2lwQeFwOEqDCwqHw1EaXFA4HI7S4ILC4XCUBhcUDoejNLigcDgcpcEF5R/GoEGDIBKJIBKJcPTo0ZbuTotgZGTEjoFUKm3p7rxRcEFpISZPnoyhQ4c2uqxfv36YPXt2k3V89tlnOH78uKAsOjoaQUFByMzMxLvvvgsigr29PTQ0NGBmZoZ+/fo9VYKgV5nMzEy88847SEtLE5RHR0dj48aNUFNTg4ODQ4v1702EC0oLERERAQ8Pj0aXDR48GN26dXvi9unp6di6dStcXV1ZWWFhITIzM+Hj4wNTU1O0atUK8fHxSExMxJEjR3Ds2DG4urrCz8+v0eTLrxsXL17EjRs30K5dO0G5qakp0tPT4ejoKMiyz+E0iSJj2+tEdXU1qaurM/e7+rRv354A0OnTp4mI6PLly9SlSxfS1NQkNzc3kslkdO/ePVJXVyexWEza2trUpUsXIiL6888/CQClpKSw+o4ePUpaWloCt8BPP/2UWrduTTU1NVRbW0urV68mKyurBo6ERETnz58nLy8vUldXJ1NTU5JIJJSdnU0A6O+//2brjR8/nkaNGkVyuZwcHBxo7ty5Ale+/fv3U+fOnUlDQ4P69etHDx48ICKiyspKWrhwIbVr147U1dXJ09OTIiMjiYhoyZIlNG7cOJo4cSLp6emRkZERHTp0iIiIDh06RKqqqtSqVSvS1tamzz//XHAcBw8eTGPGjFHaOXtJvPYZ2157XkdBiYyMJAAUGxvbYFlcXBwTBblcTsbGxhQUFER5eXl09OhRZpq1YMECGjZsmGDbbdu2kY6OjiCt5b///W/y8fERrHf8+HFmSBYYGEgeHh4klUqptLSURowYQb6+vkRE9Pvvv5OGhgZt3LiRsrOzKS4ujsrKyujChQskFouZKBARde7cmYKCgoiIyNjYmHr16kUpKSkkkUhIXV2d+vTpQ/fv36e//vqLANDJkyeJiGjEiBHk4uJCN2/epJKSEhoxYgRNmDCBqC6dorGxMZ06dYpKSkoamGZ1796d1q9f3+gxtrCwYK6QrxFcUFqa11FQ9u/fTzo6Oo16DJ84cYL09PSI6vKRGhoa0rhx4+jhw4eC9fr168fc9RTMmDGjgXgMGTKEpk2bJijbvXs3iUQiunv3LvtXwZ49e8jIyIiIiNzc3OiLL75o0MdNmzZRhw4d2OeamhrS0NCg//73v1RWVkZisZjlZq2srCRVVVW6cOECUV10JhaL6fz58/T7778LIp2kpCTq2LEjbdiwgajOha9+LtjVq1czV76qqirS0NCgy5cvN+hfUVGRQLReI157QeFzKC1AREQE3N3dIRY3PPxRUVFsXkQsFuPChQuQSCRo3749Lly4ANT55Ny6dQs+Pj6CbWNiYuDi4tKgrU6dOgnKzpw5Aw8PD1y8eBFGRkZwd3dny3Jzc2FiYoKcnBxERUXB39+/0T7WrzM2NhYVFRXo1KkToqOjIZfL4ebmBgCQSCSoqalhbchkMsjlcri6uuKPP/6Ajo4OBg4cCH19fXTt2hUjR47Ev/71L6DOUqN+3+Li4uDs7Mz2q7q6utEM/jExMQAgmF/ivBy4oLQAERER6Ny5c6PLIiMj2cUIAF26dMGNGzcwYMAAdqFJJBKUlpaiS5cugm0fFZTs7GxkZWUJJn9PnjyJkydPYs6cOSguLoaZmZmgjv/+978YNmwYSktLgTqrzUeJiYkRXKxXr16Fjo4O7OzsEBUVBRsbG7Ru3Zrtj6mpKfM1ioyMhJGREWu3c+fOKCgoQGpqKvLz87F27VqIxWKUlpYiNTVVcCzu3r3LPl+/fh2Ojo4Ce9b6/dPS0nqiayHnxcAFpQW4e/cujI2NIZPJ2F9mZiZQN/orLppff/0Vly9fRl5eHgoLC2Fv/7+IWOHGFx4ejvj4eBARsrKykJeXJxCUO3fuAHXuemFhYfjiiy/w/vvvY86cOfjoo4/QuXNnyGQyXL9+HRUVFVi1ahXu3buHuXPnwtraGiYmJli+fDnS09MRERGBq1evAgDKy8tZf2/fvo2lS5fC3d0dIpGoQVTxpM/dunXD9evXcebMGcjlcoSEhDADrMjISIjFYnTs2BGoM/aSSCTs2OTk5CA3NxfJyclISkoSHN/o6Gg4Ozs3GgFyOE/kdZtDSUtLIwAN/hYsWEDl5eWkoqLC5gUCAwNJX1+fWrduTaNHj2YeQ2VlZdSjRw9SVVUlMzMzksvlFBISQgDo/v37rK21a9cSABKLxWRsbEwjRoyg8+fPC/ozb948MjY2Jn19fRo1ahTFx8ezZZcvX6ZOnTqRuro6WVtb07lz54jq5oD09fXJwsKC/P39ydvbm6ZPn05ERL6+vrR48WJWx6BBg2ju3Lns87Bhw2j27Nns84IFC6ht27akpaVF3bt3ZxPK27ZtI2dnZ7aeYiI7MTGRiIii/6+9e4+Lqs77AP45w8AMiIA+gqCCCioiKhc1I7t4C10LMKttt2w1Ni/Vk/msVo+VmpW1bVk+rrqZhqbW6rpestS8pGlaiuKFywCSpqZyEUVEuQ7zff5IzjqCDuqBgeHzfr3mVXPOmfP7zpH5nN/5DZxfaqoEBASIs7OzPP7441bvadCgQTJq1Kg7/Jeyi0Y/htLoNbZAqSuzZ8+2mmCqKfP19b3htz8NXKMPFP7Wj4NITU1Fp06dkJOTA09Pz1pPYepI8vPzceHCBeTk5HBA1k54kekg0tLSkJSUBD8/P2zZssXe5dQ7EUFgYCCCg4MBfsNjN+yhOIiqAdOmSlEUXLp0yd5lNHnsoRCRZhgoRKQZR7jkuQigwN5FODKz2WwAAL1eX2bvWhyc2d4FENW5sWPHTh87duyb9q6DGj5e8hCRZhzhkofqmMViKeDJh2qDgUI26XS6FgAUe9dBDR/POkSkGfZQqDZKRIQ9FLKJgUK14aooCgOFbGKgUG1cslgsvDwmmxgoVBseOp2OPRSyiWcdItIMeyhkk8ViKeOgLNUGA4Vs0ul0Bv4eCtUGA4VsslgshYqi8PKYbGKgkE06nc6TPRSqDQYK2VRZWXmJ3/JQbTBQyCYnJycP9lCoNnhdTLVhsVgsYu8iqOHjWYdqNGbMmLOKovjdYHX2p59+2qaeS6JGgD0UqpGI/FtEqvVKREQsFssa+1RFDR0DhWqkKMpcAMdrWHW8oqLiYzuURI0AA4VqtHDhwqMANl/fSxGRbz///PNj9quMGjIGCt2QTqebDeBE1XMROV1WVjbLvlVRQ8ZAoRtasGBBloh8V/VcRDYuW7bsF/tWRQ0ZA4VuSkTeF5HTAM5YLJb37V0PNWwO+bVxQkKCt4jM0el0zvauxREUFhb2BQBPT8999q7FEVgslgpFUSbEx8efs3ctWnPI35QtLS1tbjAYhoeFhRntXYuDaWfvAhzBoUOHSktLS18HwEBpLPR6vblDhw72LoOomuTkZIedcpRjKESkGQYKEWmGgUJEmmGgEJFmGChEpBkGChFphoFCRJphoBCRZhgoRKQZBgoRaYaBQkSaYaAQkWYYKESkGQYKEWmGgUJEmmGgEJFmGChEpBmHvWMb1Z/z58/ju+++g4eHB4YOHWrvcsiO2EOhakaMGIG77roLly5dqtX2//rXvzB+/Hjs2bOnzmujho09FLJSWVmJpKQkXL58GRcuXICHh4e9S6JGhIFCVpycnLBx40YUFBSAN/mmW8VLnkZm3bp1eOCBB+Dn54fg4GBMmDAB+fn56vqRI0eia9eumD9/Pnr37g1/f38MGjQIu3btUrdJSUlBy5Yt0a9fP4wfPx5BQUHw8/PDnj174O3tjfvuuw+xsbEoLCxUX2MymTB69Gh07twZ7dq1w8CBA7F+/Xqr2lJTUxEdHY127dqhT58+mDdvHq6bGrlW9bds2RKvvvoqoqKi4Ovri0cffbSOjiZpjYHSiHzyySeIj4/Hzz//jMjISDRr1gzLly/HQw89hMuXL6vb5eXlYfr06ejZsycGDRqEI0eO4IknnsDJkyet9peeno7t27fjoYcewuDBg3HPPfdg2LBhcHFxsdpu//79ePDBB7F+/Xp4enoiNDQUR48eRXJystV2O3fuxJkzZxAcHIzjx49j6tSp+Pzzz2+5fvw2WTvatGmD3/3udxg9erTGR5LqCgOlkcjLy8OMGTPQvHlz7Ny5Exs2bEBSUhIef/xxZGVlYdmyZVbbf/TRR0hISMCSJUvw3HPPoaysDKtWrbLaxsnJCevXr8ecOXOwbNkyKIqCzz//HO7u7lbbTZo0CSUlJXj55Zdx4MABbN68Gfv27cNLL71ktd3AgQNx6NAhfPfdd5gzZw4A4Msvv7yt+h955BGsXr0aixcvRkxMjKbHkuoOx1Aaie3bt6OsrAy+vr5WZ/2ioiIAwMGDB6229/f3V/8/IiICAKr1ULp27YquXbvetN3Tp08jNTUVzZs3x+TJk9Xlbdu2rbZtSEiI2ruJiYnBiy++iBMnTtxW/Y888shN66KGiYHSSOTm5gJXQ2HevHnV1ru6ut7wtQaDAQBQXl5utfz6nkhNcnJygKsB4uxc+6miq4Klqs1brb82tVHDw0BpJKq+vh0xYgQWLVpUb+16enoCVy9ZRASKotzWfuxVP9UvjqE0Evfccw8AYNOmTVaXB8nJySguLq6zdqu+Abpw4QLmz5+vLs/Ly1MvZ2rDXvVT/WKgNBLBwcH44x//iJKSEgwZMgQDBgzAvffei0GDBlmNSWhNp9Nh2rRpAICpU6ciMjIS0dHRiIyMxMyZMxt8/VS/eMnTiMyZMwdBQUH48ssvkZaWBldXV/Tr1w/du3ev03afeOIJuLu74//+7/+QmpqK/Px8BAUFYcCAAbe0H3vVT/Xn9i6IG7j58+cHNmvW7EhMTAxH9qjBWb9+/eXi4uKw559//ri9a9EaL3mISDMMFCLSDAOFiDTDQCEizTBQiEgzDBQi0gwDhYg0w0AhIs0wUIhIMwwUItIMA4WINMNAISLNMFCISDMMFAe3Z88etG/f3t5laGr58uXo1auXvcugGjBQ6tA777yDxYsXWy174403bukWiEuXLsVf//rX264hPT3d5o2ob7etXr16oWXLllaPkJCQ2671/fffR//+/W1ul56ejqCgoNtuh+oOA6WOWCwWrFy5EhkZGeqy06dP47PPPkNZWVmt9zNnzhz4+fnddh3p6em1/pDfSltFRUU4ceIEZs2ahb1796qPLVu23HKNlZWVAICwsDBER0fb3D4zMxOdOnW65Xaud/0kZHTnGCh1pGrSq8zMTHXZu+++i7KyMqtAyc7OVmfv8/f3x8iRI9VJyqOionD8+HG88cYbCAgIwLlz5wAAu3btwoMPPog2bdqgU6dO+MMf/oCKigoAwLZt2zBw4EC0bdsWI0aMwIEDB9QeypUrV/Daa68hODgYbdu2RZ8+ffD111/fVlsmkwkAEBcXhy5duqgPf39/5Ofno3v37vj8888RFRWFNm3aIDY2FleuXAEATJs2DTExMXjuuecQEhKCFStWYMKECXjyySdRUlKiHpsdO3Zg8ODB8PPzQ0hIiHos09PTkZ2djejoaPj7++OJJ56wOqYrVqxAv3794Ofnh/DwcKxbtw4AsGXLFgQEBODDDz9Enz59kJiYWEf/+k0XA6WOfPnll/D391d7KCaTCatXr0br1q3VH/4LFy5g6NChKC0txY4dO5CUlIRDhw5hw4YNAICZM2fC3d0dJ0+exKlTp+Dt7Y3du3dj5MiRGD9+PE6dOoWpU6ciNTUVzs7O2Lp1K0aOHInhw4dj//79GDZsGFJSUhASEgIRwahRo5CRkYHvv/8ex44dQ0VFBS5evHhbbaWkpEBEEBYWBn9/fwQGBsJsNgMAjEYjzp49i59++glr1qzBpk2bsGfPHmzbtg24GggZGRl44YUXkJaWhkcffRSzZ89G27Zt0a1bN+DqPD5PPfUURowYgeTkZHzzzTcICAhAYWEhsrOzodPpsGTJEmzatAk7duzA5s2bAQDz5s3Dq6++iilTpuDo0aMYPXo03nzzTbXd4uJiBAQEYP/+/RyHqQO8p2wduHTpEjZu3Ii5c+fiz3/+MwoKCjBjxgz84Q9/wIkTJ9RAmTdvHq5cuYJ58+ahWbNm2LNnDwoLCxEcHAwAOHDgACIiIqDT/Zb7IoLJkydjzJgx6ny/J06cQGRkJADg9ddfR3x8PCZMmAAAGDJkCF555RWEhIRg7dq1SExMxJEjR9CiRQtcuXIFZ86cUV97q22lpqbiwQcfxHvvvQcA0Ov10Ot/+3E6fvw4FEXBBx98gObNm8PX1xfOzs7qvtPT0zFp0iT1XrJGoxGFhYU4c+aMGijTpk1DfHw8nn/+eQCAt7c3AODIkSMAgA8++AAtW7ZEmzZt4O7ujvLychQWFuK9997Dyy+/jIcffhiXLl1CamqqeslnMpnwu9/9Dr///e/Vmklb7KHUgTVr1sDb2xvDhw+Hn58fEhISsHfvXrz++utwdnZWA2X37t1QFAXBwcHw9/fHhAkT8PHHH6sf2qSkJKuzaGpqKo4ePYo//elP6rIDBw4gMjISv/76K37++WfExcWp69LS0tCyZUv4+PhgzZo1ePjhh9GiRQsAwKFDh2A0GtXLoVtpq2p9eHg4AgMDERgYiICAAKt2AwIC0Lx5cwDAr7/+ivLycnTp0gWFhYU4e/YsHnjgAatjZjKZ4OTkhODgYJw7dw4mk8nqvVRJT0+Hn58fWrZsCQDIz8/HxYsX0aVLFyQlJaG4uBj/+Mc/0LFjR4SEhMBiseDvf/+7+tr777//Nv9VqTYYKHXgyy+/xFNPPQVFUdCtWze8//77mDhxInx8fKwCBQDi4+ORlZWFjIwMda7fKgcPHkTPnj3V5ydPnoRer1enGT1//jwSExMRHh6OgoICAICXl5e6/ebNm9Wz88mTJ9GhQwd13aZNm9C9e3c4OTndclsWiwXp6elqT+p6aWlpak8DV8PHYDAgKCgIJpMJzs7O1QZV09LSEBgYCKPRqE6cXtNsiBkZGVb7TktLg16vV2tRFAXJyck4dOgQfv31VyQkJKBVq1Ywm83Iysqyei1pj4GisZycHBw6dAhPPvkkACA0NBR+fn547rnngKtTdFYFSu/evfHvf/8bWVlZKC0txffff6/ux2w2o6CgACaTCdnZ2SgsLETbtm1hNptx/PhxVFRUYPLkyaioqIC7uzs6dOgANzc3fPHFFygpKcHatWuxfPlytQfStm1b/PzzzwCA/fv3Y/Hixep0n7faVlZWFkpKSuDi4oKjR4+qj6rxGJPJhNDQUPW9pKamokuXLtDr9UhPT0fnzp2rTWtqMpnUD7u/vz+8vb3xt7/9DWfPnkVKSoo6gJqenm61b5PJhKCgIBgMBvTo0QMGgwEff/wxLBYLMjIycPz4bzeWP3bsGMrKyu7oa22yjYGisb1796rfsuBqoEyfPh1GoxEA4OzsjNLSUgDAyy+/jB49eiA2NhZ9+vTB1q1b1f3o9XqMGTMGc+bMQVRUFI4dO4aIiAi88MILeOihh3DffffBzc0N3t7eyMzMhIeHB+bOnYuvvvoKoaGh2Lp1KwICAtQP0NSpU2EymRAeHo5XXnkFQ4YMwdGjR2+rrbS0NADAn/70J9x9993qoyoQr++hXPvcZDLV+KG+drler8fixYtx4sQJ9OrVCyNHjlQnVc/IyLAKlGsDxtvbG/Pnz8eqVasQGhqK+Ph4dW7l9PR0+Pr6qpdKVDc4Lw9RPeO8PEREtcBAISLNMFCISDMMFCLSDAOFiDTDQCEizTBQiEgzDBQi0gwDhYg0w0AhIs0wUIhIMwwUItIMA4WINMNAISLNMFCISDMMFCLSDAOFiDTDQCEizTBQiEgzDBQi0ozDTp1WVlZm2Lt372V710F0PbPZ7GLvGuqKQwaKiORVVlaOPXnypL1LcQi5ublxAJTWrVuvs3ctjkJE8uxdA5FdjB07dvrYsWPftHcd1PBxDIWINMNAISLNMFCISDMMFCLSDAOFiDTDQCEizTjk76GQtkSk0mKx8ORDNjFQyCZFUZycnJwUe9dBDR/POkSkGfZQyCaLxVLAkw/VBgOFbNLpdC0A8JKHbOJZh4g0w0AhIs3wkodsslgsBfzamGqDgUI26XS6FjqdjmMoZBPPOkSkGQYKEWmGgUJEmmGgUG1YLBaL2LsIavgYKFQbOg7KUm0wUIhIMwwUItIMfw+FbLJYLGUiwksesok/JPVMRHYA6G/vOpqQFoqiXLR3EU0FL3mISDMMFCLSDAOFiDTDQCEizTBQGoFFixZBURTk5OTYu5R6k5iYiNLSUnuXQbeIgUINzpIlS9C3b19cvnzZ3qXQLWKgUIPDnglRLYnIDrHh0KFDct9994nRaJSOHTvK0KFDBYBkZ2eLiEh5eblMmTJF2rRpIy4uLhIWFiZr16612kdxcbFMmTJFOnbsKC4uLtK5c2d5++23xWw2y+uvvy4Gg8Fq+/379wsA2bRpk4iIxMXFyauvviovvviieHh4SPPmzWX48OHy/fffy+DBg8XV1VU6duwoy5Yts9rPL7/8Io888oi4u7uLt7e3DBkyRPbv36+uj4uLk1deeUVef/118fHxES8vL3nyySelsLBQREQWL14sAKweixcvFhGRzMxMGThwoDRr1kzatWsn48aNk8rKSluH08ve/+ZEdcZWoGRkZIiHh4cEBgbKxx9/LHPnzhUfHx+rQBk9erTo9XqZPn26rFq1SuLi4kRRFNm1a5eIiJjNZhk4cKA4OzvL5MmTZdmyZTJlyhQZOXKkiEitAwWAvPjii5KUlCRvv/22ABBnZ2eZO3euJCYmyogRI8TJyUkyMjJERCQ7O1v8/Pzk/vvvl88++0wSEhKkf//+YjQaJTU1Vd2vk5OTPPnkk5KYmChLliwRFxcXefnll0VEJDc3VyZPniwA5JtvvpEffvhBcnNzRUTk3nvvFW9vb/n0009l1qxZ8vDDD9sKEwYKOTZbgRITEyMtWrSQvLw8ddk//vEPNVAyMjIEgEydOlVdb7FYpFOnTjJgwAAREVmxYoUAkM8++6zGNmobKN26dbPapn379vLYY4+pz0+dOiUA5JNPPhERkeeff17Cw8OloqJC3aa8vFwCAgJkwoQJ6n5DQkLEYrGo28TGxkqPHj2qvd9z585Ztd+uXTuJjo6+2eGrCQOlHnEMpQEpKSnBt99+i6effhre3t7qcr3+P39ytXPnTgDAiBEj1GWKoiA6OhoHDhwAAGzatAmurq4YNWrUHdXj6upq9dxoNMJgMKjP27VrBwDIz88HAGzcuBEpKSlwd3eH0WiE0WhE8+bN8euvv+L06dPq69zc3KAo//mrj/bt2+Ps2bM263n66aexZcsWvPjii8jLy7uj90Z1g38c2IBkZ2ejoqICHTt2vOE2hYWFAAAfHx+r5S1btkRRURGKioqQm5uLNm3awMnJqU7rrQoFkd/uvZSTk4OHH34Yf/3rX6tt6+V1446Ci4sLzGazzfZmzpwJHx8fvPvuu1i8eDHef/99vPDCC3f0HkhbDJQGpKpXcrOzb1Wv4Pz582jTpo26PDc3Fy4uLnBzc4OXlxdyc3NvuI9rewdaatGiBfLz89G1a1dN9lcVVFUURcHEiRPx5z//GePGjcN///d/Izw8HP369dOkPbpzvORpQJo3b47OnTtj1apVKC8vr3Gbu+66CzqdDhs3blSXlZWV4ZtvvkFUVBScnJwwcOBAXL58GStWrLB6bVUvwMfHB2VlZbhw4YK67sSJE3dc/+DBg/Hjjz8iKSnJavmVK1duaT/NmjUDgGqXQVVfJzdv3hxvvfUWAODgwYN3WDVpiT2UBmb69OkYOXIk7rnnHjzzzDNwcnLC7Nmz1fVBQUEYNWoUpk+fDrPZjKCgIHz66afIzc3F8uXLgatjDfPmzcOoUaOQmJiIsLAwpKSkYNu2bTh48CAGDx4MnU6Hl156CRMnTkRqaipeffXVO679zTffxIYNGxAdHY1JkybBx8cH3377LcxmM9atW1fr/dxzzz3Q6/V46aWXEB8fj5KSEowbNw6PP/44PDw8EB0drQZqr1697rhuokarNr+HMnfuXOnQoYO4urpK7969ZdSoUVZfG5eUlMjEiROldevW4uLiIhEREfLNN99Y7eP8+fPy7LPPSqtWrcTNzU1CQ0Pl7bffltLSUhERWbp0qQQFBYmrq6tER0fLkiVLqn3L06tXL6t9BgcHy1NPPWW1DIC8/fbb6vP09HR56KGHxM3NTdzd3eX++++XVatWqetr2u+kSZPE09PTallCQoL4+vqKl5eXDBw4UERE3nrrLenUqZMYjUbp1KmTfPrpp7YOpfBbnvrFGyzVM95gqd7xBkv1iGMoRKQZBgoRaYaBQkSaYaAQkWYYKESkGQYKEWmGgUJEmmGgEJFmGChEpBkGChFphoFCRJphoBCRZhgoRKQZBoqDiY6OhqIoUBQFK1eutHc5dtGqVSv1GPzzn/801OIlRI1T1f1Q4uPjZejQoTXewKN///7y0ksv2bzRxwsvvCCrV6+2Wubn5yfTpk2T7OxsKS8vF4vFIkFBQWIwGMTX11f69+9fbQ6fxurs2XzrFvYAAA1oSURBVLMSFxcnp06dslqenZ0ts2bNEhcXFykoKOD9UOoReyh2cvjwYYSHh9e4bsiQIbj77rtv+vozZ85g3rx56N69u7qsoKAA2dnZ6Nu3L3x9feHs7IysrCwcO3YMK1aswKpVq9C9e3c88sgjNd5IurHZvn07EhMT4e/vb7Xc19cXZ86cQXBw8E1vjk3U6InIjoqKCjEYDLJy5cpqZ92goCABIF9//bWIiOzcuVMiIyPF1dVVevToIRkZGXLq1CkxGAyi0+mkWbNmEhkZKSIiu3btEgBy4sQJdX8rV64UNzc3qxn2nnvuOfH09BSz2SyVlZUyc+ZMCQgIEDc3N7n33nslPT1d3XbLli3Sp08ftYdjMpkkNzdXAMjevXvV7UaNGiVxcXFisVikc+fOMnnyZOnRo4cYjUbp3bu3LF26VCIiIsRoNMqAAQPk8uXLIiJSVlYmr732mvj7+4vBYJBevXpJcnKyiIhMnTpVnn76aXnmmWfEw8NDWrVqJV988YWIiHzxxRei1+vF2dlZmjVrVq1HN2TIEPnjH/8ovGMbOTQR2ZGcnCwAJDMzs1qgHD16VA0Fi8Ui3t7eMm3aNMnPz5eVK1eK2WwWEZEpU6bIsGHDrF47f/58cXd3t5pE63//93+lb9++VtutWbNGAEheXp5MmDBBwsPDJT09XYqKiiQmJka95eLmzZvFaDTKrFmzJDc3V44ePSrFxcWydetW0el0aiiIiERERMi0adNERMTb21vuu+8+OXHihJhMJjEYDPLAAw/I6dOnZffu3QJA1q1bJ3J1YrPQ0FDZv3+/XLp0SWJiYmT06NEiV28N6e3tLV999ZVcunRJnnjiCQkNDVXbjIqKkr/97W/VjqGISNu2beWdd95hoJBjE5EdS5cuFXd39xrn5V27dq14eHiIiEhlZaW0bNlSnn76ably5YrVdgMGDJAZM2ZYLXv++eerhcfQoUNl3LhxVssWLVokiqLIkSNH1P9WSUhIkFatWomISI8ePeQvf/lLtRo/+ugj6dKli/rcbDaL0WiU1atXS3Fxseh0Ovnhhx9ErvZA9Hq9bN26VUREKioqRKfTyZYtW2Tz5s1WPZ3jx49Lt27d5MMPPxS5OqPgpEmT1HZmzpypzjBYXl4uRqNRdu7cWa2+ixcvXhtaDJR6xDEUOzh8+DB69uwJna764U9JSVHHRXQ6HbZu3QqTyYSgoCBs3boVAGCxWHDgwAH07dvX6rVpaWkIDQ2t1lZYWJjVsg0bNiA8PBzbt29Hq1at0LNnT3XduXPn4OPjg7y8PKSkpOCxxx6rscZr95mZmYnS0lKEhYUhNTUVFosFPXr0AACYTCaYzWa1jYyMDFgsFnTv3h3ff/893N3d8eCDD8LLywu9e/dGbGws/ud//gcAkJycbFXb0aNHERISor6vioqKGu96n5aWBgBW40tUPxgodnD48GFERETUuC45OVn9MAJAZGQkEhMTMXjwYPWDZjKZUFRUhMjISKvXXh8oubm5yMnJsRr8XbduHdatW4dJkyahsLAQfn5+VvtYvXo1hg0bhqKiIuDqtKHXS0tLs/qw/vjjj3B3d0dgYCBSUlLQoUMHeHp6qu/H19dXnekwOTkZrVq1UtuNiIjAhQsXcPLkSZw/fx7vvfcedDodioqKcPLkSatjceTIEfX5vn37EBwcrM7hc319bm5uN52BkeoGA8UOjhw5Am9vb2RkZKiP7Oxs4OrZv+pDs379euzcuRP5+fkoKChAp06dgGtmFkxKSkJWVhZEBDk5OcjPz7cKlEOHDgFXZ9z74Ycf8Je//AW///3vMWnSJDz11FOIiIhARkYG9u3bh9LSUrzzzjs4deoUJk+ejPbt28PHxwczZszAmTNncPjwYfz444/A1TmYq+o9ePAgpk+fjp49e0JRlGq9ips9v/vuu7Fv3z5s2LABFosF27ZtUyfzSk5Ohk6nQ7du3YCrk5SZTCb12OTl5eHcuXP45ZdfcPz4cavjm5qaipCQkBp7gEQO5dSpU7sByPWPKVOmSElJiTg5OanjAhMmTBAvLy/x9PSURx99VJ2Xp7i4WPr16yd6vV78/PzEYrHItm3bBICcPn1aHUt47733BIDodDrx9vaWmJgY2bJli9V4wyuvvCLe3t7i5eUlcXFxkpWVpa7buXOnhIWFicFgkPbt28u3334rcnVOHy8vL2nbtq089thjctddd8n48eNFRGTgwIHyxhtvqPuIjo6WyZMnq8+HDRsmEydOVJ9PmTJFWrduLW5ubhIVFaUOKM+fP19CQkLU7aoGso8dOyYiIqmpqRIQECDOzs7y+OOPW72nQYMGyahRo6qecgyFHFdtJvq6HbNnz642WVZT5evre+23PwyUesSpSB1EamoqOnXqhJycHHh6esLV1dXeJdW7/Px8XLhwATk5ORyQtRNeZDqItLQ0JCUlwc/PD1u2bLF3OfVORBAYGIjg4GCA3/DYDacirWecirTecSrSesQeChFphoFCRJrhoGz9uwCgwN5F3IrKykp9RUWF0Wg0XrZ3Lbeh0t4FENE1xo4dO2DMmDHf2bsOavh4yUM2KYpSCcDJ3nVQw8dAIZvKysrKAZy1dx3U8DFQyCa9Xg9FUTrYuw5q+BgoZJOiKJUiwksesomBQjaJSBmADHvXQQ0fA4VsEhEnRVH4u+xkEwOFbNLr9RYR4c8K2cQfErLJYrGYFUUps3cd1PAxUMgmnU4nIuJu7zqo4WOgkE0iUqYoSqq966CGj4FCNimKohORmu+qTXQNBgrZVFxcbFYUJdPedVDDx0Ahm1xcXCwAetRiU2riGChkU1lZWbmIsIdCNjFQyKark32xh0I2MVDIpqKiogpFUZLsXQc1fLxJNdVozJgxmwH4KYoCETGISAcApxVFUQAYFy5c2MbeNVLDw1tA0o1sBPABAGdFUfBbjiAQVydrJ6oJL3moRgsXLpwjIsevXy4iALDNLkVRg8dAoRsRAH8XkeJrF1oslvMWi+Uj+5VFDRnHUOimnn322RSdTtcd/+md7Fi4cOFAe9dFDRN7KGTLbBEpufr/lywWyyw710MNGHsoZNOYMWMOK4oSJiJ7Fy5cGGXveqjhYg+FbPL09Fyi1+sLKysrP7R3LdSwsYdCN7VgwYIAZ2fnI/htQDb82WefPWnvmqjhYqDQDVWFyfDhw70AYN26dRcZKnQzDBSq0fVhUoWhQjfDQKFqbhQmVRgqdCMMFLKyYMGCABcXlyNxcXE1hkmVr7766mJlZSVDhawwUEi1YMGCAIPBkBIbG+tRm+3Xr19/yWw292SoUBUGCgG3ESZVGCp0LQYK3XaYVGGoUBUGShN3p2FShaFCYKA0bVqFSRWGCjFQmiitw6QKQ6VpY6A0QXUVJlUYKk0XA6WJqeswqcJQaZoYKE1IfYVJFYZK08NAaSLqO0yqMFSaFgZKE3A1TNJiY2Pd7dH++vXrL5vN5u4MFcfHQHFw9g6TKgyVpoGB4sAaSphUYag4PgaKg2poYVKFoeLYGCgOqKGGSRWGiuNioDiYhh4mVRgqjomB4kAaS5hUYag4HgaKg2hsYVKFoeJYOC+PA6jrMHnggQfw1ltv1cWuERsb667X61MXLVrUvk4aoHrFHkojt3Tp0o4WiyW5LsIkMzMTa9euRU5ODqKiomAymfDaa6/BYDBo3RTWr19/2WKxhMXHxx/XfOdUbxgojdjVMEmNjY11q4v9b9q0Ce+++y5yc3PxX//1X3BycsKiRYvQtWvXumgOX3/99ZXKysqeDJXGy8neBdDtqeswAYDOnTvj4sWLMJvNKCoqwowZM3DXXXfVVXMIDg52ycrKejY2NnbFV199VVBnDVGd4RhKI1QfYQIAZWVl2L17N1577TU888wz2L59e102BwCIiYlp5uTklJyQkBBY542R5njJ08jUV5hcT0SgKPX348LLn8aJPZRGZMGCBX0NBsMP9R0mAOo1THC1p9KsWbNdn3zySVS9Nkx3hIHSiIwbN27flStX8nJzc0vsXUtdy8vLK75y5Ure+PHjf7J3LVR7vORphBISEg5GRUV1bd26tau9a6kLeXl5xT/++GNmfHx8pL1roVvDQGmkHDVUGCaNGwOlEXO0UGGYNH4MlEbOUUKFYeIYGCgOoLGHCsPEcTBQHERjDRWGiWNhoDiQxhYqDBPHw0BxMI0lVBgmjomB4oAaeqgwTBwXA8VBNdRQYZg4NgaKA2toocIwcXwMFAfXUEKFYdI0MFCaAHuHCsOk6eBfGzcB8fHxkT/99FNGbm5ueX23fe7cuTKGSdPBHkoTsmTJkiN9+/bt2rp1a5f6aO/cuXNlP/30U+bo0aPD6qM9sj8GShNTX6HCMGmaGChNUF2HCsOk6WKgNFF1FSoMk6aNgdKEaR0qDBNioDRxWoUKw4TAQCFoECoME6rCQCHgDkKFYULXYqCQ6lZDhWFC12OgkJXahgrDhGrCQKFqbIUKw4SIbsmSJUuOpKenl124cEGufWRmZpYuWbLkiL3rI6JG5vpQYZgQ0R2pChWGCRFpYvny5duWL1++3d51EBERERERERERERERERERERFR0/D/zNI1yHyNKooAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pipeline.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ev0SiDqnbOCa" + }, + "source": [ + "## Extra: Metadata Inheritance\n", + "\n", + "This is just an extra step to show how metadata that belongs to a document is inherited by the document chunks if you use a component such as the `DocumentSplitter`." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gAPfuWMMRGnP", + "outputId": "c2c0d04f-8c0e-4a38-f319-3e2e343e0306" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "🚅 Components\n", + " - fetcher: LinkContentFetcher\n", + " - converter: HTMLToDocument\n", + " - enricher: MetadataEnricher\n", + " - splitter: DocumentSplitter\n", + "🛤️ Connections\n", + " - fetcher.streams -> converter.sources (List[ByteStream])\n", + " - converter.documents -> enricher.documents (List[Document])\n", + " - enricher.documents -> splitter.documents (List[Document])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipeline.add_component(\"splitter\", DocumentSplitter())\n", + "\n", + "pipeline.connect(\"enricher\", \"splitter\")" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BRgr9jy0Ro8Y", + "outputId": "0255a435-54e2-45d3-9edb-aea5b1f81758" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'splitter': {'documents': [Document(id=9611aa2bdb658163d8f6964220052065936fcd036dd24743d1b34ce79d25bc5a, content: 'Deepset, a platform for building enterprise apps powered by large language models akin to ChatGPT, t...', meta: {'content_type': 'text/html', 'url': 'https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/', 'company': 'Deepset', 'year': 2023, 'funding_value': 30000000, 'funding_currency': 'USD', 'source_id': '5844517120556b13f92430ea8af9837714ede1b351580c43c2ddce9b646cb6cb', 'page_number': 1, 'split_id': 0, 'split_idx_start': 0}),\n", + " Document(id=6bffbcf9f1cd1a3940628d1450c9ba9a8c9a092136896d295b35af3175caffbf, content: 'unfortunate state of affairs is likely contributing to challenges around AI development within the e...', meta: {'content_type': 'text/html', 'url': 'https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/', 'company': 'Deepset', 'year': 2023, 'funding_value': 30000000, 'funding_currency': 'USD', 'source_id': '5844517120556b13f92430ea8af9837714ede1b351580c43c2ddce9b646cb6cb', 'page_number': 1, 'split_id': 1, 'split_idx_start': 1256}),\n", + " Document(id=da372f9bc2292f487f0aad372053a531744d9549a46f8ac197c216abaa4d99d0, content: 'to end users, and perform analyses of the LLMs’ accuracy while continuously monitoring their perform...', meta: {'content_type': 'text/html', 'url': 'https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/', 'company': 'Deepset', 'year': 2023, 'funding_value': 30000000, 'funding_currency': 'USD', 'source_id': '5844517120556b13f92430ea8af9837714ede1b351580c43c2ddce9b646cb6cb', 'page_number': 1, 'split_id': 2, 'split_idx_start': 2609}),\n", + " Document(id=f316cd275e8bc763de41d128dbdbd81e1baad2693b0102f6951c4f46aa8f6048, content: 'predicts that the sector for MLOps will reach $23.1 billion by 2031, up from around $1 billion in 20...', meta: {'content_type': 'text/html', 'url': 'https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/', 'company': 'Deepset', 'year': 2023, 'funding_value': 30000000, 'funding_currency': 'USD', 'source_id': '5844517120556b13f92430ea8af9837714ede1b351580c43c2ddce9b646cb6cb', 'page_number': 1, 'split_id': 3, 'split_idx_start': 3997}),\n", + " Document(id=c7ff4e0d7af8aaa16f3195cb1f9096bb1cf8e7d985190fa6746c278b1d8457e8, content: 'Arize AI Raises $38 Million Series B To Scale Machine Learning Observability Platform\n", + " As companies t...', meta: {'content_type': 'text/html', 'url': 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html', 'company': 'Arize AI', 'year': 2022, 'funding_value': 38000000, 'funding_currency': 'USD', 'source_id': '8cdcb63a4e006b1cac902ebc2e012cd95156d188777e0d0c8bd407a92f4491c7', 'page_number': 1, 'split_id': 0, 'split_idx_start': 0}),\n", + " Document(id=646f4d43ee20fcbe35c97bd04e8fd6edd4ad5c9af63fe4a63267f5df1807254f, content: 'by humans.\n", + " Launched in 2020, Arize's ML observability platform is already counted on by a growing li...', meta: {'content_type': 'text/html', 'url': 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html', 'company': 'Arize AI', 'year': 2022, 'funding_value': 38000000, 'funding_currency': 'USD', 'source_id': '8cdcb63a4e006b1cac902ebc2e012cd95156d188777e0d0c8bd407a92f4491c7', 'page_number': 1, 'split_id': 1, 'split_idx_start': 1360}),\n", + " Document(id=09382ae0ab9adbd7860199b0d86e8ca044787eda860dfb181e3b243c6584a427, content: 'what happened, and improve overall model performance,\" says Morgan Gerlak, Partner at TCV. \"Like oth...', meta: {'content_type': 'text/html', 'url': 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html', 'company': 'Arize AI', 'year': 2022, 'funding_value': 38000000, 'funding_currency': 'USD', 'source_id': '8cdcb63a4e006b1cac902ebc2e012cd95156d188777e0d0c8bd407a92f4491c7', 'page_number': 1, 'split_id': 2, 'split_idx_start': 2697}),\n", + " Document(id=94497826791e38f15016a2360d7e3eea5e242770f51dd11be69fb21210e89c9a, content: 'you are going to be left behind,\" notes Brett Wilson, Co-Founder and General Partner at Swift Ventur...', meta: {'content_type': 'text/html', 'url': 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html', 'company': 'Arize AI', 'year': 2022, 'funding_value': 38000000, 'funding_currency': 'USD', 'source_id': '8cdcb63a4e006b1cac902ebc2e012cd95156d188777e0d0c8bd407a92f4491c7', 'page_number': 1, 'split_id': 3, 'split_idx_start': 3967})]}}" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipeline.run({\"fetcher\": {\"urls\": ['https://techcrunch.com/2023/08/09/deepset-secures-30m-to-expand-its-llm-focused-mlops-offerings/',\n", + " 'https://www.prnewswire.com/news-releases/arize-ai-raises-38-million-series-b-to-scale-machine-learning-observability-platform-301620603.html']}})" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}