diff --git a/Backend/.env b/Backend/.env new file mode 100644 index 0000000..4e72aa5 --- /dev/null +++ b/Backend/.env @@ -0,0 +1,3 @@ +DB_URL=mongodb+srv://abhinavsai:dbabhi@cluster0.ld98sx9.mongodb.net/VisualAid +API_TOKEN={"Authorization": "Bearer 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"} +API_URL=https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-large diff --git a/Backend/Model.ipynb b/Backend/Model.ipynb new file mode 100644 index 0000000..e4c8f77 --- /dev/null +++ b/Backend/Model.ipynb @@ -0,0 +1,2573 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gUijQ0u8P9Fb", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5f23d56e-ef74-4661-f9bb-f5f93756e3f7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-1AMvhDj53_a", + "outputId": "f6dca53c-b78c-4949-98ba-8d53589f728a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m11.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m868.8/868.8 kB\u001b[0m \u001b[31m22.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m812.2/812.2 kB\u001b[0m \u001b[31m30.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m23.7/23.7 MB\u001b[0m \u001b[31m144.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m823.6/823.6 kB\u001b[0m \u001b[31m259.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.1/14.1 MB\u001b[0m \u001b[31m151.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m731.7/731.7 MB\u001b[0m \u001b[31m170.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m410.6/410.6 MB\u001b[0m \u001b[31m115.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m121.6/121.6 MB\u001b[0m \u001b[31m218.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.5/56.5 MB\u001b[0m \u001b[31m231.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.2/124.2 MB\u001b[0m \u001b[31m184.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m196.0/196.0 MB\u001b[0m \u001b[31m154.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m176.2/176.2 MB\u001b[0m \u001b[31m144.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m99.1/99.1 kB\u001b[0m \u001b[31m202.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.3/21.3 MB\u001b[0m \u001b[31m179.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting en-core-web-sm==3.7.1\n", + " Downloading https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl (12.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.8/12.8 MB\u001b[0m \u001b[31m29.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: spacy<3.8.0,>=3.7.2 in /usr/local/lib/python3.10/dist-packages (from en-core-web-sm==3.7.1) (3.7.5)\n", + "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.11 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.0.12)\n", + "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.0.5)\n", + "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.0.10)\n", + "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.0.8)\n", + "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.0.9)\n", + "Requirement already satisfied: thinc<8.3.0,>=8.2.2 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (8.2.5)\n", + "Requirement already satisfied: wasabi<1.2.0,>=0.9.1 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.1.3)\n", + "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.4.8)\n", + "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.0.10)\n", + "Requirement already satisfied: weasel<0.5.0,>=0.1.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.4.1)\n", + "Requirement already satisfied: typer<1.0.0,>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.12.3)\n", + "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (4.66.4)\n", + "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.31.0)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<3.0.0,>=1.7.4 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.7.4)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.1.4)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (67.7.2)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (24.1)\n", + "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.4.0)\n", + "Requirement already satisfied: numpy>=1.19.0 in /usr/local/lib/python3.10/dist-packages (from spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.25.2)\n", + "Requirement already satisfied: language-data>=1.2 in /usr/local/lib/python3.10/dist-packages (from langcodes<4.0.0,>=3.2.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.2.0)\n", + "Requirement already satisfied: annotated-types>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from pydantic!=1.8,!=1.8.1,<3.0.0,>=1.7.4->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.18.4 in /usr/local/lib/python3.10/dist-packages (from pydantic!=1.8,!=1.8.1,<3.0.0,>=1.7.4->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.18.4)\n", + "Requirement already satisfied: typing-extensions>=4.6.1 in /usr/local/lib/python3.10/dist-packages (from pydantic!=1.8,!=1.8.1,<3.0.0,>=1.7.4->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (4.12.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.13.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.13.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.13.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.13.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2024.6.2)\n", + "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /usr/local/lib/python3.10/dist-packages (from thinc<8.3.0,>=8.2.2->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.7.11)\n", + "Requirement already satisfied: confection<1.0.0,>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from thinc<8.3.0,>=8.2.2->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.1.5)\n", + "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from typer<1.0.0,>=0.3.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (8.1.7)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from typer<1.0.0,>=0.3.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.5.4)\n", + "Requirement already satisfied: rich>=10.11.0 in /usr/local/lib/python3.10/dist-packages (from typer<1.0.0,>=0.3.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (13.7.1)\n", + "Requirement already satisfied: cloudpathlib<1.0.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from weasel<0.5.0,>=0.1.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.18.1)\n", + "Requirement already satisfied: smart-open<8.0.0,>=5.2.1 in /usr/local/lib/python3.10/dist-packages (from weasel<0.5.0,>=0.1.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (7.0.4)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.1.5)\n", + "Requirement already satisfied: marisa-trie>=0.7.7 in /usr/local/lib/python3.10/dist-packages (from language-data>=1.2->langcodes<4.0.0,>=3.2.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.2.0)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich>=10.11.0->typer<1.0.0,>=0.3.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich>=10.11.0->typer<1.0.0,>=0.3.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (2.16.1)\n", + "Requirement already satisfied: wrapt in /usr/local/lib/python3.10/dist-packages (from smart-open<8.0.0,>=5.2.1->weasel<0.5.0,>=0.1.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (1.14.1)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich>=10.11.0->typer<1.0.0,>=0.3.0->spacy<3.8.0,>=3.7.2->en-core-web-sm==3.7.1) (0.1.2)\n", + "\u001b[38;5;2m✔ Download and installation successful\u001b[0m\n", + "You can now load the package via spacy.load('en_core_web_sm')\n", + "\u001b[38;5;3m⚠ Restart to reload dependencies\u001b[0m\n", + "If you are in a Jupyter or Colab notebook, you may need to restart Python in\n", + "order to load all the package's dependencies. You can do this by selecting the\n", + "'Restart kernel' or 'Restart runtime' option.\n" + ] + } + ], + "source": [ + "!pip install -q --no-cache-dir lightning torchmetrics spacy\n", + "!python -q -m spacy download en_core_web_sm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u_BmZaMM5_-z" + }, + "outputs": [], + "source": [ + "try:\n", + " import lightning as L\n", + "except:\n", + " import lightning as L\n", + "\n", + "from lightning.pytorch import Trainer, seed_everything\n", + "from lightning.pytorch.callbacks import ModelCheckpoint\n", + "\n", + "import re\n", + "import os\n", + "import cv2\n", + "import copy\n", + "import math\n", + "import random\n", + "import warnings\n", + "import collections\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import urllib.request as urllib\n", + "\n", + "from PIL import Image\n", + "from google.colab.patches import cv2_imshow\n", + "\n", + "import torch\n", + "import torchvision\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torch.utils.data as data\n", + "import torch.nn.functional as F\n", + "\n", + "from torchmetrics.text import ROUGEScore\n", + "\n", + "from torch.nn.utils.rnn import pad_sequence\n", + "from torchvision.transforms.v2 import (\n", + " Compose,\n", + " Resize,\n", + " ToTensor,\n", + " Normalize,\n", + " RandomHorizontalFlip,\n", + " RandomAffine,\n", + " RandomAutocontrast\n", + ")\n", + "\n", + "try:\n", + " from torchvision.transforms.v2 import InterpolationMode\n", + " BICUBIC = InterpolationMode.BICUBIC\n", + "except ImportError:\n", + " BICUBIC = Image.BICUBIC\n", + "\n", + "from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights\n", + "from torchvision.datasets.utils import download_and_extract_archive\n", + "\n", + "import spacy\n", + "spacy = spacy.load(\"en_core_web_sm\")\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['axes.facecolor'] = 'lightgray'\n", + "plt.rcParams['mathtext.fontset'] = 'cm'\n", + "plt.rcParams['font.family'] = 'STIXGeneral'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GCk2KTMx6Fun" + }, + "outputs": [], + "source": [ + "os.makedirs(\"experiment\", exist_ok=True)\n", + "os.makedirs(\"experiment/training\", exist_ok=True)\n", + "os.makedirs(\"experiment/dataset\", exist_ok=True)\n", + "os.makedirs(\"experiment/model\", exist_ok=True)\n", + "EXPERIMENT_DIR = \"experiment/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LCaufKhg6JDD" + }, + "outputs": [], + "source": [ + "ANNOTATION_PATH = \"experiment/dataset/Flickr8k.token.txt\"\n", + "IMAGE_PATH = \"experiment/dataset/Flicker8k_Dataset\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BDz4X1yJ6M2R" + }, + "outputs": [], + "source": [ + "METRIC_TO_MONITOR = \"val_loss\"\n", + "METRIC_MODE = \"min\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "akghWWVH6rRY", + "outputId": "051c4c80-d3a5-40f5-f74c-12dca48d7be3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random seed: 651470215\n" + ] + } + ], + "source": [ + "SEED = int(np.random.randint(2147483647))\n", + "print(f\"Random seed: {SEED}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QRxXG7U76tLo" + }, + "outputs": [], + "source": [ + "START_TOKEN = \"\"\n", + "END_TOKEN = \"\"\n", + "PAD_TOKEN = \"\"\n", + "OOV_TOKEN = \"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "05a78mJa6vBy" + }, + "outputs": [], + "source": [ + "MAX_SEQUENCE = 30\n", + "IMAGE_SIZE = 300" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WDtjoriU6w7K" + }, + "outputs": [], + "source": [ + "TEMPERATURE = 0.1\n", + "TOP_P = 0.9" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BEs6WNz56ygr" + }, + "outputs": [], + "source": [ + "NUM_HEAD = 32\n", + "NUM_KV_HEAD = 8\n", + "NUM_LAYER = 1\n", + "EMBED_DIM = 640\n", + "HEAD_DIM = EMBED_DIM // NUM_HEAD\n", + "ROPE_BASE = 10000\n", + "MLP_SCALE = 3.5\n", + "DROPOUT = math.sin(math.sqrt(math.e * math.pi))\n", + "EPS_NORM = 1e-5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xd23ydk660FD" + }, + "outputs": [], + "source": [ + "MAX_EPOCH = 36\n", + "BATCH_SIZE = 128\n", + "LEARNING_RATE = 3.1e-4\n", + "REDUCE_LR_FACTOR = 0.69" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MtnLl5XF615h" + }, + "outputs": [], + "source": [ + "MILESTONES = 1. / math.sqrt(MAX_EPOCH) * (\n", + " np.array(\n", + " [m for m in range(1, int(math.sqrt(MAX_EPOCH)))]\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kncXzHoz63Xq" + }, + "outputs": [], + "source": [ + "DATASET_URL = {\n", + " \"image\" : (\n", + " \"https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip\",\n", + " \"Flickr8k_Dataset.zip\",\n", + " ),\n", + " \"text\" : (\n", + " \"https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_text.zip\",\n", + " \"Flickr8k_text.zip\",\n", + " ),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hvclq88265JC", + "outputId": "e055a0ce-b804-489f-bb95-9a3807a53f9c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading https://objects.githubusercontent.com/github-production-release-asset-2e65be/124585957/47f52b80-3501-11e9-8f49-4515a2a3339b?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=releaseassetproduction%2F20240625%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20240625T181717Z&X-Amz-Expires=300&X-Amz-Signature=99e68a5dfc3d5385180cf756c78439342e003ea71888a880c716f6b43f2ed467&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=124585957&response-content-disposition=attachment%3B%20filename%3DFlickr8k_Dataset.zip&response-content-type=application%2Foctet-stream to experiment/dataset/Flickr8k_Dataset.zip\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 1115419746/1115419746 [00:09<00:00, 123731918.41it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting experiment/dataset/Flickr8k_Dataset.zip to experiment/dataset\n", + "Downloading https://objects.githubusercontent.com/github-production-release-asset-2e65be/124585957/47f52b80-3501-11e9-8d2e-dd69a21a4362?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=releaseassetproduction%2F20240625%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20240625T181746Z&X-Amz-Expires=300&X-Amz-Signature=6796a2e60f600c1eacb2cbc108f49cee3c05224a24af197b9834f7ece79fc80f&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=124585957&response-content-disposition=attachment%3B%20filename%3DFlickr8k_text.zip&response-content-type=application%2Foctet-stream to experiment/dataset/Flickr8k_text.zip\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 2340801/2340801 [00:00<00:00, 45961767.30it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting experiment/dataset/Flickr8k_text.zip to experiment/dataset\n" + ] + } + ], + "source": [ + "for dat in DATASET_URL.values():\n", + " url, filename = dat\n", + " download_and_extract_archive(\n", + " url,\n", + " \"experiment/dataset\",\n", + " filename=filename,\n", + " )\n", + " os.remove(os.path.join(\"experiment/dataset\", filename))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kAnqQ7Dr7d2o" + }, + "outputs": [], + "source": [ + "class ToRGB(object):\n", + " def __call__(self, image):\n", + " assert 'PIL' in str(type(image)), \"Expected PIL Image\"\n", + " return image.convert(\"RGB\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DHbi4DMZ7iMy" + }, + "outputs": [], + "source": [ + "TRANSFORM = Compose(\n", + " [\n", + " Resize((IMAGE_SIZE, IMAGE_SIZE), interpolation=BICUBIC),\n", + " ToRGB(),\n", + " ToTensor(),\n", + " Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", + " ]\n", + ")\n", + "\n", + "TRANSFORM_AUGMENTATION = Compose(\n", + " [\n", + " Resize((IMAGE_SIZE, IMAGE_SIZE), interpolation=BICUBIC),\n", + " ToRGB(),\n", + " ToTensor(),\n", + " Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", + " RandomHorizontalFlip(),\n", + " RandomAutocontrast(p=0.25),\n", + " RandomAffine(\n", + " degrees=22.5,\n", + " scale=(math.sqrt(0.5 * math.pi), math.sqrt(math.pi)),\n", + " shear=5.,\n", + " ),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zS98Xcqn7kcm" + }, + "outputs": [], + "source": [ + "class Tokenizer(object):\n", + " def __init__(self, freq_threshold=1):\n", + " self.encoder = collections.defaultdict(lambda : 3)\n", + " self.encoder[END_TOKEN] = 2\n", + " self.encoder[START_TOKEN] = 1\n", + " self.encoder[PAD_TOKEN] = 0\n", + "\n", + " self.freq_threshold = freq_threshold\n", + "\n", + " frequencies = dict()\n", + " idx = len(self.encoder)\n", + "\n", + " with open(ANNOTATION_PATH) as captions:\n", + " sentence_list = [\n", + " line.rstrip(\"\\n\").split(\"\\t\")[-1].strip().lower()\n", + " for line in captions.readlines()\n", + " ]\n", + "\n", + " for sentence in sentence_list:\n", + " tokenized_sentence = [\n", + " tok.text.lower() for tok in spacy.tokenizer(sentence.strip())\n", + " ]\n", + " for word in tokenized_sentence:\n", + " if word not in frequencies:\n", + " frequencies[word] = 1\n", + " else:\n", + " frequencies[word] += 1\n", + "\n", + " if frequencies[word] == self.freq_threshold:\n", + " idx += 1\n", + " self.encoder[word] = idx\n", + "\n", + " self.decoder = dict()\n", + " self.decoder[0] = PAD_TOKEN\n", + " self.decoder[1] = START_TOKEN\n", + " self.decoder[2] = END_TOKEN\n", + " self.decoder[3] = OOV_TOKEN\n", + " for k, v in self.encoder.items():\n", + " if v not in self.decoder:\n", + " self.decoder[v] = k\n", + "\n", + " def __len__(self):\n", + " assert len(self.encoder) == len(self.decoder)\n", + " return len(self.encoder)\n", + "\n", + " def encode(self, text):\n", + " numericalized_token = list()\n", + " del_oov_token = False\n", + "\n", + " for token in spacy.tokenizer(text.strip()):\n", + " if token.text.lower() not in self.encoder:\n", + " del_oov_token = True\n", + "\n", + " numericalized_token.append(self.encoder[token.text.lower()])\n", + "\n", + " if del_oov_token:\n", + " del self.encoder[token.text.lower()]\n", + " del_oov_token = False\n", + "\n", + " return numericalized_token\n", + "\n", + " def decode(self, tokens):\n", + " return \" \".join([self.decoder[token] for token in tokens])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "50T77egh7nkw", + "outputId": "0a7756dc-1107-4a67-8b84-ba7a53667c14" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Vocab size: 8506\n" + ] + } + ], + "source": [ + "Tokenizer = Tokenizer()\n", + "print(f\"Vocab size: {len(Tokenizer.decoder)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NWopnXqP7t_w" + }, + "outputs": [], + "source": [ + "def tokenize(text):\n", + " sos_token = Tokenizer.encoder[START_TOKEN]\n", + " eos_token = Tokenizer.encoder[END_TOKEN]\n", + " tokens = [sos_token] + Tokenizer.encode(text) + [eos_token]\n", + "\n", + " result = torch.full(\n", + " (MAX_SEQUENCE,),\n", + " Tokenizer.encoder[PAD_TOKEN],\n", + " dtype=torch.long,\n", + " )\n", + "\n", + " if len(tokens) > MAX_SEQUENCE:\n", + " tokens = tokens[:MAX_SEQUENCE]\n", + " tokens[-1] = eos_token\n", + "\n", + " result[:len(tokens)] = torch.tensor(tokens)\n", + "\n", + " return result.long()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "P-LR7IzG8P6j" + }, + "outputs": [], + "source": [ + "# class Flickr8KDataset(data.Dataset):\n", + "# def __init__(self, split):\n", + "# assert split in [\"train\", \"val\", \"test\", \"inference\"]\n", + "\n", + "# self.images = list()\n", + "# self.captions = list()\n", + "\n", + "# with open(ANNOTATION_PATH) as caption_file:\n", + "# for line in caption_file.readlines():\n", + "# # Image name and captions are separated using a tab\n", + "# img_name, caption = line.rstrip(\"\\n\").split(\"\\t\")\n", + "\n", + "# # Each image is repeated five times for the five different\n", + "# # captions. Each image name has a suffix `#(caption_number)`\n", + "# img_name = img_name.split(\"#\")[0]\n", + "# img_name = os.path.join(IMAGE_PATH, img_name.strip())\n", + "\n", + "# caption = caption.strip()\n", + "\n", + "# # We will remove caption that are either too short to too long\n", + "# tokens = [tok.text.lower() for tok in spacy.tokenizer(caption)]\n", + "\n", + "# if img_name.endswith(\"jpg\"):\n", + "# self.images.append(img_name)\n", + "# self.captions.append(caption)\n", + "\n", + "# random.seed(SEED)\n", + "# random.shuffle(self.images)\n", + "\n", + "# random.seed(SEED)\n", + "# random.shuffle(self.captions)\n", + "\n", + "# n_data = len(self.images)\n", + "\n", + "# if split == \"train\":\n", + "# self.transform = TRANSFORM_AUGMENTATION\n", + "# start = 0\n", + "# end = int(0.8 * n_data)\n", + "# else:\n", + "# self.transform = TRANSFORM\n", + "# if split == \"val\":\n", + "# start = int(0.8 * n_data)\n", + "# end = int(0.9 * n_data)\n", + "# else:\n", + "# start = int(0.9 * n_data)\n", + "# end = n_data\n", + "\n", + "# self.images = self.images[start:end]\n", + "# self.captions = self.captions[start:end]\n", + "\n", + "# self.split = split\n", + "\n", + "# def raw_image(self, index):\n", + "# assert self.split == \"inference\"\n", + "# return Image.open(self.images[index]).convert(\"RGB\")\n", + "\n", + "# def inference_data(self, index):\n", + "# assert self.split == \"inference\"\n", + "# image = self.transform(Image.open(self.images[index]))\n", + "# return image\n", + "\n", + "# def __len__(self):\n", + "# assert len(self.images) == len(self.captions)\n", + "# return len(self.images)\n", + "\n", + "# def __getitem__(self, index):\n", + "# image = self.transform(Image.open(self.images[index]))\n", + "# caption = tokenize(self.captions[index])\n", + "# return image, caption\n", + "\n", + "\n", + "class Flickr8KDataset(data.Dataset):\n", + " def __init__(self, split):\n", + " assert split in [\"train\", \"val\", \"test\", \"inference\"]\n", + "\n", + " self.images = list()\n", + " self.captions = list()\n", + "\n", + " with open(ANNOTATION_PATH) as caption_file:\n", + " for line in caption_file.readlines():\n", + " # Image name and captions are separated using a tab\n", + " img_name, caption = line.rstrip(\"\\n\").split(\"\\t\")\n", + "\n", + " # Each image is repeated five times for the five different\n", + " # captions. Each image name has a suffix `#(caption_number)`\n", + " img_name = img_name.split(\"#\")[0]\n", + " img_name = os.path.join(IMAGE_PATH, img_name.strip())\n", + "\n", + " caption = caption.strip()\n", + "\n", + " # We will remove captions that are either too short or too long\n", + " tokens = [tok.text.lower() for tok in spacy.tokenizer(caption)]\n", + "\n", + " if img_name.endswith(\"jpg\"):\n", + " self.images.append(img_name)\n", + " self.captions.append(caption)\n", + "\n", + " # Limit the number of images and captions to 2000\n", + " # if len(self.images) > 6000:\n", + " # self.images = self.images[:6000]\n", + " # self.captions = self.captions[:]\n", + "\n", + " random.seed(SEED)\n", + " random.shuffle(self.images)\n", + "\n", + " random.seed(SEED)\n", + " random.shuffle(self.captions)\n", + "\n", + " n_data = len(self.images)\n", + "\n", + " if split == \"train\":\n", + " self.transform = TRANSFORM_AUGMENTATION\n", + " start = 0\n", + " end = int(0.8 * n_data)\n", + " else:\n", + " self.transform = TRANSFORM\n", + " if split == \"val\":\n", + " start = int(0.8 * n_data)\n", + " end = int(0.9 * n_data)\n", + " else:\n", + " start = int(0.9 * n_data)\n", + " end = n_data\n", + "\n", + " self.images = self.images[start:end]\n", + " self.captions = self.captions[start:end]\n", + "\n", + " self.split = split\n", + "\n", + " def raw_image(self, index):\n", + " assert self.split == \"inference\"\n", + " return Image.open(self.images[index]).convert(\"RGB\")\n", + "\n", + " def inference_data(self, index):\n", + " assert self.split == \"inference\"\n", + " image = self.transform(Image.open(self.images[index]))\n", + " return image\n", + "\n", + " def __len__(self):\n", + " assert len(self.images) == len(self.captions)\n", + " return len(self.images)\n", + "\n", + " def __getitem__(self, index):\n", + " image = self.transform(Image.open(self.images[index]))\n", + " caption = tokenize(self.captions[index])\n", + " return image, caption\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rXUvu7458vnD" + }, + "outputs": [], + "source": [ + "class CollateFunction(object):\n", + " def __init__(self, pad_idx=Tokenizer.encoder[PAD_TOKEN]):\n", + " self.pad_idx = pad_idx\n", + "\n", + " def __call__(self, batch):\n", + " images = [item[0].unsqueeze(0) for item in batch]\n", + " images = torch.cat(images, dim=0)\n", + "\n", + " captions = [item[1] for item in batch] + [torch.randn(MAX_SEQUENCE + 1)]\n", + " captions = pad_sequence(\n", + " captions,\n", + " batch_first=True,\n", + " padding_value=self.pad_idx,\n", + " )[:-1, ...]\n", + " return images, captions.long()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2p6pVG248ypP" + }, + "outputs": [], + "source": [ + "CollateFunction = CollateFunction()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "i2vHyomx80hE" + }, + "outputs": [], + "source": [ + "TrainDataset = Flickr8KDataset('train')\n", + "ValDataset = Flickr8KDataset('val')\n", + "TestDataset = Flickr8KDataset('test')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yrNn-hDc82iq" + }, + "outputs": [], + "source": [ + "class AvgMeter(object):\n", + " def __init__(self):\n", + " self.reset()\n", + "\n", + " def reset(self):\n", + " self.scores = list()\n", + "\n", + " def update(self, val):\n", + " self.scores.append(val)\n", + "\n", + " def show(self):\n", + " scores = torch.stack(self.scores)\n", + " return torch.mean(scores)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DWSs6umh84MJ" + }, + "outputs": [], + "source": [ + "class RMSNorm(nn.Module):\n", + " \"\"\"\n", + " Implements Root Mean Square Normalization introduced in\n", + " https://arxiv.org/pdf/1910.07467.pdf.\n", + "\n", + " Reference implementation (used for correctness verfication)\n", + " can be found here:\n", + " https://github.com/facebookresearch/llama/blob/main/llama/model.py\n", + "\n", + " Args:\n", + " dim (int): embedding size\n", + " eps (float): small value to avoid division by zero. Default: 1e-6\n", + " \"\"\"\n", + "\n", + " def __init__(self, dim, eps=1e-6):\n", + " super().__init__()\n", + " self.eps = eps\n", + " self.scale = nn.Parameter(torch.ones(dim))\n", + "\n", + " def forward(self, x):\n", + " return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.scale" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "a24N97Gn87WF" + }, + "outputs": [], + "source": [ + "class RotaryPositionalEmbedding(nn.Module):\n", + " \"\"\"\n", + " This class implements Rotary Positional Embedding (RoPE)\n", + " proposed in https://arxiv.org/abs/2104.09864.\n", + "\n", + " Reference implementation (used for correctness verfication)\n", + " can be found here:\n", + " https://github.com/facebookresearch/llama/blob/main/llama/model.py#L450\n", + "\n", + " In this implementation we cache the embedding for each position upto\n", + " ``max_seq_len`` by computing this during init.\n", + "\n", + " Args:\n", + " dim (int): Embedding dimension. This is usually set to the dim of each\n", + " head in the attention module computed as ````embed_dim`` // ``num_heads````\n", + " max_seq_len (int): Maximum expected sequence length for the\n", + " model, if exceeded the cached freqs will be recomputed\n", + " base (int): The base for the geometric progression used to compute\n", + " the rotation angles\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " dim,\n", + " max_seq_len=4096,\n", + " base=10_000,\n", + " ):\n", + " super().__init__()\n", + " self.dim = dim\n", + " self.base = base\n", + " self.max_seq_len = max_seq_len\n", + " self._rope_init()\n", + "\n", + " def _rope_init(self):\n", + " theta = 1.0 / (\n", + " self.base\n", + " ** (torch.arange(0, self.dim, 2)[: (self.dim // 2)].float() / self.dim)\n", + " )\n", + " self.register_buffer(\n", + " \"theta\",\n", + " theta.to(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n", + " persistent=False,\n", + " )\n", + " self.build_rope_cache(self.max_seq_len)\n", + "\n", + " def build_rope_cache(self, max_seq_len = 4096):\n", + " # Create position indexes `[0, 1, ..., max_seq_len - 1]`\n", + " seq_idx = torch.arange(\n", + " max_seq_len, dtype=self.theta.dtype, device=self.theta.device\n", + " )\n", + "\n", + " # Outer product of theta and position index; output tensor has\n", + " # a shape of [max_seq_len, dim // 2]\n", + " idx_theta = torch.einsum(\"i, j -> ij\", seq_idx, self.theta).float()\n", + "\n", + " # cache includes both the cos and sin components and so the output shape is\n", + " # [max_seq_len, dim // 2, 2]\n", + " cache = torch.stack([torch.cos(idx_theta), torch.sin(idx_theta)], dim=-1)\n", + " self.register_buffer(\"cache\", cache, persistent=False)\n", + "\n", + " def forward(self, x, input_pos=None):\n", + " \"\"\"\n", + " Args:\n", + " x (Tensor): input tensor with shape\n", + " [bsz, seq_len, num_heads, head_dim]\n", + " input_pos (Optional[Tensor]): Optional tensor which contains the position\n", + " of the current token. This is only used during inference. Default is None\n", + "\n", + " Returns:\n", + " Tensor: output tensor with RoPE applied\n", + "\n", + " Notation used for tensor shapes:\n", + " - b: batch size\n", + " - s: sequence length\n", + " - n_h: num heads\n", + " - h_d: head dim\n", + "\n", + " TODO: The implementation below can be made more efficient\n", + " for inference.\n", + " \"\"\"\n", + " # input tensor has shape [b, s, n_h, n_d]\n", + " seq_len = x.size(1)\n", + "\n", + " # extract the values based on whether input_pos is set or not. When\n", + " # input_pos is provided, we're in inference mode\n", + " rope_cache = (\n", + " self.cache[:seq_len] if input_pos is None else self.cache[input_pos]\n", + " )\n", + "\n", + " # reshape input; the last dimension is used for computing the output.\n", + " # Cast to float to match the reference implementation\n", + " # tensor has shape [b, s, n_h, n_d // 2, 2]\n", + " xshaped = x.float().reshape(*x.shape[:-1], -1, 2)\n", + "\n", + " # reshape the cache for broadcasting\n", + " # tensor has shape [1, s, 1, n_d // 2, 2]\n", + " rope_cache = rope_cache.view(1, xshaped.size(1), 1, xshaped.size(3), 2)\n", + "\n", + " # tensor has shape [b, s, n_h, n_d // 2, 2]\n", + " x_out = torch.stack(\n", + " [\n", + " xshaped[..., 0] * rope_cache[..., 0]\n", + " - xshaped[..., 1] * rope_cache[..., 1],\n", + " xshaped[..., 1] * rope_cache[..., 0]\n", + " + xshaped[..., 0] * rope_cache[..., 1],\n", + " ],\n", + " -1,\n", + " )\n", + "\n", + " # tensor has shape [b, s, n_h, n_d]\n", + " x_out = x_out.flatten(3)\n", + " return x_out.type_as(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Bvgd5dHn9AA6" + }, + "outputs": [], + "source": [ + "class KVCache(nn.Module):\n", + " \"\"\"\n", + " Standalone nn.Module containing a kv-cache to cache past key and values\n", + " during inference.\n", + "\n", + " Args:\n", + " max_batch_size (int): maximum batch size model will be run with\n", + " max_seq_len (int): maximum sequence length model will be run with\n", + " num_heads (int): number of heads. We take num_heads instead of\n", + " num_kv_heads because the cache is created after we've expanded the\n", + " key and value tensors to have the same shape as the query tensor.\n", + " See CausalAttention for more details\n", + " head_dim (int): per-attention head embedding dimension\n", + " dtype (torch.dtype): dtype for the caches\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " max_batch_size,\n", + " max_seq_len,\n", + " num_heads,\n", + " head_dim,\n", + " dtype=torch.float32,\n", + " ):\n", + " super().__init__()\n", + " cache_shape = (max_batch_size, num_heads, max_seq_len, head_dim)\n", + " self.register_buffer(\n", + " \"k_cache\",\n", + " torch.zeros(\n", + " cache_shape,\n", + " dtype=dtype,\n", + " device=\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " ),\n", + " persistent=False,\n", + " )\n", + " self.register_buffer(\n", + " \"v_cache\",\n", + " torch.zeros(\n", + " cache_shape,\n", + " dtype=dtype,\n", + " device=\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " ),\n", + " persistent=False,\n", + " )\n", + " self.max_batch_size = max_batch_size\n", + "\n", + " def update(self, input_pos, k_val, v_val):\n", + " # input_pos: [S], k_val: [B, H, S, D]\n", + " assert input_pos.shape[0] == k_val.shape[2]\n", + "\n", + " k_out = self.k_cache\n", + " v_out = self.v_cache\n", + " k_out[:, :, input_pos] = k_val\n", + " v_out[:, :, input_pos] = v_val\n", + "\n", + " return k_out, v_out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "KclIMAV39CqW" + }, + "outputs": [], + "source": [ + "class CausalSelfAttention(nn.Module):\n", + " \"\"\"Multi-headed grouped query self-attention (GQA) layer introduced\n", + " in https://arxiv.org/pdf/2305.13245v1.pdf.\n", + "\n", + " GQA is a version of multiheaded attention (MHA) which uses fewer\n", + " key/value heads than query heads by grouping n query heads for each\n", + " key and value head. Multi-Query Attention is an extreme\n", + " version where we have a single key and value head shared by all\n", + " query heads.\n", + "\n", + " Following is an example of MHA, GQA and MQA with num_heads = 4\n", + "\n", + " (credit for the documentation:\n", + " https://github.com/Lightning-AI/lit-gpt/blob/main/lit_gpt/config.py).\n", + "\n", + "\n", + " ::\n", + "\n", + " ┌───┐┌───┐┌───┐┌───┐ ┌───┐ ┌───┐ ┌───┐\n", + " │ v ││ v ││ v ││ v │ │ v │ │ v │ │ v │\n", + " └───┘└───┘└───┘└───┘ └───┘ └───┘ └───┘\n", + " │ │ │ │ │ │ │\n", + " ┌───┐┌───┐┌───┐┌───┐ ┌───┐ ┌───┐ ┌───┐\n", + " │ k ││ k ││ k ││ k │ │ k │ │ k │ │ k │\n", + " └───┘└───┘└───┘└───┘ └───┘ └───┘ └───┘\n", + " │ │ │ │ ┌──┴──┐ ┌──┴──┐ ┌────┬──┴─┬────┐\n", + " ┌───┐┌───┐┌───┐┌───┐ ┌───┐┌───┐┌───┐┌───┐ ┌───┐┌───┐┌───┐┌───┐\n", + " │ q ││ q ││ q ││ q │ │ q ││ q ││ q ││ q │ │ q ││ q ││ q ││ q │\n", + " └───┘└───┘└───┘└───┘ └───┘└───┘└───┘└───┘ └───┘└───┘└───┘└───┘\n", + " ◀──────────────────▶ ◀──────────────────▶ ◀──────────────────▶\n", + " MHA GQA MQA\n", + " n_kv_heads =4 n_kv_heads=2 n_kv_heads=1\n", + "\n", + " Args:\n", + " embed_dim (int): embedding dimension for the model\n", + " num_heads (int): number of query heads. For MHA this is also the\n", + " number of heads for key and value\n", + " num_kv_heads (int): number of key and value heads. If specified,\n", + " user should ensure `num_heads` % `num_kv_heads` == 0. Default value is\n", + " `None`, in which case this is the same as MHA\n", + " head_dim (int): dimension of each head, calculated by ``embed_dim`` // ``num_heads``.\n", + " q_proj (nn.Module): projection layer for query.\n", + " k_proj (nn.Module): projection layer for key.\n", + " v_proj (nn.Module): projection layer for value.\n", + " output_proj (nn.Module): projection layer for output.\n", + " pos_embeddings (nn.Module): positional embeddings layer, e.g. RotaryPositionalEmbeddings.\n", + " kv_cache (Optional[KVCache]): KVCache object used to cache key and value.\n", + " If not specified, then no caching is used.\n", + " max_seq_len (int): maximum sequence length supported by the model.\n", + " This is needed to compute the RoPE Cache. Default: 4096.\n", + " attn_dropout (float): dropout value passed onto the\n", + " scaled_dot_product_attention function. This argument is ignored if the\n", + " self.training is False. Default value is 0.0.\n", + "\n", + " Raises:\n", + " ValueError: If `num_heads` % `num_kv_heads` != 0\n", + " ValueError: If `embed_dim` % `num_heads` != 0\n", + " ValueError: If `attn_dropout` < 0 or > 1\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " embed_dim,\n", + " num_heads,\n", + " num_kv_heads,\n", + " head_dim,\n", + " q_proj,\n", + " k_proj,\n", + " v_proj,\n", + " output_proj,\n", + " pos_embeddings,\n", + " kv_cache=None,\n", + " max_seq_len=4096,\n", + " attn_dropout=0.0,\n", + " ):\n", + " super().__init__()\n", + " if num_heads % num_kv_heads != 0:\n", + " raise ValueError(\n", + " f\"num_heads ({num_heads}) must be divisible by \"\n", + " f\"num_kv_heads ({num_kv_heads})\"\n", + " )\n", + "\n", + " if embed_dim % num_heads != 0:\n", + " raise ValueError(\n", + " f\"embed_dim ({embed_dim}) must be divisible by \"\n", + " f\"num_heads ({num_heads})\"\n", + " )\n", + "\n", + " if attn_dropout < 0 or attn_dropout > 1:\n", + " raise ValueError(f\"attn_dropout ({embed_dim}) must be between 0.0 and 1.0\")\n", + "\n", + " # Set attributes\n", + " self.num_heads = num_heads\n", + " self.num_kv_heads = num_kv_heads\n", + " self.embed_dim = embed_dim\n", + " self.attn_dropout = attn_dropout\n", + " self.head_dim = head_dim\n", + " self.max_seq_len = max_seq_len\n", + "\n", + " # Set layers\n", + " self.kv_cache = kv_cache\n", + " self.q_proj = q_proj\n", + " self.k_proj = k_proj\n", + " self.v_proj = v_proj\n", + " self.output_proj = output_proj\n", + " self.pos_embeddings = pos_embeddings\n", + "\n", + " def forward(self, x, y=None, mask=None, input_pos=None):\n", + " \"\"\"\n", + " Args:\n", + " x (Tensor): input tensor with shape\n", + " [batch_size x seq_length x embed_dim]\n", + " y (Optional[Tensor]): input tensor with shape\n", + " [batch_size x 1 x embed_dim]\n", + " mask (Optional[Tensor]): Optional tensor which contains the mask.\n", + " Only used during inference. Default is None.\n", + " input_pos (Optional[Tensor]): Optional tensor which contains the position\n", + " of the current token. This is only used during inference. Default is None\n", + "\n", + " Returns:\n", + " Tensor: output tensor with attention applied\n", + "\n", + " Raises:\n", + " ValueError: if seq_len of x is bigger than max_seq_len\n", + "\n", + " Notation used for tensor shapes:\n", + " - b: batch size\n", + " - s: sequence length\n", + " - n_h: num heads\n", + " - n_kv: num kv heads\n", + " - d: embed dim\n", + " - h_d: head dim\n", + "\n", + " TODO:\n", + " - Return the attention weights\n", + " - Make application of positional embeddings optional\n", + " \"\"\"\n", + " # input has shape [b, s, d]\n", + " bsz, seq_len, _ = x.shape\n", + "\n", + " if seq_len > self.max_seq_len:\n", + " raise ValueError(\n", + " f\"seq_len ({seq_len}) of input tensor should be smaller \"\n", + " f\"than max_seq_len ({self.max_seq_len})\"\n", + " )\n", + "\n", + " if y is None:\n", + " y = x\n", + "\n", + " kv_seq_len = y.shape[1]\n", + "\n", + " # q has shape [b, s, num_heads * head_dim]\n", + " # k has shape [b, s or 1, num_kv_heads * head_dim]\n", + " # v has shape [b, s or 1, num_kv_heads * head_dim]\n", + " q = self.q_proj(x)\n", + " k = self.k_proj(y)\n", + " v = self.v_proj(y)\n", + "\n", + " # number of queries per key/value\n", + " q_per_kv = self.num_heads // self.num_kv_heads\n", + "\n", + " # q: [b, s, n_kv, q_per_kv, h_d]\n", + " # k: [b, s or 1, n_kv, 1, h_d]\n", + " # v: [b, s or 1, n_kv, 1, h_d]\n", + " q = q.view(bsz, seq_len, self.num_kv_heads, q_per_kv, self.head_dim)\n", + " k = k.view(bsz, kv_seq_len, self.num_kv_heads, 1, self.head_dim)\n", + " v = v.view(bsz, kv_seq_len, self.num_kv_heads, 1, self.head_dim)\n", + "\n", + " # if needed, expand the key and value tensors to have the same shape\n", + " # as the query tensor by copying values across the relevant dim\n", + " if self.num_heads != self.num_kv_heads:\n", + " k = k.expand(bsz, kv_seq_len, self.num_kv_heads, q_per_kv, self.head_dim)\n", + " v = v.expand(bsz, kv_seq_len, self.num_kv_heads, q_per_kv, self.head_dim)\n", + "\n", + " # llama2 applies the RoPE embeddings on tensors with shape\n", + " # [b, s or 1, n_h, h_d]\n", + " # Reshape the tensors before we apply RoPE\n", + " q = q.reshape(bsz, seq_len, -1, self.head_dim)\n", + " k = k.reshape(bsz, kv_seq_len, -1, self.head_dim)\n", + " v = v.reshape(bsz, kv_seq_len, -1, self.head_dim)\n", + "\n", + " # Apply positional embeddings\n", + " q = self.pos_embeddings(q, input_pos)\n", + " k = self.pos_embeddings(k, input_pos)\n", + "\n", + " # [b, n_h, s or 1, h_d]\n", + " q = q.transpose(1, 2)\n", + " k = k.transpose(1, 2)\n", + " v = v.transpose(1, 2)\n", + "\n", + " # Update key-value cache\n", + " if self.kv_cache is not None:\n", + " k, v = self.kv_cache.update(input_pos, k, v)\n", + "\n", + " # Flash attention from https://pytorch.org/blog/accelerating-large-language-models/\n", + " output = nn.functional.scaled_dot_product_attention(\n", + " q,\n", + " k,\n", + " v,\n", + " attn_mask=mask,\n", + " dropout_p=self.attn_dropout,\n", + " is_causal=self.kv_cache is None,\n", + " )\n", + "\n", + " # reshape the output to be the same shape as the input\n", + " output = output.transpose(1, 2).contiguous().view(bsz, seq_len, -1)\n", + " return self.output_proj(output)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3G12F3GW9G0n" + }, + "outputs": [], + "source": [ + "def _get_clones(module, n):\n", + " \"\"\"\n", + " Return a list of ``n`` identical layers.\n", + "\n", + " Args:\n", + " module (nn.Module): module to be cloned\n", + " n (int): number of clones\n", + "\n", + " Returns:\n", + " nn.ModuleList: list of ``n`` identical layers\n", + " \"\"\"\n", + " # FIXME: copy.deepcopy() is not defined on nn.module\n", + " return nn.ModuleList([copy.deepcopy(module) for i in range(n)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SG2AKE6J9In4" + }, + "outputs": [], + "source": [ + "class TransformerEncoderLayer(nn.Module):\n", + " \"\"\"Transformer layer derived from the Llama2 model. Normalization is applied\n", + " before the attention **and** FF layer.\n", + "\n", + " Args:\n", + " attn (CausalSelfAttention): Attention module.\n", + " mlp (nn.Module): Feed-forward module.\n", + " sa_norm_x (nn.Module): Normalization to be applied before self-attention.\n", + " mlp_norm (nn.Module): Normalization to be applied before the feed-forward layer.\n", + " \"\"\"\n", + "\n", + " def __init__(self, attn, mlp, sa_norm, mlp_norm):\n", + " super().__init__()\n", + " self.sa_norm = sa_norm\n", + " self.attn = attn\n", + " self.mlp_norm = mlp_norm\n", + " self.mlp = mlp\n", + "\n", + " def forward(self, x, mask=None, input_pos=None):\n", + " \"\"\"\n", + " Args:\n", + " x (Tensor): input tensor with shape\n", + " [batch_size x 1 x embed_dim]\n", + " mask (Optional[Tensor]): Optional tensor which contains the mask.\n", + " Only used during inference. Default is None.\n", + " input_pos (Optional[Tensor]): Optional tensor which contains the position\n", + " of the current token. This is only used during inference. Default is None\n", + "\n", + " Returns:\n", + " Tensor: output tensor with same shape as input\n", + " [batch_size x 1 x embed_dim]\n", + "\n", + " Notation used for tensor shapes:\n", + " - b: batch size\n", + " - d: embed dim\n", + "\n", + " TODO:\n", + " - Make position of norm configurable\n", + " \"\"\"\n", + " # Input tensor and attention output have the same shape\n", + " # [b, 1, d]\n", + " # Norm applied before self-attention\n", + " attn_out = self.attn(self.sa_norm(x), mask=mask, input_pos=input_pos)\n", + "\n", + " # Residual connection; shape: [b, 1, d]\n", + " h = attn_out + x\n", + "\n", + " # Norm applied before the feedforward layer\n", + " mlp_out = self.mlp(self.mlp_norm(h))\n", + "\n", + " # Residual connection; shape: [b, 1, d]\n", + " out = h + mlp_out\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M5RD4EsQ9LIb" + }, + "outputs": [], + "source": [ + "class TransformerEncoder(nn.Module):\n", + " \"\"\"\n", + " Transformer Encoder derived from the Llama2 architecture.\n", + "\n", + " Args:\n", + " feature_extractor (nn.Module): Image feature extractor.\n", + " layer (TransformerEncoderLayer): Transformer Encoder layer.\n", + " num_layers (int): Number of Transformer Encoder layers.\n", + " max_seq_len (int): maximum sequence length the model will be run with, as used\n", + " by KVCache\n", + " num_heads (int): number of query heads. For MHA this is also the\n", + " number of heads for key and value. This is used to setup the\n", + " KVCache\n", + " head_dim (int): embedding dimension for each head in self-attention. This is used\n", + " to setup the KVCache\n", + " norm (nn.Module): Callable that applies normalization to the output of the encoder.\n", + "\n", + " Note:\n", + " Arg values are checked for correctness (eg: ``attn_dropout`` belongs to [0,1])\n", + " in the module where they are used. This helps reduces the number of raise\n", + " statements in code and improves readability.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " feature_extractor,\n", + " layer,\n", + " num_layers,\n", + " max_seq_len,\n", + " num_heads,\n", + " head_dim,\n", + " norm,\n", + " ):\n", + " super().__init__()\n", + "\n", + " self.feature_extractor = feature_extractor\n", + " self.layers = _get_clones(layer, num_layers)\n", + " self.norm = norm\n", + " self.max_seq_len = max_seq_len\n", + " self.num_heads = num_heads\n", + " self.head_dim = head_dim\n", + " self.causal_mask = None\n", + "\n", + " def setup_caches(self, max_batch_size, dtype=torch.float32):\n", + " # inference only\n", + " for layer in self.layers:\n", + " layer.attn.kv_cache = KVCache(\n", + " max_batch_size=max_batch_size,\n", + " max_seq_len=self.max_seq_len,\n", + " num_heads=self.num_heads,\n", + " head_dim=self.head_dim,\n", + " dtype=dtype,\n", + " )\n", + "\n", + " # causal_mask is used during inference to ensure we're attending\n", + " # to the right tokens\n", + " self.causal_mask = torch.tril(\n", + " torch.ones(\n", + " self.max_seq_len,\n", + " self.max_seq_len,\n", + " dtype=torch.bool,\n", + " device=\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " )\n", + " )\n", + "\n", + " def clear_caches(self):\n", + " for layer in self.layers:\n", + " layer.attn.kv_cache = None\n", + " self.causal_mask = None\n", + "\n", + " def forward(self, image, input_pos=None):\n", + " \"\"\"\n", + " Args:\n", + " image (Tensor): input tensor with shape [b x c x h x w]\n", + " input_pos (Optional[Tensor]): Optional tensor which contains the position\n", + " of the current token. This is only used during inference. Default is None\n", + "\n", + " Note: At the very first step of inference, when the model is provided with a prompt,\n", + " ``input_pos`` would contain the positions of all of the tokens in the prompt\n", + " (eg: ``torch.arange(prompt_length)``). This is because we will need to compute the\n", + " KV values for each position.\n", + "\n", + " Returns:\n", + " Tensor: output tensor with shape [b x 1 x d]\n", + "\n", + " Raises:\n", + " ValueError: if causal_mask is set but input_pos is None\n", + "\n", + " Notation used for tensor shapes:\n", + " - b: batch size\n", + " - c: channel\n", + " - h: height\n", + " - w: width\n", + " - v: vocab size\n", + " - d: embed dim\n", + " - m_s: max seq len\n", + " \"\"\"\n", + " # input tensor of shape [b, c, h, w]\n", + " bsz = image.shape[0]\n", + "\n", + " # shape: [b, 1, d]\n", + " h = self.feature_extractor(image).view(bsz, 1, -1)\n", + "\n", + " mask = None\n", + " if self.causal_mask is not None:\n", + " if input_pos is None:\n", + " raise ValueError(\n", + " \"Caches are setup, but the position of input token is missing\"\n", + " )\n", + " # shape: [1, input_pos_len, m_s]\n", + " # in most cases input_pos_len should be 1\n", + " mask = self.causal_mask[None, None, input_pos]\n", + "\n", + " for layer in self.layers:\n", + " # shape: [b, 1, d]\n", + " h = layer(h, mask, input_pos)\n", + "\n", + " # shape: [b, 1, d]\n", + " return self.norm(h).float()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QaGi_K7i9N5c" + }, + "outputs": [], + "source": [ + "class TransformerDecoderLayer(nn.Module):\n", + " \"\"\"Transformer layer derived from the Llama2 model. Normalization is applied\n", + " before the attention **and** FF layer.\n", + "\n", + " Args:\n", + " attn1 (CausalSelfAttention): Attention module.\n", + " attn2 (CausalSelfAttention): Attention module.\n", + " mlp (nn.Module): Feed-forward module.\n", + " sa_norm_x1 (nn.Module): Normalization to be applied before self-attention.\n", + " sa_norm_x2 (nn.Module): Normalization to be applied before self-attention.\n", + " mlp_norm (nn.Module): Normalization to be applied before the feed-forward layer.\n", + " \"\"\"\n", + "\n", + " def __init__(self, attn1, attn2, mlp, sa_norm_x1, sa_norm_x2, mlp_norm):\n", + " super().__init__()\n", + " self.sa_norm_x1 = sa_norm_x1\n", + " self.sa_norm_x2 = sa_norm_x2\n", + " self.attn1 = attn1\n", + " self.attn2 = attn2\n", + " self.mlp_norm = mlp_norm\n", + " self.mlp = mlp\n", + "\n", + " def forward(self, x, y, mask=None, input_pos=None):\n", + " \"\"\"\n", + " Args:\n", + " x (Tensor): input tensor with shape\n", + " [batch_size x seq_length x embed_dim]\n", + " y (Tensor): input tensor with shape\n", + " [batch_size x 1 x embed_dim]\n", + " mask (Optional[Tensor]): Optional tensor which contains the mask.\n", + " Only used during inference. Default is None.\n", + " input_pos (Optional[Tensor]): Optional tensor which contains the position\n", + " of the current token. This is only used during inference. Default is None\n", + "\n", + " Returns:\n", + " Tensor: output tensor with same shape as input\n", + " [batch_size x seq_length x embed_dim]\n", + "\n", + " Notation used for tensor shapes:\n", + " - b: batch size\n", + " - s: sequence length\n", + " - d: embed dim\n", + "\n", + " TODO:\n", + " - Make position of norm configurable\n", + " \"\"\"\n", + " # Input tensor and attention output have the same shape\n", + " # [b, s, d]\n", + " # Norm applied before self-attention\n", + " attn_out = self.attn1(self.sa_norm_x1(x), mask=mask, input_pos=input_pos)\n", + "\n", + " # Residual connection; shape: [b, s, d]\n", + " h = attn_out + x\n", + "\n", + " # [b, s, d]\n", + " # Norm applied before self-attention\n", + " attn_out = self.attn2(\n", + " self.sa_norm_x2(h),\n", + " y,\n", + " mask=mask,\n", + " input_pos=input_pos,\n", + " )\n", + "\n", + " # Residual connection; shape: [b, s, d]\n", + " h = attn_out + h\n", + "\n", + " # Norm applied before the feedforward layer\n", + " mlp_out = self.mlp(self.mlp_norm(h))\n", + "\n", + " # Residual connection; shape: [b, s, d]\n", + " out = h + mlp_out\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RLJAWHMT9QjN" + }, + "outputs": [], + "source": [ + "class TransformerDecoder(nn.Module):\n", + " \"\"\"\n", + " Transformer Decoder derived from the Llama2 architecture.\n", + "\n", + " Args:\n", + " tok_embedding (nn.Embedding): PyTorch embedding layer, to be used to move\n", + " tokens to an embedding space.\n", + " layer (TransformerDecoderLayer): Transformer Decoder layer.\n", + " num_layers (int): Number of Transformer Decoder layers.\n", + " max_seq_len (int): maximum sequence length the model will be run with, as used\n", + " by KVCache\n", + " num_heads (int): number of query heads. For MHA this is also the\n", + " number of heads for key and value. This is used to setup the\n", + " KVCache\n", + " head_dim (int): embedding dimension for each head in self-attention. This is used\n", + " to setup the KVCache\n", + " norm (nn.Module): Callable that applies normalization to the output of the decoder,\n", + " before final MLP.\n", + " output (nn.Linear): Callable that applies a linear transformation to the output of\n", + " the decoder.\n", + "\n", + " Note:\n", + " Arg values are checked for correctness (eg: ``attn_dropout`` belongs to [0,1])\n", + " in the module where they are used. This helps reduces the number of raise\n", + " statements in code and improves readability.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " tok_embedding,\n", + " layer,\n", + " num_layers,\n", + " max_seq_len,\n", + " num_heads,\n", + " head_dim,\n", + " norm,\n", + " output,\n", + " ):\n", + " super().__init__()\n", + "\n", + " self.tok_embedding = tok_embedding\n", + " self.layers = _get_clones(layer, num_layers)\n", + " self.norm = norm\n", + " self.output = output\n", + " self.max_seq_len = max_seq_len\n", + " self.num_heads = num_heads\n", + " self.head_dim = head_dim\n", + " self.causal_mask = None\n", + "\n", + " def setup_caches(self, max_batch_size, dtype=torch.float32):\n", + " # inference only\n", + " for layer in self.layers:\n", + " layer.attn1.kv_cache = KVCache(\n", + " max_batch_size=max_batch_size,\n", + " max_seq_len=self.max_seq_len,\n", + " num_heads=self.num_heads,\n", + " head_dim=self.head_dim,\n", + " dtype=dtype,\n", + " )\n", + " layer.attn2.kv_cache = KVCache(\n", + " max_batch_size=max_batch_size,\n", + " max_seq_len=self.max_seq_len,\n", + " num_heads=self.num_heads,\n", + " head_dim=self.head_dim,\n", + " dtype=dtype,\n", + " )\n", + "\n", + " # causal_mask is used during inference to ensure we're attending\n", + " # to the right tokens\n", + " self.causal_mask = torch.tril(\n", + " torch.ones(\n", + " self.max_seq_len,\n", + " self.max_seq_len,\n", + " dtype=torch.bool,\n", + " device=\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " )\n", + " )\n", + "\n", + " def clear_caches(self):\n", + " for layer in self.layers:\n", + " layer.attn1.kv_cache = None\n", + " layer.attn2.kv_cache = None\n", + " self.causal_mask = None\n", + "\n", + " def forward(self, tokens, enc, input_pos=None):\n", + " \"\"\"\n", + " Args:\n", + " tokens (Tensor): input tensor with shape [b x s]\n", + " enc (Tensor): extracted feature maps encoder [b x d]\n", + " input_pos (Optional[Tensor]): Optional tensor which contains the position\n", + " of the current token. This is only used during inference. Default is None\n", + "\n", + " Note: At the very first step of inference, when the model is provided with a prompt,\n", + " ``input_pos`` would contain the positions of all of the tokens in the prompt\n", + " (eg: ``torch.arange(prompt_length)``). This is because we will need to compute the\n", + " KV values for each position.\n", + "\n", + " Returns:\n", + " Tensor: output tensor with shape [b x s x v]\n", + "\n", + " Raises:\n", + " ValueError: if causal_mask is set but input_pos is None\n", + "\n", + " Notation used for tensor shapes:\n", + " - b: batch size\n", + " - s: sequence length\n", + " - v: vocab size\n", + " - d: embed dim\n", + " - m_s: max seq len\n", + " \"\"\"\n", + " # input tensor of shape [b, s]\n", + " # bsz, seq_len = tokens.shape\n", + " bsz = tokens.shape[0]\n", + "\n", + " # shape: [b, s, d]\n", + " h = self.tok_embedding(tokens)\n", + "\n", + " enc = enc.view(bsz, 1, -1)\n", + "\n", + " mask = None\n", + " if self.causal_mask is not None:\n", + " if input_pos is None:\n", + " raise ValueError(\n", + " \"Caches are setup, but the position of input token is missing\"\n", + " )\n", + " # shape: [1, input_pos_len, m_s]\n", + " # in most cases input_pos_len should be 1\n", + " mask = self.causal_mask[None, None, input_pos]\n", + "\n", + " for layer in self.layers:\n", + " # shape: [b, s, d]\n", + " h = layer(h, enc, mask, input_pos)\n", + "\n", + " # shape: [b, s, d]\n", + " h = self.norm(h)\n", + "\n", + " # shape: [b, s, v]\n", + " output = self.output(h).float()\n", + " return output" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "T-WXsdvP9T8j" + }, + "outputs": [], + "source": [ + "class FeedForward(nn.Module):\n", + " \"\"\"This class implements the feed-forward network derived from Llama2.\n", + "\n", + " Args:\n", + " gate_proj (nn.Module): Projection from input dim to hidden dim, fed\n", + " through activation and multiplied by up_proj.\n", + " down_proj (nn.Module): Final projection to output dim.\n", + " up_proj (nn.Module): Projection from input dim to hidden dim, multiplied by\n", + " activation(gate_proj).\n", + " activation (nn.Module): Activation function to use. Default is nn.SiLU().\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " *,\n", + " gate_proj,\n", + " down_proj,\n", + " up_proj,\n", + " activation=nn.SiLU(),\n", + " ):\n", + " super().__init__()\n", + " self.w1 = gate_proj\n", + " self.w2 = down_proj\n", + " self.w3 = up_proj\n", + " self.activation = activation\n", + "\n", + " def forward(self, x):\n", + " return self.w2(self.activation(self.w1(x)) * self.w3(x))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iK7hVNjJ9WDy" + }, + "outputs": [], + "source": [ + "class ImageCaptioning(L.LightningModule):\n", + " def __init__(self):\n", + " super().__init__()\n", + "\n", + " self.batch_size = BATCH_SIZE\n", + " self.max_epoch = MAX_EPOCH\n", + " self.lr = LEARNING_RATE\n", + " self.lr_now = self.lr * 1e3\n", + "\n", + " MLP = FeedForward(\n", + " gate_proj=nn.Linear(EMBED_DIM, int(EMBED_DIM * MLP_SCALE), bias=False),\n", + " down_proj=nn.Linear(int(EMBED_DIM * MLP_SCALE), EMBED_DIM, bias=False),\n", + " up_proj=nn.Linear(EMBED_DIM, int(EMBED_DIM * MLP_SCALE), bias=False),\n", + " )\n", + "\n", + " # MobileNetV3 + LLaMA 3\n", + " FEATURE_EXTRACTOR = mobilenet_v3_large(\n", + " weights=MobileNet_V3_Large_Weights.IMAGENET1K_V2\n", + " )\n", + " FEATURE_EXTRACTOR.classifier[2] = nn.Dropout(p=DROPOUT, inplace=True)\n", + " FEATURE_EXTRACTOR.classifier[3] = nn.Linear(\n", + " in_features=1280,\n", + " out_features=EMBED_DIM,\n", + " bias=False,\n", + " )\n", + " SELF_ATTENTION = CausalSelfAttention(\n", + " embed_dim=EMBED_DIM,\n", + " num_heads=NUM_HEAD,\n", + " num_kv_heads=NUM_KV_HEAD,\n", + " head_dim=HEAD_DIM,\n", + " q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False),\n", + " k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False),\n", + " v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False),\n", + " output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False),\n", + " pos_embeddings=RotaryPositionalEmbedding(\n", + " dim=HEAD_DIM,\n", + " max_seq_len=1,\n", + " base=ROPE_BASE,\n", + " ),\n", + " max_seq_len=1,\n", + " attn_dropout=DROPOUT,\n", + " )\n", + " ENCODER_LAYER = TransformerEncoderLayer(\n", + " attn=SELF_ATTENTION,\n", + " mlp=copy.deepcopy(MLP),\n", + " sa_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM),\n", + " mlp_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM),\n", + " )\n", + " self.encoder = TransformerEncoder(\n", + " feature_extractor=FEATURE_EXTRACTOR,\n", + " layer=ENCODER_LAYER,\n", + " num_layers=NUM_LAYER,\n", + " max_seq_len=MAX_SEQUENCE,\n", + " num_heads=NUM_HEAD,\n", + " head_dim=HEAD_DIM,\n", + " norm=RMSNorm(EMBED_DIM, eps=EPS_NORM),\n", + " )\n", + "\n", + " # LLaMA 3\n", + " TOKEN_EMBEDDING = nn.Embedding(len(Tokenizer.decoder), EMBED_DIM)\n", + " ROPE = RotaryPositionalEmbedding(\n", + " dim=HEAD_DIM,\n", + " max_seq_len=MAX_SEQUENCE,\n", + " base=ROPE_BASE,\n", + " )\n", + " SELF_ATTENTION_1 = CausalSelfAttention(\n", + " embed_dim=EMBED_DIM,\n", + " num_heads=NUM_HEAD,\n", + " num_kv_heads=NUM_KV_HEAD,\n", + " head_dim=HEAD_DIM,\n", + " q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False),\n", + " k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False),\n", + " v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False),\n", + " output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False),\n", + " pos_embeddings=ROPE,\n", + " max_seq_len=MAX_SEQUENCE,\n", + " attn_dropout=DROPOUT,\n", + " )\n", + " SELF_ATTENTION_2 = CausalSelfAttention(\n", + " embed_dim=EMBED_DIM,\n", + " num_heads=NUM_HEAD,\n", + " num_kv_heads=NUM_KV_HEAD,\n", + " head_dim=HEAD_DIM,\n", + " q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False),\n", + " k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False),\n", + " v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False),\n", + " output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False),\n", + " pos_embeddings=ROPE,\n", + " max_seq_len=MAX_SEQUENCE,\n", + " attn_dropout=DROPOUT,\n", + " )\n", + " DECODER_LAYER = TransformerDecoderLayer(\n", + " attn1=SELF_ATTENTION_1,\n", + " attn2=SELF_ATTENTION_2,\n", + " mlp=copy.deepcopy(MLP),\n", + " sa_norm_x1=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM),\n", + " sa_norm_x2=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM),\n", + " mlp_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM),\n", + " )\n", + " OUT_PROJECTION = nn.Linear(EMBED_DIM, len(Tokenizer.decoder), bias=False)\n", + " self.decoder = TransformerDecoder(\n", + " tok_embedding=TOKEN_EMBEDDING,\n", + " layer=DECODER_LAYER,\n", + " num_layers=NUM_LAYER,\n", + " max_seq_len=MAX_SEQUENCE,\n", + " num_heads=NUM_HEAD,\n", + " head_dim=HEAD_DIM,\n", + " norm=RMSNorm(EMBED_DIM, eps=EPS_NORM),\n", + " output=OUT_PROJECTION,\n", + " )\n", + "\n", + " self.automatic_optimization = False\n", + "\n", + " self.train_loss = list()\n", + " self.val_loss = list()\n", + "\n", + " self.train_loss_recorder = AvgMeter()\n", + " self.val_loss_recorder = AvgMeter()\n", + "\n", + " self.test_rogue = ROUGEScore()\n", + "\n", + " self.sanity_check_counter = 1\n", + "\n", + " def forward(self, image, caption):\n", + " image_feature = self.encoder(image)\n", + " return self.decoder(caption, image_feature)\n", + "\n", + " def captionize(self, image, temperature=TEMPERATURE, top_p=TOP_P):\n", + " assert image.shape[0] == 1\n", + "\n", + " self.encoder.setup_caches(max_batch_size=1)\n", + " encoder_feat = self.encoder(\n", + " image,\n", + " input_pos=torch.tensor([0], device=self.device),\n", + " )\n", + " self.encoder.clear_caches()\n", + "\n", + " self.decoder.setup_caches(max_batch_size=1)\n", + "\n", + " pred_token = Tokenizer.encoder[START_TOKEN]\n", + " token = [pred_token] + [Tokenizer.encoder[PAD_TOKEN]] * (MAX_SEQUENCE)\n", + " for index in range(MAX_SEQUENCE):\n", + " caption = torch.LongTensor([pred_token]).unsqueeze(0).to(self.device)\n", + "\n", + " pred_token = self.decoder(\n", + " caption,\n", + " encoder_feat,\n", + " input_pos=torch.tensor([index], device=self.device),\n", + " )\n", + "\n", + " if temperature > 0:\n", + " # Apply temperature -> make distribution softer (?)\n", + " pred_token = (pred_token / temperature).softmax(-1)[0]\n", + " # Sampling\n", + " psort, pidx = torch.sort(pred_token, dim= -1, descending=True)\n", + " psum = torch.cumsum(psort, dim=-1)\n", + " psort[psum - psort > top_p] = 0.\n", + " psort.div_(psort.sum(dim=-1, keepdim=True))\n", + " pred_token = torch.multinomial(psort, num_samples=1)\n", + " pred_token = torch.gather(pidx, -1, pred_token).transpose(0, 1)\n", + " else:\n", + " pred_token = pred_token.softmax(-1).argmax(2)\n", + "\n", + " pred_token = pred_token.item()\n", + " token[index + 1] = pred_token\n", + "\n", + " if pred_token == Tokenizer.encoder[END_TOKEN]:\n", + " break\n", + "\n", + " self.decoder.clear_caches()\n", + "\n", + " return self.postprocess_text(Tokenizer.decode(token))\n", + "\n", + " def postprocess_text(self, text):\n", + " text = text.replace(START_TOKEN, \"\")\n", + " text = text.replace(END_TOKEN, \"\")\n", + " text = text.replace(PAD_TOKEN, \"\")\n", + " text = re.sub(r'\\s([,.!?])', r'\\1', text)\n", + " text = '. '.join(map(lambda s: s.strip().capitalize(), text.split('.')))\n", + " return text\n", + "\n", + " def training_step(self, batch, batch_nb):\n", + " image, caption = batch\n", + "\n", + " pred = self(image, caption[:, :-1])\n", + " pred = pred.view(-1, pred.shape[-1])\n", + " caption = caption[:, 1:].reshape(caption.shape[0] * (caption.shape[-1] - 1))\n", + "\n", + " loss = F.cross_entropy(pred, caption, ignore_index=Tokenizer.encoder[PAD_TOKEN])\n", + "\n", + " opt = self.optimizers()\n", + " opt.zero_grad()\n", + " self.manual_backward(loss)\n", + " torch.nn.utils.clip_grad_norm_(\n", + " self.parameters(),\n", + " math.log2(math.sqrt(math.e * math.tau) * math.pi),\n", + " )\n", + " opt.step()\n", + "\n", + " self.log(\"train_loss\", loss, prog_bar=True)\n", + " self.train_loss_recorder.update(loss.data)\n", + "\n", + " def on_train_epoch_end(self):\n", + " sch = self.lr_schedulers()\n", + " sch.step()\n", + " self.train_loss.append(self.train_loss_recorder.show().data.cpu().numpy())\n", + " self.train_loss_recorder = AvgMeter()\n", + "\n", + " def validation_step(self, batch, batch_nb):\n", + " image, caption = batch\n", + "\n", + " pred = self(image, caption[:, :-1])\n", + " pred = pred.view(-1, pred.shape[-1])\n", + " caption = caption[:, 1:].reshape(caption.shape[0] * (caption.shape[-1] - 1))\n", + "\n", + " loss = F.cross_entropy(pred, caption, ignore_index=Tokenizer.encoder[PAD_TOKEN])\n", + "\n", + " if self.sanity_check_counter == 0:\n", + " self.log(\"val_loss\", loss, prog_bar=True)\n", + " self.val_loss_recorder.update(loss.data)\n", + "\n", + " def on_validation_epoch_end(self):\n", + " if self.sanity_check_counter == 0:\n", + " loss = self.val_loss_recorder.show().data.cpu().numpy()\n", + " lr_now_ = self.optimizers().param_groups[0][\"lr\"]\n", + " if self.lr_now != lr_now_:\n", + " self.lr_now = lr_now_\n", + " str_report = f\"[{MODEL_NAME}] Learning Rate Changed: {lr_now_}\"\n", + " str_report += f\"- Epoch: {self.current_epoch}\"\n", + " print(str_report)\n", + " self.val_loss.append(loss)\n", + " self.val_loss_recorder = AvgMeter()\n", + " else:\n", + " self.sanity_check_counter -= 1\n", + "\n", + " def test_step(self, batch, batch_nb):\n", + " image, caption = batch\n", + "\n", + " N_BATCH = image.shape[0]\n", + "\n", + " rogue1_fmeasure = list()\n", + "\n", + " for id in range(N_BATCH):\n", + " pred = self.captionize(image[id].unsqueeze(0))\n", + " target = self.postprocess_text(\n", + " Tokenizer.decode(\n", + " caption[id].cpu()\n", + " .detach()\n", + " .numpy()\n", + " .tolist()\n", + " )\n", + " )\n", + " rogue1_fmeasure.append(\n", + " self.test_rogue(pred, target)['rouge1_fmeasure']\n", + " .cpu()\n", + " .detach()\n", + " .numpy()\n", + " .tolist()\n", + " )\n", + "\n", + " rogue1_fmeasure = np.array(rogue1_fmeasure).mean()\n", + " self.log(\"ROGUE-1 F-measure\", rogue1_fmeasure, prog_bar=True, logger=True)\n", + "\n", + " def on_train_end(self):\n", + " # Loss\n", + " img_file = f\"experiment/training/{MODEL_NAME}_loss_plot.png\"\n", + " plt.plot(self.train_loss, color=\"r\", label=\"train\")\n", + " plt.plot(self.val_loss, color=\"b\", label=\"validation\")\n", + " plt.title(\"Loss Curves\")\n", + " plt.xlabel(\"Epoch\")\n", + " plt.ylabel(\"Loss\")\n", + " plt.legend()\n", + " plt.grid()\n", + " plt.savefig(img_file)\n", + " plt.clf()\n", + " img = cv2.imread(img_file)\n", + " cv2_imshow(img)\n", + "\n", + " def train_dataloader(self):\n", + " return data.DataLoader(\n", + " TrainDataset,\n", + " batch_size=self.batch_size,\n", + " shuffle=True,\n", + " collate_fn=CollateFunction,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " )\n", + "\n", + " def val_dataloader(self):\n", + " return data.DataLoader(\n", + " ValDataset,\n", + " batch_size=self.batch_size,\n", + " shuffle=False,\n", + " collate_fn=CollateFunction,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " )\n", + "\n", + " def test_dataloader(self):\n", + " return data.DataLoader(\n", + " TestDataset,\n", + " batch_size=self.batch_size,\n", + " shuffle=False,\n", + " collate_fn=CollateFunction,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " )\n", + "\n", + " def configure_optimizers(self):\n", + " optimizer = optim.AdamW(self.parameters(), self.lr)\n", + "\n", + " lr_scheduler = {\n", + " \"scheduler\": optim.lr_scheduler.MultiStepLR(\n", + " optimizer,\n", + " milestones=[int(self.max_epoch * ms) for ms in MILESTONES],\n", + " gamma=REDUCE_LR_FACTOR,\n", + " ),\n", + " \"name\": \"lr_scheduler\",\n", + " }\n", + "\n", + " return [optimizer], [lr_scheduler]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0kC6GNtU9buD" + }, + "outputs": [], + "source": [ + "MODEL_NAME = ImageCaptioning.__name__\n", + "MODEL = ImageCaptioning\n", + "BEST_MODEL_PATH = os.path.join(\n", + " EXPERIMENT_DIR,\n", + " # f\"model/{MODEL_NAME}_best.ckpt\",\n", + " '/content/drive/MyDrive/ImageCaptioning_best.ckpt'\n", + ")\n", + "LAST_MODEL_PATH = os.path.join(\n", + " EXPERIMENT_DIR,\n", + " # \"model/last.ckpt\",\n", + " '/content/drive/MyDrive/ImageCaptioning_best.ckpt'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2tkp59Is9ecv" + }, + "outputs": [], + "source": [ + "def _train_loop():\n", + " seed_everything(SEED, workers=True)\n", + "\n", + " print(MODEL_NAME)\n", + " model = MODEL()\n", + "\n", + " callbacks = list()\n", + "\n", + " checkpoint = ModelCheckpoint(\n", + " monitor=METRIC_TO_MONITOR,\n", + " dirpath=f\"{EXPERIMENT_DIR}/model\",\n", + " mode=METRIC_MODE,\n", + " filename=f\"{MODEL_NAME}_best\",\n", + " save_last=True,\n", + " )\n", + " callbacks.append(checkpoint)\n", + "\n", + " if os.path.exists(BEST_MODEL_PATH):\n", + " ckpt_path = BEST_MODEL_PATH\n", + " else:\n", + " ckpt_path = None\n", + "\n", + " trainer = Trainer(\n", + " accelerator=\"auto\",\n", + " devices=1,\n", + " max_epochs=MAX_EPOCH,\n", + " logger=False,\n", + " callbacks=callbacks,\n", + " log_every_n_steps=5,\n", + " )\n", + " trainer.fit(model, ckpt_path=ckpt_path)\n", + "\n", + "# _train_loop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XjpQpszT9ktS" + }, + "outputs": [], + "source": [ + "INFERENCE_SAMPLE = 9\n", + "MAX_CHAR = 50" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vZtNKSo596YN", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "acd2d017-d05f-47c9-f96e-83c1f1df9d35" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Downloading: \"https://download.pytorch.org/models/mobilenet_v3_large-5c1a4163.pth\" to /root/.cache/torch/hub/checkpoints/mobilenet_v3_large-5c1a4163.pth\n", + "100%|██████████| 21.1M/21.1M [00:00<00:00, 44.9MB/s]\n" + ] + } + ], + "source": [ + "model = MODEL.load_from_checkpoint('/content/drive/MyDrive/ImageCaptioning_best.ckpt')\n", + "model.eval()\n", + "\n", + "InferenceDataset = Flickr8KDataset('inference')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "amqbXxEN9-kA", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 793 + }, + "outputId": "3d473e26-22ac-4017-bd1c-b1ea5b7f3d4c" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAM1CAYAAAD0DYmZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZwUxfn48U9VdffM7OzFLjcih4rghbeYGK8Y5esVj3zFRCMmatRIEr8xHlETNCEaMV6J4hW8FcUTr0SNgnihoiIgIMh9LCx7z+7M9FFVvz96mZ8EVFSMGvv9evmSne3uqerpmZ2n66mnhLXWkkgkEolEIpFIJBKJL5X8shuQSCQSiUQikUgkEokkOEskEolEIpFIJBKJr4QkOEskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4AkOEskEon/kLq6Ov7+97/z+uuvb/I+zz//PFdfffUX0p7Zs2czduxYGhsbv5T9v4q+Ln1qb2/n7rvv/lTX0jqvv/46f/jDH76AViUSiUTi80qCs0QikfiQww47jPPOO48LL7wQIQRXXnklo0aN4pRTTvncx+7ZsyeTJk1i7ty5APzxj3/k7rvvBkBrvV5AsHbtWgAqKyv561//+rmed/jw4SxatGiDx7feemuuuOIKcrncZzruZ93/xRdf5LTTTvtMz/lF+7zn5D+lvLycGTNmlK6lf6e15tprr0UIwXXXXcfll1/OiBEj+OCDDxg4cCCjR4/+D7c4kUgkEpvC+bIbkEgkEl8lv/jFLxg+fDhLlizh8ssv59xzzwXg2Wef/dzHFkJQW1tb+vmCCy5AKYW1lrPPPptjjz2W/fffn7/85S907dqVk08+mW7dun3u5500aRKpVGqDx9PpNBUVFZ/5uJ91//32249hw4Z95uf9In3ec/Kf9HHtVEpx1FFH8X//93/86le/AmDUqFFccMEFPPTQQ/+pJiYSiUTiU0pGzhKJROJDhg8fvtHHDz74YH73u99x0EEH0dbWxlFHHcWoUaOw1nLttdfy1FNPkcvl+NOf/sRjjz3G6aefzksvvfSRz5PL5bjnnnuYNm0aa9as4fnnn+eFF15g1qxZPPnkk7z++uvMnj17g33GjRvH+PHjOeqoo6irq1vv94sWLeKCCy7g5ptvpqysjMsvv5xly5Zx3XXX0dDQwLx589h77725+eab2XHHHYmiqLSv1prRo0fzj3/8gzPPPHO94y5dupSDDz6Yiy++mB/96EfsvffeG6T9RVHEL3/5SyZNmsQJJ5xAe3s7Tz75JGVlZaxYsYIwDPnxj39MfX09Tz75JA8//DBRFHHppZcyYsQIrrrqKnbYYYdSn8ePH88tt9zCT37yEwYPHsyUKVPWe765c+dy9dVX88ADDzBy5EhWrlzJ/Pnz2XHHHbn55pv54Q9/yOmnn/6R539z9qmhoWGj5/7fz7fv+1x22WU89thjnH322TzyyCO0trby7W9/mzvuuIOlS5eyzTbbMGXKFF5//XUGDRrE3XffzaGHHsqYMWMAWLZsGZdccgmPPvoo06ZN+8j+/TtrLR988AFbb731eo+3tLTwq1/9ikceeYSTTjoJYwzXX389/fv3p7Gxkfb29lLf33jjDS699FL+8pe/4Hked999N6+++iq7774748eP5zvf+c5G3wP19fUMHDiQKVOmMHfuXKqqqliyZAmTJk1i2LBh3Hrrreyzzz7ceeedm9yfxFfLO++8w3XXXfdlN2OTfF1Slz/s1Vdf/dqc34/T3NzM3//+d956660vuymf2xf5miTBWSKRSGyic845h4ULF5LJZDjppJNYuHAhQggcx+Gwww7jsssuY/DgwRx11FH87ne/Y8SIEVhrN3qsbDbL7NmzmT9/Pj179qR79+4ceOCB7LjjjvTv35+99tqLHXbYYb19xo4dS0dHB9lslgEDBvDmm2+u9/t//vOfVFdXc/rpp3PwwQdz1FFH0adPHyZOnEh7ezuDBw9m5cqVDBs2jHfffRfH+f/JE7lcjn/84x/stttuXHjhhesdt1+/fgRBwHe+8x3uu+8+Bg0axI033rjeNoVCgX79+nHkkUdSLBZ55513OPzwwznooIOYPn06QRCw55570r17d7TWPPvssziOQ79+/ZBScs4553D44Yfz5JNPAnDzzTdz5JFHcvXVV1NdXc3++++/3vP99Kc/ZeTIkYwYMYKDDz6YX//61wwaNIhcLsf+++/P7bff/rFf9jdnn7p27brRc//v5/uOO+4glUpx1FFH8ac//YlRo0ahtWabbbYptalPnz4A7LXXXixYsIDjjjuOq6++mnvuuQeAM844g5EjR3L00Uezxx57fGT/Puyaa67hnHPO4cADD9xgrllrays777wz3//+95k3bx4rV67krLPOorq6muXLl9PQ0MARRxxBeXk5Dz30ENtuuy2/+c1v2GmnnTjqqKMYNmwYb731Fj/4wQ948cUXN/oe6NatG1tuuSUAQ4YMoUuXLgAMHTqU5cuXc8opp3DxxRczYcKETepPYtN9kWnaH7bVVltxzTXXbNZjflG+zHTsu+66q3SjZVPU19cDUFVVtcHn0xcln8/T0dHxuY4xcOBALr30Uo4//ni22morrrjiCo444ggmTZrEs88+y4IFCzZTaz/euvP3WV1yySWMHDmSsWPHUlNTw5lnnsnFF1/MHnvs8YW+JklaYyKRSGyi6upqDjjgAJ588kkWLlxIa2srs2fPprKyEoCZM2eW0vW22GKL0jyyrl27bnAsKeWnTp976623uPzyyxk6dCjHH3/8Br//yU9+wi9/+Uv++c9/cuaZZzJkyBAgnp/04eetqqpCyvXvzVVXV3P22Wez11578dvf/paf/exnGxx/XWrk3nvvvcGoXkVFBX379uXJJ59ECIHWGoj/uJ1xxhl0dHRw7LHHAvEXjY0dN51OUywWAfjrX//Ktddey1577cV99923QVtmzpxZCi533XVXLr/88vWOl06n8X1/g/2+qD591Ln/8PmeOXMmgwYNAuLgvG/fvhudC/jv7fvweZk6dSq9evUC4tTFTfF///d/H/m7fv36Ya3l+eefx3EctNYIIfj973/PmDFj2G+//UpfSC+44ALOO+88qqurueaaa9a7fte9ph/1HvgorusipVyvj4nN54tM0/6wdZ+BXwdfZjr2iSeeWPoc+STz5s3j4osv5qGHHiKbzX6u591UYRhy4okncvXVV3+u5xw3bhzDhw/njjvuYPXq1Zx//vmcc845TJ06lbKyss3Y4o/20ksvcd99932uAGrYsGFccsklQNynESNGsP/++7Pvvvt+oa9JMnKWSCQSn8IZZ5zB6NGj2WmnnTj11FP58Y9/zNFHHw3AbrvtxquvvgpAEAR07dp1o4HZxkgpMcZs8O8PGzhwIDfddBMAxWKRJ554Yr3fT5s2jeHDhzN8+HAOOeSQT9Wv+vp69tlnH958803+9re/0dbW9pHb1tXVsc8++6z32NSpU7n33ns54ogj8Dyv1P5dd92Vnj17MnXqVHr37r3J7bnvvvu47LLLOProoxk4cOAGv//wuW5sbGT33Xff5GNvzOft06ac+w+3GeIvQoMGDUIpRT6fByj9/6P07t27dAxjTGlkdtWqVZ+h1/Gd/HfffZeDDz64dEyAo48+moULF9LW1kY6nQbiuYtnnnkmw4cP5zvf+c4n9vHD74F1fbTWJkHYf9AXnaZ9ww03cM8993D77beXHlu1ahV//vOfefjhh/nJT37Ce++9B2w8VXn69OncdNNN3Hjjjdx1113rHXvp0qWce+653H///YwaNQqAW265heOOO45zzz2Xs88+m1deeYV77rmHiy66iAsuuGCD/b9K6di+7/Pggw/y7LPPks/nGTVqFKeffjpjxoxh++23Z/Xq1eu17dlnn2XOnDmlz/kgCLj66qs5+OCDueyyy4A4vXv8+PFceeWVnHzyyev93Whra2OHHXbgjjvuKKUTv/HGGwRBwIgRI2hvb+fPf/4zEydO5Mwzz2TGjBksW7aMl156iSeeeIL6+nqefvpp7rvvPkaNGsX1119PY2MjI0eOZPTo0ey3334bZG+ss7HrznEcDjzwQCBOCbzgggvYcccdS/0eP3489957LyNGjNjgWhs/fjzbb789bW1tnHnmmRx99NH4vs9jjz3GDTfcsNFr5dFHH2XOnDm88MILG50S8Nhjj3HwwQdzxRVX8L//+7+b3A+g9Hn5aV+TTZUEZ4lEIvFvCoUCjz/+OAATJ05cb27WnnvuyT777MMhhxzC8ccfz6GHHlq6C3v++efT2NjIXXfdxY033rjeFxaA1atXM2fOHN59911WrlzJnDlzePvttykUCuy7775cd911zJ49m3322Yc77riDV199leeff57m5mbmzZvHhRdeyKxZs9h99935zW9+w3e/+931jm+M4be//S277roru+yyC9dddx1LlixhxYoVvPzyy8yZM4fm5mYmT56M1pqZM2fS0NDAq6++Sj6f56yzzuLNN9/k6KOP3uid5UmTJpW+QI0YMWK9/auqqnj77bf5wx/+QNeuXbn11lsJggCAkSNHcthhhwFxQPLGG2+wYMEC1qxZw9tvv13697vvvsu8efMoFovk83n22GMPhg4dyr777rvBqNb48eOZOHEiDz/8MFOmTGHs2LEsXryYpqYm3nzzTd544w0gngvzcTZHnz7q3P/7+T755JPp1asXN910E3//+98ZM2YMlZWVHH300YwbN45rrrmGvn37MnfuXKZPnw5Q6ktLSwtLlizhhhtu4Nxzz+X3v/89S5cuZc6cOfi+z+GHH75eqpDWmqeffhqABx54YL0+P//880D8Bal79+48/vjjXHXVVfTr14/rr78eiIvXnHjiiRxxxBGl/YQQ/PjHP2aXXXZht91244EHHuCVV14B4F//+hfw0e+B4447jksuuYSbbrqJ7bffnhkzZjB9+nSamppYuHAhb7zxBqtWrfrcaUiJTfd507TfeOMN3nzzTU488UROOumk9Y77ve99j2OPPZZTTz2Vn/70p8DGU5WnTZvGqlWrOP300znggAPWa19DQwP77rsvRx99NJMmTQLilMQFCxZw5ZVXctVVV3HhhRfiOA7bb7996WbCOl+1dGzP81izZg1vvvkmZWVldO3alZqaGi6++GJ23HHHDebV7rTTTnTv3r30HiwUCvzqV7/iuuuuK1X5Peecc0qj8FEUsXjx4tL+lZWV/PKXv2TmzJkMGTKE/fbbj8WLF6O15pBDDqG8vJwwDDn22GMZMmQITzzxBFtttRXZbLZ0Q+qqq65CSsnQoUOZNm0atbW1WGupqalh8uTJm5xa/e+GDBnCn//8Z7bbbjtefPFFnn/+eV5++WWUUgwdOpSXX355ve1PPvlkfN8nCAJOO+003n//fVKpFA0NDZx66qkbvVZ22mknBgwYwIEHHrjRKQE77bQT77zzDr/5zW82+IzcVJ/2NdlkNpFIJBL/FX73u9/ZIAistdaGYWivv/76zXbs/fbbz06ePPlT7ZPP563v+/aiiy6yURRt8n51dXX22muvLf28Zs0ae999932q594Um7NPX+S5/0/L5XKlPn7Yb3/729K/i8WivfHGG//TTUt8RosXL7Yb+8r3k5/8xD7yyCN27Nixdu+997azZs2yd955p7XW2kMPPdQ+9thjpW27d+9u165dW/r5yiuvtOeff37p5379+llrrd1uu+3sjBkzrLXx+yWbzVprrX3ttdfs+eefbx955BG7cOFCa621hULBnnTSSXa33Xazc+bMWa9tQRDYcePG2RdffNH27dvXWmvt5MmT7X777WetjT8Xdt5554/t94ff4zfeeKM966yzSm1dvHixtdbaBx54wD7++OP22GOPLW371ltv2T322MPec889duXKlaXnHjlypLXW2ttvv73079GjR9vRo0d/ZB8/7Pbbby9t++H9Ro4caW+//fb1tv1wXxcvXlw6vx/+d58+fT62/7lczg4cONAuXbrU/va3v7Xf+9737D333GMbGxuttdZOmzbN3n333XbMmDGltqw7N6+//ro96qijNjjmxtr6UW6//fZSHza2/7p/X3HFFet95m/MpZdeaq+++mp7zTXX2KOPPtpOnTrV3nDDDdbajV8rH36N/ud//qd0Ta7z4fO4Kfr167fe34vP+ppsimTkLJFIJP5L5HI5jj32WH75y19yww03rDey83ksXbqUFStW8Morr3xi2t2H3XzzzQwYMIADDjhgk+dHQZxq9OSTT3LCCSdwwQUX8OyzzzJixIjP0vSPtLn79EWd+y/D7373O7bbbrv1zrm1liVLlnDsscfy61//mvHjx/ODH/zgS2xlYnP4PGnavXv35rXXXgPWT7H9qJTjjaUqz549mzvvvJM//vGP/O53v1uvbZdffjnFYpF9992XKIo2SA+rra1lyZIlpaql06dP/9hRiq9COvan8VHp7R9WXV1dGvVZtGhRacR9nfLycg455BDOOussLrnkEoIgYOHChdTU1FAoFDj22GM58cQT6dat2wZp9VtuuSUvvPBC6Zw+99xzNDc3b9CGz5pS/WEDBw7kzjvvpFAoAHHGyr879dRTueWWW6ipqWHUqFGceuqppRTyjV0rHz5/nzQlAOK004aGhs/dl096TTZFUhAkkUgk/kt8UdXS+vXrxwcffPCp9zv77LM5++yzP/V+W2yxBc8999yn3u/T2Nx9+rpUqtsU11xzzQb9EUJstDBL4qvv39O0jznmmFIxnQ+naefzeRYuXLhemvavfvUr7rrrLpqbmzdI0/7f//1fJk2axDHHHMPhhx9ORUUFb775JldeeSXnn38+NTU1LFmyhFtvvRWglKocRRFVVVWMGzeOp59+mldeeYVu3bptMO+nd+/eXHXVVaRSKbbbbjv+9re/kc/nWbZsGfPnz2fQoEHceuut/OhHP2Lw4MEcd9xxnHzyyRv0f9KkSSxbtgzYMHV5++233yB1eZ999sHzPEaOHInrusAnp2OnUqn10rE/3Md1VXc7OjqYMWMGK1asKBWTAlizZg3z5s2jpqamFFRAnPq3cuVKbr75ZrLZLE1NTSxYsKCUDrxo0SLGjRvHaaedxi233MKhhx7KOeecs0H/f/7zn/PSSy/heR4/+9nPSstpSCmprKzktNNOY4cdduCZZ57hlFNOYb/99mPMmDGlokAHHnggu+yyCz/5yU8Iw5AFCxaQzWY5+uijqaqq4vDDD+eBBx4oVZ1dp66ujhdffJGFCxfy+uuvs9dee9Hc3Mz7779PRUUFhx56KO+//z6VlZVcc801PPHEE+y8887sueeeXHzxxRv0o3fv3gwfPpwRI0bgeR6HHnooW2211UdeK9/97ncZM2YM999/PxdeeCHHHXccu+++O8OGDWPs2LE8+uijNDY28s4777DLLrswadIknnnmGcaPH7/Bc0+ePJn6+nqeeeYZdtxxR2pra5k2bdpnfk0+ibD2I+o8JxKJROIb5amnnqKjo4Pjjjvuy25KIpH4L7J69WoeeOCB0oLo9fX1PP/88/zwhz/8Qp93//3355JLLtlgKY6PUygUUErxhz/8gUsvvXSTR/2/rD4m/vskaY2JRCKRANYvIrExzc3NfPvb32bmzJkfu95Pst1/ZrtE4uviP5Gq/O/+G9OxE98MSVpjIpFIJIBPXquoqqqK2traUpWxZLsvd7tE4uviP5Gq/O/+G9OxE98MSXCWSCQS32C+73PZZZex8847b3Qdow+TUvLrX/+a3r178/3vfz/Z7kveLpFIJBL/fZI5Z4lEIvENNnbsWLp168ZPfvITnn/+ee6++27uuOOOL7tZiUTiG+TVV1/lzTffLM3X2lxmzpzJE088wUUXXbRZj7sxzzzzDCtXriyt67a5fFHn5vPQWvP4449jjOHYY4/drMf+os7jvysUCjzyyCP06NGDgw466DMdY+rUqSxYsIBTTjlls7YtmXOWSCQS32BTp06lV69eAJ9qfkUikfhm+bwLhF9yySWMHDmSsWPHUlNTw5lnnsnFF1/MHnvsQVVV1QYLRH8e69q61VZb8cc//nGzHfeUU07hF7/4BVdeeSVCCC688ELOPfdcDj30UKIo2mgJ+M9qXR8297n5NA477DDOO+88LrzwQoQQXHnllYwaNYqf/exn1NXVbdY0znX93dzncY899uDiiy/mzDPPpKamhrFjx3LSSSdxxRVX8O67736mUvfrVFdXlxaf3pyS4CyRSCS+wXr37l1ak+jDaxU1NjZSLBY/cf9ku//MdonEl+mll15i9OjRn+sYw4YN48477+S8886jsrKSESNGMGbMGP70pz+RzWY3U0vjqoknnHACwGY9LsTLB/ztb3/j3HPPBeBnP/sZV155JWefffZmfa558+bx85//HNj8ffg0fvGLXzB27Fh+9rOfAXDuuedy/fXXM2LECMrKyjbb83z4+trc/f3jH//ImDFjGDFiBJWVlZx33nncddddfOtb3/rcffikedqfVRKcJRKJxDfYRRddxL/+9S9GjRrF5MmTaW5uZtWqVYwePbq0kObHSbb7z2yXSGwu48ePZ/vtt6etrY0zzzyTo48+Gt/3eeyxx7jhhhtYunQp5557Lvfffz+jRo0C4NFHH2XOnDm88MIL5HI5xo0bx/jx4znqqKOoq6vjscce4+CDD+aKK67YYL2ydYYPH77Rxw8++GAgXuj66quv5uCDD+ayyy4DYO7cuYwfP54rr7ySk08+eYNFmV955RXGjRvHXXfdxU9/+lPa2tp44403mDFjBvfff39pu5tuuokf/OAHnHHGGUC8cPJNN93EuHHj+MEPfkBHRwe33HILxx13HOeee+5HFgT5pD60tLRwxRVXsPfee3PXXXeV2njPPfdw0UUXccEFF2yw76RJk7jrrru46aabOOuss4iiiGeffZY5c+aUFkvelHMTBAGXX345p5xyCj/96U+5+uqrN9rWT+OT+rts2TL+9Kc/sfPOO/P8888D8PTTT3PfffcxatQorr/++g32veOOO5g4cSJXXnllaT2zD19fsGnnsb29nd/85jecffbZfP/73+fhhx/+TH2YPXs2o0ePZocddiitPffAAw9w7733cvLJJ29wXGstl112GQ8++OB6n91z587l6quv5oEHHmDkyJGsXLlyo8+7SWwikUgkEolE4hshiiK71VZb2bVr19q33nrLDhkyxFpr7a233mqLxaKdPn26ffzxx22xWLRbbLGFtdba22+/3Y4cOdJaa+3FF19sx44daydMmGDPPvtsO2nSJLtw4ULbtWtXG0WR1Vp/Yhv69etnJ0+eXPp58eLFtmfPnjaKIjtnzhw7ePBga621//M//2MnTJhgJ0yYYE844QT7wQcflPYxxtghQ4aUnm/MmDH2vPPOs4sXL7b9+vUrbQfYfD5v8/m8TafT1lprTzzxRHv77bfbCRMm2J/97Gf21Vdftc8//7zdeeedrbV2k/oA2MWLF5d+njx5st1jjz2stdY+/fTTdvjw4dYYY/fdd187YcIEe++999of/OAHtrW1tbRPY2Oj3XPPPUs/n3rqqXbcuHF28uTJdr/99vvU52b8+PH2qKOO2uQ+bKrFixfbfw8Zbr/9dnvcccdZa60dN26cPeOMM2xzc7M98MAD7YQJE+wtt9xiTzjhhPX2mTNnjj3yyCNLPx900EH26aefXu/6+jTn8Xe/+509++yzrbXx9fBxJk+evN51Ya21o0ePtuedd5611trzzjvP/vnPf7bvv/++PfLII+2ECRPstddeWzr+Og888ID9/e9/b6219oMPPii9TsOGDbMNDQ3WWmvvueee0rn5LJJqjYlEIpFIJBLfEEopTjrpJO6++26EEAwePJiXXnqJIAhIpVLstNNOvPHGG7z++usIITbY/6233uLyyy9n6NChHH/88QAsWbKEbDb7ueatplIplFJkMhkKhQIQF/RY9xzr/r9OQ0MDdXV1SBknge26667ccMMNGz12JpMBKKUQv/XWW1x//fVUVVWVjjtlyhSqqqoASsf8tNalya3rw9q1a2lrays9x49+9KP1tl+4cCFBEJR+3nXXXXnvvfcYMmTIettt6rl56aWXPncfPo1153Vdu+bPn09lZWWpPf++TuPs2bPXa9e6/nbt2nW97Tb1PEopS/3d2LX6WfowY8YMBg4cuMH1ts7UqVPZYYcdgPXnac+cORPHcUr9uvzyyz9TeyBJa0wkEolEIpH4Rjn11FO55ZZbqKmpYdSoUZx66qkccsghAFx++eUUi0X23XdfoijCGIOUspRSOHDgQG666SYgDnbWpd59mO/7NDQ0fO52VldXl1LHFi1atF7xhm7dulFZWcncuXOBeP7m7rvvvl5bP8qH+9DY2FhKyfuw9vZ2WltbP1f7a2trWbJkCdOmTQNg+vTpLF68uPT7QYMGsWrVKpqamj51Hz7u3KzzUXNaN5Zytznmv2655Za88MILpT4+99xzNDc3l36/88478/bbbxOGYek5N6W/n3Qe11m9ejVRFH2uPgwcOJAHH3yw9Jo88sgjaK1Lv/+oedq77bZb6fF1/fqskuAskUgkEolE4hukd+/eDB8+nBEjRnDAAQdw6KGHstVWW5V+d8sttzBu3Di22247/va3v7Hrrrsybdo07r//fi688EJmzZrF7rvvzm9+8xu++93v8sorr9DY2Mg777wDxPOozj///I0+9+TJk6mvr+eZZ56hsbERgGnTptHU1MSCBQt47bXXaGpqYtGiRYwbN47f//73fPe73+XRRx/d4AvvxIkTueaaa3j00UdZvHgx5557Lr169SKbzfKXv/yltHbjtGnTeO2114D4i/0VV1zBhAkT2GeffbjqqqvYf//9ee2111i2bBnz588H4MYbb+S6667boP3GmFI1wUmTJtHR0VF6juXLl7Nq1Spee+01li9fTkNDA7feeis/+tGPOPTQQ5k9ezYDBgwoHauqqorbbruNSy+9lEcffRQpJSeddBJDhgxh5cqV3Hzzzbz88subdG523HFHpk+fzvvvv8/y5cuBjc9pXb58+UZLx3/U/NdCocDjjz9eOt9RFBFFEdOnT2f+/PnU19fz5ptvsmDBAsrKyhgzZgwHHnggxxxzDMVikS5dupSOtc022zB69GhGjx7NQw89xE477cT++++/3vW1qeextraWWbNmMXPmTNauXQvEBVo2tl5nc3MzzzzzDPX19fzrX/8CIJ/PM3PmTGbNmsXatWuZOXMms2fPZscdd+TEE09kjz324Pjjj6dnz57rjZD9/Oc/p66ujpNPPplHH30UrTXz589n/PjxTJw4kYcffpgpU6YwduzYDdqxqZJ1zhKJRCKRSCQSiUTiKyAZOUskEolEIpFIJBKJr4AkOEskEolEIpFIJBKJr4CkWmMikUgkEolEIvEl0lrz+OOPY4zh2GOP/bKbk/gSJcFZIpFIJBKJRCLxH3DYYYex/fbb4zgOl19+OWPHjmXp0qUUCgV22203Zs6c+amDs/r6erp37/4FtTjxn5YUBEkkEolEIpFIJP4D/vnPfzJ8+HCWLFnCgAEDSqXYn332WVatWsW0adNKZf43RS6X4+CDDy5Vo0x8/X0j55w99dRTpTKom9PUqVO59tprP/L3hUKBBx54gAkTJmz2595UYRjy0EMP8cwzz3ym/Z966inGjx//kb9vaWnhjjvu4B//+MdnbeIX5tVXX91oWdxEIpFIJBKJz8r3fc455xzuu+8+Bg0axMiRI1mzZs1Gtx0+fPhGHz/44IMBWLZsGX/605/YeeedS+uvPf3009x3332MGjWK66+/fr39Fi9eXCpDv3LlSrp3786UKVN46aWXyGazLFu2jFwux3HHHUcURUyaNIm77rqLm266ibPOOutzrwuW2Pw2W3D2xhtvsMUWW3DCCSes97i1lu23355ddtmltHbEZzF06NDSquibKp/Ps/POO2/wuNaap59+GoA//vGP3H333Z+5XR9WU1Oz0bsdL774IqeddhqZTIa6urrPHBhtDq7rltaOgHghyqlTp2502/r6+g0es9by4IMPbvD4XXfdxZgxY6iurmbGjBm8/vrrm6W9P//5z1m9evXnOsa6flRVVXHjjTdujmYlEolEIpFIALBw4ULee+89fvSjH3HmmWey995706NHj890rIqKCi666CJOP/10HnroIVpaWrjqqquQUjJ06NDSQszr7LTTTgAcf/zx9OnTh1NPPZWZM2fyne98h6222oq6ujpaW1v50Y9+RFtbG5dddhknnXQSZ5xxBkEQcOutt37u/ic2r80252zPPffkkEMO4b777mPhwoWlxQyffPJJevTowZZbbsmgQYM+8/HfeOMNUqnUp9qnrKxso0FCZWVl6d8XXHDBeovLfR7l5eUbfXy//fZj2LBhQLyi+5etsrKytPL5DTfcsNHzunr1an784x/z3HPPrff4R/XxxBNPLK2gvrn6WFdXx5QpU6isrOTPf/7zZzrGvHnzuPjii3nooYfIZrObpV2JRCKRSCQS62y33XbssssuPPLII/Tp04djjjnmMx8rk8mU/l8oFJg/fz6VlZUcf/zxAJx22mkfu//PfvYzjjnmGPbdd1++973vMX78eHbZZRdOO+003nnnHYIgKG2766678t57733mtia+GJs1rbFv374cf/zx632Rfumll9h3331LP7/zzjv8/ve/5+abb2bMmDFEUcSll17KiBEjuOqqq9hhhx2YPXv2esedN28el112GQBtbW1ceumlG119ft68eey9997cfPPNpZXS16Wx+b7P6NGjefTRR0srnedyOe655x6mTZtGc3Mzxx13HBdccAHnn38+u+++O8ViEYDf/va3TJgwgb333psjjjiCBQsWfOQ58H2f3/72t+y+++6ce+65GGN48sknefjhh9fbrlgscuKJJ/LII48QBAEPPPAA9957LyeffPIG2wJce+21PProo/zud79j3Lhxm3TePqy5uZnf//73PPbYY6XV0deuXcutt97KvHnzWLFiBYcddhh/+ctf2HXXXXnmmWeYMWMG999//0aP9atf/YqddtqJa6+9Ft/3efDBB3n22WfX266hoYEf/vCHpVHK8ePHc++99zJixIiNruD+7+677z4ee+wxxo8fT2trK8DH9ntjQ/XPPvssc+bM4YknngAgCAKuvvpqDj744NI1NXfuXMaPH8+VV17JySefTBAEXH755Zxyyin89Kc/5eqrry61adasWey+++5cccUVHHnkkRx66KH4vs+qVau46aabGDduHD/4wQ/o6Ojglltu4bjjjuPcc8/l7LPP5rbbbuOpp57izDPPZMmSJWitueyyy3jsscc4++yzeeSRR8jn84waNYrTTz+dMWPGsP3223/ukcNEIpFIJBJfnMbGRjzP45hjjuG4447DcZzS4+u+S35WW265JS+88AKLFy8G4LnnnqO5uXm9bYQQGGMA6N+/Pz179uTGG2/kyiuvZNq0aVhrcRyHQYMGsWrVqtIN+sbGRnbffffP1b7E5rfZ55xdcMEF3HPPPaxYsYJp06bxrW99a73fr1mzhkMPPZQf/vCH3H777TiOQ79+/ZBScs4553D44Yfz5JNPrrfPwIEDS+mCy5YtY9q0aRx44IGMGjVqve0GDx7MypUrGTZsGO+++y5bb70148aNA+C6666jf//+HH300Rx22GEAZLNZZs+ezfz58+nSpQtlZWUMGDCAK664AsdxmDFjBrlcjscff5wf/vCHnHfeeWy//fZss802H9n/fD7PmDFjePnll7n//vt566230FqvF7j4vs9tt93GuHHjOOaYY1iyZAn33XcfSil22WUXXn755fWO+cwzz7Bw4UKOPvpo/vCHP/DXv/6V999//xPP24dddNFFHHDAARx11FEccMABANTW1jJ58mRWr17NFltsQS6XY5tttmH69Onst99+ZLPZ0p2aD9Nac9111/H8888zevRompqaWLNmDW+++WZpm5aWFiZOnMhdd93FoYceyvPPP8/LL7+MUoqhQ4du0Md/197ejlKKQYMGMXz48NLr+FHXS1NT00aH6nfaaSe6d+/OEUccAcTz/n71q19x3XXXldJZzznnHLLZLH379iWKIpYvX06PHj1oamritttu4+yzzy61a8cdd6ShoYGjjjqKxx9/nI6ODh588EHOP/980uk0NTU11NbWMnPmTLbeemsWLFjAlVdeydVXX80///lPHMfhqquuorKykr///e+kUimOOuoo/vSnPzFq1CiKxSJdu3alpqaGiy++mB133JEpU6Z87LlKJBKJRCLx5YmiiEceeYTdd9+dnXbaiZ/+9KcYYxg9ejQPPPDABtsXCoXSQMHEiROJoogoipg+fTrz58+nvr6eN998kwULFlBWVsaYMWM48MADOeaYYygWi3Tp0mW94+2333789re/LU3jOOusszjyyCORUnLSSSfx/e9/H4ind9x2221ceumlPProo6XfJ75aNnsp/W233ZYjjjiCK6+8kmw2y5/+9CdmzJhR+v23vvUt7r77bpRSpTQ4oJRal06nN7jL4HleaZh3hx124Hvf+x5Dhw7lmmuuoW/fvuttK6WkqqoKKeV66XVTp04tBXPr0hillFRUVKy3/7+3o6KiglNPPZU777yTdDrNxRdf/LH9z2QyKKVQSrH33nuzbNkyamtr19vmgw8+YMGCBYwcORKAGTNmMHDgwI0GQgAzZ84s3YURQjB06FDmzp37ieftw6ZOncovf/nLj+3/h8/dx1mX2titWze23XZbVq1atV6qJMD06dN57733OP300wF466232HnnnT+yj//unnvuobW1lWuvvZbu3btz3XXX8X//93+k0+mN9nvhwoUbHaofMmTIesdNpVIopUrpAhCf33XtWvf/l156iaqqqtJ5+Xfrnn/vvfdm9erVvPXWW1x//fVUVVWVjjFlypT1jjF27FiOP/54+vfvzy233MLMmTNLqb7rgsNFixZttH+JRCKRSCS+mp5++mkeeughtt12W4wx3HnnnXR0dGxQvGOdTCbDL3/5y9L3snU+vP0NN9xQ+vcvfvELfvGLX3zk80+ePHm9n9cNQgD85je/2eB3635/9NFHf0LPEl+GzTpyFoYhABdeeCG33norgwYNQgix3jZnn302vXv3ZujQoaUh2E9jzpw5nHnmmbzwwgtceOGFm7xf7969efXVVwEwxrCpKwhEUcTSpUsZOXIkI0aM+Mg5VxvT0dHBnnvuucHj22+/PaeddhqnnnoqEI8MPvjgg6Xg5pFHHlkvcN1tt91KbQdobW3daKGTj/Np+y+l3KTXRym1QQAEcNBBB7H77ruXgtmBAwdy5513lgKiddUyV61atcG+URSxatUqRo8ezdlnn81VV13FVlttxW233faR7fioofpN6Ud1dXXpztaiRYuYPn36J/Z7nbq6OvbZZ5/1RncbGxtLFZY+rKGhgddee43+/ftz1113bfC6hmH4ueZlJhKJRCKR+M9zXZezzjqL008/nT//+c9st912G9z8TyQ21WYbOXvxxReZOHEihx56KN/+9rc58cQT+dGPfsSSJUt49dVXqaurY86cOfTt25fLL7+c5uZmamtrmThxIm+//TYLFixgzZo1vPvuu6RSKYrFYmmUZM6cOTQ1NfHyyy8TRRFXXXUVxxxzDD/+8Y/Xa8OcOXNobm5m8uTJnHTSSbz22ms0NTUxd+5cLrroIn74wx/S1NREly5daG5uZuXKlaVjH3300SxYsICKigoOOeQQlixZwjvvvMPee+/Na6+9xu67704QBGy99dbcddddGw3Sunbtynbbbcdtt92G67qcccYZ9OzZkwkTJrBgwQKWLl3K9OnTWbx4MWPHjuXWW2/lrLPO4pJLLuHEE09kjz32YI899uCXv/zlekVKDjzwQI444giuuOIK+vbtywknnMDAgQP561//+rHn7cOuuOIKTjvtNObOnYvv++RyOVavXs0HH3zAtGnTGDBgACtWrOCVV15hr732olevXmSzWf7yl79w+umnlz5kBg4cSHl5OXfffTeFQoGrrroKay0zZsxgxYoVLF26lFmzZuG6Ltdeey177LEHmUyGX/3qVzzxxBPsvPPO7LnnnqWg7fDDD+eBBx4opYpGUcTFF19MR0cHQRDgeR4dHR3079+fyy67jL322muj10sqlSoN1e+///6lofrGxkZWrlzJzTffTDabpampiQULFjB9+nSamppYtGgR48aN47TTTuOWW27h0EMPZdSoUdxxxx28//77LF++fIPRWYB7772XXr16MXToUIYNG8YVV1zBCSecwBNPPMG+++7LH//4R8aOHcuyZcuYP38+gwYN4oorruD444+nurqaAw88kMGDBzNz5kxuuukmHMdhzJgxeJ5XmkO3Zs0a5s2bR01NDcaYTxzRTCQSiUQi8Z934okncuKJJ37ZzUj8l0gWof4Ezz33HEopDjzwQKy1PPvss/Tv359tt932y25a4kvSv39/pkyZQv/+/b/spiQSiUQikUgk/ots9jln/22EEPzxj3/k3nvvpW/fvnznO99JArNvsHWjsy+88AIjR47cbMswJBKf1f/9fCQ6bGJN3Ty6dK/m+B9uT0VlN+pzaynv1sj06UVmvxXSsMIlm1J8e89qdhwC099fQbYrbFmxNUOGnsKsOY+SYx4zXnd497VGBm5Zxg9P7Mqsl9rI+IbpdU0c9D/defixBew1eHu2//b/8Oc/34YrLMeevDWCkChXg+8XmPLCXBobWvnWdlvQaiJmL2jDdctwnYD+/Qv4RtHSpli0oAFtAo47cTuOGn4G5537V8JCSHtuLW6Vpqaykh7dDHUr2ym0asrcNCvbFIh4FLm6qgtWG4QFiyHlQp8tmzj6+MOZPO0VyitayOgeNDdkmDp1BZ7K4pUVQUT069uVc8+5gH88+gANdYt48e2V5DokFZlqeveponvPMt56YzZVfSppbyvQsrbAgK5dqGvRlJeXceQR2/Kt/fdjqwH78vLkRxl7+U1ExrLTtlsye3Er5WVZWvP1WKvZZauuLFqTw89HdCv3KLhl5NugV68K+vfUzF7ZiExZaiurGNS7Fy+9Po+WZpehO2zH7y/+DQ/f/3cefvxFqrMuXdIOKMGihpDy8hqQAV2yHazNh+icpaklT+/aSqxTRqayG9IrIEwj90+c8eVeqIlEIpHYJElw9gkOOuggDjrooC+7GYmviO22265U1j+R+CrI5XJs18th5IidKIoK8vNb6D50F9bmGlDszIGDi+gVy3lpcT1u1kMHkramdr61xxB69DwQbIa2xuVUew4r5jvoQgptNMapYlVdlmJTPS/MWcPiVe306lXDWT8/lcn/mso9Dz1KIZ9Hex6vvvwue+65A06FS7Gpnt79JWtXBLw+az7d+mYJQ4kjXPr09IiISHk+VZWGbj0ydOnRFRNJOop5gjDCWEPtFmmCYg6/rcDixpCWloCKrKK6r8OKNgvGYq1FhwFSSjQCgSUymt79DNNnP0NjE8yeDhWVIdKL8COLqwxWacJIk6roxvh7H2fbrbYmkyowrCrD9FfrCYuaZctWs2hxB54DbUuayEcGEQkaWjoohpIsHqGs44EnJlJV/gYZr8DW/TPYwGFNa57QWoTUpFOKIIJ8voiSlp5VaeoaOwiEIe2Voa1Ep9I0rlhGlz6KoNzQd+iefLta8uwjH2CkgnQNW26zKyZ6jpRSIEPWtvsoN4OVltoeFRTa2zEFS7omg1vwibTFSEPKaFwsbU36ky+kRCKRSHwlJMHZZtTe3s6jjz7KoEGD2Guvvb6UNkydOpUFCxZwyimnfCnPn0gk/rMiDfTIIt5cTWqoYasDdmPJgiaGdN2FD9a0EEaNGCHRxhJoQ6G8g7It+mAqmvFZTJTbEtFRpI0tmbnkXZa+vxpjFIsXrWLZvPc49YDBPFusw2J5edoy9t1P0Ly2maCQx1pACxrXGKa//T42XEbdggYo02A17e2W3PwOjEzjSs37iws4qYiOXJG99t6K3//2JCY9NYFi+xom3HUjudYcZWVZECG9e5bhpTPMm9mALHfpaI9YvMjHWA9pwVhLqCM86YE1GCCILNNetnTr6VHetYrutWvx/Q6KHSmwYAzYSKLbQma98w5tbSGTpcsFvz6eRY2vo0SITxqpBCa0nPTjH/HEMy9QXLwK13HI+yEajzASPPbgKmp6ZTCsQfp5Ksor0G5AVgeotQZjBSYyVLiCilSaoq9YtroVrKGq0qNoJIViBwuWrqaQN6TrPVTYyptTn2fx0rUEgaVu5Squ+uN5NK5cTmXKIeOBqjBstSUs+MAgjCBdVqRvnzRzp+dxKsvZpTbF1v0V/5xssdbgt4cEhSQ4SyQSia+LpMLAZlReXs6MGTNKZe6HDx9eKo3+79atRbG5VVdXl9bvSiQS//3CKKSivJbGrYcS1famSQT0GNxOofgBRf8d0hVr6LVVOcqThH5AmWyjfvkCFr49n0n3PMq/7r+VlXmf7j22prmtFUQRowMqy1Lsun0/KnRAj0yKKIpoaelgwt2TmDe7CbeQoqzMxQKDevSkbkmOFbNW0dKQp25RkaICpzqNU+ERGYsQCmUtZSmFEBH/fGoWE+6dyPADD6GhLsusuU0YLFhBJutS1bc7x514Brt9Z1cy5Q4pDyrSFmktVoA1BkwccRmjsdZgtMEUQTV08M6U+bTVWbat6UbDonrCoo+xlnxzgGMErc2GHn2zbLttN6xI8dOfnEtVly5IC2lPUV7msLZtLZEJSFWkKS+HnXZKU90lBVgGb5mhw2+jmC9QDANWrmrDyUOQDzDWYqwlsoqMdKiuqMIPQqww9O5VRWshwFiD0Yq2tpAIQ4cf0toYsnLGShqWdICN15R8f+4ispkMaU+hpCCbTZOy5QR5ibXQrcaw43aV9OudpW+txxm/2Y3vj/gx3avLsNYQhAFO+aevjJxIJBKJL0cycraZfbh06qRJk0rrVX3YvHnzuPjii3nooYc2+/NXVlZu9mMmEomvLmMM781aSXbYFmzX/xgMDisbbsftUaBhTQuqoTcKQxiGCNelEGhWrW0jv0bRtWd30tUBr7w6gZWrU3StCglbNO3CoxCEdOu/DXPfn019UxNaG/yi5t1Zy+kohnRoST4UpFyPV95eAx0dSM/DCkF5NXTtU8nAoVuQ68gza2oDRodEQUh1LuCA3fsxa8FKlJ7Hi//K8dOTv8+/przOP59+D4yma5eeHDQszfxZ9zPntcWk05rq3g5rV2sEYIXFdvbdmrimlbBxYIey5MOA8rI0rS0F3pm7lLZChLEOAoPrStY0F/Aji1kakivzWbJkKd37b8Oy5Y24pAm1paMIzzz1CmF7O+m0oHZLTb+dq1jVJPBbBVv3cfDbKmla24rSlqbVAQ2uYssBtSxf1YrVhuqswLMOL89bRlvep7YshXLAcSOsMbiuQQlLqkxSCAxCQiAFfbfMsmJ1HID6BDTmO3CrJFZaZsxqoWuZR3seqlIRs94JeP6fK+jbtQvfGdyPJR9Yli1/Dy0FIhTgQLctqr7MSzSRSCQSn8I3PjjTWnPFFVew3XbbMWXKFPbdd1+GDx/OeeedRxiG9O3blwkTJvD888/Ts2fPjR5j2bJl3HbbbQwdOpRp06bRv39/li1bxv33389Pf/pTGhoa+MlPfsLJJ5/M9ddfz2mnncacOXN44oknOOKII0rHueWWW/jXv/5Fv379CMOQ008/nX/84x/06dOHp59+mssuu4wePXrw61//mu9+97tMnDixVCL+8ssvZ5tttvnIkbpEIvHfKQwjVjU08uL0OnoMGExzRz3NzW3k6tew/wHbMu2dDwiDbZEKhJaEa8sory6nUbWyqHUtZhHMWNGEVy6p7EjT2iiwxlCRLWPwkB1oKWti295t1K52KNbD7PfqQRjq17bgpdK4ykEJQ0VNlhWrOxBYKjyXoinS0NhIz17VIC3CKrrWVHDqCUfy3EvTaG9bSbFN8eaiZTS2Tmbue4vJ5zVVlbBq0WqW1/Vh5RKXnv0E3/lOT177VyPFIMAKEFYgBAgpsUJgbZzCZ60mH4b06pVl74HbsnJZEyvnr8RoENJgjKC1GGCAbLnEcVMgFLnGeqa++hTZMh+/w6NQiCjkffxCgZ7dInbYytBWdHhneoHGBkvaTTNjlSZVFVLmWvxQUFWjKRRC6le0YaUFBL4wrF3bhpNxqanI0KUyy6rmBkJfIj3o3auSbx04lLvufIWVK1qxRrCmpUAXrXC8FBWVWbYdUs2yxQspNkFZnzS7b6EprM5S31GI13AMoWv3CoIyhwUrGykr68PimQtZu7aNbEUtWEEYiU+4ihKJRCLxVfGND87+/ve/k0qlOOqoo/je977HNttsw+zZs+natSu+73PxxRcze/ZspkyZwvHHH7/RY5xxxhnccMMNDBgwgLfffhuAPn36MHHiRI477jgGDx7MypUrGTZsGKeddhpTp06le/fu6wVmAFtvvTU33ngjEydOxBjDt7/9bZ588klqa2uJoohf//rX/P3vf6dfv34ceeSR3HXXXbzzzjvU1dXh+z7/+7//y8KFC/nHP/7xhZ+3RCLx1WABqzX5fIEJt00kWwuSPGV+gdndl9CnchCvvrqEjo4ilRVlLF3mU1nThcOPOp67bv47DWsa2Xn3AXz3kP9hbWORbbfZlot/ezUtuQIP3/sAgROQ7lrBIYfsgY0EuVueZ3VdC1IJEGAtGCNZVteOsRbPkXTtocBELJ7WzGHn/oDVgybz/uw6iqHkoSf/SUtLnvKMQ1NekTcRC+fNp6YmRUtHQKgjqtOWnlXb8O3jv82r0x+hT/8mvv0/vei3o89zzy2lPQdYidEW64j4JAiFxZBrtizXAc0dH9DSVqAqpXAcSahBYNh15340tTXS4WuEdAhbi7Tn8mzbr4qdtu/DG6/n0JGh0O7Tu3c52YoUq3KW0Fga6oqYwAVpqa83sCaPJxTde2Xp2VVStzTChgZr4lcmCAIwlh5ph0xVNfW5drYeXIajHebOgfoGzUMPv0fj2jzSQEpI2vI+DWGO2m7lVHepZb8Dj2Dl0hdoWvUOZVVp+g1Ic89tLfihIA3kQx9LQCaIiBoE7+SKdN2yiqq1Gu1bMD4O/pd5iSYSiUTiU/jGB2czZ85k0KBBAGSzWfr27VsafVqXkphOpykWix95jKlTp9KrVy+AUml1pdR6C1VLKamqqvrYhYTXbbPu3zNnzsRx4pdo11135fLLL6eiooK+ffvy5JNPIoRAa83UqVPZYYcd1nv+RCLxzWCNIeOm2HGnLPNmNhAFBarLajjm+ON5dMoLBPklrKr3sdqgw4B5i1tYuXw18+Yto7k5YPnaPF06It6aOY8Xn3uZnbbflygypNJliKid8qqIAYP7kMvDsF32Z59DFzN92kKkk2bZwnaE1RT8ECQ4VmGtobkxIkDQt081q1cuY82aZjCWlo4izfkW0mWKmq4OC5d0UMxrttxCkulaQUWLJAwFTc2SpyZOZZvtfSpqa7n3hhn036qSXfcazHvvreL9OT7WxjEZViMFGAzWWjxXIVAUChrlSKKiJtAWgUAowWmnnkZNTTmnj7qAluY2ulW4tOaKvPLyQuoa8hhsPB9MSfJtmkVtEZU1Dn7BYLXAagMCenXzqEj3ZNHKNbS0FuhVXYN0A4y2IBy00Sgr6FldRrdulSxctYZ8AGvnKIrWIESa+vomQr8RGRhEZLGRRgmJqySt7e0sXbKUa//0B7KuotKJoHuOdxcrfC9COQqsQWoo5kNS7YIGv42aXpLutX3Jd9ShlEt5SlKb/F1IJBKJr41vfEGQ3XbbjVdffbX0cxiGpWBtU/Xu3bt0DGPiLwgfR0oZp6N8irY1Njay++67M3XqVO69916OOOIIPM/DGPORz9/e3r7Rsu8rVqzY4LFv4raJxH8Da6EtF9DeEdF9C8mwPSvZabdd8dUA1jY2Y0OflLIIa9DGApL2fIjfavGqqnCloK2lg7dfn02hA5556h/kc+34oY9KuQwYtC0/OPz/6NtnKyY8eAdz5y0iHwXgCPoN6E5kLU5aoVIKoQSZrKRDG4pFTWOhyKLm93CzbWgT4aYEmSpNWdZl6wH9yZa5eJ6ivjFg7sw6mls6QIAnFC1rfRbMfZ3nnnkWJxshZZ6nJ73N2rUh2oK1BjAgBFoIjI1H8lIpRTotaWrooL01wsQZhmAtYWR48p+v0BG4uKk0yIiV9TnqVjSzYkUj0nGwBjJlirJyKAQhUkpybRFKC7KVBuF11iGRAYE2ZL0UTWstS1blaWkJ0MZiRTz/zTUOvbrVINx2evSUVGHBSNraNQIV/wEWGsdRKCURSpB2FTrSSAtKWirS0M2TdHRYGpcqiqtdth5cRVWNAuEQBBEisqxtj1jdWGT1kgamPP8G7fkw/lsgHZY1hF/mJZpIJBKJT+EbP3J28sknM3PmTG666SYcx2HMmDF4nsfs2bMBWLNmDfPmzaOmpgZjzEZHvm644QbOPfdcDjvsMJYuXUqhUOD9999nxYoVvPzyy+TzeZqbm5k8eTInnXQSQ4YMYeXKldx8882ccsopOI6DtZbXXnuNZcuWMX/+fAYNGsT48eO57LLLyOfzzJ07l7Fjx1JXV8fbb7/NH/7wB7p27cqtt97KddddxwknnMDJJ5/MjjvuiNaa+fPnM2nSJAqFAr///e9LbQ3DkL333pt58+aRzWZLj994443fqG0Tif8WSkmMdWhcHtCzfzVvz2qAilm8/f7b7Lfb9tSvaKN+1vsQGcDieAppFIXWIqvX5LFC0lDfipUZlK+R2LhEvoUIw4v/msX7C65i1aoGdEcTgQoQRlJhI2YsWklZWTmVNSlkjyxrF+RAKnYb1pWarhnqVrWweN4y2ls8rBVYYxEWMiZCOjVUd+2JH63Cby1irSDCIIzFqVQM6NWFBUtydOQ1rc0RLWsEXbIZih0aa3S8zpnWGK0xsjO10UK+oPE8B7CEYYT00pQrSd7GI2L/fOpfvDbtNdo7WlCeIBU5pJSkxQ9pWNOCqzJYBK7nEYYaE4HE0rO/oKaXZNYs0NawZkVE49pVCAGVZZKWpjxdqwShthgbB801lZW0tORo7/Bp9y2VGYeisRgBkdX07OkS+oqGVYqylEJJ0JFBOTKu+GgE1akUa5qLLG0okEmn0ULR2OHQ0iLJeCFCCCJrKfcUUWQotkWUOe041kMIQYcJqK1M5pwlEonE14WwnzTMk0gkEomvrGOP/B7plEOmqpXBW/dGZgrUta2md9duDN3hRzz46F109QPe/SDE1w6RLpItX4Vqy7K80cdxFY6UtLb7ZDMuoY7AraBLTRdqUgaCVj5YlaOsTFFZm6UpX2DQFl3oWVbFP15ZTFk2S1m1R7etDA0rO3DT0HuAJJ8T5JtDCCUrF2ukKsP1JIMHp1HSUJ9rx+8oo701R3tTkW7VZTR3GKSTorpWccoJQ0AOYuyfb6Nrd4f2Fs3hBwxhyrtrWbGiFWMs2bIU6VSKyBisEGAgX2yiJiOJhCFXCOiZzlIMLU1FTXm2irBYwCFEu9ClxqUsbcg3WQbsUMPcue34BReVMnTr4ZDSKRbNX04qBXvu5dB3S8Xjz1n8XCUt7a2Y0Kci4+E4kiAM2WZIGS0NgsZ2j2zaI+0WMcWQtOMSGYHnBKxt07QHkCkv5zt7b0lb20pmvNGK51mUdGgvBHgpF+uUUVFehp9vJCMEbYUIIQzdK8toLUZ0GIeqimo62psxUYTVmmpPUJN1aTGGtjBNZWUXykSOTKXgvoff+bIv1UQikUhsgm/8yFkikUh8nRltkVKiogqWL9F075Uhv0zz/rv1vPf6bXQpc2lttzTn8pRlq7GRYtUyh35VHo4TgDUE2pCukFRXZDBW0dphsQYa2oo0NOWoKDNUVVWQNxJERPOaDpysiBdrthpjLFiJk1aYIKTQkKW1pYDrOuy617YoWceKxR1YDStWFfGDNqyy1GTLcDIelT1deg/oS/OMpWhtcIVi5rtL6dUvRVWVJPItGUdCpiuVXSxyVQ5tQ4y1aNs5TIUEEa+DVlbmkIt8Uh0ua9t9pHTRUbz2mFKSXEeALEK7E9GnZwVIxaJFbSgJxmocFMWipqWpBWMl1eWSjOexdHmICQVWWDxHYYyDNgJCS2QkVgmCUENnif8opfFcCXmLtD6elLTlQ6xwEAhmzlpFS3MLnqco+BGeiqjwBMqVdBiDMdDUHJDNOHhSoJRCoBE2QlgHa0EoS1tbnppMCoulLQKrBbIzc76tPUTgfanXaCKRSCQ23Td+zlkikUh8nRkLhWJELldPe/0y2haspXmlQ9hhsPWNDOxdQxAJQj8ijCKko3ClQ3lFmpTjoa3ESFCuizQBJorAWKzR+FGEg6ZcpWlo8wmLGs9KCs05WpuaMdaAjYOnYkuE64QEbQFNHzSTb/bZYdshVGV7sd3grdDGIpCsrltLc2OBIBdQ6FiOVjkG7zqEH/94JN/aeyjWGPr364VjMrz98mLa2w2rGwKqK1K899YcFs9fgsUiUFhr4wIeAsBgrKamxqM87SIiiUDgKQdtIhwp48Wew5CUEqTKoaaryweLC1DmYAW05SK0haqqMrpUZyivNaRTio6iYMFiS1vOoLXAANZYNHEJ/0IQ4TmWlrU+5U7n2pZC4DjguREt+SIyJajtluaAPbaitiqFkIowVLTlQppzRYpRhBCWLpUuylUYK4iMwQhLRyHAdSReStFcCHGzAiFBYCnLOnSrThNZyIcGYyxbdK9GKJAI0mmPXL7wJV6hiUQikfg0kpGzRCKR+BozNkJIwa57lRE1OKxcAjYKKStzWaMjXn93Ph/Mz2GEgzBx+XhhLEYEpNIOrfliXH2wVpDSDs0r2glJg7HUZMsJlE9dQzvpyjQSQdZacgLQYE08/yoqRiyf1UKXPoJQh6RCj47WiLemLSCt59K9/5YIiEe1UnH6oSsFjasVjidoas7zyptvMGfBCoQULFpaR5+dq0E3EoQRylhaGgu0RUWKRoJwEUKDXTc/TmCxWG0xvoAqQapcUegIcKWiT2U5a9p8hIaUdHAIaWwPscsiumRdWhuKEBo8IwiEJeVk2Hff3fjHP6cgU03kiz5ElpQw6CAOiowAKSyeI4g0lLkO6ShFfVuRCA+UwFEuYV4TBIamZkNzKyDXUAw1Km0QVuIICLShDIuULkpJ/HyEsQJXCbp0SRP6IaKyDJmSZABrAkyHxmDxWzU6FFSkHCSGTDbD2tY2tPE6A06fYjEJzhKJROLrIhk5SyQSia8xHRlSLvTv5+CbkLrGFjyhCRGsrfdpqCsipAWjCXT8hb4i7ZLyXHLtIY5U6MDit0QYoSnr4uBVKrS15PI+hYJPwY8DCS1CVrUbcqGlEGgsURwgSUm5p+hosmgtabYhZa4gamilJZfnjTfnYIwh0oZiUVKZzlBblkUIhfEN77+3kIfuf4pVS5dhrKVX924M2ftbZHtVsfXAKmqyGUw2w577DIorL8ahGMbGVRGtsZ3FRiyOVOSRFLRGyDgIXNXUQa4YoW1EOu0iEJQJ6Jp1kK6mPdcCxSJSxRmSK1esZtLDkymrSBEJS7tv8LKCyHUpdhb8cJWgttJFIShLu3SvypAPNO2FEBNZIj+iYaVPR7vEWoMfGnIdAflCkTAyYDSWuCx/1rV0LVfx/r4FITEWvLRLZW0WlXawnsYqEK4A18FYiQC6dSljp22rGdgtTZesS0NjB8IIhJCsK6BflnW/tOszkUgkEp9OMnKWSCQSX2NSCfzQ5cUXA5qaQgpFTe/aFCtyRbLSkpYQSEOkBdZoXKkZttsAGptyWFrQxuJJQWV5GX2HVrKirgmzUhF1aAIdkuswVFcojPYJgxQg8ENDmaPp3b+KhjqNo8BYB+FGpFISpyDI+5b6MER6FhtJXBdQCtNuaWgsUl1myKYz+PkCJghxTYBMuUQG1jS0ceOtTyIKeVReUt+WR7f4dBSWoaTEGOIy8Ras0awr1SgkpColQeBDZOiSyVD0NZE2SCGxVgCGrl1TdOQlWw6sZP6KZjzHwUaKYmARDqQcSa65kfZIoJVAeIrGgkO1TqGLebwyyFS4dOtXjs5rolxIUy74/wGRtAig0OFjlaXMU7QVDZE1BMUI6XhIIYm0JZV2yToO6awLzT6+8HEyHiInKOSLhFEHbkqwRW9Dqkyzdq1HGAggQGvN6rZ2AqDMKtbmItqLAWUpEHhoY8gXfcrKk3XOErHdLnwM13HxpCQMAwIdEoUGrMDXBqs7309SooTqnIdp0Dae3yoECCFQUiGFwFECqSDlKFKupCzlklYS5XoI4RBoCKzGAEpIHGEwSKy1KBO/fyMTvz8dEb/XlJVI6eBHmo5ikfZ8jmJQxAZhnFIswXM8UpkMQWhwpcBzXZSNb9gIDEoYhAQj4rUgfb+AiCK0BKkkwsb9CxAUowgVhkiriWx888VoixUCIV2UI0kpl7SjUFKiHEUKjQl9HMfBUQIrJL4B3xgiHaJsRBQWMSZE6wA/KBIFIRiDlALXc/GcNAKXCIEWEikUUkq0hVAbwigCIVFKkHIEKddDCIWXLgcnhbUQRaZzvcd4eZHARAQRRFojhUCJOLXbdRUZ1yWbcdHS4GuNtAqrQ5SOwGh8HVEMDY6UKBuhiLDW4iMQSoERFMMQjUaZCCkERcfDhgYFhMbEC4QI8ITAlYpACtAGoTwCI4h0iJQCR3Wmnbte3F+I/w7I+O9RynMRSJR0cRwXryxDZDTWQBiF5IKIohU4BnQQIhBoQCqFIyTaGITQSKGxUiKlxAUcC0UbYRC4KFwZr81pooBI+xgsymqkCePnkwaLjq95BEIIBPENPmMsYeTjBwF+sYBjNUQaR0kcT5FyJLbog+vyyk3nfar3aRKcJRKJxNeYEi6Ooyg2u9QtybNFhUsutHQUQjCW9pyPFIrIgjKW2q4VHPGzE7j/vofgvZWUeQKpHNau7cDML7BsmSEKIjJpFyJD5IfkQ0VZrUVIg5AOZZWWwFj2HrYDT02aiTWSQhihiwbdLkm7llwQYSODwYBUKDoLiJh4zhYWWlvz8RcyQrr19Fi2MsL1DKtXt9HhN9O72mFtiyWIQGJob8uB6yKEh6AzlRG7bhkzLJD3Le0deTyTQqQcylyDV+OxqinCCEMx0ARZzYAB5fTuX8XiJW2klcIXIBRoC4Wws8hJm8BNS8rKM7Q0Gzw3T8oRWAymYKnpUoXp1oGlSCpvaVoiyRcUeSGwwlDTxUEXDAUExSgE64CM54tpa3CsobbMIbAhLTrAzYLMKMIoLqOPEKQzLrlcnrpFAUN2rmTH7fsxf/5a1lBEIFDKodgWkilX5II8yhFIJTGhRRuLVIKW1uKXe5EmvjIqPImRAlcoMC5h53qBVsdzNg0RxmqIBFZKrInTdrWNEFIhUbhKIqWJvyhbCIOIQijwtINvDJWpNGkhQAkiwAqFlKIzWJBIYYlCjTKWKChiIx9fG3zHkgpcpJPGuGmUgSpX4LmS0Ah8qXCUEy/yLhy0MbgGgiDEL/pIYZEIIgSeEghrieLl54msgzUink8bWRwp8JTECknKUXHwEIKwESk0VhksIq4CK8Bqg68jlJLIEDQhwkQUfZAyfh8KL4VA4EqLjQzCijgAQsYfLq5EGovnuQipCKyDMbIzCJREQuC6LnR+/Zc2DooklrSUuDJOJbfGoCONkQ5COSgMUihMEBGhsTYCEa95GxqDtQGBFkShRNoseB55CxiD0hbHGkwU4heLaBOBiAs9+TpASoVWLkJH2M7P7sgKwMVaie+D1gKtNRZQ1oAnCaUgZSEMDEpKXCRKWBzXQxA/p440RR2gpcDqOPMh1AbjSEzna4QUSOVSiC8kFPE2UhAfH42QcRBqbZwhEhIHjp4QeF4KIQTSWlxAWEMUWjTgCUtGSoTrEoYCY10KOsCEPkIBoUIbizYBTucfGSEFUgBGgzQIaUh74EkHoy2OEEhrgADHaJTQaB186vdpEpwlEonE15hwTWdqoqZ7ZYrytGTu6naMNaSUC7pIKDrvahpNe96nPVdHZYWLUILIaByhEFiWzwlpzoeUVWTRaHp3r2SfYb15fsr7pFICP9QIYajtnkGGIfPe+4BIRzgyHpnRxuIJwS671rJiVZGFi3OE2uIohbUaKST9B5TRuLoDJeMROOtIHAw7DupKoVigsdUghUVJ8AvQUdQ4Apwyl55bVpFriWhrDYC4GAgCRGdgJgC/Q6OMJF76zFIMIwo2QltFyoLrOvTo6RKpkIWL11JeLhBpg22RiGI8AmdNHNymyz3KU+m4bzqiNRAUrSaDREioW9KBFTlquwV4FSkKfkA6o+goGEDS3m5RnSMNKc+JX5O0xPfju65SSJrbQ0IdB5oqZfEDixASMCjl0HPL7vhL11A0EfXLXfp364G/6j10FH/fy6QUwoQ0txfokkkRRgEV2QztbXRW0zT4fvTlXJyJrxyZzuJKhRKCVCpFKnQJ3IBiGJA2FtBoDBJJynNwJAR+PNIS2nidQhmP1SCUBKtxhIy/ACOIrCBvQESGtJIEvo8gHinBEUjXQegQ/ICwUKQQFCmEBfzQJ4oMjhRkM2k8L02EQltJFAREJsTFIrUhJMQYCMKQ0Df4QYA1EdZGOEKhBfhC4CCwygEh0UoRKoGSAiklobD4wsRtk5LAQhiBIv5PdH7Z13bdY3HAQ2Di20I2QIcBURjhug5uOoUTGTzlkJHxl2u3lH4scVwXq1xsBFYpQuL1KYUFB4MrASGRKg7cEILIWCITNyAkXtPScyUqlcbINIFVaKEIdYQOInA8LA6eowmjCGEMAo3VURx0K0FkAzKkyEiXgHiU0NeaQFt8G9/scoir3krlElcechHSxc1k8KRCGo20YK0grQ0m1EQmJBIWgUUKgyMExlocV8bBNAIlHISUCGE6AzVLSkoiJJG1eMTnPMJihcQg0FZgfA2dI2oGgzTgWUEo4r8VwqGzYnGIwBJEEUQGA4QmhXLjUEcrhbWgEJgoJFAWayQi0OgwIOgMZoksFoMEHARKKBwlSbkOQgq0lYRWI6xGRaAcF5lOIzpHZa3WoCOEX6Bg2unwP/2c3yQ4SyQSia8x1fkxng8ENWVpmvNFWtuLSMB3FSYS8R9qJbDaUMiHPPbIS7zx8vs0thXpUVtGaAxSC8rLFLliiNEaayzt+ZDWfET/AWUYUyCTgUi45PI++UDTtLwRHUmMazHSYgxoa1m8PE9FRRlK5HA9gXAkRWOIQk2xaAmxSC8Opry0xZUOs+e209DgI9wMSkAaKLQbBIaycpeuW5YjnDiIMcZiTYSSLjIuGAk2Tr8Kw4iMAmUioqKmEETkfYuxGovARIaGVZqtts2iPEHdsg5yDSCtIYoUSAOOQChDVAyJgjhdUiKprnFpa49r1LuVaaq6ZmleVaCxLsK2uRR8Q1vexF+6iL/g4cQBYsoTdPiWoq8QAlw3HiELQ4NyJTq0iNBSW5Wmw7e0S0H3Hl3YbdetqVvVRODD6oZ2nnv6XygpcKTCGBChjzERUkoa83l6Vnjk/RCLi8BSUZYim0qmlydixiqUVVgpMMKSyWRIp1KkgrBzBNoQKkC4OFKgjCGVtmTCgMAYpHKwUiAM6CjEmnjeqdYaqxRWORStIAw1jilikbhKopTESgiFwAoFbiouJmRDIuug0VgZobG06QBR1IShIAw0fuDjeQ4pB1zlkilLEeby8dzOyEdHPugQx4lHm4WNv9RrobCoOOBRbjy6ZCXaAMLGKZkSos5AQ2CJTIQxGmE0GI02migCYSKssJ2jJRZHWHQYERpNwS8ifR/hBpS5LoGSpFJOZ8VUECiU8uLkawlaSMBF2zgYcRyXlOviCVCOg3QUwnXR1hKGmkhHmPi+EagURnhYmcZzU4TGxnOKCdHaIrXEERHSc+MUT6uRWHwbYJUklIqUidNQXU9RDCJCbbDKol2JwKCB0MYprhIFRiHdDJHxsDZOA3QFCClwhUHEw0ooJVHSoJRFGI3SFqtDAm0oBCGBiYtXCSUx0omDXmtwXY+08nAchdYabQ3CmM7UUvAkWK0RBqS0KGtKqanG2jgdNYoQWgMGqYuYSGMQoANC30FLgcHGI8RG8/8XeBYo4aKkQVuLNQZhAqSIb7Bp4WCMAiSO6hwBlHEKpYkiFCpOKUUildeZAhwRGkmgIwKRwZefPq08Cc4SiUTia8yYECEtRgiaOnw6fI2jHCIdEYTxFyfXU0ip4uDESt56eSFtrR1Ulzuk0wpRsOSDiCDUeCkVz3WwlkIxYv77y9lxV6jNOLz3QYSXqkSqVpRrKDb6YNJgDa4j8YnTljxrWbGkFUScAqOjuPCFEJZVdXmclKZsgKS7o3BTUJHK4keatCfxtUUgKMcl7xnSwsEKA8LgKIUQCkHnXBIbp+7Yzr+00oJyJA4ugbFoYZAyXm5AdH4RklJQXi7Za9++NNWHhNrSsLrAsgVFPMcjFMSF+pVFaQiLHTjlLmVZDz8PkREoDNpY1qxthNYCXXqUxylaCozSODik02mylRHGFZRbaK7vIIoielZLfN+gdYQScYpMFIRgBVW1KURGooxC2JCmxjZemPwmGVdgtcJi8RxNFMh4pA1Bzx5pGhosDbkiKSdej+2D+hyV1d0R1hDoAk5KfKnXaOKro0uqHC/lEal4rpaIQoLAx+o4ENGAgyTQhtA6WOGgpMHzUqQQREiKxhIpGxcJQhFZjeum4zlZQqKNwI8CQmOR0sFKhxCFtgJ8A1giPyTyIwwuKLBGYeIktXgUXIB0DJ6wOK4bB0kGgqCA40DeL4CVCMfiCokNFRaD7hwxj9/rEqTAOg5aKGRnwCmkgxTxDRkRTzDD7ZyPakWEFgaliOfbGQiUxdg4vdF1FGlH4rkO2kJgIrTW+EUfLS2RCfGVix+GCCPjzywrkSYecVQoXCcdv3ulIDQWowRFBNrxcKTCQyB1HERa4SDdNMIYIhMRGXA0OEqhbDzKFRJ//ioHHFGG1hEFHcYpkVLEozxBSBT4RFbFwaNy4sBZxq+HFTI+95p4fi4uRsafhZp40FAKjZKdC5kIgbQa1Zm2YIXCUR6eC44jQQlcoxF+niCKizFFYYgrBDaMrzNtDemUh5NKIY0h9A2hCbFRgDJxkGhUPP9QotAyLoCl6MxBtxoRBtgoiFNmAdO5xmSIRRqLsgFahwSOiucnS1kKzOJbViIOBoXFah1/roo4fzQ0AYH24zl00sVEDuVeBildwOK6HtIYhOsgpYPbmXqKhY4wQHh5ZBji6E+fuZAEZ4lEIvE15nouUWhJp9O0d4CvobwySyHKExmflCuQkUMUxukiAGVlKfyiR1XPLJnuZbTNa8BaQWgtrpQII9DaIFISg2HlCs3inGXFyoiKyia6dPWIgoDyrCQXCrACE4ISlnxkWJMzdAQ+BWNJZxykFJhAIJBs06+WQYO7MHPJBxgpKK8qRyBoXG6oqK4g31AAG6fclGUdlC7SkRNEHYbuXWtorl/TmTqjsBDfDTWdgZnrEAWaulwbGU/Fk7iVoqLC4guBCTXSdQmky4QHFlCVVqxaUSCbspSXOTTnA4xbjquIJ3Vn4pG0tAc6iiCwKGHiKpFG0LC6g741DhW1PrmcJEw7OMYSdFiiKMRNe/EfeympqhFUphV7bdWFOQvbWJW3ZFxLJAUZR+GUSaq7p7HWQViJJST0C3huyHf27M7sWWtZUR+xOucjjIsRCmPjSpL1LQVCY+lakWVNawE/MmgdovEoq3WIrP34iyjxjZGtKENKFc+b0SFSREjikeUwKMaVSB0HBxnfAFFxsKSUQljQQNZRnQvPG0KtCazFlVCmFKl4mJmwM1VaSbDCYGycHmYdFQcgngO6DF+HaAEmshS0JjAGZSzCRLjW4ocFtI6wVqO1JooMURRSlknF81itxhpF6MRFRkIdj5A7Kk4NVK5ESrCOwigHpIuQXly4x0ZgDMJorI1THDHxDRhhQCCQRuIIRWAtQimEEmSyZWSz5YTGUgwC+vauIdfQTH1bG1EUFz8xVhBEhtB0BptSIRE4ykFqcJTAlXEAVgxtPOdVx1Vc044C64MTp4sKITpHiTQppTBRhONoPBnfdFHG4psIVxqUUEQmikfsrMYRDgKHtCvxRTxXuEMqCpElhcGxkE6n4pxOGReNSnUW/9CIOEVUa6wQuBJcYTA6QkQGjEXK+JrATYF0QcWf91EUUfQ7yAhLqAMwIa4OcAWgDSiFdQQpN041jIPqOFMCG2DDItLGgWEoBBIZF06RAq060yONhqhIGISEQYjRFmxcUMU3YHU8b80oidQKoWTnHOV4zqUjBUF8FwAHsIpS0KhNnALrKhsHoq4CJ0WAxLEqTqm3cSXeyDd4QoMUhFKgXAcDuK7Ec0Ab86nfp0lwlkgkEl9jGU9R9AOKhQhtoDVXoLyqDLfMIcyHBEZjrN+ZT6Mx2hBoi5cVtDS2033Lago9y2le3kJtd5d0NkUxr+hojgttlJVL8qGmpSEim3boaDe05nKkq1LxFxgZZ9v06V5J3dqQYmhYuyaP9SxOSv3/cvfCYKVhbTEgN2cFvbYop77g097Uwv7fdtFtFqcc6hssccF/S00XS3U2xar3Q3Kr87y/9n0C4xJ/I9ClUbTOpc4wxlIMDH5kcSSkPYGr4iAtiCLoXLi6WxfL8mZNfb0l7SoCH9qKnRPhdYSbEXTv5VBoF4BEOhK/qGluKxBaDw9oay7iFwLaMoZdthjIC68sIfBDvIyLn4cgMogIKrMphu02hA+WrmD5wkW0tBRpKwQYUvjapRCGbNEzi1st8dEoq4h0vIZbGFga1hR4c2YHplWTMQJfuhghEFaBsKRdKMsopFCEGGRGUO1mAUukNcozVJUnwVki1hb5lHuZznQwEMLBWEVk4hs7oAkDjVAeRljcUMRfnm080msUCCnxbLzOX7mr0GFIsdAOfpxKKKTEkRbPcXCkwAqLERZhA4xwcISDawxWukRS4QhBJCwFqztT/wye0YjQRzkCY0OsCZFSYx2NFCmUC5XpNK6xcZaA7lyQXgd0rkSI67p4ykWLOIUwJC4sYa0g6BwdEkRIadBEYA3CuHGQqjpHuaQFx0Ei0VISKYc2m6LD90BIhEizeKWPkmk8F1IyHskqRHERCdGZjihlXPQj7WbwXIHrOKSEwA80baGmqDVRGGEwRMbgeArHSjzHw5UOxsSFWwIdB5TG5tFaoaTAaIOwGqskEZ0j8saSch2yaQ9HeARCUIjKKBQL+H6I1SFFa3CExRFxkC2ExEhLKBSOArfzczal4myBrLJYqzFCE5ceMehQ41tJpAOcsIgpeJh0irSrsFLim5AoDCDy47qUNg74hHQQygXhkHJcjEzjm4hIB4TaIkQ8AlYI4/46xiJxQDoYz+0somIQUYDQEVHoE+p4JNQa4oqgSqEdD+VKlJQIx+lcXkXiKg+lnPjGmHSxSKzR8U0KExerUSaeZ+gCjpfCOE7n+4V4TpntnF9HhKs8cD2MVAQ2AqVwVJogDBAqCc4SiUTiG6W2RzXLFjcS6XgdsWxZBj/Ik067hFJi0LiuprqrpGGtRVtLUAwpr0rh2IiVCxvp099h5+2zTH83wuAhPY3pDJAaGzVdu2i69fTYbtgQXntxCWGQw00L/OYQbeLSySll6LdFBStWd9AcBpgIjDRoCcK1YDwEipQnyeU6KC94ZKoc6lbAjIWKIhZTjO8yegiUdBgwsA+zZy5HCkmmHEJlaWuMQDlYC57jkM1myRfyGGPjlBarUTJOtUo7DkEY4XqKMATlWFJpxa7f6U7ds8vpaPfpUp5my23KeerJOoR08DyDp1JUZV169CjDNyFhKNmyZw/KnDKeeup9DPE8j9oeksg1vDxjJVZIhDZE+RCMh8FgQkPPrv0YNGRfFi19kvaGkDlrW/FtfBdXa01F2sUrVxRcg5AuobHkC0FcKc4adBDSuLSB7QZW02eLGhasamRtnWZ5cwTCst/wPahbtobXX/2AotL06FtLnx5b8OarSxHGoIxDOqO/7Ms08RUR5FqwKR8hXXwdF7opFIq0FQoEYRAXahAghMHIuKCGtbIzbSxO/QuMiQuBWIu0ESYICINiPPIhRefC8OB4Lo7roKSLEHEqIdLBdR08CZGRtFtAxWX3i8ZQjCwiCmm3UTxfKIoIghBho3iJQydOWwSHSAnSQtFR1BjpAeCJFBl80tLSYTyKwgPlIqXECAVYojBEGo2wEa6O0/pQAo1DhEF6ZZ05bxKsLBUIcYTECEmgBSaKK/IIAY7UuAYcPISyYCIyrodSAiKDxMTBqYnnrHlOmqzn4nTOrQqR4KjOcSMTV3i0FtfIOAXQAWnjSomazry5KESbEBEnhsbrJiqFkHHApsMQSCGVi5URViiCYogOBKn4TOLbeFQqFAqlFCllsDouRIKUSKXIKIE2YTzPS8cFN3wToUNNEAaExhCEBqEEwnGIUhmkCAkDgeqsbCuxpBwHY8API8LIImwYLwtgFcqA40CoPLTOoj2B9SVGF9BRgDUhQsRzA42J57PJzsIi0kbowCcKip3p+MTXq6MQKo2Wdl35GhTgSYnneUjhxpUu0xlSXgZjOtMbiUhLg0tc0ERqjRIS5bqodAo/jJeY8YKAwM8TGJAqhVUunpIYY+KAXMWpwUaqOOviU0qCs0QikfgaW7umDddxCSNNYCzKsWRFmmwmoNAhscKjusLQfytLeyEOGIwVtNS3YzMu5RURNdWKnXaq5b25bdSvLVDIRUibwlpJkLf4mZAthtQye+5SDG04rkOx2WCNKlUEXF0wlJUF1HZxsQbyRQ06njviKEUx0GgT0ZGLqMx4OKaM5rYimXJJaCNaOyxha3xXXok4FWnWrEX07l/OyveKOCmXjjAuSewoSUScwuQHQTynDBnPTSMulxxEES1Fh9oyF+sZPKPQRlDIW/751FqKoaayi0Ov3pZZs5owhng+hRXk/IhFywMcE1BZ7tClVy1vv7sKqyWRkCgryJY7GBUQFAzKBGAEZdVVCCT5fAfWGJqb2nnjpbd4/ZV36N0nRaQtA2rLWFuEJl8jlKRLeYr+gzQL6gS5johCW0DrmpBUpjwuP64UTR0FMlU9+dZBO/Duzc+Ty0dYq9CR5bmn30BJQZsfka5x2WKLHmzZuwfTXl5MqAU6H8GqL/MKTXyVeFEb3XtkWVmXwxcOkTaEUYgnFCgHbeOCDEoYrInfZ6Zz7QsjDMYYQqOxYYiIIqKoiA0DbOgThkVMGOFIw5Zb9mDFytXgpBDKwZFOXNHRU+A4OCIeATdCdAYUktDEI85SGwxxIQtpIxxrCXSEERK0wPEcwFIMwrhMv5Ioo7FhhI58enbNUJsRvL28HdIeTipDys2g0TgO8dqFVqBwSQuF4ziolIMmniMb6bjin9YWE0adFSLjOXlOPH0WbSKEkFgd4JgI3wTkieeX1qJRrmWtzZBKKQTxDaesDZHSiUvCG915A0bjGImnBFoIsHElzVCLznXlBEZrQqdzTpgRWB2hjYlTTaUkkhAnYTpIHJQFpKAQWYL2PMJNYaWDbzTGmrgkvLVIITDGEBEXGJLEU7mktBgTQBhXwTRBASssFo2jRFwwRViko+MROhEHMFr76BCMMhjl4QoXjCUlFJawM10wxGiDlAqsS8EYDAoHj/ZA44cKG8bLPAhhSXvxca2Nw7zIEKerCoVrRWluYkqAY8L4ehIKz3HxvBQqlSbCQQmFEBZPic45xZ0Vfa3BLxQQ0gVjsAKEowjQ0LlumREWZQTpzuwTYTVR4GOjABNZfBGhVISIikiVilM2DThYilFAFPqf+n2aBGeJRCLxNaaEAddBBjJeA8daBvYXbLFVBa+8mqOlUES5LitWCTpykop0XH44ciRl5S611YZii2bVaug9QBIWodiiscIgrGHo0HIG72J5dVorhTwo5VLMGXRes/WgXixekQMdz1ELI43rKTxXknJDCgVJMTIErRGoMowWOMYi3JAg10alTtG1j6TFQJesoqZLFwrFNIVQ42Q7GLxHDW/8o0CmLF6Q1s9F9Ozr0rAm/ipitcFEEdbEKZhYS1naw5U+6TKXYi7CjyCFIt8R4mYcokjQsDxHtquk95YeB/5PT/zCaupWBBQjjedYFBLXlVCQ+HkFgaDQbsmkNZm0JChKuvcUrF4tSLsOTuTgCXCkjf84kwchqe2jKKyxFPIRixd2YKVgRS5PMVQYmaFMKaLAZ+FCl4bWEGMNIpJUlXv4kSWKNG15n/I0tPk5XnxjNrlcSOTHVdSsMbTW+7gZATIiKBoqshnemTEfHRmcDLS3BTTpT59Wk/jv5CiH9ryhoT3AiIDQaowxKG3QCKLOAjyOtLjrqswZjbTxWn2R1XElP6uRhHHKohRxOhcW1xp0ENDSmKPQXoxHbTqLcwipkK7E8by4gqIjUcpBKZfIkbhSkLHxqLQiLgaiRFwBNnLiUStHCJCWyIZ4xKNZIl6IjIA4iPmgsYXFEtIV5WRcj/KUhycVOBLtpQh1ZxEhGa+B5rleXC3R8egINWEExUjj24go8DGRRvghxvjxwvFYUp4l5So8rchIGa8FpyO6GE2NbqLSCWmS5SwO0rhWkw3zbKFyeJly6qIqytwUMoKFBUM7LlXCxViBlg5aKoywRNIibIQnXVwhCIyJPyOUIBLx+mOhNLiRQRiIojAuK28sxkZA3E8rfSRxMKIcSQCoznW7lBBoowmsxrEqXlDbRnHmeBRho5BIBxgMjhKEgcF0Ls0SGYPtzFbQJowrLRJSDDtw3RRu4MUphFpD5KP9Dmzncispx0EqRUekyfkFbFFDaOOiNHGEhOs5oNIoHaE6y9yrzrmHwho8Ey+wLVNx5UcrISJeiiSTylBVUYVMl5FHUiz6SGNwdDxB2XXiTAcDhFajw4ioczVvo0W8tpygc1qAQVqQNo3rOChl8N24gq80IZ5yCCUoN06hDYUTF3OJQiKzbuTuU75PN8u7PZFIJBJfCmHju61pL0V7513DhUtClq3yyesIlCAUkJEpHOJRJpXyKC9LU9WtjJ7da1i9dBUt0wtkazTpCpeqbobWRjAIlq+xvPdIRI2Xxi23ZNIe7avbEdLS2tJKEGmUEHgmzvfPh0WMilMdQ2NIVVq6dpEsXRbPmfDRbNdfMHCAx2uTLT2rt2DXLXdi2G7foesWg1FW09HagF9sY/7iRTT1eY73Fi9BRyCVAu2ClRgToJw4NQUblVJXkIauXdNU13gsXZDDE5aufVxySyCyEkdCe14jmywdPTVBoDj40G0ICguZ/nauszAAYDSFvKbDRHTYeoyO598V8vEct9XLC7S3GHoPyBKEEU6HobG+jcC0Y01cIjJbBX5ThFCSMArACiLtYDsXZ1PCEASaBfMDRNqipGLnHSppbhEsWVrAWkt5hWSrLTKsXNjGjHdaUAKyKYcOP64e1xFEyELEtw6oIuWlmPnK+6xuCDBGUF5ZzkGH9ubpx9Z8eRdo4itl4bIG7P9j789+NV3T8z7s90zv9M1rrnHP3Xuzu9mcWgNpSjY0WzJlO04AxzEyKIYAAwHyJwQBkhg+MpwgBhRDcpBEQhxTgkMGhGyxKdEkm+xmD+ze3XusXXPVmr75+97pmXLwrKaQgxy00AApum5gAVVA1VqrVr3Dc9/3df0utabMC4wSSJGIhiq7YQnKlOEnJeAswnlk9GgpyWREZyYh6kXykrW9JQSP6h3Blmhhsa2lC4HRyST5o8RNMxRSxhQxIISFCCJYBO6GDqhvNjIyBTtLRaYMLkZ0lCiRfG5KCPQN7CdIhbWWgKfpG7rW4pxF6ogQnoyKqAVRS4I0aZATI4RI11ucC/TGYbVBaocDgo80vaV1Ftt1SOeIfU3mPCpGbhvLnSpwkBXI3YoJFqUlNlqGWWDcnjMyPQd3jvn1J8nrdMsv+NLtSC88H+4D77024vzFmmbuOB0cMBQRMyi52AnmnUG7wDo40IaCgsxJDBErE08jI4F+VEiNLIHUHIUepTJMimJGhUDwIXn9cBROo0xCUabv2aGROKmIUeNwSCXxzqW/Fxx9SDRDERRC5ejMoAI4mUK9tQRJwFpL4yxdZ+lcoHcdJnoMntfunPHo0Yp6V1PmOblU5KXERkkIDgLJO+c9eJskjBGEEmgJqBvypYvY6AihT7EqKAjyhkYsCUSUMpSDKaaaIIWmjAEnPZAAKcokOaoyAu8jXWgSdZOb0G8liEImkiYO63qETD8reyPNjEQQBlnkJDEktGSIIHDRp6Wb87gYCeFHp+W+as5e1at6Va/qX+IyWY5rAyhBluW0bYMUhs16jxoKptMCKW9ecrlGKU0xzLn/zgGTyYQnHz/m5fOaZh8ZnWTonBsghUyTvz5C9Oy3DZWUhCGoLOJrybZLzZ68MW+7EMiVYDiJLFaag6GkOI609kYyGEAZxZNzw2ZVUhUj5tdTvD2nNJ9y8uKKt95+g9mtN1hv9rwtK+7+B69x/vwTfuVXfp1PHj6lnof0NaXCh/RrIRLJTEaB8LCc91xf9SgR2DjB+mGLzCTYFK+LT/lijz9t+LVfueBPf+UNDg/G5FlDFwRKgfCCtg2UM00fBJWL1PNAV4MgcPfegE/2DX3bEYKgtwEc2N4idZECsXdge0XX2xTCm9LPUFLiQkQqyb53xAh9B6OZ4GLn2O4tUWmUlpSULF70CKUZD0oQPW2XJr5KScqBYGDhyz814ul5wezwmuFE8oMPIl1j+eg7W+6eZX+0F+mr+mNTeSWQMjLQDqMkxmTEvKBpLVVmUDcSQycESAHB44IjF5IyeLRSBKESXEFndM7TO09sG6JvuX//Fh9+/Bk5KSeLGOm8I8ibUGgfbiBC4oZ6GtFIOh/wMYAP2L5HxkB7g70PMeI9CRcvUzxGwp0LrPfgPdF7OtfTty2KSJZLpE8SwF2zAx8IqiDSo1FEF5LHLQR80xOFTLi+CCa4tIkBMhMZip5hYbkVOmbumnt5z4lqmdqeq6tzXL2mqApoWl573RCaFQMhOZKX/NsnU/a1wYRLbucjQjXkC58/oBguuVJ7JmrI+HaDshF05KPnlp0Z8+DFlo9azbzL2HtHf0MB7IXER4kWiVirfUR5Rb3c4Nc7hNQ05RAlIh6PsX3C9LuI7LaoZonyNWY8o3j7CzQHY7wA7SVSSVyQRC8QIoL0uBjwIm1QpcpBZyhh/hDYkQAuqUl20dLaHZZA9BYRLN46atfzgw8/Y7dep+iXCKaqCJBiGbxF4YhBgLcobrzDSmEQyBtipRICc5N3Z7vk4xIiAfHjTYRCpgyg6RqPVo4i1+SkyIc2eKRU6KDACKR3yBgoM0XwHudTNIvuIlEKmhgQLskwawleJ0Jp8i5qVPAQIj4IolI4D8JZHAkqEn7Y4P4LrM5eNWev6lW9qlf1L3NFKIosHZBu8n1cCORFiXUdo/IYGy1dX+PwKG+x+8D737kkxpZqEOiEwonAdu4pxwLvJUiFi5G+6xmNCqzyNNtAqVzCB4fIZhfwXmFySWctde0pleNgltMKiTKauA/0MXlDYvRIoShjztWziFQN0S5YrRW7zdf4/DuvIfAc1y1f/+3fZFAW0Nccj0t+/ue+RIye73/2Ah88gvTCBpBCEKNEyMDbbxxh+xVPPtuxrgMik5RFxFQZ+7UkksApXkjGs4jOSxbXOfNFh3Xp+zw4zNhtE4myqAxCC+5NIxcXXcKJi4hUGp1rbBfJRTo4RqHoneWH9u/9OgMJSjmmR4K8FDRXgqww9G3E+4iSBq0co6MSoTUxCrJckusM72DX9tw5KDlft3i/wzuwCESeobUgzyR+rfkHf/ecXSs5PisQeQQpmB1q/ua/c4+mfkVrfFWpvEiDGqEkxhiUikjXk+eaKKAoFEZpnJBEJF1n2fuA9QEtJQFFfuMLtZ0l9o5gLbZPcIj3P3yCV1kCiAiBD4FcJX6iCMm/00dH7wMxKuQf4gxTODBCEGWS2nkXkSKmRgFw9oaoKiBGB85TyUgmBcvVFi/TNloYTac0LhgaKxOMxAq0v1nfaYET0PmQpODB43yH9yC8o4zJzzVSgndlwxvZhtuZZ9o/ZyrPcfUeb4bsdpecf/IIJVUKcnYg4hi/v+a9d+/z4e99j9d+4vMMJgN2i566XnN4kGPCBTHmHN3JyDePqO7fxRgNRwPea8cEIbl8Cd/83o5/8oM531oXbIsc12kaH9BRUBmDJGNydUn1ybcYLj/Fdld0MeAY04sbiR0KGV1qanWHzi1GehqrmLd/iYNf/Jv0UaB1okkaVeKkAZWBzhA6Q8SIMoluqI0hD6CiBdsgQyAvBwSRgfWQD2ibHbarwVvQFmxP3zXIaogmgtG0scDtA0JalFQJ2CKBLEk4c5ny9gKR3GSASE19cDRNj7MBb9PWNtMSRMqwjCHFFnRmR13vKMoBRiqcd3Te0wsoMoPOS8qyJDcKIx0qqyh8ArRkLiAEdM7hnE6E4xBxDpxKIeo+giFRSRGBTCqMlGgt6YPFhHSfdbbHule0xlf1ql7Vq/rvVUkZbqhhHqMNnUjUKikFWS54+vAFOjeIzJGpLPnDYiJo3bt3zOaqJ5MNk3tV8g84iHSJhIVEANMqJxzA9qLDL8HWij44gk10LAEM8oxKB7YdbOuejVdUJtLuIr/wl+/y/e+tOH8hCH3gs8+2ENL2q3eODCiM5AefPOJyvub23ed88P6H3DsecOfskPHkmFuvvUMMjrrrWD+8xgWfJFkxQozpOxWa+dKx37SMxoFoDJva0rcS53oEObfv5Lzx50b80/+mZr8SfLy5Imw6/uy/dsp3fnCN7yMXFz19L8gzTVUGilHJX/nXb/Hrv/qAeh9prGA1b5iWkmYfsMnbjo8Bk0v6PqTw1pB8CFo33Lpbcvt2we/++pa+tnipybRE5ZI6AEITfdrAhQDuxstgDNi+IzOC3GR87u1TvvPxc3YuyS9FkNTeEfcRbSTLq45NY5H5iKb3fPq05Qvv3v0jvUZf1R+fKrRBEOldn6RqTqKkRkcSDaLpCMIijEYEiQmeMkQ6D9vOpZho1yN88oL54PDeQgj01iepm9JomTD9BIFWifYopSYlSZm0y5CCiMdIkzxuIeCCxUqPvWnSAjFt2HwgAtJHrLUJO+97et8nUiHJ0+Z1Cpt2KETUyCjJosEEDSrDRDBBonx6voXgESHgo0skwNgzjIHTbs9dueUrw463i2fE/YrxKNIsF3z/8QJz+iWuP3rGdBTRWnO1sEijWc83HE4yfFdjSs/lk88w+Zjq8JjxaMp+ucVfrjCDktHtY8yBQPUbxOEtsB7FElWNuHNXcnLviFujB7z5yPPpLvLdhcToHKEyDpuO4oOv8TOHH3Drcy9ZLVdsVh37vcCxQMqA85pN62ksSAQqRCZGMhCwOrjH9mc/zzWeSJ5kijEN92KUOBSIAnRGpkALSS4EMkqCtwgfMUGgokRZcARM0DjrkE4iYoaPioBOH0ojqgqiJwhF79L/RZAOpyBEh/UBbkiSSoJSGgG0zhKExMiUbxaUIZiCYHK863HiBpISAyIk9H7nA/QW2ewphETehHhrKWm0JisqdvsSkw8phgUBIEiiC4nAKBJ8pA+RGAK+67Ax4hBEqQlRYgFhLVIkkFVD2gQLLcikRBDIIxRG/cj36Y+lOfvil19PKEqteOtkSlNvGU8N0+EA3zeoXGNFRddJ1pueo/GQKpfsdzXjieLWzDCoBmx2gc47ohU8utrx7GrLaDDmeJJxfrlm16Qcg+FwQIyRg3FFpj23ZiXT8ZDTsyO6xvHBw4eM8pzTozESy37fogeSN++d4bqWhy8WLNYtD17MWawaZpOMz712wL2zCb3dYn1kNDgli5Kvf/f7vHZ2m8l0iO829NGi8wFlMWViDF4aHl++oMgNmUwp5ZPxhNU2EkUHQnOxXNM3gaPRgC+8ex/fw8v5guXVlmcXa77y0+/yK//06zStY1dbcm1Z7beApMosmTZ4VTCqDIfjgmVTU5oKKeD48IDJaMx0UBF8z3bVgnK8fuuU1naU+YzvP37J+dWWy/WK0ahCxcgbt0+xtiEIybgccrmdU6qMw4lmfDREqwzXeMp8iG0Dre149GLJ9c7R9i0iOLSy3DubcXpwQHA9NlrGZcawUBweHKJExoNHVzw4v0Ap2O9qPni0oO4cZRb58z/zNj/7+XscHAzIVIYPgkfPLlntarbNhuVqT0TitOHg4ADpA9/+4II+BLa7NUZF3rh7j812wWxS0XQtbx2eMhwJrAuMhkMyJZgvV1jr8a6ncYE7x8c8eHyJR1EqzdPLDSF23DsY8fhqw2rTMrd7xoOcd+4dUTjBm6enLLs1y82OcjKgygzLLVRlyd3DKUIZbN2zqGvsbkPQmrfunnF5ec7l1vPJZ+c4BD3Q9IE8M6x3KwojGZQFeZ7Tdo6qKNg3W6rBgDuzGZ88v2LbJBJQ43oKaZiMp+Rlxj/8r37tx3H7vqp/yWswq9itHbnJQSqyzBBiwMae4YEm7CNxt2W/lqAdRmQUec7J0RStBzx89oBcSmanGYiI6yxK5exWbUoLspKPP1gzPs5QSrLatFQDTaEExVBSNyrJKr3koAxc1oEWxeyuZDSD7YeBD35wyfw6oihpdi3epzwjKQP1NiDLnOV6z7bu8d7x4LNHaAH5nRleZLy83BEuPkQZw5/62S+yrr/DJy9ScHaM6dCWKN+R1WpPpQRf+lcz5pcdn3ynpGsCwSeD/cWVJ5jUuBZCsFx0fGe+RKghOihs9MQ+IrsIOvn5dvOWf/rVx2nArwTCCYxRDLNI2KUJb6MiIgR6C2kEnAJb79/v2e0N7c7x27++Jrp0kJEqoaEJCf/2wzy4cIMSl0ETRZKCLWtH3cOud6w/fEquUt5O7yTSWTIpsFJSzRSHZ4HzS0m9Vsgo+L1/ds5vfnXFX/9rf2SX6Kv6Y1TF6BTX9/R9z35/Q1gUIW2hb3xdldEopVAyXYPOevaNoxoadqsd9fUGHxwxOMQf4g4CQUhUrtGZwRmdcOVS0yHwMm1BpIw3gdQpeypmkogmU4FbpwOanaVuHN0Nfl6mJ8XN/RFQ3hKcorMd3gkUGT4GokifMyJQmUGYHJSkUDkmKxA3aPgiM+Qi+dmaPiQ6pW2JncIEy5FvmTU73sif8Xb1hNO44uxwyPPdko8/ajl/dk0mQT3/GidDKEWHij228PRbiVCWs5Njervk5PiATOY8evgCIwQL16CrlDtWnR1B9OTjEXJ6CG1LHGbQNIhuTxwPMIe3+bm/9jZf3mV8/bcveeuzLR9vJYuLHUePfoO/8MUXTEzH9c6wbiWlLCmnEFyCXODgoMjobcRHy+ig5Es/ecLqyQWfqQMWg7chFAjbE7McVMpMy7ROP8sQGAgwSjLOczIpiAK87bF9ZLdv6buG0HuCMARxE5CtDEpqOtf9YZMdM01AJMOc1GiV/MI6S/j/6G2CRQFaa4SSN7TOSGc7pJApFgCF8BprdKIlxkDvLMo5nHX4rkMGn/y9SoKQtEJCcPjokUqhswxdNgSdo/SefJNRGo0ICcsfg0+xEALavkMI8L6HEAk+EkNERUFwnuh7YhQE4ZESUiyephWSKDUqy8mU/JHv0x9Lc1ZWEklPlme8dWeEDGMul9doGdgESXsdGA+2CDlkMCx4sVgxyjW9bekCHA2PEMHS9S2zyTF17ej7NZkyBDyPX15Ttw5rHcOqIvqAyRU/bLKv9gsmp5KXF0/Y1YE8y3i+eErXDfipL34eXQgyJdGZpLWK2fQYEVY81guyskSpnv1mwaqEoix59vwx46Kna9aMsgBiS9O2SDNgtbxmLDzGSPr8gKbfsFlfc7mLvHb/jOkgZ7Vc0cecdV9zfbXl3u27TCY5RWWwfeRyfsFivkFlGZae33n/Qz59/IJbs4Iyk9RdizGKEBQO6HvHsApcLVasV4rOBQajntloTGFyClOw2nY8PL/mbJpxdlDRdB2XixVC7jgbD/iZN+/znYcv+eDpM2zruVjV7PcNr98+5uX1irV1vHM0oK9r5vNAmWXMRhOyUrPYz3k+v2ZTO/AZXdeTFwVZZRhOFPduz2jqhvEwZ7Xasm099fma0He8vN5TmgkXqx2rHSy3NYNiyGhY0nSWuqspa0HIA5KMvm+4dTDiLI64Krc8vLhmv63JckOhUsij7QTjUcmgVIjouXM8o+l7ZMjY1DseLa555/SYXGVIIbk9m3C93rNzEedWfP/hIyaq5OX1gtffuc/nXzvmex895rPLHY8vVownJSNTMixKQhO4fecOC9vThaTPn00H3JoMyWXP8+WaB13L/ZMjnl9dczyZsisLRrniybMXPHxySZQZB0cHfPfhU6I35EUKnpyMSvquRWtDJHK1WBFFYFxknB2Oab1DCUVZQllUjGOSk/X9FlWMfhy37qv6E1Cdc0ilyXTOeFbSWEfuDK3fk2mBGEg224jyPZ3VyNwRYk7cCZ69eImK4HpHvd6jSkF0PmXFiNQ0CKWQKILz7LYWU0kGs8CwEqyWgrYWGCWoKsHRLcFI5FihqRuHC5Hxicc5QdM4ChmJRPxNcrR3AYlgT4eQgjyLeHb0nWU2LmiiZmpynry4wPUNQitUNuQn37nD46s1vfWEmHDTMaZDYvCe1nm+8U8DX/nKGzzJXuJ7hw06yT5DZLuNyFJydekSgj8E/uCbT+i8QMgcqSAbS6SDSjjq0NN3ZQrhFWmSL4Wk3SVS27ZzWBEZKIU34EKKD7CN5d0vz7h4YQm24snDZ2ih/vDAGQGdC+gE4gatXeDY20jnHKM8TXzxEZ1FJtpQKEmIKuWo+YTU74MnqkDTdnzucyfYesP1ZaBtIsEqOvejo5xf1Z/Q6gK2sTR1Q1c39H1HlD8cEAASFiIktLoyOB/QQhO8Z7P3iNYT/R4f+rSliGlrECUIpREyIGNIgfcyIGPaaoWoUpi1SJt+ryJRCKTSOK3JjSaoEp95tBZkKvmZMq3IJQQS9t8Fi4ge4SzWtkQREmIdkCikECBkIjBKic403uQEIFoIMoUjh5gyuPp6R2+T5+iYnp8ql6j1+5zGczQ7eiN59FxxXo+4ePqCgYSjWeR0VrFdLcllRPs9x0cV589rdk3P8lJw9/6E/eqa6vgWw4FGxhVFoRnNJiwurul3U2LQxK5j0EXU519DOE9otnB6CNUUGgd5gRlO+fm/OeGnLh7w3a/2/KP/7h/wr3yh596tGfNryfZ6hQ8RbTQGjdcejUaaFGlitOPevUOmhxXtssXWnvja69jW4cMeby3CNgghsCHipUBphQgBJwXSaGzfQZbRBk/Tt7RdS933yZt80/h4BCFwI2FPmWxRaJxM2WzaB4QGBzgpCUphhEIHiQgy4fJFyjIzUiSYTLA3fmZLiCm2JQTQEoyALJMEYXBNh4mB3vvUYHmH8hEfIKgUZ4CAIDN6G+i8R6oek3f4VtGJALFPskYpyDVoKRB4gvfE4Ol7R/Ae3/fJ3xwcvW9Tfh0eaTRaZ4ReIVWGMAXKdxwfHP3It+mPpTmbTGb0Xcfto5Jf+Mn3+O8+/IDDkzHbzQZEwa7p6bzgrbsVTR/pqxJQKY4+RM7nLePRDBE61ruaeteRS6iKkvnqitlsRJFLpBjSdhZCTJQePJkRHE6nNBuLzjSPLy544/SYr7z3NoMyR8rUsapswIPHVxxNjxB0oDPuzI64e9wQbKQqA/u2I4ZAgWC7vqLKNVYJzi8X3L97h8v5jslggooB11g2fotzklF5RKa2rDdXOHlEmQm6umVkhhy8doTzHe8/fMhqseTLb99hPB5gCsmgKBhNKx4/v2I8KxiP0kWTV0OUCGRG4myLFhnRZExGBZfzLX0M6NYScgtRJMNl29D1PdEFYtT4WLKqe5ASFzzf/71vMswkB4Xm2a7nxdWaqip4OV8wmWpeE1NGY0VhxgiVISOcjib0XpIJw37Z8ezFjqIscb1nv1tw/OaUd27fZlIautWW7TqhbUO7Z+0cb50c0zaBj1+ukUgOpyMePtPUTUNZSeZry8Wq5fW79+n6msVqSVEZ9naNkhmz2THfefySs5NbHE0zfNC8/VrBZy+WfPj4kvGgYF9aZn7I9cWCXdOzPxwQ5U3GRpYzKAwff/aEbz94xqQqef3OMRMHWVBMi4zFtuX59Y7rpmW9XjIYKFbdjqNyRmcdF60kXDxnOiywred0NuTW+Igiz2ntOQSPQPH8akHfe7772UN62/HFz7/OYltTDgYILVk0Oz5365jz1Q4XYTKoCNHS2Z4mBvpdSxCQZwVFkaMRDHJPMVK4dcfAlAxzOJwVBCv59OIVfe1VpWq7GulLhMk5OZpxtevoGo8IOZWUXC5rjg7g+HjM++93IDUiwourFd5bzk4rQu/oGkdRFtSuSzk4pAwc6wNCOpRWuB70GPKYYBTIkLJhlGDVwG99ZCknOSE4/M7RrgO372mW1w0EQ93W9NYhpEArQWY0RinK3OBDpG4aNvsaJSV5Znh6uebyekXwFt93ZHkBYskgz/nc6YT3ny3wIfnYlEgzfBc83jsmUjOrWgoj6ZWmt4EYDXhwnaMaa5bXHblQDCpB03g8EikDJoOjO5p+DrEzNBvPbtBRleKG6RG5ugrUm47DUrNzgbwTVDOVzPAteCLeBX7nny14+qTHumsyKcmzRJ0MRJyLHB6UtG6PwJFngn/jXz/j69+44psLKErJ6UTz6ElP6GBUCbzvOT6bsnvZIKWgt7BNZgiUh9/46oJ9rRlVBduNwzpPNjJ/1Jfpq/pjUrtmlySBwiFMRKubZoVIebMZcUIgb6iGKga8b9PwQwT60CFNILoIUqVcKMCJdM0rDy4t6REGtBZInWRdOqaQ+SRxFGg8CodSkkppml1LTyI1ViLDGMXRnRn7bYvtE9lUREOMAZNFijgBJQk+0AVPZyMyCmJwgCKKtJWLTkFwCNvjQkih1ID1DtnuGe47BmHDZP2Q84vf5u3jllZaruvIi32LK3tmx3fJtKXIHeOBphxYdi93DE+HaJOzXfeY3HJaGhAd3rZUBSjZcXw2xtqO8bRAiI7pwYR2MUduG7JRjpAF/vkFcjpBjsYgh+Aj2C3YDYw1Mp+QH/8ET7/6v+FPv7sj15qXz/esd4HttqE0OZnOiDeQlIHWNG1LORCMp0Pu3D/CW0trW/atZzV7m0Xf07U7DBDxoGTKuCM1RgoSiVNotoiU66YUISZJaxeSAgKXGm6lNKVQCA1RyZQdicQKRYwCQ0Tnit6mc5OSAiMFMgRiluiTFhL9N3q0TDmWXXQpBByRmv/MEKJCmgIRNNY2iKoiygYtA+iICwJFRFqHFik+hghBOVwICG+JNhKdIkgJWHzocSFJap2G3BikTo2lJFBmkv2+RoQO27eEvsXaGhkcEIhK41VODApMRZQluSl4tl3/yPfpj6U561rL6WHJT33+debzNfPLnqBLpC6ohGY0try4vGT34Dn3z26zb1uUNoyGQ86ORxyMK95/eE7b78iNpdQFTd/TdB2jQYEWkelsyHbbsnc1wUFj98wOSobDMZ3tCSFwUMK79w9wwdO5hnFWUncNxhRkRcHbkxlX2wVHhwdsmxfcOZvgvKLtdzivuFzN2d4EDeY6Rw+GrNc7JmWBj5GTWUYkQxsJUbPe7DFG07Y7BoOSziqePl1QzTIMHh082/01y80Vh6MheijRyrJeLZivr5kczJjmJfNCoI6m1K2jGvZs9jUns2HScmeKVdOxXu8psoxBCb0z9ELQxI5H5w8pC8OdwzGfuz8hAtsuEqTlzlmF1AXbZYMn8ni5YTqcMCxh22zT5NcHDuMB+6ZmVhW0tufy6hKZ5Ty4uOa91864fzzFhNfZ7B9ytWqRRjIalNw/mfLi/CX7csByu6LpJbcOZ9y9cwvrPHXr8CJwfJzz4uWOjJI37txhuV2SK0OVaabjIfPNGmTPZFyweLrher/j1mQMuuPW8SHVAGbDEQfTKZ8+v2TXDTC8zrZec7XdMqwqpodTsu0WF1qMUCij2buOflsznIw5G015484ZRjtaJXB1YHQw4LOPHlLkJdOxwdkBk1mJMTn3Zge8/+QlDYa8yCgLQ5VJrCiou8Dyasm3P32M9gGTa4w0dF2DxhCD4rsfPGbbNrioePPOHe4ej3hyteHd1++yqvfkWvP08pLOebIYEUoxng6xfYcoMlwxICrFV945pvEO38G+XqCdZ912aWL1ql4VcHA4Yf6ixjnLW7cmTAaBR5cXmC5ntVkTtWPVSZpHFog473DkZOOc9byltZau97SdQw001gWC9UQv8T5gpESNJFlVMdWWUR4YFJLHT1q+9NMKwZBvfyviPEynJSIKem+ZFgKdw34RiU4igsU6gVY6BVOL9LJPgzZJ3fbAjUxRCObrHdZ7tAC8oyoz9K6hDx7XR5p9w+AmjDZlnAWikEgk1kWuLnt+47f37Dee/d6SqQgiBwR2EziZCvqJRsaMv/o3zqj7lg8+mPPJR4LgJdFFQh7Y7CU6z9hvJYWRrDc1WQaZishSY4ViNlN0jSVsLenYBziHdYF9HdFCYIPHC4GPghvVDdZ7Ll42bFrHYGRQPvCtr28Zl0OQO4qRIYqCgQpMDyIHx5HJ3YLPPlngXJY8Mpkll5Ht1uJ9ZBwFofW0mSXTMDmReP+K1viqUu2tRcoElBFZGmoIIdPWRUiUSHS8XKqbJifJxjrnsH2PGA0wNzh7W9cg0rbDEQku4HpPcGlAYvAoGRAKyrJCK508okoTpcRozehoylBnyKbFWYuOAh0jhe/prefhxzvyKvmsYohkCDwQZTq+ahK5MQiNVeCsp4+RxqZsMrTFCEOuIplWKT5ASjIVKYJB6oqsu+Lo8ru8NbpgrELaKJoBnz6+oMor8v2eSjzj1p0ZpWzRuUMbiSo1KEHMM65Xc2oy6nXknXenzI4HKB9x/Z7ZyV12bYe1HoXFW0+32UKRUxycEkNOvF7Dbk2cjBBBEadTMBLyHJQhOMUH/4/fxPQvuPvWCdutY3G9ZbdpKfMCbRQqCKJPDbe3jjIzHB2P0UrSbno61+M6Tzc45qk8pXY2QTeix0uR7LtC0luf6JauT9LBxuKCT4RYodDaIIxG5TkSgY4CbnD62mhKEYkoUIrMFPQh0gXoIwQvyaVCy0ghQeGRJL9Y7y2ZEHjnybXCkySnhCRdj6EnywqUiHTe431IcQ/BIrxDBp/+j41BSpO2ZiGQVIURIxQogQsCEeSNuy0NIJRQ+CBT4LSUFFlBVQ0JIkGkgohJxphtcbaj3e9xfUYRC4RzP7TKIYUGYVAyx2Ow0iR55Y9YP5bmLEaQzlM3G77x4RXRg6wafvpznwdZ8Oh8zWwyoG476s5TFSP2TcM+tnz8sGM2yZkNB+RG0djI+WaHVBqTC7SC+8cjpBK8vFij0TgtGFVDtOhZNz0nk5KjA41rNnjvqFvHdDjDdy110zOeTJjPX1DduoOIkV2zJc8Ftg7kyrDeW3ZNjd1bRpMRR/cPGRcTLldLVKs4u39C2za0tkfKQCbG9BE2zYYRFUezgu3as24ajg+nLDdbLnY7TDtncb3h7t0pq9WOgQlkOoPQM53e5uXz5wRtGeUZbeNo9nuGxRgZC57NW4oykhmFUTmvnxRs94AWZDkMy4KsECi/QytNXpRInfHo6TOKfMjgqGCWDzlfdBAUB5MJQSqeXm3QSnD79Jh9sycExUePn/Hm7SPKaoCL8Nabo0Q9kgplDHWzwYVAUUA+jAyKjLsHIyajktWu4enFNaORocwNzkZElNw+GLNpBV/99gfcOjrkaDLggycvmFaK2Z0xSheUw4LxIMcoQwgm0ZYsnB1OmZRTrhdrTqZDVtvA83qJUYI3Tqc8fX7JpglYC6UesN51vH7rlJ97+z7n8wui90TXk4kJq31NFhV3b99lvrcYCbXvkbsdsyPD5964jfOR8XjAk2rO5eKKYak5OBpytixYtY6uFXy42FBIzXhYc3KQoyvDm2fHfPLsnKEpePTikhhgtd1ydjjk9bMpwpFIQaohkyW5Fpye5NzWJdIVXK9XmKokeM+4MhSlprU5IpAmQaMhvdhgm5pHzzdI6TAauk4xyV4dtl5VKtumjB2AT19sUcbias++q0FppHG4GFjWEaECMaRcMpHD6Eizn3uKoaG2nsvzDdXQUJYFOvPEGzJarjRHI81y13J8V9PvCoaFYDGHFy8aIsUNha3n7tmMy2eW2AWC54ZIGBFeIGV6WUIyqGut8CHirU20s5uwWmKk6z27fdL/Z1pQdy1jI0EErIem7TBR4EnT/vR2vJE4kg4aL56vUl4SAq01fYSqkhSFQImc42nBm+/l/P6HSyZF5Cu/cJtPPr0ghEDfOPrOs5w7JpOM5WZPsy1QkZvpdGS5t0wryXbl0DJw/2BEt++QQgESFwSrK48xEaMUxkgm00DnAk0rIUCMgcooqiiZjgSn9wbcOTviN77+EZfPG1Z2y53birtvFGwsaBVYr2w6CwiH0hZJQBpBtxe0XZrzQkArxe7aIbLNH8m1+ar++FVGi3ceqTSDLEdrg9E5WmXEGBFCEwToG/JrCJ5COrSOdJkn15JCRKTW2FGDjDcUx5Bw9vu2pel6nLdIKSmynKJMg+JwAx3pXEw+HR+pV3tE5iikxAZJ41zyUVYl+/UOpyRu70H1aKmwQiZSqlRorcmESBj03mFsj29bhLd4EdPXsxIvLb1RSBuZDHNEsGB1ki9vlwyuH3EaHvHmsGXed7QUfPhgTmcL3K6m8C2rxZzDYeRolFHlgnMR0TJnfhG4WnS8XGguhcGvoThomOaRaiDJlEAYhds1DLMR7X6H0obTd+4RnUcUOQpLrBRiqIlNnTR7hUEMZ2ADUbcsPnzB+//g/8J7/9odBuUJ++USui3jvEqeqBhQmcZaT7NvMFIyOhqnLaYw5GXO/MVTcI7l9F1cNmHY38QXOAfCYYxAqRyrFF0M+BjTc1k4Ot/jeotEIJQhqAxZJy+Yuhm4GaPYZ4rcKpTQN9LYHhvjTWaYxKCIgBCefbQI1yFcR/A96YEIUQj2SmJJ11/wHqmTf8tFhXUB6wJaS4ySiGiQQZEPSkptMEqjy5J1H7HBY7suNZ4u0ou05dU+ImNAiRR6LoQkueIsCIGLkqUlZZ/5kCTtgCwGyNyTFRbpeggWCEnqHpNv0yGIXtw0h5Hg/Y98n/5YmjNnO9a153K+RCvFl964zVvvvI7KR/zG1z9kubfkesRivaAqK4IPTAcDVpsVpZLYXtG0Dd57JsMR812HERkGx76xPLnaMB0WTGcT5suWwgii2yIUHA0jRWzJ44w2SibjI7TZUugMU1a8dnBCWQxZ5Gtcb/FWML9acnR8yjc+/YTlak3brqmbHXdOj5nMzhjlBdHBQFS88fk3mQwLXlxc8XD5Auv3nBzN2G/X1HXg6cUL7pzMGFZjRmqADQ373YZmb1k7z927h2RFTlYFqlLRhIYohkQpuXfvHlerNctmCypyNBsxHecIZbG+RKjAuBQMRwMKCfnQsVr36NBxPBM0VhPVFGEkPkii9RyNDzg5OcF1nn3Xs/eWbd3zxu1bDIYZ+67HRcWLxYL7J4ccVSPeujfFk6GNx3tFnicijr2ZvOSioLbXjIZTtAnkpcKHHfu+YjYa0GWeyXjEZ08WXO8sDy8W3D4bcPfwFuM858XFip/53Oto5Tg5KhiMpozyEY+en/P4aseg3HNYDdHZiKMTw2J+xYeXj1jO98yOjjgYTDHZmOgkA13yi1/+PNY/4mIeqLc7fBd49PIa6SPOBSa55Hreg99zudkyHWdcXi/Ydi1H1YAsy6lmI1Z1z2g0pBIZreh46+5tclMyzBXf//gRVVXwM/du8Qfff0bX9PjMI1rNk5cLZtUAFxzHB4ecHkx4dLVmvd1SlBW9jAxyzdFrt5hvGqRUzDdr1vsd14ueqsgo9Ijj8YTLbkdeGAojGKjArekQoRSbnWW7vuI4m5EruH8y5vlyS9PXDKea3P/ok5hX9SezvE1IdpkJ2q7Hr2tMgOgD3gqErBD0CN0wmSkW10AUxCAxmeZw6GikJ5MGGwKZyTEmQyoLLlBWGdV0ynxjiU7w8GOQrqVrHecfOKRUZCailGZ56anyFXkuUMKwajxOSSZBsgktRiffiJICYzQ+JJP/D+XnQHrJq+Q/cD4Zrg0Sa3uCzMlU0lHlxtB6BzL92QQYETe0sbSNVkSUjuRImt4jDJii5O23xjx8cMFy6bnf3iGvzzk+HPLwgYQo0VrgGoVyikmVDPb3TyZ0rWPfpTydpvV0NhBCoLORUanYu4AVCqIlUjDQkZ/4whFRBt7/3opiWDI4zGiuOhCBgMBohe0ie+Foa0H1ZMuzy54QIlpq7r+V8wt/5RYffX9Ns+7wNTTb5KsZjgx//W/c4fzS82v/9RynLPt1OnBVmfjnP0vv/v9eP6/qv191PBokqp3UEKE0RZIFqwRzcNGyc47eR3xMW+lMBDIiZaYo8pzo0mFWFToBFm6oera3ONXSqBpnOwg+5V8FhbIhQR1wFEJg256OgG1qurygE4nEvncOET2r7QYRBdpohAsIleik0uRkmQEFrrPUSHKtKYylwNFrTRQ6kSSFAKlBCjwKoSRHsyHYgPRQrC44ap5S9t/m9fEaQsV67vn+lWPlkgLq6GiEspK62WD3jsXeAoq2digtaCK83EeUKTBZwWhoabaWjRqDAy/h8umSwbgkeofJJNkkS8HbuULst0RRgMyJ+xayApoacX1F2AdiVvDZtz7j//Of/iPe+4mKu/de4/2vPeTysxUGQcAipEwETtnjBJgsQxlFVpWURvP08QsO8kMGoyHnzy9ofuLncEajZUS6kCSsQlNmGVJorNAIHxBdj+obhGvJfIftWgjghIKQfLLBWVzo01Csh74BlEYIQS4UwUWiEghjQCbIxw83q8H24DpwPVpJjFZkeQ6ZTk2OSLoIrRM4xJksBYlHgY8xgUi0REqNMhqTFUiTofIhFENoXWpuZUsfHLbrccGBs8jgCDHgQmDf9ykTDoEEohH8kK/oo0eKJM8VQqP1ALSB4NE4ku4jyXWdc+AD6sYXJ3xMkk33oz9/fyzNmVQ517uWw1pwazbCZ4Zd13BQlLx154gPH5/T9Ht+/ovvsuuTqW8+v2ZwfMhhmfP05TlNBk/O57x9BmWEZ8slo3JIjIrOKRYbT902JCuhYDg0zIaSeydT1rsdtXPMBiM2G0ewgWxUkRlDURhE8NT7hkwZ+nbPwWjC4/MrHjy/ZldbXN/hgyCwQHrLQNxjNKq4dfuI1lk+/uwl73/8lOvVhtFI8eGDOYfTEYWy3D46wChYLJeUhUQLidGG05MpdbdF65zGOaajIcW4oDAlXVszGWcoMeTlsqPeOXb7npOTAUIoMpWjcsfx6JDDUU6mW7zXlHlBIS0/ePiM5XoL0THIx2gVoE++kKo44PJyxcXlnHfeOOV4VCAVlDmUZsrAVHTB0wTLe6/dInhB0+/wokWhyM2I2AX6YMnykiqbcDlfcjicIGJJlY/49PKCXkC9dajo2deWzq45PRxxvWkpBhmrdY9rr7h1cIS3T9jvNxzOBtjeMxsNOBqO6YLnuz94wKpxfPG1W2S6TlMQDIezig+fnDOejejqLYMMrhd1uviV4JOnz1ivd4nSFByDwYQn5xf89Ofvc1hoXi63LNd7FustX7x3l81aIfMDRnnGe6/fomlbvv3xE6qy52Q64WA8JISWQkXKvOBoMMCbgPSWgGNVN0z0gM4GGgu7q5rz7Y6zwwmr/ZrpeECZa15eXCIaTe1hIAWTcc6itqwbx2tnE4a54mq34a27FYOm46cnM9bbFfW2Z7PbMy1g34B3Fq1Vug8Gmsn0gDt5iVSKdb2E8KNPYl7Vn8waDkZ0zR6BZDgscJklrho6U1Li2boWMxQgcoSMSQIUI6GLFHjKKMilQFSe+cLjmh6rEmhDiQIpNXkp2NY1WudkUqE0qNJg4x6kRLjkT5EuIvaCTRuYnUJ0AhMVsY4Yk9N5j0hYDnrrEgJfKyBJTyJpu2SkJHqP7VOGTaEVvQeTaUaZZrXpybQkywwdgJCIG9M5UiCUwAXLqEoob2sdIaZmbbuq+e43d9y5K9BFwVs/8QV+5ivv8f/+1f+GEBpENEynOf/u/+AW/+V/9YD9Kh1irxc9IqYBkFaSQSkYF2OiD0wCKA3rpqELEoQiCsHduwP2m5ZPH+3JcoUFlmtB08YELkCw7yOzA9hbyf7a8sFmSxQ1INFK4KTkN37tGrsJdH3y64xKw7INdDvLd75m+eTTOg3wipw8E9SWFIsQkhQoxB89Z+dV/cmsfWsTDEE48qzARYeWJGlaFLR9S9M12LZN/s0YKYyg0JI379xhdblj14OM6TBdR48jkelwgb53uM4TPaAEAkHvA0iJkhEVE6XVioADVIC263AhZYsVIiaPKcmbmSsBShKlREuTCM7WEoRAC4ki4IXjrbcP+PiTa3QGKkaiTiALo7MbOVtGHwJdJ4ghUobAsd/yznFgkI25eL7lN7/5hLmN7HSOCUkW3OwahloxGM4IoWW7qwk+ErTCx8heaFoDIQrMfsdPf+WEtl3w69+YMy0094aO6ciwUyN83jKejnnjVsHZkSYfV6AtIkYQFgTEyZi4SbwA6zy//p99lV/+5a/y3juC+29+mfl5y4Pf/Rhpc1Qm0aUhZMlnFqWiFYHh4RTrO0IUTKcT5MU19a6B4FkXRzxXR7TbLR6JiB60QEZBZz0mz5BSoTBok3K7otXkDIlVksR6AVlMTZYLUFubVA/WI4NDhECSC3qUEgijcTL9m0QEoQNeeIIUkBt8DyJGupDeCwqJ1AGhFcbkFFKRG0NUElAgAkgSvMpFokroexw0EVoCfV0ThUKFQB4ihkgv4430XaVAdByxD3TCse8a+t4hQiRmmszotFGTERciwUmKvASriN6R6wytMjKj0jUewZGCpyFJ1kWIRGfB/+g2lB/P5iwIClVwuYbZNKeLOZdXDcKtOTsYs9p3vLze8fGLp5zNZsy3DQ5NpgMfvbyib3Z8/vYpi8WK9XqLD4JxWdL5DmcDxoxpXUdtOwaZRGWBSZ7zxv0RUWikHlBWUx4+vUZ7QR414+mI49EYYmRfb+h3O8xwhEJSty2Lq0uOBxlDU/H4fE/Xei7ahug8b9465HNvnXJxecWDJ1fMly3e7sgLOBxNefOkoKUlUyVXyytmk4rXTybsrSXojLfPZuxbQc4x633D8WTM1eIZ7bal1TUHozEPH14RoqLxkUE5pLWWvmnZNoHBUDNWGQfDCedXLwmiJxOSuo40zmBkzmIdELpktdkyHADRsd63/NQbAzrb0YU9Xd8RvSC0jt1mSx8th+MZk8Ehs/GYl4sFz67nvHHrmEIGimrIy/me621N2zruneTsNjXSBV4uVjx6esW7rx/wZ7/wLm3T0vpAmZUcDKd88+NHDCqH0SlocpIX7NstnfUcTCY8v7wkmox37x0wznK+9cn3EQTun5zSX6z59ieXSA23xxW5jIyrnswYnr+cc3ICR2aKNobFesfT65c0bY2Uktl4hJKScjjicKDRucDFyO2jAxbrGj9v+OZn51SF5ChTKKn4g48+5Xic8e5rd/md733C9x7M+St/9ic5GFdEt2C1jlgVGecjdFZweDCkWKwpc4+MnlxJLvotZ5MKYmC5axhXBjnQ3J7e5eV8TllEtm6LznJuHeXcOszY2x06G/Ol8RFXqxW3DgY8v7xit/XspWVSDXAqIINkNFJs9i2FKXm53XGxa5jkIyQBIzp8eEVfe1WpnPcUhcF1Fm1MmhqjKCtNNRwxEFsmBwdcLyxPP3uRSFha0nrBYt1TSYG2gRAkOgYqFSmNpwlpA0WE46Mxm+WGt+/c5fl8jVIR3zf4oGhbsDahcyOSpy8bDkY5+3WkaRyzQY4MjrbvUsMnBT4IEAEt0kEpz0ySjkiJEAJvLcT0OUUUFBKGVUbfOZxSODxd7/AuEo1EyCSZJCY/igCwAqcTVTFKnchjIW3YnJAMBgM++fSKv/f3/z4Hg4J/9997lw8/uOazh1u8lzx6osAWeCx125NrxfWmw5PeQdvGs91vORrkGC2Td0IbvBOEpLPk8fOWumnJtcBkAhtr2vZGbnXz4s9GgVv3C148tehxzrCQbJuA7TRRKWRQzI4d3/i0JTeC3jvKgUbLknIqYCLYesfIVHTecnAGuoHNUiSfSEwo61f1qgCuty0Rn4LbewvoRCxFkJCGnuAtKnrA40TAWeiCRGjD03WP0vpm2yZApoENMqBjpMw1Y1NgQ8CLkKTMMX1+ESOegO09wUWC7Wn6juBF2qhrSaYlUqsU9A4EAtJ7jIo4mTbrSili5whSopXGWvj2+w6ZKbTwGJWw+VHlRF0gVIoZidYl1H63Jb94TJx/jUX7ER+9vOT9+Y6dU0QCsuuxMjWyVV9zKw9YKSlHJYEMj0WoSNM56qDpo0Q6z9tnJX/uzx7x6GvX3NaSk0HP7NAwHBasgmTtFK5tePbYcvEix2eG1w9zjn/yNkaRIuDWPUhFfdHzy/+vr/L3/tFvUZTwi7enhGD49Pc+RvSCvtkhO83wcMLwcMpmt2NvA8Ynz+1gOMCUJV3QOOtZL1c44Xh+9PM83kQC+/SzlZAbgZERL3NaZ8nyEVFmZMYgVEEsJRKQMSLw6Xl305ztfCRah4+R2FtktETfowkYlaIZokzP4IAgv2moA/GGfBv+eY6dEEiRvGDK6BQtgkALTaYzdK4hekRw2K5DFAURgUMgosQIgQqO0O/RKKQuECZtdvGBUVFh482/IyY/JX1PrQOWBhssMgRE7NBWkBUGEDeUXjDKEOlRIlCIiBYKFZLHLPiIlund5CIoaSgzTWkE0f/o57UfD0q/GFDXK9xux8uXhuADRwclq/WWL703ILg94xKafeTZy2vOzs7o+tRRz8ZjBkcT6mZLWRqWq5ovvXGb2eyQ3d7ydH7NvmmZDEruHxZ0vifLPHdORxwOx2y2nq7tqEyANqDykoNZxbrecbWac+/4gN16zd1bp1zMtzx/fol1lnGuWQvJy+UaZz3IZHDNM8Fiu+TxM8XVeg3Go7OaoRwi9ityFfBhSTmdIHvN3TsnHIwrVpuae2f3WOx22MZxtdiAhZdXG55LRVY4DiYHzK9qHj7Zcu/khM1uxeV8j8wMZ8MZP3j6gNuHA+4dH7DfbXj08FPyrOL7j68ZVZoyl0xGU0Z5ZK8jvfKpO9cle+cpCs1yf8V0Mubu2YRtvWJdR4bGIG3P6a0J06piXW9p2o52U+PWNXPzkruHB3z0g4+ZHt1CKU3rAlf7jlmRs9ntuVouCa5mvtFsP/yA2vVMBgeUJqfKFH/mc2/wK1//kIPSsy0Fd0ZJ8ng5X3C1d8xry3tvn/D2vXtsu8hscEzbOV67e0zt4MHzC6TUSCV482BAlWUcjg5wHuo+slpumR7N+Oy8Q4/e4k/93BfZbGtyk+F85Gq1o9djPjpvaeoNVb7DtU8wIjKubiXUK6BM4M6tA2yAi/UlvWuZjnJ+/4OPOJkNcbs9O9tzejxgta3R5phds2dUCiZDzdF4xOE4pyozNvWa+dpyVJSMx0k6Frzj+MCD3eL1iBgDXbdl37a0faQxG7ayZJCVPH9+Thscd2/fomle4r2jlCXjsWBTW6ZDzaDQhIWk857dfoEUgWEuCa9USq/qpur9DqMrBoMBIVh62+OFpBfgfUNrHX/hS1/GFCOevHjAb/zqB+z3nqIUKJXhvKRDUK96hNH0HmLtkeoGXOEj3dYiheR7HzzgtVsVr797xMcfdbh1kiolWWHEBU9ZZuyDZ7CT5ES06+ldxHuHkkksEiMYlRozIUBrhYsBowXe+5RndGNQ1xIUgYHR1HvLtukxUtHalnDTvIlI+pCSIDUhRkwmkAheu5vx5FmH0JI+psTssvJ89/tLpNLYVtBq+K9/5QGrpSXGjO2u5dvfesLFdctkLNi3AaLgYJixqP/5zRduPl/rA0YZms6hdIIeiBioW4c2hrGBeudRJQTXEoNBSYnMImYk2dmACpJcRXb7kH4vwXY9V6uebSsZDnKCC/yZrxQc3Sr4tV/t8Z3kkw9qXIjM7vTcPtP8jX/1df7Pf+/ZP99UKIFUr2iNrypVlJAphRKKICQhgg0O+ojwEectMVh8BKkkqCQNFELzu7//EJUblHMoEYhB46UhM4os0yhjkhws+tRYGU1UEq0y5A9hP8Fj+x5nW1TXEBpN2/aokAY3QYEwElxAeUECsntClAgZU/5UUKRQKUUUkSg1UgUEksYJ+tygUIhgCL1AyZgozlGi2hYWe3j+CSdmzapr+WhesxUajMR1ge1+TxsDAyU5NJJZFtlseq73FpGbtCYXERsSrfZQSw7ywM+8W3GSj/m0dRxPCja7jm29ZzoVmEFgnEWiDRy/8Tqd9zgz5VsPltgXL3nvrRPuTsDNL7jc9/zn//ev848fr4h55E+NIl/60us8/O5T1k/24CKlUdz54m2+8r/6W4SXc55881tcLrfM1zv2bcvyYk/rBagt1tZELOtO8zJ7k32fpbxGJcmMQeU5SiXYh/UR2TdIdTPYiRCioosghECpSDBJtuj6QBsiuIAIHoEAr3BOEyQ4KfDC/BDZhFASJxRG6aSOMIYoFVLJ1GyFSJYEBUlfESPO+Rs3MVjrEMKjfZIT9j7FKPioAIdUFmNy+pgiYWIEYoYTmrQ7E1gRUd6RSw0y0CtP1IayqqgygfRdgtlITVYNiSrFSBAFQQhCSLAULxMduLGWEBuUyQkWvA/YAJ1Lnm1R5JjsR2+1fizN2fX1FaOqoMoLtrHmnfEZm3VLs3e8tu0pspLLxTMOxkPGUhDFnNloRucM08mEPFMMTdKn4iPztiZvMh5cXKPIUHgy1VDmiqGPFIOS7X6PIeeTB8+4dXpMZ3oGRcrO2tQ149kBgyLjarVDeUHXNPTW0blAbkoinqNJzmrfch0UQ5PzhTdv0fcrms2W62GGUDFRYIQk0nE0G7Lornh9eEiwkaISTJTlejnn9bvvUBRDvFB89vgZJpa0tqOvHQ/nV/zsO7dwQpGpDKRl3y1xwjCYZIzLIdt1w63DA9bbmhfPl+SFY1RkVIVhOqzY7bYgCsaqZ1pUbEzNZr0FIpvNjjyHSSXxckSMiiqTTI4n3Cfjct3irOHrHzzn9TuB88sltm146+yAo6OKy4s5se7YtpayWTISBVe7NY1VbELgp997i9vHZ3z67DlHo5yzs1N+43vf5vr8khACeQy8eafh3jhn43v6zrI0Lc/WWz537y4Xiytuzw7p94H59ZKX6ytOZ3fYbnY8kxIjHaURXG0bShPY5x6UZtcEpKlodh5TTNjsDrleXxGkot4vuZovMEaz2W7ZbXdIoVG5oreJAJeVd6iMZdy1GHrq1nM0G/LofE7d7EDkeNGz2u4YKYUcA5Xj9qAkk3uEqWiaSyaTlp2LKLHh2fMly+WAanDAo4stpTTcvXeX59fXON8yzmPyx8Sc00nF9x9fse5aiphzMtH4aNisd6gx3DkZ82K+Yb29IAZJVSqi6VjsPTpC6SL79R6lDW29Q0TIc0Xvc4KyP45b91X9CajJqGC1askGOYMiT5RQAiIa8A4RFM9fPuHw4C1+/2sPWS53FNmAaBXSCLJc0veCfFgQArRNi/CBEBTWOnod+MG3HnFypmEguV52XP7uS5bzGpVJuAmUNdIwmw1TbpcIhBiIG4uxnp33KNLUO0H6I0poUIFMS2LwGKUoFHQh0d9i9MlsTsD59MZWQDYcI9qWgTHMbSB6UFr+/2SdZVozqSLVIHD7buTh04DzCiEkmYJf/PMn/NZvXrBaeGwDapjT7z2FK1jHQFVk2NAiFbzzecX33ldgJcPC0AewAkZlxvFohlGSpukIzlEYlSSjN2G4RkVKDTYKBBLbRkQAokPpJN/MM1g872lqlyhzO0umc2QW8XhePKspdMKLn5wO+Mn33uKDJy+x3rPa9OybjtFM8j/5n7/Dm3fPCE2B889RAkxpUBm0y1cy6FeVajSeoAhp83GTH91bh8VD8Cgv8EEn+p6WaJ2R6YxBVRCFJFeKGCIISe9jwqSL5AHqo8By40cjhayXwynbTZ1yDaPEu0Rb9UHSO0WUBgyIG6JeVIKoBTqdnRFSQJGza1qE60EkdY5SmkwLlLUYnfymygekSllnRqqUNUiiNyulES7i2w08/Bbq+g/4uHnCvtljVYlQ4G2yaeysYzSZkeOpwo5m2xF6j/WCvuvSJl4rghDkAk7KyPFQMRtkzOdzvI88u9pRGkkRFWhD1zi08Ni65fLFM66f9Kz6Z5RvvkPvcv6L//YziqyAqwve//Qp35vvcAqOkRxVEJqe3bNLhC/IjeLNL97h5/7Dv032M79AfP6CUhacPH/KcrPmw88ecHm+xNqa3jsmh2O6neAi3mEzOEMrg1aAVghlICqUkClAGU8mAkq65EsUEhslnY/4YAkuNdcAjdBEBFKkYZoQAkdASw3B432E6BP5NmFAsFLS6RydJ8m80SW5EGR5lkihwWNjyhWzbY3ta/A9KlpECEQZsd6nrZtQEDVaG7ROslcvFN5DQJBmgZ7goQ+kgG0CpQqJpOmSQKOqJownM2TokLZl27ds257aCjQ5Ugl0TKA5JSJakQYGIdI5SwpQ84QAzU0YtoqCqCRt7LH9j65c+PHQGpVi33XY0PP26V0ePb0k04Yyy3j44jlaS2zTopzjzr0j+piz2O+RumC32bHeebKTY+6/9gaDwZD5eo02iqbrCC7yE/fPePPWhIvFJcORxgwkrR3xyYsNs6MZJydj9puAMIF2W/P2wQmVzqnblvn1kqPDA5re0jY7ghIsW4uzDeu6R0vHyTjn/kmF0orXzt5O3ojYsl+tUTpHmy0iBxV7TspjnJes1lvefuM2bd2x2zjK3NPFlvl8j7WGMsJiM2dYSbK64vvPV7zeB3763dfovadpdyxbsD6wbTushAcX19w/yKlFR5VVXLU9rtmQFRmvj2bUEWbViGVrOT4cMpmMeLlcMBwPqOsdUQoW+45JBXmWMy6HrBvH7aMj9vuGojrj4fMFjy8WHI7GfLZomdQtg1xxveuZjSv2dY1Skd7X3J6cQgwsri9xQXA2NGhpWV/NGYcRL3eeNvTYpmPZXqCEoEfx1ukRQlqOBhlds+fkYJDkCrnh4/NNMuvHFd4L/uCDD3H0vHt2hHXXDAvJbDrk9OxnOZpkrM+v+OrDDymmGaun5yxWS9q+58njp1gHWsNgOKLrOowJ0BtyrdnXG/abJU0xYLnLeefWECPO6a4CZVkzHYz45PGC87llMlBEU3K97tk1cy6kYDAoGegenOLx5Zosd9RNy3wnOZy0HHU7YidY9IrPzgNGRAqlkHLI6MDTrWsev1gQ+8DMDMlKMJkk2oAKLVdbKIYHHE1mrOuXuNASfIRe0vUOYSRXdc+wqLgzqZhVWZrSdIq2t6is+HHcuq/qT0A5L9Fasd1sMQcTRuOM82WHljmDPGcyLHj55DG/809+gCQg8DhvMVokHLR07NYRGTWHWc6W5GHt9x6dJ99TNJrzlx3lSBGcZN80FGWGUY5MaUTUvF4MuT++xUkxpReCb1x/wrW55KRUrLcOKQRKJNewlgIZPYg0mBfR44NIaHyZsNwxRpRIE+LOeurC4BDQNeRVQdV2uEKxqJO2Xwq4GZUyHmre/nzJBz/Y8oPPFOODjPUiESFDEPzWb6+YrwODMvLlL1Usrj3VzDBUiuvvdmx3PZvrPeVYMl8KxgPFaKj43ic7rJcUZaR3jraumQ0z8kyjCkORaXwULNoaEQPTQUluFMIUjIdDJqOCYWGQSvLiasX1Ys3y6RaLQORJiqozCHXyp2kUs2HBaFrQdB3Q89/+9qccjA0xBCDgYuBwVrGuO7738SX7iz372lLkI0LoOZnAyf3BH+Ul+qr+GJXrwUuFFpK0cPA3LtCAjZGgBAiNFJEgNEEaepUDOcPBkHgjP0ZEqpgIdsGnjVhwPkF5REjNkhS47YaDqqKuW3yAXgSyTBFdxMsCLXK0CAgBUkqEgGpYIb3jYJRzfr3BORiqdHv3N7TUQhm0yVBKkSuJ0DKBMKQmKIPKMoosR6scKSRu1zF/+JLz3/lnFPuvcfu+ZD3fY60jyoSCcDbQuB6pDXWT8naV9BgMUiayXwiCLnpaF5L3SglCE2iU4MEHL9he5vi2570v3OXwoGJ9cQWhxQwG2P2adleTaZhvt3zrScOTb1+yK0bMEeydoN2v2dmaqAIlAhECp+OS/XoOMpAJkJng8OgU8WROLD9DDivyW3c4Kwpm7Y7qYMpvf+136YVlPJtQDQ1Xz3ra45/DFbcZGkOWZZgoUUqgpUDZDtc3+HaPlwGUSFspaXDSYD0ImTZmOlO4IHEuEG2LFuJmqKZuhmSAkCghb/x0SY+qRNp2OhK1VwaPdn0CbgiB8wmp31pHwBF9jxARpSLCW4IINE2LiIk2ijYoJdOf0Qp0hkBi1M0WVCQvnUQkma7vccGybVukCPQeAhJhMrQYUBQjTFbidcfSrfExUXEFCqkVw7xECpDCo0VKbc8FNxvUSB89BovAEZzDB02UkSh/dLr2jyeEuhqgZCDTgr654s7JjMnsgNAFnl/PKQvN3Tu32WwuKE3GYrEmFxlXyyVN74hW8/HjZwyrMYMy8vq9YySOt+7exijJraOM2u6YTApC2yBtngAVJ4p5veP7D6+wrWVUjSgHQ4SE3W7Hrm4Yj2cgM17Or7jeNDy4uKYUhrNZRVWMmAwyyCzrzQapLdbXdM7hoifKhNo8nGWApu8l2y4yzCsmSnPn7JTFdcmtomXXeh4/e8Ry42l8x8468izD+5bP3R2zawJRwdXVc8rRiNPjY9zVnM6PkErjLNw6PGU2TuSyfQ/7lUVVioEWRKM4rQQhaFQGvm3QwvP6yRSdGa5CQNIyKjXbZku+7dl4S6lm7C/n4D3FrGA6GHCddaybHfs24yJ0zMYjbo8HBNHTdx3VMONoVmJjz+nRAU3refDwM/brHccHOZOy4N7BAZt9TpCaXV6S54bH8y2FiXz2YkGmHD/52gnLVYd3ASsLNusdk/GInQ10XqGiw5gS4aC3lndPNa+9/bP80v/ob/Py6UsufvW3uabj06fPOD6ZcPXynH2zJca0Bu/2W+aLPfl6jXfuRouu0VqhpEzo1GARreHb25zDowF3B1c3oYg1x4dj2nbHG/ff4Mv3D1ltGr7+sUDFPSbkuL7jarvm4aLndDLidJphMpKMQmiOJ5HrTUQFx3tv32PfeYQXrFdrnCwpB5GdVRxMD2iaFWvryGVBLA4Y0OO6NVHVZDIwHI5xfU/jQRuFNgWHeozREucl0jl29Y6NzRE3ZtxX9aoA7pwqri5hFyO7XUekxBhLkB0/87M/y7fff8GzR58xyjRt79DaIJF0vcc7mEwlSja0+44X8wYlQBmJDwIVk5F/cqjYLXUChwCj8YA69Pz84Iw/994v8t4X/jQn5jaFNcheEnvLbuL5u9/4O3zrg99jICCY5A3QpAYNQqKxicgok2yawLSUSDRtZ9O2KQY00EkYysj/4i/+BK+/92U+fPAp/+VX/4A7r7/G1/7gAVIkSVQMKW8nL+DJ4y4R5KLDEZnMMubXghAEro0Y7Ti7M+Ln//SEixcd3/1Ox7/yS6f8wQcviCFwMNREBXYjqYY5v/Tv/CTX/8W3Ob/sUuOoDM5Hui7QOYcPlqNRSRcSIXEyGqam0ydPhfWepu3JlOL1W7f463/tL1CNDvlP/4//CY/PF8ROgE2e43XvIBh8hO2+4ehOTlYJBiPD05cN2y4mb/aRoJ9HXrzo+U/+Dw8pjeJwnBOCYL1v+MVfHPMX/+ohjz56tTl7Vam61S6FxHtPlIBM5E8pJXml6fHpgItC3MTpoA1Ca6TOcHg8AqWSD0lHkCpgZAqtR0tS+rBEKE0AqixnLATBBzwZgYhMdtZEYLxRTwoFQqRw4lxKBmVGiBVSSEod8cGz9xEXJToKlFC4mxD72PdEyR/mtwYEgkAmI6ZzPProAy5/7xv4698mn254542f5+Xj5wgZQUViCLRNQ08gVzkSSeVbhiIw1D49h6IlKkHjIksvIaThkdQB6yObTUB1LT/7+TGm2WKbwHhScf3ygrN3XuPqQc3goKLtO3Jp+fL9guaB5eP1gpVKJNs+eIIA6T1OSiSCetPhW0c10OwWLUVZ4J1lfzVnnH+COzxGFQaOj9CLDFiTFQXeJ8jKbr7l02bIJ9nnCKrCZJGByDFGIIXHeksfemzosL6laxq8t0itQRlyVVIoiVM5XdT00SK1IYtQ5AYlBY11OO/xPsGkYryRvAcBUqXmWwgQNvnXvEX5HhFyVJahREA4i4geLQWW5N2VMpFAPZau2dJ3PTZYMmnIsojMDT7TdFET7Y33GEGM6V0VgycEi5IBFSybrsaGDhF6YohEqdBeUxpFEAZVVoyKkiMBru/xUSBNTqFUCtGWEikiUqXhg24tXd/QWY8kkDlDVkR29Z6IxkqF/RfgMf2YaI2ee3emTDLBdOg5OhwiqHi4XqK14HrT0LmCrjO07jmj0ZS8MBzGQH8FQQsG2YRpGXnn/i2yKrBt9vyZO6cMBgVd41is1kyGFevdhsnkkMVilahdO8ly0yIiVKPIaKjY1C1VISgrjRUO0SfvhHeCg9GYUaExqie4DZk5ZDAYIX2P9y3Xiw3ni5ajqUKrHskPM3cCs8MDDoclMmgm44p6v0DmhhAjLy7XzEZjinzLtz58zulkyp2TI/ZNS1EqNhtP7zus8hgh2O1a2s5T6vQSDUFSFT6F5amAC5aDk4LKQIyaUVGihMTJSLOtkVrQ1RYlHcrB/cOM1d6RKUdmJE9frjg5EDxrN8yGQzb7nqEXnC8XCLniZDikDx3Rw8G4oYk71s2ISVmidc/xUcZm27JYLJjXDUF6qsmIRgRWTcOZXFFWDWU+JPqOs9MZdee42mwRmeFgNOaDp9eMc83r926x3nQUWUHXdhyNKl5cXjMcFzTNHK1zrucP+Tf+zb/FX/il/xl9H9i9+BbbL9zi7/7v/q8cHd3i/e99n8GwYrlY0bYdRZFxdnbK8fERVVkghCIS2Ww3bNcbtus1fdcls2noyKRmeRGQRyfsmsfMZpJZabh7OuLZ4oJ3bhtuT4f8lZ/7Ih89fAjFGOX2HI6PUOWnlLrhoJgxrCyoitlwSPAtkyOFdNC4DqNLRObIwoCTwxN22z1WbskFHJ68zdW+4+60wAXBxdVTpqNbbPY7jAoUWUHtVowzjRCe0WhEcBltt2O73xBFTtsbZoMS61tK88pD8qpSnRyXHJ5kfP8P9rgQWW87yiLntTdG/N63v8fyuqGMkkmMZKVhUVuCT5PnPipW53tCr+kahxERjyD0HiUlwYMIgfU65UIOjCZDMOgi/+vX/wJ/7q2/RHl8CnOPkB6MSIe9w4KRiPxbf+Pf5/Ao4/d/4+usbMPztkfISBNSlo2SUMnITEu8cdyfZqyznuA1V3v7hzLI0HveOcg4LQ1i85LNfMWwkvzlX/hZusbz/c+e3eDzBcEKmkajCkknA6IPKJmz2SXcsxKCQQGDSvP0Uc0HD8bsO4kzin/4jy/pukieKYQuKEYtQgTqbeTv/GffZNf02B5MnjxheWbwISIlFEbdeLxKTocjlBIJdGC75EtrLEaAK3IWyyVXVyv+4s//Zf7Dv/U/5f/0f/v7bJqaMos8/myDEyJtLKOnNBkPP1ujcrAO+jZwJR1G5aznOXab42xkmCtKadjsWhorkUriUFydr/nm763+qC/TV/XHpOxuxaASbHYtiEQ2DZkmZBrV5kidoTONFBqTGYzUyUvUW/rVGidket/GCEqhBZQS0IrMaBLbwSO8w9FiQ6Tf7tBCkRvNzYoMpRUhgA+RzjlCsGQ3OYgSaCOsF+Bvmrw+0yhlCELhg8BJQa4VO2vZ7fv09aJDeI/zEa8UmVZUpsReXfPkt/4xZvP7lFVHCPDr/+SfJACFFBCh63r2XUeuEwTiJHT8RNzyhZOKw+MjFDX5qOJ6sWGxaRhc72iFBO2T5UAbDB0/9+6E04OcdtdSaUPvHdPZiPrFS5QWSFPRbhcY25B1Pb/wzhGbHyz5g7piEROIUCOwSuF8pBeCnYv0jQUJQTZEMnb7hqvFFW306MsrRvfuoWcT1hdzNuua4WiK6CxZ7LmoPcvX/hKTk3voPvI//Etf4Ne++iGYCg2EaNkFx3a3wzY7gmuQMiCCRJsi5Q6bAb2QdC4iZURHj5QKLzUhpKZIBw/CgXdJNoslRkHiI4qbwXbC/kcXoFfYVrE1iiAjIgi0ighlcChiSBA2Qk8IgeACwfbEaFGZoCoGkBc0XhIBJQWZlCATYASX1BcRh7ctoWvQviP67sb7G1E6w+ghQgFCIURBlUtOphrX99RdTxM8vfUIrbDhxu7kJNYH+q6D6OlvGmvhLYSI0JooBGjDv0iSyY+lOTs5EJRqw2xYsNy0zAannK+fsm0czb5lvbZstx2D0YAmVhwrxWSUUXcL7hwV9EFBrBkUBVfrLeMoKHJD1y7Z7geEkAg7dSexncT1gX0d8L3n7ukxTR/onKUgMhvmlBXYkB4Q3X7HYtORFwWTsWEYc9p+gw+a0bSiqBSN7zk8POJq07LbXnN6PGO5XlBlgqpUOO8QmcT5QCEhYKlGmpeLJYNqyHZbM980aCe4dzrkL//pn6BvIx2WPqQ0eoRlvlpSDCsW9Y5pHnChI1c5FZZ921JmKYXdxIy+tTgTISqCy7icr+kDjCqNd5q6Dwx0TugddVNzPu8ZFBHQWOewUXK96siKjKuLS2zf0OUVg0HOZFRx+6Bit9+z2Dbsa82gkmzrFb3YMWaI8Zp1FymzyGCgQCoW8y3DakjbCD55eoEsFIUX1Lancy2F7pkWHmMGdN0eoxxOeJ6cf8Sbd96i7hVRQIiG+7cPyYznYuU4Gmlu/9Rf4y/+0v+SrCx5+P3v4Edj/uP/6D9mMpzStjXRel68OOfkaMYv/MKf5eRwBqqnW6zZe5vyNkTBa/fuM/z8iLIyXLx8yQff/R7LTcqxq4YlV9eOo7ffQdhnOAWjQaTte37304/5qdtnfOGdL3B7+h7To2POnzymVyM++PQBTyIsqh3jQcntYUEpBWsnyEJk62C/VwjV0nrDaivYdgvafs+twYDldYvbrchC5LPtnqK4ebnJQG5yYnAUGuRwSmlymqbGOMmmsShlGA8O0Cbn7tER1aAizxRt96OjWV/Vn8x6/Z0Dnj5dEUXa0pRFhm06gquYDSTLyx1OGK5Dh+ttkpnHiDGaXA+Zr3t6ZxkeykT87SJ9Lwgx8Redj/RNQMpEWnuvGPK3z/4md4s3kc8b4vVzZFURb00QXhDLLAWD3Z1wbzDmf/xv/Qf8qT/zZ/jlv/OfE15coLVgHQTzrocgUChmJQQvwDtuDTUy5jigt56hgYlUlBg2F1eoCF9/dE3vImW/4T/63/9v+cY3v8E/+H/+Mo8u1kQV6FyL6iwegWsE4+FNgKgPTIDjUCHDAJM1fOs351y2Dk9M24CQI5Skdxa7ECz3FpN7CqP5+V8o+J2vNXRO4qwnhkBZKJo+IkxFLzOsizTbPVorjErvD+cDIYKPDqk0RZmDjFy9fM7d197h3/ulv8qv/Ppv8YNPnmBtOqwOxsmn0NrAbCqpW4+3CaTib/J4Qh/BRqpMcf9swMvlFoeiC1Ap6DYOocCqV3TXV5XKUHN0cMRitcMYjTQKmSswCrRCZ0kSGIUhqAQNkUKRZSbR8AQEH3HOYbsWFwIdoI0mNwajUsiwi4FgO6KzOB9S5piQCKkQQjMcZrjWYXsHEry36JBUS8i0YRdCppB5AkZmZNqkZsALpFIoEXExUf98TLQ/EwQxOnqRIEG1n9N+7wHaPiEre5R0eHkjzXMJfNI3gfVuj/OeSWZ4q+j5i3cLTp3gS7/4Uxzevsv104eM7t7h8aOHqAI++eAhm3XN/s5r5LNbPPuHv8qf/5v3uVOkfMmutYTFNeOTKVIaghOw62i7Hud6pIqUpebgVuTfPz1B/dolX3MFayIRhUziOLYxEP+/7P1XsK3pmd+H/d70pZXX2unk2Kcj0I04wKAxACYAQ41IMYw4omSatMRy0ZZp0XbJKpfLZbtUKlsXEmW5eEFRok2K5EikmYYcTsQE5AGm0Tn3yWfnvdde8Ytv8MV3yHuwuooqVD+XXV2nw1rf+t7nfZ7/72ehqSoaa+kMI6qy4XSxYH3vA7bcFUyaUeQ1g0uXOFvM8NIidEMWPMO+5kH2Kc6i5/AhIS/X/Mo3breqA7em9Ja6aVkBSilklkHQSNlmBH1QFF6yLhpqW7c5LyRGa7TSLVrft011XdcEV6OcAxHw4jGJ0YN6nAETAmrXYF2DcrScUA0iihE6RscRQlhC4/DBt1AaaAEmUYcoStBSkHQH6N4YLxKSxuO9RYYW7GeDx9kabx2ls0RaEHCIWNMXAuUljVMEZZAqwsQdXBxTItEYIEJHMULVpLKEMn9MkQw0uDZzJiUiSJy0OBTe1RgtiEwrxtZIjDGUQtP8KywufCjN2fxsztbmFvN1TWEFbzzaY9Ad01E5Tpac39D0eiVlYdu9UilYzRacG6RoCWky5q27+zS15+j0hPce5lwYdUlTsG5Ov6tomilnVYK3PU4Wa4o6YKslRbBICf1YcX6ri1Y5naRLZRXomDTrs7mRMMsX5PMzGhc4WwcuDIcIV3G2KhllhnXRgJcMez2K9ZLNjS6OmmHWpSotzjtmq5JuVzPsncNXBY6At4Zer0/jYmy1ZlXllMc1sgEdZVwY9JlXDbvHu5RVTR26lHVNtGnIlOBwekhRFGyPMs7mK/ZOVkSRZtwdk8kI1TQsV3MWq7Yzd7VAqpjFuubIefppzMXhBvn6hMPFlG4vo2MiVAL92FA9HjUrNEXpWduCiIaE9uEBwySLWBYFy1rQXeckW4Y0GqD9jNl8j34noa412hhqH/DSs33hPNPpMd57Gmt598Ft0iRjc6RZNmuGccJ6WbPR69FJMxq3RuApixU0XfaqYzYGip1uj+H4PH/sz/xl4ixrSW2J4f/xX/4X5FVBvxuRr9ZEWvGlL77IpQtj7OKQ2f4f0u1k2OIhkRxhQs1STtjIVki1Io5ucPHSZa5dv8brf/gHfHDnPst1SYhi3r495fnrfYpyRmMTskyyGaXkVc43X/semYnJphOqtaUrF2xsxORnOQqJEp5i1Y6rq0bzYL0gqJrg+zg0lzY32O5rFqucjXGGLysuXNtmuZoyHmwSpynax9w/PiAzip5p8yeHx1PSTgek54mnngZb0y1yhNAI7yAEIhNhnaWyDhP3PoxH96P6MahXvreP6iasViWdtEPTBKRUnJ1OySaCq5cnnB7nrPOaxioEkMYxVVmRz9eUtSVODJkxlLYm6QS2b455/8GCYtVOiJSQKC/56o2n+V/4FxkNr8KgA8MOYm9NmK0RGz24MSD4CnlW4RdLeG+GmMRcfuYq5y7scHA6YzNTHFc1eaMovKdoamIZ040li1XJxs6AK9qwv7Zsj2L6UYJR8LFnztHvj/i1l+7z2v1dNrOUo719Vg9e5ytf+hKfffEr/NO/98v88j/8VQ4WjmduTEiVY/9oxoaQXN24yc/0Ps31i08x/PRV1Ns5q6Th/uoO/+jN3+S3775K7cRjDw7UFhZ5ReMCy7Xj2uWEJMuo7Lr1s8l2fcoRoWNDjaIsG5rHb+KOSpASsjQhLysCAucEq6Ki3p/y8usfsHHuOk889TSf+cmf48rVG/yVv/rXeHl2v730tZY4SYhSyfZFzdmhRSzav+4bQYglUoINgUESM2ugqFu/W9Mo0I7376zJMs9i+aG86j+qH4OqG8fte3tEcYSOPDppqXkyThEqQpsYrVqfmBcBG9o8ja8CLrRoe+8d3jlcY4mNoShKmkhj4xijdYvpbyzC19iqonG2ResDIUgaK2iaBGkVrqxR2hOEJ4R23bLyHus8VR3a/JK3JHFEHCcEqTA6QirT4tYFWBHQSmEen/4jrUilwEmw9/bwD7+PX32AGLRgHilkmyfy0HhHXtYUVUUWaZ7uOj4/iXjxhYtcm4wJO1eZnq6YTi1vP3y7XVWu1jS5oFzXPP2JX+BwT3Nr8xtcSAXL0wIhNfPjgq1z3Zb05wP5aoVQCh1EuxiqfAsEQiBlwR/5tKb4QcHrdcQp6nFMA7wXeCOhk7CRNHSyPvffOqJUlmK1gN1HnH/iFrnPqQ4eoRLF/vvvkKU5GxsN2z//BfztMS+/XHFf5SgTUVRtBri2gdoLIELEiihOiWQgeixWtl5QNTWOgAuSOG43K6wXKFoASO0anA8E7wi+xDUlwbZyaicdQQSUo/1dFWC0RuEAj5DthD9JE3SUQJS1gJLG4YzCugoZHi/BO4UT0WNKpyGvY/KVABnQ2hCphEi3WWblSoK1FN6Cr7GlRQXfEntlYHMwZLVe0gSF94ogE4LXBOeZrRa0tl2PCA7rLEqBUK2MmrIk0jEiSJRQoAONs6g0Jos0SRITm4TKt5692Huk+9H3Gj+UX+ynrt1AG8kHj44RBK5fHnNpc4OTxYIrl3ZY5GeUqwqXOLRIuHLuFrv7u+yenLGz1eH61gaLMvDweMVg2OPR7WNmy5w01Wx1M7aGm9jCobVgUVbsnZySpF0EDjc9RmUR1itmszOS7QwtM4z2RElKJ+1xsigYyQHaQ4Pi7sOc46M9JpMOnY7gaLbEWwXKEsmKJGqDfvnco5oKISTeS3wDzdKDWnLv5AghFaW/TxJnOKfRkebg9BTnHEUt6HcqdudrTs5mLFc567JhK7Js9DrEsqYoK3QQJNqzrkpS2eHqdsSyksxrGAx7nBsJfDjC15LCFUwX7c5uWcGwGzHKNPeP94hUG4IMpWJZ15xPh6yKkiTK6CRQVWvO9VK8FNTrmqKEompdJo9qR55XpEFyJjXenbKYl3gt2R4PqauGVNYkWcw0L+llPWxZsFx6zk0M6TDmaL4g62jSbkTXdinrkhA1HE1nXDzXo98bczSd897+AeMsYXO8xXK1IO3E/Nv//v+N0Wir3StuGv6bv/E3uH9/lyTNmM/mnDu3zU998XMk4oh8+i7dAXQ7fbyLMWHESeGZjCSDeExXLCCJ2b/3TbLRJdToGp/6wouMRn1eeeU1jtcFcTrkvQeO558a0Eklg86AYj6lyCv6WYezlWVaHFPVDuklcVKxPTZM+hskKiFNM3woYD7nUhrRHWyRmD6ni33wZ6zWJXE6ZjafsjnZYGM0ZtAbsSqWlEVD3VREqWEw6DFfrImiDhcuZDS+RnnJuqiJDGgVYb1nscwp6wqtJd43xDoiSn70gOlH9eNZC3LKe444MjS2waiAC45VXrF5JWN63PCZ58fE3Qm/+/VDTlZFG6JPIgrnGWz2CNaRhYg4UcR4SgtJrKnWDQb49MZ5fvGP/CleePonSfYqQhyDc62KbGsErz+A6QJuPIF85hzuP/uH8AjEnV347C0EiuujIW/GkrSbcHMUceZXTMuK0sLe0nFjI6FsPNvjEZtbY149epPLkw7KCXrdlLNC8be//X0enOb4oIiMoLGW919/jSgbMLp0k3/vL/5HfOYLX+Bv/3/+X3zwxh1+4uJNfu5Tv8hG8wRJ6CJmDZQGfrBEVpooSZiE53j2E8+RuP+af3r/JUrRZj6mszXW1URGIaWgqGqevbnJnQdz3nmrvdHPG48r2/tUI9y/QM5hlMQ2NfVjh48L7fqWEAKvFE2w3Huwz2/8+q9zfLDH9VtPc+XKC/zl/+g/5n/9l/4TKrsCH1BAlsTcfbdg0BG88LEOFY43X89xQT7GOIAEbt8+QWpJvy+Rj2llZ7MCkwjWq48yZx9VW/H2ECklSmqUlsRxShylZGmXQgh0lOGFQAjZpraaFivurQXfItOdL6ltoFESbEknDjjhcL6hrBxSyfYwHBxNaA/0QrQ5Mh5jyeenCySSNDFo04IkkiAJeFSASgSUAevtY0+Go/AVMihCaBBe451BSIWUkhB74kiRCEGWaLSQVIs18/v3qRZv88JnbnJyuEexqLCNxVmPs56ialgVJTJ4LmQRTww9iRLMjhcsUkvxzh7vfnDCW+8esmwsk3GCbkp0Zshiz92//v9k58IG158zIAPT05wkUqheyrII9KShDuDyBmsLiqJCqoTYGHq9GNvkdPsDXnimy+ZmwT/69pTvHDqOhWAUafqm5v4Dy+demNAZKGJt2bk65N7dKVFnSOFL7h88IOlkJP0+q8M5lV9zcbPHrT/5efTONp/oG+7cPeXX1j0eJR2iECgtVFVJVXu8pBVPC4lTgqBbwXhjAxaL9R4v2olQhCRBtF5HKagcBKERImBtiXU1oilRIbTsBjyJ1HilEEojARMprGtaVYsPxFGC0TFKG5QxhMYxr3KUE0ShnaxKoYhNjKIlRBY2YEND7RzBa2wQrINDC48ONcI22KqgqEpEqIkkGNt6yPbKJcFZbBBoExGCR6iEBkXh28xcpg1JFLVZS2WIkAQRGIwypAPh25ydEII0UhQepDA0tUS4QNE4MOCU4F/ltPahNGdnc89W3KfThYubfT556yYP9h7w8evXKeuGu/fmBJ9w89olHj46INUxOxs7cCxQTvPB/T2yOGOcRQghmHS6HOcVdW2YDDdwztDvdOl2uxyqOfMiRxvJ2WmOEStsLhj3EyYbQyJleHDwkF53zOVOn6pYE0tFHQRCQgw8f+MyDw4egW+wlcDVGtSayLfyU2E6dJOUWFYsbSC2koPTFZcujOjElunREdP5mivndlBa0/iE+3cPOD/ZYmdymdn8kJPjU04PFiSpxAZD4S1VYTk4mvO55/p00ox3zk4pixolJaOsw7VLW+wfr5nlM2bzkl60IlQleQ33z2rmecAVCikbBr3Axy71WOSWe6uaYANBCs5vavImIutFdM0AObxC6k9IFpK7+X2OTqf04i5NAc5ZahFYzj1XtrpoX6KijEXuKdc157dSprMjIpXgAlS+oLQw219RG4WJwTYltajYmaQYaahzTx2mdPop48GAk6kgaMV0fogxgieuXqQuK4xxeAlf+2P/IRs7l1CyXRv99d/4LX7zN3+XwWhIU9Y8++wzfO6zT1HP96lmr7F5/iZf+KmvsTWY8PVv/5Dl6hzh4BGz1T6j2PHGw0MGfUNS5awO3kck2xA0F248w2pdUL31HpWUlJXjZJ5xdSTpKMnKZzw8OkXGgX4nIg3gCstgOCCOh4z6EbbOEdrTyRI6aUYcGU7Wc9ZVQ1Ot2qmFs/Q6QxZ5zWZnzP5ew8HpMZdHHbz3bRMdx6QoHjw6oEBjmxWbnZgkTQkqcHx6TD9LGI03KOqGNHVsbp3DVQW1c7g60PwrSA0/qh/PEs5z/uqEwz98yHiwyc6O5HBvxaP9kuO9Of2BYTIac/OZK/zgD36X+cLSVA1JpsjQrFaWXpaQNIGgDfvTJdWqpi4antA9/vLVn+G5nU+Q7HXQ+7uETgxji9AC0U8ImcIOJfKNO8i3dqB2hF6K++Z30ddu4F96j+jcJa6IbT67PeDhbMmVnfNUQvLygympDKzWJVeePs/RqqDb7ZIqzXYnJjKGbidBaskHB/fpZjlyrpG24ur5CZFSLOdz3n3pu5w72OP8s5/g1hO3+L/83//f1N+6T/pSidwt2swMJULG4AUUQKqQsn0FRk8O+Qsv/p955f/0H3CnLJChXeuMVIQWnvEkIpiaH7x5zOEuCBFa6SqqhQ4oRQi0knitUVKQGokXgqJx1E1DQLTQrLLAIkiM4sGjI/YOvs7N997nqSeu8uQzH+OP/8LP8rf+f79CENDveZ56MmI2t5zOBNuXBty9d0zdgDbQ70sSaSjWJUFDHCmyOKEuG6TwiAD/7J8vqK361/od/aj+p1M67raTcG1Q2qAfT6R6vT5RkAgdUQVARDjXrsU6Z/FBUYcG8DReIohaXLKO0FK0W1Fe4HxoNzxCaFd0a4fzDrxvD7VCUFsPWqCweAurOqC0YSUk6jF0BN1Cr1TwaDxBCbxUxEqjhSAyBpAIZVDKoKMWBhapCBMJlHc001Nmu3+AlisevPsBSiuCs60fDUHhHEVZ4awj0XCh4xlGEiks7775Ptc/8yL5keP2w7dphOXFr1zBnpUU8w50IaUmDEo6fkHwcHYQyNKADJbxVsrp0YqiWNAbbnP/rV1S2TrcgrVIJTCpJukO8c5RFiWXd7r8+V+IuPKtI97PBXZW8uSTA4yuWB0fwmSHk/0ly7OCqhSU1Qzdi6EpmS1rZL2mrJaMO11EDWpjAkGTmTl/4tMl7vvv8StnlziTCY1sG+JIQE2rIWl8S10sQ4Cm3QKwVdkqTaTGRQb5uHGLtEERCJqWoushkhmxjxAqwguPdO2FlFaSIBVKxQihQbb5XK0CvrIoE2GlaP9Mb/GyIJFghUTJmMa3k9EEgdGmXUE3Go+iDILcWRof/qU8XQeJdxIbWsVCCKIlUAZPkIraW7IkagElCDw1wnqctbimblfGdYz1MSrKKBqFlxIErPO6hYgIRVACYQyNdwQnqRtPIh3WepCiBa1YWr/mj/qcfhgP+6UtxfZGxJWtiwyHKfNihokj3rrzgGAdT1+7jPNQ1GsubA/RwnJpZxtPhfKSabHgeHaGr0pGwy4vfPw69/amFEXFolzgrePWjatUVYUXNQ2W02mJ95b+ICNIxWBoGE92GA+3kdMpUgheff8Om8MBysSUVtDPBixXaya9iCy+yIPjPfaPp+AatocROlIYqambnKrW5I3AKMHx2RwbLL6pmClPmdd8/PJ5Hk3nqFiQlyBl4HC64Gy55PD4mDgbId2KZaPY6ghOZwWbw4xeJyLKLEeLQN90kCEi6aRI5bm3P+W9+zOMiLk86BMDq1whhcGVOee6mqtP9tk9KbgwylCqpFGeixcyrp6/xunJDK0dn7Q9vnjao/zEZzn8+Kc5+cbvcf/dd3E3f5IrL3R4+4NHcPImXub0o5hODE5LeoMhXd0wymBVxUyPVkhpieISIxOMzMhkjBm0q062LImiFU1jGKQpwy6crWG1bjg7mnJha8Dm0DBbliip6USebi+mOxxS5WueeOpLfOKzX0YqjQ+O27dv81/8l/8V3W6HPC+5dH6Hn/zMLcT8eyzXms//1B/n0sYltgYjIhNx5cIGcXSNV80Odw+OmOdvMRpcolrdI8gIGW2wePB92L6K6lxmcvU6G0fHPDo8hRBzeBIjbu1wsloQRT3OXTrPoCvwdUW+OuD69nmsbIiE4GwxQ2hFpDVVqNm9d0q31yMVHWT0L8hACctiTaocG8Md+mlMXj4gihVNUxDHKQRPnc8g6dDvjwjLJZiIIBWCgBSKXrdPpBRF4VBJj3M7Q06m+5yczEjSFGcdWn102Pqo2nJ5wrScY7SmKNcc7nuipA3fj7oxRJaz2YK9vUOSLCGIJcoYytLjnETKQPAWoQ2zeckqd1gcX0s2+d+e/yN0F11Y7FFbh486mGevIeIebqzhbIVcCMLBnOr+K5hfPkTfeg51cwurJEEZyqMHmDTGrGouZClPXtii8pqLnz3HC0+uePP9B0xXJUkkeeHyRkvVMoatcZfZqmCw3WN/UdLYGWWVERvPTj/hqcvbJFqSaokvck7u38GvcyZXb9A/d5nui9fwe7cRJzUIhfSaIGS7FqMFITYILVskfRBsDXb4X/7cn+U//ef/HVpKlJQoHEpIpkvLSBrefr1iduaQulVZJJEmUe2STlcJkkhhG0vHGJRRHC0LausxkaGqG5Q0NI1toQZNw+m6oNtJeO/dDzje3+PR/Xv0B102xx2mS4c2kms3U771UsO8tpyujqido24CkRHEJuP6c54P7pesjxW+CCxXVXt4loYQLEUOg8G/Ai7so/qxrG63h/QB51pEuLAerxyLvEDHCSY4UpVikRgR44GgI6woCcERgsSYCCUhhHbKJYRASEnj2vgFFrxt351KQu09Lng87bMWx7p1RykFSuEJ+LrCtcZjrHU0vvWsxUmETvtESUJsYlKjiJQmMhFCCiygZIwM7RqjkwIrPdlyzqPXfkAmjnGhQclWvBwcNM7hgqCxnqqp8b5mohJ+5icu0a8Ldt/YpXae3/3t13nrtTOcaLhxMWa9e8zh/ZLbD9c8ccNwfqgZb3dYnMzYiMc0RUmnH5FEBoyhd/McOjL44NBZRL4s6WQRXmp6mwNiGTCdDsrV1Bb62+foS8ef3N4geeImv/3Xvs0Ht6dsbxrUxHO0d8T8oCFWkqJqqCtLdecBZQjoTkJnMiaVjjt779P57CWqw5z0yhjSJVlnwZ/4dAYvPeBXTybsqhSrYoKSGBVhFNRBYtstTKqmRnpLKgLgCEiUeCxilpLa0a67SomQAqkjlJBoAsHX7cTTOowMxDpCSomHtqkXgiAFzz61yUsv3cfjsEKRNznGWYSv0AKMNAgc0kR4J2lUO2hpvECJgMKig4TGIXyDtzXeB7xvbZpSSSIZIYUC+diwKdstszg2WO9wokXt69AK2rV0yND+N2sstljgVDv9VEJSN47YpHjdyvmEEtjHYmpra0rXIJXCA1bKFoAS/jV5zpKoot9LENrh3AxBTFE5Fss1aSfgTMXhoyOcszxx7QKLfJ84qlmuDumnfbY6XRarI8qq4dH+EXm9R9nE5FWJzCKSfsyj/RMWZwtm6ykGyU5f8Pyzz1A1FVrU1EXFbHbKuq4QssNiPcMkmv35CTokjEYjjtYlqcpYNzl1vmLYiQmqh9EBXIMMGq0DpWu9OQbPsL+Bln3qqkLrhq3JkIUZMM0tdeE4Oq4QcsXpqmLcE/SyDsNrW9zbXTDpddg/W3E8c8RNYLwtubAdc7A75WixwtcWk8SYLLBaBDZ6m/STNVtj0zoYQsNsUZMlmn4/ZtwRzKuaXj9Fpwlpb8jmwCF1iooUF3o7cGfKv1df5MGnXoAvf4Hyv/sb/PY//03e2BzxdOZQH/sF0qbDSz98g5/++AZXN1NOmwUmiohkzKqM8b5CxxGXRuehrNvbBS2x0hDQGNOlXC+YuTOqvEKHiru7x1S1ZdDVnJzOmIzHdLMIpyxlEDS2wcoMZRX70zNCiPilr/55pI4QIVAWNf/VX/mvWS1zpBIM+12+9OIL5NO3SYJgcxRz6+oTNBUIaYhjzeWdIe/cfsC6OCWJMmbzc/j6fWgCaSpxuoepVigg1DWCiOu3nmG9+gP2pjnHjeWH78Q8c95jVIx1U/rpeZa2IYSEZX7G5UtXybIxdfUOOs1Iky6Nt2xe2GIxLwhCElzDoDfAC8PIROgoxTnPfF2xvX0JbEGW9RBGUxUl2qTIKGK5KklTSeM9G4OU47MpWRyjlKMymkm/z2x+wGIaiNMe2xcm9BKBs468KD6MR/ej+jGo/f0VCI9UGUII5osKE1kaC3EqCSrm/TunJIOExVlNEkU0jcQYCU1KZAx1WTJ1NafrGh88P5uM+Y+HP0WycgixQpkMAWDX2NffQu+NEH/m84SqIvzOezSLIwrbEE/vkh4NEc9ewtx6Dn9yjDcZR3/4a3gC8ahhMWpw3pHZjMlwyGefMZwdn9LpZWTDAbZuUFJxbtzlH7+zh05Sfv+tB2x0G7QxpLLBIFku1ox3EhIFER7tLfnhHn6+oN7fZXTtFvGXt+C9CtHINrcRtRmB0E9AO6gDIRWId/ZxRcNPffpr/NH7b/Jrd19BIvAIrIegPJvbKQe7LTFNEUjxZJEiiRSRgq4WRFIQkphuGnGyrog0pEkECCZZijaKdWkY99sMMFpS1Q04R1k1lFXNYDhiMhpwvJiyWln+8I0pD+7UJEpTThuEty1NUkqsq9m5mvHuvTWRkJgO7aFj0aKsBZ7EiPbU8VF9VIA1CcpJHA7rG0LjKGgQXnBpe4t8USFthfdt46WkJAjRZpEihTRxS5UW8vGammy9iULinaVpGkIw1E2BjiUGTe4cjRd4Z9ssW2jl0iZSgELLxxz9EFC+YV1VnOUlUmp0ZCBqD7k2GCorCV5RI0G3fxauhUG44GlsBXXO6Q9+QL3/GrWf0U80KhLI9gyNBJrG0jhLpA1aCja7ik/9xJO89uvf4+2HK+42DZPjMxLV8LknB6RNSdTkfPIrm3yh6UCxZrlwaAo2Jik6FgQfs3H5ArZYo6KY5emKdDBCRAkXLs+YTXOyLMPaNf1Oh97mJs43SOmYdDNkkqJ3dhiPtgiN5av/zhlP/vA9Xv/BEYmSpFnEXBYEFbf5JxrKxhMQZMHz5T/9i6jplLd+9R9iQiCc3iH0FHR2UJ0VA7HmT3zBs/iNPX4z36LQoHRGHEuCiiiso5KQCkGI2wsoGaD2oZ3+hHYQoZzFIHDB4ypLQ8CHEutb+mWQjsY7ImdJtURFQKB16NEgdIT0gZdeedjCQLwjEg58gxAO58q2sRKaLE5wcY9VI1iVlqIocd4ipKBnYrytEaFB2RrhK6gdwrcAEaklsTJoNEGDF22GUesYrWMSY2isbXP9TU3lPVVpkd4jQsA1lqaqqVwgOPsYaqIIUYzUKSZKCVohH4vRm6rAugovANFSKqVsm98ftT4cz1l/g7qsGQx6zIoVTlqCK+n1BFHisdUpjfb0sw7HJ0dkqUO7BkN7s7i3f8hstcLXjq2tPv04Yrk4Iwmasimp84o7h3foZgkqwHDcxVYFuw/eYWs85nRV8MGdhyBT8tpy7cII6yDNupR1Qy/Oma8dhW2wqkOnk5ImMVE85PiDGcWyps5rkkgz7GZsDM5xdrogjhVaRIy6hlwagvAcHXiKxnM4XUDjSOKUEBt2TMmkn+Kc4HS1JEojBl2Y5ZqiUGxupgx7KXmxwiQCtQgkOkJlUXsLFEuEqLlwaUKwBYaCbtRFJgETZQgdiIKgKGomY0Wc1Kxr8JFuP8TCsBl1+VIecW845OTTz1P+rb/Jb//aP2f63NNc7m6gu7D39d/m4b2HiLrk0XzMzVtPcCUVWCeo6xUizJjOG9JOitANDM/R2/wck37D5ZvPc/7CRd559x5333yX7tkjZCI4fvAaHXLWRUVXG8zQk8Y1q/kZcbpBEtYEL0lNgFAzzDTPfvrfYufi5ZZI5Bxf/93f4Zvf/jbdbtsIf/Wnv8Due9/ByJrtcze4fukiQsYIWdBUayppcE6wmC+4uZGyEpv8cPaIxJbUSY90commqYmHW6wWS5QqMZOb6PEmVy9dZll8wNm6ZvdkwUbPUDZrJqMJ+7Ocne1zZJHjLIfDkzVCrUAFulE7GWuaglUjSVVK1uvgioLFomAwjEhi1a4cygQTaerGEscpB6dT4kgTGYPzglhJ+r3scU7IM9m+2P7wNAtG2Ygk6yFUws0bz2JrS0lgYzTkZLYmljVmtfwwHt2P6segXGiRx1KAiTV57ghNg/MwPzM4YdnbrQjMWM5zBoM+80WJ0BpUhBDtqrRwgXjleTrq8ZfiT5GGrL1pRoIB4SyNctQbAREviX75kPT8k5SyYLV3j6JpqOsl6vQIc/cAd6HH8vvfpFqf4oRDqYiB69NohY4ilIzwQCfL6F9LkbLF19emRAKbgwFXximJcPziZwfsbCu+9abg5vaEQWbAW1INRnq0dAgbCA7qsmGxWON3T0hHm3RkSpRdJagacXyCnK8InQTKihAlsFoStjYQvQzzxAX+7Jf+LLsH9/n27IyVtUx6EUJqPni/JtEQnKefKi6nYHRLsu0aQxZLtGpx4sYYkkgxcoG6ad1ywgiWhafbD2it6QxgXVgWpaPxAelrpmeWs8WayIh2kh555qcVtvE4H9jeSZjPA92sPZStVpbvfOuMrS1wa5hMDFlXcPJKIASBQre3+Paj5uyjaiuxNSIIKtfi7oNrAR/COg7vP8TIhEgr4jhFSIGSoZU4NzUmtNtE3lmaEKgriw+BsmkQQiADKDyJblfUEqMIzhMh0b71oJXWtYIzGdqJC4+x+kHgkAQRYWljKEK3mSAvNEEqyrqk8CCCQGqNePz7JIRq+WYiYIRDFjX19D2CP8DIgNCGWCU0TY2zgQZBnleEYNEykBi4OsroxSm33zngroUzF9M0gRsiwHrNp7804doLNxAhwc/XeCXxqyXr+Yxy2aLeJxsb6DhBqIjgBI6SelGhBwkCyfVPPkuxmCHqLjJOkVjSXobJMsR4jEwTSBKIO4i4YOOFjzN57ibXPv0er/2THzDfzekPYvaOLfPc4yrB1kTj6kDYnfOdv/K3+NzPf5bR5R12bu4Q37jWSqDLQEj7UJcMwppf/ISieTvn+2KCSzO8SVg2gnXjCc7hhUCK0N7pBLAenPcEHFoEnG9teM43BCCgW7WCD/jQqqvAE6QgKEXhA9Z7ghX40KBpiCNJoF1Jrb1FEgheUQRL8IpIGqyMCaaLDS1wSbMmU4LCWaqy5nS9JiAQAoRvcLZCh4AKAikVwYMTjkgoXN3qGowUbeYwBFTtqBqP8xZX55SrJU1RIpzFNQ0heHAW5zxCtm4+I9pLPhmnSJMgpCaOdLsVZRviLG3XQZ1HKEUUxQTxr2mtce/4hO3xEC+W+NAh0SnntjPWZcFyPePw5IziLGdqFMNul36ToQJcv3iOdx6cUTaKxapiqw/52tEdBnpuRqlj1isDDfSSDkIJItMwz+fYvMTWfZxbYNKUy1euI4RFSYUrLQezU/aPp1hnKeuKC8M+Kk7Z2QycrA6ZVwVx3OF8f4vTxZz91Yrp0Yz5bE6andJ4SzhzjNYV/d6AvLDESWBdrCA4Lm0M8LZkVXh2hgPyYk6VJwzGGd0ooqoUq7JmlKU8cV5RViuSrIMLEat5TmeUcrGXINM+89WCIjjGWcaynBMrTUWPwXCDfNWgZYcs9Uw6EZGs0WmHVAcq62hsSeo7/N4rOevTY/7ZfM4vhjfpDFK+8eu/yT91DS8Yw2QQoZBYOYPY82/97M8z6I84Wxyh17t4aqyQXBqOkPEmUqfU9oyv/ewvMehdJK8ktw9O2T3Z4+/+rf+Bv/jnfon9+4by7gf8uS//Er/8vX9E3JmjkHQHlwmhIY01XgjGvU1KX2AdGBs4q5a88Ll/AyVa50lRLPlv/9v/L8PRNnW55hMvfJxIrPDOMugmxJyxXm1wePAeWbaB9CukSDk82qMsKs5f3uLgMPDgwS5JMBxVM7abbRbLBZPJBebH9+gON3lmQ+GV4NLNm9x9eJ9VJShKeHNvRhZ3KbTlvDFU3tAZ7lAsdhlsXyMu7pIHxaJa451nXRli097CaATdQZfnf+LzvPHqa6zKNRc3R2BS0tjwzp2HaJ3QaZfNEdrQwogahNSMxhPmyzPu731AN0mZlzFRZ5ONyYgojhFK0OkNmD64T50mbI2HWNsQ/Eco/Y+qLSk1tnE0ZUEUxYDi7KTAxJK9vRVJ6rl5q8Pt949JM4G1JZ1uRlU7hJT44OhkEYKcJO3xp88uMDYTZBwjnQRX4ZSl+vSA6OefYHD5PCIb0Ryekf/nv0qkhzSJwNcJ3mvyxS7q+9+gKZZU9ZIgPSrKCKHB6gYjJc2/oLP5dr1FmQijFSaSGJ3ggqeTplyY9HBS8uQlz149ZFGu2ZqM0Roi4drVFtGCByCghUL6gFrm8MihZYIUfXjwPhSr9pShEqR17TpOk7cQj8UKcbrEn5Zs32/4z37uP+H76Wv8vW/9dWZNxWwqaFwg7Sk2xobJIuXZbY0VEq0VadSuMiklkcEhhCDTgb15geyklM5TWsG8KRCdhHVZ0e+k5FVDpBR1aPMQtbMIJ1BBEkJgMQ2cHnkiI7h6YYxb1YxHlrQvqE4VTeMIS48RksYqHj1yreBXKIKw6EjhK9Wu3XxUHxVwddzHOceqblg3rZRBaAVCERuDEJKdS9scHs4pqxpBoCqaVjwMj7NljiDaVfzgW2dV49tpSSBgtCLIgPShfd4RBASN91TWt6h1bwHfTssEQDuhCy60sCE8wnuMEhhpcFUN1ra0QBQah3wsERayBYO0/jRJ2kC9mrbuKt/ghaIqS5z1WCGYlQ2layckn/nCZ/j0k7eovverfPcb7/D+qWdqPSWOy7Hkqy8O+MrXrtO/+ixV6ML0hLKaM376KYKQ6LuP6CzPOLz/kDjLiJKE5sIVFm++R2hADTRNWRNFHYrZgiiJcT4Q6ZYaqSfb1NMjosoiNhNEp09IIkR3QlAaaRLG29f51GSH3/1vfoPFYs7GpmK1FCxqT1EJRpnBDxu8OOHem7/DU5/9JJsXd5BeQdonTB+Bt/hVA4Mx55/I+crJlLePLvOoiZg3ikVl8fkaVTVUwiNE2zy3s9H29wgcMo0py7JFEYnW5yUF+Mefo0IQeY/wDUorqCxeqsd084D1Dd4YQmVoQoP3Huc8oXGtNFoEtBbgNThobENkBFEUSLsZvgr0IqitpGoaStu0YuqmpqlrnPfI4JHWICKNtY5aalywBN+08BgUsqxBGpwH59psnS1abL5oKoRvCL4C9/jfEYeiBS3JJKETS+bHpyiVkEcRUkd4Zai8xbqA9xZUoHICL3500dmH0pxlnYS93Udsb26xtzyk16m4uDNke9wn6zhO64K5LRl2O+AEwVjy/IxX35uSpV26SYCRpN+RRLIh6Jiti9uI4DhdFCggyTI2NyYsVzWOJaY/opuMqBzsHx6jZaCuPFqUjIYjds5dZe/V19CRoq4Fs9Uc7RzuwCKVQihBnBmWqwVl6UBqNrcmnB4fMZCCotRMBjEyFBRlRRCKohQUVcl6VbE1aaWDk06HIj9BhIx+LIjwLOqI05NTvIwQxhPo0eunCNE2VJHucH7U43Axpy6meBz9tEvSEVw7/xTbn/kPOCoUv/X3/w770xU/+eWvce3GLZrFPqP6PuXRH7KcH0Ct8X7C11/PmZ/OOZ3PeFSVvLuY8+zf+Tt83+WoNOON11/n4sVNPvP0iLw64JNXUm6/8W3OX7zBl3/q36A/3uDbv/+rrKfvspcfszc/4as//++DHyCiHtkgpTiY8+mPXeb99x7xS3/mTyOiHp/d22P70jaH6ZDhcMKttMs785JHR/cY9RKOTx3dJCZPCy4OR6ymC4qguHTri0y2L7RCQu/55u9/izu37xJnCQTBc09fYvXw98n6I8bXn2Qsc/7gBz/kwf6KZ2+VjJKa+8s579w5otvvcWe/4P7dd5gu1hzOzhgPtwDDqL/FwYPbDLcvYIxid+8+Fy9eYry1xXgwZLE+pcLifUZdzZlkGZIF+aJmXlskNWG5SxVlbF66yfT4gFu3blF5Qz+yHB0fUuRrGus4fPiIICydTpdZXlI2azqdDpPJBt6XCOlIlCR4S2FL0iSlymveeTjj4rnz3LiwxWlu+fz1p9g/eIBzNeW6wdMwkopev8fh0QGDfkMUS9rFjI/qo4Jut8N6saIOgbKsMUrxzHNdzmae9bLm5pMD3n1nCQJM4slXNUJqsrQDwuKbQF6WNF6zMYNPyyvtbWmoiSKN7/dofm6H+NMXiLM+0rQ466SvWH4yQ/zOEZOnPsni3Xco5wes8ykZAi8UUra5Li9ah6PdaNBxp32JrRY0zpJlFZHZwdLB1ZagPPk68OjkjHlRMBkNyF3glTfO6EUJcRIjpEB4i8cS3GMvUlCIeU72gWfDXSHJLhKOTwnlu1ghkTpGmi5BScJ2F7GsEGW7HhOCw5/OEXeOCM8MyZTmc0/+Iq++/885i+e83KzY3hqwXJY8fFSx3ZdsdRO88khliI0hMu0kEK9w3pMaxSAWBCWRTcA6135WdQNCc7quqawlMYJgLUorrA8I4RG0SPDgHCYVdDPFvUcLnEkRC0XaFcxPHdZKGguTbf0vJyAEAW1iiLzKWSxXbIw/Um98VG0t1zlaa4SQIFtgl5IKIw0hKKww3Ht0Sgjt97qXRuyuTqlDwNoGH6DxAedqhPDgHbZpSY5Kthu0oQFCe1BXQrReT+Gxvm3Ygi0J3j5eFQvUIhC0bqfnovWkNcIhhMR4T+QDUayRiUH60KosTLsyFqQmSIEUAoVEzlacfPO3cPVDhLcIAZGUBN9gXaCqaqQVGMA2jvXJisPunPVJxW+98YfslTVGCK4M4GufSvn00+do5hJ3BuX6mEhq4ic/RhABnxcIpTAXLjERCukc9AaEwxP8Yk3W71LNF49jCIbpnXtcvL5N98JFXFHgi5LISfSl8+jx+PHULIO6hiYACr+aQlHRv3mNz37tWe7/4auYfoRRaw73arR2HJ7mmFhy8+aIjfMTZCiQ5yNoKoJcIbIIygK50SUcLSAqeXKj5HOzY/7+QuOEJvY1IlR44fDOY0NASU1sNJFSyACNrRHrAlU3eAnBaBSeSHqEMWgtMdK0TYw3IAVSQAgBE1rDdmMDVd1QOEvTWJxtpc1SCKSRKKXxBKrgMc5RVzkijsEnLZAEgYwilJL00ozMNzjrWvJkU4JrzXhCG6SAOLT//LwoCEgawFqoa4cUnmBbf6d1NUJYpAIpJMEK8BKUQnqIpEHKwGhjwul0RrGcoWxDsA2+VjQ6IUQ9aifRWdLqHiTtBaj40c9rH0pzdnKwx2Rzm1oPUEyJRcPibEnfGGanFXYmiLQk8g2uqjgtPIe1wjclQewzGExQ1REu6pH0QBtDrzfh9GxJowSn04qwKHj34X1GHXju6gWmiwV39g+ABq0CWloW64q6WnNWNDRMybIMHzw7kwwtAxvjGBcM2xs7vHXvIf7ojEEn4ws/+WX+/j/5Heb1giTrclSUDDpDysqhdGA9r5n0IlbrmtgkZD1FIg1CKSaTAdOjmsp69pYrZFHRy2IGox4uCHTUYJSmrD0biaCqa+JOTJXPGIrAtG6Isy6TLKKXddHRk1z54Xfp/9QvIn7pf8WqtpROcHR8QL50vJcPuXzul1gUb3P48GXef/CI+WzOYrGgaiqaqkYYweJmn585N6GbRkyXa0YjS9adsakMRnqeu7qN8FNe+v7fxEQ7fPGnfomH+8/x7e/8KlG8w2/+7ts8vP8unSxmtVjx5I1rPP/ZL6JUxJd++svUq4q3rz7BvWc/Tx4Ml758hVe//leZnd0hU62QNQ41aa9Pv9NhXq9Jx1soX3Dz+S+SO0UUArau+OX/8e9jvadZrHjxxS9gF3epbExfzomLQw7Wnks7l6hVn1cf1rxw6waPyjNykzHuKYi63Lv9kGUOW5sX+cQzH2M47HN4NuNy+gxlMSeOIjppTJwkmMhw6eI57u0fIYLkys55vvbTz+PzJYvZKVon1KVFRhN6nT5J1iWNJcMk5v7uPTqdHeJRh+HoPJ2BJesMQDT0x2OOTudEStALnihuf5xSPWL3eMZsndPvDtje2EIQEbqOj338PHePFvQGCVk/ILVC+IizlWV9ts/lKzdQcZeDRwdsdLuUxZSyNlTlR7TGj6qtfJWTpjHSWuraoYVkvpCcnBXcvDKm15tQVzNEMNhS42zVykAJGClYNg0uCNYLz5/25zFRAlIglKeOwf/xc0TPnCdOe4i00xKvVse4com/kDJrXmNQDUC1hzB0t32xJ5rw+HsahKfZ9IRLHUyU4qVBqhqjHP2+4WB9zHuzmA0RsKtThGvYnRWcVJpp8hT33v5Dzvc7rGpQRqOlQniJ8BKcJeQF4v4Jw3c0XX2BIEsK917L/lBxGyxXGqRtb9hny3bdh5beBR5R5oS6IRx75P4c03iO7wj80x36I0PIIipXI+eC3TKnn/aRsUZKidYGbWKcCzjn2gtAEeh1Eg6XOUJrpusZWkQIwAuBs5ZYq/bwGhxKKIyAyOjH4ITQrpsvLcEKBhnc+WCNbwKFDehIoDUkIqZjNJMBnC1qxoOMR0frVsoqIU4NIvrRA+kf1Y9nnRYNQbp2uhoABEYKBDVS6naVSyqcLwm1ZT6bo21B5izOWQJQe4cNEmnaSxKHRyjf+qC0BG1QQqMQaK1aR6gMOFqoQrAGhEX8i6wYARtAa4V3gSbA2rcC5AhBrEAGh6Ul/SVKIVQgyVJEHNOJMrSSpBg++IN/BovvYkSOk75V9NgGgiRxjmsbkiiU7B+UHDSeO2+9RnRwj+npEac20M8Mz0wkL5xTdG3g6HDJxSAp9C5RNqCanRBOa9Lr1xHBo3pDnK0hyiiXCwZS4pZnJB1JVQeIDJ3IsJ4v6CeSxcE+tirpX7pOvDXEFTk66YKOoDeGokIYQ6jWiLLNz4lOD8yAjRc/g52fUE4X6EuaJj/k/Ts1qzJwbTMmzVKK2YLk2hA57ECngzApOE8wS5DQFIfo3hbZucBX57d5e254L95mvN3nwd4ZdSxIHhMGtY6IJXTjhOAEeYjI81bFUruGIARSBlCi1YZ4SR08dWOpG4sIPF6LBaUEERIfAkFKwIFt8LZCBE/jPapRNMKh4gxiT0PAGE1AEkJMYx0ieIyCOEpbTxoBW5dIGWGSHsJ5vG+bfRMsUbBY26BCIISARxJFHpxrf6uNwkqJCwKcBusgtJNd93i90VuPpBVcF8T0dy6yPjtDK4337aWDiUGnEGURUaeLMRHBe1wItN/CH60+lOYsUhLfWJxeU8xn5IuSbq/P3UcPcN7RjUL7Y9AsCI8fLu/WJJFCRl0StYbuEFvVNJEnU5JRZ0RtEw7OpiyWC5xdsdlX3JyMef32A4ZZQhI1TGdr4ihha7tDp5Nwf7+ibyxGK4oYunFMIxWLIrDVG7CqHXunMwZZytl8jsodd17/HpQ5ZZGTxQkiaKTLMcIQGcmwv8V8vaDbT/CqJhUZygS6caCoclYiQSeOa6MRlbes1zXjYZ+HJ6ecH8RU9YJRp0Nd18yWc4ZxxKBvmM4btoabRLHEN4Ks/3lc/xzfX6+5sfc2z5+/xg+ONdXJHfz+Lr//T/8eo62LHG9scfXmU8hzn+Zc0+V47+vkRU7TVAjg489c5uPPDdGyxHvBs9sJqIqiFDjvuDAcMF0tKaRGVoHl4av8+j9+RH/nU/zcV/8Mv/O9V7n/7usMRiOSZERR7XNn75hHv/GbzOZz/tbf/1U+/8Uv0uRrPnv1eZRSuMpy/TN/hmr3e0yt4INX/gF1brksAqmR1GVJXuzimjGXrj2HddBYeOuN93jzvTvEUYQDnr55kaFYIuucJN2hEV0mF7bpbN7gqBywu/uIf/I732d9ukuaJczra4z6Sy5evsLl64qtrU02tm/y8muv0EtizuqGWzeu0Ik057a3eXg6p7ERO+d26CbvMG8Uzgs2RmNsMsDIhEd7e8g45sr2hIOjKWkvxUQdZmdLdibn8A6s9ZzNZmSpobEKLQKjzU1OVp7NccSj/SO2Jxdoqoqt7RHz8iGbl4eIUJB1MkJQxEnCg0cPSGRMWQmiKKHIC9LMYL3HDIfMplPyMmdrkLJeFgjpafIS78oP49H9qH4MajhxRImmWMWsFuBwFJXE+0BZ5+SFptvpsXG14XDf4omw1j/OikCSpZQngQ0teMZsIyIgVYjhkPoXYlhRpAABAABJREFUztF76hI67SKzLsE22CInP92jmc+wkWA2LIkf3CVYiVKSEAxCtLPdoCIcjv3Is5vlXHbd9oWvJE1wRN2Yui5Z2Zh31U3eqASiuE9UnHIy96jzz/DEp77IvW/M+Pg2rB/ttbhlqREWpBbEjSB88z6T4xGGDt6XIC1KRgjR6lmCaCGNwggwol3ZcRAIBC0QsYKyhnceoIyH2RnCNTQzyW/86j2SvkT3EqKoJfEfrWvWjWSzo1GmpXYhJVq0JDohBEr1WRYFgyxmdbZi1I3ZO6sQCOqmvS02SrT+KAHWeaJIEivJWV4hkPQzzbIQLBclRnQxAvLH0zEh2mlBt6M5PawQLqHfSdFJFyXLVhaMx2hJFsf/ur+mH9X/ROrw8LidKmhFojVayjYHKiASAi8kToKSqt10wiMIZNKhdJtxRRlskC3dzgkaZdvpSGxQJqISqpVEC4WXBiUVQjyeaASBodXGRFpi4F8eYLXUxFpRN5Z5XVHWDUZqtI5b7YXz1I1j3Ti6cUbjBYmIQGmEV+y+/j6L93+HL/6Rz/HKd75NvpwTQo0Usj0el0uuyIyf/NhFdK/Dr/zaK5xUHhOWHAvH+Y7h5obiEze6mGpNHBlClHI6L3D77xDFhiRWbN+8BHmDdQ6ZRoQ4w0jVrsJpTTQYMN/dZeOZZ1genTK7v0c1X9F4z2gyIOn3MGlKsnEOX9eYjTF0uoRlSVABoghhIsLRMfZ4it7ahOEIffEZNr4qePD3/kdCXjIeR0zmDdP7ktfeKtg9uscXfmKCd572w7KEbg9RVQhvIbdE21uAwq0KtieeFw/v8dauxnV3yNclQgk8gcwoYi3QRoPUNEFQFzUISRMaeOyx886wciVgaKTDCdmKq51F+4ASARECSkqIIpqqpnaOxnq8a2EchkCsJXFq+MTHn+DlN+4QVIR6LKkOUtL4hki25EMp2ss5ozRaBlSU0miB9R7hPK5uBdQVEikibLAoY1AikAmNFgEVArXzWC+wSkGAgKBu2uZM+gbrGpy1VFWFCgItFSiBFR41GKFtha8rTPBoI+n2Enr9EXFvjIgzbGOpbYO1zY/8nH4ozdnGxnlyZbh974Rxt4fUGfcPzoiUZJgoqqJkYzhA4Cms4uHxjHE3ZTLu4Jol5eM3pw2SqgoMLnVZVhW3dx8hgqIziLm2tUFPLrm7v2I07hNFEh0kWbehsZplIxl3NE9dmXD/2LE9SrFeEJylCQmjccOyWJJXgpOzgkgoDBKCYjY95Na1HsfHOTubPZQyeLHCVgqrLFWzZmc4oCkKokhSWk9TepwyJKmgEwVmZUGSJXgtOZk2fFAckMWBYt4iZqUOSNXj6kgxsys+2F2TGU1tZsRpzFb3Js8991m+8e2X+Nmvvsijd99mo5fylY8/z6+f7jHoP8MLL3yBX/+tX6FB8N7b7/DZL/40YusSP/PVP8f7L3+d1+69wZNXx3z+kxfY6Em8NeikS1GuKMoaGRTjXoQxCuYVOz1YNZZ01AexYnb0Tb61/zb39yxbgy7jyYDDWckH77/BJz/xKZx1jKXnc5eHbL76XcKlCxy+8y1U5YgSKJZrHu7t8fbDQ4Y7P01/w3Hm5tjlmoMzGFx8hqc/9gIyGVA1gaIq+c43vkm+XEAI3HrmaRan9zhdTkn7OxyvLJ3MMM37vPFPf5fNC5eI41aWufHk8yxnp+BLHtw95NbHnuf584GjPKVuPBc2xww7mrwn2d7K6GcRL735JrIzIks79PpDItMG+fPS8uDBIyJtEV4T60ASJSTdAZejIUFDkO3/y/HmeWZnc2yd0+tPyKLAstYY3ZCvFhibI9WQ7ckWsRFEJmK1zNkYdNFGIMgoSoe1JWVtGfVGlMWK9XrJcr0CL5HBs1wvGQ0HlEWJEiB8iQgFVdV6PiKdfhiP7kf1Y1Ddbo8o8cxPHXEUUTZQNpZOP6VyDWdnS5yv2NzYxroZ+X2PQ7QyWCEoS4fREU/GPYZVhtzqEXpd8p/aYnDrAqbTQ3TG+HJJcbLL2YO7nN3/AOqapDdC5WDXOV5LpBLgFEgPeEIUeJs5f1N+wMebLhdFHxEZfJgRxQ6HZpbXzEeXGYQuWnaR57ZpMKzeeZm4v8F0XhHSmPnoBtnpaXsgMwIpDUYIdF4RzQ1StWvR6FbLLHSLeG5PnbINpwePDLZdV3kcWhcN+L4B5ZHTBSHUoBPEYIMXP/Uiv/1r77Kae1gs6fU19UqgjeDO0rE5lhRVTe1BCkvayUhM1n4w0qNtQxICOgR6WYfqcIn1gqr2ZKo9EAsjcbXENg39NCVWgjw2SFkRJRljLbH1nPWqIdbtIcIDQkCvm3LjQo+jWc6l7TGrYs3W9gUiJbj3aIZXGuscs/lHdNePqq0gAk1TQiOxQiBCC2kIdYO2HqEVjW4dWIRAcB7btPlFFUfoJCFOUrwFpXRLLxUSISRJUBiR4CRo3cISJKqlOwaB9eFxIwautq1mIgSEknSymDSKSKVh5kqyVOGqNbWTzH2bLZUhtBNzIXEWiBJKEeFUB1E5jr/5m7jmNs5do6GLc0fExgChdbZ5z/39OcuDIwaZJsMzDIG9dcnQKF78zISntxL23rlH5SR1p+FidpVVXrJaLzHrFcNexDnrKfd2ic5vQ1NiG086HtFkCaEoEd0hUiesFgs6OxeZP9xFJIbqtOJgd8717S3KVU49P4O8YPL8C7CYQ5pBU0HjIZ/DaIT2HjGb4+drGPdIuz1GH3uW6pvfZTTqc9XPMSPJOx80DAykCvrXtyBKQMdQrtsPPkoJp7v4uEtYr1CXNpD3jnk2vc+2uczLBytSkyKURGuBiQ1CRjgZ4YVECkcURaggieKYSGssDhckzeOV6ujxdCqRqgVJAcnj1cZWPp1gE0nVVKyKmsYJZFAYQCoJWvPW+wck2QBtNImO0VGKMBqjJDKA8wEv2omcsg0ieGRdobwjeswBsD4QbEPtLXUIiMerlWVwSKUxQiCDwApJ4R0gED7gbTvxk6GFfyAUeIf04D00NiA19Ec9PnNrwm9/51VCWdDvZgwHHfK6xlpLqCoIiuAD3rq2Mf0R60Npzg6PT7m0vcUiVqwWM2Sa0etu4JZH5HlNZCTT+Zw8L5ktCpTuEg/gYC7Y6PfZPcoZKMdkMkYLx71He3jT5eLWhMPdM3o6Z7a0zH1NiDyZdshQg5Gs1gXrsqCpVoxujFgVmtQ4VnlAGEM3jRhow3RVUOSC5aogFBVm2GeeF6SJJChFIgWXz/fxQTNbFWz2U6wKxKlmWsTkixmzZU4sA+PBmOWqZqvbocobFuuC5fyMBMGJdYw6gsbV9LIEVMB7R21rtrcn7J5ULGeBwaCHVB6pY8rlnFfu7yGiH/CxJ67zw5deZTDqc7/I+Vxf86UXn+f3f/0Vntj4BZrPw29+659xeHLIr/3KP+Rjn/gkM2344r/7v+cnHr0LxW/h6hWzpSSLFIMso7YRRZ7TNCXnNgfcO2kYxD2m6zW4hiQesBmlVN0Mj+flV+9yuB/R6e7hHfypT32cL8yWXFsLdqIU/f13aGzDW6+9z/+187tkOzv0Ns9TnEyxb7zOSwL+2J98Fj+5ye//zj9GEsiShHF+xJO3PKtlQRJFvPXy95HKsbm1w97uIyZbW5zMS0zokcYbRPEEW6/YnGxx7sJ5bNCs5wsOdh/hVMYzTz/NxkBzevpDHuwv2BpfYzzJUPkhm8NtbFWxMJ5BN6Wsazq6wEfbeEBFEb1OSrFsWKyWXDh/CSVqrFUMBz0qL9na3uaDu7t0ow5pokjMCOFzIgNx1KHT7ePqgrPlDCsNuqmIIsFqdkTQMY/2HpCaGKVjpBQU+ZJuv0uadsnXoLGsijXeCuI4oixzQpBUlWNnY4emcWSpxtuKwmqESahnJ9RKoqPkw3h0P6ofg1qcCIL4F8Fq0fphojZHdXYSOLed8MTPdHj71TlSJBBKBB5tFFoqfJ2jTcRmlKHiLj5WmJ+7yvDpC+i4i+wOadZLlvff4fTOu+SzE4IHrST17jG94xhUhBGWoCReamQiWA8Nf+/wHX7dPiRIx4UoptIZh3LMZPGAxAtO5IDq3CdYV+c49+CY+UVDfHxEdfESbnVAGHTI4g52+AR2fI4LT73Ae3ff5pNPXifSgli00KHykiR91IDptKLTx40XptWAeOfAlUCr7kAIxOPbUoJHHRy12TVA6ISgDaJY8LPXf5rvPPtDfuWtH7SQD6WYe4sSgu/cO+XZ7ZTFYsbDaclwNOZKt08nitoMj5C0AoIFg07MveMFWEdXwKcub4FR7J+tmFlHalSbP1OKRlhOZmuE0swXC/IiRyHRSqBjgXMeqjagf+X8Bi/+1GfoZYaT+ZKLFy6hJbx3dx+vJASHEJCXP/rN7Uf141kiOHSwWBsoncc3Db4umHQ1y7MFPgSsFCA1QhqgxekXpSQYjYxiorQkAMZERLFpqaVK0Xgw1hHpCO88RguMkkS6JSo21lHadrVYq3bF10iN0oqNjSHOC+qqpKotKutQ55rKNm0+zrn2EC8DRrc0QYMkLeDk7j7zb/028uy7IHK++Wv/ACUlGoH3DhcU0gWMkuS24OqW4vpmxMsfrHm0DiwsvHAj49/86tOc3T8i3xgSdTtYBafrhsO7R2jvePapDXqRwBmNCB7R6SA7GXY5Y7V/TNQfI7VGxTG967eoZ1Pq6RpjukjZMDs5Y14ozq0LVOlIt3cwV2+xfusu2aSHjD1BCITSBKOhWIOQrY+rqLAHpyTXNpk89zzHP3gLWyw4tzNi6zJk0Rm7dz3ZZIDZuoDYPSSkC8RoCL1NQtxFRCnKesL5HXAOeXmTSb7L+XsHvFZv0CiHFzVOCtZVII40RjakkUQFh9IaQptRjCJNisD5tnPxwaFC+JcuMKcFdXB0o4TMGIRsBeMBT1WXmNW61S4QHq/YK7Rq30mO9gIqCEUIDlE3rZjc+8eCkxYK02hNUze4pkIQ6EQxUZyglMAbg7Kte88HqCtH0YD1FVq1eUvnoQGEsCQ+IHCkXUO1Lqisw3nQKILSOBnarTqlmZeBN+5XBNMldAJnZc6itqh0gFit0E6i44BRBikFRvzoXtoPpTnr9TrcPzhhuVizvZFgLRysl5jH++6Z9qxqycaoS5bGSGnwtW1Ho95zc3uCs6uWCibHJHKOcA3UC+JOaIlYsmbcH9PUa+pmTRxHRF6wNRkSpwnVqkCbCdN8vx3BxxJnV9SVwFkFdc321jm0WSJ6HWarkid2NrBUZJ0ORjocKVL3sGLKrKgYJIr5tKYzUnSTMZHOCMrSBLh4uY/CIPIlVVmxuTlAdjRXgmY6zxkPJ+wMAkp67h5NuXD1GeJ+H71/hO4l5OuAbxq2RmsuXvgYk8/9HN9/+wPe+da3+MqLn6E3TlnnBV//vW/z6S98iac+eZE3D475+KWvUn5mxXde+w7ew9vvvk8nifi12ZKPP/sFevrzZOEHSLtERrC//4BGpHTSjGySsFrBuNdFhZx1I4i1RMeGlfYtvGOV88JTW3z/7QVlWROnXW6fefLS80d2H4AyXMhijtdr9pclV08tbz64zTTrcJov6AUPaJYPX6a3eMTBBy9TNhUi6tHrDKjWa/7ge69x9fIlHj54F29zvviz/yYvv/xDOr1tpDBMxhkuGpEawfS4brH+KkMrxe6995nOZ0xGgXw1Za0H9IfbhKYmUOAWOZOtIUenp3jXsLE5xKiIwXgb4gkPDxc479E6wiOpLZjgca5m7TzdtEuWxUyM5Pbdh0QqwtU5p7MlXggCDikTKuep84KycaRGEmkwJmWxLFtkeJYhbYM0MVmaUdUVSZaxzhuq8gQvJItVgysK0k7E/v4J2sQE20CsqU4PCb4kjbqsXIW3HhsUw36GVoKy+ojW+FG1lXQb1kuDdwVJZHAWQh0wkWRdw70P1pweS+pScHa2oJvGLEOLfh6OE25cOsc7703JJVRbBv2Vy/Sfu4aOYkh6LE5OOHjpdyhO9gmuQgpJJEGVHvnqlMhvoNKWAhACKBR/IGb83ek9bhdnxFGgG0dc6Mf8oByR1j0eiZsMszHJ+Ruczgx3vvV1/mhP82gxY1N77l24gSQw3rnFpBfjJ+fYffcV+i98hsui5OjokGs7E1QAWzn0hT7zQcbGW2X7UlaKUFm8twgMSrc7/0LzGGssoKkRdUXwbXYCFYPptEACraGbkGyn/Id/6f/Ia/+Hv8D7qwUPDiqUUYTgmeY1P3h4xpeePs/aHeFxzJc5vcEIrQ1KCjppCrZmazSkWld87sVbbHW6hHVD2unx3qLklTv3KJyjaASzoqa3uUE4qpG2Jk0SvvITz3Hh3JhvfveHnOU1/7M//mVefusu3/j+bZ6+fgFsw/GsZr4oGIw9l89P0Ma0aHHP4xvsjwBCH1Vbvc0JylvquqasakLTYCvBzsURRV3R6Wes12s8CtCIIFBS4HTrNRNSIIXFRBGdSNGLI+LEII0hoBBCE8lW7SHwLWzHeiwe6QMxjzNIoRVh18FjS8/Z6rgl7UmF945m3lDWFQSPDu0KsBEBJ2jVIeuG5s5D9l/5HtXZy5jwACfWeNcgg0MjaAcWCucdtqlJgmWnA7cudqhXJbPSM60Co0zzuRfO8fDtY2ZnK+Yhwi1ammRZzMmyiCvn+vh6TWdzgu70KJs5dvcR2YVLdLIxVV8RFkuCCsjLQ+K5pju+ytE7d1CiYXYyRZqIrb5hMT1mcv05krSDcor67ASxMyQIhRxNCMUKmgJhLQGPtBbRSciXBc2dA7rXNhFRj5M7+1zuJZy7fAMjdknYZ2MyQDzcJQxTRDchaNossEoItYUgcXsHqMsX8CowGHV5akvx7XmgjiKksHjX4ENFsJYgNULHmMgQ2o6JgKR07UpqcAEXwCOR3iHweATOglIGjUAHh9Qa69tsofURsYJEWWxwOOeJhHw84QJra6xrsDyemHqHdzWhrunEhk4noUHR1Jp1nrMqSpqmze0GoTDKEGtJVZUEoQkOpG9QwWF0oJulLf4/addHlRTEtKAZKyFC4nz73XRNg0DjgwBHu3WiFKd5Sdbt4WpFrQ111eBqh/A5zgWassDrBKE1jTI/8nP6oTRni1qi05hz/YxIRawbR1Su6KYJsxUs1gWT4QDUmuGoQxApvcjzwaMz8rIhigvqyjKZjHn/3kO2JwnUDU3l6Q37TLopwRccTtdUQXJtI2W6lkgjCVpi4g7lquRsvUaoGJ+vOC4Krmx16fW7LFxEXqwhb8g6XWbzM65sxahEUPkRUVCQnWM+vc+ljQS5dZHV0R0Inv7GmMYFDo4fEKxlb65Jk4hUxiyp2B5EjJuKZW2Ji4hKGzqdDB8kh2eWybjDzStjtCvIZ44HBwu6nTGb21s0RYlhxvWrTzLZ2OFjTz7ND99/n53NDZ79+DMUteX2/UNu392lv3mOjRvHHHxP8ZPX/iRX48+y4JSpO+DM5czmD/i93/jrbF+6xbMf+xoX/LdQoSCLHZ3OACVK8sqyNQ40MsJWHba7gbIQdDXYxiOtYpo3TDZ2eOL6Jvf3p6xXa96ZTXm1bHgvX/FVJxiKDj9MIm5vbHK+8Tx5+12aqmQVxxRJQi8IHt67w3C4RxqtsHVBtZwzWz3ge0fvEL4bo1VCUJonLm3zxe0n+fTX/ucIX9HRng9efonGT0nSiL0HH/D2Gy9j4j5BQllWJFHKE09/iv7OBd576RtoHaN8RRQPGY0FIRQMeu2Nv5NQ14Kj2ZJJ6vDbHfbnDUF4pJQ460ljwfT0AKk0qs5xScbpeomyDq/KNiCtJcZ0Wa2XZEYx6g5YF2vixNCJUsp6hRaaQa8ltjW1JwQDdcHJasG6WJEkfYr1kvFoyMksxyjDufMDqkXBoJuSdFLy5RoEqEhzthTsHe/jfECqCCkCU5vhXEESdz6MR/ej+jGoZ56b8MYPjzmbWaq6II5ifCVYr2rSWHN+J+G5T4xZzQV/8J1d6gb6WUyWdtjudXji+jk+9dyYLOsxuH6DOEsQyuCEJD8+4P73vk49PyDWAZ3GmLlF31tj3lkjZzGqLxHKQxPwvuQtseKv+TussXQTgY0lw1RwNRMcz/f4w5dWPPu5TyG3L2CDxDUL8sPblP4iO6mle/kCq3dfJZaK0XgD36zpx+Bu/QR6kJJ3v8zV+ZvEdkZY5NA49MaA//7wgK8OUp5YGUSSoUy7khLKnKAifGSQQeArhygLlHcEpUHHCJnghn2EMoS8bg8J3RhubnFeSn76qU/h9l7i3v4C79u1Sa0VtQucFAFnIiKpGXda4JKUtJh/o1G9LlkScW57k96ojy1rThf3MMWKzzxxg8g4fvPVD9CyzQTv7R3ibE1A0skSsixhMJ7wp/7oV/j+H77CG+/ssViUIAS3Hx5w6fyYR3vHvPvefX7v26/wxU89wf7BES3fus0LyY94IB/V4xKdCYJA6iy6KnDW423OSe4YXLyCkp50OGkBCVIikHjXHlw9YIMAofEiYI2hiWK8jnju+nnuPzimsYFVUSKDpbbtZbZA4bRom7YgMLKl/yElhYXGeQJggyOJDDp4Ih21MxVtHk/JLD0Udrri6K23WT16A7m6TZqtSHVNaB5fWIqAFgKlJEiFdR6JJNGKvrD8xLMjtkaaD/YKTorAja0OT2wlzPeXvLO7oDvOEFGEijyxgnJV0BtHLJZnDCNFs84RdUTv6Y/jXEUzLVnc/YD+1YuoUaCczuhmGQx7yF6PbC9mvu5Q1ft0el0GmxOkDvRuPIETkkRasqeutdkwEROq0LrbTAJSgXHIzYAvapqqwQgQTjC6vM2r33iPYW+JiR6RmQ6TbpfupYuESCG1IcQRIFvsfaghWHAa1RsRljnCCPQk5oXtU/qnKx7qMZFQRLr11TnnaYJlXXvwljg2JCbGB0kt2u1LT0TlLc57nG19mTL41iEnLEmjUWnarrM6AULig8AohQJMaNUMwlq8FNjgWwy9c9S2wbkGnMWXa7AVuYLCdhkOt8h0huwavJTUZUNwgdo66rrC1W2u2vsGIQURjiQxaKnoxjFJ0oE4ITYRadRO9moXaKRilVcgJWVdIkIgAHhLU7WCaS0VsVKYx+Ls+XJKXZUQIIozgo7ad0mQNI3HNj86wO1Dac76aQRNztG8ZtLNSKOEUX8THQTNoKIfDwnWEXTEypUMs5glDZevXKdocoKvyFLFg/19zg0jds5dpGgaTqYr9nZ3Obc9BhFT2xXdzJOXirIKTJcFFyZjXFMz7CUsyoJhOiLuGdZFRcgmrK1nmS8ZjyOWsxlJL+X8+U3ee3+XKIVrFy5QFwtiZ/FNwytvvMHFnT7zouZsvuDjn7jK8e33yExMpzem2/OcLQ2F83Q6MdPFAlfE7EwSDuYVIlQYYeh0hoQgaLxFOMXsaJejxYo0FiQmZxwLZJZRqKsclxk3Bx3EgeMX/+jPc3h4xP7+Med2znP11hMcHK+om4p0p0uxeIfxaIfB+RHlH1hGy5iesFwcnSM8H7DmiLde+j3unbvCre4ZQ7XARJYmaI6nBU9evUJwK+bNguXCUzRzKpmxPdzkcDZFenjp7RMOpw1FkeOcpakrrLO8ERyvuAo7zfnf/MW/wMmd+3SJiW+/RyEErqs5vzlka6fLeDNhNOjxuU+MqEtBp7fN91+7R9rdYX/vEYcH+0ynJ5ycWs4OHzDwliTpkZ2/BnsPeP6Z5xhZSH7pz3Pw8D4n+w/YPz1lOY6oVzO2xh3efv27nJwc8e/+O/82/U6fd++fIIoztGxY5znBxyjliGVrrr99UFD3ruKC4v7RKfePFxSVpTccssxrOgnMqgXRaoGzHhMbXB0wUUSWdTlbLBiOt7B1jbdr+p2E6emcKE4Yj0YUeU7RONbFCiMLtPSYTodEeLwzKBmIYiA0bA5jGhc4OjklMQYVSU5mSwyWk+mUTneMt45uJ21vImNJmm1yMjumk43odEcfxqP7Uf0Y1JWrfbrdiO98a5fjoxopU6q6fRHvbCZEOub1l4/p9w03nuhyY+tZLl27yWRygd5kjPISlWXtQUCZNjgvYH26z/4r34ZiQUcZsqVEvrVA3FkiK4ESKTLVKNXmDarM8S1f8rfP3udUVCgCOpLgLZc3Bpy7voNYpPx0U3D71d/m3beeJPQ7jDodtjt99qoZT3S3md59xHc+eBu6MVfzE+ra4Mslly+cZzYtUSPPo/FzLE/vMWzuE2lFeuMaez+8z19dnvKfjm/QX+UIG7WobZ3iqgLVVNSzGulsK7aNOwiVIGWENwaMRKxqEAafdvG9BDmvOTo54kHziKvXNtGR5N7hEvEYEX71/BZGSZrSYWKNkhFGJmhjkN4hlWwpZXGMThKsD8xmS06LhijKaJYzkIGOUSzrQJymfO4Tz/DOBw947f1jtiYjrl3cZD49pigannrqFgcHU/7gh/tI4O6jM2zzOm+894CqaZgtcj64d4DzMBr2OF1byrp+3FB+VB8V9JMUGzyRB69jKtvgbYJwDUYFzL+k62li00rqa9cedB1QlQ2189TOEaTgpPaEqmb55kPKMlB7h/dNS2N2lsZZdKBF3SuF9y0lNjYBjWddOBrZ+tWcdwiliHsdDFAHRdNAwHMhjTl47TXsG9+hqd4llmuIfbsCV1uUDAjE4z/Htofb0HqpkiRmNEy4mRgiGdh7uOLOtGwBPFowKx2Pbi9ItKRaWeJMkwFJVzM+1yGSLcBnvDGiM+hRzk+pXjpDxCl1kRN3I3RRoyY9go7I7xyQbQ4QsSK7fI3lSUMQCcIYVGeEHqRoW+JNjJAOH1qBN70hQRlEFcBVBAlCxnhrEWXNxtUtZvf3aI5nuMYz2dTcOawoOaLTTxhtjsiyHjQLEK4l00ZdQu3ajHGS4hc57t4DzLULMJrgpnOuXE159kHFWiUEIVAqtGh5SkJoVSVxGtPvdhHKUFeOJIgWDoOiDIbKOUoJtrbtBElA7SxnwVOHBkRD8L4NywZBpB4rE5yjbhqcrVtFA6oVYVuL87ZdHw2tcFsKgyOwKkBlEhMporhD4iMaSqxvCEWBdxZrHc5ZsLRoJCGpnEOlCltZTKiJQkzmHfj276m9wLqGTEBTBgrnKQMgDQqFVyleSDxQEWhCABtogiLoBGWi9rIPQ+UCRdXCQFoy8I9WH0pzJkJBlqRcjxJqYmoh2Ro0CBHQhWNlBTGefN2Qe4lJLLExrF3B2XLFbKUR9RrpLBcnGbsnhxyuROuzMAlv3p0iZUkvjTmeCXZtTRQM1y5O6GYaoROqxtNXgZNVxb39Bu8DV+OaTqTIXIWd1dQWahUzPa24dOEii6ri0dEBujombabYyjK1Ccv7MxLpGA8STh6+i3YlUnVZ5DlCxCSZ4dLFIUXVgEkYpIFON0GdPSTRPWJlOdy/R+UE2xubzAuDkQOG/S5BWJTK2D89xDUWF/aRpePO1gWevfIEOtV0+j2++2vfYNW5RP/iFvHONot1hdfQXDrm+//gTZ77332WJ54fEOYTXvq7v83dN9/m6PU9qqxhfOEqWX7GqrPB5ZFjtZoxmGyTJAXHixM6nQyTJoyzhNOZJzQleT1nUQreea8hr8E2NU3TsF6vaVyDFJ46WOI4oicEr7/2Jv2ty8h3X+Gccrgb57jx5ScZDLocHZ+RdGNSE/P/Z+8/g25b84NO7PeklXZ+83vyvffc3H07qrvVEmq1QAlFghjZoCEYmzGm8Lg8ZXtSjQ0FrvEMTMnYJgwYATPAjEAESUhCjbpFi87pdt9878nnvDnsuNKT/GG9auarqK7SWHX+VbvOl1Pn3We/e631/NPvR/QE2dD6Qz7ygSu85zv/OIicV7/6GT75K/8UKRRNecbJ/RleSIyvWJYHtPpJ/tYv/EOevvUNnrzxDDcuX+WFnau8fv8h55ee5q3759Q+430f+jhHleHlr3+GW69/ncu//0cRscVLWK2WKCmYETifz9G2ReuGPB9QryqausV7GPYKysWCau7Y3L1M265QSuFCQ9NGvF9yPj0kSVKWpzWti2jVjRmuFmdkPcXmlad59eSQNM9ZNBGtJEE0NL5ltWqZTDZp6znBBcpmhfUSHwNFUhCV5vzkiLou0Spj0B+Q5RqlB0i60QChBVlaIITDtgH1uBT+OC7C+jn9UeTGlYyjI4vSksGgz+z8nPnMIYHLl8c8ubPB01c/gNEa4Vr6/Qyd9CE0hNjtlcSLnYCwnHH49c/hV+cM3ylJ75ZQCsJqBZrOM9bXyGGGd4EH1Yr//vwBX/VzkI7ceZCRtoXaBT7xlUPGq5JdNWFzrccLVyf0CQzHilH1iOFHdimk4Oi1fb58vCCmFi0U7vw2Qq+xe/kG3i4oFLz58gmjNctuZtnezcl7Ywa7W/zRP/5j/Kd//m/zL6YP+IO7NxFzC70EjlZQNfjQwZmUKYgmR0uDEpKgO3iIrH033hgDonXId06Jd084NfdJCjianVDrlv4ooV5Fnt8ZszuZYOuGjX5G3uuR5QO0STCJgRCIrkV24hyE0YS64uR4hvWS2fmM9e0JrmkYFoY8DfSyEevbO6ydrwhvn1C1ns99/W3WRmP2Dw95/RMHzFYrAoI8zbj76IBX37p9AWQQaKXwrsEGRWNd54kyGmsfj0E/ji76RuOiQESQWmN8wqpticFyoQomSklQiiA0UpnOXQaEEFGpI3UO7TtAeArUtqVetd0+ZHBEBGXwBN9RHMPF4VQ433WIfQezuXFtna++fB8hO0KeMQonIpVrsQi0lmRaYryAwzPSoztg3wA1x4VAEAEVJAJPCB3wRwiJBLY2Nzg/n+GDJTQB0gQpJPePa05OamY656kdhTKKk9ISZEKiFV4JqtZR9HrM5kuGqSCTII3kfFYy3trGioQYHXkvQaQC2Za081PyJ3bJM48LM1jUhDIS0CxOTijGfbJxH9s2DHZuINOEZGuD6mRKb6I6L2RrEXkKOiGWU2K1JPiOSktlEYlmtL1OsygZXr3CaOMr9FvFW3stl73nuZubyPkZsq+JxQAhcwiaaBJEOe3GEr1DX96A/hBcQG2MGQwF71ov+cxxZK51p0ywikymXbJuDE0wnK0cQgV829ArCvCOIk0YJzlN67FJQlk3LERN3VS0raeyNVO/QIWA0oDsErMkTRFS0bSOuqzwrcVbRwih88WFeDGCTgenkZ3+RUhBA5TnJTIRJLrG204b4qJAmAyVRlIpoG0JtqX1LcIFogvUVYuJhtnsHJFUaK3ItULSIfGVsDx3ZY2jsznzJtJGQYzgo+gk6chOPSEjUYmOiBkECIP0BuVVh+kPF10/13ZE3t9ifEuSs5xIEwLn04pMR4aDhNl0jk57JMWYvvPM50uijwySnNOjhtwsWdaBjcGYvK84X3nW00hVCdqouDzqsWodQtTkKmBUwnBtE+dy7OyUfpGydWmXk+OHaFcxLyt0zGntnFZoNoeSupqT9Z7CAXv7J+xujZDOsj0eIKKjcQqdOo4WkuTckaeSLBGYNiHXkUwEDk5r1vs9LBJhBlReIr3nwd4JvUKxmi84WQbmbWQt63HazNi9epV5NWdjNMbWMxwp+XgTk/dwTWA1O8Y1NUfTyPb6gP2zfS4fnRGfj7h6zmR9wns/8G187pf/JeaLOebZDcyVXWxtMWvQ9vd455c/w7Xf9QR1UxLV17j0Xdss3jzgo+99jitbBVVbMs4eYURCf9gnEpkM1ynSTrhsVMr5coXWOda3vL3vuPugpaoDZb2kqRvatsV7j20a+sMeITi2ez3+4M4We+NNPvKDP8g38pTwxuvsFRnPD0as6oreWoHSGq0TdAzgDa21pElOCJFEea4/9SzXbj7Ppz/9Sd64fYfnn73Jh95/lfL0c7R5wy998ueY2YZjv+L+V78ALwvq2TnnsxOclCiToZXmQ5s/yTyMcYObrF86ZHr0KvNFhWtOEERUWtDvb6DjDB882+NNojaczVYsVy1CwmSUopQj0Rnl7BClE4LW6BhobcOoN6GxK4ajMWdnx5zVFdv9CXmeoHpjmtryla99lePjY0ZrO2xtjFkuVkhh0Drn4OwQnRk2xls8Wi5IU4mrKhaLc2zW56lnX6CfGM6mK6QxEBqq0tIfD1gb9ijrivF4jG0DejhEKsPZyfxbcek+jt8Bsaoaklhw7ekeL782x7YOKeDq5R5PPZ/x2qsr3jN+F5u9DdqTA9RwncHudexyycndd9DNirXnP4gariPCEr+acnr3HcqzfT7z+l2qV8748GCD61dGJGUKfYNUkibXnJqaX3j5DX7+nTssjaE37NHXkrqRLEuLExGpIlJrVls7mMaRG0E9WuMZ1TAYBz79tZrttOLZrQmPjOJBmvDBG09z7CJtXSPUKWd399jtrTBN4FkiRel4ul+Q1y0y1ahiQG/eIpXkM23J9/klY6nhrMGt4gV+OUHqBKEUKtIdGJVEJRqMIgYQIRKNQPgacbzPrczxl+79fRa6JmrDSKUs6ikRGPQLNvoG0kgsxrjgSAwd5SyGLsnl4mcoSXAt84NDNgc90rU1RLvC5ZqbN6+yszPhS/dOeeX1Iz7z6j+jrB0mSbm/f8JXvnF64fehW2L3Hm00eVKgpSJLDEIInPdY50DqrqIdwTtP3dT0B4/pro+jC1suLuD4kVRIsJZY14QYabkQBYeuI5IY06mPpOocElLgXcDFQJSCVBmMlBijEJlA4QjRdWQ774kh4HzACYDIcDxkOV+hpMJFeOdBzXDrMhjQSmMSjdYKoTRGmU5+HCTTe3dwX/0Uz15eUlx/mi989gtEJVCYrphCh8pXItDPDGXVcHJ8TgS0MBAdUibsrwIPFjX4jH4CbQTlJItWo7VAOY8R3eRB1rQ8eWVCNT1FJ5I0MaS9AScHJ2xfukG5nDEYDBn0BsRBilobw3KFmWwhViWM1hHLKZQWrQUyz/E+YooE33QjosIGZF5AIjuHZFZ0QBCvEMWIGALy/AQoAIlbWux0CXjS4ZD+2hqzoyVmkHLeCNavX8WWpyS9XaILhOkMmU2Q/TVi4RG7BqGSrnt1dIpYHxGjgOk57x41bN455UxP8FiIAmsiwiRoUqTuHHi2WRLakkfTI1JtGPXGmMwiVApSE3REpnT3QNcCHh0bovA4DzoqKh9YuQB0xTCCQ+KRKhCURyQBEX8zKeuSojS9oPEKQRCKJnYjhXUAnZkOJiIEMXQJnBcgUzBSkQRLDJ7oPdE7YutIZYLzLaFyVNGz1s+oZktWQfLZ0ylKXCRjUuKEhCjQ0H3XtELobpzSC4nUpvOrNQ4fLBKJ0Yo8T/C+I4z+VuNbkpyRptTLCiEdQq84Xnhal6J9w3Rvyu72Fkmw2CgYG0cqNYtKMRqmDIcZvqpRsaCYrKHcgqGS9LJtil6JsmeUWQLe0i7n+FCSZBqk5PzomEImvPbwhPVhN8I26Q3pyUCSgDYBt7rNadmyORkRY8LR3pzh2KF8jQ0GLVoGRjIaFSyXkEVJf2gYDTdpmgXDUcmijQyLHjHCeNCn3x8imhOwLS4ds8aS1Pe4trXOcFzgnKa55BgUKfNFj8IIcBETICtSQhiSD/psX+oxKAbYEPn0v/kUT9y4ghCBptljsrnDjbuHxKev8/lf+iL5uzcprm8zyBXjF1Puf+prJDcUL7/8ZY5O96gfvc3lrW2evzqhaUtQUBQ9BoXC5BusDXq0ImU83uS8bDl88A5FuyTonK/fk7xx64DVckUMnqatqeoa21pc8FzaGfLjP/En+cSv/nP8/iEv/egfIF851rev8MyHvof7n/0N8rv73D885fr2iDwT2KCQyZDF6SPyAmoiaT4k0ylCaYbDdcqqoaktJklRSpNlCVoH3v/eNXTQzGc9XDxAJC9y59YharLLRrNL28Dbb3yad21s40aB+e1/Q573KQYF86M7BN9gejvI6MnSgvOjO0wmu5j1a6TpAJ1m7B+edEZ6YHdrje3NEVkvJy/6hHKG1AJLSntwSDHewBGYzuaMhxO2rzzD/OQQHzxJkuOsZLy2QZZllG1Dmhj2ykVHLLWC9bUJu5ubHBwck+dDjHI0wnHj8k1WbYtvWkbDAYfzBlEvia5CEZmftizOLGUbGU4n5EVCXTrW1tbw4rdeiXkcvzMjDTucnx5zeuYJXqElJFmKkppmkbG7KTlbHHO0XPDavbf58Y98jP3Zm7x1+212tjZ43we+HUzG8v7r3Uz/asXZ3h2+9M4D/tWrb1E2gt+gwuy/xZU8IznqKsunbsnVd6V86viAJaCERiKpXOC87DpGzgV0q2i85ec/8zZb33aN5y+vc3spGE4yfvZTL7OSm6z3LO2i4blLE566nrG3nPHWmy23919mbZjzwvUdVJ4zm7U8tWV4ci3D7s9YPXhI8sQ2i3de4a0793E2cjc6/u7eff50foW4ikhlICbfFIFKIt4IdKIRujukYgP4TvwcU0HMJfsF/F+/9t9yjwU+OJSPBAfjzZyjw8hn3nrEy2/d53/zkScoRn0mvZRUWbTsEikfHfICPiKUIkQYjPuoKDBZnzamlKslUkry1DAtW7769j18iBgU44mhtpa27TxoCCCClBKBIEkMVWWpmhahJLnSBB06etoFHSz4gNKdsPdxPA6AuiqxIXROviJFYukpCNZ1KVvwJFIQhEAF17m8iKgocOJibwiBlB3aXGuDlAphNNoUpEIgtSRIEB5sa6lsC7IbbcyGI5TomHtSaVwAkm60OE0yTGpITYpWmsIoEilZTxIe/puf59qNbb7/9/1Zvvbyn8auHiGwCCkJoUOlRwGrxgKKpm3QUnYFTyGo60hWDPC5J4mSu+dL+roDl1ROo0WgAWZzh8ZzNU9QOLJeigHyPEOhOLi/T6gcRMvSCIqtXawvGT37BKFtwFvUoEd0DaKXo1eK/s4lUIbStfQ2t2m9ZfLkzQ76M+ojjSI2y25XKTEEqRDlAmmb7v9FRIhIsC112xBtSb+XY3oj9o/u88T1qzz9ofeSNBVqMEYYg4ga1ncgHUC5hPMDUAnCXXR8hgUED2mKXBtyeWfO1uo+t6UmlS1bo5zjsqXOQSAIrnMmIjWZzsj7muAcq9UM0TREnaKExsaICwHlW3oKbIigBTEKZACtISiBlwKl9IWPEqIPtN514JgYkUJidHe/i91CIkhDFBFjUoTWKGnwsru3KiFItEFfyMxbBBhDIjQiROq2ofENwrdQ19S2RvpIkA5hAwLfgQFFQBqJVhKlFNYHpPME55F0O5jeevABqQwmMV1HOXYdP+8dIQislQgnUEYg1W8TrbG1ln4xwDtFU1umsxXDtQlr40vkZo/JQFHnIzY3r/DO7bsoApsTQykSRL7D7Qcvc31rh/PTA65dGtJ4w/70Djc2+yxJCL7ChcCDaQBXkyvJ2qCPTnpMXcXOZI3cJJyeHbNYLLFRk6QDLl3axC/vIhqBMC3z81WHZI0Jy0ZilOC4jGwMBvjWMGtb+llgkkn2ju9z89n34tslR0crgosYbZHRMD+bEywU/Ql5TyPUGoO0+4LUjaSul9y8dp39kzNUmmBSwdbaEKcVC+vYKHYoywWVazlvVgQfODw74h/8w5/lJ/7g78eFmmHpWf9DP8ad/8f/i6ff/QL/+pdeZvPjT2AmOaPdPktxztuvvcqd22/z1JUNfuB7fjdPPHWT2J5y5/YdLm1fQgF5P2fn0lXKxRzV1uw/vIdWkWpZcu+g5LVbDzmbn9NUXafM2gbnW6xz+BDJE8Vzzz7Bpz71y6xmKzICy8ND/OZVgrfMfvEfIA/3uSIVr3ztIVd+oE9ZWVrb4FaHRBeIK49UCbvbw64tLegqZKarKmigtR6TDijbJb6pOD6ek8qE0guefDJj58ZNTo/eZCNPcSphY/ghJpN1XnvrVZRwGBV4/voWJn2Wl158kbv7e/SSjNnZGXliuPHUC/h0i5aCyrXs7e/RWsuwn7G1s44aDOglCaenp/i2pq6mlI1nfW2DplpQVo5Bf0Traia5YaEytPIXSO7YobpNjnaBsqrZXt/AWot3ns1xn5OjfWxV4WOLVYbecEI+HDIwmgcPHhF2BAaHSRNOFuekEpReMJ9HvBScH5fMk4LRcB1rXXeTfByPAzifGl5/u2R+XONtRJhI3Tha4XnjzRqpHA8e3aIqLUE4/tov/QuOzlbsbG3xY5M15qcnfOZf/iK7qac/GuKVpKobvvjOHRarlsTkRGC/Ltkrpzjb7RO86wXN199Z4muJFIEQu9Gn6TRQt54i1Xi6anZAMBhFDmYVq2WDOrrPI/MMH3j+JocnnmawyfHOFl99fY9773yZ733W0SwbKldSlj2+cnDEHSIbUrI1HjAd9JApDN93lXSt4Hg54xc+e5cgOszyr85O+e71Ld7l044gV4uOzWwEpAYkBGe7R20QgAclIdMwUjxgyX/xlX/MQ84wmUKj8V6QRo+nRaBJMsPJbM7n753yoed6FBkYb8GuCEEilETKDj/mbY2PnmBSPND6irauCd4RlGY0HPPMs08y+cIrgGS2AKRARtmNz8TuQCzEv31leU7TNMTYdfwaHGmSdBAUulxOSkiV5t9h5eFx/A6NpnXY6LBK05Ytq3JF9AEhOjJeojqHbJfUd6JftKEQEik7+qf3AaE1WskOhd/Vn/EIUqkwWncCagFLoXHaIJT6JtlYCU0I8aKbEak9eClJ8Bgb6UVQ2iGsZ3a+Yu9f/WvK/Tf5Jz/7SX7hlz9DvZwj6NQTRI+UAus8AUHrHKlJyCLYNNLfHiPOVh20zBQgcm4fnqCjwNOtCEQjCTFATMAKNguDjo7NySbGroi2xhjDKy/fQQRP1k+ZbKwxXZyTbGxRPHmDmPUR2QCamtg2kGhEkKieovfUderDY3oxQ0fBcGOTeHqGGBeIxkKMiF6P2FYdrKyNxCSBZoXQCsoakUrMYMxAR+pTqKfn5OtbrK33ef4jTzIsFH41R2ayc5xtXkL0dxDpiLDcR2w9Dc2ScHyC7PVhuA7BI6wlnh/Qlw2X9AHebZBozTiRzOpAxJKqrmcUWk8QgVUEnCe0jtZ7pAGZeDKTIKUgVbIjZmqIWUYkxQZHdIE8MSATpEmIUqBlRpSaKoAIHmFbVAAjJX1jCKbTpWAvCgpKkpqExCi4GMEU3qNjRElBsK7zJgtFNClGJyitWJUrAn2Eq3H1ikUJTeNpL767y7ZGFAbtPamR9NKMtFeASClri3UtdWOxDryPuBABh2pd59AUAmwNrsa6gHeeqDXGSETy25ScGWmYlgsiCUURsH7C9e01rG+Zk9Ab7xJXLT6mtGWDJ6FuE0YbY+7cf8TuxjVCljOQhjQzqLpEJI75wkGqWJ9c4s6j+1zaGDGfztg7bjmbNzy5UROkZXPrOlYVXN94gsP9fWRsyPo9YojUMmVrcwOjc4xeUIx3GY/63Lp1m6Zt6PcMR4uWvG/oGU2qHac1GCPJ8xG39vdIe5bZzPLUzhWKvMfR8ZxVHRGtYLA55NH5fXwlGSYGXYyZnR6xqgOba+s8c+MJvvr1V5GDTZ69tMusjXz11ddJVM7OZIOqqtHCsznsc3v/Hj/9V/8mf+p//ce5c/sO3/1dH8P+7/8DXv0rf4v1NPD6P32ZGz/6AstqitzJuHvvHS5d2uF/96f/GGvjAQ8f3mGYDnjpvR+iahtsuaCsI/sPHpL1ht2YYVLzxtvHfPnVPY5OZ7S+IfiA8xZrW6qqAhFwrmVjbY1/70e+i5/9xX9DbR2ZMqRC46sGoQ3TT32Cr/76J/niYs7vTQ0vzBWHxycMRykOSWJ6OFtRZH1irHnn1ld4z9ZHMSFBGcNwMKIoejhvWZU1ddNja3QZKSPboxYX4Y07J5TllJ2RJraXEMmQ1fkBZvcaxMizmxlBKTaHAusim2tDHuw9YnlyjusNyHoFmztXefvRIR/66Hdwslxx9613mM7OEUQmkzFXNgZUVUM+HhFOPaPJmMH6iGZVUzWWu3vHrK9NKHo5x0cNt2/doyxbooxcu3wJ2ZbUqyUhlLig8VaT6IysV7B/ckLEsbQRjGJteI16tWQ6PWZ+fkgQka1Llzk7OsK3K0o82SDDVg2ShLwnECpHXlSTUJrW1jTl8ltx6T6O3wHx1S+/gkw8N54oeLgXWZQC7zrdglKS4EEIj9GSto2U1qG05nQ65Z987ksMPvsZTGhJn7yOTHJ0qvn8G7dQSmByRb1q6emUJDMsFi1SCiQeFzXTacC7gJIKG7velJKSKERH5woeITUQsLXi8LxhuWpJckn26B7VzvNsvet5NteGoDQ3Hq4YijG95TrfebPGncK6yliPjix4EtHJcLONlP6715CJBAS/fg9uHyxACLQ21ErwN++/xX/57AdJD7tdjdiCchZMh/yPUnYkLy0RiSRmiunA8+nTb/BPHrzGa6sTiqHCGI134JxjVVkGgwSkRCeG0WbKJ+4+5Evn57zfZOwOcn7w+z8ISiBEgghgfbd74AndyKHzWNfiWotJM4rBOrsvfZBJMuTv/8InuXe2JEkkIXa7q1p3ldnoO8GrkN1oj3cdIU3ILlmTSNrWE2LnsItCIIXEO0dbP+60P44uNvKUVe2Zt1XX2Y4RHz0+RLyUVM4hhUTJiDEBJVuEVFTKkKUpUnXXvxaSJmisgBgv/HvRE0UgeI+REu89bVPhbYuIAacv6ItS4303KdmlexEZO0G1VBIrPcIIENAcLFjc/QQt+xgirnyIkR0SXhKRQnTXRBS0PqCVJiGiM8Of+L/8x9z40HfxP/65P8+rX/gctV9hg0Mnhlx03ix7UZeJyhAvqhjWemwdaFclq7MpygjKOuFgClev9/FFRpL30KqHkhY96HfJVDAIJ5CyhHJJDBLRH5A/+zRxsaQuLc30mNFTO8SyJHoQIvxPRNF90BlEizhfERZLRFMRk4zYCOS4QGw48sZyvv+IarZi6/KY4eVrxOkR+tIurE+g6CGc7cYMg4d8A7H/FtE1yKwg5iNQKWLxiOAa5DAlVZH3Xy/5V2+csO9HfONBSVokaFGhQoOSCSEGnG9pXIttW6xvQQjyLAcricagLxJz8HgVus5fjFjvEELhdA/nFNKCMZpe0cdZR4yO6CGNEnMhAGmaFt84vIjkSU6uU5QSuCCJQRGCxDuB9AFFIDQWay0CSUskyKQb45QKHzuCp7Ce4KEKgqgMOs1JTIoEotToEMizhLXBCJMVWC8JaUOoa5RscNZDcGjvu/tx6MYyG9dCsKgYOhiLilg8MXQdw99qfGsk1GeOqFKG421m03NuXB1zcHaGc53s7f69t9g/67E+qli1gsTkjCcj2iqw1h+zc3kT37SEXKNFSyx2IUyYzuf03Dnny5rF0oKv6JuC7XGGkgbTzyiX58zmJyTFBj7JuHbjOr1c8rWXX2E43ED3rjAZ9ThbLBFFj6Z2nKsWaTT9fEjZVGTjEdeefoa3Xn6FvG9YnCwYDwYcPLiL9BrDgI9/9/v59Kc/T9HT9JSnlxt6RcpsMcXIgrWiwAmLDo7h2jo67TFe38JZ2NzeZWU1J/OGKBWGhMJI+nnOoL/O1qUJbz6coc6WHBzt85/8ub/IH/0jf4SHr75CPDtj+EPfh/vvfplwus9rv1aRPLlGGA85eOcVnrq6w2qxwKjApc01jo72iTjqqiH6wGSUcTadI03C6XzOl167xytvHlPXS0IMxBCJ0WLbhqouaa0DPKnR/MDHXmAyDDz/4nu4fedN7PE5eT9jfnyCGxxw8k//Bz5XrdiP8Enn+ANHc0bnDjfKUVJTpIY2aJwvSU1CEzVNVSMLTVSKF158iX/2T/8RRdFjOp2TpJKTqmRrmOE45uHeGe9734cZ9CbcvnubZ57dIAslD7Meo6Ek1mesbUywyxNO5xl9fc7RkWXZOJrpPqPJGm1/zKDoc/XSNY6WluFki1df/sfENiCV5vlnrtMr+pyfzlHKoZRiMT1jbfc6RmZU9QmXtjZ5eP8O07MB29sbBB/ItSNGxenJCZtrY87PzhgOB6RpymCYMT/eo7U5Wzs7PLj3gOdeeh+N9Xzhc5/hXU9fYbI+4sG9u0TfMJ/NqOsKKT2xXYG+RBs9aaKwtUBFiZKGJDe0rmU4HOHaxbfi0n0cvwPiQx+4gso1aSE4me/jgma5aKnrhjRJECLS6yt04emZCZOB5Hjecvfhkrr2gOV9u2tsXrqGzhVffOs2bz06wYtuvMgpjxCCpFBkMeJWksY5bt2pCV6gNB2uWupul0EKkostECMVIEhUgi3h1HiqxqIibPYyZHyEO6up7Q6VGmJ219iwL5B5RXl6Sm8iObQpV4uKtSSg8oC+bGCSUa0q3NSyfvUG9/ZudS4fAUoKbuxsMK8WvNxM+ba8h68cUkqC75buY88gEonoZbhhwrFp+PW91/g7r36RR/OK0WjIjUsbPHp4wPy4pHKBNJd4IgWej777RV58z7v4V5/5JZZLixaRZuWJPcnR+Yztca/blQjgXY3zrhOn+rY7cJiM1kWCFITFguAcu089zU/+oR/lp3/mH7Fou5OrThSXdzd48fl38aEPvh9fl/y1v/33mJUtZVVdABC6cU0PZPoCc47oEOgx0rp/+3cex+PoFz1kolHBgut2ezTuYj/M0cRAALRK8EqhhEIrjRCyg3mISGEMWZpTtZYmCuoAtmkJITJrHT7GbufSNwjvUM6SCIvOUmInQKP2gig0SvgOV+4jUoHVkkVbkWmgbTn5xjegeYQx8YJ610mp5W/CIqQgEr45GqdU7Hbeg+fhrX2yKwn7d7ruf92sumJSL0EUPcRshvIgxW8WlADfdfOIYFLBsrFEb7h/6wDnAslgwHxuGaUlg36PgAYfEbMlSINfLlF2RfAOKbs1Dl30CTGQDgraSQ+SFCkF7ekUM+4h836nAugVkE4IB69C3YBR2LOW9mCKyRSJidDLsb6CqkZXp+w8+zRhOkUmOURPfXZGGgQxODj5OmowgLUN4mgdyimYSDw/Rax7RJogelknpA5nvPSM4snbJY0aEWVkfZLhrMWYgEk7KqFsFTJofKxQ0mOkomc8QoFXFqLD267gH70DIkZIsizDC8lisUAIhZKGplV42wECtdIkwXaTUCIQ6UYJRYz0tSGXkkGaYIVi2XpaG3GNJXhPXS1wrsaFtmuDRTqSok4gQlQpURqEFGgsKniENqg068CFUqO0wdMRQ5cu0NgEiUEKidWamPXQ2iFC52bLiJjoUMGioqWqS5q6xLWSGB3B+W+SIvVvF60xHfWZnswomhPWh32m81PSok8116wWNVsbPbJ8SaYzRrtrBC+xtsVGUNJw+503WcsvkJWDHknfYN0521sTBskaJ2cH7IwNeZKSJZp0YNHA3plnbfNpemm3O7Za1GzvXOFw/5Ckt8Z40OO0KUiKlJ4PbF+7yZuv30a3FePRmLy/wbKskEqw98ZrbK71GA1HGJmSmIQnnnuBW3f3MDju37lDz1hSWZFIqFwgH67Tp8bGOcNhn0XpWNvcZr6c8cSNm1S2ZTqfMx5N6OtAkvep64rv+MDzHJzMCD4yXu8xmztWs5rra0MyJXn97kP+8T/7Ob772z/C7AufJ0n7XPqOF7jrzrn71ps4llx64gmKPGMjA8WUcr6kRIJKmC5q0JJ+r4cLJVpE7tzf48tff8De8RlV01VyYwz4GKirilVVErwDEZDA7/nY81y6ZHiwt8eteycc7D1k13kW3nJ2vM/g5vMcz844dwGlBQ+Tgi86z3d+5RHJcx8gM4pEO6L3FL0NyqrGtTVVM0WnCUkIbO7s0it6xCio6xZnLYU+5tF+zaJcIbMRB0cNc/1VNgdDTo7ucOZmmP51mtUe3gvK1YrFbIYLC6ZJjrNnrPUl/a3LtNYyKDQPH93n2e/4cZZOMZ+VfPXLn8MHx2g44ua1dZraMRkmLJeWfj5E9nK0khycnLOxs4NdHhFoWNUFvdEai3nFU5cvcT5bcX+xZLqakg8H9FPFrKw42j9mVU0Zre9STc84mx3zxjc+z8aw4IlLY155+2UCgrXeGj5EFqdHpDojlQJBQr04YTzYwJhAIhVSZ0QazmfntHLCmo8o8XhO6XF08eqbZ4xHA1QCdd11SvI8ZbHo9jBG45TVsmI0yGhd4O7hghC7A0yi4KPXb/DMU9dBBX7pKy/z9VsPKJcNKhPY2pOnGVorvJDoFAqpmC8M5/OWIknwAbLUUNqIUpKru2MePmqQClwD1nn6RScgPZlXNCHQTw06FaSpQFIxcfv4eAAIms2GrA18MLUkWiFkRMtIKVtULyEGjzheoQiYJMFsbjM9n3Y7GRFa5zibN2z2M37x9AHv3XkevWwRMsW3DVILZBqotx0P1mf83Xe+zOv7+zycVd1uhIQoJAfHM65c2uDO3hnCNSwWlkE/oT8c8JHv+WG+73s/xnh9wN/463+b3f6Ej+72Wb+xgZKKxloSJWjqFusdzllcgKpuugOAFeisR+UDVVvy8PWX6Y/X+JEf+2N88Utf5QvfuMe3vff9/OCP/DAvvffb6A9H1PfeRFZTXvnaF/gXv/F1oKPnOedJMkWvrztBrI/4Ti6FlAKBgPD4fvE4urh9PifErurfJWGSvunWL7SUdKmOx0RBVJLEKKTU3Xiwv+hwuIALloFJ6GvJaQ0oybypKcua1rXE4AGHjwHhPCp61KxEydglJiGQmpTrV7d59GAP3zp8U+N9241YSs/ARcxyDyMr0l6f2WyKlLLz98muy+Y1jEdjliczMJ0kOwZPLSXTo2P++V/6b5gefRUtXEePDpYf/kM/xff90B/gL/9H/yGn999Bi0h/OKKpW+qyxDnHsCeYjDMqpXAIkkwiXOD0YEFwltOHZ7z3Ay9Q3zulbXugNEZHTB7h6hrhzkPk5iYh9IiLI0bPXicsHbaJ2PkKpSXBefzZDHEloz6aYR8uGTztoD/CnjyABCzApE/wDm8jCoOdW/x8RX9zTG/3ErFeIXcu40djzPmS1aN99GiCWd9CXH8OULB/B2wFziFjh7UP3iPaipgXEBUbg4pnhvBKK7HRcPtkTvSewaCPsKKjd7rAynX7WlmSkWhFkqQEpbARAgopQcpIcA5nLVGnhCRB6l7XURUCEQWp0iij8BefhcPRuoagFZFA65fYuu72BqkRImJF0kE4hETHQHA1eVhS2ZpMSrSQoAVtjITY8puetxhbokiQxpAkObk2GCGwgIudPqJAEaOjjRXe1Xhb0/UAJc53I+LSJHglUEJiJGgpOs9ur6JeLYjBf3MSTYVw4az8bUrOZssZ65s5qUxYNjXlwqJVS5qB7mnKhWPY30RJ6PXHLJcNA9MtLbfOs0JxcFbz7JPbLNqG5fmMvLfBo709xv2EqKGWAecbvHVsj7exbUXblEz6BUFGVosllfM83HtIs6y5dPUy87lnd00xW67I8wH7R3N2r1xme2NCXuTM5ys2g+dsumKen/Hscy+ynE+ZTDYwosS5hswErly5wVt37nH9yedw9QlpOqQ8PsXLnOFgjRvjy/TzlONpw3hzxJNPPcvpYo6Nke3NSxydnXaVkbZBSUVQKRs7u9y6dYu3v3ifX/1Xn6Ewiv/op76HVbXk7/+i58F0xTsP7/EDf/bP8MZnPkdbv8xwUnAkLbO33mB9Y52PvvQ8H/3Is9jVCpVleOmYzWuGgyGjYc7e0RmPHk25c/+MvcMpbV3jnMO1NcEHguj2BVfLFT54uqUM+MHf8yG+5yM3KVcLDphy9OAeTVuTBc1pu6RZzBkUhnMpCSYhzzNiiLyqDU8cnnP5/hn25jrnswZvK2blisYKBr2E5fk+vWwNn3h6wzGj0YSz6RTrLQ8fnfL8zTXiIHSI1LTPcvoWZX3O+vMfJ54+QKgRzazBuZKt3edY1gsaD5PhGKkEWbpLMUo4P5ny/Lue4f79fa4/9x34/BJpgE/84j9mNp2hRGR9MmCca965/Q2uXbnCO7fe5KlnnqWet6z27yJCy2uvPODalad46qn3cXx2yuLsnM2dq9TSYHLNFglPXXmO1WrOg3v32N9/QK/IGU62qGcVlZ2xNtiiWs2RG5cItuTG1iVaryjyHC0zMuOZlRWiLZmXhnG/x3I5xyZDruyscTKd0bYtw96Ytc3L2HaFMuNvxaX7OH4HxIc/tMbxo8jDgyPm04osHRCJZFna4YhdYNBPWLYNvvK0TcOV60OWS8tT632evrTFo5MDPnv7AW8/2CN6QZ5lLFcl/Syl9eHiQWgItaZuPdYHjJIoHVmsXHf2lwqB4OS8RAnN5ijl6KwkqkiaaBbTuvOeadBGIxLRcStkNyZilCbqiMwloqfJRuZiezxinUOR4HwgOocWEGSHxs9Hm6xvbhDvH10w6AR17dgrV5wqxSeqQ353NoI2oZU1s7SmHc1hd8Qv7x3y+YM7EDxN41kf95m1LYjAomy5/+oZWaKwzgMCbwP3H5zzN//WX+e7Pvpt/OhP/Cl+13d+L3m2B4eW/de+wPL4hEDENd1IV9U0LMqqWyw3mtpr0jzHBYGKgrKsGczOaasFo8t9/os//1eYn0/pyYTs6lNIKVESzI2nEasZ/94f/mP82hf+zyihukqwVhSFQXYE525XTQAxII1CB4d/PNX4OC7i+OyUVHedggviApUPtIAWgTZGWiAVHuMNznlS5XHWXiQ3DutaxllKCIKX3v0evvz1AxIpaVYtUnscHh8CNnqkdfBNsbAjWte50Ai4uuLuG1OUBBk71WJRZLTlkq1LGyzfukd1+gAdPXVl0VoTQ7cnppRAycgTN5/ix3/ij/Jf/af/GTKBxHTjbi5Ejvf2GQ3GHKsFynddGC0ER3ce8Cs/94ssVvaiuxKZTedEL1AEZEdu78A+KlIuVzxxY4hSkuneCeNRn9XK88qrd7l2ZYc7976IdyXrPbj+whNsPHMFb1LEzi6xtogiIcqU9uw+Mi1IigRPQCTbTL/+FSZFhr5yiXi2xM1OgYgZFYSmZnV6jtCi2xMrW9xin9XpCdbOWL90o3O6XdphNj3n8NOvstx7xMbVTXZ/8H0oBeH2K/jGIUKD7BmkicRs3CVlvoTRFqAQ/ow0M+zkS5pljzrRBG2RScQlPVRSEJVEhkA/DrHOEnxLUIISRUQRLmBFCgghEKVD6Qt6ZwuxrUiSbg9Ma0NmNLmUSCRegUs0XkV88MQIWZaQ6q7I6KJlUU7RKkGbBK01WkB/nFCWinMhyJSipzN0klBHQQBilEQ6JZGVGpKEtaxgnKX41jKzltK34Fu0CqTKIF0g2JYgFUmSUXuY1pZEGrROCOLiPbmAdQ2rusLWS2xTdT5A77vfS3Akkm+Oy/5W4luSnGmlWDUpx+UCLTRKZ4gYSYSkFhbSnK1+Hxdr0iRncGnC8Un3BfQkPP/MZY6O9jiZl0iZUNdLqqaFaDDCYIp1XHtC9I4QFGeLfWyUhGKN+wcP8VYxGQ7ZGGl8s4TgmE7PwSuC6CGNJBsOyYTGCM1s2TIcDKmsJ/rAE1fGRHGTtDfCesfVy9e49+gQH6HX69GsZmyvj2m9ZvfSc6SJwqQ9apEwW9Y8dWOHYX/MYFNjaEkLhVwKJsMet+/eZX2Uc2t/xvXNAiUj56ctB4dn9HuGX/qXn+f0/Iw/8aPfzeVnvw3alv/kiQ/zM3/1v+UT//3/k7Pbr/MT//7/kq0b65gbE9qJ5OVvfJlnijPWhz3u3d/j0u42UQrmraOX9pgtW/71597mnVsnRA1aRqqy7hYyiTQXT2rbtDR1i/MBRERExe/6wFO877kh09mUfj8hSRNGRU5V1+RBUEZHcIEsTdkLDustNBGTZCxiy2vWs/P5O1RrCY0NqCQnTRQiBASK1eoRjb0JbU3eH3P9iSc4+NKXUFLxyhvv8NJ7fwzlvs5GGtnY3ORWcxdrrpEXGUIobj7zbt548xuM++skGnzjWFubsCprCpPikyXe7iBEw2J6wHQ+Y5RdJWsirin5tV/65wgBOkn4wY+9lwbBqN+jqWryYsjZ0TnWViRJRqo1l3cKimGP09Mp+XDMsN9nVS8YmSFJkeCmx0xnnrfeuc+qmVGMxoz6E8a55uHS8tSz72K5mBPqjLZaUlUtuR6RJbBcNIzXEtpgGQw3Kc/3cc6SDfpInTEZ9lhWK/pFD5/3aOtjzk6OKHKDltm34tJ9HL8DYrlQOLFkuC4YL3MWM0tiEtIkI8ZAWTUIE6gqy4tPDlmUCffuLgkyYeoFv3HnLq/e26eqakTUVFWJyDJMmnA+XyFNSoLtRhijYm29R3s8Y5AmlKsWqSHEgNEJMV4cyqzj8MSSZwmRyHCQcjwvu0p9ItCpRKiLcaQLfDcEog+dcDVEVJIQfIsSCmU00QWQoKJC4iHCYPcyupjwHd/xIT7z1de7HQAhENLgQk3Rz1iuR97xC9yqxA8F6dqAwaCg2Mj57CcfYluL0Yq2cpTzpus0RYnzAa1Et7MnOzBCCB4fYZAkUDmi80wmhyj1kEq8i8XnW4yQBG9ZVjNWVcsbDw7QRpP1ctrSIVWK15YrGzmb16+jXMv2zWdJN29SkWHGI/xZwz99e4BZaG5uSr79ukZmPeJownuygpeubPDG+QrTahJtWM4tJlEIBVpLpDRAxAULKqL/HWhhj+N3ZuwWEST4i5dRESk9IgaC685EbduwuZkxPTlm6TSjfp+mrjtMvq1pQ0NrNO9513s4O+sE77kQbOaaRjqi13jZUZuTCDEGmmC7Tor31KHr3BVKoaVGd6d5RBQkhcGFCb0ix8kHtMISo8c2tiOpR0B2LjOJ4vYbt/nrP/3XiCrFYzvaqXDICHff+Aa5ychSBa1C0ImF/80nPoHOP8soLxBSIeSFRkO0pMOEonZgA/OVp00LNta2SKVlc2fIszfWSXoZ9+/OuP/wjG/cP+F8r6IYSYbP9WBxinv5a52LtPXEIkfo3oUDThNnM9xSoC5tUh9O8csZ7uwQHVKq05Kzk1OGW2skgwEmlfS21rBVTTbMEeMB9uQcKRT5aIS6voubz0g2Nhk++WH6722Iokf1ziuE0yPYGkMW8GeHmAhysAVKIWLoFATjywRlkOWMKBUhKK6NG648POUNuYPRGTpRIFJkuLiHBEH0khgkyiv6vZx5WeNdt4qRJQkojTYpSLAXCbmI3bSWQpJIkErSRk+idKdruGAhmjSnJaCFRMtA8C1ltcQ1FQqHjAG8pW6BGKFVlKslVdvipSEWEoPGakOUCh0FLgZcBOc9qWvRIqV0LYtyRVWvsG3V7R8LgYqRFE9uNCrLgaRTaSmJCx7v6otdx4i0DapcEOsVTbXAO4uSijQxBK3QOsGISPh3mFz4liRn86Un6gXjPKUwKVma0tiSwXhArAu2N9bpJYJqlbJYzTHtlGpxhs7WcLHk8GjBsnEYDNd3NrG2R2MFzkda32LawGQ0ISCoqhYfNRAZDdZZy/v01nd459YdLvU3sUpTlsc898QNXnn1dVZLS5b20ELSKkPbWlblkvkoY7mqKfp9lo1mMBxSN5bgIq+9+g164yG/69s+xC/86mc5W5akvQGTXk7SH1LVDcdLx/WdCXrNcHI6xwdoWsHuRp/7Dx92hxZhGRQG6yS7E0kiFZVtELRsjlN+7dOvcHB8xuXddR4dLeldfYk7r73NF776Zea9Cc/ulOijz/L1f3yXPE3Z8IZLE8Xh5oTbJw0PyxzUktcf1dggOJuuUFqwXJS0rWM87uOrwDK2BCcIoat6Rd8taRIF1jUE3+1aff93vZfv+fhLrJZnVHVN6RpGgwE/8p0f52/8858jJdCKjmx2ejJnJjOUCuRFgXcWoRS3Esn7Hs1ZPyxZe3qDtckmB6dz3v3+dzM/uc36uE9ZLfEqJ2SOl973Yb7ypS+CMjzaO+TkdMF6ntHGhDde+9ekSUox6PH1l3+N9fFVpoev0sz2GVx6hu2tgtdePUBLwfteeolXX3sT2Qamq1tkk0vs7R+y8+IPkRRrSCn5+X/4M8zPFyjgyuVNVCjZ3X2Bu/fvUQwKdFNStSWpVmxfv8LR4ZKisPTzPmEI/bVRV7VHkyeK0+MTytmUA7tiezzieJ7yxJNPUBQDein0J3NOTk+7RetQM53NCUFxMj2l6PfxzjMve6iwpBhoxttPsH5FkxjVVexCZPfqVe7euY1SGVcvva8jaaUJw8Hat+LSfRy/A+JLX3lIDIKyhLJqKPIeIFgslt/0BtV1BCHZn0WETNBJhVSa4/mKZSlQUuIRGGNQqqFpW4TsiKDeBUQKXKgnfIiMRhmL1tIEh7pA1LetowCUkmyu50hpGPczTKIo65ZRlkH0NM7jo++gGVogNCBiN2YTApGI6RdEwBAvkqWITCQiiI5G6CMmzcjXNhFE3ve+9zMs/iHTZd1Vi42gXjpmssSHMat+QtNT6CRBZxmyl3DWwjt7JwThaZ3DBUF9sZsGEZNqbBC0le+k8jHg2sjT167yZ//In+b0wRxnbzO48jwsbvDzf/UvsZwf8pHnLrOYlhztnXIynzG3jqzIqUJDkvVJ04Qky6gby/TomOsvfQC7+SIHdc3e+WtoNaaSV/BbfRqlEMITfLhIsBTZZIfv+eEf5vZ/94/w0dPvGc5mFu89WapBdFXrDoDdwRKkfEx3fRxdbGxdZrQ14eHxnFQaEhFxeEK02LaGtmWkcrCetWGfxcpRW08dJdIkyDxDSU+WZjw8mZEcLhhkOVKEDs4RBT5qotIUIkOHgLcO4SQWQwg1tBbfNtQxEIVCiG70TElB1mhUmrF0DcJ6VHBY0e2USa0JvoNFgKB1AY9gfr5PiB5FN2qmBGgEkYZUK2T0RK3wzmGUoBDQeEcQEWkSgoiE2CAkfP//4j/gS//wH7BoGt66U7NcOuqixS9n+Cpy9ck1TDLEFC2n08Dt45p75yuuzRMmfcnEOAa9A5LRBI4PkeMRMYmoZYNVEtVLcc6ivCe1NbXR+FnL8vBVju7fpa4s9epp1q89jb62QzQalZYgJf6sxJaW8uSQYpiTDLcRTz0NxTacn1C+/hp5r0//8haiP+i66MWQbHyZuDhBJNmF56vs7qU2ItslcTlHrFZIJfjoezRvTA95dE+y6o/xpEipyZPkQksQUIAmITpH7R3obhxWKU+MFh86QEyMktZBWzkgIILHxxadGhIfcC5wEmdolWCEoJclJFmPICVSabyIRK/QtAx6hoAgEAmuUwrUzlLXAS27Z1eMiqq1WF/iVA5SkkmFJbJaLVFSIBLDma+oq5a2rRHRkWiDMQYpI95ZGt8SUPS0RimHlgmF0ti2vlAbeFx0BF8TQ4kOKxLRYmWgyFNMlqPSPlIqvI/M6+q3fJ1+a3bOjCZJNcE3BGVYzs5AKjIz4MHDR/gqMCgS8JoQQWjN9s519k6n9JOEYb9ASUdmLItVhU4KBJY0z4kRhuOCtpzTuppRb0yN4Pi05MnJGk1bIe2Sm5sJs9kpbVuj++vcv3fAztYmw+GY6XTKrGoxcUmvyFlVD3njnZr1QR9ZlyybDB8a9s4svql48tKI6uyIL3z2s+RG4qZzrl7Z5uRsyqFd0tqKSZFzcrSHtYHJ+jqnp2doYzg+98TWUzctRktMdKyWe5zNWoaTdQapQaQD9o/nvPzabXywnEynvP7ohP/6L/5XfO4rX2a5XDBbLfgXLpAlCWujO0yKjO96/00GhSKTmmK4xclsycGiJOCpqprEFKSpumirdiSv2jYMBhucn+0RQ8R5R9u2FHlB0y7xPrCxucYf/tHfzfNPrGPbKXXM2Rxq5ssls+mCz7z8DYxOSL2jHyWcnaMevsOjcoUPllUZMVpjpKY0CW/WNd/96gmXP/oC2WDUuVSaFVEITo/vYLOCvspI8gFPP/PsNz0W3jo++7nP80M/+qPYo3+N1BZTXObeg9cxQaAvj3hw+A3MaBdXL/j0Fw7Y3ZgQZM29+7dpVkfo3oAsHSF9yejmx0m2n6Vxnm986df53K//GhFHkib8+A9/nEGaEb3n6vo6+4dHmOEam70h3llWp2eoGDifWy5tFyAkmtDhgAvN+ekSozWTjV1Uokl1yjObGkGLXy2YVQHbtFSVZ9BPEMkaabZOkiTs798jy4YsVytkO6UOmjxKTGroF31i8FjniSGS9cY8/dx7kEpgW49JUnSisE39rbh0H8fvgOiplJP5gqr1+CBwzmEM5EVKuVphTM7OVcnhA8HR4ZxeanjiyiXuPDwnL1Km8xkqglJdWXow6LNYLGjqGmM0jXUoJTvktQvEuibJVUegyiVpJmmWLYhunEMIQZZmeAfXrm5zaXeLX/jVL+AuPDmlDUS66z1qDbIjOgrRVdiVlETXdihvqZHETsERA0LSUQsRKGNwtsZVCzY3r/HMk9f48mtvI1GkWcqj1QEudPACJzUaTZIajBLoJOWLbz+kDR4bBCKC0Z1gt9tvgCzvHDo40TnjnOW7PvBB/ujv++P8s1+3FIN7/PgPXWJ+t+Kd3/hFpif3EcJwd7/h+OEcsSyxWpCYjICkSHOMSZFSYaRiWdWMnnqJeX4NNbesbMnV0RaTwSZ7VcmpP+Sjl59ku1AkiSYguz0yEfjeH/ox/oef+wVWqxWrVdsBW3JF3jO0jevGeejGbv6nI+uP43EsGsdsf4E3PZKkc4DJEJCxRYmUqBsqFzhtWi6tbSDslBACqQkkWYaVmigFVkDoDYlC0uqETEVy3yLLBXVddt0K7/FK45TEe/DB0voGoiWEhlXbEltH9J0LUKQaqwf004I265HEFrDI6BFa40NEEUjMBYUQun6LohMQC4+RERHoROyyK0oLIkZ1gI9adM4ui8cTEUoTXAc0Es7zD/7q3yB1geXcEsQCFT09uaIIjrPlilNr+bYP77J25TKrT73JKw9qpibDqcjOSctuEdncCJTnx/SygmR9FxksbrXEaHAIbGOx50vs3m18XfLgra+Rrm0QmpKzZc3D114juzXlQz/+g6RFD2U8+6++htE9yrbkeP8hV/Kb2OkS3d+kOTvl/PU3aU73UO2Mnf63Y/oTZH9I8ALhAyIfEYe7MDtCFn1AE8tT+GZyHPHzFenOJj/yAcHrx3v8RhMpY4HDcy4izmp6WqGJCClRovN+9bMcKSVaRrodL4VSgigkUilEovFREpyEqKh9N6oe204+HUQgaokVEYlGSomXlkXd4G2NUV3X0RiNlh6io3SedlURtCYmBnSCQ6JEgiPFR4n2kcZZqrahcTWpCLRW0c5bXFN1P9t7RJIRtOnumSFiiSRa07hIXjuMSmnbFudaatsSfLcb2fiuk6cJGKXQsvsspUzo0H+aYDSt/21C6UuRQIisj3fItKBqR0jvOT1fsjGa8MT169x6cMhkkKIkDJRn7jOMXuIBT8LGMGG8scmDR4doCQsUPQVp0iNL4e37U25evkRVlRilGfaHbGyuk2jN3Qe3cYDwNbYtSbM+MTTgHcdnR6ggiLFCZZ353eSbmGpBtZwzbSxpPsIkOTuTBKMUy2ZBVhgeHR6yNhpipab1jv6gR5HnpHqNw7MFMk3JMoEPERFbykVJW5cI61k1S5I0wTUOvGQyXkPoDG0iq9WUN9+4zenZGYkx1KuWg+ND9o+PSLTGupZeL6dfDBABnHccLOHv/dIXedfNq1zaKDhZzjktV1gfaBtHDBGTCeqqAiI+dBVgZy2Hh7fRQneLuVKgtGK5XCJF5GPf/m7+0I/8burVlKqqqGzE+5p61SCCJzGaw+UZJtVsNJE/8twLJK+8yuyTv8xcSgiSopjQ1KvuACUNr0vLu24dsX73nOEH1lnWjvn0jP3jlss7Y85O30Fnu6jVjLWNbZ559nlee/VVpII3XnuTd7/vmJ3t99HOpgzNhLwo6A03aZcHTHpjeoPLHB+/zSjzrMqGrWu7LOeWRVOT9AyCEcNL347ZfIGmcpwfP+Bn//ZfxTqL0ZJnntji2ihFaYH1DSrxXNnZxktJr8gRQeGbinnZsLu2xXR2RkSQ9wtOZgu0HIJrWFYNU6e43OtDaKjLmsa1GJFQNg29IqOfJzTWM1jbYHZ4hDZdy11Lz+x8hshAeIlWKU21YmN7g43RGJlpsAalYTVvMaYbgl/WK5qZpZ88pq89ji52d9eZrVqq+SmJSWnbBuhcLAhBWTaki4wkywjCIjRUTYvWCmcbtFEI2/LklQ3uHUypWkuapFjrUIlAC0XTtijR1attE9GpIIZAYiTRRkaDnMaCiIFUaubLFaNCE2zDO28/oLUtPkRkiEzLhmvrQ5x3hBCQIULsxhS1CJ07MEpEBElAhAjeAh1qG7pdM2tLqpMDkl6fwWSb555/ii+/+iYRSWNt52cK0M/Tjg6muqQt7WWQKj7x9bcRqSCVkmhFhxVPu880Eok+IAPf3G352Evv50/+kT/Br3xhztR9BZ2WBPn7uL3XYJcnZAKasuLg7iOMbbCJBGPQRqOTrgdY25ZEBDbXe6Q7TzPV28yOAxtbsPIbXMmGnSuo3OfaZM7lsSLTSdcN8wF5YaMeTrbo9QvU+RkK0bmGRPc4N1rjuBhbkqI7+PK4c/Y4upis79ICqITgfec2bRtEbDsnoXNIJEmScXQ6Jen1MUKiYkQpQzrIcJUlWCgbgVWKynoknf8wTUbotE+uZHfoTzWld9TnC1RjkfUSu1xQhxletWTGI5RAagVSYXXGso7ICP70jDR6NOAC3XsQoHBEPFEqCK4DPgiFkooYJTp2CVmIgHdopZFCE4RHqHCxmpHgEYTYyY5NVDz13pe4+8ZtZkdz7qxi956Q+NaTK82xikzvw6OjNxhtb1COnuI4vs5JVVFHw9ZBQmErNsenbAwMYr4gZppQOlS/IJ6cIjaGiGVD4h0x1Zzf3+P8xNFTM2yEMkpuPVgwO/0Gx1XDu97/LjZ2L7FYSu6/9TXy4TbT08j2TY2LOedff4P52RSdKFbHp8j6jEe/8stc/s7vxjz1NEJnhGqJTAcwPwMliMUusT5H9DeI9RKhQKwPUZWnPChZH4/5qQ/D9MtzbguFSCRBKJzuxlSVUvgY0KJrzigBRZKgArgYqEPoEjWtO4R9ApWz2BDJQlcEFARilnZnWNfSWE/rGspVQ2fMvNg9877z0SmF1hqjFYmItA3EoIleUFUOtCAEidYCLzobZYwB4SxtW0FosDFSEUk12GaFc92ESJI50ryPMCnWWlwMlNYhljNSpnABm/I4GudIZAfLsVEQo0SiO3efVHivSFtBGiN5ohllOWOZ/Jav029JcraxvsHh8UMQDfunkcm4R5YVbAwHHM8WvHr7TcpGMygSbBsYb00o6ppLkzHHiwWXdzbIe4Yq5Bwcv8bVK9sUYklbO+7eP+bGdsb1jS2EMly7fJXj6QkqlNy7+zZGCFZNTbmsSXXCeJiQJYGy8fjWUzcVXik2+gUGgert8pXXHvCeZy5jXYUxliTWKOFZnlfY0NIb9KiDwdUtR/6Q4ARnsyNOTxsGqWAyGTCrFb2k5ux0Tl6sMRlJUmFpXE2WaCbacLK0uKApLnwf1eqMUKSUjeNzX36D4WhM2zbUFRRJig1d1bk/HHR0LSGw0QLwcO8h/aLg0bnn3uGUIDqvVwidADlNU0K0ONfigyfLcxbzKc476tqSJAIfHbZqsdby5LVNfu/HP8L6QPHowVtEoWhc52dtrWUyzFGmx+niIW3rMDLh3b/rO2m/9/tp/7P/ExV0C60SympOnqTdAqSJrNKUd5ZLtv7166gbIw4Wp2wWA6KY07icyRDq+X2EScn6Y97z4Q/z+ltvgPO0zvKLv/jz/K/+9P+RKy/++xy+8z9ybXuHR+c5i+pNelmGiyfUZUvZtCiTc3j/DpEEHXOsTdl47nsJwxtUjWN5/oif+W/+HE21IpGCrbUeH37xKiezKVe3t/HNitrBqFCcL+aU0dMv+jw8PWCg+5ycHbI2GGJdTTWdohPDvZNjkrxHbCr8suVevWTSS1gtVwiZ4twJg9GEvb375HmOjo6z47ssVhYhHWV9xnk9Zm33CqNM0VZzWh3QeA4f3OPh3iFbfUPZRGx9FS08Hs/J4TFp0WeyNuFs8Ril/zi6ePXWIWVdsTnp0zQC6ztQhHOWJEmo65pyZkmyBCUFWkiqqiHLDM5FQozUDewdLjpXkLX4uiVNU8giNjiC90ij8SFQjEwnrG8DmdZYH1nWLUJ29Ksou92RNDPcvn9AVXvKVUXwEWEkp6sWqWWn8QCEEt8UNkcEUQoEdAeuEODCk/Obf0opkApiCCzOTknXNynqFTu7lyB244dN23QIY6UYpAmjyRab166zdfN5fAx86td+hXsPz5FKEETESIXUIEyXJAJ4G7AliCD4jvd/mD/5U3+Yw/k5/bVHPNmPPH/jfWgduLZj2Hu4ztnD+51GoLEskwhaopVEGI0Xkhh+0/njef2dY0bL61z+0ACfCMo68OS2JgA+Kp7bfg6jum5i1/WS3Q4LULUlXsPWeMKtuw8JMSKEpFxamtoSQsTIlBA7WIhUkmD9b8t383H8zy8WLhKVwbQOHQMEj5RdB0ET6JkUoQxRGkIhcHSTLVp0LjHhPdgWFQXCN2C7c0jrLbXvutypjGgpyLIEpTXWQ+GhAZAG3eszzg2oiLcgdEKadpRsk+REIRlnBQ8+aZFYhIjgup0z1EWXRyo+9N3fzWc/+SkMCucCUUba4FHELgEQkhg8bfBkiUHIrtiSaN1di1LiQyds7/eGfMfH/yC3b/9/KcWCOgZs42lsS4iQaINvcs72Ss7OD5m3d2hMShU7J1wbI4erkkXWsqw0mXAMKos5OEEUBW46w85rZKIpdregXRIONdOjBeel5eiRw9mEI5dwe9/zaCFITlrKrz1i9S++hOilHN87Jczv8cH3T/Dlgmp2ytm9t1kd7OPnp6jRmLP9R+xuTVjdv8tgOESi8KFBjQKyyKG/hkgGCAlIgeivEXtjxPwUKc8oRoHInJc24cPrktNjz2DcpxYZpUg5mVti7QjRoWRXkEsSzaytu++E6CiyoqqwYUqIF78Db7vd5ChIpSBPNCCpEbjoqWvLsqw7ckjwqO4mD97ho0dEvkkYlTF2xacY0cagshQSh857pEoRPHhx8fLdHqWtWhrnkK6F6BHBEnEgFGEZCLIG0XW/At25mmAxMnQ7cVp0o7sqoVUKaSRCKKQQBAkxdAh/hSS4QGkriBItFPw7jJV/S5KzujzjmcvXWFaW3LTEyqIzzeHpIQLBIMk7ZPlqyVLkRGMYGM9Ru2Q8HvC5r32NXpbQouj3R6RJStZfx9YNZtuzaiLXro25de8BdT3D6IJUFbQ64fjoPonWKGOoXECKEYOewtgp5yvo5ROUFFgnmJ+dUtoTLk9SXLsk1ymDdMC9B/s8eXVMJQKrZQ3eMuo7RqMhR6enSBloFpYnLw0pywXEwDhxLJcLtjbXKOfnzE4cCEiyDN8aSlexWpYYmeBEQ6IyVPQsa8+//NTXaZ0lSTRNVZLlGVF1COS2rUi0Ic1SmtbhQ+TgYJ/xaEiWpoTgu8VG53DO0VqL0RopBcvlijzPsKVFEJkuZoDEeUuzbBAE3vP8k7z0rmtcXsuZTIbce/SAnY0dajfD24APkmKYYWPDcj7lbNoSo0AFR/+7foBH0zkiBmofsKEblbF1ie7WQhAChDG8ahJefPOA+qv7HCeWsBbZ2dkE66laz2L1CsicpU64+cQzYFuy/hDtuy7bP/p7f4uf/N/+hzzx0p/i/q1fZ6TeROYJ2fAm9eIRq1ax1i86gaDS7O5sMU2fJd9+jmXIyWJk7+7X+Wd/9//NcnbM1tY2TTnjR77/O3jPM1e6fZa0R5YXLFYLbh2ec2N7m94gRak+W5sSKR2ZC4wHiv76Td5+6x2KtEAnmuV0gSyGjLKWerbgrXtzNscFg0xAMMQI6zvXWM5nONMJzhMV8L7b41vFPuubG6z3DCquc1ZaVrMzGluTKcd8vmJVthAdVV1S20BmNFVZUS/nzOYnfM+34uJ9HP9/H613ZFnOWj+hrCMHx3PyXjc+V1U1eZ7S7xk210YsVyXXdrcYDHu8fvuARenxwPo4Z3d9jVsPDrExZ+k6HLAKgixL8bVAaU2eJfjY0tSRPEtwraVqfPeQl6BENwK4tpXy/hefIJOOdLjGr37iCzw8nkEMTEvbHZyk7PahjEKZzocWRUQKCaH7t0SMHX+xm3lECNFBR1znaBRCUi9muGpJnnYdLhc6+bKWgu97/4vc/MBH8FGhej2OHj6kN1nn23/4p/jQ59/iS2/cInoIRKSKCOQ3O45SSNrguXnpKj/5h36SZJCzVUjWd9dJFSiTcf/LX2Dy1IDDgxNCNEhhWWauk7GK7tQXLwAjQnaJY4gCk27Q39lGmoQ0z7rRH6U6FUAQ9CO03jKra9KkzzjtOoYhgtEZc2Gxw6uE+A1Uquj3DKtFR+EFCaJLdAGkgDY8Ts4eRxfn8xVRKFKlyJRACQ+uRgWHl91BMwhJEJIYFQkgRET4FukctmoQresKKQK86/D6TVvjokDHSBOhzQw4zfpwROoBldKajKQ3wKpImilUlrF/WiNNhtIpmASlM5RJGUiLXVX0JbQu0HqP0aoj0IoOZT4/WeBth12XEtIi5cb1J3n4xhuI4IimI6wa3eH3YxRIqUh1oPIOLQRSSUSMTOcr/j//979I4z3ILqFwrrs/RgEmMcwWK3rakovINNWoNKc9rxj1DKPcMBp41q+OKC6t057NOH94iHnx3ahUEaXk5OE91tfeg5/PkfWc2LZYJ9D9hGVreXBe8/aJ4K2VoCTlV94+x37pLrujIZnRTHLNc88PePrdV8mHBazm7D75BKv1AQ9f/jqjfsLwuSew5ydEN0O0LXKyBskGauMSpAOEyTv/mC6I6RCaGtwZ8WAPkSiYDJArS2JWfPypnM/tr3jrPLJo50TlsR4QF93KGFER4qrCxQ7CIkJEyNgVltSFbzFEYuzOiyJCkmhKMoa9ASoGcgI6QlAe7yO+CVhrCUEitEQRUDFCiBdj2nQ/9+J54KwlInDK4tEkaYZWksIIRKahgVI4bBUIPuJtS4y+S7a0JE8CQkV0qgiiewkhOpl06CY8HJEYPEZAIh2ZUojQoKJGiKx7BiYalfXAJIioUUoTZLzwB//W4luSnBVFyqypEUiu7E4QyjA/3e9mME2GVgpfndM2HsGK+/cfUleeJO9jbYvUCVmmEI3D1QcoD6t5ZDga0GK4tG7Y33vIxs4Grm5J8x7eV4Qa+pMd1vo9TpaWjVQwHE1obEtrweQ1N558infevsVouMZ4/RJHRydkiWY0GXA2WzGIgstPPkmSJYzRVG2k109RqSFMz3jx3R/g9VdfRYYV7bJi69KTvHX7Nq5uSE2GmJ2Spjm4zhl4Op2xNUixszm7kzGnc0fQGbPlAucaFqszvvaNW2xubaFMyng9wbY1tqqpbMOgKDBJyunJKYPhmJOTEwb9AYN+D60NVdPNvXofCDHStA15llBVZVd5joEQPEfHR4TYjUSmSvDCM1f5+Le/n41RhrclrfWUZcWkPyTGhiLtkSeR2pYsVyVGejIJVRmJKHQMFFvbuNcOSSPMowClkCJAVDRtjdYZYLh0/f1sr485PbzPzluHPPFD76PIU1rr2RpmmHKBtymr2S2CUGxceparN25w+94dxuM18I5799/h7/yV/5o/8Mf/DNff/xOszu4QZ+9ggmI5L9m8NEb7kuHlF5C9K5TjK/hGUFqBSjyf+aWf5Tc++ctE29DLM6Jv+VM/9fsIIfLZL7/NB999lfOTfYiaIFOCDxzPKyoPa0PFxjBn0bSsbwwgBO49uEuWJ/T6Oa/fWnL98haZSVi2gd21Cb3hHNOfUBQp2rWYxFC2Hi0jbTkjLwrKssF7w3hrjU2TUZc1i/mKtqoYDPss/JzrN5/mzTdep1CeED3CLfHRM52dsbm2xtnpIb00xZaPd84eRxeJ0bRtTQg5UnhC7EbgdGYQbU0MkcWyITLj0uYaa+MRq3JFU7fE2CVBIcKlcU5d9jier0gSTYwaLy1VWWNE8U10cLSS6AO++rdyau8C0XU7Z1JGtsZrfO5rt+j1co7ObnGwf0yiNEoJqjbio8AoSfhNbLUUXVcMgM45cwFCvgCCBOLFK8QOduFDh/h3VYlvKz74bR/mPU/+Mi/feQRS8JMfeTcf//AHuH/7EblR2BZOlws2t8a89+Nr/KW//Jf5uz/zt/m5X/iXzFYVPoBOFCJ2CWIQAo3kh3/oh9CZoAyW8XDIZ98MvPt6QIcZzv5zstpy9dKAB0cFjXCIRKNN59uxoZPdRyKSgNQCrQyXrj3N6NIGQSrOFjVRQpLWvHGu2d3wvO8ytG3J/UXNyhR8dEuQSNBS4qNk0htw/cplXumluCjxPiD4t0vn8SKptdahtXgsoX4c34y6XCBkgtOGUkuUlhSmTyI9htjtpl8AqdLYQojUznfesramahtsCLRtS7Sesmk6yESwuNZhBBcJHqRasZ9I8kQT0w1Ur09RjIipRgVDXAVQBUGlSF2gdQJC0rSRV7/6OrLew2uPDY7nXnyO22+/Qyo7UbALgTe+9hWMCJ23TQjaIKhjysoJeloSQlcMUUF0Go7oiRcjdSJ2f3ofECIgRaBvAlJ2BXDQiGDpaQMhsHt5g75McHfe4oWJ5ldPPA/PjghR4H2CkJoQ4PgwEHsjRukQJSPaCZAG6SNpfwhOkl4aw8MK11QMtyec7J+wiCl7Vc2tpUMkGTs0DBONGUh2ntnBlYIntub8wO//drZ0l8C0qwVy1rBz8ymU9qzeeRNRFAyuPYloWsQ4R1x+GuUVhAA66wYDTAqxQFhHlCOEmRB7GTGPiEx30wzC88TiiG8bT3jj5IQmH+BChRCg8BjZYfURAqk7SqwPDhkVQnb+W2UURkmI0LhOweJdd0Ztbc35UmCynDwbkGcBLQOjfs58OWO6WODtxT2f0I2zSroGhfcgFFZIpBAkottP9lKRmBylc7KiIM8y8iyhrZfMpycsF+e0qwWqMgjvSA2ddzdNUCZDpDlSJkStv7mHR+zeV4gBH1pyAZNUk4lI29RUPlC2kaALZDYEnSKiQipFqzSl8yx/u4AgdVUTVcX1609ydHiKDw2xqkh0gV/N6ReaozPL2qRgaFLKpsCxpFyU5P2C6Gco1adIc0QxpGoanBVMz1dsbGxCjPQnGwTbUFeBJHEUKmEZPDsbm8Qo2RAtaarw7QofDZPtbZ4YjTmdzXnqqSeRRnF0MicoQzocMhkP2d3sJNSnZyc8eHRKCIHhxi6P7t4hTSX9POH45CGuXXH1uZscn5dU1YJy1jDaWCfWC4wpUCJAMaJIHFvFBg+PjuivbbOKBpMv2Vjbpq0nuGbFK3dOGI2HDEYDfNPQNvWFk8aTmQSTFzx68JDNyTreeWzbMhmPCCFQVWVXyfGOGCNN05AXBU3TEmPAGMPp2Smt67wiRZLw/hee4f3vuc6zN68xX7b0RkOKZIfz2Yp61VAMCh4+PGLcT8hTicSio8Ne0HUWi/MOEqBSzGBMs5zTi7AQkSxLeO+L13n9zXus6sB7P/gRfs8f+BPIwXW88OjQEu58Hbv8Ko4ShGC2jCzmK6KU1O0h830LUfGxj32Me3/nDsvZlDzL6GvD8cED/s5P/wU+9N3fz4c/9nvJbjxL6wXrV76bECVcAE68j7igIVa89eqX+Pwnfp7p+QnRW4yC1Bj+b//5/4EXn77Mf/nTPwO64Nj22d3d5a17jyiblqeuPc3ZdIG3CUYMqauaXFikSGnaBVk2ZNjro6TgXc/3u93DVDOqLMjAcLzJwckJq6XH0qJXNUWR4WJkfXOLo5NTjC5Isk4kmeiGB3ffJElTFJGz83Pc6pyDoxl5pjk/W7B96SrzckndWBIsZbUkRoclkhaP0diPo4ssSwhtg4iCVVljVNf9SYykUooQPGmqOZ0uEFKzMejRVhXT+QKlM5LUMJ3WnM0XrG1vEW4fAp0zxkpwRuBbj0SS9gytbTGtJEZHHWyHog4BpQxIQRSar775iMWqxqhu3KNIM1rXMswStOr21VSiOkKj80TdAT+wDSgDUnUjLKEjwMUQ8N5eJB1douGtQyUJ7WJB4IzR9ov8x//5n+Ev/IWf5nqS8qHdHc4f3me0ucH+wz2sVIw21ljf2WJxeJ++b/kTP/WT/Mjv/g7OFxWvv/4Gb95+i7fu7OOjYL5yXH/qSc7iS/zS61/mpRub5P33U7U156tI3fa48tzHac4+TTn/KFK+TNQKVEes9M6CUETRjWlKEVEykmQ9tOnzG99YkIwk3/auMXXwHC9aPnLVMxzA6fKUs9WMmGxw7hRfmEY+MhFoIkpIogyookeI3fPA+0BaaHx78ekIgRAS1waCiwT/WEL9OLrQoutcGyNRRmAEaKEhdqRPISJaQKYFW8OEvb0DWhLmK0tdNtRtTZQBX65QzuJ9C8Gyub3B8aMjWgEq00QfuXJ5javbgQzHb7w1A9k5sXr02FrvIYQEnWFMQaI0vTyhmZ+SKMHs5U+g1SlCehKveHjnAddvPMX+vbsXeBtBDA4hYzfyKySxbbn35itIGbFeoAVoGSAEWtd1k4WUGEGn+dAJSZ7SVguU70Y8MxEJEkQUqESx2U8ZmpaqXnD93R/gq/fu8+uHC06DwIWIlqbbs3IBaQpKW/Hqy3OeXYebz98kVBY5dfjKkegEv5gTlwV6OCIbbiD8Hlk+oCwtKM1o3RAqx/sKx1CeM+0XhJ1ryAdv8b2/9yNcffoyuIhfzDErw+ndu8R3Xmfj+36A8UsfQhEI9Qy87cbDdQ5ZDyE7+IvAEpsKmlV3L/UHxIM3EHUNPQNREYNFljVZL+FHXpQ8vJPyNUa0uiMmyhg7YmOEqBVBdPc3pyTRC1KtMErQM5pBniHk/4+9P43VbD3PM7Hrndb0zd+e9665zszhHA4SSVGyJEpy5Mhux44dOUg6bXQCBAjQyY8gQNBoJPnjGEG6M3Ta7XQngBM1utO247YkW7IGa6AGUiRFHvLMdU7NVbv2/M3fGt8hP9amZCC/ZBxABlEPsIENVAFVu2q963uf57nv61Ys64Z104D1NHWFxxK8RAjTDsZUitARFZooSxjHQyLVZhg33qOURARL0zQ4Akpr0BFaaSLkZYawJHiBllEbFi0ka6eofErtExoXUVmFCAaFpA7gZYbDIEUHrEJpQ2Q1RpsWwAQQIIkjVKLJtKaXanQocdNTyosJs3VOJUrCuqDXGdDt9HFRh6IR5HVD+NcAMn0szVlkBgzGmvfvHhI1JTcODoi3ejw9fEqn10EqwUCnJFHCbL2kqhRJf4RYNQzTmMRoTIC0G2FJsXbJCzd38SjmhSUETSfNyIsVnaFmY9SnynM2ew2pkYw3R7z/4IzlYkmsNd7XuKbiaDmjdI7jsqEbR4zHQ7Y2DnAe7jx4xuYgYp1bbFGgtWA0GHN6MeONNz7JBw/OGW6lxCrCXIN7j8+4tn/Axfk5veGAUW/AtFrigqYoajoKIgXT5SlJPyEzXara0x/dpCwrNnev4qucF9WQ9z48pFjm1E2O0eaS7qIQUrGYzcnihMY2VE1Dt9OhaRqk0dR1jXft1EAb3fo1aKlESgpmsymOwIs3r3Fwa59Xb4x56foVjk7P+OjBIS/dvE2Rrzg5mTEebeLElKLOGG/0EEIxWU4QtsU+Z2lKMCnL+bsE7+hvbaLSjGK5aB9qH8jXBTubEcPhLX74yz/Prduvcf+jt7j/5m9yMZ2SJRGf/dEfR3X/KqvTd5mdvIUKjo2hxwhNVGvOl2eUT95kf//TvHDrGh/de0hVlfS6I+qqwruab/7Or/Dm136XGy++yu3XPsPG3lVMkiE8FKsV52ePefzhOzz58F3m8xVKC0SoibVgNBrwlZ/5GQpr+cbXv8fZ+QwROb7x1n3SSNPrDhgMRxzNKrrpECctTblkFGu66aDFw5qIjqiJYsG6aKUbzaLAuTapr2oqqOr2Ze5zAoq03ydVFllZnj59hjQdgqsYDgZoI6nWE7ppRF5LECUX50dkiWS9qth68TWKvGR2esh4bx/8AkJMN9JYDKsiR8Wdj+PoPq8fgBICZBRhabh+ZYt7jy9w3qOMJOum1GWF0prNfofZbMm37pQkSrFalXR7Bmsl3jlyq6nnTQuYaBpC1IYkSwFBthsfpSWdKCEPJcYk0LTSySjRrXckBBSCqqzQtKHIWkrA0000hYWyrvEeXAitfyV4grfYOrBeVsSpuyT1tg2FCy3gKATR6vpFQLR4V3xTMbgi6O0MIcDGzVf5whc+Sf69OyT1moExiOkZG7El2xrifUVx9Ij65AnP3JusqpraWkabW3z2xhZffuPnyNIOLgSWFr7+9pRf/Sjm0ze3eHHvJtbDT7+uOZ079oaBJPppzlaPEOoRIm4R08potJKU1qLUpdxTKSQBA/SGY2Ze8bX3DTeuGz77miORglUpWKyWuGCZl1OSjmarn/Bq1HrtlBCtTT6AILAxWvGXf/JHODo74o/f/pA46bKcLgm2jSiQUmKMxjYNSn4sH/XP6wegur4gNjGxamM2ggx4LEKY1iskBdIFNnp9ptMJQSfkszWhqpHekSkIWHQWEQmBIhAJg6Yi3dmglhIpPYIWFrQ+c1wEzc39LWSkMZ0BJuujtSGOE8rGo7WAUNM0NTf2upz8wXvUh18jFjVSQCMFrq6YTC5az5GQSOHb3EQp/8SrKaVCylZuV4cGgSYJAmk8KkBzad2QSuAE5PmaJHKkWuMdeBlIhLjcwlkUAVc33NgbsFyvmd79kN3bN5HzBZF1nJ1NyOsaIaCsHM9WFdIHNk/PuTZKsB58o5FOoGXcyo1lRL6E2HpMd5NlXnP4cMnFOmZFhFAxS5/zftVlPOwwev2z5CcVr29rtl64CSqGOBBcK/Pb+fIXKI4PCR/dIf3EF9sstTgCl4NtEOUc0hRR5oQkxqsI4SuwFeRzRLUkaEnoRIjhFlQFYXqGiDQiLzkY5XzZRcyWG+QypgFK76maug0PF4I4iiBAGQJCarSEREkyJTBRBFIxMIHEtVL0Yr0A26CEwpiWsrgoG0orWFSOJgSkl4zSlDqUBCVACJRULfUxBCIR6EiB0hIhDUpqHC1FVFyqMoKApiloyhxb5wTbDvikEHgtLzeImuAkPi/b7bDWxDpCIxEiIBF4pfBFQpSmzLVnnltS0RCHmK3NLfr9mkZKaicwpkdQCXljibzASEnS7f+Zz+nH8sYO0mDXJS/v71KvS4w2LJZrdNRBhEAcxVRO8OxkhtQJWRyRBlBZhg2acb/HsNdjWVg6acS4s8ewk1B7ico8g6zD2eSMuqwIbk2tLUl3yKqyTNcllT0iFg27G2PuPD1j2OvQ6WWkGrIkpqgsxXrBS1f3OF87Hhwe46xA6QGeOb3tK8znM/LS0e8Pabzhxeu7JFlKJBxSC4adDmeLOVvbOxwePqbbS6mqMWVZkHViyvUKa2KkHBHLCKkVHQmhXrKuapaPC/a2xnR0zc/82Ov84q/8AVEU/6n53HuUMVycXLA5HIMQWGcRAuqqxnmPtY4QHFEUkec5aZZS24bgA1XT8Pk3rvOZT13n9o0rzPOc1XLF0dlDlosFqRyymt3DygF7mz0m03OioFjNzsm6A8q6aKUv0lDXFXmwVIsLKifweDaGY4RR2PmMIANpv4OY5fzBtx9xsLnLer7gG7/3qzw9OeL05Jh3P3jI/sEVnLV88bOvsr33Etne51ieP8Mu32Y9f488b1itoAwrtvf2uHk7oxvt8c7dM5arOWlkcKEmMil1OefOm1/j3e98E6UMQoo2vDaE1uQpAjiHViC8RWrFT/zoF/mxL36eZV3z4YePuTg5YlmVlIsFSRZx9coLZGmXWAlss2LQzegqiS3nTI4nHAbJsJOwKi1bG7t0gkQjSOOY0CxZVJ7rt67znbff5/TwBOUKbr9wi1A7Hn50j0TXvPTSbW7t3eK//ie/TrAFL966SpZotnsGEUUc7G9Q13A0KdkcdEhHmjJfkJgCKbusliuySGF0TFGt2RxKTBKR6ueXrefVVggOEQLLqqKZz7DeopQmUhKnA7ULNFXNwcEmN/cN946nnEyWrUzDORIZI4LkycmUyXRBtxszdRVSaVbFGqREifayL6VEqoAxEXVVkfUNWknydUEImuDB00qJrG83Okkak0QaT6DOLf1MYnSAIHG+9WEa30qCaltjfOv3aCUlrdwx+ECwrddM6oBmTre/Jk0dvbECGoTMCNWE2XLJyXLFy1d26SQptXVs7mwQdWKqizOEEhRFhW8qfD5DCsXFs6ccPX5IbS1SG6I4o/CaNNpjT0f8xGdepJNmSOVwXpHGljRWSGDz5r+N5wMmD/4F8nJrxqUER8nLUGjRftArAabT48l8Qe26vHzD040FMuSY1e+xfvYKYucFBp0+e5sHJFFMEO2/gwgtJMX6VuLz8z/7N4n/asQ3//gP+dr/8n8NlSWOIgpb/8n2LIpi4jhtNxTP63kBRV3ifIOWAU+F9wHnFfO8jQGOdXvO82IJSuOFJM1S0sQgSImNQsuACg2pa0gpuH7zgPOLFZNVw8KDEBLhPTZI1sjWAmEMaadHkvVoVELtBaIRuCAoVzOCt6gA+qThvX/+T5DyiBDa4F/vJZHylMtFG1atQEsuPU+eOgS0bpmkQiosDiUkWniMsbzycz/Ds6/fYX76DBtCG2ItJf0sI0LR5Dl17dBSIkUbY6MR1EGybhy5VXzuky/y+OkFD+c5WZyQu5pBt4dpSkIQaAnTvGKUBIq1Yl3EnJ7PiK98mtDEYE+pGpBVwOQe3x2zPp9QWUuJZ9YEFjKmxjAcbJCNO6jtXSZHa7bKQ1754i06xiAWOaIXML0e1pWobofu6z9BdfKAsD5D7H4RIS0oTZAamrwNjjZAqNp8M63AFiAsXgnEdIrIYsJ8jp9MUUVN6CdI5VG24mV1j98sNnjECJRo1UqNwwpLP1ZkGqQSJEiEDLgyR7iGhWuwQLfTxSiFFQnLumpjUZq6ReYTsMJgRWvLcbbBSvDBczFdYJIUrdotqLAVwZVUeY6JFFlq8DJghaey5SVkqt3GSSDyksRD5EocNVo7YgMyMkihCFIRgMY1OOtRoh1MFr4gBrS8pEXqVuqY5AlRlkGkIdLUQlCZBB3FBNswyAyZyUAa1lZQeI/VhhD+nIAgn7h9hZPJiqdnZ/g6Z793jYAnjVKuXbvOfHGGXed0R5t0uhskSTth3en2kV6QZRFlVbHVT/FNQQiCybJmmi9JdUIpA/v7+7zz0SHjXoxK+jx8dozyBeezkhduv8rrn3qN9z64j1KKXicjOI/qjblYLzBa46Xk8OQZHz6ZMpkX3LxxQCcJ1E3MybOnjMcjNkc9PIKT8zmjfoayBefLNRfn54z7QzpJyvmyAJ2QZDE2KFJlqEpL2hshPUjjONge8+HhlL2NPvPphEgnzNdLBAXzVU0SR2gjWS5y4igiXBJnVnlObCKUamkxSqtWM+0byqJECIGUUNc1UgrqqqKxnqqpuHWww8/91OvtmatWLOcLlDKMs4Szi4LSLwmyw2gA9x8fMe6mKFUy7CYI5TAmIpCyqgvOTk+BiEhqrLV4B7tb2wQpoSqRQqN7KbdHfR4/PWcYNyzXp3z44Anv33mCdw1SCk6OD5nNZ9x//IS/+FNrbl29Qm/vFifdr1Cul0jxCCEr9gd9muIJqyLnk598gcFgxJNHxzw6XpB0u9RFgYkiGu/RNHhfI4XC2jY8OzWCOE5omorgPC+/8hJ/+2/9dX70y5/h/odP+O4773Ftu88Xf+gV/jvuK+TOs7O1TWwUq3XOo4cPOXy6pl5pzmwrMxUmo6Nijp89RWQj9mNNCDXWB3y1ItUZgwE8+ug9drOE3Veu8+3vfEDV5EgZ0esEhBOcHh0zmd/l5oYgEGOaBVmUMJ958vWKuixYrZdsDyPOFnPGxoGOSdI266/T22a9nCGVpxML5gtPWVVU6jmt8Xm1ZZuAayw7wy7eW5ZS4D1kJmZ2MUfgKavA3SenjHoZiYkRLDCRQUpJYx3CaKarFcIovAok/ZS6diTdhPksJ4njdhjiwVmHdA4ZxKWcEbI4pixcOxkOrcRIK0USKbLMUDeBqm6paTd3enSzC6pyjNQxtrF4bVGRYjjq411r2hYIgnP4EPDWgStI4wWdfoExliBiTDoiZLfa0OWHv0HY/hyqyPmh2zeY1o7p4oLtg+u43gbvnh7zi7/yR/z8T3+eF6/uUC0ShK+om1aS5IJDOMEqL2hWObq7QX+zx7/z6Zgyctw7CYwHgjQSTFeS5XLNu4eOg7Fkb3yD/mjAYrFooUhSYEXAaImWoESgatoL09P5kncuGoaDmFevaiKxgPI+bvqbFEfP2N7aQTWe1UlDGG4jlQd7H9N9g6KRNFVBJ4a0N+D46Ix/+Vu/jUDjfSAyEbKX8n2vXpZ1Cd+XWDyv5wUczy8wxrCyDVpF7WY30pxPc4SRmChCqggvIoKUpElKYhSxNu0Fm4BHYAgUYU1eVQwqxeGkYW0dpdOUvsE3Hueb9h5DwHpPt1eTdRoqDFJHRFGElI6O8oiqIImgPLrA5t9DKUvwmtpVeAJOtI3Y7u4OZVEyXyzbxzoI4kjz0quv8MF7d2isQ8oW8qEFaJ3xEz/yP+I//8NfZuV+CSU8Rd1gIg11Q9GUXN3e4vDp49b/alqPVIxrh0wOPnxyTlM13Njps9+vqM+X1EGhOyk+d7i6BUoE13rWRuMR67zg/GTCcFnTcwuiOMYFoHSYoUH6GmUMcrRFea/gYlYjhoJOHFGWDdUyh3DMzYM9dkVCrxu3Qd0dAVKDEujhNm5RIAcRpTM0H9wlq/uoa69CvUR415IJky4h6RFs0cZqyAyGuzA/ab13SUpYryESyOWslZmT4DdTZD7jijnhyvwDfru4iYsUsdRkRtJRIEVBaVKUinAEqrwi8g2+WlG7hlW+xtg+JD1q0VwO5Cx1VeGCp590MHFCiiJRkCWSSjh8UEgMmVGkRlG59pmKRUqjQEtB5R22qWnqqoW8aYMWikQlKKWIlAIjSJVEiogqFtSdGC0l5lLiWvs2j09KgQweCzSNRdaWWAXSOOJitcYJgdK2vYMGxbIoaZocsBgh6EUarCTtKoJOEXGPddFQ0kpq/6z1sTRni/mafhZj9m8SpylaNPiOQoZ1C0ZoNFev3+TZ+Yy8Clzd3aDf6/DVb3yPT75wncV6BU2D9K79UI8irKsZJAnPTpc4X1M0Da/dvoLJYj66f4gKnk9+4hW4+4j5csLj44xrN69Res9qNSXJhtTFijTJePzkmI2NGB2PSKKc124OaOoZq2aTgytXmJeBrNNhnRd0s4xxP6LK1zw+nmC6G0wKS9McIYXAxApva777rT9GSM32cIgXiqJYE/tAN+3z6PEz5mfnLM/g1s3rvPvohP1RxuFZQ914TCh54foBd+4e0diaKIpACGbTKTsbmyjRGl6/b+oOl1hYHzzOhnbaYC3WOZpLRHJe2UtsviNOuiSiSyM8s4s1G1nG+bLhfFWSpGu6iSE4S29wwLqpWBUN4jKEtskdSdRFqi55ntPYNuV9++oNQoD8YoIXjoePzggvv0CiDZtbVxgO+pxcFPRHO+SLC/CWyeSMpqyQwvKr/8V/wwtf+Dw/9WNrrqQj3lrFSN/lxc1dvAscP5oz1l2k9xzs9Ll1MOLO3WNOFiXzhWK6aJvs+DLHyTcVSqgW7+s8kRF86Ye/yF/+2a/wmddfYVlUnMwbNjaHXL9xk9HOBirU9LqGm5FhMZ3x9CTnV7/6bT77+st8+GTO5K33uX3rNlkaM0wlt64N6GcRLhjKIqcXj+lmhjgSrFdrFguLScdILJOTc5oQCF4xnVzQ78Cy9pR1iRKe/b0R3ju0iiHU0FiUbnNmRp0U7y1XNvpERlLXJbYusNZT1k8wEtKsx6IsWc2WOKFYlM3HcXSf1w9A+dojtGJta5xrJ4JIyWSRU9YOrTQBS9MEzucljgXaCPC0RnpaRD5S4YMnVhIfJCoSiCCItMK6hjTNUEIho5bo1u3H1E1F1TSUhUdrjQ+OJM5I0whbQzeLycuasqoRoqXD3bo2pNdpGHRPWK5SAiMCCUpESNWC41sbrgVfIf2SNF2SdSzaeFzQ1L6DWmVgtnn23Ybs8D4brx4gaseBicmSHjZfIbMRMiyJfcw//bXf51sfPeHNR6e8/uItpvNzPrXf5+feuEqnrgkoZPCEoKidxySKl7/8BaIoYTk9YX+05vFFh+tbnhf2Nb/3Pcc3HnUQDwrS+pgfTzVxIXAi4HzAKEGsINICgaBZ5RClrKuI6+N3GF3ZZHs0xi+/Q1b/Atn2J9i5/RJRIigtVJNDytN7+OYDBt3vUo5+HjP4Mspbqgq+80e/x9/5P/59zienDLsdqgasdwjr8L71oglxieMPzz1nz6utve1tlNQkygCS0jrK2tHN2m1DFTwIiwYiExPTsBFHjKKYIAyntaVsPBdlSXAaSZ+zByU+GJoGcI7KtRsH4R2drEuV50gdUZQVaztH6QwZeSok3Swl63dJtMDZhuVHjxFigQ8O7ywG2HnxFp3hLnf/+FucnJ6jgV6assrXIALBOd595wOkUCjp2o2bUBRaU6xL/u7/6n/OcPsajRMtrCLSSCUAj4gls8WUWIpWpiclWghUAOk8lQ9UQfLoYgHrOZ//6z/GD+/c5hf/z/8Vx50xqtujKkrKsmTci9gdQNIdsKwWxKsce/YOJYZCCFbTgrgr6FYRwqQo77n1qS9jbv4Qw3nEh2/dZXl+jupHyKLE2CX+6ZTejRRlc6rzCWwNEB2NqBpWBXT7W6w+eI+6WbHxwquIckp48hZivAedLfAVnhRRlAjhQXoIFoghGiLrnNDJEDLAakpIFEJLUA5ZA/2YTmj4XO8Jv3asmAy2MXGXSEo6sWR7NGYyuUA2jrJuWBQFi/WSdb7C1TWdNME7j4ocqEuqIZ66sVgpUbLCKE0SxZfB1ZAa1XqRBaRZTF8KfAOL0JA3ilom1MogpMYqi9bpZfS1RzrLqixwQuFcm3enCUglLrezHuEhzjKiNKNyLQEyNZpIaqSSVM5RVhWuaairApN5XNVQeYdr6lZ14RpMqNDUxNKSeIMQEbO1QGYbBOJW+eFbxcSftT6W5swpja8Vo2HKvLCIpuBsVZOYBuccWx3Bk8f36KYJq8IxvQhcTM7Y7HVoXM16XaKFZbFcEnV7ZLamrgp2DjZoTqY8eHzKZ974Ie7efYfd7RE7ww5CCVZ5STYcsrOzx9HRBd9750MGmWE2W3Hz9oDGFlxcnJFGgrv3TnnlEz0KF9hJM5q64vT4AqkjRsMuh08PUUpgrkTUdcU8XzEY9JhdnLLR62BCQ5HPKFcNPkiGWYS1sFrOcMRYXeFVxHpiCcWKQa9Db9Tn+HzOjYN9XFngy4JYlqi0S9Lpgz5BCoPznuVySZZliMvGzLl2te68x3l/iZAOhABlWeMvM3O+X4tlgfQZ41GXplzyrMwxKiZEfer1km5kiEyKJiNIR6fb42I2xTlJUVXcuHrA4fmMylnGgzE6ill3BljXUsY29g9wzqPXK2SQ5DQcfnSXzd6AWNY0VcXG5ha28fimpFhN0VpTOcuXf+5nmP7z3+Dh17/JPzo/4+q1a3zy1gEmOGyzYjzaI+uPOZ5aoiiw3Yd7xxO+8hM/jkg7jHsxzx4f8uZ796itxTcN1lbEccon3/g0N2++wMHuNtevb/Do0TFPnx3RiQy1D3zt619FZUO6SYXRgsOLkiPfkEUebTXXN1N6HUlfH3Pz+ibbmxFWQD/yTM/PkLKlwnXSjIvpObX1TC9m9LOIrJOxmB7x+OiCw5MZV3ZGuHLFcJDhq4KmqYiNw7oV62VEFCcUs2fU1rO1MUZ0IwSSuljQzTrUIkJGhuV8xSDNKIsZF3lN8IHUrFnYhp3BFovliuJfI3H+ef1gVj+LOZsvmduGYrUgCEMcRygJSQRN4xASgnPouA2VriuPlALvA7Zu2BgPeXZ8RmNrdBwjlMQ1Fb4WrYSnsu3mTASCaFAJeOsoc8C2oZ9IRaIM3nt0pBGmoaodVdOgpUQrQRKnRF7hkgwtVmynJSEc0TQTEB28EARpkcGh4godW1oFb0viaqIOVmjCIiBFwEdTNm4Epkfw4GtP6O5qOrJL7WsIgaFukCieXsz59gf3qRuHVBEPjs+YXEx4cjTh/acT/ns/8hLXBylKVK2U3IJwBat33mTzs59nf7SNoOITVzVStu/da1sa8d6c2C0wqWZaSyIfkMpfYqMFsZZEup3y9jb7eJ3x9mqTrWHDj3yqT2YMOV0e3bvOqNOwvfObLI5W5PY6TgTS+ojx3ndx7jr1k18hiD1kso/wnm98+5ucXRxTVxXdzhhXV+1FQBqiKEZKiVIKIVqK5vN6XgBX926hdEQaR9jGYp2ntDVN00IXKizdQR9ftuS9gGR7GDHyOatKEqSiiQ2yXlO7hiIvKOwCERwSTy9uaX+VkPiQ4r2n2+kSmRijI7zRLQ1PxSilibn09TQBHSTNswctzEJ4IhxGOOoHd1kmNdZ7vG+3VL4qUaLFqXu4jOdwRFrhfMB5STrYZvL0MR2zYj356NIv196U68ayc/UGX/zKV/jGb/4WzXKBlIJIyEtIisAZsE5QOodAka9rPnP7R1jFr1Cs/wmVnxMnCTpSaKvIdOtRe/zhMxJXwbUUaz2nswlpd8jTo2Ou37qCFxZ8gy0KlufnjDcOePHKq7z7W99je6DpD3vUF2eE5Yx+t2Rn+xb4Bl9WqERDd0h5cohdrFlcLOmMB3Sv7SFVQti9gSAhf3CISS0qzlGDfYIx4DwinxOEI0QxIjic1EgVg6kgjRDBQBwjtMS7qvVd2Tmf2IIbH51QhSFFvqQgaX1Z522jQnA0HrY3OqznUzrG4JQCKViWDlfmGOMRps3N85dDRBscypUY5YnjmNrWaDyxlKSRoapyllHcenHXeZvrKyQ6eIR3NEKCjAgEYqlANORlzmS9wnlHZATDKCJIMEYiNNi6wjbQuKodBgpJZTUyTulGfUQcE7SjdB6R1uhyTZRUqBAwSITSyGBJ44COJJEJDIQjlAXrylGsJnR7hs1shCXC/2vQcj+W5uzs+AipYDZLwDu8kIz6GXUjKNcV51Zw+8YLbHRjuvMFq7zBOU+3n5Cvl0Ra42XC3t4+k7PHnC/XzOYrHp6dslxYrm71OH76IUVdoyLD08MjDvbGnJ9NKMqcnc0djs9O2BiPefLsjC997tOA5Z1373L75j5FUZJFBl+tWU1PeFCtCbYg6Y/Jp6c8OTrj2u6YXn/EdFHSy3os64L9/RH3H52ys9MliXt4nVCWJZ00oj/oExnDcLjBk8cP2dje5HtvfcBAB6TW1OWKizNL4yV5/pRuqoiSmMlFRVdqFtMzYh2xrpbUTQv6GPYHOO9p81bb5kvQ5u18X5ZiLw2N3/8CQAicc0wWBf1OQlXUbPU7FIXHN4FaGvKVJelEbHaHbO5sMup1effdD+h0Y9K6xFpLFrfQFl8uGXR6HD87xgVL5AL9rV2ausTkqzYAOziCNHSkprsxZLnKCd7R63XJl11OQkDJiMaWvPnuPT792qf41Le+xat/4bNMhCDrJeyObjKdTKidw9UVV3e3GXQSUhW4du02i/WMLBsTxQlXru7y4su3MUnCejGnEyfkVc7rn/8i7737IR/c+YDDQ8N8mbO5tcmVYafNRHGQUfDs/n0Oj8/IegOEXTDsplRWk6mE6cM77I36bI0G9He2cEERVWvW5ZrJpADhqOZLgmhNy8ZEKCFZzmfkqymGnBf2B9RCgC/AO2ZFTmRgldd04yFaS6pqSb/foZOmzOZzJuWKQW9A7iXr9RqlLSLdgWxIFTxxP8WVc/qDDJVkJGVN1svob14nf/+7H8fRfV4/AHVyscYLh5GBKNVUZUuGcl5QNy1qOOCJoojgHSpqfWPBOaTQKK1YrnIAvIOqaIgjQ3Atot1aj5ISqSTaRFR1RSQMzjqCB+s8g3FG7TyudG3D0TRIpcB6OqkmNI7GB2bLgqLIESEmJH3qskHLmjirEO4cPATpwQu8E4TGUIcUG8VUhcfngd5mjBq0BvF42Ke7Oaa7u8XkSeDi0VvtBXNRYfMVPjbceuET/NLXvkPROL6fAeYusfxpEvHh8Zz/wy9/h5/8xAE//cmrbCSGsmxwUtI8exf1uc+ilKepJd+4X/OjL0ZIYbm23eHfevWc3aGmuvjnfPjWpW9BtxcFqQSNDcgAyniEVHipMdmIT774MoP+NspIhjtvkGR7VOfHzOY1ZrzJvXfuUehNvvSpA8wwQppXKWenBLosFsfMVhMePngAl7lNWhm0tFjfxndo6TEqUJRrFsucunm+aX9ebTkvsS7QlK2n3aNxSiFle5aRCcsCUtXBW4fzjvOlo1QxzoGQEuqczWGXqioJPYNtalRTs7cTYVDka0sTpVRBY12bSda+ayIcAgsgJN0sISiITE3qDMe/9w1OvvsvMbJACkiE5+f+9t9EHU/4/X/2uyxVhJIO4TxCqPbSq1pycywlVgmaIIiUIqoqqotnpJFvNyoeNJ46eJomtP5QofjCD/8k73z9bZbiQRvIHVq8fpCCNI1Zlk0r5fSeQ6v4j//9/z2q+ynoRmxGHk+BpR3a+MbhFDTOom1gvfa8+/4TOp2YvjQEFTg8OQWlSCODDw3zk/v0k4z64W/w2gspTmfIdU6TWbrDlHE34+rVK8TCsT66T3ZzgCwi4le/QDx5Co3DLyfIqiDYBTQlbL2EGH8GIR1y0xNsCQpCukGIKnBLaAoo50jvCFKAiSAk4Jt249MEWOSQ5xBgmFZciS3fWNU4Iwh5jtYJ59MLQhwTxx2aynMtkhReoqTGqxZakhpF1Ticq4hUipcapVoATeM8lS9RomaVr1tvLp4SjzMSI+GiqViXDY2vSSNDL4rpdXpYLREiQvhA6WoKXxFcQ1OVCFuhQus9RAqMjrChHVQZAb7JCQIipTE6xjlPVQTyKuCCQdJCsHSs6XbGzJyldgHt2ifYOk8jNd46ZosZM7/mSmoYdbt4nULSw4qIWKc07s+J1niwd8AyXxCZhE4aMVs3xJ2UZr5ERYpOmtIUCwptiI2klBVCpASTUNSe+XTNcNjlg/fuYJslwge8gH5/xMFWFxFKtscjepuS08Nn7G0NWM1X1NZD1OPN997DCMn2Rp/BoEvc6fDbX/0D9rZ2KOuGpmq4desmlfP8hS//ME/OCk6fnZKlPUb9lN5og9RoEl+znK95/PSYRCvufnSXxq558mjKZz7/Rc7nh6hEkGZwOi3Y2k6orGUxX1POj9kfGGIlqVBYYyjKHJqa0ShDeMfkfMVmr0sQ0O/3OZ82qF6fqqkxcdImktMaIf1lwLMUAq0U1l2GTtc1IP6kMWuzgQRb44yInHuHbbL67taQ8VbKnQ+f8fLN65yeLyFOWDnBXpzhCXzpJ77C+++9x5vfeYfecIBWcGtnkzAcMdzY5eKth/ggGPSG9MbbLOoCX+QIAl5oPvvpT7B4ckJ/2OPiYoaiDR7sDjd58dU3uP/e9yirinffv8sjrflKU3H89bf4sX/vb3F2eo6PMkY7GcNOTFkUnE9z1qLDeKDodyRCWp49u4dSGZ1EYsslxhgmsylV1qOqSn79n/8yayvZ39tlmGjqxZTJ8SGLJyvOJnNMqBFVSkNKkiZk2jMvBKVPibSjLguKfE5sYtZFRf3sIVnaB00LXenEhKYgUOHqhiSOmZcrErHGlQGjGoIriXspxnnKfEUdGoZxyrLI6XV6zJY5WZpRFnCWO3rrNRsb27z20mfZufoi3/7Ot5mePKVjDEkQbHVHdIYb4EpCOGZaOHoy5aWbB8imZvvqwZ88K8/reWktKcqAMRohHUrJ1tBuDHFisLXFVjUiikCCr21LOAstRVBIQXChnRobQ7EoKFRFp9NBSFisF3SyLkpAFkdEJiM4WDmHMYqqEZSrBh1pnBRIpciIuDhfUjtPbFrK1jKv0FrzrKg5WKzRa0EySoiI0WkPRYvxbpzFXlSUJw0hE6gx6Aa6cYaiDSclUkRZSpR0wA+Ir9xmd7ig/+J1vvPLf4jyniQ2dLIeg6sv8M23/jFKytbzIQRIQTdNefn2AW/fecygG/GHd4751ofP+MlP3+THX9llpARh/2ZLgBOBONH80A2HrS3Nck3aj/jhT18HLJP+v4O+95tUy/cpqwZrPbEWxEl8OR0OOOdJBz3+5hcPSHvbfP2+4KV9yTi1xPGYeKSYX7zL27/969y5/4ydH/7vkgxvUOjXSJKEwas3OTl/yjvPHhAnkqPTM7SUCAnCV6zmk1aa7j3WBbwPSCUJIRBH5s/5KX1e/6aUDjnaayIVk5cNXsdt1IM0OBRKamofqGgBGa6x5Ks1pRasmpqmaRh1MkJZt+Ae1+Drmrpc8vbbE/q9jM3RBlFnCDJGS0PwLbm1sL4NlZeSwGUzqBps8NjFOedf/4cYDgGPDDU9Ifjs6z9J8lOv8v/55Xdw9hytFTZ4FtZhonYb9P3cQyMUAYfynswobHCXWHyQwaONINg2XkQ6x/Teh/zn/7v/gJOTUxLpyYy5lAODc47ae5ASUVukhFII7gpBVN+hn0SkoSFLUooqcHl7w8jWi+sjRVE2nJ7N6DcJi0VDksjLe8YFV3c26XYzDl5+EREMz/ILRrFEJn10z1BOFhg8w06HREJ3c5NkmKB0SyV0lUZ39xF+ghp3wYNQEPKCMH9GPEqRVUmYt7lpRH1EVRFm5wiWgG95dFIivAJbE1YN1bpGVBX+4SNEURDtbyE2t0nykpe6c/qna3IsImiaWYlWkDeWulwRXODd+QKNIGBbH5dQ5A68jpBRgk1TgjZorUmtB9dQlTn2sikEi0dQBkHlJNpIYinQJhCh8SKw8BVVIZAmw/kGZ8OfEIqlB6FT4l5CCI4kMgjTbq9k8BjlULamqnOqqqBqSoyoaRpL0QSKsiWNRknEoNNjPBiRpQMa55FNg1aSWBsqYWmcRUhPDHiRsBAZje9SlYLVcoXRFqXzFvv/Zz2nH8dhTyJFd3CFuw8egO+wWi2YzKZ0Y411klgXzGwHFTyHJzMOLwryRjHe6LM9MDw9PqNxOxijkHoDnSoyAjrtcHp8yvagC1Jy+vQMKzTzxRwTZyTaMBh2KG0fEXc4vlhg/BJfrbm6s8/GUHKeS24cHPDo4QMIhn5muHEw4IM7d8nrCV7sUhU5nWxIZmrqUNFNFKOu5OFZycZGhjZDimLOMIs4nU3IZJdB3LCeOE6ePSQRNUJapACXTyiCQKoey+UKnWQcH52TJREBw3S9ApdjS0cQl2kdStL4gLWu9VoEz7/qEGihIIG6blrU7b+yIW2/9/zQZ19mf/c6pfBE1uEKT6gFL7/0Kr5ZsL3dR2vFs1nDsNPh7Q8/Yjxbki9nfOq125RNwWg4RhjDeLxDXa756N59cJbB1iZ6OGL1+COUs0ggzTosJxdo4dBGce/eMU6mdIc77N/Y5NHd96mrHCEcrqloXAOf/QJvL2d87mJOJzKk/TGLyYza+RZKIBO6FBxNoJyvePD4CVF/m52uRBrBcnaMDxGTxQV1vOTp2SnadNje2mJ1ep9JWSCTDbqJZbrO6WUGFVI6PYMxmmAF09WKUaaR5EgU464h1xlaGebrEhV1iKjQKiJWsChWjLspAknhSkxYU5ydoG/v8eDxCcoYBonG5QuSUUYnUvjacnixIu6MGcYgJhfcOXpKnO2wv7tFJ5zR7wmCg+m85NqtW3SSHkoGZssVu5sdojjh4ZMz0k4P2TX0koRHd++ytdHnzm+/Tb/T+ziO7vP6ASjbtBusct36TqM4wXtHU7eb91hDP+tS1Q1ey5b66h3dTheIEVK3HhOdMp+vSboaHWtEsBgh6XQzmqpGSNXGdphLGpqReOnppBF17SmXFXGnh5YCj8SL0BrYVULTWIzWGCU4PLP85GsxRkQI63HBElYVGE2Ye7y0iFSR7BvSYYbpxuAs9bwmrx2ykyGNoSk9x/enQIfRa0eEKOPo/Q8xITDsxSgVI10gSM2g10MIQXbZpCihsRLuPTpCKsF4kNJLHU9OZ/zjP7rLH9694NM3tvihtSI7PqHz038NozV5UfHk3UNGvTG2qFh2+vRjwca4Q2SXVFKiBEijWvqtEAgFUigSIcm6HVSUgQgs5pbTeInJFty79z6z+x/AeoL0lpdHEf3oKY6XOVoodpRgHAlGvU1Gvac8fvaAo8fPcE3bjJf5os3LFG3YrlYKbaDTSdjZ3ODqwc6f5yP6vP5NqqiLc1AFw1pIGi+x3lPbpg1etwEjJUELhIFuZki8QAVPR0NtFJkxFNZhoSUlZook6TJKHPV6htQdmnJJUK7NLQwSX12CzaQkBIGKDLYq0DKwv5PhH31IsXgfE9Wk/S5SKaZnp/zdf//vsP/Gz9OEiFgpcJe0ReVRPlxGCrWQkjg0jG/vE0LM9N6jduCDRBIgtIPv9s4kUFKgsVSLE1LjkVa0+VtCEhvRwi6spSscRiviOOZ4VWCVxtY1kjarMfUWVzdoH0ijAMJTBo/RulUpGE1dWc4uDnnxlaukIqKsLGfTGYdHTxmPNhFM0RrGEoK2NE2FdTXjjR7jUZ9mdoYfSPRoq5WV9w/In2WIcYLevwbVDGZPCXkJDkQ3Q0hH6G200tTQtBmSyznBFeBrWJ8jeyN8kPgoZv7tU/I3fwcjCpRRqCgjSjLc+QWmO0Jf2WHvds3WxHORaaSOMFJi4pixbsmW1tH6y7BUTYUQAtc4hNZYGRHpmEylyCSl28kYRIpIOIrlnDrUbdYvgbKqaXygDp7YmDbEXGiKpsI3Dc47fJAEJ8ltTV23ZGBXgUIikAjBJcBGgY5ACjIj6CYagod8iZft1rdyjqBSgrHIkFOXDbb21M6zrBzCtM1skqREaUwiI7qpxqFwwLyuWBYFF/kSQ9lafLVGmogoSUmT7M98TD+W5uzo2QlXrm4hvGIxP2eUai6aNefnBXE2QDQ1/UHJ8dGKKEmIIs1wYOgnnunZCXXtmC9XbPUMKki2N0Y8PDwnyRu0MsRpzGwyRyrH/njE7tZt3vvoEca0F4/ZxTm7+wkX+YTp+oTJvYpOf5vB6AZnZ6dc2Rkjog79uODs2RHzxZKNXuvrujg+IemmRKrBNZbR5gGn5+ecz1fsb1/j7PiQ1fkhxfkhvV4PHeB4usQ0novFgjQZ8/ILO1xMIc9rOlkfv1iCz9m9/iJvv/Mh16+OGIw7nJ/XXMxyhommCdWfNGLCB4xSuKa5DBS99JxdrmC991jbSkH//yrA1saIT736CpGMiBcVZxeKt44L7s8uWKwu+OLnbvNTX/oUKkp4trjH2no+/8brPHp4nyROWSznZN0toihhY2NA0zQcna24++iIOsCt69dxvuSX/st/wPXGoRGUVQ5+k5/9K38DW6/pdge8/dFDbn7q82hpWU+OgHD5UvTkSP7FW29yHcF3vvEBr3/5E8jQsLnZx/v2rMT5BRhBFiqK9QobMuZnJxA2kM2abqb44MFDagsv7PfoJx3STLBYXBBvDpkuG3a7NdW6IviGKAocX8wp3BARcvq9PrE2JKmhqh2NL5HBk0WO+XKBDQ3CF9Q+46P7E/rdLgjH6XKFURHdJCYvlnTHG9x7dkFlFeOuIjKeaPM6N174AvfuvQ/VPbpJRGJW1Lmn20vplgusm3Hv/pRxJ6a3nbJ4/C7R4pT5tCZWcP32C0R2yfzsgjiJ2BsMwFuOTy+4P7kgtxHzx8dsjQbEOv44ju7z+gGooiyQqp1wK93GbAwGA+rGkuclvSzCXnpXjTRIExNCwDqH0a0J3lqPiRxJoijrVtboQ45EUqxaWSM40jSmcQGtJDK0G6IWr2/J0oiiqnB0EVLSTyKsD3/ye7xvpYKPTwrq5ZqgLZ24TzxIkEYQVhCU5xKVhsoEJtHUVY1vLMuiJMQxomwbvtH+VaLbtykngsWDj6jygn43ZucTW/zxN+6yFWWILGb15CG3b9zgowcPkEpRtSaDFlRSewSC+4dTIq0wSmMcLKqGr9895Y/uHPLv/dt/lS+19gg2Nnrk44zi5Ax/9ISNlz9Ff7iFCJZiMUUQEEIgRLuFbB0uCoHABqhtG//hXM3r+2u+/vXv8mjyPlGzoqMkxkhiHWO0hJMn1KslSsYscsmoq4iihBc3X+Rrv/a7+NBO6UfDAf1+h/3NnP2tPoNeh/FwRJJmmCQjigxJmvz5PqTP69+YenhWEFyg3+0xL4pW6XvpYfd4MiPQOkVLQzfuQFNgvcOFQGQ0eMd6uaC0NdZXaKOIOz2M0IjeBnIvpvYO7xyucdiqREjVBhdHEusDcS/CRDHUARcEJycr3OOP0P0I0RR4J+kOtzmfLPixn/wR/sWv/gJG5mSmlVdXZYNC01OCtbOEoEgIxNLx2c98gcNjweGHD9EigIAkFkgHkVGsa0fwEgjUeE6XE9Kkg7oMatfGE3oZu69cJYo1Jw+fcfTuIafrAnuZsaVFu/lLjKF2gaWzxIkkRSKloHGWpQ+IwpFZx2ufvk23Y+gPBjx7NEFHGb3+gHVZ8Phhe5ftd2NsXhHJQJJFpCFl78omg36fZGsLUS0RjUN0ByAM3U9sU955m2CfEG3tEwYHiG5NWJ/hqyWyLhAqoVmv8EpgOgNYrRBSImxOUBG+qrCN451f+hrnX/1n3L7pSXf3SEcDzPY+SoJbLXGRRNqc7UHK8ughJ90ddvZ2qIJiWSuU6qKVQSqJEYJICYyvsa5BB9DaEJQhjbskcYY3MTqOiNMIHRq897h63VJ6laaTGeqmoaMlW/0evV6XWhhO5zlVVbEsC5rG4QOAoEtAoWgkCKHxwrT2EyDSGpNEaK3QUtLp9aiDQpoVSVZRFjkyBIqiBtdgdIPIGoJv8LZh2dRQlSg8dVGS5wY7HjHsDhinCWW1ppQB4+r2Dl8XhCDRRmGyFKVUuyH+M9bH0pzVQnF0NmU8TFivHUkvZRQpup1ttkcJJ5MZVeO5dvU6WdJlVTcUqxnLxRkfHs/ZGY/ZHPUY9ftY77AkHOxtU1SO3c0xq2JNURv2DrbJIs2TozN6/SFaOBpn6XUzpssprjqn3xsgpcebiGpd8vqLezRFyWY/oV43HC0aUl8TmzGqA5FwCJOQryu8bRjIKeNOytyWdGLBKomomw3iTDFdT6nLktFwk6W1DDfGJCpiOplzer7kYGfM07MVm1mgXFVU9gnbg4RYxiifoC8vO+PRJg8ePrj0lbV2Mi0lWmv4V3Zm4fIX67JBXP66tbb1ol1eABDQ7yTEC8nXPjjjm/cfsag9e1dusnP1NbZ84IOHd+ll7/DGp1+hHynKfMHRak2W9SmLJULWLPIZUSLYostqXXP4+BmYBN1Yrty4yf333uLi7IxtE5CN4I2XXmaaDbEqQvcSKvsY4So++PbXGAwHoNvJRZJm7O4fUK7WzOZTPkCg7jzm9Z/8EpWXCFr9b3A1XgiqVUPwNTpJuboZeOujc2w2Z7GsOT4r2Rr2ma4bhI4Zb2iMDqQ+0ItqllFNOV+wtiU6UVResrnRoWoagvcQHGiHijWZKTidLdqwwFyQdFOGVjBdzbmYr5ku5ohmwWhzTNkEjiZzrIPNQZ9+LyPzDtPNma4qOlsJk/PHvPjJz7GqLNrlNE0HguTs4gwdS6pSk9uC84mjsgnPvvp1Xr6xzwt7Cc35Bc4Lzo/u4auCUBbkYhuqKevK0uRzEp8yGHVoakHS6XJ6cvRxHN3n9QNQaWywPrSo38tQUOscxmikgqap6WYpZaixTYMxhjhNcB7qqgEkkVZUZY6Wgm4nu3zHtHj28Waf6fkK2wRULFAYtAoUopV3lFWNs4EgwJjWiyYQONdOHgmCJFJ4Z3EBThaO0miMaJifXyCXAt3R7aZLa2gcRhlUaqjLGithvcxZF4pymhCbMb1bLyG5RRARprOkfy0llAW9kcBuXUH80R06gwFzk1BNp+xuDlFKUNYWVHvB63dihr2YxapCCbABxsOEx6fz1idGoKlL/l//5Ff4ja+/yV/5uZ/l06/dZrSVEHpd7KqHJDBbrPjoozu4Zo2U8k9CoiUgvcTZVsZlg0daj3cNxcLy1rf+EPv0Q4TyRFHr/dNaXUI8BLIpOb/zFjd/9C+SO4kIAqk1qekgqsBf+snPkgpDlkWkWUaSxjQ+IFWMVIY062CdxXuw/xo5O8/rB7Nms1kbGuxrEiOIpEDiMQokloODTR4+meKloVlUJFrRuIq8rHDeYXS7eTARJDomMSlR3KXxmjp4sB7vwFY1dV1TugqpNUYpvFR4KRloQ1N5iqpm2Onz9PSCxTt/BHUBSMr1nHw+JRKCX/ulX0IJQccEYm1oPGgZiIVFKsHAC3LvcXhcUPzKP/wlfDAtJVUASpINeyxOzqgaRxCCSGo8HoIiOI9rKvpb29jJKbiaV774Bf7G/+LvUFWWr/7X/4gHb/1HSCMxAWzwKCnoRYZeppguKmxQfPLll7jzvXdITYAEvvKVH+Xk8X0ulkt8sWb3+oscny2JsjFNE3h2OkFKxY2bLyBoyBdTEA2r2Tn9XkK3l9JLu8TGUD78gP7+frvNlAK/OEbImPSl2wQREXAI4WA1aYOnFyuacontjIl7fdRwF04PcXVBPZkQvER2e0yPL/jGP/g15s++w/6Ow4sutvZUixKt54ThAH37NkFGECmuJUtumAXHbshyvgQlsDLD5W0+pNYRSiiy6DIiRbT0RSEcRglqV7F0AhlZ4qbC5QojHWVVsC4LlG+IZWizO72jYwQ6VeiQ0PhAaCyzxZKiKZAeYqVRCiohQSqUVigTAZrGQ5CCJE2JItXCQ+qG+aog9wrvBRpDHGWtai2J8Na2m1jfoIVHSI917bDfWIuwgdw55tMLVkXFJE1IsdS2QEiH1gEZAsJbskiQJAKpLepfg9/2sTRn49GYK/t7zCfneBuIsi0wnn43ZjFf0BtvklRt2FxeFSSDLYRJGB+8wAufaLXCZVEwGnRYFiW9QQdrBdXFFGs6NHnN9SttMPOb793n5Reuc/zsmCvjiGUt8CIw7g9ZLIdkcUpZ5qRGEGiYXDxjZ2eXKBpTSs+4nnF2fsKrL9xgOT8nzVLefP8Be3tb2NUc71JkmlELQb4u6A+HuOaC4/Ml13avEPqW9bpAuBITNCqKqdHE2hFJzbWdXfr9PienZyip2d7rEqQikQ4x6BOlioP9PT748JTgzoE2MV3K1kCO409gH9ZafAgYYy69Zn/asH2/QgjceXDIf/iLv8u1W6/yuZ/4G1y5+nL7ErQOXxUUxSv45pzT0yPKteH864cU77yLy1dYY1GffpmTqCQ0a2jWlI3lw7v3Wa3XbA43GF57kXVesJjPqDAI0bDb22TvE58FIVHSk8Saza1NxlvbrGdT7t15j26WkXW6nB1fkHUzpDZIPLPpKW++8x5XRhJvIdaBxgUKB9IHbDVlXVTkRcmNa9c4PT2kahzraom1BcONISosWa8LdCSQImPiBd2ORvqSSIHSDdN1IE0jhr3QZmJUSxpnmcxzxr2MSEU0taMpHLJeUniNFBnO5mz0+8TKUdc1SdKnLiZYrVjnC2Jt6aWOO+c5+dpyul7xytWE7/7Of0HVdFhUJ2xv3yQzEYE+SE3As5V5toZF64VJbxDFkuPjJ3QGGavFlMV0SV0LnDSk9ogPJ4cIsc3m9jazs/toPWS5KCGU9Prpx3F0n9cPQCVJRFHUxNoQvCMyBtvYdmMSR0Qi0MtSkjhisVxQFRVGt1JfKz0IWvR0HTCxIorb93ZVWpJOgo4lUWqQrW6OECzOtn92ALI0QSjFdLZiOOwgfEArhdLy0g/SCo+UkiSylQzZEBCDmJ6OUUYRRMBZB77BadF6RYoS4WB6MmG+iFnlQyKdkm6muMLipSTLxpiNm6y72zz7rX+AePQW/uAzdKM+ZjxgOpnS9ZpuJyES4LSkCbKViof2vVPXDRvbY6rSMW1qTC/DWUEcp3ghmJUwf3jCnb//C/S7XbZGPbKsw/7eBhfnE+4+PuaKqfjsQdxOpaVowSv4Nhfg0idBoPUFNjmPvvcWq8f36WlBFsckWhBJidEKFSuSVldBcfyY+WzB5tbuZZxK4PT8lIODq1S1xQN1UxNMTKUUSguM1iRGYaQnFpKzi0m7sXtezwswNicSFiUVmY7pyNb/E2nRDhQPLwjOEnuHdjVFHnDBg7NoJRFNS27V3qO9RguJ1jGEgFLQH2hEAUQpjRWsq0Ck2veQTjLWKkaamDS9HEbLwMaLt7l77UUWH91DqkvfkHAEZ0mkwmNpgsLmDUIIUuW4+WMv8YUv/CV++//2/0A2FbVU1F7QSSTaV1hbt77adMxg/xPMjv4ArQQSSxIJatf6MyMl8L4i7ndYnkEK+HnJL/zd/ydH9084vPNV4kjTkZKmauOeYi3oRwrlHauyjTX6w2+9h9KaWAhee+MVXnjjR7goYza++Cnee+c3uP+bb4HWHJ8vydI+SabY2N7m8PQZr7xwnbPzh3QTjTCa4ALlLEdfhbTfJVYDzPYIkUWE4S7CDxCLc0g0RGPE7BnBWgg1Qg3wgw6+M8LXFqRBePAm5fCbb/Pk/n0mxxPGb/wloMs7b32b7T2PjiW2UaxmJWkFggVdpWFREoYRMklI9ZQb18a8KXYJJqVjYpAxpW2Jmc61DdAsX4NtZfaoFkpllEEmOTJJUFFGJ4kxaULlG9brBbPZCSkNfSNpJ1uCbjRkVtcUq5xV6ZhM15TFEiUD3ciwvzGmqCtcv0tpHda3PmptIgRtJl8sL7/zlsZXhLwgURG1DxgpkM7T1DU+CPxlEHpqDN0kIYpb1UntK0xwLURlcYEqCmyZs1p6Fq5VPiEVwQdqWyN8QAZD0CAjh+TP3p19LM1ZnHX46OFTtra2mJUTynnO/v4uAcdgcxsZPI8fP+XW7Wt8dDTn4mxCviy5eSDY3Nvj8eEx165cxdYFIq/Y6PTBwL2799je7DPsd5mv1nSyDle3uoTVhIPNhKNZzWY/42x5wXw643RW0ru2yXgoOTyZ8+VXbnJ+MkGKiCfHx/SNRwvH7jjl6fERkZI4X3DjoM/0+JxGB5pIYc8b9rczbJ1TlgLnBOONMXmT4x2M+33OQ2A83GRj1OF8kfPiwT5n8yndKMVLRSVirh1cJ5INdZWzXlcEkdBJFLVzKGP4U/NYaFPvfQt5FUIgLzdj4TIg7/tSx+9vy0SQEAR1XQGCn/1r/xOu3H4d5yyNbydBri4JdU2xWrBYnCKeVPTf+UMmp6f4UBOaGoJleu8p3f/xv8sqP0L6I3Rnh5Ozc+LUcOvqC3z6Sz/O//v//n9ChMAMgULx7NkTtj/5OdI4YblaMJ8vKfI1r77yAg/v3SNLMtI0ZTpbIrRBpxmmLiiqEm0003nBWBYUjWTYibBNyfHpkt6oR1FXGCnxIeLJkweM+ymDxFAPDIUtWbuKTZ0x6itOTgpQgVW+Qmc9xn0oC8fi+IKs22F/bw+EYbJc0IgIQoe8tFRViTKghGCyXJNEEWnU5rvcvrqPMRGrdUHlPIdnS3a2t3BNxfHFjDiK6Q0jNod9xFhTNA1Jt4e1js2hQbgh8+kZlZvQ1GusTOn3u6RKUDmHW53z+OQEEWmG4w1C8Dw4PUVEMRu9Qbuqjzos1gYtJmyU8ML1K2ilGAx7nJ1f8Ojo2cdxdJ/XD0B5Z4ljzXyeo5QE6TFR1JIDUVhbs1ivqCtLmiQ0rqDIS5I0RgndbuGBNImQkSJKFIlNWS8b1pOC0rQfXEG32H0hJb6xCGh9FUoihECP2uHaYBBTlJZIa6wDgUMridOmzY5xEmlTsiiintXYoibaiOnv9lFCtGTHpgajuXh8wuxCcD6PMSagJa1vxUiU0QgUoc7J+ht0rn6KxXtPWFcb9IcRv/7mO3z123f43/y3v4KREUob6rIEJVr6ZJxQBYnMeszWnm6/T08b6vMLosS0HuIgCKKVIhJgla+Zr1YE5xgPP0OWRazWOclujJKXBDgJrVgyICW0NGmBR3F2fMrdp79KuVjSiRXdKCY2sv1SCmPai0ykJNpoomuv0BsOENITMNiq4nvf/gYnZxekkSFONBvd5PJColGibaDzomJZWeaLJW+99TbaPJdBP6+2XFmyykuQgknwGCEJwiOEp3Zcbr5LxsOMNE1YFb69SBsDQpIo6McOvKduPPN1gfcTtI5JOxkmZLgaUq2IZUtH7USBRw8/YPPqNeLsgEwJ3OkhpS+J9vapREb/Ez/G9MPfIdKBzSsHTJ88wRUFUnq2tzYYbmxx784d8J4Iz/Von7t/vKCij5QTat9A0Lx07YBHT58QIamch6bk3rd/n650jPsJBAhCQuVapLuHWCv0fIpRHoTkvW98mya8jfSWUVpRNQ7rFOEyAy0xCmMEq8rihECbhIuqRgKqarj95Z/gdKnY23+J177wFQ57I+79yn9CN4W4F2EJzMua5mLFxfEJZZEj6gVlPyGShjLPOdgdEkUaHQfqeARGsD5zhPNjum/cwm+9hvQWEXJCFCGyETQ1OKinx5SLBcX5BbKbYrNzpocz7nz7TS7OHqKiLv/i7/1nFKVmJD2RAtlIguyh432EzDFZD+8FYloiN3cIeUPU6XJ9J+NK0aOIemidUHiFqizCVuBqHJYgG7R2KOUJogEEIlR4W0NeQ1WwyhUrKQnB4UOFVoEoScnSDlEnoV4WhCamsBEnJxPyxrLO1zhX0jERS295Mrtg2B2QxglxpJmtKxqvCCYmkQJciXM1zjvKpgBn23+fOqf0bY5ncI7aOsqmRfhHAvJKUBa6jY1wbWakwqFEg69ztPCkBCLpqF1DFGdEaQ+HoGpKbFW1DXZdYYt2oPBnrY+lOdvd3gIUnX7Gpz/xCYRRuKqi1+1yej5DRwbiDjru0BRPGA3GBOcY9lLmsyWjQZ8rO1vkTY0XiuVyjo4U167uIIKkaQqkTnFeUQUgJBQXU65sbWCDY3djE+dqdjfWnK1rkrTHG5+6zh9++7ts9GLefXTOi3t95i4jjXo05QXCVnR7Gzx+9oyD/Svs3RhSFgXrqmGzY3HrmkVdEKkhUjZc3RlxenoKUULZNPQ7HZyrmS0tzsHJ0uNlj9JVJEXJhqlR0mNEYDgec+I81WqJ7A0pGzh+doH3f5o/470nOI9woTXzX5IZXWi1qk3TPuABEOH7E+w2PK/b2yAdbVPkawgBGSzWNjRNxcXxA2RxwY2jR6gP3sG5gPAO7S4pS84zkPD2P/6HfPInfoStT20wdYonz87QMual1z/D4dMjvvNHX6eqGyoRkMJRzC6oyoJVs2SxWvHDX/oSwXl+89d/nenkguFoyO7eLst3PwAp8PmSyjokEi2zFlSQ9dH1iqrJOT+7IKgOdVEzOTtDeEfU6bG1sYHWJcI5toYR8wWIjsZ5i9YJptvQVBXDXofSNpxfNKRJQjIY8uL1faqqnbAPBltIrTk7WxFHsK49uijZHPXppZbJYkEjNDf3t2iCA1+zzAsKC7HyrFcLss6Ajf6ANJHULmZvq8tyNWE6t6igWDYlTW2QlKysQHlPR0k6cYV3gUezCmrP0UVBJ81IbMF6PSNnTZpF1EVBWaQcHU8RIUeFQNzPgAXPjuYEYpQyfPRkRi3GH8fRfV4/AFVWNWmSkKYxZVkjhMRaizYSpUBJQdM45suSgKCTJayLkrKoQTiyKLlsHlrzPEEig0RL3U4Ba48NAdPX1HnD4nzGoNulkyQs12u0StAChNE0QVHXTQsC0ZpEBNa5J1iPAHwQVA6+9u6E/1Z3TLaRoGvwPrCcr9CpwRiFLS1hXVIWjtk6wwlDYhJkpDFJgo4zTNJFRxEiBIIQZHs3kE/3SMYV//Gv3+HO4zPyomS9mnG8avAmIulqpNJ4JCruUnuHMe1PXlcVq1XebtSsvQysFSjkpTRHABItA1Fs+O77D3BVwXoxY5ammN2NSyqXa5s/IdGqBTjljWLlBLYJaNEw6iWkkSaJNIlufRpGglaglSTNusida3Rvvc7apbgqoGTN4zvfwbuave0xtqnppCmEQBM8tmzIi5qqrjHaoLRkMOjw43/hR9pYg+f1vIAqnxLqgA0WRHtf8KqN1SBotNYIDdNFzmTVEIRiuS4RQSEkdETJX/nrn+Vb761464OHhEiRKk+v12M6KThZFgStkUjS0LATO9arilsvvUDJgMOjQ954ZRflH5NsKNK9Hd55OKcebOPNNtvXEn7+f/o/4xd/4b/k0Xd+n0RAJj3nTx6xsznk/HRG1OvxtX/xuzT+6xC1P0eQAi3h/oMH/Mx//3/AN3/7X7LrKkbXrvHdb30PLQLrdUE60sTB4kpP5ANRHBGAenHCdtfw6b/4JdZRRpRv8Fu//E/JuinNoo0mQYKRgkGvx6zIWReSIggqa6kIREKy8oKzMxhtDViKmm/+wTdZPj4kNj2UcuztblGFmA/fe8jp6Tnd0YgyaKwrGA72mJ0cY6dzRqOEfFGTXTFE2YiV6vCtf/hbvPgXv0w36yHOn2DrJbLTQyYDQpUTgsQ3kpOHh5y+812mjx5x88VbEMc0IuHJ/Q+p8pqHZ1MW5zmdLuhum0mdzy21mJJ1D1BStVaa0QD6Q3xeItIIrzpkoy02kx1OG8HaWpyt6WpIlEN1YhQJjXctkEOCtyVN8NR1A1IQcKAkjfcE0YY01w6slUyXnlVVsyUiDt9+l4s3v8PBC2+QXbuFHndJJGASlGrvwLVzFLZu8/KiGGthXpZoFbBSYmRNU64IVMh8hg6WRe2Y1IIgNRKNRVDXdRt4bqARAhHA1VWr6KoaJC1uVLgKiUNpTxJFEMA2FrWqUNEaGScgJY21eO+wjQMXkPLPLiv/WJqzdeO5KANDDE01YTGtSDpD3HKNVoGHDw/Z2x5ydPyAQdoG6nZ3EubFjCfP1gw6HZbnjwlRxmKeM+gIvAblNPPlBXXekHW6LIuCrc0xp+eHPHl21m4/4h5XdoeIwlFjKKsSg6PSOVsdydHZDK07eKlZnx5T9Ib00h22RpKqXLG1M0YnGVGSsFgtuXXzKqv5krJY88LmmDc/fEq/GxNkRFF4dMfQ7UTkTY2sVsS9XbI4YthLaZqSvJKczxfsbG0Ty4pVUVF5R6/bJUtTHhwv0VIy3hhwsVghhG+3Yt7jRKuRFb79jxRSgnOXIJB/BZ9PaLOLQiuJHG/sIFXWrmZdQwiWfLXgzltf4+DWAddtg5qcIRuLDr7NovOWR0HwtvBs+sBPnJyw/sVf5tx9meX+qyzmM1RkuPHaG/zOr/5TitWcgKAKAoFiZ7RDlBi8DaAktq75R//ff0ScphRVyYA+9+7eparWaGe4vr/FNz86ZzTcIu5lSOlYzycgPb1EMt7qY6tWZ8z2Lp6SXjdip9/FmAG+KpjlF9R5SYTE+ZSljIlDRF5YSCu06FAFj/easl7z6OQYow2LhaXX7+GVpN8b0Osbjk9ndFWfsq7ZGmeYGHrdjDJfU3uHshIlJcIptoZ9zs7OyPMKYwxKJGxujDg9nzIab3NtJ2JdeXrdmO++/xDbeDb6ikg2rBdr4s4VellKCEt0OmBj1+OwWFtzMVkwebIglSnTdcP+aEqIa87PGnyT8+ooRpByenLE5s6YyekpMZ58tf44ju7z+oEoiVJtECZoysoi0K0MUUkSk+CLBqkkRVnR6SakcUxdOwICay0gaGoLQtBUnqqo6XczFsuAd5bIaJSURLKllq3ynG6nQ2winLXM1+v2nSTbpsB4jfYlQkVEJlCWFUJIIhUIQvJo5SCWNA5CR7WSRyGwPlA3Dp1ETO5PeXrU0CiDjgxCKRCiBQ3YBnxAKo0QLVhpePAiR/cb7px9xMOzNaUwhE7C3/vOXdZ5iYwSuqZttLyzrQcMGI96zNc5SkDlPUapNtNNm0vqZYV0HmME3gN1znLehmu32U2C81WFFAotPZ6WLOalpgyK0mpK5+mkMUOjEVJhlMDIQGoMsQJ96b2Noph41Ce58gp+cA3d2+K8hNsbgtlkyttvv0WaxYgQIEiKyhGAoiqJ44Q4iYiTCKUUUrQYfSnbJvN5PS+A/Z0RPvhLWrQkBMtor4uUgWeHCwQGpSOqKiB1hCcQnECJNhYjqRX/+Ne/h40PSNIOUQx7o4wbO0Pu3z9BGVjUFbO8Yekc0VDR6V7hj947JogFr9za5KP753z+pc9QLZfc/2DG+/eOyU2Ckxmz0wn/l//tf4RdnZMIiRSO25/8LH/wa79GVdTEtPlfZ0WFIaCkorY1CtmG1yP56j/5r9AWVtKzmszJJFTWoxLJsJewWpfc+txnOPnoLrHLqeqaLFKkbsVf+rm/TPeFn+U/+w/+Q17+wo+wdfNFvvHbv8/q6DHGW2IlmC9zLlYlXkBsNNa2REcRwIuIX/h7f5+v/MzP8lf+1t/m8Xv3ePz+t9jf9FSN5fRsypXbr7F71XF4tOToYs7krGazn3A6yRmNt1nlU1bFmqpZ45cOESsUXV76y3+NrZf3WwvK5hXUaoq9eAKccnYyoTi/oBPH+KNH7G0PuX51QLlY8zv/8ts8Oil4/OACL2E8FNx4QfLSlZQ4GPrDhPreMXm+pntxSNjZRpuYoCPEzhZiVSDiLj5UzOYNd1fryzurI40NqVZsdcfs7A6ZzHKUSamDI3gL5ZrZ/Jy6aoiDJYkUSI9XGqkknSiibhqmq4pVXiF9gwyG13/8c3yv+IgH3/6H6Lf7dDffoH/9Jldee5VskNGoNralayK09axWa/COVAashBIwaUa/m2Co6NMjEZaz5RJ7sSa3bQabsw4fLF44mkZQCyB4pLNURY4ta6RqP2O0CK1CITJUntav6AUEjygrhPUEoXHBtzEmHmQUtYHbf8b6WJqz+ekp10cJxewMKQq8t+Qrx/l8SppkdOOax0/ukmrJorLs+i5eOO4fzuikI8bjfeplg7OOT710k2fHj1okZ/DkxYooaJIopalzDo8e05SO7fGAOI5JI8t0Nm/zbDbGDDcDk2VFP3JIkVC7Gbv7+3Q7BttAr58hdEyxnuGcJPguVR2IQs7e5gaVlaT9TQKaCsEPvf4qd+8fktuIq7de5nw6x1Oz0e2Rq0CkFVpW1I2i28no9QWFLYhkj9OLJ6TREJNFlOs1QnhMpNnsaN73NeGSkNTKGCUtD+1P6/vAkBA8SimglThK+aeYZiklL7z2Y9gix4YGWzmCL0lixxd/+C8wvv4y1ub4H/qLrP/wn9H93V/nBM9Xg+KxaxDBcx1BFASh8lz86h9z/7Wa1z7/JfLzc2QU882v/RYIiQAqpfHWsrGxSY6iqguaKufpkwW729s8fPgQ6xyHzw7RWrXBf97z/uECETSD8Yit0ZjbG4G6lJRNhHOCEASxKHGi5tpWTOU7xMpT2pqnpyuubXfoZdts9KC2isl8jvaK3kYfHSegPdNpQElPkDVXtruUTre408pTLgqiTFP7Ceu1YXF2Qd3psLs1IokjTKKpaktQEVe3t8nXa7xtqIPn2dk5zkt02qEsVqBqkHBtb4e1bThfrlgsGo6WZ2ilQASSKCZfBFQ8QgSP92u0hjKfM13OEbLhYuHZGQ/ZGuyTRjEWw/T0nExHuKxCqivMVp5hAsPegDJfMl3XHM9zhoPNj+PoPq8fgJICyrIkMopIC+rao4REICgaS20dtvJt5oyU1FWNUoo41lR1C65oQqCqHM5Dt5diG0lVlgx6KVVVsVq3UJ1AQAZPL4spy4ok0izzBqM1ZVmChChOiLRC1AFpBM4BQRMbiXeCvHR892HJvcdrPvfJiGDaxqEBqDxagTSB4WCAucgprWhFguL7wymB0PrS42DbST/gA3z3UPN//cUlHlBKsDnucTad4xpLCAJ7SVNEynayn3quHmRs5pZ37izaS+ulhDwSntoGGufQEnTH0FSO2BiCdMQmIoo0vTRhe9QjmA4+Sih9TNAJgbaxFdLRiyHVgsho4sgQG0NEIMJhpMcYg4kjTG9M5+YnibeuE6TmcN4wuZjD+QkP790lSEVZ2fYzQCuEkgTnOTo6o24se7tbbG2MSeKYbidlNBoxGo3pdDt/Ls/m8/o3r7Z3r2N6in6/z/HJDCkNQbcIm40bHic0mkCzLoGAdzXKWwwBo6GsPUYqdPBEaZ/YWG7sbnDQG/LCS/DB+YyDqzd4enzGdJ1zUdScNKfkBNw656t/PKdrYHNryK0rB5QXHzGZzon2B7jODlk65/b2gPvvPGppjgQ+ePdtdKz5ys//Fd7747f46X/3f8j6xPKr/+l/QqItddO0zZlsgQzGNuxsJlR5TblyNBak0ig8+ckC6TzLj95H5WuiKBDHgqYsiJTg6Tc+oK9/lHfffcoP/+XP88dvvkWR56S6bVKd9eRNgevEJGmParZAdAyR9yQ2MC9aAMrXfufXMSw4UBXXR2t6W2OyYcLGeJOHTy5IRmO2upssP7jLaj5D5Y4kr4lMzGru8GMYXbuJ7A4opxbz8ivsfeJFQun43j/6b0iHPTZv3WRw7RWWH36b8uyUkFcsZxfEQlBMnvH0fMLv/N4Jv/v2CSvgxkBzYwM+/bN/i87Zb3PQSzG2oD/oMl9OWE8abHlGXUqC3EdkPUR2jVA9xBdr7HLF1G0SqYDSnq6ROO8I3lOHhrSfcPr4nG6mSNKUtfXkRc2yLGlsjVIeqQzCJERxRpokbPX7IAK9+Zx5keMI1HVgupbc/umfZ+fWFT761X/K4uifsT4ZUN5/hYNP/BDy2jUYdimNwTpBYwOJafH1tvQIHbHOFQ0gvedICqRKWOUVa28xShPFBmkdVtaUoaaxgHUYGXAooo4i69FGTGiNoL2rCwLB+dZ25BuQAW891trLoX6L88dIIh2h5J9Tzllhc9yiolzOWa1qRlsdqtKxsbHJajqhco4rB9dYrS1f/NQ+H90/otOJub63xd64R3+rz9tn5+xuD4l6HaLlmF6UUS1P2d54mUXVoEUgTYe8+srrnExn9NMEIxrOpjOMNBgtODo6RSlNt2OYFQ06zrj94jWaGvJ1xWDYQSiFF547j6fc3NKsakHqKzKpqZaWkHjmyzVJHFM1JScXx2yN+5TA6TxnNEgo155Hp3OubY/YHIyoqxXEKafzighLNx1yMjnj5vWXeHZyxny6YDjssjka0Tx5RpxknC8qXLB/gsz3ziFC64HyUiKlRMm223au9WCEwCXRsc0qsrYhMjF13VCVBb4pidKYXppS5DOqYsqg08fVij/4/d/gd//o99mSmpPGEoTj07ducPjsGSpf4b1HqMBmWdF7+22az3yJV/6tv8HXfuvXWS/nBA86MlRBUuFQ+Rptc3SkOD1Z8ejBXT73uc/z4MF9tPo+eRJ8CCjZ/n07nYTBcMyL10ZomSPThCa3jDqasg5ImXB+3qA1dLoZZZFz5dZNlLvHYr6kriM6nYgrVzdAOrpJilcR/b7n4nTCk+NjeqMBvrBs9lO205iqzPGupKkDqxU8qyyxNgwyg6pLVrMV5yIw7HcwSjMa9Zgup5R5gysCpW1oao9SKWnwmDRmsa64//SEl6/t4lzNfDUljWJOn04QQmMj0W7PEon0gaapKeoGX1miTg8nFet5TVM3PD4+IYq63Nje5GK6ZDDucDEpEFmXxcWcT966zuHpEUkWcT4rGI42UFEH9PNJ+PNqSxvNarkiJBkhWIxROGcJDRjTvkOsbT1iSkPdNAjriKN2y+W8uwysjlBaUdcOcCSJwTvf+g5kYLVa0+9l6BCT5w2REXjf/P/Y+89gy7LzPBN8ltn2+HOuzZuuMsuiHICCLcIR9AaiRFKiHClDSq2W1GxxJLXUE9J0R89Mz7S6FaOWa7UYpEiJooEgGoAQCAoACYJwhUKhqlAuKyu9uf74s+0y82NfUh0xMT/QUREzga7vR2VGZFbevDfP2ve863vf5+XMVp+D8ZIoCChN07kWRxFSCearFXEQgauRUtBpp6z3Ha8dFDx7xXK+L1BpRJhKotCh2wFmXuMWFVZYfBAgvD4hLGqEUugoxJgSW+YI+kADUJrnBT//OwdYbxFCUlc1i/mEJEoohKSuDVoIBJbK1BhTkUSawemacBGx+uoCUzW0rkDB2qhNFIZMVgbrPFIHjDoR/W6Lfq9LuxXzxD2nuXD2AvVyhsWxyjJu3tn/w5yZFxBqRRxoIimIZEOujEJFKEEpSRAqdBTRGu2zzA8peJhEQTnd5c6LL7JaLriT53jf0DC7nQ7OmT/sxQxTxXve/QSj0Yh+r0crbdNud3EIdBjgbCPm3pg3BkBGLUIUzByBiPFhgvQNSMbbksJJ8I5ISYQ3CKUJpUdUGRrotRqQh7OQ25JARfSTFpee+Qqjfotw4yJHhaeFwXmYWEESgnAGp6FyDis8n/rsU9x3usdgfYMgDNDFnI2L59lRJd/7w3+M3/3IL/Lal7/CVGj2j+dI47n07DUefPu3c/1Swo2Xako0QblAa+hvpFSTEl3lhEoTocjrmiTWiMBB0mZ0/gLTF5+nG3pUuUArQ6Q0RVERSIi6MR/78C+yerrkhcvP8sDifv7En/lT3HzlFT7xc/8MRc3KVGhR88M/+Mex4Ta/9uFf4O/9z/8Im5f8k7//35LNbtEfxfRFyff/4LcxXNvi9//Xf8S5N72FydER+0clRnYYr2qMkLTWNlkVllm2JK1At9coCEg7LaraEduIOoiJhjvYXCBERP/ht9FZW0faknKcsVpClHY4vnWTbHZIuTrm1uU5/+ELuzy/9NRacbYr2GjVdKRn/IX/yKmHWuiyYPP0Dr5eoDcGxHpCHICwC1bHh3Q6XWR8jEzbsLjLnaOC63aA1Z4WEEiDt5ALzXix5PeffgUlNa2kcaO5ylAgmk6y2mIQ5EZSGo+oa+KsYjpZIDwYZ6mdIUwTtNa04oTalXTOvJ23/7nT7H3+k9x89QWW469x55lbbE3fTOvex6k7PVZ1E9EJux0IY1IR4YmQ4oTtUC2RwlJ7S1vHrG2MkCKgMFDUBh3VeF/jrcVYj5IC7y1eeIRoCLpKSrTQaBUgJChnsSYH76j9CYxENDULFnBC4ZCEQtOKvnGA2+tTQh13MfkxNuoS1GPSsM3ewTHG1aTtDmtpSiAN50/1qZZLet2IIEobfklgWS4yTm1tEWhDldUM+32MU8yyLlvDEWq5S256rPXXSdIW55IU62vG4ynra9s4W3P91i47WyOEgMViyeF8RS/ymLhiOh/TbfdopYrXbt5E1I5IS1QwYhDmOCR7x0u67R51mdPrtjl/doujoynJeoAOJHu7R5zZ7ON0hPKKe3pD+q0OFosLUhAhp7b6KFtx8+iY6WRKNkzAlRgZk1c1u3dvMp3OyPePWMwXuP9N94HSirqsMdZijPnfZNGaXJqUijiO8R6KooITbLVUitl4j7ooiEPF/pWvIe97E2mvQ5xZlpe/wq9+5F/xysFdJIJdW9ILFI8+8jhnHnwTr330Izy8MijhUN4jncfakvuuvcSraz2+8OUvgJeUxQotoJKS3AkiV5HFfebHu8ynM/Z2D+j1+4zWRkzGk0bsCYFSCu8deZGzceos66N1dgYlTngGnYTjyV1WQZvF1NMLLWf6HaaLDCUty9mSS7/7Bc5tb5OEKVrlzGcZB0FFhWSt1aWVdrE4JkfH6MTT0YLxvOTV16ZYU/LI/adpRxq3yrk9X1CbBGTNYaEwa2cwBZztS0ztEdSspsf02yOeu3WFUAXEaIKoR3/tFH55SKwUpVzSbQVYJIvVikgrprMFaRDQGnZZTyNKU9Frt0lbLabTY5xo0OatQcK67lGXx6zqOZNFQSxy7pIRKslqlrG1sY4Tlt24JheS/nCbRT7m/OltLl/fx6s2vc7263F035hvkgmCgNrmSKHxngZMoSTG+MbyGEfgKzgRYlVlMNYRxhG1FSfPGElVlaRxiAX0Cd3C1I2QC5KIurYEQYinwp+0U1RVTajA1h4pPDqUOOfxWLxwpGmK1CFFVWKNJ2lpwkByc+4QJiObtlksGvuUkh4tBKpoclvWS4SUjbgQjY2lKitsUTe2GmuaTZh3zGcT5vMMYx1e+MZyicKU+UmeM8ca0wABEARa0It7TA5yjDc8eO9pVlnTfaYE6ECRlTVJ3HzsQafF6VNDNtaHSCBJEoI4wI93GW5sEnQ7XL/yGtLXKOcJtEZGQSPAAkUrCom9IdKCNAkRAdRFTrnMWM6OWcxLvIpx+5+lvv4cK93i7t7xH97URmFIGIbgLRujNUIt2NzaYLR+GqUaFD/+xA7vQQiJ9w3gwLs3aI1vTDNnleee8y0mtaO4UTKtK4QO8FUN3mGrCo+kKgvKssRgsFmOLwqkNk2xrxFY39ABlRAcjeds9ga4dI0w95xevUAaOfZUzGB9g1AmTDsV89IAltI2m+yFlIzHsHXuHBu9gG//9gsUt09x+sG3c+qBWxQZLK5epsgXpDrh5vPPMd87xuseB/u3OZ1WSGF5x/d/kMfe873cffUmX/+1n0fWJfkiQzuBE4ZUKRarGXdfvUZHK4IQ+nFAtsqJhSBMIIhiSgHz5Qx98DVSe4SYH7G7f8z2Pfcjoh5kBbY2hIHk4//qwxyRko56CJdwcHNOWYUUzjIbzxltdkhPPcxg6z7M6Am+fmmXm5dfZplVzCqJUwEy0vRHQ3qnz3Bw7TIrI3nzQ9/Kyy9dQWBQQpEvK2zUxU/HWOGITu1w7pEnOLx2Ba3auHICXlIdTBHK4TYv8NmffZ7PvDpj14VU2jMMJeuJpxcJAgGddEHa3iAJAnQnIdYRtZaEskQnKSJsUZsCVxvUZB9vQoqjCS/uDblRxiRphNYVtZIsTUXUislWOSqKCYKYhYBsnuErg6sswktkECJCjRUavGi2s1WBDDWT8RgvBVHawtUeFWqE9Xjjmc9yykIyevcP8OBjb+f6Z36TYjxmuf88yi7pnHs78dYZ5ibHOk2kQ4rKEIYRzhuKbIHLM6SuCYKUNE1IohhHQq08UlQEKkJzwmHwFoXH1oasqlBSEUqFcqKB4njQQiCloPSO2hiCKAVCkDTf9xqqG9YJlh4WxTd+Tl8XcWYqg4jW2Oq0mHjH0XhOGoc8fP9FJsuSxWTMWx9/gOVyRak1oQFrDP1el1WWsZgcoXXAmVMbTBcTbty8TdrrM2x1sdWCvNK0W5LCwjyzJKGnso5uq814fkgcdRkO+8xXGYFSdFoxxhr2JzMGrkW7PaCWgpt3J5zeOkVdwdkkIkpSqmqFlgGrOsHomHvPDri7O+XKjSNaEZgwxFQ1jzx8L69cP2L31h3u3enTbrURccrzz73M1vY6oVhhtMSZktXxPsNOyDxznN/ewAvB7Zs3mVYOHaRMdu9SOYeQAdJDbaoGIy1OgB8ndkVosKBBEDSN4wiyVYZQCiFOcmlCIEMFrqa7cYr58i5msU/f9pi+8Cz//tkvc+AdEomtc771ne/lvre9E5fl/M5v/huiyRHaa7yrCJXGYomsY3i0y82nvkyxXDbtq6opVpQq4lhCmueQH6N8wWx6TFUXXLt+g/vve4AvfvELCCGI4xipBHVpiOKUTq/PfWdaLKYHIAX9tMUogcn+AdcPS9Ke4sz2gFpkzUZtMKLfk3TagjhKyJYwl0mTZ8znrFaWNHLMq5KJ9WgRcDiZkbkQasdat8ut3TlpGFB7S5nVtFsxa4OI3XGBrybYoE2tW5xeGzHLVuzuLbl08zJ5tWQYt5kUS9CaVy+/yFqvxdaozZbR+HlO0TJ04jZz2yEOl0BGpCSDTovCKNb6Q7rtlCov6A+HeF9TVyvKYkGoU+oyJw6b1/Yiz2gHEWWRczhZsb0xJKoNl+7c4p2PvIWVmXHncIz3nmI5JRT163F035hvgpECtFYslxVhaBFSYmtLFGvKHIrViigK0FpSlwa8RytNbQzaGpKozbLIqeoKfGPXCKTGe4e1DdxDBwq8wHlBUdeEYchilRNIydF4Sa8dU8uK0jSl02kcU2RLtNJMplNkEDVdjmHAwgi8l2QmQGuDNA4wSAKc9eRGY+uEfGWwuIZcSyP8nHcIqfBSYOsSbwxCBzjg9t09nNRI1dSzmCrDVI7ZdEmgJVEcE7RTnDsh0tmSyeExxVLSayf00oRzm0OKqvn84kiTxglCSQ4ODjk4nJDEIZtrA9J2C2tqiizn1nJFf7XChQG7B0ekoW7oZ7IJvCupiHRAFAakWhP6kmJxSF2VeAHWnqhpWiA8QuaoaB0pAtIooN/r0ut2CbREa0mr3WG0tkmn00eKpoZAeI+3tvnaOEvT0nZiAxUKY994XrwxzeSvfpHe2hkefNOT3L6TcZyVeGOZZwUKgXWWsnTkqwXFaoHDUi4ytK8YbLRphy1u7h6gI40MJEUYkOU1+1XA2nzGm7pHPPTIafYOlgwJCYIR/RZUu5LSV1RVQaICLAqvNDoWOBwPnx+yvPosSSflM79/mYsPvpmP/Nufw9UrtLdY4bBScHBwh/VtQUtl+KJkbSPhgz/yE1y547j4Pd9GkQV8/cP/CK0dgQbpFZlo7NKpm6JpsrnGO1QE6QMbiNoxv3aI2trmLd/zBAeXnuPJ8Cw3vvxZ6iyjvvfNfO8f/xE++vP/giBwzKqaUjqMrRgf7PO3fuIniJEobel3O0RCMF0UfPpjn6JcfYobz36dJCxYrHKOFhk26WDznPXWkPlySZSkJIM1wlTx1K/9HK3JLYL0Ih7JcrYiWd/G5RX55DrRqXvwYYA2BuySbHLAbHeferHkzrUjsnvfw2f2P8pNHxFqaEvYSCWjsCKJLGkq6aQKYVYMz9yDokIEAVG3h7Y5MgpRo1OUx4ZyniHba/jFmMO7h+zyKPHGFq2WRmIYzxYYLzk12KIq91AEhIRUFSzsqsHXm8Z9URhJASSi2aLWdY3CNPGXpIWKIrxOME7hCKgNxEGboC0oVMxh6SAdMPq2Taa/98vk8yOi49eo9m+gu2exyWnqwSbleh/dHZERoRSEQrOz0SJNBbf3c6rSgq/IixytNSkgvEfQMA+8a/D7RjiU9oAB51BKU9kcIRWrrACTU2ZzMBbaHWzQYmU8HoGTTa2Jqz22qqmN+YbP6esizpQ0ZLkjjj3HkwmboyHnzp4mM5Yg1Gyu97m9d4ipaxAKHUjmswpjFmjvGfQH9BKJR2GqFYFK6cWKoq5ZFYpWEjb4eJtTFRDoiKosEK7i+GjM2nqExbIsMlaTGaWRjIZr3HP2LFVVUOSGtBUhopDawGhjg9Uyp3aO6armwpkRo8oRYNnbO+LmnX1OnzuPtAvK2U1KuuydrDejVsr1/QVntgKyg0PuOb2JsRXWQZHPkQ46vQECT5wkyDhkPltycHjMorJc2NkGb/G1RXiPEzRiy7o/LJbWQuCExAvf3HwCdW3w3p5Qt5pyRY+nP7iXdnfAdHkH/+oe925v0trd5ZmPfpjfy3OsPgmPm5KHTp/l4fd8K1defIrXPvMJ/HjMHM/vBpJOFPN+Y09gIxABF/ZvM+gNGBcZG+s7LOczame47QQX8wwnE4SuyfKcOEm4c/sWTz75LXzxi59vSlfrhmIYxm1kEHL+7FlSNWF+vCQJU15a7eOFoy0VXbfi6msV125nbG+E7Gz2CLAI53BuDiplXs9xKsUUllF7yHg8YdTrUiwMw8EaeQmqpTjTbzGZzgnx1KXjqKhZ78WcPZtQ1CWFT9jc7FDnGcM0ZK3fRuqQvJoy6KXk1rAYg0j7dMLGkvjguSFoyThfEumQjW4HYWuEDGjHDu81w7Ues7zilbszBh3HWqdiNbfEoabKFizyFac2htxa3mWZw9qgR6QqOt0OGsPVg0PSMCasNPPSM+h0eSi9yK2jA+bzGVop1oZt9o9rru9OX4+j+8Z8E4x1Hq0VcdLkwMKwqRfLiwKp5Ak5UBBEAVJJbFUjkCf5M0uUNCAKvCTUgrKoiOKQunbkVU10smnTgSDUIXnlAdcImEBTVAV52byORVFTO42OQmweIZQj7qTU1oIKWJkGbrS2PqKuHQfzmo1hTVYFgEciEdIjhCcOJMa4kyLT5nkopMDjqMv/1PvocXgczz73Es6DFw0pMpCKUCniqA2+RjhLHAW0WzGjQZduK2YyniJxdHpdzpzeoTcYYIwlz3PSVkorjrHW8dD9F5oLMu+bcm+pUD7GVjmxMkhbIJ1kY9QDZ7Fl2VjRnUDLiDgKSdMEUS+YHe3j6goVhHghEUKdiN+TTaAWYB0bpzYRnWEjsXzjrlhf26Q/WEcFIdZUuBMLp6epWHG+If8aU+Gsxdi6scirN0qo35hm6gsPc2214JVnrrFwEdkypzCOyjkC0eRPTW1QAXS6MQ5LpxPjTANGqE3N6dPDhgKLpPQKrTSB0kQa5kXBWHSYDzbYO84RtWet1SZoeTpRRGkSWjoiPHnNxrEkSBzT/QmzImbnfW9HrRSf+8UPs5oc0+lL0nyFQWClQinB5PA2HRzR2Zjv/vE/x2jzURYUzFeKg33QDjqDlMU8x1Yl+uIpLrzpPdz41EcJjaGuDDNR8vgPfYh3/+DfJptkPP37n2bz9Bb3vOXdkC946asvcP7xJ3j168/yH37x33Hm/gd405Mf5LnPfoogaC6uIluDCpB2RW4lkRKMhkOsrRm01vntj32UYbdPls/Zaq+zWC5JBiNE0mJ6eMzRwQFJO+FoPKNcZdhhmzNbbVQW4FzK0rW4cvkWo1WLTi5wStBXElEVJIFgvloyPTyksDnPPfssv//51/iPN7+AUYIkUCgpSDS0pCPVlvMPbHHfA/dSj/fZPn+O7pltquMD/PS4iaMMt/ApyPf/5xTPXCGZPgu2wtSWSSbRoeSUyDkuewQ6YtiO6Cee1aQkVC2cM40DTDnyrKJeNbGSqsjxeLTx1KZEKYHUAqEVZeFQOkKHXaQI8FGICmN8ELIqDE4p4iRG2hpvSiqXku68CZ/9Di2Vc++2ZjF9ieXxS4jiFCw3KLsX8K1tTHudehAyndVYoQm8RtYe5zJipUki1dTNFDUOg3eW0oLxDdfBIllmSyqnqZ1rrL/e46uCQBriUNPtJGxubpG2exS1Y7rImg4935Sde+coVvk3fE5fn54zrYi1JNEhT77znTx36SpZvjwp35UEQjMvl2ytbbLIc8IoJi5WxJFE+hrnHctCstFrMxg9wtkzFUoLKuswVUG3NwTnWKwyprMJUVFzfDxn2A4Jgw6L+YpeN+UocwTdbSK/pJsGGK9PrCAxx4sCISUtV1AUSzLjGLY6bHQ65GXNZLJkay0l8NDrtgh8Tbs/YDmVKGuZL1asSsGZYZfFvGQ+P6aqFXk9pttpE2ApVjnt3gZtISjzCi09L750DWVr+r0esY9odTqgYqwtm2JAa6mdpbYWYy34pmjUusbeKE56a6IooirNH3aj1dYhvCcdbLC1scPp4YDzvYTi4/+ej9+6wYt4hFJ4WzNUnofe/Fbe/P5vZ//mNa597jMslyuueosMQgIFn1ABfaF4pKpwAgok+97QijTOxESdEcvVAl/V3JGCs/kcdXCdhas4Pj7Ge89ikdHq9EniFlVVNMWy1hEmmuFwg0fvH7EzmLPvDYt5gYo0tRUcW81USDbWEjrtPiIS7KxvUBY1zkFelITagrH0RgkHRxNmtkNVFuwfjbGrCbWNONg9pKbFelGiYokKQvLlmADHdOnYPyjodhT9VmP36fa6tFoJu7szUCsOx8esDfokqukUunM0Y9iCKEzIaouqLb2kj1SOw9WcxNWkYUTpSlZlQS0co94AfEWEQyiNMYbxZMZw0KGsVtw9LomjlKFWFFVFO0mJvGO+zHjwzFkMhrIIubG/hzGGYSumEwYk3T5JBMusQIeGs+fOvB5H9435JhitBM452q2ouQDzHqUUVW2INA1sSEmUlkQypHTNdsx5j/OG6oTSmLbb1HWJFk1PlhUCKzxeeOIoaCTQyTeoIICuVOS5JRRpUxpvJEKFtNIEITWtdq+hmAUajyfPC4JAkGVlQ4aUcOl2wcPbC27bdmM3dB6hBF6ClY11xLvmkkpKiRSNbU8rja1yvK3xNmRV5ly+co17tnt475jOC4SAQTdhNGgz6rXp9br0+32UVARak5dN7YBzBuE9UiqcNWSrJZev3sQax7ve8WaSKEDpAHdiVfS+OdtYh45idFXS+FkMyglm8wwnJK04AWcJhaDXigiEYTnew9UFzjiEFEitEcLjrKch54GwjrLIWE9Txssjytow2thibXOHOE7xrgGNOOfxzmF9jakbMabDkECHTf9clCBEU6wKb2RU35hmZqRsb97HC5fGLIucLC8pq6K55BCS4IQm2m9FmEJROccKifBpYzfDEQUBSdx0/EkLkdaEWqKSBK/XefFOzeZ6j+lkgghgf3pEGIVYKQmSLqW1VFXTs1pYjckcbd0hGIy49PkM+9QVpp/6dS6uaf76/+uf8jP//f+DW7duUhQrAtnA0waR4+K9b0J13sfBrQmRqZhfv8r4Sx9jS5Zs33s/12+Pye7c5X0/8hfZr7a5GPS59Ov/Bu1rBrHi/T/0V5gsFM9/5RLR8AKXX32NKLnOA29+C221i5h7vvO7fwhte/z7D/8K7/3eD/Cl3/kd+oMuj77vXXzmE58hzS26PCnmtjFkOSIMGS8z1ocDVqam9JLXbu0RB4pOKwHn6fRSBr2GGG0OJgRaY4II0RoyV7c5XFn89SnPPH+Z73v7e9h521vRcbtxMp10SCpjePXVS1AdsywMt+YeEWsiQJ88L9MA+rFnOAo5vbNDp71JZ/sU3TTClwYlQ0Srg1vM8BgCtQYHd+msbRF2t2C54vjmhMO54FVfsRsvWFQZztVIEWKcoPaeoioo8wx/EsOxBrA1SdyISbzACljKAnECwFMChA6QcUDiPFonICuiskKGKVpqjJCoIIIgIHYRsbcsB6ehv8N6MOPtb7mXl154Aazkxp1r9JIC7QuW158j120e+d4f4dWjJdmew9Q1kVSkSqHjBFVqQjRZVVEbQYanrGg2yFJR2hKFRHhHojUBCgJBECcoBVoLgkCD7IAPiKnoRwoRtECnRM4zPriFPr7zDZ/T10ectTpMZwuUMVhb8uC9O4zHS6LAgq/JEHRaA4zzaB0ymxf0Oi3SQOCkQEtJUddk2YJAJcwWGd1eyu6dY4ajDjeuX2Vza4uiykFonHXEcUScJGwEEUp4ep0UbWfc3T3AyZCj5ZwUTRpIep2Azc1NbtzcZWNrnVBYukXG/mTCen/I0WzOoNdCC0mSClYLwfH+IUpvMs9K1gctVqsV2mUc3JmTV0vKbEWQJERBm/3ZnCRQFMazyCzYiqOjI8K4RVXVbAzbSAExFXdu3+Bwf4x1DWlMSoWWDQFGS0lpapxtiGJJklCbJqBeVQalJFIp8jzHe8/65kXe8eQHuE9Z4uc/z+0Xnua3hOaukCjRhHs3peLJD36Ie9/+Xl55+tO88NnfQqku2fmz8NqXaO4GFE54Ph5GXMShvaM0lisYMql565kWz+/dQFUFtXPcEZZVDeXVq1z1lrquabc73HvvRe7cvctwbY3d3ds411iSdBDx8EMXubgDVSWgo0jDFt2wzWSx4sX9A1rxGllRsag9azpgfDSmtoZ+K2ZtuN0cgsWE0BlOr3dYZLCwmsu7U3qhQQnPA6fWybKKiYHl3gSfasbTGYFuUYslq6LE+oi1UUrtcmZFhpnBcpoxnpUMOyFjsWRZ1AiT00m7DHtd6tISKE9mC2IqIpUStQXzbMHh9A5ntk4TBS2cOWZuFhxOlnQCzaKsaEURB+M57W4Lbx1V7qm9pa4Lhu02lS3Jljnjw4L19VOEyjIapSxXDXSgLHPq0pCGbQatkOVyn34rZqMTvB5H9435ZhjX5MWcoxFRzmBcc66N8SgtMc6h6sYfr2TzHMnyEocgLwq63S7zxYQg1JSrukGvO08oFJVxzRsiBWk7ZVaXlKUjjCKIIPRNGL0ypvHhl3UjomiIiVVdoZUiCDR1ZQijkLoyBFJxZZmg6ylabDSh8ZO8lNYaZzVYi3OcoIw9AoWQirIqcMbgbA3OcePGDfqp5vTaBgjHcDQkTWOSOKWBM0pqc3IBBlTGoqRACo8XGiU8SIkIJHGyztmdU83XTIimC0rJxjrICS2Sxu5irUelLaQSFMZT2pI4kLRbKd54FhaSXhuqjNV0H18XYBze2eZzoXFGNKkyh5Rh83WjoTCe2jlPXpWknR5VWZDnGVopPOIP/x0DHZDEraYoG/GftmneIYRCiAbf/8a8MQDPXLrFs6/exQoYtVJW+QqlJc5bgqApTU+05KFTI167OSZVCmkdK2MwzoMKWFZQeovQMcZUWCtYlZ56tUQqxal+zLw8ZoKiXhUNUKesQUlEVgACgcOVGaEMuOf8gEu3J8RJTKgDdG+KS8bIZc6v/ON/ikx30HGOWWZIYZChZlUKjm/t85Xf/RX+zE/+N2gdc+bCFvc9+A/46if+DenWJqPgGYrdfe5+7SXix+/jgSe+i69++JfoDwWp8rzwqU8j7/kAw+11Tp3b4WqkmN65zVMvv8zlz/4uNt9H9Nf47LO3uDlf8gN/+gcJuyMqWdPq3csP/Mg9DJOCpDqie+c57j73Gp+4nTNJ13FJyDyrMLVBmBqvFLUOmcxW9Lsp73zf+/kjP/InmUzm/Mr/8r/ywpe+yOZjj6KTGIan2Z86rt29we7RjM7GNjrugQobEe1heryPK3NO7Zzia1+6zFe++hq3C4uXzVcXIVASAjxpJDl9YQdrNbO9PbbW7yEMBc5YwtEAyhAXCGQYIM7tQP+AMCoQRwGMRshxwVf2jvlda5hyh0BHBFJQ1x5jHa624GrwFd5WJFqjdYARntprHK6hGAYaGSgUEOrG0aGEAAxb2rLZl9wtHEmqCUMw1rLIC+q6pHKWRZ7jqoJaJqSjC+ST59g7mnDm4j1MJkvkrGRZLhkVmrQ+5uGOZvKx/4nz9zxCOFwjX45pC4NYLii8os4lPu6yVeUMey1agaXyDnQfqzS5qQh7a4S9Ngsbk+kB+z6kRuKlwNuaqig4rPabnHMYEEUxoq6Y373B4utfZat6hfs7E+AnvqFz+rqIs8l4wnDQZ7WYcHAsiZKEOBAEcUSiA5KkRbbKyMslq5Wh0wqRvtkSVXnNwmo63ZTjyRKtGtTz4bGjO0yxzhPFLRazOTpQtBJNllX0OglV7Ui7Pa5eu4kQirLydDZOMzu4RaoFss4oKmhHEUcHh6x1Q1y+4qC0jPptBq2CqzeuYK1ktD6gLArqShB3UkKtMdkhtiyZjkusNRT5iqyEbq9FO+0hgOPZAVlWUQQJUlpsnaF1yNbmgKws0VpS1RVSKaIkbnoXuguUFAinmttr12zBlBdoISEI0FpTV3VDcjxB7lvnqKqyOXhSsLkas/nxn2Y+X/BFBF8NYmoBgZLUVckoCPiBv/CTLBdTXvjcx7l6/VWGG+e4QYpfTOkmfbJyDhKkFMwxHCYRW0XBsXMcbmwQAP24w3c9tkX+pa+yUJKbRrBrK7b27pAnveZWA8Hx9Jibd+7QSRLWBuuMZ1Na6YD1zU0ev79PL9GsxJDVbIIKW1QIpnlBJ4kxXhLHkrXRiOl0RtDpUq+W3JosMXJJOw4pXYtl7RnGmjiuGRBwa3/FUS3pdyDQDqEdQZVxkOVULqayhiJfkHQiHjjX5+Ur+7z8WsHWqE1eGI4O55w7fYaynJI7j1lWhMqiS7BRycHRIbt7xzz0yBkW0xXZ4oAoXGejramLmsVqCcWKM70tppMFl27sM17kZKli2DnN/sGCKI6ZTZZkpUFITy+OSYKQzY0uz1+/y8ZonZ5eYtyKfruNcIL7L2xT157KJ1x99SrD9RZGKuIwpRsIClu+Hkf3jfkmmAZuobHGEoUK7xRZadBhdPK88HjXCIwkTMjmS4KwEQECCLTEA+1Wi7Iq6A0GWOPwNHbqBsJRn/S2OIQKUNIhJUjZiLwo1GgJzkuSJCYvSlSgUc17OcqiRCuFiiTWGExtqfOCK8uSW7OIdnfFXHQQrqEcikAhfIQ2tmHsC5r/SI8SDTnL1DXe1iA8i9mUBx+8FyUhiUJAYpzHebC1RSqPVk0diJRN/5fWGq0kONfY5qVCAP5EzAVaNZs8IbDWU1lLrDVaS0xZIhZLkjwn7rXRgy6xDCgWS9x8iijmeK9pRS2kqVlN70CdIWXzZzZ/MYc4yaU1DeBNmYr1YJ2lzhe0umsknX4DRVFNWkapEO8NzjXCznt/kjPzOOcREoTQeG/w1uIFeGv/P143b8z/MafnVghjqHE4H9LSnuWsIRrnEpTSJHGL35tdJQg1URJTekkQaGLZgBxUqLAnlxWBVtS2bizF3uJdwK39ORZBkgRIB1J4rAnQoSIxNRpDIDzbaxq7Kti7dJ1HHjrH0d4htgSzsUHev8CDj0bcvLrHlctfQXhBomyDNZea0tXEDzzCt/2JH+M3PvJRLr73fZztDfjMf3iaJ975Z3joHW/m6w9dR2z/Bneu/T7Fv/2H3AmH3P/4ad7xo3+Rg9tjym6bd735UfLZnMlshkh7CBtz+2vPsPbWIV6dRicB33nfOX7lX/47fv3DH+bimx7h9z/9Sf71v/xp3vXku/grf+0v8tibHwEfceerv8HT/90/5/DKHmE84J4LF0BqXvnas2gpiIMYtZzQqiVnL9xHNq/p9Xb47h/607zwlWc53D/keLdg1ApZ7M6RZcm9b32cbifFHB+iB9sIGSHCku1HHye/c4PpsuSLv/88+4XCKUekQ6xrCLPQVDBFoaSY1Fy/fYlv+a53EqYhenMIscJLh5hPUTsDvBQw3MH3NhEiAhlDkRNsG24cL5hKS8mUwnqEb+zXTYm5A+EJlERqiVcOJwxSR4hAkSQpSZwgkxhUSBJEJIEmDiJ6acKqyAgAoxTtVDCd5eD9CSLf4MqaLFtSlQW+zBBZTmUEtU5IRtsc7d/ildfuYEgxWY1b3GYr9bRCzXve3ufU5iHC7TNlhmOGSCpuzA3PXZpzfSbodTS9M10unBmxtRbQbneokPhYMkwLemt9chNwc77HK9M2r+UpR5lnUQsqFbMqChbTGTqI0E7B+BBz9fcZLa7y/neMePwt69/wOX1dxNlwtIX1NVGri5CexXTC2tqQ5XTKxAviZEGv1SII2/SlJQw108WSMEnJspy0HWOdJY0ExkvSVsrt/SWbQZdWLMmsIVCS3d27CBUzWlsnkJowgaP9fVphyPE0YzbN6QY5wjuKoqTOCtY2zlAVE24fLNhY61HXHqESxq4Ca+h2WlRlDXXBYrkEoVguFwSyyT8ESURZZUgUpYA4jalLS14t8FLQilooqVnlCzBgs4IokLTbO6xWU8IooTaOLCsZURM5xWNnT9ONtvjtL3wWXIOat64pE/W+KcXDusbm412TNRMCLxReSby3KA+TbMav1SVTFVJLj0Q04rZo3s1EScLs+C4vPfU5JqsFjz32Lp558WXq208T+JpAB9i4+drXpsbUli8HIR80lhe7KXY44F1vexfjl1/i3tmEg+GAebfNuRvXuZFDP18RVI5O2iHpjxgfTTi1sUaSRAzSDtuDbY6qgrc9cpbT64LZfJ5169EAAQAASURBVMa8UhRGYcuKbtonSfpk9TEdJL4KWS1m7Ky1KCtYX9+mm6y4eWefuJNw/70bqFJTG0VRZpSzJX3tmNYRRelJ4oiD6YR2u8877x9SC8/t4xAjUry0VFhqSmarAh0pRu0+SRghFbjAstaN2d+rqIRgWZZwDMtyzno74NWXbnNus0UQ9TgcH3F2403Ubsya22CWGUx5AK7m7PqA7VGfMEjYO5wSaoEsHOPKMFlV9DoBkcvxwI3bK9ajNsvlkqrMWUyaDhXhDVFnk24/Jc5KHnjTeca7Y/buZNi0QMiEbrv7ehzdN+abYIIgpMgyojhGCImWirxuIBiKkLIoT5D5zc1enLaQSIajDotVhg4iwiDA+xTrBEIEeNEEmMNIUdc1cRyTZQVaW+IwZD5fEKQxAP1uC2sdBCG18SAhjiDPclbZClcXJKGiWjYiKNCC2NcgDEYLPn255se/V5IfBFhvUUKdaBXVgIycIZCy0WYIwDbZ3EBjbU1lKlarJUmg8UJSGQ+isXYKBCrSaNmADsIwJAyCRrB6TxhoqqpECo11jkaSSoQIKIqcyhiquqHXSQHG1PS6LXZObTFILuLKnMrWjA/HmNmEJNbQ6zBb3MG4mLjTwxXzJkuNQApwsrGaOudoWrg9BPJEnDViGymo8gVhNqPdHWEAnG3qVU4KqLUOmgoW1YhNaw0IC143F3onzgWQCPnGpv2NaSZKY1xlkVVGVWe86Z5TvPTCdWLlCUNNUayQ5QpZa0wV4auYTq+PrwW9Tru53FAK5wxKNBc7zkpKJ1BKUpuTn0vLZq/L0fGCMA1xtukI3Br1qIucwBnu3w6ZFiGruwuOxwWtzha580yWOeG7fohP/sb/nTQoGfQSzGpOZQSVBIkF5/jyRz7JC596ng+87zsIHriff/4//BNe+dJ/5JlfafHuH/mT3L5R0duAn/i//HPuvvxFvvTLP8u3/LW/R7zxFrY3Fzzz8Z8l+S5BriL29+Y8+eR7+OS//HkOLj/Fj/+dX0RGmxxNJsSm4jMf/jQmO8S3U6JWhC1rvvaVpyiq/4yXXtmlWIxQ8Xfywb+Ycur5LxJoycsvXmZVOZ78wPt55akvsamXnHp8yCNvepxv++4PsZyviNMO+amznH7oYarlGG1LrNcYNCab8o4PvhflHVQVXnnwBuGgKh1Xbs/5hZ//MONKUCPoJgFlbchq1zCGvCPSzWJgOp4RyRrvK4JWC5IOfjQAanzSQ4QhMkxABHiv8HWBCFugElqn4f7ThzxbxCxdgBVNtjXAEWmB1xAmIYE3tHRDDO70+hzOMyqj6LVadDtdwqTNzCm8jEjjmLw03Fk6vEqpyhKPRQgwxiOqJrdrywrpasrVEl9XaFtjjWc+W5KNp3zycy/z1kcvEqQ5N6/t0tGOC3344LvO8C3vvo9OV6OXC2yZs7GWcuVrt2gNN2gvp7TTivfeu8E73vEQW72IwdYmMnKIbohvJfg0RhwU+IMpSRoy6Gouhnc5LvqUrSHP3HF8eax56fJV2osZVgQsZhO6y8s83JqzteVodzSXrsx55zd4Tl8XcdbpRcTxGi+9coVOaCldxe07d+l2u0hTE6gAqTTZYoGpa3Jj6LRSer0hUraoXY52NV7CdFlxamPAqQ2PcZaqrKhXU168foM0HdBqh9y9u08vlSRJi3q1xCAJRU4SeCbLJVJopHS0As346DbaepK0zeH+PuNlRqgjnIetUQ8hJGEgyBYLJuMp7X4HBazyFZGKWBUZw06CwyAtLIsV3hj6rTZSWPJiiTwpZpVItjYGHB3vc/36TSYri7NT7jnV5fadPeq1lNmy5PTmef7a3/lbuH8S8IlPfhK8IFC6iS04h1cgtMd6j7QK78EIj3M10FAdcYJdTRPiVIpQSLyvcZmhrxzeNyHKl77+VfbHh3z7t34Pn/sPv4FvJYzue4Bagq8c1fgu4/E+xjZltF+mZha22Eti7l0f0EoTnp8c0asLbrbX6J++j/3uFrsvPsVwmfNABPM8QwhPNRxgXYmrBYtyxU53m61Ri1OdJceTgvm8RsZtokhSVQmTVU5Z1XgfEUSC9ZFmujSUi4pV5YnSEfPlPnFHMEo1R3cniKD53GPp6Kyvc/3KXfq9iP3pjGvXd+m1I0JTUtWatNtnpy+4ujvlaDKn7MUkrRZnBhvga+4/t0mVGXqDlKO9AzrbA4rOlGXm8Nax2Q+5Z+0Jbty4xOYgopXGdNptTJEzXx1x53AXIQMGuoUxhlvX9xCdFr6oMNUUWxfcmS6JWwmbo4T779mhqmtOb22RFcume28wJK1WBLMYLSIOx7us9Xtsr7XotFIOrSFxinbkaW+3mMxFA7OJ3gj4vzHNeGdIk5hVntMfDCiKEhDUVU0UxVQmotNtEQYRUsrGilQZnPTErRZlZVgsl9gTIJC1hjBsNvfOeaIowtSWVisF4dFKsLY2AKAsKyIlyOsaW1cEwjNfZBQnVMhUK4raE0oIYzia5ZRS0O+1GfR6TOYLXtqbc7Qq6Yw0y/EfLLIESkukBHviHjiRLSg8dZGRz47p9AesVhmT2QxQKA0qaMpCtRToE8S8UgIhBc77E8y8AKEJ44RlUWFM1WwSpcS5CpkIhmt94qSFN4ZsuSKMIzY2NkjSlKoyHB4fs5rNEFlOIhRxp0PQSwm6A/LVDHe8QBU1VBlKgFQSpEBq1Wy0Tj4viWwomc4iZEPA885TLOYkvcbGozobmNVRY1WUEqWSJkv2BxtF0UBhrD35HuIsSkkEutmceff/7eXzxvwfbO7OS1yxRJuSwDu+/MxlVBhga4syDuUF585sMp/lZMZgvKVezREqYlw1OXWpJUpqlBB00jZl7rDO4QVUtiZMI5armtnxLqW1kMe42hL+AbBHag72D7k1CbG1oLKGpBUyZ0kSJ2wKg+p2uZKkvPP97+Hw7iFHrz6LFRk73S7j+QIfSe7/4Hto1Qm/9+9/ht/61Z9He0c3tKzqOR//l/+QUEi+80PfhnCeN73njyLS09y8OuHqxz/C4VOf4dt/4EGuPfNV/M5DDNY3+M1/8Us882u/zHCtQtCQX6dHBRvrXb7lx/48j7z1MXLv+a4f/AF+9ad/hssvvMDP/9zP8eN/6W/QOdWi108w4bt477d9HzduvsYHvmtBVeVMD4+5px1x5uEe7/m+v0ioQmqnSaIWh/vHnLtwgT/x53+CT33yo4jsEL9/k1Yg2H74PGd2TlFlGarXg3afYrHAVfC53/xdfvHnf47laorRGo1jKB1xO2K8KJkUHiEdUodMphVhx/O2b7mfc488ghhtQK8H6TZUGTI8xnmgqPDdLqJuahVQLXygUXqPjc0W6nidUKd0koBVWRAqRbcVgQ5QgaAfh4z6fYrZHBEG5NEYW1uGSYcoaWPjFtWiZpHVTIrGqoixuBMqcCcNiZRECofDEkYJPlAoEaC1p6wDbFXgVE3pchbzGZPZETf3DolCaEnLg5sxf+GPvYl7z/ZJ7z0HGx3IV03U59mXCOOIyjpuXt7n8UfP8pbH78PlBZFT+HyG6A/BWPztPURtsbUlv3PIPK/wPqDAUFlJZdo80V1nZ9Dh6LVPstayvHaQo6XnLeuetz++AXHMjbszXrg65ce+wXP6uoizy19/ES91U5Q7lwwjhQk106Mx+8cTHn34AbSUKFFwtFhx/p6LKCXIVsvGwlFblIrREURuzq1rL5KmfYraUUnLfLogEY1K19IT+pr5PGORVVDPsUZQSDC1JQwby0tZGQQVx7MlrVgzvXNEsSyQYZtWS9CKNHk2JwxCiqKish7jc0xWocIuVIb85A3J4XhKVgsCaCAXQrOoCkadkCqr2TucEWhFGgRYU5IkPYqywuUzpJDcPVogg4CyNKgo4sadAyZ3dnnwoYf417/8S2xtbeOMIQo0WdHc3RrfBLidtQgkAtu8kU9a3Lp+CR20EUqjhMQ4gzYWKTxnRyO+40/9ZT76Cz/N5M5tlrNjfugH/yxfu3WX8Px5sumYm3eukK9WFMUKaLobBM03/TBu86r3REXOzStXWUwPWNsc8PKdI+Z5wcHv/SZHHpwxvCo9D+QrKglZEpB0YpTk5CbXobzl3ntPE8QZzgb0OilWRMymOXhLuTJM8xm2hjqIub47YzIuWR/EnO4EDGJHLqGuBKtVxWRZMRgMiFA8d+c2p4cVvVaEszlH0xlKajSadJAQq4Dx8R4HRwu8rdjZXudouuT85jatsKYybRZlxfowxHnHA/dv47VkOBqStGs6iQOtuXb1FYxQtDoDdicLpsuMTm/Aq9dv4UxFP41oh5ssFyUmkBSzCYGJmCxLpHaMBh3OnN2mG2nKImN7uMlitaLfb9NrDXC2RqkQ1WtwxKfPnOHc9oh2CMvFEaYqUWjSdofFsiJqdbl9NGOwsfZ6HN035ptg4iTFekfgBVlekcQxDkVZWaSSRHGCsQLj6obaqBXee3ACCUigNs2beSkllbEECDqdDlVd46wF1dj7vK3wzjOfLYgCicARJB18AMss49TGAOlrjipDZQxKOjrtiKquKUpLpx1T1QZnG5vludNbtNvnublMeGILykWAqRvrEk41EBDZECf/YJwUnFzX473l8PiIOElxHuIoJND/6f8TcLINa56nUsqmS7KsKKqM5WpFGAYM+l16nS6D0TppuwvecnR0zGo+JWqlrK+vk+UFe/uHrJYrnHcESpAkIVHSIw0CpJToNMUCw4uPkEd3KRdTFqs5afgHfwV/oqckCI8XjWAUJ/8OQglQAmsMeZaRFivadY04sY4LEeCdxfqCBtossb7J+jUbP3FSydKApZQSJ1m5N3rO3phmklaTA7+/X7KlBc/shmRobKiRQlKvcq5ev0kYgjcSK0JcFKFiiw4SAglhEBJrRygVYblE5XOEXeHiPgerkmwl0MIw6HW4fvuY5cJjnSCSkuVsl41Bm7IyPHjmDPPc0O+fwpqCygussQRCk9x7iuT84/zHT/0eSnrapUFLzXg+QyGIVcBbLryT1569RqJgc0uxc/4s59/3HWw/+F4+/5sf48Zv/Sp3v/pFluObtHsbtPo7TF64yd1XvsCHfuxbeeg9H6CyfdJ+n3/7y7/Ms//qHxO3K/Iy4LUXvsjWxfegRc1yPuVbv+f78ALUaA3rW/zIT53jf/ypv0hVLPjIr/4y3/Lkd+CKkK988VVKc4f3f8cT3Nq9zOl7z7O5ucml5yTnwotURYhudyizBTeu3UVGITduzSmt4q/+zb/DK89/lU//L/8D66OEi/efpzfqotp9iDv4qIPIV3z94x/jV//Vz1CZAicNWjqCAHrtGC0s2702r1ydUKCoa890ZYi9oFjlLA+O6a2vN5RwX0C9wuEQunlICTRQNht6myGKAr+aI6sV2aKmTgyFDCh9G6sSnNEoJNJ4CpewaxRa9LBFhQu3iBPP1DqyhaGcL/DGNzA8lxNJx6CdYGpFEMakWkBdYENN7YImXycllS1ptzuE1rIsC2Q7obwzhLiFrTOyuiYUkodPpXz324Y89LYL6FPruCRA1DXCAVKgox4qbnP9xoQsKzi9toEv51TFnP7ZB5qsNQ5MjZyPcasMlcQEYk55vM/KB1zeW3B76ZgsNa9crzkuLK1A0eoITkUZnVbEVj/h/APneOXKHa7fnHO4+safv6+LOOtvbCBdyaISDLqaNIR2u8ulvOLUzhmCJOFgPKcsJYPRFugIoWAyPiSKUrQQHB7ewhpPd9jn5u6K7c0I4UqOs4K1tTWiMCTPF5SLKToI8XXF8fENorhFEIApLZ04IpMh5XKKwaC949TmJs++fAUdhkih0MIwmy/orrfRosftw7vEkUchsbbk1qEjDgpMXRNHMZPZMe0kQFQV87qmNJZWu8d8ukL4lGyesT0KiaKY2WLF4XxMWQg6aYe0PWSyLDDG09ZtDhY5Wx3FaOj5+otfpNc7i3RNl5kKNH/7r/8k/WGf41/6FQ5e/QovTQrGjz3BaGebj/y7D9MqMhZFzp//sz/O5U9+grlwXJtMOD1YY3PnLJ3+GutJyt5zX2W6WtDrtfkj3/WDHLsEKSU3r7zI/We22F7UjAcRt8cWg6J53xMgBFjvaKchgzRuwrlZQSEzJk7SdzUPP/YEX3juGVYCKmuZIDBBhF9bQ3qPFA1xLAw0ebnk+muvcHq7RawCKutZ39pCas/OICQrFLcO79BL+nTSkMJJ0u0WiRYEiWY2PmQxXdFpp9hSMOx16MSaa7dnRHGfw0VGKwmwTnKqlxCehInzQoDM2D0Ysz5c48tff5V37PQ5vbnOqszoR22KbMFsYclKzc5Gj9LMsEvPYHCKi9tdZouQ3SODK4+ZGc9Tr9yimygiGTBbgK8jcJoyE9y5usvRbEGWGzrthHG+Qtuao0VOq7dFEjhWiwXT+QznBG955F7KrGjKDpUB69k9PCZthdx75iyuyjk6WDFfTilKS7/XZXtjRLdj+Pqlm5w/c5aWfl2O7hvzTTBCR7jaEIYSaz1SBXTaISIrsNaRhEFD9hIeqXXTuxUJatuIgjiWJ5ZICLWiKsum36w2KGPAOops1fzeqCHwhkHzc2MtqyxDBwFxq808r6kdTVYlDNBSsLHeJYpT4jii02kTRjFRFKJVgDvplVlJyaSs6K4VTA8zhJWgm8yY/AMx5jkRJM2fL5XAC890NqXdbuNPKJXeWTySonbUtumoCYMQpSRKwXA4pN1q0R8MSJKUIIyQqjlP2WrJ3VvXmU4mpO0W3jmmkxmT8ZQoCui2Ikb9Nurk/Ekh0DpACEldV0xmK2bzObY2lKsV4vAKtlghnULFzXNYiOZzw3uEkAilGgKb1KggQoRRE3xTGuPB4dAqbkpcnT0BSYkT/oc/KamWJ1UsutnOeXeSRfNIpfDujc3ZG9PMA2dO0/GOH35XxPVLr2C751g5T20qqjKnrEqyquA9j5/l1sGc43EOYYA72byrMCJsdejHKd00JVEBd668yqntDe4eZchQkyQhdV4SKMGF7T6Zs5S1wzvDqdGIYRhR5jmqnNPTCe980xpPv3LEqjJM5sdY76CKSB9+L5NXPk/gKmrpkLIpiJdeIrKcj/3Tf0AvDHjwvhE/9i9+lsr0sTLhc5/7Mu/70J/l8vlTvOsD7yKrYu5cO+Dzn/wMG/dt8tC3vJtw7SGOpin9s1tcvzHn0be/m0tf/iiDzTYbGwPuf8cHyRaAqQljTWE8m+fPchQlzI8labrJt3/ojzMYJRzdOeLv/9RfJqtKWiKiu97mHe+6F+0DHn/w7fz2Rz7J53/7cxxdvUFtAt71Pd9HFMcsjvZ401sf5aVLN7j03Fd45JELPPzEu3lm8yxRmNHb3kbFIULGeJOyun6L4+O7vPblD9PPDpgGEd4bpBCEStKOFYFwnNoZsbXW5fmvXMMJgVKaoii5e/OQhy7epteL8d0EUcYgDIgATA2tEb5cInyF7w4hqxHzA4rXboBN2WzHZHFIKSSJAOkqQmMIrKZAkLuMxFq67Q6y1cJKSaoUxWqOVAU9pVFJk29ezefEurmMkr0u7Thks6e5dfeYeVkjvGqAeNZT1hDFMYnSiKSLlobJIidQklBFSFfRU5InznX49ifPoEYJxAFiPm+efbWnfOk6d1+6xtH+jMPjQx547BRp2oi+TmeArHPkYNDkc+uyIQabHL0qiVoJa1s91DjjwlqM7Cn0zPHctRnHVlJow7WFhFrQVwIZae4cLNg/MhwvHfJ/h9R6fWiNgSZf5uAVKmnhpUcEEedOb5FnC25cv87O9jZhqCjyJXevjREnq8pV7vGuZtQfUWVLlsfH7Gx0iLVlthgDAbPxMcvFksoYdrbWmcwXSOlpdzpkdU07tMSRZ/dwD+cEaRhTlzUijDk8vEuiS4Kki82mOOOJVECWC4xbNi8ukbLKxujA0B+d5u6dfTaHg6Yg1JSM5wVrww5tBzq3SLkCt+LWYUYcWbqhwlISKEdlYqwsSfsdUq3p99p0Og3E5HQNQb1i6hSvXn2edz15P1ESU9UV3U6Ha9ev8Z9/71+lfugh7D/+R/D5/8hTz32J//PnDTkOUVd8/we+k3PnLzD6s3+Z0WjIK69epbe5wyJb0UkCpnv7PPXp3+Bsr813fNt3sFdNGLUnvPnNhofWHmfvruNGVnO0zEm7LZypsfWK00piWjG6nYB1BMJyynts0OZ2qQgCWJoV00hwz8YpDqqMbPc203ab9tl7Ghy0lkRBeBLE97SkZrCpkFrQ6gecTtc4mh5BlVNmguXKc8/GBkUO1mqCJGA2n2IMJLknDRXGw/G8IFtUbPZa3FnlxFFMUUxYlo5X9zLW+i263RbddnNrPZ2NcV5y52hCvzugP+gyPzLcqm5w7lSXw+mc3qDD7o1jeumAo+wab7l4DuszisWYW4eOyaLkYGU4nE0ojaK0GiUiZvWKVhJTlwW9NGSt3yHSit1pjpCO3emS7WGPo/mcM70WvSji8rW7nN4coJVkc9RjmWXY0rKsLP1OhIgUSRxyemtEVWVce+0asQpw0hIHEbuTQ86cOYMSGe9403kyI7i9u/96HN035ptgvKnAKzyqgWMsV/S6bdqthMWqQCiJluLE7uYQWhNrjT9581SUFbauyKoKQo0WgPN4I6jrmiAIaKUpeVGSlzV4SJKIPK8oy4puNwELSZKSphHDjYAojui02kRRRBRGQNNd5gXN1syfZMCCEK0kYaA4qDqcT48JQ0OdV3ghEEIBtsmDGYtC0O526HRbBGGA87Bc5WRFRhDGVFmBc4Z22iKNY7r9Dfq9Hp1unyRpNeJUNR02jdhrusWaHJenKjKSOCTZ2SYIQsIoIY5TgjBshKH4T1u8RvQ0SzAvBHu7u8x2J1Q1JJHG9Xp4f4765ktY18BVojBAKImQEu8FSIXQQfO5ygCpAnScIoIEFbcIdYrqnwIEMuri8nGzDfQeJfVJtcoJgl82P8rGJdn8klCNGOQNcfbGNNMfbtIX8Hsv3WA0ehP1AkQgkUWOdILaCGrheOr510jjFrUPSOOYVhQ0zw0czuW0ZEyIxVgYbZ7ieLGgtOBswTKryK0lDVqsb242oCIvKcsCiwCt6Hf61GVJFMd84ekr6KiNMgWn14cEWpOEinDQ4fgzO7C4iTMFMoyaKgrROIUSJUhbDrEoOD623LnxGnt7tzh38V7C0PNDf+GvMV9WRCj+wd/977n56Q/zR/76n2X7ze9jsTSUdcjioGZ6d5ezp0/x5u/8k8Rpwr0Xz5Id1ly5ssfVa5e4fusSf/bH/jzHB3OSjqUTdXnp9iv8sR/8fj73ud/l3sce5Ccv/g1GozWe+sxnONw75KnP/hb3PPAIf+sv/STCVLz/Q++jzscMtweUixkGwfrGOuO7e6yvtbjnvgtcu3nEuXtO42TE8eQuZ971ffgEvOxx+dkrPPWpT/KDf/tv8eQP/jle/czfwYqm/1DiiLVEC08aBkTC8uT3voWNQPDS5X0KX1OXHlNbhBaY6YRwvI/vV3gSRBCDTCBb4f2s2dRXc1iO8Qd7HLzyKgflO1gGCVPRaUiLDsq6gsCThJ7S1OBCWloStro4oSgl5MBKSnSnjZOK2liwngIIlWa+mFMv5syFY3EYoKIAYQ14gXIWvKUVyQYjKlOiGI5ffpn66ArClggM3UFCP19R7E6YX7rFWqsDGwaqGnQAy4JsOmZVzDFacv9jD9LrtbF+hRQKmST4vCRf3SHdHEFgESHIzSF+lSOyks7GNlG6oDObENsE3Sp54LRmdctQiZhMCJbOEBWeVuExt1a8eHXCyvzvs5W/LuJsPpvRTgMOd4/RQrAsKhgVIBy2LNnZWseYkvliSTtJieOUsq4wtsD7Fbia43JJkS8RWlBkK9K0xbwweFsR9QXO5yRJitKeZTbBuYDBMCEQBZNl06EQxC0ODo45c2GNq7f2USdh743hCKkrwkizOx0TR0OW2RifBwRaMpnO6Hba1HVBNdllc9ihKGYnt5mC8XxB0nbYUrIoDVuRRvc13uaEwtDSHVaZoR1JaikoZ5bI5uRVTekk43mGcAJdrSjymsGoR+4Nt649y8baGkezKaPhGl979jnm8ylmPqX9kz+FWT/NY//uZ/mJ7JC/7z0yDLnxta9w59KLvOWHf4zb05wqUlRVRr044nO//bvcPtzjkUGf7/kTfxSr7qKOJ5R1wr/92Cvc2V1B3KGdnGKr5ZrD5xbUtWQ6W/Koh/VVyRLDVhhxUyWcee+7GRwd8rWvPkMYx9y9dhkhYsJen0AF7Jy/wMWH7uP5Z5/GViWlr3GisQ7JSOFzQWewwSq3tEPFzbsZo26AKTVmvkQPN2jFAfvHE4yBuqpZ6wTM85osq+i0Y6QIiAJFjSWsPUaXCC3ppSHogH4kSdoDdKy4de0udZGTrHc5t7OBDhxnd/r4qmIt6hPqFrdnNTaoGcaSigxVSPb2DyhWObFKODhaUZUFg36PtV7CclXS67bor63zwmu7TMcrusM2RVXglWFZVRgMW9sj7kna1K5ga72NihJ63S5l6dkYJewfHpDbGpaGVpwSqoL5PKeuLYGMsEJxa/cO++MVbRVw6sw2izxnNNymrCuW2RJhDTevHxGk4etxdN+Yb4LRYYT0nrr+A6R+I1qSOEQg8VhMVVJWZQP/KRaEgSIKNN46lG/Ii4QBSnparTbjxYLaGMxJD6O1jqqqwVmCIMQay/r6gE6asLk+JE5bKKWQJ7hDd0JAdM4jhUOgTsQNBLFGiMYx0IAsmnztIi+5VPfoRTGpOcBUBusbbLQxFh0FtNotRjvbTRE0nrJqaIeDwZBup0u336fT7dNu91C6+TjONmh5BEipwTfkQuctAkGgI6y1CCXoDzfojzaRotlkOdPYe6xroExSihNMvW3siUr84a9//ve+xHiaoWLJc8+/yAsvX+H8mTXee3HIts/QDrRt8jYehReC2kmc8aAkgYQgiAjbA2Snh5Qx0cZ5ZNTBmQby5GmyPs3HFScQkQaA0tga/QlEyiGlOtk4Nnm9N+aNAbDZjPZWi9VtGDjB5HiP7tkdFuOMC1vrFLdv0E8iTsslrc1Nri1CVLfLKGwRBSGJgsOyYmVrpivTlDELRRD30M7TUoLalEQ+QIUNpEeHPYyK0EHJajrjcDZjNGxzfDAmUJLzG218OcG6FNo9ZBQTdloM04R3/sm/xO/+s79PqAKO85qOkkSyoQMiQVlHvZFS1zkvXn6OBy7eQ7ufcuHi/SzHS6oa9g8XvPz888RrKY984L2kw4e4cmmfT/xP/xpfT1hO7vD4O9/MZz/1KZyZYawjUAH9zpAn3vcefvQn/jJxmGDGC8rJisLMONx7jVar5B1vextXr9/hvne+m9Wy4O0f+DbWe12e+/Ln2d5Z4//09/4zAqkZ7WxjnOLq7hE/91/9fS4+cJ7v+/7vZnI05ou//xTz5ZLv+aGLfP6Tv41qt8nzNpOjFX6a8OX/8PM889WvYOoK9c9+hteefonrIsJbA0o2ZdNRQNqSdEOI8XSqY578jm/lyo2PUeUTglhRWMPseEzkFIPlDKElmClm/bvJZ4o0BS2+DqtdyOeI1Zz81jWOZinn3/EOHn7V8MrBgmUcEIcRgW561DZ6HcrJmChSWCrmyyk9FTIIJdMix5U5dS6phW4s3IHCnBBqQ60p8oocS1EaoqSmk0Ts3j5oOtCQBEGIdBnomuXuEQdf+m20WeC9pdMKeMcTb+PSp3+Xw7tjjO3iJ1PKK9eIz51B9gc4AmS3hVeec/feR5zGSDzOp9DpYuuquSzstJvnZ0VDxYw0tDqwdwR5ge706aQpLa+QccmNsxOuHU6ZOs/aaEC+ukugBGGU8Nr1Iw6WnsL6piLmG5zXx9bYbXE0WdJqdaCasz3qsigMrU4EkWUyHSPxKAPT+ZRQS5wtcCJC2pwgchxOV5SlozIZa6Mux8vbaCEQLmKZwXw1ocWC+WpFOy0Y9Efs7e8ThyG9VkIniTkaL+i2E/K6oNNt44xHOc8yy5B1TZzGjHp9ZtNjbGZZWxtgjCfuCaLQUeqYeZEzVAKXStJQNJYdGbGYH+JUSlXX5JUiSQJqQqLYNW3myzFR0qMs5rSCFVlmkEHMapaxyA2tIGHY65K2Pb1uRMvHZIs7vOXR+/mN3/od8mLF7cOKr37pK7Rmc5LegFPvf5Lii7/Dk8dT/kYJPy00z2U5anLEa//s/8nW1kVqWzKfL5jlOYH2fP/pC2x/8D1cuvUiX391l2t35iid0B2d4txDHcLAoYojbFngY8ViGXB794jKVHw2r3nL1ognnGIiFFvvfjPHVy9z+cprhIEikIIwbjFeLOhGESZW3Hz1Mn1q5HRKGYVIpQgTTVHk1Mpx+6Bm7/AWg25MdrykrdtEynJ19y6eGH/7Bloquu0Od45nKCUwRjBZGJwKMBOD0kvWhgGqrpisctKgQ6cds8gyhCmZOkueZcRRi7DVoZQRX7tyRK8T0/KWM5tDvNfcOphxeDwnjTtkWUVgQqgNVkYc7c5JO21m85qdUUpVaeLBGt3NLpev3KWoPPsHB6yKnFALnKnZ3tkmijWJqtjZiuikKUknIgmGHM+OGaRtkjRFKENVwZnTZ6nzJTKQZNmc3cMZG4MB0lviTsh0MqbOHP1um04rpBOFrK118U41tqow4fqNa8TtkPCN2qI35mRMbUjTAJzD2gpvcuq8RNumGLYqSiKl8dJR1gYhYLmqcHGElJq8qLDOYR30Ogm1NSRRRJpKZvMlwsHGsEu33yMMNWmSoqVoes5o8Pp4T6hDrG+Q7kqI5pucAu8FcRQ0Njw8SqqTDdofiAhBpCOEbFFUJRMUQdJB+wmlcX9o/wvCAKU1Ek0Qd5AYems7vP/8A0gV/GHhshTiDzdJ0IBAxEnuzNmq6f5CIoRDCo3zDi8ckgB1AkMEGmGGx3mHVE0WQ4jGX6lUCEIgkdSu4rd/67P8/C//JkezirxcYG2FFJLDyZz94yVPnO3z4FDSlhWdtsR4x7IylF7glSJNEjqxRgQeVVu2dh6lc/YRwOJlgHA1Np8gfUOUlH8gzIRAok5uZn0jGkWzNvPO4JEndQD/v3hlvjH//zgKS8vVvO3t9/O5L7/K2c0eV2/eIkk1WX7MxrDL+e0hW+l5uhtnKV444qD2HB8fcP/pHjf3C3YLmDlH7RzWWbRz7LRD/OqA7qhPun2WG7sTiqJkPtlnfTNkXi3Z6IUkGoK0QyAC1td3ONWWvO2hhMAk/M5zY/JVSZ7VlMsc322z9vj76Zx+iOLOc2gl6Hc6ZLM5WjuCEFwvYfuJJ+iNdviWJ9/N2971XlZZxq1rt/ja117g9D3389RnP0vQt/zRH/ubfPmZBb/+S/8j5f7XSP1dWlsjhvc+zH/4xEdI6yXGFui0xQMX1rl0+RpPfy7jq88+Q3bnmO/683+Ch979LqpDw2Btg9P33Mv4YMLu1buIIGbnzA73PfpWYmkZro1YrVbsnL+voRypgLVOl//44d/nzKjmB/7099PSLcrFnETXlBxTZPsc3n2NvFxxzyNvxs2P+Pl/8+/Yu/Qs4bk2H/wj30c9XvLa1a+SBQaTCgbrQ9RkzPkHLoCbEy6nqECSzWdk+8/g8hWutrzle76X+rWXyNv3MN97lc4oIigMpkp5cXfJ0eEhjzx2P5unH0PuXUWIAp+tyBeGydqjtE9f5EffcoZP/PqnuLIQrJzCxBFRFGJqx8OP3ovMVhijKZyg1wlJE43dWzTkxaKmMOClotIBmTHMF4sTwNoKW9doY4g0Ta/sdE5tLQqHwhN4hc8KyoOXCcpXqShR3uArwac/9TskxrHsxyxLR3cyYTWeE53RUHjqomBx+4Az5+7DCcFqMSVKW8StFsvZgqTdxcUKvd6j2t+juntMNOwQdGLE2hDX7+PNBCEVYdjB2pKzO10ema/xtacPmZaKg4NjttshD57vITTkeU7hHAujyE31DZ/T10Wc5bUlDQTjbEFRLphVc5RPSFtrHI9nQM18tWRVZoShoJf0aKcR+0dHBGFFkWUsswCtEpZZziLL6HVabPa6SKkIVIVpKTptwXxxhCAmMyu6/RDnA7JyiRBLwsCjRE5eJizyktVsSSkMWiiy1ZKz4QbSSbbX10jbCYfjBYKmffx4MiFOR0ROkShHogSREohkG9SCrM7RwjOvamazjJCA++69l243Jk062C3DC5dfYmEt660tBDBZZlizohMGtNo1WWUZ9doImeBlwGK84PzplNNrPRazCVonfPQTn+THf+RPcOtgj8OvvcB9/8VP0fqn/4g/+vXnSfOCf+0Fe0nEceU4vH0NlCCRkscCz3vf+R7ujjb5mV/7OI6A9mDEPfffT5IopJtAvo9fFsCJ9UUEpHHIWr/F8cwTBooXpwtmrZT3B5L5pz/FFelRYchOFCGIuGQdoVKIOmc6nRGlaySXr/EhFfJ7geewrhAC+iqhs9Wj2wsZtUO0MAw3BgzaXVarJZtbFziYLTmarei022ylIWmvTRKHHN85xGmNFZreICJfLZHRCFvP2dpsk6qAg6kjyx3rGwFRAHcO57TDms1+m6qs2VgfUZUVQRiRpD1u3bjB8y/d4p6zQ1TtOL89oCxK7kxWbI56JEFKbTxuOSdIuqA02IKDg2OO5iv6UcLm+oheu4VDs9FPIWwxmS2479w6O3HIbDzFKzDOE4ctjlYruqbCVIaZUwSqQxRKOlHA1Di6nR5OJ3gnmgdXXdEOU0pZECYBspUyzyuKMsdWNSZr7Jr5qmQwaL0eR/eN+SYYLQ2rWUYUKoSxpIEizzMilbCsG1w8QjTbJ62xziOkB9XsYpIkpihLAiFoxSH9QbMV7/TaIAKkaLqMrPUn5daSUAuMNQglwUvyPGd+PGcwGKClIkrDk21OY+lwzmEq2wSuBYBD68bqZJyjqEq8ryjrGgFM4z5rcUnlJlhr6SdtokBjspxqPqe7to7wFh1FoII/LF6WQjXbMmfw1iHViaA66WCSorFlgUPJEOdsg7d3/AEzBHfSwdls2xRK2BMhJHHOomSA8wYpQhyGp7/yNL/wr3+F8XRFVlqkiPB4Kl8zTGP29o/4yM09NtZ6PHLPKd760Dpb610GnQE6CInjlN5wjTQ9Eb2tIZ3TF5BRiimWeFNRG0dwsv0SjV/xRNjq5nP1vtmrCYn/gx+9QSnd/N43bI1vzMl02n12j2e8+OIzPPjI/eR5zvLaVdK4xXSaoZTkwtn7uP/0kGs3J3R0ySKr6bYz3vHoNvk1RX15RexgqTWronm9L2xNO+mwtCnHBwavu3QiSatjmc8XdAxsr2luHk8Y9SLS5ZjB1jrvuDflnY/fw9OvjBkGK8q0x/z2Eb1RQLue43clb/n2H+YLv3CJUFcczqakSpHJgA/++I+ytfkmDm7ssn/nDjdeu0RdGs5ceIS0M+T8/Y8wGedceNODxANFmqzx9/6r/xKU4WxbsfH4Fn/qb/4DeqfezLOf/E0+/dP/N7ySOBwvvPwq3/Yjf4Zv+dY/wv/1v/grbK3usK4nuDLlN37hZ9nPbnL6wkU+/Mu/wac++VH+6//u73PpylW+69u/FS1Arm9zsHdI3O5hEFx+4RJFcZX5wavc+tRnyH/4zzN6YAOVhHzoT/5Jrt68zvbOefTbHR/9t19nPlasjvdYLXZ554fex8Xv+E4ubt3H9cuvEv3mp9lZ2yJ9+M088MBb+MT//N+SzRa0WwIrQlQUoPQ6T3/x8xhX43A89dHfYqNt6H7qLk88tk5+vI+0OYSnCLbbvPTlr3Nz95Dv/eHvZG2uUMECP5mwLCQHdcjq6i73nrrIuaHgrY9t8TtPXeGu62FrQW/YQedL1gPDUW4YzybgUlzVbpYhTmB9RS+NWCzn1LUkwYMpCYUlSgylrLDSYa2jPOmE1b5EYvHWNFj9vRcZRiuyUFJXvomxFCuyvKKFYGUirt1dEUUj0rhPsTdDdwxHd/YYjUYQx+zfvM3i4A6nHnoT2WQXvGR/L2P9vntob54iGIyw1QusJgekVUqQdhDGI5I2tjLNxZ8OiYKYRx67wEPP3eTw6xlO9BqLu9YY30CtjAhYmpLafuO3Y6+LOHvt2mvgCoathKPVkiAI0GHNjdsLrGuAGEXdeEgxIXkxwduIJGysMokKyPyKAIupQWiFcxBGAmdy6rpio9uh1R1iOEALga+W1KUiy5cMRm32jhZoJWi3ehTGkhnL1HmsUdSVpaos0XxJN9YESQSFoTQFaRySFfMm+1Ut6fXaHC1ypIbA5RxMZoiwueU9vX0v584oIu3JM8t8njGeHFIVE0adlEEn5Nz2QxyPD3n669dJwhh3EoDsRV1QFZNlzni+otNqYY3DmBnve3Kdz3zhgGW94itf+ypveegBzqyt89Wrl5mXGY/+1Z8k+83f4PHf+m3+xnLK1zPLa0JihWZdOM7vnGP4rd/FJ1++xGtfeIqNU/fR7beIycHcRSxLrAB8UzDZhPBp3mBIQauVsshriqqirEtuWc+v1xHfPmzxWF5Rojh2Ifc9+RaqKze5dmVBmCgG9LAi5GaqeOe84KHxMYv1IVVV0+33SDsdrMnotBTzec7VKwe0WhP63TbT+SHWaNbbKYezBWUmyBY5wTDECQO+JpSCVMIky7lzd0yRV4ShQ/sa5STaw909iHuC0iuOxjOywjEuLWm85MGNLvliwVMvvkI/jnjw4mmQEus9YSKZTwqyunmj5nzTKycTwcvXDuiPOpzudrnn7Blku80w7RFLCR4u3z3k1sEhb3rsAttnzxPYmsnhdV65ustaP0Y58FHIme1Nbu7exdYVKyuwSnHh1AjvKgbdPogVx4tDvn75FqcGA9b7bbyo0QS4WjJZFPSSgIPxPsdHRyRxjE4jJJYyz1+Po/vGfBPMsBWxwDZgiBCEtehWU+8gpcKjqawhCAOKsiKOIvr9FkGk6bW7tJIUrRReaUKtEFJjnAPfWAa9c02th5LEWmGdp/aGIAwbSpcUxKFmfTTAeY+WEmsszp1AFT1IoWl34uYbb2WakmTnqE0jIOI0ptPp0hsM6XQ6REmLg2svoi/t0U4i2mmD7TYexjevNbfzgxHSy8Yy4jx4gZD6BLsvG2iHbzZdHv5TRsv7E0ujwnmDOEHrN9s23UA7pMRZi9IabxXWNaLRWYN3BikUxhVkleOXfunjXN2bkFfNps46Cwh2NjdZ6yUcjifERY0xlt/5ykt89plLrI96bG4MObW1zrmdU+zsZKyvDeh3Wxxe3ePqxz/J8XRBtliyKCrWRmv8l3/lT9GOTqiNze0a3vkTkRaA8FhTNf1wUjT/dt41oBDeqN54Y5q5fXBIP4SwnfDKSy/jlEAEAS/f2UMZz04b1HiHYKRZH7QpLwSUr1zigbND9vaWbKkRWduxrmb47hav3ZmRVR6BYvvseW7tzVB4IjzaC0JynjifshaWPPDQOtfblre/8wLV0SH9Uz2Kozlf+8J1hmdHfM/7zpCbNj/z5ad57J576cklK+G56UPUxsP0kmO2z+1w+cvPcv6eAe/5lj/F05+7zJd/6cPcf+9ZHvvA20gsdFoBut3hsx//bRb5hCc/9L08+uRb+Vt/7i9T1jmB81gjeMd73sF9D7yVV165QffMDsnps7z3LY/x9Je/ymR3n8vPv8jRbsZoc5v86gG/9g//BfG7blBTcbh3m//m7/5dHnz0zfzln/op8kpw+vQ5fvaf/yyr5Zgf+tM/yu0bdziXl8SdDi7skcZdvudH/zR/92Mf5rd+9df4c3/3v+bcxQe4+uolhPOUqwVfefppvu/P/Cg7O132rl3mwsOPsXXhCY7vOj724X/D1vYatyYFk2xOe/k1Xv305+mHCkmFWZUESrF1z6M89czXOFiUPPhtT7J/5TJHr94hywSTvGQyPiaMHXY1J9yKOXtxwPvU+zm4+SrXn/064alHaB0+zeTKLlcP++wHCWI14+XnXiJH8y0PncXbJZ95Zp9jHTPPF8ReswhTaixjY7l965hWq6TKDDW2sYkrw6jXIQxiWu0OrXaK9OCcZbGYMy9yCmMwxrBczHF1gTUVyKaqoeoabn7mI2itMaYmCgJWtcV4iQ9hWVlu3soJgjHnd7qopGBy7Yh0rU+yMcKVFp/PCZVHuJwwVBhvMLMpy2sSd5xBPWWws0F8akg1PsIcHBOsreOVR/YjzO09gpZGtP/f7P1nlGXZeZ4JPnsff72JG95kpK3MrKqsQvkCCEsUDAkCBElREtnyvSiph5ru0UjqmV7d0z2SVvdqea2WKImkJEoECXqCIEECBaAAFMr7zEpvIsO7683xZ+/5caIKMz+phVkacer7ExErb5x77rm5455vv+/3vC6NQotH3neCt29c4vpwwkharE4EKgkYhTHD2MZP/tMs5d+X5my3s8vcVI1YJDQrLrZrMR4P8WNFFo4xhUG1UKLfDxjpBNeTeWidhIKdo39nqiaDicGJhQamkafQ73c6zEzVqFYKFFwLzIRKbCM17LYtVhfnGPR6BH5AyfKQhoVhmJjKIvTbBJGB748peR6V8iyHox5BkCENlyRLsITC9wfE2mKqKvAKkl6/T61SI4yHGDpF2DE1xyGTDslkl9F+hFIRkWkxXSmx342pVQokusxomLDf3ctjZ1yFWxB4soxhudzdj1hueBTLLoZpo4hxrRRTCJQK+fFPneTFNw5Y3x7wK1/6XX7mp/4c05USL1+5wvbtNc4/9hjc9z6ca29z+s5dlqMY4ZUxT5xgUq3xG1/9Kn6cUak6VM0ecrKH0gaGFGgpMdFkKkWpmDjN6I8ndPpD+oMQfXTjJcmz4wD8NOMr7RFPLc8zPQwoP3SWG1eusLO7T8GzURnM2g6lWpPZMxd4+8u/zJLp4PYHFGstIstiFPj40RDDEFQKDqZnkaYxQazxE4FhGBwOJyTJBCWL+GlIv6/zKRlp4lkwjFJkoczJ5Tprd9uY0kYaUHIkK9N1DvbbpFnC4dBnmILKxtimzVS9xSS1ubXV5uSxGQqOQ7HiQZYxigPGYYpla4b9mEElYrZeIZYTzEKZ440So/4AQ0pc2+Ls0hxJlNLtjehNYgZDn5XpWSahptWsMJm0SUyTpdXjnDx+gqnpJjcvXqTX6VFyHTLLZbHo4Ccx19c3ma652DJkEAwIA4FjFxlEKXYQUi+WcWyB60rSNGR7r0e7H2KVSvhRylK1zqB9QKla/n4s3ffqT0ANRmM812UyDjFMQZakeEUX5acYBtRrJUzTxDJNHNfBdV0cO59Hy5QiyzIswyTJFKnWGDo7ssHlUOX0SEWSR/ZAU2oMw8K2HaQEyzKJwiQ/Ga3JsgwEGFKiAKkNojAkjmNs26FSKlIslSmVK7heIT+nYjlXeYTIg5M1OLVZXDsPojbQyCxG6hRlwPBwB7dSI0tCpFcAnZEpEEcKmmGYeeNCmoM3dL4BI+QReEMpsiw5ojTm9kSlUlSW5AqazhubLIlBvDNnpjBMC4EBOgUh+dLv/A6vXLxGnAoyITG0hWUJkjRh/2DEzu4+rmvRqBQIkhTDMEiVoj+a4IcxN25vYPA6WoNpGniugx+EIPIoANu2qVYraGHSG/iUZosInaGzBCHzDExD5q8hyzRC2qAhSzWGZefERq2A7D/Pf8736v/n6mCQERc11aLDvafmuXqrj+coVmqzZFlExRJsDCecL1UY3ApolGwqrqAoMq5e3eZwdEC9KvCaUxwMhtQ9A1MlpFpx/e3b1Bp1pCWI4owwC7AL8Kknj7FYNCiWKkS9CZ6w2O2nVCoxvUGDf/Jzv4/dHPH4GYcPfvQpVNTntRdf5H0X5jh+6gJf+K03cFbfR2ftZeJbBwyCjDtXN/jbP/VnKUQZdbvPYO0yH/rkY0hZJKVFksSYJcEPfuwThJOMS5de5OaNy5imQgEnH32cF3/nJRZOvQCVE5jONMfOP0mcafa3O3iew42LbyGytzEtKEiJW4T3P3aMe5/8DL/5hS/ywovfZX9vk69/41tUqhWapSrXrrzEP/0X/we9cR9/MuJv/Ff/A+cefYQ/99/+TVzP4+Kz1+iZJW5cv8H1Ny5iqyKykHDi3L1IafH+p36Y+ekmSiVMHW/xytMX+cMv/jr3/eDH6W/f4qVvfAkr04RRQLmzxZSX8MgTj1CbnmY86RLGghsbXe7c2UdbBqsrq1TtIVZ7l3E/JQ0kd/c05QWb/oHP1MwsreoMlXqHxfoFvHCbcCzZWjfYvd1nu3YvsjhF7M0wEhUKDx/n1e2Ea28dMswceplPUcUYyqbdG+CVTbIkoOJZmGrChJRJCiQR+JpSvYzhVjicZBzGEZbpoJAYRo3i9BJqMsJIYszSLJZQmGQ4ngUCtDzHG+uXGa5dYXZ2ljSO8v02O6NlapbqkgiF64AlDQ63d6jUa5SXT8L0PIMXvkXRdSjPruLWmvR2NgkTzfb+iItv3qFVtDh1qsgpfT/1+dMIq44+3CYLUrS2MIwEWbERjoN2TWgWmF2ap+q8TdEyGKWKG9tt7mk5VCQEgU+qwJbWH3udfl+as/tX5+n2+qg4YBiE2KZDgoVpg+E4eFJhmDHTrSLtwQRQ+JFJsVyi7lZoDwaEygApsA0Dy5UYGRiRAhXSHY7odsbUq4vYhkenm+BYEbu7e/hhyvbhDsfnp1HKJAxTxmGElCHHZhtIUcGQGj8IqboVUCnKtEGBtk3SyMJzLRzLZRyMmG6V2NtrYxUcQmUiLVCyiNBD/FFIoh3SKCUYlxiogJ1OwjiekCUdpitVXAecQgMpFxlFAfVKmUq1wEKq6bS7OIaFZSZ0uh3GQYZjONTdFtVSgc99bIbtwzEbWzH/x7/9ef7U5z/LI/ecwaqXkZbJd77zHLVSEeOBRxiNJkTRiPDggBeffZ5qs0kh3iX0E4zEQVoCdEaqQaQahGI8GnHQHXE48NECpJBYto1pmTiOw2g0wjBM0iTJbyKyjD+4s8Xj9RrZK6/RTiIKtoU0DSZ+RKloU1ARzSmHDQFTUuMZHhvjMR/+zJ/m6mtfQycxW6lFvaQI4j5Fx6GztoPtuQRhQK0+g2MWCLt9pDBIsJBSEGYTBEVs26ZiZmzvHaC1plzIGPcmHIwFWZYyShIspXj/yVVu7Pv0ohEuEMUhkzSmVCuxfjCk1qyw6gmCyGQShkABI3VYrqcUbZP3f+zjmHaRN15/jedfepVq2UN0RxxfbDGKhoxHMeVaDWlFeK5D3bOJx2u8+uYajaKJSn1O3PsEH/roJ8lUTv38wm/+JoN2n9mChx+NKXmacT+ELMDSNqkWaBJOLdWJYkEwmmCUJDpLSLHY2tzisBdjunV0Jnj44ffR3lljdnkVw3hv6Oy9ystxPZTW2I6NaRvUm3Vc18XzCpimedSYWUfwjSRnRGj9PZaENEhVhmkKpM6VMse20Uc7mo5p5u2LlEgjz0V8J0A5TdWRAyDJ/820iKIk/1kIXNel3piiUq9TKJSxbBvbcRFGfgwDgSJDSiNXvJQmE7kRT6iMgmNiWSa2MDCFQAqNYUiSyYQk8jHjEJkkCMNCGqCyGKVTMHIqmGla5PlgeRgzOkVlcW5v1Lw7j6V0CmS5zdEw8uc/UtzyeDKFIFeqhGGglOCFF17iC1/4MkmaoZRASJtMKWyrwEytjjCK7B3u4EcDJvt9bNtAqfz801ShsiS3IkpBpjVZkhLGSQ4y0TnZUgtJozlFMBky6PdYnm7mDksj/7BXKgGRN2emab4LYpFCQvbOHJrKf36v3iugN5jQHUWUigZKWOz1ItxykcHQxy6UKFo2zWad9cs7XLmyTizgRz95H41KEcso8cZba5RExGRkUzBKRKHPJPIBk7JrIMMeMjWoGCamMlitWnRvXyYyTA5GAScfeJChNMimlvnO5QO+/tU3yVbrFOsVhrrNWzffpjHd4v0ffgwjnrC+m3L83HFGkU9XSXZf/03KMkPHCY4csLTkUqzP8OYf/BH3/8AnWL3vURT5vc+ZJz9M52DAP/q//09s7l6j6GjC1CBNU+xCi1c2rqJ+8V/zgc/8NCePn+TyM88wGh+gSUE7NGoFkmHvaK4Wgljy/Je+yte//hqvvvY6QRxx8+ZtDNNEBT266ZjFahHHddhY2yUYDPCzgGLNRkiN397jH/2v/zOB3+Pa7ZC/99//9yzaBn/1f/i/EsUrbN1ZZxiH/MZ//BW6nQPOnD7O+3/ix/mNf/kv+f1f/DkiEhwFhiWpZoqHzxd58r/6b2ht73BgVijP1CnUjvFb//GLJFGGJxUbL3yF1VMlWHLpF0YUnJSD/YDXX25TPv4AsV7k8ItfoCAzmG0xefsL6GAXK1P49QvE9SWSgU9xpcEoFmy/ucfCg0tY+pDJ1gGxO4VbrmJUK6w06rRmi1yZjGiUCjQKFlcOuoTDkIyUcZgQ9jOKWIxjicTClCbCkPnf+XGI6bg4dhETyFSWO/GKJVzXROuAxSc+xdXb1znY32e6UcMzDexUsFpIWJqpcnLaoGAKxuMRM6srVJYXkdMliGOGe1vowEf1Bwz6PlfWNrmz1ePZG3Clm2LJjMd24fP+Do8UTSY338Z0c5plud7CciVuwURXHMQwRldh8dQyJ1eKXD70cR2XTCt6kwgEeKbJOMkw/xPu174vzZlrC1qNAmGUYtequHbGJIgYJxGGsrErLTqDbTwrIIujnPJVKtOoFTEMi0hHHO6OMBWk2mDSiSkUPHTqYBoNXrtyibOL07hejd5wjDQV/X7C/sEhtaLJ/HSZB86ucvvuPi/f3ENlCfVimWGvgxD5TIVSGsuyAY0lYzIVUS+W6KRjGiWbQA1I1IRUlphbKOOPMu6OIgI/Yz/tUS5JhBL5G5O4aBkxSGymGyYFW1EtSmrNAkkKSo4oFQ2KpRqlYgHXSsAMCF1B/+CAgudQsiT9XooWE1JjzOHQol6Z4aMf/QnOPPQBvvUHX+Hf/cIv0Fye5fHz51kbThjrhPGoz1y5iDB8bly/zM5Yk2U+VcNCGzaxziVgVH6Dk4YJvcmEzb02YaQwbBvLtpHkRDUpBUIrkjjCNHLalyHzxidJFIahmfrYJzDCDu7uJu1OD0taGBKySUDBsJGDDjWVsG2VGSjB3LmTdNevcLh7gDQ1cQb+aEKlbPEjP/rD7O+1uXZ3iyu3NxkMx5hSUa8XKJgSYg3SYmm6QafjM/J9Sq5kdn6O1RPv4/Ibz9OcEmy0e0SJzXS1wLA/YqPTw8gi+sOQ+VYdkgzShFLRZqIhxaQbQKvpUA/BlRk3D/v4mJxSMZtrV5ieX+b0iRVGgx637m4RJ5L+xCdIJI5doX3g06wZLLam2Nob0Z/4nK7XGPoBu37I/vo1vvtdxbA7ZDzqc7JuM/HqCAEizojigHMLs9zcOcSoeBRMhW25CMNmNBlgmgZ39w6oVyuUgIF2MUsWK4stgjDB0jA3U6fgusTvKBXv1f/f1+LiAqZhUih435udEnmDgYYkS/KJIykQWqKUynH28iikWOkc7y7ywGIMEynFUZCzhWma+cZJkqDJ6YppkqKyjEylCCFwbBvbtnC8AnOzFQqlEk6hhOU4ubVS55lgGsi0xlBp/n0++IYW4l0GvDhC3LsFj0rZQ4r8HGWWHwMBKg4J+23sUgMz8pGlGlkaIw376ByP8PiIfGdVaRCQZYBQIPNQ7SyNMAwbKUySNH6XIKlU/ruGNPOZOZ0dBTznGPvuoM8Xf/6X0MMRBWXi2Rax6WJbRcI4pNOfICwDadXQyQjDmCKOB0id5dfbtUBKkjjNlbmj9zJ/D8S7iPxqtY7QirlGDXoTkiDE8myEFCid0znztzlFq7zp1kLmx4AjEMo76tl79V7BqYUiMi1gECCDGE9qklGPWsHDNDXS92nvK0pexNJ0Sqed8s3feZrF42fYHUvuf+JeNvY13fUdgtEafhAh7DJZlKGVz/ufPIfplAk7fV65tMGhaXHig49xsLVLpWhSL3rc3RjxH37lCkNHUVywqIgqpYrkySfvo2gWWO/t8ubbe9hWSorJj3z2/Tz3+g2Wmw0OxCHXXv4SQkjCNKC8tMQn/vLP8vzf/Qds3bnM3PknMC0D0zAo6ox//U9+DlfvU7Qm9EOFLQUJki9/6Xcpuw77Wxs88dhpkqEmVRpTpCBSVKaozy6yF4wQWUyS5QCh3fYmlh8yU/doDzU7vRGWtnBdwZ/+sz+GEQb8w//tf0UlFmvra9SqBf7gd36b669fJIky0rBNrVRAWJLV82f41Iee5J/9j/8zx578JGHg88AjFzi5OsVo1uPU/CJv/9Yf4G+tceZ0C9+PWN/Yw3GKOMJlzixS8u6DCw+RbGzgLpzm4O232b54BVOnWAYYIiQaSgpFg7nZFoaKycYpB/0+OhxSE1XiO7+DJzZQe7PYVkBWUIzGEmYvkKgiiUrZ3d7n1GOP8s0/fI4da8yxxQUu396lVasTKsVWxyfpBrx0R6GVQT+WxLKOLDZoGjGmzvD9gCyTJFGICpL876xh4Ng2aBvTKuEqja0VjmESqYQoVcjQwpYmg0nEZKgxhWa67PHhxx7njZee5Xjd5ocenGaxbuJqTcGzadTKOM0KwpagI9L9TSwSDrttxkHA7Ytws13g4tDi+jgjtR1i1+Om2+Bff+MOB4dtZugx1fSoz1YgTnBdC2t+BlkogLARYYw3P8XHf+RhXrr8DH2gVrDxKi7dfhs/zoFUtvmfidYos5RmyWEkJZ3BBDfzKZsWRbeGxMTzJEpU0QpaVgmlQpJszObOiHqlgD/pIpRmdmqJrr9LxbFoVl2GhoHvx1RKVdxSi4P2mCyZEAtBlGqOzU8TJAELzQZ317fp9HrYhuLW9oioDp1Rl0rBpRw6WIagVPEYDHuEY4f5VgtLaIIoYxjFxH7C2VOzdHpjlE6ZBBMSf4JOFTNVj7nZCr3BhJiAsWmydRhiqCHVgkN5rkhjuokfZxSL0G/HHPQCQmEwE7k0ix6TKKY3CUnQFEyXSeQzVSuQpAluMcLzFKfv+whnn/gQUpt89JEnObl6lhcvvsnO9i3W7rzJ7MI0ZVJEvMuJ6QrTHzzDK2/e5vaWT3eocQ1JlEYoETMJYtJM0emPKZU83IJHqewSx2GOMhUGrmPgOnmwpNYwCQISlZCkkiwVaB1wz33vY35uhl/5+d/lyUfPMSMMtrf30CiOF4tMuQK1uYXtFOlaHn7VZqXuoMJD6pUipZJHiiQMEyqVKq+++jLFWoWZUsJuuYgpoViuoJMI24YwDRn0RniyTJxBa2qGQX8fHSRkwwOKCKaaZSyvxHgyJk1DhGFgmpKVehOjWcMqFli/cYl6rUJr/jg/+eHHuXF7n5PL00z6Q15Xt1m/e4eK43KsYNEbZTz9/NucX+3QLNuMh32mii52yaY3jEgjzVqvzfFj05iOoB+FVOsFkkTjY9CfjJnzikSjiN7mXUhijDhFlpv43UMMQ2FiczDKSHQP27DZPfRZXagxVa1jO5JmqcHtjZv0uhPK5RLbuwNK5SL9fodSyWFhusrCjEOvK1HCxHgvg/q9OqparXGkAmVIQ5CkKULk6HfDyDeVsiwlTRNs08IyTYSUCJ3vTEpDHGHiJaZlIw2BaeR0RZWmZKkiUSlpmtsdHdelXCrjeQVKlSquV8CyLSzLOZpz4gjnrjGkRKvcaqi0PgpKFu/mcEmZ4/azJGb97h1mZucpeCVAUqw0sAsF1HhyRGBUCGGiUOg0IfaHaDSJP8QtVlFCoHV2lI+WK1Ra5fZDpXUeXCsFUsj8dct3ctQUmQpz9Dwy30yRBlmqyXe5BIbpIDDIdEoUx/zKv/llSGrMFSaUPU3dc3lzt89hZjEKxnimicgCUBkNt4kWEk0Jw9/lk+wSZS6D1MQ3BRgubSkJtKAQR9SIcIGHF+Y5XYFFY4K4/horq1WS7g7yYx9GmNlRUyvROj7C86ujJlijdUo+/6aP5g7fq/cqr3Z/RDrxMRBM4g6245DGISW7iB9McM0Iu5vyQz/zOb74699AGTZJahC1feI0Zus7h1y73Mc3Bxz4I06eOs7dt2+y0Er4/A9/CB0OWTw2R9dQfPnuFlt3U/730Zi5uUV2b77Oqd2E9d2YvXBAbNqEgUsmDEKh+Y1nNqkUp6h7Njt33mBxdRnLqXPl2i4/8oGTXHr9Cg8sPcXe9VeJ2rcpuh5n3/cgjz7+Wa6f+gbHT95LdxTTubvB81/6XZ79xjeoNyx8HVJwXMIkojE1xcZBmzQWZJlia2+P3//132Ljxh0szyCLNIYSZIbkqT/7l/jW73+Dw1uvI7OY0WiMKTTj/gG2YWKK3OJdKJZptqa498KHiCdjHG+GX/r5X8C0bKJYMDfToNddY/nUCjotIm2PyXDIjUtvMTw8QJZL7Nx4nROnT7N3+y0e/8iHsSt1Di++QTJ6iz/3t/4MLbPE27sB3gtfp7e2TaIcnn99l+u7f5cH/8LPcGxlEdO0eP7pL1PRO8iFJsmoi4wz1CSgXCjQmq4TdHZoRwG1soEzukj3mzdoNiSiXMGdOYnM9jCCAUkUYZcbzJaa9BJJCHzrq8+RxDHtseLUA49Qv7hJXxdBJdi2pmJBNFDEUhBEAdONJd5+fYNKrUK9XqPolhCmSSYykkzj2h5JmiENC8t1KZoSQ6eYlsA0LVJlkkqTYZzghz62SjizsMjU0jTLxoTGaIun7j+JCH1GPc1ab0JZDpmuV9DhhAVbIIou+qDH8NZ1hjvbjHoBjcUqFamYbEbUi1UakU+Uakw0TpQhzYj1zT0Oi7DoWNzX62GZJmajimzNIMpVsKz8cyWF5RPHuX/+OV5aj6l6DnE4olxysfoRjspntf+49f25xZMmQhkoLZiqCsZjTcWzqdaLJJlBrz8BbNJQMJiMkHGfxEmJbQ/btAgCSdMx0ekET2syBUaiUanALbnMTjUpeRaW6dIdCpLBBNs02Oj4BNGYN25sUa97zJaK9McRcZYQxSFB5IIsIS2fIhm7B4dMlTyOLcyTKcVgEtEqlZiEEfNNm153QhhOKBRqzE+VKRRjev1D5moVdrd2ESZYhstUSTJ7wsaPNYuzdYquQTzpIlREux+zszVkz49pVCwSq8ooPSRJQ4Z9SZKATlP645D5aRNPSsIw4MIDP8VDT/54vpj321ApQxRy7wNnkNlNhp2Qe1ZT6m4RKQvYTgHVzggtg4EoMzycsFi36fbHFMslRqMIaQoq1RKmNjBsyST0adSqnLvnNIuLCxTLDiXPwzQl1ZKLbZu8+MolvvvSRTrdNvVGi4999Ad5+g9/Hz9V7LbHFG1N0YPj9TofPeizv9/j8M42QbHENhlTzQoHB11mmgXKZRc/iOmPh0w1pyl6Jv6oT6Vc4vbGHq2Ci+3VGKUCx3UY+UMs0+PYSh2VjJmbKlIogaGblDyXV157DcuwqC+cIhttQhTSGYUsrh5n62Af01ak/RuIcYVUFhBulf1eh/Gkx7kT83hekelmnUmkubu2y864T08pVqYruKOA3fUNDkybURxRazRQAgZjTZpFFCtldGbheWWS2Kdk20zcEVoI+n6CVS8yardJfJ+d/oTpxhTTukujWqc/UURZgGMZLC5MoUKT6O42pmliWzBVLVIoeQTBCFME1As28zOzzExVcQzIkJiW4MaNdSzLItJDTOO92633Kq93wR9ao1WWoweFyO15QuLaeY6XazsoAfIIaS9EPuektEZrjWXkWPk40URhfNTcmXiFAp7rUipXKRRL2K6HPLILSn0EDpEmCo04ste9k7Ul9BGYQugjVSxXpaRpvmtlVEohgKWV1aNZMYVGYVg2xeYcg/Et0jjNGz2dolNNkCWU3SJaK8LBAZgWztQcKskVsxyVL3JMPhlaabIjOIZC5K87y/ImVcgjwEZOOhQcNbpHmWa5JCXIiBDS4eXvfIdUlRCOzeMf+RBrF99EEfG4OaJXKPCC8giyDBFNcNUETA/PkNTLZR5yNZ+0i9hCECYpie1QXp5Gn7+fdHsHb30N3TvEyAws0Sdbu0Ot4GA2W2SjDl7BJb1xDc6cBmm+a7zUEtKj2UGtsyM6ZR5DoJXM1cL36r0Cdu9comBB0EmJswypMlwZ4tia8ytVykWHw86Af/PvfpUkgBEm9flFrm2u8clPvJ+n/+BFgmyXfuZw4bEnef2VN3HUgD/7+ad47NwZXnn9Go7SdA86QERf2zy/MaTWXeP8qfvYHcRIV7Cy5FAqVxl0fQZpRhZr+nGG44VkWMweP86jT5znxVc3Ca++xivrfX7wT/8k+3c7TM0s0PF3MEXE7Vc3iCcxU+//BE8/9xof+uxJrl++yNu//e+plTVRR2NohWVkuLZgujXN3e0DMqUxHYNEKb74b3+Bgufy0ac+wevf3ccWASJK+fWf+7f0RhElUyDCFNOy8rlby8rhQzpCoRgHPnfu7vC3/+bfoiQtZqarlEtubvEOxpy4cI77H3mEjz71Gf7WX/nz1G2LluVgmIr3f/BRys0mf/QbX2JmeZ7pVp3F5VVeffF1Tpy9wCMfeYLG6gXiMCBe26bozfAb//v/gxP3n2QvCwjMHWaXamTJCCcM+exf/Dxa/QhXvv4NBndv0hhdZfnhhyhN30enFyAmf0TVGhGmKbVWBUNCSozpCEyzg0ozoigisluESpEkgg8+9UOs7U0Y9nrsbGxy5/o1gu0bCNtmMA6YbtZYPTaHKU3crUMG2qJSdtjaHTFbr2B6HipNKbge4zBCGwZFKTEzTaIFYZqRxQkqE5QcE+E4dIYTpDIJkwmEAXbq0wq38dpX+cCjizStAWM/wYt91rcP6XdC5muSgjXCDzsYgcl+3KXQaYBUjNfXMLVBvWxTdAUPHm9S9brc3h1xzI64e5AhxYQls8cjT5a4//wCjdNnkHLE1h89S3WqhnRyd4qUBsKwEYZERz7O1AwXHlzltRtXyaIClbLJgm1wZTtgEqe4/wm76d8flH40pOSVCLOQLOxhWXWEISgWiuy3R3S6fWZmWxybr7O2Izlog6kTBr0x+509FqZqbB5uU3E6zNXnsTOTSrFGZoSgMxwJGpu17V2ure3SqNTY7PdQymXsD6iWimg8rtzdR0tJpQT1so1bhqqrmJ5qIYQiEVPUCh6dwRBtJGjLIYsURdejO5nQ7U2QZKRJn5nWHNPNCrYqEqiAYrFMHExIooy5RQdDaG5v+WxvbtAbJpxYWWAwSWlVXKZnFMOdCVGcYekIPzQYjjPq5TppKhhOAmYqFgXDxjQNLPsC9z/6U1hFj6w7wSqXGSYxKUPefOFXicNdqo0mtze7VK0hxWKFxTmDXphw8foepuPgWYKBH7O8Osva3X2arSbj8Zg4iUm1oDXV4Cc/9kHqzTIba+vcuX0Nz3H4kR/5cZ757nNMxj1q1QaVSoknHj3P1laHEyfOMBn12dnZpVWv4EcZ5WqDJ5cbuCqgfdgnkxadgk3i2kzNNTDMDEuUmKtWsAzJ2nCTeq3J6uIsxYJLya0w02jQ7XRJlMKybJYrFSYa5lsNtva3qRQrpJmLUjGepWmHIQNH8tD9ZwiUzac+8xO8cmmTP/ra76LUDiXPZml6nvXdbfwJtOqwXFF0e3tIMc8v/drTLDTLVAqwsjjDlUtb2NmAuqspVwy6gz6HgwmtcgMx7lMSikpicbDrU3NtMlfQKBfZC3zC7QCpJVk6plQrIVRCvexhqYxio8Kg22Wm5tCsOkTJGM+Z5sJj76d9sIe/dxUPTS/xmZmdpl4pgsi4sbaBLBkUKi56FFGcalCrz3L1xpvMNmvoNM+cTbRAGJJsEmKa7zVn71Ve4og+aAiJfjfcOf+KFBjvzBuJHPAhLAPDkFjSQOmMKApRqUZpjWVZVAoFKtU6XrGEVyhhWhZpkiANAykEKsshIlJKlMjnud61D2qdz21JmW+yGRJp2XnD9U7TqDJUlh2d0lFzBO+qbJAfxxCC4tQC/a01VCbROrcmiqNZWa82hWHajEZt4sin7nhIr0KWhfksnWEipZnTFQ15FNB9dJ2UzlUzAdIwSLPkKJvtKB9NqSNiYwpCo7IEadhs3b7Oy1/7OjSWefyDF3jta8/wA+9/H1effZaoOk1LZHy24vNcUEYgWfaK3Djoo4RLIwn5+E9+gqm7b0OmKRuSSX+MWXZJ0wjv1Bm8qRLp3h5mrYn1yAdRv/OraKkxTp/H+uhn0GmC2FxHnDuHVu/MkmlUEiHF9xp0dXT+edZbdqQQvlfvFXz0w+eQSZnnv/MWlowhC3ngxCpNY8w9CzXavYBTD3+MYn2B3/uV32Xu+ByJ0hTLU1y73Qc15i/89Mf4ra9eZePuNvVWC5G6TCYOr7yxzvHTx8iEzWGnh1kuYkoHs1hlkGpeu9NjaaaGRHD/iRmKxSqvjrcRWUil5BEFPp1uB50VmWnM89yruxgy4omnHmexpFhptrAim1J9msc/+JfYunaJKzfW+erv/wGX7qxz7wPnWV/b5NjqAt90wBYxmQaBwLMMHMflcHMDy8zV9EKhQMlxiUIfIRXf+fofUHAMIsASgsnObUpz8zSnjrN38woiA9PK4Ts6iXAMsA1JnCqcgpNviLgQiowLjz3CK9/9Lh946mPYyuFXf/GLfPNrL1DRDg9WihjJPgvTdR544CG2I02xUiINAh796E/xa//m5/nmF3+ZQnOaRr2OqNT50b/0FzDGQ9qvfI2Pf2yRV168iFmqEScxF5/9Ko/90E9h1Eu0Vk6jdUyzF9F/6Svc99EVpv7i3yfbuEmwEeAVbSajf0PJdbENie15xJMBXqNFoVoiNlKSpIgeaTzX4/rGgN/69ndQ2YQf+9wjfOCHnuSlV95m66BD2vNZdGxOtqpYOmZtZ0CoLAzLRlh5LrBphTgIXNsmzcCxLUQaUJQWhUqB/c0DfMB23PyaqzS3IiqNZxYZbO4yfPtFZthEVuDkjENsVSkuLGB1+wxvvsSpVkohiyjXPBZPLDLuh9hSIXRA1N/HrpbQyscyEtyiTX1llcLiKs0o49j6IZP+Af54wLg/YunYErWFeeoXHsQ8fgL6W6wok/7rb1Iv1xGpgBRQMTgSUagiZIHTP/IXaHz579DuBrjCQWQ+ZUMxkILVZuGPvU6/L83Z5k4HoRUFr0ShuoDOAuZmlzBtl2DvAKfo4doZ+4eHbNzdB5mA26BUKjAlLfq9gDgschgK6qWQYtnllbfeRltw5vgS9588xihIubqRMokS+ntd9js95qZKzFRKGJbEUCmNWo1KxSVMfLyCR9TtUm/UMVyTfq8P2qTT7lIUkLopw0mEQZEBY0wp6A1BKI1t2aSZZjjuo7IMW1pESUh/FNGq1JmMU4iGmEoRp1VqlYwkDkhVxjjU6DBkuVVmv33ATjukUCxSKbm45hgsi9EoIE2LdAcTTsy+j/ObDTb+b/+Ilb/3f6bQaIItYL/L28//Kpv7N7C9MrGKmEwEpYZHe+QziDb58rcOwPEYT3xKloElM3QCM60pgjgDLbENl/c/8QjnTx/jYGeTr7zwHM2SxWzd5eSJM1y5eoVRv4NhKG7fvs1k3OPcufv43Cc/wAMPPcr/5e/8fUxTs3LsBOFkwP33nOGb3/4mP/ToKhvnFtnY6DFXqHKtPWSh7lCUmkrVo+RKDKNM7dxZhpGg5Bg4ErZ2+vgpjDPB2E/R3T1KhRGFmVXcaoOzU6vIpM/Gzcu0pivEccKJ5VlwBLHSqHTIP/lnf59abZGTJ09z+ZUt9g9HBFHKhQtP0lm7wk67RyoFAotwcIiMfPYGHQ6koH17m0mm8OMIbVrYqctDD5xip3vIzt1Djp1cgijgIICBnuBWW/gJGKLG0ok5OjtrpFmIVj6bWxOCTOEWKpSqC1SEgWsXmWk0mGpMcXDQYXN9je+++m944OxZTMfEE2UuPPEgpYLF8y+8wgOPfZDeQZvrt19mP1Ak3hx7nTaFxgqPf+gn2dm8y+7mbQqWZni4iSyYtKaX6HQ634+l+179SagjwqEQYEgDIQVpqkBKpGGSJQlCStIkxnRshNYIpTBti0KpiuMWKFVqSMM8Ur3ypkopdTTHJDCPGqwsy3LrnDRyu6KRW+Zyi2JOf8xnnI5AF1mKodSRwgMqidFIpGnkj0Mhjbx51CpX3sSRDU9lGdL18vkwW+RxKJaDIS0sz8W0PQzLIU0SYv8Ae3+N0vL5fFYOC6UykFlOcswShOXkpEMhjs4vt1QqkSK0Is1iDNMGJEejXAgpjl6vJAx9XvjqV1lYWuKFN9Y498BJTl24hzvX73DugbPs37zD7iigUHP4oZbFViLI4oAfWy7zysEA4ZQxj99Dcv+jyGBMcvFVdG2MQuM88Bje0kmMvXXMjRuYSpDevQO9PvLkcbIHHiNZPI0tNbz1OjqOEaaZW0SPcs2UzlBZilAqf4+FzMO55RH55b16r4BxOMOVq9vY0zNUZYhtCiIr5sd+/LMsNxp84+uvUJuuMvYNsswjCSIwbDLhkhyO+bE/81lsx+H+U2PCRLA59OkELn/w/BYFEfGRKGOuUcNxUqabFZLUIcKkULaRQlGtlukf9Hjj+j6p2qferFJINOl4QIKgWCiQyZhUxAzCiJmKS61V4/ixGToHETe3bezaLB/9iZ/ka0+vcNj/A37xH/xv/NCf/3MsTB/jlWdeZH/jCtbSMnr3OlpqbNvBlhaHA580zLAFKCnpDvpMLJPWyjKm62F1Dzlxdombl28hDYmQKVmiGA1zyrUlNEmWK/FSShpTNYZZn+EkIvLHGKZJaEqm7RZBqIiU4JGHP8DvfekPKZXL7N+6zuOLJZ78oU9w76f+J9Jvfotv//ZXSO+9lw9+6lP0Dvf51X/+L5iqF/nLf+dnee4b32Bvc4v5qsne1ddZXF3lk3/lz8Cd77LblcytrrJx9zaj26/y6r/vc98HPsfS++4n62ZM1iZQLtOeNPCfv4GuzrPwSIs7v/FtvEYLSEFlZKRUFxYY+hEl28VtVVF+SM2OqCzOsBH7jF6+woUHTtIoFtnb6jNXctjcMVm8/0no7tCSPZzmEt++eIe7qYXlecxJzajn4zoWlUqFURozimOSMEajKdsm4cEmvTAikxIriPMNQHQeBzKOWbtzjcH6GxijtxgbAduWwVvXNTqMqRVs7ml6fHilxGw1Ro9iKsWMLDXIkhRdLIKpkeSgKatUwrAneM0ZSqunUK0GJWljV5tkw2WwDEJ/SHlpBekWMebn0GEEwwC3VqN5ahXiMbJsoYMAUauAEDlo6u5dZkLNidNVnr/U51AqZqoGsx50Izg+Xfljr9PvS3NWr5UoVVxKXsp4PMKxy4wTn8loEyEyigWHIE6JgpRyJcV166TaZboyzfbeHsHYRylJvWBR9BxqlSLFkofnugjDYHuvzUG7w/5hGz8KicOEUkEyXXNJBKATpqZaTEYDOv1DykWXKIyYqjoYScCNW3vUiw7TMx7+TkyzZJAV55gqKNb2uqzvDFmZ8ygWUwzDRVoOQ98nmgTUGmWiNEWJFKUN9gZg+SNmaiZZPECYRTyvSpaMKFgmV2/s0JoqQ39AGiump0oEfoBINNoy8EoVinZM1XI5ceajnB40mdp6BX3/Ck6ljLYlBzu7fPX3/hnRYJui47I/SFiZWaBo9miPQvzI52AYEWQmBhmGUCzNTqFVwiCK0AJUmlAsWHzsox/CM1O2r77AgW9Rs0JWFpqYhkulNsfv/+aXcB2LmYUZiuWQg0OJ1AkP3n8vT3/9eYbDCQtz82xsrPHn/9SP8rtf+TJ3tjv88jcC/tST53nymMur7RHeXAVf5whrOzMRaUysDRzLZdrIqJcNipak6VbZ7o3Y2+kAgsXFFq1GC5X1iYYhQSZozUzxqc98jotvX8SUY7J0Qt8HqSXbnSFVr8zsdJOZuUVuXqvR64+J0oTrl56jWKzzgx/5IG+vdVEqIepushtYVJtVDtttCqZB2bZZPPcA73vfI1SqFb78G79IJFLcqoWZxphacaxRQc/M486d4OLrb3L3+lUuvfkatldnPOljGAmnZ1uQDamNx4jtPtIpMzU1T9UrcPf2Fbpdn8FwyCMPPECxmOO+V0+f5JkXX6ZUn8bzylgSOpMQ213l4ftO0TvsMD/XJEsFm50Br984pDsW1Gt1tvZ3+NgHnyBIE5x64/uxdN+rPwGldZ5bKA0zvwXPY75A5bAJyzJwCi7l4hylSgXTcbAtK8/GkvIIHJLbDbMswzBMsqP5MkNKMpXmjZOUaEDmvj8kAp1l76LmsyyfLUNKELk9MIdo5Gj8nCQoMYVEZ3mG2jswjPRoPk1pjU5j8oGqXGFLM4UQRt4ICgNhWhiWgyaP4xAaVBoTj/qQJUdZhlFuYVT5c5tSQpZ8D4whc9sjWqGOqIaGYZBlIYZ0QAr0UW4aWUyG4I1vPM3Fb7/Gg5/+JNWizeG1O4wnEdZkRByWuLg3wDRtwk4bp2yzmIRMEAyAT7ZcNsYTktdexvjoD2KaEv3QY6jxCFNEeDJGhEOMUgGSmPTi26SJxim6yFNnoFgk7h9iza0gDQtGY0Stik7To+udIbQ6muU7goEcXUthWug/fgbqe/UntHqdHgtzJWxZYKVqMe0YmHrMI+dOM/QVjZWzfODhFZ7+9hU+/2M/gB/GvLHms+3HrE67/OE33+ThY1M05IjI07QDg6bXItKQWZKnL4fMcY3ZGRMKNTJVpGRakCTYrkV7oinU6rTqNQ637lAgxdUjTp5f5jAuMklMDBTb+0N2+xMOD1MK2YQZu8q1tZDffGkfq7LKi197nlOn7+X1Lz/DuD/gP/7zf8ozv/3rhAcHTNetoxxHCxGmKEvQXD2GWtsljbuMVQZCY+kyhYrJX/3n/xK56/Pzf/O/4fKlW1hSkubT+aSDA8JhF9vSkKUIJTBQmJbJ9PwC7U6AthVBqknIiBPF+uZddtY3KNge//Tv/wNKTpFC1WN+bob7Hr6P0rkP89oftbn9m+tErQG3nvka5558mL39XfauXOPNvT3OPHo/kR9RdA12tjc4+PV1pht1HvgPv87Adxh0nmcyfIPP/sxfo3/7Fa5/92Weezpl/C/+CbbpwOAVzj6yTPPhnyDSE0bdHTprI6RTRZgmUZBQqlXxu33M2Rae68FwRJpO8lzENABfc+Ghh7j49g6DTp/nn7/MVMvleA1Ue404tFiZtfHmTvGl526zGQqkodBJQL/TBmHR9gM6mxHCdHBdK5/Vkwa2KalXC9hGSoImUwFaGmjDxXEld57+CnQu4yUdpBnjmB5KhUSxxhQmIy0ImkvMffAe6sNn4QBK5RJRf4BrmxjCxK1OEw32kFGGW51Hqgm4DrpQQhYr4BSwWwswGiIikV8DC4TtodMUsX4d5YGol7HSOfTIR1saPRigbQddriOimMxI6F6/yYljs1y6OQSl2e9ETCITqeHG+u4fe51+X5qzYytVapUCG5sjJtGEM1OzCO3x7DcPmGtVac5U2euOmfghw5HD8qxLrezSGwxIVMbqUoN6YwppWVhacbjfJjVS5qfrXL25SxglrC6tcP+xFaYrAWtbG5iORFoWJRHiOTbzVc3AtLm1OWH3cMzyTI1BEKPqHjWniE4TEt9gpVWjWvRIDDClYu8wYGbKZq87plF2ECLkVFUwjE3GvkHaC9HSZRhotCxw2OuwOO0SJQleGYQaMRmDY2VYWUpzehZUjOdGjLMCceIw16wz6Q2YBBFOxaDeaHH81Id4qHUevvQrhPefYeFv/ywUXDZu3+Z3f+Ufs7N7mVrJIUszIh+S0KBWa9Ae+GxuxewOIU0CRJbx5INnuHJ1jXq9hEo0fhBR8lye+viHWW0I9vc3uDU2GE06fOTCPYxiWFg8yeX1HY6fOUl/MEQlQ2yRMb+0xKee+jiZVeUrf/RNwiSgYlZ47KGH2N66gw7HVFyLSZjxS89cZGWhhWUrElIC38bXGnM2o2iU2Or1KToFXKmICHDTCWmcUZla4sKxJoaWmLZFGvZpVqtonTIIR9x8e52dW9d44OwxmquLaA2j8QhplTjwDa5evsri8jE21tYxdcqj7zvHtbtbpJkisgoUCoK4v8Wlu/uMxmNqnk2UZUityAyPhz/yYT7x6U+BkHztq9/mmRduYJiaE1MFkvqQMAw4fuIsjbqm197n/Pl7qD/xKIVKDdB4bonhoEOvc0iv1+bM0gyeCyNf8Nyb19gajomDjOb8Mvc81CJKMoqmx/zSAuPRIZ/59CfY74ak8QhtGJw7tcK4N8RGMBz51GoF4kTT2d0hU/CxjzzJzsYurrif167u8v73P4KM+t+Ppfte/QmoNEvym3KtKRbLOAUXx7KpNZqYlo3rFUFLFHlOV07305iWQ5bm1E8NSCnyIGdAGDJXlY7oiXl/lSs0KAXGEWTjXUS7zmfP0GiVZ28JrZBHVkQQR8c3UGmKEnm6mOaoaZOCLE2PMs5yTL8wJJHv5w2WOJoGkwZYFtqQZGmST7mJo9iQcISOxmi7mO++Gua7s2NaHtn6tMhphtJEGCamyI6otcZRXIDOyY4otEoRwkZpzf72Ft/85V+nqCxuXLtBlCZsbKxTNzTnP/A4OtM8nKbcubHJYCywATPLmPd7OBLaYYnmdJOCa8P+FpTKZKaDbDSxTJMo9LGjAOqziEc/hnHuIaztdazuAdnjH4dKHT3sko2HmKUyRjghowSQX2MMtBBHc3ICkUuPeXRMmiGM91D671VeTy6Z+NLDLdl87gdOc/u513jzzbdY376X+vQx5hoNvvr8Gt3tLvdcaDFJZnh7b4szswssNA3mzCaeGnLuyfPc2fORMx537+4xNg2MNEbho23FoNPHNUuk44hu5wAnVUSuRVarUS6V2D9okxgmk8EEx7FozB3n8uvX2Bnkqr9lOhSqFRSCNw9iXv2lVxhqA1Uv4rdtrvzzf87SqQWCSRccCzPLGHX20GbKKMxwInBqBQIBTdMiCAV2awG732e1Xmdjp88kS/B9xQv//kvcfO0iYRzk86giI1UCKQ3sTGEZGs+2MKXNeBQgNCRxSmdnm7KlMIWFl2YEWa6kWKaJi6bgGGSJpugKJpMBozjhy1855PVvvYolHVrnV6nMLRBevcXhYZuHPvgDJBfuYfv622BY+NEY79gZLn/7BUzPZnKww9vf/TbPfv119jY2+YHPfwJ/rJhfWuG28Qa11XvZvfoCc3WfRkVS0HuEu88hKLP88OdIayX01BTjmxmYNloIvGKR/a1tVs+eJRz2sMhjA9xyiW73DqHb4gNPnOeVVy5SrQs++IHT3L14idnpCu32bTobERUJE3/C/afn0KQME5tJnJEqC0NnlG2bWJH/7RIGru1SdkzMeIKIIwQSwwa0hT8ZY+y3Ga8/TRp3KRXLGEqidUIUBRi2zfT0NOFozN1b67zwisGFT5zCs03icEL1+DKT4YQkskmTBGE4SEtSOnEaITOkikBnMBmj4iRXwqYWSLfWEZHG8Kow7KFvX4csQi63wHGhOY1wxvln7fI8hAocAYcDjIJDZanEVL9MbdojHaRksWaSKLSQ3ByEf+x1+n1pzgaBz2F3yN7mhBSDu3cu8+bVAa5rMRqPyW5tsTMcY1mSuWaTrb0hh9cVtYLD0kKdqakWOovpHQ4JAp/JJKBWq7CzP8TG5tjxOUzLQ8VDim7G6vI0VddGWAotiwwHE/aHEzr9DgszVcYh9CcJMw0T0xYEcUbdK5AlQ6rVaSZBRLnuMOiP8AoJPR+GYcZeu02lWCD0I2rlInGakFoB/sTAcEqUXIlrePihwjEMUm3hFWwsIyMOfYZxSqnUZL3d41ijyeq5OQ529znoZSy2psh0hKFj5o4/waf+7M+S7R0y+vSHqf3UTyLKRW699Rq/82v/kEtrG1imgcIlDgZoYWNIj2Hfp9eN6IYmmXonbDVl/+AAyzI46I+wDAupNZ946kPU7QGeW2F9e0wQRzhugW9c3sfMTF69OcCrVGm1ZgjHMcfmXA6CKoM7Nyi2lvja177N+vo673v8UYbDgEcfvI9nnv5dyiWPSEXEE4XSJp1+zNnVKms7O5SqJq4r8MhI9JiVio0fZxiWy521TXq9AfecnmHOVSAKyIJBf7vHzNwMw+4BE+0RhQmH7SE9MyDwx0zVbCxTUyk5lIo1atUpHn/4QZbn6lQqRT7zyccY9fv86u8/Q8mzSaXNxp3bLDTqrFQlYWuJeNwjQGIYFu/70Cd4/eotLt3+OT73mQ9jmCmPPfYQDTFku93DLZXpBAH9tM9oo8PssfNUsjZnj5+kOrtCHAk67X1ee2sLbTepTJVwpxucO32CyzfWqc8mPPDgBZYbDsNxh9WFBbRVYGd7j1QpgqjB7mGHaqmBUTEplyok/gjpuGjDZnu3g5YZjXKFzkTzgx96kLubh5w+e4KibfPbX3uRqze2KFVq34+l+179CaipZp1maxZTGrheEdN20ULktj5AS0kax7ntMEsxpIFp2u9GaUBu8wOQSuUU96PGSxgSnWVHuVvie4hF8sfoI9WNd1SsIzCI1ors6PhKpXmAszRzO6Fto5IUKXIAx7uERzSZys/DsCyEEATjEUl6FPkhzaPnOGoc0/y4AkAp0tgnGnXwWhUUOs8eUlkeL0CuLHI0k6VVkueMGTn98R2YvdaKI5Y/hpAolSCl4JVvPc9WN6RUFMhRQHOqSjCccHNzi3a7x8xMjTMXHmAqHXMzbuNLydLiAqxNsGyP5eYU35p7kF5ykqk9m+mKwnYGVJrTpJaJXWmAIXMVdNIh/dYfYd65iXH2XrQK88iCSp305acxJn2U7aIMB/OdQXMhEWmCkO9IZEdKZ6aOmtf/b/8vfK/+S6l5b4wsuwSjAfOezXqzyA/+xOeZDCRbt2/zxi3J2IX63Co9s0S7P6a5NM9oGLG5r1BuyscuzKNSxf5aB88q0oo7uN0eo3DEBz/9aXb2trF1kWgkeajikSU2C7NFwGLnMMDyCqSJouJalM08quL5165ya3+AFgalikO5bOGPYgpOAdMqoAsFKp5LqVxAtmpcunEPrWmBM1/nzYM9/CAhVBmWlERJhuuYBJbDwj2PsP7Wy0xXYjxRxDY9LENjS410bSZBzB/92s9jmYKS4xBnEgNAgkTlACWVUKu1kIbFeLSN9EyKjoU/9tGOZG71GP72FhkCu+TQrNdIw5BgMCJJAVORpCmSlIAEPdWiOtNg5vwyYWYwiTPurG1x8epN/sbf+ZvcunabLBQ8+JHPUapV6O/ucfqe07zwlaf50i/9K/rtMSfuP4EoVLjngYdRb/8WdjjkxX/19/jwz/4M+6/8HktNxdJ8FS/cxB/02f/SFeylBwn2b2MUSkSRJvB9LB1Rslxs10R402TFGYJeG3nhx8j6EA/2WWo1eeS//nFu3b5Dd3OHSr3OCdPm4O43Offow+yMB5ysmyyuzHE4jtjuZbgGhMLEQNOsFQnHPpntIoSBRhCGEZYnsVwXQyn8KMAzFGEWMuptkqQBSZKSqRQyQZYIhqMhf+rP/DRkmmg84ebbFxkO+mxvQ3WYkIzHzBbKlOZXGA8SkBZJO0JaDkpa2AvL6IqFmByAihHdHnr/AF2YxlicB9tDbd9CDvrgAMVKrrSZEpEG4BQQjgVZhi6VEHGMthyIQ3SQsTK/wAc/4PH0l1+iExukWiLRWOZ/JiDI4XWbm/u32en72Iab58cYPpbh4Yc21YrHva0m3XFIZzSk6lW5cLxCnBksz81xOBqxubHF0sIcqWEwP9fEn8SESmLaFYbjiDAcsXV4SMErsjBTQwhNfzKm6GUYFYMgSonDGMtWrNQLCGFyYrGK55XY705oDyeszs1h6DFpotja9gm1oDeUqFSjlcCxLDJtsT8YcDhMcU0XWyYEqeD8ySkMHTBd1VSaRcIkwXPLqGGbYahYaM3SG4VMkoBjrRa1RgE70QShRiYZ0izRqDUw7RJP/fj/Ccfz0MdWcP76XyZLM2698R1+54v/irs7d8liQRhoTCJOLc2ysdvjYGdIhs5plKl3lMOR8NST9/L869fwXBtTO+zt7fHZH/kk9x6rsbPV442rm1xb2+Lm+iH33XeWOJ3gWg2u37zFJJhw8uRplheX6MRNXnv5a6zOrJDGmpdeeY3GXItqrcajjz7BzuEuK8dXkLfvEKWaUAlSBePQJ8wcatUaM/MLFFWMNiOK5WlG3TYH7SFWpUxrronnVQCLFy+vc/7UAsP9gFtbQ9TdNhKolwqcnGuRlgqUKyW22x0O2j1MGdOqCgrFGSxnl+Z0ib27LzJ77BRm6wKD0Yh+e8DQdvAsjdMscmd7l2NTZZ68cI4T997LN7/5PJ1hj7ffvgjRgERIXn7pMj/x+c9x/tQp3rq+xWONCs2iy9Pf/C5bN69QtgTZeEIvtbBKTd56+WWeeeENfuLzn+bTn/gIzzz7Bh947GHGgwG7e11qlSonl+apuYIba1tUak022gnlUkip6PHqG2/SrFYpVir5HEwcsrezz6VbBwR+l/tPHeP0mWPEUYJVqnPhfJFOZ0iz7jLfqDDdKvKTTz3EYDxBfJ9Aq+/Vf/k1M7sAUmIIgzhJjsKL86bLMAxUGmNZdk51PIKHoFKEkO+GSedxGvkd/PfUqCP64zt2uaPHvGObM4y8EXuHDJhlCnEUAI3KGzqV5Q2dRB4FueYZZIZpoLOMdxmCR0HJ0jTyDz6VoQWkcZg/hwJD6CMbZv7asiwnU2qt0akiJSYatCnOnEIcDfwLaSAN+T2S5VFkAOQ2TqEVHBEjpXinQTtqbKSNRHGwu8Vz336BoTRZaO8QTGLC1ZMszJc5PXeOY2fPEE58Di5eZGlhhdbuPodbO9xVGV5tjpM1h68MjvHSwQVKoY1TcAjHPWwhKdpDCiWLCyeLPHGvjTNuMwwE5Q9+nsrHNBQ9pFtGxgESTfrmS4jTF3AbraN5MhMlJAIDw7ZRKsnn0FQGOn+POYoveK/eK4CutUw6idnaTRn91nOsHF/huW/7LMwqIn+MVa0QDiesbVhsbQ0plCXN+Trr6wfILCSumKzfDTl5fJkf/IHjRJ1DDlZn2enXacwuEEqPk8ePM/ZDLh8cIByJoQVg0+sHaMsmVpp6wcDxB8yeOobpldi/dAth5zbjbi9kMhzQLBeZMjSRcBiECVkyoWgLRLnK1PQyCys2V15/DVNmVFybXhTimRKVJShlovpjbr/+GkIq9jbvIjKDkiuJVcbMXIOHP/ZD3Ly5zne/9W0SoUhVhtISQxrA9yzVWmh2t3cwLBPXArdUZnX5GG++/DqFYpG5qWU27qwxW5Pce/4kDz3+KGatThYoXnvldaaXV1i/dYP99Q3e96GP8NjHP0v/oMtLzz9HoVLjYDimu7+NUIr/+HM/z9qltwhDn+z3fw9LCk6cPskgNogbNZ76iz/N87/6BQzpcM/qDGXjCp2wx/RDHyW9+AUu/eYvstDysKctXMeiMNUi0xnGqIMTv079sz/L2h/9Njq7htQe8XiE25oiS0NM20PTZHBwl03fJ/Bsjq0WSIMRTjZmcWmOUqlMGEWo8ZDJrSUajoWfwImWxZUrt+kGmsrcAltDn7FRwNEpQRxS9GxOzHrsrB+SqIxRNEF1Q2yVgmHiSIkSMY5QjPZ3qdda9Lsxlm2jVcK995/jpRde5gv/4T/iuR6tapVm0WZqrskkVfQO+6zOTdEdBbi9IZWlEySxwHroI/gXX0Bs3UamCea953MnQhahPQsxGZOuXSS99CbGwkn0ztsYOsVq1NGzq2A5CFK0KWEwBLuO0EfzzGiolBCphT0/zejVNU4uTPHKgsfu1QklQ+OnoLI//u7Y9+UO7421W4zjBCFcLCvFciWr8y1GwzHDIKLbTcmUwbGlBZIoQwtFqiLINONRl34/oVYsM+4O8jRwSzLddEiVplC0sGyL6+ubFKtlZmY8hOgxHrZJE8XOyKBYnOLmWgdLaObqLktz82RI0jRld2+fzsjHtEpkaYJSkv7QZ+BHWE6MqRM2DzpICtiWJIhHxKHC8wResYRlVnGcGmaphRn7RHKXnq84ubxCNGozsAVFMyZLJ3R7QyLTYKRi7NDEtSMa1TKZElSmXCyjxIc+999Rrs4ezVooRsMeX/31X+DyW1/BtE0co8Ryq4hrWyQoKiWTC+cWWVvf5nAiGGU1LFOgtU+l4vH627do1UsEmWZ3Y5v7z59lse6iohFSuLx2+TJ3trs4jsF9y01uHToEseShRx5mc+eAYqmIEIKKZ+IYgk/88Ce5deMGd7e2ePSRh1hZWcXvHbJzsMeJhRm6u/sU/Yi9nk+mDWynjO9LKuUyr7z+FhXH5cRilYUZgbJMeoMOJ1slXAWrq3XeWB9Qrs+z2RlRdgzmZmex68scHm5x5tg0t25d4eTCHI2KwyCY0I4ntGbqpKmkM0o5O7XEZH+Ar3xufOclrlw74M6dXR555CF++Ec+zUsvPcf69euUdIhlG2xef4tvf+dbnDx3LxVbUZY+CyeOc2Ntn+3rt3nphecYTiJQGaOuoOmZ2KZk6cx5fvDDT9Bq1ECljIIBkyjjT3/+U/hhRLh2g3tWp5gMevksW6nKicUG+55JHEacOblAv+8z7HdBFTk87GJ403jVGoYKSOIJtXqRTnvCwmyNvd2IcRiytDRPxc5od0cYtsHZ1SZR4POl3/w9Pvrppzi50OL6bf9dheG9eq8KxQpCGlheCa0UcTDOAR5CotIUw3CAHGohTetoFit7F3phyBz+kWPmyYESRzNZuZKU54PpI/AIkDdG70AzOPoqjr7L0iNQxdHj32n0OCIhZtm7OVxSCLI0yYEmR0ALw7Ly50gTwmCciz5SIE0DoTVSa440tzwgOg4QgMpSosmALBoBXp6tBgiRWy7fyftSKo8REOSB0sbR9dDv6Gda52JgFqOE5O03LjFWmoJQeFoyn43xJge0jt/L/t11DkYJK2dOc+Ubz7I6U8b2B0w1SqRhipmlXN2Keb20SDI5ZKIsJl1IwgNmmrM0ox2GexFvvHHAW19xqIkhx82IAiHdmdM89OkPcPJsGccfILZuwfQC4tEPI0wPVEQmxLtESn0UiYAQKJ03tPncH0fq5nv1XsF4+X1c/NZbdPZ2ubWbItZT/IHPh6eXWZkucHLa5Le/vctBD4xSgfBQkt7eJQ1SmlWLwzhh/vQFjk8L6vVFbrzsMI4Erx7sU+xGtG88y+KpGa62DbxSlUwJUruGWZhiu7NPNAlJgx6FMlSaJf7opXVkwaPenOJcvcXhQZvBaIIhIz7xvjmuf/NpZk49SmcwInQ99oc9Cp0exZLJidP3sLN2B9O10KHPuU88QXdnxOjmLcZqTEUkKEsxUQalNEGQoDOTDEGlWiYax+zc3cU2LHQSksoMhUkmwCTf2Mi0wlCa1rFjrDz0CG89/U0Gh23e3GsDCi8csvHS05Qdzf3HlzEnO+y+8SyL5+7DlR7vv/8EtenTXDh9Lxdfe4Uwsnjz2Rf57S/+Jhtrd1Ceg2FbWJZBxba5e+tNktgHQ7B8bI7T504wPXeCV559jtEo5JmvfIfObo8pZx/DPAm6ybDX5drTb2FIgevEFAywpUHBs5B2ijRthr2QsuwRd1Ocez6LbM8wXvsOMlVIaSNPfICwm9K+/BbDS9+hUl+jUlohuO5in/sk8tgCc/UCMk0whOLa7/0r7vHbSP8q97ZOk2weclrbxLUl+gT4TIiUomDnm2D+2Ed1oKwDEpVhGnD2niW6/YBBLIiQ+FGCZww5bK+jswmmZZAkGUIL2p0+S4tLbO9sU60UKduah84uMlWS+EHI3NIc0WSAoVM21zeYR2AVFrCPH6c8s4FpDJFWhhjsQasGtoW0JNotYiGwggRNHz1TQWQJFF0QCm2biChFZICCbKcNCyZGsQxIhMrQwxGTnT6m62EuneTsUxab21/CDgTDLMst5n/M+r40Z6VpEzcy8aw85PlEq4JbKWFaHvOFhHq1QBilTNVdhuM+BcsGy6ZgOgjLwcgm+O0hngkzc0vEUcz+uMvc7Dx2wSYIOlSKMXFvyO3bAQW3QKNcZne3zexcjaIpWZkp0gs0fiqwbdjcHTPyA9Ca+eYsadphMvJRMQjh0Co57Pkx3e6E2arDeCKIVUzNc9kdKtxGi15/QLHVxJNjnFDSnqRIu4JlxGTpiHHgMuj6ZEoxNkMqVQuVZVQLdQrSRDo29y5MYwiP7a11Pvq5n2Fq+hhq7COqHneuXuE3f+n/SX+yi0SQjEfMTBdxHIXrKBJZI856BIFBY+YEQScg3utSKNiYgeDCmWXefOsWYz8izhS2YXL+zAq27rG2nvDq5Q3uWV3iwZOz/NYzl3j9To+tvQPOnDzBYWfEoNdm1O9x6tRpZmsFPvTYh5meXubl115leXGRU8eXKNQqXLx9kSARrO8PuHz3gHrVoVyy6U0kcRRhCw8ZT1gqe9QrNeZKVdrtDqeXp6jeLrB36GMRoAKfNMhQMuX0qWPs7nfwkwx/cMjCwnG8iseP//hPMux2OLx7lWbJxXWnGE5GdLsjpopVer0BwrG4eXeIwGJ/7yoH/RE/89f+Kg9fOMfC7DyvvvEqz734IjujA3Ac0lixv7FBvexRmmpw7NgyjqO4u+NTrC+ycqJCr32IZVrUmg0efuheUqPAnbvbhL6PUyzT741oTxRziaZar7G8dA8ozY1b60ShJsjG3HdmifE4ZGamiW0aTMKAnb02K0sPEEUR42zM5u4hM3WHZjVXhLcOJ8zMNjh7Zo7uQZ+ylSPQfT9i/WCIlwWIYoEHH3sfTSfgsBPR7g143wP3fD+W7nv1J6DG3U2cYiPP7zJMDNPKLXyA4Tjk814S4x2kvVa5aoY+CqLOgRgC8S74g3egEiLvwNQ7v6P0u+HSmcp4xxIpjyyEUsrvzYwh0FkeAi0MI/9eyty+lykMQ6AzlVvzjuAcaIXOshz4IfNcNH10Xu9Y86QQGFLmTWWmULGfN2mZIg0mZJGP5Rbz3DUh82bxCHiieSdqID9YHsadBzVzdO7iKEBb6AwtNbeuXsMg30yriRSzNoXV3kMGIeeeeIjL33qB8oNnKNeKZIU6UmkarQrDzR1qtQbpfQ/zU5bNSxsD1vfaBCM4F97mib1bVHWAYVgMDQdrojghYsqWhZ8mHHRuE9x5ju986Ed56P330jrzMObyBNMy0RJUqkGnZFly9B4bR9eQd22aQpCri7ynnL1XeV3//VcY7dylVIlptyf4nS7RYMhadcDDn/sBbm6v4ZWLXHr2FUS5TiIlFceg5rhsdS1mpx2qbsLhTpf1Kwm//ZUON40+3rxLEgYUVk9DfQqrt0/Ztdk7GCJLRTq7/Txew3ExDEkSbXDq5Aovr9+lNwbf7LFctDBQlIoeDcdjrlBm7tM/zKt3B8zPeWwcDLBsi2j/bT7+oftpthr8t//j/8Kz//5fMXzrt3j4Qx/ki196k4PoGo/81KepDgShsLlz6zZ69w5kKabQWJbBaHDIG898nUFnRLPsMgo0wyQjShXVkkWSJphotNQoBe29Q4LXrzEaRJxammFxYZE3nn+RKBNUyy5lS9A+7PL+T32E/t1bMOyyducOXrHEH776G3Qyg632iEQJUqk5efwEe65mEgZ4JZeJH1OYavGX/tpf4Td+6d+xv9thOAp446WLPPiwSRD5mEpx7bUXaVgm1WmTKccBFVFaWMSuXkZsaAgNtC0pz67gPPwxkoXP0v7dX2Nr+xrnF+YIv/vPSMI53JmTuHMPE3UPEDpFNo+jkgG969ewSzaWM4D4IlHoUaj8aaJhwtWv/yp2NmLloz/KHDcxJ1eQoYnuf5UPzs4z2UkJR4scdEok9jSjygyRUyf1Wtw+GNC+2yFWgkGiSSybVy+nmI5L0bTIkoSZukvJy7iRDqlVy0BCGERkacbtuxs0q2XuOXcP6WTIibk6y0slGgWJqaA/SGgWS0w3SyTRmGjUx3TLBG/9LvVTc0iviZh2oVhG20WEU86bJstHWA5IF/wOot4ElUChBK6DUKAzBWkGo5CoP8KdauYofUy0NBG2hZFN6HXG9HodhuOQVCn6iQAlaHj/mWyNUgUokZGlKY2ayzjVGEGG1n1azdME4yHlosNoEjMOTCrlCgXbYOhHoLpM2wbdcgHLMukMhhRcSanRpD8ZEkV9zIpDZEi6w4TVhRppZjAJEsaJpt0bUFsuUnI91jtdDGFz9fZtet2URtXD8xrsttsomVCrVFEqpFiqkwZDLEym3RrtaMRed0DZtTGFZma6SnWqyeZmwijIyCJF3xOY2qRoawzL487NIUvzNYrHzjKcjKmWHbIkpuQZjAddLDNlPIy5EyqK7pj9A0ljapY0UZgFh0uvfIOnf+8fc9Dp02pWGI1Dbm/1OG45ZIMOJ08dY27uLC+9fhFTWAw2d9gcJHjlBlk0ZqbqsrVzyPz8NPvtPr1+n/vOnWRldZk7ly5hWQa94YRjK7NoWeZ973uEgZ8wNV8gTRVZGjLVLFMuz/KZjz9K0SpQbS3wne98G6da4b7zp5CFBnuXnyfTEeAgTYv+JMEPFdqQCJnf6KRCgO3y+GNzxLGgN4hxooCXL92hPRxTKxiUCxmb6wekTonW7Awnzj5MmF1l8/JbaG1QzkasH0r6G1cROmSqUmBqaobDG2s4boHTSw0cmdHvHVCql5FS0+sGDIdD/vxf+Wk+9MT9KAQL001GZx7kjSsbdLa3qZ5f5uTj93Lt6k1WTp/gxLkzNFrTDP2ET5yZxikqOgdbTFU8Am2ysbnLaKIYBwdUCi73nF3k+p0ezVqdpfklgiiiVC7x2utXqTVmWZxfQMWaWBnsdnqcOTVHCuzsHnD7xg1qUy3iVDGaTLj05jWsRovpmVVGcczB9haNSovZmsX+wYSpZgs/yrC1ZPtwwNLMDOPBAcdPHGe/02e3PeL4wiwP37eMP+5+P5bue/UnoCzTxHZLGJaZAz1kTm2UOrc3CpFj6UWWo+/z0kgkmc4QkjwsWpPb/HTe9Aihj6yP6t2Qa5RCoHJK4JEVUQFaS45yplGZQgqF0Ab6SJ7TSiHeyTqTeeZYlsQI04YsRZpGHk4tRK5u6Xdokbm6ptM8q0zlncdRbplBmkZkUQCGheEVUWlKEobYlVzJEyr7f1ONvgcwecfm945iKOWRaihyQls+swVowUzdo1lyMFaWsC7vUwx9ppMh7eeeZeF9f51ytUjUH1KdakESY8wus3HrOotzUzSadeoXTtD9va9RTQXjuMdotE8FTccqMskkBhk3zQJPpV0MqYnjAC0EpkqwVcydy3tc30j583/9B5mdXcUgf5+kIY8sWGY+Jwe5IqkUQmmEMNEotMhf0Xv1XgE89kiDzRcvIdKAy/GYQFqYMuDu7h7rsUv52BPsr62hpUTpMa2CxUceXKRSnubyG5soIrqmx467yitv3qZbSWnMT1MpmwxGGYNJRG93jFOtkhoGMzMNhDRp1quYVsYwSskiMMYmb1wbsjwzS0NZZDJGaJikkkQLVptNnnmri5/EaAmloqJUrBPvdYjWL3P2J/8czeYMb7x6hc/+jf8O/J/k2V/7fbbXb+LWXU6vPMG3v/w8t64+zX2nT9DJFHa+04RhKM4++gQXn3+dehHGcYLSuZ06UiZRkuFwNM+qBQJNPPYJb13BsKB/EDDcO0RJk0RlDP0Ip1EiVJrv/s43KBZsBnsDsnCCdAPWDtoEpodd9kiGE7Io4fK1KySZQksDfzAkUyk723t84Qu/w9mH38/o2RcZDIfEvs/tm7dYPTbP+qSPUu8EapsYaULQHRE37uO+T1Z489V/SHuUUO8YDH3JwdUOO91NjIXzzJw/BipGZxkFt83g2nWSOKRYkBjlaWI9zSgtUJx1KJuLtNt7ZGGINgP2fvnvUDl+D3Mr91F7/8fZffVZ1PoNPDfCIAItyfa3EXFEId5gtVBkuD9hfr+KrtQZDTzqRoNBYZ5Du87reyN2gjJDt4pwXaYaZdJMECQ1HANSq0RRTVhdWWRrc5swTrAtA88r8OT7f4CLL36XxdkpTCkpFct4GJQqLpal2e+1KbeWCPa2KJ86iVnzEF6ZYWea8swKoqBzq6Kw8txI4QEXIY2g2kCURU72dcu5KqYBGqhOhJwvYddHUPDArUCxAZYF7U0KjQrWVpeN688wGCc0iiZpkpEpiI7AW3+c+r40ZwoD1ykThT73nbqPbm/E5s4Wrp1y2Fun106o1F1CP0MaJhsqolm1cN0My/JQqYntplgiwhY1NnbaDLMJtVqDVskhmbQJA00iLa6tDaiUMjBLVOouWabY73Ypejatsk3Vc5mE+cUIUpjyFH4gGPRN5qZarG1ssrgcMIod2oe3EGYdYTbxbItxGCNEgeW5Oge7ezi2w/LqaY5VE4bdEb6VU3xmZ2bZ2g8YjSccjCSu7TBdKyLdOlkaYLom9VqNod9jZ7tNVi6ycsLjW7//Kywcv5+K3eHpr/8SpZLHXH2WkT/G9qZ56lMfZvXUSbKwz3ACpuNyYmWF9kgTxQZuEuBHMWdWpknjCZtbh+wHQ9IkBS1YPr5MmilCq8KkvUa7O+Zrz17l7D1nKBTLaFMx5ZQZdrY4sbJExTOYn5+iYDsI02TvcJ9xkJBGCeNQM7l7A+KIKFAIOw9tlaZFZzjANC1Mt0KWalaXl9EiYqNrsNow6IqU6tQMxUSzdGyFu1v7zE8XqPa73N0Zc98jD/H4+z/A9Ow8h90uC8uzbG7s4VaqVEomDmMuXb3FqXMPYLlFmpUCQRiSSM3swjR77T0M6fLTf+HTtLsx0zMtLl29yqnVJQa9kD/4w2eIw5BGpUyShKxdvcgDqwvMzlUZ729w6dWXOXHiFCNfcenaTTzHwD3RouRmXLx1jaGf8qlPfghTSTZ2x3iuQzpqc3XtLsry8P0yYSywHEGYGJRaM/QGY67camNZiv07t5g/doonHn8STcLbb73F0996kfvOnuT0MY/+7i5TrRpLy0sMDttYsshwMOSgH3ByoUzBrGAZBrfv3OLksXnKnsPIdUi1wXDcx/NKvPrKm6zc++Hvx/J9r/4LL8MpohOfNA4wLAvD9kBYOaxDZQjzew2ZStOc3KcUGfp7tr7/D9tbrmCRQ/bz38uSo2wwgyzLLZKoo+YvyzBQ+fyYzps3tEaQK2jvmB+1IMfA6yy34AmBSPOQZ6E00jByEmSavqvc5SrZUZaMzjMopSERhsgVQinJpERHMabtkipN5vcR6RyGbaEQSMvK58+OjvdOGDYIDJE3jhjG0Wm+K88BEsOQnHvgXnZ32iwur7C5dhVTw9h2qR3skXQ6zCzO0bt+lWbJIh71KScDlJ0hez3UiVUc1+Rg6w7zKqFq24yminy18AQvFy9A+03m+89z9gMfYO+7T1PWCcKwORSCRGvui4c8MrzMF4qfYX+QUUnWMMpVhCogK8U8aFwfQVr0kVqp1JH6l1MxDcNEvWeDfq+Oam66wMwDJ3ny0VX+3S98lVcDRT+y0UQ8843nmG4dYzQYsXzPMQzH5OyUR5MJZ5bmkTTY7vT45nMH3N5PGe52mTnlYjmSV1/awyqXGPgT6vUiUim6231KpqZoCyK/j8zCnJxXqyHtfKTCszPMVOP7CYkC09b4/QkvvrLLIPDR4YSTq1V6mxFBf0hn6w5LC2Vu3drm2qVrGBhceuUN7rnnPh768f+a+id/irdfe55//Hf/J1ydUTRSbt64RtkC09BkcUImNGEiMKRByTaYpAEnTy3SP/TZaXfRmcYwNKYUZEcbNQKFIRSkiqEysZHESpPp/FiZzGmyI3+Mn2WEmaLfH7PTbzPSFnEcMW8IFsWEohnQCw12RIG9NCFWIIRBqFJMy+GZr36LaDQijCNsUzMchUzPr7Czu41MI6zBATNLC8SjEX6yg58ltCoDZqs2a4cTkiSE5BLz128i53vU5qapVKeIBmt0uhNMw2D6nuPYhTL+9jrtq9e58eJfJ6XIbK3L2JXYjk1xpkkaJPQnW+jOmM7mCwwuvkrsb2Jl+9hOFUwTWZ4lGe5TbJQRSUw4HiATnzTow/AuNSmohBbK8UgaxzhWmOet8hKXegGdqMq4PSGzioyjEK/gMbV0gmx9Dx0EVDyXgutQ8AoE/RG//Wu/yX2nlzEMwfRUi2qxSt2rUzAD4vGQ2vlpssMd/OEQOTUFi7Nor0b55EyulCUg3Epu2Tdt0BIapyHpQRwhVIKSArIU7Q8gDBGDhGBtC7PVwrn/AsIS6CCG/R2EV0YriXXqGHPjmAe0hyjXeP6VtxBvbZIlmlrZ+mOv0+9Lc2ZpC6EVbrnE3c27JGlGuWiisBiNMyzHRiO42/URWnDPygwzzWmsJGAcR9QbVcyJSRL4BHGE5U6oaEXdsxj6IZZloLKIw/aIerNMY8rEcWrs7B5SqFZYXajgWSVmpgyu39liFI7Z646wLZuXrm7h+wHTtWleev11FloOd7ZjtLHK/fc8RqPeYH13gzix6Qx8ppsNasWQsltEFZdI04CJdQzpbVK3QgbjjNff3qRaLVCdmaNSHXH3YMTuxKFRsiiJlIX5GcbhhCS2Obm8itYxMhXsbr/G2t3LDMMA167jtyP2ewLfLPKTTz2OKQVGMqFeLTE9ZZAlJuXigySbfTYOI86cnGFjY4t6zaPXSSlUysRKEicTluZnqJWqZLHJwvwMV/fucuq+Bzh1/Bj9TpdxlLEwv0B9ao5w3KDMBNKA4eEAA5NqtczujU3CNOTatbssr8yxe/dtmtUqOBG2bWOZFqYhQUgsy30XBBBkGY7pEkY+NzYnVOplBn5AqzpFvWJgWh5+nLAzOOT+88e5df013rpylYptsTKvSPq7qKBHhwnzjQZxGHF8dZm1mzeZxAahH1OuOkzVZxiPI1oz92GN+4x7h7gyZHsrxLYMLl66wqn5OuGoT9MYM3YNPEORhAN6HQlJCMKk7BUZHdxh0iuw+fJrFM49wvLiHLtBxt5IM5mEXLmzxcPnVmlv9hGpT9nIg2qzJGIwUNx75hhvXlvnoQfPs3Frk+988xlMy+apj76fO5HJ7FyLw4FPt9cnkh4f+/CTmOmI3mGbpdVlqpUiQSBojxIWlEM8mnD+obPcubVNnKScPbPE2m0wLZeBH7J19w47vTFPPHgPjSmb7b3B92Ppvld/Asq2HNAKw3bRIkOlAYIYKQ2U1iht5XNJRw0KaZpj8A2Zz10dwTDUO5bHoxBpAE2aP4mQOV0xUxhCgtJIYYABWZaQRiHCcPLH6wxpOEd2O43Kk6xzWmMaHjV+R4HZSLRh5c2fIg8hNU1UGiNMB9t186cXAkPIXDGSAsM0kYaBU24wdeYR9t78DlmvjekUGLb3cOvzOGbziOyo3lUAVZYHNOc5Z3kQrZC55CePQCNaaIR+ZyhN0ZpfZGVuCrdoU/uBjyBefIFMmegswhx2mSlKbl++wczJs/QHAyZpxlTBw+jtUZ2ZJnnjdfppxle1x6lQcUJGnNVvES+dxDtzhujZNzl7/728felN7ox7ZLPz3FX6/8XefwbJlubnndjvPf7kSW/K2+td++7x3s9ghgAWgEiKCxqBZEgUV5REBbWiNpYRyw05rlakuKKWZkFQXBp4gGOA8TPo6Z52t7uvt2Vu+ar09vj31YeT3cP9OBEdgV3w/iNuREXVvVmZWffNyuf8n+f38PmTTXSloY1PSIMW1++2mKmfkF75CLVCPivsVhlCX8ls05jpzuw1WqChCZDvPJbH83gAbTLm6Q+cYa66Qtl6lo88l2On18bJ5wgjDcPSuLg0S+skxPc7lBdrzBRdbt7d5K2NQx70DOK7h4wEXF6vskRM+/4jKrHCK5QYhxCGCtfyyFccKjmLmbyOo6UEwy7BZEzUH2AJjc3tR5xer1Mqlnn1/ja1uQqnl5bp6SmHQQctHOO4E37mwlm+8/Ufk062+eAXPksappj5KrMVj2eeuUK/2SE8nvDKWze4vX/MaNhBUxqenaJrOnockiQQkmVsrSih+fpL5DUNZULpqTN85At/hn/5//nnSCUJwhjP0TCEQgiFqemkSYSBhq4JUgXS0EnTrKpDTxN6x12ONajZFqvzy4R+xEavyyDRAYWbxqzJmF/6619g7gOf49Y//If8xtdvEhWqDGVKFMVousadN1/FMExsPUU3BIauE417XH/ljzDzBc4+8WEOXvptyqUiugSvUsAsnMINj/jsn3ueX//16+w2+zjGBMSQRfXb6EkDbXGOk4FOWL1ELuqxcb+JHmwRDXtEfoBlmzjaEZISoCNcC6RO57iJZeUIlKS0PEf/6AaGljB7+hzNzhDReIK5tUu0Nm8Rde9k2WZdYHoGmopQiYIgwbQUqSYpxFuU9D3WOeLJ1fdzy61wV5UYmB4qSalGEtuosk2Z2RmH8e4jnr1yhc3NTUJNoOkaQRgSJAIzV+LezgFFU+CaMUW7wDhNmWsssvjRc+hnXsiIi3YxIyoqB6UihC+QJNAfouXLkJsBI+NZpH4TTekoFSI0HSYTSELcWon4aA+xPAdLZxhv3sO/38Gs5Ck9tQT2DHOXYm6/do9JR/G+D3+YnQe/xUKiOHem/FOf0/dEnJ1aWWJpts7ecYeuP2J5pkhrr8Vhb8JcpYIfh5i6ST4XkrdsVpYWsx4Iy2bCAKVCoiDz4uYLJprI0/ZjojhkNAzpDHz6kwmlkkvelCBtBp0OS7N1Tq+tkyaKIEhxHA3dKpEOdM6u1pmda5DsHDKeWCSaYHlpiUbZZTIK0LSQZjPBsYZUvAovXKqxc3LIcDiiM0jRtZRnz0x4dBQTdB5iipitozElz6ZRyVP0NHqDHl6hxtKMTioTNDNPrjoHdBiHCYP+kEohT740w+Fxi50THdeZcG59jVdev06pXmVloc76+gKeiBCmRhr26YQRplNiaf0s93/8MqQzXDq9iKvHrM5d4uWX3mCmkUeXgk6ngx9EPHXpPMVSmfVTKxzsbNFqtnj/J59n7EckQRdUjsP9ByxUHfzRPjf2Wlw6u8Li6hoHO/ew8i+wfXDEqO9jWDqjYZcoVGzuNnErBQp2Dss2UUphaBpRFKEbGrZpQTohCHWUkWeCRdrvUa2USXU4aE2wcyXyeZvn3rdE2Yx5dLRHFExINZuSVeFEHtAe7LNaXWH3qAPKwNAFj5rHyMTgueef5yMvXKJcKVAt5SmVy2BVkfGEyaDD4cmAe1u7fPuHP2b39BIXzp3i9tUj8jmdXqgTJBaBNLhztE3Uh9n5WcJRF1ck+KbOXNyknD+FsPNcXJtnpFnomk7gj7l0usE41jBMHePwiL1Hu9y/tcHc/Dqjoc93vvcqD6+9TsnxqM+W2dk/4ouf/xCWCBget+g0e9QKOpcvrPHa24+Yqbls3r6DV6zh5AsszZQZ9tusXzzFpD+g6GkImXDn+tvsH/T58MfmkNGEvGvw1MI5atUaJ80xF648/V4c3cfzJ2AMw0aRAgka+rQTLEUqMktfmiATAUIDLevA0jQDlSTvUPBRIstb6Rm7Y5rnSqcsj8xuKIRA6NPi6XfKnJNMZEklUTITY+Kd/JZMQWavF5lYEMg0s4m8S4fUQEzLoXXdQKVpZrjUsz422/Wy+6JlUJKpfEJDoJsWQtcoLZ0nnAw4evvHxFGM0g36Bw8pCYlTXSJNg/8hEEPTs63iO0QUmG7KpqMym2OiUjR0vEqd+VNr3HjzAc998XO83euR3r5NRY5RkSJst8kVKtx+7XXi/pjm0TFzWkwdm/a3vs2tSYrrFSh1R5w2Uq7pHk+4kl/a+XUm0QLDU7Pwb/4pi+Mx2ld+HquYZ/Lbv4shBEMl+LZZwNcLXN1zOXX6HOb9A55pJeSevoJG9jMlkUgy6+c7lBYhsudTaOIxD+TxvDuvvXmT06Wz/NvfHjDM5wn8hGJhjk6rg+4VGfjQ7/mo0KegKdYrOrsbu3Q0B2aWqKpjlExYzufwTw4ZaTk+/PwiOyeSk2FAkNMZpjF+v40hBHGsMdZK7HVHJDJidaaKlsQgU8rVItu7Jyirx6B/QBAcsjRXpVIps7WxjW5IkAb/1X/7m3zqix/n7NrH6Y4gGPXoDiRf/Jn3YQidNAe/+49+i5cfvMitO6+jmxqWqQhSiasEUgj8NCVVAltPMYSANMKwDDRNUXRyCF8x6g9wTZNYxQSJgadDURfoxGhmRsRVShLEMZFMESpFBxzNINFT3vdn/gwHV+8yGgx48+4moVQU5meJhj3qUcwX/uKf4uKv/N8QosDaX6yS/+6voNsG+SSFVGEZKZ5pEAQR5brH2pPv48YPf0S52uDyk88gI7j/3d9jdTnHcDAiGk8wejvE+xuYpZSl93+Y3MEc/h9+nUSfIHSNIDVo9yNubm5z7daEJ77yJBU3z8n9bzM5mnDip8wXJAsNnWpBRwZD3Po8urCIkJQX5wg6XQqFPEI3KS9W8JbW2XjtPrOnFsh//K/SuncDldiMByFOQeB5HoVikbgSkA7HDA6GhFGKhiQ1TJxcihrc5ImwS20uQJhP8nCcYuHQubHNnbs36cqEjhywtLTOW9dv4dg2wjIxdEGnP6bvSw47E+rFGnlXkI77YKRUl5YxjQRjZg6kBkMf2Y8QnT7xw0eEx206Ryf0TZ29azc5f/YiK3/jL2BWKijZRRgOoneEskzQdVTOQ02yLjb7wnkoeqh+Gy2e0O/2mJspgDIhTkD3uPLRp/jWV19m741jKiWLfhwh0j+mnjPd8NnrdhgHYyqeixYIojhmZb6MaerUciaubeEUZhlOdFIkvSDCyymkITnud7jxYIelmSICm1S4FHMaJ90Y1zOoWDlmrSqOZWCaOoZpsLSyhikshr2A7mhIIZ9nPOzj+z0WZ00mQYBjRRTyOSyngEVEKAXjwGQwGaHrIzQt4dr9Q06tLOK5FjOeSd4ukGgSzzZ5eNDm0tkrzNRWOegNSfVdkiQmiBSlxjIfPrPGzMISQRzTH/jMzDbYfniH2zcfUZg9w/adEfvjAbOViIKrU1tYo98fcnC0zxc+/1l6w5iDzpARBbqaR8XO8fbdDe4/3KJSqXNuZ4ymudQ8WFo9y+svv4Zu6Jy/sMwbb95hFEk8r4BSfer1MufWz9BsHqObLpg53rr5gJPDfT72wfdx694GGBD3j9HSmM9+/EM82t7h3IU1jg/b3H5wj26nhWcHPH1hnSAaMzg+Ri/ZOHYeBKSpJAhCUikRuoFuGSgZM1ObY2/3Ab1hH9st0ZcOpiOYiSN6vSH7O0M+9twZlCbYPThmaXGZimeDmGBZGnZulmE6Iu+6DEcGO4dbrJRL2HqB1fOX+J//3IeQcYhtaOQ8B0OkJGGbfqdL3nJYn6+wUM8TDIf88OVXaB12ODo5Ya1RYBj2afcnuKJCK0qZcz1sJYh1QXXlEg3dYjgY0+2ltMMBlWqF8OSY/cM25ZygWirxw6sPSMKU1eVZhiLH8rkrFHIaIo158ObLnLvyJP2xorqyxBMXlrBMnaPdPkfNDjP1MiuLNVKlU8jnqDfqVMo1dg+blAt5XEsgLQfXtmkeDSjk83QHIbqRI+eOqM9VaG49QgmdatEhmYzI6SlV73GK5PFko5smSumAJE2m+HTeoSj+JG+Fklm4+Z3MmNCmGSsBWeIKIUxATkVbBgnJBFqESkFIgSATW4p3QCJk2zKmSTaho6lpXk3LyI9MM22aYfPOGifjb2RWycx2pxCGld1vmYkK0/WmdEU9294ZBrxra8x6y4QmqKxd5uThLfxuH+kH2MMB7mSMXTMQ6O/SDIXICq21d+x/7xAm32X6M6VZZrktSDFME9Py0OOY7v4x5z79BTpOnvHxLkbrkNbGFlG+wY/v7ZGYFjm3QjccUSFi3vf56GID48x5Lnd7tB8+5GMXL7L05S/R/vHLOMuncdwcD//pP2ZXGhx9/0UWwzEXohGxZvCqbnNDlkknOURf496+oGRYPFHXUUmA1AyY7vyy+551paVpitJEJsY1/fHi7PG8O1qhwe+/2mZz/xHUq5gtD7tQIGcbTJKItDvA8vsUbIn0inzzlW2CIEHpNlEw4skz8xy0+6SJZGVtltMzDrGWY+5Ug/hRh+POBnPFIgkmJZGihyNG4xjfB6Fi4jjioN0nUTrDfoScxOTzMW7OJgxDXn35TfzAJEpTYhmhayFf/NnP0hvnmRwFTKRi4ofs7jT5wXfe5rWv/iHD7ohBOKBxYRV943UMI0XXdXwfAqnwDAPH0kjCFCkATUMlEpkm5Nw8rdv3+erVv0fB1BBKMPATJkKwVHNxfJ+iJXAtwUSTBCOBbgn0SBJPkbVhkiJQDO4f8WDjhGRwSKiBqSnSIERGMYmf0N0bkcYmuqXY6krE0x+g1t9hvhxTVSFyPEaGEV7O5NRnvsTDNzc57SToQYvBGy9ilUs8cdrBsTUclRInY/T1ZUbfewX6Fream9RmLnDl6SbO7e/jWgIl4ZWXm7zR1WkJm1f+7b/jQtlEiyd0hymmrjBRzM0WKC9VIBziOC4CjclwSBiG5PIGeq1O/3CHSrXOqNmmsTqHk7fZ+Gd/h9n5GUa9OziGhlup0d99RKngIoOAJIhxPB01lGiaQiU+uvAwdRDpHqcG3yExOljqIm/dj7h15yHdsEWk+Uy6kt5wRBKGeJ5OPp9nEo5JYp+tvSZhGLNQK/HMhdOMw4Cc53F8OGRpfh59x4e7tzBu3EfdugFbh2hJSNgP2cvpfLUbs4/J8vdu8VcqBdb/2l9CCAl6DlmoIeIQBk0II0h1sBxwLJTpgnAwOkOWP/AC1rk1hGWiZIwQx8ycPc8v/S9muPnGA14Z9hi2fSrVwk99Tt8Tcdbt9xiNjqjUCoSpxPeHLK+WMfQUtASbgKN2B9sqUPJcIjmkN+nT7Jo4jsawP6BRdCkVbfzAZvfgmMZcCWFIgkjDc/MU8lV6k2Nm8iVQkmCsCJIJtq6xvXuMZTQRUlIu2pRdD5TGw80DhKazOldnNHbw4x5hnDA7UyaKUvY6Q6y8xyiCUOqUCg1ymkGnf0S3r1hdWmfU6aElCYXiIiZQL7qkMqKYM+n02yS6wM3lObu+RBBG1BtLPDp6nWU75P3PP0WxlOeDT50hAfzE4e7GDi+9+G3q7RGnT5/BLisqtTyLjSLbu32evPQkjplncWGBcTDi6LCLFYzp9W5RKOQZjkecHHeolgsc3NtCszycXI5iscCof8xkErA0V+fpp5/me3/0El/80pdYWDrNo8Mu1bJDN0iwDJubd+7x/Afex5tv36c79lFJwM27D7ny1LNs7RwzN1tn5fKzHB/vkcYBEo00SYiiECGydb5A4BXKtEIHo7LGh585hW3ArXtbGIaONAyCZMhSzaFsTxiOOpTKJuHoGOWUCOIWUWRzb3sH0jxXr20iEURjwfFRlz/7y3+Wz3z8A4jeQwKlsGwT29SQUkeRUK40shCnrmFr8OmPPsdrD0dsPLhObxSia4L1xXlcx8LWc5w6c44nT1U5dfoMJ/sdgnCMjLvcubZBqVxid3OLD33qk4yHA+699iMcFSBPL3NqoU6YWli5IiWnRuton6POiGGvy/KFp9AsnYX6DJWczfb2Ed32EeunTvO+568wHPhsHvQRQKlUwHQ8/KCLpgucUh6VSPI5i5yeYM4UEGYBP+6wux8Q6lV2dw9x83X6R33YaTG/ugIotve2eP69OLyP53/yIxCZdRCBrplT4ZRO+67Eu/mtd0iNCLLyacXUyphZdxQSpbJye4138PIZDESgZ7ZGlQE9EAZ6hgJEyQxOodIERUqa+qRpZqnLQCKZrVCILFj/k8qtzHqX3aROqqaFr0Jkf18JDNtCpimmZU2FVWZ7xDAQppkBRQDDyjFKBX4YI2JJEvgIpUiDAZqpZ99b/KRsW/17q6QszpaVb2dLJy3LpukapBLfD9m7v8nZi5fYvPmQ5TPniObP0TeK3Lh6g95wTJTTSGbOowyb+1v3MDWLikzojgPKg/tU7t4nLeRoWDYlM8X67h+y8NQzcOkFSAJaP/9zXP2NP2R1POHjeZ0oAqSkowx8bwmZBOQSnYNBEd+L6DbmKRNnIhY5zdTp7xQMZJCT6ePR0Ka9d4/n8UCl4NEPU2afe5a7DzcpJhobd+8hlM4kSZjJKU43HPI27I/h4d4Y0zRI4h5Bv0PF8Nm694jOJKCQc/A+cAZ/V+ftt15HcxW5vM3wqMMkSJgrCJYaRe5vnXA4iBEkHGwLeqMJiRQYQmJpkkpg41mC3NIMJd3j4d1DfDRcR+Op1QWElBydHLJzrKMsQa1Y5fbtR3Rvv82r3/9tCjWdz/+Fv0w/WgLzO6CNSZMJpqERxBGmMKnlXYZySJQkaLHCNjLYUKhJ3PkaHHbJIelooGJFqmAUxFiAlSbMl0qcev4Zvv2HLzIxHHSZEseSBA00iUrg3is/QMUaxUaRNA5IJxG4KU99+nM8/N0/5Df/zfe5cfi/4ak/9Qv87m/8Lhs3b3NqtcTZmseVJxfQh01KroEpJJsPb1Nv3+PMGYHhJOhxH9eNGAwm6GhYJ0PGUYddf0j3zl0OlYlIA84EmwxPdsjPCs5dnOVkv09iKKSlk2BjFm02hj3sMKZiSXJoDCaShxs9Ckie+fhFvOVFeo+2kaUF8nqKah+wd/8RRrEBQ400HVE/fZ5ms8X8SorrDchX12ltP8IfjIijlGFvSLnkIFIYDUMsR2Doglw5j1SSXMlGJimaGPKU9wB/P+TV+138JEEYKZ6bQ8mQ8WSIbpscD2L6kxG6keIZGnIQ0vFb3NtucnWryYWzZ/neqzf53Ok16g962HdvYze30Dod1IwBSwYMx9S8mHMHNv1+wj1LMLJ1Xvqdb7P0H30Wc2Ee5AQRBgjDRekjRPsEJQ3ioY/hWojjDngu+vIs4eEj1Mo6BD5y3EGkCUF7TBoIeu027cM+uqYzvzj7U5/T90ScubbObKWcHTZXY//ERxskpEwgAaW5THwbzQ8wGGJai4jUYDDokvqCRPmkOpx0+xhUGEVQlwmTsU+lmGPsT5gtF6jNOSglOWkNsPWQnOuxc9LCMW2ELjFJiOMBE0ujUCygGxqtVkq9MUuxpLF74mJrDpNkzMp8g5xtYHslojDkeDBCGCampVFKKxRLguv3DqkUbLyJJDqMkFJRKHqYmo3n5PDDmMlxlycuL7C/3+S4eYQSBo1KnmjQZG7pPAkav/avfw+hAg5bPsuzBTzLJFeuMklNZsuCbq/J771xg3Nn1zk63qPV7pDzPCoezNaLCBVhOyZ37m+T92zyhQJ3N/YRwiAOfEqVPHkvx+LqAoM7W9zf2sNxczQ8yf7eEZZbYGt7G3+xwlzJQWgmxBM6zRZPPfkEv/eNb3FwsM/yyjqDccDSymkUMBp0sHQQhkM+57K5uYkUAqG0qX1GUKkUUP4IqVL2th6yNFMiHHWpz5eZqVfIeRUK9oS9wx18v4Wbcykoi5udHquLFTAUIomRic2ZxRVUKlEioRvr6DLi6g++Sr1RopL3sOcWUTH4TECCplL8MKZUqeB6HsoY89TZGXT9Ofz2ITpjFtdOc9IasPbEFWaKFiXPwnZMXnzpB0wixZOXz/LZz32Cjd0TannYfXgDyy0wLi1jVRc4GdvMlzU2Nu/iyxx+JKm48MMf7pDqNs9dXKRSKzPfKBFOxmwftFmaW6Df2qF7FLN2+gI5Qk6GGkKTaG1Fkmrk8wa797fwU8nqQgWznl2df3jvFn4oyBdriP4AkaZs33kbXxT59EdeIJyE7O7ucvb04ntxdB/Pn4B5p2NMQ58Sx5IM1Ugm0jLdNsXEi2l5M+nUiiiz/JhuZnkvkQkVNSUYKpnlmSQSoWehZpnGQAxaBhLRpmXWmqZNt3YKJVUmAAVZNk39BO2u1BQS8g7OXmhT+93002QFsEpKLCePABKZ4pDdnkxTbMvGsFzekR9JHDMcjImiGDdMwHTRTAeSGGFmNsssl5XZOv8HLr8pPp9pRxhiiu7XNJQmOD48YGfrGFsrY2ke43HI3Z19rt7ZREgT02hQK8ySM022t48p5D2ENJlNfJaShACTR4UyO6OYtSBm5aU3aHzuU5iNRbTmHijF0nMvkP/6S1zodTEm4EuFQuORUyCWHlo8gTRiZ7dF9coMxbxAkeX+lJIZx0Sm7247NYA0RiCm2b/H83iysYpLpMMRzWYX0yoSplApzxCojFJXqufJnT7NSWCz//qPUf6QZ86v8eb1LQwVc+f+bVbqFbwRjEPJ7//BjzF0D00XzBcr9Dp9Rr4gTAPyjRI5x4Ooh6NiYikJAoWXMzEsgZdzyeeKhEGI5xqs1OeJ+zkaC4LYNMnbOouzFvMzefxqjaNJipkzOVfV+P6/+x3achNlxDz7sc+zazfwfZdYaphCIWWK1DWWTq1ytLXHYBxgaAKha0hNoAo19JxNKV/iqU99hT/61X/Ighlx3kjYlxq3lKA5TMlboGzFqNnl+h/8kFkSzv7sL/Pid39IsLuH0gUKnVQllFybceRzav00G5vbjBMfT3e5fP4DvGy/RMezOH7zTb760ovojsuTz57GS9uUCmBFHY4fPsColqhVPRpOm8JSTKVSwNAVKhFIkVJ0U2zXJuj4JMMJ7Wv7xH5CMpYwPCSdQKOsce6JBXKVBn7T59yyTTeRuEnAci7GsyNMS6ekCVILlhYbWBIKyQQt9hndv4kIEmYvrJD6I4KoREGGyEKVne0DLjx1ge7xEYV6g6ArsbBRscS0DIQGC09dJtzfJRz3IIkyce9LLE/HsN/pkZTEQUyaJljjfV4449Hs9jm+GtMyXWLpY5oG4zDG1FxUzkRTGppj0B8PGXdi5leWebS3hxzG3OyPsLyzdG/qfLA0wN3dQBV6yIaJlkiQHhQk2JKaSvhcN2VbSXK2QSc6YPT261SqH4J8HYqCDK/kI4c3SWKToNPHm51DhmNEpw35Ks6l0wiRIId9tl+7xngwwjUF9x5uEivJMIxwDI+dnZ+erv2eiDPPKqOh0e72aOgunpPlEkzDZKIEc7WMZtfsD5ktlfHTkJrnkYiUMEgpWBZ5TXHQnIAjWWkUcXWL0wsFahWLcZBgCcGtu4f8+OUBH/7YHKW8oj8eoxkRMRoxFRwtZLYoaLZ8umKMAZi2webuEetLC1w5s8b+/iN6fsyj/RNWZmvsHHfYPzmmXJ5jOPIpeQrhreKZCVcuz4GeY26+gue53Lu/T2VmnkFrlyCNGEwUb117g2ZrhG1nRLDhcEyhWiMNAw5aXW7cuMvR8SFnVlfxXIdPfOpTlEpl7t5/CNJHSo00ivnE82d568EBkyDiox/6IK+9fR0ZOCRpTKVURSmd+Uade/ceoOuwNFfFj0PiYYSScNLq84//xVc5c2qV58/NU5l9mkq9ysbmHnfv3icNB9x5e5vZDz6PYZvYhSo51+Hejdd57olz1Koe3XaP8kyVSb9FnEjGfsja0ikcAlzH5EcvvgQqsxc5po2h61xZbVDKaXRlg2any/WNDhKDvf1j0lSjP5gg0wi3UKKcr+KPfY7GIWHYY76+wGQUcnb1/Zz09qmUyrz46m0s26SUc7n++rc5vVThx2/2WarksIs3eeKZj6ExZDTu0m8NWTh1CdwS+TRECI2zS2V+/d/+JoYQ/NW/9IusrS0TK5dYCbbv3eONq4ecPTXLE898iHqjwspSlbdeu8nB5hZriyWqjTl+59uvYVkuGw9vk7M92vkiM0WTG2+8QXnlLM8/8SxC03jp6k1EOuHC+llCf0Jz0GV5rkiv5xMGCYVineF4wJlTKyxMfLr9JlsPH3Lt4QlzcwU++r5LbD7YgcDk3rUdZhdX2Hl4H93JkSYaF54+h2OntA836ScGnf053nzjBjIYsDrfeC+O7uP5EzBiKn6UJhC6ObXsRaRJBChUkiJ0C3Q9A20IkVkNpY6mK1QSo2mCVGZWODXNXKVpOgWEZKopSbKAtK4Z03JjDU2k75IZFUwLnMW7oBGhCTRhTMWQnIq3dzyE7yTIMjw+aTK9lTTb5CmwLAulaQiZEQmFpqHrBqbroZl2JvoE9Fv7DPsDCrZLdXGJ8twiwjDRTROZTq2eKgGpkJoxffzT+y1VRmkUU5T+vyfelBC8+sprvLq5x92jLN+r33eRaUy5YhBKAyETBqMWoFGkTSWfYmnQ6CscTGa1BDlfozVQ9LodbFPRODlAPLyDfHQX9fEvcP3aAQVhsGhZTKIJE03Qq9T5pf/4z/Nr37jOSW/IuHMf1d7j2WGL6sf/OuTKmaDURHbBDZAyAxepafYv26yRWRwfz+MBDnvHdMchjqdTLjcoFHMU8nmUZtLujUmCCZ2tNq1Qo1Jp8JmnZzGVQlxa53g4pjXxmF2cp/3mQwxP0CiuM05S8o7BuUtnuHbjHqYhcYwKdrGCtCvkGoqcEKyszLG9e0guZ5P3PAzTIecWcN08/mhIfxiiDBOrMofQNHxNY4siY4qkro5tKMaPdnj9n/828eAmTj5z1Hzza7/PF5/8BM3RmCQJiWWAiUATGsf7x2iawSiOKRkCQ9PRTI1ioYCKFK3NTX649d+wIkK+8OkVFj50het//6s8Pfs0P+5oBA+uYlZsZj/yJPOLqxx/5/vc+trv0e8naEAcJyQI4kTRi0aYmsPLL7+OUjpKh8luk7//X/xdLl65xOvXb9LwChRLFh964hQLczaXZ0pUrBEFQ8dbmcNKI4w0Iadr2JUGlh7j5nQ0lRJHUKktIuOIiUg53p8wGShMF0xLMr9sAAalqkOuUgbTYv3LP8vkx3/E9tEWCy6YIsaQoLSEctFhcbXOysVLhCcHmOMWaRThOAbYFnbOohVaKDePbI+ZdA5IgyGJWaLVesj64jzheEI6HFCemcEu5JGjLqNHm/itDjlT4Do60kkYT3smVSoxLBPNhkSlyFhgaCa5XMqXP7PO0dENfiQLFFZXSZIYKWfYvncfX1rI1Obymae4u/mAXii4PyqjqjMYcyv4kcnYXOBkocJ/Mxzwn9c7WIM/QHigrDxKB00vQBqgVRM+WoW3jiRq1mHxiTlwNRQxIhoRPDrAKJfRRz38gY+hJShNIz4+wHnyMiy4BDu7RK/dwKgcoS2fYv6FD/HmN7/GJAgJ4oh79/awTJsoSNnf+2MSZ7WaR6d/QrXqYJgpucQi0sFyYvrNMVub9xFaQs0rkPhNmnsn+PUqhl2i4Dp4Tg2BhlMYUC+XKDoxhp0y8iNa/THX7jfRUoelmsvH3l9gsW7guiZhYjGJPI4GA+bLGkF/RHeQozNJkFFMwTPJORaWmfJgc4OYHEEwojE7B/GYg7bP0kIDy8ozGPYZRXn80KdRO8Zy52j2fFaXCqR+yEm7QxpO6Ld32D/uEmsLGJpkrjHH7/z+H/BzX/40SmZkoGQyQZMp+48OqZRrnDt3hnolj+/7HDdP6A9CGo06N25vMDdTRtctTgY+z145Syrh4OARz19aJwoTdjt9DptdqgWL4+Nj5ubrDAYhG9fv4Hoe3faQOHbQdIVjGJSMiGG/x8tX71KdmWVhrsbq/AJPrRUYhimGnWdvZxtX6uzt7hKGfRZ1ne3NbVbXz3Fm7SybO7scHBxw6tQCIoVL5y7R3r2La2SEsySK0E2LesmjVq3SbLWpzNi45XP0eh38ICEctYlSk/FozGg8JtjeAw10y6Rix1y8eIn5isVgLOn3j9g/aBOHGvOLiygpaI98dGGzdTJhMByT82Zp3d9kdXaBVrfPi69eR+oTzKs3+eAL76PoGhTzgu27W6zPeAxTneeff5Jg1CdvpXSHHfquZNQPqc8tYcY+N6+/ieO8j9r8DDPVEl6lRLFU5ctf+izt3Q3mawUe7Ha49sYPCCZDTq3NIWXM1sZtqtUG73/yLBfOLGHoOofDiB++cptPfeQKhXIJ07RpNY+wcw7tbodioUS35+MnkheePotraDQP25AoOpOY45YC7RjDBqQgRVLLG2iA5VWomS4PHz5A6iZHA0lgJo9tjY8HACUUSmTbE5lGyCmwQ5FOhZYOKkFTBmjmdIklMU0DqUBoFkpmmbEMlZ+SygShm8g4Jokn73ad6ZqB0iVK1xHTzJaaijMBWS5MM8jkTSbClMzybZCJh3dH/OTfvcOGfCcDp6aZNcPxkJqGLgx03QRNw865GG4+e4wqBgkPrr+FTAWlcpFCrYFTrGE4XlYyTfxumbWYbvcUZACTdwu3xRTxL0EY2SZKME3VaaR6wtqFBT76sRdQe7cY7m8hJyl77Qlv7Ib0xhI0i7xIMeKUVDeoPvkUT6zXWXjqGUqnzjJ/4y1u/qNfxZAQ3H2I1eui1+q89q03+Z3J01yRBppMuOsU0eYXuPJLv0BtdZ3P7LT5jVcFSgasRbusd1okP/w+xs/+HEpo02qACCH0aeYsK9dOVbYRnT61j+fxABBYOYahgVewEEKRJArDcEhTjVyhhOa5NGoK/2hAGmvIYRe3btNNcow0nacvzJPz8pw6b9EOAk5GMXoi0Uw4avapNSq4UtKd+DR7PlHPp5IvsdPqsrnXpOB51MtFHMdDGHYm0PJldM2hVoY0GhMpk74y0Lw8ecck77o08oJut8/9gx3aB1eJ0y7+AEp5FyONScIJk/4IgyQjBgpBqgSWriENmF89R+v+bQqmhDihvb9PMe+gI6mYMQullPM/c4nCC5+kdvYZ8v/lr7J/Y5OWbvLZv/l3OP/+zzCJUozq+0lu32f767+LxgSFRoQkUpAoDUtPsIUk1XWSd6tHJG/fuEYcp0gtRZkGvcMHvO/UGukoIiJibCgqnonn5jhsdnCXz+LOXCba+BH5imDQbGKXPCb9ITIJMfWE+aUCG9c71Iomlm5iuSZhEGHnTex8jjRXpHn7FsXFs+TMHeLQxzMltqth6zBbEYhek/7+PmuXrzDYuolezCBMWhrhH+yQXzvD8SsPsQsO27cPmZg5br3xJgXPpnnUR2g2oUxpHx4w7vaZKen0jts4hiIRgiQR6LaGpwE6YOoooSGEojg/RxAm0J/Q2XyIyA/4uY/N8ac+9ddo2lVOrl6j/eqbeJ95P3rdY/yr3+P4zZeYCIjL64SF88h0QFkMGKWgezn8rYBfnV/mhbO/wlde2URLdsAUaIZACQuBh4qH1FYlXx4rfqQZNFbWcWYaKDT2/u3/j4M7h8xcOk9Va6IGI0LTQoQ+k7ZE22thLc3gzpaxS2VOrm9wcONOZt1tDgj8ASurZTzPZDyIUaS4nv1Tn9P3RJwdd3cZDCdUPHiwHVHMGUjDIxhpuHoB8imWCfONee5vb+PrZcREsFoQ9HsTZtfq5ByDUXdE0SuysbPHfH2O2foSpEOWG0XyjkXOhsFkQG8Yo2uKXt9HIrAjn/2jNnnXopq3KYQJhUaeURARxgH98YTVeZPjXoTnCPb2H7KysEDds7hxawtpVdGExUK1SDFfYzgM0OMR9VxMt7mJpuWo1SrMGRblioVpGsRhwGQSIUTM5XOnGQwmGMQYpkmqGbz/yTOI2Of7r91hdrbKcOijMPnxm5t85iNP0h2MWFmZxxKSRn2RQrlEq91DyAkiHGE6i3zjBz/ic5/8AFEtxjQESkvZeLCLVCH1Ro1Of4wSiijKsNkffPoC6aSL0k0uXjzLzMwsG1uPyJVr+COLs8UiAo3FuSqbDzYJ4ohYK9FLNS6tLxIbMXduvs3K6jKevYBuuBSrJTQmbO/t0BuMmZspc9Ieo6KEU8vzHBweg2bw46u3yBdL5C2bJBlzeNxmezxgcbbEWq1Iy7GIDY+c53BlyaNoK9qDPgqHzihBw6XdbTJbKPLmdhuvUCCXy1MreIyCKv3EIzLnubHZ4UJVsbA8x3B4hJR9fvzjlzi7tsje3gbjYRPdLeONx/yTX/s11uerTHyDtTNnSZXJWjkhGY/5g299h7OrM+zduMru7i6ubeMaZZqDAUrkKOdt9rc2CcOUK+dPs3t8xPzKGT74vme4e+Na9kvq6afBgKNml9CPqJYq/Ojth/yZn/8cu/fuUbYVew9uc2/7mGrFxXBKXDy7zvWrb6C6J5SXz+HldHr7R6TjIcc7ipnVixRtwWHzhIc3Nli49DTF6iqtZpPhxMYoVnnq9FOocfe9OLqP50/ApHGAUgpdNxFTWqOmG9M36hloQ6VRtlVBn1oZE2JiDCuHEgLdyupOhIzRhSJJEtDTrOxZuBmmXUl07R2IiJy+4dey74mWIeinwk+9CwoRSLKwPO/QI2G6uUpQYpoHQ07DXzIDWAgxFUrTLZsCIRQaEsMwMJ0cColIUtonR+w8vE/etbBcF7dYxbA9DNtGpmEmXEX2zkAJASoGlRVhTyUb79gj1XSzp5REJlkv2i/96V/kc5//DIVqDSONGC5Uuf+tE8ZRwKkFj1q9yNdujrjfSZGRRdGx+PT7zvLF//gr1GbmELqJQLHywY+x/dKPkbcfIKSBGk4QT8zz4GGRJJqwFnTwZELNkDz73Driu79Nkivw/OJpXpYn7MhT2IkG/Tb9t65R/uwX0Qs5NGGDTJAyRTMcdMNAojCURCGQaYL+btfd4/kPfe5tHKAaBbo9sAwNFQW0JwI7V+DcksuwGRMTM5j4yDRk187jGDkSW8cyihz1YrSjDotr6wx3jygZIZrSkVpIpZZHJiFu4DNTNEiOdqiGPXRZpqnlkMIiwiTVTISTJ5EaKToiCgkGXYqOj2fDaw9GNBOdUTKhXioyV29gGw7IlP6DG8RpE3SBriUQBxRyOunRHcJHLVzXIAkF0tQw3RyJVMQypTq7zuGtO0hN4Nlg6jqEMbqMqSYxn/5LH6Vw5TnEuIs9b/OB/+qvMfevv8rmNzZYW1vHUTpWvsylz/8CL/7hf4pMhkwSxSRO8SouySDEkYLGXImSV2Lz4S5JAilguDlKroM98VlaqvOn/9yfo/3y73NqZRl9MiKvhYzaBww6PUrnllhtnCHuDWF0H7vkAglOuUY47FFszGAsLsHRDmm/z5mzE3THQjctUpXgILFcF2GZJEkKiY/W6VLPG4xGIbNlg0rVJpY6xblZbCuPka+gFRssPvtxovYujPqkcYiu6bC1het5vHlth+YwQto6Bc1mFAb0h0PK+TxezsM2I9LBDkLTqTS8zP2QJqRhRLFWzF7bHZNECQzTQglB4o+RoxBNM7EdExX7FJWG6LU59ZWf4ev/9J9jfftrPPt//ltc+F/+Mu1H9zFbGk+GI755POGPOm8yY074ws9+hLuPjvjqQcRESaQj+Vs7YJ77W3z+9n+Nbp+AUUUEI5ThIqIx5AWXVjT69VmufOQFdOUzeP37DB5scv7Tn6R4YQXCEYNHO5idFn5rgjtbpfnWm5T192EvzqLXSjhrQ6xRiBIBZU9DeQXah0PGgwFIRamWp1xzf+pz+p6Is9gPmGvUGYcdTq1USaTCUDaOYzEeRwwCBwOd1+9sMhgFFFyTuVoJmZjMFS06HZ/YCakUHQ4OT/CMKmdWzhIlKQUnoZEbUSlYdPsRoZKIJGAcGqTSgVhRKdVYMMsoPeHgoMk46NPuR+yfjLHMGM/NU8qBjY2mayzO1XGsBtJQPGqnPP9Eg5ItGI17uGaJ3X6HSWShpxGbzYDFuQXml5dIg5DQTyg7BpvHLTQnx/Fxh1q1yNJ8lf5gQr5ko1IDzS3RGkZcvnKJyPeZDAb0JwmOCLn6ylXKMzMsL85RrhY42N9hTizhOjb3rj9kdXmeSqXElz75AXx/yFt3t1lslOm2O1SqZU6aB/TaPcahT5pIhsMxvh8wDkecWl+jUqxgezmGo4CPfvCDvHLtFts7JxirNpal4fsJtVqFcZCCYSPjgPnlVax8mau377Oz12Ll1CmSVFEr2xw+usvJyTG1qsdxewgKyuUScZjw5vYeMlagWShiRtGE1CpSrNbILS2zsjzH1oNNpAmWATOlHO2B5ESmnD81y2TUxxAauVKdSRQxskt84sNn0Q2bw+MD7u10eerSOc6cO0W/M2A0GfDtm7epuSmGNsPpUytE0qIyP0fz2EeUSgwHAxZXKohwzK23T3jhmWdxgogkDSjnYP/2ddZrDpP+iAfDMUVTIwnHHO0d82DjVS6cXuXouMWjVsCnP/E841gxL+Y5OT7iv/uX/4aPffh5CqUif/jt73FmvcHtO8d85vMf5sMvnObq3RbX3rrN0eZDLp2tEAQn6OmApUqRw4M9rr9+wM7GDo4e0xwOOXfhAouLDd54rckHP/I+6jUPEY3Y3h6h5QSmpTFfdYhUg1QDJ02xwx6Wmb4XR/fx/EkYNbXiyRRNN9CFMUXFG1Ngjo4Qboa8lwmkIZBVNsTBEHQTQ+qgZZsXoWsYwprm0xI0w0TTLJRKptsqNSUwpiihvbudESoB3iFFCuQULqJkhuJXKus8yzZ5mZjjHXE0pTkKpsh9JUCmyCRBpgrLNBBCR9MEtpNHt11QCt8fc+21l7Bsm1zBY3b9DMWZVTTbQxFkt63bmUgVZoadj+OsCkBkJEP1Dt1STkWjZmQ4/elzpamUcqWEUCkIjXxjlfUPfJoHP/wa4WhMyRL87BMFfvPtgNlCzHOrRT70+SeoVauZQJUpSuiYXoFn//wvc+2//ceInQ30eo3+GDrV0/zy9tdZSlrcwuTZ0wvEr71CsHeIni9Sarb4Gx96mhfv3uPoaMRgFCA3HtG7ccSpD13MbI2AbjhTW2mK0MzMTiqybaRMoz+G/5iP53+Mc/df/Kcsf+Cz2E98Btu0kKMRx9uPEKkkfFhi7cw8ieExN1NAkwVKjsVQGCyeWqAXJHgiRQRDRn5EqVjmc0/Nce/RiGEQYetkBNEwZH7G5fS5NZ5fcHjt/hG6aqCKs+QdGxFJ9ls9UqEhEg1hCLzGHN1Bj4kMuXylyMFen/2RxDEF3cGAGB8nytE+2kBXMbqU6AJQIY1ykZPNu8zVZni4oRCGhlXIkyvWSFON+lydC+fOc+MH32YgUoycxzia4PoB647kyQsuM/UKjGKIJ1D2MEsVTv+v/iqLn74PC/NYusXNO1vIpfNonkMrUMRKw7B1TloTNKVT9BSf+p/9eT77pV/g7/6N/x3XblxDE5kFvFGfodNqsri0wo3vfZOnSjFxnNIfpAQixLNtdIpouSKmCtHyNmngExgaptRxyjVsTUN3bEY7e5jEhEGI5bmYuRxpFOLOrdHfuI/h5lHRGF0X5PQEog762KeW15AywRY6q0+cI79+hf7BMfkkxWvMY9gVwoNbyOEIo1ZGCo2TzQ26UtIOFREa47HPMJI4rkM/7jEZ9slbLsW0R8kR5Gc8SnN1ht0BpmvjPzpE2Dqm5ZCmYHsF0jjFnK+jt7to+pBkEiFjjUgF6Cri0e/+Sw6NZU5cl52ZOW7+xjf5xWc+ycJf/Vu8+p/9l+yHIePDLZbkXX7m08/zV//yX+LX/u//F17bv0H33LOYgzHNNOHvFC5wqf5l1tr/CEUb4bjgFCEYQRrjVSQX5hwKFQOjkWNy/R4LS2UKuSD73dkZYuOi11dwVk6jxWPyi4skStJ/+xr7+worp9M+aBP1BrRPTpBSZzKMKDSK1FZmGY76FBp/TLTGopdnMhwxCQTjJGG+UWEiJcftBN3ME0cDRoFP2bOwdB3DSHAklEslbNOlWquwd9Ck2x1guQ5PnbvI8UkbYegk0qOQl5xaW2djYxcVQKBsTg67JKnJqeUVkmiEj0m3dcCd7Raz9TJVzyZfGNDpC+rlPMfjPI7us9go4Hh59g4P2YklZ86sU/ME+VKB7qDHeJyQ9xyE5oJdpl5JsQtFNjYeUXRzDAY9vLzH/MICqVRYuTxl18awTBp2nonfx3VMDnZ3KVRKpMJi//CEWr1IVQo6PcXizDytTo+9/QNaJzqDXouxHzA3O4eRc7i7c4K+d8KzT1/h6NYeT56/gGumFNwcBwd7ODmPUqlA1NWwnZQwSjg6OGKuUSeSef7wG9/mC1/5ArV6jqs3b/D6a2/zqY+/n4d37yCsHKcWSzT9IYe9IaWSYL7qgRwyX3BZqOaw5p9ExSGzFQvCYzYebOIPJoRRxGAcoJkOX/zMB7hw4TK/9jt/QGNuDpFGoDQcK2USmuzt7lOuFLlz7wFFy8IozVHJ57BciyTwWaoXkVJSaixhOUNEkKANRwTDATOXzjLodDhojinkDGZmK7x+9RrVaolGucTC6Qvcu3WHSTigPX6EoUNhd5eC41DRNJYKFv1ggtQt5leKvPzW29iVh8T9GBMNzS4yO1MBM8fly+fwh12u/fgVkvGYtzcOuHZnA2nluHhunY2dfWZLM+RFhGMqXFtQr6+g5x3WXY+33vpt7myDWaxxabVEw/R5+MZNlK64eXeEV6gxP2fwze+8Srma49Fek9PnnqBezYNuYtk5KvUGH//sp/F7LTbuHbA8v8T5Myu0BiNe/vb3cRYvUinXCWIfFU/on7To99o89an34vQ+nv+pj25Y2RaJaZcZ2RVLKcMp3yLbdsmpuECzMjugbmBoyZT0qGV9aIDQdTRdR5HlM6RKQCh0zcw+npZZC81AqcwmKFBIkQW2s2vFAqFU9geQaUZ01Kf5MwVoItsoSZlM6YImCPmuqBOGRRR1kFJhOzaGLjAMDcPJZaF+Jbn79lW6J21sx8ZxHIRSaF4JzbJhEmT2S8NGJTFSN9F1HfFOFk9ltkxNzwq6UXGWP1OArk8BIRlIRVNySnLU0RDUTl8hGA3YfeXbKHQqOcGvfGoWwhFS6YxO9ikvnsMuz4LIwClCSiorZ7jwiz/H7t//BwTeLM2HGzwfnLAy2aLvOtQchxKKo40DumlMNR7ije5hHXf4xPpZDi7MUQhz6MU6v37T4+fLbc5dzgMmQsnp9swCTUeqzFKqKYWmWX8s/zcfz//4Jh0eMbj+bUZ377L0xAv4rRHEXcxijVtXjzl8q87ah5+ntHqGgpHDsgwsK4cTKQwSemMfEUXINCSXSo53uuS1bOtumhqd4Yhe5wStqyOKJdrDlKZcYijzjFsRHU1iJT7BeEKiSWLNpj+QFPMe6URyuuLwuUtV/tVuh/rsKk6uiGtIuoFi99UbVJ2AwXAKPhIgUsXJyYCPfPocuxsnpCjcYpXSzBzD3pBRu8XJ3g63Xn8THUGhNs/lj30GRz8g9/A2i90tzpxpMLl/gJufQZk6IucgxQjhOLiXX0CpOcKjNIscHG9z9cYbDFIwhMBIE1IpkFpKJC1WVi7y3T94mc1HTaIkRSHQ5Zi9jYfYlkVr94CZqkFaSHBETHW5gp6fwYp9Qn9EkCiQIUathgiG5IVJ2ukg0gBp60jdIn/2DOnWBlRLmI6L7rmE3T6GV8Cwc6SWQzzsI/QEQ4bocUyxCDN1g9TWqZRz1KseUeshOUOQX5lDPvoRmuPiOBoTOSE49rEW1hCmxagXkMSSk4MRsxfP0uuNsBAUvSKy1SZntjn73Aqzn/8AdpigdraxXJug3YKSi6lrCNNAE9mFOLfeQPgJsjqHUaqiNreQGriaRTiJKFZHpNLni/+Pf8Dbr7zM3/vf/x/40V//65TyJdykz1wpz4f/k7/A3tYdyksXCYIY/c0bPLe5ySuzcxy1OihjkZvHff7lxc/zf3zzRaz0LkrTEUqBV0ROJmhCMb82h1HLoQZdKo06lmujooDk7nVM14aTHkmconsmaSqx52cx3ByVD3yQyUtXef0bP+DR/QOKswVc26ZzNARlUC4XyC9fpH/rLQ73Bz/1OX1PxFm5OEMuicmHKZZdZhQNiaKYXm+I5Sj6A5/5WpEkiRhGPnOVKpatcB1BOVfCswwWZxoUvBKTYEQYJFimzUxjgSBNKFh1bE1SrRaomjXuPtpl0AxIU8mDwxbHB8dcOr9GqxvRaJg4jkM38inmqhQ9MA2L9ZVT9NptBqmFnGgszK2ilMagNyRMYLj7iJpnYegmQTCgVDa5emOTfN5gMC6xOj+DnssjEokyDYxcjqolWC86NNtj3r65wZkzq2gyxTNNcjmTh1s7rM7NsFCvUm7Mcf7cOmGUcu21l/nwRz9A62Sfr33zVYoFm0oiGI8GyCRBFylJbBAGKZVyka3dTUp5hziK0XSDfqeHBhQ8m4mvEUrB5u4+Fy5fZHPzDmeeeo4XX36Rk+YAtzjDRz/yLOm4T71RJk118m6OnqFRydk8fWaOgp0SK5u0sEZpaY4EMA0DiwE33nyTo26fUOkcNoekqeDJ03OsNixuvvUKH3nmLBuPmlgGnHQ6hG4GMckXPKLxCFMIJnHCrGXRG01QwzGnV2YZBwmhJplxBa/c3MSwitTLOS5cOsOj/WMATi3PMxiMuP9wi4O9IxKpsC0Hw7TwJSwsnyWKhziWRjTp0e5O8P0Qy0zxg+zKuGP4GJqJNgnQlMkklCxUNLbuP+TiE5cpFB2++/s/oD2JmKvpLBZsnOoM5dIMwrUxTYvVc/O0BwvcuvE29VKOl7/zVVQSUSzlOOl0GQ+GfOv3f40786tots6gN2Y4aFGuzPKlz32UME1ZWz1FzoG1lbOgC4ajhKKn0zw5Jm+nVGslOoMI03IZpzG6SkhSDZOQnY0H1J86hZsmtHp9OvGQJHx8JfzxZKMZWWZMTcuc0zTIFkO6nm3U0mn2S8lsy6Wb6Iad7axUCmmIkAlT3+G0Cy0TWRKJplkIlSDRQOjompZZVNBQIkWlYXZb0+6zNE2RMsmsKwg0oU8JiRLSrIAaQBG/05ecdY5pYmqRTFBSIgUc7z7KcnEiA3/ouo7h5Bj0Ouw+uM/guMnK4jyNmRkCCXGSInIlhEwzsiwS0gQ0DUOGmW5USbYtEyLboMmpdVJM4SoIVJJMrZUamp5ZMTUMFAlSZZCTuSc/iAzHHNx4HanpGDJGsz3COGTYbDM42qDulRGOMyVpZrj+made4PjnfpHmwxOCG9eYTQ9oCcGe0vBm67x6MqLvVKjLkLf8mFysEGGPaHiLi88+zf7REcn2EfanApyDPdTF57PnTEw3lkmU5ewMK9t0CgXqcS/i48nGKrgE/S6a6NK5e0R1+SIf+NgLvPbqA7RkwOGNGyj5iHPWzzKsnCKNRthuBct06I58Wt0B8XiAlvpYOhy2U+quYmGhhOva3Lm5ixKKWLncU1l+LEnHpKpPGAboms5irYotYkajiKGeYOoGnheyezKk2Yx564++w+UPvJ+98QQ/0vF0B9c2iA9eYdK6ixAKXc94tFKAXSiyun6Om6/cx80VqM6vsnjxOW58/2vEkxa6yEBACZLjgz2+829+jSdrkudWSkjHop+aFM9+gmg0wUpbqIUKWhKi6CJyOiqMePuf/A6/vTHh6z/4PqQBpZyB6QJKkFMQaRqxEPznf/tvE8UQD7sYBpg5h0KhSMHNMex0sIIetUKZfMXjqNVmsQqucgnCIZajYZQqKKOOTMZo1QJC9xCOhxh3QNqklo0II/RSDtebIQ199HoVUZwliQ0KpyL0XA6Vd0lth6TbRq9YPGFGjMKYZBTiVst0Dg9Z/PCHaN24gQhHWOfOkfZ7qG4XtCQDSUV9MFxmFmbo9u9weJwy9H3kuE/UT7D1hEvnNZYX6pSePoMYRqhuk7g7YnRwmDkmUHRaQ4qLDjKJUKOAxPexbBsNEHFCYXGZcDDBH/RIhcTM64Rhj0kn5N61B+TKBVJixqMOgRBomBz5Bp/75f+Ef/kP/r8c/Z/+C3auvskLcYR386t8z1pmcOVPEbYe8q/SEp+e/wQf2utAPQ/hMUoz0TAhCTEGbVQ4QfhjnEtXsrzxZILe6QApzloNxhEijhkNxoy2DtG1HIcv3qJ/csCwdcRwFOJUHZI0QugCyzFIZcr1F79HEIMwfnog03siznJeBSMYECUdWv02YdLDsXRWlyoMfLAMg1jXGU8G5L0iwQRmqjNUy0WSIGE89DFMl4mfEI5TVM0kZ0hcU5LzbPZ3j6mWCyzM1BkEIQWvxFIDknjCSX9Armzz1p2HLCyd5eBoH8sxSBILhc5osIfnzeH7bYr1OtuHB6jyDFocoCHoj0Z4lRnml4vcuXmTXtjDdvLs3D/B8/LMzVTA9JhZWKDbbYPUaTQq1KpFRt0243FClGr80lc+xVHzhGppkVGU8mhjh0qpQGVmhkXXo9ZokCQRt67fpD47w7DTYTKK+PRHX+CHL7/KG9fucPncKp4Ok1QwP1OiWnJBlni6XCIMoN3cYeRHNGZq9MOEzl4Ty7aIYkmn02Vz6xGXLp/HHx6yt7XNmSdfIJ8v02vvMel18Epljtrw3JU5Zgo1Ol2HMJ1w0pU49ToPHg3JF4oQ+ThawPbt63S7fQaDCSedCdJwKdomf+XPfZ5aKc+Fi2fp9wK+8JEnEAJ+9/u3uLu5i6nDOPSRjobnOISxj98b0hoNyefztDpD0jhCpTHN3ggDg2gywNcjth+Ba7q4rsVxp40M46xsu5inUZ1h2O2R2A7vf/oSSkVgVhn2h8hciZ3Nh+weH/H0pbOkZkq1WsQfT5ipFChpMUImKEPwxtXb6Jh0jg75o6+38MOEOIGth5vM1stcPP0Eh50ecQC5eo2Xf3wfN+egGxZuoYFX17n/1uvomiCKStQLJYLhhPbxIadWS7h5kyAqMg5SvvbdV7ANg4XFOfw4xDYFSWJy+fwSlaJNr1ujHfh4k4iCm/WABKM+rm1gWCbLy3VGm4dcv/Ymi8vLGIbCtVyqs5X34ug+nj8RI7PNmWEipEKmYkoyVCBjJAnwE6KfIJ3CCbNOLN2wEVgolWaWRZlZ4TLDoTHF62cIeiEy9L56F54hso9lJqCEbqCbJrr69/H5Wgb/ENq7HWcq82Fm915NJZpKkTKe2hohSSJ2HtzHdXOoVKHbDrrtEEp48TvfQY7HVIsFwoFPczDCyueJk4T6wnW8uSWEriOUnlEspXz38SKmkBTtnY2Zmmbism0hxjv3M7M9Zls2hUyTTGiSPU+GbjP/9MeJEp/WndtEaQBCR0nwR2O6j7bIl2ZxZlYRpj0Fdgh02+Xil76M+a1vYt4tEvcHHAmD+ZkGlXqNl282aRsF2tjkTLibaOSigLkY/uDGJjOmwbMi4uLr/zUM15AfPI/wijB9jELL+uhkHKJPP37nuX48j+eTf+Vv8q3/1z9C0eRLn/8UF3/hf03SiYm63+flZpfmuEd/4zZbasSlX/nb3L83JJdXDP2YIEoASd6IMeMEV1MkScTTl07xgfOLvHJrHy1M+eCSSWJq3BEernBIVIIpNIRwaNTy+IMJAofRyEfFCbGv2Gs1s+2vIbBOnefmToumrxBOgb6ZJ5/E2JNNApHi5Wzyjk6z3UXoBqfOXcQ1y0y6Q1KZMjtT4dr3v8r5s2u8fXgf29LoRSGWnUPXND755c/jNE8YH11l/cIsLbWA0TYoeDZWyYL+AEwLoUYZoNqWXPqznyV6+Zg/+MNvoBdN8rUaT1xcptqo8q//9df56M/8PD9+8Xv87Je/xKvf+wG9oI/t6Tzz8fdjmA0S3+f2W6+j2YrdvQ4zVYdy2cWozaE1ikyut7A0ieXaaLaOGPkox0Kt/QJy9wF6+Vp2gSoIIElIrAp4OTRKqDRFm59Dj0yIWthLi8jjE7S1ZaKjAqVaDdVeIkhjWm+9zsyZS8Q5j/H+HtVn3k+8vYHc20MaFprjkJ9fyrLM0qBYLuJ5ORqDGqVOgDR1KqZkphTz9AtLLJ5dQXYGiG4fddwl6HcJej7hKCSWCt02M6vfQQcjZ2LmcyghUTMNlB9h1BsEB01STUNKMB0XWxgMogmTvS3+6Ld+A6diE4YJ6AmFQgmhSa6+/jr5QgnTcVAiZGBq6LbFx4sDlh/9kG/pJteWP0qz2+N319d51lnCPXwb6jWEXQA/QIkTGHYQkxhsB5QBkxFq7wAMELZJqmtQr0JviJMvoY6aHD96xM7te2zdPWDhwgLS7ZKqlEkPYsOgWvNQps7lK2u8dnULkfz0md/3RJwd7t8FSkwCk/HIx7RjpFDYVsB8I0+iLLZ2muydpMzXdRqNPI4uyWkWoSUZDWL8cYqlaywsz1Gv5pirrzAYjqjV6ghs9vb3GY+HNHtj+kdHRFLn7uYBiS1IYokSNo2Sx3DcoD8YMB5NWJgpM7+wjCZytNoT3NEOsyWPYTBh5Kd4pk4YjfDHXe70JY+OR7iOg7CgWClTKdmsVjR6EWzu7FAulDh9dolhb4w/GWMYDo3ZWeYMFzRBahaycuLhAN21qJaKhFFIsehhWzr37j/g1uY+l081KBXzyNRndmaZi6eXGU0iHNvGtDTcKCYcjzhud5ivlWm1ujy4c4skBadYYOPhBo1ymePjAaPRCM9x6Q6GvH3tOktLSzj1Ohff/1lGwwn6ZEi32SWUBgu2zfMfW2LUG1ApeQjLZJiUOE4LmEEONyeJxh3MaMDG9m0e7ewSRjEjP6Q1nFDJWfzSlz9BapTYa49ZnC1TLOhEYcJRcxfPNphbWOPutddZXV9ne2eHUs7FcUzCeMLG3Ru4+SobDwWVSplioUg0GeLHCbpp0elPqPkS19E4PVuklpPsTBSh0Jgtz3BwckTBNUEpItchiGJae23CIMC1LOYW5jl38QzxJGRxwWN7c4tiucjC2mkOj1qsLi8x6La49OEFomGbSq0O6Zh2NMGWLoPqPCunF5g9vcbu9U08EXDhyil+cHUL2xJ8/iPP8OjBPU7aXVbOXmZlfYmc4zCcpAzHY5Su0W0PMaTPM0sWq+vrIAw6rSY52ySVkmpjkWKtTE5IbF3SEzGlaETU20U3dXK2ThyE9FpttvaPWFlaoO5A1bXpNI856CXM1suMh/57cXQfz5+AUZqVCQYpM/iGbr3bfZYBN6a5Li0THUJpSFRWLq3eESzau9ANYeggY1B6Vi5N9u+klFM0uzbdlJlAOhU7GVxDqTT71LSTLPuT2SYz7IZ8l4SY+R0VP6G8v9MxJtHQ6HdaiDjBLlfI5W2K9QYyCtGAoucSmxp+nFKyc2hSMOmPmV86h4wEpAHCtFCagjjJxJaWCSumz8+7gmXa5ybeWS7Jd6iR2X2SclqibZhTIadN7zyYTp6lJz+B3+nS298BzURoGrGUhL5Pv/UIzS3hlGqoqVVSqSx3ceFnvkzy0Q/hHxxSHAfkgglvv/Em5uppjPaYYNyjj4FhxXTcApMkRtNN7sUa55MujWiX0naKPvKRjjuFrKRIqaMJA03IzHaqmfykvuDx/Ic+mz94GcM0iGLBj37v91k880H27wq+8d//E2LVRhcBpl3i7iuvkXv6dWJ/iXotz2zOoZAvM06gYGvEx7tYyYjYLKHnarz6SLLTtUncAsLS6UQpdkFHppmVWgiBqTlMAkEr0FFBwCieUMt7WJ7HJJHIMKGUz2HogvHIp1xxSU2NnOmy8+9+j8mjh1giJY59YsPCMww006E7GHOwd4gfjLhy+SKb924Rtfd5ODrBNjQ0HfKuy6Dv46cR1eppfvCju8wOIoruCVrSovf2NSrPFln4+Mcx2xEqD+JYIeYHMKfhrTWovtjig2s1rvd9wlTyze+/Tj1vEseKu7fuYOgWL/3gR/idLkma8tFnnyAdBZz4TfzJkGIlT66o0NMJSjNJ44St2zdZWphh5cmLyEEbbbaCyHvgVzN40ckbaEWF0mbQ4ghlj0Gk6OVyJihE9rpNKjByCiNdQegmabUKtoP1xBMoP0IUy7h5l9lSBQ6aaBgYxRr9e29TXD+DYdkoXSe1NYRvYhbmCbcOqV5cY7C1xfmnnyMeC9q+5PS5M6wUEmwnx3jnhLhziEgFtucRjHzah11Gfpq9P+yFuI5FlIRYtolXk5iFMkG7i0hTjIGPlnORvYQoBgo1fAnJ/tv80b/6BuXBMdrCaYxqka5lgATdFHz6Zz7H/QdbjOOA7cMeQ9vmJbfE//Zv/E2W/+5/xuz2t0n6Y95ufJiv+WV+ZfkrnH90Hc1UKBEjLA0Rguh1UBMfqgXEoAOdHrgOygQsE3HUY7D/gH67ixI2wtGRcUC3MyE1LGaXlmmslrl9c5tOKyQ2LXLYTAYBdimDchU976c+p++JOMvn52m1I1Ih8SpuFi5POnT7Eap7TK5YwtAMlmYLzFUrjEctzMYStmuRUzqjUYJtBKAsqrUCBUen223TH024ffcB4zgiSBTKD5kkGp1RzH6rQ6rb2JakXszjmQ6HzRPanQGNQo5ctcjRyR6lYg3JBMss0WqO8UyTThwSDPu4xSKuXacS69x68IBStc5sxeXU0ixb+7t4RkIYRagooWIWWZ2psH3/u+ScObYHDuPemC8szTAIR/ijiEmvSRpLxgd3SN0Z5i+c4dWrt7Btk1q5Rmfg0+20MS4u0u92iKXBnbsPaNQr1HWd4XiMbRqUXYNxrGMa0O4ccnQ8JowmnLvyNHHgM1pfptlsY4oYz/PodQdYls1oFPDd7/+Az3/+sxQwsHIFYt2gcapKOglZubxOolv0/SHbXYOOD7qeA80nHLUx04jh4Ijm5g0if0wUhhycdNnab1Ms5vnSx5/i8rkFjk6OmVus4PtjoijFn4ScNAM8UyNfKjO3vMJoFNCYW+DCmXUG3Q7CNFhfXeJHr7/NzPw8SSIZTiaYMkEZFqVyHcsU6NPSXD/R6HQVJ72Qo5MOYagxMzdHqV6ANOalV+9w6tQaly+eQk4mfO2b3+XTH/sgQtcYS50nLp3i5KRDY2aG2w+PqM3U+MGrNzi9VKI18KkXSnQHMcVqnWolJUhjVmp1wtjg6LjDqaUCaDVub+wy6I8p1G1G4xHleoXdwy5KU3RGkpNum0LOIl8ooJKIJJfiT3TWz5ymUikjgxHJSHLlhefJWTkeHRxh6hpjqXHc6jLu7HO8u8vCYpn5vEEQjPDDgHa3zeH+IZap4ZhFTKuEluygpzqeDbncY5vS48lGxZOsv0sINN1E6AYyDrMvapkKEpqB0A3SOEEX0+0KAiFAkwoldJRuZCJGSVBGBssgQso42zQh+UlXGVNboJ7lyKaWPTXNpL37dZii9tMpvj7r5ZriH2HKS1TTTBco4ihkNOiz++A+mCalapn67DxuocrgZBvlDzj35DPYlkUSxwSDDkGvx7h5gufF2DM1lFdDpSHIKCvJ1hQindootWkh93Rbh9CzxV2WDkHJrIRbCDHNw2lZlkvTplk5LcuQZUoXq1hl5YVPMen9FsE4ykSq0DBcF3SbYNjFtAroroskE4oCDcMw0SszWKUaxal4/ORHP8aHkpRg4jM8abK19YitP/oBd1uSJPQhDNGwyVke+UaR5AufIvVctOn2UQg9070qJVPbmZj+ifJ8PP+hz/2rX0dhYuk6g96Q3/h//l/pd3X6o00sS1Kuz1CpNtjZ3OTRi1+n3ngOf/I68xef5NzpD3K7abLfnnBxrsLywhq3Ho747us7BGFAqEBYOi+PNIxU8My5Ci9d3wHbI+fZaMIBZVPJW2jlEsuzVdSgg7RNjDQikiOGgwGGkcNwcpjFMsrIo/XHyM5DLBFgEnPxwjle+NzP82//4f+bSCnKtQbNwwNEPGFwvEfS62LpEMQ+QgniWGLqMa6ZgYH+1b/4VRj74GpsnEScqevYcw7be33YGjF/dgbzzivIegWt8YuoKELzEgrRQ563EjbUhL3DIbl8ntYkIlEpG/fvYOiCfrONYWR02+//8BoaENkWsZQslAukY7AaZSLlECnB2toacfOY/tYuRskjn2sg8h4q6SFyHtKyEbpAS1NUeIRKK4g0ycBGfgBpBF4BoQJEKklnG6DnsaIQ9BRVWEAE21BtINIY+9QZIs1C7RzizM5gzj+HancRto6UAsPJI2bnULFEXwRsyJ+a5eD6I3R/QC1ImC01IDjGH7VwvRxaqcq408HxCsSDEXZOp7hQIfDHSE0yHMUQapSqEAxHjNo9inOLOPMNzFgRj3xIUyzXpdUaYDRmaT+6RnHYxY0iBiMficQ1LfLlIrPzc9y/e4+5+WXGR0f4hsnah9/Pq99+kd/8h/8df6o34ek05BdaL+E++xFujUO26iucr51FyXb2+8grQdBFTUJEdRFyCnodVBIiJgqRxMi8QzQKiKIIP/BJY5841Ln22gY3bnUwSjkWWn28nI9XzKG5MZpmMRqnODmH3YMxF154H/deefWnPqfviTjbunub6sIyMg4w0FCkdAOTgldD11JMZTFT9jBTiXAUH3rhYyTjIcE4ZjDqYmiKVk/hlRT9TofUcWj3hzw6HpNqiq3tFonyGfdjDgZtAj+mUshT9Cxm8wtUXBsjn+ON69v0Bn1IQjzHwLIbdCYTCuV5cqV5QnnIWPkUHJuSXaLZTxhPjsm7QCrJey5KpIi4gyFGRJHNIIZOZ8zCgsmN2xvkXUEgfUrVCqfO53n44AHNVo98zsXUfI53e2gaVGZrbO/u4tgGaRyioiFF2+CT77vEZDBkOApoD32W6i56ErHbDFlslJmtlTlpt5ibX8QyTYaTCDun8cRTT3Ln1g2eeOIS60szDPpjrlw4y3dfuopmaogoRqWSbmfEN776Db74pc/SmF0njBVju4Esmrx0L0BJH910MGwTZMhkeIimJoh4zO7mAya9A2rlKklsEaURJ70xjlNgafUCZy+eZdA+ZPdRm0Y1hx8HRJOUKE2xbJ3m8YBJENEoWNw73GHtzCXOLc0wrDjc2+pQm6vz6U/OoJs6rmuzt7uDCiLsJKApIUoi2p0e83Oz7HUm5L0i816VT3zik5wcPkJqBsPegOPjI1zPZrbmMV8t8KONHSLlsN2aMN8o0OqOeO36faRT5sWrN7ny3HNsHZzQ7Ptsbu6wujZDrzvJrA69Nn1c4lGC6Q7p9SYcHUX0R/CVTz3FjUe7nFudI1IGKRa5osfiWYPDwwMOjlooEpzcApNuj8XFCqksMT/n0TvZRzNcXn7lFmcunqPbHdFOhpSKLoOhz7Df4nhnj4XZPKKebZLH/SZxlGJbDrFMWFpeQ3fK5Eo1MCyUKGE7USac9ce0xseTjVIZql7DgCRGvoO7181sv5NO82RpjG4YGRFRKdQUxIEAoWJ0tHfjV1OSCEIZ6Fr2SU03URgIYbzbCSbEtFhUZEh9MRU671gBs5vKxNc7GzMFaFPCJEJHCQiCMf12i167SeD7JEnMqD9gZe00K1deQPojHNchzJXRLYPZxgqmYaBkCpwijUPCyQjdNLFsA6UboBuIIMmukqbp9PHwrv1PIacF3hm4hHc2f4JpubUOcprZSmMQOpppZc+lTBGaQMrsuc9V6tROnWfn7TfRNRvDMPD7I7zagDhIkbGisnga4ervdo7JNELoxrSnbPq0axquAU6xSLlcYuXCRdbLMedvvE2YlAliiWXbuMWLpIUi0XwZmYYYWm4KMJn+7Miom0Jp74JPHs/jAXCcHGESUp2ZoVo7zZ1br5CmMY5jIpVO5+SIXruTne1Bh73B24y2enzlF7/IXmQTRhJDS7iz02N3b8QwSTALHs5MHUNkr0cFXSNvStrdhNV6GaErotjHSEMOHzXxPBtpmoxVRMUMSIIiM0pDjnYonjvPTksxSSTJZIRT0lHRCCEjDFvHiE06kzH9YUSYGCydXaAwM8vxo23OnF8nP+4QpWPinE13GGTQ2jRFxQopoZTPMRz1sEydYZxyv5ki/Bhrd0LdFCj/m8x670N78jJJIHjpd45J45APfOkKs597H43ffJG/9Df+Mv/s17/Ng/sPMHQdoenYIsuVIkA3DFSiSHUNQ9doNKooldDt+owCgcWEnHZEuOAi/Q6uXcKMJXONWha/CEOUlwevjEhTRByhNANUEaF8VKogDrIcq+lkdmzdQ6U+QuTAKUChDuM+Ik5RTil7HU5ShO1gzs5AFCN1HUYj9FKRxLQQtg0WKKmj7BhjdQXNyqPaJ+RXIf9gG2vWprZcQRukpCMHo1wiOOlSmF+FJEZoUJyro4RA6RpKTShVPdr7XdAzi7thW4xO2qAkMl9A2QWSyZhRZ4BZKDEajmgFgna1TFqq0hYe1STG1nQSqUiTFM+x6LdOAIXlujz3sc9w+7W3uLOzyftlxJKC08SI+7foL6/x8mSOz5nrGEkb6cZoVgHllqBzDL/1W8gnzyMKJgqNeNxHTyXDvV3iVEc4eepLpwmCCc3jY3Z3Bhz5iqIpCEOfoDtk/0Sh5SxIbPLlIlLXiALJ/sYW1cIf0+bseGAxv6JPcwcaum0T9iIatkmcGuimTac1ZK5eJYwGHO3uUXE1khi6vS6aNHByHp6Z0cFOWl2+8d3XeXCcMDtToutPsCyNs8vLXN/Zoz/wUUIjTiWj6IDnLqxy4/YmQTIhJWXoT4giizDsszo/y3K9wO7BFo5jIWNBFAacXl1iZVGn1RuRphNKJY+5xgKVgkmns8H8fINBp89wCKWKx0k/ptqYo1FdRGgJJQdOTk4w3EVK1VlanS4LpRrPfOgik34Hz7HZ74y5eGaZXrvN9XubWIbLwWGbSRwzHvTQpGLcTynl8qzOV1C6RafXYX5+Hs2yCJKYVqePZcE49llYWWPia6yszDOe+Lz0yjWefuIcmzsnKJmSpJLhaER/6PObv/k1nn3qCucvnsNTAYmyiNPMmiTQ0fQYE8m40+Jkf4vj40M8W0PXNKJ2l96gzzjUqM/U+fmvfIVQFbh7PCIfpsyUDfqtY1IFURSTCpP+YIgfW2iaweJcjURG+MMm199+i9XT6yzMV0g0g1EwoXPYpVwqkGgWk1GLhadewBx22NvbYWZugUkQgBIMukeEMiUMYjq9HirNUN2Lq8t4ts/drX2uXrtHpTHP2vkLuOUixxONNFegsHiO1WKBrd1dth8+YH93n35/xIUnLrN31KLgOUDKB66cQmv3Of/sAuNxQiOfJ4xCNvaOaHVO0EzF4VEfqSZ0CoqwUENPU1546jLf+NaLVBoVwuEIwxQcHDUxdIs4VTi1RR7tH1OoNZAK7t26jVAhx80u9UaZhpvSyEtaB3ukkY+e2qBFROGEQTSkYJaZyIRxlFB2c/S6Y2aW1xHdHvfvXOfKqbn34ug+nj8BI5SYWvPSqVtQy6x7SmUZMT0rhdamhEKElm2GeGdb9M77eolQ046y6aZFaRoaWgYcURKEyrZjZD1qqHS6MZtuaqYWSU0YWZZMpVPdkV20g2wxlyDxJyP6nRbDwYDxsE8qQSiJbbv4wxGnz15m/tQljFIdNWwhVEpx8QyaJqd2yxQ0kRHANBfPcqcWTYVI/OlGTEwFo5zaNrPXwIxQkj2WzKb5zqQIJabbPDUtrRYolW3JVBJm1EsEUop3iY6G6ZCrNbKYnVLoKHSh6J+0EWJIOpxge0Ucozy1lxpTa2UKmoZu6Kg0Rahsq4eefX9kQv3c03Q27pD0fap5F9M2MUyBplKSwEcGPhRqaIaJ0AykDKdF4DqKdJp1e9xC/Xiy0XWFY7h02h1OTgakaYyuZX3saZwRSxM5IZWK450drLzPaHjC3/ubf4vTn/+LFJ/7DGVbESsYjbqkUULRa5DPGxhKI0hSZBojBBhmSsXJEfpjgmCcMQLyBkHQYdidkHMtZlcWCX2D9vEuwo/42HKJ3skR/X6fxLYo1fLMr9XYTKLMdqccmidDvvv1r6MbkkGYcq6xTHNzn//oz/9pwkcnfOu3foOjfhtd6Kg0Jk1TdMPGdgxGYz+7QGTbOMUy4XjE1iSgqEf0U4PyUcDR1bdZrhURl99H/U6XTb/Ig7uKyy9cZO7CIg+OJtSKJca1CpMk5MknnuX69ev4/RGGqVEtlxh0eziGhqYko1aPRNdA17BzObpBSiswkY8GGHqRC5/8EJWLNRw7Ru7tos/VEQvrkErUsI2KFTg5RJxDjcZQ8X5isdaN7Idn2JmV2/IgHGdWvUIRghDMXGZocDMrurBsTC+HDBN010NZJka+RFooIJIE0gngoIIQhYMvcwRNHc2bY/nZBSzbZTIK0S2X7qNjcrk8Sgq6+ydYhobf6REGKW7BIRpGFCoe1bMzxGd+kfDGN9HbWwjdQQlBLBXxeIBu5HArdbqjMbcOArZ3JDuxZLL6FItnXmDv2o+o6AGf+tlf4uEbP+LhnduMJzF5z6Nslvnv/8k/Y5hKgmhCr1KlTo+aillpPuDlSzU2bI1418fI9RBOFXQXKqdRgwFCJoiJT9xqkngeieVhOha52TmEYePvH9A6POJ495Br1/fojBKKOY2CHpMkEak0aE+G+IaGTFOscUjO0jHTiMunZyiF+Z/6nL4n4qxeycrudnePsRwdM1+j1x8yV6mRc0yqhSppqiFIWVtYxzUklqFIpY/0Q0pzS9RqRcLJiFa3QxJGzC2U0BzJME5xDcVM3cUSMacW5zmkiWHYrKys0u62aPe66JaAwGa+nsNwPLrNJhMZ0RoMWE1mOLtYpVBweOXqPRZmy6RxxDCMkSJkbnaeIB6h+xssrJxmos9g2zajvsIPhnhOnsgPGU1iSiWJhsPJwEc5c8RoLC/M0+sOMEtlDo46lPIGtqnjxE1uX++SYNCYnSdVEeVSAStSSKm4eHaRVrPLIBiyVqvQbR1QyOcRkzaRr9PsS1rtAU9dPkMwbpGKHEifdssn6k04vb7Gw+1dCo7BJNKBEMe2GUsf07Z468Z93rxxj2KpwNxMnXwuh2EYWTH3YMSwP0AISblYIGcpUglRHBMMxhwftXn/Jz7Dlz72HC88fYbDoxGvP/z/s/efwZat93kn9nvfldfO4eQ+oXO6OSELJECQICGCQVSYkWRRkjUj2apyeeSyy1Vjecp2ecZjaUxFyqNkiqSYRJAUQBAAkYGLm+/tvn07d58+p08OO++98npff1i7L2bmiwtVqJkx1f8vfbtP9zl7rXtW937e5/n/nmNMb5XhwUNUss2TF09x5/4G127cZe9owjCzKM+sEocWh4cDMqXojoa8ee1dxqkkjhM81yUYTTBsj1KpVMSZbJOjTp9Tp0/S6w7o9oesrSxhtWcZR30EqjjNG/SZX16j15/QbtQZJTmZYfBge5eFlQX2Djvkccp8u41OY3b3R6SZ4vbdDSqVCnMrLUzDZG1ljVFvwNrKPKbKeOGFZ+lu30WnGY7jUi4LSt4KvaFirwPNiuDixXNkUcD6+l3CFLJ8hOdJZDykH5aQsUGSRURRH68UkClFmiZUSh5Gd0yzIjGdDCfPMPM+Sjd548p1lleaSGkwkRapkDiVNtl4SC5A5Ca9vSOWTp2jXmmwd9wlHh/xxOkVZmuPS2UfTzGavOjlktPvCVHsniHk+xAQrfXUZcqLHbJCm0yZHYVMy/NsCvVwik8zdWCUACE1YnoqXAAm0vd/z6N+skKXySkxMinig9OutEcl1mEQ0e0c0T3cI47CAlyRK0zLQpoFLdcvlVg9fZHK8kV0OEaOj8Gy0XmCaZqQR0hA60fXW+D8MWXRlzbFemsdI9S0lw0TRPb97rWpHCsuf4rPL9rCitq4QuMVjpoALc3ifuQFsEQLoxDEuohGhsNjbrz5OpGWNPwKhm2gDBORg+UYmJaJXS1hmDZKWog8wbDcaaySoltN6fehilIW91MphVdpU1lYYjy8g8rzaSecJlcZtmOTJeHUwSyimsJwij47naAVSFmc6D8ONj4eAKUlSZogpYEUEaZpkGUpTLHv5XqN8WiEVCk6i0j7u2gJC/MzHLzzBWjX6WUOYrxPq1ZlFKQcxz2ioEUc5UzCgEkwQeYxJd8miWOyPEObEiENKm6ZWnsGKweJwSArY8iM+pnTPH3ieYbHAfNLqyQJxKZBGGtuP9ggi7tcfvIcUZZw68rbjMf3OPfUJZzZFbr7fezhNvrkPGee+wxjucK//eX/M3NLS4w6h8gk54nLz3Dt5g3OrZ1gOA4xSw3GoyHdfpfY08yfmuHcZ//X3Pn932bhYA9/1GC2+QznfmpE/OuvcqJ9AeFXKc3NcfULXyZEUy+bpN0JN669x3gwol4pkecJa2trvNe/SsORPP3MZd64eodAgeG4mJbLaBLy7tYxZ9sl4qv7bO/+AQdPrbBQ9Th7cRVxEFCeGZHvHSGtEipOUDsHUG9gVlro4TE6tZCuAUkChokSEikqECcIPHQ0QqsBslItur2SHC0DtOGBJ9C1KnmUkMYptmOBNJB2GVW2kf2i5FtaVfLdY8w452Briywe4HkrqP4xdnMGnQrMkmISjqdQpYQwLFaWpZYMxxGj45SSO8EsmciexbgzwUkFOkkwwxDfdrBLVQaHI7LMYDKJCq4AAqtWJTi8T2DPsPahnyUf7nFnQ3D//jGu6WIaKXESc+PadeI4IVM5oYb9fpdntcLI4Hk54HM7D7jv1hktnMbb/Sbi3Dn0ZA8MiTDaaLMFp+bRDzZID3cJBiPiyQQhTbzFU5RaVWwDHt7fYmM7wHBMPv2nnyEdjTh/aY2XX32HRBmsfODTHL73KuV6CTXscGahyrmai3P8PxEQpBsJ7NGQessni3JU3Gdloc14OGamMY9XAnsIpZJHEgVUGzV6oyE5ErfWQOgEnYRMxhOOuhHDIOQojUklWI7iM08/weZxh+39LrZQKK1Ynp8lVymNWpVRnNMfjCl5LUqOQaJTFpeXOEGCa9tsHO5x7sQse92Qc2dbzNfLzC0tMQxCgjDm+HjE0kyV1fk6yaSDYzpoNHNzHkrHWIaDm6Ykqeagn3NiVpFlJtLxuXB6hTiKuXTpHJPcRIU5R70JKhrTqFdR2YiH+10yLZmbq1Gr1ZgtlagfSg62jynXXILBkDzqkUUDIt+hs3fMwtIplmYtRv19Hm6uYxkO5y+dpt/pcLh/gLAszi7MEoVDkiigNx5gmCZ5HlP2bbIsL4I7CnrdPp1OD60UhpC4jkW54lFyLWSuEXnCYBLgei4Hxz2q5RZ/7a/9NX76p16i5rpoYdJuO3ysUuOgO2HfskjHNbZ2HuBVmkwSzd4gZGvnIXJrn9lPfZqTZy/R6fWRWuGWGtj9PkdHh8y0ZzDmF1hbWaXT67E0O0vOMbOtZcoVj93tHZrtFsPRgKWlGgKf7333O5w8e4GPfOxZNh50GI8HpElIOB7hlzxOnjxNmieoVLOzv08aBrz55iu0Wk3S3OLMxReR+Qjf89ne3uby2UWePbPGMxfX2O9MsF2b7+1GdIcDxuMEZVjUqyWaFY/xpEeYjMluBxho7jy4y9zsKoeDgKoFx1FGnTEnl2voWLM17CH0gHa5jlMF4mMyA6RbZdA5YGdUIc8NrEmX/WFG9KBDrVzmpaVFdrYPUZUU3/dQWYyu2yhVwiTl4GiXzt4xq6dXKHku65tbP4xH9/H8CRg5dYbejxFqjRQaLQR8PzE3/cdTTGEh010w/ah1jO+LO9QUFFKAPb4fRyz2xDTTPzctln4033fbDIQsRIvOM8IwoN89pt/pEE7GaCHJsmy6d2UjbYFlGpQrZVqzJyi1lzGq85Cl6CwmT2Okygq4SZ4jTBsti8ihENPYHmqKi8/RWIXILEDbxZXLKU5ea4rttqKbTU+vWTAtpZ5CVIqPq6mglRT0f12INJUVogobaRjE4xFv//GX2VzfZa7dRJs2lufjOC7StCg3ZmmdPo/pV76/kyeL+KeQVoH2V7roW5MSDGv6dacgErfE/DMfp7/9kDRM0XleUMWyjNHhEV61WRRdGyZaxdPGuymFUhYQFv041vh4ppPnqnBppcQxDTKtpy67QErB0oll6rUGL3/n69N9xZwsF9y88S5nnn+evc2HeKaP02zSlSXSms1so07J9XEtB0Mr4mGfcLBPkgYcpwE0RUr8AAEAAElEQVSe4xLnilqthueWsa0qdslHYVF1HBbXyjzVdvjad+8QpYKkZCL8MjrKyIUgPu4gjICbN66RpBHCM3H8Mi9+6rMEosb+vYdoLWk+DLn2G7f4zpVvk2YxBwdDGvUWYb/PtVs3GUcTlsqncK065VKTh5s7VCo+wWTAZGKy0p7nnbzOd27dZPC5L/GnnJDai5d54i+vImSHPEl4eOeAZHmBsrYYHz1kvl4mTwS5a2A6Ele73NnY5IWPfYTe7ascjyIWT55mOA4Z9IcEkwlRltIPYuI0ppRnzPZzbu50Obu6wNL9HsunljmnSnTffJv5j3wYazBEpgl+2SU+yt/fo3WMBrrsgBXBwR60Z4qORlOhwwSkhfYX0INDRHUWoXKwPbThIJyE7HAdq1wr3DI3h2iMEHV0YxGiETrXBEeHTLqa7vYxCxdWSbojdNAveEqJoLvTwWi1KckYKW2i8QCn4pBNYmxLkiWSztaYWtNFHf8ydqbJBaSTnPpSiWgUkndicmHhtRocTWJGgzFxahQHb0lI9+Z3MdKM5vlnufr6dzl6cAdDFeTQldVlcgHSFKRBQsWWKAxklFHSGc+oMReXa6zvD9g5cZ7Z4xgebiAaVTAztNlDhAHq1FM4lRrOYEC5NyI4OGLSOUTqCWlgMg4C7t0P6CmLki/JhcRtVzC9CtKfx3a63H/9FWZrNpeeexZ5eBU3y5lfOYljez/wc/pDEWfNug+ZIFYGzXqxUF0ql6lUKpQrTSzboVxJkdqg3Z5hHMbcvLPJqdVlvFIDAaxv7LF10MMxAp559gVOB6v8xh99k6bn8VvfeZV2uUK12qDa1swtVtk/nND0PI6Ox0R5hFQOOSmmYzHopuxtr9OamyWzI+ZnKphezqnZMlIYOI7L/tE2507Ns7kXUa9IgkmfYehiKgPD0KRphGFk9Ad9LNvm0qklDgYTuoNd4vIK87MNZtp1ep19Sq7LUWdEbngMRhEzjSrdQZ8Yj0BnLJ9u88Qzl3nv2l3yNObtq5vMOYpJkJGpCa5XZRIkzC+16B0dM9uepd89pLl0htbCaS5fPEm/2+fmjXsEYYDvWlTqLerNBk9dOg/aoN6o8O71BziWA0JhOAZpGoHOsUyzyEIrjWUbOLYmz0Imk5hatYzhOETDIQf7W5y5cIm//bd+kcvnTmBJQZYmoGMsoTCFSc036fYVE6NGlLfZuvEOdzYOeHg0wHFcnHKJg+6oQE07Lq5lkGrFiVoL26+zvDRLv9cnTsZ4rskw2MWxbapli9defRnLb+M6Ljr3uHv/LrmSrF18ijgIGR92iTOFYRrkSYhXq3DyxAK5ynnnzZt85MNPY6rCCZ2t+3QHE2oVn+UZl6rnE0aKjz//cfb3jkA4bB8O2O1rBpMxueWz0DYJGpKt3SN8r8Jrb15hY+MBH/74czzcWifLDIQ0OT7aRxoe+dwsIonJ+8dUm3V8y8KvVBhHCaVShmcZ5J6Pb2mCEeyNPfYPh6hUEuURlmWxuLLI8mybh/s9MC0miWBnt8vO5jrLZ86SpBZ3vvUangkf+eSPIQ2TW/f26CWPz8Efz3T8BiKJECqdEggL20dq0BRR4MKhEdMoXVZQ9gG0QAiNFI/+KciLN/XCmAqQYl9JK0lhvYgCvoiYdpPJ93e0lM4KyIc0yZAMez06h9tMRiN0XnxcaYlh2kghMIXA82xaM/PU2kskvQOMUYRsSFR/BykEwjJhGh8UpoWwCnJkYXQVmHvx6L+nTp/UGp2lxWsUEilVAfmYumYo9d/bN3t03VpLwJiW206F57RguyinLn4daaHzGJHnxOMuV77xR6zfvk2lUqZU8vG8Cq5r4ZZ8/MY8jbXzmL5ffBlpFhFDpb4fbRQ2GNPdwUcwEsNA54JpmpJSe5H6ymk6t29CmoBtIkwTrVLSOEHnCmkbaLJCdqq8+Pxafp/W+XgeD4BSmFJSqjhYhkuv1ysOAaaxxoPdXXa3d6cHHGA6Np4UhJMhcadLMnqHoFED+8N4kwTtQKYTmvUqnmMQBSkVYYMzTy6GtGd8pGHRmwQoYVOrzaKFBZbDYWdEbxyz1+vzShwS5ZCYEjea4HkJcZwgLZPBnSu0ZsqYdplhv4tlWRx0u7z73l3GWZmLl5+gu7PI3/+7/wVRbJJmhyTpBMt2ODjeI1fFIYwSMAli5hbPc+3V18jiEfWTS2zfD3jv/gHj/+LvQK7oOSV2+wE3f+8rPDPew/30z6Ox2H99na9c2eS66aOcCpNxghQ5Sgl8zyPPFeVGjTTRGFnC/IkVAsfHc+tgjDjaPyQXAssw0VZOrjSBlGyMAtwRHA82ccgpv3qf59/dZf3KWzzTMQl2HnKi5XPmAx5+PsESisZME6ukkJU6Wo0wZk8XO2jSQpsGsrkAKkONB8j6MgRDtOOAcBBSoP0SMlcQRWjXglyBdBBhDIZR9GMe7KJtybtf+n1s06BhVFChx7gbILOMOM6IxmNqlz7K0Rt/iOeAXfYQOqPfS6nWHdxShqEl/W5Ga9ZmMA6xbDBMSXA8xKh5qBycRpnBqI90JOEkY4xFrDXlkkOoM/bufo+FE7M894EzfG3ne3QP+oBkdPMeSwtzLMw0uXHtKnXPxF0+i+daNN94g4oa8szd93iv9mFuWSd4RrYRwRB8C7wKQjuIsUK6C7DgoN1DDOOQimFRnpshngx5ePeQb31vk/2J5jBT+KnJjSt7VMqCleVTZHFCFkdUbYFI4fjmm7x08QTlVNJqn4b4B4+V/1DE2Yk5iWP57B2lmKZJrZ7RbCyTZzlapwRJTCwyKq5i5+g6aWYwv2Czsb+DbVdJk5z5RoXTazOUGzO0FuYY37nDarPF7GwNp95gPBxSLoHAoFSpYvQm9Lo9FJJa2UUqB79cRhsGtVrO4U7E4d4BFd9itlEjTm3iLCCPNZ4L9apJGESUrYzDSYBjlRh3x0jpYtkuQRxgWiEwYnV2BiFydrY2CDOTqpNRsWfQyYAgSUmcErOtGtdu77F1cEBwqGjOtrBLNSzPYTiICSch9UYNhEmzFpJGYyxL4gibdimjNzoiiRTl6iJJkoM0SYIRFa/CwVGPN17+HuVKiReef4ZvfOM71MsVhhYsrZzm8rPPs/twk3b9Vb73+rso6TAYT5htlgijFNOyMUyT4+NOgVrONK7nY1sGKtfsb++QKMXyiRP853/nL1Er+aRxRJQmqChASBO7VGam7lBxTYT2efvGQ0JZI/UXmKS3kAjKjVmWTl1EmJI4iEjHE7YHHaq1FqkD9XoDpTWTMMLxq/g2PLh3j6WFWe7cvM327gF+XWJ6dUajHuNeD8938DyfKBiRKA+v7tPfPeDpy2eJhE/Dh7l2jRIJCzWX0qk5BrEiRPOhFy6zsb6L1AlJEDPfWuD6nYeEwYAzFy/x8tVtKq1ZZtuLHB8dkGo4PDggTVLiOGF+6QRPPvMiaTrkzoOHuL5LrdbGL5Vx/AoKzfLCCll3j43NLSqezUKzxLnVObqjgN3jEY5vU56tsr07pjsAUgOlI86sVQkjTZpEeKUKlmGRoQlTEzXMWTh7Ea/kc6JZxfNLHA0Sjjshp8+c4cnnZrGv+z+MR/fx/AkYmadoCcLwQRrkOkNioJPhdKfp++5Yga8vJI2QhVOEVtM9MoE0QCtR7GJpgZpi2LWY7kJpClEjjaloy4s9NV0QIdM0oXO4Re/4iGASIKQsSqQloASWLTCkpj23QL05Q7laQwoLDEnahfHDG8g0wj7/bLEMP+kinFKBtzcNtEqK18Kj0utHnWzTGKawYNpr9ohuUmgsA/KCoohpIVXGoxuipYFWYgr9UEVZt7QKIqNhTD/+SM0WABVpOsTRgAdXXuHBzTuUSh71epVKpYrnmrj1Jq3VM1RmlxGGNY2eaoTpFW6ekO87l8Uu3pSoKQSobCoG1fTFFzCV+UsvMN5+QBpHaG2jcwudpaTBsKBKqqy4H3LqGqocIQvbU6mi3vvxPB7LFDz17ItcePISlVKLf/ZP/ylaj5A42JbFL/z1v8KXP/cWw8530DLnmZ/8cdrNZb7727/H1vYWSu9z5kPPceYjL1HNyyRKkwlJPkkJN+/hOgFxHHE40vRlBUcYaJ1huCVkYhIfpwWMLBmSJTmSIuWTypxca7I4IR+M8SuSkyeXeLg7gXGHZtmhd3TIcDRBAUtrJ5k9sUzVWODa66+x/u7b1MlYXlnhYLt4/IVQCNfFskskWc5ss05jdpmt7U1EPqRd8wjSFLNaJhqPUa0S4+MR60cZb+4l/MENWH7vOmv/dpd6vcIbV7d4L0iJzAHJaEAaxnjVKv3eCMPIqVR8uoMIQ0hu3dvA9T2kp2k3ygRRSorENASW6+J5HjrPqBiaVtkj6HTRaYbOQMUJb165we5RyFd/+fcp2RY1mfLMvQlrDYvFhsmp08uc8Rzchgemg1H1EXGA1oJk9wFOvYGuNhE6RxsS/BJicgSmXyQQMtBuCRUkDB9sUZmbw1pQsHwBlEQEXSZ7fTbfvk0ymvDkx57CdmyiOGUymDDcO8BzygTjCeKNLzI4DKidbaPSCXmcM5mAYSREI0mpojGlor8fFcARDcKETKekQzBsh+DwmMS08Go+maFJhUmnMyGxBa5fJiXm+ve+xGf+zC9w6vQl0s7LaCBXCaPDA7LuPmVDE8UZg3u3qEYZNSMHDS/IkN8QKdt5E2XNYEQPwF1BNGfRM4uo3S1ErqF8CpGvgnUVXamQbdyhe3zI+tvfY3IYE2tJhmSic9a3e5xYqhHICrfvHzKYRDCGc7M1HFsyOY45c+YFzIGge7TPzA/4nP5wgCCdhLOnl5gXKUpP2DnOsOx9pJC0W2uMo5jRpI9SY/IoIAxNqv4MBwe7SMtAEOK4FpZXpWrCa2+/iZmOadZt5ts1wiimtTqLymC5vUCcjhg3WximSaXiEo86bO7uo1WVcZRx2B+wdqpJfzAizzRxEDJTsogjhyA5Zt4uk4d9dgd9lKowPzuPyCMSFaBNh5KTY2SwvnPIYKAYtQWOpVHaoNVo4DoTegcBdzsDlk+u8XBLgdtkEmlWZkoc7h1TDkbItI7jVeiLmNEkpeR59Pb3WWrXyWWDh+ubZMkErZo0bcHWziE3H0TMzjWoVRo4zohMhfT6BXDj9KmTfOcr36A+02Rvb4+llRlOnSiTkTP33DkuXFjhuefO8vLL73J/Y4eN3S6+X2YcBJQrJXzfwQD8UoUomiC1DVaO47mszbb5m3/pT1O1QaniTZvlOCg0w+EIv9ECneP5gjnR4MUnYDAYkay8wKnlJX7z83/EcDjk4fotpBDkKsLzqtSqTY4HPVotC2kYaOkiDYc4ikljaMyd5nA0xvTnWTk1h+OUWGi3aNXrJDMLjPqH+LaHcm2qlTqd/Q4X1uZwbRdUQMVyub+xRZQ5vHLjAZZhITPNk09c5P7WIcsnT3P37h2eemKF+1tdlleX2dwS3Li+yWDQYzgYEYwDWrPzfPerX2FldYl6c5652XmeeWmeXGn2drfY2ZvD1DAZH6CzlIrjUKl6XD65yLBmk2iTMAyp1apMYpNqo0bZm6UfJvRHCXGuieOUaqvObKtCGkwIww6+45BkGsd3Od7aprU4z9tvXcGu+FQsyWc+/RE++wt/ho2NfU6fO4MpYDKOmGnP/jAe3cfzJ2E0BUGx4OBjyIIAqKd4EDHt1gIKbSHElHKvUJr3aX4CicoflZAxhWtALk0kEvL8+9HFaQxKTEVbnuf0jw85OjwgDGOkFOgpTMM0BMYUElKr1WmfOIVj21MipPE+qMSfXyIL+lArI20fPRm+30uGkRen7SouXCDDLFylLC+oYNOeNlSCFg4YVrFzxdTdQ4NhfN9BMoxpPDAHLQuoiih+n5AOWgjk1OGa8vPRhjUVTIDOCY722b6/juvZOI5NyfexXQe32Wb+/NN4rdlCJOkckVOI4HSMxEKJAuLCf/dAVedFpYEwgPz9XrUpxQR/ZpXayimOb19HpUlBz9QmaThGx2EBDJiWgj/6fyg0KCEeA0Eez/vjuw5X3n6L119/E9f1p2BWA8MwSDPN53/zdznaG6AMqNUqfOwv/qfMl0/y3d/4FuFkE4gZ7u/jCM3Dgw5mqUKYTXhaDnnl67/GJz/7IcorZ7j7YA/drNEbQZhnKJmTRAlJEBHHE5YrNmdOWEwOA+52JoSlEq1mizRMSCo2ftniZLuFLxsc1KrMN+cYdXpYpoPXbDLz9MfYGM6gs0Puv/JHzLZsVJSwtDhPd3+XJDMQ0iJNFMPRkCRLMaXNw+ge//Uv/QP+y//jf87x8RYzzRrD3oBSu0U3BFFZoN/dwbBcAr+Erp3grdt3WWjHdBONUy2xONfizLnLfPub3wTHwTAtKmWbk6fWqFRavPHGVQZhwv2ddZSWtKq7HHWPsKQsDIwm1JtthFDoZEKeKWwpabVqGHlO2XXw6hXmVhb42htX0U6ZiWPwh6+8S0vCEy2Pj/2oora8zNLMEUZlFq09hOOhhkfYtVmIRkivjLJNjDQkN2xEbRkdhCjXKf5urlbovPc6br1JKi3MXoCYS9FunWS/w92vfJcrb9zg0vk6Qb+HrreJJxG9wyFpkIGVYbcqpEHBO4gmCXF3CIZE54poLMlRBGNJuSLodjL8ksBrWThlA7NsEQYKs2QQDGOCiaI7igixCYKEcW4QJRGOkAXZEcE3vvwl6kKxSIJCk5sC09akOiu+h42cCjkuaRHvR/HSwz9mYflJ7uYmqrWGTDeKBMXxBJHEMOyhe2PwPQQj8n7I6EGXnZffZuPebba2EqhXcaMhMxPF+afW2Fzfx6/NULv4I5gLN0mD6+RacdxLaFs2eqyRtkO8v8uV4Cqf+gGf0x+KOGvUG8RJAlnG0VGAXWvSDzIW5psc9x9Sr84w7nbpiIhwmNCsCmyhOH/+JJ3dA9JYTkl3He7eCbFqipPtMpdPNtkdxKSmicwyzp1c4e76EXe3d/Esn3bL5+79TUSe0h+MMd2MOHExzBKuV8cIU+Zm60jLZJIJVv0Sl061qderfOWbR9TrTUwjo1k2wWwxHBksLSxx/b0rREHCt9++S7Vco9lqMt9UVH2bmi8puxbhZIzQYx7cvckkcVg53+a9hw+pnZ9jtxtQdhIOjlxGWZ+Zqsfv/OZv86d/+lN0Ovu4YcDs4jwvvfQk21u7GLZBEMxSavn86AunuHl3A601t2+s45c9uuOUSrXExs23WV/f5uBqzKc+9TFefPE8Qml0pukd96mXLT78zHmevbjKlZe/wZe+dZvzz36Iw6MjJqMRkzBmbXUVQwqeuHQe39Hs7u1yeDTmoy+eY26mSRpranMOrucw7A8Z9zoYIidLQky3AkJTLltkyicaR5xerlNxMvb2nuR3P//HhOExlmtjOTVs1yTJEhrVGlsb61hGgeO2TEmalKk1Gji+g2G7VEsVjg92SaIhm+vXUNogzfX0TYiJYRvkacjsTBXyAW9cvUamHY5PtPG9Ks1SSqmyhuPXuHH9Nq9cuUOaJWzvHyBNk+9c2WJlcYH33rvJ3v4ull/HNgQXnjiHQLCztc0Hf+Qj1Pwqtx5sY5o5L3/jK0zGCbVmjThQCCvF8yuUK1X29jcRxjIHO5u0Zto0TQdnucV4FDKYxARRTBqNKfk2R72AvY2HPPHMMwXIwDaZJCbmTAmZTrh59Rq51vi+w+bWFR7sHuL7Zc6cO8u9zV1S3mJhbhHHBNO2GI9j0iT7//lcPp7/UEYXe0aiAHAU+0YKaTpFRE/l032yR71ej97zT38+pRUWLpQBqkDvp2mCaeYIy51GCXUhipSa7pMVO1mDQZ/O8SFxHBPHcdEPBli2jc5iHMOi3mzTml/CdivT/jBVvCYpQRRl2IbOqa9eIuodonsH4HnkSYiUCbglBGlBoVRZAThBIEy7MAYLa67ILWVJ0dlmuZCGBZVRyqIHblqkjTAL5WLIaTWAAmGip0JRGDaPbpSQ0042VRDoVJ4SDjvs3HmPJIrwXI9SuYJbqePV6sysncWrNtF54YDpR7FCnYE2i/03VYhCLf8HHWTTqKia7scJaUw/niOEYObSiwwf3CdNUiwrR+c56SQgi0NMw5rSMcV0R7CgwxW7c/+jf1M+nv+ZjlI50hBIJdBkBZRrenqzsnqKjY275FmOAUwGY3777/5dyt4p+uOHICZIKRns7nL7nTfoD8sI08SSCXLN5af+9t/g1ihjxW/TWK5x+942vRi0ZRCPh8RJ8ZxlUYBDzF//G3+eO7cHXP2VrzAxNHlgYhplDL+GMm0eTCSq1CT2T/D2K7+PbUDJd4oD3m7Eg7f+gDNPzmPZkv4wxjcUd9bXQdpIkaGEQa4ykiymUinR6x6Safilv//fcPXWHfI05KA3wnYgSU2iICWLRzzxgad54skn+MPf/wL7G/dYXl2gXCsR6Q6OYTDs9Hnttddoz7Q4ef4c6/cfYGhFOA6J0w5r507ywosf5Otf+gLHuzvEOmVuYZ5+t4fjeyitmEzG/PRnf5Yvfe53yKIYV2c0LJs8HkAqWWi3kP0BL5w6yTubO9Rm5im7DpXZBSZk7B3B+pUbtBsuvuUiqq2i0sStI0o5BAbEY6T0ix1DKytIjpaDMGOk6WBOBlj1GloZJGECUY6x3yGfPGTzay/z1qvXObnmUmn4KC0Z9ibkeUouBNo2kK6H254h6g4Ij3dJ4wlCQ64zUiyqS3Xy7Q55DON+jtKCJCnOvIJxSsX38eolsjTHK5lECKKuYjyKSXKTZFo4TZaRJyle1cMzFS8+fZaLP32ZrStXuP/WDQ7CCX1sctulohWlKERqhbAlOLCih6zkfW7sj+jHZ2m7r8HwGFBoy0XEE7j7Brr8DOnGQ259/g9Yf+c6+4MAu1Fja5xz7sl55k+t8N3v3KZeL3MrVoySMf/2H/49tm89IDRdSpUa24dDrJ7gI088TX5tyIN4j3vm8f804mxpvsnhoIuUCq9kcNjpMnQSyp5Aa0k4ShGUuLd+wMq8TalSIcrKlNQu2oxwfYeglyGFT54r6koxU6qzfzzhvdvHzLSqVEoWNjnjwYTjgwErsz7hBGyjym5nn+XWIg92OvTjIZ5TYximXFo7zeJMk8WFBQ4PHpIrzShVXL9yi3q1RZ4npEHI/eAeZbdBJnJ6xjbRJOOwH1DzqizNtFmcqZLEmrKriMKcHgnDYERnGJBrC5Errr/1TRYWT1Er1bhwwcJMh+S5Yn+vR9UWnDu1RjAcctALaWuDaDJhYxwis4z+eEKc57TbJ9ja2sGzXBxb8swLT7O/cY+jnSPG0kRKi9bqGuUYPvmpH8UgQUkD22/RGe4xHIdYRlL0zqJZXJrnL/6FT9Pv7RBOUjyvxtzyEmkY4EkDLRS5eBIsh+6DBwgzx6CgKgaDPuNBD3ROuVEiCzvEOsMtz6CFpOw7LC200QhWlk/wmY+D71r8v3/ltwmDFM8TNGtlTp48QbPZYHW+xutvvUumBHPzq3i+hzQEpDk6U3QHXexSBS0NZls1xr0elmvhmB5pFiMweHDQZWZhmftHklKlya3bt5mZnyXo91nfPKbZbJIkWwyGE9ozDRw8OseHXDh1ivmFJfxKjbffnNBoN+kedmgtrTEaDYiCkE7niE5nh2rJ42D/kEnvAJ2ngGY8HrG2vEAQTsiVIlYmWiWUELxy+4AnlMnF1Vlu395gbraGzCM219dxLE1aKTPsB/zYT36SJ544xyRQDPoDNrcPeOXlVwnqPtkUeT5Xr7B3cMRT59e4cOEkySQhGkXcurHJ1SubvDAMeOLSJZrNEsOHRz+MR/fx/AkYLa0CJz91fgrEsiq6uGDq0kydLyicGSHeJzU+AoUIrcnSkEwpBBLLdIpTdZW/70DpPEXpHK1h2O/SOToiCIdTGmRBbsx1hm0VjZf15hzN9ix+uVw4QVIWhEMpinhflk4pj2axy2XlmOUa6aSLnkhMz4dKrUDa68IlE9JCGFOQhxDoLIEsB9OcRhiniH+V86gIexrkLKpElAJTF6Jw2m0mpCgEjDSmq3UGOpsWeQsLnadIrd6/dpWnpJlCGzaGY+OX65TKVWbWTlNqL5CTIw2vWItLE7RlIrQ1rQPh/d3AIrmo3o+YaqWLTrbpfl/BM9EUt8ykNLOC02wS7e6QJQm245CrhGjYwZ1b5v3CaVkIyyIeqZGG9T/K9+Lj+Z//2KZFDmiRF7vhpoFll2m2Zjk42Mc2bbShMS0Tx/HYu/0eSfoO0jCQCCrNGvVGHT0+RJgerm1SsQ3emWuzfCQYzpzmrq5QtwbUZ2DOSml7EjP2OOwlbE8yDMulZvdwHIujQNFeWGLxxAwYgtOLsxx3UnLPRAtJ0jvg8idOI878R3zzc78GSUK74bJU09yJHpAMBYbv8dSlJ3nz2js8/5P/EYfrW/S/+UVIUmZbLS7PVpibbfFwZ484VLzxrW+Q5YokVaQqo2b5pElOyXUwymW2N3YpeRVm508Q+yNWFk9w8eknmYwm9PpDgv6QufklrJLHvfv3+Jmf+Rl6gz79/hAhDZ589kV29vb48IdfoN34JLsHPTqdMa+++irnLpwFFIcHR7z+2mu4JZ80HJKlGVsHB5xfmiWLAvYe3COIE+L+mKZtkA6HWFohj3axTTjs9ujNnWZ4uILZXMaqmAg7RxoSvBpaChjtg4ohCsCyi+ieWQGlUEKh51aonzhg963r2HGDvLlAfOcBm+/e5fpX32ZpscLcakGUznIIwzFpMMYqVbDKFca9MREDJsddolFOtSRwPIlhOgy6CfbRANcWpLEiTcAvCaTUCKnJUkApomGAV3IxXEl6NEAbDqUspm5LjoKILDGwTIklDYRWWI5NEAueOP8sP/GjH+GgP+Qbf/RlvvX73+Y4y6kKTUOBZYgiri7BzhJKGNw1c8ats8zcy9E1gSjZ6EyCkaHfeYfMN3n3i1/jynfeohfkhIZkuHlMpA02bh+SofC9EtdvbGCXyjzYDsnTCUeRia61MCawYrU4X1+k/cEPc/TNV7lal8R55Qd+Tn8o4uyNd+4zCjrUKiY69/DdEoaYcHigmZ9dpjOYIHXGB586w/ycyWBoM5gccmfjmJmZWXTkcDjYwRIhS40S8XjIfkfRGSvmFhp4QrB66jQb6w8IRgHzrRbdQRchcpIM8hgGoxSlMkwdM9uocm55gbDXo4PmsHOIbZs4hsn3rtxAOg4iF9S9BN9XxLGi191ibnaBo4N9jvshGQ4ffOY5sihAUmI4CjBNE9ezGYzHbO1MGA0ks/MNMmEz03YZ9w7Yd22kO4thV+iNI86slElSxdr5M4SDPqsri6xv7JJl2yzWLR5sHVBtzWKVquwc7DM/O0cSjNEZvPHqO4yTlLpncbC/S6XeZDAW/C9+8a/huxlxnJJoQRju4tvQqtc42HtIqdYiCCOefO4ZRJ4wGcaYloMUOXmWYZoemZCMOvs4JReRxCRSkgxDbM8n6HUpWQrHEZjCwRQGSZJjygn9TkIaRliuj3bqxOMOQXcbJVxmKg4/+amPce/hAMtStBo1PL+C6XisnTxJquD2/S2iMKDXPcL1fWq1CpCTZTl5kuKXSugc/EoNISS25dBq15hECVF6jEbg+SV2tx9w/vwFDo6PeP7pJ9lYT7CdGmHcY2F+Hq1TJpMxFy6cZTQc0G43eXBnh87BHkf7DxEqpGsrlD5Jo9ng1IXL7GxucvfBXU4unyBKEywpmKtUKFXqKE3hcA67zNgBx5bkzs4uplXm+rvX6e3uMBj1cd3LlEpl2icW2Hu4Q2u+zSdeuoTlGty6fZv9/T6u67G7c8DM8gprSy0e3LuHxuWwkzC7uMblVpndB9ucuvgEZy+ex602sIF337vGvTsbXHrqDPMzP/jD/nj+ZI541D02XS2T0kRLe0o3zDDIi54yoaduSuGiqWlMUeUZSTJB5TmuU8K2bAwpCuw8FIIKQa41aTSh3zliOBwQpzEq00hZ9GmZpoEUNkJqbNui2Zqj3pxBGsXX4BFuX2dFxG/qCgmtUFlWxA6VQnpl8jgg6/cRaKS0ENVS4QqmURFZVBT4eWTxo5yWSU+x9ELIabTz+7RKKIiI8IgoaRbuls6LjiCt0SqdQlMUmDZC5VMxVwgrKUzIU7RSSCVwLZd6tUq9UqKxtEJlbhlpOeg8hixDiSk5Mw6L14iYumUFcEVPu+UK008UpdFMMf7IYvfvUXm2EEhp4s8s0dveI04zZFoUWQf9Y+pZjrJl0e2kNVKIwrUT9jTq+HgeD5Qsg0zlKJWT56AkJFFM9/iILIlwHYc8zzl56jSICoP+mxhmihQClcNP/ORnOHX2I/y7V26Qn72AzDTC1vx0tcFv/+YbDPxrXHr+Od5a3+TkQpm15RIvXZ4l65ps9zXuyEQKhW2f5nPXBtzbM1i8/AzSt7EwmKlAGiVsDLtEk4DqZMDtt79AsPUeWkGiNMf7e7TnTpNqybtXrxFHE757sM9f/t/9HT7wi/8JrXHK3735gJ3tdzg8OsKbaTB+sM9HP/wihwcHHB0ekCDoDEeoXDMZTjAqJUYqo1w1ycOArTu3+fDHP8GX//BL3L05ZmamQb05y4c/8nF+6f/+X3L31l3sWoVKrcJXvvLHmI7DzMwsURjyO7/2q5xYmuezn/007fklfunv/yO++Y1vUWnUee+962R5RhqnzLVjqlWf9kyT4c4GOgk57B+z1KwxGQ+oVG2WtCANJwhD4aERoxFzCz7nF2o89cxF7JJNcLxJff40IugVB1jpBGwb3ZhHRMfoPIDeCF2rIwjQtouIhiAVYmGW5oUR91+/R9Npc/udK3zr829TNjPOrjaY9EZYdo34ESTKNIjjlCzOGA0meFHCoBdhapMkV1Rch+E4ZKZhEYwSUilQMdSrFtLIsUzAlFQqRSJKDyeklkQaJs2qh0pyuvMWo72U2LfZjhKiEJAOpDlJkrO13+XdV97CDt+kNneSP/8XfpELT3+Qf/N//XuISDGTKWzbQFgKDI3OEowkomcKbsh5Tk67UrQSYPlgmrCzzdEbFW7d3mRvKKjPV/n0f/yjfP0L3+bdKwP2jmNyLYiFhVsqYUsH1YuYq9WYJWI7FDyl4DMLK5xpr6Lub/PvO++Ql9ukQfQDP6c/FHF2cm2BrYcptWrKldsjqk5Mu+EirTEHm9s0mnUasx47G0dsbSdkuoxjpyy0Vzi7fJJ/+dtfxi1rnji1gmMaWKUTOBWHS/OzKOnQ6Q752nffYa8zIgxDgiCnXC7TatURWrK/1+HgOKBSq7E8P4tlpEy6hxzsBtxJj6i3yyRxwHKrjVcps39wiC0TRAJRaLN9PGZups7C2Y/x3s13sewRZ+ccgnBIFI/Rhyk37u6yttJCRFvMtlq8+MRZJpEmUhlS+vhehcX5E/QnAWtLNd67s8OHP/QSnaN9DJXS6w9ZWztFGkaYjsfRww0ebB2xMDvHQX+EGaW4tRJHRx0mYUDZBsuWrM61eO3ttzhb87Edm5/7uZ+k5CSkscRzS/hujbkFjzQZo8IutuchURwP4Od+9oMk8RCUwHasIqp4fESuNUmcI7KYJBxiuRLXNskzGyUd0mCEtm1M08I2TZI0RguLJE4wCRhHMUky4aC7R7lSplGbRZgmcwuK1WGPBzt9Tqyu4thOETlKFeNogmtJzOnCvRaCbqfDZDRkdrZBOJlgSsnZs2vcubdOFufYjo9hRYxHmhRJHoUcTlIWlk4wmoywnDJWFLGxuY1pefR6XS5evkwYjjk+2qNUbXL73jYXLl4kSQts9blLT/GRj32cwXDEsDdke/s+Ok+YhCHX37tGs9XCqVRplRr0R11GvUPuPLjP6uIanmtTsQysUgsdGxzdXWdlLmcUTthTAYaGjcMxF880Wd/pcfbMBfyyh2EZTEYhoyAijWOiyYRJELEw1+TWzTu05ubI4oR6vVm8MbM8/txf+zGEtkiTgOODAxQ5m/c2yNdWuShssken+o/nP/jRmsJxKdjsUyGk348XgiycpnzqUmUZSgh0lhJHAVmeYVgObqlSROpU4bhoLciyhCicEIUTwmBMHMVkWVZAMaRAGMX+miEkpmnh+2XKtQaVegtDTAuiYVqKLNB5jFJF0TMGhbASmjyPim7K8RApBJ5fw202scs1sOxpDDEr3LXpnptU+ZQ8WWDBi5ptgTTsAlAi0ukNyqfu3BTOKCVIi+IijAKe8v7dLGKA5I963IrPW3TGFWAQrXQh1OKQuu8wM79AfXmV8sxScf/TuBCQU6dB5xnCkoWrqHKkygsnSxU7gkXxd7EPp3WOMKwpVTKbIv6npeHT7jNZKtMPQ2wnh0igtGTSPSLs7OEvrKF0hhSF+CwueLrf9ngeD+A5JsqwSUdDEl0AwqQhizerWjEajwG4c+tmEbNVmmajRRiFRJOQq29d4fd+64v47Rqnn3sSoRpUZIUvffENVOWAml/h6pXXINdY88vYyicNU8rVBkvimEGe872thM7xEdHr90BBnKUYlRIV2+F4eZnOcMzh0TG9zjFmf0jp9gZVa0KgNUKYjI+GvPbKy7TnGnilebpbD9GjDmdnW6iNDuubIcQj5meqHPcGfOKTP8E/+we/zHu3/x0Li22E4/LC05c56hyRJ5qtzW1M26A9W+fpZ17i1o0bVD2Pu7dv8jf+1v+Sfu+YtZNr3L1zn/V7t3jhhacI4hDhl1g9c56DgyMOdw/YuLuONOCTP/pxJr0DgskYwy5z9uwFvviFL3LhyctIYXDr5i2CyZiHQcDc8jInLz0BaQqjPWQW4diScsvio59+gQc3NymbDzBdh1arznjS5+SJNlGvSxr0qT/7SYwoJz24h9I5Tn0GzBjh+5BO0LIE9QUIunC0U/xd1migDAMRjsCyMdwqpbl5Xv7yt3nrygN0LjgxIwnjBLe+QCos3Pos4eCYOB6TjRPSIGIcZRhaFGsfvsQqOwyinCQ18GxQmUFKhm9aGI7GMDTSEFi+xPIchOFiOSnVZhVt5FQaNpUsw5+RRG8c4+cWuptwbwhm2cN2PUzTQtsmD3PJiVDR/fYXqdxc56n/7L/i5//6L/Ddf/abzGtVHFKV7OJ07vkXqN3qkzo5bzsuP+5dwFJ9dO4i6iV0Z5787i7X7j9kb5hw8yihlrkc//o7PHw4ZKQclLaZ5AauMihXmlxstDk9W+XJRpt8sM8/ee0tWtUZznVzfJkRf2oRdz/jaPcG8ST8gZ/TH4o4297Z5bA7ojtyKHmKOArZP8xYnCujjAn9QUqsJNrqUjYWaLcbSKfK2RNtJqHi0qXTiCxFYBEMczIn4mJtlTAac3NjjyCI2Nw6IohDTEPi+S5JFHHnziaWKTBEn8tn6ux2RwxHKWXHpb64gGpazCE4nBxi5gY7B0fYtkvdrxEHh1h+EylMnj27yETW+NQnPsTG9gGdQZ2wOsuge5WmJSkZVX78T53hnTsP8HyXr729ibQMLp07SbVapdmao9sbU6v5LJRK9DpdjGTI1r3r7B0csbK0iOFWeLizR9P38RyLSGms8gzKsiiVq1gGlB0DIT3SXpdkkiNVwPG9Q2aVSbc/4ud//BM0Kg5BkuB7ZVJtULIrCNtBjbvcXd9haabFw/VNFk5fouopwkQVSPw4QXplfMdiEoY4jkV9bp7RqI/IRxhCUPF9hlGONDRpmiFljsw1UkkME7BMVJzimgZGqYmfROzuH2Avz2Apk3qjzulTZ3nr+g55knP1xlvU6zWODw/pHh9jui5upU7NclDJhEH3iKXlk3SOBmTxiPPnTrG3tQvKINM5h1sbVOs1KhWfZr3FMJqgdI5BRN2TBL0j6hWfcyeX2dvvEA+7rL/3FlEQgTQpVysstOpkwx7l1goH+wFPPPUkSkuCSYjre6ycPMeNq2/gex5PP/08p86cpVq2qVbLfPWbD3GsCvOLHr0w5KjXx/d9ciPEM2wun1/l3bsHzM4vcvnZM+zcv03VcRhFGZ7bxHPLjAZDvvfWTWzbZzQKWF5dYP/hQzaPQgwr5NITl1HCoVEvUylZzM00uXvzLg9uv0cQZxx2hhx3QlaX51lanmE8HHDt3WucWFr9YTy6j+dPwAijEDgqL1wawRRUqPKpQCsEhdCghSRNoveLli3bxjF8cpUTh2OCYEyWZqRpQpJERFEMSmEYJvmUfihkIRSkKA59HMelVK7gVxtYpoU0LTQmZMH7PWHamJ66qrwQDcKYllnnDHvH7G/eYzQcIKSB73mEoz61RovS7IkpaTFGywIMInQK0kBJA3SGVGYBP5EmkiJ6iLQp1J+BEAVi/v24p+l+31WTBRpf6Hx6MOIUAcg0KHbXdCEAUQJMG22CFC6GXcLxapRLJu210zjtuUIQmuYUjlmg+LUApm6d1Bqhizin0vkUWpIBznTnTRZkRykQRoH1LxRd4YpqYSMMMJ0y/SDFEQa5qXFFhhhHjI738edOIQzxvvtXbOZNP9fjeTxA2bGxbYM0s/E8i+EkolKrEIYhUiQ4tkGaZWRZjiUFhqEZ9ocIKTFtm7t3buFYFmE/ROzexnj65zCdGo6jWf3RDzI+SplJM5A5ySTCc2CuZCAw2dzvsN/3iFRRlJ6Nx0TBCL9ZI+rsMnIqbEgDrz7D8soqKzOz9O7cZjOcMAlDpFXhpQ+8yHe+/g1cM8USI3zLIGmUSdOEz//Gb/OBH7PZuHeD/f17/NjPf5Lrb1zl3/zjf4IhBLbvIv0SOw877H7tZRbn5iBLmJ2p8dyLT+C4Pv1Bwk9+9udpzbZ55+q7xAisapN+kLK0doqZuTnmTpxgbmEB0/ZRCL719a/xnevfZjIZ8dk/+3OcOn+Z+1diXv7aa7z+9ga//qv/GsO2eeftd1hcXASlsS0T13N54aU/xcraea69+Q5rC4v4eZ/ReIhrRAz3drF8i5/6c3+Kjbvr6FTwwU9/hv37d/EtyfHDQwb/9nd5/md/AYOIYRgSjgcINJULL2B4NUQ6AuWSHwwJ9w7wz64VbqdXBdOFziEECb3dgPvbAVmYUrc0ZgaZgjQOyaOIXMDo4JhRtw+xptz2aWmDyThBoLEdk3GUk8Up9bKPkhl+1SGNiz1HQyksV1JuemhTkGQ5lpkhJZTm2wgUouRRFgZemjAYhjw4VAxDySAR7E/GCNPBkAaNZoNJauKefw7d32Zy8ID4O5/j2bVVlv7r/wfmN/6Q9Le+hD2J0dUqcvV55o6aCEPz+12T/+TUp5jLv4pQEfq4Xxx87XaIMhtnbZZYdLnbi7h2tEvF8pCGxPdqPF2rc8Gt84Ezl1gquZQ7CYZyidfKzL7zFs6l8wwf7OGqiP4rb3JmuY7njEjjH1xq/VDE2Wg4YGmmSX8YEAcGM02XRqNOFEKSjanUfDyjTNIxqNZ9bGlx/b37NByTNM44vbjAlSvvElbKiCSlUnLodPdYf7iN6zWYafg0WlVGewlxGCFiTaPm05718C2NZzbpdTWDXoZjjmkuuAwm26zOn+Dr1+4gMVluNbExOQoiTMtlpjHDYDBGWpIolvxv/7O/jm0okiiiUvaIUpe8eolQHJFGip1b69zf2mI4ifnACy/y2hvXSLSN1i5oQZrH6CwiFTZkIfOzDcbjgFbNI4pi7l27y9LaPLrk0hmMiTNBvV1nezCm6lXJog6TfpcwGLF8dplJaHLrzh4t3+UwSrh86RSrp5fYPh6xutAmTKKiiLAliSd9ZB4xHHSYm21z5fp9PvmpD5OOx2SZmv67LEmzjFwVRZO5ylAqwxCQJCmlskOaKNJ0TBJGaEeCSjArFWzTJU4SdA5eew5vMkHaLqcvLhMnMddv7WE3ZlloVGm3Z1mcm6c2dxJpGLz88jdZWzvHKMyoNVpYpoll2DRrLZq1NkpKwiggHIXs726RYJNph72dh5R9B0NXqVfryDwlVwrHtNjdO2QSRRimTcVxsX2fZz9ynvU79xkNujDssHrqNGSKra1tckPy3a9/ixNLS9x44zVM26beaBHnGeWSw+nzT7B/cES10WAShvR6XdoVh/FgyAiFEIrJcMCFc08yGPUJ05iy73Pr+kOWVlZ48ZlLpEmfmROrNNpNmiWD+Wcu0qo6rD80OTHjU29WMbRBsz1LHoT86c98hoP9h+RZTsk38FyDQa/H7cM9lBJEw5g4CUminJl2gwvn1jAMONg/4OatdX7rd7/KP/zlX/phPL6P5//fZ0p7MAyTAg6SFbSsKQRCa0mWJoSTAVrneG4JrTVppoiDCVEUEifB9O8H9X4sDgGGNMhVQWc0jMJ6MkxJqVSnWq3i+WWkZSGFUcT10gSdRY9K1FCmWUT1pIFOY4TWqCQiTVNGgx7jYZ9Rf0Cu8kIAZhlRMMG2JH7tXEGJ1Nm0mFkhdI7AKBbfAXKNmu6joSh2s/K06HVEI6Q5raG2CzKaMcXs66wQTZoiF69yhOlCFk3JjQaYU+ZzGn5/dy3P0FriluosPPk0tudjlavoKe1O5zmY1qMbT4H8LxwyhADLRGiNyPJpcbRdOBZ5ijDNAsiSpehsCnQRGkyziIKqBJQgVzmjTBElBpltUTN9ar6PFhqVpxiGjxbqvwcaEf+dsvDH8x/2dMcjtJZ4jk2c5XimZtzvkWRZESuWEtc00VrhOBZ5npKmmmxaSWHo4nuwPb/I+lc/x2LtIvcqJzG1zfrVHo5IydOYeqVJdnzM/LMrbG9v0U98trM279x/yNLZefr7IfOr84w6HtVWjSDLsByXyytL3H4w4WBvk86Nt5k8fI1mLeM//Zv/B37ln/1z7t54l+WVWQyhuXjpHPNzC7jVJu++9g6mmrB356u89NxZPvDMX2WSVrl+9Q7Cc8izIm5t2TbtmTlefPGDHOwdkkRjTp9f5QM/+gnuXL1Jo+XiuCU2NnZ5/vkX6fd6jMdjavUmh4f7jDe2SZKEo6Mh4yBjfWOd+zdeo9s54Mlnn6VcKVFv1Nk+GPDy179NN5xgWwaV+gyGZbEwv8jszDxKZZRLZY6PjvnOV7/FaLhHli9wYfUEZm2W/d4OV4YzLJ+7zN3DN+nd3wW/jH3viKwzpNqeYW/vgFNnV/jOb3yOD/3MZ2g0y2gtyKVDtHOT0srpopg+DOjfuo1bdskO97FqZyCeIJSBti36RxO+/rnv0YkSZjyYqxtUfRO/UcN0S8SjAW6eEo8DDExUtcTcj34WqwLbv/ubJHHRK6nQpKlgOEwoVUya9TLdgwDTEGRKkE80blXTPwopl11MM8eue0jXQi4swiRGeDbVJOLyxRSnnbA/3mGnn9Es+YyTgCx1yZXmzq11jmZOcu7Jk3TeuYVhTUgOb7Pw1F/E/j/9v8hHI/Q3vo3Ih8hf/0eE5f8NyaJg0zF4J7/EjxtfRWoNWY42il09cQTbRkacSlzDYM2zaSJZLrU5t7LGSavMolnFbTSRZxdg/RA9jJHVKq4l+NbdO8zkFqfSHkeDkKUnFigvnWD93ns/8HP6QxFnQeRwPOgzX69z5nSTshR4vs1uNGBuaZVoNKFeq6IyTa3VYHdrwFzdJc9SeoMxfqNCa2GVTj/EMmM8s4YwZwmyY1zD4vTZNW4/PCYIQqpuiZlGBdcyCYYRgc4ZjIeMgpSZmXlmWx5ZNCIdwXp3B6/SoFmyWH94wNLqGsPuEWdnS/iGx+FxjzxP+MW/8LPMz9cJRjG2Z2FaEpWN8X0bh3lKc1X2b99gbuEETj/h9uYBF556lsSpcXVjh6V+n5XlRYI0RoZDoiAhkQ5hqIjzhGDUIQgmzEQZgRORpDnH3T6HnT7SsDFOlUF7eHqCY2pu39pie6/DmZPzqExgVT0++KFLDPo9bOEi0ERxzGy7hM5jRsMBVpYipcPtO/c5ceosjmEQxhFBkKIQ+K5LFCU4rkWeKwypmQwOAYFpeqjcQCmF59qINCdLi9OQJE2QUmDaLpHSjI+OaC2tYtsOWsP8XJuNh4fEgcb3M+YaJVZXzzNRCs8rU/IqDAY9yo7PuLuPRmL7deqNBoNhB9d0kLZBe3EZnWkMJCqKWFg8iedCFgTsbW6iLZPxZIxr2cwtznLy/FmGgxGu47J/3OXK1Ss88dQzHHVjFhdPYlgOnc4BQRCRpory3DxmucLx4T5x54BMa5pVHyEUJxbniMKANBrT7+zhVNs0GyWaMzU6R33CMMIr1QjzEbYlabcXMfSAn//sj/HUU5cJJiHvvnuT809eotftYTgelbIDJMw2bWwzJxh0sW2PYUdz69YtZhZnqZc1bsUly3Imkwm5NigKaXOSJMHzKzTbDTJpo20f04TZmTa3bz9gtv245+zxPJoCmf9ov6pwyARZlhOFYyajHnmWIwyDLIo5Tg7J8owkTRFaYZh24WJJC6Qx7SzTKK0wpEBahTBxSz61Sh2/XMayfR6VVIMs/rwqwB5a5yhTTkmyGUpr0jAlHPaYjMcEkxFZlhIFAVppjOkbwTzLMAxJrjSm5eH6FbSK3y+ZLhy3qeUnC5GjDLO4XsNC5AloyKUo3CsE5EU0ESkLkaZU0V8mi69JnoNhTt25dHoP8wKkQYFLEYaNUhnkWQFU0SmGbVE5cfp9oaeUYpoqLQQakKkchCxACsb0fqQ50jSn4lkVcU9RxCu1ykBOu9UAlccFqETD9OYipKRz3EPhYpgujdkFzly+TK1WpdSYR9pesZs3JXE+IjdO1fLjeTwsLK4ymAyo1GfYfHCfkmNhmYIkF6SZIstztM6xbQtDgGtY5KZmHCfFfqtlI8lZWJjh7u275Dvfo/qBs7iZh9CaaqlNGozIgxFnT5QZ9PZ58uIFXv/j27x1f59BCqObmyRBgJGF9I76DEd9ECZGd8z2zVd579WbCHWAinaRRkKalvj93/k1iAfMNFocjwZ4zVlef/0GjnMX2/fpHh1SsSXPVS1On79AkAgePjzmp37hz/PW66/R6Q159rnn+dV/82/I8oRvfes7DDp9KtUykyji8KCPERepAb9SZnNrmyiK+Yt/9S+zML/Aq6+9SRiErK2d4Q9+7484Pjxg4cQK7dkZWvUGu7vHXH7mOc5feBLPrWH6Lqeevkize0CCTRTFtGfnCYMQy7JxvCrzM/Psbe8TjI8QsijIfubDP8oXPv/vCXoZn3xqlbf+/et48RanVs7hHG0SXbvC4lqJ29evkwWK/a0vsnZygS/+o3/MJ/7GX8FRKf7KMgYCHY/RQR/huHQPtrB3E0489yz0+wjHB8cmHU34g1//OjtBSNXOaZU0jbqF55XxW4tF/VKWEXZ7JKMIwzBoXLzA/Gf/V3i2oPO1K5hVg3C0TTruo6TGLDu05j2S0YiKLdC5RlqCJNTs7QQYwqA/iknHCStPLRYHW6aF8AToFO151E6s0O7doV5xWGorqpbL/eOEJE3pD/roKOSbb9zjiU+s0WpvkU8GOE6Le7/7+8xnVWbudMEso+s2WiYsWwnlMky6fX5tUuZPsYzvvAW1CiKvgPRpj2L8LOYTlTkWPZuzs4vMew2q/Rw7KmNaNjSrUPLQB0PSW+sQaYb9GrvKYENoftsa8Uwj5qXnTnBzZ4u5Cz9Cord/4Of0hyLODCPDNm3QIWHoUqp42KbBwlyVB9v3qfoem/cDxrFgc7fPyeU1dLlMtepj2op+kLG80CROd9jfC9A6QwmJCiIOgpw4vEUa5yzPnCBHkWU53TQnjBOEVjSqM8zP+widcurMWR5sH6AnHYaJ4nj3CDnX5KMfuEwwThCtNt3BEbLW5PlnLnHY2WRuYYnRWNBq1Lhw+gzjJCdMcyajEes7+4T37jGzeJrjvYccj45YWjlHkmk8pWiWPeqtGYaRxpUGmVHCq1cx04xSWaAygZ6B967dJAomPFg/xK7XsaSk4dvUymVmyhLlGOhqg9tvP0DaBuVGDcc06Q+OubQ6R7XaZKcz4sLpBTrDmIpvFzsfakwy6qBMA8N1uPrqVX7qT38cqXKUkownEbZjozSkWY6ZS6Iwplp2MaTAsCR5rsjyhCxPcCwPqwJhCFGUMZkkSMunOb+Ci6a7eX+6z2GBTmnMtpmdm8PwW5R9g8NexCSNcWyXRqVakKFUzqnTp9hYv8do2EdFIdHYxDNs+sMhlqmolqqYjkcSxGRxRKlk4bo1MpUThin7uzucPHWeTOWs31/n9ns3aM+00MLA9assLsyyefcWcXeP/d4Bo3GOWakytziDa9v0uz3CybDI1AchwfYW99KcxaVlXHeAIGVhtkmrfY7W4gKjYZdg3GPSC8AFLU1UCj/y0Q+zeqLF8fYOW9tb6CQhyCRPPXWW+flZ1pbm2H24SRL1GCUJruWS5eBIiUbxpS99lbeuX+eZ5y+wNr+CFDapSNBoLEuiZRXb9uh3eqysLVJvVLl6bY9GpcTR8RC/VKbSnKHUrP0wHt3H8ydgHhVIg0blOVE4YdDvMh4NSdMElRfL/0XxMQVmX0ik6aHShDwvqIaGKD4mpERKiW2YuI5DyS/j+mUsx0VKORUoxQ5n4WAVZEitcnKVkytFOB6RpjFRGBAFY9IkQeWF4FO6QLtL0yp2qMS02NkwMQ0TITWV9gyWV5rukFmFwzTtItNphM5TtGkjtAF5UsA8TAehMqRWIDK0MCEPi9eoQCg9FVBWUQvANBIqjQIvjipIkCqbxiCnd1UayEJ1FZRLLEQWFy4aBXZfyKn4EYVoRIDxSCRBcTqLQFjW+6RGYZhFL1ueFTtliGncstjfU1JNKw+K/T+hFUkUsHX3Hs12k5WTq1x46eOYlo0zs4ptWog4AjOfgkAMijyknHanPZ7HAzv2U8jD76JEj4rjMI4SMAS+6xMFMaZhIi2j4OwoChctz8ilprmwyNmLz/LVP/wid2/cZTQc0HnlqzzxE79AFi8wHoWMw4TJcILOoeMknH3+Bb78lU12oxJuax53EpLqjNWFWbrbu1QzTe/ebWY/+iy+hvHOLeryOpbvcjAZk+cZIjGYa5bwxCz31zcxLMlHP/UiX/rDr5D0+lTyDNs2KTVbdCawfTBh7fRTvPbb30K6Ft/6xisMRj2+971XMS2TYDKh1xtQr1To9Y5RaUAcjDg1P08yGnDqzDLnnnuJ9vJFml7K9avv8vWvfJWtnR2qtQa9XhfbNBjcusafffLP8c1r7zAJUrSCBxt7JMrhs7/4N7FbNdbfusof/c5v8KUvfp7xJGIw6PGTn/400nZxDYO333oVTPDcCgjBv/7Xv0qvd4wUmn/xL/8VhpA4luS5n/1F1r/8W7SOHnLiqTWWLrVYf/cudp5x79YtVKb4wj/6F5w9d5JTT1+kOjtDFmc48wuQRpx46Tn2X3uTZNRDHkiMpTV0P+CL/5dfY/3+Mb4F8y0bz1V4loewXQzLJR90MdOIyWCMlAopFP033uH6r/wWs2efojsYoNJjojAnjaBeNTh1ronMQ4LjGMNSKC3QSMapJhwqSl6OowWGNjB9F0qlImJerhT7viLCyMCpVLHDIxzbpJ/EmJZEuA4qz7BKLrd2+7y95XO5toh/5iwH1x9w8I0/5Gw3w6h7RS/mYYxpSv7sJ33uzg35itnitR3NndKP8PTR64hgC22VoFHn6XLOQmWVrCQYrfg0hi7tjRiBiTlnwMoMSRyRXb9FOk450CPup0Oub+1zzzqmpBSrTyyyeMLg4Gif/vGQve3f48Sc9wM/pz8UcXY8HOJYFU6unubw+IAw0WzeHlGvVAhHNkvNBkqCX4M4DKlXBY5bJYpCBmNFP7E4OuzjuTXcSkyp7FKv+eRxi8yqUy+7bO4cMztXxTIsSn4DLTJUntEZDFB5SqXi0u1GvPX2e0yiFJlFeLbF2qLDeHzEg80UFVss1TwepDZpFHPYGfPM8z9FqdFGGhJLWNRrPgebXTzPJXc9arUaOlME/S4lr8LmOGEwGDIKQvzdDU6trrK6vMidGzeIDZPZVgOVp7imSTgeYNo2dzb2adUcNg87ZFGMn0c0ZpaotOYYdo/YfOMdhNfAIMGqnyQa7FKyAg47Ib1Oxqc+fZGjfkS91iBMFCXPxfN8DMskzzMcMycDSq6FYxtFETMZqRZEcYbj+YRRjM4hiRVRonCTFNeWPGKZGdJA2y5ZnsN0OdiZvhlTGahMYPs+9cXTWI47faNkorMJedRlkpvUSm32Dvu4vo/Gwi1LFldOEqUZB8c9Ei1JtU0SxaSGTfdwB51GeJ7AM3KOO0cYsmigD9MYL0txDbBLPqv+KocH25w9e46Z2gUORyNKvs/g6AApFYNBh9Eo5MKTz7P/cAffgBzNzsYugoT5hSUMx6Bm1plbWUPFIftb2/QGI6wYmo0mueVw6+YdZvYP0CS8++4Nzp2Y59SlD7H1cIu/+Gd/FK1dpJBsbXUJZZnPfeErrJ48y0984kVMFRPqQhSDQa1SwRImkzhEabC0YtA7JFYZlmmxsDCP0oqtB9s4jk+93iCOFVEaUyqZPFxf563DI15++z6rZy6wdv4cjmmS2RU6nc4P49F9PH8CRuU5SRwy7PcYdruEcYiUcrrGpFFaFmXTeTYlAGoyUoxp7C1XBTxEpymGbSME1Ot1Gu0FTONR95dGGsYUkAFMPSYBRWRyPGQyHhBMhiRJhs4VCgVKF51mpoE2BTrJC0iGlBiOU7j408JnISWW5VAql5ldWJqSHRVaFEXOCKsQHJaNFFaxz6VyhM6Lr6Wd90mHWk4FlDQLs02pYo9LKTQ5QhiIPEfpDKEVUhhgONOKAYlQRRF00adG4UZNO9JEgVKckhStYsHPmAohYU6R+I8oixqVZ+/DRIQqYEgIgZB2UREgpzHMXL1fsJ3lKUJIxPT1o3KU1uzeepckiTl/4RyrFy9hWwZuewmjMQ9Br6goKBqvebRz9z5a//E8HqDysb/A5FuSs6sh169cZ9TboLWyyEc++DG+8Hv/HiEThBBkccrzL7zEvbv3SCdjfuqn/wwnTp7lwXafj33qp3l49ybr168RT/q8UA94ZzdiIEEYKbW6C0nMKJb86u+/ys5OwAdfvEy+mTPsd/GkIu93sMYBR1e+xeplh5/96/83KvsDvvzPNhns2uz3Doodc8sgVjnf/M7bmJ5FpVzFNSUz7XmefuIJ4tE+vV6ffJzwiZ/4cW7euUcfnzsP9vnWN7/DMBow7PfIyLCn/Y2WZZLlGVJKlpfafPinPsHM/GV+55f/BWp8jNlq8bf/1v+eoKN59+U/4u3Xr3BweIjSiiQJUTonTXKeffE5usM+kyABpfnSF7/In/3zv8itm/coL61wgjmO9zK+/MUv4bgO3e4haZzytT/+Cs999OOIOCPJU4TSmK7LyVPnuXn9Bnmek6pH8WwIU/jlf/DLlCzJ+YpP74/f4/SJGlmckeYFW8BEsPVgn+3NPfa2d2m028yeWmGu3aLUrCNMj8qZM0RSkx0FDK58ndtXt3j1nXUyqThR0iyemCtos8kEneYEuzuYlkDZZdxmhmH00RkM4gnivX/OnW/blCoK5Xr0Oj0qrmD1ZBUrC+l3+7i2Js8MRolmMFBEKQwGmtQTnGhrSjMudqMJtXqRIFAJulxF4CAGOzSaDdotl7tDRZgIpDAYjUa05xbQQnKo+vz+K9usfPYpZqOI7v6YWqpx4wH0Q4Ql0DJCaItyavHc+VN8/tYWHW3wu/o0T4SLGOGXEOUS4OEri1bucHC6wvmf/Qj79zbY+PWbLPtVRjpC3NkgMCMOPcWGOSCojIiyAcsLJc7VL3Hl9S3igwfc2IM8SRBKUCrbrK3Vf+Dn9IcizrYOKszO+GwfdhBorj/YpV6pczCYsNhyyWON7bkIQ1CyLVrtJkmQcBxpgiBm1BuysbHD0nyTklemUm2yUKnRLlfY6kyIgiGrSy2ub+zhGj7DYcgoitFKEWYxjYpPkudM0hzfLeEYCXmUMYgSJkOfleYsttNAmSFjmbHcrNAdh5BLVk+dwHfK1FwTy9CcO7vElVtbuJ5LuVIlCovdrv5giO/5nDl/iSTNqDkmC02Xkm0Q9fYQ0RDH9Oh3FaZpEicZiRKkowAsi/nlFQ6uXOX8U89y8533OO7fxzvYZzyOaNcrpIdbKKHoD8c0qyWqTYtRv0ur1mZ+eYFMmbQbPv1+iOuUkKbAsCyiIChy4IbJoNcnCMZYEkhVcZJUroKwQGtyLYrTZB2QJzmxljhuDa0UaZ5jWBZxGqLRRKnCMAxsaRSo7XCIbVuUShW0LN7sqDwnTxMm4wGJSNjRilQJDMshz4qF+1Nnz3P77j2idIAwXISV4TkuWZriOFVWzpxjZqbM+GiXg+M+aRJRn52lMTtPOByQRBl+1WMyHtFst9jd3qRca1JxPOIooVRtIKSBMBw83+bt194kTxNUllFutEhzgec6eK5DLqzCIYwTDvd3kaag6Vu0Z0+wsrKCiiYYkyGmjoj6Q1ZPrLI679IuG5z76Au898YbmF6ZEyvLlCQ8ef48Z3/qx1mcr+F7Bt2dTfr7PdrtCv3RAM9xi/2SSU6QJ3haUPYcjg6PWVo8gdbFG+XZhQW0tDEMQb9zyMHBEUqlIBXbB/u8dfUKt9YfcvFgl2a9SrVaYzIlaj2ex7Nx7yZplJBlGZlSxbM+jTEKLVBKY5omKstQuSrcHCWKvjFk4SZNXTNUjuE4VCo1DGkWsTyhC3Enpr9XSlSWMx4PmIx6BOMJWRqTJlEhQnSxt2JIWXR2/XdifMqm6BoTBgiNaxedOH6tQalcwfPKmIYJckqYpIgbFtFENa0L0CgjR2RJEQeUsnCrdLH3gM4RuQJRXE9xfaJwrqZdOaAK8Iaa9oHpbBoOFSgh36clal0wIN+nHopCZCGMwi0UqnDQsgImImTRm1Z0lxmg1JRYqdGiEKWFTNJolaBzXVwDIAxZ3GN0Icy0Bp2Tq2JfLZz0eXDjPRYXl5k/dRLTqSClUQA/8hyRFmj+Ah5SOJCP1KrgsTh7PMWMhwOscx9hc/s7dPsRUQJmJrl25RphlGA7AikNlFBcufIuH/nYj3Dr5k3+8A+/wmj8OaQwqVR84iQHy6Bk2Xz+H/xTlj/1V6lf+lO4uaTtOownI9I0QuYZJ2c1ouxy5myJtVYDNz5k0tvlnddeh2yd+ZWPonZ2uX3jOrXqDMK08G0H2xBIw2Q4GiMNC0uA7zlUSmX++S/9PZqtGn/hr/xVkjji87/1u1x97R1e+qmf4fSzH+Q3/9svMez1CdQIZAE2EwJqFQ/PL3N4eMxkPGFka546/yy5WGD/8BDTyOh2+lSzjK9/4ct875Uv8cYbr2DYxWHWZDJBAo5tcfriJdbOnUcIi+99/Uvsb2/zr/7lP+H551+kZCn+eHfEd776VZ7/wLPcunUDKSXkxf7u2tpJbt+8g2UZ5Eox7Pd49XvfQAoDx3XJlYlOcwzDQCnoBwPsxjy3UwdxYp7ywR5VT2BKcEseUZBgmAZpmvHum3dR3kOePvERbr7+AG/wMucvn8Zp1hmNBnjVWf74a2+yfn+fFGi6glbFIB+P8RoOy08+T3i8TdTdRweS6rlnwPE5ev0rWDKmUjcwjZjWossottnfmRDHCYszHq4pCCYjanWPJA0ZdBOSRDAOIIoAJVGJwrANyhUXKlV0vYrwazA4RrgW2nHQgwqOzJhfajN8d51B7BOaJoaUJHmG7diY5QobScyvv7zFXymf4TAzONFLkHUHgglkEm1rsFLCr3ye/8/Wcxy6ElFq81u9jL9k/TjneBOdDsGywM8ZZ0M69hJ3Pv9tsuEY0xhxLDI6ckyjkTB/oc3sQo26XePe1XcYJzm1uRbVkstgbcjNa7scdTNyBDXfJOqM6A1/cLr2D0WcfepDM0TDkO3tgItnl6lXXJbmF4iCIdsHx6zNmHRGPZaW5llYXEGqCCET8mQCOma2WUFbp+l1BsiyD6Tc396kP4nxK1UG/Qm7x31OLJ4iSRXxeExnMGJldYl+t88kGHGEgWO6GBpePHuCvcMjJmlOFJucPLVGnJnEYZf5podllliUsNsJsawyfskgVwm9XoDIYjzbRApNr3NAnsWUSw6jscS0feYWmyTxCKII246wLMX25haTMKZ5ep79fsgLTz/Lg81NDtZ3cRyHbq9Dnh9gei38cgXTs+jvb7O1KyiVyhzs7GGqCOnZrCy0KFkpD3b7WEnKqTMtPNuhVC5xdNijWvIouzaOaU53tASSYqfh6LDL4uIittRoQxCEKcPxmEa9QaIyEJIwDhlPhtiigufZxSm3BtMwieOILEtJMsVwFOF6DoZlIKVgNB7j12qoFCQmCkGS5AyO9klShe9lyHQPwSyOVybPEuI4pupXaNZ8rl1ZR2sLy/IwKjaTMEBLyLSBiCJGoUCjKVWrSAF5GFCv1lhYWiKMI0aTAQKT5uwiw+GYOA2xLQvHtekN+gyHQxzbxSs16B9ukuQ5NZUjTcgSweq8Q6vS4q072zRKgqhs06y3CUZ94s4mVzbfpVGvcfnCRRy/Tr1RmRbzCjJDsTi/SK3mk2eamdl5nn5uCc9jejoeEnQO6I9GNGYXCMcBYhwSBGMEsHvcxzQFSnm05+dIxhMOjnc4uTKHY5fwPAlasb31gIO9XSaThDjO0Jak1x3RbNSwyx42E9JxjnYMpPrB0ayP50/mRJMYpTPyvBBfhStT7JDqXGCYJmmSFEAMXeCyDUMCj9ykQjgIw8CQBkoLer0O5miMV6rguA6W5YJWpEnGZDxgMuwThxPyaf+W1hrL9lAqQwqJkKIgNwJeuYpSivGwTwa4nleQIk2LcqlEudrA8Stowyr0D1PXiik+ngKf/WgfDKEhTwrHarp/hmC6MzaVWMIoenHylGnTc0GZpDhYAvV+AbVWFM5XnhZ0Q62L2KPKmYx69I6PydIYx/Ep1+p4pTKmWbheRdG3mDppFI6ZSqbisHDBtJSILENOgSFS6GJT75HAU0U1gYoDpOUWYBJJ0YOmcqTWTPrHXPve9zDdEktnT+FXZxCWC5ZHHg2LAgBZ7ApKBNr4fvcb8P0fH89/8OPbEtduEx5dor4codR32d3eYmZhEWlBrlJ0rDBME8d2uXfnNnmqkHlRIZGTEkwyDNPCdCzGUcrtG1foB/+YecsjnX0SV0jGk4QgTWjUyniuyfEgJOse8sxpk0uNWdKoxsPXv8u+MLn32rt84mcGlF94kZvfeo8oGNOolAkGhzQ9j1Zq0zVNqo0GZpYhwhE/93Mf56UP/xil5gmWV09xcu0J/t3nfpvf/Ve/wm/9yr/j/u0HjJI+KsuRloFjSy48eQnT9BBZTr83QBmC3iTm7/1X/0/m5s5SbpSwdcqwN+Lf/re/xsvf+Dabh/dozDbpdI6o1+oYUjIZjfErVbbXN/ju177B/t4hcRwgpYE5mnD7+lXeeutV/tyf+495+qVTfOijL3H9717Bbza4+ORTXHvtDdav32Bj4z4zCy2Oj3pkeY4Q4Ps+QRQVB0o6J46z4tdNj6PeEVkcsn/ksV+zeGnWoG7G+I6FVbbJTSASCKHJNRzdvMuk0yW4/R53763TnmtTqVe5f+9bHG0fgeVg5zG+CVbZJxESHJPOwQ5OGmE5DobIGN97i1QZ+LYgHed4nkkUQGTHbG+PWN8KWG1KPNfAKXlUFufJB0eoMGVmpUS/HxJNIgwXal4NGFJu+VRWF6HRRDTaaM9H6xgZxohyA9oziKGJMLdwDAOlNSpXlHybYa/HqbNnGfXHTPKUKz3B8a++wurGNheiCEE67efUyNxAlyQNecyZe3d4/amPomXGQyvjH3of5r/pfQSLryAlaCejMxlz/7XXOHJH0ChTOuXzkB6NusnC2TliLyI5OqYzGJAlEXOtWeY+/PPsX/kCIolxLKjXbYRj0XRN4iBi0Bn+wM/pD4fW2B/i2CZrJ+fY2O8z26zhSMG1jSM29w+o+Sc5e2aFSaqoVUsc7A3oj4ZUqnNoK0RFGb3umChX1ARMwpRu95jFmTYGgmeffYql7oTvvn4Nz68wCSNKngdKsd/vYkiTtt8gDMcYOmdvoDgcm9Rsk2efOsNeN+To4TWevHCaVmuW4XCMTgO0tpkEKUmUk2WKeNyj3ahwemWO7eMJWZqj8pxx1EGqgDy1ioJWwyK3NcPcYmbWJ3a6PDzs4g4i5hdXeff6Ld58+xq+7zI3u8il1VVccm4dHLF+/w62A16ziRx0sc0Ev6opWSWOQoHWNuSapumxcm6R5nwLr1Tm8LCDbRmUKyVM10N4ZVSeY1U84iQiSjS3bt/lMz/544xHA8Bmvx8hDIswDLFsmzTLidMIIRSjcEylYmMJh3xaWGoZJoYr6I5GZHlCmpkopUmUwpQJ3f1dKvUGnqgwnkyI4wglLCzTLOJJSUxNHvHwEKTlI0yDLM2oV5voLGE06uJ7ZeLJMUkaI02XKJkQhSZJmtMqG2zs7TO3fJJWq02ahDzYWGc4GDHod2i3Z6n5lWKvxLSZX1xgMh4x05xjMh4CAmHA/OIpDMdCx0Mmo5DVk6fpDxUff7rCyvIzvHJ1mzMnz/DUxRN0OwP2DydcvnCCds3j7oNDTp08ietI5P+Xvf+Msm29y3vB3/vOPFcOlWvXzvHkqCwhBChhhDBg0yS3TTduzMVu98X3Gtu4sd02XBy4xm64NsbQmCwZhCQUAEkn6+R90s65ctXKYeb5vv1hrr3FV42h7tutsf9jnHH22ad2Va21a641n/f/PL/H9knznDSDkl+mXm/QaleADEOnaGEghSCLUuJgSJYmmHlMngZUXIdOb0S17CLzmMWFA1TKDo88fIKN9T7/9b/9ESsL8xxdO4K2FN2tda5dusbC8jyGHPDG1hZaSi5u9GgvLdNutHDKDk6eEY4H4NwFgtydYrQAnWvyvCiZFhRbF0FhCVQqxRDFEgUpC1sexSYLqdA6R0obKSW5yhHaZDyegBgzHHSwbQfPK5GrnCAIZoKmyKaZhllskixmyHaBZZqUKjVK5Sqm7RBFEf29DWzDpFKu4lfrSNMuyGmWU2yUtJplwUDnSbE1U2pWBSAQKi3sibNMl4CCZIj+S51ksw0Voug/y4sOMbS6A8i4nbkrNmlQWP+KDBiq6EPTM7JiMJlw6+r1GaxHg+4i9E0c28L3Paq1Mq3FA1i2VYiyTKOlCYZdfE6hbys2tFE8N8KcCTSVoUSOmPWtCTSG7ZNlMdKwkRryXDHo7rJ39TIbV25iWha2yAg6PWxpk0UJ7dOPEuxtUF1rILIILANlWF8Dp2gN8rbIvTt3B1oL85jlGs16idFFh5IIuX7lGZI0xnFKGORICVmeEUzHBOGE1twiQTjF832mkxFxopF5Yc+XQlD2y6xfvsDoP/9Tjn38bxMt3A/SwnB8bqwPScYjCBLq2y/yY+/7CDd2co4dW+bbf+gniH/1f+HlV5/gl/7uj2PVzpD1Nmg0GizNeXg1g3Il5VB9lU+/uM7NvQGojG/51nfw7u/9QR48/RidScZWkJMInwc/8AG6n36K15/4LIZjweyxIBR+qcqP/tiPE1hV/t3P/CyGYTG/PM/6zVvs7/fodl5iaWWRd73tW3n1lRc5f+l5tvYvk6gMmRXH4Gma0V5YZNgbMOj3eOrJJ9BaYxoG9Uab3BC4hsX65jalSolf/dVfwTAMXnzhBZIsJxhPWTt0mJ1bmzz31aexfYsHHniQ6eQsYRRiGjZ5llLxPOIkKYiyoni9jdMYpUAIA5WnXO8pXKvM+0+1cOM+2jaoHVhgf3uAmXv4VZfh3ldxswxzwSGMUtZvbRNdvoXSEtOzkHGGbQqaDQ+3UsIru7hGjhNNyLMAr1RCWwK7G0I0QtsCw7NJc02Qwe4w4+p2TJRrGg2DlVMrLN57AgOHmy/tAQaTTkwe5lQbgvm6RiYj3Ao4TgoSZMVD+WWk40G9jU5vQZYjHA8Z7mMj8XwPJzNIlUEUh7iOTxRl5FmG1IJ+GFGaW2S124dpH+2UEPkE4ZWBGNIUQ+3z9tEVPul+gMQ00XLKJ3KT75v7P/G+W2+CM0A/fhQPzenHTvGuuSW0W2bvxiZ7W9dolQUVVyCyMblOMXRCo2LhWYrJ2c8joxGTyYSlxQqdQUCYwXAypVEvkd3OJH8d8w0RZ3Gu2djoE0UjDh1dYTjap1WWHDkwT6vsYLkm+/0hhrDZ39liPIgwKkt0Rind7giUwvId2n6Leq3E1evX2B1OcS2XervEa5ducuP6La5s7JNl0Gg1QWuCrR2MTHFwyWUwHlGrt8jDfVTS4diphyANWN/eBdNjZW2OuTmLvf3L7HdH2K6k7M0xHe4STMrkWnBgaQGn5GOb1/B9yXCgSLOcJC1oXJaKETrGFDlaFO3or4+HBMGIUqnKfm/IzuAKr5x9lUq5Urh5kj43OmP6QcbCyjJKZWxv9wiCkHqrRqlcoFRt0+LoaovpbpfIyjlyco1qyWNl5TCDTo9MpZRMpwiuC1BSYlg2pDF7+z22tvdo1GpIkZEoB5ULTFNQrToEQYJpQJII4lghtcDxHEbjKa7noxEoYZDrtDh3zjWObWFIgW3ZCCHJtUm9vYLUmjSNCacBaR4XfSdRTLniF+LYVJhJyFZnj7W1MySYuJ6P5ZSJemNSFZJFExzbRIqAfNJElKvEaYzI4Mjx+zh53wlee/Yprt+8Qau9jOWVqVRb1NsLJEgsx8V0XPZ397AdB6UEc4sLdHb2MCwPQ8DRpRbLi6c4srbEV554ip1uyOeefJ3v+Y6H+ci7DxPECdt7PdZ3hyzPz/HoPUfQec7y4hzStEkzk0SZ1NsNTAlapUipi4CpYSBMq7BspQkijShX6hwwLNb3hmBaeCWLOXsFQ+d41RGe51CyLaq+z9/9H/8H/m9/7x/z73/tj/iFf/Q3KUmQakKejtjdmtLd3adZMhiNQ04fmqM/yXDLJTzXIZmOMA2Lcq36jbh07843weRKkecK03YLMaYpyoxnVRlK5aiZtc2YnSaCKqxLSs/si0W+S8wsfEJaKJWghEGcKeLhAMMyC7udkGAUBdNCCKQpsG0Tr1TG8cvFIY9hFRh7nWE7krnlowidY9guhmkw+yZn1so7mMNCdBl28WsBKs+QQqCQiDwtblRmYqYw6okie3ZbbKmv/b6AIoOVC8TMDlnwOcTtyNwdm6HW+mvCTEp0lhIGI4LplDTPUEojpQEapsGUNInRQtCYB4RdiElRlE4rXcA+irycmtkoRfF51WxjJ4utola3N50SJQ0yrQk7O3T39+n3egz6PZy9Lov1JZRjMu7v09nYJ+qPUVGMSDJUEOB4Hk6rXXwPMwFaPEh5p2Lg7twdgJWlBQIlqLSOoSYBg1cyDi8fpNvvEo36WJYEyyEJYppzLZCSj338r/FLv/DzGJbCMw1sz+HAkUNEYUy/O2AaBjhIksEW25/7Debe+d2ceO8HKFmSC9euMXrxSXwbXn3xM/yNF36Dj/3I38fw3s3Bh49w5pFv49z5VwgnY4ajZwp777jKtL/HB7/tfr77h3+AjYsZN/77TzHxFCpXXLq6wWQ/Rp0Ao1FmX2vOndtm5fghNjpPU21WiOIYWxc51TiOGY2m/NN/8DMcu+dx4smINM/Y2dnGdR2SKMawTaaTkKtXrnP46HH+5o/9TX7p3/0y5WqdK1evEQUxAs3awRX2tjYJ4hjDMBBCUKs1qB04Ce4czvA6e7ubjMcThBQ4ro3OFblWxHHM03/xJeIopl6tMuj3EUoTTGIsyyHLshkQqDicKZV8wii8Q4+9Y5nWFokwGCgD6/ApDp9aopTv8vpXXsZIBXPLLQxHcvL+ZYgT1m/cYGdzxHgQYNk2uakhycmDnHpNUK451HyHasWj7PskQYjUFqYpMc0S3ajI6aIztCkIoohxLrlwK2Aj1RyuGpw4vczhxx5Ceg5qZw+yjHFfc/2tiCyEdhtcX2DXoV6zaB1fwliYh7kFpFdFqBhhW2jTLUi6UUi012PvxiZJkjKODWLTI01yHCk5fvwIvf0dDN9BpClhBvLd72LjTz/FYhAgzBlQWJugUqSv+ZbqdVr7AVsrZbRnk0qD/2gc4aH3/j2qZ38esbnJkQ+8jZ1SnSvXb7G+fgOdJBw+uEyzbFMyM8p+i8lgyGg6xvF8PN+jP9nGc21WVxrcvNnH92xkJgkk5KaBNu2v+zr9hoizrZ0BrXqD+fqUpjVEeuCVDAZBH69qsNhs0xtPubJxk9FwiE7ArQ1whWJ9I+D0yYN0Rh20K9nc7JLlU9oVlyCLsMcJ6ClJpji0ukw6Oz3QpkcShywdXKbcqtGyy5R9C9tYZTSc0NnfxbEEx48eZ9jrUytlZJM9NtZ38DwDU9fYurXOkYMnCdKcA/NtfN9CS5P5hXkubpwjz6Hf66J1Qrlcm/n7kyITkZlonTGNp0ynKaNpQrnqM54MaDfaeK5Hnobc3O2RxgEowa0bV5j2e2S5oNaeo1xukKUhc80SVpBjq5wLux3mlurMt9tUlk9y3/3H6O5sUfUdSq6D0oIsNzDCEKRBlibkacbG1gbvesejtOs1TMMkCMdUpUHJtojDhCyNGY0mWKag2WoUwfYsZzwe43g10rigjyVZyjTO8DwH13XRSpPpjFKliVKSJEuwJJTKZRAlwnGX+Xad3f0OjikxDQNDpWSTMf29t1D2HH6pjCEsHEsgpYO0EyzLYK7VpN/t8MjpRUaTFFBs93Y599KYRDicPHECzzTJzCoIk7lGi253E6E0liExbBPTNHFMF1spHrn3KFv72yw2G3z4/Y9z/uoWTz13lqXFJeTmJuvdiIu3ehxdbVCrVNnrhlR8SW+/wyTOqThgJjHJeIRdWqTSriGSMVrPrFqmMYMSmCg9E8lopFNGmzbZJEZlBSQgjFJyNNo0OHLkKFEUIbwym1t9Dhxf4Kf/p7/Lz/2zn+f5Vy7yHe89QblaYbFdp9Mf45d94jShUrKYaxrsdDN2hrtY5hKVRpuy5xJGd22Nd6cYjSyKnzWgCguMYUgQBYUQQOUaTY5tGEhZgISkkBiyECOFcBOF8BIaIRVCCSzTLjbrdpFTs2y3IBFKsC2bUrmG7XoFYhhmOkuAFsVrDALb8WY2wYIqWVATC0iFoCAS6ts9aTpH6CLrBbr4tTCK/JguSIZiJqq+9gQoRK5RKOTsm1CzHJ1QqsDR/+XU1e0NGnoGC8m4baPMtSAY9OjubdMfjEhnxduWKTFME9d1aTZb1OfmcTwfo/gEFCJIFT1rQhT2UlnAOIRmts3Li843LZCyEM1ZGjMdjxhNRgz29hiNA9K02BJmuSaKEobjEaZhEPZiGq02WZYxHk8pl8psXr9Mc2kFWfLBKyMNG7J0tiYtHmNBnbxra7w7xUynXRr1Gp3umPY9x0gnH+HiJ/4jZVdx39ElmgstOiODl196hSROGU8D/uSP/xjH88mygCNrc3S7I/rdAWmSUy57zDfnuXDuHFJD2N9g44u/ieht090c0L32ModWS0T7IaWaJhMmn/hP/w+e/mSLn/uPv8LRb30vZ25d4sVn/jueX6U/2Gc4mND0DD76gz/O7p7Jr//mp+mKHEMXtUCXz1/kl37+F/iLh/+c0/c/yp/92S1ee/pPkHUb3zeQpsGh5cP0eh16vQGWbWFZFmE45fKbz+F4PvGwyL8LIcmEwLJtqpUyb7z5Blma8sxzz1MqVdjZfg6lFKZpsLS0wvziPEmWYhkmIi8yYXEUMN2+TpJfZbS/V9z/KY1SWVGhgaZerZJEMZ3tLVKtsC2J53m8+MJLLKwuEAUh3U6vyAejsV0HgHvO3MPm5ia1Wo2dnR1Go1HhhnId9ntjgvJJ6vd8lCd/+1e4cNkgyRPW4gGHV5qMzt3CTFL6nT6ZkpieTR5nCCVRCZhasHRgnhMPPUwNhWumpNMR9bkVgizCGHcZd3vYjkUYxMTSxHRt5o4e5MbTl5gkCttzqJkx5ZqPzCLw6+S5prej2LgZ0e0pSpYkTxTNdgXDyShVfOzlJVheRXsuwnHRkynoHIVGKKDTZTqJSMwygRpgOB5ZWrwVhKMJQilazRqdvT1Wl1fZ3NvmzX2H1pHDnL54gaoGHU0QczX0OISTb2Ptwg2+7dpr/Jb3EKJpEY0nfM5z+b8bH+PnlvaoXP2PZJ/5c16oemRHV7FVjuFphErY3Rug66UiYtTrE8YJXqXJYDShNxjg+zaVkovlCVAmo/2Udnue8bRHtzP+uq/Tb4g4azUX8C2XKI7Y3Zly+tRpdKZYW1xgf5CxtbPPvYdqmGkD4WscabC0MEe3n3DwaJ1rN7cZjhLqns/aQoVUlhn3Y/xSCduUDPZ71G3FMB1zuFVhmAgqjuDitsI2DeIgwWLK2rETjIZTXMekPEkZTcbc2B5yaqWOCgWGnbHaaFKqC67tGNx7z/1oaTPfKJGkU5LYwSk51Couo+EEw5Az8pVJFEW4bqno5TEgTCbYjkUUSaQQDPo9NtZvYpmSpZVFlIoZjsYcWqlj2QaOabDXGaBLFpg+fqnMbmeHhWodYxKwsLrA5vUtSvUqlVobt73GvfedwTYT0iwjSBzibIrv+9geRVAcgRI5/f0d1lpVlhd94umEXLuUvRIIgzhLUSpDKxOd52jDRAqBNgSGMFB5QhAEuJ6LUpo4zZmGAa4JrmNiGC5xHDEZj7DdUgEIkAXBzTRMtDSp+jabqWYSZcwbMY4LB5eahHHAW+dfo9VexC1ZlJM2aZZRry+SRVMyrZlGI/b3OpT9MkGSIEwwFBh5RBxqHnn4FDrLMKrzTAZ9SpYD1RqlksdCq4xjCe49tEynu8/6ZgepTU4dO4LtOAgdsba2yOrSPI89eobnv/oST75wgT/70h6nTp9i2u9x+NQjZHaJ1197k8ceOIM2XOxaIV7j7g6eayNdZ0ZsK24gtUgRaUIaRUV2xnZJ04iNWzeZxDm2ZWGbJpVyGcu2GI0mOCWPJI6oVSzQGatLLX76f/zb/Mt/9Us0qj/CAyeXcBwDnU2olyTjiSLPBUmUsFT3WVuqsj1K2dzdYuHMCYJ+/xtx6d6db4IxDLOwNqqZjU8UmyApTQRgCIkwBKCKvJlpAfJOVkoIA2kW2TOkKMqspcQ03YKgOMtWmY6FaTt4fgnP9zFtCzmjPxY0wNkGbJblulPczExoyQLnrm/nn5S683FCGqCLDjJm4A492/7o29JKGtyhl9y27Akxo8ULBMaMF1LkxoTOZ19LFBu0v/ScaUFBUowj0jhkPOozGg2JooQgDAvCJBrLNLBMg1qjTWt+Cc8vIaVRkCtnJEdxu1OtOKoBaSFUOju2NQvbpgCVpmRJTBAEjIdDRqM+40GfOM7u9JOpXGN7PkgDTwqW1w4w/553U6o3UQqyJCqcnFoVgXjTxrBdTLeMsMroLCzE9e3HLoxiU3cXCHJ3ZpMpm1HBKSPs7nLm4UdILn+Aay/8DiqZMIkCNnsR5ZJFGAwRSDY3ruD5HmkoqVYsgpFFFkXFQYBw6Gxt4rsG5UqFSBuUqz7O9CalvM/a8TLf9v7HeO7JF2mdeQdrh+7l3/+rf0E32eQf/sTf5lt+5O+z01FIs8bu/g55FoCQdMcxf+cn/yFZXOfqtYuYdobnVlAqRwibwWTEH/7+H7D6wtOI1CJQW9iBje+1GfSHjEYTEAVl1nZNqtUqu9t7ZFlGrkYsH1zkO779o/zBb/0uBgXAaDAaY9gWSmjiOCKJIxzfRUqTJAwJwxjPr2H7Pq1anU6nU2RJZ8CeIIrQUoNSlGyHJCsozYcOrfE3fvxv88v/4VeQWcrF19/ERPHAapMboxxTOpTbFcIgIo5iMKDRaLC/v8/21hZxHBPHMeNxcZMvZ4Cn0LDo7EV0ulNU+14+c+mzaA0LewHvCD2Ozbtk3V2kIYt7PgzMhSamZTJ45SLVUpWVxTnmFg5S1xNEOiVWMVLEWBKchSW04TIdDxmMY7Q2oWSwcOwM/qs3mC8FxFnGXNlg7uQBxMEDYJfp777IrSsDhuMc2xaUKhrXESgtqbbbOJYGywXbgTSBXMF4AkaOrLbR3Q7peMS022MQZuAakCkUxYeWHZfpZIzrOPiOSziZUvHKWL7H+V6ZrWqZcsNBZhLV30EaAl55DseS/ODkCT6ztUSvcRxNjNJT/suW4L7qX+VvLDyD0XmSNb/Kvq3JlKDVnkfpnJtXb6BX2izMHaXbG1GtlBgOuuRKkqQZk/0Uyy+ztLLE+vouaZwyCnKE3yYff/107W+IODu0VCdNY0hbTKMpe4MROzs7HF5ZQJOTpClXd4YkeUadMsFkwsAIqFXLpFmfcDrFQHPx1gYrcZvFps9DD5xGGS47m1ssLK2QGBGlFGKpqXiaTqdHq97g6KED5NrEsQTd/R7tVoNpKFElB2lZSJ2ghGasTFr2PAcfeJgwiLl3ngKfb5kYpGhhF0FqnWNaLkfWVugPe9SqTbIsJcsSsixFa0Uch6i8uOj9cgVheoRxyl6nj1Jw5eotbNPEtBx0mtHwHa5u7iNNgVIhFcMlmIw4Nldj1B8iGlUMkePUm1RVQsUzsbKAZkUThRmDScqSL/FtQc2XGMRIy0NIi/X1TYZ7u9zzwBk2b22xvLRCloLlu2RphqGhUfWJM5iGBmkWMZraOJZJzbOxbRukT5zEWJZApoI0TSlZRQ8apIRhil+By9eu0m7NM9dqkuUFjTEJQlQW4zoml6+sMxnYPPjAGRyrzCtvnieOQ4Kgh2+7TJ0E1zGZjjpEwRDDqLHQanLuyjrHDra4cmGdh88cJULS9ixGScYggFp7gfX1WxyYb3DvoSo3hyb1Rpmrl65y+OQxqrU6L7/6OsdPnGQ5Sdjf3aDX2WZhYYGFBRepFZfPXePZ59/g/nvvwaqV0drifR/4KG9e3WUygQtXLtBqNThx7BDBcESQRhimyXiqsQyLxuIC2EWPElmCSmNUFqO1Qbe/w/bOFkGSI4XAcTya9TKe75AkOfW6i0QyHMaQ51gqQ3iCtaU6P/bDf5Wr17pcubRBFOacu7pOGHTwDMVgOOSRh89Q9lNkElLRBnKyz1ef3sH2v/7ejLvzzTlCiqLHy5BI00EpVWzMVIFm11JgmkYh2GYlZcIwZv1iBQ1NCAlmsZWyLQelitdHKSW25WC6Dn6pjm0XaPdZK1chTqRZ9H2JAkChKDq2CtS8LCyHeVr8iZmFTytdCEY1E1PM/i1ub7j0nQzZHYknKD7fbWE26wUTshCZsw9g9klRM1gJUAhPNFrlqCwmCqcMBmMmoz5xFJEmxbZOZxGmKamUK5TrDSrVBq7rY1o20vhLb5d/SXjqmRgq3JIKVDr7FjNynRKM+nT39hkPh4TTMWmmEKZJnmaF/dE0MaTAdErkTk61UqbVnqPensN13MJqLqyiSFtnM7Lm7G9AykK0WrNScFFsJosahWJzVzyvdzNnd6cYnUAuFZWSj6EV2WCPd73vcYK9N9jffJNJZ4wtJdKUSFMQAquHjnLrxnXqZYeyZ3Jwpc1mr0Oz0sbIIQ4DylkRtThw8DAnT97LS89/FUcECOATn/wMD7z9EeaaTf7sU5/C8lwCAUaW8Kn//O8Y9gdYloFjG+SyOAxVuebm9ZsouY7jahSCe+47xZU3zxPkEf3hCMuROH6JrfUdLMtEKM3+9haaHKWgVPYxhEGUxIxHYxzXw3MdsiTi4x/7OAcPHEFnOb5r4boOH/jO7+WTv/vbpHGMEAZzC3PESUaWCyBiZ6/Df/vN/xe+6xIlEablIA2IkgSkhWkqhNQcPHmcbDrlbe98J688/1WOrB7imS89QTwqBIUSmjDVvHJ5k1hK5peWuXr+6mwbp4jygO3tGK0V+/t7GKZFFEVYloXKC1iL1kUO7TOf/RR/8Ie/S5LGaENgSdgZZ3z53AbSmGdeGlQqFTzXpLe+Q7k2x+qJh5m8eBHHzClZBs7gJt7yHMgSjjWPbFVI+0PS0Yhq2aG33iGeTBgFmoYsM45jbFNTdsAWOY4lifd7qNRAuRYXX7+JMBW2r3G1oFzSzM2bJEmEZ7cw6z7peISTp4g8KA7iBlOkqVCtGkxyRCzpjEOCUh1paUydF12OlsRxLaZRhOt7zM21uXT5GqZfIlea1K/witNi7WN/Hf/eQ8if+gm07UE0BtvlPus1Hpx8gDdOv4Pe1Zg8giSb8BvGIh858ZMs5LusVkr0sxBlaGq1KlcuXSYYjGmcOUoUJQgJURgznMRoabC6Ns/5czeIszKLB2sk8TZawl4v5MF3PkSe7n/d1+k3RJxpETNXt3nhUoZnCUQc01hYYhQMOLJ2EMudUK3kvHHxOtOoiaE9tDVhrAImowENf4oQdb567jppMuboyiNEkymZDLm8vsNep8djj7yN/aub+DpmZa7G2x86yQsvv0E2HVCt1ilXy+zu9uh1Mg4ePcYbF29Sq1ZolyRb65eJdYlxKFn1HTp7e5w4uIrtGKQKTNsFVQS246woD62YisbqIrt7g8Ii6dg4rkcSx7M36cI/XKu2UNkIv1pmbmGR7s4WXsWj3VpmNOpw9eY+xqJNKi26+z3yXOOtmByvu7i1BlEUEk4Dzu8PeODhe/jWb30/Zp6Q52MuvHUBx7Fo1V1MoSg7xWmVZbpkecaXn/w851+9TNMv86hrYC20MW2bOEkZjKYYhkSKIrQfhmN8W5KaPnme4lUqxU2WkARRSKZyDAl5nmNbLp7rkcYRcRRiYBKFE5IoRaAxZycwQRiw29lHmiYL8y22OmMyTObnD+KXPBqbHRr1PlGcsTjXpDfoE0chruezduwwIk1peJL1jXUMBDv9EYN+h5PHT7K3F2NX5qjNH2ZluYxtSsa9fU6fbHDlc68xjpo8/PBpzr15kbMq4+R999Pb7WJYms4w5cK1a3zvxw6RDkY8/dXXuP/B+/je7/sYB1ZWsKUiTiW9zjZZPKBdqvD2972DE0dXmI77ZLlCpRl5VnRBmZ5BnqZYjkLHEToNyLOULE3YWN+h0+1jmRZpmhOHIa1mmyiOcF0L19bIXBKECaDI8pQki1FSIqSk2ayyvT+gP5ywsb3LKxc2iiJcAYZ0eeUTT1H2fBzbYGGujNSKKMzJvv586d35Jh3TMFBSIwGpFYYUaGkUVQ2WnGXDbveSicJqI01AY1k2CIFpOhiGgZQUFDbTwnZ9LNvFcor+r9sURaFv5x8UQsxIiaoINimtZl+r2JQJYaJ1gY4unIRZoSGkuIPmn8WiihyZkLM8mJht8ow7YkzMrInFyflsAzcjRd4ucBaAFLLoEqP4vlSeECcJ0/GQYDwiiiPiNCNPEzTGbNsFltDU2ku05pfxfA/D8kCls14z404m7U6xtJgxP6RRwFiylCQOCKdjgumUYBoShhHBdIo2LEzHRdseUqbkWYZhFzAFrRWObVGtV1hYPUClUkMa9tfElcpmmTGFFKDz2XbUcBBolM4hS2bo/rz4e5fF86lVBoZ5e6d3d+4OF996FS0Fx44s0/Q8PL/Kenef029/H94rEVvrV0jznCiNSSOFtG0GnQ7EEQuLK8wtLBMn8N0/9MO0l1bp7vdYWl7iqc98nq8+8xLn3rzApXMXOXxgjtWVeYTjE/sN7GMPY67cz94nX6A1t0i31yHPNL4HmWeSZTmeaZLIwpadZim+5yMMh8l4wNve8Xb+1v/5x/nCH32eT/z+7xJFMbZtkcYZeZLRnptjOBhh6xy/2mAwHJGlinE4olqrY5oWQlqEwZgDh49x5cotPvk7f8BDjx2lO4gZT3OunTuPngZgGTQbTYIwJApD8lzdOUTyfBeR5VQaFd713od4+ktPMIrH1Go1VJ7i1Sv8wi/+a37x53+RD3/oo9x3z8P8o//5p8lFhkZgCIntuggNfr2Kmyvm23N0d3aKXjPDgCwjn5FvFaCSZHaIJrBda0acLSzq/X4HWwgc18EvNxBuhd7Ni0wTwWs3RnzryQYqjdjbGGDbNvnWLbrpkKOPrzG61WVzfQNTxZRbFZx2E+E4oDOsahkZjEmmU2qtMubcAuX+hMHuDtefeZre+oiKoVAuqETw2pdepbexT5QbbN/sMg3zIgpkzTosXYlXE+RRgLN4DDLQhkAkBeEWI0NNJmBKkt0pk0HGXuTg1ObpB7sIw8a3Ler1GkGWUquWCCcTwjRlbqHNMAjo9/bBL7Pj+kz/8E/w/8hEL51EP3oa8elPQJRSK+3yrsF1nrs1RpfqiHyKLlV5g5xfsx7np6vfTjK4yEb/VU6991H6w4Tu7pDW6hypyBhOAiqtBfZ2NxhOE7p7E2zPQyDp7O2QGSnjQYTAJht2eOGzn2b1aOvrvk6/MeJMu6RY3HusOLk7f6HD3jikKqE3GmAYPseWy5w52OTstYRayada9Xnj9VuMkoC5+hxziy2ORIqFdgXsiJubl0izEoNBRK4N1jfXGfU7aNfg9OmHOHn6JIPtTabaYX8UYfs+tYpHuVTGzCc8eHqZize2GY0l3URh2hbRJGQuHHL84CKlkqA76BKnEuwKDhphKHb3h9y8cR3TSGi4BsvzVW5ci7FsGykNNILhYIg0CpLhZDqmN9gmiRIcyyBVOUaS0+/ugMoJsykvXVH4rgkIHNslTnM2w5h0c4+VVpVaELN4qIVJAlmGNnN6vQkrK22urq/znkfug0wRxQlpkoApGYz2+Y3f+iQ3Nvr84s/8BJZpY5kWWksMs0SWhti2icozNCm2qREuRLnFJMwwjOKGTKHJ8xh0RpYXJ0B5nuLYJRynRJblyEQRK0hVjl/ysUyD3mjE+sYW3c6Aes0paIbVMqY/zzgY8sZbb3L+ZhdD2DQrigPHltnuBZiWxfLSHFvrVyipEWF3Sm8QMR6FHFlu4DYW2YgMKn6Fpi/Iwi1a7gIHD6esi4RXvvoW3eEOo90upkrIphOUmseO95l0b9IdRqzvbPCOx97B9rWrvP7ayywfOIBf9bm+0Wevc5l6tYTpOmxdu4ZlV/jO73iAspESTkaEQYAwDJIkQ0qD5vw8xu2OqDAAnaJ1Rhon3Lh+nb39AUopcktimg5zi3P0R0NsqVA6wjckUsfs9QaMoxzLdAmiW4STgOF0wjAISbXCL3mcPn2M4STmrasb+NUqnlfHj4ut7bg/Zrc/Qugcx/EQ+d0Myd0pRpBiGDaGEAihkFIgpIltuzPRA5Ki/Ngwiq2VlAaW7eI4HtKyME0TKWelxzOLoUbOXvMosmFq1iMmZoXLM1sk5IjZTYSUs1Jm8sIGPBM+RTliVmx8DChslaroP9PF1y1ufoptm8rTmViz0YivkRlRd6yMQhcVAEgbrXLyLMKwbDSQphnxdEwwHjKdjIniiEwV+TWhNbkS5Aq0TlBKYFsW9VoNt1ojTWKSOMR0XGzLQAoTwxaIGc0xVzlxHJIlCVEQEEUT4jAkiWKSOCDLsuIvRhqkaQ7kGG6ZPE4QsthUGrIACQjTYPnAGu2FA7iuPxO8cmZNTYttoNaFdVIIwJzpRF3QMe9kBI1CyOYU1XVazkJ34mudaXfn7gC+ocmzBDUZYriC87f6OFabzB7itld456EVNve2uHX9OkLlSJ0hdcThBx9Aak1/nPDAQ4/wqc9+gfEoYToa8EM/+iOkdoMIl0kwJY1DSh68/zu+lSeeepFr19c5dW+fzd4lpClotJtcuXEFPdB4nsGhQ4c5fvwU5998i8GgTxCGeJ7D0uoS1cYCb73wAiePHyLDY+XAYyTqD+5kU3e2t7FMidYpp+8/w41Ll0mSHNOtEMVDpDCJwpA0HXL/g4+wfmuT+x94nPNnX6PfGzEYVfkX//5/4/rWmF/8+z+B6Qga9Sr33HOG5558Gi0FtmmRqQyhNXGSsDBf50d/+If50Me+l3/a+xm++OXPMRqNkIbBuD/kE7/7O3z8o3+Ff/uL/xbXq1BrNIiTgCAMQYBt20gh6fYH1CplLp47y33vfYQ8yrnw/JtMlabmlUlVSpTEGKaJX3IJx1MMaaOQlH2Pul9i0t3HNkDXGyTKJU4yhGOhTQfdWOH8fsAHTjWQecZke1RENdKQOEkpLZbphinBepfdwbMcPrDM0sEF1HiIbRskkx7allSXFikvrlC6chUjGTOZhlQcgU4k9Yqm3rapVE2SdEj1ge/D2/h9pByRaY1INJ4nwBS4rSXSZISYjDCOnkRYBkyjovQ6itHb+6itCRfevIbh1ehbHlc3h2RmiTyHWq2KaRi0qzU6nQ5aKSbBlGqjgbRNTMNg1BmzjqQfd2lZIK7vILbWEaZEGwqppnw8fZ7f3vw410+00EGENl3qyyU+OY5450N/jaOvPcFo7xrlcpNnX3iW/taIh992BNd32ev1Edi0FpeZJNtUGrC73cNrVWiVNUEYgYJ6w2V+vkyl7tOY//oBbt8gcZai8ozheEQWZSzNt5iEY+493mC/08PzJN3uHgsLbQ7NW5QrJldubRFi059EnDi9xJeefY25uSaTUJNF0OlMSdOE5XaDSLkstisszbUYTwdcfOUFtm9c5cJmyMmjDRrpEBPYHSVk2QQpIZzsocMxuVchmeSkxpBWo876+h4qrtKulaiULJYWlkljTansEiUBV69c5asvvEzVlQyrLnu3boFIydMctCDNMyzLJIpikjhD+nDjykUQxXZEIjCxiEONtnTRRWYI8jznUKvB6pFDTMKMsq1pt5osVCzmllp88c9fwLW7vOK/yOnTa2TRhIW5NS5c0tTLLjpN6Q4iXrl4gflmnfPr13j0kYf44e88wvGDi0ggyjW5ykg1mFZBIbNm3UGWa5BMJK5rE2cxUrrYno9f8Um2N1DaIIoS4jil4jkYJpimQCuBVil5LnHt4gT95s11djs9ojBECJswVFRKBgtzLfa6fV565RauY2IJjWGbCEtimwarZZNnXn6BeHqQ8WSA06iwNZyQa8Vis0GcKsLM4rEjBzm0UGNrf4yyXM5fGnB0LkPicPjeQ9wY+Wyff52nXjnLA8dOkEZjbt0ShLHE9m0OtEtk8YTL230Wj5xA4HB9Y4RXLZGFIZW6j5lnfORDH+TAsYPkvVtkSYBhWvjVGnEwoVzy8EtlTMPA9VwwDLIwwDAUYRCyubnDdBxiuy6O6yKlJotDtm5eZevWLXxfUq74OKaJZZlkeEwTE98XbGxcYTyeoAXEiSLPFLbjYhuauZpHrdkmDqekMmJubpGllQWyKOTKtet09rdJ05z5RvMbcenenW+CsaSJaZtU6m28chUpCyoj0iwIgwggL8AVM8LibaLh7ZzYbUuhvkMyNJCGhdZqRjIsNr36NnlQFLRGfTvJJUSxsdLMNkvF5xXMtl8qm1nzZn1lKi1Q97MeM3Q6o0SagAFG8XlVPrNGznD/ty2TGIW9UWcJWmWoNCaOJiSzbMZkOiXNchSQpUlBO8vUHTtisTWj2HgJRZpL9rsDdK+P0EVxtJACOaNcyhkKP4ljQBcn6TPyYrE1nCH7pYlhFvZ4oRWGbSMMQaY0mgSZQ7lWozG/RKu1iO25X6M5ou4UXhdbRo0WEikLNL/W+ayr7i8LuAKConVWCNbZplELwLAKMIvObwfj7s7dQQ/7RGHA1WEH8/Rprr9+lcn6RZZWq7T9BW5tn8MyLebqbXQ8pNEwue+xd/HWlX0uXbzAkRNHyIXgox/9Li5cvMFTTzzJv/qX/4pyqUq9WcNzLAwz54f/1o9x4a0rXDx3lVTH/N5v/x7NZpve/j7rmyla5ximpFSu8F0f/25SUeLEI+/kyU99luvX38DxTPIwpL7q41cqPPXl53HrJ/ijP3wWZI4GXMel1qzT3eugs5xGq8293/c2/uwLn6cU5+zsDgHIsqwoc841QuTsbqxz4fybGLZkc7PD9bOvsbXdIQymNFo17v97P8YaC7z59EsknkGqc2QqyfMcS0o++P0fo7S0zL/5T7+BMbeIZbvkIkegsYTmU5/8BC9/9Wk8t8yVS2cxLAPPrpEqSJOIIAhmZ005H/7oBxGW5EPf9XH+/o//JGEcI9FE4RTHc4tNm2fz0R/4Xj79O58gT1IsIZFpzMGDR3n4uz+MMiSyssyXvvQirz73BYRUJPGUGzeu0rNsDs073L92gDS8QXevi2G3cX2B0mC4Lp3emO5Esb59iXt29lldq2E2qrhnjkO/g1FrIW+u05iroYIybCY8/FCNfJJgGZrG2hy25xOHiu7FFzF1QKltMBml5KlAWEUOOR4MqZVk0clo25CmMIoQ4wm5X2V0/U2m0qKX2uyOY3YDm04UM1E2uQEIwXAwYb7cQEgLw4SVtQNMplMsw2R55QDT4Xl6mcW6zjg6ypGmRCfjwvUuC4DTMe9FPn7xBf63e74XtSRIlMl+L2M3kfzoaIF3zL2X6sU/5PFgQnd3F9sQtFptWu0G3U6HS+feolxroSyHTKWMhgFLDz7ExdfPYhsupYrLoWOr1KtVjh+cpz/43ylzptUEwxWUlcRrLDGahhxaFoR6jOMbuCWTPCqRpC5eyWR3b8CNjQHlxjLziw7X13c5dvwQZw7Os7m9z2vnb7F68BDROMWRgqqnWSgnvLHeodcdY6cRp8o+awsOvf032NuNmFOHmE4CpFhAZwNcK+fE4aMESUoii94YwynjRRP6+5s0/FVMew7bMojjAOVZszfYhO3ddW6lEVI6BFGCZ2ruPVJCSYfRGHQZptOCzLh+4wq5Fgz6fbSW+F6ZXKeUPYPlZoNhojBVyjDMkZbFdmcfYdg8evowySTl3PnLHEunPPrAAXb7IS+9eYn9UcK3vvc4KEHdtQjzHCtTuL7PS1fOkwQhVsVlzlvmoQeOYOQZmTQIggjTckmzlNF4QL3ZBq3wfRvyHNu2yHSOEBphOGS5hlzhWiZBmLK3P8Ar1Wg3K0gVYCiNMCQlzydPDKTlcOvWLXzHZWd7hyAOcCwTzxAsLM5RKnk0c0VzcZGyV+XGzvOcOHaSi5evcPnmLqlpsbaySK83xLFNwmBCmlvYrqA1v8iP/vAP0dvfwzUysumUd77vMb783HX2e7eo+WUcv43nurzjVI32/Id5+tXXSdOI1fkWsb/MUmMBIw2Y7l+gNb9CGr/FaNhnkFssLTdp+YK81MLOM46dPMHS0cNk/S2mkzEoqC2vUjItwkEHrTWu481sRBHkkKYxo2HAaDgkDGPccgkZR3S2rrN98xbNto9GU6vblMoenuuSZgqz0sbQDuNOj/3OPmEQkmUZSpuYtkU6DfE9h+X5Oi+9HHBo9RCGCNnrBxxYaHDP8VXKrskDJw4zzVKiYEK17H4jLt27800wCweP4ZZqGEKg8hSdJeRphEZi2A6G6XBHiEEhxoqQ1p1/bvd+CVEg39EKnacwg4oIqe8IL4FECe6IPV2UnN3pJdO3t1uIQnikCUijEAxKIaUsNlimObMNFts4oTJUloIshJzWRTmzFiZIG6WSmXBR6LwQP5P+HqPxkDSOibOcXBX0R5Xn6DybURlnOTVp3CnpnnHsC0KlFLMs10zwaUGW5yiymZVSYlomWZqitJ7h72fofaUxpMSQBnkWYwLCtJDCQeU5huMipUHdd2jMLVFuzmE7LpLi6whm1kxhFkATMRNmwiw2oKivZfc0M/EKoIqC6tvgFKW43WtX5P8k5Nks5ycLYXx37g4w3zCIqw0Cw+XWKKZ07CDlumDwwmcYpAPiYIxSEWQZJc9gmlnsfuklNjZ3OLy2QDDosLO5zVe+8DTbvR6txTnmlxbwLRuNIgqnvOO9b+fosVN88YvPUp+bo1YroYTm+37wb/Gv//nPI5I+ruvjWzYqy+gNJgwP38M7Dh3n1v/6m/i2pFL10Tlsr1/HdiTXb2zwy//6n6EV+J6L4znkKueDH/wgzz79VXSa8uoLL3Hxyg4729uUHPB9jzTKyVQGQnL1ygWUgPGoR6VaIY6nqFzxT//JP8Y0LTKdYrl13uUv8vxTHWS1ioomZHmGaVk4jkt7oc1Caxk7lzzwyAOM13f5yufcwlWTJViug2Xk/N3/69/hlefOsnHjFmE8QQuT5ZXD3Lh2EUGOaZqYwuYTv/dH/MAP/QBPffFLdDtd5pYXSKYh48mUb//QB/nUn/wJcRDjS5dv/+hHeOnpZ9FJzOpSm3/5S/+B+upBRoMp//wf/AyvPPtZtNDkSU6WZSRJRmqkPHdhFzW2aOgcYZiMpzFWtYpWMXmWkUwSYhVTn2+wvdXl5Lvvxzr6HpwVl8Ern8F3TKKSh2tZGO9+N/6rr6KiAaUHlknWb2AgyNIYoSVmfo2FeYf93ZDpWFAyBY2mjdewMbKAJJJ4KocsgzxD2S5iMiYe5ozNRSprc8TdK1zvjdkNNZ1pgnAdHMNimhQ53WkYUWlbWBJ0krA0P8/W1iYbN65Tch3SwYh94RBNB/grK3Dr5gwoIhCOxrJD/nr3i3zircforNVp1GwGYYbXqjFNE56beHzYcelu3sI0JCfPrLK8vICQGr9aQpo2t67v4dU9LMOk2qzw2hMvoI2cMIupNMpIaXL88AE8MyX+36vnzLAzLOmwsLpIhqIy1owqy/RGE5aWi0zDNMjojKeIyGQwyXng+DJmpUIYS4IwJQwDtjtdIm1g+i06/RGrc2XCURfylJubA04sr7LuKCQx1zc2mQZTqnUThWJ/5xq1xiGCeJd+ZxcwuNUZUvYkc+0WZ89eZJxlHF1d5P5ja0hbcvXaZZaWj3Lk6BppnmCRkEy7zNdNVhePsdeZkgqbGxtb7PemfOCxQ0jT5OVLPWQaMkhDgiAizwuyT7lcRegc33LpT1JIdjiy3CDLwFY5UZJxcm2BlcU2vX7E5dfPEZKytnyIG9v7YJssrqzw3vc8RLNRxlAGtZrLpUs7PHrfIXZ3dxmOAw4uLrDTHSF9hcwShO0xHEekeXECHU4DNOD4ZcJxQSDTaISEdJowHadUyjG+46GSmCxLGY+mSMPB830arXlMkRIPuiRZQpJpprEiySKyLENmMVk2JY0jHNNjvz+h1a9TrlQJQ4ulpTbPv/A6Kkk4d+EySI2DxLFs5paPUkvG2I5DpdxiSUvWr59jEkVcPP8mSTDlyq1tvFzx3YfXsKIu880G999zkv5wyuWNkGSoOX7iIPeeOUQ43OPW9ascOVqipU1q7QpZ6zRpCg++7RGyBKQWYNlYTola1WNlcY764gJCaNJ4jOdXsCoNhOuj45BgPMX2XdI0JZxOMU2JYZkMRyPGoylZHhOFY86++AqVukMQjJmMMw4dX2Q6DqlWy2hykD6OX0ErgzhJKJV8oigkVzmTSUiUaaq1Mp5rs7RQ5803L7K12+HYiRZve+Q+rq93ue/MSVQ+5qsvnOfgoQPUhI/ZLKG4e7N1d4rxSxXSZMo0mBBNx0RRxKwxDMfx8T0X0zQRUuI4PqbjMVMWXwNbSONrdsHbdL8ZzOM2Xn+2zplVaOk7/x9uAzootkkzmqK+QwzUCFKELmiNX9syGSCtO+JDmw6y6ANA6bwQesIGlSDUrBZghtuPxkP63T3G4xFZnhY5KwroiVKFhVNQ5NGK70MgZ1s6lWXFxk+rYiOmCztols16HoUsHoMyKLScJoviQtNJQary4jVFzMiWqIIWaTmzDqKMUrlOa/kAtXob6ThIKZDcFlJ5kcczCqu7pqBsal3UHhR92XEhtDTFx+liY1b0sAmK8uxis1ZUDXzN6lg87q/93RaC+xvyVn93vgnmY99+P69eHnD22oA8icEStE7dT6Nap//cp/DmQsbDfXrdfYZhyCSMUfmYVkkw5yacPH6Q185fZOvWJrWFeZrVCqNuj/WNbWzPpN6u87bH38Gv/tJ/pLWwyIlTp/j0H3+KMBrya7/8S4yHO7iOZLnZZjCdQq556itf5G++52P8l5/7z3jGkHa7wv3veByVGFy88BbN9lGmwTmYBMRJRE6GbZUIpwmvnz1LqeTR7YSE4YjR9Tdo1Mo88vZ3cOXCOXrDEMuG0X4PaRiYhuTixQsY0iocA4aJKQRJEmNYNuNhyC/+9M+weOg47/uOD/K5P/kUWoWU/BppmjLs9vnd//LfKLk2bnOBrWvrpEmEU/HwnTIV38eyNCeOneK3/tNvUPFNqvPH0UnO3rUbOFKiTUG1UgGtieOU3/+DT7J04ADlRo0oiVlZXmZ08RKf++yfovKi2+03fvU/4ZdKfOd3fpR8NGU86mNZNjeub3H1jTf57Kf/AKWLTNxkNCkO0kRRK7I9CtmsWAiRk8eaMA9xSy6mr/AMg/mVMkkQ87b3vZPw+mtcfepZDqy9h+6TV1l6+B7y9ZvYp+8nf+lp7MMnmCrJ6sI82nXw3v4e+s98mXJ9kXRhleTJPdJxiM40li8wpCJOMuZKdUzpkAcTGI/Rk3HRk1kqkQ9Dxq/v4i4eJrV8epnFSJXZD1Nwq6gopNJoMh2N8B2X+aVlVBYTxjErK4solRAHI2zTwJQWbgPUeJuJTrF2J1gPPYR47XXIU0RuoMsOJ/Vb/JN7d/j9JOa8cQLbyMmnAULAEbPHu05rRlGTk9/xPdRHr7O7cZNmvUo0ifCqZUbXptQWPcaDEWsLC4zCgCSxMExFreGxtroGlXmyYB3bMr7u6/Qb8ortmyU8x6Hb61EpVxlNMxKlOHlshY3NbUpuDa33cDzNzkbAwUNLbGz1GW9eo1pvU2vWaZck5Amm1hilOjiaa7euAzmu63K4NY8yLAyt2OkZTCLY249ItyIkKZVyjZ2RIpx0irCm71CtThGWxowalGXKsXsfYL5ZodnQrG++idQSlZaZ9jq0Kh4ZIRJNvVTHtHwmwT5ZHrHUahAEIS+/dZlqucaNaxvsd/uMpiFZnjGZjPH9CnmuaFQc2tUahpyQa4NL3RTPtWiVyhyZ92l6YOqAwXBEdc4j7sNXXjuPsgXt1hwnGgZnTh5iY3OdYWTh+AvgSpI05tlXn0cLg6rvcWu7j0OGknqGpC9IPrZtkI8EdqlCMB6h8qwoN0zT4uZECBqtOrVahTyZoKRLqVJlv9cnCCLm5m1MKZGuj1Q5Wa9LnMbsdUZMpynlikNORNs3MEWBmY4tF2bgkcW5JsF4TLtdZXmpxdm3Ntnr95koeNujJ3n+7GW8qseoO+LYoQWG05RkskTNs5iMA7rDKY3Fg9Qsi2deOk9jrkXaHfDK61eotuq89NVnec/b38GJQ0skwQR7qUo8GNKaa6Klxq02GExSSlUXM8oxLQdQzNdsMiWJopjawnxxY5gnGE65AB64FXSWEgy6dPZ3aLSajDONUjmObRB0p4RhRJbnrN+8wc3r1xkHMc2WhyksDh9pM+wPsWyPUsljMBwxjWMc12MyGZHnOaZlYFoWudJIKalWipu2LMt58ulnaTXm+YHv/yA7uwNeu7DB8cMLDPsdytUSy4tNPLcgPh463CYYf/29GXfnm3P2t64ThzFpmhW5LnQhevKUMMuIghEAUhrYtk2l2sArV2fdZMaMtgi3M2RqVmIsYLapmsFE9AzccZuyeAdpXwgOpIEwjGKzpFXRa3Zbu81IjpAjKFD9RTZNAwZapUVpNbPS5jy/g84Xwi6s8zpn3N1nOp0STgOyPC/sgpkizRJM2yXLcpQWmKZNloZf21AZJgqBVjOxJs2isFoUpdyGNAtRp/WMbSKLcL6UxWYtS4rcltIFxVYDUhR9h7PnzhAaz7GZO3CS9uKBO0XUzDaDxRP6l/N8ZpGtE4UFVc22m1IrMAphWWiwWeZOMMvtzeiNFNZKDHNGb9QUKfsZ73JG1SwEYfr/+R/Eu/P/F5NOd6kbFr5jU63UiGb9g86he2kol0t/+hvk4wF+2cWYhniOQbtk8OCpOY4fPcT5a1M2dnaZW1kgzeHiuctoIYnimB/8kR8gjhKe/PKzXLxwiezCOcq1BpPJECkz9javc2ypytrqAkGsCYIhC4dXKVcafOJf/yxJb49mVeAYgklvgG26fOSvfCvTqIBdPPHEU+RKkWc5k8kUKTVJEuC6Do89/jCf+vSnKdfKBNMRN65c4tS9D1Gdn6fbHfHUp/4I05TovHgpyvIURc7S8hrT6ZS93V1WVxdZXFrjjVdfY9Tf5dbmLU4/eB9Xz72BSjKSJMG2Lf7OT/0dHrz/Ac6fu8gv/sK/wTQlKkvpTycMej2Ehn/ys/+Mj3z8e/jjT3yC7/nxn8RNFf/yH/9DwixGafiu7/44v/Pbv8Pjj7+dCxcuUPJdtqKE6XiErYutuRCz+hFRwNrCMOSPP/Un5FGM1jD62z+JYZR46603SVWKZ5couT6T0WRWkF3kTZNM04007ZKF1ilJknP9Rp/5BY/24XkefNd9dC9ewgk3yaWmds+7yM9/mvDFF1H3/R9heQWu3mTQ61G/8hZOq04Y9kg2buCtpdj1BuFwhL9WYe6Rb+HSFz9DnmlcQ9CoWliOxXA4ompLTNsj1xLTkKANlOWS7I4YDmPmj1V58asvc31nxM5QMwoVlueTaYEEWo0mvV4fwzBptqrcunIVKST1uTb7+7tEcUHDPfToY1zo7HF05QChUWf1Y38N4/I/hvE+5ApRKWOvNPhrf/V+GtsDfvILPRKjipHF5HHMsnmDihFy4fyYxx56F+HkHMloiGkqgvGInBTDBCF90mSAigWPPnKarz59Ftepcd+Ze1k8sEgqSgwHI4w8+7qv02+IOFs7dIzdnU0y5TIYa/oTxfWdDt1RxOkjdchi0rzKnGcwnezRD6ak2qDVruO7Dp1un7PrHRbaFRqew97WBtWKYL7eIhYpaTrm1uYuaqNHmEo6vQmjyQTDtCiVfdJcUXbLLC5U6LpjcnyW5haJog0MHPqDPmGkGaxfZMmaQ9QXscwG3cGQ9TfO4UiTasPj2uVLCIo32+s3rhGFKbZT9H/t7+4hkjpvnLvKrb0xo/EEleVMopyK7zEJpri2i2/brCw0GaUZnm1Qdi3e9sj9CJUzHfToT2Ju7vQ5c2qZ1dZBRrHk7MV1pnGO79gsLc4ThgqpNI32EpdvXuD+001ylRPFE2o2xEGfBd/k/e98HGE4xElGFBUvsKkWCNtAYzCNAgwUhtRFK7wSYPlYhoVhGmSxwX6vg+HaDIYTcgWQY1oW0vUZdHoMJynDIKHdbHL4QJkkCZn2t1GOj50qXNejWpvnzD1nGPQHREGMaZhY0qLZanHqhEtzd5ezl25w9uIOg0mEbxn4JZcvP/EU3/c9H6ZZdzF0zltXbqKjBMezsC2D8VSzE+e4pTobO9s8sLDIBz/4bTgG7G1tsDA/T5JptHSZ7t2gn3pUKjUOr60hsimhrRlGCiE8wlRh5jHtpZWi/0kptE5nnWYGUb9LMB7S72wRRBPMocQ0DVzLRiqFa2hCEva2tnnj7Fn8SpV6q8LNjT1WVxeJohjLlKgoZtQfk2qLINCMJns06mVq9Xk2N27huw4HlhvUGm1GgzEXrqwTRCmjUKDklGPSYmWxRRRuQJZz34P3c/blszRbDabjEddv3KI/2Me/i167O7OZjEO0UoWwkVZhxUWghEDkGVpK5KznK8kVw9GIOC1e23y/imkD6IJYK41ZKXXxA3YbZF/0jhX7OKH0ncJlgb7TW6bSpBAkAlQWk6bFDYRlFbkJ7qD1iyyaFoXt8GuwihmmX2ggnv2eIktCJuMBw0GfaBKg0CidFWJKCRQCwyw6G9EaQ5joPMRAIqSF0gkSRZZmM0FmIA0TTV5sq3QhhEzTJAqmM8qkRiKKovksKVD5ukDgay2RhkShcWybZmueWquN4xQdcAZFzYhEFHbOmaUKwytELPkMRqkLmuUMDiK1muX95KxDTRVgD8OAvLCf3i4VF0KAYRZWRinv/LnCHllYPjUzAY280zF3d+5O4+F38cL/+iVubm8yd2iFOMtJxwa2OWB+dYlHv+//wrUv/hfy3pucOdbg0fd9B3tvvcj9J9pMg4wLV9eZJPCRD36Iv/jClwmCbSq1Bq4hePaJJ7l2fZMsT3HsAk/f3d/CNkwMQzJX9inplL1rNzhy72k8Z4kf/Yn/gV5f8Xv/z1+hJiaY2iTVBhcvXaNVL1GtedTmDnP+9ddoN8psxQWZtLkwD1nKyVP38PqrZ3ml8ypSKywhiHPo7O6ws7WD61cIY4UyNME0wDBM0jRDCEG17KLDkCwMMIH9/Q5xDLbjEiUj3nrleZZWVzlw+BA3blwnUxl5qPjzL/45f/HFJ3npxRfodTtIIycPKQ6DpKRZb6G0yTPPvcSVaxv80s/9LEJbjIIJCgW54Ld+87cQUvPMM08hhWR3ewvDNLBNE4ni4LFDPP72d/MXf/bnbG7cmtFtBSrL0dLAdW2eefZJhBYIQ9IoNwmSiFwXh7+madzGBuF6Lmmuscs+hlRMxgGTMIUdkHqfh95bYrg34Nh7HmGwF1B55w8hJ28QPP8S+5/9PPVHH4dBj9rjb2PjTz/PsR/8AbpPPoHXWGLz+dcxySgvN9j688+BW6LqWsRGynCcM0Bh6qyghisoezMSbZgXr2F5hur3WTh6GO/oYcQrlxiOtpjEDpZTwnZdRsGUQb9Pu9lCGJLNzS2kaeOVymxv79BYuBe/WuNIqcbFi1d55fmXqNcbPB8PeGz7Js4/ucxi0kFYEnKN3t9HDELMP/kTFrom5cEj7FiQJjlLq4oj+XlUGNC7eYPtZz7J4qJFrd5mY3eHIIjwXItGq8ygO6VcL7F5fZ/7HjjEiSNtbl4f0Kp4lNyI/RsvQxBg+V+/0+kbIs7K1UX2d3fp9HqEsWBu+TjWwGJr+xYijSk5FtNJl+ZinbLr4ZRWOHHQ4y++8hTjwQ2ssslCo8TWfpdhdYGGZ1Avu1TrOZvbit1OSqKHCMshCot288MrbbIsxnRNRl1FpWoynewihYtrKCb9TU4fdBiEMGrMs3lhl2XXpj9KsDtDXnzzKv3RkJVmjYvnz+O7gigICCdT1rd2aNZ8LEdg1pt8/onXWJqrMZoEXLu1x15/zGP3n8EUBuudPnu7u5w5vEZnHOJVqygUbReWFmqkFD7b1y/d5NTBJfb2x9imTTQOeGl3j63BBM8t8djJg6RZxt7Wda5eXuTEwRpe2aFcMmn6Hv3RgKu7t3DcBp7IaB9oYNsWeZYTxwm2bWDYNv1RSBRHlAyTPFdYUqBm1LUojkgygzzV3LixwWjQwbZMJsGQ6SjCr1WJkoit3Q0GvSnBeEysYBwkoAOOPLpE2Z8nnFTpTVKM3W0Wlg/SblTwfJfRoEucTkkzcDwL13FZXDQ5++ILNBtVtvd7LLSadLY3OHPPKbI4JZ4kCCUZBDGmNjl08iC7G9uEvk9v8wZrDzyMawve9/H3I3DY399j8+YF3v/ud9GYX+LJZ15kkiXE6x1KC4eoVio4ZkY4jbFkSs2csNsNuNkPOHboIMs1+042XiBnJ+Qp4842G1cucuH8FQ6cOMjyXAvLMMiUZjIJuHHtCnEccvXKVSoVjzSP2Fof8Pjj95MEAZVaiyQOSZKETn/A/MpBOsMOXqnGziCnVJO4tst4GjG/0KLk+8TjKXmWUSuVqB3x2O0HfOWZl1mYbzEaTplf1Dz/pa9w/P4jjAYDdidjSp7FdDoluNtbdHduj9CFqNEF6EOrfNYnZqAyhcFtJLvCsExM00TrnCQOi+6zQGBaNq7jo1SOYbsUlrnbmzGNyopMU7FNo9jkKEWe50hDFNYblaHSiCguesSytLBTe45DqVLDdv3ZRi3+WgJO2gjyGXgommWkTBAGKkuYjvt09zZJU006y5OlSbEdLGJtMwGUFzZLIXKEKJCFWgrymQBSQgAJekaDlBhkSqG0QiERucKQYJgOhmWQZ9msV6zI6JqGWeTNEEjTwLVM6q0WcwtLlGrNr/WvqbSApwhRIPClhTA8tGnPKJcSoUUh0oQAUWwYNeIOSKUAfxQ1BJAjVI5mZvPUchZqB6FmIBEtCjGn86Js+3bxtr4tdO+C9O/O1+aVZ0dE1eOsNRpEQmMLk5LnsdhuYWCgmkvc/91/h/Grf8iav4Nhlmk3lrh2eY9zV/vc2BuSmhaf/cxn6HcG3HPfPXQ7fXS5zM7mLZoVh5On78WvN3n56eeoGmDaAsM1IQ2xbBvfNumuX+Xbvv/76Ox1cMwKNTlloZpzdapJxxNqy6t8/4/8DX77v/4mcfwWri0YjWN8p9iE53GEZQjOvX6Oa1dvsnZglVKlwjve825e/OqLTGaU1iRNqFWaJGiq1Qaj8QilcnzfR1oOYRphG5p6rYwSkkF3nzBJKHkOGCmTQZfOziYCSdX3CacRTz/5BN/1vT/MT/2Df8C/+Ef/GFPEpEqTpRmmazENAl5+5WVc1yZJY6JRjDCKahNDFYA4lWdUSzVG4wlZVpBcXdcljiImQUiY57zw/ItEUYIhTTQa13GKDVo8JU4iLMsu0P6pJoxDwiggTGI81+PxRx/jtdfPkkwiGq0ai60a9QNVTt5/lMuf+STbO5ruJEK6Dn/6qScpdcc059dZeddjrP/xH3Hse++juraGNCX59WuoYQez3iYNNNf+2+8xd+YevEabyjhk/41LSN9if3eM1hOS6hLTYBPDFZiuQRBmVGIoVyykZSP9agEEsX2EgjhKcRfKxNMRtzZ6dBOT3HCpNRrs7e0htCSKM7Z29zFNk1rTp9PZZ2GuSTwZE46nLC0uc/3SRdIsJUkyTh0/yj3NIcI7zfpTbyDfEsxnauaAkGgxhl//J9wbOPxI46f45/d/CDvv8/DGSxyfP4cSEkXG/s11yuVV8qxLFido08Uve7Ramp1bEY2DTbqjLaLRhAOrddQkJOptIxYaKGFSbswRp5Ov+zr9hoizy5cv0B9P2elHHFg5yKn7HufMwy5f/PJzPH/2aQ62Y6Sasj1xMa0pC0nG5as9Op0J0jExlY9SNot1iTCnHFotsbM/ZmM/Jk0kpVqTmtNkvNtndXmJJAqpVx32eyk7+xMaboM8jig31jjcKPHmhctUKw4bwwrjLCNROQcOtRhOp2gjY+/aLo4tWWytstiy2OlO2B+MqFUXWTvyOI9+8ACmzNnaWGezm3G6L4iSBGEKPnT4OI7vcM+pY+xs77K+2eHy9ZtsbXdpL8xRKVfZGoVglEntEv3+mNdudElw2B0EbHf3qZfLXD+7Rag1Soc0ai1eeivh6JFV7j1znCyf0pt4tLVDxZNYJZfRVo9TK6tc2RiztzXh1H2rbO1OCYOYPEuYm2sSJZreIKDkG5hSoJQknwXwg3BKlkOSKqIk5+rlG0iZ4loOnudimCa2aTIaTMjinN5wWNzECYVpSsrlOkoXJ9HlShOzYlOptxHSxnaK7EQSBCTxmNE4Rwufne113nj9MoYr0OmIum9j25IDq3McPLDCgdVlpGsSdSNilWA3l7i83mV+YRkrC2jMzVOv2Ph+iaYlaLQtgr7gzH1vwy97bG7ewLcyqpUy0pE8+MBJ2g2f/v4OWsWkuSxKX4MBVdNjYXW5uNGRCUIXXUhaC7pX32LjwlskeYxWEcP+hDTPsE1Bb9DnxrVrDAc9avUKJ08fnlm9JNNxynyzyVCaBNMx4XTKxs1b3HvqJO2Kx3T+AMcPrXL51ja59MidCu1GYUlUesRwGhNEKaaVcu+pA4hLN7jcjcmiKQ+cXqU/2EVLjyjIadRrHEgLS5VnW7zw0oVvxKV7d74JRgqD3JhFkWb5BKSBkEZBbRUGwihu/svlMrXmfEEAVEkhXDQIoyig1mmESqJisyQoclLMcmRIUF8jCWZpgtaKJI4Jw5AkTYjCCDWzNWpV2AKTOCaKQhqNFq7nz+yKMxCGygs4iBBoZpY9FHkWEUym7O/uEsUJCIM8n/mRpECKYj+ltSrs13k66/kCaUqyNEFKsxCSCPI0Lb6uIdF5gk5jNLoo4qbA6qts5rxMCwuKyiOkYRTdbXlRF2BZBvValfnlVSrVJphmcVquZuJpRrSUsyyY+EuNAxoQelYMLsTM3lhYUG+DWfRss1dU7hog3WLzRqFrMSUIc/YfqsiSCdCGVfhRZ5ZNiUJrcee5vQtrvDu357kL14jjiMl4TJynSNfEK9lUpCTTkjhJafoVmh/+Mejc5OatFxDWEhev3mJznPGe7/5uXn3uLHEyYTgOuXb1OiuLK+wHG5Q9g5oFejwmCQOONyQ1f4FRmpKGKanMWKpaVC04/o6H+cBHvoevfu5pbqw/z0//L7/A1sU3cZ76KlcuX+XM0cM886WnGPW7vPvb3k157TQ7b17l2c/8EY4XE6UTMmyiKKLklrh6/SoV12Pz5gZZplg4eIj97T1UFNPd38HxXGq1BuPhCDmrxPjAt36A7//+7+O//+EnOHL4ML/2n/8zaZIghSJNMqQhiVXO/NICC0tLqAw2bm5y88ZNfufXf4VGewHTzGk2m1RrDa5culwcVqmMUsljNBphmCamkDQqNaajMblUJIaBYZqMJxO0yvB9n2kQFJs9y8TyXMajMVm2DhqarSb7+/uMRiOEAMMwyKMEHM3hZhs9HrPZn5BKFy1yyEJuXLuMoOhSK5XquOOcuWCb060TpK5B7jmEeUoUpuxuD3DTnPmXr3D/d38X02d+DbGpaR5aJdrbx3vftzB64kmi119k6cQKYZCysxlxqJqy9OB96OEewneoRQE6d7AWa/Su7GHLlHbTIhhp/IaPsMB0bCBGu/bs/UdiO1WSLOfN517hwqVbZKV5lDZJck2c5EjDRpEipUEYJyRJRhBOii5Zw2B3v8PyyiJJnlOqVIjDfbZefZH7fv6n8N/xV1h/+E/46q/9Kg+/cYV5ZWCN45mzYYrjBPwwf8jzQ5/2GYPvO7DDjVfO0YljVs8sUK5XyESOTnPiSYyWgknaJxiOaDRtkmGPRx47gu875Gjuve8olWaVNEpwy2WyXFGqzH/d1+k3RJy9fukyh1daOFJjuS1Wl1o8/coljh87Snd/j87gHNWSR7PhcP3GkGDSZxKENOfXaLXnMZIum4MBKo3AtHjm9Yh6o8F8cwl0RLPkMO7u0VypcfXmOrk2iDMXz5d824Pfyfr6BfJ0Alqz3x9w8vgRGq0VUhVjjMe88PrrVCs2ySDm+MEl1vtd9CTFcjxqtSXuu+cAKwfv49FHH0KJEuubN8njmDiMaFdMzhxeotOfsLzUII7GVL0yFV9gLM8TJTmXrl6h1a7hV+eJogDPqxGmMecu7yINRUNJXM9iMu4hHdgNUpYW57i2ucF03EcaZW7eWOevfvTdnD59gGs3ujzxzHns2hKlqstkOCAcdXEzwZJToVFfxTJbDIYRSmnyTCMNiyDSBFEK5LhOOoOu5UynQXFSa5qU/CqTSQ/DsnBsmzxOGA5DFhdbmJZFkiUYaWE7StMU23KQaJYXFvBdDyk0hm1BkCEMC4kg18admwWlFLbjoEhAKQwjRyqT8ahHPhngz68ynQxJgg4rh47RG8S4fshkPWFn8yYry4vUPcHu9oC6Kbj/xEE832e/06PUqtNuuPR767z8okJZDv3ekFK5xIOPvZP5ml/cFOU5QRyTpikqL+xXh0+cxG+1IRyjkwBsF60hGk/obGygHYtWvcXW+jYPPnSGervB7q3rbK9vEEwn+LUKfrmE71qU3BKDcR9LWFy+cBlIuXj5Ju1GhUcePsU9p48TZAapU2FxdY1Svc7ZV99koVkBpXCaNS6/9Sa9yRR0xOXL22TRFNO2sEt1Vo4cJUGyenCJMEzBhptbQ6pVn0MHHcq+zYEDS9+IS/fufBOMokDSCwRIPRNiuhAiM9y7FMX23HGK4mIhBRg2Ks8wRLFlAok0nAJAkWfFa4YBeZrNNlIGigL6kWVFNiKJY9IkJk0TtCwsN0oV2SetM6QoilPzNMIUGstewrgNIQGEigvoCPIOTBJMVA6jQY80i4EC9a8RZLdtfbcR9mjymSWxuNaLLZ4QkjxPCzvhDAZSiMUCH337i+VawYzKmCkBsthCGUIWeQ2M2XOnqVZrLKysUGvOYQijELNKo6We2aTVLIQvZ6+HgOmAYRc0RV1YGgt7klFYD8XXtp23q7gRVnEApFK0ThGGBdpE3rFhUjwuzJktdLYtnZElhRZoac+2ZrPHLe621t+dYvrdfUCj0wCRZ5jSQpGyE1wFy6JcrjHOIOxMOeRIzjz0DkyRsbnexdGXWW4t8+ToWXqjfaQpyJKIzRvXEWSgJDLSuLvXuP9QlbihCMkoacEwD5hvOyxUBPc/eJgjb3+Uq199A3My5syp0xx78J3MHTrF+a0ppfoCX33iy0jHxskibr78Mh8+8TD7ex3+Dx9+kPd+53v55B98nmdeu8G3/LXv5ZkvPMWrZ59HA2+8/jqNZpMjawc5c/wMX336adI4QGU59993hs0bV0GDqXKUpbgy6vLQI2/nv/7yf+DM4UM4tRqdccSbZ1/BcFy+/cMfpdEo8/AjD7B3bYd//2/+NZ4lEY5DPBkjZM7Hvu97uef0Q/zUj/8EEo1bclldWeXcuXMIIE1TXNdl0O8jDJNWq8XS4hJnX3oJv+TMtv4FOda1LcIg4P4HHuStt86RZylxEheCLFcYhllY1227KLCWPT7w8Xfxud//EpfMErHOmWtU6Xb2ieOMjIj1myl1S3DkoTnOfOf7EbuX6X72RabKoTNNyVMb07MJ0oh49zrlw6uYc8skKYzPniX57OeYP3USvbRG/9xb1B59kOB8zu6rTyNdg2gSM92PSZRJMJggxzexHMF828P0BXkfpGGTGgqjOY8o1Qo67d4OqdFAVEtkmeDG1XWGhkFuuUglidMUTIMkTgmjaQF0MS0m4ymWbdDvD1loNRmPhpzr9Tl0+DDd3qukKmNLWHziV/+Y71p9D8HSI7xgtxg8aPPtH/oQ0Rf+DPPSefz9mBIS/Z5jPCLPs5rtc7ja4MJkAn6FOIhQ/QBTCfrTKSrOsFGsHm4j26BUxJG1g/R6XbJqCSFSvGoDbI840YRhQqezz/Ly2td9nX5jaI3SZX0jJI0SLrz6NPH4Blb1JGUrJZzuMVdvc3jeIooD7j26zGic8Ni7v4vH3/42Xjt/k4sX30KNzuLUa5gioSlSSrYiDvv4BGROCbdWZnd/QCqLm4w8jnHLdRxrwqGFBpjzxGHAOMgoVz2Ie2RJynBnh6ZU1EjIm4pa2eBWV3Pf6SNkuYFrZMShwePvfS8l32e/l1CpznPz/DPFKWRmUStlnDx2mO3dHlEoi/W8cNjcvMYbb7zOYNjHK9UY9W4RhTF+ucFOZ588SUjjGJWHLK/NYfkCW9QI+yE7vYBGpU0WhETDCc36HLYlcKXB/WcO0Nnb58L5azxwZo6XXniDRkXiiDmaFUWt5uM6HkqDZUCl1cKQFrlKC6RzrsmyHM+zidOEJBcYhlUUn5JjSE2SpHheGde3yPNCVOW5plqpMxwOSNIE07CIwzFnTp+h0ajfIT4KLdC5KjoyLIdcSQxrllfRxRZN6ozt7V2SKKXXGyBNB+mXGY/6lI2M/u5VJuMxB07cz+tvrWNZDs35RYROmCtB4rkQjDAsh5Ln8tz5C4wHAxqNEmEiKbeaCNvmjXOXueeeNmury0STMWGU4JcreKUqUThmNB7g5h6t1WPINCHPEqSEdDQgGI/Y2timdXCNQWeXURji1Sqcf+N1yp5Ft7PFNIVSqUTJtgn6A+prK+QoxpOAc29cx/NdVDbl2OFlDh1c4dChRaJoyqgfImSEiltUbMnx1SZhPGU0TRgMRgxHEY7vI7UkrSmcUpn1GxssrS4yX/MIgph7HjzFU0+8zpNPX2BloUQQBqg8oez7TMbBN+LSvTvfBGPaFjorhIqCGYZdkqtshsE3ME0bz3NxS3Wkac+QgH9JFGXxDAyiUVl0RzAUxauSNI3IkpQwCsmVIkuSAjef52RZCloV2ylAIwvhoQQ5GdIoBFoQptSyDGnYhQiioAjetgAyoxlqnZLGU6LpkDyN0dq6s5EyxKxrTWtUrpBCIaREpenMgamKXpsZbVIrkMYMwqHSGWfEAFTRVaYLAqPWqgioo5GC2Uat6HarVGssLC1Ra7QxLLt40lWR5SuqBgrLJDNrJYgijyfk7HGJItgv4PYOTQA5RZ/abQF9245abMAAFEIU0BZUPBN/hUVVzTZyBYafIg8nJOFgi6C7S+vYo+g7OUFRWCnvzt0BHLfYxopKE61ybMei4lj4jkuSa8LJkGZrjrVSi/3XX+R3PvtZHnjoGG+8eRZTBfz6r/wywvGwLAtDSEqOIAkSVioGK2srnFw8QHPnRcpySmAKXKlJh2OW5suUPcXanMW7fuCvk3uPsPEXL7By+hDtg4cYxgmvnb3MuBNx9ep1jDzkA+9/G6+99DJ6f5MLf/pf+fC7H+DB93yQVDk8+si7eO61TfJpRGd/j0a9hnQEnu0xnUS8/OwztBt1Jr19/JJHGEW8ceE1Dp45xMbla7i2S9n3eOj4KS5N3uKHfuxvUHMEX/iLJ7jnvvvYvLWJX/G5cvkq3/r+d3Hf6XtZ95rUDh+lFk7Z2dwgzjPyNOfJv3iKr3zxOXIkhhREUcTlGeSjOb/AzvY2G9tblMtlwihkb2ubna1NbNtieeUQnd09Aj1FCEESJrglmysXr7C6uMrG9vqsXiPFMCS+7xMEE4QGW8Ijjz3M9//0z/Onn/8O1DSnWqvw0NvewYXz57lw7s3CiZAnxGgMv4RZbrP4/r/O0pvX6F3oYgoQQlGfbzK/YCKnXfzjjxFFNuXFJpTq5Pt9uMeCWoXR7jZirkS6t002HOBRIVECtyxoLi4SjqYMgjprawZGuMHc0SME/bdIgZLrglMDwwfHJ4r3sFcb5NOYYBCTxCnCdEjjCNuvMg0iSl6JQE2I4uKVVqkMIYvXVMM0iNOMsuei0oz9To9KtUx3a4+JY3MxTPj5v/d3MeeWyPsdsnsPsNNw2H7nGbarCYML1yiLCt7c/XzHRz5A97nfYzAZIgyfcnWVrFZhcO5ZdJCiAkWl7rCw1qTq+RxcXSUYj7BdqwDiJDme7zEKQhwCxrkiiiOEUeLapQt8vfLsG5M5WzxJtdzGyDvsrt8ktw+yvHCARrvK0kaXkhVwceM60TTHtHMaZZdR5xpPPa/o7Iy49PoTWLbk+FILlEmnJ9DaJJpOWTu8BjojCMfUKxVMw2G/PyTzNN3xhLnOdQ4dPMbLr19BKInvSba2OkhlcqPT49jyAg+feZw0C/nyky/RqQwQ2qTdaHFzd5dsnOP6JrVak3AywSSl7JtMghTD0LiOyVyjTqPsYcoaKo8RWcAn/vuzbO/tIHMLz/Sw0BimhVE2mUzHxNOINI9olKo4yiIbJkx9g/39MZ5XwfU8TKGp1+bZ7fe499AqQWbxF0+9ygP3neTBR87wx599FlOfRAYTuklhvxmNQ8ZBgmmFrCzPU69VSHKFyApLi2NDmsRoZRNGgjhUIMF2BDLLceziJNUyJZ5fwtIpeZaSZIo4izAtiywpOo1G0yGOKdnaWCcKxiwtLZPngvy2tUlQbO5kUc4YBBFJlqJ1hs40o/6Azb1tTMuh7MAoyNFa4dgmtVqZp55+gaWjZ4jjjFqjwanjq+zfvImpUzzfxTQE3b0tsrhMniY4tQqxAK/aJlQZk/4AlcQ8cu8q00EXw3ZJggiNwLQsPL9KEAbMHTqE6ZTQ6QSVJAz7fbI8xTRgYbHNcH+PF/78Lwh0gmla1BpVklCwdOggna0OUZJQmW+TZQlpknHx8iV6+x0GQYRfdWjXGmRpjBY5/f19+v0BQRBz+L63c/XyRZoVl5X5BQbjjN3dXXIlWFpeZBon+M06eV7gbpuLC8zNzWGYFqat2Lp+jYqTcPHKVUxjDdc2ERKSKCNNkm/EpXt3vhkmK7ZJ0ixAN7c3P6bhYBkCzyth+RVAk4STwvKoNbnKZxZEPaPoC5TW5Gnxs5VlGQhRvJ4AKEWWq9kmLCFXRRGs1qDzbCYGi2yTougVK/Z5OXmWoEROlsbYXpnbfWVC6yKPNSMXJuGUQa/LZBqQpopczwqylULNrIVa5SiVIwyDPAedzQAlWiGkIM9VYfXThSUxj8OZkDHBmBEhhYmQqoBwoAtI0GzrJSg6Iev1earNNpV6C1PKInEnZqXZxuytc/Z1oeiHU8yQ/UUpXJFr1fkMl1/8kaIHziispaIAo2DYkGdIdHHzISg2laroJRKWg8qzO6K6AKLkWGZpJg4LG6lbX8ZpHixAI0IjUKg8I4sjvPL/t34g787/L097bRVLgmmY5EnC4QNVomlOFOcIr4YRZ1TrBsF0inLnCYOUz3/qj8AVuLZLKiSTKCTKoep7GFmG65q0yy6P+hkH5lK0qqDLJZLNLdZaFmYi8Ssm48GAedfFXHqMLF7k5Ld8K16ryqtnX6WZJ6ytrvBvv/QMC+2IuSro/jW+/4c+TNQbcerYAsun7uPGxR6f//Rn+LOXXqd1cI0//eM/YfXgEjevTxlPRywdWOLexw+zd/U6o+0dbENT9j0GkxEf/uBHSBYXuPDka1x95Tn+8Dd+mye+8GXWDh/mZ3/25xh2Bkj7Ja5cWmcwHDMa9fFswTvf8y7eeus8X/mzL/MP/+H/xNnnX+F3f/u/sXx4nnNvvs7Z185iCBvLtlE6xzJNbNem0ajyHR/8dn7913+DZrPB3HyTm+vrCOVg+xUOrq1y5v0f4s9+/1MY/RGWNBCuRf3YvfRvXqHb26c9P0+73eL1115DGpIkiZmfX6Tf66Mtwae+8BqXJv8zL+/2SLOM7mCfr0QxH/zgB7lw7gKWkRcEbjOHA4+SRW1uvfbfOfPBD3Hj0u/gADrRNCs+D33w3eTbryPUANW5hfmdH6J+4A2YTjHX7mVy6U0W77mPYPsmB08t89bnbqDSmOryAlkQ0J5r8v9m7z+jLMvu607wd851z/vwERmR3laWySqUAwreAwQgWolWpChDtkRxia3RkmZ6davVUvdMiy0N2TIkQQIiQYIALQDCVKFQ3leWSe8zvH3eXnvOfLg3EpyPWM3hEjSxv1StAsK9iJcZ++39/+1hMUf/9au0N2yqVYnvDjFMi+7OgGIlje720ZaEeh8/KmLbDqI3pFvfpLXVYNQPCUyJ1hLLTNPu9kDH5zWGlHQ6XQwpSafTlMolmp0+I9ekUszR7fYIPB/DsOgPR/TKBZzhBvryNe578C4e/vgPkJUuO5sma9tdCscOsP8Hf4Wzb17nrX/9bzgwEZK/bxYrY7O5vEV+X4GUCYaRwsUnDD2kSFGuTVApOViGwkjnqEQWPVcjdAbLCMhn0rhrderNLhKDYLD5PT9P/0rM2fk3X+ex93yAE/d+iIffX6Hb81nd2OT20irXr68Riia25WDbOY6eeoj62i3eunwRdfEiOhScOjyLbZpsbW7jKYFQHqZpc+89D7N/dow/+8pXqVbNmLjYDlBRRLvuUh236Q0GLN24xNZGnempKiMt0J7DUmubqakxpueqdPrbbG41mDm0n9FwyKMPfoijxw9w488/T2sYMOrdYNBukE5b2HmTmzduoaIAy7SwHRPLMkGG3Lh2m83NNQbDkNX1DUzLxgs8TMvEdjIIYeGGARubKxjCwMIgpQ1yOZOUY9P3QAUaN+rhdruMl7IYOuKekyeYnxnjvR/5MLdubnH9xk2uXHmJx975MC++fg5rtM7BhX1EKmQ4GqK1xdh0mfnDR6lvb5O2U2TS8eipTv5y9wKNjCKEadBp90mnHTQax473dAr5DJvrG1TzDrZjs1XvUq0UmJmuUs6X2GrUefmVs2SqFUbDHj0RMF4pozGIVLy/MxoNCQOXcm0c1w8ZjFw6rSaj7oBU2qBYyBEFAcLKoBH4kSLyejSGPvXegFEY4fe2mSwYjNwuRnvIZNXh2IkTHIoiXn/lHLdvL7FvZoq7H7ibQEmKpRKtThu32SdwA/7Wj38aS3tIw2Bna53G1jql8VkcJyCfNrG1pjCxADog7Lepb2/hjuIalu1I2s0dGo06diHL2kqTmalJjp04RiZls7O5Ta1cBcei1+myub7DxmadVneAk8lyem6OTrtNOptnY21IpzNi1O2yvrnDWKVANpUmY0okAi1DvFGMus3nU3R7Peq3ljBIxxsdA8g4EkmEihRpx6bVHfL8i69x18kFiGKClGnEIANh7u0W7SmWNIxd2H2Cb9foyMcQFkGo8Ps96HXiwWTDRIvdzS+Z/HkRIaVEKR1PO/gx9TDeFQOlYgqk3oWDqHgEWmlFpCJAIIVAKE2k4w0xAyMhSEYojPhGTIEpDUQUoIWMUyMhCL0hg26bTmsnfm5qmZhAElBIXPmLMfgxiSy+BYthHUIk218ihiDp5JXVGKcfoWQM/hHSSF5UspIx7fiGAR1hAI5jk88XyRVLZAsl7FQaIK5UCpDCjB8z5Sc1pN0q5q45MxOzppOdNJVg+2NS4i62X2CgBHG1lLjug9boZIZASisxdPEtoA49MFMII66k6iiMDbix+z2JdrkggEYqTag9/FGPYa9DZ2uJbHWK9Nihv8afyj3916psPo8OAkwd16HDjksUhkhh0O+0aHY7tC9s0Lq+iHf9ZSxvAzMtSaVttLCwowihNDPTs3juiKHf4cd/5mc5Onec27/xr1irv0ogNVZuxKF944y6A+ZmxlhbW+XEfQc499oS2//0n9DInmTyxGG20bRafYbbHX7vP/4WunMTHIGMBnSbJqVqjlEYYaTzfO23/5Qr17a43Rrh5DL8wI/8MGdfeJmNtVVCz8MWBuOlIjlHU1qY4oXb11iYK7Pd6eMYDr/9G7/Jp3/mp6gVclzxXQzb4u/8vZ9j/sARLl6+yef/039m5I/IFKogNEoHLK8s8/zTz3Ngfj8vP/cSL734AutbddKpLP1eF8OQOKk0KlKEoRdTIEtV7rn3Xp78+uN88QtfpFAo0un08DyXrGFhjxV55B/8MluXr2D4XaaninS3DPKFNMJx+Gf/7J/wP/zyPyGfTxEZNhcvXAQ0MzMzbGxs0Gg2KBZKHDp0hCuXzrH05JMoCRgG6VSaTrvJH/7hH1CqlFCui1A+rgZVLLD8+lXGpnKc+8bT9CKwbUnakqQcQZCfYPWFFsc/+RG8y98GpanNTeINAsLtZfprtygfPEBOBuCOELbDqBWiRJtevc3S9R3GZyoMej6N+oh+z+KBM+9AZnbI2wGeisfFkQaq38Rtdsl1y3gjl8iMa+VWFGES4LkjKpNjDD2XXreHVhoTjY4iAj9gMBjS6w+YnJphZm6BVmObYqWEVGl0oLh27TbNoc/BuSM8eOYkB4/fxew7HqB79itEvTaGEGQzeZZffpxguYHYuUg3N8F2O487HGEKg961l5gYL2EdeQRn/11sfv0/sHprjUMnjpGrFhl5itL8Ptqdq/S21xFynGJ5nPZII2yLfL6MMKC6f+J7fp7+lfyGN3ANbNPGkT6zuYAwa7KxrdH2JO/62N/ghae+ihENyGUzzO4/QH17h54rqJULmCpkY6dNJmfRGXjkcwWmxyYhGNJdu8prK9c4MJul02uTStmkMyHCE9TmDmHTY+QK/CjAdHJ0hhGqNWJ6YoHjjkE38Flbj39Z3r9/geGwz1htmvG8wdkXngevj9d1WWl0ePOFV3nnh99Jpz3i6vVrOI5DJp1CIMlmU3znuZe4eGmZbFqwuLwDWuOFPqZpYqccMBzcIOD20jIlS1HIp6n3fEbugJRKkVMw6HRBa7oDn2o5TzaXYnJhDn/gMrdvhq2lyxw/Ok/Q9+h3J7h1/RbnL1xFSyhVPNxRB8t0ENLgrtOnyKZz7HvwMG6rgT8a8O2nXuf++45gGgaOk8IdefhBiJYOO80BxaKD8EKE0BgIquU8QvmgPJCC/QdmKafTiNDHseL7FC3AcTJMTtaIIo9R10dbKTQGzZ0GZrpA59YVhA4ZDFysVBZTS/zhkGOH91Mdn+Dbz76KCgVb9TbaG+AOPULTJZt2WFu9QafT4fD0FAYR7giG/S7dTodyxWbQCxBWlnIhx9JGgytXrvHFP/wy6VyBX/7v/g55wyfEYWdnh7XNFaIgIOMPCIYttm6tUalNYZkWw/o67e1tmq02nttna30ZpQOyKRshYqJQJlPmwOGD1CpjhMGI6X3TuL0hb7/1NsJOo4joDzSlfIaB63Ht1iaFrMR1h1ipNINOjx2vQyZrxwbZbTE9OUO7M2A48Og0GmAYmLYmk3FwRwO8wCPlpDh18hg79TYklcmU49BobFOu1hj0A+47uZ9Gu0MYRgxHwwTQsKc9xaZst5oX7zvHFUORINq1iuL6XmLMhNYQRTHKXsWXSvG0WRRTCrWMq4podLR7B6Xif9eKMPBjQmJCBdSRT3wXllAI0XFyJgQq0mgZYRsmxWIRO51N0PAho8GQTqdJt9MkiASRiu/cdJIFhRok8dcT0xlNMGI0vQ4jhDQRQqKEJtIxgVEYuyYIgjC+sxJSIoUZm1gdG1DTTmEZadIpm1w+R65QxkqlMe5skyWVQCEROn6ckLuJlkhqkzERUSdUxPifycZY/IHZhXxIKVBaIU2b+E/f+A3jbe8YJkJCZ0QYyfckfnxj8x1/LUrEBlwmhi82cfHunEIy7NTpbK/iuR6F2iROOkNt/gSZUuWv6adxT/+1a/PmlfjnUCkGnRbLvQ4zk1XarT5eJo1hORSzaY5/6DHkBx4kkx3QeOU5mmsX6W3uEKoR+VSGXmOHdC7L/oOHKGVydJbWWdtoUcyNCKQkp2BtMSQMQmbvnuZgeo7NtSYbMsXmubfpDl7j4jMW1Q98gEMnPswf/S//d2rZAWNj4JjxWcbMRJmx6eNsDLcZBHnE1FEeOfowy7/7BcbHCjimyYGZCV79zrcJRn1qtTHWbt5i1C2RtRze9Z73Mnf4II9//QmCqMnswn7+/L/8PrYhWTg0z/LtRS6cv0hzu8ft28usrN4kW8yzeX0FyxRYdh6lQn79V3+V+dlZuoMeP/0Pfp6vfekr3Lx+jVYLKhNVJIJ2owlSYlgmG+vr1Le2md03Q6PRIgwCLNPE8yIi4dEfeGw/920uXbrIaN8Yt25cRKEYjXxEEPCf//W/pL+1wfw9dzG7sJ/G1iaDfsjmxgamaWKZJpFWrC0v0R8MyWQz5LIF6ltbFPNF2t0OtmXjOCn63gjbkLi2YOnSVfx6hH/rBc69fJnceAnR7iOFItI+W2efx02XUc3rZGwL4XfgwDx6IFArS4yWl6hUyjDogZ1m/vQJbrz0JllDY9iSgmnR7SkGnsnpD55E+i4ym0FGEXa5gGWlMGvjBJ0W2jKwbYPBzg6esglDhZAgdUTK0LQ6bYZehJXNYxgmg1Gfge/HTTHfR4chWms8d0S73aFYLFEqpknJiE69QSadpTJ9iM/8wt/n5We/xYce+SCpdJbR7HFC8QpeEJLOFpieS+NvrtN3BKc/8mOsn/8G2xstpvaNISyHTLVC2F4jWLVJ2QIj56Ax8SMDK1fBdNKEwx5G4BONhnSsIVPjh6DTwSnOMnnqOMOlF7/n5+lfiTkbmxjnxeeepWT4WMMpdHaGxvoqmbEp0laJoyfOcOn153CHgpe/9WWkYTA95mALl85QMJ5zaLaaRKHCFj6O9IhkG1cpesOQzrqJYwumxzUyk0IUqxw7cpSXz56n2W0yJMJ3PbJZm9PzEzz2vvu5utpl9bWXCJTL0SMnsI2IUi5Fs9HlK996kuMHZqnWpjGiFbL5PF/8vT/k7ofvp91uEHkQGRHFVJZBf5NXXnmFZ1+6iGnabNc9DEPh+iK+9ZAGCslo0KfeG2AbkrFaGkuZ1NseFJz4ieJkmJ2bYWZyiky2SH39FvVuAweDysw4Mhjw0rMv88azz7K1s8Nmq0+n7aGDiKJjEWiXenNArQDSyWAKgQH0uz0a9SaXb6zw9Ctvc+9dh+j1+oxGI7LpNEoLDNvB7/WRGnx/RKiiO8frSoOvbWrT01iWgxfGO2/+yEVrTS6TYaw2Rrk2TuT7+L5H4CoiS9L3XbYX1xj0GuRzebJpg/FilvHDR+h3ukzOTbFgmCzdXqXjRxw3Ta7eXGVu/wwrK+uUUjk8X3H38QMM+z7DSJGyAjZ3Wpw/t8jK1ir3P/AIh46eQAUu+VSfjY1tPv6ZH4VoxOx4gY3NDYqVcbY2ljC1wh/16W4t4g16ZNPxZkhrfTmuTIUuve42o34LWw8oj43hh7FRmhwfI5vdZHx8gk6nSaQ0N29c4drlZTJ5G2+4zdz0BJ7XZm2tjkITKcFGX9BuDpjfV4x/AdYCFYV03RChLVLlCfJGn+bydexCmaIK6XR6vPH2NQQmprA5fGielCXIWOAGEsuxaDWaLN1Y5J4HTlDfbGDZikLWwbazXLh0lVQm/Vfx1N3TfwOyUzYqqTaGoUIKMFIZFDEYxJQGlpPBdmxsO5UYFAMhJagIacQH6b43ot3axvc97pw+CSM2JoEf1wqTdEepEIERJ2cqRtuHCmSSJqk792wKUwoq1SqV2ji+59LpNBkNegwGA8IoqQUmNURpmOgopjYaQsR3v4lhQwdJgpVUBk2LKEpebJIxQEMIOx68RmNISRR6SGGBNMhkshRKZUrVcZx0CsMQSHbhHbvADJnci8W1QrRO9sTinTaId8eEiuKPt4uoT8a4d02ZFsnAtQLDjJMxIa3EeMZoSIFEEyXTBDL+78kNoGb34ycGM9JoA4SKEFqiDIkQJv6oj9tv0W81QGuc0hjVhZM4jsmo3UKYJn4Y4Q36OPm/xh/KPf1Xq83rl0EapNMOlYxDpqRJGRGbq6to0yQSBtJ28AYDLK2452CJnZYNVDAKmkG9QyaXJp9KU99YxaPPM7/5a1SCiLmiR6GYYeRphq5HKxhy4OgY0+Np3n7+JqsrXXZ8Ta2UwU5pZg6VKaY6tC48y1TJI5N1GDS6ZCxJpeYwdfAAfpQlX5vGH7gsXb9Fq7DF5HiGUw/fz0ze4tWrV7Edg0PjU3heCJbDD/7M3yOLzZ99/nNcuvUURjqPk/U48+DDbG1vItw+3VYTGYR8/U//lPvOPMSFt9/ixOkT/MKv/DP+6PO/z0uvvcjE1BSra6uMT8ywvr5JJpthbHKWA8fv4vbNGwgV0Wm2kMKgOjFBtlJi/dYSpWKZfr9Ls9VCCPB8D60iiuUSDz1whse/+QQvP/0UQaSory4RRmEMNRKK0vgcO6O4vXDpymVu3rqB45gEgYUKI2YnpzANwWA4oLG5RbVWxbTSlAtFmttbtOrbmJZJ4AXUdxrkLUEqY5JyTB5//Hny9rME/SFHFioo4hembSGprzfZurrM8X3z5B45DDMT6EELse9etv/4C2S8AYy6WFEPc/8BjEIZfWOFQlaRKWaxajVaq5ssX2sxVbOZO3mYUXOLbNmkP1ml8uC76J9/GWE5DAc+ds4hPVmltdEiTJfwOgOyjmRqLM9QSKQw2Oj22Gp2ELaN7/soFd9QR2FIGAYUHAdvNMQ0BbVKkcbmCq4hUEFAGHjUG01S4xMsXrzK43/2dY4dO8TC7BHu/vF/zrkbv8jG0gqPfvC9LJ17nbzj89KffglHN0FLMrkMoVLYdoYDs1XajQtYKUVx8gBaQ6s5IJUvgzBJ5/LMF2v0Rx7VWpawvUqmkMPM5PA36jD43s9Q/krM2aNnDvLEk6+Tn1ggLB1gcX2Vx7/xFxTLRbSIuO/0UX74Bz5Mdf4Izz3zAhfOP08pY5KbPUJONEgX84xZZcZKDlk7orm5Rqo8yXDkMTZTYhDcwvV9ImUwtu8u1tsetxtd2l6ffVMWE1N3E4WS1ZVbOEaWp567RDaX4/4zj/Hmmy9x+eo17jp+hAtvX2Pojsin83gDj9m5cVQYcd/CDDevXOMPP/tZPvFjP8rRgzVanS43rl6i3djmwrV1ysUivV4Pw5RoJTEljAZDIiKUNug027gq4qMfeJSwv83Gaof5hUnag4DZuRk+8Nh7OHhwnlTG4elnz7Lv8CnsxSsozyObLpDJmAjnAH6Uwg022Nx8i8mZGaoZh63tBktbQ5bXtmm3UswcPc6wPyDtaLzWNlcWd/jN3/4yc/OTDL0hQ9cjk8ngpDKEXsTI9Rj0R3QMget5FPJZDClod3scPnSYtc0GluGwWe+TmiyTcywWl1coFnJUqkVCpWk22sS/y2k8JZCmQ31jhygMKBUypGyDbMZmev4Ig+6A2r55ioU07sDlne96gOdefIu5haOMzx6h0+2ggLmpcS6eOw/tFrmxWabnaty4co3xUY+5OYfVHUV3Z5krFy8we+AAqco0H/zkpxh2OpQzPqNOAzNl0mi1UFJTyBXQIv5FLzJM+sM+3rCFOxwSeT3SNmivx2g4YLxSZnJyAi+IGI36jNwR1WoOf9jn/NtvU693uLm2ghcYvPuRU6x2l3G9gPWNOo6T4+SReVAemzst1hout9a6HF+oUM6W8UMXLQHTwXddhr0O5Zl5/LVF1hshjbaLwKQ6PoaORgjL5MKVJZQAQ5oMNje4ePEGH/zgu9g/N0Wz7rG902WsUuHU6aOsrK6hxN6o7J5i2akswahPpDSpTDYmE2qFYVmxKUtnMOx0cgul/lISZdwxQkIaRJEfp0zSJAiCpF+fpG1JDS8Kg9hERCGK+JVLgUSpEMMwYoy/TrD4SpPLZihXakRasHTrJoNBJ574khJhiLiKrVTy/kkysyQn0hrTiP8iNk2TMEnClJIYpgE6gNC7k+BJaSYAjLhqCSDMLBgSyzIpVQqkHZuMYyJlXDvchWrEqRUxWEMnK2wyGcvWCiEsIEbe6yj4bnKtwu8mj8S0Na13ASAG0titJ1rEYBCRmFEzweXvDnInhk7Fjx86imuKRmKOpYbIRwibgT+iv72DVi6YNsXxfWSr+zDthLKpFQhBpljC9zyyTgo7tXdwtqdY+XKewwdnuXltkVAN+Juf+Qhf+4tXKU/PEEgds0tTGVSxSL5Y5nKzh3XsDKX0GW4/8Re0hxfpBANmqpKiCXntk4tcjh8ssDBeYm2tT6ftks1IMkJSK6fYunELUGRLGfI9D0OEzM9XUaFi8exVhvZynCq5QyxTU5vNk8+a7H/w48ydeoStSzf49jd+g4W5IvmUxdEDD9HpDvnmF36LzfUm9525iyCEC+cv4Yceoat46/o1ynPzzJVybG412NppcOvaFd773vchvQHLl8+jbUm92eb0icMMttfpr67xlS/+AUqFHDy4H9M0GZ85Q3limif/+M9p7mzx0nPPsP/wITBNtBsS+QGZrEPgedTXNhgOBuhUiiAIGQyGjI1NYLg+zVadvArp9ftkc2mGQxeBRmmFaaUQAiKleej++zFSKb62vMLIcwl8n5Rjk7YcAgL6vQ7FWpGZfbNEbsjQC6nWity6cY3yZIVSKceg3qTeGWGZBlbaQJgmw5FHRESuWKY/8Min0oxcj3f/6I9z6alnMbRLs1Nnc/M2A+P9iCjAXFwlVT2E3W/QvXkTR2mM44cQhSqq1SXqNpg5fZJAQHlmP1Gg2K928HZcpGNjYjJqtJCVBTLv/EUGy+t4y5sxSG44wNAm4bADQLeziWWETNbyaNthfFygrzVo9Abk00WCMESjiKIQpSCVSpHNZjEMA7Rgc3WFjIwwM1nG9s1z5fJtujvbfPP3PsfOlTf5g2e/zf7Zcf7Zr/1nzKnDjC2c5NYTX0X7gmypwuR0l+3mGsHAJ5XLMhxFRL0hO+srzExX0UrSaw9BtBG3QjK5NAfum0SnLaYPH0ZJh83NHUrFLDocYaWydDvbtFe2yRa/9xfT/0rMmdsbYFg2Z89dZbrl4g4H/O2//ZOcOH4X9faIen2dqZLJ86+eZbu+zdTYApOzU3zm4x/C9QXnL19ndXGRkW6zvQ2Wcrh4YRm7WqZ56zJSC6r5Kl2RZn5iPxv1S/itTQ6P1yiWMkyPV5iYP8HRex+mvrmCKTWT07N4oeb6zU0GwwGrGx3e/857mKhN8MobbyBMg6OnH+aoEmzdvIbOzvHa669z6r4HObx/DHfU5+U3LjNesxn2WhRKFdI6x+ZWm7GijW15RJks650OUoBlGxzbP4cIXDY2faSTRRsGv/xLf59ThxeoVHOMBi4Xr9zCMTReoIhSBTa3lxlc7rKzmiZTaeOpEN8XjJVKFGtFDN+lOlNBI9iKDK5ttjj9SHykO8r6OHaaa1dvcWN5laNHD2AaGRw7ItQRA3dEEBm0Wy3azTpQRBgWphvij4ZoIekNhtjpLK47YtB1markkSogVIJcNkuj3qHvtijmclSrJVzPx3Qktg3jE+MsXb2AUc5TKpWYmtiHbTo4tTSplEMQKIZDl1q5zHilQNcfUS4ajLyAMAjZbjQ5OjtBaf44D9x7hMWby3Q7Ad3GFvv2z1AqZGnUd3juhZd5p2mhjYj6yip3H53BHSjSaYtAOzQbG9g2hH6Ak04x6HexbQsnX0ZkKphSYaRMatUC26tZkFAoFfB9n06niVIGQeijI83Zi5c5f/k2QRTQqA+ZmpnANiSWEAS+i2HYpNIWa0tLBNpnYX6aTDbFm9c3MM0p6vU6pWKaZqtF5Ad06w2uXr7BwuEFMuk8kjrDUcTE9AyptEHk796jCIJAIdNw4coirjYxDcFrb99E2vEvqH4YYVkWURSx02r+VTx19/TfgAq1abSKsfHCsOLERugEDvjdIWl0Ur2TRlwfjF0SqAClNKHvErhDgihKoBQJzELrBPkuMaRB6PsJDTJKIBc6TtiSHbI4uRJYtolGsLa2TpCQQwxtoEVIlNQplY6piEZCHIyC+BVjQVzZ832FMEQy0irjqQwdIe4MY8cjYtIwUdpAEOCk0zhOGiJBGLlYTgrLtrFNi0w+ixAKVFzFFFKitIoNKoK4FxlXM0VSB40fQi9JvogTLxWBlGgJOlJI00pSLpm0GRVgxKZLRcnWmZEkZyJOzOIRhHiHjgSHL2Ty70kVUim0YeL3OnS2Vun2uxSqs2SKZdLFEoZpxvZOq2TYOqY5Ig2EYWHZGaQKk4rknvYEEwuHwTYpj82SsXzq9R7V8Vn66QBlO2BbDENNJl8mMjLkynPkUwpns85bjT6GFePeh702OVNQrhSYCiXTZZvhwGXk+tg2CBExfWQ8fkFBK9KZIpduLlEcT7MwV6XXj9hY79KzC/zIP/4p+q0B3tYS1154HgKIAk3r2jms7FFuvvEqhyYFc0cmuHVrndvXVqhO1Hjk3Q9Tub5N34WvfPUbRDKeqvmzL32JW9dv8ov/6Bf42le+ztLyMpm0xebydQbdLcYKKX7oRz9E58YVxmYP8siP/Bwf/+Ef4htf/COuXrrAxKEF3vm+z7C4uMi3n36Gd7zjUf6018e0bF78zlMYqVdIZ1MEfkg2lyIIAtrN+O9k2zJx3REygVZ0uh1GgyHpbBbPj3jhuZdJZ2xMw4pJiiimZqbZWlvD93z++EtfJJvJ4kYe+Vye0WiIO/IQGqRpkE07/MNf/AWO3X0/X/ndP+R3fve/UMxn8T2PT/7Apzh5/Cj/6//4PzM3v0CnuY3tGGRtG195CG3RU5IjB/ah/B5T42mydLEtSaM+QmZTDELFqOeSCgP8YISzucZofYvU+DS9m7fQ7R5he4AwUphpg8yj76Hxyhs481Nkttaxcw7Xt6/h+hFROEIU7iN1/CCj1jayUCAMRiBCQiSpVAbDMslPVKn1RigjYmm1xf7j91M9dITzb/4GEkljZ4dhGKJ0/OeYk0phSAPTMLBMk0ZjC8MbkXYc3v2u9zM1NsYbL7xCbzDg5W/8KbOMiNKQr+XZWXmd6899lavPPosaRdy+vUJlbIaVG1c4cPwgV1+9SJSa5vSHfpSr3/ljZmcqjNyIYnmWnXKbkR8S7Gwyl13AMSXuZhu0wWjo42QqDIZ9clkTREDQrhOOmuTm7v2en6d/JeZsZ5Tl3gc/QDUdYQvN9lDz4ESJSq7N8so6V2+3uOyPmJrcRyY/xg9/8lHeuLSB5yp6kcawU1iZNDdu1JlZ2I/rVpl0OgwGdfbVLCqTpzkwf4BRe5m1ay+D73L3O97F7bUG2vIpje/jHfccwk7ZXLqSIVMY4yvfeIG+22FqeopiWnPvsWm2ukNurO1waH4aMIhknlw+zb57x5i+V/Pnv/t7PPmNr3Dkl/8+EoWNy+pSk7FqFnfU5+ShBdqdIY5pkM4VGQQRzsDGcFKU8jmkMun0IoZ+fOv10z/9kzz20GksS9LcXkNHIaNBm5E7QpkZSpUqOtKYlkcY2Rw5/Q4uXTzHeNnBa29gD5rgGIxaHRpdHyeb59T8AdCadNYhk8rjZDNsbG7HQ4emSSotMYfxWLSKNEHo0Wy2cFIOhpS4vk8j8EnZFoaWdHt9jGyVQa+D49hcubXKsN1gNBpSK/u02j1I5xl5HtlSmbarEcEA0Rty8eJVsraFVpKp2f34gyG+ckiZFq4XoFVIoE1CXzMxOU53cQXfsMiYaY4dmcf1Q6Jmg1Q2y9XbDY6fPMHM/Dw7m2ssrawyWy3Sb/Xx8zZn33odb+jx0L2Hcf0QTwmGXY9udwvHFrHZ7UWMj5UZNge4bhsR2Bi1ORw7JGM7yFSadDZHdzRge7NO2jGIRAxe63e73L5xk+1GFz8M8XyNNBzmJiu0G3Vm5qYYDAYU82kMWxKFJo5h4zhZcmpASsJw2AdCWo02G+sNWr0mpWqO8elxvKFLJmOTS9kIERFGYAgLYcVH/ulsin6zwfVzV+kPhhw7fogwVGRSNqPRiH53RBQJnnjiOWZnJihVSn8VT909/TcgaRpozGQ7K4rdBPFt2e4OFrvwiiiuIca3ZhqlNIHrEkU+w34nScKSt99dUFaxidACVOjHtEMMkBamgCgKiFQc7igN0pCgFIEfEPjxIHZ8SxYTIuPELkhQ/knGlaDelVKI3QSOiN3JMCklhpEg5DVAFD9/TIkhQ4SOcLI5iuVZCuUxTNMCEtNlCMAgppvENUiNvIO9l0YC8lABKvTiOzPDQhhW7GmJa+BECp1UKncfFyCmRqoo/lpkDBCJq5QyLipKkZAbYyOJ4i+RG+PhaqEVKIGWiRG203iuS29nnV6nQbpYI1OdZOzgSaQGLDtO83aNnzSSBPK7SZ8QJEZQ7t2o7umOhi70+x7F4gS2GDKKUmQnS6RoYDsOvU4fIQXtbgdHePi5DCf2T/DGd15D+y1y2TzeqE0vdCmV8hw6eS+t17/D1lqLdMoiQlOdK1CdKGOl82w1epz8zKf55m9+gan5MoW8w8pSj5n3/wDbt75JUfV59rO/w4/9q/8BJ/shrr+9jHIX6SjJNz/3ZTJf/Q6lYpq5hRrXzw9xzRLKzHDy9N1cubnCcOjz2kuvkTIC9h2ZIVua4rU3r2Ja8LWvfoX5hUPcun6dkQiZmJlH+UMefPQxDr7jEWrv+TS5fJlMqcah/Djv/NCIs6++yhQBtqF58uvfpDI+xV/8+VcQBpRrVcqlAvlSmUNHjvHVP/sax08d48L580RhiDAlxA1z0ukUge8zcl1AEwUeUSBJpR2Q8PB73sUL33mWfDpLY3uTMPCQ0qCYzeAFAdlMltFohGlahGGEtExmZ2eh1+D6m6+Rdopcv3AJN/A5+9prhFrxh7//RdCCYOShxA5SKQzl0Gq30aFCWZKw0eOhhXHqV1d51ycfZv3Cm7jdHvmKA6KKanfwm31CCzqXrzDjeyyeX2Zm/wRBGBCtrrN1Y4XqvXeTuf8M/dUdtt+4Rm5hgbAzwEg5pEqSjeeeZ+LoITrmfoLsLO7tZbqbbWb3Hae7dY7Jk/NEvsBJWaTLZWpzAme6wNLi4+ybnqBQLnLy+D5uv7jICDN5gUuCjkilUjiOTaQCgkhjkML1RkTSZt+Boww6LUIEKctivJjmVDlLWJ7ngz//D5jdf4C2/XWKFZvWyOLW5Wvc+5F34z3zHXpbfcJAkTUNXnvmad79wDtwbAhVRH1nh0xhjEF/RDZfYfbwMZbOXyFfK2NYJsPBEGVkYNCjXKhiZgw8d0iuXMPzv/fpo78Sc9Zcuc6ZwwX6Azj31lkm9+1nYTZLOWdzYn6Cl8/eQml4/a1rZPMOjZ1tqrmQb377ebK5DKlUnsjrgupz7z33cnx/jS9++Ws02qt0hhl++BMP8K53v4M3zl3j9/7omxw4cBfZ0hg//tj7+PaTTzIaemSzeSIV4XoBh6fzBKM+mxsb2Kkmm1uKq5kMUmlW67cplUoQRYxefZVjd52k32owaDeoldPknYjf+rXf5NOfepRjB2e4vbZNsxdw+sQUre0mh6cKPPa+dyNMQXeg6Hb6XLyxyOW3L5FK2wRIlDRJpxweffRhiAIQNrWxMTx3RMpeZaxaotnskMvmcQc9Br2IgTvkqaeeJZ/PsLp8m7mKQ1Sq0lxfRPR8btZ7/NBnPkirMaBWLFKtVcgVyzz93Bt859mXmRiv8u4zhzEQmMkIreM4DNwe+XwGpaE3HCCEjSUlvV4fMPGFRTVrorWk22qDY6IUDPounjvEsDJkpYXnB6xtbCMsh5XVLfqDAc3tLQ7smyCTTWOhaA4GcVfdDQmiAEtCpDWB5yOEwc3bSxw4cRrDkeBHjI9b1IcDNlZvMz5RpblTwDI12azBTNXhrTfXOXzyELfX6qTyNQ5OjXFwfoaNepthENKob5POpjEiDVrghQNaTSDwsYVBdewQF94+x8c+cxQrnSIKPBpbG4Q6oNXcYdjtY2VSDPo9pJb0egOyWQsvlFzbblHKZwmDEXY2g+NYbG10KRbzeK5Pq9mgNlbi6sVraNPk9OEJLl67zvhYmnRks9He4bc+/584OX2Qn/y5v4Pbb2MhGK+VaHX69D2fsfES7XaftZV1XNfHNgVTk+OcOnWcibEKqVSGer2FYdkcOjbNpYvXMC2LcqnCRG3vgGRPiaSRJD8qMQ7xL/86IQB6QReiCMcqACIGUhjxtpiKXIQEy3DIFUr4gY8IQ6SM6a+RP0IKmSDtdxOqZMsM4vqikEhClAqT1EzGPiiK97tUFCINK/aGIq5ASkOyaxeiKAIRY+WF0EhpoYSGSCekRnHH2GmlMWRcLzQlSEtQSJfIVSpkSjUM00KoKBnQ3jVgscGSgN5NymR846X17pi1RBtWksxplI7QkQYd1w5FsoG2C/LgTq0xNq4yGZNOFq5Bxu9DahUbQZmKDbGI7/A0gLRjsmTkE2kNhoXvjhi0m3R21khl8mTHZpidPYAhkkokGqEFSlpxYic0SidTAFZ824bSyVh1sqlmWsmy2p72FKcO0oibJ0V7mqsbQzyvTW08Q7pQY/nKbTzbpzY3j5XPESqL8+dbvPXU4xzen0WpfZx/q44pJVEY8p0nn2YuJ5DtkEJGMX9kGhfFxuIODi3CcIR8/gX2nTqBrSPefu1NNnZcrn/jaYThUy4a2O4WqfI+AlnmzN/8GTrXXqbfruPeuEgqEzI5XWTkWygjYuCPmF84xNf/4hsUsmO8+exzDDsN7r1vH+/64Pv4wp98m0h5+EFEu9PkoGViGpLpmUmOnTxCNBywcnMFaV4iV9zk4P7DzGmLUCveOvcWdz9yP+944D4+/7tfpt7qcH1xCWEIKpUyuXyGQ4cOcGtxhdCP756GgwHzBw6wubqGViHdXo+845BKO3Q7fUwE0nII/AAkpFMOYRTyzsfeTWNjhzfffiveXpQm2ayDEIrA8zBMG8u28D3/TrK/vbHBiUPjnH7wAZaXb3Pl9nWEZVHMptnZ2WE0dCnkcsiUiQ59lI4YjiJsO4Xr91CRgZlO88a1FUqhpLHW540Xr3Pfu+/hxvXLlHN5XEMQZXJcefEV3OXbFMo5BkHArUtLTO8rsPjSJYatNrl9NZz7TnPrs39OqWRQf/FFRk0fZzzLviMH2dnewr9wg5H4PaoPfxCHDdy1S7TsDP7QBSw2r19iYmqG3sY6BStDd2eZ2fkp7DBk+epljh87yNMv36QrbaRShEphmAbSENiOSSbrMByNuH17iaxjM9ru8P/+1/9P8oU0Iz/EDBXjYzOcfOwM+979Gcbm5ul3uswcfJAD91/loniFm4vLTC6uUxybpbmzxv7TBygW5zh4/G5qFYvFq1cJAo/hcECv3eTIibspjhXJlTOs37xNihTeYERuYpyrLz6HdAMOPPLjGNLHLG6QSpcQ9vdutYTWeq/vsKc97WlP36fSg7XYFIkYWqGTFAetGQY9Gv42Y6kJUlYxrgSq3Zpi/Ef/7s1W5A/p1Dfp99qEYYBS8UCy0kn9LwrROkJF/h1ghUahdVzNVaGHir5LiRSC+P4sue3apUYmR2cIGcNzhFBoTLSwEDpCJrds6GS/zTASeEZs06RWWKZJtlCgUpsiXarGpkeFiATQJNDxHZmRmD6t78A3hNYx1VImZMdkGy5mg6j4sZMJDESFSZpnxfdkSVomxe4UAQkoJJFhx1RJoti4STNOxlR4p+ookgqnRhJGAcP+kMb6TVLZHPnqFMJMkcpkkAkMRVqpxGTG5EwhDZAORH5Sg/xLdVURVyLFnTQwvANPkfYesXFP8FO/c5ko6GNGOoH2RNi+y3QlorsKr11fZOzwBNWZgzQ7A5xCic0XL7D+9f+DXLVPs76DiHxsQ2AbmoI0mM+4zBctZqYyjOp9LMsgbcH4QpXK9DShM8lL33oJf9SldGQeXTnAhade4tSxCdzWDsdP7ePIR3+Ozbbg8Ol7eOmJZ3EbtzHcDXJZk9WbS/jC4fSDD7LRbHP0+HHStsWb55Z4+etf4cThImMTc+zoAk++/DaLm5sMXJ9ypcrM9DRba+tMTo9jWpLZWoUL56+SyleYmpsjbadZWlxB2iZTs5Pcc9/dvP7cS5w7dx5fwMgdUi4VOXjoENlsBsNXPPfcCygznsZwHAchDNzhCM/tc+DYIRpbdUqzB2hubtFYX46nPjR4XkhtcoKN9XVq5Qr9fp+AiEwqw2jo8sijD7C9vsHqyjp+EDG3sI9cLs/Fc+fAEKAER/bP8K//7a9iWml+6R/+Y67duBT/Wa0Vjm2Ry6RJWRIHgSEFqXwmfpGu38dBM14qE7pDJiyFM+oxN2Ezd6hGJmeQc0rcvHKDyckq6+evk89JHnj0bl771mvxPJINRiSYnLbZ/wMfYnO5Qfe1Nzn2ifex9OIrtNe2GDt6mE4/YOD28NsDZg/PMH3mYd56+nk6rTZTs9NEGo7cex/nXniW6liNbDaNaRts7fToizxYOVSujF2a4H//1c9xvWfg+RAicBybmblZ9u2bYmXxFrbtEEQhzZ0dxirj9Lo9pJPG90ekA4/jc2N8+pMf4GbD4ZM//mPkigU2r1/m9aefYOG+h3jjqT+kce0i0m0yPVHANDP4QcCJB97NzJH9vPHE41iWSc6AsfF8Qi3WjE9WOP/Kaxz99D/m1nNf4vDBaS489zh0R7z753+WcNBj9dItspUpSuNF8h/6H7+n5+neWNKe9rSnPX0fS+2CKyIfoXfvsGIKYtoqMG3lkrukOPGJ05e/lLLFaEIMK0WhVAU0vU4zHj3eHawO/SR9ieEZhiFRkY/QoFQYVypNG8tygAgdhSiV2CmdAD/QKAyQAikiVFJtDMMAQYiQPjo5ipdGgsqIVJJwRZhmDGLKlKpUpw+SSqVis2bYaHRcOdQkxsyIKZJagWEl1cqkQilBEyB0sklmJAmWCuLHTseJXZxyGUn4FtcOk/gQpBUbH9SdezxQEAVoI6mQyriCI6KYZokWaKGIkPijIfX1JVx3SCpborZwhGy2gEzMVFxVtMFIAC6S797iCY1QYWL6YPfbokWSlBkyMbYi/trj//rX9wO5p/+qFURDKsU0K1dvkEulGQY+47UsFy6v4A59TMtna2WRXneACDTbzQ7urRukSoJWo0G1mmc4HCC9EEMochlJuZShVBB02l1OnpxG9fvMTGU49OFPsHh9wONffJxMasCHf/yTvPxmC2fqNM3Rq5y9sMx7HzvF5o11rDdeoXbyXUQDn+bNG4yVh0zN7uP24kXwfTQuN65eYnbhMM31NYqFGrMHDvCPfv3foroh3/qNL/PEmy+x2KqjTQMnk8EQgm69gSUNAt8lZ2d49aWzyEyBldu3uXbrFrlMmlypSi1bQ5jwkY9/htVbW9y8co3IGzA9NcX4xAQnjx9jbWWdN869QRBGaB3ipDNEEfheDyPSmCri5NFjvN56jU9+6hP0d7p89tf+HVNzkyws7OOZp55jfW0NwzTp9Xpk82mQkl6nj9Ka5559Eds2+JEf+VG++udfo7GzQ7vZJpvJ0hn0EAhur27z9//eL1Aslbl+7SpG8geAlXLIZ9PYpsCMQqQ0iADTTJEv5fFSWfzWDsNeFxUFNH1FNgpwQ0mlXGBsrMja2g5OKsfG7U2K0yWOHJ9j8cYy7XZE1TLp6ZB7PvgojQsXOPvFJ3GyDlKYRKVxitMzOOUK7b7HubeWefhj99JaW0FlcqzfvMnVa9tMHpnh6u11jp25l66v2Wr5RM6I6UqVUEXkJ6YJOj4918WRJlYmS62cpxFF+BkDZVgoDe5oxE69Tq/Tw7E8Dh8/SqVYpt3qkMpk+cAP/gS1osOf/Idf5UMf+wSZjGbWDfi3//iX+aX/7X8nlTG59PabfOSnf4Fc2uGbG/8bpx++l423XkdMHOOdH/00Sy9/m6tnL5DLV6jkLCamsqQMWLp6k4nZSTx3RLlWI9w6T62YA+UyMTFDlHcxbYHQgkw5Rei5hCPne36e7pmzPe1pT3v6fpbhxKZg94BLxemQ0KBljJTXYQQqiH/pFyZaWnfw7wAohRASM5WjWDbxvZBQ9VFRiApchDBiE6QV0W5lTlqoIEh8Q4hGxgh9DWDEhkkn91063gtTKt70CsPwTvVOSiu5f0tMXBKaRTqM7+O0gW0JirkC1Zk5nHw1TrKSz1sHI4SVQggrNoLSQMu4hhjTPHxUmIw9i5iaKIVGi7h2iYoHeLU04putZPSaZArgzgN7x6iBirzk/cg4iTNiOqOOAoSO0MKI07IkwVNRyGDQZdDapt1qUx6boDI9RyZTQEYKbVqJ8YoN1S6MJY74EmMlSIAfZgyAkTI2aEImuwckX2+CvtS7+2nyzlDAnva0eeMmtzptwn6LXEaie136ekij0cZK2xjZMWSxitdvEQ583GGfdF7gNRUYmkG/R0oa5LIGlVyO8ayiloew3eHYiUlSlTTmdIHB0grP/+6XuXy5Q1ZGfOSf/TLOwU8zy1t85Y+/RGTAvY+9C5HJMOhfoLwwSXlqip2tHdoXX6BbHJG/6xQ7Vy8ThRoyFu0VlxQRtmUytG8TWA6ViQ9B+hC36w2OHd+Pf2GAZxi4EbidHn7kYwhJNgWuimi0e5gBIDTT0xNMTEwy8gN04LGzscGXf//3ef2lF+l0Oxy//16y+Tzbq8sMmztcfeNNpIpw0jbSdtAaosBnPJ/mwKEFcnaKlFMmjAz+/I+/gUpPEUWCsdokJ++6lycefw7LMnGcGAZi2GBJG8+wCUUQm6gg4Ozrb1Cp1Thy7Aj1nSaX3n6bjGUShArTkNR36vT6A/LFPIHno6KAfDZFyhRkMpm4jq7jm/ogCtja3sYdDKk5BmkbbCVJmxJHpdGpNFpkeP6ZSxw+c4jWpRUsaVCeKpEpFnnxwlvkKyWmZh1yeoCTCpl54DhXzvXY6gUYq5epPP1txhYWSI9N0Lq5jBir0VlaIz01T3sQ8vazb2FWxmm0oTU02CdSfOerL9Dp+kwerrC01CCUGssJsLJVgrQg9H0GjTblTI6jMzaZaoVWd8QwFNT7Pq4XYTppRoMhly5e5vDRo8jBEMu0uXz+Kg+84x7cyOSF7zzJibkUV154HYsSbz7zHfafPER/fZ0LLz6P2+1Qy+YxlGStHjI9U6J28D4uvHmOnbNf54G7jzE7U6FwYIKN6zcwiKjNjNHvtimNlwjXrjK3f5pOo0l5YppMtoBK5zG0z8TcFJ36kFG3Rfl7fJ7umbM97WlPe/o+VpwsKQRRsstloc10nOaEboycN8w4+dmlN6rkjkEY301gdHxTJaUgncniRyH4Xuz3dPxKsRASKSUqCO5QGVXkgTQhoYnFZ1wJ0IPk80GjsJAyQdFLmRx366SyqJGGjNM0YWJIjVACYZpk0g616X0Uq1MIw0hqiQlNUkowHHTkEpupOCEUkYirRCRk+TsIfJ2YGjOGp8B332aX0oFA7P7VKOPXpaMwjPH9SX1UCBFDToSI9+ISBH+SRQISPxL06uv4gYeONMIyKU/OMjF/GA0YwkzuAs3YyCVJHUrF3y8hYuOl5V9KPeNNNmFYyf8/MaEG8dtJk6SlikjMmw6T+7s97QkQ4RBL+0hDce+x/dxcXEdRIKUE0zMVwlQVbWSYnZ3k+tV1Dhw/jL+4zurGJRwnj+e1kGgC3yfo+djSJj9WwSlFtNfbeCPA1jiuw/ZWh3rPJ18swsR7+d1f/TXmjyxw/MxJPvnx93Hxua+hspJ3/swvMXJhcu4Ql576EqHb5PQ7TrG8skghJxCWRWVsnFvLm3S2VzANOH7yMLlKjcUXXyGobvDxTz1MpZYhHKxwe7VBYDsYY1W8YUhKD5gZy3PlygqZbIaJ2TFGQ4/Q8yhVKow7GW5eu8gDDz3AS88+TWt7g0ylxI/+xM9Q39jgue1tXn3+JVqdDoHSzB86SKvdxw3CGI7qd/nhv/UZhlt9itUZut0+D37yE+ScLL/43J/wysuvcu7N89iGgTANUpbJ2OQY95y5n6/+6dfQWvPIOx/i4sWL/PAP/hiPf/1bjNdqvPTMc/z03/158tkUb7/0Eukxm2wZvGuKo0eOEAmFJW3efOMsKtLIlMED73o/jUaDjXNn6Xsug04HLQRTE+OYfpc0AcqPCA0HN9SMtl1e+90XOVBzqPcuYXshM4fmSI/v58ZiCyNXJhiOyBppwlFIpZZh6ElG/Zv4zS4Lhyv0/ZDxdAGnnCHXmuD4xz7EpT/6TU4fyNHDpO4LJlION25uMntgH67KcvbaNkakcK4sMRpq0pUi1UKKnVtLPPrpj3Hr4iUCr04+myKfK/ADf/OHuXH1Nn/21acYK5WwcnkK+/dz6e030UKysbkDQpB2HC68/gwrNy/SDxS3NjaopTK4QYgO21jZLGNz8xSmq3zt//wXONGAYyfmwU+x/7FP4fsBbz/9LaqVIiv1JTo7aRYOzmHnawy6V5g9dgpRKuC4LjLcYdht4OQOY7S7ZMdKpHLjqMwpGJ4D7ZNOO0SZveRsT3va057+/0oxjNEEpYncJsLOIqIAbTlxtS6S3/1FX6nYjGGg2B1/TnbP0LEBk1Co1LBsi63NFeIrLAN0RBj6xDtkOoaJiMQcJZ+IjmL0viK5gdI6vnEDkDGxUCiJFnaC8/djOMnu52BYWGa81+VkbMq1SSrTBzDtJB0koT9KM7klIzYo0kmMSwLt2AWfoMCUEAWxL42nub9bX0QjhJkkTLt3bjoe29YRIkkADdOMP8dQxcZSGPEcWXzsFX8fhMAdebiDBv32NgiDVC5PdXoBy3YQUbILlySFcdqVVBYx0Obu1pqOP18p4zRPCkSUwEtkUtc0ncSQE9+dieTnIPmJiHfTdtO+3cdkT3uKEfWm7VCuVXhjuUMhP4mwBNncDGE2g9YOXr/PlWsbDEYh7vVVUv0WWoR4bh9PR/hRREYoLEvgMKRgpqhWMmwuNqhNFemOXEbpNAMtCbTBmrKx01kOHFygtbbEe3/gR3nrxReIggEn3/lTLK+vszA7jzfyiEZdKlmbnRuXWDg4T6ZcI2tnuH5rjQOHDxJpqFbLTE1O8uyLr5KtznO8coid9S0q6Tw/+VM/xH/41d9ip9Xm0Q99FFmaYuPqWQ7MjuGNFIMgJF8scmnjJoGAsYlJrly4hGGYXLx8CaUVw8inpBXPf/sJtILmyGPhxEkem5/j6oWLdAcDgsinUi2zdmuFjf4A10+zMexyY/UteqMBf/a7v0dncxulIlJZBykVhjQJA4UvNI1mj28/8Qy9wRBTSKSwaNU7PPPkU1QqZcpjZTIrBn/xJ1/mwIFDYNl87G9/Gswuf/R/PMHb597GdlKUi2UyjoGF4p7Td3Hw6DE+duQ4/69ffoVc2qJQKHFzeY1uq8WhqRLDTgNhpwi1gacVK60hmbTDThiSjmDouQw22iz86N8gv7WJtbrK3EKRnfVNDp6qMuwPWV1qsH1zC9OBzijNzbfbXFt8lXzVZGV9QD28xES1wouvXKAz0BT27cMqVxiOVmkPA77x5Cu0lMWwPSTbLzDq1wk21rD1OtnqGFaqQLFcJlKaD3zsfYh0lumpKmnT4LUX3+SlSyvobI5UyiTwA8rj40Q6fqFs5MW1wt6gy11n7mPjylv03IhMIYtpFzl15l6cdIHP/KN/wcYrf8LSy9/mfT/8Kc4+/hTLF1c5/q4HyaoNGrevMDkzRz5fwa4uMBxaRCJHKp9GjnxQmsrEOLliFT+SpMsFssUsOhoQbV5GZG2iIEev0cTKF7/n5+meOdvTnva0p+9jCRUmmHeFdIpx2pOYtdhsJOPTyQ0UOoqHkpMwZfcXenRsVLQhEComAe7SCVVyXxXHYxaGITF1jG0PowiBQBqSSAWoMAGGmDE9UEVBbIJkfP+kkrqflHFdMIp8DARaGFipDCnLpFopUqpNYKRyQAzU0AkaHhUhpJ0YK40WZrwVtms0dUxrFEYyMaCC5GuMb8E0IHTIdw+2Evy8NuL3ZcSmSYgEqrFbD5R2bIzQKCmRGEShjzdo47YbDN0RrutTnZhi/MAJbMtJQCT6TkqJ9tF+vDEppXUHWKLR8YC0YcWPW/Jx0SQ1S+LbOCGBKIG+/CXTnRi3OxYsChCGgxICYSTJ2572BNQmJ7EMQb6QITdw8V2PoTvE1wbF4gTjlQmsCDrDHsOhi+518FoGw1spQgFZ26ZoKCwFcxM57jleQPf6bK5vMnNokv2PfZS3vvYtkIKltR4bA40cNLjw9d9n3z3v5+bvneOPf/1X2bd/nNnjhwilwrSLrF6+ytrNG9Tm9nE7XWH/PouNm2tMnzzB4uIKShpMjU1QKFTJFQpsbWxTzJYZn59jc3OdfVPjXDl7juWlJfbNTKL1DmefeZKf+qX/G7qxiBKaYskhEzrcuLGMjhS12Rnq20221teJtCLUgs31DeYPH2Q07GOnTI7cdRfv+sD7aDQaTM3M0ap3OPfUd0jlMtS36/TdEU6+yL/8n/4NH/r4B/nBH/pbfGZ8nAvnLvCP/+7Pky2k+einPkW5MsZXvvxHtJst5g8usL66jopCTCTjk+M8+/SzBF7E7Ru3yRWyrK6sYglYX9vk5q048Vt6dZXXzr6C7/pUx8ZI2Rl06DI9UaXdbLB26Tx+a5uXQwNLBWgt2drZwTQNROQy7HQJtIVpp+k2G4zcAEeKeGusmMILPJQ0mJvIcfXPf48bL7/CPadKvHGxiR0FrLzYYevxN9h/Ikdhfx7fE7SU4uLtJs1hh2zZpBMYePTYbKdiYEqhQK+jyFQzdHybklWiFUo2Ok0MJZALZ7AGq/TOv0Zn4HDPZz5ILp3l0IEDtFp9qhMT5McmsItZGmtb5PM5DKnodFr0ewYyihBKUa7U6HYHBJFH4McbbRcvnCfsdlkUFhUNh07cTWV8ilAKUnaRlZUBY9P7kK6m16qTDrcZtw8RLF7H21ihVi2TKpXxtUf93BXqF86y/64fI3C3EJZESoOs6TDs9zBtA6XAKqSRnU10A+z5o4xPzNFY6XzPz9M9c7anPe1pT9/PMhwwSMATu2lYYlzY5UUkv6BLOwZh7J5RqZgqSAIFibeidVxbCrykExghk1kvwzCIdAwfSXalMQ0TFXmEno+U8R6NREPoxhtiVlLpCEOUjsB0EnBJlNyOxfdoKdug7Z0Y1QABAABJREFUMl6jMn0Ay7bRkQ8ItIgQ2kg+7zjh0soDiOuJUsVVPh3DTbQw/1ItUIBwIEHkCxI0vyDZI5LEO2ZRXE9MjJBOjJwQBgiFQsa4emngBx7D1gaeOyB0PTAs0sUKU7OHiIueAiWSiqURkyxRCm1KiAQxcyxOHw0dv28h47eMTXYMWNHCRO4aSqUS4xnGJnf3ziz5npFUK3e/j2CidIRI7s+E3AOC7CmW7aRY2D9Lrx/vMo2NO5iWiacMIi1YmC1we7lHNpVHIPHDECsoUx96WLbDWCmFM2qTkZA34skclU1x4PgC0gt48XNfQNsRvSHkqhn2j1kMe4pnfu/PmHq4S2NthYOn9tHYWMIUPoTPYQkTRwzotdq0q2scfughLr7yTXR/RLC6QW1mgcbGDsuLy1QqI4bDiLfPvsWg1+fRyTlyhXF6Ro1nvvFZapNlBu06lUKKhYWjPP6Hn2WiYGCUS0xOlLl6dQWlFPlSifd/4EP8+Z99hfW1VeYW9tHp9XC9gKXlVcrVEkeOn+Dl516gtd3izCMPkK9N8ewzL2NIA8/16HTiamNtepLWTpPmdpPPffZ3uOehB1lbXESFAcqxGfaGbKxfwAt8MrkstmkjVUQ4HGBLgemkSKdTEA7j3a+USb3eYnJynLvuneetN85DFNBcvAm9EZYpMCywHIf17Q3SRsSnPvkhli6cRXXrhF5IMWMQlieYmd7PG888jYgcms0+XiQwHBdTBRRshSljUNFoFGCagkKpiJPOcunsK6gg5DvPrbJKipRtsu3amDri6Pkex8fTbPYFR45kSM0Wseoe28OQri/Qjk17R5HL2WgVcfrgQW6tD2i6sHVhiYMPPoDVbGIMRlx56QlOPzjNDpr97/4Qh+49gy1c8nMzFGcMokGfTLmESGcwLIfiWJl81qEz6oAQONks3XYb03JQSuMHPtl8gbDVYTAcYKCRmQIH3/EQqdo+nIxD2B/wR7/xa+S61zh+5hi94YhRf8j9jz3IwkSJNa/J+370Uyy9eYmZhVnytSxBw2QxcuneuEWhliKXThNpByEkZTMF2kM4FsodIQoOIjChuYkopqlMf++18j2U/p72tKc9fR9L+fUEqU48Mp2w+WLeR4JST9Kh5AAr5lyoMCEmaqRp3QFaqDDEGw3oNHfodzsorZP0JRmJlgahP4TkVkzreKvMMB0M04iTs0jf2eXSSqFUiJDxvZrAiN+PjiEljpOiMj5FeWwS07YTCiIIldAUTSeuHIYBWNn4lizyvoumN5LBaZHg79HxPZze3QYjoS+KOBFD3iEbIojJlfH/KUbSJ1SVeHhbQxgSoXFHLr3tVcxsAS0k5eo4VirNLpEyTh4lGBIRBvE3R+v4uxF/c4Ckkqni2zdCPzmVk4CBlrtUF2JTpRXasOOKYxQl5lPG6WikvntLJo34c7hjzhJiZPLVxPeAe9uIe4If+l+fYuh2KBSquO4AxzLIZR3cyMbKlRl0u4CGyMdOpxirlGm88hyLT30ez91gImcyWbaZnJ6i0t/A7m/Ta3kIoZidz3HygWMoK8fLz15mZ6fLTttl4CmGfsS+w1Ms7JtC5zOcuOsBzj/1FEFnGykDnHSKiYPHGCmL6tgUg/o6hnYp1mZpdwd0tm6TNUNmF47yxOPPkS4XSGXyHHzgDGc+/LfotDye+9z/iTvcZnxmjPLCES7faLG1dIUj8xms0jhr6w1eO3sJ186z0xrgOGm2treJ0JiGxBQS00kjLYNTd50m9F2GfZdarcqbb7xGuTrFWK3KhXNvEGiB54ek02m63S4oTRAGSMPAMk1814v/WLIkgR9gOjaWIRmv1jh2/BgXzr5MOpViGES890Of4Lmnn2LUb1CpTrC2uYUfKkxTUMml6Lc6zE5W2Tc/wbATcvHGLcjmyGZKNHe2sGXE5FiRu08fwwkDtm7fhHQGUZ1he2WHteVbFLIWlZHPPkvjRgqKaUwHQiUIVETWsfBdn/J0DW0adDfqRO6AdmSTmpzl7YureLaFNxwymTdIRyGBdBChi1Q+86UckzJgMPC5PDDwLZtCNYeTzzEzN87ipZvU8hlGfsjMvXOsr6xSHLoo3yNVypEvzXHywfczXXSYLBgcfPcDyFARNVoY1XGGPZe1epcXn3uNp19+iyvXl1BaUigWKFeKbG5scf8j7+Ltt99AhYphfxC3RLwRB8ezVLTN3Y98gJ/4Z/8UhOTq269w7muf4/7j+3AHdSZrFaysQ9oxcHJpzGKG1uI6TrZEvzfC7XYIIo+Zo/ega/Okdt6AwEdLgZEqJTd/HkY6gwgDlOGgPQFGiEjbGPt//nt6nu4lZ3va05729P2sBEQR1/ziiEsnyY00zDs7ZhCiQw9/OMQddIkCl8B3MU0HaZiEQUAU+QS+jxcGKC3Qu+9DRUSRHxu0KEjGl2PcvDSsOCkToEIfdIRhOfHbKoUyNAIbqUGrIL4zkxam4VCrzVIZn8BMZRMoiR+bEsOON9MAUAhMtBFB5IK2ACthYeyOQhuJETXZrXHGfA+Z3IjJBGJoxu8vUruNxgSgIeMbNhWhMVAJhW3Ya+EOOggEmfI41fkjWIYEw0QmFERBTHGMDZkGJdEivlWT6JjeqEFIJzaUSqF1CNhxwqd3CZEahBU7Z2HGcA8VxpRNbSRJnHmnzqit+J8oFRvMJCfd3Z8TWiR3hck22p72BLh6gJPJ4PsDMimbbEqxsC/Hq2+vcvJglS1l0ht62KkCoyhg+eZt/PoSubRFOAwpCI8HDtaozh7h0lffIG8POXJsiiP378ePBCo9yaW3lzl7bhNtCQwDhNZk0wazEwWWVrY5+dDDbN6+TWd7lYwRkMraGGJIY/EW290+E+/9KBtbKxRUwNbNm2hDUNk3z0RtnJHMMnP0JLVyicrkGKmURThooHqCM6cO0u/a5KamuXJjiXQ6z8yRBYzROqnQo9PeIZ/PEnoK7fl4fkDaMsE0CFyXKPSxLEHayNPa2eTwkRNcrJ/jzTcXAY0Kh6AL9Icj/saP/k1efvkVbt24kQCQwDAtAt/HRCNNTRgKVBQhzaR2HYQ0G9ssXvI5dfQAf+dX/jnf+srX+cIX/oCpmRqTUxNs13sM3YB8sYA/6tPrulTHKvzKv/qfeOdj72Pp2g3+l3/x/+Clc5fQCkxbU3AymMDOZhOv06BWG6O47yCF0jjXXnkLI4q4uzLGfYUh93ziY7T+5JtciBRboYdvSKJQJtMpEXrkcvDeM2yElxlshUxMlVhZ3aFshdRHPr5UBKkSdgZaG21EZCBlmlzXZzIXkX3oXqoXbjEcGSChUkoz7G5SqClc3cNlxMq1AdOlPKVamYyV48DBU0wcOIo78pDhAKwKRiZH1NimubWN4wZsrjdpuAYXL1+n3x2SzmRIpdPUmw0KlSLFShUrk2ZyepLbV2+Rz2bpdppYhoPfGRJ5W1x67km2fvKnEFowf/geJn72VzAat/Gbt6hlXTx3QNQPsGbnkIUUZrbNxo0lPBQmEVNHD6JCn+bVFSYKDpb00EMPFbiofBY766AGo/i+2lCIjIVOVxGkv+fn6Z4529Oe9rSn72fJ+BBah1H8i/iuIZMx2p7QJxj1GHWaeL5PGPiQ3IqBwA8g8kZxipOkYEIYGFKidDzCjIri4WW9S1tM7ptUiFBRQg800DoeddZRGKdXUiSGjaReF4dgKJ9CoUAu62CIhI5oaNBpROTF48vSTip9HhDF93Bit48p4pRJGLsBWIyO1/oO9ENHEUImxZBdwqLQaJV8EkLE1Ee5y8eXhFFIp7GON+ggnAyG6VCeOYRp20gt7hg4Ffpow0oolT7CsNCmnWyjERvmSMWbZ1jJ58WdhA6xa5YSyIdOdtIMCx16cUXGSnbKtEJHUXIvJ8HYpUvG3wNh7P41vmv8VJywaYWUMkHx7xVk9hQrFfbQoQQnh5VxMAxJsytJ54uMWiPEsEM2EpiYRCg6wy5q2KPb3mQ8BVNZk+7iLXq3b/HBT91FIaOYOXCItdubbKxus9ke8dbLl+hEIXc99BCjxhay12Lh8Dw6l+HAkfdQHK+yfvYpigWTVDbFzkodpTWtVpuhF1GceJu7H3on9Hq88eyTjM3kOPPBT7Jy9Sp3vfP9VN58he7aGvXr53AckyPv+SiDW7cp0WD+niPc3hwRNtbYuHmTI3ffw+KtRcbnNSdP3s3O5nOUswWMOYfN9W0KpRzSThMKgXKH7D8wR7c3xJIG0vcIBn2i0QhTCMLhgOWVZUrFCs88+RQr6+vJ/ScYWqB0iCElQRggDDBNiygKSdk22WwabzjCkpAKXGZyeYrFMs16By8MqY1PEIaabFbRbLbiezTHIfR9Tp55BzOzh7lxa5GF/UfIFatIHREEI2q1CmXLJGuBJTWuihivldnc2eE9H/40f/GF/4JlGiytbfKTDz/Kqb/zb/DOvAf33/1LOqsBKI2emKC6cJT2pZdIC4/2hVfJ+yNmD6WRjknaT5EN+twKIzZDmCoWsKsVUukWzeVNJJqxsQzHf/jTfOLn/zm/9S9/hXNPPkFqugRGj2xac89jB7h6eZ2Tx4/QWNwm2BH8wE/8HAuHj7H0+lv4gUc6bVAoVBmbGIN6i956k82dNrYruXztNs++eg6drtAPAgzbZmJ6inyhwE69ydy+BSqlKpfPv43tWAxGQyItKeVyyLBPbuYEH/v7/xApQ770q/+W9330Exx75AH6Aw9zooDfeZNsxSHAIsTAIoXQsHXrBunxMcbf9RGIXGTUZ/D2t/AOH8U+NI2dC3C364jIJdJFhGMhQoVOZUBqhFNAy33f8/N0z5ztaU972tP3sXY3vXaR7hHE5mvQw+938Ed9wtBHaSOuGEYhSseZjxAxCl9ohZQWYeRhGEYymyVBSqQQCGHhuyNsy0IaEhAoDUQyJgMSoVVsiiIdJ1VSaHQUYgAYu2ZOYVgOKghotbqMRi7lyoDyxD4MJ5dU/Kz4Fk7HyZwwUgnNUcSNPRVXF+OKpUjSr7jiqHedmkqMTdLv1DquAAqVpGMaMC2E4RB5I9pbyyA07nBAqlhlbP4wpmkn5k/FN2sohNIoIZMqZZJYygTIAfFA9K4fTMakNYmR3N0hY3d/bfe/xYZL6N36Z1x9FFEQ+y3JnZsxeWeHLbmnU8lem+kQVyZjWAg6JjiqKELupWZ7+ktaffMVrJSDrE6xGklM0yJt2UgdcfP1baQ3RIQ+Vq6IyhbJF/Ms3H2A66sORgSDQQsXxUOPzFEcKzA5e4hLb1/h6luXGHY9NnZGWCj2ldJE9UUq2RTZWoX5I3O8/tYSRw5GZHSHyN0hX0jheyG9kabZCxmEGkeaNNbWaPU6HLvvYY46NcKNi7z5jS/hGTmG3TqHjxwjvzDD5MJMPGyPjd1eYvLuE0Qi4EAmx43nO0xPjLN46Ryl8TGOHT3Mq8++REYNsEvjWJ4gY5i0d7bQwwhMyal7j9Ns1pk/MMP+fQd46ZnnmZmcoL61gZ3NIbXiw5/+YZ795uNcunSRVCqF6w7IpCx0pMGyknaBoFat0O8PECIdG6xjR7hx+QqTB/fx8Dse4pmvfp3X/+Evcu3aEqlUhsvXblAsFGhuNxAIirkiE5Pj3Lp9iwcffoTf/uxv80/++19hMBhw6cZ1ipUSUoc8+tBD3Lx0kUG3hWkKiimLy2+cJwglX/j1X2Nm3xwrq7fJjOd56dtvcvCxLzE0M2xe3UYbIVKYnLz7Hk68/we4nd2hEPl0tzepCI3KZDDsDJlwxLgHs6bkZi+ivXyTtLtFveUShYIT99xHdmqcRz75c/zxb/8Gl199HiclGRvPMRwG9Bo73LoYkEkVuPb6OqeOnuKhjz/KodP3oaOQbMpCux59d0g2azHoDwn8LVZ3eixv95hJj1Pv9olCzfUr1zFzOYadLtvrmxRKZTK2haFD0o7DgQOHeH37RaIwQqmQ0PeYu/t+Pv6Jz3DX/e/AHzT54AceYXpflnQhx9LFHaq1MVwqZEsWMtT4zRbe9hZed4QXDOnfukar65EdO8hdZ+aZPX2KXMZABi7MzuJkiuAPEaMR2rTj5oS0IRxA0IaoyPc6dLZnzva0pz3t6ftZiQFAaHTo43UauL0ekY5BEjGd0QClUSqu3klhoBOzY5gmSgVopTAMM3kbhZQGUgii5JYqm82DgCBwiYK4hqeFSBD5xh08vSSp/UkTHYZokj2xKEBLMzZphoWQBoGWbO80cb2QSrVMOl9GWKnkdir5urSIwR9JahbXN0mGtpPbLQwIg7j2J3ax87vXd8SmKjFCQeAx7LboN3eQQjNx8CT5yXlMy4zhKYnpQUfJVlp8byc1KJmMS0szAYwQQzd264PfxUHGvI5ky3r3lm3XQKM02rAQhg0kgZoOY0iKNNEolGHF1EkkyOQWTydGTciEMBlTJXUwjCmPGAjDiD8oGinVHqlxT/9fKtMgUhkiN0MxUybnGLjtbcBlLm8xf/8pljdbjBodBr0twv4m66MdwlAwstLolE9tPoXIV9jZCnjuqae5fGkZdMBkxWZszGIslcbzNPmcg2VbnHzHGYpjY7zx2jW23nwLY7ZCLp+FSDBsrWLYNuiItG2Q1hGDzW28wTa+MDHHjnDj/BKnZ02OfvBHUOGQXlRE9FvYYYvWlXO8/dl/RaVYQJx5DxnDYHR7m/tP38crF68yMV7mwNFZLBlx/NRhKrMDbqy2UO0u09OTRH6eQwcOYSqPfD5LfW2ZY8cOUd/u0ux1qFbTZIoFHv6JnyXVg5tXFmk1WoQqQA1DJqbGmJip4g9dJqb3YVgp3njlddrNDqmMzZlHH+XSK69z/uxZnFyGI8dO8NB7P8rSap0nH/86E9UioRBgmnzgAx/iD77wRWbn5+j3XS6fP0+6mOHXf/3fc+/p+/jN//Sb3Lp9g0w+Q6aYprOzw9NPPoUpJbVSFltHBIMBC9OT9Ha2ODLtcPKTv8Dn//N/ZNRpcLFW4k//02/R315B5BT5jI1hG7hXX2bDW+Ng1YbQ4MjM3ZQWiqiBi9dpMz9uo++ZYO1mg8NDwdWbdZbqfaYzNv0AhoMB77//AT73b/5Hzp19kdCMKFcd2psN7jnzKOfffIuJ6gwf+finGHZGpFNFLNuitbaJ641YW1pl6A6wMnkazR6N1oiVpRUw0tRm5qi3OrihJiLCNCJ6zR0MYaGjCCkFU3PTbK6tcvH827iejyFthAxwbBMnl6K9dps//cLnyUxWOH36FPK+R6iv3iDXrTMzb7L40teZO3QaYzyFe/ka7uYWnXaLtZtX2FpbxDAkfnOAOH+BudqPMH5oARH2QIyg10/SMQNlRMgwQqfzCNtB44M7RIgl4NHv6Xm6Z872tKc97en7WDpQRKMewaCDO+gliZIdo9gBYaaQGqJghGWlUSpCAyqKjZvSEVKaqMhN0rK4qqeJa3G2jkhnUpTGJjANh25zk0ajSRDFVMH47ClOukBimOZ3EyIp0FFikAzrDnxDCIHSsYmQpkF/6OL7W1RHI7KVCaxULjZdKp4IEMSpn9gdfU5uPL5rOzTxcYuIUzN0nExJSaQjAq9Pb2eNQbeDYadIF6qU9x8lZTtIAbZKACY6Ttbi6qS8k8TFmH6JjEKUAKkTY2qYcbVzt0ypk4+rVJJY6Zh+KWVSXUweXwm7kwbsTgSYMdlMJ/1HaVjJ0LdO5hEkCZX/TnUyrpLq2NApFRM6FfHH4C/fmu3RGvcUy+1vEUkL3esgzRR+6CFkTBHcqDdpbl7h8MPvp9tvUimkGTY76I5CBxpTuhSKKWYOzrN4c4e3zq6z2HJx8hanZjO85/0nKVdzOIUpthY36O2s0/V9thYXKU9OcOTYflJS021tcfLQKS5eucHsoQM4G01y5gamAD8SCCWoMWDU6mAWjnHovZ/CbJ3njS//NlGmyKZzEsuXPHZ4xOFjZeziAfzAx56dgW6TgX+DSxde58TpByhNT1LaN8mw2yVXGce9ukqpG3Dr+iJW0eKBd93PD/7Iz/D8N77B1Vdfwg4DDN/jqW88wcAd0Wp0kbbFp9/zXlKVg9y6vkxzp87G9jJSCiwTPvyR9/OVP32C55564c7zN2UZTI8X2VfLszFRplBJc2LhME9+9es8/dTLTIzXCPwQt9cFS+MPAp5+4lvkCzm0htFwQIRmYnKKD338Y/z+Zz/P5YuXODg/S2drk0hHSNOiUC4QdHvMTtYoCJ+1TpultU0qeZu33nyTvpVGhjY72wM++t//d9R0yOA//EsOPnCQBz7+CO3NDlfOXSDqrTJ19C6yRQd9ZAYnZQFZ0lduUzk9D+P7mfRSHNxZZ/bVt3n+2+fpoJGZKrnJKhf++HeoX13CsWO4SiFvoAawcuEad5+6i+rEBK21Nul8jY2dHouXzzNeK7FT3yFwh2ipWDiYZ2dtg3J5gs7IQwifmnOA+sY2lfFJsls7HExnuLm4Sm8QolREvb7NPfvOMBiOaLdadLp9TNsmLcGQkl/4pV/m0je+xMyR+3jg/vvRaEbSZOr4fVx74jfJWC7CEziT83QuvoCRNWj1u5iOxXZ9A7fXZjAMyI9nOX73XfTWbjN5aAppaHQmg/aHCCsdv1CnTLRlJs0KG3JVcIdgf+8wpj1ztqc97WlP38cabC4RJXREIR2EjJI7IwNhCJSKd8i0EAjDin2B1vHtkoqNRhQmt1cKFBGmaaOUwjIMMtk8+eokViqPRpItBvS63RgAojWRUkgh0DquO0ohiVSEJv7fDCMmDaoorvMZRmwcDB3E217JWHIQaXaabUajIdXJOexcJa73ESdNQsjkbiupBe7+O8BuYoVKKJQ+I9dj0NjAHw5JF8pkK9OUZg9jWmlEOIoTOCnubJFpkjFpZGz0tE52zeL3r9Fo00HqKDFERmx5kjQwfkwTMInaRdzbcfKldZwg6jChSBrI5G5Pa5WcooXJzVqS1qkwSTdlfIOXmEekgdACLRPziEoakzIeDBckRnm38inuPFx72lNMDUzjRxrCHsVCmur4PKESDDodot4Ot5/5CrZlEioDSxicXJhn50qPfXM1HNHl8oXbrDU0iyqLl4qYrTiMjxdpdQK63Ta3rr5NvxcSWYIzH/wga1eucuvCJTq9IZaIyOke9fW3KEmfyaljFEvj7Ngu+VKa1a02+WqZ4dAlfPs5/OkB+ZMPc/TuT3G9fg2vNsnE3R9jsLxN0HkcFqbprd7CykhGq9uIyMMan+Kdv/ArbDzzDSrTU/Q212ndXqU+dFm6uEKqUsUQJpVyjZsvPsvyw+9l5sgZzr/wHU6dOMLqxUuMGnWU5dAfuZimxT/92Z/lp3/u73LXYx9kNBqhpIkC2tstXnvmVWqlCZatVcLAQxsCiaC93ealF17lEz/2t7j42lmefe5Fhhqc0YDlm22KmTSlvOQdv/APqD/9OldeeZH7H3kX/b7L6tIqGs3Nqzf4Sv/LSAMK2RTry8tk0zb33n2KS1dvEEYBxYxAba/QCRVT+xYQUuNaGXrXbvCtbz5L39cUMgZ/8bnPcU+5wKm7pnjXT3yKzNQUbv882dIB0mKA36lTfOj9iFI+hhKJFMZ4h2juELL2MOZokwo+W8Jman6G43PTmOk0OnRIHZpkcz7HVn6OXnOJQAdMH5lhdbnOIJT017YZuSH5Mly7vsa519+iWMgQakU2ZTF3cAplW2xtb/PGK2+RzuWZOXiI28uxaW9ubvPAmQd45cUXGauUSKcjDCdNbzSi1+8zPTvH9eu3cd0h3miENxyQMS2+9vtfoFYocObYKRAGruthSpNLb52lv7lDVnWYnt1HuPUKRr9NxBTk5+lvvEEQ9PG1xklnOXbXKe768LvoXbtCuLaEWSsg0znIpCAcgWWg0xWEN0LrHJh5hOUAvfg++Xt9nv6VP/P3tKc97WlPf22KdAyB2AUQKgSGaSFVCAhMCVEUYkozvjUTcV1RK4U0JWGo4pRGhxgyBmkAZDIZSpVx7GwRDDM2AjrAdYfxx0oIiYZhoMMo3gIzTUAjdUQUxeYuUgpppzAFKKVRUYRAI2wboVRisBSEPhHQDV1Mc4Oq7SCcXEJSTNK3v3SzpaNkbFrGG2YaRTAY0NpaZNTtkS5WSRfHqS1U47eLgvgVzYQIKREQhbFplUlNMMnAELEp1CpCGCYqDOL7O1RcR4z8eJPM2EXWx4OkaBWbL8NM7uCiOFMTcfUzPqqLB6Y1ZnJDp2KoR2Ju46ROgDJjAIkw45TNsBILKVBaxa/USonCQqDiyQMRv83upICIe5AJqn9PewKnMI7t5Jjbt5/Fa5cYdRvshJuEwqA2fxgZhrhujw9+9MNcOXuFpStvcfblp0nZkkG/Bwyoez79yCZUirRtMnJDrt/cYen6NtWJCkMkuamD9Lstqmc+TM6c4drSBU69+yO457/K7PRh0nYR1xsiHYPQbTM+XcEfKu595zvpu0PmS2VuvXGWgqmZP7qftz//BMPbr3Pyxz6F9s5RDJfI0MYbTTLcHjDz2DECdwsjWyO17z7az7/A9P5ZrMZt7JHHwXsXyK+2OP/yRa5du00OB3Xxbe55YD+TE2Xe+MMv88iD+1ltjrh95TIpx8BVGjPl0OmP8MMm//7f/zvSn/0dVhdvkymkOX3PaTZWV3nxpTeY3ncAN/CwDEhJA9OQWBmb93/043zgwx/nz//gTxlFgGXQH/SwLYcg9JjKVrjvwx/n4q0hbz77HOfeOoswLMq1Ap1WD62h2W0zNzfDkf2zbK9t8c53PsRgMMC8dJ3u1g6VyTzZlMWoP6K1ukY/cnn4h3+ateuLRCictEXWMZgopThx/ywf+oGPkzt9H7f+7HGe+P2vUpvZx4EalN/xbmRtDrwu2lCIYICeP4SsHAURoZobrHz5j1nb1hw+MMPEwgFa9U30SHP8x3+e1bMvYo8d58Vvfp4b169z69oyZrbG5KG76XeaNDtbvPLqN1nf6CJMwaDZpVgooFzB7eU6VjbLTrOFk80SGRKRzrHv4HHefOVFeq0WpbEBrudRyOdxMuAjsbNpguEAXwgyjkMrCFBRREoaTJUrVKpjfOrHf4pjJ4/w3Nf/gmMnT6CDEV/73H9kNhdijeLRcdVvsnPjCh3hE83N01pcxKzOMp7WGHaZQrmGbnUYP30Y3enFfy15fnzjm8pAJBHtFbTMMNw2iDApHLYgDBAq+J6fp3s7Z3va05729H2s5s3X4/qgjn8vj5IcyCBOc1SywaW1Amkl6VNsIlQwRKkAIa1ktFijIp9MJkdhbAYjlYv3yJL0Ztip09xaIwwikAZKx4AR0OgoSvgW393kCsIArTSGaQGaSIMhDVSkMC2JUgodhjF0BBA6HkWtTk5RmJgD005Q83HKdSc0iyMntNb4/Rbd5g7dnQ0UipmT95Ny0vHNW2LIhJDoyI1fDU7MF0LcgYPEtUUVUxd19N26ZOAhDRMlZbwhJ21EAkQRwoyTLakTjL9kF8kodpM26SCV/13Dl1AUgcQ0GcnbKRTxBpswDFAxXIRdkqQWSSq3W+00dg/ZkjHqGIYikOjIi7/PuyYv/mAYMvP/85/FPe1pT3va0/917SVne9rTnvb0fazG2lXK00cQpoUAZBR9ly4Y/7oeJy0JYl9okeDWJdJKIaLdSiDYdppccQY7V0TYqbgdGRno0Mft7tDc3iRMKIlKhwnSPf4ooY4R+yq53wKBaVmoSCMMM06dVBzvSUOid6uUhpH4DIVlWVQnpsnXpsC04s9LJUlQpJLbuAh30GLQ3EFhYDk2udo45bkDSGEiRJzcKR0hLCc2YJGX3OHFIBEtEkNjCFBRbP4wkhuwpHKoFMI2UCpCCgNsJ6456mTBTIcgNVoZ361bcgdZAolxU1oik804hJEYxMRsRioBqiR3Z8KIPy8Z3+/doTKik3qiSGqed/wpUlpxRqbjmzNknObJ3Xpk8lntaU972tOevj+0Z872tKc97en7WM+88Dpn7u4xd/getJNJYiAFYYyPR5sJpCKuVgjpIGUqJgqGIVqDbWXJFCvYuWKMJUQmKU1MfNShz6jfRyVmQEVhnPKgk5qeQpoxeVAmw9BCxGZCJrdRQhhYu7tjyBgUkmykSSkxJVTGp8nXpuNtLwVIiRYRYRAyatcJhh2QEmGnKUwu4DiZ+HYuqTgiBVoa6DB5DCIVp1ZaoUIXYWViyEZilAQSCNAySRaJzU2MqweEQJpWPOqtJJgWWgUQBUhpAmaMz1f6DtmR3Xqk0OgwQCYmU0chGAIsB5FswQkjuUcTsRHThozv4CITpIHeTdSEQOso/n4g48deisQoxuPT8ecT1zC12jVzcf10T3va05729P2jvVrjnva0pz19H2vp/PNceONFajmDhWP3YeXKcXoFcbUu2qX4xdU7YVgQxbdahmnhZFJY2WJ8A6bjX/hjw0BsIsIRo3aDdrOB0jGZMQqDJJmBMPRBGFhWGq0VgTdE6xgEIkSymaYT+AbEVcZktwytMKRBOpujOjmLmc7tTpPhD1r0G5sEgz5KGuRqk2RLVaRhIaQJOkhSsJisiCI2oEKioxBpmmid3JCpKAFpJGh6IeLyoZlKKp4x+Su+zYruGBqdYPWFacc4fw0q8pBotNi9GUtqkEol93EyrnbG3cR4ZNq0YgT/Lu5/N1/ToE0TLSQyiuL7NyGTr0nEVUr0d6mLuyPcWiRmMJkX0OxmpN+FfySj2TpB+xsi/dfy87inPe1pT3v6v6Y9c7anPe1pT9/H6qyeJwgC3n79Nfo7t7n/0feRrUzdQeZLiKEcAAJM08TO5DAzeaQZJ2i722G7IAkiBWFIMOzS79Tx3BFRFKHisbCk6rf7V4dBpGNCZGwI45sqlRhArfSdeyilooSQrxAabNuhVKmRKddA2kSBi9dv0G9t4WTK2NkiTi6HaabYHaXeTbhEcjen40mv2BwlO2L/H/beO86K6v7/f54zM/fe7cvSURRFsUtVibHGFE1iYolGo8YSjTH6VfJJ7IUUe0OSX+xEscQSFUkssUXsIGBBBQSpIn3ZvrfMzDm/P86Z2V0BI4oRk/PMw7DcnTtz5sxw73nN+/1+vYXwUGjrcBiZVEJtfeh1jPCkTfr0rMCKzK+EjQcqZRwbVdKAOkYKH4RvXBdVjPCyJsImtHVsVIg47hBkAiP8hLA2/yb9UcSRMVhRGul5pP3cVDJuk3KaRB+Nm6O0fdJER21bItTQgEdH6qK9htDp9yBF9ou5AR0Oh8OxUXHizOFwOL7CtC6dSRRrNBGLFy5m5vQXGDZ8BH0G7Gxqumxqoed7+GXliGyZjTwlJohGcJlIjhVfaBPJKeYJ25toaWqgUCwhPR+BJI5jUCEaIwDjOMazQkwpExVLUuq0VkaMCWl7okUIARWVNVTX1hGWCuSbGwCo6rU5frYMYRtga7sPYycfITQgVVqLplAI6SN0bOrABMioSJJuaPp9JS6MwoodjEDTVngJGy204k5obd0pjUGJlr5NgTRz1ZH+GJh6NsBWjFlHS3tcYe3sO1vzx0WEsGYdtnWB9uz5CWlbINiUSuus2REtw5yLjc4ZEmX68b/ba2CjaaCdOHM4HI6vCK7mzOFwOL7CaCHwPUWsJFtttRU1tTXMefMlVCnP1oP3RFb1RHqZ1PlP2MW/VqGp0bLCwwTOtDWTkGhVIi7laW9tJQxDY88vPVSs8aRn67RMM2vP7ltKD2EdIYUVDEKHYF0jhZQIwFMRxeY1rMm34Jd3o2bzQQS5MpPGp0PbpFoZe3nPphbauisTYfLRIra1V4GpB1OhGbcXmIiaMNFAIzgTO3lpomba9jTTKhVjeBjBqaUVr7ERTEKbGrhEFFlRZQQtNnAljGmiTbE0+7RNpK1dfuISqZWyLpTKpibaSKVUtq+bFVq23QGiU1RMdGoqrZUZG16niKWy75ck3duMQHOGIA6Hw/FVwUXOHA6H4ytM67LZ1gpeI/2AIJsjH0YsnjGFPuWK2p2+jizr3smwz3jua2WFgSrZZtDSpuOZaI+IQqJinjgMUbHpHVMs5ImiyETWkBAXiWJjl0/qGCiMqDJhMhv0iQiEII4isjXdCcqryJZXkclkbcwu6S2mTd2YjW4hfPB9dBgifB+i2OwaidJRalgihOkxZqJR1iQj8dzX1nre1oehQUvPCDBIreeFCk20TWnwcwjPmqJEJWvY4ZlImScQ0rc1eSZVUmtlBJ4ygknIwIg7zzPTHYfGnEUEab0bcSkVd9LzSBpOkzSSJhHLtsbM9lMT9k9to5yJXb6wYjHt1Qbm3G2UzRmDOBwOx1cDJ84cDofjK0xYaDDmHFKYyIt19NNxTOP8GYj6edRsPxJR08/0QLZNn1Uc2oW9Z6JSqE4pdEnzY1O/pFUIUURcaCMs5CkUiqg4Ig5LNm0x+RpRxiXQ84ztfFggyJVTVl0LQQVl1TUI6Rk7eLRxZLTmF0IKa5tvzULikhEyUiISUQUm6hTHNnsvBhGloiQVL1qYsWBFiddxLtiolnFwDJEalIiM2LR90LS2aYcyAGHq78D2GiPRnRrhB6anmxQopUxj6yTRUVnnxyBj5iIRcqnOMtE5tDLjsY2yTe+0pCca9k9txZsHaFt7h/3Znm+a6mivRSdhBk6cORwOx1cFJ84cDofjK4xSYYfvg9BADFqmUaCwcSXx0nfJdu+H6L2t1V+2BgqV5DNaIWDcCs2XglVDtgG1tPVjhCVUoZ1ioY1ie544joitYyM6ptTaaGrKaurI1fUmW9PdpE2qJI0PktCQVqZZNdJEgkTHSYEyfdFM02dsby8TTRPCjE1pZd+jbLqjSeETnm+cD7WGsGR6pnmeTQU06Yk6jjpEU5K9qEFID02MUBptHSa1TY3E983r2lbpeZ5tAm2Fn/AQng9KmLHGMdoPEJ5nNhEeWkfGudHLoOPQvEdIm6mYWPgntWPmwgrhoW3fs47XRRdnxkS4dY2a+en2HQ2pHQ6Hw7Ep48SZw+FwfIXROgKSfleQmFZ0WFQo4tYWioveIFfdDdlvR4SXsYLCOgEmDZRFx/uNABHW5ML+LIX5U0XoqIQqFAjzLTSt+ohSoUBZVQ252p6UVdfi+RkbkaMjU89GgRLBIxEorRFJRCqOTRAotj3a4tgabHg2HdHaw8cxUvqpRT9xRGovH0dG6AjPCLLIRuBsKqbWsTl/KVFRKY1SEYYmSoZEB1kj5KJSOotGD1phlNjlK43w/VS8GcFmepShNAKFUqGp+TMdowFhepwJYd0e7Xn6WROt09oIO0SnlMZEmHWmk+DSMv05EWdJa+sk+tY5iuZwOByOTRcnzhwOh+MrTOoeiOoi0AymAbPGQ4cFSovfRROR3XxHRLbSLuAxokRru4C3cTMTRrJRNdVhamEjPnExT9uKhYT5dmRlD2p69kV6vukvpkJbuuab9wppre9tXzJroiGUNk2uNabGK7aRstj2HFOxCfBJacRaWLLjNZGvJK1Q+oHp45acelLvZhHCs8Krw5lRe6a+TkrPyJnICCYVmx5uJgLnmQbXNvKlVWzr2pQRikm0z/NtXRqpRb4RpYlxh+zobSaESf00G3dE+KSXDN7U8FkhrNKG3snvSQVXEkFLTSKluX46UcR2Qjre73A4HI5NHSfOHA6H4yuMSWs0wsMs2pOPdBvz0UkaHOgopGn2a1BYRe32e6Ire5k6KRsxE6ktu42e0SmtTyuiliaKjSshiijrswVK+PgZz4inpGYqMfbARLpkEn1DGzGWRHBE4qJo7e0Ftk+YTRGUEl0Kwbepg55ERLGJCnrWMVEKoz+lMLb3yXkLCSjzmsYIIImpyYtjm8poI1NKo5PUSa0RUWRK1oSXjhwhTVqm56E9IFKmmTcSHRXNsaSH8gJkFBl7fE92ZIYaFxN7CCuCRXJ97JCTYjQdG/EmfHMthOpyHZPeZ11TFW29XZfoWiK0k/e5yJnD4XB8FXDizOFwOL7CxKpoPDWw0RqSSFrSGytd/ZugUVSi5cP3EfVzqdxqCF73LWy9WOKsqBDa1m5pjY4iotZ6Sq2NgEfQrRd+WRlSShsJktawIom+GYmQRnwSQYEZi9bapisqW28lbF8xbfqVJZEt6SGV6lRXJhEqMpE3sFEpE3FK3CqT2i1i1VEvFsXpGEWQMSYcSplOYBKIFPheR2QrtvVuniRVTlKYaJ4fpK6MWsXGvTGJpIlEhhr7euFnbDqmSl9LG0hD4gpi2gOgESIA63iJVqY2rXOfs+S6SJHuo6PmTHaNpHURaUnKqhNnDofD8VXAiTOHw+H4CmNqzj6+GLfpcToxq+jcnNikQrYuW0hxwet022YYsucAay0vjWhRMTosEjfVmwBVrgyvotakzWnrKNglagOpy6FInBITg4+Pm4BE5ielTFeuxFpeJk2TNUShSSVUKhVr+EF6XkLFJhqGiYqhYlu3Jm3vMsA3Do3CRplUHJk0xmQvnmdqxlSMsumNSGHSGG0ETwQByhqmCG2Em5YCPFNPh4rteZr0zDRypbWJssnARh6Vbchtr48VcgjfijczP4kzYxLF7DzPRrQJk1aZXmc7Z52+xTvqyzqui8GJM4fD4fgq4MSZw+FwOBwOh8PhcGwCuEdpDofD4XA4HA6Hw7EJ4MSZw+FwOBwOh8PhcGwCOHHmcDgcDofD4XA4HJsATpw5HA6Hw+FwOBwOxyaAE2cOh8PhcDgcDofDsQngxJnD4XA4HA6Hw+FwbAI4ceZwOBwOh8PhcDgcmwBOnDkcDofD4XA4HA7HJoATZw6Hw+FwOBwOh8OxCeDEmcPhcDgcDofD4XBsAjhx5nA4HA6Hw+FwOBybAE6cORwOh8PhcDgcDscmgBNnDofD4XA4HA6Hw7EJ4MSZw+FwOBwOh8PhcGwCOHHmcDgcDofD4XA4HJsATpw5HA6Hw+FwOBwOxyaAE2cOh8PhcDgcDofDsQngxJnD4XA4HA6Hw+FwbAI4ceZwOBwOh8PhcDgcmwBOnDkcDofD4XA4HA7HJoATZw6Hw+FwOBwOh8OxCeDEmcPhcDgcDofD4XBsAjhx5nA4HA6Hw+FwOBybAE6cORwOh8PhcDgcDscmgBNnDofD4XA4HA6Hw7EJ4MSZw+FwOBwOh8PhcGwCOHHmcDgcDofD4XA4HJsATpw5HA6Hw+FwOBwOxyaAE2cOh8PhcDgcDofDsQngxJnD4XA4HA6Hw+FwbAI4ceZwOBwOh8PhcDgcmwBOnDkcDofD4XA4HA7HJoATZw6Hw+FwOBwOh8OxCeDEmcPhcDgcDofD4XBsAjhx5nA4HA6Hw+FwOBybAE6cORwOh8PhcDgcDscmgBNnDofD4XA4HA6Hw7EJ4MSZw+FwOBwOh8PhcGwCOHHmcDgcDofD4XA4HJsATpw5HA6Hw+FwOBwOxyaAE2cOh8PhcDgcDofDsQngxJnD4XA4HA6Hw+FwbAI4ceZwOBwOh8PhcDgcmwBOnDkcDofjC2XZsmX86U9/Yv78+Z9rP3PmzOHyyy8HYMqUKfz+97/fGMP7XDz++OM8+OCDtLe38/DDD/PAAw982UNyOBwOx1cYJ84cDodjA3jppZeoqKjg5z//Obfddhu//e1v+c1vfsOKFSs+137DMGSXXXbZSKPctOjTpw/33HMPK1eu/Fz7GTBgAH/84x8B2HrrrRk9evQGvT8MQ8aMGYMQgnvvvReA999/n8GDB/Ptb3+bxYsXb/CY4jjmiSeeoLy8nAULFvDkk09u8D722msv6uvr2X333f8ntnM4HA7H+nHizOFwODaAvffem549e/KTn/yEU045hd/+9rcMHTqUoUOHfi7xEQQB06ZN24gj3XQQQlBWVva595PJZMjlcgD07Nlzg98fBAGHHnooAMcccwwA2223HUOHDmXPPfdkiy222OB9VldXpz/36NFjg9+fvK+2tpZBgwb9T2zncDgcjvXjxJnD4XB8To455hg222wzbr/9duI45vLLL+fRRx9l1KhRPPLIIwC8/vrr/O53v+Paa68lk8lw9913d9nH22+/zbnnngvAtddey3777UehUODMM8/khBNOoKWlhZNPPpmTTz6ZK664gt12242JEycyduxYhgwZwvvvv88777zDiBEjuOqqq/jBD37Ad7/7XYrFItOmTePmm2/mpptu4q677upy3HWNt1AocNRRR3H00UcD8MILL3DxxRcDMG7cOO69915+/OMf89JLLzF79my+9rWvccstt7DLLrsQRdF65+nJJ5/krLPOYvfdd6dQKPDQQw8xYMAAtNZceeWV7LfffrS2tvKb3/yGUaNG8cMf/jBNFbz11lu57777aGhoWGu/URRx4403ctddd3HooYcyc+bMz3QdC4UCRxxxBL/97W9ZuXIle++9N3feeeda51gsFhk9ejQTJkzg73//+zr3NWvWLMaNG8c111zDCSecgFJqvccdNWoUnudx2mmnfeL4/lu2czgcDsf6ceLM4XA4NgLbbrstixYt4vbbbyebzXLIIYdw2WWXccYZZ7BmzRoeeughtttuO37zm9+w6667csghh3R5/+DBg9N6pREjRgCQy+UYNmwYAFVVVfTr148+ffpw/vnnc8ABBzBlyhTOOussDjzwQP7xj3+wyy67sHr1ag455BD+/ve/09bWxt/+9jcmT57M0qVLOfXUU9l///27HHdd421vb+eqq67ijTfeQGvNokWLOPfcc3nuued4+eWX8TyPwYMH8/LLL7P99tvz0UcfMXLkSN5++21831/vHI0cOZKxY8cihODtt99Oz1MIwciRIwGorKykvLwcIQQTJ05k9913Z9y4cfz85z/n6KOP7hKpShg/fjwLFy4kk8mw00478eqrr/7b63XllVem/73zzjvpfO+0004A9OrVi4EDBwKsdY5jx45lwIABHHrooXzve99b5/5//etfU1FRQf/+/YmiiAULFqx3LPvttx8AX//61z9xzP8t2zkcDodj/az/W9ThcDgcn5olS5bw/e9/nxkzZqRpXcnifP78+Zx33nmcc8451NbWMmbMGKqqqtbaRzab/cRjSCmR0jxTS9L7kp9bW1vX2s/XvvY1li9fzhlnnMGpp57K7rvvvlbEbn3jHTFiBDvvvDPPPPMM+XyeyspKpk+fzpAhQzjqqKPWGldNTU06tvWRpDaWlZWRz+c/8TxramoAY/xRV1eX/s7zvLW2nz59Ot/5znf44Q9/+InH78x5552X/jx79ux/u33nc3zxxRc544wz1jseMPOazNPH58vhcDgcjvXhImcOh8PxOXn++edZuHAhJ554IsOHD+8SuQnDkEGDBjFx4kROO+00DjzwQPbee+9P3J/nebS3twOkf34Wli1bxl577cW7777L+PHj+cMf/pCmJyasb7wAZ511FmeddVYaCdl6660ZP358KqwefPDBzzw2MOeZ7Gt959mvXz+mTp2apksqpdBad9lm66235rbbbkMphVKKhx9+GDCC+bOM6d/Nfb9+/dI5W9d4AGpra9NI6Pz585k2bRrFYpHVq1f/2zH8r23ncDgcjg6cOHM4HI4NYNKkSaxcuZJ77rmHm266iQsvvJDHHnuM1157jZ49e3LCCSfQt29fbr75Zm6//XYuvfRSqqurEUJw3HHHMXToUIYPH75Oy3UhBABDhgyhWCxy1llnsXr1atrb21myZAmzZ89m/vz51NfX88EHHzBz5kxWrVrFrFmzmDlzJm1tbQDce++9/OUvf2Hw4MGMHDmSJ554grFjx9LQ0MARRxzR5ZjrGy/APvvsw0EHHcTOO+8MwKGHHsouu+zCkCFDOO644xg8eDAzZ86koaGB559/njiO1zlnS5cuZfHixWl65aJFi5g2bRqbbbYZO+20EyeccAIffPABUkoWL17MO++8w4wZM1i1ahV77rkn3/ve9/jud7/LzTffTO/evXnqqad47rnnAHj11Vf5xS9+AZjU0FNOOYW99tqLMAz52te+ls4JQKlUYsKECQDcf//9gKkNe+utt3j55ZdZtGgRBx10EBMnTuTyyy+nqqqKhQsXrnWOF154Ic8++yxnnHEGzz//PA0NDSxdupTJkyczb948Vq5cyY033sgll1zCAQccwIQJExgxYgQTJ05M6wo/if+17RwOh8PRgdDreuTncDgcjo3KBRdckPboKhaL3HHHHamoSBgxYsTndmwcMGAAkyZNYsCAAZ9rPw6Hw+FwOP7zuJozh8Ph+ILRWrNw4UIOP/xwttxyS7bZZhuOPPLI9PdHH300w4YNW0usbShJhOdf//oXxx9//HrroRwOh8PhcGyauMiZw+FwOBwOh8PhcGwCuJozh8PhcDgcDofD4dgEcOLM4XA4HJsc5557Lv/4xz846qijPrFH2Je1ncPhcDgcXwROnDkcDodjk6Nbt25069aN2tpaevXqtclt53A4HA7HF4EzBHE4HA7HJsc3v/lNdthhB4QQVFRUbHLbORwOh8PxReAMQRwOh8PhcDgcDodjE8ClNTocDofD4XA4HA7HJoATZw6Hw+H4Uvnoo4826e0cDofD4fhPsdHFWXt7Ow8//DAPPPDAp37PsmXLuPnmm5k8efK/3TYMQx566CGeeuqpzzPM/wriOGbChAk8/PDDm9Rx5s2bx9VXX01TU9MXOi6Hw/HV58MPP+Sb3/zmJrudw+FwOBz/ST6TOHv99dfp378/xx57LDfeeCPHHXccV111FQDl5eUsWLCAJ5988lPvr2/fvjz11FPMnj37324bBAFLly7ltdde+yxDTznwwAOZP3/+59rHZ2HevHkcdNBBn3s/K1euxPM8li1bxjPPPLMRRrZ+Pu1xVq5cCcCAAQMYM2YM+Xz+Cx3XxmLmzJmceOKJXH755fz+979n6NChbL/99l/4cZP5+jwMHjz4KzPPDse66N+/P7Nmzdpkt3M4HA6H4z/JZxJnu+++OwMHDuSb3/wmv/zlL7n99tu59NJLeffddwHo0aPHBu+zpqbmU29bXV29wfv/OBMnTmTrrbf+3PvZUAYOHMijjz76ufbx4IMPcvPNNwNGDP8n+HfHaWlp4Yc//CFgxFw2m/1PDOtz8/7777Pffvtx7rnncsEFF3DJJZfw+uuvs9tuu32hx509eza//OUvP/d+Xn/9dcrKyjbCiBwOh8PhcDgcXzYbJa2xqamJ6upq+vTps9bvnnrqKa699louu+wy7rzzTgDeeecdbrnlFsaMGcNpp53WZft58+Zx7LHH8tJLL3V5vaGhgUsuuYRHH32UZ599Nn194sSJ3HXXXdx8882cfvrpRFFEsVjk17/+NX/9618ZNGgQxx9/PCtWrEjfs3jxYsaOHcvq1auJ45jRo0fz5JNPrjWWJUuW8L3vfY9rr72WYcOGcffddzNgwAC01lx55ZXst99+tLe3c8YZZ3Dqqady6aWXstNOO7F8+XLmzJnDLrvswi233MLRRx/NqaeeCsCkSZP4y1/+AsBNN93EgQceyP/3//1/DB06ND2vxx9/nOuuu45zzz2Xnj178o9//CMdUxRFPPzww8yYMYMpU6ak53PZZZcxZMgQnnvuOerr6zn++OMZPXo0++67L1OnTuXOO+/kwQcf5JprruGiiy5CKcVZZ53FCSecQFNTE0cccQS//e1vARg3bhy33norJ554Ittvvz2TJk1a53E6s2DBAiZPnsz9999PW1sbAPfddx8nnXQS3/ve9wAj4G688UbGjRvHIYccwrJly7rs47HHHuP+++/nt7/9LZMmTWLKlCkMGjSIu+++m+9+97tceumlACxdupQrr7yShx9+mBNPPJH33nuPZcuW0atXLyZNmsRLL71ERUUFixcvpqWlhSOPPJIoita6NwFuuOEG9t9//y6RsiAIuO666wC49dZbOfLIIzn77LMZNWoUr7zyCvfccw8XXngh5513HsBar63vnujM008/zcyZM9Nre8MNNzBhwgQuvvhibrzxRorFIsceeyyHHXYYYRjy/vvvryXmZs+ezeWXX77O83I4HA6Hw+FwfPX4XOLs6aef5uqrr+aggw7i5z//Od26dVtrm1WrVnHIIYdw8MEHc/fddwNw7rnn8vOf/5xRo0ax8847p9suWbKEF154gbvvvpu99967y34uvPBC9t9/fw455BD2339/ANasWcPll1/OT3/6U37xi19QKpW47bbbmDdvHu+99x4/+clPOO200/ja175G7969031tttlmPPjgg7S2ttLS0sKTTz7J8OHDueCCC7occ/PNN6elpYVtt92WadOmpWMSQjBy5EjARJR69OhBXV0dF110EbvssguTJk1i0KBBtLS0sN9++3HHHXcwfvx4AGpra9N6vB122IGmpqZ0If/QQw8BMH78eL7+9a9z1VVX0b17dw4++OB0TL7vs8MOO7Dzzjuzxx57AFBVVcWFF16Y7qN79+5oramrq+P555+nsrKSCRMmpCJjypQpPPXUUwwdOhQwUcuddtopPcYtt9zCD37wA66//npqa2vZb7/91nmczuy6664AHHXUUWlvoAMPPJC//OUvTJs2jRUrVnD11VfT1tZGRUUFW221FVOnTu2yj0mTJtHa2sro0aPZZptt2GOPPZg7dy5HHnkk119/Pffccw8Av/71r/nWt77F4Ycfzsknn8xJJ51E3759Ofnkk5kxYwZ77703AwcOZNmyZTQ1NfGTn/wE3193S7+FCxcyYMCA9O9hGHL//fdzzjnn8Nprr7HNNtswd+5crrnmGq677jouuOACfN9np512Yt68eTQ1Na31WhRF67wnPj5fvXr14uCDD+app55i3rx5HHroofz+97/nj3/8Ix988AFXX301b775JnEcM23atLXuz6233jqNoDocDofD4XA4vvp8LnH27W9/O13EPvzww4wdO3atbQ444ACeeeYZFi9eTBzH1NfXs2LFCoQQCCE4/fTT022feuopXnrpJYQQa+3nxRdfpG/fvoBJmwMTZSuVSuk2w4YN47333mPHHXdk6NChPPLII2y22WacfPLJXfbleR6VlZWAEUujRo1ijz32WGednJSSmpoapPzkqUrS+HK5HIVCocvruVyOYrGYHu/fve+qq67i7rvvTiNJ/44kra2srCytP+o87nfffbfL+JN5Wh9//OMfueGGG5g0aRJ//etfP/E4GzKu6dOn8+1vf5ujjjqKMWPG8IMf/KDL9hdccAGPPPII3/rWt7rcA8kcJvMzY8aMVGx1Ppef//zn3Hnnnbz11lt861vfYty4cfzjH//g+9///nrHOHDgQBYtWpT+PQgCdt99d8aPH8/IkSPTeQSor6+nubmZo446ip/85Cf87W9/o1gsrvVakna7vnvi43Q+HyEEgwcPZtasWfTr14+DDz6Y22+/naVLl7L55pt3eV8mk3EpjQ6Hw+FwOBz/RWyUtMZMJsNmm23GqlWr1vrdMcccw8iRIxk0aBBKKWpra1m0aBHTpk0DYPr06anA+tnPfkahUOCWW25Zaz/9+vXj1VdfBUAphdaaQYMGsXTpUtasWQOYxfOIESOor68nk8lw2GGHceSRR643agLGlGGvvfZi6tSp/OlPf6K5uXm923qel4qS9vb2Tzk7G8748eP53e9+x/e//32GDBmy1u+llCilPvX+hgwZwhtvvEEYhkDHPHmel55H5/P561//yuWXX86hhx66QXV5QohPHFfnSE+hUOiSrgkwf/58nnjiCQ4//HDGjBmz3v0MHz48vReScwFjRNKnTx9uuukmrrnmGiZPnozWOr3+y5cvXyu9cdSoUTzzzDPMmDEjfS0Rsh9/SNC9e3cWLlyYuopOmzaNlpaWtV5bsGDBesfe+RjJXHU+HzBpwsl1P++887jmmmvYdttt/+0+HQ6Hw+FwOBxfbdavWj6BKVOmMHfuXCZMmEBbWxtz586lqqqKc845h/b2diZPnsy8efNYuXIlW2yxBWeffTYnnHACK1as4OWXX+bWW2/liCOOYODAgfzqV79is802Y+7cudTV1XH55ZczbNgwlFL87Gc/I5PJACaadMoppzBr1iyKxSItLS1orfnLX/7C7373O/bbbz+klPz0pz9l1apVPPLIIzz++OOUSiVGjBjB7bffni66Fy5cyJIlS3j55ZfZa6+9+H//7//xy1/+kkMPPZSqqqr0PBctWsSSJUt45ZVX2GOPPdhss83YaaedOOGEExg2bBhSSpYuXZoaoaxYsYLZs2dTV1fHvHnzWLNmDVOnTk1d+d58803ee+89Pvzww1SgLlmyhKVLlzJt2jTmz5+f2s9/61vfQmtNLpdL69sSRo4cydlnn83Xv/51pk2bxpw5c1i5ciVTp05l7ty5LF68mLlz51JRUcGhhx7Ktttuy+jRoxk9ejTDhg1j1113Zb/99mPx4sVceumlXHTRRcRxzKpVqygUCrS3t7PbbrsRRRE1NTXceOON6zxOc3NzF3OWfffdl/PPP5/DDjuM+vp6Jk+eTBiGrF69Ok3LO/LIIxkxYgQjR47k6quv7nJf3X777cycOROtNQcffHAq4KdOncqCBQtobGxk4cKFXHPNNZx77rnU1dWxcOFCbrvttnQfSSQ2uRcSkxIwkbVf/epXaVoswDbbbMO//vUvrrzySvr370/fvn1ZsmQJo0ePRmvNa6+9xuLFi5kzZw6DBg3itttu4yc/+Qnbb789Rx55JCeccMJarx111FHrvCeUUuk9uMMOO/DRRx9xyy238LOf/YyDDz6Yq666iv79+3PMMcewzTbbAOahxLe+9a20bq8zM2fOZM2aNel97HA4HA6Hw+H4aiO01vrLHsTG5o477mDPPfdku+22QynF+PHj+dGPftRFeG2qFAoFrrrqKkaPHg1Aa2srDzzwAD/72c/+I8dfvnw5DzzwAGeddRZgIovPPfccRx999H/k+I4OmpqaKBQK3HfffYwaNerLHo7D4XA4HA6H4wvmM0XONnWCIOD0009n4MCBbLnllhxwwAFfCWEGxo1x2rRp/PjHP2aLLbZg0KBBHHvssf/R4z/22GNpL7udd96Zn/zkJ/+x4zs62H///ampqeGxxx77soficDgcDofD4fgP8F8ZOXM4HA6Hw+FwOByOrxobxRDE4XA4HA6Hw+FwOByfj/9acdbQ0MDtt9/O9OnTv9RxvPrqq+tsMfBZefPNNzfq/r4I8vk89957b5dm4Z+HMAx56KGHeOqppzbK/r4o5s2bx9VXX52aunxelixZwg033EB9ff1G2Z/D4XA4HF9Fli1bxu23386UKVP+I8fb2N/nH2fGjBlcdtllX8i+Pw2PP/44Dz744Cf+fty4cf/BEX2xtLW1cdddd220dSlAHMdMmDCBhx9+eKPtM2GjirOTTz6ZF198ETDW7G1tbRtz95+KpJdat27dePrpp5k7d+4G7+OXv/wly5cv/1zjSBwaa2pquOmmmz7XvjozcODAT7SZ/6y0tLRwwgknfO79rFq1irKyMt5+++3UbfHzEgQBS5cu5bXXXtso++vMXXfdxaOPPvq59pFc6wEDBjBmzJhP1QPu09C3b1/uvfdeWlpaNsr+HA6Hw+H417/+Ra9evfjGN76RPvybM2cOO+yww5f+EPQPf/gDd99991qv9+nTh4kTJzJr1qy1fnfggQcyf/78jTqO9X2ft7e3d2lxlHz/bygDBw7kD3/4w1qvz5s3j4MOOmi971tXy6rPQhzHPPHEE+v9vdaav/3tbxvlWJsCFRUVzJgxY6OtS8G011q2bBnPPPPMRttnwkYVZ3/+85/ZZ599CMOQY489dqPdRJ8WrTWjRo3inXfeAaC8vHyD97Fs2TImTZrEDTfc8JnHMXv2bH75y18C5obYmHS2rt+Y3HPPPTzzzDPr/OD7tFx77bU8/vjjwGeb+0/iizrvCRMmcNVVV33m97e0tKR2/Z7npY2nNwae5230+8fhcDgc/9t84xvf4KGHHmL69Olpn9hp06Yxfvx4vvOd73ypYzvvvPM45phj1npdCEH37t3X+Z6JEyduUE/WT8P6vs/Ly8vT6F3ntd6Gsr7v9oEDB673gXHnNdbn5d+tqSorKzfKcTYlvohz2thr3YRPLc4mTpzIyJEjue2229hrr70YP358l9+vWrWK2267jdmzZ7N48WJeeukl/vGPf7By5UpuuOEGnn76aQ4//HA6+4+USiXOP/98jjjiCK655hq+/vWvc/fdd3PzzTez++67p1G4iRMnctddd3HzzTdz+umnE0UR1157Lfvttx+FQoEzzzwz7aP23HPP8a9//SttBPzqq69y3nnnscsuu3yqaNhf//pXHn30UcaNG5eGs6Mo4ne/+x0//vGPue6669h5553TPlbrGtvTTz/NzJkz0ybLpVKJ66+/nm9/+9tcfvnlAMyaNYtx48ZxzTXXcMIJJ1Aqlbjiiiv42c9+xkknncT111/fZVx//vOfueeee7jjjjvS15YuXcqVV17Jww8/zIknnsh7770HwLhx47j11ls58cQT2X777Zk0adInnnMURTQ1NXHmmWd2ESpLly5lv/3246qrruIXv/hF+jQnjmMuv/xyHn30UUaNGsUjjzxCS0sLjz32GFOmTEnn5t1332X06NFd5uuBBx7g3nvv5YQTTuDhhx9myZIlfO973+Paa69l2LBhLFu2LD1+Q0MDl1xyCY8++miXUPS65rxYLPLrX/+av/71rwwaNIjjjz+eFStWfOJ5P/3005x33nk0Nzd3maP13euzZs3i+uuv54EHHuD444/no48+YsGCBUyePJn7778/jRTfd999nHTSSWlvspaWFm688UbGjRvHIYccwrJly3j00Uf59re/zVVXXcURRxzRZVz/+te/GDNmDA899BALFy5c75wDvP766/zud7/j2muvJZPJrPOJo8PhcDgcndlnn334v//7P4477jgWLFjA8uXL2X333YF1f980NTXx9a9/nTvvvJNFixax7bbbMmnSJKZMmcKgQYO4++67+e53v8ull14KwPz58znvvPO45ZZbKC8v54orruhy/HV9Zy9atIh77rmHyZMnU19fz/HHH8/o0aPZd999mTp16jrPY/HixYwdO5bVq1czZ84cdtllF2655RaOPvpoTj311PWe/7Jly+jVqxeTJk3ipZdeoqKigsWLF9PS0sKRRx5JFEXA2t/n06ZNS0tLOq/1oijixhtv5K677uLQQw9l5syZXY43bdo0br75Zm666Sbuuuuu9PWbb76ZH/3oR/ziF78AYNKkSfzlL38B4NZbb+XII4/k7LPP5mc/+9laa6yEK6+8kgcffJDTTjuNt956a71rt2KxyOjRo5kwYQJ///vf1zs3CQ0NDZx11lnsuuuuacBiXeugadOmUVZWlpYRnXLKKcybN6/LvsaPH89tt93G2WefzVNPPbXO6ztu3DjuvfdefvzjH/PSSy91ef+67sn29nbOOOMMTj31VC699FJ22mmnf7vOf/vttznuuOPYeeedeeGFF4C116Xrm78oihgzZgwPP/ww3//+91m0aBFg7sHLLruMIUOG8Nxzz/3bef1U6E/JggULdL9+/XQcx/rJJ5/U3/nOd7r8Po5jfdhhh+nnn39ea631lltuqRcsWKC11nr//ffX06ZN0x999JGO47jL+8aNG6ePOeYYrbXWN910kz766KPTn08//XRdX1+vd99993T7k08+Wd944436+eef1/vuu6/WWus77rhDH3/88Vprrffdd990DMcff7y+8cYbtdZaH3nkkfr+++//xHNsaWnRY8aM0Vprfeyxx+rLL788/d0dd9yhjzrqKK211ueee66+4oorPtXYFixYoPv06aOjKNIzZ87U22+/vdZa64MOOkjfd999+r777tPHHHOM/uCDD/S4ceP0IYccks5nwpQpU9Lzi6JIb7nlllprrY866ig9bdo0rbXWL7/8cjqW3XbbTS9btkyvWbNG77HHHp94zlprfd999+m5c+fqhoYGXVdXpxctWpT+bt9999X//Oc/tdZa9+7dWy9btkzffPPN+tprr9Vaa93a2qr79u2r6+vr9fHHH6/vuOMOrbXWo0eP1uecc47WWutzzjlHX3nllfr999/XP/jBD/R9992nb7jhBj1q1CittdZ77723fvTRR9e6N0477TT9r3/9S2ut9e23365Hjx693jl/77330nvy+uuv1zfddNO/Pe/f//736b6//e1vp6+v714fOXKkXr16tdZa63vuuUcfeeSRWmutO/8z2nLLLfXMmTO11lr36tVLL1++XF900UX66quv1vfdd58eNWqUnjhxop43b57u0aOHjqKoy3m3tbXpESNGpH/fa6+99IIFC9Y752effba+7777tNZaDx8+XDc3N//b83Y4HA6HI4oiveeee+r99ttPl0ql9PVP8x3fea0F6EKhoGfNmqW32247rbXWf/7zn/UVV1yhtdb6hz/8Yfq9mLCu7+w4jvX//d//pcc47rjj9A033JB+R3Y+fudzGD58eLre3HLLLfXs2bN1Pp/X2Wz2E8///PPP12PHjtVaa73LLrvoyZMn6w8//FBPmDAh3dfHv88bGhrSNVjntd7tt9+efh9feOGF+rbbbutyrD/96U/64osv1nEc68WLF6fz1t7ertvb23Uul9Naa/3mm2+m+3zuuef0kCFDtNZmTbiu89farGWiKNJjx45N1zXrWrtdddVV+i9/+YvWWutnn302XVeui+eff14PHz5ca631ypUrdXV1tV66dOl610H/7//9Pz1mzBitlNJXXnnlWvsbO3asrq+v1xMnTtQnnXSS1rrr9X322Wf1CSecoO+77z592WWXdVl/a73+e3L06NH6vPPO01pr/eMf/zhdD62L0aNH61//+tdaa60fe+wxveOOO653Xbqu+bviiiv0Cy+8oLXW+sknn9QffPCBvuOOO9I5uPHGG/UvfvGL9R5/Q9igPmdBECClJJfLUSgUuvxOSrneXmLXXXcdxx57LPvvvz9jxoxBStnlfb5vhpHL5chkMunPra2tzJs3j1KplG4/bNgw3nvvPXbYYYdPNeaysrL0z39XC3TPPffQ1NTEDTfcQK9evRg7diy/+tWvyOVyAGmIOzn/Tzu2bDaL53ldxjBjxgyOOuoogPTPl156iZqamnReEl588UX69OkDmFB7wowZM9K5S44N8Mc//pEbbriBPfbYg7/+9a//do6efPLJ9GnDjjvuyHXXXdfFdOTj5z1jxgwGDRoEmNB8//7915nv/fG5f+utt9h6663T802QUlJTU9PlnJPzPvPMM7uc9/rm/LTTTmPo0KE88sgjbLbZZhx22GGfeM5vv/02ixYt4oYbbqBUKjF58mTefPNNhg4dCqz7Xv/4fH/8SeD6znv69OlcccUVDB48OD33hQsXUlFR0eV6AsycObPLa8nP65vz8847j3POOYfa2lrGjBnzlenn53A4HI4vF8/z+Na3vsXChQsJgiB9/dN+x3cmm812+b488cQTOfPMM/nnP//Jaaedtta6aMcdd1zrO/vj68j1rQ0+fg4fT1dLxlIsFj9xzD//+c857LDD2GefffjWt77FuHHjGDp0KKecckq6zce/z3v37r3OfU2fPp3vfOc7aZnDxzn55JM59dRT2X333btkuCT7T+attrY2/V1y/snP6+Pb3/429913Hy0tLcRxnL7+8bXbiy++yBlnnAGw1tpjXSTz2rNnT7bbbjuWLl263nXQeeedxz777MOOO+7I/vvvv9a+vvOd7zBhwgS01ukYO1/f6dOnM2TIkLXWhwmfdE9+/Dw/zTntv//+LF68eL3r0nXt95VXXkkjqAceeCBg1u0bojM+LV+YW6OUEqUUYMKRb731Fo2NjRtcbDpo0CCWLl2a5kXX19czYsQIPM+jvb0dIP3z48ddH0uXLl3rtSiKWLp0KaNHj2bUqFFcd911DBw4MA0vb8jYPs0YamtreeCBBwAT/v+kIsV+/fqlZhhKqTQ1dPjw4bz66qtdjg0mNfPyyy/n0EMPTfOwlVJdUgYTnn32WY4//nhGjRrFqFGjGDduHOPGjWP16tXrHU/n44JxUxw0aNC/Pe+tt96av/3tb+l8PfLII10+SNZ13slxkvNe35zX19eTyWQ47LDDOPLII9MPj/r6+nX+Y33ooYe49dZbGTVqFOeccw5nnHHGesXWus6783wLIf7ted98882A+QBO0l3XRZ8+fZg9e3aaUpuc9/rmfOLEiZx22mkceOCB7L333p84fofD4XA4OqPX0ep2fd8361t3rYvJkydz4IEHcuCBB66zjm1939n/SQYMGECfPn246aabuOaaa5g8eTJa6089ls5rnq233prbbrsNpRRKqbUc/N59913Gjx/PH/7wBy6++OLPNN51rbHy+TyHH344xx57LD179vzEtci61lSfFs/z2GGHHda7DurXrx/f/e53ue6669L02M4cdNBBHHbYYWyxxRbrHOPWW2/N+PHjU3HzcSfJ9d2Tn5XVq1ez7777btC6dMstt0wdLFtaWtZKL+3M+taen5ZPLc6mTZvGmjVrmDdvHq+//jpLly7t4lKzfPlyPvjgAyZPnkwcx+y7775ceumlLFy4kPPPP5+nnnqKgQMHsttuu6XvKZVKzJgxgyVLlrB69WpmzZrFBx98wKpVq3j77bf54IMPiOOYv/zlL/zud79jwoQJSCn56U9/ypAhQygWi5x11lmsXr2a9vZ2Ghsb2WeffRg7diwvvfQS77//PtOnT2flypW8//77vPHGG2it+f73v9/FxTGKIi666CIaGhrSqExbWxsDBgzg8ssvZ/r06bzxxhvMnTuXFStW8PbbbzN79myy2ew6x7bDDjvw0Ucfccstt/Dyyy+zZs0a5s6dy2uvvcaaNWuYP38+N954I5dccgkHHHAAEyZMYJdddmHatGm8//77fPjhh13m/ogjjqBPnz4cdthh3HnnnVRVVTF16lSuueYapkyZkubL3nbbbYD50Nxtt90YPHgw++yzD++++y6vv/46P/3pT7vsd/HixZxzzjlpZBA6imDPOOMMFi1axIcffsjUqVNZsGABq1ev5s033+SEE06gb9++3Hzzzdx+++1ceumlVFdXs9dee3HnnXfy6quvMmPGDN555x1WrVrFjBkzePfdd9lll1049thj2W233TjqqKPo06cPS5YsYcmSJbzyyitrPXG46qqruPHGGzn77LN56623WLx4MVrrdc55FEU88sgjjBgxgl133ZWTTjoJpRSjR49ORXDCo48+yksvvdRFgPbs2ZOHH36Y++67b733+rhx43jwwQd5+OGHmTRpEldffTUA++67L+effz5Tpkyhvr6eyZMnM3fuXFavXs20adO44IILeOeddxgxYgS/+c1vOOCAA3jllVeor6/nzTff7DK2zTffnAsuuIDvfe973HDDDfi+zwsvvLDeORdCcNxxxzF06FCGDx++1rk6HA6Hw7Eu3n//fV5++WXefvvtLt9F6/u+OfTQQ7nxxhsZM2YM/fv3Z9asWemD5alTp/L666/T2NjIwoULUUpx/vnnM2zYMIYOHbpWC6B1fWfX19czc+ZM3njjDRYtWsTcuXOZOnUqTU1NLF++nJkzZ/L22293EYYLFy5kyZIlvPzyyyxYsIA1a9akYwHW+o79OKeffjo/+MEP0rVEEvmaO3fuOr/PkzXdrFmzuqz1kpqxwYMHc8opp7DXXnt1Oc4TTzzB2LFjaWho4IgjjmDy5MmAEbHJw/dk/x9++CGLFi3itddeY/HixcyZMwegyxorQUpJdXU1p5xyCvl8nqeeemq9a7cLL7yQZ599ljPOOIPnn3+ehoaGdQYrwIilyspK7r77bm699Vauu+46ysvL17sOAjj++OPTyNLHGTBgAKeccgpLlizhjTfe4MUXX+xyfQ899FB22WUXhgwZwnHHHcfgwYO7vH9d92Qmk+Hdd9/l3XffZcWKFcyePZsZM2asV6COHDmS+fPnc//99/O3v/2NW2+9lREjRqy1Ll29evV652/69OkMHjyYSy+9lEGDBjFt2jTmzJnDypUrmTp1KnPnzqW5uXmda88NQegNkc6OTZ7ly5fzwAMPcNZZZwHG5vW5557j6KOP/pJH9sVyxx13sOeee7LddtuhlGL8+PH86Ec/+q9P87vgggtSk5liscgdd9yRfkk4vjgqqjNoLdBao7UCDQjQyvwJIBAIT+D5Hr4nyXk+dZks/XJl1Pk+OS2IFURCU56T9K3K0TfrUecLKvDJ+gG15RV0y1VRI8so9zNktcRTAYgMaFBRTDEs0djezur2NhY1N/Bm40peb1nDW4UW2pQCIdBSIAV4ApQGbf/DvhYDAonG/EIITXlVFd8/9HAOOuBgtuzbB88LqG9uYtIrz3L3XbezekU9aI1EoDFT4AOdvxalJ/A8SXVtLQO23IJ+3XuT8TPEccyyVSuYM+8DmhqbCOMYjUYCQpv9KW33aqo60XZipQfJc0UNaAFSCyRgthLmGiTXQQsQGiEEsQRhfy3RCO0jhEYJjVYCidlWC3s8ZbeV2rwRASiUHZMZhEBIaf+qzU0QayIFKjknKZBCkPElUkikFCAEwsy4vV8kCoW0t1OMSi+U0hqtpf2reU+sFLHWoBQCgUKbcxMCKSUZ38P3fTKehyfNiSuh8ZQGLYiFuSdA4wmBSkcjQGozDgFKgIg1KtYoNLG2sy80Qsh0qpMxRXGEVpooVihlr6EQ5t+DMHPVUO/ag/y3c8kll3DxxRcTBAFRFHHLLbdw+umnp7//X/3O/m8kDEPCMGTs2LH88pe/TFMxHZ+d/3wc2fGFEkURjz32GK+//jr9+/dn55135ic/+cmXPawvnCAIOP300xk4cCBbbrklBxxwwH/9h7zWmoULF3L44Yez5ZZbss0223DkkUd+2cP630CDsIvzRIwIZQRAstwWwggGCZT7Hv0yOQZkyunjBdTigYCi1BSERuLhhVDUMW0qIlA+VVlJDZI636eqPEc2qEDIMvADtJ8BBL7W+FFIeXs73Vub6ZXN0jObY7NsOVUtK5jc3khTFCOFWbiny2gtEBqEhlgaQRMLZRbdWqMQCC0IfB/fEx31DloThSWT9qE1WmkjiKQHWhNbcZAICCE6hJJAIqy4iLVGa4i1JkwkgTZzaTbvJBTsn8puE9sfpD0foY0oU1aUaa2RiVoUHcIRjABDCnTyXqHNkeyhIisBpRB4GmJh9FFk3oBAmblEos2BiSVG+NrxKyEQAhQKYQWbRiCFFVcStJQILexZYcdtRY/URuRrbdKOtNlACwV45o7T5npKjHhSmG0FVqR65sYTUpt9A9JcVTQCJTEiUQNCIaRn512ZGbD7N/eJucZakgo2rY3oNBpTdgjV9NrZkxIapcFoW5EKY8d/Py0tLRx++OEMGDCAgQMHrlWL9b/4nf3fyt///nd+8YtfcMMNNzhhtpFwkTOHw+HYQCoqsyBAaZVGM4BEBZiFs5B4nqQiEzCorJJB2TL6B2XUyYCclkRo8jqiKDWlQJLNSCoEVKHpLQP6ZMvpVV5Dt8pqctW1iFwlIM3C3gvQnmcWxkKiY40oFYlbmmhvbWJFSzOzGht4tWU1k1pWML/QSmhFSwQQK2K7TFZ0ym8XyWIcqrvVcPiPj+ab+x3IZj174UufVY1r+Ofzj/HXe8bTtKY5jfKY94GSyW6McvCFxPOhqraagVtsQ+/u3fGkeZK+YtVK5sx/n+bGViJlBIcUolOwTHcs+q2gE8LExxASLxF92go4K4wFIr0eQoAWRowlQlFqiS+FkXNCAgolpNmFfa+y4s+zl1RomUamADsWYQUWxGg8hIn2aYUGolghbeRISg/pSTwp8T0PTwqzvdAobcNzWtpxG8GmtDL3lxJp5DCJzmllxJ/SmjiJTmGjfMJD+oIg8Ak8j6z0QUqESC8WSoCPh5SgpUAoaUW6MvOpNMKKbY1AqBgVYyKMOhGURrSnYlxJlI6J4ggVx0SxifihbERPyvTfRb2LnDkcDsd6cZGzL4E4jvn73/+OUorDDz98o+zz8ccfp62tbZOOnCxbtoyHHnqI733vexulYWR9fT0PPfQQ+++//+cqDHU4NpQkpvPxKIAWGk9KPCGJBGR8ycBMOUOyVWybq6BXUEa5kAilKcYhhRhKaEoaZAwVUlLn5+gV5OgZVFDjV5P1qxF+OVoHJo1MxaBKiNgDz7MLbw+dy+BlelBVUU22rJGaskr6VlezQ2MNLzYv58WWVTSWIjytiYVn0+XMgt0ElDpFvBAgJdIPkJgoj3HZUkRhjLapcclCXWiNstEobaNdPhJp09m8TulvVl4RC02kTaqc2QddkvwENsKVHAM6IjootE7yFoUdsxECHXl2ZoxWXqTCD2GObc8SJUyEx0uicEavYWJNmiS+JbUgtgLNE0aI2bghdkTp35SNeCl7FC1s/MxGoxACrc1MSJtKqqwoM1IrucNstPHjd56w848VoJ23SW9MhcAzUyDMfKXRRoS5l+w8aAG+NlEwJXR6pFQpI23kDjwEkbBZnnYrKcy9n+zdjEt3Go9ILlUqcB0Oh8Oxbpw4+5QopTjqqKPWcpDZUFauXEmvXr1YtmwZM2bM2GjiLI5jnnjiiY0uzl588UXeeOMNRo0a9Zn30d7ejtaaPn36cM8997DbbrttFHFWV1fH008/zXbbbefEmeM/ipDYlLUkamMWpYHnUZvLkZMeEYruXsCI8lp2q65j87JKKmQAKOIwpBR7lEKPkopR0tQhVWUCumcq6JYtoyZbQa6iGlFVAZ7XqbLLRFBEHEIcgvDA8xFSgiehLEMQdKdHeTmVzWX0zJSxWVkZ/XOVPLnmI+YXW42MUKbSTNs0vyTNUQNSawLfIxv4BDY9TkgT1QmjIrGK8LCCTGm0FT5CJel2poLKLMzN34RI5JARgkJ3CAyNiZrpDknQNeUQG/lKpF8iKJE2xU50El0daY06rXcyexVSgFZWhJnIl0dS39ZRBxZI+15tRYY27xVpMC+ZM5WmEyYplirZPpFmdm5kWnOlbUTPnrmdc0UiaOxxMdErpEZr0VWk2Xo8iUkbTERaIgSlPWdNh9hORFEimIU04/PSyjibVJrU/FkhJ9N4pJnDWApkZ2EsNFLZRFQrAKWtYeuc7iitKPwCTaIdjo3K448/zvPPP8+AAQOorq5ey1TNbffJ2zk+O06cfUomTpzItGnT+Oc//5n2N9hQHnzwQWbPns0ll1xCeXn5Rh1fdXX1Rt1fwsMPP8yjjz7K6aef3qUPyqclDEOOPfZYrr/+egYMGJD2g9gYCCFcjrrjSyNZwAoh0Aqk79GrpooefgCxQkrYPlPF4Io6tquuo3eukkBK4jgmiiKbAqaIdAxCEnge5b5PRZClLJcjKCuHygrwMzbckBQ1xTZ6Zuu+pAdxZCJoQRb8AJHJoYMMuWyWzXPlVJXlqMuW0dfP8WTjR0xvaaDVLrAjGwGJ6agLAuPc6ssMSB8blyKOFWEYo5QVFdZdJE0nTMI40vws0sW+EQ0KbUxJbI0UypxTKjxsbVKyT+yYdGdzkKSOTGMidwJiIfFIon+qQ8Uk47GFV0KbqirS9Ejzmkykh1YIaVL8knQ8LWw0UBvxl9SRocz1T6JlwgoqFduoWWJSorWtKUvMYzxTy2Xrr0zETRp5ZO+FtOJOSBPdNMrXSCUt0CKpATS/s0mPVvakUjEVskkQS0sbBUxEo5VeqtP9pdM9dpir6KQgTifpmGYfJugniO17YpL5tzbddr/GWETbGrVPbjPjcGwqdO/endraWurq6ujWrZvbbgO3c3x2nDj7lLz33ntcccUVXHnllak4a2ho4NRTT2XrrbdGa81zzz3Hyy+/TC6X44YbbmDLLbfkjTfeoG/fvvz85z/n4YcfJo5jpkyZAhgr+8suu4y//e1vXHfddRxwwAE88cQTNDY28uqrr7L99ttz9NFH83//938MGDCASZMmce2116btCIrFIpdffjlDhgzhpZdeSsf6yiuv8Pbbb1NZWcmkSZO44YYbqK6u5vzzz2fXXXflj3/8Iz169OD6669n2223Xe85z549m7333ps5c+Zw7733csIJJwAwZcoUjjvuOC6++GLuu+8+9txzTy666CKWLl3KXXfdxbbbbstjjz3Gb37zG3K5HC+99BL/+Mc/+PGPfwyYptf33Xcfr732Gi+++CK+73PrrbdSWVnJhAkTuOyyy2hsbOTMM8/ktNNO48477+xyfm+//TaPP/4422+/Pe+88076+sfn/Je//CXz58/n1ltvZauttuJXv/oVF198Meeff/7GuSkc/7MYIaLtglyQyfhs0b2OXXv3pGd5BcU4Jm5tZ9vIY5vyKjYrr6I2V2HEQxzblDi7CNaxSf2THr7v4QVZRFkOclmE5xshIW31k7ZKBm2cMYoliGMjnQIfcmXobAbhZxC+D9ksnu9Tmw3IBgEVmYA+uRwDcit4tmkFy/IFm5qYiLKOcUlP4ns+vpC2NgtiHVtDEJWm4SVGHdZNJHU8xCYEJiIhEUwmy04TaYW18QBMmqAROWZDpTtSIJPokxYduksm0T4SmwsrTZI0x855ftqKKh3b2jPVIdyE6LieANqYfsjkWKlLiTFg0alzpMZTNgMyGbNKfmPGh04cF72OIJIVWUmKoSn8sufeqeZOSCOG0xNRiUROImY27VNqPG3nQGobfUsqCTtFzOw4jZujtvecNqdnw28xtu7MnC7KRhmT48ZS4ieRyUSRWqFubs8oNTHxJKCs9NRY4xD7PofjK8Cuu+6K53l07979Ex+ou+0cGxsnzj4Fr7zyCnvuuSf77rsv5513HpMnT2bkyJF069aN8vJyttpqK0499VRGjhzJW2+9RVNTE/PmzWPUqFEccsgh7LDDDuy7777ssMMOAOyxxx7MmjWLqqoqLrzwQurq6njooYcYPnw41113HaeccgqDBw/mhRde4IwzzkBrTV1dHc8//3yXLvFjx45lwIABHHrooVRXV3P33XejteaUU07h3XffRUrJhx9+yGWXXcZFF13E3//+d6644gpyuRxTpkz5RGEGMGHCBM455xy6devGGWecwfHHH48Qgj322IO5c+dy5JFHsttuu3HIIYdw0UUX8etf/5rf/OY3DB8+nD59+nDSSScxZcoUKioqOPjgg+nVqxdgek0cdNBB7LHHHrz99tu8++67LFy4kGHDhrHTTjvx6quvctJJJzF9+nR+9KMfceKJJ3YZ10knncTLL79MWVkZEyZMAOCpp55a55y/8MIL1NbWcuqpp/Lkk09yyCGHbMQ7w/G/itYmGqBtZKVXVQU79OnFzv1606uqBqUlXiGiW0uBblGW6vIqcpXVCN8DHUNica8TEaNBeqhMBlFRAbmMiYyVQrOtxhwsWdCDUS+lEF0oEKsIjcLLZJCVFehcBWSzEGTB85AV1ZT7AQP8DDVelh5Bji2CMp5qWsH01kbCOE6dBqUVPJ4f4AUewkuiSiZ9OoxCiBVCWQOORI1os9DXQuDbJDYtNGZkSfRIECsjAKUWYI02lBVPidul1iBlh6hLauF0pyhaEh9KAmNKJ6mRdh9Jmp8VjKa+zggWabVLkg5o/ipNSiCglUILYeekI83Q/CnR2trp23kx5ooqFS1KJ+mYRmx5NhKo7LnEaWyLNKUwuRd0cq21SiNfoGwapZkHZV5BYGrANCZ6CKYeTibRt2QM6e1jI5hC4lsvUTO3sQliaiNKFRq0TNNFFeZ+9ez+EuEqY4h00p5BWRMTnc5LUo+XiHszhx2pjg7Hpkx5eXmX3rxuuw3bzvHZceLsU3D//fczcOBAZsyYwa677soVV1zBxIkT099ns1kAcrkchUKBGTNmpB3mhRAMHjyYWbNmrbXfJMWvrKyMfD7PnDlzqK6u5qijjgLglFNOAUyTwZqami7CDEw92BlnnAGYFCQwXc+XLVuWbjts2DD+/Oc/U1VVxcknn8z48ePJ5XJcdNFFn3jOK1euZMaMGfzpT38CoKmpiUcffZRDDz20y3kn5wx0Oe9hw4bx3nvvrXPfHz/v6dOn853vfGctq11gLVvW1atX89FHH6X7SM57fXN+4okncuaZZ/LPf/6T0047LRXIDsfnQndU4VSVZdiuTy8G9e3LZn370L1Hb8hUUGrNU9bQhm4LjSgoy0ImMKl/QlinRRsp0pjITSYLmYyJlEkBvhFfItZGpJFEhTTEMYQhcRQSqpBYxXilIn6hQFBeRFRVQllk0iIzOUS2jKDOo2cmRy6ToybI0CfI0d0LeLm5noYwRKYFXuAFPp7vp6mJACpWRKWi6a0ljJW+nRBbbySSkIt5i5JIaaM2Kqm9wgb+FEophDaRoCTCI8DUd3XsOY2GJbolCaFpkaQsaqQN3yWpeEpZcSMSoWBq6YSMMLb+tjNap/RCKYRxsxQgVWLXj3Vw7EhhTMWo/S8RgZEwiYJJxE9ZEa+sC6Nn7D+Q2ph1QCKGrP28jYxKa5RitLhOBVsSlxOp7DGCK2mHYDNKzRbi49FQc6ICm/6JaRXgac+K5+T+0ja6aM1NML8yWY1WTlqjlUiYHnla2YiiolMbgDTgiEbZVFJhEzgdDofDsT6cOOvERx99xGabbdbltTlz5jB8+PA0pe+EE06gf//+vPfee+y0007r3M/w4cN56KGH0r83NTUxZMgQZs6cSRRF6z3+Fltswb/+9S8WLFjAVlttxTPPPMOIESPWu32/fv149dVXOfDAA1HKPHnt2bMn1dXVaff6+vp6RowYQRRFLFq0iF/96ldd9tHa2kocx2uJoDvuuINbbrklrWWrqKjgiiuu6CLO1nXer776KoMHD06PC0Zcrq9jO5hO9LfddhsHH3wwYCJ26zNKqampoa2tjXnz5jFw4MD0vNc355MnT+bAAw/8zHWCDse6iIWJWGQCn81qu9G/Z28223ZnNt9xF3r37EMcx7StaaK4ZCksX0WpPaQsjhAyi/AkCI8kcpLEQZIeYEors4D1TK2ZiEKz4k0aF+sAIypKoBVxHBKpkFApIqUQpSIVUUi2FOJVhVBZbsRkJkAEAaKmmuogw8AgoCzIkgt8KqXPk43LaQ4VsW3C7Ac+vvRTC3StNbGKKEUhsTaW/GnzYy3Q0vT6wuqzpJ+YiYwlKZBJXps1u0gs720Iy4gRYY07OlIOBSZlMBHFiUukshGwRGwkwkxqkQqepEYsMfPQSlqHS9LmyzJJjRSJkCTdf2oAYl1IkkChgDTa5Akr/Egid0bmmLosmzaqBckpJw2l08IzLRB2RtFJTZ4VVB2K1EbS7IzYE0p6tmm0yZAUVugnph26kxmH6HhNWGMPLYwoNdFLaefKHk8IE8G1qZdpZFLbceg4FXDJXGmb+mmuq5nb2A7X1PC5mjPHV5elS5fSr18/t53jC8U9wrJ8+OGHfPOb3+zy2urVqznzzDPJZDLpa+3t7fTv358zzzyTRYsWMXfuXKZPn86yZctYuHAhb775Jt/4xjc4+OCDueqqq/jrX//KMcccwzbbbMPIkSOZOHEiTz31FNOmTWPOnDmsXLmSqVOnMnfuXMrLy7n00kv5xje+wWGHHUahUCAMQ+bOncvUqVNpamrqMr4LL7yQZ599ljPOOIPnn3+ehoYGli5dyoMPPsiYMWOYMGECCxYs4OyzzyaOY1577TVGjBjBrrvuymGHHUZrays33XQTY8eO7bLfV199lQcffJCGhob0tZ49ezJ16lSuvvpqpk2bBsDUqVN5/fXXaWxsZOHChVxzzTVMmTKFBx54gHvvvZfbbrsNgH333ZdLL72UV199lcWLFzN58mSWLl3KokWLmDZtGr/4xS8AGDx4MKeccgp77bUXr7zyCgDPPvtsl7EFQcCNN97I0UcfzZVXXklzczNTpkxh//33X+ecK6U4//zzGTZsGEOHDl3rXB2Oz4TtLZULfCqrq+mzzU5stv0Qem2xDZnqarLlFWTKy5AV5YSepKgVURwByix0BdhkOPNfkuqolImSaWvYoGxbZGnEnBagPWncGzOBibLhEYYxpWKJKAppC/PUtzbT0tJI2FgPjc2IfDu6mDfRNk9CZTnZHr3YrEcvhtf15Qc9+nNgbV9qMgG+lASeT8YP8HxhxJn9pohVTFgKQVnzCZH0w0oaUpv6JZWm8GHLrswPnk5S5kw8J0lhTAxEpBSdnAats6AUpj2BZ/4T0rymRcfxlT12nPSdI4nY2HRCGyFTKLRQSaIlMdqqhhgttBF7NkoWo4m1sv3EFFIpRNJ7zAoQYdMx41inQs3QkeKphTTHAav07PGtMDPRR2ujnxRvkaQ7Jr3NMJFKbWq4VBI2S3aZCuIkkoiNuClbw5fISbsvTLRSS5WKPJv82CGU7X9SSjwh0v5sxvkxSXcU9vrGKB2iVGTGqFOvF5RMjEA6RTodjq8o3//+95k7d67bzvGF4ppQ/4/wzDPP4Hke3/jGN9Ba8/TTTzNgwAC22267L3toXyiXXHIJF198MUFgGt/ecsstnH766V/2sBxfcbIVAZ6U1FZXMmSHHdlz+N7ssMMO9N9sSyqy5ZTaWyg2NNCyeDFlHy6hV0s7fbRxF9W5cmsWmCxSbS5YrIy9e7YMyrMmMhGWIMSGJZQVcBh3xrCAzufRTS20tzbR1N5GPiwQExOrmIzvU11WQVW2kmxFJbK6Cl1WiQgCCDJmjVwMKTU2sGLNat5Ys5RHG5cxqWU1BQ2Ddt6Bww49mmG7DKemogqlFO9/MJPx9/2FF59/ARUptLK2IDYq4glj5y+kxGYcA4JudXUM3HIretXV4cuAQhSyeNmHfPDBBxTaC2n0RSaCILGfl6Z2CiHQykRylDWZiJRCxXF6TZLoGZ3EXarUkiiQ2RDP5lpKRCdnERN2UtbeUGojuFBGhAil0UohhG1CjQ16KZ0avEhpBVdSa2UvL0n/OynwA4knA5uGrW26oq05SwxHbLqk1sZQJalVM//ZYySpg7Kj+bdJOQRPGqEbSB/fC8zcSNN3TtpIoydMBFEBxFbGCm2TLUUaLU1cMz3hmZ/tcWOtTN+7KCaOIiIV29u0Q3R3iG0b9ZWmCfXKlV0fNDocDoejA5fW+D+CEII//OEP3HvvvfTv35+99977v16YAbS0tHD44YczYMAABg4cuM66NodjQ/FsbZUGYikoRBFt7QUa2toRXhatFKWmRvSaVYi2NigW0XjofAEhffA9TOKC6TWWBNGEBopFiKIOdztl68u0Nilmyv4ZR+g4Aq3xPZ9skKUQlygWC4QqJl+KKEYRcayoBspiECWFLssgsjkIsuggIKiupmcUsgMxeSTtxExtb6EskyPjZ4x2wZhGhCoiUmGid0jqvYTtb5XUhoFJLUwW/EYYCYwhR1IzZyq4EvMKiVnMJ/6NUhohoZEIrUyqIxrPk8RK4UtJhInmycRREWEt8IUdi0Dp2Frsd2yTNIfuwOYDEpO4P6aVXYl9fpoVKPCEaUiNFWVJLVfyqFMK0NKmS0prlW+jUEKbpt7Cmm8k4isWEk3cESlLBJKyhiZJHZm9JwTGwEUIhdAy6W1tNKa278ezJ22bBWhlji3MOUpljy+NSDRXR9tayGQOddqE25ik2FfsOFKnRisowfyciFcjuK3DpEjG43A4HI714cTZ/wjf/OY310rb/F9gzJgxX/YQHP+NeBIpPYSQrF69kpWNS6ltrCPIZQjbVuHli/jtBXyZIVteiY8HhRI6jhBhCa1kRyQHm+ZoVttGJCgFwkaFIpPyqOPYNJ6OYnQYoYtFwrZm8vk28lGRQhhRKLaTD0OKYUSoNJlIpCJKRxGZYh4vGyDLKqCqCpErBz8gW1lFnzBku5qY/eI89UKRzQT4gW+FqOmvFceaUhh1GO5ZMw+z3rZmFyLxBLGpemhrFJL8zdYkCZMCKbWZz+Q1X9jG0hJ830cIac1DItOnLBGytlYMIU26ou4wFUmOhABPShsNs3VSAowq8YxrogApTSqeSckUeGlXbmVLxjoqzUTHAawaMgJVx6rjHBMDEytYvcQ6XxqhYrxgkmbPHa2izbWKjZBHobDdztOaM223t6MQGqVtm2ibNqjTeUlSP0GLGDApoZ3M8o0TJTZLN5WlwqQpCmUeEChhoogytS2xDwqMM6NSGuNXY41HbKpnUtcHpMfD1rg5HA6HY/04ceZwOBwbiMCICIGg0JZn0bxZlEtNuGYZPbKV1FZ2oyZXRaa6lkxJ45dihIwgjNDkjRhJdyZMjzLpIZDGnzwpKlLKRM2KJSiFqFIJFZWIwpBSWKS9WKCp0EpTvp18FBLGEa2lEmEUU9KaXMkYWahYUcjmqciVUx6Vk4vAkx5aSkSmDJHLUVlWTq+owNYVNQyJ8yzNZvGtABVCobUiikLCYphGkmxhl61RwkZkkkgbnaJVxkDFeilaDaNN/Ze1qpfC/F4KkNJDeoLA962I9QhjjziKUYQmtTA26Y5CmxS+NFrTKXqXzG8iXDwhOmr+rN6SWiNj69qoZSqwTHRKIrVtxywkWiYOiiLpItZRg2ZFJXQ4OHo2rQ+0NVYRaZAu7uTeiBBIpU2fMR2gbX84qdOqxI5zSie2ow+caQFgRK9xi0xcK815SdurLjHlEOm1sAYg0kYzU3km0cKkPHq2HQLWQVIrjVKCWAmbwpjU4HVqAJ46RSYpkmbChZA2AupwOByO9eHEmcPhcGwgnrSJfioiVjGl5jbWfLiISuFRVuOTVREZVSSjY3TOJ27FCKooxgsju2hWSOGB8IxekL4RS9ZyHGGEmQ5jdKlEXCpRCkvkwzz5ME9rIU9ToURTsY2WYomWKKQA5CNFQZWItKZMeLQrRSmK0VLiB4pAK/woRLS1mfqi8hjhZyHwKA8y9MhWsGV5NWGmDM8LkDY1TmuI4pgoDFOXQyAVaVoYP4rEsa8j7VGQ5txpk6KnwTRVVqJTaqBtLYBASg/PkzbKovGER+AJ69gobINnQayUjRbZ6FISZLI5hgJhHdxFmqYHye8Am74YJX77GDt4swsjXBTCih6DFAKkScdUUuMpk36qpSa29WcyCRSmxhpGsEqZeE9a8SJs7zUhrCWIByKywTJT8Ga0qxF4OnGEtNGnGJAi6aFm9q3s9fA6CeEkPVHY43giqSTTaeNrSAxMkssqTCoiyl4ja7yijYhMXhfJxUx/tu8XGEfIJCKY2mB6OBwOh2P9OHHmcDgcG0isNJ7oSC9UnqB1NazKSPzAR2SzSBUSRIJMoZWgrRGvtYkQ8KRvXQc9fE8hZYyIFVIb0wnALthtFCLWKBUTxiH5uEB7WKC9WKK5UGJ1voVl7e2sKLZRANrQNCtFm4ZYx5RLQYtUlOXK6CZ8pJfBkx6e5xkhVSyiowjtF8yiO47RKiajNNW+h2/NMoQVKGEcEes4FWMmCtLRX0vZxb7A+mBgapWkDdkoW7MEEGlFbM0lTHSnkzujL5Cdml8bz0RjkJEYVuCZqJXp0Z2IHiOwhFVoQoq0sZoQ0vYOs9tqm1iokyifQBKTVF6Z3l8atIk4KVv3FpH0MhN49thKJucgELFpGI01v0iEj7DiREgPCXgqCTyqVHx1NJtORGsiGiGtUdTYGjSzg9imcyYRLIFACg8hNL6QadWZMaLUJrXRCinh0SGiSerEbGKkEMaFMza/V4nLpG2KrrVNZ0yuYaddyc4iWOqkWC914nQ4HA7H+nHizOFwODaQpHGxjEJ0XlMC8rFmjQqh0E6hfzNk6/AVeM0tyFVriPIlAi8gl81Rnsnhmw5QxnFQK4SO0/5axoo8Mi59CqI4Mv3MogilTCSpzMtS7UfkfU17FNNaKrJahXykFQ0oSkJRR0DPTAYvmyOXy5LNZsgEZUjfQwmJjiLiUolQtBEBjWGB+kILTaV2lJDGwCKpn9IKFUepQ6InJVjb9GTFLYGMn6G8tobAzxq7eB0RlGdMDzGRLP+xdWy2+bMJmaVRHgR4XrKQN+rN1JrZNEKSpsfKiEHrUKJtI2UhZZpel0SIkpoxsz9AaGP/kUb4QCOJNcaAJB1Th+mHss2jlRJE0qQDejZiKDREaLTXEeVS9n2JRhRWbGlprWDSeTPph7Ew0cS0LksbYSO1FbvCWNPb8Fh6WgorgmRSOWbNakgiYEakxem4NLGQpk+ZNelQ1iUzibAJqW1apTS1aQq0EsRa2P2YqKVpU2BNQkQSnbQRMhuhkyi0SExwXAcfh8Ph+CScOHM4HI4NRCvTa0rYSAnFCBlLdBzRGobQ0o5fXUNG++SKmlwhIhBZfGkEjy98Amurp1RkRY5O/9RaEKmQUhQSRYoojlFxmOQMIgRkfKirKKPMz1CdCcjkW2nKNxPFJZpVRCQ8diyvYrvK7vSvqqVbRSXlmSwZL0NESLGUpxSHFLSiqGLa4phVUYHFbS0sLrXjS8zC3fbBUkpZkRjhSw+tjMmEicjYpDzPY9tBg/jaHnvTrVsdYaxob2pi/pJ5lAp5I6qsiYZMUguTABVYvWE6Sxu3SmUlLGiliIlNREuZ2ieh7P4UtveZNNHHJNikEykg0v2nbaJtRCypf0siSx5phqMRZFZgJPVaUtq6Ky3wwUYDrSjSVqgJSWqOYWvZYhuRAlsnJ2y9l323sc03ETwj7pJM0ESA6kRvmv5kqiMK1dEMXCOEmVCbfZmmN5oNjRDucGJMzEOSayEQwut0PIGWInUFNe4oNtqosWMQNlonza+TVEmrH5NaQtXpNYfD4XCsHyfOHA6HYwPRWhHZ5LYsgnIFuVKELiniUkyhENPaXKDdzxLLMmRQTnm2nKryMsoyZQRSmsW5tSI3fawEEg+hNVEUEkUxxahIGJn0P09BRvpkfI+sH+BL8/FdypaoDAJCoVmuQj4oKMp9jx0ra9m/qjs7VHend0U11bkyMtKnpELaS+20hwUKCtrjkOawyMpiO0vCIvNKeT6QIVtID+kZYwhsSmAcm35snhQobevOtBUXUqADjy23HMDQnXalR58+KBWxpn4NJUosXDAPHSu0iNOaNGlr0ZTAigGJL3084YMygjDWJgVSRR3iJdZGICV1bEib2qhJnRI7GSl21HQZTYNEmjmXGi9JybN9xACbxmh+IRKPEJu+abP8EJEiSqNcAmScphQqkmbbGhGbtE5fWuEpPIQ04s0TRuRpnQRNrcWHlmYP2vQWM5JI2zHojkzH9H6ka02dieumgshMs7Hw11qjpX0Rm+opTCqoqTdTCO2b4wmThGr8aYSJtiqN1kZqaqGSCTaCNym2E0lKqjSOkzYCa4xJnDpzOByOT8KJM4fD4dhQNPgoMtqnTEoqNVRiaraiMCQOI0S5oLIiR/dcOT3Kq6ktqyAXBASe6TkltHFAlGAiSRgTB+NrEeIJTSAkvge+9skEgpyfIRNk8IMA4QcQx5T8PLGI6VbKUxtk2VJqhpZVMqKqO9tWdaN3eSXV2RyBkBTDIm2lNlrDEu1xSGsU0lQqsrzUzofFAvOLRT6IC6zMemzh+Xieh5fUkCkjGlUckYS7TDRKp3VQAwZsxQ477URVXRWVlVkQWcKoRCYTmIQ2ayuP1kQqQqFMvy+MUJFCI4TCWl10TLY2EkUp0/hYGTUFYA3nE9t2KxYFaZ2c7QHdkSKoFIjkGlivChu9S7bVWtveaBqhpRGPncRRUjsVxzEepjZL2pTU2EvjUbbfmBE/iWuhGWdsmkBrGz0THSmPwqYIJj3HFNb9UXaUnwmsoLchwsTUw0QjJdoaggQ2pzIxsEn2qW2sLXF2tBmjSG0L4YhMrzZrsuJp23hba9BxavyROHRKkQg+7PkoKw+9VOAldXDCWek7HA7HJ+LEmcPhcGwgtmcvntRkkJQJQRlQUiay5AtFXVlAr6CcnhU11JVXUhZk8D0Pz5pMoBTCE6kFubaNiZGaXJAl4/lU+pmOmqHAQ2YyyEyZsd4XEuKYoM0nG4X4mQx9K6vp7tfRu6yCLSuq6VFeTYUf4ElBqVSgudBGc6md1iikNSrRWApZGZZYGhaYV2jn/VKBZTqCoMxY+0uZWsFrHRPFEWEcEycuHkqn/a26de/Ggft9g8FbD6KqqsoIB00a4dICE12zuYyxsiJLWMmgBFpKlJLE1hhEIoiFcSxU1sJdxypNGzTujzItJbO2Ex1pjVhRZcNoAlDJ8TCRu7hzVVqn99kMUsD2aUOmtYZJ3ZZAdNjMa5s+qBRKGut8lCYWZtyerTLUQpiIkhBWiNl6LtuvzPhD2obUdETWktq7JKUwqYnDism07k+Y81LCRD1NE2/TaNqIaWHnypyPEiCUnZPUXVGk9XIoc70V2vwpJFrH1nofmx4pzbmk6aR2f8ImPQqZhO9cVqPD4XD8G5w4czgcjg3ERFJMY+ZERAi7iI+loDaboU9ZJT0raqgsq6A8W0bG9437IcqEPYQHKkbF0hhNaEWsFGgTjcl4PiKXg0ylKTALjMMj0rcLbIXWISIsIX2P6qoqtq2swvMl3YJKarI5cl6AFFAsttFcaKWhmKclCmmJIhpKRdaEJT6KiiwoFZgTFvgoylMQgkoh8AMP3zNfEdrWPqkohEghBUn1FxrIlpUxYugwtuzfn1xlGUrFRJGJlihbM4WURrCkBh6JnXzS1UuhVIiUtocZyqRVam3TGGOE0HhSECndRUklWjEpFEv6jaWmHlp/LOVPYUNDeIm46rSvtOhMmLTFpFQqOaLQiehIDm4r5ZJIUpI+iBXyaNuU2xxbpCJF2CbeVjhpZeZDq3SsQiYRK2tNIswFSdIbjWW9dXaURhSlBiSyY449nVS3kaYeJp3OknsajJhM7mhhjyFT8anNuQmB8oyIEypCSGX6egthbm0R2whc0jjB1hmKjmifw+FwONaNE2cOh8OxgWiliCVEWpv/BEQYN7yM59GzrJxeFdXUVtRQUVZOJpMlEEnqHbZOyZgsmNiLsamP4ghPa7T0kT74mQxUZMEP7Mo/KYCyLoklhSbGL8/SPZejVpsP9XI/S8b3ieOI9kIbzYV2GovttIYlmsOQhihmRVxgeVhkcbHE7GILS+OYtljj+x6e7xH4mY7mxYCKNWEUEcUx2qbjKR3jeR6Dhw5hj2HD6VZbQ1shTxZBNluGlomJhURK099KiKSPmcD3TKRM27olhbANnBVaWZfCOLZiRRqRhkkJVbZGqrP/n1n2GzdJU8PXETUz856YdJjokbJ1ZtJGLVUnoZamGWpzvYTtUdbZvCR5fxJSS8rghDbFbRI6New2Ahct0zq4ZEwIgTCOJCaaiOgkBDWJeb/ZSHWkFZIEHj2SZgJJj2fPmq4gEqdH3VFzlohD29ogcYeUYK+tSRc1aZXK/s3Oj7T+mokAFgKBZ7YQZl+JEBaiI3HSRNhcjzOHw+H4dzhx5nA4HBuIFMZQoqShiKZVK7KALyQVmQw9chV0KyunMpshF/j4tq+0FhKhpenD63umv5ksEBSNK6CQyjgx4uP5WchmwTPmEGiJFpF5v9aIqISOCqiMwA/KqFIaHWuk9gikTxwVyedbaCq2saaQp60U0RgVaYhLrI4jlkchi0oFZoV5VsQlirHGw7gdSk+Syfj4nkAIZVMvNXEUE6vIjMfWGQ3Ydhv222Mk2221FX4uoBSZRTm2iTK2N1kgJL708IS0/xnDkQyeEUpJ/6xOISyVJB1aC/0kVGf+6IhoWeWTFHmltU9JDMh6DJpzEzbik9asiXR/SRPtNPFRJFEyk1aZtBUQVqEluss0qbYpm0ob58JO0Tgj6owNfyIhtU1rFDoRfAot/bRWzaQq2oMoazCCQCXpj53cE7UWadNnYVsgpKLUmoIIBLEEqWw9nDCyNml/bRpQ22bSwog7le5fpT4fHiYVN04jleb+7PBm6XCDlDZi1iHWOpp5OxwOh2PdOHHmcDgcG4oWeALCWNEmI5qkTyAEtVJSns1RlS0jl8ng+aY2TCmTPickaB8T7jBFWDbdTxBIjLWF1iQtoXRJASWE74HnIbRE6xLk24lUkTCQxDkPISR+DJlIIGNJWMjT1t5KS7GdlkKelkKBhjBkZRxSH4esUhEfRSHvlwosD0sUI+O+KBPXQ+nheQGJ9btJFYxRcYlU6SDo1bMn+47ck0FbbUOuLEeoYjzfQ0qB0NJGVYwzped7IG3/LWH6evlSoJRvDDA8EzWLlJEhnjYpfSBMrzdl69c61XdprQmtkUXS+Fin0aGkLC6xhCeNHKWFT50EVqLpjJO9EVFaJ9GjxBzEGGboJDUyTaE0xzGpjbaGUEprzS9SURkpK8C1sfOXWMEuTfRJ20bkyvr2C7TRX1J0RPU0KCuilI5RKk7DcxJhDVwkXhLpE+ZeVQhj+GFrwJL+cJ40hiCeMO/VQuPZyGKsBREesTLj9ZK0UamtyYqHFMq0G0jnMpG2Jv3Rs5E/adMaXdWZw+FwfDJOnDkcDscGou1CuYSmNYasFgRSUOYFlHsZMp5PYEMgcRSZxsZ2YSojAfggYxAS4WXQZT6eyuIpBXGIkQo2qpHkrsUxutCKamsnH+Vpq/QIy3PInE8gPcpC8GNFFBZoK7bQmG+jsdBGfSFPfVhgeRSySsWsUiFLwhKLoxKr4pDQRmW0Vig8JMYq3/d9pGfEmUYQKgjj0EgVISgrK2P33Xdjx+22p6K6ikIUmt5fgY2N2FRAREfanJV5Zg6Ftvu3VUhKI1QMGJMRpQU6xkaJ6Kjt0jZypczcSKXTBb9O/88eywZ2ZGKmYX+TWPkbB0MrnpDpsaSN2HWuUkvcH5NzSHuLpfeEqS+T0KW+LXVUTO4c3RHlC6RPnKZd2jEJE91SwlTieZ6N1mkjeKQCLU1tl9QSrTyiODJRKWEacEvPpND6UnS0FkDYRtCkNW+BL5FCIwX49pwEwkR60SgtKaEpeCalMo6NWPUwws22oE7TP70kiiftNUKjhbSplmb/UrrYmcPhcHwSTpw5HA7HBpJkdMVC06Y0gYjwtKRaZBCeJCNM4+RSGNIex4RCktEaPzFhEMaiXnoS4XmIbAYy5SC8DiGjBVadQBShW5tRhXYKkaIlq2nJ+bRlNNILqRSCSMWU8u2IfImWYjsNxXaWt7WyPCywMiqwNI5YrhQrVMSKKKQhDokUac8wIwBMPZL0fXzPR9r+VFopdBwTlkJj1pHx2HXXXRgxeCg9e/Ui0oowVvhekEawkkbSQng2cqTTREOpbaRGevja1M/FxtyQRF2Zei7T00wmYsrWeCn7HtFJHCmbjpdoH2zkJtmj1Qrp/pPUwMRYvpPVYFoTlkbV0h9sCqQ9VrpzI31SR0MTGe2IyqETUZbUupk0wlgaQ5lkP0kjbFNLZ143PeA69JuQpi+cp4HYI/ZMtFUTgzUAEcIIsViAZx1AIhswlNbO3vM8AqkJpBFxMmkRIKyktHWCZQiypZj2YkgeQajs/GPGG9vIpOmFZ1IkhZAdjpJSAF46rg7J63A4HI514cSZw+FwbCDCpuWhBUUd04rERxBKY3aBkMZ9MSrRrhWegAySQEqyIkDKGCU8/BgjgKIIEUaQ8RFeBjwT4dAIRFhCt7WhixGQQZQJZDmUyn1ac5JSVKS9UCTbGuO3tUFbSL5YYEVbK4uLbSwJCyyLI5aqmJUqpElr8iq2Ru2YCJQVOdpGdHzPw/N9UzuFWazHcUQpKqE92HrgNuyx+0i22mIAuWyO9kJbarQhpElh9DyBtO6USc2S1kZsKFuzJoRCS2PIYRpEi9T0wzYzw0sje4lAUx31ZXSqZ0quTerM2BEJspcqjfKk1zFNZiR9j7TFUyLZqU6udSLSbB2VjYqZ7ZQ1IMEKOG2jaMk2OhWWmhi0SKNsph+0QCiBxjToFsqG/JLokx2lsKLNRL6UcUzECPlYkaY1ejLpG5fMAwT2jE0LCEFWCso8SeBpaydiomdGS/lUV1TQvayaOIpozLezorUNVSyiwsikOQorUrW9jjq2ETIzM0KIjpo5k/CJSCWnw+FwONaHE2cOh8OxwSSpcGbpnNeajNAUhaCoFJEKieMQ4QcEQhNHiryKKKAoCEFG+GQ8n6wQSBkgJcgwgoKNpHkeSNOnyjYDQ3gSpULwPKSfpdLPEgYeKwQsqV+GWNOG11ggKoa0hCWWFtqZX2pnaRyzKo5oRNGuFJHVJzHGTyJp+ZwIE3M4D0/6YBtGKw2hUpTCiLruPRm52x5sO2AbyqsqCYtFCsU8vpdJUyE9z8fzvST2Q+fUxVgoYqXRka2nwoZ3RPL3xGBCoJRCdYmaYX82IkNoOho005H6Z5JCrfEFSecwe720NeIQiXAy0bDEJbHj8oo0gpQIulSkJUIPYSOdSbKmfb8xazSJklawJNb6pp9bR68yob2OuFtsGlsb3WmbPZvu0DboZ8bteYEZl7Q9zaREKROF0yLpX5aIOHN8k4BovBOlEARa46PwtSDjaTLCoyKbo6aiguqaanpVd8fTgjCKaGgrgWwg39QMRJRK7YQUO+YATJ2esGb9OknVTObcXLhIKzyX1uhwOByfyEYRZ0cdvC/77rElvbr347W35vLhqjyxp9mmdzXdMjGbbV7LwK12QXhZVjUX8b0s1TmQukAchVRVVjNn/oc88MSzNBcidty6FzttuRVvzVlAfWs7B+8zjDLfI1/KU1ZRRcOalWzTpxeltlYmT3+fme3lVNRtTbGtAV8oumXr2XrHbdlsq2H4YTsfLpjD8taAYstKPlq6gopu/SivrmaLPt2oKu9Gw8ollGUzlFX3pqQzVGYEcftHfPjhPIQM6Lv5NmzWqzexkqxoKrJ8xTzef+cltu/Xh4bGJlTGZ5sttkErnzfee4vWljyhhtWtBUSpnbKycvrttBNb9ejLqqVzqS0vo9tWI8j13IaM1NTmYnQUs6pxDe1tEcUoT2W3zZGeh+eVyJTytDatZvWS9xFxSF2/rVFehipZoi1foqUQkV+zjHLdTLeKGqisoyDLWNHUxtJF88gJRW1NDVmpqCkPKKvMgfARQY5CrKmqrkQrU+zfq0c/MrlKNBFS++SyHjqKWd2wktY1ayiVSjS258H3qaurok/vvkgkbe1NeEE1oSohdGRsvKMY6QVkpYeO28hV9WTpkrn4fkBVVRW5wMcTPhrwfdO/KRaCQrGNQr6FWEUUiwV8X6DCIm3tJda0FIkjQXVFJZmspBS2U1NWjR9IYl8Re5KWfJFMppJuNf0IslUEskTOAy9Th/AVWrWhwxLFfJHuPQYighz5llWU2prQUlLMggoqyPrlxKVGBAoPTVRopbE9T3uhnVCbvkuy1E6VX03GryCKCkSxxi/rRraqjvLqaqRW5LwcjQ1L+GjxfFa0rCT2ArrX9qNHzwFU1/WjsqYH5WXVlIrtNNZ/RCwCttpmAJv13gLhad77YCr/fPIJ1qyup3/vbRmwzUA+/GgBF5554cb45+v4LIhkwWn+orSmpKA1jmhWMe1RTBzbe8QTBL5PFMcoZWzQY60o6YhYSBChMUsgb1wMyaSpZabuR6OEMgYZnk8gM1QGOYTyKLZFeHFMQ2uBlatWE7YVKUUxzVHMiqjER7ExAWlHoRDEGmOqgREzymaZJUbsUkizeJcenjT1SIlVRqQUwvMZPnR3dt5uV2rr6tBRTP2q5axsbGKLvptTXlFho0qyU8zK9IMLwwgpba1WFIFNTdTWNj+d2iQtDyMe02bWNuqVNkdOtk+EGSLVzNK+3/SjM/8pGw1LjEGMyOpIKTTNqtOLa+aezq9bdBovM/b7NvIl0fbamn0IbRw4O8SKiZzFgG+PFwvVScQoYnuPKDQy9eWXoKx401bHespEZ+35xcJHSiNokybUnpBIba4piZujHTPKjDuKISMlNeXl9O3Zg83retKjWw113XpQlisHDYVCzKrGAqG3ijWl1SAVwi/iRe34YRulMI8XF4hEAaVKnZNGjbNocm0QaVTS8eUx9YPVNpJsUk6TW14I0ybPs2Y1wt5fSQTYPNAwG2th2iNkhTC9G4XGE5DL+EjPPHjwrNGRMUIyDqJSmH9/OtaEkaIUxvbhiyC2De2FNcKJlSbWklhhouwk/7bMvwGNqXv0rYGNRhFrQahMCm9kn6TkPHP/BT5UZyVaQUMhZk0IMdIcH8A+SDEmqRolhX2ulHyuJFHgNEZv73LSFOY0j7lTgD79M018tr0Pk6C9NcyJ032ncXLbxzDpaWg/yTpF8tNx24c4H88MSB8e2cF19rdNvr+07vSg8WNZBYnJT3IeSbS8YxsTESfNbBDJiNJxdRpm+p2mEWkqffr5rkWagQAmW0J0mVTTwsW8y3yPqqQuWyef1Z2uRceRO8aczLfAXvfk80iZumRMrbOyDwJTQ6j0oWBs0+qTedcopdIHhzp9iGi3U2YfWivOPXoPNoSNIs6WtkWsbs4TeG0sXtlCXkkG9Kpht10HQqlEZU1vWouCGEVbvo26ao0XAXGRhsZmQjy23mpLhuy0LZNef4fG5gKrG1vYrl9vdCCorqmlvXkVnpToUp4+NTlynqSxtZWV7UUaG9uJSrF5Yhi2UFEbmaeTWlEqlcj4grrqMqjaAhlkyIcZysq7UV7RDRUXEGU9WLVqHqKpmfo2SY8KRW0moFiS9OxVi4rbmTPvbYSXoTybo0dZjt67fY2W5jW0RwUqszXMmjmLUknTraaGSETMm7eKQHhs178P2e590dTy2tTX6ZEV9BtUg4ib0W2rKeRqaI6KdC/X1FVV0BYWEapEuW6horyWUkGxurkBnwhiRUNzgWx1I73qepERiqa4QHUuh19bx7IPVtC4qpm+AyQVPSopDzwgRnrQo3s17c1NRFFMTWUFsZehoS1EeKY+INe9H1lfEBVaaWtaSTbIUOZlKSoII4Usr8YPQ5o/Wka+JKjKlVNR1Z3aylqiYomCbETFbWRFFo0kLEWARsqYUlwgkymnUIzIVdSRyWWJVYkoNjUSpVChI011j97ExWbiKI+QZvFWXl6BkII44yP8cmJZorWlHaU1YaiIQ0E7beQIKM/kaAtDcl6WwM+RzzcQxiVyZTmCoIYAhZAZtBAU2lYjRIZ8IY+KItoKBVS+FS0UoQioLKsll62gJWpEyhyhioi1NM2BM2Xmn3ExD5GHzmaRZRVkipKgVCKK2mlvCSkWm6isrCLSjdSvWIDSrfTtVknsBZTCFbQ2RXjZDLmKKvJtDQg03Wq6kSvz6dujD1Vl5SA1OwwcjPyuZO47c9DFkKxXTvduVRvjn67js6KT5C2d/n+oFXmggEZ5PkgPaaNkvgjICWwKoUJKW4Njv2W1iomVItSKoi7YQ5gPeaElUkJGZsgSEIgMQgYEUUwuKlHRmifXVKSptY2PCiVaYkWTimnQMY06pmRFhlbmC0TZL6gOcSbS9UZSFuUFPsL37HeZMgYdKqJP7770rupO3z598DxYvabAO0sbaG1cTt/uvYnDCOn7to7KLsilh0YTRvbzBihFIWFUIlZhup2wUbpkXoQAz/NQyhiKaCTCLh5N42o6mkCDiRpB2tQ5SSpMl1LJXJMsD7ouUhJhp7VK0xGTZZJnr7lKF0Z2ESnMQi5Z9MT2S99LFwgdi620ri1WKGm628l0HPZ6JO0ClDL1aFbkSanNwkQYwae0NrVjVpAKqRGxMepPxGRiqmkWv3F6/mZRo4lNPiXdK2vYbovN2bJfX/r06kNdbS11tXVkMhnCUNPUXMTPtbKi1aNsTUBea/Bj4riA8ktEmSJh3E4U54nidsLQfIZHuoTSyi6c7Y2lsKmuji8LKaV1QbXL3rTlgWk2DtIGPu39KRIxBr5tsxgrI4gyviDwzb8Dk0Kr7DWW6UIZT+IHnkn3te0yJCbt1pMQlVRaI+oJsO0QzcMhT6SpsoEnCePIRM2VSkVTJvDwAw+tFXGkiGPzGVcIzedWWVaSyXgEgY+QxuCorCKmvLnAqoImHyep1skjBNMixBj7YJMHzHx59gGLrawktm0w0s+VTp+lSbS8o3eE7mjLIVJJY1KadfI5YN1Uu+hAnX5Ea1QStk9OPzmUTTFOPncT4ZUInHRnHb/vXDRr95n+SddNOtfYGrGIbSeSxPzNJ1zauzERPqT5B1b4Ji67oKXsJJY6hH8yTvNcK/ncNN62Iv27Z+tyrWhN5sLou+TOTq9bInA7NiIdh0hbfZhtpACZtC6R9kFBLKxFVEeav9bKPtCQxptKmIcL9u4FTJq3oiP1fkPYKOIsE1RQDAPClgYKhUZKsge5ihxeUIkUzXiindZ8K56sRLXmWV6/hpbyHNWVmmIUMm/m+/Tv248yv4K6qipqynM0NBdoFe0MH74r2Wwt+UwrWQlZXaSmsobm1WuYNW8JQRDQKxfS0LiMgvDxJMQ1Ab4vKRaLeFGRrAet7U3kyivYolcvljdERFFEqRBRv3wlbWuW0dzWRKWMqG+JEL1qWBPGvLdgPvvuNYK+mw9ACB/CGBFLPlgwg7C1gZqaGrbYfCuWL12FEJqWsA1f5th3j33YYoslvDB1Gr26d6cpX2L6O69SaG9H9axkuzCmVFTIoAFVaKMtCBBU0q0iR++qkPZcNYEU5Jsbybe3kl/zES2rP6K+oYXy2r40lzSyaQ39qzL0qKxgRWMLIiyiJSytb8Arr6abX01Ugj51tVRWZBFllSxdsopKP2IL4SG9AHQISpPJVZKr6E5r/UJEsY2ysjLKMjkK+RZ06JOr6ka3mt60tkXEYjlSl/B9ScYPIIZ8KU/GK7c1Nu0IP4f0fYqlAmFUpLwsi46gYfUCyiu7EXgepQg8P0AiyedbCQUE5d3QKiaMNJBBxUVyQZZMkKEYZhBVOcq8iDWN8/F8TVgKCUslAj+L9jRe4CNLUMq30dzYQq6ynPLKmMqqKsoqupHN5MgXSwg0Xq4bqBKthRZKQlEsFgikwIs1FENK7XkK+QKFUjPSC5C+h58po1t1P+KMT/3yBRQLBaiso7yyO5VBGZHnEXktBOTwKiuIpE+QraZ5zUJCFUImg/Y8KoVHS9SILwSB9MlmcnieRyZXjgSyviIjPQLrkFaVrWHrvtsTtoQ0tRTxgwz9q7beGP90HZ8L3ekDHkL7haSASMdoBIEMCLwMWWH7W6kYtGfEmVRIPKQ2NvVxHBPGEaEKKerYRnoknhAEmIiZ9AQ6KkFek/U9KooxNfmQ2nZFLpQ0FiOW64gGIgo6RklJUv+WPukjSeSzqX5SdDLLME+lfd9DCGPRj/1VNpthq80H0K28lkw2S2trK/ObBe8VNqNHeQ2lWJBva0MEPtlcBb4fIKRESPO0U+kOkRJHiqgUE8cq/SL37KrMmFJYt0YEwveMKFKJCUjHl3yygkiaSsukHkwkgi956tyxZJH2T5HUrKV1UFaOSZk+VZV0zEu6UEie5CbbiI70SS9Z0AidCk3sUdBWIHvGAh80npJp1CIZW0zicpmYedix6iQiRuqiKZDWKj8kEtq4MQrS+rmOs+142qy1Rln70N7dejCo/+YM6NOXvr1706OuB92qaqioriLIZCnkC5RKCj+bRfo5cpkaAmljACIiEhE+EQERRDFh1EYctxLHrRSjBkphMyougrARBiGIXOTsSyXnRYBpp6CT/6ULby+NIAghyNqehJE2vqSBiKnIeChtymLLskb0GH2irRGMWdTqWJmorf0MAkyDckBL8KRP1tcEgWciucqkvZo0aiMqAmk+C0wkTuN7gY1IyLTG1c/4aCkQMfgZKwIFlGuI4tiYMCWmRvbek1LQvbqcyrISrfmQ9hIUrKhTAiIgECL994gA32bQJCnRodIUhCS0D7wSgaKTT1dhhFeXoA2dBJWZ8A4RIjpMmZLPMzOtHQIDwBMqdUvFigulrEDqpHfAPJDSycFJftH1sdHHNVsq9NJvCT62Qcer5vshkbWdt0s/nZMt7fXvGItOxFsijDCCW3eqk00/ZwWpyEtFJJ0+Y5Pvg04D1vZ+TL73ugo0g/z4T7rTvwe7Q/u8AqmMh69IJ1Om6dpS2JTxTiI/ad8iO3a2QWwUcbbbrgNoql9CT5XB9yooxgGzPmijcfUbHLj3jlRW98TPl5gzdx5T33ybBUuXs/2APnxv/73oXl3FgkULePONpaxuKlHfVmDbbfvQu64fM99/m/r6BtbUr2azPr2oymbwdEBciHj7vfm8v3glucoqskogiWhpasb3wOvXBykk+Xyeas+EFhcvW0VFVUzP6gw9cpq8akEXi4RhA2Ec09CSpzVuw8sG9O5ZS2N9CxUVARW5Gj6sj9FhBVV+M4HvsW3/ASxfKenTuwafLIs+XIJWEbUVlWzeY3PKysv5+uDdGNh/c+pXLGfZrA8oFdpQwiMMNfWNzeSqNFv26oZSjYQqR0n7tObbqcwGxHGBpkJMWCySb1pNw5pm6lc3E2moDHxyuUq0FMTSNKIlLtGQb6eqrg86CGiPI8SaBvJxTG25T8/KHC3FNqTwyWUF+XyBYksehKQsm0W1rWZN82oUit69+tKjpo41K5bR0t6GnwkQ+YA1zS3Ur1kJ0qMml6UiMIvE9nwbxfYWhPSMi1cUkRMR4BtXNwGeV05zyxpWNDTQC4WUJZSOEZkqolgRKUW2spqmho8QUZFckENJUJ5CaEGhUAQ/Qzaoo720lNpcGc2FPE1Na/A9QRBIZFFTXhZBqYBAkA9jVCkmIwKEn8XLluPl6sj4rUT5COHFtLc1UCqFxEGOEIUf5NAioljM01JahvIgjIsQ+FRWVNCjajOyuQqKkYeIPWKvgsAvJ8iUATGB75PL1KHCCBHUkeu+OatWvE/Y3oLvCRQBSivaCq34fpaKsmoyvukxnM2V4fkBniepqipHSE0UF/C9LFFUJFaKzfpvR0VTC0IE+IF7+vxlItbxN09IAiS+FMRaERETiRgtbYqZ8Ew+C9iUIdui2LrlSySB9JFBBhGXUHFHTyopQYuISGlkJBAtEfigowjVmodSDMIjkh5tUUibUighEVrY1ESdRlJSswZtf7b1QVqYp5AKTeB7ZGzDaLRAeoIeNXU2HQ+KhYgFbZI3Ct1YUdGXnpk1CC9PFMVGDgQxWimE55keZ55nGxpjvgC1ItImWiiw4kR3PA0XwljGK2vzntRtJSeRiJ6OJs+JwDENoMGmFCYLAZEItOQLXXR68pwawtvvY22TMu1SxD4tTw4kkwUPAhPB0yAkShiTj+QpuE6+3BHpmLXWtlebXVDZJ9ACs8CL7Sl6WqRpOhJrmIJGoYgESBSBkNisQStok+WMPZ5WZqFjV2BKmyiEr2MyQtKjqoq+VbVU+QG+Ak9JPG0Wk1EcoUomwlmMY9pKRUIdU4gkJUxNpMQj48UmuotCeppiLoQ4QkXtFKM1FEv1hGEDpagBRAl0jOciZ18qvcs1sU23MgY+giiGWEHgazK+iVK0h4qSdeb0pcQTUJn1Kc+aBuex/bcOpnWC1smDEfuq9Ox9n/RKTKJr2op1E5mTNkKslSaw/7JUFKFi+zv7wKHDBZbEkwfP86yZjv0kEKRPNITW+MLrWEzHpq2JVh0JhkJLKgJBRmrCKCaKFVpBLITpT4gmtuJL2DQ8KUwELetBRikiJCGaCGHTJJVpj2H+mZt/m9jHIzpxOMWevaHjs9nQ8XPnV816SErwPI1v8+iUFmjP/LsNFSidiB1D8ngmEUJdno10emiVah5Eqn3SnXTaS+fPaJNS2CFMTZROJUdLHxKJTgdMsiI6SCJcIhVhSbQvEY/pUGz/yeRSkwquJN3R/i75TtOdtsVevE76MhmHZzpZEgnZ4T6rzcOKzlfFpMsnkVNp5zTJcME8JFBJVopJuRQqSe/fMDaKOBvQuxv1tNO4ZgVZGVHS7dSvbqdfzzraSjGR0v8/e3/2a1uWpfdhv9msdrenvffc/saNPiMzsqnKZHUqkkXStFmgSMgwSMD2k58MvQj+B/xowIJtGH4R/GBDMAwIkCxZlFEqio1JFrMysyozIjMjo29ue/pmn92uZjZ+mHPtc7Ig2axkyPkSE7hxb5yz99prz7XWnOMb3ze+wcZA4VaXfPTFE8gGTCo4n+zz6qOvc2/vDgfZGaOtgtNKYtuUUb/gjYevMruYkicezIisl+Ot5MX+MT99coRRCfXK8OnBOal0aBQ20t2XFxeIVjPcHWGN4fn+EY09YVwI7tzY4NbNG6SJJks0c5Uy6peMtu+Qj++wuz1kmO9z595NZq3m5PiStq4R9Tk3SkdPLXh4cw8hPX/8r77POx89YaNXotU5737+OQ/2bnDr5i6Pbj/g9s079AZjNrc+4UcfPsN4h8axWtU4lTEePmA+OUC2C84qz0RoNvo9MtcinKVRnqb1WJWBa0i0Jss0vd4AqxqWzSUrSoaFolmes72xSWU8s/kKaQ1tf4e6d5O9IsM5we2RREuFrwxZmtJ6y8WyZryxy87mDv0so142nMymNMs5vSKnkZqmMeA9lW2hXlCYHFrH5eSIREqSNCNRKXWbUDU1ZlWB0mjpWc4umM6nyEShshStDL0kJ9UpjXSMtzaoLKzmFbkS4CxKaJxIqZsWmUiWqyXHT35MTsJGv4eTKZNJYJ+UN9jWMZufMZ8vyNWYPB+QlhuMersIFKu2Ju1LMlGwmlQ0psY6i3Oeuqkx3mO0IVGSzAlWdU3dtCxZkfiUcW8bLTOMrZmcvMAsF8i0oCgKSBS1rXH1nEHapxyMmFQN88NP8M0CLQSt0sF8QVgasaCX7TDYfgmV9REIlFBopcjylF7ZJ00LjGtZLC9orECnPZrlaWDY0gKdpl/Go/vV+LcZaylItwEIkGCFxHpJaz2r1pNiENKRKo0WoSEzwuOlCtIQ5cFrEKE5sXSQiBQnHDbq7A1gEThvcMZhrAu1ZdZxXtWces+FlCwkrESQ5QiCbfr1jKjDh95YkRLqQE3H9HQckkoSVJKACI6LSZrQtgmJTqhXDYfzll8sSp65MU0ucKrEihYpXZCtXctsBvAZgp2u5qprRh029hhkEOtc4gmHDHAXHXSp/av/978UZXSvuQay1qNr9gzORbv4GFB0x+s+q7Pev+ILu6ClS8fG8xVXmeWOdZBxqju5ZVezISKI8+uMdDA+cbGNgYq1ZRKJ8KEezQqPBnpeUDhB4jwWSy0ES7qAIfagizU86xAiAs8uOOmCHXXtvk20RiOwdUu9alhVNcvVikW1wgiPrBZIKWlaw2zWMJlcMptNmUwXVKZPpoekUiNkHurtojlJ6SzWG7AViR2QJhs0zRl1e0DVHIOvovnMV+PXNVIBPlK8QoroqqpwLrh4JolGKMnQe5rKsKwDqx/qRRVta0gTTZrowGIZExhyrWLcfl2q62PdznVgFcDDmvsWsRZXRmDnPUrJ+Hldz0TictIlt1jX94gugpdxReukDHEN8uuESVyP1mtEeC4lHi0dUoNWwYDJuE5q6dHRfGidn4lJHe9BKxfAmBXUFkw0Muqifuv9ek0wXmAQmHiQ4MzasUlh3XNrtHStVce1ulUhwDtofehFKAQYJ7BOXCkShb+a3e5EBeCvGL2wGUTH1ThnAtAKvPPBNEqIrvPjGtR5BEKGZvTChZpC74Nxk8QhpMQiUR6kCCmv1oN3gfFP4l5Tu5jk6u4FcTXfvvu5YH1tu/6SXN/P4vqKuMaaXf3FGjiFXW59G4X6yAiw/FXSEhHYUWLNWUiadfdLuL8EV/V9znW/D6xysFpyoFjXm+EJe223SfwlxpcCzn7x6Yc82L1LPlphnh6QiIwHtzJ+/ze/QzObcn76lHQ0DoVxSUGSZah0wGSyYlVNGYy2WCQjlHE8uj3Hu4rF/IJy1OesmZM6S7OaYXsZZmX57MURvt9jmGUsZg3DIuNs2YI3aAXWtKyWCzY29+gXPS5MS1vPSVQPYwRnM4Mqa/pWoZOCrU1FbWdsbmyyefs1ysRAc4ZOMpYTD76lsQvKrGA0kkyOT5hXS3ztWNmaVngen17yYGeEs5LTyZyt7ds823/K/ovPyQabvPnwVV6685BZtWR7lHNat1TTQy7sBsIKEj9nkA44mi0QwjFINYtmgXOCYS9hMTNkWUJPCQZpSaISEtHQS1KeVeccX17CckGpBYONIW0q6PW22L31Kr63jU8qXn7g0eaC1WpBPugx2ryNQzFfLUhoaRcTnp9VGECoBF0MWNqWHoJeWZL1BjSrHrZakgnJanFOv1+S5AVKp+uFaDDoIfBcXkzBWxYrQ9O2bG/doD8o6Sci2Dobi0DQNkuqVUM/LynyAmktbV3RGhMYpNZxeHqIbeDGzbuUeUlV7zMsC8pU0e+XlOMhp+eH1DZFJIpxmdMfb6OkpDGGpG2YnR+gpUbKHMwS48FiaFqLFZLRxkvMV0dU7QzpQjakamu8F7R1S9PUlL0hzgmatiZLEqRUNM7RGotwhqyt8dZRLRYIkSFlKBitq4ZWamrhIckoN++TF32kShHCxk1SkiY69BySAmM9FxcnJNkm83rBcl6HbCTXFu6vxq9lhH3ErzeCsOd4au+4tIZT07BfLXC2YaEzelKjpSKRgkSqmBGWSGx0HLxy03NdNtR77NrIw+LwmFg43zhLbT0z7zlqWz7xlmdCciEkTQcthInyv1hLIXyo53Bhg5NxYyVau4cNJBhN6CRDJglCCaQO2eBVtaJtGy6WFe+vcj5xW1BkJE2DlzqAkk4qGKMn52zoiSUEItEkBImTjKyed1dZVktXixI2tCuXxqu8Y1eg3c35+mKIGHJJsQ69ZNxQu6S6RCCUABcZg3Wdx1UWFhGvgw9BpItSwOube1cD0135roarkyipjrnrArUY1HStAFz849ffR/4Sq+lx9L1kHP8MEKQesJ4VhgsvmSpPLR0OiXNyzeaFEpcYjni5vu6IAO5VBHXOQ9MY5nXNdFUzWNVcTi9DqwQBXkgUEmMts/mK88sKM3HsZp4D46jqmlqlJKpEixx0QuIzlMxQZKBKtOuRqAKlihiwOurmCHz7Kz93X41/+2HaKhj+aB1WimjGo0RsA0IAXDhPpj1ZElQwxgUQhQjrgSQw4l37jTUI69ZF7zFtG+7JTpKXaFAh7FwDJE80CIrJmQiQRGygLlwHqsIxnOsan0dwFpvRd8glKA6ugJyUMoKhrk5UrGVu3fGUlKEGzsd6MxdaU3RS7Ph16ExROgbcedBCoLVHq84ogm7FXdf3Oh8AVeMFtRcRqIXn3kX3VERXMxbVAl6sjScEDqXiv1xYmzx+/e++DhVRgeWT0dAigAonOgmoX4MwCzh5hds6xGPX5896TjtpOEIgvSAVDiWhSC1aWTQwayTTJgCzRBi0CjNgY9eTLHFspI5UeQySaSVYtNB0hhld2xDfsYl+fQ6hDuya8sN34PyKgRPrbyBiexK7fk24AUOP0WABI1Di6vi1gdbG+e6MbURYJxt7NSed2UqoxXQRmEJnUiIF65Yk1l2JQkXICv7lHlK+JHD28afnnJ/P+OvfeMjXX3vItJK88fYb9NIxdb2PdzscHB5zNmsoR7dxQjJdGs4mS1rTIFC4tsUaw8OdMafTc04uFtwoBgx6uyh/hlaSxXLF8mLJZV2xtbnLalkzq2eUqUIKT4uilwZZkfCe8WBIlmd4a7mYzJjVC25sDhlvjNga91mtLD97/2M2t24w3nyIzvpkXELb4NuG5yeXnM1qtrf2yNUA7yzb2yNKteD4dMLPv/iQ7dEGv/XmBj/59DGnVcPd7Q2c93zwyYd8494uRVHy8w8/IhGf8fD2Htt39tjcusVuMcLpHkuraW1Ou5qR+YadzOGkwXsosoKqBpEuyZWkyDRCa+atRYmaokyxsiEFlrXjxf4BhTC8ktxnb2tMf/cuw3GJ156qbimKMb725OkexnraVY0XNalpWNYNTydzHII0SdFIvK0Z3LjJeO8BWZ5R9raYXZ7z7NN3MfWcMk3J0wKpUqqmYlW3KO0YpCOGvRFeSBbLivn0lF5/zHC0RaEtvTwlS1NmdYs3FlPXpEVBL8/QUtIKiW9bhK+p25Z51SBVydbeHkmiOZ1c0DrBzmCT4bhE9sek/TE+2+Lk5DlJNqQ33KDQHpk5kHOq2QQjcvJyGyEzEp2RMKMGpLMoCZeTA2bNCda0NPMliQMrGlZeMF9eMNAJy/k5k/kEdABRmQB0gvUJQgyQxRaTxTlVIkjtisRCa1rq1uHThCLrU5a7DPob1PUSLVt6vTFCglaCTGvw0NQVVTWlaSsml/tYmeKcjcCto/C/Gr+u0bEpITEZdgsrYOosh6albGoscFZLRkpRSk0mFRqFliGAlzFLKrzArWV2AoeI9vZ+/e9WBAMJA1TWsrCGhbVMvefYWZ55w4l0tFojXYK3LV3RdNjvgxJeC4UVAh3t1jsHQE+H2ULxf6I10jlca1itljRtSHgt5wse75/y/vIGs80i7JI6AaGD9b93COewbUOrFBpwzqIARQi8RARnXXBmfag38RIcNshyrjmPeUF0mIzwpUv8xgBNRMQjpLxyd1xv2l0GOfwgGB/Iq0zsmme7YtwEXXZ/nQtdb77rADSCuOuy0M5ExOECCBJXn4AIUkUhQItohuAt2kmkUzHr78gjU7btBbtOMvKOIZLMC4SVrLzg0nuOFUylZi5VCL5URh1BYEC4Ck+sFfJdv7MANqV3OCdYtg2ztmJZ10xnM2qzwDgXA84QeAsPdd2iZMFmXmAGjtYuOV4tmVaShgKlMnRSYnUPnRRolaNkihQhvFDeoNMhCQOMnWHayX8vz+RX499sCO/wzoW6wxgEOyeQSob1QLjA6tqQPE3SlCRVJELjbWiDIYWI5hpxqBjpW4uLdaSdi11waQz3n/cerFm/zQPOWjAmnInwMWnkscbSycvgqjbJWoP3DqliLaoNxgyudb/02d2QUoZ69OgeSUy8dH0HgfW/O1fENSS7BuYgrJFSEL678Gvg2BlmKNGBwvB6FRkgDSQe8shKOS8wOBoHjZc0ayAmQ3JIBDZJA5kUa6ZnacNUpxEgSCHQwtCT4IWPgNJhCWuf8YImXgdHNDTyIib/xDpJRLg66xosj8C44JjpkMFhVkChW3YKT2sdrRNI6elrwTCzFCvPvA3zUJsAVoeJI1XQSzylsly2kkUd9jWtwopkCCxUqT3Ce1YmsHaegGk685V1/W+Ht0THYl6Xh8c/IvRuVCLemmtpocTg1za+xoU91QkZVSWeNJreNJYodrwqDQi3hF8zmDb+VIrAJnbnGMoQiODtOpv3bz6+FHDmtWfmE+ZI7t67x0VjKbMdnj55TO5XGOM4PZ/x5PiS1km0cLQYpk1C21QkumC+OCNVJVas2N0e86P3PyPv5eRas9EvGWY5i+WCJ/vBGONsNaH1KdPKYE3DVl7SmJpMhwDBCSiKIkj44ga1XFXMpp7zfcuL1DMox/Sk5/TsjFXjMU4zTk8YjRLaVEE1Yz6fU/YGlHlG1YaLkCUFt3f6fFQ+44e/+JiN3oD7O2NGo4Ltm3s8e3bITz/4hL1+j5fuDXj9pfvUAoajTbLeiJOjI7KRQfUzhCJkaXzCbDEjEzV9ZaltQr+QGFtwdlxjWktajlnWFa6akfo+YpAjVEmb9Ngoa5abI8ajlEevvU4mFaPtPdJ8xHw5QyynXC5bnFlR03BWW/opDIuU+azmyeExQqUIa9FuQZqlNAq2dJ+9my+R9vu0q4pqUZFoRVZucXNnh+rygqqpQv8kHFKlZL0dko2bFK5guXyKdS1Fb0zZ3yB1KxIFaZZTpkN8tSSpHaONDRSOplqxqGcY4Uh7W/i2olmeUBZb9IotTHPJ2eSENBlw4/arZKVCFUN277zE7PKM1qcomdDfGGPaGb20JOvdZDZ9gfI1iVpgrcfqFFSBXi0BwdnlhEZO8aoF6Zl7gzKWUmmE15RAY2sqY0mkRucFSmuWyxl+uUQkglRpZqamEh5ZFKH2YrWkXVQ0LeRpzsbwNnlRIERJlm+SKIczDWWS0euVaK0xzZKVaXFkCD2gWj7H+QyyFK0Sruv6vxq/nnG1iV2ZUHghWHrHvm1oW8mZM4wR9IWgEBotgttZigr18TJK2YRAe4G7BlxawMoApNbgTIR+agvbMreGmTFc4mhiPzSnU7T3ZITG1Ma1QRrkBajApHgCs6I6ILHO7MYKCA8iCdvYcj5nMp3QazKMNVTLJS8OnvDez37KKQ/JXhlTb+1hhMZpFTPUoU0ApsXXAqfTYPrRzZMMG72XAqE0CBXaeHSUkoj1C/5KjOKtXWewAw6WsY4tOPLa1gBqLYtZx3MiBGFSiHjsmGlV4f+962BXxzSF93dyp+vXuhMKdcXqXdpVBpQeN+WO0QuBRdflTUhIpaAnFH0HhfWkFqQVgenzFqGCG15iPIMWtvDccJ6hh4FzpEIgHFQepkDuNGcuZYrGKEXrPVakSC3RaYJMU1pjmFRzFrbGRkbNE1ixxnsSD7UxXCxneFsxSjO0TklEkF+1eJJEUyQpRZ5ijcRlllXP0NiW2arG2gJrc6yt8boN5h+qAJ0jZBJnIUNRoEUPLQqcn3+pz+JX4y83fOw1J7xH+I4BiIyTD386ptd7T9OA1rFvYWSYukfAx9cGx9IA+rxzQaaIQCmF1OqKQfbhOe8AjIts3HXTng5YWfvfJoAN5xr6MXY2/NdD326diJ+Dx1qJtRatg1wTL6JjqFi/KzjuRcMQH+SGHZAJcwbWxiQNINUVk9e95ip4v743X6+ECiuNIpibJEAKVN6FGBCJ7aCICI6xUkAWDXhWVgSQJz0D5TtRczAIEuH4LuSeAoDwgtYHbwLHL7cX8HiMA+uvOeTGdfBKlR7+33jHspEU2tNPLX0tkInDuNBqIVEe6xw3StjBYq1gYXw8Dxmuq3TMraB1YJ2kdSKaygg0AiccmRaAo/HhddcW8ajICHXUEo8WLkrVfVzbwrLetVhwrkNuIakmdGDxJJBBUGT5YKgk8biudper2j2lCDWQkfkMe2UAeN67dRleuHdlkHFGtlX6jlULDKtYa8r/zceXAs6+9vIjbLaNy3J2d3sUleBg/wump8+5s11gJOS9AXjD9OKAUT8j628xW9QsZkvGm2MEGfOVYWO0xd7mDnfPzujnCeNeTikNeIuUkJQDvDxFSs3ldMlkUVMva2Z5wyDTCA+mzdBpQpFnSClItWKzSGmblqxteHF6Tj4syPMhy8U5GM20niH8iqNih1QVIXDwhmFScnIyJUkFW6Me04nnvZ+/x8XFBTvDXd5+7RU+3X+BXs4pN0ua+QxZ13z9/i3KXsLcS/ZGu6S1YTafM9q8i06nKGXBt6ya0Jejdgm2AVnPWNoRgxxymbNTwOZrL3G+kdE0hqQckvU2UVLSzzRGwf07JdmtPV6rbnF5OeWLL55zMjlntH3E1o17NE3FjrpkNLrBwjZs7d2jH3MW81oxXZyCnAFQKI8TFpIErVPobzCdzOhbx3x5TjU5IlMw2HhAf3wb67/ArWbceek1ZF4wOTlitWw4fvyYTDik9wwTTT/roYRk1XowLU4kJL0BmoZCQR4NRSwSpVKcDYGPxjEebNPr72LaJaenR8wmMx6+8ZCb9+7hmiV3Xv0WRVGiFcxWC/rlkN2bd2mrSXjYlGexekFPlAw39qgsTC4uSco+QsNkeoZMe2ggLzZoRYtPMrxxCNMwTjJ8krKKmgWdpiQqoXWCZVMjXE3aSGxZ4nyN8pDqhFTlrFYrvBP0dE6RpiivMUajE433ljQdkCQO6StKtYF1FctqgSOndTWz1Yrap7TLC5K6JBmngETKr/rH/zrH2vDBXzEuMi71K+85sA0ntkE4h3aCNMoYQx8zgYoMaGCTglOhlCpmdzVOSTwyZBClCuBLBDatxVF7TxOaqAQmRong/CgycqURPiVxLlpiBzZFxuCiAz5dACKj/GVtHpEIjNAY46hXKxIlMG3L0dEh7338IR9//AsozpBlSSm+y7K/HYI8BMgA9LyxQA2ekOmOUkIPpDJhYzjmrVde5xeN4eTiHGcNsbacLqDBX7Fj4QeKfq/PvTv3ydIMIQXj0QZKSepqznKx4PjshPOLc5Z1tb5WHkI9S/y3FyKaxwUkKPyVO9f1vjqdDCp+LdbAz18deC2M7AKJdYZ/fRgyqdhUCTtCsQuMvCexLbL14BxGeFCh3lBbT9/A2EMfR995eghSAcL60MDcK4RX5EJS6hyT5qyi5XOSpWR5CVphTMtApby4PGGGxURZkhcCi6XxksoGaZFUGb2ix7Ao0EpHuZXDWkOWFAgpMVRIZRgmllTNadtLrC1Algi7oLULlC1JdJ/UlygytNQ4bIwYNULqNaP41fj1DK1VtPwOCQoRZXXORYAlgglHJ0V0ztA0BtUqVBKciz3BNEZKgVDRZRWJj4bjomsDEd1aketIFoxbPyNCqAiUopOsszjXuUmCUr+8zwl1ZdHvvV/3BfQxeF+/7tp7vHdXrrBtVDxIGfrISvVLbFpXQyV8CP475jkUDoWjWu9xtjt2/DwRAv1OVB1OsdsZ4jxGAAoe4Qh17j6AO41Ai1BrChItICGs39YHTFAqKPAkwpPJ2NvNX7ffCDVj66nGR+WCxzhPGxmgygVpfLhmEQ4KGQ1UQgIxFx4da/ikB58ZBAEYGg9Lp1Dxmy6aIM0spScVDlJJqhytk8xaR+slxklSGe6tLHFYBJUNCpJMOMrCo4Rj1XB17aWPSgiBkpAISWNdqGFDdLk8CgVlEuY2AD8fzJkCF4YVIJxFCUiVpNShvYdxnsZ4Wi9orQ9GIBHoZTrUX+ICUKza0NoEd9VewrrAMEdkHNp3iY7jc6HViQ+byq+y4n0pEV6/6HM8PyVN72FdytHhYwajIdr0MM2CQZaQqYIbN3Yo9k/x6YjKjbG6CjbJxlEoz8dPHnOSSpJXFrxx7z7paBNXTyilxriWyjo2NncY9A84uTxjsWyYzRbUpsUJwSDt0VhBa2yo3VEK4QwIwWahcUvFx6eXIBUvOcN4UOKA4/MTbu+MWZ294FB6BskuiRcsWs/KznCkNNaS+ilnpxecTBf89NNnKJ7z8OY23335JfLccjmZMz+/wDLn1ddf5ebGHtWqZXJ8wsf7z8mLgi+ePeMb926xm++wXK7ItGGjV9A4mDSWVaWpaoNNNlksIW8O2ekXNKVmJRyNV1xUlowlvbTP2eSCXzw+ItGCm4OUDz/6OU/3z9BZTqvHpNmMve0dhv0R88spW3u3GW7fCtaf1pFbjUpzeqqmOjvG5htMZ0eMlaeVgsbAfNXQNJfQrLD1lMWqpjmfoHUPrxJGN++ze+t10nxMU/+cTw9+TO4crfDsH70g8xJnFiyWjiTvITT4RNA0S5rVAm8tjbdkm9uI1tIcvmBQjKmcpjnfZ1zkOBTHkwnVqmW8s8vWzdeYzxakwiOWFRWe1aKhSIdsjm5SZiPm7RLTTFAi5da9byHtgn6xRVIZnPM0TpFnD1FP3kPolkW1ItEFRZ6i7SV1dYm2CaNylyUNtW3IRYlAIZygsQ0tHtlqkjLD6DRmtiSpTBEWVNJHjSW9dMSqdcyWDUlYkcNiKAXDwU2yNOHi/AV52ceKhNlixWIxZ75cYFtoyVjNTnHeBGlUWsCdnS/j8f1q/AojgBt/7f9ibx8lgyW8CJuEdR7rDFcuCDFgEcHBMWjzsysJhgclbHAxi/JDxPUtPkotugy3DxuEjMFGqhQmCdI7K8AruXYLuy4JwbmY9Y6ZvVhbgJAkScLOzh7DskeaplhnObs446Onj/nwyQuc6iOaGe3zn4BLsLe+jtxIghGE66QdLgQw0Z3SOY9wgtYapqsFQkryNOHW3i0SrTg6PWXVNPSKkrqugZCFJMpVlNLs7T1ga3Ob3Rt7fPvbbyO84cOP3ufx42csFxccHB5TNfVaHlwb0x0AiEXrIrCTQjgECuvNusEogrWDo4Are3HENao0XnPf8WNdXUpEdp4gwRTEGjpBriSbMuWuE+wJ2JKQGIdqPFZZrJR4E0CitJbCOQofMrw5mgwZNmohUF6TINDOUwhNrjJmaUEfiUokejQiywpQAmNbSp1QLWY01Qy0CqykCHJNLyReE0yIioyNQZ+NMiTRkCH4mNcVRoR72EmBkwqhoDYNbbvEOounQooco1YoswBV412NUgVGJjGjbPFW4IVC6K/MjH6dQykVZFf++hoWmG3vPcaY+HyIdfNoIgPSti3KBeOH4L6qQgmZCA+PULF1hvfX1qtr9uPxL2ttVDSB92FxFBEUBiFCWPfCWirWLHjnBNKtYdJfS4YQjhXYiitmQ0R7fh+depwDrEU5h1cOqWTsOynWD71AIIVbW6N3DexFlMh534GmWL/mI0MDUT4YGbV1/SnXmPWw4FiCK+RVXZuN+0Bg1aQI9cZSXNUNS1i3w/Ay9InTnSIgTnDH5HBtXVMKFJ7cQYYP5RxS4rygsmEfSJWkp11IBAloo+wV5RFOoWSoCcR7rA2OlB5JIl0EaoLWSzLh14ZPmRKkeHIVar4WracRsGohV4pMBems1o4Ej9GStAXhQCkJ0pPEP9YHJ9GqCc3JvXQkUtBLoLUiSERtrF/DkScS4QK76uIcGQ81EtuGuW2doLEe4wSdnkQLTxbX+8Z7agsNsdbPh+cktDKQGN9pKkLz7ADuwnWRXN2ra6fiv8T4UsDZ6uKI45MXJF+7RVMt+fTjD7j10n2+8eBN7PILRkXKtE5JsgGjjTuQjumXGW9/4xGOlGU9YXdU0i7O+fnnZ1h7we9/769QKsWLi0vygSDVCbmWeHPJTply0evx+GSJNZZMe+7tbFEoTVUv8c5T5DlaxcyzkMhMkvYyxKlnvqo5PQs9xPKiQOdzVJJRNwbjKlKteLF/iBOCezfvM1nVFNpwc2fA4eExQnh+91vf4p2PPuSDZ6cs2xW/8epDbu/dpBj32dnYYzqruTw/5uPnL5jNaopEszfoM20MT0/OoHeK6aUIWspqSqkEGk+/7FO1K7xQTOYr5i+eshxr7t5/AJdLzHxJ0l6SZhnKtyyWKxof6llWjSNRKUWacbGoOfrJu/zMvkueZ2wOhyQa3nrzTV75ekl/NCBTFq0T+r0c2Wyj8MxFRo7DuIrGCSaXU7JyhLMWfzlhsLnH8vPP2P/sKQfbWzx47TXuvfpN2tay//Qd3n33TyhUSjneZDo7ZjpfcGP3DqPNLRqhaOqKtjGs2rBgp0VOsjGmHGxQ9G5ifIOWGtNYVucX2LIHSY9mOWOwMSDJU2zd8Pijf00hHfcffYvPPvkZOk04m9UYb5Heo1RCUW6SDLZZzS8Z5RuoxAEt88UZOh1gTMP5xXMq10I7x3pHtarpiT6JEmRpST2fMq3OyLUkz8bopCRRBXOzwNoGZTyJdqTSoZxDZiW51GRC4iyIokQmPbJEkaxWiCRjtLVDWvbBh8VfJaEfy2o2oextMl9OuJwumM7m1FWNj0EtraJAsqjm+Kr6//VYfjX+ex9rLmYdTHQyOkkoLu4ymz42FxYxqEAKvAyNqpNOyrLWk0hiEVIIbJwHGaQ2xIW+k2qHv8P2oGTsy6AC2xbAhohg5DqYiPKNGDZ1LKBwHqkk927f4usvvcbu1hZJIrm8nPDZs8e89/gLZo2DLAfvqWen+Oc/IHEOnd5FDVQAJD7kz89OTjg8OOLxkyecnJ7gTAiUnHc0Vct0anCmQWnFcDggq1sSranbBrzEqxj0+ITbew/5ze/+Dr//e79Hvyc5PT5iNltQJgW3d25wLCwH8hhjDXUbJZoiMmMifC9EqB/r6hIQEqEUwpvOrHKNgD0eRWh9sLbm72pL/gJ9FmaSmHG/dj8Q5rkQmqGHTeHZc5Jtoch9g7M21IhIG7C78yjv0I4AwBBIYbvEbChklxIZJTbKeKTx9FqP0YomH5CPdpBln8R7WrsikYrxccalnWFk1OoQ7bxFl28P5jBaK7Iip8gzAKwxOAGXbUUtPAvvqSVMMZwuV8HExhnABTMo5/HOIJ3DuxanG7zOA/PoVvEZUOHPV+PXOqTsLNU7BkvEYD1I3rrHR0qB1Bop9S9LCAVoEdpk0DH00Q/UR+bcWhOOqzubBPDGYIwNYN/aNTjsPj+8TCCER+uwnq2NF7okU1c/qq7MQ4DYx6wra7Hrn60li3TYMCRqrLVr6WQArB0XtJ6WcF6AF+4qOyauXhQC7wDC1v2HicYcENfwbpUIjqnrrooRzIUG82HOA2MWWB4vBDI2OnZxxZZxHQ/mE0QFRtyHfIh1Q3Io/LGGkDCLygGhA5grvUPKToYXAKKKXbwCVAvtU5yPJkcqSEltlKvmSsa6Lxexc1eXFdk24UmUow8YHyzll1bQIqlNx4ZFds57jJXMTTDgQMrQr9i6UJvnPbULDb+1ICT84rxbD/MmqDVMNGjxkVlbtsRWCg7rIZNBcm+MxHlJ1Tpa78IafO1atnQKe491gWGLWpnACPvItEZQJmMch/DBBdVfOQLHp+3Xx5xNzw8oE7C15Wz+nIHK+Cf/4s/x3214++UbaJUxnZ3RehCywLQ1j24N0Fby/R/9iK+/ts2jB2+yuzOm8paN8Q6nF1MGc0O9mKD6WyRaszPe4uhwn8vpAmssu/2EPC+5szWmSDTOw91ii9Eoo1/2w2anNFujLba2b+E44a0HmveeHfLi9JJFteTOzW1oK1bzOVmSsFVITGN4/PyMqlnxxps9Xn31ERvKMBzmvHh+zA9//ilvPLjLNx+9yuH8hLu3dhjfechGNoJ6yv7jx0znMzZv3WPrzojH7/wp9aVBpimJSvHK4BYLmvqEvExZzlesdEaW5Cg3Q8sEPztEVzMWZ4d8ejSj7G3SJjkuKym8o9ThRkyLHrd3UsYbtzi6WODKCWnecHGwz3K1IE0SrLDYiSFLEv7ln/6QP/3xT7l39y5vf+vbPHzzm2zt9kmV58wb0qVHlCnt6oTF5Rm1eYbWlkf3H9A0JaZeMK0qzs8n7L30Em9+8/ewreTFwWd8+O6fcnR0xO7mFoskZbFcsXHjBhvbO4i0h6srmsUkWLVK2NjepNjcY3TzFXQ+4PTsGUW5SaF7HO0/RpYZ9/dexoiGQbtCozk9+oKjZ/sUyuFbx3sfvUNlDNrUKK1YVpbzzV0WD84Zb+zQ7/dIdMLp4RN6WUZrl8wWF9RCM69nVFXFUnhaX8NqxcwqVs2c3eEmMhlCVuOTHJ0ocifIZEaFQUlJoQStdOgkIxGS1LSIzKOkRgqNUBbbNBRpRpYOGPR3GIw32br5EJ1mtK6lNQbvGoxpUUXBbD7BeUGa5wylZpEsqFZLbG1p/QKpBmRJwrL9ypD61zm6ou2odAuBSyeL8/ySaYt3nXNWV9sUFngXXarW4hevu0QrHV0WevE4ROfPvs52x4JpL5EEhzXvPVIpRKz/ckJE4w0Rs9JwLRwn6PHl2mHKC9jcGPH2K69zb2+PLE9ZLhc8PTjgg8dPOTmfAQqhRSyotrCaYY5+AlsOtm+xXNS8ePGcP3/nXR4/foa1kOc5RZ6gVAjfjLXUy4q6WTFfLKjbhkRIRv0BeE8vLzDOsqxreoMNfuu7v8vf+3t/l1t7O7z3s5/wxaeH3NjdZdxL2ey/xnK54pPP+gjnOJ+ccTI5Z76IrrPraxBrYGIggZdBaYfEoaP5gV8rr4QUSAVSBFMM3+20UkZnuavLdNUwrbOcFiFLL4PLmHaOHp5RdF/c9ILEhmAjGC/4tXxTxsow2QVzkTkUMgRjiQflHBiHNw2+WpEJwVJKkkSjyz7ZcAMNWLMEY+grHRryipyFysO19xbvDbVNqJyicpLae2QiQm9L4RGJRPiWZlFxsayZrAyz2nI0q1gawKexvggQFuFXOFdjXUvqDMq3ONdDSI0U7ToA/VVspb8aX95IkjRchshchQUosF5pdF+01kUlgAKhgiLgGnPVoQ7vHTgbXRljiwhro+TLRXmaROrATgXDDheZe39NksgadHVATQhigl2vWTNxDRyGIdfBuuh6THWW877rR0WsUfPr5/Y62was5ZFXzbIhuMrG9iNSXgOSQQmgCWUYPnjurmXb4XOvOVZy5SDrCdLBK/4s7gqiqwkNjNr6WYmArEvkduzcuq93l88jSDIhAAwRHTWF8KRJAL1d7i8QiqGflyMYWaju/D3rliehrcmVMqBjHk1cKyyOBEEhfHT6DCCxa/QcgKNHuQCAciARDueCUZUSNjj2Sk/VBmmhJMgVjQ+ujkJ4hil466itXBt8GBeSQSLk2EILJjppbrwPfZTtCxGamcfUXG1dNBqJDK8E7XzoZ3m1lAOsmUnjo/MkEYjiEcrHno3h+jgv8K5L5LkI3VQAjWvpxb/5+FLA2dbdG7yyfYNmXrH/5JDp4px2Nedg/1O+/uYjVN5nPG65t5fwzvtPaOoJm+Uu7/7sI54+e8yrD/rkqeaNVx7RWAHO06wqji+n3NoZIL0Ncq5Egc4YjDfYVo7hcBvd22A+m1At5rRNxcwvKHtBo6p0QtsuOD8/4cnzE1ZVw53NTX5/uMn5corygq2dXc4vzjg4PSddQeq2OT875fnxMXmu0E3F7OAQk7f0ivucT+ekuWYpK+4+usm3+l8nTRTvvv8+/8X7/wzpHBrP/Vsb3Nrbo3AVO8MBL84nHE+mrIxls0gYD2acrS4ZjnrUeoM8l7A8YFm3jLZ3KZ2hnhywmJ5zPF2Q7x/w+lu/w/nUcLmYsKumbOaKdJmysXOX3vg2Np/itUflfc5XLRcXCU1VUeQZSZqgpKBXlCgl+fCTD3j6+HPu/vmP+M53f5sHX/sWTk1R9pCLhcGs5uTCoMwEXQ84PD7BtUtK7yjHd9j2CQ9e/QaiyVgszpjNK05PLzAXR0xoaKo52Sjn9W/8HmUiUdKymp/QzCcs64rx5hZ5f0Te30JkGWlZkFcjfGuolitEmjMoNkkTweZwj15/g5ODz8nKTbZuSszijKOjc2ZLA9Kien2G4xGL5894+uIpl8sLyiJlPBzR7w0QzZIyzSl6Jc5bjFJ4ZxBOYp1HFAOk8RSXS1aLS15MD5Flwag/okwLZDrAG09dzRBlRmKXKGFJBht4E9yBLA3MZ8hS0mpIk4RhryDrjZAyC8kCIUmFIssSMjStsbStohjv4JVkcXkKbcJoWNLYCue2cMYyvTgjTe+TFT2apkIsmi/j0f1q/Iqj24S7DS0E/HH3E8F90a2zvZEpiPIaK0LBsFoHq5JQMRxs1UWsieq4rq5YvpPNORfcDdcAwXd9WELmdC1RlBJHqJ/ACaxSsTE1EaTErG/sl5MUOa++/AqP7t5nNBjQmpqDwwN+8cXnfLZ/SGMDbJBCEtRGMsgVkwKSlE8/+YDv/8m/oG5skHsIyebmCOssi8Uc5y3eQdNWNHWDbRtW1SoApETjqophWTIY9OkPN7h19yHf+Mbb/O7v/TY//rPv85/9J/8xx6cXgKNtVrTVilIr9m5sU5Y53/n663zw+ROSJOXz5jmmNWuQ082fJ1rNS3H1OyGizCt4nCkRnOukitlPEQrqg1wz1Gx1MhUZWyB0mdTrLqo+uk4q60hxFE6QeYfGBsDtO1BOtMIP2XnpYwClgqOmBBIv0DGLn3iHMy1FHYxktAeVpDQSlFYkRQFaklYKk8zo6x5DRqA2cEkvuK/5YN5hXEtjNBWKSsLC1yihkUkwXPCtZSVaTuoFJzPHtPJMF2HNctGtzHUS20ALo31N7SHppNtovPRYKpw31wwUvhq/jiFUZ1UTmkSvk0ixhksIiVI6vC5JrlBABBF0DqDS4drAkJk2MGHORTaGLqgHg0e2ItR4revYrsCZc1c1aJ27o4+6S+ccSV4gtA5r2hrAxfX3GiAICSx/5X57TfLo15LFAImug63ro3uPFBLrBJ2hBP7KsTGcY7TgDykyuu6Mzouu6m7N1KluhiOIchHfdozaLz8NgrXpCF1tcJdQE9H2P1wL71nP9fXEYGe2IoUkSVnPjxSxrYD3a4t7RAc4wkFEl4QSwS0yXCywHej1oLCkQmCcipb0gbXyNjhOKxnAbzBc6uqvWJt3pMqhlKeQktrZK6AsJLUJLF8hQlJTSRikFusEqY2tCyRYK9bJzkSGk7SOoBpZz1UEcYCKDJ/1AhtdGBWOVHqISpeuMXsAsVFf4TtW03c+UnG/D9fad4wlsaVEN29eRsMVcCLu13/J8aWAs+9887s8eXzMD975M0a55OX7e/SLhBu7fTQO4y39PGV7rNgZSs6nLVqkPD3Y53JhOT+f0roF927s8cEnnzKva3ZEAu6Sfj5EWkeS5shsQDqo2RqPmS4nfPz8C1bNc04uZ2wMBxTCUlqJcxlSStJU441gNpvxeH+fpydT3ks1D3Y2SRLNxy+O+VpW8tLDlymznB/87ANOL2dsb+ZIUfHqrZe4nEyYXJ5z78Etzi7PefnRXR7cf8jGYIPF5Ijjw89AKJrlDOVbVo3jfFYj0oQ3plNODs/ZLHK2bt9g6Swn0znGWi5nJwzvvcEg7XP6/JDFac355QX9IgXTcuE92sy5WNac1HA2bclszaDImfse+SBDILFaQzmisg1FWfLwlW/z6NE3ePjom7z/43/F0bPPOZlc0rnJGW1Ik4L79+9yenrC+eUJ/80f/z/J/9W/4M23v8PO7oh+b0mlN8jlkFQrThYLzPwprzx8k7K/xbj9GJFk1KuKTz76Eca2PN4/4QfvvsODfsGgHHC2OOXNR79DWYzJU89sekltMmRSIE2FkykuHVF7SS5SdNZnY1MxOXpCvZhgjadXJvTHI3IlkKLBs6LQCSuRkCSCnVubjGuDEApjLKpdUaQC0d9ksLWBoGFazVgsTxDOsLN9j1T0sU1NW1VY59C9Hhv9TYxSrJIBbfUxp8dnXLiW0qyQ0iMTjRWaROSY+QXZQlAMCkhLjHGgQ2ClZI6tlrTTCeWtNxiMhkEupBLMao700FSG06MP6dfbeKlQKmc43kOlCd579OgGdTUPrmnFAGsd9WrOzmgDVIpxYGzNLDv9Mh7dr8avONbSFOhKIoJkpauPILAgSkqc9MiuTiHKUa6Il25rDkGBkjJKUK7/Jg4XAoF1rRhhK1/Lj+ImF3rdWCyOzuJZeAHWIFQ0F5Fr7i3aaGtevXWPt+7c58buJkp4To8u+OjJUz588oSqbqJchZC9dsF+WI7vwJ3fxJabfPiT75MmBVmuqeoV3lvqZsWgP6Qse1R1Q1MZEHOaagJSo5IMZ1vyNEULGZqrFkO+9va3+a3f+R3u3r7NP/mnf8Sf/uDHuLbh5bs7iKZitlJcnDUkieSDLz5jsmzY3RwzKFLu396lMi1PXuzjRcyudjPqfWgWrQBcBKo+SqeCTEvG/++auUIIfJyNgZkIOW6HXwda64u+vq4haEmcILMmNB/3Fu1DDyUfN2sXJaCd6Ep7EbPYks72XwkRmrrGV+JAuwblPI1twbfIsgi1J0mCyjNEosF5iiSlnw4oVU2TbNJLt7AiwVqDFStad8alqRkIz0xZLlkhpENrjXOCmay5cJZLp1l4zdJKGmtxfoWlwtpVAKYR9ONdYNGcxYsaYzxe6FDjLCqEbxHiK9b/1zlM29KBgK7vF4CzLkAwKRBSoWS3CqkYrAaWDBcMxp2zWNNiTbsGZsGjKLIuIkjTrpJMNlrQR0fGyJDJaMl/nc3qjES895i6QTuPTDWIYLsUaj5DMiPGxDGjEQBYMMwyV8xcVA5c/4zOFOXah15TJUS00zkFXQOwVxb8VwBB4dc2+8qHWjLrg3qh2ylcPI91Ti0CSC9CcgbRuSbG9aVL/nWnF4/fob4Ae+IjJwLDrkTYP5QAqcJ+cr1tiPehdgvfOTN2bGAnw+vOo2ux4NcJRytjssVJrHfYOJVLJ/FekEm3ZufCPtUBQIGKRiXh0Q+qk0RYpJAsLdRWUrsge/SR8RMy9L6cNwrnBZmyGCOj5NWhhFsnekS8TM4LrA3ySxsl6IGBjXL+COhtrLvtZLrexesQ7w/junIEokT9ak6CGUnYf9f95HwwUApHU2v2VIhoyvIrmGt/KeCsmlve+elPODyfcOAsg4HkrW+8ineCRIceNyubkxcVb9y/w7PjluWi4vzynNmi5vH+Od+6nLCzOWB3Y4P3Hz/jsnfJMC04ujD0EksxTlhVKw6Oznl8dMTKwVYvp5GWppZI7/A4pEpIEh2DF4eOD75SiiRLWS4bvjib8vLtXQ4OzqGt+fYbr7E5GPM7b71FOZTc2r3B96zn9OySXqHZ2hyzd+Me0ieIdsXp6Quef/pTJucrvM4Z9XoMix5/5Y3Xqb3gaHLK3t5tSPp8dPQBUihe29thpxyymfeZVhcMteTxpx9jfMvNIme6rBC2wS4ETybnDIqUUZaxNdjEp4bpcsHJ7Jz+eI+5b1jNDcuiQYqCuqqRZY4uC3rFiLqusdYyPX/BwfExbRMywmmmqauKuumTVzXD4Zj59JKt8Qaz1YQf/ck/5e1vfpfX3v42UjmUgO29l6icw9VTRtt3cUKw4R369AvMfIkYjtDDPdzlggff+g67wxFlqrFnh2TlJl4pqrpC9jfZLPpo8QBpa6rFlKzcpMGSJJo8TRGAzgqa1TlOJIw2XmZr4yaIhvn8lP7oHoIzbDtn89Fvowcj6uUU0yyYTi45evGYbDFjczxAlD2k7OHyBiksRX+TvZuvsjr7nOn8nFZnjHZuc+vu1yhGG7TOcHr4GLU44uwQ/GxOtWhZ5QV5UWPtHKHmZK5FO8nKlDjbIGWCtVUAVlKQJSmrumV1cUwiHVle4GRNu5pDUwOKdqmYTRckZZ/x1i5ts0CQxc3AkWdl0OPXDQJHv9dDqoTGtGAMWuckWze+jEf3q/ErjrX8QVyxJU6KmMXsOsYEnibUDHi8cAjXMWdh53Ix/dk11hRShcC82226DaFL10WpSyct8tf/vpYJDo5iPtaDCHzUwwgb7ZFFCMKcCMYkd/f2+PpLL3FzcwMp4HK+4tODY37++HOms9Xaz8SLwH55oWBjD25/D7H9KhftMVXT8tbb3+Wllx6xd+sW3nvOz88RQnL71k22tjbolQXz+Yyf/fwX/On3v88HH/yc6WyCEoLt7R12b9xASMWjl1/j3u3b/OSdH/LDH/45y/mUvX7Cg4EiKUZMp4pmqPjFk2NWxnPr5k3qxvL5/jlaGyRq7bYV9m+/Zh6tc5GpiuxZBLAqBqR0oqSgb1wzb3EbX/+3YzXF1Y/X90JXxxc2aInyBrzCW4FzAi88bQzArPfELk+BcRAhA925eSo6mZaJQVuowxC2RThBFs3wtErwKkEjSLxAOouXoJMeKmlRekSabONETq0aHJd401LrGVUuWZQw6ztUvyHTltYqLlvHIkmpdUktMhrrMNahVYnW89AHya5izaXGe4N1FkdN6Fln8EKSek+iLM43mK+aUP9aR9O0SO8Cw3M9uEX8EnihWqGTGpVmCKnAW5wNNZDOO5wx0X6fEOz7K2Mhh4vsfmCdsQIvZUw+yTWwCp8aTmDdVFjQLYZIpa/YrxBdX8uDiGvrYAReseE03gcbHRGYOemCgUYQGFzVkEI4fWfd+skNQTdhDRcdE3VNwfAXuC7Wrw9ACUKvSkEHrsJ3i6aQa5dBGdmzznxExKA/EITxswnMfBIhmyMwc8oFJkxHMCSFR+sgxdaxzYiIDq4d6+f91XolZLDlXwNbH5gt14HRThEQNq91z67aSSor1vV0bTyPJLJsLppLdVnLdQrRhUujZFBxtBYqJE0EZSsTzDmAOHcyOFLS1XmFfmkCT6aCVNE4QWUEjQ/tuQBaI5DKkwRqE+uhcTLWyl0xltbLte19x+ytkwgi7J8BhEVw7AIjFu62WJIQHx8XAbZFXJlrxSRspwL+FfxAvhxwdvTsE5qmQfYHbGxusuzv4fSIGwNFIhOa5ZzKACpnMBpzO73NalbRWI/Mejw9rzk4PEGLAa5ukG3NajZhvmpRuebB/Vdpjy5Zzo/4+MlzaqHIkpLPDj5Feri7s8X5ssJYT6pTkkSTKI0SAIYkkWwNSoyDI2dJZItuKxbTOS/ckr2dbZSSVO2Ml3Ze5c7tR5yuJBfLS6RMmUwnfPbZJ+w/3ydNEza393i6mPCDj5+yWNbc2Ohxa3uLIpN847XX2RoWNE1FPbvkzdv3yYsSaRuWbU2vzHll4xbDniJdGAQpA+2Yzy+5mCc8Pr+kN+ox9ILPjs7Is4KdPGHpLJfTinIgGKUpTbMk1QWFyFk1LbPFlPl8wSyd45olSR1qv548O2S1rBEIau+wicK7Kca2LJdLBsMBq7pi0Cs5Oj3n3Xd+gBOCb3z7exQl9LfvMHAtXtxA5QPaeslo9x6J1vTyltGNN6h8xmj7JcRvOhKpmZ0e8fSTf029mNLWS4bbu2TlDqny9AZDEq2ZnD5hfjljONqi3x+jYuCyrAz93bskScnG+AZCGpQuGIzuYv0haZ2xc+81EpGS92+QpSWLxTm9pEdS15jFjMFoTFIWtFrhbEOZD9jeecRqeU7jYLR9D/KSm3e/yc29hxRlTtMumB8/57JdMBwmlOWIqW/QosE4i1AOsVzh2waXF5jpCS7poZM0NIj0Dd5plEpR3uBX56xOWppU0fgWYR22bgJVn5UgE4RWXEz2GW1s0i83UDpwKkVvmywfs1w+oyx3UUlBW1vaNrB9idZomX0Zj+5X41ccXQF0iEuiFA66OmykCjVFSgbWyiBCv50OmMVl3ruuPsFfBSuhQUwo2ncuBvgd9pJ0NoaCrha+23yDHbugA49BWmltGxz4hMR1zhchTYgANrY2+eajl3l48yZFmbFc1Dw+a3lvWnBgBjh7fk0CI/BC43fuou/8Lu7GK2yPR/zBluJv/v3/kJfu36EosmDnHKVEHYD84vFT/vzPf0TbGga9jN/4znfY3t7i+bMnXFycopTm7OyMja1txhtDPvzoQ/75P/0XnF+cI9qGjd1trGvInGeQwfvPJjRWMe6PSJVm2sz4zre+zb/6/vfxfkmRZ8yXVZhL38HlcD7Odt8nnKe8Ftd1O3QHvsDHvIlb418RE+sdMIvTE4OtDkOH+pLEejIvyJwn8V2wxDrwM3RNY69AH95H506BFbHw3HaRmEd6GeWQHoUEnaGkplktSGaagUopVnOKRnAsClIt0GqTRG3ikhJhGjwan3r6WwkbNy3FTU2+paFwtFg8KemgxziTLG3O7LwgsR6ZgBVLlEhCgIYAb5BovJBYt8TbJkqwLJkUDIEUh/MtM3/VhPir8f//4doKp2LTY3fFAsnoItsF8d572qZBVMtYf9SBksi8eNZFUDL+Xvjggod3eNviowzYexlrbEHG/lgdu6Zkx8yF3ltdZzCPQ1hDoiRpZIp0El0V6aqzOll5HJ3RiSc4R3oZ6omcC4EzBJMRrr6ntQ4f3SddTJiF311F1NclkOF31xgtsTaGjIE/dEm5zgDEyatjrIPu2M/NExsxCxmx8nqxBx9MjGpBbHLsyWPtXffScBIhEegjyPK/nFEKoKQzzIgnHVi7AMas9+t6LX7pFMJCZ62naQWNV1QugBcpQMtgha+FiHV9jqAOF9GxkGi4Ee41QUgmCTxzC633tEYipEfRmVWFWelaDQgXZKZKOrIkgKzGSRrjsQQjPS2DeZImzKF1PvTku2Z930kQRZybsL+KCHjDxeuMVzwdG+bX91dn8uQj8+diosxGMOoReBlIjagmxTgR2jH8dz2M/1/GlwLOjk/2efTgPmMxosw3kDrh8PyC7SLj4uyIjdEmvgHKjPHGkBt3bvHuux8jdEk/H9Mox8efH9EsG27tDLl/+xs45zk8OsG0kqf7BxihaZczWtMyHBQcnc84nTYsqoqyLBmkKbVw64BDIHDWkgiJ1il129Ivcx7sbJJqR+2glZK6cZzPZjy6d4fjs3Os18xXc26PEsq7D/jRLz7ijdfvYSvNT7844P5OH43g6OiAPMtpLRxOKpyqsXZF0j+gJHyuSARfHF+ipCZVko1ejzLLOZ2c0kt3aFuFtQ15JsnzTfzqggePHrE93uGz93/KycUZeTkAhgxEzenJc8bjknGZUVPSipzW9ZgdPeNyMWVqG3Z3t9krJOkgp795i+3NF7RtTdu0QepkwSmJaVrSVHJ6esrWxpgyz+n3Ci5mc9772Z/x/LOP+OZv/TY3br1ONhrj00HMDHlkAfRzhr2SYriDlimFaUMjXWupLo8ZDkr6RY+it0Ga75DqlLSXkxbDQP2nm8zmL+iNb+N8waJacXTwgtPjfe7cf5M8L1mtpgw3b6K1oq5WlIMt8mLI/PwEJxyTiwNas6QYbCJlRZoN2bn9BuPtO+Q6PCxSWoQ0mKamWjQY3SNN++AMtm5o6wqF4fT0Cc5CUpaUGxsMdc5scchUSDKVUCiJyiQ263F02eDmhu2xYK5WIBRKG4rxLqoc0Z4/Z1kt6TcVVkiccEihsaYGMrRKWUye47yhpoZEsT2+SZ4WJEnJcHybLM25nOyzsXWH3uZtpE6p6hkSSVqUCJmyNbrzZTy+X41fYYguxXstc+t9B5mC06KUKlohO7S90q+7DrD4uHF4uZYXdVm3LkhCXLksdllduixfZHxclHAEBywRWTEd+uBIhWg9trV42TWcjcGNc/SKgjcfvcJrd+6ztbVB0zYcLjw/rQY8yUfIWzlta3GTJyhDsFLfuY+8/Vuw+wq/9XCT/9Xv7vHa7ushW/sXm6PH4MFay+7OFl9/622cc/R6BW1r+OEP/owXzx5zeXnBYjEnTTLe/No3qZYr/vE//iOOz87oD8ZkSvL4suaj/Sfc7Oc4V/P5wSl3H7zEQGQ0bUPbOgZFwa29PR4//RzvLYjOyDtswB0I9i5k7l0sepeoWEDuovGBx7kQtHjbuWOKaxKpcO2vB4aWKHLqst8IpA9Ne9U1s7er+8Wv+9Z5QAmF9YFxU/HnCBlrLK6QYMjCx2SAgFonOOvxsxnCW1S9IE1SimVNahKGLoUsxyYjvC5QMkFkCic9vb7n/qOCuw9r9vYSNsYZOvd4a7GtoKw8SS5wLqdpCiaywK4k83oWa9dCKNPaRVdEgyDsa1JYEq8YO8XYe3LpcLiOpvlq/JqGr5aoXh8hJF5F19eux1mUJTrv188IVqzXu241OruccDE5DwkKa3j15dfQWY70kvPpKU+fP+Pzz77gpZdeIUsz7t+9SzDfAR97hgWpW5TdRYmjUDK2H/FYSwiYncM4T4nAK3vFRvgow/wL9WVrY47wPwHwqNAC4pfq1pwH50KQDjgX196r9EqYr/WxI4N39YsrVi+mZ7rXBWATbCBUTL91FvuOjtnrmCuJFsFUpEVgiczUmtHx6+OkItQqR5unjpeKrFAAUd4FFYeUrBUY4ZqCsVcGJETXQQdYJ9aSVPkXn08RnWIVZM6hohrQ+LDmIQRtZKCS+FaPoAkLbmhaLsRVAip6uGQq1Hk1orsn4Iq5FVGWCFo6UuUQ0tMYiXWhg5mJt2cdGbdUSaQMtvjGSjq7RKVEvL8j5PeAkGsjJnu1qYLzsY5WXqsl9mtDGefidSSAuqtztiQCVGRIu+OauEenv8KS9+W4NdaK7TyhWUxpqwpvG2besJUNGRWO1WrByekldbJgONrh6ZNnvPv+exhjSKQk729xsFhRnF/wG29/nTwvOZtcMD2/5OODM2ZLg8hzdvZ2ubtRkAtF1bzg9o0RJ1PFybymzgz9LAEs1jqMaWlaAyY0Skx0gTMrmmbJoi3wKqU2FbPlisnlFKzlzs2bVKuKo6NDjK1ZLhf8xrce8eZrb/Of/KN/gSNhNZ/z2WxKbj29FAQ9Kl1zfnnORj8ndTBZLNka9nj57quI7ISffvQR3gouljVza3DLOaO85NPnExKlOJGKqXXs7WwxQNKcHYOFMi9w3nG+XJKlkq0e6HbB4Ysj0rSgnizZnyY82z8ldTN0PiQbDVhamJOTln22b9zi7OyMxji8DXndpmnjYuRpreXJi0PsTbi9dwNnDU1Tc9ye8Y//6L/i8PkL/vAf/C8Y7o1ABQvSenXJ5sYI2zoW52dQjGisQQLV4oLZ9JytW19H2AqswznLdDZhnN+lbjxts+Ts5JDpxQyZHGNESr0447OP36GxlrsvfZfWhiyWUCmNNzghKMs+IHEYinzAi6fv0x/dQPcK5gcTEuEp8oy0LMnyhMXlYQygFCrroXsWt7qg9hVNW2MO36dZHWFUS1W3rKpLhIWk2KGyC7zPGJCgBBRKQr7J4fmKz7444ezwjHs3thnfHFHbhptbW2TpFot6Qes1rhwi8oLUzFg14fxRmrTYpDGWSmradoVbLphWUy7PThmUQ3ppn8nB4ygdg8uj5+zefYX+5lZwcdAJy+kFdWt4eOcrcPbrGlfmD1cbdsBSwf1JqlDSLYXDeYsQHkQKvg3yNA/4rog4vg+5rskAfw3oiCvZTpcF/IuLvfMoH/RtMklABWCYupBdbKjidhKzf96jkoQ3X36Ftx4+YjQa0DYtF0vLB1WfzxjRDBKELMmEonnyffzlU/TGXeTd75FuvMQfvtLjP/gbd9kcFiHfuGb+rorn48kxn09ZLOYMRznWeObzKc47Hjy4w+//1d9n9O6Qd999h7pespgf89Of/Tl37t5hvDHm6PCY/cMDquWUtq1YzEuSROFEijUOQ8Wbb7zFxekJm3s3KD/9COE8dR1kf0KKjsQLXQxi8BX6E7mwrrkAXLuNVcTfOxtMCfB+Hbh1bRGAqE2KxyfUm6zrWzxoH14SHNGiG1l8swOCEX2we3Y+FKkrH0wDWu9jjU+415rucz1oKUi6rLfz+HqBm5zi2xIrVmiZIlqJFJskok+bJ5isRKoEJxRSasrcs3PH89LLBXfueW7saEajnCQTVG1FXbeYRtAfagZ9zXikOdjOOHqqcCcS5w2tM1jbILzF+mod8+ENGk9mYYhmy0MpHEaYda3KV+PXM4ywJFIgVbpexUK9WGDfnbfB9RDw3gaGoKOHvWdVG/4f/8U/4sWLQ4qioFdkfP7JZ/wP/od/m9YZ/i//t/8rH3++z6qqSOT/m35Z8Id/62/y29/7XgiUbWhKLpRc4/SOwbLehv5hPrggElmpRKrIajucCTb4zv6yViw8eiKyNqFujghiROeq1/0NgdZCRhbKo2SoZ+paVXRzAnRlV0GS2JlpxPO+0jHIaKsfbOJVJ4XzV6+/zo8LZHQ4BKKxRgKkvuttFmqHO3OQruLJ+NC8WcaaWcRVsgcR1gPnw1rUHd4T2K4OhF3HX85HditKvTvFqcdjfZAYBkON0IOtc7ytHcwszNvwvXvaUcgQuCyjGUehBLkMskbTGbJ0iUzhUUqitWPV6AhK4+/X3zeA5kQqvLdBsqgtZeJY1IJlqyhk1xMu3DcO0Dq8r3GhVy9x5xOEOuHA5gWZqPPdHu5wXTuIbm8X4ZnoAFx35cI7w14vfJibYBjVXYuwpmsVTGNS+Zfnzr4UcDZZtKT+nKPzc3xrmCwt924NKPMxuVI8e/aCw9Oak/o5r7/6JstZzdHJKfPpJcZbbvbg7u3bSHfGcn6JTBLysqRtLB8+2adeVnglyfsp9+/dYT45Z7FqePn2HnsbLccXE4rEkiSKfq8XFgBCRkSpsCNv9xLmS8MXx1PO60uUSjDG0jYrKmu5tTWmSHp8dn7MN996C+8lk0XNm299jYPDS2aLBTf6Oc8Oz5gvawZlyqPdPR7PLmmM5NbmiEEmeX52wM6wz83NIYvqnNtbI7b/yjeZLyr2Dw7paejtbjHc6PEqnkWbkfQK0sWUshBo5TDeocuEN195gETSthYpFVXlmZxP+OL4hFf3btDPW06ef8zjw0vubm+ylzsOn7xHnpZUKqcoR+zs3mQ2OePZixfMlxV126KlQJiQ0U91Ct5xcHiAELAxHnB0fEJZ9pktK9796Z9xcXnBH/7Df59bj16lmZ1QakfiHc+Op2jd4jjEyQwhPdQLzs6eItWb5GmfeSOoJzVOtoh5w3TlqC8PuJi0LN0Qu/8JxrXUlWfVZIzHBcbVZImi39/BNhVCJfSyHqkWGOvo97aQCLa3b6OTQajHKmrO1Rm+WdG2k/gQOZJyhFQ5zjps25AmBWm/DH1QWs/p+XNEUTJdnrBcThFKY41nsayxpkWtGgZ6C9crWVWSg+eH/OLnn3J6esqnn7xg58Ym1hmsNdzbfY+3336V0faA8Y1bFMObFLklOdsnLwdIbekN9vBS0jSO6XTO8f5HVF/8hKpaoOWKXGU0Mg1Oc8rRUwLqS9K2z2h4C6kUi2pGU02/jEf3q/GrjrXzH7GYWETtf5BgSKkQSLwUASAICVi8ji6O2AgOROgLtc6Cxvz0lb6OK86lCxRkbKZ8BYKcAKscSkiETknSFCM9NLHPjxI404YjxYDj/t37fOvV17mzu4PScDKd8/405ed2wLQcY60hVSO8fAUlNOn5B/T7W+SjTf7Bt/v8z//Ga+RZeu084iZ3bR9y3lCtFtGlzyOFpnE1H334CWfnZ9y5fZu9vV2Wi1ew1vLxxx/wgz/9IbVpSbQiSRSj8RidJDjrUN4zKlLu375JlqTU3qPzAZujAffu7PHRB+9xNpmQZxmTxRxiFloJiXAiusW5UKDdFac7HwxSuvobH2QxzrnASPkrJvPqSgTHzRBkhKsWY72IrUMmVvr4cxFt8ePvuppoHzk9FUQ9KAQJEuEFLZ7atbQBtgNBSpZcj7gEeG9wqxlGWkSp8CtJM8hJyh71KqXNCowokaoXmkJLhZCC4Qju3BPcul1w51bC1oakLDVeWHKXYY3Ftp52KBmPFIORYmMDRmPBJ++nmGclxgzwrg1KBGcQvqYTCglTkyAYyZQNISnwWAHLr8DZr3X8b/63/wf+Z//e3+HGS6/SK/pkZQ+NjgkGedUDzLWAxBoT6r28wXq4nJ9xcnZO0xhOzl4wGgxYzGZ87ZVXuPnSA7zzzC9XLFZL7u7dopfn/OK9n/Gb3/wGSZaFJIk1OAPeSSpjqNsWpVKc1Lw4OOTwMMRh4/EIcCgRuSeZrAPhpjHUrVmnx1y0T0eAVgqtBInWJFpHvZwMLTVkJ9GMiTEpkZE9FELgnP1vAVThMzqWSgpB15zaIdefu65v7UBbXCM6CZxDxPVivZoHBj9a8itcrCO7gieBYY/fERHLdYjMefws3yXu1kf9pTqnACxj644oSe0MnrqfdV+38YLWBwav6Q7iBbkISSFsNxNBtq3xNEhmraCR8dr4sJo542mkRwkXQXbk+0SQfxoXjDkKRWgG7QmJbKAzZApz4GhdAN14wbJ1GB8s7o0TaBmMnPChL1mQEwZmjvWcRpDqAqPlY9LTdVttt3jHBFuXkOtqBulYf3/FWoY94Trg7oYjUZ5SOTJh0b+CCdKXAs5miwkb6ZjpZIqpK3QqGGQlx8cT2gIOT6Y8PZmxP2tx6jNeuv0Qbx2LZUXTGBZly43+Hm2bcXB8zN2yIFMFxjhWRrKwLY/u3mS3JxD1OW3Tcrk6Z3tzl7p2GFNz++Zter2cJBUMeoo0y4N9fNPGG7ahqmtmVUXTOHRIcWKtY1W3OK+wCNIsoapW4BUP7+3w+ZPnPN0/Y9TTnNmch689IhNQWcOD23vcbzzLdkW1qrBOU+SDoI3NCmbzBZ+df8HNrSF72zdIUOwfP+V21mOY57R5zQcvjrl78wbbWc7x2Tm7G1ts9Qc83j9mtqhpbcOimrHV67Fcznl45x69bMD++ZRbr9xhvLlkONcMyoyN3NETOYeziovGMypTEtEyHvbR3OJoMuX87DxqbkOGxNjAXpZpyuV0ynK1oFeWnJ2eIaTGJ4rT4xf80//0P+Jr3/kd3vzWd9jYLHn2/Dmz2jHMM+zyEmemeOG4OH7CyeEJvnmOUB5jNArDclXx9PkJwtW89Ogh+WCIVJ7NQQFWoZRntHWTUb+PFAlpsYEQgtVqgvIVoj+kEZK6rqhXl6S6JO9v09YzfAvYmn6/4P7Dl+j3tlnMz0B6bFOzXM0wQpPlKaPhFlaKYOe9uiBJNNZXlMMNNm/cJ2HAxckR5+dnWJNR4hDKcTlb8MEH+/zoT37KyfEZznpWuma5WuGExTaWF8+P+PTFCW+99TV+53cfkvctmdpA9wVaOm6/9IhesUlSFKyaFc/3nzFZnjK4/ZBR67h79y47d15D6TyAR+/I84RCaFy9oG1WaKnxpqVIyy/j0f1q/FsM0W1y4ioTGazsQ0PTsCHqsDGJYCvsnEU5HTPUHofFCof2IUPnnV2naTvp4hVIY/1vH2UkndpGCoFXEitjQ9UkCXISJbDGkLWKRgqEdaBga3ODb7/6Gvdv3qLXL5kvZzw9X/LRsuC87CG0YpRLNkrJqlBMhCQvR+wy5Q9fK/mHf/1r62bFQc7TZdo9YGL/q5qmNpyennB2NiFJUwaDPlmquf/wPkkiOT874fEXn5EXJX/wB7/PjRs7/PjHP+bg8DmrZUWS5jx99oKmriiLjN1xD9tWfPr0Mbd2brJoHW//xqscnhzx2saIx0+fszkcsr9/EDLEMUPdFQS665upiAGYD46VHTAOG/i1bDSB5ZLxWnelHMHtrtvPg/HK9QazUgi8BJxAumhH7gX4tSCm4yRCw2kkqQhBUNfryNAZFFhA4YXDxey1IWSePR7f1pgapGmQtcYNBG2SU1eSKhnQ+h5WJIgI9HSiGG55NrdzNkewMdQMBoo0VxjXoqzCpg7pJMY5ilyQ54J+DlnuaKxgsUhp65LG1LTJCswC51pkbDItrCFDUKAYIOghqJUg8V+5Nf46x/ff/Zhnh+cUZcp3Ht3j7/29/xE7D19H6RylNZOLY7RMyLOSy+kp+8+fs7Oxwcb2TRIfHACb5YK2qWiblkGR89bLD0gSSapz/uHf/XdZLP5T/uzH7/P4+Qvu7t2gX2asliv2T0+4deMmtbEcHZ0wGA5474P3+c/+839Evz/k5t5t3vvFL2jrmre/9gZ//+//XY6OT3hw9w537t4jL4q1oUfTtlSVQSY6xNOdyY8EqSBLElRsYt0BLGttSJKoa/LrdUR9lYhRgNJBQmytj5K28OI1dsCvGS7fAaq4OLjYbiAAMxEkwETDHy+jolDE+mMRBZCh7sx5H/YDoJNjA2tQ1oVvdr2ARYMT69cJwrAviHVvso71c90CJgJwaSNoszGJ5L2g8ZYWwHsyEUBCqCkLkskGTxMTTUp4SgWpb0OvNwhyRoLCoPKCyksyEdkoK0ijq6aMjFKiPMK0aC2pjYrGIIGZ6hg9KSFV4dSlsBinaGxgxlwET9KH6xU8TfxalUJsb+Dj5DnCPt2xniLeA56OG7vObxLZ23hsrurX1koWgsOujC1S8JAJT65sAGaq6233lxtfjlujVTivqJZLzqYzHu4O2OgP+OTJAY9uDcnLPiuz4PPnh2R9yXe+/m32dsZ8+mwf6z1PT+a8+9nnfP3RK5zPpuwsZiRZCCyGwz6jnTHf/eab3N/MOJkG9ufRvZfp9wqOJ59hhefx/gu2tsdsj/vsJGNSlSG8xLpQRKrShF6ZcaOf8uHxNLq3JOAF2/2EYZ4yGBYUxZiPnzyjFg1/+3f/KueLlru9EYkRLGYzDg4PyDJPoVPaVcvl7ILt0ZDaLfns8DnLyiKc4NZAMdq9jRhtcnp2yuPnR5Rlyc2NPS6WE9794FPubW8wv9jn89k5S+tYWsmtac2Nfo9mtuTJ8QWjjR6v3r/HbFZx1ir6lxe8tLfN0/OK09mc1195gMBSaE8/F3qT7eMAAQAASURBVNRoWMAoM2zm8PzkgvnknIOTMy4uF8GpTCqs9zQGlAoOSjQtqU5IdA+tU3qDHtPpFOsU1arm8OgF1Z/8MdOjL/jWb36XX3z8GTjBi/o9vJAk2vPpxx/w2acfU69qmtaEgszYxFIlCuMNwjp+/ENJkmbsbt/gm9/9A15+tY/y5zgLMztGZjmLugJbIdA4N2FodukNt2jaiiwtUGmBd5bGWM5evMNiNmfrxiM2N24hE09vXCBUhnEt88tD5rOafKOHRWI9CDkh25aMN15F4UjEkKw/4nxyTFGUCOVYTs+oVxeY1nBxPOOdP/s5z54/BwSJ0jhnmc3r0E8kSRAkLGdL/uzP3uEn7/ycnZ1tXn71ZfCCzX6fV18/55vffJuHL72ELgfc2Ntl2b7EnXuPoGq5s/eQje09vHRxswnPl2lWVItTLl58hnKC/sYNennxZTy6X41fdcQd2hE2LElkzWJz0K5ubG1CIYLBh5QaKV38vY+GHQ5nXbR9jtbPPtpE05lQiHXNk3NdSvSqPk3IwKapmM4L2V0NCqROsFqRpBqMJcszvvHa67x65x7DQUnd1ByfnfP48JwjI9HpTfA9lBDkQqEzTzUeMC4F3/SX/Lt/63v0ioz1FuY9XkjwlnZxweryiLpuebp/QDbYolf2cc2Cs/NjPvloTlqU9PsDfvzjd6jrBU+ePMd5R+/99/jG22/zd//uH/LDP/0BJycHzJcVZZFzfn6KaRqm8xapCpTyXHzxjJs3b1AtFvTLnM8+/Yid7U3+1Z//hNmqCqcX60p818ytm7m4U3fZ0+5nnTnLlV32L2/Ubp1JjgeKEkSJiHbYV7eHiBlWK0J21l19IlcQUSBJQoNpAX0RJTzCkzloYlabWJPS+GsyHC0xqUZqiREeZxrccorSCaapadwSS49WZfgkQ1iwOFCOJIP+CPoDQdlXZLkgzYLLW4j3AoMmvEM7EZgIDakK4HI+s5wdO2bngrRNQy2vntHYFUgVmFbvyXH0vSN3oTdU6JL0FXX26xzWWfaPT3lw+xbff/8zFvwRWv8Tbu9t8PDeHp9+/oQPP3/BeGOLWdUyO5vw6O4Nfvu3vstw+wY/+OGf8+3XX0GWGT/48c/ZGg9462tv4IqEVTXDJglChh6evm2YTGe0Tc3/+n/3f+Rw/5jf/93v8sXTZzx++oLtzS0mlxPmixXeH/Hz994nSxJ6vZyfvfdzHj97gjWG4XDIndu3efONNxiNRty5fZvpdEpd1bzy+ltInZBojYjsc3haohGI90ilEFKhI/MWcE38vQ2lMMGJNDrtSXl1l8bHWsgI0K5pykU8TmcG1dW0dtz4mkjjyk5FElxyu7WjWzQCuyTW7BxcuQZKrsCG89B2zpZ0SaXO5TBUqMk1kxi/T3xR12jbd8knCN+b2HA7ArKRiu/xHhtNXgLwCYYkynfsWKjtEl7G9TG8JpNBNVq5UI8mRWQR44R6EQxAcgWVdTivqK3ExTo7G48dGoCHercyMVRGUZsrJ0tEaDwtEBGshvWpY7+uWC0RpIlrPeoVQXZVoRiA63VTlHD9fpnJ+6X6Rh/70XmPjD3xpIBE+dBaAI+WoffxX3Z8KeBs98YWG0XG9rBESMHcVKSknK1ajiYzXrkzJBWejULx2kv32RqP+dorr/Dj9z+jNob+cJP3n56wWBneut9DutuAYTTaZuuGpVocU/oJiF3mVcXB0QmjYUFZbvPowcvkQjI5PwMkKi1ZtY7WtrTGoFuL8JJhv+TmxoB7NwbsHF4yryp8llKWA0S1xNKwOSooypze4GXGWxvotEfezEENefLxu5ydvABbI+YlP3m8zxfHp9zZGrAzGLDwnnFvzKjnmMxm1K1g1bbcu7XL/uSMy3nN5aKiqhtevvcAZ6agHI92Nvjzz48ZjDZ49dZNGmP4+OiEQZLx5qM73HnwkIODfY6XDVorpqsaBBTKUk9PuLU94N6tDar5FC0SDi6P2c17DLZK6tWCxXKKxNI6hxHhsXfWhnoIrcEGKlxpjdaStq6YXnrGGxtY29I2ltVyToLDZPDpBz/lk/ffx0rY2tpiNp9zMZlyfHxMtapjpiE2cY0ZLoFHaUme5iync9q6wruWk6OGf/Zf/9/50b8e8+rLd3n9628jhzd59uIIs/oUU68Yb2xw8/ZDLi+WHD59yuZohOhtkPYEea/AlSPGO29wOfk5X7z/HkeDA+7cf5mN7R2KXoHQMNwZcy6OaVtoXEXbzBn2NxkONsnzHqlWeBeko/1bD9kYb7I52iUvSiarCxbTE3YPTvhn//KdaCEbahrj2gXK0bQu9I9arXDWYkzL6ckpX3zxFGRgUvx/+UcM+32+/rWv8Qd/7W/wvd/+Ld545dtBg28ayrwgSxVKqjBrPtD8XnhcneCznCztU25tI7Pel/HofjV+1RHlDa7Tv6hYL0bI1Mp1o1AXXy4iYJLRFTA0ffEOvLE4bYOUyEuk11dUTTciYLte69Blebs/ofzJ412LNwkijc5UWiF1Tm4sooTXbt/la/cesLk5xDnD2dkpHz17wkdfPKUpZqi0ByphJfocKEFiPNva8bv5OX/nay+xvTXkKt0sQpbSWdqLZ1y+/9/gF2dUokTIm+jBNr3BkMV8SWI8pYXpbMHF+Tm9fo8f/uiHHBy+oG0Mt2/fYrms+O53f4M/+Ou/z9Onz/HW8vkXn/PFY4X3sZlzr0Q4z3yxYGO0yfziki9ePOPe3h0+++gTqqom1Tq0nuh6NcW9V8K6/033HeKVihvzf8flvsa4dZny7rKsM6/+eghGdPTq3uuQTqCRpNEYwRAYsy78ShCkUpHEwNDKUINmYvAhlMLI0EjcSIFJNT5JsApaEQ1EZqF+emEb2kzS9vdodIoXCoFFuth7JxVkhSXJQvJSJ+BlcFsTQoBya3CZaI2QmkR5vG/pDRzjDcv2bsvjXgtzT6ITGlmg1BKPI3UFPTGj71t6QCp86J0lBPZX8ZX+anxpQyBASj5/tk+iFbPFe/SLnI8+zkilZ7zVZ1wO+Jd/+g6TyyVaS3720Rf813/yY6yDxaom1SHRZK3l40+f8MOf/wLnDKPeACcELw6OcS7IIQ+OzmKSymGN5b/643+OMRbnPNPL+ZplAnDWYo2haRpUojm7mKKVYv/wiM8ff8E//5f/ktFwwJtvvk6ZFvzmb36X937xU46PT3jz9de4eWOXjfEGSgWVgk4SpNaBMe8YJU8wO/F+DczcWhMZTDWsc2sWaj1rAgQ2iHZdlKfHdRgCs6TkFTCzcQ+/FvqjvEdIF+R7xL6KeKQPgXzHarmYYBNEO3lYL7ndOYkob/Y+mEB1aigXgYuK4ETFSioR39O48J5Qt+pQQjG3ARjmEhIRlBAhMQQQTDhMNFfqWnmYWK8Xqqs6p0obHFsJoEUKF/q+EXpxpgTG3yNoAWMEJp5Xhqe111wQO4Alws/naGoDxkm0FLHpfbiuruO84jx07OL19Tz0g5PrRfs6S9Y5OIY9OvbxIzStDu1NrvaQDgKv3+89UliUDOoHEUWqAkEiA8j9pRYV/4bjSwFnvllhhcOZinFZULUSkVju3BxzOp2gpCCRnkQpMC0npy/Y3dnkG2++zMnlFIzn7GJJqRT6pTFKhqJMhGU8zBHJiGq5ZFmvKLMe+Gf0+rucnS/Yf/6M2eUUhETpjMZrLqZL5nXDrgjWvvPa0JgAg1fLhrvjMT5xbNx5ifmqQrYXfO+t77CqKxbLS7JUkaaCRdPw+YsnDPIxe7d2eO3WmB+++3P+yTu/4GxluL87RjiYziq8txzOFuztbvNw9yamXUBTMz/4nHHqceOC56cTPt8/gmbBrVt32HrrW6ySp/z5QUXRG2CsoZdp7HjMalUz1oKnT17w+OiUMi+RytO2FVpIdoZ9tjYyKrMkz0qyLOfF/j4fHV2wUbZ8bfQA6ZfsDvukWFokRTpnulixrGqMs3hv0V5iGwfG0LaKNE2oraFpDcNBH28biiyhX6Rcni+ZVmcomVAO+zTGcnpyxsXFBcZa0jRB64QkTdFaB3rdh75CiZQsFwtWqyX48KC2MsgMzuuan84uefrklL17X7Bx4ybnJy/ArkiVZufmPYw1zE9e0CtT7jx6hV5vg9HuDT794FOOn3/B5OKQxeWE7b3b3L7zgG9+7/cYb5ckeIrBNqtlxXI1DQ9Z0sPKIZVLUFaS6KCDaEyDQpLIjPu3XgYlGbY7uN1X2dm+4Fu//Q6ffPQJrnZYZ+MSrBDGolX47v1Bn7aqmM8avAsbTX9YotKU5aJiUVX8+Kc/5d333uf+f/5f8g/+vf8xf/Wv/xajzQFCgDXBkjq25wvNJCUordi5/QreNkiV0csHX8aj+9X4VUcXYApiP5m4Ecaasy5jKoXEebtOWoQAQbFuxOs91pkgL/YKaxVadnIMH4uMFW69xXcBgUMIF48VGhVL53HGIUSLp0EIiU8UwhiSJEMmkpvbm7x15x67m2MSpbi4POezFy/44OlTFtM5onqMUDlKpTTyLrXqo6zggZvwt7a+YFxtcXGyz+buXa5CDk87P2F1OWEyl5j9J5wcn/H9fUu+eZc//J/8T9F5xv5H+9y4ucPjx2ccHhxwcX7BKy8/4smTz7i4nMasN3z80Sfc2btBniVIIbh3bw+pwJiGPNFoa7HWcHAiWCwuuZicsbW5zfT8AHzDjc0RR+eTaxtpDGKcD01hI6sVHJ+vjF0EVzLGq42e6zN/VZfW/SLKXbqkbej1JK/NTPhb+hAAKARaxF5FPshdrA9ZZu1Dg93QzDxc00QKrJPIJCXNNUILVgJmPrgNWxVbU3sfrKrrlrqdoZ3GjD2LUnPpNV5GSSQGhSRNFVluyXJJmvpgYCNjRlgoBJD4EGqILuMtPQIDrkZRkaQ1eWHwokVIT5Jm4HIkjoH0DGzJRjOjRJBKgYuy2/YrR5Bf6zAmtDmQUiK9ZLZYYY1ltqpYLJfk+wlJnnJ2PgcB1kqca5nPq7UpRysV3ldBOiw9TdsCnrOzaWwPEl0WWwsCWmc7kh3rTFQKeKJXw1oOKESoeWuNwVfVOqhNtMZaA15wdHTK+fkP6fd7LKqK2WLO6ekpn3zyKmWW8Ad/7ff5xtvfIknTwBL5CGhEp0iJiRh7BQqFEGgVAuIADKK1vOus9YN7a5e+ca5jqqLTLp2JUFRKXHsfBBuz4PBqcd6TeqK9fidoJMrsxJrR6uSEnVywA2s6Mk/eh6bNwLqpPQT2X8aEVPe5hkgoxe8GodGyiUDQENagxkPrQXiF9VB5TxvPx/pYW+cDEO2Am8QhvUcLQaYUxjkaJ/FCobsGngQA3Ai5Bl4uXneLiD3BPFoHgKSMpLaellg7ZhWVu1Id1Dach6BrY9B9/66mr2Mf/Vow4dbJzs4luVvVPZ0hC0TzJh9ULA5Jg4xr+lXTazqAJqI5iwhreQDCnkRCJiGRYY6uHJf/zceXAs5uDhOSpmE5W3GwuGRzXNK2Dfc2RiwWCyaXUwSWi8pS1Y79/TN0Lvj2m2/w8y/2+dnP3mdZrRj3g8xQK4lONFnRo54dkbgJ1mxjTAteMOiPGGRDPnz2GSeHB1R1TZalTGczji7PeLg34Oz8jO3ZlK1UsaqWHJ+eMR7ucjRpmExPePnOFuXiklE+5M69N1nWhs+/OOJydsErr9xEkuGM46W9u2ip2RoMWC7PuXf3Hv+OUtgko201v/jwQ5a24t5miVo6np+cUJs5O4M+O/2SG7sbmKphsKiYXS5Zriom84b5i+ck4212ezm/9+2v8en+BdM6NHy0UjEeFYwyqGdzyrxEJeF8Vq7FiBZvl7gWlgtNPT9H5kPywTZpccbSep4dHSFVSuMlm+MRVhes6pZptQpyQ+9praHxhkQqtA+W76HZn0Z6i6kXJElKYw2HF02wPW0a8BXT5RwtFct6FZYoKZEyNIzUWpOmCVlsLG2N43I2Y1lX64ehtSG3kmeaECZZLs5fMLk8wv5MUFcL7t67Q55plvNTLi4miMZQDnp88dnnnM3mNFVLVS/jQyIoUsViccnl8QtW81MGwyHKr+gXCaNbj9h++A10UiLSPkhJVXtW1RKtochyMA3L2SmbW7dokGBBkCKVYG/nBv/+//I/4M69u/zH/9H/meefv0AiQbiYGEgoywJnW6bzGW3borVHJwmDfo/aNCRakGQpTWvwpuGzxx/zH/6f/vf88T/7r/k7f/sP+N5f+S6b29tUxpAkCkkobhVCMR7cjJuYw3u7XmC/Gr+uEXrNyKhx72qPkNdkEjGQ6VhQ71281zv6KzRrtV7gnUHYULjuvAt1O/HYPtqDheReOHZn7S5EcPYKgY8Db/EmWLQ74RE+QyQCbSXj8Ziv3b7H7e1t8ixhsZjz/PCIj54/5+RiBl7iTYO5/ARZbpD3xuhhhnMtk5/+MZ8cfs57esi9epM/+Ju3ECpsH847jj99n/f/9R/RLi+gmvPxwZIlBQfPDvmjf/T/4q/8O3+N3b093n/3HW7c2GFz82scnZzwT/7xH2Oto20aprMZi8WCk+NjvvjsU84uL5hfXjKfL7DWgVIkWrI5HPLGa68wGo6Zz6Zsbu3gmprL03OkkCxXS2pjCNnsa+xYRMw+9lLqOtp0v4cI1lzc0L2I88wafF0HXVGrcw29+RAMEntAxc9WeFIvyICke5sLrJn212VJNgZ2MjQsF7GGRGcIrYL8XGmEVvFecjipIgsQkkU2Fs6nraN2grlVLLSO94bBuRYhISmgHAl6fUWRKZQOjL2IrF2KjoxA+H7eOqwPSamqXTFdXjCbLzErg2uWGBsSCZku0AJGVrCZDNjC8v9h78+fLcvy6z7ss4cz3vnNOWfWXN3VQHejCTRAACRMAhTBwRzDQUmUI8xwkJKsH+QhFA7/Aw6HFQxHWEHatERZlkRanCeJGgASIqYeAXR3VddclXO++Y5n3IN/2Ofcl005wuyOMvsH1Y7KysyX9913zrnn7L3Xd63vWgOv0DIYnAR49+nc9cMcxjiUCvOSMQalFEVVI4TAWkvpoGoMzpqu8BBucCEccayRSmKNo6nbrq9TUNe2kwkChDnM2f77AIIbqrM9OwTO2S1DFHq7XGe841BaPCffllhrqRtJpBVSQGsMZVnz3//qr24B3OPHzxgOh3zjW2/y01/+ErduHnK4d8CP//jPkuR56DMTouuHddspWnZatN6J1TmPdMEm3tgriXP4lt7QyaGlQAftH57O2bXrAfNbpo0r/7+esekAmXUuMNpS0luNXFnKd6cuQkFI4EmE3DrJWi8wnZSwN+boQ4/FVvLYA0i2wFiIED5tvMeKYBBifOhra0TIVgzW+oH5t/5qzhO9yZ53JL1kv5PfN64vbgVJaOT9c/EuQcIopcTYkOmounkSguJDinDVEhEK0lYYlFRUbYgF8C4wZlvGSgQnzIjOGt9LrPdhbnle5RAweX8xu08qvMcVUxk+k62s3Rm8bwhWL4IUiXOCVkR4VCjw0algOs6ul6NK0X+SXa8wIUDiB1ELfCLg7MbRNez5CaMs46NFhREaHeUsi4a69qzKkhv7u0SP1jhSqrbl2u6Y2WTIm+9/TFnVOKNYrBuaahPowDihXD1iubrkxb2cTVURry1ee6aTKU/P55yvSoaDnEEsA5IWkkR5DvZ2OJjtUFQVqmrBE1irkwteuXWDV27vkcQp95+ec+/FFJzi/uNHHC9rhE6IBgc4G9NsSh6tK9aFYTyq2R9kDHdusr8qef/ZEx49u0Q4GKRBY51FgsNBxutvfB5la450S9F45oXgYtUgsog9PeZgNORsU/GV336Tn/uRV3n52jX2pgecXc55dLkin42xxZwHq5prk11UDkubgvco0YLIGY8jkjyjMpa2qnnw9CH3Xn6Bl+/c5MHDJwHpGxskdp2cQEvJaJTjKVmti65yDK23eOHRKNo2PHBpohjlAyyCZxdLNpuKWCucswgFkY9obBMeLq0QCFrTorzCNA1pHJHECVpJmrZBrDy6C7nEi630yzpHFOnOwcli2jYYGkh4+vgps9mEdpCxmi843NthOMp48uSEtm0wvmU6G5NnSWDrlGSQ5ygpePTgI5q6ZpDl3Lh7ndHtCCdi6s0K1VpElEIXDmg9XLoVvprTbuZUjSQd75ClMVoqvAwLWZzs8a/83B9nc7Hh//GX/wPaTdtJjsKkt1mvWK2W3QSlkEKhlaSsa6qyCs371mLbBi8VUgjqtuRbb32b77z5bfZ39/gjf+gX+T2/52e5fvtWl78SwHJQiHY8gFDY7/9Z/3R8gsP3rlP95jqEyoRKKoHN6q19O7Nq6F5/5SAi8d5uF37rQ6gw3naAQHYy2v8h0xDcH91zskaQ3oG13ULgcCLILPGCPEp54fCIW7u7DAcZTd3w5OyUtx8/5P7FKaZbiJQQiGSfVk/QPqJBoDcLHv7WP+X/xpx7L73Cz917hutZPTzeGJ48+Ygnpxd89PQEHY05WXjuvHyPW5MBO+MR2m9IVMZo/4CTi0vSLGZ3NubLP/7jeO9487tv4b1jUxWcnJ8xynJ2d/dI0gydLLicX1LVDY2BsjmnMobXX3uN/du3kUgevP8EYRxpnDDKhyw2Na3rOsj6awTb8FbXHztsQe9WetI7N4rgzuX7XoMOVPQfR7+xhLB/9Z3MSHSKAQEkHjLvST2kEDZR3ocsMx8ayfveFEFQEpTiakMLoHRg27ySWCWoowgrBN41WwI3yCSvzAMsYJ2kRVL5wMi3pqY1JTqFwdAzHmRkqSSOZHA78/3cHOrhW1c550FaBCYY3SiNtVDOC+yyIG4dzmucjNHRgEwIciEY55YZgqlWqEFG4YFyQ7OsfoAn7tPxSY2AeQzh/lehvqC6PGkZ5IBe0AEsEMKhY0kS62B60WWDJZmmbQx11QaTi75AhA92/GHXi0CiVABYaRx6vjabEgiGGt65bS+nczYUolxwfwj5XA5jQu9R24bNv5QCJUMUibFmq14oioqTkzM+/PABQkquHe7y7/47kp2dKXt7e9y4cbsDTgKlJDKEn13JKr1A4AhWkp7nYzOk7Hu4esfBnhnz9JmTEtXPEts5wG2ljWHtlj2DF14Whgj8Wd+j3CMdSRfm7MPn0HNCkhDqLsQVC3UloQ6vMb7/mg9SRd9nMULtZWDEevaf8D4NbJFhf269FFT6fnWjK4gHYyLnBXkXsm0IjBywlVLKrgVAOkcue6bLhuBt3xfKAihLRZgLG9GxfkDdKR68E12uoui8LQModXhcF1mgXS+xvHKZRPorybnvC3Vd0cGDcAblG5Q3W7ZTONsVwERYh4Xq7ueeLe3Xkt7mhe1aE76n7xn3tMZhn2M2/0XHJwLOUKAGY7JBztGuYDgcksYJbbFARwov4Nq1A24+nBNHijiWTMcTJvmUL73+IvcfPWRVNty+PubwcEocR0TCYZqa0SBj52AXYxyLosJLy7p0vP/gjLPFkp1hzChJUNbjtEaTEEeSwWjAcDJhffwIJwRHt+6yLEtmO2NmOzOiaMAbBwcc7Ozz7PETni1bfKx49e4Re8OM5XpBYR3XZjtUY8e6MlQ+xughrcxRPsI6x5PLNWXdIvwlk2HCj33pC8goZ0rF2x894Ze/9QGNV+yMcj5z7ybJWGItGFuRJxm1gdN1Rdta8iTixWv7+MjzzeM1641jMJyxP8sZ+ojLWpIry6aqOJhOUcMcc3ZJmqQkusHVa47299AyYn5xhm0qBm5D0ziUzrh26yajTUm5/qhbiMPDGiuNQtBa06XIK7IsYd14LpZL2qYN4bbGYFzQKIMD71A6uNJJGeSBkZQMBhHDYRpkCHFKLCLyNEHK0FiulMKYoPXWkd4GUUopEcaAAyUETVPz5PEzlBJcv3ZInCWcHp8wGGRkWYrWioODfaSSNE3LarmkqSuEUljnKY3l+EHo+br+2YT2YkmkJEl5ikwGWJUgZJB9VZtLjPF4OaE6PmbSOKrxFEUIW3TOIVxDsZ7zxR/5Sf7Mv17yd/723+D86Sl4T9sGV0hckCAKGeh1Ywx1XYcqIY7atNt+vzjSRGlMFEcIFGfzC/7Sf/hX+Ot/82/yJ/7IH+WP/ak/iYxgeXHJ9Zs3ydK4k83B82ZTn45/+UML0TlmhQXO9XVAEeQZssNfbrtw9wKMzo73OfbAe4fFYnFob3Feo+ns90W3mHVWybKTuVxxPd/bnOyaGq9VYMEIDeexSLh1sM8Lu3tMhznOtpxdXvLBsyd8dHxG669ktHZ0A3vwBdzOS6yTGcIpsuOHNGVBmaeUVcvh4RGyyxACMG3Jo9MV8d5NPvrOY07OP0INZpy+94jD2Yjjh+/xc6dn3Pvc56nKgrfefYfD3X1efvllxtMhr7zyMicnx9x/cJ8kiVmtlpidHbRSoQhTVzhru41SCB+9mM956513mDw7ZpRnKKVIkpTKNoGh766b2LJn38twhSp5/1H4rhcwLNi+u5aRjhmOJwwHI+q25vzigqosu2b6fjN2BZyfNwQJBpGCoRNMvGCMIPPB9KOXuDhCpbfpNhoS2VW4LUp4TLcR0coTCZAqwkeaRklqPM6GNngnwlbbirDDjlzYNIUuM4dRDheIRIQUxLknzWqiSBMpiRQ2SI2cQHkbGN2OQet7MYIcU6GVIoljRoOMsZBcKz0vti0lhmMlmEcRWTpgqlP2shE7asR0Z0S6u0NhLdXpKfnTT2bb8en4wYYQwZ3U+zb0QOkI701wNvRs+6ikEAgd2AolPHXdYK2lzxJz1qG1QkeKujHB0Kibj3xnrKCExNmwcXbOYYVFq7BXaE34ulQKnKWXjYneSc8GENO1goWikxegwuus80gb2DfZTWCyl65Zi1KK0/MFf+mv/EfcvHGdJI74C3/+L3D9+g20UjjhQbogQeyMQwL75bAu/AoOh/2VC6yI6izXfSfPE8899tsNfwf4enBiOmBAx8cECNsVQGSQD/cBzj2Y69mk3hksdDKFPysBOmjeAzjr+sC2LrGdRLKfQ1rCOmU6Vsn08KWfGsWVm+FWKtCvUR2gsQJMB5ikF8GFtmPs8B4twn0iVb+3FF1QtCeSglgEZsz5XhIJTWd4FdZRSdX9zKCl6ooHBAt9KQKTaZCEPDOBF45YhOOvtynXYe8l+oPvz9N1mXPdZ4QzSGfAteBaHC4YxNA5bPpunRUKLzReRsFUhrDGCy+DO6Pr1/3w9ViENi4lQpB6YxymR6zfx/hkcs4uTrm+d5s2TkgGllvXclIJ8Sjm4No+y/mSy0XJII1JVIS3lovTC9bxJYeHO/zhn/0J9o5m3L1xiwO1ZJhrXN1y8+4R2dE1XLlivWkhUhgnOH3wkI8eP8RYg3YDfCxIkyHnizXGl7xkjhBSkqUpLsvRccbrr7zGNJFsipInpeMgi3n91g2eHZ9xUtSMZ7sMUsl4NOK4gMena3YHKfOi4mRl0TomTzx7eczozh20EgxGE16/W3CyWPHkcoVKM27vDplKSymGnDOkzaYU6xVutaY0DbujMQ9PzjBtw9oIjjct1w5Tzi8XFE2QnMyGu3z5c6/x4PiETeu4bCT7Y8HRtSllUSFdTZINaIxgLQbgLaM8xQrF6vyY+eWaqoWLxYq9qEGkE9LZEbGVnBy/S2sNgzwm94GBMW3nFNetxlmiUTpiVZQY50LgqzU0XeNsLCNCtSg8CJFSxHHMII0Z5MFUJYoipIpCyGplSJSgwTMe5QzynNYESURdN2Gic2FilEmyndiTBIQ0pGnKzv4Ol+ennJ+cobRmMhwSRRH1aEjTGi4uLliuVgzH4yCHbSuMsdTW8uZ3vsvurW9x90sTVD7CoqnmJ7QyB6GhXtI68OkUvEU6gT99il4t8XGEQiFcE6IB5AA93OFnfuLnmF+c8Xf/xn9BHKfUdQ1ehAZkJdFRzGg84cbNawCs1xsaazBtSxLFJElCmiRhM5UkNE1DHEmm4310pPk7//jv8dVvfoU4TfFO8u/+O/9rXn7tFk6Fys3/FzLl0/EvcwgfSqn+io3pl7NQVezNcFyXidNVYYWnW4rwhCpxsGm2eGPDjOyvFvbnYRjiuY3CFvBd3QjOe4xtcFZh4xghLN56rh0c8trRdfYnQ5R0rFYF909OeP/ZKZvWooTEaA3ZEW7vc5jZizT5FOcErvGovZfY/8Ivkp18jfF0xhtv/Ei3GfJYa3n08CGl8TRyRJwNiTPB57/8e3l0fIrOJRfrlm+++Q5P5gu8ynj64Akfvvsu3/r2byG84LVXXuUXfv8v8Ff/k/+U07MLkkjxsKyYjsZs1mvKquys7buatPe0xnI5X2CNpS5TIu9J4og4TtifzphvChyhMu6dRfSEJd8bdCq8J0IykIKBlESis7OOFePZLtemu8zyAUpIHk13eefxAy4Wq6BKwG/treE5x84OGOYeDoAD7xl7QSYUGtlJWaHCUxLkfhpPSlc1Dx8vGoFRgkZBq2TYxGpFKcI8LAiSHiMEjVTgFLGwpApSKam0QEYRWiYIYTpFQko2aEkHnjh16NgjNVtw3l+o0AviQxix74N0w4YklppRFHNtd4SYGtKVQbUVBwiexRqbp9yepLx0kLM/kYwORjTCI51lOs6ZqU+t9H+oQwTg00sIpewAVwesejmhVJL+trDuylG2e5MuoD0UNoIpQnDOc84hVQBY1vUOhIRgaGBnMgY8p+cXlLUhz3Kk9MGcZF2wKartzxHd8+RxnfmSwNkrUwff7YqtNds593kW3BjDx/cf8ezkgrZtOD2/4N6d6/zb/8t/i9F0AiIYOfUAzXWgzHZgMgDVK1CEl12/uegMoAiFoI4dEs/PB50plHPBFIPnYrSsF1jZM2mSVHliFcCtsXRh0b2UPQA5QSha+04uaHqw9xz+CADMY3vBnfBbe34hIPK9GjsAKNcDwI5lcyLwd32gda8Y6C43fWnJfg/t57dKkV6N1EFPUhnezzkXYl06BksTDFcC9+Q7cxW3jQfw3bnKztXRex9MQOjuse5nhNU03BeiYxz7nrMAksP1omcB8QgXoklE1yKCuzI66a9lB4FBR3gVA6rjRLv36c5DQKeiCT/Teo+VHi0krYXWOEzH+H2/4xMBZ999tGK6U/LFz77Gu09OyLKM4VDwygsvIH3G73z7Xd59Omd6cIhXmu988IjdUc6dgxFH10fcunnALJXsy5YkirBIiqZgONkhmYx48PHbnC3OGMz2yJIMIzRZliIxTPKIQRxRGseqbonSqJsYwsXK85RpHmPKkmeXBY/XCaNRzvWDQ5bLBVVTcvfwJvOipGhKqjZnWRYs1g5JTdFWnJYp46zlTDScS83+cEq+67gxGJKmOa/riLKqSVTFvWvX2bSKJ+cLbtzJEJPbrFeXRLbg1k7MwSgGJVHLlpKUVkakcQRxgrOwWDc8XC65dTjiR158nYuy4nzTEo3HDBJJuSmY7u+gspT5xRIZjch2c/T6HK8Vy7LlYrkC4xhHniQb0EY5B7u7qDgmG0TcfvEat69dY1XU/OZvfp0nj45xQoZF2HmEUlR1S2MM1truqQzBlEoFOZ6zXYNvZ3KkpSCONaPhgMFggFaqm4RgWW5IE42QKdPxkL29PQRgnGO93rBar2lbS1nVgRqvDUiBMWGijLRks15ycnyCbQ2Huzucn18QRxHZaAhScHp5GRyWqhqUxrSGjx4+wtUtO+OcJx++y/XP/BhaClwSg4gxi2fUbQ16CPkU5VqkVlhgXbeI9UMQGVpaXBQjkwmONW1V0c7nTJOIyXSHpm7wrgyTmHPoOGU8nDDIYjarNfuHBwyGQ+qmoW1bsjTt9QQgBFVVUpdVqDa1hjiOyaKY49OzLjjT8hf/L/8+P/8Lf4B79+5x++YBSZ6wP51+Eo/vp+MHGFLKK0krV71N31NtFL18IsgQhejYJhG2K1sZnQ/lWe8cwoXFQ+owf/muH0Aitj1Iom+y7kJTw3LhQ/W5r0DbsDHf3Znyxp073NrfJc0SqrLmycU5754847JpUHGMby063cXsvIHbfZkmnwQXLm9QTtBmAy4WF9zC87O/8Ee4cfMGEDY+jx58zF/7T/8qp8/O+Myrr7AzGtN6wXe+/ivceuEeB5N9fv73/CRvvf0WH3z8mHsv3uV//uf+Fzx8+JhmNefy6cfc2lEc3X6B5n/2p/h//uf/GWkSs1pveHpyTKx1qKB6H3oZ4hB63dQN3gvqxqK1RWhN5ASJijitLVonCGcwxoDoKuvbTUzHXakgD8qRTJRiF82Bk4yVJNYx43zCIBkSJwkewdHOATtlxcdVS+EqpPNE3WLfb1xEV0mWAmZecNdLbnnPDpALgfbQek+Lp8CyJoCrrNtcDIQMganSY6WkVBKTatpI4rUF+kynICGqRZARWR8hvCLxilx6tE5wQ81wJBhGkthraFJkFDEZtQxHMBhE5KlGRaIzevNb0C9d6KnsDOCCPE1LlNZEUUSWJ0z3MoojCxeKvNiQ0TKlIVER1/KIvSxhZ3fC4GCXpW9YmZpRrBlVy/8/Ppmfjv9fo9/aCinw3oaMPxGAQt8bq7TEOQNedpvo8AxaEwCLCrQN1jhQEMdR6F8yBuE9rWm3/bAeT5ZkHB3s0rQNiVbEUqLkLo+Oz5AStJKkSYyUMrhs64iyLLAdxRLMlvpHuJOb+X4T3m3mFR37Zbe9o6Uru/dsUUrznbfe5f79Jwj5l/mFX/h5Xrr7CvlgSB9R0v8eGLOu38y5TqLeF4dUmMM7cGSdwHY9WPI50CJ6Yyg8Svbi5QAsZZe5IlTooYt1gF/OQ6wkXoXzCkqmzgWRAFhCiDKdhDkUewKo6CV9XUA2vUzTE+HQHXgxdGbAIvRDJSLMY14IWheOs3df7F/b91Mp6AxVgoJDCogQpMIiO3DVElgz6UMOmvcWL8W2jy0sewE82g7MyU662UO7/mzC/aNC4LQN96EU4X1FdyxtJ2UMbJqnFzCEj6IDVM4FhqxTX8g+jiTICTp5paSXlAokqAihoyA57doN2N4DfM+R+u6z6NflUHgFhw4S9Oedl/8FxycCzia3PkebeG5OBqzVlKKoGA4Vs9k+g3TKk6dnPKk09168R7HxGLnkrDEc+Yj1aslIpzx877doZjkv/siXGOYDEAWb1QKdJzivwSvWywWjmefazoD1aoxQcH0nR3jPfOOI1iWdMhQhNUKEaqNSirpakUQpB5Ocl27vc3d/wrOzhmiwg0eRKnjx8CZaaE7WcwoX4yvB0UQiRcN5YVm3g7Axki1eDSlMQ2USrk1mzCYN3tac2RjrBLujFKFTxjNB5A/xzmLaEudq9pIDytywF08YpgKSnIODiPZsxUhalI15shKc1WsSrRgNc3LVcPHkMdkgZ5ZPaaoNkVCU3mFlws7+EVGSsNgoonnLqjxmlMF4OkNM9zncmzEcz7h1dA0RZ8go4d0332K1KJAyhFEb54m0xCtJ1ZrgHCglMtJI4XEWlNKhB6HXBHUbRq0kiY7Ae6wxmNaACBtEoSKktuyORuRZRhxF6CjC48nzHK01y8UKaw1tGx6u1rZh0ys91jScn5ySpwPuvH6Pi8szGmsZ7+5RGcdiuUQpzd50RJok1GXB+ekZ5WZNrBVaK1YXx7TFmkIpVFmhlCAZDHAlrG2MqkukjRA+bD58nuCKAt+cMtq9g42HbNYFZ48fcPzRdzl+9pTfefO3qaqatgmVPq1iIh2TD3JW6znn58+YTHaZzqYMRyPyNO009J6qqsKfRQjTLKsa2xqKoiBaLVGRoigKtJBMJlPeev+7fOu73w49NaMxw0HO3/rr/69P4vH9dPwgQ3iUEFfa9p7B6h6NkOkSmssDeuoNHvxWJtKDBO8dxgtab2ldEHJ436fWXKWw9Gp90TlkbeNXuvdyXtAaixUglSbLMz5z9x53D48Yj3Kc9ZwWnveXLceVQcsYJ4FsTDt8FTG5h8/GRN6HBT/ULNFNxUhrfv6n/yB/+Bd/sYt68JyfnfKtb36D9bzk+vXr6DTl8OZt3v/61zCtoVwsOG43lEVB0Xi8N3zzd94iy4d8/gtf4GDnFZrly5y//w3qD7/G60cHfOa1V7j/8QOyNGdVrCmaBuk9WZKSDYe03Zw0HI6ZTXc4ODjCNC3nF2eYtqZBkuYZw7ZhU2y6OA/f9YkIjDd4FxZkSZDrJUKTKU0uE8YodvBMpOaAmFxGYf3RCis9kzjhnkyD221wQwj9ad2OwAUkjgCmCA5wHAATGcAZzoXwV6ACSvpA1yA1klIzjBKUUlQK2lgi8wQRaZxUSGEQTmI81D7Y7DtDmJs7WaTRjjjVDDMJuWeWe85tFAJgU08SVSjA2T4TKciqQqE/HL/rlE2eXqIFUgmiWJKkCfl4SD4x5FNFM0iJ5YCUEiVKRpFl5BpEtUaLAVpCJlNq0zJMU2bqU1njD3MIBEKGYitIjDHoSNE0ofiqdAAVWkmM9R1ACtSP96C07MCF3/aYtcZgbSjuah3u1cCsB6mYSyzXjq5x7WAPU5dkRcFGapCa5WYN3tM0DXmes7c7pawayjLksPoOpPRMX29cIjo5oOsKNzgfcvygezbD3b1l+7zHOcPctvy9f/jL/NI/+Q3+0B/8A/yhX/xD7O/v07Q1aRITSw0iOO9ZH5gd3HN+gKJz8rNBlui8CEXU7t/ldl7ui2mhsAYC52WXe6jpOCvAY5zvwGZwjZTCX4kzvEdfkT8d29VJDemD78W2r8oDqbAhF7FfRXzIVjPhxxHhO1gXTIoigiFGLoIcsu+kaj1XbpGdvFnhkH0IqxAo32V8yXAOtZOsfLguPfMqA1yhcaLLR+vALIpYOLTobTqCnNv4wC62SLyUiL4nG9+B4P7VEtN1C/RyRdlJG+kZPx+YMuldxzNY8AZvDX2u6LZWLrsrKwRK9cHb7bY9YQvgnlv3PUFG2SvJrIfW0WERB1IGCe33OT6RWfInP/8Zhr5hff4+00FMlozJYoOzDUkimU4yxJM1kyxmkipu39ynNo4odlSF4cHJB9jzC2a6xfuadPIiXiWsLy/ZlCXLi2dMcoVTEVGimYwz0sQhtGZnZ0qxKRFtw3i6g29X3QYpTAyR93itaeQQ6Uru7ntujRMuz88xPmGQa7yz7MYRN/YOee/ZBYVxTMY5rfOsrSRKBbKV1CQI71hXnuvjiCIaUBQrTtslcRJDOmOcRTgM81WJkZqGAcY1GBmR6IxK1HhibqQ1pU8ZqAYtLEQDRrMR2cgwbgvmdUxpNN43jLKExnrK9JB7hznKlDTFkscLR6X2uHNzh8HAYo3lcr3hsqqJZOi9y/Zvsn/tCGVqTDGnJKcoN8xPPuTX/9k/xbmGtm2CPAGC+URXObGEBnWk7B4ej5dg2/Ag60iGBVtJsjRmMMgZDIdbiYC1oWIipSJNM+IkJYpinHW0GNqmRulo22DrbYszNoT09vphJMY4BknM7/19v59XP/95fum/+cdUjSHNMoZpxo39PWIpubi4ZLlacnFxgW9qdoYDZKSQSlJXK5YPP+Dws1+i9TW+rUmIUd4i6ksKEVFZRxrHZNmQQRYhI7AuIhYJdW0ozo75+Dtf4eSj7/J0WXAxvyTWlrJo0SoiTjRJmqI1VNUG7wWmrSk2GybTCWmW0LQN9abk2dOnCCHYOzjAA23TYI3BOctm48iSlCSLubi4YLVYMJ5MGI7HOO85vzjn9Ozsk3h0Px0/8LjahNMtE3RV59A75q6AmqNzdvRXrk3P94mFlaXrZQrdZwoVFpO+iie2ywBhoxRyqHwHMEQnARGuczsbaF64dYdXr91gdzpGAGcVvF0PeV/cw48lrB8g5YA2fwGb36XJpls5jxCCCItsG9T6CX/kD/08/9a/9gcYDgZhHgCmA80btyfYL3yGX/q1r3Ht6Br7u1N2plPeefu7XLu2x/n5mvsPHrIsC4RUTMYTfvM3v8bJs1PyRPP7ft/PMN6/QXn5IZPigp957Qar1ZrF5ZI4jricz1FCEKcpQgoGg5ymblFSs7uzw+HhAZeXlzTtAN9G3cZTMhqEEO2iLNBaBWtsHwpMQnd1VREAjVAaITRKREih6TGKaltyBFpGAbC4hkxE7CU5rmxxxoRQe9EHpgqM8DQiSFv2kVy3momAoXdoD6VzoXej2/RUeFrhSJHUBAOPVglkIhCJRs+m6OlOAErzS3zTYnxL48E6jzEWWo9qQ8jzUgcWYzyIiAYgB479oeVxJWgbTaQNeRKTKYNyYFqLNcH3WYrQP+w78yHXVZnxopM9eoQW6MiRZBF6PMBMwIwyvKqRtSByDZl2xJElMg1UFWwKtIKs2iBXa1548unc9cMc1lqiKMK0FmNs12/ZGZJ71xmG9PJcgVBymwUWGCkwzoS4Bx2cG60L0sdeFxac/cK/SSFI4oj5/JKTiznDQcJYSJbeM53tsCo2KKVoG0PTNkwnY+rmnDgKelutBVVVh/fqYkaEB9+BsV5654SjDy3eyh67Xbe1NsgLlQqukISYm7/1d/8uX/n61/hdv+t38dFHH/LGa6/xZ//Mv0pVrxjk027ODfDEdRtw7wPrGKSedCAkmJyFYls4IudtyLSkUzZ0QE0L3dmxEFicDhhtxZNOgFRd71lX1KNTTACxgNb5EJhN/1n5LVxQhCB7XMc8+ZDT1bNh4TtC35cVUHkwIuQshpJcCIIWPjgzhh7qztaqKyzKvqcNReMEyoGWvUW9RTtJI+S2xy1ILnuAHeSNjQ+9WakM51d7aH3ISHMdKxnkgwFUZQoS7cL9ZyXWhTVTdUBObnm3TvppLcI5cBbhDHgX2gdsjbftNuvObZ2PgyJGqig4e/rQFuC6CpWjk6HCtqXAdbEpz/eZWG+D2sX2Jvpyex9+P+MTAWejWBE7y+N5Q2uWTCaHlHXFclUwHhqKoqGpG5a1Ym80YGcyZF7Cut2QecOitKwvCu7NFG1lqGVELWKK2rEqKuq64ejWXSIpWJUblIy5tT8jHebs7u7i/QUDkXNjnGGrC5I4Ch+Id3gpiAY75Ec7RH7FzWlCg+TxpkVr2J/mmLYiVp6Tk0fMF8HGPEKFxcsU7M8SdmcDTjeaTWOpjaE0lukow6qSwzzicTPkdOHRm4pZJthNc2YH+5QtvHO/orUZs6GjsIp5IdhPLBO7oCgqNpNrRHpAIxxxmhNFCZ41Wnikqzg7uWRjNC/f2qVuSlbzUybjIUf7E0ojkL7C6QHK1UwTx2o8Jq49t+9c5+DaERti7l+2DN2SOK5YN4KPP/wA0zYURR2obymCqtb1iUqC1jqapiEyllEc0xoLWm9pfpwnFoo0SRgMhuTDIUpHOBNkiSoKN3kUJYBnNMjxztOYFmFbmrImSjpRlvfY1tC2bdAlb7XtnmyQ8aUf+zF29/f5R3/77/Ot3/kt9mYT9iZj9iczlJSYsiCWkuV6w7qsaZoG4wSuCg8vg5zLx29z77XPMDzYp6gKjo/PkNYhzIpm3XJ8fkpTLNnf2+HWtYMgISCmLn6Heel5++1v88F3vs7AO169dos3XnqRzWbOL//mNzibF+DANlA7Q6Q0rbWBuZWSOIpo6obFcsGD+x+zuLwkT4eB6et60ZwJ8YzGWJblgoEfEcURm9WK6qRgsF4zGI6YzKZ8GhX0wx3C9R+A6vTrobfA2bBBcc6GibszaQx6fgFCI6VhW/sMq9a2P8NYS2TBKxFCzblyGpQiWKzDlWxFiZDRJ5UO7y9rBIKb12/y+p27HOztoJVgXnne2aR8p9ljPkiIowl5MsXYiDa9QR2PMUJvNxcgkE3JoHjMH31lyP/mT/8sgywLzoVeYNcX1I/ehuU5qV1z79Z1vHdoCS/evsmmXPPhw4fgHKUIhbRBNiCOYtIsYz2/4LJY8Pf/5lNuHE55bSjZT1s+v2M4f+GQX/8wCk3gKqZta4ajIXVV01QN49kUISSXiwVCKgb5gNl0l8XygrooUUojhA25g/kA5z2lbTFti48ipArX1Hf9VUZqaiS11FReUjmPdo75akmMZ7J/SLozwacj9HBCNJ5R339AfXEJrQ222N0GR0iBE55MOsbOM5GKiRdk3ea2pt3mhvXbPucFVkhqIag0xFrho4g6zyh393BZjow0wlvMaUXlHbVxtEZgWo2sW4wzrKTHpAl7kcRISZYovKyIKUiThCKWzEYRe+OcnaFnkgkSFdhdZ0WY26XvWyk76Y/vJDyhkq+EQ2tJFEvkMKKaDTgdCbywDJUj9i1CrVGqRiUZti6pLk4pqgKxXhMvC24+uviX/LR+Op4f1oY+M0RgwYQM9voBz3g8BiH01kZeqQDaAwPlu57PtovPkVjju1ywMPepTq0U4mRCdmqWRlw7OuQ3v/kdNqs1Vkjwjrs3rzEejzk/P0cpTd20JE1LEseUSlG3Tbex7fqDZJBZyo6lCGZihP4s7zvBY9gSO+s7l2O2vXQ9QAtEm6WuHR988DEfffgApTSPHz7h1q1r/Nqv/ir/+r/6ZzjYP2KxXJIkGaeXl+zvH5KmedjMdwU4JVTHHIXerhAJEKIHcD0rE54lpYORhxQe412X+RVAhhTh34QMrpVhLibI4ftCnQgANQYiEcyRrOtYJh/8EbUMxZ+2Mx7pZXc9S7dl+Lth6Jl8QYwMBhs+GJd4IZDekoggROyZMC+6PMYQtY1F0jqJ9B6JJfOWyAkaH/IN+3gB74LiRALGd1JLF2zxcxnCp40D252Dk4Hl8xKUdMHdVggQwYmcoFrvJJHh/HxP+VsTQFiXZ+e8Czb5zkKXY7ZlRDtm0zsf1ljn8b4NhnEihCEo73Gu7qSPXf+bVB1JtxVSdr9HWOWDHLXfBHyf4xMBZ/cvV7y0N2J0/SXmj95hfyTIiDk5PaGtYFk6hsMxq6IgihMqn+GFxdo1SlpG0z2Wp8dcbGqWiznJ2TnlesPDZ08Q8YTRbB8tM4riEusVKo2CFeiqZCdbkOqIeDhhmAxRdcQwqRhGmkRCrDWTSHKYGtJkRJznqMktbu7HXJzep3ItKMWto0Pe++AjNvNL4sGUJMvRUcLZRcN8XXN9pkhlzMprjHFc1IK7E0VrBKtWULoIoUL16HJpiAY1arFgNhpya3/Cs3WDlmCNxkpBQc44c7h4iBEDEqWonaIwEImYSCZMOKP0EWdGInyDrxeIJMNGOTad0VQlbVli44RED1lWMUf71xjqC+plCV7w4PicMz/DmojGR+xqhWtKmnLDarmgdc02jNJ6S+MgakOlSEqJ1iFbqG2aYJnvr1zplFKMxwNu3TgiyzMEktVygdKafDhAS0XbGnSkiaOIKNJB29tA2zZESYy3FlM3rDdr6tYE+2vfswICpGY8GPG7f/an+W9+6Vf49d/4ddBQnlQURUlxeMTB7g6x1kghmY6GPD49YVnVOBuqJxHQzCZksaS8fIBKNbWTRHGGMS1NG2HKZxRnD7k4uU9a7rDgNi7fYzA7oigX1GfPaM8fcHi4z+50yHCQE+czzjcTKvM1hIDRaAS2orWCJIlJhGb34IA0TzFNxXy54vj0hNV8iTOGuiloqjJUtbpQa+tCfpHxDW1dk2QpaZJhraWqCuq6pCwLDo+ufxKP7qfjBx199g9s5TbB7SmYZChpoLN67huVe0Z/Ww0VoQKLk881LQcX1F74IYXsXnvVlB7+3/t9hfdQMogdpZYc7O3y2Vde5ca1I7IsoTTwaJPwdjPhJJpghURoRaNTjJOUJGHZlaBRGOFRdcm4fMr/9ve9wB/7qc+QJkHqI7vcI5XmWNOi2hVsLvjMrX2iwRiRJty//zHXd3bDJklIootL/FDwI2+8wXgQoi6auiRN7/H0ww/52je+RfTSDjdfm/HyTsK1owP2Dw75eOEw1nGxXNG0DaYxHB8f44zjlZdf4nOf+xFaYzg/v+DJ08cslhuqqiSOIxCaSMeIKGJdblBSkiQJRnikFgipcL5vbtcshcRIQWk9RdNy4DxR49DOoHemJJMZgxu30aMx9XrD/K03WX/7t1mcnYYw3a43sBZQK7jmI1IHqYfMQioUpjVoIQOrQFh8k+7GcFJgtaJKFDIR1ImniQStAOE6dkBAKaCQmtJbjBVYJI2tuPQtaynJEIyNCNJyb3CxRA0TRmmGGHj2BjF7Y8HRIGY/j9B4fN0EBs8KdBRyiZAOoTyya6jrsyRBoDVEsSVNBYMhPB3BpklIGaAHlmiUYVNHnWq8gsXZMXK5Rq0qxHKJPzn9l/ywfjqeH856Wm9CRpkI8kSlfIhJ6PRjzrXfM3dJ2UvzQvuOFCqYikBwXu5k2L08UakgJxxPhiihcE6wk2f80c+/wUPT8lvffpsXb99kujvl/Q8/3GakFmVNpHW371As100wEukUONa5ID3rmJU+T63PfOxZ/WAcYrtQ+MB6QZh/+/5TY0wHeEI/sPOex0+P+T/+n/6vNKZluaoZTQZ8+623+b0/+7N887d/mz/5x/8Er77yCsZYdnZ2kFLz5MlTrl+/jooSmsaSZ8nW0r63bO+dJ33b4qwJ5j4ovA+FtrZ7rcQTCY+iixcQfURBOF8pHFoFIyLZqTGc9wgr8CL04wrvMF7iRC+A774XCIU9H8BFZxLihUC6QNhVCBoXwKAUHulBdwZk2yINgdky3qE685RgTuJQznSRDB5pPcoCRuGEDCZxAlrraF1wrlU2AC8jIBKOWAblg3UhQiDZih1750dH2zpc6xDGoIQkGJjYzryoY81cD8Zs6Hlzot+0IqQCr8M668J6K7qcXrk9wzCEgEh3rLITtNbjRQc0pYK+j5wrSWl3p6EIrs5CyMDSfZ/jEwFntU0orefo5i2i0RhRPITWsClaiuIJXowZDweM8gl7kyHna8fxk6e49Tl2JDk6uI5SnoOppxSS9XqDqWqqYs1uPsLlKU+On3ExP+bu3dvs5QNWFxnnZxcsLgUbOWKVjLg7mdKuHOv2Ia2QGBFh6hVFuURpj5I5Vg4pNmsQiixOEUZytDcgS1Na54mSODQxugbjYmqXcLaqaNsCKQvqOg8b6HqDNTnpYMazRUUmahqVUjUgZctklFF5ycfHp+zlOS9NIwSeuZVIZYnTFJUqDpOE0klsW4NXbGqDdY6hcAyBdDDgzmCCwDBKDVk+JFI1aZxjrSO2hlFcM9CSNKvZ2R1wKUqWZCyTIZd2AEIj/BpkxHlhmD96xOr8GCU843xAVTbUrUFKuonUUtY1ZdVgjKVViukgR8URtrPMRUnSJGEyHnL67Cmx1iRZFuzxlababBiPx3gpg6OZEIgkwndyRx1FSK2oyoqmbbuqXJgBnLHBlajTtCsZHriDG9eprcE1hiROeHhyysnFJbf3d7l1dMB4PCHPc2aTCafzJXVrkQKSusY0hkgpWm/wKiLKI1IBVSWp65TWCqbSsXPrNlHseTYvmcSKw2hCPJziJtcZjo+I04RsNMJ7R5PMcE+esHftGsWHH1G3lkgphBa4xnLz1g0m0xnD4ZCybtgUBcV6ExYPGao0Qip2x2OcdWxWa8Ahu4w07x3GtAg8aZKwXjeUZUHTtF0vzafjhzVEVylz3oXAUu/x1uOV6yq0fgusXNc9HJqqw9ZcAIguN0b0Xk8d5Or8m32Xz0LfRO176WT362oHgJQaJyyT6S6fe/1HuXfrDtPJGOs8pxt4qx3yTE6D3EWAI6GKx2A92jpaL9AiVE2xJXl9xr/5e+7yp3/2c8i2xBvRBdd0S7yKGRy9jFid8+rRCaX3xHnL45OHfPnFPT541BKbmN3pkM///BdJs4RYKs4uzynLmvV8TZom6JlC+CMKI5gvaybTGVMr+PItuHPzGiae4rMxjRE8eXbC2dkl6/WcLE148uQRy9WKqqyYX16QZRk6klRVRdPWxDpCSs9kNKa1hsq01D4YW7SdlFR6F+Q50rOWntZBKaHwLcpZhBVM4xw/2iHa3UeNh6RHR1RZzMoUvPONOU1tgyW+FNR4YuEZ2fCJxk6RaEHqBaU1wdREChInSPCMhGCEwGuFj2PKJMLHikhFwRVus0C4FtqCSgnES6+SqoT4bIm7f4xtSh67hjPb0kqNsi2BzfWhuT8bwWzKWIwYIdlP4WggmKaekdBoB20bUTtHYRxeiZCrpkArH5z8pAPRbdbwWNeCb4iEQcc1xC0tGj2A5PYRw8OUdBTjkwhf17RPHrHZFLjNAn98gqs+zTn7YQ7nLTjVbWT7nEUf4lm6OcU5h5Ihp7NtLVqLLkS6s2rvNveBiRK4tm/aAeMszlnyLCXSEdZajDWcnJ5w4+YNrgnP+eURr73+CpeXFzRNi7WOumrwzlE1BmtLmm5P4hxEEqwLJgu9KYn1ECm5deTrQ577HiLfSXJ7uWa/bTbG4GTnSClDw5LWAWRKKYODrVJ85eu/g1QK6x1/++/9lzgHf/n//leZTEbs7s5QKsi0z87O+Nmf+d1cXF7y4UeP+Omf/ilef/UV9nb3Qz+8VoyHo5DhhsS0YFyN7aR0CBks+QHoHTA7ObzsxXrhC2kEse4kp10/mnVXrxVKds62NszVQnVmVVfGUdKHPj06MLuVovr+IEQX6xGADYCzDuPBOIHwNqw53uL7PDhLYKVwuK7w6C0Y19vfK2oh0VqjlQwRCNYgVMeudcUtpTSuc9DUSiA6h8fGeJrGbZ1wEwlRrsAHExPjFK0TwR3RWpzUnRS9c5vtGTLZBVm7TuLog+stPcMlgixUydC3jVRIGa636y66RQW+0AdGULD98IJMVTqU8Oiud9t48T1M5b/o+ETAmbeGulUooxkPDhC0LE7eI4pTNHBZCTarBZWU3N4bcSczlGrFs3KN8BGj5JJp0rBzdJcoipGiRUhJMrqBjhWmbbhcLMiHA2bDAVVdob1jlMekScyGjPFkyiDLuFxBmo0xxtNUNbJ1jOIMawQ+GWOUYj0/xZqKnb0jZBKTpTFFZYkG+0xUgzEN8WCKcZpYlygpmbeaaSaZiA2FdTgijhc1B5OI2mlMWxOxomwFqVrh3YTKj6lFxEVjYHnKLI+5nQ9JXIWrLjhpJ8xw7KSC1lpSHVFqxd4wIzKKutgj8o5Kx4yiCB0HO3tta9ZnT9HZkHRnn53pkNpHrCpDs6nxxQk7OxNuzXbZWMXjRYtpHEka0RoBsxzXHBHFEU9PL9hsKlCdbMoHy1KsDZOqMSgpqNuWQZaEh1tI4iQJwZKt4eJijrOWbDBgkOfESYKxhqIsme3uYJuWUhbh5hYCZw2xThFSopRitSlo2vDzehtb70znummoqpJHjx9jTcNsNuPy8oJN6BamrEsWDx9yPJ9z6+AAVCDfdRSzbtZooVjXLav1BqKE2y++zvTwNjLWlPWGi8slm0HKZBizHDjMckmVTNkbTRmMd2gTQWsbtMwY791gNBwz2tnFI5FJzr3bL/E7v/UVPn7/Q8pyQzKZoZQgjjPSJEcSnOWMsyCCdDNLY7ROmc6OqJqSzWqBUAIV6RDy3XXgt03Ner0Kk5nSITdOgHeWtqk/iUf30/EDjqgrHHTKODzBQSrBkHpLIjxaGBRBC9/3GTnvglufCn/3XmKEC3lkMryHlpZYBIv7oNBQSNdvOCzCBRllwHwB4EkJsUp56dWXePXFF9nf3cULweWm4P255YHbg0GMwKMdXYVZoqVFdS5axnsq0/CaWvHv/anP8uJ+yptf/TWcdVy7+wKDQU6WalQ2RghNtHeTcf77SQdjipP3KIoVd0aStl7x2hduE335JUCQxhKVZUTDPcr1mCfvf4ePlid8+PZTpJOc3L+k3NnjTTIy9YTBZETaLJjoiI+OF6S7N1jVluXilOOTxx07luGcZzgcMhpPyAcDNpsVjx89YblcUBYVSkXkWUKaJQwGA+LWUDvDxjZoLzHeYkXonOiLqNY5GmupTUvrJNo6lPTIWOMjTeUdSE+5O2H1wg1+572YYrkOvX4iZNVdt2FRTr0kEYpMSLQP4a2REKRKYvB4r8i1xClBGylcqhGJwseaVnhwBrdZ4csKPx6RvPgy+eFtYpngblYszn4FPT/FOMtxlrGe7BBJifAl3hqsTDDpCJtPSJIZsVRMMhgPYZB7ssgTeUdrapxtqWpYqwhUyK6KNGhpEaJFCIvwBkGLNbBew6q0tPUGYwvqWhJNRgx2huSzAaPdCdF4QFs3oBRF3XB+dsqZq2lj+GM/3Mf3f9TD2dBbJKXoGLHOYAPRFQ1Dv5gxLdb00kHVmXP0ihrdMSihYKS13m6ElYAkjsnzHGscfS7ab3/3Hd7+4GPiJELHCd/4xte5uJyHvk1raU1LpGKsabC2Ioo8uZDEut+bCJoGGgOt8X2kGH0YdB9E3ceQANviluvD0ggM4FX/U2DSgjkKnYFTFycgRGiPEYKyDL9fzlvmiyX3HzzeCtXiKOKd9z7EGIv38N2332YwyPiZn/kpvvHN32aUj/hf/dv/JlVVoXXEwf5hZ6jRAVzbdnED4R2lF92aIvEugOKArLoeNym7wjXhPVxwbPXySgIfnCcNUngipQN711nQGy+6vZ27kk66INEUHeALzWUCbx1l9w/eO4RzRDiSWAWliAdnDaZtOmByFRvjbOiLDSyWx3qBEapjVUO8Ses9xoXzC0xUAJS9ZT5KdveUItFd7IEIDFkkJUo48q7/r7WCVoOxwVCk9QLjJE5Ez/WWhfNVOhy3tS3e2c7hkwBKBSAlKgqmguEqd8HTKJzvv3YFersPY9tj6Lyg7PrQNA4tf0jMmUwSNkXBsnpANNwNbleza0iWxMKzLFKEa/D1KaZIGY0zXvviT3Hyy/8tb779TWx1m8+9dJ2jaUzVSDQOHyWYaJcHp4+I2w3GWmIRM79csFhviGOFaQV5FlP7lHgUE2vJKNNk+ZTaJVyWgup8xXI+Z+/uF5nMrlOua3IbEWtLGifoJKVtS4q2JR8MidSGTSlwxHgPeT6grCvKsqUWCalsGQwnLIsW31jmpUFLS+EFiWxIzBIlJUVpKERFEqf4KANjOJ2foVTN0UhTk/CwVty/aFnJc64NBIlMyCPNUAkaMmyaoCkZmDWTKEOnA2ax4axOuaxrhmmGqhXzTcvK11zWY8xqw8yl1GqP+bzCyBhlCxLpyEVFHAmy3SGbZx7ftHhriSON9pbWOJrWEtctaRSxqZvevAsEQabowUto2gYpBc9OTvBtC0JQtw31vCYfDNBKgg6OZkXboLRErwusNd0N7Eh8gpI6uPgYS2NChS1UOTzoEDZY1BVvvvUWH3/0gFgrBsMBmYeyaSmLNZVxPJkv2FQNOknJ8yEqTZFlSW0MHijqmrKw7O7NmE3GqCyhbgaMswFVbTDVLtVuysnTB1ysLIYYaRRNYWiLBdZWZMrjyzM25x+i9IBsNKMWMc8ePgqMIIZ8EDLc6rplPl9grSXLUuI0xdkQCzDIc4ypyXXCdDqiLCqaItw3TqqgOcehZMR4Mma5XGKaMlR2vKA2LVH9afX5hzl+PBVoul/eozoZho4ESezIdUOidOgL6+Uj3tM6S2MtQluk8zgnaLzCEKRFSlvQBiIZ7IeFohWeVgha7ymxVMqy8ZbWe7y0JNIhJRzdvckrL7/C4eEBUaRYbFY8Ojvl/mmBjXOIRvhkFBYqQQiStmEBTyRI0yA3z3h1dslX/rs3+Rv3P6atHcNhymdfe5Wf+wO/n2x81K/ggAetcEriTEPqW/JcEU+n6DgFKWmdoaob5hfnlNW7JHGOGu6gBxdMRiukd/yJL93lq+894fFZzURuuHO4pLWa5eYhHx5bHn37PeI0Q8VDvHNEOmUymTAcDHjp5ZfBwzd/65ucnZ9RVBWbTQF4vBFUtSTNBiFLKI6IZIJqFKu67CyqQQi/dQKzzuC8pRWeQngqYyiWC5q6orWWyjrKqmZeViyNY5PGzDc9FxqyyqYIDrxg6hUDKcmkBmuJlCBxCtv1DkovaGNBEyvqSGIShYhU6DfsFnvTNHhhiSc3ya/fJTk8QusIe7lkZRaIZs0kjrg+PeLJaEosDXGbgIogSfD5CJlPSPNZYEZij888ZB60RfkWrEC6iNYpap9Qa4WKFXEkUMICBnwLvkW4EtM61kvNfCFZN4qirgMDqRK8rZA+R8vwbHgl0YMUv7PDw8mItyc5l8rzv/9hPbifDkyXCRaYs7CBFEIGQ48OcfRuseHPXf+W6MBBB96kDDloToiOcLPYzkzEduYhgVkLroqVE5iyhqIM+WcqWJjrNMO5ENRrTEUcGZRsMDYAGGMkCIuSECchGNtsXBduLQJQ1FdZfC4sk1uZo3NXIdVXAO3qGesZwP7fe49BqRTeBjZN9Jb13Xn1xihIQdUBu9445/Ky5fLykr/21/4WHs9sOuX//Bf/Iuv1isl4wi/8/C9w68YRL7zwQjCYkFFnotapLDoFUc9seULRSHRgzNjuODsjNevBuMDwedsAAtcVDZ21VMYjlcRYizUO19rgH4CEDgiGnLg+E8x1YDjEXkup6J2HPR6rIoyXSK8QtkVai7WyU5x1qg96hceVe6YArDNYK7efg+/67gC8MV1GWYgYsNZB2/khKInQMVp0xjN4pNCobikyxtA23THaYOThkQiVoaVGqSD9rxsTHC67vkjfGNrWdOcIthd/yi58oGNhg+2/D/1qnRSUrv9a9DLR7v7pw8MjEcxM3JZl+/7GJwLOru/NyNSExitaY2irCxLRMsj3cRjGwyPS3Zjq8jF1uyAZZQzTEfeO7nDyzrd5972PeO3Fa2TJiCRWJImnaTxZFnExj5F+wdHhDm3T8u79E0xb8fKtI0wjOF0UxPtH3JppqrJi0XqWPiFTGXVVsZifIKIZWTLANSWbcs5gMiXGYcoVxpcsXIPSKQkbFmXNslFsLp+RDRK0GDIZjPHNMW1VkY0U12cxsRaUZOgsYRZZkrpFqx3m3pCmOTYaAjm1B+Ulzsc4lRIp8NGIgc54KY9573TBaQXWNGT6hHKx4VJpptN9dnb2GWb7DFii2oLdXKFsycelYbkuuPQNR1O4piJMrQBH7pbkO7exeoBuVkigag1P5gtOLo4ZjIcMhWZjGnZ3BtSmJks1F4uCsilBeoqmJstSIilpRZAx2G0fDERRzGyckUQRT07PEMaQxJrGOuouf2g4zHEq3JxZlmKs5ez8DC0lkRasTk6wONLpLkqFHJLGNF3RQhBLjYw0beupmpavf+W30FKys7NLmqR4IbhYl0xHU27dOGJnOuRHP/cKd1/5PIV3/PJ/9yu8+877vPPOm7SbFcui5PGjBxQnp+imYbhznabesFksqNcXYBp0MiGfHbGaf8CmvORyuSAbDtHCkzpPu75gJTxVcUpRGWw64vHJBR9/+EGoHkYRZVWw2WxAajI3pG8FLdZrrHWkWYrWEd47qmrOaHqDRrWYusXZIHc1pgYPbd0wGo3I8wFVXaOURklFmkTIYIr76fghjZ9KYSAlGmgtgbHQMUQJsRIMhUXiqXzIr8m1B+fYtJ5WOtLEkjhHaRyV88RSkGuBl45COFpp0NqjpaT0grWX1DI0YDssa+GoPNhIoiKD35+yc+8Frh0ekuYZplhRnp5w+ewhg5VjNhpwXu4hZIJVEdvQTBF6zaSAgW+Ilh/xnW/8U96PBNPJDjv7B9i25atf/22ODg65eXQArsW2LWZ9Sv3g27hi2WV9WdJsiNShqlo0IfT16bNL3vrgPlVRMx3GXL91HSEVd16+y7WD65jNBTtDyYMnF5w+Oyd1Ofkgw9YRszTnopFcriu8MGit2dndxTmLFILz01OWqzmPHz/CGMPR4SFJnLBeL7HOkiQJQnhM6xiORhhTU3kCYJIWhQ62+N0mokVQi/BrITxzCdHJU/Tj9/GTIe1ozKmtOV7OeXz8CFMHQyUnwqI8MILDFvZaz0CEngmNR0hJrHVwL7MgVJAQogUm0RAJRNRbuzk8EmvCZ42EeDwh3z8g391FIdgsFigTGtajwZTxzk2a3WskpiDenEBicErh4wiVZiR5isFT4ym8pTCua/x3WBdhTIxvYyqn2KgY0UZEkUcJh3PBednaGmc8tm7ZrBIuziNWixgvc2RaUTcF9WZN2eREdRNUA2VBWVTUEpo4RsxmNGn8w3x0/0c/+g247diZQJ8EqVpoMbtyHuxD1Z2zWB+Cp5USCCfQSm/zHb/XNj58rzFB/eKcpe5gRuvChr+1LhgsAK5uKMu6c44EYovp2aDO5MM5aOrOPF154ljiOsml9zY8g11OWQBJ4Rhc1zfXF3z743s+bPt5Jz3RnWvoE7L0/b0OT1cbDfNl16/K1hgKlFRb90sv6Nx34fT0jJPT0wBmheKt777Nz/zuL/PFL36e5WrNl77weW7euEGso20Qcn9EQSIPdNlrHnBtZxHfm1IggvGEAC8lUgUXTSEkznjqutpK4o0xAcAI2MZ/9MpGz1baJzvWTCoVAlWMwVqD9x6jLDQh08u74O4YTDnCn1UHSlTPUHZHiRdI53DYK2k+4IXqWNeAKJ0QoWioup5rTzD3M6Ev1ndAae0NpnXUbZAyXgHCIPV0XuBFi9QB5sRxjNKaWEla29IaQ10W4Rh11AG0zhPZQdu0Xead62qRNgDPbp2XiOACSc/gyuB06f1WTdPS35c/JOZsOh6QKgHpMFQQjxeI1QcU5RnJ9Ba7O4d4oTkXBQmCw1v3uCzg+h584cU7/MZ33uThw8fsz8ZMJ3tEKgERMxsM8JMxlCuuHe5RbWoa03J2UWFxHO7vcVk59q7fJLKOx8uKR2dnTIxnNDsgalps2+BcwerZR6gopmkt1fqCSZ5ibc0oS0HE2LJgU1W0IqcVcWjO3qwYZyuElvg8g3RKGgmSPOLOSFOKHIdkmgqOoji4q9054vTpY4wao2RKYyx109IUC5RZM8oiThealXe8uK/5/PUpZ/4o6KjXD9gXOY3MSQc5gzRiZ6DZIeHR42PeefSYi43guKh4dQpenTKLp6RygKqOycqaXMxRg2tsak9dS3xb0MoB5AOOkgH7Q40WhsOB5unxGcZ6zi8XPD1bghAoKfE23JiTNKY2LbGOSOM4TNoC9naGSAPVeh1uRKnIs4RNbTE2TIBKCqQIYdaJVJSrJUVZd/1jhoggb1dNsPJHQBRpcB7TMXFaSJxyvPH6Z/izf+7PkuSKLM1QOqOxksWq5MHHH3Ntx3CZel5NE/b3D3Eq4kde/bOczGu++s3f4a/8B38Jt1mwXl7w9lf+K1QkGc+OqJ1hdXHC6uICkc44vHWPjbM8eHSf9cUlT4sKkpQXD/fZy2N0JHHRAB/HJCrl6argW2+9RVEU3SLlWC2XeC8ZTQZMJhMGwzz08DUVOEccpUymE6RUNG3N+eUll5dzLB4dxUglaVrQSiO0YDgYAiBEqPQc7Ix5/c4+093kk3h0Px0/4LgZC9K+JzIWpHGMz0bIOCHRoOsS1zRY74mEJJEhMyaXYVOSdgvARoY+s5GGWDlaJAvvsNKRaR8cap0iMhbhIFUOKSwrHGsrENKQDzXcu4e8dp1skCPaCn3xjMHD97h+OifKjzAy59zJsAjq4KAlHOB0yGCRHhln1Pe/zf0Pvh2sgL1nMhuTJBl7O4cY56mKEq3KIFGpCopig1tcIlxLnOW0SlOVLY8eP+BsVfDOx3PefHDMu0+CCcTn791Aj9bIek2TRQzGM6JkjM5yRtExm0hzfLZkp6opZQ6t5O7hIa9MX8WrGCsEddPibNipHB+f8tHH9zk5uSBNUnZmGYOBwZiWoiqoyhLT2qCAKCqMNQzTAXVTIRw44dkYS+27mIOuwrtRglPhGEiJMIb67be4rEriw+vcl5aPF5d89OQR66LY9rMoDzvOs2cdQyeIRejbEZ3VdiwivJaggt0+WmAiMFrgQuzRtphjtm5toY4faUmWaOI4wtoWnCPylibLWe4c4K7dJh4fkDQbYunQ/hy6jYHxLsjFhWTjBaoRKCzOOjKhkELTOk/tJI1PaF2Et5rGBltsawW28dS1pa01Va0pV5rlRcTFIibSE+JpSlMXbBZLFlnIbKsVNMs1jTPMV0us80xmU4r807nrhzo6csYa27lzdlX95wxAnO0AiexznaC1fuuOqKTE+LAx1UptAU4PeoQQVHXNcDjA2S6g2HXWgkpgnNsa8khC+4S1Bp146jooCqQO0RfOmo5dkVsJXg+JgulD+Jvr+oqED8HQrstEC0Dt6vhCzJLtTvnq6+H3qwQx64JMMuRgd3lrArz1neS8kxxuj6Xvd+tMdLpIIWzAQRaBlA5rW37t177Cr//GV6nqlv/69i/xwt1b/Mk/9kd45ZXXumw2tlEWvmODXCdjD/12PfMkMM5vA56ljlAyQQFt29IUNbZtt+DUOY/dMnTBaMp53zl2hz53j+h63hy+bdm6ZXbgV4iGnuAL4D30w6muL1UJ0cnzA1AJH1YwwnJ9PyBXfYHBbCSwheFrASBdGXWEPrnQ4watCeC9KEVnRtNf974Xu4sP8B7vg+OkB8pSobRGa413dF4HpjMgsVs5KaJzLXc2HLfvGUELUiCURkVx6Ae0ARRLqREywnoTeoUJQDfUCiTefv/F9E8EnEXJhGr9hJ3ZHqlIeFIUJHXJenHB+XzJvekN1GBIdPMFZPGULBsho5RytMs4h90s5be/c5/LVckbr7/MK3dvkmVDwFA2FoGjaA2N2XDrcMbh7oxBrNiZjDiIc8a7Ozw4vuSy9cQ6ZS+u0dUFm/WaZDAmiRKWdY0zETrOsdby5OyCl27NGMcRD548xoqEKMm5PogZVIZVNcA2mqZakkQwubZPxRAtDVW9IfZrBuMYEQ/QyhFHjuHsZmi0Xxc0RlLJGC8NiatJIwMqwUcJZ/MNFYLvNAuuT3MOZhFp1HJSrdAuZjRwaG3JXIGbn/D2+ZJF2cC65HRRsZ9CLmLO1xeIvT1MHTS/wtQMj17ED49wm0fM549RQnD7+jVu7WUsT06pWkOthpR4CnOO8J6qqrm5P6IxllXZsi7rAJZixThNSZOILE9wCAZ5TuLh7uGY2WyHv/PP3uFgmrM/GfD0YkmjFEJKIq2JY92VojxChwm8agxVsWF/MsA4S7HZsLO3h7FQlgVtXRFpiXUGhCJKNF/+8R/l2l7GIElIshShY0Q6QkjFiy8d8u/93b/Ob6zOuHe8YZpHfPbLX+SP3zric7cOeOnazzAbjfh//7W/hq/XLE9PKeuak4fP0JnmyfkJH1+06PSCW2dP2FQt33pySWQse3nCaJJgFzUPzwRSK/JUB4mPA98IIkLuRrC7FVjrGY1GvPDCSwgZNnyBNtcMRnmX89Zwfn6GkIKybkIFs5skFYANDIEQgsvLS5RSxFohdMSdoxmv3Dnk6PZLn8Sj++n4AcdhGjY0iVQMIoGNUqrhkCRLSYSHAsSyIREehe0WeIEKrry0XRP3LFIIYYlF6JlohSALbcREnZ44lg6pwgKTCY8QhsSLYG+cKtSdl+HWC/jpBFyLOD9FPHiP7Nn7jNQ1nmV3uRy+QJFMMQRQJpREdbbvwhoEIWPmzguf5+l3/luelCVFUfHk+IQX79zm5tF1jo72aOqCsixxcYJoWhpjiLOgEiit4fL8nNPzFV/59kPef3jMx08vuP/sjPmyRCWavfGU3/W5VxDe8ejxR6SjMSfHZ2jjiKKMydhzcbKhKBpII3aHnkoZtCuIRymNjLg0DcY5Jjt7vPEjP8rnfnTNb/zmr/Leu++yWJwhhA5zTVkjhSLLEoy1IJrQBF56oijh9rV91kVBef4Ub0wHVkNQ61xCKySRChu3Tdlw+f77JE+ecJpI3inmXG4qbGu2Es9ECGbWM7EQdZlMTngq2yKwwSVMarxwGOVplKONBK3spGEubI6t9aEK7fsmfU+iJImSaAkOTeUNC+GoJrsUh3ep9m4ghzN0u0aaOWpzGW40F2RMxlis8LS+y0gyjo10ZHgiGTZpBZpGRiHpyDq8DRs501ps62hqT1F4ygI2S8VyoWmriDjypAq8azifbzCbS/yD91l4gbEeOYiprMMqTZpOmKbZv9yH9dPxPWNrnsH3Svp6gLKV+HUbdNttpkUndXOBdN9+//Z9OydFAdt+ddM2ncU+0Pe2dQHVxoZ8NN31sfXyQ2tDCphpA1vVSyWDoUZXsJBBEtfLAbXWQLhfhWALxq7ONWz+HW57nv/8Ofd5adBb8DvwIWogsIf9u4KXAaCFXiXRWegHNn8r++Tqz1gXAqs7OLouSrqryvsf3ufJ02O01Pwb/9qE3d290CcXxBada6PrTKhC1IWETgbpAvC1Afy2dU1dFkFKKgS2DW0i3wsyeifD7lygk95BbxEf8JTfgoweOHW3RQCfQrJd0LwNx4lHKBVM4LYXq2fJfHD87B0Vffjpomc3AYfdmm2J7nMPskJobCdTtZ3JiAuMqu2P87nYAi/8FixDyCewwgYiANEFU2+tVq5+99s7p/sv3IPbHkbhEdRQboIVSNfyE8y/OsDen2sviXxO3vn9jE8EnJnNE8z6DLPKaEREsXrKejVnuWj44PG7EOV89sd/nny8y3J9QrE6pvFD1nXBeDrlztEenC1YLIIbnZMRUSTYdSueiTkM9mm8Z1U6inKF9IJkrBkP9hjMDqmFJh7skOmGlSlwTQPlgsanaJWwN5jiN4Z5vcT4oCPNYsnBJOfkZM7FoqQS4cJPBzXStexKg0vAZxEqyTB+gDJBblJYxfn8nHG1IUkzllKwu3+b1Jas1xfEgyEDnbIuCoSzOHNO5UqGwxmtGiP8OXZxzJOi4pG3XBsrRnbDWAlGgxTXaFyWEZsZD5885aOzOW/cmpHPYprLCxaLJRu1i48TPnz4lLp+QOI9N3djfDGkLt8nWjzlSLVE6QCKSzb2nKfHp5TWY2XE3mzEjZvXeGd5xt3b+0wGOU9PLnhwfImzltp6rPGMh1momClNUdZ4KRnEEddHET/xhSPeu/8UITJuHEw5XRaksWeYp0Q6SB50px2uypqqqTGN7UIgw4NWVQU3k4giEmw2DiE1rmPShFKoOOKbv/Mm12/sc3TtiNlkxGCQoJXEE/Hd997i8h/9Cv+7QvGZfMJDYfmPn/0S3/3dX+aF4Uf8Gzf3+RM//Qqvv/Z/4J/+w39EtXjAWVmgxgmfe+OnmL/1dTYffRO7WpGaIYu6ZbkqcMYwiuGl4YSTTcnlxjJKYuJ1S71eUmwKFqXnrY+OaY1HKYmKYvLBONjqKhX6V6xltVoRRRF6ENE2Fefn5yyWS6RQxFEazAacQ2ndhVEHZsDaFmMUWZojlCKNI7JEgdZ88ODdT+LR/XT8gCOOI0pkcDBUkjodUg1n2DRhbR2+cozsOgSVEqqasYIIgbdQGU9lghQjljCMNEJFNF3OVuIdiQ4OVjiP8hqNJets2KXyRLHG3n6B+oXXEQcHmFjjL09Rj99F3X8bYcb46eucj1/mcniAVQorFNZ6dCc7UT6EpTrn0QjGd17nePcG4tGH3L11myTNuXnjOi++cBfbbJhfLpiMx8F4R2Xovdu4ck1TrTg7e8av/9bH/MY33+bNt97l6GjKMJVI59nb3yMWgldvHTGajricP2Szqnn7O2+yv7eD0qBczHRHkmnBer3BChgohR2mPFtdUpYVJspwKmE83eGNz32O2WyPjz/+mCwdMp3tYE1LWWxYzuchhzGN8D7YSBdFEQogSnUGSzmfvfcKu8/2+db7b7Is10BYoA1ghMB0zlsT7xm3jnpd4DaeoTFcmh6YhZE5GPgg4QnWz47aGJquuV4qsBoqLVhpz1IJGtlVvH3of2udwziHtAJlLLEArSIiqfHGEnuBjhMGe7uYnT0avU91cItqZ48om0Ap0VGCULKr1gdXMmtbDBrpgrTxxDXMbc1AghYeoWJMFOFjhxeuC+wOBifOtLRti2kbmrairCqapu2YBIv0gVvRQlIbeHo5Z3H8gFXdUEaC6a0D4tkBcpASJ5pcfyLbjk/HDziUCgxJ8LzoLdWvfu+HlCoUcJzH2CA5FFvw0fejBYYmSPaueqWU7OSMTchdtK0hSdOwrsuwWRZ42qbqpGMmBEwjiJRGSo/SiqYxbMoG8dw2OgCH4BwphETr8LNl5EmUom0sznTn0TXN9xvpPkSZ5871eadHfOjFCirPDui58Bz1QDSwh4EVsdYgruKjQcrAOlkbDKA6OWfPSgZXQ0ecpl2GG+Bh4yy/+fVv8sqrL3F6dsqrr77OKy+/SpqkHctFkM09FxYeXARFZyAWAKT1oS8OI7u+v2C734OjTrsYWCDXA07f5WZ2oKxjnsLP5HvARm+CIYVEySB7VpFGyxis6d7Fo7rganqw2x1j/5446C3yt2Boy9FeMaO9JNV6EYrYHbC0tuvR6+SLV6xld57dOQSWLpxZBx23h7E9Sb/9XwCS3bFeAdTtldua0Hj8NpQ8vLaLeBDd+4pOCukEXrir++P7GJ/ILCmw5ElEOX9M7RxCxKxKzfn8kjjOefbgA67depHJrqeulrT5GB8NaGTGvKyZzQYM8oTvPj1Gyc71bzQgThz3Dg9oiJlfnjAYjNjZu8Z6saRsznBqiNUDnpxuWG5qdoaeaH+MFitaEvKda8QSFsWG08WK2DcsVxU69ty6ucPm4pIHD97BM6BcLSirApMlTPKEpxdnXBSGmy+8wsQJyvqUPBlhSLDtirZyPL54Rh5Z5HSfNN8nkZcUdYEWKTpNOdhJEY8/4KOH72BMwV5kWVaXFKsFzeIEuVniTMHjp4bHRcVOpHjt+oTP37tFjufBh484W69J64ahmlBsKky14NVbe+xOJ3z1vRPmiwfYpiWWkjv5EZvThvunC4qqYFNX6DhjIiPAsCkNTy7nFNax8+M/zijPGQ8Tbl7bRzQtJ2dn7IxT0kRRlA3LyrNpQsNp3j0tWksuNyVrt8M3/tnbtOdzxkdjpPPkkUZLFTLA4jhM0N6jpES4IO/y0hJryaauKUr40S/+JI8/+K1gue8MXgQrU52mxFlO3bb8k3/2FQZ5zpd/6otUN69zpHaYyBrzwQdk/9Hf58+9ecpRnpNFFddWG/70/Yi/+c5D/sMv3eXDown//u+peWX/Vcrf+9N89R/8TbLJmINXvkRiPUey5Mdu7FJ5SZRltOua4cbgjecwTxlHmo0V2NyRJTFt7Slbwdmm5cHxklXRMsgyjo5uICOFlhprWtbLOaPRiKI1tMbgjeXMGuqi6JqhAzNG58QkhEBHGtNWtE1D27QkSZCS1nUAq+NBSP1498OPOD67/CQe3U/HDzgu4ymRAK8El15RRQNMOqaOUmrhSEWFswJbB1lQoiF1YLvsPes8yxpqLxhEilZlaDQLp1gbw44zwZFROhat4FErGSsR8qewFM6zmd3AvfB54pt30XmOXS9xTx8SffQOrko43flRPhx/lvcnNymilDQStF5QGMFoveRWdUmR5JxkAyIhSTXMxZAv/OTPcPp37nM5vyDWK27evIZtW549eMT+3gGbYoMlOKmuC8v6YsXHb36Tf/CP/imPz5dEIuHFWze5fTRiVRWMhy3jvT1ePhzxmZdv0sxP2SwXLFcVfl0yP1+QaEWeR0zSmFhKdJqhnSeWDUI2pIczCj2klhnp9IBbL7zE9es3kCqmaRt+9PNvMNuZcHp8wtvvvMPuwRG2tXhC9EdRFFjryTtHWaUVp2cnJEnKF77447zw4qt89Ru/wQdPPqK1TedgCaU1LLXmQGhmXiIdjK0n95oJMecY1s7hIs1OFDPTgpG0aOmpjWNuLKozFfDSY6SgUIq59tQqbCr6ANXSO1proXXIFiLvEUoivUV6C61BNQ2xVkz2Dzj4n/x+Hn80R092kKMdRJaiXY3UUbDL7tgCfGDPnAiGDa1paJoK1zZcijA/q8SiE4ic7ZzjQuO99wZvDM6YkDXXGlzVUm0KqmoJbk3kLElrGLUlg3INRcmoMJRlTeMNw9mMaARNbWm7jfKn44c3kljTGgPYzqgobDK1DuzVFqB1m10pBcLyPXJACGHL/eudc1t7/V5KqITEtKbbwDqcCT1LrQk26vQSSmeQ6oo1RgZ237bBhCyL1TZjyjlxBUC60RuWSSWIYk+SRmAFZWkwpmNQcJ2xRxhSBgt+07tU0rMsATn0OFNit8e53ct3O/LgVCm6nqTOqdDbDv90/W2OLbPe4yIvg4OzdcGy33QmE+fn5/wn//l/wXK55PXX3ualF+7xp//UnyaJ047lsSG77LnMS9mFeffZiZ4+cLk3KXH02V/0hi/OIRxbyCE6cCGfBynbaxtYpq49beu8qWVnNy8cqbKMsgRjoO5cpGUPxrbXrWcywzF+z0/aMnQ9AAzAOBx+l3PmO3MUH0CZ73rxXM+W+b53rpc3sqXEesgXfkb4Yi+tpGPawkmGb9q6eHIVP9B/+L5HaFdndMUo+u/9ew+ir+6Z7298IuDs9r3P4JuSTbHm8YMPWC7nLBaXlF4y3DuiKFc8/PBNxrtH7O8fEo3HSDUj6qRcVgqyPOXe7UPuXD9ilOes1w0fP37Kg8cPUZEiVTFVVZGkQ1y7IR8NsNGQqqxZLU559uyEdbnkcDohUgNWjSVFMYg89ekZ1eUx6BG4NcN0SAQ8ubhkMNpBiIzzi4/wzZp1dUrCPtYrFvMTHv7ar9DUDbHS7OzNuHU4Y5gmTFND4VpcVaLmNRdujRnvM58vuNiU5LN99kYzNicPWC83CLfiVDouNhVmtaZab5hNJ2xKz9PygvEo496NXfZHE7750TOySHE4zhkiyWe7lGXJ+w9OuVwV3AZOLhdcLE6YZQPWwrKbaYRUVGXBjdkA5BDTGCwtAsnGSm4cSl6+M8HIhKNrM4pNwcs393j19g2apibXkkhJ6rbh17/9Id95dElTtcRxFCZhDwJJaxqenS9oBhMOrktaIUGGhsqd8YjpdILSmqqqUFrhrSGSoYod5ZrZaMCqbHjjC9cY3nqFz9w2/OZ//032rh/y8eNnlEoQZzlplrFar1gWBf/4n/waZjamshtuLGb82OM1g//sv+adt7+DtYaL5YJsNKRcrBi3A37m6YZ3Lo/5r14+5E/c2OEXf3TI63dvYX/hf8rZR+9zvjrjg/ffJWtrbu7PaJHUUUQ5GJLs7TGNI4qTp6xauDPNOdnU5MMRRalZLVdYmbBc10RSMcjzEHgrw0xkbUucDvEekihCK0VbN7R1iTMh401JHRYwHeSQQmusc6w3a6qqJo701kGoqSqQkkgIpoOY1nl2puNP4tH9dPyAw84OGWPwQlKKCBsr1vGIU5VifMtUp9RGIozGCIlynpH0SGdwRrJ2LQ8bSS5hP8lweoSMNMdSgauJ7AZahxWKE6M4I2xQlDdIIdgMJ5hXvkB+62XUeEzTNixOnlF88AHRPGK++2O8u/9Ffmf3Fhc6Joolu7HE4rk8W/Di4+/y+cu32AwP+e7Nz/Nkus/aR+DhC6//NH9g9ZSvfO2reB1jjWGxLji+XDK6/xGmWrNeLXDW8OF3v8vDh8d87WvfRMuInXzEOE/5zO96g7P3H/DkuCEaZhxNc37+p79Es3rKyZP7bJYrWmOpKosWQcnQOk/VwmiYMxoOSaLAnOvEozNJkg/Idm+xf+sFxjsHeARVXVLXNctlYLO9d1w/OsTiefbsKZtViZSKLE3RcYzUGuc98/NLBoMBOtIcHh6xf3DEdDTig/e+y9sffJeH5yd4WxOh8aYBKdHCM2skuQ8mT6+7iIWHMo6oo5hcaK6lEfvSkoka31oKGXq7nPS4LMLuTKmyiLJcQV2AAIOnsJZVa2na4Jibtd0GEUViFVlZ4OsSU1ZBkeA9By9/lmq6YV1I5GCISDRyE/KJ6DdT3mNMS63q0H9mHU3bUJSbLo4jyJCSJiU3jtSY0CdHyJWytsVbgzctddNSlyVluabazGnLOVG7QtkW4QRxXbJXrxmVGzCOllDVTkqDn2/YJJpFqjnpN46fjh/KuAq8336lkwn2ph5BCnb1Mk8UKdo2SPj6gOl+oyyE34Kdq8yx8D6mA3BKhbnHOoszwSAhBEt7lA6ssjOBpXLWY3u2BY8QccgtjCROOiKpKAqDtVeukRC+30qBIZyHlILRMMF6R1m2eC+37FxvoZ/EMdbarcStZ3nkc/1k1rqt1K6XgfbYI2CeIEnf2tW7vtetc8S0V6ybFyDdVcaa2wLkcM0WiyV1XVNsKo6PT/jWt7/Fa6+9zvnZGdev30BFcQeaXegX6xwkvQuKJOd7wBL6yLb9Yr6X+XHFgnVAyAuxBa3PS/wC4widWq/7qug8BQJrFimJxtK2Vbh/+gY70ffMXQGT/tr1gEpuo5VcMB3xlj5y2nu2nz++B53de/ju/vFXwMz7q8/DuyuzkecgFL1Ekg7sPXem/9y5X4G57f+8v3p1z7T2r+qO1Xd5cVexDdsH7ofHnC0vH5NIQRLl7Iz3iaY7+KbGz+cc3LtLNnudxZPfYrW4JD+8Taojai9DWKE16CQlk5LDayMmiebi/JJVaxjfeoWjeIenH3+H88Wak5MnWOO4sZNw8+BzSFNhhGJv55Dh5CjYKM8fUyxPSQ93GQ3HxG7DeJSjxA5eJiFAz1tWxRIjU3Z291ksVuwc3CZVitOTEy6rhmuH+2wawdnHD1hWjlHiOD1dcbpY8YXXX+C1O69QbC5paoNzLd4bpK9QzvDs4pibg4T52QVtsWCUWUQypVYDzs83VK1jMNlhcnCdrK5YO8fuZMAbd+7w8bNT3r1Ys3dtn3R2m6999dd54/Y+6WTE/cWSpm4RSYquG+7sjGmrlp3pkDsHI07WFQ2aSZ6jtSJWlst5Q1U1HHab+SweMDu6hRxOefzoEdVyzjdWSypreXw8Z5KnmNayrEwIHJSS4XCANW1oAnYOp4Kb2YX1RNGA1XxBpDVCwGxnunUdklKjdQi1Vt4zSBR3D3cQUjCLWj57K6XO3uPuCztM/U/w3vGcj47P0FFGEudIqajqBh1piqbhH57f5+zdM66frfnshzXLjz/irKy5tZfzyh/7Eh8/OOXkl8/YXNaMnOdLK8HffnrBNx6c8gdfXzMdOq7fuskHv/aPke2SnfEOi+UcrTRxlEAsGMUwIebJ6Snvn5zwyqFkNIjYGSSkecp4kPDw5IzFugIhmUzGZIMBy/WSOMlIshRrHcZZLi5PKcuK6XTG3K9oiuZ7HtooSkKOh3WYugp9g86RpSlRpEmzLGyI6hqJZLWpcUYQoRlFg0/i0f10/IBDTmc409LI0LxdKViqlLoT7K4RXDqJdo5SSmrvGVnHxEuskbzdwG+3jtcTTZtkjIcT2nzAfeMYixVx21A0DRWS91TCuYzw0lF5QRQlDF/6POkLrxLt7uC85+Jyw9NHT6gXnvX+T/F4/0d5a+8m6zjCC0lkHBsF1AXqybuMPv5V9s++yv5gn8J4Lu79JNXOHgbNN9pDfuIzP8VPOLBekiYDDnfHLE4e8w+++WucPH3Gqig5PbnASkm7LjnIRtzZOeTlOy9wOX/CnWtHvPnmh6xMzcv3bvNn/vDPsjn9mPL8mMbUpOMx+3GK96CkQAhJkqcMJ1PS8ZR8NCFNY5QLpgSD2TXi6QGD3ZtE+aQLKtU0bchdnAxHPGofUhYVrWl4+vQJpvVEcUJZFmgVk0cR+SAYg0xGI6y1jEcDhoOEOM0BmE132XUNF7JmUzTYtiSxnrFrmQiYeMXQKSIfmt1v+ghFjLAKJSWJgEmUkTqF8A2t8myMYy097B+QzKbITBE3I6pHH+FsS2kN89Yyry2rtsVYS2YFKymYONgzLe2TJ5i7F1T5MDizqRihIvLdXdJcUiYp2jmEd110g8AT+nfqtqT2ksa4YBJQ11RlQdsW4EGqBJf7EHzvLEoKQq5RAGfOGmzdYOqWarOhWs2pizNYX2DrYPiB1NiqgaYkLwoGPvTkSAF+XdKqJXGkMNqTuk9jQH6YI6g0oq3Zw/OgCg9RojGmy9vkynK+z0QLYE5iTNdPtWULruSBUgQnxd4AAix1XXd9ZYo40RhrUBFI8VzfW7cB30rHOlMIJ4KFvJQKITxpqilLg1LqOedFjzBye6zOQWsDCNQ6nJNSXb+buQIMoT8sZJ15QbBt7+YlTwCizvaAqHN69A4X7C6DxHALZntTiwBMwml5ejQnpNjKFL33CNc7YzpUpBgPBpxWFe998D7Hp8d8563v8iM/+iMcP33GX/jzf56jwyOstURRhOjkcuHY+h40vzXu8K7vJetAzxa9+N6Ys2Pb/JbR63nt3n0zyCZ7+Wt//4Q8LyUcus/1csEwpAf6UhL6FbuewCuAFkCWVLLLzfNX3x/+8D+473rm6nnTD7p/Ef8ccyW2f+lB6JYQw3eukuEW7QFTzxKHE9tKXruv+Y5320o7ee5r3c8JXwv3r/MeuX3fcBf3WYDf7/hEwJnzA9bHH7JqN1ireHx2RrFZM8wj9iY7qNEeZ27K/bd+ndzM8bs38EOFRjAY5UwmQ6Rtcabl4ZMTkt0YkY2Y7dxmvbakUcq6Omd/MuTJ6SVVEzb8tjVU1QUtEfNNg3SeYSyxqUQKj7cNSjrSOGK0s09hFcvNkrZcEyvNtd1dWicZJiMm1yXeR0RRTFFesjMZs9rscc9A0dREg32k85hmTtkmvPXoDKlSRsMdMgm5K0hjwXR8wN7NewiRUNQVbtcy0I4oStiYASZ/RCTM/4e9/4q1NUvw+7DfCl/aeZ94z823Uld1mq7u6WGPZkSOhsEkMaRIm5IgyYJN68kQDBAwYOjBsAC/WX7wiw3DsA2JMGDLNkxAEiUxDcOQM90z1ak6Vrz5nnvizvuLK/hhfXufUz0D0z0osh9Y6+Gee/a9O31x/dc/MRqOMKQ06zk3dwbkZcWTac3UZ7z+1T/JK/cfYErP7o1TdnY6ZJ0Br9y9B6YmjmNq6xh0eywpiFONkTE/fX7Mykv2CxhEEulKnpxOqWpH00Q8u5hwuc758lsrHtx7k/cev2A+D7HvReNovCNOkpCKg8A7SxIpkk35anuy5bVhulgyHgisUlRYpssVnW6HNE7alZVgFFVKUvoaCeztDNjdG4fOk/KCP/jtH/H2N17j45Xn+48u+OFHDzFCbU8sJSVlU+G9J4kV08kSt9vha6cLyp8+5dHlJfHuDvO+53v9u9z7q2/BP/0hduU56A/59WzAb9Pwg8sVK71L15YIl5IMR+jc47SClaZBYquSSHUYiJonl+ecXEzo6AghoEYQCYG1jovFkuW6YL2uAWiMYb1cEUcJ3SxDRBFJ3CVJYsqFIctSer0OBotpahrnsMYQJxk6jmjqhrppsE1JU5VIGYH2FGVBp9clSTPKosQYy2yV8/j4HOMKmvrTOHM/G3/cMYzb7hTn6fgS5TyuWdP1oKqSpCmphMdKzwpP4RwD4cmAXFgqoRgpzzAJnsK4P6TujqltOMdW+RLtDTMR8RMicpkSCctYCQavvEH3zS8SHd3EacVs2fD+SvHc3aPZvUex9wYXBzepRRqWor3HOMflbAUnH9N7+E+pn/4uJ2bG7uqCXeMZy4R58ieoe2OeCEkT/QqHb95mJjIOP/gdvvuP/j6n03Pmi+XVqqQQ7HYGfPHwAV979S2+/o2vs6Di6eMx//C3/xkfnL7kG2+/zW/9uT9BcfmSsshBR/T3bzHYvwU6YbR/RNbfDZK5ek0kHSqO0XEaFnekwJgGoRJE0gOtUVoR6RiHpNfT7O/v8+hxH7SkatY8fPSQ4KkJk7t+b8DNm7cpijXWWaJIUzcVWkvm8xlRrOlmKZfeolPNn/53/0PmP3mXJ//t30QVFYnxxN7TsY4Ogo4XxHhiEyYqSokwaVSghSZCgpc4r3HOUSpHLiWikyAiHQI4soxGSoraM20sp3XNxBoaITBSsvQVQyT3haDnY4qTE/yP36FJE/zwABlL6iSlimM8ETZSqMJte5Icvo2frqmqkmXtqGpDWRTUeY5tSqwzCKWJEkFk0zZy24bJKYRyVmdobIMpa4plTrWeUeUTZDVD2AXOVVRNQ+0iytqyyEvS2iBtTcdZpLWwmOJsETxtwtGU+S/03P1XfVyxXteDQFq3j/dUVUOswgw8dI0FpsF5HybjUqC13JYLQ1DnQ5DCSikxjd2+trUhUVHoICOUziKlx8vWD+lpGSaPb2WBG4bGucCQOGcxCKSXeHs1SbbGgmon8OJKkhl8bEF6ibsCb24LIAKIs9b+zHOCyUyrliWiZbius1/tRFwKQtAQfhtFf92zdwVMryEEt2ElfdgGXmyLj42xnJ6dBRbOwmw6Q0cR3/rWO1jT8P/4f/6/uHv3Dp1Ol69//Vew1vCjH/2Ir3zlbS4uLjg+fskXv/BFer3elvXchHS4DbXUfoPN9pVCtoXbmxAYsQVlW2C2eVYrUdw8Jlp2TPjgmRUItGwX2wiSbCU8RgSNeCj/DvNC0frlnHO0Ifi0hO0W9FwxlWzB5uaftimbBIZ243sV18u9uWLU3HXgdm0bfPL38B029RB+03p2jYXbvIfYHvMbqLYp9L7el9e+7oZF/DnHpwLOYkom6yml6oKN0N7TixPQsM5rZDojG+9SPH/C7Owpl8sFu4eSen1Jvl7TTSNKIyjp4aoVu8YijWN6fsH5+VO88BzuDxj3x6gopZOmRHGH8+mMKOmwXC94/uIZwju6iWb/YB/dH2CEpSoKmuU5cZrRHd7Fa4Xpprikx6wKE/SkP6CbdXAGjHfs7e/Q7++h4hGoOBQvqw7OCXyVslwuuVhMyZIB05WnNiU0Ex7sROztHSFExLpcQLKDExFlK42p6xUJkKQdSPbxLiJOHbEfYGhYCsUocxzduIVpJMfTFbdv3GNnbMn6A8b7MYlZYpylFF182qUXNxztRFyuPTc/96uQZKhqRRpbvIWBPMSv52S7Y7rJLqMIbt0akZdTrBREgyGdXoZuGqxpSLsxGsGB2eXjk1krVwAlBHV7xjvrWRYVN270UAKSpsZaz85gSBJFeKmQShFHGm8actMQqdDoPp0skVIwvn2T3qDHR/OM5x8d8/DZC0QUo63BAHGS4ARUVcNyXdBI8DcGxFpw+6MTXiyW1N7SsY78eUHnn/xD5h/sktUaH0l6keZxXpC+fsCPVmtOpjNe6/Tp9QaQdDHlnMoYdBbjAesUaZyRqJTd3YSoO2I+X+G9oWhqrIjwpmK6yHl6fMlstkBpjXUNrqppTMPY7/D5t76Ec4KXx8f0si7TyxOK1YKd4Yi6qKgIBYhxmlGWJcV6jVQK05j2RiExpqEoC0xtGO3uEinJZDKlNoaPXpwjpSeN0k/j1P1s/DFHLMBFEm0twoA2DV2/pEbhm5rUVMQ4SuFYOkcmYCgsEQ4rYVd7dpXnnnLsR55YWVJfovCMpCOLgMiSesV96WiE5VBA/+AGw899nsHde6hel9ky5+NVzPebMcu9O/h9RdPt08gI7QODK51DFznp2ceop7+HOH+XSaJ5oQfMbUmyeMr42d9n0klZ3/tliv6Yx8Q87PXpVDkHP/kOl4+fUDhLJNrV60jxxZsP+FNvfYWvfuGLjG/d5KOHP+W//oPf4fHlGeu65q//W/99vvK1z3P++D2KfEE83ic+vEO3P2Iw2kfrhE6vT5yk4RxwljJfg3eh97CuqeoQlAOSpqhYNxdk3RoZxRRlxWK+4IMP3ufb3/42H3/0kMl0gpKh2LWpLUeH+9x/8IAPPnqf+WyC1sHHKZWgsjAcjqjKivFIsVytcNaxGq9568//Fkevf473/q//W/qXTxh7hbKexhq0c/SUYJAolAcrHCLyaKXQEvCGRtXUiSOx0G0l4bXLkcRQQ1UtaFyFkwYZO1Icw0jipaKRio6LiCvbMhseakf58XOKzjv4N95GjW6DiKmjCCEiMmuJm4bEOpQNwSGNc1BVsF7iTERdrCkWM+pyDUIiVYJIOkjlwBhcLTHeg5btpMQGyVfdhL6y9Ry/miLKCbFZEIkGlUAlJNPGY+sGU9cYFwJEek2BshavBI2vmXVSLoXncrH4hZ67/6qPDfsTZHefnLBuWJKdXop3jvNV6PETbcCB8x698ZZJgdzE118DJRtPlo5C75cnpCh6Eya2HkHVNEi5ScwLgMhZtsl4QgTVjvPgTRtQQwj22XISLjAwCBEi3LXaAk7nQqBZiMa/Ylw2XqarEurrEjqgrUdxTobP5+xWliZEuG5sGEbbSu02oO9ni63/8Hy8fW+5KczY9Hs5tFaBuXMbuWPLujhLU1UgBN/85u/yB3+gUDriD955h9V6xenpS377H/4209mcOI5ZrXN+8zd/cwO1kYTY/VCRsIngUAGEbRbQpQjICxCiTadEoASbPBU2frxNnH8IhPEBoNMGlBBkqt7J9n1E21kribUkiRQbHWIIHAodobUFV5uwKN++3yZ8xiOwJqR6boSnsj12rW3ZUhvSbj2O1lmylRh6Sevr3fja2ii60CC+fb3NFw3hKW0gieTqgNwcP60/bQNOvQ/BJ5s+PiXaABF/TZbL1XH384xPBZzll8+pyjmDu7eQNmX9zFKu58Qy4/LkAw46exzs32dWzjD2nMnFnLL4MYPRHqvLDspLDI41CbPLZwzHXcajfVbnTxHljEQ7knTE2jv2D++ixJJUWsqqxiW7KOXoxjFFUbJclkTRhIPxTbSG5TpnPpkx2ovoNjWDQZ+jozeZrT3zxSXj3VsMhvvgPcfPP4JYE6djaq+IOz36u0fMS0tjFdQ5Ump6gyFRY4m0o6pz8kYhXRfrJLnvkSQ9uhl4oTD5GbZac7qoaIqGoljw4syj4pe8dXcfYQ3HbeT2uNdhvZpy8uwhy0axLhsejEERo2zFTkdz8eyc86qh0xtTE3NnfwDSM7ES0b1BSk0ickYH90mkQ7iHTGTO7aMdXh/sI+MIITSmrlCyg0wyhnv3iNOUxfyS9fkzVpNzTk4meB/6yoz1oQBZWZqmCatISJIsI4k0Uivy9SrQ2h60UEgZGLCmLqmqkgjBfFVwUi/pdjosGklpoHbTsGIba7IkocldSFmLYyyCLE2oqorea7c4LQqax8f8xDl+pZuQCkd+eYnDMvvmisd8xCvdjERrojjho6RhtT/ARZrvXs555fY9qiqnyWcgPDpLORgMMA4WyxXKrhioGJ/FRGlElEWIpqLnBQhFrCKaumY6X1M1NbIxaB2KC9fFDG8tk8k5aZrR6w+I4pg0joLZf52TJSmDwZA8L1gXa8oiR0WSpgm+Dq1U8Nkta9IkQUjBeh0iW4fDAYvlmnVhiLSg3+18GqfuZ+OPOUoAD4mxoWfGWITJMTLCOVDt6nTloBTBL2i9QwuBlQ4tQOPp4elKj5KeSnn2vGNHG3qRo4mCLuaBN2gco8EO6vU30Lduo7p9auN5VkS8m/c4oU/WVaAkVmgqggcDJ+jla145+YjBy29izr/HRSzoJUM6dU1k01DKXJ7y5vHvsog0z258hcv+KAA729AXht2si3Jhoh3FCZ8/vMVf/7N/gcnJS04e/Zhv/eBb/O3vf4fzpuRLr9zhb/y132J45wYnp8cY4VC7++AVcZLQ6Y0QUqKTCKEVVV3QVCXW1GGyJgRCaFQUYSOJQ1M3lk6/x2i0Q14bnjx+yscPP+b4+JSHjx5zdnaKcbC3f4gxNWVRc/v2HYajPj/68bvUVUO/t0NdV0gpgqRKSnSkEUISRRGv3H/As2fPmM9mXF5csPfqa/zK//J/x4v/6r+Ab/895OqCSsC6Zcy0VGRChcQ2b4lkhKTB2IrGNpTOQxzTUQrReKjnmOmawnkoc7RvkNKhcexkQWpmlaJQitKBKyuy3NLx4FVIR5OXM+zHPyQ6nOOGR3R6B4xkh66PiNYl0eqU2CzDBMfWdIsFO84S5Q15vqDK59imwusEoROE6ROLMTEGao3UEql022/lcSYw/lGxQBUzbD3FVxN0OSHFoaMOZSRZVCXHzZq1NKyUZSINma/CZ85SfCdmaS2XpmHai36xJ++/4sPYALrDBFKGCXSsANX6wUK9QhJLlqUiN1cT040nTOAC69JKwTagREm5Ib5w1rVSSKhrs015VDqUC1vnQwAI7hMgyrVgSforZk5JtQ0gAba+oo3nTYg2oKT9nJsetsASilaSuAk42aQthn5CYAuu1GYjidCDBS2Maj11sgVg1l0lBkp1xTx+stD6ytu02dbeO7xtv6u6qgYw7bby+DZFU6JUWz3QslyIALSstfzkRz8M8EcKHj96jFSKbrfHd77zbd743BsoqSjKil63yzvf/n2+9MUvc/PoNk1jiJOQD+AIcnKpZKuwCMEieoNwNjI+vwl5kShCAbRSUStlNFu2yNJ67kQIURF4hJQopbcyRhW+BtY7rAgsq8djlcS020u2vkZa9RRaYlzYFgGQBZAY2L/wvri26tqH46nNym+B9HWG7IrdCvmNV1JOuQVhG89uYPsk293LhgVtuccAKP1VPcOWoNywahsZ5i+KOYuUZf/2PcRgB5E3jIc9ikQgRAylY/HyR/jdGaMMmmlBREY9e8mN175M981fplgco2WMdGPq6TGRMNh8zsuXzzFGsNfx7I8PWTZQljW9eEBTLxmlQ6a2omwKnIPu6IC6XFGWOZPphMavOT09wRQ5MpmgdELsuxyfSKariqooWc4ndIdj4jhjtVwjdIatSszyKXVd0e0dYdOYcrUmNw0MbpFg6cuKRHqacomfVkhTsSg85eSc/WFBPLhJ6TQHgxtEzRzqM5ZNQTTYo1pVvP3akNs7h/z2t3/Ew+MTdjsxd1XDenbOqnYsi5K8KDhkwEvTY5YlJErz9PSCWeHIohmv3b/Nfm+Hjx4+oSolq4s5Slru3t6n1/HEQvDWgwOKeYyIFC9Pn6IGtzFmznRyQerhMNX4es5sveByOiH2FmsqqqYiL2uGSa/tCIJOElF7T2EtDs98PmfQ6yGlQiJI44gk1kgd0qCSSOF1xHAwYDGfM1vX+EiT6QSjYqSymKLi5GyKU5JEKYxz6CgNE9syp5MkuH6XYqfP8skx/nLJk4Md/tJgj+r8guWLExIR4UyD9lAYGCYKEccsXzkgvneTG/tjvnJ0QFlVPHvvQ5ImJ00zbKzDag9Q1TXrouDGjqanIC8KBnFGlMWMogScYz7LmS7nVGW9jddNdUYUKZIkRicRZV2GGHDrGA5HFGWJFwKlQmdKXsyp6pKqqtBS09gmlMoStPjr9YqqqtoOlXCBMc4ghAwetKpBqgjnPtM1/iLH0oQbUOk8tfPUxuGlZOEFDZJMagyKysNCCCQKJSwd78i9oPYCj6ISgmYj/hceLRpiYVHCYkRYAY6sJe5GxPcfIO7eh2GPVZnzYgnvLno8Nl0aFYWU0zBtQgoV2LZyya9evMerp79LfPkDclVykWTsa0kvkcQ2waMovcetP6R8ZnlmK75/85d40j9k6CqGUcS6O6CjJZ004/6tB7x544DJ6pL/9x/8NqdnCy66HcZH+/ybN0f81b/2WzS9HueTS7z36LSPlh4lI6IkwTU5xlfU1ZJiHYdi0aqksU2I71YxcZLRGQ7pDnZI0h7GwSovefToIccnZ5yfXyK15vbtW4zGYx4/ecqL5894+fIYIQV3797FO8uTJ0/Y29ujk3XpD8Y8ffaU2XSCkgGQgUVpibWe0XjAo8c1SvcoqoLFakm/1+Nz/+P/iMtf/U0W/+i/RL77T4jXc7z3lNLgpMYrhXWWxlTEMkxy1tJQOIfyJQmaOFKUJVRrgbdtF44ELxpi2ZBqwWCYoLs9CqnJG1jPViSUdBqIpcZEYVVbu4Z0eYnwCu9jbAJOKOJqRrw8Rq8vkNIRNwWumrFTzxlOLynXC8pyhXCeOErQUQzJCCtKpFmgdJg8IRWm9Q1753BNgcuXmPUU0yygWaDMkkQIlKyorWTd1OSyRMQNyjcoVeNTixMS2/F4bZDeM1CCjpW/yFP3X/mxASgBuDi8D8FsQoCOFbFSRCqAo1hDaVwwGbEJm2g7ya6xAZvX/ERXWpvaKCXBf2YDW7Fh3nwbrOFaGsz7EL6xeS0+wewFr5izrpU7thNx7xBtsbJvkxO1DpHznygm9htvXeDevN+AU9jMvDcARIjA0rgNKPlEMAXbz75RK24KnkEg5BUzt2FcgvTtSu62+a4biaCUwe8phcAROi2F8ERRhK3MJ+SJmxLwDfDBCYwwCCOYlgXTyQX/6f/mMQhBkiQc7B/w/gcfcHJyyttvv82HH37Ab/2lv0ISpSRJChtWR4TCbe8FsdJ43Da2PjBY7Xdpv5a1TfvVBFYopHctcHWh/sW3jFErN21sWzgugwoLL7BOtImwtOmegFfhmFFX7J0WCo/EujCvtDYAYzzYDeEpAtDfbPLNYRP+7rf7r93TLdvbSiI3kk4CA7sJ2xf+isHbKH8F14NW/rD/Ddmqyza+v3axYVuH8HOMTwWcdYZ7xP0hyegu69MnjEYHiPmC56fnOBUh1xbXPMEqy+XzZ8hej3Gvx/LyIQdHXyDtjVlUa5TcwU4ekWiDVjDsDblcFVQypiFC+IpYNWg0k4tzugNPhePi8oLGNnTSDkIlvHx6xoezj+gM9hlohYgS+r077A536Y16zOsM3ekQJ3D57ENOHn9IQ0M22KPTHRNFXbS3UFeMOysS6VmommjUw6oE5aAj1yTCkY77xPqEy4sJ86WkLiewmLB3w5F0+8wKw8X0kmr6kiTSjEZdvvDgBruDXb7/8BlPz5cU6wInCiI55s7RIZezBbPZSzqx52DngKbxTKZTEhSny5rJyhIpzze+lFA3DZergoODG3RtzWg85qtfeguJ5Pj0JSeTCz744DGduMu6rkj6FxzsH5IYx2p6iZ+coNQTXpYV/aMHqKzHs/MJF4scIQVxpIO0BU/S6+DrGqsktbGcnl8QtwXJ0kOkFGkUBSqa0JMTScWw30fHMcY4km6XpjHM1yvOTk5ZFgW59eyPR+R5QdMYBr00GJKlIu10yeuGxeklvlozGgxZjUf8zcsFb+z0eHPWoY9kV/UZDQbYoqITxZxFgtM3b9O5c8SXOj2m6zXff3hMfHJMnCZoD8pJcpOTN5a8aXDG0/iIQdZjWFqW5YooTtGRRyqJTmKKNk1tG53rDEJFaKlxjSdJY/Z2hpRlznxxiVIxoFBRRFXV5Pkaaw3Oe+q6wliDt6FRHmsR3tPr9YiUonGWcrUk1lHoFWqLDp0QlObnb5z/bHx6o/AGhwr9UMphEdQ65SzqUAjJjrFUYkohDcdOUgtN7R1dAaW3PPWOrowZaU2MogvUWhJLRSUF1gqqxjGrDHMpGd5+BfPKm+i9PSyC6eWMn1xGvC9vkOsMIaHxYKxAa4HE0vUFX1s/4Zdn32e/ep9CLlnKmF0tGCnDOFJ4nWDaVWxlLKZ6yO1TzxDFP7iV4lXCzt4ewjuywYBXb93kjTfehKrkvYvnjD//NsPBMV/spRz+8lf5M19/CwYZs/MTjAsBOFEcICNC4k1DbS2YkG7lzATbxtaH8voUHaUkSYYUmqoqsdZgvaDMC6LIc3N/xK0be/T6A0rj+dbvv8PlxTlFnnOwt8/B4R5lVfHo0XPGwzGvv/YqR0c3aRpBHMc8ffKEuq65dftmu2BsaeoKLzzLxYKmKRkMhwz6Pay1LIsle2+9RXLrLqdf/w1e/p2/hf/wHaJmjROGynmcULjIhrVYb6mFwSlQyqJpiKXCCEnuQtmZkI5EWJJI4IUkVoJuqok7MYlOED6iMQ5ZhmsCShClCV5phKmIzQJvM7rrKZ6IRqXouiBpSuJyikgynCmI6xU0OWr2hGI5Z1kbtPAMIk3aHWK1YFlH4Bsi4ei4NdI7yqhPqWKMc0T1gjifI9fnFOUSaxuU9nSThJiGxlqWrmZlS4QzpFFDT9d4lWCiLkbHyCxFNjXarHCfhTX+QscGQG0AGoKtR8yq0FOVG43Ck8UxhSkxLsjGAvgIC43+ZyannrY77foU2IWetDjSVK5BqRbw/yGAeJV2t5FdbmSAgS25miRLKbaR/htAEbBSG9hBAAmbLraQRBkAo7UWpfT2tQMT564m4O2QLfsmhGxj20OwCFfzeJQSxLGgrFyQAraMUwBwQS6ntAAPxl2l+AlAyAAalJR00oQ00lQmSCijKADYNNUokVDWBmNN+3kdQqgw6W+3gZQC79ptLmG1mIfP2B/y4vkL8PDd77zDD979HlmScnZ+xpe+8Hl+40/+GyRx2gKaK0+ds+ZaCfcV8PTtYs0WZmwRkMSFDYCQCZJNamPw4wWQ4gjuurCdQ4l08By2Asi2K69dgBKEHk4Z3kd4D8KFrjMZwI7ytF13YsuehvWCIEvcgEOxIQJbOSJbFaNAX0v73ASpIOT2WPBs0kg3ZFgLzMSGTQ7/a7OdNl7nzfEW6if8Lw6cLQvP3o4k1gnTfMnk5AkPHz9ltiwg7hB1+vTTDMuSF6cn9KsBd2/ss5zOyKt32Rnd4vLimIW9IHYF/SxDd/oMvUZEKWVZcjE7J+0M6e8eQA3r8iMKe4GRDadnF4yGQ4RomEwWvLi85MabX+Ho1isMlaMpZshI08kke7s30MuGplxxOVmwmJ2xXlxQ+4rJ9Aydjcl6h0TC4fIJ49kxWsdUTjIa3UTFQxamINKaVGu6kSfXnsvKUxXnnOcFRVXwtchxW9/gdD5D2ohG98l6mtdu32I1P+P3Hj5ksbbcHAgGjSSSoZh23IsoE8/RuMvdGzfY7w94enLCgx2oS0MvTpmypp9GJNKxNivefvvzJDphvlhSW8P7H/2UJOuxnC95+uIU6yHrpkhvqNYFatcznbzk5PkxedMw6g44unGD2ekzTouCSGkaJwLokq3x14YV4Y1x0xhDXTeUZYHQGiVFC9R0iIInSAGs9ngj6XV7WAe1tWgdM5/Pma5X5HVDpz/AWMNyXaDTDjqOaVxI1onTDDesKIoVbrEm9xHvP/0xP04cv7875vCNIb/aG/EXzg19FbO7f4BQkr/1oMPzu7t475kax988n/NmlPCgvRTM8jnx4AChNZkVDOIEmcbs7N5gMOjTy4a8ePkI7y22KiiFJ45iIhVOOtXeWAb9Hr/xb/w63/zmt1guS2pTM5/PyDoZ+HChi6MBWdqhqRu0klRVQ9U0eOtCItTmBmkdTV2zv79Pv99nvlzilEZJSWNtYM2EJEtSoij7NE7dz8Yfc+z6EisjrNRYLbCRoFCeSkliFImEVEKfUN66FBUdBJHYrEhK5t6zFpIqzVCdPqv+mLRcI/USS8y0XPND42nu3eGLr38Zees2PkvIl2teXEx5Ot1hPZLoyONQGByI4GOIhGPfWe5RMY5mxJGgzDSgiFNJV0pS4Yi6CWWc0jSOpC7wVUnUXNItz+mXC56MDjCHb/J2f8SdV+/TT2O6/ZT3nnzA//07/5R4d5/aFbw6vsG/82f/FI6a5+eXGKMRaJRuAkNjLbjgoVBxjLE1QgqEjrcryUppoigmSRKEEm23V05dWqRSDOKUfjoM8iUhcF6ireLB3bs8fvSEWGu6nZTT8zPOLy6IIsW9ezfZHY24cXCAkJKqWlPkK/I85+bRDbrdDrPplPFozHyeI4Tko48+5ubN26w6HYq8JM4SVss1g36PZdKh+NKfpNApxQ9/j161YIWn8ZY9KxnEAukEiwpqB10d2AeJxRoQThJ5TyQEiVZE2tEo0FoRSZDeooUlFZpOrKiFx7arxzpKkXGMlA1xVSDVCummuCjBDWPk/gCtb6PiGr9eoRzE5ZKovESuT1DFisZIhBdEPiJNFbg+xtVUPkXbkrReEtkcIaZUeghIVLOgs7ogWr5EFksWxmGjGJVpupEICWttdL4Vhq6v6MeCZGfA2qcshSbqZGR6TLQwUBa/4LP3X/HRygW3/ih35any1lMjKYQlUR4hVZAfOrcNidgk620kfkKG6bizrSeopSg2LJS1to3TD6JBYzcIJ7BPQeLottKxjQfsCgiINvUwgJFNt5oSG+lgG9IgwZkNcAzeWOfc9n2vWD1/TXIYgEkU6XYSv2E8wvtufr9eouxbVi2NFL1uQmNWJHGMUoqmMdTGBBZSq603STiom1BYHe7nBrzYSjADywidLCZSKtQV4EPolLxiCsM+++TqRpDStb4vL7chJ0kUsS4KlBRUZUklBN2sy7PHj0m14E989W36B/vt8bDZTwTZYiulFO1xIQEnruR8m23rfCh4FlIilEZEWQBSttmyUlJ4Iq2IonAsGWtAquAD8yAVeCm3VU1SibbEOjBXivAamBaoC9kyVFf4cFN7twFdm1423UpFw96U29JuIdskymuaxcAIhz28+e4bWeom/CMsKrAFaHjR3toCy7ipCghdbOGn9VfhOz/P+FTAWU1Nku4gsDRGslouWZU1vUFCUzomL56S3Nrjzmuvo/du8+Sj98nzGZ4eVZ5TqnO6nQGrxYSqWKLVGJylWE1QjWGoJTrt0biS0fgVXB1RH97AOsn7D084m13yS3/2z3Hv7peov/1NVLTglc9/nqR3A1+cIWJBVa0oVwtOnz9hMjmjyi9oGo+zE7qJYi8ZYUzD+eKC+eyCRMUh8lkeIb3jyclz4vQRcRzTG+zi+h3kYECz9pRlgfMVo6xLWWlWtmG1WrPurpgvC1zSZTga8rnDLpeTOb//g/eoliuyNCJTHtEsaIyknL9kXiuGQmPTlMV8Tj/W3BxHfOXVQ3748IxXb/X5lS/eZNCNGfZ6IGLyquDDjz4mXxVEccJ4Z8StOyP6ozG7paWfrFCmwaURUih02uH4Ysp7x5dUleHBLc2RtZw+e06cZvTiCG8NmdZ410oMbFjdss5jfDBeGmcoq4pUSXq9IXGSkKYxtqkD8FCylTVInFKsipL5fE5eVuRVSW08OsnQSIq6BqXJur1tyWRjPW7U4/JIEb+c4p2grNc40UAN85eXrA93mL2+x3f+1AH3Vw2//s4LVD/lnTdv4ndGRL2MZ1bSK2pGz5+wLGb4pk01awzdRGGlJR51iZKE0aBPrzvAd7sYZ5gtpsFTlC9ZLqchHUqEmxUuFD8e7AwYJYpmalFSszvoMdwZM5suGO4f4YVkOpuwmE0o2/JJnMPZBuGDN08rBUq3+uUQiJJUNY0xdLpdhFZ4UWJqw7os6PT7n8ap+9n4Y46Dw30aFIVQlFWFjxTaSxoH+CCZS5VA41GioQMMgJEHKw1xBEsvGciEnvDEvkHbGikMkQADLIGT8R6Hb36F6N6rqP6Qsio5uVzw4aXkwvWDpMdafBQmJIogHaqcYCojTroH7A6/wtiVVOclOYrMOrx2NO0ad+PBaIUsLU6mLNLPcdF9wHnSZ60Uf/uNP8N/sH4HPXvIo6eXXJYF/+WPf4RJOtwfDvnTf/W3eONzr7JYT5iuakoL1ibIpsDma+KooNvphRu4CCvVSshQmyohRiOEQmiF1hrfVJS2ppKyVaOoANySmihJieIUFWmsl1SrGmsbdkc9ivWU9z54n+VyzaA/Yndvl93dfb705V+i1+1wfn6OMRWNqej1uvS7HW7evk3d1JycnVBVFkQoxz0+foF1njdee4OXp6c0Tc3DuiJLOnxw/JwqGZK88lV2jj9imC+oi9Cx5pFECKxTVAhsY3BNjQaqRmOtJBWeVCg8jtxDiaRRgjjWqKxPoWLmVjBvQrBH7EF4F14vGoY0GunRqkOd7GAO79G9c5vx/phUKtzkjPzxY8qHP0Yuz5B1hatrVFMhfYLGEVuLbjK89UgP0jSIusY3FdgC7Twykiih0PUaXS6J6yW+WVOXFpMLfA4ijYg19JygFhGV9CjbEKmYVGuc1Jikh5cRmgbZrIiq9S/orP1sbMYmCdHawCxsPD7eh96pygRGpqMU/TRmkdcYu1GLeIRwOK68WoGlEm3v2CZ+XbEJu6iqIFn23oWMhVbatg1VaBMRwyRWtlI+v/UYbZgtpTbSyRZYbgIbEGglsL4FXzaAjQ07d8XGXX3/qz628LobH15guK6YtKtuM7GV+HnvyRJFrDxZqjDGE2nRTs4dcRQFv/m151oTtoWSG5+XJ0tiokgHOaZSIVbfX3nLmiawT1qF6gFjg6IIceVvu5KpflLCuc5XFEWBtZ5O1gn/hieNY87Pzjg7e0k3hsP9fU4vpzgPnU4n7L92EVsn6qrHjbDvfRup6ESQ0PvNRtwcD4BUEUJJ8AYpPGmiydKYvKhYViaAaVSbABksHRvG03uPgXBvE0HxL4UISZpSsvE76k3/mg0LA77d11Jcfd4wZMt+ia0nLIBm3/rK2v0MCLUBzFw92P7cJH36zcM+eOc2xd/bCgN/1SsXqg2uM8z//49PJ63ReCbHT2hqw/HzD8nrgi984R5xssuT43OKKGbnwVvc/9KvsXPzVR49fMTHf/C3cMsJLy8vOdjrcf9zn+e1B1/kWKQsm5pYa6bzimdPPqayNW+8/hY3b+6jY4mIUkgHrOc5J5Mpb//pP8Of+nP/PtJqHn/4AUm9Q5TEIGBdVOj1GZ0oIV/PEFJz6+iI6aVmvVry2u0uWEddLLHW0O10OJ+vSXsD0v4+VBXLsxfE1iBsQrWoeXn+E24d7TOM7tLpdqltTlMUzE1ELeDGzojVYsapiigaj7cX3Oju8vjM8N2ffMzs9CXe1Xz+829xcfaCFyeXDDoJ+zd2uHH/HhqBf3nCslyTxAotBGeXM1aLNQoYZF0GnZQfvP+E49kELXrEccr+aIdeKkmzHlF/lzu37vPWV3vgGhbTCXjPy8cf4EWHrNOj2+nSSxuGylOWJYe9Hl4LZosFw06Et1A5i9eaLE7QUrA76DMc9LmYzjBNg8CTRBGdJEVL3V50PXEscVLgaouXYZLSNIbGhMLo5TpHKEEqBTiDihPSTh+Dpy5KnDVUtw55cZAx+/iEfjdDeoeaNSSdHoPhgJcX51A2FPMVk+EId+eAh/tD6izGCIUXFoqK11WPrz59xmp6RhpHxL0By8kFi2cfcetgByMVlY5CcXAzh9zS6e3S6XXx1tC40PVzOS+YLtYIBM6GzpTFuuDv/vbv05iIeV1wkGr+7b/y5xmOd/jbf+cfczxbMV8sKMucqq5QUhGpCLwP6ZhpSpQk1HWJ1po0SUiyFOMsXgi0jlBSkqYZeV7iCXHFxn6mDfpFjmz/BpEQeKmhyKmlQhhQFYEykRqhBAqPRqK9IxaCTDisEPTb2OjE1SSioasFNpYoHZOmEWlksN2MP/GFLxO99jrDnSHCWZr5ioup4pk/ougdYrxD1BUej4xivBIYQk7XVGT8Xu8WFyrlthAMFiXTes496SltjdEaazxzwo0uk13m3Td5PnibHx+8zklvDMJzFvf5R9nbfDVteP/pRyzygle++lW++NZbvHb/JnEiOX7yjCbqYpIYsAgakAmohLJa4bwnieOwCEFY/AziIo1zFucblPeEG6lCCZA6IoqDN0pFAcBZYzFVjjERKukhpSaSgtu3b9Lp9tg7uM1oOODm4QGDQY+bt2/Q7/ZYLBZIAVqG77q3O6LT64aJB5KyKAKjXRmKoiDPC0xjmS1mSBkkyB9/9BDwONNw/PKY2tSkOw/o7kCnyTmZnnCzXHNgKxIDayFJhWZtDKnzJD6EJAjlkQgsAqsiltqziGJsp0uSZViRsWosCzRd7+l7ifEC6xIK0cHqGJ+kJOkA2x0idvpE4yHd8ZBOHOOyKPQp1TPch5fBX2MMSyNYeE1fa7yS+HhEmeywTvcp4oy+mGKbFU3jWAnF3GhqZyFf081X+LKiWZcsC0+NJ4olFjCJYu01EwPGQuTAJRKrYpp0SCUTpIe6nJOsS1zz868ifzb+RQyxTZHbpPEF6VcAbWUtUKIhUpAmmmVe4Zz8BMjZPNe6a0l2XrasWiuVtH5bXC2DLnHLAoVJdwBYgf3ZzPM3/qpNaMiGUQvMhZThed5tPnd4nw3j5RwgQnCEEpvp+GZSvvnDbxeQA2tkPwG+aGWHwDVAGH5qKYi0QCtJmiSsTABOG2mebD1nYvMdgSQJQThKBqZQaoFSIiRCtvMmax2NDXUWprFtOEgAELHWRFrRGItpgaRSagserw/nXAvMLM4J1nmOFIKTk5fotmfuP/vP/3N+6Ytv8eor9/l7//Cf0BjPwcE+Nw4OWK1XpGnMv/dX/iIHewftNoLGCRobysXttnS7FWsKj2u7cV2bQ6BD9ON2mwZQ2noc2TBhHtn2wkE4ltxWZtmiKQSiDdXYMIUbBhghkGqTMLthcrm238TGMhn+/yZhdHsWcOWruwYGN0qx9ugLx7TYeMo2frIrb9kn8dfmF3d1PP2c41MBZy+fH1MUZ2RRxItnx2Te0esM6GQZ4tXPc+uLe+zudBnujdg5uIlTXc5fPua93/1vaeqCTrrP8vKS0kCcpCyMoW9h0E94/dXXeHJ8yvHZCeODMSoa4Wso8oblbMYX/7Vf56vf+ItQej589C4vnrzLTscSCjjDCduPE7KkQ5z2SNIk+IO8w0cxIkpIY40uFeVyClXM7iAi6fWpm4q6qVgXJRFQ5QuyXpcv3vocNkuZOoUkJev1uHvniIeXNUlTcTRImS09RTPjzZu3GHVTfvLwY56frKhWM1JVUeOJtWJnOMKuc7SGW7fu8+Zrv0wkI55lH1Dlc9arBbHu8PjlOd/86TPiJCPLYrwb8+J0RmNjCtUgmgrjKu7dfcCNw3t87vV73H9wD6WScOErD0DHzF+9zcn5nP27dzg/O0e5hm/+zj9DRJqv3d+lm6Ws1wVV46lrg48yvvvxKR9+/IjxKOXoYI+9/V0u5js8evKULM3oDgZESYSOg98s63SxrkF4iJKIsqzIi4p1XhDHEePRgOW6CBdb5xFJzGhnn1mes5wv0FLi7t3g5atjpidnaCcZHh6Spwtk2mU+meL6PbqJpFGg0oTZ2QVWQffeTepW7qABnaR89cUpg/UFUb/HzsFdapEwu5hiGphMlxgt8d0ORnvi0jHe6aFlSpJ0aLIKWQqE0qyrJlx8hAxmXMJF8PT0jDiKuH33NW7eOuT77z1lvvopZ7MVZxcXFHkedNbGYGhQShHFil5vh16vx3K1oiwKlFSMd8ZoFZHECVGU0hhLVRWhiFrKreF1IyH5bPyCRm+AFxorFV4qfNlgq+BpyJsGJzWNDEx1hWAtFQmOyjms99QIaiFCSWiUILMu6WCAxhLbGrkaMLxxiPzcl3E3DomloJoXnF9KnlSHLAaHVEqHLisf9P3SNKAymvZ1nZC8VBmzzg2Od77Kqw5uHf9TuuVJuMEZR4VhJi3SR6yGv8zD0Zf5YHSfD7tjjJTgLQXwIzNk1fs1vvZnX+OGmtKPII0Vj6oOJ6eSW+QcHii8kDgMXipE3AE7wNsQrS6cpxFh9VgqjbWOSKnAmokgKbGNBS3QQqFahk1IDYSKjqSN3kdIVJSye5AyHu9ycXZO01RY07BcLmhqy87ePoeHN0mTmCTOWC4KdoZDhm++QX+0R9rpsFwvw3leG/r9PlVVM7ns4b1gMAzJqlppLs7PWa2WPPz4IzrdLlXdkK+XLK3F7x7QDHZ5juab0wlJVXJTGkZ1we2moue7TJs1A29RVtGRDuctJY6pgJdSUqcJRWdEL+mjZMJCe9bxOd4ahjYiiyLqbMAyG9N0utjuiKgzhFijrSKra6q6RFPjqzVNVeCrIsihbY0TnkU2YCWHRDIi72TQP6Ts7JF3d2l0SiU0ucmJ8yl5mTNRkrw22OUlUT6hadaUxjKrPUsnQ+G1asikYu0FcycwCJKkGxI5RYcy7lKpFFOuoBLEvUOa/LMo/V/kuJosbjmArVRQSolxDuUDe1XpkGAoxdX9bgPOtoXMbiNta9Mct/6bVh7WyhSl3MgLW3Zl03UlXAgCaUumN4972JZGb8CHb5mxKBZooVuPHG3oiMe2ni5jQqF0SBi8KogWApRWJFFEWdXbbfGJwBBvt6Ds6vEWBIjAUGkVJvDBimCI4xCFHyLxWx9dG3YRxxHee6oqhHgppQL53TI5QrW+Nu+2oNUYGyb7G7Dh/XZ7CCGI2vcBQW2aT+zfzbYyW1+62CDbkL4qPXGiyfOSP/juD/iD7/4Aax3Gei4nM370k/dRWnP31gGnL5/y4P69cG12DapxRI2j9FBuag+8x2NwToZuMaHwwiCkwuCp8JQlKFm2TOImiKX1iPk2cfFaN+XGr7XZBz/7U7QHw4bBArEF/tsezuvHvN9siSvJ4+a1Nq+xkTtuglCkuDo2uAbEtj2BG2bs2v/ZHPeb4807j7eeyWTyzz0vf3Z8KuDs7PH7NCLn1p17zPOCk2XOpH7G3u6YnZt32Rn22Dt6HSctlxenNKZhZ28PqRXDVCHxlEXDrHjGvdufx/mIWDlG4x0m7pLxsI9OI6yPeP70CaJecXl+Se1qXj16hZMnj7g8eUqnM+C1B19iOfswJPA1DWkS0Uv2w6pG1scpzZPTY+LuPp1xH+sscRKTmj0sj1mU5yzyNUm+JNIxRWlpqoL5ekk3zvDNCltqnNxnsH+T0fgWk/MXONnQVyv29ocMhh3SGcwvL+mkmuWy4OmLY2arBQ/u3uKV+59jcnnOy8vHDDo97t/Z53I256Of/hCaOePdfSaXM7y11MWK3Rt9huNddndm7IzG3Du6xaOTc2SsGSQxWTfl5v4BrmyIBzv88jfe5m7fI90lQnbwsoPoKJyM2D3cY3d/D4Sgrgqkqfn1X3mDiw9+xK2kJhIK4wWdz/9ZivkC1pf8O/uv8X/5P/wfuTh5wd7ubkggbEoOd0eM+31GvT6xlriqYlnmpJ2MpNvFeRG6vIoKpKKbxgwHfdZ1zWy2xFtLrBS9wYDaGtarJVqEVamyn8Coh86XxJMMtyoYZh2m8xU7e3vMyjWlN6R7e/THOzSDlLppqM8m2Bu7VC9Ooba8dnSPw2nOwc4+OopIU09+/pjIFPQGXc5nM2arJfdv3qTXj+kMj0g7Y4rVBR0dMdw95MXxM/KiYjJfcjFZUFWhGNuLtgzd1vhIUVUlF2eX5OsgcSpNxXK9oMzzbXpUkAzEDPtj0l6P9WrNfD7HO0deVjjn2N3dD/IM63DWUJQF1jiaxmKNQSiF+ZkL8mfjX+5YArlSFDqk9RmlqKWnkoK5kpREOBI8BZX3XDhNKR2NlwjXMHeeiVZkSUYdpZg4IUpipDcQp0Q3X6O7/zr1zRuYRFOtG57ONT8oh3zYPWCtVGDLvMAKQVI27FaXuDhlMrpBpcIqn3RQSc2TwSFSfJUD09B9+Q/oFxdoaUhcghWaR+Mv8/u7X+ej8X0maR+zbQQVSFOTLU6oqPm7g1v47FXSsqERsLYKhOHPxBP6ckXqm3CzbjX5SqeIuIewOc41COcwCJQ3aB1jmhodgfMGpXRr5NZs+m0aSnqdPslgiGqT1sqioNPtb+smbt3Y49bRPsZYyrKmbhrW+YaJjhF44kRxeLiL4DWiOMY4wXy5JC8KvHeMxmO8Cx7Qg4N9nGvwzhBFGY8fP+L09IxnTx9SNxUvPnpOr9tHy4hVUXAxOWdnvE8ap6g44TIvWChN1N3hA295xTTcLzSjak1qPaoNBvBesWoqHsaCWmlM2mfQGSJkzKKxLGTEDoJ9AWmUUnVGrHq7rPpjqsGYuNPBSglNQnV2STM/ZWAL9OQl5cUEcfqSxjqWVlDIDmfdfRbJISAx3R6d/h6+t8Oit4tTCiElTbVC6znL6imXbsZFXbNcXlCsl/Rtg0awtIIX3mONpixg4ByNhgvp8N0eg4N9prpDLQiLBb0xhXPIuEJlHVQy/AWeuZ8NuJp0XlOkAVcTe+sczkNZN2gp2Ma584cB2ub1No87CLLCVuKmdQvK2veQMgQ5GGPRSrW5EaK9P7aghTChDmzYFYu2eY+mdigFUSSIoo2MEooypBuK1u/mnccJtuxcJBVZmjLoZlR1TVFWGOta4HTFpgGtzPHKxxTpULvhMdekbcHTZFqf2QZ0br1PflOi3YaayA0D18oGlaIyDZJNB9l1+WXLNIkr8GxMqAeIogitQo9c8AGG19wEpchr4BLvAn/jN91jwS9W1TWpCNthA2ecE63H0DOZzhnsHOLQOG/wXqKEQyiJdKHv1iER0l/1iLkWVAqJ8xbrN2EgoUpAcO27bYM7XOvvaqWBomXLNjUEPwO1rvv/8C031R4AIhjCAlBq2eAtK9yCpyDa3LBvEusJjwTy74pdvXauOOeuAa8Na+a3MtgtqLz2u/ee5XLNT997j3d/8C7/8X/8P//nnJWfHJ8KOBOipN+P2Nu7TRKdc16e0hcxo909dodjdHFOme/hXUxp5+zv3SZNBnSzlN0kQUtJd/8AG4+pqnMG2YAki0iSlEcff4ivcwZ7t1hPLyhmEyIlsLbi8PUvMZvlLIsPePvt30CrlNNyFRKFvKA2VWDN+gnOK3TSQ0Ywjl9FOkWadqnKgqoqWK8LnNV0umMql1KsFszmK2aTE3a6PVwT0d8dk2Y9ivySrjhnrPbZ6RouXqw4fnqMN0suqiWrVYcvvPEG0e27fOcHP+T4ZMJed8zN8Yhbd2/Q7UmEz+h0bxNlXaQx6FhT5wW2rCjWltl0yqCjubM/4GinxzNXcXP/Bv1uRI3k+HLCQbfHzf1dSunpRIqz6YzZy6fE6zPEziHgoMmhKWGj65URXkZ4lZAmCnTM4d4+B9nbrB//FLu4IOkfoHtjuv19Jv/4HV4+fMrybEKv2ydfTJlO55BljHpdukmCMw2N8VTrFaYuwQ6IkpjVqgjnUFvmqGyNrGsSDwfDAbapUUlM2u3z4vycNI5xrgl9YLLDbF4yWRfk1ZLlck5vd4RJgpbauZp41CO5tU+1myHiGCliKq3odjqsjGGoIoa/+2Om4x1u7x2RdUNBeiQVo90ekU5ZNyV5scaaGu0SdFURq/Pga1Ga1WrNqlkzWUyZzpcUTQ3eB7DvPIULBlVlGooqRyhJUZcURcFyuaYqcqwNF7ZgrA0rX7PZnLgsg3fNgxAS6yx5WWDPztnZ2SGKI+q6oq4qtIoDo6glxgWZ1WfjFzeq9RSTdBBNRbRaolY5rhGklaBrBJGESkED5EJy5iWpCxJHhObYW574hFh3GKmMVMeIOME5jRrsIG8fUvVvYjodqsrxeCX4fr7DT+Ix8zhBmyrcWLRDGcPe5WO+evljdJTy49tf58nBXSoRY4XCC0/t4Vlnh73xl7lX5uwWfx9XXmLiDqfjL/Ht8df50c6rzNNee3N1SA+JLfnc5DlfOf0eh81LTkdf5p2jr3DSHaAI6VkGyUKFRZ2teEh4hBdIHSN9F9EIjFnhrG1Xtj1IR5z1wBliHaNkhBAha0sqRRQnJFkfZwzVbEaUxCTdDodHh3ghsaZBESFx6EijowipJKLcdNcEdYJ1ljjS7O6M6HQS8LAuSpaLOTiHaSxxK7lM04Tp9AfEScJ6vSJLM45fPufly5ecnZ+xXIYOsYuLM0ajHYRQTC4uKfOCrNcjkppOmjKdTdBaUyjNpdJ8JxpyR6V8RUi+5DxdWyGw7CnBTec4cRZnaxpoV+9DxYZrJxMq6SHSIUKnEKWQdHBKU+qY2gj8yQw/eUZ9+j7d00e4eIDOOhQpLIRiIhMexQPy/i6N7lEmPQbdMbLTZ9bbw2pJJSRJ3kfEA5Yy5WmZ83Fe0l033CsdQweJcJw5xfsILoTnhhOMhccL+FDE9PduMz64idIZVdMghGLR6TKdz9klppEK1e39As/cz0aQZ7VecLfp2rpijza/qzYMrG4DsIJ68Kq8+mef84depwVJG6ZEytAJJgkTd79NvgvXjSiK8C1rIlrAcV0Odv21A3BzKK1ojG/DHQRKgbMb5s3jZPAFQUhgjCKNVpKyrlEi9KjWTUPTGIwJE/AQwhF8YZvo/jDJD8BLK0WkBRJPbS1FaRAiJFsrJYiFbmsDgpfNt8XEovVEOWFDkIYHS9s5R4suce32CN8n+OY2yZGCxphW6mlxLRpMkzj0yHkf/OxsmMpNbUCAIiEcReOcoyxLIEXKBmPNFeAR0BiPkI5VXvM73/oeg/ERvU6Kcx7jCKExztPYVoLoWojl25h5PJ4AzGglmWwA0HWw5YN3bAPCwmNXBrAr9Wn49y3bRhuiBtvXuu4pbLHZNZlhSJrcKCQ3x527fky1ryZa1VXoNxMh9n97ALbMLaL1WwZJZ/jp2qyEsOCR5wU//tFPeffd7zOZTtq6pJ9vfCrg7NaDL+F8zmo9J1YFBwPJ5x4ccu/Oq6hYIdYLTj76EcvCsbZrprdeZfJyjvDQ7WSgFKaqKYoJXTmlt7uH7uwwnb5kd9ihe9BFd4acnp2RpTFCaLJOjC1qHj3/Dns7Q9579x0m81PqxYSjW2PKokBEA4xzSG+JoxQXdTm4+YDlyvD4x7/N0oZV1rxYU6xnuDKnP9hl2BlDU1KIisEwZdjvMxz3iNMMtGbQ3ydKYpqyYDk9J19NiERObzji0YuXmPNjHuzvMl8XXMwKnE6wqaE72GGxXOIpibMOXkYIX9ONNQd3j3CuYVWXlNWMWCtu7O2wM8iYzZfMljXDccZOP2O+KohlxuPJlLPJhOGoz51bR/R6HayKePbRh+x3BdFojF+cIVwDcQ+nopCkIzVeK4Lx1iCiHqLTIb3zGvWjCt/MKL//32GTPo4l3/2Dn2IwuLJCNhVVVZF2ukhjoaoZZB2UllyisU6iVEyxzsnXK9ZlTdTtUK3WUBfYouLg6Ab9LGXlYby3j9Mx+xgsitnFlGF3h9e/8Gu89WCf/+K7f4fZ+YQvvPI6777/Q7IsReOZlTlJk1DZhlQq4mEPXzdI76EoOHj1ATe++YjsbM4JMW94wY6EuqnxODppB9cYumlCdvsmSRLhnWAxOcPXa/b2DnFFQbEsyGcLqroBIdFaI5RChcxsrHPBn2IsdR2CYDzBw7dZ6RLtzSeOIuIoxjpLWVcgBDrSRDoEgSQuaU3RNiReJhF1U1MUBVpboighimJc3WwvTp+NX8xozp9i0g7KOtI8h2WObxQdn3LgNIkp8KKmFpYBkpGq2fWOnrcYwGsByrFDSexKcDXeNpRKovfvQO8G66RDbRzPl4LvrHb4nt6hSmKEc6AVyhp8XRNNnpOdfo/Ds+8ySmKUNCA9Tw/uk6sg6bFOkJPwXu+I8e5XUMYyvvh95oPP8ePdf40P9l9n1uliUETOggNpS169fMGvnH6bty7/Gak94Xb+nGGV89u3f5kngwO8sGgPxgtc+GYIJRFtD6hWCu81UqQYk+NQWK+IorhNFVPoJA1pr2mKkBopJVEUwJqOknCeaIWKEkxtWc2npGkCwLqcUmuNjrsh+VFoJJIojoiSKFSBNAZVS2xkiJMYZx21saHSwjlGOyO63R7WGJRS3H/wKsfHx1RV2fpIFB999BHL1Yo8XyNlmOSdnR0TxQnWWxbLOXmRk8Sb7yVYr1bbSZKUiqn3/EhYdmLN270+X9WefbfiplmRFSWdypKacOuvPYw1RFKiRfAi9gDf5KR1TFJ3EBaElkg08WKBPL/AvzzDX06ROykkWZBX4YllTDdOaZIMmwwgSnFSI72hYwpmOqUg+CyUbdCmIWvmNKbgzDv6ShMJi/CCWIYFh5de0reOtDGoyOGimGq4y8JosjQskq3zgg9On3JxseCujDjUmhjx/+vU+mz8Cx6fkGLh20JfPrFXrjNr28h9L649b8MoBCZswxQBnwBrGwmYjhSIECpWW4ezLXDxYca8YXqCX2wTBHLFPgVPGy0zF+Rw6tpk3Gxj6oMEcSM720zegxcMIi2xxuCkoHbuqjOL4AW1NoAP7zxKC3TUfjm/Ye5se/6rAN6MResAXKWWW+nklvHyDuECC2fbe7bzMkgOtcI3brvtQqmzb7FIKxn1HmdBChsWbbiS94VS76A0iCKNMU0AX9ZtO+WUbgPsZXi9xgaWTwowjaGSDaY22+2vlGolltDUDY+eHfP73/k+X/7Sl0iTmHZ3bdk1az2m9fo5Wh9gy4UJALmpNrh2gG163sLe3u5ngQo3jQ2qajvs8C3LttFAApsi6evjSnL4ycfCNg/bg5ah3LJeWwliCHfztJ1rEhwW1wLCQEBuJJctKPMB+Dt/xao1TcPjR0/4wQ9+wGRyyXwxR0rHYPDzqwU+HVnj5CT4p/Yy7t2/h6lCHHmcRGRpSr2aMH/yAY9fzjidXdLv/C5V3nC7D93eA6yImUxPmS7XZId9lssTunrIYj6lmzhGowOKWuCtpWka4sghfM3F8w84O59wOZui/ENiLehFYM0QJQRJklIt55y+OAmrrN09Vuspk+mCj3/0PbSpKaqSKPJ0koxivUToiMG4R6eriOKbLMoVRli08ZRNjTMNWSapTM3ixQVV3bAz7NJVd8DX9Lp3yJKIfDVhvSi4vdsh6fYZjW5Qm5K6mjHoJgwGY+aLC5brJfFohyTtMltMkVFExztMWZLnS7S0nJ5MEHGHV28dIZ3lg0c/ZpWvMNYw9YKeFdTrnKQ/JBscMGsUpQExuQRjUHaNaGqIUry1iDhDmAh8iXTgdQ06QXdTxNFNVh/9BJ1YVqcPOTu75NHTlxSiQ7maozwIpfG1obSQ9lIsGo1EWBjFKTudLlZpZvMVQsB6uaRazunGijTSeFMxGmQUVcEwquj3I/bfeouHJzPOOin/+r/+l/kf/Ht/jfeLBf/g2Q8QN+fUhAQkXzWUNGilkWmCKA3lco1OE1SWUJ5O0NNLPrewlD/8kCbSVA5m84pB6inzFRKD0I61caS9Ph2lAIOzOdZaFqsltamRUrOuHaY2OONoygpbWwQKpcIJ7UW4SNZ1RWPqtrAyXJicDyuO3U631Z2HMk6lI5RW9Pv9ABa9J0mSEDecSHQUYYzh4uKcpq5D9weBrpdbvflngSC/yDH+4m9gtEBhieoaP18Sr0uiwpLmJfF8hlh08U1F3ghKJEMsXRpqYOw1r6cZw70+g50xcb9PlCbkUZeqs49Je1QezteGH65TfmB75DrdejQUkpFvGJsTVPkx4+YRTT/BazgyD2kWfepBymn3DrmQbJQf0yjhmzv3yEXMnfED6mjAj/de5yzt4VEo75DeE7maB7OX/Nr593lr8k3S1cdY7xnn7/JmWbO2FnP3Gxz3dxFeoL1AuPac8B6cR2mFFh6vFM4YpLNYD1IolI7wPkwotI4RKiFKMvrDPaRUNHWF1kE2HMUpWqc4b3CmIV+smV8UpFlK0h0idYcoTkDqdhJnSNOUtNNHIKh9jnYRSoSes7KukVJR1w2LxZy9wyOiWKO1YL3OOTw8QAjJcjmnKHJGozFKR5RFgW0MxhPYvLpCyBwdBY9oWRQ0Teh2C/09FtMEAOrxKCkQQnHaNPyDouGfaMnNTocv9XvcoiGpHV1j0MqHa1Pl6AhFN1ZEGqS0aCr6zRy1bKikRKmUzHuyxRnZekJaLomcwWIR3hIby8A0dAVIb5i5mqRZ0zclWZ2j64i0ydFpB1EWdNaXqPIMX12Q1jMS71mmnhtWMjYRHe+xwpOisB52hafrIXIlcQKVM3RtTVY0xKbELhfIDz9A6wzZ6YZ02j/kCPls/Msc15RfQCvm28jSrrNn0AKKIBHUSm2DKH4WpG2AwyffR27BmbOh50pp2crKbJDJSbWdoIfXvpK9bb1em0/TApaQGOm22rMNFnRuI+sL9+AQ7tACA+/RWmOMpSF4w4QIEj4hBXGig2+tdlcBF94h2vTJzRspJVFSEGmCQkuAjoIHfZM7opVqwVHYppuYdfBt0MQmwY9W9ucRWm5VNErJ7SkiVUgiNPaTpd/GBEBljCeKLGkSUQmPMS4k3vor8CsVxEmMRFCvirBgJoLX7fDggMuLywA6rMU7EySIXmBNw3e/+32m0xndXp8H9+8HD6BvgYmzV5I+twHDsv0JXoiwgBRecXtMce1vwottYqOQmyAZv1UMCLap+YFY8J8EaBswHIDXFSt2fWz9YG01wyZ45grAh+e5FmAJ5zBiw9xdlVJ770Jvn78CaZuPZI3jyZNnfOc732G1mqM1JKliLxq1QPLnX5D6VMDZenbBaV2S9lJoap49/Snr9SFepYx39pCNwzY108tzZos11lqGKmKv32U03KV0CeeXC+qmxtgGV5cU+RlJ3EeQUzWWpm7oJMHD0U/6LJcxPz55RGEFMl9ze7wLSJZlQdFYEh0hEERaEqmEfjKgXC+5fPh9zi8LZhdzXrx8SH844tbBiEW+oikMcjbFGUFZzrEOLCZoamVE7S3rYslibejphNoazKhg3O8T+Yq90R2W+ZJ8taQxgsPDDp0k5eLihOnxJTrrM9zZo7sTzOg2STH9NY3KWJqGWkYkcRftLGmnYTRMcV5yuSwZDRR1tWIxX7Df6+EMdDIbvFqmYlo2pH5FM1nw8jjBOMODgx79NCZRhl4mie0aX65RUQeSHsKVQSJj14hqBnODdo4oUbhGEGcDzPojJB7rDHkZmCmhPWkmGO6OSeOU0kvmqypIJbOEihTtHd1IoVSEWdXc2B2zXCwwxjO5nLK/O+CNtw5YrHPm58fM6hUP9vZ4/cHX+Y0//5voWKMrxSs3bnPx5EMubUMaxUwXE4glqpMRjQZwuUINutSLFeb5OePLglsfn7HTH3NiDE6HieHlNGfcDx0sUkDVGIwzxIJQkqEiHDDo9xE01KbmcrGgMiAcDOOUSEnWZdmeZ60OXkgQQWogfLgpyFaCoLUizRKc9azzHGMsSZKGmhLhWa+WNCYkQVZlAJ9RFBEnMZeTCUVeBLlHnLQ0v8C2F+U/6mb42fiXNz7/l/4nn5BnCBsm5LZpMHmOX8wRJy/g+Cn++AVcnKHXBco04KGWEpv1UPuHiJs38UdH1GmHD4sls8ZipWC5Mjxcp/y0GLFS3fZmJUmk5us3Iv6tz+1zP7uDNF/Eur9M7AzKh8lGKSKmesAPZ4q/9VHB01WIsRZeMIkT3tm7zcf2iDrJOI5TjFBYEcz/e6nnL+0pvnwv4db5kO7pa6xOY5jPGK5zjsw5O7NvczPN+LvqbR51uoTaebazvo1kysnABFd1MINLHSN0YKnjOMbaiqpak2Y9tO7gEQzGezR1Q12t0TpugY4JrLGWxEmMjvYQUqHjhChOME1D3fpHkrRLmgQgK6VAxwneWYyzCLmRZcE6L5jO52it6HW7QJjslGXB3t4OSRxSVaMo4rVXX+H8/JSyDX1pbJCH2caAB1M3xHFC09Tbm3FYKBfbSbC1HrxpfREWi+PhzPA417yyO+I3swO62QiZxsg4ptnbIUISyQQ13kHujdCjEU6CpEZ7aKIQJqCjEh2vUb4APMKrEM5gPNrUZDrBJH1EOgLdp2cKes0cVddEZUYTd2iqNdHsmP7yhMQs6dKEkmotGTrBoYWed+Teh94mrxgrQd97tDSMlSNvcrqxZmAhrXPWF8+5d/mccWfM0JXsNZrIfCbJ/kUOJQROEhZQ1CbAovVDt/KwT7Bj3rehHu0k119Jya4myp/0hm2fuy3iDaDHGIuOQuhHYNLYJuV5fxVXvvksYQikCIBmI7/bJCJuXvfK0y2vES9+uyglWnmftWGCHuLhg29KaUESq1AYDWx60qwV1yb/tN4vh7M+BBm1RdxaSTbx8kKIENpB69tzG4An20l+SHreSuu8Q0mFMQbbAlhxLd2SLS6UW8li2Ge2Pe+DTHMz3/Ae4jhBCk8nyxj2u+wO+6EDMktZVw3LPGexzDk+P+fs9CV10wCCKIqIopi6rnDe0ViDdY75fMnf/m/+O45uHvH1r32Nu3fubCsCgk+MK2aJFohcYy2938CbzbXQb+dQ14Gbc21ttNj8/3BQCHzotGv/fg2+B6DoHNe73/4oKax3bMHX1eNcvZrYLFaEhM/NfWwjxdxoIjex+I5NdL7g/PyCb7/zHV68eE6kQSmwxlNXDUqHeVrTGH7e8amAs+54j7qMWdge+zHsdTXaFWjlSbKEouqg+kckuwbvZlyWgsbNKP0AVEQiHKvlipPLKUf7Gb00pbEVUqcIeYP57JTVqmQxn3JjfxBioucrZnMDUUoSKVZlifSKWDt0HNK5GmfIkoRB3GM83MUslzxafAjVnKOdHqtZSidLiXWHs8k5ojEUVcHk4hwvPDrp0hv0cVJglKSoFgjbEEcRRVVjnWY2m5BIz42dHbSC+apktcjxzpJlGWlsieOIVW1woiFvCkRdUzhPlnTopzHLfMGiLKgbi6hXofPLO7SOeXE5RXUzRqM+Z5dzTs6mjAcZR3sjTqZzqibI7LJOn5PzU4qmZtwb8Q9/5x0S7XnrtVfoZwmJlkQCBh1Jr7NCqQm2qUlSzTADnXTI0iBpklqSvvprpMmY9OljlDxDOUkvCRHNKumyOxyitCRJNHfeehMhNU1eki+WOOPJVwvipItrclxTs7YVznvW65KDo30e3L7J176wz3x6yfQsxD13BjG7d2Oasw+pBkNe6fT5n/3qn+c/uTjhe9/9PVzkiA938NrDYEB2+ybT9x+Rrmv65yXjlzOyszmdNAQFSNVKnKSgMhZJws6gy/nFixAV2+3Q0QpvFfPFKqzMeYvE4wxI64kIhYeXVcWj43PK2rYgDMy218LincAJi5AOTCD1GyOpqirIvIQgiWOcbQj+s4jGNyGitl3JCSt7hvV6TVHkOCeCjLIVX3tBYNKkQn0qZ+5n4487VD/IFK5PZBQQbYTp1sLnvgB5hV8tELMJ/vIczk/g8oJovQpsaG+AH+xCGq6FpB5BSZk3PFvCu+uMieyhtMLi0dLx9dsx/4tv3OKtg4xIbu7f13T7bG8n/HLjebA34z/9vRNeLBSbfpmllqxihW+7qDwS5T03evA3vrzDb93rMYjuYuavouVfxq5XuMkl0dkx4uSY1ycTvlou+Ub1iP+bOKKOPVoJlIpwPiS1CudwtsZbA0KDSlEydJkJJF4KpNc401CWOYPxPuBYzuf0hwOk6LQMmoZW8qN1TKw1Ok6DDDLSQVoVpcTeB22/1CgdIVUMInwGKQIjHZLkDHlRoLUmjlPq2tDr9SjLmixLaZoaKSU6jkMoSW1QKqbT6bFeF3jXbE36XJMuV1XVprg6pFBIITHehuRa2qS1lrYw1gTppwBTGD56ec5FXvD1t97iL/2Fv8hXvvoVtAddOxIBSkUIHeOVDgeatzjvqWWExUFZUL94wez3/xnlP/3HQJgoNVgMGnSfNO5T93eo0wGmXOKWDSovEOU5skgobY5cHdMpZiAqokTSIaaWoKxFO4Fwjth4tIiovce5mkhYkk4Hl6TUWKQI3UY6n6IvXpA5Q1OtSJUjM5puvfqXc5J+Nv7IEccRGAEts7sBNBtAdN2HE4BMG4HvrybNfxSI2/z+ide4hmw2vze1JU5062kL/+acDayadW24BdvutMZsFn42E/7A1FlrES7EqPuNPE4KvA1Hv2rPtY0MOTBucMXKBdZLahdAhRUY6zFNsy3QFlIglMQ0ZlsqLBCUHmTSgopW7ri5f2/X7LxDKYE1dutbszYsEKm2w1G1CZYbf50gsF/OtwXMQiJUALWb7R5+SqQEJSFSessECSG4sTPk/s19EgmvHo3w1oZ0bFdzs5dRjlJkdINZeZ/3Hj/h5GzCugi5BHESY32QPnoviHXEcrGkKmtevHiBs4ad3XFYZPZiu682OygkNwbWUXpaX9e1/9KiIL+9Q10pjUAEGaGQIK6BbO9BtMxhe1y2xOg1BviKCr4CZxsAFpi+TwKzq3/bHqFbb9v2KN+eA963lQ+49rUk09mMd7//PZ48fgRYkjjsc9N4qrqi1bUi4I9VffSpTPF2BvvkZsnp6YTBvuHuvZsUpWO4s8P+3m1mjcbVP6UTx+yPRvzk4w8xsmZt91FYTGM4v1ywXteY2lLWBbXUzBZr+t0+1ktOTy/44ONHPBplvP3FLxFFHY6GQy5nS4pVTTPuEcca4wUqTrHO4tF4IZmcz7l4+gRpPC9OTzm+nHFj/4Avf+5V1uslsa/Y7yRIkYAS2DqsjPb7XcZHr+CKGZPJOatpQVM33Ll9SGeUYUzN4f6QXpxwdjHFqxW1FYgkmKEjqTk7OyfRIfa5lJq6NrBegxTUVU4qPV2pqZwgL3KiboZEUBVLqlLjdMOdmztoIfEryY39Q5AN/U6fTtrh/PIS4z0xBbd3+ngVEwvBfDZntl5yfvGC9NYd5oua87MpuEB3l0WBMjVaSFLZ0M1Sbh0NONgb0u0MOLjTJz+b8/DjF5xcLKh7EZ044vhixmC/x/l0wflkyt5On6oqiOKM2/fucHT7iKooMd2UsxcVRZNzOVnw4M4eRdGwf3OfrpB8/ZfuM0pKFk8X9GPJcLzD7sEY05yTP/4W69EdiqjLu+98m1We01yuUFpxcP8+MxrU0T5Hd+/TKTVHH5/RvZixXi6gNeziIclSIilQtBdXPN7ZED0b7dEfHKKbGbVdk8QarVOEdFRlTWU8yAxFzWyx4vhiyovzVZBuERKIvPNtqqIJF8v2BiaFJEmScBMUgiRJSJM0SB/rpi16DEbpqipRKhQ9rtdLqqrBOAseojgKCXU+rKIZ0+DxNHWFUvGncep+Nv7YY3Oh/9nHW2O3FqAjfBJDJ8b3+zDehYMbiPkCP73EzydQl2BrMIa1VOTWU9eOlyvHu8sez20fhCR2lkZpXu06/vprA97ay0h0K9+5/t6f+Junlwh+8/6Y+TLnf//dBaelx3uBEBq7uWspT6QEfdXwP3qjw7/5Wp9xKmlqy2w9pZdoop5Cd8aIm33W69tk2YC4bjj6+Dn/7skl323CwoZoi2Wt92EF1AnSqIPWETiLtw3OW9K0Q6e/y3j/iNHuHp1elySLwRuMsSwvJzT1MtwcbRvYkcRIrUmiBJ2lIdzIg7A1tiypy+DjTPsZUmm2d3HAGYuMJM566sayWq2wxrC/d4COFLPZjF6v105SFXVd0+10OT4+xjrDarUkzTKiSGFNuAaIbSHvZjIawkWk8FhC+mS42bcTTnstrpsQaCCVQnhBaRrOJw1/71vf5ve//yP+9a99jf/gP/zrfO3Xfh0dJ9sFmo1IaLOXN74hvMM+eMDk4IAPVjnlj3+C9bBAsJYJie6SRT1s0qEejJFZh7VUSOuw6zlrVsyEYtXkGFfSF6GzslQwF+E+OjWCyjmcshQoJkrjrEZJx3h4AEmP0nnKqsDVJfn5SyhKVBTj0i5N1AEt29TNz8YvbPggvQtFvpKmMZ+YCG8YqGsz322f1IYNC4uGYaLtNv+n9VR9IimQjTdq81hgH4x1V7I1GeSFvg1WQLRl0+1rNY3ZKhVhE7G+KYT2W7nZhhHzvg1zUJv4fr+VZTZtn1Zg8ETwiSHCOS1bb5oK4SWCsKhqarPZOFuWSuk26MO2tTZCUNdNu32arYdMa3UVud/YzSmMd4HB1EK3DJ9okyVbj177PKVkAKc+MO9hMwb2HqmgBamNtWip+drnH/Bgf8yHj5/zbF2yuDjn3l6XQTdjkhukUDRFSa8XsZcM+fqbr3O8P+XDJ8ecz+asVqvAULKRXlqWqwVZ2sHYhm9+61t89PHHfP3rX+dLX/gynuCn8psDa7uTW4DNlWwxgLLr4Og6NApDbMDZ9uigxThhH/oNCBNb8m37luGnuwJp7R/e/6zPcvMR2+MT0fau+U98GtEGrgi/8awFGWSe5/z0Jz/l/Q9+gmkKtArP3wBo8NsuO2vcNdb05xufCjiz9Ry5ntFPFb5WNL4miVJcWfH44x8xO33B9HLGe49eMMg6HA66DNMe3VgxW66YTBZczKbUANLS73Sp6HNy8hTTrBkMb1NUHzMrPZOZJ3l8hjcVt8dDVNPwoljTFBWmsox2OqRJCoSbbFXUnD17xvGzx3Q7MQ/uvoLuDanyBWm3hzMF3lTsjbttkk2gviuZslquOX32IZnWNHWDrQXLteFiueBeL2V3OGS3v8vp2SkXkzm7e/tkSRwmCONdqqpmtpyim5qmgUoICrfALeYc7h8gXYfl5VMUgsvZAhcllEIxvZzjqxKlV4z3Rox3jng+OWUlakbdjGF/j2WxZk3OeJghooxKZqSmQlpDma/Z3+1y//YuvUyyP+iw6nQRIkInGSLq8PT5YxbrJf1IUi095+crnpzN6MeaRCek3z5mdnbKyekJH05runbFOBbU1vL4xQsOOj3ee/Sc+KTDb46GiHzNfD5lvSq4ebDH3Tu3SZKYclLSy2L2xiMeLl4wvTjn7S/fR+dnlIs1g7QhSrpk4yGZkkwmp6hoyfm7f5sX6oDf/f/8V4zfusnuW2/SNBXx7i53VcLw8YSdd7/De9/9MaNbN5CxpBCCJIqo6gprDFprep0ODsgSTUzDcrkEp+gmCuolZbmiNg3eW2xTE0WwMxqD7pBbR5PPeXlyyQdPjinanpJwxiqkDIZVr3RLmQepk9aaXr9PlqZt6WKQUsokpt/rYa2lLEvqug4rhkpvHwOJFBqlJVJpxPYmFG4oYXVT8kcZYj8b//LGfPqSTcLWJvAllLC2/gMInoe25wRjEDbEzAvhcNIgbI1czXBCMm9qPh4MWQjFxbLm/XnCx9WQJk5RBNAzsCVfo+K2jVH1AKtUewsTV8YLsbE1X/1Itecb+wk/3ff8rWNB4RROCPxmddJ6ImH4xgh+bSjo6TDhWcwviSODiiCOJbbIQViiqKZxK3QnY+drD4gXS47WBUXVcHwxZbpy7QRcoqMYHWnwCltVCCno9Hf43Nu/ymh3v62WMGFyIhx4R5RUpOkh0zPB5cunRJHGuzBBS5MEqQS+rkEZUBovNFHaRekEITUqzkDIEIffej8sV8u4+bqgrg1CRQx7YZFtPl/QNA11XWOtIYoStFZMJpcURUVe5AjhtgEfG3O/0hJrr/qEpLA4D4LW9L81sXuct2Fv+eBDCxIns52kOCtobMnElvzXv/s7/M4Pvsf/8N//t/mf/kd/g8Fw9IegN9BOWASgkL0eg8Mjug8ekL/3ASWelW8TZVtm1DjPUijqJEN2h4iixMTnrMqKZ4knSlOapkder9EOLp3mYx0zVJa1cQxwCCd5hOKpirkbJ9DPcIM9hNZcRl0q5ymqArGuSH1MnSUs+geQJhRKoX/+ecpn49McPnifpIJYRySRoqoNdWO24SB/iIX3VxNXeU1CiAjJedfT8jaT4z+KWdsmMVqHwZNEEVJBIvW2N8o5F8I2WsCWZiFEaxNtr9ppq3MbqRkIFdISnXMB+LVMoFThc8VRWMhB+AC2ZJiKW9vG+fsgRTPWIJUkTjTCh2vYpnstvOcmwCO4Iay1bdy/2AYBCRF8aZsJuxIbZjKkVMpN8AVtV1ort4ti3W5nsZVkX/XPiW3wyhbcWIcRBhFFaBXxS2/c4ut3x5xN1nzuzg0uVgW9JOJ8mXNRlXSVQOdL8nXN6UXNjXGOHu1xb7fP/vANfvTRY04mC5br/FocPNS1wZg1QjjqpmE6n/Pk2VO++93vcvfuHf7cn/vvkcTZHzpuYMOecgVKN0zW9ri6CgdhswDQsqCht2wTKBJCODagzLlr8sZPyBivfm4Wrq4DsesAbcP6+Zbt88K3zjXxiedumNaqqnj08SPe++kPWa8W7b70ofLKBOAt22N8w5RtZb1/jAC3TwWcnbx8gtcRnfgGz549ZJE27O8f0CtLXFmRn5/QFBXrdc3p+SVvvXIXjWM2XzAcDUi6KYd7O5xOLhn2hiRpB2FrdsZDTs8ucHJC0h3RHy4Q3V0aF3ExOyeLYnq9lNfSmyEetCkY9lKkDh0QFkltDd4ZUiSxhzhSHI0PePY4Z7FcoXxCbi07+zdJlOZsconvDhFWUC1XjNMeiQ5sjBCS3rDLcO+QuNPBNzkffPAe6/UKIVNOLyf0BwPiTkYnSenpmNujX6KpC3760YdMLy/AC2wvpUnm+Kyk2xtQLCZkvmLv6CaTacXp6Tmd3oieSxh1R1gncErTG43o6h6V9WTDO+ioQzM7w+NJlKGsDbWt6Y9HCCdomhVpd4feYIAynl5/HHqzqob49gFZdBvpHV5ovv3Ot3nvpy/o9TLuPHgA0wnlckrc6/DgpuTl5ZolCQIYZxGv37rBW1/8Av/NP/om1gsiFfH+Bw955ycfcTTo82d+9asM+hl1sea1O4dcXs5YrHJuSMPOzpDJ+QWDDOrK8OGjxzj/glceHHF49wglJMXJT1DxhK+8ecR7L2a8fO8jdKyJqieQ53glcaM+iQaHI5KSNNFkWcJssaIqK3qdlDjWRHFML4vweOLeEaPxgPnxB6xnJ2gRfCbWOmbLc6Q33LvToZ8qYiXJTUKv12VVO6yxWN+WULfUOyLoykOniwQJvW6PQa+3XenRSqN1RFEUFEUeetIAYw3WWKq62erNpVTtxO3qQqZlCEYIZZRhtV2qn99g+tn49MYP3/n7SCFDIIwPK6jCC4SMQERI4RHWgHd42a5SO0ishdLgVjPUbIK0DXVvj2mcMfeCed7w0Urzk2pIqbPQCYQMcjIcsixZPH/E8/VDfJIiowStAyD0UtPIAOoTfIibV2DQrArFjoZEQuElXrVymhZYSmdIvMeWFfPpSySSNI1YzZfUxJSrGaZY4Js5xXJJPLjJYGcfKRO00oxHIzrlik4q+eHDcyrTpqv5kFwmRYROYnrZkDe+/Mv0BuNrW1OB9AjvCP5NhXA141GPNH2DxcVF8G/2usRx+M4BKGmcD51pXjhUHCN0ykaQJaVsvRnBbK6VpLAN66JgneehDD6KmU2XdLMBk8kMYwx5nvPKK6/y8viY5XLFxcWEujahJHeTmOYsxgfDvkDiaMMIxCf9FmGElV5jLZEMEiSHac910S60BHZNShUS45xlvpjzf/o//2c8e/mc/+R/9b9mf+9Gu3LM1nsDXGE119BgodNDDAYo1xBrhXMlnWZCtx6TrS5RkaaWElUs0M2M2JbsNgtW1lOakn6k6doIbEXHG1IXJr2y9QMJBFpA6SGXCq8jvLFYFCbRLFSEn09JGofxHpPELLsjbNUw1pIsSf4FnpmfjX/eKOuwIOB8iKJXSpAkoROwaQzGWowPXq7rh/FW9sgmBMJdRZpfY9uug7LN3901ALfxZ0spaaxBuNan5QPbJUR4fOPxiaMoeNdl8JjJ1l+1mfBXldmyT+0FOVwPCd4tKQV1ExZqpFboWG2/i5JtQIkI84iNX0wiiXTc3n8DiNgswFZVBd4TaY3zjrq2bWplGxuPhTY+37cKAgjBHMJLrAnbwjtomiYs8G0klz5QNeHzBGmjboMyNrLIsC8C4NsEtBztjvmTX7jPerGkKCr6VOhiBS5lJ9Y8nxUsmpp+IjAWSuN478UFw9zT62ZoJfmlV+9y96jk3Q8ec7lYIWW4LnnvsaZlNNvruakbVqsVeZ6Tr3NinW6/byD5/fZa6K4BogB2w71y67vb2EM224uW7QKEE9v93AZkI1umqz3wtsdfGJvjUXzi8Z8NsLl6zG0Z4A0gpg0H2WgejbE8ffqM733nHYp8SRxJrAneYqUlSIVvGqxx6FYOu1nAuN5F9/OOTwWc9YYj9g8OGCQdzhODKVbkqxUvnz7ENSXL5YzZZI6uclIcy+klWaSId3a4eXQLvOT/y96fxdqWZel52Deb1e1+n/72XfQR2VZmsToWq1g0ySpSNGVJNEFZsmwDBAQYhGkYfOCjIch+tWUbMAwYlgwBkklZFmn2VaViVmZWVWZGZkRmRnfjRsRtT392v1c7Gz/Mtc+NJClASSQqHhwTCETEOfees7u51hxj/P/3H25fgIZYS5JuimocTTPh8HiCiCbsHbxIenrGvJ5hspThToed21cY9QZI0/D42RGThSNOYoQI2n7ZdivSKOLa9QO6/QFojZcxSIXyhk4/o6NHeBGhog77ex0OL6ZcnB6RKImOJeu8ZDafhs0gJbWpyVSfYul4Opkz6qUIITg9P6HTSxn2d1jlS1xT49OMSBCw6KZBJhFsjTHast/rEsUp9WrJ3u421/b2sfUJw1Ev+DFkRdMY8mpJP+oRdXcp8yWRd2gcVVlSVhaLIRKe/qBDP92ik/WZr9c0a0uWdljna6JsQJKN0N6SrnPGgwFCOmazGWXVsCwFKko4meb0rqS88bUvczudsROVPH3yhN/5vR/y9smafpYQC8f5Yskr+wf8wpdepaly6sbx8/eu8cbBNt2tHT786BMuLixxFPGsPON4siTtZowiOH/wYyYCXn9ln6NHT1nOK0ZdyerEUJcFIu2T9ftspQppK5ZnZ7jjI4z3+DgijmO8DOSlSAq0VKRxjOpvJIahy5R1u3hjsLYmTSU6SXBRl+nFE5rVBYpAXlNRio8yIqdIOh2apMN0cY5EkZdLirJgtiqQLXVNKxk6P641hnqB1hFaavr9LoNBH2vNZZjler1uuzeb7BNF0zSYJlxYpZJB9kXouHtk8AZ9SnetWhlkmLSpT3U4P1+fxTr54TcBQSOgqGrqVYF0Ciu7OK+Jvcetp9TLGco5YilIEKQiTJWkhGS0i7z1Ok1vRBlHrMuaD+eKHyy7TEUXoYP+ZePPWijFD6su6VunvH7+Tcb1Q0SakSUBIFFFEUYlyEiQAkanrOMOzzr3+Di7zffrEXOjwDlU0AyFvUI49Pxw7vjtjy84fnTBnasZL7/8Is8ePeT+d79BPNji8NkRQ1XQjwV0brFz+yovv/YGKh3ilcPZBmzFqKM5XTbBMC8sUmvSSJP0Btx74Q26/RHw3D9xKREVAnyEEJYANlZksSO5cYtiucQ3BcRxKHyjLkiF9A7hdaDQ6hhP1P5ch7cBv2yNQYk2fNVWNE1DWdUkWUYcJVg7xzpHURQkScJyuWQynVI3FbPZBc+OnrJYzlgsZ1RV0QJKHB7X0tKS0GWXDueCxJkWDrTpwAoE0oH1oSjzBMiS1knbIQ/Xgk33XSqBd6FQ+wd//3d58vQJ//P/6f+EL73xJYRSeGuQHrQUKK2J0j5KaBrn6N18kfJrOf6T90jqJcqPGTQlqTnGrhzGrynTHtIWJG5KKlZ07QJhaqoopt8d0u/3UKsJ26sVsS8p8QyEpe8tqRYMhWaEJZGwpzx9GpQ3xCZiSIpbntKzFam0+AiS2BB7x1BLYvk5afazXNa5dgoV8jrjSCO9J4kkKomwTlOZMEmz1obDaju22NAWtW6l9u2EJUzAaZUEhMl1+1kOsv3nRVzY75Kmsa3UzaN1yODydjM1kW2tFRqfUqogM5Qh1DqIewOQQUcSZ8Jj3PyeTb6Ya6ENPugIP3UYFz9BYXTO0jQBi6+1wlkobfCESyEvX6umaTAmvHahkOSSVBgAK+Gaaq1t/7vF67d7XEqJk6695AXwiHcOfGgkOT6V2SZlmCS2hdzm9bvMXROeSEpGgy5/+ZffwBvD8ck5eVHzybMZSSSpygmDXkYUZeRNQ11ZzpYlWRKxahwni6e8dOsaAGVjyDopX3vtBf75939M0zSh+dRYvAhKANf2n5CCi8k5nU7K8fERWdYhiqLLgmYzz0eEZ/npiezzQimcjy6jGngeEA1BGu9anP7G/bWZurVv26cmZc+Ls09Pyp5fg5+vT3vO4Pk0VMoI0RajG4LoyckZ3/3ed3jw4X2srTnY3aYsK6wLaijvoKhK8A6JJ47j1m/2qeclAlTqp10/k+Ls5o17xEKwWJ7Q7UjWdczhkzlCXHBzf8jesMfJWY7TnmHWoSlzXrl2hdu3bhDpCOkd/dGQlXVY70miLuvVimdPz/jo6WMGWY/hcM6tG3d5//F9Km/Y2Royx5PGMXtb23SM4elqQeZNwDXLKOR5ScUKhzMF3WhE1hsQxxlZlobwzjhjNr2gOjli/2CPXtqn4wuujLos8prJdIW1DT6JGXQHVKbBmYJhr0ueF4xGI8b9EVprBv0x21sDqBoW56cYKaiwbPf67Ozs44VitLPDeGuHKp+xdDl+cY7xjrQ/RsY90l7BzXsjUulIxYIyXxDFMVoIlHc0XhF3txC2oZNo4q1d8rpAas/21ja93oAay6iTQS/j6v4VpE4pjOBivmBy8RStBNpLKOcUTc2zk4JPHj9jWRq+/LU/yV//W3+LnqwQj77J8uKc6sEh9154gWiw5PHxOXlhcGLBo+Nj8vUKWxR4rUmu3OP6tVvM5hM0Jat1zdwLtu+9wtWx4OWrGfeGBfujbZazM6oaxlf2ycYVVCVxJyPNItKeYr6csWQPWxkeP3qC0rrdtq2US4WckVG/z7DfI040NoqYTC+g1aEnSUplV8jWoL/OK9TqE1JTobKUusjBNpTFDJkO2Llyl9HBNZYXj5hP13jb4Cv46OkFqyJclTbZKlIAWiFsuHhLKYh01BLoDForkiTBGEMUhQPjarWiaqWRQsi2cx8FPK0A64I0zjiHt/byhrjJbdlIJqxtkPZz38ZnudLFJNw0ZYh3ELMlvpI4BRUxlXfYizOKp8/w1qCEJyMUTV460sGIwZduk2UjTJLSNJZnS/jxsscTM8LHkqid0oaGqsIKyeM0pZF3WFysePXpM8Zn30NqQxpJlE6pVILQkkhLfNJjOfwK39lP+MbegPMoQ3qHcg1RY1FxhITgmxSCo1Lw944iHjSKX588pZ4+4tEHP+Qb3/wex7M5x5WiPxgyVI4/+Us7/KO/8w+5svV7/LX/xV9n0O9TTc9x3rI9HLAscqqmCbtVxuxcvcn1m/eIk4R/0WdwuVoJiXcWb217UJNIX9Mdj6jWCWY9Q0cxuAZcFXJwpEIo1d6tN56D4DWRQhMlCcbWQWZkHdPJlOVywWAwZJ3nlGWBEG0Xm3BTPXz2jOFwwOHRMdPplLoqMU1DUa7bidwGj+zb/a5x9tIY00pzgiTH+UALuwyhdeGAqbRCSUWvP2C1WlOVJRsJjccCHmNB4/nh9z/gb9//j/lTf/Kr/MmvfZXYrjB5QaZiRuNtBtdfpD+6Qhp1iNMu3as3qdcT0pVFDfYZmCWqyCk4I1EpMutB1CPRFbJKEaZPz1bobEgcC1LbhHtlvWa4mOKXCxIEXSFInUEJjetk6P1r7PR6dHUc8tGQSCxVohhFkqEF7xq6qsFvjRjGEZ2m/pfe+s/XH99SAqRSl3JFrQJ0yjhHZZoWZhNkglaJ4HXyYBoH1iHlc4phFGt83dCOcy9leeH8/qkJB889afC8SAv5XKb15oQsNWNCYzNOIjyhkeHb032sVUtmDKAQ10rGJAEAFlQmEqkEURQTRxFVXdO6n8gy3U6Cgp/LtcVhFOnLx1hVNYF+GIWCyYbiKlyfAlxkMyW/pDn61icmg7TdNAYZyUspZ3jOfOq6sXkheC6VbgmMrvXZGalCnptSoTg0IZdRKR2+hmfU6/Dv/sYv0E8Fs6NDvGk4my4Z9jsUeYX1kJcNJq84XVasa8ewm1LWhiyOKOoGW6xBayb5Cr3sMOx3+NUvvMh33v+IRV6EBrJwbR5r6zlUisbUPHv2lL/39/8bvv71r/O1r36NXq/LxiD4k5OqTxdIm1Lr01I/d1lsbWxn4dq5mbL9y/LEDbjjuXftJ31lYf2rz0mXpFHPpebSORuyzoRjPl3w1g/e4oc/fpvlcokQ0OtmWGMuAS9NY/BAYyxKBb3lKl8RxzHKCcq6at9z+xyc8lOsn0lxNllMsHnFxx/f5+b1XTIR41xNHMVkWZc40mztbnNDd/FFQ7k4Y2erxwt3XsKiqfMZcZxgrWO5rnj47IjDkynvPnzCs5MJ64Fj8cN3eOHllxmkPe4//jjIWZYltnGMk5T+cIcXX4mhKcMm1RFNC1IQIqGpJeeTFUlvD1fXdLs9MtehsRaIMHXB+dmM4a2UvdGA47MJi8Wa0jZsDQfESUo3TYl0xM7eNjt7V6mNprGCi/k5W8MR3eEQ6QzL+QWrxQTd6zHs7bN/sMfh8Rn9OqXXUVTNlIVZksWK0dY2U+FwQnE2nVCWS7JIM+yk2DpjZUqawkAxBZnT6A62quiKmk6cIDJNX4zQErbH20RpFyMg0wnr+QwV9yltTW5qijKnLMtw4ZMRiYwoK8s/+NYP8V4wTjv8qT//m+zu7RFffMC0rHn3B+/QjRS/8vUXiNOM48MnPPjoiDffP+L+++8RxUnoIKG5/+AjnuiE5XLCIs+ZFg1bB7f407/+S9y4coXlj36XV165is8rdKPw1Yo4ysj2dhkMx9RViRKe1bqkqCy96Ckjt+DKwQ4nx+dY62lMg5KCJAlRpv1+jyjSpGnKumnC+72RNwiHaSpUHNHvd0ijCuE0cUeRxjtY19CRnvPzUx6eTOiainh9TD+SzNIOdbFktZrxyck5pjV2SgTGW7wDYwMWPYzCQ/Btp7PxO4aLrZRtcLWQdDpdpNStryV0j+u6RmtNmnXaLpwlUhKh9KXOHsKBM2Sdha6b+On3+ufrZ7i2ijW1lBRSQ2WwVY6rJUbHJNJQW8HKOMqm4cxIKicZSuhJSx1njG68Tnz9JaL+GOs8ZyvHu6sOH5gxTZwG0pWpUUIhophGSpzS1F5wmA4wV9+g8YI3LGRnb6KaBqcklfRIpbFZj7z3Ko+7X+GH/Rc5i4ZI28o4fJCoRZVBpRm1AOkszgvO0byvdvmN7po/+uf/H97/7vc5u5gxXeVMSkdRlTyrDJ88+juMdsYsFkM+ef/H3HnxHjbPQ1MiE9y9sc+DJ4d0O0Neff1LjLd3PxU0G9ZPSlFaIaAz+I0PywtEFAffgbeknRibXcVWK6TLkVrT2khAxCAUop1kg0eoCKF0CIx3gZponWe+XLFcLkPAtRfMplNOT08YDrdZrRZoHfHw0UPS5C5VVTOZXBApRZ4X4MP0euP7DBCQcPQTQYPaes5o/5xoDe229Qa2UkipGI/GpFlKt9vl+vVrvPvOu9R1TZA4BkS+lB6LxUvHapnz+998m+NnU/7MKzdJ1yfMF0vK8Q75sqK87Rl2x4h1SVMtEVqQjfpEcUrqEsRqiqSDEYpCVqA7qNGIulnTeIu3K2x/gPEGH6X4zpBIanbrmmZyTH34IU1VII3Gy4jBrRuovbvEShDHEqxBLddkTtJ94Q2ys6eIw0eICLIsxvV6iEShzeeo2c9yiU3MhQMlBd5ZGg8aFYpuZ/FC0NgA51FKB0y7C9Mj2wZIB2ne88ImFD1Bliw3HjT/kwfmzUHa2kBsDBOoKPjAWt1aFEdhX5mWJIlnf3ub+XLGdpohpQgEVRnhnOWsCXtLS4VWiroJ149ISpTwdJJQTKVpRBwpnBM0Bqq6xlt/mVtljW1D59tJmQk/1zuPkiEbLFYahMNrjQ8aF7JUtUWTpDEGISDNokuvlRAywEJajxqINovMP5+qXY6Awu9rnHuuniEoZy5pkIRpWzfL+Lf/1BcY9mPq+TFlWYXHryVXhykn1lAbTdFYOlGEVjXdWNLRoKMEj6AbxyxXOVcPRngXM5tPWK2XXNvb4Ve+9Crfefcjzi6WAWYiw+8WQmKNxVmBbUrK8phvfvOb7O/t8cbrX4BLj1V4rz8dHh2MZ47n5VT71bbpHV4vcfkeeL/xbcHz2j787Z9UNn56MvvpdTnKe/75F771hvmQI+dCZpv3sC4K3n3nfT744F3qKifWMsCy+j06WXop290A3YSSRDoEdxvn0FGEFJLGtSRu69pC+qdfP5Or5Gq5RBpPksZMlzUkNVcPdhBCUeYFdZIE/P1syWpdkSnB6XzFZDaltJ6mxYse7AzpD3scHU+Yr3L2tg6wBgrjqY3lk8cfceXKPcTTUx58dMrtgxELNWGiFefGIbrDkD+h00AKsyFdPYkEKM1kNmH/2l0ms3Oa9ZzEW+q6opNFSN8h6qQMBkNMseZiMsE2BbujIYNeh+lswfGzZ2RZwpUreyzmc6YXT9BCMuxmjPspvslZLteUVUPWybCxZVVPKcoBcaRprOPZxQXn1ZxuqvjSjbvkAkynw6oEtVyTCNjrD/BYZtTgJfPFIhxflKU3UCTGg/TUTUkv7uF8w2qdk1cVXkrSOEUgmc5O2RqMSDs9RNRltP8ig907VKsJZnVKU6z5Z3/4PZ6cLNgZZuy++Co3X3mZ1bOPSI7f5OjjD9nb7rC1f8D8YsZsWvCFr36Fr/3i1/n6+w94/NHHPDot+eC84N0PnoFw3Lgy4u6Lt1FmTVkUxLJBfPx9Bp2XiLISW1k6nYzo+g06sabKVyjb0FQTDk9LomzI3rXrbKcx83XFsL+kE0uGWyOE0FycnpGoOMikkhSEIO1kVGVBWeRIGcy4aRyhgKoq6e9tcfv6NZSsg8erzClWc7JY0u+PsCLmIndU8yfMbZ+oM6KX9igsPCunnM2rTWMw3Jycu8wbU1qTJAmDfo80i0NYdQsj0VpTliVN0xBFCZ1OlzTNAinOhs54Emd4IS7hIBtpk6cJ0ogWHLDxuYUCLei+P1+f3VL4EEDtHB1T40yJKQVWa7qRobGQuTJ4qaTHCocW4SAib90leekVov09rJacLw3vrxJ+2Gyzjjoo4VFVznB2hBSGenyTxXAHpyRGhESXx70R7voX6LTFQP/0bbxV1JGiG3WZjX6Oh3u/xH975XU+GmwBAifq4FvDcm11yrVyxnlvm5PBFZYqCj4HocgJPsjF2qCKgi1rGQ+GLIo53jT0Is8o61Jby7Vxj9XklNVil9HWFrTY7X434gtf+Ao7+9eI4097jDadY/Hc3E6bU+M8mBpvGpqqDF1MWxNFCehwq5Laoro7uGqGr0vkZmJGw4ZCKTZ6mja4XUUaaxXC2ZDf09RMJhOiuEO/P6AoKyaTKd3ugDxfI4Tk5PiYbqdDVVUU+ZoSgXWBxhamYO5TkwBHYx2KVobTetBCx9+FrnswpQCEe92VA5yx3L51l/Pzc25cv06RV3zwwbtsCHQBPNKAC4Wfko7VasWT4xN+NB7xy1sjkrihmExpPv6EWdHQRZItV4hiTZwKkt0+aUcRGYHqxcR0WJcxlZE0AoSIsf0x5XpBXuask5SuUgGIkHVDJlZfke1cYZWmzJ69T2YsSa+HvnkH39vDKoHRImT9iRNMY9FW4HavUzqDtA0mG2GzGB8HXPnn67NbzlmE90HqK9pDrhA07cFftl/XQuEENFWNi8Kk1xOmPxs4lXehAlGthzVkcIUJNXDZjHDWB+BCKyl8LmkOKpTbt66RRBFNVXMxm+JQ5HmJEJI0lrx25zYCwd7eDh6PmUwQ5yesmpp/fnKOUirYDaxDKI8zAb0eRwS5pGunWI3F2JB0EnxgAtu03jkRbAW4VgbZ+qaCLy9AgLQCpWIaa6nqOuSxao3Hhte19RhB6wkzIdMsyEPlZYbWpjm7kZULGaaZti1GlNLhPi9EyEvznkiH4tN5QEh+6Yu3uXWwz2JyiqkaJJ7pbM293QFZEnMwyrDOM10Z5nlBrBRpFNpgXeWJ44RuJ8ZaWM3XjEdDEt3nfLrg6ckZt+OIX/7CK/yjP/w+5apGI1B6Iw1VrawzTMFWyzn/9J/9E/r9Hndu3movvZv3+fl77Z27zDHzbaxB8Cu2f05sCrr2s8nG3hFAWt6H4pDwMiLlBsryk1O15+u/Y3onaAErAqXCtPS99z7gg/ffC+oIXJCMJxHpzlYLjpEUZYlWGtcWXcFmImmsv/QvCiDrZMzmc7pZhrWe1Xr9U+/Tn0lxVpc5x8dnDLsJTVFxNF/xwq1rKJly+PgxOl4zmdc8fPSISkbs97usa8U79x+SA1u9HtIV9DoxeV5SF3MGAt47f0KaSt64dZMyrzk6n7FeHvPanRf45ve+w/284I1Yo/e2Kc4vqKdLtnYG6Dhr82ZCxpjUGYfnH9MbDrAWLk6PWU8n1HXFcDhkHEf0RyP6/QGddMgsXyGlZ5im5OsFvUThqoqmdtSUTJZrTHmGEBH7O/t4HLYqWFcTZBSyfPo6Y2t7h1hHrOYrLs6OqWczZNplLxtwa3dMXa2Z1zXGRZSzOUPluHr9KlIrZpWj2xnR7Uu6ScKk8DTO0EujQE5rbJiSOZjOJhyeTEgySTfrs5RRyNaSnqIpcLmid/uL7Nz7ZXw14/T+t2jmx/zOt9/hW+8+w2NYF56Xfu4XWVxMmTz8Qz75wVv0kpqDnTGiaUjSLld2Uwb9Pro/JoqPKEzMizfH/Nav7/Dw0Qm3X3oZnUZ8+OiC650GlOLk6SG5iTDlhN2dIb5YUzeKpNtHxjHaCbp7u/iqwmcTzqcr5os1qe4QpTHLwjCdrzk5neKcpZ+mdDsJWZZQ13UITaxKyrLA2pDbEkvFYNAPnTGhiCJJVc7bCReUVc3J5BTtLMv+DOcVWkVY4yjLBidyEimxUnN4tuB8tr4c51sXAANSBlmi1oo0CR28pg5+tygKcojVaoUxlrpugJKiyMmyjE6nQ5KkCCmxwGqxQMpg1AVa+YBASX95UQkdRoVwLe5Xiv/O/fj5+mNY0gRvqw9+MOscrrHhBhIptLDEzjL0ArBkQhBLj9vbQ73yGunBVZI0Y102PFpF/LAcM5dDkNCpc27OPuba+Vtk6wtW1df4JPo6x/0dGhGoe1ZJHvcG2Ouvcmo9uzImPn2Xueohtn+O5cGf4KOD1/mwv4MVYeKqkGhv2DMTvlK/z8uzD5nme7zlfo73RzdZRxnee1ZE/J3ZLXajN6D6FhkKm+fcHsTYVJMlCan09HfGXL82Zj6dUS1XqNEWRAlRlDDav0PUGbc30n/1Ydy3MkZXLzHlGmcMVVURxRn5Yk6sA7XUmzDhU0oiDPjYIrMdSBp8Mwcswjmk8iAU4WAUyI9Yi3cWpMAhWOcV3jrmszk6ShmPR0ipWK1yJpNzVqs1QkBRrPnoowes1kuaurn0RFx6R304PFgfyjC8BbuRNBraY17oyLtwCHCtJAzvuXHjGkkUc/XqFWIlWC3mvP7ayxwePWGxmLWdYkuk2uZMe8BpTM3k4oxnFzucdPZ5pZNgTE15+pTJ6TOW0yXblWGws0N87ypaOzLh6Ke6VVEIOkLSJ2FVK1xtsXVBZRuOGsNkdczNfp9RNKYWgHeUaQcnI7KD2xhXYZbHiME2qyRDJ5JOnOF1iLFZrmacu5LUewwK2R3jbUEZx1QytDSIP48B+UyXCFl8ggBraIwhjgPN0DobDp8hZZ1ISyIdoonqunmeF2ZbjL14PpmQrYdVqU3odAuR0AIdx2xyvPBhL2z8bFLBqsjpd3c42N9nf3uLpNML91vbIPDcufcK/dGIsszRUtF98TXOj55gZwu2y7co6zWNdTTOYxqHlIFfoEWQIDdNg3OExoCQIRB+M93bSFF8CBAOBVCrfFHB/4UIcuvtrS1W64JlnuOsg0i3UzZHbQJRNhAW272OwjuLlApjQ3Eh28fkRQjXhufSN6FCc1kSMsekCNM4YwMFVklJpBSv3TzgV7/8EsrWlMUSYR0/enDEVj9jd9Ch2x/QlCmrvCYvFE3tqKzBOs/BMCOWgn6q2OpnCBWRVw3z+ZxBv4vrdZjXhqPjC65fgV9442V+9zs/wnqLa4LHUKmQl6m1ojHBp/Xo0RP+7n/1X/E/+w/+fXa3dgK4o732u3ZiGqaEjg34ZBPy7Nvmd7gpbJQUovWCbeAhG6iMbL2AwTfYNAIwl5Aa+BcLtOdf2/we6xxSgDWWR48f8eb3fsB8cYFqw9nFp8LUN1POsmoQCKwxNKYhSVKMaT1rSrVRMQ4DjPt98nVBYyyrdXHZ+Php1s+kONvducpyVaOjhtpULPOKvGywdYWxNQe7u3QHEVcfTfjweMI6sly7+kUyHTGMFbZeEGdpyPcyOXvjEAi6uz3gzp3r7PUzHj05YRHHnC8VIEBJAAEAAElEQVQWXLs65ufu3eVxvkBHIxaLBfl8xtkyp9d9kShJUUojRBgzJmj2+n3G+/ucn5/z6MlDOmmCSmOSwRYhhwYmsxmuWtFJE/qDLVZ5hVs6vFes6oaT2ZTeeMyz4ymz0yf0OxlVldPtZAFMEQmy3pCeTKnqOZGOEEoxSDLqoqApS4ZZzHB7GyVSzuYTOkkHR0JRnLJ/bUQn1uQuRQlNtb7ASokVDlxORwr68ZBef0jZVBgvqIoFXkckWYdultHpdqjqgm4c0e12UVEHn+zz6ld+ieGoi5Id7tz8N/i7/881v/PW38U5S209b/zin+DXf+vP8v1vfJO3/sk/QDcVV7c6bHUSLrIRlYjZ0hFmtQZT0peWfpbiqpos7fLaq/eQseKDp1OWixydWE4Op4xTx/r4PoNbXybef5X54UN6Mke7JcIP0bHELJc4a1gvC4z1TCcz+kQ03vPjhxfMlzmmqciimCxJ6WYZdVVR1YbR1phIa+ZFES7C1pDpCB1pGt9iTmvD4bNjkiTo1cHT7x3gXE1hSowVqLhD2h2GGw+G2WzN2/cf8t13P6GoNpIEd9ll3Mg2tApY3OdjeXEpPdiQqYwJxmpjAgygPxySJAl5njNfLBAIlNKkSuHaG4nn+c8MvoBgVBZSB7DB50SQz3T50X6Q3gBNUdOUFmuqAKoRAk3bldOSBIHCkQ6HdF59A3XjDgy6lI3lyUrwVjXgqR4jlWC7WvPG6kNu528yqn9Mp57hns3Y9Yrv3v4ah70xjVRYAdppTrMh3H6dotth0N/h3CU8vvp15ldeYtYbYb1F2aDnT1zNLXPGi/YBV/iYYXbM0E2Ick+UCH6kb5ET4YD3ZZ/d/h4MuhyfXlDZCiMUOzrlYL9Pt5cxGvSRUvLhO++DkySxYnz1Nt3928SdYXsIhOed009LTBzeG7xvqIolk5NjyjzHOku3N6Qs16RJSqxiksSQxnHbpYxAWdANqBghd6FegCkDg0NKBBlCqMubq3BBCuyFZDadcnT4lMPjZzTWIJUg66ScHJ+CcCRxxmw64eLijDiJWS2XKCmpm7ItNFtanQlSp9b7jhcWdzkNCJ1w49ub/Mbsfrmfg3fnlTdepmkaXnjxRT7+5CFewO7uLvP57FL+1ZgAQ1DtBCJLMzye9+4/wNYlV673uJO6gK7Pa2xeohuB8mGymzQlHZfTj0KgrSoqbK2IEyiFolydU0+P6NVTrKjp54694oRxvUV35xYuG+ElxC4nERV0O3hG1N0Oa2XoU9D1gshrmnqBjyyRjEjzkliUOGnInWKKwSlPT3kq/9MfVD5fP7u18VYCbMKYQ+hwOBJ7FSbArvGXcAtayI13BLiB8ljv2qmFvcwyUy1Z0AsZMsRCN+MSDrKZllvrQj4YQVY4nS6oiop8Nefe7XuUZY2vC+7dvcvx2TlIePrsIXGS0c0ypodztIoY7h5w9cYNPrj/zmXANNITRQrjPVXe4LBY4zAuQCakACWjMM0WmwmMQqkg89Q6TMma5rmkrjEhs2xdlBRVifcQRxFx64XXUhLHEY21lFXVyplFK58Tz20IgpBjCpcAFQiiAes9yjuUDOcUpcK/RXuRMbWBSHFtZ8Bf+IVXSKiYX1wgPbz1/lMyKXj5zk36gwyERnnBIE048kuyJEIZybysUEiSVJFpEbzKkabX6xKrcAaOUPRTzapq+OCjx3zxjVe4frDLw8MjvAuTVieCDN1uSIsuyE8fPXrMf/P3/j6/9ef+PNeuXG1jBNoCrVUTAGwQ+s/vDM9zzzafkedFW2hNKfn8PIQPxdsGkBu+18odW3HGT/rP2pDy9rX0zvPs+IS3336b46NneOdQMlBEI90GpLeV3MaGYowhSZLWrqJ+gkCqCO0OL6FqGk7OzzHGsMoLqqqmLIufep/+TIqzBw8/Js26bI328MZh/cfMF2uGnQ7Xrlwh63TwwnLj6phaWV6/d4tUxKSpYGfUoVhLFqsVZ2dPefH2Pntb2zx4eMTVcY9+4pnnK2pbB1JW46mLBV/44mtsTZZMzx7h/IBRd8DHhxPmRY2xntQ5kkiim4j3Tp7x9OlDvry3y8XknFW5pre7xbX9W0yPD8lNicpGeDwL2TDsdTCJZri1RzqbEElPmiUcHOywtbXL9CyMkctkwJvvfMjusMeNawd0ez2cqRn0u/STbaq6YrE65/b1m9y4fpvBcAuzntBPNKVxZEmXqipZrVdsjVLu3r7J2cUEp4ZsdXssvGFRV6xLS7Eqibuaql4xP1ogY0UnHeC8p5cm6JFnVRksAaG9KnMa79m7coUv/+m/xHCrx6ZJFKUZ/+a/99f48OmE/8d/+n9EK8HXf+VXGPaH3Li9z+rudV6/kUHjKOZT5GpKGifkxRZJXJA2ivFrv8Dd7D5uNWe8u421nkVeY/MVB6MMXMG16zscHs+5evsuizxnfTbH1A1bnQzTlKyLCVm/z3Q6QStBJSMOj05wUUKUxJwVYQMOhj2SOEI56HRTDJ6iqEmylF6vy3w2wzQNUgTkeJYmCCFYTKd4Z4miBGcVkVZYa6maGnQa/CgiQcmA8M3SAQ6YTM/40YeP+fZbH/L0bBG055uDZqsR39xohCCg8iNNEieXxdkGAJLneXvxl0gpqeqa+WyOVK1uu7FIpVCRwnmHF/6SbrUZ92sVB5OpVpf65eYy8PDz9VmsO//O36LxNnRrrcEUFbaoaKoGu17Dcoo7PcI8foy7OMMUJc3uAdWtF3DjEbWHsyX8OO9xnx1E1OGltOZ/sOd44XpKv7mDcHtQ1dh1wa4s2BnM+IOkwwdFQuFCV7LQEae9bWwSGkp5ZVl291l3BoBEWYemoic8X4pmfME9YS86pBc7UreDNoY77hQXP0CqjB9zwMxFIAUfjr/A1177dXz92+T5mqwTsz3qIaRn2OtijOXp/Uc8enSKU5q7L9xmeEXQHe21E6znEsYgxoRg0A7FUlOtqFZzVss508kFdZ7jhCDJuiynF6xx9EfbWN8FHdPpdoM60FmCScYjRATJEBh96ve1RZkQWB/kwx5P3TScnJ5ydnaOVBGHh0cY47h69RrOOp48fsbW1jbHR4c0jWU2v6BoC8YwjfMEembIZHPeXdrNN6KZzYTLf6p5Ij71mDYHi3We0+v1qIsS6y39fpflcok1TSsX2/zcMKWPoojhsM/BwXXqsmK+mFEY+AfHK/79GxG9UUI3FrjaEa080gd5Fjhi2xDbOkg8VwW6bOjoCb28wJ6f0RSGSkI3Ds2kcW1IlmdEqcInik7joSpJixm4HCJHRUlZL+j4hlStQubPxWMQglE0pFtXKLPGN0tyAdJ1UFYyNJBV5c9+Q36+/nuvIJnVLU24DZEWhHuRDLllYWrlW6nf88mYcx5nHVpLJLr1eDVtcdfCObRGSy6znbwLEwqtFV6G+5417hI/jxeYxmIjS6QjiqKkKAtGWUpR1lhjmJ2d4IUg7o3wHhbn51RNw+716zx5+hRjNnAOQRIr6tqRN02QPeNbsIcDGWSOQvrLQz/IIEcWtPLMMJ3SUtC49nm1k8JFq4ahLSx8O+0SskWXeEkaJxhnsN5jnW0bvh6FDBN2wmNwrX/cuecerQ1eHtqJTPu6a62xrkErxa984Ta6nnO+Njx9chakgnXDl77wKtdv3qAs1tSNQSjNeDikczrhPK+JlKYXaWarNVk6QukIEERxgrGefq+Pc46jkzNEnNBRkuPlmtnkjBeu7/P05Jza1pfeYWM83ptWdhgo0t45fvSjd6jrmr/8l/4Nbly91sYctFOylnANXAJANv/9E9Uaz6WvzwmVtJ/DT8kk2x8gL4sp31I5w8/Y4PJBXhba08mct95+i8ePHuG9AW+DghWBVrqVXv7LjfYNcVFrTVGEYituJ8LeOQpjWOcFtWlw1l8WZUJCknxGtMZPPvyQW/duY/spUgquXLlNvpggpQ10LqEYDAfcvX2T7f0rKBlzND3nhc42oFjnOR98/BThG/q9Dp1unyg+J5WWpi452N2nn/V4eFaQr6akvU5Ao7sVO4OEnfEAyZphFhFLj5YghaNpDIuyZLaumRYlSZKx1atYjXeIZcrj+/f5+KOP2R+PSLMpjZTcvHkPE/UYjHap6opOktBNExaFodvvc+fGdd559z4LE/S7aRSzKBvm64pef4gpKi6qM3qDEXW+xlclzhjiJGO710f1EubLJYvaU1vLcrWkWNXcfekaUadPfrrANHOqRmBtjW1KlKgZDnsopSgbSWMtHWKcFzROUzcFCIkzNTS6TXaXlFXFaO8Ova1Rq+WVmyMCCI2QETu7+9RFzu2bB6wWE1y55oU710h8Ti9zzOM9JrOS5PyMsVxRJleYrj1DcYIoV4x7CXGS4r0k7vRRwlA1MYOh5v4f/hFeJQy3OpycLJmff8Jof4ucmKIoqPKKUTbGEDOZNCzqhunasreX4JIuW70evewM7BJbN6RpFiZhTQVCsLO9jbUG0xiU1ti6ppcmbG+NqZqKssjpdzoM+wnOFVgTIz10swHR4Bq4Ere+wDiobE1erUl728h0SN4YzmdL6romIHyfd2FES2zSWrUkxnB40jrkAWmtLzstG5QvhP+PfRt06SV1WQcyllZsku03xZhUsjVjK7I0JUmTNqsp/I7Gft59/izX3r0vtkd+gfAtKti7cCNyHpoaX1W4PMfP5+SPPuGDZ48peiMaITlbWd7NO/yo2cLEHb6sCv5Gt+YrBzHZ9ivI/tfxvS5oBVJiHVQi4s+vLf/Ze1P+0cOauvYYqVgiqOIu6dY1hIMKFQ5cvkFbz14P/oM3BvzGwR4jdR3FL4cgZO/bfC7Hl9H8Wd/hj048/9mDkqdVzFE65r27/w7bw6+R5VNumPe5lk6wdYMzFhU50m7Mzdt73Ll3hVVV0B/vtd3JzeczwrsaawpU1GGDuXeuxpQr1usF6+WSsq6YXpwx3tmlrksa41lNjoNnywuiuEMT1eg0Db42rUMAqA9TgPBzA37/0/1YKQSWgGM2jSNfr3l2dBgiRMqKXn/A0eEzrIPZbEpdFxwfH1EUBWVRYI0JFC/xHHPvfCiYvPMhzNZvyq/nk7FPB4NfqnVE+PNCSJbrFYv5HK0kadah3+tx+PQJi/n8Un6D96RpSrfXJ00zrl2/yt2799jbvsK3/+BbrFYzHpWCfyhL/kdf2yHpgI8a5MIj0h5WCkTTgGyoXY00oXHphUcWK6L1go4wmL5iHaegJLF19G1EGsT65PWMrm6IvSVyaxQ1VaRC6K9f06sqEmtoqjW+WYPQ6LpkUNUkdUmtDEUUEzFDF2uypkHXzyc3n68//uUJ/jLn5ae+Fg62siUDBhBHCB0O+ZvPsefWuctei2obB7KVdj+fcASismu9OlZJlA7kRGMsUkmiuI2K8Ru/lUcmXe688CJRkvCjt9/mzvY24719bFNjsayWEzzQ7XXp6xhbW9K4y8zOL7PRIkVoRGiJFB6pJTGylViG52FN8I5+2vfkPeRlIOxpKUiTjccrFG7O+sspobceg8eo0BAWoiWwKtlO2qCpQ6D1BsseICqAbqMCfCgiqrq5FH6H1yO8fpfF7qVcVPLStR3GsubJ4zPOLnIWlUFay0u3r3H95k2cNTgnwnlQKOJOl2u7O8wePSOLYjpasSgKZsscJRXdXg8vNEILlHPgBN004WKVo+KMbqI5fHbCa1/Y4dU7N3j3o0+obZDIb3zzbbwdTdOEhphxPPz4Id/5znfY+XO/eRkAbjdvtt+85s+LrM0U0YtPf3/znXDPEJ+awn1aqbSZkG0a4BtQ02VQtQie3eWy4Hvf+z5vvfUWWosA+9AaWiWSszawBFRI+3Y+xBzVTRMy7dxPAmO8d7SOAdZFSWMCJ6CuzGXxlqUJUawZ9gc/9T79mRRn3U6fqmq4OJuymk9QUjEaj+hvHdCJBFXTUJY5dV1wMb1gvWoYpCCuDjg/P+Xk/ILKeHYGXSyBfrLd63BcxVy7co3RoEevZ/j6l+5hZEKa7VAWc/a2eiyXNShPkiVsj/pIIalqg1c1VW2xTcML169yc6/Ddn9E15VcnCoefvAhJ6cn1MaiteBaNMQbx/nkiNv3/gTdrMMHP3oX7xrkeJvJ5JRXX3+Ffq+HiwW2gIv5KVu9DrV3HJ6esqoKyqKmP+hxUBsiU+FtznJ+gXQNo15MLBUzbwNhUAUK2yRfsFj2OTo6ZV3UWK+RUmKaAhXFXL9+D1M15OsF6/UyaKfrimU+p6xhtc7xxlHWJUgYj3dBJ5T5gif3v4eNunzhT/wicSSYz1a8+6NH6EzzxZ9/ld/9vQGDrsaWS+r5jOXRI85++CNeurPL+MoIVjWT8znlOkd0R/TrM65sj8CtGcSOfj9icjHHNp7RwS4XuSKWjnIyR6cJg50DqqpiOPb4kyMefJTTk3vMC0mxaIiGgqtf+ctcGd/g4v7baP+7dPuK5Mp1vvHjp/zoyYTD4zO2+wOcMWgdIzz0xwPiWDO7mLJer8nSiHVRcHX/gCRLOTk7w9SGeBAhbAVWYcsaoyRZ5qE8xlYVTV2yrg1NUwVox+Aq4+2b6PRtisYEfbx3P6Fh3mx853xbOKXEcXy5aZumYb1e0zT2OeVxkyklJf1uD6kUSzcP3jIlWnNq+HNpmiJ1MFg/JwOF7k8483l63c7PYut+vv51lwho5g2BL7xbnzrspAmi14OtLfz2Dk1LPFO1YbYs+STPeKcaspJ9Xm6W/PXimF/qC2JGCB8HWZCM8VkHnyoSKekgGIzhf9Xv4NxT/vEnFVgbCn0cjdBBuuY9EQ5pPFsdz9/42h5/+cUtBhlItj5Vu2zav88nPy9c91wdz/nfvTnnaaV52LnKw+4+mbOcl19iXL4NAvZ4hKzn9Ho9rGmIYk3SH1PlC0wxQ2dDwqtisXUOtsKYOtyAnaPIlzjTYMqSpinodrpMhSCNNVol7F27ydWbd4NXpCmwHuraoGKB0OGOGGRRAqkiNhmCXjik0OG9EAqhE7QH6yrAcnZ2zvHpCecX5/R6A54+fUInzej2ByxXa5bLJWVZslwt8c7T6fXwC0ftPUK2MIX24BSynQTCO/ylty587fKQ4AJqWwqBl4JYaXrdbpBpNoa8MMRxTJalpGkndPUJ5zOtNZ1uh93dHbZ3tnnlxZfp9XuMxgP+6l/9q/zTf/ZP+d6bf8QfLDx/9it3GPf7uDiDQYxWETJtEGaF1YbcOryX5FkAU2ksvteB3gCbKEwUExlH5hq0D11+nyTYJCWyBVo4oigcdqyOMVFE5AzKVYimQAkLvT5SCrplQyoj0lggI02pEzJvSfKKLiWR/nzq/1mu4IEWl1CPzT1GiMtzcficS4lWEcaYy0ahb+Vknw7w1UqhZERdN5dNC9cqTJSWaBXC1k0bkhUnUVvM6H8pM+zk9IR1WXHn6jVuv/gig51dev0hVZmT5zmiKZAqxkmNkJJPHn1Cp5vRNJa6CeRjtCCOAxF14xHdIO03UxwpwOJxTmw4PWGSJsNeTZTGW09RmcuCKzRPFVpLSlPhLbiyIoljYq2QAWGEwAVfWat+UUqFa6y3Aari/aX/VEpBqmLwAR5iN6hX+ImiQwhBP014db/Lk0eHTJc1s7xCeMcvfeFF7ty7g7UNTR2ycV0bAWCdYLS1ze2i5nw+p592uLI7ZjZf4ivDerEmjjKirAcKeoMx63yNQlBUgf4Yacn0/Jx7V8Ycnp1xsVwFkqxQl5Mv356RNs2ruja8+ebbCCH5zT//m+F9ca1nN7yU/8KZqg2fdhvp+6dtG+HuJMRGhisuPf8hM7bCWi7VRuEaLFu6pKSsat5/7x2+9703efrsGdYahsM+kUqCHPdTvugAeVOX1O/N2c8TSKWuzQjc+NDqqqGqG2praBrDarWmrAJ4bjjq0+t12R6NfvLp/PdcP5Pi7J2Pj9ldLXjjxZdZFg3HR4/Y3h6QporutVuksaGoVhxsj5lMZzixYtwfsVquSTPJ3s4BeXUayH6uwduaOPIMxwM6aR/vHL24z+7AcrhoeHL4kG6qGPZHCEqibECmLP3hiHnhWKxKxkmbq2EtUeTZHl1nla+oG1gXFXlRsjsa0+sk9AY9+p0YqWIq36AEdJI+O9vXOHv2MYcnp+xubTHqb3ExnTNIUnRmWeceg6WjY7COyHsGW2PqxvLBhx/TSyPG3YROvuJgawtlDXleUZSWdb5EYanqnCRW0FguJgsWhUXGkjiWdPq7WC84Pz/n5PgJEKhIcadPnA2p56c0zmCtYbUKhwqJJ0v7RLEmS3rEWY8ff/cfk8/XfPXX/gz/6J/+gP/T/+E/5m/+zf+Qqvb82m/8GqsH32f+4Xd5fPg2x/c/ZLtjKazlO3/wPgfDlD/3q69RWk9ZWkajHr1ON4zBD66A1iyfnFE1hvXJgpNnp1zt5OSdLUZX76DiDoVcMHl8xHzZMOrAe0/n1LVhbC/Iohfobm8h0oTdV76KO3mfLF3zz9/+If/l//ct1rUlS2IEBi1CXliv22HvYJ+L6YSiLEIH3Qbd92DYp6kb6rJESEG3m7I9zOikEdJbGu9RaERdUa3PA93Ja4SpUQKWZx/x7HzCxx89CJIK12LsL29gIni/RAi1rZuGKE5IkowoilgsFlRVdXmh2HTatI7o9/t0e12cC9S1pv27URQH1LZos1Vavf/Gq+bbA22kY5wzpEmyacp/vj6j5Wy9afd96qshPJzW5rx5k6yEmbSc2ZpFWfMoV7xTDZhGY3Z8xZ9tjnnDPyNZNbjjPqLcQlRrqEtEM4ZeD7IIVEBUX+lp/r07XY7Oct5cRXgHmgCXaVyYEikBWeT4t25m/JnrfYZZGw776ce7+RBJWlkH9GPHb9wZcb4o+U/eLzltIkDhpeVhsse33BdpnObX4y430gfEA09TzOn2xmztXSPt9RHeYfIZUkcgY4QIU+PJySF5kWPqkso2SKnI4hQlIOkPOLh6g/n500ArSzKiOGFr7yrO9HHOBrCJ1ggVgZQ4YwMXUW5IiAG577HPKWEiAm1RNnhqVusgS5IohFBkacK6WOMAUzc0zoTwVSEx3pKlKdZYfCHwTYlAX9LnnDNhdqrUZaG7OWjiwilEijBB6HQ7CCQHVw/YHW3R63Uoqpx+v0+Rr9FRzHA0ZG9/j9V6RVmVGGvQUcSdO7fZ2jqgP+hz69ZNlEp58uQR9+7c4oP3fszZ5Jxv3j/jf/zVLayM8Ekfn2hSXaDJw3VISWqdsNYhbkbH4b0pI8E67VJEEWld4m2NkQKjI4qoSy0VWZWjRE1NStWNWaYdrHNEVU7TCKzKqHRM3u0irIW4xFlHjaOMEqo4IWoakjQnLhLk537Zz3RtpkShgfD8MmCtx2NQIsgXrWkCNZDw8d74yrxzWAK4YjPX0ErjVCiCAl3QIRwkkQqHaiXBhSm9b0OrjTcYE/ZNkPMqbLPm/HzKK69mXLt6lboqWQHDwZBOp8Px04/J4ozR1hZFVSGk5NHjRxgbGqneg1Q6ADw8P+FZkrTcjzYD2jQOa8C1wfBShqmPwJMMMrx3LIsKU7dyz/a5Ohd8YQGIEjxkvnE0LVURHw7yvlVURFq2A6CAyfeEKZpzPmQ5tmCLKFLQFqveO5x/nn8mpeTuwZDlZIoxljSRRLnnjTfucfelF3BOUJfFJSnStY0xYS2RVFy5esCg18MLSHRMFmVYLHESh2clJVJp0p5itLXDsqg5my4oKktV1WTJlOFoxLjfZbYsAsxEKoQUl4HmmymWc47GWBarFd/89h8yHI341V/5lUB+RbQTNNhIav9VIdGf+j9gI4H0P/H9OI7pdFLqOsJ7T1mWlGXZykE91sEnHz/iO9/5QxaLGXXT0DRVm6uXgYto2mabahsIQgUpo5ZhYroB11gbJmoB9ubIiwKlNU0dJL2r9YqqrHDO08lSpJKMxyMirYmiiLz4jDxn13f7bO8N6fQ6nJ/J4OlpHI8+eszJ6Sm3rl0jUkHade/6Hvmiw7pYISVc273GomiI05hhL2J3a4yUGovlYLxFVdV8+PEhs+WKh6dLlk3o6uztjnnp7h69pk+Rlwit8SJQ7uq6udT2l3WJx9Pvjnh8fp+Lk0N8XbPT6+ClwypwkSAejRj1RyA8ZT7nuFxiXEmWJazKiv2DfS4uphwePQ2oWB/IRc46dCw42NlCx4qmrFgulzTFmpVNifFo21CulzRtpkKdz4l8MKgaPDrS1KbByxiVpKxarWoadTC2YXp6yOT8HJ0liDRi1MtAeIwQSC3Y29tjvDXG1BV1VVI1NavinNrUZMWauopIuiP+7n/+DzCJ4C/8pb/C/+3/+n/n3/5r/0Me//gHXJXn6ElNNVekquZsWvDR4w/J0oiXv/QFrFPsjTPyxlLkDbmZo7o9js+XHD855Mat60wqzXTe8Mar18HX/NEfvsMLL97jYEcRWcu5bUiHXR49O+PBJ+f8xT/zFW7u3WF7pGne/33U9h3Uwetku7dJxRHT/BPOJwt0EqMQpElMpCRxEjMaDWnqivnFJGxSrWmqioP9PeI4ZnExwTaGOIrY3x6xtzXCWENZrlitVxRlThon1GVNJ+mQaklTlRgkcdwnjkuiSNM0IRTS45FCtbrj+HnYJAFH2+v1WK+XNE1DnhdICYPhgE7Xcn7uSOKEOI7pdnsYFzaylJK0Ewq62tStZt+hpSKKY+qqCgcgHbUgBEVlLVIIGqVoFoufxdb9fP1rrqcP3mqd5AovZCtpk6FI0BFKgBYKoSPysuLRySHz5ZqPZ54f5dtc6BH7qeR2s+K6Pca7Q6bHF6iPF6jaILSAfhe7d4C7chOxdwM53kX2B/iky8is+Vqy5sP1gLmOaSBAILxH+jBNu5c63ug2ZBStWV7+RCn5vLj8SX9UIjxf21b8Qq/mH88UjZB4K7Be8UBuI4TlPLrGjV5Mx0wpvOPa3VfYu3KD3nAMUrE6O0FqRWe8i4wSyuKcui45PTnk7PgRkY7pDbZZaU+sIqRKkEKwWCyYTU4o8hW7B7dRUjLa3kdJjbMGU1YolVxSu4TUwc0hdPBzyKjtdNr22WiE0K0HTlDXBms9O7u7weMVafr9IdYYlIrwUtDr9pnOpoiqwlhHmoWDmlaKqm4AR5Ro6qZsp+itud2Ly67wJp/JeU+iFdevX2fUG9AfDLh1/SrewWK1ZLFasT0a4x30ux12drZZrpacnZ1TFjmr5RKtNVvbQ6zzNI1hNOqwvb3Hm29+n8YZKmP5nXef8KevXeE6BbkW4BJSXdDRJYkpkQJINGkLCUmtCcHCVpELT8cZUteQOBDOUgtNk0qks0jnkDiM9NRRQp6kxHWJ0wqHpEki5mmPedqnV62oRShOvZLMO33qOKW7XuJiSd3pbLz5n6/PaGkdtYfo502MzaFaCBVSqluwguV5sQA6SL0EgUyHxOFwNtgbsySmbgzGB6x42AOEosT6SxkcBBmldWEioaQKU3ARip1PHn3E3t6YKwdXwTnWiwVNXTOfz/ju9/6QxkiuXN1nvc45Pjlt77kCZ4MPqixN8IO2U5Yo6BwRQmGaoHrZqFl0JpFC452gm6bgHUrIywnQoNsJz0UFKahEUTc1Qb3uSOOEdVHgkJi6DqAI7y7lb8JDY0KzZxNF4JzHedtOiUJDT+pwvVAqROWEaXso7FxLaHbWkdcF41GfGE8virh1dR+lE6ib0JSuLbZq8DJg+70QWGdRQtIbDbCNoWksTirSpEMUp0FhIDQqSXFNRZx2UVFMZSzrskIrxfHZBeOdHfZGAz45PAuvX/saBfS/urRzbCZNeEtdw5tvfp9f+Pmfp5sFGnBQMvj2NXyeg/e8KNug8j/9PdpJo7wsAhtrsN6FsHIHUaSJk5h8XfDk8VO++a1v8+GD+0RakqUxAkev28EYQycN8S7Ouk9NKAWmCaRd23oDa9O0klKFkIq6rinLCoenqWryPKeqKwAGg6CIcs7z8isv8cu/+EusFku+8Y1vcf/Bw59+n/5r7O1/aX3hiy8hI8HWIGXn1Vvc2uowmU4pasNbb37A2WzJC9dvIOoVq/kU25TcunGDwWCAB6JE0x9uYcwZVdPgrEGJFGtSHn7yER8ez5nmhgdPjsmNZ5TFpFphG8NiWVCVOcPRkE6WUvrgyQpp654oihmO9/F1xXx6Qd003Lx2gBZQGENJgo40WRphTEmShEO73XhHdEKUedAZi8Wc88mSbqq5Nh5zdH5OUeR0sxHpeJv1ckW+mtJLM7I0pXGS2hSgUj549IzlasbOcEAUS7ppD2s9Esmo00FGESpJ0cYRNXl4HLZCmoKqyrEStg6ug4hIvKMqV+yPR0idUBY5XZGhsJSrFesiBDo2jaOZrTg5rzj8+/8F09NjDs/W/If/m7/N9evbHB3eZ7tjuTsYMegkbO+NmK0Mg16Pg52M+bIm6w/wbs1H7z2lNJ7x7i41QCP5J7/9R7z60g2cbfAWXn/xgFiUnB7nyO4uw1GGrxuizpDtg10W5xPu7Ma8uH+LGyNJcfqMp2fH5GvD6OBVrv3FlxneehEmBV5k6EhRmwrpwNMhTWK2xkOiSAeJgw00TiEESgqyLCB/16sVQnp63S67oyxopKMe4yRl2OkxWy2YLNasFwu6WU1/MCLOBngdUdmSo6ND3r7/BIdCiPaiITam0JCjFDpdAZl/cXFBXVeX9J4sGzAabjGbTxj0+6RpB2sbirLEOoOSKsgejIe2azcYDCiKPGC7qwbT2FZusaEMCaw1pJ3OpUTj8/XZreNv/NfU3tO0eObCSUrrcXEXGyckWtMdbhH1xjivKPKKZR3zsM544IekKiJVEo1irTrcLyGpS1zi0N4gqxJ9doE7fkL91ncxTmA6HeTuVdzVO9jdl/F2i0QYrExC/ozzOKEDFsMZLILl2nB09JjlWR4OVa0LWyFAhMOCxCN8e1BAUsmYxTImcQZhLEJJpLdYbylVhPKSh4y5kY758rik6iVcuXUveO68pC5zvBaISCNVTLmes1otKZqK2lYU+QrZHRBrSblecXT+kNFijmsPe2Vd4o3h4f3vY2zJ7Ze+zGj7AGtCg6UxDd3eAB2nOBze1wgHyNZvdulbaPPToD1sOeIkJo6Dj8say+TiImSIKYVSmtFoRLfTJc0y5rM5tmmoTEOn26UsCnQUswnI1S5qb8zBD+JdeB2VUgTkchPQ0c6xWq052NkLBMj1it3tHSaLGafn50RRQqQqqrJke3uLprFIoXj0+BFFWfL46VPu3nsxeN+U4unTJyidEqcpeV4gHExWhv/0h5/w11+7QW3P0CImw5PE7WE4jlBb2/SjjDjrkZQFwlkKnZBmGbIpyeqStCkQwrOMIyJriV1Nr1mTFAWNUJg4YmgMmanoVCWRsRglqHWErgSdqiA1BmXBRBEJAt00dKwlQoSJZPx5CPVnucIkRlzKFDdLSkkax+GzP58Hn5V73nxwziKlxtmQ3SjbIsYjsCYUbbrNOzM2oM29aq9L3iGVROFBBc9XGC6H39/rRQjvySvLuihZLla8/vo+UaQxOB7cf4+H7/wIW1ToOOaDH/4QhyBJEnY6HXJjWNZrBp2EVVnS7STEKmRx1U2DsRBpSOIIhG+LA493YQouhKJpDEiPxdDYMI033lM2FcIEWbPwTaBZOsBAJwvFGWJDbhYIr0IMjvOX+x8RJHth+igQStLpdSiLEtG60rxzLbQkFD2RVGRZQpGHaY+pK0Qk0VLirWdV5kHS7RxRnJD2h7DOmS9z1uucujaknQylNV6CaQz5umS+KmhsmPJ5oJOlbI3H9Hd3kZHGtDl2IaMxojQhb/fk7JTdKzfQStOY5rL5tCluPg3P0G2Bb63j2bNjfvt3fpc/+2d+gySKwmvUFp+qlUZ6NnECn56ciUvZLYRpo9KqLV6D0S1fF2zC0L33zOdzvvvd7/Gd73yH+WKONQ3ZeNjCWxw6ClLIvCzJktAQ3ADYrPVtDEIgbOJbea4QQarYYiCNcxRFQWOCd7bX7aJb9dMXv/QGf+G3fpObt25jjcNaw4t3X+A/+T//X37qffozuUqOhruUTYHSKUR97NwwXZ+ymK9RQlEsKh49PaTXHXE+a9jOJDvbI6JeDxkrtro7VO6C/CLnvQ8POZut8NYx6sfEsebm7dtk85J15YOfzDZ458mLCoNARRnzRc46rxGdfkDFupo0USij6LqMo6ePePj4GUkcI5Hsjfr0ZIxyDVEsEA6MhWU+w+OQOg3kPDz7V67gHFwcPWYQBwrZsi6wUiK1Qm/tEo+usprfD9Qh34QDkpJc2d/FiBiGVxBWMF07XG7JshVx2iWNuqzzBY2HxpcgFTpO6I+v4SVIYbl24yav7V2n8BFnzz4iBs7Ojoh2DhjvdCmN4mI2ZdTdYVKsOTk8IY0ioihmWTvKdc1y+hGL1RrXVPxHf/t/zb/11/5d6uUZian56OmcLN3HnixC0J6tOClApF2yTp9Pnj5le9DnhReu01hHsVrwh99/D2thb3uAq3MSqdFRxPzokEefPKTX3WF2tuDG7V2OHj/l4Uen3NpL2esPWc9mLM6OGIwPGH/xt5g9+RBXXrD+8I8QwlO7nJOTE6xzrPM6JLMLSJOYXreLdY6yDN2yNE1Y52u6re8rX4UCBx0x6AdwTF5VJELhhcE2DXnR8MGDD3j29Ix+L+OFl17g5p2XSTR8+MF9/vl33mG+rJDeX1J7aCWKTdOgVLt5aS9EWtPpdJBScn5+QRzXrFZrijzov+t6EW50gLM2fAaFQMdRIFc5Q+Li4KdDUdfVZafSX042QlctdNDMJVb28/XZLPX4XRLrkKWFuoa8psgNtrNNqRL09hXKexFxrVE6Ypl7Psxj3m2GrEQPrGdROd4zMcZu8yV3wPX4AiFqRBShOhJFiq2hEFCsHfUyJz/5mJNHCYc3rzE72GeGwpqGWESgg+zRSYkzmgel4e89W3NyfMxr/hFDThEyKAqUDRNhpyTKeoSziMZS6B0epXf5gbjBN/IOpXFEtiASEuECfUwIybu+yzyX1L7kK1mfSGmq1qdVLic4pVguznEiYnrylLLIOT85YjE5Zjgck6U9eoMRVVmwWs2ZXhwRJRlRFjIArTaoJOXi8DFKRVRVznD7CrZ0OF9iTUN3tE2kQgCsMTVKRQgV41sZk3cWhwXncNZgTZimj8dDqrpiMBxyfnHO7PycKA4RFZPJGWmSsbt3wGDQD8Ah6wPaP0twxlEUFdZakiQhc46qLlvdVyC3eWcxziCcCCZy4OLinCLPkVIwHAz4xT/xdaqqIl/nRFHE9OKC6XzGzu4uVw/2WSwXbQNGcHpywtnpMXdu3sIZw+T8gvc+fB/TWCIdk4ucypb80aNDop0hr/y5LxP1EnaEZ4Sh43YYbV3jhRd/meHWTYT3eOMQ3tL1nrH3uHLB9PGPefzgG7i6YJ0keKGIrWIVOQZ7V9i59VWuDA+CpK3J0VXwm1lboeun+OYQ1WjS2iKMoVaKNGnw9IkGY0Rj8OuC5Tr/jHfv/7+v1pcjNt5If0kYzsuSskWHi8CVaPuD4bC9aQpKwpRBRG3jUHiw5vIQ7FqvZZp0KMsySIPhUqYHEHKuRIvVhyQWxE7y8ksvM18uefDBOxxsjSlnM6qPPmC3KrgyHJHujJhL0RaHltGVq5wUFU+fPOPea6/xje98j0RrOklMpCU+jRFtrpZDoISgstDrdDnY2yZvahbLnGdnZwgEVVNjfZA+K6lJ06yVJgqcsZjWj4T3zJdrmsYhpSfbTGOcbxH6IeR6M/HZyELTJEIpSaIF2bAHCMq6Zp0XOBHOCJvg66IoUTpCR4JRr0PsaqbLikR6LhYFpjakWRfbNCzPpzx+fMj5YknTyiO3+l163Q5SK+q6oShrpss1qypYNtIkQUhBkedEqyVpr4/Smn6/R3R+TtQ4VrVHCE+Rl9RNaFA1pgkkSiEvP0ObzLjQvApNZ+s9VQO//81vU9cNf/rXf51eJ8O3E1shQ4yBVuryNQo/K6hRNpAVZ00gYicxTW0uvYoBugZ5nvPOO+/yw7ffoqzWWFMisAwHgfTtrWuBXQ5jHOAwVhHrKEQXtY9fK4XZZP05F4LGpaJpAW9FUVJVFQJIsoQkTcB5vvjl1/gLv/Vb3Lp1q1VbtcWkirj50m3+o//9//an3qU/k+Ls9/7gW9y7d4+kv89sYfjxR6c8+uSUqlizN0rYH3cxOuLe136J26bD5P63aZxjkHVACpomp1jMOJvOmC4bqrrk+m7CC7evoZOrPHz2lHo9J9GBgGOE4Hy5pmxq+t0OZVWwWhQkWUrczdpMqBgPNFbiECzXK2QcYxHktcHHCWmkyWcL6qri5u07CO85OXrGxXRF5ZZsDYfcuXuNK3u3eOf99zibzoi8Y39ri0gnpKoh3dpiNNjh/PARNp+wuzMi7QRfURwr0iRjbSxa1vQjxbKpg6HcSpq6JthILaPBCKsj5qsV6/UKiyNREkFENh7T6w9Ynh7iTUHSHZLFXYqqojk9YXv7ALqao9NnXJxeUBtL1XgMkqOLKc40VEVOla9ZFCV1bTn8+HuUpyfcGUccXN8niTT9cQdTlqHrE8UsliWWGevS0+uCLUsqY/n9P3ifL375BX71136OZ49PqU4nHDcdsq2c61ev01nWzCcrnPecns/57psfcWNnxM03Xufiwx/jZBpyy0Y7pNdfZHfrOtP3v8Hh2/+Q/vUbPDia82yyZLXKQ3evDWiM4hghJKYuQwEuAoyhKEuuHxxQlSUXixkNjk7c4+Zuj17s0XFK2umjdcwqX1JFlsHe9VDsVwUy3SJKM+xqwkePj3h6viAYcYKBWYoN7tZSVSVpmoR7lfEopYnjDbFKhu/hWa+X5EVBU9dkWRYuRN6TJkmgOnpHHMWoVNM0DU0d/CUqVUgtWa/CzUwIhcPivCNLUyCM89Ok+7PYup+vf82lBMQugBUQYIUjcjVlU5J3t3DbV1CdAVJqVkXDxwvNO0WXddQn8rC2gtJ5jNWs/BAn7qBFw3XxY2KxQEmDtiHQWhGhOlA4xVnvRd4bfYWPBy+wEl1KBN5bpDHEzuFbE7wVAus1Pyq6rNjDuRVftqf0OUFEHmlskMtKjTcGYQx52ecTf40/GA75QdJlSgQeGjyxtWgVDnWNFFQq48PSsWMzfu3KNuVqwc7+VabHTykunhHvXqOpLavZBY8/+hBjS4Sz2KYiSzKybpf+eId1XmAcTM4mRJGmP9pCbkcINFrFON8wOz9CyDCl7m8dgPMsmoqmaRiMxngXwr8r64nTLlIHHLI1BucFUZRe5jGJtoPtrWAyn9Dr9livgl8gwBAC0XEyvUDriCROSDfQnyim2x/S6YExFVJoTBPuV6HTbCmrkqJYhwl4S3fEe6qyDCQwGTr0q7zg4OAq1oYcMxlFPDs8ZDKd8dUvfxnXRmXEUTg8nJ2fsTUeoSLF8ekJ77zzLufnZwRJmkOgaBrLt3/4IfWr17j2b/4659qTOo/E83PbN3ht/yWEGvI80jogWySAt2TbO/yoD5NijhXgvSGylo7zvHHlZa5e/RppusVzKezG3V/SrT6E9TcRNsc7A17RFYKRiPH6DqRfRIghzTLn8J0Hf8y79fP16RWmYQC2legHVDvwqSlFmCbguTx0h++HaRmXUzUfPJ9e0FjzXB7Z5okulkuU1CGvT4XDr9YRdV2HfYtASYn1iqLNFXv48BHz2ZRnH39MPw6TEhlHbA3DtNudnOOkRAnBuNPncL6gqCv2tkcsTo/Y7qTkxlEbR9WERqZzDqnD3jceamuJkoStnS2S9RpbVvSyLkorruztMRqP2r0rqJsKKQTGGi7Ozzg/PwfrqI0lkpJYK7wIk8UwYQyvllSh8JRCEMe6DcIOTTElBMJL6rpBRyEqx7bFhhQB7e8B1UpQpRSsGxcKXQfjVFI2llVe4IHjw8c8+OgJT85mLGvTTjcBJUjSiG4Wt3l14JTCRxqNoNPrE6UpTWPJ5wuU0iSdLvsHBzw6OsQqQEmaxpAlCauiAhf81p5NbtnzGINQfIfrrvDuMle2rGq+/Yd/RNbp8mu/9msB2SGCYiGKFGmShumVCzJXYy3GOpSSxJGiaQJxsWlsUMa1vsWmsXzwwQe89YO3mC8mWFOD8/Q7HUaDMKhpGhMKJucDMFcKrPXUVU3cApiMtZcxRd5D1dThMyokRb5msVoFyIqzJElMkiRIpXjjjdf5zT//57h5/QYCT52XYQrqNw5F8G2o9k+7fibFmRQdrBOcnc05Ojrik0efUNQ1X7i1x5fvXWU4GjBzku5oj6qSOO9ZrBvkfEa/n9JPOmRpgpaKnZ2Mg60r7PQTqnXDjz54k/uPj1mUhn53BK5huVygk1B1Owt1WdDTCqcVstNBRXFIeMchpEAi6WUxV3e3AnFHa5wU9PZvorIVT558SJZ22O51ORhmnC9zprWll2W8ePc2i/kSAbxw6xbnF+cU1qCNQ8cR2zs7xFRs9xRycA2hQrekKQv6ScIyz6mNY9xN2b99hdNpQEcvy4pru1fJ4pSL04JOJFlVBbPJGZ1YM4wk67xijWHcv81WJ2KqoPSew8kZdVWy3clovGfVGJZ1ycVsBh52toYIoXnnwTHWWJqy4vjsHCUUw+GQX339Lm/cGTLTc4ap4srBFrVxuKYGb1mvDUcXBfNVzRde7XMyXdPtj9DjLeYffcLde1dIhUO7mkHU4LsDyicVj++/y+Sow+Nnp+jeLrtRwnsfPePK/hZf+sVfJju4SX9pUN01NTF1XSGzId5HFGVJ7QwfHU/4z//p23z3wTFOtDKIFiPb7XZBthtJSpI4Zr3OSXSEjmPm8wVFUaF0xPYgZXuckjcVGk06HCOTGN1otscjut0hL926zXRxgZEpH3zwHg8fn/DmJ+cYJDrSYaPWdbjoaBm6NB6MCRcNL4J5tCzLS9PucwiIbz3AwTAbbnYW5xTrdU6aJiRxgvWOTicUb1EUc+3WDe5/cJ84zTB13VKRAhkwjkJAsBSSSH0uDfosl9MR0oLINLoj6XRSmm6BFn3k3i7V9hYyjqid5XTp+PEyZu5j7nVy5qLD00YjkEQeVhbeYo86kvyCF7xg3kaZKdqUSBHhtKDRHdb9GzxOv8ij8YtMkgHGhymZF47IlvTNGis1heriJFgpqJzmY9cliW6js4Qvmh8zNoegBRqFR2J1TGl7POY63+MFvhtdYU2EEaGxpZwnNTl9Y1mrDg0C6QVea35huCTVIHVMUaw5/PhHaCHZ3r+NVJ6zs2MWywlCCmgabF2Tr2bESUK+XrN7cANnfx9nGmbrFWVjSEfbJFEUoCtOUhVrZtMjmrrCO+gNt6mbJhShztDJuhjbhKaXAyE11lmMaZBKB1Kc8RRFRWMcRVFSlgXrPBRlUiqkCqADR0vhbMmMxjTUdejg1jiqWYhkEQKSToyznjjWdDoZy+Wcpq5wrWzMefm8jGkPrcHLY1ksFty7dY9ep8d8uaQsK1brnNOzM/Z2dlivV3jvSNOUvb1dup0uw+GYsqg4OjpiNr3ANuF6tMGY4y3luuLH//C7qL0e8qv3EEoRS8WdpqJylq7afIKfHx6C9VCQC88jrZl1+tRStOR/QaIct8Y7iHQAUvP8oLF5dj2E3sNnOzhfc8k+E8HzhzhAiKtAStQbwSr+49mkn69/5RJCXcKBNverYNEP97VIh5xDKVt/lKOdcAiUDofqkEstnmdOtcCGqt2XgpApFkeaSIHSgiRJgwzYh8O+bSdMIZcqNDK6cYzMl9wddrg2HCKEIxlvIaM4kLVVQEoKBFevH2ARuOUKt17Q6fVQ/T6d3lMaHYi3zhmEjMAbtAqFpbGOfL1CIDg9PSVOUl549TUmP3ibw6NTTG0oVmusdwG2pIOfSscx3e6QsmjAhkZt2VRItfGR+eC5s2FyhBBtmHQoQqQIqKhYaWpjqJowrUSG5mtTN22zpvXkWQu+DWV2ium6JqpKhIrQIhQ+67xgPj1lPl0ipGI8GmIWBYt8TSQjSgNZGjMcDaiNp/QT7KKkLHLOypL8fEqWpry0s8O+NcSdlO5gSC+O2RlvMz8+o5el6I4nTmJmeUMSx1SNaaEggUq5sVpIqS6hK2yAMeEJ4Kzl29/+A7Z3tvnqV38OJSWdTkIchdBnYy2uDrh6BERtxJCxpr2euqCca4vfp08OefN73+HJk8dYUwdRvhdEscZ5S9OYNkcvSHONswG2ZmyY1KnwOyFMdAWECJWmDgVaXZPn4bWSWpKlwWpjrcMj+Bt/83/Jay/eC3vH2bZgDX66jW/Qt59V/9PXZj+b4uzs6JByeU6WxJS1QfsKLRwowSwvKGxNfzTm8OMP+ORwyfr0iNH2S8RFSSdLODs/ZTqb0pUSF0nSwTaNTnnvg7d59vQZykukjLCR4Y03blAVltOzY/K84uGTI4Sv6CSaRVlzu7dFKjS+BZvGScJqOgFhGPX7FFWFjBO8iphNL1DW0utk5NWKJPV0EsUg6jIaHuBNxLquOToLcI1OFnP9YJ84itCdHpPJBadHJxghGG6NGA375GVBEktu3/4Ks+kR8+ka5R0v3LzO7Rt3WSyXfPLgQx6dHCMwVM2SxsPh+RlZHPHClX0QkukypzGWvWs32e9EnB89Yrlakg3HeGMZDj39JCHr9VjnJbZcMk5TLtbnlGtH41PKqqHf6XKer0jSjL/4V/4KX3/9Ol0z5fjZEXnSRWYpsruPPXlEp5fSGxxgbM3Fu8+4da3PoN9na2+Pfj/mzW9/H9EZ8/TBU3Z+/jXOL9bktePo8RPODy8oFAx2Rxw9nvDSvYrz0wTlLC9dP0AtjuHFX2T0p75I9Xv/L4a9Phcfv8fWeo1IBgyu3KWqF/zO77zNt995Qt0i5rUQpHHMzta4Lc4UWdZhvV6hhKAsS25du441llWRo3RMJ4u5e3Obvf09ppNzpLW4fMkyX7NcL6mrHISk1xsx7A159OSQ3/ve+3z49Ix1HkhjHk8URURRhDEhh8RZ2xZnLdJfBNKTMVzmwERRRFU1lyZZKWWLeg1+GCkNIbgxY71eIYQm6nVCZyxf88O3f0gcJ0hEa0wO3co0iUizmLpxGBU6QZ+vz27ZThdiC0qjlUZgUUUNckwz2KNJU4w1TJaO9xYZJ5XiXnrK3arkRO8yE1coRIIRYFDMnOEtuY+INJHzvMibqDauM1YZx9FdHqhX+HH3BY7TPn4TaOog9Q1vmHO+WD2ljmLeTm7zMBoBEic9jVe874cgFVHk+KLzjOxjcAaPZK32+Ji7fCu5zXfEAeciBQQWicZz3eX8PI/Z8ms+qg54S99gLT2Zs1zTBdKDJ6axnp2bLwXjdFmQr5ecHR3x6MG7dLs9XGMQzhJFMd4Lks6QvatdOv0tzvxTGlNj5nNirbEYVKSpXYOSknK1BCRPP3qPnRt36PW2KIucpiwwTYVSbbZg06B0jPNh0m1tiCMxVlAUecg+HPTJ85zlYk5T15+ihwmUBKlkKNiEJIpj0iyhKmvM2oZpUlQghGQxW9LpdNCR4vzshPliGiYJPhSJeoPyxl3Oqrx3REmMjgMpbLy9Tdk4lqsVSZKyWq955713sSZMNXWs2dvd5WBnJ5DR6oYyL7BhWNECSQS67VB7Z5mfzHj3v/h9+vkp51uSWEm2r074KmP6+/eQUgVAinhenlV1zoMn7/Hmg+8z93UA3ciQD9XVmi/YmDy9RtzZY2PYvyTG+gJvjiG/QFIHydLlPzHES1y0QpLirON4sgSu/DHt1M/Xv7iCj4dLKEaYKgdMvFIqQA3aYkm139dRjBCtn7KdmmwKErzH26Ay0S2G3DRhUuGkChMLQvh0gOZ4KtNOMVSAMljTAldVhNSCBs/hckYsNT6vcXGM1glShwP4Is95fHSEaCr6aRpQ9sdngWwMqCxmvmoQLZhn0HrFS2dR3jPwIWBaIhBJh4XSrOZLsjhhS0sOXNnSBT3SCajBVoKiNlwVAdWv0w7rWvPxYkkhAW9J4oS8bFitA+Uvy9LLSbWUkiyJibVmXQX5aPBcPSdCx1EcEPwtUn5TPODBqwANuv9sght26ElHmqWslzmzZc7pquK9kxkX6zVaSK704Gp3RG/YZ7y7y3rdkC5LRgPD0XxJLjTz1Zqq8bxvT2kGXba3xkg8Ssf0hkPWD48Q2nEw6mKFZLpcsVwHpYCQovWPPfeFhYByHSSg3iGcBBmw+wJo6orp5IzdnR6bKJoQ1m2IItlSLEMzQAmBkFFb/LjLSe7x0Rl/8Ad/wAcffABYokiFgPP2MYVCN9B5Q95s6ztu3wfVwkxiHYKhhRA0jWFd5NTGYKxltV7T1DVSK5I0ZtjroaIoxBR4GAyHjIZDhPV4gtUpvE/iEpRyGSb+ryBS/vdZP5PibL1eI1QI8j24cp2sO+L+/fus1yWPjia8fGOLblXyO7/9/2Y9uMbd3TFbgz7T6TFPnxxRFQWDTpftnoY0oywKnPak3REv3tGAgE6fg+s3SbM+04tzerHDRzGnZyf0ugn4lPPpioOmpucs1puAk5ZwtpxSNQVahQp9a9Cjk3Q4OT1ECsf1K/v0exFSVqxszGxdE9WHbGd9DudzoqTDcDDmYnZOXRXEUYdBr4N0lsPFhPUs53hdMD2/oCyX3Lh1g1XZcHwxpahrxpHHFBOaok+3PWR3BgOGvRHnkzO2dg5YL+dMLi6Ik4qGEFA4Hna5vRdj8hkfPXwCWcrBlSskusvs5JTZ9JiLecbZ+QXlfE4iBfP5At8fUhqJkIr5fMFslbO1e4WXb1zl7n6H86dnzKdL9vcGjEYD6rrm4PoBpqqIk5jp+ZpXX9zn9t27LJc5g+mU7/z4IXf2Orz53ff5pT/5Fda24cH995nnjrrxCCI6g4TJbM2wr1BZRKJiXnr1Lv1Mc/HgLaz/R3RvfJHi9AGLY0NTFZz+4X/N+NpdYr+myrb5owenWC/abBSCKTaNGQ2GrFYrOv0eja2RHmbFmm4ao5Tg9OKcxoUQzet723zh9ZcR3rAqCsgUZVXifNDJO68xQjBfzJjNlrx7uODJJKeuQ2c7NH1ESwXa5JFoGlXjbSAHNU3IihFO4ETDBq1vTMiwC2ZYi7UOax1CeLIsu7wRLhZzFgvQUcR0KkjTlO3dPaxpmE/OiaIYKRVJEqOjdkRsHd00Bu/brJrP12e1FCC1wMcKoSKki6nTLVxyjSbpYYDZ2vDhMuG00HwtnfFaesJefcSk2sdpy3ej65QiDrJEJyhQvK23yeyLDK3lRvddlKs4rQ5419/mu+k9Hkaj4LP1PvgcnOU1d8qv+Qe8rD/Aqx7byvHfurs8ZkwjFF4KGuH5wA5R3EQ4w1dsRZ9nFKbL4+Y6fxTf5jt6j3MfY3FoErT3XLNz/rT4hK8mjxiIBbeaJfiUH3AFj2e5mFP0Y6IkxVU5s8kZvcGIB/ff4dnDQ0ajIfPJlLSVjCRxglaaqiyZT86RMmJrZ5+HIuQgWdtw9uwJW9evt5AOQ2Mqst6AxjQIqZidH9Pvj0myLs66VrpSBz+IMaSdENpcLoORfj6b0R2MsNaybE3i29vbLBYz1qsgP3YhRbzliAQjfhyH6f5sOg/+GilQWiO0J4ki4ig0TyaTixaj3B5QXPBDxFESpubiuSdDADjIkg7nFxeUVU2W9YijlLKsyOIORVGTJClaWzpZN9DVBKRRyvvPPmS6WGCNQ3qBse3j9g1agZASa0omTyZEv/0RvKBZKMMnxwU/zDv4GxdEKgIhEar1HQnFfL3k7fvf59F7P2DuGkJhL1DAKE55/6LmVdvj9u51pIoQUl5K3Hw9x63ehuJbaBFoZ4GkKfEiRmQlcjBGxA3TyYIf/vBtfvMXX/oMdu3nK6xw8N/IEgMchHZ61vp4WlpdkD2qkMulnhP0pAyFxGYqLLSiqZtLD7aU4YCstWJnZ5ckiVkXOfl6Rb/X406suZgsmMxXpFmQ+jemxkrBpCqp0x7G1CQK7lw74PrNm/SGgdLc7XQ5Ojzk/nvvcfXqNV5543UeH59QrNeMt7dYzha8eOcuP/rWt5g9PUFFisJrKtkQocALvHQoJ5F4GjlHPj5CK0vpI8Y3bnK2XpJkPVarBf1+j3yVs7+3Q7VYBM9SS/GTmWQ1Cxls/TQiVpJGBhljVYVpuVabafPmtQ3k17jFsjdNAP0kcdL68eTl2ePTxdl0WTIe6OB1K2p6g5idnR2WkxnzZc5bT084y4O/b9jvEsUxV7b6dLKUNMooBHS6ffaFRlrD1VXJeRYRJwmjNGNn1CPJOmgZ1AOdpIMHLmYrtgYDrPEYG/LpQuPLXgI04HmD2lobYGmOdnzEZSdHCM+DDz9iOZ8xHvZpv4hXAkk7NRQbCS14ZxAtIXQynfON3/9DvvXt77BYzMNUTsLOzhgl9WUOmZSbDD/JJieuruvwefdhWhvF8eV7UZtAsNzk0xZliRSCLA2eMqUU2+MtirpBKxfiCOIEJRyR8jTOEElorKdxErfZYpe77TOUNf7C115HRTFaC7ROOT+bEMURZWUYjzrcuHUNt1rx+utvUMotitMPmJ8lfPTogovzY7bSmN61mFoNcJXn9OQZZ+fnZNLTjSOmqxXbV3ZRB9swn9Mrl7yyl6K14Oov3sPIiI+P1zw7nbBe5YxskIOVZc3J2UfYyTnCVfR6KeSOs8NnbI1HpFGC9RbhHXVpWC3nrPKaZWm5fWWXvKiYry54+YWvsr09ZrDaoiyKsMFtSaLh6sEB43FJnjekcURy5YAGy9nhx3QFbI/HpD7n/8fef/3qtqXpfdhvhJm/vNLO++RTp3JXFzuym2yySaptkIYogjZgA4JBGLJuBPsP8KVhwPeGAAtyAG1IJmBLNlukSHauqq7qCl25Tg777LT2Sl+eaSRfjLlXtQQIUDfKrAufAeybvdfa61vfN+cc433f5/k97WrJx31LmY/RyYiTkymb1RUfPL4gq0p26xWXqw0q3fPyiy8xKjQv37/JfD7nJ+++gy4rxosxN47mhE7R5xm2K9nuW9brK/bbPfdu3eSVxWusV1u2a8t8OuHs/Jz9rkFnW45vHZAWJb19wvHBhNBuKIShqXdcNoIkGC72Fp3n3HvhNlmSsA2ASni6cZhuyUsvH/Hux+e0Zw9ZbbbkqeKFGzMOjo9Ytx278ysOFmPGxYS7xxNO7r9OmN2nubzk/P0/p1s+4eSlT2PH93n85/8f6rMfkttTRi98lu98cMXZ1Z4kyUCDFpI8SViMR9jgkV7Qtx3b9RprHaYzzA7mXK1ihgVKMZ+U/MovvsHNoxnPHj9hMZrS9g11Y0BoEhGYTia4/Abvf/AT/vSHH7ExacTQGhNzSZKEJNEEb+n72C1MU40QJdttHTtGg5FZIJBK0HU9fW+vwzyVioVa3/dAoKqqYarWDX8XYQGBQKJj0Ge935LnBUor2ramKisSrRiPyuifcQ6NYFaNuPLbn8Wt+8n6K66b5nngaDScN+WEq3yBTab0JNT7jkerhF1a8Xdfr/hUapimc9Jec68P3DArTmzFv2yPuPTgnUAQ2DnJ99QxpXb4NCf3G97yt/hW+irvJyNcsCQ2bjClhi8lV/z18JhPladMpUAkjio8pbCK3zOS95jQS0VAUKP5gVvgpSDpDS+JigtX8afyJb7ub3BBSpCgAojQc8eu+LvhY34x+YjbyTmajir06M6RYflmeofvbKaoq29y42SO9YKL08ds1mdcnZ9R72pu3bnHzVs3YmdYxoLA63joXy0v6I1D6YS0KGAj6buWd997i09XE+6+8gb17hK7vqTvDGU1BiTeGpbnT7k3mSLyEW1XY7sW03VIa1FJTlFOyKsJ0f+5Z7ta45yj7w3b7ZZAoKpK+r4j9RG775xDSUVZVYzGFcvliqZuccOGn+Y5o/GE0ajC9B31rqbeR4nkc3y+9/Z6oqSGQ4IjSpGVjHQ8pSQPHz3k137l1/nzP/82L7/yGlU1Ik0TSARlNQJClIKlJWfnF9jvf48bN+4gQsCYHqUgLwrsdn99TT4300sZML5j+eEZXxzf4aV7M0Z7Q/PkHT7cXaK8BUcMOk8yhNK0zR719CG/vLY0QtBLibUG37YouSW493jfZ+zmN1BERLjUGqE13qzo19+H5u3owYxVYiSqSYHOLdksQWR3eHK65M3vfhf4n/xbvmM/Wf/tJYS8JuRFaWwktk6nI7a7DcEzNC0GwqPSg+zuORjExs+Y2BRVKn7mxsYw6jRPUEmUj3nAeY+xlrrZoeSE0WRGPzRXIqE75nkaAevNDvA00rHa17yU5yzPL7k8P2c0nrBp98wXc05OTghdz/rxM8ZlxVwXnJ5/RD1dYLOcdjZhlGtWJlCmkl5I2t4yK1O2TZRCH0wLsrJi/fQR7dYynky4efuELMnZ1TVlVdDULdPphPT8HOeHzDcRd4D3Hj4CogxPikiQbPtmkPqBl7Ewk8NUDyKW33oPMmadiSAIz0OdB1+s1glYO5AEPdu6wS4OuD0vOd80KF0yGk9pdjtMb3hhPuHuYsG+abhZ5dw+OeTkaMGkmpJJSYqgTHN0otFSMV5uuD0ZzhjjinI+IZvM8FKBjzLQEAKTMkWrODX0xOtESzX48OLk9HmxrwbUvRBxmiSlHPyJFq0TjHE8evSY3/u9P+Lv//1/By3Vc3QADuLU/dqvFd+t/a7hT7/+Lf7kK9/g7OI8UhQHgqhWkiLLMF0f8frWXMcPGdMPRaK7Lhyl9TgC+7qO6ooB8rbb1zRNg1aKPEtRSlKWJVVZkWpN1/cIqUiUouvjzwreY43DOIEhKhmcf16IxenZ81/j5yZrfO3uDVobMAjWmy1VLvnc6/dodjXzxYSgCvrU8dLBFLvfsHUZVSq4dVzQ91M622GyikZmCO/ZNZaLnWFSpbje0+x73vnhB5yfRgO00o6/9rnP4ruaMs/Z77dUoWWUJQTpUAKk89TNjrq1VKkmCSX59AiVFFjT0RrHfnuBt4bRKGd8cMLq3PL49JQXbp5wOJrxk3ffp/WB1fYKkUp86MkTjXKCfWsR3jKdlNwe3eHR0ydURU6ST9nsLplXCXk2Zt9s8C08XTW8+723mSwOeO2NL+B9x4cfPyCtRgTXU5YlN4+PufXCi8xObjLPFakwXC23zOa3Ock1h0eHCKl5cPaAtl0zHU+YT+bcOjri/PKSzvQUecV61bFer9k3LfV+hwmWGzcPORyXdPWeJFV0bRMT3rMZabLl/ScbzlYdLx5VfObTh7T7mrYRNE3D3iT4tOKqviL4kqvTZ4zGE9IAN2/f485rL7Ddr9nuVuS3KoSwzMYlszKBfou6+QrzL/0P6b7yf6cqU4pXv4w5fA2+9wd0u1PaqmX57JyvffO7oDWZVGgZ88GqPOdwPov6diGwXYcWChLHqIrdZhfAC02mEj732j3u317Q1xtcXzOfzGj6HC0kVTUBLei6hs5ccPr0KU+vWkQSCWwhxFwxKQWJ1sOBK94iR0dHbLexa/Y8WNoNhv+8qK4ljF0Xu/XG2NiZGYov7/01EStNU7z39L0jz3KqqoqdHefp+47Dw0Pq3S4WbE2Ndz2TqopJ9sGjtRjAI5+sn9c6KW9D1wIK5JgrPeJZOmHvFXVT83gNPp/zP/+Fz/CZl44o8hAlPCEGg74RBF/uFV940vN/+ME5H6/AI1HBsfKKr6YnLNWIqTS8X5W8r6rrzrYQgZPS8+9/esbfOJ5zpE4oxOcIDOhm53nVpXxxX/Cff2T4w2cOGxReQqcVP1CHWPcGb7QnrLTmG8mClUhjGzJ4Egdf6Jf8ezzm87MlxwcT0tEJ5CUhzbgjMl6VU168svzXT+/zzKT8ynu/TwrcuP8qevYik4NnhP0TumvZoSCESODywWFsh+9r2nqHUhlpoqLby3tM1/Pkwft85ku/St/WVKMF1vU4L6hGJW29Y7064/HHkrsvvsFkPKORO6zpsF1Ls1+TJBlFNSMrCra7hr7vKYoSISRNXbOr9xB8bKTISGI7OjhgsViQKMl6u2U+m3KwWOCcZzweRZBB13FxeUnXtfjgaeo2HgCMjTSwIZPnuSQpxmtI0jxFCkmaZxyf3OTs/JKfvPkWb771Ng+fPOHWrXvMF8eYruPo5Jj9vmG731CWJc5Zzs+vOH3ymKatmYxnXFxe0fTd9eEDiD5UEZs+WEvbCt595xm/evczfGpSoaWDbg31DtV18UCYj/BZyrjreVU67k8neKGwVYm3FnZ7ZL9H9S3Z2cfY3RXeGMS+QfiASBOcCrjuirDTuLbBy5SQKZzSuGAQ4QOytEZlx7T7ns82Fz+/G/eTBUCSpLRtdz31QEgEbjj0iuFZI+g7Rxiua2mHJoaIJLooF4vTE9nbwYMGidbXYdNZmmFMz9XVFW3fIwVstg1t65hN5zHHKyiSFJwBb0ENjGKUYjYZkaaa3W5HvdtyeXbOt3/0Y4zzfPqVl9Cp5unDjxmnCZiOR++8RSUD3/neNzEy4dbtO2gCMtcI7xhXI3SSgukpqhEGaNuaoii4WC5R+zXBBRbTA45OTthsNsxmU1brNcFavvv4B4OnNGLzXSC+DwI667CD1zTPErquR+t4OhcejPeoTCK9xzpPb3oCUU7qfCwknvu0VIie9jzPhqIjFmmNE9xZTKhSzeGkIksTDheH/PZv/Trb5YqzZxfUjSErChY3j5jPRlRphgwBGYjyZ5VxeJixmI0xxiFCINVR7YSMk9LeGuq6Q2vFQZ7jjKVuewR6AGfEqKoI67BESXWIBcxACkd5vOtJtQY0wROR9M7zzW99l89+/gscHRxAcIOcVsfG9/D87HvDD3/wY/74T77C6bPTGCdg7DXYSUpJVZXXUzIw5Hk2kCIjbCVghsiEeA0773CD3LHvDbv9nrZtkUOcSlHkZImmyGMGbao1QsoIH/Ge66xQIdi3nnUXkAzyVxGnZEM/41rK+Hzf/suun0lxZvqG07MrWjQ3To6ZVSXb3QZxeECWpTy73KIzz40q4ejkBZYnh8xGFS/2Dmd/zGXtSUcFh0cHCOsRzjOZFowmY7q6I60mHOkUa3s661kczWn0jA+fPEAmKdPRIaOk59NZye27h1QlmN1jkmbLK8cVhSzpjcFJwSgd4cUBZ1fnjOUU5UGlJYgEmaS88OJrvHh8SF3vEFpzMJqxq2vsPiCdwTYt680epTWTquLG0W280EznCw7HY7puz8rUNF2GD5Jmt0PRMplMeeGlT9OiMb3j/Pwp+7pmcVBQNxanWo4Ob3FyOOXgYESuUx49echbH72DVgk3b92l7Vra3Q7nBcV4Tt01PH32iEIquqbFmpYyK3h8tqFxnqA1y12DN4HzswueXa04qTRaJeh+yeVyS98b/GbDd998yudenPC5T98hG5X86Ls/YX4wY1RltLsNpfKIIuP9h5f82t/42+SjKce37nDj/j18V1Nt99zQgqfvv8M9veRA7AnC4JaP4OPv02+uMNZBeQAHd5E6QRYVaRhj0gm/+8ff5ScfPCXViiJNESrefGmqo/aYgFaSfRMN/LPZMZuPPsJ6g1QSrSUv3z7ky595gXmV8/DJis6CDn2k/EhFi8Z5hbc1pjO89/gMGwTKWby3w8+L1EUlAK0pivy/EZCotbo290f5hrz+8xz6YcxArQrPc04cXeevMcTPyXFSStq2jdp+JQdNdWC32ZBlKc5ZCA5ro4xyVJboRGNMT5okP4tb95P1V1ziC7+FuDyH7Tri44VkYwO7pubJVc16lfN37qR8qYAilVBloJPrw1AAcuB/sPCkRcL//uunPNkrbBAIJEuv+XbISYFGKWyImx9KMisV/+EvzPh3X1swzQWKw1iYXZuAYBHgpgvcu2kpvnPKv3wyXI9E7PVPqgM+zsYYD5sgwYMNkHn4cr/kP2of8aX8kkJYpJghkjmUUxjPCKMxd8sxr7aa4+qSf/r2DZ5Uf4MvpOdkmUAm0S+w310iaPHW4C0IrcELhHAQumt/Vttc0Hdt9JMM07X9fseH777FwfERF88+pigL2v2OLM/xBPabK/pmi5Zw/7UvMp8fsN+vqc2WZtnTdo5Er1Fpxo9/8APaZscrn/k8Ska4z2Q0ous7sizjhXt3mc9mSCm4XC/Z7XYEAtNplFJ2bcf5xUU8IA2dfjfAgXQWg1UDDp0k2G4olHQy0NEEQUBeVXRtx+LwmNu37tG27/Gd73wb7z2PPn7Ibrfj8OAElWq2ux2joqTrkgFqAuPpnLo1bHdbkDAeTehNx34fqbhay2sIESJm8QTnWG0avvrDB3z65ucpswInBciYCymH6ylkBUoIpHDIVCGUxo3ncWLY7BHtHuE9ochwqYLQoFSPsD10YCcTQnaAVBmoDaHrsCLBZCWegKobsv0W1fRkSUn1yuzf8t36yfqLK4TosXmeyykHmVaiC+aLBQ8ePBoyzeRAAo0+MWufY85FxL2raL+Isv2oFnHYuA8GTwievm2pdzukUjhrcYR4SPcdl1eXSBGLG2ujLWA4l5PnBVJIuqbn5Pgmj5884fziks1mR2cMQkgePHyE8oaXXn6RZ8vHmK6nbWrmiwMeb2PO12Zbo6SgNTEeYDEZk5UlaSB6iJyJ4dJBIoRFa02SpREQNMAogg/0bUeW57S94eL8KvqphEDrJMqfTce26ciSBK3g+OiQv/7rv8pmV7M4OODRw8f88Cdvsa/bWFioOMlJdXqN2H/++I4+1YCSsdjxzqOUYFTmeCGYjAsSPEeTEuE808UBrusQAZI8xwZJXhWkeQZ9i0SxXa5pNzWoFKzHp4o8LygKAdYOn3GErYUQYUBtVzMrMqyz7Hc7VFayKAsyrThftzTdDq01k+kMMUg2+96QpjELssxTIDa5q3JE33eAJMsStNL82df/jKODg9jUNj1f+NKXKIsS7zxvvvkWf/KVr3J1eRmb6V1/LfX0Pl5jB4s5RZ4hCNE7bN0Ai2GgOcZJrsTjiDTR3sYm+Wa7jVm5Iuac5VlKlqUURUFVlkzH4yE2aYBFOc+2aYfPPPoEn5MjJZGsTbgWxl/jlv6CWP4vvX4mxZmVOToraTc7dvs9qdQY50lUfGN6FMZnPFxbTrdrNts91ahlVuUc3brNDZ1RFRVCQmctRVkQGontLUWWYA9iKGiqE1IdeOmFl0iUYjYv2O823D25QZHkbJo9J7fuYIzj4ydPuAgrTkZ3ydOUq82Wdr8DrfF2hzA78jQFFHXfEq7OUAJOjk6wCC53WxaHx+RZznR+SF33XDz+iAcfvs+6C7z06ouUJ1NCETfTyfyEIpUoYDyZYHrD6tkzmt2GECRnoqdPNOPpnMenz/jBm+8ynUxYhMCLNybcmd9FFjl5AgmO3f6MNFG89sqnIkpWJpw/O2Vfb7Ay5fbN27RdQ9u1bC+vwHe8ePcelxd72raLF7NUlJMxtbGs1hu+8pVv8e/+/b9Nkucc3zzh2fkaigM2y5bb925y/1ZO3xouLh/w5OkztpslL73+ChLP8UHJxx9dcmPxIl/463+TshqRJCnGGGQxoVIFttvxyiLl/nyB8hnd2QVXjz9GLn+XoEpUGg29ou8xtibFUd3+Ig87x3fe+xZSC0Y6w8tA1xm0kpB5TN8xmk3w1hC8p5xMGM/n2A8+BCVBKI6nY37xsy+QaMX7D59wvt4jdInbrxkXFdZ7WtPhbItvO7734WMenNXMF8dcXJyTJAl5HjNN5vMpznR0pme/b+j7jrreU9d1lCm5iHsVSkKAvm9J0xSt5ZBPxrU0AR/H2z44rLMQGDau6Guz1mCtoaoqQvDsdpH0ttkG8iwlTzPK55hZ05FIuHPvNVbN7mdx636y/qprcYRLCsR4R7NectrVLG3Ps+WGx+eOly43vFFK8t0hrDTCjQllCakGpeJGI6BIJL95Z8zjly75T35Sc+UyhNCgHHXw7EPUfASlkUAu4R/dTfmdOxPm+fMN/ado9OslQGt4aa74X37+iE17yleWGZZoyvcEVkKDiAGpQkASAp/Lev4XC8sv+ZSijcHKbDsQLYgKtEEkBplaDlLJP5wnLMuGZ2007NvQxiIwy3HpHC0c3tX0nYHeEDTIIGJxA5jO0TY1rmtRPqCVQhUZSZLx3ltvMp4fotOKrt7Qty3NtqAYj9lsNrR9y7s/+T5d1/DqZ3+Z2fyQq9NnrNYrkmzP02cXnJ+d8uijj8mSFBcE9X5PWRRUacJkNiXLM6QIaCFZ1y15Vg6+OEWz39M1hv1uj1RyyEiMMBAlBaOiiHCDrkWr+KbnaYazQ4ZciH6T+XyBC46iKimy2Am3Jkqe9/stznsuzi7o9g15WRGAcTXC2NhZPz5c4AaCmDE+htVbQ5okiLJku9tHT5AUgxdMIJ3HeUdvDT98cMF3333Mb+ZpDIHtfQwX95LgeiLgI3qURZKDksg0iyRIF032QQhCNYEkAg6CAyk0SIksJlgZ0eASiZeRbibGs+jvERvYN8jgSAvJaDb6t3effrL+O1Y8Nj5XpEgp6PsWY/pYkMm4r4YBmY+P+LnnHrMQngNuwl+QRw5UveesKiHojSUQJxdSxmKGwLVUDy1ASKyDcVGACBzM5pzcOMH0Pb1pWa5X1H3Dttljg2VUZTGc2nvee3pG7QKenv2uJgTor64o8py6WbHaR8iH1ipKKwPkScLBZMTVao0OjiJNsQLyfMqyPuXpszPyIudqtYmeq8slAejOz7m4Wg5ytUhINc0+wslUlC0DtH3PervjrXffI1Gay7MzrOk5mpes15AlKdNJSd81CCnoB+w/CFSiaVtDkmt++2/+dW7cvM0ffeVrPHr0iOl4RKIELSlV0tH3Bmt6sjQn1QmTyZhqPEZojQuezWYNXcNu84zTh1fsjYFEMjs8gU6gxpaMFBEiqdYFjycQEkcQglRF6NR2VzOuCqrZGKM0MylI55LznSbLdWxsCYlSmuVyGRvVWpMmGp2kdH0bKbtVSghjlBRoLXj6+BGnjx9HGaSSLBaHpFnOn37ta7z7/nuE4MmShCRRtI1HasXNk6MImiGQ6oTgHUokNN6jtKYoCna73XVsQde1BOfpekNvLfV+T900gyc4IctSRlXJaJCVa62jlzJwrYZ6/vuovr+WRwohqOs9222OIu7l15m0P+VLxfvjmlHwl1s/k+KsrvfkynP3cIrIU2aTCdLPY2aBkjhvMM6hREQTaynZbXr6uuNwPo+HUOVYbtbUbY/UGeW4pMgSDg8WlKMxMpFoAVmiuXV8ghCKPMtYXkFVpqxXO0gFi/kRZ2dPyBLF8eIIEWC9WdP2PcZZbBdR6ydHx2RpSnAdTd0iRKAaj2NYqdDcOLpNqhWp9IxUzyQsGWU9xc0ZZ3Ug0Ya+3/Px2ZLxZIHH8P6DhyRKMS1zmq6jLDWTbMwqlOytoFKBk1lJu9vxxRdPuHV0zHyUczzOEAguTEcuEoztIQRG44KD7AjrYHl1SaYk+cECnRVkmSApJrySFpwXI3Tfs9+2/NHXv4tDcXwwZbvesN7vCLbn4nzLd3/8Nr/2G7/KremCjHtMHzzicr1kRcELJzlaxoyed957yL7umI8Llqsa1+6pQqDIc+ZjRb/bM5sd4XGEIK8nQRO34fhAoI2J+RrTMaN9Q71v6LuWJE2pl6dkFw8w+pDpy19CVRnf+t1/w8OLVcycEIG+j8ScNNHkeUZe5MgQ2Dc1SZ7RNA2st1TjEU3bMa9yfvHTd5lUmvOrK9579IA8HTO/seDq9AFpOiLJS/r9ChE8Z8st3/7huxwcHNMbO3RQIqEtzwuqqsJ2MQdps9kPCPxo9O9NH8lDg6zhuYr8L46thSAKkEVErPrBmPp8MubDkA6iFGVRUhT58CAACPTGoACVxcNWzKMS1HWNDJ71xVOskD+LW/eT9Vdcz3yNzgWinHMqHU8uGtZXDRdbR9btOQkreP8d1qtvEo6OETduIo5uweIANZqjqjEqzwhphraBL+YNv6w3fM0fsFMqoqoRCO9BxKJFK/iUXvOLaU8mZtGnJq4RNoThmri+Joei7WYR+J2F44PNjo/DKNZjyqFCPEipodt4Q3X8drXj9akjkZqwLglbg9hcwu4clo9hOkdMF4T5gjCZMjWOv2me8Y39BlEwnPkEEsH08Darp2tSnZF6ibEObz3GO2zb0TcxL2e/29HutiidoJSmSCaoPOXw1n0uzs6oyozlNjYxNutLivGErJqxOvuIkCZ89M4PaNuaV974ZbJqzI++8ickxYgHDx9z9vgpUgbGkzkff/QBT08fk2rFvXt3mc2mdH18DW3bMhWSNElouprVasODR09o2o7jw6PYde1WMEypJpMxIUBdt2RZTl6U1PtmkErG6XqeR1+0kJL9dsfBYoExjvfee4fV+pIkTch9Sdd3OOvY7ne0fY/Wmr7rECL6yrre4J1htV7ifOxyp1qx3e9QQiKVwLshxsOYa3qaBJyzNK3gz9+75LO3DzlaVGjToNoWnAUNrt0RvEP2NartgXgWl1pBWyOjsx+h00hNDgKCwKkIm0EqQpLiuh6SDF8qgk5w1TQe1HuHyeOBRiQ5Ls3/Ld+tn6y/uLIsu550PQcmxGahZLfbkaQJ4/GMNKsijt71XF2eRSLjX5wCCJBIhBxofUOR95wAGokNimTwLgkZ5ZJKKITypJkaIDmxOEMoqjInywu8D/HaNz3WBZwFpVJEnuBsH92+QuCF5fTyEqkGIqTz7PstWZKiZMwTXRwcMJ+M8c/pgN5zerkCwKNxMgOZYZxHSM1m1/DnP3iTtm0QIdL+rPfkaRIljSL6qJIkoQ+OLCuoRiNwfYzSCOAcLLc1R7MZtmsJ3nJ0uBgy0ARNH2XaIgiUTjmclkMBKfE2wsO89dTbLS/fu0swlnGVoSRkWjMVHca5mKeYOZzpIYCWGmccfVOzv1ohmoY//sYPWPvATKV8//yCX75/yb2XX0AEi9QpOAFCYQlYAniNTLOY3+Y89Jb5LMUlGZLAut4jvGGU59y8fZubx0ecX1xweXnFtEzI0xSpUyaTEav1mrLM2LUdTdvHM5NUNNbS9/0Qz5CQJDn/+t/8HvvdDkEg0wqtc5zzdMZQVbERppWibmuSNBZmQopYbHmP9Z56X+OMxQ2Zc/t9jZSK3X5H3xmMMaRpQqI18+mUxWxGlmU4Z1FKDwTuMDThYw6gcw6S5Pq5Gv1m8PaHHzO5WD+/2geJqrwOoQaGWi1GRfxl18+kOJunCpKUyagkzTRZqelNoHYOLySSDJ1KsqRAyYSm3rLf7TG2RRLAO1rvyfMJSWKwQWJsj0pTVJYiddxk9m0XR8bHJ6QCpuOK+fQlEqm4uHqfrrWcPXtEXe8Z5TmHhwc4L3jngw/wHkbjOfvdEu87puMFeBBJjpIp1aiiKCd89PBjXN8yG1V4bzC242K7IdEwmy24qQXVvqZLC5re0bZbpuUI4Ru07enrhuXSc3p+xq1bx7zy8huMFjdYrmv69RNOZhPs4ZRw/w5ZUSBx9PWap8tLxOw2rTWoTmNdz6yconVC123o6jU6lUyPTsizMc8unxFwpGnJ5cWef/P7f8rp5RpJYD4dk/SGi/MLrlbraOqsSt57+33+9Gvf4n/8D/8Orpki0orlg6ec3LzBYeGYTRc8/fghT5413DtKCSpjeXlJqh229xymhmTziMdf/136z/8mxdEtdJKiZGBiLjiQlyjhCL0FVUHmyUc5yeQWbe/ZXzxht9+x/up/AemCG1/8DX70w6/zh3/yTYx1qETRGYOHOJmCwUkZ6PsWqVJUknL+7Jzee4LzjLKET714yJ0bMXz8qumZTU+Qtqe/+IhMSWy/RUiL6fYYB0+urhDpjP1ux9XFJX3XXXfyvHc0TUOwFtO72B0WgSDCkCwfuyiT6ZzxbMrTxw+QxM2naZprauNzSpsX/qfY+wBSKlKthy5N1GfHTrpFp1HvnegQZZxpStu12LajLDKUiF2Zrt7ik088Zz/P9cH5u9x58QuMZkdYHJtHD3i89pzbipdngvHojPfbAHaLerxGPH0fpSQyTdDVGD2bkY/nqNEUVYwou4RP28B7XUKXzuIPGchSnVQEEZjhecVvmW/P2T24YptIdIiHcKQiRA78UJxJUIN/wHkO3J7XneDcKVpdIEJsWlsZA09T57gnO+7lOygCl21DCHtCf4HcXCHqbZTI9B2y70ArwmKOPbpBWefcJIdwglQ6yjgCqKxkenifevkxUlkymWCsRYskFmm2ptntECGw2+3QmSLNcxBjxpMbjEYV1hqElyidYW1H3/bsVisOTm6x255Rb7Zko4zzZ4+pqveYHt1F5xUPH3zE2bNz9vUaM4TFn54+RgZLkmqa/ZZ79+4ynoxp2pbdes3V1RpjbQyovlwznx1wf1Syq2uePXoWCbqzOZPpmDRJ6a3l1u1b3Dg+4ejwGOs8TVtTpBlPz05ZXi4JwrHZ1cyzBZPJhLOzC/b7Lb3pKYsShURLSdu39MbS9g3aaaztkQoSJbg8v6R3lmpcUpYVUij6vqVp6vg5E1DD5/h8ucEHo4b8oQdXW55etSxmI1KlYYiaCc4RXI93AdVbRN8hUIiuwXtF6BpoGzAO+pZQdQRvkPsdomvBDwfD0YhgeoJpUZ1BdA2plphEI71FDh1kYd3gXfpk/bzWZBIped65OOEUIu6/SiKJeZtKgxKRcJckmuPDWSyspLr28Cj9vKgbCu9hz36efeZDwFkfA5YHgmmiI7nQOBun5EpdS/whqk2226jAEiKGsBPa2OxIc7I8wzuLtWbwOkWJoBiIqN55gohFWFEolFQ0XU/97IIkjYHuyEiW1FriAyjR4oNE4iCEGNFhLEoJnI1yyLIoOZiOGOUad+0hEoiQkecFxvRAcU2xtNZEEEYIiDwjzyakWcq9O5GGGBvaNkrybGTH61QzHk/xzpNozWazYXl5zsXZKQpBs+vi1ChPuVuVPDu9ZNc05CrBmR5JDOy2zrCvG0xvsG3LOE+YpSV5IvjrszFFFu//tndI2yIsBCQmgBeBYBQacAjGac7sOGMyHnHadzjv2O72tE3D4ijl2ZNHtPsdm13Nbh9jpPIkoTWWpm1xfcvJwQFN2w0gj0CIwXBY76mqiKh/8OAhvWmZTSaMq4pE6+gxk466CRjj0FqzXK5inIOVOCw6idYSMVxz1jvqrovXl47o+329GSa3kizPqKqCxWzGdFRFMuU1wCTKd53z13RHgPR5Uc7Q9FKaEAJ105Nkz6XBcoDn+GGqGqm1DB7rv+A4+O+9fibFWTYpubhYsjo/J08TUnnB4nBBNTqgHM9YTMbUTcv5+Snb9gpISPKCJCQIbxBtYN1sQUmSRJOkKUle4B08e3YRNwOp2O1rskSghebgcMa4nNDWOzbNHq9yRtMjbDAcHcwwfctsOotFUdew2qyxoxFFNUMlCXk1whvPdreisy2JSzGbDc+ePsHans2yoL66YJJKUqU4OpiSJWNkkFR5oO0M9XqDxPLw6gEZCt21bDeXFFlKPjkgHx+R5BNs03Jx+iEH04JkOkX0BvoWJaJhVqg5h+NDqsPb9MLgyHBtHw2mLoYMWlfjk5zVboluWrquQwVJE3Y8fnrKo6eXSB2NqGkRO5OXqw3briNTmmmecufVF+jbHdv1JdJKZse3eaGpqbsVp02IWPd94AufuUtwjrZtyHBcrnsmWeCV1+6z3u/58L0f8v/4g+/TGMuLd17k3/+Hv850btGzA4RUhCAhtMh8DOOAmr1McvQG6gdfheUltmsgz9jsz/nat77Pg8uraCAV4AfttZSCLNEE56LXIwiyomC9iTKgruvwpue11+9z69YRQVWkRUVuoG0bds2WKi/Ii2I4cAWSfITyhvOdo3OO06dPcdYPssNAIiVJkkbZohKMRwmLacV637Dd7sgzTZokBAT3799mdnjI6eOHgw463sjxRv9vaozVsAk9z02L3qDBoOoGLHGaMJmOUDqha1v29Y6maTHWUKRpjAnQktZYOtHhuk9yzn6eq99t0UnKbH7Evm04bzxv7QpW6TEvH3i6RCP7p4RgESEeoLVzaNuh2xp1ekX9NJDqQEgmXIq7LO0rtInBix4votTMaoEQGiMF++B4YhI+ePIIzv6clA7hfKScCYEfcnnEYNwQKjbNVumc981t1v1hlL/hQIIXILQEL7FCsLOKZ3vDg/CMyl4huh6fGkTp8QKoEkQfYGfQ9QbxZE17ccWZvktz4z4V0TPmhymxEIJ0fEzf7KmbFYmWZHmK84rxQUZelawvlpw/eUKWZrHL2AdMW1NmCmG3FDqhbbaUxQThA22zxbqevm9ZHNzktK7p9y2J1CwvnzJaLHj1tddYX17y3vp99u0enWTU3R69SzhejDAepJacnj7m6iIax+t9y8VmT2ticPUrr7zMfrfl9PyCrjGU5YjFwZyjw0O8NTRNw2w2ZlRVTMcjyioHoVlv1jx5/IS2bdntd4xHFc5YlE7ZbHdAoK7jwVMKhUglQmuEknjXYAbQUAggvaTtDEJYettzfn7OYuGYzGZsdit0XUOIOU7O9j+V0fjnnodorvc2sN40PFs3vGgEeVECAt8nBJ1iZewYWx2vF0F8HrqgwCtE52NWZNtikwQ3yCYxFuk8ojOQmvizbUD1BukMQUooKwgeZXpkaxCqJVHqv/vG+mT9/3x5Z673WOEjGlwR0CHg8QhCnD5YiwCMjZNdwYA3DwwTBB2ntjFwD+8HwIj4qZLEh0DbNwQfCCEWasF5hBLU1g3FXpRW64FwLIW8lk8WeXwuOB9fV9Pso9870ddS3ra1BCLYJ0s13np646IU2Vqs6dBK0bU1gUigTBKN7aFuOoo8YVyVuBDDA7t2gwgBawP7JsLajhZzrpaXrDe7WGAQSLWmKgqK3JNqiR8gFlq6gczo8dZHe0Zw2L7DGMfGGOxwJhEiYAPYIMBbHj85H56dsZAVwaGHn2V9wDmDDBWUJXLfE6yh7Q2mrmPmlnHYvqfxns5bZsdH/PWbN3HGs9+1GBGLyz5Y+raNsj/jCUHhRHRPCaNijEYI3D+cc7w45IPlln6zwpie5WpDlmfxXBXg7OKK1hia1rBrAlpprLOstntmk5LNoyf4IFBFGfMohQQ0WZZxdnFJ30fv7NHhgqrI0VpRlAX7/R5vDEpJjDGEECmJqUhJREqidbxmhrBu4yz7usY5T9O01M0VPgSyPEWJn0Y/TMajGDUwcAKkUtimxfnICui7brjGhygJIVCDbFGFmClpnUdJjVTpgAgZvkHE567W6tqj7J29hjb9ZdbPpDj74pd/i2a15snpx+y6JmLNiwKpBWkiqHuL1IIbxzfZbrc07Z6r1YrlZo9OEhKVkumETAaQkqIokCpnvVpHiYcLGDzpYkG3XvPhR+9j3Yus8j2Pn34csdKTKcdHR4T6HFSGtz2Pnz7h8bNLGhPI0pK+DajEkuqcJ+cXtG2NkpLgLL25osxzbhwdstvXPDk7Y7nZkB5M0GnC2nVM6hUupHz8bMWm6dg1HVqn+CQlaEWlNaODYzojcErz9GrDgyff5ifvv8vnX73DFz77O4xGE3bbC5xWpElGojWjvOJ4tMC7juX2HJPl2KRgs9sibE/btCRJhUpKur5lU19QpBVZkvL22x/z7T9/B68U88mI2XjE/GDB0ydPB/xtQlZULA4O+eKnX+IXXr2D321JJwfMj26QK8e777yPbffs2zHFfIRSOb2omR7OwVnSgxRnLSYb8+jK8/s/eJvTsxUyBL78ude5czIiZ43whhAMZAk4HQ21qkCsVqi7C+p0ThgLJl/4An/+R7/Ld//0v+KPvvsuSiUkSjEEq8dDhQxURU5aFFTjCR7YbHes11vG4xG77ZZpWbCYZeybHdBT5IppWdI2DbaNkgYpNF0IuABZnrPZOy52nkePH9O23SBRENfa4t50NG3NL3/2JU4+f5ezyw2Pz6/o+gXeW6wxbOqe9999F/v224P5NAZoKiWBqKeWMo7JY4ZMLMy8d9fmaZCkacwy00nKuCqZTUbRVJsotIoPAGsdWstoShXxuvIePJ8UZz/P5UVC2xnaeofpLY/6Ee+5EquPeDNYEgUvTDVTvUYJjyQGu6bGovsOfI/yILxgs53zQXuf74nbPJJjrPUIHQ/tCIGV8bCyQ/JDP2e6b8mTPXeTR2RuSRokLnjc86aAMYP+XbAVR7ynbvE1NeEHYsYOgbCGTCpSqXACpAw4Dx/5lD9YjhGXz3g9uWDSP4M0wyU+BrvpCh8qRK7wTYrpBU/NfX5cvALViFe1JBUikrx4PtNxjIqS9VMPicdKi1QaZSVSwOxwxng6otnXbNdruqbGG8P64inzIiNLFKtuB+TMipzlMOWpm+jzKqYzdssL9psNSXbG6uKAF166x+7qktOnj/nR20ukhSAVs8mUxWTEdl8zrjK8NVSjKdV4xGwuOQyxA+qcYLfdcJVFepmQgsViwagoubg4p5Oeo6N7HB0eUZUlWV5GiICMxvJoFje8UN7jrTffYbPZcvPWbbquZTMAZISUdH1PWeYEE7HZWRZ9O88N5N47OtNFzLmLwb6r5YpEp6RJzmJ+SNdFP6wbSJdymKAJEbvAvXPoRLM3ho83e76U5Zg8RaUFoe8IUtPnI6SP0zeSFuEcVmpskkEaSHKH9A4SjUgySHO8TBBSR++aStAyxSkBJgbRCtIoXxMKl+XIvkP0Ngbc2k8yGn++K06SszSlbhrSJBKKj+YzLpZrnPfXoe5JktD3HTKJfh5r47QKIch0wmRU0fYtIUBnDNZ6tIzh7Umi8c7Sdj3WWsqiGFDjAqkiNVVpjek68jxnMZ+z2e2uARld1zEej1htNkyLEU3bkmh9/e9heH1t2yCAqsy5cXLMxeUl230TZZdSc3wwZ7Ne0RmHsTGfNElSwOOtQfhAXzcY67HPbQUySvpq41CJ5/zikt50QCxqn1sbjHOsNrvB6xkL16aL8Tn9IK/L0zTmphKbsb21OO+HSbeIihwRZZru+T3sTIwfgQFRHz3ueZ4Rmp4+mfLS/ds052vSmxl920JvsW2U7pkQ8EmEiXitwBp80yELTR/CMOV21HVDMAEvJEHF/QAhyROJqRsS7zFty1Vd0xnDZrXDE7j14kuQFigVfVpSa7ROQQTyrECo6MtVYmhMa01RVWiVsFku+cH3vsMHH7yPIHDv7i1m44o0SQbITKBtWrIkZb+r0VpB8PR9pF1b5waqNpGSaUycEnpHXbc0bZQ5pomOBGIERzdusjg8AuDZ48c8eHiKkpAk8T4IQ6C688PUjDgl3jcDyVEqXHBU1YT7r3yKcjTm4PgGkmiHsd6hB1jOc4dLeu2vdPDfatj/91k/k+Ls4eO3SYBqXHJ46xZaSnLt8bZl33exAJMZF5eXhCRlXo2YVDPGow2tMezrPUEZbt57BeFhvb1ks75gXObkRYqnQM4OKcsJfrFkmlcspguESBh3Mevg4MYxxyd3ePj+hvceP2W7ukIkJX0XP8hMK5brK5LGkIaOZrNnW+/xQrFrdqjEcXB8BFLRyJb0YMx4UnElPa2UULecXr3H0fwO6ewOx6Md2X7L6OgOd158jUSlnD/+iOXVY4SDunV8fHrJ+fKSg/GIX/1rv8b8+Dbdfs3q8oqr5YrlZknddbxw/yVu3b5DYnuafkc/tahkRJJWLNd7nIX5ZIpUmlQmiA6KvKBrOh58/IR1XXMwH3M4n3BycsLjp8/40Vvvs+8ch0dH/OZv/ia//du/wlxbVL8Gb2ibHXo0Y5QXvCwU7775FhfLPVlZcrXfkCeK5a7jzsuvMyknfPT0km++8wE//NF7bDc1WSK5ezDj7/36ZynHU8J2j9Ca0HaQaoIzSJ3jwo7u8pTk9H1WD98n0ZJv/P4f8k//2b/garXGC3FdfBgfoqdDKVIVL/o0L9A6Yb3dYq2la2pm0wkEODpcUJblQOFRPHp6yt0btynKKSYImu0Vpjc4lUPfUYvAv/ra9/jxjx+y3WziwcH7GLLpI8Vqv9uRp5qX793j9q0Jo48/4Hg24snZJUIqzpZXPLlY05tIDAKGyZkky1IWiwVlWXBxcRlR+sNE7XqSMIBD8jzn5s07rNcr8jwnSxOC76M2OQiqakzb9UCHICClJgiBRcWwW/lXmJN/sn5mKwDL5RLj4e0n5/x4m7ArjpEi5btbwbNmxq+O4PPThIN0DThkkFiVEDKN8BkuKDb7KT9JbvBVcZcfqQneCbyIMpM0eIJW0XA8HLi3MuUb6haZTvnbacnd5BHK7ZDCI2WC8gHhI5N6b6Y8snf4Aff5rrrFmhThou/LahBaxbDgwchvlOZtDiiAUmheLzSl2uHlkCuTpFG1YTuETFknt3jPvcYPqpvcSXsEWxgmd8IHvIiktzxNmU+nXF4+I0kUhhaGzdB2fZTRCcF4PEJphTEtpm2xbUOhFakUpN5QBEevdYQgLc9juGo6xpQ1fdOwXa64yJ+Q51P+2q//DUbTOe6//C9464MHBJlgTc+4SCizMbvWMJ3NEMEyqcYIlaB0Rmccm+2evMg4SY5449XXyVJNu99xen7O8dEh8+mU0WhEnmXIJEHplLKq8F5g+p7PvP4pts2en/z4h1hnyPOUp6dPyPP8OsxaphqVJtfZakElJEnAeoMzMRzVe+Jkf7CX7usdwed0bY0QIR5+pCBLUyBg+yjBCoO3Jk1STDB46wmJ4sOnl5jeIqqI7CbRyCRHlOXQYRJ4oRAi4JOckJaorEbkBcEZtFaI8QSRFMi2hXIHXTegR8v4dUlN6HOENXG6luUweNVE3uBtVMF8sn5+Sys1+IKi5yxRGiUlSgUSJbDGYZ3D+RCbssM+Fnyg6/q470nBLuxZb7fRmzOQiqO/BnQS/88iz9hsdyilhmLlOQyLiCi3Homgblqcv6Rt+wFdriLQZrmJChITJd5N28SiRcbJlGg68B4XoDWOXfOItu0ww34LAmMHpU3gujiD7joiAOIkMKoOonfOu9he0lrQ9z2Xphu+b/CU4xDW0VuJVrE4ee63i/Y7STmqBm+cZDyZsF6vMU0bn4tKIQlorSm0RicJaZoPuWAB790glxNxgBBiuDcECuUwScGrr9zl/PRj2rajbXpC12Pbnq7r6bxFFzn1dk+SaFKhSKVkv93jsoSuMXR1Q1e3eOtBa4KKjSghFb7r+ZM332eqJV4nnPcGKQOjouCzn/sFZrdewusUnSZoHQnXWmvkoJ6QAyBFD1JXpRTr1ZIffvc7/OTHP6Jt6pgfm6nrDEg5yD21kLRdS5ZmsRB2EdlvXQzlllJE4Ie1A7Am5pZtt5FcK6VEK4kQmpv3XuCVT32ayfwARJyC3bn3Cl/9g3/NenURi7OkG6S9EdNvrYsB2iEM16JEa8VkOuGNz32Rm3fuxVw/EZUJ1sdoBSXFQOmOjclrZmNQ/FUQAT+T4qxpW3yWYINhOjqiSCvq5SMSGajGE6TOcLYnn4yxUuHwNLZhPK84yUboNKX3nvF0wn69wewT0vGEw+NblEXFcr/C+IBo94yrCUU1wisYpZrFbIx1kfCotWI8OUAEEclhJLRNg/IdWiRk2QgROsZVxWJ+zEdnTzi7eEqWSZIko6ktj87OQAnyMiXVIJVGiwSzd1xuG4y+4rWT20yzktvMyaY3KOcHnD8753x1gekhUZIsk9y5d5vPf/Z1DudjXK7Y9DXb7SV/9L1v86++8n1Oz2uUltw++g7zScbBJOczn36Vlz79GY7vHqNcIEsKgkzoW0PiasaJoCwzjPTsmprl1ZYyz5hVBb0NfP/N93nz3Q9Y7vYEKbh/eMgXf+nTvHFvjmu2QEbXdNimIYwmSKkYHdzl9suavEgQzmFUwTixbPaWW2/8Aj/+4BG/+3v/NU+fPML0lqbpePXmCf+rf/I7fPreFNltELMDgrGI4aAg8jlWKvb7NT1jwlvfJh1V/OFPHvLP/+BrnK3WQ55JQKtB6ucdWkm0EGgYDMSB1XoNQrDZbIYuR9RkL2ZV7I6pgPWWnXVsdkuObrzAwckN1qsz1henyHyCThK+8s3v8q3vvkdvPM44pBIDOtZGHG7f4LxjVE6od1e4OpBJiR9lTM2Uj04veXbV4lycej2HpMrgkSI+nBaLRaQxEq47fFrrIaCT4UElSBPNZr2h6zqSRNHsWlIl4wahU7qup227Ibxa0/cdzgesF5iuZzaf/Sxu3U/WX3FJqehNz2a9od55SOZIkRKUpveBR23BN4REJZJfTBTjdElwFidMnCuJgqtuyo+4wVf1Td5jhPcy0hSRKOG4p/eUCB6Fir3XUbaoJeuQ81VxSO4lv65T7uaPSEQ8dEgihKbpcx6YA/7M3+er6phlkAjnCUR50tS2HMsdV8mILfH+C1pRC8X3/CFKa4TUvJ48IFPb53znaHYvJlyEQ34k7/PH8gWeSs2JuMARSaQ+WMDjg0ASJ8V3piOa/ZJdu0MrTXBgTAc+YPoGZw1Sa5QWeC8xpuXhs0fcknfI0xThe6wUZELjhMD1PSgopke0zRpZCGzXs16eofMC6xwvvfYy/+Q/+A/43g/e5Fvf/g5paAjOkWUZPhist0zHE5wxFFlOEIKyLMnynK7rwfVsdzvqdUfT1CxmI8qiRCuBlAbvoUhylE6id0JJ0kTz+PFjds+2WBvY7ffU+z0hBDrvhqy7CLZiwJRrFZH2Ms9AGBrnCDZmRjnvrg88XddQFjmT8RghJKdnZ/H5IxVKK5yVSB+GA3CIURzDc8hYeHC+5vEHjzh5/RZKSDB7yOLBmhDidMvELCqlFEJEH5LQEiV0JO0lOa4oQaegFT5pCdZCniNGI0ReEvoa13dI5wlpjsgKXFYQugbl7OB2+2T9vFbddLSduY7WuFptUFLQ9e3w9/HrlBomLyFmdzW9wfmIJQ82fpET4VqejwCtEz7/+c8zmU1p6obFIgIXsizl7Oyc02dPOXt2Tt/HPFDrn6P6PbZt4//jhoBr4Hm1Y619XhXhnCOVSZT0ClDPpZJa0cfKkEwIdJLG1yYCaVFeRwP44MmyjKIo0MlA6BumJ13fEYPiVcxvg6FYi9LLsip/GpExvJ/PkenG9DHbLctiGLMUtF0XYWNKsjg5HJ7Q8XHadXHiWFbl4HHT1+Cw3kQoXJomhBD9gd47JIoiS6BtWV1csjpb4meCvutwJkoVm11DYy2ZtRRlim97vvbH3+Ny27C2PfdeuMvRjUP2bRufcz5E6LUE7RXgONvVPNpsOFOKPMs5Opgxm0yYVxmjPI3FfTFCDNJApEAJSaI0Mmq2478JQVM3fPjuO3z4/jtcXJ6j5eDTkoLFfB4/U2/xfRykmD5Sao3pybIUW9toCbEO4WLBZK2jD566btjv98M57jk+X3B88z5f+qVfZ3FwBM+R+iJGBKQHh/zNv/M7/Mv/8p+RqBh7opQgTxN6Y/A+YF34KVVbKbIs41d+87c4PLxNZyPtVisNIRJxAzGEHCTOehAxasm5eDZ05ucFBDmcAYLgAnmSIlJFNr2Btz27bs3m8owqH/Pyq18gycd0fUPX7vC2p603XFw+w9iAc1FmduPwBtYaHI6m31JlBevtGpelEHJ22xWiKKhti5JwenaOzgSTtET4mizV1Ahsu2WUl6TJlPX2EoNjPJ6Qz+ecL6/obc0rd1/CGUNrW7q9ZeYVi4MFulRkeYL2Ate1LLUkO5mzuH0TNS6YVTnbqyeszh8zaTa4ek8WeqzvSTLFfDTDq4yDwyNGkzEOx7PtlraHl179Av+gOOTDjx9yvlxRlWPSvODgcIYaLfAiZbvesV1eUK8usd6hgudkMmIyPkSmGqcl9UrTtC2TccXlescHTy/ZtQ37psERkEFEFPLqjNWjjqOTW6RpRSM0rdij0ww1ntDVBceuQyY5zhjGhydkWcVRkvH9dx/zf/5P/nMePfyAdW0QUvCPfudv8R/+z36bw4MxEhAqjWjdYEBCSKeE9IR6uSF78dfQ+xWua/iT7/yA/+z//S/onCVLEwghIpp5jtodHnLOUmQF5WAMFVqxWq5iDplOMF1HmefcPJ5z++YJs4MFu3rNdtuAKsA20G+ZVzPSJGXdBD54dMpX/vxDQtA4F5G7Xd+hVOxGEWA8HiGxvHz7COl7+rZBZglmW1PX+1ggBcfBfMSu7tjXLbPpgs32iuDidMwMnfGoVZaDQVijpYjZG0oyqUqcD/SuH2hA0RhspaZpDE2zjzdnmgwkIYeQiu16jTGGPC9ZbzY/i1v3k/VXXFmiscZSdxuCs0xzSajjYUVLQVCSj/sctz9EJ5pfUIJSLRHBY4Nk1S34cX3E17rbvGcrXAhDppBES8cX1ZZfL59RKcd32xt8oz9gT4onpdeCs1Dwr8Ix1gh+TcOd9BkJASkDrS35oJ/xNXmTP0yOWTqN7EO8PwkcypZfTR7xitpw7hd81d1hJSZYEQgqsJMZ3xEHSCRaaF5JHpHKPTZ4nBWctsf8OBzzFX2P9+SEzLUEL/HW4mSA4TAnRQzolEKQZimv3TrmzUeezXZLVqSDv7JDyAStJK7v8FiEiwfAzrZsN1smBwvCgNnvJVQCWh9Ie4vbRb+qMz1IQde1XF2c0neOYnKFUBkvvXiPNMt57503kbIFoMoLni3XHExnEBzCGbJMY0MX/SJKUHeWIpEUSc7hfEKSxQ5xWU5Is5wkzVFZRlGMCN7RO0Pd7oehtifLU4o8Y7tZIYVEeI8xPUpFyXWwhlGZYwJopfHKMysW2N7jQ5T+CaLMUYo45SzKivsvvkyapLS9AbFit9vHDrNWODNIGn3syltjiaGNUDeGr350wYv373BotwRrICQkehOzjpoG0bXxEFONYtFlDLJv0IPULYiAHDL3QrtH9ibKtfGINEMofR0TEUQAayDPCVlGcDZ6HflkcvbzXEopEBIZACJ5LghJ0w2TLyIeP+YQhmsoVwgi7seDVExKQMrh7yDLcl5//Q3u3ruPc57kRA0T/7gPIjzjyYj5Yk7fdzR1g+ktxjqyLMoMjYlB1xBI0pS+a1FaoVUSiXpak2gVc2udjXI/KSGEgUIpadoGqeQAaXAURUmaJvHrEHRty3a3Qw25k7P5lLKoIpXR9NiBeGpsvLa11vS9oe86zOAXkyrCi8JA9mvamq5pKIoCFzxt3eJ9oCxL6mZPUzf8NPs0TmOstZRlyX7ncdYzGo8hxIbubDbHGHv9ekKIzwClJdJbrK/5wUcr3nrnIXZ2xq+++iJt30fvlzU0fY9RAb3ZcPpsxVefnPKo7zDB8/HbLX8tOLJE4ZVACwZSdPQWiyTlo8fn9DZ+/qMqTuml0pjhesjzFJ3nBCmvfx85FM/WOXAe6TwffPgB3/nmN/B9w3w+5WA2BQHjcWz8FFkWZYE25pg5F7PmfAg0TQTBWOdAxJ+TaRULst0+yjet43n2Xp7n19lmeVXhpGS5i/5erSQiiBj74A1OQFlVTMv0mtaoVVRSmSHmpLcWF6LkPM0yRqNI6NUqNhB9iO3QROfEZIlYristkEEPaqxhQvzzkjV2TkRaSue4OD+nLCY42+CkIYgEazre//gR9f6KV1//BabTI6rRGHygMYbz7YZOSnzf40TgcDxlOhmTpDmI2IndE5HFVZVirKQ2WxA5eVYwn84w+56zJw/p7Q68xvQ1u80aMfYEFEjJfD7j7r0X0GlKkuQcjmeEbk/XtvR+TDuy3L17n3FRstld0DiLtIHGeuZHBVk1JckFzm5oQ8mWjE2/IXGO0WjKsU6ROo8j6CQjG1WUo4Km35HnGSJ40lxzeHLI4XzGay/fp6kbOhvQeQmASBL6veXy0fdZ15uIg+32aJ2SykAxqkjlKE5kspT7t484/dH7PHh2RWN62q7DBo9Sipdfeol//O/9PX7lF26jXI9rttigyBMIdY03S+plxzsPn/H6/WNSOsbTe6iywnjBt3/4Ef+X//T/xkcPPuRivUHphL/9S7/E//Qf/T2Oj0aItgYsjKfxoaIlgRSXzFmenqOVpNs/xAf4v/4/f58//tY3qI2JWPAkwbqAxMcOlVIRO28teZpQlrGASRFR9256qrKkqWukiJkoRZVSlBWHBzNuHi84v7ri/PKKy+WWUepIqyPe//Bj/vkffpuHD89QOmaZGaNwMo7PlRJEGb1nXI340qdu86mXb0EwSBUwdYsMkvnhCY8u1hxPJyzrmiSRlGVG120RSIy3jNKc6XQ+XLOO82fnOOcJ2pNnZTSeGhP10iHgiZEBSmm0VvTG0RtLWVYgBKPRiPVmzb7p8dbSNh1Ky0GP/Qmt8ee5gvBDV9kzSw2/NjN0LuctNxsw4zGL5aM+5fe3KR7JZytPqa44b6b8pDnkz/a3eM+NcFIhncMqSJ3l82rJ36qe8qnxJbkMlHKHdR3f9HewaAgSLzQXJvAVPyfxHiUCJ9kF3qU8aA740/6Ir5ljtl4hQ2Q7C+CW2PFlfcqvlA+5UezYuUtE0/O1/gWuRBk7wlKwI+HPwoLUOJQWvFScIV3LWVfyPXPEV5M7vCfGuOBJgsSJ+PsinmcnSURwQ/c7Iv+rUvH6/Rv86ENL2zQkKiUdilyLApmiQkLoWqQ1hK5nvb4gzWKWjhGBREQiVi4CKRbqPbNqxBk+goKaJmaqIWjrPa2xtK1j15gYJGo8N0aKYjylE5K27ynyDNPEPByVpKRFgZaBVFcooUiyDKkUxlkSnZDqFK01Tben26057Z9hrKVra3yABw8+4uMHH/Pehx/R9y25jgegTAdsFyKR1jvyVDOtMpa7GBESEKRKYaZj9k1N3xuMiUW7lJCmKWmSsJjPuHPvBQKSd999lzRdsVkvCWGPtRalE8JAFzs8mLNcreMBB3h2WfPR4yX1uGBcFRxmkOkULxW+62IBZR0i0YQ0IwQLpoGmxSMGcm0svvxujdhvkM4Rshy8gyRDdA30LVgTpT+2QemUMHiofzpz+GT9PJYaOvzPD7UhxKahYAAgSEGio1wty7Polx7UIUVRXAM/0iTBulhgFEWJdRalJY+fPKLvGhhk/IQ47Wr7njzLSbMcneSMx4uoPtisEcFjrCEv0qgWSVOsc/RtM8jfcowxETHvY9Zf07Zx5uZiGDDGkhdFpDFaR9vsMX1PnscCL0lTtNJxSgP43tB2DULA2bNzsqJkOpkidcJ6vRr8SBnj6YTHTx5jnWU+OaAaVdS7HfPZnO1uy3a3QwSYTmaRtkigEUPh6QNCZaTZ86ldQIpYcCRJStt2BB9/x/1eXE9/ov1B4b3C2hpnDWmWIUWCUp7OCKwQrArJxw/PuDE/4CSXOMApQApcEDw+W3O52XNhDDsTJc8f7msOzy946c4xhVBkUiKUxCIJImCk4tlyjZTgGSIDug7Xt4wPb3N892Ums0OCSjDBY/3wnA+RF1CmGU8ePeRbf/ZnPPz4wyFSC8pRQa5TZKLROlYudpAnKq1RStC2PUn6U3J2olP2TUvb9SitEA7W602cXhKnb0mqkUKSZxlpnlPkGXmeMxlPcD7EyaP3uBAjiTwSlaS8+qnP8v6b32PX1AAYE4EgboDXSDFEDDi4+9IrpFk1eP/D9Z6mlI5f7+Jk1zqLcwEhiXRHwIUA4i/fkPqZFGfeGkQqKApNpgo+fvQROglMJgvSVLKY3mRWHGOznNpXmPNL3O6cy+WS880l282KIi/xVRaN1cKTVDllMcL1LXVnSbKUqqgYZyN8amiNJNGSSTEjURnL9RUb1+GEZjIacfvgiOpqxWp9wfnyIWVRoHXKcndBY2tU0IzHY0SSQFjjjSENHil6Vrs9eImWBUFZ0pFCy4x1tyPpA1pJLtsNx7df5NDu0ElKU+8pqop80FiXoymjUUmqNVrFkXdaZOhiws5vuFo/pd5t8TYiVRPpMEEgXU4xqtBlgU8UtQvsm4ZSphiveeujj7EicHJ4yG6z40fvP+TtB0+pe0vbGXoXQ5I9Fq0kizIj0ykIQ5bkDNgZVJaTjib88O1H/G//d/8xd+7d5te+9AYvv/4aded4570HvP3W+3z47pvs9nuqJOW1+7f5j/7J3+fVlw8JywtIAJlBvUYoTUhG+HTO8skpom/ptcL1e373j3/Cv/qD3wclSAYip5AShScEGbPwQsADWgqqUUlvo+xCyXjBZ0nE8XpAJQmL+YT5ZEJvWlarK6RSeGeoEsml3yOSioItq+Ul223H+cUFznqSNB18YGGQJnKN8t3uNty7/SWyXLJb7UmKEbPDY3S95OzROS/dOmS1bRiNSrZ1z7OrNXtarPXXk7jVZoU1PUmaMFvMqXd7sizixfdtG6lXWiOkoiijFMoHTzvAZeYHI/a7HdvtGuMCbdtHJGwI19ExAR8DrT9ZP7fVm57W7hFSM0oMb0xXBG/o15IPzYSo+olT2Y9azR+JIzyCm+mYD+ucb9Q3eNuNsUhkUAgl0K7nZb3iN6onvD66ZJr2ECx385pf8Z6mTvged6hFzJfyKJ6ZhD9xBwQJX3QZrfF8qzviq90x5yElcRblHU5Ibos9v54943PVQ+5Ua/LEUwbHl8NDpIevmnucywlKgAiB2gu+7qagArbTVNS81eV8zd/gfTkevI+xIaMHbL9SsRPvQkAGHfvwLmAkSJ0w1gmfeeUF3n94wb7e4ZyBRKN8JJvhY6NK2Bbb9fR9jR2CbK1KyJQgEq8VMhgSs0XvW6ZSse9jFlrX7TDWMF3cQKoUb2roW4rQsq7XLJUlKysOZhXWQpFnOB8QKiHPc0JwTEYjdFZEhHc1Jktjl7jvDNvVktVmiXOBy8tLVpt1lH5Zx2a15Oz8kifPnpJgGZUZDIXjuCxorME0FgXkiWKcSLYyoKRD6BStE44OZ1R1DMFtRIu1Lh5Q05SDwzmmj9L8l156mdVqhfeetmlp+55ER4KdTEWkeIYYjN2aHu88y7bjo1ajx5oFPQoFaRpbvH2L7zTe9WB6LB6vBvKeNygPoW2xWYMDhLWovkf0HXhBKNqoDmibWLQZA2Kgs+UW6QxsN8i+/Xneuv9/v37hS19E6wTvn9OFxTUaXykdswaLgiTRGGvQKkVpRVkUKKWp6yZK94ZcKK31AFJo8c4zm8bpyHa3RwhJlmV0pmfX1HjnCD5GZ6R5QVaN0HnOerWiKMoBre/xNsr4pgcHZGmGSlL6NipN9vsNzsc9MJ6fYuMl+Bi8HLwb0PQZ08MjZHBsN2uEgL7rUFrRtx0ED96zWl7FQ7k17Ldr0ixDJ5qiHLFYHNF3LbdPbpGkKUFI6n3Nb/2Nv82L9+9eR+88OX3Ko0ePWa/X7Ood23UXs7e6QNvG691ai3ORcIgQg6w0RBjaQG48Prk1TAAjSMM6w6isGI1GpEkSm9f0CNvx8Zs/5O2nGyDwzfc+5NdeukMuI6hFC3BCIILi+GDCqzvD/uKC1sFBmvDiZEqmk0hSTXSU7wE9nq2xrJuGNE1QUnD7hRf47b/7DxDeM57OkElGEJK27bH1bihCYrGy2ax584c/4K03f8JuG99zJRVaKbIsj3JqQIlY5CiprhsEZvDaujY2rLvWsDbxGjLGsNluIsRNRh9enucsZhMYgB1N1w3gFUmqhzoijVENMZIhIdUJUibUbc3h0RFnj0YUeU4YQCBt39MPk8qYRxtlm/dfeIEiywbJa0KUizusjdl2dmALKCXRUiNFlGoyBLQ/j4r4y6yfSXE2m85pzIa662ispRM9VXVIPppQtw37ZkOSF1SZpWvWLHdLplVKOp1wXE0YlUusWzGe36BpOwSeVOVcPTtF+YBzPcL1LNcNK85jEShzGtvTFZZ93bLvtqhcUjcNTZ7TFlO0Fhyc3CSpR2Q6QVpDvd1inCfVsLd7TNcghEImAi0F3hjKvGLXWNb1hhuHJ4xGBZfLc5qupkoqxtNFNNzXS4qqQiQBXUiESjGuIy8KEgmy2xJ8hu8bdqsV3TYD1PXYtDYdZxdnBAfHhzcgH+N9SyoU5XTMsdT01pPcvhcfnt5S7Lf0piUQeHS54vtvP6Q1FusMgjCYYGMXe7PZUlsHQg1j2ID2Ldb0iHLGeSP45//VV9h2hm/98C3efv8jDkZ/GLODqpKutTRdDEX99N2b/G/+1/+YT79+G5o1oiwIctCF+xxkAekY21oq1eJnM/ZNx1tnK/7Fv/4qMlWxe0GIh0XrcCE+UIVKoqxRQFlWUTJDABEx+kr6gerUk+qY6H7r1oLRqKQoc6TWNG2PDJ6jk0PKMsF2Bte3fOnFG/yrP/0exjhC8Li2uw7gzLKU/b6OI/Es5WRe0uy2TKo5r778BvvdBUKXmL7mtduHdA6O7YifvPkjdu2WUZawGFU8ubii6y3G9Dx++HEE4GjNZDLh9p07GNOyvFrGvCWp8UFSZgXWO7quo+8NCEXXN4TQsN1v6dsG00fkubYO5y1D7jVJogcy5Cfr57WsMRh6gnDkoWeStXx20iLw/N7qNu+7Gb2AIBQuCD4wOb65yathwWkQfOQKPJKAJOBICLyaXPGb2UNeG51RZea6YZEoz4vlFfCAxCR8O9ykGSRJCMEjr/nDZsG5yWi954fdhIuQIL1B2B6C5H7a8GvFE75UPeFmuSVTsTMoBByWG74kHhD2kj92L3IVKiCgEWxDxjebA3YhY0HD273igSlBDjJkLynpKLUnSaIp2gVHsD1ucJNYPC4BqyUIxSjLeS0vOV/VXFxcst8sCSKQ6IqAx/SOVEafkzUt9X6Nvn0ToQWutwTnop/TdLGA6HsSoZikKhrjfUe9NbjeUoymCKkpUomcFggZcH3N7uqcYjSGoFDkUfaU6NiF1WlEMi8v8dLjHlmUCBTVhGKyiPLKpmF5dcG+tdT7Nkr3Sx2DnfuaSSIpj0a4vsd6Rdsb8kQwrgqc3ZNnCdNSkiaOTCtM35JJQSIyiqKkSDV5mrDa7mi6jq5pBz+HQirJxeUZZTmh7zr6riFJFKPRhF43VKMRTV1ju5pEK1oRBjy5Z7OrWa0uyQ8PUTqhlyk+ySJAPe/AWpyPXjfrI+nN6hSV5KTOI53Fh4BRErRE6wTtQRII3hGUwKshOygEhI4yH681Is9QXYL4pDj7ua6/9Vt/l6oac7m8Yrle07YNzlqkEJg+khOraoSUiq6LPjAhJM5ZlqurmL+53ZENUtWyqqibPVIIXnvpVQ6PDrHesdtFeb73kVy4b6I9YF/XGNNjbIdEkScpycEhQkb4RvCOpqnxzlLv9/TGkKY5eZaRpRlFcUySZujtBtv3Q05pjJ9InMM5gfMOZzuanaPv2ujZci5GjgwI/yxLo9Fq8BZ5aymrEZPZHKmi7eLi/BlSRhjHtq5pmppRWTKuRgginbXMSuazBZ/51Oeww8Rnt99QNzWr1ZK6adhtdzEvrarQSrHf11wtl7RtTZpkTKZTlFSkWRKtFkKS5wVlMYr3mIowiyzPsG3H8uIR3/j619i2PS4EWrPhG/IJX759SCY1aaJRAdCCaZ5xfKR4IcnZOMdUJ2QmME419nk+XIi5Y32AxxdX+ODIs5RxVdD1LeeXV9y//xJpOcY6gyTaNebTGdYY1qsl3/rmN/jRj35EkStMt78+o8S8Oo0A+j7KF2MAukcPfsEQ4pnPhWgN6ft6wOfH4rYdsmizNKGqSsajiul4TKIEvfMkWU5pIw3bh7gHFUVJCAIl436BgF3X0ZtdhKsISZbnJGmCs5FIm5EhiNmQAYEbpstRhrtDShhVIzbrNcb1tG1LVRZDBpokEZKu3bE3HU3bDrJLf21V+cusn0lxtpjMeXqxwjuHcx1lmaKl4OryKVZaytECIx2p1iRhxSiPIIZtv0XojGSc4duC2u4YzebMD26yr1sePnuMa/fkaYYLmqbzNH3LyfEh40Jj6paryyVJkjIZTemMIZeG7bahXdckaU6fPKUYVxyM79Hu1qQiQ3vPcrXGuBpnBZvdFdOqokwLWuvxSpCXFROpqJ1ld7nCOENVVKR5RVqMMV3NdrckUymSHGEd9b7B7rYI5zF5hswT8jxBB8O0yAlB0rYtwhlOjhcc373D6OIU03dkekSa5njbc3b+GGNanNAcHBxzkGic7+iajuVqRaoEven46tfeZl3vo6k2gHHuGlUbvOfp6Sn//F/8Eb/82j9kWhQQbJSmjI85u6z55p/+AT988yd0fQ/BY7qeK9uz2mxJ9zt0okh0ya99+bP8k3/wZT71yh3EbkOQkhAMotlAkoKegCoJokD7C9ThbZxPebS94P/0n/4zgjVkWtF2FmssfdvjfNSxIyRSeRIp0ElC23foJIYDKq3xKKrRlE3b4DrHyaLilRdv8bnPvsTR4SxKFKRmllc420UUrhBc7VZsrp4iZclmtWE8nXB6+pQiL5EywZieut6DEBRZwXQ24X/0t36VySIl1RV5puk3PW3jKLMMNR5zub4i+C0v3DzghRtHnC23PDg9+2m45nUHKBqn5W7HZDJFCsVkOqdpmoiZFgLvoe1aQA4Tsl3cZJxFKB29ZUUVN6yuIdEJQSmUSFBaRLnRJ+vnt4IleIvFYqQhTRzj3PGGuMR5sHvNx+qYXkQkcx88H7YGrRIOMsmJDzyoo/QhEY431BW/WT7ljeIZs6wlCIXHEYJAyECmLC/JC3SXkHaSb5lj1j5moTkE50bybSsxQrCTGtV7hLXgPXf0jt+orvhy9YxbZSStBuLmFGU0nptlw5fkY8xe8yf2HpeixEmJU4ErB1/vxxS2wJoAWKS36ACJcLyWLrmT1CQqQny8jbKUgEd4h/AGl0V/Qxss0nvQnsODjNn0Hsv1EZcXl5iuiTKVQmDaGoTEC6jbPQ8fPeb49h2UTLEiehqMsThnEG2HbRusThmVBV3bYfuGxhhs35FUJQpFphKoNC4p8c5T7zdIqdlgyZIMlSb4LEdnGXk+RYxGdLsdPR1937F68jHuwXtkWcF4fsjRyU3C+RVIwbi6Q7fdMZ3Ew1WeCgSOpo6TdUEgVYIizamTlsUsZ5RIUiXJpQcRSJREyYAQjizVTMclWoNUCy4ul7FrX2/xznF5cUZTtkzGY9774L0BVjAmOAfBc+PGEY8fP0ZISVqW9Ovttc+lbvc0dUlb5CTK4ts9JCXBRcO80wrvZPTQJgUy91GIaCxaarzOsHlOEBrvA073ZIATCpdmsTBDEPJYUKo0R5TjmMXmP3lu/bxXbxyybjHGxkmTdaSJIs9i2PBifhA9PogBwhHY1XUE5xQFSksEgel0RvCOyWQSB68m4t9X6zUBgbWGtvsp5TARkulogrWOG0c3SbRGqhi40fc9eZbGyRKRComQWO9p2gbvHEqIOGXyniLLI1TH+0hx7hskkuADbd9G68N4wngUX9tisYiQid7QdQ3dACQRA2jMuSEQWSeE4MmyHOcsq9UyFpM6IUtzsjSja3u+9vWvMR6NODw6oipHFEVGmmaURUmeZ0zGM8o8Fm1KSbI0xfsw+KriGS3Sm+PU6jmJMUKXIgBFyBhLEUK4BlVIKZFzydvf/xNOz68ggBQR1vLOkwsWVcH9aYWQijTVzIsUZyzPui2dMxRKse1b6iKgu5JqXBFC9OF11nG6rfng6RlaK6bjkqrMWS1X/PP/13/GfLHgC7/wS3zmc18k0Qnb4X378Y9/xPvvvcXZs1Occ4zKQ7JEc3ZxNbxmKIscfMCFgIIYK5Ok2CG2QGnNtt7TtvFz6XtD1/cRshJACkFV5RwfHjCuRozKcsiP86Qh+oNDGAKjA0yrMVWWoVSK8/FM5p9TPkPMlnX7Jha9MXMhRhkwgHBClEMqpYaQa01ejLDe0jvPeDKjNz15YZmOx1yuluyamtBaxlUBzpPlCmUMm+0a+5fngfxsirOz5QXSaG4enJBVFd1mTbPbUduaxjYk+ZYkzVnMDhFCsV5GWYgNgklVoJRFCQ8uUCjNxfIJKkm5ef9FNqtLjG04Gk3Z7QxPTj9ASoENAZVnGCXZNju2qzOychrJfzjSTDAqp1jfk4qUvu2wQRB8TZGUVEpxvr+kawOh6VDFlM56dn2NsS2L6SFSa+r9lt41jIoRipTd1Ya3v/Ndmstzbt65y/R1j0rukXvFg7e/h8mOefTeh2jzmE995g1euHFMkk9Ytp7WWep9TVmOafeGQhjm0wX1ekmuNMa27DYb0iAo0jHnq5qH6we4wylFlnF5teZytaMqCjbrFd9980OavkdJifUB4zwixKrfB+iM5Tvf/wlvP/pb/NIXb1G3PWubkCw7crNnebVks6sxPm6+Qgm6rsF5y7aTiM5QZpJf+OwLfOZTd5EIQuLxWgzUHE2QGUEleJnBboVQCbZX+DTwf/yP/ynnp48ZjSqsc3QDgciFMBSE0cyZJSnz2YRRmZFqjRfELI4QKJIMrxIuL59wOCm5d3POp1454WA+IisUl1drWmsYV2OE9+z2e9q+xThH3wteunuXf/zv/AYPH5/xX/zeljt3bvLw6QW9DVS55rOffp0PHp6z2VxxuJhRTjXLqx2ryz11s8eLgnt37yOLKYc3X6BtHe+8+2N8X3N0POPZ1RLnfyrtCCEa8QnxIXx+cc7dO3eor85ZLpcx76MoQEiapsHZgEwSurbBmA7T96RZEf8/0zEaT5DB03fRpyK1xtmA/gRH/XNdPsSQZxVPrcggUAgmieEzkytQKV9nzCOmnBlF0lmwlovWcCvXvFRIViZQG8On9RW/WT3hs9UZk6wfPluJINLIEIFEKIoUXtZnJMIjguXPzE02SiN8zFLZeTWQHuP3ECy35I6/WVzwC9Ult0Z7Mh0QQSKEAgRBRbqjFnCz2PErPIC94I/tPS7VGI8YninQBk+RxFiHzjlS1/FqdsmXsmfczQ2JHA16/WHyPeT0BBEDWlU+pihHBDTWdQRrUdZyPB1xcOsGu23DernC9x1+NAEh2S8v2G9XWOsxTlDbnnq7w/YW29WEPno4907SNzXtZk+iJXmS4m1LX3fYeoNOcvKiJFUJjW1pe8N0NiZNFGAxvcEYsI3CC0FWbknygkSmFFlCWY25eedltusVV2cP2G/XbOpnVJMDyuKQ7eqCHoN3nuPFIQrPbnkJmWJne1It0UoxKTXOF8yKjJRIdS0ySSoSlAZLD8aSZinjMiOVh+RFxav37vDhk6fcPF7Qba84WLyK9SZ2kcuYAeWdIU1T8jwlTTOqakTb7CnLkm3YRJ+NcTy9WHF1WHGoAnLvUY3BZxmi70iaHbJpkCrm4SlnEcGjmwbRd0ihQEuUrwguIK0D7zFSIILHBY/McqRzoAKoJOaAFiUyFPihePxk/fxWILDerRHA7Rs3KfL8ejKmk5Sua6N9MI2B5EWZMdMjqrKk6zq6QU2TZnmU2nlPksScPmPtIHeMfpupiAWGTjRN3SAlLBbTCHowls70dF3HqKoYVdXgt8qASBuNxR1kWRqJhlJhbaQrV1UkMLZtR9M2TMZjpNQkiR5eZ6Qd13VNWVb4AUP5PNMqwlACnenQOqHIcnyI0J7dfs9ut6PvO7q+ZbvdUtd76nofp4neUjd7VksV4SKD9E4M8KOYX2bJspQiL2IYvXNkeYHScQJeljlVKJECvInvqRpCj9MkNs460yORlJmOzeoQ2G83PHz/TVQSLSGRJhmVSH/+0WNmb7xIomGSlxR5zrrb4kYpZ23Lrm1JEsWNvKIxFgYfe2N6lnXDe08vaY3hYD6iyhO6vse6KM3bbZd899tf4cFH7/Arv/IbWCf4F//yX7JannM4n3I4n11j54s8I9FJLKq1BhFlnUrKOMEMgt7HKdq22dP2Hb2xAzGzv5aCPi9gZ9Mps8mILM3QSkWVxiDb3u8adJLhvSRJEkIITCZjqrIk+MHfp9P43BmydJWAx7s11vr4mgY4nZACfJyCyeBxzuKDotlvyVJNKbPYEBSSUTbGGINOMo4OjpgaR9tbnLeMhcZaRzpNGY9n9H3/l75PfybFGf0WESRPTz8EBNNyQucgkRnzLKFUGd225Vn7AaPJAcIHFuUYEsU4HdGsL9A+oe8bQufIRhPycoQXHp0EjOtA9ByMRty59xsIocmyAonkanOJaRbUfU2VVdS7K8bzA4Q0scjYbhjLCbiGUVmiZIbpDLPxjELnbLd79EJHMpBzjMsTMC3KWarplFmScrU+w+z29Lah3tRcPt6gbKCrO9rd7v/L3n89a5al553Yb5ltP3u+49Jn+aqudugGGkCDBEAO0YREEdJoDKUZRSh0oYuZUMwodKX/QOZOCl1RMdKEFAzKkqFxDHiiAXTDtO8u77PSHfv5b7vldLH2Od2SqJG6VWRfqFZE1qnMOHnyc3uv9b7v8/wefHaGEEO26x1ePuJLL9xkuYVvv/MOj88+4uWXvoBLD8nyITJNSXRG1WxRNsWYiExPcoH0MCiGgKKxDnTL0eQGkpbdbocSjmduHyMRvPfBEy42OxyQacVkkKOVZL2tqFrJrmkgeJabNf/L/83/jVvHf8GjJ6fsjwr+p//j/x7LtuO77zyk6Rw+iL4DI0gSBRQ45zBBMtub8vwrn0WpguAr6ATCJQih8fkkfm8o8KvHaCWgOAYp+cf/9E/47g9eI1Pxwm6a2AXxDrreL1XtGkSwiKRmGwy7lUAoSZFmTEcjhuMxZa5pTcOkyNkf5oxTQVMtef+DivFshpYZQUfCVPSsSKQqGI0Tzp48xjYL/v5v/AJ/+cY7fHix5vRsySvP36NuK6bS8dztKbdv7vPll++zfzTh+NZzuO6vGSUFNw5nOBJkmqOLksQ11Lstz92/S6o073zwNm9/fEJnQo/EjgWTQCCVwJgOLSWrxSWb9Rat5TV9sau2UWcuBVpC19a9NjnKBYQUSBkgOLRWVPUaJXOarkZIQdVUn8il++n62ZYUcbOMBKgW6y1BROnEMG35jDhjzJhv+5y/aEsqHwhOsLQJby0tszwwCnAnWfO3iid8bnjOfmEj9VTE4ulKohzTeqIEcagCzwwWmODZGcV3/U1qASKoKBl2BkVAeThQht8szvni9JLbox2JtNjQy81ET1sLMaePAFp4bhRrfsV/iK0EX/fPsJQlXoHygiAVVviIqVaBO37HL+RPeKY8pdQlbchwXvdkMUAIlEhRPkHKlDvPfpmje59FJ3m0e4SA7xs0MaDdUO92XJyfs13NuTw/I0816+Ul508/4JnP/43YkGtbOtdR1zuWq0s++OhN5utTrFFY2xvJvWI6GbCnc0Td4TuHkprJ3h77hwcY79lWFXlZ9Oj8FhkUXvjoIbUVwghMMDSmgRAw0xl7B7e4c/c3qKoNb731Bm21Iy9HDAYlgiPmF08I1vVwDYMWnlQG0kQTBKTScDgeoUNLoiVBSsblABviQaTxFoXGB4cIhsO9EaiUUVkw3ZtQ73YczYZslheM9w955tn7rDcb3nv/g3gwzhTWWXbbHUVRsJhfonvPh7ER2LJtLPPG07lIpGuNxcgVvm3JmpqhMfHgJxQ+TfFSYE1LWVfInj4mrnDZpkVvNuANohvHyV+aoroW1TaR7JekeClBSVy9Q1b1z/fi/f/ztd3VDMoSKQRFkff7fkKaJgC0bU5nOkxX0XUN84sL8qygzFOKIqcoCi4WC5abLYnWtF3XS9aiF+1Kgqj1VY6fZKiG/b8uGQ1HcQIkY0GDgDRJIiGvi4VSWZax4bTdMBrFyJ/Vaom1ltFoEiWVfVyE1pq96R5JkvS+1/gr76/rsix7tYq9nopF79qOznSslgu225gHJlUkP0opsc4iJSRKMSjzXq3i+ywwSVGW6CRCU/I8+uXoJy5125Fk8joKB6VxruGjhw9YrjaEAM/cv8/tm7euoSZZlsUCzMWpEiLyHIw1MU5nt+LJgzd58P6PyFPD7/zNz/B7f/UBD08vY8aWh6r1fOO9h/ytl+5RloYkSWidJUk1k3EZZZM6QakEF2BXN3gt2e4a3jyZs+46pqOMYZFStx2dE2z7olq7SK1cLy74s6//Lkpn7DZziOEw8fUXMZMz+ChlJNHXE0OITWwD8fX1DmMMTWcwxmGNo2nq6yyzRGv2Z3tMJ2PGo2GcdtmAc45d3TAcDPDOoJMEJwJJ0ksl+3iE0XB4TdN0/Zkz9BLWy7MzHj/6sPcER3m+khIyaLsuRkY4H5tJSvL00UOOj29x5/ZdRNY3T4W4fu+UkowHGXlqYn4ymjLPKYuCXa2p6p/+vPaJFGf7t5/BVjWy2mO3PMd0NcFYJoMJQmja1YahhgSN8iCCxnYVAc+yXlJVG0bjGcIL1tsloV4zGozI8jE6KDI1pOp2GKAzS3KdMR4PWa6XXG4uKHXGdDClqpb4riaYhg2WQTbqoSQJ26rfQGTo9a4ZUqdYf4mtOwg5UiboIPDekKsMZS1WeIZZgSqHSI5ZJJfozxeMikiSdDbhcl5T+Q3TO6/SLZ6wO30bn6fo8ZRH3Ybdkw+Y7Dtu5M8wGs2YZIKZmpAVQ7brNWF6gFSK5WpFs2upgsUimO7vMxuPUa5lt16w6wymqrg43/D1775L6xzTQUGiNNu6pqobsiSadCM8QiAJfOdHr/Pam28jpeJ3fv1LLHcr/uBP/orX33uI9dH8Lwl9Z0HgvcP4COPwIfC7f/h1jsdf497xkNwblI6ByKgMkZSopkKYNXL2EtYH/vxbb/C//Yf/MVJ6XFC0Jk6Rgg101kI/tg/BkeBJVUJrDKHHbtvOgPeUZUaeSLbLDYUKHJeaYRqY6YSqvmSzVEynx+AkgYTRdELpHScnDzBVRSoE1niMh9/85V/hF179PA8ePuK9h6fUTcOuavidv/1r7M1GlOUQg6BuKw72bzLKE4pBiWsjTWhTnSNDwqTQzA7vg+h466N3aVvbv8ryijiMUmBtxJYrRSSchRBvuEDXmR7o8eP8IikEOktRSpNlGVJBolN0ImmblkQr2rbiuWdf4bd/59/kH/8f/+Encel+un7G5QnYHivcWUMQLVoElAAXIJMwcksmbs1AZFSJBpOiguXMOi63oAi8WHhuFzXjvEUI30+0fmyavlpC9KQ8BJm2HKUV9+Sct/2IlglC2EjN6yWzKlj2dcud3HCz6NDSY30g4GPRROwgBiJBzHnbF2qOcbLhvrzgpt1jG1IcsTuLlHigEwHtBTeyltvZglxvqX0aaWREIz8EhIreAppAh2Cwd4Msn/VxRT/pmfxxYtB4BIfHzwEB03WsF5c0bUtwnrQoODw6iv4pISAE6nbHNz76S/6TD36P1jaE4PDO03hPkAW/9uzXeHn/OS4fP2a7OGc8nqETjUwUaZbRdlGyaE3H4ukjtqslxu4wVYXUINMC6TOChcF4inOG5eqE8XTG/Rde5OG7H2BsE6UxwTAqB5ydP42d1ySjaWpSLXEhSnA0UTYv5QBwKBnwMjBKe7O5AxUUjbd0TUUnYbx3SKJCPFzdOuT20QFn53M+Oj1h/8YtBqMhnsDedMp8MWc+vyRLE9q2wVhL3bax8RNvRlgETikqmVEgENtz2kRjjAUHOgQyIVE+gkvIMoLrCG1DcA7X1QSX43SGl1FYq7xDdB3SWZwViK5F7LYIbyHNcAq6RCPqLdlu8y/34vx0/ZeuO7duYowlTaMPKEmSvikrqOuawaBANRIpbJ+zNWRvMmNX7djuKrKsQABFqikHJVUlol9qf8p4NKbrOqQQkbCnkmtp2GAwwFqLMW2P6o+0WwK0TU2aRsqetY75fE6aJGRZSVVd+Y98zCMLkdZ4BVnQWl8j7mPTKRZmINA6QQjZT9Jq0l5eCBKlEqSMZ8I8T0DE0PejoyNGwxHOuz7vL55XmqYhSXT8mmZ4T2+PqOh5EEgViZYHqaaqdjgXJZhlUeLsgIP9I9q2iTE+MoJAfAhonWJcoO6ityoxgTzLMS5g2pZH736bavmAp09PeXRyQddYHtQdm7rCBw3CRcI0cLlt+PN3H/FrL9/GeE/TOgKSQV6ghIpeZmfpOiJYRQrefHrBxa6izBNSrdnsKoIUWCfY7mq01uyqFp0o0kQzKArGkyHPPHeT4GKOV1M3gOgjDHwszLXGBU+m+2mqjNOt9WYTC6AQaNuWpml66FESz/xpynQyZm86pSxylBAorTDE7MYAbLYVk1GJFxEgcy0PDVDmOQfTaQzU9p6qrqNlRAiU0swmU+ZnT/nGn3+9x/XbCHXyfUZtiCAkSWxGJWnJaJAzHgxojbkOrFZSUpYDEp3EzFrpGZeDn4h5EKRakY3GP/V1+okUZ6nOSDJBa3ekhzdZX54wnk0psglNvWHjDXjBMM8woaOuKiblCKk0TVezV4zJkxSdg6sd2WDE3vQQGyTb+YLWrbmYzzGuZVwMqbCwrVg3DU5GrO9qd04qPFkxZtPuGOsJ6+WKbF+zN94nLXI28zlKC4rBGN+YCF1oGsbDCTorIATaZkOmQKUC66L2eZiPSNKMzfKSYamZHN2nsxbfVDRVxaZrycoJZZaRH74KzTNUdovfrVjPz9nttiz1KW2z4nh4TLZ/kyRTeNvhO8NmtyV42NkaG2C2N2FX12RZSZKXZHqMVAWGks1uzWJzzuP5EoKntZ51vcX0xMAudLEo62UFgR8bXvdGGZ/73A1OTh/xg7c+pulslBYSzaDGeK6YqFLELmu13fJ7f/SXvP/eE375Fz/D3/3ar/PszSFFolD5BNM0SBFwxYzHi44fvPkR/9H/+h/FkNfOk5QKZy3xxzm8jUWYCJArRXAOi8QjwQcKFQ+3JniCg1wJqs2KUisSNUa4hpfu3yYvn+Xd0xOSHu3cbOdIs8aaDrfbsrk8Z6QCw0HKplohVDRyvvribT773BGjLOFivcXKqKtvuxaVFGxWl3g8jU/oKovygqEw5K7CesV4sIdSDukc621835CxKwf0ORsJWV4igkErQdcZkiRlNJqwWM7p+qBLKWM4ZZIWdF1HkkgIkixLcbbGmh2ZzDkaJpiB5my5ZbOd8/t/9E+oV58ecH6eK05qXWw0ACp4DA4rIkVx3k14ry15s5PstCdLMpoCfBUI5BjvsDgeMeRxuMXMOSZiiRKxgBIBvBe9Rj6WMiHEorAyBZftlBNbUBsJiUeKgAoCJ2MoewiCUzHgodjnpm05lC0imB6HDi44hIWA68PNLd572qBZtyMu/IRNiHQwIWXsOKgYNIrzdEJyyYAzf0RS7xhoh0ziBhkAIRVaapSUGC/Y7hqauibCmf+fJbni/+F/Y1EaUHlBduN2X7r563wlcf0OwKAcc/v2M+zxDHWwIBRCxAdxIx3yhTu/yJ38Fs/f/2xsnhDhBqGXTV9l69RVhf1sx+vf/QZPPnwDnyuyyYS7z32BZlfjCdy8c68ndYGzhv1jx+nJOXnX0BrDbHbI2z/8JtJ5NusV3nlm0z3quomB2yHej70IxBdfIEMMkQ7ekWiF9yA1eK9wrqNrHPVWMpvcIRGOo9kIrRR705yHJwtM06B7elndh8pKEQEkbdvFQFVr0UrTedfLhizWa4o8RyERfoIwNVYn+CQBnUOexKJMa3yRkxAwgGraOPEUAqcTSDUqL6CVCKIMyKQZLkDi/XUYtUtzuiJHeAfdp76zn+eqq1hkeOcxXUfX9V4ypXAusNvFGAcpE7IsYb1es95UMf5INGy3a4oiJ0ly5vMLjDEcHhyQJGkMaM9SIFAUMczdOU9V7fpQ4ejNiqQ7g/dR8ti2LcvVkkQnfWEV6EzLdrfG+xD9XGUBgDGmh2KpHpCVRNy/99R1Tdd1bDar6FsjUBQlWRaLtcv5PMZ4JEmUHeZZ7yUr2O12eN8wn18SQmAwGF4XkSEIApK2cyRpVBaFEKLMTse82aaOWP6AwznFYDCia1sG5aCnMjuCdwzKKN/0IdB25jofVclYWKZpQtNUGNsSmg0nH3yT4Greevcxl8slRZYyGkqqXUuqEqxr+3w0hXEeGQSXu4rvPzjj5RsHZDKGhLfGUTcxMDlLJJlSdMCHlytWxpIohbOOXd0yHBY4D08vLghCoolZdRESY6h2Dcv1lvPLBceH+8ymU8rhjLpuaaqa0AM4uq4n7favlwvxM3f13He73TWVezgaUO3qGJmVF0zHY9IkBqEHATpJUSruAM5HJURdtwQho40keFIZs8qyPEFrRfCgtGQ8LHpKN/39H/61r/021a7me9/9q6hmMoauD1oPxHuqUoqjmzf4t/9b/zbHh7dQSscMZu/ilFZGomnM2YvxB1rKaxIqMvIfnPs5hVBfPnkKCHwCaT7g4OZtms2a+eos6nttR1A5Ow8qkaAEjxcn7M9ukBRDgnM0XiCKISUZ1eKEy+0aneW4tiZRmr28ZNNAvdvR2gZsTVaO2RMlvmnBS6r5OTaJaOedWzKYTElUyqOHDyiHQ/JygpYOTPREZInh9o0jhE+puwZUArqk04IkLdmtloRuw3CQkiSe4+NDdpslAcu8WhC84catWwwmBxgfMHXNdrHGJwWjwQ1u330RTEVVbznbrajqmiQEbLND+AxnAghNu6pYnT+lspYkTRjMPKm3dLs5DYFM5YBkPV+wXG/56OOnOBMJhlrGiYtNQtyQrY2TMCnjPEfGMOoySfiNr76EVpEcWHdRy+37D83V4S/PM1Lh2JlYsLVdS2MafvjWW7z/8AmvffCUl5+/x6//nb8FoWE8zHBdQ20DX//Gn/DNP/lTHn30HlmSxXBVqaLB98qQCcgAKhGUxYC2kwQVR+2tMbQhkAhB0xo2Vc352TkFltsHE/ZmUz4+/ZC3PnyPl5+7T71aIIKGLAdV0HWwWVsuNobWCO5P9xmWQx43DZW95KYuIAhMK9CpYLY3QauUxgbOlhfYLrBeb2nDALP4iGExQSZ7GF8hSOjqitCcILqKSZEzPznDOx+75r2eXcjYfRnkGdYEpM7Y1TFc/fT0hEB8b65MqXWzpam7vgsYAzZz5ZjtjRkUJZNRxu2bM5brmo8enzNfbXny/gdUm0+JZz/PJYLsJ0+ghUCEPj9HaBZmynv1Ed+3R3xocqyHXFmSVMUg6dohg8R7zQOb8sfVDYIQfKGAkVoQcAgkUroeG38lb5Q0JuWj3ZS/bo/4XrfPzicgDFJJfCJRzkdQg5JckPKnTfQ3/KIXTNVjBCbmDol4DwzBRnmJd3ResnBHfNjd4a/NbR74ESE4Mk/MA5Qy0lWFwATJR27GwMWfczcsKHqaqBAykgWVRCIwHrbrDY8/epfJcEbWN+biNDASHK8m/aE3yoe+CLvyrvx40vbjKZvAY71huT1hsXiM7Slg6CRK8mQWJZv9zxQ/WQP+xG+kTNGTFNO13H/l8zz4+H0a5xmk+9x/9uW48ftA0+y4e+95gvcY21EUQ07OnvKDv/pTquWcRDqK4ZTzRx9geqz4amGjjwQHUhEECO8RIpI4Y7HYP/M+0FVLRSIDBh0nX9sVq3nC7TvPYLstTscg7CJ5wuXpKdlwTJambHcVwXsCrj9YSJyTGGejXzgyvNlWOz48W/CFl1/ixkQh6iHKN5T9v5sLR6IlTgasAJcWEXakwGUZwnpclmHyAoFHeo8XAukDAY1TKV1qCHkR8+6cwTuLETGfz6tP/bI/z5VlmizLqesaqRRaKzabDc7Z2P3XScxzCj4CzIRkuVpQ1VXvaSxIkpTlck6WpVEOKUS/t8VAYaX0dV6XlJLdbkeex6mVc5amafuCULJcLWnalmFZkiTquvBq25Y0zWjblixLsTY2kJSKBVNV7VBas91uegllvKI22y2hPzwnSUpd11hr2Gy31E0N3rPdrpHX14hFCsloNCQwwNlI097tTqIkEdlHdLS0XUtelNR1TZqkvT9OXPtsQ/A0dYWx6+uJHgKSpIedeI/W+jo7LASH9zZGUKQZTdvRmjiJb3ZLlg//GtNu+Ob33qOtO+4cFDx6esl0XHD7eMCuazhbNtRNL9vzHqkiXGTbWd58cspsWJKJGFFgfZQgWi/ZCMuT1Y61iZNOlSiyLCFPo7RytW2ilzCN9+q66SJ5Mctw0iIENE3Lx49OmC9X3NifMplMUbKk2laxDyejGsSYiKmXUvbF84627a5liEma8rXf+jsc7kfK9z/7Z3/A6cUCncTQ87LISet4T037KCbvotexbiuch8FwwK/9za9yeHDA/v4RznV9NITAuYBSEfpxtccgFL/1W1/j4cfvUdcVbdvFRpqztCZ6J5Mk4d/8t/4tnrl3v9+HPVqlBAJKRZhLmmgQfQEffN/0u7IiSIKORd5Puz6R4mx8fEjwgbPLUxI8SmdkZUFHYDSacXh8HwIkST/KTscEVaHLMZPRiOChrTas5ku2uwV5kZNkI5rdGukF1XbNaltxcnaGD4G8TFHpjEE+jESypibJC3xZcnBwl12zwVSKyWCf0WTMrYNjjDFcrFY0viOnZXF+Qq48mUwIXuK0Yjg5ZG80wQpDUQ5xQuK6ggpB5z2ZFixlwrY1OD0mFYKknEGSsF3P8a0HIWmbCrxDlQOUKEAZbu4doI8KhE4gSJ48/Yi63nLn9l0ODiYMi8C6qUGmiCRjqEbQtVxenrNqThkMZjRtw7vvP+JyvuFgUrBrHfvjAWfLHTvTYmwMxpVSxjEw0TA5zFJeeuaYr/7qq9RVzYNHJyy3FVJEuZL18ebUeYv1kiJLcSJ+QJ0PGA+t9XSbFX/xl9/ie9/7Ef/5H/450/GEF156AZmmvP3GO7zx2o+wpuVwMmRT1bFz1nUEpdlWNVkazbwxyFUzGg35zPGzPDg9Z73bkWjNtmmpu4DyhnsHgZtHU4QvODjeo9hTqPWAP/zLH/GHf/k9Fusdn3/5Ns88/yrHz/4N8mxDKiWehpA4MikxpsMFCK1hs7zk8fwJaTICeRPwCH/BKC/YSzWLakMpDWWhCYMRtt1C11HLHExDFiyiWVOtT2iF5r2PziN22ples58x3Z8xv7hku92RZ2mUgXUmTjGDRyndd+Ic2+0W6+DmzdtcXJxAgDyFz7/0DM+/+AJFJrhz4xghW54+ecqwyNhWHd/44RucXsw/iUv30/WzLin6EZFAhViEOJGyMPu8WR/z7eYGT9wAIySVi93eUQKlllSpxxqBEHHC9X6d4cRNvIDPpIGhOkEgUEhCEPjgEc7ThAEPqynf2h3z12afhU9BRsW/9IJEOpSWuODRCFoEpybjT8Q+Nji+kBhm6imeChtid9C4Du87TEg4t7d54O7xvXCXBy7KfFUAHzypCehcY5UkdLGQqL3kdXeADYEczc1gYqEqJFKpiNoPgiQbkqUHPP74lCR8n3I8RKdZLPTCjwECSkhEEhs1kig/Eb0sSQoRg3KVRIhIzwpCsNwuef2tH/CD97+DlR4hFUoJhJZshvd4krzC8d0JqY6d86tCDeBa/92XhVJ4FotLzhZzpHUcJiXeGo5u3KPpWkZuFN/vJEEl8fB5+859fv8/uyCnY7k6Y5AXBBHJjF0QBBEIwUWjee/xQ10VnBaCRHqHU6C9o8hSrDUIqTmY7CHTEW21QMiC5eUJZZmxbk+YHd7n+GiP9cen7M32yLOMxXKJThRu42NTTmoGg5S6biLZzPtrKMKD0wv+5PtvcPyv/9f59f/230OnSe+XNzFQ1XQsz57y2vf+jNXyKVmRc/eFL3N0+14szvFYApgWqgrX1mA6nIJWS2zTousdoa4JpsVpgU0zbNNANvpXfrl+un68ynJw7ctyzvaH5TXOW5TUkQzcHzKrqkL3sTBax0P0brfj7Pycrm3I84y9vT2yNIugkdWKoiiuGwFKSdbrFVprBoMS35PztI7NFu9hUBYUed5/NmNzs21bjDURge8D8/kciNPuKGkUGGMRStI0NVrGQ7yUgs12E8OjRyPKsuwP3Y7VaklVVxzsH3JwcEDTtQQCiUqo65qmqcnz4hrs0XYtEJiMp332mGAwGPTwkCzm0yYpxhhUovFeRQA1oHVCZ1q00j350YEQpFmO0glaiOu/G0KgaRs2m10EXaCwAeYff4vNxVO++f2PMMHyzH7J8nLFuMw4nJast4a69jEC6qo5LARReCBYrHe4YUG92iBCIFX6WjXQGsuu7fBCUGQJo0FOnqgIJ/GeXWuoW8N4NCBRgSJLabME6yN4xBFAKrSSeOvYbitO+oiTvb0palSw2VS0xtN20U9vretDt12c6odAlqeMR0OmkylHR8f8whe+BCGwXm35/T/4A4yJ9+um3hEC7LY7pFK9Ly1+hvI8wo+++tVf5Re+8MW4d0pFwGNMjSRBEsmLgrifee9w1jLdGzDbm7ESgSxNyLKMumnQbYcQksF4xDP37iGC76eTMsaFhIDE4YLDXssle2+vsfhgkTJSH7VMYnD1T7k+keLsvXfeIk1BFynOJ5zPV4Q8g8k+uyxFVxvMbhW1xc4wKvdItGA3f4JdyAj+6KlY1md0rmN1+Zjl+ZxEBUzbUNeG6XSfLNPMDo4YTgZkWUFb7XC2gqDZGIeZn1EMS8rRAVkxQApF11TsliuGacnlxQUbWsbjKa6Fs82KgMeFimXdkBcF1ljG4zEyHzKc7CGFYr1eYY0gSwe07Y6629C0UdJ348ZtBukILx2LpqLMPHkSkKbBAIu6xnSr6ElJMwbFPjoZME5zVs0OREI2HjHeG9NJwXYdb5Szm3c4nOyxvZxjTEtSlEynE0bna9rO8eKtQ56cLdjUDVVnrvREgIgjcmJ34OXnbvMP/t5XuVXuYdIhq8c7VpsWR9TVCh9H8egEYz2ZUkxHY+p6R9MYlAhxMugDjW3Ztg2XqyUPteZHb7yNTjWL+SKaRrVgVTVoKSmDoGpbgjBY70h97Awb5ykRlHmOShLyPMM4T9W0JEoiRWBajHj2zj6Hx0NCNiQtcoTSfP7Vz7CuKmxQZIngCEuhPGH5AF9olGi4Nzlg7SWLy6eIALrcQyjB5XZN22xxwvNornCNoV3NURJGgxKdKLKkhHbFZLZPPpuAC6x3O4xVBDcg6U35r7/1LpfrrpeH9CN751iv12ilkUqRaIWSUWLVtG2cbngYTSecn53RtgYh4eT0KYJAliTcvXHIlz7/WcoB7E0OOTyeRXpWkGghWK1W7A1y1M+QOP/p+uRWnHtEOYYUCkLBthnyXnuDvzTHfGiLiEUWUb7iWssNf8mRsnwox5zIHOuviBySjxvNPxe3aBF8MbUM5BzlBQiP94KdKfig2udH7S2+3e2x9CkIgSRuQtOw5gW2tD7lcZiwkxLpBU4KTkzGN90hnXZ8Pu0YURHootbeW4xXXPgbvOef4/Vwl0eijD6zECUy0tXs+w2F08yLPdYuIJFIGaid4IEf8rwYchzWgO+7k3ESL4QgK0pUOMa5jkdPzyguFz1lbUm9eBqlm8LHQ02Wo5MU4T1KJshUR8xxIHbjlUZohZASKRPmq0ve++CvcCdnfS5cnOJ47XlYrvlh/WeMlpbhYHRd5F15ZpMkHrikUAgl2W23vP36D/j+D77P3YMjjPgez965wWQ4QCqFa9q4MUsFInpFardlsbpEbFdMBprl2WOCNfiYEoKWUarcu1xwxLDZ+AqCCB4vHD4KOvpohYxiPOalL/4SWbrH48fv8pW/+Xf56z/8v7I4fcJgOGK3PmUyGDAZDgnGUg5yjGliZz6JsqikBzLQN+GcdTgfP7u7puZkseSvv/NXvPilX+DFz36ll43++BBR7D/DO8uaj775p9w9uMnNz/4mt249g1D6J76tnwD2h5coN41QBLwFH669RY6ACxbxs3ClP12f2Do5eYL3EcJTlgMIgqIocd5iupYkVeR5lIFNJhOEkNe+saqqydIMhgGGQ9o2xsOUZUnbNVhr6Loopx0Oh2w2K5wxjAcFeItEkmcpUkaPpbH2eqK2q2Kmmdl1PT6+w7l4iBY9tEQpxf7+Plor0iwl0Smb7ZbFcoE1DiUFh4f7jEYTvLNofRUsH8iyDGstZVmSpikjRj1dOWE8HvWWBInr1QFSqgjMaVuk0kynMQzae4/vEf5VU5OXBULQR3v4Hp1fkOc5u92WQBwiddYBgvkinueM6XDOxvcAgdSSpt5y/vA13nr9LQ5H8PbHJ1jn+dzdEV3nmE0y5uuI2c8yRZYJ0jR61713ffJBpHUTYqFVWxfplMHENlTfV0yThCzXDNKURAukAOs8TefYVA1FnpElEq0FWis6ZSnzjDTRVHXHtmrwViGVQklJZzwnF0uW6x2plkwnQxCKzdaw2WyBWNwUeR5VFUoxGY8YjUakaUZVN8w30a7x5a/8Mg8ePubBRx9gOxM/B87FqapOUNbGBqBSZFnGL37ll/jKL/8KVdXGQjUE6nrHaDxCJ1FB0TbtNc3xaglgNByzWS9QWqGd76Ftvn/PJwyyLFquVfRoGmORIkSpupDxc6Y0smc3SEHfvBMY03sBf1K28f/l+kSKs3a+pVGCwUyQaIFNR4RiCF3D2lhyF8iaCoIgK4qY3m0dVpV417HbrDi8fZfBYMRIHtLsWrq2YZAWLNdrEAVadRzf3md2dItsOGCzvmA1f8xqHU3gh0dHFMUeCEG1q2nbLZtNRplnjKVE1paL5QVVGycpspTk4wF2u2C92ZIHQxUc2Sh6zzpnmc0UF48XZEmCzoZ439DVFaXKyKYFi/OHJMGzW6+Yry/IkoLV6pwbxzdJh2NM06BkwjjJ2TqHHuRYEbC2QYUG2xmqxnNweBMRLOvtiuneEeUkYds2nO8uWG8WtOstWhaQZJTjgnyQ88rdW5zO52w7E7XAQkZZQf8hiDAQwQt39/n7/9qXuXVrj610ZKMx57Wjax3BxZtMn2ITCY1KYIOmzDS5LliJgK0s4GJoch/0Z73rTbCih2BIENE/UXeGIkupuo40iX4K66LJ8orMNBkNGQxLBsMB+8bR1oZKNBwMC27Opjx/95gXXrmNKlPSouDGzftoKbHtlty0DPNh7MYsThhkA+rdKdXW4pOcjTc8/uhjCp0hg6LQ8WaclkOOBy+AlyT5lHX9gNYFqrqhQ5FkI9jO6XxKbibcLA15KgjpmOnxXbZPvkWhBcPjPe52d3Dy2ygdKT9xTB47WBKJMQ3JeMhsVrDebEmzlOFozNnZKfVZR9vU/cFQgPeoRKO04MZshpIdWTJgMiypq20MrxYZh0c3KPKUuzdmfP/NJ5/Epfvp+hlX6HG7CIlHM+9mvFnP+EZ3kwemxHuDDOC1IhOWV+SCX9OPONJbnrN7/Km4y5MwpBMSkyqUDzwwAl8dkbmazw8CWdKSBkftUh61e3y3vcVr9oi1TxDBI4le0mNX88vZKZ/RT2hDxne627xjD6nRIGL+3qnL+Au3T2cNr2rLTD0C22CD4tLd4p3wHK+LuzwVA2wISG9IEUjfctxccKt6l4nsKAYvUhe3MSEhXPnXPJjQk0qlQqtIG43T4ggZac2WenuOCoEmz0lSTVsvqJsl+OhDRQpUGzu/EoHw/bRMilgCSHF9gFIIhExp2x3PJBmzG6/G6y/EYjaaDcBfPuY982ekSRabUMGjpEanGSiFcPHAJJVit2t558032KznPOxqVvUlP5iUtMsnpFlBQFwfDoTUWGN478HbLJZzknqHdjoeZtrY/Rcqdn19cGipkNIje0pl9PrGYlKE2H0OSQzhTbXHNjWP33kNKTTb3Yo//f1/gt2tUaUGtybPU7JCMso022rJnRvH7HYVl/Ml1l5GGapz8QABVF3sakcbRIrynmo959Gjx3z9j3+Xg5t3mO3fBH5CUqoEVeNYbSQ3Qkk2mCBUQq9BvV4SojT1v/yK6b/+9IeUT9cnu5IkvabBah2Jid5FL1Q63YseRZ30BUqEYdR1xa7aYY1jOBxSFCVSCqbTPaztWK5WMcfTe8qiIAAffvgew0FJlmV9jIONROMQQKhrOrGUEud8lK6l/ecrBOqmwXnfZ4NGMEOapGS9VFLK+DPSJOHmjZt0XYySIMShuPe9ikjF74tFUOilkVHyePX/V/ljPjhMXWGNZVAMUDJmlCECxhqqpo5AOR8f32azIYRAnhdolVDkOVpruq5jvV6ilCJLNEkvGQzeI0kJRc5mG/H8Td3SmY6sKPj+97+DuXyH472Utz44YbVp+OqrN1A6PqnV1rKuW57LNda0PaUxSvasdWgdzyHBBfJMMywStErj5D4EvAvYnp6oe0mr7m0WnbHUnaOxLtprihStRcyTAwgBJWMu2LCMhZtxgdWmwWsdr/DOsWoNaaqRMjAZlDxzZ8Z8kVI1HUmSEoDEWoSQpFlGIN7T07RAqzRSEwO88sorXJ6f4It45pT0ABNrsTaqJ9IsI80ypnv7LDdVPH8pRZqkNK2jW2zY1R0Qm1NCChKtMCZGLXjn8ERYm3SG0L8+SRI/h3meczFf0PWFf6IkxhqkitJb1Ut3266j66nDqs/iS5MEqTUhyGun9E+zPpHiTJU5oq0pVltIM3Z6QmvOkLsTGBwwGOyT5lMKnbHbLXl68QHNdsnxzbtAwra1cHbGeXhCWuQgY5bB/uyANEnxQkZvVluxmF8gFucYC7bqmJYl0xv32O7WDAcZMliEnrCpJEkxYG07ZFpQVZc4lTLa3ydgmU4mOGc5PLyNaT8i9YFUZUwPD0nSkpOn5zw5+ZjhYEg5vEHXbjl/8oAszxjtTUmTIeX4ABsMVTWn2qyQQ81kPMG6lsvFKYM0I8kkaSKYjg945uWvcnn6gNXpAzoT6Jyhqy27dMNwNCFJx9Q2RduOUTrEbdYM5ACXS4y3OAvGwtHhEcacIdSa/dEApTSd3cYAaiHxRMjGdFjw2/+132B8/xhTTNhcPCAJgl/45d/k9//0Tapmgb3qdobYARXEMffB4ZjbNyacPF3w8dMLnl6uMc5HVo7o8d4iki+lUNeTBO88idIIEeMAXAix642Muu6iJNGa0XBAURRstjvarsV4QwZ8+eUXePaFe0wmJfsHE4ajkiTLycsEpVKS2TFeSuzmnACcuoq1Kij0HrVtWFUNQeUc3byPwtERIGicd7R1RaEzCNHeng8PKJwntS03j55DZDlufcG2CzRyiJA7XNAsFzvOTv8a5T1Gdjw8f4f/83/xbdYbhxIaoem7wyHSzIQnBMnBJOPZW1NW8zkfP1mwXK5AhJjF1+ehCSEwxpCmCeOiZDrMUd7g2i3V7pLx3gypYLE4ZX92TJqmCC378M5P189rxW6hJqCZdwmv1UO+ZQ74wA/wwQACqwS59HwuXfI38ke8VF4ySStu2ga98fzz+h4Pwh5OSgRg8XzYDfiGv8NISz6fneOwnLVDftDM+FG3z7LnLAoCIngOXcUXihM+l5xwO7/AohHe0DWCd+UhJkQvIwHmvuT7/hbeSr6oA2NOWbkDPuAer/MMTxjg0KgQaYvaGW52Z9yr3+JW/Tql3JH6LZ1zPB7coyLpJ2yijxRQaBX6wkwS+hwv5yKWeLO6QIUNpk1iDg6SQaFxXoOMHlpk9K644BGea6kSkl7WGENXE6WRQpMNNCMxRYrey6oi7TKE0HtcQwxWDg1eOoSPTSJjFLITBNd3lRGYruP+cc5k8BLOepSQuPopjz5a9ZARGQs/EQ9KnfGcLy5pmxa6lkYaUpmhZSRbtsERpO+fUy+nlBBcDJ0mRFSzJGZBoSW+f9WMMTx58CiS4qSgPlkgZcJz9/eQUrC+POfoRsZ4oLhcrCiLMc8+8wzr9WskScxW2mx3NE0VpTz+qjgTPVUTbk5H7I9zHrz/Md/56z/nb/7m18jzQd8N9izmF7z9zhu899FblJPAYn7GbDJFqvRfcEVET99PNKX/hd/zk18+XT+ftd2smEymSKkZj0bxsCmvIm+aGMasZF+wuJ6wGPNUVabYVVvOzk/RSjMcjkgS3RdmV7EYseApipI0i5Izax3OGILWqETjuhiqrNMUrRISLUh00tdlsV2stKKqKtDRCkAAZy3rto2fMxEI3pOl2TUxT/ZZVXF6F2W8MQ9NXftOvTcR4d5nacXA4UiZjQAJDSGw2+3QSRpjBUxf+DWxuB0NY+7bcDjEGENVbWnamrqNxEKtNYmKkSidjfaQpm3ouvaa8teZLno2VQJO0hmHa7csNzve+/iMrrXc2s94+8OnPHt7xsWiZtsYtFJ8fFazlwa0pC+yJDFKS/Rep4DWkjyTFFrH4Tn0Mvk41vc9vClm0DqqNj7ONEkoc02qJUpGybfzMVYgQksi0VsrTaIhSyVN59m1LoJNlALnuVhW1J3hYNIxm5YcqjFaZ5xebtBJJEaKPg+260wEwRmDAZwP3HvmBb797e9wefEU02egOR8VStHzFb3S9559jrvPvkhtHEpEDzhCUAyGcV/1IZIhrY8SRDyqxwQIqXtScSz+pBDXzXbvY+P+crXtPZSCYH2vDehw1iBlJEv64NE66XPcKqxzPe1Tx4bhz6AW+ESKs6NbNwhWoHrTX2E3/YhvSBoUfnOK0QXDQcm4KNg/usX67Jzz5RyR5iTlIGI4vWM5P4/kxmTAloS6WZHPZrRNTU6gcgrrYLOd0xlDOhwyeeFFEjFhs7rAuw5sFU3YQ43saoK2yHFOEiQW6NqO0/OPcSKhHE5pjCGbDrl1dJvBaIRxgunYRBOh0KznC3SWM5odMhiOY87UcolrG5xpGYz3uHFwjFAJptvRrDd0PpBO9xBtA0pQ5Clnj36IazrSJGF85z6D7Za2bkiSnOAq/GbNyYcP4mt68z6z6Yz8aMB2u2G9XlFXHc1szPsfnDA+nHFHwMXFBbUxaK1wJpZXUsSu89/59V/kheeOMVhqYwjJEc6XnD55ghIe413vuIhTNyUlN/ZH/Dv/za/xzHO3ODl/xMHNMw4eTXn7rY+5WFesNjs2jWEbLKrP4ohwCxVx8Vojfei9JzGrQilBrlPyPEFJRZ4lDIcDqrqhLAoSrUgEvPDMXX7xy6+wt1+i0oTJZI/pbI+sGGK8wXjLdnOCcy1218QxfLvjjB3jYkCiS0KoKVXO6OAQUGw6yc61KF8xUDGI8uTikl19zt7sgHEyQSQNl2cPaKsKqQUiOLLsgsbmeOuwzjMsxojEsG4F3/rBA959/xJk7J64rse4JnEDCM5w52jGr37uOY4OR5zPL/nw0RnORjKmt+46U8U7379uCccHe9T1mvffeYeD/QlCxrDpJI2Us91mg/cWay2zvf1P4tL9dP2MSyqJkprOpzyxGd9yh3zAEB8cSYikqkQJPp8v+LX8CS8N5uwVLRpFqhq+FE5RBH6/ETwUezilAQ8+8J4p+fruFkrm5KHl9V3GD9sD1j5F9aZzgueAHV9Ozvh88pSb6SXCNSTAHd3xJeXoTOBjeUQtHJ4oNTy3Cd+XB+Adt5J9zhnyI3GPR6IgoAg4PJB6y63unBfrd7lh3mGsl0gpKPwHDK2i7BTvZffYXpEXo5q6J2K5XroXwMfjgtIZ470Z2guyBNI0IVFpTzCMG75UCqTA0dOtXIg+NCEIV56tHjqgpCDmsCfRXyslSqqIL+4fTPR2xvucCz5OqVwkxV6tEDxeRDGeDIp0XDKze/1hMBZhV/e24APGRYmNCKBwTPdKRoOU9XZF4gPDNEEIhxQBHSIowMvYafe9ZPtqmw7OE4zH9N1bUh+fi9J446h3O5QW0V9nA3NTM7zU5MeBxgi2ywuGBzfYH+fU1jNvapyL5D0pJJvdrvcgC5I0w5iun+QFgpCcNR2fzVOE3fHeaz8k15I7d++SZhnGWD786CO+++1v8MPXfwRs+MJLLzDOJOVghJBXaOyraWZEsQtx9Uv1lr6rCbPoJVV9TITK/mVfop+u/zerblqE2jAcjliuVjGPU0cPZVEUUUbfEwSNiRLDJImhulVVIZVgNBxcy2CN6fA+eteU0my26zilEDAcDlE6JThP19aMRwOcd2RZwWhYIpWKsRjQwzW4vu6KfEiSrJFC9rI9i7GWti9wgveRsGc7qmWDMxGzLujBQD1aXar4GYyP16NVEmN8kiRK4JzDC7Bt9JoVSYrWKdZZ6qbBdKaf0nmU9HRty5aoNPK9jLiua3wAqZIo4XWWREWSYwiB1jY0TY0gTl/SNMU7S571zZBYOhGE5odvP8J4xZ3DkvOzFV/47G2224bGWLQQyEQynzcc3i6YDlImg5ZtY/rGVC8pFlHRUySaLNGkOt6nPbEYszbQuTgta41j1xjarmM6GZEqQZlFCZ8WKt4vQ2+VkfReaddLyxUShfAx6PlsGaEnQgqKPGNYFFhLnJppT+pC9L9KASrep9MeCCLlj+8f1lmGw4LpdES9XRCyq/glQdvLXRGCPCuY7e8zzOLrLpVGSh3R+K7fR0L8GhULHikiDVxKRZaXOOu5Gk0AUfkhOgIB4xxKx33KGIt3jq4vyrRUaJ2S5WX83AWJD1FVZpwjCI1WKd2u4umjRz/1dfqJFGfdbkuSZGytxfjofRJdh05SSqFp6hqlO1ozh1wyOTiGgz2Gs30aY1BCsNxuMM6RS81UF2SDIU3w7JRhMJmwP5piqi2V8xgk+VCTqQyjJe+/9wPq1jOeTRlND0naDctmQagDuYiV/WgwYVxM2VrNen4aDYPBUqYFm/0ZWRIxx7u6IljPweEe3gaczDC2YaATqq2krupYBXvBcHiARzIcjklyifAdzhY4Y/EisFrN2WwWKJ2wvLzk8PAuAU1dN7RNR5amWFPR1iuGecmNg2MOpjfY7FboTLNbb9DFHnp4n8xfMj95gzfe/JCnZ+fcL4s+/Ryazl2jXaWMHgMtAl/50ivcvfMS6+0W5Tr2dGCzmvOtb36d3Tb24J0P0cAuJYeTAf/Ov/Ff4Ze+8gpJUnB0dMT55QmT4iOO9/d4+OSS1959xOLBCUVe4nrktxAB3Y95Q59pEZGwEp1oyiwDEUi0RgvBwWSCs5bRcMBmuwEfeObOTf7Wr3+F2UFBKsGHBq0c3resN3Hs31QVpuloMSRSkYmEcTElkxnr+SO6sGGSDbDGcr57QpIWKJUjmhWtaUnyAYuq4e33n+C84uxizmyUMxumDLOUXEfMtiintNbz/bcf0LUd48mQ46OEXAm8c/z2r/wqT88aXnv7Ic5GB3CiNVIIyiLhxVvHfPlzzzOdpARnKJOc6XjAYr7DI0l77bwQAkd875wPKO+5WSTcHCeMxxl5kmCamq7ZYZqG7aZmXI556c59LjafTH78p+tnW1dhp1IIOpGy8Dk2JAgcPihS6flCMudv5qd8ZnTJJG/jRCWAFIpZ0fFlcQlS8btdygduhAwClMCGlNfqwNYfMRWe9zrJecgIMnZ2BXBIxS+kZ3wufchNvQS3Y9eZHu+/5WZo+JwPNAGeiCOMUPj+sHzpc74tbzMNjnUy4KnPcUKgPMhgSb3lue6MV+wH3FcfUOZrAlF3n6rAUXrCvs4ZeMn31V1QEqGu8m0sQkQwR7jyXQWJzhVlSFByhFSBPE1JVdr3ea+M7D0kIERpDS7KAYWQhH7jDoIIBYFrGbfEI5SMhwQRw1gBlFS4EEu14IikuOBRgArxgNA5jwm+n1g56KlrQvYDsl4WdfUvKh8lKyJAEJAHz+0bMy6eXtCajqauGZQKJz0qaIKI1DspI0FNao3oY09cD5QxLu4XwRpklhGcp6pb6q7DG0/TdIg0o/OSs/mC2ThB6pT1/IJhWXBzf8qjkw3B1iSJohwM6NomNsB2W1rTkWmN966Xvcfg1NWm4eOTNS8/cxvX1mwXj3h3/QC0xBrD05MTZmXLl165wXQQePTR93lNN2RlzEuSIRJEpYoewFgYC+j3Aqk0QmqUjn8uZfw+rRT3X/m1f9WX7KerX7du3sEH12d+efJ8fH1+cL3VQQjBcDigbZN+IubJc0maJtcH6LZteqJiEgEbdRsb13W0sEwmY5IkoaobTNciReDx06eMhyNme9EPKWT0Y17dS0PwmK5FJQkhCEaDUZxYeIfzmgKwLr+e0LWm64vCeJ9QvUSvbmpMZ/EuUFUR125MDKG+oiZe7cEQGwxJkpCneT8x6yiLktl0CsRJXPS5ZTGntCdHXjUkhqMx1a6i67oIovAeEQLOO0zXxZu2d9dMAGOirG+1WREIDMsRzjl++Vf/BvOLU37vT/6Co1Lx/J0R3nTkmeZGlnEy37LZNnzuhWPazjEuE24fDjhfNTQ9GOQKTpFoybDM0H3gt3UOayzGelrj6ayjNZ5t1dEay3CQMUgViRZoGRsvSvagER9iTEIv2JH0Yd2CXt6uKLRkUqa0nUFJwWwSvXhd56nXW7RW7O1NyPMiQt+kjhh9FbPTfF94E+KEixBfskSleDw2OLz1/b0lIvZlTwntjInqgBBBI67/+1efVXoQilISUAShrmMB2rqJZ2cRz6umNb0vLU5mfb8PZXmBD4bMJ2RZnxnnHF1n6Ixhu9uQptEHefXvWePYbja8/95bP/V1+omc8AyS3XYdK96uZbtaoIsSs9pxMV9yeHzA8PAYIQTVesnDJ48xMgYM58MB222F8R3T2R6mTHCt5Wz3mOnt+9w7eIYszTCt4Xx3SToZsD8coX3Og5P3uHPjWZJtzmqzIS9yslJCMkD5Bm8tAcX5eoFMShZVRTo4YLp/gGkrNpuWzWZDPop5Hqerx1TBoyXIrWCgc4ZlgQgJSE9DRVYMGKsBbVfRIMG0dOtz2rWk9tB1Gya5RGc5k8GE4AOynLBcLJmfXzI+uANpSbN7yvryFCWihpWuIxuNMbpEqRKhS9hc4LoasjxOwzLNYrmNnSohMM6xa2o656KPTupI5dGQyZSDm3e499nfxNmcH33rnyHq9zg9O+Px6RLrI7VG9BKdNNX8rV9+mS998UWapib4hLIY8MK9V7mxd8RHjx7w5z96n3eezAkyQYhAJlXs9IpoFg6Akpos1VHCOMj7cbslSxJUf5EPioLBoGC93WCNwRjPbG/MrTtHOCzVZsPeeIbykvX5BZUxWOPZ1SuW7QqdDxgNjuhoUCpQVQuabUfQGhkadJKCVyznF4zyAeOsJAwmLLYLdqste3nOzlhCZ7k8X3B5Znnx+ZeZHt/nrTd+iPdb6q7lw0en3ByNGJXw8OkTus6SpylJUfAbv/gFWuNZLLZMhgVeJXz+5Zf43KsvczAWtOszfNfSdY7b+yM+89wtHhQLzi6WeBuwIQZ0xo6eorMOExTjo1sMxooky+jaGtMa2s7y9HRBY2E93JCkGReXZ5/Epfvp+hmX6GUyBI8WkqEWXHgHXqKk4RU951ezJ7xYXDBO+uxBokdNAAjHNN/xi+IMudP8F92zPLIF+CgjMUjerzRaKTqlEFoQvIRgOAw7fiE54bPZI27kc/D1dZBn13YIoUiU4678AG+jDPBJckQrJYK4Ic5FwgqJFwkkqs8ncySm5VZ1ykvmXZ5VD5ioJSpNkFqRXMuPFGN1xsimZAHeZ7/f9H68GUoh473Fe1LpyFIHQqFU2ZMX44YseuO6upIdAca2EGKjRAkVqY1SESR94RQ9TzZ4XPDxdXWx6+mF731uoZfvxEnZ1aFNCBm9bMTv0VLD9WSt91Kp3nUlItAjUTpmr/WHLedcz3eMz/ezz93je996G6kEXWtJVZyixy4q4MHJCFcJISCVxlnbT5Wi1Er76KfwAZSPkBKtdKSSiYTKxEPXQKfMlyvSvTFua9hcnjM5zsmkYSANL9w+wpBwNr9ku1mjtULIFEFgkGUxHNZf+TccTxdrbh0fMFUa0znKQYXsJwm3ZhnTX3ml99EKsiQl1E+p2pjrGFwAHxtzUsQCNviYOymIDQyHiOApFwjexQmokJ8WZz/HtdmumUwmZFlKCNC0HfP5nLLIESJ+DieTKSCuoT5Jkvfh8tC2Hdvt9npS07Ytjx49IsvyWODkeQ9RWzMej8mzhOBtX8RMyPIcGwK7uoamjVlhSvZACovpOkqpevKq7KMr4lTsKtPs6vCr24bRYHg9Bbs6LIcQKArR2wYsxhqaqsF0tm+O6n4qGKcqif5xwzTLsh5YIWIUwE9Mc6pdBULStl0EfukY9t6aBuM6OtOS5zlZllEUefS95SmbzbovhAuyNKc/+7O3N0MribOOqrLMlzuenG5QQrA/TXn23gGJ1Fwsd7z+3hnbquOV5/fIsoRN3SK14t7hgIenW7ZVT6buJXqpzq49v7vGUrdx2uiCx7pAYyyrbYNKcpQPDPOELJWkqpeSi9h491cNeCGRweORiBAQMt4nffD9+2SYDgtCyDDWYjuD0hrb1VGb5TxPnpxx8+YReZITiHYT7130F7pY1PkgoCccN82OIKKCKBcZHQZjHdY5lFYorXBdFz283mN7HkKiNYnSeN8DinolhTUO7yOgThCQIeCxaCnjoKIvqqWIhPauaWlNS9ApnbM9GEdR1W1UhUlJfSVV1QmdcXSmigWy1ggFb7/xOuvV4qe+Tj+R4uzRyQNssIzLCeNiDGVL7ToGwwmXFxcUmwKtTlm3FZXdkicaXczYdI5ZLumExWAwzQ5PR4tjMJkyHQ3RUnG52eBsRyU6pJrwow9eY5IPGZQTbFNjbMPx/iF70xlZlnI2v2RSjNhulpSTCUOd0JmGLElZLE94tF7SmEBothRpzsHeMWmaMyIla2u8behsyyBLGaiEdWXYOEPjW3aNoTwckQ2nuN2a1WZLNtoj0RldXbHetSSqYJikrKsVKs3Yzh+ShgyhErLJhJv3vkjz/jdp2hG72pH5QJImXM7ndGZOPrtNlo1gu2Z9+oSq+ZA8G5AImM9XWOd7ImBEo2aJjDhVrjZFSZZCkng2y4csLhfs1g9YLLf8p3/8PbaNidKoXnSspeTzL9zht/72L2O7DbvVgrl9yGazxcuMizrjP/rf/1Mu5utrrXGqNM/dvsX+3ogHT5/GwMcQR8JpqijTlERFo28s4ASjsoi0HAFnl5csthXWeYpU89yL9zhfnXA42cMHwUcPPqRIJEWRoHWBtBa3qXGdYJyU5C5BSsGgKNk0nsnBAY3paJsVMhUIleJlyqpu6bxDZoYu5Gx9w7rdMclTBjpQN56T9ZYfvPsW+vEDFqdzFJLVdst6V+EMPPu5r3KkVxhjeXQ558MPn/Lsi6/yP/oP/gc0px+xvzegai37N+4xvfkcWTFm+eRHzD96i03dMD64wStfzHiyMvzuH/0R77zxDsZE82iapugkwVrD5XrFslqjhaD0Q2g1lW1J8xyvRVQBILjYrNlW7Sdx6X66fsalpKILHuPigT0TgYkSNNrwRTHnK/oJzxcnDJIW4wLKCYKU/XQpSiwCgnGy4fP5YzoHv+/uc0qBD1ES5KWk68uAREZJ9szs+Jx6zEvpRxwml3hr8dZjOkPXOrouoPAI3ZEnG54R7+McOJlwkhzierxvkCL+7F6jL4QgsQ3H1QX3q3e4wbsMkgqV5CRpLMjSNCfR6vogVYZLkk5TGEMiIlUxSod+7If0wSJCTSZrkiLtfSLh2kwdfCy2pJCocDVHS3D4Xr4okbr3tUZ1XDSehyiXpC/EYr5X9BaEK3llgERFWREydmCtkAgBme4nSKGHIgV3XWwFuAYrSdkjkvuWsbO9N4XIHPEicPfOEUUu0P1j6UwgkxGSFKTEhlikxmw810/04t06BK7BBiFEaAJpQplllHmOC4LGCqZKcrg3QruGYT5AekNTr6k3S4piCG3DnrYRl50PMO2WlY6fnbIo4sQjCOqmAmMRCrQEYzrWmx1t09HULccHIxJlAChDjmCGFKqfnsTJgw+yD5mNjYar4lVwNT3tDzkITIi0PWMN1ts+MNb/q7pMP13/gqWUZr3eYIy9ljMOypIQInUxIKmrCoCq2l1TDq/Q+k1T07ZNr5SJE6zRaESWpT2lOMGYDmM6Tk6eIoSkbZtrtD1Cst3tIiwjzemjCKNUDuJUq2miRM0qpBSkSR5BQX2OqIqaZlQP7QhwLXvLMkWSJAgZi7U8i556OY3k7TSNlFbXUxebpolQFB9o2rZv4iiM8azMOnrhevmulI6ui5TuLB9gbIfzFi0Vs+keeZ6jlI7QNBulglVV4VyMB5AyZqZlaR6LBudorQcJvmv5v/zj/wNPPnqXXCfcuzlBSc0Hjy9564MLAoFbxxPGRU5Z5oyd5b2PFqS6R7tLSZrGbDXrLE1nWG4bYpStJ8s0UkJdB3aNobMuRgQQz1njMiVP1bUkNBJ3I11W9Jlw9NNNKXyUj1/lekWsB+CiukEIqqomz1JUpBDR9RO1Bw+ecHQ4YzCe9Q2q+J6HvpmW6gylEr7z119HeEdZRHKocA4lJGnSB1zb6N07Oz3lyZMn3LhxkyxJSNCAQCdJvy/Qf2Zirq8T8XNEgK5pMW2D8FG9ZGxE/kcJJHRti7MdpCnW2P4+GO/Zneli48AYvO9z5ojxEN7bSPKWmtOTJzRN/VNfp5+MNirXKKeRRYorUtqLDqkFKpXcuX3EdLiH8IEGyPMJ7XzLw5PXGRwckueKgSrIkzG0BtcFtutLtiLQGIcYDWjbltn0JuWg4nz+iGq7IFQNorXUm0va2vHUnfDcM/c5PrxDITUmTUlmRwxHe6BT5vM50nbcSEZkKSzNktp7lAlUy0vISqyAECRKFNyYzCjHI/AKWz3l8uwxUkl0knJy8TFZljEFprkEDReLp8i2Zr8Y4dIcP9jD1RXbbodzhsrtECgOq0vM+oSmqzFOxKJ2MsU7S11BLg328kPOHv0Qj6JudgjnGRQb3v3wjKZrCEKxq+IIXQhBniRkiaM2BiUhEZK90ZBSdTx545+TDoYc3b7Fmx/N+fh8jQ4CFwQ6y9BCcDRK+e/+g7+Hly3V1hCEpPKWjy+X/N4f/og3Pzq79pZppSjSlDTRjIY5Nw9nYC1Pzs9oXTxQFXlKmeio85UwHRaURU6RF2yrmvPLS2rrsD6QFyV37+xTpg7pWs7mT2mqmixPsUrzqKooCxjIjGw45p7SGJ0xvf0K3q1ImwWVVjxdPGK93IIzHBwcMRlNGIQx28U5Pp2yaR2lgrs3DpgOMrabBZ2XjGczpodDRBBIkdDtjXk6v2Q2yzlfdTQuZ37+LsW+Ik0GHA8VqZyyPH/A+92Oe/fuMbr7Mndmh7GL5iWVyBD7X2Q4/AzHwzGT8Yg0keys59wEXn/tDayNwb7ee/b3DgjS8Xf/3u/wG7/xFVJds1vM8QG8HPOZV7+KLFI2mwXr5VMePjrhuw9++k7Mp+uTW2mS4kKK6CytCzgLhTO8qHb8anrKs+ljCr2jNQ4ZYoZXDIaXBCFwvf5dSUWp5nwmbVl0jm/6Z1moHOf7yVPwsYARkom0vJxc8Dn1PkfZnBBqms4hrMB0DuF6WmtfrOAdiVjzLO/jbIoXBavikMZ5Gg8KgRdRlltgueGWPNe8wzP+XYbJEkiRqSRJ05jjl6RkSkcCFQ4lPHf1HG0dVuwxSFKEJG5uRKBH3HQ7hDS93yl6vAi9N4KA8iFCM0KEDbm+aDLBoYOOEpueBCt8lCf6vhCzPYEwFrs+FkIhzinVVSYaAdFTxqSM110q4vdcd1b7DJurLnnPmowgEiGvYYNWxCzIKHuJ8KXJeMQrz99i/tEjgnPgA9b2xZ6KBZL1AZ1mGGdJVWzG+c4QhIqPT4MznqD66WrfxRfBM810hIZ0TSyOpUDqglZpzucLBoMxdlNhjWC7a9i7WTIZDijLnKIomM32GI/HbNZb6ramzDO00swGJWWm8L6lqytW8zn6Xk4iU4IgRr9Ide2lcCFCaDyx/JZX+T2e+Jjk1WHd9ZPYWJB2VhJclLdGeeenRJCf55rNZj3xzsbsr6qiamrqekeiNDqJHsnxeAoETk6eYJ1FCkFRDOJkrG8ojEbj62lZ09S4tiPPCvK8JM9L2jZmXGm9RwhcF3qRAFlTyRhsXRYlOolkWaSiamo221hApklCng/Ii6wPqc4gdEAgS1LSIsf5GEqfJn2DKIB1HVLEKYpzjjgMirAM42KxmacZiVZY6xBC0rQdnYm/XH9It3WFC562jYHcUf6WsFwtsbaLQc1JRpZkMczbWjpjcD7CVNI0I8+zPvcx9E9RxExEBHVVk6qE7/zFX3J8dMDQVMztjqJM+O5rD3l0tqEscm4eFrSNJUkSVqsN623LsNS883BJ1cTnY/vnRT/Zr9vIOEiTJHrLatPLGR2TYYlW4FwgTQRFqtGqVw+IH0skAyBVbFg5uJYLdp0l2gSvVAYKEzygMJ3rabENZVkgXATOCCFxiebk7JJJ23Hr3nPcun2H4+Nb3Lh1i6aucd4hhGBvNuX113b9exNx/s6Fa4BTCALrPIv5ku1mjbh5A+cMrseCx38vNowiQE2ilECp2LgzzrHtmxQCh/OezkS/WPy7RIvM+Tk3bsQps/U2ZvVZF5tvgf599b2sNlI5lVRYZwjWoZW89vz9NOsTKc6eu/U8285QtWtOVk95snqCkorPHe6T6YKP5h9jti2jLGNQDFi1Cw7HR9zcv0meD2nbiodPPiDLst7AqTlZXGLqDeUgR4fASCruTo85HBxQjQ4YF2M2bYMKgm5a8p23/oxbdozjCCElq/UqhiZqiZcK17ac1xsKKZAhkAVJ3TqS0nFzeEDdxeTz4fSIH731LUaj53Ayega6rmaYDhlPD5FSoJOYC9FWu0h32V7SXl7w4PSU6SBlON0nkQEx0GS+ROuMNM8Ju5btekXXfpv1bkmZlXTOsKk7Li4WrHc70uGAG6NDxjLlcnPJeHKANIrX33qPP//Ga4BkMBxSDgYsLxaxI5wo9gYZfhMPKkoqhITz9WOCt+wnt+gQfPz+A8q05OVXPsuffv2PcX1i+6988TMMh553P7rk/Q8ecX5+wcOLDR88nFM1rh9fK9JEkStFliZopWiamuViSaoF+3tjdrua4AOFih6DYVGSFwVZlnO5WnN5ftkn2CdYF8iLjGfu3uaXPn+HvdmIw/0xq+2cwWiPg9GEqqlpd+c0tmOQpwxCghKWQoHuzklHM9LZHRjNWTffZ5xbrMk4OzmjzMfIJEEXJdmtl0iSAVnzMUWqOLp7h11b0ziFUCki1AxSTZYWOBKeCwUeRTY6xnnPNFcMRzOCb1gvTjEORrMbCJkynR2RDWIOkiDQOdh2gU0dEM5HkmMuSTO4nD/ljbe+h+2itCC4gLKSvf0p/96//x/w23/3txgOc3wQMe/FOza7HbnQDMYlh0dHOPciN59f82TTfBKX7qfrZ139pEVJSZCKrbU0XpKmnmEKZRK7ac7FtrCSHhwkMnorfIhkUyssXghE6JhSM/Y1OxKMiJMyhOrpZZ5EBYZKMVYeXBt9D8aBi6VEmipSVH8A0Ejvsd6iZcuEmkFoWRFQqUS6frPtH0vhPXfTwPPDltFuw0ArZKJQiQQdoqdMC4QWMeMlRJKi0o5ZaNmGLdYWqCSCIUIvhZFSgo8UQhd8T1CMRVjMxgoxkiO43p8FlijT7qyl8wbdy46kj53x+LNVX9z1npEgQQaUuupw91O1XrpyPf2S0dguolYHFWJhFkKcqF3lG8WA074ik3FS5JwjCPFjIp2MRZxUgi989kW+eXJKWzm8c8DV+67RWuJai3cWlUR0uVJJlLSHrieIxfu2DAFnbI/G9gRr2HRrrA9UTUdZZBztTbl94wbT4YTL0w3bzQrbOZQD6Vu2y0usVaTC89ztI4o8j7LQPCFPM6SA2WjIzWnOzVGOoGF7/pgyPQLu9FJr0U83r0ACAeE9wkefx5WHLkIMQj/R7EmQfdc5Fr3RSyhFPFghovT90/XzW2+//WYP8QgcHByQZWlPQxV4FyA4dKIJwVMUJYPBkO12Tds2UdpXVyQ6vodt21BVO+o67eWPKUpFdUBVbWmapg/jdbRNw2x2GL1sXY21hqt8UK0julzqOE2PE+pAmmYkScKu2mJcx6Ac9GHNKVmWo5SnaTu8B6Vlf932YAedkvSNHq3ifcc6gzMe6xx5mmOsYbm4BEDphKIYMijHOGdxPiqUAmCsZbla0dQxy61pmmufm3OOVb26nqhrrcjy/Pr1jqQ/SQjDHmwSkELFqVpTYWzHG6+/wfbkKX/vt/+r/M/+5/8TPvPSAd9/7RGLreN4v+R4NuJsvkNJiU4CbWPZ7lryLCqIjPfoRNPaNj6u4BiVGZkWOB/YVA3WBRwCH2A8TBmUiuDABUuRKLSKJV2fZ40nQuJEf58VIqLjrpCsxjryVOLoVRASgg1YY0iSSKm01iGVJFUgydnuasbDHFUHql2Ftx1f+cqvYp2PkUu26++6gdt37vDlX/kV/uj3f4+uNbSd6S0Boo9H8GR5xm997Wu89NJL8Z6VJNf3nc5GlZdOIkXROoexXWRJ+DghW8wv+4mrjzTyECW0zsf9yHnHxcUZd2/fJRDQquxBMBYfPEiFJGbjRSJklOX6PmPS2XgvT35exVkuFXW1YJANSbUgG2+ZG8tmu+Tw5oQZhzy2D8n2ZsznZzSd5e7BDfZGMxbnJ0wmE+7feZ6AI88KZJAUkxnleB/f7nh8+gGd0lRtRSY8A5Eyn58wPb7HdDBhND4kySzr5oKLyzMOxwfk6YBVfQpKEJxkUS0RIsM5Q4rEC4VNh+ztzRiWBbgt+7fv0DjBrRv32WxWLJaXNFWN8B1CJoREMNk7Yn3+gFxMGATHrl7waL7le+8/4NJXyCbn8HLDswHSgyFGSWaDCavtJbf2brPaLNg8eo9ED5iW+6yXFaePHpEP9ygHQzZmzeNNw/7RPQpKgtdsW8FwcpvJ5ENa27F/eEDo0azOBWyIUsbDyQAhwXWxc7A/PmY4OWCzWPK7//k/4y+/8x6f+/yX+fwvfok/+OPfJ3jPIEt4/d0nfO9/8U95etZ3YPpOciT+CBKlydIULRWpUqRJ7P774MmyBCsck5AzzgfY4LBty6Ao0FnGsul4ND9lu6sp8xS8JUhNPii5e+9Z/vV/8A84PJpy8fhNdqZmXq04yGdsOkFIpkxTx7Z9gjCedG9Clg6o247WJzTzBZ19xGx6zJ0bd5kLQZ5nXF4ucdbQNZZtE0jdkIOR4P7nfofB7CiSEnu9dBAidtp7bXUANtWW9z/6kG3Von1Dpyy77Y7VruPdt3+ICQm/8VuvMp5OKfKk7zZFGY+KZHFMgE0laRvDdrPi6+98i3/0v/uHfOfP/hohNZJeTuUtX/riL/K13/otxuMiHvYCqCxBOMnm6ROWdcNL4y/HzLhUcpjO+G/8/X/jk7h0P10/47p993O43/1j2o3hyGS8VI9Yk5CngVtFyyzX5NLhRAdKYoYj2ls3+g1OEJzHOYP1HY3JOQ8TzvQxxmYMg49eHSFxQCMlAUklFU/EMTfds9wNLYm7JIQ4CZIKtIqdO+s9wTqMC3g3YC7u8ii5y1k6YY1Ae0Wme7O3AN95dLB0aY6bPE+atGTyEWmiUYmKOWPS9ZtR70XwQJDs7IAzM8EEwdB3JMahkxwtkl7eEmlsrnd3X3lYVDRDEAcvvd8reAgiBt4HHxHU1qGsI9UerQRCxXw1Sbx+hdQoJdEiUmF7MGCUP4XoJTPORmmOiAWpIMoR4wrX3WzfT/OUuJI1XuWUxc08XIPuRSykRE8qJPDiS8/z9g9f5/zhCa2JYbviimSbpggFzrTkSUnnA21bR7mWklhBLMiSK1iHwXZxUtg29TU4IdGBrtrRlgXBG/b3DmnqNZerOcN8SGda6CyNn7NuPAiLROCCp9lt6DrDdDJC+oZn9zTHpeXmwCKzFKEEpXR4AzKN0wsp+uJMRliMayrqtmEyHEcEtiB6zHo/Bz3psy+/rwEN0dehsdICHvX/MRPt0/Uve+3v79N2LT54iizaDYosj3mgP5EjFouviuFwzHQ6Y7NZM59f85L2jAABAABJREFUQojNVaViVpU1hizLKcsyygStYX552XsqI51wMIgBzpvNlq6LsnylNWUZM9OMNZg6hj6r3vckpLwuFoRQGOvQSUoQgqZpaOoGnUT/applMWoGcY2Ox4d+Gq56IE78PEshabuG5XpNXVVMRgOKLEMKjxIBmWgSxDVB0nlikH2A7W7Ntqqo65qiyBAo1tsNXd/sds7SdQbvPUlyJXG019P/zhisMf3k33F+Pufx977L3/6N3+BHf/AHGBnYrCu8d7xwd8x0kHO+qlluW24dDSEItlXLZtdSGcdy3WCs78ORBc5ZpIA0UeAsEXii4kTPGvJMMxuXBBsI2pNKRaqjaiBev5EkK2VfjIlwLXGMDcmIv3chou2FInrKPPHPPX0Eg0enfb4Y8b6cJJq27RiPRmx2NR9/+AHvvvMmd555AbxDxvBcArEBduf2Pe7eucfF6SmdjXmY9gpLLwSfefWzvPjyK+yaOEkVvdRaiPjY2rYlSdOYyyckxjhE8LHolJ56u4YQJ2FNZ/oCK1I4r6Tnjx8+5vmXXkXJhERD8FFOKWWCVJJBMSA4x2qzoenppq5por6xB10Z99NLuT+R4uy993/Es/deJi2GdPmIgdbc1ykLAu+cPoaqQqHQjWWUTHjxF75IIPD46ccgAvt5QRk8i+UldXtOLgfI3Y6L1QWTozskekCz2vBEGw6GU3a7DV3wjAVcVkuGBze5dfMZ9rpbFDJnPf+QVEmSZMDZZsmd4zuMAixXF4ySHF83VLs1Qiksih88eUTdbvnbL3yei/d/xHq7ZrHcsFpuOTw8QmjNbDgmkSW79ZL9wZTaWbZty84K7OAYKx5zkM5YVS0Pdi1vf/QDDmdDBrMRr74ENyYl1XJFmo4YHTxPKgSt22FkzWi6x2C4x1sP3sHVlun+kKRr0bpk5zWjGVyuLxkWCRzeYO9gn/nZObumpe5c7EhKQZ4o9gcFh/f36bqK/dldVKr4x/+n/5R/8oevkSUpb7/+Q97+4XcZlrGQ2u0q3vj4BClixoiQAhkEvqfg5GlBlsSOVJ6miBAIEpyNnf+urhmNxqQHBblOqLYbtk3LtrM8Pl8htKJuWxItqdsaVMJYJ9w4vM1//9//H/L8Z1+h7jzF3n0SFbjd1mxaDWKMB7JmzaS6YKAbjm4+Rzoo8C7w+MPXOH/7T9luzmlWZyQiIVWCyXhGno+5OHlMrjTF0U2yfM1gcAiiRWsFSvc3ynjWRAScV+AMSmiyJGM2OeKdywcMikPsYJ/TxZz5YsXHyynvvP5Nvv3aW9y4eYtXPvdl8kJy785LzGY3kFLSOtjVjqZzrNYL3nz9B/yj//h/xQc/ehNnHWmekQhompqynFLu3eB009DpiK/1BBCSrvMYM0blQ1ZVw2iQI4VGEjjYm34Sl+6n62dcd/ZvIB4tYN0QAvwqMjYeQuyKBhHidIZYLfi/+2XC3/lt4rZDpObjY5EWPNYLugCdj3S/4MEYT+c8tRc4F/oNbw9p9sn9F9B2FaFHwROc7adQBtu1MTuwdWxsibV77OkjnpMDbnuwRPJWUArjHEZ4ghE0oeDj7BaJkszkiFJdgjQEESV/ic7RKkFJEN6zaHI+6g55t9vjUFvGyRwheyzxtXIt9BttlLn54KM3IagfF0UuYHtioghR2WA6i/HRk+GdR6KABC2iET2EngzoHdIHVJIgpOyJj73/LDiMi34nhMQqjwwSJcS1Ky5c5ROGHiQCqN4EE6cH4bqLbm38eoX6FkJFySOBcljypa/+El+f/wHNsosY595LQQjIJMFLaNuWqxy3rjb4niqmlUJJkDKgE0XdRJ9KVde0XUeRZvH5icBqteRUC8qi5Mb953j4/ptsm4quDayrhg7HpupohWJtPIYt4EmlIJGOz9zYI1Qrqi3sCs8Xn79LqiWny5rl5YY8n8WsIBelohJFIErS8iS7xkUH4a8jGkTw/dQsQkEQPt6rRJwhqr7Qc95/Kmr8Oa/7958jhMB6s+Lx44fsdhuyLOWZe89SFiWBQF3XbLdb6nrLer0lTTO6rolSLgKT8QghdJyMiggX22zWXF5e9CHXEeigtCLRkKbRH5+kCu8C4/GkL+jjhKtp2muokFKxuM/zEqU0dV3RmY71JkLnsjy7cteTpRl5nrLdOgaDIYNB2U99NYQId0AInI05Zc7HM7M1HZ0xJDqhnO1T5gU6Tfo4jiiv9MFHD6iMUBEfAlmaMhgMGI4iXdGYDudCnFq1kejYNDVSKoyxJIlCqYQr8l9sGoW+cEtZb9Z8/Y/+iL9x5z5yd8F3fvQdpmWC6Tpefe4AlQhO5xW7OjZoijTmZp0tOs6XHVq3ZElKmQfKPLuWBEpxRZjUOA9d12EdDPOUg+kgTvmU4CqI/CrnK8rNBQhBIiVSxt97H7DhaqoWaPtzp/ce0b9fnfV0Jsr7XAh01pLpBGctSZrijKUsMzbrXRwMFDm7quKN13/I/Wef/3GkiYyAFKU0OtHcuXOXzWqBsr2yIonDB6UVz7/wfI+1j58lca1sCPG9x9G1cQ/JsixOtfp7lW1qqs0KRN9yE+La++Z7aaSQktViyWK9IS9G0LSI4K55B7lSLFYruq7BWBthIsSmp1T9Y7ExSP2nXZ9IcbZrHG9/9A7P3X2GWkooUrbW07ZbsixHpoHEBebVCp1kPL54n91uS5ppxpMZuzp2B7uQIA3Mdxc4mbM3OSbzlru37tH5jqreIpOMpITj8YhlVyOUwknBo9Waar3kxrRgZzvOz8/I98aUecLZ+QW7dstQpkgbOL1ckU6HfPaFV8hkgnUtn3n1S5xfPKGmJd/fY9B2XCxrLp1Dhg10ivlphdINdw+fwbUdyeiIcW4Zp5q8+FXOL9e89e6HUFtkOebhskHvNjy5+AG3DiZMR0NmkxGHRxNmB8esux2NN7z9/gdUW8ds75BhNmZUHtNsd3hy5osFRVKwvVgiVUKSOB59+CHVZkdw7rqLQYjdncpYijzl/vEI361ZbDreePcpWipujiNBqBEJ1fkS38bEdDy92T56KYKIH8wiSSmyBC1l/L7eJaqFZFgqZsMhh4cHSBkx8ovNmvPlGhcUy80u5oRsN+A8oe9W5UnGbP+If+8//A/5hS9/HiElo1xwMIpZEZUVXGws81WFqQ1WpajxPTbB0dYpVC0lOyazIwZf+i2qagU+UFUbykSQq4DbrJgd7dPUFbN7r3L47KuUZYFMCjbVFqU1WVoigiG4jtoJ1nWDEpJxkbNePmJzeUGWDVhut/zRN/4z1udz7t57ma//6T9leXqJ1iXPvZjy5PTbpEpy686c+y98BoulqbcUxQgBnJ+f8Id/8J/w/ptvxdBFAm1dIaUmTVI++6Xf4M6Lv8K7D5fklx1JmqFEzP4oypzB8T1yBVoHEhX53jII1KdHnJ/v8oZweAhjg7DumjoY8LFA6H9/pf0Xz95B6Sj5+/99HfRfw//Lz7vycf3k19D/+VVXtL+Moe9OWhc9Ud73RYp/AeF+FRk6vDP9IcrHTQcfJSGdx5+s+e5fVTx1Q3a6xqeKVLQoLdCJIBUeFRypGFAIz95IMRpIVIyuBm+QYYNMtmA9zkusi7IUKSI11yuFEAqhVH/Aj1N7JXXvLQnXXgt1RV7E4YONxayz0SslespjiKj9q2KCfvoTJUnxtQw+oDDX9BFjLS64Hu/ckx5F9GHFtyBKhW4/c49XfukLvPWdH7Jb7OJ7IDyhs3ESGgKdNwTne+x8fFya2OUelCVHZUmpU84knMyXcYouoek6cAGR9PJA+ueczrj/7Gd5/OGbeFfR7Bo2ZocNAo+KfrBQM84i5vorX/0CeZbyjd/9cwSBo70xCE+SKKQ3LJZLpgcjMu+iHM0JlLhOZkMEgfEWE2LB6+mnjKIvyui76fTd66vrwkfvpQj+Otfq0/XzWQ8fPWC321HXFTdvHPPqZ15BCElRDABo2hoEuB5qoDS07Y4kzXpZnuPi8oLhcMxsb8ZgOKTLGtI00kC32w3GWg4Po2RSSEnwccq8XC2wnWF//wApFbvdhtVqSZqm5HlB8NAZQ/Ce9Xrd+40i0EHK6AFSSpJnBav1CpdnSDnGe1gu1zRNgw9RzmaNidPpNIUQ0FpTN21PKw3keQFCYqynalryEGJhqeMh3/fSN0QMkddJEmM7+qm8VooQUqp6SfCevekYIQTT8TBKGZXC2Sh3S7Tqfa3xXtF1XXy9nMc+ekoyPOcv/uoxb9cdN/KMg9kAhODkbIvUGi8DiYQskbz90YrXPrqEING6D1OO6fY9hTbKtB0CHSLBUCpBmSqOJhlCBKyPuPxUJb1Pzfdtw/6/oj/v9etaZ9AXlsb20Qveo7zDCklreimgi3AM34c/W2sJxPfBWsNoPKBtWgbDIdZlnD55gmkb0qIABNZYhEpQSYoxlnJQIkXMx+1Mh+n3pKIsKIocZ9rrqJUrmXtUMQlE6D2IImBtR5ZKdA/Fenp+0lNEwXQm7pX9mNb7GAfjg8d1DYvLC45vD+I0lwTnLMvNmrTR7I0neJfQGhvbgs5HzzACRGB8sM+TN5781NfpJxNC/fxdSpWDE7S7mlWzYjY9ZP/gWYZ7N+m8YTd/gJjFaULAo5xkbzzEJGNWXU3qBK6uWVQ7lIBUCc7WT0gHQ+7Npty5+RKr7Zynpx8x3j/g+OguRbXlYn5JVVdsVhd09Tlh8iqBDHSO33XUdUvtAonwLLYr3n5ySbvacvO5YxaXAxbriptHR2AdH7/zI5JizDM39kiP73Pn1hkfnrzP2eWaNx89ZjwU/MoXfw0tA+fbOTackyUjdCPBbri1nzLMnuf119+kaj2HL93lZL5ivrjg4ZMLvnf5Hsf7Yz773B1OxudImfPRoyf8+Xd/hLWKg72nZFpytFfw7O0pd155lkGpwFhstSYbjLh4esHF+RzvLMZF9DJKgvNoKSjznCQvODoe8/DRx3z/tfd5+HTFpEg4X1W0iy1pOaYzlmBNHM8SZUchRCqPJJClCVmSkPZSqavLc5BHH5+Wgr3JEGct06N9Hpxd8t7HT8iTlIDg7OKctuvI8gyldQxT1ikHsz3+3X/3v8MXv/yFePjpD0Q+xAOisR7TdlTbiuXykvPLM8pizGg44P/O3n/G2pam953Y7w0r7HzyuefGCrequ0KH6m52i2o2u0mRYhpRokSJImxoDM94PIANf3CADQH2BwOG4S8efzA0gxmNDBgztiQqUJSoRIqZanaurq5cdevmcPLZeYU3+MPz7lO3m7I0TbSmDLheoFD3nrvPDmuv9a7nef7JTzyz6YxuYXjq2lV6W5fYzmLiO1va1uPaFjudkwfouinz2QnT2zdZH25i+xsoW6JMRJklbeup6yXHZzNmc6EojAYjlnPNotqgcp66dVy98kM0O0t2dq7xy5dflEl/aLmwtUaZOb796uvMFlO+/fK/4sG9d6jOTul1R5zOl3TKHnloU6gRsBIUW8P29kWuPPksVTvj4QNHfzAkzyQYsd/rYVSgk/XEfTJR6a1SH+rp/39gNXduYW/fQVsDGGIKUD43utBCDUsiUCgLhCYnvx/jdz/fd9erqUlID1L/X4rZ1XOspoXvP486//+/e60oZn+80Xv/lix47urGR0K57o7v8Gg+JcaCO7HLPbUuTUFMTVN6CqU8OY7/4y9e5NPPbYhRCIHgG8L4V8n1q9IguUjTepQOoC0+agKa4FsIFUFnRPNj1O1l8KLhCsERV/z/KHbtLjQ43+DaButaXHQQPSZGFJ5lMyGEChK9VAVQSfyutSbESOUUNtYoo2lDK9qJFGTrVaSNglRqx/nv+Oh59qUXWNve4Nbrb3H3vTu0dYuLLTSROkTaEMjQROXQRjPsdhnlBbu2YKuBzrQh9w1XI5z2BxzHwN12ycGixvtA2ckY5h28a5kvJqz7PXZMTjZY553GkekJJQEVFaVVDHs5/WHJ7sUtPvLic6xf2GQ2nVH0u0zPZoyXFbNpRZEpcgMhiN5v0VYYkvYMlUxRhErqcaJVJGASNXxV2qES+ojGhUBwAR2RyaHzoDXefriBfZBruZwRg6dTFpyenTEej1NocAelNBsbm+R5RlmU7O8/Em1rDMznUzG/yEs2NjZx3lG3FW7s6XQ6LKsl4/Ep3W6XzAqSVFUSGLxcLmiamizLhc7tHFtb23gfsNZyeHhA68QxURrAQFUtsdZiTYbSim6nw3C0RoyasuzS7fZpGgnMbpqaqql5dDAnz+U+PhyOxJgjistqVJpOtyvuehEWVYVLqE5MBk0xBKDAGJOGVRHXOqzNUBG8C6AEbTc6YpTojjNrMFqdu5TmSZPnCGgViaGldQ1l2SX6SJEXGKv5w9/9bZ5slrx2d84/PTzFZpIztr7W5XS8xCbWUtt4oR5aw+HpQpDsXFHmyThIazKtzxEgqzWLRZ2GJh5jDFuDAqI0oyFEdG5QBFoXyIw6v6Gs+rJVVIw0WSQtaRQpjRfXXRcivmnwQbR0IXistdStO2/kvJfojTzLIEqDbTOD946izDkdLzg8PmZ7Z++8Jow+UNUzGQxqS1HmeOfxPpDnGc4JC8NFqJ3QFEmfHUgOvIL05ZkhhpayLKR2Q1wb9x88oHXy3eaZRBZlRU5d1SlI26ShgOb+7ZtcungZghiRrDI226albVvklq/ld1RMhiJyz7z2kedo4h+7DP+d6wfSnBUzh+14nLFMT4+JhWFjbYNu3uP08A6Nb0F7QrtkYHOyfMAitjgPtVswa+fo2Zgyszzz9EeompblckJYLLi0tkV9esKbkwc8+8Kn6Q0/yf7DG9y79wa5HWCjp2syFos5Hdvl+OA++4f3mMwnbK9t0h9uc7m3wcHRIdE61rMeYV3RtzlarfPR5/8Ug55lengTlXfJOoazs1NwYx4eHVGPoVdl7F79CN2eJtea927f4lvf/jb99Q4mdih9xu7uBTLraNqGzc11LpUlEcMkOtZ3dxj2h9y4+4C7R6f80Ss36XRzbt15yKL1rHW6HExOmc4nXNrZ5Is/9Qsc3X+Pu2/d44Xnn6OiZjr3+GBomiVRQ1XJTTSQOMbICdPplGit8K3j6GDGd948YG9twL3jCU2EotOVuYL4q4p414fkOiOFfyfZ4Jt0ow0qUmhFWRh8jLTBsz1a56lrF5nWFd944w0Oj8bUTcvMVFR1Q9U0IuLXGYXNGPQ6XNm7xF/6q3+NL/30T6UTW6ZcSlvqZcPx2QG1K/j266/zzW98GatKTD6i7PfZ2trCtS2n430uXnyWm/kxnbKb+PFJRxJERCwXuEerAaq3RlCKE2OJc4cxgbqtWFRLYoA8y4jRkuUDAobxwuNDB6ynY6HI+6xvX0h7hiUoCQIOQbjpxmquXP8Es6kEZPc6l3n9m7/Fq698i7OzMX/9f/d/5rWH3+H3fvM3sVmB0ZIXZIzC6JY3Xv4nvPXav8AFz8W9a2xu7TJY3+WpZz7KhQtPYvRFulkJKuCCxSbq44frg12nN98if/mbmOUC3XqCtajMCNKhNNpqxMoqEnSO+qkv0UEMLc6bHGDVFMXzbu0xI4rVI867MPmnP953JUOGf9sNQL3/h5XcajUp/e7382/8Jd63x5ccKx0BrfnUlYIWi1EKr2yijESIydkruSF2LVy90EtmRQGUlbvPZgelNhFVUiQLiRKphJIib8GKkFMXwIugdpLqLOWRPf5e42Pz31RcReI5whZC4Ffv/TN+tfkjAkJB0S6iQ0iItMamBioPmk/ap/gzGz8hJh9RHDB9ELpkU9cE1xB8TfA1GZHl/BHZlYandn+ItRee4q1vv8b0eEq1bMEF+towKkv6aEbastFo8uMFcXGG8Z6WZLYSAn0NfQMbG12+1Y08Gs+ZTuY0WcOozel1c6qLFe3xhI2jhufNkLjlOVksaQN0e12uXr/G9Y88w/rWBkopfGzJRgOuXrnAa6c3WC5rXCpA1/oFdZjTLiooAk3KkDPJhUyjEoNiNZ2OycKb5OaYdMoogo7YoIitx8Ug+hbnUUYRPnTS/0DX4eE+WklR3+/36Q4GDAYD+v0heV7gvWM2m1JVC/b29siyDOc9dbXEGEt/MCD4wOnpCWdnZxhjGE+ESueDWMZPp9LIaaUpyzJRDTVZblmM50ymEw6PD1ku55RFSVl2CCHStBVVVTEcDpIzYybN1mjEfD7n8HCf8XjM9uYWFy9dFpqaD/jg6PV6DAYD8iynbhoePrpH07YMegOUgrW1NYbDNbKsYTqbUZQlfWvFdh9wqcgOITnkJnMRazNsluFdS9s2dHo9yVpD9ty1tQ1c22C0So6wosGMieKmNHjn6BQlMr3wGKVonefVr34VOx3zhmvRZYYKkWGvIMZIZg1ZppktW4kcKg3EyGxRy/4XI66NWCP06WWQYXJm5b2FGDAWWh/YXusQo2a+rCmsRSnZF5sAPkTyZBxCokQCKIQZ4FY6shAkpDzK9yxom4GoqBsZNmmtWdYNTevPj49PaNRy2dDtlCwXS8qeZMBZa+gUGUeHB1y+8gRKa+q6xrkWEsXRJEMhm0tu2bxaEiOUuRzPumnfd9u1VlgiiYJqEKmOsRllp0dmc+pmycM7dxmfHtE4iTzQ2qBUwDlx2FRGBujOy/d4cniIa5YMBwOht8eIUYYs62KNpWprfJDQc7nHR9F+J+r+R59//vu+Tn8gzdmsmdLbu87o4nM88UKH2k3oFT2q+QPavEtvuMlgcJHcRLyrUW1NFRUxeprpEffvvcnZdM6sbTiaHOJbz/HshLV+l3k1Q4eGpmm58dYrbGztMuwMeXT8gM1BzoWNLZr5lKFW7Aw3OT075Kndp5lNxuiOQbeOpp7wxNUrfPv1I2zuePHJ64wuP8Ng4wLLuuLWm69y/OA98syyM7xK01ZoVbE2sGQxo7FD6uWcrLvFjbdusb6+TqnWGPge3UGHqg2YLMfHlsOTGYtlzYV+D7+oyLWmqWr0EF746JOMHo144+ZDjs7mqLwki4FHkymTpUNbxV7Z5V9/41/TzmaoakJAszbcIKaciRgjddUSklA9IgF9yua0QU6qR/fvc/3JT3PzaMm903my7Bf712G/z8nxCVqTLJJFRCmT8UBmcrloYySLka5WdAqLioFl1bLR63Jld5NOf8DX33qXd249xBqbLkjJOjNoOlmOKTJ6ec6VC9s89+wTfPGLn+fS1YL7732D3asvoG2OxrA8e8Tpg7cx2nKw/5DpnVu0h+8yqQLF+pM4v8vk6A47G2us9dcps5yDh7cAzdbuZWlYYkAr2UDyokNW9Gh8Q7WYUhY9QuZwDupmRvCebrdHVAGi0KZ0LkWrFBgKn2g9KhO9hYtikR2Do6nFzcd5z2Q6o1rMqeoFwcPY1ZxULY3K+dHP/wT0Kv7xr/w98OBDgzKWyi8ZDHpcuvo8LTXvvv51rDaMDw7YXF9jMBjw1rd+m7XtK/zET/551j/7Iosmw7sCOxhg1WrC9aGw/oNa7926hTq4h0JjVxqbqMAo8hDFIt1YVNJEbcyOMbMTovJC09OGGJ24Kq76MWVgRdeDRIt4vHFSydo4ueABoM8pjN8Dv/F+o6fOKZbnmrfz9f22+qkoD44bN+5w957CqwylFLkxRKPJtOSyKa2wWor3bpbT74iJRhS8BQigA6hS/q500i+InoSoiLGRxgxA9VF0WTWK6t/UVKrHfmr0Y/8grZwPLVUnZ7t7VUKsVdJKKTHO8MrTxsgSRcSzXrzA5a3n/9jryCF/jPaTJu//7d1/zq/6AyIlkUv4n7mId9IohhCoPVQeDpuWnwof48/2PoNvPb5tCU2Lb1rcsqZazGiWU+KiJrZnPNX/Dg8mp1TLFtW0hNBS5Dnb13J6pwMIRwxNzs5wi4c4arXOaG+P9d11Op0cqyC4mtyD1gVXLl7mO996B42htNDtleRaw2JBvVhSFl2Je1CrbyOmMHChc8rRNKgYkjkM5/lyETAh4lVEBy3UrtaxUgN+2Jt9sKvf76OUYmN9Qyi7PrBY1FhTS1jzcknrWsrk1BhCkMbeZmitefjwPnVdUZYdtre36XZ6FEXBcrlgOp0xn89YW1tPGtmW+WJOp9Ol0+1hjGFzcxOtwJhMkBGlWC7mycJ/lHRlJTYFRfvgIUqTNBzmdDolRZ6zWMxYLhZordnc2MHmOXW9pAk1TdPQ6fQoSg8RirIkRDg9PU6NVaRtKmbTlk6nJMsEPVsuF5R5Tll2UUbur3mWJZQ+poZTUddi/CA5cQabSZ6XSm6lPoptvEksGa80RluiEso3wKuvvMqkmXH1+Qu4b75L27YURc6gX+CdNC5tsr3XSlFmVkKWI8To8a0iqMAiiPbTB6nibCNUTKuhozI2hiUhwLJpWdRBNMcaYpNQMRcpLLRBqMh5hqDkShor58TJ0KfXifF96rJ3oi1zPrm5ak1Vt0mbFgjKiN5KSxNljeRhzmcVRaekrloaD6enZ/S7Ei0w6PWJEZq2YblYktlMIkoyaVe0MmSFDAKdC3jVYJUwGKITbaA1mqACO9u79PtDCaXOMoL3BN/nm7/3BzLIT7R0yYgDizxuWS0JyRgEpXBNy50bN/jES59EZyIq0drgnKNaNFR1LQ6OPqTvGUjRAVornPuANGfF1iZtHPNw/3WyIme4eZnSwGyx4O7ZA7ZtQ1kOIBTcvnWDs+qEa08+T2675P0tsu42s3ALnGdxekrmlihjWTrD+HiftU4f71pK1XDz3jdpcPS21hnkJaf1MWdnB2SNYTId0yxq9h++TpmXPPvCx2ldxuHkEdtrT/H8E0+z2Niiu7HNhctPMK8aFtMj3Nwx6G1RNy0P798AAsPRFpkq2dpZZz5veHD/BjfvPUCrDGUXXH/iAkWeE4PiQqeDJaLI6F67hraGjsk5PTslRM18OSa3EVyD8i1P7W1z92FkMBwxbwLPbX4M8FSuYbacUjUNujtgdOEKo6c/Q6fsMH/7n3Dj9k1Oz6bUraf1coOMWotY3Fg2ty+BgrsPH2L7u5ztH7F/NKVaNoxGQ6wJtE2DNoaVrVlIAu2cVGAkC2obI51MggnbEAhe8eIzz7K1u8Gbb75BdXzGzYdHLKolCpIuzWCNIS9zRsMh1y7s8sJT21y/vImxgUfvfIWTt+FgNmN05Ql6/SFFBsNywIM7t2g8fPSHfpxf+h/+eZrFhAd3brB/5waxs82DkzGPDo954dnP0F8bcXCwz2Q6ITOFTFaMpmlros5QOqf1nugjMWo5L5qK8fiEbtajjQJ/50WHqlnQ7/Zl0zWSwaO0FBlWR6JXEBwoi/dLDFHsZ0PAtxXV7Ig3336dw/19Tg4P2L//Dr2sy6c//iOYjuL/+p/93zl5NCYaRbc7Yri5xaA/4Et/+vNcuv4xHhzeow6Baj4huoY2GII35GXB8cF9fv/3fwMXHS8+/yKXLg5oWgeZOCvpf8s1+eH697u+9uo3sM0cbIGOAeUCJgIYTOuwKEwE5T1BwdV3X2P7QplYjhZtNDF6TNY5j2HQSmPMythCbjYq5ULpGIXHnh5LjGiTISzXVWOzan7iuSgctWr2Un7Xaiqarn+Viur3+zqVHi/6M5UCXrUyqSPRYgQR4Z2bD3jltQqnbLr25UmsTu5dKkcbwfSvbllUfIKVGC+iwNeweAvU/QTGCD0HJe6UEjKdGjFlwa0Ti/hYm/S9jRmPgY6P0X9TY6pACr3QclUNcUjWm0y7jRhfhIiPDQHIleXp8sL5sfvel3q8GY5RUKROlvNsdo2oUyETHE6n0ZdPmWoEPI4nOs9xafPFxz7FOaSZHoeEV3MM6v9JoEqvGdKnCefaRu+fBA8hKGLcxsdfAMqks4u4puaf/96b/O7dnDI66u5nCD/yc+xnkT8wsOcy+lmkjhP0tKQwmhcul3QLg4kQgxMUQPlkJZ2QRC/BrDp68C0uekwKE/bRnQ8OVGblE2mF+XCm9IGu3Z0L0lAYS7fXI88LscOvljTzGte2oCJNXXFw8Ih+r89wNKLT6ZBlOWtr68xmMxaLGSoqjo+PhQYYAwcHD1ks5oxGG+zs7KCIYpSAYmNjQwyz6orgA51OBx8ck8kYHzyFKZgv52xsbIq7YPD0B30mkynWGobDbZzzDAYDQDObj8nzguVyyfHpESFEur0e/V4XpaDfH9K2TWoec87OTgnB07SWTqeHVjplxcJqiJUXXWkknEMFT5GXyWlPkCxFpKkqfFTJ9VmJgUlc0aIt0YujpFYiGRHzMSn0gxe7/cWy5jd/4zcY9juMxzM6uWV3s8+yjeJUiaZyDSqKMYnSYtxRN5IPm1uhXYrOSzSdNrPkWoZkZWEpcoNWEaMVk0XkdNIwW9YovaRTWDaHZXIm9LRZTlSeTm7REdoQsVrRptyv1osm2adhvg/yvE0bWNYCChTWQozUbQtoshSLELVEI2itWVa10BIjzMcLGh+JSvPtV75DjIqf//m/gNEmZduVDPs9jvcfkuUZVV2fU8/bpkleB5FOkct+40NSE2iKQvSR1maUWYFSojXTJuM733qZs5N9QvBice/S59IKX4tezhpL7cQ8BDSZUdy+fYennnmGwbCPSYMoa4SxXRQZRIkXCUlulGeWLM9xjUPb77/V+oE0Z8v5FLc44uHxkonT0DSU3nNhawjW8s7t15itv0y2aLj7aMxJ47j/+pepQ2StP+JgfsqgMGwPB2Bz4sGY609e5kRp7o/HKDQEw8M7t6gWZ/TXt3EzzVtH38GbjFxlbGV99tavEHvr5JXi/sNbvPvmuzzx1FNslkMmJydUyxmnp1Peu/UAlMfVLQ/u3eHwdMnNB4dU9YLtzTU+8bEXyPsjOjFjqXNsEXjq8vMs9m9QhiVRNZyenEB0dEfrBO+EClj0WFYVbbWk0y+Y1QWj9XUuXHmCQb/D2ckhVkOeFfQKxX4d+B/9pf+EnUtPcX//jMlsSW+wiTKKvCjRpiDTnre+8hvcubfPw/0TXEokr7242XSLLsvWUS0r6qriiWuXyPKCr3/5y9x4dEyRd6QoI6SsoECRBLI+CjdWCjEgbRzaKPqdktJarNZ0yy6f/+HPETolv/qrv0a9bHDRM1nMZHqkNMpYiiyj08l58omn+NEv/QRf+okvodoT4nLC0fE94qKmHG7z0e3LaJtTtxVow2B9h0sf/zPEYOgNN1Fll6zosWZG3J9Hht0uP/zsc2RGsawdSz/n6u4Gp70uOstRxpDbgtYXLGqZtGkv6FbbeowyXN4a8vDOd+hvXODB7XeYLyva1lF21+j2RwwHawwGPY6OD7i4e5HecIhvG4KrODl6hNI55WAb7xq0sbSuZTGdYHXJha3L/NCzT/I7X/5t9u8sKXsDesOMrDPipc/8NPf2bjM+eMDzH/8R9q5c4+LuOp976RmiUjT+o1y8fJ35IqTATA1YjLb4KBPDRVvw1q2H7J9NmU4ekeVdsiLjz33+h34Ql++H60+wHk3HHNcVdjkXkXhCuVSjUYnyoAFlBEU7+MYfcdFMzidp52GkNsMYaWKMNhibSa6WVqmJE5c7lbRrEmad/q4l6kIrhU6ohtHS1CitEoXQoqxNAcsm2VOnQGe9sh1OAcJEtIrnyN6KVoJS57oPo2Xq7L3n4P4NqoMJUUsT2Ghw3mCtqI5k+APGGoZtwXL2Ep1swMrpsJnvYw7fwuhDVKL/RKXPG8eoFCraZOGvQe2idlvIVvq3xzVx8TF0MK3voXlGYLmc8odv/wGPzBxvQalAa6BA7PgVKqGXilJlfKnzyf/O54QPnkUzo1RgVSbFg5ecH6FIQaal+TZKs1dsJQTxe6iZSsICxNdfS5bdoofSObgIRpRfhJDCu9MgKQZByOwmebmGIk+eJorgGiq9wdT0OY0R3wXz1HWaELmpDTdDhCYSjEK3MJw4fv6lS2wNS2ngE7Ni9R5jcnULMeW/pf02+EAMkvEXnBMkLeW4ed/Sti7Ze3+4Pqg1mcyx1lCWBQdH+2ituXb1GloLLdAaS1GUhOA5G5+kIQmcnJ6yXMxpWqGdWaMJfsmgP2C+rHn+uZe4dOEyy3pCt+wwnkyp6yWF1WQ2IzeWbm+AHm2cF9lNU4u5D6v2SFgrKNGPepexNlpLroKWsuywf7BPWQr90jtPlhXYzDKbzTg6esSjR548L6nrBq0V8/mc9bU1+r2+DH6i0ACbpqXT6VNVc5bLMxmExUCRl3R7fazRtI3UOK1rEqqWsbm+KfWZ0rimRWWgjUlMpvQ5IgTvJEbES2Cx96KJD0R+53d+hy/92I/y9//Of0s9XTLqF2gi1ioaJ8MQ58VB0bXJWyBGFrUgeFKnwTCX4TRKaJgxBhmQW3F/jRHaYDg6PWVReRmLBcV86VhUM7pFxqCjJd9OCw2vcjL41x6q1uODIGXOBySqMFHEI7gge5QiUtct1sr+HVLzBskApRXMvDYB4wPzRYOPkGUZWa4pczg+uMPNm29z7dpTFPmAwuZ0On2apbhghmXSsAXRnjVNw2jQZ3f3Aq33EKWxzfOMGOX+V+Qli8VM6NdKMz475atf/UPquiLPbdqbJTvTBaF3tyurfjnkxOCJ1lIvl7zx+ut8/gtfYDlfpAgl0eMqo3GuwXtxq7SJtRG9hKC33n/vZfjvXD+Q5kzN5gy39+hvOWZuTvRgfKCwHeZ+ztreM2yVXQZPXuQjP/Ec1TJwOHnIxb2rFHlB22a888ZXcc0+66M1qrUrNL0Oz155kWeyPqGaMz59SH9zj3KwiTUdZsePePPVrxCzhlDPaELNwe23eO/2A1Q5gKLHceMo94/pFQYfDe/dvMtsuaTf7fLWO++Q2RFN67h08QrvPRozW9aEw5rf/6NvcfmJa5zOK5568kmuXXuScv0KdWeIO7nHg/uv0FiZFGSlZrl0OG1oTvZx0eAitFVNaXPoaVqluH37Lr08YzAcYohc2BqxUwxolmOU8rzw0afReUnjItNlRYgKo0pOj+/z1jf+UHjMKJbOUzU1TQiUyrDZH6IWS+p6gS4s46Njti9eYekV1556ipt3HjE+rTBKJs7CKU8J6EjuhHCXWzED0dDNLf1OF200H7n+MX7pf/wf8+Rzz/K/+t/8L7l/cCwomZLawGpNr9Ohm+Vc2Nvlp3/+L/EXfuEvsnfxoli0Ktkw2ralcS15XqYCTMhJK+3IKkuobVuq2SnGdilyw5PPvsSijsy0RkdDq+eSvN7O6eklw8JJQ6OXLFtNTykcisxmtN4wp0UraHTBxz71Y/gA5doVvI9iqW2EthhDS4yKwnb5zMeeQueBf/2VL3N8/y4P7r7FbL5k5/KLeF1yfLjP4eEj6uWEK1ev89RTTzBfTPif/0//Z5z80i/xX//Nv8GDg3sYfcja5iU+9anP0e12GQ77XNha59MvPsfWzogit6DAFpHTgxkfe+463W5O3dbMlkuaJnA2HfPue/cZH+8zP1hQTR5w4733eP3mPn/uH/3aD+Ly/XD9CdZHf/zPMPvEjxCaBupTYjXBtTVNHZguNMfNgJnvyk3VO8Z2jZPZBiU1RsXUeNRYWjrMKVRDqT0mTXFVMuoIBtBWkCQlbnlKWbkZK9FZ6pRFFVUKRU7Nm9YmUSUVMbzfsGklyJmEjKpz/UlUUejBNgMtttIRybXR2iZTGrGa9r7h7s2XqY9EnO6jJiqD0QGXkC/xIcywWnFa57z3zneYbK6htcJiWM73yQ5vk5l9FCEh4PI+V9lEKCOOhpnCxRpt75MVkpEU8UkMbwjBoZSRMFtlztE/SEHhSpwyj0/3efu915mZQKk0i8yJs6MWuqlWGm+EnpTpgnZ3QlyXrKA/1kR9158jbdvy1Rtf4zvqFgZhJ2it0RFUyhEyGKzSGDI+/fQTxP6/iVi6QjcTCqobsFOUkewgFTTGpkC3qEFl4uuiC1Cg9RpgH3viSIyOrbUOn1NFMg0QxzZQ1EEMREzaO6OPFFlDJ7fnBda55vC70MnHG8v/LutPoIr/cP3A19bWJq1r6Xa6wqAh0jSejY0NvPecnBxz794dYgw0bc3Z2RmgWCzmhBDodXuUZUG/O0RrcRXc2Fjn4GAfYmA6n7A2XKc3GOAWDu8iowtb5EXBsprzeMi5UorRUJqvqq5EN550tXknR2lF0zbMprM0fDIs5nOmkzF5nlFXC0KEEBWbG5sp0Fq0Q6dnJ4xGawwGI1bncFO3+OBomgVN05LnBdooqqai1+lTdHt41zKbnZFl4iAJss+iFVXrOJlM8O6U4D3GGpG5FCVFUaRwemEbxHjujysmJEFQoswaDvb3+amf/An+6T/5NSYnjzg8XhBNZNTrJPpzpNPJOT1b4kLEJu77bCkUR6tg1O+e56qGoFksKwl8zoxYuitN4wP3D8csKi+GHo9dszEGpouKsuimOBHRndXOp0ByxaIWLZlKgzaX0CnvpWHDiEurzSw+NadaKTqdjDKTcObGexoPjQuE6DDGp6Ym0sk1uzvrFNZQ5oblbMyTTzxBZm1y1VTMJxNBwYzBAVkKoI5Ezk7HXNjbQ3tpkEejEXmWpWGkIKPa5ClTFiaTMeOzI8pCYhWUFu1fVTcpQF2Gik3TYoyh1IaqqYUloCMP7t7l3XfeYWN7B+WQnyN5nStZjbjmx3SMVxyHD4jW+NEf/ln2Lv8Q+/v3efDgLd69/TIow6W1p2jOblNqw1E15uY7j2jf/BqDtQEXR2uU2RbD9SeIKmN968+REcGAUZaqXaJUIC965MZKjo+2RLw0Nxcu8vRzn5QTJgb2b73H/Xf+kE989Me59MTzKDxVtYSkHcAHBh+pOTx5QK5blpMDRqM9gm9ZzI954TPPo+rI5PSIu0f73N9/xIP9Kcujfd779tcoS8Pl3XVsd4OTyjMoC7r9LVqjmOM4PT3h6bUdzqZLbt18wNrwlKtPX2M6O6RZRmK9RBcDdOvIs5ISwM+5ujvgyuXLdLodrNZEBY3rUrnIso288vvf5tG993h4eMTZdIYpctCW0mqaxnF6/Aitc7E29ZE8y3n6qUvUdcu3Xn+bz/zpL/IHv/PbWNWQxi8UZSFTzSjTEKUiJsvl/9oy6GZkxvATP/0L/Ae/9EtsXtjjn/3LX+ebX/s6RKi8wO0aTWEzemVJr1vyH/zCX+Q//I//IzqdXlKmkAT6EW0UGZaqOqVazBitXyLoDPAs6prp5JTZ9AzV1Ozf/jZrW1cgH2EGF3FNGhLbHHRGtBaHJagBh85jAwxKy8YosN6zRGMJPqBCIARDcJIH55xn0XjOdKByiulswunpKWvrlyCzzKZTyiJjbXNEINK2jrfe+CbTwwcs64aT4yNmC8XxwTHOO3Z29vjYM9f5yR//cdY311kbdfExkHcH3LhxhPct66MhvV6P0aDP9sYGo7Uea70iZcfJJvni09eY7szYWBtQWoNSJRG5ofiwx8efeZKqmvPw/g0OHnQ4PnyA9u0P4tL9cP0J19aFy6xf6ePbBl/vE5p9QELFXZtzu7rE1/0L3MguUlmd5E+KQWzJdWRmSlzQbPkzPhXu8jHe46P1XS60C4qo0QSm1nIn79JqxbKp5TppAzO1w6PsOnfLPerMkIWWPLYY15IFR47HKEcWajbDKZtqRqEnRBXEaSqurM6FJkm6mUSC7BG6wJscHaLkiJlEf0ShgujE6qphfPSALNTEEBE8DUHwVgcpitU6IdAoyze/8jtsrg3OXa0mZ/cpzu6TmRlKBQnT1lHQPRWx1pBbiKlJwVTkB39AVu5Kz5kiPLS1KESTq41Ba0Eb5bksWsm+arThndtvc/DWXebaoQlgJXhVGSNW70bCD4MNFCpn9vQ+s+59QSpTw6t14uWlZliCTxWz+Rm33nudR3Ff9BpaYkdQGm1IAd7yHFfNNqNLnhjac43h+Vr9PUozHmcPUdUbKO2xKJT2xGAEaURJI9/IHhu1ApND9ljjFCOuXvDNV2/y8qMCo4V6qoyhzCVBTpmMzIoFdM8YNgYRxR7n9NCVrjF+d2P6x11GH0czv3d9v/rGD9e/j6WNZnO4hTGGoiioqgrnG15/4zXGkxPathWdVYh0Oh12dnbJs5yiKHCupWkbFrMZVdVS1xOyLKfT6dHpdpjP5xiboU1GkXfZ3CwIQTLLrM2xWZ6if4IMioOnrmuszUQTFGAyOaOqFoLi1BIuPJ1OCNFTFl2KIsdoTYgZeZYJ0hHh7r07DIcDrLV0SwnSVhHaphFWgnH42NC4BpWMSlCCmnTKnhhAtI24RGYZoaklCy3LJZ8whnPdpQstRdlBK5gvK2KItN6xXFZYpSiKHG0My6qSGUpCnay1xBjI85LcWn7mp3+Ov/Vf/mfoDJo6MJ429AuDtZqqaamahhBhoyNo0GLZ0Cksg05GkVuquoagWVRLmjbQz2UY5tqAi4HZomFZtan5it9FbQ8hnv/8nEYdIbhAbjPmVYMPChfDeUNNqhlFd4YM/ZSiahzWSMPtfES7ICZRUTGZN7TeyfeBDN6KPKPXsVitqOdz+ptr+OB4563X+eyf+jybm1sEH1jO5xwePKBp2vOcyZiazBgCN2++x7WnrjHoD4jei5YxuX0qa86RfQnmNpR5gQG8a1gulyilab3DuUAnSnh2TIyySMQ5iXVwzuOdp6oq7t67Q280FGaLEvSv2+lSVQsJMbdJl5dyRFrvJR/z+1w/GFpjWDBxNet7V7h2/eO8OPszHB8dMB0f0Ftbw0bH3uVrlP2r1PMxi9N7VLFB2z5tvaRyE3xzjPGKZTulKIZMZxMqt+DS3lX65YD5fE7ZKUB3qZuWLINVGRAxDHf3WNv7ZYqsBCXThU1r0gkn0Kpznt6oh5s/JKxHevmAw+MjisEeG5eeZq2/xnJ6SCRnPJ+Qu4C3Hda2n8XXU2b773D/7utc3tmink7xboHtbRJnJ2ys7/Ew1HT6JTtPXmBjNOJkOaOKULeO9a1d1tYG5P01bNZhd7BN1h1QZpoiN2RGpSllxGRQGMewVOShZVk3LCvP+sYa2hqqeUX0Ff2yR+M8y+WcEBXzpiVazcM7t5gvJDDyje+8wvb2DmcnDyVjxgfKPIcsp3YtNkQUAWssmVF0i4JOUXDh4hV+7i//Ajt7F5guK/7Lv/E3GJ+cEAjoYDA60h+O+NEv/hRvvv4NbGgZ2iO+8bv/DwaDbXaf/BidsofSJU09IbQtwbc09Zx3Xv86l698hHJtj9PjQ95751VoW2qvufTk82xd+RibW5c5fPQO0/uvkA2eYFKLPsfaAhdcys4Q2NkpRa+b01/fotsxtCHiwmriLyVB1zta59j0nsvNnOhqgt6gqfakkPItzTTHKYNfnrJooJd32LlwneHGk/T7m0QUjx7dZrB+yvToAT/7s3+OX/7lv0qWCc9ba9Ao/tSnPskLzzR0Mk2eWxrvODw7IbOWshQoXQJ3ZbPs5gVmZAh4mmS5r7XGKJmYjbodBp0V1SLwZ7704/zYn/3lH8Sl++H6E66gBBlRKXcuBHFpzHRGJ4fr5ph6cYdTV3CfTYJWoDRTnVF4RRMjHdPyfDbnU/aA6/URzz88oDtdiFGhtWz0O7hccbs3RKPRUWOBQTxj7o+Yhyd5s3OFoC0xCM1Nh0DmHSoGNpsxz7dv0tcT+l1Aa6q2okq5Njk65cCIHkpbg8kyKtXlnvoYr+SXOKGDVRGLJ0bRFmU4+nbK9S9d5HPLW2gqvM9ovWa2qCTbxgeWy+rcYKCfB5r5CXMzFxerEFlOz/CTAh28aO40KJILmJfmQiSw0nhATT75BrbchCjhzSrFFUQlTYZMOAWhUlqaDpM0Y9pY3rpzi/adGUZFghIqZZpzE5QUc17JRLjRmje3vkp2ODtv+kQILmidsRaTWUEeteV0csrRq/eYxwlaB7wWHYO8tlBfMmN5qfcUHxmuU5+OOStvoU2GRq+oBGJbr3WiNsLswWuM/NsYu3L/SvbZShpXpZUwELQYs4TOs+jtmqgcqYOjnp5ydnSfN99uU5aPHDdlDZlSYC3DQU/Cdn3L9T1DDM8gTpkrFPLf0Hh9148eR8b+XSjZh43aB7W890wmY/I8p20ESWrblrIoGF15AmKk2+1irCV4z3Ryyv7BA4rM0FYVWadLkVtOx6fYrKTb63ByesilzlVGo3XyKmM8OaWqlxR5wdb2jtjuN3WiOWsMoj1r2hatFP2+oWk83W4XpWFNrQsFMIbkpihByEVRYozBGEuW5YC4Rsbo2d4K9PuDZETihCmQJA9ZnrGsl3SKMtn5e+bzOZFIUzeE4FlWAYUmz3OKvERrnV5DjD9WqFNRdEQT5wNFp0PbNDTeY2NBWXRARVofmI6PcM4TIyyXC2mCnUhHJtMxRyfHvPDC8zz59PPsf/WPWFaeXs/yxJVNGW57L+HbszppOANt0qSpCNN5Reuj5IoljZPRYI2idUJ3Ju0TK1OX716rEfpqWLdq2MRqflm7FCkQ8L49pwCmuEeCk0zczBrRc4FQL5cN07m4J4IM1k2iPgYiHZ0xKC0aaBsHuRV6qDHMJme8+vI3+NM/+mMopdjfP6Ruq+QkLqZNJsuxyD1rMjnjqWvXUtxTYmRpMWwByZcriyI19iWzk7PUkCtUlDzMphbDwcViQV0LK8MjUQFN6zBa41LjZ7OCstPh4s42RdHBGtFuGqNZ1DVtKyCIUorWybndeE9bVd/3dfoDac7c7JiT21+mtD30lefoFus0wxKdbbGzd4Wz0ykHp/v0mpbx+CHrox0YH/Lqt36bGFuqesaou0ZfBw7GZ4y2LjBZVJwsT5ndHZIXFm81l3avMTk+5eTRI5RWLJYzdvYustYfcnR0xM6zP8TG5rPknR6tW+JDThMNudVYrclyze6FZ2mqa+zvv0UTHWvb6zRNjcVz972Xsb0Nets7fPSZHyHTYhWqtEYpQ3j2E1xvFrT1DFd7zsYHtMsZvdFDOt0Bo63LdHtrsoHonPnkmLPDW4w2LrOxfRFrM7TR53QXQiQoCUWNChElJs71bHrK7OhdFuNbjOdLTGmYTBYE10hGSZFTFDmLaspzz7zAM889z7/8tX/I6WzJ9Ut73Hl0jCp7HB8dsnvhEtrkqODEwUxpnGvJtSHPLUWuJdOsU1LkBcN+l6dffI7RxgZlXvDGO+9y787tJEZXoCVbTAfHvftv0R0M8NMTLm31GfVLjF8QT26xUAoXFGWRo2NGPtimN9hje/uEe+++ybz6CpPxnLqNXH7ieeb3bvLg9a8y2d2hfKlk6+Kz2PGcOhbkfoILDqMzMmOJmdB2gg8UmWHQzdErZURcCfTlL0Yp2TwyAzZikiuQigpUOD/mZ7M5p2czzs5mFKrl8y9e4Usfu4qLhjYIfG3UF2nmU2jm5OvbKHdA20YCAZtlmGxAZnNG/SxZwEJuc3q7F3AxULdJ4we4qFAhgooUmcUHCTBEaYTKrRJ1KaJ1pJfnXLzyDDsbF8l6W/+2S/LD9e95GSJuNcFTkJksORQGIpbQDrAmxzihlAVVErQiKkNrQMWIDZHaGvK8x1oFndkCdXiCCopoNLrps9bpcLMP3moUlsIqWnp0XI8uNda1NLnChkiLwltLjAodWowydMqcUol2wRqLMn2Mb3DOgWulEVSKosjIbIEpMnAddN0yaQ2H2YCYGbkZOi+fWcOFvObzzxg+m3cp7Rj0Ol71aVwgy0uKvHMuVK+Xc8LsEaY9weSGxtUsl3M6nQ3U7o/KRN3IxFca3WRp7SQLzeOw1hJ8xGRD0VypLkbJTZPg0sTUEINY+EcfROjulrTB430k+EioJ1zTa9Qu0kafaFQBF2S6GWJI1s8eFT03v/MyxckxyuiUc6aIybSEFTULCcY+nY1pb8/IQyPXbISghJmAivg0Sf4yX+OPLDB2/MhHPgMmJzMGjJbjQDJXysRJdnbwOt3FHazJMMZhTCsW9xa0jRiTSSSAkQKlLZ+nrN4V1DDdu+68/RpvvvpVmkeaNhqhedqMTGna4NGDDSb3JoBkKQ2aknp+SGNGiTqqkq5yZS4ThTKrkmvo6t7A6nGPXy1/nAb6odPsB7di8DStZ7GYo5RiY2OLspQInvF4TFUtmEzH7O8/TPceTZF3adoGFw3T0ynL5ULQtI5mOIRef0DdNizrCtc6tjZ2KDsd6rpmPB7Tuob5fMYTTzxJnpWSa9Y2zBdz8jxjPB0LlUwrup0eWkfuP7jPcDAUepsydLvdhGRI4SzUbjn/NrfENZLUxCmlmC+mABIszfvXb+taGYp2Oxwc7hNX2idlmS8WQntsa4L39HoDQgziwmf0edA2ShG8p2lqvJfnm9m5DJZipKqkoRgMRmKzbzPKUvRn2lrmyyVvvfMuBwfH3Ly7D2i0juRKYxJCXZaGtf6QXlbhgmf/eMHRvKGqW2yi9mmtGHZzgoqSSauEZuic5KIB39WUxVQbyZ9jAvMlZBulxL0zROaNuDCaKHq31gViK+wGH2WAFEl2+UTqpqXTMSmr1p+/zoq+6r0TLVZmsCuNWiPvX2tF4xwqBLRyvPvu23z+iz+O1Zbbt27KvSBEbGoUVxRRgOlkzsnpGRtra2gNmc3eNw1xDXVT49wcm2m6ZYFz0nxJuKUwG/LkAtm27zejVmlxP1cSPq60Pg9EN8awvbl9fl6VZYbWsBYibSOMJmOtMB5lDM8///Xf+L6v0x9Ic6bbioPTV9kaXeSNV+7z3DOfZHz0kJdf/zKXdi6RF32aySnHTYULNTvls0wWU5azMzrDNUaF4ureBWZ1RDWRJubsXXqGa/6A06MTXr/3NlfXB7y2/xBbGhZtoMgCly89zcP9W7TVENrIyf5bqKgZblxF6wLHDG07YLs0PrxfLHdLrjzxSbRUJtLPR9i88hLayLREk0RRUeFTLoUBTNmj6PRQMTLavpRyfRIzyDtcWOC94+DoEbNqwfMf+2KivigyHc+pMABRxZQPJPxbl9y8XIh0B9tktsf+3V/lmevXuX3rNkXw7J82BFLqe13TsR2uf/RpTs9OGfQL+t0OBycnhBhZJorB0eEDCQZ0DhfkAjQKjMkxGjpFRlaUaNujO1jnCz/3F+kMexwejVFZzu/97r9iuVgkIWpyldMGozR33rmJNYpf/Cu/yJUXf4Lp8pTF8gS9XNLMjmlDRLUwW05Z27uOrRf4esGly1epZhPsJU2tcnaefIH19R7eweVnXsJ2Sg7vv8myrulka1zo9gGPV0I5AAlXVLpmNOxjSo+JtaTLKyuFWhSuuFKJH60MhEYyi1SGtblMb9pTYrukoyK2F5i0E44e3KdpgWKIGexQdkf0ux2Gox5DE1kua6yO5N1cQnBdQ1XPaad3UaGSyXfUZGUfnXfJbAdtLDZ4rC1BWSmK0vkQvEyh0BoXIjohfyvxbYyCtg16m9DflPPzw/WBLasCnoBRMsE1SvjqURnGbZ+7bpM32OUwdogelPZgcnzShqEjtYd3w4jLzR7X60No3oQawEPjwC7oTxfkoyHLMqMoCmwsmLod7umr3GKbZVCY1oM1ZIADaR6cYpL3eKiusE2kVDfomJbcGjohx7ctzjRE3xJNhsnlemjZYT9s83bc4ShagmvBgFcpVywEQlCcKLhtRlxUF7mioVTmXJRutLiYrSbYwVXkGWRFH6MUmbVyE0SmUiZNH8/dzULEBdElSA6iCKy1NhA13jcyEVcmBaM6IJBnhVhaWynEAiTKSptwHMUzT1/iC597Ke0NQVD4KJSj1gea1lE1FfiAVhkbvS69sqT1/txaOabJcgieNgScWxI8WOX4+PYlxm2Ld462dbTBU/mG1nmxzA8BHz0uKg7u3uWGsoLAJpRQG3uuV8PI550dvEFeeawROrmPHqUjuZGHKNWm7DgxlInlK5T3fgtri0QRVdx883X277xONTeA6AfL0rDR73M8WTI5rIi6A0phleLU93jjtZfZ2dhEWTGC0UZhlE1oIMlZVJ3nnymTmkGS4YzSyTF0JZyX/yut6Q0vfEBX7ofr4aN7dLvDZPoReLT/gDbRxpSONE3NcrkQPatS2Myysb7JRtlhOj1jOyvJiwytDIPhGkVR0DYtnW6XGCOLxZzFYk7rW4q8IMssdVOzmC956623sEaofUopFosFeZFTliW9bo8iLwEwpuDJa9fRRvRaWSbueycnRxgj9vXGGLrdHiF4ZrMZk8kUo60U8K6mqivWRmuANArGGpqmpmkbut0eSlmGwzW00vT7Q5xvGQxa6qYVzZJOaHECgX3wLCuJzSEqslxClbM8p1rWNE17TltcGWNUlRzHfn/AdDqjaRuqWc3FC7v8V//V3+To6IAiN3z241f51ut32Ls44mhcU+aGzOQ0bc2icbTecTpZ4itH3UKjmvM9rZMbjF1piaU58gHqVppwQdnjeah2CKvrV/bV8+YsSG5raRQuRvrdnIiicUGQQheovDt3avTeJ2ROpZxdkt5K1irAWaiC8l5jlPqzbsBH6OVZqsFaMYbJDGcnR2IGExQ337sh8R0pP29lwCFmJxHnHO/duMGVL/wIPsWVKBRtW0mweqdA6w7OOVrfkpXSvFmTQrO9NGCrwZxWQg33CeF8H/2T5lylWl1ca5vUgLWgQtJuSzyVNO4N3sOrr77F17/x1e/7Ov2BNGe333ubhVZUswarSr4+PuLZa9fZMAPyNnDy4AaxmfOgOmVrc5vb794gakM5GNDJFabtcf/hPW4f3gcMe2XGe3e+CdUxdawZ9TpoXRComRyOubp5gd5wQLU4Znq8T9dIAd5f5uTNmMxNaOwQRWA+3yezV8iMJdPQtDKdcUGdQ61Cj1EomxEVtG1NnuUQIm0byXJxLgtwzrEPpJRwLUWLjqKJst7gXUOvU7G3ewmTCoiAnIwxiCOaCN51Er/KBCNPUwmlDcTAwYMjvvOtr3J3dopqHePZEhf9ORQ97A945sVP8s0//DKHJ4dc2Nsh04buaIt2XNE6z9nkmCevXmNjc4dH+w9ZTMe42FLmhWyQRpMVHbYuPMm15z7HYHuH0bWPUZQZU6v52m99hb/9//o74MF5CQYUjwEr4aIh8vkf/Un+k//F/5a1tYEo/KLY8C5nY87GR7RnB/SKnHZ5ytlygatmVE3AFLtU9ZTIhNvvfo2uyslzw9G9b3Dr3bd59cYj7j484dKlZ7n+/KfJO310XtIbDaXBjXIMet09ymK12cSkN5ELuqrEFtsag7UKyCF6fEgFkdZk2RB0nyLpSUZbVyg2n+TB/hFlUbAx2mDY77LyYtJaDEcyo8iNSqGHiryzLro9I5B/W0/PofymWdLUC9rFBBlal+R5n7K3hsk6eGTTQYkgV2lDMgOCCC4mA5M0LfxwfbBLJycsbQw6GjIlCMW0XeNOvc7X2l3ebDeolDRM2kdQDpPlRK3RRLzWHPiS3w87XK6u8xF3j54aQ3Co4IjzlmI8o7e+ZFJaUDlnao/39GW+pa7wIHYJQRO9J6pAbjKMikBDUJopOTfMBdA5ORnD7A6ZakAbXJouRm+IOqBsRq22uOcu8HLY4/WwTksOeEItlvqkUFYdI84p3ml7EC7hUFwpzsgQ19dIABUJ0ePaBmKFUQ3WJFtoq8lVlowpxJUyMxoVFASVrPqlaSK2hGiIMcc7J/FniGmAQ0TtbbOUQtC3lLEkC7k4l2mNi4GQ5mwhig5DI/bXubVoLdoarY08lig0GhSDskuZguNd8LRNm4hNQjmMRJx3YlAUAlEpXnz6KkqJO53VadLrHU3d4kKLDy11cASvQQVp7DEYZYQqJAeQRtJbRfeTfQRfb+HcgtP9B9Qz0d8o1WKNwpocbS3WGIgtzjb0uCMat3SfevjoASpMGGQ50YNzDjeBg/EjvFaUJkKwaISeHaY53/nmV9heGxB1ytI0Fq3sOXVIGjCTxPcqRT/oFEabRPnpP6MzohZ6p1aGz3zh5z64i/f/z1fbOCZuzGx2T9Cd/pDr15/BGItPw4yiKIW2azJiittZVkuMzSS3isigP6AsSx4+fES/1yUvct55920ODh5hTEav16Pf66GUYnNzk93dXVQyCKuriuFwiNaaqqqYzWccHR6R5eIUeXJygjWGfr/HcrlkMBwyGIyYz2dU1ZK8KAhe2CqL+QxloMgK5vM5xECW54SoOBuf0ul02drcZmNji36/lwYzMWVbZalJXHJ2dsxiMed0PGG5XLA2GpHnBWVZ0ik7YvhhAr1eXyihbZvojtKIdUpxxq6qKhXzhizLRf+uDRub29x4911+/df/MePTQy5tdtkbrHF5p8tmv4N6ZotJpaiWNb28Q4hwfDIjzyzzRc0mMA2OaTL7QCWysVJkRhETwtg4L66oiD4sJBdDpcT0QydDNxDK4aJqUSi217oYrWgduBBwWtN4DwHqIBqsNjV8EsUg94PWeTEsCRKSXeSWZdWmpkcs9EmyIh9ELyt0QNI9IRKaFmckuLk+PmY6nTA9mXF2coLNDEZrQaOi7LkxgSK+bXnjjTf48S9+AaPNOfus3x0Rleio26aW7yEELl6+zM/+hb/Ar/2Df8BiviAvMmLSAhLl2jDWiMY6acVWCGDwDhcNnaKbhg4ZrWsIXsygjJGYgaZuKMsORW75vd/9Cjdu3mRZLb7v6/QH0pxlTc7J7ZvYKxcpigrddOgVfZ594gmUbzDOU5SXGCzPuHdyxvHZbQrbJc4f8eRoh7K7zsPDMQfHh9Q0bK6vYWqFjwXDosdwdIndC0/TtTknxzepFifcPzzg1pvvMt0/4GjtNtsXttnZvIBfHDMflwx2R2g7pCh65EYcv7yLTCdHdLsjgs2Yz+bkqhZhbDmiaZfMpscsqxm94SZWZfTKAbFxoLJ0Uqtk5CAaifPJikowsdEo3WFr59I55K5S0SJuaSunHPldrUSQ7pPWKEShDCqlee/d93j74SGVCqh6jvPyWmVWUrUNJ6cT3n3rHX7yz/8F/t9/678kxIxibYOb790k63YZbG5y5+aCs+mMnd09+mWHUa/H2clxMlIxdLqbXHz643zsR/4sF649TVF0QIHJcyYnp/w3f/O/YHpyQn+4Tn1yKJQBbYgofOv5+Euf4q//7/8PbK6PiKSpTAx0ig5ZXtIbbWGeehGTJu/eR2K7TAVcgVEehSfoDsE7jsZH4BrWLn+WT/14n6PjO9y7/SqPTh7Rya4zGnTx0TLq9djZGuFCi7WKLJMMEvMY/cgYQ6fbF86zBsE3NUrlkhuVzl+js6T3kO/LRriwscbO2ggIcty1TGRi0i9arbArW17ku48iAknHSNHprafTI+JDoNeHuKEJBJp6wsnpEZM7b7E+GNAZrKFtQVQaF7uUw41zkhAK0QtGmVB/uD74JUHQAW0M1oLyBdO2y41qg68td3i9WaeJqzMOTHAM2jmZUiz1GkulCUrjreVRm/NPsgs81fsMP9rUZNXbqHqOah1qNmU0n3B/bZ2TsM077PFNLnGHbjL2cMQYyaqaXEMoOjTKEk2g1XCK4k22UUqTR8VVfZtMVYQQaWMtaFfMWMYNHnKFb/oLvOZGQpE0gmxlvqUXApiMmS4gymhqHjWvtl2IW2Sq5WJZQ3R453DaEpLRiAwUAgFNTHbNKNImqEQnFkTP5ZUjEIgmoFKUFq6lTuHGSsVkwBFIj6RNNEgVA8q1OCLaWmJ4n14XQ8SFJCgHrDJkOiRtpzSFmVYEpSS7zmhsVmBMhoRlg7KR1rUQXRqQSNishORGiJ4WUMHI71grLojRU+hIoQ1RKQYYfFC0ymNUQZaiDhxRPlP05KSmS1m03UbrZ/Ah8t67d7jxztsSFFw3FHlBrxgw2thkc+cS1uY01ZKNNcWgV4h+hMiTVzd56dMfoWqEFrRoPW3tefP1d2lcpOhvMFzbxERDjDVRZQwHI7I8o17OcHFKiGksGECm4IEgVnHIq8Q0QY8EVpEIosVUKhN9XzJg+LA5++DW2toWo9Ea4/EZy0qanXfffYdur0cvoV/9/pA8y5jOp/g2UJYlk8mEs/EpdV1BhI31dbq9XnqOOfPlnEF/yPraBiGIfqxaVkBkPJ7Q7XaxxpLnGf1e/9ycoqrSMLwrZiXGWnZ2dvDe0+10GQ7XaF3DeHxGVVVsbe/Qti2uleu+KAqyLGcyGVPVS/I8Y3Nrh/X1bVCwWCxYX9+gKMr3C3GExrZqDNumARWT5k1jd7aTFXtBWRRYmzNaWztvxpbLJScnp9RNxe7OHkoplsulsCeimBmttG2tazg9OeKrX/kaX/vmV2nqios7F9lbb5iceG7eO+HV5QHG5gQimYLRoCOmYwqWCh61nmLZcBw0EYePnuBBaTGvqBvod8QgKYS06SkN0SfUUKM8tG2iIqaGIxIpgaJu8K5AWYP3QmkUJYdodU0INDESPHS0OQ/D1mlgp/SqBoLcWirlzvf5EFZgxKp2VsToKRKyX3uPawI6j5Ra01QVr3772zy6t49Njp4ocRYHJVR25H0qDXfv3ePO3XtcvnSRGKSx9F50ggr9mBulGJu8+OInOD0+41f+7t9muj9LmjjzfrxNiqwJIdK0LYtqmcxzSn70iz/Cz/7sT9Mru6kGiOjMYJyWzxvl82VZxmvffoXvfPvreAK9buf7vk5/MCHU2YCLl58kLw3buxeo65bx/h1shJmraeqKo3pJkUd21ne59EM/yaC3x+HZA/r9NQblgP7OCZfrKb1Bj/Gjmyj1iCvP/RhrF55hfTTC6BKt4cJTnyK0Nctqzie+0LKYTclMIDZz+oN1+psXyJNgcwWdu6BwARrnmE3G3Ln/GmVeopspa/0eTduwuX2VZSg4PbrD2fF7XHv2sww2rid7efmyVlR6CXpNK33hsFISpX8TYIegBFWR83RFaEQmyyGkDCPOT2KVCvGmrfmd3/xdLly7xI133qNpHUrlPP3sM4R2yfrGNt3RGt/8yld582v/ms3dXda3dti7ssfs+ITFdMo777xLiIHp5JhuJ3L58i79wYjnX3wW1ekxGm0w2rzEcGObjYu7LOoZEmwa8E3Oq9/5CnduvkNVNTRuRlF2Cd6RKVAROp0Of/Gv/jVGOxeofcCmBkfowAYfJZQ0OuECRy0ZakF3CErh2gZfz9BZF+9rpvNj6tPXybVh0N+is7bLtauf4lMvfZq6bmiDR6mc1gcyoynzDB8CSkmztGqG4X1etSImeiBSOqj33epijNTeSfYQCA+ZpJxIm0lEY438VKcNiFRggGRjmFUQZYg4v5SsCzQ+bX5tWydHJMTqO0ITFHm5ybXrVzBWzEAIAVfPaZuKtq0pbAGJEmu0TMZW9gWtE/Tzw/XBrNa7FNiuiFFz2vR4b77G16ttvlMPWSp9Hi7d14HLasbT+gHrtuW2vsQbcYuzUOC0IWrDO/mQv7X7FF1V89lZhpm8jppP0UvHaK6Y1Nu8bi7xstrjPdNLFMOI8oF+XHK92Wc9jjluNrjTvcTMFihkz5pE+A7rZEFj8GzxHrGtaIPsXZXa4tBc446+xn5cp2plGGEIGOW5oia8YE6po+aVuMux6ghTIDqc0zyMBdOshCgT2BCjOLIppPHRCo09LxRkXzbgBV1TRtPiSIaWkt9GJlQcLRoZ573ocxVkRCn4tWj3jJXcRqUNXglCZkNIDaAWe2Sr0EFDcLjoaYIjRE0WLaiVrlgQzVyDtQVGmdTcSSis0aBNoHEtJHrjKliZKHtFYson7WtEY0BnqHN7a4jRYXSU96YlwFsZgyFRH6NP0l6ZGBMFffcqMlxbo8g6BOfw3hGIzJdLwskxdRMoihyrDd1OSdFLeXExQhbpD6GMCh0LjM7JbE4/q3l095grTz/B5WtPk2U5g36PTm9I3TqiD9y/+zb9Tg+rhWodlTSZMYjBVNs6Fq5Kk3vR96664hAVRJETBC9T7z+JrfSH6we3stzSNBW9XpeylAZCG4t3LSFIHfLee++leJuW2XRKVVfn4b9KiX41Bk/TtERkH1nM5+Lm2LTkRc50OmFjfYPd3T2KsqRpatq6oaoXTKcT6qaBCMvlHO+dNDONNEjra5KFNptPqOuK+WxGt9tlNBqymEt+2rKqqJuWsuyQewmstrmlaTyHh4doLShcv9fHOaFYQ2Q+nzObzVBKapj1tQ3Oxmcs5jPG4zPW1teT7k1R1zWT6YRu2aXX7zOfzwghMJ/PODs7pk1Zfrs7F6haCUluW0fbKowpODg44tvf/AbfevmbaB149okrzBcLtDLkueKJq7tcaj13H024dThFRUWvU+JbjzUakxmOlk7ip1ppdmyeoUOkiV4QNIRK2SnEuXJeNbRe6Iw+ymBY6h25Jr0X7RgAEWqjiUbC4b3zOA/OianJSr8v3gQZiyaI4Zr3aHSqawNFXkjcACohaiKBWbnoxkSpXA3OszzDGoX3SW+mhIvgQyDLLL/3u7/NsL+GMoaqFhaYzSxN057XeTEGtNJUy4rf/r3f46/+4i8K4pUYR841rIyTWieRABqhw37px75EaB1/9+/9bfm+nMN5yTjzXiiOUjPKcep0enzpx77Ef/jX/geE1hOjsCnEMEa97+CLotPpo7VicjZlOTvF5IaNQf59X6c/kObsxR//K0yril5vQFZk5Frhjx7wzjd+m/sHd9l74U+zuX6FUa+gv7bBaOsJ5vMJH7tynUW9pNtbZ+eqEpjaGJqn/hQH++8KP5aWNsCimhBdRafM6Xb69LOSvOPY2NlLxXQ8L8AdER3iOY8WFTEKyixyee8yGxu7tNUZ1eSQm299lV7H8vo3fhs77KBUxslkyunygL2dp7l08Vmyco1uZ43c9uTEUyGdIOlODAkhWYXLphtTKhRCkJPcJ/tjGbom/q0P5w2FD20KjtUsZxWL0/vU8wlVtaDf6VCONjBZxsGDOzzcP+ETL30Gqw2P9u/x8z/35zirI4vTh3zq489wejRmc9Tl62+9y3Btk6ee/xRXLl7g6Pghr7zxMr1ejyevXuXundfo9Ps8cfBxxrUH13Lx6rMU3TX+xT/6FaanJ+lk9ULhUmCNprQ5L37yJRpl+drr73L14i7bg5JerslNhtIBqy0Nks+mTKIsRTAJZSRCq0s6tksIjm65RtAli5N3OZkcc6F/hUAXoxRlmVNG4Ua3PhADYo+qPZnJU4P7Xe1vatDkrFhdZD76pNdKTU9Kakx+RSvDtMeeIyX8qMg5DhplEgS837AhO0KkQOHRWgpQo4TSo5O7X0D4y70c8mJlYyt22DoTqkWwK0Ht+zRacXBLdrgp8+PD9cGtNrg0UFGc1n3uLCzfXG7yerNOHQ1ZBGs1uW65Fsd8Kn/Ik+V9hkXDpbYlbyJf87vMoyGgcMDLRYf/YvMZMp3xyaCw9ctEl1PPLnB/eYmvdi5zTw/S8EcQrb6b8Jw+5RP5HTbiQ059j2LRcCO/xtzmQt1VmhbDK3qE42k+jWODJSqOmYdNTsqn8cOPUOo18rnHupahgtZFNsOMT+ePeLF7AAT6y4o/aq9yrHuii4wO5VtiDCJk1xI6ra0hJmqP9zLNCXhBXZRCBUGeGx9xtKhUwFtrzu3qFRHlleybsZZmz1gyZcWLgoiKBptLULXQ7XRqAOWqymwm7m4p+y14RxtaWtfivMdHiQHQiap3bk1P0qyl55HjaNDKYpUMsIKKRMS1caXbiFHMCpTSeCQbySiDClGeUUvz2ro2masooaMajY6KaCF4iYfx58GqHt8GggpkWcBkClWJqxxRSQGzrIhxQltlKJthOg35QO4lIUZ8dDROMulyVdDR0nhe2Nvl5ju3ufveW8xmZ7imoShLNrcvsr6zR9np4aJj2c7JTGomU0ae8y3ap88ba6IKtCqibY5RhgxxslxRwX30eAzGfjhU+iDXxb0rGGOYzSZMJhO6vVIKeWeZzxcslnPqusI7R1mWfPyFTxJVZDabivtqQhIUis0NyS87OT7CtY7h9gUGwwHL5UIKXtdy584tOt0uIQZymxMJmMxQqDzRC/spB3QkdLbphOPjQ0yWoRR0uz06ZZder4exlta11FVFluVkWUan001ar5joblJzWVtQFAXeOcbjsdApkzW/xAI45os5Rld419LpdBLaIgYh09mExWKBItI0LT4N+5XSdLpddi9clNpBCZKW5Rm9bp88L5hMzvjDP/h9/tk/+3VOz07Z3d7i0594gXpRcXF3lxgDeTiiyMQle2ety8HpkqNpxe5aj5NpRTc31FETXUVmFWPncSGggkIZ2Wch0i0UG8MeVmsOpzXOx3O5TPLNEABhFY0YVywvYRQYBd1MmAatD9SNp3YBlzRcWmsKo8Q6/zE6pOiBIEvPo9CJTSIIWQgrpPwcyhD5kBYTPIk+UeQmF2fONhC1Byzjs1N63S551iNGJblmUVy6xbkzpNfwRK+59d5tXnvjTT76kWfIlBG2UhqGBR9wbYtFGA0KoaBfvnSZjdEaZ5OxNO7JPC6uYgPSCsBf/qt/mZ//mZ9BeY9VUfZn1+Kc6O6ssd8tN4nCtBLqtyXy/ddrP5DmbO+ZT3ERJdbgILbRFz7C1rOfo1ossT2hvNWLI6ZH93j9ld+nHO7y+iu/Rac0lJ1trl1/iY3BDtZosp7hqac/jlUKH51oDmzObOJ49PABg+E6IRXDa6PNlDCfJrTpxAuPoRsqitbBtTJpKMqCsnOV3sY1VLnHt7/+K4yufZpB0eXdRzdZ29rFaoux6xwdHZGXjrBRMBp0JGBwlZII54jL+23B+w2aD4Fl7TE2UliLVkJv9F7oUEqlk06BTQYbIYguIu+WfOlnfp7X/m9vcO3SRS7ubXPp+kt89Wt/hDUFw40Bf/pHfpiOsXzlX/8W//Af/COUD3zqsx9nbW3AlU9/nP6bmldv3OGzn/9pfvl/8r/G6IzgHbPFFBWgW3ZwMVAtJrimYdcULKantHXFt7/1L3jv9a+nRHbZlHzryKxoDDa3N/mZv/SfsvfkdbI853QC8/mS9WHBaJhRWkWmRT+XKfVdhQkoLAqbl8QshaJGg7I5Kt8gmjU2N64S2jnNMiMrBtLU8thFrgJRp01BpeMeICr/PQ1a+lkw+NiI9kGlZjlGdDQEFWnahvzcTVN+0aQA2XPeKmmSolbWsyunMpmSq0RnaNtADPI8jV9Q2i5RaXxwhBCpmyYhu+K0RkIXmqhovZxf/eK7L3aV3sXqz/p7s5E+XP+9Lh/kJrSMirtVj29XAx7ETaHYhoAPGqLjmp7xkt3no92HDLIZMbZcyu8RUDQq42W/w1xpglG4kPOVzgCvnuY/8orPVgrXRl5TH+Gr4SL3Yi8Fc0ZMgL5f8pG4z4vmAZfLA3q6ZlDVUL2BauDNcIlWFzJBMLBw8Koe4HiSj8eWbjzhIRc5y55kaIZyGkbPZmHZVi0dM+Oqv89HO4/YKsZEDZ9UDbGKfLl+ihNTiFNilAiJoDWZzSmLLnlRCvWoCUSviT4Qg5frJ64QaNApTFkl3ZIIriXoWgg8ws5Zad40BrsyHAlO0GQFBCcIU1g1ZiEFisZkOJKhjSEEi3LyOi5WYq4UI1mMtGnSijGi8fQaHeS+ZrRFpW1fpWJhpZmD1FCaxwThQSbQQaWczRWlT0EIBq8jIWqiyfBWfk/2r8j7LmgyVdbBC10oLxgMDJcu7/HmG2+J0YkP+GSE5NoWtbaOdZZ6KdlCBIuLPtHnDTE4sHLP0SEy6ve4cHmXd966wfHZCVpDUZQsFguOTw7Yu3IdDMzdlFL1yBCaogstlaslCy9CG1t8bAUVUw0aS6AERPMblcfHVu517gdSdny4/oQry6SoLTslRhucbyW6aLkky3LJOHOefq9Pr9dnvlzQKUu63R51VWG1pW4rZtMpdVVRFgV7e5fo94egFbPZjLYV17o8yymygs1NaeKq5YIsK3C+ZTabypBRIbbkNks0xZLZfMZwOODs7ExqPCN1VVUtMdqwvr4lOWneY4zGGEueJ4v8hSBxdT1juVxIA2IMTdNSlOU5tTLGyHK5OM97M8a+T/eLkQs7F8lyyV+bTqfo5A5rrdy7vQlMJhMW1ZLx2SkhCoL29lvv8pu/+Rs8fPgIYwzDYZfBoM9sukAnV2atNRjNomq59/CM49MFi9qzfypmIxc2u8Qghjt5keOXS5pasmnPB80+Si5rv4AAh5MZVRtE2xmlcZOxH0l7Ae8Pq2NC0qSOrr2jaixtCFStk7hLbSjLjLKQ63Uyawghim4s8cRiEL2y1Fnh/KW0klG3ix4dk56e96mN56w2JzR3rSWwOoZI5cTaPtx/wJUr1yRYPLPUVS3HXoPy0qiKwYmwGX7jN/4Vly7uMer3pY72ThgJSQfrfRA9GRGjDM47MmvZ3VpnWXWZzBa0CWGtHnOE1CbjySevYpQ6N8WLRHJrxW7fudRvRGIUIxGjNb6tQSu8c0w/KCt9m7JUohLqV440R1XWwQ4KfNNw692vsTx+nfVuRt5oFnfu8uDuu+yPD3jhox/nqeufxKWbkFnRYYgYJXkIWMX6+ibr6xvJgEEsisUhRd6HQjivLsjpJ4nd6jwAzmR5OmnkvdoY2b54iS/+2f+UTq/EKMUnzicN8hwhvG9pvmq+3sdWVsF9+vxfoloV8IiGIVPiwhgCtWvJrBZqW3qw0aJBkkwKEXCenU1YHw341Ode4vnrzzGpTiHWnB3f46kn9vj9mzfYvXyRu7dvMuoHXvrsZzg6nXDtyhM4GsY+45/+/V9nNh1jyg4vfvqHccGhjEUZw3BtgywriNGTh8hgNBLteFRELjOZzfi1X/27nE3GBO9ZieC1VmRG0ylyPv25H+PCtauU3RyNRZmMoA2TRuNmsNZVDDOS+Qm4kMws0rEV1EEmqpqUFq8KBk98DH/1BSofmE+OCVXDqCQZqwRa7xlPxyg0zXJGv2PIRjsoJafyCo300bGYHtHrDDBZj6gii2rGybFQabXWdLMSbTOWjeNosmSt32ej30eFFmVsMkAIaROTCzLE9xsyOU/kDyZdnDpCtDZRmjSZUmRWYH6DBQO5fZ/24308J/lkRIoiJys5px08jsSu/v/4zz5cH8xSiPg5BsVhW3Kr6qE0FMrQBof1NU/oOZ+xh7zY22eYL2hjEKRGt1zJH2BNjq0U31CCoEUDgYxv9PoszHV+srtJxzX8xmiT13rrBK1QAbSLdOKSj6pHvGDvcjl7SM+mqXSsuawOiJWHpuHN7ClqXaK82P83LbzBJo15gQ294KHqMwsjthaRKrTcWcDQRrayGU/aR1yyD7hQTDG0aGXYzJd8Ot4nes2Xm8uMKdEobOBcwxCJKBWFZWAzlM9kaqntYzEXIWUVBpS1oGQCLe8ySCEfZOKrlcJamdQrJa6NBk3QMkX33qEwiFGIBNI67xM1RZEpAyplXhIxRq5Pa8TZzcfA0rd4ZLCjvCY3lgaSAZOmMBnaRxmwpHMghCDFSaaxGBnaaWnMvPeJ0u3Sq4bz96MSkqVURlBBLM6sPkdETQoGd96JG7BX5DajNB2UhqeeukKRG77zyiuMz8Y0raeuGqqqor+2xcbOHlnRYFVOVDI9t8qgTYnWgcIU5EpQCaUiTz15lQd3H3I2GWNTEzoYDrG2YHx8wHBD0LPaVWBzorL4kFzgjMQXmBjFtTbIlNroSI2Y5DQ0BFpqLzbWXdv97/ty/XA9tvK8ZLlcktuCtcEaNs/knE0OdXVdMT47o9ORrK+2lUzR05NjrDUYozDOsLu5izJSsC4XC1zrsMaC0WKB7wOz+YJOWchQ2rlzfVg/6zMarIm0w8qgum1aitRgbWxsMptNGfQHTCZnONeKtjOh42F8do6QKaVwjWMwHLK5uQ2psdA6UDcLoVivqre5Isty1kYbYiBmLW3b0rYtMZKcXRNalBf0+wNOT09YLBYMB0OMNZRlT9xi85KqqnHOsb29zbvv3ODv/8p/zqNHj1BKYa1m0O/yzBNPYK2hbhtiU7NcLNDAZq/lYP+UxaKl38vIOpZp08NmmsbBpGrxIVJXjvGywTuHthJfoUEC51FMFzV1E6gblzRdAefk2g7xMWnvOYIVZRCkhRUQIiwqxzhv6JUZw36Z/BHktXyMLBY1TSv01RDa1fxamhUlw8qoVqAEoDQqvu9GDZw7uao0AA8h4JwMykl187JqUtOlmM1n3H9wl/X1TXwrrqGrRjvEZJCmJeh7NpkwPj3jwYMHFFeuyDHSWsxYVnWmNilqIOBpuHnrdjr/NJ1uCdqwrGRAZ+YL6laMnrSx1HVzDrg41wojJGmNJTzdJ1qnHGeX7m+JJkdefv9sgR/QCCt96VGamTZ9IeIup2jdgmvXnsE++2kyo7gWIXrPc5Mx2mbYToded5joY/r8OSMCQoqboZx0EY1WQUI7E780pInAKhaK5IZoVTLt0N+rEQOUOtd86V4JacagkemmTvbKwpFd/fK/qSBWPF4nS+EuVI9l3TIen7BYLGnrA65deRqVjWh9K9iRMoToCSlPAWXQWrG1tUWmI1s72/z1/8v/iVe/9RZf/6OvcO/+u6jC8oXP/zieJYvpmMIW7O0NODmbcvPeexwenbH/aB/nGrRWXLryFOvbl1jUDlvPmU9OiCqytbOH0hkQxRAjeqKO4Dz//Nd/hW/+wb8kOrlqjJLQVZU4mdeeeoEf/ulfRBux5Na5IjixFp2dzYkbu7RtThzmDItV+KBwis8bDBKNKFEExeciNUMKgm/olCP6vZKVok8ywwxrw3UJB1SKfr/DeXp9+patViwqz/HxKWEtY3N7QOs8BMPDd18h04qiv83W9mXWt69Q2g6jvmScKNdgdUunt4bSnrZdYkyJTkG/2mhA4wPnBjHf3TxJ3ohcDpEM+9h7S5tUgt1DUGRWxvEqprDIBMU//vjzU/cxesCH64Nd4qon1DPvoQoRF1oaFYgu8Iwd87nuAc/3z9js1RA1oTE4pOAuTc1V+0h0j7XmFbNNpTLJM/Oa17IR93sjtIZjY2kiqOgICnIang4HPK9vczl/RN80aJWjlaabl1jjeMJMyOrbmFjyRrxKpc25wHuB5u2wRmnWWGQFjVNMfaQJsGw9W2HGVrjHheweW9kJBrlRy57uGeVnfKx1eO/5ur8k1BGdWp8Qqev6/DyOiIOYNXkyBRLmQBOWeBzBRzJtQIMnJIpc2su12MorIEMTVcTjCSGeh44KlVgyzc7HHOeFiAy/Vq5d3jlU4ilroGNzWudookuNXUj0TEHOZNgsGYZV8GSszH4MMYitvoriXOeC3IhXuiqhTPp0GScqY2zFKTLto5mRa15pCKmxMcggymslWW1RDExCBNe2gv5Fz+7uFsVnXuL3fv/3aeoGpRV1s+Tk+AFlkfPE03uYRH9WUQZbmZUmuWs6cleNgcZ7il7Bxz/zIi+//AqT0ynaBZbLGeubQyazM3qbkRWJvwmBQE2Mq0Y5w2pNJKMOBnyLiYjhUqJRZRgq18r9JCaK1YfrA1tnZ2OyTM5hpbo453jw4D5t0xCCYzQcsbG+TtM0ZFnGcLBGXhbsXdjDec98PuXo8ICzkyOKskBrQ9ssyTLRgDdNg7U5mbUMhkNGo2Fq8hrqpqHIClAIehUSKo4MbKplzenZMePxKW1bE0Kk3+vjQ2BtbZ2yKOSa9JCXomur65pOt0SpyHwxYTab09QV3W4fa3P6vSHD4VA0miHS63VRSierc5Fr9BJy1tQ1i8WcLM/plB2c8+LW2OmS58IGGI+nzGZT+v0ek+mYmzdv8lv/6rdom4aDw8Nzm3+tFTvbmyyrivXRAB9aMptLc+IDzXJGr8y4vDNgsWiYzht2RgFlcyKRw7M5s0XNvG4JPiIyXum2VvoxgMYJ2uVjwEQNaVCmlCCk58VvlB1NYk6C3JOEZ04EyswynTeUhSXLrPg0NC3OR5rWU7WiGSasMmRD0tsm9RDSYLXOY4zCtZqcSHNey6RcukjSoEHdSq6kDyFFdCgKawHRk7XNkoNH97F5XwZCyHCuaVvqtj1HOUFRlB2qpqKqa6y12BTZorUmqMePSeTg0THf+tY36XQ7OFeTWQulOae9Gi20cXHdzLh//wH+E5+UaJgVk8yvaOuCJoYULUDaLSV2JQgYw/dfu/2AmjN1joisGpWIFMnaGPLRNit+qlHp+4yRbm9ARJ0Xr/KRVKK5JUQCyX/yYVXUiyPUCr1QqbAXLY9MBFy6qbUrVCbdC2Jy0nOuwmYlqRUT22W1mujKc1SuFR6pJV0UoiGzCOomHosKokxT5TNoYvRU1VggVVUwPnvA9HifW699hdNrF9m+/Bytsly8+lG0smQ2h9CwrGtMPhQ3Ph9RuSYvC9a2t/jTf3adz33xcxwdnHJ//5CTk0P2H9zj4OA+N956lfH0jFfffJe2Wcpk3uZcf/p5bt16m6tPP4/Jc5azGZkx5GUfpRWzyYyIkuwaY8+/uzde+Qb/7O/815J0zqpF1vzw57/AjTffIoSGT33+xxhurZNnuQShJhORqEBjmJ0d0esPOPYWvbFGL4dCP4b8wHlekGi+5OQRPrQi0wbb6VE1wi8WlX26qceI1QqPpyw02th0s0+4fZSmb9TtsPbMi+ebRm40zuY8+/EfxSiLzUqyvEdeZJK9VJT0Ox1UFJOCyjmUn2G0xdOIfkaLhqdqa7xrKYouWqUMpscaqe8NYQ1E2qZGYbC5OUdgdRoksPptJSeyHA4ZRsg59b1IWXL//BA9+wBXhET5ddGhgsapiHaeK/aUT/cOeX5wynZP9oaoDHmuoZXi3hpLHlueyfbZntRcrmt+o3uReVBgLAE4MqtpZMQG0M5TuAVPu2Ne0re4Yu/Tt5UUyjFgtSazFussRlU8oY7IG411hlftJSoArbAh0AZNtBqlFT4oThuPdg17bszz5j5X9C3W9BiCo3KKPMp15qLsrcPyhI8FT+UdD91O2otFNxZDwLeOuLoxRtFQKRXFuVKt4i4Mvm0keD1qvBaLfK0MUSvRsynItRVczHlq3+Ai1FpcWX0INK5BmZUiFAxaNBlaNLKEANGjUnitdyHlsYljplUGlyiSMSTEK2XW+BgI6T7iogSK6qhTgH2UzEUFrW8li8c7at/gnUf5QGasIHQkZ0clTobWWDwtXkXa82YyEZZSRElMDogRaHwrAwEFbWiluex1+KEf+jRvvfk2B49OaaioZmPms0MGvav08lzo+aHFIQY2SmkJ1I6Kxnl8KvY2t9d58cWP8PIffZv5bMbB/bsErxltrxGZSyZodLi2Ept/nVOYgkyplCkZycnl2CNMC2MMKgYCFuebdOfWRP/hkOmDXGcnx0QkxuHRw0cyuPASwFvkBcvFgjzPmc5nTMZnbG5ssba+gdGWumkw2rC2tsGFvUsURZdV0b16DtGkSRhyiIEsy2jqmtYl63kt9/2qrqnrislE6iXvPZnN6PX7dJou/cGATlkSfGBza4vT0yOOj/dR2rC5sUOv26fb6cnvdPtoo5lMxwQf2VjfFGMgo+n1unQ6pThCnhfoYjwxmbRMxjPKoky0Rhm6tE0r+4sX05M8F+MH5xwhevr9Pm+//Q7/+B//Gjdv3iLGwOVLF+iUBYtKBuPraxti2qXEeARKWhfECK2tuLyZU5ZDTs/mLJrAZNnSVA3BKHRu8HEV+GyoXY1XSNyICugg/xaNl+d0MdVH6n1Wkkr1m0ooV1xxB+K57iyEIAZmSurAbqmoqobpvKVpI0ZDnpsUC7KKcVrVb5EsuRzGEIlajqtvxY4+M4Ef7WT8/tLRxHg+3A8hULeRee1wSZcs71ORJ2Q2IqidzTJxwQwN1hR4H6nqSvbhlKFmkv6+dYKASq6a5NopLUwEAX4E+aqWNf/wH/wTUD6xMDIi4vTd6UgmmmkdwTlhAxrDy9/6Nl/6whfolYVQ0GU2i0msKBUlKkBpJVmTPp4jsG3b0u99/2yBH0xzplZUq1V/qNJEc4VqnTft5/1jSAW1FjzzHDV4H/+QunV1Q4fk/LSajyrRl8lzJgtMJTdMo62U6iHSBvAxCQhVBGUwpvs+QpFQitX7WyWWW12I040PtDGgUxiqFA1CRXSukteMwtuez8649cZXKKmZtw0Hh484nR+wvX6Rs5NHnB09pHf7BnvXPsnLr3yVotiBZsrzL36c/ZOa/toG3U4fW3TQJmdt0CNXnraZsWgtp9HAYJtu1merGPFovOTkdM746A65LTAmZ1kt6PfWuHXnNlneodMZUM1mhCzD5zk2E+0F6bvR2qB0S2YtDx/d5+/9N/858/H4XFi/+s7u3LnJfDnj0oUd9q5eTyGvDsPq4vTE4JmdHWG1RseWTraFBjItJ4CPq2Bl4eSGKD+Xucd3C0cBEY6uGpPH0CmjoFN2aBqN85HMkjabVYP3GBUwNf0oTa/TpdfpnJ+zjw8zFIoiyzCpYXLOs1xOqJspB8cP6XQ22N2+Toia2eKU+fSIYX+XTm+DEBRaJ3Q3uXik2g0fPL5dcnx0n253m+H65rn2sA2eLInrUWDSxrpCHHyCyY1Oz7t621Hx2ODsw/UBLGssbZTzM7hAVB6tcq4VEz5XHPDR4QnrHQkzjckYRp0j+DppgDx9P+f6yR0+eviIbOuz/NOty0yUxkSASHBgELp311c81TzgRXOHq/kDSlvjXEBbRYwZrWuJRvZFoxS5CexlB3w6RKq25R1zmUrneCVFes/AbldML+6FyLAe84lwk49md9kxY4wXV8qAx1kJOFZGEZTY4691JnyC2wyrBSU94durFEic9mSlFdFkREqc9rK/RoWhRbUBlBQ7KshxNFqDlQJJI1lhOqSMMt/gvKfygvKrRFFxiD7MPuaqi1JEDS4NbWzi9wSiODU6KSRXdu8x6dVEUyBURBVSexRVeh4JdzUq7ZsoCAqP6BtmbSUmCKFFxUgWxJCDIDf5eI7MKeQLDrjgCa4RNCAGEfynfTcglKEYhNHQqiY1jrLHWJMz2Bzxsc98nOODYx7ef0CMkd3dHTqdTtJaWAqjwMlnU0bjY6T1njZIuO1K9L++vckPffGzvP6d18jzjM4o0FkLRBVQEUJ0tKGhickxM2n4XEwGBEqJoUIEgqLUGU5J4VLmcsyCaxP74MP1Qa033vo2MUBmLNtbO1y6eo21tXWKoqR1ThDWLMPkBYPBkF6vR1l0xMlTCYWNkEw3jFD05TqxCVXQjM9ET9bpdomB5Jxozu/xi8US7x3WWvK8ZJAMOpwX+vSlS1fJ8zzpRQ1t61gbbbG+toUPkSIvKTsFuc1RyhCjZzw+pWlqdna2UcrS7UpBrJLeSeqNpIuKgvBnWcHuzi51U1FXornL8gyjDYvFPJlOBNlfW6GzPXr0iF/91X/ErVs3ODsbo7UhyyxFUdDr9Vksj1FKsTEanjt7jyczjDXUdc1svqQwLc1Ghxvv7nM8njFbOqpGmorT2VyiKGKgCRGcg6jItJW9KRiCWRlwIKygVLesonZW1UJMCDkxaVrjSrG2MiOD5bKi0+lw/2hGrzRkJsOHCmWk5j6b1VRtSGiSwRtN3bhzcGQFaqgYxYwEcI0ni4pbraMJKeLoMb+GxnusNhSZprCGmPYlY6WGKzJx0I4h0uv1klunxdqMgKV1LtXr+hwNiz4QvdTsYuyizmupGMR3ghj5nd/9Cu/dvkGnzCiy7NybYoWI2SzDZi1JjwPA2ckZv/5P/zl/5Rd+IR1ZxF00OBlCIPe6VUxDhOQOKse/+qA0Zx2N8F/Tl71CyVYnQkj5TOd6r5iQLlY+WPIrWr1fLa/+pJPWy4X36+mVqNxDss5UWEhiydS+pYvCuQaQg7YKjhUDqfdvECG8n0MWYxT6XUJc8J755JSoAtP9m+S9Dp3eJoGG5eF9ZtNDdq49x+T0iEcP32V2eMbZ5Ji99XWZooQ1zsYnLJslRydL5rcPqf/oTQ4XU7LMMCi7fOe9WxRmg2/+wa+zvbvDRz7+Wa5df5GdCxcY9XrMp6fEbAunu3KxaYv+/7D3Z8+WZNl5J/Zbe3D3M9w5pozMrMwasipRqEIViyBAACTQAGd1U2yITVFtarZJRhOlhzaZyfQokx4k/QGi6Ul6afZLs1uSGZu0JkgNJEEMhanmecg5MzLmuNMZ3H1Pelj7nHsjKwtA0qpR1oa7zCJuxD2THx+2r7W+b32fn/DJz/08u0cvsF6ec/tDL9C1HXfv3uU3//WvsTw54fT4PuO44uT8CbPJnCaOOOdpuonOXQBhWBLHgdOzM/7Jf/l/5+3vfaceO5VF3UiRPrxzh7ZtefEjP8HetZtKEeqoEtTaNUthRCTRTBpmOwe03VQ7p9nUQj2DXKBMZSMFW2k/m3mUjdCGdkS2eLmeE7IB4QvO6UzD5ozZ+GFsOM65QMiF1lZZ/A2EL6XKPm+k9XW8bMs+rEaNk+6IlM7Y37WkbIkFnjx6m853PHvjkxhntso+MWmildJAjpmu7YCEyYHl+V3CsOC1d97ixnMfY//aM5QsrIcVUjKN7+i6CcUqj3pz7m4oIFsNyYosRgpjyMzbqyTnxxWtVZrgpr/jUsG2hQ91iY/N1xw2ay0GkqMw6qxObYbkHAklU1KEYeToyR2efedNfnE85GuTXV6Z72xvTKGA5ISncMCaF+wxL7R32WlUvTCmDKUh5ojJugYrkqFFg7GZ6819Ptm3nMVd7jYHjGo4BcZwJIVdC0fTwG455+XhLjfdA0wRUlC6RkyBlD2NKCXPWpXGzxZudUs6a7HOYIqj8kfIhjpLKuB38K5T7zCrw9lxHPHlPjHfhTzWruyGVZFUidUKyTiMSUAh1mKslKRd46xJQSJrwYlTsR8R6lSazgIYS4wjvhojFzJjHim5qLiIVB2vSx3EWBKQVE4/A6gxdi6RhFL1wGsxiDCkkT6u1GNINGm12VxKXtUMe9u1KZUwWVSdrBQh5MgQBjIJb1sMF76aIob6BioXImoGngtYL1x7Zp/rt4/wpsXZKn4kfnt/dRjGFJXu7qrJbEmENCoqmEakCHu7c/7cz/0MQ+o16UHV4XS+MmOwNCXjxGDIxDQQRdUyfZ1RcVRFtjrjkXNUeiUdo2S1DbmKH1t8/KVPMZl0zGY73Lr1LGKMzm0KiBmJMZKGROM8OC1KwhBYLZeKUhshhqhiZmQmkynz+S5d11WJ+Ja9PViulqzWC05P1ZT37PyMvqoszmbzShfsaJpOUTOfGfoVjfe0jRZrKUaGnBFrSTlWRpLBJkPJSks2ovP6k8mE+XyH5XLB8cl9ZrM5MSn1zVm/FQ2xVgsplT9Xo/fGt7RNx9npCavVkhQj/TAApSIxcPzkhM9//nf49re/Q86JZ599hnEc6fuRvd1djJG6D2B/b1cVIYOqwi7Xa3LOPD4+5vjJCZ99+Rm++Z3HrII2abrO0XrhfJ0YQibnkRCSzn/uTXCxcJQSbxW7aTcrGp+V7piSooSlFKVWbxrrm4GzS/Fewk1OmfV6jXOOMeo1veFM5ay5sDXQeNUG0KZMFVwqF6icZCFVtLTkwjPe1zleLQRj1P1orCrSllZR1VQ2k8oJa1tm08lFnZAyVgxt0zAOC6zfoSS1UokpbJG4zWhLjJHTszPms6nSDJmw8QJdrge++KXv8Du//3u8e/cezjsmrWc66ZjNplhj1Ky6ZKxYQk7V3irTDwO//wdfYD7f5ZOf/BTXDvaZzyekXCgxEYLaR2wK0JTVZ20c9XoqG5TqA8SPpDhLpVRUSyptUXe1EYVeN8VXrgjZBs1wUhP2ilhpd6Ns30cP0KbXXD1WEOIWjdM3FJRHq5+hhEOlS0LjPal6UW1PyjpHdhmo2QxOysZGs0qnF+PYObhODInz8ja/9S//Cct0Stt1TN2Eg4NDTk8esre/DyFwuG9oJztMpjMYB/LZipIi79w74Z2TJawNNgeeLJasc2Hs7xC++i12u0OOj0/4/pv3+e3f/TJH16/xc7/0y3z6c3+Z/aNrOApGenLJrFaamHXzHV7+qU9WmXWlFB7dusFLL79EGAfu33vIvbtvszh9guRIbDpc04GICoJQKNkQYuLX/pv/kte/81Utoo2F4ghp1GTPWkIpTK3h2Rc/hlhhvV5q4uAsOQXt4APd7nX2dg84Othhb2bpvNnOlBUuLuYN1B7KZhpND0asfhTWmNqtLdvjVGridEH50wRNNgZJm65QLW5CyvQh0Uw2kK6eO32/QkphNpnroHLWYt5uEidqEuomHOx326ZDoTC98UKlqen2G6lc+TiQi2E19gyrJYYjYl5AWPDo0X0a4zg83Gd5/ISwPiWkwht37vLq17/Ez/z8r/CTn/nz6sVkNoif0DWTep6jaF6mqhtdURp/7GFcFVkwYNUiI5bMYzPnibnFbgk06ZSQViAXC62pVLmYAzFH7Lonj5ZT9wzH0hJzYlZgJOkMbEVTXVRvlWDnBLNP5hGmTsmmHAGLr7ORKpxhMUZZA8HMQSb4NGBCoHGeXAx9greGzDUrhAw7boplF5MfQuxJMdPnURuIVnA4rFiK2NoYE8ROaMwO3rU4W1TUCbUSMNTB8wyJgvMFbw0JyFJ0zary7DGlSnUUUkWMQo6YlEgCqWRCjBSzKchqp1IsDkWFYkWajTFIiTR4bDFEU0CUImiLI+ZIyJGYCo1NzBqHEQ+ukKvKXJGNRxj1xmBIRZMVJTeq+9koA6ZYTBZa0xCrTHPjGhrT4I12hInVksNox1vXLE18UhygllHGqDw/GLzR2Q+t5TI5JVwupCLbOR1jIWdPFi00N0ySVDJ9HDESq1pa9Z+LkaEiiLnkOrunAiolJzIBkVznyVSaPKWREEZEnCKZYpEiuLxpdCn6GdF7sgoNWHJQ3zNxSlktJatdQI5/ElfoVfyQePjgHpNuynq358HD++SkxU0II4vFAmfVFH1nZ4eh70lhZDLRmSwExnEEEUIqtE3L2ekT3h5Gdnf36LoJxlq6bkqI6ns4m810ZqtVr9rVasXe7j7rdV8VWqn5WKbrJlVpsWc2m2OMwTnLo8ePyKkw6eZQVAVSajNgI/awKSS9b7h54xZipFImA65ttyjPOA5473HOVc+yJU+ePGIMA846hqFnvjNnPt9hOpmxWC75tV/7NT7/+d+h73tyKUy7jknXcevmDfp+oG081qin19HRIbs7OxUJTKyGgdOzc05PT8k5s7u7w+HMcHTruqJTIXH/ZMWb757y6GRJyZnWWcYQKRiue8uLOfKFPpKsYyMFn4t6cqVsMRamrQqrLCuLyVgHURtbG3sRjYvcQdiMFWnjyxhVDBfUW9VIwViryFd9jt0YQ18KNaCuSVFRlHIqhbdj2eZ8OevISCPKOoiVTllKoW083nbkorPBvlE9g1QK62HAGcM4jBQZtxoTUmmNueZvH3vpJUIKvPbm66qGmTM78znPPPMM52cLPv87f8Cjk3O9j+TEej0wDJbzxQIeaY7YNIrY+abR5kCqo06lsFos+De/8dt8//X7kAO/+rf+Os/cvEao9x1yJqe8VTiPQZEzY+TfKV/7kRRnsUAjirQkzJZ+qNIJZcNP3O7UjZN4LjoOsIElnakYwcbJs0YuqgKWLqYOtxc1sC3QMrJV6drMIlkjuDp4TblQE8t1tocNildpjzkLgUzjLFKLxpwjxcCNj32KT2N5/Rv/b4y37LQT5rMdEMP9h/fYP7iBt7eRIUFZsTx/k2mzyxe/8W1Onwyk04GYEjvzlms7O5yve4LxHJ8dQxi5trdH8cKq73n44AG/9a/+BSITPvVnf4mdPY9tHGHUGRbrGsiR88WK2XwH8V7pcXUQXZzh+s0bFIH7d+8Ahkf378C4Yu/aM8z3j0jVdO9rX/w8r33jC9XkWCWbx2HAGsOknakSY0okYLq/TxxHlmcrVouebtoqnZBC1xhmu1MOdzv2556JkwtEiopoVUS1gEpPF7aQlQDeqlnfRmq7bBHOTeF1GV2zVeGNbVG2eW0BvBMVO+HyawrWatKUS9GuhmhBrnSbDZXyoqlAnXXTBeFiqDUDZ+fnpDjguz2VVi2Gnb05zhl8OSDIlP2jKXvzfbJJvPXq1/jGF36Tz/3c3+GFF6Z854uf595bb/Cpz/wMpmzm77TXLiIkhDGpbWuMCV8Xxk0xexU/nshoC9BWCfgkjiyOtwJ8OdxAnPCCeR0np5QUyQSsKGrkRaWffbJk4K35p/hu8yL/r+sf5d2uw5XARCAAY7WfcBSGJLzKAa19kY874YAHdaZLFcZyjmQMxVr12MKwKDu8kW/xLXOLe3KgtLkYsM4QovCoLxwXLUYel10KH+VzrnCUXiWVBWNWEYpWBKmGyaai2GOe8DhcYymH3PRTxC6hrBXZlmpVkTPj2BPSGTaMtK0hp8h6WBHjisaA4DDWVvNlUVVT9JJLRbuXxUglO6hvYKkKXE4EhyU69d3KRYU5vDi9nkD3f8mMxdAItTCpiUdF8nV2wpKMU5qlVL80CllUOlrvZbYi2YlEIAYdHvfGM7GeUHQurhAAW5kHBdsYSt7IahSsqwqvG2ERMeSScBhsERoKjdHP3MymhqSiIjkFpTYbg6vzEkYKhsRmhhUq8ipaqJOVojqmAcmbeTwVXDFi8FaIMtbvDsYBIqRYRW9KRiRo2ViVcVNOW7EtMRDpiTHQS67+SU5n7orO3JETMQzb+8xV/HjixY98jLbtKgKiVLp+UKR0OtthuTzn+PFjVsslq/WSxeKMNA5MJx37uzu0k46QCmeLFV3bsTOf4ZuGflgzjAMpJXbmu0xnc7pJx97eHkb0uhrDyO7OXhVWiKxWkRzz9tp3vq0qkZb1es2km5CNVLl8A1LUwNg5clSFvFzFH2KMDOOIc5ZJ22HEcP2oYz2sCCHgXEPXtFivRVnf96zWS87OTkgp0viG09MTpM4JPXz4kD/4/S/w2quvcefOXSaTjp2dOefni+3MvDGGyaQlJ51TA6XUrfuelCLL5Yonx8f0w8B8NsN7h7PC0f6E1Wpg3atHpJTCtYMpJ8uRD91o6PtMyDCMET+MfGldWBZoc66zwyq0hOg6Mmsd3hnWg87teqkN76y07AsELW+ZRZtkWiqwYY3QeVMn3fW6VuGzi/l4U0EPYy5Ez/SdZMtcoxSsFPbE8F2daq35k6rhplSwVhjHxKofmbQeXz3PTLGKsDFWj0alIiaxrMfIsDhhox2R0cZfO2n57Oc+w2d/6jOkmFmuV6oeGiP2keX1t9/iwbv3WJ6fkSk4Rq4d7bNYLoghMcawVVRfrfutPctG2n9T2HrvObgWuXfnNQyZ5XqJcB3nW5zL21GgOA6kUhQYKomccmWifbD4kRRnUlLlrheKMaoCWMDbQsiqmGiLqixS1JS4DzrDZcVURM0w1kralLJFwwoKW2IMGwuqVPSk0aammjgbZyqCV6ppcqT1jo1Z8Mb/JlWlGZ0rAy0iZXMKkUribHGMKYGpVT+qIbb048hrX/1t+uVDjp59hr2953n9+78LnWV9dsbNG8/y3Kf+Ckc7hyCWNI7cvfMGr3/7q3z6xTXX9g/olwP3Hj/md77yGjePbhBDwZjC/s4u5+cjY3+O2MLezpyZP8S1DffefZXDWy9S3n2da4e3wE7oZnNySjx89w2lw916nsl8l43seyqCMQ7XFI6ODtiZT+mHEe8cw3rJet2Teczi9DHf+8YX+OLv/Nta9FElQQMhjRzsHTIMPS+99DKvfO97GNNy/847TGdzmq7DWUMYqvmrWFzTMO8sBzNHa+uMXq0hNgpdW4PYSl3cUEl/4Jy6qOgUEbvceZDtX+8B7C+esPn9RgxG6j8sMPF+i8Kpkg5bVbRN0rdJzDafvXWlZ4Ow6jZ739I6T7EX1F3fOEyJ2ALLeMw4BpApzjTceP4nefT4lMlsl5uHR/z9/+z/wLpfE3NgWK0wRphMppSSGYNeU2OMIB5rHN7WbX2ffXYVf3KRc8Z6oxwNY0jeE8Uzkvn22uLsLaYT4Zq8gSkPdd3LhVwCE6eUmnPrec3d4O7eNX7dP8urfkrIgkmwI4UpGSfCWCCYQiqGMXUkbhIx/ORE2Jf7WFQNKlMYpSA5UIplmfZ4fbjFV9MzvMYhwWrBJKXQphEvDcOgCbwR4bE0fM3coC2FTxOZyvcoMlCcILaSkXMhG8MQWx4NB3xnOILZEc9OBGt6+qDjVFIKUj1fpAgxCdFVRUQipgQa4zFWi48+BmUvGPXRMrnR5hEFU0XBrGkwGGwpYAJZLvz+HDrHXESH1xvTkEctykJUahMGspXadQYvTv1oSOoLZJQxATorpiaukRwLBfXq2ZgwFxJjGghx1OTRGTWbRpGmWAqRRBBVpLPGYkvB2haIqqQoVq1f0I5rJNUkJhOKRWKEJFUAqxBzoU9rhjgoddN6mqI3flMyAU3ErG3xVueuhxjUG08sRoTIoFShrGifwdG1UwSDM43Sy0ma9eRCIw3Z1XtmLWZLVS2KZJx4tRvIiViyGnznSI5BjaidY1qU7pZzJKe0FSa4ih9PeN/Qth1d122FHabTGc55YgxQhNVzS7773W+xfPKIYQyEEBlzz3rM7O8bnn/hRX7qcx+i8WogHGKdj67iYtYIk3ZKN5mwXK+R0msTwmibdbk4Zblcsjw/p+sabt9+jqabsVicslicMZ/v0DQti9VSqW8JvDXs7ezjmobj48dMuwm5ZO7ef5f1as3h4RG7u3uA1MYBqsY6BpxTv7J1v2b5ZMFkMkFEmM+m7O3uaeM+Z5659Sz9MPC7v/u7/PN//s85fvKYDz3/LB958UMUijb/66ycEUWcrVUaecyFENOWyrZareiHjbKpZbXu8dFz62iP5XLkbLEipcKyj5wtRwThY8/uc3a+ZgiZW6bwoBRe6zNjThjJ9EWbL6Wi6caqYIe1hpAKQ6i8MVHRFZ2f3VxvT4Memxwi12LJ6MC9Nqwq0r5pPiq6qY8L4J2tx1zzuY1ZQSla7OVYWJdcx1XK9lM3n7nJAZfrkRAz/RjV67fOnNloaCtNMMZICBHEqHVKLYwLWjB98idf5sb1a7x79w6wYV+p76RrPN55NsKBpgjGO2bXDsmH+8ScWCxXrIdBFSCHkWFQ8SVbBaSMVVuFybRjtTjHe0/bNsSkxaaVeuxDzcuKqQwQlKVnYKyMjA8SP5Li7J/9P/8xz37kBX7i5U/TeE/Ter0whsDp6bvMd/exdg9jClbUeTymTGOt0hdlyynUYeWaINtKR7ygemlYqdQNNqCLMKZSUTKr8DuoSEN9jbDZWZqwmw0FcnPeGvUtcsYwbWesFqes+sjZ8TuEVc9XvvpNdtsCMrB+5R57nxCevXWTcUj0xXP43Gc52Lm2cd/DNQ23X3yJnNf4cp9u2vDWu+/Qnjb85EsfZiyZrhOMN4QxkFlyvd0F51kPI7M2Y9qO+29+j+HsEcXOufnsCxwfP+L6zefx1rN6cpd294D1MLJ3eB1EaKzHeo9vJ+QUGddnqixWMovTEx7ee41nnv0oJSUms0NOjlfkqFKmOhhuWSzOMCKs1itSGvjiH/wuzgqz60oVWJyfs7r3Fqc7d5nNd+m6KdePruNK5nAOZXzIeR8ppmXS7dA0E4xVNEhTj1LNnf/ouIyIPf1A/d0PudFvi7lL69FWtKbUYVrRJkApKlCy8TMLVc7bmo3cP8otrtsu6P+HMELJNF7niXIcUVNeoeAQq1K0aVwicptShFk34dnnX6CbTjACs0nLpGs4X61ZLdfEsefeeI91v2JvZ4+9vX0oBusdXeOqTH+5Ks5+zJHV3IWcwUlmRmZttDmyjJlvLBpsvs6nu8Qtelw8J0kiRkgpIGaP++M+X0nX+d3pDe7nDpN0HcwJDoZzPrM65lE35zu7h6zFEqwnY3hYLCbdpo0Nn/CWudzHSVHWQg7k7FiXfd4Kt/lqusFraZ8kBZGEKx6TB/bLCovwyO0QisfmTBbDWbF8sRyR+Sgv+8RO832sydq1JkE2nMeOB8N1Xgu3+Eq4xp9tp1zbhUYy43pFykqDrGL3lQmhN81gCzENKuONXltRstL9spaYMWeqvlZt4BQa8VqYialecYYxJWIOBHJt2un61YhT0Q2jss4jCYPBFS12ydAap0bwkgk5EdJaj0/RGRGfvc59Fe10p9qQseK0oYgQS9AVrWjnX3Ihi85ylaSCPkMcEFFGwEwmSIw4U3Cpzl4UFPkruo2xjMQUiBjCtrGYuLCU1c64q9TClNRCYIiKWDhjlPqYdd5jDIPKgbsWZxoa2xJNIsaRMQYsnhgjbdPincOLChWl7UonlKjrobcOAWKOZJPoxyUue6TSUgsFLxZfDAlDKZFSPAlVt5RcqZtXjOwfa1y7dl2VUlNkHAceP35MSiO7O7u03YTpdE5IiU9+8qf40IdexBhhXudg5dJ99/HjJ6QYWK0W9P2gVjdts1WjNaLqd9PZnFIKk25K27YM45ph6Ckl0XQt62Hg+OSEw8OG/cPrdE3Hcrng5PSYR48ecvzkmH69Io4Dzz//Ap/57Oc4OrzGcrVkuVogCIeHhzSNZxzXjMNITFocFXTdOTq8xnpdRyyMY7lcEmNkPp9jzKh+WMDXvv41fu1f/EvefPNNRIRJ19A4T+MdY7XiuHXzhvouFhBjGaNSrldLLcbGcaDxjrb1NE2j9MSiM0iFwmzqWKx6FquAM5b9Wcv1/SknZz13Hy04WSmSM8RET8GlxMQ6bGNZ9UNNfar4WdYCMQqMVVbcO0tOufr7VjbRNhHaoNaXmuJGm+SmFjx6fV4gbHIpf9r8v23qNV8usZXKJrcCJ/AgaaFSSqjbK1t6o4jmMMOoZs9jiDgxWCc03uM8+rrKlBQRppMZxup8V8qZmDLOO5paKKWi3pXOX7ClYhW48V7ZX7IRYENV2r0I1/b3t0VlCEHZJSKsa6G2M5+TS+HkdMF6GEhJGIMwjCPDMCjwULKqXC5WvP3OO7zx5lt8+5tf48nJCTEomvtB40dSnP3ir/xNHpyeMt/ZU0PqGsU6kF2s28F7qY41grXQeN1YveCrMiDlgkqYCudrNa2cT1s9mGzQi1pd14MmZjMbQKWEaVUeQqFxGxXHC3PrDWpS2Px/w33V7rCbztiZzcgFDm+/RMmFD3/ml+n7njj0LJ7cZ9JZ2uku4nUo9fDohqrqoZ1i7eoWxO/x3TceMW0Tvt3lmWevkdKrnJ6vObhxixVTlg/v8PztOWerBSRI1jGUzH4zw9iG83WiaUce3HuHd15/m7defYtnbr/I3be/z9Gt5yntEQ/uvc356X3C4pzdgwNuPP8JwtgTVqc429DHwpd/799w+5kP0XQdt557EbLh53/lb5Fi4J3Xv0bGM5vv8O47b2OdwxpPSoFJ1xFDYLE85Ztf/wPkG5ZH997h9o1dTpcLXn75J/iVX/kbrPKU3/m3X+bDH3qBd+89BDfnhedu8eGXfxpSqsPtrh5DlVbd0HwuuM9Px4WPhR7cXJOkfElC9f1iW5PJpW4N5aIYL3lLDdxYM4iUagfwXlRuI0srW2qsNYbWN5ydn/Lw4Rvs7ezibYu4GUMsNF7PyaNrLyBJKXClRLy3PP/Cy/V9oE8DaUycL485fnCXo8Pb7F87YhZ6Sgjce3CH2fwGB92M1pq6qFULgqv4sUVOiZTWlDGzHyMHZk4oOwQMBcf5CF+kZVVu8ueawHW+jy9PGHPiLO1xlnZ4ZbjG78Vr3Geia1aO2JJ4ZrXkV+++yr/35Hv0zS7/1Yuf4zevPUNvLYmMFMPD7PhaukW28JJJ7HGPYjPQcFb2uDPc4hvpOq+nHXoyvlicGFxe8Zyc8gl7D0PhO+k53pSbtDZXSp7lJFm+aq4jtvBJKxzIG0iKRALrMuF+OOKb8Vm+GW6wLI5VFLLV5N04R46KsAiKFlIiwpqYF6yiKMuiJKXv2aY+R5EsRIioMXSpc7QbxbMCYAxOXKXGD0hODCXQ18H/1jdKDcSQRJFNm7wWM1kg6ayYq/cNlTRQRcKYEiFnhjQSTGZiHN44HAZ/6R5jKmVIrMN4T2Msrop3pJiqWrDK8W+QSsmGbJJSOFP9nahSZshqQ2KLcGFyr+pmsSTWeaQUtfIw1qiHVPWASzkSx2oDUNBGZehJKRALlDoHkcg0E1E/n5TIYhiBMaxojEVyIY5qvo1AJDGEASOGMWniUkS910qBMUaMccQCMfakLFiUHumMo7WdooJ5JMdAFFvvy07VAK7ixxYbtoiIpWkb5jtzdmY7eN/gnK/CaQnnGg729kEKq1Wv9FxrePjowdbXVESYzeccHBwync6IURNa5x2pWknEMDKdzmiahslkxnQ6Y3/vkPV6iTGG9bpn6Htef+N1zs/PWa961qsFYxxJOWvjKQSg8J1vnfL9732X555/gQ+9+CKHR4cYa1meL6pH2ULv+VQxIhHatuHhw3s8OT7Be8d0MuHatevMZjNOT08pJfOtb32LL33py5yeHLNcrnDO4pzj6Oiw0in12sk5kUMkVbZBP44sV2sWiwXjqAqwOzs7HO7vEUJgtV4TYqRpGlWTdY6PPLPHzUNdK84Wke+/ecyb95+wXPXqI5gLKoqkdEMROGws53U8SN6DgEnNSwzQeLNlidnL1MN8uY+94QDVXKoUStExDxFtSiulvGwLwe37QF2LFB1S5LAKlGxebw1tpY1n8tOvv1SgbfJ8PFv0jQxDiLpNrmCqyXnXdiqyVkZlAMSEtTq+VDI0badqj8ZgRbR4FhUCdN5v0bcCWLfRPlDBK2tNbWx5rPOQEjFGpm1D6yzWwDiqQMxm37Zty9HBISlkHj5+xGuvvc53v/c9npw8YRwHwjgQxjUHe3POlyvCMH7w6/QDv+J9Ynd/hun8Rkthm1BbZ7h+7QAFYmX7+y2t7VIyvoFMraiBZbHQOeXUKvtQ6ZBKM6vm0peT6IqmVQAOpNC4+pk8naxf+FDVhH97ouc6T6Qn21Y90gpYT9M6Spmxf+0QuKDUFLQDugwwpKRqrUVnBJqDW/z83/j7PHjnFZbf/R7v3n+A2f8I8x3L8ZMnvP3m25yfvEPTWpCGe/fuqUfGret08xl/5s/8AscnT2jaOe+++wYHhzOs28P5KVjh0d03eP3Vb/JTf+bnOXv4OsfHj3C+Yfmv/jnTrkVMBizGOUyxnBxPWC7PWC5Pcd6zc+D5D/72f8S3vv5hXnvlGyzPjnHe8j/82/9zbr/wEv/1f/EPkbxkvdYhztP7d9nZ6TjcaXj44AldK8QHd3j7a7/OM7/yq7z19hnfffg7nMaGZ29d4803ljw4foIYy0uf+DR7u4e0zQQMlMpBVvL2+7dTc51P2B7HWpBvOM+6/zfFl45cbOmuW0qlvOecK/W8uniPC+n9i0XovY9xCZ5XXrWwu7PHtJvpYL1osjcMAylG2rbDWx3W1Zkxwzgqt15vdA4plvPlA9bH98lhxHrHxHuIa06Wp5wvwHuVux5zorFVue0KOfuxhsuJVerxpfDh6UC/gj9IjjOZQIIowpAsr4cZxnyInyiRa3lBxnE/P8sr4Vm+E484Dg1elO7nUubFxTG/evdV/tq9P+CZ8BrSTNl9bcDyF/hXR9eIYkmSwBjuRUuSGxQPn3AwK084jQe8Mt7m2+kGd+KcnDJGIJmCy4lnyzGfau7ysckDGrNkpz+nJMeJPcQZo7SdLDzJDV/lBq5EPukDO7zNOnhOyg2+P97i2+kG5zRIKazGkfO10DaasDuvdiaQVcE1r2jtSJHMkDcIi3p9OWuRbDAlYVBEKBalvol1eOPVaygHUolIAe+0MEGUPp/LxhEQvKg6YiwqJIK1tKLFhymClIIVi1HqBGIbyJmYY0XyEiXr60fRrqgzDkNVRyuJLHlrQNq6Kd5aSNrAaZzFoCIezjUquV+0cDElk2IikDT5TYJsZkg3yilYMB4jOt+ns9yZkDMZwYoWPirOYhiK4KwKrOSsa0suuQ7TK71MpdEbvO1qYysTYyAbsI3HoCbVRQpFGkApmt5okW2lkI2uqSo6YpiIVy6K9YxZ0T6DoTEtje9wxuIEhhwYN+axlY5dytXM2Y8zlPJmKUXV6UqGdd8zjKqqOIaBYRiIMdJ4zzj2nJ2f0jQd89kOXTdhPt3h8fFjlufnGDGcr09pfct8vsv+vldPwnFkuTinX6/omgn9sGKxPGd3dx9nHY8ePuJ73/8e65U24XNJ1YaD2pCRqqis9DVvbUWfMo8e3uHu3XcxruXGzevs7k44X5zjnFflSRLGeCbTOQf7R1y/dpOd3Se8c+dtnhw/Zjqb0Q89r37/Fb717W/z+muvM5/N2J3P2ZnPuHP3Hof7+xzs7anqX6mmwiJY7wkx0a/XnJ2fs1qtaBrPwYGabR/u7zObTkk5qQqi1blOMRbvPbduzDk/O+e7rz/mjQcLhjEyhkgUw7WdCa0pvPHobMsassZwvbEMgB0CqRht7kAV4RCkquPmcqGnoGnVJmPRNWaTR1EfVyeRavOB3Z4gBrVMucjXNQ/S+VgqQudIKZCqp9omL3PWkKTwOFR7oU1eLrLNWzZIm1S/Sl+VJvVP9UurxakxjqPDa1BVLGQMGKPrW0F49PAxN2/fruuoEDFVOK3AEChlzdliSaredkaU9morEyOmREiZkFSJNFVrgqpVyDCOatqNNidyzpwvTvm1f/bf8uTRCX3omXQtxhTGoSeGhHNCioZhVEVJ33Uf+Dr90QiCZMFVConxVI6tHpRNEi3bYoinCrMLZOQiNsXTpPNb9UbN4XOFXe32pNsY6V18yMbboVSVK50j2JyoF4OR2lXRhFs2H6HQbB0I3J5Mm++ConwoM2bLfRURhlQ464XzFYwh4a0QYma5Hsl5jrn5WT5x47N8JBaotJUUe9JYOD95wnp5jnGGd954k3t336VfnjDbnTHZeZYkO9x59eukMdLaCc9+5CWSsayXuyoB/SDx7W99AVdGZvMd4jgynzXEOJLGxDBmppMG61tOHrzOb/6z7/PMiy9xdPt5Dg9vsTpb4iTw/K0j3hgyH/34NVb9E9bDE6azKafH5+xdv4ZPmT//0z/J733hq0w6R4wjH75xnV/8+V/g8fFDYhRe/qmf4/f+5X/OneMFPr/Ew/Nz3nzzPj/x6Q9TxjM++tJnOLr5Ye1QSKFUfvMGkdpcvO+rbrOp4Wp9dYGIbRBYtsdNkG1x9oPv9/R7/3GVdERUV/JywW8yuNYrR7sKyhjptm0DbVpp+dh6X7tUmWHsycXw+PwOT47vMykNH//4x7G+YQw9Ipl2dsgLN6+zDGtO1okZwswbOlfe+xWu4k86snbXGmPY9z2fmg7EteVr+QWOXUvKQpTCkxFO04yH8iyfFEsnK17N1/luvMV5qrw2Eq5EPnp+wq/e/x5/+f4XuT18D2GAsOSF5Zf4B296cvkZ/r9H1+mrRHoumUej45v5GoJw3T7gUZjx3fgMb+Qd9PYTMSQ8wu1yysvmLi/4d9ltlkgeecG/yxgs3xw/wd3mEEsmFR3EfjJavmpvIjnyYWsZi+WNcptvlxssk8NZTQ6EjClGDT2txdQ1Vq+RgskDnYt4N2UsG18zoZMG13hACDGokpfxlJIw2Grw7OlDTw6ZUKpoT8mbJRlrDF1pdHatGo5ahJjVrGWjFJuLzouAKkaK0bmxUnQemmK0uMmKciEqNpDiSKgehurxpgmBNTrELlY76NYZlU+uCYYBGuvomglNOyWOPSH2LFgRsloZWKeInpXCKOqP5kW3RYrQ4PBuQuemhBxVYAWdE/NVlbMVR7EJXzqGNKgFgVgyCVsl79tmQuOmeNeqH2XpFa0U7TwbcTjbIUUoou9bcsTZhga1oMmm+n1iyUktUKxTlG1KIaTAGEc1Qheh843K+qeAj72u1zkr5cpcFWc/zjDGbMULUkq0bUvTNIgY2q7DmF2o53FKiePjJ8xmO0ynU1arNcYY+qGHnFmdn9JNWg4ODtnd26cfRh4f3+f87JS3336Lx48fMJ9O+PCLH2MyU3Xktm355vdf4Utf/hLWWpbLFd1kyt7OHNe0OAsxF4xxqhGAEELidLlmsVhxdrrgfLFg1feoO4/wsz/zWX7qM5+ilETbeA4PD0nFMJ1OsabK++8eVETJEkPk13/9X/PqK69gjWE+nTKbTqAU9nZ3cdYhIoxBdQdKRZjCqKIjp2dnrNcrRQedY29vj+vXjkghMp1MdF5KVP2vHwKucbTesTNp+ep33uW1eyeQMqs+EMYRyYXbO3P+s7/6Z/nu9+/w/zjrWWVt9sacOYswmViGxhGyrrlbsKM+J+WsdHuR2qSuc/OXcoXN8zfjHZv/W+zTzylP5+b6/3IxYlQ2HmMVBbObPL8Wf2LBC62tc3r5ApSBC+RMqY0jtmsv+RkXLa5yQRrLbNYgBpz15KxzbAgVxRfOzxc8efSY28/fpmToRzWj3njdiHG0bYOEjiHovi5FB5lzySrrn3P1pKz7p+ixt9YgVu/TzjnWw8hytWQ+nfP666/Rdp62aUhxqC4yWUEH8fimrRTX5t/pOv2RFGfT1iDt5KnfKa/UvE/i+4Md/8vP2aj01SOsVJG8mR0zmhxz6SSjIglsDjhb2uIGKrvspVY/kI3BskiV8S/qF/EUYqw8mq0yDDWxNhX5kCqvvBwyKRYmxtDNhNMepjNFEk/OLYtVJKRAjgljC2Ia9fWRDtvAtdlt7fyWwu2PflwlqIuqaz169y5d1/CL//7fJY49r3/vu/z//tt/RDy/x/nyhHYyoYSBxdkK6wxt20IJrBYD1w4OWfcB2wl5CPSnPeLUp+j88bsM53e5YzoOb77I+fmKxf2HzDtYDgNvfv8LrE5e4aMvHhFuzXl0ekIfC++8e4/rB1Pmsykf/9hHefa52yzJdKaw6O8Ryxm2nfK5z30I4yeYxYK/9Jd+gbfv3md12tO0+6Q6iA+ytWFwZuM19jRd72l09QIaf7/Hf/DEes+Z98MQsfrY5cVo89gP+/3m7TcLzMYsvYjgvWzPo4KuEZCRkqsIjeC6KTEnrs2uczS/SUYXb2eS8vbXjpROcNKz4ywikMLIUARvPOSAtfMf/t2v4r/TUJRWbzq2NRyZcz4eX+N8bUCex5gGKzCUwjoKd2SP3k3ZKSMPRscQwRMRU3Ax8fHFKf/Jw2/z86dfZ8+9gzQJgiAxY3jAc6vf5391F0Lzc/ybg5sMAjYkyPAwNHzV3uKgHLAohndLixSV97fF4UvmQ3LCJ/27PGfeZkfOKEm7UVM78rHpuzSjgfEF3i2HKhGfVbXrcXZ8nWdYmhlOCt9JO5ylCUj1JQNKTjjraNsO53yVPNa2oxWLt47GKUXElbj1p7HiLijFtqFIRdySClLYiloV70m5xWaLNR67oTXmsfqMFcS1WDE0Xoe/Y0oUI4jRTnro12SX8KZRWmKlJVljcAZStOQY8cWqX5fJZAwKv1FVNlViXKrKrEGl/Lc0R2fVAypmSo401uJtox1a15JzqF5hOv+cULVJ7xySHZ1tSWEkZE2UJ5XKYwyMKeifEOhjwOaC847ONtu0aj32xJIZY4CcSCWqEIlpsKbBSYOzAgqOsYy9ypHXhdKIDh6knCqlLJLE0fkGis4zl9r8tKLWCtp6V85UcSqVndF5O/WnyzTasQUDrW0Qe9VZ+nHGRqzCe48xlrbttl56OevIQMqJJ4+VouWcXm/L5ZLl6pxJN+X4+BGTruX6zevcuvU8KcPDR/dYr0dSily/fp2XX/4ki6WqPYLh4YO7LM9POTk74zd+47eYzeasV6fbxsm0dYRxZDLVIu3J8TGPHj1iuVpzdnauwlqwRXH034Jg+K3f/gNyEv7j/8nfpZ10iLGEivhNp3NN1kumxMxv/97n+c63vrW17JnPZpyd6Zx9Rr/npklsRJs2IUbOzpcslgtCGJnP54igs3bGsFyuEZ4w7dRnsPGebjah8V79z5zjr9g5v/fwPq+QWK3X9OvITz5zxO1ZR7/ouXF0QDhZ8/a9R6xjYDUmOmuYeM9U4F5IijBVLpqxer06q2iiNnXYilGo/EHZFmrbKJv5sM3+2z5QgY6KYr2nqLucEynwUkeK8kUuruuyPtcZbWiN0TNUWt9l5tzF7JnOd3mrCH6uGycitMmrPcFhtQIpVbK/UrFDiBhjeOO1N8nFMpvv0E4b9uYzBFQkJT4tQjSOoxaTkvW8qPtETyg9wVK1dtF5QVXTHYYBI8KLzz/LZNLhjSVEFR6MIbAeBoZRVUE3yPMGpJpNZx/4Ov2RFGemzowp59RUuLK8Nzd+Kjm+fLD/sBDAVTnpTc218TXYPqGiXnaz6G+5svUpIrVbsIFdeCrB30j7biSgzRaBqwsBipBw6fUb2NgK7LQWN9EhyExhZ9oQsnYapo3jfOY4XzjGkFiPUU30iqoahbjpiFbPN6RaBhSc89x8/jml4hgwXcuHXvoEf/t/+r/lrVe/xd07b/Ho7tvsf+yA+w/fIYcVb7/xfaad5fatj/LwySPCsMZ0ukBgIZWAEWG9OmWxMOzsWr7/na9xsLPL2K84XS+5/dxHme9+hNsf+Tjp9C3WixNW6xU73vJTL9/mzsNzQn9GsgOPz97m1nOf4jQGHr3yBdJYWC4SO8vEJz77U/zsX/yPaecdP5tgvrOP975Kt1Z7A1E/Dd2zfzxES95z/P648fTi8ofHBQ2SWsS/Z9suvc/Txdvljbwo4Kgp1BbrE7TL3E3VoLbCsalYRApNMyHPC3l4jEkG2hnjcM75+RlnuWdnckR766o4+3GFGIc4T9d2NB2U6Dki8PHykKmbEybX2W0drTM8jqaiWA2WOTdDYD0WSom0KbIT1vwSj/jFdMrsaIrkDyOrgdL326FucZ7np4/5B/ktTLvL69M5klQsIgm4DGI8h52hyzBgyGJwJXEtD7xsznjWLpmLQ2QXi0NEjdhnjWc/jez1j/jS2HJP9umLJRdV5kvScleu4UrBtsKOL4Rs8CVi08geC0zJiGkwxoGE7ZyvnvCldjyt3lQpOl+2AcpF/SjFGPUPBPUsExBXaFNDcZmIrVQ/BwiWTM51MJ4LKw7rlFZorcVZS8iR0TZVVlpRQSVXZm2y5bTtRDemobUOayx9HEmi6pHeqseXqjVKLVEMJJWm8tXc1lgBY1CjbL2ySSPr2LMaekKOUASSkIgUSSTRYm/iGmgmdIA1jsarSIcxghePK4NS7Y3uNGscrfX4ouiBxVBE25eWwhjVp7IYAVHfNAPM7BRGQUTNyylQkr6vNTr3l3NmDCNZ1JqldQ0T0WQ+m1jn5CIuq22DzqfY6m2aGUJPzonGtFtpkVIsBvtDKexX8ScTqc5/D8NQfb70913bMp3NSRnOzxecnZ8pRT8Fckp4r4IW1hg+/tLLUGB/T8dWHj5+gHOW69eO2Nnd14aDQNdNmHZTxArOGcJ4nddeewNKYbVYMoQR5xxDP/D4ySk3rh3x6PFDxlBYLM45OT3DuaaaHptKiZUtxS6EsY6yZH7rt3+bn/+5n2U6n9L4BmMd4zhw/+73OD075Utf+jKvvfqqosmtp/MdRhwpaoIfQsA3vu4lLWfWfc9itWKxVJVrgK5r2dvZ5VTOEbFQMsYoK6YPkcXDB7x5Z2Q+m9P3I0MfmElhPwQmY+DB8pQSCj/zsef4T37pz/L26/f49a9/j+cNhFi4vxyIsTAzluecItnrOLK7M2PVC0MMHB1MGYbIo5NK1zMXYx/W1rWpaBGneaxsiGKoPdEGiUBZS2Vja1V1AGqhuvGUfVqOHzaLuxUhVP6fjhUVsggUbW7lWJVfK+Dw3jBGJ/xT9QfbbKep7LoUM6fnK8ydexjX6dpa0bNhGFmt1jRNgzGn+G7GdD4yDud85MPPsX94RKRK/RYY40jOOlvsRUgkYlUZNVaL8BQqpbGAtIblakUGZt2E527fYjad4MSQheoHp+baqsh9oaIZQlDVyMrmWPf9B75OfzQm1LlW0huYtbClCr433jtv9scv0qpHWeWZbn7mUnBWsLL5/Pcmy/LUz8vbcfnnBf3y8lwcmzyajfeaVDRuS9spT0086Q3eFrwppCxgwHcwbyyxOI7PHX2AENSU0zlLH4IumNXZWOSiAHViMAbatmMcR0pnmLz4PLde/DC2crS3Bqw5c/eN1zl5eI8XP/FJvv/d7/Kf/1//z/QPH3H75nOkeM7Z8oSchb1pRxLB2YZ5M+fG8x/lwXxONxxzY3+CmTkePr7PW1/7OsN4yjO3b3Ftd8reYcszLz7Pb/7ON7m+39I1hp29Gb/wS/+Aud+nme0y3zlQepH3GGcuLrhKd5VSvTW2B6OiYk8dmzr4+jRQ9vSxY+N9Zran2uXC6/3Oq/c2CN772FZCX5c3NpDrU/2l95yzTxdplwowLs6ZDQ2Not1lctKB+TCyXp4RQmAcB5Z9j3WeHHuWiwc8uf+E+XzKtRd+kkjh3ttfISweYUbLX/kP/9c/8P2u4k8mnHX4YrCuo7iOQovkkWd24fmZ0O5auq5hYq1af2wEMkohZUMMOmNBcTTJ8sz4HNLvqhw6SicKMStwkwu2FJyFQzvlV2fCvVZIeEqxl9YyHdRGLLGoR57BMik77ApMzRSISgXCbIsaY9R0/Sh7nhtbjrNnVD4IYlqGcWQc1ljJWrgUYR31Gn52/4DDyZybM507cN4xtTO8b7DGkmNPOFthxx4pBYfKEjdG4ZuQIjGParcCFNGbuxiDsUBR1TDvPa5o8eHEqKhHNyEXwVr1ztmsv9bofKyYjXCUJhHUoiumQElBr2OzEfco+OLJZKZ+okUYhpCjDpdb/eyEHrdSCjaHui8hhURnprjS4LwnFYeTTE6GmNbbz/K2JeWElKIzr0UoMUIpjFkpV8756ltWSCGSpBDSWJOBKsFPQafbdJidVLBFsL5V2lqdG5Mtt1uPpw7QJ2LWOTZTDWFLzjjraUyDbSxWHMH25BwxYmhtR+snOGORHBmjmpNLVpVNUJRUjHbxcw5K85aEMRYjHofBGc+QP7is9FX86EI2yIC1qp5Yi7SYEsvlAmstuzt7HOzvc3Z+xmJxxjiOtE0DFGYzbQqu1gvarqXvB3Z29jg4OGIcB8BgnSXGkRxTVVEMXD+6xXJ9TsqvsL+3q+tK7On7NTvzHUIMFbUoTKYTJpOO88VS2UpGmEy6Kmk+JVVhmhBGlssFTWM5fnKKEWF3d4c33nydnBLL5YrvfPs7fO3r32C1XLKzs4PxjpwLYQx0XacKfDlTQlAVce8IMbHqex49eswwKupz8/oRs5l+dte2mnBnqZL1KkJhROhmM5z3LJdLVSH0hs5PKf2KoyHhQ8E2DX/1Ux9DCjw5X7JyLX/w5l3i+ZLlMDIRoTVqo+JKxgXh2n6HtfD6w54XD+e8+2RB3ptRcmE1jEChdarqnBIUydv1PdccvRR5CtHZCqdcym+MGNI257loOm+UGbdz+0XpjHmM5GwuLIgylFx0rGarAq77aZs+o6wFRUHNFgSxzuJsVdW0gjdaHA7DwOJ0XRUXFcBISc3s133PZDJlWK94/PABzsKzz17DeYfNQRlx1HuEiIrV5Iyksm1UOGfVyoWs3mldi3OWvb09JpMJ3lmcs3pvKTDGRIqaf6exqkqmhPd6P24aFdYxRv/f/7iKM+oBVoogSE1wc9nYYW4q9x9MaJ96F7kQDXk/OqQSWBRhkiKsVgt840m0itSZi9df/pz3EyDZxIZ7/YPbcfmTL/5Raid469NVP0/9YS5/Tx3ULqVgPTRFSBlkx7EIMAZHyCpc5UNkvV4zjqN2X6UOJaLStM5apq2hHwzPThv2ZkKMhfsnA8V41us1RlpaL3z2pZ/lzqMlZ4s1n/vzf44PfeQfcf/dOzz/oed59bvf4ouf/z1yXrE6ucNzH/ow3XSPX/xLv0xcLfi1/88/5drHP8FPf/rP8fCNr7Lfeb5oPsPXv/0W/TjhpZd+khduT3Byxt/867/AwbVn2Nu/xvUbH+aZD31sy0c2mC2iSanU0/pTfWS3Iq3o5aBdm7w9Ly6EX3XOb1PmPI3G5i26mWvhd3G03lug/2Fo2eWCbLNduWRSqmpARdC07OL8eL/iX9/norOk/1b1pRAD9+99j8d33yCWGUeHt7j+zPM8OT5h3nZ0swPm+54jI4QQOXl8n+Vy4J27v4fPgW995fME8aQSWSwf8dnP/PIP/T5X8d99WLHkio4MMTP0iZgdxhrmPnEwGfFeGwxjijjn6ZoOqOpYedOccqiWccc7+RCpjYksGy+7SzdN9OzeEcektkEFVdGDzdmrSoCIdi4NYKRBOKCUvQ2GUVtdioxtiN9tKcxy4UP1uoopEtMAJRNjVp89p13RYRhIJXFtt2Fvd0brdH3rx4FSDLPpjvomhRWrsiCenKmarQi2CKrdq0XhmBJ9Vil6U1kS1qqYfsxVlr6kredOQW+4IgZnPc5ZvDOkqAjdpkkYYqxzCSr4kUrAZoszjkkzoRhV3UQKsYR6D1GTa2MMjXNKKzUOXzvxqUBIQ6WlX6xfIScYe7JJtE47u8Zp9zoDUoTOeGxjGMa+Fp0bMoYwDgMDvdIsfYMzWhylHLUJKVWAymxoTUBJjGMhR5XTNyiSqqJuOg8n1labEJBia2dXkXxjHK3VOUEpBlLCWYuTBtM56CbEqL5lxgiVy4nHYnxDSZEkGTGCpyp1oidpEa/qnaJ0SG0AOEouFQ2+ih9XWGuZTCYYY7DWYa0jhJEQ1BCZUlXvbMPOfI/d+b4i6FV63zl9DWIpCG2rM9Z93/PkyRMmk64mvRCCSpGPccQVnc/69Kd/ikePHvH48WN25nOOT0658+67PHPrhkrgr3uGMXB2dsY49jRNw97eDvPZtHpMdTSNVzn1mInxiHFcU4pwcnbK3sEe89kBX/3qV/m3//bXuX/vPvsHe+wfHJCTNkU3y2rKmX4csNbSOE8fAufLJcfHxyxX2lRp25bd3R1u3bzJZNKxWq2wxnG+WBBdnUc1llIyB0dHNN7y8P79un+tigJJ4ZVhSaHwP5jMeKMUwhAwxvPk+JhFLjw4XfD28SlzLEfWsiiJsRRuW0fIm7GZhuezZajHwTnFxlKOeKcU61zytiAxVfU1pViBCyp99WJuV6q59yYPKlmqkuLGM+1CMbsUqXYEhpjyFtQIUT8fNn6elR3kDN41NN6pLVb9UJGNmqYehwtRko1ipNK9XR3pGJMwESHVe2lOKjgjxqh+AcLJyROMgT5k+tXI2A9IibTOMoaxHmfDOCgYYhuvQlxiiCmSYqSr10XbtMpGMBZjDLPpBCvqsWwr0jiOI2OMOKt+jsMw4rxjue4Zx8A4BkJYAfDvIoL0IynOikCi4DZ4YL0BmCpNzuWC5g9Byf6wBPoiCaYiTOrnYMVgJXMhx38ZAak1QoU1N7CpQuR2+77vLRqfTtTZFlv6LerjhacSc/veBOk9SbsIYIrK6wPGasFChT3btsNYh1BovcNaYdIZCobdNnM4NawGdYHvnH7S4a4nxELBV7hXu+sfava5/6RjuRppmo5bz9yiUPiZW7/MT/+FX6zql5m21Tmnm0cz9maOv/zX/hL9as16HJn98r9H27X8TeD8dIG1nm7e0g9rHr77Om9//2u88NE/w+3nP4rZziIYVdukeskJl4oVs7XY2PRsNp4Ym327kZeWzYG+hJppuvj0PFqdNqnPv2BVK6ivymeFjWpjqdD85pjq7zZF1HZLCrUM09eWFC+oTD+Awl4Mzl40Fup5LDqTUtCENIrl7p0nvPGNV3jhYz/NtWc/Ac6wd22KyZlsDKuUSaueYVjQx0jjdzg6+hjr40eMduBjH/koxu2ye/gMH375Ez9wjVzFn1xklHbcOI+vKE9Ab3h5OGd5kmjaKc45Uo6EYijTma47WTAp0IasRpeiN1gVZChEqWpZRWrDp9JMROc0TVmpAJM1FGO2TSlKlWGuCBJ1FiqLdjKLXFC2tRGS9V/V+6XUQWkrah6dSqSMa3IKeOfpGt3+nCJFRtZhzeMnC1arjqZVP6AcIu10Rtd1NN7TE+iNIkQxRLIVojHYNGBMIaaRkEbWcUQKKoVvDBRLSRmKkMNIJiG+QTLEGKq4BzSuIWevBagxqmRZaTYblTW9Nh1CxjidB7HG6v61iTiOWuiZFus0mcmSKamuXzljs6i5tTV4gRQjmUQpUT0Qc2IMK8Ys9NZVNK7K61PqPLRSZ7SIymSKFnWpkLMWktkY+upXtukyF2vUcNp7TNKZLkqpcyUe9YZTemIY1+q1KFb3pWtomkYpS7ZQktSZoqAixNbRGAelMJTIOo94yfWe5ig1+coUAgX1dCuMYYDCFnUVDM5aspjaLdf7c8mqQlmKYcyazMQcfwxX7FVsYoOUOecwJtb5mEBKsSLeThsbaB6ns2kG51pFQY1BxNC2RV8Xg9IIa0ItZEpKHBwd6TWZEiEmZvMdAHbm+/yFv/iL/MZv/Dpvv/k2s9mMGBWNvvPuuwyj0o1DCPUaTlw7OlAzYSPVCkDzA1t132075fYzUz7/+d/lS1/6Et9/5fs8evSYcRxx3rC3u4OzllWsMu1Fr8dhHFBUJXOyPufx8TF932OMoasKe9ZaYgw8ePCQ/b0dncETZTbpNa1d9r29Xf6jv/M/5otf+D3OT04JseBiVBRJLBPT8KhfgRFumcLqdM24vyRHuNYYjnZmvHW24CPWkoC3gvCsdyxTIgDNmPA5U3LmZJVIubBY9lXFtTBxtvqgGlYpqfCSFJrG1f2bay564f4LcmluXtP3XFS30RqjZt7bHEdfY2pOoylUqZTQisZVJsFs2uGd0bmzOhesRT9VpEnvW2Zjcl3FOYzUzK2qPsaUGcbA0bVbzKYzcs40TcMwKMckIyxXA+fn5zrDVhkCxQrZWJ3PLyrepY03Q0w632ZQ5pp1Kui2v7evxbQYldfPCSPCpJsgoteNOIuIVYZHyYQxMBZF8XIupKU6ROZc8M7iq2XYH2eU5r3xo5k5Q01ZU02oc9mm29vE+WIDf7A4+6MKtvciHxvFxOl0+tRz9N/KcM9FcPZC+OPy5/wwquP2/blIxPPlLl9FcEqpxtjl6c++eL+n3/cyqpJhW7CKwoBaIhj147CCntRO2JkUZr5KPwt0jSVWhRoR8EZwHnKpyZUIfYIxFYxzNA2aeCVd7FQ+F6wTOm/Y6SzTztF63aCmtTjXseN2LwqNDPuH+wCkOPLk7n3Wp4np5BkIQikObyzOiqKm7/n2245I7RyUDfpoLua5tgqMvGf/PbUbLxXQl/96Cq3afKLirJeVPrfDqk+9/uLzUtHOszeC27SYnKfUmwM1MdbvcIm4WDYzZZtj/Z6CvFIBGu/46Z/9i/yZz/48xludDSlCqTeXgnak8Y6ua5jN9plMOp772MtISiq7b4zSq4om3Ffx4wvXtLTFYUVo7ZrW9WRJjCnAujAsM33tMLdNSxY4O806LI7j6OyMZx6d0sWIGF8vAm0rpFQYYyTkQq43q815pc8znLcNDw53WM5b9SSsksBqSmzAGrzzNFbnpFKlEhsjGLFQVIwHUHSnFErKVcrakEmEBCmNGFQwYwznirJgMDEiw5oURharas6eM7O9a+p3aVWQRIwhi2MdIyUuEWswztYkr+7MerPebIsAMQVNioJ6eKUSiKiUexhVGbCgRdLoPc5GrHXagLNqG6LrXa60PEskVdVFHTwfUiSEkVwTKFVoUzQgpUhOSsMsKbPqlzQ+sjEcTblU306DITPGpJLMIZCTonTiG1rTEKpea+e8Du/nrBSawpZuhFU6ozOWdQ6sk34/Zw2CU1+4qCqTUpXPnDWoSJqFkkiSGUNSeqnRNU1SZAiqdFZygtpAtWLIKeJElRULQixFDdJLJsVIZKxFmqmqcXp+payG3+RES/1OtUgzIkQ0cVmGoXam9fhmYetFdBU/vlitVpcYQ+oP6L3f0hxjjLV5ernpqPdx751aW4xrQFGjtploYm0sB4cHeu1jWPULHj96xM7OHjvzHW2vVmTn+Wc/xN/7e/8z/ot/9I/47re/y2TSMu06hhAwJtM0E0WorCHGxLe//R0+8fGXuHXrGcZhpB96pWJWip61juOTEx4+vM+ka7HWcOP6Nfp+0Pu/LqA4p40ITcodZ6dL1v3A6ckpwzgynU44OjxkOu1YLteklGoxqtfT+WLJcrkkFRWjCDHRdi2TruOll17i7bfe4s5bb+Kc0/VP0QHWUpDdGS+Mgfs5sIwwni25f+cu63Hkud09Vsuel5oZMyN8te95uekIOfCYQipCv+xpJw2tNzxZrJlNVNmyD5HdeVMTKy1QGm8YY4ZUSJcEMXJVB75oJKstyIZyv12XyIhspPU3f1WWWM3nc22wWyNEgRg1x+u6pjbepTZvNP/aFGT6bpqX2dpY1PuOFv6+5lkp5UoLbXDObUUGUzXbTtVUerlc1PGeRAzKBJnN5tx5+w5j35OGgfPTMyyJpvXszGbEmMmi98LGN7RNw85seokymZi07QVYUATnVS1ysVry5OSEEEK9b2kxFmOsaKFFxGy94C7yzQ8WP5LiTOpFGvMGcaqDgeiB1mLnBylrAlska1uZbyryH/ZZ70NR2xZmaJF48bj8wHOeev57Cr+L7bgozjaL2GbebRMpb9RpYAMJSf3s936DDVQb6w4pGVLSk6nkAkW2HQWRAkYpL2erjJ9bdrxeMU60sNogd6Wo4leIOvQ4xsJ5n1iPiWHQhWMjdmKspesss84xawyTRmjMZpheKYKL83NW9+5w9OGX8M1EB89Npe8hiG/5+MsfrQmk+icVcWw2JqXCxiDxcnG7EQS7LG3PpUJdOcnvf8N+fxGPy4X6BgUTyvY4FJJqXlJkg9TV43rp5RfvkvHb804XH1OfYIxRatG2s3Rxbg1JF7Op5wLiu7TdTzUU0PlBN9F5EZ2n28wtXppftAbvuvpNVOmsOE+55OsHwpUH9Y83yrvw0r1XKROP2BExkSCRdVYaWGkNqzAQgDydUCYdiyYT+pFJgWfvP2by1ruYfkB8U2HmCFEwQ8KtA4QRyYmSorIFnKXyWNjxntUnnuPeC89hOk9jG8ZxYAwDKSUigm8adqd7NPZCLU+swxj1B1NpjlTpixFdRrQ4C3lkqKad3nla06hCpK3D40kLFJ2fyiAZ7xr8/i5d2+Cbpt58Pdl4ljEiIeCzwZGwvsWZrmpDZLzRopSiym0JpQrmomtYiCMmBZxRT7EhDFrUAaEkCj2NVWl6fEfnHc4bYqxrTIiUvKHh5eqNpjfhIYdqBaA32pKimoimUNH5TB9HFS+oqFjKmcZYvGuVwmgMkrTAS0YYY6TkhEiiWEGydpzNZr7C6jo+bSfKusg6x2isx4aeVViTDXS2qZ1qaIx2dUNU5KlANVG1mGwwYrGtJjiu3rf0nqLS/FIEs6FZFW3sGXG0bgpSJcZTJMXMOq1IJC24Ki0y5kiqq2nnWu3c1e3woglJKko2TyUzpkjIkUYsVtSjyhlL59s/2Yv1Kp6K6XRKCLX5UYubDZso50op3qC8RgUycsp0naK0JycnLJdLJpMJ+/v7NE2zZSuJKB0upahiC4LOHqWE94riIhDHoKqICCEFwvlISRHX6AzbYrFisVhgjLCzs4MIfOOb3+Stt97mIx/+CL7xKuDhPefn5yzOTzk5OdYGh6tNGWNoW5UxV4qh0HUNy1XPEBJni2MePnpEjPo+t27e4Ob1azTeUaQwjrqPNt/Pe0/beFLKnK+W5Cqv7p3n1jO3+Yt/4ZcIceT87JgvfeELtI3H+0YZAwLywnO44xNuiKEX4fG7D3j3ieV4scb7GTPb4vYdH/5bf5Xv/eN/yunyHIsQCmTUf7Jf94xJdRacgf15nTGVzLKP5KzCFyFuWEGabytFcZN1l0u5iQpaNI2voEpNmGozupSLokxDUfGUSxUQ0fngy+NIasNatn+o1g3mPa17AWLNuXX91cZRVPiOlLWo3JvPcXbTbCvb+chS1BbFGBijFssb6fpvffWr3Lh2jdmk43RY0DhLjFlzNgy+9bRti7eavzaN14IaZYw4p78PITGGXtHfEBiGUSmcbbNFHHW3aMGv54gjVoGTlDM56VjLB40fTXFWM3wLbGYYuIQeiGyEG2rxJNQOqdQCo75PVmxJ5AK9ukxn3JwkmyT5orhiW/WnDK03l05LjR8GK14IelCr9x9Msi9XvVK3fYOaFKQWHVURsqrjwAVip0WjetRMnT7/NBbWIRNCUnSubOFGnBOC03mRJwJmbunq66TS93JO5GJYx8JiLKz6oAVZ2HCLtSsw6TyT1jLvHJNW6Cx4w3YbN6IqBdg72Odgb1/pOFsfjVoFSCUL1gvYOQOy2c/1KVWC9aJQKZd4xReLgshFUbKhI25U6djgYJv3KBfFoZ4/ZVP+XxT49bOqhAilFPqUaI3gzWZS56lDcnH8qZKwXHycFVOhfE3gjHGV8rU9CxCB1v7xGyJPf6eK5omeNci2pL3UBFBluXLp9NuAwBdU4av4ccXB9x/ysTe/f+n83CiJoeAEQDHkxlB8IP4v/0fET3+CMSZyGGj7nrJYQIg6eBoDZb0kn68I64Gy7imLE1gvYblCxhFSgBSRcUTGga7ZY+b2iY3ORsUxMA7VLNVALCMja8RGSklkkxFvtUOZiopi1BmtnAsjqfLsWy3Wxl7XVGdIldbkTEPKVcAIiCVDiVgjODPD5GrYWkZqRwERS0J90Iy1SucuWqxI0QIJVGIeI5SsxYWt81KhFkVpA+WbQtM06u0DpByIOTCOQudbOmOg7aqBMoxRxXbSMKLKY2B9o4bVvquFh0r3izXkMSM4Sh4ZUOGQIpr0qOeRNppSThgCznq6dka0SuELqWfSzXVlFJ1PhErBJFFiYIwDguAxePEYb/HegdXv3XhPFqp8fSakgC1CY5SGmAtabEalfrlqO0BFRq3TmUhTpf6lKBoqIjSNp2tbxqTmv84KqXrVeZlo8Sy2ds9Vej2TSKmQS9BZNe91VikFUghKgUxK79z4xZlUsOoRg7GCweCNx13yVLqKP/mwVtO+jYx4zhnvfaU3rrHWMp1O1QNvcx1aw4OHD9gIzBwdHmKt04RW6n0r15uS6H11pxpWe+cxYuj7nlwyx08es173/Ff/9T8mhJGd+VSFb3JidXbKaj0yjiMxRqbTKTknDg72KTkzjAPf/s636CZTDg4OuH//PqvVipc+8iL+2jWss/T9sEXRQZktzpmt19Y4jNy794BhGCilMJl07O3tcuPokPlsQus9YxWb8F6T9pQUdXnxIx/mjdffoB8GotmM0+jcXdfNuLl/i5s3b/HqK6/w6iuvEJIWcNevX+PjH/8kb379u4QCE1NohqiaCVn4yBC488Jz7O9f4+13F8xz5u0UuW4bBAjAuo/M9jzDepPoa8O+8UorHp1+v5SpM2cbZcuaXl5qZG+ACH1cC1ed1c3EtMkx41ZBXKQWuHKRWRsjKogkG0shpZmarfaDrv0bhpQKCFzk/YosKrXR13VPgDFmsqhsvjGKcJYCQxiZtJ2ivOPIEHSuqyD06xWlFG7euM7hwQGTSUtjDSkMGANd2xCsQZxl6hXtN0ZovNdZuZJ1FEYMFmEcA+fLRdWBqEUhWjBCRnLGqmIVgq6fKSninIteU/PplCcnJ4BRe5MPGD8iQZB6gCpCdHGNbgzpLhJsK9TkVFE0ACdVLGNLi6xHsyjsui3wilyk4JuEvz5XjMGUjN9CChcZ7OWq/vJc2mXEbfs+7wfb1WJxmx1TT2QuvsPln+9Vv7nEHsIKuFZovbAz8fSDZx0gAikW+mFUBbOgJqoxFkLItK1n3sLUl+rtY0hF0UpTYOLUmDR3BStaoHqnF25joLFFC6GKtl0UIwW3pS5kHSK/tP0X+6MiibJJuC728+Vd9jQqaXjPg9ui+qmi7dLx2ZZaFVnbFI4qWar0oI0wgLGyLbgKmrflip/lDX3mUvG9OT6b77T9vLJZxiqad+ncMOgc0Eb57anOjzy9H3+4mM17908txS7v54vNu/icS2/z3gLt6R17FX/Scf3Fa8jBZ2GxUkSqiBZPpUBImKxi7VKAgwPcZz+FVO8VjYvz4PJvDCitFnSNvGw2U1sSmgRnniuZZ7PKtecUNYnOiZJV2jzHREk6FxXGnhQCMUVIkRIH1utzFfao1MG5FEIeKKiKqB1WjMNIKiOxRArVsNg1kAdIiRxHVettLDnBOK4Iw4j1mznURLezy+7126T+jIlz5HFEBFJJ5DiwHlekomIUXTNRmrRTSXxrDJ2dUCSRk9LuQhgoeGLO2tiRghmNDpFLC8WQYtwuDKWqEmaxKkgxZpwUrFPRA9sYconq22Ut2dUE1hYojSqr5kQK+p7OWJx1OsuXCsWqypg1Kt1ts6VrWqw3tTBCMxFjiDkixhJRhG4cB6IJSpkRj2cj2a9zcYiwGtUzJ7HpUlu9j4pTClrO1RszY72qnXnnyDisd7oOZyHEUdd4o9vVuQlQkY4Y6EOPsyrh75zOGcUYkLxmtV6TYqj34kxJGWMKNhWkmCq8AiVrc0BKwRWDVF83a3TWLaQBY67UGn+csV6vcE6vMWMs6/US7x2z6ZSCCh2klGmsR1DEYbVasFgsODzcJ4SRR48fcfPmLUrRRL+UC+W7TcJtjHoDCsJqveL4+AkHBwcc7B9yeGT4O3/n7/BP/+k/wTun60yuKF7J6kVVC8MQVDHVWct0MmE2m7M4X/Dmm29sZ776YY0xFqXsarNJbR2U0XNysmAMA6enp5SsqrKTSVOpe8LZ2YKcMs9wjWu1EHTOEUIghEjXtfzNv/kfMmk9d95+h+l0ShGzRR5Pjk94++03OTvf4+zsmOl0pip/WdeS6XzO/XFJ4xzWwAGWWArvnCz4WDfnzeNj4q1nOXv1dc4fP+DBek0PhJJJJRMLnKwGbrodui7DOrFYRxViKoWYC2PI28LYuQ39Om+FpDYV2uWcpf4L7wyt2yCnVTBkg3ZV9GvzOkFnwnIp2n+LZXscVMwuUoyO08SUcFa9JFVVXddp46wimY2ruTQgheqgQi6ZgtK4U4xEifimpR/UR282n3F9ts9isebBk2OuXztgf28Pa4Sua3HW0fe9ev86TyiR2WyKiK7VOWUmTYP3jpAiKRSOF+esVmtlhTml01qrzTjnDG3bUcj0a0WCh0FtILrWE0Kv66jNrNa9FrDLVWXMKTL5QeNHUpxdzJhpmMtHkQuESekfKhSiClaaTFOVZTbowYaCQ5HKUa0QqrmUQNe4nLRSqlw5bLmj9pJz+ftvu5b0BUhF8LIZmn86np5ru4CF/7BEfLs/tvxufY0BOpfpnKFMtMsRsyJBy6FhSK1KSxstXI1RaNRvJEbrTm6M0LmCmegsW8wKKcu2MKF2Ki6lgpvhz/cUB+/9fj90Hu+P+P0ftV82FIrNZ1y2MHi/5wrUIr3QOHsJpytsxgFjLowxEWLg0aN32Ts8wrqWICrnffE981PF9wZlY4Pmbs4r2ey6jSrn04XSD4vLhf8fto/+OPv5B15bX7f5/uU918FV/MmGe+tNSL2eO5VuKN5SxCJTQ7FGDX6NgedvU5rmPW0M+KHHb3POwZZWvH1+AXFaxl12zrvcjPog58Xmpv20mJLOiKquRhWfyMqrV9ERTeZDGBWRGofaUc8YN6GdzFjFwtcfZYw4mnyDvLtLnowkEsSRktYwnpPCA4bsaBnwxlFcgzMeU6/LXAfMTbFK5c1Kvyy5mmBbj7GGrm2RkqD6+4QxMsqAMx5EaFpP4wxjHNTjTBSwFCN40xBTRrIO2WP1vtBMWmzQmTUBwlhVGq3VWTSjSUQywpADqcBYeowteF9UKa04comYotevFQuuYVYMxUZW63OGMBJLxltLShEhVZnpqrKI4LGUmviIFcQ0WEkY6xFRtFIpaKVK2G+oXB6dLwyEGMklKgrQdPoZRurz1cJAv19GqsKcdYKJFuMaTImQEiZlclDq6RiiJmtORRUkGybVUDylRDRVUdM6QgHJmRjS+52KV/EnFM41rFYLuk7nusaxxxgojaIobTupAiDNdklpmoamUgknkylHR9cBnftJKXN+fk6MkZ2dHdq2BRFOz0558uQhbdNxeO0at249g84oKRLx3LPP8ff+3n/K/+Uf/kNa3zCbzhitQ6wlhHr+VA+ynD1UCpoR2NvdZTrtiCkxDEplCzFqwmw0qR/GkdV6YLVasVwtsdYwn89xzrEzn3F6ekqIm5xAjevPzxecnZ4QYma5HhCB6XTG4eEBt2/f5rf+7b/Ge0USvdOfTdOSc2SxWLB/eEDMmd29XWazGcv1gHWexjokCjtieNQH3shrkjP85M4+x33Pa2Hg8Vf+gF/c3WOeCiclAJm+ZIoIY06sh8iYIvO2YeYjJ6uga8aYCJs1vAjOWpXSr3YpjVf9hRTzU0wx0CKra32dA625oblAwja5+/Y+sX1l2STd6N7TfFIbaqVSqyuTCaXAG2O2CowYaLzmZiUrShZTqVYz+rPxali/ODthtitMZzNu3TjEGxjHzPHJOet+5PlnbzObT2l9wzgM2zlFRfEspydnGGe4Nj+AnIgxEyRzvjhnDJEhRFJMhJRwtXhxxjKdtFBRZeccQ7W8apumzl0GPTc3DAlrt6CNcZ6u61gsAiWVrR3DBwkp/y4yIldxFVdxFX+K4xuf/Xlell5LJN9o4iAq8JLQW5afTvQG9rM/B//7/w34thZdG9T56TmArZwpF+Iz70VQ4Q8rvd6/qfQDz3pPI+WHx/s9/t722OZ5F8VhLoUvvHXOr53MVV2xFMYi2mxjQ0kuRFT236XE331+4KU9FdegqHqh0pBUfTGlxPHyAf/1vX/GmNaQ1KemLZZOHNNs8UkwsahgRo7ctjeY+32sE/VnS5lhHEk54Kvfly+RaIQxDKj3m/rxZG0Po75ibsuYCHEkp1iTl1xn4zQByWUklYg3lqnXebqcTPXmASOWkDbok6GkyHpcMRT1Apu3k23zKMZUxz50vzlRk9tiwdaClFhISTvJxhhscVgnIAbjPdYa9abKQgg954tzhqBULmddRU+Unrgxk82lYAsIldJmoMTCeuwZQq8qlUVFErQUFhWekZYQR4agQhHOWaVkG6VbOuMJKZGi0iD/8t/7P/0R595VXMVVXMWf3viR0Rqv4iqu4ir+tMQ7xw85Wp/iAFPUN8IgRMmsU6G1lmmV7i0fe5FmOEWyDqeL2At6iVGKsub+G8KxbH8iF9RdpcI6LtRJN8WT4b02ExeP/5CC7XJN+EPjvZ+zoeD+8Bdt5iWjGF6eQ8pCKEIfN5z9TK6G3IgQU8bmxI3dCdO5f+pTN8h/QViNS34vfJmv3BoJxhClVMQvkiRW17RcrTAKPhn+j9f+Az4++VCdcQMdZq/d41xIT+5jfv2fqLl0DlsGaUKLCpxVMQ/bgCmMe9for7+og+GhJ4WeMPZIjtiSQaaEuCYzMpJJKWCwtL6l9Q05qBBJjCPGKIvEtS05qdJkQo2lyYkSIyEHtRpAaHxLY1ucceQY1AYgQ2t9VcADRD1/rLUVtYWSYONTl3NS8YUUYFTEzBjDvJ0x8R2ZTKhFsaKDjs61SkO3it4ZI4RQiEV971rv1MhalAq7XJ9QSqJxHbZpMb7FO18PalYD7PjBu8hXcRVXcRV/muKqOLuKq7iKq/iA8dVxQezX+GJUujxTPQxFCzYxWFFqm3t0j53XX0G8V2EEY7d/VLhnM/OpXjS+meC9ehdu5m51BsIjRhEN6uuwSn/byB5vpPCVHV62haBWJ25L4dnqD4lcquHMpXJOLv3ZxB9NslABicQ7D095tY/qV+PUBsLkUNUgBdt0GFtoJOFLxl6Q2i+9GfV3hWUeuO96ft59jpgCA1GVE636aiXJ5KJ/eiJtsdye3qD1Le9XoEKmLI4pe4fb4k1UhkwpwxvwUgQpmRIS5UM/Sfnwp+ts9GYsfls5k3LirbO3+N/d/7+RJNNUQYwOT1sMPoLNBROhy8JcWv7S/Ge5YfZIcSSFgRIHyJkSC8O4YOiXrNcLHq4Tk6ZlD6+0zHEkxpFrk1bVOLPOEzauRapcf4mRsST6fmCMvdInc/X8ybmig45e+q2vVUgjrkpajwLJ9mq9IKrQVkpVYgwjpgQMHc5BIqpSo22gJMSpOMlmntj5DieegMPywecvruIqruIq/jTFVXF2FVdxFVfxAePLpnBiraI1UnBZpeml5FqcqVAPJTN/83X2/vW/wDQenMVYFWTQYstWdT2jFD9rsX5K07bYxmsRVyXlXdvhxG7FdJxvsL5BxFTpX+qsiMdYRyFhrKkS6gZjnPqMia0COgVr2W6DiFE1RdCixNSCz2rBV6p6VpUZZWP4qYjepppJhHHgK6+/y2vxQIvVouqREnrsZKbS8a7BIpiSmZmRv/bsAexY9ImwgfU25WC/XvCdO1/HGIePhtKqipev0vBOPM44OuvYk5apmTCxXd22Hzx+WxXaa88hRr0jS9nMP5fNVLpug4jaGexfUzrhe4q9jRqaKYaFC+wc3WCsb5MksiqFUxKmJAbUQ6ggHJWWv3/jz3PoD6FsDFTZCsnoTKzwlXee8AevKfJlJaHW4brvnQiWjBSlaLoU+NnriY8fFFVyDIG+H+iHNSmuKGRCGLciMKA0xX7oyXHEmYxIUnPhnIgp0xqLtw4xQkgDiCeXSIgBm6SqLWeisdjpXNXRrNPzznmkKK7ZTaZMJ7OtFcBVXMVVXMVVvH9cFWdXcRVXcRUfMD76N/4i15spYbmkP35A6M8JCcoYGMZEjpEcVXL3iR05fON70FiKpAuanVwaui5okde0ajheRWyMsYg1xBBwxilyZtWUXuXXJ7hKGzNGzVitVcl6Z70KZmDA6iC+Pu6xXosxUsE1TS3iVP3QG0szmYH1tF2n/lxqxIgYp7L5zmGs28gJYZ1jg7QtFmveevU13k1zTAacRUqsyh4OxGO9R2yDk8Ke9IRPR9KOGnIXqH5gGxfXwunZA77wyu+zbgJOjNIOa5GrAJephafBIbw8eZH/9MZfB5MuCrG6rRVWhHffQl75NqW+FjEU1YVGrKVYQ8EizlX2qb2ELF56x1pBDinwav8un+Fj7DUzWvGs6BFx6vlZQcpc1Ax6li0zO79AMC9hlkp71RMjFTjcnZKNvlaKFkQZAeMpVbU35MIYBq4913L90G8L5s2U4IV4Vql8x3ru5YrOUv9Tn5NL0fM4JUpWJdAUAzGMhBiIMWDJlJIIMRFjIpeI5AB51Pm0mAhxwJiCWIeUgvl3GI6/iqu4iqv40xRXxdlVXMVVXMUHjL/wV36GyeyQHEfOT+6wWj1h3k5oxDOENQGdI+r8hM7PsM4RS+BsdYpF2Ol2CCGxWp9SQqEMgfU4sC6JPqq3lhWDF0hhAImK7gQhDrl6OiaKEWxGJfKpYE9lMWpargWbMiGrN2FVSbXWK2VN5Sy2yJmzFhGLOFXZs7UYFKsFmREVpXCuQZxTzxiniJsxhtOzBW9+5TucjAaToXiHMZZkDNZ48FNMM6EYjxXD4BNv/cQ5ZriOGK91SkbpkM5gjePRu29y+to9RhcQDNkKxVRKqK0FSP2OxRpu7Hjip08JqdcCbmtyfzHHN3zvG7Tf+LJKwYtFRKXAsa7OmhmtqLwheY987meQcnhRSG1MfioHcgxr/uX3/wVvmidMmjkz2xBTRKxVbzBUvrwzDYjlw+4I9v7i+5xdT4vBRGnY9UZ3Sp3XSymRcsQ79YTLG3FPWvYbq9TWLU1Unn5XEZBLt/4fqe3YJeVPqDYCqiK3qYnVEPcqruIqruIqflhcFWdXcRVXcRUfMExeMqwVxdnpJjRmDwNYHI2BnEeiBEYixCWNNBjjmbgOsTCd76jS3URnpkpIzFNGjAOjJpZWdL6sUIiSsE6tRTaeVzFFcoHOekrJrPteBTFSZh3HakLsyKkQsxpOS83iU0zkHCklEquUsGAJY2aZYpXMv0iyyZXiKKVapUj1AFSEKxf1V8wCZ+cDyzv3GaNBMmQRLFDEMBoHrqnIoApXBFv4wsEb3HvmSItGZyuaqIIVTdPw2uN7jF89IZpMMUXNqgUVYrEGDOp7KILYwpO9CV+//TscTnfwXtFI67RINCJYazn+1jc5+Nr3sOQtVbMYQZzFGcEZp349VsjzCf70MaZTwY2M1jQF9XMU41itTnj1ze9wh2Ol+jWGTFZp72q+LcZhBYq1nHcvUZ77W5Qm1KJZzyA2HpJFBTS+/todvnzWVR/RDDlgxeB8gxT1FvLGYCTTGEe8daiInx6x9zl7tXrfzh9u5GYuxufelwq6ee1llc8LK5DLojGXEcBLv67va8xlJPMqruIqruIq3htXxdlVXMVVXMUHjDH3MI5gnfo4NQ1OdK6LCDZEQiqshzNWRZjFXead0gBLyqz7Bc45rDiKRAabsM7RNB2NbSEnQhrp06AS5SVAFLx1OnNUwIpl6humzQRKxlc5f7GGyTgyxoAAzhi8a5CcSSFQxFDEkEUT6hACYQwYUQpkLIEiGRMLw3IgBKWk9Ul9yubTFm89JcKYOiIzklhSLrTecfSs8O/v3ON0sSKkTBrVYLYfetZDT0iFkiHmQIhrJAbu34uUcJ+SKt5TMsYIWbRouH9+Tnc3Mm6gQVHz7Y0wSmJjwApiDXvPRr71+79B4ydYr1RQa3Sub7OfHn/lq3Rvv4sp4KRsDXTFCE6gRaX9izOwM2Pv61+meXALQTDe442DUvBNQ6bweHnK2XcfEWRBCiOpMYgTgmHrhyPWUKzgCpztTTj+2NvMmgl2M39ordL/BErOjMPIK6+9weurHZ1rs0pBxDosBmM2xFJw3tOVkfOPZmT3Rq2Tqn9RFXy5eLZUOuZFFVYuFVabWutpCZgKaV6Ki0JN3r8O3Dz6VKV2FVdxFVdxFX9YXBVnV3EVV3EVHzBKgdY2TJuOIolsW7xrcNZjB8MYBrw0jCbRxwEvkT4PpDJiDSq5ng3eTxUty4mkuudkkwkpMJRIyJGQR0oBh86LiQhT39H6FpMzrfd419K2U0JU9KwzHUUE4ywhrXFFC8MlC2JOeO9p/QRnPCkHxmGgr4p9jXhySXiE2WxKTIVShCEnxCgKZothcX7O47MT3nh4lxgKzhqODvd55toeLz9/gHfXcU3DtPWktGbVn5PDiBHDzmTOtOm0aAtL1qlnlBExjjJEQt9DnXPLYWQnNvwvnv1lNVvF4MUxhkg/Kh20HyPrEEipEMLIs7s7DKsTYjkHU0gpqklyRX5iCDxYHCt6CIpApSrigioxGgRTBCtCWY4c/ea/or15vRY9thrUF5pGBViO10tW33hESANFVFQkmersZg3ZFIRMsUI0lke77/K1vc8zmUywxuJ9pzL4TqmkIob1euCVb7/Fo3WjipdmQ8HUm3eyhuI8JqvCYuOERy/3HDfnVdzFKBUVlNppVXBFqZ4q9CJioCqHFjYzfJUWK7l+T1NtH2oBt6Eq1hAx2/8Kl563ETkpcNnuQeQq9biKq7iKq/hhcbVCXsVVXMVVfMBIJZJypG0mtE2jM0DVlheBJAXxhr3ukJ0YMdaDCLYoZU6MYE1LItPHgVVakVJALOw4RymJlEdEMtZ6ZrbbSpojwtR6GmkIMlByxhqL8w4zGMYwYm2haRoEi5dCjolh0MJo2nZ436jMfkl445HGMpQlKY4IKiyxThlvrVLyjGVqJhjRwrNfDcSUicOSxZP7nK1HDncm5GZA5gXTzMjZUsKakDI5rQmrJa2bMJnNaRwYm8gmAkLTtDTFkYaR0+U5Z8szmmnHzmwf6ab43HBjf0LXtvi2YWcyp3GelBPrMDKGkZKr4iFCP66IZLxt8NaSkopWzJoJ1njGFFi+/BFshBQjwziy7nsWiwWMEYfHFEMKkTAO5Aiz69cxzpGqF1gsKpSxWp2RU6QPkZtphl8KqWRiTurrVjKUVDEnQ5GCEDmbHPP7zb9m2rUY0SLKWlu/g8XYwpAt69UzLF99HRNWRGMQMganBZExaoBeC5/ON3zt4DnW7+zr7KBRxUTnvTYOrMcYnRE0Rgs2a11V+NwodooqiaIonRGDd16LO1NnCylbQRb1+Kv2DrWAVKCu0jlzBgrWKsJojKGZ3/4Tv2av4iqu4ir++xJXxdlVXMVVXMUHjIP5IWEYSCEivsOYxBh0fksoTNopY0l0vsM4YcyBPo10VlGWkEcMhZgTp6sTTtbntLZh7nYIMRJjIo6JSMJag0GwzrEMvUqgFyGaxJAGrHEIOlOlkoBR59SiYE2BbEkx0I9rxDom3QxnHGMcGcKaMUWktKSUyTliKZQxcro4o5tOmE/nOBxT15EQFmEg5IhxwsF+y0985Cb9mJhaYdJ4GpdwNuObFiQwhBWkhHcTsoUgAW8cfYExBjKGkgumGByOSbeD8S1N42icblcCQoqYbEmhYJyrPnCF1jZYscQwEmPQeTDfIDlVBQrofEfTFFrXMGt2iSXSTToMhkQi5YQpwjAGxjAw9y2Nb7He1xk7gxTLGBMhBxrbqdCHFIrTYoyc+KVf/AVCSqz6Nf0YUes0LeTBMgyRIfas1j0xR57f3QFEi8AUIWVSLowxknIijT031t+ityfEnCkpkVIh5cKQAjkXcvUfkyIMGL75tbc5f6eDKvZijcG6qsgpFoPO9YUw4rzaNTjvMb4qcRr105ONpYARvG/wxuP8Zr9bpeU6h1jBWS0OrXM432LEqqefc/r51qkKqTFY3/DyZ6+Ks6u4iqu4ih8WV8XZVVzFVVzFB4xZM2GdCiGuWa+T0taSkFMEybRNAzGQSqJkpdFJTuQqVx+rdH7MhVUcOBmWzG1m5XpMyQwhUEoVuBBLLInGCxM/YT2siUkIOZFzwqXMmhXeNVhjSTExxoGmEabdBOtUxdGnyBgDKResFBwW7JR+OCWM5+qNZgVyYdZ05C4RxRBTxphIGAbGlBnXS/rlApLQWsvuruO6mZBzoR97Yh6wTGhNRoynTw2Ygm8blnlFn0Zc8ZiSGcOAFLOlvjWm5WB3DlYY84ikRLaZEIUhB9a5x0eH9JV+VwRbwDuPd14BJGOU8jcEVaEsgncO33Q4EUQyKSuS5a2lEUvMsXomFwqBJJm+9LiYmdgJDY4k4KwhxkJMa1IOiETwHozF4rC5bkIjHE53aFxLLFn9wqxTpDSsKSXSWFWrRNRDLpGwYnHGksmMRYv0z8bEmCL7k12atmMMI+tQpeylUfXKnCnFEGNCJGFzNYuuc37D0LMeB8agTmtjDPRlpKzVTgEyOYPBYsWRyeQU9JwmIcYgWJCihTQFEacWEKbidla916xRtU9bhT+c89pgqAbq4hwvf/aXfyzX7VVcxVVcxX8f4qo4u4qruIqr+IBxPixZjStcLlqMmQnOCRTLOo6Yigb1OWAKhKiFRiqeUgK28VjrGFJPSJmSMliIMbAoGeeVgiYpY4ohFkgZJu0UkiAFghRyNuRUGMLIYEcVoMiBVb+kGwPWTeh8h/OFTnbJw5JchFh0ZsgYizeGYqtoBgq4bMyp1zGB1QQ9ScKIMJWGiCWXjMPRMEJJNNYQrCMAqzBijQqcOGNJKSICrZswEEnJQlHEyRehcx2pFIoUpdIliy9VYEWUrihYbKvKlCVGCJmSM7EkvFiccVjbUpzFFMtiPCfGSMyRSGLHqOjF6dDTx0hjHd5nhjgq8mWEIQ7EUhDngEyMA0YsWTLWNFhjaLyrNFYhFgvJYHKCkoi5kCWqDUAVIjFFiGkk54hkYT0MpBLIjRZQtgjOWKUaipBTJpTIOiplNZWCMRDLQJsNlIDNA1ICk8bTNg2t90wmc0oprMYVMQSM9UhKhKiG0Wf9KctxgXMqy78cB7xp8GIpoh52u5NdZk1HQej7NesQKCYjWefIck444/Fi6MeR9TiyDgPjMJBTIcdAiCNjiJScyLkwhIEUVP0zp0xJ5Q+9tq7iKq7iKv60x1VxdhVXcRVX8QGjkEklYY0l5oSkAUnCGCNjSkjSgqHkSBKhazv6cVSJdcDVGaGcElPXYroDGuPpXEMGjHjmzQ4hjIyhJ5XMehgoUY2JnXV46xBpiCYS4sA6LClZjZJTKSzjmkm/woqq+mUgk0lRlR9DGlGfY6FxDblkQhhJueCMEGImp0QOKnoR3YhzHdPpTIuIELDW0gbHMA44bxH//2fvvuM9K+rD/79m5pRPuWU7SBcUQYkKImADK6DGJGBEDChoVGxJiIlRv9GghqDYjYqgIljCKj8bNkQs2OiooAJSd5et7O69e8unnHNm5v37Y87nc+/K0gTCJplnHoa9955e5sx7ak7XWrxICEhF4aTEexfmXktTUqfxtqLwJVZXOJ1gJEN5obR9Ci8kaJxUISTTCSbRNJMwL1tZWXrdDrbs00gzRIHWCUqXOITEhiZ4qdEUpcdWlqIqUGhSYyiqkqoIk0MnDSjFopWmmeakJsPhGW+MUZUlnapAYbAKrC3puYKi6KAViDbkJiM1KoxKiccqIVVhkI7ShdotheDFUoknkSQ0KSxKirIK/RQFUpOQ+BRvBCWC12FsxcI50qxBalIqccyUfYxSOEKfN1fOUrmKfhECxsSkeFtSlD20CQPUKG3IEkMz95R4lLekWmOSHO3AViWNvEFiMppopCpBhZEqlXGgIMuSYb89k2jSxNBotWjrJlPFLFWV0ExyjFY4Cfc/MylapcxWM6Q6I9MN+mVBURUP01sbRVH0P0MMzqIoiu6nVtImaYQmYZU4JjszGFFY8aCEZtZCa01Og27ZwxlhfGQcwVMUfQShrCqMMixojqNyqOqJhUWEylucOCrl6fsizJFVegrjQBRJTt0cTaMNNNKcJNWhFgghNW2seMqqS2k0SZKFgTzKPpWu0N5RFn3Qnjxrkag0zHcmHhGwVqjKisqG5pVapYClqmZpmAyTKZwKw8O3khZJaijFkaAYSRRGGdBCv+pQFn2cBZP2yZoNlNJYZyldBYlC5R5VeYzTVFWFUgqTNhCpBzdRnobKwvkUs5RVD9uvoNLYRo5OEqwKzR5LEVqmyWjaAB+G4GhnOZUrqWyPRDXQxmC1YIsOGPCJQYkn90KqQtBrxOBEY8sClao6CC/CZN9KEKXw3uK1prBVaPanDLkyiBK0U+AsfVfiETCGJDEYbTAoRFd0ywJnK4zRJKmi50tmxZEmGe1mi5GsCTrMvZZmOSlCgsLhwvx2aYaqJ3UuqpLKTZEag1GANkgIC7G+DpJ9Gdb3YXJy6oBd65w0baC0pvQOoxJMEpoopkkWJjpXKQANUlKT4Op50hKlSbym9ELPOxJlSNCkRqNMilaaTBo0TUbDNNBKh6kAoiiKorsVg7MoiqL7qdft4Yo+Ujl6RZeJziYWjC8izZroxNDKGqQmR8TTtxXdssdo3mK8Pc4U0K0K8jTFGY1zGrxQ2AII83CJ0fSlxIoNtSTWkjVysrSBOId1oT9bzxVkacZY2iYRoV8VVN7TSlMyndMve3T7s+RZg74tMQKJSD3BtMJqoZmE4fE7/T4oRaPRpOoXON9HeRUGgVCCs5ZUIFVNJDE4NKkOfb68ByWGLEmwVYFBKLEUtiRVQtJqUPrQ580Yg5USrxzKG5LSoNMwZ1hZlWQq9FFSTuOcwrqCTmWZ7s/QrfqkWUozzWmkTUoRnHPgpsPk0lkTlZi6NkyRJJrcZGQ+ZbI/zbSaIjNN8qyBabRBPM4XlLaiLHo0TE5iErpqFi9Cz/bpU2KUCf3WALxg6qHltdcIHqPDyIUK6FUlXnlybWileeg/BiQYDCmVLXBlRW92htl+hzTNGGm00GkYLREFqUpJVIb3PXrVDH3bp5HktLN2PY2DQbxDKY1Tjp6vSLwDp1EmI0nDBOB928OYMMZ9agxFKaTGkCZpGKFRJzSSRriWvqJfdkhUgk4NaDD1nGhKmTDqIyoE8mJJ8gZJkpInbfr9Lj1f4HCk2mAQtDIorRltjpPqJPS1RChczHZEURTdk5hKRlEU3U8TG1bTn57CiaFXVfRklka7RT7SRpRQuBK0od/v0imm0crQdQUt1yA3GUVVkqgwcEJRlbSzFjrN6VddUmXCIBJVAU4wXqFUiqsszlRhDqowekUY0t1ZtAkzMFtvw4AUhOH2la6gzsh7X4H32Cqsg9GkZGBDUCG+ovCCVQoQSrGh+WTSxOOx1uK8gjRBiUG5WRQZSoVJsYuyJPUWrUyYKUxplFFkaQPTyNDWYCtLWZZUrsAohfKC1xat8zDJsoPS9ul6CZNjVxXaGJLUoHVGliqct1gf+kGlOqHwoalcnmYsSDJGkpxUabzWZCb0d3PiyZIGTnscCqWEZpaRaE2nV9G3BaUkOAepqUiSHBSYJMXbCpeA8QblFd1eCGJTrTGpRZQikxSTgNEaASpX4r2inTUwKgHbp1cVeNfBFxWl7ZPolLHWGD3bp1N2aSYjjLdH0CbBKyidDfODKU1ZlCgHrvAYo9ACCo/XGu8dlbOU1mKSjKYkpAjeFwglYgwqCdMJiA6TdjfzJlmSIUaTmZQkzTAqIUsN3oaBa0hSKm/DzwpMmofpAaouoGk2FEmSoMnAW7AeVEaSJBRlHy+A82GETu/oVX2meh36tv8wvrlRFEXbvxicRVEU3U/eFeAszfYIC3fYgUIVJFmCUxWlK6FUOA/dYhZrLaPNNqlKmKn6IGHY+KqqhjUuIp7RvE0rbdAvuvSKDoUtkUpoJi1ajSbOh35LzSwnSzOsrZAko3AlvaJgNG2wtDGKdxV9BJxFGx1aPypo6RSvLJVUIZiyfZRolCgsULqSvrNkStHQGVluqMo+zqcIGq1SlHGUvguSUNgu/aqLrmvOrC3pF5Y8z8myDO9LtAaNJpE0zMslnsJ5+pUlFUU7aeALh8scWaNJmuVUuiBNNGnSYFZ58mYTtGKMBmk2hrMe6yxZkmKVYIuShJRcGhinMUaR6aQOoFIqQKyjlTVQSYrXiqLqIwINnaLSNlVaolRCIx3BoFEIzjsqcZBoev0upfTIdY7WmkIsmc4prUXplNSk9MsSNKQmNNvse4fHY5ShtCVlVWCdo7IFaZLSbI2SJRmNosOWYhan65H/vadbdEm1ppnktE2bwlT0iw6CxXuFx5NpQ6IU1kFDFF4lKDSFK7GEvm/g0WJQ1pOJJs1H8PUon0XRB6VRqeBQNNOMZtrAmxCIe1eA2DDlgq0w/U4YTt97xIdBPZpecN7TL/s4b4fD5isB7x1aoGe7oBSz5SzTZScULERRFEV3KwZnURRF99OChTtQNsfpG49qahLVxIunb0t6/S5Ww0grQ+mcRgOyNMFKhSsKjDZh0AgFs74PztH1nn5V4oFu2aHv+mgxoV+R9qHGx4B1HiUWTYKoMDiDMSld28dJRVMZnNb0bMGMdqA8lbMURUECNJKMJE1oZk10qen7KvRLQrD1aIZiIMlSdNpGjMe5CvFQSYFKNJUSFIZCKipvQ42SFYqyworDJyqMYKg0SoTKFfSLkjRpYitH4jSjuoVgw8TGiaJre1SVxytHkmVkWTMch/GYLKfdaCP1iIgu8bRoooymU3bBOqz3ZM0FGJ1QVhVohbUVaZpijAkjY3qL0TCSt2iZDFuWod+fThlvLcR5z0hjBPHQr7pUEiZpbmdNxhrjdHsdKluBNlhr6YsNzfvQJOKoii4qSUhUG53kqKpHZUus1AGT91R4dJqRmJwsbYUJshEysSQ6TMdgBLw4UIbMZOhEk2pDv+zQsyWNpEFT51hb4ssSVxU458iyMG/bVNnBIrQbLdIkIzEm9BOzFus8mcnwXnBVRSkFvaKD7me4RouRtBmG9kfRTNthegaV4HqzdPsdnK5oJTlOeXrdSSpb4hX0bXiOtFZUVRlqfr2jnbXC5NRKkYapvYf916IoiqJti8FZFEXR/dQaG6fRHiUpu5SqDEPSSwo+ofRlGDGxrEiMQZmUEg8eChuGmBed4r0HBZUKA4EkJqUsS3pFL9RCGEWpw4AcZX+aNMtIk4xCSqS0NJTC+opSPAZD31v6HhBFZcswel+akHrFVNmnciWLsjFUpmmkBpKMXHLEGPquR1O3GDEZOgn9kLyt0ImmqmwY7MQl9H0fpx3ah+Z1RRlGI0ySlLYawZiEXjlDt9clyzKaSYqIY6bfIfOWXGWhr5PSFFUfW5UUziIlKCsooyAxVL5CEJSGXtlFJWGOt7IqccqTChiBkWyE1rJxOmUHZTQmSXFFwXQ1i8eTe0diNKlOsRIGsGiYlMpD385S2T5Z1qKRteiWPbplj4ZJwxxouu5nlqTkSQOjFb2qj3VhnjTnq9BcFI1VDqMy8IqEBJUa8iSjsgXdfg+FIk9CXzmtNUYMqU7ITR4maFYGJWGeMXQYkTM1GcZoEI/oMIGadRU2yRGTYF1Bt+yiCkuj0SRLw1D/idJYb0EUxkNRdSkrHwJxUeQqR4UZzUh1SlH1sLbHZFXQz7sYCc1tR1tjJJkJI4g2WnjnsFWBd5ClOdZ5ekUXpZMwDYI4KhyF91hX0ZOCxCSMNkfQzuNMRiNtYLR5mN/eKIqi7VsMzqIoiu6nTn+WVqPNWHuUTjED9cS7XjyjYwtxzuMqS+VL0jQhVQnNNEOLYqo3jUsaaKNQxpCZFj0qrNY0GiNYgdRVaGXQKvQfU7qepVnCUOuWCpEU7yoqX1I4hxeH0RmNdIQ0TSnLHuI9zbTNSN7ASUpummQmo9fvMzGxAV16ktGcpN2i3V7AaDZCYgxeNIXpkUuGSyu0hGCq0+mhVDieBglZc5xZV1J4hylKjCSkCsSHGCPRBm00TZOitITzTUyYO0wKir4nrfum4QVBYRNH1xWkpKQmQ6RkcnqSftoFo0kaGSTUTTxT2lmbkWaLLZ1JymIWVU/QrVBIpbDWUqiK0niqfkUmiqIsmOnPUtoe4zoJ+1GKmWIWaxphcms04jyl72NLS8+VlL6inTYxGGZnOxSFQ2eOJNO0slFEhKIsaSYtmnmbZtpCEYJfpXWYdFqDuDDJs0lT2lmLFinWWXq+witCAGcSnA/95Xq2j8WjjA61qgY8FpuEmrAkTVFJ6O+W5c1wD4DZahZbdfGUeGPIklEq10dEyHVCphKSNMUj9GyBLx2JTijKisIWNNImlVT0XEFpSxDBKkHVtcSOkjxr0cjbANiqQpRDiaZbWXplHzBUZYH3oQ+dSvXD+epGURRt92JwFkVRdD8VztOf3cLC9hhKp1hv8d5hkoRW1qIoC3pVl4bJUCjKoqCsCpyCSjsEx2g6EmqovKNfFRRVjzwfZ1FzIZ1yBrQiUymZSvDiqFSYjLjhDJWAVaHp22g6RkGPXtnBUlL6PstaS0i0wioYb44xKm0QIddhcI+e6UOWUFQ9jIMsbTCSt8mUQcRTuZJ+1WU0GyFNTejfBlTWkqiMhY0FoV+RErQtmOxuoeM7JDbFiCLLUrIkRZPgnaXqO7xYkkwoE8XYyBiNZgsnnqoqSLKU3GQ47yl9hQPytEme5IAwW3XoSUXD55hKk5gEnUDl+myenkGcpyj7VKqilY2QakNlLb2qi9ZC6St6ytFIc1Tf4pyj9KFJXmEr0tSSktLUGbO2A2JoqZSchDBaoSc3IbhOMCR5A0UGegZtwsAkymiaJkNpAyKICM1GgzRNmerPYL3F+ZKqLMIcZtKl3+3Sci0aOqfyFutLRCmSNKXEYcsSpUwIhLwnMyniHb2qR+Es6DC4SR9Lr6jCRNdGk5mMoiyoJAw8YyVB6wQxCZVYMhWaeipCQIdSmCQlMUmoObRC5RyiCjTQ63XpSp9M59iqh+qHQU+c9uAtibM00wZ5PaDIjHXkOgk1gfVANZ1iFisOXcZsRxRF0T2JqWQURdH91G6MMN2boNvvkKatMJy68qQeQLCuolvO4NKMRtqm9B6pLD5VjLUWMpI2SVVCnoT5u/CeVKWUZUGepYw2xvEKMh2aBiKWTtVFgFaWU1QlfdvD2YI80SxsL6adjgCakhLnPM20RdZokKiEvi0wKEpbogi1Jrsv3Z1yUUmuc0yWk5kUbAUmZazZIjMpVVminApN17wiMRkiHiVCohKsdiRpRpYkFLkm8QnKKnq2QpOFebeylGbDUVaWxChMnuCNJssyFmQ5ZVVhpQJRWNtDCUjhcBR0TUXpKpxoiqpClGAsNDAkjYxO1WWm1yXXCc20SU4DQei6LrMzXWy/wqCxCtJcIy3NrPUkSuGUw+iELE3D/q2nbwt6rkuqM0hy8ryJ9prKFaA0icno2wqdQNLIWNxcipLQL8+6PoUI2oQh7Kt+HxFLnjRIlaYUh1IJKhE0GoXG2orZokup+kAa5kgTQKCwBaV1JFoorKVf9Ei1IUsytILMOLwXjNYUriLRGq2hqvpopciznEQSBE1RdcME3UrCyI2VxTpFpRUiYcRJj9DKW+HYjMFjMElGqhTGJVAqSilxTsh1qK3TSlE5y6Sboih7IRCrKpwvcVpo6DbGaPI8w5k2/bKkKDsP56sbRVG03YvBWRRF0f0kviJLwgAMzlYkKmSS+96ivGYkbZOOJcyUU9hEsaC5EOOF2aKD8TCSjuDFUnlwriJVmjRtUBrIspxGllI6S542yJMMVxUkSYoXjzhHog0JCYWHzdMTLPSKdj6C8pDqFDQkOqOZjNDtzNDpz+KVp7AFifM0shEaaRMEOmWXhq/I9BgmycEI7bxNnjSYLDdSuj69Xp+p3gzNtEkjb4UmfyJ0ej3SrMFYNkamktCEsNdHOSFJ6oE9qpJmq0HLC8po8mZOqcJk141GTrM1Ss/2KPodGiantI6iKpjqd9BovPdYHKSaylZ0NZgqpa1zcjKssWRZk2bSwPqKmXKGbr8bBqawDjEJOk3wWqOShCzNEe9xzpHn4Xwcjr7tYCVM1Bwmk4aO7ZNKQq/qY8SQZTkOYbaaxTtFrjMWZC0wmqqAvuvgRaFEUZZ9pr0jSyqcL7CuxJgGzaxNZhKsczSyHOc8/bJHZXtkWQ5ah6kInKNwBbOlo6wKxDsKSkZTTZ608M6ipMRZRykOY1o0TRtfWWxZYDKwVBTOUVmLdSWVsyQ6BNjT/S3kSUqetUAbkiTB+grrofSONMvxwGR/il4xQ4LCKgn9GFWK8iBi6dtemENNh4mtTZrQ1A2ajRGazSZWKmzhaGoNKCrbe7hf3yiKou1aDM6iKIrupzAMBOABBaUtybKM1KRYa7FVRSPJkcZCkiRlrFH3yUHY0t1MppIwbLk2OAHnQWNp6JTEKNI0IcvyUPuRZpR9FQZj8AndYhrvLK4q8dbRqyxmZgotCiWCKIVOU1Caju8yObM59P2inkesKqncFP2yjyjCPGiFw1dVGByjPUZlKvpVj8JVYY4z5cmynNF8hLHWQvo21C6V4uj3O2SSMJ6OUKQek2aUtkQnGg1YLM4IeZrSyJp4LfhqFqUMpfXkCbSSJqXvUE1X5K0cl3lEFLYsEQwGyFRCq5mhFPTLbhhCPkvAe2Y605RJn0bawPcdridkqsHoaIJJDCbRWB0GGMmTUKOETurgT3CuxPuKJDEkXpORhEm9bY+JqiBNW2QKBIdJE4w4rC2Z6M1giw6tRpsKT7cq8M6ToqnEkmhHrypw1oJSJAp8VWGkidIK51wYGAZAhF7ZRYyib0NQ2i/7YfJu52iaFJTgfUmi21RW07MlmU7JTI4Tz3TRoXAWbytKF5p5OgHxBrTCU2EJTS5L70hcmPy7mTVopDnaCxPFDD1Xon2B0Zqy6KOcI03CZOdpmoOHqd4siNA2bZSSevLqjEQltJMWzawZBsYRR+k9OF9P0P0wvLBRFEX/g8y3fIQAAQAASURBVMTgLIqi6H7q9Tqh5qLyNPM2RilynZPmDWxSMjU7Tafbo9kaoaXzMPmyt/RdhRWhX/XAO5rNUfJGi6LsM9vvkGlHAhRln0SlYeA+73C2oNfv0i26YY4vnWF0jtGOhqpITQ5aUVoLosm9IW0kVLagrEpM2kRrReJSKtunTLtI6Uh0TmpCBr3fL+n3+5S+oqjCfhLROJ3QaLRJlQcSKqlC3znbwxnBp4aisPTLirSRk+cNKilwtqASg9iQMRcteHEUrqLb6aCcoFNDoRKStEmv22Xj+o20201GF4+T5k0kTfGJwinBiCdLMoxOsNUsWzpbGGWULE1JtUK8UJRdCtdHvCfNcvJGC6csU71ZxFqyLCcpNa20RaKgsl0myz4NY/BhZmdEQ9f2cP1pMAavHTlNmjql8hXaZIxnTWacp/RCtyyZdRUWSwK0yCirEBiZ1KAw5FmOcw4rFUqEWdtBI4goNGGgEDEJzhY4b0GFqQgyDFogVYrKORSWQjtG0hYNEkrRpGJomAYWT+ErrAJnFFnSYDQZw6Moy4LU6BDcaY3zgsrCuVY4Ggoqscx2p1FKYbSmW84CCkNCI22jhNBHzQEiGKUZyUcYzUbY3JukcH2M1ngjYLtUzuFxFFWPUkrEC955lGQP67sbRVG0vYvBWRRF0f1U9Qp0v4PqFpB1UM0RLDkmadBMmmQjDTpVH689trRgHT0pmJ2dptObRWcOaYaahRGtAEen3ILocXJX0u2GwSKqqkd7bCHaZFhn6ZYdqqrPgnwco1NIFI1mg9ykmCSjwJGolGbeCvNgUZGkGq8Fi8eZCpeByXK8C8O+ayth4mzr68EfOnRsGF2wlWRonZCbFNEKEU3P9sBbRBK6/em6qaTCW4emQmc5ymr6VY8k0WgxdMsePVcwKh4nlrJ0dLbMYLIEpRWJ6SIuBFSl8xRFQWZywAAuzNWlM7yTMEWBSmkkHlEeqyzOW0YbbaxzuEoYbbcZydo4L5S9EtevyMTgeiVTspEZbSBLkERIswyyBiqFSvqIEfKshc8VpROUEkrpoStHnwqlDBkJnarHlnKadjZK6jVSzNJ3nma+AOMFlKKtMlqtEfK0QafosKU/UzdbhNl+GBjEe0tumhhjcJVHJMxplyUZmUoopKBSBl8VFJXDW03HWMbTUVJy+mWJVhaTpDSNwTlLAei8RTtr0zB5GDnU9sGAV2C9Y1pZLB5MQuktnapH3/XJTUKY5UEQW4EStMowHnr9Ll4pUm1CLW3dHNT5Pt4BvsRqmPHTaG1IFHSKWZwNfd28KHCx6iyKouiexOAsiqLoflo2upRuBU478jSnNTqOaY1Soug5Cc3HdIWzluluh17ZZaS1kEQMqlQ4PF3VY7qzhcmZCcZGluAd9HtdRpIGWhtQiunuLD3xjI0uwHmHwVBh6FQl4+2M3DToK0XXVfiyT5olJFmG1hrvLCKetNnEW2EkzSBpU3mPKEtR9DA+RZynmY3gs5KyLBHvEK8gAZ8o0iRDGUPpKhQe7yuqqgIqqn6JFk0ra6EyQ7eYRUloXqidI7EWkwgm05QKurZAqoLUh6Z0Ng3zeokRsmZOq52DhD5X1jpQ0Ol10KlhvD1Gv+zR65c0khZZ2qzn/rJY75gte2SNFmMLFpCJoaEauKoC2iTKUEx1WblyBb3p6VBT1c4YW7KAJTvsQJE3wEEzHSFJDKUvydMGo802ooR+2ceYJg2x9G0Xpw0ojXUl/WKGRjZCahoYpdA+1KJqY8Joj2WFF0XiILOaShxJYmimDbSHjvNoZUgxJCi6ZUnpHdIQEkLft1QSmknOjDfoVJGbJh6N81BWjn41TZ7k6CTMl9bWGaZydOwkZZKhVUY7yTDGUFJhtGapXoBKDKWEgWKc9yidkKQ5uqooncPkCWP5EhqmQbc3TUPnGJ3QNjnKCDpRZCYjz1J6laVbdul7y0hjBKMVtirJVUaXDq2kRZo2Ka083K9vFEXRdi0GZ1EURfdTmSVUI+0w7Hojw6Sa8TwjSzNmyi7WgvaeXtlnujdNUfZIGy1GF46T5SlJkpLo0H/MKU3ebLO42aTXn6GqSpLM0GqPofImIkKr2aRfhsmpR9JRnLP0yh5ZktLIMgoLWdYiScJQ+D3bxWuPwqC9p0sXLY6mtElSg3WC1gkFBaUtWJwsJU1T+lJhRMhTg6Q5Jk3Js5S+7VO5igYpI9kofVMx1Zuo59TKGRsZR2lDVo3S73VZ3F5ENqqxU5toAtJoscmWTExN4pyQpJol7YV4pZkuZ0Mti07RXsJ8Z0oobBecRmHwVUW31wnD7LsClTXQJqFv+xhjGM3GsN7h+o7Rxgg6gelyhlwntFojCIrNxQQr1qyj1y/xRrOIcUYXhdpDo/RwEutm1mR6ZobcexLTJFGKhgmDm1hf0bM9jNKMJW26KjRpHW2M0ExH8EpT9Wbp97p1E0WHMYZmHvreFbYgIUUnGe20hRehEk9iwnQF/X4f8UIDg7IO0Zqq38d5jzE5o2kb0WCcolf2mO3OhsFNrEMoaGZNWq12GOFTGTrVLKIcaarRKkWhwZehqWTaJMszyqqi6xztbASMITUZaSuhL2WYKDtvhAnNlYR+lg4aWRtPhdKe1DTJk1GMmUFpkLLDWGOEXBmm3BReN8iyMJG3UgmtPGY7oiiK7okSkViMFUVRFEVRFEVR9DDTD/cBRFEURVEURVEURTE4i6IoiqIoiqIo2i7E4CyKoiiKoiiKomg7EIOzKIqiKIqiKIqi7UAMzqIoiqIoiqIoirYDMTiLoiiKoiiKoijaDsTgLIqiKIqiKIqiaDsQg7MoiqIoiqIoiqLtQAzOoiiKoiiKoiiKtgMxOIuiKIqiKIqiKNoOxOAsiqIoiqIoiqJoOxCDsyiKoiiKoiiKou1ADM6iKIqiKIqiKIq2AzE4i6IoiqIoiqIo2g7E4CyKoiiKoiiKomg7EIOzKIqiKIqiKIqi7UAMzqIoiqIoiqIoirYDMTiLoiiKoiiKoijaDsTgLIqiKIqiKIqiaDsQg7MoiqIoiqIoiqLtQAzOoiiKoiiKoiiKtgMxOIuiKIqiKIqiKNoOxOAsiqIoiqIoiqJoOxCDsyiKoiiKoiiKou1ADM6iKIqiKIqiKIq2AzE4i6IoiqIoiqIo2g7E4CyKoiiKoiiKomg7EIOzKIqiKIqiKIqi7UAMzqIoiqIoiqIoirYDMTiLoiiKoiiKoijaDsTgLIqiKIqiKIqiaDsQg7MoiqIoiqIoiqLtQAzOoiiKoiiKoiiKtgMxOIuiKIqiKIqiKNoOxOAsiqIoiqIoiqJoOxCDsyiKoiiKoiiKou1ADM6iKIqiKIqiKIq2AzE4i6IoiqIoiqIo2g7E4CyKoiiKoiiKomg7EIOzKIqiKIqiKIqi7UAMzqIoiqIoiqIoirYDMTiLoiiKoiiKoijaDsTgLIqiKIqiKIqiaDsQg7MoiqIoiqIoiqLtQAzOoiiKoiiKoiiKtgMxOIuiKIqiKIqiKNoOxOAsiqIoiqIoiqJoOxCDsyiKoiiKoiiKou1ADM6iKIqiKIqiKIq2AzE4i6IoiqIoiqIo2g7E4CyKoiiKoiiKomg7EIOzKIqiKIqiKIqi7UAMzqIoiqIoiqIoirYDMTiLoiiKoiiKoijaDsTgLIqiKIqiKIqiaDsQg7MoiqIoiqIoiqLtQAzOoiiKoiiKoiiKtgMxOIuiKIqiKIqiKNoOxOAsiqIoiqIoiqJoOxCDsyiKoiiKoiiKou1ADM6iKIqiKIqiKIq2AzE4i6IoiqIoiqIo2g7E4CyKoiiKoiiKomg7EIOzKIqiKIqiKIqi7cD/yuBs8+bNnHXWWdx0000P96FEf4LB/bvmmmu2+v26dev47Gc/yxVXXPEwHVkU/d/0P/3d+5/+Tbjppps47bTTHtJ9XHzxxXzgAx94SPcRRX+Khyr9+d3vfsf73/9+Nm/e/KBuN7pnl19+Of/2b//2kO7jiiuu4D3vec/9Xq/b7fK1r32Nr3zlK3e7zK9//WtOPfXUB3J49+pBCc6uvPJKdtllF4477ritfi8iPO5xj2P//ff/b/0oLlq0iB/84AesXbv2v22f25tut8sTn/jE4c933nnnNv995JFHcttttz3o+5+/j7uzcePGbf5+0aJF/PCHP+Tmm2/e6vc77rgjF1xwATfccMN9OoaH6ty2xTkXE/j/xe644w5OOukk3vOe93Daaadx2GGH0Wg0HtZjOvvss/nSl77E0572tLt9lx4s9/fdeyjclzTl7vzxN+EJT3gCvV7vwTq0h9wee+zBf/7nf97jMt1ul06n8yfvY+nSpXzyk5+8z8vvu+++TExM8PznP/9BWS767/HjH/+YZcuW8exnP3v4zbrpppvYd999ueiiix7WY/v3f/93vvjFL97l9/eU/jyQ7/yjHvUoTj/9dGZmZu7Xej/96U95zWte8yft8+H0YB732rVrOfLIIznwwAM544wzOOmkk3jnO9+J9/5e191nn33493//9/u8r263y7ve9S7+6Z/+idNPP53jjjsOYwyXX3753a6z5557csoppwx/vuqqq/jIRz7CS17yknt8zlutFrfffjsXXnjh3S7z6Ec/+iEPzpIHYyMHHXQQRxxxBOeddx633nore+21FwDf+c532GGHHdhtt93Ye++9H4xd3SdKKUZHR//b9rc9arVaw1KmG2+8kXe84x189atfZf369bz85S/n4osvBuCCCy4gz/MHdd/z93d3PvjBD7JkyRJOPPHEu/xNKUW73d7m7xcvXnyfj+OhOLdtERFOPvlkXvziF/PMZz7zId9f9N9r06ZNPOUpT+GLX/wiz3rWswD4f//v/3Hsscc+rMf15je/mampKY4++mhardZDuq/7++492O5LmnJP/vibcOWVV/63pA0PlizL7rEwoKoqjj/+eD784Q9vM+28LxYsWHC/lt9rr70YHx9n2bJlD8py0X+PZz/72Xz1q1/lRS96ERMTEyxevJirr76az3/+8xx00EEP67G97W1vwxhzl9/fU/rzQL7zjUbjT8orHnbYYRxyyCF/0j4fTg/mce+0004ccsghrFixgje84Q0451i0aBEHH3wwf/7nf36P697ftOaoo47iqU99Kh/60IeGv3vyk598j+ssXbp0q59PPfVU/vEf/5E3vvGNaH3P9VJLliy5x7+PjIzcyxE/cA9as8Zdd92VY489lve9733D3/385z/n0EMPHf7861//mn/7t3/jrLPO4tRTT8Vay7vf/W5e+tKX8qEPfYj99tuP3/3ud1ttd8uWLfzDP/wDX//613nFK16B954LLriAQw45hM985jM8/elP5/Of/zwA1157Laeddhpf//rX+e1vf3u3x1qWJc997nN517vexerVq9lzzz05//zzAXjFK17BunXruOGGG/jwhz/MV77yFU444QTWrFnDypUredrTnsapp57KW9/6Vp71rGfx/e9/n3e84x085SlPoaoqVq5cyVve8ha+/OUv86Y3vQmAT33qUxx55JF84hOfYP/99+eHP/zhVsdjreXv//7vueCCCzjuuOOYnZ3l0ksv5cADD+Tss8/mGc94BmvXruXMM8/kjDPO4K//+q/vUkL6uc99ju9+97u8/vWvZ8WKFVx99dV87GMfA+AHP/gB119/Pd/+9re58sor+c1vfsOXv/xlVq1axcc+9jE2bdrETTfdxJ/92Z9x1lln8bKXvYyTTjoJgImJCf7pn/6JL3zhCyxbtow3v/nNdLvde7w/8/e3LTMzM3znO9/hiiuu4He/+x0XXXQRH/zgB/mP//gPzj333OFyP/nJTzjmmGPYf//9+f3vf3+X7Xzve9/jvPPO401vehOf+MQntvrbfTm3bVm9ejUvfOEL+eAHP8gBBxzAHXfcwRlnnMEXvvAFjjrqKK6//nqmp6d597vfzQUXXMBb3/pWNmzYwI9+9CN+/OMfc/vtt/P5z3+ez3zmM7zlLW/hoosu4s4772TPPffkkksu4YYbbmB8fJwVK1bwzW9+k8MPP5zTTz99WJoz/zp0u13e9KY3cdJJJ3HqqafyuMc9jvXr19/tsUcPjbPPPpudd955GJgNDGoy/vg+rl27lve973187Wtf45WvfCW///3vWbFiBSMjI6xYsYJLL70UpRQAH//4x3ne857Hv//7v/P4xz+eM8888y77P/fcczn//PP5wAc+wDve8Q4gZEimp6f58pe/vFWt2cqVKzn88MN5xzvewd/8zd/wlKc8hc2bNzMzM8MZZ5zB2WefzV/91V+xbt06nHOcdtppfPOb3+Tkk0/m61//OrOzs7zxjW/kVa96Ff/wD//APvvss82mRPf07j0U6dn8NOWBfhNuvPHGYRPBK664gr333psvfvGLvOAFLxiWht5222287W1v46yzzqLVavHe9753q+PbVjr/6U9/mmOOOYa3vOUtnHzyydv8hlx99dXDe3/eeeexxx573ON38Ctf+Qqf/vSnWb58OZOTk9t4OoNVq1bx85//nG9/+9ts2LCBE044gVNOOYXDDjuMq6666i73A+CMM87ga1/7Gn/913/Nr371q6229/a3v51PfepTbNq06W73+c///M8YY3jta197t8vcn+Wi/z6HHnoob37zm3n5y1/O7bffzvr164eB2bbShampKZ72tKdx7rnnsnLlSh796EdzySWX/MnvT1EU/NM//RPnnXcee++9NyeccAIrV67kS1/6EpdffjmbN2++yzO8LfO/8845TjnlFC688EJe//rXb7Xc3aWL820r3frOd75Dq9Vi9erVVFXFy1/+cu68806+853v8LWvfe0e392zzz6bT3/607zyla9kn3324ZJLLtlqf9tKH+5PXgXgP/7jP/jBD37A8ccfD4T864knnsjExASHHHII73//+4FQkHfdddc9KMd9dwbXaI899uB973sf559/Pq9//ev5zW9+c5d81bp164brffSjH+X000/njjvu2OZ2r7jiCi6++GLe8pa3bPX7N77xjeyzzz7Atr+R81122WXcfPPN/PjHP+baa68lSebqpX77299y1lln8ZGPfOQuz02/3+clL3kJ73rXu7jzzjt5xjOesVUe9X3vex9Pe9rTOP7443HO3afrdJ/Jg+SUU06RG2+8URqNhtxxxx1y2WWXyTe+8Q055ZRT5IQTThARkQsvvFAuu+wymZqakj333FNERM455xw59thjRUTkrW99q7z3ve/darsrVqyQz33uc2KtlSc/+cmyatUquf3222WnnXYS55xceOGFcsQRR4iIyAEHHCDdbldERI4//nj5yU9+crfHe9FFF8lRRx0lIiJ/93d/J+973/tEROQTn/iEiIgccsghsmnTJhER+dKXviTHHHOMiIg84xnPkIsvvlhERA4++GC56KKLhv++6qqr5Oqrr5Zvfetb0u/3ZZdddhERkZ/85CdyyCGHiIjIpz71KTnppJO2Opbp6Wn54Ac/KN57Ofroo+VnP/uZOOcEkC1btohzTo4//ng555xzZPny5fLa175WLr300q228ZKXvES+//3vS6fTkc2bN8vk5KTsvvvuw/0fdthhIiJy++23D39vrZUnPelJcvvtt4uIyO677y433nij9Ho9yfNcRES++93vDo/37//+7+XCCy+81/szf39354QTTpBzzjlHRES++MUvys033yzXXnutPPvZzx7+/eMf//jwnrzgBS/Yar3JyUl59rOfLcuXL5dPf/rTctxxx221/ftybnfnGc94hnzzm98U55x89rOflbe85S2yfPly+dd//Vf5zGc+I7/97W/lyCOPlOnpaVm1apWIiBx22GHD5+1jH/uYbN68WS644AJ51atedZe/77777nL77bfLrbfeKkuWLBFrrTjntnkdTjnlFHnb294mIiIvfelLZfny5fd47NGD73Wve93w/R/43ve+JyeccIJ861vfust9PPbYY+Xqq68WEZFf/OIXctBBB4nI3H0XERkkvfPThltuuUXa7bYURTHcz/XXXy9/8Rd/Mfz5uc99rnzve9/baht/7LDDDpPvf//7IiLyile8Qv793/9d3vGOd8j73/9+Wb58uZx88slywQUXyJlnnikf/OAHRURkdnZWHvGIR8jmzZu3euY+97nPyXOe8xwRue/v3kORns1PUx7oN6EoClm2bNlwX4D0+3254YYb5DGPeYyIiHzyk58cfov+8i//Uq6//vqtjm9b6fyPfvQjeeITnygiIs65u/2GDO7b/LR4W9/BVatWyfOe97zhPgf7uTvzn6+Xv/zl8tGPflScc9u8H8uXL5fPf/7zIiJy+eWXy1VXXTU8nuXLl8uNN954j/uK/uez1spTn/pUeeYznyllWQ5/f3fpwvxv9vzv2Z/y/vz+978fvqMf/vCH5VOf+pQ45+TNb37zcB/zn2GRrfMM889h8J2fnJyUJz/5ybJhw4bhd3m+baWLInPvzbbeExGRF73oRfKNb3xDZmdn5T//8z9FROSb3/zmMF97d3nYJz/5ybJu3TqZmJiQgw8++C7Hc3fpw/3Jq+y///5yyy23DM/3xhtvlAMOOEBERD70oQ/J6173OhGRYV7qwTju+U455RQ56KCD5PTTT5eTTjpJfvjDH4qIyHve8x6x1srHPvYxec973iMiW+erRMJz853vfEeuvPLKe9zHl7/85a3SaxGR3/72t/KGN7xBPvaxj8lvfvOb+/SNnP/Mzvf85z9fvPfivR/m/88555zhdTrllFPklFNOEZGtn0FAZmZmxDknBx10kJx//vn3eB7314M6IMhjHvMYXvSiF/GBD3yAb33rW/zlX/7lVn9/6lOfyjXXXMMf/vCHraLMQZV0o9Gg3+9vtc7uu++OiPCjH/2IJEmG66VpitZ6uM6mTZtYs2YNzWYTYJtV4/M973nP44YbbmDVqlUsWbKE8847jx/96EfDZmnXXXfdMLo+4IADhjU3Wuvh7xuNBlmWDf89OzvL4x//eFavXs0VV1wxLCG9t3McHR1l11135Tvf+Q5KKZxzw2rX8fFxtNZcc801HHXUURx77LGcddZZPOUpT9lqG+9///s55ZRTeNWrXkWSJPep2tgYc5fq2TzPaTQaFEUBwBFHHIExhu9+97s885nP5Mgjj9xq+bu7P/fHc57zHC6++GJWrVq11fqDY3vWs57FqlWrtlrnpptuYmxsjGOPPZbXvOY1fOlLX7rf53Z3tNZbXfenPe1pHHvssZx66qm8+tWvZr/99uN5z3seT3jCE+5S4gzhmn3jG9/gzjvvvMfrobWm3W5jjEFrfbfX4Z6eneiht9dee7Fy5cqtfnfEEUfw+c9/nv322+8u9/Hu0o67M7i/e+21FyMjI0xPTw//9rvf/W6rJhj3ZXvzt/mUpzyF9evXc80113D44Ydz7LHH8pGPfIS/+Iu/2Oo42+02u+6667Dvxh+vP9+9vXsPRXo23wP9JmRZNvzd/Os1//165Stfya233sr3v/99Xv/617Pvvvtutfy20vlBujH495/6HAyO44orrmDRokXDv9/bN22++WnYtu7HL3/5SxYuXAjAwQcfzIEHHgiEGo3TTz8da+193lf0P5Mxhuc973nsvvvupGk6/P09pQt35/6+P4997GPZf//9+frXv87OO+/Mq1/96uGzOjD/Gb6ncxh85xcsWMDJJ5/MwQcffLf9he4pXdvWewLwrne9a1iT+OIXvxhg+J7/8XbnX4P//M//5KMf/SiXXHIJ55133l2O5Z7Sh/uaV3n/+9/PEUccwTnnnAOEPPj4+Di/+tWvKMuSn/3sZ1x33XU86lGPetCO+4/tu+++/Mu//Atnnnkmz3nOcwA4/PDDWb58OTMzM8PruK37+YEPfOBe+/vttddebNq0aasWW/vttx+//e1vGR0d5aabbvqTvpEQBorasGEDSimUUrzxjW+8T+sNjIyMoLXmsMMOu0se9YF60IKzqqqA0BfjM5/5DHvvvfdWwQnAySefzE477cQTnvCE+9RpEOALX/gC1157LYcffjjA3a43Pj5Op9Ph1ltvHS4XgtttU0rxyle+kpe97GW84Q1v4AlPeALLly/ncY97HABPetKTuPTSS4FwAwcfr3vz3ve+l36/z6GHHoq19j6d589+9jP+67/+ixe96EVkWbbNdfbcc89hk6fNmzfzox/9aKu/b9q0icsuu4w99tiDL3zhC1v9TWs93Ob8f98Xt9xyC/vssw8vfOELOeqoo+7y923dn/uyj/nLHHfccRxyyCHsvffe21xv06ZNHHbYYVv9brfddhs2I4Qw0tg9Nfv5U+2555585jOfwXuP956vfe1rXH/99bz+9a/nxz/+Mf/v//2/u5zP85//fI4++mh222234e+MMXS7XUTkbgOse7sO0cPjVa96FatWreL73//+8HeDj8Efp3Fw92nH4BmY/5GZr9vtsuOOO27V3v2JT3wiv/rVr4bp6/1JiyCMcvb0pz99q/Sj3+/z7W9/e6vjhJCG/3Hf4MH6893bu/dQpGfz36+H6psw3+WXX86RRx7JkUceyRFHHHGXv9+XdP7ungOt9T0+BwM77bQTV1111TBQurfjv7t0d1v3Y/fdd+fcc8/Fe09VVVx99dVAyKydc845HHfcccNCgtnZWaampu7xWB+K5aKH3raep7tLFwbpF3Cvz+69vT+bN28myzKOPvpojjnmmLsUwPwp7rzzTp7+9Kdz1VVX8fGPf3yrQq4/tq107e7SrQMOOIAdd9yRn/3sZ+y00073+XjOO+88TjvtNI466ij23HPPu/z9T81jzrdgwQKuu+46LrnkkmGzxNe97nW8+tWv5i/+4i948YtfzD//8z8P08o/9bi991s1RbwnvV6PF7/4xRx//PEsXbr0HvMyX/rSl/i7v/s7Vq9eDYTCoT9uSn3ggQfy3Oc+9y4DiGitUUo9oG/kggULWLly5TD9u+aaayjLcqtl7stzPzExwTOe8Yz7dZ3uzYMyIMhPf/pTzj//fF7wghcM21/+zd/8zbB/xbp167j++uvZddddee9738vk5CSLFy/m/PPP51e/+hU333wzGzZs4NprryXPc/r9/rDz87Jly/jWt77Fbrvtxu67784nPvEJnvrUpzIxMcGtt97KlVdeydq1a5mcnOSMM87gZS97GUcffTTT09NcccUVPPOZz9xmBgpCpmt2dpYlS5Zw0kknbTW649lnn81pp51Gt9vlhhtu4P3vfz/r1q1jzZo1/O53v+Oxj30s69ev56qrrmKfffZhzZo1XHXVVey000586EMfIs9zHvvYx/Lxj3+cqqpYvXo1a9eu5eqrr+a2225jampqWIoxKOl4z3vew5IlS/jMZz4zLCX94Q9/yHOf+9zhCDXf/va3OfTQQ+/yoJ5++ukce+yxLFiwgGc/+9n84he/YGJightuuIF9992XNWvWcNZZZ/GqV72KdrvNBz/4QY444ghWr17NL37xC0SEiYkJrrrqquGoaL/+9a/JsoxPfOITnHvuuVhrecELXrBV+/Ft3Z+3v/3tw/397d/+7TYT3qc//emce+657LPPPuy222685S1v4cQTT2TDhg389Kc/5bDDDuPKK6+k3W6zYsUKTjvtNNavX8/111/PwoULOeaYYzj11FN59rOfzf77788rX/nKYUkwwIoVK+713Pbff/+7HNfKlStZvXo1v/zlLzn44IN53etexyWXXMITnvAEDjroIE477TRuuOEGPvShD3H00Ufz8pe/HAht+D/2sY+xbNky9thjD17zmtfwghe8gF/96ldcd911HHPMMbzrXe9i5cqVPO5xj+M3v/kNnU6HzZs3D49lW9dhkOBu2LCBG2+8kUWLFg0D4Oi/x6JFi/jlL3/Ju9/9bi6++GJ23nlntmzZwsknn8wOO+zA17/+9a3u4wc+8AHe+ta3smjRIlasWMFnPvMZAF72spfxd3/3d5xwwgk88YlP5LLLLgNCW/1zzjmHVatW8dnPfnarfT/60Y/mlFNO4ZRTTuGAAw7g8Y9/PM985jOH/VYvvPBCjjzyyLukcRdccMGwJO+lL30phx56KMcccwwHHnjgsC9Co9Hguuuu48wzzyRJEk499VTGxsYAhgME3HjjjZx66qn36917KNKzpUuXDtOUnXfe+QF9E5YtW8bExAS/+MUvht+Zq666ittvv50tW7awYsUKvPe8/e1v5z/+4z8QEU488UT+4R/+YXh820rnu90uq1at4qabbmLvvffe5jcEQiHMcccdx1/91V+xYMEC/vCHP2zzO/i2t72NF77whbzgBS/g6KOPZocdduCiiy66S+uFgcMOO4xTTz2V173uddx88820222OOuqobd6PM888k5/97Gc87nGP49BDD+WjH/0oX/3qV5mcnKTdbvPsZz+bF73oRZx11ll8+9vfptfr3evQ15/61Kce1OWih9Yf/vCHYT5h/vfwxBNP3Ga6cNRRR/G2t72NoijYddddueGGG4a1Vvf3/bHW8vWvf53vfve7lGXJgQceyAc+8AGuv/56JiYmeNaznrXVM9zr9YbpT7fbHQ6ANP87//SnP52/+7u/4w1veANHHXXUNgf6+ON08brrrmPTpk1ceumlPO5xj7vLe/L0pz+dLMs44YQThrWLVVVx5ZVXDt/Xu8vDdrtdnvzkJ2OtZXx8nDPOOIP99ttveCzbSh9uv/32+5xXgdDv6l3vehdPfepThwPxHXXUUfzyl7/ksY99LK9+9atZsGABWusHdNyzs7O8853vHA4kB2G0xmuuuYbVq1dz4403Dvt/aa0ZGxvjNa95Dfvttx8XXXQRf/u3f7tVvmoQDK1du5aTTjqJI444gnPPPZfbb7+diy66iLPPPnur8/zGN77Be97zHl7zmtew1157YYzhkY98JIcddhiPfOQjt/mNHBT4XXrppSxbtoyVK1fy85//nCc96UnDZ8MYw6c//Wle8pKXsNdee/GP//iP7Lvvvlx++eXceuut3HnnnTz/+c/nuOOOY8GCBYyOjg6f77/8y7/kk5/8JIsXL+aZz3wmBx10EJdffvldrtOf7EFtJBn9r/Pe975XtmzZIiKhffegzXUURQ/cfemfeX/dXdv6+2p+G/v/q975zncO++FUVTXsixBF0b27t/fnc5/73LBfo3NOPve5z8n09PRDekx/SrrY7XalKAr513/9V7HW3uf11q1bJx/96EeHP2/YsEHOO++8+7Xvh8P/1OP+3+hBqTmL/vcyxvDSl76UPffck0c+8pG84AUveLgPKYr+VxARLr300ruUPD4Q82t+DzrooPs9xP7U1NRwVMP169ez4447PuBj+p9oZmaGF7/4xeyxxx7stdded+k/HUXR3bu39ydNU974xjey1157sfvuu/Oc5zznIZ3+6E9NF8866yw+8IEP8IUvfOF+9fm01vKd73yHK6+8kl133ZX99tuPv/mbv/lTD/+/zf/U4/7fSIncx0b4URRFURRFURRF0UMmdlyJoiiKoiiKtjuTk5P813/9F9///vex1vLd73532I83euj8+te/Hs6VG/33i8HZg2zQifPunHHGGXz84x/nLW95Cz/96U/jcvdzuSiKHl6Tk5M87WlP47rrruM1r3lNXO5+LhdF/5cNmswdf/zxnHHGGbz85S/n9NNPv9vlFy5cyGWXXcbll19OkiT0ej3+67/+6x738bKXvYxrr72WQw899B6Ho7+vy91Xq1ev5vnPfz4HHHAA119//QPe3sNpr7324iMf+cgD2sZVV13FRz7yEV7ykpdw0UUXPUhH9n9D7HP2ILrxxht5xzvewVe/+tW7XWbRokVYa5mZmWHZsmVxufu5XBRFD6/x8XEWL17MkiVLtpqHKy5335aLov/LDjroIPbaay+e+9zncuKJJ/K3f/u3LFmyhBe+8IVbjWY43/zpReb/++4M3sXddtttOJfXA1nuvtpll104+OCDWbFiBY997GMf8PYeToORex+IU089lX/8x3/kjW98Yxxh+n6KwdmD6Ac/+AHXX3893/72t3nRi160zWWe8pSnICLceeedPPrRj77bbcXloijaHmmtefOb38xOO+10jwNlxOWiKLo3U1NTjI2NDQcfet/73seee+7JT37yE0466SSe+MQn3u9tHnvsseyyyy68/vWvf1CWezBs2bKFU045hcMOO4xvfvObnHvuuXzrW9/ijDPO4DnPeQ5XX301p59+Op/+9Kd55CMfyT/+4z/yzne+k7e//e2cffbZNBoNvvWtb/GmN72JZzzjGcPtnn322Xz4wx/msssu461vfSvr16/ny1/+MhdeeCFr1qzhda97HaeffjqPfexjueSSSzj00EM5+uijueGGG7jwwgvZeeed+d73vsdpp53GzjvvzCc/+UnGx8eH84YB3HDDDVx66aVMTEzw+9//nk9/+tO8973v5frrr+eggw7inHPO4ctf/vJWwfVll13GzTffzI9//GPa7fZwChTvPT/+8Y/5/Oc/zxe+8AUuuOAC/vzP/5yzzz6bD3zgAzz3uc/lpz/9KStWrOCWW26h0Wjwr//6r3zlK1/BWsvFF1/Mi170ouGE4P9rPUyjRP6v9FAMix1FURRFUfS/xWGHHSYve9nL5PTTT5cDDjhA3vWudw2Hqn/Pe94j1lr52Mc+Ju95z3tEZOvpPbb3fNYpp5wiJ5xwwl1+v2LFCvnc5z4n1lp58pOfLKtWrZJbb71VlixZItZacc7JJz/5SXnve98rIiJ/+Zd/Kddff7388Ic/lBNPPFGWL18u//Ef/yGnnXbaVtu11spee+0lGzdulGuuuUb23XdfERH5zGc+I/1+X84880z54Ac/KCIis7Oz8ohHPEI2b94shxxyiGzatElERL70pS/JMcccI1dcccXw2K21svvuu4uIyPOf/3xZvny5LF++XI477ji55ZZb5JxzzpFjjz1WRETe+ta3Do97vvnTFxx//PFyzjnnyPLly+W1r32tXHrppfKTn/xEDjnkEBER+dSnPiUnnXSSdDodOfroo0UkTGVw9tlnyx/+8Af5i7/4C1m+fLl89KMflZNPPvlPvDv/c8SasyiKoiiKoui/zeGHH86JJ57IySefzIEHHsjo6ChvfvObOfzww1m+fDkzMzM45x7uw3zQ7L777ogIP/rRj0iSBOccWmva7fZwmP5XvvKV/P3f/z3f//73ef3rX8++++7Lt7/9bZ74xCdy7LHHbnO7xhhe8YpX8MUvfhGlFPvssw8///nPKcuSPM+57rrr2HvvvQFot9vsuuuu3HbbbVx33XUkSQgBDjjgAN773vfys5/9bFiDOX/qgOuuu264/8F/f/7znw+bgjYaDfr9/j2e/zXXXMMnPvEJxsfHh9u45JJL7rKNG264YbhOs9nkVa96Feeffz577rnn3V6D/41iI9AHkdYa7/3w59WrV9+n9eJyD2y5KIoeXps3b77Xj3NcLoqiP5ZlGTvvvDMbN26k1+vx4he/mOOPP56lS5dulZ/aFu8969atu9d9PNDl1q9fj7X2T9omwBe/+EW+8IUvcO2113L44YcP1/9jl19+OUceeSRHHnkkRxxxBAB77rknn//85+n1egCcf/75d1nv1a9+NZ/+9KdZtGgRb3rTm3j1q189XP9JT3oSl1566XDZqqrYe++9t/r95s2bOfDAA9lpp5247LLLhscn9UxbCxYs4Ctf+QoAt912G1dfffV9Ou/59txzT84888zh/n70ox9tc7mdd96Zn/70p6xcuRKASy+9lD333JP/7//7/5iYmADg61//Os65B3xftmcxOHsQ7bvvvqxZs4azzjqLqqp4ylOeQqfTucd14nIPbLkoih5+p5xyyvDjHZe7/8tF0f8VV1xxBTfffDPf+MY3+OQnP8nJJ5/M6Ogo//Iv/4LWmrGxMV7zmtfQ6/W46KKLWLlyJb/+9a+54YYb2LRpEz/72c9Ys2YNq1at4sorr+QVr3jFve7zgS732te+lp///Of3uuzq1au57LLLuOyyy/jP//xPPvzhD3PCCSdw4YUXsmzZMr71rW/xoQ99iN13351PfOIT/PKXv2Tz5s38+te/BkJg8fa3v50DDjiA/fffn4997GMcddRR/Nmf/RlPfOITefnLX84TnvCEuxzfTjvtxJFHHslLX/pSnvWsZ/GCF7yAvfbaC4ATTzyRRzziEZx55pl89rOf5dRTT2VsbIyzzz6b888/n6997WtccsklvP/97+clL3kJO+64I0cffTTnnnsuo6OjXHXVVZxxxhn827/9G895znP4xje+wQEHHMCvfvUrbr75ZjZs2MC1117LjTfeuFVB1C233MLKlSv5+c9/zszMDKeffjrLly/n6U9/Oh/60Id45jOfydVXX83q1atZu3YtV199NbfddhvNZpN3v/vdHHroofz5n/85xhgOPPBAjj/+eJ785Cdz7LHHsuOOO2KMuc/35X+iOAl1FEVRFEVRFD2M/u3f/o13vvOdpGmKtZazzjqLN77xjQ/3YUUPg9jnLIqiKIqiKIoeRjMzM7z4xS9mjz32YK+99oqjvv4fFmvOoiiKoiiKoiiKtgOxz1kURVEURVEURdF2IAZnURRFURRFURRF24EYnEVRFEVRFEVRFG0HYnAWRVEURVEURVG0HYjBWRRFURRFURRF0XYgBmdRFEVRFEVRFEXbgRicRVEURVEURVEUbQdicBZFURRFURRFUbQdiMFZFEVRFEVRFEXRdiAGZ1EURVEURVEURduBGJxFURRFURRFURRtB2JwFkVRFEVRFEVRtB2IwVkURVEURVEURdF2IAZnURRFURRFURRF24EYnEVRFEVRFEVRFG0HYnAWRVEURVEURVG0HUgejI3ss0sbJR6tBMQggFagjUZE4b1HK0fHCt55cAo0GA1KgdYarRTiFRoQJYBHBMR7Ki9Y63EelBJENF4gSwWjw3rOC4iEfWtQCChQKJRSAHjvEREU4WfqfYsIzvrwOwn/MRqUgKiw3OBYFRrvBesEkeFmcA68DFdH6t/Xux7+DAzXGywLYIxCm7ABpRVKbf33wRpS/z01BoXCuXDOSTI4EoVSUp9vOKbKC8p7RIV1AcQJzgveg6AQNHsszRGlER+ukChXXx/q/xm0ssxWikVtR2IyRBxWBO81XsJ9UvX98eIRcTgRcMxdc6XwYQ8o5VGo8LyocK+UFhQe0FDfFq0MaSo4bxCl8GIRH5YxRki0QqkEpcI2xWs8HoWg0DgRfHgkMEqjNTgPRnu8V4gStAIvghczvK8IYAxG+XCtnMc7j9KKxCi8B90pMM4hOiyvgUxDohW+vvO+vunhuoCI4Al/9wKVg0oEwaCMYeeFivHEDde1TtjihTs2KTb3PE6EieKuT0j04Lnk0msRHV5EW6cbUr/I4d0e/KDRKLSu06D6OdaE/6EVTgTrPd7P3TNBQtokoFR44g2ERENkLvGo9xWOIKSRXgEM0sv6uSa8ZqIUWubSG+o1w5sm9W/CPueWCb8bpluEtFPqdEhJna7Uh0a97uB/cxtS9f/VaaeXQcKJqs9zcCZz69QJjNJbnTOEdcJO5q7b4L0M6eTcdhSg6zNURofV6mQkvH7hWEQEqRM1X5+L9yGhERd+55WE463TdFGCkrB1EYXSW5+z1P9fo8I+9OD7I4OUbvA0hCVlcB8kbHtwHkLYvlJQp5L1XrEStu+dorI2PDO+TtcGz8zc3UXreoPD/XoSE55K8R6UkKRm+ByY+rkVEazzFNZSWI/1AuLxInPfAu/DsSjCt2X4vM6laXrw7RNPagy5SUhTHY6hTgPD8yQIglbhW3zIEx9F9NB5xZ8/GS2Q6oys1YYkoecsM90ueM3iBQsp+yVZmvGIR+zMk550MCZNufjHP2DlHbcgqg9YWnqMkWwRez56H/Z89F7st+9+3Hr7Gnbe6RHkow1W+jaXbpxl52fuh2QJlYTPuQMeUT+vHbFkhPdgnVdYrVniNDuLJ1ElXVUwu/JOzjnlfeyZpOywaJTf3/IHbFUhZZ/FixdjxWEJ+SDnPB7NzPQMqTE0sgxQHLjf/ty2YiV3Tm4kSzO087TbIyxZtpR1mzeyYs0djLVH8WVFs9FgYnIChydvNsgaDbrdLk4k5IesI88z8jRjQauJEmF8wTgbNm+m0+1gjCHNEsbHxlkwNs6yJUtYungJI40GoyMj7LBsB3bZdVdmZ2Yoiz5ZYhgbG6Pb67N06TI0mqIsAY94odPtUhR9tkxNMb1lBpMkTM9Ms/tuu2OtJc0SekXBzOwsvV6P6alpdtllZ8AwOTnJokWLuP3221m0aBF3btzAPvvsjVEaW5bkacbipUvolSV5s8H6detot5t4seRZgwVjC0nSHO8dWZ5htEG8YJRC8Ij39Pp9BJjaMsUtt93KponNjC9cQKfbYcumjey260485tH7kKiEic2TbNq4iYnpLczOdli4cCFKhzRn452baDWaoCBvGJJEs8MOyxhrNVm8cCHdfg+FIs9zut0urVaLnXfeCYUwsflOFo0vpF9VNPIGabOJSk24Xwr8Vt+6+t9K1z8JonxIi4HJTeu47Q+/Y6zVZvEjltIeWYxoz+W//Clr169hydIduOGGm7jt1lVMbumCUiSpoWdLBMiTFLEe56CyJdoIWQ7nfeOq+/WePijBWSI+nKgOibeWQcZFhh8tQaNFQHm88ogPnx5dX6CQh/FzH3s8og0ohRWP1hrvXf0BClt1tr6oEgIDXX/QRKg/TNQf3WFYFI5GQNAgHhC8r4M6QmDnff0BGhzYcM2Q1xgGNfW30BOCQ7nLnuYCtMH2BpmTYVZjkLcYbEwPv3H1h7o+inm/VHUOSdUfYKUUSvl6hToDWV91RCPiQAlK6WEG0zP4XwjSnITgN9zDeVk5kTrroRFVgRasc2yaFmzlUErRSDV5w9Lta/AOUz8HqHkBq4B4Aa3rgNxjlA/XxocMiWhdn6eAMoj4OkcHTkCLCgF6ndlSIiEj4BUYMy/TRp1BUJj66EUM+BAhig73T+twbcM19HUiAcYPrrLU2a0Q5BklSOIRMSgszuuQUa6fHYWgVAjKtALRCu3DsShUHazWz9PwHML5GhU+Wh6PEhPulRac93VmTWgrzY7jiqLyTDtzH97M6IGQQTAmKsQGEu4vohjmpRXDt1m8hMwq4QWT+uUXLyF5rFfyw3d6GKYgdfolMpc2KBlk7GF+BOKHiUko5xoEaU7qfQ4z/oM0Z3BCwrwN4uvt/3EwOFjPqEGaFwLOcEwMjzcso+beb0CHT/bg8zcMOmTeMYX/zgVbun5vhn8bXGcEUXWJh8wtP7z49bKD4FaYi0ilDrbCZlR9ruFbIH7euoNjH9zHwfWT8EtfB9DiB9ff1+nRXKjllQzTeqEOjIfbVHP3oP6ADK5vuOcyd85eDQNhIXxIB98x0OHaurk0YXCnBEFLHUgPShOVzPt2eJJE00gzjAkJj62faW3mF0TVAWtdOKrrtDjRijxJKa2lKF2471qhCel9mqXhzOvnyPlwfRLlsRIKQNMkIVFgjK7P3Yd0V+tQ4CWgjUKb2JjnoTbSamIrixaFtSXOVRTW4p0lT0dwpSLRGWOj4/T7FWvWr6Mou2yZuRNMn0ZDoSRFlaEAduXtt6CTit332JkkLZnYcDuPHN2bfjFDZQsyNClCn4q+gdJrNogCCowkLEkyXL/LfmkThbA59ayiwpPgXE6eTtLMhSWNhOc99SC0lFz3hxswjQbOe9IsA+fo9DpokzAzM4W3FiFFrGa/fffDeUeiNaOtUaqiQurEsnKWxBgoLSQVY60WedZg9z/bhZtX3MRMr4P1fVCKtM5DjI222X233XFln7GRUe5YvZqpqSm0ggXjC+h2OxilsP0ClxVsWLOOReML2H2Xndljt11YsnQp69auY6zdQI3keHG0R3LarRyNRaMw2tMvSozRaCX0+11sWZIkhsnJLYCiKiv6/R5a5zSbml7XY0RYumgRVb+k0WrRyDMQITGGbmeGViOj6s0iJgER0iSjPztFu9lmdvMELa1InSVJElI8dnYClSQYrUlpkTUyjNZoZRAfCqSTxDM9NUsxtZmxRNNBKKemSADjLNo5dFnSbuX4ZoN08SK8LZnavJF2thgFJElOr9FgtttDxNPvCuPjbXxVoGyClAUjWcKmjZvo1IHisl0fQWag1+nRSBOsWFLxpJlGK4d4j6/TQx1K3kN6Q50+aw2qzh8jiIbVq1Zx8Xe+w6rb/8DYWIvRBaMc9pzncfMtK/jJJT+kqHpkeZOZmR5TU3100kIQZvsdvFShQCprkugGWsJ3ueh1MSa93+/pgxKcKSOEfLRCq0FJYKixUHXxpdQftbC8qjMeIdOplcIMiinDEiDJoPwPowVn61I25jI3UAdSdekkdekbEgIMqf9bfxUZfs+Q+oYovJvbp69LUoW6RoT5GRsGUSdeDWpEwvdscDyDwtStMkT1tkOp8yBiZxhEDPIDStUljXVmR9cl9sozr7avzpHV2xJc/bMZnr/gCXnDELk7P6hxHLRh9XUwCU58ffyE66YG5Z5hS9aGzWdGIcqFMxRY0DJM98phptF6jyoU3oZgStwgk1kHaYPMlhpkpAxaDFoZNB4xbnBjwrWqz0ajQs3r4BrbuZs+KPMAF2rdxAMpg5JxVFhfqVC6K9bjQ0hOHUbhXKgt09qjMIiE85urmZCQsRbBa12/7GDFgYfKOVqNuSA8URqlHEl9rUPtWB0oEp6rwTUQkeHzqAiZMO3DtZJhnR9zT7YojHa0jGaH0YT+5KAqMnqoDDLQIfAQXJ0J1jo8j1qkrpURnJp7bkUGRSMCWg0LDQa1XKauIZgrAJqLCebvfXDvh29+HRD5QRIwOEjmb6suGJi3ZT+3BfRW+5jb7txPgzhNzUtnBS8hsz5/n7p+j+pEivpJDmnAHwWJA0oGaRfDY5FBCZWf+6UMIqhhmjF3XAzPdRB8zNVEOcI7PbhnKDUMiJRS4YNRh2lSH7qqryf1Oc8FkiHMFBmkiHVgNy/9n5/eCIMWD/XPMrh7oZRZ1Qc+rI0cFNSJGp6vQPhW1mnCoGhR6hsfCrbC93YQumsVCoRQCusllPArwRAKu0yiyFOD0YPnSciTBCXgBul9nSZ58Vjnh2lUCLrCfTP1tzhRijxN0YD1liQx9bdSId5jvcfVrR6kLgCoqhKvNZULmWQDGGPCddIKax1KFEZicPZQa6c5U0WJaTbw6FAr5C2tPEd7R9GdJU1SujMzPOrRuzPWHmGL6yKuZMHYYkSEmZlZjFYkpiQxKXdumuBnv/gJzzz0UCZW3UGaVew8tgOlneRKLI+ThD2UwQts1hpxQsO0cHgmvCVv5EzakkJXjKqMXbxCi2ajhjWkJI/cjan167jqd79nfOmu9H53PaOtBPFC2emTpilVt0AlljxJ2GHnndl850bGR0epqoI0T0FZVFmCdZgsx2nFltkOndkueZIzOjJGniZ0q2l23OXR3LGhyUxnFlSC0hmVF/CWsdExnvDYfZnZMkneaLF+/UZmO7O02qPoJEXrhKyh6Xe7TM1OMd4eZZedHsEjd9udpYsWgBd2XLqUylZY62i2WnjvMWlozqPrNNRrTb9XkJmERppx5+x6RAQDzM722LxxE612TqJyZia2MNposHndRpYt24GJzROMtXN8v8emqRlc0aedtcnzjMxaFo2NMT09zY4LF9KdnUW7PlLNImVFmrSZ2jxJYjSNLMFVFYsXjNNe0ELrCpM3UaKxRYl4IRVB+rO0U3B5wmgrZ9Wa9YyMLSBv5vRmp+hMTzKa5Uxu2kivLOj1+hS9Hv2iG/Lg0qOwJYWrwrdNGxrNJq1Wk1ZzjF5fmJmdIG80aDVyPI60mWO9p9vrg2jKqT5jY6OIM3hROGtJsiykrYlBfF0QKHWqqjQeB96ijGbT5jv56YU/YuVta6m8YcOWaVSjzW9/dyM//fk1bNlS0iu6eLoonVJaBb6qWwYaXGlpt5q08lH63ZIERUqK0ylVJffyVt7VgxOc1SXJg+BLK1WXAoePnlcJShx6mOCHugatFIkhNOejbvJVlx5aLyhRJFowWlBa1euruk5j7mOm1NyJD2tsnAxLd4fN/OpapUEzkWGk5EPgmJg6QJIQcAxKDoFhzVU4N8Ey9zFm0ASm/pCHmqxB1orQTHOYV5orZR1k1lCD2ptBWSj1h41hyf0wn6RAvMLWQU44XxnWVoVS+9A00CgQpUgTSLRGq9CEDy04r/EYvPdYO8idhKYrzlsgpbQuLN+oA7s6J5OmQorCa4VzYFX4qIsfRoDDD/swZ6XC+ZkEjBa0HmQ7FEqSQdYHUHivh1XdHofHU1aa1IQSEW0SPBZbKZJE180c1fDaGEyoDVUK/KBxUB20KsE5T2jqCKkJ9zjcB8ugsZZRur6ug+Y+hEyZU3UW1CBKo8RTpQotdfA/qEavMybDjM+859PXmbmQ2R7U7Kn6GgtOCaJD7fKg+Zc2oDG0E49tCjvKVtF/9BDwg7ZZ9eOjVChUcsPCkrmSm0E9jRneXzUsNBg0DVaE2qiQZ1d40fU9JgQ0ddAzSM5E1zVrPjyfBoYBj0INg7XB9kJTMUdocDZXnMMwHRy8kVJvYU6djNSBgRo+t9THNqjhHbZDUIJ4NQwCByGI4MKWh4HXoDnoIOAZlEio4TUZJsGD6qatDqwO+obP+7xgqE5rB/+FuhX0sPk7w0KyQVApohhUgsmgRlB8SL89w2MbBIBeBldnXjO9+hQGNY+KULg1aJY9XLlO96gL0bwPBZbiZVhQ5AnXVsn86xICIud9fZ/nHW/9/VRGSHQSmpAzaHESgjyF1DVbc2kHSuHCRSapz3lwqZUoHBKaT4tgJTS/DTV7Yd+VdygNzWZCqnVda6jIVQYmXDvrPKI0RoXavcI6KvEYBq0JQrqujQo1fVDXcErdrF/PqymMHipOq9AVoapwKEhTKPrkOgFtUElKWXk6RcGfHbgvV1x1KYuXLCJpNGmPjDG5eQYvnmbeptsrcc7hVA+pVnPzjX9g3733ZmLjBnZ69I48XsHqtV3WjY1xfaaZrRyjxtBUlkwJM32LiGO03WDK5kymOcusYoG2zNqKyU7J+MYeudfMVj2uu/n3tBpjaFthi5S8mTE728G6GRYtWcKSHZZw0y03MTkxgTEakySsWbuWoghdOxIlJEZhfY9eryCRBhs3bSBRip133oEVK1ayZMliJjZMQukZyUcxaUa3V+JthbUVvW6X62+8gTwziAh5lrJli0GRs3TpUm6+7QamupZ2njHebnHw/o9nyWiTBaMNEBvSCiOk2uBTjVeO1Khh1xm8R4tHqQqkj3KKnRe2yf0O3PCHWxjJWiTNlGJqkqYZI2s32LE1SqfXI/MOKfuIK1G+ItGeqtfBeE+qIFOKsjvLyE474voZYkuqokunY3HO4a1lcmKC2dkOXhwLxtq0smxYmKO0ClGDUmgSfGVJlCFNE8azUfq9gjzLyRsNemUB1uFNCl6jdEqnKFm7cRPKZFSiqOruQIlOKB30K0dVWMZGmuTNNjPdAu9nKPp9rCsZTUewlbDzTjtRVEJV9On0LVo0o6PjoA060VSlpSwLTGLwotESuiOF5NmgROGVJ9Q/hLR57br1rNu8kcmqw8zsJBrPdLfkltvWMNvrU3mHo4kThziHFYsrKxKdoJOUNG/yiB134jH7PoZ1a9ewae1m+v0SlYww25+53+/pgxOcDb6waq7ZjwBojxKhrDReEirn6qZdMpdhsKH6yEvo9+WdqoMZTSsDawxe0vCg6jrht4PS1bmP7yDkU3XmRuoS42GzkfoDr6Qu81TUX95Bk5q6P4cOH6VU1/VMblCaqYYZgmGmoO7EVFeAQd1vSVE3UZr3+0FGZ/ARDh9+PQzWkNAvRZQKzT+UwiSmLp0KbakFRSuDyunhh82YuVo1ZwnBQR0N+PqjH65B6FtQ1+6idQjMyrq2BtFULvS38g60tqFW0+hQgyaeRBm8AesNoj0oV5+bqmscfV3bxfD+DB4Q8QqjFcrX19GpYeZHJARQIbPj8AIGqfseKkQ0fQt9B41USFWJUSHIHJRsh7jQoXTI9CgzCPUgqc8ZHQJlIZT+hqZmg8xw2JZROvzL1JlxpevMl+BEITpBETI4XoWCCNuxw+NI/FzJOHVJ8uAJHTSTGzb5qs97fgl4eHfCPTODmlqv6lJ7BUZoi0I1/qRXNbqfxPth4AKK4d2sn7mQDw/vTwiuCU0nBjVuUr9vhHQtJH0hIhNV1zYoV9fqUOf8g2GwwOBZGWSmB89xSJcM1Bn/8AwNCqiGBQL1BgaB2bDJoMwFIcMVhbn9D5oKDi/GXII7qAWWOsgYNMUbNA0OBR6Dmra5IGoQGOrBQQ5ikuGZylx8JINCsfn3Y7DwMHGp1/EorUMlHoN0Q7ZelxAMDaIzRUgYvArNnNXg3R0E38N7MT9AnDs/BcMao2HfuOExhbU0gOiQlikZJnjDGkQJrTiEutmrzAt3/dy5h2dmELgNMnd1wCx101ml0L5OO+o+ydTBn/UO5QVtDH740ayfCT8Iuwf97Oomi1rI0hQvnqpypEaTpDpUbqrBtagDxrqPtgZEaxIniBgyDNqoUFtmdF0wOmjzG66F0SYUgJlB0Bc9lEqxOISirEAniAbvLcZ4jEmAlEosvX6fiy/+HmvW3cGf7f94ZmZnmJnps2B0MUtGFzI5MUVlLWmi0dYz001YueZOHv3oR0HZ48ZLf0I1UbDuyt+SH/wi1owsolNplnrPwkYXjCHpe2YKS5UniDcswtOxDrVUc8cfrmXFN77IozQknUl8f4J+aSl6FXme02jk4VuZZvSLgk2TU/TFI4mhdJ5Ma2amp3FVhfMpo60xvKuwrk+37GFSzaYtG+n0SxKVcvMtt7JwvMXYaJvR0VEWLVrM+g2bmJ7uYNKMJEkwiWHTxBQTWyZZtGiUReMjNJtjNBsJSeLZsG4FibIsWriYPXfblcSHAMf4Hp0t6xldMEbPhn5tiCc1CSrLEDTiSnRqoKqg6pMnHsk8ZVGCd7Qyz87LFrLmjvUsGBmnh6WYnqRoGh6x114wMcmScgl3TkwwNTtFvtHQarWpbIUxmvXr17DH7ruQNHI2zkxixdG9cx1ZmrF5agvdXp+8kaEEJmZmmJ2Z4eZbZ9hh2TKcSegrGF+8EN0Xmo0WgqasYLbTZUu3pLAFs2XFDjvuRKdfsGliEryiO93nzjsnGV2whMboKHpqCzMzM3T6PaZnO+SNJuvWraPnHL2yAg9Zo0HeHMG7grWbNiM4mnnGxOo17LjjDmyamKLbcygbahrHFi8hTVPSDLy1VFWFdY6yKkjTNLROUAqvNAqHUm6Yp9+4cS2r197BZb/8GbetugnJR1BpRr/bxSSarNFkcTtF8Gy4cwqRNpOTHZK0AVKQ6YQ8y8gzTae7hdtvv4WNGzejKijLkkajSTtt3e/39EEJzuZ3OFYhJwuoulRPEFthKxtK7uoSR2ME70Aph9YhGDKNEBwpbYYfrEx7Ns6ArRRZDmkyl6ENzdHCN0z8XDAy6Pujmau9GmQSYF6B5iBHMPy+z2XKB6W5g/zDYB1FKD0YtsKUeSW2UpfYDq6KzK2TJHOlqokJ4ZzWgtaQaEIwaBReDM6CMQ4RTaKh3VBMzIb6mjSpcE5RuZDZTxiUNtdZBfFkiQbReDSZIlTjKoV1g/57IXT1SuGqcAmMVqRJKN30XpMkIMohwrCNsVIeox0emJ7VoTaUEMy4OiMhdY5VhtWmGq8FXZfull5h6qZhoDB1ya5WgyaGug4iTbiqdWl67jydriczQp6CUiYEw0g9GIPB1DlXrU3dBK2+80rqwh7DoGov3Jc6OJawjPchi2LCiDKhpJfQXllTDwJQ5xyVCjUZRqlQIzkXitfPy6C/HnXvvfoh03UNcf1g+UFGUIcM/qCvXzjO0M3ZUw+sI3VthQxq/KKHkq9rGoYNDAe1MYNS/2GgPa8mftBfqK4VDfnQEMiFjKzfqh8mddNvhQr9t0TqPl7UvR3ngrNBi69BajsItkzd3whCUOg1w/5qoIbBmK/DhVC7MigoqonMFarVNcLDYClsZlj4FVofDmqw5mrAlFLzahXrk6zPadjsTeZaNMztm+G1GyTY8+OqYc1YfdHDnzxq0F9ZBun1/P7Ffl4hkQybNw+u5WCfoQ+xQtXN3J2E5c0gVh6cvpo38Mb8w1Zq+L/BvgZCiw09DFxlq+MfPA9zR/zH/fIGBQKhKfrcwYiE5rWubgqp6po2Xw+QFArV6tp/H5rjVs6RDPqtydZ91iDU0tVdckPzx0Erk7rAVWcJRtXPqvLzWgWEFibeh2fCSuhYn9Q1YUb0ML1UWs17X+r7Ug9+4hEQNwz+o4eOTkJfK520MEmKKI/JcrrdgmajjdbQbrZYsmgZkxs6lL2MPF/IooWL2bhhI3mm6Ls+PVfgdIpL2mwpCsbbbTat2cRPfvQLnnP4c/nlT7/PTWs34nZ6Eo92sLgSxqkYbxigiTgh0cLIaAoaMgGdeBb0ZtgjHyXpl6zauIl+UpCJwrpGeNaKijTJ0Ai9bqf+lioq60INlzIw6LLhfeh3pQ2OLk55+rZHWfbJVZNUt2jlTfJGg/GFbfAFMzNbWL1mNTPdHqISHA7nS5rNFlma0+vMMtJOmZmdxbuSZl6EZnPaMtOZJk0VI82EotthcmqaO5o57dYjWb95E5ddfRVF0ePgpx3CmjtWsuOSZSxctgPKJFz6y1/w2Mc9jp0XLaOqSpIsY7YoqCqLsg6lU1Qjo6+FqtdldHSMO9etxjcSks0b6fVKJnsdtsx2mJzqolVOo1T0vMH2C8qeo9N19EpPr1QoDL1eQWd2luluB6U1y5YuRSrH9HTJ5MQMWjmyvM36TZO0RkaRqVlynZCYFK1NqDUiQWnDlqkOIsKdmzeybKcdmel32bB2klbeZtaVTPZm6RTdOm/v0Bo63R6CYXa2Q997WiMttHj23H0XtPd0Z3vY0rFk8eKw/OQslCBlxcgCRd+WNBtN2i0oqhlUkmH7Du8tjWaOSgSXOJI8R5GCTkJ6JBaqDkmS8Ic/3MT3v3thqC30hsULG8yUFmsVSSU4P8WCheMsW7aU3AtF6Wm4jCRp4HwT50rKfomhgSsqNnZWs/MuO6KBzuwsixcuZnbmYao5CxmYun9Z3R5vLpjxNDJNllrKCkDqzG8YiCI0BwmZE103JQsjUGlcvf5IA/rK0+lrfFOhfSh5E6VR2s91hib8V+uQcR70iggZWj8cSUsrCX1B/KAGay5O83WmKJSE1h8uBgWeg/4BdZCV1E2XtEJrTVKff6ierpuw1JkkrRnua1BIrQi1SUZDkmi0UVgnkEJVaawPH73ShhW0dngv6LrpkUJCiaiE/csgDFCqHpUxDJaRJIO+dwybRHrA+lAbR90UZrSVhOP0ph5QI1w77wXxFQ6w1uBE0emXYeRE78JydWZMa1+PvhnO06SCMaEjuKmbiA0C3K0L5cMoYojGeU+FIKLplZ5WVv9dKUxiQSWhuaEe/D4Ef2iDiKmbIoWaCqWFbBC4KjOXwVHh+RhkPpQKmRw9LMpXdRmDoAn3xmhTl9ArtPEgIYDUxoSRLet7Hq7zXOOxwTPgGNQGgvKDYmYY1HLMazSGVT4cL2EgklDiPwjmhGSQMY0eMiGAGhQA6a0Gwxg0GRsMRKQY9D0dNOQLyzkFpm5iO+izBoO+jBqtfd3c2teZfIbNDy11H8n6/Rr0mBxWjamQhg0HnBn0LqsHe5B6qEKpC3AGtVE6lJmE41B1PzQZ9EZVdQZ+eAUA5vqlqUFaOX+wkvBsD34IQcvcABEohYO6tmzQX1TXAUsdwDBo4jdoPijMBRDzgh41CLbqUWQHgbPAsChEza+9nyssUsOarzq8q9cftoYYnCuhTy51kD1oDRK254ctRZQiDPpTp7ne1x3LlRkGpGFUQz1IcOZqXutrqtW8GszhuQ1qGWHYsqI+bl0HL0qgqnwoHNLUhThh3UoE5yxGBoPQqGEtrHd+LpCs748aDB5SX7fBIFCe0AQ8DFBg6gI1GdYA15eBQY3r4IkIBZeDd6EeoKseodHrue+r1DV+vu6PriQ889FDa2JiEuc8JgkDeqRZEkaz0x6TOvJckzdyHvGIZdxerKW/ucuKlbczNTNFWVZUpaWyFa1WwszMLJ1uhSal25lFS87tK6e5+srL2W3X3bhl9WbWb+4y6no0m4vIk5QtpdBPhEYpKK/pq4QOoXDAW2GxGsN3YLZMQi2SVHT7DlcWjI+O4+r0LTOGjnMopVk8toDKeaxzDFpPIYJoIclzrJRhTIE6b6lMg0Q30YlH6Yo0h8JV2KLEJA0mJ6Zottt4Dc1WgjIZ1jq88SRJQllWjC8Yx1ZdKqnI85TJ6Um8djgF070taK1ZvHgxlYM16zaSjSxg7VSXZrPBt37wU3772+t42iGH8JjHwPoN6/nWty9mj1/fyMuOORbjPUr1EK/ozFbMzHQYHRuhUzicyslbY0zO9piYKZgtN7F4h52Y7nTpl45uUVF6R3NkFG0SrMBMr6CZ5jilyJKMdmucbq+LEkWet/Czs1Rlwbq168mTlDtWr6Hoddh5p6U0W03GRkfwCEW/oHA9mq0WSZqiCLVzjZkO7XabW2+9jayRo5KEJUuX0O12qcoKJ5ZeZ4axRoNNzqEUZHmDsbFxRBRlWTA6MgrOMT7SomnAFVugmmbXnXZgbCRlw7q17Li0wUjT0swsaWZQ6TiLly1BaUtvw0aai3dDN5q0TJMka4UBAxWopIFWGoegJATbt157Gb3ZGR7z2F3Z4RGv4M51k9x44/WobBpnF/G4fR6PVAV/uPl3tBtjLFywgA13rmDxooW0G5pVazfiTJOR8Ra7LNiBPDGsXb2a3fbYjT322oPf/f53dKpZxvMF2Ierz9mghFRhBl+d8HsVAiiUIjXhQ+d8/Xn2oRRZ6s+rc4LSgw7Y9QAV3iMm1H+Z1JI6wZZ1cIPDEEbjS03oZO+lrokK3+C6+Z6iqhSVC83C5kbHAl83PQSG/d9C1Umo2ciNIm8YnNTV/op6GPi5YEfVpYvUzfEEMAz63NVNOOuSyGEfNqlrdYaZEI1zCmt1fdy2jmAErxSlZzhstCcJ0wYM6w9NXUI011Sy8qYOSk19DAbvFdbb8IF19fHUg2mIUpQWpmYsSnm6pUYZV9coJWgcvVLRTg0q8fStkCcyHEDF1u2GvdR9HerrpFQ9Go6CXmHI0tCZHRUGvzCEL7w2GqMUiR6UTIch8UU5MmNwXtjSh1y70MxzUMtnpD4PGRYQhH8OMiChFlYNjknPZQsHA7SYQaGCVlAXFBidkphQa6l06AivE41JFVolKGVQ9aiWKIubdUzNhuFkHYTmqXUt3CDDo3Wdafah31to8jjMWobAFlXXlQm4uh8IIRMfCiM8OFVf80E2L3qoDIKjYZ/WQQ2OGmTw59UADH43aMpa16a4QW09dZoDdUWPGgbuYdOqDnDC/a6LEwgPdP2s+mGiwXAwoMHWvSC6Ts/EzRXGzCt0CH2sQkAWas9C5nwQ69VHMte6cl6hlcwLeoaZ+/qahOR/fo3HvIBHqbnADobP+9zic83cBkO6yzAwVFtf2632MEg+54WJg1dp3vrDGjnmRp9F1bVqdSAS+lv58J7XkfG8eGwYKM0/RzVIT+rv3dwIk3OFMeJD0OzCV22rPqZzZ19fFTWvGXy9T+pCR7XVXWBYEOBdqGlyjlDgVg9ZL17X/dUAXU/x4OeCr+H9GRxBHaR673BufvNJNUzHRQRrXb24r6/RXDPtMIJkCF6HBWCEtFCp+jnUgjgT0kdh+N0aDCJmvJ57pKOHTGtkhE2bpmgkKb1+iTEp3nqaWYoxmsJNYXs9rrpyFVlrlKSt+c21v0Erw0hrEaPji9myaQNTWybIMg3ag3iaed00TwurV9/O1EyXquPQbc1sorlD+rhKMY5i3AqqLfStY3KmR6ITFqSK0cTT1QkrewUd22WzFZrdWTJX0hptI6nFKgte0Z8oMUmOTsOok4lSNBODIUHp0FandJbZ2SrkBfOMftWnFKGRJaSZYmZqlizLSNHkKkcpxZ3rt9BuLWR0dIxVa1axdMfFNEdabNo8zezsLFkWatNaI23KArZMbsHVLVpCwa2mU/ZATbHjI3YkH2mjTMbqtRuZnCm49oZb2bBxPWW/w423reKOTTOsu3MzG6ctau0WVq3ZyB4770hlK6amZlgwvpDZvuPOTTMsHB9jNO/RnZ4hzXNGxsbp9aepeh3Gs5RN09OMJjmFqujOTtJuj5G6HiOZJ1Q5dRkbaTCWQ3dLly2TE1g8aWqYmp4EL3SmZ6mKMoyymua4sqQoZvA2pV9Bu9GmtD3SZoL3FVVRMDbewNGmsc8erFp1B+tW3EyrOQKuIMs1ynfYcXEbWzl2XLIA2VgxaQtSHQqhlRKy1ODcDE84cB8etcfOTG7YjPbjiCpI0wJfTbPLHnuxasWtNNueKtuBxbvui8kMs1vuYLI7w6LGYpJ8FFSoRBi0XhgUN1XVDDffcCWrVvyOtTf9gcULF9Ppdthp51141MLF5KOPwFaLWHH7Sh712B1YffvtLF3WpCwK1m5YydjCBaxZv55ur4sZMWEEW1fQaDfZcYelbJ6e5Ppbb+bOLZvp9Eo6Pcdtq9YzMzt9v9/TByU4MyaUkKk6SAsltaHZSYIJfc+0QlSCx4WEfNDuXNX9lVSdyQ6bwItDqzCwQ1WF/j4oj3WaRA/qxEKfsFIg0Z400SQmZI5cHdCgFFmqSZO5kRnDEL51x2hVz2FGKMHWmvpjpMhMPUqZqHpYfwBBOzeIRwm/qTMgEkq3PYRxrRFUqP5D1cO3ezEofD00dajr0qhhqbJRYBJNUYTmNqi6P17oElAnAhrrwrxyYU4yQWlwPoyaZZ0nUxptbOiv5MPw/xpFpsAZwdbXx1qP10LpPJM9xVgrzNnQylJSA0prNDlKg0k8uTbMlI6qgi0zjr71NNJBpsdghjVRIbNlVJgbJDGKPPWkOnQKH9QYhpHGdB141h92VWd7fUI790zMhmZHSSIYnZFnhOCsHkRlMB5deHY0Wht0EmrXMi2oev9GDZoshvkvtDbout/foP9cCC4NyiT/P3t/9mxJdqV3Yr89uPsZ7xg35sjMyAGZBWSiMBVQQ7NZrGJzbBpN3dbdkl70IP1LetCDTJRMIptq61K3SFYVwRpRKBQKSGQCOU+RGRlz3Pme2d33oIe1t58bRRpboGVKL+EwZMS9cY4fP9u3772+9X3rWwKwVcJtKhuPpIx41CKjVZZeaVmmuKITOIrCFJdqYHQO4lTG3RHXhV1y9SGlj3XURG+oY0RJEQ0oJ59rQPnIeROcp8eXc6jzqCW5CIYc1J4HXawD+PPmFJk9SW8kg7nEVyeDnrheSLITYIzkaZkVASoZxoQYU31PYoHOBezrz45PgqgUfHeXkoGPygAkc2aJ0UivVinZlF0hMjv+/8XI0eWhum+7ToYJA5m/d+x6iulz1xwScNRpPDg/rulTOhDUjac+B+Iy6M1WLeocaEjggOxImSuO6cYvAzdYP58ZgGXmNNeNPfl563sRkiRDpdq883WDXU1y5/5IxzSu5dCswV+GoDGxncj7fBClgo9BkojOJ5CbgGHw6KRG0AQIuf9ZHjdN8EGK3IO0SQkJENpUC+YVXc+0jh1O4FGn/bv1Lq3baZwT0PZZpp1dGtX6OfIpgaXTHhzUeVnq0+PLOq7euM7pZMJiOSF4S7vSqLjJIsBocIWlP+PseJ966VDtAq1he1RhvGbc71G0Le1sgnKwdKCKCmVKSlvSNFN6RZ97J8dMJgtOVyuag7+EPyrZiT0WumY2c7SV5oFbEZxjq9fjt775bd746c+4385ZFT2sLmnufsaV1YoqFpTVAEXBYuGJQeOcIwZPv6xoQtO1xVExUlU9QLFonMzNVpiktl6wamsqq7l4+VkuXdjjz/70z9jZ3cXXDY0Ca0sUin5/g8npivFgh0L3WM2XVBZiv8QYg3ORk6NTQnRsjPck+d02ECKL1rG1NaZvB8QW7t19RFO3VKMen929x6d3HmJUSUHFg4cz3MMTHjx8zNAWuNmMu++8w4uXdnD1koEK9HG8dOMStz69RRmnbPY9G70+s8WcazsFh8dIm5/g2Nnoc7B/xPNXtzg4eszS11zY3GA+d2gdubDVZ9AzFGaF8WfsblkOTs5wLnJ5d5PpdIKNBQvVcuPaFaKrmU8PGQwvooqSG8++QDUY0OLp7ewAEd+0aG3or1YQPM+/9it89NbP+fTDt3n2+jbXX7iJsZHdS2NGoyHFBwtu3LhJz67Yu7iJNiWTo3vcePYCg81n+fqv/w6bW5e4+FLNfHqH6cljdncvUQ8qtq5e5hd33yXW95kfKHae/xaND9y59xneT1m2B1jVMJ8u2N65SlADPBETZ5w8/pw3f/jv+OGf/iGXtre4/vKL/Mbv/EOKYoPVas6//Of/Z04O7/Otb3yLs8mMH/zxn3NyfMTVy5d55dWvcP/RIfdff4dHJwuW7ZJeVbFRDbl2cY+eUhw/PMT4CquGrFaB1aqmqVum0yWt++Xdtb8QcBZU7HqU5Z1TqdzPxAnbIBYPyWY/5PU7yS0S+6TEzYyYPL9UxJpAaSPzOm2hKmK1pjCBwmjQmkGhqaxCaZ/eX3UsiErtrZQOkhXs5BYixQkhq+ClgLo0AR8UPhpcEF2siZkty5txssJOeNwQCUrjoyIgNWMKn3qzRXDJSDnmzKBct5ZYPMkAdQJYiR1BNvUQpYBRp1y52I7GJDWRmj4r6jeURwBMEcQ4JQIIa1SY+ESPB00kBJPiLkWlFc/sVfSLDG4gm5RoLaBF8LSiVIHprESbhoERF8jc286aXDMmQYDRRgrBjaYwEZM6j2mTWMwu+MqOkgpwaC28KCpwsnBoPMOBZmug2RiU2ELqGpQqJMSIMge1Ek1rNlvQ5/Q3Smn5f0oegBJKK/0pCYQU7IaAUgZMkk8pQAWUsl0oV2iNUoEiFSavU+4p+E2DrfP8PhdMh+TVRg5m8tRKbEsg0ibrVx0lwG2VomvSpJ/KGv9/ceTVIjsj5t9lUNbVbcki0oEFydcldlTL2rVmYBLzcQ7gAV2fKg2d5JqYRX9qvX6GxMDl8FplsK6eBE8xpnpTUi8uBV0dXfrc1BRbpTo1EmjJp8qg4vyIdO9Nz8UT/56AQffYJTDRgY4MSuL6HHkAwrlz51OGc+OuEtvXyfHOvS6Sa67ST+dYosw0ZfCV1RkxPa8m1UaLa1forqd7n0rj312IvHfdTzy7Guru3maJPSA9lVSAJMEO+RqjgJkQ05oT19JKEEDU9XoM+X6k8Q3redZGMdoKATw5gRRp873sbk1K/iTgJNNBWH5hs9btE5QCp1y3P+Tf5QSEyHrzmMWu1kwjiD90K5yMnYx9m9jG9R6c+eFCJwD4VK79pR8P7s5pGkSNVGkGo4JmFWmjAT2kWcypW3HMZlVTWku0houXr0IoOZtPmKxm0udTW6xyKNUyO1tSFBY7grpZoakZmUgzOYK3/5wNEzHNDJaRMg7oE6l9w/Fsyq177+EO9hmGiK1bil4P34hJnC8UoZByBdd4lrM5w+GA2gaOFsdoYFxWhBAph0MxOCHS0krZR6FETndySts01DPP/fCQw8eHbO/u4r1DKUtbB06OD9nYGFOWMJkuGI6GtG6OCw2729tMpzXLRYv2htAExtsjrly9zKOHByzrFqU8hkAzndA6j21b/tavf5f/+fvf50fv/YImamrnsDowLgump8ccn54RUDhTMHM1V159iauv/Qqr6RwfpMl0b1DxtctjmsUJZTkG3efw4SPC6pj5e2c89/VX2LmwRz2fcPejd9Fuxca+YbpY8vJXXuTunU+5fO0iN3/lZbxztPUZvQuRtoXy00DEMp3MuLi3x+ef3QbvQE94/leuUwwGvPbdX2O4dxPsGEOgpGG2XFGWFeWwxK1WzJaP6G9eoLdzkV+99DsMdnuE1QnjXcNw7wptgN7uDheeuUwPw9HkgBA8W7tjvve3v8WP/+qv+dqlV6jb20yXC0ajHYLyKL3CxxW/eONnvP1zy8NH91DPXWQ+e5+7W/+WwkbuffQ6G4ML/PxHf0hlFcv5km/++t9j49LLRGcIqxNOH3zOtfGQb3/1G1SjLTauVhwfPODZF56jN7rKr379P+f3/od/xq1PP2PQHzDc3OOTW/eZTx9ydOr45LM73LnzmLqOmGJECAYfLXfv3WF73Oe73/3P6A3HqHsFWzsbvP/hm8TQYFSJLoa/9HP6xcgavcYrhTVxbXnf9eDS3YZntZS4e1JDajRGiX37uvhZwhCrICpZ7Pul1E1lQcig0NJbJWqWjRhmiATN4nxk1UoMUpiICQJOMoMjrbgiUXuIAhWkAXHyGswa/ihuhYUx1GHNeAQf8T7SekCJq1VIhfQ72z2MiZyeOQFtBhQWq887OipsCvhlcw4oJXLMkFlE53FR2C4fhPLNtXAB0VHrLoxRuFaaSKfoDqnbSnIXnwCrMqkwPdC6SOOQJseIfbJOTJY08EvZTbKsS/qAKSW/q6xiUHn6KT/rg8I7sCZ95wzMkr20thGrIoUGhUMrI2YoNmC0QWlN0YE5kE4eYvDSNoGeiVzaKSi1ZntU0OtHtCrkumKWX5oOOAUNNgUPMWqi2E8So05Nc6P8rKXfmlIeY3soLbUsxoqzmNUFGBK40mQtamYesmGILc/Sz3LuVHlCNAizmRuiPxk5y0yPmpBq/nJdjE5SVB/FkCUkB8d1LZ3Gnz/V0+NLObp2EFnmRQ7uU4ic7pciGR/l8DlLVhXJIUrY/Bwm6wRMfBfMinw5Y/sUt5PrjTKDFdST4EU++/yqSYd6ukD6CRAQ1tLB9O9SlZYk4OTgO0kY02t0/swoDH02senkaufm4pMgNnRs0BPjev586UJjHrdz7xdkmoFRXLNI6fVZPXG+y+M5vJSA8HlQHM/dV33udYIyc6NtzoGktZQxyxbTuJ1j86KSWmWjMuxKSTXZCNFamjLnaw6qw8TdnqbWVyT3IIFcUiJIarQThMxrfXfzkxFWAsIyh6QdjGwJWdWCJHdU3n/iE6A1+Cjjm+oFs7lLroXL86gb6aSO6OZrlN6ZGUCHfOsze6nSnMiXoiLinKaTKUvo1DNPjy/vqFcN49FFZrMzirJkUAWiEzMHFR4Qlws2VJ8VMG8XbG9vinmHUsyaJY2P9IY7LFdLFJEQAjbVNmkKHj48W68ZSmGqHmezKYNiSKFHjMuGtm5olSHaCqeWHB9N6BUDfLNEqYhrFyzqFbZXUqmKuFrRFpFgWorBknKgOZvWaGVpVzVOWQpb0bSBgsiscThlWbU1165cwgaPK1uoLXO15PGjRzx34wq//Vvf4Y2fv87FK5d49HifKhq88RycPaJuZ+z0ClAehWZVT8EYVu2UYVUw7mt2xhWj0rI5HuKbJe2qYXNYcWl3kysXd9m5MOBHP/5T7tz7nNBI1rhvNFZ5bl7c4/LuRX5yfMpgaBhuRr7+2iv42GAGG/Q3L8mzGgJRe6qNlsrtEpqWqrdNuXeZ5fEnXFntY3oNjTlCjxyL9ozpw0NOV4rHRw/56jdfYqlPsOMLnEwesXflOg8/ugO+4uH+IaEcoaJitjxgNptiS8PFy7sE1/Lss9cIA+htbaHo4WODqw/xqymnj+9jK0O/N6I/GDMebRF0BaokmgHXX/oe7/3sDzm59znfePZF3GJG00zYvDAWc5J2zngw4nRyzPWbX+HKZ/cpgmU2OWNj5xpEA8GwsbnLe+++y/HxGatVy3/x9/8pjx9+zLUbY37///1/IwTPr7z8GsPRiD/8tz/g8qUNXnv1VeqVJ/gaVEMTpmxe3UHv9BjtbtHr93jv/R9x9+g+dz95ixdfeY3hYEVROAbDAZf2LvH8C88xPz3m+OCIb3ztW/ziZ7eYHi/RZSWEQ4T5MoLvs2wX3D+6y3hnk+O371K3GwSnwfdQQXfr/C9zfCHgbFBp2pgAi9doC7rbagLa5I04SI8rpTtL/QzKlMryMakdiknWKGYSYHzW96fNOvXUan3AgzTITAYKReFRUVi4kBg5pcU1y+aeaqEgqJBkFbYz/PAxyQCjR3SrInGUoCOgjbgB2lJhUtAhNUZQGo/SilJHTOr3ovApaJcgXdskIgpJ/pis210UiaKPBT4GQkgVL4k988hCF5UIIWPORhJQVifgm46c/dSK0pgudNRasreF9lTWErUneEPfidGISXIZCdKSbDDJU3M2HcRdsiqTMUqKzmKhMMZITzpFAmcCarQGTbILV2lOqHTPtJzPGJOkkCIZDV7R1g3TeZQas0JTGIMtDCgrcyAalNGgSsi98BDbZpH9iDxWUYJyaG07qatSGqIl96Qzxoi5jA7yvTHpdQlEpaGVMV+b30REkpNd8ORvqgtaNZKN9+ekSJkNkHTDuVoVRPrqo2SidVCpuN522ebEnxAyg/b0+NKOdaCfI+lzNWIk5qZz6lyDjZjqp7IrYn57UrB1P+d+i+uaIgE3si7QyRohrv8k9/RTGTcmdm4d5K/hW76uNXuyZv/pAKfnSVC1/s6Zp+nOBFF6VHWJhsiaGUOuV597WLLFe0IAHXhMp1r3vjw3tjLUKaER1lLCDIgDYsrhWV+LUus2B+fvRci1dekr5VpBYbnOS03WdWP63LWs70y3/HVmP/mkMYMUFbv7J0A27TUdkx6ThD92Zzs/5p2o79x4nr9/8l9J2HS1XOku+QjnWbK8v4bzSbs0NzPA7b6CyjXCGQDSZQTWeDVmHJjOL1evzn2X/IUiWcZ5/rrzvD//+jUwz2Pin4KzL/3YGytcHLG/f4wLnt29TWxVY/2c0j1mp1/T1IbVdEm/DFSFozSKgVtx4+JlFm3g9uN9IpbgNUVhCI0jNiuC9yjfQKFZhRWVHlLUFSOjuDga8spXXuSTWx/z8eMDeuMRk7olFJZHZ8fsjYc416TZYal6Q5wLLGghtBgndQIDu0mYFhRelEk9bVGUNM7ggoPQ0viID57l4gTCBpcu7mALxXT+kJ3tMY9Xx3zl5esEtWC2mDD/dMVi0RCVZas/YDI9ZWd7zN7lLWbTI65cucbp6ZS7D47R2tPrlVy9tsuli7scHp9hVM2zNy7z+P4DvvON13jxuW0uXdnh8o3nOPjv/zW+jbS1J0ZRIY3GQ0YbO3gVuXJxwM72FlWpKFdLbHOKW51QFD1JxBCJQSrQ0YGmXVBWW9iiR9QV9WLB+6//iOdfeo5m1UDdUpiKw6P7qKho5ksO7j1gw1omw0NsLDk9mPHp7Yd8/OkdjO1hjKU0imGvwBZDnG8YjoYcz04YlTuodkLQgcPP77OYTdjd3eHixQucHk9Y1YH+1iZFf8xssaREEf2c/lCzd+l5Pnn/Z7jlAZPDO+jlHqXu0+hd2ljx+acPuHT5Ekf3HvPg3ufsXd7l4qVv0q+uEv2EO7ffYG9jj8P7x8ynE6bzCQ8O3qXXh8ODE04Oa2KEd9/9jEc7Z5RmxTM3nmd7b4f+aJNP33+Pze2CVXPMWz97g29/+5sMdyoO7t/l2pWb/MVf/Dnee1545kV+/Ed/zHZ/i6999VX+1b/+ff7tv/szfvd3/gvuf/A5904fs3N9kzuHj+kPxxQ9S13P0CGiGBFCyV+//hlV1cP2d2mVojfcwU+nYgql/uPP5H/o+ELAWdSKvjYUxuOco3XitGjMOtTXnTtiFJcyFGgv2ccoUjeVglxI2WUtwb6UZQR8tEi9loAVCHhMcmQxtFHT+ORQpsAng5IYoYGu+WfaPdfSS5IDotZURvpKGd3Dh0iMwoP4EGmdMHrEiAsOgyZiUh0ALBauYzV8CBijBRTmVHbQaC++atkFsEt/pvjFJjDqQkHtAr3CE70Ya0hdnCEGA8oniGZAC7AiCHCzqTmiDwKYjbHE6KVfWgSFxbmCAHjlKbQiRotNwEXUlykzGiNE0zEGBLGP3xgYtFYEH5LEJuXdYwLCmm5hyfUcMSqMTc1ak8QHpTGmRBkrzFVMDaJDC8oQVJscKzWqkJ4T2hrKJIHJBg3inBg7VUwOqgw2zSkxOxFQJv8Xl7KA0gZyg1gFMRiUkoJiQ5KiKjkbOVztGIqIsQL0ky+eSFljRIcUxKonZVUpqs8+McKOhbVsSoKgKM3BQVgXJUAcTWqQ/UU8uU+P/9jRDfHfBA6cCzGVsNbrZJQcIYQusBWAnX7POlBHqWTOwfp3KXjv5JIp6JaYWj2hMOjCYJWh4vq6Yp6iGTiwBkEqZtlhmnxJdpkD+DWgPH9WYYcCuX5SC1sU14xdPJdk6K5R5S+xRqVreKS7REUGh/l6OzMRdNdrbs08q27N/ZsmLOfBJzE+AbQ6uJWs4Dl3LwRMqcRUp3OSx+BJICVMnOoSJSDMlU9zRaTu55I0qA7MrNm9+ATqU913OofeySA1iy4FQIUoIveY5wbJHkqJN4OoIGXS5ZLVTjZ5jgXO45FBXp4C8dy1hcz4pvHoZnke05jf153tHPSSe7SWf8qR2bEOpytFgTRG7tjLp8eXdlzaLikGl/jos8esassy9GjYxDcNpqixJjL3kaiHeAytG/D1b7zC0fE+k2LK5wePqYPBxQrnDU5rtDG0yuKjoRpsUc+nmFiIrKtoqYYVr/2t7/DXP3sTNR5y9vmcgenRNA2ubnAo6rKRPS4qnIsoI3b5hYKq0BS6wfuILaFuW8rgwMCw36cNgbqtMUZY2Np7mnpJv1ewXJ7y3M0XebB/jyZM2BpfY/+hxwX48Y/f5MaVF3jw8BG/+7u/yd37n/HeB48oqxHLRcv+o0MK6/n89l0Wq8DkbEFhS2zRZ7UKnB7NKEyPQjl6BVy9ssHh0Se0S8+LL/19Pnn/p1y/vEcRpXk7SrHRK2nrObc+/5yoPL/zn32L73z92/wP/49/zvHjh3zj177Og/sfc+25Alv2+PzTW0zO9nn1V1/DR8fho4dceWYX06sYXbjE5sWrvPnjH3HzuReZnkz58U/fptfb5vHZnLLo8fjYc/vOBMMh3/nes/zsJz9nOndMF4GlK2lqKCpDZWCxWkEzZ1DAYFDQ0wZVFwQ342D/FzRzw/beDSgiMS6ZzR8yGA14/PkB1eAyvlX0rjyDLkuCLdm8ssH0rQVHR1Da5zg8PWF3d8jZ/n3279/l8sVdnv3KTVpgEWZQNrjwmPnM0TOW0pU8vv05cdkwOazZ3rvM7Vv3uH51l8oOOT1p2drexbcF4/FFfAh8cPtz9M5Frn7Fcuuzn3JpNmZzdJGXnn+ZOx/fYXNQMJ8tuPTMV/jub/89Pnjndd7/8D0uXLjMM9c3uH/rc7568yVsMeTnP3mHw8Mpf/gHf4hrI8NyC91W+LqmsJqiL0Z+ru4RI0yW4iI5NBVNqFG2oDKKZlX/0s/pFwLOlktPrQP9SjGoDKGQh6N10qtL5mS2+pXMJzoSQ+pSle2kQ86MSjF1Mr5EI6Ci9QJogpINNptlzJdQ64hSDdFb2ZSMuEBZBZVSUGjKVHDsY4CQXaPObcFaAEaIgbZZSzSyhMUrlWrUImiNky7Gqa4KbGpYPFea3VEKMoz0LyqM6myNY+5UntwFYwxdHYJgrIBz4D1474lFCiOiog1RxkEriuRyKL2TAtZojLJobQDp9SBZdi3NW2Oqe4sQTAMEvIUYdJLtCQeZgzIJmLJZR8qQq4jWFlMkRtBo6QcXE5BVIn80xkrD5iSpyQYbRiuUtum8os/WOiSAabqAxxqFsT2WzrBqG5oWChdY+pYBGmcFsOcaBgkEAniQfmY5/MjALAVinpTR9h3DQfRi+KIDigJShV9SVHX3KTs8EqS+0UfFYhGZzxvosr8iZwox2ZREYXDze9dyrEAMOvU8k3+3KVBXSh7MgDB/EWFVI1pUSYTUTuHp8WUeGXSc/022ns/Pq0/q7Sd5J3kOspxOqwwrxIE25PnA+WdyDRbkhCnZ0QG8zN6LAoGYTB/OsTGdoQTZKEdOkQ03zgM3UuAs9W2Qm1qvPyOx/Wnee4DOhITEEqdarS5CX583ktoG5F/n8TmnDcwJi2zNntsTxLTeyuf47rvIE51OmMZAXpNAZL5X6SEKRGlZ8UTAn4Gi9PpSaYzl72sgdB5snJdcPjE3uh/WnFUg1XTJqegMWp64PwnQyb9IDWGu+UtHB566G5aTUBmgqfR5CJN3jrnsnETj+ROlNGkaDhnCDGxzXV0aqvNzhQzYkH21+3sC4TE+UasoADum+0uH5jL47D5cp9pKBf1+ybAoWDUti9rx9Phyj9ffvk3jHrJsFA3gMDStolkYehcu8uhon9m0RasSEwpmkxXvvvsRVQVbuxcJS0v04FgRtGFZa/q2olR95pMV9WRFiC3KOKoyorRltQz84R/+FSeTFZg5RlesFnOig3a6YjAa0TYRH0Xmila0qylKKayxFFWJtX3q+RQCtO2K4aBPbD19U+LdgkFlmbsVTRNpGifxX4RXXvgKz197jp+Z9yl0wWgwYlwNuLS3x0cff8KjR/d47voW1I/pxUipIXhH1Jqj4zmElqClbKKixDrYGW7z7M0bvP7Wz3G158blqyhnmZ0saGzDxmjMo4MFt26f8sGHD9naHuP1nNPJCf2Ni9THLbNFTVlq9o/ucTS5zLKtee3V36DXH/GDP/0D/tF/WXLv4Qn/+l/9PjrUXNgesHv1Btav+OwXf8Yzr30HWylm85afv3eX3Ssf8fVXX2P74rO8/9ZtlIWZW/DDH/2cxcpydOo5OKy5fzjhbOKoWyirMToGBsOKnlWY6HErmJwdUUws9w6O+fZv3mS1mELT49KVi9y7/QnG9hj0L/Dzv3qP55+/ytVLu/ziJ/8arzRf/dZ3ufLCK2izzWh0kfFgm1sfvc2v/cavcev9z9AOZtMl08NjLu7t8szLX+MH/+6P2RhexPkeg/4mNEccPjrh1qd3OXx8wP1Hx7SlorWe+w8ecXF3h43+iPmyphoFFssp9rPP0cHxyd332dq7RP2rC7764gv84vU/pbmu+cZv/VPq5RLjppw+vM3m3ibQ8LWbLzPoj/j+vR9T65I33/w5m6M+21vbnE4mrFyJnxTUyykwZzxUGDVkMS8JuhCn36wYiwFLg6UkhkAbPU2MxPKXr6X9QsDZztgwW3lmq4gxmmEvMjCG1kDjPI2DpoXWmXOZWtmQxU5dQtHMptmo8FqaHhOg9QoXlbg0qiyPNGhtKFSgKiLWCmDxTtgoMbEQdixnPz2WpgXvZdvxXjYTH7KnlE+SPIs2EasK5q1icxATsEhGHEY2YwNoHToJm9XiJLkZLT0dpE0VEnwZaylKnQAgxOjwIfdhO9dXKAVlwQfpiyXVrSmQj4TQdq6MGsn2Km1ROAFpXYsChVOFwAyhyJJhCckLQxPT2GiiZJ6DSvFgDgRy4CKXlgu8VYSqZ7HWEFuNpxEGLUaUEV21Rpr9oXWqhYiJxZJfSx+4BEEUxJhYqy6vqgCPynPFpMxx0EQTklFKJPgcYOWIQ+bHuhpHgFSMJLYOCJm1y3GbzIcQc9+zdEMBkTfK+SVIjITkPDqfzzg+clR9S0BhIwK6siQp5ivITbBzll6CwdzTR3fZ8dwvKgF/Ij5qQsy+jnJSl0HB0+NLPeK5YD8qlRwF49ot7xzrcD5YX/d4EiAQPN18g2SWozRRSR+pGEPqo5frdeWzBYinhAgI4FCpxiqxPCpmyCJsjQD6tJbGBKWy4Wd6prNsMjMk67qxDI7kO4ecTDjH4mVjmwyiosrmRfKeTqaYEl0dG5yQokjEVRfcd4pLlQ1BArmVwBoYp6RdOsfaUTG9v3vZur5MQwcSz2HcDniQ2MkMZoShi9216qRE6L76EyBd3u8TMMnJK61UMqQSwOnS+Kv087rOLStI6M4voO7cdebPjCRA1NmIyLhpWWd8dsM8h0s7cJW+w9omRaU6rwyXEyhOCcG0MK9XmnNUfmY28z1TGbWdG/4MJHPy8bzcNZ9Tx4gpLL3K0DNSB20LaXreK8Vg4unx5R43r9zg088P6HlN8BG18pR6zCpGetUlTg/3KWwBUZis8WDIzavPUfQMnz54TNNK7FAWCm8C6ApfF7R4dKFxYZUkxeCCwVPStuCco1eWzGYrjDW0RFoAa/EKmhhYBSfPXhsojUFF8CvHonYMR33aRU2wLRujESEEThcrli4lwkPLrGlxpsS1YkEXYuAHr79B27acTh290RhbKfYujRgMAs6f8eILX+G//q/+Af+Xf/YvePTIEX3N1niTGAOr1qGCotKa1jnaYAi24PPH+xxMp8xWUspyMDlgZh2jseXbv/oNjh7f4e1ffMSFvWeZzj/h0uUtJosZw41tDs4WNMFQatjZ2GBxsuLB7U+5dnGb2ckRf/z73+cf/dO/yw//9M/4t9//EYta+qv+3//Z/4vt3REv/8oVrl+7zO23/ornv/YKjw4f0TQFr//sE9778AGHhxP2T065srfDeDQEF7h26TIPHt7mBz+acOPmiyh8Wu8U2hiWzYrpdEGpI5vDiqIqxXGyrDh+dMpgtMH4wk1Uv8/G5YKyGPDos0959bXXuP7Cy5RVxStsce/zDzG65ezoPpt7BaYac+3m13jzZ39JoUqeefZ5jh8fcO3Z6/SswdqKGBQmKOYHj3n9h/d5/tkxVWW4f+eMH//4XQKK48mS3mDA57cfMeh5hoNN3vrgY7wylKXm8rU9Xnr2GvP5CbW7QuUCf/H9f8moN0YXV3jx1V/H84iHd/8a6zWXn/0N8DO2dq9g9JDldMqVG1f4N7//+9x89iZXLz7HG298yOlZwJmICquEKSxNs+TC7hAfPctFAx6i8hQ24JsJvlacTU+l3KowLF39n2Tg9oWshP2qoCo1tQssa898aVAG+mWg19MUzrCqoTCt9JsyKsnzlLAtss8SQsSnbKzWkUJrCgttEymUNK/OrJVWWmzSi4gyOsnQoA6eEASgKSxaRwKeEMAYj8jZxJCiVyQjDGNRKLQSh0WNlsbSREZRM9AQYysyRSW1WDGkTKPWqCB0tTaaojQMVEGhxHpeG5veozEmMXEh4F3AOSmmjSrXGkGXatbSdiAmMwinIz4otC6xedNXuSGyRsWCmN0iQ4DoUF7h3DrTSZAajIgYm4QEJHQU0OhiTCJAYWk6u/YMTHIdA6BND201gRWxaVmXr4sEs8tzp2y7ynC2C1LpXi9GBeKcmTf+dR0CoCwxNngv4D7ECD4mySgEnWoXs1QwFb2LLEruOSqitMga5XvlCo+E0JTuZI9KJTtqhYxGHmeVvkeKYworTprNaiFtGVLgqLPrWSY/jIxASEztWob2pGwsvyWoiPSqMgL2KJDANoH2NCeeHl/ucd4WX6cA2yuFjef6TUH3mvyezCmR/y0qvPdou574GbyblCXOc0dpqWWV57PjLuRZMVrWEURanOViwXvwmT15kuVR5+dJBjgp4Bdw0PE3dE6g66wFUs+UzqmyJ46wPfr8M5rmcGaBRYqoE3g6/5p03pDNQujGKSZ1hVl/YzIr1fFNaW1QiZVTCQyGdT4lYYTI+tvE7nOeaHWQv2EEkqoiZnDZHcKwdfcyn7PD2qkVSpZBpu+RVRcJG6PO3Uu1vsrzdzfNizXgyeCpG2JFl4RSISd61BNSxO71T3zH9Rjl2r38j5HYWed3Y60Uf7MGMQs54W+8NrNh+e9x3Sj7SaZRnHSNNulcAaO1rJupMTBILfTT48s9/vF//Y/4n/7HP+TtD+5Q9no0Ycp8saAa9jEF6KJEK41VkSsXLP/w7/0WDx495PN7BxzsnxL8ABfAmwYXa1y9QDmLLkeoosSoVmrPogVjabxNhkgRo6FfGonHlCYET0GkpzV9bTCpvn7uPE1KLJRBMap67E+meO/oFz2WPrCoG2K/z4KIsdCuanwQdYkNmtJodsYj5ssZP3/vLqu2JRo4OT6krODO3YecnNRcuLiDKSK6gJWfs7O9zWgwoCgNZ5MZxsJytUKj8UazChFNyXTaIJqCBRsXLzKwmmeuXWN2sqJe9vjsswPe+PkjzqYryp7j9PSMNla0qiBQEGLEmj49s8X8rOW//e/+10yPj3h4cId33/6U2/cnHJ5qag+msPz055+yMyx5fHCP/93/9p+gfOCTX3zMm69/QFMbDg5b4vGZPOdlxfFsBlgGRcnB4RFlr4+yBZPZjKLscTqZooueMJIthFDSBs9sHumVm9x9vODh/oxvhC3+zj/4NerZfVQ9w9Lw9k//ktOD+3zt1Vf5+PY7vPy1X2fj2g12/ITRYMDju3epZyuu3vw6V567yXR+hDZjJpOa+/fv4M2KpXbsPf8cbYy89Oo3+MEf/QWLyZRbH3zAr3ztaxwfLjg5rllQs2ob5quG6Bzbwwu89eZdPvv8HkGVtDVcvXidZ5+5xs8/PGNSRz7+5A6P9j/lH/yD/47f+rv/LePd6xBrbt7sc+u912lDoN+/xKe3f8zh/nsMC8vs6ITZfsvDcMydj2dMlwGnIqFYsbe1wbi6wP79Q9qV5/DhhDZCoxQoT3Sr1J+4IbQO1wJFidIFzjfrrfWXOL6QldCWBoLCWqgqaOqWxSoyW4Jziq1RpCzBB3E2dCEBsaBw3qLIjnvyuxAVTZBNsypFmmK0So2Ok8GEUngdAYv2qdGmjhijKKzBpGDbGI1WhkUT2ayyW5k6F5evN0ulpDeWsWCMwqg+WxqMlt8rq5NETTZek/rAyLbcJmt4nTZOJyAlOskGKxkj6X/jUCFZpIeIT9ooCdRAm1KCfFUSCLgIpg00Thi24CIYifpjVF0DxJyplqbQhrolbdjyPo9kw32SWUXkEg0hORKm76kCkAw6yPKjNL5Kp341whyiRBeOcusgI722q5vBksSsiJk+EL0EcUj9WboFZBmRjF0UeaRadd8zxDZdba5diF2wq3MwI5RlOjR0tWakP1UH1LqJAHR1a9JGXNpDJCdPpZMNf8xsiaOuIyfTM2ZnS1RiLbXJbmk5llJYnuDxUkCUsuJdpl3nYSOgCAHaCMs61bBoGUGXmGT7hFTr6fFlH5npIApAy1Ye+ZmDbuYTteqemdzseT6fMhpvIoJWMaTJFj6dkUgnb5N5YkwGWSJl0zFiosbq1KsqsWdoRR1cMolJTnxKwFY2y+gcC+P6SqMSyXVU6/5VJBDaUTp5fUvPWJa1ZXCaPyuDg2x+tAYXWQons18wVehqwaJeB/r5M9cumXIJ4RyozO6WLjFAWQqZvvlavpkB6hoTrVm6mO3y5fpy4+k1ujn33nT31TmL99yiQ9gBeV02T9Qhdi6FTxh/dCxTPLdWZ8RIkiYmkNV9fhqbKJ+pYjL6UIgRTWLhQzh3nvzeENas5rnZKSR9uuYYO4HEeRasA87deKV1KssqM/A9z5zlxACZl6ObuyDzoigMpVFyz0Ok9kFq01Ndbzz33qfHl3ds7A157rlLfHj7DhcuXGBrMGJoDIv5lOBXNH6Jx2IjzOrIB5895NbduxwczqgbgzURHxxoQ1QDIiuU9hRFS1FWeF/ho2a1XOBNSgLT4lxNDIrBcAMbIou6JuooyhAVce1Keqbqgug1jQvUOJxzTN0M0yvAFHgVmc7nBF1C9Di3pMVTFDolKwK2DxhHf2vA49MjXDEQK3dlmE0duJKH+5+ji4qvv3aTj99+j3ba8NKzl9gYjzg5OaNpNJvbY2arKct5S7R9gvaEUKP7PdwqELzHBs1y6vA4HttTlAk8c+MGk5Xiozu3aIJl3OtT08e5QIyicqJnubu/z/Ube5S7I/ZevoZ+BH/007/knfceY8w2Rg9xswmVGlDYgjbC6cGcN19/i2vXn+MP//ivePhgKrHRqqEsS5q2wbWOJS1nasFpWFAYQ1WVNJOWxfwBVy7dYFhaThdLeqZi1OuzcDWrZY2vAwsV0MpT0HLvs7f59BeKYd8y2hoyHl9g3B/zle/9XUbjMfv7j/j8vR8xmaw4nR/x/Cv/hGfHl5jPHnB2+DbVxg4bA4/ubfDsC9/kT/7kB7zz9sdcvr7HsPS4s8dMTqYsA3jdB/pMT+fc+fwObfRMnELTp21rjDYcTWtW7ZTFckU5CnznN3+Tf/iP/xGT/Q95+1/89xw8fsAz3/lV6vYiO1euMNrRRL/P43sf4kPLza9/A62H+Lrh9OEx/+Z//HfsbO9Q9i6g+0MeHU6w5QCnNMqC0Yambai2esQErJvoqZ0XDKADIXpCVBS2oK4XeMC3huAVtQf+E8pQvhhwZiFGjSWincJUBVXh6bWW6azhZAarVlEYT9NCrxSGKqpIWWh09CmrpojaSvNpB1o5FnVg3gaM0gwGnuA1g76E+1YrglMURQQM2sQka4SikDovUwi42kkbCzhAAJw1FpPt3BMwUEoskXWXPE4SJp2MPMhVcBCVFz5IK1A9tJbtRd5niVGjtJEATcckJ4zY1tG0LZGGEJZEJ9JDVRRgDMFbWQAp8NHTOkXrpKGo5OQ1xIA1YrOv0o33HoIXtk6AQgDvO3ezUgk4ilHjlE+gKEczRtoT5F4zyTVRoTGotJ/rZNIiktMYk9BRC6OjlU293bKOKgVlMaTAA1BSayVZ6mS7TOrVhJiySANzQ4wW1DJv70ijaJE6aGW6NLFK2eCohcvQOShQEREBCiMYlSEQpMk0RaopS60MFKmpdfpuKuCDpiwR234t8yNAolE809mMxWLBdBLY1ckQIAW/KiaBploHZgolkt5zUp9sCuJDSFK3NRvQukhQgeglWRGRnkJW5e/49Piyj9xIWpjc/LfuH/NfyP27gM4BQWalImjfzfMYc6MICbBVYovzvCHkNMY5a4Uk34tKQL0PKQmUPtAkIOfEX6lrTaJSRmBtg57BY+zOHqKsdbkqLrM9OoJPctu1614yZ0ogi3Q+FeT5CWrd+6sDoXmtTN8511V15h4hpodAgJGYciRot8aH8rKY2ES1BobdeVQGxKQlLclPBUV0648wQwmpJRVBZgYzlpIWB2Ku8QTQ+w/Mja52MH1TYSJ1utvqye+aXtklZjrwkkGxOL52IC1dQ06Q5VYdAoZEHqpVtstPMk1J/ayn5/nvDesM7jmA1q3N6XXkuZzudV7HE8z8D4z5ue+XAVvHUGaYbog+0BJRXtydlXNYa6iMWbNtf9M95OnxhR//p//j/5VHj48JAeaLJfpsyWAwoOwpnAsU2hDrmsJYTo4DP/zRe8xXgaAtZb8khAbfLInByJoYIiqKGinGhqoqaJSHVUQZReta2sbjnMIYTe1aCqOxZYkKjqA1wWjqZoUxBcG3hDbi6pbBoKQ/KtAmsnSOtnVEVVGaPoFA3TQYW7CsA00A5SI9qwiuIUb47LP7aNOjMJrgwLUBbQuIkfmqoaj6/Pgv32Sg4G//+q9x+94nfO3V6zTuKu988Bn3Hh1zfOJo2pKihFhEgo6czI4otMU3nqEdsVpVeGW4c3cf04tMvOfsrGXpYLaoma2OCV6SriGpfto24A2889GH3L/T4hcnzGY1n905YzC6wHzRoENJ1RuzcjO8WeHbgmEz5oP3p/zlD/+CuwdnFEVFoRUhOJyDtm1wrsFYw2K+pFf1WdRTjCq5cu0im+MxBAd9hYslk+kco0v2Lm1BGBJ8Q72a09QrbNRUvYq3f/EW3/m11/Aq8ujuO3zlq88wXZaMn/kqw+tfZTlfsHs25/HjB+jyWZQNjIab3P3kx1wInkI5Hn/+Q7Z3XmR38wa3Hx+zORhgViuOHz3i+//mz9k/PMWUkWq4y+Gx4+hkxrJ2tKuaqhpC7FOWCm8d0+aY4Vixvdnjys4YpT33Hz2gbxx/97d/i8HOBh/fuUVpp5ztv0NZbdAfweR0il9OeO+dH/DhBx/SsyWvvfpVqnLIw8eTlPQsWNWOquwRao+Jis3RkIN7j2namhXgYg3WEJwiRoXSPXxbE30g0CfgBYgTiT7Q65n/pcfy3zu+EHAmrn0GpSNFodA64DwMlKfa6dG6wGzRyBIeNEWh8F7LphgUZaExBtEYG4s1UJXiBmRCy/6ZRwePKSTbrKPHeyVsRZSsplVaLPQLqe3qlYaykJ5ixgqgIBq0dqiQBi0aQmgheMkW6nPsCtJ/K9ukSwBfAK7bjFwIxOhT3QgEWrTy4pLYeLlWA0pLY2djLEZb6rqhbVpa16a2M8JICZGTMpBayXVj0VajnRhQiKxPoWKq+VIevBF5pG4JQScJoocYUp2GbOQxBRsasOj0b7LdZkt5pTLAFOCVt3arPVn6o40RyV2UoFMbm0w+YsriSoCSHcKkZipJC6M0lpZMa6o3UwUdmMoFwSiiFlBpsRjtUwbfpnMh51ESFklg4/CNpo4NIcjccMHhfCR6aAM4nxlYMaxxLqQ+cR4f033PtRdK81/+zgtJzmpI2Co5KxZUvQXBCzOnkV51rmvvJ4FLEUGbZLOvUmPw85FQDkC16iy65R5ZemUkLhVtjJgYpDWBziDh6fFlHzoK0xzUOct3IIfOOjEVHcOTmJsOPeRXZnAV4xqcJAdCFQWcqC6YzYRJlHmlVdd6JAQIwUtZajL4kcbpKpd4oVxA7IAyK91xN+kFOvdDlt/GkGriVAIIERPpevWpTjZ3TvLImi1s6hVl2XsCsHY8sVbJyfIcAwgdy5QNOFKXbjrTiHS5Ygolb8hS5JjXhiifFRKLJWOs1peYR1/QI+duCOeFhevLzgmTNQu4rtWS/+qU4OtyP+QxS0uaUp2LsBHkk1ii9VxYk0kJfCYzFAHQuS1DrqFJCoco5cA+g2RBjAnkCXKNeWzS/Mvg7nzvs/MtAP79VgHrce+c9zkHsv4mOM1s5hp/dceTzdXXo9z4IPWLMRs5gfMtwa7l5k87hHz5x+aFb9Kyz2QyYTZfYJceisi0dlwcb+CD9Hd13uFboIbgFbpUtPMZUTmC8tLcF+n1anXBslHYSlPXDTE0hCJSSBcb2WO9oW0aFBE7GGCKEppAJLBqagrW7YWU9klhVBFdg9bSvyxGT2xqsHS9GRfLulMF9TQMi0gMloCU3ESlKVygMCUL55gtaxrv8EQKKt548xa/9e2v8N1f/wbND+d8+t5t5ss5z7/0CnX7kP3jR4gngiY0EatEa1Q3HmNLoo34sODqlQscHk0JSnHvwYwHj05YrVLeqZ1RFBalDN6L07dWFhMsqzODrgr+4T/5r/j43Y94vP8Gx1OHqQYQRf4b2pLZfIGuPVb10abl7LhB02exaChLiykM3oEPBVDStgoVPNJGKOKUo24bptMFk8khN2++QLSR+/sPpGecviyER2jwzkNQeNfyzIvPc+36NsNhj/def5frzz1PM68ZbioOHrzF0VHgwf0DzPyEewcPWUxOpUXA9ZLCOPrjMZ/99C8ZDTQWTdMcSRyu4PBowmh7yKODY8qqgBg43J/w7jvvc+fuPttbO6izM1btiqZx+NbTGzRsbCi+971v8vKzz7DZr7n/yRscHdzj8vXL3Lh5k+//8fdR1DSLE2x4hbL3DFat+JPvf5+h/gmHd+/w8a0jbt9/zJXL1zFFn+PTM2bLFYXtE2PLyjmKsqKeLbnd1DQb1znb2kRrzdCAqmvicoGyK5rTfbQPTJ0DC8pGoo74pqbqGZxrfunn9IsBZ0jNUsSnhrsiJQzG4ltP1dP0il6y5dUJSASIhdhRWqnpISq0lgyMiooiRrSybPVBaSuufkBpSqwuUYlJKa3CaoUtshwv1f6o9PWSe6FWXppOmwqVnAmzU1qMLgUjEZLZSPABY4TV8q0DvSRGaJzqQBk613oEtBG5n9UCQLUpMNpiqyLZs6dMdRnAtWlDNalmzmAKiy0s0StxNzSpAsxLtlJH022wGSwQZJOOKqa6KGleLbJLEiBT63qJFMiQAAjBY1SS96CSTEgy3kqZBNwCKJtAqdj4121kMV9J9/pSrOdJ+lvSHMjOZ2CTkYgEY14hwVaUC4wpftER2bR1Cu+iT/LUFFxEnWMPIDczFVCrQ+D+iePnHxwzHkvjb6uTO6SR+rDSllijsVbRtwZjUk80ZVMLA2mQbayhqip+8OYjaZidZKZKJQMXE1O2RAK2wiB966JPbQhUJ0WKihTEqAT8U6AZxVwhnrslIaokmQWNoagCvkmGESmwU8nV7cmKkKfHl3E4YmfQke3VEwbq5HM54M4CWRBmZM0XCYektYfkPhuiBKGde19IAb4PKSkgZ5JEQIcE1pLCkPpX6QycUsAe1rVXKkkcldJdgB0TqDHxSSAZ8vuRWrLsNSPzOPe9Uh1wyXG6woicIzN9Ma0fMUnqQv7cHP6ndQc6wKcSLbY2y0mBvVJds+7u3fEc6OjuUmaSSK6P62rMgADbcy/gfO0a3bl54pyqA9S6WxdFapiZpfXrs8FSSN83X7vPH5Dk+YEMdp+ATp0TcJahdtfSMYz5u3fftLtKnQAlqe5N7mNmvWR2Zjawu4epOXoe1wykupGM+Xf5Pp3/9zVgO/+LPEZ5bdYJPCq1ltt3dzHd6+BDvhMsnagXciuDp8eXexQXdrl6YZcLq5qjw0OaupYEsmtolh4dS5QK2ELUSyjoFwXaluwfHILSGFtRWkvrHWWpAIeKpbgvNp6iqKh0SYHGqwZDxLlW4sI2slw0BCNgIdcj9qo+PtZsbW4wjgrXPqJtlgwGIygUbaihgtl0TkBjrE5Sbk9VWJyKRNdSDfrsbOzS6/c5Ojvj+OyMoBRGVSyWcwKKGFtKq9E4irLP5sUBzh7zt/7ed/mD3/sDvvriK9w/mHByfETbLBiOt1kslxhjCI0YjJVUGO0wrsEog1ss2dzcQPd7nN0+ZbloCarAeyiUJThRBuksS4/gcZiqYLpc8P6HnzAYbRBQtG3LcnFMr1/S65UoV2D1EIfjbLFktnpAoRWVLiiskcp0XaC0olnMcW0kRs2gXyWSvM/pyRLinGeuj9m7dI3R5jatcQzHC06Oj3BNgS40s+mCtmmYnD7m5ZvbvPzVZ6iGmv17B3z7d/8BhR1w+9ZbXNzcwDDkypUtrj/7ItOzB/h3DTe/8jJVNcYWNWeHHxDrOdP9JWxdoBpf5IWv7vDC9W1m8wn93oBCR7ybcfPaNQ73D/nzP/4Tgi1w2nMyPaK/scnp0TFOB2gUsZ1yebvPV1+4jq8bvFvxp//uhzz/0ku0jeLP/uQnHDw645XXnkMzYLKMDC8N2f/8cz74xXtcu7TDZFIzHl1id3fIR7cPWNRHFNaCr/CNBj0ghEhbLyjtgMlKoy5fxD7zK5hKszEqGNoSvWoJi30++dEfYxc10WiMjtggWIaiR3AtOlS/9HP6hYAzpSxZDoHyGAXRaLw3KUMWsFoML7yCEpFjKJK5RpRCd5V0OLJQQ0yM0s6upWc1OiqR/yW5hFIFqcwr7RomJ2zT342YiCiLNkEWmigZSClAdvhWCrNC9ETfiiGIKUReoTQ+atk0dBQtNBKMayoC8lBE72XB0gqS9bP3AaVLoi7xIbFBKgd5Gq0rbKGJwUN0YBXWFhhT4KKwUSJwEoBjtLA1KtUeZUMSaZItYEcFm3ZGkSppBdaHlC2OKThTnQucEYuxZMQhAFmaOttUb6U6xovssBaTNKFuOD6LbI6hKFoMJaCJwUotXQfQJCAliK9YjAlMxkj04kRI8Fhr6FUKpcXBS1zONMq0yR1Rkx01CYVMNb027YgJxI0Hmq8/P+Lg8Qwf29SLKTBvAmWrcFgWITJvWhbJaKYqLUFFLA0KRdXr8Y1XnyMqizEWa8s00aXzWe7FNB6MuXRhm+3nh3z+i48l0y/RC7mWRatceyTv8cm++nzSufuLUgSVvpPSlEPLZOaSFJKukaHKVnRPjy/16KrKotwXEsgJKSw3KVLPcrKOYFCpsTMKrRoOHn/Ih299yNe//jK7e9fQpk+kEH5FQTb9CWnO55keY6pBk4tJQXbswNQTLDMxBeixAwEgySBUvkYJ9QOyGHe2JudkhRGIWneGIWtmZG14QW4xopLMOzvMpm8hn5ED+fVUVfm6ycY3iZnhSdnguu5UWDWJ78/Vvqn8Z4dB5CukDxVAmeuYfEpsiSi5q8lKn/lED7j1V+1AEYmZ6xwuYyBqTQwqyZZlgHJT+Axyk/6gWw9ybkyuaS3dzCqMGBIwU9mMQxC7tJ6ha+wdutGjA51i6kTngqw6MCk3USUwLi66rHvLkedeBwHXwFudG5MM7uMaHkZkLHItXtoe0nt1UkycQ7P5jelnSUzmeS2joHxYJxGfHl/a0bSS9NSm5MqV67SuJXjHRrONX60oe0Nis8QHJ+UmxjAabrKxtUXdeJrGU1graiItLnX9wQBtLE3tCMGjY0FhKlarFZPZCoWR1jpaQrMAeOdST1ApcfDeEyKcHJ/SKw074z71aoGNmmalIBiaZkW/qqisJaiAtSn+IdA3BWW/R7/sM5tOmU5mrLyHqGjrmqLfo7KWaAqUrag0uMUC30Tee+cWZdnw27/7u1y4/gymt03UMJ21lNbQLxU6GparhlF/gC0qNsdjjg4e8vJzl7i+N+L6M9d4461PWdU95vNHhKiSq7L0vlVaU6SWQiE22DJImynjWawUv/d7fwIeyt4AZVt09Mxmc5yLjMY9+gPLYrliPp3hQ2Q4GOBKYaP7tqKde2xh0MET3Jyy32dre4OdrS2s0TjXUhhFUfTY2dnk1ief0YYeha2oehWT2RmDqkBrxWIxo3ULTDFguf8Q1etBLOnvXAUNL7z2TaLqEeMGi+khVbXksJ5xdHrA9uUbaLtFVA0XNyras0c899JL3P38Lh+/8zb79085eHCMjTW/8b3vcOuzhyyWLZ/VjwjBswotV3Z3uVT1+eijTynLIQqHBnE9NxW7O9f56x+9w+1bt/jud7/LT9/8gLc/usvOeMj+g2PKQY/vfu832djcYjAe4tpT3vrrP+fK9jZ3b93n0eNjDHDx2nOcnhW4xuNXAA7dDwz1LtPVEbNixVGxxbK4gqfHuOxRRE9dK1bzwFxZijhmWVxg27bYMMOoBvHiVmA0IVq0/f+TrFHqjiTcFJYGQOogNLK4e6cxyqB1IsKVkU0k5vyjS/U+OXMsWVujI4WxacMMoAX4GHGu6HqTpf0IH2KSpylMFOChjQfXCPsQchwSZcCSxaXWBUqXQMTYJG3DopSmdTXBt8QgrIotDEaVeBREgzcOZYxkaUOLaz0uBMqikJozIt61EjxFQBnQXkxMlEHHkhA9WleAxlpQ1iBWHWljDSo5Q0ZcbKUANIgM0VoIwYg1v26xaZMVJ8SccRZmJtvsr22is+ZGgJjVhbCBSmj88xIl2b4NWkX6VcmVS5aYFnClNdEHlsvA4+MlITpcUPioBVCzrldRRiSARkl1hlKwrOGrNzcxyDwRMGLFQVO5lJmV92G8gDgRD8n910HGAYcKcDhdUgeP1QZPoG2hKaAwgco6ApHlyjLoB5Yu0rSOsoChUSyWAShQKhugBGnyjZWG1UpjTOTZ61dZLj3PP3ORe+/cwgdh8MK5zPE6A50Bcgq2lDiW5kbdcK5GLcj83HtmE1sqHt6eiYFJAgtG0QV1T48v9wjdDIvdHOxATFhL6TLACFrqG31ssX5GEQ7YYp+Xr1cwu8ukfSQbTNVLluJjbDlEmR5K9QhUBGXwQQxwiJo2SI2CDqpzAHWJjjFqbb6Rsj9J7pOfV/nTI4YiUWemb/29VErWpF8I24MkbDLDt2Z91qybjorgArFwiVWWWbzWxCXY2BExOfCWqxVnR0VuPQAi0ZRrknN4lcFpNvHQZFfAc+kNQuiGZg0RQ3q2unrAbOCR1pK4ZqSeZHnyOg3EJEU+97zF5CInn0FSjWQGqZs4GakRu7FO7z8Hes4fCoUOAti8ogN8Mc+vfIYEcH1cryuZjc21dMQ1+xZVHpfYnSVLVvPszUYjaj2kTwClEHMdZDcK8jxkqWSMqSwgXdQTICvJz5VCx8xkyt1SXQiQa+qeHl/2YZSUY1gjypii1BAsVWEwG2P6g+9wdHDA0cFj2tkMoxXHJ1POpktCUBhTYAtDXS9RaPplD52k0doYkT9S42lZhhVer1BKHBpdUARn6RVG2uK0HpOSq00MtCtPv7A0y4ZRVTAY9Iha4ZYNhRLWdzzoo2Kg8RqtS3q2ojeoQLWoInIyP8XqitF4k/nBSZJeWuoAwRb40DIqSkxsuP7CNZrpjN2dEdMzz+/9y38LoUcTT1kFRTCKftFnq7/J1J/QG0deeOk6+/tnLBZLWFUsDs949bee5/L1S9y+N+MP/vxd5o0TO/8iIj1TFbs7O1ijOT09lR67XsgGrxWF7rNcgjWG6dEZw/EGbR2gWRFQNCowGg8pqx7LusY3Dat6xUZvk+Aci2bBYDik8UuwgXFvxN7eJQprOTzcx7kG5zz9XkkINZsbI6wdcLB/QqssIdbMF57Dk5r59ASNZ2dgeO76FXSoOTqYUuw8w/z0kN7WFsqOmR4eUk9usXtlh/lkThWg54bSA88sMXHK4f5njJSmMprJ2ZQLexXf+/V/yF/98E948Ol7vP/uh/z1Gx+yf7DCK81orNgcK/6b/+bvMz+pufvRbdqJRzU2ybs12hoe7O9jL13nq199ldd+9TV+9vbbfPboAT7sMtxSfP2rN3nw2bucbmzQhhXP3PwGN65eYUM3fPOrL3Dr8wPefftdopvx2iuXeO/927SNxfkhbVTMZ0uKXp85G1z/nf8D4flvMY9wqa/52mZkHFYEW+IHhra21N/4Dd76g/+J47f/CL9YEGyJUlb2EBtQ5pdf2b4YWaMJEIW2U0gTSa2iZEOCFlUhKum7BJhIqUZqFhxtZ4uuUkE1ygGZfUhOecoToqdeOUIUWZr0e1HpM30HQFTUiBmESXk66Y3lvRQhQwJ52dkvGrC5GTOgbApGHNZo2lBClD4sWllpBRCTm1/U0uvARIhGWCsaFAW5Wav3DT5GtBHHSm1KVHLFskVfgCWR6POGKt9bE0G3GIIwJikLHLXUs4l9foQokkqdJrBkJQU0hy7VHqROAVIjZtVlP0OQXdIYkTBGhYwFiTHogifpBVZYQ2kbgreEKIayTVDcfbRAV4qLWz0B21oy64aQAKlEW5JFl1DGR8/H9xO7hJGNXYfk0imuiVrlAMisa0tImWEt99gkFhATaApLvYoc1YZISeFXNCHgnUcbsNUm4y1FaGvmdUu/jIwrRRMUwzJgTcRaMQgxJspYpLpAhcIa+eyiqCj6qSg0iP4+0wOKZCYRyKpGcu8fQOSirKVcUYV1sBQCJ2eeDx95RgrKxKhli4XI+eDn6fFlHBJ8JuYJWBvo0zkqyr0LnSW9Xz7i5OAW/dIyLD2HZ1NcUETlOZst6DV9sZlOyQ6T5LVGK0xhKKuKouxRVCVVNcCaHkV/IAs9FR6Li4YQDcFrPJIMEJeyBE1UYvSRAD23s4iQmrSvOXlJKK1ruQR6hbT2IHLppGSQCpPsvuZpFmc8uHeHy1dfoD/a62AgiElA7g0ns1Wt2Zj8LJyTx2VJIuk5l6SeSuzY+bq1NetDzNCTvEytf+jCfLlfWWCdAVjXm+wcWMn1bZ1o+JxEcv1etf45MZwqxCfOn6+fxH4JmDoHrtJ3786p1njW51+G9E3TWzqWMTFYIeYPS0A3f3ACwx1zioxfTkg+eZyTR6sMlOlMWbQR8CWzX597/xqo56OrS8u3NH0/pTXGFEQve9G4VxIB5wMr5yAqPGKxrtd34enxJR4mKJxzxADGihlLQOIIHwK9wYBL12+wd+UqfrXi7PiYo5NjFvM5BI/SERcjPiqqokDpiqapia7FWJuSulIiMigNWvXwIdAqj3MRose1MtcMmjYCyQ0ZHfGhZdgrscZglRHwYjRts2RYlfS1RmPo9wucA6c0pZE2PU3wBCqWjcdNFuhoKG0hJhwxUpaaGAoqrbG2QKnAxrhHPZ3Q375IbCPVYMBnH3/KYPcKbVOwOdjARMPmcMyqnVBZy9HBMaul48LmJhcubnLn7jG3753x4P4JRkHjwBYlxkSiEiC8tbsFwTObTVAuEn2gX/XYHIzpVSWLxQLvwZoS10hieXt7k8nkDGsGTM9mmGGf0XCDJXOC9xgMxmpc6ygKy8l8QlEWKGPZf3SY1t2ILRTOeaazOYvlgvm8ZWd7m/FwAEXBYLjHdDrn9t07HB6c4FcziivbGFVRr2rufPoBXxuUnN66S+/yS+xe+xYbW9vUtkaphvHmNtZUzBe/z9H+j9i4eBXlA1V03Pv0AcePTvnLn/0Ce/Eqrz3zG6xmUzY3LzLcuMz+wRuoUDIcRP7x736XH//oz/jsw1u88c4nPJhOKQpNsBbVBgosPQLf+/Y3eP7FG9x6933+n//in3N6fMbGaI/Hjw75z3/zGzxz4yZ/8Rc/5H/1v/nfUw22QY24+MxzbA7h8MFtbl7c486w4mRyiqsM2xslg94F7j88ovU1dc9RR8uiv8lks8fOpT790HK97/n6tQGDVmH7Y5wvaIqSz4sSNTYs8Si1QhlDqQzaBQweq/7m2vu/fHxBskaDUmlTxhARJ0CldQo4pc9X10QUQIlduVJZNx/JldViha6hO4ckQQtboKPG+UDjHUURKG0hYELSwSnj2RCClWtA0fhkcBEdMXi810kSJ7b+MUas9h1PFHwUti3J+oypRO4XdWKJ0sISFMHqrp5DaYWyAd9EbNFP31U+z3upFVExQnBiaALga3wMVFWPXNMkdV1pk1IaoyvQkukVJ7EANgWFwRBDK+RW4QlOoUIKIgNdLVoO4DQmOb9J3VxIme4MppVONVyZ9el2+XPyKYVkArxB+ojJXTdKEdCMrJKGosncpHPgUrqz0M4lb5GQzFqaFOz6FGPkYCDVyiiXMr3yP7Gsj+k+yvmttsRgsMqycBV1LDFWGjaXVjLLjQMdLcvSMG8U46oiLh2VVpRG0bSwNfBUhaOwIjszuo/OmQ8ljWaVEXbVaIWxUidnTeiS9ToFG92Mz1JcH5+QdMnYrp3QcuI5xsh06TiZOnoFFLmOKWWln0KzL/+Q3lA5mRA7K/2opcbHq8SexIiKc6jvEWcnXByNUJXj8PEEpTS9XkVf9TiLx4yGA3xwNK3DtZG29fgWGtdKrZc/wyhL0CGxwAptDb1+QVX06PcKql5Jr9enrPr0igprS7xXaCtNG2JQRJ2SCUnerUzqxRVDIjUihJAI8SDGHUoBHu8dzrWAp3WOxXIuEqRWLKC1guBEUrnbD6wO3qKnX4Zqj2gqmf+k5TxlYuL5wJ11YK8iqU5OZIjZu8NnQBdjynXEc+Dub4AW8jKVVs8YkxEGHYMTCRDUE4xhJKZUYq5pzc+s6mzwIyJRNR3Ayt9A6szkx9B9p/XXlN+ENHfysx7U+rufN+gARUvo5KRpFezG4zzbloFjTCYFUv9qUOGcHLObw2uvyOwEe/48ArtUB/LWbJkkCju8ex4Iyyw7ZzaV9vQO562fmV6l6VUVbe2wpdT6EsFFjfbCvrYu0K9KCoWwxU+PL/Wo8UQr7Tdi3VAYKUvxXly0cyLFlAVlf0C5scnWpaus5gsmpxOOTw45OTsENLNVjbYWmxyiVQwMen2IgflkhrYBt5rTth6jS0yI4sRtjbT38WIx651D6YDWDUVZEVXAFiUWw8w1HLslQQWM1TTBU2mNpqG0htIUKGVoXUvtPLU36KiJLrAxHBB9ZNUGQhsorEcXCt8ECl1xdjzj8saQZ29c5tuvPs98uuKdzx4xX84I0zneNRAbzqYTCJ7dvQ22Njbol4bK9Nm9sstJW6PPepzOVtw9rjlbLJPHgEKpnJB2fH7/Nq4JWK3pVyWjqs/O1g6ayMnxkfTbVRFbiIlJ40X22esNsNayqhua2ZLxcION/iZ1vcRiadomtTCAoujLNZcG19RoY7DWYk0htu5uRR0cB8fHlEXBaDhm98I2dd1yMF+wORjw4nPPgVvx7OUtxv0+D/dP2Lz4AnvXf4V6cczy7IST+i2K4UWoPK5eUNoI0bI8rnnzhx/yt//pa+jK0x84BsWUO5+8Q9+MGFV92vkJs8khV65d597+AQ8PHtE2hqIquf/wmJMzw+//m5/w+PiY4cYG7dxLfWC/om1aGhwfffIp0WveeP0Dnrn2HDvbY/bPlsxPSv7qz9/jwe2HvPL1V3nuld9EV5sYA6YqWfUWjPuBgw+OODo5Zh487bTl3v4U5xYEFK4xVHYDmhVjP2Hx+vc5vvUGyhaclRr2xlgXcL0dTuOSw3nLYtkwefwxTi2pYsBGS2g9qzpQFpbmP8GF9osBZ2mVV8ksQlGkXSWKxE6JO56YshswSijttPSLdYQEwqJSTAAlCe01CpVs3hWwuVXRNkYYmwBat8iGqiAaVJBN0asCFQIBgxFvfow1sunkInwl/cWEJUoBDQEdPbluQHXBQ4ToIFip/YoxZQQLjDFAELkhmuBbCI4YhL3zQeHbGhPltYpGNjyD1EhEUEonZy3VSUSCAm2EkYmhJUQnJgVBWMdA22XvJVJJDo4pyx9DDgJSBj03Wgbybq6VwceILaQpaK7fyrK8GJNmiCAuQ1ohX7fFG4/RIiTXURbPjOka5+R7BY9L9VhRK7wLeJ+y5NGysdEKA4ZD/HwUYiyikymASRKd0AUkkB0mpQ4sxtR+QAUBTjqIA6iq6VvNspb52Cs0TmmqnmFVR6bOUo43adyCYX/B4aJg0G+JaKy1mATAlNaZLkElxiG3g9BYjFVEH3AxhzupBoVzpgjnA5xOmkWaX6oLliLgU3POHLDmmheTRoH/hEzM0+OXO4TNSEGxUil3FLNKC08AbejrCYd3f4Gbeb7+6jcZbm/w9vs/prIWU1lc21CoAmvKxKST2oYAXvo2VkWfGANNaitCdHgfsdqA0yzOAqftWVIPCFsvvR2lf5TWsLuzyWgwxDlPiJoYPcqkulsjFss50PetF2OR1MIh5B6CIeC9ovWeVV0TWkW/Z6R3pC1wrsVaI2oCJ+cPPrI4epf++DKudx1bbRApyGVUkNh+levGZOXPYBGlWbcPyPVhkJ00BDScY71ibmpyjk2CzrxEZEwkxiqdN5v5ENdulYn9UakFQAScyvd8XQenUJ1xxhNwKn2/teut/Mco2dsEACUWKiPI9CxrVNd6QOfvlc/fmXak+tx0XknXmSfAn9Q1qjVTJRcsScZ09TFtdhlE5YSC/LMkjrIBlrQ3WY+tJCFC93KdrivXiIcQur1CdVcFpF6YZSm9M21l0TonKKW/Xt9aiGI2oYzstibbiD49vrRjNhD3aNc04KGOQdr0WIBAdBEdNdaD1SkpZS3lzjYXtrfZvXGF2ckxR4cnnBwd4mJAGUUwERsNWhlGozHL5YpoNLYweL9AA027xGiDtVGS5LWYJ9hW+odVtqJfVNB6lnjanqJREulU2tMrIlFpam3oBUN0kaKwhNCwt7tFPJpIl9J+wLc1F7c3WE4W6NjQKsVi3lAWFT0M21VJf1xRFHC0avmz1z+UdTIWLJeOYeXZLEsu7Yx4dLjgeO4wdeTDzx4zqxXWFDw+qcVJULccH02YTFpi1FSVot/vM5vP8B6ik+fYFgPZOxowVYVrPGfTU5wPVEphlSV4KKqyc+euyh5GW7zzeAzLVUt/0KMaDro6NhUjeEW/GIpM0UWUNfgQsUok8sqUlErRtEtqCs6coV22bETDxmafy8FzOpkQ2hqiZ3I24533bnPxQsHf+XsvEvU+5XbJ/icP8Y/vsXXxBTaeex5tLrB6vM/i9DHDnkU3Ex598ibPfO152nbG9tVtrrx4neb1H3FjZPngJ3/EqAw8e/VZfv/7P8a3AxyO6bzmjZ9/wM7OJSbTKdpYTICi32PVCtta6hLVKu5/OuHv//ZX+PCD27x76w6YCq0tN67sMO4vubS7wQvPvYYpNlgFTb/Q0Kx4+4d/QT2fMhpu0x+NOX50Qr1Y4Jaa1kGMAowdc2wR2AgN83d/yFYwrGxgY2+PYqFoP39IPSy58OJzfHT/PrMIRespwxzvFKH24p6uIrX3FKb3Sz+nXxBzpunkaJ0EkcTcqK6vjCzwnlywLB16ZPMUx0fJnhBzD6vkApjZJNZZSempRbIYblFRgn5xe5TN2YUayewVAjR0ajJsdLJah+g8QSt0YbqsqjJJWqM1vhHgEKJcm9VarE1jJEYPsZBJpC3eC7tjtJyzbaTRslIR5cXaHhVTf7KK6FtC/n3w6fpEpikF/wqjdSfXkUywFutY3wiYCxCiRWknwBRQsSUiRicxaGGujIjsOo5Gi84cJZmrpCjqmDNhNQXYaa0gCPA22kjJnIao5fPEXEVjgkGrlcj1lCcGQ9vCZ4/mzOrAzshy82KBUgUYl+R5Ue59avasdYFGo/Ep6JGMvtZG6iLItvZGGD6d5pHSKKPAK7T2jHo9Tg7OcLFFDyKV1rQqsGkNFNDzSw57Q2ILNRE72mCyigyMo/UKowqs0clVRUmNpM7JBJ3GSUmiQSmRq6IxINJQUo1dXLMuMabgJkpg6iM4HVEpusvStJjAt7aiV89MQY51M5h7eny5RxdoZvpAk5IIIlMktMyOP+X0+A7Xd69z9etfYdUobt19l9nxjOGwSsG/sP9lVYGKIq3VGqM9Whu89ynQlefKtatU+Fzg2kZaZiDSlOAVJpYoo1C6JXjwLqCKktff/IjRwPLNb3yV3c0NorfSg1LBsm146633AU1Z9iit7UwojBZWvCilplKjKYqCom+hH5K0TcRKvarCWotzLf1eL9XaGryLLM8eUB8/ZBUGjLdvsLF5BW+qLrDPNVk+uemaxIhlQEAyEvIJiKiQWay0d8S4Bnh0pBi5Bi0m6iomoyaIiMPrmrnKACbbcEPu4bhm4FSM+HMYYc1Uxe4XT7YDSCAx/eQzW5VYbpGdr18Tkd5qGXjFmNnFfA1p/T/379LwOmUFujpVMRqIWWPYyQ5DBzZJ4E0AlOkSDlopnE99P5IKQYeIC1Lvlg1IYrpXVq9l1T4l4awSab/Riqos8N7jM9hOoDOGgIsBq6QuWsY5AbnkTuqJqDYlYp8ua1/6cXL8AFsUWGtTWUVBoQ1WmxRTyFzxPtKmJLb3jpiaRWsD/esXuX7jGheXDc18jg0tD+7exa9qlqtA2y6wZR9T9aEIDAZbEB2DpsYazcHRsbCkSiz7e0aigbJnQUliteoZnAq0dYMJmuGgT6H6uGBZrRyLdsGg109O3oYHB4csW0eDxjQOozT3T47x7XqtWAUPvqU3rKBnWfiG0pS4peXo7jFaW5x2FKMdjhdLbGUpNkrGeouj5YLajTi8MyeEIasW6tiijMWjaIID6+mPLM6DLQrKckAMkujVukBKR6SgZ/fKNV555SXefPN1zk6OKcqCqldgycVBYrtft+IC2B8Oab3ErsvlkuGwTwxBWMgQqF2LLUraICJVZaD1gX5VYKqK0DQQFP3BCEzJ6XzB46M5450R21uXubh3keFgh63BDpOj+1zd3WKrV3B89w4PPjjl0vUdsA01BbYq8NpjCgGB/Z0LKN2nmf85ekvx0z//PppvorWh17/MyXTJzpVn+MnP32O5OuGVF7/Ow4Mzjs4W6GpMqS3R1SyblsdHJyzrGaYCrxsGG5ssz1YUtodrVhLzhshf//wj+psXKGZLVs2Ma9euweqUGzeucmF3mzZMWM7uMjm7hxpbPnrnXd742S84O1myWAWcq5ieBAbDAq1E+bX0nlAEUIbYJmJjuaLptwwLy/PVgLO3P6C3dDA5o+z1+fr2Du88OsCFQFCaYANNdFSloVeWBJeThL/c8cWAMx2R5s5lqk/wKCzoQIyiaY7aQUwgLmbZgzAhIicRCaHEoepJuaMCpcS+lFR8LU2dszU/RDxWW3GKzFqZqBDhnpfCck+yX81Mkye4lqhzw2OxZhUpiQQExmq8a+X1MRCCxquQgitAR0yy5VcqoFUk0IIOmMKK9WoAHZcUWooZlTaUxuKQVcMai1KSpZKQ4txGem4TVz7inJf+I17RNaBWAZFCSiZfR02I0j7AFNA5nvmUjUWyxeiAUeJnlm2rtRaGwORNMv1FahvF4ERZWaCVF2DtCOLQpIXlAwEowUfevbviZOHFMXEV6FeBvS2RCZlkTmB0lLmhpEeesIk6jWcymFGhCyq01qkmJksHZJ4YDSE7KuIwpmGzFCbAFJELWuO1ptQKbT22F7l3vKQfIDSKSdljuVqyszRETGqo7QUsmuwkts5Wo6AwqVZSi25f6VRHFlQa6+Sgp2IHzETsGokaisQCuCeCKwFsW8MeSk1wUfLlKlEI0Z+7P0+PL+3oRF0xzTHRAxPxmDihaI/o2yVbL7zCcOcqj45OsGbO/U8/Y3O4IcA6JrlQtqvQGmM0zjlZy6L0MmvbNtUGBYyV4mdrFNaUNE1LYQta1wDilrpyNfV8xaA/oF1FVssJEcW9R2d8/q/+iMIGXnz+WV5+6SW2NrfpWcv2xg4aqNuG+XxFr1dSFRaISVKTAIcWaaO0I5GEVogOHyLaCHvmfUAhrUnQkaoqhIHxYFYz6qP3uHXvbfaufJXR3vOEmHmhxMaTTTdUMv9IjHNQqR5OdS6YHXICzrPP3eOiMmZZvzaqbJSypt5ilC0y9yAjqgSAcsovVVdFEiCVc2cWKZ97/Vmqkwpm6WXIDF9+PkNIwGtt3JJLgGW7llroRGcBuRZOAhB06kuXPlh1csT1AiAtatZjdL60LAZxEpa1ee2RkuvnQpD5J9eeZK96fXalFUWhZO8iO2CKM7Hq/i5KAZOMnnJLBBtTcksl86ruAsP6fsQgADABUimPeHp8mcenP/oLfPBEY/ExUvb6oC1og7GWajCg6g1kTbCWqt/HaNslZoxVEBtqB0VvwNZgi5N791nNJXDumZJVW+MCFCpI8D7YSHPaEZxjS1mmkwlt4wkeWjzaaFCe1WohToTB4aKH2NLraayC1WJG4zSNV1T9imAsK++IvqX2Dm00vWjQEYaDMYtVy2Qxw8dAWVlUWdA4z6Jt8GealQv0BobBwIMdE42mN+xTlmNcoxn0Rjgd2dh1PFctMaZkLxmRKSXtAYy1WFMxHF6UejHnMWVuARSFlYweoyWpZQqTEmKRB/uP2b5wgYuXLxN8i3eLJAlPD6xSLBdLVqslMYBbebQPKKOTtb9C+SC9Z5XGtSuW9RKtYTjso4z4DCzrFcvlkr29SyybyOl0RuNXjAYVVX8ga4S1FD1FezYDe8q3/tZrDCso2KMqDLFq2drbYDeMcfMl08cPWKoVg2vPomNBqCbobcP3/s7f5gd/9Mf8we/9BS8+/xzWPOLnP/oZUZV8+uE9PEus+oyj0wnz9hTKgZR2mAK/apK002L70B+WPHj4Obros3BzCivOiorIz97/oDOlGvV3OZ1qFlPLSsP+fM7P3v8Bf/XG64TVGd9+7Ru8/9EjjlcXOZiespwvAEWjB7RO43o9vAuU9KQPsjY4o/HaYfuWnor86vY17CcHlNOAViUVloODh+w8d4Vd3zBvGjRD5jToWKNigzKRXlnRrH75de2LcWuMkoFBiUROjA6SQ1MQNkgj1vCoJ2VewpyYrgZJ5YLgtOkZleyIFQmIJFcnqVCXWjRtZGONeWPQKSssrJXIC6VQHg3Be2J0Aq6MNI0Ovu2CkeCDWMmnuietFUoVmMQskWsa0vlVVITQ0ja1BOVaYXVB0AIoQ0wLT1AYbaVI1DdoXWCKEk3Eewm6I6CLPB4FuU4uIOxXu9AobcVgQ4X0XRPzpaSBYHZjlEBGagFDIAU7OXcZpXF0TNa3htQYUXXsWY4xxBo5F+xKU0RtFMGWhBiwUer0fEiOmESULpi1KybzBqtFihNi4PODwKVtBRq0jhK4mgqlaxTSLNykDX1df5eAu7KyeSego00Uw5HcIFqLA2ihDZuxxhSRwmgoA20wWAt1dBxMNVWlOVs4XBNompa2NPRQ6HGffd1HW01hpc7Q6LWMZ22Rj8hkjZjDGG2lt1GK6ELMBiYhzWgxPMnBV0yAq2PDQjZzkXH3KlAYjc3EcXomYgKoah2bPT2+pKOzkldi96BDRClPz84o2wPKymP7e/S3nuH2g9sM7Jz3PvyIvunTBk+lC0II3YOkSOx+Uhd4L3M2aglKvRd3RGtlDXVti7ZGahASg12VPepVjdGK0XCMxqELjdF9NkY1h/sLCIbp1POTn7zNG2+8y9Url/jmt17l+jO7vP/ubVS0bG+NUrIJyaDrLGOWdUQcQzXRhO7vOpkH1E0rdbnKopKpkjBbGqs09BRutuT65RH37vyCxkc2LzwnfV9IgXhCEyEmuXNUnRxR5HcRr1L9S8y27ImbisnFMe0RdOAIGejkSJvB2Tmo0TlDZmYqJEiWROBpvU5YMQM4YpLMyzWLw6ycMxuBpJEjc2PZMEae9dj1PdNxDcxilJorECZN5pyszz4m2WfIn5Fl6elzOjkFncKhW7DJ+6D8HGKQ3pnJDCZ/r4xwXZtajqefvc+1zTrtGZ6gpY5cAuhI8OeuWyVdS0poBiXmTD749bzKoDapw4HOaj+rbMhxwdPjSz2+cuNaqtuPrFxgvLXNycmU5aLG147F2TFn7jHL1YqiV7A5GtHOa2LUmKLAVhZTGkbDHYb9EXOjOTw6kFrPYIhWMdzc5mw6wcWIpmXlVkRvUVhh7aqArQJtmBOtxiuR3dUagtV416BdQ6+QOnJdDFiGFctmldy4C1QjPgbWegoDA9sTkOAtq+iY1C3BOUokZipNSSDiTKC3tUk12GJrtJNco2NihyO60KAUVV/iiRA1zin6PZuSwEa8EGLEOEtRFEIUaIVSLVVPU0cn604IkrCOChcalPUoJeoo51piCBgLrRdQossK58X9NkaoioLN7Ypx2KCuGwaNp65rVnXNbLZEe0WvrFILIknolEaux0SLtprgYb5YoI301LUlFLXF6j67ww1GdkBQBcpU1PWSpfOsVg2P7zyE1ZRLFy7SrmYsZmf0C8XelR3qUHNhb4dP3n6Ta2czdnYvY2wfO6uZHp7x+MExb735KY9uH/PNX/0W+48mXL15k8PjKSeTY+pQYRiwOjMYo/H1lK3tMZM6UJUVR6dnrE5XDEZDlrMWKk0sSpa+JS5bdAysamF9g/csmwY1ndArDf7Y8+mdM5arFYN+hbGRTx78BNf2uLr3PKWKHB0dE9tA6x0LP8VUonLJvgsugFcaFyFojVct/oqmvLGF3io53T9Ft4HxaIRe1Qxty2y1INKjCLL2R5WBc2A4KH7p5/SLcWvUEYJB6TbnHjGUhMzsRNHsd4XoJKAQpe0xyiPMWwCKxLBlkQi0DnqlsCt5f5JkaKLAERaNmK15DT56otdifU7A2AjRobRFBY81WgJ7pFjSqBIVA35VE6LHmpjkmVKQb20lmWGdTTsyKDCE4EUm6Vu890StCU6aUovEUrIrSkudXK6NsLYErQiuxhYShQsjEuT6lNTUKS+ujU1ocLEhhFoMOlJ/ItWF/ykQUR5tFRHpGN81Q9Yp89qxkxJWGG0lex2h0Dq5WSSWKAMjnT5HSeZeWSBJMnOcYCxo40CVGK2ZzAR6j3qwajWDnsK1oK0scDIPDEaBURkEI7u31qhYoo3HanEEzc5hKln3ixtkajSrwNg67f6GntaoItJGy6CCx2dw3Io0KKjAdNUQlBQWV/2W0xrK5RxT9piftpi4J7U4RNLXTv+X/ka56XZhPVBLQayRgvaQsugRknnMWmaU61CUghCzUUvMcRbR5/oyjwqWwkSiS09V+uxszfL0+HKPANKzTxmCcvRMw8AcYdwcFyKYbfq7V3nn3V8wVA2Pmn1irSk2DGVp0nqXmKLEJsQQiSYF3glRxOjFNU1rmsZ1iQBjwfsW5xRlVRFcBALDYZ+AYblYELzHWmlcb4xhvLnBo4dHlLqE2KOuV3zy6T0+v/2AvUs7PH/zRcpC4VyDNSVlaboAOXTyQo33kaKQoNo5R1mW2EKK7kW+nRxvQ0BHA95Rlj28D1hj6A96nBwe8/zze7T+hOXUMNi4ScSL11OXKAJCcqLN8kUyUxU7KSAp+Zbj+AyUyPVpUbLN2e8vRp8cNJNYPdVxRc67GeaVPN+lBHoSmMh1wPJDSNdN98yqjkmSiw4J8GVz4pgK37qkYXpNVmbo7kWRLgcTY8edZeCT1wbVMWexu9bM2MXumrJz43n6LAHMrs5MgpCYX5vYRfnXdI4AAQkkRS0C4FGtz3rQdM0JkOa9N1GJRmm6ptrpOVAK6fuYHDlDYjqNRqTd5xi7p8eXd+ztXCSiaFxg2Tg2dy5gYwnjiLUFZ2dntG3LvQf3GfVGvPDss9SzU1QwNE7j0SybFcbD7GhCaH1ijw2D0YjpfEoRSrY2t5jPp2xsbKGUxfvIfDZjOllirMROtugR50uUsuzu7lJoy+zsDOUd1kCzagDNarGkaR0Bi7KSDPcBGtfQN0OiVhTKYo0RYx1tiFFRVQMubA2JCoqyYDAaiXrJiG+Asin5oQpSJgMpq4E2tFiTDMsIydFa0qs6JWeslRDaB0nCaq3xTlgSY1OMkp5XsXyS+j4VIXiH0cK6tW2Dcy0heJqmSYAPVqsV/X6fopDerkUZGG0MUCjm8zlt2+IaR9t4IlJ/F6OibmvqWhLZPauxtqLXl9q1nonojTFt3bC9sUFpJaHUhJaDkyNOZ0vCquTTW4fc2IONgeXe/gSjB9x5NOevP/qUS888w5XVgI8+Ubx16yNeuFmztbXDqdvgs0crBhe+wjOvDCjw9Heucen6s7z04q/QezCmf7jNYLyJC4atS5uMx1tM5zMwcGFzF+c923aLGKEoS0a9JcpodCGlTHiJt33yT9DaorXC+0BZ9ehVPcrhCu9bpJgnMuiVeK+JxYjBzohn+xdoF0tcdCxCk9oZCDED4Lwnm0ahoLCOjeGYi+NdzkYTpoWhMhU3XriIHwzZv/eYzcrhvaZ1Da1r8MHjQ0PjllTVL19L+8XIGlFgnATx2LwrpUmcFn8d0+ZvSWlkAR8xvy+BnSgSDFITZBl4ZDft6s9ikqOIMpe8+cWQnAFbAUHaYE0UEskrbNLmqiiyS6NLjBUb6RhX0Dii84kh0UTj0MbIwxpalCnSJp1q4sjARa5KW413Ll2DSo6VFpud07SlNNKvqPUtWllB1yomkxABVsZojC66MQJwLtLUPum+E5ukDTrbNaf6q+CTy6QSQ4Cu55EOYo4S19nnrt5LS8ijTEBZidRMbiKtFAqptxIsKKyZMREKcQgTkB2xKIoklTC6YNnIeQdVj1ef6/P4bMW9x0t0jJQ24KJFRUNpk/ui0HSQ5K1klkgbkUCmeh8xJFFoHaX/U6pxLExB1BG0GH+cTi3TJtAaRVV6TlfCVhgtoDdGTzCenlEMCli1MKDGEKlbYcecT6BIqWTnnzLlWsaxND1C0BSFTsyZyqUmaW7mACsv7OtATEWkwW1KZKe3i+ulUihds7c9wJ8tsF4aVhqyUuhpGPNlH6K2VRTUjKspanXA8mzJoLfF3sUX0YMe77z3E/TyDLVlObw7Y2u8kRItIjeTI3aBvjHgg+vqvcL5glIFxkAISVaoDcZYjJa6jMIWKC2BQAyOQb8ALK2XjbUqS67u7RFaxdlkisFCGBPjjFU75/MHj7l/74jf/tu/Ra/XJwSfmGBD8MLuZ3MHaxFwFOR5K0qDc22S+kJhRaIktRQqncsBCu89xig2NzZ59OCY7Z0NdirNfFLD+HlULMggIKW5UsuCDIYSFxUV4GUtjklKHM8ZcCSA16WmzusccwEXmW2C7KoYEdvtmE6WZYQx0VDSP1Kl+5YTJyIBjN05FTqea5qcZJT5Px34IDFlnZRPdc95DOs2MHLWjMJk7nQGNAmuqbhmAX0CfWkgyF8yhJgSoWl010i2A3/n/4znwGN2lszjFmNOnMo86I5cA0c2D0mmXhkg6pxpSsteZitVvi+p1i29qE0B0HlG8unx5R2j8QbOBQamoO8iu7sXmU9r6rZluDEiGJFZDyZn7O5eYu/idU6tZXo2R6kKqwv6ZQnRMuyVBNdSlpZmvqJZLHFNSz2bM7q4x/FJQ9N6xsMR3kTYAFVFTvYPcHXDYFixXET6lYCj1musHaCNp1dapn4GqiW4BltaqrKHMpFFvUi17hIvFEVFqcRsTdtIORjRH4wpdImJkrjKNZsBT8CL1Xkb8SGCDUSjwRhUtF3SS2kBb0Yyz3jncD6gU18+KasJnaomBEnKxxCIbV5fs/JG40MKFoPImV3TEmNLWZZAizGWslA0bZ0fW4qiwDmJ+7Qu8E3AWsNwsClulwSmZyeEGGjbFq0DZaXwcYUxhqgdxoJSgbpZ4UNgNB5xcXfMsFeCgXq+4P7BMQ+PT6gbR+sr3vxsyoODik/vP2Rne4fD0zne7DGPu0wfVny6P8OrqwTtePxZS9keEbnOn/70HsYa/PAKPnh+dmeKvvwit+eKsPkMO+MbXZw3uiTjMkZaKBgjPwfvxXU4tW7SaR3RGrRVFIWlbRyz2Zy6bhiNhhRFQd06QpDxITlpS8wv8t3JZCqunUPNRiHzJRjVGa6pGKVulpiUfI5AYBA96vFjpocnTE+nhJXDlxAHAecbnr35EptY2uT7EL2ndS0urHB+yfHJo1/6Of1CwJmR4isiLoEsR+7GlDNp8t1VB7AkmeYl65oeMililO3WKJKDlzAnSon0JgaRWfhOygfi3OfJNuwxIvVVybSiKAQ9xyCbgrJWNj+k75XSLaFtkiBfip+lxkfAi1bSUyz3AxHAFtb9YJTUn/kQCD51Bk+bo0anwmcEFGrJ6GbHQa0jznuCFu2/0hZbJHOVkMxRiIATqYsuRJqjU+AXFbYQUw5FxBiIvkTpKCAk9QgTt8kg4+ARt0nEhyQvIEppaSKpUp2gUqm/keqcLVGgjRZmjwLvHSG0KQARoOSRfm7KiMnHom4obY/DiacNhnv7kReuK0orTppKi/OhNkV37vzdQmwxuhGZTBT77rzY5f5QWkeiMhRBXOQKY2mCYdLAxlDAT5Yoeg9o6b/ioqbUkbaQxtfjUlNZS6+ImLKPKeouwEoXdK5PWxrXIskbbEHUqltQu5y8UoSgUVFq4mLy0vb5dV2gKXGUjznzHfDB0C81vlKwtKnPlAD2p4XzX/6hVMtAz+mrE9qzMwwlw8EFXnjpW6xMy09++kPao30uXt/h/Q8/YNDfoqiScVFqHN0Vc6asZtum+rHQChBJAbrzLTFKc3XXOEDkKBLcenxwWK1pao8xRWI3ggA1hWR3VcFiPuPrr93kZz//iNmkhSIS6OHqhgcPT3jx+jN437JarSjLMgUVIQFJI66jaWPyXpJYvV4/Oe1B2zoKW6aGwZIF9iufEl9RUI6X7LM2gY3xBsfHpyxXNZcvXoBwm5YrODWQZJrSBJXkjGT2R+UfkHREAnLnAILsH5khiumZXCedRH0hL4yJqToHlZ8AJtnt0SObs8qALEmTg0ouhlnamK47djSevCYHHBk4BZWX8dDJKQOS0MpyzA60sa4lE3ddYdyJ4k/bsYwqu0CSwE+SfeYxius/z5ugxO69dK1NOnv+/PdOVSG/zeYQAtIz4KMDdt34ZsIh/3OIXQNt6QiTIGWu0+sMTeITUu5/vw/b0+PLOKphSeGAWFBYmB6dYIIGr1mtGqlbV45BVbLVL9jql5itHaK3tE5TN40A9KhQwRN8y3wyozesKKxiECOTyQFl4RhWEdecEQYVuuhTlH3wDSFoXBsZDjY42D8l+ArNCFUp6lXN9saY7Z1Njm59yMZoi9B4QowE7yiLis1qiO33KKseVdmjNCVGi53/fLWg3x9iihIAYy1Ga6wqiHiUsrhWZJpRaVQh9K2PuZ8pgCIqS4jSb1dYEA9BjCNUlDjIu+SFoBTWyNoffMBmUKBzMiXgUnJHIXFR8E6AQIC2EYdo5yKgMdqSnX1DCAkAOnHvjQHXNMmpvMBazXC4yWKxoOj3qHVNv99nWc/xQVoJxahYNWLm40NgMjumXxl6vYKH+4fMvGM+r2mXEasMhS0YjTYxGyP2fcvhaUNUPYwq0JWmjZHVfEZRGqxWOCdjhgJlDI13CTcbGtd2TLokdaJI4QmEsMYKQFpbxLTPRY+yUeT+CBu4ubHB5uYmq9Wc5XJO3S5oXUOMA2HOjEFZI2u2UswXS3YvXODq5Qs0Tcv+w4dMJzNRy23v0iuMSEC1hpAJJMjusyiD8rDSEFWDKlaU4x7OiQz1bH/O0ckRe69eYBmWaFNgGhlj5zzeg489qurKL/2cfjHgTIk8MffMEkl7kl4EyNSS1KK5tIgriBodxZEuJK87k7iFrPvX5JqzIIuBcEWpaNJ1TUpBp3o3umJ2pX2SHEqtmXcttqjELbFQeB/RiREKKkg9VdQYLRR18IBVWKPRtiS4kKQXMSF6aWodQ3rQQoPWHucS6o+K2KwE0JQlKmjQFcpaIjVKlRCCuLC5BqymV1qR00VoW8GtLihCVFRlSUnGtwGU5fGDY6lps9m5UMamNxBZpIxfICqbatMUOTmtYiDqkNwCpc2BTZocrWLSUOu0wdp0H4TlEnCWnesKvIaIx1hLW3u0CuyMDPvHFlNYHhw5Wh8xOnDlYh8BweCtRlvp0aSTntsYmwICkUxpVWFUjdQ2QmkLiiJJTo3FIIUMpZFrK7TiwpUthjtjxj1FUSmMCrS+xBaWwiqpNyR9Tsq+BS+Nr70KHJ2ecXZ6SuQqygiwyjl6eXDFoMRqRfDiLgU5wMjSV9ZgTa1/zBnmmIJJmcvp35XUobjEWBY9Q9VY5staAiKVmdEv4sl9evzHjm3zmLY5ofaRQpcoxtx85TtMmgP+6N/8z/RCxYtfucT7n35GaCy9jYKiKAGPbx3GFvgo61a2r1P/H/b+rNmSLLvvxH5rD+7nnHvuFHNkZORUlTUXAQJVAAGSRtKaRprI1vAgM6mtH/pBX0EfRo/9Ij10S7JuMxq7JSNIWJMASBAoVKLmyiEyI2OOG3c6o7vvvZce1vZzo6inklUKD0y3qsyMG/ee68eP+95rrf8kmCVyUbRUCmOlEJcybuzRqC9iG4ZS0X+MXaAl4yLkpHUw4PARtsvCxWLFarVmPo88/HSJhIL3jm4Az5T9+awiQIWcEyE2CFggq6suorVYCDHQNNaw9X0P4quNf93EnKFn3gdKNSsKTWNDq6xoLoTo2Z/P6bqex0+ecutmx+GxsOgP6WSfQjRtL/bcGHo1arbsGMEq5cr4okjBVYbGSNMeaSimkdU6JbfWwBiGtfGkaj0r3ZsRhRqRHXaP7a80IvaS9U91n9uhTWPjUVup6oJtBiS78xxpMqO9vb0xrc0V9X2OzRqvUT9HG3yVq5Mr9euF15qqsXGDXXG3a+xe+7syZrPp/3dTpONflLrWjOvV2OxVdPVXELjabI6gpVG/r+IIGGmgFb2w9zf+nNZ1+Nen/nx5/PpH4z2lOjIOCB998hEDgfZ4H9dEGAp5UEL0NAiff/hLrt+9zXw+4dnJJWeLU8T1uBKR0tThLlyeX+Ibz9DA5GifxXqNloSftuzND4mhwQfPbK/lcd9x48Z1mmlLnwZC6jm6ccyrixOu37rGV959i5cvnyFe+fZvfZ0yFB4/fk5KhTZOadoJPlCNf2yovR0SRQuxbclDIg+JMGnYUJg2gShGdTRX3Layi3TXVEkplFzMqdWbWVORWh14j2TTUAYxp9tUWVIhRBQlJVvPnXPkSr0b4yaor2H2ubZGlJys8VCl224t5mmcuqC1drX1LEZjKGh1/Dbvg2TGLkPYGTq1bctqtcJ5z97+AUnh/GKBOEdoWnDGHltfblhcrojR4gi6AILH4ZlNAtEJ2RWWaYtzFpFQUqHfVPZVXaBLlxnq4uh9X53MraF13jGoJ4unDYIMEJwjymgGZWuz/XhFzWtho2qgjyL4YNcwp8SLFy94+eIFTdsQnHDt+EZ1Fx3ZKrmCOo6cCkNvLqLPPn+AE890NuPg6LjSTSuVX4SieTeys2gmrbWYGfJ5BSnQFsfq2Sv2es80wubBS0IzQwclOyFtEy2OYchmpuXNBXU6nf/az+lvxhBExMKm6wXWkd6VC/0AyoCjMTSlFiiWNWO7VxkECaZ1yk5AB7yayQcyhjxX6JgBccWmzPKri/3ICY6hsc3MmROQU8W5EbIeNz2Pc2Z758WhpaWUvm5IFnRNRXXMvr3mdZTRxEJqgSKUYSD1Xd3EBB8DuUvVfj3bQqhCiB7nTeMWoqsmIB6VHk2uxgC4q43QSMz4UCgl4EPeTUaLc0jOTCYN600P9IivVvk6gLR4gSQVrawF/ehEps52Rqdae2e16ZJrqkGBA5cZ3RANwq+fXXCEGEBGlLCWRgohCvSFEAJRHN98a8JsOuXurcg7q31eXWRuHHo2yXLQ2iB4GkLozOgkjA1ivR+KmF13CEYtddEaOc8ua8xVGqDTiKjn3//8JdEVVAPPqE2oQHBrgg/42KACs8mEECGGQIyGrsXgiRPHxEX+8PducOvW1O6PiiLWKQNjtEOIQi4JkWgUMAF1FfPNDifmiFlqITYK+wUhMKJo47JQqalFCQKaC7mvguK6SXhnjeWXzdkXf6wuXzCpWq/m4B73v/IuHz74c370V39BGBre+/YbPHzxkPMXC27dus3h4dwsjbcDeF8bA8AZ1c+NpjpkM/nIxWgp4qpZhqCp0Pc90+mEvs+UXGnOrQccLmRKKnjXIkHIud/pN6fTCV/7ynumT02JGwfX+PjBY1abjklTON4XvJ8w39uvlA1XWdqjJqkwpGzovDNtaYimqZXaGZhTejG6TEUHR4Mno+rl3RBo1DXFENBiAvgnT57TdT237vTEbsHKXSfrHqYfHgv5iqyIrwW8NVFuXOcBv3N/ZNdkUJu3Ut1noWqdbVbLVc7X2CDpr7gtvt4MmgnIldmH1IGZqT6tUSw6Ily8dt6vNXb1Ic1j81Hph6MmlTrcMrdKZ+9spwuTnWNkqQ2ZQxklA9S1vNSG71ckZq81UuM7+k8bMKlNUeGK5iivXQF7DTG4VORXro3Un9+97Z1zzvjadjG1jJq8Ulnd+WoKVT/L8fPb/Ry/ep5fHr/5I9Cg3pGLFfNvvv02F+sNl9sVpURkpPyK0DQTvBbayYzzYcGjx485ffYMFzMlGQVwpK22TcuQMqk4hjQgZSA4x8G1I16c/JQhWwC0jw5UePHqKeeLWGmwHY8//5Bu2HL761+n3Zvy+EfPODq4wbXja/jGkVzk6dOXdEOiW10wnU2t/nDR5CnO6N79kJg2E4Yhox2EtmHT9QzeEcRkNU48Q+ptrSjWCEgt6DPW9FnhTtWN96TUo1nJLtqaW7TWa4aeDWlAgSEngn+tyYjB6ieFkjJaElGEnAZjWqky5IFUmqt1wcGQbP0fhkwbRlaRVC2b4r2jZGMXiShJezZ9Rl1m26+BSC6F3JvMJ9YmMvdbRDIumtSGxnHgvWXRhkBsPctuQX+5ZLMJoNZo+GIyo1wK6my/CN4bOOCCNTzj4EYVHz1usod3LQ1CM20BEO9AB1tHPBTN+Kqpo1xpYX2NvBKszpvvz6vWz1atkkfGh9uxP5yzoSe16T7cnxltvyScC+Y5UAwQEgwAUOFXnH7RQipajbASmjP0A7NN4NF/+ITJxZYALENiE+HO3/s7bAU8LaGd4UNgEgOTNtIER6xuzL/+c/obOJSCLwIS6g6abIl1Hu8zw6AMuWfiQxVr1/BetS5bRfGuqbBCLbrF5qQjw825irRJQ3HJtBkVpXAi1uxJ2m2AWo0YnDPRoK+bn9RATScF8dGatpwRyUSvDFmQGGiCkMfAF+9HfgZmfe0YzTRyMht5KQkpQnAKeHzb4EKDkFAN+KYhxkDfDXVC7UHNhVHrRAYNpAKaEuKtefPOaHFIthtPXRVfW7MwaWBvr+Xy0qbnoJRBaEIECQy5ugYhUBcRyzOzBkFzg3qlaAYB70Ntzuz1BbOlNVvXapvsIPhKefG1iVK7mX3Vf3kHB/uRy0Xm3vUG74Vrh2Yhvlj2tHuRV5eFW9c8ziuNmxAkWoMabCrrsIlF42uIokSEmhNSw3URhyPgpBAbx//uH30F8YE2OlxQe80AQaI1ZgGCN3dFcQFx2ZwfBRsEVPRR6oBB6tfcOCGH3fV3gnGWB63FrKEOmoAsBCm7iTtUh7b6zIiMjm2yy2ey8tts9VWV+XzGH75/l09++ind6dZ+v2jNffqyiPmij/32mOnBLeZHNyhxxQ/+6v/Fo08fo53nq19/k7P1CQ8+ecqt/Tvcvn0Nlcx201HZ04QgV85/IiYad65Sqk1nqlpIOdemHsDcorquMyfHYtPbEAPgTedTJ75Sm7o02OtaXKLiQkE0cff2dabzlp9/9JTVpiMGoY1TRMywRHOpgxlrtnLSStXOhOiYzELd9KxYT6nHOXuG1ZvW1TIKAYSh72maiHOxbm5CPww01VY6xogT4fnzE5brFW/ee4PrIbDMiW3ZI9c8ytryMEIrOhpI6JVuqdTBxs7xbwc8XVEEqUxD23yLPeMjulNGGuLYqFxRDF8Dp9jZ74/GI0WMAbILAqsUxrE/0deez3GoCIw5n07NiXU8Z9398vFk9Vfex+5cKsq0o1eiVw1SRf9G/40dXfE1yucOM9u9sat1aXepX2/i6otLfZ2xpyrjDV1Rx9ebtPGz+ZXpv14NY3e//rVfXLh631pRgi+PL/bwriMpuNgwaM/7f+vrfPDBT3GbtRmCFcFVKLad7/Otr77P8/OXuBCRrJQukYZcXWNbVDNZE36mpE2P9xMOZjNWmws0Z9bnZ8z39tFU2C46XPTM5jNSSlwsDeXp+y0vXqygZB58+BFBHKvLNfNbdwCLk3j58iknL17ueLCT7ZKcFNQTg9URmgZKETYxMgyZGBtq/U7WbOwsZacBK5ibnqI2IFPPUJGuJkRGzWkhmwma2gDN+0jJalb2TlDv6FMiFRtoB1H2pjPSkKx+wIbM1CGWU6sbS0qUlBH1VXYDiElfUrZnPeWB5Ky2dd6Z1MPbQxv8BHVKyj1aYEgJ7zx9nxj6nvV6jY+B7XaLEyFOJ1Z/1yFTn7MhUxRcjLjQokUoW2GZVlzkDaKFGA2dC85VDwO/ozmb7MeTSyHGhoPjQ6azPdvjQovHat3VZmnLr6sDMyvEaw20sfW8Zn4C7CRDREo1ybOBn+2BgjdJTWXu7RB/KZWlUCqrY413JrfKFjpWWWFABVvG/TgNpptOWIPu1fD8bYTZjWMmN2+jl49pixkOxrfucOvrX+d8f5/9ydxy5nJPSh1Dt+HifE3fbVgsLn/t5/Q30px98MsX/O1v3KHGSe5oeaijiSC0dMVuUipH3mECZOcijTMY9EpLY9/n8FULpWA4A1YiC1KD/EqRiqRZk4ZXTERuPOEYjTYT/AT1a0AJ0eF8GJ0VbBPMDnIk+IJmtdevwYijY2EpFpy8M2RQc5/COQgRr4pqg4QWwaiKhUDwE5yPNpXpzO2qXy5JQwEPTgK+LiapWOGQijKdzWpzKWZbLc7ygrTCrc6mAz46Do8MwcnFtGLBQVKp+E42H8dR7yelxqKJ6e0YOdTgGqlQswPnrXGuIw4ZA77FV4GtTV5y7nDFW4PkC1o8MQam08DJZeGXD5d88509JHiW64HVOvHt+YRhKEQf8L7F+4S4TAixZuiMG3XEh0gsA5mA94XgA8HFGsRbFRliOXUHTW18xXJRikR8pQF4kTpxH4909Z/iEG+h3L7yzqUigmPjhpiG0LjTVxOdPldqhAp9R6Vn2gTO6Giyox7VssruOWcF7o6yxNU02YqaCW/evc7po5c84aUJY3HsbLC/PL7Q4+Yb77J//Trnixd8+KM/58nT5wxb5WtfeYvsB376158w94e8cf82oVEuL7d1M7ZA3tHISMsYuVCq/jHYSimmW4hyZTYRom163bbHB0GkYRdMzkAIjozpa12dVDZts6N+exdq01EYhszhwZxvvn+fTx6+YLPekjVzcbng1q1jaxRVLX9nsI3MR1ftnT1OQuXz25QyhkAuiZIxTcVVf1JNRdQavMbuZB/sfRvlxRBhHz2z6R6rxZZPPn3IW/cKh/vHTBhYdBMGnaGYYcjYUClVK1yfm3LVqVT2xNjGVLpMtaoY9xIDrkbivDAag4hemWroDmUbj9ow2F9SpL6qVMdBrUZL9Qe8VKqgY0cxvNJ0/apboo4UVaU2OvY7tFJY7bTHZ1x3KJ8NNu37d0jW2PjU75H6gex0abUAGT8nG3q9/ha1mjrprywrRki5Mll5DfCi1OtBqWievL4ejQOs8VNgZ5BVxu74arHbne/4hr4cOn3xh2iP95HkPX0Pl32mz9BvE27Zs+02DF0id8WMqRpD9Z04JBcmYUIJMHQbYpyQ02DZm05wbcN0OqVpItteCMExZNPfHM6PKHmB84HUJeZ7e5AKQxqIztPEhm2fef7wKcPlhrtv3uboeEpKmQcffsyLjx/QSMQ1e7hJA5II0aN9ge1ge+6QzDJ/SDvd5+iQOmuixSQBw2Zjzny7mlEZFKKf4CaBIkq/6Wo5Wei6DkSIbYOLjem4MJQol0TuC6XKRdKQKKmQ1iskK1EskiI0Fq3iRawmqbXFMGS0BKSuL1DD3HHghFQyORjLwjtBvNIPAxYvlA3JwoZoORvi7V1CMLfH/fZgR7PMpbDpCtu+RwRy6QklsNJCM5vTqiNWU7/NOrHd9kzaSOoHYkz0WrCV6PX4LBvUBO/pfE87nbA3m9PnTMgdIp7BC4NmovO4AlJsHTcG2lXtU7INGoH6fj2uGp2EaK6ZSql7K1aXZ6NMOx/pNdUBmyGfrkYzyTD6Iowmc2IRWq8xFSwSWNCS8UBDoHih10LyhQHP8Vfe5smTp5Rtj7SR+7//O4RrR7hc6C4uOVkt6POAqLFattu13ROp/7Wf099Ic5ZzZsxnMf1vRb5E0VSMB9yASMZ0Q1obmzrWpIqr67/dqA0Yba3EZmx1dLnTgY9GJIhCyATfotkyy5zkqw3FKUU7c28M1nSpeKQUez0sUwqHWVIHj/cmchR1VRtibY4LtXBQh2ACfidKSuBKqWYhebcReudQMRF/EjFIt05RNCdEQxUPbsjqCM4WhpKVtp0AAYdHJVcjkNHxy0xQxAeCt9+Ti8HyBQuvVRLixV5DgWINkE0qDBoXVzfrGrJmjZE1gk4c6ur0wFnT50TwIgTnUB9M4K6OTEIDxCA4Z1Ss4ODmNcePP9qy+lkCJwQvtCHSTiM+9CiO4DIxWOyAd4aKOXGV7mCoQcqhZpeaYUgI43lyhWQKiEzsvhKLovYj6iXBroUzXdvYVNu3ut1CJ2NRJ6Npy3i8TvuxvDVRX+kNAi6iWvBOduhkUCFpLc6qHdDVVFlsCm+d2NWvKaNrmWMYesueKbkWgkKun737sob5wo9mr+XRw5/x4vkD0ztsMu++9TbtoeMvfvAT2Ebe+c4b7M095xeXdNtUjWrsHnXekXJ1OMyKDwHnhdTnqh9QEN3dw6UUYvSklGjbCTl3NZBa7J6todUhRPIwoNhQIERHHsyOX1BC8ORUMwPFc21/yuT9t/jksyes1j1nF2uuXzvCedOjOSdVr2qLVggB7x1931daidhwI5g+IYRSi3e3C50HW0tyTgRCRfxzfWZtwGVIoeJqsbfp1nzyyae8cW/FjRv3uDsvvFqu2cgBSWfsDCyuvBTrb6p0QIBi+0ThNWhGX2viZKf+rE2Zu9J3jV+uCNDunYyIU31M5TXkaXTAHRG+Xeag2AtdgXNihR1i+yBXmWe7IeNrsJhc/bqrc6hf0JJrsfH6VajnUM/96gVkR4OsL3T1ugaD2TnV5tbQrdd+X72+uvvv8ZpeNa4j0i9a5QwFtKY2ju+t2oHUyyJGEyiKOnBZa8zBVTM2ntrro7Mvjy/mEJ1hjJhAILMXA/dvH3MUrS4Y+gmCcDGfm3tzEIpTXDCqtg8B10ZkU4iTFh0yDYEcramIUpjFaMZBTg11ch7XTChhA42DBHHSEDqj3gVxplkVoW33yL2ShsJmO/Dy+SuePHzKXjuhZGU2nfD89JKDm0c0UQhNYlgPeFWC2DqVB8Wp0DQznp6doAGa/esEcTTicCWjYnRALyDiKXhc6zlZ95xdnODJvHfvLYZtTzcM7M8nxohqpjx49ozZ/gGts/pTwgQQNMHi9Izrx3PoNxxOJkRgudjQuIBvWpIY0qglI9njXMuQEiGYSy/FJEI5WQh3UsVFb2Zt6vA4Mo3JWOogeb3ZMgwJJ0KIYUd3d/4KxfcxklJhGMwp0gdPlEgbGoY04LNQXIc0hcKWfrOkbAe2RVl3Kw7me6R+Q7dag145UKraGjA/3AcvPH36lFk7waWCF0dzsAezlm0ecLkQq7a6oAaehNEAT8kpmbwmjAMBIYZAP/RWkwZrWJ1TglNCaBA1NM/7SArK6JY2Ogm3LlRJgeyil5yr+4BAHLV+aqZ8ORRKcmyz7V8umKFe30Q2d44Yvvse2+WKN+7d5fz6IavzU4YQmTjPbB7Z91OKM1ZL39l5p/w3FUJdm6ar/cByIEbNwYjWiPramBmtkeIRMkhAGCoq4HdUD2v4xpwI2+QV0/FInVrsZGdarej9uNCbXky0WuOXsSO3ndSLIn7M6PJARmiAhAvehP0yWCBs1cl5P7GGgfreiq8bo2miXGzsHks9TjOIxzce5xrEJbR4mumEUfxuk+aevku7zUxDrjoqg69L3cHF23k6xrwv6wCcMxTRlWpW4YXivIF56ur1tgmRG7UB6gx1ZNyI6/dowflgdEIxbrPVFwYhI4qTjBdfRbTWgCMeshVJMUZUe0L0xNAwGYTiImebxF6ENY7bh8LFQpnPp/RdRuYNMbKbSntnqJLzDqdm4JFihDJUkDJUy1XsvJxUTZxUlHFEYUOlkIJz2WgFEmvDWhtRdxUT4GTUk4g19EUQcp382nTG9BOFqW8oYsHl3bDBRdOW4Qp9rs2Y2mSmjPqN2rQBO+tpqcX5yG56vTp58ewl/z6t2ZysGc1D6hOG8mUZ80UfDz76Icv1BU8ePaH0kffu32X/1oQPfvxT1ucD337/Gxxen3NxdkG3zWaD3BpyNa453kdUszGj1YLtxZmOK5e00+lakW8625JtSNU4CyS1UOoxQsIYBOrN2Us8RncOHikOJVN0IERbX5oY6zqpfO0rb/LsxYLziwtKHcTk12ygrUFUYrxaJ4NZwVbzo2yRHyKUOqEVGV0jqzC+jkF98AQ8fVenuvVnVWy9atsJIRjd5tGjEzarLXffuMP1w1v0/SXnm46NzlAakNFOf9ciMRpKyGgiQm0Fds2I7Q1FX29nIJF3nYqhNlWzIJWpWKmTO9Op1356bKyu7N51V/hYZuHr51U7Nh1VcqM27erZtXlkbUDtZBhnkKOhyPjQ69hAcQU81VO4apbqtHiMTzE3zKtz/dVzttcz/cW47OgISO6uMvU32jnW71UgQx62nF88I0hgfrRPaA/rPqR1or4DyHZN8nh/2Hsov3JOqlfmKV8eX9yhrq5J2tP6xMsnP+Xli6d4cTaYCcZoOtyH1ieWr17gSk/Jgz3jWdmfzrh+cIwTjzJQdGC9ueBiu8KpEMQR1WhniOmxBOWdN9+gkHj16oRhGGo+bEG9mZdp0SoBmfD48VP2F2c0JTOtxbogTKYRF5R2OiEG8DhS2iJFcOpoYov6wpAwWuNQiO2Mdjpn1kSiKJtuixRDd73agDaLx01apCtstgmvAz5GLs6WnJ5eEH3gaK8lxJZ+s+Fgfx/nsLoieIJ4tn1HyQPqCtN5y958D6dCji17h4f4yQQNDrzRwId1h5fAsB3otxsYtpSc6dYbQ8JSJuVEKy1azHSC4uqQH1QKXZ/YbDqGviM2lt+W0gDFBlt93zGb7iEa6LY9uZRqumZ1eDfY97rscJVphqqBBlponNUz0Udy2hKzsX00GUo16v5DFcPrumO5WBui74RrMUBKnL86YbNcUVIm1WlYjBEfozm+psRmvamB3rbe7+/vM5tOOHn5shq5VAaFmONl4xu82L0RxDGwpeSh3m/CwcEBTTvl/GJVWUyVhVGp4aarNrmMuaXDxHsaH4li+svkChlHbFoODw/JvnCSLnkjz5k8+CXSTJlMZjgn7LWBNjQg1hhu1mtW6wU3bl7/tZ/T31DO2biZ+7qRSi1GqwuOS3W6aN2qjKiNKjsyOq3p0Bj57QF11cJesQatFjxKMnSh7mqjWYUZkTgUj5RcKRdjs+h3dtAiaoLNGmLtPHgXEW9US02g3uysXWxRjdZOSa7iQh19SEYGkVEwnQd6+7cI0XtKzT1wRLxThr7D2p+Mph5NGc1i5htQHR0jRSHnqrFwRsfLvv69r0XeOBEJweyrxVPFdzVAdjBjZ81183OkXE0pKJSRqyt590AGGiQUgjSWPUapltDW/HqJddpg0/FUc+ESSlZDHYsGmiZydHzA8VHhn966biiWt+lbDIGmWtJbztqAe1HQsan0Duda1GW8REJo8LlHB6O6huAJPiKSdsWPiTeFgqU4p6KUvCajhqaWRClCXwpv3L7G3mzCZ4/PeHl6WZtc07bYDZBro9WAVzNIkGRoGMrj5x3//B9+g8nEIPMhKcFFchZ79MfCqhbdY4SBLQcmRS257OzwgzOtWh7LtkphunHzJn/v732NX/z4I/7jk1N7wupN92Vr9sUfw2bJ40fPKSny7v27HN2c8pOPPuT0+ZqvvfM+t+4dcHZ5xnq9IbgJTeNsepd6CtaslGxUklJt0RUz4MiputeNJbAJkFAtNE1T3RHNkMMmgL6iT27XzDs3sNOehWJaAR2zGKHXgSH3+BDBJxqEt+9dZ2/esFwuuX3nqA5mHIKt0bGJO42Z977mL9qk01WxdirGyw/OgeaKPhttsYmRvu9pXd20q6W06YghF630dkPjm2YKIrw6XbNef8r9+1sO9m9yY9+z2rximef0eQbsWrL631cFvmIDEFeRq+Kw4mEE00R2o5Xxh2urYEMwqJ+NNTg7O3qAXZs2Mj3ULJfrA+gYEadSXVdr0cQVYmcIk+11ls02vpfaCekVijq2SrvYgF03ZH/napNnfaSyg+3GuZuOZ1sHoxWVH7VfaG1Y5Uq3KvXvx67MQLQrM5Sy25PZwVvdYsmf/tH/wPLyhPW2hwi/84d/l2986+9AqQ66YHv42GRWtLFIpdFrXW51PAu1rMgvjy/0UD9ArvIDIp5Int4ild5YUM5yBZtGmEZPHDrcMBCK4hFKGrh4+QJRQ/mdL2TtkeiIYYKo0cKcwlASySfI0K+XnL98zpA7ijPLc4eYjoo65AEzmyAz5IR2iakP9JWNMKjipwGaQDObMYlCGdbmXggECeSc8BJoYmAynSDe40ND8A1NG2hF6aOY3IXqV2DLoEle8ATX4BUmcYpjQUrKepM41MCkmRIVpj5YkxurTl+pNd6GmRzSKjR4+kFRDUz3Drh29xZxMiOLoWz9Zst2s0bzwHaz5cXz55S+Y7tcozmR00AeEtN2QnQOkUJOPeT6bFWTE1Gl67rK+goUzWz6JdPpXjW1M91+UTNmykPBxUDrIznZOtgPqRrkRYZB6YfEUFLFxJXU96yXlzSVRaavDcSHkgk+Mqy3xGQrVfJKiZ6960d0mw2pT+ZJ4DDjKC2V3WSoVnZXdGxX16f9/X3m831OXp4RRHDFgAStn7dFJJikRNQhJaLZocnW2Wl7zN7+nJPTJUPf2/Il43DMzFmuiimhFGE6bdiLMHHGaBiGAi5yMvR81PUcHF+jbDPPHzxGw4AUj5dIN3TMDyfmzO5aG8hKQlzh9p1bv/Zz+ptBzqpbClSaRd2aBN2ZOiiRgml6Rlv8Qq4fLsgoDJZRcGgb0bjVKDUjwjlDrFw19sAE2lq5jg5PwVlOdDaXrvHCowEhQVbUK0LEAp3Z6Q+iz3RDIg+GSimCc8XyHapdac61IHHOqCveDEbsCZ0hrafkAan5Nt7rLnncV3MRGTL40RzSxNAU7LyKuSDalLoxo4+iqKZ6OWpWjhck9DgX0dKDFrwawiVutHAdjNKHTS19TVUvpdJuRBjqAybi8FHwLuweGPCE12iq4+TYe9PBqQrqqi+dS8QmolIIPjKf2ee3p0YfLWLOmMG7ep9QtQlmHOMRYmjxPtb33lbE0iYcOZQ68W84OV/z418+ZD43KqviCRFcsKwzg7xbmmihjk1wuMZxcZ7Ij8958/4t/sd/9WP+t//4a9y9cw0fIsEJLoBHLXNNRjTPj0ACQQp//IOnDNkx0YDzCiMH2hcLS6L+INVLZhRzyIi/mdpNqx4tj67a9i04qkYtGTrhvMHwHq1jEI8fc+6+PL6w47MnT4gaeOP+Ha7d2OOjhw949uiSr9x/izffu8HZ5UvOTxdM230m08acDbPbIQ8lZ0phZ7Fc6jNrjl3K6FBRciHlgnc2+CmSzKBHCyJKToJrPKMW1DszEnEu70wyRCFpbYK8t6YuejSPRbFUt9nC8eGUzbKKn6UK3yPE6C3wNPeAt6liCJRiQcSlYFk/XA0dECH4MMIj7P5Zr4Fzdo+XbBTsMWy6lESIRnEPYULwLavVgo8+ecjb9wvHx9fYb6dMdcl627HIU3ptGV0Xx34EdJfFNdraW7CzUCuYus7Y8G7MrxmboFFnVrQ2ja+1Tq+lr1mDNf7G10BsQ60Kr4Vn2DGGmalAqc6QSJ1m664ZG/+8E8iMzeGvvL/XX7meY22wxmGO/Utfa9jGn657W71gv2IW8p/2QXX4+fpf7GI/doCYDff+8k//jJ//9K/N86zLdLnn+eP/Hv9fRb72/u9jb8ztqIrjK7rxHtGr9pqxGaw0zS+PL/bwJfI6dTVG4dr141pD2ddM314qFdcbc8cpvRsYopJIBFHUO5xEvDbWaGEmXeu+o9dMwVPULNS1FGKIRud32JoXPdsh4aMjh6rPrRlfuWp9ik8U11n94BtCjLzz3tvM9o8IqvQXoK5jsVmQY+b87Jxrs3329w6YxMC3v/k1gnNMJq3JVfotxWwC8dSQdXEgDSoTnK5x24HgAy4LR/uRfK3l+GhCG8wpO8UJlyh7sSGop3UNk2bGlJbZOy3Xjua0sTGnSRE2mw2rrqtAvRC8xaXMZhPaCCcnZ7SzQ27eDlycvuDy9BVQY5a0IC0kzdWYyJxySyqoGBOgbDbQJcKepxRPyoFVB+oKB00gSyA7ofeOkmoeW8p06kEbHBnJhbxNZBzdoORaDwagEaOkb3OPl8hEmt0zixYaPNM8JXc9npZcEjEXhtbhGk/ZKDE2dN0YmWXNnXeW3xqiRUytLxa2V4mjCMxnMyatSYmk3kMiBgg0sWHSOo4O55SkdJvM5arKBIIzhtP+lL39OcEB7vXsOcWVQNY6NhepzgwFPwhdSuQIeQDnWnypRZpTutQzP7pBvlwzrJcohRxBgzJox9QFkwL1pstTb/KlX/f4jTRnfcpoTX0WrOouWmlbKFk9miGExGhKAdQgOq32mFdErXEDdU6NjjZujDpuXvU11OhoSR1OBjOwoG7c1eBBtCJEAXM1w1Fcoet6ur7DNQ1p6CnDwJALm35g2Jh+ox+U+UHm/bePq2W0LVqxbXfnaihaRvyIpjmcs7BWtBBiQHPClYG07ShZaGYNTgoBSGWkE2Ji/GoiMJYX3tXN3CvkgCXLZ1QHytYj/UBoI70UtNKaKPbg2QdhfEGT9imBHckGsNd2FgOHc9CEBueo7pbmYDTCyHHkjIq5D+Gx4OkipCCQlegdKQ1cnl/QZ4skyKkw5IE+Q8mWt5ZKIWcl5YGSPZdb5d0712jbGS6YM2OQDKp4F4kuk725pInb8vzVimGA3/22uTnZvWehpnijNHoRcKWilqMJR+DirDN0TgzFm8QG5w1t8OJrAaG7/9v9lyyGwFnRmtWCC6MXNDtciAQRvDd3vVJMI1JJU5VCate81KyVkVKUKqUHcdZo1kn5kBJgyAlkmygWG1qUL6uYL/zwZcIb965zdH3Kw+ePePTZS+7fuM07797hfHHG5VlH2+wx3WuJFTHqLTvEzIiakfY36iIVcEYnFJuKgiHfmszqd9d+Vw2jqwYTVPvinEtFZm3CTS6UZEMfIwJYfqM4Q/4t3qFURIhKT3H4/SlQ6PuOHDPBCyF4VOw8vPeVl1+Rllq3VWknZrhklKJS2Q+ikLJBIVqKiavRWvCbHtZ7b/EB45+Dq3RQwXs4v7zg408fcne94e6tO7TtjIOZMulWrMucizSlMDGtGVZACAolgQRGtMt+o+z2jvwatXBcW3+lgYGKnl09V/Z1YUwhk6sJi9GSsYHVuKOpVF3uSBgfKc3jNaQ2O685IY772O7i1iZ3Z+3MlWlJUctgrG+FUTNmW66McrI6yKxnrFfNj+0rI0p39St372ekdI4GIowGKzZgsoGBkovjk1/8jM16SZdt+FpQmjThh3/xH/nGN34PirFHzK4aG0QU3b135er8x0ZBMfTzy+MLPsYmezSvGaN1Xr/3q5ugylW0T1cSG01stAeX6UqPL47imxpAb3qeViKFjiWd7cGKuc6WUbLhKXkcNGOFcXXMcyQmYcZ2PRA1EGhJ2bNWKDkhpfD5R7/AYo4Ks9gwcw2z6RQf4Hx9wavFK4IU9qaB58/OGFA8pjtqfKCkjum0NSDAOagO3rY6w42j67jBcXH5ivWwIuwJN+5fZyIzxJvmiz4z8y2Co0uF5XpJ6RdmVIbwavkUDbB3/oI379xlfXbOy2cvWf7kp9y4e5tvfue7XDu6Th56QrvH4bXIZrPmYH+G7/dYtJ7szd0bFwka6fuBJkSk7i+itoaKVw7nM6aTlm0a0JyYxEAbIjpkSjcQpi0pJVLfM5RC0zq7D8Q8DShlV/OZmZXQuGi+CGVg2gqTieNwvk/pMqUi9raGOMuFi4n9m3O2Jx1DXy9ocURp2Jvts5he0m3XlvGJ4Hw0w5acGYYt03ZKCY7g7BoH52hwSBK8RttrCkRvdZ0PjuOjA77+ta/iXWR5seWXH33Gy5PnBKeID0Q/QbIQcNUUb+w1ZGeIlce4EF8NrLwHIoutxWP5UHB+oEgme0emsFqd0G03Zm4zQMCTiqPQMBRj/XnpidEiK/b2j37tx/Q305xl0wKNW5hAzYWyKTFuwDJyPDs3D2db6NiYgdEdEEwPNjYHYqc4WuBLUePUDn2lKSZKKbxaDvQpk7KZeXS94j2kBIvVFsUxJKXrB6Zty8n5km3V6FmRHWjbyEE74ca8RRdbnq567oVq7TlOJSk4iQimg0ATjurUgyFTWhRXdXcl5ZoVJJbpkATRDMkK7VLMRr9gExJNdtM6B5vlgu36wnjdxZN12LVWiENTIg+Zfr3m6PacTN5p1LxrTefmQMi4UnV+Yhut0aRsWuu81uZaCCHsdFvB3F2s0cWyOoomFEOyRq2FihHyVD03jg94683Mo0vPxLdmpdook6DMBKI3ukHbGvwexAKegw80QVEp+OJx3hpprVOQkBpgA+qIriWGNaVkgniyGkRujCOz+s6pr3RN+5waH2knE2JwRr90ljknRJbrDZ9//pR+gOnMJoXXDiKvFonT0w2xSbx40bMZhH/6979O9E2dxBfEeZIqoTE0UYurZi3WhJnxiDCi54LRVV210FetWjexgtfZR1tpwTbV894KetCqwxsNHL48vsjj3Xu3mF2b8ezkGZ8/OOH20W2+8rU3OV2ecPJywcHskNl8SmFgs92QiwUxW6TCgKTRCENsAppt6gfUItj0k1opeKpmRpOyvYYFThtlt+/7nfbMitlsmjNxFpvhwIuhXK4WOz4EKyYqvTClgaYJ9T4rdEOmjQ0Uo3nb7y67xsx7gZxrc2are85GIxwbtFIU5/1V4GpFkVJK9hw4yyorVfOraDU+idWWP+OdmTtNJpF52WO1XvPo8TO22y337r2BDy2BwEFcMo0bVp01aSoe1YSWgVx6xE0sS1NH0yaopLwd7Qh059g1HldhyVf29SPybSYXV02ENTI2BBT5VXdHj7Om0VU9r5gluVEZLW5kZ1VSaTkjOlqo4unXftsOFasNG/XP9W3UNeZ1o6IrTNBeuraqOxGZ7n5+13jW73l9jxuvx684J+rImnDkrAybJSUNNKEh9wlyIbGlW55Rig2VZMcrZafBHX/zFX3zigFw1bB9eXyRx1AjMZxzNTqjspZ+pTmrQ5U6YEkCxTu6nBlyIQYzrBhKYpuzRdMgaFYGTcTck1xBERofCFiAfRtb8mDZXSMOa+uGGYcMZCZe2WqPBEeH8PJixWePT0gy1AGsGPVkGOgmE3R+RAh7wIS+3zCUhsWq5+axow0tjXfggqE1JYFzDMkcK8ERKqgwUjGX3TnrzUt8I/Sa2Gx7siqXeYXSE4aBsN+y7FZM45zz0wVpm4wO2G8QFxj6gRKUl682PPzoGSEnDuYznj1/BtHz4S8/5FtfD+zv76MiNLNA0zSEMrBH5uXjSPZAKmi26+rEWRZvDZ8eWWc5F5brNeI9/TCQSs/+0RGTtiH1ZvQWnTfmRlJCsoGSMYNsP9KKBOScGGQgNJGUE8N2DcVR8mD5aNnhJJBrDTKOcTQXXl2c4Jynyx3qhJIhSiRvC4vLBcv12upkL0gdymllVgwl4QvYuM/WzeADbWxxvmESYh0oeJCEusz+fMrv/O7vcP36EX2XuH1DuHbjBh988EOePnuKk4bGt9XLwoaSZrmvtd4y0zgJHpzfDaJ6jBVWxIFTsqZK/Wxtj2Zi1NIKeoQ21l4gEMMe0bcW8+S2SOPwBOYHR7/2c/obac5KtsIADVWePY72bDrjkiOpXQSpVI86REa5QtDGqayrTjB4h7hKgayomUhCcrFNL9lEesiJv/5kwYAiMuVob0LKSsKThx7nJ4ZkOU/KcHbR4QocT1reuXXMtYlHdWDTD5x3G56drBB1HAbFM8MFj3Nhh9Q5V4CIhWULI1lDgoA649MKqFoQde6N4hgw7UHue3KyhtNJQcTbTSKA84iLJvRXQVzCh5FeM0MwIWRGKF1Dajr6zcD5yYq9wynBRULjiT7S9R2iyar9ugjpSEfKueaZ1WYNiM4C8xAs1qxOF8wdUlCniMZK1XS1CHHkJHgSQubW9UNuHe2RqTlkKmTtbYhSbLrrMSqU1vnziBQiYq8fFXNEVLw4oo8MYai5ZCBeCN7uI3VwfrokNkbhOltu+dO/+JzlOjOJ0DSBEAz9eu+tG3zzW++imk0z5wUo/PyzM/7lH32MqmN/6phPhDdutazXCWlnnK07uuXA/TfnvLpYEqOJc50IwSW82DTHC2Rndt15DNKtKBnYR5hLXRiqRsW41SYZBFBvzMiMNe+qmRAcwVcnVGfoYJSroubL44s55tenPD99yeefnvDGtVu8/d4dnpw+4+TJOe1kynQmDMOGopbn1XU9wQWCbwi+Bc22/nnTZmqx6AiRajusHWD3g/NiRZNAEKkUPF8njGZbn4tpGvqux1WHKS2F7BMeX2myNQNGjJbsgpX5sYkV+bD3JiLE4CmvTeZ7AAEAAElEQVSqtD4iYbwnIyWPUSQ2AJI6YRz6wdxnKYZUVxpzybaRUocNWZWcB6JryClXoX+uuhIbduWSEWfrSD8MuJwIIdAER44NXRGev7xg0w2899abaNOSh4YQhf1wSnSR02XHJjWkcoHmKUUzMUxpJnuoi3jZq8iX7qiFY0+WKyJlRNERb9OqSTA9r47W1rqDqoArGwsDo66msSqYYZRAcN4o2RU5yKWQ1YqsXLQSaMB5a5ZTgaJWcKEmWx/1aHYutQxSM00aEc0x3+eq5cLWUwPKdu9pPEZXZbsWV685NtdX32joiTWBUr9UG1YdWC1WTNqGYSj0uUdLJpdIbFpbxLDsTBk1dnXPdyNSNlIoKzqoteP89T3Nvjx+3UO9Gr1ay67u0ioJ2TX24yC6SjuSFChK3BSO+sD+rOVMNqx1IBUxN7pk+5U0LVmTaVJHhNeZE1/xkRA9Q76qK5wLFKf0XSI0HheFvcOWy8sF6yHz0cMzum1XGSTC6P6axbPd9CS/QeOCNjRsNmsKhUXquRh69tuJ1YtO2Aw9y9WKoevphx4VaKPnYDrncG8PJxl0DaUn5S3bNPDZ447tYKYmafQAqEPSy8vCZLLHV975GvN2Tjdk+iKod0QKM9+wOD9j/3CPy9WSNCTOzi/YXq75bP0Jrx4/5Xvf/x5HN64j3nJ+bYk2JpAXTwgTuqFnmzpirF4FxYx+ihZyySgOCR4fI8Epq+2a0AUkeMqQSJpQL5TswRsCpWrgSIxqUUi+MdlKGww0SYVJbEgb+7miwmawQaNgDA2t0hcR0GwW/aWaeYzSpBwcWzLblMh9ppWAFCVpwSKvQJzHS6CNU2bTxKxxbFYLa/BqtpkP4FRJqQMvTPb2uHvvbYhT4t4hzSRx9vwFs1nkd3/3t/nLHziePT/BO5DWQyMwmP61lHHP9ZQSiJOJ+Tz05k1h4eOOSSgcHh+xvFjQ555h6IhaaHxDUkgki3nyLTqAlp49F2l9QxGrTV0ww5HJdP5rP6e/GUMQJ6hYzpXqaHM8mhsrKV05OY7hcaMRiKtojnGVK5JWHZtc3WDkaltAsKwv5525/JAgO+Z7Nh3V7AgeslrYYHaO1WZDHrZsBzPdMJRK2KaexcMXRkOJgflx4XAfJnMPCR6d1KyPPlsH7Cs1KCcUC46l9IYkIaRki4DTvNs4Q3BGTxNrFLQMZEuaJsRIM2Q6DFFCBB8sE01q3kLJEXGeJhjVKIRACLX4QhlyNu5wVmJTKU0YemNUqmizWF9sgupsuuuqFs/Sfyq6UxRxGe8iwV8pB0djFaQWNeLsAXRK8OaIaakaAcmZ4kNt7CKMM6ksmKtTMSjdFcqukJTaoNXJckW2vBjS6qPHDaP7lxBroHRRiC4QozeNoToePrtksRGaVphPIrduRB4/79h0wtlFoY2hogrWeGYdLN+s5qUt+4H33rzNb333Tc4vVnz9q/d58vKCp0/P+cXDF6RBiPumnXEeAi05C5MwwYj5iVH2MaJn431u03Sj647gOpX6ZFNsIWkNAAWLdRCD2o19Ua3SpRDil83ZF308fXnCi2cX3Ll2iztvHfHg8085eb7i6OCQw2t7KJ4hbVlv1uQEs8kMH4z6G0MgZa0UviutGBV9GTWerk7yQgyV+lMYSt659jk/co8qNa5ko5GoFc+5rjkjhU1L5c1HM/YYnVpzUryEes9bFMPo0poouILZ/YvgG49FOZibGjkh4mnbtoqq1SyNk6vP+Yj0SB1gWTOpJRPDpCJs1kiGGHeDjZxsDJHVKM4lmWB8OmlpmoishIvzFT/d/pL7b77J3mzGTOZcv/4mp+fPuD1PXKwGPnryiIvNJdN2xmxvn8Uq0rbH7O+/R3H1OlRKX9arNmtH+9tpbcZGIu2auFpX2k/UaatR90d9l/2Vc1L5q9X0ozIiRpZeea1D8u61MtjbYM+nzFBp8aV24pbRVJum17RqIwj1usnIrq2qzaSBZLJDysa/z1ydR35tamSmSqZlrPSK3feVeo207mniHb/927/PX/zwf0LTgMuK+MikafjWd79HLuCoTpH12o3noOhrVMna6EodRF0J7b48vsBD1FPyCFK6nW4ya0X1qzZHRcwVQEFKJpC4e21OKgXvYblc0DgbSHR9b/dGgWGzJTiBEFHnyJrss9bCtoNpOyW0kSEPlGpw4b1ASkwmU9I2seq29KU2K0lpXCQN2TSwqZBRihk1s1yvWK+W3L5x09xngb7rOD87Y3bzFpJNInC+WHK+uGSdB9QZM8XlTDfLiARmezMm0pJ0xabPbPqE9pkBMdOuNKDBdLmSC5NBOQDeObrB/s3r9E7Z5sRkNmMvNBwMcPnwKZ8/eUizP2HVCG+8cZu+ZJbdhiyJn//sx9y4cZt33nvfZDhO6EbDC29yHJVKoU69yS401OdISMWaIPHeDFScIwObfstBu08JBnwMKgwiJDGjupEphTcN7xiQ7ZwguRq1YUwqvFC3MbqUcAJt43eGZoZE2f5CKuAcqdhKI403KqCWHXXSq2nNiipxMqGdTcE5mtmMTb/BR0da2943qKd1o/kdhBjxjefWnVvcffseYTah08LedILGwMunDzk8POJv/dY3mD94TNNMyLkQJEKNzxLqYJ3AdDJlfuMGfrJH31s2XnS2F7eTCW/dv89isaBLG05ePmNxeWF2/xIQ8Rxe3+f997/F6nzBT3/01/gQaNrGFjsf0BAIkxnezX7t5/Q36NZoNC8w9xvTaNvkz0jphSDBFmIZEPF2A8hYyI6uWK46XtXNfpwCF7WmTXINrvP4YJPYLDCkzHbwZAr7ohzMGrwI674QXMvJxch/VixAGAb1pGQ5F9evZ27fnNCGQCkD603m4MjTtgnnTCtXkrOmImeEAMHXoqM3ipwKJSVC0GpoMlByxIuQqi1qGYa6UVuTFIKpwKZtNA2Js9yiEBrLTJNqciGRECwAum0iSqGknu1gAX1u6MnVmMKNxioh1F1Z6lT9tfmvjuWJzSudCs7bQ+Mqt05GRFDGCZvbTUKdE/u4cp0Oe2+ZXjsDDDG7Vy24Ytk76h1k07H5MNq91OJTRmt8E5K7cUKD4MXThIgPlp2GL7gg1Yoegp+ieWDIytl5x7R1HMw9wU04uUx0A9w4jLx5e48YAqoQwmDC4wzNJACmCQo+8M6bh7x17xpv3z+m74U8JGYHDe+/fR3vHW2QSkHzxLpAuWDIGVDD1ccmy2heebTSl1ovq6FrIw3VYU5lUp8m04CY3brz9iqjU5vxHl+bcn95fCHH6ctLbh0fcHhrnw8/+YjtReb+nRvMDvfoy5rFYsn5+YbZdI+D+ZQQbag0pGR5NZgVvWA29DkbHSXnhK/ISk6Doek6UgVhfF6l6tRUwTtPP3QmUncmvHfRmATW/NTIEGrRXa3rESu0vLNifhg6XM0bQ4ShKDkNNNGbiLnBDH5yzZHUioZl061ZDpudaAjeDELGWr4+96WGunbbLTnWhkyzTZ69uWr1vW3yY/NZciYXrXSrQBMCB/t7BB9Zb1c8+Owhd2/fQo+h5IfceOOrnL96xsHkjN9++z4vLhb88tFzUuoJk8hs2tIPK0JTJ5alImi1opCxcZGKWmuVwMioFxv3oLERGql+Ulu4kbJXdVoVBbB9ShnDsXNFtKwZl12+ne5Qu7pWNB432OdeqrR3yIYs2m+zBuaqaazNov2Jsf0azT/ySFHEmsuRNk1F6q/Ij7ZZ64jEV7ffcR5nzRPVAl9IYvlMwWdKNtRMXEFcYDJvuXv/PaPvuqppQV47R66asXpiWiV0rkYAyE6I9OXxRR2jtkjGXBesCNsNWIpWNo2xPqrqHBGl79dsVpfszw8gePqcUOcBc4x2SEXaC31WmvoaxZvB2bZPbIclzXQCQci6xbnEzRu3GbrMZkis1hvTTjkzaUgpkYsNkrMOu2cCtQK/SzagXqy3JB2HX45+OwAOH4x9c+gOODjYr2yrzOX5BdvNGi+OzXqDSCBGZdvDoI4h2zrhfCAPCVFX3Q4ta9cXaENgcXnBQnvi/ozQNlyen3K67Lg2OPzFmsvnp9w6fpevffM7fPrkER/8+Me4opRh4OTVCU+fv2C6f8DR0TGDQJ97UikE50maKd6GSicn50h1Qt3fnzFpLPqplMymH+hysvxcHP220OxPcD6RACk9JSmaM6k2teIt4BpRpOaLGdHK0emWFEHbsIs7IBcjdNchfy6JYUg7tnIpW0KIeDxZEwAuGWss54w6TzH9E0WETOZg/4C9w33LF1Ol8Q5JhalryMWb+2YaUMzV0Tnl5o3rROc4nh/QxoaQM9vlgsP9PdaXcx48eMDdu2/w7W+9T9sc8Pjxcz4t5rjtfF29nRmOHFzb49bd6xBa3nvvfWbTGbGCCs45jm9cY9N1XFycs1ltWF5e8Itf/DXnZ+fETcuwXPGTH/6AEFo0BGbXrmNxumoa8BiJzYwYml/7Of2NNGfR26ZgaIxSapivVrpakECSbDo0Hd0ZxybBWSEQKn1CDB3YJYA721RsuFm7fczu1EKUFVcS27XQFRjKlrvXjxCFF+cXLFZbcunZA5pYyGq6pEWGUvVO3sOq85xdCJMmcW0vc75MpOzQ6HEh1o07E73Z6udcjJfq1SYZmpFijaSvvFoTVpvFdWgwSNhZvsSQDEKlFWIySo9B+i2haSqCaJMUq9R60Ih4Tyo2LU+V058VJAqumOuOw5qbNFRerxrdwMr7qiUhV0h8POrkxHt8hap3Y0yRSr+rXl1XIxP7uvM4heBtcEIxtE1qLo56sQkv1iy6MWi6ImW2+48bgDXnMjZrCjE4kJZ1n2mA4GPluNcQXLttcFrY359wNG1596u3+fSz55wvhGsHwrUDs4qNISMFGt8SozeDltb0L4LyO9+8ydfef4PVujCfN6h23L4x57YPMCRKSqTY2Lk7qVe0VFR13NTsfvVVu6ewy6YTMI2hKsH2Qevm1NC1UaOSFVsQleqc6aEGiFsu25fN2Rd93Llxg3bP8bNffETMgXfevcfF6pJPf35Cl5TWK/ffvEvbmvvZkNLOmVHqWpeHDK7qVmW8D+q9UnVHUu+hkq8KJvt4rVAeh1ehFvZFoQw9TYymuWRsatwOtbVAd7MYzphJjWajEKfcUxQePHzFq/MVr16esV2ueP/dO/zu97/OMECQjBbZoXlghhBOjHIz5MFomrGhpDoUclY0bbYbfv7zz/j006ds1h03b+zzj/7+7zGfz2wtolhDJsqwHaozqxmLpJQNiXPmNjnfa4mN43Kx5vGTFwxDx83rNyhPPuTW3XdJw5xutSK2kRuHx3x28pJPnj1m6Bbce/P7Y7c7lp0VqbbixMEOYbL/zhVFkJpHqPV/UgdI9bVGsWjVHFQmo12bHcKmv7KG7lwiBcbAcfQKDXMCTTQDF9ViVOmKvKWiDFqNR4oVMeJGkyyu7qexAatjNXXWtI97ptXgSnCFVyfPubw4Y29/xvH1e1j+QL1HR0SR2vLVJbpXz2azIWxWPPjkJ2y6LSUXs7h2ia9+53scHd3dDQicG7Pp9Gqlr9Op3ZooRtssrqKX+iWx8Ys/yk5/ObpgA6BGWZaaG4oqfowNUtv/E1U/2Q94han3DLkYhdHZhMPWgUDeDTVsDRpyT1Lbw4ZOaaJJRXLqOTrYYzad8+GnjyhpQJJp20WrqYWJ581MLFu+qFFp6gACQ+JHuYB3gZwL265nPt/DhcA0+rp+wXa7RVFCbAypkcKghW2fmc72uXev4dHjz9luu1qH1EY2QXaWE7al8LIMlNMXDGdwuH/AJEwI4rlcX/ACx15seTkRmpL527fvMiD8+Mc/tQzI7cB6s+FyteT5y+e4GJl4IXVb+j4xqOfFqwuGooRmyuVazdZCE+10D++K2e1TQAKh0tSDE/quY7lZsjefWsB0o0ifCU4YxD55GwBX5lQdAkq2EAzBdMt9l8g2jQOMDeC9MCRrfHF+N1BxmsErWTPFmfvwpl/z8uyEIQ0MVSc3cbHqmJXgo/kfBMFl6yFa59kMS9p2Qgyxrpk2sTq+fsybb72JijKbtkwmZui3XC7ou54bt26TCzx+9JA7d5Ub1z3vvPMG68tv8PEvfmYygDqUS9Gxlszlds3v/f5vc/PWXV6dnvHi9IyziwuW6xXf//73efDpA/qcSEkoXUf2ylvvvsUsXOfxo4/YbNZkzbz7zg1iGzl5+Yo+9cwPZ0zbQPEF9X9DIdR9eV3EXFE0NRpdkYoq5Drmc1J/7SimrhsizVXj5vyuUK8kRIq8ngpUKHnA4hYcPgiroTAUIESWy0tW24GuS3jNXGuFnIS+CBlzLGxjHRK6isgNymK9ZbkRXp0p82nkYFKI0cSBPtjE1zlXR6wJ5zIBQ7G0KBJ1Z9Qg44aoA8F7zhY9m01XQ4kzaSiEJljDWmC+H2icp2lqOKCaU6O4jHMeVW+hypj+zVBvRyLhUIqGiprV4GWs6bRcLJtUSA3rEzEky+ReZZf95sVZ1++oEE+l5YyTYVcbKATvDFZntKcWE4A7reJ7PGOe3Y6+mI1m6cRV7UreaTxs59YdXXMMDNdqOEDKBImIZKIP+GDT/1D1im20WIRp2/LmvT3ef/M6924c4qPw8188I4TC0fzQaBFUZ54ASQfaMLVrh2M+mVtmSJ84u+h5crLkzZsT1quBP//gM377/bc4usPOVKA4WxB9DDhXp8MCPikUR/ZWx3nseuVyNcEeYbRxUME4OZY6oa/NtzhfmzYYS3n/pSHIF37kJvHLD59x6/gWN24d8R9/+Ff84C8fMpsd0utA6TvyRvn2b79NPxhdIkgwUxtnmSkhOEOLxJFrkPO4knlxpGyawq5XQqiDp2olDcKowtEaHKqVBlzKAEWZNC1DKYiDnJPdHSNVuCJuSEUyMCRt0J6f/ewJnzx4wXK55vTVKUM/8OlnT7h544i792+SxuGDi5TS7xA8LZU6Wex3DMNgtCcRVB0vzs75o3/zl7x8dcl200POPHz0itPTFf/Nf/1fQlFySeSUd3mFOWdCY8idEk2bkgv90NE0hoK1zYTLy0uev7ig6xN3biSGoePOvbfBZSazA2Zz4WB/zju3bvHk9AxxaedAuAtkrrb7r7mG75Aw+3szpvK7Xkx2GWGvF7QiVT+HmTk552uDMTolag0Wl/rEXj2vuZh+Z0TxbBBdTX5cReWDIw+6cxPzNcpEGRuo8T1UL8napNmyfmXEsdqcMGkP8NIYjVYzf/LH/2/2J56TRy/56198wHe//7f5w3/0X+JlhhRPKWuKCEGmIKYVRJUffSp89rMTvnH4U16ePiOlQtGEi573vvFd/u4//t9Y4yq1mJdsDsJyRbu0vL/Kkqm6GXt5xeUO1y++mIf5y+Pq0DogLLXGqvCwuKpJlStHT9M+OUgWxfHOW2+xkIZhueD+/Bi/17DKW9b9tg6DbLiaSiaPQ0dqk1a3+ZSzuXdLoFsr3gmnJwtO5RzKwN6spdCQS6YoTGJrNGFcrRXqMxlMBiN1wNnEjKhnoJg5mmRW/YqWiQ1iU2bbmQwl5cxkZlSznHuLAPKOPic2Q7IQY+cZ7XJ1fJ6xdTClhKZMWq1YfP6IIRe8eGTQajufKG0gC2hKbEvh91YLctmSc+Lk5BV9lfvEGOj7ntVqiZ9O6LuOvmQ2qyVD7tlW/ZcE00NFEbJLDJoA81IQFcqQSTnv0O7VektoWlxsiWFK8EM1eLHa0onlvzrAazC6K4IUIWhjMgoNlQWiOPFWd5FJaahrd22yguVYitqQUsSETVkck8mEfrWxzM+cyEF2eZCjMVRoItvlltIPuNjQOG/sEq3SHYRbd27y3lfeJkRhMol2v4ryp3/2Zzx+9IxcEt/+zru8ee8e37r2t3h1csqL06fcvJH57u98gyY6fvbTXxCc4+BgSjjcJ8xm/L2//w+Y7x9z8uqcxcqud5cyb77xFtFFFq8ume5NmUnDVgvdNtPcmnN0eIdBhPOzU05ePuHsbEFOXfUiELbLJZOmITSOkpRf9/iNNGejXYW5Uo1FhW0yBYM0rRwxypptjlqRMb+zOzYRPHWhMJevkSKHpBoq6nZB1KaviuYwkxNJg2U6ZIVeuTHN7AkMA5wVGAoU8ajLzA6mXAuWu3C+2pAy7LUDq7Wjz55uW4itML/taEKwya5q3UQnOJdAIo6erN5CjDGHSM2GyDUhgEayZNQFXGsN3qQx8eeQerrLC1wbiJLxYg5nvomIirmwkerU3ahB5oCWqxbPHhSVQik27XLVYUaz0f5SNstRJzU9SxyiJjYVKWaF7wK+Zmk5HyyzrU5aYVQP6u7TNiOTSCoDmm2qjxgSYCiifa+rhYaUiiCN2T/ojmtj02apKNT499WGWYuxYp3lvTm3MOtYKcRgUz7LoIOiA6/O1tw9bnnr7jWatiVXA4b94wllGDjcF3wwIbIlw1suVVsNVFQTQ7exAG/xzFr46UcdH/zoMx6/7Pn+t25y7+4RyYMM9r69c1gavK8as9cE71JqvILU9zM6YNqhu2dAqgFALX7VFq+UrVC0oEmD9B2FGGxo8OXxxR4XLy756lfeZdMv+KuffsAf/asPWCx61v2npCwE53n5+BUH+zOOb80MFZZAyXlHrbEBtKFPfZeI0Rv//rWhhFKp0s5X/aQHnDmOYkVUbFpzW/QBnOCiTRJDHE2YwCWjFKWUzG5YqEJqmz76aM9n2gonL9c8e/qSk9MLo5wH2ww//eQZ73zlHmkUZwl4ribOOZuQW8RCqouaQD3ljATl3/7bv+bzz1+aW1kupGwN0s8//JyPHzzmq++9aXRIf2X33jijiAsOshA8DL1tyEOltDRN4NatY6aLCSevXrHpNty7c5v2ZMLhtZtcnL2g7we8a9mbz/jO9WNOThacDYVN2QcahFSHIK42EaW2vtUZVm1IhVoOpFSqn8qVZhqMumiW+RVFcLb+oOAJFdHS6vBlutGiBec9UmpeZJ3IeAeL8xN++pMPuLw45c237/PNb/4u3k8sx65yLu0+kjrQGpu6isrXkyuMiLqrRaQ5GXfDhkkTcTrw5NNHfPjDv+R7v/ctYAup8PTjB3xw+Kd8//f+CTknLlcvmO8dgmtQYCoDX33njL048H/59Do/f34TFZMNUGDv8B7f+Sf/Dd41FIFQXTp99mQTN9r51WbS1QJbMR2KpBXt8Ar6V/Td5gt9pr88IJdU93/7s1YdTimF4sQGuYjZg6cMvrBNHf2259n5GTE4XPEcHl3j5v27XHRLnrx8BsUGnIbGGX2WOtw1HVs2Da5IjQWx53CVCpuUEclM9hrmTYRgg/PFdsVs2pieEwscFrX7p/E1LkdNw2/yD0PshiGRtOCDsE7n9MtLBJOXDNnuxUzC5cKkbYnR4chQVgTM2XoeHW6w4cswVO2nqhm75YIQSDUmaNBCnzsCzqiVJZGSsbMigfVizR//63/NyelzTl6c0MYpUqAbOg4P9mhV0e2GgcJ6sSalgeVmwabrKMVRhp6oiZS3NtTIAXGNafxSR190F8/Tp44QwKvQLTritCHvNxDN8bCtEUUlJ0bPFooxoMbcR3GO6AI5RIbcMWhmyJC2agwfsZik0YioaDCKJKDJ6v2CIE3LtJ1wnmsMh2ZScUgQsneUJoI4WhfxQWkIXF4uwQWyZuI0su4XHF7f5w/+8Pd5+/49HnzyMfODPTabNavFhvv332JImYvTC9Im8/LJC27fucN0Eul7q0H91PPW+++y3Cb2j4/46ne+RnNwRDudcTCZ4fEc7x8S2pZBhdJlomtI3Ya/+73v42OLiCeVnovLR9x/8w63b93k8Pacm8d/wHa94fTlK05fnvDi2RM+/fhnLFenHE5mhMkMl/tf+zn9jTRnwfmaFeDrplCpN2o0jVwsFyGoVJ2ZWYQDUIL9WQXF101TQW1y4WrrZ2YK9nVU0WL6M9NcOFL2dEk5X/Xs+8A37raEQThbDixVGRxodSwTaTme7/O1ezc4mE3NRWfZ8eDFGZvyimt7A6uNY+giQ6q0Eyf4YBbTIQYoLSall12jY8LmgovOxI/OIe11pntzDm8JOY2iW5ujrjZrHvziUy7PXtG2Ew4OJrgQTVNWsNyhorvv3/aZz56+MqeYlOh6ZdObgcBuQlwnqzgzTHn4eMW335oxnwA0BO9tslKskHAu7wBNQ/sy0FRKouw2fycjzUVAzEjj1ek5ZOXa9UOcRGuufaXl5foZi9REeLOYHs1eBFeRuKvmxby8QDEDgnEx9EHAJUpxqEs472l9gxaDu1+eLXn2/IRnz1cczCPv3LtO9JnBOdrWcTiZ8PRiybMk3H0L1FnIofdWkMUmkqum8cNH57zx0TOObh7y+PkFry7PePx8zVffPuCrb13DSaZpZzb5J1qzj0H4IQgpmcOo3aOj8Y09D+LMaWosUqS85rFWqJubTcLFrO2qMyYgo5DeoVwFHX95fHHH/KDlk08+sWd9cFxcrlitBrqU6DpzIO36nh/98GP+i3/+fbqhZ+j7+vyb46Fx3NUmjMBqtaadNKa1QumHAUlAgawFYWDY9kaNrpiq975GbjiKZltvqq5DrSOg5FIHMOys8IMPNe7BdB9i8Arrbstnn3zE+atLcp8MdS6G0JwvNvbAWzgbiBJjQCs9TpyFvJdiRk/eWTZj07ZcrrekJDbocEqfexOy50LG8csPH/K1r7xttD1vyFvORvm03m8cuAR8bOj7juDsd/ZdT04D00nLm/fusFysefL0OWRFvGN//xbL8+eU1HH+/BI3adibz7nWtqxT4vFZYpMDrmahab12FbBHZae4YbTNUHXjzlPZDKX+vZhxS7/i4ac/Rgfl6OZNbt25vxto7RomUXJF4syARdGRDi3w+YMH/Hf/t/+W87Nzghd8aPnqtz7gv/qv/08UdfQpV6Tt6n6A+q+RemhzLlt3ndG7RwuOoUucXTzm9s13GNIlP/v5X1Hykj//k7/i1dkrAF4+S7QPfsb3fu8fsV6f0PUbDue3cGTmbc/v/zYcH615+95L/vjPP+EHzwvN/hv4fotPhTY4/u2/+zPe/Ge/xe0bN1h2E1uvuDrd8URFLX5Bc0/IF/h8RukXOBLLyy2Lzeo3/BR/efynR6isk18dojq2vdAVZVDwTthrojklU8xBuvSQlCIRne0hs0P89Jhrx7dZ5Ck6KE7dTlcJFdmtg6iSTYckAn3uyKWwvnwFJFLO7M1nHN+4gY/mHVCAPp1yON8D7a0mEg9FjAIenEX/QK05C67YsNY3Vo+kPDJTCqqFEBtcUUQCUpraoFjOlxNzgfYZWhXmd67tKOpkB2qDf6lDqpwMqdoMPS9OT+j7gfl0hneOdRnoS2+1b69sNysePPyU+dHEhsHOMd9r2G6VeYiE7ZbNes2iH8hDZqLCvm9oGvCuIYTAdG+PnMzpehIaPNQGNBDK6AhbaEJLygOuZHRIZD+gmomzqSHrNeO3pIwXEFdrDleMpZWzGcA4R+saiDO22dGlLXkYDPUyN7waxWC6ZfFWs8XQUFKi5ExThM35pVEWxRg/PgbiJFIceC1Izgx9h/PCrVs3ePjgU1SV+XzO/uGMu3euc3x0xFe/8g7BO955+12WywvysEUbB/M5b997g4NvfJO+W3H66oQHDz7hzhu3OTjeo5kF1v05SOHr79/n048f8qf/8x+xDoV/8A//Pj/++FOefvwZpMyN27f5rX/wh8z2j+l9xAWHOzQ0VYrQRiXSsXjxOW9cm3Hrzg2GtKA5EO5fu82N+0d8b/47/PSDt/gf/5//PaerLc012Lhf38DtN9KcpZxIag2W301NbLMvxT54p2IbvmQKo4g8VNpHqZB1QjWAQva2eKRKgdAyCosjyGANndQ8LKfEYOLrvu+YNjOm8xnPLoTF3oQBZc+ZFep22bHXRO7dvMHxbI9pC8TA0TTy1rU5zy9u8KNPn9KGBTEWQgh2Q0nC+wbEHg5IKI7SzCAlC1fWbDlAkkCh5Mx05mmiR7Kn096uTSmIOqJzXHvjGofHnpwGYhtxoUHUHg7N9uAJDZvtlg8+fMa1W3e5exCJwQqcbZ/p0oB3MIneisFSOdol8/L0AaU4vIQabnylfzHRdgF8/V9tBGWMNbiycN5xEmoekiMwn+8bMuSD2T3Xj/h1fdVYUDhXM5vqV1xtxERGIb4hpyb1iCBav0dNq1ciwtYQRJyZwVh3xi8/veD83IrKi+VAOwk4AuIheKGd7fPs4jlvzDcECRTM3TH6SMmDuS/VMuz0YuDf/eAhvhHu3Zjz1bdvcfIikbqBzx6/4PbNQybeU7w5s0kVrgQnODw+JHI20auIcftdDWC1Blp39tqD2TDV929hwVmrhhDLxQKtNJGRElfNCvLrVc+XxxdxrC8z9269SZaOH/70KavNli4VypBxmFlDdMLZ5Yph24NXfPAWKl3XPieW8K6aEC9oCa8FDIN3rdkP0+F8qBqHgI+BMQjWO1/d3JVBLbNwSKbV6rue0EZKKtbsV3e/AvQ64P14LxlMo5p5+eqckxcnbNYbW3mlZTrdY7Pd8tc/+QX/9J98Hx8dQQSchUbvGguskXHi7LXFUYqDknCiXJ6/InWd2W57D1oYRGmC0G8TqJByIUS30zKoCFF8tVhW8lBoghkbDf1AiJkYIwjmIKkD8/2WI/Z4eXLBavsRX/lq4vj6XS7PnxODIyn0yyX9eoNrPO/dvslmUC47z+Uqs1ovWGxOmU7mBNfQdSuGkphPD4jN3NafK94jptMxenYGVmdP+Zf/j/8rT548YhgsUuAb3/02//if/x+JzYyrsZOteFnFDE8wXWr11+Czjz7k5rXrdVqemU9b/sOf/Ae+94d/l/tvfI0hVzfGAqIDUrXBOtK5dIzINuMGm+BYo5lLTylrXp78DAkrHDNOn3+K9oXF5pzlagVSEIl8rQ1st6d8/vl/pNlv2Qz7HM9afvc7lzx5+Ef80b/6EWmz4RtHhfvfzeh3G37xyzv86c/vc1k8/6s3/5r+7M84uPMeTfxDzldfw9yh7AKaZmnA5w2xXBDKAs1rQEklsep6Vtstn37y/P9PT/d/vsfrekcUsmYy8Pz8DN8esR3A+QEXwDSqCUcmaOJwEiF1xD0hxCXLy8e8efwu63lks1zSb7d4F6js/Oo4ahTpLLmuiUaxTip4MlJ6PIXD6ZxprIPg4hE84ubMmKFuajmPpVJ/PeCNrZOyNfweZ+whJ0b900JTdR0jFdn0aA4p5oaacr7Ko3Uev9PcmzlaiN6yRV3EV6OI8RqKE7q0ZZM6ZssDcsqGjA+ZoyGRdLChSac0RNqJZzoNHDaj9lbw7tBoo2pOgW0wW3ykZT7f29FMAUJwaKqZwWIVaCoFV2qmoCvVZ86RkqJlMAVeu4drPFvJpKI19LlHSsEFs3sJ3pBEEcFFSN3AZKo0LjNPkZQ8XevodGMMssouyMka3ZxBipnA2VwvUnyg9ZGZiwyhwc0U7wM+OJpZIIiQLi9w0wk5N3hVgofbd2+yv3/A9HCfg4MDvvX1rzGZTJlOWrQM7O/PaVvH3p7n9NUpnQ40wbG317JebbhcDOwfHXN63pPPLogT4fj4iKPpPkwd3/7ed9i/9gaXXaGdTXmjvc69r/8OoS+sL085f3XGYrlhSMpf/+zHdHnFt7/5W0YtJXNxccbezPPw8wekh4/Z29sD5/nzv/wrPv7kE37/977Pb337u3zlva9wcbk0IOn/h2n6b8hKf6QupOo+51B1KANZi2l8faGIR0azEB3Z8eZ86ARzg3E1Ob7YRDal8WENFOkQLBvMHhhBiDiBd+9HzlYDry6FTdPStRPiXJgOjtgnuk1HysbdDT6yP3F4yWj2ZslfCqU4jieO73/1Nj/5NHCyXjAJepX5Ja5mtWVCDAxpwFFIxVzYVJUhqVHt6obpvAXcOa2ZIVnqlMKcy4JTfNuSJJstvYx6K2tobBIO4q1hun404eaBfb0UEN1UcwpHU+3vc6XeiHi8E1Qz+IjgK+0lV7qB0QPsd1kByY7acxV3YPurIZo7Aw/gYL5nWRtpsKZJ8pWGoC786FDXl0obqj+vjl0A+ZjNZCHX9vuNp26/yVwqE02IJK2UqpEGpZDxbLaOvUlCcKTBqENU2tGtQ+G9N++wPH9hjj/icB7aJpCLp402SRcdKCo8vxAOZp6jr0wpw5bf+a27PPp8wWQyo0uZwxhIOoA4XiOVITLsGlzT2VWeuuoumqBUm+tcL6PbFS9GAwAzBxioWWdqLpCKhTqKKOoTeazuvzy+sMO1W15dblHN/PjHD2lCw9Bv6fuuWhsrW9QyX7xQ8kBomp0WKcbqSuqgls74qTMUKCecDzRxxmq7ZtYEcoH9vSk5q9ndj1Nb+/QrTdKT0mD5WFI1niVXRNzurTG/zztvTZmr4eXOkVPm1s1rXL9xm/7ZCWBifles+XjrjbeJrSHnuaRd8LVz3jIdvRUGJRVSNQrx3pGHwnwyYX8WubgQ0tATnNC2LXvtlG23NvzfFchG+dOUKVLwwZP6TKi7UUrJQrErxWoYMnSJpm0oWWknNtTr+g3XDvfY5swvfv5L3n03c3x0h4uzJ6SUrVhQCMmxOXsOAgex5dqNfT5/csKnjz/k4aNnJBVePntBOw0c37jOH/zBP2E+u0Yh26emhpwVjGpdFP7dv/6fePDJJyzXW7QGb//Fn/57bt1+g9/9g39qDbgTRnmpSgb1tvZr2Tn7fvDDv+Tzh58w9D24hsxA4yI/+eADrh29ScoDTdwzHSJSXTn9SGi34VVRC3atrJVcACmcLx5wevkhj578iE3/CN3u8/Szn3O8f4wuEjE4QmzRDDm94MOH/4KTVw+YLt9i0/X8vX92n+X5n/C//M9/RCoF1UyYTmkmLa70fOdbnzOZFrZMuf/GQ0Iu/PInL9H4C+b3/s+I3EA04UvHHlucLClljarRqfqsLJdLlouOl6dnLBdrfvjBz/9mHvb/jI5nr54j2FA9+mCOqP2Gzx4+YrNRfJyQSTyceWZ7cRcg3w8Dz86fMplN7H7bXhCGyPCyZ9tvuVhfUHLBJ4GSaLzb7dOaBBcE3EAJCdEG7wNH1+HyojCbBeaHiejPzGVWzS3PhwHnewrehpIYgiUIzie8N518UqMAqxiaFKQl+AbU6Hc4q7tM7ulwYlIJmz8JkGxd865m8AFFkAHoFecGkO5K9y2mI7YpS+B4emQIlGaMYJyqHqvSjBWUwejjQ7XBz8YW8GL0Y6t/lJQSBQM37B3b0GXTD4TiKECnieKEwYFIR1MKoTg0FdQLgys1SsUxDRN0EIslUBi6HlJvA+NhgDClbxszdksZZSBGR8qJ1hekBKIGZuJRaa0uz2Y2VLLl1FEcor7a32fba1A7b7bE/UhTB5Gju3BXlLUWyqZDtwXvlPfuv8033vomkh2Ls0uG5YrzF894+513IPf0/ZYhDSxXG5YXHWdnA9ttYTqb8+LFMyaTfbq+4/3bt+lyz4uXPXSeZ88uKQcwn+6x3J5grsKBVfJoEHQivNic8fz8CUf5GofumB/96Mc8ffKYrl8ynx7w3nvv48VchWPc53D/DVbLDZtFx7MXT3nx9BHzvcCrkyc8e3pMl1a0E4f2PatXl7/2c/obQs6qE5VWqkoVRI9c1tGdyQIzqzGFmIW0aKrURXvgxsDPscQ3RofUKYDg1IE2IMkK3TyQS6YbhG2y4j4P0BYL3JOkdBTEC12CZZcZgkNSRlOq4aqdOZjlaHomhW/dP+Kjl4GMo/FtdTCq7oel1KIi2MQiRsRHRDOl9HinBOdp4x4xOLxXwBNy3l0jAO/NjjplC5eNodlR+ZBQLfF9te63xUAcfPrZCY+enbDqBpbbjq4rlqlUlDRAl02I/c//0TesOasTIVc84gfLHysV7K+ZJ5Z1pjsdQ+XV2afmjEFcytgQjPQa3VGlGD9zqc0nvv50neqoXtEbGZu03WDV3l+B0dWsfpNNdZzRtLROs2JwO82Vhb46nOsNYXDC8xcLDg/2+fzpM64fTChF8LLmxvV5veYZUUdoqqZi2uCDp2Szky050aXCZ88W3L09p51akbtYbViuO27UaaDJ5sz4QZxp41LVGzkx98rxkilqaBpU7Qg7tJDarFkTK+ycKxVEBe+ivb5XgjgmUQm7sf6Xxxd1/Id//wsmkynNtOHzz54waaZcnK/IpdCXgTZENl1H9IXF6tLQ/743a/xULA8lGKl/uVrTbbb0yQpzbxa3BA5ZJGV1+hHXDq4x3Z8wnc4I3iaagiM2wdjGziiOw2CDARFn+o9+IJeRlKfEYG6oWcxwJ8aIDwmnpU5aMymv6dMWV2z4lHUghsDvfucdtv0a5zw5ZfJmAIR20iAYamh6YU9K9lx7L/W5Dly/cZsnzy7MCKXmdflWmLo9hn6g71aozLl95ysUgaef/ZztZokEwUtBcWy7gZevOo7mc3wM5D5RilFIfXAMvRCbFgnCwECIEOM+Tx4/InjPtZtf4/TsOcN2wWax4SKvmc732J/PaWLLkBLv3XuDr771LviGZyfnnJ+/4ujoiJ9/+Dn/8l/8d/yt3/oe77z9dSbtYUWoCtS1bX15yc9/8mMulyv6ftgNtfrU8MEPfsDv/J1/TKEGWas1v56aHVUnMqMp0HKxYrvpKDlRyOy/+T439+Z89vEDvvL1z1mtLrh7+x2atkUcxHaCJJu6b7YXXC5ecuv6m6xXS5arFUkGrh3c4uzVSy42D/jFg39F1ld89Mkjrh1OuPbGnPWzBZqsUOz7xKQJXF484+PPTvn2G/+QDx98xnffv8XFZ/8D68Up/WJDcWZN42NEgqcbFOda3n/rISIWByN+guTE4skDbtz4iDZ2tLLB+UIpiWHosT0n8vjxM16cnLBcLllvOpbrFdHPWG62f5OP/H8Wx3/8+C+rqZDd0977qx19AkUWlAL9Wln0VusEZ4yA2fXAVgZk1pC3AxMKj19+aih5W61vpOY2Chbvo4oWgRDAhZrdl5g4b89D7PCTCdMjQLIZoYmgmjCz+AFxBR1RZPHVxGKokTWOoFfSiIKj5DXCFu8j4AwdrKZKqOUwOjZoMhp4Lsko1WJ1LOoN7UulMrSgaKqREq66pnlcmFhmHCNOLqCeXOpAqxqggaJuQOkITVN5yNaEGrXQm0vlGLWB7Ix0pOrcSinkauhBNoaEK9C5TF8GfDZHXomebhjQlGEQwqRlnYxenlKmlDqEV0XUk4ZMdlskegLG4HFOKD6yzB3iMzjbX4oGI1EFxUljfhLe6kOtuirxYho4tWiFQbU2ZQUXxgw9qw5RQbMSXGQ62yO0VoPPWsf85pxuucS5HqQjZ6HrtyxXG548fcaTx8/ZbDpUC/fu3eTZi1Nu3TBp1ScPPmJ+eMir0zMO9udo6fn49AXHh/vcunGHy8dn/PyTT7jYLGASIXrmswnr5Qopgvctl5eXTKeR6X7h6fMf8/zZjzmYTelWZzz5bMuzzz5ilQub7YqL7QI/8zRtYCsLfvDzf8eyrFEVFouXnGw+/7Wf099Ic1bUbJuTWnPlxKgvFIfzypCL0RqN4wVYRpTRRAA3FuQjFa4emlEN5igjAdEBA3MLuep1pDi0ZC6Xhe0gkJTL5QJhzl4rTBvPMGtJQ2C63vLgeWbdbTm5WBCZMGmEoafCwFujYPqIQ3jv1j4DhnDFODHULnhEbclwFQkRhJSUnBNNGy3Z3ZmlrKuUwiImkpYyNj2YtkKcTWsGh3MZJ9E29up85FwwLnAWXDBh/g8+OuWDD5+jjM5cJmincsfbRhk6ZT2A86N9vuJDwfuWXQ9cwFVHTe+B12mMjMXeiG6Nlt6YQN7JTvRpAvuKgFV9nDLmLpnGrJr+2z2AqwvWlTHCaCYjckVRsLMAJ6a9K5g9vXdCU4WkIh4Vh3PQJYiuMJ04+jLw8WeXzL8+Y7HtefzknLfuHBFcIFQ30CZATlqbP+ukzDktoggPX6wZUuLe7Yg08OjFiqP9JV/7mnBZL4ZzHt8E8I6Uq5elN7RXc3WoKqA4chXtmtOmIWTqMLqT2O9O5SpHpFSqqHilCQ4ttvFRhw1fHl/s8enDR/hgbmW3rh3x7GxJJlFEcS4wmUzYbrcstgv+41/+gDRALgMpC8N2MFoiiSxCyjZZnM6meO9YLs7pui2kKc3BnNNnT7h2/JhmEgi+Zdo2zGaR6XTO3t6E6WSCHwNQnVRbfXu+o/OMZDZUySUzDIlt17FYrTi9WLJcXJL7wnabWCzWbLcwaxqWmw2pH2gQmrblfJu57PZJQ8dsdoRvI3nYcv7iGSWtUdGd85RqIQ25TqMtuPnNN2/wi599TMnm5FdKZhiEEIQnL17x7FUk7mX+9F/831leLphOvDlaxQkxFJroQTxPX5xwtD/HjYVRKdXIB5qmrWY+iT4VUj+Yllfgh3/9U+Y3bnH33nusFmcEFPGBg5R5cnaKq+HQoWmI4oltZNJ4bu8pQbf8wXfmfO/9/z2vLs45XTxkOnkTwgHrfkArJfPk+WNenJ6y6TdoHo3iQVPPs+ePOV3+kk1KbLavWG8veOeN3+OgvYPlj2VcwmiT4tmb7zOdTOm7LUWV1bNPcPuH3HnjDqcnp5xenHD66hVvvfVVPvjxnzLbn/HV9/4Wnz/6mKyZRw9/xqw94vTinMnejG7bcf/+Ad12wdnpivNFRx6E7TrjdAsRSogkSTbMK8o2Kedr5e/c+ENOH19wa7LHsfsLnn/+C87Pt6RtgggpCMvLwvnzxN4UjvY609xKB33Dq66w1wxI3/Hpj/4Vj0/mDFm4XKzp+471csNqueLg+DZPnj3Fe0cTGvaPjjmcHvLxx5+wXFz8TT7y/1kc0jSIE6Krg0ABF6I5Geeexjuiaw1cKR2WyGHVQN8l9pxHtwnv9wjODJCstAuIN9fSIoXihQjELGQRtDhDtH2DBKUv5rCtIvRpoBsS6gUpFi2kajQ4zcWCkUfXVLFEZBVnjkfqdjVIzgMuFCy6J1F8qq/jiNVt0fS3lUmQe9uPNQMGLYk0Fi2BkKPZ8nsvZB1MtlIwTTwOZQlqz3KpbCUpjlACiNVjBTs3qfVNzgVVR3AtirdGUQWRiMlmjGoqLtjAGmMZOVWcmvOuulJD6IWpRvZkghRwYnKRPMNM6ooHP6U7XaJ9x5A6W6tV6YeE04yTTK8DQT3ON0gItO2U4/19PAPQk3OPuEhJQjf0JE2IJIoOVXNWJUyKNXtq9VrAaJRNnBJcqHRRR6wGcuoa2smcdnpAO51RtPDq1YZN6XFdh5dC1o7prGEym7NcdHzyyWe8OjtnMpmzt3fAxeUFT549pQCfPXyEE8eqDs6iBCZ+StPu8yrBq8sNff+MUBw3jg4ZdKAnkcvAYmF0fHMSF5pWcD4zlEQpPbkk1sPCuF7bS4I2aCkEpxztRfrSISWxWazxOGbR8nO7bY/Lf0OaM4eYTsJZmHEpYI57Ba1FqFmPK64+WF7Y2UIbt8uaCEbdUbVhd1Id9krZITJoNhRJ8856eL0ubHsFLaw3A5tNzzyaADF6e4j3Ji2TuOTHny74xaNLFusVxzNPdA1mUZ/sPLISRAg4pm1DEydEF0xj5CMiGJwrgibTfjkBjVOG3hEENHeQNzg5xAWjwwQ3OnvZIhG80Q7TaKOsfjcRtwwve8BC05BTxkudVEsxG9TaQHnxNqEVx/FBZLEt9GJdgPfWADaxqY2Nt8l+tqmZiC2CwUtFumTXMAGM2T7y2j8EalaplYTUf5o7p1aXwqvFCKhaiIgz+8JdaK6MtKGR7lgdDK0Rs695p7uH2tXJUQx2zaTSRbedEIKJ7T95eMJm6Hjnzj43b8yZbuF/+fPPCDgm7QEHh/dxIjRNQ0lboncEL+TsccHaUi+KqOP0fGCzesHxjSnbVHjyfAWayEMazxgRy7JDIIgZ4IgIuZrZaF30nSg+vHZNC4hzDNW0IeWqzQzY5iDW7AYJlHqfBwchjlqWL48v8nj89BWIRxQaCZTiCM5TvMNJMJcvF3l+fsaL1anpy0RwIRBDpG0jPkxMuF06+m3HenlhodAitTgoTOIM7+HsfMW0CTRN4bIs6YeebrDweufUQq7FHCGdE4L31pSoOXq6+iylnOm7Qi6GLI8DGS9KPxSGQZnNJsiqs2dIGlQC/VD40w9+zr/74S+ZhBV78xneO472GuaH+zQxEEIkdwkJlnu23Q6UpOTcs1kvubjYGtVZbSBRgE3f4fqAcw1/9G/+mGFYEcVQ5ZTyzl0yNBiVSKyAeuzqYCkKQ29GSk7AhYDzpnvIdY1JRRiS0G86NqsfsXfwJ+Q8MJ1MTTAPEGros/cMJdvnpWaQEFwxepMT2mZC0xia0DTWLG9zYdtPmF57j0e/+AkuZabO08TIathQKooYphv+5Cf/LSdnJwQN3Lhxl0X3kt96759xEG5DHdgsLs+YzvYZ+i2xETabHi1Kt9oybQp/5+//H/jxj3/M/KBlu+r49KMf8fLFM4bHHSfPPmczXODbRN70XGzPoXhefH7KZNby8LMT4l7NOCoRV+6Tm8z5xSNk6CipYag6QgEmM4drOj7/6Kc8+/Cc7/72EQdNYtMV+r5ns1YmB54yKJsBnjyZcf3aksmkx9HiYmCzWvDoyTG3Dtdc88rDJw/4o3/bmx7ZBUMdcETfcr59ig6FvgibOOGibyjXEyLKZOL/ph73/2yOxauOEKstuuZaIxW2wyWEQuccIgHwOFFrhryQFFQjkUIbgGxW97bfOTQUcklEAk6FWCyHtKcnRosc8qpE3zJ0PVoEXwI+t7hsbKZcjNrXdYM5ovrqfFuHwGYoJkBGy9Zqxmokp6UOWesA0wVBgoUlW8SR4IpQssNLxMdIQQhSB+necDcRi9oRsAglqQY72TJWCUIabNjuXMaLksuW0FhkBwUabUmqqPMkNX28MQkEXERocKG1ukCdGYdkxSVrLPEYKOGoNZW3jFssUiAGh89YwLNAEQeVGq/FmjlxCfWFRIeEwSjFZYtItgbNGQU6JaPqiUZydBRxeN9wsD9n4ozH5sRkNqW4Wt9nzJDPGjPFptBDMinTSMufhIZp09qQ05msJsamSoQCJXjWvbLuYHGxpRsukNATXYLU00lm86rnYvEhs/1rnLw8A1Xu371HnDS0bcvx0Zx+6NluNoAn+EBsIn3X03U9y4tz1qstobQMQ+H5aoUEZ/EJIbJZLMmaUHFkleqwm2hjy2rbUcTRxEjKAs7jfSATCE0gb9cUhS5ltllJG0NXzcgt4X1gqEY4v+7xG2nOcJnglUIwE19f7X4z9qC0Std5HNnyVpxjZM1LfTCszahNF1Vb42pws1hzRrHNudQhh/Mj7JwN+ar2rWXIvLhcwn5L8ImpRmJQPMp+67l7reHp2ZbPXjlO1sIkJhoX2J9MmDQQK59/INPOpkymjWmCqoOi0Q6jvXWJFC30XU+MgZJ6YoCBxkww6nTDuwg+E6nOllpw6ogoQ2jwoTfqYZ18OGdTI3GjyDVUS/lsED+ACsE55jPPcqO0UTlfFd65e8DHj88IIkRn+SUxjJSD6kDmPVKRrDH3y2XTNBjFdGy7bLJ2FUoqFZK/ChfdoWujA1RFE8cWoozNl4wGAMakNlvoSg/AI5IQrRqu0ecXV+MJ7P6x64A13CIoVgin0uNLQ4fw009P+ezZkhtHDQdHE9ZdZn8v8Ooi0fcLVosnqLzPJHqGrtC28MadI/Kwtql8MGfO6D1N45i3ET8JvB8abh9PLc9s15iqGcTYB2ImIE4r1bHgCkio92bNg63yPaNJVTC55Movd4a+DaLVWbQ2pt50TcELQWoY8JfHF3p4P8U7YcjgZzeRxQniGkrpaLy5Xu0dHTGbh+rq4urUQimpZ9ltzGpeHa4kenXWBDhHcY5hyHgtzGYzlIx3LSkp3bA20boT4qQh5pEWojsX1KFPdartwQWEDu9s2CN4kIj3QmEgpcGexirkPD68S5new28+hO4JWQfS0NO0AVemzN75X/O771zw7//s37C5eMkrB4M8sme+TkmrDMuGQ94zaSKxsQ14bzqhG5ZkJ5RxWi7K+SYy8X/AtaMtF5//sU1e85gZJvTp/8PefwbblubnfdjvDSvseOLNsXPununpyXmAAQEQoEkaJglShkiKkEwxSIQsW1TRQR8om7KLdtkqlyzRoMqkBdAkAQIEBMwAgxkMZjA5dJrOfUPfeO69J+y41nqTP/zffe5I5VJ5VNNGldhrqqe77+17zj5r77XWPzzP7/FojEy8UwJVopNIeF2QgY0mg4OUSIJ8CiLxzbEFJIW2MvyJPjCfzLOX864XNuWhkEoGpWNuztKhdFoR833IEUicObvFu9/1ML/zzS3ufPefc2ywzuntNSaLOct5S89olIGiKnjs8Xdx+cK3OJh4aluzVqxxaz7l1y/+3zh3+gkePfej7O3u8Oob3ySFANbjFg1VaVkuRW7kg+fG9cvMl/s008h0/wDXLTh57xabwzGvXr/BbDalKg10ia2xZmk7TpyqMBWMhmP+zMf/HW5du8nnvv2bHN08zc3rM2q7QTu8n/2Db7HsJuAdQWnWK00KkcVeQ92P/NzPPc2b3/nndO0c3zpCgNnEYaym1w9srndY0zKZ9Hnx1VPEVPLQvTc4sT1Ht4ngAtE5ll5jU8JakekrpUnKkZaKolZ88tNP8tKl+/neNz/HjAUHywm++8GR0+8cP9hxavMcIMRB55zk1fmI7wQVbhQURU2IiuQ8MXhUIQW4ttCESKgrXHCUZYFWhtZ1pDSjKA2FlYGL0RZloQktpS0xKEpr8dEL+CIVKF1hKbCmoNdbI3YKWxlccCgrz0PxO8pQRUqnXHOkft5kidrGlhalRL1AVuNEr4gekpFhmHORGBKeDryTeicI6dFo2YXpMuevIpLHwhasHrfaKKwpxFXmpXnSWhHjXeCZ1gqvm9zEZJBaWIV9K2JsAQOhpSz6VMUaG+vHUUGTXCT4jmXXMJ3PaZaNQFS0SEGT8uJFLgq0FYlxCjLYIEckJJ1rtoDUkKZChQaCJnUKZQqS1zII9gEh63va2IhHV8tzJsbVdZslsKhcr+XYJJ3Eh1pYCFLj1kWFj0HIjUZjvMJELfcR7YkqoIIDVRNSYtE1TNuG1uWtJJ6kEg3guzmNcnRhQLdomd24xHS+4PjRTU4Ph9LkWcuwqA/9emjJ17VWhjxaCbV8OZ3jfMfO7R12d2/TG/Spej1eeOFZwiJmn3gemBsZmrcq4JInlhbvPQSJmlDRQXAs1ZLoHF3XYawMZmPnaDsHQFVXdMnLENX/4A3aD6U5MzqfjGQAh1aaEC1KLVkeBJJeGYiE1CNhySspl8jtSIakisNidLWpKQoQQ6WWjZNKEAqBI5iEU508pBSghaIWk2Nv4djuQecN0XmKqqBQiRgS6z3L7UlBv/b0e4nCekJrmS4jXSioa7BK9LIbhaUqylyUBKyRBBDy91EJYuOFwOcdhTEixdEttqzomiVpX+Rq0bU0rZPJspPMj9t37mCtYTCq5ANvStECG/GJhRCkG10h1dHoPIEISTZgddnj4XNrXL414d0PH+PO7SmFssBK/qSxupSOIAntzyhNMoKiVzF+H46ZjNXnsLmCrAGPuR1bfYq1zpK9lLXY5AYtWzRMvmDEcSE30STTKansTP5crHaAGReikC1lhm1oJRst5YXMGXwOfNSQouOT7zvHBx8/jikChakpSyhNQWE1g14BxvDEw+fQVmGrApcN/LasadMewwL++s99UCSKspzIUgJpErWShsmYEucT83aOz0kBKQoRMiUoSzmJwSuhQWrkAZcEPZ6MXAMpZdy1RibpMa8RVlrzJD62lH9NW5FhiIZbLoxD+987x9t2+K7mxLlHOHnPg3z70oTJ9V8lkKjqioHSbG48wOb5Td5847sSrhklXJ6UPYjGSBC8EWmejbBMjsOAeqXQqWFysEtI4GNHDAZMQIWUYR6RVd74oR9RKcFhY2XDrIXEmiJ0XqTf3olsTWUZb2Esp848zE/+9J/gfR94P5954Q4XXnmD3/qlv8tyMqUgEExgffs8x+69n7/21z7Kv/Zz/1N+53Of4bf/699keuuKTKCBlEmxstGT+5RPEFzCaLlmqqpPjJGqHrFwhseffIZ7H/kQz7zvgzxwTvGf/p8dL377i+JbU8j5QMlQKgORQIhqXQiEKIOliNwfYgooTJ5a56KI/OzQOkeaGCS1JWZSqkHHKB5mksgug8JHj0IQ3ForykJhNLzrmXv56Z++Hz9/ic9/4Rs8/611dLtAp04GWZ0E2hIl7mPUK3nppdeIfYGovOeepzC+z429W/TW17GLTd5683Vu3rnB62+8zqiocEWL7ZW08yUpeYyBxaLhlQtXuHPjBtZ3LGZT9vb2uXDpGo88copiCCZptlXJL4yOE/YbfrmY8Jw6YLSRKLt1fuvX/iWXL9+kqFuefem73D444J4P/hwHaz+K3dqmuP2PcQGKQjEcnaZ39ieIt17h7H2XOLI55fmDJcp6ok90jYESigrq2uFvNlij+fp3j/DwQ4GN0W2ef36d9z51mWGVsM5wa1dT1QqrS8ocrh5jpKwMz3z0Xv4nP3OeuHyTL/3Hv0NUFW9e2yXGBgGEv3O8ncd4lCjLIg9q+xhTkjBoY0GJPzAEUMli6bGcz0jaE6Ioi4hiAQhBJINN01IZcKFhOV+gyoKuhc4tUUVJGzUpOnRIVNZl5Y/DFhXOl7QxMO0CV3d26Rfr+IOlQIxsoqgkyyzFiFE5awzJfgTxeWujCCoSabEqURXyeQvSKWGVSCBTgqoSqrYPHlAoWxJ9lEYqkSXS4rMLIYrP1eSBuVJYW5KSbNCMKfDdMgPLsupLI161KGFqOttT5L4tw3alhL47b5YstaOxkbIYMOqvYfs1PT2glyKbRxJN09B2nTTRrqNzc5GMx8jBdEpSMKhrAaNoA8gQL0XJp4xR7BTLRury0hqsCfgk1FhVWKKXBUnrRb7oXMC3hTR9BSSibBXz4CrkZta5gM1WmxXBLXiRuCafQAuZ3ayYAbbCFiWNC+w2HfPFkm7ZsVzMMQpsZWmTQ6WCtj+k6Gna2R1mwYPRIjGtFI2fMZntU9l+jm2AVX6iWFa0kMiRhl4+b5IjvD6saWaG5mCfOF1QNBHdKrpsJYxZ1dd5D1GiseIigAVVGJSJAlIJ0g+k6DP9MuSMWnle28JA9AgpORxyJn6Q44fSnA0rncOkRbomnXWCoGldoGk9EairmrL0aFVKbZ6pUxLgLD4gyYLKJD4dKEwm45CI0WRpoTqkAlpdEr00UiZ/DQxMlx6XCiod8UERlh1OBGZoFRgPFF2qpAFwcoGTIpEOFxS6FHSzKXsU1qJ1osvBqykbu62piMERtCaqRlLog5VcrrzmJXiWk125WFTCZFliUWpc6zm5PSAmQ388oqqGIqFOEShISlEWBdGLLlhTkmKWQCoOMe670yU6OgaDHjeu3cGj6dUiSzBGbkzGGFImZcaAqE6TBFGqmIuhsAqOlJu0fJ5ys5VkYi0yPok2iCFvxmI6vEBSpg2lfLOLaNE9J09MARezxDPIxjMlI76qFLNEQcAwVaWoK8kMUxp8jEQihiCFWd4kBq84tdlDHxmitReZppItadISeyCeNpvtjqLtTiRsKXTNpOUCFkx1zA1SnreHHBCtFCl2EowdPU2Tt4AkyrLKNElB2NpSCjahMUnw5erajGl1vhQhqExWk/OsEoISj6IV90mMswppopPWkLcEJr2zOXu7j7/7v/s/8di7H+GLz77EZ//OL7L0kNoZVhsOrIHQ58/8+F8l6dt84Xd+nT/80ueZz6f4EOTzk2EvG5vHQTlC65g3c1xw+UFiKYqSraMnuHFzznQ2IQVp7OyKRkre0h42Zllak0RShFL585Q/+ynmnDNLCB0ow7A/5G/89X+bT//0n6RtEpM28Kc/cj+3Hj/OPcf+Dq997w3miwUnTz7I0XvvY2084rVLM6qqx0/8xJ/jU5/6Mf73/4e/yx9+/rMQA9rq1Zzn8JCNv0iMS1uiSdiyz5/4yZ/h5EMfYLh2lKqqUTbSK0b8jb/1N/mr/7MX2b38hkwllciHTO5EFat8pJXUOZ+L3JySt8cGSFrM8wawWuOSDKXKXkm3aIlKhjEJK3ACpYhKiobCWEwhBv8EaBsZjAw//2/+MTbWL4H/FtcuXuD6tYqUtgmp5satXTYGFZqAUpFeoahqz6c/fZzfe36HtisYjXvcvLbHztXXKQcFe29M+MaNlylKy7mHT9PLkSDT7iz9gWHvzuv44EjKYIJmf88zuven2fvOLzGbTukVFq8jt68fMDwyxOqC4bzjqzs3efnOLnZ7QL0tMICrN27y7e9dZGPUw1SOD33oSX78p55ir1H8p7/2Cm4wx/Q28UzRqqKZGdIyok/+CM984AaNu4TjJO7gDRRWJFcxEbLE7Z4zHVduFLikOb51A1iysW7Zm1jQc67vGL72QoePmqS67K81GBv5ub/0fn7i0z2uXf4WL7xwgwfPlVy9eYLCruGc+EveOd7eY+6mzIMXkI1SqGTR2hKDk8GvWW2hkealFMuESiUm1WJhKQoZFhoYqgrXRRIVSm2QQsT5SFlWJOR5RtREj6gKQityfTtk707Drr5M4QuqOBZFFBbXOKES7nsBVCiFUkGaBKOkUcx5fkqZw0FwYQvx9Rt5/rvQitpHGYwpSIVm2TQygJVlh6DsY6KyFdYWJCO03GSgP+rRuI4QoVcO8C7QNp14xXUiOfG+93t91jfWMNqwbFqSNQTfsmwbFJbC9tCmoCgK6roWqbWxFEVBaQsBqERIOhLyFshYTVnXtM6xc/sWMQWsinjvKKuKqipxzmUZXs641GrFehN4nrG0bWKyWILWVHVBgRXaY5R7q7IKY8WvH5olyQfCsiW6QOpVJBTBe6z2efhlMMmiyCyAww9LACOeZKMUKihJAraGZAqWHubzJdNlw76WnEzlAz5CkRSqLkkqMl0sMNGxtTagYAOzmNMl6THqSmNQ+DZgUpdhdfLtAwmfs9biinbspdnSStRqtio4dvIEWmv2b+8SLrtsM7CSiacQuifyTPNRmnRcQDWeLgmwyBhRhKQ8KBCFjKgvjFE4dzfTTzaOP7gN5YfSnCUFVud1s0pETPZGWVLqcN7TBZsL3koIO6JnRDDNss3Ryue1pOj9MTZjoeUhrVQODMxrV63lg2Gtx2iZFozW4OEzJaXq0AS6RUVwJREtWxEt24m1kabrSgpt6BdSDBlr6fVKxv2aflliS8OxzSG9QSWT2PzBRFuC70jZpVVWlsL2SbHF6AJbaRQtwSXqqiaZPr1KU5aa0Hpcpv6EmDcrppCtoC3BIKZ1o9BYUhIAipwnxHOCNDir9UmICddFirWK+86vURjDieP5pqZ1voGlXNRICysh02LZNFomxyEXGwmXt6CQhYy5gSAbb/OmLUm7BIq2czz/0kUIQXTPyBRaaZNfhxSMsnKWAlMpLT+nFsmlSFg7FAUb44Iq059QMaNay7xtlc2h1TBdzDBF3uqpDqImRJmch6SJyeO8I0WJZfDRsZzNUcrSr2p2dg747OdeJHnwUaIvY5JNrkIIQykXyHIPMhhteOxBCZxNKgjEICBkKNWhg5YUPBUJKmWgQR4uZHBBSgqVFIXEFqF0okuAX1kwo8hPkzSb2iD4fCWTGfUOrfFtP46dPo8PiaNHz3LugXuZ9SM3Lv8+7WJGEUv6/R5XrtzikUe3+Is//z/nJ376z/LPf+kX+fLXvkjXNDJksDV/4xf+Iz7zpV/h5GiLL/z+Z7h5YwejYGt7i9vXb+Jjx8l7t3jzjZbZnQWJyLheYzFfZIm3FBC2rJjPF7z//e+iP6r5wue+yKMPPcLFq28xO5hz9sxxnnzycaq64o2LF3j5xRfZ3t7mL//lv8r7Pv5TfOuFa3TLxImtddrO8fJbN/jF/+c/YL03wPaP8tx1zc3Pvcyf+9GP4h+3xHbG8e0NFt2cH/mxv8A3/vAPOLh9B1Ma8YlZeZh2jZMiD1FF1IWjXw34s//6L/DAkx/ClBVt13Fw8yqkSHvQ58zpdX7yj/8Mf//v/W/onAMShcrxzwnJViNnEomumrrXox6M2bt9C6Ui43GfojBYqzGFZdDb4M71W3ShFalim2Tqr0RS5L3cr622cq9LikFdU1aWwXjAjRs7GOCv/7sf5dTJ63zv21+EULG7t2CykAf+eDCkX5Qc7F2jUBGrFFVZ8dijIx5+aJcT9zzAP/7V67g9yyu7VykVRNUwKjShV2BLS6ECylYc6W9wW72PtcFLXLtyEe88OJGhh+lV9lyPH//ZP4+/9Xl+93Nv0LWJo1ub9PpjZssDrt6a8dW9HbxSuIu3ePjUJge7nrLoU1ee7WMF/9a/85M88rDm8sXnefh0x888/iu0ywnzRw3ffeUMz188zdQantn6LE88VlJ0B/zu7+ywuWl44dURwXg6p/DBYSoYjBVdG/FeEaL8ZaLCFoGmgwsHNSmOQHlmc4EllD3LcDTmYx/Z4tMfb/ndX/8GbXJgSk4f3+eeUxHfKrQ6woXLe3+k1/y/Cseia1AmkLKaheQxusyTf8lGNFa8ZGEp4AxFJLiE1SUJC0a8+jFFYnJ430gcT4yURU3bOfTCHNKPoQJVAVp8sCVUNmEGkWD26Q/XefihUyjbwxjJFCuKmujF1x99OAQMJSLeOVzX4UMQ/HwUcING4dqONjhiErWSUoq67lNWBYvFDN8KUEieozJIr4uKQd0XHH9CmjMFZVUTVcKoEmPqfF+SIr6qSgG+YSkKS1mUWe5niKYkhI6UAihL9KtA+7vbP2l0pP7pWjnvKXWytQFwSsKuY8va2gClpdHwTtQXZVlm4iaZmEgepEsBFj1gNG1oUNbSBSGchyw7XEUAaQyFztoDpXAxsPQti66lFypUbgiVMXl7Jq8/ZaXCKgA8qSA1vxZMXVkVJFXTKs3BdM6kaWlCEDiMNqTOEUOgKKWuIzlqq1guHbvtgq5rOLI+Zn1zg+l8yWTW4rtEressl5fztIqcSSmBDxIoriWPUimdh0oJa2XhUpUDFos5l69cYekdpiwEkLJYoI2hsJkVEKP4q7VCGUvKUtYQPCsmQ1xtIRT511bKsZTfj5XV54+oOWs7BO5hBKlrstHYo3Gt0G18aImpznIx8VOg5aR1XlGWABplVr4zm5s4ASlAzARTmerIEiQQknjVHjg1RhvFsS2orcknymLHcvEZK6HDRliIDIfDQ79bz0K/1xcTf1nQG5TiPeqVFGVBZWWyFGIkBE9EETpLTI6gA1FHNAUSDqjQukBHTyyE0mNUwPuOzlnBuld90CXKiy8ixkyuyWZEbQ1oAWGEVoyqInPUpBwUKGZdqGuBY0yWiiMsuL1reOTeI6yPesJONDlKOt3duK0IglkMnf+eCZqsEN5kw/j3rWPVisYoG5wYNSATLBcTs6WHnPdGXg9rI3lLxgSUht2DKc4FNscDNjZGWIzkjuhEjPbua0wqLw0UKmlIDnRA6RrwGFty7tQ2333pAGvnGRyTsFrLVq0wlNZSlDKdqktLVRcMasOPPzCkrEve89gxHjn/CZSK6AxOsVbokJItp1Fp1TxmTbK6u8mVYYQ0ui4ssFaBN4TgD5tZBaLHVrIhjllOYFSEQmWqkeSqKEROJZTG1eYlZ8Bpk/H8UgC/AwR5+4/+WsU3nr3OsF/xkz/5MYruQ0yXP8bFF19h3O/x1PufYb6ouX5zn+Fgg5P3vIv/xf/q7/Ff/uLf55/98i+Roqf1LYtmgnMt/+Kf/bLQxCIoldi5cQOVYHN9g0IlTreeS8sdmq6hrAtmB5FEoK5qjBI6oQuer3zlD+XhEyO7k31OnT3DKy/MuHzlClevXaOuKlz0EDXvfc9HOPPQ+3npe9e5fTBlPBgRlePyWw2dK+i6xMVrb+K5jd9eI6kR01lHiALZefPiFSgK+rrmyac/zhd/558TXBCZUaUxZYVv4+F2zxjN0ePn+MjH/hgf+ZGfYj6fMNm7QTc9wC3nhBDZWfSJoePhh9/Hhz/143zlC5+hXS6JVnPqzGn27+wyncyIMeaQWHkQ3vfUU9zz9Lv4zf/HP0TjKAeWm1cP2NjooaqOolxn8+x9vPXaC1hb4FwLWYXRtA0+JKrKYCuoTM1y4WiWC4IvcDHgfaAaWZ56ZJ8Xv/YFlrPAfD6lay3jcsH24DaLpeLJJx+gWx7jlVfeYOkDU3WE3WVicvsNNo8b/vyf/BM8/8KC3/vsr+Nt5MT2iPc9epJf+p0LFDaCa/kLP3mSMw+M+fn/4Jtc2HyIYvwAfv/lHHcyYLYwPF5/jaZd45Mfanjowcd59cVNvvOtF3jrysusnzzGn//r/x6/8k9+iTdefZnN45usD87g3woM12r0iRl/8d84Qhm+xNc+d4nO18R7hvypP/UIe7tzvvKHr5H0Kwx7O2we6XHPqZs08w7TK/BtxzQmmuoePvPZS9x/LFH0xAdS9Cumu4GDCQxMn+vXR5zYjtzZS7QzmB+ssWgDvX7JfGZx0XHq7BZb2/fx6U86Lr38Gjs7+wQDWjf0S/jUB3cJLuDaCXWx/Ud70f8rcKTOYwtDSDJwiFGyBTWGADjfoY0MSTQFKXqsiRA9rZ+htCFg0FZqHpss6+MNJrMFPgYm7VQsJlq2WikoYlgKTCIljC1BGVx3AEETvWI+bXj2uy9TDErGa+sYXXL0yFHKqo+xJbbsUeg8GM72i5Cjd1aM6RhFfbIiqK58Yai7RbTUNKuc1HzbIg+WVgRGJXI48acmbC1DfLzYSNq2o2mWJJzIAgGvRSZtMATXod0y+8sVIbQELyTJmKWgJtOYdY4TSGkVQySeZVbLqGzxqUuboXqKIpMsV7VISNkWkmFkuVMAo4lKPHtlVeEbiXGRSCKJp0LJ91cxYpVB2QrnW7qQEMZRwqRIL+cKy8g4K7eQ85qyUi4poYcXuiAqTZNg5iKTZct0Kb4yY6XO0o3DhiADcZ2g0Di3oFKaYVHQLByTOxPmezMG6336/T6Dqk8XO6qykjpVqWyhysA1LcyEFRJAqlD5bCQUXScDdt+1xJgo6mwlApLzVKagrEoWviOtmlirs91I47wACLWyohSJkSJ7zYR3Ic/BkGFTGpU94mSG+Q92/HA2ZzGKYTHJBbGSoETliRpMadBRtLZKaSSXKheoSmOKTDtcgSEApSPGrDI4VmtBj5LKhqRU1gQ7lCr40KNbFFUhUkkbD7O7tFJo5KK2laFdthRFhVptMQigNCFFaczWhgwHfaq6h7ElJmcGJeTnU10nmFMiMdZYnYh5tRp91t4a5OeN4osKnSNphSmFmhY9UEZMIWn00ck0xZgoWNfsN0NrkjIQDLiFZHRgwSCa7CRRAWePV5Bq1kdrXL29x9Z4ydnja+jSYLWGEDA6kA6JmHITSBnrnlszBNiRG49DAz13JQ5ZVkVabarkRhBz2GuMSVa9UZNipnMaRWkTS5948fXr7E8XqKQxZpeHz4x5/JGzEl+QFOTVsMqgjCTfSrxllKS4PJwIjfoFf+JHHkcZncO7NSpzZ1MEZXWGC2Q/iopEbbCIqSwRGPZKBnWRN2Q6++yQSZRS8tlIBRCIKV+ApLwBNqAk80lneSUpkoLPTalIDFzeWnovW2WiNGpJSXEdk8mBjlm+uHoBMdOxcjiasknIUEZ+3/z30DC/c/xgx/7ehC4l3rp4FWvgm9/+As3+Te69736K3ph/+Ev/kqcfeoZT9x3lpRdf555HDZf25vzUz/w8f/DF3+fa1bfQKfLF3/sNZvM72dcg8r+Ym26R+cCJ0b088b6HmJ56i52J4wvfeU42xslgipoTp+9lbVjz7W99TWSvQbycKST293fRJuUpq8dFAwRGwzX+9J/5c9ycNRQ+D7oKTbtYMvdybyxtn0VhIQSohoSgcSES26UQ2pYR45Ys0Xzk43+Mr3z+N/Guw5Rixi+Sodfv47yjV/X58Ic/xn/4H/5tdhZ9Ll6+xGIyITpH8g3edaQQqW2Pyd4O3m3y8//m3+C1V17m2puv0XaOsqw4OJjA9z3McpAHL33nW7zxwgso5wkqMd33eUofaGeJ/ZuvMx4OUCiKoiDi6VygXXaHBcnJU+ucvHed4DTf/fpbMsFVmr29KcYa7jm3wbhecHXuWUwaQieo5PvPB04dv8B0Zvn6iy1d2KZ3/B5ODZZsbN7gzPaUpl2yc/Ua60df4z3P/Bk+99l/ibWWuRvRlveR3EswrPm3fu5xPvKJHq++cpNPf3TMv/y9q2ysb3D6yEku7ByhS5uMxo6PPvYtTp3rMVrb4OIbX+HY8ffxzPs+xm/81q/RNZ6vvPQ9HnziIU4eOcZLr7/EpNmmHiiwHb/w7/1Zmv3/IxdevUpadMzCgv7GkBefv0xRVhzcTnzziyWXb97mvvsiR9drbFEwm0XatiW2nkcenvDVr/d4404t6ofrke88r/J2wOLdVa5fcxzdLCgHnjt7iTu39zDWYMtatv85f2py5y02xmtcem1OTxfMlw3LYNCjQFkrispQ9Rw/8uF3Nmdv9zHbDSiTQFvaLknxniIlCW01RvcpypK27fBJBofLroWkKGyNLaz4qoyE21f1iK3+CXppKSqpoiEq2aSIlG+EzmHXSmnKssaWBSEGuqbjm1/7OuPhER55+HGitVgrUlpjSrpOQBgme7lWUKKVIogkntPV3SKI0YzDzZQyohKKAj8zJiuCktSt8XDDESB5keqxstckkk60vpGswqQIXr5H1zagPFo7SFrIjKRDL658H6msIDeAOm9XVL6j5WZTVEYmD/JVLvbT4S1QYBz554siEZY/S7bLWMyKFKxNzlOUb+2jwFlC1+HbTsichWz1xLesaDLXQGU1m7aWznlaF0jKYrTCpJAtLzIoluAjqdFTziY+jH6yfRatZ2+64GDW0SJxTbooxRcXEs57fAh5CxXRTkHo8EuRpitVgVa0ztPuLZnsL6isYTzsMeyD1YEYzGENupIyGm2l2dJSQHZBBom2yLFVEULyQGRtPOZWWdK0jUjjC00TPK1zAu1KCW0ll69zreTNGS3yfAUx5ODzFPFK1CPBJ5wL8qxFQG+rT8APevxwUPpakzCHG62UZBZhdQ5ZbjqUlo0EGQaikLWxBPyJ94j870rnpkoXeUsgzYSK8kEhOmJ0KKLk/wwt1pZiTkSkdMFDjEsx6KUOFUR+Upg+Knmij/mGUVEUJVZbqrrPcLzJYK3PeH2DoqgwSgKCfecIweObOW3T4LHs3rzF7Tu74KFXJ44eP0pVmiyLk4sUSlLZUKoStMbYgq7pCE6aV6M1FPrwJkHU0p3nB6C2AZdSxmTLFlCtyGRKCniVCqJx7M/ndF3Lb33tIsfGFT/6oUdQ2sqKVRd523I3X06WUys/VMjelZTBK8JGkw3ayhi1+itv1JInZY8XKuGDo3Oe0MkKX2UZaXCJN65N2Z8sWHnZIokLV6ecOTlnbW0gPzbF4UpY6Dky0RE/oUBXNIm2axgxkJthyjdeLVMetEXFRApBNoRAUoLaVdHk+IZMpMyB2CGJ9FKki7L9jQpp7lI4bFTlRMV84nIjiCDN26QOP38hRplYdbKl9Er8fCiFtVEmlhFi1HlIlnJYOIIlX32r/HelJA5CrIE6S1Leac7e7uNbz1/Du47owFYFo41NfvtX/kt+/wugq3uI5ghPP/RhXIgctHMmN/ehP8DS4xM/+hP8k3/8X4BLfPXLfyCSZnEv5qmjxE4Ypejajh/5sffwmV/5h1y4sMN9xzZ46vQWz11KnD9zktH6BtWRk9hBzfCVF5nN5/LAToHNzTHXdm7Sq/vMm4X4PVxHYTQfeO+HGK0d5cKVN+lXtQwJXMPNmy16OEZpQ6+/xuz2NSmmTE0yWZoRGpTz9Ho1k70d6mrIqaP3cO9Dj3Hp9Zew2vLpD/wIH/74+/Fpxr/8zO/zP/5zf5ETZx9jdwmd79BmgDZLuvkerpmhtKUs+/jQ4peGtfWCZtLyl37+b/D3/td/C985Xn35VWKQgQasNtVy2gptKLTGDvqC8A6ehKfu9dAmMpsGnnrqSZqu48KbrzNbNiJl0XLPkkQVw2y6oDCGrY0NDg72Je7FCu793ntAFx3KCmVwsqOoBx2q0Ax6hsoseM+9ln/xjR71fMbHn7jB2tq+PNM8pLZhGJ5F6WcYjNbY2hjzzDMnqUfw4GOPcu7UkiefnPDWpUt879lLfPI9Wzx2/zbzO6/guhmzpuW5V1rOHJ+SmHPlwpSdao/Swqh3meXiPjbX15mvDXj5tec41jRcurxDGx1xcovbr97gfZ96P+ngN/HdjOUs4puEi5Gb127xvedu88ZbAZZjLt/omCw9z79QsDcNbBzpc+qUZ2gSmo6l2eXJh8d84Q8nWCPvR4iWoBIGR+NkiHXvuZZxf8If7IwZ9yOzxjKfNzgv2//bN5ecO+rZ3xuTdEVVBSaTjl7p6BpFUWTPjAbUO56zt/t48MyjsvVSGm0KfEwUytArakKKmMJirMF5KeaVUhA1VhmsZM2ItFAbAgmtJPNqfeuIeNGzZ0q2OBqlChk4K3tY3EeTA93nC1TRJ+qSwXiLLnSAxui7eWSkLKtTshlJh15UeebHGDN4jDzklAZsJTMTenT2BCmdx7Xc9ayhslJHnssmZ7AmJRuhkGV7Jp+HlFbqnpAjd2Q3A4no5R7vosrSttWWTobwcj5WNVfe6ehVA5bu1oH5nw/levnQqiQbWw6zH4nIPTP/uNHnEGkt0tTOOTov9o7Ge6oB9KyodlJeTKicMSzqNGna5l2H0xJHpZVB+4jOtRQpCOEhyvnTxoAtaRJcOVgwaxLeF3QxyHtWGjAGHyG4jtB6kR8qeR98zIRePFZL75CUo6izHNQHtrc2WB8N6ZelbAmz7URUX/I6RfZKzqmTRm9FeXPeyWY0y1J7Zcmg32c6m7F0IoXVSmB5xkgTGWIQWmjwFFZo2SQnfmgUOim0FY5ECEId1lKMSmuu1eH78YMeP5Tm7KPvPp8n+asPkUFFWScXWuGUxlJIRo1WKBNRSsJUZbWczVTJ5g+JOvQo6cy2NCnJn9MiCQomYE1NWfWzWXTV0EgOWVkaiAXRCdI0EEgYBoMhMQQqKz4hXZrsa3AMRjXDfklvMMYUY6p+j36vkknCYsZ8PsMbRXSBSxdvMtzY4NHjR8RQHh3XLl9jp3GcP3cKmKN0Cdn4H0JCK0twLdoobt++RdKazY0NbGlJ0UrDqTqMrnKTGw6lqlYbCivbF/t9xMt+aVA4Nss+FJorN0WHm3TBoCfbmy6Rt24xS/MMKWl88IcSPZU3iCoXMnIDzJHU+WYkNxTRM6ckTXCMmbGY0dWTScuNmw3rIxj2e1gTmAbHdN5QGDG7KpJop4ncuH3A+trgbhOYNNH4LIFwrPLfAoL7N0ZR2IJVqGPK5EyVMmg7OpbNIhPZxOSvYmTeScGqtSIkjVHQukgzm9EfFsRYcfLEukwU82uMaXXrRr42YmxeabVTjDL1sQrnBZmutJUHQYiy9VRC8VEqHBKNVjdRtMzpCq0EWhNE+miSgL9TJNN/ikO/3mqFHn4YF+47x3/ncfLYGm+8eolgC7rZAoXLm2OZBFpbUfcrlI8U/QG7d27SNye5fuEWTz7zAf7FP/1HdH6R73saoxQ+X9Bp1edrxfmTx/jGl34L2sRj7/sITHfYu/U6D9xzimXTsHPjGsXt2zz18KN86mMf4RvPPceN6zeI3vP8Cy8c5qoJgVW24xH41Cc/zf5kgW89qfD4RUujEvNZSx0idVXQW1tDV32Mt+iqh3ZLohZ/1o3dO1y+uMOZYwNGwzWcC7z3w5/g4psvc3R9nQ+99z7e8/QDPPv6Df7Kv/232T52ku3NIZev3+LVl96gXUyhXWK0peptgoLQ7BFUohqeYH8+oQoH3HPqFNsnTnPt8usydNDqbmGVVRPaKOqqh1KJtc0xH/joRzly/3l271zluT98lltX32I+XfDdF18gpkC/qEjRELLJezgYo5TmQx/9Sb791T9gNFjjgXMll66WxBQ4NRxw+a23eOTBU2xuK4q6wrSge56D/RZTetaOGaLVbG3u8WPvDhzZTGwOGnTyBAe6SOgIurnGzp1nueeBM8wP9vnaN77H2mjArZ07fOpDPb74hSssZkumE8/6hmazd5spE1CJ8fAmH37qJhCJviBEQ1lGFssWwy2ee+73OH3+MUYnzjPZucClK88jkuvIzSvXIEYev+9+wvQfEW0khgwviorJ7oLrVwfs76/T7s/wwRGdIpiOq5ct08mC0ih6245lMKTegkeesqwry2xxAEnRNnD1oOD2gaV1ilMnEsNegybx9OMLKl/zBy/2mTWOooJFs+Ds2fMc23Bcv36TQR0pBy3hhhTCly5pqGruuTcx7jmif2fo9HYfZVlibIkLku1XWFFxtKYjOI9yCh1EwdS5iLUWoy0+OsniAlRKQkPMebTy7PZCm87NWUq5LgiNFO/G5MwuGdT7ENmfHOBCy2I54/q1t4hKQot13nAVRUnM2w+lxd8eydJ/ZEOllAx01SrLTKQ2qCSKLTlyAJhKefCc78FqRYjOg+cIOpn8/WQDo7TIJSMr2IRkw6VcoMcV/AkZdidkoG/ykF1q3JCbQVEnyTJMvobWOqu4ZOCk9ffFD+VhuNRv3PXE59ccMgtBkyCsxJw5HolKoCBdh42eYW1xLuGWC9SgT4wKn4FjEj0gg3ljjbzfIdAsHVVtCEhdKe+rlxYnIjRgW5JMwV6buL03ZdJ4PBZjarCFZFBFT3Ihb/IaYlzIQMbkpjVJBuwqI825FkMkEBnUFZvbY45sblAZKzA0rbKfT2fVmc1y0FVkQTw8d1JLCQFdBqPioxyM1xiMxzRXr5BSQOeq0SiJbXJB8P4g1haTBxoxSeOsc5MMnsJkSavSBBQ+ugwriUQd8Pru9vP/1+OH0pyNB6s1Zw5CzZMBmVLkRkJ7CsOhrne1EYAgjZoCyfDSGGWxOd9L5SBSIfBJhg0oykzfKWxxV1WqxLskxRAkZYmdoSx6hLgkekd0Df3eOlW/R9UfMxyNQVdU/RJrFf2hxRR96rJmMB7R3ziG7Q1o2yXh0su8/ubr3Lkz4Z77z2GsR8VEDDKZOH32NPP9W1y+uMPxk31MVUGUPDdwKJUwukZpxcb6kDu7M4qqkEvQRIwpsKaHNjkdHqngrLXUvYqqzFpjI/JQQ8HmGJKPvHlzSWU1TWsY9kSyub/wGJNyE6EAm4EackM1h1AQaYy1CijlUciEa0WLi6vcn0NqGnl6JpSamJsUFxxdiJhKsb8ITJsF/Vox7wRmcmxzk+NHh7RB8+bVm3TzyJ09ASCkZDFJEZMndAl6ZZZPygWVFEhId6YZrhaNSQISc6/D82/s8r1nv8sH3/sIyiis0oTS8P/65a/wkXed4t77jxOTZXuz5ruv3+Gt117jxz72BEsf8GGIMUX+uf2hmVNaNE3K+G6RpckUhqgp8uo7xoDWAhwgOgIZ4Y00XSusfsr0xnyvyN8j5zgZRZEgKoXLUgFIoMOh2TdzTX8Yl+47x3/Hsb1Zs3tijZuXdvChIXRLQCzUGIMyBVo7YoReWbB//TqjjTWcX1DUll5d49slKk9R705F5dBK8cRDDzOZ3Gbv4pscG/e4/tpLvHp7jy4a5mHGrFkQPdjC8t1XX2VY93j6iSf47M4tuiiREkYbYvZM6Zx1traxxSOPv4uLNydonXBB/Gs3b+zx+pUrjAvLA+fPcu7M/RQeUigoHzzBbLJg1BfgUFX0WC6XDHvHSTGx6BxPPPEBflX/A+5M9/nalz5PVyR65z7Cu977BEZFnn3xCq+/9CbNdA/vZlhbUZQlKSzpmgml6eFVj6Q1Fy5f5YHjJambc+78fVy9/GamTeq7Ruo88Isp4r3nwQfP8wt/589z5Pwj7M+v8XvXbvPEuz7Gzh+8xc4v/jqzgymDwYjesE+gouta1ra2UErTGwy5cfU2OhQir7GG08dPQllw+crrDEcVDzxcsWgjs5mjqAxHTvb4/Msw6wJPoDhyoiT4jrPHDjAmsmw0a2sW1wSqSmNwxCZB+xLLg2329ndZzhbMZh1H1j2Fv8aVKw2xEZT4fB7Y2ZmQosboXFgonwtSy609zUtvGs4fNRi3x9mT51m772OU68fY+uAHePXUaX7tn/0y5ZETqNv7pLrk9NYJQnOAsmUmjyXaNhIJWFOytb5LOdTc2Qu0jdzb2i4xvR14oSlI9/c4c2ROlRSpmXPqXMmda4m9CYzriLVw37mO+aykqh2q9Xiric2S/baPLWqKIIOkBx65n5/9c3+R6xe/hla/RtSKpBWDoeHWHU/rSuqqpOsWNLFD2er/vxf5v4LHZBlR2mWvO3mYE/E0WC1bzBS8UF+tBZ8AJ/aQKA1diiINAw4HjRAFcJUDiyFrbQqR4aES0XvxgXlPh8OnJUk1oAqMclirZXsWV183oAOQxL/jQ8LFgAsBbZXcY4N4jkARnEejD/PIQGU7rMoWgVWc013cOnCYIwlyf9f59aIROm1UAh8Jq9ZHtkttjhdKUWAf4olTWX6opY5N0symnFF0mH+Wn+8pW0KMUXnwDWR7x4pGuFq0pbiq19KhX4ok8ssYc7i0SqioicEQgkRJ6RQpS0tpNIvY0CwayqqHNVZI2JlK6L2cR1VITFKzXLBWD6UBRZFxmaLyiZakezhqFouW/dmERRMIXpYwxshAXbw9EZUiPnh0gJSKQ6I3+eeNTmByhdKYIJYcqxNHN7bZ3Fw/bEZR0hiZ1blRwmoIh/LP7C3MJZJGCfSDFcREmu+IpbA1vWrAbDmjLCsIgeQDPuvMtJb3chVjI1AQiRBYMRlSPtcpKYw2lAXEzlPk/6YwNm/4frDjhyNrNEjBj2iBJTRPLtBBXdCvNfNlxFrxBxkjH3ylI0RBnMsJzqHLWi4uoyXHRqns+cqAEKsNLkWsFb/Q9Wu7rG/1GA3XUCiKVYecgQ5G16yvrbF95gwn73+Q0dZZdKoJfg6dBBEqI8TGam2TsncCZRXWFtjBSZQpsT7i4ho8/zznHjpHrRPOJXy7R7dsiT4Q9IJef8BoOMN7S6/URIIQ9aPCFAbXtphCY62lsCXWalLQhCT6bZEOS0YZxCzx1IcbQ5IESmtliESu3tEMSk1lZSrfG1gsmvc8dpJRr+KOqVgg0/uYFAkD+NxAr2SKILtxLc0DKRtHZWIleWTpcHNz904h5ksJhSxI0bJWK7YGGu81bQhMGk+IHdhEUQa21/r0Bn2Obg355ncvMe8i0/2Gg8UBt3cPuD1xnD+xzvu3HyDb4yDJxRiSg1TnbZaV5kgFVJBJCko2GldvLHn2hVcZj9c4eWyDo2tblP2S59+8ys3pko1xzZHNB+mXmkXT8fUXLkCquef0dpYzxsOMMVbet+RAFaCi7NCSyb8tUzSdAv3KEqKEtqI0KYr/TP5Pk0LKElV5KKakiWnV9MlQYSXZCHkaGXKwusgbDETJYEnv0Brf9mN20HFkc4trF6/SzBaAQVuDCRBVh7UlZaEhBvq2ZGY8YXmd/Z1bLG1iPpvlvBdF5/xdf0He9G+M13nqiUd5/rnv4hsZ8sRCs7M349TpY6A1TdvSpUhdVDTLBtd1dBcc1lpi8JRVRdt2hOAgS12ihnc/9hSxGhD8AQpF13XErqW0hqNrQ2Ln0Mbw/qffy4XNEzSNY3urpjjbozLiAR0PK5585D7WBgVt29KreoxGWxw/eYbrb73B77/4Omm0zvpuSUOfsjvgzpXrdMsJoVuKlN0GXLPEOUdhKhoFVa/HoNAU2mC1YrmYc/L0KTbXj2MLw63b10lJJswyWc7b69Txv/z3n2RZfIW/8yu/zc3dXebeYbTl3Sfv5akPPc53/vB7hCADrSJoSlsyGAxou47QOW5eeZO6NBxMdlnb2CZpxfTggHYyYW2txhjF57/+aW7eGnD26O9he5qyKjCuZLq/4Mh2QCVHStC18OqlirV1w9FhS6/vqW2idYF7j9yG1MNg6JyHuWLt5BLaKW7iCMFghh2X37hCpGLaFVhdsD5aShQDFSFaKhzROXwbcG3Dia0eB7bg0SfOYSa3+Udf/iK9e5/kwU/+ae7ZLnn1Dz9PXTj8vCOqgqgSyoLrRNJeFh17e4nRkSFFPeLpczdolp6LlypuTSx1jDz7vYrJmcTTW1AUHdO24LPfXuPGnhKoilUUVcIqRV2VhGiZNgUu1PQHPYxyCH0Z7n/oXjSKrSPr7F2LGGPp3BnK6iYhzBj2HS5FTIx0i4Jvv3L0j/CK/1fjsMOalKDMQe4mQrQGjwwXU4gi7UuJkD2DKcZM4UvSwJniLpEOoTGrjB4vjM2f4Tw2j0FCcpREcNiowVZoU5FUidU9UrIoLDooajugLEtpugBtElVhpdBUkl+WEGiHMYaua/Eh0HUdIWm88yQf6WJDUAHy89z7iHcBayusKbIqRwKDTUawA3iCIPVXA1GfA6dTroGSxqWI0hqXN3YheKzVh2HWgu+XzZrSCrXywimTpdo6238kqy0El4OTU66nBdG+Akp4H9AoClXLBi6l/H5pPF489mpVR+us/pGhlvPSzKYc7dPvD3Be5I42/9whCNpewHGlDKOjp23nhFDkLMcarSuUqfFJ0RFpXGLaLJjOl0KbTQVKRYJzRB8pKiPqIm2ynNERXQdBMmtJUYLpaYkhYVNEpYAhMu71Obq9xeb6hmzzMjExRNmuqQwsOTzXKvMh0l1JPEiPndxd6SurzWmCtbUN7r33fq5cv8Jksk/nvAQqxUjwEt+ktTSCKx2VUlCUJTF4dFQIl6AghYA1lrKStkrn9znGQFnWP/h1+gP/if+vR4HS/pB8Y1QiKkNhE8NhjdEwGmhsZaTO18iFmGEKMl6JKOVQFFhlss5V5SlqzF3yihgTcpaPnOEQDOPRhuDVlTnUzWoFR09t8vi778XFjjtXbvHmN74oGRpOglqVsgzGQ3rjHqONYwzXNxhuHmHr/NMU4wezBwmUaRiu9bn/8SdplxPaZk6RFF5lWWQhzUHwjlOnj/Lcc5c5d89pUAq/WBB8wo7X5WdQmsF4RNUbSOq9jkSHFCSpQhkp1OOKiqF0lsxJ9/7Bp87y+P0nWHYtIUTGg4pB1cuwlNXkJ2F15K3rUznhrJo72V4eIkBZGVdlJSwraDJ++u7mRmdJ4Uq8GgP4kMEgiYz2DxzMGuadIG8DIuErS2kmrTHMO8d8uWQ0qjClJbmOP3juEi5noCQCW+t9MQSjUDqiY/6GWmNMIARLwhOTQUeJVlhhYK0SQlE0hsmi5eFhxaAynDq6TuoWPHDPUaIX78nZk+u8+NIYOsXJs+vEpLEpsLM7YTFb4r3D+YR3ER86ghcaUgiR0hY8+fhZNFqy+LRMB3VQNEHW8TJoiKSgQUe00ZQ6a8wTeTouQ41CSzRAiCnLcHPTnAlNxlh0fn+jIj/23jnezuOpx89yZecWX27mLKZLKKwMhBRE32GLHhQFN3auMqBidGyL2WJGNGuYXk3RHxK6A2noteTaaS1bIWsMH/vgh9mf7xET3Fk2tNpCqzh19jxdM6VtO1SC0Wgg014SwXfMJ17EFD6B7ohJtuIy2RM89jPPfJDJwSIXKoGgI8vJPmsnznJn74CmC6j8QFkupgyGR7i2c5NBUXFic0SqAs+/8DLHtjeZ6ApT9Oi6GTs7DY888V4uvfkKdIHnnn+J7qXX+fJXXuUnP/5uXDtBRYciUZc9lgc3KOs1lB3gVE09OkpdFljlefDee+jbXWIMnDl1Chca2VErwSCThxIkTVlpnnriOJW9xP/1sxd4c6+kc5FEpCwqXnKv8NC9Y4qvgfeOpC1dNyeljhgalKkwZUWpPdr2cE0iOM/BdEFRWUpjOLatUG7Kzd1E9K9hFTTTKYO+oV3O6fcCbTfi2s6A7a0OoxpUActFIvYiuES7hIOF5ey44/jmjNlEJuSh81RFpNQBfKKZBawCnxQXb8LN6YDNkefx+xJX7ox5/eIWvfU13vfQW5w/cpthXRCnCV1PMYMeNym4/PWv0Dv9ECc+8FOkquZiO+fU+3+UZ196g3G6h/sfvklMFnRL5zSlgbVeQ/+8ZjaF4VqfM/dGklPUQ0t4bcR8/4BFE3ntzR5Xb1ne927NxkbD+UdPcvlLe8TUEZwhdPmeryDlTXIMHdGMWB+vocMO7bJjOOhTWEtnahpnObH2MN945V3cf/Q3qM2MVHcUPYMl8erlMWZQ/pFe8/8qHAV9KWZX8uGUUClQoIghYXSGsKlEpfShxUGhoMj+hsNtjWxeVRL7gaHAdznwXakM88ob4QArj7tGo0JCReENaFVRVH2JjdFaPD35Xpmip/MenZulEIUwqWwhaPuVwiUGytrSG8r21ftAiJ4YoyDSTYFVBRaDSobWLUk64rw7vC+r/HB2qSX4CDo3SVEsF4WR4f8qIzGnGRGjyVh7QwzxUCHmXcAaWVgkFWUAl3O0pIY1dL6QOjd48c+HiAuJgEJreXZoY4lBPFVd7LCVJaZAoa00zio3A0l42iopgoJGQaQArbGA7xpcDCRbEpQRZU9hKDAYmwghEfBEDCF5+Sx4jSsL5tpgXaBZzOiUYblsmWcKI4AuCrSOuCC0Q5USXQdKyyAndp7YOQgypPG+k4E6EqVllMZ3DaaIbG2N2NrYot/rSyi4F4jIyocnGZcr/oI+3I7GKJWRyVT3lKSEVdpC9sfljzwmRdZGQ3q1YdgveP21C+y5AwItRkPTOPGFm+9bjqiItQrXNfJ8yv5G8vLWGkXTLjAFHN3eZmtjzI0bV9ne3PiBr9MfTnOmxKxJJtGQPT1KW8ajHm3npUg3q1Vk7miVFK1ygo3kOGgrxJi8JZNsByHmgSxIVlsjlXW/m1uD3DhoxOSq0UROnTnBQ49s88JXX+TK1Wu41qOsoS4qikJTFgVFaUkaTNEHAjEEjKmzWyk3RySggG6KtpGUvHwvrQS0UQSS6+SnspagKrY2BkwnjvW1GhddXkFHCis3p6QLjPVSWCmTddAekXnKpkWkngkf4qF8D6UZ1QU9q5gsJOxx1CspipwZl1aGxxWUxUAqBP2ZFLnTQR1OVpRshcjTHCxJ6cPznZ++uUnLMtRMbUwpv1YFEIXoBYQgP5PVYE2iLCxVUVCYkp4xjDcrpvPAsXGPuj/m4rUDSC0hQWlKNjaGAvXI3i7JltPYpIhJ03XuUNaIDnmzp1DJYK1lY63PsDekrnqMhhUWOHf+DNcvXuZg2nDuxBGMUhzdqNk6doSeciyWgk597fKEf/RffZ5PfvQ+nDecOzGkqgbURqAxppRsn8994RWefPQ0ISaMycGFSREzHMUogyrT4RTShfxMIxGjEmInCmOSmF8TuJA7LxWpjMYEadQSOmdtyAWgUNLdvXO8rced3QOObG2ydWST3StTRoMNHn78U9RWY82Ate0HGA5rLl7q8Elz/NwJbi06DlrHsm04fuo+Lhx8A6JQwwQtLTfx9z/1Pt7z/if43c/8DtYWQhTUC1QXefTBh7l+oKhLx3Q6k8msD5RFwdpok7Iu2J0coI1k91mjsLambT22LCgLS1FtMJstWMwXYpI2ikWz5IhRDAcDRoN1+qMhIUVOnjhO52Fr8z5c2+BDg/MdXdQcTJck79g62mM2nfPKm6+zffpRtk7cy53bV7mwc5tBr8et3S9y8XTFiSNr2MJysJhya29KFx2nTx1lY+teKPoYA7o9IBYl49rw2c/+Nrdv3+bqlSssl1OqsshDKnkIr6+vo5VhMZ/RrxtuXH2NInS0cUlMmtM9g8az6xJd7VAGggu0XYvrGrxb4rXC9nr0Sgi+ousanHd0PoIpML0NbH2Ajwfg73Cy908IW1eYNR2V1RzdSsRl4GBZ861vH6ffszx/WfGpxy7x+KmGpCNVnTBzg19GZkpxbU/kTPNFIx6akOhVUaTMSnyksXM4rxn0Gk6ULe1yTuv6vPDqKT70nh16PcWLl7Z57MTNDEmJDHpgT2zy1uUrfPGzv8vG+z/J3s1rUFqWizmz0RB14TU+/tA+IYJV0AVFaBS6Dy4E+uOS+azjYF5Q1QNsb4HZGfPwgxo3TXz7ucDSLOl8wZe/pfmpTzpS2MPrESo5gvIY3SfFBpTGmEIm2W5K5yPTsMFA7WOKwPbGmDde/i5Xr32PMycLYI9BdZ2k9ql6Bc3UM66l6L69X/DgA/M/6sv+f/CHwNlUVseFXPQGrLVYI8/QFYhCo1lBef7bQbqrzUTXdYcSZKEB3qUQpuxzN8agkxTNRhtiCLgYMggmoU2i7pWg4qHEUGT8CkXJKuswpYhF7C4hpMNNyV0Lwt0/b4wwCLRSmDwUN1JeEnH0KiH4pVTjvfjvy8KSkqbzQYbhSpztIstEAqO1QeW6MGRLgveS1Zhyc7CyXkjckFAetZH6Jem7EsoUAyoGvJPhcwie4GKGsim5X+iE1iUpKZp8L+9ChzWaRehQKAGRJEH0q1y6djh8LLEJ1Lwl1JB8h1KatlkSlaZQA5q2xcaUQRxaMtCU+I6LakDUJVeu7XBzMqUIAqqzVYWPIpdfKS2VIUcFyDYwklDJQXI0mTCslcJai0sdUXsMArZKsQNgfdzjyOYphoM+pdUQElHncGdtMPa/mQ+ns/orrT7TMR02v3L+Y26a/SH1MqmUGzpN17SUlWE8XmNr+wi+S8zbAxrXZC+gNKzaSA6vVuIz67wT0vp/w2CiBEwXAjol9m5f58yJNR5+4Azj0eAHvk5/KM2ZQtbjh33XSuupFSgrMqAYUdnUuLrYVe72JTsgU1K0IMMVAkAQ/0/2PiUylSWikskes4KN9QwRUcJA0ymytr7BQ08c51uf+zY3b93JJzVRGkN/2JPVqZLE9sXcM1iTTVpwc1JYENop1t0m2jUSiuQn2ME6tn+M9to1QkoYHanrPt6WkA6IfokKiZQsZ84e5+VXb7J1bESt1wBFVKufyedpVF5pxygWfqUREqAlIebJFBXOBQndRnNwMOVKWNK2HXvTBU2bqAowSA6bC17oQlGagNv7HRvrkudAyF4llWRJRqYSJTH/HuLj8+Ql5fdSAC2rd1sfvr8xZcVeuvuh19pTWo8YNa1cUNqgjCbgCEkiEGLsuPfMJlVh2Vwf8e0XLxOc48hGj6oq5TXkT5c0O+BNRnxoK01LEs8XJk/2VMDqwIntPr2y4MzJMbYoiCnx+H0blKZha1RzdHtENAYTFR984gw3btyi1+sRo6z3u67l/tPb+GDY2CiJgIkFSimWy5beeEBKRY6NIGsvA0UhpmHx74m+2sUVzVIeCj6I5lzlJk5riMHKpDCB0ULwSzHJQjC70Yy2EEvQkiv33wP+887xAx7/91/6Ch946mFOnjzF9Qt3GPTHvPeDn+Ta5dcwKnBkzdCrLceObuIXuXCo1jh7asDt+T5Pv/tpZte/S9tFOpdIVGgdOHvqQX7mT/0xvvKdrxMWJe9571OMxhfYuXmN9fUeZZfYrHocv+88X/3GtwlOZK8heGbzCTTQ6w954l2f5Oq1t9jbuw4R+sNMw00FL37vOuOjp2jmS9nUaY2tesSYOHJkjRee+x6qV3Lrxk10ingivapH3a+5fOEiJ08d59H7z1HVBdcuvkp7oIlFn63tU6wN1/jUx3+KO/t3+MbXP8/84A5r633m3YTf/PIFfuLHfxq/NCy6A86cfwJb9UErCuXpFgsq7XEOYuh47sVXuHjhFWw0xOiJsaCuSqKSHMHhYMTG5joXL7zB3p2GtbLgPacL3vAVy66hiw1V0ZcmqhrIEEwFdIrMFjPZWPtIX1muzncwxTluXL/I6VOnCNGxsX2Oj3zsj/PWpYtcfPmfcuz8I1y99k1mKqCSIe8o0abgqy9u8on37XN0c5fvvnKUvaXiyMihg6ZnEr6NzFooCsdyGlj4NZS+TV2UdN2Sus7bdJPQhaOdQ9CJjbXI9Nqc4AM39yqOri9YH+/R73W45WlIBSF5Ygt70yXD6S7P/uqvEvpjyu2HOLj8BgnPZDYBtviRB19je7TDcl7SRQ+xpG0860XCGygNDPoLThxZ8tVnT7G91nDx+hqntiYcP73O6du3eeuqJcSO/duW/UWPqvCk2EJRY0KFsj2IPVCepCtU9CTdEryja2aUOlJp+K/+0T9hvTegP5jz1OOWwnQc7X+W0kyp1yp27kgBH4Ji2Ie9xTubs7f70CtJvMqSxBzPsipkvffS0GjJPRP/0AqGsVLzyIYmJQn3jVGGm4lAyHWaSHDEly4FKyQM3nd45+T7h9VAOuGjA8JhcU/W6azil4QmLbRFFVd+cxmjy+vKfqmssJIjZamJJSaRNibjpFbJHjqj9WGD4QkcRjApgY+IpA1S9PguEHOtSh60hdzYgpKYJSW2HPGMVdmOk60oQWBhK8JkTIGYHM5pYlLMgkeVRnxZeQDrfaRrhXarCo0tSqbLBq0TqXMQBZxijM4/vdRMTsmGUEWByBECzmUvYYz0Ksl/1T4SOk+7bFFGU5Ylg+GYYjymqHrMG0/roT9Yx3hR/CzmC7HiaJOBGxGTsuVCQTSKFAImRmzKQ2mds+eCl1w1IjoFSqPY2lhnNBpS1z3qapCJhxGh9plsLVnJQcl3ZfHmSqOVhIsQUiZIyjBBYgUkA81kRV3MGy6NJxYty2Yuktg4o2OORGiL9ajzHTF6UrQkNN6HvATJVO4UDq8Ho82hn9H7JRvra5AcxiiW7e4PfJ3+kGSNRnw0q8nKKiNi9aKzJ00bk4vKkFew+SJeLd2ypycvwKQz1nlbkx+WSktXozOlReR/MmnQwCpL7V0fvJ8Lz11m6TVl3Se0HUo7UIHklygSpjQEL1ML18zBLSkLzXI2o9q/SXAttuoT3RLfHpB8w6gumW+d5ebVVzE4rLG5d5YJUTJC3um8oa8D7WIpP3+0aBsF7BA8rnWUVQ0JwXAmSKrM2RvxULaZAGMSUHF0aw07a/AuYHRi2B9gDVSlZW1QUvd6GGMxSoKptVFMpnNUlhVIl5+1z5o85Qn55ufymjagVCX+pzwZk+DvFZlGpEQAMfrDzAuVkKkQitJaMbjaiFGiTY9doigtZSUXB0Zx/dYdttdrNtbWeM/jp3j+ezucPr4J0RCSSC5XNEm0EWCJ2K5IeIR8WBy+vhQlh+KB80c5eWqTXmVFJkhkUCWefujk4aRDWvXE0XXL8fVj3JnIz2us+MkACpPY32tIRAoSIcB00nJm3EcpnyVY8jlNCawyeLUK8JQLPCaRmakEIYWsUpVAS6tXzV2Q5s1IwxyClgY2ZfhJlkgqHVAxoQsZQrxzvL3H0D/PFz93jafe+yR1v0KaZHnw7ly7yZHxOW7s3YZuSTEYMpu3BD9jMCrYbWBz4xSba326rsMHxXwGD9zzEO//8If4va9+kQsvX+PP/um/wl/6m3+e/b0DXv/eyzz/reeZTyc07YQ3blzHK0N0DkUgJotLkcLUfPADP4mqRhw/+QBXrr7Om69/j9n0Dt4H3vX4e3nymSeY7DcQHe1yBh421ioppnoj+lvbjEcb3Lh0g1uLA2Lw3H/PBlevX0Mpza0bO+xPZrz70SdQtmK2mLOxOWZ3smQ83GTm5nz7m79D3/bxRc321ja39yf47Wf47a+8zk+89zTj8TE0geF4TK8/opkfoJJH6ZIYvRDiOvEqVD0oY0HXtIzWSoYjoYmVRUlRlDz++NP0BwZdthw/NufY3BBnu2zbAq9rytEJukuG8WiTrp1iSyuJmdl87yRbhcuXL1OX8hxyPnLi+CkiieMnjnPq1L/BP/jlL/P6dwZ0yyHDomVr7NkY1ey1kfFYM652cU1iuqh4bDghRVEfXLxQoZOjC5aigss3Nftzf5hlpG2BLgYi+YkOU8B8D8zAMCwNxzcaBmPDzl5k2TnJSwoOUxmMLUmu5fZexdhMWb7wLG89/zwn//jPQmloZhOGG1vMZtdZH/U5fnxOf31MMdhkZ+cNlvNIF8GogCkMISSiDjz18HVu3BkxmdZ85P3XaQ8i067i/e/WLBeKGxNLcp7vvKAYjUaQHKqZkuo1GewVBTo6lOkR3R5JGwya0E5g/SSpu0ZSkY9+/OO8/L0vMx5GvvWVNyh7msavo0NFSC3Be1CR+88s+PLzwz/iq/5/+EfI2UthRWPWQjY+HIhGQcLLYyrI7NGt/vRdKmJKqyG7qHzEygArAuHKW6u4C9zwMeSvEqVqjOJvjSQa16FSyAX0ylKxyiWLd4vt3IgltdpEq0MVVYrpELgF8ns+BTwhbww5bGCSimCUyPgO8fZahuIgfUH2DUkjmWM9VI5iViIzFNmLP9wkgthCFHlTmOnSWgtk4+5mz6C0wSCWiOBhrV/lGgTaznNwsI/zUpvVlSHahA+tbJtcklltUoQs/w7BA+KRS6WmLg113+BTResDdr2PKhO9zqODkChNaYiaDDQzeKVRRUFZ1+wulswXjWyKAJs0VVWhjKJpWlzXilUmbw1VoUh4TBRkCjkfNkRPSiFvDSN9bTBK7CXHj26yNhpQlFUGoLhMNRaXV3QdwYcsiZXPXmFXfYE6hLusFGc6DxJSSlnmKQPvGALJCWOibSC4Bft3dlgsJkyXCw7aDh8FqLIarqtsK0nOgRXJqjVGaKIpSq3H6nrIAwqlKOo+rou8dekmZQW2/sFbrR/O5kyFw02LbMt19guQ/UsGbZU8LBWAQSsLqw2ajnK5qJC9YjZfFAZtFMRASlaoK1qAIjEvmhRgrc1rT7lAt4+u0+9X3NzZRVmDMRCVl7DiCMr20KmTlTaBjc2a0DlsVYMyzCe3QEXK+R5lWZFCoOsamvmSXpUYuAPKoqQcHGfn4mtUPUVZDIlGmqsUI53zbG/2uDUPHD++IR+2INldPhkGwwrnWlBiai1VKRsW7/L9KMjKO4EKnsIUbG2usbYxxPuO5bxj1jjQmqoo6VelNHMpSZOh5Ca4mAvJTSktm7BMHRSCpBh1U5bVrYINdZ40xNxcS3sU8t9Fe00KeTq2ynPIm9Ikfrmq0nk6IZlfRgcKXUogt1Xs7y3onOfytT3qnQXHj4559KGjHBkPpRlJKw04mWQmr11rJVjWlYSVld5YsKp1URCNoTQZo68M0cuFJW2pwQfHom2orKEoNFErlA3Z26hIOuFCxuWGQOclqyPoxNqooirlgZSCwBesSmLgTbLl0kroPTEFyOdSpYROWSKiE8omQtIEn0g65vdOHT6sjNHYpLOqVqS6gGjgk9zY3jne3uOB+45wfcdy8fVX6A162WdWcfzIcWgblPY0beDylR3WtwvqYxWlNjivGA1HPHLmfXzu985z49YlCu352I/8Gc6cv4dLF77M6y9dInnLPffcz5tv7XFk1OfYPfdSHrsPkwzH1w0vv/ESvY1jfO63f03Mz9mJeP7+xxmMt5jnCfeJU2d56+qbqEmgV1kefegJto5v8tbrV7AoXPIMbMl4a5uukwJhbTDGLeaM1wqqapsuBLSp6NVjku6wStMfD2malqou6aYtpqp5/IGHKXuKr335BvP9m0y8ZsNWTPd22dra5s5br1P1j+BCiTYRggbfEtyC1DUoFSmKIS7AbDZl99btQ8nn1pER3VJQ0nl4yZnz5xmM1tnc2CQkzxe/Nednf6bm1vWvCkXLB4yOrG89xTcuLHjmA8cJywPKqkeMz3Pzxlt4H3BdR11XdG1HjJrCFnSdZz69zXPf/BxvvvoC6xsbjIqO3RsO7xNPP9NiTWK+dMRQAB29oaGNPSaNZrRu6WaKnVs1v/PsJjWeyWKJSpG1rYreesC5Dl2J5Pr69EdZ2/8eKv4hXid8UvQGmmgCWndUVUWvmnBzd5O9O1ssHUwWA0KU5qdxidPDlqZfcOLRd7N+/Cw+y6ca12CWC+Y3L/LPXw08cvYoL12oaJpN7ju+S9KaRQiM6hLvcqgvjuObu5zclO3HN14Zc/K4Y/OY5oGHNuDyMdar6yQ35+q1dYxVdGGO7mZo1aF6W5ACwbco08OqTKy1A+ZhQN8cY1AfcOTEFpvbP8bvfuEzfPVrfZY+0bOJ7dGUk8cEMe7R1MMZH33mHbn22334pZentpKaTajuWd2RFUgGJQG6OVpnFUkBfJ/VYzW4ld//ftljjJH032jOvs8mgdjEQ5JCfbWxE/iXOsxwFBjGakCPSCXTyh5Abo5WEraUFVkq15Xq8Pd1HtinvPUTSmV+tuYGQJD36tDTtFIDhZgzwHLzw8rSQY4LyMqWFFM+F/nnQ1gFrovSFIj48fC1piSwj0Q6tJwIJZtDeWZVGTY2x3clplogZIHEqO5T2oICcC6SrJTyIUjodNM2RKNJDRTLSN0GWjw2QREiVV3TuEgyBhPBW0/ZL3DOQ1Ew7xwLJx64CPgAbbugCxG0hJWXZYktKtq2wXup+0wAiwyS0RAKS4iQnEhLTR6KuxSxvYqyKnEKDpZLmM9zTUmWmUqzXRUl1pj8GVGUZUmIkjm2goCszutK07k6ZyF43CoIWok9IIRATJF20dC4iLYVpY3EyRITNYWSaLS6MnKemiU+eKw1mJ5Yfqq6JERH0pGy7qHRuC6Tm/uaqiwok2ZQDkAbWveDhx/9kJqzrD9WGRsOJKUPw4lFrrfKgtB5axEPKVzS/QrMQTYRAk+QKYckoktGoKy4jVVEJxeatqtMNA63OFvHN7lzbV/0wCEQOy8rda0pyh5FoSFafIKqLkhoCqsIERrXMqzGtIsFi4NdWVWWPcG1p8j0wLE+0FTNNe7sXsd7T5xq7OY6puxTpEgMibqUadBWVUrSeHAS2KiNIPi1wcUcUIfBWGiXc1KEXtkjJYPLF/BiPqc3GuNjQOUgSMUckiPFfvYjiTnboGSLqE0OUQyS24EROIVo6hCku9wsVJJzt9opofVdyV6+EeusvxbogNwdxfS68q+lw02nBkq9ysuQxsJohTaJ/dkSvXAYrehXJR2azndcvHwHNDSjfc6cPUavWhO9d8ih0fl7qCQ7o7sqBnX4ADFGU5WKWYooo7l49YC+CVRVReUK+v2KSev44pe+x/vfdQ9tobGFZnN9zJXrd7jn5NEcsmlJPqFry1u7U958/U3W+gUuJD79kSc5fc/TjNauSQMpllFUgl6pCKqk8Q4XfZ4gJrxE/h1CWmKCLuQJptJZwpFluym/DykSoufzf/gyP/Gjj0tjfEiPTHJtvXO8rcfx4ye4cf1lrB1y+eJN2g6Gw4r92Rw/n/LWte/y4CPv4ujx4yRj+fa3/oB2/4B3vfejbJ44z8s7t9idRaxSPP3Y+3nPxz7Ijde/w6uvvsGyWVKYe3nhjTlPfXjAqzf2+d4be3Stw88bfvTjj+JSxWOPvYfd/SUXX3mZ8XBMr7QcPXaWxcEEkyJdUVP0SrquxRpN1y64edBy9a2bpJCIKlCZkvX1dTrTl6FA6Dh95iw6Oi5e/CbXL1+jQ/Hq3qNgCz52zxH6paYe9Knqklv7ibquuTOd8NLL3+bV73yJuphTFCNGw4rxdML9p8+yExyqW+DbQAoPUPYrfOtoFjPqyhJDDhjO/tm9/R2axZQUE95roXWVia5T+MYxHo34D37hb9IfDDiYHrC7P8GEwGsXPGeHT5IGCkdBapfUccCPvtdAVIfht726x2/8xhUshq7rhLAVxQvTtA3WGl763jdZzqasD9aJbUs1KFFEiSkZQpgvcW3kSGXYT/CFbwxZuiFHNhPPv1rygacGtEvD8RP3kpoldyavopQEmC5mLTFBVVXM51OM2qPXv8Kig+Qj3hh6I0W3jBirsKqgNlPe/9SE594YklzLM0+9JZ6LqCh7Ct/N+fxX/gX9x3+MtmlpYwPWUFQVum249M3fY79Xcum1lsFgyHwauXEdPvEeaFNkrCH4iNFGkkkCkKm3Tz5yh0pBXWmOHWl46c2OydZ7Od1c4USv4XNTT1mOaJsDsKCXN7JkLUJRUNhNMJGoNck3dPUGJ889BhSE7jpnzo754peuokLExUiKLf1Ckp90IQPeUs/+qC73f2WOVc0VAWKmBLMKJBKfMzrXaV4IjYKil8I65c3PCsCgclO+Kp4Pv89hc7ZqrtLhv0uwc8IHGfJGn+gah1YZRZ+i2BaAmJuzVYO3oh3KvkK0QIeLgdXGRXSIwMquIQ1RzK8hhXhoz5CvzaFsU+lw+D1yG5gzR+9ux1aSw5XsUhuBa6ScO7Y6mz6Gw4Zr1dAefs0k2yYXPUkZYlqBNIL8QDpzAsj1mVKQBPJutUhCWy/nKQQvlMcoYJeyGmCoOKBh0gdfgtmbMog9dA4FJ0hjWBnZcrapw6SC4BNd6yiKgrpXgY6EWOB1hw4BF4QO3DSBwhoKjQyYY8rCNyFLr+Jb9MrCwYpUbSmNZb03ZHNjTGkSmkjbdRhV0HYNy0WDD46qqggiSSPFyGKxYGNjg7LsYe2KNCmfR63M4bkWgIv8mrIiR4w+SBC1VmhbUNQ1A7VGs5hhQ+Lo9lEWyxbfOVSt8N5TVRV1UdG6lqQUvV5JCA1VVeC9BHjrJIOD0lq0tYdAncpa6U2Mxbd/RCh9If7IC0J9H3o9r8RNghC1/AOBmLMmFEX2qUnIrhj8smZXGflrVXhnGZfSEa0thXRueWuiDw2CKcDm+oCdt3YgBvxyiS0UyfYoikIK5EJT1ptZlyoXXVKK3mBMWRS0yyldE4nLGdpqemsbGUBSg4L9yZKNWrH0RX7YW7pliy2E4qe1Bp0I1mLo0y4X9Kose4wKowxJGQrbQ1tBdAacdPWU1LJ+zBMBTW80QqkoplNR+NGra1zUzJcBo0pUirnIz9OuVfeSDBLMF7O+OX7f+2Zzc5FPBJBH9CTu3vxQK7y+TMmIiRUGdnXRKW0wpszUQtn8lIWhsBZbaIy2mAKMKTGInrxJDUElSmtxefq0e+Bo37jOU0/0ZeuqI0qJUTkk2aamIDpfoUmKNyXff9HKMF9IN/SVb1/j2JrnofuOE9IAreDyHcerF27Rs7C1NaSuatbWK55/aYfzJzZIRprY4FtSKukWDfeeOsLerGXYU3SdZvPU06B+A0+HpiIRCDGSlKDxg7fZ6OxoMyhEkSjyNo8I1uRMGITiF2IitIJvbZyi7SAmQzQa71Z+RPlZo4JDTNQ7x9t2lFhOnTnB17/9Jjdv7GN7Y5EK705YLvfRuk/QcOHlyzzznnu5+tYLTG7t8K1vfQ5VDRkOhrC8SdcuuO+hp/nCl7+Du/5N7tyZEjjN4+/9aY7ff5JXr3Xs3D5gY33MteszHn30LBvrAx645308ct9pPvrJj/GV1+/w+jeeY+/Ks8xuX6Whh61LClMzLPt455jPl0QVefP1b3P5reu895n3cXRrwMnjW5SDdTpqrFXYoKmGNbM7B1y/cYNXX3uWgGV56gRe9/nI2TVSjJR4kuvYu3OVL33hMyyXC45u9jh/bJtRf0idGi7vXGOU4AOf/BSf+dbXMWGPhjmvXXiDdz/xKBHHYjlhbdSXZ4GyxOggNdy68Rb9SnJ2BmWNChKt0jda5EpefGk69JhPZuzd2EUrI1EssSAo8WsQFO3CkWhQCboUMgkYClvg8IehuMPRiOl8xmQyYXN9zGTW8L5nPsHx9ZqyHHD92mXq8hbT4Ln4ZmA8iCiTKArHY/dMaZqSsmi5civRYWmXHYOth3nwkUe4evEi6bIoFVImvPXrPhtb21i9w7vu/TLj3j5urpjOVSbUCpChrgs616IrwwNn9jh/6jauCRRlycJtYytDf2S4OV+nWj+DqobMJju0C89wY53QOXSyRJcIVaRtElURiESGRSLZFluI50WUnhLiqg1CvM1Ap4jHU3DkSMvunQtU1SYfPr9JMXsTXa6RqOmVJ3HuDmGxQyRAcOho6VyWcTaJ5B1OJ15J9/GTn3qA5755iZ/91wb82r8wTKZaRG22wacoXiKnSEbkR+8cb/NRyFBWw+HmSWdZY4Jc4Ip3TGX8Onq1bVpljEp1ELOEUOwkHG7XVvmgAkPK/22Qbchq0JtYca1EchaDDCkKWxACuE7Q/pItlvdciUPZmSZvsfLXAml7dH4Rq21ZRCARMiDNm5ngDzdy0mTKF0+ASkHqohxjQ1pt5FbSx7sbO1htD1c5aAFj7aGUUxq+jOnPzdj3o94FBS85c2lVkAZ53qdwt6ET20bEKsmZC0HUYCEEtCpQ2hC8Fy53Eq9ZKgyutGhqYgut1ajQMdI1QZNtPdJMetdRlQUUQmGMSlEUUJZQlhXeBxoViV6hrCV4h/cdrvOiZAo+q+REYpmUhaiIwaF1Jh4mad6MVhQ6sTYacP7UKUwKBO9YNAIY0kbl7d8C7zuapqNpGmKMFEWBc47SlzmWy8hnL7MpVp8/oXjm91slkpGta1kWuTSO2SdY0S8KBmubeO/wPtLMW5TSOOcw1kCCoAWrT0qk4A5zmH0XaJZL2uBZtg1FVZK0oW0X7PoJZWUpbI/gfvBh+g8n5wzES4Vsu5LOBJO4CiKUD/vqv16FG4t2V8LhtApZ2ligET3naiMiV4z4zZSyslEz6tCAmnKzEJS8GVYrfNOiUqLq19jSYIwitEJZtEUlWzajicFhdE1hS0yl5cOHJ+GkiPCabrnEViUqNayCtUNR0wt7uN6Q4CMhLHGNQVVBDKbeEVxLMVhn7/otesfGkGSqaLTC2KwPjhGFQ0VNUdYkL87UGOWmeFfbHOnZmv1FQ6nktStdoG28u9VSWhLhkfNEEs1sTBGd5IFI3sqktApMzG9LCoQ8cUjZWCv3Tcn1uktsEimoSAHS4U0jGcWZ42tsrQ0oDFSFoioHlFVBUchkyVpNaSxGW5RNvPT6FXqzhhhKFm3Cuw7voes8+7d3uefMEVAeoyLWyKZPS7QzRE0MHvGl5a1p3sDe2p2g0wl6Pc3VmwcsnaNnLe996l7G/QJrFJdu7HNlb8ZDZ7ZRUVNVJSGQvYwWFxR1UiRtuLF7jd07Hb26oGmnvPDF/4LpwQEpniQZSZX3SWj/EClLIQM5BzYJldNkXbR3CWwiYfBRjPAugQ+JLiII3Ux8kuDHiA+gtJCeohJE7Ts1zNt/fONLX+fhpx9iVCeOba9nP8WSwdoIZRPJlfTLkmPntukOJqxvjJjcuIzWLaFZ4OKU3rhPrAxf/9rnKbbOc/HlG1Sj83z643+WRx89g7aa2bRho4ZuWLE2X5BUx7Wbu4TQY7I0HFnv8xc+scUfnDrKf/Yf/x7Pfef38T6homcwWqM/HDHdv01MUBYFqb3Ozq03+PUrL3L63MM8+vA5PvSJ/xFFtYGOUFWWrpnIfStFfGjwVITlAmULtC6AJstsI7ODq4TZZfpWMZ8W1Oce4PUrr3Lj5gWCDyx1yejoSZxztJNL6OIIi+V5FsspdWVZzKZ03VAGcKYihTlKdbzy4rfoFRYVPVZFlFEURUVRGJRrUanlP/nf/m3WNtYYr2/y5GNPc3Bwh+hmgECPUowib0Q20hd35nz92VcY9DR37uwRgpDojDW0y4bxcMjefuRg1tCFxLL11Jsa394hmA32uz7WKIqyYm+/YmN9mTfZicJGqnGL1h3rDDg1augazavXh1y6+RyD3hobG0e5desqnYssuhll2ccow/p4yPraAXQ9ymEk3A6EqOi6iPOJcWFomoa1rT46gvKBGFpcgCNHPPPdip23ar7yYkEw1zhzLnLr+iWGa0dIaFwMaKPF84yoNlrn8DFKJpFXFKUhdoGoBDyk8vwuEjEqQxAA4xOjIZw6bnAPPsZL8Qi3rkzwyUuRXtTY8jTeN8R2hxRbXPKgGwozwNg+qh6gyg1mfsx//Zuf4fb1K/zn/xkMK8XupMMqmC36hNDSBKjJxeo7ioC3/Qghh+ceNlqITSGtHio5rBfxC5GtKjHJFi2xQpXfbW5gZW0AlaRROcxRXeV5GZOtJOJc11phbJGbGcmV1dl7lVKiKIRQqHQipJDhD/KM1kosAGFFhdQ51idbQeR13X2NKSaK7P1a+b8E2Z+H/oc/cyYjk9VF+RpZiYgkw1fd/brZBydfIzdqq7OYayb5ZzmHKtMGDzeP+XxaFCpDQnz2LCg4bEy1lprXIEobpaALPgOGBHaRIhgMlhqtayYx0MVEbAPN3oJe1Sf5VgK8KWi9x7mI0Ymy7FOUInmuciSXkCIjCYdSibq2uA7A4rUFNDG2JCVE7egaUPIZibrDGJXf2xzXlEQmqnXClgqUY7aYYJLsbeJKXac0VW2oe0PxziVN23Y45w4bYbXakGUsP1nNtTrZd2WNspDQWh3an7quO4wr8tkeU5Yl2BITE0XZY+VlWzX7Pnm0VVm5VkBIh2RIZTTGWlrXoo2F6OnaOeKJk5q5c39Em7PVCck5wJgovqeV0hZtUak71MzavCJXSvZhJssdyfJFTMxSRZUD/e6uxI0RXKhQ4YVyJxMKg4qyIm/bjuFaSbUfAYO1MglSNmEKBUkS6GNUKAwqNTi/ILQHGGOFiqMU3bIBEmXboozB6KxZJjB1nkGYEWYdi5hou7zqxzAYWIpSY1RJr1cQ2xZMSXILXOcp+j0UirKA4DWLZUtpS1KSbVP0gYgg21c3Sh0lbDAFgWBE16KqmtRMQPdksxY9thxDuw91D7f0oAucs5joiASCD3liFLOEIWW5oBhbxS+Y30iyyRbBjoo0IBxqe0UOoVBGU5jIkw+fQoSVotnVxlDaEmMK8gKOlQZdG818Hpjcvs2icYxqz515EjhLNEymjayldZEnVgZFCcjFFlMgBtkmGX0XdWutZTzsk1TgxPENlpNdjqyNiEbTG9ZUqmBjaw3jZ5w5tcWxrTHew/kz63RdgkJhtKfrPJHI+lrFq6/DuF8zKgv6ZUXPGlRy+WEh+nCdkmigRT9L57VsGPFYXeCD0H1WU72QfJ405ly5nGm3esdXk0WjIHryFjk/RKIC8w4Q5O0+1tbWKY3lwftOoM0+b1y4yJXLF1mqPhM/5vToOMc2Nzh6ZAs/u8jpM2f53je+QlUULILk54yMwS0XXJ9c5pljRzn/4Q9x/MRDbJzs41KH6Rpu3drl3vM9Ogwliqcf2KCqFdeu3cTExMFUxAjvPztg/O//Lf7dv/YyN65dIgDz+W32dm/gfcJoy/p4jaZ1mOTp2X0mN59FPfgAyg7olxptC1LsWEz2s39TfFsoh2nnEAQ9TYp434INLOcTkSdruRe98vpLLJb7GNtjvLbNPedPsHbqHE+++wN856t/gFITXn3lWc6fP8UGJVprFvMDynqAMTIc2T+4zZXLr7Ler5ks5jK86xLJhEMKbEqJxf4+3f4EdSoy/ug6oEhh/dBDenjF5CFzGjb87pefw5qCxaLJJm1P8IFIYrlY5meJZTqbM1rfJphtXLzOixf3uXlLc0IZNsc93roz59Xveh4627E9jCivmTcOWyQKNefGnZLL04e5Mx8SU8t4c4vi+k0iitZFdqcH9HqBM2ct03nktYun+eoLNxmaHmeO71MYRzN1DNZKuthRDwv6/YLl0hODQ8VIagK3Lu2wfbzPbL9jPl1ghj1u39mT7YJzWG1IIeF9R6+u0TpSF4VIrFB03rJwIlMLIaILK/eatCLO5ZNnNERp3JLqOH9mxHencwb3/hg3n/8GSu1BKlHIc9oOT2GUo1tmGrIuwVbylypZZRi9+OocEx1X5udQbQ3xAsknZq3l0rWSrXnHaKA5tn0Xg/3O8fYdPq4CdXUuXGVgvJIK5mqMFRJ4BQaTf1nJuADS4SYKpAj1QRok8VKRUfUcyokPY35y36aIMnQtCpQSNP2q3iOKHWXVoKy8Zj7JFkzlryt/INMRU2YZ5IfpagCt9ep1iDQyhJjDnkOWDuZaUCmik7ih1c+3er1GmdUpQCIkTFYe3fXbrbZl1hR8v24y5U0+3zfoVnlTJt5+wChU0tjDgbl8f2lAJAoguihDYAUlhewtsl8wIsqdNiZKneiixrWBrmmwMVFrTZvE7xdbh1WaatQnIah/AG0T/dKwCttOOGbTKUYbqrrC5MYxhEhRaAKWGDUpGLm/xI7SaLSGzi0Bh9GFgNFSpKoLRqM+Rzb69PslbbtEJ40OAqhRVkk+DKvsoay6yhEPMcrnNUZhBJDy+0EiBgnwFsCNRBekJL/eOUcIklHbdY6u8ySV8utKpNkiE0fFcuNcBygJFVcaF1dxU5ZePZR6DFEfoDJdVCtiXFCXFUoVGFtk8jiMzB8ZEETBCsuuNFHJTV5u4lEKUGUyEUcyq0B+fxVubHVxOAEwpsiysExszM1bIqIRIIg8HVbr8twYZurN/p0J29trvPjsyxhbYQzSXWtNERPKGpJWh16fxf6c4XqfcrgNRjpmozT1OEv7tKztV0lzCrh95RKjrQ0GtPQ3jrFcNrRdSwigrML2Sgpr0TZRGIOqaozypCUUdQUp4doOdMDYmoTBFtAtF3Rdg64rtK4gQug62qal7A9YLBd4pZjOWqLpsXQVezfnBL/EL5ZsrE24eu0W0Sh86Giuz5nrRD3occ/JEYNhn5Tyajdv58hT51XotXzo9eEaf6WNRieiJxuFyVTOlRdKZWOrBC9bkxtoQ053z822ETklRE5urrGmPdf3OsZFRB/M2d1fgE/UVb4RHBo882sJckGk1f+SxhZWfIlAr46sj8cErzlzfMDlS5qmDWxuWMrSohKcOrHN5HYiho7NraGE4B4TfKtRGrCEqFEqsj0o+cQHHyH6QFVoJm2kXjS4qHFR/JV5xiUAkWgElx9kKlkUcjMNUdyYWjtiCqho8hYwYIyW6VFIhDz9kWmdyAE61+YtZW7ulM4Ez3eOt/N488qrfPO7X2fZLIha88qFm9y4cRNfHkcPDDfcLfziDskaynqdraOnWPjAVq9GpYaQAq5t0RHmLvDt577KYw88xLguqAclaagxw21i0xJdn5NH+pwZb7C1XfLiy6/x//4nvy5N15FHeeDp9/H41gH93jr/+l/56/zn/5f/BO8D8/ntLN9QoCLj0YDF/p5sX4xhf7bPyZPnsEomoFpr9vb2IQXQFh89Xrp/YpgDBTFpCl0KSCd24JayVdGGRIGp1jl29BQHt/exwzV+5Mf/JFCi7QB5SM6ZNyVXr17j/Mc+gY4dqZtTVQNCaBltnOGf/sovolxHKKE2RrZfKqGSJ3q5VoyKdMHRotg8foJ6OKZxQNTyICdDg7IuQ8XEVjmkPxhS2URZliyXCwpjDpHbKQSKokIZQ2gTJ46fwZZHuF09A2ffxaMfe5CDz/99+u4yafMYF151XN111NZDcjTdCGUChdV0seLYuTUeONGjmc5AaboISpeEFLGmIEQYr4352b/wl+mafX71t/4jlouOV14r+MSHHGtHpcAqtWVjXLJ/p2H/dqI/hsWeYbIb2J/BSy+1fOcliyoCsd5gMWsxyeGTJ3kPyhJDR79XQgp07v/D3n8EWZbl6Z3Y76irnvDnMnRE6qws1SVaTwugBw0xhMGGQxBmGMwYNWmGPZfcksYFueB2ZoyLobCBETQAJEAMhkCjG+zq6kbprqrMrFQhMpRrf+KKI7k41z2yhjQaq61yetF52tKiOiw83OO9d+/9i+/7fUOm2WEIwdD5/KzLhNkXcioxytpjys+6SytBRHLtQLH5wX2epW8RNx+B3yCEQroSl0p0tYtLEnSR84hQiBSJvkPSkuwztJU0O9ts7X6Oh/0NVL9D3z2H2GOd4NHzGX96v0OLyMEsbwc+O5/uMVpdDbu5DIu+Yga82J7Jy27ociuRqWFEmWWBL0Ael+uhPCzPcKyczRrE2HAnrgjd2XYBSWTPmQ9ZOtxbhxxzy0QEOTYuV1sqAUGACx6tNQrJCx3l+OfGnzkP/0fQGfnf5/0LKaPROssDR19blktmWZzCcAkqebEh4+r1yY1iHAfXaayTxFXjIITMg/8rz1p+Da82cJeqMDH69se/JyXy5gXIkQLZ/3dZ74aYQKgx7GhUCyVIyY9WiYKUsjctREebAr7SWGdomoawOccGR6EalFJUTUMQkt55khJEESFlNVeha7zzWG8ppUZpje8t3nu00dS1wQ6jz1BmSqFQuSlVRIiOrapiZ3eBD5bNZo0pDFtbM5pJgyaDqVD5dUsxL2x8SiBCzsNEkS7jD0aCeSLh/aX3kKt6Nas8ROYyjH2DIBHGjOGi0ISQo6yqKo2U3Ty4iylDW2JMV6HmocjMAB9GJdxlvRnzptR6l9/ZeAl8Yfw7IqbIgzEhY85Gk1m18LOen0tzNlg7Qjs8w5C1nIUpxgkGI7LdQ5AINWqZBQg8GVAoQYNIiihinhRIxWRSjdu4lBdr6Bfespg3M5c4c/AINMjA6dEZX/zyy3z513+JJ/efXE0sUAVKyCtwhVL5grDLOMod84clgy7EODkaDa0SQOWpUMo/dxcsbn1Gsb2DNoLBFdjQ01loraUqAy4W1I0kDILYdxAUwXdEF/JWRTc454jeZTS9MaNsoCTEHEA92MTJ85ZnDz/gZGU5uLvgwZMzvvDKG9x/smK+M+HmQcXResBtWvqLJdV2RSkSxf4eddKcrB7z8dPAy3cLhq7F+pYUIiJmNO58e5FX0zHCCD95IXlkzAUZmytemHUR+cLqbeTp0XPOzlqUkLxy9wbXDiaIkDBFoio12qhMHcwDe6raUKddlOmYSUFQhpQMfTdQ6YwmlbIgRUf02ZmXoiaOQ5UsSxCosbG/0ncrhRSRa4uKX//6Wwx9x60bO+MdNvAbX73N0dku84mhqTRCFFQFWBdQAqSWeBeYzSpEgi1EbprGnjVKhU9hvKkYBNkbwpCnPFE6hLQURX5QDS4XjojRm0aehlkXCV4whLzBDBF8yuGayWefppFmvOEopMzTRSnDiwfiZ+dTO6vTgcl0gS41j54e8iu/8Dn++fk5PkSSTHgX8VFRNjNk8NRmwtZigfcDymisc7Sbnsm8wSXPMDh+8M4P+e6PfsC9e2/w+bd+iy/ffYvN+pTlyvPVzxd4qTi8sPzR93/Mn/7wA0JKtCcH/HG/5Eu3BP+dtxL3XvoKX/vN3+bf/PN/wtD7ccrJGEQfcTHLaHs70LU9e/t7APQX52xiJlh51yOFIQx9lgmHgAiOFDtOT86Z3ZwQYsS7juvX93n/7Swdr+oaJwTD4Nm+cYDfOA6u7eP6jmjzPTilbOz/7vf+hFmT+LVf+U08mqE7pdSR1dkzfvev/x3+V//L/wUybphvTXl2dIxCoOXYaskcTRFGX+nvXLuHEiVRKNJYwKQkkVcDpKzAKDRM5jNCe3pVPOoiXze9tThraZo5nbOkGKjrirmJnIdd3v32P6Z6/yVuzl7jlw4k69WGB0cdJxtPb9e5ENOZDttai9E1y7Zm3QnabsXQO7rO5eFTtDRFRecjL7/6CndfeoPT43OM2cKbUzrnkAqMERSFxsiCd95e841vSdxQIDSURcHH5xMGGgie0B8xmwa60yO0P0NWDejXSc0uqtrKE/Rxk2iKCdYu0SqOz01FSnbUnUli9OQbms9ytjgWkloRBChR0Ew03YMfIZ78mP1asQo9IWkq2TMMlvOTj9HVAqUbQuxBBGRwFMqjSEgtKGRBjA6hGgKC1fMfIMJobfAeZTQNC6x3HLuKMNg/r8v9L8wxUuUiNF4qgSJJJJLIdOFxHYMQMqt3xqYCkRsgKeRIJh57tjEkLCbLuPe6sqQkEtLkoahCIELO7/SjRxshSFJjEXQpUYXIWDkTY8pb4cvvJRh5BeJKtXLpK3vx60iiRJAhEoo04l+VzMAPOapssn1Aj4j9vERI5HoGMgXwk96y3IzFXPOM8UTpEuB19WfGYfJVc/gJj1l2yY2/F0ap4khqvJJf5tcyXdZco5/qqtkUcfTYCYQaG8VksllozF7yyaOkQp8ckeSMgYplPzCta7ZnFZuuoyo0nR2ISWDjmCWXAoWIqJgQQ0/yOZ8OIRi6ftxMku04Pg+OtZEMg0ebvGQJPqBJ7O3scLC9TVkbkghZkijyZiumSEgyL0xijglS42ftMhw9Bp/HRomrwb+14Up5lbv9ODbl2a6TYg74FpdMBJE/f/Fy1Xil/sr/3kIqUKO8dfROZm/ii6Y/y2sNPl6Gm+eNXUg+9wUpU01TSjjrrpYGPjpCcFmSG3KMwM96fi7NmQuRolCkAG9/cExdG77w6j4SAzL7aC717dYGwIGQuLHx0UoSU57qJlWgyUj9HOoGg/MUyiCQI5ElIWUmvMRxHJF7ioSIgrbfcPT8nDe/9CZ9F7j/8BmlSAzRImVuFEMcuHVwMG574nhDUpA8775/QVEXaCkpjGHTWax1HK8GfvPr18dVWsQ7MKXCX6z51mPHB0c5sC44aG0gCcmNXcuv3Wk4f/iQ6DaUTY2Pgm6zxhjN9kGdbzZCIIVmsF2eXgTF4CLrVY8Hvvybv8vn4opv/+EP2bu+xWLvHGEqXipqbty9xf7+PsRvUtQ194zkg+fwyq0JTVkikuW9D1bMpgY7bDh6dszx8QUCQaUTCEMzmVOUGtKIsReXuXWCJAIijjsiAVKNa+rxRtw7x+/98Q8ZhsCklkyqCY+eH1IVN3jtlds0sy2qqsq+PWmyBNMF1heWzid2TE3ygaqbsruQdIXm4GCOLgq8j7ggsCmHRvpo8WFszJMgJo/RCqmzr1CqOCJWE1pqXrq1TWI+TkES0SmETlzfy4AC5xRdt8bHRKCkEAEtYbluWa07YsxZJjGJ/PUhX5xd15NCQuiATJLZdEoRwfUQgkCKAikS6x4GNxCCYBRjQBJYn+iG/Kvz+WtCyMhaH8n+PzLVzvtMZwwBksiyEi6DRD87n9r5yq//DmcXJ6xOH/Lug8f83u//PipBEgZBiRUa5xXzosa2K4pkuHbzBg/eeRttDKSEdZZFuc+kmLLinNXJM6pmjmhusHf78yANylTMJzXVxJAEPDwO/PgnH/Dxs4/x1uPVF0E/oHF7vPzX3+D04gFf+tpv8Xv/t/8rSSakKsA7KlO8GIZp2KtL9mcNpx//KcqfMr37FURvaS/OidECOSIkxkwIE8ESleXo7IJb10v69hkyeJTSeVBCQhWGYlrx7P6PkDdf5YtvvMXLL9/km9/4AVpGbtx8hRAdmF0mk2s423B+fERRSog5fPTk4Ye89sbnObh2g4cf/YSt7XmmoUmBGyVGRil8JBdTQlBPpyAVfW9pmuoq9iMXiwI5mvkNkZ3dXU7aE4LPhVU3ZCR0ijBYx96NKatnzxBC8Cff/AO+9/1vM916GTP7Iu39P+Y939PqI968u8u/+0uf452Pz/nTnzwgJQjBEYRCSUNAEYNn0yYSeQLd24H93V2WZ8+BXGCsLlZsNo4PPngE5NJNqYQLivffB7zjh+9JPno8x4kKERVCl2SftYBiijIlDBf5g7k+Z15E+rOOePo2u4uGi1gQVxERdR5+ysT21oTgHNYl7EaSokap0ZSfsmdEpMvwJ3lpqc9D0qjY2plg5BlK1ZmWHMcwlQhKS+ZaEXSJHwIei4oWmTLMQGkzZknBenWOqZ8S3QieiBGrK8o0kLzN0JaU/71K1f9NX+Z/4Y4b8gZEqRcbNJ9G4AEvNkiMxS1y9JXHSym+HDc6apQ1jlYFXqDo5bhRSuMkNsfOXKLtx9gjIHqXr00XkDGipRoHBXmLqqTMBHuykkTLF6HTkhey3Ev5YYw+58pClgWKUUoZRuWKEBBz9lkUKSuXRMzeAZ8HFwDG6FFSmIewV378mLdembKc/+2XGWxXaH8hxmFIuooIkCKzDES81ISO5OmQCPEFEt77F7YRLtUyUmVvXBxtJ1xaXVQuyEYQhxc+N9w+4EMgLU9RNUzkjJg8fdfTRsvaDmjnkEpQFQrbr5lVM4Q0OMAJ6GMO6g4jKdvjCTZhVM6o7O2AGYO3QeZcPOeZNIZrOwsWW1MKydj0S8qygpQ9wgowcvQOqlFA6iOqkPlzgyLFyyFSGocCCZ3yvUPmDynxamOb7S05uRsuieIpXmlH8+t9+cdFIkMAFSSB8z6/f2PTHmMYm8T8+Y1hyIMv+cJbaMaGUKTL5i5SNcWLIYEcJZUZ8/lnuk5/Ls2ZMTnXKRHwweMtuGTRUiDTKCkRl6S/y/UkaK3wITEETwqSSW0IYaTaXa7BCdSFISSBFBFixA+J6DyaADZ3rCFG6lLRlIaUPB+9/QF6OuXdj5f8o2+f8eYiUWnDw8MLCnPK0q74H/63/hqVEKOpMl1NHr/z4+csbURJw71bO3xw/wQlI7qa8Btfl2jhSSHinKVe7LL56DGb9ZTl2ZqIY209fsieqFJYzrZKdErcvX2N3kb2rm/j7YzD58959uQZi60ZUhWk0aflXSL5hNKKZlIQfOL86Xt8/8PnPH36AFO8jFCK5flj3njrF7n/3jvMJwZTNFQycBYSW7NIU5Z4O7C1M2EYPEWt0ULjR2SpD9D7hFSRZ8+ec/vO9Sst+aXXLMcTZPBGjkbIkyM5rpuFhE0bGTrHom64vWXY29lBlRWdS1RNQzPdomwMZT3LN2uRV9q71x0X+oh12zL0nrrOMldjFDdv7qEKSYqOIUba1nJ0ckhwAe8TRycbfukX7qJkxHvPpK5QWqKNYN1anDVIPDIlTKF4fjHw6KOnvPLKDaT3CGkIIvF7f/gD/p2vvkoYpyeq1OxuT/jeux/zzgePRnntpYFYjxs7+NrrN5nOqlwMC0GKnsEGrA3EkcZobX4fiRBTGDdeEe8ldsjAEGslg83QjxASNuT8o5Tyil/I/MBTUqD1pRnavdClf3Y+tfPNb3/A3VffwOwuODr7I05WjihL5GxGcJ6q3s5DIgFJalQx4+D6Hd7/0x9cySESCZ00Ozt3mO3c5BHQFBO889x97XMMzlFOGp6fLnn73UNmk4rYaO4/uM/QneEDdGcdxpxz1Flcd4dbN7e5aF9ja3cXf3jIvZfe4PTkkDI5hq7DaMWAZK7hqF3zx//qHxCD4j/+n/9v6VJFUdQ4ByhD0sX4cAeSRENuNM1tgpR4t+GjD36EjwFJGsFJBSIG2otzfvmXvs7hyZp6tscBir/7H/59QvKYyQ4lmiQFRhqkSvkeKhz2+GP+z//gP+fpo/skoO+7cUDHVeEy9O6q+JNSce369TEYdQJiDJ0fi6IQIyFmxYZIgrs3rvP0/T/NtC0pcaPPNpEBApuuQ4lsEPfREYaW5fkDqsUvUzQv0R7+MUMVKBQc7DZ4v6E7b3i2UqyGDtB422EmW9h+SecOcO2AEGAHx+17e7xz/hxtCgYHSMmdWwf8m3/1X6HUCDIJin/1zZs4sweuJwZHKgTGSPzQjduokHOIzB4ohSr3SfEYHxybTuKDpYga3/cYd0HtC1q5yIPQIPkbv7vPh+8v+e4PLrg4k2xaRSwVQuurXCYts5cmhExrVMqgdCIERW0GZtMC20ViVKNvKGVZtoDkB/r2EVqCTgGiQOpcqHjvMwRq3KTG6FBohCxz1IELBK3RBKIfKHWBCyY39p+dT/UEAZi8UUoxZYt5vMygGr1bYwMSyQOQJGLeoomMeRciR1/EcEmAzl+bM8riGHuUqdxyLKq5tEBcBVRDSPnadNaRnCOVGqFGNPxIic6ZaflnFzFvpS4L4ivZ5SdOTGncklxu/cbhg1CE0UuWxozbmEJuelJ+tl7aOS7lbT8Vep3yaxXjC/mnINe0IV6CKfL3y9YPdcVOEEJCtCQ11pvj6yqSQKWf3tQIIUBlL/vlP1yInL8qrvxxuaYedX1ZAjq+DKUxnJxd0D0/wVQOOWmzPYJIlInZpOTkYo3UmtJsYWSJToKqKOm8Y913JJ+oixIhx/cNhfMdNkaMUciYiawiJZR3KAE7O1N2trcotUIScS5kJqBUeXGSRqlqTCSdt6hZ4ikJKaDHHiYrHkYNwGUzHkcwHWm8l1++NFlhNXJrRkUeXDZk44s3LmHy90OMy6J4ybaQV9tNSBlfMsrs5ThMz7nA6epnyjyBRBCeEMYhAhDHCCWRXkBfhHjhy/xZzs+lOUsOztdL9nYm3NifE8k+mygEUmZFoE8he5BGra4xFVonQkgsV45IYjZp8nZMRZTMgXyZTJc3aDlgL2T/hI0UKmJCoEoOU1U00xxW530ibDb8+I++x5MPHqMevcfJco5M+YKfTCRq61UgF9qXgdd5LiF5486C779/QttFTk86rIPdueHl25O8WRIyS0S8QtQzEJ5i+RQ9DBSVpFaWXiXuPz1BilsMd26ztzejKhXt4IhuIFjPYjHj6OiC4+fHXL99HWGAzcDQD2hjEGi8i5wvW1Z9x0Su2Vs0xLSmURXWFLz39rcRSI4fvU8lM/Xnpes7HJ+vmFQeLwL9esnrr97IdJp2IPiA0QKjXL7YpaAweeIaYhgn0pc66DECQIbs+EtqvCoyXOTs4pzBemal4fqiZGvSUJYFTdNQTabEqJjO5xRNgy4alNFIXRK8x40TqSEtGfyK7bnA9YGmKSjripgi1vfc//iQp4dLtmcFCU3bW06XHdZ5tC6x3rNXN0iVDc6bAVbLju3tKZs+slMq3rl/ykcffEzVFGwtsp7aKc3jJ+d837zPzsEON3avUdWa//hv/2q+kSBRGlCJ/OjKNLGccZIg5Z+fmB8yzuXfMybivcAFgQuekEJuZMfVuvVZwqhFRIxXoPA5Bw0pcj5VGGdSKuHHm08M4/RGijGW4rPzaZ6HH/1rfvC9P+Qv/+7f46/97f8p//A/+1+zaiNEi0o9r13bIwnP8vgZ5WxBLKfs3biDSwnXdWzN53jvaVfnnK6/w87eS1y7/QscP/uAYbOm2VpQCk2KA/tbM5brnlU7MKSB50+eEHxPiBUpWuhXmNrwze8+4ZVX9inLCTfuvsr50Sn7e7fY3dujO3nEyfExu/t3mG3PkEf3+Y1f/hWef/g257Lg//l/+T/wC7/7d7k4P6YpNFE5fHuRJcfCoMslUgdmxSnPnr5NoSST6Tbvf/SAtu2o6gbrHGm9wgVH5Tbcu3eLk/MOEHjvKOsGZxOzyRauW2eEvQj4lCfuSZZ4VfHNb34ze92AobdMJg2bzpLGh1t+kOapbFmU3LhxE+cCdnAEFShMSeISlZyfMykl+r7l+sEeg/O44CivJtjZB+OR9L1nVtfsbzX88P5jtBE001309ICLsz/E6CldsJyeX/Cv/+Ab+KR4/fZt3HsnrDtJFAqpGxIGIQMdJVpUEBLeez786CNi8DSNYh3g9OSY+x98F53O8b4HJINPmGZBYgJmiirA+z5LsAqIPuXvIRIpOUSICGUILhdLqx5qUxDCgLcRrQVKaTQiS3VM4vbuOc8enlPWUzadYNkuKQqQIyI8K0ZU9gSJrKDQRX7WWjvw9nv52fz1L3yOd9+/j7sKBfZoI9HK0BR5+EqZPRtucKPsLI0FjUNKQde2yK1tZHIEXZHcJkcJKIHCUUhBaQra7ufHKPvs/H8/Nmafc260MzQmpvAJTxTjNZM3B0mIK5LepRSSdDmwzM1CHnxkOh8iAzWEzEAQ0qXMTLyQFI6eUSEUijyYKYQkkCCFTF8U2UIxUu5fbExSIjh/JYETXMrR8v9Joce6fJSxCXBEtJSjRSA3bnKki5Pcpabl6uQA7BdRA6PSM1vgR699jP4KupOl1aMEctRZZzBKlt2JDGHIdMmQlwBZhigQKeffXubJRRibgsvvPH5voUYwW/5HS9JYr+Uoo0ga5YExS+1CxK3OMG6gbhqCUDApaCZVphUGQegGFvMp7XJNJOGFRMTcdLfrTMVVSueNXogoBMFFQgqUApJtMQRuXL/O9mKRt4lxVBxGgVQSfyklJG/JLl+HbEvKjWoUWerKZbSDzATPGOPohYtXYBrn89YzXPY8SWS70/geyHG5IK5MaXKMM8iD9pwGNX5+lbxqtFPKzT/yxc+b8/0SgnL8cy82pD6FUcX3Qv4qpb7alua/M9eKiZ+9Xvu53AnbfsDHgdVKMJ0WdK2j6x2zSYlU+cVMKWt5hRwnLCnmB2jMNJStSYkpJMkHQCOFQ8gKkfI8RyIJMf9qZERXmomMlFrQSENRGFQp8QHWQ8R5TzCBrZnjyy971j2Edk3b5eyZJDUZw56pZG7wVPmlZ7nueXV3w/32JkcXG24eFCz8I05O65zfIMYGjUASmnr/gDvPfwK3JjSLGa51/NF3P+LZkaOarJmZvIXKDyuI3jJ0PZP5gvmk59nKst54JpWhMBorLCEptFDENDCbl3hr2XQepSVDl4MAj04tvl1y0QfuP3hCkRRzqbFJsBGW6WKP87Mlk62C4OH2wYy+3+TJ5bj6jSKhjWF7fx8psjY2Xk6bGH1eZJ+FiJdAl1H6SGC93OCCoC4rJIo+JA6KKXvzKdOdXZQpmc630c2MotlCVjVIA36gms5p6ilSfICREIYeJSK1yunvPub33Lus1raDZDE3FEaxXvdjXk/EWU8zKdHFhBQdk1nJoyeHHJ4uqcuane0bzCc1Pmje//CIZCIv37zO3s1dClPy4GnHxbBkazJjN87QRiGkRgqNkDZPqdI4oSFvD1PK0ySRMsZbybxJNAkIEesEzjvAI0WiNhCFox+yPNJ5keEmZB12ZjvlB1JM5GI2ZhlHCKN8gxzIfTnN+ex8ukepRIpn/Ot/+Y/4b/+d/xG//tf+u/yX//g/B3tKSp7BnjPZ/SoySZIpkQJOj5/naepYw0gp6F1H09QsDz+gDpZuc8xr1+8gw5oYOiZNhXErPnx4TG8LqKeYmGmxAYlcP8a2hxTmDWx7wHBu2NsuePPLX+Pt7/wxKXh2D3a5GI549swz29plUUu0dDx55/toJZlKz9bNNxC6Qjdznjx5BLbj13/5b1Aoj+1O6bsNgYqb1+/QDRuMNszn+7z0ypscPvoAKUArxdHpIZvVkjdf+TygUDKwPDtEJhDRI0KA4PF+QMdE3/mMKW4qhhjYW9xgutjm7KhDyGx0n9UVq3WXrwckl7RYKaCZ1Ozu7vH8+VH2ABQaibx6WKdR0hhjZOgtWiuUMS/+DimRWhFdysbwKNieG166scU795+yNZ1SNgWHT79LYeY43zHYmqfLga5fsbdY8Hy5xuwsEO05+OwlSG6NmtwgiIbr+zfYubaHS4HT1qGJLLsN1oIbev7T/+R/x1c+/0Veun2XH77zHs3sgD5Ckj2oGUJm/4VMkSQbgj9B6ybvI5LPVGNVEQYojaJzYGQgloq6rojBs7s758mpIAnFwQEsphJTlnTtOSkZHj4wNFXPtCkQaIgDiUgUiSgTpVIoBcOF41tv1/zLP2rBw1tfeJP3P3yKj1neE2Jk6CwpSYL3QML5wKSpiDI/QzMJNOKTzcMk59D1DFkt2Nl/jWFzSHv+iCRyJEv0HpHWFKb8c7ra/+Ic7waULOnbnpRyhI0Ul9FEedvFuNmKRJLKbGdBgU5Fbu7HeKQ4yroE5GGl9xleNRajUeQtTyYSyrxBVTHj/KXB+4AyGiE9fViROqgnE7zPBu/CFMQwSi9HkqdE4J1HKE0SgRRH6XUcNxqRLPVO2cIidZba0iuQipgCRnNVx8UgkUkjUiLFLit7pBwVQ2KEoYkrK4FUuSYNIRfmPsVxmzgu/oPHjBAPIbjarCG52oZdDjBCzFAzJS/jjbIUL9mIGjdDcgyJdiH71LgMdR7x+kLleCdxuSxSkpfffJWPujMuHj8hDWNnq0pSWbJuN2gjqcrx9RIRe/lvGDdcIXiC97k5D36UFnpCdLlxUVCXE3b3b1EbRWUKYko479FSjiCXUVKarhaD+QhBEUdZK7mUUSq//lLrnN0mBSH4LCEdSY9yROZfbmp1uhwkjNLOJLLlZvwcf9KXny7lhaPyKTddecGQly35/WCU84qxzhsDJxAY8hs4fgZG3x+XC4zxvc8AQ4EQY60/Sjn/LIyAn0tzdnS2ZNM79nYFShn6LsvMuExRl0DIORo+CAbvQVhiCPR9ZL5VcbHe8PR4zav3thEuIpRGCVAk3Eg+kVJQCMGirJAxMREBlSIigLTZN+FCxNmIKnIyd1EL3n2qOdi27JYa1XWsg8SeXqBH1h4p37AAEOC6M9rQsC2ecW2RJxRHj5+zCgP8u3dI6pKOlkOiy50dJo3mpjQ8OTzm8OiYhx8cUSMQq45u45htyfGNkghZUTQa7yxGwc6i4Wy5pm62s4HdFCilGYaIMRVdO7A53RBDZN0uCS3UpeL8wSmb4w0sSsqqwDHjpdsTnp1fYJVlIT2t71mUcw7XJ3xwf83tG9sc3Lx9uTMGEoVRaJ0gZS9NJjCOa/5xjjPaz3I+yeWELeYP5mJ7RvCOWhj2phNMIambgtl2w2Rnl3K+oNy6DvUBSTa5wUuewl8wlwU3Y6BQkuPjI843gvPTgXrtObg+Q1Egtcx05tF/5VKGtsiUW97BRkxVU892iKFna77gdHXGrRs7ecmkFHeuT3lnUlAWit3r+xxsT5jVguu3tlmfnXP92gRSiUwlUiW0AggkNFezjwQiCkh6HDaM/5EjAGotMDLSDRnPW+iADxLPSK7yChcSSeasD08OTb/8T5G9Zlrm5kuQsdYuOEqRswAzESryiSzxz86ndJ4/PQOp2HT3eed73+bul15n/9bneH7/Q2QMpP6C1G8yvjes6YcNzx8/vJrCLpdLZpMJ1jqkkrSrFQJLGTwv336Zxx9+G9etODs6ZO/OFyi39qhmE8rpFv/hf//v8+jD9/E28cHjligMX37lHpGeRw/e4dr1G/z2b/w23/tn/wU//NGf8Hr7Ghfnh0hl+PD+u7x2bcosBZqqYlYZPt5obrzyOWxILGZzipc+x+nzh2w1NZvlMUVxHV16pCqQukCNgcLWRW7ee42PP3yHMgaCWbE6ekqMka989Ussl0sOnxzhWouUkXb5DF3Nsf0KU8/oz05HGVz2TAy9Y6I1uzvXOH3+GCEk3r+YPspxAhrG4HYpBDvbezmHJuWoDIFCajnefy+n/fmBXdUNYnXOYrHD4eEzBLnoDG40dJPl8TH0XHQrmrqh7wd0EfnN3/irPI0NT378DdYP/pDTDhamIYSAFpp33vsgN5lIgkuoYg5RELoLVBPYms2z30MlXtqe8nw9EFLi0cPH3NqTfPDjb3NydEjCM5ksaM/6bOQXjhQdpECMw+jp6QmpR8SAiB3STLMMK2QYFUERpaYbOk42A7NSUeiSus4y6dXK8eGjM/avJfb3DKcngo8fFczmkVdfCijpCTGgUsiFERqjNGw83/lB5F//QJNEiY8b+r5nMZ1wvl4BCR8cIaWroG0hQJuMMD/Y22az6bF9T/SXw8hEP7RoF8Bscf70eyR8zpVEZr9TcGAdzeSzzdmnfabTwGymWJ47JJmUbZ1nvRkoCgOErFIKgaqowQh6byFZZEiIIChrwzAMGakuDXlD5XKzpSRaaVKEzlmUzhLI7Gf0RBnwacBUE6x37B80CCo2m3MCoItEcmNGazSjB00wqSu0VDRVzcVyAKNZrdeZVxA1zoMXEV3oK+/PdF7Rri/wNiJSSVlO81ao82NzJphOJri+y776CFHovHka70cxBrTR5GVaQviI1iqHIZuKEES2ekjGLF5FSCN2P3E1wBCQidcx5QZNKoJPaJnzv/IXjFLGUTGWARi5kTH6EkmfJ38heIQa/aMxobXOzVFd8cqbr7OY1vzBP/6/U9iA7x0Bx871a5xYR7teUyhDURTIwTOfVwgBQ++I3qOFQmiDTyn781JuVGuhwFtUhFJpJvWEUr8YXAuRm9kcOzB6DT9Bs7wEyqQRpIESY3RKJr2mKFCy4DKWijQSqlV+PbOnT/LC5yev6tU8wU457/ETIBYud6pKXIE55JiLF0dlGOkSCpLjkGLKm98XQBg/gmK48jhe9sIvGq8X27E45vy9CGn/2a/Tn08ItZScXTi254lJKZnuVyDAR4G5TFlHkpAsVz0uDlgHEcG0kpSF5snjDaebnrt3t1A+MaYI4LjUHZMnL/m2jiZhY6CSgkJEtMxIYJUCKvpxO+pJVpNmnkdHS0Rvae6V7Ewkz1OBk5JagpJ6BIXkF1J1a8Bx8viUpU3IZs6264hDhReSMqZ8Uelx81HMaPZ2WD064umD53zz3RVv7nuehglbWw2EPm9EiEDIAdVDlgLFBGWpcOct7bqnLBuiygCK0Pecnix59Pgpn/vqb3BrXvIv//m/4Ku/8ossj07pYsn1NxRNU7GztaALUDcC/URxTU8hWqZ7O0y2Zlwvcn5HVRrKvXJc+2aZ52WQIyIQk72aDlzKG/MHWOUARpUlClFGrI+ECMYYZosd2lWHKkp0CeW0Ybo9Z7q/g57uweQuyMm4xM5r+VSUFAvY8pZ+teR8vUQZTaEcy2WP0gKpE0UBk7LK+RwiG5e3Zg0uRC42LZtNy/HJOW/c/hwpOqazLdxixqaTbM81R6drht5TllOStBwfr5mXilXXQVKIpHn+bMm969ep60z8TFGM27FxMh9fqJhzozbq1XO7Ot48JRKFFomkE9FrogiU4xZw8CFLMiJX13GGDDBKSvPGLOR7NyIl7j8841f39vM0DxAoUpI/RZH67Hw6p7c256tIwQ++9w3uvnGbV27f4ouvfo2dm3eYSIdOFqWmrFfHuCi5fvsVfvy9b13pg+JoIC/KirZt6TcbWuf5g2/8UyaNh6Lk2o030ZOGojD4bokOA2WAV2/fg+j5hS9MR+O9wZQlwcHz588odm+zuHaDBycniNDTdY7t7T3eeus1Du+/y6RSDMEzTN/gr/+d/xmrjaVfHrN0HbVKTBrDsH7OsLmgmOwQSMymU5LrMiIYgfOW+XyO0YppMeFkfYHAURSG1159nfOTU/p+IMRMSbs4fcZsCwazoJIFspkSuxXaFISYpdEpRq5dv8aDD0yeohY13joKPcZTKLIfQYBPiTt379A0NUprjDFobQB+ajp6GZirRxDF9s7O6BHNkSlxbPRIihAcgy94fhqQOKzrWZ4+5S9Nvsn/5p/+iDbz+umGwP5kSkzw9vvv4QMYmX1qspwjijkxdhA1627DT955j7Iosn8mBEoFlSyYbS2YVyvazRlG5k3C2ckzYtAIMk5cSH3lvVCknDsZelIMoEqEt6Q4ZP+GUFlJkqASOdhXSYl1FucLpDIsplsMqaQoD6mK3PyGFHn7ncjBXmJSJ7S5pL5l1LQUgsF6fvhgnkmxukKlAddb2q4lRI8AyiK/xn1nKYqCojBICS/fuYEUmh8dvpdDimVujEGAqfDlFkqZ7HWyEVNoUgw4nyfVAslms/lzutr/4pz15iln54/QQqOFYjqZYPuOFByFmTLYAWUkPvX0w5LSNHjfIZJif+dGlg/7DZos67PDMhfFBWid1Uu9DdkKoDOOnJADkmd1iZKJznuk7FEmYoyGlCjLmqJu6NoN29tTkvd06zWTuqYqK6IbSCFlZX9smc40zm3YbNb0LrKzex3nPW235N5Lr5JInJ4eURpLU0vA4dxpJiCabBOIMeCjBekoixqjGtqhY/CeoiooyoKEGiXTHeoqyHiDNIogAi7F7LdMGuHl2PS5K2x/brbICwolSD6gdUka80tjyDI9lVHYLzZr0ef7l1B5GDvK7eRIwuRS0h0FSki01hzcvM6de3eJKbLz0l1e/8Wv8cG//R7OB5r5lOAGxPmamghSst6saKuaugWtBFJptBYQBLF3ecESIlpICm1Irgfv2NnbYTGfURSalDwoiRmbo+hD3jSO6h45Nida6yvJbBilrhJBipHgw2W0HEpx1ShlIEfIA9Ar1ai4+vUq6BzGrdgLL/KLk35as0rCucBVLMKofhIib0dzw5UXFzG9yFm+PGKU3MaRrMmlT1DkuAZIo2dttEulnAv3s56fS3N2Y3/B/ccrBpeyFn1cB8aQ8D6H9TJKttrBUxQC53uOLzzNjW2cCyTlmVbZkPnR4yPaPvI3/tIXidFjh9wUlIqMTkbgB0fwA5vNBhUFRaGgUKxtwiYop4JCa3yMhNQhJwVJaN5/KDG3bvG1/Y4yWUCRyYt2JAyB6FoOHx2yiSWfvzXh+dEx523kcfKkNMpAkh9JLFlxXU13KPQRwkU8gigKVCFAFxQxr2eTy/4kqRVGNKwvVkTyDU3JxHLZc3B9h1J4nPVUpaEbWnRR8vyjH/BcVuwvJgxnRwyDpW40ulDU9YTFzg7tw0ekZorQFWVVEIeW+bRke2tG37aUZZ5CuFHWiDCjJEhmnLLIiPx0KcvK67HRuMr4gRwD92JiNq1oXr5F1ZS0XeKZzwQdUzYUo+es3tpHTW+CmF1pe19cKQahdlDlIaaZ568rK3ThkUPi6LRjMhPMplPqekL0lhQFQQSkgI0VqBAxCj768Clv/toCHRJ/8z/4a7h+gzQVm7PnHD34gHbTcff2zSv4QRjNxG+8PiJ2haRUChfzhszHLCcKYyOUPmEKvQw2zM2rom0tJ+cXLJLA+pBv+inix0wMkSK9lUTyZo0oCCp3YX7MOxGXygmRqY4ySlQSfPVzt7l3a86D9y7yDy7T2A5+1px92sfHQFWVeOs5b+/z/NHHbJUB4iHudI3Z2uX4+RJkjah30U3NdL7Nzs4+p8eHhOAxJoc6z5omBxNfnOOc5+nRY/7Fv/xn/NW/8XdJekLV7GCqCa5s6PuOix5UEOhihut19nhVht35FrLawvEMb+H2q18CM+PaYs5rr79KipZvfefbtJsV92NkZQP/0W/+FqqpiE6Qeks93cW354SLI9rVKc4NeFFQVTXJWy7XslJIRIrcuv4Se1sLTtcdne1pe0tTNlTVlKOz80wRdQ7rexCahMIOHbpoQCtEUVKUNVJYkssehq3tPZQSWJtoU4/GsL894+nZGqkkpsgG/sJo3nztDrPZjK3FFk+fHF7BQASZlhVjuPK+iDFjc2dn78p3oJQaJZkapCD4iJJQaUXXW7SusH7D/UePGLxAFlNEdIT+lA+eHeUiiew7da7HlDOkmowDwBYb5rTrhLoeMaYkRc/9leXaTBPbSNte8PDijLp8sW13fgPUubCJCUmBDxFVLEh+lQdiI+ZeiXzPU0KjVeR//O//Kt/69tt88PSQlGDeaJbryJe+cIfqrODJ02ccHT6iNAtUoVGyo7NxlHMpTo8izU2beyat0TGhbKQ7Gzi7mHF4UebPgIL9nYaPPnif04slJIHSMJvNOLtYZb+GFGzWa5ppzbRU/OjdB9n0H3KzrmSWmHo9RYfAL28PnEbDD04sPiS0rjMNz/cIGMN7Pzuf5ulagVYlPnoijg3rTCH2PW2bSFJiyhrbp0yf7ltAURSGGAa8H1htTimKPOT94uff5PDZIat+hQsBo4osZ5MR8BgtCQK8HQhITKEhaKyNectS5o2GTStUDCQcqy6ihMYBfXdOJSu6zcB0Muf8osVozenyEOvW1JXEmIq+WyNKg2kMp6tj2k2HdwElFdPCAI42rEf/kSEmxfZiQd9eUBQCb5dEv0Hrkt51DDaAqgnkHiWKnI9clgVRWCADFbz2WBcpZE2Mue40MlEWJcknfB9QSmFjYPCJwpQEItpkWacwEJNjiB4li5w5mMYstZC3UCmNdEYMWuRIKlKWZCIkQkp29ndZ7Cw4PTtls1qDjLz6xbdoNz0P7j/ANA168MyWG6K3RKUwZUUXFGs3JUhPUVoKBdgeJQU2BIyqCRZCtJAcBwfbXD/YRWmFj3mQRcxeVq10fr1ieCF3FZd5uLzYcik1WoNecB+Qo8/rE52UFHoE0Y3NWhozLYUkY+3D2EjlhvWTTdCL7dmLr01pzI0DriiPjLJdlX++LKvUV2ASKWVWGVx9nfhEY8i4jRtJoOMRVzEM40hf/Dl5zh49P8uqzDFZXGuFVIwZNXlFDHkLokWiriqqumI6tcyniuWyZ3te8fTQUZlsLB/GMCuBwA4t62WL1lAXBbH0DBdLVqcXuI2lqkpUrdHVBFVpVKGpiyyxLKuCvbpEzSR9PaEYSqbpgg+WM75CATJPM0AhpAIhObh3i/n+NvVujVwHbt25zrGVfK6eoKUfjYWKFNzVGrqcT9FK8/lXt/ilv/Lr1E2V87ZSZP30OUImepuX28KUSCGY7xb0XUtMnsXuFu++8zFVKZhvTVAaamEQow7YucBsKnBC8/z4iPPTC7o+8dYbt0hx4PzoOdN5SUyBaW3ohg1NUxM3ludPH4/EoIxPlmPwaJYiMEJBxkyIlLO4JCqHfyc5aocZhzXpqqGb1Ao1r/E+0p11uJAYEBhT0MxmTPbuUu28CWp33OuKqwsvXSp2hUHqAl0oTKEwQqJG+WQfEuvlGETrIzENWU8sPEbWKB0okqDWBh8TybXEMWcDoXDdEtu2qEJRRo1wo1E9BmQQV5hcH/JavrVjtgYiy3VIY57LZXpFIMVcDHJFbxK8+5PHfPT4glu7AyJZnI95KOAVCZW3ZSnk5pfLrXweVuT/xvdBiBFnHYkkQlTMp5NcK4tIFAoVE8iCJPzP49L97Pz/OErkIHc7DNzbX/Dw/R+xuz/hxrU7DNJQ1BOihBA1hahz8DOC54dPyQ+EhHOWGBJHR8fs33uNpdGEjx8jhKAbWtTkBvNrdxFG08y3sCHS+sDW3oTzw0PqaoIsa2QMeOsRWmLKKeWk4fz0iL/3H/19Hi4v+JPf+yc8+eHv8+FH99l0lt56hhAQSvP2T+7z8ptfREuFnOzg7RLT7OT7WLfh2Yc/5O4bX8Mun6PmN9GjhPx8teLhk45bOyU6wdnpcxIik0OVJhLZbFboWOXtTrLEFFmvTlgUFW6oEKFAVRNiHIAw6u9hUtZIBGVp8udeKw4WU07XXZaza0VMmSa3u38LAOvsVdj85QM5P3yzvyOR/bM7uztsn28zqUrAj9IhlWXRMQ/1npxsOHAD82lN2w9IU/FfPr5F0s8gdnlgUs7QMpHsOgcto0CUIMsMgwstWhek4JhVFU/u/wRv85bQDo7TLnFzb5vV2SmdSNy+do2T9TFIQakFvR24lDsJYTIZN3YEuwJApkhEI0KexiIjhYL9RUIxEEhMqpLVEIgSXtoq+Dd//DZ98Lx0MOWVg2scrnsWzYbeBZRILCaS7kTQNRCNZu0Uy3Wks7DpKt79KBHQRBzeBSTw/v0nDMEhgUkzpSgqhuEYmSSOHBkzn1S89+F9OuuIKSFSJAh445VtJtUe33kcke4Cw5JJMUBMKKNzBhAS6zMs7DNa46d/tqZTlJGsNxfZ+y8dkUAwkZAGJIZk+4zOlxEhA2VZocjRNcokpAkMbo1MktXqhBBbYujxAaq6vMqkkhKS8yhhUEXB4Dw22VxbxIQpcw6eVBFtNO0wEEPCuYjRI0QDQzsEyrohpEQUniEGhmGAGCnLmoBitthhiD22H7hYX+CHDOSQSeHPewozDnWExrnAYjZns14yuBYf88M4xuwntSIj/vH5PqOEYj6dZbmaFLjBE4MgeIv3LsstS4PRmqZW9P2Ki+UhSuoRbiJpmgmxd4TUUlU1xpT4rifJSN+vGYYBpQxFMUFJiZIjoC1mX9/gA1pPSClRGcPQO6QwtDaxNd/j8OyQDx49QJkSrQqMcriu485bL/Pal1/l6OSIx+/eJ8QeFQaEEGhvSf6C5GZIUxKsQE4maFNDCrgQUNojlaSpKxZbB2zNp0gZCVdZc2PTFDL4KXv9Lonfo+roqjnKv4/M7IYctzEqlEIO8VZjLAJkuXqOQxBX2XqXaghBps4iLrdpn5QyMn79i+/5Qlqp4CrKO419xos/q5S+AoZcNmtCjNl6OTSZFzEJ+eeMMVtZXmz14DKSIv0Z+QA/l+bs2bOOSakQMeaJqZiipKTUuSPurGToBwpdYArBdFJgXaI2efI22J47t/d56aYhJri2P4WTfnwAB7ztsc4xeMemXfPcblg9X7FerWmaEm09u5MDFk1DWdco7TFlhZSGl2+9xN0bd5Fa5ime0CBBKzmSJAtAo9Ro3lSSX/xLXyWQMlpWAEKjUvZX+eBytgEGrVRGqOqc4TP0LTEEarfi9Ccf4lTDF37hVYamxsjE0HliCAQ/FvwpoquaGKFmQKiEUJea3DxNmTQ1s+kEoxTvPz5n0wasC3SDRMfEo4dPaHsJPfQqS1UGD7NmQ6ECh6sKryoM8Ll7WyMulixDSHr0lkFKPmt8Ixl9K0YQyLjVQY77miiutpdBSh4/ueD+gyP8ANuzBgTcfeUW9z7/RcytXwZ1kD+sY9NztYFO448hJEKafFGicuMySmAvv66qDdJDFDJr/kTOs6irkkonqkIxm1fgBnyM+GFFv1rTtku61Yqh6xn6gHOZVJlEbpaCy5rgHBI4Gk5HV20c895QCikjoMfhx6UGPF/IIXo2Q2SruvS/6FGGOybNx8hYWhFHeUOm92bdtCBhtMT7OIa1i/y5k6BEvjnFKKjqOcynnG8szkXc8GfDs352/v8/hYRGFbx874AbuxOOVj22LVmfPabZvkYUE1Q5xXYeRCLFntVqSVnkBoJxC6u0pO8HDp8+ZDYpMXXNr/7WX6epF+zfeBlpMjFPiIAOibKuIUaa7QVh06KMJoVIVZZIIenblvliTrO14J33HvN//Cf/iJMf/ROi3ZDIBNGiMNSyRCTJa6/ewXpL33mkSWihcOvneNsTU6D3gbPDj6iaBVUYxutRMbgESmJFw523vs6D42cA1E3JfDLPkslNTx8u0NV2lqh1K2w3sLt3j2DXKLFNcg7vNvkhqGtIMC8LXrlxgFIyB8sqwc6k5Ovzl1gvN0h5KYMRvPX66wiRGOwoFUqXtK3xjRIJUFlaJKFuptzYP+CN2/s5lFTI7EuWmeaah3EJRaIqDaebASFKTub34Ow5OdpHI1N+CkxmU25d3+HswvJs6cdg2ERSBhk9yh/RlJJ5XbM9uQFCsBl6vPVEAjvzirazfPfHH7NxjkJJfIwIHCkMoASBQBQR0S/JQbg9KdXjTCuRwoBA4oTin37zbT462rBxgsVMM59NqU3k/PSU5XpJ11se+jX/xb96i49Pv8i+/Q4inTKkxLOzyOG55k/eOyAkh7XrcdhYonWT4QoFSGkgZPN/7zIQQGtNVVSkENC6oJAK1SgmZcG1rQXvPlhlGl6ulkgicXR8zlO3opx/nkTFd54FurVDCUUUBaYs6ddPMEKPRv/Pzqd9tG7zFkjmgarwiuChLKb42JNCD74d5XseERKbdc5FXSnNnXs30L7BxxXOdXz89AFlUWNH2XK7XqOVwkwKXLsmDpbF/oykJCdnpzkjKgoUimlRs96s6WyLSQpjKnyKKJN96c45QoRaNzR1Q7de022WaKUoygphSs43FyA1fQggA55NtqMaTyFrhE/4YEmiwLncbAgZ6NwxpjLZy60USDEi3FuS9PiQ8F1PXZaEkIAc12G0oTIa11tMVJgAYXAoZVE1uH5DtDlawyVPJCJCoqgrHJZ+PRDaDkRAKsnQ5iH/tNIQPDJsaOop+3t79HbD8ckRwQu2pnMO9hZsNhckYVmePEMkhVQzop+wvXON6WSH5bqj7y0mBOxmgwgD871d3nrtZb7w2stcnF7w7MEDnn70kNOTU4p1T0WHXUEvC9brkunODskFCgOTiWFrNmM6mVEXVYYxkUDF7OdNHm3Ui2Ym2is7TIxXjq9MCB29Mv7SL5ZEDo3OvJQxD3lkG14uBRC5Vhp/XyAIY/DzZTMWx2VOJmeOtfxYo13i7K/Im59ovC53dYlRfsnY6PmA0RolFX3XjZFG8Uo2eblsgMsYhHj1/S5/JjX65MRYx/3M1+mf6er+r52ySoQgeXrSUVXb+FXLZGqYymkuBpTAikQSCVNUSKWQTmCMxoVAVSjOz1eU+3OUMuxuL9jb0RAEdghIXTKdQrdJrDfHnDw94/QwsLVQyLKgmZUYrRDJEYLM04rR0IeI6PHNkkKBTGPA9WX+QParBWtR5D9Pdg5lEKuwo/kwQxhy7R6zR1VXxL7Fh8Dy4wdYa4le0F9ccHR8zNBbiu6I+f4dBqXohjXBw2JnF20S3ufufbB5mjzf2iKJghhy01CYgpvXD+j6nvsPD/mTb/wEZQxqWiPVnF+917KTVhy6GTs3K77/6IyDrRldhE1rWWxbpEss5nPW6w0ffPic1169iRIyJ80DQl5+yMOVKTJd4maTJNO8RlqjHBPahUGmxOFxy7e+8z5a5OYoyAGl5sxmU9RkSpLTLBVNl47IxE8PNgQiWYIfsgwm+jwdURGpIjLlYqqealKbZVbB5Uk4QbE9KdBaMK8E2wc7qOkNVBIkOSX6Y+hapNKooqSQERUM3lqCszBk/H2IOaclhkA/2BwDEbOcIEWBj4KUPDGJnFofBSFlM70PkRAi21sVL+/fQj6+wPX5QRBTfFFshEQMYkTo5rw/KXKTiMzNmhJZNoEQWbYYsh8xJcGjj4/4gz95xoPnLb2zOB8I4bPN2ad9mnqLr37pK5lQZS/YmWs23oCU+OURVmnqajrm7XiCs0yLms/duYFWl3r7HFR81rYsNy03FiXTVw8YDt9l994voqtMJjRKE10ApZHRYPsLDIE2WGjPCFEz3S6wridGRbs8pZ5UfPTkHZ6+82+o7IY713fxvefNN2+SYsxFRFFy72CCkBVSDSTX4VJEywJMpCg024sthKxRxRbBB2RRIaRnPp/iXGLTbrh9+yX+vd/4BWRyGKWZbd9GotGqZAg9ybY415FG2dPQXzCZX8uXve8RwmOjopI5KPuNu9vs/6XPQ8gezELmJkCXBSF4nPPMmymqKLj30k0SOUNMCDGSwD4hk4l5Qpvl/wmjDXvbO/x7f/lLiBSojCY6P/rdPD74LBUk4V1EmUgMFf/s3Q9x4SHENUKQA++j5z/4rS9zb3+Hiz7wv/9n77AaLIUUGNFTSo8i8datW3z1c2/gQs5nG2y+h8Y4QhBI9JuBf/v+Md/44YcZphECUlqEqki+Q2SrBzLm4Q6AkIpLnLMkUQnFw8crpJRMSsXJZsAlwaLR/P73HzJvDE2pEVLwzukB1he403cwOhFcixSJSEFSBkJEkP0+UsgrX1outiZIEbkk1mkUxgimU03fDnzp5TnLTrLqLPvbUx59/JQYAppRCSA1IsDX3rzD+UXHR2mbvp6yShqP+UTeU4GSJUln0NR/7QHx2fkUzmpzgROezg/EAJqS6CS99yAdQuaMKqNLtFEgsvpDKsHgO+4/fkgcAT7BJ7rYU6YMptBkNL5KAdGvaQrJkAo2/RoXPcH1pEFwY/8Wi2ZBt2qpm21O2sB63SJqSVU1OGdZr1eYoiTIxHroGZylVIL5YkbynhQycl8WCqUUwbZM6i1E0vjYQ+ZNUJUG6jkuSgQrRAxUpSTGgehCbkZlQVVMGQaHjJJC17gIgYBIkiENeN8R1o6mqBAB+t4i6hppDEYLpNHEGIgBlps1QlV03cCdO7dYnx5zfHpG9KCTQQAh5rpCFonostw5ekdK4KRktdoQY6DdeKTWbLqeo+Mjum6FVIrpdBs3JIpyi73dA4yeEDDsbjfYweLckt7l9/i07aDU1HVBtT/n9f2v8vqXv8KD9z/iw/feZ/XsMbpvKYJHRsmNuuLp6WOqvQm7OxOKskAIi3MOiUQogwseZB5ERp9Izma6Ill54UNAq2L0yOdaKysiYg6tzva8HH0gcmeULUPZD6dkXiRoofPWSonx75f46HP2XsgNLlnMhOQSwe9+ClIiRo/YVfMk8v3nctOV78X5/x/3adn3FgNKqJw/LHJ8g9JFDnHXBSTFC4L3JbUxXTVycPms+nOSNW6soi4SELh+UPH44w1dm3PIyspQaIWV+SKvC5lfaARKCWIS1LXi+KynLiXz+Q5VrVBCMbiWwVusG+j7Ff1moFv2bM4sKnlEKihEokwCnRxuyJjlEAWHz54i5VHW7XoBetS/xnFNOtJiApFoN2wvprz97e+CzDQvqYvRYK5BKZLPMg+hsiEw2EhxfcLHHz0ltGuCdQxDZLcpqYsCIwuGsEI6TxxaNkrgXA64886OjU+iazdIpbEhU/rOL5ZUakaM4G2kaz3ODbz8yqv8vbtv8r3vfIu/8bf/B9x/9wdsVhc8P35Is7dLc3Cb2/XbuKFjrhO6ukO9s8+ef4a1lv2poSzq3JSSqbBCfFKvq8aYg9xEXz4o8yYrjAsviSB/UBWRjz9+DtExSMEkBkpl2FvUHJ5bDqYvI0MghGOkKUnMfkqTeykUFH7FsFnStw7rHDEIRNKE0BJjQChJQuVctjIjo2s90BSa3/ydv83q4gnPHr7D/sFdRPMmQmrqiYfyPTQWXVQU3cAwnNKte5KLuJjX9d56fAh4nzeaPoYX262UDbkhxtygxpH6FrLUIERywLQQlCrk1yWlUQKqshl6JKJJORpf0yhTGHGrntyYXU6I0ijNEhKETugAtg/88Y/PeftjB0nnaV58EU752fn0zt58yvHZc67deBmpBevBoVOiLmqCFPTrJUIco8odgndIIi8d3OCN3/gyRnnsYNne2sJGzw8fPOHtHz7jb/7qm5RFnr6m5hqxt6itAilgsBkIlEdGAd9uMIXBrs+ZzHbYrM6AGWU9wyVF6QLtZsnL17dolGbSLnnlzWtcf3k7y/9GSUbypzjfXQ2WpCpIIlOvalbMZyUbK4gCBruhLg1KGXamJY+OzplNZxjj+dzt3Vy8oTi49zkebYZMvRIV0gjiECAqpvMZx4f3aeY3EONGMQqJ9ZLUbWiaBikS0zJ7U0JMFCox03OaKvsousEiZUIXFdNmAUlih2HMH5JXmUDiE4HUY4uGEBpTGOaTBdqv8kNfZYlyDJKEwUiJF3lL7aMnOM/f+vyGf/jwgnNvIQiEcMxqyf6iJsrE7lzzN3/1Dv/kX3+b+hLBlRSRiNQZ/RyCyNEYSqKNwnsISZG8Z2d3ztfkhG/+8COsD1RVAVJnKRABIUyWLIf8fMj95iiVieBT5Fe/fJMvvXqAsxEbBErGUU6lEFIyDJaEpE8T/tHFr3Nx/32OwwRhGoRY4cKAQqGV5GBnwoPH2U+UheQKqQ3BOxJrFosJW8XAcQJjEl9+7TrCJ9ZaZp+uX7MzrTk9PGdjHZmEmW0LIXq8EvzBdx6wtyiR5RP82T+lEBf4FJBEpBd5PZ0cRgki8kq69Nn59I5XEpsEuqjwg0cLg1EKFzqqSo7NQUKphC4b1puBxWKbruuJ0UOIVLrAhgpTNLjQ45MnCkehEyYV+NZSq4JN2xOEoFCG9coxrxZMigaCwEeLjRt88BRlQyMq+sGPuH0wRjObViSR7QGuz4Cc/d09Tk+OWIeBFAxabUEMTCqoS4FfO1zMtMi1s3TCUtaRqphQ64LoHRNRoI1BSYOeBqxvuViuCDZv95Vp0IXEuYGiFKSNo19bUog0Vc329jbdpmUZPQmYmIJNt6aclEitGbSiSJoqSdbPWpKsScHSti2l8kQhMUVF1wZMpVEyUlUVQXqMkPiUODx7TooCGxO+b6llGGmNI0/BSaSq2Tu4y87eTZRuaDvLxfoCDBRqgtYV3vUcH18QXOTgYBdjBBhFEJFqsc3nvv51Lk5e4uGP3uHJ02dMduZ0wwZdwP61OdYv6e05ZVEwKSsEimgFznlizMqnkJ0kOZ9RKLQyOJsAi5AKdTmsJCFizAMoZ7ExoYssiMr5cWmMbcpWqBSyPDoJctDzSOWNKeV4lMCYOyvRl5uqlLdWl6j7F763sYGTWRH2yV2W/IRcUcjMTnDEHL2gwJOIKFJMSB/ROoOftBy3iON/IeThvlLqExLHP0dZY1HU2KFle6ug6wYiDhL46EiiyJlRqkAIwXpjmZs82cuvkGQ+nXF+fkzXexZbauxOIfhI3w1sNuesz9ZszjfY5QYZPWUhiH2iby1FUaF6i05grMAUGqNyM1aUJUqqPDkMDoVBiEyHsW1AG9CLbeaLOUVR4YaWpi4IQpPz9DRFM4XgsX2H1IYYHK7vgUiYFfSzW8zVmu9//DGVCmzJBdPZhM3FCc4PGJGotrfoNxbneqw9wQ2SopmgtcD1HSlJqkJzuuqJIeONw4gRrasKoyNPHj/g7rU9htP72PUR68NnTKqCWvfcf+/77O7MSRODVAJ1vmJ/3nBxrJjvNJhmQuizl+JyKkvK2yGuFluXfitGc2aOP8jhyXmtH8dGTWg4P2txViD1wOAlhdQkpdHR0Z8tkcoRVx9S715Hzu6SmINQ4yI5QOzx3Sl2s6Rt12zaHjv0+KEnOMfgM0glbjLxyQ2b/HOaSIXGlHOa8pC9nW12rl0HqXLTKzS6mrN1+00WEdywxC6PGJandJtz+q6lb3vatmcYhvEmA9YNOax2vGqdc6QUCCmOG8XL8i/mxlFEpNAMfeIH33+X13XgsmYLyefJ4rj9SymOmSYQoiCEce2fRi/eeANC5BtSSnkidbbsef/hgJYlPmQppKTIYbWfnU/1XJuXfPkLMw7X5zxdwuAF27vXMNMS6QAzI0SDwY2gIJgaqCaK5CJF05CSp9IJFT2/9NY9Jo3C6JxpFWSktwN2GNBaXFFRtdYjUCFSFRWbrkNMHUNvUVJRFRWRiO08f/13/jLdw2/zi6/eI7YtXnp8yAMmY3LeyvHZU37v39zHOpsLlGaL/d1d9maae9Nj9P4+7330nGH1jKqe0vWCydYBCMEXXn2dh08+5KN3/oSbb1T0IW+vqbex5x0x5ZFNdJ7gHNqUlE1DP3j69pTZ1k0Skscnax4+fc72tKKZvMFMJkStGGxEZzAWIllSyHlFSuZJvYsSaTJa2TmL0npEUef3yHtHIqKlyQCCZLJcXJV0siL4YwpT4YJEJoUpBc66PMENER8SQmbT+WxaMp9VnG/seM3D7l7D1qzJG7AYeO3Wgr3tkuVy+Cmccl3XJJVzM10ARtx+jBkTXVQF0mj2tgO/+ytf5b/6o3/L4AKellGyMcrZMzkMEYnJj9S2nCn1hZcO2GoGTs/XpBSoyoIUoB8CKeqx6JDUJhOQ9z/4Fzx98CNEDERdZXm+cAih2JmVvHmz4eFTfQW5UiLLGaVOCCWpTUFdzYjiiDt7FX/pF+4QQ2C2f4cUDN/5/rt8990Pudh0pJjYn1f80pdeZlYVWc4dsk92vW6xIQAXPHl+wUcXGZkuhKaMgnu3G3xM+Cg4PvmM1vhpH6Uk0UlCyuRPIxXVVeGrEVKjgkJ5RaULlu0GM4VN37JVVhglqKcNzkeKeoYQAtv2BB0Y/BrrLWIq2T24izpdYkxkNp2hh2f0dqDXgps7NzlfXnDerRnsgNE5325SaWwY8lYKwfL0Aq0qClNQFRqkwnYOkQSVFrkZSAKla4pCc7w5xiVHoSZIWRNVgVCRiGfdnlFSUJka5QvKYoJAMLQXeJHASbbMFFUVJAl1VWC7hHUtZRIs6gVFWeQcRQJNbZiZmnazIcRIiWKqa5Q0iKkkWjBFwWK2zXyxy6pb8/HTh6TQ0zQlXedw1rKotogxUKuKVERs3yGSR6OYbM24WK+xPt8HrO2ZNnNSVNTVjKZZUFVTYhJsVkts8CSZidYqJYpCsb21h5Z54D60llBlHgMCjJHYweGbkp3Pv0naXeDDQHQtB02NFitcygPt1Gt2m2u4Tcd6vSaGnEknsXSrFarKnAVVFhgV8KKntx4hFTqqnCMmFUoISpHDtkPunHKa7gg+ESlRSoXRCmmg8zm6I4wJ1lnWmBcdMcZx0ZAIPmT10aU3TTJKrDORnHGjlyMSTKbPyhfPEnG5vUtptN+I7HFMCURCaYlzHiHUmK0nSMGNm748RAuXvrVPXG9XVMef8fx8mjMVaIWjLg2HRxckNN5lyUwYC/405mXVEw1JEFL2GAWRtb3WJ84uBm5ejyN0QWZsu/dcHG/oVz3L8x4VwAZJ9GNmgkuowaEayWQyhbHIMWVBVefGTIqIJssSjTEslz1dZ0lEvAUZe3RZImVuCgcfKcpMaCmb+spDpI0mpZyBFYoKISUNJRfP11htkYlM4xocacyr8VYQ3IDbWESwKClxvWVSTYje52ZCSqSQNHXJ0ekKaz3GCLSSlAVYHxm6DbuLKc+Oznj/xz+gNA5dGOraIIGb17by9EEYgouUkwbXn1NXkkJrhnVLWQpEFKSkyEF7mSQohMxSFAIkDYkc+C0SKeRMsUvNbZYpBTobuFh19N5jhODlV1/HmILBBXZeeRUzKXj+k3+L8Rti7Jk6D9MthJ5kc2foiO0F7fkxF6fPWa7OaNuWrh3o+0BvE7213N2quXlzjjKSWgt0oamMxpSKow9+j8JoXvn8L1JtvwlcmVDQ1XUSE0TsKKVEh4AiIJVC6xKtOrRusXbAOof3nhBKvA847/HO5qyWJPHB5WiDy1yzZIgx55eJKHh6eMLJuuOVxQjVT5cK5BywG8MYLkkOkx4TQMgToLw+zwVnRuZmjH8EFD952NINxSg/dVdfJ4T6/7gOPzs/37O7NSOFgTtbcHPHkMIWXXObVSewss95OMkjVTOa5SVVWVMEhZIxUwF13rS/9dItGpMnfsaInLtTz5AiQLC4lIcmzjomdYMInsIUJNdilMV1a5QsCLZjeX7EZL7AAqdn5/zKV7+AO/wuCM+kKBAxy8dtjPgkSO4xP/n+n+CDR5uCSlf8SOa8yP/Jv/913nnQMnjJljJE2xFMQQIefvyU46d/xBvXPV9/STD4gcooeil5drJEC0Pw2VguQiSGRDPfIYRAoQv6zQmlKSnqCUIoru0tEEmQQkAECN2G6CJFle+rIjq8KzGmyHJkGdFb+wiVIVHOeVJ6IRWBPCGNQeQstSgRMvL4+Sk39hZgpiAVfQxEISiUzA2uEbjoGWygMnmIZ0pNiI7FvOHh0QbvM5hie17jrQWhCSIiteL1uzf49g8/uvJUSJ0DTvve5624zIRIpSTDpsNrSeosyqockpoKfunlO9w/2vBgmUDVaD0hhgFwGZpCfpaI8fmpZckXXtrj9WsSm3IQvQ8WJQucj/lnKzR2yOqDOva8XB7y9nAf6yMpaaIwvH7vNr2PvHJrxiv7FeYHBc71ECJJOqJQSFMyrxTKaJ6enSOS4Ktv3aMxmlW1S9x7mSfvn/D/+LfvIlyHBT53b5u/8mtfREaXC5MYUUXOTrNdptORNN+2kg+fnmWTvYL9xZS//VuvkbxgiPDoefvf8FX+F+/IGIjrjMaXHopKUIhEoedcnHdMpw2VqTg9OmGxPWddrLk4OyJ4x97NA6SPnJ8viUqwv7NHbSYs/ZKiqti4Kcv2nKEfOHx2yuuvvMbzk8dcnC7RQbKYzHEENjZwurF0TiJigeqhlgpaS6kNe1sH2GHg8PlTTAE37u1TTBrO1muOTlo6l0l907KkKGpciKyGSIhTwtBhExAzKCdqRUyeWk9o+8h0e0bXdtjYIaWiCx5hFKqYkoTBBo9KMiulUFR6jio8ddEQRWQ9bKhUpvmWQV/556UQlELiO4tsMzPBY+lLhT3u2LQdRcpDvtI0NKViWnUYLbKP3K6zjNlAGAIh5niJG/vXWS1bhr5HycS1nWs8e36BA4qdCc1khnMe7y0xeYxKlMYwLWqqsiDGwDC0JCFoJg1FrajLChkhJs/Fmae0mlAYbt65TXQtq9UhSMtgWwgJjaQqFG13wWJ3htmpWZ5vcGHDfLqgURWrdc+s8f6EiAABAABJREFUrFFyne9NxtHISAygVIkLIKJGCpVrfucIShFt3thLrWjbDaRIoSR1WSISdNZjdJ2HVxG0KcYadUBJNfrVVAYqjdLHYbDZzyZGnD1Z2YcQeSAXL4mSn4R4XP7vF9LHTOqMMA7yRqcUKSaMKXJMRJbijdATRjvKC4X2+Ff9zOfn05xJgTOS3gkmVcEQPElpfIiUITHYkDcPJCotaW1AyUg7WGKUlMZQViWmMBij8sYq5uJUS+jWF3TtQIqeZZfwQ5ZgFKUnKZWxnNLk4tlalIjEqiKGhBYx0/lMgZCS1brj6dFZnk77DYWuqKQhDA45rTFGo4sJSRiSW+OHNaqcI40Gb3HtBikMzWSevVIa5rVkWDqEUYgQUCLStz0h5SDH5NqMsi9yIrsbBG1YI7XBTGZUTUXfeqT0KJXyxkiA0QUohU6OlCRHq4627+iWHmwkEDhMiiAGfJdQKXERBRvbs7tYYIzEd2uIAdcNvPz6PiL1CEyW7ZEbrxQD1gcEHlWpK8NjjOOHdcxBE2JstJNjuQqsNx0AShnOzi741V//dcT5x3z4jd+jmd6lavZZPvqYYDt8t6FoFuiiyXIr29O3K5bLFeenx6zPjmmXF/S9Y2MD3TDQt5bt2TZ37tzi4M3fQWw+oigcRTPDbF2D4jZKb6OKBqEqfoq8g0awTZITkupwrsX1LcHZ7G2LuQkLMeuWQ8iy1ewjC1cAjxAlKWV9fQRizN6xiCB5ydpbnjx7Qp0ccoxXyEOXTLtU0uW1+2iMzdkqXP0eKXvp0qhZ5iroEEKUfHy8RooZiSxzilFdTXU+O5/uuXOtoC4cMVpk8nTJ8+TohG4I6GJOXSjq6YIUO0bhKh8/f8pL2lGUHmQkeoGMiVmlkSkHeorxoRuLGd36HKUM9WKOlhrvHd5ucp4VAtefsz57TPKRevsa3tucs5UiThf8+O1HvLWY0NQVIVoKUyBkQkpNiSTSYWLk+s6Mi1UHMoejxxD5tbfuMCvgy69G/tN/8P/CRYPRBRFNFxJ/9Wsv81e/sMAoz+ATpIj3AY3n9OEPeNwf4Kxle7HN4HpEMcFFxenJcxZbu2hl2KyeEf021xd7Y9wKnJ2dUJqWKArWwylBTLM/RCsqLSFGbEwUSnKwd4ASivN2QwjxxRZ/vAaEEEiVJ67WBX744we8+sotpIRiMocub8WSV6PsEAbvKY0ixMS6t2iVt0UxCvZ2d1D3T8YMQ8F00qC0wRFJncVHy62dhm+lnNUTY0DFnMdmioIQEyFFVMjbrkwuzhs2ZKYVPzn3fPCkpPMGWSiEKsiG5n4cY47BpckSfYs0FUIkZjOJLhONNlnmaXM2oiQTxqQSlLUmRsVq2bEZLDCi0fEI4flbv7HPVtMAkuA9N+eSJ+ce5yPJX1CoDX/vr/wat65P+YPvH/PHH1+MtFmBMIZ/+fvf5+P1HzEvtthsWgTw6q0pf+1XX6E2nlKbMYNtJNDGSDGd4mMejiopUUoSYoIkOdidUFUTnLME73jz3s6f3wX/F+R0KaCNIawshTD4vmcQkpgEw9BnCIxo0VKgdCIKh1R59HlxcUqlKqI0CK344MFDjJIsJhOaMjGcHmU8PILBrlguj+l7T7fu2JsvkFKyblvC2QU3JxPM3g5Hzw9JNtdNlIKzVc+t3X2auqRqDCJ1dGlD1w4EJRmiw/qI0iVt9Dh3yuA9SZcUoWRRbBHiwHJzhpcyKwmIuFggZMlsd5f7q7chROwIGvNtotQaGTMxvFCKoQs57N0LBtdzcK2hrBv6bsNmuUZpTSsT3lnKUhNM4sSeI5VCTHIQtiLhaLGDBSURUlPpCcFrhMkBHUYUuRZJiaIpaLueoAK6CKw3xyQ/o9EV8/kWwSWOnpxhqgn1bJfZ1j5JKqLIUlARIoXWVEUJSbBarbHBooxkvjXPWy0JSoxeZ5OjKwqloSBvrRYTypni8OgJLkq0EMjosF1LKg2rJ0uKosh1TILDk6c5EsGUuNARRCYVexcZnEMoRSk9TliSSGgp87ArBVKIFKJgXm1BdAjfIrXIEkbf0w89PoF3ikndUDcNfb9ESOhsT1NNck6i0NSiJoWC6C7hHVmVFFMcKdweEeWY1/uC3HjZkI1z79HXnLurS9uPJI01WwKZ401mkyktG1qbVRSRnEGnxnxNBJ9Qnf3s5+fSnN28OeeDBx2lVlSVoiBPOpXMnfng7QhxEEgDjTAYbTheXpCEYndnwta0ZH93QvARjEKOOVKqqJnuHpDSBcpc0A5+BCkEUjLjFggCAus9ZVXik+L0fMP1yhCSpxwpfEeH5zw7esa6zbkThRFURQaTDF2PczVlVWUDuwkw5pOJaBFCEZVEGZjd+DLXX/siR9/7h/jVhp2ZZSNK9m9eo33yMUl6zs9z4+JG46pznkprvPcM1lNuTymqAqFyZlaIESE1pSpoe8f29oIYA6aQBKHpu57z9YBSDWc/+D5bZWJ2e4960vCjZ5aZUphkuVc43vE18mLF1ks36XyLEpYnJ54f/+Qpr718QFUIklCjPyqbJqWC6AUJPTY2eQ2cP9wh53ClnOWQhORivaS3eXtpTGR1fMrDdz/iy7dLpLvg/h/+n3jlt/57FK/9Bscf/CH22RNUtUIaTRISP1jatqPdXLBZrlhdbOjWjrZ1tN2GfuhwLrC1u8e127eY7twhygvKMmCaLcRkB8ptBItxi/TTzYpIiciYBl8uKLdv5aKvf0Tf9nTdhqFvcd5hh0SIbmzSUpbjjP6y3Mhlz1kkjkWGyHlrKSKF5OV7t/B9j3/+ATL1uSkbv3tK4nK/ng2oI6HxMvZChKucx7EISoQorrTUzuUbRPRxbJblSHX8DAjyaZ/ZJI7wCYXWChsTH3z/O1hR8KPv/wBVVDTV1gjQKPHDml9/dZuv/vIWUiu8D4TESCGNhJClJUYqYjHlghI/mqMzlCEhpELGmBs5N9Buzlmdn6CkoZzOEbpGEBm6lmar5Pr1XZCaKmhizAHPBImSgeQdjdbcvb5DWUK8iKikiAK0VHz+tWtE4ZmWgroOnB2eESNopWh0wS/ce43GOGJylAaCC0ihMNowKdcMbuA/++d/iBQFSudr4t/5ystYbzl+/oCXXv8qB3tbeLtGGs2sVtQ7M47On2LbD7ix8Cxmc5Q2mZeVFAZBkgKCo9tEinob5yPWhlGWzpU3lqgQIpCiIiTBH//JQ+7c3WfWjIZuWdKtNyAj61XHdJJVEFpo2vUKJTVVren6HullbnBSxNvxGQMYAcFawigxLEvBzf05k6bkdNMBiRQ13nYMdo2mzPj9GOm77LfonUWqIitBjOb4vGNDRZIBbSZZOm1PIdrRiD6gEJACiYBCYkxBmQaCM6y6DcE5pNKEkAc7znVj7lREK8N0IilNgY2ZsouA/e0aFRK2axFaZ3UEEZFAk5AisjsR7M8DIgxUJUip6G0cTe4ljTacH13wyhduYBRUTcPf/Cu/ikk9MUIUhsFl+q0WBpdkBlAhGHxi8BGtFNZ6UIGD7RofAtYnStOwadd/jlf8X4yzVRsGo2CrItpAoQw6CZL17PZ5TuBVot5d0ClL2WSIj6SkqhsEkroQFEWDIBFij2XD4TCw0RYAnRR1VbM6O6cQElmCFxuGwYM2BKEyYDV2SDOQFMznu8znC8qjc9phxWY4YxVbqtIw9AOKQNf3aCXYmgiCsxhV4kPCUIHXlDoS/DlBCYppSS0VKuVcU5VARMfRk49QRX6WIyKmUOgkYHDolAdkUkuUlnT9AFHgUuTxs0OUlKz6FtXUpBKMH9AkOvIwxjiBEYEhumzfCFlGXZU1KliUTgQTWPkB5TTJR7wH77PXSSIoBLRB4UTeyjkX0SJgdMQyYL1nwoKbezeZ1XN674ghjhm0FaDYbDwpBYSGqixomhotRypwVeKSozEF0Wmm5ZRNd4zUueYoSo0yM548iyhj0CJQSI3RJfVsi6PTYyDkhiXkLEZTaKT0eYMvDB6BQyKVIfnAEHqUgqYp8cHjyIVP4Q0T3VAEjdKScnsv+1W9Q2mBqGq6fsBaTyEi01IxbLosFcej45D7pZh9q+3mnD46VFmgpUKHTAXtU0SkHu8FdtVTFlNCUWE91KbIcCSfSMkjK8UgDEiNTooqRKISKK3yJi1EpDKsVqscvUDIVXQO04Qocgj1JeFRwWV26M9yfi7N2e6WoXz5Ok2tUVrj/JAL0YxSyMHHWGIqSUlQ1RlDf6vcRumCQilevjtFG52zggQUOrcHKjr2ZhMmOtJvFK4/Z2kdQ0yk6Om7SF876gAuSMqkUVXN9taUsi7ROiGTwzlHP/R0g+Pk7AyloKprpnVNaSR1NUdHgSaTyuTZmtB7zmrF9rxDWAFGQlDUW9foL56yXq6JKeEjlJXG2p4kDKedo+t7ikLQh4yqjuT0cB8DSaZMTCPkQEIX0UX239UTzfFFnzv3mA3evc3p6duN5NHTFbMv32Nr2lA027z0xqs8/8bvUyhDb1uOe8fdeUmztcf6/DkUDZteIpqEEhZrMz1TyDg2WrnYEULiYsR5mwEgSYz+LTciTy8Xw3kyfHiywoaUzb4x0rY9q9On8NrXYX3MybNntP/sP+GlX/odbn71b3F6/3ucPfohQUhCVAxDz9A7bDewbnvWG0vbeladZdUN9IPFu0AzmaKqEplahMnNulAGvAO9IqkZgk/Ex+cyL/dq0QMXpLgiuQ5kQhUFUmfCmw8D1jq8T7kp84EQIiH6XPDFiI8hZ7aMmN3EGEAdGLddWXftlcLFfIEjxkF4ipmOJiRSZN+aGH80KRM+yZHWOFJ+hMjAmbF5kwq8H2Wo5O9FgiTk+HufnU/1pERRFNjBY+1ApQW/+fmCH350yqOm47y94LR9Nv5hxVRrvvLmb9NaC1Ejo0BrOcpkyJJWWeYHk5rjZMF8Jpk09RWZVAgI3iNk3ogk70iqytl5fZvpjjLDH2SEazcO+PjdU0oKROjxUZJCT4VGCIVPCZynaUqS2OCih6SYa0VdKVabFicidaWQYvRHjhAcrSLWDnnjn6AbLCFGjFL0PlCIKW+8/hqHz5+wWa8wMvLbX5ozrfMA5r1nj3jy8QlbOzcI6YK+Czx59oTYP+cLL2UghhI566yuFMHn0FNF9kyliaCczTm9WJJSwPuILkYDdsqT3xgzafYbf/SY6daCOzcaQrRIJEoVNJM5xJZpWYzSkjxcmU/neaiTAkpIqqpEqgQi4JNHpDyiurY9pylNBgHJHFpaV4rFtGC1abE+MqkS17cn2L6jmhRcrJZsz6eYuqQoK/q+G/NxJE5IvFvjV4eIospSHCnQ0uBDi1Dq0nx66TEnIagLw2xSkKJFKUFhqiyBNjm/LSWFH4PKiZ7ORp4dX2B0ifOZFvmVN28yneSQbOsDXOYEyTQiuSU3rs+QSeBC5M27W9iLWxxdtOzMC7qh5UuvXeMnD5/Rt2d89c3rPD5bUemICBKpNd7lOBDnPUVVkGzARU9ZaaRPDC6OQbGJSmtuX9+Fsbl2MVJPpn8ul/pfpONcTxICbQqMlhgRCYMjKY9oRIYVARebY5QtUFJRapMpqr5HKYkNgd4P+BQJMRKHCN4hpESXhuQESeaYDBt7mnnFql3hYkTKQAodbpPphkIaooicXhxzsTkiBMVFe5qvBRHxQwcpEaNGqEhyjphAS42InkKVSG2wNoBL7G7fwonI8dkpTVlju56qUGgjSVJgvSU5iU6apiiZTktC9LRyQESFDlMW022qScmxOeRidUGhFEJofNcxNZJ5UyGMxoVISBBEwrqBJCUpT72RKjdXUiacDbiQIORBdyCgvYcYOPMtWhn6oaMdLCF4ojIMMQ+IWpHw5ytK0xNJ7G7f5Obd1xH1hD5B5ywZ85/vTyFYpJJIqSnKgqLImHujNdPJlMIIzs+PQDs2m46z9ZKiLNi0LWdnZ6zbc8pKUZuS1g345GgmDSJBe35BIyKD3aBViTAVQkvadiB5jyk1g+8xVZlhSDGhTcXWfIvT01PqYjfX4d1FpqlPBOt0wao/RKWIUSUp6Qz3MxVNPUNJixCBYUiE8wu0rthdbHN69JzQWeZbc6SQnC3PCHIcqsVEE0u0kPShJzHke7h3KJXyMDENFMrQGEAlztenKC2IvUbpimFwVHXBpCkJQnK2XI91ciIksj1GVjjnM0hwjBOQ5MYqKo2PecD1ZxE6/VyaMy0M83lNxCMQ2fAuNSAIXiBSvgB9cKQgCV5keY0R6OBJBmwfOVwHtqYNjdE0SXLj2pTt6U3OzJobP/ojRF/y7i/8Nqc+8s1v/RCTBtoY0bFEO00KisInqkCeQJclhUkEm7MkfLDgw/+bvf/4tS3NzzSx57PLbHf8NXHDu4z0zGTSF4vFqkahIdNACyVBA42kkQb6RzTUQBoIECAJMhBUaknFQrO7VSSLPsnMZDpmZvi4/tzjtl3msxp8+0YSGrSQrQxxUPFNAhdx7zlnn73XWj/zvs9bQPn1bdqDM07vnnK8WDD2jo93FQ8fB3Y3Hbf++tsIWbP6vX/Cf+u3W1TOhBRRIkDo6NYPIYG1itZMSNHz409GPrlIfDV1RFHAGqOH3jmMFLStZRQSN+4Ye4etJOPumhAMIUaEqJm0Mx6db3j0dMvtkxoyKAXKSqzJ2CpzNJ0gVUVWIzcPP+S1OydIXTE/nvPo/n3W6y05rGnqFiElt269wgfv/5RJvaBuDEqG4guMCaMlAkHOJUScvW9OaLV3cJXMsefG9xgDKWUul2tCCEVnmxSrIXC1y2zqu5y/+31QGru7ZvlH/3fuffwTXv+N/4T66GU++Pb/g/XNOc4VSZEbPV2f6NxI13u2O8+2H3E+EEPA6IzIgrD5WSnYhCInjwgS3AqqhiwPAVuKlCLWLA1aGiBtwK3IrieNI9lHBBKjFW5M9DuHFAXQEWLBvYZQPGIxlWY6xETyfIpDzblMT8pCTBK8R1BCMzMZFynBkxlSLISf5xKAT/XIpfqmcDLZg0Qy5ToXBPFcA63378Hz7A+FyOm/EZr18/OLndnMIAS0VVMwxwJmTeLVOy/hwpq/+N4D4p6aKQW8eeeY46NS8ERR6KtSZEYnkfugd+cKeCE0xzx58oTdquMrv/ItSIHndKkUA0oqEpla9NR1Q0Qwuq7IgslkWeFzogFee+ttzPn7DJfvUQmFnVboPSreKoXMisNFTc6iDIdi5s7RAc4NSCWZGsPRpOKRVPiciFlgjUJKzRg8UtYoozAVaJFAGubGsl1JlOg4PjjiaL5gOrHEELm42jJpNK8fGt44cfybv/1zfvDuJU1tuX37Vb72hXtotaFpDEaU+9B2tyOETMpglCZTpG+6mfPk6Yrbd2awl4jkpBAiAAmJ5i++85jlyvMbv3pIIiClIoSARDMmDT7t40EERsl9fk0xhnsfUCIydjsGD9HvYUUZTAWLg5blGFHsw7e15nI98ORyVXyiAupKYkV5WCMER4cHGKOJIdGPDucSs2ldctrw/A/+2at896c13/3pB2y2F3gUSrQcLyxfeOUet09f4Y/++u+5Xm0RscOPjhde0kwrSYoKhMAaWe5zqlBivQsEKRBZUtWGECIPr1ZorfAxUhnBmy8dE72gshZkgH2OZZGql0Gq1ZrKgp3PefrxY5TccjoXLCYTRI4cLSz//Nfe5jsfPeKVowmnBxX9pmw3YhwhUZQWwLYrhXzJhEy4ENl2HT6UcOG7Z1MOmhYfRnxwSCry54KAz/zkNMGFgRACWhZFiEYSskRog6xrZIZpVZNyQitJ9MWDKcnE7AkykIJHmxpU2XrEFNG2IoeElpLRl1iJJAMbH3DJFy1LzkhVcqdy0ohUsqJydgX8EyM5W6JPZQiVdfGXmfL5aOoJJ4eHhNjjQ8AH6EePloJKK4yKbDYrZB7QomKymBMR7FxHlAOe8nM1tsVkSR5GguswSuFkIknNpl8zeo3NkoaKHCLaJlTbUDc1tqm4Xq7IKWIqCznQaIo0Lycqq7BWkH15rUYqnC/yZ9uUjUryHXVt6F1g9B31tCaFAaE0KUR0FmhtsFWNk5K+G7h3+2Xe+cI3ULpGSMPgBlIMCGLhOzyX4olcNuspMowFW5+zwSmFyYaD6Zzd2NHOZyw3O8ahMBL6fkDKGkQZ6AQhcHvYSPKJRtUczQ6JUTD6SKRs8FOGaTNDGYs2A8Oe4KmMJAvHrl9ha8Pl9SUxBoIfyaoMq6RWWNki9+Ys7wNokDaDcYUQSkRqzeHREd5lHj85R8hIJHC5vUZbxSBGRIJaWSor2Y0bPIkxOg4WR9w9u8f1syu67RqhMjFuCQmG7hqEJNQFxJdTwOBJeWQMgtUoEJRaQFWGvh9Aasa8xWdB73pm0xlSaoa+QwlBVoacDLvBkaQG9Yu3Wr+U5kwpXeQXSRZdbd4HvGVHDCXMQGtDZRXaGKwt2EslVVmpa4MyNce3jxmCpdKJLDUf94FkLaOpGJq3qVvB9P4l3Ze/yOFbz6gW94iuwpO4As67Nd+olsQAbvCkSQYrC35ZGaydos2alDOLs9d58403cd7x7Mbx4OmaDz58QmwXLKYTmvqYL28vqX74Q3Zf+SbzaQbfs910mI/+gugybkwoKxnHQM6CH7x3w+GtGZvlshAhkyBlz2aneGFac3N9TTWfE8MeW+0DMoCQmRQtMQ60kymjcyACYv/BzS7ho2AybWlveoytmVSW1a4jmrynaw385//uZ+xcwLkylf7CK3N22wGxfMRiXnO96pkGQ5YaKRPj6MlZIIWBXGRDxlYIdCEWirK6RgR8zMUgKyUhJq6ue0JMBQWdIoMboVL4mHi69ezGgYkVzCrDZvtjzu9/zJu/+S9553f/R/zd/+v/yOMPPmA7BIZ+pB89vS8G/X5wjKMjhpJ5pmVApAB+JBmBJBJDQuzT5JHPyLpHqCNyDuSskWIOQPJbpPDkYY0f1vS76xIUnhPD0JMSzGcN3nn6weGD32/QKDLHPQAk7cljZUK91yOn8pARZHzIlFlj2W4pAT7sPSmwn0zvJ+HPQSCplJZpvznzMROCIAYKuSxSvieqSDTzc+JPAa1/fj77s9qV+PAQ3H5rY1HCkzvBQdsUABAFhCG04K2Xb5FyIgbB6B3JFMiEVgopShaPmoAMkh89esKde1/lUkR+8IMf0kxnHJ+cMGktlTbFu5xH/OoB1twhyJq+H2gqhzIKoaYQwcXMMHZcPlzyQqOIcSQnjaMUAIWarKkrUxoWWTazL90+ZDZtsRXEKDg4nJK4JIvirWxqyaStQBYZYwyZ2hikhmfXW86ODJiKbtiQQqZtG46mLU1taJoKZSKVUPTjwBdfOeDhwxXCWDKRSEPIGqstVoHNioQu8t+QGaNDS4WyLc5XbNYjt07qIrWWgvsPr3jxhUMk8OH9K+4/7vn1b9wGWa5RKSQ+BITWTGYLxG5digbBvogs20kEGGsYxkQWMJ/X3Gx2CBRShAKQItGYVIznMUP23H/0DD+Wz0jJ1Mm4mBHVPg+KxOjAakNT7aepCqpakbPmUPT8s1+9y+A7vvPTT0jOg1jy+7/yNb72+iHZJ5ZvnPFffPsZOQuEErx49kIxwQtFCo4+RDQGrTVaScYMSElOkdjDxXLHfDLjZntOzoFXbh8ybxskJRKEvS/sYD7h4XJTvBExcnI0KxEySrFdr/EOdGUxpkjfkPDSrRZhX2G9HUj0NK3GxELAzFmBqkrOXqXwoyfmIvzpx8Cm92SRMELzzusniAQ+SBpbFaXG50HUn/mxlWc6K1lYVukSKRMiSAlK4IMjjp7aGLLMhXgoDdEHfIzISjAGj1IWj2f0noq6hK7H4u2JSqJMTSSQKZsjIQ1KlEwpHyJCKqaTin63ozIVwQsEGWsBGUhJMTpwfaCuNF2/QYuMthVRJHrnGX0plG1tyB6OJi0wMJmU3MQQfYnmEYnoO7Ir8kgfIswVQ0oMQ0fwnslkThgzygSsMeB6iJKj5pjVZg3eYdqKTd+Txw6XI2YvQzcCkIK49zmJmAjDSApwtDhmeXVDVhbnHXnwpOhpalsGwUIwXUyLa9kXkmZjDXEvmU4hUekK3UreeuktJvWMLkS8dwz9jpwKETHGuI8WEZ+q6KSiAPGkorYGKTKD92w3G0LwTCZt8eu6Um8qpbC25uzslPc/fK9kFI/QqArPiBsGdmqHz4IxlRiiw9mcqmpYr1ZkPxLzSGQkiz0kKWWUGpCy1P1CJJqmIgjBGB3JSbQ0RCELATcWCXn0I04EYhLIqkEguXj2DKVM8RELSLk0w9FrhM9IJFVlIUGMCVlpRBLEQbNdbsg50ceBJAS5FFsoY4kJfBTkUGAhemKZzCu86xhDROeEUMWsImVG5QRxhOTRWkG/KaTy6As5Mmn8uM9Vi4LaTH7h6/SX0pz59DzeOxYKilCloE6KLBJCmJK+LTNCeGIsN2KpZYm4lJnoe5bXj6knR3hpqCeJPHa89+ENu03Pn3SO8ekVh8tn/M6vfBGRd6SkqCsNOSD2MpfdMGArSQgNOYJAI8RzKV8u9Dwkl08/4OVXXy5IXzLRZ2SUvKoNByIzfOEu3/6bc85u1yixI4sp3jmkFKSLLf4p2NcVO7dFYBk7T64sX7knuHxavE4uZQiWla843W5oZg0xg9QVEHCjoraivNkq4sdECBklLeM4AHOEiNSmGN+f3Diu+x3DuqfViiEGtCzm27/5+yt++MnlnopVfE4fnG+5N9VoI0BqXrt3gBQKN4zcXF/gnGflKl55YcF8YjBWYexeyvgcGrLHkeYcSuK5KE2a9yM+ZSSRMAqEzTCuOX/4CcEnnAv0neM8KY52PafbgYs/+L/y8ts/5Yu/+z9k1f9rHn//b1jvHMF5xhAZg8f5QPCRFMo0SIrSKKkki4lWDIVoJBVpSGhVI9IaTAQiwUt0ExFkgl9jRIfrd4ybFW5wBZ0/OKSUtJVGysjQ77dlUZSmMBa5VMrFC5iep9GnvA+OhJ/njCWijyiV0LJGqI6YEqd3XuTsxXt7ClPABXApsOtdwQEj2A2CYUywvCa7gSEkbm6uEc4DJQsNAVnE/aasPLz2CrnPz2d8ZE74OCDRVKpMZKVSpCQ4PmyQAvYfBlJKVLrkc4l9ATKETPIRJQNaQQgU8mDMSBq++Y0v8sd//qc8+ru/xQ2e7ZgJ0WKbObdO7/Lmy3NengzlM5OmeKF4cH7B2AceP/seF5fnKG1ZTGf8xmuBulaIPANRNj1SJXRVUclCQ4w57f2KhtOTQ6TdPwgRnJ7MEFnsi3eobUXX7dCmPOiTTPSDo7GaSSXYbDa8+1FPGDyLWZmY3juusArGWPJvXHY0teHsaMpsfkmMHi0y7330mK//xpzktyRpUbKYLkcX0EIiCKRcZJmrTebkaEbvRvq+Q0rL1aXj3u3Mdhz52c+2nB62HMz3RKwMWWSsqYCMbg8x6RrvRrLKjC4QQyTvVQ/KSKxpEVmRsuPyZomQoLTABc/FzQ1H82N870lkXBh5/LTcZ5UUyCw4nLXcu3sKIhN9+bcxCoRICCloVZEjGlmkNLI2CCRXy67In2TiaNry9TdPsBLQgpfvHBdabMooKZg2ukj0UaDr4ichF0S2klijidlDLqTj7TZwtbphGCJKC77w+ilWSqAEw7p9o76YNWWTS0IJwfHhlEwuUkylUaIg+rerLe3xooBDpCCHgRh7chpJSlEbxeg9daXwmQIESeXpWhuN1ILdpi/meVECZpU2uDiitEQkSQipIL4/P5/pqXzLcXvAwwf3+cI3v8qy37LcXbPplqX5ygJCCWpHS+Q+ezQrhdIQcLRVi9EV3W5E7gtRuQ/b1UqSEsTsS+5eTlijqaqKlMvmPpYsGbzvqWtF9F25XpIo8kMBnuIj0k2pkYIvw5mMY3Qbum4oAC8RuHUyw6uRod8VCaGSTBanjDGw626KZSCCyApBkUYO/YYxlvgAZWYIPSUPHXkciQGm1ZSj4yNEpfDnO0KquPPiXTbdjqcXTws6nVRUT0pDkoQEsawH0UKhsuTO2Uu0Ys7F6orF0Yzl8galKmbTQy4uL5DG4MdIZeQ+5iAgtIJU8gCJCRMrjudnzI6P6OLImATOjeV7Z4o94nnAMmCNQWtoKktVKSaNRSuB9wORzPnFY7bbgUk7Y7fdkYWkrg0pZ6azGc47+rFHGomxGpEDiICxsliVrERlSCHRx2XJpd2HNIfgkLoMkRtpC1ypEM7KBlYqNn7EKMNEV4z9SJTgUmIxX1A1ls16hQ+Opq4od7oSbp1iIuZdyRr2JRsukQkxkEVAW02ykW4zAKoMsKSkG7fsntwgNXRuR1VV5CSQGMiaRhoW1uKcRyvNtJ3ikyeOkZQzPgdSGIlDYjaZgQuEMaG0om3nbHYjKUtSDEwqy7ydcrVcopFEITAu/sLX6S+lOUs5IqIoMjgJMoU9HUXv0eJ7ZHuuiqQQiZDFfJdygiwRWXE0n3Bxc0PvE49+JnC948luYOwiu76nciN3x8SzrSBNvk7KsHWeISRi9NjkObOenHwBkXiPDRmpKvyw4fJ6x7NlR4qR9vgl2nbOw53gfHvOew/WHH3yCV+4ecTmzmv8+PCYky+/xNu/ehtDgOSpmhYpHNk6skmEHHAjVDax3nr+27/3Ek/ffxcpMzFInl0Z/unvvYXWgYPFHGUEoxvp+0TMkSRMITwmSWUV9VGDHz3TJtLttoz+GKtKFsQwdjz4+GPWXcbfrMlpjT2acTjN/OW7iR99tCr4WPa6OZH48PEKc9bwpRcPUXPJ+cWKs6Oa7bNLni0DG5/44HLNsg/8ztdeQAtdpDJJkmWBTogkQKZ9/k758jEW3a2PGZ0FO594+XQCUrLtB/phRInM5WokZ8kwwHYbmE80T2++zfnTC377X/3PuP/sksff+zZ9iKQYcTEVDXcoFJ9Pzf97SanOieh6lLFcXHdslkukvV/oSMJyfPsUkTOzW75MjtyS7fqccXNFHHrGfosbR5wbcM4Bgm6IbDtHStAPrlB84vMw6kSKsWxA91kVIYa9TGcP+9j7KxQjMSvub07oMfyLb36Jl165izUaYRPBB7ouIkWRjIWYCc6VcEOfCH5k4+D/9p99QOiWqNAjfcSMmj7Ln8sYxV5a8nnM2Wd+pDFEXwoEBCTMXrYF2iiQEqUEMThSzLiUaGtLiJlJM8GHiJ0ohCxY301X/t5sXlOnkT/9w/8nppnz4r1beFe8qAjJsO24uvgOP1lnvvUfv86f/Pi79MOCm5un9NsdVdMwmc948+4RJ2en1NM5R9UVOQ/E6AjBU9WWnDLdukOJEnCtKBkyVsDh3CBiIivBZjnwyt0jjJUMHtjL5GLeD61EQCnJfDJFypLjJaXh44ueR1fXPL26QYrMP3njbbwwKPbZQ9LQ7xyHU8N6e8PHjy8w5oaD03fYbOYczxLDboNUGh9SURuUXzw5OvR8Soya48MpV6un1HWL83B97RjHyIPHA0k0vPpqy3Q6IQtHTs+9mIWylcSEq+USJRKT1kKSWKuRUpFzJEVIBPrdDm0lzvl9nEXxcXVeIHSLnUJOkYlccOeO4wefnKNQICNvvX6b0SW2o6PSNXGI+0n2iLWGEIqXULMvtozhwfmKm80ACJRUfPn12wW97wJaCEa3g5xRQqKQXN2s8f6skGNzZNcPVLZGyIwLOxqjSSkgVKHEPbrcMLqAUHDnuOWLr71AioKQJEMYkELT2CmjKwoEDSgVOZpWWGUYxx1u3GEaQZIKFzNVXdNISQyJB58sWV/fMD2Y0g+OxXRK3gfNOj8yaVtiiD/3d0jB1c0NLgS0lChB8ZhoQVO19INDy4DRn4+dPusTleL88hqpDO+9/yG+1kgLRrdIk6mqmlA7xq6AF2ICl1zxOodC20s+cOuFU4buMYJYNlQU1QeVLJvmnLBGlU00Ao3i4OiUy8srrCmwtJAUGYMfS7CylKBlia+ZVjUJyTDsUErTKLOnesLObzCmQaiIwrPbXZFTIOaaw+OX2Llh7+deE0UkypJ/SpIQYdIWOXWjWtarDllB59ak5OlTwOPYjQ47azmoJySbWF31dB99hNKCkBJhL2aRSmKExoeIlJYoY7nnp4xIkfd+9mNOjo+JboudatpKEcnsditm02mR8YmECwmtclkydBtMZcgxIpNG0HD75EV8FrgYGHuHdw6RUpEOp59vnIUQaKOprKauNZU1WGswStJUljE4Xr73Eu+9/xHLqxse3H/M4dGMqtaQIv12y2az5nC6oJnUbIc1lxePyXsi7a7rCUSkESAi236FzILa1GhpqK1CaIUxhpiKH06gUErT9z2QWIgyfJYyUR80DKFQjKMckVpjJ5LWtLjRo5JhHErjlUVGKcXoRkDQ9T3WWGxt9vEcokgJYwFtxQhJCQIJa8U++kUSvUKJot5LwdMnBzZTVxVKRna7S1KGceiQWjNrpwhV0Y89pEhbGVa7QO8DOUiCSiQlSTLiFWz8CtEUYIogEfLwC1+nv5TmLMcCmHApE12Z7I9jwqU1215yfGDRQD92rNeSMQgeny85Pm5oGo2SmXmluNqM/Nn3lkQEQ4I3Xn2Z128d8Xg9osYKU53QfPgeNiWe3KzR6xVDOyE/fUQwhuM7x9x+YUZtNdE7Ugj4sXTyjx6e82y5xofSvMR6wXK948FKg55yevuUow/+nvcfbXm8+oQHs2dwi7INVAopBSHD+nrJj37yiBfvnfL4yTUfXWX+1b94Casym0f3idGx2SZQlne++gqvvf0yMmUwBlNb2hAw25KtBQrT6ELx8nH/YRoZ+8AYAv0QiDLRD4Ec4e6rryEvl3y03jFgCNfw4Nrx7Y97XBaUnLKyQcz7NPMHy8jrLyguPlrhnWCmHWFIrNfQhyIBOr/ZEWNGVGK/ISoJ9oJERhe8ey7LIikEWsqiD87gY8IEwbw2qBSRQD8kfHYsN9tCuhtLRtJqZ1lMBtabH1FN/lf8R/+d3+d7f/OX5WL3nkzJdCvG2YKhTSEicoIUIZbpNSLz7nsf8tF3fkjYyxuFznztn/4eZwvLfD4vzd7mCr+5JoeRfrdl6Lb44BjHgPeBcSyTPSkVMQe0FcSYyKLo4UuVlkk57ocIBZLC3pOSU9qTQj0+ROLY8513d2y84r/3nywKgVELjKpJw65kPBGLTNJnkAW57TOgFJebxE8evUbOHsgIpTmoW5ab7+1ljfDzBLXPPWef9bEKctOUnD+ViUhETBghOJy21EbS9W6/Rc1URpXoDEQJEtWafnTUlUYKSV3V+HEkBYf0gZl8xI/f/Yh6epdcS4yuqeoWeZy5e1LzKy+O9OsLvnjP8tGjHZVt6cWGejHF1DVGC5LryU4Ra0ljDNFmQOF8wpgKH0fGlLi83pbhihIgAst1z/FhzTgETNuQo2MxN2y7ESEz687hfSJLqGym7wd87jmZtVRacOMsF5cPEEkgtEEpyWI+Q+URUxsIgSwiTSOplOOf/9ab/K//LxtCGOm6Fe89O+TFU4uLFUqCciNGVfQx4lwJZV8c3sFVAp9iobXJis0usdkE/v2ff8yuh6ZtOD2akjP85CdPOTmccnZrQVLF9xRly63jY3bdmmHwJV8tO4y1gGCz6cmyqDwaUVFVhpw7yBJtMrdPj9g5MNogZZGGel8IZQiYN4Z7Z0c4X2RKvncIo+mGAWtVoX3K4huWSHIscvZHzzY47/cyTMXxYUXXeZA1I55HT3fFc7qnAK12HUhBJQVSayrTYLSmGzxRKsaYiFGBg0hg0xVZttGCN185K7KkFAnJI6QiS00UBThFTsWjLQTL5Zaj2y1WSE7mE969WjLkxPS1FxjGoWzzEXzhnXtcrDas1yuCP2EcBm52A0wrcor0ux3WFh/wEErxOHpBjMUCIHXm7u0DZpMZIUSylshclCWfn8/2BOWZHbbIWcum7+ljJO48tRQYofbQjyLFDiEijPjUeyaDgJCJMXFzdYkxRR5ba40KEDJgdIHANJY4RlpTAYKxd5hsaETFpl8XcnPOpbFTZQg8pp4cLUZYtNRYY5HRc311yWSyQMmiPshZ0gePlpbGTKlFRYoRkTU2abSp2AxrwthT1ZZIRinDMHqyNARVIke0FMzmAqUt3iesnhDEDUJIjKi4XC85v77ARY+wESEjbighxgrNmBwyReooabVFCcPOj/RSE32AfQ7i5fIaUGw3A7PZIUJLdl1HXVUMqWeMDpcLEl6ICCoilMRkg+s89XzG4dktdi7iR0fyDtJeqUb8tBoQ+6ZHCVkiPKSgZHuVQXNTN+QcGVxEyoKzTznRD1uGIVHXDTfX1ywWC44ODlltVjT1BKFMqU89WFvhx66UQRmU0AgJPpVhvhKCNDqU0EQ8MUeUqksYtTFICTGV+A4tdEHho9FImnpCVdsCTxP7hsqBkhmNpqlrhEwlV1RIjFGlRiehdYWxDVZXbMIKVIkyCSFijObW0RGb6xu6zlHrBXbaMLodXT/is2MXEgMjxtqy9Q+JaTNlu1ojcqCZtCjd8MnDj2mqiqquiULjsVRNXeoEIWknLZfLCxyeQCKMvlgVfsHzS2nO/t33PqH2iVYblBI8c5EhCnwauLr0/Hd//9Uy9SDxNz+4YNpYwvVT/HhMHyL3bs35cO04PW74xpfvMbjEzWbg9HjOrbt3UUcjD57tECLQ2YpxjKTgCdsV9eqGxdCz1jVnRvCbv3qPsHX86JMdm9U1yxvPcrnm8uqabjfiY0CpGbdObxNpOFwYXILTj664e6jh1l26L/0ahx/8BD9ueXwjsURY3hDGiB8c3/v+U37wsyUpOd756pskF/npj99ns10jhOYm1By3EonnyfXAvIJKgKEu69isOb9ao4RncXhAY0SR9giJS4IxFaT2k2dX3DqYkJPm2fKCy/PHDLs1SlUcnx1D0hxMav7qg/fpvCPvKX8l7rvsLrfjyI8eXPHq2RyaEZkyu7VDJVGIQQgWxlAZCTntc71SMelKuXc5GZLwIEshoXWZ1qR9o7H1gh9+fMWirVnc3vDk2ZIhRIYxEfKIkoLOaaZtQsrANgv+/I//kte/9havf/Ft/vyPv40fIns1RZG6Zo9VpTBLKZCzx42S5XLN8dEMIyQbN7DrfQGz6IhbL3F1TR43BOcYt9fsVpcIBOPQM7oe7zPeR5wLe/pUwIeIdwmRVGm4is+fuJ+gi32qQM4Fy5FygQmEfcaQEJB8mXI7BLdODrh1OEerjIgBoQvtTlfFjN9vR7Sh5M8lgZaZFAX3HwTCCGmfcRUjjDmRsuc5glLsV/yf92af/fFjoV7FkCElxn6gqhu60dNOGk6Oa643YzEKS8l60yHkGUJkjC5QiroyyBwhRaZthVN2H1osmOTEwZcP+MH9gEKT8VxfP2CzWfHNF2syAak079yVvHIK59cDjyZT/u2ffYfVti/fVykqW/M7X36Ff/k7r+CdwxiJyoIYBmatoYuZ7W4sjYDMSFmzvF5TvXmEMcXrtaimKFmCk0VOhBzJKXF264Bht6OyAtd5lquBSOJqKHRaLcXe66UZXWLw0A8jlVZIU3wQgwv4BELvt9F+zbsP1nzrjZpQkkkxtWW1GnAi0w+Bg2mDmR7Sx3J9dv2AULBadey2I7tO0LYVr7w4JcaRTx6u+fjBkpdfPCPl9Cn9EqXYjYG+G9kNAaktUhqc03g/onTLwUGFpMAEzk7nfHy+BKC1iqYyKFlyjpQoW9MHT6/3TUrmndfOOJhW5XtGj7USROSg0SSRSQKS81hrGHwoU20pefDshph9kY7lWORbUiJNRGB5cr3a9/wSZKZSipgiaZ+dud2OHB1PmbaSJmtGV15fiontLnCxuiaTMFoxqTXjMJCVxhrD4DwhDey6DkQGJZG5bENHH9l1PVJL7h4f0W8Sl9sNmkASNSlkqkYRfeRXv/YO793/hElbIbXl7p0JwQVqWaAlMXiESdRZMYweo1XJexSZpjbM2xnd6Kmsoc7Fi5I+784+89OMkeNpjbJFOjcMHSIXmuDz7XGMpQnQQC0atCrZet1mjTU1TdMy7kZC9JTE1QIN0drgtyPagYkeMYycvHoGE8v9/hHXmyty9uQ9GdUIgRsDWWqSsiQqXEwYm+h3S7YuIIHDdgpGkyRshw3IIs/VxuDCWCjQAVQeqP2K7AMqeSqpSVKiZS6QHj8ipSYRmc8X5CAY+h5jFUE7xrFD5TKIOTo+Zjo/YLm+Ybm5QOdQnvN7TkJSUNR+Ca0FRkAKIzIFaqsIUuz9VppG2yKhrhsAtustkNkOa0IMRQkj8j4X1xOlYBgDbci0suLo8ITORzrnyiA7lzol5oxKhWHwfOdc5I1lmPs8YDnFRFVZhBQM0TPGQDuf42LETm6IosBYNIn1ak2Sgmpi+OTJe6x2K3StkBTFFES01ph9uHfOCakkPkRCzghVCLQ71+8b6f2GKgWkjCidccNQXmsuICwpDfP5grZq6fsOEWEYirFXKFW2uWMkkxn7Hcpqsi6+Mh9HKmuZzGp2q4FRDCRZ4FIhR7QRiBRIY2RSTUnhBiHW9F3PGMv/V/vh2+gCMfYINLauCVmQdM2OjOtHzk6OeeOlt1hvVySVcW5kHDzZZ1SWaKWJGcJ2i6gK9TglSdf/4oqAX0pzJpNn2cNGlowVTOKVWxVazHjURCqlC3FQar7wxiFSStQLFbaqQGUqazg5EUxaQ93OcG4CUrPrPY8enKMnFQfa45zjve2aW2Lk4tHHmO6G9mrL7ZCwb0yZrRMPPrrL8VHNYSv58NmWdT+y2/WkrBBNQ7PPYun7geNKF89n9CxnBxz1Cb1Zc3B1RWgmNNsrfvzjx7jbGbfrmUwMPmSePNvSzj3P1p5//vsNf/Gnf8/HD59QN4LJ8Qs8/dk5d45aHj+5obl9xYNOkGXF8cFYLkA3MLpAbQ39mKm1RYqCZF1tSsZOypHVpmM+rXF9z5/9zfucHBi6rsLHjN1FhIDDI8k7ryz49z++4lMLDLAwAing7VcXHE0bZhPN1cWO3lu6MbHxAIpbVWChqiLbyrnoeikTqNLlpQK0oKC2kWWtLKUkpYBPCSUM1+tSuL1+E3jv0Q1CSowqcjwlBdpF3NgzjhJLpjeSf/u/+8/45//y1/jjP/xztgNlq1QiWBFZFfwpAq00KWeWw8C/+Td/ym/95jvcf7Tl4w8fMDgBOHzKfO23BhQzQga/vWHcblhe31BVFV3fMfa+ILljIIRMcJ4Uy59joiDy92Hpz/XbifJ7KSwz9plnJcQ67aVT0WWMjLSNJIaO+VFT/HtaQ0rkVIq2kASj2ze50pADKCUIsWzePngg9u992vvNDINfUsyTJR8t58TPgfyfn8/yhFTInjEEqkqVh3F0TJriY33h+JAP729Iovg+zy9XzJqaXdeRRfl0bNY79P4hsupHZm2DSTB0I1oLqtrx03d/yv0HT9hsd6Qc0Fnwm//qt1FyRk6OmCKVEtxdJM4Oj/gvv/18s1sml1J5VssljcqYij10o+SVCTLd0JNDKrLJDDl7lr3DJ4AyFR+HoURGiOciJFive166d4SsLT46JqaARYaUcJtyfUhdQpRnbYuQnuS7MnmUJR+xrQzJJxZ7MmPMAUmk857InMSAj4EwRNrWUANTUxGCY354i26dOVzM+OD9jpwy83lN1Wpyrjk5q6laxV/9zSf03cgLLx7xV3/7Hr/722/t5dAFoBHlHG07TmdzYizI6RxLgRFj8XpkEgjPvbNDvpMeEMlopZhODBpV5I9hBKMZhkLTrGzmndduM7oepSwhRpSMKCkwokCyUvbIlOg6R1XVWAU+RHbbLTnuAUJScnbUUmuJ0oLejYUuidzTZzOnBzMqrYpMRmqaRnJ909M2Gmsjs2lF21hkhu24ZbdzQFE/3D07RKlM7wdM1WCMAKWwWnOwOECf36CSROp9ARscxlRIIm++dsw9N6fSmpw8Uir63YAgUVvNV9+8zXbrSbbofUMIrPodKRSogjCZtjZEErNJU+zQIjJrJ4iY8H6/CUjFV51/OSXJ5+e/5pwuDtEJcgy0xqDG8h4IpfDZ4fMAKaKUQKmGPmZSDhhlUe2Mg8NjpJRshjVjtyk2CK+YzFqGbkuTBDZKuOqRKXH+4QPi1JAnisvtsnjXc8REqKqas8MDhr4MC6aTQ8be01ZTtuMNMe/Q2hKSQnjF6B05mQJxwOHHcu3lSjLUmdA71HJgd7UsDcTxjD5ksuzRsce7yJ50wHabSnCy8LghM5vOmE7mNEozmy4ICW6ur4mxw4qIVAafRfl+IpLxzI1CRIWSmt4HkhVkq6mFJciyFbTWkiNM5zNWmw2jcyhRxqy1kQyZQqsUshAwibSTBeMuoINAp4qDgyNGP5baZQ/MKJE8ZVArhCgD87SvH0XxR0shsLpYKUTOPD0/53K9YrVc8+TpE26ul0yqhpwT09kUEhyfHBOj5/zZEybTBlTEh7LdHHaFwFoiTco1fnR4QN93rLYrAELwCFXyctVeiZVT2tdfntpabC6LnJwCxtZINLXUTCtLpQSdFETvsVWF3wPYDIJ5XbOJiW0Y2fm++IZlZhwHtLCFAErCp1Dm11KQgkBmOL+6Kvf+VCIXYi507ZACIRXGQY6hRBxozcZv0aYiNYbRRjo3kFaOu6dnYOcM0THuHMmP+DiCtqTo0DFRVeByRKWEz4mc/5E8Z++8fIuQBMaW9WGlFUYrlBS89Vomo3EuMW0Us+kctc/pMRKErjBKFtmHKCbwq1QTs2ZSV9wi0NaSNG0Y+sgPui3yJ+/ylUdPqPNIayomrSKfB8zNM3ZfPUIryaRKPHp0wRjA1hKlFVZYpLVIJN31x4zNq6ht8TmMVvJYSdJuoD2/T33vTcRwwWbXcXEZOGxgs/LsOs+bby44vxz41hcOeP873+fxRzcIm7Fa8PfvXdD1O1JsefpkhWnPMdMWnzMiH/Hi7UOqxrLzNRIJKeNSxkiNzIKu35RfalZoHdl1A4vZhN/+xpvMpg3vf3yfZ892uKGn6yV3bi/4J994lZ8+3HGx2lFwJ5KpEnzlVsM3fu1t/vS77yGUopm2dINHYxDJM8ZESIrDg0zXB2yl9uACgdAJQSpEumwwSiBUWZ9rDYjA4CMxJ2bthG7Tk3NkfjwjhEAUmTEojMwoofeRzIpKSzonoPJ894fv8utff4VXX7rD3/7oPjFnhHxOJSz7v5vrSy6eNdhmgjKGPiX+7N//NSl5bp9YeiTCzpk0FYeHmh2wGTpMVZNrBQaGbkP0jownpyIfzVH83ECbymsVci8jSnGPtk+fZpUVOWO58MnFuyNlSZyXAhI1/RAQGb782h2ycySVsXWF630xJOeMURqpTEmpt4p1vynhwVrxyePdXr5oPoV+hHRFTM8x+nsMf/ocCfL/jzOtytTVa1BGYEVdikhVpMO2NkgpkCikgOtVx/XFkpOzBd2ww+fMZD4j+oGmsSX4PcbycFKF5Jhl4P79j7hZjaQYkVpy3FYczxUxjXgPwUWMlqx3makJfPPLL/AHf/ITSBkRwY+ej54uuVn3tFX5rPoY0LUmJc+80VSVRTKyVyNjtESnIuEIITDGjA9+TyAVhWo1dAy7JUorRI5MJwbvI8OuA2GQJNpmwsHBKY1K1LXmZtkh4hZV1fR9jzEKrRSBmqap6foOoSIiJM6fXTDslgg0bWOYTOqiAcTQp8x0cUgTAm2dGIYRKRSLmeXrX3+B9WpgcAM//MGqhFSPI8MQeOedN/bY6FQs5MFTtxOkB6LHaokxGWH2ge5aE/xACImu98wahVKJnBS1ldQmE/2Ws4MZCIk+fhs7ex9WW77x1m1ev3uAELIMXfYXqNQ10SVyzExqi9SZ7TawXK45PZqUSIOYyEQyktpKzg5mGKtIFILkreMD3n98VWRJUnDvzikxZKQyIBRGJ4w1dGEkjrGQkRMltxFAZASR2ijuHlbMJzXTlLFKFmiIFGQv+NKbt+jGFTFAM684W0w4aC1kgYuOymi0qtBa4L0nC9C6AB+cG/dYf02/7VBt2QDOJ5oUFSmkkuOWRxqjS8g6ELPEVgohQ9leqpquXzNfTPDxc5b+Z31i0xKEZrNcsXEOJw3UplCMc0RovQcLS1xI9NFj6hqtFU1dMY47tALnN2A8RhUZYqsti8Upz55eUs1aQmXJWZBFRFtd7oNCUmuLd64EG8fI+vwZro+0zZQqiH0g9EijDTJbvBBQK/q+SHt9iqQxYnMAPMcHE0YXETmi0GwoDdJ2t8GsRuzBlHYyoRIa7zYFL59G+uAQOZBCQqHohgEnAr2SbKInpMj1zQ1Z/AOJXQwYMjkWxLvQdh9RUkBhUuoCVSJhrN2j2RMIRVVPsIPnYLag7zu67QakwFQKmSWNalCNJfnAbrNkLiVVbrBqhpUtq97jc0BRSNAiZbKUSJGRsmyxkCXiR0loK0tTK+pGkXNmdbXk5uoG14/IzjGLiqfnV1TzOfPbc+azKUPnqOuKfliz6a5IokPr8jpiEDStJPiBGBxSaVzvOO92xV9YW4TUDMGTI3u0f4lVYF9needRFDWKMQYhLDlIdsNA8pLNukewB5oki8UiTWQxmzCsNtSVYDcUtZLvIlIJ/OgKwGq7ocsBW1mSj9TGYFFIqXDjgKkU2263V4jost2PnpAdqJLK7HzCmYa48bx0+x4hejbbHTmMEAMr35f4XCk5WswYnSDEIh8NIeFzYL3rqNuKsQMjDYaIbepf+Dr9pTRnpwctCQ+yhL4hy4eUvZ4+kcqKV+h9EwZKKrQS6H2jpmUJV00hlXDiPVY3J083CCpr8EPP2VSzePwR85gQb32BbAvavBKR9Pi8rMn9yNjBrUWLN5ZmekI9v02n56A0wUW2W8cPzz1V1/PRk3PSbsXYTtDa8NbmkkO34MavCX3Hw1HzREbGITNRjgbHG0eAG+iTZ3GYywWZ4dnFrnixUkJkwXB5wZHQRF2Bq7C6JcWSITa6gcbUZYKaFCBwvgQi+5DwfUBGw+FszvHRjJSL9GU20+y2nm5MrFYDd+5avvnWCf/22z0yw8wIbk8kG2H5sx885Ycfb3DjFWlPY/vaQrLxghE4ruBi6zn/zjN+62vHLGZlihJTmQJ7D9fLAWQE0p5gKNiOCRcKSvz6ZlnMnQiMrXBZEmJEilwkVrr4P0IQbIdMN2bkmNEq8Qd/+Hd85bWX+Ivvv0dOGinLhZfLJ4r/4k++y8mPP9n73TIhJkZ0+WyoGpUhh0C/y/zhv/l3CAyVAaks0ReQwe/+2qtYXag8MQM6I3OBNMQIwkBUJestBElSZVsWQsmkiqn8PlLMGCFxouC4RfYoCdOFptKacTihaa758ptnZKWRMRNdKAUbGbnfHIgkikwzFfiAFIHVYFivugIZySXAU0tHyjcACCFJ/IPC5fPe7DM/fTTILHDuuSc0IyU459BGsd11CASy3PJo2gqh4Hq1pqlrjAhYldHVlBgDUkikEaQ9Xl8IhRf50621lIqQAm++eo9mMsHWkmRzmcpFQXtsIcNvf+Uef/6dD1muhhJmLxSb0RNdgnqfUZZKtENVtRAV9157h0eXf1fIo3rC2ckZVWXx0Rdlm27JwpJEQqREypKzw0OsNfgkS96QapDSc6gVDzpDyhIXApdXV7zz0iGzBnSe4t1I1VpODyds+6H8blTFbFYxuB6RJDufUWbOyaku3rlUoDnWiOKZDRJdNdy5ayEnhr6HLDGm4d4tTb4159m15f0PbjAq862vv86duwugbMdFluUajokoWmpTGugYHMnvBzOUabXIgqbSHB8tuHXPMPv377LadsynDSJBzhLnHcREO5nzza//OrUx/PY3XkbKQnWdTJt9MyLRKhMsICq0ArKiPjLcOqwZc6RKhYD4fOJ9ejhhUtflkg6JulK8dueQP/9RaZQPJ4rDucKHgEQRo8MYjfSUrV5K7AZHbQxGS45Oj7n7whld1zFpa7Sy7HaFmjfqCkUGlYlj4qW7Bzx4WNOHyGRes5hUtJUBMjZoMoEcE25MWGNYbbcYpZBCA5mmrkkkaluhtCWnQEglgDWrtCf8SnLyvPHmlPo7JXrgeJ6RKVNXmoSnrQ1+9L+kiuTz8193Vuue7c0KneDl11/lIPQ8uVkTYqbSkVlrWa1WjCGQcgEiCTLj2NEoybbv8TmSVRloqiSLTcIljk9OGeeZzdhh5jVKSqoYIEasMHTjUGh+xiBURlWBnCN+61D6kOgCXb8m+4Rpa1yS+OioyKTk9tPJQnEWWuJSZun6ElUiJLXVeOdgUdFOFY5AVgIrEnMh0fWM3dCDlOxyQABaKyRmDxQsab1GSXzo0I1i9JnGzjicH7JcPcPFHZlAyJmYI0TQytCqihgSXb8j6kigIkSBkRWH82MSjpQ7ujiw7FckFVHSkLMk+4TwHmkSSUV8ctjqGB0mKD2njxGP+3RAq6T8dBsjpSDmQhLXSrE4WNDUlkZHKg0Kwbrr2QwDoqrQe+DZ9skF7npNMhVGa9Y3S+aLQ6QU7HY93oMyDaAx2kCKRQ2lm0JgFRKjFKubFbvdlogGKdgsd0xmUyprGL0nkhGVZTqdklKNSJkxjoRdYrnqmM8XRSY6OJQOhJS4vt6ha8s2dlgluXN4RJQDV8s1QZReYTKZYk1dJIupJ6Ye10WSK0Og5DOjkFRWo3Vx6StpkaIElk+mE1LeEd3Ic5/IpDnk7tlLuPWGVliiiXTa41xGa4PLkU3vMWgudmtGn/A5Ym0hmaec0EaSXIIIIQLSULfTX/g6/eXQGveQgpxTySrIRSojUGQR9o1YKtPMXJq0LBIZC6LAFcjFvxOy5eHlhuX2moNZS1tBU1WEHHj8dEXXFx2q9D3j/Y/JdQ0qklc9E5m4vF5hfcXoA3XbcDCd4VzHw/d+ws0QSC7hYmC37XjviUMJjxt78JGQR6yA+1LQPT6nd4KYEyet5rQK7GTFP309YgCrNdYKyIaUBEFKuqD58pslyd6YyNntsmb9u/seHzy/+nWPyIaYI+ud4+nVmjfvNaTkcVEiRKLre7ptwPlQBM39PpcmF1O18wMx9LhQ8riePlvx3pMN3/7ZdfEuZdjEzN9eJbi6JnFdmmGRMSLjkuKpgywjvRc86STdLoHY8g13RusF45io6zIZ3fU7Li57fCy5GuNYtOmy9xxrx0WwpBjLZkgIpnXFsPeRiAxBgUoZsibLgIoWFyLXSTCzkZ989JQvvn2P+XzO9VVHzGVbJ1QENMHBdlXIS+S0b9zKFB0p9sVP+RQKCUiHdxLyCBmSEKyv1yWYNWW2m4FExntPcMUPk3JkdLlMnWMiZle8bz7gY8CHgkpXAp5ntrgUOWgsnzyKuK7jxbtnfPNXvs6tJ+/y4vGU4IaycUh5Hx+jS2zDPitIZYt3CVTGSMV7H3ic25SYAPZRBgJiHkrQ96drswJE+dx09tmfTCZFXzZjGoSCkBPRS7KU7HalyYohkEgcTFqi0vhxZBi3NEaz63q0NFS1IaYttVE0Tc16vaZtKz58fEXfOXyKWFG8Om+/OGc3brG2QYs9LVUoUowFRqEzTa1ZbcqGKwbP4nCCaQwuZrbdgDESoy0xO2ISvHTriOEr32C53HJwcJdbJ4p+KCjqlDKju+HXv/VbvPdgTQ6OZjJHGLjZjoSYsNoymRQDfVXP0LZIVfpYhjaLWjAMO7TWSKHwYyDiIIOpFDGLAsRIAp8Cznva2jKxxRweZGJeN2hVLujF8TG2alCxYJJ98AU3XSWkqBBScHJU8/LLDS/eOeXstEYJjw+hZAim4u8iZ3wqPiuyRqSMMoWilVFIFVBCcrPaFGCIMpwdNay7geOzY6pKoY1Ea0V7eErnE+vlJb/59bc5nmdII8rU5X2QkpzB6BojI6jnAIxcpD7aksaxbOC0JFN8vq/emWN1LkPK2oIq72+mDIdeurPgdDEj5oSWmuADQmZCykxURc6ZXTdgqz3tTgjODjTi+IC7L9wiIUiiYP9zymzGcT9x9kzbKUKWbLbKaHKB2eE95BgxVjOZluY8es/t00OkMmy2HVNbM4yRm2VBU4duR6UKsCTGUCbpqki7k1BcPbrmpYXFqQxpRpaaSV3kRU6WzDap/r9clJ+f/5/Pk/NzdNaQMuvVjjF35N2OumqZZMWhnmKsYu16vIU+7ejdjspo+kFgbVXIH1mR+sjUNNisEUrSu5FkJClAIJbnIJIQ/N6bBCn5QtGTJYIpiYyYapZxiychK8g5El1fGg5ZvJbKBHLMGKGKVC2Ve+noHVaATREZM3cODxndgI89LgQUkTY1RAfdOBa0uW2oU0SbGh/KQMeHHiEEFRY/JLSJtChqoDWGhQWzmHB+1SHtBJUUWoJPPRkIBITONFNLDAqy4HC+QCnFbrOjdysG1yFGCfvQ7pATRtXUM41KAe9Kbadtw3R6hgiJnY7IVjPXU2Is91EXPEKUbfaQQVGGWNYY0ugxtWGwCZkFImQcCZRkQqZeJd7/9vv0Hz5gFhwHRyXfy+qaRrdcXj+jdz3T+Rw/BoKLpJCwVpKTo6lnGFVz5/YLtG1bXlvf8/7H7zOOI42dYLMm7BxKC4y1aGnox0DvBypjqJqKhGQyb6kai6k80Y8FOlRl6kohhMD5SPSCx09X5AwhGYieRlkSkdH1aAtj39FYydnRBBeLsiglqKsayq2YEB2mkpAEpyd3uX3rDo+fPOKj+x8Uub0BU2cenj9Chciu0mgtCcojqoy2ltpOkChCV5gIOmWGwRd4Vih5cbqSpOyxdYkSIxcY4i96finNWUzFX5FFwa9nqSAVwhmogspH7FHsBUMexoFtd00MpYsvZGqLQHD34JB7x5kUNoQoif0K3/ecLkZ2x5oVAb1o6UXEqR0jmVxJJq3i/vtPuBki/SaipSfHYqz0XnJ7Fnj/UhJyZKBgsCdV4o4GbRKjl2y9YBsSQ8gMRcHGLkTmleKFE8XDbZGkeZ8ZQqYbE72PBJeIuQRPR+ALL9SslwGjAj+7gLrO/JrVSGLJEhGR41lTgguTYewdpI7Ness4pCLvyYFh3NINI43WhBj3nqeMD5GnK8ffPlwy+FK0P8+CEFAK+szeN7UPAAKETDwZS8ZXlz0h5GJkJfCDj6/5va8dMww7nAc3FlypyBk3RlabjAuRnBOnM816lbmKgpAzMmd0axGVwccIFPjAegDrBYoAEqwp+t5dkhig9z3vf/CUX3nrLn/4lz+CvQRApvJaHl/1VGtfNNZZgihp8akMJmAvR1TIIi3wGSU8L79wTFNZztcb/pf/p4/IuQBMQoQcSwZPSKWZzSkTs9j/bmPpf4TAJI2NmVlTpEmT2iJN5mKbcEnw9u05z64u+fjZksdPb/ib77/HrbM72KkGH0kxYa0hJr+Xh3oyiRhApEhKHimgndb87Y8+IeZrRKqQskIIi6QjpkDGgBSIJMliT878vDn7zE8OBShha0naS8aVSkg0tjLce+Vt7q8+ImxWqCS5e/uERmXm8wnDODAOHe2kQZAJbo22kt3OlcytKNm4wHffe8Lgi4fRycSbt055+cUFMTiePr0iC0UWmTA4olCMPvHu4xtWm7KRkvtm/2hiuVkFpguBj5ClLBK5DEkkZHR89/s/IqaAMRf8/pe+QdIWoykhnzpwcjDhvYc3TMwUW02wk8hytePk7ICmKqjiHDIpdp/i5p+zae6cNrSNZHSgTCnqvfPkJFntHDl6Zq3kYUwoUzwsF9fXjE0sXzsnvItUdYtRmXY2L3laMe2zDwNVVZNLqg2kTEqBL799hhSCFMe9NxZiLB5RKUUhucoWXU1pTCLFIskzVQmfjslj64rq0O4jMeCf/ZPf5JWnPXfu3mIYH2IVICpe/frv81/9yQ+ZLo5QJjHGHUoaht6jjfp0ixpSBCFIwWGUwQ19yeOUCZENQhqaqkiXpZB86e271HXNetOhG0GKmXEYMPun5kt3jogxElPGxQEhBMEltMwMPqKVKsMn5zFWMplWTNoWhOGwqtAiIExRsmipmLRNiQuZWCKJ0Y9kJG1bM28rpJQYDSRNHzyh92U6bCqCD6TkiFEiVcTozMt3T5ASUtoT4KJk6wsFVyTBZhyBxI2XfLKdMUS499IR2TucVvvYBYhhRKvmH+Va/w/pmKai245oZXi2WaJNJquBftdzePgGblMhk0eqHTJJdIKZaVFS0W+2VHNJdq4EOUdFMmDrGqvLQCE6h0gB4XMZShFIRhKcoK7npAR+cBir9pYBqCsLQqFzYBh6ctKoqqLf7NBGl3umLAW7D4lKVEwmM1xwZJcJJoOEVkL2Ab8L+BGa6ggRFNpUVPOG7bWjG4sFQ0nN7cMzhnHARVeAbvtcwqHrSSqVOiBKhrjj4279qe1i2kzoOsfYjyip9gTCSEqKk+MXeOcL7/Ds/ClXF8/QUlIdTujGLcIVyrNEovbxwDoGFs0E52AIjoBCt0e88PoXePK99xivt2zOL9ETi9SGIQSQAqkVisykbYuHTSRkDsxmM2aLGUl4coi4EFFZcSIrbu5/xN//8bdZny9x0RNnBn1rgh/XWGG4vrxhvVkzqSsOWstN2iKlwoqKxWKGlJm+2+D8FecXA03dklKiaWccHk8ZeoOUCYXEu4ExehBgK0M/DCihGIaAyxYjA8cnNabStLO73Cwv6OIFYfQIKXB+oKlrMp5tvyJmgQIao5lOanQYWXYjMSTqpi1RXkgqozBK03Ujfgjl/tg2rFbX2MowuI6rZSSGxIsvvEjX91xcn6NMyV9McWT0O0LMHB8sOBAwny1wMRHIRTI6myOiYLnp6NYbohNlYys0RhkiIxKI3qOUQcR/JM9ZzpCyLBPeVCQ6ShW9aQmbKJOSrBUJjcwFmf7jH36CioEgFV0ALcCoQCMFQ9wndufMzidilJAjmsjfA7UsSejSRx4uMzch89V7FT/+qOeozpwayaRNJYcolbBhozNWBRojCQNAZDUItrJkcBirqNpM4wGZiBECgkpGNgPsHu4w5H0WR9H1KimYIRmk4FknkCKSgBgLtGHtM1ppjieWw+MTRi/IomY6mTCtHVdXN5ydLAhCM4yGHGJBqSf2YAzN5eWSF+4c0fVbnI8MDv7+8cDjpS8Qj1w8Ws8B6zk//2/+B++R2DscMi5BHGIZfqVYgqaF4r3719w5qnnltkQLuUeDZqZTw9W248n1kpgzLihOVSyNOLLkgInE3dsHfPLoISklxF7+GGVpWKUUiJgZYgnIzWS6nLAm83fvP+S3f/1rGKVwMdHKWLwOGq6vb7CqZGZoIUpujig6YjQoUabJTaPQWqOkwVSaaVNW/GTJdhNK9pxIOG+QYt/W5fJzFMJlkS26ACFK2MsotjvNFw9OeOvVU3KC6Hsm88STi46Tl1/lv/8//k/5n/8v/s+c33+ACvDqSyclMBtfJFOi4ImHfiRqCq3OeSyFjIeQ9MnwwQePIfdEHCKNIBUqbUgpgxCItIc5CLHPV/v8fNbHp5HtpqeqG6TQJZcuBayuGV3PreNbvPP6lLHbooTm8KRmtVlxsJghJRwdHZBF8Rm6wSCVpFpI+m5EW8HFrucHP32K9xFyQmbDN9+4jWpqGtmQmhFbWZwbsWenhH4kG8l/+b2HDGP81FclMnz9jRc5PTWkKJBV2apkSlMTYuDV28fUk7oUYAe3C1zCdQSRkNoQhOHZxQM+/uhD5o3lYDhGm5dZHCyIWbIdMmafAWjQn264iuIhcbgo/jtrBUrV7PoNUiq0EBzNLTlHTg8dPyGT9nEm1lqEcoT4fCMOznusrpjMbkMqNC/vCtyirhuc90XzLzJZgJIRIYqnomypKNEbqmwOlZBIFKaaI9I1lSmPvJwTjVaMXpIEhNETk0DVivnEImXH6CR6dojMW1xKjP0aaxPd0HH31ousux0T45lOK4YxF+kPHucDPitUTkgLSRoChjgMGGMxRjJva6QQ1EZw3FrcODKdNKQQMNZQVTXsgS53DtvSqElBW9UoJVh3G2ZtTd97hJCEnKhrS4olZHscB6SK1MpTW4NG41JA5hG7BxuQPKOTVLYmSMOkndAaQfCJKIvSpbGGKEFTwsorVbZzLpbto1KWvu+ZLlpiH/Axo6RmVklyDggpOJhN6XeRH+cZnXsIZJpKMg4jSSqmTcMwDMQE3dj/o13v/6EclQS1NuSYuHN6xuGiQbYNH52fc3V1icrlOg/JQhip65r50QkhjGQ/IKJD+aKgmc2m3HvhJZbXS/S8pQ8DWI3IxWv62suvs9nt2G63bOIa74Yyd1ZlSK0peWNKFNo0KqBkud6tqvFKEbOnnhi6cYeSGmM1lTbMjluWVx1NDUMc2IpMkAI3jMQc2Ww3tINnPpmgvSV7j24nTCYt6+USg8JvHUZprFY4epq64e7JCZvtisv1FTEUpHrcjAyrDaZV1IcN/XqJF5QQaj+iSKQgUWIKUfGzn37AxfkTcnLkvf0BLYokXipk2dvT2hrtBKb3DL7k5gZb8ZUv/gpn89ucD+9x0EwxWtH7gUYmXFcUNu1shtIKlTrOjg7JZGw9R+w39kYIrK3pc6QVlu3DJ7z/R9+GqzUyRLKIqMbSuZ5EICqLEwE9r4lRc3m1QeiSm+jCwM2yR+uAd4kUYRgD4+gYR4+1O8bQF9+0VMwXc7qtR2fJ4MaSL6YyWmuEjmgrEGNNDhN6H3h68xMCcb/gKDLPSmlySISsiupBWaSSPLu84NmTS46PjjiYHnO1WTHE4m3TKpDSSB9Ljq2UgrqZsJgfgIhc35xTVzUpdcSw5fzyEdN5hRdT+nFHih2TxhKsRkuYVIKjqqKtZ+zGCLbi7PZddtsdm/WK+QKUUWzXPdvt3ltYGWKSpDzs0W2ySLZ/wfPLkTWmuG8QMij2P1CCrJBZkUW5wBJ6v92RtE3L0Yt3+PGHlwQH7Hout56ZFbyxiPicuehgM2R8LvjdRSWZqJLhgM0sO81RE/AZQhbc7CIntaCuFIOCzkt8yDS1onew3hSoxcWQ0bKAHpTYGypFiXZ3MROSIAXISXB7oVgYqGVESD59nQKJlIX2khL87n/0Lb797Xd5+HSJSJnOj/gcGfUB/9P/yTeYtDWNlbjeMWklIQiUFkynFR89OmfbD3z48YrD1iF1QiVV6D058vT8EmMFVgmeLUf+8mcbdmNpAhMZIfZ4d/ZZWMXN+/PdyqdNWvHFCQrRJ4u8J4Lt09dz5jvvXnLvZII2Yv8VElpIbs0n1K8K+j7w4LwnDZkhaKzKDCmSkuBbX7nHf/XHf0nOkcOJZdkncsqk53x/itQxU4AKKwTHAi7XW25uttw6OeT+4wtevjfjxTsHZdcqyqRCaVPeK1l+3hTL714iyJqCBE+KTEDLxHrjmOienGB+YGhnLZsevvfDc06OJK/enpWmRxrIxZp/sxoRwfHJJz2tyYigmFOkpoMTRD/iuo5N7zi/jvzxH32Xhw+e8Bffv88LdSEXvXzrgM0wUqtAVoah69Ai040lvgAy0UuUyUhlIUfefbhkc7MtEgQSWRTEdi1WwHy/bS5XlRDlc5fS5w3aZ32MtpydTsg5UlcaEQ0ozWbb087m3O/38hsyRmjunNacLfbepmwhBXxM+GFEpJLP4zpBbRQuR67XA7vO7TNdJBpZpIvBcXGxJQAnBy2IxG67JiNRlaXzJYEwk4uUWGtevjUjuoBAoKVgPqmRkr3fB4SL1EZAY/HxhvVqwawRkBW77YjScR+YDFfLNXXV0ihDzCPBZ2wrcGOJAPBDh4g1UoBLmUaBFo6+A6krRjeUvxcCw+iorMJWFWeHTWkmBUiZmR1MIQ5I4ZnXNS7ETymw04MTUgzkGOmHnpzSfqMti/RNyE+nkZlMjJ4YezIZYyyVLlCL5/fIPmhyygzOMZ/aAuPZeqzViCywTUuW5T4wnR7y0uu3ePLkMWMy6CRxo+P7f/knOHWC1nC5XiLtnEW7YdU7tDCkGABF8AnyQBaZtdvSNg27IRCGgLUCMTikAIRgPtVURuB9IKaASIkYE/3Yo3Ombgwv3zsly0iKktE70hCxlaEbCnEyC4WhUD5vtiNG7EoBgqBtFNJYYoxYVaM1uBBBFMqZkIqmntAnhZWa5bZQ2UQSxJTQOjL4QhJWOKyypJzwbsQojQ+OpqlxzqOkwvlACiNRaJIvABaRJaYRzOuAEBVCeCYTy4t3Z8QsGIdApSfklPYE0c/PZ3mG1ZZmOiVlGNYbuiExPxJMQ6RLkaQ1TTstETJKMJGa2wcnXGyuuXGKcN2jxo5Jo1kcLzi7c8ijp49QXebZsyc0VU2dBaMbePLkCW3dorLA7rOyRucQMuxjSkpsT1U1uMHhhoStW8YQsJMpQVic87x46xbPnj7EuYGkBIMIXNxcFSqrtQgvMCnR6oZ5M8d7z7RtGceBLnpSWHKnuk0eI93QEXPPqALXw9M99dCULLNRcHF9xZhGXE64EBFoVp2j68HtNtRDx+HpEVkZKrPg1t1bXC+fsrq5oqoFz549wAXPtK1QRJwPDDGXbaCsy+AlJF598SVESlw+esjF5po1MKD5tRe/zEtxwfmHn3D0+hlqWtEJcNGSREbVLUoZjo6OqFvJ9dUlu6GnrizjsIMYSFXNiCTVijZnzMc3nP/hXzG76KmzZn77kI9XT4lV5joumWtLZSty1CUTrgpokQtYSrcobYlhJCWxV02I0lyrTF1PMUYjZNnQCykxVUXYbDBVgzDF+qJTwoeAUQqRFNNZi0YgdY32xzy6eApaoIxjOqsxwqBVTdvMGHY9OWRu1iuylui6oU892Qlqpdh0A0FK0AOqLveoWltqmVChY3PjUcYynR8SY4CYWbodg8x0u035XEWPEprNoAlCYms4mlmqegoyk3Vm9ANPb54QkselDSJ5JkYjJkCUdMOAdx5JscGQZcmH+m8AOvolNWflocReGmZURIqC8RRC7B/IAikC8lO/meYLr7/Al956CSEgjIHr1cBqvSUNI8F7TqNjO0SuNmUSsu0SncgIK1kOGXlYc+kMl77DWqiPz2hEIDqQwmFF5urxhiebHUOAmBStBS0SOcr9Zq9I2mLayy4RSAVaCqQWKJGpdCmeVBYgC7FQiDLthRLMHKXgW7/1Bm9f7fh3f/YuISRCFPzGb36Jt964x8WzLcaClIrNbsTYmrpuuXnwlO/93UcoE3hyBflYcDQ1ZKELqj6MXF4JrpcDpyeKH38ysHM/R84/ly7mf0CIeP4nwfOo4n2blf8BhH3fSz9/DeVrCVY7x+Prkddu1eWDJUohKLWgqSdYLehC5vJ8JCbPwdQW2Usf+dFPH/P4wTlkmM8q0JHL1QhEZN5vz/ahzhnwSeAk6Jz56OOHvHX3NvcfXfLx4x3bofyQSpXGXIgi6RPsN7UpIUQmp72sUsDJvOb1l0+I2WBtYnWzIxnNOGRcGhEI7pxanl0NvHqnZDMlEiRZEPoJPnkyInNiNtdcLj3OZxauTLz6rWO327HuR3oHScIPf3Kf5COiLfj7V+4e4reO3EBwZUodciTGAjwQqjykhHp+bWi++5On+DiWnCMhiAIqEloMZCbk/PP3k1wAOkXe+fn5LE/KkeVygx8ztrIYrTg6njFrmzKU6HtuLrfUjQGZmFWFrOhzot9r9ZWyaKVRRqCFpgs9OpQNU9OeIqUhygEjJEYJTs+OUShu352jtEH4iK4VIWRyTKAEL9y5y/nFmt0wIFPkjVfuMV1YPJnoRxpr6ftxL+2TjDEzjIFbJwf85P2nhJCxlSAKQ6UlM1shyJzOMimXfzfRisomRpGLGiCWKakSYIzCiB0CjZCJadtQWUk3emQaEEIVo72xWGFp24Ksv3PUkJUgpFRob9sNzliOphOePn2M1JpJU7HrSghuCj9vzkIsocrPTfuFplqaNSEFzgUECq1tQbhn+el4KiWPtBOkE1StIRMZOoExgpAi0UEIkXZS084OeOXrv8fP/vM/pm4Vm35k2sCstfSp58tffZ0sWv7iz/6U09dvYVQR01hbvpZRGVkphKgZXJFI+6TIfqCqDUpbJJHFYkHOj5i1LRlLN5bMOGMrpJC886vv8KXLltkkM9MVWUZycKSYyu+fAl1CCQyBEALrnWM+b0hWo0zJ1Jw0LdfXG6aTmiwFuzEgVQFvpZCICqrK0DlK0VNpNAV0YKRGAZUtYnk/ZgQeqQQ5KUa3o21nxBBACaRUGFEavpwzpiqbU3IgiAWvfPFFfnNr+Zvv/jWb7ZZuMPs4g0CMCSWhMtU/3gX/H8i5dXRQAsy3O4b1ioPbNS5Grq5uGPwOlS1udBwdnKGriif3H7AZOtS8xjeCjEK0DdnCpV/x00/+niB6zq+uscZSGcXgRtqm4fL6ouToiYIzFymjhUSNjraqcFGwOL7Ni6+9TT9Gnj57xtXVE1LY0G07Tk9u8fjpMx6eX5RGTmomVYtWFdKaUk9tNkhl8TkwDpF1KPTAnHPJrfIeBaw312WrLSVOWwxFORQzZXgmBcvNmsera6xVNEZS1Q3BCaQVVIeWigplFHW9wFjNdD5nt72k21xjlWAxmdI0c5Y3G5QBhOf27Xs8eviUnBWzxRwpCj9gvRs4mE+Qk4rNkw3bLLl7+0XyduCj1XvIgwlvf+UtohZs+pHVqmO72ZJiYLXcsrzZcng8RVvJplvSWMPZ0SG1ahAhsc47Fg7yR8949qc/xD66wgk4/PJb5Lfu8qO//VPMRHDQGpCOzbDG1BO0kgS/Y/RlwJSiQyaF0RTKqpCMY8ZqRUieOARm81sYIxkHR9f3+Is1MQi0FURf0P8xJuJ+iJPxuOgL+ttL5tMpk1deYdd3bDZXtHVNTpK6qslJYKShmiqy8NhpDQpiiIQxcHCw4OTgkL7r0TiQIBYFlOT7ERUSwW2pZnNmti21f8ps40BiACKttkynxR9oJi39MJBiorFHbJ3Ah56sE0OKbFcdWmpa02J0UffFNNDpnumsZnQjUkBVlcHCMA5o84+Uc/a8QRCi5FORSxFZbMalcUsJyLoA0nOGXIzbkoIKtpXm1smMg4XB7WENSEWIqUjCoidjMVVVQlDXPRerRK0Tk4OO49MZZwuNHwM5B6zOkAITm/npRx1Hc4XWZa2XQ0Kbgvtv2orJpGY+m2KMQRrFbhf5/vfeh9ghXMZpSaUSUZTXVlqEVDLFhEAoS2Vbzk5qfv2b76AF/ORHPyWi+dIX7hBjZjazZBI+CJSK+8DQyN27xxx++Ij1pnTbySliTpADbgyENJKURanEZu1QKu9zt0TxS+X/z/cif9pkPv9f+x/zuQoJBPsN2s//ZpH3CYyRTLUuqHeREXvJYsqFUIiEy5XjehhgzKx7RwqCyUTz/XcfE1N5fz96sinN015qm2UmJbn3hZTQRFKiCzBVkgfP1rz6xss0taUbej58st6DMMoNtIS+PvfO5X3jmMlZYqRkUoMImVdfyuTk0VIQYwSVWK4cd+4oTFVTtxoXYbnOHB1J2Pvjskg0TaE93ZpJzs4sm51gOwZcGNm5juvVDjcmtqPAhUCWiW7vFxp9ZFJpOj+QhcEGhakbgnfFVylKkWiVLjcNl1GyfKa+9+OngANU+QVTNrUF3/8PM8322q+0v84+P5/piTFRVxalJWF0mNqyWW9IKWC0Ykw1791/nxQjLx0dkdLbXHcD/eiIkb18NzBpilxNi4ASsTQZGKRpOD59gf7xJ8yaQ7719iucHjUMg2e5clRWY6QlbDrQira2JGY8vjrnYDbn9GCB1Q3/8nfeQtURYsI20z2gSWFrS7ftaKsaYyJffuOMH7/7BMSIVqps1BCEvXz7+OQWx8cvslrfcO+FO4z9UAi7Zc1DW2msEoTkuHU449VXMz97/xNODu9Ra0nVztE64mJiveqo25YkI9F7kIKTuWU+nbO8WVObRE4jbHu2Q7mnWlOzHRymntHM54Q0IlImjG7vMYtF5rt/bwSZEEqeDxRoBVKRsthv6ovvVSnLGCwzo9Ai47zCO0eSgZwyVmlsA6Hf0gvB/+F//7/lG7/zT3n0UOEuP8GpHVpqrK5Ynj9ivVry4gt3Sf4ZWRwhhCJEAUITQ8Qz4lyErNFWoWTANBU+BMI4orVmenTKSy++xNe++jrKZFpjGX1EG8Nm23O+3GC14uHHH3D+dsukEaQkSKGkNMUsQJYsxRw9/TBia0tOGd8FHjxdoY1meP2Etq7KIFJIKlMgV3WtSBi8shzeOuPpexf86z/4W/7JN17mm1+8g0Tj3EilLXFPvQQNOZGjQKiMNC3rvuRhVUiS2EtJlQY/opQiR+jHwMmbX6IOU14/v+T99yqePLuAr5wW/60Qe/quQujPcY2f9WkOpqyubog5ouqK0WbOLy8oSLZITCNGtYz9QHKBxWTOwXzKs+4c0kiUGlvPCGmk70cefvQYIwzojG4k1+OWCJgEQSV240glJZUsIeRGKfoYWXcrtKnobz6m/3CNkIasDS6vSTmwXa958exFfvWLX+NnH7zLVkaSTDghil0lB9wwFBJfShhVoA8uOXwIWGtQVUbXgkDiql9jdQVZcNxOqduKFAaGvmyEqqqhaaccJ1heXyBCoDYGmop4EjAajG0YBkfKI+C4vLj5uVQxF6/T8cEBVmQuV5f0oSddeyaNxo2O4NbEFEg5cbUceHZtyEKwjZnZ7Iw3X3yb9/70r3nxrTe47q5Z/fh7JAHLyxXDtkfbFlM1tJMJk7bi9GjB2HeMg6TG4F3ATA1KCObBIO8/5fovvou8XsOh5uzrXyR9+S1WYaC5c0hlQU7AqgnjMOLGjCCgsqbWM7IqESMxOCqtEMKSYiLEQF21aKUYhpH15gYpYiFky0hOYK1mGHdkSnPVxaKIc7Fg+Hf9wKRugchyXFLXNUYqptUhZBi9Z+1GlFxDSoRcI7Vmve5IImJrhZSCEDxTUzOdL6gkPDl/RI4QRMKPiSw1gUR0W/yYMFoxmTTgC3OhqTUqSipblQ2g8QiRyAGi8HS+KFJiSEQCSpX6P+aMFLJkz+VEP/RIrRFCI4SBrDg8PKTvBrrdPxIQJMVSUIp9AZ0VRJHQBNgXkdF7qDRECfL59LQ8SIs9TYJI1LahsTV5IvYddmK73TKGQiwTOjH0gvm0YrkthfC9e0dIAdttJGSBoeRTKTIv3J1zfDxByIhSNU2rGLqI0oJJU3N8csDZ6Ql3b99iMpvQNjW7zZY/mHZ899sflgbCCWJlmIhIpIQ7i1yQ7yILhApsNxsWC4tVihdOGu5r8LVmPtP4cWBw+0DWEFAIXBiZNS3eKza7xLpPTE1m8JnkM8iAkgnvK0KJiCCrMp2Pe3Lfzxuz52jon//5OQAEIRH7IOi0B2Cwb6YRshABKWCBA6v4/V+/y9SWTSJyv3dLAh9g9BEhM7cPLSqPPFtH5CBIMnE0n/Hx+YaYixdGYbAavMjF15FTwcknUWSOe5/czitaAZ3zrC5vePWFU37y4QNqVQAzhUwooDDzQCSiKN7G4q0TaJmwWu0lpiVgMglRkKZ7QEuZWIPKgqad8MGjK4w95HrrwWdun9S4MfDWvRapBefLyGa3Q5AYYuB6s+XpzRarA0MoU+ucoPOBTGJwgut1x//mX/81/+nvfoWDl0/JIZbQSykJJKQwiJgQqmw8hyjo0shHD5/tA1h/LlWzosjdci6NrBJy32XnfbP9uazxsz6uL5KtfnDU1jCGhDIGsHRj4OZmR1u3tNM5b95dsBu2IAyziUIrTXAjpqpKLEYHzUSCsGRKQPTY3ZB94o07L6DrGa+/MCMEB6bBWEMfMwHIyWCzZLnsCPUxT5cbdpdXGKX53a8fczxPKKGwlcaHyLAdkLJitxuYTid0btxvsydYY4nRcLGUtBNYb0bqdoJWCS1GZA6k5JmokSAaQlIYmQgpU9cW5x3z2Ryc4le/fMKz5ZqDieHgcFpw81KRg+Tw4AgpIsoo+sHjfUTbltn8mPW644tvvsR07hn6EUQq9K2ciVljbYNUkH1HioKu78hAcCWQO+VCVpVSMI6ByWSC2m9uYkxEUe5tQsi9/DcSoyrUVZnpQyTGyPHJGcvlliEGhE8Y25Cl4j/+F/+Me+98lavLJ2SjMHZS/m0U3Dy7QMmaw8MTxHaLIJZ7ZYpYqyELcjKlUdtfo95JxqEENxPBZ8fF5RZN4I/+9K94++SbVCpjK81m1zOrWhph+evrC/rlivOLFW//v9n7s2ZLs/u8E/ut8R323mefc/KcHGtCoQqoAgEQIgVREtlsyS2r1Q4rWi07HFb4wr6xL3zrb+AP4Bvf+coXbTtsd0e37e6WKcmySIoSQYIszKi5KufhDHt8pzX6Yu0E2IowI9ABWBHuWhEZmVlZmbHPPvt93/Vfz/P8ni+dkJRkO4w0tiq9QtowTZFhdIQgiEQ+fbjh//GvPuHB8z1n58d880sLvnJniVKCRCqW+8ETtcILyWiO2V1f8IP3P+d6M/B/+L3v82c/ecA//Du/jsiJxSwdKH1TKUiXZVh/8HTL7fMZfvKoeYux9nD4l3BhYhwnlBEYKck+8+D9HxPmrxMyvPXWbU7anjBJYiwOEGkqXE6HvO8X61e5jKgKMbvRDBn8ds9+36GUxIVMciNeR7wcC13RwW7/nDu3S15rvU/0IZAlaNsQc8Q7QZSZ6BNlVBe40ZNiRkWLNZY8Ro5PTqjams+fP8OlARMjKvbsng5UpqEbI3Vdo7VldCMPntynGzsmP5BDZEqeXoy88JcoJTFSsWhnpBRK/r9uC5hGCLQxIARZCmKSjEOHlBnyiJ+2uGDwY6BIBBrvMjfPb7FYLpjNZ+y3HdPkcdOuqEetJIiBJHI5HAoKITRVpUlJHHpqBzbrK8ahZ7fbMx1cZcO+Zz5vicERY4GFaalRSLRukMs577zzG+TNhOs7Bt/R+cDzh5/Tdz0qCDSSkDU+g4ul4+2bX3+bd776LteXayY/cnT3SwQDNgjMLnD9R+8zf9SzW9bc/ff/OvqdL/N8N5KHnvnNBTHskSJyXp0y+J7dtEVVFlU11E1DVRuu1tf0Y19qhSLM2zmzeXFauakASHIOVJUmxky/90BC1KUv9mxxg3und7joe55fX2JkpvM9XkGUEaEko3Pl6xsTy8WC1157A5EUn336EUobus5x7/ZrbDcdmqHUDeC598orxC6gHYgxEvGMhyEqykTTzLh1foumreiniYurC4IP7LtETApIZJWIIjImx74bYAooKTFGMcaBLMtnJKdcMnCxuJumaYsQoJQhhITzCrwgi4CxENLIYtly48Zx2cb+guuXc0yVEwlFjgVJEaNAqhLYLuW7BTqRDiWUxAOMMEmCSGSRkalsYqUs07DRpqD1YyYLSxS+NIpng1KJxgoQI2OAboxIIsGBVQmpIymVUzwjBePkMFoXIpQ/YP8PWauUM1ZbvBsJsSJkyfGNM37t197ixz9+zLOLidFn9kPmnZtgU8n7lK9UIIUgp8hP/+R7XD97A50iH3zwCVprjpoFVhTLjJ8SscoYndntBgwKpSD4ErgsRBvBOKlSI50oXzugM6y7QKPLgJTTz435/6ZyJl4m61+qLYehLaaX4JCyZBZkASmDzZkWwTwrFnWNjxERJS/FKkFinEZ2O0eGEphXM9bThE8BS+LNe7d4fD0S+kKVy1kwa8pmafKFrpgPeH1kydLJLJhEZkyZWmg+vP+Er3/9bX76qUSY8noPNVAHlbLYmdRhqEzkQ9dH2ZiklEkxg8zEKTCGSJaFMPniaset8waXFJerPbsh8Gc/fk7MkkUlOFkKrJJEMj/5ZM9q44CSd/Mu8ORiSzcGFjbjYiDFTBaCKSRSLvRGI+DZ8x3/4o9+wGtnv0MlSpZECNg7T91oRBJUwuMjTCnxk2db+n2HlRKQB6tjxspQlEpRMoVSlM+OEB54+eOL9atctq6ISnLj+IiQPRKLy4W+JKXCZ83kE3nX887rr9M24ElYCcM44pIgjB4lBcYqnBeEUGils7bi/KhYcS6vdlQ6sPzrb5F1R44B7wNVXbPZ77BaU2lLW1e8vyvQIB8z5ycLfudbN3HeYXVFiAk3eqytyEoTDzj0WTvHx8zxzKD1RN/v+O6HC958400iiuvNlkVrCRFclGgz4/R4SQQuLlfcPD8lZU9bQbIzpIL3PnrGZTcjhz0+nEBICKGY+j2Xm4HzZUsUGmUkJ4sZUQjW+0xSM77ypS/x1a++xX79PbQ1DP1AUhmBwoeIbSFNQ6FlSsM0TeVuJiHFTEoZpQzaWCCWA0CRD66BTI6RJA/AkgTKQs6abe9p9FRIbapi9eIZMUa0qdBKY41it93xp3/8B/yn/+f/E8/WW778+ilnr9zCGIsLA1fPHqPmd9ler2mbSKJCKFnKlGM5iFQSpBJYXZUMbGPIR6rcB2MmYrmz1Hz2/n1eP1/QmgqpEpW2VLMa7yPvffdf05xK7jav8i/fe8rpjWOOWjhZLsiy0HGDd0hVToFLzg0+ePSYh9eF6Ljf9Xzy+JpXb1TMmjI8VdZwpDQ5BEiS/+Kff4eHT9doo/n1b36dYXS8ePaURxfXvPPKTdKhWHV0gspWxFz6g27fPQMfiCkxjgGRJ7IQNNayG3uauiWGyOXOk5LnyfML9vGSEAW79ZY6J6ZUStdFVviU0dqy23xxX/tVrxfba4KCyU1oY+jXK4I7QHoqhanswUKcCQQqW6OnQHd1RWstSzsHMi6DtIqsQDUGkyVVZZjcUAb1JGnqlleXS1pbs98NLE/PuN7usLKlMi3TuIEDfXUYC+GzkGkd7aImiIHHqwelBFmDGyeUMhhtymGBlgzDvsAgpCWEWPK7uqKchWRSTBAirbUQC6ysrRpG54kxHaiRhcT7/PIBz681WlukkCV+oCnqtBtJwRCwJSMZJCkrIBYFvq6wyvD8+XOkKLvMtm05P7+JP5rouy0IgdGWcfQYbUkJxljx6t17nNQ1Vx89xnUD0sPF0+dsuj0hZSplCpmSkoGTMeOS4/f/6F/xyf2H/I2/9tf5/PNPSTV84+23qTcd47/6APGiY3sy55W/9zvob73NlQu4aWC/7ZhVFS73JDey8wO2UsyTJYbIbF7TdSPdeotpLApFpQ3zqnTLblYbUOXQ2YfSvyb0jBAzYyjl0DFkfIpc9VcsWBDIGGk4ahvi1iHyxDCsMcbCQOlEDoHdOvBR1zMOI94FjhYzNlc7GrOlbVti9Oz6jiF4hFAk4dmM+4K1jxP6aEbdSHxwWGHZbK7ZrCZMZSFO1LVGKcU0Ht5LqemmnimN2MoWmEcsNm8pFDFlYvYlqqUUonCSCUSUTCipiFjqZgYiggqF2JsU0Sli8ojgfuHr9JejnOWCLv5ZrikpUiwFn8SSj8leHnzlkixKD1ZOqvydVE5+NQIp0iFT5EDKg5MrlZxS0IAvm3CfycnRDRpFxJDReLSGeaWorcCogBQKrRe40hqMIGOEAGFKp5QoVkcpiwUjZ8hScLUTPNkHtqGQJUNIPFxbvnzsERJCyuVBlUEmUMrz4NNPePDxxxhbSgmrmSbGkWnbkZTmxZMN86MjBBPLxQkxeabg0MbQHFDIq+1AXbcsZ6ClIomSu9gP0MwTy7mCF0UZezmYvdSWxOH9J4uDEpMOI+RLC2NGZgUiUmmJDNCIhKZkN2ylUCrhYyjK1s+GUE88IKiFiEgjMFFTaqxL5m5yHUqVAdwCtyo4kom9UCidCf7w+QCIBRJSCpehDwKtA+ttpE4jr95a8uRqffji8iFrdgiiIoqidvjCi5hU1MGU4uH7GQ8KkyRHQWUV/QTX+8zH9y9Z7RwiJiKZLCL3zmblm5gTnz1zXG+GQnwTgozGxQnfJaapNL77lAvoRCameJDAKZ7qqha88+o5IgaCd/Qhlc1iFvT9hNSGShZyH9HzZz9+Rs4Fz/uyv0zJ0gcYc6K1ibZKKOlQwuGyJ8RiCf5i/WpX0zToqqU/2EmyMhgMKcBm47n/fE0fenSGGEfWq4A2kmglWuviDtAGtKASGTd5tDLMqpaYPZqabCqcu+DELrixSHihCxU0CFKE43mDrlt26y1DFPzpJ2t22xWZhBbwL9/7jL/17bfYDdOhyNqy3zhOTi1Gt2Cgd4F9H/nJ509Ybza0dUXWFU7NWTaO+fxACfQ1GEnuB0TdAIk3X79dlFtp2O86mhr2ecbytW+yevyI1dU1q+YGl+sddVOTsmB5tMTlQs+augljVClVrY+YNz2MF/zr73yXr73WMo8DCFUekOOIlIrF4pgU9uQUiELT7bd477AxknOB4nC4HwhRwBUv7c7ejyhV6Lw5J3JKKF+eI3GEai7pB8diHpDGQnak5NnvRrqdoJscSntuncA33369BNvdSAwTWXhuHVs+fvKIcXXN8bu3D/e1jMiZnMsJ6xQittYM41jyVr4n5EBOmpACt798j7vpjN0f/jGvn54TQofKhqQV03bFx4+2/PDFBTdv3+TtO/f40U8/4oOnI3/9nVOMCsTgCG6gbWflhDhZlEyE4Pnr336X6tY7PH7+jLOb59ydBZ5fbbl3u8ZozWYM1FaiVMZqyaNHL3i03vLuG7fYrZ5xvFzyNGW++9FAc9Jwb9kiwyUy9RjVErJgGCeET0xupJ3X5OAOTgbNxWrH9W6DtBNNlfGjwFSR1Ys1n1/uePTsCiEEq7klDZ5ag64086bi7MaCHP4bHDF/sX6hNRxKnLXWqGLSYV5XCElRgXKBg2ljmeJUqg5UyU5ejY6qyWgkWRp8LIfV1iiqJMA5aqO53m8RRuOjpBos4+RZLI4ZYuD51SXGKpraMtNztChOnmKdFTg3IU1x7mSlDq6fVCIXqkZEXZSKAyla5YpZs+D8xjlXV5dMbsBUFudLb6GWEpkyX3/rTYbdFY8ffg7jSA4JoWTZMyhJSA4pA0JBPDiLYogIJDFLRCwW34hjiBmZFIv5Ail1OYyfz+l2HdpqnO+p6ooIbLdrlMxoXdxgMUqapiVFgY+ZyQtuYBDeU9eFwPrx+59z1e8RptwzhBGleJ5E8g4Ri7xQm5rPP/mMN159neV8TnW1J24+YPXTB4THK+JJy92/81uYb3yZIWf67Z6rbouQBQAUkSiluPYrTtqW2HcMmx3B9ej2iPPT2yQyr7/yOsE7Lp8/Y7/vcEPk9S+/gkuOR88eIbRmM3mqquHo7lFxsvUbKiFx64HrocfOZwzecf3sCnRA64yUmv56oF+PdNMlN+/c4Evf+BpBSfZdzzCN7HcbRCNYDS/YOlWEHZFoasXT558dxJwiCHgKnThFULrwI1w/keKE7wNWWdzkidIhp0T0CkxFY0+IuiMIh0CRgG4YUUZjraUSDZARIqE0RSARFUpKJC1GK6Iv1VfSGARglWWYBnbX40sT2i+0fjk9ZzlzMNsdHoiSFBNRBIQoF1yO08GmJQ8mtZ83nGcCUpSLPMmSp8lJkLIgRE9wPfgEwhV0so8I73lz7hAzx1zHg+8PUvbEQZD6yBRhNwamEEnCcn5nWTQzpZGqXCyVKSckmVIAm1IgBUnbZP7Rv/8O2w5+7w8/5Wq9ZztMXDSKszqhDCgKqTFlQb1Ysr/aEpJA5ojKge2u52oTEEkgUyAER7e9ggjTvsfUFcMQOF407PYFm163mWkKOKOpqtLLdb3NVFVCW0VVGPl/IU+W/2vq2c8NjfnnUmpxQSJysZsutOSGEIwi4g/q2TxHblTFliOyLBu9Q2lpGfQ8IQTamcEIzSgigiIHC6FYrTqkLMOcVZJGeLxTHBmgFTzaCnzKB2R2Iidx+Gwk+qiZqURE8tNPn/Huqzd4dLlG5Hj4guRh65UOdshD3kyUcugkM0IWm6SQqQzbWpZS6uzZ9gFTSd77ySU+BkRMHMCJVFoxXxhkFoQM/b50kRWRsbyHISbGUBRSlyZilORcvs/eJwwARXW7s6j46pfuEXNmuyvo86rWpMkVqIyWxByZBs8QIz/48DFalAdA+SYVf7M8DF9tVYAqWkmUyNggCF84f/5/srLMPHuxghypgyHnzJOLHTeXC/byJs+ef4xMgcW8LgXNdUVbK3JOmEoSkseYUh6NECxmM3xIdNPIez95yHd+/JRHzzdFIdYGdIvWmWncYUxGacqJcYKTo4b37yueXI2k6MhJ8OnTRxxVdwghUair5dqfHTdo23J1cYk1ArRivUt8570fF2uvrjhetnz26VO++poFqZlXhj/78DPmdmIzXvMvvvMed//D3+JUD4Aip8DiqGJC8OHDLU8uV2Q38rW37/H84gnr7Yx784bjRUtIinHypBTI1hIE9J1j7PesL3/K5vqai8sLPn/U8Jtvn/Gtt28iRWZ5dINxGjhqLcPukhACdnarEM/GHiF0OfATRWUr+TNFjOW0XCl5eP44hFSQIyF6mqomxUjVnLHpPqeuZuyG8iypjcY5D1RM0WGsJUdPPw386IMNRivmbcud8yOcDwx+Yrfa4fsdH3ySuXF+jAaOZg1KBIyWKBHxw4RQCmkW2CohnSenTCUrHj67RuaW3/yNd/n0/mN+PFd87bVTNv0OEQLTFHly3XH/xcfM7Gckafn++x/y4P6Mf++3XqURmX3vkesti4UhJ89mu6MSExfjmvObX+Pv/r3/Lrv1ju99559y3AbCsANd6MVxKJCEpm75G9+8Tf5J4uLyin6KPHz6jJwlDx52/McPHnA6r/kf/Htf4d7pjKEfCBGmbqQLicFN6N7SWMHZ0REow3rs2DuHGyZqDXVtkV7z5itz7t2dwzfuok353rSVZRg8u6HcGx893bDedf8Wr/j/dqxK6UI/BbSQVLMjjIUkIiFmfMhUTVv6VJ2maTTdMKCpkEriQnlUGVsBCZKHKeNlcTbFQRCGCgJMyRGGFULA0o0MXYebPH4UNOoEeYirRGBKkdpKls0MIQRj8PhCESEHj5YKLQq6PCnB3LSEINCyoh9GLleXRKaiulVtcbQ4jxSamV3w/PElYlohpsg4RZRpShefMKX2QR2OosOI1jVWWfY7j1YSLTRCG27dOmO9vabf9VRSE8YtujL4pLhcO2KGMY34XA4wBIp42JfkGLBakyLU1QyhJDpnwjQgxh3OL5m/ck7fWp5ttiRlEVNxLSnpqKxF6IKjR0KOCR0StbD85Ec/4Xd/46/i3v+Ux5c7bh0tqX/7a5x+7V3k7XOc0gz7FVUtOT6y+MHRXUem0aObigbJNHmqZk6eIpOWCJ3p/I79rmOYOrwv/WMTgaA8V9trbF1TV3Mm7xn3Pc1xg61qtMwMHYW4ayROJUR0ICJJR5RJ9JNDaoNaak6OGkyQaGF49PgJUwqcnZ9jpEDrCnNUcrPODVRWkQRYY3FhIpIRSpNjOVgQKIwwKMBPgXY+J4uG/XZECMM0OoKfSCFwfHSTu3ffZD8M7AZwcYeLnpTLBmwYR6RSKFNovCmP+Ojx3tO2bXF7+MB+46lVi22XrPcbbDsnpMDRfMHyxuvsV/+2MmeHXYGSRQ2JOUEsEy6xlIEmXhb+FtUsCYmQGnIoFsicisKWIWcFqYBCvM/FI/roI2otkBqud4rrLmFsxnt4GDI+J7KQKK05Oan5/PM9653nnbdPURYW8wZjFSEW66RSRcY2SpecQpxI3pBDkcZ/67e/jUh/hRQDwfwB/5f/7I/RWfJilTFncKQEWoHSAIkHV125aYSI8aVkdTsM/Okf/AFWZ2I4qEVC0y7P+a1vv4MfA7NaEtNQsNsOZEqMrihgKRfV59VbEiEjUhQoR+m6ekkDKVbFv8hr/BkK5GUu6VBIDVAJgc2w9QXFX+VMhUALqGpVQC0U/HbhAORScHgIP1ZWk6QkIxEyk7wgG+jG4qXOKTEAPoOOiSFDLRRfORasnGY1eMZYsnrp8JpDTIwxUavMgxcbvvH2Hc6OGq52XbFiikJsLCjt8mErxM9EluXPc4KQBGRRUM9T6bgTIRNi5MmzCZmKIniYbxGA85nL1cjtc8N+NPTTgcKZDv8fkZASPkq0kvjwFwiZIpNEIh+Gx1pkfuudN2jbhi5GhpSolMRUhhwkwgeEgf3g6ANcdAOPn23KKeThe5dJBfghI1mAVgkji4hcm6IwxFQTvpDOfuUrJ8npSUPf9+z3PYvlgnpmaec1n10FvnGzoVovefXOLWZNRUoON5U6joWsEUqxHyYyhdJ38fwaSaZqGvLxjCfXG2Io/vb1sOfycs382FBpi6wMOQpCDBiTSUmwWT/BXz8np56UA9ZYbp6ccOPkiBAm+kOPViCw211yeloRQ0YqRV0nbt46ZbP31FXFvttw+spNJpdZzgVJKM5uv8K7+ZjNZsUnj+/zn/zfev4Xf/+bSJvJPtGRycKw7wXvf/QB1xdb6kqidXmIrdYdo2/Z7fcomWmMYPATQhvapuXycsQPe+q6ZfSOsAt88qTiy3dOmdWJTT/gg+fT4VMmt6euDUdniauLLW3dIJQiptKFpg4npTlHQpjQUoPSCCWL0/Glkp4lLjqCK3CRc1OjyfiQiAxMY8npWVvonColxmni+eXAGDJdt2W1fcr5ccvdWwvmTcuyVUz6GCEyu03HertH5UhVaRZ1KYqdXMLWirF/yvn5AqsybW3xMfNHf/oTtmNkCnCx3rPaWZQ8xZqWqANvvtrwP7/9V7neeZ5fbnl2PfLZkwtWmz03PhB89dXbdL2gqgMLtUAZyWy+xMhM43f869//x/z+P/2vSC6jVWJ89YjVkWbRFoy3FonaKPb7kXs3LP/jv/U1IpE+RDbrget1x2rbsRkiRiVWV9dU2VHZYic7OppxdChsHcbIo2fXPHn2AJ3h5q0b3DyeI21dMngh47wjpoSMkd22Z7d3bPcdWklqI6kqaJqWxkpuvHb2b/uy///7NXV96d80pYS8HJ6XmEPM5V7Qj55hGkFq3L5HC4FQAqU0OUl2+z2yMqja0g89bV0zTRu0rhAUsq2QGalr5rN5UcOEpmnmRVFNmZAV1lq880QhkLoCkZnPjvHjVCyKSuKSYz5bIKIoXVqMWK2QTlKrGmEUwzix6vf4MKEoapsWGpshDh02wDA4opD0vqYXxfkUveeoEmidGaLHk2nNnBwMw6RR6gitAkq5Mph2I34XmIuG09kMwoBSNX00bPoeJx0ed4hDRLQ0CCpyCEwxMfqA1YpKwPHRnMsXF6Q4MYxXvFgLplEw2OLWykykEEkHp5kHcAUMZKsiKkSR0aamv9zQf/Kc9HDL8b073P67v4P82j2iVuz7kdBtqclcPXnAs88+ptt3vPHlN/nau2/zg/d/wmZ3yRQdqzgircFKSQwT2/UeISR+iMQId26/glCaRkuGaeDy8im6UggZMCpB6ul2EwpJTgGlFNIqZk1F0zY8Xz9FaYhuIuZA3/dUpiJlydHpkmGzI/YOpSTTfk03TfgsUNIwW9Qk4ZFGk1KEJNDekGMgqAlde3w2mNoipUCRaZqKcZoYsyMIX8rMNRg9x8ee3GSu+2dcXayZzxrm1ZIgpkJqXq3JOkCITH4EFdE6o3ShDw9DEZW6nWPsA82NhvmsYdNfsdnu0dagFkvu3b1NOPnFpbNfDq0xlg6wnCUph2KdywWYkMShuymVQHXWEAWonEkhorQuN4ekSkj18MCNFGUi5EjKoFJgGBRpblg7Q57XbLPi/SuHkpJaZxaVYGElo3e8WE00s4rz8wpzyIhkShZAFF200KrChBsHghaM3tOvN6TkcePI2A30XQfbSxRF6YkZNp2lnnk4lFGLJFkax3sXmlePa+o04AMEMttJsjSWdmloast6u8eHwOV6S0qSZVNRa4tAYCyQDKOD0SeUlggRsVaQkyw2RSlRCMLP9LH8F+NlP1sH4yMCyUuuRq0kN2tYdYXnpsloClVOZWhqS0yC4EGpWEAhqlAhRcErYnRR7VzMHDcVjU3MarCyJpia9a7HReiCYKHLoJGkJwfBUklOjjS7kLkcMp3/OezfRUklElMW/PTTC37rK3f44NElKUVC9sRiSyflTFWrAgxI4EIht+27RIoJP0WySviQIRZF7YCpObxnL82VAoSkthnnYbtXPLjoOFvO2PQj/VikaIEolgZZbKI+qWJ5pAyBUoEMGSkFX3/tjLffPIdasN04Fk2xD/lpwk0JIzPDlNhODik0Hz24JIWA1AItBFVdgWqpRMNkDZlSRlzolpYpZ5JX5JfkzC/Wr3Tdf7pCK01da6p6Rk5w7/wYmwX/wd98nel7f8jDYc+RP6aZzrkKO3ohi+06yVL6KzXKSp4+vuDkqEKIwNVqx7QtDzstywO2oqeaNcyUo2kUL1YjtbFoo8l+IgnJ9dUjbrbg9pKuy4QU+f5nj/lrT+9yvNAcL+agJbt1xys3j/HO4yhl846a3/2dv823/orjv/wv/jFz6ZgdFXJqCAV/7rbP+M0vv8t6u+Pzjx/Qnp7iqlNkuIaUUNqwjprze6/zTdHw3T/5Ht2wJe9GlkuDFI6x8ywbi8gw9D1VZYGEH7Z0/cB6s0Fpi60bvE+8uN7z3gdPeffVikXbUDU1PkV+8sMPOT22vBoE476QDPOh+DYLQZ5KPsVHVzpqfGSxWKB0TYz+4PGOh02RgxDZDytUdYXUhtWm43hRusCMslxfbdBWMk4OKSVf+8o9Fk1FDIn10HP/8YbHF1tIO6pKcjJr2KeJrnP4DFOIeC+IIWKkZAqliHpRZ27tFrSVZFbXLOYVX311xvV2YrNPMCmeP7vg97YrKmtLb5wBKyTHN1rO5zVv3DzjN79yxnbv+fzhQ37w4y0ZRV1rVtdbjIbT45PSbyQS/73f+go+J6ypSTlAjkyTJ6XEtp9IKJwfGPuJ3a6nqQ2zRjNras5mmjvHxyR5xourjgePL/n4/hUPHl9RVxprKoKHdiZZtpbjoxmv31qQ1QnbXY9LcH11xTAWO/40eZz3ZCEJsRTKShmRQjN4yegjuROk0BMQ/43sP1+sX2x9492vcXl1xegdwziUQ3AEw3SoOkoCrTIil7qWGAOQqY1FCo0go60hkEneU1lLcoF5PS92SJU5udGwmJ0ABiE0q/UKAZhGs1guWO13ZcBTGn/onK1NhfCCFBXSWpLrgYRKiZvtCX/l13+LFxdXrHZXbPsVq4sVmUD0L2nIAomhMhahEtkPGKfQI4z9gKg0sRI4BSkVSFlT1yW31u+R2mKzQdJgTI0wgsW85vioxk2O9XZDNw4cHc2YKcORMGSXiE4SZOEm6CyQ0qCkoqo1QliUrssuJxq8HzFGMwwD07ZHC40Wmqvra15cdby42LGdCv1RxUjIAW0UyujiDEsZ4SMqOaLKeDyJjM2ZDz/9gNvzBXf+O79BevsOffKw7xBuYvf0EU/uf8rzhw9QCJrZjNX1FWpWYyvL9DzSTQPSQN1UGFFgJUIWtSjECSksD+9/gswa7ydMrUh4YtejpKCtW9y4I6aMUmWAkkhiFAxpQPjM8awu0BjbEpJgvfMkoUgisZk6onEorQtXIERcAp88+AElHGGaOJ6dI6uigEUlqKuWq+sLdJLg94hUEYCUFdlYfAg471AmUTUGpWqil0jvGKYVLu6hlgRTDvesqsgRjmYSKSH7RMgBguBocYP1bk/KDVJWGAmanuNjw+Adw7qnaWuEtmhTsdn0/PH3/7T08P6C65eknEVktCSdUUkh8GRZmrhk/rnKEkLAqYSShiAEUhQ6nZISozIZXwa8ZBAyMQXHNI1M3YboIht7m/Mbp9w4ikyjY1oNhJyL/zMVnGqWmcdP90wpIwfP80vP3RsSRUKqSGskdWVorMFKjxiu2W2ueDpEnq/3vNiObDvPpktsh8B6iHRTZKHAprKt733EJ0iTJEzFpplTQuXI2iWM1jQ5EYLgS1/7dX77GzfJZFbbnn/9ne8zjAPvvfcjnm4y88URcRpICMYgGUJiiolqFNQWpJSHcK1gjPDnjwYORHte9hAfIH7l14fo0ktRLQNWKmYycXcmeLjLBd6SE5qIBQwZI0Xps8mJTAF4JAE5SLJIICNCKpSoCq0SyXZ0XO+L0jQ3meOzWwiek8k8GxXN7IATTwVpLXIiBkmTBW/MS//SymW2LrFPggaJzIlPnl5xcmPB05VjP03F4ifSYTgTIIv1UGXwMSPRHM0LIMRHjxISJSQeQcoGKwWnjSRk8zPFMQuJ1dBYgyCx2o60MvO//Ievszy7x+Nnju//9Ak//ewJ19c9ViR8Ll1GinwY2iIiFRDC3Gj+yq+9yiAisZ8QUWG0YegiEQUhE1VCYHAhYW3ke59ckESxpJ2dH2Ham7z/+QUxbggpklIkZ09MJT+TCIgsUKqUyn6xfrXr7KQ+9GVF3BhI2uBcKCWiskO/ec7+6Yo//PRD1sbx9d+4R1QBlGGYJvq+Z9a0kAJtlbAGKmvZhsxxW1FXEtnUjJPn1dvnyOkFuV2ijeTkuKUxmn0/4DJMPvCtr73On/3Jp7z79ut89OkT5rXlnVdv8vrdJd2uY73v8ZPjaN6WkmBtSClRScWL6zV//J0f8uzFDpLnK/fm3JhrCI5Fq5jimqF7xu/9X7+PlxUpJB4/u+A/+yd/zt/59m0WbYVIkdX1hv/4v/ynTA5qW6F15nhW8d33PuHe+Zz5TBEXFUobpjEQ+z1SWpCKmYz8o7/7LT5+csWHDy8YXaLrJi4uJv7Wt34NoyybfqAyktOzJfvtwOOnT3j+sKOPc/opsNv3hJiZ3FjyXikS4khwQ+nMQrLvf96blZNDEVFSUGn40lnFq3fPsEaTpC1gDB04vjEjRkE1a/BTqXJJbbmnWGV55827vHrrlGEYkVoR3EiWDYtl4uJySxAeIkil8D7R1DPy4JFKcrWeuIgZxI6TxQJUpq40pwuFd4bVBroxMXmP1Ao/ZeaLis8ebglxQ0rPigVcGKSgqBJIRpd5dtWTiTx4tsFoSczlOSSVpjIGYyQpFiT48rjlZD6jaQ2IBVpaNkNgs+8YnePFbmC739N3HUppBAkhBHWlMVogjWaKiSkEduvE5WpAPNogdMJikEoxrwWLRYPMin03EoGsNJmE0YZaKUgG5yNCZVCCNGWUAi0yIX0xnf2q1263wbuRYRyIMSCUYoo/txfG4HHjREoj0lTkBNoYjKqYVTXrzQpVywNdNdPYijg62mpJbStimkgp0VQzun4gxKl8Dkm46LheX7GfJqLI7IcOo0o2CEoUZNdtWJ4siSkRogOluH/9nNUf/QvunN1DqRqRZiizI4lIcp5GSYSp2Q09nojOGpciQ4zM5kf4wZEYkUSwHiMCMhi0OSIA0jaILNFaMfg1IWtyFGhzwvhiQEnB/PgG42pNiInN6BC1xCiN1JqUPcookBKlLSlOxJQJYWB5vGS761nYOVHXhOxAW4xQnJ3eoJv2PL+4KmTpJMjpEPwRZd+ckyCFMph5kUiqdIxJkdGh2FOthpPjBtNIzJFis3vBEAIVmQ9+8D0uPvkEGwMtEm0rhBJsxg2f/PAx9WxGNauoZ4YoIrOmBpewQjAOHuc4KEalEzFIRQiRbBRKSOIICokUGuf2pdPOKELOBOdwLvD0wmOE5rhpMRiqqiUIScoTjkSWh97hoGjmLVVtuLy8AFH6FWspOZ7P2E4TLx4+LlT2RtP7gbqpEWSOZsfo3NJ1PWgITBibcHFkGHrklBHzBfWBjZAVWFOVmiYXia4HP6C1ZRhA6QaJodsPhFzQ+W986RWOTzU//NH3qHQgMxJ8ICSNMBIfenIaqStL329QqgKhWe92v/B1+ksZzvYBFqpkvqIAhEAkWX4jZLF9JUnwCat1sTgcaI4hJ4QyRMFBOcsoWTSOznkmF/Cba5SC2diz+UHEdT3eSlKr0D6RpS/f15jYdpHdfqLSGa0iDz6/YJFabi4hJskqyIIiDYJ179mNiW3vWfdw3UeikFRScnI8497rN/nqzHLnbMnHH3zOw89eUBd6CJPPuETZQEvQQvBKK9h6x4NBcENGpsry7PkOvnWblODq+hofPDklJg/dduLJi+fcnGfGKBlCLm3iSeBceb+kLqCSvvf86Hnmqi9I+nTInRWr3wH3IfLPIRlwmNRKp5kUkif7xBQEkoBFYrOgohAJJWArWfIbufx7MSWUKOCMeGiDT+V8E3I+dI+VMHxMAT8Nh6LrzBQzmyQ5U6UsOubyeg5/Ax8SRsCtGm7VkjGWIH1KidFLHj/b8frNGR8+diDLsKgPw2bOmSjKa5YCWg2tNURXTq6VLD+nVEwbUsFRW8ozOVgSE4KcSxnhy/fr9rKhnkv224ecH9X8g7/1Fv+Tv/c3eHK14s8//Jw/+dFjnr7YEFOpQ4i87LyD128vObuxxFaazT5QVYowJXKIZHH4kTXjNEKCzTDx4f1L5OHfaOqKZ5sd/fCCxewuKnq0Xh4yRwJiQukZShyhVM3LZOEX61e3So4oE1IgzgwpHDKQJC63kte+8ms8/eQZqwdr3vrqOckKbFVRGcOsNqSjl4WePYuqou82JBRv3ViwPa549dWbjLuJblRURjGbt+xWW4buihwNYdEyOo9Csjxa8Ea2qG/d5c/ev0LJTDdOPLrY8ec/vuTd15eM08hyPgMt6QfPbFayU8NuIufE0wcPEUJzZ6H44UfP+Pz+Y7721j3Ob2XCMPDuq7c4WZzwJx9e8uFnTxj6zJUcefqspXrlFKkEy9ryP/uPfhvnEqSJ46MZMSZWm47tas3nz9cYIfExcDRvmc1aRt/hQ8S50hHzxo0FxwquNh1IgRLwne99wpffeJ3TI0ukWJFNXbPZjbxxosEEBhdZbSJXqz32WNH1E0IqdrueaMp9uJ9GZrPSHRSzxOcMQSJFRpG42DjW+8fMrQQFy6Oat9+4x7w9Kiq3S4jW4FNgcpHkwRpJFp7jI8vNhSERGceMNoaQBOfHZyQfeLbpWK127PoRBMzn6gCNSodDNsF6KHaevAaNJKVI05S+skprkoRZY3n7jTtsdyNX645+mpj6kfFA1xv7oqRKpZGyAJkE4H0p1HVRIqVgnAZSSlip2FWB3ZSZN47b50uaqqELHaNLHLcWPWsIR3OSUIzTRO8c/ehIKeF8ZhgHcjqUCcuAkTUhBoSKiFwRYsnUhVFzudsitEQJmC8qrK2ojOConXF63FJXJTqQYqIbHShTIFEpllPyL9avdF2tLgEKwEYWKFbKHoQhuEzwHj/tsZUixFDy4dagjEKIUsnQTwNZK6RWuOQQKhHyyOgGpJL4MHFxGZiCp2oNLgdSFrgQCSGBlMQUiX5kSrF0QYpASiN+CiDKA18rTbM4ZvQjXer46MVPmXxCmgoIGClJKpJDolICq8p+ZFx35CRwObJLVzSVReWIiYFaKqKo2OfI4AdMbklJ4VyP0plhGNGqUMPpAvO25no1MJ8vuL24w/MnF4SQ8FZw7dbM1ZwQHcYKtFV0YULlSFNXqKx5/c4dPtx9QqtglGW/5YJnDCN7V5GURNmGvIvkKWKyIsayR0mUPbE8HPyYQzSoO5AqQ4TkI7XUGNtyvVrz3p99j/O3v0xqLMmNbHc9+27i1FqsUaXAWSaEkVRRUqWMqsohcoiG5BWVtkWJz5pYdr34GMl5T90W5bBqG5SQ9EGU/VDICIpLbegjyh761ua2HGTHjMQw7T0tlpQGuoun2LamapelymQ+Q1nFZrdh9ImQPDUWkSLdZksKHpUzSEPMFqkVu35C5MRnj59jZhUDHuGhsRV4iZ9A2xYhEyEVV1pOmkzN0AW0MMTJE6aO5VFL3+9QukYpS+f2eCa88GRh+OzB53ztK+/y2p27XD5/jB93iGyICLppRNcGITIhiEMn8YDWLbb6xXtpfynDWT8lZm0qsuJLIsVhUEhJoETGhUAlJDkbJAebnCoWs0QiRFDCg1DFxpUmcJ7kO2KYmAbY/vSC7AulTCRBo+DOsSTXEiOgkYXoc2dWfLgJGHzmkxcjP3wM3QSjh5AjEoG1ipNlzZ27N/jNO8e8cvOY4+OW48WM27dOWSzn5Bj417//Hs9wzCrLlDyrsQwsRmZUzvgELhXE++UeLrygXQpAMXZbpiiIk6c2uhCJcqEfLhpoaoHKCqmLZ/d6LNCLEMElTRUzg4M/e1IerqWINf3MwvjSvgj81/5b+UW5Ufmc6IIqubGcUQgsiTpn7AFJL4RAWYnIgpw9KasCaUGSsiOjWR4ViGg+dKyVGoGSDUxJ0PUOkTLpkBHzSbDXgnkuqlcZIBMyv/yQZFIsr7ii3JCHw1d0eb3hm3fe4GOxJqTSd1e60l5G6SQpJWIW/L3f+DKdspy/cofXT2bsV2vc2BPimovthnffmL8sijuouYlEPEBn/MFSK3j15gIlEi5FtmPP//MPP+Pd1z1vv7rk7/7Gr/H3f/ubPL3Y8N2fPuDP33/Iwxcrgos01vKNt27TTY4mS3LMUGtCigQJsYtUNlMh6TvHhODTyw37bjq8/4K6btg/XyOk5O7xuyQ01swY/EQ3bJhYkZLE2obl7C22/ZNfxqX7xfpLlh9Lb1/KILQmeYmWgq987de58+3f5Yff+wM+/s4RVVLIOpOco2oq+u0GXRlEKh1/xsA0OZpZDanYXC93kYRkP0Yyms5l1puBEBzSB5paM06RmA99j8GRouCo0iznhWgWkuTJas0fvPcpN+ZvoRvLdufKCfU4kZgzuszGJbyL/I/+7m+wHSc+/uQJIU5cDIKffPqM18IZR23LkZbcONJ8++1TvvnWTd77/qcYJfnp/Qd8+Okj3njlBlVtkVlxdmNO08yorCJnjcyeO6evcL3r2e0HrldbklI8W68hF6WZBMOU2W57hBZUNYc/g/V25Ac/+YhFqzk/WzJranbdwBRCgee4WChyoVRmaDTffPO10n/JAiENMWS2w8SjRxdkkTFKIo3FB8k4BZzr0VJihERXshwcIrn/6IIHTy555fYJ80PnW20bRK3o0oBOEmFbdv2WbCv6KUEuFnAfJZerPUlKxmmkaQ1CC4zWIBMia5yfMLohhEBx8Qsm5wg+4JxDkrFKcHzUcnLcYpUhuUgtJa/fWpYS9JiJWTJMAR8nJIlFuyguByRaKdarLU+vtwxjOUSYXEbLiEfRyIqzswWNNQWEoDWtVTQziQWkFiVAnyRdDyfLGiMFUpbTfJ9LVYHRFVKWHHiWHA4bDf24QyRB1wdGPx7gX2AUSJ05Xcw5ms0JsXwPhRQoFLWx2NqQQ0Yb0Grxb/OS/2/F6p0vKHEfS+luFihhmUIgy4C0kZwkLimMVhhpUHFGywk3Zgsa2fD06gm7YSSqokDUxhJywOPRWaGsIKQeU2uEEGhpmUZHdh5jDiXSSjBKDcLiKeTsat7QCM3kMylLvJPcbJbM6wYhI6v1CplABoG0Ld2+Q+lcevy0wMxb3H7ETQ6DZNm0jNFhq0zyiSZXmKBQWZKDY9KaSGTMgZAjraypZ4dT4AAEQRhGKiV49vQJTbWkmRmG/cg0OmSsSKFCyZbl8hhRSfT2in63ZQqFPfDR/ftsx55kE1pLcoqI5FE60k+XCGkYxoksW6acCZRqIIk4sBhEIVYLAblkbWMsvY4hQIoweMfqeoXf79lerJjdHNiuN8xricBhlEercvgTdUJEzVF7RNeNCK2QyFL55HqCEGSlEYCqK6wxOOfotx6ti220bhS+d+z9QCZCTshUKghSTFhdoYRGaMWsMfTdjuQdU9wyDI5dt0JpibHzknecIndvn/Lk2SO6/Y7Bd8XynxJYTZSadfK4GDBGcWNxxCt33uCnDz5hcBONqZAhkgZNjpGcAs3RjHe++nWSD3z+6Qdcbi4JMuKHNVaApoGomEKg7zrcfs2RrqhlzZPNE+yN0rcXR49NNTEEPn/xU8IwcO/mXebVMX3u6PqRdt6AzwdHU6npkqIhxkCMJXrzi65fynA2BUcuyTJICikL4CDJXNCfuZzGWK1JqWQFDlwQRPZkin0rS3Ww3IHIgRw9tQ+oxYxPNo77fsdJgiMl0QJ8gJsB7iNY9aXAeYyJO8cWHyL9lLFGsGgsy7nktbsVTVWsls1MUOk5N84W3Dg75fhogdXldLOysvRUhExMmb/x73yLWLX84//t7xGzIJJ5dS5oZaH6qVzQ+oHIqRVso2CMGUbP9XrLbjdiGanrGW99+U2untxn03XkLJgmSVaJRke8L70cUpSCvMllqho+vQyshwQHG0H6C0zGf+Onn09m/8Z/jzGhDwOS4WXerIBFRC41jBmPC7EALwiIVCyNPkA3TFTzlpQlIhePeE4KhCMdBlSVJmKhwCCyxCeYcqFgtpS6BXI+KE6HF5uL3VGIcqJUfDCZ/Tgy9R2vHBl23UB3yLH9jAwqDnJfzFQh8Y3XTvnTh49guMH/9B/9PV6sB05PLLLvuFit+dPvvsfHn31ON3h8ouQiVURQoQjkrHj1/AbJKUKc2O4FHz2O/PDDD/nal5b87rffYNEorGn4D/7au/z3/8Y7PLrc8Cc/fczlixU3T2fMqpopRpKQmJSJWqNseY+HbQQ5kpUipcAPPrsmBlBaIUSmriuGaUAIg9Q1L67vc+f0nTK2psDot2jZMkzPqc1Nrrbf+2Vcul+sv2Rdr3vwnnZe0+06NpuBm6dz/vn/+//F1X/1T/j++4/odj1Gav7wOx/z5pdusVgrTk/n7IdEv+1p5zXaa4SsGSaHkYb95Li82rF+ccF+FAgpefT8Be/9BH7j67dJSZOyKHkgWxFN5GrdM7nI86sNJ4uaL7+25PnlnhwzyXc8v75iMW8xtuKo0SxmktXumov1RC1LOH/qHEczy9tv3uH68pJN1zNGxwefvCiU0IN9WGiLShJrJLWWJFGRk+bh8w3x0B2iHkoWjcVIOL9xwt07p8wbTaVnvHI+p/rKKyA0QkY2246Hz9c8fvoCIUEYhbY1QzfgUoIoqK3G5+JgWN+/IJOoTC49NqW+HikdxtTcunHM3Vs3WLYWnxK1NMzncy42a44mzeu3FhhTLNLDmJhCYr0fCaJYZlzX8+q9MyqVGfYdfnJorZBGQkyMITJMG7QyXK4n7p7NyH7kdD7HO0/bVORs8d5jdOaVe7cYho5Xbh3TGEXMEecTOUekqPBhomka9qMjRsfRbEZyE9YYrtcbepfY9R1kxfVqT0iCkGDWGG4s5xxpy9GiwvvArAlkZgxjoB9H5jONlTUxJhaLBe2sQWmB0RUhC2KEHAMieRCJam5RWTGOEWUEwQd22dPWFXGcaI9mCKVQslgZc06H8vGB2bxkCZ2PZKMJwaMP3WfHsyNylKhzjTKJGAU+gc8FuhWImCQxRKap9PhpJUGpkvXuJxa1pq1/8RPmL9YvtqZYNn4hFTKzlhphQKiIPmRmRZJEn2m0xghBiHt6L7i7OCIqxS1zCutLuuBQBow+dHQmXZ7xMR0OonqUEZQ+KYVSEiULIjpFX8Ak1kISyCxp25oQEpMfSXhsXbHaXOLCjvmswbsemWTZr/SK43rJNPWk6JnGiSzAh4QQGnJCiMRy3uL9VEqj04EoLgS1qlAounHi7GRBChYlwAdDSpqqbmjrOcGPZCJaV/T7EdKA0pEoPMvTY7Saszy+wdnNc1abK8Z+x5oeHyPaGvoU8apnIhTo+GHT+BIq5qYBEEilAFF6tWIipBIZKSTaQgXkAFEzSpNzKOqnyIzRsXECowVjigxDz3V3AcsjVtebQrpUYBVkLFMo/5Jua6KFHDO9m4qTTQhSTKSUQFFow4lScxUc52dn3Lh1g+fPnzFdT4f+WkVlDTkldN0Ud5QLjKNDyrJnHVPCjz3j5LHWYKQ8lDhLgoSr7abEAZxDKYtEFWrilJgfz/DeI2vNOIxsuoFqfcXdO3foP+tKDZcs++JGWXTdIoLg4eeflwMmFErWWCEZY8KJCKpnZisakXn17m1ms3d5cnHJs36Fs4pu27FcWJbLO5zNbyKT4OrykkZqrp89IhEYU3lehM2Go6NjmlnL9fV1+TPnCiQwFR7CL7p+ScPZAfghDpa7GBGiFO5mIUgp4/Y9eYyoUaGsxeh4UGHKKU0UmSlnhilzuZrox8g2BMYpMzhBP2WuI5wKwXkULEViB5ysEs/2kY0UGJEgSfpW8O98Y8HoC71Pqlw+4PIlSEIXRSk6+j6z8IFhmHA5o6TF2hohNDEFckzs+pEHDy/LDe2Acx9jLqdGhwEnU/JQScK9OrALgiF6Li83/OSjF/yVt06Z1ZHX7t3ifGnYTvd5+vy6+KOTJHqB8+lgs8s4ItOU6KTm2a50cMVcqIkHaaoAPwrtoqwD7+LgZoQMMkPD4e8JDja6MrIFUV63ySCk4GI9orRlNsuH3oiSTUu5WBtKz1go/mJ5CEtmkLlYhBazBbPa0Y8D5IMqlhOTlEQhaLNH5Z/bJlMuit3LbJzMBVDiMoDk6YuO5aJle7lloQVHCpyQTFnSe/C5vKbd9Rr16gl/87VzwszwL3//X7H40lf5X//v/o/85lv3+Gvf/AZ//z/8jxj3ex5+dp9P7n/E8xfXrIeeEEJ5bxDcu3FO01a8/+Iz9lNgtZ0QCd776Dn3n17xu7/5Bl9+7ZSPnvRMLgEVd268yXEb+MGDkTsnx5zOJAoLWbLxPXXlMcGVGxGRIWd2RN7/9BJ5KJiGAjZxPjGrTohJM69v4INnvVuRheSoeQcf9viwJ+aRZfv2L+PS/WL9JcuYQEQQvccay9lpiywEINLe8e1vvks7U2y6PQ8/f8oHD56SU2Qxq5HacO98xuQCp+dLVPZYq1AC9r3jxqLmH/ztt+mc5oNPX3C17vj4YsPmj0funhlee+WcJDJaaaQWVE1FaxKnb71KzvDNr9zj++/f57MHO1JKfP/9h1RGc352g+NGoWVieXzE+eIEqRKzxtK0ll03cVtK3J0Txqi53q5ZX1+z3XaEKYIUaCMRMaOEwTuPjwmrM0ZpGp2REoKPDNHhs+Hhiysevbhk0VpG50Fo2koxn9ccty03zk54/c5Nbp2dcLnesrreoIDT5Q1Wmw59ILHmZPHRg9SFVhvToXOoEGqDk8haoHXNxaqjthKrM1lKHj9/jrGWRVsTg6OuBEMPk59AKOZV6bPsdhfcWMxIbsApzb7r0UoTXWDaB6pKE4NHSsU47ZnXltV+om4MPgwIEWmaBdPkECJjNDi/x8riTOj7Ee8cWVsSsJhpksyMw4CKAqNq/HDoa1OJG6dHnGaJVMelsB5NCMVyllIBMjnv2Gx7qkoVj7ZQzGaasxtLlIRtP+H6xOKkYlYZnjxZ04eR5XJeKMEeuj6hjGJeL+h2jkhiHD2zuoGkcGNESkU/JWKkHL4FqGzFtveEJEEryJJhOlCXkaVqRSaaytINI81M/AwhHpxHKRiGkRAjVPUhhxNprGEMAR/AasH58QItMkp/0RPyq16vnd9Fa0PXdcznc3JKrPd7cp+oG0tOicVMcOf2K2hl6fst3ndcXr3gRx9/gLUGqTKqaskhEworgWnYU1eK6H05qs8JssRIX2ipaCY3YVTJtYUUaY+WZRAIJZbhvGTf7Rmmgdl8RsLRjZGUJXk3kZ0sQ1zTMgyZV195DSETw9TRDXterK5IPh32ZBljZbERC13gXcbS1A2b3Z4xJWLMCCPYDVvqumQjQx7RypJyUWpSjng/cdQco+uihqdAoZHaxLZ7zvXDZ9x/WKBxiYjOqoDYHCQf0EmRQmaMAYVGCkWOgn4KzGrLW2/eI6UjHj++xvuACx6lJEJIcs744JAIlCzPH6VUidSQCz5eSJyC4/MT+uTJwNd/7ev02w1XwiBlVeqFtMQLVSpJUkSnQLffo4Ut97AESqoDDCTShx6lJVkE1FwgkTx5/oQXV8+JyVPVGhcCKQWiEHR9T2Vc6WEVEoRgdAmpDEnBKD3qaI4SoLXCeQ+qKIyPnj+jbWrq2RLvA0pYrBZIJlT0xd6pIViYcDy9vmLpF7S6IgZH27SEXGjvp6c38c6xur4iCc/kA63V5DAg8USVkQnq6FH7iXrMnJ+co87OaK8FIVV0Y4eVS2K09PuRVgvmc0UfNlz6FVEEsjc0tqiElWm5c/Mus7pl12+4ur5CCEk39BhrfuHr9JcynI2uaCE5ZlJxi5BTJsdEUIKcAsMYuO72rIxAa8V8JpmwDENiPwQ6lxhcwnkIMaMrQ2VqKiOpFmBnEhd7LjYTlyJwlCSVyPRCckJm0BJNRsqE84HgPCFKMrlcKCIyjQNX64TQEiEli6MZddPjxpp9KA+bpg4scsn0OD8ikiHJyO/9yackBSJmRBa4COmgN2UgHKyNnowRki8fZ6YAOnn+9Ls/5bj9Kn2/43qzZrNx7PqBKCCFyLUXnNYZF8ppSji8d4MyvOg9wxSKKpmL1P+y9PTlYFY4ihxa6cvvNaCzwOZMFIVwZv7ikHYgEZYJuQxnu53n1u2EEpYcM1F6EolhKApXdAmkQpmEVhJrwAIoqBT4oeObb93jT97/rJz85GJVKaTLTBISHcq/DQFJ6bKTUhwybGBVxiVFFnCx6Tg/OypZsxgJgCLRIpnr8nUFrZnNDKNT7PcdxteYVvGDf/IT5uOc3/vHf8b//j/9Y95+84zf+Wtf4W9/8x2+9c3fIIaJ//yf/jExXpOSoDIGSKU13ld8+NHI4KZie8wTMbX83//wQ968u+Tzyxf4UKG1waiaSp+zXP46D8Z3sYvfIJ28gq0NsinEKykdMjoME01cc6P737Baj+XzCqXEUjbM9ESjI1rULOrX8FmwXByTU0SrWQEfhIHKnNBU57+MS/eL9Zes+dENUsgYq5hiUQysqYiuZ7mclw3I6Ok3K7IEZUs+sJ8Crvdcb7Y0VcUrXcdbr93C1oapd2jTYkxm3w3EfuAbb5/x4IFmP40MU+Dzy8D1/glvvnaX9WbD0A/0MbK+7KhnhmmMxXIsoVUZO1PF7oJku1ux3RRb3kTklhZoUVGbCTdlLq52nCwMRI9wiVeXNV+++QaXqz2VUUw+EH0Apcg5kpKgn1zJpARJjB7nIiEGxpgOqntitphx62hB1hKy5PioQWnDrdOWcXQFbV3NuHe+IPEKIidG7xldxA0jVV2x70fGyTM6T/C5dPAY0LLQvGZVzXLZUmmNCxmrBVY1DK6gta0pBfRCCrwXGCPRyuB9RBtLzIJ5BSlrJgdaBhAKJBhlUO2S1a7jrLVkJFYvuF6tOWkNfppIUpCEwKeB7ANVXVHpCmPBjYEgA+2iwk+GTDnBz9PE6MdCwo2eymqCiwiriu15VOSUMKaQ5oRRBfYUJeM0EMbA0aKhDz0+JaSYM0wDMWS6vqepZ8QExkjclNitrrDW0MyXZXNnNbsdSBOom5rdtivPAm2oa1WotodMsqlM6QvKqVTNaIGPE0MI+Jhwu0BKApSgMcWWOPliIVIvT8ddRKaE8yNVVVFrgzEWIUXZCMdA26pi5aTGuWJXLwePAdIXytmvej26fkhbLxiHQBc8zo/EFBmcQynFrRu3qHTNws7RxnD39BaZyA+nH7Hb7zGmKKrZC+byiPVmyyADMSpstsQ0MY4jgoZmNsNnx+g8VpTCaxkTVV0iIjF5UBUuONCGGAJJBKpaok0i54BUqsRBkuT4eIkbHaYSTKNns3rBfNZQaDylkD5lgTYtOUe8aejGnlk7Q0vNyfEpWiu2RIR3pSJAgEsFh44s3bVRRETak9xw6MFN7PYBgUUIAyrT+4CPkv12S3WwbfqUqY9apjDgOk92ibataVpL8gYRJNoWSFoICaMtr7/6VVKUfPb5Y4xO7HyPlBElCsAsp+JLU1pAlkhpSwm3mxAKUsxYKTBGMJtZpujYbFbY64oXTx+zWMzohj1JKZJSgEcIw9j3DFNPEAFPQmpbeoaVwpqKV+++hlSGDz/6ES7uyDGSVMbHnrad0/UDfpIIEt47Jh8IKeLHruxRpSIFwbw9IrqIjIK5aVBVRW3L/c0qQ1VbUgoFf29bJAkrEvdu32a72bDdJHIQhDQRosclf8jbjey6WOi8OTHFgDI1jW3Zri4LhE705ZkgPDEbUBrnQESJbU+JGEbbsZ4cTz/9FK8kKSQa39PgSNMGWQuimHjw5Dl21uJFRupZKUfPpVtTacuu7/jwwefs9jus1IQsIAVCmMjZ/cLX6S9lOPMHCwdZAomU9M/yTjJmgstgNMEngpOQPVJbPrkqJ7pH84bby5rFrGLeWmpbNgnDGBlcYBgST6/21HVmvylD0AXp0FUVMQl0gCBBS4EfE3sHWXhy0sQwsbpyXKwjkAiHacbYnutrB6Js+r1PkA0ffP4cPxX86jBFtpuO8XqNlQKRBYGSexIUe6VSmcqUKUcquB4L1a82kpg0u4sN/+z3vssrrx2RpWPoE96VEyeRBT5kppDwoXiJ4wHqsXeeR5uiMEHJlv1FtSyXvuVC1EqgDhZLmcuwVprAykBWusrK/68OPyfBz3rEyICKVFIUUmOMhCiZXMTHiJSanF05NcKgZeT1mw2vnVZIXRD/ISs+f7bmH/zu1/jPf/8nSK35q28tQZUguRCCyScefLrC5mLpFhlEYfUDAilg8KUQevKOFDLKVHjfF8yyoFhgg0QJQSUT+TrTn3d8+nzD/pORt7/8Bt/70RWXl8/Zx4G9S/zgg+ds054//pMf8a1bd/mbv/1rrC+vaGaCFDPzGYRphWPBs+cbrrcJF8aiQAqIKSCj4cGzFfvgIFe4WLPtH3BUNzxb/TPSzf+E+bNbzPW3qdsFZ9/+XxGPb5GkRB5yNzLs+PSDQnKqdRmKjdZIkZmpTBY1j1c/RGSLlA21vcF+fAwZQhrQckHaf0SlT34Zl+4X6y9ZV1eRqhY8fnTBxcUaHwLTFDC2kMr2g0MLRVMrVGVIMSKVQFYCpoS1LT54Pnt0ydV6z2JZc73aMjlDSo7Gan79196maQSNNTx5csnzq46QYLP3/PCjz1FKokUgioasFP1YahuSLLClqpVIEsYYUo4Yo5jNWl6/fZM3XrtJ9lM5UFGZyXnOTltqLTB6jpt8sdQ2lhxbFq0moRBCUluoqppuGEgpUlvLtht4dLFhtw34EGCayiFPDlRaobTi9tmiPGyjJyPZ7zuqeobRkuwCSmWidwQfIXkMAl0LapM5Pm253I0smiOyLLmyEBPdMHJ8smDqd6QsceOEUgVX7Q8uDR8j9z9/wWJRc3Z2ilGabhzQtqGZKZyLbPa7krmS4Fxkn0oGt1GaymquN5cctzX7vkcJQa0td8+Oy110kIdNWizff11Q0V0/0I/FFmmsJutiR9zsBqSU+DgRs6S2GmU1QoqDwpiIuQyUq1WHsgqlDPthRJCxtikFwXWNwHB0dEJMDmUqUJJx2NM0DdFFqqZmmiZqozg6Oy1gqJiZfCbGASNBNIZ5Y8hBgxRst4UkOqsEQSisSlRW0lYVbrJARhlFcIlFE9lsOoSSCBRJZqwqqlkypXhYSUlwO6YRZk1L07QFThISMWUml8jJo41k6DxClj46BGgjyT5hanPYQ3yxfpWrMgLn+gKTyIa6MYTyG0gDu+0L9kkyVjPiYa8QcqAftiACOdUoaXA+YLTmqG3IlBoHozM5VLRtTfQCIxVEyenRCbN2SfCBk5MjbKX45P5nTMFB9GgiIkUwIGQpgw/Ro4VGZUFTN0WtHzqkMgzJc3TnFKUtz1cXxFRql6q5ppGWOAZyyuy6kSQVvR9JQjH4HqbM8dkxOQv6biibaSqMtcQYcHQk7ws51Aq0lKVSKAVSSEhZunszkag0QcE07DCmHNhO2TGJEYfHVgY1Uzg5EmOmsg0xOpQumf5Z2/L06WP60bHvPMfHCzabPUIociz2TK2LIqdUJqaEUBHnCtk8uIhG0DaC02XDvJY0UjMOG54/y2gJ09STRQCpkQIUZbvnXCIFxfHpTV5sLkjBU80atn3HME7sP/gxR+2MMHpcUAhZrJVaezbjBikFVpfvby1gyhGpihpmtSlQOZGIbsQWvZDRl0x01i2Vrmjqiu1+S4yBuprhugFJ5ng+I7qJG8fHZJlY73ekKCBrTCo2TC9GgpvIMWFVxeQD0o34/YgWgtENTDGAytjDMzvGiUpXRJ8JShDriiQMvppARxAet9szTR3HzYxpijCMeKHQ83k5UMiRmEe0tuQsqKuaRir23Y4pRLLKTEJgK8OimdNWluCmX/g6/aUMZy4WxQeRSplgLpkjUiSKxOQ8KWVkYwidByGY14a//e1bKKXRUqM0CKXQqpycTQF8SqUIdJjYdgFEGYZiLnqVf/khy5QPciqbe+sTf/TDkTsLhREd3ZDY+Iym2MhscbgwOc+zF9cYvWM+M3z6aGRykmOTqBpFo4viZqTktZs1L3aO/QhDlNxbwtxIpIz4INlPmW4sBMdllTAi43xkHwVNLhSefjugW0HwCe/KUKBk4qSKbDvBGA7I9Ey58CP4UCAW+S8ghosdtNgXTYblAfE/Uoq+X6L2JaXfSyIQqdAx5cGznP+ClVAIMLKoVpPLTMETwsHagiTFomq99D8nF5AS0IKsJCFldAYlAs4F/uHvfpNPn/W8/9F9ojh0wVH65WZ1TZoFLi/WKFPKr7UCjUbLosRVIRJ8GS63u57lyYJuPRYUP4mcxc/oJ5VWHL1zzE8eXxBdYL0aefi9DxDXGjeMdCkRYsY7z+XzEVnD/XTBrfuX7HYDwpZT9lYJhmlPFxTLesV1d4xWDSl5IPzcXhAj5EAIHqUspIKvlszonz0itgkfHrLqv8uvfe1/yOz0FjqX07lEySu+/2CHEOVGSS4wEB8SISckJ0gaXNozN6eEOJaQfPZUVQtJIyTs+se/jEv3i/WXrHahWC5aHq8u6YeRlCBkwdAHoCgHWpVrtd/FUkqvKpQCZMTKjNQSeVTTuwCdQ6mK5UIhTcOirjBSMWsNx6kc9ty5K2jrkgkSMqFFxdGRZbdzZMKBhKtIRhB9QgqFVRlrDZXKWGMK9nlmIAUikpQUY/B4n1G6gJJ8DFTtHERRReq6AZnYrHvmixrv9QG1HdFS0uXIvgvMZ3OC33PWLEhSoaVg2RqEllxdb0sfYPSstnukMuV+kXp2YWJeN+SYSMGTYumhiQmsMQil8GHiqFZARGWFVgKpJJGG/d5hskRbBa1A6gYVA7bSpSuLyM1b52iZefRkxY0jg7QVOQeUksxqRWaBNhSre8qYFIljZL3aHDZbkp3bsRsCrVF4G/nowRO0iChtmLUNSkZmsyN8mA6dnIUya2RmnhtcdHgpsMZgrcRIy8yXjK9UBnc4+Y0UNP7oAlHAuotoJhICJQVTmpjPG2KMuJhARBQakQKLtqKtBDFAbgSoQF0pKg3KSHa9R4pykqW0IkaPlZphcLS1QWvB6bLFhczQ+VJku6iQWbDb7QhTYgie46M5Q+9RymN0GZSFBDcOxENYXxtNzpqQAm3bIhRMe4cQxcokhQKtkclhZEFeCykRSFyaUErjfKkF6TcjyC9ojb/q5VxAGYMyIFWithU7l6hqTYqZyY+ctEvu3LqBspaHjx6So6NpNEJpUhREn5k3LfPZjL4X9P2OKTuEsNR2xmxWrL/DtGe5OObVV79E2x7R7zuuVy/Y7FbF0iaL1UrIhFYCNwWO5qes1zu8jzRVxRQSg3DYqsKFQBaBel4Rx55d7g/AjHwghJZdj9QFlCGiPKQ+HEkmLlZXODdRty1SWEQ0yGxQIoAfkLmQH4XQZB/IUuK1hOjKvhaLlBLnA0JEnHDYuSBZhXMTSQRCyhjTQhNRSOrZAm0VwxCw2hIS9EOHT7DrdogAtmowlQQpqWvLNJVuQAHFApmLA00o8NETYkSrqlC2TWY+05yczJnPanyEMUVk9ozTgBu6olrmQhWPWRCFIBCxTYPWNXfPb+OCw4XI8fEZ5zfOkTnhphEjDZerLVFDmHoMC+JYsv8xCrQClELEsuestETrAmyjloQUkCIXSEjUxFzyaFoY3JiJE6AyPnTF9pgNz9YbPn/8nLPTM6bcEXIBmqisCR68y2RTk2JA5FAOrWTGu1I3kFNAtwZGg0AfOA0CtMfFnqpJ5LwlBvBCkWTETztgRFlHbBWjTFR1i48FSuKCR8hMCo661oTgIEnmsxO+9NrrvHj+FOcj22nLlCYIHu8HGmORtv6Fr9NfynAWDvTATICkAVlofTkTfAkr+hSZoizBQhKjy/SdQypPZWrqJpdpWyi8j4zjxDT2dNuR7T6y7cEqUXJOqQwYkqK+pIPyk18qRjnzdDex2sHSCFqbi3wty5CR0kGCEZkUMsMAX35tzttfuk2SNf/sT57wvfsbBBMSyWxmuOpC6QSJoniKpUIET4IiYVGUISUkVhXlrHMJFwNKCkLOjJ1DJImL0I+JIRaVysXMGMrpYumzKSpXFwWRQMpFESwIeH5GPlRAi2ASHKyOvPwI/kzxKZGm/DP7Y375I5fMmS3oQ4yFupL0UyL4VAqoxSH7kBM5gpCqZM6kKgjelBAItFAgMkqAUJkHjy74d//qO3z8+ROE1IfPhiTLRBaexcLyo88yN2xB9ZdgrEIe3kdkGSaVgBfrLV9+9Q4PJoVSAiUzhpIdlDKjKoWZNTx/cR9kRhjJaBuEqTD9Gh8UJSkYWV1OHJ063luNfPb093n7JlTe0kpFY0c+/mDgxj1PoOV6t4cMxszQqaWMvgc1MkPKE0oEssj4uEGrljzCFAbmi7r4wafL4qc+ECmzgG0UbDuBlqUgPAtJU1UM/UBIAk1Lpc8RNHgfqKsz5vUN6tpyuf4RTXVGVZ+Vh9oX61e67j96itWW1XrPGCXGSjigyYWSpUIiZipVcXQEdW0RSnG92iAPxZqJhMyad958nVljqLTi9s0563WHy4KZFbRWEq2kPTvi9S+9wfrqGa2tcMEjhUQZwXCSmEZHuzCstx4hCx1W5jKYbfcj85llipLoR9Z7x9nxgt45hC4WOyVL91VVJSpb07aWfj9hbMU4jsSQuHPrjCl6gvOs9mMhC44RWymySyQtOFkuiG7P6WxJiJ5al/zU7dMF4gDXWR4tKAZsSV1rYqjo3MSiagm5Q2iDihGTBSF6ki/gqJRAaUk/empdkPFWSaboCE7RiEDKmX63YopgkOhZRTd4IpnFTKNlZj6zKCG4WpdqlqPWMm9LsB5ASUkMmevsqMWMGCJ+clTWspjN8JNjCp75ccvZ6SnR9SWD5weGcUTJAvPRpqLRCj8lvBBsdwOt1Ujn2WwCi0VDjMXmoLRBSENAst4NaOUwUlFpQe8isgJjKqZhRCmFS4YQExnJZtejjeT2rTuk7EldoLKCTddhcmLoE0FLmlZiZUZIQT9NmMpStRYXPSIoQsqonPAetIb5rSOic7SNJodiCYsxYjSMw8B+cGQJjUq4mJGyDNRKKxpd4cLIvps4v9lSyUPnU60PlMeENaXkvDaCEBXdfoeuKqzRZJFRUpSONKFJKeDDF8PZr3qVTlNDDJFKZOwUyN3IIAso42R5zBRLuXGaJtw4sNtvqdqa85vn7PcDtp3hppGQJ6bYl+4+Oy+21yxLKbBxSBXZ7nv+/L3nkBSnyyXOjbgYCmgmZ7Zdj4igmhnRJ2bNMXdvfYmPP/6UlBNfeutd1rsdDx59htRQNQZij+w1ZEll24KdD44Uw4GCVmA3qcT4USnhEcToyQKSm9AykaYei6Dbb2maGkcqFUn5AFFLgbo2ZCxBJLRuiFEX1d6PhFEhdHmOIzMpRLwruXyjNCpl5qbl9VdeI6ZI73ruP/ycnAK2bnCTpzKKlEt1AVKzWFrGi4GQJUabsvfK4EMkxgKp00KQkyu9h1ZRzy3SarIo2VfhJowf8cGzH3oWupSLC5cxCgY5kWxm1a3YTmuaeY2PnhgC/QDDtKVpa6xUNI2m3gROlufcvPt1YoDV5RXPnz4miUxQkuZogU2ZcbfDuw6A/ThhG4sSGSMlVkty9hAS0cJX3/4qOik+/uQnXG9eECfwTlDbGZVpqGaazXBJUopIQONR0jAJD0YyjCMyCBbtHBJMvidGAyKRVSKLTFYZKSJIgw+ydNf5iHITQnvETJZhLwqquiU6idE10mpCyMhqjj4c/lXaYkzNEGtMrNAiE83ExdUlLy6flToH0zL6EamLqFEoLBn7b6uEOsQSrKTQkhGyfJNTzoxTIoaIzIm2FkxRkaZAP3jy9RU+SiqrmC8MxlQIkXEeLteO621kNYysh0iMkrmN1LZg5l9a/xK8pPYX018uP6cEDsHOl8Hm1qz0sQHlpCW9BNBHrq4j//x7Gy67DcMUcSGiSBgpEDlyo9Jc7wqsgsOJ5K1ZJk6CKSW6UNrmi3m/OPQSghBFCZimcrLjp4QT4mAnUGjpQZSCZqMErcmEKHCh/P1pKrkPI6DSHPCyRYX6mQJ2wNrDXxjMDgPXz5qoX/76MKCJA1Pk5dxWAeJliZgQhBzKa0xlc5UzCCPLKagQCEpvT0qZJPIhM6YQJE7mik8ePuPW619icIl9HzmalQexREJS3D62zGeGVR85rwRWFsWwfA25KIUHUEY/OEJyjF7hhmJViKLQg4SEIwt//q9+wmt3jvnxgyvcCM3M4P2MjWxBjAfVMRbs7FSUwSQF/SCQ0nHreIbbR/bXDq0GPvdHdF1PygEZBirdYAUHdVigpCaqEgJFaLy7wL2EGoTDCwuZPK1+9hkt7QGZJBVRGLSQSFlUzXY2oxscMUH0j9ByU3zcac8wrgjhMcM0QyHY7T/kcvODUmT5xfqVricXa1IQGCX4q+++ymuv3+ThxTUvnl6yG0aGLvHu268UO9lRS1VrYp7Y7m+wvu7wccSNkbpt2O3XPHsxMa8a9vs186ZGSnDC4jaBxXzOfhr55NPPIXjyUcmvkhxaJoSqcCGxfbHh4mLHm6/dQhE4OTnGCYnsHWM3cXxyxCgTgczoRroxsNlesTASoxWqNcgsyJPEiBqtK7phouscFwcSZMgZrSQpB2IovUZK10yBYkfDM2vnmEM/z+QccSibGKU0VV2TiPR9ZHKRmBNdn0BLtvstPky0RrHfTyyPjtBG8vR6jwgBIRNH85ZpmmDR4PrAvCmFrWbeoG1iv+pIwMW2p5IVbQpstwPnJzN0FCyqzIsXV1T1DI8kT75kGuKIrueInNFW40bPsqnYJwGmwasBhC5lspTi3WVV8eziAqslVgVizgz7ograuqKSgmk/El1kcXyCFJK+H6lqQ9W0SGNJVrK72lBVAmSpTqhqiUxlgJ+mYm8OIRLTUKAZqScEf7jPW45aja4EY3fBZjuybBrq1sDcUFcatZQMg0ObcrgppCCZcr+3KtBWZQAX0uD8iDIGN0wM48BiXtPvpkN2TaN1yZ9JpVHGIBDEkIgi0DYG2yzYTxPZF+VrOZe4zuHEQD644wowJKKVASExRhPSiNEl8yIjzKsDGCplcnKE5LFK/H+7HL9Yv6Q10qNcpI4SuRvISI5rw4tuS1M31DGz3a750WbFrG1L7ZDWLOo5d0/vMMw8ARj9yH7ck5TAIw6KksMIjw8blJSoKNFCI4QkANvdDm0UUimGqdCLZ21L9KnA1aTm+eU1+8EhjCE7z3a3QyrFyekpyETI/pCHCGhZF7dRAudhcj05R+q6JkkOWX0BSpXSpmL/IaREEo4xDuSpKOi5WjD6iI/Fdqt1jc+CMASkUEhliGFCy6HcQ5TFGkv0oG0DIhHMhDUeVdeEcUIgmKaJi+fPiw1YJvw4IjNMXY+Smnpm8M6VA6Npom40i+WC9WoghIDMCgVlnyV1GXAor3PW1JyeHVG1BVv//2Hvz34ky/I7T+xz9rvY4u6x5lZZVSSbRTbZPYPRCBIgSBpA0LwIehSgf1QvowdB0KglYdjTzWk296rKJTJj88WWu5xdD8c8Motd3dPFLoLATJ5CwCO8PM3Nrtm993x/3w3dFFmpliY7160mKMtKkJXOKCpNlqxypDOWKUfmwxkpFbUkXGdYs+fh7T1WaiQaieLduzdc9VuMG5BK8eSjj1iD58Xz53z2ySeUWpkeHvi3f/FvePX2GzyFNQY6qxm2HSm2Qu1cMtkX/uqv/oziV3IOSCXQprH6EtFsJFKyGUdCTaTUwpBiiCgAEdltJaYYVE2A5PNPP0PrHefDgdPhPTVFfC3k2vaXMcfGUyiLz4qweqbpAXs1IqRASEc37CghtvdDaAQSpSradRxPZ2oROLtDK0eIKymvWOuweseTq2dcbZ8hhEXJ1pt3Wo68u3vNwzz9xufpbwWcLbHgc4uLrNUjyJTSjM65ZmRtU16hBNkIVi9Z1kw/thjNkuHwkFHSI0RlWuHdqXJYKse1EDN0tmJ0xtqKWdrvfWTPHkMqH1mhx7/HC1jrgsDHSicaKAlKUDVo0zxXa8isqfB053j6suNqa3i5E+zHwL/6U885ZZRoVVlFVJxSKJrEAyorkBFoCYMW7fmUcilnFgQl8AU2JbMsmkC7IWUhqVW07rIKCIWQ4FwlpibXNFJgVL1EwDZjqq21JSzWCxB7RKePr/2C1h5LohvkuXjORP0gaRQ09kzREtqM1kDmnEp7flUQsyCRqCkRU0WbNj2ttckU5cWzJkRLXny2s9weTmzOKyUXci7EJFGSJv8TrcXjaqs4nD23i+BpL7GycMFnKJqnJpeWUnk+Lfxnf/AS9EqzU2S8jwRfGJSlO8LVuCWlO0ytLEYS3e+znP9bMo3tozbJa5WtgFx1mb98Iyi18n/8zxN3rzy7TjOfEq+XRCoriEq9BBcIOqxqLGA3aNbgOU9fYuUO+fSGfP8l0jxjDV8CiSoEy3zPUC7dcI/JjFKgpbkosHO7kdiR1/fvQGRK/IJQBQjHbvNfcrX/Y7Tatc+GqNQ68c37/443d3/y2zh1f1j/gfXRyxfMfmKdI6dj8yF8+vwJAkX+5h1KFdY4I8XAPC2UYrFW86QX/OifPuE8rwx6RNtKLZn7w4JfIsoottYhbaJmAdoShKDvtmxMC8JIVWCdRRsIwRNTxHZgxiu01sx+5mrT8+bdQ4tsr4r9lWP1Z4y07PoObSqdTbzcWzAWKRprL2phnc88fDvjhsLhNLPZ7XDdFqU1VkVihL4b0EZyfzhRRULKymbcUosn+ZUHn+i1JtdK1T2pwnEusJxYzhnXN2ZpWTz7m2cs8wkrMjVpSi7EmkmxeVqtkvT9pjEnyrLd9WiZMb1k2G4IqTAvkRAVXX9FzCufPTe8v/fk0qTBa0wIYSiylTMvvtJ1hc4oUmnn1Dx7rLEsKbRr7xoZt1vmJVCkpMRI5xTddmT2kZIjvbEoY6k1ECL0V8+52Q+cpglRmqZ8f3VFPxhunvRIdDPsJ8nsA9pGnn9+zenNBLWyhDPGKsa+Yz7NGApJtkTQkirJVDISWxPzvNBZR0DSuwFy4cWTgRSb/1FZSUmBENr9ZD0vpNo6OI3STPOEXypCnC/JxZFaMncP7zDGYq3hdPBc7TcIpVsYFYIqHMfDBFKRS24F5/sdyzKz1ktNjc5QCkpZgm+KFm1aOI0QkSoS2jiOs6dTkt5qpvPK7Wlh6BxD14ClqBVlC1aYX5Hv/7D+YVatzfcpqsZQ0Lmii+TlzQ2H23uO88p5ntFdC0br3ch2u8NZx7t37zGu4+3dLUIX1ryy+hUfI8oIlAaqwtmOzmxQCIKfoVa0bkFfUusWjqMt6dJzKHULVkAJYsmc55WUK12/AaF4Ol7zux99jtLwFz//C+6nB6oUSCdbxHsuqFpxtiPkhVRTs2TUxmAkn6miQG7dbhWwogXprCEw3uwICVKRVDTBe1JsMvJh6HGdI5eEIKG1aBv3Ksm5op3A2EJMESUkvd0giiCbypLOvD++5/Z4T/aJzmqqalkASimE1MxrajJIYYhpRhuDsRnXa5ZTIJXcOmVrbv2CZJRIdKby/NnIk2dbvJ9RWoNonp0iwOeIlAItW+p2LhmURQqHVAp/PuBRDJuB509+xG478P79K27fv8FKQwGUFMQqEcIwbgY++elPyWEliIU0zTzd7Zjnmb/9m1/QVZCmsL/qOa4jW2nwwVNqZvErSl3yEqhYMRJDIZYmDTe69VRq7Zo9iRY6l1PEGINWBS01xbUKrSo12ogGmmvzA4oUUCKjhcYqS84Z21u0sviQmEWmifcURYwMymBFYUlntAVYyOuMVT36UukR60QhY5Rj7EZCDOw3Hb1zvLk90EmBs626K5XIGidOp3ekUInRU2QkxBmpf3NFwG8nrTFm5nm9yLeA2iKBH4MsxCPLQ6G5xQoxwDI3wNb06YVykRw+nCV3U+W0JkJJSCHpL8V5xlz6smiyvsJ34Oxx5vYIPBpfUjlnuJeVoUgslUFUkmoBGlVWooBnm4H/8o/2SIDSqj1f3WmGbeQXXzRPgc9Qi+B6K5C59bplWnx+SHAK8G4tbK3k86FNQ0uupFwJSSJM5hwygWYmbayXhNrkJLU+gpyKz63gubPNb5ZqY99qAVsFmwrnC7skvnc/+/7c8QNvVuuvfK/U70yhhQbwkmgANuTC2VdSLi3tUi6UKoGVnC1KaiqKKnILJiiPDNsloERKDsfI//dP/4pSMq/ee/7gM9lkVdiLtFHyZNvxy1cTixC8XQWf9BdRdKM+6SxMa5MCHk4zz593SNNhNAhZGUeJEpWtVfBq5v37U/NZuEJeA355zaBuWPI7irjcAISkioGSAkYUepNZUuHljcc9j7z6eWbV8PPXAqXacXrUkEp5YWSpVLkgqqEMkboeKcaR+4ALoPSWmI6Ia01UE6hCvlRKiNqGEUY6qvjujDB25HD+qn0WqFQJ1/v/it34R0jlqDRTcq0ZIbd8+uJ/T0q/eW/GD+s3W/+rf/Y7zH5BVImouRmqUfzks2d8/OyKlAvWaaY5UELm2c0NiUypmekU2fYjsWRuD0dk1uQiefnxM4SEToOzPcs8I3RHTBGnFYs/NymIBqESx8OJrtsQ/YrCstkZlpPAB837h4XT5Bltq/+YvMS5DTkF3j4sKFnZDK7VXUjL6eFMzAGFYr/vCDk26Y7WnI/H1p2jFH4tCCWbpr5q9kNPrYlx0NRy5P64sB1d64jpHSVLaoFEZW8tp9PK9d5QpUKWQhGS0/23TcaTKvOxsulbuqRQib4zWA1jbzlPiWWZSbqy3YyEHDi/v6NWSdGKviikkigkKcPTJzuUrPhY2PQCLXXbyEhF8AtFghGCXltqSvhY27R7mpFaIbRiDitLjpQi6LuuRXOvnpTbuE+4y1BMGEqcsFUxnRI319c8nE7sdxumZQYS3ktyLFjjQGZIBVkcpzijbCblzP6qRxvHOi8Um4jBczofkcaxTJrROaxKLDXTd10LiRKKtw8rIglSPWGNJiWF7QTz+cRu15OLwoo2bMQZ3j4cGDqB1B1SOHycUaWipGGzvUJSkAJijBymiLOSUgUhLoTcNptSNu+0UZowLy0EwGqUonW9BU/MK9pqSlZ0nWH2sOkt2l6TYuDadBxOMyVEXO/4bOhZUpOxPpxP9MbRCcW8ruT8g1z7H3oNao8qFakNqTbpGcpgbc8aD1hrGDcO1/f4kohSMNXCcT6gpMLMLdEzx1aIXlJLPSQNOD2Qkuf66hkxLE2qjCOX3KTgUlKVYjmtbIYOI+A8nen6jpQTWiWol4qGAsb0jFuN6SuSRAqZUjLGGbS2xOypRIRRrCGiqoPckbPHmBaIU0urtxFocvGoLCklE9eMUo5Nbxuw0rCxlnVtZcvWGpZ5ZRxHnt48Y36YKNXTdZJpPiMlSJfaPb6CNIoYK9PU7BmleELwzf4hW4/iVBescCjtCGto9UxVkJJH6hYVD5lu1Ci3x3aReU2czydqyUg0Vml2O8ezJxu2G4tfHnDKQIoo7fA1g2yA5/r6KfNpJcwncqdIVWGkBKUpWlFCYLCGT55e8+TJNaQT8+mBdPHzLn7GdlsUFi3gF3/714iSGAbLWAViTdgiscZy+/4tD/GBczi2fAgkm80NJadWYVUzQoIsgSe9YPaZex9QSrfnnSIyKVL0KFXb4J+KkKH12VZFDJV+uCLmQM4eZRv7LgrcvXuHUg9Y2yFlpmaNSK2+YQ5Hqkx0WiNCZdfveboZsKlymDRnEkuY2eqO7pJVNC8ryDbMOPkHBK0+qpQFQYW6IE1lLWekkry//4rbw1dN8SAFIUC+SFLT30Ou/VsBZwrZulEqZAGiKlp4Y7ls2kuTHNImbfnCFp0XRdc3MCLKJWmxVu7nzOQLhea56EzlugcnKw54J8QH39V3wK+tv/v3UtumYaowqgZKRK24KpFzkyE6WYlx5pd/Xkku4XMhFchZoGphTQUpCgmB6yTPXaFGiBlez4pDapHo1EIWcIrthOuEYKYBnalIUm0hJy2WowVbPEoxP+gzafjkfm2b8ZAFRl2YttKglxS1JR22n+bX3c7K4wP9nePy4bhdUns07cPtc5NdIqBzzbdRRSblFrccQ+V0yhgnkKLFntaLd0/ISqmqgbRa+fq28KPPP6bUwpuHmZf75gP00SNFRWmFE2C0IKZCyIK7KHhmLoyfFPQW5qUdkylk/FK5Px5aiIlSqNr++zBInmTJu9MDRlVAMUWN96+oWVMf+VQBUncY/Ycg/geqKPzsc6A2uvy8Zrre8vpQeJia11ArEKoFPzx+1kpJDIzcL2s7qjbD+YjST/DyDuUF0c04e4UvR0ptTKW4yB5zFUipKVJcVKQKIRxTsJRssdKj5DN2w88QqqPSCtHboXZApgq42v3R3+tc/WH9x69pmtltLFJrOitaWpTQLWZ+k6EaYipsXETUQN+3Is6cI+dOcH/0SCnp3Q6jZEukEoWQIynDw2FGSYWQic61jsXt2FFS4v6wkAtotUPZjvm4cvvmHR+FwnZ0KB1w7orNNhDmQIwz07lQvGS76dn0soVApAbMSgzYDrZmw9BrzqcFRGLsO8bthrvbe0RpIURPnmxASHJuoRQptatM9AElC9vNhhATGkGOnmmeGbqOOQRIgVoDJVtCiJwPB4bdFdSKQ5AQXO9HOq3pt1tIiRgDc0hIGem6HqEi2mh8qCjVM+hKNzqs1IQcKFlRTJPNKVUIKbHf3RDimXHoOR5PPLnuuN46tCos08ocEtpJjJbElNjtBg7zikQydBrjMvODRwjH8RzIGcZBkaugU4YUPLqzWNcjSivHPh/PICqnk8fnzORPbHc35FwpIpNropOK43zCTyv9aHDWEvyZIBeMsdw+HFliYfUJ2ymuthtKStQqCcHjZJNgDsZSagv/SMXinKBIi5aSsXfUlDCDRVDoN4o1JvTYtXtIClQExvU425IrEQZKJsSINB3nNbOGCaV6tLSE2PziQgS6wbUpds5UWkF2FYrbu5Wra9uKhWthc9UTYsSVSsma9+8O7K4szmqePdsRfCT4lcV7TvPK8yd7ejVinKJEgTRw+nukmv2wfrPVPONQO0vRgvsYSHElrWdqJylWYo0h14KzllIzqiZKjBSZWJMHKVlXj1S6lQ6L1PpLZcRYAZQ2QLwY4a212M4xLQshRXJOUMplABQvsqeEVJIUU/PvG0XMC6++/hveKc2T55+x3e35+PNPef36Fcmv5LwSigdtELaSk8RYw7pOQPMIxZghJKxxxAxGQymZJRSyUhgjyUU0Jtn0xKIwCpSG0QmymHn9/pdsuj0kQWcG+o1mPT+wiIxP+dIPB7vNnuNpZvLHBh5xFAI1BwQZpduuKy8LVnWUWFGiJQlWEoNVCCkYekfOcDVqSlHMi0EpSSXgjKKzDpETtSRqDIy2g+ip2pDSitSCj54945NPf8Rms+GrL/6GGBeKrEQJVQp6q0kI/PmOX/zNn/DLv1HMSyBTQVUECSMrTgtqLuToWZcTxa+cD4VxvAFk8+rFmbUulFLRZiDkQCgLRhiUbq9JCEUtmSoVKxmjM9e6Ka7WJbUY9l6iux6kIKSE0K02hgq6GhCVJc7EuiBKpNBhjUNIjXQGH1YkmVQjkURJK8hKECuuswhZ0Z0i54V5agPC3hrcbmhkwLISc6ZqTcwrVIsxttUajTuESrx98xUHK1jWBdeNgCALWNcVhGy1IzWzLCeGoUcqw98Hav1WwBkJ/tWXnj94oVqx7sUV1UqI278RF6BG8zBQYVoLyhV008WRc/NVqZx4bhNWgtUVC1QPlYgr8sKY1UsCy6+uR9/V9wFaAibAl0qr7Wvx8poGCiVgROXhS8/oII5wVpWQJSUWUoYrJ4lV8tNNpZTKWgW/PAvOOWNFvSDqVhL4ogcoSCVbelmFNbV4+Jw1RaYLG9WOhqAFaWgFSgim2FgsamFN0BvF0AlucyICLjdwp/lgE/uVoJDH1/39ryAu8f/fhYpc0v+ZRaXGQJzUJUGtaSaVbB1DUoI0lTf3HnmRnorL/x7ZuXyJwq9VILB01iJFpdOFu8OCkooCjUUiImrGmla8XUXhFDQ7JXEyo1W9WPta1HVMiRIz5/NKqoWcxSVJUjE+6VmSZdwaHt5lYk28n850m/+adw9/dmHiMlUILFcY8RlK/Q2xJqYZnKn85b9KfPRx4uFOME09y9J6RsCghUIJdaHjW++KqB1aGfx6Yr/7I3r9hxwO/wOCTNWKuHyBW16ij5UaMhhz0b4DRaCFaX6iSxVDySNPNv8FD9NfMq2/YDdcI+QGhLlA5wqYVqQp2kX87zOJ+WH9ZmtZD6A6zuuECIJh7NiPO6QQnE4L3XbDHDMKg5CC6f5I9hHX9czLwrjZEFMh5wxKkkNiEgWrDWZwdHiWEOmtJRfBKUiCz5yOR4RUWK0wRuDnld1u5Gb3lGU5EaIEHPPZU1LlydM9ocWbIkpiDgEjNEEE9lc7zlMg+pVOSySV6ewptTL0Dh8K6+mBSsRoR2crtw9HjO7orOTu1jMOqkUEF5BG0jnbertSJITK1dWOEjP77Ya0eo5zYBwd690BrTtKjBhrOB4eSFSOU6IbepzSGDwhVTrXoxWkIhiGAdddorplRdVMjImkFCFJ3rw7sN2OaNMjtCKGCZsXrrY71nnCSMn5PDN2mrlkOmOxVSJFu5ZobbEWnncjy9RSF02VPL1+itYKHx3GOsiRWBJ+8SQpiDkBBZQihIU1JJxVdNYwqJ4scmPjqJRqePJkQ5pDK3Ad+/aZmgJGA6qVMe/Hkb0wSKUQKEpJVKtBCPbXW7TQSFVIMZGioNt05CJYl4VYV4rWdJ1tcjFZ0bJgnaKvlustlChY1owXrTyXlOh0u+vUqthst40VjC0ifJ1bx93YOUqfWj9cy6hq1+vkiUnwxVdv+OSTPTEJeicJK5ymTCqJ3diTc+WT/TUpRoxqJn1ZNUYPjEO5lOEmTG0BUEoJtlqxGXf/mKf8/yxWSRpE5uF4QMiMNpVIS050vaKzCiUFIUSMUCih2e93vLm7JabIaZ5x44DSijV4jNBoIylppShNKYUp++YvSu3eG1No4D5Vdv2WTz75hCoL33z7DdkLSlXUIki2I0SPc4ZKxkdPyZE1RuZvv2Rz2qKE5HQ4oDVoC07pRnWEQkkTY+/oxo6YJRmFVg5RVpKP7Ic9XW+Z5iMxzxQiVjmscsTgmUJoe7NaoaTL4CAjtOUUD1hpOSwBQ6XkRNKFWCM1amKIZFZ0byFAjAFqqzmpVSNdouTWHyHRiKwu+6IFmi0OKUUrYFYamSrPr/bcP9wT1Uy/6fBLYs2RWi+D9TWyqY5RduSYyUmwhsrJL/j1lyRZ+eQnn3J/HJjuFkDgECwZnO3IMiGkp9RL+qxs/r0YMtZanHMYI1j8CYTj3fEOTcHnwJv1zNDv2OYNy/nMPJ0ootJbQ6c1xlqsFaxhJuX8Pb9fopSesmY6oemM5eVuy1fv7jmngnCakFsJdyqVpRScMgQyxhSESPSyEgOoy94VbfCrb/fhsJJSxGhDIVEyGL1Da0uqCSk0SViOKVF6hY+Reh9wXc8SI2H19BuH7gaKEBirsNqwlnPbCzpLqgWrB+LcCBY92BY+YhU5RVaf0G5AyQ4KpJz/R87Kf3f9VsDZ0Wd0hlcH+OxKXGRuF7biAxt08ShxSUykknJinjMdTRJXqdQEV5KWWlglJWfOWVNERikQMiMf9Yy/Zn1IKvzeykCogtei8hSBuQQ7PPZsSSCUwqJgXWEbwWt4V8HUShWSjYXrriUUQuVuhVNqMfHmAswy8JOd5MZkfJK894KQSwsIEQWfJJmErBUlKrk0u7eULfDDqEIBzqfmz+Ki8jssFalqe7fihRH8PgL9O7LGDxt6AdTHmuxGzz769B7T6CvgawMKuTZmqJTatNcVcskffu7D0b2wbkIIqrzANNmAX5XwdCP5+ddvkFKyBslpbWwlVIRoSZ5Q0Kp+4D1zzZyzafHjotHBjx5CUZr0hqIIqfnQWqBJxJSBJRUClVgynVJ8/PT3+PbNK4KIH4JFAIx8ShEjRg447dkP4LaCIDLHBLeT4G6tZMKFjcyUZgnlsZSn1sz96UROjbPNMRG7lbX+EpEkz6//Tzwc/g3n5ecMD8fm33h8g2qLxR36jvOcKbVgTcfsFSEcGdxHbNynaH1DyAdu7/41Y/8jdrvfRdTE/cO/YfWvMGpP8Mv/6Hn5w/pPW7lKwlQZh2e4bUdnJGe/0GmD6recJ3+RPSTuj4Gb6w3dzjDNLQhnjp6+g3U60tuOftez24ycTg/Ek2ye1aqZzgtXuw1rjPiwgjKMnSXFzJvbE2PXgwicHm4ZNg6hNBjDMPRQKtOSmJYVJyR2UJRUEE614JuHA2uCGiPFGKr3LPORJ/trfInUrNgMI1oPTGtoaYNDT60SIRRaZ/qhQ8SI1ZpL2hFGt+D36le0FOihY40R6zTjeEM/bLm6ecpXr95wOp/RObPZjqRS6fvC1W5ACPDREoqgxFZ8fD4ltjtL7yw3u5FaEjlFlpBQAvZu5PnTgdO0kGJlGB3Xe0tnFEIYlmXCuSapT7m0AaEzpBzonGMz9milEGR8SnS94TyvaD2SU0Kogl9W/DrTmeYdU0ohh64lQ6pKzoLVe1yIqIv/WCI4TB6TThhjqTqynBN6N/Lu1QFVTlwPT1l9JAbP0G8QQhJKomSPKJbOdWjRfBLeJ0TNnM4z19cDKQtKKWw6wzQHBqfQncPniCDieojr2uRdxSOlo4TEYQ5oBUv2aDNiL4M1KSvSGkoq7R6mJFJK1FYgL/1rhYpxilwr2Sdc19NXAxKu9j/Gh0RnBUZq5K4ghUHJSk6Vqto93V7081JqzCVoRYjCbuyYY2Q+zxg0UaSWo5R/GDr9gy8ZMKb5mbSCqhQCi3Mjw9CRQqCWTG8dQzewLJ7DdCLmSBG1lZVTCdkjZCHGRMkKYzQxeZTQPLm6ocQCQlMEvD++bV2lWRJmWKi0PEiBD6CqQElDveztam57Ba1AGHdJjM6kMBNy80JZLZtcjoqPiSIFruuoZIwSVBFRIiGkgHTGCIeqM8GvxLJghgaGqveUJKkoSqWppHzAGo3QmhITSuSWehsnfEwMXY/PCzpZOt23gLlayX7GKMtoHIi2FxaigR0lHHbQBF/J6jKYzrn1YcZIzhnXgdaS7XbAKoczHaVWllSJyVKKpuaMP9GSgqvm6ulHpDW1IXm2CDJjZ9C28urtK+7WA+9eveZFv0VXeWFAM93gEGbgvLT+RC0tiUiKGZEr3hdIAWN7pJRYKzBq0xIpV8G6rqT0wDIdmx9Mtn1/SU3CmgJonbC67eOFaJ5Wa2wD7RWyMfha2XWOq/2OcDyilMLHBescg3LMyjEIhZkCIiZc3yOMwauMlRo/r8RLeF2p6cK8akqRpNT2m0pCqaFF/MeINhYhLXfnFtoihWINAWP3lOyJCbbbLYufCaun6oSPiSoF2jn8aW7HXCm6sSeXtp9TQrIbO663PbZKLKalQJbf3IbyWwFnP7sRPKwNRHxyJXn0lkn4UNZcawu0aMkWzatUK5wnEKql/0kpWIBUCykrQhHEUvEFBq3ZyLZZFqpCfOThfj1bxvf+fXHy4Cu8F5UbIbC1AZQPYE6ALK2n7ZhhnyWIxEFLnm4qBqgfwG/l3DIm6DRslGRJjUNyqr2uJYkLVS3IStINhtlURCmtU0xktmNhdAKBwqfGsIVa8VUiiA24wQe5oBSVWgVeVEy9BI88HgMhLuXS7bhcwv2bOfTyfcV3oAy+k6FWIUlJEGqT0AFIJZHQNOA8Mm7teZQK1NoSM7O8nJCySUEL7DrD69s7KpUlJuTapHxKFhQtylWJSkyP3FsDyceQ2erKIAS5VlR9TDqsLGu6sLKthFEKyKVF+C++YLs2EQkJ3h7eMKnfo4TEh8a3CkbfELOmM1s+ejLxV9+c+Nnva3hWOK8tBOXBV8xlCv14LKEiLo3flYLBotwzTt0rVr7AzT9ChZEsVqqBbvM7+PILTuufUmq+BLRc3kshiFWT6UAkYrW8vp1wxrLEM0hNqZnD+ee8ffgX8PAveOn/t+zG3+d4/iX7/WccT9+w6X/8n3ze/rD+w6v4QnaCdJ6JunIWhRACRxaiEFwNIyUViki8eDYSU+F8zm1qeOVQSnKePcNmw8snIz4UyKCtZZkT3379wNVVDzXx5s2MkYJSEyoJ3Jh5uD9Sq+V0eMXV0+e8+HhDjZHDaSacPG8Onp98cs3V86dYVchCsc5ntOnxPjF2kt5IutGg5Ui/6Rq2Uk9YjjOj7iDDNC+kBEpWXjy7uWywDJvRkBJ89dUtVRaeXo+kFBEFnFXMPiKl5HReuDs9YJ3merNB+EzKEyjF1X7kxbM9JVZCnImxUEiIWhDSobVmNJpaE5XC7npHipH3xyM1JPquJ8eVaYl88vyG4/lAVaCK5WrTI5TkPC3MQdD1hc3GUVIixII2klQ803Rg6JvscjMqcs1En9BGMw6OfhhY1pWrzY77w5kn1yPKdeSUSTFgbYu0l7L1yt3fHXmyGzn7tlGjWEoOXF9dky9JajlKppBx9cTgNKIaUsmsJLpeE1Imh4AQAq0FzgqQnlIKqbRkzZAT/aiRIqJlQnWSeT40WbQQ5OC5GkZquxiSTKTU3P5eClJbrq8dOXv6OlBERmBQNDljCgkjKlJJOiVJdUYUoFaO51Z4uxk6pBNYK0Enkp9w1eFUpe/bXb7WVr9S6kJawmWz19JoS65st3vOUxsyZFGgeHz0DHZAylZam8vl2v6YNPzD+gdbRZzxUSBVpaLJUbIZn5Cz5PSwkOOK0YKkBAhPLIXkI904sgSPVm2vpsVlhJkzCAhlxTnH6AasceRUsJ0jELC62UtKWQjriSqOVGtAFrZbiSyNqUFb6BwhLK0nq1SkawX3PnuUcZe6Iehsh9KVUCVVGtZpZY0CLQdq8E3iO1r8OiPoW5hP17UguLSitUFrg9RgjeX++ICsEikMKRWWpZBLwhpD8AlTDSlVhOoouqdoiawgUsVK9SFBu8SAQiJqG4VbYzj7EyIZlHYomYkxoozBJ0/OheADMQWCt0it8H6hxDMvnz3jR599TlGSw3TG6o64RLauo8aEFYqb50+4e/OewTlyDgyugFMIJwm04m4jJQpFjYqAJ5s2iPdxwZhmofHhDAj63lEJpNxqspZlIcdI5xr7P3QbrBvI5R3GKnIKlLTS9a5tMJHEcLHvhBYotB12uH7A+8g0z62/tTdE0TZ5x+nMZthwWCeqgidXOxCVkiMbn9gIi1wTKVWSqmyvthAyIrbrV28Ms1+Y/JlxsyWmzBoyuYAzFmMVPkztWE+eJQY61106hAsxBTbbLS9ePGcJ8JOnTzm+/5Ywn/DJs6yVKjRVScgSqqHrLW7sUUZznk4M/QA1o2Kh14JBWQbbsd/s0Nb+xufpbwWcXQ8Cp+HPp0aJOqUuUwMaEKuVUhodWcUlz160jXmqErMzLXqyCM6nRCyq+bNSk7D5VDgsTcpGhf57DOH3/Vb/HjLpw/czsFZ4Jyp7AUNtDFS+oLNEY4RkhUhhBK4zWC9YTdNPt4ANzXOXsbqBsYJAVMGzrnmojkpwyO01Gld51huEKsRc2ZjKZlRYY1Eis8aMLA1EWa04L4k1XPq+hOCmb6/x4EHS4miraheEegHAjzHt373ay2u+SAM/MFAI5OU1Fy7+QCTaVpRuPRrtZyU1ZpQQdFZfOrlagg6ioEWl1BZ52gixxg7JLJjWymmKTGugU2B0oebWLxJpT0qI9pmIj9Qloj2n2sC4EJWSJUJkZGks5xoS3aiYcqFkSaYBQecEOVeq1DhTuF1mvl3eIkXBqE8IabqAXIlWN6w58Mm24/X9kTcn+MznBtQ1iF3leBcuA4VLuiWl6ekvMD4X6JxlLiCSJseMe7HnY/d/RXVb5vOX+PnfwFqIh1uiX0D3qAqpts/KHHpmryglo7Vh1APWPgNxRa5nal7ph2cM7seU7AGL0JZSEoeHr3l2/c9R4jc/2X9Yv9mKwjQzb1SU2kqhQXP9ZCTVynxa0UaxG0aMjJBb/5g2TXc/nY/sthtiFHz77paSBKSK6CT7ccuPPr9B0jYBx/OMQDLNK/t+pKTKzdWOeY1EtUPlzDx77t6deHN/x+h6dldXfHk7I4+vefFkx25j2LgNVimUtCxhxjgNSkLMrKeZ4AvGtSLzUBMpxu+SWkWTd6MMG2dbHLpIbHctifH9w4QSit4qSkqsPrCEtrFRWlAxvL5d6LVEuULKgd1+x/t3R7CWGFdKav1Gx8m3jpzi2boeY9oUfDCqMXJyIOrGpoxdj3ZtKuouoUBuYxEpc5gO1NRYmqlkfEwIJYgJUlzZDo6CotY2bc+pAQHXO3IKGLthXib2o6OWlsSljWjSagy1WkIKvHs3gYBxGFFWoVXl5c11SzJcPRTLcQlYoXl/e2L2GdM7gveEUFnnwFyP3NxochDcP8yN7XMCE1o/2c3NNSUmpjW05EMFtlcYrXDacAqRKCun6Z7xaoOukjWGNvCyFqUUtYAx3aWKJaJkxirHlBJ7ayhKQ2l1KSYJtG1y1tPpjBl61rASY2Ca5pbkOEVEEqx+xUjX+j3zipKtlzRGzzQ1drHrBYOzWCO5vbtnf7XDrx4/LZiu4yEs/OKbB37y2ROUEHjhMbpN0bOEEDLuwq79sP7hVpQgc2EcHTFGYk3cTa9ISWCMA9Oi8WuunJczWjXvdi3NptG8pwrrzEURVckpo4VFBMFhOXI6nFBCUs9NQiuEoaBIMlBtRAqwoiUXKmNJsbGrmUjJAqkcuQRCWVEZiILqKzGvbLuR7WbL+TRhNw6tDWsqDEZRNfhlxujWqUuqdKonF0EWBecc07zi1J6wRqJuEs5aBc6MhLSgRZPW2XHkJz/5KTVF3j/cosee5CPL8YxMEoxDJ4lZV4T2JFcQnaGslRQTOWeEaF7NJBJhhYRG6YKoAZE0o97xn/3nf8jdwy1fff0lUivuH+5AZvqhefnW5YwSFaclfSepvaFzjuUh8aTrSf5E1YFZJqrMZDxWaozuiQGE0OxvtuTpRJaREiCj8aIQiySXSBaJUhNGS7R0pJBBXgB8EYz9nmVNLHEhrSfGsSfWiigZP3naaZuoRTQPooRlCVBdk6vXwGA6/GlCa0E/9Cgt25BoCUx+Jom2x845IqRCCUFeIyYXfF3IVLTryVFwujsyxyPPr59zs7uiCMWrNwsSyKFijWPYNo/a4XAAodn018Q1stnckELrIFUyU3NCK0MnR667J/zk02uu91uWZUHen6hLYgoevekoOZMpWAvGCNZ4xMkeJQRaO0IM5JTIEdxuALPDy4Es/5FKqK0oCNsmBSELjCjfsTq1sWbqAhpKldSLZlYUUBTOiySSWILgtDa0W+pjgEJjaEoRlEvRcVuiAY/HgAt+PSD7dd/zwF2FGbCAq+IiXPtVJm6uAlsr/VTYSEHtK0FLpMi8cIKxKr6YG2BxRpBqYaoaSaE3ld2guO4k1EwEapFIIVACFp+gCKwufH02nLxgsJG7qT1Ora2s+9mgEbUwBd0KbSk43ZiqVhJ9kSxeXqCs34Gd+uhz4jt2EL7r3VIGhq4gnOCQuMgsm9EeBBnBHOolkj830CLEBajIBvjk5RFrez8GpxAysrWN6UPKC6CFx460IgSHGWJuk9JWCt7gsy+NXS0tRpJLsDMxRbosITXQVoXEiIqQzZC7j6b5FesFfcpAKhO1RiQCSYdSN6Sa6U1PZzV/8SZwd5DsNzQDap+ZY20T8vYtJO05I2RL5yyJkz+j5Ej1kHNkOv+C3m3Zmc8Zt094H//f5FEhWVH+RHU3l/qCejlUmlwLtUqkHDByixSWlE+EdMeT/T/D6A2/8+n/hZjOpOAJ88pnL/4PWLchpJWU7v9+J+sP6z96iSrZjB3zUuiHHkTG1QsHXQvdsGH1Zx4OE0+fbBGiSUWGYUSLypOrjuALuURQT6hJUKPHDRaN4M3tkYrlZrthM4xM5xllNjjToqUPhwky7EeJD7Asld//vU/4J+ITlDRIUXCbnnfvV2r1xHVhM2pKXIgq4qzmvMwsS4JcGIeRXCXnuzNCwuaqp+TKftshRGWJzSjfG0nwC6kEtO4YrGTNAbMdmE4BqTTGOqwd6WPCqsagHCbPs+3IWis1NzalpgWtKzmvCDKrP3A8NVZHxoKUgvlwREiDqIEvgsd1DqMNUiv6TrPWQsmCJGZCjFircU42b6zKkBxCV+7PZ0zfNQBcDb3ThFjotCCkjDVQc+F8bElusU6sITFPR27GHqcthUxaMzm30CmpJcYYPv3oCULWFqAhbBvCzQslZVRtYIdSsZ3g04+f4qtmtC0UYY2FcJHxaFV59eYe0yvkqBl2mrGOGKV5/c23DNsrKIlcW0T0NM2cs8BKiXSKEiudHumS4/bujmGzI6eMWhIpF4Yr06bhRTVf9zmSxcoaAzVItHGkNXGYZ0pppbBd1yF1JUyV4/mMEZq+G9mOG5Q03J/PdGjiGtAbAymzek8IkbCs9NstYfHEqHh/XlCqeZcfDmeeP33CeTqR0opRkp++vELKS9hIiUQRSLnSd479pm+Dxh/WP+h6tn2J04oUF94tb1jLgu06KImYA8ZYQmzdXkIblhLRuqXe1VIJIdCbHhElw9AkeSllaolM0bPd7qBWYgpQBc51WOdIseJ9U98YLbG2x2pNpSDlitQRgyZnRUigsEih6I2GmCmmx2lHjYFzucfLyPnUyrGV1lgbsUajRSXG3NQ6tWux99Jjh5Z3sPoVSQOcrnNI2ZJpu66HIDAmMWJRtYcM2/4aqiQnz/7pDedhyxI9748P5FqJU0IqQZKGVDyDMgxu+JW9J7qitUUbg7Mat7tiXQLOdjhb+OM//D2MDrx59xp1M6B1S8b2ceH1bbz49yVKCrTrSLGx5CEEfFh5mI9IZ+jGkacvXjKfTqx+Zl4WQoaQK9dKUXLbi4bc7mM+J87Tge2+o5ZMqor1dLpsfhQxFbSGh/sDpQqWlNm4PfmSFi0lXF2NTPPSgCiFaZ5bkNJmIPiFnJsi7f7Ve0oSdLZjnStCSlzXkSuk2HyFnkjwlepBtiAHZipjv2nl1SkhEZANphoe3r7nNn7bfMC1oDqBMgWrNbvxhrHbMqh3+PqeUiN2EOw2A1p3nA73nM5nhC4orVjKiX/553/CRy9+zB/+/s94/uIT1jXRdxt+5+YJVUv+5ou/RprG/mup6btrSgkUOZP8gtEOXxQoxdPnP2LTbbG253A6/8bn6W8FnG3IFFnYWTguAtdXkM0ELC7+s3KR04XYYkdbThYomQkhcxtokfG5bWIv3BGSipIS2Qa7KAGaSoyCR+zxfUD1/VX/zvce/VYtwbGFhMy1PZ4RYGpjzpo1uzE4j54nAYyz4NlzSe01cwIZM5+5BrgkoklUlMQZcwFK8JjgKBGtoFpkRK10QlFkoRZJCZHDBG9PF5BSL1pE1UqupWh+NJ8uHi3REhIbAm6biMeD8QjV6odj0xhHKSRGtRPc6cq2ExRZ8Vky+cpcoNb84Zhd6qehNM9d/SA3ufR11eYSr6lcmMNG6uda2WxGLDCdzx9kKkJcokhqA2M5lw/gUTxKLS/o2ShBoHWMXTykhNy8Ln6pOKfQurQSXKNJ5CbplIpM88XkkhFSXcC7QKs9Su8J4YA0e/7g4555rfz1Nys/fSkwGo5BEnNu8kkhLkEijbFENA+L04K1Bpb169bh12km+yXb/n9H9Eek+QjDDVF+RfGecn6H4kftWF1Qai0RWTKFjBIDsQZW/w2T/zmd+YxcVs7HN+z3v4+SO4QLaEzTU4eVkk6s0ze/jVP3h/UfWC9fjEiRW8DHGjgcF6BileFqv8GZwNXVnhIivRVshg0xV4RYSCkTfWCeM7vdQAotsv5hmUm18v71LZ99/pIlxpbkSGa/H8k549dA3410piNTMNpAiXy+sxATtt9QqyRGz/Fw4v3bI7v9QIktBW2Nkd2gwBVsFayXG2zOC6fzgtUWqx2dzlgc5/PM6jPb3Z739w8tqQ1BjJ7BRVKpjLbnuBzxMXN8e2TxiRdXlutnT1h8JK0JZTUJsFqw+BXrOubzCecsYZ6xCrrtlk5ITjGSi2I7tG4vZIePZ5bZtPNCK3wK6FAxveNuyWx3O04+MZTE229v2zzIWE4Pb0hRs9tYKGdSpUXNjz1VFhYpCalds7RTzVulVmIs+PMZGSPZWW7ne+ww0HWWIiL7btPqUAqczg+oUlhi64E8LgVdI1ZLlrliNKQSqJMgSkERgukhUygYoci5XSezklxvLU4NHP0DsmRcZzH9jnlJPBxOCFpwgNWGZQ1shp6g2+R8aw0+NvbCaUNOBaEd0lnm6cB0e2ZjOlQ30I2CuCqOpxPWGOaaIUa0tIz9nuN6oh8dIgmcMOQMgx4oKTFoR46Rxc8MxnI8R4ztmE4rVUiUVsQika7jMC/s+yve3r5DSUuuHqsVYVm4PxiUUUyHFd0ptFH0ORNjwAO1Ok7HI9ebhbsCRfx2Msp+WP/+VeMBrQZ2V3vmdeH0kAleUXIll0wMC8705ATbfsv1zRW7/Yavv/6a8zxTBTjrQNBAGZeqGHqEcPggcc4R04wUAiE6alEo2VJOre5xfYcSFiUM5/M942hYw4EqFEp0mKqw1lz2OytYKFWRdEuEjGlGGocs3aXiR2EEKBTODMga0dLglwVpe4xRVAS9G9BP7EWe2PpURS2IEqklNc8dLZhOiMLtdM+3d99yPt1zvbvh7du3WARPn96wFZIoF1IHyA6koRYHQuK6vu0BRWMbO5PbXk5p/viP/hgtBf/qv//vcFbw5c+/4Iu//YI5zAgMWkq0kkBGd7LZOqYFTUtcLbXVLNUCsQYEibHT5Aqjsvz4o8/of+w4zSe+eX/Hz3/5FX4JxK4jiAKi7WvWGMglY7qOWCoxKHIUlNKqMrQTaG3JWdB1W07TjFSCNT6gisD1jpcvfsTWbYlTaHyJFtyfDtzeviefEqoarIToFzrTNY/hIVJiRHUGimRaFxSCnCohFoRWCKO42uzQShKmM11W+JjIpYUuTXGmJVkLsgSpL/tSAZUAQtJ3md0ocWJPSk2VcjgvPLw/ItV0qTlQ+OQxtdWIZClZ08z/61/8P+isxhnFaBzz/TfEWnl5vWPygZIsN7unnM8LPgZUhVoKafVsttc8eXrDEhZOpyOb7RXfvn37G5+nv5Ur4fsg6aVg1xdCqAy7Qsi5lfohLh1egpIy5EwugqVAkYWhKqyoDKrF3ZsPIKwBHSPb96Rsm3QlK2GF9z5/yLyAf5clg1///zUlbPuTL/8ONAvbdyCvMWiqNsBmBLhauaqC8K5inoPeCm46ByJdkoa4+Lsu0LI0JG+kbGxfLQjZwEYpknRBI7lKnm7BucwcYIoQMpw9FJMOVCMAAMnuSURBVCQn36RwaymXgtDKkhRbU6mx/U4lHwun28ADcfGjiYqVEqtBC4nW4FMzeB8CLCWxXg6MEu25cWF4BE37+Ai4vkvdfFRQPoKux5CXBtYUgnVN/Oynn/Hl119zd575kOlYIV+kllKA+F5YSQuJEfSyVQyIWnjMsxS1UnNjBWvJhKUipaS0A4sns3n6DHV+R6mSdCn3dvr3IH9JAYx+itYDLLfUZBA18btPMk86xSkIHnLiNEUsreohVdCynfyP1F/JrdD2eiP54l1C9xqx3ZHEEURlXd8zjL9DTRlRJCIF8npEzm8RqSCkBKko8S2xXiYpskMUh2BBCssaXjEONwgqOdxThcLoHcjWNRTjkZYK80Mf0D/0krJjnmaUy2gpePl0i6KgtMTIghFtQ65EISyeIpr415gm5QkxIqRgnqfG/A49WmlSzFw/fQJkhq6jRMFuqxBVk0pgs20s/i9+fs/PfucJSyiUWHl4CFAD6rg2j9TNgBKF3/8nL/De8/59IuXE4DTKgF8XlJXcXG3QqrDmSIya3TgglaKETAyet3dTK2999wukHVvHUPQMw4BEovBMy8TN0xuWaaYQGN0IZGLN3N0fQQ4MZabKFj6itWBeAkYVTEnUziBF85YIVdlohTMdWSq8bBfP8KZN2j/66CVhDagC6/TA+ZAoNfL62zvevD/yuz96ybDdUlLCjh1jP+K9Z9cpUo24Yc/dcWI1FX9YcWOHUwZfMj5EliWy2/YsoWM+POAUvD0cMAry3YI2FoPil/4thUr0EqEL++1ILq2LyFiLE5aFzPVNx3HKFza1bSyXaUIoi9bNiHuaVzrb8XCYud6PrUojWrTXxHDCVsnHnzzh/hA53X5DFq7JjIwkpoAxPX6JhDWwuX7Kej5RcmJwPSkvKJ8YlSCZxoadw4wxHVVkSlrwJVGVZdP3UDWxBHbXT5iWGS0UGUWuCecMUXhiTlipGLY7QiwYnVDG0HUOpKDECb9GXN9hSgN01093WKMJoQUzCf2ENXpCWjHXA6ZATolpTphO43TrQrJ2i1aCUVmm8/qPfNb/T399+/YNT/bXKNPRdSNOB9Y1IIT+MMDWaD5+/gmj3hDnM6f8Hq0qMSS07slRIpQkC4XUGiEk3nuUEIQ1I0tA5YqQzdNWyopSBWMFJVWO0xmJojMdSihIYMWGaW1s9HZzw09/+nsA3N5+Q8mVw7SypFtiTVS1IcZMZw2yFESuaK1RQlOcxvQjyzLjZULZ3Aa2PmO1QtZWjiy0opAZO4dzGqUlPmeqkigrqTmzxhMhreRaWJcVoww31zfkEtA5gTLUfc9p8qiam5qn5pYsqJpXtYSMkRpdoabMq19+wc1+z4ur59zf3WKUwqe1XZNpuQLDpkeUxOHYFDJWGnJqSjIJTJNHSdlkoYBRFqMtxQduv/2Wz370OU+eveTm+WdcbZ7yp3/y3+O0QhWBKJqsIeWFUCPSaAQRKw1Y21RCxdM7gxSaGiQvn32CGwfO68J5es+3b94wT4m//duv+OTZR3z24hPIgs3NjucfF/7yr/4cLeF4ODHNZ5ZYUbXQmYEYImXN+CUR18rmyZY1emKN5CLotGUwI7//+T9FAe/v3nFazoh4QOuI0pVUC7GEFtakNWM/UnLi5CPH48y5LvRqx4ubz+jNjhieY+yR2/MvSWVBaxCjgpJRyTZrji8oYXBuYPyoZ5ruiOvMw/FAXQNPnj9jN444ZZFSE/2KUZFuO+Bji9CvKLTWHO9uOU9nQmjWh3EYfuPz9LcCzpasOCdJrIn7JdPi/gMiKUIp+KKbjrhm3GV372wlFlhTQYnKoARCte4qJUF/kM89ihEv8Qy1MSrfX78CzC4/Xr/3ffF3/jyu75dY/zpwl2jAjUs4xSQqTzMMd4JSBM7BaFR7ThREkd89B3IjzoumiEblCyEvQSjiA1OUS6UIiTWtAyvkyprSJQWyyUOVEGgBQbRusaXA3lU63SSSSImo9ZLg2ABfo2kKnsocm7Ez1xa2UmpFVNF0s6rJFrUsqF8xY3/HvrXJGBcWTVyAWvmVFMcCUNrrWvLKv/qzn/Nk2/HJkxu+vT2QamP+8qW8uz4a30R7nlUorIDeNFKuPAK3SwdeS5rMXJrhyDWhK4S1TbPfv30LWnLVX/P58H/meDxwXu65uMeQ8hohFKXMVGZKyR/eFx8so64cU0ubFLWggFSat85SibU29pPEw4HGrXrFzfhfcdB/yZpeUcqISxO1BMRaqCXCfEe5/X/C9NVF2qtx8a9QQ2H2oKTD6g2paJDfcl7+muntF1xt/ikmdSg5UuSCs1tKiRQfENagTP8feXb+sP6+S5QzVzvbijOVI4QVKSrHw4lnT64IJXO+O1NyZrPboJRknhbWud1cGwPVgimGYYBc2N+MjXG9OEhjrbx7eODZ86uW6jgYalJQEz/7vad00pHTCdlbXIWYBdN55unNFnRGCotfJr54deJ6dLjeIJWEGoghEbJkKgtKSDpd2e1H7m7PGK2IMiEj6G7k9evXjU2aDzx9MvDi+Q6oxOwZjGaRlfuH90gEcQkwWvqNY1lnrreWJWdqqShrQEuc60BHavKEIlBa0RuFdVty9nhfCUmRdEEVSS2Rj16+xOjWmZmqJtyv9P2OKio5GIxYUPueQXn2m45cDSlksmkNapNf0YNjDR5q5PB+xjrD+bDy+rzwuz95ycMa6TcRLwqlNDlq3xuE0qzrijUGP6+sfmazv2Gz7znNleV8YA4BO4yE6FFxRUpFqpnX/oyyHYNrlSp3t7cU0VILtRDUErHaoZTm+YsNeY2c7s6EFJnnM2/eB66vZrQofPt+5pOPDFI7ht6CklQkMQZu71ZML7i9/yXbzZZc4fTuDf04kMWELND3I4fjHVe7DYezZFqOiNVge4cyPVY6lmlGKUVOhofbjOsCmB7lBEIpxt0eLTNjb4gRei3Y9htQgprg/jxhlebm6Y5lSgyDaEyJj1Ay/qK4OJwf2F3tqMfAumZiEVxtBKJ0nP3Cpt82qdeaSEQwraPth/UPu9aimaIg396zLCsKGHrD/uoJtUiSj9TU5ELFFZaQON4f0aptMq3pkUVd1C/Nm2aVpuqKVJBjplAZNiM5J4QKICKlCozu2uAzlxYQJgNWG2QRiOzAx7abSCce3n/J1dU1z642GDXwIsP7o+LudIcQHeu8oCrEkqmqfW6MNejyGF9f6DpHLgWfI6hKlc23hoqUi6dK6ZZa6kMEpRmcpeSC1BIlDcUMeLEyupE/+Cd/xNOnz/nii1/wumpEVRjp8P4NpQYwkaKahNkYgzKCEAL73Z4UEqfzmXfv3vL2/VtyaXI6XSKZiJa0IX4u5BjJ2SNExocVZzukEqA12klkH1BZkqLg5voltVTm+czxdKIIwV//4ucULbl5+oxnVy/ZDw4ZAlZJksgIKVCy0BvNHDwirYxd39Ril+T0zjl6u+H57jk/+fR3kShefvqSL998w3/7J/8/7s8nFr/wN19+wcP9PT/95HMWf+Lbt9+wHXuebnYMpXBbM35ZOZ8j5kpjux3vjyvGGZSUHI9HhBZYU3EORIko3QJKwhz58Y9/n0LkzduvCHFiWu7oRceyLkznM13fs+k0OQuyzEjd0+mO4+nEv/7TP0Eqh1AdqUTmZUYZWudoZynVIU3PuiyMW4kVkvPdVzx9+pJPX3xG9Zk3r75G1o55ymAXvn7zLV3nMEogjUQLwXF6QGiD1JabqxfsNjv+7b/9U/phIMaF83T4jc/T306U/loopRBL5Rzh6wV6Iei0oJcwyMRMpaQLcyIroshL6MNjOXWlVxKqIiVBquI7YHCR0sn6uLH/DmR91wP165f43tdfAWcXBuhxUtQgwvehYFuPj5yAM016eeUL10khdKaoi/zv8VCK0nxgQl4azMoHv9Ujg1hLvZQTt81/qrCEynEt1FrYdhUjWuxjJbfnpMFnqLIFYRyDeLTdEWsDfFzUkOWDPLECjwWHF5GjKIjawB6XKU0RovnNhLgkbDZQ9Pj4jwEZRckPre2XWK92fGqTVhYurwmBEImH5YxLlk+f3/DL9w/IFOkc5KKZfLo8xoXtK4XBCJSu+CIvPXYXaeiFvavlkWdr75SusM4JJQWj7vl0dCzlBe+/nSjrW2K+vRz/itUfX+Cyb6EbpfkYJRBTwi9gK/z4SrFGwTkUllRacmhtKUFG8SHNrNBKNO8e/m/UPdz7e5Tfo5QlxjM1ZaoU5PAay0CZ/5pQMiVPlPLAaAROCYoa2gQvRJSUxDwjLlPslCsh3RHzxBzuWNc7hCyM4id07ul/zKn5w/pPWEPfvFhSaqQ0bUiD4ONPdxzvj/SjZhw7cklsBkdIkc2mp5RW5N7OGUC1/scCHB7ODJtmhpZKIWPk5csN54cDWlREhuAnnFXkZeIUBcPVyJvXr9HCMG62mE2HcZbVr5AjT7aW7id7TsdIpWK1ohTY7XrmsF6mrBmhOqbTmev9BrqWRqsjaNvz0bPPKKVgtcUYEFURQmKrgJrphWAujpIyw80VJRZGJ7nePiX4hBKCtRYEivN0wHUGoQKybCgYtFYo2cpl7x8qOSZOYWXNbcNwvd8jJDwsM6VmrLDsNppv3pywtlLryuwVz19sKSny//mTX5KqwOnEsxfP6aymKs3D/cT5fODd/YQojqe7PVdXA/0G5hRxttJpS7yUNBtn0VQSFWG3+OlMBrr+Bl88vU84Ae7ZBklmSYXiHQ/zgtlbbF7Y9zekVNFF4wNsxi1FSKRQzV8tKkpZAoUUEkJp+t2GukRkWfj08xvuTiuv3tzirCQEhaqZuzRRcibFgnWaqu0lfS7iY2EKiauhYzvueXh4oNTKMZ4RcqSap/T9yP1DQNSFoR8wWrOeJ3a9oVJ5mO7pNhFkpZjIftiQMhxPR3bOMZVCTZLzMuGMZNwMpBjZOs0wOPzqkURKMSzzqdXSSE0sCac1Hz/ZMI6O3GuK1MxLoMZELoXejWx7Q/CBNc6YrmedVqwy/7gn/f8Mlu52+CqJi78oegTaaA6HB5TomurHr2SROYaJFDMlN0uJMwqlMqUmiiytn68IlNCY3pJyIlXorGI7bJnmQ7sOCIFSpqV6XmRKUkpyDCRRGPVIrJJuHAjxSODIl2/u+OqNQeuBcdiBypzWB1Cy9f9pQdd1bFSTVj2cJ/IcMEqxrmeUEA2kFRjtyFoX5ujbHsgUjH5szI1IowiLbxLHtdD3PTkUUowo4RiGHUIY3t7f8c3ta87nW5ZywpfKdDfhhGqx/gaCqPh1aoM5oehtT0yJh9MDPrXrntCamAK6QKdaz1/JbUBeaiZ4TUqVxVd8yKQSEUrBfCadEsEHOmnZqS3vzyeyUiwh8LBOvPUnht7i58jpq5U337yjz5Wn1iEpVBloXcORHDJWwnYcoSZqXQgpobVj9gcwkrugOf7ln3C6P+CM5ZOPP+d/+ft/zN988QveHe5573NLBFeW93fvePv2LR/94c+I0wlTEp2U1CqpyjL5hdPxSDUGoQ1zyozWUktAIrHGUTEUUfnm3c/x04lzuGW732KdZndzTfz2zLJOlBIvoDe2/WcuLYSuGkIWhFJZZULkiLp4nrc7hzXNY2iwpFjIa2IUHWE587Ac6ZxChC0qbRHSMIxP6G8c98cjD3NkvL5m8RNLXLFSEU4rqUZ0FXx085If//h3mY+Jj1/+Du/vX1MrjJvffJj+WwFnJWfqpQ1KCVgTCClYSsUIiZMFJaDKikiSUiXOtoOXP7AxQCqgLxvxR9kcQK2kCysDzdT96Byu/wFg9nfXrzBp35NEPn5V3/u5738fvgNugcqxFrZF8XzUjQmjyZDyhRWDxv7kRvWhxHfsnLxoMZuMTzYGp7QksX0PPAKTUi+AS1NrZbAFLQVLujw4ohn4aUmY5ZHDejRwPWoUKcjaJrqIirr0z3zQYbakivb8aqUIcQFg7Y+4xNc/HoXHgHnxwRr34TutM+RyNESRFNHSxN49TPxv/uBjfvHqDcc58fR6z3bX8y//7CvKpVrBSNiI1htX86Us/MNb+11xeGPwHs36giHAT65HstG8PXpsTWheIOpbigyI6qBGtL4h14TRI6lEptB4rFQKnSrMAXxoDFmp0CvJqAEpWWJhpQFfSyVcJJ9FZGoM1BNk+Zbo35HjHSWfqSIDEn/8mr77Q0peqcUT64rWEacEveqZqqDkM4v/mlLA6C2QSfmBs/9bHqY/a4wllZur/zVPxv8CjOX+4Rf/0Z/7H9bfb4VQ0Fq2oYDKFClI3nMKK8txZbe/AZPxMXM6nbm+viaVjNGK09yioI1ykFovmFCZYbSUUggxk1ePsYowB9ZlZT6defJsi9KS45zpjWIzWA73Z1JxFFlIhzO77cj5tLL6lVIzd4eJ5D1IzTytZCp935OiZ1kFzla2mx0LCb9Gcj4iVthte5SQDJ1hiol5PlNzT/Wi3YBCQORMrbJ110jJYDumecKajjvvkWtGF8G8zExrwFjD9dWWb799x83NnuM0kwrsnEFZidQWrWvzgMjK3uxZQyJRuJ8fOJ4fsGpgZzxGSjYmcHs3c3O1BzXz+usDUheevRjZDo41RXKJvH038+TJwPk+MIfCJ0+fYDpL8IZhHNltOsZ+QyiVuE4M/Y55mto1TxrWMLH6GSUE4zAwrQtVZoR2OJmgKk5pxYdIRrEdLUVItLEsaaH4irNbhFOUannszjHWssZIbyWi2xFDbGqKFHiuHfO8UEvEGcHvffIZyRdCDhg7UKJHO8O6BlIquKFDxMDTmxtqzFwZScqBYWMZ908xRaClYloCKS/cvnmg7xWdviLHwDIvjKNDCIUSimfbPUUllFAUBboonK0YO1KzaF7BUBjtyLRMiJBx1mAETHnlPkyMxtE5wZokNVVCWUG29EVpe+Y1IkWh+kiaV6YQcZ2izIqvv70jl4VdP1Dnlc1W8+bN/I992v9Pfm31npACKS70/YDSghQKacmEEtq9VpYW6nNe2PYdVQo6IzBOMadIoCC0QSuLUQZZwPWCWg0CWH0ghal1IKoBSqH6zMZYYvJUbYilMC2JYiSVFSEq0S+tT1E2j5r3hVI1ZV2J+YTtFQjFvCwYY8ml8s//+J9RMvzLP/2z5hEXFaoHMjUJVJXkORJjJsvC6meMqAzOIQScV49QjoxhnWdGLn2sqLaJU7H1AjrB+9MrUorE6FnXlTUXoEm1pdbNu5UjOa5Yq/E+ghDM4cRhekBoRagZkscaRY2R9iMCawwKgVGm7eOkxLiBWMHn1junkmFdZoQc8blwFokajmhjSKKgnCbnQFaFbttTo2i+QG3IUiBFIYtKqQVnDSBIOSKl43RcSdkzDCP5okoq6cx6WrHSYK1DaMEvvvgL5vmBj55/xGa742Z/Ra6Z/c2WtXjyt4bXd/dsHZymA4fFU0xlHC291dzsnmL7gdNhRmtD7wxDr9hsR+4PZ46TByl4mO4pcYblluN6TwieYejpOteqTZRD2y1VFI5TbLtQvQEhEQKeXm+AwjydMNrQOYVR7U9OgTkFjKmYmlFFkJbCZ5/8mI9fXDOfTkzvX7GsBeyA2/TslEPgOE4TvgSkUQiRSaWpCXYb1VJKM3z68jmdrdzffUORonWS/obrtwLOKjQkLgRGCdYIna2t1FhIltwi3LUEJytaVkqBrWkyHZEFtZa28c4tLUyoegEcDZTlBHNqoOUD3VV+zXOpv/q8vr++z4YJ/t31d1mz7//MBdtQgVgr70+V6+uCvjBiTUrY+j6a7av99oZ9ygXqNLfbB67vEvahZQNrtQiQTeqYhGjA9fJMZJUY3YpaqZVYWlx0lq2Tq7327wFa8dh/xq9+pYHklhopLl6+VorNBQCJC5hszF17suUDYOMiLGxywe+D48e+54pqr7iKtvnJM3/96p7DuRB95it/4PcGy+9+/pSvXt2iKcgKTrWywJRa7Px3Dyw+/IJHz6CQLbQjzBL7xBKVYk0nvBoIxYMckOwR5RukGLC6yamUkKzpPX/9Hj4a27tRy4UJlAVyCwDIl8TMFicOTjdjr6LQV1hy++yWWhCxUmVD6SWfoKQPx2Y5vmJ//b8glnMr0iwrWrcPRhKSNT5QwpHObbg/fcN2+AmLf4tkS0gnBJpUT4DEiIGue0FMB9R3pXs/rH+g5ToLAvzqyT4SSqGzGisqm5fPOZ1m+t5g6PHJA837GWJESw1WoSWscyTHRIiBVCtGPnaPCSiCmCtSV+gt89wmpFJoRG+4P650m55RZdRF4puFJiVPCIVp9eycI0uL94Gud4SUKDFxdbXlWhuMFJzXhLIdfbXsNz1mtBxu71sRcYFaNEoNRFGZfGS5P1IQPBwXlJI8vdpThWJePakYNILkC/OyMJ0mOqPxcSWsLVp5WjKn4y3XO0uKgaVErLLEHCFWtruuSaCnCasMthT8OaF9Y+6SLBit0c7y8uMNvZPMJ9h+plC5Im3H4iMhZ1KZ+dGPX6JUxWxGDqeFH390jfcro23lzud1gtpM9RgJJExnkaVwiis+Lry4eYoUBYFg01uKaPee6Ftq5agdg2yJa1JUfPAYO2KUgj5hpOE4TfTOtKAkAaIUiJAknL69R14Gb0VUNiN4v2BU5WbbsS6Rq5sRv8DD6chmGPBhZTd2KGNBGGquvH//wGefPOeXX33Bbjvw5vV7jBFIaiuQFZpaYTNsOD48sKiK60diCZx9xZDpjMFpgVGOGAWVTBaV5BPa6XYvTqCsQiVQ47512q0TXW84PGRUMaSUOZfImiQ5RTZDD2XFCoOfM6Eojg93WKPp3IjSiuNxZrexPH2+JeUOlTOHNXJ3apu4H9Y/7PrZj/8pw9hxd/eWV998RZhnqJKNG3nx/CNubm7oOsV+P+DnE+eHBx4e3rGGhfMyI6zGWYMuIxt7DaLycL6lruVSNC4u+w9JypUsBNGnVpOQWrJhiCvL2jy5p3Uiz4W+d1giISrCkqhCEtMKIiODJYaAEpaQZpQxhLX1U337zbfsdtf87A9+xl/+9Z9TyoLrmtys5MziZ5x1WAXnxaOUxBqL1IJaMlIKcmk9p1I2y0opAmcMKUcqEUqlE4ZTXDkeH1DWUgwoWXB91+72pdBpiSwCM1xRi0YI6PuB24dbqjYs68xgNM5YpLJk7QhxIYeEUQ5RNVKoVuxdIzlVrB7ZbzfUnFiWc5u9S4nSliKbFz9f4uD3+y3T/MBm7FgXj3UtmESkjJQKJUAqQxUSXzJLykilmOdETpLObaFKcqys50gOZ3qj+PjzT+kk1HQmyplXr/+KGB4w0rCrhVKbVDstmeurHW/v71hGiXSFGCO6CGRceXb1nJv9BiUFcb+l67bkmhGq8P79Ha+/eoUzim5j2Y4dS6jUqlBKMfRtoF5KQRtH7wbqhbXX2iFlx7JkxmFgc2XZbnr84pExsbvasc5nwtKSa3f7HZ89e8abb1+TL+nxu5sd19dXhCkSF4/TFTlklnzkfJwZ+w2lSOJpxp88ykiGnWM7qPbZKYLsK//N//2/IcRWGxbTjBsNScbf+Dz9rYAzpUBeZIidrixRUu1jJ1i+4CiBLwJfBZ0QjLawNZUFmBJUJLIWRBEUCbmI1sFQm4yvUC5sV5MMCtl+9vvessf1/X8/Ml5/V/z4dwHa9/b/v3b9qhtLsKTE3X3Hftdkg4+PWHgMBbngR/EYatEQ5a9gjosMsHIJTBGPLFxLP5EXEPuIrmRtIE7I1oGjLgAuP4KgS7XAhxd30W0KxHev75GlvPy9sYiXSgLRvHO1tvSl7yAYj+LSC+PWeMByeT2P0sbvewTrBbI/Ck/f3U30vWSlQC389d98y++82PP8euR0e6YCQw/kylogloqmsVVVClRVZCpFNeeZyhKhKw+zp9sr6qIYreYv3n8J9UcUIcnlnlI8Wt00b0480MmCUgfmWPnyoLgxgiwT8vJZagfiu4P4GJyZUyZXmKpESdgYQdKFeGFIc81UKallvnjxJEpZyvk1cp6I4UxhhRqRFCJQVCHyHikEKR+pTJS6MrqnKNWjawe1deFt+h8z9j9mWl9zPv1bduOnv/6D+sP6ra11idjOIFWrU7BGUErEug6lMnozoqRAyZWhv8aHGaRsZfUCwrySRANf27Gj32hSlJQSiOvK3dRKjofBkEPlejtiNcwx42qirCvzkljWgOsaCyOMbRHVIhDDSi0wh5U1epxpsjNjJGFamM+Cm2ebVj6sI1pk3MZxXFf0EqhCcpxnfEp0/cBGG2KumI3F+4XVJ/qxw/vAm7dvmReFs5Kr/cA0rfTOsts4dpuxyUSCIUdYZ8/YwWYzUHJG0CSep4eZwymjFJzzTFgrL1/cMHQ9qQSG3UCK7fqQSzvnhBTYyzVv92RL33fIUphDZbvteCY1Uromz9KJxSdudrs27BFNZonUaN3R9xtu72/RvcLPEaRuoEEJzifB8XDieruhSvC1+X7DklGqw7qe0+GAkBJRYAoLtQhS8NjdhhgSWVU2Y4+mkIygYKAklInEVLi+GfC+YJSlUthtRkICZxIlFZIFLSrJVj775GnryymOeZopqTZJdoGPP3kORG6urhkGiw8epQzBR3JZKLGwhBVsx+76CTk2qdJ207P6zHLOHOPEdrdDY+iGjvOU6LRkWRe2OGpq/o0S5YdaG+sU1nUc5iNWuaZ6UIbTGqBIpIFpLhg9EHPBe0/RAj1ecz6vHOLCYB0PkyLkI04bbGdAtGDzm5trpnP6xz7t/ye/lvmB9+9OfPvmFct65upmCzVjtCDGA7UMHO5bop4PC2/f3hFiYRx27F1PrJlSLP14RVwLKXqcNsS0Emu52E40yjpKAJkV1vTMcWopgSlBFhhlyTFi7cjzZ895/fpbzLhjOp3bdcyJi1JHILTGVMu6tI69vtfMrBjr+Muf/2us6Xj58Y/IZcaHM65UQglIqdGdJZcz1ll2qsP7BBX8GikpYjQYo5rU3G2Ja6ETDpkbU1xq85/f3p+oCEpxrHPAbSyds4BkXhd665rPFMPplNGm2VTGbkvuBHfHe6xzDNbgjCaHjHGGxSjEKMihotA41bOEI653KCeZ14hfAiWWpszoBb4s5Ao2uyZXXhd8Kez2W7pOsywzKEvIhVE7avBUUShSUoUlpQVpFboq5KUwSGlNzpFSFVr3aJsJcSakzDydAIEtuYFLKzi8/YYrZ9hYQQie3A8833/Cjz75KQ9+5stv/pYsZobBgFMknzmuJxKRvE4Y19GVlSVEluCJwaOGSiaQqKjchgBWg1YKKRrTl0vzJZYSEAislShVGHpz6UhbKMWzLCvrAk8/+oj9fsfx7h13t69RpiNrxd3DGT8HyAmtJfP5wJ0odFKitGNNTf7ZdVu8L8yp4DooNZBrRCmD1BUtFYMbyLliuo6d6ci1Mq9netl/wCy/6frtyBrLJdqT2hrb10oLEmxBGr9KgjSJ2OoFd74lIZrLZvgRIPgMaxEUUVBUlJBo1SaDpUpyAaGA9OsZsPq9r3/XOwa//r/5961f52grVFKF+3PG9qUFBgguYSVceLLvZH8NwbRHavu2R1jzGHIiyEV88IaV2t7IUi8wp3JJgvuOGZMCOtP6hWpp3Fy+gMJavnvOzad3Saasl2CSy6O039UKmuuF63l81d9PZGxsVUGIcomWf3w97WeyaBfkWuuFzBQfKEyrGuPUettyk1cWgaHy9dsHnj3bIa7aZs/ITC0CXy+AqPIh6RKaD2ZvFONW8c8/2aCl5K/+3IOPoAKpgFMvOE7vWMM9iAcAlBxBJFK+R9qKlZlK4XqsTCfVbjayFV4/CkTrI+D93vvZTrJCrAJSbUmk+VOMfI8WS2Md1QUkU6nM+OOf8PA3E60WpFJq82kgEgpNSiecq0zLGatBGcdpOiCEpbMjxgJioNYH1vUv6dznbLuXLOH4G3yKf1h/n1UoxFDQWlGEbDJF54i5fSZcJ5jOJ9Ia0CYTL4yplIXTtLbQnUFThOL07j1KGozRvH1/4Nl2w7hVLHOb3o5DTwqBUjW7fsN5PnM8tZvDYA1Xuz3eR0KM5JSpaK6e7SELEoUraZjnFUmHTwlRC2boWKcTWIExmuAzWgj21xvqGliDYLzaUkKixkCkEnNh9oHFF7Kv7MbMrttBl+i6xLDpyEtgWQtGgXESKQW9HRh7x8PDhBw7lJKgdCu6lgXbO7oMzz4e+PLrbwgqoXeSKArneWkbhEv/FRXs0JPwlFCIAqTo8cuCls3kr1TEh4Q1iZwTShpSAJEkqqwIJdCdIaZExbc6hOCRwqIQTKExe6dT5uNPn9Ibh3Yddjtyd3dPETAHiXGW692GFD1JVbSWnEQgysRWDiAq9w8L/WVS75fActF8aw3LdKQKDUKR0orSGmkVrnNoVfjo6YbbhzvuDzO2k7y7PzFox7vjjJQVY9r0vZZwUZAUTg8t4r4UQcp71phQJVBLospCJl9SYTPatc9st99hCmyHyhpX5lmTykyo8HC6Y1ADOQmMtcSsWZcj+yc3LPNEiJ6SQUym+W615N3tgeurkU53qN4wHY7ECsY0L3FMILWiCsv26TVr+IpBWaSWfPbxFYufkMpQSmReC1J33B49Of4md+cf1t9nvXr9c6SSdFuN2YzYwWCNhSLw5cQX3xzZb/dM79+ChJefPuPu3RElOn76+U8JwVOk4Ownvnj1t8zrPaoEdKepCHIGUQ2351s6M7Df7bg7vKHKQMix3VuxxKIR0hJDxZkBowaEGvmd3/mcu3fvm5RWjUgt2GxHntz8lGU+MZ/vWf2EU13bvyiLkIYvfvklOWXGsaeXljVOzGvA9BJRFE519HZAi4j3CzhDlq1P0GkFQrLE2EqxL7U5KSZCiay1EHNh7LeMaoNeZxwCHxLSOoZhQwlNrl5qJVtBSZHRdty/e4cVir21mM4QcsDXyFImtmqD0ZrpvNKcEIK1NltHDIlUKsoYCAlDxcmedY1UJJ0dyDETloT4/7P3J0uyZAl6JvadUSeb3P36HWLKsTILQFV3NUGgyUX3AguKUKSlKb3liq9B4Vtww2chF1xQ2BsSgiIKhaocKzMj4sadfLJBpzNycdTcbxayiM7uTJZII45IxDV3N1NTU1UzO//5p2jRGoITCNkglAVtyCESfWRt22X+zGP2gULSVC0pehSwblccxiNzCLg8Um8MTbclTZ6jm/Ba0+iqLCwLcBlUijgvIUny5JD2iE+Zu8OBcTyxXleEGNGVIVpbwleyBLnG+UgYemyjEXEmiZnVrkVJDbFUaAkBtYLoAjl7qrrBh1jCWkTJXK80pJwY+yMxJWIyjJPgcDjw7PIawsjxZiQFj86w3z9w/+GWWir8saeWEtvUaKMxCJRuaZsdk9uTlODUnzi5GWsN8zwRxAQ2E2UixogxdUlxNgohLS+uLrm6uAQyh8MDw9Dz7t2b3/t9+gcBZ37xxBTWpnilfEylu2CRyT3J3wqnlEUJ+Yhk5lQCKjot2RmKxE4kohT0HuaUmYPAfQRgzlSQ+Oi/f0jG+A/9/B+M38Ga/f1fPTJ1WRR8LzVkic8SQUme1Ge2hfJGEJmSMLlEvOfHPTkzVRRfx8LalDRK+fjseYlPfbSTyQKkShR9Kh0jOaOkeApAfNx+mSic35SJvGCnRcbIWf5YouvLrhVvmZJnQFIAHJknqSlnMJbLO1Ut4JSFP1zAXVcJkIpsPDKVD4RIMeDLLPhw03OxNnxxpRl7GFIihCKJLK8lP5KAScD/7j/bcbHT+BT56a89KSfausb5jHKah+mGPtyUzjxxQIqIEhWknujfs1lVfH8nqdqatx8OTDERXCYGGF3pMxMLiEWcQWrxxYksSSIjUzlPComUB4QsSXVZZHKSC1tZvHrRH7jZ/+syKRQSpEWLRFIKkSNKerQoRbfgSGGisR4hHNbODKMHAVImQv4Jh9PPEWKDrT75j13N347/iaPvJ9x8omsV0xSIIaKtRGRBDBGkRNmSyNdJi/OJ5CNKw3mBYo6JPgwordnVNcInPvv0CpkhuIlaVxynAUfFpmoIaebhwwGpNcOc2bWKtql59+HAGAVxmhic52KzJjEjpcBISVUXCeJwcDy/3LLbrXDBl//GmbaFdtVwe3igcobG1mQh6PuJ/f2BXdciM/SDo6padlagu8UfbCQkTde0ICM+VnSbDpWgHyeSVMWrkiOyMlRZEIVEici2rvnm7S1WK3JM3Lw70WgFwtDaCpNtqeoQMLsJgSGlhAiJ6XRkvar59dd72sZTVZaQYJhmxiVYI/gRkTRtUyTjxmpytEz9gLIWkuL2w8CYXfmeiQ4pwakK6iteXSlSKMXz//5vv+bgMs8valadwgrLdm15OyVEJzgys/KR03HA2oZJZ2SOaKXIKXMcjky5SKDHIdA0NbvNirv9kRBHNrst49EDM5Ob8JVhcBO6XrHd1RiVSY0nRGi0QkiJC6Us2shU+tkqzfE4IJQmR4UPM/N8ZLW6YDg6dtuG3cUOQWZ2gYxAC8nd/oAMEbTlOPY4N6GUYNU0NLpimh2zizTrFVP0aGsZfKY/Orp1i/OOfvasWkGaPBerFplgf/sAWSJ0RVNB9BllLPOc0Epxf9gjbYWpNW++uWezXcEc2FzU7IcBpRVXlxf0gyPkCaO/BWd/7LF73hBiZHYRoZqicRG5eLGPPZvVhu3lBZvNjqEfiCmCKt/Fx9PA1eVLRjfz/qvfcH+4J+KJoTAOpZxYMc8zAo3PkcO7bxDSE+NE09akkCAFkJmqqvGT4/3Na4RK3N19A2HkO599B1PVuBhJeSaFSA6att5xHE6M0VEJjREKawzWWmQGlzKfXlxT24bX794W5ZYUKGVLKqDoaZoaxPLZWRsUqiggjMVFj4sTWbRMU6ZqquInCyMqJvzUI6XBJ4f3gTllrrc7Xlxccn974JhPhBTZKYmbJEKqEgQkPEGPTHFJcZUGo2qG3lFphZtnksiINDOH4gHTqcYHRytAJk+aPU0INNKCXRNj5ng4kl1EyKIwkgmyEbRNjc+q0AAhUrUNlUxkIkmXuPpTmBBCokwB59pUVBnSfEKoyHZjOB16cpUZ4syYI5NSVJhSK6ArpiS4eP6Cw/6OGCaOd2+JQJCC1ijqrEmixcdY5rU648JEAiprCcHhD44YM42piNGhpcJWmhQis3OkqkVVknk+FRk7CZ0qdErEOCGSJ7hADIKsApPz1LZBCs04HPHTHhVLfnqSliwUKUzoVYVddYhhxI0jqIqUHdqURc3tuuUUPMM0MCqJFwIXPEknqm4p4hKSYZwJMULWIDQPh3c8HAsYG4YTxmiycb/3+/QPAs5cKGV7iIyQxcfko0DJwiJIeIyOz2dp4sL0VVqUEmdR5IwDglbDWoFWcKHhwWcGBVMsXqQQBbNeSo35nZjqPxgfg7g/yBCF0Uu5pB/GnB67xs6pgjmfuagiiyoT/ZKkGBYZYMq6ACxi8XXlRBalGT0twPbsGUM8yRPzIlUUiPLlKAsrV0imhesRkpyWVEVZZJGCj2WOxXt2BmDAY2l0YcgWyCsKwETm5bXmJcWx3FeK5WTKvASElFJuhEAphTEV3gd8FuRc4vAj5Vz6FKmGzArFxbZlFROnm5nJFUHDSkg+v5Js6iITnGPg9pBYd4q10rx6KVDbmvtfH2jJSJ4hcs+c7ylFCIW9FWJAZMnz9YHPLmbcNGM3ibWU5A6kEfzff5YhLdfxAmDFwgCekyjFwmIWCWRCcCCVfoRyjD7yGpZDnEk5gnBEAcQRL2BwCuSMyAI3l/CAImVdzpnMzFOiUhopMz6N+DAhVSLnG/rp13+oK/nb8Q+MkEAqVbyfOqEkuDnSrkoYxP3JMd+PJUp+3KNqzf5hotKSpjFoLeh0xcY2+JAwZFSriN4Rs0AZyTw5ri6uUSIilMI7ydZEmkrzySe7MmmeE3WjsUKSO8sLa/DOAxprdblelOXltSBsC4udoiP64tEgZFrV4j08W18gQkQ1DfM8k3MplN1ut4zTiWeXF0xTAgI5JYRQBDfjfKZKhbETKePnRFYKqTSQQVnG0wm0JEyBZlXzzdt7Li8a6qYpCZWFB8RNnhATxpQeuUhm1bUYY5gPE6NLrBWsNivIie98viVEgbY1KTimFMlWkJhILtMptfy94eHhHjeNzMPEHA74LDjOM7ba0W09WSkOh8BmU2TS/SS56Brq3Yb/xcUFzg9kD9pk3BRAlf6muZ+Zc0arzLPr50xxQiZB8mXxafAzddUw+RMYjWkMqs68v9tzOM6stg3aNKiqLE6O40AmcvQTvnd885sHfvCdK1SOBJGLX8RW2KohqIA2HcF7Mom660hREFUippG6qUlp4urygpA9x8MJrauSgKYUd8eRdl1D3eLnmcZU7NoGrSTjMJNFoBYaLzx3b98SpWS33WE1XO8qUnS0G8WLqkNLXTpMx56MIedczPlE5lmicsS5Aa1rZuepK0meDuDh+uqCYZxZdaU65uXFallV9VijqNWqmMu/HX/UEaIrTGiWpBmEUKDqUnCvYegdf/Xv/mbp3TwhtSSETBaGkP6Oly+ecdp/YPYjVV3hHSixwjtwzheJnKz5s3/y5wxjz9/+4m8wDSQjmMKMSBmpVSmBJiI0jO6I0RKpIrf7O6bZ8/zZNZ+8uuZ2P5RFoBDZbTZMDz1hkpiuolo11E0NORHcwHrVsq4bTFtT9xYjLtluNozeIXPPOIwIoaiqiuQTyQtsrambmhAiRmtiLFackD3D6NCriuAy0zzQdg2jG/ARiAaZYX9zz/gw4H1AacU8jwSZaOwKUiSHTB96dJUgR7Sq0UoTg0AquYRbNMRUCr2rqimBcCmVsmYjUSLjkyPLCmVbZGWJQ8+mU0xioF2tsabi7jgQksY2GqsVBM+qtSgcPi6hbSmTjKEVuniwcmSQR6p6QsvIs3WLm2aYMnXVgla4OTLFieN8JOoWXQmcn+ldJHy45/rZc75590uyDiQRkdLQ6oZKaAIBoVIJGPIZHQW6qUjCk7IrfW1akjGAIkiPTzOgiLmEstTa4KlAGpx3xJyI01COY5JIaQmqVMtkioqiayrIMxmIQtKPI+3KkCy0qxVXuxesdcvdV28gRw5+pO8dY7jn0801Vhn6dzNijtRViwiKmGZ8diiTSSkilMFFT1KSfjySRKIyTUnqzRGyKq/J/46AjP/I+IOAs/189iKVEVPCRUGrF0SWlniERxSVF7+TQKlF5pcFOSvGLJlmeBDQqUijoRZQqYSTcIoCLyTZCIYzoMj/ITz7mKcrX4f/v9m18yYeWaffgfh+y6OWy2NihJKvLpbEw+I3ylk+HRJxllhGinxzYaHEOZWxSPaWI/PboSZZPMlVF0BV9JI8Moj5DHYXIHyWP+YMSsgFEIuFwTzH14slkehp278tbDwPWeSVGcSSrJk+kkYKyopNYZZEWeE9g0YhSDGj60JBx5QXDLccg0UiuesSLsDtfU+Smk83CpJkiol/8Z2GH36yJeZEygFIaKkJOTDLxCELLrzjs+c1b994fOjJwhNzJGWPUoqc9yT3Hpk+cKVPCDzaCtZGstsWCcbJByoV6XMsaZX57x+Jp5OSH8/zcu5/x/UnFnQmhODcg0defp8BER+loSmV9KT8WFMgzoceL9zC0AmUBpkkmYCS3/YB/bHH/jRyPIy8en6Fbgx+jujWcHc8oXTG1JLVqsTK96Nn3dYc/YCx5UsluojSofgScqA/FSajaxTWqOKDqiqcn5myQMXMN1/e8Oknl7y/uefhZkBXGqkakA4joGorDncjL19eoZXBhURVFynjxbZjHhwZhZQzGYsQmRQUQkv87BBopLS4IRG9w1Ytr16+5Hh8oLEWcqLVmqgyhEw/9DSVpqkMJFXSyZIjjQGhq7LUFCMuR9qmYZompFWk+cR3f/iK29tbhBDM/cB222Kt5RgddWOJMdA2GqENSWqkEng5YusVx9OJ62c7ZuepjMVq8AIejo6X1xsmP+IidPUOET2kiWka6FpDXdeYqy1zjHgSlamRuSzWj3Hg5bOa/sEhm8wwO1Z1RQw9VkhkpcrEIGVsZcBqjIQL06ArS+8mYnJMw1wmgarEca+2DfvTCenA6BZjYLVeEfItr1YrsIJ5PlFVijh71l1NBl6sLhlD4qYZi2xq3RJjYNN2hFBCfyqtkUISYygJblIR0gwUGe26q7Gm4+E4oxe5z+H4gC4acpq6JcTEem1pjWaeR8YgkErRrTMhaqIbqZoKrSu6jWC3WpFTIs4C3VpmH1DCMfanMhnKEBjRKpOCh5zxc2D0mfWmIqeJbrXmcJzoR4dUkk1jSdQgAjEK5mnEaMtpdrSrDfvxRPTjP+I7/j+NcTwGjLFoozie9qWmwbliF5ERZQVWa4Z+RGqomgoTwLmAURDcAEogomEaPZCZ057ZB7q6oxbgpxk/H/jP//w/K16e/gMuZ0QSBYTEwgxP88CqXWGUZOxHXMxABOV5e/Mb7o+vOU0DVJaUJW9Pe6yuWa82XG4uWF2uGfzAu/evqbTF2I52c8mH/S0oTVdZhsOJYTrR1g1GtKQUUMIQtSOKRGRi9oHgILiiNgppLqFuGqb5RMgRoS37wwkpNVY3jEOkMg1WV+W9KYrnU+qMFDXPLq85Ho5MfkZKS1NbpmGApBBalddJWdAux14hlURrwzj21JXG6IZxnrBGI9sW06zIaHrniUZxcIZV+xwlVbGfaIHIE51dMc2JbbvG+sx0OJauy7qCEPnm3Tuuts+IoyBKSe40LrqiwoqROZSkdXSRZyolMGiUsUQJ81hYNx8lN9+8RtoKbTsOY0+ifF4l6Zm5R1tVcgMSxBSwlS0hRNKiZWnjFdqTwkQmMo0jUhmMblhtWtw8M3sPRObJY23FNI1MOaJ1DVliTLXMbSMpRmKC3hefbiU14+GIVBXSO0II1G3D/Tjz8oc/5M3NgYv1llcXO/aHI+N4wsfI6w/37KeZ0zxxffkSUzc0rUU1ivfvv+F4HEC0IEei8KAkp/GImyesbjFGU1lNDAGjf3+o9QcBZxd1EbulJUhidoI5gKiLFbwwKgWanAM3UgaQhCCKyXpBMik8hUhMLOyaEmwryUZlLkRhbj7IxMPDU/jG/5BxBmr/Yxm0vz9dj1mU/VdiCdoo8kLEo6CweLUQnPvPUvpoW6lsTYj0iPYE4tHvBDwyZ09BHwvw+uhVP2Z8ZB7Zu3O0vhQSclqEigWQnV/Ak4ft4x60p+cuACQtyY1PTJA6g7+FzZM5gyySTnmO8F9i72MK3B/6x5wNJRbBX85kJBc16FSi9HedYN1GtMyECP0kOPSO1/cjP/pihRQVIkt+8+7EV68jQWa0FCgT+fJdKDHV4Q4oEeMpZ6TMZLFnmP89kXu2XUZJjSAyR8FP3kb+7r0n+rKoIFOReD5WIjxyn08nXi7eurz8/fy35ajx+MhHwP9Id378iHKMeLzTR+BZPOauZJb6gCjALwEsQiB/V1Tpt+MPOqSA6+eXOB+ZUsDPAWRh1AyCps2QE6apqKykqxT/9EcvAEnygRyh6QxxDoQAUktWXc1wKpMB505ICZWp8WFG5Mirz7bMfqIfPDcPI7td6c2r6oZq0yIRvHx1xeQCYvZIVRe/ktYc3IT3kcZGYszMLuEZ6OyaMHokGRkgxID3E0oZ5n5kngZu7h/YrlZsug4pHG4eSaKi6zqcD1RKEoTk5u6BnVV0K0t/6gkpseo6OmORxmC0ZBgjIsF4GpFY+nEkGcN402NMj/cSraYSa9wo5slRaUAkVs2a0+QRukaiC+OvJEorUvSsupqcMq1tscFhZMSRUEJjF/+Id4lVqwipyM2JmRA9UWvqINEx0bYWY0HpyDSN1G1HpZZOISkZxxNtq8vngS4KAFIinE6sNx3UDVY2uDQjBbjBU5uWqrPkHIgp8PDelaRFbRimCYks1QwStJL4JBidI8yRH35+QY6Odr3l/uYWwsDN3cjoZjarhn4MXD9rOfVDWawREuciAZAhcezviAi+elP68oxtuL5a8+HDHc+uJHVXsT8ElIl875/9C9786pecHm7IImK0RJmaUz/QtpY4w//7J7/kn/34JZuuYpg8x75no1pujw+ErNg2W3IWDOORy90l0xToVobTPGKNZp4dt4cPxStdwfX6Eu0zm04iZSzyb9tRtS3KTcwuUJmarH5/4/y34/cbSXlcivSHQMySccwgHVJnjBK4GNDaYFqFyDUya7RUbDYdzy6uQSd+/e6XDEPxj2kraYzCeIElc9m2nNKRn/3s39MPPd/77FP6n+6RwhCVRMSE0gIhAxlf0g8xhJBRlabrDCH32EogpIJpwgpJHyU5CL549T3qbNECVBY83N/STwecghA9+18+4GIAkel8DTFhSKgUy9o2ijh5lBEoY5imqYQ45ZIyXdtSHO/iVOZAcpm7SIUxNeMwYvSK9WaNTA7yiFSQfEIKXT4PVzv+xb/4Lwku8v/87/8fxDHh5oxUTVER+YnKGmIMeB9RStJt1tzd3xZJaI5En4pEr24YvVtCJ1rcMDBOR5yIiK7Dhch9HBDaMFeCdbNj8JG62ZKExKVEbht8zozOk4i0lyuimWnWGpE80VjGaaKqWpCWrDT9GLCNRORI11ZkL5h9Ys4elzM6G5IC0Ua+unnNdlWXsDbdEIPHp4gXiUZ3zEHQmAbnj7g8EeOIUrak0AJGCU6nBwgKpS55fvkJq/WWGBMPD+8REkKI9H3P6RjIVEvGQgnYSpSqlxAjzoFPiRQCtoHjMBTSIkCay2e5nyesAOV7lE6IxnD56WdUm57h7T39dEKuM2bXwc0bfB4Zjidu7j2mqZjniZgiozsRScRcog8Ikkikdx949uyKECJSCWL6/RUBf5hAkGXFXyyTTS0lpwS+1JaVuHYSIp4bs5Y2rJwZfZGvKSnQskymVQHspGWS6qLgZpTci0yrM2vDo//pH2LCPr79u8iwj3/3eL/fRa39Q68ZEHIBLqkUjhYpnHicdAshHlknkIuX7Pw85ZnT8u/TfoiFPHnyP4FcovkXOHD+O09ev7OMTiwoSokzOCswTWW5gLHEEyQ4I7+no1ZCMM4g8XyvjwDK4095yfgRxQP3mKN/hiYQYyqsqQgIsfi1siy9bguQ++5W8ScvNJ9cWZTSS31A6SSZpsjdPvD66xP/5PMdQiZ+/uWRn/zynhAVl9cr1lLiU2I/zBgfMCniRV6KuPNybnqmMGKl4y9/nditFSkmvryJfDiFwvoKgT4D37wA1o+uh7M0tyjql+Ls5YWG33HZ5I+XAM5yx8fHpMJuwOM1gTiDtkcU+7jRvJxTsVQ1yPM2vx1/1PHscktIkWgNPkXqxtJWFXHWoDUiJ1brhuADUtT42aFmibCZqlKEIIjRE1PGas3oE3e3B9brmkRmvV4TJkck064bRFQoGcHDi+c7Pv/sBdYqYlqkiiQUipjAGM00zkhZpG4heubgSKki+AndbJH1gJ8Sh6lHoKi7hsPdA0ZZxsmhrcfoCjdG6mZFVppjmBFSkx00K8mxH6kqjRCC06Hn+rJmGDxSa5xU6KqlnwYu6wtCCEgkzk9En3nWtVRGstuucDGzP0xA5ubmjvVmzScvL7k9HJiGQGMTPiUElqariWHi/jDgwwhdixAJK2usVswxE/qezcUGkTSn/W2J1nYTtlL48YTUhnEJNpFS4WNaMlIda90hU2Q6efo5oitLGCaclEQRUVJiTY1M8P7uA7v1muF+T31xVeKwh3I+lcj0p4ndxQZySe06TkfqqqGtACGJyeGjY9W23D3ssVWLkIq49McNx4EQMm1nqaxhHvYYkTmNM5+83BJTkQPVVUMksd0tTHya8CGwPx1BBWzdcrjvubruqIzCKsvxNFNVmtubA+FW0HRrVqsVD1/+HafDHmMMVd0hCHzzdmCzbZmnCS0kLz7ZcRgnTqNDK837h8ibu3uunm8YT3eYNBCnQNKKfijMgFKapl7RtQ2zmZDzQE4KpSPBZQY3MAwnlLV0XYcwhv64x8TI2mqSEaTwLTj7Yw8rNON4YJ6Kd1KrBp8cKQb6WaOkQmmBVAEtBCJluqbi+nrHh4c73r79gJuGxQfkSVGi6466aYjTTB9nsBod4ebhLUqnUkviItN4QupMVVUIWTzaOZdExCQT2mRG71BSMY6ByJHKVEw+UqFIOaFVAKEgax72Dzjn2W2e0dUrpnmgHx4IMSxrxDMSSaMlImRiEiXgKTqMtSitCVEQM2SZyMykpEhBI+SKECLKgEgTCYdSUDeWnCeEiGQ8MRWLRttumE+ONAvatuWv/81fgi6LcFYrpK3oh5Gu2UCCMHkaa5j6uxKbX9VEn3HB0doKgmBV1QzjiDaW2Xlu4k1RZEhL8BNN8lS1oJaaT66vMMYw+cg8Z5K0+GHG46HS+GSIGqSccMNDAU/ZYE3LOAWyqHjoJ1LsyUmRSYxzojKW5ASNWRNd6Xhz04CsNXP0mK7BWoEPE9pqjE6g5RJGp0nCEuVMlJ5ILFMb4XE+UOeMUQo5ehopsBtLZbeEMPNXf/2vaZqKtrNst1s6W+PziewTfd+XOXDSxfsXMnVdk1VkjD0xaoy2JCdp6po5jJxcj5OOtq7JOTOFgZu3X2H8hLv5wF43YAz1rmY69kxu4GG8Z2Zm8GOZnymJ8+Gxe1IQIAuykKiYiw+w7zFZkqdErWrGodQR/L7jDwrOiiUblD73aIFUhWE6d0ecKRglCqukVAFvSgikKKmBZEF4ZI8KU0YuJkMfBQeXmabio0rxdzNn/0OZsd+HQTvP1R8lkwsTJgQkkRZwJpcwiY9BTZGqpXyWdy7x+cSnfchPe6OkeAR5JSBkyebm/PsyqRcfB3aI4v0q0fyFMRNLiMd5f6UoQKDUIxcBZOHUCiOT0pPH7Xyezq9AnAE4CzA5x/Av/WiPAE+IUoqdl3sLEOiysrHsx0or/tkLw//yBzW7tiKweLbk+QqypBxp6siqG9ltJSc30xi4309IkfnuK4HZaHRq+PLtgZet5dBIwofAHEtjPSKX45IdLgkUkZ+888i3sTCEjyCZx4LrR4asUFSPZ/vxGJ6vhfxYLkARNj3V7mWKZFUswDfmhMiSJ5ekgBxLD9JjWXgJEMnLOXs6Bee/F2BdrhXxO6/5b8cfdhxnSQwOqySrVYuQ4OaRSiukNZAzp5PDyIwwxbcoBESXSCKjbI2UkqYVQMSmiMprshAYqUhEdF0vZz6CkmQUVSshZ8IUqK0lqWK0LwE55XMh5oQ2loygtplxHBFao4zDTRn0xHh8ANsQhhkR1dIvtmb/0IOAfvDk6Fh3G9ZdhW22vHn9lrvxyBef7Li7OZGU4nq1436a+PrmxJ92Fzy72DDOjme7FSgLqaXvR5SUuOjRRiGUZ4ozITiELt2F+z7QKUc2MI0D725u6LY7TGXpJ0+3XvOLX33JdjRUVhC1ZtVV2Lrm9sHx9u3XvHi1QUuFFor9YWDqHSEF6uzIQjGPDll1fHUzlK7EItHAGkldWYSy7EfF5BwXq5qWitn7IoHUCq0TylgOp5ntumK1u0QIQbutMAp6Z6lqw91+4MWLjrZrOJ1G6pVh6E/U2w3SeZq2xc8TwUncPGFUghS5Pzyg5Yph6EkhcZpmLncVJA9B4D34LNlt1jwcR7zPrFaJ/ey439/TVhWV3lKpTBKa1tZIUXOYB1bdDud6LrYXuHHm0y+eMR72ZDzDMOPmCZkFr98cmYbIED3bZy8Q4UTTWtrG0FhVoqWDwmhBNprT4cCLzzv8DEoonl1ecThM1O0KqytWXcfpYeLDfKTRDfsPR5TO6CRwKZLGwKG/wVaSICNqTHy4e2C71ugU0KpCCF2k79/Ktf/o4/bmjtWqQlnNzMiUStWCUhKrip8RL5BoTK1xwXO7v+fudGIcHEIkGitBKoTRJFHmFimU73GXPVkKsjFEqXl384DWNTELqqbGxxGfHJUypajdlO+3FCd0sui6YvITm2bNpmroxyMHN9CnhDCSbw7vWVcrYogcjweyiASnedW+YL2uySLjXWaeHClm5jAQY2S1UoQUmHwiUdQMJmliAh8zqrL42ZeqIqNRKJAwh4mQIkprjLVYIzieelLyIDLKarKU7KcTMQVyzvz6/u9QUuN9wqWIrTTaZ4wWrJuKV89e0t8dEEmwEobJO0CR6jVz8CAzkJBK4WeH1Usar1LYxiCkp+4EPo00usOohpgVMipCKB1mUkKUgpAyUkUwGecGqkpBNAwu4bKmExYrFSHOVEaTVSAlCCGU1MqmRkTJeJj4wfd+wPOXV9wd7vnZL3/NbDRZJYyR1NksVSOZMDtyTCgrQAb8PHF4f0+tLNlFDJK6qhApL2m7lsauMMYUWWE+gJxJGUSUzMOJeVJMQ89qtSZ4T0BgrSHmiDGWEANSSxAKLSQWic6Cdd2RQ2CaNZt6zWcvXuAOJ07HgV+/eYefHHPvePvNB5RSxBp0a+jdyCn0yEqjosTNDiENKVIsDsowzYEQA23dkV1it9pytXmGBi7WHeuu4TdfHtDW/N7v0z8IOJOieInOKYUZgVKC0UNLKu3nqsj/zoxDmeR+zNgIYl4m+eeEPgQipyVwokxt0xJvHkV+TPn6eKb60bz28bb4e7fhqf/s498tAX3/ICvx939dcHPRURf1YAYi53yMM2BZmjqWOPyPt1aerOCIZQIuWMDdExw4byWdX9UyoRfi3GT/NH3PQjw+4xO0kgt+Ssv2zsD36WjFJWDxLFlkYY/Eue9MnhMjH+Hasg9P3W0FrMZHACkA5FKxkDNaSP7F5y3/6s8v2K4rhjkyu4BInuTDor1e0iqzpLIRKTSXOnH3EHh5ZXn5vOLFVtGtMn/1TeBZ7WGIvDvNjDFhlVhQ0lL8LRKIAhbJsQDHMyg7k1aySDPVE0rmMQRlkXk+Hs1HlrLcb0m/fXy9ZdOlnMBoSWXhYZC4KGl1kVf4JAor/MicpuU4yaKhOF/Xy/mUmUfQ/THH+u344w5rNUJbkgsl9UhHaiVhUQQgIeaANRoyTKPjOA1sNl3xXcYJgyQmRRKJcRjZdB1Cq5KEKsrC1rjvycA0lcTDYYyEnNitO4Y5EESm1jVT9MicqG1DVhqpMso0ZOFQscTk/+Q3v2FrO7a2pn+YWDeWbdNQ25pmZXh4mAhJ0ugKY3NJUzseCacTX739Jfu7kazLws+Ly5oOSVU1DKcD3/9uKaLOBHIOkEAJT0ATsyeEhPMJqaDZtLjo+HB4IE8zlVK8e/NAqwVznBiOkc8/i9x8uOewP7K72OKqe541iupig/cBLQMSxU1/RGjNZ59dFR8YgkoJZpdoO4utKvpxLqvQ00SOme1uzeE4EqMmxSMxd5i2ZTyd8NNEdiOv95G2MWzWHVVVM6UZqSy3+76Ej4hEXbfE2VFrBUax3W2Zjw9st5p5PNGfhtINVxluH46skqMxhtuv3rLZvUAC11dbhBJ09Zr7w4Fxmnn2/AJbaUSaqU3FaZwRKqN6T2Mq5mkik0nCcJg8fo6s1xe4ocfpe05TRNUWa2tyOKGVKRJ6bQmx9AD1DycygXGIjP1E3WrW7Yr93YlmLXh4c+L23Qc+efWMq6sdpMzpeGQeHM4HjMhMRMZ55G440NoWTULphqvVlugj/XEgoFDBU5mKi2fPkPcP9Pt+STJONKuGqrHgAakwuuZinensCp8cyihIinEccOHbQJA/9iiBbZFxSuiqJcRirQhhLsqM5LFtjZHg5xNTmEFbMo7NpsbP5bs1Bo+WBZyRMi92n3K52kLO7E89p+AZJ4+LM/00ULclQEYohRCC4CPW1gRXzrkREhsCwgnWUnOhDJ91ax4QpJD5MJ8QUnLqj7jjEZUUQmeyCASO/N3NofiNsmS9eo5UkpRmtrs1bh7pZ08OGaElGY2KAtKSvusjGYlzmmZd4bxDa1UKhAePyBUCgRKGrARVVdM2HTGUUCUXHJuqZgw9jcpoLZh9wNqK1rYM84nkilLh5sN7Ol2hY0a4xCfrSzyZqASzTIjKMOF48+Et46mnbmrqqiKHwgZ2VUm+1aotstRZ4ozFD5HaJpyfGcYRIxVG1ghlOY0D0mSaxmJlTZUDpmpIBNy4Z9W+IriANgJtNN658pnoFFZVgEBWkg/v3nPz4TV1Y1lZDS4SpGB0I8LWaCVxcWIOc1lmzwIRErWpISpEgiQjtTG0rcbPYwlUU6WrbZhPVI0i+1wYxqwQqSIMYBvLqn7GerXjs09+hFWad+/f8rZ/i0kG2zTcDreknFg3LUZoGmtQQXC9umKlVugMX2xeMcQ7HlTH17cfGDSMDXjZFy9/rvD3PS5OGFOTYkI2GoEmhkQMCak1GYUQHTJ7ksuoFAjTgeeffYrShkpa3r2/I6aKT1/9+Pd+n/5BwFmMkNMSfS6LPKxWCR8ltin3EeJM4ZTJZ3qc0vPI7jxK93KBLGVCfb5fWia0EudhjqlQFhkI+RGMfQw5Ph7/MabhzJh8NC9+fNzfnwo/cUgU5oz46B8rrKB49Gude8bOe/a0veX/5/uKwt4Uf9oTGDj/nDmHfSzbkgt4FZKYBHFh5KBMHLWkSAgp+1EYGrXs1zLNfzy257rpp8n/E1YsvJoQJYExn5myxyNw3tbTERPn9m1RwJFA8P2Liv/mL6754pMVPimcj/gYEBIUmiiXDjYZKa+mPJcwGhUCx3HP3a8qPn1usEYQJWgc7wZAwctLzcFF7u4iIcLHyS5nRjCl/NgFd06uzAAxlzaADGfLwxP7KTh3GCxE2MJhPZGF8eNLOcNiFsP7jETy+VZwP8JpEnSmpJGy+NZCKp15KWdCLlxqWp7okbMT5/RPKOD6W97s/x9j3t8RsiP4jPMVVmesNqjakkOZ7CpV07SGDx/ukaIU9Q79SF1bukU+oYxBIrm6vCjcqFSEacanSJaCKARKGVabBqE0xgWUDETnUdKSYiDHiDGK4DMP/cA4B1SObLaeEB2zTwz9xPX6mlpr0mGmWV3RnybmkNnUipv9idElaqMxTUVXGzCKvI0kpfjOdz/jcNzTtjtOx57TYSboxPuff0mrMqPTdLUkz4HhNHFUkrbWaNvQtA1HNxOTp9qseJgO3PdTkX74Axt7wXe/s+P+7kR0NfVqZCbSbHbopqbSAm0AoTm8v0FpTXdVMwtJbRviPCGyJruMqRSnw0TIiXke8TliRUVXC1AageX+YUYg6NYakXbsLq45HI9gLJ1RuFGS0glrLDklpjSitSGPPa+udyRpGYZ7pulIv3dUVmGX3rYS9W8hC5rNivt39zRBs7l4Rg6RkC0uwmHvWG+2HGLNh7d3dJWguXhOXfdsdzvm00xOpSctpgKIJxfJ08D9YWa9XbHbatQS/DG7hOxWxJxodSRkXxInvQdhWTUCHLgY8XGmqiQiV9i1ZXu1QRmF85nt9RVTf+Tzz14wTI7VRvPu6y+ZomCzWmPrln66xdYVJkHTXZBTZr3WCBQpSfw4MrjIZrth6kcOh56qsRzzDcFl5r7nfpz58x9/B6k185SJYqSuV7gQaG3LNE0ILcF7dG1RuiX2v3/k9Lfj9xtJKUISaFljRVU81n6iNZrWVGyaNZ9dv8Q7z50beLh9i1KG3E9MeiYh0VESnaKxaz57+SmXFzsUNZJI19X8yfdb7k4n3tze8PrDa/zxyOgOKCVRyqBVS465gAwpqW2Fajtqa3m4P1BlhXGZMIx0wEYKTkJxmh22qnBuRglNW7ekFEFqvMwYJZEp49wNdd0yjoEwaWTQGCXx2aPRaKsJPjKFhFCKrDInN5CVYAhFqhbcjJgcWigkRdptpGb2M5UEKQN+masQICVPqzUiBmIWyOW+QmcinhwTSRpmmfny/gMXVcta1QQySEXbNlQSRu+4efeeYTwhKYDK+56mM0zjTIoB72ZMXWGVIjhfjNBzzXb9DF0L7twH7vo9ojJIIZFK4+cSjvH+9o5u25ZY+1hSKX0YkDoQo0cbg5SJ7XrLODlcjGilETIRw0TOCUWFrDQiTuQYUVnhvcR7hwsOpMBWTQlKcYGqakApXJqwVmBbhapswQwpYusC0oM3qKyRytKohHcTQjjWqzXOBa43FzTVhuPNkdswcL+/wfuBqt6htSUnw3bVIrPH6qLEEkrTdC3XLz/lzVdf8827D7y46Kh1pJkrxpxo65aurYnBM04D49CjpETqhNaCNCVk1pACVxeXSC057A/gBavNioeHe2IGKWsmr4j9TMoDWUSSjvzl3/yb3/t9+gcBZ1o9SQulKBNdIyWDowSDLCv/Eol6musWOvw8SX4Eb4vXbKEpzoxaShkXMyEVduUp8KJIJ3P8DwHYozrt7/3+Y8D1W6Kxj5izj2xYTw9aHpAeAVypABALuirt8RDPDJl4elh6olyKdDAXz9YZLD29/CJ4LKxhKeETi29MCrWUfRffmBQs/6blMfA4ec+FKStsjFikpzyhT/E0zU8L3Hh0pS3g4BGsLf62EljxBMxyFoSccWFhgETZhlWyMAcCrJD8qz/d8C9/vEJrzWl2JakrBGIIeO+XkBSxyDefpH3nqm6wXK0N/5+f7vnVN3C5qvje5w2fXiX+Xz8febXVDLNmGmB0hXVYoCuSQuurZb8f/ebL4VAUMK2XfU45LeD4zGp+3Er3JGU8k2/5o38/BvjlAYnRCe6SYtsmVpVgckAsXkQpoJJQL89VevHKIoTPmXmR956ZuZBLuMs56v/b8ccdu12N1B0hZJyb2W43WKuJPhG9R0qLleUaenG1LfUQPhJDid0PbkIJg5QRrSVSCYxWzFMiJInSshQp1x1JCtw4URuJkZkYJVlVnIa5sGvJEceywm3rhta2tK3GzY5hSAX4X1xxPE7cTxNtW9Hf9agmo2LmeH/k6vkl1h3Zj44UEofKI2TNythlQi/pjwe+/OpEUyk265a6FqjFBzQNnuQGVuuKtmvxQRRvR8pMg2R/6tGm4sPNAS0VbdKcXMaolhGNtStsI3j2acU0OMYxMYdI1VhSzmitiablz/7JD3j9zTel0yZ6OM5YoQgxlvfnwaOMIgnB3W1fip0bj+w2vLs5lOObFS+urzk+nPAuErPl17/4BS9eXTEeBj4cT6xXEt0akk8ooTj0PY3RDLcHcpzBCEiC9WYFYaZua1LvS6R1zgz9zGZb8+L6JZW1PNyPDP2JT15cU11uGfuJ25sD2+7I9aYipcQ0jPiYmb5+hyxadEIuJblhmtC6Apm4ujJUzZoQPIeHHmkVh/sjWTdUNvFs16J1Q3+aaS4v2R89fkq0VYUQnmmeyaplPPVklziGkXXToYRkSoLD8UjdaGIM/O2/e8/VZUtrO6ZhT9NccrHeojV451AoBtdzdzsVxjYlrLWQI7c3dwgSq7VhioFxmEjZcXm9w/aOYRwgeYRu+dD3tCGQkiUej9Q6sFIVU0jEESY3g6j+Ud/z/ykM01mC8xitEDmgUymJF97RREE3Z8a3t5iqpjYg5hGhi5LAJUdSlslHRNZc7a7YdRv62wdu794hVODy4mKpvBnYzyNTdpiqLGwZrUipfNenSPF3WkMIgX52HFMmRvApsLY1PiRcGNFa0lUGPwSSn3FhwLaWPiY0GrLCost8SGZC8IR4LOyZCEhT40JAG1U6Q91MEhAsaDKtkLTZsGobpBGcpoEsJNPsCNlhVE0IguzLd3QmM/YDQmuiy4isGIaZHCeqWjPFEW1qpFD0+5HLqx137oEpu2LhcTPHYWbKinRxTdU03D+cuO+PzMHjwkStSxiHokgURQpc1i1YxVEVps1PHoaZHCLeeuz2msuLK3QwDHPm2bNXHB5OtDvF3f17Dsd7MpkQC2uZU6TrLsA7jMnMs0NIizSWtze31EYXFkqWOaBqLCFmZAbvPK2y1DJjjKGrG46nB04xMPmAqSxZSaYwIiTYWhJTCUPpE+SoGMaJVb0mR8uqWlOZzNAfsLWhaQxHMtM4sVEtdZvpxxMxBsZ54q6/K6ypcAzhiBs9lc5l4bSpaXRDcpI4ZQ5+z+2HNxgFp+PA1r5gdo7sBZ1Z4T1cyB3f/6df8PNf/w3fuEDIJRcjZ4u1GpUF0VMWk6JiJTWmScyu5/JqzeQLUL8/3ZH8BEJQVYYpDsjq95+w/YFkjU+3z6EYWhXmKySBFufQinPy3wIksiy+gIXFEUswQ4LCBkUIKRHTk6/tzKg9gZ4Sx69EkamlVCSTJaT0o/36HbefJt3nqTyPrN1Z0gaFTdESapmRSjwWv8acPsrMO5djL9vKhdZL570U580tjFUWBQQtz5kQpVdJFLni8l5YQNvHYC8jFunbYwiHFEUOdwaKlHC/s3zxMaI9nysMSsx/ifJXZPwjcEwyF0gjzqBkAYhZltzGLJ7A8wJmKx2WGoFc0iEpgLJVmv/2L9Z895OOOXqmkAk+L+EGsUTqpsI8pRBARKQ8s1uqXCfLvmsF3/vM8te/cPz67cjXNxOfXtf8V/9shwuRb3564JtTZIyh7G8SICVSCFyGWiQU8YkZ+61rYpEWLrGXZ1nmI4P40fkVCzj/+II6n6PH6yY/vRcEiSlk3CFhtaZrNLZOxACzL/68x864vFQ+5OV5lm1YW2SnpyERRUbm/FvX87fjjzOEFFirsUax3XSPKz0xJWLKDP2ANZZxOIEwhAVM1LbCxYiQmdN4QkhBTom2XdF2FSnD/jBjbPE6CAXGiOIvi4lpdozjxNfvel4823H5fMf+/mFhzyrevT9wdbnitB/Y7yNJRaracjh+wzQHrj/5HnfDB24PD6xjXRYgTM3x7ogUmRfbBprM/n7EyMhhOmCMIiZFRGJsoJIZlQPBZ2qtqKzmxcUG5weEsAiZEXNgcgojMrbOVFFzfN/z4tVzpNGM/UjQE+vugu22ZjoeuUuZ929uqJsdWUuuNhXz6BHZM+OY3D2v34y8efuBPp+obcWLi2d8eL1HK8E4ZX7w2Qv2fY80FZ9+5wVZZvKcGFKFaRWyjqjKMjjHhw9HHu5v+fNa8+qzT/jpr17zve+84KprUTkwZcV8uGfbruknT0wKpRLT1BOD4PJyx93bO6pa8tB7jseRdW14vn0GUXDcT/z661/zbNdSNzXtRcsxeNz9xKqxKF0WVT7cD1x8/hnx/j3TYSJlSe8866am6Vr60fFwN7HazKVLzPfo3iFVomlr/DxRd3VhTOuKm9OBT6+v+HC4pfUzVmv6Y0+cDX4MmEbALGitpeoMMdbkkDFa0xqNbRXzaSSlyLOLLdNiYlfaMvW3NF0H2jD3EyTH6mrF0GdS8mQHx2OPaRumFAjzTO8cZEVtC/Nl1Il1XaEQhJgZpj2rqkagMRZOc+AQjkwPnqprwUcM4P3wj/mW/09ixDQRU0CbGoEiisisMj56RDa01lLXLUnBOE/suhVeL5kASZAiZJkITHzo3/P2/hvmeSIFj5HwZn9TvGU5EqOmUgbiiLGaeU6klMhSYKQhp4CbY+m5zZ45l6CczliG7JkGh7KRPkwM80Qi4UOiWbeli8wltDYQMz750rOYPG1T0/dHqkqSpaJnZvQzF9WWlGGaR6zVaCXJ80CrDa8uL9jYFu8DU6t5cDP3MtDnxMmPKNXgRebYj2hriDFhiGTnKVXWufh+laYzHcFnmqrGGk0jDDQt8+ywlATK/uHInAUpzMwiEa1kSm7pBhakMVHXFdPk2LQdl+sdL3fX3B4fGO9mZudwPlFZjZ8D87Hn7v6ItkWdNE+CsZ+RMtMYzYvdBX1/RJvMnOAw7HHe0YmGXbvis88+5d/95G847CNCVZzGgFDQ5ICRiqEfkE5hdMU49kgpWa/WkDNaafBFXl9LSbVeYeuWmAJdZZc5fHk9Ugu0kDw8HPjk5Rd8+vxTtlVd5vUyMxz3HB72jMPMDz75E4ZxxsXI7tmatzdv+MX7b2jqBhcS201HIIBaOvSyQMZENokpTNS29EOmnDB1Q/KOhOFwirhoWTfPMdbycLjl9uEr/E/e03QNV12LS4lximxWz/EpFG9z3aCAYSgJs0JFhIw451DagrD4EIjeE/JM0hVeBP7HzNj+IODs4/EYHw4LE7EQL8vkNZ31cgAiLROX8jh/BmRx4YYWEJcXULLgi8eJMLB4dhYpny6gIS7o7Skp8fz8Z9LoiekTsoR0SFEAnpKFDdMSjMqsKoUWAhfLc2QBPipSjiW4I+bCPImPZItigWW5gJRyYFjYrLM87mOJY2EcrXqSGRaKTf29tMcSBMACAkqIhSDHp8COx+h1xBJC+ETrlHtIyAXhuwiVjtQGUIneC4g89pSV6P0IWS4s3Tnv8ezYWwBJUqW0WuQi0aKU9/63f3HBd14oZj+TgiDnYvCMSTCHuTAMYlFApgU4CllMpaLIGxFyMRzDi0vF9i8afvpV4DdvAr98M/H69h1/9oML/rf/8pofvx/4668G/vbtyF2fl/Mq8DGDTsW7xRk0LafsTCguV0Q5Xsv5XDDtE1P6dD39lmVveVxezpUUTwTluSIhZxhTZDwJjBS0VmOrVJKh4nJOU5FeZgSl0a0EwIhcwPoj44x4siR+O/5oI6dMDhGpSrS6lhrvInMMhJBo65pxHpmdRyRYb0oX1tyPCCnJMROFZBwFbo6c+lvWbkeIJe1JO01KgdVqzddfv+dqs0PYAtiVhB98/yXH48ybb25QsrA7w12P0XB3mNnuOrpLwzg/kGaPn1rIgYdv3rBat+hnG6SSVLaGnKkoaWXBO2SUXNbbIttMmtnBX//N11ztNnzySctpGPCTZNc2eJc47o9cP8ulm6ap8ONASpEQE3NS3Hx4Ry06rl49R2jN/f2Bura8+OQFlVLMvaNuLd9bPYepIckSOZ+ypeoU2bYIHBe+Q2bFdz77hKM7YKuOPI48f/WcOAz88PvXvPnmHUJp3HTC5xp3mtEGUowMQ7nvYX9ivbWMK831ix8we0ecZrr1it22xc2SGCfCHGm3F6wvNuT9jBaZfnBcXL/i4e7A6GaiMUyi4uHhPfMkuN1PvL0vPq+LC8unXzwvMs/5SOUd4+hoNivujhNdpTDKMpFps6V3gtFHYvAMIdBW8O71PS4m2lVHCpFj8uQpcfEM+uNMLSVt2+HuH6gFTKcTq/UFX76+4TgGQoKmKZ8PUkRUp5nmwOn0wPMXay4+/Q6nN2+Y4xGjJC+/8yl/+dfv6fsHOqtRGZJpUG1NmhNJZvwU+PDhlrqpmb1HDJH7/UTTNNimI4kerOFCWkajcS6iFVS6iO+ruiGKiv2xp+tWiDwSg0ObjJCaq80OF1uG40xyDqRi9udQqG/HH3WECi0N3arFuRGSY44RXRnmmHnwM0JY1nXHzIb19gpy4nQcaCpDt6u5O9xwyCdcGBFKkLVAyookBD7OCKBbt8yTJ+ZAlgEfJEpWWBuwKmFFoK5a3BQhCZSWpDigYmbbGnIcOfkZN+ayKFkJqgiuH8lOYExLZTRaGap1w/3dA1kEso3MMtJeXhBmz+QySUJnOoQXWGNZbda42dHZmq65JPdH0pgYphlrSjiNEZpK1YzThA6QvCMLiQwZcgk4m33ASg05Y6uK4AMZS0hlrpWypGo6Xn1yzS9+8zMGN5FNRcSjNg3W1MxKgTJ4PxVPvJsRtiYow4QmIrDtNdcvvqBCcyVqXIBfvXsLuqEPidlKmqbm/XBiuHnHMM+8PXzAbiSfXW3plMBWHXK34ZQcP3/9BmMrPn35Ca+2F1ijyEIhUknMHkJgRmKQnCKc/IRRpoQxac2QTqyajikFUoy4/sTpdERVRUoiQyaNZcLSdhUyRObZU0lJWzdEEYhekETgJ7/6CSJFHo5HbF2zsYbpcGAcHd/cv8dLQT/0dK9bcoooBNoYhOqoqLiqFGOMOBUJ3qOVgSwxlSUKT5KBmBIpKubJo5ThfnrguD/Stmsur675dPeMd9EzjxN9mksNVJ4xtSHnkRBGonNkZZkjpQIglOLyza4hZk8/9oQ4kYQgGkhR46Jl9oVt/H3HHyit8cnik3lKFKz0Wf6VF1ZHPLI/IElJESKEyBL08QROPgZ5Z3zxxFg8UWfqLPmCsnKRwciiSEEUyRGcZYVLmqSAc6+UFKXbQ4rCiMVUZHBFPCjZT2ca+6OnFk8hJ1kt8/iPmLYnFnCR5T0igo99XeejJRf/2CM/RmmxykXClsUiCy3iQ3X2muWFGYNyH7kwP+dtZEGST+jj3H/2BEJAx4xRGYlefAzFL5YpBclSFmCWUlrO6znGPz+GZJxJu0c5X4aA5F98WvPJtWLymeAlPgV8ZOnvio97knIBe1JkhFBIWaL3S1hGKfNOS/FyKe8W/PgT+OJa8NWHyJdvE3/501t+9vWJy87yo8uKqwr+bz+bSkBLyqiyLMC5iJuF4WQB2/Lx9JxFm8u9FwR0tjby0TW55CYuv8qPm/wY+p/B2iO0W5C2ywI/JvIIUgqslhgFVQVGlpVJ6TMhFD9aRC4ALSHi+Xr+dvyxxzRMCCp0pTC2LgzPIlWIaeR4HEppMLA/Hnn95j27Z8/4cPPAbmuRUlBVLaZORVKja3yIDHMx3rspY+uG28MJ3axxsiGnyDDNxEGyEXD1fEc/z/R3B7pVzWbdkrVif3/CTYGYHeuqxYuJrqrJBmpbczieQLaonPA+YYRB15qm0mhRZENKW4JTzPPI7CN/9mffIRNRtaI2Dav1JafDB9xEqQk4errNCqk7+rFHWUUII7cfBjIV7XbFMExo0+Gz5XR7Qjz0XK62DH6kqy2/+fWXTEHxz/+LH7Efp7L6PQd29Y5hihyPA9PpnvV6ixKaRlacZkHWitEFDndHqqajNpIsLJiaB1neV0Y2OK34zfsDP/7+K/Z3B14+u0AZgciafe94VQUOh7fk1PH8xTNCKOLpafKonMqiWky8/vVbVp0hKs39MNGpgRcvXtF2hloJUJbJRSRwHE7sthUP+5Lk5pEcTpmrqw1ealzqSTnw9duvWXUaf4CH+3uqtiLSIaWj0RUPd/dsVyvmccBWmiQUWbXcHUaG1/fU2zX7/YTI8NWXv+Lzl1d02aAzSJeo6zU5jVipqKxg7wOH+4l5+AW3H/ZsLlfcf3PPX/3yls5KfvDdF7x7+67IbZNGuEwi4lzk6CZCgOl+xNS6GPhtxKjEat3x+Xde0Z8c719/RV1pmsbgkuF0HGi7mn6G2U+8/uoDP/ixpalWmFZyc79n+2xD6HtO+xOmUbhgOR0P1K1Ca/uP/K7/T2EEYorsD3t8cBgt0aImO0lIjpETJglE0nz2/BN++P0fgVHc3t6yPx6IYWY8HnBSkVWZm3g10dQN0TnWTU3dtBhZZJA+lhJlFRtqs+ZiVzGM99RNx2F/KP2REXyICFOTo+c4zsxuxOEJsUahWbeZ6+2arbAQNcpWRDGCnuldjzQd/RzY7Drc7FEplQCPnKmQbNotq82aw/6ENhU+C3xKaGvJyrB3M3UtISbmGDlOM1MqdoPZO0glxdHITIgztqqIIdII0BlqBd1mx2EYGIIo13JMnO73xKsdP/rBn/Bv//bf413AI4rHVSmCkGihqasOMQ2k2oAq7NI0ObarK77/+Q9oZcPh/pa7wy2irri6fs7d4YTHo9flNY/DkZGMcx7vJjohWGeJcpGYSzQ+KC7aLeuLS9qqwUgIOTIFT9M1iADSBYgekTQpKmpToYTk05cvqRrN4Ca69YaL3Y7D/sD4/gNRGcYcCWFGTIJOQNc1eJ8Y+xOXmw6rJdM0kpJgwvD+3QdSFkiRGPzIEGb6bJAxUzc1Tnj2wSFMxqsJoSLBz4TxRFV1nGZFJRrwjkpnpBGLJ8+XS11ASoLTOKJUUcFMaSBOE8P0wDjds9+/Z7feMo09ELm83LK9esZ+PHJ/mqhkjawMooHD6YFEpDKSnD1StsQsGAaHVECeEDLSth2EiugEVoOPv7+X9g8Czs5sVsos/qECxmpTVvwzheVJQE4ClwQ+CXKKj0Djd003z2nyLJs8sz+Pa2sfAbOYICwTbUnxsikhiI+R5mV7aZGLZTIyFd+VKxgEkSHkx0zEBYyVqXop/l2ASRS4KLjoMuYjQJxzSU98evDCnvGUqMgCDAHkOc1RPLEiBcAW9ukjNeKjr4nleJXbZbtSnuV/H7GTWS6guTBGSZzbzZay4ySYvcLnjJRlD81y/NICKGLUT8+bF9YNSpriAqBTlksf3eLFkoKVhn/5J2smlwihHM+YIiEKyL5I9iJIXcCTXNhKoSDFREznhMoIYoZsUEiSECQFWUk6JfnRZ5ZPn8385hv49QfP+4eZKWbGkDFCkFUB65UAlZZz/NG1I55uos6SRs6R+vnxb+cL6HyOchbFDScKSEtlxeGJGT2DuMfoz4/qHs71B8vJTTEzxHLO5CAwakl5NJJtWzxGPiVGn1FSlrCTDIhv4dkfe9imIqTMaT8jZWIeHbXV6MZA1tjG4ENCaku92uBUzWme2L64oOlqhv3A5tkVp+M9AoNLAqkM9drQ9xNCSR5OviwauIm7uefZ9QV1oxi9ZAiO/pseYxRC1+yHQGUl86knLtLkVy9esukUf/flB7IImOhAtvSnHq0U3WpFZyRN1TJMPUpkTvOEEhJFRCi4urog58Q4eWIGIYvPYejfozJ06wqz0qBrToc7Hu7eM/QTm03HpqtItSILTVUJhjkWE3QY2V5dcjj1BOGxrWUcZ64//wJtNDe3N1y9eEm/f2AcJnA30CmaVc3DPpPnE5um4f3NLT7C9cWO5vkLsvPk4PA5o0RDCtDWG3KOjNPAfDjxo++9Yj7e0DQ15ICbHUkrDseRl9dbrFlj6g6RMm+/+pr1ZlPWi4REac16XdGtDJvuGb/86tdc7yytrYqkPVVM84isI9OYOB3u6efEttNIo+hdwuqWegc69ry/7YnB8+Pvf840g/OOy+cVdbvDZk0/9kzJ413m4uoCmRONXPH2tC9JZyIyOI/oWpSRXG4N9w8PPP/0Ep8yZlMz7PfcD4H98I7tqqJtK2TKKFMzjp7ZO5St6U8Ol2ZSygxT4FdfwtQP2Fqg6zVzijT2Cunes9rW3NztGccA0RB+M3M4TficWTW3/Mn3v0BXLarZME937IcRKztGH6mSZH9/pNpq/vn/+i/46V//HKsm6nrHPM9MbsAdHad54JOXGxpb8WHMuDRj5LdpjX/s0VgQVEyTR8iKFFyJIEdSV4YYPadxz2rd8u7dz6j0zD/7s/+c9tMt8v3AX//N3zKOD2w3HVOYSxiZMOgskEaDFsxuZphnrG549vwZr16+5Gr3DD9FrDKcpgEpNff6gaEfqbShaVYkYzAqM7sTv/nyVyg/E0TGz32JmTQZ7TVKVOyPJ3Sb8T4Qs6EfR7S1EDMGRZ4cqmpwOTLFwHDzlovZQdZ45zlNIzATKkVFZJwdhIixlqpp6YeJQ39ifXFJJcp7F6WQwiBCYvIJTYQ4I+ZA7AUiwEYaWiUIEoKS+JS5P56ofcWf/8lf8NOf/BRtAklIUorE1FPJBpE0Wtc4mdi2DXlwrNuK733xfXarmnHYcze+xcUR4+HT3QVVlnzz5qb4AWVksgIvIj5F0Jb39ycumzUbaxmnAa2K/L7VG2qxZjwMRBFYXa1olOKf/umPeP3mPbZecXNzy/54j4yZFDwXF5es6xVjv+e71y+42K04Hg5UMpYJt5aEFEnSIGRmCoHsJsI4sm1qtAJDomsrIprj6Y5G1WAq+rFHaEUgEH2krRpG71FKwDSTAb9M2qpqiw+R7CWOASOnRVkicGkgpoS2DZMbEUKVrmQSKgVyFEy+9IbmuimS06oGVVRcu/Wa64sNOQhWseXtmw+snld8/t3PaXeX3B+O3O/fMfTvMLrH1ppPPvkTbu8GTsMd/ejpJ4eOBfNoKbi4vMSqf6SeM7f4vIQsE+0y6U1nC0/xj2WBT5mUJClnsogLECiSwo9lWuf0wr+nHINcmCNFkUrGDD4Xf1n8iLmBBaAtPVfnbSLOcGaRAz4iv0XyKErgyEecVNmWACUXaKMKwMsIIhG9eL1YHrXg0kevkvz4h0ep2wIC+IiNy/K3Xm1eet4KcBNPwGC5T3zcwyWlcUFQYgnykAsTJBeJXvGELcBRLiyR9EVGGsBqSVZikfBJhCwHNi5Jj3FhRB9ldeeDembRltethODTXYUgM/nlbyIvRbrl+kCUEma1RMgjVDnioYB5JRdQK0EqQ2FZBTkaZEqk7MlKoXJm01b80+/XPLv0/OWvJw4H8AQaBQZBH/MTM/YR9XW+VFQx1BWfYqZUESz+xY+vuydUV/ZLS5CqBHY8DMVbmZcgkfNdS9dfxsj0uKBwljueZbrnJxAUL6WLgjmWgAcpBUZBWyk2VlLryM0p49Lv7vb7dvxhx81NT1NbqrahH0ameeShT1yw4zQG1iuLNRKhBCQH/UhWhtv+DvKWEBJvfvMW3QimmLlYtTSN5XA8opSmbjXSCsYU+Nd/83NMhN31iuF+ZgqCVxeveLi/57AfefHsBSGfmMaRat0SXIKgeBgiv/zlGw7Hey5Xa8gz8cOB9arFhwlbabICpTLaKGzT0qxWaAXv374nRhCVxNYWLRPzaSIROR0T1y9WNKuKnIqvVytN7raE5HEXW9yc6VaGN68PrFYwz46qNvg4s151VE3Fet1yuLtHC8Hlq5fc3eyZJ0dtW4LrmdxEPyc+ebkhSMlXX75ns9lgdMPDaeTliytynFHGMIwjbvZ03QqlLcPxiFKJmCPOeVxKXGw7FJZf/PxnfO+7z+nWHdgakaD9pMiz+tOI6gfm7Om2LSJF7h6OGKNI0vDscoUKhvc3X3F9vaGtLNFHZpdx4USWM5tkkGlgt6nYLdHkJjhyBGvXzPOBpmr44pMVxmqiS6x2NcPQk8fEun1GqyNXl5fkmHE+Ik1G+IyLM7pN2JINwsXuGXVdk1JEZsGLV1fEAGHuCZNnddHBM8nsNihVJNGVVrx/39NayDLjyCihuDQtwzzR1Fv6hfk9HR0+DxijOd68peokcpgxlSa1qSx0kUsk98mx3Vi+fv8Gmy27F9fobsdf/K/+K6Rueffl16Q0oaUgEfjVT79kGA40uw0uz0x41sKgLjbUqcK2LXPvuNxWaJsgf9tz9sceFW2JS5/2VEbRTx4rMwLFqt4xnUBKzfF0pDOW7bqjMzXT5Lhotry8fkVMif1+j9BF6m1NDTKQVcRLicby8pMv+JMvfsQnL68wJqG05+e/+An/+t/8O+qq49NPvsN//S//JdFlvv7N1xz3I/PgGfOJD8M7ZjkRTMIJyZwN/TxyED3RJdZNhXeZyilG5xFaYGtNzIF+LEz0PI40zQplJXNMRJk4zCN26WgLzDSmJhvNzeGeJBRKVsiQWG82fHp5SfryS4J3kBO60qQAJFHCJsjEpMg6IhvDPMy8GQakkYQqIKRCCIM1lpv7NxAlbbPCWMvoXFkg1gorWwSKFDNCR9pGEOOB3brj+eWnrE1D2o8oP7PVEdkIOmu56tb8ePOKL5tLvn64Z0oO3VgeDifu8oStFU5OfH38hufrDSYLgp85Hvc0mxfMvSlSw7YlnEoiNlZQacnp9EC1qti0lzw83HOaBu7eHrgPPZu2pbOKIUbup4HjPJMqiwTy6Jjn4ruOOvMwD7RtzRwSVhjkNJVQmOzJ3jMLGIMvdTHdinnq8XEmq4jWhuR98dhriZQSbS0pS7p1h3cTVpsl0VHgvMPlwDxNbLRdYvEFc4xMs8NogxAG72NRVSlT6lVk+czcPnuOqSv6MJPnTHAeQc9qvWPs3yFl4off/TFJ/ZCf/fwnfP36a/a3e3z6O7x35GSoxOeY2qCMYr1u2G46cnJL2N3vN/4g4EzJIhX8LaFXhhgFIUPIYmHU4OzFInPOsPhI5PfRv789dy1gSz0xYyGV2pTEkz3o48eW5LtFh58/Kgl+7Ola7n8O1jhPwEXZ+bP8TcmCH8zCupzj/aWIxCRIMj36sT4OlJBntJkLKPhobr/sr3wUwOVzIt/j/j9Nvn9rMn9mzc4+puVYnD1mcrlfYcLy0/Zg6WBbPF1kyAmr5NLtlZbo/PzEgmVBzmc5o/iIvcvnF1W+sEWRZlqZFkliptKCEErfWcY/SfsWX5YSAqkhZQW5FEJKQCtZglySXID0gpOSJOSyz8iIKWgZmUsUvRKJZxeCf7WpOJ0CN0eJi4mLOvHVPfzsJnOYlxO8AFn5SGWWRMl8vkDPoOzj87GwhEU+mtHmifE0InHRSo5zZo6pXOePDBsEIQmUBD7zmOyZHxWoZymyWBYLHs8zmZwycxLMIXIQglWleLXJHKbEfvwWnv2xx+VVh0RwchOTz/igqNc7EJrdriEjcXgeHo6olDHrNc4ntnUFJEKa2awuydLTVg1KgXeBWltcyqgsMSpzcdXyv/mv/zlVpcg5cLsXXFYVTWe4e8isGss03pW6hyh49+YD3WaFEILpw8x2Lbm+/oR5ikzBUIty3Ww6S0qQhOTUnxCqJE0e708oCSlA0zXMMRP9XORNtSVn2KiZsZ9KT4w1JU0wJ6bZ88tff8X+znF5taJrXnL1rCMk6KcjtpIYCXOYmU+5eOF8oBaG48M9SkiaSuHnwN5NSClY7zpU3bC/f+DliyvuHw6I4AszHSdef/WOFCTf/d4luq4IfmC4/8DsIs265bMvvuDm69+gmw1Cwvv9Pd/9wac0tUVEcGHC+UBTtXz99TeY1vLy4oLGCFIUKNtg1iuEz7y5fcD7zLsPBz77znO++fodGyvo2hX94YQ1ktvjyL/75u9Y7bZ89/ufUKmEyJphnEkhYauRbGb6FAhDIM+KttbgBafjgYvVtoDKlDnc36Jsg1ICLQ3Oly7GVlTM88RqsyHMEDyEFKiMRuREXhY7TW1xwSN8OVeVlQVEJ4V5EbHG4EPk4WGiqiWVbajnhspKtiuLVPDys4ZpnJDCEnZD2a4on7FpF1HZ4HzmWU7s9idu9nuerV4Sxpmv/u5LTGO5ffvf8/7ulh/96Z9Sacn9fmC3M1gZkKLhyzfvqWuLUDXrS0l2AmsU+5sTwlb4lNmIiuPD+I/9tv+f/WjNBcP8QGUEphLkXKOz4GJ9SV1vOKWe43BDEj3XV59z9+bX/GSa+OKLH1BL+OzVS+Y4c3d3IIbMav0MrQyH+bYwGjmCTLy/e4MfJ4bTS9bbmsDE+8MdH4Z7WufZ/2zg/e0tP/r+j3n2/Dmb3Y7+OHHjFa/da7zy5DSybi5oTYsQhkxGr2r8HDG2QtkKkTQ+Rcb5nqauMVKilMIYSyZxPBywXUsIE3WzQuaMcxNNJcnhCNkiVQFTwzzghp6X18/47qef8cXVc16/fs2Xb77mlCM5Z2qleXn9nE23xaqKYZ55c3fPab4l2RGtA3XT0juHTIBRxBhJyXOaj4QkkFYhZAljcUwo21BRFBkhBzwwqcxhPhLGGRsdRnoMA94lBq/IYqRaVZhtxWVeERxkpbmd7pBEpBKcxgFjNdPdgRfdFdt2i4g1AwqRPMIoRinph5mQwU0Tt4d7XE6cxpF2vSLmSN1YjG4YhhOrpsZFwWmcOA0jUUhWmy02OGaRyEFjrSHNvnj+k2AWAm8MujIM88zkPLrpCHMqC4RKYdDEZFFKoVSxsqiVZrvaFUYuQ1qSy0ffQ47M44jMGWyFVLb0IpsEyqCyQkRJiI5G1rSm4cc//jFunPjFz39OHxwpF0XHlCLenegrz0rUyADD4cToRm4OX/Ms7ZinnjfjPZsXn6NFQmhFvaqLvF4K1tsNbg48v75gGkei7znuHzg83D2F9/0e4w8CzsQCaPKZUcoQosDHs9Duo0jyx/i7J83ibzFkj5im/P3MepxLW3MuTN3HaYxCFDYt/UPbWp5ywTRPP1BYkCe54dPts4eu+NIW6RsLGFrYI5nzUpwtl/sXn9ljWrs4b/bpxJyDNn6b+3jy2D3t+EdJgVks3qgnj9l5gn/++TE8hQwpLzH0cgHDpdi5lFYXwCVYAOGjT+23u8rOkbQFkC5l1LmA2bOMbxF6ImVZlT2zU3OEEEP5oE4eqTRKmnKsUyJHgbJysWCVXrycCmspZAkXSWcfYgStE1okopBIoUBmlFSklMsxz+oRAHetpq7L5CVFxT9pIz98KfjmLvLLD3AzJvwCFq0qnWPD+BE2/4hV+11vp3OaZkHM5QRpkdk2MEfB6Epf8flcCErSIrm85hhKWXDpjmMJKVlWph8XKhZmlwXIUZjnwyg4zbDtFC82v/9KzLfj9xurumaaZ4xShDSh25raCmKS5HGk70fefzjx+fdeQJZsLi8Z+gcapcBqdqs10zjjXMLLCT9HpO6IfkBbibKai92Wu/6B/c0dTXWNYSZ4AcLx4e0DwQe0Nrjoubha058cz63B1DVZKq4vDLOb2L9/4HDq+c5nr+jnkU9fPWecTvz0F2/4zos17aYDJYrHZNOS5kDXGWKIbFdd8TOSSEFgrCZjIRUZ8ewiOgeO40yaZn74o+/y+psPPNteI+sVSJiPB9bdFVJlIpqVVkQ6Hm5eY5uaLGeqWvPZD/6Ev/23/5aQAut1RX90vHjRcPP2Hd4NTFkhSHS7LVVjOfQjV8+fkRL4rJEycThO2KZltc403Zb3b1+TkVSq4v2HGy6uNgynwOkIX3zvBW7yvH39GwYc66tPSdM9d8cB2xre3j7Qrgaqdk2aMraF2+PIF9/7DtGPPPvOmrk/oduatY5oqdErzcsf7JhPI0ZlKmmptONXb25ZbxRff/nA5vma1daQRGY+jXinkEazvlyTnGcYZqw2RJ1JoaeqOm5vbpljpF01KCnQCab+hDIaoQow76eZ9aoiZsE8O2RtUGQur54xTIHTOHF51TGeDjR1VwAWASFGKluhTE2nAlIIDsc9F9tLvAvMw4ypE6qpiEfP5UXHHCJu9iAy7272bK7XrLcbvCiyJbNeE0Xm2fNLTvsjz686bt+/4c2He7773U/JMfH+bs/Fs5bvfv/7aK3I0XF/P6HMyN1h5OJyx2kc+fyzF4yjQM7fLjr9sceHu7eINqFqyTA64iDZ2S1X9hnJB+q6QgTBbtcy9Pd8uDkS3r/mq/6ei+2O6D2NEPzwu9/joXe0zRqrDPtvTqAkbW0YTyeCPzDNd9zPb8hkJjcVpYoxBBkRcubN3dd88/4rri6esd1dkGRi9CP9wwcaGVg1lkZn5imTTUvVrogxcz/dIqwBYLPqOI49PioQgqwEfdhjG42XEWUq9scDWoCLofRP9g6BwIWAi5LBOZq2RSRBZbf84mdfM9w7Xl4/Q1Hxg+/+KfV2y7/9q79CZclKdVzoNcY21DawPx15O/UonbGqYp4yKncoFNNpRkiPxNM2W/phAmmQWmK1JXtH9g5pDaNzJGWYvcZqSS/7EhO/d2hhCCkgtMfrAT2faA49l+tdUT6Fidn3iDSxaTumOONkB+0zpNB4aehjIrUttqqYxwmrJaPr6ceeqq1wCeacsK3BCI+1mhwjOcVlLibwwwFZafaD5+SnkpY5H1jpCr3b8pu3X6HqFVmUsBSrG3xyfLU/cr1Zk7Pgm/s7TF2DBpkzyii0FZggkapi9D3aJEwtsXTMIRW57DSiUtFuJZnRxhAmzzANVEaRUvFyy1pRVR3rbsPd7Q1fbDfUtmZdt6j1BUpW/ObN1zzsb6gqwRjG0m8WG94cbglThhwJI7RHidcOUc0oNzDuHRfVBX5Xsx8j+/7IHBJv7j5QdTW3x/dYkUt3adUilCmVM7/nEDnn/8mfhi+3CwuUIUaFX8p+oUgLF7Lpt6Rhf18q9vE475EUBT2eQU7MLIW9vz1x/tiTdU43PCfsLVkkv/W0jyDso9sCitzvkclYJuKcX0epBDCLdE/KTKWK2U8ImLP46CWJj/xG59h5sYCjJ4ruDNyWZ+DcrZXOE/XMR2wcCNJjKEeJwHySZp7v+sSyLQCX+MhCCvHE0BUAKhFZLtt4KsAuoEKeN0YW4vG5y/HOC3soHrerxRMErbXgv/svVmhZestSygjKF3rOAZHNIn8VRUZIQIi0FFQWWUtMgRwVAo0yeYmaF8S4MIZCgQikmJbzLfDeP4aVpFSeN6YMSZNExPnEw5B5c5eIUjFNmff7yJxL6WR64gX/g2vxzP4pXWLPz9eb+OhYC1HSFkMGHwtIc3EB8MBqpehPhemzC9t8BtVPyxhPJ/MxfOXxOpac28HbRvDN/tvC1j/m+L/8H/87lIJ6vWK/PxHTIpVWlhQ99/uebtVRa6iMRZgKkRzPr3fcH0/MkycEgQ+Ru35Es+LiypLmiZw8q7bh8vqKt7d7xskxu0w8OS5frvFz4jAUFmG9vmAeH1AGTgfPdz7ZcTyNtKuWFANV23L/4Z6sJJVI5BjZrmuOx1ts3UEOpKrB1h2rusbNE/NpRNWWOM+oSrNZr8gp4Ocif2wqwzD2zLPDZ02eJxwGP5XULqU143BgtdoQVWZ4GNGN4fLyijfvbpmnkZAy1887pLAQRmJIpOSoV2uMVfjgSWlCJk1ICZ116ZQLJZ59162L3yQU3byfA0qq4jHOiuQmLndrTqeB1XbFHBJaKJQGlEIrj80gm5Z+2BOTQSmD0ZIPxwdWdsV+PxGmEW1Lh6StNU27ZuoHZuGZ3QPv3txysbnm+uVz1psN9zfvaLcN6eiKwX3wKC0ZRo+pSriSnx3rbcf+8IF1u6Fbbdj3I2k4cT/0tG1D11oqa1nZFpEjycGhP7G5XBOHASlrxnkieIeQYIxCmoYcElMIGJOp2zV3tweMCDR1he12SNnx7vXfLbJxzTw7hnGm7iqiz6w6S9O0TH5CRsU0nvAxIAzMISNyZrXuMMISfSj3U5a27Tgd70EFZFPRyA2vf3PH5qphGHsqqbh7GGh2NdJD3TbErLj+bMNKW1zvePfunhAF++HI5XZF0or9fiDnGZsrqkbxf/o//1//Ud/3/3Mf/4f//X9JSp6UobYtyAqTHBsDlbIICXMeGVLPQ3/kNDgyBpE0V+stxhh8VHz68gukaDDWctjfc3t84GK3pTYl3fbmcMtxOhGUx7uA0RYhFCGmUjotYOh7yJmmrkudTiqLVqqSVJVm7o+IOZK8RtqGFCU5BLwbSVoTAWkMPgd8jAihkVpgNFRWUak105g4zD1GS1ZNQ6UMtbH008h+GLDasFtvEGSmYSLlgB8c22bN8TQyhUC7WfHy5RV3t3fIJPj8+hN27ZrBzbw53HHXP+DTTEqOqrKEmJCyVB41bcvxeKI2AqsVMYIUhv9ve2+2I1mWZud9ezqjjT7FkBE5VLGququbZBNqCAQECtCFXkK60wPoAXSvhxCgG90JkJ5BggBKIgVSFMnurrkqp4jw0cYz70kXx8zdM6spssQsdKFpC8gwTzc7wz6D+V5nrX/9wUuGdqDMEjASL+IYEBI8xujxAW4AFSR2GMiTjGoYUNqQGUOeZiilaFZrJkbxvY+vEAb2Ef7FT39N48a/VUjDJJuinWVaFEyKKUZr6u2O+WxOmiQ83N9TzCesmy1f3HyJV56kKHDW4QZ3KBOSJCYZ/zb0DVZA7wbwkVmakYgx4Gq9WaGj4Gp5jouazkc27RYM5JlGhkhTWXzwaKMJIXK+OOPjF6+YZSXt0PLFu69w3mIJVE2FNIqoJXW9Q8WAFgajJ/SNRUtNkaXYocG5wOACSZYwzSeoCKlSvHj5iof7B6b5hP2u4dXLjzCznHe3X/Lh5gvqeouSGikFvRsQQtM1HlzgfDJBtnvOC810YsiLkiEatnXPrmtRmWGIkWZwiMSQKonrW7KkINMpIsBgHf/9//i//U736Xdja4xjopyLEUcAOdYgHUL8RnsKjGrLo3L1RJQOb42v8RCLf7ATEp9ImYvfcp39NeTuaPM7qmTfoJ7PVLBHUvb4etjYM8XsqMaMn49jvHkUJEAKY3PsCIs0Mo+RLii6MFrt4qH26/H1W42DH0Wr54N4Zms7qo0j4xQHy+ETkXveJTs+D7OIkTEsQjwmKo5lVOLR4vRI0KI8LDPW1I3bH5VAH8JhJ8c6NSHkIQhkpJVSPgtmIR5CREZFsevgr64dP34pkMiDqhogSIQcb0YRD4WKj+reIZ3RKQiRiEGqADi8kwj0QfWLxCjx0R72X+BdwLpRSYohEqJHCEHwY8e7IDxtr/EiYtJIWTp+c+PZNWFseR0F/kiyDtz5kZQdRvyo/waBQo6q4rOAzKPSO9ZEjsQ9GkFAjk3Tw1hL583Y26oPY+iLPlhQH4nZYZsiPllhny6TIxEMtO2pNuP3jSEqcpPyxVdblnNBZhRJljPUFW2AT16+QCVg7Xjt7XYrprmhbhq291uiEDgnSMuUWVGyX+9Iw4JQpux3Y/PoDz/5knySMS1yaNakl4r31zuMDOPkKc/p92uK6RQhLK3y7NZ7Gutp6przWcH7+zXTzCCN5u6+JhMekwqyxRlSa3brikmmCP2eylZjUlaIXM2XDG2F6C3r+zW7umVx/ook0exWW7JJThdblNSQTwn9wGQ2pesbNnYg+kC9WjH0A2eLnIe7ig/v7nnzakq6mFKmBW13R1SW6HqcNvjOItZ3ZGfn9H3D5+9WXFx+xPquwlvP6xcTktKQpwXrfYsyESklQhi8FngXMUYwdAPRK+5We6RMyH1Eikh5lrO6vSfXGjnJeHd9TZYloAwieHwaqG/3THLD4AbOlzkiZIQo6IYOETT3728o84QMEKHk6kJzPpuQRAvVlsW0gN5ijEBrhZ4orHVM8pTeWVKdIMuGPu5YLl8SREcjSvrdPctZwXyxZLffs60bdN1Th5ppkYDUzGdnPNzegXOs6zUhjq1OZpOCNjhiN5AlCp3l7PsOJQWTac79/Zo2NIh6yyybkWqQ2iC0QqcJxbQghB41TxDe0dYVi8Wcal/hIpTzDN84jFZobZhOUzQJCEnXd1jrGPoWqTNiP9p8H3bviUrQ+zGC2wrNdCLxLhC1YrXakBQZib8iK8/JpgKZLLCu4gfnP6Jebei7jkmS0PU1fduTpt95d58TvoW+0SQyIZeBjy5eIjPJ9u4rjBrrzspyTiJyHt7tkMGQZSm1cyijuR7WmD7hbPIxWTpHB4mSgvTijLcfv0HZQF/tIMuYzQp+9vXnrNselAaV4oPE+4BgbGycaYjBgYM0yZAx4oTHhch2tUcisH1HUUzIioTQR6p1TXQB29RkRUGIFiklqTQonYw913zA+kgUHV3rOSumvHnzER+//ogiTWn3NUFKtnVDta1ItaZIFV27YwgGpRJiGLDhPUO/pw81X36o0caQ6pT90ACR3vb0/Y6u3yKNQMlA31boNCdJGcmNa3B2LMNRQqBlgghjTH0UFq2g9R1d31JmKS9nE/rg2LQtRIOSKR5PP+wp0inLyRUfX3xMOTGEUPFwZqmrrwmy4aI8o4wFr+cpv940FGlKDBrf9zgcidcsfMQPPa7rcElCKiVpFKRC4/sBISVSK6RS4B1BjfOeKCFNE+q2YfAOaRTSRSb5hL6qCQkoY9BBME1ySq9IsxwrJJmMbLot9WbLbDrnfLpERUG9XSNkZFjd8b7a0i3mVHY/2tSU4mJ5RbgdaPt2DE2THkJACInEMp+kBB+Qsscox7BvMElK1awZhi3nWc4f/+hPSKXElAl/8aufsOsG3m1vmJ3NGPqWtm0wiUJJQfBjX08vI0kZUTHBiXFO/GGzA10SGMNg8nJO5yRaamIIJDIyuAEfQemAUANDHIg+jmmfvyO+myh9GfFu7KZ9DIY4EisOL49WP55+96QfHRLyxEjMUvGUGjgAB06APFjxnk9k4SAuHQmKiN9oEhy/1TblGLAx7kt8UtHicRr+9M+3faIijqEPjrG3mBRgncRYyLQnU55MCbogaFwgIJ/Vkh2Vsqfj8GgPfBxTPFgejxbD42TcI0KEQ6rho+0uhscDKcRzQicOISLicUvH0AtxZBSP8uTY1DqG8bMhjGEtj2pNHCc9x6ARntnxjqT7Ubs71KkhI//i845ZmvNmZomA0hGiPvReG8euhUTKkZR5N25bCg8HhTHikUKjZMQ5hw/HbYXR8hgGQnDEGAiHsJOx7YHnEOt4UP0iTef52c3A9T7SDOFALo99954prcehPF0Sz0dICOBcpMjE0xk7HM74xNQOL4djriAeHlgsMh6358Lx2hZ09mlbv6X0Prt2D6bSb90BJ/w+YISAYHn9YkpqNM61xOApZyUTNIO1VDtH6C15mXL10Wv6puH64QEZFdumpuskZYx426LTYpww9J5MJyRlxjyBIlPcrVb4wUJreH2ZMy1T+s6Cgn4wzBeKr+4aHlZb8hclVg+clwtCVEymM1wM9LuGbHZBtD2tjVT7HYiIKRIG6xFaIgbFurmhmBbYYU+z37C8vKCvBmYmxxhP33cMviXsAllW4mXg+voDZxcvGPqWRBouUsGgBcVkznazww0Df/Knn3K9qeg3O4pc03U1QuZstw3zyQwlPb2VdKFHdpHt1nJ5cUlX78kKSVYuyLOUzX5DkgrysznSOUR0TPOSPkJV1SyXM1CR3WqLMAm+7ajbhmxaMngo0gl906ALRVFMkUnJrurxLqG5/Zokz5mWF6gso6ruEE5R7bYszl5ArPnkzQypNE3dMJeSVmiEzvB9hcOhJfTtQGpyjIigNEPd4G3P2cWCqq+ZmRkf7u5Isi1RFWzXHxB9T9NA6Dp2VUMxnWDEwFleIJRASkkMAxfLJTKBaeNYP2xQKqJkhkoUmTI4O9C1NakXbN7dkpqEaamo6kDQgsr3SA0Eh6g9Siomk4KuF9jekuqcoBzb3QalFJM8RUqFzlKiAJUENquaNPV4KbBDIEs0MnqkCESpKYxicnWOVAJvLTJNCLFDxjm7eo824KTivFCsbt5juz3T6QwpIq9ev8BbTfn6FUNdcX+/JkSBViN5P+H3iyIbQGi0VGzvbkh9y4uzJUliwI8hFvu+o3IDCgHWkQqBkhEVPGmRcvHyBUIFRLTYzvHixQs655DB4+saKS3Liebt2RJ3H9m0FUFaBBJlYLu7RYeIRlLmBVFErPPodLTseiLZZMntw55EL7DGUOaarJDsdg6tE4JUJPmU4ARllvPq1QvKyYT3H96z3e7Ii4K8LDk/P+dqcYGMkusvv+LV1Stm2ZwQHOnEMNGGpt3TdhVD3SGNJAwNTbVlZiKpSQlK0g0RhKYsJsyWS0xU3F9vaGxPmqcE75ExJTMJ7dCSFIYsN3SdYzaZoeX4t90PA/PJhN12hyew7ltkUKRiynkxZ5llvNs+EEXKECJ+sLx9+TEfXbxkkWWkxiB85GH1OX13Q5Q1MfR8fbtmW/dMZq/R2pAVOW09UJZTXDuQ5wmX8yVlSIkqoMoZ3g7s9wNaC67vv2aLxRpBagxhaBFxQOuxpZEiEOmQqSP2HcYY8lSjRMSlBiside+xfsyZuN1vaW8+UE4nJJMCgWawEicMjXeo3tHXLckhBMXg2K4b2hhxaYoTmv7uhl21ZwgDWDF+B/lIohXajmnE6EjwAzFRdGlPE3pCDPT7mmmW0t18QTO0zKZL/vxHn/K//sVfctM+sLqtcLbHJJqpSom2J/Q9zRDBCIQKLBZT1rcbXp1NCPuO0NTYtibVGpOMyaR135LP5lR2jU4kbhhItGFwFpMarLBgfvf79DshZ94/a9R7tAUe3oviSeSRj5PWJxzVHXUgZUZyqC84JDE+I1rHDTzPNXycUB/CJh7NhMcJ8zOf2qN5TxxtYk/q0nOro3g2kOfjQMQnq2OE4CJWRDZIUidI1KhouRgfw0dkfJpKP9rgjsqeOKpr8THeH+IhSIORNBGfepTFo0J1rOA77HSU36ili4hDAMi434oxBRHxLEvwqPYE+XzLhxHLR9UwRkHgUK/GGCgyikSRGHikCkcie0yndCHyj3/e8p/9IOFqPhCiQotIjAqpIIbAYANKKowBqSXOBbwfg0V0IgCN92bsAM+hxcGBjPkQGfo4Rq1iRrXscOysH1VCEf3BCiiZlZ4//0TSD4H7RvL1Gr7eBWp3pM3j2OVj4mJ8tC4eHzTEw3XRW0+Zj0WQR1LL8dwerrHH6yg+13rDqGAyVuulCoQGLcQ4Hv/80cXTtRi/8SvxjfdP+P1BiojRBq3GFOfJdIazDusiaImUCd12zXxeEoOj2u4okoyynKIxTJczbHBEH7HWs17Xo+06SM7PpwTnKBZzlPScW0urJZMyp+kt93cVTiqKPKVqGrrG0QXBxcWEpMwpJhNoJW3vKIuEfdcznRXj02UvaPvI8uKMrt4Th47tZkBkkS+/2LG8CkxmJV+9/4oymfHF5x+YLhJEhNX6HqMyvHZkWU5SatY3d2SzlIf6DuNKyoVCWEfdegSGVVDIGPn8wzUxRO63e8q2ZzYpmC4mnL2YUO9q0iApZyViyGjagZdv3vLh/YpyMkUoQ101XG8teVmST+aIEGnabnyy33gQA3la8rCq6buaxlYEJPNyymK6xAtHXe3JJ5fYboftdqwebnj9yZ+y2Wxxfs9ZOSXPU3ZtR333QBQNMteUeaDafM3l1QUyCurdjsQYusFzs73j/GrKVE/JJiUfrm+ZlROC8+AjUXoSo0kySV9tCaLD6TE8YDafU7U1l+c5wySSiJQsSchyQ17mbO4e2LSeXI9/A4rSUO0rLsszBhmQiSJbzFECvO1AwdAHjEzZ7S0mFWgVCVEzDBbXdKQzzf1+j1SSxXSOkQHbVaMLAsswKLQJ+Dg+wApiwPfjg1EI2FbTU9Dud5TlhNl0Tj90WBRGOcp5RgR8DGPT6DTHWU+9j7R+oJjl2Dby8nWB70EpT1/vqduOxBgyneCt5MPqjvmkQIpIXTesVg+0/d/oLf8fBGS6JyEn8TnzdIbrDPVeErNkbCIuAonQLKeX3DVrMpWjh7H/nxCGttvx05//7yTSMM/mvHzxMdv3v2a7W/FqPidXghgdzb5lmebY2QJhB1rvCHJMHNWpJDpP1/ZM9AznIhhFExxtN/aBzAtFkYILPVKl7LYNRWK4fLGkrvboPCW4wKef/R1enb9ikmUkWvP24i0mMQQOhE8rdDI21b6YLfjpX/xrVjGyuJiRTAu23Y4PD/eURUntHEnYkUmNEJIyXZICUUtC3FF1De9u3vP1h68okhSN5GJ5QZaWTIops+WCoe/o+ooiT1FK49x43Lresdlu2cYtm6aniQFLIA6BYDsuz+eQKe6ahlXtqENASYlyEdEMiLojmoTr1Ves7t/TtfcY1YOwmDTHigXv3rekmx3vr9eYomQ+WaJxvLq64LM3b3F1w1DVOMa6sod9xzB4pJKoLOXKJBhl2bmGytdoLZEe5uWMrm1oupGULSZL7NCA91jbkEiNd45CKrZtSx0cKk9hVrAjEto9VV8Tkkjlx5TQ3XpDtI5zmSMHTV33hFTSKxiiJxwsnnqiiA2I1jGTijOtKNU4Vyu0xpNQi7GGrxkG6u2WLEpm2ZTmfstdW5GnEJ0nnV/wZ9//jFWA2/WOm9sdLu5po0GHHN8bpHLkkwzrB7z3zGYLqs2GmTAoO4oV3kEbKtpphhWK/cMKaQTSW7QM4HuQkuDkmKz8/In7vyO+G+UsPGNc39qHcarPoxoBT2RNxEPriiMpAzovsMSn1DueEa7DSiQHxeaZAMRhO9+etj6KR0fSKA6z7CNhFAf17plK9ltDefZZeZx6y+P6xg1EEbHx2OMqPrNLPoVpgDpYDsearnioPxOMJC4wtr5GBESUhzorDqTo0Pb44GPmkKR4XP5IHGI89ul6RiLjqBCJA9GLB4VRHE/Co4VRPB6rI2ERx99zqPsS4z4ebZpjEqYixHDYj+PnPLUT/C8/7/lHP0h4OQ1jw27CGJBxOLmefiy+xCHFWNAZIvguoI08jFsdzr4HJEKGUaGVY48TIdyBfI41dPIwrrH33pigGBhTH0FwlgVmLwN/51KyqgJfbgXXtWRwYONTtMxRZRWM4xz5+Tg+OwiUPKhnj7V4h+vnIA8+p/dHRXOcII3nJMbxvFsERgWGcLiynxH656Tsm9Whpz5nv2+YLOGr61v6Gl69uiQtPMF5YpD00aGFZDov+N733+KD5f7DihAd1arhbD7DhkCuFV4MlNmMvGgIPuPl6zcE29DsGyKBarulaS1lnpGXCZt9zfKswPkI0TI0FSEzmC6wvCxxMvLwsEEMkUSUDE3P+cUZXT/QbhvQ0Ncd79ct08scayVKQ/Sei6sZF7limU5xu47u8ES1bQLRB6SW5Lnhw80aOZN89dUdVy8uWF1fU+YT8qlECc/nXz8w1TkVd+i+IUknFEYSkLy4UhSpYr8bSNOC1WZFkmRU+z25FPTeUnUN7nYgKaeo2NEyEI2iGzzC76m/3jBZTMlTT3CB64cHPv3oHLTHWEs6n6FaRZlndF3HT37yUzyCq1eXyHgz1sk4wXplMeodL5YpSi1Y7VqUbclLSTHXxG60O7b9QDFdYHWkryNFXtL4gaptyUi4+XJN/7IkcSuSvGQyKcE7qtahAkiV0Yeah61lUpZIIkWScb+umeYJsenJTc5uWzGYmtZ1Yw+9RvDi43PWH35Fkc1Y3e25u92QTeZstjX5tET4yK7bUXXt2J7DB8pswvw8w7qITjTOeYp8QZIkED0XS02ZKRI0q21F5aBMJMZoghib/g79wBA9MUoIlixLuVu1zCeaqB3ROzabDbZvyHTCvExR0hBCwLY9aV4QgO12RwSqQSHpMHVO3TY458cAARsY+shsqVlv1vihp2sjSaJYP/RMz6Z8/4+/z6fue7x///A3fdv/rYevJTJJMcmENioGbcjSBCUjRgVkGCiE5UUqSZILqsYySMt+qBiMQGlNKhRaKlb9iu1dQ90OaC/JpCLPZ4ioCW78o/lyec6kLNjUe3Z9y77aI40e7WJ+dFxJpehdoPEd2oyJff3QYRJBsI56t0V7jYsd82WKFz2JkRSTDKMaqu01Z+XHvFgu6Jqa9zdf8tW790SpuLp6CTrhYb/G2wo1dAgR+eJnv+b1x5+wtT0PXUUVPLbvuVwsSScLurpDaImipxk2tP4BXWhEOyAItKFjVuRkqcPVW2aLCwqTMi1zVFgw9GMD3awcSWQ60/TzM94/XLPpNtzuBupuwPuMmAha37Fpt1S7jraPhBBRiSZEz83qHXf37zGTBdZ2xG6H9I5MFgxtTRQdajZjbTW2WYPRmKgoJyXb1YrrD3suihQ1OIgOZIo0CToJtPWOLu7ptxsKZZjPpizKKde7B5pDsJuMKVoJmr4mRIWKmjRZEEJP3ewpioy22YPrsb5HCEXd1iR5gXWOEDwRO9bW9gPBJySJok8DxXKOrRo6OxCURk+mDH1D3dWYVDDUDukTzqdLzqSm8C25tkhRIwP4QVGgcb3jhTEooZmXJW9eXLK7vUZKECpB64LYBq5mBRe5ptvf000L+iGnqSyTUqNLDxikUkgvGXqHCgIRclrrkFqPVUUhEtrIxHfk0xm1FvQi0jqP8wOTIiMgxvkp4qkp9u+A7yQQ5Lx4rsZwmNx/E4/KkXhSI4yA5FC75MOYwmjD03z0+Hl4mvh+Qzc4kLPw13zu34Tj50I88rExHv2bO/tE1o58BZ6i3cWhcE0cSJASkGiBPAY2xDjaBTkSxueKVXx8OZKzY+ewo5VxTII8pgI+Te7HXljHoI7RVDdaOEfyIg7JjByT/gJPgRIcCdtBZROBY9e349l5rvGIw35xqIh6xm6fyG0c9+cxbfCRLo4kIwRP8AItJf/g44Qfvxz7fklpGENAjkrckcCGxzMskON7jP3EpBx5KYyx0oN1h7h+SwyKGOUz9S8Qo+LYK87HgHfxQNA80UMICo+HGAhR0NrIzS7w5U6w7uNoOTyQ2yPBF4eRSQHTTJKob+SQPl17cRzBeDzHf42UGHkg1Mdzf7h2pRjTGFf7SHhWL/hvw+aUbPZ7xf/w3/6XdASMNLRVTZolVPuaaVHgpKTdD8gsJ9YN569f0tYP9H4gYexzojWEweFCz3xS0g4DggQ3eJpmx+AjkzzDpDk6zcD3BC1pqz1aGvouMr1aUK12RD9gpnOWZca7+9UYwRwj7crx6moBrsWpjLJICSKy3eyRImO2SNhcP3C/anj16hVeB3b3a5QQROEQES7mE2QSWdUNhZmjZE+QgdoNRJtxdXmO0lB1NfSOD3cPKC/IpzOwLX1MKLISI1qSNKVtOy6u5mz2WxZ5SZASL/zYs0YIsklOqhMGWxGjpNnVxKjxRIxOUQQG68mKfOyd1A04kWH3G5JiQpIapNCsth0yeC6uJvTSs93XZDof08+8oGothI6PXr9mcI4QHZoE3zc8tGvSfEm7r9E6MHQBL3uqVcf3v/cG6ztuHjZcTecQArooCV0EWqJU2KZnOs3wSObnE2zn2TR7rG0pkwtmheR+tWNxcYnvWowM7OsKi6RpG0ye07QDszIHEurNBm1gkqUImSCEGNsOTEr6biDKln3bY5KMoR8wSqM8DM7z9bsVLy5KtE7GdDU59njMjKSuW4KIpInG+YA2mq7tEYy28qgNX3z1NS8vFxBTdCowZuwhtVltmZ3laOHxIVL1DhnGvzOJSbCO8QGCtOACQUnS1BB7T+csVTNwuZzTDP2YYGoMOjHUm5Zd3dAPDWmWEmPk4vyM5fkVkPJf/Tf/3d/off+3Hf/1f/GfMJudQ1QoZfDB0ezuMNEyLadIH9HS421HpwyNjNzYPW2weDuQZzkhRnx0CCXwURKCJuws33vxhjfFkugcTkay+RQtBXF8IotXgl3fUHvL+9tbqn09RsqHOP5tVo4sz1DGUNUV1gciA8JFpnKOHzwYQdAOIwWpkqgQkV5yPrtiUZ4zny1J8oSbuzu+en9D11miktzWD2RY/vTtW87Pzti4jtY77qr92KvXK86nC64WH3G2vCTJE27vv+RXX/0FlnFfQlA4G1FK0g8dhVa8Xb7EbnpMSLl6/Qk6z2j7DdV+wIicV1evyNOUvm/52S9+Rj4rWF4tqYea1W7H7WrD4IbRMp6mRK9wQSF1inM9PjrAk+UpSkTC0LKcTChkiaskm+0eTAQzWsb72GMyQ5Jq0iKnzApEZXmzuCAZBlIJrRPI6YIvVw+8Wz+QJJ4k0zxs1qRKcVFOSFJN4y2bph771KLxPqCVAjzGSLquJU0NaZoRomW722IHz+XlFeoQRgSKwXla2yKTQMRhm4CMY9z9TKeUWrKt7wm5RGcFm7oB4UcraPBkIePV/Ao9DJjQEWSP1QHhBZlOSGXEDT1O5YSgSI1BBpjkOVqnEBSJkPS9pVOwDT2/un2HKsZ64xAlXTsmiyeqJ9UKLQ2ZLsBKJtkFrutphh2JiMzTEt07RPsOj6B8cUE6X9JLiUdibaRuW4YQ2bUd1jn+p//5H/9O9+l3U337JG09kbL4ZB08NiIThzm+kZDop40PHnr/TAsQ39IF4piJIXkiGceUu0dh57jot9S050QLeLQ+yvisRuvICR5fDhY9vrHoSAbFOGmXxy7Zh30N8WgGHAcpDtbEIHj8LYf1Hc1vkdE2+NR4Mx4IiXxUwjjuZTwyhKNyBvEg343WzHHZeBxkfLa/4UklCxxDPYDox3UcFMGxnk8e6ssiiJF4iWdBJY80+xDvf6yAkzxtJ4pDzLsERGBwnn/6eeSuNvxHbyWL1I6JlCikDCDG8A9xsF2GMNr8fHAkSSD4nBgi9tAOwLuIG9z4hfEYjOLxIYzNqg8E9Eg3QwgH++EheIQIIqAYQ12UiBQm8vFS8tFCsGoCX2/hpokcFekjcX5UYo8qpHiipDGER8IsHpM+BakU5HqsP4yHxJEgRv9uiJKAR8hjrdkzFfpbOCaP/vs/Tjnh3wU+OBKliT4yn2f0rWM2KVA6sl/vmJ1f4NoGczGh2W+RRIxIKMscO1gcfgzTEILBj0E4UUa8DGSTCfPpEi09Wim+/vJrZIiYMkMjGYKjjwa24x9N5QX4nvuHyExrtlXF5eKS4byhWe9IMs/QWi7Pp4To2XSB+SIgrEUqxcsXBancE4OgeDnD9S2tVYSQYHKDMoZPzq7Yrlb4qEizGToqHu7WhK6il44YIlmp+eHiY9qmxUSJ1Dnb/Z4YK+aTGa31zC8NuI5pmmOtY3P/gJMGJSwGEJxjwx6fWNrakjI251Y64OyA84E0LSh1ROQLNv0Ny1mOzwVWKsIwMHSWfJqidMK+74gyEF1H62qMmhGEZWgGkkkCIuEXv/ic86WhzHLS6YSlWRKCIl+mbKotUbW8uniNXwg2uz1ZnvHZJ5+hI2y3DZCBHtAxReuE2eUUO3RE37PZbXlY10Rhubp8RWwjVk3QuUIow936HrxnOivAjg4DFQz1fkvXrJkUC2QiUSYdi969xShF17coo+hsTSY1hS7Z1HtMVBRZikghC/CDzzRKBIbBkyhF4zV324pJGUm0IdGgdIYLDR9/7yP2m5776xsQEh+gWEy4uW/RxnJ5VvBQV+xWFcXMsN82fP1uy/e//4J+31EUJfvOMmfsMxV8S9c5jBx7E60fGopUstu15EXKvq5oO8d1PTAtFYlJSFKDNgKlC+pthylHEun8O9Ik/5u+7f/2Q2vSsiAxKZvNA+vtPd2wJhGBrmoZ9h0pkjxRyEnOzjaQRMpJRlv3uNAhdY7vPSoKUmUQIkGmCWfzM4RO8IMkxEjd9ORJhhEGIxXCB5bZElHXvJy+pDYtu2pLazswCX0PzWDJywTfKxKdjsmkiaALLWlpiDGihGYInn2zZ56XFEmCl4J8UbK8vCDJSmYvP6KK/5Kf/fKndEPFZD5BbSNZTBAhcLu6oXGWNJswLea8unjDi4vXJAKsH+iGLftmQ9MP9A6MyceHzVri/UCaJORJwfvbFWVa4Pqa3Ze/ZLevyIuEWbnk8qykH2rev/8VdWfpQyBXhiyd8dlnP8R5S91W3N498MVX72mHlnyS0rQ9g4WgU7TKMcZQFgWFTpnkEyJQ7ysG5fjo6pzJLCfg+MWvfkahNShoaRkax4TIRTEhCxYlAkIGZOxwTY8RFmsbJBohUqLLQSQMQUHv2e0bKtsTTECElkyONs3BB7QyxCjJ04K2Ghh8jbMBnWZYqRikJMhAYQzOeRbFjIhjGBqsq5nmU6pdz0Ndc68E1numRkHbMzcJdd+hVUFMPEnUGC1YTBcEGbir99ztKmLnmShNqRWp0kgRsbYdG06rBJXPMEYzdDX7rmezb9kQsWlCyBN86NEyQQtFouU4Jw4aUBitKIuUq/NXIDU///znBBqs63F2jRwEmY3kZcl0doZQmugs+SQlTCNm23K32ZJiUfJ3dzp9p+Tscfr+DT4UCYf3JWO/slSCDGARIyl7RiaOatiRdMWDG+zpf0bVIRyVsm9LdM8++jSR5mn9h59/K+zjr1nPo150eE/ybBWHSbYQY0KfQH0jQOIp+vwwmBiIYrT9jB8Jz1Y+HiBJ5JiYEY77GA8JhUfF6yhgHcnXUSuK4GJAimMPrQP5C+JR2SLGR3UqhqMvc1ynFt9Ua570oOOy8vGdo7JzDAx55BPiOGYxKnNhDN0RcmxK/YvryJcPmj99qfjRy0hpepxTo/VTqTHwRcZRyRQeBHgrCdGP4xBjK3Ehx2JNJePYCNx5fIxEP5JYf1AR42PrgaM6GpFxVODC4cIarY8R8CAFKkTOC1hmgu8Pkq93cN3A4MaEICFHz3EMY1y+lEcFNSLkmDx5tKPKw1kNSIYw2iD14ZwKwngzhIAU8tAi4En7+y3t+ShWHt/9a67XE75b5MYwHFJArXU4HyjyjMF35EWOtA5lFLv9lhhhMZ/Q1w3rtcOISB9B60iR5+gUYhiDbNIkRRpJX63QmaZzgWmZUaY5Ipuy36xJoufVxxcM1oHI2O/3GBHA7enceA0O9QrQTCaG1g5MypybLz/Q+Z5UpNzdb9AmYb6cYV3H0LTkWY4NAq0ypgQGKUiL/BALfEeSgrFwdbbgZnPP8iKSF5Jh02EwiC6iQ0uKo+lbFuWc0mts51A4nG8QbaTqIUlKEhzLszNkIpDCI2OkavZoIemH0RIdE4WVEAj0cUBFqNoKxQTVb1DBsL7f0FY7kJHZZIH3jhAHPryreXW5JGqJHHLu12tev4pIAzI3nJ/PaJuaN6+XtO1APp9ye92wLFNW2wdSA0U553rd88FeE1B0necKBalBZYq223M5kcQkoes9iRas1luM0lg/Pqir+8BHFwuCFdxdX7P78o6P316yud2hhKOOlqRS+Dgm0LpOUKQFL87O8C5SNy1CWNAJvXWIFCbTEuctmVYIJN56zso5TbVnv9kyO1syOIuKgqG35OWEzWaLTlLKUlLmKV3XMVjPrupIjeef/eO/ZLbMicFSVQ2ohOViQfQ1uRbcPayZTeYslhl173BELq8mDGEgyzRCOHIjef+wo28sl+c5BI0sApkpEBPJ3cMDaZHRthEUJFpzdi7J8wmJSRFpyvuffMHsbEpILCEG7tcOozuM2/6N3vP/IWAQHT//zV/x9vVHSBMQoUGniuXFC/pti+gcAYHPM0IyWlaEht5bglQQPDK25LlGeMHZ5Iy3Lz4jUxOKtMBby267I7QtQz8wKSZoKUdrlzK0bc8kXZLrKaHoMB99RDu0WKDpO77++pY8nzEvz9hWK2yQNENPMZ2wHywqCBJlsHiqbkCQ03WR6BU+3tCHjlevPqUs5/zgh5/hYs3P3/0SlSuEM1TaEduKWTlnv6v45OMfjKl8vaeqNqjgqLst6TTjfn2HDWJsKl3VSGFQUROjJEmnRKHoQk/XtBTJhHIy4XJasshnVLsdd7fvWalAlibMZgnl7IoiX5BKzbvffE7d7nAh4KNgWpbMz5bsu5qPX18yTVPatgUEvQMbxubZptB0TU3PHqcHqtZR2YQYHItFRp4nOGu52XuyVDG0FVFrQhAYY8bgFinRwTEzgkI7UOOD4qHrkEPg4WFPkmvkfMIkTbjf3h3aYlm0yWg7x3xSgBA0zYAPnqruSFODVpq26fFeEEODLNz43d72TMspxhRY1aFURKgxTEualDAoLssJaSrI84SHuxWZLFhMDFNjyEMgjWP/sHI6ZWgq9sqzaje4rCCzEt91XF2c8/3PfsB217BvLLELSKG5q7ZUYaCLkTg4JGOttG96OlsjtSEtJmMYVN9gQ6TpVlTdQN9ZvHckJhvLeNAMsqWYpwjjaeoHsqygb3oSLQhCEFpPTk5RzKj/fxTTfifk7HkQx+PvnpEnFUf7oj5aCoE2jml1Ph5NdCOzjDxXHTgk+3FQb562F/kWCfv2/jyT8MSz/XvkQ3/Ncr81rsPrb33soKYoNU64lThY6R5VpaPGF8bQj/ikvIwbPpKfyFEjHFWvwweP9WRxTFmMz2rkHpW0gxVSiHggSOPyQognEhlHJhKOEflEgjiqbv5gcwyPJyo+pliGJ8J1qLGKQh7WcEhTfCRv8JTFGQ/DO9RTHZQ8KT3agHWBzln++VeWn94ofnQgaYX0BBuIUox1YSIi5dhQ0jkY3DA2wj4SQzjEax8TGv1Yo3hQxMYUS/UYvoAY/dvh8byMntRIGD2KYSS1IwGUiBgIQpAlgc/O4dUscrMXXNdg/XguHDz2vVJyVB3lIZpTiJG06YNdMQCD90QfSZQkUWrcdjhEg8RI1coxafLxwj4Q3MMZeZ7meQy/OeH3i6ZrSdJyPB0ukKcKISxaKEg89X5HphNmxQwRKtq6JjiBH3pkbpiWOZMsZd9VdPuexg44K3j5YsbN1x8IUtA9WMw8xe4tcikYeofAMSkzdqt7+q7F5FOGtmHnPXk6EqF+UNiuZzYXbLdjA1XfO7SRTIsp0UFdOXAtX/5qw8vLOe0QGVyPTmHwLZMyR0Qxxs2XBSmGXGiEClx/+SVeWPrQ8cX9mhfnc9p2j7UGgkTKglRndOs9dd2R51PW9yt0YfBO0tRgfEdIDVW1Js8MeTHlw90d09mMJDUsi5zO9nSdxfiUpu4o0oSqcSwvxj5bkoBzLeezOW1mCN5jJue02wf6fc/Li3O6DpJcEaPlfL5ABT9arzJPaB13t9cA5GXK/mGN7/ao+ZJpmWKk4Ob9mo9fvUAn8LCzBLvhr764p/tXn5MYzadvz7jvKsoiZ7aYcnO3Ip+kaClpdg4dPbmUPFxX5EWknExJhh5cizaSobUE5+npQI4Tj0QnzPMJs/kbhvYepXcEOxy+s2EYPFXbMMv0+HDLD0QitvP0zmOUQEqBSjT9tqZqdrio6LuOuhvIS83765ZER2azjCw1BN+x6gRmACMTslKRpimbhxqlHH4QCKGpdhvaztFbRxCSXAWaWqFlgpNhbPxqB7yCrz5sSI2naCakSU1ZTMinJUYKssxQ9ZG2b7iYTji7PAOfUE4nhB8aUjXg3YTb6wfSeYpE4Ybmb/iu/9sPGwNFnrO+W5EbzVRlJHnGLLukGmo6OSozGEVMBGowCDdAbylEijaCqt0yWZQoYXj/9S3DFq6Wr7k6l8zKkvv6BmEH3l68YF911N6RlSVOQEwTfn17zf3te95eLvl7L3/EfPKGgOR+V/HxxfcJxvCbr79gvVkjpETESHAOoxR2GDBJhh9Gy1wTHE4P6Lhjtx/49f1XfHq/Z1ks+PiTt8xnc2bVBXWzJ59mrGLHZt+RTxb4EPjJL37KOBVQJNrw4uyMGB316j3NsMVT0XSREAOIlEl+jhQpWqXMJlOmeSRTJZfLC4rUEL0lzwxaSXabB5qmwvcO263w9ZZ/+ZNfsq57VJ7Q2IrZcsbgPdZ5hDYkWcYQGvZ6dC15F9BZQTUMbKodd/UNJoAPlqzMxmPaW2ZFRhojU5FSlDNmcsq22SDSlH7wDIpRvYwGFx1OBProRpKEx2iNEILGO2SaMAiPaMZQkFk6GclJojEmI9ga7yLWWvpuIM0zokkR2jDsG+aTBLykGyCd5ITQ0nYDtt8Dgr6XRDGM9dG+QcuOJAUrAhNr8LuauUxRac5yMeVsMsW2Pav7B+QAvRA0rWDfSYIs2DlBbTuWmeEHP/ohs+mM6fSM1sP79x/ou54AqFShfKSzAYOhbx3K5FhfY1JDHzwqNhAcPmqEVgyxxQuHx+GFIZ9maClxFXROYm3ANhWpt+z2O3a06DJnvd/QVi3TYgb+d79Pvxvl7NGqxzcYWhQjKUvlGKgQxdirrPfj6yNBOdq14ECc4nOn4agtBZ7UsuP6v0WwHt2VRwfggZQd1bjnn3lcRjwt/Vt1Psd1HGxqT57Iw9xZRJQ4pv09mvsed3wkFMd3xaMFTyBGAndceRwtgWMd0kFJAo71ScfIy2M91Wh9VI/H7lFtfKxPg6Pt8PEoi5GojMsG9GH+z6FW60i4Ho/Fs3+faPPj6Tkcu6fxPP7+QCbFsZ7tECai5agwOhexQVANnn/+ZeCvbhR/dKH4oxeSSRrwcSRSHCyL46gNUnrEIUwlBvDh2HdtJGIIB3KsHxNBHhSzUXUbCdy4Pjl6N4kRvJdj+wcxnjclFF6N9kJ9eJqloiA38HbhuSjhQwWrVhx62Y3bi4fjo+KBGAtB9GN/pmOrAQmEQypjOPaUiwIfI3UHe3sYmzge6/h0oB9J71Pjbnlqc/Z7R5Ka0cISBoK3o9ple7omkOaS/X5HZQxu33I1X6CSSN1s6TrHojS8e/dAWWRUzQ6dSgQp02LKejv2KZtME4zK2a/32MYSfEs5PUMpw2pd03Y9m/st3/vxAusDSSLwNhKFQhhFmedUTU2aSVo34L1F2EA2SRFKcnGWM/Q9aaaw3hPoUTEivScOFi81xkApFbmRGMB1HR5BcJGHfUueaT558wn4CiE0xXSKdQNDZUm1wJiCi1eXeC/p6oLeeXzfk87Gq75rOs6X53g/IIXho08+IdodrrXEYNAxcDHNcSGQyIJuCCRpJAyG2kkuL3KauqHtGqQxZHmOCy1FmmKUYL/tmUzHPj55ruj7jr4L7PYd5WzGdr/HB0Pb7nC2J88MTd/xl//q57x8/ZLGB+ZnJevNijTNWM7mZEpyPg8Y84Yhpth2A8Fyu62oQyBL8+MzHZIko8g1797dMDszhNCSJwV15UkGTyGhKAvoPPVmT5IqtnXD2dmC+3UDQ8HXX36JVI40T8myjP1+IAZDM9R0iWYxLxj6wLqu0MqzmCzo+oF6tyX6yNB7Ej1l13Y8rC3WD8waQ5KkfLht6doeN0hQgWrb4PturBfyjuAVL96c8f59xQ/++FP61S1DSMhLiY4pXTuQzq6QPrBaP3C2LDl7eYXrYL/+gHl9SVXtKPP8sSdV27SQZJhMcTYtUYsFkzJw936LkJ7b95Zu6BFqjEfvraMwLbu9482Lyd/wXf+3H6nMCVFw8eqSutoyhB6EoukGfCaJiaZtGyZJzmx+yblKyfMMESP9pmK5PEPkGbt2w2+++g0vrwqEFbhgMYlmvVvRdhW263DBEdUY2z90jj44gpasth9Q2nF/f83/ubpnlk359NO/w35f0dieu3rHrz98hSpShDKklExiQW5yGj0+0KkHiNIQREBoS93dcXk2J9WSh807qnbDV/svcdIz2ICWBolmta+RqSaxNUkqMWnCrmpIM8OmqxlWLUoKur5Hak10GcZo0lweHvJ6YuzJ8oQYWjJjuFjmrO/ecdPUxBB58/pTLs7OOV+84GJxBSFQ1xuiDHwkNfbmA1bBVM6JUqIRmChRWuDsnl1dc90OTNMJqTbgHuiGhtzk+N5yPl+OdU1df4h1l5wtzjFBkEqFCJHLZYEMsFpvyOdTVBToMD6gr6Pjvtlzvd9Q2wEZIzkZA4GgNXmeEVyNlm5M0owSIRTeSSSBLDF03QDek6cJWkpkkCjrMCYlU4quc6RJSVNbnIWus6QpOGdB9SiV4/z4YF2olHqwdENLExom0TBREj9s2euOpt1SW0ua5BRJxu37a/ZVQzAanUikcHz04oI3yyWuHYgK6u2OfVNjXA2u5lUpcUCHYHb1mvPJGdt9zf/zs78iKzJ0YtBS0lcw2IgyEVCsti1JonDOIrRA+ZZtVYF3KFGikglDYhj6jqgSdlVLHiX7Yax1XNmaIi9+5/v0O1PO4pPQM/IXBdmBmEUxJjoOfqzheYp954lc8M3/jlrMoyAinj5+xGNYxxMfGvfn2zbL42fjYX3iiZSFxxXGx7E839bTfsTHnmWPbknxTTImxDG5Tz5L8IvPVD5/CL6QHGkH8UhiDhtnJBUQRyUpHuyOjImQknDY95FkxSN5E+PP4WA/lMc0xnioiDqQtXiw+x1NmuJAMo9d2L6ZNhkRwj8mQI77+mzMYiSkY4LhUdMbUyYfa+8ONPtIN5WOY6NJL3A+0vSef/HO8bM7xY9fJ/zgzJNqhT9cVEJEpHAHtfQYU3Ko9zooiPHx0MmRwcfDmJQbo/0PdWjEQAiBgOYpzTGOxBjGCxhJFKM9MR6EzUhAKUEhIp/MJOdZ5LqB/fBE6CPHVMyjcgjDofZOHsgxQoyk+Hj2IjQONt0hh/J4MX/7ycSj1Ht4PwqK5N8i+57w743cZKAkihQRBYO1rLb9WNuVzTi/fEFepDgUQ9vS1pY8S1mcz7m9vqMoSy6uzrjSL6jrnt71tL3jojwj7QYihhgGZuUSlznyxDCZT4gkBClpP3xgujxnv2558clbEhXwXvLVr99RZALXe7LpaANJg2b3sEMXiqqvyRNFFzzSWggwPzuj21i0SiiLjCg11W5PPpmx3TR87+Kc26+/ZLI4p64b+t7yclmgkgwdwbmEUht2NzvKi+V410lBPwz4tWO+LNn7FqFTksQQXE9SJGR9Blogek9UA84JCDmYiqruQGmqrkYKhTGGzbalFZL2/Q3r1Y4f/9HHo9JswO33lG8ukVXHrt5hVMJZKWj6hso6xNYRCQyDI2rItGRWTohDpJyesVk90PmUYjJlWc7xSM5fnnF/e0+eJkQkvutRItL2A3hB2+yZTaYU8zmSFVJqrm82XF5NqXctUkm6ekfvLA93jiIzMAtcvVzyV7+45aw0FNn4Dd5FWG97RHBIsUWZhPcffkPXt+SJBK+oq5a+H3C+4fzlktWHGzBjTZkGkrRkta542OwYup4kHSdmJjNgBRbY1jUvL85YrTtqZ0m8JohA6C2vPz0nV5ooNE3rKZZTJJHvX1ywXVWczS+o9jXe9vRu4MXVOft95Hq7IdWRqBOu393x9X3DchI515pEFXz19Rqi4+XlgvlijtGGat8hVQVScb1rQUVUyElzQ1lmbJue7UPLerUlhjlnF+fUJ+Xs946JWRJNitY5XtzhVY9JUur4QO8C/dDiraXMHLaXlNMXxKZju96go2PtOkhmhAiX+SvyScHZcs4vf/lzVps7gvC8q27phh7Va6bljFQoaOH1q9cQxwbSZ2cXfPzyDfVqz+5hxT/5v/45XYiURU5eJPzJ974HRcK63VGta97MP6ZMcoal5aFf8/n114TgkUGQCE0UkW21R8rIdLKgqjfkaBITyfIcOwhC9Bip0Frhu55JNsUHxZuXnzCfLrm5/cAwVPTB4k3GpJihupqpKZF6XH6IPVW3ZSNbVs6irWC33xJakD6Qpxm/+uUvCJ94ri4uMYnEhZFEDW6gnJYshgn329U4X9YJ3nm0HB8sex/o/IBOU+q+B6lhcEzKCaKF2WRJIVNkplimkOQG5zt6u6P1kcKUTJIZeT4hSwSFCqQk+K6mGixdkDwMHSvr8EKTakVQ0IQOnR78UUNHXip0Log2IY1TFvmUWV4yXZSs2x0/+flfErEoKfj4oze8On+NEeB9jxeO99fX3G1XSJPQtA3OR4QHKTNSocEr3OBI0gStFK4bFdE6DrQE+sRj65bddsDsDIv0DJlMqOvAJL3gR59c4pUgTVPmeUEeYag+8LC6xs89za5iff+eGC1JJtFpxtnZGbOLC0xRoKPmcrHAvXzJX91/YDf0DM4yTXNmkyXr7Y62OTz0R+KcxAfH4A6E0oMyFhlbfDcQgqDvPIvFlH3T4oOgzEoyk6D17061vpso/aPqxTjBTCRk+mBJjIwR5T7iOEwzxbM55wEH0eXx5+f87fk8NYpDv7Rv/e64wDP33ziRPwpUhzflUeU7vj6qTs9I47PtHgneYzjIs8KzYxhGPEafx/BI2sRzsnUgAeM2DjP+x30+buGgsQjBGNRx/NjTERCPLC8cPiofyRMcQ0me9u+JNhzTD8ftC3GsXxvfe967DRGfkd4n8nbszfWY6nJc/BDxHx+P57HmKjwez3gYXjyQSiUi2kSsFDgX8WFsDP3Pvuz4i3fw/QvDj15IZqkjBPU0Pg9CRnzwBA9SyLHPjghPHQYe2xaMB0KMdBbBWKcYEGMz6xAJ3o/Wx0M9IEFwrPCLIT6RaCHH5MdD+uU0DeQG9jZy30oa63FHQh2fLIfhoMa6Q42aFCDk6B+PQR3aGXhSDV2Ij0T7qfrseM4PBzE+tTNQ8rsRvU/4N6NqG5SR9K1HmwRiwsev37LebdjvOs7nGSIovOvIEk1bNaR5Qd85losFq2rPT355za9+dcOPP7ukKARpmXPz4R1mXtKsa6x1zM7OWd3dsvPjF6k0Y2O1LBuJS5bPeLh+z09/dc3nv77jfFry9//+D/HecXW+ZNhVpIsJywX0ziGRxOB5+/I1VbVls294uF4zmU5pqh0iRLJUIWYlSggms5Sus8wXUwbb8fJqSQg9bhhtbc71DK6j73ucd2zXd0znC1KdsGpaqvsb/vInNZPZhLefXrK5vmH58i3RRYLrsPWOznqsNAha0kRx99UtWZkxmeUQwQhJ21im8znUjqtPL/ns40vWmw1dCHT1gCkj+5/vUUoTpWB7vSfVAaU0Poxe833TYoximkxY7zZ0dzVdvye6jE/fnuNiYKQwgeA81f0D9bZh9mIOUuK6Q4KgkRA7ludTwmB5eLfFGIUdelzwNFVNkJHEaGLIuLoUCAy/+Nk7tJrT9mteXpSEIVDvO5TWRO84KyY4AjYMzPKUsOtIU03nInoI9Fbig2Q9tNTvLefFguu7Gj0J2EaiB89qXXN1MaO4UKzudygEWXaONZYciUlhs+1RRvG6LBm849VZSTRzijQlxMBgQTJgfEdf9WTlBFc3rAfJfDal3vYYlfPLX94DkUwbTJKxLAtu6lvenAmUydl3DTIUeBTzeUJQhv2+5eosQUqNaztkUtA2jukkZb+viTrBdp5dVXF2PiWZ5OhckNBxCqD9/eP1RUJVRertHQwVJlEMfU/rG5IiwwbL4HrqQdENNdd3X6OYkiYTjNHkQkNbIdCcn11hQ89+u2YYan5+8yVZnpMlGS9fv+XNq4+YlVOcHaj2FU3bUhQFb16/pOsHktRw+f3vEd6+Zr3Z4CmwwVN3FWdX56RZSlat+M36V9RNRV1VTOclF7MlMURu725pugYd9Jh4mwis7xmcH5NLiTgHvW0QJAzWE4UcbYa9RagOQcTeNvhNxT/4/p9gjGTd7vjy/Xs2qxWLJOej5RItA0ZqvPDcbQ2briKalKTIWU4vKXTBUDesHx5IUok2kbrecZHMCT7wYXVPTA13uy37fhhDwQjE0JMkimgjQgmcCCilmE8n2MTjrUOisa3EBE2eTIhdjyBQ5ikvX73kvt6w2q+4vbsm2ntSkXJ19pLSZKTKMDQDJtUMKrB2NQ++xhqQSULsLTIGEqEwRuB8wAWPtIJZMWE5n/F6+Zqz6QXBCarQ8JNf/JTc5OAEk2TO3/3R36MwCa7t+eLL3/B+9YH7/RovHVkUGC2wFtq6ZjKd0iMR7UAuDMpF0hQIkZnJqANYJVg7h08EiIFlkWOV5936A/NyRpElxDAG2KRITBL49Re/obU7pMr4xc0OBkcmHWelwrkek+VMp+dEn7F5GIg0yOjReYkTEp3nSKsRviFLNGnSM7QtaZYjtUAIh7U9wiu0EgwhIhQYGXF9R3SjI04phRNjMrj1jhADqUh/5/v0O5nhHQmROShl6UFuskHQ+4g/OLSeE6lvTD55RsaeEalvrF/wGCzynDgRn6U4Hpd59gX/jXq4+LT8kZgd5rpPitkzYiMO9UIqPquvOqxbKnEITnzWwlg8be9oBxSHhR5Fj/iNvT8oOM9J5eH/jukfj/2yDqwwxENt2Ki68XhMj1t6bokUBy0rHiyBAinUQSka66wea9QEh3q00X55JETiWP90+PkYmi8PUmSI43LHisAYDgTpeOYOSY9CHFXIUf86Bp4YBVqBPSQXdg7+4oPjl7eCFwvBH79UvFlqgrMI6fDhUFen3OGAyVH9DGPj6XiskTuQnTE5Uo9jQhzsjQeFc2zSRgxyTHkMcVTSRBzrz45c+fG8jD1Zxn51kYl2pGVgPQg2/fgQ4uhWjYBnrHdUh+MrBQgRcFEQpRuPnwclRvukP1yc8RDOcjzN4UnefdQgvTj5Gn/fqLfD6OcnohJLKlOa1tE2A0ob9nWFrxrc0DCbzdBasF7vMIlBOE9hUvQ04T/9hz+A0NF2Lcp0XMxyNrsHjJGcn53hhp4XL84IQZMVBdtqjbCSyXRGnERQkQ8fHri8mPCjH7zBJIbdeo+WivvrNZevL7hf1SyLjMVM0iU924cN+92Wttrz+vKKSOT9uxXKZBSZxmiNFD2myJlYhfQVeWmIwtB3NYmKCC0Bz2bfjjWhaiBVydg8treYRKKE4GyRk2Wajz/9CDOdcvvuloebD5RmfOhQlBNss6fd7mmHAWjHHkBBYDtNqgE/kE9yHm72Y0x86hDRM0sEZ5dn7Pc9iYa6beg6S2giy7MpbVMTVIrxNdP5EiEEXWUJCTSdQEvHYrLkF1/eMLkTTKeGTW25mBfsNi2TF3OkFNze70i0RktY7yyziwntqqFEUNUDu22P1APOBfpOMiSK+SInS3Oubxva1pPohsu3Z+RlioiOru1Znl3yoXlHqTTF5JJ290BqEn75bof+6p6LszmXL6Z0vSMtJizPl+TnM4LrCXu4ePmGn/zf/4TarWhoeHE+4c3bz0gc7PZr3v74DeuHmsmiIISBRV4yDBPatqWYLWhrR5ZF9rsdsWuplaLbt+Bb5tMSLSzkCW27w+hAFLDbVVS1x4WKs1cZyo/fZkVa8O7La5rG0dQN+3jPcp5ydq6ZlQ4TFbv7W5JUcX03kCaGprcsM4OQEuc9iRG8fHtBte7wQ0W7XxEqz6YZ6MyWfef+v2/KE74DrAhCsaofGKiQMkEJM9q2nUMqQ15oXIx0vUcpzb59INMdhpKHakuiDMEKvtp+TvSOSZlSlAsW6gKlJVoKZGj44lf/muCgahr6oSdE+OGPf8Sf/d0/Y3Wzh6jZbnuCt6ikwAvLhw/v2Oy2VN2W//jP/pz1wzu0GrjZ/Ib5dM6f/9GPSXTGD/0PePfhPT/95c/YDzXeemSaIpIUh8Mkiq4ZwAJKoI3C2whC4qwjSokVER87FMAg+cvf/Jr//B/+I94Un/LRR5/yT//p/4GyHvxADBYhFdJ5LtOCs3LGyvb0g8d4WMxKLIGJPuNuvWK3usWonDAMWNvhtcGnCTYxEDJ2mzVlmY+OLqdwh2bQwRq0NlSbhjJPydIUPwgMBbnWdF2PxHPX7DAy4frzPW3f0tqWIVjKbAIxYdvusG1NGhWu97TBU/kGNSsolaQaevCexOQ436GNAWPwLuC8Qieaq9kLZN8R6j2//HBN6xU3q3t8cBAhiTl//NnfI3EFfVfxxee/YQgdRmvysqBpd9imJk8MwSu0ghAcpcmYlVP26zVpkmCBqAyBMe4+aDWWRWUJSR6oYsf9tqVMCrrY45uOh/v7sYVHuOJ2+8BmqHhoKpJUksgcGPv7FjLj7ZuPsSHw0LcIb0nLKfcPa/arLfu2ZQCCkKRpRhwstW9RpSA1CYOLTJUm1wmDTumGniANKpN4NfY1S5IUrRS+82PpQDyEziWapu/p+989rfE76XN2wgknnHDCCSeccMIJJ5xwwr8f5L/9IyeccMIJJ5xwwgknnHDCCSf8vnEiZyeccMIJJ5xwwgknnHDCCX8AOJGzE0444YQTTjjhhBNOOOGEPwCcyNkJJ5xwwgknnHDCCSeccMIfAE7k7IQTTjjhhBNOOOGEE0444Q8AJ3J2wgknnHDCCSeccMIJJ5zwB4ATOTvhhBNOOOGEE0444YQTTvgDwImcnXDCCSeccMIJJ5xwwgkn/AHgRM5OOOGEE0444YQTTjjhhBP+APD/AracbddtoUeEAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ], + "source": [ + "plt.clf()\n", + "fig = plt.figure()\n", + "plt.subplots_adjust(\n", + " left=0.1,\n", + " bottom=0.1,\n", + " right=math.sqrt(2),\n", + " top=math.sqrt(3),\n", + " wspace=0.4,\n", + " hspace=0.4,\n", + ")\n", + "\n", + "N_SAMPLE = len(InferenceDataset)\n", + "SELECTED_SAMPLE = [\n", + " random.randint(0, N_SAMPLE - 1) for _ in range(INFERENCE_SAMPLE)\n", + "]\n", + "\n", + "for index, sample_idx in enumerate(SELECTED_SAMPLE):\n", + " image = InferenceDataset.inference_data(sample_idx)\n", + " image = image.to(\n", + " \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " ).unsqueeze(0)\n", + "\n", + " caption = model.captionize(image)\n", + " image = np.array(InferenceDataset.raw_image(sample_idx))\n", + "\n", + " title = [\n", + " f\"{caption[(cline * MAX_CHAR):((cline + 1) * MAX_CHAR)]}\\n\"\n", + " for cline in range(math.ceil(len(caption) / MAX_CHAR))\n", + " ]\n", + " title = \"\".join(title)\n", + "\n", + " ax = fig.add_subplot(\n", + " int(math.sqrt(INFERENCE_SAMPLE)),\n", + " int(math.sqrt(INFERENCE_SAMPLE)),\n", + " index + 1,\n", + " )\n", + " ax.imshow(image.copy().astype(np.uint8))\n", + " ax.set_title(title, fontsize=8)\n", + " ax.set_axis_off()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ThAE1zfB-EbP" + }, + "outputs": [], + "source": [ + "INPUT_URL = \"https://static.wikia.nocookie.net/near-pure-good-hero/images/1/12/Yukino.png\" # @param {type:\"string\"}\n", + "\n", + "\n", + "def show_result():\n", + " image_raw = cv2.cvtColor(\n", + " cv2.imdecode(\n", + " np.asarray(\n", + " bytearray(urllib.urlopen(INPUT_URL).read()),\n", + " dtype=np.uint8,\n", + " ),\n", + " -1,\n", + " ),\n", + " cv2.COLOR_BGR2RGB,\n", + " )\n", + "\n", + " image = (\n", + " TRANSFORM(\n", + " Image.fromarray(\n", + " image_raw.copy(),\n", + " \"RGB\",\n", + " )\n", + " )\n", + " .to(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + " .unsqueeze(0)\n", + " )\n", + "\n", + " caption = model.captionize(image)\n", + "\n", + " title = [\n", + " f\"{caption[(cline * MAX_CHAR):((cline + 1) * MAX_CHAR)]}\\n\"\n", + " for cline in range(math.ceil(len(caption) / MAX_CHAR))\n", + " ]\n", + " title = \"\".join(title)\n", + " plt.figure()\n", + " plt.imshow(image_raw.copy())\n", + " plt.title(title)\n", + " plt.axis(\"off\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iTbOT9RS-Ft2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 416 + }, + "outputId": "39361b95-637a-45f4-ecfb-1cd727b256b6" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "show_result()" + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "E-eJSUhi513i" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip install flask flask-ngrok" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LlHFFn055w36", + "outputId": "b3dfbfd8-549b-4010-e995-3d035b9e88e0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: flask in /usr/local/lib/python3.10/dist-packages (2.2.5)\n", + "Collecting flask-ngrok\n", + " Downloading flask_ngrok-0.0.25-py3-none-any.whl (3.1 kB)\n", + "Requirement already satisfied: Werkzeug>=2.2.2 in /usr/local/lib/python3.10/dist-packages (from flask) (3.0.3)\n", + "Requirement already satisfied: Jinja2>=3.0 in /usr/local/lib/python3.10/dist-packages (from flask) (3.1.4)\n", + "Requirement already satisfied: itsdangerous>=2.0 in /usr/local/lib/python3.10/dist-packages (from flask) (2.2.0)\n", + "Requirement already satisfied: click>=8.0 in /usr/local/lib/python3.10/dist-packages (from flask) (8.1.7)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from flask-ngrok) (2.31.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from Jinja2>=3.0->flask) (2.1.5)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->flask-ngrok) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->flask-ngrok) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->flask-ngrok) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->flask-ngrok) (2024.6.2)\n", + "Installing collected packages: flask-ngrok\n", + "Successfully installed flask-ngrok-0.0.25\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n", + "!unzip ngrok-stable-linux-amd64.zip" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qj1g-9UDp--E", + "outputId": "39bd1c8e-c19f-4782-ca7e-ea46273a4a80" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2024-06-25 18:28:30-- https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n", + "Resolving bin.equinox.io (bin.equinox.io)... 54.161.241.46, 54.237.133.81, 18.205.222.128, ...\n", + "Connecting to bin.equinox.io (bin.equinox.io)|54.161.241.46|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 13921656 (13M) [application/octet-stream]\n", + "Saving to: ‘ngrok-stable-linux-amd64.zip’\n", + "\n", + "ngrok-stable-linux- 100%[===================>] 13.28M 17.0MB/s in 0.8s \n", + "\n", + "2024-06-25 18:28:31 (17.0 MB/s) - ‘ngrok-stable-linux-amd64.zip’ saved [13921656/13921656]\n", + "\n", + "Archive: ngrok-stable-linux-amd64.zip\n", + " inflating: ngrok \n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Run ngrok to tunnel port 5001\n", + "get_ipython().system_raw('./ngrok http 5001 &')\n", + "\n" + ], + "metadata": { + "id": "heIHwg-5pqmQ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import time\n", + "time.sleep(5) # Allow ngrok to setup the tunnel\n", + "\n", + "# Print the ngrok URL\n", + "!curl -s http://localhost:4040/api/tunnels | python3 -c \\\n", + " \"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])\"\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZmIzyFCLqNdi", + "outputId": "c8014c4e-8bd2-44c2-ffb3-6b2121fabee0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Traceback (most recent call last):\n", + " File \"\", line 1, in \n", + " File \"/usr/lib/python3.10/json/__init__.py\", line 293, in load\n", + " return loads(fp.read(),\n", + " File \"/usr/lib/python3.10/json/__init__.py\", line 346, in loads\n", + " return _default_decoder.decode(s)\n", + " File \"/usr/lib/python3.10/json/decoder.py\", line 337, in decode\n", + " obj, end = self.raw_decode(s, idx=_w(s, 0).end())\n", + " File \"/usr/lib/python3.10/json/decoder.py\", line 355, in raw_decode\n", + " raise JSONDecodeError(\"Expecting value\", s, err.value) from None\n", + "json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "import cv2\n", + "import numpy as np\n", + "import torch\n", + "import urllib\n", + "import math\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "from flask import Flask, request, jsonify\n", + "\n", + "# Replace these with your actual imports and model loading code\n", + "# from your_model_file import MODEL, Flickr8KDataset, TRANSFORM\n", + "\n", + "app = Flask(__name__)\n", + "\n", + "# Load your model\n", + "LAST_MODEL_PATH = '/content/drive/MyDrive/ImageCaptioning_best.ckpt'\n", + "model = MODEL.load_from_checkpoint(LAST_MODEL_PATH)\n", + "model.eval()\n", + "\n", + "MAX_CHAR = 50\n", + "\n", + "@app.route('/caption', methods=['POST'])\n", + "def caption_image():\n", + " print(\"ENTERED\")\n", + " file = request.files['image']\n", + " if not file:\n", + " return jsonify({\"error\": \"No file provided\"}), 400\n", + "\n", + " image_raw = cv2.cvtColor(\n", + " cv2.imdecode(\n", + " np.frombuffer(file.read(), np.uint8),\n", + " cv2.IMREAD_COLOR,\n", + " ),\n", + " cv2.COLOR_BGR2RGB,\n", + " )\n", + "\n", + " image = (\n", + " TRANSFORM(\n", + " Image.fromarray(\n", + " image_raw.copy(),\n", + " \"RGB\",\n", + " )\n", + " )\n", + " .to(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + " .unsqueeze(0)\n", + " )\n", + "\n", + " caption = model.captionize(image)\n", + "\n", + " title = [\n", + " f\"{caption[(cline * MAX_CHAR):((cline + 1) * MAX_CHAR)]}\\n\"\n", + " for cline in range(math.ceil(len(caption) / MAX_CHAR))\n", + " ]\n", + " title = \"\".join(title)\n", + "\n", + " plt.figure()\n", + " plt.imshow(image_raw.copy())\n", + " plt.title(title)\n", + " plt.axis(\"off\")\n", + " plt.savefig('result.png')\n", + "\n", + " return jsonify({\"caption\": caption})\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " app.run(host='0.0.0.0', port=5001)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BKGzuxYL5ruG", + "outputId": "4c4ea733-4809-4837-ca31-90533b045ca5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " * Serving Flask app '__main__'\n", + " * Debug mode: off\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "INFO:werkzeug:\u001b[31m\u001b[1mWARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.\u001b[0m\n", + " * Running on all addresses (0.0.0.0)\n", + " * Running on http://127.0.0.1:5001\n", + " * Running on http://172.28.0.12:5001\n", + "INFO:werkzeug:\u001b[33mPress CTRL+C to quit\u001b[0m\n" + ] + } + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/Backend/imageApi.py b/Backend/imageApi.py new file mode 100644 index 0000000..1848bf0 --- /dev/null +++ b/Backend/imageApi.py @@ -0,0 +1,1974 @@ +try: + import lightning as L +except: + import lightning as L + +from lightning.pytorch import Trainer, seed_everything +from lightning.pytorch.callbacks import ModelCheckpoint + +import re +import os +import cv2 +import copy +import math +import random +import warnings +import collections + +import numpy as np +from PIL import Image +from flask import Flask, request, jsonify + +import numpy as np +import matplotlib.pyplot as plt + +import urllib.request as urllib + +from PIL import Image +# from google.colab.patches import cv2_imshow + +import torch +import torchvision +import torch.nn as nn +import torch.optim as optim +import torch.utils.data as data +import torch.nn.functional as F + +from torchmetrics.text import ROUGEScore + +from torch.nn.utils.rnn import pad_sequence +from torchvision.transforms.v2 import ( + Compose, + Resize, + ToTensor, + Normalize, + RandomHorizontalFlip, + RandomAffine, + RandomAutocontrast +) + +try: + from torchvision.transforms.v2 import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + +from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights +from torchvision.datasets.utils import download_and_extract_archive + +import spacy +spacy = spacy.load("en_core_web_sm") + +warnings.filterwarnings("ignore") + +# %matplotlib inline +plt.rcParams['axes.facecolor'] = 'lightgray' +plt.rcParams['mathtext.fontset'] = 'cm' +plt.rcParams['font.family'] = 'STIXGeneral' + + + +os.makedirs("experiment", exist_ok=True) +os.makedirs("experiment/training", exist_ok=True) +os.makedirs("experiment/dataset", exist_ok=True) +os.makedirs("experiment/model", exist_ok=True) +EXPERIMENT_DIR = "experiment/" + +ANNOTATION_PATH = "experiment/dataset/Flickr8k.token.txt" +IMAGE_PATH = "experiment/dataset/Flicker8k_Dataset" + + +METRIC_TO_MONITOR = "val_loss" +METRIC_MODE = "min" + +SEED = int(np.random.randint(2147483647)) +print(f"Random seed: {SEED}") + + +START_TOKEN = "" +END_TOKEN = "" +PAD_TOKEN = "" +OOV_TOKEN = "" + +MAX_SEQUENCE = 30 +IMAGE_SIZE = 300 + +TEMPERATURE = 0.1 +TOP_P = 0.9 + +NUM_HEAD = 32 +NUM_KV_HEAD = 8 +NUM_LAYER = 1 +EMBED_DIM = 640 +HEAD_DIM = EMBED_DIM // NUM_HEAD +ROPE_BASE = 10000 +MLP_SCALE = 3.5 +DROPOUT = math.sin(math.sqrt(math.e * math.pi)) +EPS_NORM = 1e-5 + + +MAX_EPOCH = 36 +BATCH_SIZE = 128 +LEARNING_RATE = 3.1e-4 +REDUCE_LR_FACTOR = 0.69 + + +MILESTONES = 1. / math.sqrt(MAX_EPOCH) * ( + np.array( + [m for m in range(1, int(math.sqrt(MAX_EPOCH)))] + ) +) + +DATASET_URL = { + "image" : ( + "https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip", + "Flickr8k_Dataset.zip", + ), + "text" : ( + "https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_text.zip", + "Flickr8k_text.zip", + ), +} + + +# for dat in DATASET_URL.values(): +# url, filename = dat +# download_and_extract_archive( +# url, +# "experiment/dataset", +# filename=filename, +# ) +# os.remove(os.path.join("experiment/dataset", filename)) + + +class ToRGB(object): + def __call__(self, image): + assert 'PIL' in str(type(image)), "Expected PIL Image" + return image.convert("RGB") + + +TRANSFORM = Compose( + [ + Resize((IMAGE_SIZE, IMAGE_SIZE), interpolation=BICUBIC), + ToRGB(), + ToTensor(), + Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ] +) + +TRANSFORM_AUGMENTATION = Compose( + [ + Resize((IMAGE_SIZE, IMAGE_SIZE), interpolation=BICUBIC), + ToRGB(), + ToTensor(), + Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + RandomHorizontalFlip(), + RandomAutocontrast(p=0.25), + RandomAffine( + degrees=22.5, + scale=(math.sqrt(0.5 * math.pi), math.sqrt(math.pi)), + shear=5., + ), + ] +) + + + +class Tokenizer(object): + def __init__(self, freq_threshold=1): + self.encoder = collections.defaultdict(lambda : 3) + self.encoder[END_TOKEN] = 2 + self.encoder[START_TOKEN] = 1 + self.encoder[PAD_TOKEN] = 0 + + self.freq_threshold = freq_threshold + + frequencies = dict() + idx = len(self.encoder) + + with open(ANNOTATION_PATH) as captions: + sentence_list = [ + line.rstrip("\n").split("\t")[-1].strip().lower() + for line in captions.readlines() + ] + + for sentence in sentence_list: + tokenized_sentence = [ + tok.text.lower() for tok in spacy.tokenizer(sentence.strip()) + ] + for word in tokenized_sentence: + if word not in frequencies: + frequencies[word] = 1 + else: + frequencies[word] += 1 + + if frequencies[word] == self.freq_threshold: + idx += 1 + self.encoder[word] = idx + + self.decoder = dict() + self.decoder[0] = PAD_TOKEN + self.decoder[1] = START_TOKEN + self.decoder[2] = END_TOKEN + self.decoder[3] = OOV_TOKEN + for k, v in self.encoder.items(): + if v not in self.decoder: + self.decoder[v] = k + + def __len__(self): + assert len(self.encoder) == len(self.decoder) + return len(self.encoder) + + def encode(self, text): + numericalized_token = list() + del_oov_token = False + + for token in spacy.tokenizer(text.strip()): + if token.text.lower() not in self.encoder: + del_oov_token = True + + numericalized_token.append(self.encoder[token.text.lower()]) + + if del_oov_token: + del self.encoder[token.text.lower()] + del_oov_token = False + + return numericalized_token + + def decode(self, tokens): + return " ".join([self.decoder[token] for token in tokens]) + + + +class AvgMeter(object): + def __init__(self): + self.reset() + + def reset(self): + self.scores = list() + + def update(self, val): + self.scores.append(val) + + def show(self): + scores = torch.stack(self.scores) + return torch.mean(scores) + + +Tokenizer = Tokenizer() +print(f"Vocab size: {len(Tokenizer.decoder)}") + +def tokenize(text): + sos_token = Tokenizer.encoder[START_TOKEN] + eos_token = Tokenizer.encoder[END_TOKEN] + tokens = [sos_token] + Tokenizer.encode(text) + [eos_token] + + result = torch.full( + (MAX_SEQUENCE,), + Tokenizer.encoder[PAD_TOKEN], + dtype=torch.long, + ) + + if len(tokens) > MAX_SEQUENCE: + tokens = tokens[:MAX_SEQUENCE] + tokens[-1] = eos_token + + result[:len(tokens)] = torch.tensor(tokens) + + return result.long() + + +class RMSNorm(nn.Module): + """ + Implements Root Mean Square Normalization introduced in + https://arxiv.org/pdf/1910.07467.pdf. + + Reference implementation (used for correctness verfication) + can be found here: + https://github.com/facebookresearch/llama/blob/main/llama/model.py + + Args: + dim (int): embedding size + eps (float): small value to avoid division by zero. Default: 1e-6 + """ + + def __init__(self, dim, eps=1e-6): + super().__init__() + self.eps = eps + self.scale = nn.Parameter(torch.ones(dim)) + + def forward(self, x): + return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.scale + + + + +class RotaryPositionalEmbedding(nn.Module): + """ + This class implements Rotary Positional Embedding (RoPE) + proposed in https://arxiv.org/abs/2104.09864. + + Reference implementation (used for correctness verfication) + can be found here: + https://github.com/facebookresearch/llama/blob/main/llama/model.py#L450 + + In this implementation we cache the embedding for each position upto + ``max_seq_len`` by computing this during init. + + Args: + dim (int): Embedding dimension. This is usually set to the dim of each + head in the attention module computed as ````embed_dim`` // ``num_heads```` + max_seq_len (int): Maximum expected sequence length for the + model, if exceeded the cached freqs will be recomputed + base (int): The base for the geometric progression used to compute + the rotation angles + """ + + def __init__( + self, + dim, + max_seq_len=4096, + base=10_000, + ): + super().__init__() + self.dim = dim + self.base = base + self.max_seq_len = max_seq_len + self._rope_init() + + def _rope_init(self): + theta = 1.0 / ( + self.base + ** (torch.arange(0, self.dim, 2)[: (self.dim // 2)].float() / self.dim) + ) + self.register_buffer( + "theta", + theta.to("cuda" if torch.cuda.is_available() else "cpu"), + persistent=False, + ) + self.build_rope_cache(self.max_seq_len) + + def build_rope_cache(self, max_seq_len = 4096): + # Create position indexes `[0, 1, ..., max_seq_len - 1]` + seq_idx = torch.arange( + max_seq_len, dtype=self.theta.dtype, device=self.theta.device + ) + + # Outer product of theta and position index; output tensor has + # a shape of [max_seq_len, dim // 2] + idx_theta = torch.einsum("i, j -> ij", seq_idx, self.theta).float() + + # cache includes both the cos and sin components and so the output shape is + # [max_seq_len, dim // 2, 2] + cache = torch.stack([torch.cos(idx_theta), torch.sin(idx_theta)], dim=-1) + self.register_buffer("cache", cache, persistent=False) + + def forward(self, x, input_pos=None): + """ + Args: + x (Tensor): input tensor with shape + [bsz, seq_len, num_heads, head_dim] + input_pos (Optional[Tensor]): Optional tensor which contains the position + of the current token. This is only used during inference. Default is None + + Returns: + Tensor: output tensor with RoPE applied + + Notation used for tensor shapes: + - b: batch size + - s: sequence length + - n_h: num heads + - h_d: head dim + + TODO: The implementation below can be made more efficient + for inference. + """ + # input tensor has shape [b, s, n_h, n_d] + seq_len = x.size(1) + + # extract the values based on whether input_pos is set or not. When + # input_pos is provided, we're in inference mode + rope_cache = ( + self.cache[:seq_len] if input_pos is None else self.cache[input_pos] + ) + + # reshape input; the last dimension is used for computing the output. + # Cast to float to match the reference implementation + # tensor has shape [b, s, n_h, n_d // 2, 2] + xshaped = x.float().reshape(*x.shape[:-1], -1, 2) + + # reshape the cache for broadcasting + # tensor has shape [1, s, 1, n_d // 2, 2] + rope_cache = rope_cache.view(1, xshaped.size(1), 1, xshaped.size(3), 2) + + # tensor has shape [b, s, n_h, n_d // 2, 2] + x_out = torch.stack( + [ + xshaped[..., 0] * rope_cache[..., 0] + - xshaped[..., 1] * rope_cache[..., 1], + xshaped[..., 1] * rope_cache[..., 0] + + xshaped[..., 0] * rope_cache[..., 1], + ], + -1, + ) + + # tensor has shape [b, s, n_h, n_d] + x_out = x_out.flatten(3) + return x_out.type_as(x) + + + + +class KVCache(nn.Module): + """ + Standalone nn.Module containing a kv-cache to cache past key and values + during inference. + + Args: + max_batch_size (int): maximum batch size model will be run with + max_seq_len (int): maximum sequence length model will be run with + num_heads (int): number of heads. We take num_heads instead of + num_kv_heads because the cache is created after we've expanded the + key and value tensors to have the same shape as the query tensor. + See CausalAttention for more details + head_dim (int): per-attention head embedding dimension + dtype (torch.dtype): dtype for the caches + """ + + def __init__( + self, + max_batch_size, + max_seq_len, + num_heads, + head_dim, + dtype=torch.float32, + ): + super().__init__() + cache_shape = (max_batch_size, num_heads, max_seq_len, head_dim) + self.register_buffer( + "k_cache", + torch.zeros( + cache_shape, + dtype=dtype, + device="cuda" if torch.cuda.is_available() else "cpu" + ), + persistent=False, + ) + self.register_buffer( + "v_cache", + torch.zeros( + cache_shape, + dtype=dtype, + device="cuda" if torch.cuda.is_available() else "cpu" + ), + persistent=False, + ) + self.max_batch_size = max_batch_size + + def update(self, input_pos, k_val, v_val): + # input_pos: [S], k_val: [B, H, S, D] + assert input_pos.shape[0] == k_val.shape[2] + + k_out = self.k_cache + v_out = self.v_cache + k_out[:, :, input_pos] = k_val + v_out[:, :, input_pos] = v_val + + return k_out, v_out + + + + +class CausalSelfAttention(nn.Module): + """Multi-headed grouped query self-attention (GQA) layer introduced + in https://arxiv.org/pdf/2305.13245v1.pdf. + + GQA is a version of multiheaded attention (MHA) which uses fewer + key/value heads than query heads by grouping n query heads for each + key and value head. Multi-Query Attention is an extreme + version where we have a single key and value head shared by all + query heads. + + Following is an example of MHA, GQA and MQA with num_heads = 4 + + (credit for the documentation: + https://github.com/Lightning-AI/lit-gpt/blob/main/lit_gpt/config.py). + + + :: + + ┌───┐┌───┐┌───┐┌───┐ ┌───┐ ┌───┐ ┌───┐ + │ v ││ v ││ v ││ v │ │ v │ │ v │ │ v │ + └───┘└───┘└───┘└───┘ └───┘ └───┘ └───┘ + │ │ │ │ │ │ │ + ┌───┐┌───┐┌───┐┌───┐ ┌───┐ ┌───┐ ┌───┐ + │ k ││ k ││ k ││ k │ │ k │ │ k │ │ k │ + └───┘└───┘└───┘└───┘ └───┘ └───┘ └───┘ + │ │ │ │ ┌──┴──┐ ┌──┴──┐ ┌────┬──┴─┬────┐ + ┌───┐┌───┐┌───┐┌───┐ ┌───┐┌───┐┌───┐┌───┐ ┌───┐┌───┐┌───┐┌───┐ + │ q ││ q ││ q ││ q │ │ q ││ q ││ q ││ q │ │ q ││ q ││ q ││ q │ + └───┘└───┘└───┘└───┘ └───┘└───┘└───┘└───┘ └───┘└───┘└───┘└───┘ + ◀──────────────────▶ ◀──────────────────▶ ◀──────────────────▶ + MHA GQA MQA + n_kv_heads =4 n_kv_heads=2 n_kv_heads=1 + + Args: + embed_dim (int): embedding dimension for the model + num_heads (int): number of query heads. For MHA this is also the + number of heads for key and value + num_kv_heads (int): number of key and value heads. If specified, + user should ensure `num_heads` % `num_kv_heads` == 0. Default value is + `None`, in which case this is the same as MHA + head_dim (int): dimension of each head, calculated by ``embed_dim`` // ``num_heads``. + q_proj (nn.Module): projection layer for query. + k_proj (nn.Module): projection layer for key. + v_proj (nn.Module): projection layer for value. + output_proj (nn.Module): projection layer for output. + pos_embeddings (nn.Module): positional embeddings layer, e.g. RotaryPositionalEmbeddings. + kv_cache (Optional[KVCache]): KVCache object used to cache key and value. + If not specified, then no caching is used. + max_seq_len (int): maximum sequence length supported by the model. + This is needed to compute the RoPE Cache. Default: 4096. + attn_dropout (float): dropout value passed onto the + scaled_dot_product_attention function. This argument is ignored if the + self.training is False. Default value is 0.0. + + Raises: + ValueError: If `num_heads` % `num_kv_heads` != 0 + ValueError: If `embed_dim` % `num_heads` != 0 + ValueError: If `attn_dropout` < 0 or > 1 + """ + + def __init__( + self, + embed_dim, + num_heads, + num_kv_heads, + head_dim, + q_proj, + k_proj, + v_proj, + output_proj, + pos_embeddings, + kv_cache=None, + max_seq_len=4096, + attn_dropout=0.0, + ): + super().__init__() + if num_heads % num_kv_heads != 0: + raise ValueError( + f"num_heads ({num_heads}) must be divisible by " + f"num_kv_heads ({num_kv_heads})" + ) + + if embed_dim % num_heads != 0: + raise ValueError( + f"embed_dim ({embed_dim}) must be divisible by " + f"num_heads ({num_heads})" + ) + + if attn_dropout < 0 or attn_dropout > 1: + raise ValueError(f"attn_dropout ({embed_dim}) must be between 0.0 and 1.0") + + # Set attributes + self.num_heads = num_heads + self.num_kv_heads = num_kv_heads + self.embed_dim = embed_dim + self.attn_dropout = attn_dropout + self.head_dim = head_dim + self.max_seq_len = max_seq_len + + # Set layers + self.kv_cache = kv_cache + self.q_proj = q_proj + self.k_proj = k_proj + self.v_proj = v_proj + self.output_proj = output_proj + self.pos_embeddings = pos_embeddings + + def forward(self, x, y=None, mask=None, input_pos=None): + """ + Args: + x (Tensor): input tensor with shape + [batch_size x seq_length x embed_dim] + y (Optional[Tensor]): input tensor with shape + [batch_size x 1 x embed_dim] + mask (Optional[Tensor]): Optional tensor which contains the mask. + Only used during inference. Default is None. + input_pos (Optional[Tensor]): Optional tensor which contains the position + of the current token. This is only used during inference. Default is None + + Returns: + Tensor: output tensor with attention applied + + Raises: + ValueError: if seq_len of x is bigger than max_seq_len + + Notation used for tensor shapes: + - b: batch size + - s: sequence length + - n_h: num heads + - n_kv: num kv heads + - d: embed dim + - h_d: head dim + + TODO: + - Return the attention weights + - Make application of positional embeddings optional + """ + # input has shape [b, s, d] + bsz, seq_len, _ = x.shape + + if seq_len > self.max_seq_len: + raise ValueError( + f"seq_len ({seq_len}) of input tensor should be smaller " + f"than max_seq_len ({self.max_seq_len})" + ) + + if y is None: + y = x + + kv_seq_len = y.shape[1] + + # q has shape [b, s, num_heads * head_dim] + # k has shape [b, s or 1, num_kv_heads * head_dim] + # v has shape [b, s or 1, num_kv_heads * head_dim] + q = self.q_proj(x) + k = self.k_proj(y) + v = self.v_proj(y) + + # number of queries per key/value + q_per_kv = self.num_heads // self.num_kv_heads + + # q: [b, s, n_kv, q_per_kv, h_d] + # k: [b, s or 1, n_kv, 1, h_d] + # v: [b, s or 1, n_kv, 1, h_d] + q = q.view(bsz, seq_len, self.num_kv_heads, q_per_kv, self.head_dim) + k = k.view(bsz, kv_seq_len, self.num_kv_heads, 1, self.head_dim) + v = v.view(bsz, kv_seq_len, self.num_kv_heads, 1, self.head_dim) + + # if needed, expand the key and value tensors to have the same shape + # as the query tensor by copying values across the relevant dim + if self.num_heads != self.num_kv_heads: + k = k.expand(bsz, kv_seq_len, self.num_kv_heads, q_per_kv, self.head_dim) + v = v.expand(bsz, kv_seq_len, self.num_kv_heads, q_per_kv, self.head_dim) + + # llama2 applies the RoPE embeddings on tensors with shape + # [b, s or 1, n_h, h_d] + # Reshape the tensors before we apply RoPE + q = q.reshape(bsz, seq_len, -1, self.head_dim) + k = k.reshape(bsz, kv_seq_len, -1, self.head_dim) + v = v.reshape(bsz, kv_seq_len, -1, self.head_dim) + + # Apply positional embeddings + q = self.pos_embeddings(q, input_pos) + k = self.pos_embeddings(k, input_pos) + + # [b, n_h, s or 1, h_d] + q = q.transpose(1, 2) + k = k.transpose(1, 2) + v = v.transpose(1, 2) + + # Update key-value cache + if self.kv_cache is not None: + k, v = self.kv_cache.update(input_pos, k, v) + + # Flash attention from https://pytorch.org/blog/accelerating-large-language-models/ + output = nn.functional.scaled_dot_product_attention( + q, + k, + v, + attn_mask=mask, + dropout_p=self.attn_dropout, + is_causal=self.kv_cache is None, + ) + + # reshape the output to be the same shape as the input + output = output.transpose(1, 2).contiguous().view(bsz, seq_len, -1) + return self.output_proj(output) + + + + + +def _get_clones(module, n): + """ + Return a list of ``n`` identical layers. + + Args: + module (nn.Module): module to be cloned + n (int): number of clones + + Returns: + nn.ModuleList: list of ``n`` identical layers + """ + # FIXME: copy.deepcopy() is not defined on nn.module + return nn.ModuleList([copy.deepcopy(module) for i in range(n)]) + + + +class Flickr8KDataset(data.Dataset): + def __init__(self, split): + assert split in ["train", "val", "test", "inference"] + + self.images = list() + self.captions = list() + + with open(ANNOTATION_PATH) as caption_file: + for line in caption_file.readlines(): + # Image name and captions are separated using a tab + img_name, caption = line.rstrip("\n").split("\t") + + # Each image is repeated five times for the five different + # captions. Each image name has a suffix `#(caption_number)` + img_name = img_name.split("#")[0] + img_name = os.path.join(IMAGE_PATH, img_name.strip()) + + caption = caption.strip() + + # We will remove captions that are either too short or too long + tokens = [tok.text.lower() for tok in spacy.tokenizer(caption)] + + if img_name.endswith("jpg"): + self.images.append(img_name) + self.captions.append(caption) + + # Limit the number of images and captions to 2000 + # if len(self.images) > 6000: + # self.images = self.images[:6000] + # self.captions = self.captions[:] + + random.seed(SEED) + random.shuffle(self.images) + + random.seed(SEED) + random.shuffle(self.captions) + + n_data = len(self.images) + + if split == "train": + self.transform = TRANSFORM_AUGMENTATION + start = 0 + end = int(0.8 * n_data) + else: + self.transform = TRANSFORM + if split == "val": + start = int(0.8 * n_data) + end = int(0.9 * n_data) + else: + start = int(0.9 * n_data) + end = n_data + + self.images = self.images[start:end] + self.captions = self.captions[start:end] + + self.split = split + + def raw_image(self, index): + assert self.split == "inference" + return Image.open(self.images[index]).convert("RGB") + + def inference_data(self, index): + assert self.split == "inference" + image = self.transform(Image.open(self.images[index])) + return image + + def __len__(self): + assert len(self.images) == len(self.captions) + return len(self.images) + + def __getitem__(self, index): + image = self.transform(Image.open(self.images[index])) + caption = tokenize(self.captions[index]) + return image, caption + + + +TrainDataset = Flickr8KDataset('train') +ValDataset = Flickr8KDataset('val') +TestDataset = Flickr8KDataset('test') + +class TransformerEncoderLayer(nn.Module): + """Transformer layer derived from the Llama2 model. Normalization is applied + before the attention **and** FF layer. + + Args: + attn (CausalSelfAttention): Attention module. + mlp (nn.Module): Feed-forward module. + sa_norm_x (nn.Module): Normalization to be applied before self-attention. + mlp_norm (nn.Module): Normalization to be applied before the feed-forward layer. + """ + + def __init__(self, attn, mlp, sa_norm, mlp_norm): + super().__init__() + self.sa_norm = sa_norm + self.attn = attn + self.mlp_norm = mlp_norm + self.mlp = mlp + + def forward(self, x, mask=None, input_pos=None): + """ + Args: + x (Tensor): input tensor with shape + [batch_size x 1 x embed_dim] + mask (Optional[Tensor]): Optional tensor which contains the mask. + Only used during inference. Default is None. + input_pos (Optional[Tensor]): Optional tensor which contains the position + of the current token. This is only used during inference. Default is None + + Returns: + Tensor: output tensor with same shape as input + [batch_size x 1 x embed_dim] + + Notation used for tensor shapes: + - b: batch size + - d: embed dim + + TODO: + - Make position of norm configurable + """ + # Input tensor and attention output have the same shape + # [b, 1, d] + # Norm applied before self-attention + attn_out = self.attn(self.sa_norm(x), mask=mask, input_pos=input_pos) + + # Residual connection; shape: [b, 1, d] + h = attn_out + x + + # Norm applied before the feedforward layer + mlp_out = self.mlp(self.mlp_norm(h)) + + # Residual connection; shape: [b, 1, d] + out = h + mlp_out + return out + + + + +class TransformerEncoder(nn.Module): + """ + Transformer Encoder derived from the Llama2 architecture. + + Args: + feature_extractor (nn.Module): Image feature extractor. + layer (TransformerEncoderLayer): Transformer Encoder layer. + num_layers (int): Number of Transformer Encoder layers. + max_seq_len (int): maximum sequence length the model will be run with, as used + by KVCache + num_heads (int): number of query heads. For MHA this is also the + number of heads for key and value. This is used to setup the + KVCache + head_dim (int): embedding dimension for each head in self-attention. This is used + to setup the KVCache + norm (nn.Module): Callable that applies normalization to the output of the encoder. + + Note: + Arg values are checked for correctness (eg: ``attn_dropout`` belongs to [0,1]) + in the module where they are used. This helps reduces the number of raise + statements in code and improves readability. + """ + + def __init__( + self, + feature_extractor, + layer, + num_layers, + max_seq_len, + num_heads, + head_dim, + norm, + ): + super().__init__() + + self.feature_extractor = feature_extractor + self.layers = _get_clones(layer, num_layers) + self.norm = norm + self.max_seq_len = max_seq_len + self.num_heads = num_heads + self.head_dim = head_dim + self.causal_mask = None + + def setup_caches(self, max_batch_size, dtype=torch.float32): + # inference only + for layer in self.layers: + layer.attn.kv_cache = KVCache( + max_batch_size=max_batch_size, + max_seq_len=self.max_seq_len, + num_heads=self.num_heads, + head_dim=self.head_dim, + dtype=dtype, + ) + + # causal_mask is used during inference to ensure we're attending + # to the right tokens + self.causal_mask = torch.tril( + torch.ones( + self.max_seq_len, + self.max_seq_len, + dtype=torch.bool, + device="cuda" if torch.cuda.is_available() else "cpu" + ) + ) + + def clear_caches(self): + for layer in self.layers: + layer.attn.kv_cache = None + self.causal_mask = None + + def forward(self, image, input_pos=None): + """ + Args: + image (Tensor): input tensor with shape [b x c x h x w] + input_pos (Optional[Tensor]): Optional tensor which contains the position + of the current token. This is only used during inference. Default is None + + Note: At the very first step of inference, when the model is provided with a prompt, + ``input_pos`` would contain the positions of all of the tokens in the prompt + (eg: ``torch.arange(prompt_length)``). This is because we will need to compute the + KV values for each position. + + Returns: + Tensor: output tensor with shape [b x 1 x d] + + Raises: + ValueError: if causal_mask is set but input_pos is None + + Notation used for tensor shapes: + - b: batch size + - c: channel + - h: height + - w: width + - v: vocab size + - d: embed dim + - m_s: max seq len + """ + # input tensor of shape [b, c, h, w] + bsz = image.shape[0] + + # shape: [b, 1, d] + h = self.feature_extractor(image).view(bsz, 1, -1) + + mask = None + if self.causal_mask is not None: + if input_pos is None: + raise ValueError( + "Caches are setup, but the position of input token is missing" + ) + # shape: [1, input_pos_len, m_s] + # in most cases input_pos_len should be 1 + mask = self.causal_mask[None, None, input_pos] + + for layer in self.layers: + # shape: [b, 1, d] + h = layer(h, mask, input_pos) + + # shape: [b, 1, d] + return self.norm(h).float() + + + +class TransformerDecoderLayer(nn.Module): + """Transformer layer derived from the Llama2 model. Normalization is applied + before the attention **and** FF layer. + + Args: + attn1 (CausalSelfAttention): Attention module. + attn2 (CausalSelfAttention): Attention module. + mlp (nn.Module): Feed-forward module. + sa_norm_x1 (nn.Module): Normalization to be applied before self-attention. + sa_norm_x2 (nn.Module): Normalization to be applied before self-attention. + mlp_norm (nn.Module): Normalization to be applied before the feed-forward layer. + """ + + def __init__(self, attn1, attn2, mlp, sa_norm_x1, sa_norm_x2, mlp_norm): + super().__init__() + self.sa_norm_x1 = sa_norm_x1 + self.sa_norm_x2 = sa_norm_x2 + self.attn1 = attn1 + self.attn2 = attn2 + self.mlp_norm = mlp_norm + self.mlp = mlp + + def forward(self, x, y, mask=None, input_pos=None): + """ + Args: + x (Tensor): input tensor with shape + [batch_size x seq_length x embed_dim] + y (Tensor): input tensor with shape + [batch_size x 1 x embed_dim] + mask (Optional[Tensor]): Optional tensor which contains the mask. + Only used during inference. Default is None. + input_pos (Optional[Tensor]): Optional tensor which contains the position + of the current token. This is only used during inference. Default is None + + Returns: + Tensor: output tensor with same shape as input + [batch_size x seq_length x embed_dim] + + Notation used for tensor shapes: + - b: batch size + - s: sequence length + - d: embed dim + + TODO: + - Make position of norm configurable + """ + # Input tensor and attention output have the same shape + # [b, s, d] + # Norm applied before self-attention + attn_out = self.attn1(self.sa_norm_x1(x), mask=mask, input_pos=input_pos) + + # Residual connection; shape: [b, s, d] + h = attn_out + x + + # [b, s, d] + # Norm applied before self-attention + attn_out = self.attn2( + self.sa_norm_x2(h), + y, + mask=mask, + input_pos=input_pos, + ) + + # Residual connection; shape: [b, s, d] + h = attn_out + h + + # Norm applied before the feedforward layer + mlp_out = self.mlp(self.mlp_norm(h)) + + # Residual connection; shape: [b, s, d] + out = h + mlp_out + return out + + + +class TransformerDecoder(nn.Module): + """ + Transformer Decoder derived from the Llama2 architecture. + + Args: + tok_embedding (nn.Embedding): PyTorch embedding layer, to be used to move + tokens to an embedding space. + layer (TransformerDecoderLayer): Transformer Decoder layer. + num_layers (int): Number of Transformer Decoder layers. + max_seq_len (int): maximum sequence length the model will be run with, as used + by KVCache + num_heads (int): number of query heads. For MHA this is also the + number of heads for key and value. This is used to setup the + KVCache + head_dim (int): embedding dimension for each head in self-attention. This is used + to setup the KVCache + norm (nn.Module): Callable that applies normalization to the output of the decoder, + before final MLP. + output (nn.Linear): Callable that applies a linear transformation to the output of + the decoder. + + Note: + Arg values are checked for correctness (eg: ``attn_dropout`` belongs to [0,1]) + in the module where they are used. This helps reduces the number of raise + statements in code and improves readability. + """ + + def __init__( + self, + tok_embedding, + layer, + num_layers, + max_seq_len, + num_heads, + head_dim, + norm, + output, + ): + super().__init__() + + self.tok_embedding = tok_embedding + self.layers = _get_clones(layer, num_layers) + self.norm = norm + self.output = output + self.max_seq_len = max_seq_len + self.num_heads = num_heads + self.head_dim = head_dim + self.causal_mask = None + + def setup_caches(self, max_batch_size, dtype=torch.float32): + # inference only + for layer in self.layers: + layer.attn1.kv_cache = KVCache( + max_batch_size=max_batch_size, + max_seq_len=self.max_seq_len, + num_heads=self.num_heads, + head_dim=self.head_dim, + dtype=dtype, + ) + layer.attn2.kv_cache = KVCache( + max_batch_size=max_batch_size, + max_seq_len=self.max_seq_len, + num_heads=self.num_heads, + head_dim=self.head_dim, + dtype=dtype, + ) + + # causal_mask is used during inference to ensure we're attending + # to the right tokens + self.causal_mask = torch.tril( + torch.ones( + self.max_seq_len, + self.max_seq_len, + dtype=torch.bool, + device="cuda" if torch.cuda.is_available() else "cpu" + ) + ) + + def clear_caches(self): + for layer in self.layers: + layer.attn1.kv_cache = None + layer.attn2.kv_cache = None + self.causal_mask = None + + def forward(self, tokens, enc, input_pos=None): + """ + Args: + tokens (Tensor): input tensor with shape [b x s] + enc (Tensor): extracted feature maps encoder [b x d] + input_pos (Optional[Tensor]): Optional tensor which contains the position + of the current token. This is only used during inference. Default is None + + Note: At the very first step of inference, when the model is provided with a prompt, + ``input_pos`` would contain the positions of all of the tokens in the prompt + (eg: ``torch.arange(prompt_length)``). This is because we will need to compute the + KV values for each position. + + Returns: + Tensor: output tensor with shape [b x s x v] + + Raises: + ValueError: if causal_mask is set but input_pos is None + + Notation used for tensor shapes: + - b: batch size + - s: sequence length + - v: vocab size + - d: embed dim + - m_s: max seq len + """ + # input tensor of shape [b, s] + # bsz, seq_len = tokens.shape + bsz = tokens.shape[0] + + # shape: [b, s, d] + h = self.tok_embedding(tokens) + + enc = enc.view(bsz, 1, -1) + + mask = None + if self.causal_mask is not None: + if input_pos is None: + raise ValueError( + "Caches are setup, but the position of input token is missing" + ) + # shape: [1, input_pos_len, m_s] + # in most cases input_pos_len should be 1 + mask = self.causal_mask[None, None, input_pos] + + for layer in self.layers: + # shape: [b, s, d] + h = layer(h, enc, mask, input_pos) + + # shape: [b, s, d] + h = self.norm(h) + + # shape: [b, s, v] + output = self.output(h).float() + return output + + + +class FeedForward(nn.Module): + """This class implements the feed-forward network derived from Llama2. + + Args: + gate_proj (nn.Module): Projection from input dim to hidden dim, fed + through activation and multiplied by up_proj. + down_proj (nn.Module): Final projection to output dim. + up_proj (nn.Module): Projection from input dim to hidden dim, multiplied by + activation(gate_proj). + activation (nn.Module): Activation function to use. Default is nn.SiLU(). + """ + + def __init__( + self, + *, + gate_proj, + down_proj, + up_proj, + activation=nn.SiLU(), + ): + super().__init__() + self.w1 = gate_proj + self.w2 = down_proj + self.w3 = up_proj + self.activation = activation + + def forward(self, x): + return self.w2(self.activation(self.w1(x)) * self.w3(x)) + + + + +class ImageCaptioning(L.LightningModule): + def __init__(self): + super().__init__() + + self.batch_size = BATCH_SIZE + self.max_epoch = MAX_EPOCH + self.lr = LEARNING_RATE + self.lr_now = self.lr * 1e3 + + MLP = FeedForward( + gate_proj=nn.Linear(EMBED_DIM, int(EMBED_DIM * MLP_SCALE), bias=False), + down_proj=nn.Linear(int(EMBED_DIM * MLP_SCALE), EMBED_DIM, bias=False), + up_proj=nn.Linear(EMBED_DIM, int(EMBED_DIM * MLP_SCALE), bias=False), + ) + + # MobileNetV3 + LLaMA 3 + FEATURE_EXTRACTOR = mobilenet_v3_large( + weights=MobileNet_V3_Large_Weights.IMAGENET1K_V2 + ) + FEATURE_EXTRACTOR.classifier[2] = nn.Dropout(p=DROPOUT, inplace=True) + FEATURE_EXTRACTOR.classifier[3] = nn.Linear( + in_features=1280, + out_features=EMBED_DIM, + bias=False, + ) + SELF_ATTENTION = CausalSelfAttention( + embed_dim=EMBED_DIM, + num_heads=NUM_HEAD, + num_kv_heads=NUM_KV_HEAD, + head_dim=HEAD_DIM, + q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + pos_embeddings=RotaryPositionalEmbedding( + dim=HEAD_DIM, + max_seq_len=1, + base=ROPE_BASE, + ), + max_seq_len=1, + attn_dropout=DROPOUT, + ) + ENCODER_LAYER = TransformerEncoderLayer( + attn=SELF_ATTENTION, + mlp=copy.deepcopy(MLP), + sa_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + mlp_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + ) + self.encoder = TransformerEncoder( + feature_extractor=FEATURE_EXTRACTOR, + layer=ENCODER_LAYER, + num_layers=NUM_LAYER, + max_seq_len=MAX_SEQUENCE, + num_heads=NUM_HEAD, + head_dim=HEAD_DIM, + norm=RMSNorm(EMBED_DIM, eps=EPS_NORM), + ) + + # LLaMA 3 + TOKEN_EMBEDDING = nn.Embedding(len(Tokenizer.decoder), EMBED_DIM) + ROPE = RotaryPositionalEmbedding( + dim=HEAD_DIM, + max_seq_len=MAX_SEQUENCE, + base=ROPE_BASE, + ) + SELF_ATTENTION_1 = CausalSelfAttention( + embed_dim=EMBED_DIM, + num_heads=NUM_HEAD, + num_kv_heads=NUM_KV_HEAD, + head_dim=HEAD_DIM, + q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + pos_embeddings=ROPE, + max_seq_len=MAX_SEQUENCE, + attn_dropout=DROPOUT, + ) + SELF_ATTENTION_2 = CausalSelfAttention( + embed_dim=EMBED_DIM, + num_heads=NUM_HEAD, + num_kv_heads=NUM_KV_HEAD, + head_dim=HEAD_DIM, + q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + pos_embeddings=ROPE, + max_seq_len=MAX_SEQUENCE, + attn_dropout=DROPOUT, + ) + DECODER_LAYER = TransformerDecoderLayer( + attn1=SELF_ATTENTION_1, + attn2=SELF_ATTENTION_2, + mlp=copy.deepcopy(MLP), + sa_norm_x1=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + sa_norm_x2=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + mlp_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + ) + OUT_PROJECTION = nn.Linear(EMBED_DIM, len(Tokenizer.decoder), bias=False) + self.decoder = TransformerDecoder( + tok_embedding=TOKEN_EMBEDDING, + layer=DECODER_LAYER, + num_layers=NUM_LAYER, + max_seq_len=MAX_SEQUENCE, + num_heads=NUM_HEAD, + head_dim=HEAD_DIM, + norm=RMSNorm(EMBED_DIM, eps=EPS_NORM), + output=OUT_PROJECTION, + ) + + self.automatic_optimization = False + + self.train_loss = list() + self.val_loss = list() + + self.train_loss_recorder = AvgMeter() + self.val_loss_recorder = AvgMeter() + + self.test_rogue = ROUGEScore() + + self.sanity_check_counter = 1 + + def forward(self, image, caption): + image_feature = self.encoder(image) + return self.decoder(caption, image_feature) + + def captionize(self, image, temperature=TEMPERATURE, top_p=TOP_P): + assert image.shape[0] == 1 + + self.encoder.setup_caches(max_batch_size=1) + encoder_feat = self.encoder( + image, + input_pos=torch.tensor([0], device=self.device), + ) + self.encoder.clear_caches() + + self.decoder.setup_caches(max_batch_size=1) + + pred_token = Tokenizer.encoder[START_TOKEN] + token = [pred_token] + [Tokenizer.encoder[PAD_TOKEN]] * (MAX_SEQUENCE) + for index in range(MAX_SEQUENCE): + caption = torch.LongTensor([pred_token]).unsqueeze(0).to(self.device) + + pred_token = self.decoder( + caption, + encoder_feat, + input_pos=torch.tensor([index], device=self.device), + ) + + if temperature > 0: + # Apply temperature -> make distribution softer (?) + pred_token = (pred_token / temperature).softmax(-1)[0] + # Sampling + psort, pidx = torch.sort(pred_token, dim= -1, descending=True) + psum = torch.cumsum(psort, dim=-1) + psort[psum - psort > top_p] = 0. + psort.div_(psort.sum(dim=-1, keepdim=True)) + pred_token = torch.multinomial(psort, num_samples=1) + pred_token = torch.gather(pidx, -1, pred_token).transpose(0, 1) + else: + pred_token = pred_token.softmax(-1).argmax(2) + + pred_token = pred_token.item() + token[index + 1] = pred_token + + if pred_token == Tokenizer.encoder[END_TOKEN]: + break + + self.decoder.clear_caches() + + return self.postprocess_text(Tokenizer.decode(token)) + + def postprocess_text(self, text): + text = text.replace(START_TOKEN, "") + text = text.replace(END_TOKEN, "") + text = text.replace(PAD_TOKEN, "") + text = re.sub(r'\s([,.!?])', r'\1', text) + text = '. '.join(map(lambda s: s.strip().capitalize(), text.split('.'))) + return text + + def training_step(self, batch, batch_nb): + image, caption = batch + + pred = self(image, caption[:, :-1]) + pred = pred.view(-1, pred.shape[-1]) + caption = caption[:, 1:].reshape(caption.shape[0] * (caption.shape[-1] - 1)) + + loss = F.cross_entropy(pred, caption, ignore_index=Tokenizer.encoder[PAD_TOKEN]) + + opt = self.optimizers() + opt.zero_grad() + self.manual_backward(loss) + torch.nn.utils.clip_grad_norm_( + self.parameters(), + math.log2(math.sqrt(math.e * math.tau) * math.pi), + ) + opt.step() + + self.log("train_loss", loss, prog_bar=True) + self.train_loss_recorder.update(loss.data) + + def on_train_epoch_end(self): + sch = self.lr_schedulers() + sch.step() + self.train_loss.append(self.train_loss_recorder.show().data.cpu().numpy()) + self.train_loss_recorder = AvgMeter() + + def validation_step(self, batch, batch_nb): + image, caption = batch + + pred = self(image, caption[:, :-1]) + pred = pred.view(-1, pred.shape[-1]) + caption = caption[:, 1:].reshape(caption.shape[0] * (caption.shape[-1] - 1)) + + loss = F.cross_entropy(pred, caption, ignore_index=Tokenizer.encoder[PAD_TOKEN]) + + if self.sanity_check_counter == 0: + self.log("val_loss", loss, prog_bar=True) + self.val_loss_recorder.update(loss.data) + + def on_validation_epoch_end(self): + if self.sanity_check_counter == 0: + loss = self.val_loss_recorder.show().data.cpu().numpy() + lr_now_ = self.optimizers().param_groups[0]["lr"] + if self.lr_now != lr_now_: + self.lr_now = lr_now_ + str_report = f"[{MODEL_NAME}] Learning Rate Changed: {lr_now_}" + str_report += f"- Epoch: {self.current_epoch}" + print(str_report) + self.val_loss.append(loss) + self.val_loss_recorder = AvgMeter() + else: + self.sanity_check_counter -= 1 + + def test_step(self, batch, batch_nb): + image, caption = batch + + N_BATCH = image.shape[0] + + rogue1_fmeasure = list() + + for id in range(N_BATCH): + pred = self.captionize(image[id].unsqueeze(0)) + target = self.postprocess_text( + Tokenizer.decode( + caption[id].cpu() + .detach() + .numpy() + .tolist() + ) + ) + rogue1_fmeasure.append( + self.test_rogue(pred, target)['rouge1_fmeasure'] + .cpu() + .detach() + .numpy() + .tolist() + ) + + rogue1_fmeasure = np.array(rogue1_fmeasure).mean() + self.log("ROGUE-1 F-measure", rogue1_fmeasure, prog_bar=True, logger=True) + + def on_train_end(self): + # Loss + img_file = f"experiment/training/{MODEL_NAME}_loss_plot.png" + plt.plot(self.train_loss, color="r", label="train") + plt.plot(self.val_loss, color="b", label="validation") + plt.title("Loss Curves") + plt.xlabel("Epoch") + plt.ylabel("Loss") + plt.legend() + plt.grid() + plt.savefig(img_file) + plt.clf() + img = cv2.imread(img_file) + # cv2_imshow(img) + + def train_dataloader(self): + return data.DataLoader( + TrainDataset, + batch_size=self.batch_size, + shuffle=True, + collate_fn=CollateFunction, + num_workers=2, + persistent_workers=True, + ) + + def val_dataloader(self): + return data.DataLoader( + ValDataset, + batch_size=self.batch_size, + shuffle=False, + collate_fn=CollateFunction, + num_workers=2, + persistent_workers=True, + ) + + def test_dataloader(self): + return data.DataLoader( + TestDataset, + batch_size=self.batch_size, + shuffle=False, + collate_fn=CollateFunction, + num_workers=2, + persistent_workers=True, + ) + + def configure_optimizers(self): + optimizer = optim.AdamW(self.parameters(), self.lr) + + lr_scheduler = { + "scheduler": optim.lr_scheduler.MultiStepLR( + optimizer, + milestones=[int(self.max_epoch * ms) for ms in MILESTONES], + gamma=REDUCE_LR_FACTOR, + ), + "name": "lr_scheduler", + } + + return [optimizer], [lr_scheduler] + + + + + + + + + + + +class CollateFunction(object): + def __init__(self, pad_idx=Tokenizer.encoder[PAD_TOKEN]): + self.pad_idx = pad_idx + + def __call__(self, batch): + images = [item[0].unsqueeze(0) for item in batch] + images = torch.cat(images, dim=0) + + captions = [item[1] for item in batch] + [torch.randn(MAX_SEQUENCE + 1)] + captions = pad_sequence( + captions, + batch_first=True, + padding_value=self.pad_idx, + )[:-1, ...] + return images, captions.long() + +CollateFunction = CollateFunction() + +# TrainDataset = Flickr8KDataset('train') +# ValDataset = Flickr8KDataset('val') +# TestDataset = Flickr8KDataset('test') + +class ImageCaptioning(L.LightningModule): + def __init__(self): + super().__init__() + + self.batch_size = BATCH_SIZE + self.max_epoch = MAX_EPOCH + self.lr = LEARNING_RATE + self.lr_now = self.lr * 1e3 + + MLP = FeedForward( + gate_proj=nn.Linear(EMBED_DIM, int(EMBED_DIM * MLP_SCALE), bias=False), + down_proj=nn.Linear(int(EMBED_DIM * MLP_SCALE), EMBED_DIM, bias=False), + up_proj=nn.Linear(EMBED_DIM, int(EMBED_DIM * MLP_SCALE), bias=False), + ) + + # MobileNetV3 + LLaMA 3 + FEATURE_EXTRACTOR = mobilenet_v3_large( + weights=MobileNet_V3_Large_Weights.IMAGENET1K_V2 + ) + FEATURE_EXTRACTOR.classifier[2] = nn.Dropout(p=DROPOUT, inplace=True) + FEATURE_EXTRACTOR.classifier[3] = nn.Linear( + in_features=1280, + out_features=EMBED_DIM, + bias=False, + ) + SELF_ATTENTION = CausalSelfAttention( + embed_dim=EMBED_DIM, + num_heads=NUM_HEAD, + num_kv_heads=NUM_KV_HEAD, + head_dim=HEAD_DIM, + q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + pos_embeddings=RotaryPositionalEmbedding( + dim=HEAD_DIM, + max_seq_len=1, + base=ROPE_BASE, + ), + max_seq_len=1, + attn_dropout=DROPOUT, + ) + ENCODER_LAYER = TransformerEncoderLayer( + attn=SELF_ATTENTION, + mlp=copy.deepcopy(MLP), + sa_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + mlp_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + ) + self.encoder = TransformerEncoder( + feature_extractor=FEATURE_EXTRACTOR, + layer=ENCODER_LAYER, + num_layers=NUM_LAYER, + max_seq_len=MAX_SEQUENCE, + num_heads=NUM_HEAD, + head_dim=HEAD_DIM, + norm=RMSNorm(EMBED_DIM, eps=EPS_NORM), + ) + + # LLaMA 3 + TOKEN_EMBEDDING = nn.Embedding(len(Tokenizer.decoder), EMBED_DIM) + ROPE = RotaryPositionalEmbedding( + dim=HEAD_DIM, + max_seq_len=MAX_SEQUENCE, + base=ROPE_BASE, + ) + SELF_ATTENTION_1 = CausalSelfAttention( + embed_dim=EMBED_DIM, + num_heads=NUM_HEAD, + num_kv_heads=NUM_KV_HEAD, + head_dim=HEAD_DIM, + q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + pos_embeddings=ROPE, + max_seq_len=MAX_SEQUENCE, + attn_dropout=DROPOUT, + ) + SELF_ATTENTION_2 = CausalSelfAttention( + embed_dim=EMBED_DIM, + num_heads=NUM_HEAD, + num_kv_heads=NUM_KV_HEAD, + head_dim=HEAD_DIM, + q_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + k_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + v_proj=nn.Linear(EMBED_DIM, NUM_KV_HEAD * HEAD_DIM, bias=False), + output_proj=nn.Linear(EMBED_DIM, EMBED_DIM, bias=False), + pos_embeddings=ROPE, + max_seq_len=MAX_SEQUENCE, + attn_dropout=DROPOUT, + ) + DECODER_LAYER = TransformerDecoderLayer( + attn1=SELF_ATTENTION_1, + attn2=SELF_ATTENTION_2, + mlp=copy.deepcopy(MLP), + sa_norm_x1=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + sa_norm_x2=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + mlp_norm=RMSNorm(dim=EMBED_DIM, eps=EPS_NORM), + ) + OUT_PROJECTION = nn.Linear(EMBED_DIM, len(Tokenizer.decoder), bias=False) + self.decoder = TransformerDecoder( + tok_embedding=TOKEN_EMBEDDING, + layer=DECODER_LAYER, + num_layers=NUM_LAYER, + max_seq_len=MAX_SEQUENCE, + num_heads=NUM_HEAD, + head_dim=HEAD_DIM, + norm=RMSNorm(EMBED_DIM, eps=EPS_NORM), + output=OUT_PROJECTION, + ) + + self.automatic_optimization = False + + self.train_loss = list() + self.val_loss = list() + + self.train_loss_recorder = AvgMeter() + self.val_loss_recorder = AvgMeter() + + self.test_rogue = ROUGEScore() + + self.sanity_check_counter = 1 + + def forward(self, image, caption): + image_feature = self.encoder(image) + return self.decoder(caption, image_feature) + + def captionize(self, image, temperature=TEMPERATURE, top_p=TOP_P): + assert image.shape[0] == 1 + + self.encoder.setup_caches(max_batch_size=1) + encoder_feat = self.encoder( + image, + input_pos=torch.tensor([0], device=self.device), + ) + self.encoder.clear_caches() + + self.decoder.setup_caches(max_batch_size=1) + + pred_token = Tokenizer.encoder[START_TOKEN] + token = [pred_token] + [Tokenizer.encoder[PAD_TOKEN]] * (MAX_SEQUENCE) + for index in range(MAX_SEQUENCE): + caption = torch.LongTensor([pred_token]).unsqueeze(0).to(self.device) + + pred_token = self.decoder( + caption, + encoder_feat, + input_pos=torch.tensor([index], device=self.device), + ) + + if temperature > 0: + # Apply temperature -> make distribution softer (?) + pred_token = (pred_token / temperature).softmax(-1)[0] + # Sampling + psort, pidx = torch.sort(pred_token, dim= -1, descending=True) + psum = torch.cumsum(psort, dim=-1) + psort[psum - psort > top_p] = 0. + psort.div_(psort.sum(dim=-1, keepdim=True)) + pred_token = torch.multinomial(psort, num_samples=1) + pred_token = torch.gather(pidx, -1, pred_token).transpose(0, 1) + else: + pred_token = pred_token.softmax(-1).argmax(2) + + pred_token = pred_token.item() + token[index + 1] = pred_token + + if pred_token == Tokenizer.encoder[END_TOKEN]: + break + + self.decoder.clear_caches() + + return self.postprocess_text(Tokenizer.decode(token)) + + def postprocess_text(self, text): + text = text.replace(START_TOKEN, "") + text = text.replace(END_TOKEN, "") + text = text.replace(PAD_TOKEN, "") + text = re.sub(r'\s([,.!?])', r'\1', text) + text = '. '.join(map(lambda s: s.strip().capitalize(), text.split('.'))) + return text + + def training_step(self, batch, batch_nb): + image, caption = batch + + pred = self(image, caption[:, :-1]) + pred = pred.view(-1, pred.shape[-1]) + caption = caption[:, 1:].reshape(caption.shape[0] * (caption.shape[-1] - 1)) + + loss = F.cross_entropy(pred, caption, ignore_index=Tokenizer.encoder[PAD_TOKEN]) + + opt = self.optimizers() + opt.zero_grad() + self.manual_backward(loss) + torch.nn.utils.clip_grad_norm_( + self.parameters(), + math.log2(math.sqrt(math.e * math.tau) * math.pi), + ) + opt.step() + + self.log("train_loss", loss, prog_bar=True) + self.train_loss_recorder.update(loss.data) + + def on_train_epoch_end(self): + sch = self.lr_schedulers() + sch.step() + self.train_loss.append(self.train_loss_recorder.show().data.cpu().numpy()) + self.train_loss_recorder = AvgMeter() + + def validation_step(self, batch, batch_nb): + image, caption = batch + + pred = self(image, caption[:, :-1]) + pred = pred.view(-1, pred.shape[-1]) + caption = caption[:, 1:].reshape(caption.shape[0] * (caption.shape[-1] - 1)) + + loss = F.cross_entropy(pred, caption, ignore_index=Tokenizer.encoder[PAD_TOKEN]) + + if self.sanity_check_counter == 0: + self.log("val_loss", loss, prog_bar=True) + self.val_loss_recorder.update(loss.data) + + def on_validation_epoch_end(self): + if self.sanity_check_counter == 0: + loss = self.val_loss_recorder.show().data.cpu().numpy() + lr_now_ = self.optimizers().param_groups[0]["lr"] + if self.lr_now != lr_now_: + self.lr_now = lr_now_ + str_report = f"[{MODEL_NAME}] Learning Rate Changed: {lr_now_}" + str_report += f"- Epoch: {self.current_epoch}" + print(str_report) + self.val_loss.append(loss) + self.val_loss_recorder = AvgMeter() + else: + self.sanity_check_counter -= 1 + + def test_step(self, batch, batch_nb): + image, caption = batch + + N_BATCH = image.shape[0] + + rogue1_fmeasure = list() + + for id in range(N_BATCH): + pred = self.captionize(image[id].unsqueeze(0)) + target = self.postprocess_text( + Tokenizer.decode( + caption[id].cpu() + .detach() + .numpy() + .tolist() + ) + ) + rogue1_fmeasure.append( + self.test_rogue(pred, target)['rouge1_fmeasure'] + .cpu() + .detach() + .numpy() + .tolist() + ) + + rogue1_fmeasure = np.array(rogue1_fmeasure).mean() + self.log("ROGUE-1 F-measure", rogue1_fmeasure, prog_bar=True, logger=True) + + def on_train_end(self): + # Loss + img_file = f"experiment/training/{MODEL_NAME}_loss_plot.png" + plt.plot(self.train_loss, color="r", label="train") + plt.plot(self.val_loss, color="b", label="validation") + plt.title("Loss Curves") + plt.xlabel("Epoch") + plt.ylabel("Loss") + plt.legend() + plt.grid() + plt.savefig(img_file) + plt.clf() + img = cv2.imread(img_file) + # cv2_imshow(img) + + def train_dataloader(self): + return data.DataLoader( + TrainDataset, + batch_size=self.batch_size, + shuffle=True, + collate_fn=CollateFunction, + num_workers=2, + persistent_workers=True, + ) + + def val_dataloader(self): + return data.DataLoader( + ValDataset, + batch_size=self.batch_size, + shuffle=False, + collate_fn=CollateFunction, + num_workers=2, + persistent_workers=True, + ) + + def test_dataloader(self): + return data.DataLoader( + TestDataset, + batch_size=self.batch_size, + shuffle=False, + collate_fn=CollateFunction, + num_workers=2, + persistent_workers=True, + ) + + def configure_optimizers(self): + optimizer = optim.AdamW(self.parameters(), self.lr) + + lr_scheduler = { + "scheduler": optim.lr_scheduler.MultiStepLR( + optimizer, + milestones=[int(self.max_epoch * ms) for ms in MILESTONES], + gamma=REDUCE_LR_FACTOR, + ), + "name": "lr_scheduler", + } + + return [optimizer], [lr_scheduler] + + +MODEL_NAME = ImageCaptioning.__name__ +MODEL = ImageCaptioning +BEST_MODEL_PATH = os.path.join( + EXPERIMENT_DIR, + # f"model/{MODEL_NAME}_best.ckpt", + 'Model\ImageCaptioning_best.ckpt' +) +LAST_MODEL_PATH = os.path.join( + EXPERIMENT_DIR, + # "model/last.ckpt", + 'Model\ImageCaptioning_best.ckpt' +) + + + + + + + + + + + + +app = Flask(__name__) + +# Load your model +LAST_MODEL_PATH = 'Model\ImageCaptioning_best.ckpt' +model = MODEL.load_from_checkpoint(LAST_MODEL_PATH) +model.eval() + +MAX_CHAR = 50 + +@app.route('/caption', methods=['POST']) +def caption_image(): + print("ENTERED") + file = request.files['image'] + if not file: + return jsonify({"error": "No file provided"}), 400 + + image_raw = cv2.cvtColor( + cv2.imdecode( + np.frombuffer(file.read(), np.uint8), + cv2.IMREAD_COLOR, + ), + cv2.COLOR_BGR2RGB, + ) + + image = ( + TRANSFORM( + Image.fromarray( + image_raw.copy(), + "RGB", + ) + ) + .to("cuda" if torch.cuda.is_available() else "cpu") + .unsqueeze(0) + ) + + caption = model.captionize(image) + print(caption) + + title = [ + f"{caption[(cline * MAX_CHAR):((cline + 1) * MAX_CHAR)]}\n" + for cline in range(math.ceil(len(caption) / MAX_CHAR)) + ] + title = "".join(title) + print(title) + + # plt.figure() + # plt.imshow(image_raw.copy()) + # plt.title(title) + # plt.axis("off") + # plt.savefig('result.png') + + return jsonify({"caption": caption}) + +if __name__ == '__main__': + app.run(host='0.0.0.0', port=5001) \ No newline at end of file diff --git a/Backend/image_processor.py b/Backend/image_processor.py new file mode 100644 index 0000000..3f95f58 --- /dev/null +++ b/Backend/image_processor.py @@ -0,0 +1,92 @@ +from flask import Flask, request, jsonify +from flask_pymongo import PyMongo +from flask_cors import CORS +import requests +import base64 +from io import BytesIO +from flask_bcrypt import Bcrypt +bcrypt = Bcrypt() +from dotenv import load_dotenv +import os + +load_dotenv() + +app = Flask(__name__) +CORS(app) +app.config["MONGO_URI"] = os.getenv('DB_URL') +mongo = PyMongo(app) + +API_URL = os.getenv('API_URL') +HEADERS = os.getenv('API_TOKEN') + + +def query_model(image_data): + response = requests.post(API_URL, headers=HEADERS, data=image_data) + return response.json() + +@app.route('/') +def home(): + return "Welcome to the Flask MongoDB app!" + +@app.route('/caption', methods=['POST']) +def get_image_caption(): + try: + # Check if the request contains an image file + if 'image' not in request.files: + return jsonify({'error': 'No image file provided. Make sure to include an image file in the request.'}), 400 + + # Read the image file from the request + image_file = request.files['image'] + image_file.seek(0) # Ensure the file pointer is at the start + + # Check if the image file is empty + image_content = image_file.read() + if not image_content: + return jsonify({'error': 'The provided image file is empty.'}), 400 + + print("Image content length:", len(image_content)) + + # Convert the image to base64 + image_base64 = base64.b64encode(image_content).decode('utf-8') + print("Base64 encoded image:", image_base64[:100]) # Print first 100 characters for brevity + + # Query the model for image caption + result = query_model(image_content) + caption = result[0]["generated_text"] + print("Generated caption:", caption) + + # Insert the data into MongoDB + try: + mongo.db.Assets.insert_one({"image_file": image_base64, "caption": caption}) + print("Inserted into database") + except Exception as e: + print(f"Error while uploading the conversation to the database: {e}") + + return jsonify(result[0]["generated_text"]) + + except Exception as e: + return jsonify({'error': str(e)}), 500 + +collection = mongo.db["Assets"] + + +@app.route('/conversations',methods = ['get']) +def send_conversations(): + print("Received fetch request") + try: + data = list(collection.find({}, {'_id': 0})) # exclude _id field from the results + print(jsonify(data)) + + return jsonify(data) + except Exception as e: + print("Error while fetching data from database") + + + + + +if __name__ == '__main__': + app.run(host='0.0.0.0', port=5000, debug=True) + + + \ No newline at end of file diff --git a/Backend/query_api.py b/Backend/query_api.py new file mode 100644 index 0000000..6c4f0b8 --- /dev/null +++ b/Backend/query_api.py @@ -0,0 +1,103 @@ +import os +import torch +from torch import Tensor +from transformers import AutoTokenizer, AutoModelForSeq2SeqLM +from sentence_transformers import SentenceTransformer, util +from gtts import gTTS +import tempfile +import pygame +from flask import Flask, request, jsonify + +# Suppress warnings +os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0' +os.environ['HF_HUB_DISABLE_SYMLINKS_WARNING'] = '1' + +# Initialize Flask app +app = Flask(__name__) + +# Initialize the retriever model and tokenizer +retriever_model = SentenceTransformer('thenlper/gte-large') +retriever_tokenizer = AutoTokenizer.from_pretrained('thenlper/gte-large') + +# Initialize the generator model and tokenizer +generator_model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large") +generator_tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large") + +def average_pool(last_hidden_states: Tensor, attention_mask: Tensor) -> Tensor: + last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0) + return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None] + +def retrieve_passages(query, stored_passages, num_passages=5): + # Encode the stored passages using SentenceTransformer + stored_embeddings = retriever_model.encode(stored_passages, convert_to_tensor=True) + + # Tokenize and encode the query + query_inputs = retriever_tokenizer(query, return_tensors="pt", max_length=512, truncation=True, padding=True) + + # Get embeddings for the query + with torch.no_grad(): + query_outputs = retriever_model.encode(query, convert_to_tensor=True) + + # Compute cosine similarity between query embedding and stored passage embeddings + scores = util.pytorch_cos_sim(query_outputs, stored_embeddings)[0] + + # Get top passages based on scores + top_passages = [(score.item(), passage) for score, passage in zip(scores, stored_passages)] + + # Sort passages by similarity score + top_passages.sort(key=lambda x: x[0], reverse=True) + + # Return top num_passages passages + return top_passages[:num_passages] + +def generate_answer(context, question): + input_text = context + " " + question # Combine context and question into a single string + + inputs = generator_tokenizer(input_text, return_tensors="pt", max_length=512, truncation=True, padding=True) + with torch.no_grad(): + outputs = generator_model.generate(input_ids=inputs['input_ids'], attention_mask=inputs['attention_mask'], max_new_tokens=50) + return generator_tokenizer.batch_decode(outputs, skip_special_tokens=True) + +def speak_text(text): + tts = gTTS(text=text, lang='en') + with tempfile.NamedTemporaryFile(delete=True) as fp: + tts.save(fp.name + ".mp3") + pygame.mixer.init() + pygame.mixer.music.load(fp.name + ".mp3") + pygame.mixer.music.play() + while pygame.mixer.music.get_busy(): + continue + +@app.route('/api/query', methods=['POST']) +def query_api(): + print("ENTERED") + data = request.get_json() + query = data.get('query') + stored_passages = data.get('stored_passages') + # print("Query: "+query+"\n") + # print("Stored Passages"+stored_passages+"\n") + + if not query or not stored_passages: + return jsonify({"error": "Query and stored_passages are required"}), 400 + + retrieved_passages = retrieve_passages(query, stored_passages) + + # Get the top passage + if retrieved_passages: + top_passage = retrieved_passages[0][1] + + # Generate answer + answers = generate_answer(top_passage, query) + + # Respond with the generated answer + response = { + "query": query, + "retrieved_passages": [{"score": score, "passage": passage} for score, passage in retrieved_passages], + "answers": answers + } + return jsonify(response) + + return jsonify({"error": "No passages found"}), 404 + +if __name__ == "__main__": + app.run(host='0.0.0.0', port=5003, debug=True) \ No newline at end of file diff --git a/Backend/videoProcessing.py b/Backend/videoProcessing.py new file mode 100644 index 0000000..65383e5 --- /dev/null +++ b/Backend/videoProcessing.py @@ -0,0 +1,98 @@ +import cv2 +import threading +from flask import Flask, request, jsonify +import requests +import tempfile +from queue import Queue +import time +import numpy as np +from dotenv import load_dotenv +import os + +load_dotenv() + +app = Flask(__name__) + +from g4f.client import Client + +client = Client() + +def generatePara(s): + response = client.chat.completions.create( + model="gpt-3.5-turbo", + messages=[{"role":"user", "content":s+"These are the captions of the frames of a video. Give me a brief paragraph in simple language and nothing else in the response."}], + ) + return response.choices[0].message.content + +API_URL = os.getenv('API_URL') +HEADERS = os.getenv('API_TOKEN') + +def query_model(frame): + retry_attempts = 3 + retry_delay = 10 + for attempt in range(1, retry_attempts + 1): + try: + _, image_data = cv2.imencode('.jpg', frame) + if isinstance(image_data, np.ndarray): + image_data = image_data.tobytes() + response = requests.post(API_URL, headers=HEADERS, data=image_data) + if response.status_code == 200: + return response.json() + elif response.status_code == 503 and "currently loading" in response.json().get("error", "").lower(): + estimated_time = response.json().get("estimated_time", 0) + print(f"Model is still loading. Retry attempt {attempt}/{retry_attempts}. Waiting {retry_delay} seconds...") + time.sleep(retry_delay) + else: + return {'error': f"Failed to query model: {response.status_code} {response.reason}"} + except Exception as e: + print(f"Exception occurred during model query: {str(e)}") + return {'error': f"Exception occurred during model query: {str(e)}"} + return {'error': f"Model did not become available after {retry_attempts} retries"} + +def process_video(video_path, results_queue, completion_event): + cap = cv2.VideoCapture(video_path) + if not cap.isOpened(): + results_queue.put({'error': 'Failed to open video file.'}) + completion_event.set() + return + frame_rate = cap.get(cv2.CAP_PROP_FPS) + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + interval_seconds = 2 + interval_frames = int(frame_rate * interval_seconds) + frame_number = 0 + while frame_number < total_frames: + cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number) + ret, frame = cap.read() + if ret: + try: + result = query_model(frame) + results_queue.put(result) + except Exception as e: + results_queue.put({'error': str(e)}) + frame_number += interval_frames + cap.release() + completion_event.set() + +@app.route('/process_video', methods=['POST']) +def process_video_route(): + try: + if 'video' not in request.files: + return jsonify({'error': 'No video file provided. Make sure to include a video file in the request.'}), 400 + video_file = request.files['video'] + temp_video_path = tempfile.mktemp(suffix='.mp4') + video_file.save(temp_video_path) + results_queue = Queue() + completion_event = threading.Event() + processing_thread = threading.Thread(target=process_video, args=(temp_video_path, results_queue, completion_event)) + processing_thread.start() + completion_event.wait() + results = [] + while not results_queue.empty(): + results.append(results_queue.get()) + res = generatePara(str(results)) + return jsonify(res), 200 + except Exception as e: + return jsonify({'error': str(e)}), 500 + +if __name__ == '__main__': + app.run(host='0.0.0.0', port=5002, debug=True) diff --git a/Frontend/classico/.gitignore b/Frontend/classico/.gitignore new file mode 100644 index 0000000..29a3a50 --- /dev/null +++ b/Frontend/classico/.gitignore @@ -0,0 +1,43 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +/build/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/Frontend/classico/.metadata b/Frontend/classico/.metadata new file mode 100644 index 0000000..32dc8a5 --- /dev/null +++ b/Frontend/classico/.metadata @@ -0,0 +1,45 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "300451adae589accbece3490f4396f10bdf15e6e" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + - platform: android + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + - platform: ios + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + - platform: linux + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + - platform: macos + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + - platform: web + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + - platform: windows + create_revision: 300451adae589accbece3490f4396f10bdf15e6e + base_revision: 300451adae589accbece3490f4396f10bdf15e6e + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/Frontend/classico/README.md b/Frontend/classico/README.md new file mode 100644 index 0000000..6fa428f --- /dev/null +++ b/Frontend/classico/README.md @@ -0,0 +1,16 @@ +# classico + +A new Flutter project. + +## Getting Started + +This project is a starting point for a Flutter application. + +A few resources to get you started if this is your first Flutter project: + +- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab) +- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook) + +For help getting started with Flutter development, view the +[online documentation](https://docs.flutter.dev/), which offers tutorials, +samples, guidance on mobile development, and a full API reference. diff --git a/Frontend/classico/analysis_options.yaml b/Frontend/classico/analysis_options.yaml new file mode 100644 index 0000000..0d29021 --- /dev/null +++ b/Frontend/classico/analysis_options.yaml @@ -0,0 +1,28 @@ +# This file configures the analyzer, which statically analyzes Dart code to +# check for errors, warnings, and lints. +# +# The issues identified by the analyzer are surfaced in the UI of Dart-enabled +# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be +# invoked from the command line by running `flutter analyze`. + +# The following line activates a set of recommended lints for Flutter apps, +# packages, and plugins designed to encourage good coding practices. +include: package:flutter_lints/flutter.yaml + +linter: + # The lint rules applied to this project can be customized in the + # section below to disable rules from the `package:flutter_lints/flutter.yaml` + # included above or to enable additional rules. A list of all available lints + # and their documentation is published at https://dart.dev/lints. + # + # Instead of disabling a lint rule for the entire project in the + # section below, it can also be suppressed for a single line of code + # or a specific dart file by using the `// ignore: name_of_lint` and + # `// ignore_for_file: name_of_lint` syntax on the line or in the file + # producing the lint. + rules: + # avoid_print: false # Uncomment to disable the `avoid_print` rule + # prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule + +# Additional information about this file can be found at +# https://dart.dev/guides/language/analysis-options diff --git a/Frontend/classico/android/.gitignore b/Frontend/classico/android/.gitignore new file mode 100644 index 0000000..6f56801 --- /dev/null +++ b/Frontend/classico/android/.gitignore @@ -0,0 +1,13 @@ +gradle-wrapper.jar +/.gradle +/captures/ +/gradlew +/gradlew.bat +/local.properties +GeneratedPluginRegistrant.java + +# Remember to never publicly share your keystore. +# See https://flutter.dev/docs/deployment/android#reference-the-keystore-from-the-app +key.properties +**/*.keystore +**/*.jks diff --git a/Frontend/classico/android/app/build.gradle b/Frontend/classico/android/app/build.gradle new file mode 100644 index 0000000..f3db534 --- /dev/null +++ b/Frontend/classico/android/app/build.gradle @@ -0,0 +1,67 @@ +plugins { + id "com.android.application" + id "kotlin-android" + id "dev.flutter.flutter-gradle-plugin" +} + +def localProperties = new Properties() +def localPropertiesFile = rootProject.file('local.properties') +if (localPropertiesFile.exists()) { + localPropertiesFile.withReader('UTF-8') { reader -> + localProperties.load(reader) + } +} + +def flutterVersionCode = localProperties.getProperty('flutter.versionCode') +if (flutterVersionCode == null) { + flutterVersionCode = '1' +} + +def flutterVersionName = localProperties.getProperty('flutter.versionName') +if (flutterVersionName == null) { + flutterVersionName = '1.0' +} + +android { + namespace "com.example.classico" + compileSdkVersion 34 + ndkVersion flutter.ndkVersion + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + kotlinOptions { + jvmTarget = '1.8' + } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } + + defaultConfig { + // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html). + applicationId "com.example.classico" + // You can update the following values to match your application needs. + // For more information, see: https://docs.flutter.dev/deployment/android#reviewing-the-gradle-build-configuration. + minSdkVersion 21 + targetSdkVersion 34 + versionCode flutterVersionCode.toInteger() + versionName flutterVersionName + } + + buildTypes { + release { + // TODO: Add your own signing config for the release build. + // Signing with the debug keys for now, so `flutter run --release` works. + signingConfig signingConfigs.debug + } + } +} + +flutter { + source '../..' +} + +dependencies {} \ No newline at end of file diff --git a/Frontend/classico/android/app/src/debug/AndroidManifest.xml b/Frontend/classico/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 0000000..399f698 --- /dev/null +++ b/Frontend/classico/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/Frontend/classico/android/app/src/main/AndroidManifest.xml b/Frontend/classico/android/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..3e57c83 --- /dev/null +++ b/Frontend/classico/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/Frontend/classico/android/app/src/main/kotlin/com/example/classico/MainActivity.kt b/Frontend/classico/android/app/src/main/kotlin/com/example/classico/MainActivity.kt new file mode 100644 index 0000000..91eb8ff --- /dev/null +++ b/Frontend/classico/android/app/src/main/kotlin/com/example/classico/MainActivity.kt @@ -0,0 +1,5 @@ +package com.example.classico + +import io.flutter.embedding.android.FlutterActivity + +class MainActivity: FlutterActivity() diff --git a/Frontend/classico/android/app/src/main/res/drawable-v21/launch_background.xml b/Frontend/classico/android/app/src/main/res/drawable-v21/launch_background.xml new file mode 100644 index 0000000..f74085f --- /dev/null +++ b/Frontend/classico/android/app/src/main/res/drawable-v21/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/Frontend/classico/android/app/src/main/res/drawable/launch_background.xml b/Frontend/classico/android/app/src/main/res/drawable/launch_background.xml new file mode 100644 index 0000000..304732f --- /dev/null +++ b/Frontend/classico/android/app/src/main/res/drawable/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/Frontend/classico/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/Frontend/classico/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000..db77bb4 Binary files /dev/null and b/Frontend/classico/android/app/src/main/res/mipmap-hdpi/ic_launcher.png differ diff --git a/Frontend/classico/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/Frontend/classico/android/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 0000000..17987b7 Binary files /dev/null and b/Frontend/classico/android/app/src/main/res/mipmap-mdpi/ic_launcher.png differ diff --git a/Frontend/classico/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/Frontend/classico/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 0000000..09d4391 Binary files /dev/null and b/Frontend/classico/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ diff --git a/Frontend/classico/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/Frontend/classico/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000..d5f1c8d Binary files /dev/null and b/Frontend/classico/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ diff --git a/Frontend/classico/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/Frontend/classico/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 0000000..4d6372e Binary files /dev/null and b/Frontend/classico/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ diff --git a/Frontend/classico/android/app/src/main/res/values-night/styles.xml b/Frontend/classico/android/app/src/main/res/values-night/styles.xml new file mode 100644 index 0000000..06952be --- /dev/null +++ b/Frontend/classico/android/app/src/main/res/values-night/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/Frontend/classico/android/app/src/main/res/values/styles.xml b/Frontend/classico/android/app/src/main/res/values/styles.xml new file mode 100644 index 0000000..cb1ef88 --- /dev/null +++ b/Frontend/classico/android/app/src/main/res/values/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/Frontend/classico/android/app/src/profile/AndroidManifest.xml b/Frontend/classico/android/app/src/profile/AndroidManifest.xml new file mode 100644 index 0000000..399f698 --- /dev/null +++ b/Frontend/classico/android/app/src/profile/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/Frontend/classico/android/build.gradle b/Frontend/classico/android/build.gradle new file mode 100644 index 0000000..8f31e8c --- /dev/null +++ b/Frontend/classico/android/build.gradle @@ -0,0 +1,18 @@ +allprojects { + repositories { + google() + mavenCentral() + } +} + +rootProject.buildDir = '../build' +subprojects { + project.buildDir = "${rootProject.buildDir}/${project.name}" +} +subprojects { + project.evaluationDependsOn(':app') +} + +tasks.register("clean", Delete) { + delete rootProject.buildDir +} \ No newline at end of file diff --git a/Frontend/classico/android/gradle.properties b/Frontend/classico/android/gradle.properties new file mode 100644 index 0000000..598d13f --- /dev/null +++ b/Frontend/classico/android/gradle.properties @@ -0,0 +1,3 @@ +org.gradle.jvmargs=-Xmx4G +android.useAndroidX=true +android.enableJetifier=true diff --git a/Frontend/classico/android/gradle/wrapper/gradle-wrapper.properties b/Frontend/classico/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..e1ca574 --- /dev/null +++ b/Frontend/classico/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.3-all.zip diff --git a/Frontend/classico/android/settings.gradle b/Frontend/classico/android/settings.gradle new file mode 100644 index 0000000..1d6d19b --- /dev/null +++ b/Frontend/classico/android/settings.gradle @@ -0,0 +1,26 @@ +pluginManagement { + def flutterSdkPath = { + def properties = new Properties() + file("local.properties").withInputStream { properties.load(it) } + def flutterSdkPath = properties.getProperty("flutter.sdk") + assert flutterSdkPath != null, "flutter.sdk not set in local.properties" + return flutterSdkPath + } + settings.ext.flutterSdkPath = flutterSdkPath() + + includeBuild("${settings.ext.flutterSdkPath}/packages/flutter_tools/gradle") + + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id "dev.flutter.flutter-plugin-loader" version "1.0.0" + id "com.android.application" version "7.3.0" apply false + id "org.jetbrains.kotlin.android" version "1.7.10" apply false +} + +include ":app" diff --git a/Frontend/classico/assets/sound/Alarm.mp3 b/Frontend/classico/assets/sound/Alarm.mp3 new file mode 100644 index 0000000..eaffcf0 Binary files /dev/null and b/Frontend/classico/assets/sound/Alarm.mp3 differ diff --git a/Frontend/classico/ios/.gitignore b/Frontend/classico/ios/.gitignore new file mode 100644 index 0000000..7a7f987 --- /dev/null +++ b/Frontend/classico/ios/.gitignore @@ -0,0 +1,34 @@ +**/dgph +*.mode1v3 +*.mode2v3 +*.moved-aside +*.pbxuser +*.perspectivev3 +**/*sync/ +.sconsign.dblite +.tags* +**/.vagrant/ +**/DerivedData/ +Icon? +**/Pods/ +**/.symlinks/ +profile +xcuserdata +**/.generated/ +Flutter/App.framework +Flutter/Flutter.framework +Flutter/Flutter.podspec +Flutter/Generated.xcconfig +Flutter/ephemeral/ +Flutter/app.flx +Flutter/app.zip +Flutter/flutter_assets/ +Flutter/flutter_export_environment.sh +ServiceDefinitions.json +Runner/GeneratedPluginRegistrant.* + +# Exceptions to above rules. +!default.mode1v3 +!default.mode2v3 +!default.pbxuser +!default.perspectivev3 diff --git a/Frontend/classico/ios/Flutter/AppFrameworkInfo.plist b/Frontend/classico/ios/Flutter/AppFrameworkInfo.plist new file mode 100644 index 0000000..7c56964 --- /dev/null +++ b/Frontend/classico/ios/Flutter/AppFrameworkInfo.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + App + CFBundleIdentifier + io.flutter.flutter.app + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + App + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1.0 + MinimumOSVersion + 12.0 + + diff --git a/Frontend/classico/ios/Flutter/Debug.xcconfig b/Frontend/classico/ios/Flutter/Debug.xcconfig new file mode 100644 index 0000000..592ceee --- /dev/null +++ b/Frontend/classico/ios/Flutter/Debug.xcconfig @@ -0,0 +1 @@ +#include "Generated.xcconfig" diff --git a/Frontend/classico/ios/Flutter/Release.xcconfig b/Frontend/classico/ios/Flutter/Release.xcconfig new file mode 100644 index 0000000..592ceee --- /dev/null +++ b/Frontend/classico/ios/Flutter/Release.xcconfig @@ -0,0 +1 @@ +#include "Generated.xcconfig" diff --git a/Frontend/classico/ios/Runner.xcodeproj/project.pbxproj b/Frontend/classico/ios/Runner.xcodeproj/project.pbxproj new file mode 100644 index 0000000..392912b --- /dev/null +++ b/Frontend/classico/ios/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,616 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXBuildFile section */ + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; }; + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; }; + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; }; + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; }; + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; }; + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; }; + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 97C146E61CF9000F007C117D /* Project object */; + proxyType = 1; + remoteGlobalIDString = 97C146ED1CF9000F007C117D; + remoteInfo = Runner; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 9705A1C41CF9048500538489 /* Embed Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Embed Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = ""; }; + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = ""; }; + 331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = ""; }; + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = ""; }; + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = ""; }; + 9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = ""; }; + 97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 97C146EB1CF9000F007C117D /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 331C8082294A63A400263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C807B294A618700263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 9740EEB11CF90186004384FC /* Flutter */ = { + isa = PBXGroup; + children = ( + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 9740EEB31CF90195004384FC /* Generated.xcconfig */, + ); + name = Flutter; + sourceTree = ""; + }; + 97C146E51CF9000F007C117D = { + isa = PBXGroup; + children = ( + 9740EEB11CF90186004384FC /* Flutter */, + 97C146F01CF9000F007C117D /* Runner */, + 97C146EF1CF9000F007C117D /* Products */, + 331C8082294A63A400263BE5 /* RunnerTests */, + ); + sourceTree = ""; + }; + 97C146EF1CF9000F007C117D /* Products */ = { + isa = PBXGroup; + children = ( + 97C146EE1CF9000F007C117D /* Runner.app */, + 331C8081294A63A400263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 97C146F01CF9000F007C117D /* Runner */ = { + isa = PBXGroup; + children = ( + 97C146FA1CF9000F007C117D /* Main.storyboard */, + 97C146FD1CF9000F007C117D /* Assets.xcassets */, + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */, + 97C147021CF9000F007C117D /* Info.plist */, + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */, + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */, + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */, + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */, + ); + path = Runner; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C8080294A63A400263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 331C807D294A63A400263BE5 /* Sources */, + 331C807F294A63A400263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C8086294A63A400263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 97C146ED1CF9000F007C117D /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 9740EEB61CF901F6004384FC /* Run Script */, + 97C146EA1CF9000F007C117D /* Sources */, + 97C146EB1CF9000F007C117D /* Frameworks */, + 97C146EC1CF9000F007C117D /* Resources */, + 9705A1C41CF9048500538489 /* Embed Frameworks */, + 3B06AD1E1E4923F5004D2608 /* Thin Binary */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = Runner; + productName = Runner; + productReference = 97C146EE1CF9000F007C117D /* Runner.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 97C146E61CF9000F007C117D /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C8080294A63A400263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 97C146ED1CF9000F007C117D; + }; + 97C146ED1CF9000F007C117D = { + CreatedOnToolsVersion = 7.3.1; + LastSwiftMigration = 1100; + }; + }; + }; + buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 97C146E51CF9000F007C117D; + productRefGroup = 97C146EF1CF9000F007C117D /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 97C146ED1CF9000F007C117D /* Runner */, + 331C8080294A63A400263BE5 /* RunnerTests */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C807F294A63A400263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EC1CF9000F007C117D /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */, + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */, + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */, + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 3B06AD1E1E4923F5004D2608 /* Thin Binary */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + "${TARGET_BUILD_DIR}/${INFOPLIST_PATH}", + ); + name = "Thin Binary"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin"; + }; + 9740EEB61CF901F6004384FC /* Run Script */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Run Script"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build"; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C807D294A63A400263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EA1CF9000F007C117D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */, + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C8086294A63A400263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 97C146ED1CF9000F007C117D /* Runner */; + targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 97C146FA1CF9000F007C117D /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C146FB1CF9000F007C117D /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C147001CF9000F007C117D /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 249021D3217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Profile; + }; + 249021D4217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Profile; + }; + 331C8088294A63A400263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Debug; + }; + 331C8089294A63A400263BE5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Release; + }; + 331C808A294A63A400263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Profile; + }; + 97C147031CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 97C147041CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 12.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 97C147061CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Debug; + }; + 97C147071CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C8088294A63A400263BE5 /* Debug */, + 331C8089294A63A400263BE5 /* Release */, + 331C808A294A63A400263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147031CF9000F007C117D /* Debug */, + 97C147041CF9000F007C117D /* Release */, + 249021D3217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147061CF9000F007C117D /* Debug */, + 97C147071CF9000F007C117D /* Release */, + 249021D4217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 97C146E61CF9000F007C117D /* Project object */; +} diff --git a/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 0000000..f9b0d7c --- /dev/null +++ b/Frontend/classico/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/Frontend/classico/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/Frontend/classico/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 0000000..8e3ca5d --- /dev/null +++ b/Frontend/classico/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Frontend/classico/ios/Runner.xcworkspace/contents.xcworkspacedata b/Frontend/classico/ios/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..1d526a1 --- /dev/null +++ b/Frontend/classico/ios/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/Frontend/classico/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/Frontend/classico/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/Frontend/classico/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/Frontend/classico/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/Frontend/classico/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 0000000..f9b0d7c --- /dev/null +++ b/Frontend/classico/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/Frontend/classico/ios/Runner/AppDelegate.swift b/Frontend/classico/ios/Runner/AppDelegate.swift new file mode 100644 index 0000000..70693e4 --- /dev/null +++ b/Frontend/classico/ios/Runner/AppDelegate.swift @@ -0,0 +1,13 @@ +import UIKit +import Flutter + +@UIApplicationMain +@objc class AppDelegate: FlutterAppDelegate { + override func application( + _ application: UIApplication, + didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? + ) -> Bool { + GeneratedPluginRegistrant.register(with: self) + return super.application(application, didFinishLaunchingWithOptions: launchOptions) + } +} diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..d36b1fa --- /dev/null +++ b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,122 @@ +{ + "images" : [ + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@3x.png", + "scale" : "3x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@3x.png", + "scale" : "3x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@3x.png", + "scale" : "3x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@2x.png", + "scale" : "2x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@3x.png", + "scale" : "3x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@1x.png", + "scale" : "1x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@1x.png", + "scale" : "1x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@1x.png", + "scale" : "1x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@2x.png", + "scale" : "2x" + }, + { + "size" : "83.5x83.5", + "idiom" : "ipad", + "filename" : "Icon-App-83.5x83.5@2x.png", + "scale" : "2x" + }, + { + "size" : "1024x1024", + "idiom" : "ios-marketing", + "filename" : "Icon-App-1024x1024@1x.png", + "scale" : "1x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png new file mode 100644 index 0000000..dc9ada4 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png new file mode 100644 index 0000000..7353c41 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png new file mode 100644 index 0000000..797d452 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png new file mode 100644 index 0000000..6ed2d93 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png new file mode 100644 index 0000000..4cd7b00 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png new file mode 100644 index 0000000..fe73094 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png new file mode 100644 index 0000000..321773c Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 0000000..797d452 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png new file mode 100644 index 0000000..502f463 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 0000000..0ec3034 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png new file mode 100644 index 0000000..0ec3034 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png new file mode 100644 index 0000000..e9f5fea Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png new file mode 100644 index 0000000..84ac32a Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png new file mode 100644 index 0000000..8953cba Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png new file mode 100644 index 0000000..0467bf1 Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json new file mode 100644 index 0000000..0bedcf2 --- /dev/null +++ b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json @@ -0,0 +1,23 @@ +{ + "images" : [ + { + "idiom" : "universal", + "filename" : "LaunchImage.png", + "scale" : "1x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@2x.png", + "scale" : "2x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@3x.png", + "scale" : "3x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png new file mode 100644 index 0000000..9da19ea Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png new file mode 100644 index 0000000..9da19ea Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png new file mode 100644 index 0000000..9da19ea Binary files /dev/null and b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png differ diff --git a/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md new file mode 100644 index 0000000..89c2725 --- /dev/null +++ b/Frontend/classico/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md @@ -0,0 +1,5 @@ +# Launch Screen Assets + +You can customize the launch screen with your own desired assets by replacing the image files in this directory. + +You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images. \ No newline at end of file diff --git a/Frontend/classico/ios/Runner/Base.lproj/LaunchScreen.storyboard b/Frontend/classico/ios/Runner/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 0000000..f2e259c --- /dev/null +++ b/Frontend/classico/ios/Runner/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Frontend/classico/ios/Runner/Base.lproj/Main.storyboard b/Frontend/classico/ios/Runner/Base.lproj/Main.storyboard new file mode 100644 index 0000000..f3c2851 --- /dev/null +++ b/Frontend/classico/ios/Runner/Base.lproj/Main.storyboard @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Frontend/classico/ios/Runner/Info.plist b/Frontend/classico/ios/Runner/Info.plist new file mode 100644 index 0000000..9743fdc --- /dev/null +++ b/Frontend/classico/ios/Runner/Info.plist @@ -0,0 +1,49 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleDisplayName + Classico + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + classico + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleSignature + ???? + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + CADisableMinimumFrameDurationOnPhone + + UIApplicationSupportsIndirectInputEvents + + + diff --git a/Frontend/classico/ios/Runner/Runner-Bridging-Header.h b/Frontend/classico/ios/Runner/Runner-Bridging-Header.h new file mode 100644 index 0000000..308a2a5 --- /dev/null +++ b/Frontend/classico/ios/Runner/Runner-Bridging-Header.h @@ -0,0 +1 @@ +#import "GeneratedPluginRegistrant.h" diff --git a/Frontend/classico/ios/RunnerTests/RunnerTests.swift b/Frontend/classico/ios/RunnerTests/RunnerTests.swift new file mode 100644 index 0000000..86a7c3b --- /dev/null +++ b/Frontend/classico/ios/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import Flutter +import UIKit +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/Frontend/classico/lib/main.dart b/Frontend/classico/lib/main.dart new file mode 100644 index 0000000..6fd7c5c --- /dev/null +++ b/Frontend/classico/lib/main.dart @@ -0,0 +1,766 @@ +import 'dart:io'; +import 'package:http/http.dart' as http; +import 'package:flutter/material.dart'; +import 'package:image_picker/image_picker.dart'; +import 'package:flutter_tts/flutter_tts.dart'; +import 'dart:convert'; +import 'package:video_player/video_player.dart'; +// import 'package:audioplayers/audioplayers.dart'; +// import 'package:path_provider/path_provider.dart'; +import 'package:assets_audio_player/assets_audio_player.dart'; +import 'package:speech_to_text/speech_to_text.dart' as stt; + + + +void main() { + runApp(MyApp()); +} +class MyApp extends StatelessWidget { + @override + Widget build(BuildContext context) { + return MaterialApp( + debugShowCheckedModeBanner: false, + title: 'Volunteer App', + theme: ThemeData( + primarySwatch: Colors.blue, + ), + home: VolunteerScreen(), + ); + } +} + +class VolunteerScreen extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Visual Aid App'), + ), + body: Column( + children: [ + Expanded( + child: InkWell( + onTap: () { + _speak("Entered visual assistance page"); + Navigator.push( + context, + MaterialPageRoute( + builder: (context) => VisualAssistancePage()), + ); + }, + child: Container( + color: Colors.lightBlue.shade500, + child: Center( + child: Text( + 'Do you need visual assistance?', + style: TextStyle( + fontSize: 20, + fontWeight: FontWeight.bold, + color: Colors.white), + ), + ), + ), + ), + ), + Expanded( + child: InkWell( + onTap: () { + Navigator.push( + context, + MaterialPageRoute(builder: (context) => VolunteerPage()), + ); + }, + child: Container( + color: Colors.white, + child: Center( + child: Text( + 'I would like to volunteer.', + style: TextStyle( + fontSize: 20, + fontWeight: FontWeight.bold, + color: Colors.black), + ), + ), + ), + ), + ), + ], + ), + ); + } +} + +class VisualAssistancePage extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Visual Assistance Page'), + ), + body: Column( + children: [ + Expanded( + child: InkWell( + onTap: () { + _speak("tap on the upper half for image processing and tap on the below half for video processing"); + Navigator.push( + context, + MaterialPageRoute(builder: (context) => ImageAndVideoProcessing()), + ); + }, + child: Container( + color: Colors.lightBlue, + child: Center( + child: Text( + 'Image and Video Processor', + style: TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + color: Colors.white), + ), + ), + ), + ), + ), + Expanded( + child: InkWell( + onTap: () { + _speak("now you can call your volunteer"); + }, + child: Container( + color: Colors.white, + child: Center( + child: Text( + 'Call My Volunteer', + style: TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + color: Colors.black), + ), + ), + ), + ), + ), + ], + ), + ); + } +} +class ImageAndVideoProcessing extends StatelessWidget { + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text("Image And Video processing ",style: TextStyle(fontSize: 20),), + ), + body: Column( + children: [ + Expanded( + child: InkWell( + onTap: (){ + _speak("tap anywhere on the screen to capture an image"); + Navigator.push( + context, + MaterialPageRoute(builder: (context) => ImageUploadScreen()), + ); + }, + child: Container( + color: Colors.lightBlue, + child: Center( + child: Text( + 'Image Processor', + style: TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + color: Colors.white), + ), + ), + ), + ), + ), + Expanded( + child: InkWell( + onTap: (){ + _speak("tap anywhere on the screen to capture a video"); + Navigator.push( + context, + MaterialPageRoute(builder: (context) => VideoProcessingPage()), + ); + }, + child: Container( + color: Colors.white, + child: Center( + child: Text( + 'Video Processor', + style: TextStyle( + fontSize: 18, + fontWeight: FontWeight.bold, + color: Colors.black), + ), + ), + ), + ), + ), + ], + ), + ); + } +} + + +class VolunteerPage extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Volunteer Page'), + ), + body: Center( + child: Padding( + padding: const EdgeInsets.all(16.0), + child: Column( + mainAxisAlignment: MainAxisAlignment.start, + children: [ + SizedBox(height: 20), + ElevatedButton( + onPressed: () { + Navigator.push( + context, + MaterialPageRoute( + builder: (context) => LoadConversations()), + ); // Navigate back to previous screen + }, + style: ElevatedButton.styleFrom( + minimumSize: Size(300, 50), + backgroundColor: Colors.blue.shade600, + foregroundColor: Colors.white, + textStyle: + TextStyle(fontSize: 16, fontWeight: FontWeight.bold), + ), + child: Text('Images And Caption'), + ), + ], + ), + ), + ), + ); + } +} + +// ------------------------------- +class LoadConversations extends StatefulWidget { + @override + _LoadConversationsState createState() => _LoadConversationsState(); +} + +class _LoadConversationsState extends State { + Future> fetchConversations() async { + final response = + await http.get(Uri.parse('http://192.168.212.229:5000/conversations')); + + if (response.statusCode == 200) { + return jsonDecode(response.body); + } else { + throw Exception('Failed to load conversations'); + } + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Image and Caption Display'), + ), + body: FutureBuilder>( + future: fetchConversations(), + builder: (context, snapshot) { + if (snapshot.connectionState == ConnectionState.waiting) { + return Center(child: CircularProgressIndicator()); + } else if (snapshot.hasError) { + return Center(child: Text('Error: ${snapshot.error}')); + } else { + final data = snapshot.data ?? []; + if (data.isEmpty) { + return Center(child: Text('No conversations found')); + } + return ListView.builder( + itemCount: data.length, + itemBuilder: (context, index) { + final chat = data[index]; + final caption = chat['caption']; + final imageBase64 = chat['image_file']; + final imageBytes = base64Decode(imageBase64); + + return ListTile( + contentPadding: EdgeInsets.all(8.0), + title: Text(caption ?? 'No Caption'), + subtitle: Image.memory(imageBytes), + ); + }, + ); + } + }, + ), + ); + } +} + +// ----------------------------------- + +FlutterTts flutterTts = FlutterTts(); + +Future _speak(String text) async { + await flutterTts.setLanguage("en-US"); + await flutterTts.setPitch(1.0); + await flutterTts.setSpeechRate(0.5); + await flutterTts.speak(text); +} +bool checkHazardous(String s){ + List words = ["knife", "fire", "water","flames","couch","pillow"]; + bool found = words.any((word) => s.contains(word)); + return found; +} +class ImageUploadScreen extends StatefulWidget { + @override + _ImageUploadScreenState createState() => _ImageUploadScreenState(); +} + +class _ImageUploadScreenState extends State { + File? _image; + String _responseMessage = ''; + final AssetsAudioPlayer _assetsAudioPlayer = AssetsAudioPlayer(); + + Future _playAudio(String path) async { + await _assetsAudioPlayer.open( + Audio(path), + autoStart: true, + showNotification: true, + ); + } + + Future _getImageAndUpload() async { + final picker = ImagePicker(); + final pickedFile = await picker.pickImage(source: ImageSource.camera); + + if (pickedFile != null) { + setState(() { + _image = File(pickedFile.path); + }); + await _uploadImage(); + } + } + + Future _uploadImage() async { + if (_image == null) { + _showSnackbar('Please select an image'); + return; + } + + var url = + 'http://192.168.212.229:5000/caption'; // Update with your server URL + + var request = http.MultipartRequest('POST', Uri.parse(url)); + request.files.add(await http.MultipartFile.fromPath('image', _image!.path)); + + try { + var response = await request.send(); + + if (response.statusCode == 200) { + String responseBody = await response.stream.bytesToString(); + setState(() { + _responseMessage = responseBody; + _speak(_responseMessage); + }); + if(checkHazardous(responseBody)){ + await _playAudio("assets/sound/Alarm.mp3"); + } + + _showSnackbar('Image uploaded successfully :)'); + } else { + _showSnackbar( + 'Failed to upload image. Status code: ${response.statusCode}'); + } + } catch (e) { + _showSnackbar('Error uploading image: $e'); + } + } + + void _showSnackbar(String message) { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar(content: Text(message)), + ); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Image Processing'), + ), + body: InkWell( + onTap: _getImageAndUpload, + child: Center( + child: Padding( + padding: const EdgeInsets.all(16.0), + child: SingleChildScrollView( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + _image == null + ? Text('No image selected', + style: TextStyle(fontSize: 18, color: Colors.grey)) + : Container( + constraints: BoxConstraints( + maxWidth: MediaQuery.of(context).size.width * 0.8, + maxHeight: MediaQuery.of(context).size.height * 0.4, + ), + child: Image.file( + _image!, + fit: BoxFit.contain, + ), + ), + SizedBox(height: 20), + Container( + width: 300, + child: Text( + _responseMessage, + style: TextStyle(fontSize: 18, color: Colors.black), + textAlign: TextAlign.center, + ), + ), + ], + ), + ), + ), + ), + ), + ); + } +} +class VideoProcessingPage extends StatefulWidget { + @override + _VideoProcessingPageState createState() => _VideoProcessingPageState(); +} + +class _VideoProcessingPageState extends State { + VideoPlayerController? _videoPlayerController; + String? videoPath; + String _responseMessage = ''; + late stt.SpeechToText _speech; + bool _isListening = false; + bool _isSpeaking = false; + + late List storedPassages; + + late FlutterTts flutterTts; + + @override + void initState() { + super.initState(); + _speech = stt.SpeechToText(); + flutterTts = FlutterTts(); + flutterTts.setCompletionHandler(() { + setState(() { + _isSpeaking = false; + }); + }); + } + + @override + void dispose() { + _videoPlayerController?.dispose(); + super.dispose(); + } + + Future _pickVideo() async { + final picker = ImagePicker(); + final pickedFile = await picker.pickVideo(source: ImageSource.gallery); + + if (pickedFile != null) { + setState(() { + videoPath = pickedFile.path; + _videoPlayerController = VideoPlayerController.file(File(videoPath!)) + ..initialize().then((_) { + setState(() {}); + _videoPlayerController?.play(); + }); + }); + + await _uploadVideo(); + } + } + + Future _uploadVideo() async { + if (videoPath == null) return; + + var request = http.MultipartRequest( + 'POST', + Uri.parse('http://192.168.212.229:5002/process_video'), + ); + request.files.add(await http.MultipartFile.fromPath('video', videoPath!)); + var response = await request.send(); + + if (response.statusCode == 200) { + String responseBody = await response.stream.bytesToString(); + setState(() { + _responseMessage = responseBody; + }); + // Split the response message into sentences using multiple delimiters and optional whitespace + storedPassages = responseBody.split(RegExp(r'[.!?]\s*')); + + // Print the sentences to verify + print(responseBody); + for (int i = 0; i < storedPassages.length; i++) { + print('Sentence $i: "${storedPassages[i].trim()}"'); + } + await _speak(_responseMessage); + await _askForQueries(); // Wait for queries to finish + print('Video uploaded successfully'); + } else { + setState(() { + _responseMessage = 'Video upload failed'; + }); + await _speak(_responseMessage); + print('Video upload failed'); + } + } + + Future _speak(String text) async { + await flutterTts.setLanguage("en-US"); + await flutterTts.setPitch(1.0); + setState(() { + _isSpeaking = true; + }); + await flutterTts.speak(text); + while (_isSpeaking) { + await Future.delayed(Duration(milliseconds: 100)); + } + } + + Future _askForQueries() async { + bool validResponse = false; + while (!validResponse) { + await _speak("Do you have any queries? Please say yes or no."); + validResponse = await _listenForResponse(); + } + } + + Future _listenForResponse() async { + bool available = await _speech.initialize( + onStatus: (val) => print('onStatus: $val'), + onError: (val) => print('onError: $val'), + ); + + if (available) { + setState(() => _isListening = true); + String result = ''; + bool validResponse = false; + _speech.listen( + onResult: (val) => setState(() { + result = val.recognizedWords.toLowerCase(); + _isListening = false; + validResponse = _handleResponse(result); + }), + ); + while (_isListening) { + await Future.delayed(Duration(milliseconds: 100)); + } + return validResponse; + } else { + setState(() => _isListening = false); + return false; + } + } + + bool _handleResponse(String response) { + print("Response received: $response"); + if (response == 'yes' || response == 'no') { + if (response.contains('yes')) { + _handleYesResponse(); + } else if (response.contains('no')) { + return true; + } else { + print("Invalid response: $response"); + return false; + } + return true; + } else { + _speak("I didn't catch that. Please say yes or no."); + return false; + } + } + + void _handleYesResponse() async { + bool furtherQueries = true; + while (furtherQueries) { + await _speak("Please state your query."); + String query = await _getQuery(); + print("User query: $query"); + if (query.isNotEmpty) { + await _makeApiRequest(query); + await _speak("Do you have any further queries? Please say yes or no."); + furtherQueries = await _listenForFurtherQueries(); + } else { + furtherQueries = false; + } + } + } + + Future _getQuery() async { + bool available = await _speech.initialize( + onStatus: (val) => print('onStatus: $val'), + onError: (val) => print('onError: $val'), + ); + + if (available) { + // await _speak("Please state your query."); + setState(() => _isListening = true); + String result = ''; + _speech.listen( + onResult: (val) => setState(() { + result = val.recognizedWords.toLowerCase(); + if (val.finalResult) { + _isListening = false; + } + }), + listenFor: Duration(seconds: 10), + ); + + while (_isListening) { + await Future.delayed(Duration(milliseconds: 100)); + } + + return result.trim(); + } else { + setState(() => _isListening = false); + return ''; + } + } + + Future _makeApiRequest(String query) async { + try { + var request = http.Request( + 'POST', + Uri.parse('http://192.168.212.229:5003/api/query'), + ); + request.headers['Content-Type'] = 'application/json'; + request.body = jsonEncode({ + 'query': query, + 'stored_passages': storedPassages, + }); + var response = await request.send(); + + if (response.statusCode == 200) { + String responseBody = await response.stream.bytesToString(); + print("API Response: $responseBody"); + List answers = _parseAnswers(responseBody); + setState(() { + _responseMessage = answers.join("\n"); + }); + print(_responseMessage); + await _speak(_responseMessage); + } else { + setState(() { + _responseMessage = 'Query processing failed'; + }); + await _speak(_responseMessage); + } + } catch (e) { + setState(() { + _responseMessage = 'An error occurred: $e'; + }); + await _speak( + "Error occurred while querying... Could not complete your response"); + print('An error occurred: $e'); + } + } + + List _parseAnswers(String responseBody) { + Map jsonResponse = jsonDecode(responseBody); + List answers = List.from(jsonResponse['answers']); + return answers; + } + + Future _listenForFurtherQueries() async { + bool available = await _speech.initialize( + onStatus: (val) => print('onStatus: $val'), + onError: (val) => print('onError: $val'), + ); + + if (available) { + setState(() => _isListening = true); + String result = ''; + _speech.listen( + onResult: (val) => setState(() { + result = val.recognizedWords.toLowerCase(); + _isListening = false; + }), + ); + while (_isListening) { + await Future.delayed(Duration(milliseconds: 100)); + } + if (result.contains('yes')) { + return true; + } else if (result.contains('no')) { + return true; + } else { + print("Invalid response: $result"); + return await _listenForFurtherQueries(); + } + } else { + setState(() => _isListening = false); + return false; + } + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Video Processing'), + ), + body: InkWell( + onTap: _pickVideo, + child: Center( + child: Padding( + padding: const EdgeInsets.all(16.0), + child: SingleChildScrollView( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + if (_videoPlayerController == null || + !_videoPlayerController!.value.isInitialized) + Text( + 'No video selected', + style: TextStyle(fontSize: 18, color: Colors.grey), + ) + else + Container( + constraints: BoxConstraints( + maxWidth: MediaQuery.of(context).size.width * 0.8, + maxHeight: MediaQuery.of(context).size.height * 0.4, + ), + child: AspectRatio( + aspectRatio: _videoPlayerController!.value.aspectRatio, + child: VideoPlayer(_videoPlayerController!), + ), + ), + SizedBox(height: 20), + Container( + width: 300, + child: Text( + _responseMessage, + style: TextStyle(fontSize: 18, color: Colors.black), + textAlign: TextAlign.center, + ), + ), + ], + ), + ), + ), + ), + ), + ); + } +} \ No newline at end of file diff --git a/Frontend/classico/lib/video.dart b/Frontend/classico/lib/video.dart new file mode 100644 index 0000000..c2acdac --- /dev/null +++ b/Frontend/classico/lib/video.dart @@ -0,0 +1,335 @@ +import 'dart:io'; +import 'package:http/http.dart' as http; +import 'package:flutter/material.dart'; +import 'package:image_picker/image_picker.dart'; +import 'package:flutter_tts/flutter_tts.dart'; +import 'dart:convert'; +import 'package:video_player/video_player.dart'; +import 'package:speech_to_text/speech_to_text.dart' as stt; + +class VideoProcessingPage extends StatefulWidget { + @override + _VideoProcessingPageState createState() => _VideoProcessingPageState(); +} + +class _VideoProcessingPageState extends State { + VideoPlayerController? _videoPlayerController; + String? videoPath; + String _responseMessage = ''; + late stt.SpeechToText _speech; + bool _isListening = false; + bool _isSpeaking = false; + + late List storedPassages; + + late FlutterTts flutterTts; + + @override + void initState() { + super.initState(); + _speech = stt.SpeechToText(); + flutterTts = FlutterTts(); + flutterTts.setCompletionHandler(() { + setState(() { + _isSpeaking = false; + }); + }); + } + + @override + void dispose() { + _videoPlayerController?.dispose(); + super.dispose(); + } + + Future _pickVideo() async { + final picker = ImagePicker(); + final pickedFile = await picker.pickVideo(source: ImageSource.gallery); + + if (pickedFile != null) { + setState(() { + videoPath = pickedFile.path; + _videoPlayerController = VideoPlayerController.file(File(videoPath!)) + ..initialize().then((_) { + setState(() {}); + _videoPlayerController?.play(); + }); + }); + + await _uploadVideo(); + } + } + + Future _uploadVideo() async { + if (videoPath == null) return; + + var request = http.MultipartRequest( + 'POST', + Uri.parse('http://192.168.0.103:5002/process_video'), + ); + request.files.add(await http.MultipartFile.fromPath('video', videoPath!)); + var response = await request.send(); + + if (response.statusCode == 200) { + String responseBody = await response.stream.bytesToString(); + setState(() { + _responseMessage = responseBody; + }); + // Split the response message into sentences using multiple delimiters and optional whitespace + storedPassages = responseBody.split(RegExp(r'[.!?]\s*')); + + // Print the sentences to verify + print(responseBody); + for (int i = 0; i < storedPassages.length; i++) { + print('Sentence $i: "${storedPassages[i].trim()}"'); + } + await _speak(_responseMessage); + await _askForQueries(); // Wait for queries to finish + print('Video uploaded successfully'); + } else { + setState(() { + _responseMessage = 'Video upload failed'; + }); + await _speak(_responseMessage); + print('Video upload failed'); + } + } + + Future _speak(String text) async { + await flutterTts.setLanguage("en-US"); + await flutterTts.setPitch(1.0); + setState(() { + _isSpeaking = true; + }); + await flutterTts.speak(text); + while (_isSpeaking) { + await Future.delayed(Duration(milliseconds: 100)); + } + } + + Future _askForQueries() async { + bool validResponse = false; + while (!validResponse) { + await _speak("Do you have any queries? Please say yes or no."); + validResponse = await _listenForResponse(); + } + } + + Future _listenForResponse() async { + bool available = await _speech.initialize( + onStatus: (val) => print('onStatus: $val'), + onError: (val) => print('onError: $val'), + ); + + if (available) { + setState(() => _isListening = true); + String result = ''; + bool validResponse = false; + _speech.listen( + onResult: (val) => setState(() { + result = val.recognizedWords.toLowerCase(); + _isListening = false; + validResponse = _handleResponse(result); + }), + ); + while (_isListening) { + await Future.delayed(Duration(milliseconds: 100)); + } + return validResponse; + } else { + setState(() => _isListening = false); + return false; + } + } + + bool _handleResponse(String response) { + print("Response received: $response"); + if (response == 'yes' || response == 'no') { + if (response.contains('yes')) { + _handleYesResponse(); + } else if (response.contains('no')) { + return true; + } else { + print("Invalid response: $response"); + return false; + } + return true; + } else { + _speak("I didn't catch that. Please say yes or no."); + return false; + } + } + + void _handleYesResponse() async { + bool furtherQueries = true; + while (furtherQueries) { + await _speak("Please state your query."); + String query = await _getQuery(); + print("User query: $query"); + if (query.isNotEmpty) { + await _makeApiRequest(query); + await _speak("Do you have any further queries? Please say yes or no."); + furtherQueries = await _listenForFurtherQueries(); + } else { + furtherQueries = false; + } + } + } + + Future _getQuery() async { + bool available = await _speech.initialize( + onStatus: (val) => print('onStatus: $val'), + onError: (val) => print('onError: $val'), + ); + + if (available) { + // await _speak("Please state your query."); + setState(() => _isListening = true); + String result = ''; + _speech.listen( + onResult: (val) => setState(() { + result = val.recognizedWords.toLowerCase(); + if (val.finalResult) { + _isListening = false; + } + }), + listenFor: Duration(seconds: 10), + ); + + while (_isListening) { + await Future.delayed(Duration(milliseconds: 100)); + } + + return result.trim(); + } else { + setState(() => _isListening = false); + return ''; + } + } + + Future _makeApiRequest(String query) async { + try { + var request = http.Request( + 'POST', + Uri.parse('http://192.168.0.103:5003/api/query'), + ); + request.headers['Content-Type'] = 'application/json'; + request.body = jsonEncode({ + 'query': query, + 'stored_passages': storedPassages, + }); + var response = await request.send(); + + if (response.statusCode == 200) { + String responseBody = await response.stream.bytesToString(); + print("API Response: $responseBody"); + List answers = _parseAnswers(responseBody); + setState(() { + _responseMessage = answers.join("\n"); + }); + print(_responseMessage); + await _speak(_responseMessage); + } else { + setState(() { + _responseMessage = 'Query processing failed'; + }); + await _speak(_responseMessage); + } + } catch (e) { + setState(() { + _responseMessage = 'An error occurred: $e'; + }); + await _speak( + "Error occurred while querying... Could not complete your response"); + print('An error occurred: $e'); + } + } + + List _parseAnswers(String responseBody) { + Map jsonResponse = jsonDecode(responseBody); + List answers = List.from(jsonResponse['answers']); + return answers; + } + + Future _listenForFurtherQueries() async { + bool available = await _speech.initialize( + onStatus: (val) => print('onStatus: $val'), + onError: (val) => print('onError: $val'), + ); + + if (available) { + setState(() => _isListening = true); + String result = ''; + _speech.listen( + onResult: (val) => setState(() { + result = val.recognizedWords.toLowerCase(); + _isListening = false; + }), + ); + while (_isListening) { + await Future.delayed(Duration(milliseconds: 100)); + } + if (result.contains('yes')) { + return true; + } else if (result.contains('no')) { + return true; + } else { + print("Invalid response: $result"); + return await _listenForFurtherQueries(); + } + } else { + setState(() => _isListening = false); + return false; + } + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Video Processing'), + ), + body: InkWell( + onTap: _pickVideo, + child: Center( + child: Padding( + padding: const EdgeInsets.all(16.0), + child: SingleChildScrollView( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + if (_videoPlayerController == null || + !_videoPlayerController!.value.isInitialized) + Text( + 'No video selected', + style: TextStyle(fontSize: 18, color: Colors.grey), + ) + else + Container( + constraints: BoxConstraints( + maxWidth: MediaQuery.of(context).size.width * 0.8, + maxHeight: MediaQuery.of(context).size.height * 0.4, + ), + child: AspectRatio( + aspectRatio: _videoPlayerController!.value.aspectRatio, + child: VideoPlayer(_videoPlayerController!), + ), + ), + SizedBox(height: 20), + Container( + width: 300, + child: Text( + _responseMessage, + style: TextStyle(fontSize: 18, color: Colors.black), + textAlign: TextAlign.center, + ), + ), + ], + ), + ), + ), + ), + ), + ); + } +} \ No newline at end of file diff --git a/Frontend/classico/lib/visualaid.dart b/Frontend/classico/lib/visualaid.dart new file mode 100644 index 0000000..f919a36 --- /dev/null +++ b/Frontend/classico/lib/visualaid.dart @@ -0,0 +1,267 @@ +import 'dart:io'; +import 'package:http/http.dart' as http; +import 'package:flutter/material.dart'; +import 'package:image_picker/image_picker.dart'; + + +void main() { + runApp(MyApp()); +} +class MyApp extends StatelessWidget { + @override + Widget build(BuildContext context) { + return MaterialApp( + debugShowCheckedModeBanner: false, + title: 'Volunteer App', + theme: ThemeData( + primarySwatch: Colors.blue, + ), + home: VolunteerScreen(), + ); + } +} + +class VolunteerScreen extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Visual Aid App'), + ), + body: Center( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + ElevatedButton( + onPressed: () { + Navigator.push( + context, + MaterialPageRoute(builder: (context) => VisualAssistancePage()), + ); + }, + style: ElevatedButton.styleFrom( + minimumSize: Size(300, 100), + ), + child: Text( + 'Do you need visual assistance?', + style: TextStyle(color: Colors.black,fontSize: 20,), + ), + ), + SizedBox(height: 100,), + ElevatedButton( + onPressed: () { + Navigator.push( + context, + MaterialPageRoute(builder: (context) => VolunteerPage()), + ); + }, + style: ElevatedButton.styleFrom( + minimumSize: Size(300, 100), + ), + child: Text( + 'I would like to volunteer.', + style: TextStyle(color: Colors.black,fontSize: 20,), + ), + ), + ], + ), + ), + ); + } +} + +class VisualAssistancePage extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Visual Assistance Page'), + ), + body: Center( + child: Container( + width: 300, + child: Column( + mainAxisAlignment: MainAxisAlignment.start, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + SizedBox(height: 100,), + ElevatedButton( + onPressed: () { + // Placeholder: Implement functionality for Image and Video Processor + Navigator.push( + context, + MaterialPageRoute(builder: (context)=>ImageUploadScreen()), + ); + }, + style: ElevatedButton.styleFrom( + minimumSize: Size(200, 50), + ), + child: Text('Image and Video Processor', + style: TextStyle(color: Colors.black,fontSize: 18,), + ), + ), + SizedBox(height: 20), + ElevatedButton( + onPressed: () { + // Placeholder: Implement functionality for Talk with Chat bot + print('Initiating Chat bot...'); + }, + child: Text('Talk with Chat bot', + style: TextStyle(color: Colors.black,fontSize: 18,), + ), + ), + SizedBox(height: 20), + ElevatedButton( + onPressed: () { + // Placeholder: Implement functionality for Call My Volunteer + print('Calling My Volunteer...'); + }, + child: Text('Call My Volunteer', + style: TextStyle(color: Colors.black,fontSize: 18,), + ), + ), + ], + ), + ), + ), + ); + } +} + +// ********************************************** + +class VolunteerPage extends StatelessWidget { + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Volunteer Page'), + ), + body: Center( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Text('This is the Volunteer Page'), + SizedBox(height: 20), + ElevatedButton( + onPressed: () { + Navigator.pop(context); // Navigate back to previous screen + }, + child: Text('Go Back'), + ), + ], + ), + ), + ); + } +} +// ********************************************** +class ImageUploadScreen extends StatefulWidget { + @override + _ImageUploadScreenState createState() => _ImageUploadScreenState(); +} + +class _ImageUploadScreenState extends State { + File? _image; + String _responseMessage = ''; + + Future _getImage(ImageSource source) async { + final picker = ImagePicker(); + final pickedFile = await picker.pickImage(source: source); + + setState(() { + _image = pickedFile != null ? File(pickedFile.path) : null; + }); + } + + Future _uploadImage() async { + if (_image == null) { + _showSnackbar('Please select an image'); + return; + } + + // API endpoint URL + var url = 'http://10.0.2.2:5000/caption'; // Update with your server URL + + // Create a multipart request + var request = http.MultipartRequest('POST', Uri.parse(url)); + + // Add image to the request + request.files.add(await http.MultipartFile.fromPath('image', _image!.path)); + + try { + // Send request + var response = await request.send(); + + if (response.statusCode == 200) { + // Image uploaded successfully + String responseBody = await response.stream.bytesToString(); + setState(() { + _responseMessage = responseBody; + }); + _showSnackbar('Image uploaded successfully :)'); + } else { + // Handle other status codes + _showSnackbar('Failed to upload image. Status code: ${response.statusCode}'); + } + } catch (e) { + // Handle exceptions + _showSnackbar('Error uploading image: $e'); + } + } + + void _showSnackbar(String message) { + ScaffoldMessenger.of(context).showSnackBar( + SnackBar(content: Text(message)), + ); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar( + title: Text('Image and Video Processing'), + ), + body: Center( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + _image == null + ? Text('No image selected') + : Image.file(_image!), + SizedBox(height: 20), + Container( + width: 300, + child: Text( + _responseMessage, + style: TextStyle(fontSize: 25, color: Colors.black), + ), + ), + ], + ), + ), + floatingActionButton: Column( + mainAxisAlignment: MainAxisAlignment.end, + children: [ + FloatingActionButton( + onPressed: () => _getImage(ImageSource.camera), + tooltip: 'Capture Image', + child: Icon(Icons.camera_alt), + ), + SizedBox(height: 16), + FloatingActionButton( + onPressed: () => _getImage(ImageSource.gallery), // Specify ImageSource.gallery + tooltip: 'Select Image', + child: Icon(Icons.add_a_photo), + ), + SizedBox(height: 16), + FloatingActionButton( + onPressed: _uploadImage, + tooltip: 'Upload Image', + child: Icon(Icons.cloud_upload), + ), + ], + ), + ); + } +} diff --git a/Frontend/classico/linux/.gitignore b/Frontend/classico/linux/.gitignore new file mode 100644 index 0000000..d3896c9 --- /dev/null +++ b/Frontend/classico/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/Frontend/classico/linux/CMakeLists.txt b/Frontend/classico/linux/CMakeLists.txt new file mode 100644 index 0000000..05482b1 --- /dev/null +++ b/Frontend/classico/linux/CMakeLists.txt @@ -0,0 +1,145 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.10) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "classico") +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "com.example.classico") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Define the application target. To change its name, change BINARY_NAME above, +# not the value here, or `flutter run` will no longer work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/Frontend/classico/linux/flutter/CMakeLists.txt b/Frontend/classico/linux/flutter/CMakeLists.txt new file mode 100644 index 0000000..d5bd016 --- /dev/null +++ b/Frontend/classico/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/Frontend/classico/linux/flutter/generated_plugin_registrant.cc b/Frontend/classico/linux/flutter/generated_plugin_registrant.cc new file mode 100644 index 0000000..e0c16cd --- /dev/null +++ b/Frontend/classico/linux/flutter/generated_plugin_registrant.cc @@ -0,0 +1,19 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + +#include +#include + +void fl_register_plugins(FlPluginRegistry* registry) { + g_autoptr(FlPluginRegistrar) audioplayers_linux_registrar = + fl_plugin_registry_get_registrar_for_plugin(registry, "AudioplayersLinuxPlugin"); + audioplayers_linux_plugin_register_with_registrar(audioplayers_linux_registrar); + g_autoptr(FlPluginRegistrar) file_selector_linux_registrar = + fl_plugin_registry_get_registrar_for_plugin(registry, "FileSelectorPlugin"); + file_selector_plugin_register_with_registrar(file_selector_linux_registrar); +} diff --git a/Frontend/classico/linux/flutter/generated_plugin_registrant.h b/Frontend/classico/linux/flutter/generated_plugin_registrant.h new file mode 100644 index 0000000..e0f0a47 --- /dev/null +++ b/Frontend/classico/linux/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void fl_register_plugins(FlPluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/Frontend/classico/linux/flutter/generated_plugins.cmake b/Frontend/classico/linux/flutter/generated_plugins.cmake new file mode 100644 index 0000000..a77328d --- /dev/null +++ b/Frontend/classico/linux/flutter/generated_plugins.cmake @@ -0,0 +1,25 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + audioplayers_linux + file_selector_linux +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/Frontend/classico/linux/main.cc b/Frontend/classico/linux/main.cc new file mode 100644 index 0000000..e7c5c54 --- /dev/null +++ b/Frontend/classico/linux/main.cc @@ -0,0 +1,6 @@ +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/Frontend/classico/linux/my_application.cc b/Frontend/classico/linux/my_application.cc new file mode 100644 index 0000000..0333381 --- /dev/null +++ b/Frontend/classico/linux/my_application.cc @@ -0,0 +1,124 @@ +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "classico"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "classico"); + } + + gtk_window_set_default_size(window, 1280, 720); + gtk_widget_show(GTK_WIDGET(window)); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GApplication::startup. +static void my_application_startup(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application startup. + + G_APPLICATION_CLASS(my_application_parent_class)->startup(application); +} + +// Implements GApplication::shutdown. +static void my_application_shutdown(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application shutdown. + + G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application); +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line; + G_APPLICATION_CLASS(klass)->startup = my_application_startup; + G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, + "flags", G_APPLICATION_NON_UNIQUE, + nullptr)); +} diff --git a/Frontend/classico/linux/my_application.h b/Frontend/classico/linux/my_application.h new file mode 100644 index 0000000..72271d5 --- /dev/null +++ b/Frontend/classico/linux/my_application.h @@ -0,0 +1,18 @@ +#ifndef FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/Frontend/classico/macos/.gitignore b/Frontend/classico/macos/.gitignore new file mode 100644 index 0000000..746adbb --- /dev/null +++ b/Frontend/classico/macos/.gitignore @@ -0,0 +1,7 @@ +# Flutter-related +**/Flutter/ephemeral/ +**/Pods/ + +# Xcode-related +**/dgph +**/xcuserdata/ diff --git a/Frontend/classico/macos/Flutter/Flutter-Debug.xcconfig b/Frontend/classico/macos/Flutter/Flutter-Debug.xcconfig new file mode 100644 index 0000000..c2efd0b --- /dev/null +++ b/Frontend/classico/macos/Flutter/Flutter-Debug.xcconfig @@ -0,0 +1 @@ +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/Frontend/classico/macos/Flutter/Flutter-Release.xcconfig b/Frontend/classico/macos/Flutter/Flutter-Release.xcconfig new file mode 100644 index 0000000..c2efd0b --- /dev/null +++ b/Frontend/classico/macos/Flutter/Flutter-Release.xcconfig @@ -0,0 +1 @@ +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/Frontend/classico/macos/Flutter/GeneratedPluginRegistrant.swift b/Frontend/classico/macos/Flutter/GeneratedPluginRegistrant.swift new file mode 100644 index 0000000..8086bdb --- /dev/null +++ b/Frontend/classico/macos/Flutter/GeneratedPluginRegistrant.swift @@ -0,0 +1,26 @@ +// +// Generated file. Do not edit. +// + +import FlutterMacOS +import Foundation + +import assets_audio_player +import assets_audio_player_web +import audioplayers_darwin +import file_selector_macos +import flutter_tts +import path_provider_foundation +import speech_to_text_macos +import video_player_avfoundation + +func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { + AssetsAudioPlayerPlugin.register(with: registry.registrar(forPlugin: "AssetsAudioPlayerPlugin")) + AssetsAudioPlayerWebPlugin.register(with: registry.registrar(forPlugin: "AssetsAudioPlayerWebPlugin")) + AudioplayersDarwinPlugin.register(with: registry.registrar(forPlugin: "AudioplayersDarwinPlugin")) + FileSelectorPlugin.register(with: registry.registrar(forPlugin: "FileSelectorPlugin")) + FlutterTtsPlugin.register(with: registry.registrar(forPlugin: "FlutterTtsPlugin")) + PathProviderPlugin.register(with: registry.registrar(forPlugin: "PathProviderPlugin")) + SpeechToTextMacosPlugin.register(with: registry.registrar(forPlugin: "SpeechToTextMacosPlugin")) + FVPVideoPlayerPlugin.register(with: registry.registrar(forPlugin: "FVPVideoPlayerPlugin")) +} diff --git a/Frontend/classico/macos/Runner.xcodeproj/project.pbxproj b/Frontend/classico/macos/Runner.xcodeproj/project.pbxproj new file mode 100644 index 0000000..3e7e09c --- /dev/null +++ b/Frontend/classico/macos/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,705 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXAggregateTarget section */ + 33CC111A2044C6BA0003C045 /* Flutter Assemble */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */; + buildPhases = ( + 33CC111E2044C6BF0003C045 /* ShellScript */, + ); + dependencies = ( + ); + name = "Flutter Assemble"; + productName = FLX; + }; +/* End PBXAggregateTarget section */ + +/* Begin PBXBuildFile section */ + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C80D7294CF71000263BE5 /* RunnerTests.swift */; }; + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; }; + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; }; + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; }; + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; }; + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC10EC2044A3C60003C045; + remoteInfo = Runner; + }; + 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC111A2044C6BA0003C045; + remoteInfo = FLX; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 33CC110E2044A8840003C045 /* Bundle Framework */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Bundle Framework"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D7294CF71000263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = ""; }; + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = ""; }; + 33CC10ED2044A3C60003C045 /* classico.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "classico.app"; sourceTree = BUILT_PRODUCTS_DIR; }; + 33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = ""; }; + 33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = ""; }; + 33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = ""; }; + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = ""; }; + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = ""; }; + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = ""; }; + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = ""; }; + 33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = ""; }; + 33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = ""; }; + 33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 331C80D2294CF70F00263BE5 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EA2044A3C60003C045 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 331C80D6294CF71000263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C80D7294CF71000263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 33BA886A226E78AF003329D5 /* Configs */ = { + isa = PBXGroup; + children = ( + 33E5194F232828860026EE4D /* AppInfo.xcconfig */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */, + ); + path = Configs; + sourceTree = ""; + }; + 33CC10E42044A3C60003C045 = { + isa = PBXGroup; + children = ( + 33FAB671232836740065AC1E /* Runner */, + 33CEB47122A05771004F2AC0 /* Flutter */, + 331C80D6294CF71000263BE5 /* RunnerTests */, + 33CC10EE2044A3C60003C045 /* Products */, + D73912EC22F37F3D000D13A0 /* Frameworks */, + ); + sourceTree = ""; + }; + 33CC10EE2044A3C60003C045 /* Products */ = { + isa = PBXGroup; + children = ( + 33CC10ED2044A3C60003C045 /* classico.app */, + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 33CC11242044D66E0003C045 /* Resources */ = { + isa = PBXGroup; + children = ( + 33CC10F22044A3C60003C045 /* Assets.xcassets */, + 33CC10F42044A3C60003C045 /* MainMenu.xib */, + 33CC10F72044A3C60003C045 /* Info.plist */, + ); + name = Resources; + path = ..; + sourceTree = ""; + }; + 33CEB47122A05771004F2AC0 /* Flutter */ = { + isa = PBXGroup; + children = ( + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */, + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */, + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */, + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */, + ); + path = Flutter; + sourceTree = ""; + }; + 33FAB671232836740065AC1E /* Runner */ = { + isa = PBXGroup; + children = ( + 33CC10F02044A3C60003C045 /* AppDelegate.swift */, + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */, + 33E51913231747F40026EE4D /* DebugProfile.entitlements */, + 33E51914231749380026EE4D /* Release.entitlements */, + 33CC11242044D66E0003C045 /* Resources */, + 33BA886A226E78AF003329D5 /* Configs */, + ); + path = Runner; + sourceTree = ""; + }; + D73912EC22F37F3D000D13A0 /* Frameworks */ = { + isa = PBXGroup; + children = ( + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C80D4294CF70F00263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 331C80D1294CF70F00263BE5 /* Sources */, + 331C80D2294CF70F00263BE5 /* Frameworks */, + 331C80D3294CF70F00263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C80DA294CF71000263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C80D5294CF71000263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 33CC10EC2044A3C60003C045 /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 33CC10E92044A3C60003C045 /* Sources */, + 33CC10EA2044A3C60003C045 /* Frameworks */, + 33CC10EB2044A3C60003C045 /* Resources */, + 33CC110E2044A8840003C045 /* Bundle Framework */, + 3399D490228B24CF009A79C7 /* ShellScript */, + ); + buildRules = ( + ); + dependencies = ( + 33CC11202044C79F0003C045 /* PBXTargetDependency */, + ); + name = Runner; + productName = Runner; + productReference = 33CC10ED2044A3C60003C045 /* classico.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 33CC10E52044A3C60003C045 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastSwiftUpdateCheck = 0920; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C80D4294CF70F00263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 33CC10EC2044A3C60003C045; + }; + 33CC10EC2044A3C60003C045 = { + CreatedOnToolsVersion = 9.2; + LastSwiftMigration = 1100; + ProvisioningStyle = Automatic; + SystemCapabilities = { + com.apple.Sandbox = { + enabled = 1; + }; + }; + }; + 33CC111A2044C6BA0003C045 = { + CreatedOnToolsVersion = 9.2; + ProvisioningStyle = Manual; + }; + }; + }; + buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 33CC10E42044A3C60003C045; + productRefGroup = 33CC10EE2044A3C60003C045 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 33CC10EC2044A3C60003C045 /* Runner */, + 331C80D4294CF70F00263BE5 /* RunnerTests */, + 33CC111A2044C6BA0003C045 /* Flutter Assemble */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C80D3294CF70F00263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EB2044A3C60003C045 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */, + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 3399D490228B24CF009A79C7 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n"; + }; + 33CC111E2044C6BF0003C045 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + Flutter/ephemeral/FlutterInputs.xcfilelist, + ); + inputPaths = ( + Flutter/ephemeral/tripwire, + ); + outputFileListPaths = ( + Flutter/ephemeral/FlutterOutputs.xcfilelist, + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire"; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C80D1294CF70F00263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10E92044A3C60003C045 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */, + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */, + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C80DA294CF71000263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC10EC2044A3C60003C045 /* Runner */; + targetProxy = 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */; + }; + 33CC11202044C79F0003C045 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */; + targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 33CC10F42044A3C60003C045 /* MainMenu.xib */ = { + isa = PBXVariantGroup; + children = ( + 33CC10F52044A3C60003C045 /* Base */, + ); + name = MainMenu.xib; + path = Runner; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 331C80DB294CF71000263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/classico.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/classico"; + }; + name = Debug; + }; + 331C80DC294CF71000263BE5 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/classico.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/classico"; + }; + name = Release; + }; + 331C80DD294CF71000263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = com.example.classico.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/classico.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/classico"; + }; + name = Profile; + }; + 338D0CE9231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Profile; + }; + 338D0CEA231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Profile; + }; + 338D0CEB231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Profile; + }; + 33CC10F92044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 33CC10FA2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.14; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Release; + }; + 33CC10FC2044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + }; + name = Debug; + }; + 33CC10FD2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Release; + }; + 33CC111C2044C6BA0003C045 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 33CC111D2044C6BA0003C045 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C80DB294CF71000263BE5 /* Debug */, + 331C80DC294CF71000263BE5 /* Release */, + 331C80DD294CF71000263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10F92044A3C60003C045 /* Debug */, + 33CC10FA2044A3C60003C045 /* Release */, + 338D0CE9231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10FC2044A3C60003C045 /* Debug */, + 33CC10FD2044A3C60003C045 /* Release */, + 338D0CEA231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC111C2044C6BA0003C045 /* Debug */, + 33CC111D2044C6BA0003C045 /* Release */, + 338D0CEB231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 33CC10E52044A3C60003C045 /* Project object */; +} diff --git a/Frontend/classico/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/Frontend/classico/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/Frontend/classico/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/Frontend/classico/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/Frontend/classico/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 0000000..5c4ebdd --- /dev/null +++ b/Frontend/classico/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Frontend/classico/macos/Runner.xcworkspace/contents.xcworkspacedata b/Frontend/classico/macos/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..1d526a1 --- /dev/null +++ b/Frontend/classico/macos/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/Frontend/classico/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/Frontend/classico/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/Frontend/classico/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/Frontend/classico/macos/Runner/AppDelegate.swift b/Frontend/classico/macos/Runner/AppDelegate.swift new file mode 100644 index 0000000..d53ef64 --- /dev/null +++ b/Frontend/classico/macos/Runner/AppDelegate.swift @@ -0,0 +1,9 @@ +import Cocoa +import FlutterMacOS + +@NSApplicationMain +class AppDelegate: FlutterAppDelegate { + override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { + return true + } +} diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..a2ec33f --- /dev/null +++ b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,68 @@ +{ + "images" : [ + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_16.png", + "scale" : "1x" + }, + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "2x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "1x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_64.png", + "scale" : "2x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_128.png", + "scale" : "1x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "2x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "1x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "2x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "1x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_1024.png", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png new file mode 100644 index 0000000..82b6f9d Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png differ diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png new file mode 100644 index 0000000..13b35eb Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png differ diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png new file mode 100644 index 0000000..0a3f5fa Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png differ diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png new file mode 100644 index 0000000..bdb5722 Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png differ diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png new file mode 100644 index 0000000..f083318 Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png differ diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png new file mode 100644 index 0000000..326c0e7 Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png differ diff --git a/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png new file mode 100644 index 0000000..2f1632c Binary files /dev/null and b/Frontend/classico/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png differ diff --git a/Frontend/classico/macos/Runner/Base.lproj/MainMenu.xib b/Frontend/classico/macos/Runner/Base.lproj/MainMenu.xib new file mode 100644 index 0000000..80e867a --- /dev/null +++ b/Frontend/classico/macos/Runner/Base.lproj/MainMenu.xib @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Frontend/classico/macos/Runner/Configs/AppInfo.xcconfig b/Frontend/classico/macos/Runner/Configs/AppInfo.xcconfig new file mode 100644 index 0000000..2ead78c --- /dev/null +++ b/Frontend/classico/macos/Runner/Configs/AppInfo.xcconfig @@ -0,0 +1,14 @@ +// Application-level settings for the Runner target. +// +// This may be replaced with something auto-generated from metadata (e.g., pubspec.yaml) in the +// future. If not, the values below would default to using the project name when this becomes a +// 'flutter create' template. + +// The application's name. By default this is also the title of the Flutter window. +PRODUCT_NAME = classico + +// The application's bundle identifier +PRODUCT_BUNDLE_IDENTIFIER = com.example.classico + +// The copyright displayed in application information +PRODUCT_COPYRIGHT = Copyright © 2024 com.example. All rights reserved. diff --git a/Frontend/classico/macos/Runner/Configs/Debug.xcconfig b/Frontend/classico/macos/Runner/Configs/Debug.xcconfig new file mode 100644 index 0000000..36b0fd9 --- /dev/null +++ b/Frontend/classico/macos/Runner/Configs/Debug.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Debug.xcconfig" +#include "Warnings.xcconfig" diff --git a/Frontend/classico/macos/Runner/Configs/Release.xcconfig b/Frontend/classico/macos/Runner/Configs/Release.xcconfig new file mode 100644 index 0000000..dff4f49 --- /dev/null +++ b/Frontend/classico/macos/Runner/Configs/Release.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Release.xcconfig" +#include "Warnings.xcconfig" diff --git a/Frontend/classico/macos/Runner/Configs/Warnings.xcconfig b/Frontend/classico/macos/Runner/Configs/Warnings.xcconfig new file mode 100644 index 0000000..42bcbf4 --- /dev/null +++ b/Frontend/classico/macos/Runner/Configs/Warnings.xcconfig @@ -0,0 +1,13 @@ +WARNING_CFLAGS = -Wall -Wconditional-uninitialized -Wnullable-to-nonnull-conversion -Wmissing-method-return-type -Woverlength-strings +GCC_WARN_UNDECLARED_SELECTOR = YES +CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES +CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE +CLANG_WARN__DUPLICATE_METHOD_MATCH = YES +CLANG_WARN_PRAGMA_PACK = YES +CLANG_WARN_STRICT_PROTOTYPES = YES +CLANG_WARN_COMMA = YES +GCC_WARN_STRICT_SELECTOR_MATCH = YES +CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES +CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES +GCC_WARN_SHADOW = YES +CLANG_WARN_UNREACHABLE_CODE = YES diff --git a/Frontend/classico/macos/Runner/DebugProfile.entitlements b/Frontend/classico/macos/Runner/DebugProfile.entitlements new file mode 100644 index 0000000..dddb8a3 --- /dev/null +++ b/Frontend/classico/macos/Runner/DebugProfile.entitlements @@ -0,0 +1,12 @@ + + + + + com.apple.security.app-sandbox + + com.apple.security.cs.allow-jit + + com.apple.security.network.server + + + diff --git a/Frontend/classico/macos/Runner/Info.plist b/Frontend/classico/macos/Runner/Info.plist new file mode 100644 index 0000000..4789daa --- /dev/null +++ b/Frontend/classico/macos/Runner/Info.plist @@ -0,0 +1,32 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIconFile + + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSMinimumSystemVersion + $(MACOSX_DEPLOYMENT_TARGET) + NSHumanReadableCopyright + $(PRODUCT_COPYRIGHT) + NSMainNibFile + MainMenu + NSPrincipalClass + NSApplication + + diff --git a/Frontend/classico/macos/Runner/MainFlutterWindow.swift b/Frontend/classico/macos/Runner/MainFlutterWindow.swift new file mode 100644 index 0000000..3cc05eb --- /dev/null +++ b/Frontend/classico/macos/Runner/MainFlutterWindow.swift @@ -0,0 +1,15 @@ +import Cocoa +import FlutterMacOS + +class MainFlutterWindow: NSWindow { + override func awakeFromNib() { + let flutterViewController = FlutterViewController() + let windowFrame = self.frame + self.contentViewController = flutterViewController + self.setFrame(windowFrame, display: true) + + RegisterGeneratedPlugins(registry: flutterViewController) + + super.awakeFromNib() + } +} diff --git a/Frontend/classico/macos/Runner/Release.entitlements b/Frontend/classico/macos/Runner/Release.entitlements new file mode 100644 index 0000000..852fa1a --- /dev/null +++ b/Frontend/classico/macos/Runner/Release.entitlements @@ -0,0 +1,8 @@ + + + + + com.apple.security.app-sandbox + + + diff --git a/Frontend/classico/macos/RunnerTests/RunnerTests.swift b/Frontend/classico/macos/RunnerTests/RunnerTests.swift new file mode 100644 index 0000000..5418c9f --- /dev/null +++ b/Frontend/classico/macos/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import FlutterMacOS +import Cocoa +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/Frontend/classico/pubspec.lock b/Frontend/classico/pubspec.lock new file mode 100644 index 0000000..39c82fa --- /dev/null +++ b/Frontend/classico/pubspec.lock @@ -0,0 +1,722 @@ +# Generated by pub +# See https://dart.dev/tools/pub/glossary#lockfile +packages: + assets_audio_player: + dependency: "direct main" + description: + name: assets_audio_player + sha256: "9a87062cf39be0730ba8bb31ed4d148ca4e892e0ae607113f346d3c9a8da5df0" + url: "https://pub.dev" + source: hosted + version: "3.1.1" + assets_audio_player_web: + dependency: transitive + description: + name: assets_audio_player_web + sha256: "24cf82e72c7e7f9292d67e1b52d7945a182d9695ce8f903f60e5c6b379cbcaac" + url: "https://pub.dev" + source: hosted + version: "3.1.1" + async: + dependency: transitive + description: + name: async + sha256: "947bfcf187f74dbc5e146c9eb9c0f10c9f8b30743e341481c1e2ed3ecc18c20c" + url: "https://pub.dev" + source: hosted + version: "2.11.0" + audioplayers: + dependency: "direct main" + description: + name: audioplayers + sha256: "752039d6aa752597c98ec212e9759519061759e402e7da59a511f39d43aa07d2" + url: "https://pub.dev" + source: hosted + version: "6.0.0" + audioplayers_android: + dependency: transitive + description: + name: audioplayers_android + sha256: de576b890befe27175c2f511ba8b742bec83765fa97c3ce4282bba46212f58e4 + url: "https://pub.dev" + source: hosted + version: "5.0.0" + audioplayers_darwin: + dependency: transitive + description: + name: audioplayers_darwin + sha256: e507887f3ff18d8e5a10a668d7bedc28206b12e10b98347797257c6ae1019c3b + url: "https://pub.dev" + source: hosted + version: "6.0.0" + audioplayers_linux: + dependency: transitive + description: + name: audioplayers_linux + sha256: "3d3d244c90436115417f170426ce768856d8fe4dfc5ed66a049d2890acfa82f9" + url: "https://pub.dev" + source: hosted + version: "4.0.0" + audioplayers_platform_interface: + dependency: transitive + description: + name: audioplayers_platform_interface + sha256: "6834dd48dfb7bc6c2404998ebdd161f79cd3774a7e6779e1348d54a3bfdcfaa5" + url: "https://pub.dev" + source: hosted + version: "7.0.0" + audioplayers_web: + dependency: transitive + description: + name: audioplayers_web + sha256: db8fc420dadf80da18e2286c18e746fb4c3b2c5adbf0c963299dde046828886d + url: "https://pub.dev" + source: hosted + version: "5.0.0" + audioplayers_windows: + dependency: transitive + description: + name: audioplayers_windows + sha256: "8605762dddba992138d476f6a0c3afd9df30ac5b96039929063eceed416795c2" + url: "https://pub.dev" + source: hosted + version: "4.0.0" + boolean_selector: + dependency: transitive + description: + name: boolean_selector + sha256: "6cfb5af12253eaf2b368f07bacc5a80d1301a071c73360d746b7f2e32d762c66" + url: "https://pub.dev" + source: hosted + version: "2.1.1" + camera: + dependency: "direct main" + description: + name: camera + sha256: dfa8fc5a1adaeb95e7a54d86a5bd56f4bb0e035515354c8ac6d262e35cec2ec8 + url: "https://pub.dev" + source: hosted + version: "0.10.6" + camera_android: + dependency: transitive + description: + name: camera_android + sha256: b350ac087f111467e705b2b76cc1322f7f5bdc122aa83b4b243b0872f390d229 + url: "https://pub.dev" + source: hosted + version: "0.10.9+2" + camera_avfoundation: + dependency: transitive + description: + name: camera_avfoundation + sha256: dfe32a72db81e92a15672cb6e8ecc81e34e0a9d5bf03017f0545e7041b2b8150 + url: "https://pub.dev" + source: hosted + version: "0.9.16+2" + camera_platform_interface: + dependency: transitive + description: + name: camera_platform_interface + sha256: b3ede1f171532e0d83111fe0980b46d17f1aa9788a07a2fbed07366bbdbb9061 + url: "https://pub.dev" + source: hosted + version: "2.8.0" + camera_web: + dependency: transitive + description: + name: camera_web + sha256: "9e9aba2fbab77ce2472924196ff8ac4dd8f9126c4f9a3096171cd1d870d6b26c" + url: "https://pub.dev" + source: hosted + version: "0.3.3" + characters: + dependency: transitive + description: + name: characters + sha256: "04a925763edad70e8443c99234dc3328f442e811f1d8fd1a72f1c8ad0f69a605" + url: "https://pub.dev" + source: hosted + version: "1.3.0" + clock: + dependency: transitive + description: + name: clock + sha256: cb6d7f03e1de671e34607e909a7213e31d7752be4fb66a86d29fe1eb14bfb5cf + url: "https://pub.dev" + source: hosted + version: "1.1.1" + collection: + dependency: transitive + description: + name: collection + sha256: ee67cb0715911d28db6bf4af1026078bd6f0128b07a5f66fb2ed94ec6783c09a + url: "https://pub.dev" + source: hosted + version: "1.18.0" + cross_file: + dependency: transitive + description: + name: cross_file + sha256: "55d7b444feb71301ef6b8838dbc1ae02e63dd48c8773f3810ff53bb1e2945b32" + url: "https://pub.dev" + source: hosted + version: "0.3.4+1" + crypto: + dependency: transitive + description: + name: crypto + sha256: ff625774173754681d66daaf4a448684fb04b78f902da9cb3d308c19cc5e8bab + url: "https://pub.dev" + source: hosted + version: "3.0.3" + csslib: + dependency: transitive + description: + name: csslib + sha256: "706b5707578e0c1b4b7550f64078f0a0f19dec3f50a178ffae7006b0a9ca58fb" + url: "https://pub.dev" + source: hosted + version: "1.0.0" + cupertino_icons: + dependency: "direct main" + description: + name: cupertino_icons + sha256: ba631d1c7f7bef6b729a622b7b752645a2d076dba9976925b8f25725a30e1ee6 + url: "https://pub.dev" + source: hosted + version: "1.0.8" + fake_async: + dependency: transitive + description: + name: fake_async + sha256: "511392330127add0b769b75a987850d136345d9227c6b94c96a04cf4a391bf78" + url: "https://pub.dev" + source: hosted + version: "1.3.1" + ffi: + dependency: transitive + description: + name: ffi + sha256: "493f37e7df1804778ff3a53bd691d8692ddf69702cf4c1c1096a2e41b4779e21" + url: "https://pub.dev" + source: hosted + version: "2.1.2" + file: + dependency: transitive + description: + name: file + sha256: "5fc22d7c25582e38ad9a8515372cd9a93834027aacf1801cf01164dac0ffa08c" + url: "https://pub.dev" + source: hosted + version: "7.0.0" + file_selector_linux: + dependency: transitive + description: + name: file_selector_linux + sha256: "045d372bf19b02aeb69cacf8b4009555fb5f6f0b7ad8016e5f46dd1387ddd492" + url: "https://pub.dev" + source: hosted + version: "0.9.2+1" + file_selector_macos: + dependency: transitive + description: + name: file_selector_macos + sha256: f42eacb83b318e183b1ae24eead1373ab1334084404c8c16e0354f9a3e55d385 + url: "https://pub.dev" + source: hosted + version: "0.9.4" + file_selector_platform_interface: + dependency: transitive + description: + name: file_selector_platform_interface + sha256: a3994c26f10378a039faa11de174d7b78eb8f79e4dd0af2a451410c1a5c3f66b + url: "https://pub.dev" + source: hosted + version: "2.6.2" + file_selector_windows: + dependency: transitive + description: + name: file_selector_windows + sha256: d3547240c20cabf205c7c7f01a50ecdbc413755814d6677f3cb366f04abcead0 + url: "https://pub.dev" + source: hosted + version: "0.9.3+1" + flutter: + dependency: "direct main" + description: flutter + source: sdk + version: "0.0.0" + flutter_lints: + dependency: "direct dev" + description: + name: flutter_lints + sha256: "9e8c3858111da373efc5aa341de011d9bd23e2c5c5e0c62bccf32438e192d7b1" + url: "https://pub.dev" + source: hosted + version: "3.0.2" + flutter_plugin_android_lifecycle: + dependency: transitive + description: + name: flutter_plugin_android_lifecycle + sha256: "8cf40eebf5dec866a6d1956ad7b4f7016e6c0cc69847ab946833b7d43743809f" + url: "https://pub.dev" + source: hosted + version: "2.0.19" + flutter_test: + dependency: "direct dev" + description: flutter + source: sdk + version: "0.0.0" + flutter_tts: + dependency: "direct main" + description: + name: flutter_tts + sha256: cbb3fd43b946e62398560235469e6113e4fe26c40eab1b7cb5e7c417503fb3a8 + url: "https://pub.dev" + source: hosted + version: "3.8.5" + flutter_web_plugins: + dependency: transitive + description: flutter + source: sdk + version: "0.0.0" + html: + dependency: transitive + description: + name: html + sha256: "3a7812d5bcd2894edf53dfaf8cd640876cf6cef50a8f238745c8b8120ea74d3a" + url: "https://pub.dev" + source: hosted + version: "0.15.4" + http: + dependency: "direct main" + description: + name: http + sha256: "5895291c13fa8a3bd82e76d5627f69e0d85ca6a30dcac95c4ea19a5d555879c2" + url: "https://pub.dev" + source: hosted + version: "0.13.6" + http_parser: + dependency: transitive + description: + name: http_parser + sha256: "2aa08ce0341cc9b354a498388e30986515406668dbcc4f7c950c3e715496693b" + url: "https://pub.dev" + source: hosted + version: "4.0.2" + image_picker: + dependency: "direct main" + description: + name: image_picker + sha256: "021834d9c0c3de46bf0fe40341fa07168407f694d9b2bb18d532dc1261867f7a" + url: "https://pub.dev" + source: hosted + version: "1.1.2" + image_picker_android: + dependency: transitive + description: + name: image_picker_android + sha256: "0f57fee1e8bfadf8cc41818bbcd7f72e53bb768a54d9496355d5e8a5681a19f1" + url: "https://pub.dev" + source: hosted + version: "0.8.12+1" + image_picker_for_web: + dependency: transitive + description: + name: image_picker_for_web + sha256: "5d6eb13048cd47b60dbf1a5495424dea226c5faf3950e20bf8120a58efb5b5f3" + url: "https://pub.dev" + source: hosted + version: "3.0.4" + image_picker_ios: + dependency: transitive + description: + name: image_picker_ios + sha256: "6703696ad49f5c3c8356d576d7ace84d1faf459afb07accbb0fae780753ff447" + url: "https://pub.dev" + source: hosted + version: "0.8.12" + image_picker_linux: + dependency: transitive + description: + name: image_picker_linux + sha256: "4ed1d9bb36f7cd60aa6e6cd479779cc56a4cb4e4de8f49d487b1aaad831300fa" + url: "https://pub.dev" + source: hosted + version: "0.2.1+1" + image_picker_macos: + dependency: transitive + description: + name: image_picker_macos + sha256: "3f5ad1e8112a9a6111c46d0b57a7be2286a9a07fc6e1976fdf5be2bd31d4ff62" + url: "https://pub.dev" + source: hosted + version: "0.2.1+1" + image_picker_platform_interface: + dependency: transitive + description: + name: image_picker_platform_interface + sha256: "9ec26d410ff46f483c5519c29c02ef0e02e13a543f882b152d4bfd2f06802f80" + url: "https://pub.dev" + source: hosted + version: "2.10.0" + image_picker_windows: + dependency: transitive + description: + name: image_picker_windows + sha256: "6ad07afc4eb1bc25f3a01084d28520496c4a3bb0cb13685435838167c9dcedeb" + url: "https://pub.dev" + source: hosted + version: "0.2.1+1" + js: + dependency: transitive + description: + name: js + sha256: c1b2e9b5ea78c45e1a0788d29606ba27dc5f71f019f32ca5140f61ef071838cf + url: "https://pub.dev" + source: hosted + version: "0.7.1" + json_annotation: + dependency: transitive + description: + name: json_annotation + sha256: "1ce844379ca14835a50d2f019a3099f419082cfdd231cd86a142af94dd5c6bb1" + url: "https://pub.dev" + source: hosted + version: "4.9.0" + leak_tracker: + dependency: transitive + description: + name: leak_tracker + sha256: "78eb209deea09858f5269f5a5b02be4049535f568c07b275096836f01ea323fa" + url: "https://pub.dev" + source: hosted + version: "10.0.0" + leak_tracker_flutter_testing: + dependency: transitive + description: + name: leak_tracker_flutter_testing + sha256: b46c5e37c19120a8a01918cfaf293547f47269f7cb4b0058f21531c2465d6ef0 + url: "https://pub.dev" + source: hosted + version: "2.0.1" + leak_tracker_testing: + dependency: transitive + description: + name: leak_tracker_testing + sha256: a597f72a664dbd293f3bfc51f9ba69816f84dcd403cdac7066cb3f6003f3ab47 + url: "https://pub.dev" + source: hosted + version: "2.0.1" + lints: + dependency: transitive + description: + name: lints + sha256: cbf8d4b858bb0134ef3ef87841abdf8d63bfc255c266b7bf6b39daa1085c4290 + url: "https://pub.dev" + source: hosted + version: "3.0.0" + matcher: + dependency: transitive + description: + name: matcher + sha256: d2323aa2060500f906aa31a895b4030b6da3ebdcc5619d14ce1aada65cd161cb + url: "https://pub.dev" + source: hosted + version: "0.12.16+1" + material_color_utilities: + dependency: transitive + description: + name: material_color_utilities + sha256: "0e0a020085b65b6083975e499759762399b4475f766c21668c4ecca34ea74e5a" + url: "https://pub.dev" + source: hosted + version: "0.8.0" + meta: + dependency: transitive + description: + name: meta + sha256: d584fa6707a52763a52446f02cc621b077888fb63b93bbcb1143a7be5a0c0c04 + url: "https://pub.dev" + source: hosted + version: "1.11.0" + mime: + dependency: transitive + description: + name: mime + sha256: "2e123074287cc9fd6c09de8336dae606d1ddb88d9ac47358826db698c176a1f2" + url: "https://pub.dev" + source: hosted + version: "1.0.5" + path: + dependency: "direct main" + description: + name: path + sha256: "087ce49c3f0dc39180befefc60fdb4acd8f8620e5682fe2476afd0b3688bb4af" + url: "https://pub.dev" + source: hosted + version: "1.9.0" + path_provider: + dependency: "direct main" + description: + name: path_provider + sha256: c9e7d3a4cd1410877472158bee69963a4579f78b68c65a2b7d40d1a7a88bb161 + url: "https://pub.dev" + source: hosted + version: "2.1.3" + path_provider_android: + dependency: transitive + description: + name: path_provider_android + sha256: a248d8146ee5983446bf03ed5ea8f6533129a12b11f12057ad1b4a67a2b3b41d + url: "https://pub.dev" + source: hosted + version: "2.2.4" + path_provider_foundation: + dependency: transitive + description: + name: path_provider_foundation + sha256: f234384a3fdd67f989b4d54a5d73ca2a6c422fa55ae694381ae0f4375cd1ea16 + url: "https://pub.dev" + source: hosted + version: "2.4.0" + path_provider_linux: + dependency: transitive + description: + name: path_provider_linux + sha256: f7a1fe3a634fe7734c8d3f2766ad746ae2a2884abe22e241a8b301bf5cac3279 + url: "https://pub.dev" + source: hosted + version: "2.2.1" + path_provider_platform_interface: + dependency: transitive + description: + name: path_provider_platform_interface + sha256: "88f5779f72ba699763fa3a3b06aa4bf6de76c8e5de842cf6f29e2e06476c2334" + url: "https://pub.dev" + source: hosted + version: "2.1.2" + path_provider_windows: + dependency: transitive + description: + name: path_provider_windows + sha256: bd6f00dbd873bfb70d0761682da2b3a2c2fccc2b9e84c495821639601d81afe7 + url: "https://pub.dev" + source: hosted + version: "2.3.0" + pedantic: + dependency: transitive + description: + name: pedantic + sha256: "67fc27ed9639506c856c840ccce7594d0bdcd91bc8d53d6e52359449a1d50602" + url: "https://pub.dev" + source: hosted + version: "1.11.1" + platform: + dependency: transitive + description: + name: platform + sha256: "9b71283fc13df574056616011fb138fd3b793ea47cc509c189a6c3fa5f8a1a65" + url: "https://pub.dev" + source: hosted + version: "3.1.5" + plugin_platform_interface: + dependency: transitive + description: + name: plugin_platform_interface + sha256: "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02" + url: "https://pub.dev" + source: hosted + version: "2.1.8" + rxdart: + dependency: transitive + description: + name: rxdart + sha256: "0c7c0cedd93788d996e33041ffecda924cc54389199cde4e6a34b440f50044cb" + url: "https://pub.dev" + source: hosted + version: "0.27.7" + sky_engine: + dependency: transitive + description: flutter + source: sdk + version: "0.0.99" + source_span: + dependency: transitive + description: + name: source_span + sha256: "53e943d4206a5e30df338fd4c6e7a077e02254531b138a15aec3bd143c1a8b3c" + url: "https://pub.dev" + source: hosted + version: "1.10.0" + speech_to_text: + dependency: "direct main" + description: + name: speech_to_text + sha256: "97425fd8cc60424061a0584b6c418c0eedab5201cc5e96ef15a946d7fab7b9b7" + url: "https://pub.dev" + source: hosted + version: "6.6.2" + speech_to_text_macos: + dependency: transitive + description: + name: speech_to_text_macos + sha256: e685750f7542fcaa087a5396ee471e727ec648bf681f4da83c84d086322173f6 + url: "https://pub.dev" + source: hosted + version: "1.1.0" + speech_to_text_platform_interface: + dependency: transitive + description: + name: speech_to_text_platform_interface + sha256: a0df1a907091ea09880077dc25aae02af9f79811264e6e97ddb08639b7f771c2 + url: "https://pub.dev" + source: hosted + version: "2.2.0" + stack_trace: + dependency: transitive + description: + name: stack_trace + sha256: "73713990125a6d93122541237550ee3352a2d84baad52d375a4cad2eb9b7ce0b" + url: "https://pub.dev" + source: hosted + version: "1.11.1" + stream_channel: + dependency: transitive + description: + name: stream_channel + sha256: ba2aa5d8cc609d96bbb2899c28934f9e1af5cddbd60a827822ea467161eb54e7 + url: "https://pub.dev" + source: hosted + version: "2.1.2" + stream_transform: + dependency: transitive + description: + name: stream_transform + sha256: "14a00e794c7c11aa145a170587321aedce29769c08d7f58b1d141da75e3b1c6f" + url: "https://pub.dev" + source: hosted + version: "2.1.0" + string_scanner: + dependency: transitive + description: + name: string_scanner + sha256: "556692adab6cfa87322a115640c11f13cb77b3f076ddcc5d6ae3c20242bedcde" + url: "https://pub.dev" + source: hosted + version: "1.2.0" + synchronized: + dependency: transitive + description: + name: synchronized + sha256: "539ef412b170d65ecdafd780f924e5be3f60032a1128df156adad6c5b373d558" + url: "https://pub.dev" + source: hosted + version: "3.1.0+1" + term_glyph: + dependency: transitive + description: + name: term_glyph + sha256: a29248a84fbb7c79282b40b8c72a1209db169a2e0542bce341da992fe1bc7e84 + url: "https://pub.dev" + source: hosted + version: "1.2.1" + test_api: + dependency: transitive + description: + name: test_api + sha256: "5c2f730018264d276c20e4f1503fd1308dfbbae39ec8ee63c5236311ac06954b" + url: "https://pub.dev" + source: hosted + version: "0.6.1" + typed_data: + dependency: transitive + description: + name: typed_data + sha256: facc8d6582f16042dd49f2463ff1bd6e2c9ef9f3d5da3d9b087e244a7b564b3c + url: "https://pub.dev" + source: hosted + version: "1.3.2" + uuid: + dependency: transitive + description: + name: uuid + sha256: "648e103079f7c64a36dc7d39369cabb358d377078a051d6ae2ad3aa539519313" + url: "https://pub.dev" + source: hosted + version: "3.0.7" + vector_math: + dependency: transitive + description: + name: vector_math + sha256: "80b3257d1492ce4d091729e3a67a60407d227c27241d6927be0130c98e741803" + url: "https://pub.dev" + source: hosted + version: "2.1.4" + video_player: + dependency: "direct main" + description: + name: video_player + sha256: e30df0d226c4ef82e2c150ebf6834b3522cf3f654d8e2f9419d376cdc071425d + url: "https://pub.dev" + source: hosted + version: "2.9.1" + video_player_android: + dependency: transitive + description: + name: video_player_android + sha256: "134e1ad410d67e18a19486ed9512c72dfc6d8ffb284d0e8f2e99e903d1ba8fa3" + url: "https://pub.dev" + source: hosted + version: "2.4.14" + video_player_avfoundation: + dependency: transitive + description: + name: video_player_avfoundation + sha256: d1e9a824f2b324000dc8fb2dcb2a3285b6c1c7c487521c63306cc5b394f68a7c + url: "https://pub.dev" + source: hosted + version: "2.6.1" + video_player_platform_interface: + dependency: transitive + description: + name: video_player_platform_interface + sha256: "236454725fafcacf98f0f39af0d7c7ab2ce84762e3b63f2cbb3ef9a7e0550bc6" + url: "https://pub.dev" + source: hosted + version: "6.2.2" + video_player_web: + dependency: transitive + description: + name: video_player_web + sha256: ff4d69a6614b03f055397c27a71c9d3ddea2b2a23d71b2ba0164f59ca32b8fe2 + url: "https://pub.dev" + source: hosted + version: "2.3.1" + vm_service: + dependency: transitive + description: + name: vm_service + sha256: b3d56ff4341b8f182b96aceb2fa20e3dcb336b9f867bc0eafc0de10f1048e957 + url: "https://pub.dev" + source: hosted + version: "13.0.0" + web: + dependency: transitive + description: + name: web + sha256: "97da13628db363c635202ad97068d47c5b8aa555808e7a9411963c533b449b27" + url: "https://pub.dev" + source: hosted + version: "0.5.1" + xdg_directories: + dependency: transitive + description: + name: xdg_directories + sha256: faea9dee56b520b55a566385b84f2e8de55e7496104adada9962e0bd11bcff1d + url: "https://pub.dev" + source: hosted + version: "1.0.4" +sdks: + dart: ">=3.3.3 <4.0.0" + flutter: ">=3.19.0" diff --git a/Frontend/classico/pubspec.yaml b/Frontend/classico/pubspec.yaml new file mode 100644 index 0000000..273402c --- /dev/null +++ b/Frontend/classico/pubspec.yaml @@ -0,0 +1,101 @@ +name: classico +description: "A new Flutter project." +# The following line prevents the package from being accidentally published to +# pub.dev using `flutter pub publish`. This is preferred for private packages. +publish_to: 'none' # Remove this line if you wish to publish to pub.dev + +# The following defines the version and build number for your application. +# A version number is three numbers separated by dots, like 1.2.43 +# followed by an optional build number separated by a +. +# Both the version and the builder number may be overridden in flutter +# build by specifying --build-name and --build-number, respectively. +# In Android, build-name is used as versionName while build-number used as versionCode. +# Read more about Android versioning at https://developer.android.com/studio/publish/versioning +# In iOS, build-name is used as CFBundleShortVersionString while build-number is used as CFBundleVersion. +# Read more about iOS versioning at +# https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html +# In Windows, build-name is used as the major, minor, and patch parts +# of the product and file versions while build-number is used as the build suffix. +version: 1.0.0+1 + +environment: + sdk: '>=3.3.3 <4.0.0' + +# Dependencies specify other packages that your package needs in order to work. +# To automatically upgrade your package dependencies to the latest versions +# consider running `flutter pub upgrade --major-versions`. Alternatively, +# dependencies can be manually updated by changing the version numbers below to +# the latest version available on pub.dev. To see which dependencies have newer +# versions available, run `flutter pub outdated`. +dependencies: + flutter: + sdk: flutter + + + + # The following adds the Cupertino Icons font to your application. + # Use with the CupertinoIcons class for iOS style icons. + camera: ^0.10.0+4 + video_player: ^2.3.0 + path_provider: ^2.0.9 + path: ^1.8.0 + cupertino_icons: ^1.0.8 + image_picker: ^1.1.0 + http: ^0.13.6 + flutter_tts: ^3.3.3 + audioplayers: ^6.0.0 + assets_audio_player: ^3.1.1 + speech_to_text: ^6.2.2 + +dev_dependencies: + flutter_test: + sdk: flutter + + # The "flutter_lints" package below contains a set of recommended lints to + # encourage good coding practices. The lint set provided by the package is + # activated in the `analysis_options.yaml` file located at the root of your + # package. See that file for information about deactivating specific lint + # rules and activating additional ones. + flutter_lints: ^3.0.0 + +# For information on the generic Dart part of this file, see the +# following page: https://dart.dev/tools/pub/pubspec + +# The following section is specific to Flutter packages. +flutter: + + # The following line ensures that the Material Icons font is + # included with your application, so that you can use the icons in + # the material Icons class. + uses-material-design: true + + # To add assets to your application, add an assets section, like this: + assets: + - assets/sound/ + # - images/a_dot_ham.jpeg + + # An image asset can refer to one or more resolution-specific "variants", see + # https://flutter.dev/assets-and-images/#resolution-aware + + # For details regarding adding assets from package dependencies, see + # https://flutter.dev/assets-and-images/#from-packages + + # To add custom fonts to your application, add a fonts section here, + # in this "flutter" section. Each entry in this list should have a + # "family" key with the font family name, and a "fonts" key with a + # list giving the asset and other descriptors for the font. For + # example: + # fonts: + # - family: Schyler + # fonts: + # - asset: fonts/Schyler-Regular.ttf + # - asset: fonts/Schyler-Italic.ttf + # style: italic + # - family: Trajan Pro + # fonts: + # - asset: fonts/TrajanPro.ttf + # - asset: fonts/TrajanPro_Bold.ttf + # weight: 700 + # + # For details regarding fonts from package dependencies, + # see https://flutter.dev/custom-fonts/#from-packages diff --git a/Frontend/classico/test/widget_test.dart b/Frontend/classico/test/widget_test.dart new file mode 100644 index 0000000..2a6002b --- /dev/null +++ b/Frontend/classico/test/widget_test.dart @@ -0,0 +1,30 @@ +// This is a basic Flutter widget test. +// +// To perform an interaction with a widget in your test, use the WidgetTester +// utility in the flutter_test package. For example, you can send tap and scroll +// gestures. You can also use WidgetTester to find child widgets in the widget +// tree, read text, and verify that the values of widget properties are correct. + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; + +import 'package:classico/main.dart'; + +void main() { + testWidgets('Counter increments smoke test', (WidgetTester tester) async { + // Build our app and trigger a frame. + await tester.pumpWidget(const MyApp()); + + // Verify that our counter starts at 0. + expect(find.text('0'), findsOneWidget); + expect(find.text('1'), findsNothing); + + // Tap the '+' icon and trigger a frame. + await tester.tap(find.byIcon(Icons.add)); + await tester.pump(); + + // Verify that our counter has incremented. + expect(find.text('0'), findsNothing); + expect(find.text('1'), findsOneWidget); + }); +} diff --git a/Frontend/classico/web/favicon.png b/Frontend/classico/web/favicon.png new file mode 100644 index 0000000..8aaa46a Binary files /dev/null and b/Frontend/classico/web/favicon.png differ diff --git a/Frontend/classico/web/icons/Icon-192.png b/Frontend/classico/web/icons/Icon-192.png new file mode 100644 index 0000000..b749bfe Binary files /dev/null and b/Frontend/classico/web/icons/Icon-192.png differ diff --git a/Frontend/classico/web/icons/Icon-512.png b/Frontend/classico/web/icons/Icon-512.png new file mode 100644 index 0000000..88cfd48 Binary files /dev/null and b/Frontend/classico/web/icons/Icon-512.png differ diff --git a/Frontend/classico/web/icons/Icon-maskable-192.png b/Frontend/classico/web/icons/Icon-maskable-192.png new file mode 100644 index 0000000..eb9b4d7 Binary files /dev/null and b/Frontend/classico/web/icons/Icon-maskable-192.png differ diff --git a/Frontend/classico/web/icons/Icon-maskable-512.png b/Frontend/classico/web/icons/Icon-maskable-512.png new file mode 100644 index 0000000..d69c566 Binary files /dev/null and b/Frontend/classico/web/icons/Icon-maskable-512.png differ diff --git a/Frontend/classico/web/index.html b/Frontend/classico/web/index.html new file mode 100644 index 0000000..67dae37 --- /dev/null +++ b/Frontend/classico/web/index.html @@ -0,0 +1,59 @@ + + + + + + + + + + + + + + + + + + + + classico + + + + + + + + + + diff --git a/Frontend/classico/web/manifest.json b/Frontend/classico/web/manifest.json new file mode 100644 index 0000000..df61fa2 --- /dev/null +++ b/Frontend/classico/web/manifest.json @@ -0,0 +1,35 @@ +{ + "name": "classico", + "short_name": "classico", + "start_url": ".", + "display": "standalone", + "background_color": "#0175C2", + "theme_color": "#0175C2", + "description": "A new Flutter project.", + "orientation": "portrait-primary", + "prefer_related_applications": false, + "icons": [ + { + "src": "icons/Icon-192.png", + "sizes": "192x192", + "type": "image/png" + }, + { + "src": "icons/Icon-512.png", + "sizes": "512x512", + "type": "image/png" + }, + { + "src": "icons/Icon-maskable-192.png", + "sizes": "192x192", + "type": "image/png", + "purpose": "maskable" + }, + { + "src": "icons/Icon-maskable-512.png", + "sizes": "512x512", + "type": "image/png", + "purpose": "maskable" + } + ] +} diff --git a/Frontend/classico/windows/.gitignore b/Frontend/classico/windows/.gitignore new file mode 100644 index 0000000..d492d0d --- /dev/null +++ b/Frontend/classico/windows/.gitignore @@ -0,0 +1,17 @@ +flutter/ephemeral/ + +# Visual Studio user-specific files. +*.suo +*.user +*.userosscache +*.sln.docstates + +# Visual Studio build-related files. +x64/ +x86/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ diff --git a/Frontend/classico/windows/CMakeLists.txt b/Frontend/classico/windows/CMakeLists.txt new file mode 100644 index 0000000..61d6610 --- /dev/null +++ b/Frontend/classico/windows/CMakeLists.txt @@ -0,0 +1,108 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.14) +project(classico LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "classico") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(VERSION 3.14...3.25) + +# Define build configuration option. +get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(IS_MULTICONFIG) + set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release" + CACHE STRING "" FORCE) +else() + if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") + endif() +endif() +# Define settings for the Profile build mode. +set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") +set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}") +set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}") + +# Use Unicode for all projects. +add_definitions(-DUNICODE -D_UNICODE) + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_17) + target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100") + target_compile_options(${TARGET} PRIVATE /EHsc) + target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0") + target_compile_definitions(${TARGET} PRIVATE "$<$:_DEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# Application build; see runner/CMakeLists.txt. +add_subdirectory("runner") + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# Support files are copied into place next to the executable, so that it can +# run in place. This is done instead of making a separate bundle (as on Linux) +# so that building and running from within Visual Studio will work. +set(BUILD_BUNDLE_DIR "$") +# Make the "install" step default, as it's required to run. +set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1) +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +if(PLUGIN_BUNDLED_LIBRARIES) + install(FILES "${PLUGIN_BUNDLED_LIBRARIES}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/windows/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + CONFIGURATIONS Profile;Release + COMPONENT Runtime) diff --git a/Frontend/classico/windows/flutter/CMakeLists.txt b/Frontend/classico/windows/flutter/CMakeLists.txt new file mode 100644 index 0000000..903f489 --- /dev/null +++ b/Frontend/classico/windows/flutter/CMakeLists.txt @@ -0,0 +1,109 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.14) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. +set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper") + +# Set fallback configurations for older versions of the flutter tool. +if (NOT DEFINED FLUTTER_TARGET_PLATFORM) + set(FLUTTER_TARGET_PLATFORM "windows-x64") +endif() + +# === Flutter Library === +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "flutter_export.h" + "flutter_windows.h" + "flutter_messenger.h" + "flutter_plugin_registrar.h" + "flutter_texture_registrar.h" +) +list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib") +add_dependencies(flutter flutter_assemble) + +# === Wrapper === +list(APPEND CPP_WRAPPER_SOURCES_CORE + "core_implementations.cc" + "standard_codec.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_PLUGIN + "plugin_registrar.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_APP + "flutter_engine.cc" + "flutter_view_controller.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/") + +# Wrapper sources needed for a plugin. +add_library(flutter_wrapper_plugin STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} +) +apply_standard_settings(flutter_wrapper_plugin) +set_target_properties(flutter_wrapper_plugin PROPERTIES + POSITION_INDEPENDENT_CODE ON) +set_target_properties(flutter_wrapper_plugin PROPERTIES + CXX_VISIBILITY_PRESET hidden) +target_link_libraries(flutter_wrapper_plugin PUBLIC flutter) +target_include_directories(flutter_wrapper_plugin PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_plugin flutter_assemble) + +# Wrapper sources needed for the runner. +add_library(flutter_wrapper_app STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_APP} +) +apply_standard_settings(flutter_wrapper_app) +target_link_libraries(flutter_wrapper_app PUBLIC flutter) +target_include_directories(flutter_wrapper_app PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_app flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_") +set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE) +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} + ${PHONY_OUTPUT} + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat" + ${FLUTTER_TARGET_PLATFORM} $ + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} +) diff --git a/Frontend/classico/windows/flutter/generated_plugin_registrant.cc b/Frontend/classico/windows/flutter/generated_plugin_registrant.cc new file mode 100644 index 0000000..94d5891 --- /dev/null +++ b/Frontend/classico/windows/flutter/generated_plugin_registrant.cc @@ -0,0 +1,20 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + +#include +#include +#include + +void RegisterPlugins(flutter::PluginRegistry* registry) { + AudioplayersWindowsPluginRegisterWithRegistrar( + registry->GetRegistrarForPlugin("AudioplayersWindowsPlugin")); + FileSelectorWindowsRegisterWithRegistrar( + registry->GetRegistrarForPlugin("FileSelectorWindows")); + FlutterTtsPluginRegisterWithRegistrar( + registry->GetRegistrarForPlugin("FlutterTtsPlugin")); +} diff --git a/Frontend/classico/windows/flutter/generated_plugin_registrant.h b/Frontend/classico/windows/flutter/generated_plugin_registrant.h new file mode 100644 index 0000000..dc139d8 --- /dev/null +++ b/Frontend/classico/windows/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void RegisterPlugins(flutter::PluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/Frontend/classico/windows/flutter/generated_plugins.cmake b/Frontend/classico/windows/flutter/generated_plugins.cmake new file mode 100644 index 0000000..2ccb372 --- /dev/null +++ b/Frontend/classico/windows/flutter/generated_plugins.cmake @@ -0,0 +1,26 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST + audioplayers_windows + file_selector_windows + flutter_tts +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/windows plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/Frontend/classico/windows/runner/CMakeLists.txt b/Frontend/classico/windows/runner/CMakeLists.txt new file mode 100644 index 0000000..394917c --- /dev/null +++ b/Frontend/classico/windows/runner/CMakeLists.txt @@ -0,0 +1,40 @@ +cmake_minimum_required(VERSION 3.14) +project(runner LANGUAGES CXX) + +# Define the application target. To change its name, change BINARY_NAME in the +# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer +# work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} WIN32 + "flutter_window.cpp" + "main.cpp" + "utils.cpp" + "win32_window.cpp" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" + "Runner.rc" + "runner.exe.manifest" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add preprocessor definitions for the build version. +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}") + +# Disable Windows macros that collide with C++ standard library functions. +target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX") + +# Add dependency libraries and include directories. Add any application-specific +# dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app) +target_link_libraries(${BINARY_NAME} PRIVATE "dwmapi.lib") +target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}") + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) diff --git a/Frontend/classico/windows/runner/Runner.rc b/Frontend/classico/windows/runner/Runner.rc new file mode 100644 index 0000000..5a0225d --- /dev/null +++ b/Frontend/classico/windows/runner/Runner.rc @@ -0,0 +1,121 @@ +// Microsoft Visual C++ generated resource script. +// +#pragma code_page(65001) +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (United States) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_APP_ICON ICON "resources\\app_icon.ico" + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +#if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD) +#define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD +#else +#define VERSION_AS_NUMBER 1,0,0,0 +#endif + +#if defined(FLUTTER_VERSION) +#define VERSION_AS_STRING FLUTTER_VERSION +#else +#define VERSION_AS_STRING "1.0.0" +#endif + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VERSION_AS_NUMBER + PRODUCTVERSION VERSION_AS_NUMBER + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif + FILEOS VOS__WINDOWS32 + FILETYPE VFT_APP + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "com.example" "\0" + VALUE "FileDescription", "classico" "\0" + VALUE "FileVersion", VERSION_AS_STRING "\0" + VALUE "InternalName", "classico" "\0" + VALUE "LegalCopyright", "Copyright (C) 2024 com.example. All rights reserved." "\0" + VALUE "OriginalFilename", "classico.exe" "\0" + VALUE "ProductName", "classico" "\0" + VALUE "ProductVersion", VERSION_AS_STRING "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1252 + END +END + +#endif // English (United States) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED diff --git a/Frontend/classico/windows/runner/flutter_window.cpp b/Frontend/classico/windows/runner/flutter_window.cpp new file mode 100644 index 0000000..955ee30 --- /dev/null +++ b/Frontend/classico/windows/runner/flutter_window.cpp @@ -0,0 +1,71 @@ +#include "flutter_window.h" + +#include + +#include "flutter/generated_plugin_registrant.h" + +FlutterWindow::FlutterWindow(const flutter::DartProject& project) + : project_(project) {} + +FlutterWindow::~FlutterWindow() {} + +bool FlutterWindow::OnCreate() { + if (!Win32Window::OnCreate()) { + return false; + } + + RECT frame = GetClientArea(); + + // The size here must match the window dimensions to avoid unnecessary surface + // creation / destruction in the startup path. + flutter_controller_ = std::make_unique( + frame.right - frame.left, frame.bottom - frame.top, project_); + // Ensure that basic setup of the controller was successful. + if (!flutter_controller_->engine() || !flutter_controller_->view()) { + return false; + } + RegisterPlugins(flutter_controller_->engine()); + SetChildContent(flutter_controller_->view()->GetNativeWindow()); + + flutter_controller_->engine()->SetNextFrameCallback([&]() { + this->Show(); + }); + + // Flutter can complete the first frame before the "show window" callback is + // registered. The following call ensures a frame is pending to ensure the + // window is shown. It is a no-op if the first frame hasn't completed yet. + flutter_controller_->ForceRedraw(); + + return true; +} + +void FlutterWindow::OnDestroy() { + if (flutter_controller_) { + flutter_controller_ = nullptr; + } + + Win32Window::OnDestroy(); +} + +LRESULT +FlutterWindow::MessageHandler(HWND hwnd, UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + // Give Flutter, including plugins, an opportunity to handle window messages. + if (flutter_controller_) { + std::optional result = + flutter_controller_->HandleTopLevelWindowProc(hwnd, message, wparam, + lparam); + if (result) { + return *result; + } + } + + switch (message) { + case WM_FONTCHANGE: + flutter_controller_->engine()->ReloadSystemFonts(); + break; + } + + return Win32Window::MessageHandler(hwnd, message, wparam, lparam); +} diff --git a/Frontend/classico/windows/runner/flutter_window.h b/Frontend/classico/windows/runner/flutter_window.h new file mode 100644 index 0000000..6da0652 --- /dev/null +++ b/Frontend/classico/windows/runner/flutter_window.h @@ -0,0 +1,33 @@ +#ifndef RUNNER_FLUTTER_WINDOW_H_ +#define RUNNER_FLUTTER_WINDOW_H_ + +#include +#include + +#include + +#include "win32_window.h" + +// A window that does nothing but host a Flutter view. +class FlutterWindow : public Win32Window { + public: + // Creates a new FlutterWindow hosting a Flutter view running |project|. + explicit FlutterWindow(const flutter::DartProject& project); + virtual ~FlutterWindow(); + + protected: + // Win32Window: + bool OnCreate() override; + void OnDestroy() override; + LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam, + LPARAM const lparam) noexcept override; + + private: + // The project to run. + flutter::DartProject project_; + + // The Flutter instance hosted by this window. + std::unique_ptr flutter_controller_; +}; + +#endif // RUNNER_FLUTTER_WINDOW_H_ diff --git a/Frontend/classico/windows/runner/main.cpp b/Frontend/classico/windows/runner/main.cpp new file mode 100644 index 0000000..baa3872 --- /dev/null +++ b/Frontend/classico/windows/runner/main.cpp @@ -0,0 +1,43 @@ +#include +#include +#include + +#include "flutter_window.h" +#include "utils.h" + +int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev, + _In_ wchar_t *command_line, _In_ int show_command) { + // Attach to console when present (e.g., 'flutter run') or create a + // new console when running with a debugger. + if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) { + CreateAndAttachConsole(); + } + + // Initialize COM, so that it is available for use in the library and/or + // plugins. + ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED); + + flutter::DartProject project(L"data"); + + std::vector command_line_arguments = + GetCommandLineArguments(); + + project.set_dart_entrypoint_arguments(std::move(command_line_arguments)); + + FlutterWindow window(project); + Win32Window::Point origin(10, 10); + Win32Window::Size size(1280, 720); + if (!window.Create(L"classico", origin, size)) { + return EXIT_FAILURE; + } + window.SetQuitOnClose(true); + + ::MSG msg; + while (::GetMessage(&msg, nullptr, 0, 0)) { + ::TranslateMessage(&msg); + ::DispatchMessage(&msg); + } + + ::CoUninitialize(); + return EXIT_SUCCESS; +} diff --git a/Frontend/classico/windows/runner/resource.h b/Frontend/classico/windows/runner/resource.h new file mode 100644 index 0000000..66a65d1 --- /dev/null +++ b/Frontend/classico/windows/runner/resource.h @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by Runner.rc +// +#define IDI_APP_ICON 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/Frontend/classico/windows/runner/resources/app_icon.ico b/Frontend/classico/windows/runner/resources/app_icon.ico new file mode 100644 index 0000000..c04e20c Binary files /dev/null and b/Frontend/classico/windows/runner/resources/app_icon.ico differ diff --git a/Frontend/classico/windows/runner/runner.exe.manifest b/Frontend/classico/windows/runner/runner.exe.manifest new file mode 100644 index 0000000..a42ea76 --- /dev/null +++ b/Frontend/classico/windows/runner/runner.exe.manifest @@ -0,0 +1,20 @@ + + + + + PerMonitorV2 + + + + + + + + + + + + + + + diff --git a/Frontend/classico/windows/runner/utils.cpp b/Frontend/classico/windows/runner/utils.cpp new file mode 100644 index 0000000..b2b0873 --- /dev/null +++ b/Frontend/classico/windows/runner/utils.cpp @@ -0,0 +1,65 @@ +#include "utils.h" + +#include +#include +#include +#include + +#include + +void CreateAndAttachConsole() { + if (::AllocConsole()) { + FILE *unused; + if (freopen_s(&unused, "CONOUT$", "w", stdout)) { + _dup2(_fileno(stdout), 1); + } + if (freopen_s(&unused, "CONOUT$", "w", stderr)) { + _dup2(_fileno(stdout), 2); + } + std::ios::sync_with_stdio(); + FlutterDesktopResyncOutputStreams(); + } +} + +std::vector GetCommandLineArguments() { + // Convert the UTF-16 command line arguments to UTF-8 for the Engine to use. + int argc; + wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc); + if (argv == nullptr) { + return std::vector(); + } + + std::vector command_line_arguments; + + // Skip the first argument as it's the binary name. + for (int i = 1; i < argc; i++) { + command_line_arguments.push_back(Utf8FromUtf16(argv[i])); + } + + ::LocalFree(argv); + + return command_line_arguments; +} + +std::string Utf8FromUtf16(const wchar_t* utf16_string) { + if (utf16_string == nullptr) { + return std::string(); + } + int target_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + -1, nullptr, 0, nullptr, nullptr) + -1; // remove the trailing null character + int input_length = (int)wcslen(utf16_string); + std::string utf8_string; + if (target_length <= 0 || target_length > utf8_string.max_size()) { + return utf8_string; + } + utf8_string.resize(target_length); + int converted_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + input_length, utf8_string.data(), target_length, nullptr, nullptr); + if (converted_length == 0) { + return std::string(); + } + return utf8_string; +} diff --git a/Frontend/classico/windows/runner/utils.h b/Frontend/classico/windows/runner/utils.h new file mode 100644 index 0000000..3879d54 --- /dev/null +++ b/Frontend/classico/windows/runner/utils.h @@ -0,0 +1,19 @@ +#ifndef RUNNER_UTILS_H_ +#define RUNNER_UTILS_H_ + +#include +#include + +// Creates a console for the process, and redirects stdout and stderr to +// it for both the runner and the Flutter library. +void CreateAndAttachConsole(); + +// Takes a null-terminated wchar_t* encoded in UTF-16 and returns a std::string +// encoded in UTF-8. Returns an empty std::string on failure. +std::string Utf8FromUtf16(const wchar_t* utf16_string); + +// Gets the command line arguments passed in as a std::vector, +// encoded in UTF-8. Returns an empty std::vector on failure. +std::vector GetCommandLineArguments(); + +#endif // RUNNER_UTILS_H_ diff --git a/Frontend/classico/windows/runner/win32_window.cpp b/Frontend/classico/windows/runner/win32_window.cpp new file mode 100644 index 0000000..60608d0 --- /dev/null +++ b/Frontend/classico/windows/runner/win32_window.cpp @@ -0,0 +1,288 @@ +#include "win32_window.h" + +#include +#include + +#include "resource.h" + +namespace { + +/// Window attribute that enables dark mode window decorations. +/// +/// Redefined in case the developer's machine has a Windows SDK older than +/// version 10.0.22000.0. +/// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute +#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE +#define DWMWA_USE_IMMERSIVE_DARK_MODE 20 +#endif + +constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW"; + +/// Registry key for app theme preference. +/// +/// A value of 0 indicates apps should use dark mode. A non-zero or missing +/// value indicates apps should use light mode. +constexpr const wchar_t kGetPreferredBrightnessRegKey[] = + L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize"; +constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme"; + +// The number of Win32Window objects that currently exist. +static int g_active_window_count = 0; + +using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd); + +// Scale helper to convert logical scaler values to physical using passed in +// scale factor +int Scale(int source, double scale_factor) { + return static_cast(source * scale_factor); +} + +// Dynamically loads the |EnableNonClientDpiScaling| from the User32 module. +// This API is only needed for PerMonitor V1 awareness mode. +void EnableFullDpiSupportIfAvailable(HWND hwnd) { + HMODULE user32_module = LoadLibraryA("User32.dll"); + if (!user32_module) { + return; + } + auto enable_non_client_dpi_scaling = + reinterpret_cast( + GetProcAddress(user32_module, "EnableNonClientDpiScaling")); + if (enable_non_client_dpi_scaling != nullptr) { + enable_non_client_dpi_scaling(hwnd); + } + FreeLibrary(user32_module); +} + +} // namespace + +// Manages the Win32Window's window class registration. +class WindowClassRegistrar { + public: + ~WindowClassRegistrar() = default; + + // Returns the singleton registrar instance. + static WindowClassRegistrar* GetInstance() { + if (!instance_) { + instance_ = new WindowClassRegistrar(); + } + return instance_; + } + + // Returns the name of the window class, registering the class if it hasn't + // previously been registered. + const wchar_t* GetWindowClass(); + + // Unregisters the window class. Should only be called if there are no + // instances of the window. + void UnregisterWindowClass(); + + private: + WindowClassRegistrar() = default; + + static WindowClassRegistrar* instance_; + + bool class_registered_ = false; +}; + +WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr; + +const wchar_t* WindowClassRegistrar::GetWindowClass() { + if (!class_registered_) { + WNDCLASS window_class{}; + window_class.hCursor = LoadCursor(nullptr, IDC_ARROW); + window_class.lpszClassName = kWindowClassName; + window_class.style = CS_HREDRAW | CS_VREDRAW; + window_class.cbClsExtra = 0; + window_class.cbWndExtra = 0; + window_class.hInstance = GetModuleHandle(nullptr); + window_class.hIcon = + LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON)); + window_class.hbrBackground = 0; + window_class.lpszMenuName = nullptr; + window_class.lpfnWndProc = Win32Window::WndProc; + RegisterClass(&window_class); + class_registered_ = true; + } + return kWindowClassName; +} + +void WindowClassRegistrar::UnregisterWindowClass() { + UnregisterClass(kWindowClassName, nullptr); + class_registered_ = false; +} + +Win32Window::Win32Window() { + ++g_active_window_count; +} + +Win32Window::~Win32Window() { + --g_active_window_count; + Destroy(); +} + +bool Win32Window::Create(const std::wstring& title, + const Point& origin, + const Size& size) { + Destroy(); + + const wchar_t* window_class = + WindowClassRegistrar::GetInstance()->GetWindowClass(); + + const POINT target_point = {static_cast(origin.x), + static_cast(origin.y)}; + HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST); + UINT dpi = FlutterDesktopGetDpiForMonitor(monitor); + double scale_factor = dpi / 96.0; + + HWND window = CreateWindow( + window_class, title.c_str(), WS_OVERLAPPEDWINDOW, + Scale(origin.x, scale_factor), Scale(origin.y, scale_factor), + Scale(size.width, scale_factor), Scale(size.height, scale_factor), + nullptr, nullptr, GetModuleHandle(nullptr), this); + + if (!window) { + return false; + } + + UpdateTheme(window); + + return OnCreate(); +} + +bool Win32Window::Show() { + return ShowWindow(window_handle_, SW_SHOWNORMAL); +} + +// static +LRESULT CALLBACK Win32Window::WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + if (message == WM_NCCREATE) { + auto window_struct = reinterpret_cast(lparam); + SetWindowLongPtr(window, GWLP_USERDATA, + reinterpret_cast(window_struct->lpCreateParams)); + + auto that = static_cast(window_struct->lpCreateParams); + EnableFullDpiSupportIfAvailable(window); + that->window_handle_ = window; + } else if (Win32Window* that = GetThisFromHandle(window)) { + return that->MessageHandler(window, message, wparam, lparam); + } + + return DefWindowProc(window, message, wparam, lparam); +} + +LRESULT +Win32Window::MessageHandler(HWND hwnd, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + switch (message) { + case WM_DESTROY: + window_handle_ = nullptr; + Destroy(); + if (quit_on_close_) { + PostQuitMessage(0); + } + return 0; + + case WM_DPICHANGED: { + auto newRectSize = reinterpret_cast(lparam); + LONG newWidth = newRectSize->right - newRectSize->left; + LONG newHeight = newRectSize->bottom - newRectSize->top; + + SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth, + newHeight, SWP_NOZORDER | SWP_NOACTIVATE); + + return 0; + } + case WM_SIZE: { + RECT rect = GetClientArea(); + if (child_content_ != nullptr) { + // Size and position the child window. + MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left, + rect.bottom - rect.top, TRUE); + } + return 0; + } + + case WM_ACTIVATE: + if (child_content_ != nullptr) { + SetFocus(child_content_); + } + return 0; + + case WM_DWMCOLORIZATIONCOLORCHANGED: + UpdateTheme(hwnd); + return 0; + } + + return DefWindowProc(window_handle_, message, wparam, lparam); +} + +void Win32Window::Destroy() { + OnDestroy(); + + if (window_handle_) { + DestroyWindow(window_handle_); + window_handle_ = nullptr; + } + if (g_active_window_count == 0) { + WindowClassRegistrar::GetInstance()->UnregisterWindowClass(); + } +} + +Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept { + return reinterpret_cast( + GetWindowLongPtr(window, GWLP_USERDATA)); +} + +void Win32Window::SetChildContent(HWND content) { + child_content_ = content; + SetParent(content, window_handle_); + RECT frame = GetClientArea(); + + MoveWindow(content, frame.left, frame.top, frame.right - frame.left, + frame.bottom - frame.top, true); + + SetFocus(child_content_); +} + +RECT Win32Window::GetClientArea() { + RECT frame; + GetClientRect(window_handle_, &frame); + return frame; +} + +HWND Win32Window::GetHandle() { + return window_handle_; +} + +void Win32Window::SetQuitOnClose(bool quit_on_close) { + quit_on_close_ = quit_on_close; +} + +bool Win32Window::OnCreate() { + // No-op; provided for subclasses. + return true; +} + +void Win32Window::OnDestroy() { + // No-op; provided for subclasses. +} + +void Win32Window::UpdateTheme(HWND const window) { + DWORD light_mode; + DWORD light_mode_size = sizeof(light_mode); + LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey, + kGetPreferredBrightnessRegValue, + RRF_RT_REG_DWORD, nullptr, &light_mode, + &light_mode_size); + + if (result == ERROR_SUCCESS) { + BOOL enable_dark_mode = light_mode == 0; + DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE, + &enable_dark_mode, sizeof(enable_dark_mode)); + } +} diff --git a/Frontend/classico/windows/runner/win32_window.h b/Frontend/classico/windows/runner/win32_window.h new file mode 100644 index 0000000..e901dde --- /dev/null +++ b/Frontend/classico/windows/runner/win32_window.h @@ -0,0 +1,102 @@ +#ifndef RUNNER_WIN32_WINDOW_H_ +#define RUNNER_WIN32_WINDOW_H_ + +#include + +#include +#include +#include + +// A class abstraction for a high DPI-aware Win32 Window. Intended to be +// inherited from by classes that wish to specialize with custom +// rendering and input handling +class Win32Window { + public: + struct Point { + unsigned int x; + unsigned int y; + Point(unsigned int x, unsigned int y) : x(x), y(y) {} + }; + + struct Size { + unsigned int width; + unsigned int height; + Size(unsigned int width, unsigned int height) + : width(width), height(height) {} + }; + + Win32Window(); + virtual ~Win32Window(); + + // Creates a win32 window with |title| that is positioned and sized using + // |origin| and |size|. New windows are created on the default monitor. Window + // sizes are specified to the OS in physical pixels, hence to ensure a + // consistent size this function will scale the inputted width and height as + // as appropriate for the default monitor. The window is invisible until + // |Show| is called. Returns true if the window was created successfully. + bool Create(const std::wstring& title, const Point& origin, const Size& size); + + // Show the current window. Returns true if the window was successfully shown. + bool Show(); + + // Release OS resources associated with window. + void Destroy(); + + // Inserts |content| into the window tree. + void SetChildContent(HWND content); + + // Returns the backing Window handle to enable clients to set icon and other + // window properties. Returns nullptr if the window has been destroyed. + HWND GetHandle(); + + // If true, closing this window will quit the application. + void SetQuitOnClose(bool quit_on_close); + + // Return a RECT representing the bounds of the current client area. + RECT GetClientArea(); + + protected: + // Processes and route salient window messages for mouse handling, + // size change and DPI. Delegates handling of these to member overloads that + // inheriting classes can handle. + virtual LRESULT MessageHandler(HWND window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Called when CreateAndShow is called, allowing subclass window-related + // setup. Subclasses should return false if setup fails. + virtual bool OnCreate(); + + // Called when Destroy is called. + virtual void OnDestroy(); + + private: + friend class WindowClassRegistrar; + + // OS callback called by message pump. Handles the WM_NCCREATE message which + // is passed when the non-client area is being created and enables automatic + // non-client DPI scaling so that the non-client area automatically + // responds to changes in DPI. All other messages are handled by + // MessageHandler. + static LRESULT CALLBACK WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Retrieves a class instance pointer for |window| + static Win32Window* GetThisFromHandle(HWND const window) noexcept; + + // Update the window frame's theme to match the system theme. + static void UpdateTheme(HWND const window); + + bool quit_on_close_ = false; + + // window handle for top level window. + HWND window_handle_ = nullptr; + + // window handle for hosted content. + HWND child_content_ = nullptr; +}; + +#endif // RUNNER_WIN32_WINDOW_H_