diff --git a/docs/conf.py b/docs/conf.py index c5fa3fb6..de00cd6c 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -48,7 +48,9 @@ "sphinx.ext.todo", "autoapi.extension", "sphinxcontrib.mermaid", + "myst_nb", ] +nb_execution_mode = "off" # Add any paths that contain templates here, relative to this directory. # Add any paths that contain templates here, relative to this directory.cv diff --git a/docs/examples/create_imagenette.py b/docs/examples/create_imagenette.py new file mode 100644 index 00000000..db0cd5ad --- /dev/null +++ b/docs/examples/create_imagenette.py @@ -0,0 +1,38 @@ +import typing as t + +import numpy as np +import torchvision.transforms.functional as F +from create_sq_ds_from_hf import create_sq_ds_from_hf, to_np_dict + + +def to_np_dict_imagenette( + item: t.Dict[str, t.Any], + output_size: int = 300, + img_key: str = "image", +) -> t.Dict[str, np.ndarray]: + """Converts imagenette images to a fixed, square size.""" + + item = to_np_dict(item) + + img = F.to_tensor(item[img_key]) # converts from HWC to CHW + img = F.resize(img, output_size) + img = F.center_crop(img, output_size) + img = img.permute((1, 2, 0)) # convert back from CHW to HWC + + # handle grayscale images in imagenette which cause trouble downstream + if img.shape[2] == 1: + img = img.repeat(1, 1, 3) # repeat channel dimension 3 times + + item[img_key] = img.numpy() + + return item + + +if __name__ == "__main__": + create_sq_ds_from_hf( + "frgfm/imagenette", + to_np_dict=to_np_dict_imagenette, + shard_size=10000, + subset="320px", + hf_split="train", + ) diff --git a/docs/examples/create_sq_ds_from_hf.py b/docs/examples/create_sq_ds_from_hf.py new file mode 100644 index 00000000..af4a0033 --- /dev/null +++ b/docs/examples/create_sq_ds_from_hf.py @@ -0,0 +1,54 @@ +import typing as t +from pathlib import Path + +import numpy as np + +from squirrel.driver.msgpack import MessagepackDriver +from squirrel_datasets_core.driver.huggingface import HuggingfaceDriver + + +def to_np_dict(item: t.Dict[str, t.Any]) -> t.Dict[str, np.ndarray]: + """Converts values in a dict to numpy arrays.""" + return {k: np.asarray(v) for k, v in item.items()} + + +def create_sq_ds_from_hf( + hf_ds: str, + hf_split: str, + to_np_dict: t.Callable[[t.Any], t.Dict[str, np.ndarray]], + shard_size: int, + squirrel_url: str = None, + **hf_kwargs, +) -> None: + """Creates a squirrel Messagepack dataset from a Huggingface dataset. + + Args: + hf_ds (str): The Huggingface dataset name. + hf_split (str): The Huggingface split name. + to_np_dict (t.Callable[[t.Any], t.Dict[str, np.ndarray]]): Function converting data to numpy arrays. + shard_size (int): Shard size of the squirrel dataset. + squirrel_url (str, optional): Where to save squirrel dataset. Defaults to None. + """ + + it = HuggingfaceDriver(hf_ds, **hf_kwargs).get_iter(hf_split) + + # create a default path from hf data + if squirrel_url is None: + url = Path(hf_ds) / Path(hf_split) + url.mkdir(parents=True, exist_ok=True) + url = str(url) # squirrel wants str + + store = MessagepackDriver(url).store + + print("creating squirrel dataset under", url, "...") + ( + it.tqdm() # prints "12345it [00:08, 5810.89it/s]" + .map(to_np_dict) + .batched(shard_size, drop_last_if_not_full=False) + .map(store.set) + .join() # ensures direct iteration over stream + ) + + +if __name__ == "__main__": + create_sq_ds_from_hf("cifar100", to_np_dict=to_np_dict, shard_size=10000, hf_split="train") diff --git a/docs/examples/squirrel_dali.ipynb b/docs/examples/squirrel_dali.ipynb new file mode 100644 index 00000000..744d0cd6 --- /dev/null +++ b/docs/examples/squirrel_dali.ipynb @@ -0,0 +1,739 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "caa4f9bb-78eb-4ba8-835d-66e8ffe92a39", + "metadata": { + "id": "caa4f9bb-78eb-4ba8-835d-66e8ffe92a39" + }, + "source": [ + "# NVIDIA DALI\n", + "\n", + "This tutorial showcases how Squirrel and NVIDIA DALI, a GPU-accelerated data loading and data augmentation library, can work together. The below code was tested on the following system:\n", + "\n", + "- NVIDIA-SMI 460.32.03\n", + "- CUDA Version: 11.2\n", + "- GPU: NVIDIA Tesla T4\n", + "- Python Version: 3.8.16\n", + "\n", + "Required dependencies can be installed with" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a10c454f", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "!pip install squirrel-core squirrel-datasets-core[torchvision] squirrel-datasets-core[huggingface] seaborn pandas ipywidgets\n", + "!pip install --extra-index-url https://developer.download.nvidia.com/compute/redist --upgrade nvidia-dali-cuda110" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "3UovhW4CDcvd", + "metadata": { + "id": "3UovhW4CDcvd" + }, + "source": [ + "## Preparing a Dataset\n", + "\n", + "First, let's prepare a dataset with which we can run this tutorial. The code downloads the Imagenette dataset from Huggingface and pre-processes it into a Squirrel Messagepack dataset of images of shape `(3, 300, 300)`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3d69f5b", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "from create_sq_ds_from_hf import create_sq_ds_from_hf \n", + "from create_imagenette import to_np_dict_imagenette\n", + "\n", + "create_sq_ds_from_hf(\n", + " \"frgfm/imagenette\",\n", + " to_np_dict=to_np_dict_imagenette,\n", + " shard_size=1000,\n", + " subset=\"320px\",\n", + " hf_split=\"train\",\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "863d578f-3f44-4e95-a535-0be3563ad974", + "metadata": { + "id": "863d578f-3f44-4e95-a535-0be3563ad974" + }, + "source": [ + "## Integrating Squirrel with DALI\n", + "\n", + "Let's understand how we can integrate Squirrel into DALI. DALI is based on a concept called `nvidia.dali.Pipeline` that defines the data processing graph. Let's see what's happening in the below function `get_dali_it`. \n", + "- Within the pipeline definition, Squirrel interfaces with DALI as an `external_source`, an API by DALI that reads from a given iterable. \n", + "- As an example, we define two run-time augmentations (center-crop and rotation) that DALI is instructed to execute directly on the GPU.\n", + "- The pipeline is then built, and a pipeline instance is handed to the `DALIGenericIterator` that returns PyTorch tensors. You can think of the `DALIGenericIterator` as analogous to the `torch.utils.data.DataLoader`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "80735289-5c09-40b5-8205-3489ce45d3b0", + "metadata": { + "id": "80735289-5c09-40b5-8205-3489ce45d3b0" + }, + "outputs": [], + "source": [ + "import typing as t\n", + "from collections import defaultdict\n", + "from time import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import nvidia.dali.fn as fn\n", + "import nvidia.dali.types as types\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import torch\n", + "import torchvision.transforms.functional as F\n", + "from nvidia.dali import pipeline_def\n", + "from nvidia.dali.pipeline import DataNode\n", + "from nvidia.dali.plugin.pytorch import DALIGenericIterator\n", + "from squirrel.driver.msgpack import MessagepackDriver\n", + "from squirrel.iterstream import Composable\n", + "\n", + "# properties of the squirrel dataset\n", + "URL = \"frgfm/imagenette/train\"\n", + "DS_LEN = 9469\n", + "IMG_KEY = \"image\"\n", + "LABEL_KEY = \"label\"\n", + "\n", + "# augmentation config\n", + "AUG_SIZE = 200\n", + "AUG_ROT = 30\n", + "BATCH_SIZE = 512\n", + "\n", + "\n", + "def get_dali_it(\n", + " it: Composable,\n", + " already_batched: bool,\n", + " batch_size: int = BATCH_SIZE,\n", + " center_crop_size: int = AUG_SIZE,\n", + " rot: float = AUG_ROT,\n", + " num_threads: int = 4,\n", + " device: str = \"gpu\",\n", + " device_id: int = 0,\n", + " img_key: str = IMG_KEY, # image key of squirrel iterator\n", + " label_key: str = LABEL_KEY, # label key of squirrel iterator\n", + ") -> DALIGenericIterator:\n", + " @pipeline_def\n", + " def pipeline(it: Composable) -> t.Tuple[DataNode]:\n", + " \"\"\"DALI pipeline defining the data processing graph for a Squirrel Composable that yields batched (image, label) tuples.\n", + "\n", + " Args:\n", + " it (Composable): Squirrel composable.\n", + "\n", + " Returns:\n", + " t.Tuple[DataNode]: The outputs of the operators.\n", + " \"\"\"\n", + " imgs, labels = fn.external_source(\n", + " source=it,\n", + " num_outputs=2,\n", + " device=device,\n", + " dtype=types.FLOAT, # means float32\n", + " batch=already_batched,\n", + " )\n", + " imgs = fn.crop(\n", + " imgs,\n", + " crop=[center_crop_size, center_crop_size],\n", + " crop_pos_x=0.5,\n", + " crop_pos_y=0.5,\n", + " device=device,\n", + " )\n", + " imgs = fn.rotate(imgs, angle=rot, device=device, fill_value=0, interp_type=types.INTERP_LINEAR, keep_size=True)\n", + "\n", + " return imgs, labels\n", + "\n", + " pipe = pipeline(it=it, batch_size=batch_size, num_threads=num_threads, device_id=device_id)\n", + " pipe.build()\n", + "\n", + " return DALIGenericIterator([pipe], [img_key, label_key])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "88b61122-8d1b-4125-b997-9d551a91b2fa", + "metadata": { + "id": "88b61122-8d1b-4125-b997-9d551a91b2fa" + }, + "source": [ + "Now that we have a function that creates a DALI data loader from a Squirrel `Composable` let's create our Squirrel iterable. Let's have a look at the first four images of the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "82cbc870-d376-4746-8d6e-425b75b4ff9a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104 + }, + "id": "82cbc870-d376-4746-8d6e-425b75b4ff9a", + "outputId": "7ed746f3-22cb-4404-de44-68cd31d30374" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_imgs(imgs):\n", + " num_imgs = len(imgs)\n", + " f, ax = plt.subplots(1, num_imgs)\n", + " for i in range(num_imgs):\n", + " img = imgs[i]\n", + " if type(img) == torch.Tensor:\n", + " img = img.cpu().numpy()\n", + " ax[i].imshow(img)\n", + " ax[i].set_axis_off()\n", + "\n", + "\n", + "num_viz_imgs = 4\n", + "access_img = lambda x: x[IMG_KEY]\n", + "\n", + "sq_it = MessagepackDriver(URL).get_iter()\n", + "imgs = sq_it.take(num_viz_imgs).map(access_img).collect()\n", + "plot_imgs(imgs)" + ] + }, + { + "cell_type": "markdown", + "id": "68a75729-aae7-47d6-8c5c-5b005abb9a82", + "metadata": { + "id": "68a75729-aae7-47d6-8c5c-5b005abb9a82" + }, + "source": [ + "Hooray, we are seeing a bunch of images. Now let's feed the data into the DALI pipeline and obtain the augmented images." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "275f9a00-3761-4450-87fb-238aa709155d", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104 + }, + "id": "275f9a00-3761-4450-87fb-238aa709155d", + "outputId": "7a57b133-9930-4268-d907-19a95dc4aebf" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAABXCAYAAACnZJZlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZCl53nd93vf91vv1ntPz75hBjODwb6S4C4SXA3S3CkuoiSKFLVEdmwnpdhSXK5UpSoVOxXnr5RjOUrsUiLJMmU5pZJoJqIoSiIJLiBAYpnBADOY6en9rt/6bvnj624ArApCAgNAVZ5T1TUz3T3d9z793fOd9zzneVp47z3XcR3XcR3X8apAvtYP4Dqu4zqu4z8lXCfd67iO67iOVxHXSfc6ruM6ruNVxHXSvY7ruI7reBVxnXSv4zqu4zpeRVwn3eu4juu4jlcRwYt9UAjxin7zKJJ0uwE3nj1NMpeiXEVe58TtFk+fv8zmRp92GvEPfu1X+NXP/z2UnMb5gK3RmEuXLtFOSp459zWeeOLPGQweoyxWMHVOXRq0CfF4pJJIUpb23cN9b/kUxsPT3/8BX/+//yXHT4xZ7zv+1e8YivKlPYeXk7h7peubJAlvePOb+IVf+iLHbjhGFEeoQCGlIAhDhFQ453DOEgYBURTtPibv/fbHHN57pJDgHHgIgmD38Xvv0VrjEXghqOsarCWJIvCeRx95lJ/56U/T7/df0nN4qfV9pWsbRim33PNe3vepf0R3fi/5OCObZEwmQybjIZNhn9Fgnc3NyxiZcPebHuSn3nIHB2clRaFZGypGw4xJljMc5YwmJcZYTK3RRUlZ5xT5GJ0PsfkWxWiVSf8ZsvVzqHrEdDJm7AU/fHoTa+1Leg5/U2sbhJKjx7vcdHtKd1rSarew1iKlJAgCwjBkZmqaIs+ZZDlKKWpd0+60ERLGkzFVVdKdahMnEcPBEF1ZZmfnufXW27n4zCW+/8h3mZ3rIZWn1QpJWxHalqyurnHo4FHWly3/6//0JGXhXtJzeLHavijpvlJQSnDXXfv5hV+4gy//6UNs9R2Ri5ldSHl2w3D10hbZwHL84Cn2L81jKkWW5SRJgPMCXVylHn+PH377r1he/h6j0UWKfBOsbnjBSZTyVDWAQypDUY7xboJDUZk+ucnZGhlmpiNuulHw0MP6tSjFKwIpJWfO3sRnP/fz3Pv619HudggCBQIQoAKFQOCtAzyC5iIxxiCl3CVT5xwCQZok4LbJdftiklLuvgkh0FqDlCRBgAOkEAgpOXPmDB/88If4l//if3kNK3INISQze4/z+vf8Erfc+SA2TFhd26IYj8nzCUU+opyMKCYDivEGWf8KmZNcvvwUK+un6CVdhBY44yi1Ii8FeQlRGNFrRygUGEdpcuoqx1YVdTGiGC8y6i+wMTuD3byEKteJo5QpPWLr4vdf66pcEwgBe/d1eP2bDnDgcEpejDFeEwQBWmuqqiJNU5IkodY1cZJS1jXOO8I4oNWOqHWNsQYkFGVOGAR0Wh1EWxGGAYNBn0k2wRpPXVlU4KiUoNVpEYiYXq9HXRXM70m58eaUh7+ZXfPn+aqTbrcD73zbEv/DP/8E84sx1mzylT8ZEEdtjh04xBNPLKNshw8/+D4++IH3c/KGQ3TaId5pRsNLXL36OM9c+B4XnnqI8fgZinyNIitwxqGUwnmHlx7rJBaJcBoCQ5atMRpsoOlwaXWTmikMPaSKeNMbUi4uP8n6+vDVLsc1x779+/jwJz7O+97/IL2pKaSShFGIlAKExzuPdwIvBUptEzEOIQTONXd1pVRDqEKA9ThjG7UrGzdqh5ChUT075Ouda8hWqd3PC6OQz/zcz/DlP/1TLl289FqU5Joh7S6y/9SbmDt5Jzqe4Yfnf0gQKLyrcYVBlyPqok+VT6iyPtlwhfHG04yLjMcfP8DBY7fQTk4xFQrKylDUJc5Z5uc6tJOIUCi8dpiypraeOgZnU+oyokhDep0uM9NTTKZm2NraZIsUtbAPsbWBHy+/1uV5WZiajrnv/kOcuXmOMHR4DG0RU9SWqqowxuCcIwwjoihCKgUSojgiK8ZICSoCvMG4gk67jbWWosiJwoQgaFTy8vJl1lY3aLXaKBlgdMmoyojiEKUcoQqRQuBszdk7Ei48kTMeXtv5sVeNdJMYTt0QcvqEY252QH9jwOL+Je573Wm+840/ByFYmDvIO976Pt78xndy9sxppqfaBAEYnbG1cYHvP/plzp/7JqPhJYp8jbqaYLVGIFAqwCFwTBGHJXEomWhPPtY4LyjKkqvLm+zZe4Tbbnk3737g5zhwYB+dToh1noWDv8tv/KP/FmNe2lHttUav1+OB97ybj3zi4+w/eIAkiTHWEkURYRiBoLELvAUEQRCglMJ7j/fgvENKiVKKQCmEF3jvcOI5i0GIhqh3bAetNcaYXRJu/n9AABhj0FojpWRxcZGf/dzP89/843/yko/CryXitMeRmx/g2M3vRsqYvJyQDUZkIsdLjS4zbDbG1aPm7+WEMhtQjLeYjNepyjEbz3yPR39wB61kmtnZGXStcSZnfjphz2yPJAio85psmCFEhcAghcZ5gxcOE4T4OEWxiBIBQ7dKXWrK+CCc+hg89D+Cf2lH4dcSSao4earHnfcsMjPbIwg8QSiQMkCFFutDilGG856p3gyzs3PNtewd2hlEYEnbIQ6DcSVSGKzNMSYkiVtIGRCFMcZ44jglz7eIk4jp6WnCUDIa9ZlMhgy3hoSRIIoVcRgShoq5+Zgzt0Z882sV13Ju9xUn3ThSnDiiuP20ZXFPTKUdRVnznYce4cSpPRzeP8+xYy3OP70B0vPTH/8sRw8fQcoK4TVlMeKHj36NRx79E9bXH6UqtyizEXXZmLBSKTwS7SRG7GFh/m8x1XsEb76H2GozGefgJEIqpqcXefvbHqTd7qKCxoP0WJx3fPbnf4U//MOv8Nd/9VevdEmuKaIo4p777uPjn/40p86cJoxC4iTGek8QhqStFgDW2l2SlFLuEmVDur7xv4UgkArhAPwu0e5gh5SVUjhrqeoarfULiFiEgkBKwjBECNF4cUrygQ9/kP/w7/+Ib3/rodemUC8BKojYf/J13Pzmn2Nh3xmEcdgyp11klEVOqUsKPaTKK0b9NcZbz2DyDUxVYqoCU1cYo1FSEI0vcvXi93i0FbO4cJQwCDm4t8f8XI+F6RhXWWxWESoDgcPpCnRBnVdYB7oqGA62UMITqIgEicy2qAc59BZg9hhsnn+tS/ZjQynBkaNd3vTWQ/SmwViHNhVBGCGkwDiLcyECSOOAIApodTogImpd4YUHPNYbklYIHgSGMJSkaUxdlzgr6PWmaLXaje3oQcmINPaEgSKOA5IkwvkUazV1pcE7dKhJopi5mWlOnpnw9DnD2tVrJxZeMdKVUnLrrTfx93/tHqbEwzz0zYepvUYoiTEBjz7yGG+9eiN7ljq84Y3HOX3raf76u2sQOFRocfWYixcf5jvf/o9cuvQd8vxZynwLU2mc9UgV4oXHeI/1Ma3uaZYO3s0kO0AVrBFHkqTfQ5gJTjqUsOAr0k6CCCXgkX7b0ZSSudkFfv3X/yE//YmPkWXX3se51pBScur0aT7z8z/HHXffTRCGOOewzuE8u4T5o6p0h3R3mhJCCIQA4RsrobbVCyyDHX8XmgaalBKcxyMQQuw233ZUM4C1btcnts4ShCGzacp/9p//Hb74858nz/PXsHL//xBCsnjwFHe/4/PsP/UWRBATC0XowesueZFTVQXjsiAs2wgnycZ9irxgsnkFXxcIBGGQ0u30SJMu7c4Csa8YDTYRPqLX6cGeNrGUKOdx1iC8QwmJEwq8xFnRNC+1ocqHrK1dxNqaXqtNPVpDrD+OzDRizx1Et36c+mv/FK+L17p8LwohYG4h4e575zl6vEtvqoU2jiIv8RYCazGVwhiFdxLhQ9qtCBlKal1jvQEhqHSNVBarK5T0RLHE+4YYe70uo+GEsiiYnp4lDEPqyuCMR1eWIAgRwjMaDXFOo5QgjEK8UyghqYuazOXMzM2zuDTDzXfVfPWPLcZcmxq8IqR74MABfvmXvsjP/uxnmJt6htULv8Uz586zujUiUjGttMVkXPDHf/QVjh7vECWnOXrk9fzW//47PPbYE7SDnEcf/jJPnv8Kk9Gz1OWYfNykEoIgQCiHxeOQqGgvJw+/i8XZW6Ed842Hr6KLkL0LMWEqSCJJhUa5krWVi2hToMK4eaACBBKFxQnL23/qLbzvPe/h//y933slynLNsHfvXj792c/yvg+8Hy8Ebttvdd4TRhFqu/FgrWUymeC93/Vp4zhuPnebjKUQCBrVa3dUr/ckSUIURUBjFQghsMaAaMh425NABHKbuJ9TxLrWWN00Jp1zTS7Red5w/+t54J0P8KV/96XXoGo/Hqbn93PvOz7D2dd/lLS1hELhKAm8AwMmEEgZI5WnFhInY6QMKcucjbVnYWsZRE2aJExN72du4QgL+44xtXSMeHofIp3COwGuYrB2hQsuo99KSZOIMGmjlEILj7US7xVCCALhUNRkkw3W1q/QiyQ2G1ANrxAzRZS06Z35KYYbjzD6/h++1iX8/0SrLTl7+zw33TbH4lyXJE6ptMUKgxMheWWonSJCYU1AFKZI0VgNQgrKsqLSE5I0QkpBXZWMxwN0nTC/MEMYhc1Nqdel1Wpz+dkVNjY2wEEQRDgrqOqcWkPaCphMRkjpiOIAKQVCKiLViJe8rHBbW8Rpwt5DAYeOh1x44to0268p6U5N9fjIRz7C3/17v8Sp42fxErwLmVm6mWMnv8Lg2xNqPGEEkY04//g6dQa33HWGhenTHNoT8/h3vsTy+Yzh8By6XqMuCspcUJegwggrKqwzKDXHgX1v4vihtzEzs5ei3kREhqW98O3vDZifb9PuKJIwxFYZzuVsrl+gyjdJ0ylgx6QRgESgSSLF3/+7/4D/56tfZW1t7VqW5pqg2+3yvve/n899/vPs3b+fzf4W1lqCqLlQhJLIIKDSGvBg3S65ttvtXaXqnMM7C65JGIhtVbvTHNuJge1YBN57hPfNEdB7giAgSRKUUpR1hdi2K6SUjZq2prmIhWzsH+8bm0EIvvCFz/MXX/uL5sXwNwhJq8edb/wQb/nbv0LaO4ipJd20RS+VeNu84MuiJncWGQhUHJA4jbESkSTMzu8nP3QzgQJbrtFKehw6dJobz97B3sM3knRmQQTUVc5kMmIy6jPpL/PDq08ReEuv02Fmfon52QWUjNHWURuL9xbvapQ3CJMxWn2SzJWEAoTRzM7OEC0uEc8ukL75i+QXvo6Z/M2qbRRLTp6Z4vjpiN50RBQ7ZBgTtXrosgLvkWkPbyvyElTUQxIShx2yfIjH4Rx0WvMEJsc5S7sVUteK8XhEVTvquulfOOcZj8YsLC4yOzvFsxdXmjTC7AJSBSAMRZkjVALCMZ6M6NCi1Uox2uCdIE1jVBSSZRnWO9J2wpk7HcvPGsr85Zu714R0gyDkdW94A//4N/4r7r/vflQiERi8V2gb4uQJjt/4Jp584t8yyA2hrEFITBVRTFKW9hzi/FNf4eD+FbLsKTY2ttDlhLq0eBsgRUDccmhfIlTC4swd3HXbR1laupHBaA2CDF16Qp8y3w3xk4o6a9OJC9KkQ5YN0DjGowHD/iozs0e2lZnFEwAePDgbcPj4Ep/+9Hv5Z//sX11T8/zlIAxD7n396/jVX/s17rjrboSSrKysMBgM6E1N4Zyj0jUgKMqCMAxJkoRASUxdY4whDEOCINhteEnfmFw7VgLwggTDToRsh6itMVhrcc4RBMGuYhZSUtbVC/zh5otJUNvEC3hjEd5z4oYbeO9738Nv//b/9toU80cgVMDBE/fyrk/8OifP3IuK2tSlptUS9FKYakFVSbwP0NYSiRCVRMTOEkWeKMxwWtKJZ2glp9k736UsR0xP9zhz+k4OHb6BdquNc5ayKMicxQcaEXlk5chczmjUp786YeVywuzcAaZnF1FRB2MdylW4KqeY9CmGG5T5APSAdhgQd+YIFw8Tzh9CRBHtPceZu/PDrH71f+Y5UfHaQSrYfyjm9vum2X+wg3OOLKvwPqLMA6z1JK0l4iTCSkulK8q8YDSJmO9Nk6RtrJNoO8LisD4gDCOsqVEqQuuCKJ7BUzKZ1KRpjLWe/mCAlIpet8fMTE6WlZR1QZqkKOVJWyGgmZubJkkC6qrAWdsc3pyD5uxHbTTVuCYIAlpTlpM3x3z/Gy8x0P88vDzSFYKlA0d5x4Of4sEPvJuzd51BhSGYitqPEG4dZ3K8zFk6ssShg/OMn9xEuxoZeISN2BwV/PH/9W8YFls41vE2x2qHqQSCGBE6hKqpnSQNb+Le2z7Frbe8ARUa1vsbGG8ZblZYHKNinck4I+sXDNdK5o/WRC2F21AgLdrUrK1vcuRo00QT0iPQ4D3WS5yqqO0T/Oynb+RLfzDDU0+/tED/tYIQghMnT/L5L36Rd73vvbQ7zYW71e+zsbmJCgKsd1jTNM2899R1TZqmu2Qp5HMertqOcjXer8fW9a5C3bEInh8L21GojdptXsbPTz00TTSJs5Za6xc87sb1lXgJIBCBAg1hFPHRj3yYr371qzzzzMVXv6jPQ9Tdw5G7Psidb/kk84ePY51jKnEEnYBECSI8USBARDjhkVGI8x5jLdZqqsRRpB6nPVUpmIp7jJKDqEBx7PhRjh85Ri9JqKuSorL4wFMHkjQKEVEHn1isLvA6orSeOl9lJd9isDlFMrVE2plB6Jxy2Gdj9RKD4SaYHGVyfDSNnT6KXzxD1TuMkgnW5ojbPox85E9wW0+/prWdXQi543VdTpxub18rFULERMEMVR5RTDxJGjBlWwwnFWv9CSKIiYI5FubnOHpgH9YVdKdSvF9knA9ZXb9CVVXEUUi3t4AKNGmq8GR4iiYmaiWIgP5giJIB09NTJEkKSKTyCOuQ3iMkTE+1mJ5qsbW1xWg0QWtDGEZobdBOo03TB0nbbcIw5MRNgkvnDYPNl2fuvmTSbfd6vP6BD3D/Oz/IzNQCg4nnoe8/yZGFCcXwIUbZeWy1QRREqM4We/e0OXrDTVy48NfUWoEyqECSZZtcXs5pdwMcGd5InAmQiiYG4i0qXODGwx/gLfd/kk4nojeVsrU1IklniasIO7qMtZ58VHH5mSfo95dpX21z+IgjamtUEGLROD/g8uVnufPuplPf2AqChhks2eQCo/W/4NLjX+Ges46nLzZ9jNcCi4uL/PQnP8UnP/MZFhYXEVLggbwo2NzcBCFwAiZFTrfbbZoFdQ08lzLQWlNWFXZ7qKHT6ewmCqwx4CxmW8GGYbhtMXi8d3S7XQCqqsJaS5IkeO9QsvEZ8zxrPHEBWle7dfpRf7fxmwVIQe0NysPpm87wxS98gX/4G7+JuVbdiZ8AQTpN5/C9tPedJVg8xjCvGWcFi1OzzE3F9LoQeo2pJcZIrJOoIKYtFdZ7rKmpCk0pFGmQYrVionKq2hGnHQ4c2MeJG44z220j6hIiiRUxGkFsDaYO0ZEncG1Sp5HeEGAppKcqJ0z6F5lkW4RRTF1WTPqbDDcvM9m6jNQZiIgqOUA1eydm5nZ0uACVwdaWMtiLu/MX4Cu/Ce7Vr227o7jl7i433d4ibSkClVJXAguYOkKKaWrdoa4SnJumLCEI2tx86iZOnDrJwf37OLh3D2kUUFUjat3YV1k+4clzj7F8dZnLV54lzz3WtKnrkrQdIEUEKMpqQhR1iEJJVWkCFRLHMUIIqqpCSoEKmnxunk8IgoBOp4O1jskko6q2U1GBxFhLWdVEUUQap4TKc/ZOydf/4/BlpfN+YtIVEqb3TPGGd7+f+9/2acIoRViPcausLn+XjYuPUg43WL46wOQhC/PQncspjhzkzPF9zO6TjJZrcM2dJ4oc1k+odYB3jcPqlcF5R1WnLO29hze/5XOcufF2ghiKrCKI2yRtQ2d6kXYvp9XqMNrcZDkv8Dai1ilrVx3Cz6HiKwSRwmmFkBPWVr9HXuUEYYhEIJFIUdDvP8HD3/rXLF/6Mpcunmd6WrBnQXF19dXNlbbabd71rnfxxV/6ZU6eOAlK4mmytFobtra2qK1BhKpRoV7sphB21OlkMmkI2PvGuwWyLENrTbvdbkhRNGp/h/SccwjRRL+SJCaOY+q6foECDqMI4ZpEgpQgEGhtEEAYKJx/jnSdcxitsa75oUqlcNsTcQh417vfxe//2z/gWw+9ehEyFabMHruf2TPvoVARg81nqTdXaKVT7F9cotcOWepK4h4IE1IFgqJoBm2EUkglsM6iK0fgJLGMKSXkzuMJcEIxv7jA8WMHWZpvo6ylNh4RhETCoR0EdUwQJqjAoFRIECT4qIePPdp6jANdFkw2V8iLnCwbMhmtU5Zb1FWO00BrgWTqBoLpg9g0xuoJrq4xRuMIECfeCY99CX/5m69abcNIcPKmLve+eYbZeYWuDd5HKNkmUAojJIgYbWfBzzAZGzqdPdx3353ccetNHDq4n7STIAMI8EjrEXIah8f55qI5fvgmsmzEs1cu8vhTT7K5dZWnLjzC+tWLLC6mCKcoC4HzTfMN6cDb5/LowoFs0gt15ah1vZ14kLTbLbQ2u0mfAEkYSFQrwTuojCYIEvYecswtSDZWXzrr/tikKwR0Z9osHJ6iN99jZqaL15YgLEl5kpiHCdxVnDVs9h2r/QBd1ohE0h92OXr4IK32LMcOH2Ht6mOMvdodSW1iYBCECi80CEnAMSp9nLe+/b/ktjtuR4oxpna0p2JUoJhLDmC1p9ttMdMOWInh+Mn9HDp5lKS9lyuXnkGJPi5YJk49RaGQSnL54qOcO/cQ84tHCWSAcAVbm49w/tyfsnr5IZYvX6Q/0BiVcvstgs0/K6hfhQnhIAi44847+dVf+zu8/v77icIIdnxSwOPJ8oJJXjTTONvDDjsNsKIodiNczlqcNURBgBcKti+6nRSCUmpb8W57rlIhRGM9SCmpa81kkjUKlYZIsyxDCkESx0RhQF3Xu5NCxpjG4w2e292wO0q8PQxhrUWFAV6Al5LpmRl+8Rc+xw8fe+wVj+gJqZjZdwtH7v0Z0j03kdUT8q1nKfKcwmwSh22GN54lbRXMphEqlJQCrAWlHHGsmmahaOJbIvAQNbFDoSWV0VS6RgjYv3+B/fun6aYCW3gkAdJAXjmUFEgZIsMEoWqErxDWg5UIETeDJVKiVIw0JVn/Cuv9VSZlhnGCMJpj8dAhpvYcpTN3hGQ2wNpl9OAyuTZsqBQjFFoo9J0fYbj2KL5+ZeN5UsLe/S3uffMsR062iFKJrR1aW0xtibox3c4iwitqLRj2FXXlOXHiJt7//ndx+2030koCAi9BenwzRwpS4T0I7xFeoGtLXXva6Qwnj7eYm1+iP9pg/979fP3rX8bZEVZ7QjlNUfcpcoeSljBwzEynVLrGOIOSAuscRVlSlBnzc9Po2pC2eggBrVaLoiyx3hCFAUI2qYdsUqKrGq0Nh05AfxPsSzxI/Fiku2dB8eY3zrFpeiz3HWGoKLOc2Obs6RgO7cmYb+9DycM4AafOZjz99CqbmwNm98xw++kbWJovGa8+QiIhCRLGtd3+oQWEgdr2JQO8CIlbZzhz0ydJ0iMcPn4cqUqED3BCU1eCelKizQRvLZPhBsJLJnXFeDAmiAW33X6Cu+48ymj8LdY3L5B2ckaDEiEgLwumWin7FvcjfMXlZ5/k4e98ifXV77G5cYXxVoW3iulezFs/eiODrUf4y29PXlp1f0wcPXqUz33+Czz4gQ8wNTX1gmwsHrwQVLVmZW2NyWRCp9tpblbbo5Gbm83Sk7nZWcIgwClJHEW7QxDPf3t+plZK2dxNtxsI6nnju8PhiGA7DoYHpSRxkuKdR9eaLMuon+cJG9NYB0EU734NYPdrNuPGAi881nucFLztHW/nPe95N7/3e7//itW2M3uIY/d9kqUbH8DKhLwuMN5hrMbVJX5ymS1p2Bi+lVK2kRGkgJc1tQgIgkYYIAQ4jzSCalutewHGWbSzVLombYXsWZyi11UEwuGdQArZnAQMCN80a4QIkUEMsmxGToXFyApkkxFubrQ11vbJywztuhw8ege33fI6Tp48TdruQF1QFxOKcp1hNaCqxqyTMMwytoqKdP4w9e0P8Ng3Xrl4Xm9Kccsds5y5dYa0K3HeUZQOgcTZAK0lRREQxz1a7RnGY40QmrvuvJWPfOj9HDu6j1CBEtAYEL45gTmx+6eu9HYCp9lXYbUjyzWTfk0Utzl70110Oz2efvoHLC8/gXA50muUMEShZzxZJW1FBEGENQIZCsIwJgwjBsMtOu0YITzZZIR3jrqyJElKUZXUpcb5iiBIcFbivcA7WNibsveg4fLT1Uuq24uSbhwrbj6b8uA7Ao4c7nL+asRDjy/R7pZE7jyHF5a5+5bD7FncgxQSJx34EmmXuPnGs4yzCa32hGLwOFfPfZflKxe5cCljgsIriXCOQAUEMqAoM/Jco6L9GHWcH5y/wskbUspyxGOP5axtZFy+cgnvKqyKKcoKbIkuxwRSYa3GugwpLNPtlEhNUKEjTtq0WhOSdICjoK5H9De3OHpUc+Gpv+LP/+y3GA4epb9xmcGwwHmFUvu4797beN3d0wxW1nj0iYzR5Np3g2dn5/jIxz7Gz/zsz7F37xKwc8wXzyNKcB7Gkwmrq6sY7+hNT79g94HbHrfRRYWVNUIJou20wk4zbMfjzbKMMAwJt4cpnHMoIZoFOM/bLOacpSw9kmbqbWpujm6nS1VXlGX5ApLeSTFoq6kyjZRqdwhjJ+sLNEdF1zwe76GVtvjCL3+RP//a11hdWb2mtY3bMxy74wMcvftjyNY8lXGUpqIUmtobjHGIKseN1qj0JuOVC5TFrWgFXnqkCVBowiBqhkeEwxqHVQKspHaWymi0b/LNIlB0p3pMT7eIIxAenBVoA8ZbjDP47S1tHolQESqMqaIEV09wlcC5ncnBnEJraidIOnu549YHeMc7P8zRw4dJwoAym2DyIcVEMploYjx55gn7V4mHVwho8/ozb+PwO3+T//rpb7Kxdm33MqQtxSpI10EAACAASURBVKmzXU6dbTM90yOMA5zVBGGAdQ5jHE7EIGOKOiTIQqxWDPo5t958Kx/50IMcO7yfUAnwGsG2ryjkdmKoIVxrPVlW4qxhenoKbQxXrqw3FhYRkQrQpiKJ5jh86GaccQz6Q6pijHMFBw7ME0eCohggRA1eUlWWKPREcYpSIVWt6XY7VHlFK24xHvVRKiFSLUbFiDwvkNIAAUo117NSilvuitlaWybPfnK5+6Kke/vdB1naU2CxjIsxh/dKNjeWafViluZDDs0vs3d2DiUrjJB4EaJcsynJ+TVk/QNWLj3G1toqV1fWubqZszEB7RWtNKIsc4T0BCLCe81w4rm6rpndb3jq2Yd55NGnWdsKcbJJH/Q315vAdAgeRxhEOFqU2+sEhfcI5xnoMVKMSTs1cTxNHF0mjqCqPJ4xl5/9C8Jok29+43fZ2HiEyWCNclw3x7xgDyfOfop0us3j575MmAy4+caAr3/72nsM/+b/+F1OnT69fSR3u+rwBeqUhlT7/T5lVRJEEXlRIKQgDJpQtxKNj6W1RgDGPWcj7NgPO3Eva59rnu3uTBCSQD63WrmxLRo1LJxrRn6rqlmhV9eUZQmI5nvvKFklMbWlrMpGAsKu17yTeMC7ZpLNg7ONd3byxpN8+mc+wz/97/77l7Um80fx7l/8bdLZI5TaUWqDNobS1mSmJK8qimyMK/qQryFKzdrlR9lcfwd5PU2SWowLEN4TB03KxTqPFR4vPLU11MZQ6Jq8KqitxgIyDolDRSCaBqLY9szHgyHlpKAyCqvBe4ERghrRpGacwLsmEVHrnLqeUFVjWu1Z7v2pB3nzAx/ihmPHcbWmzCZkWUEpNaKXEqouqdHUxjcWXBRx+sytvOOn7qY73eGDn/g8/+Kf/xP8NdzL8P6PLTE1ExKnKWnSLJYp6wpjBEJtRzBVBGIKa3tUZcxkWHDs6FE++IH3cPzwfkIpGnUr/HbaBba9J7wTFEVNVda00hStLYNRzsbWgPE4Z2Z2BiVgfbVJQtW1JA5nueH47RhT8/iTmmeeWaWVjFnc28H5ivWNFcIgQamQojREYUw77RKFEa20h7djnIU4jMkmBb2pOSQ1zlbbAsIThYokaSGIObBnhpXTJd956CfP878o6R7cf4j+1jKXlwvSniFKxtxyKmBxzzTeGSbD86yspswvzaPCHkKDMxnj/g/pr/+Q/soVNtcz1jdr+pOYihAhHKGAKAzQOkJbjaAEauKkh/FTHDx+L605T2/mECPvseUYTLFd8BZKKoqypqgtUaAIRIjWBYHyCGHJ6gEKh5CCdjJDIDpEQU5daiQ5D33rd3jm0hzDyTKTwZB6qBE+QoSHufsNv8jeo/cTuFW++63focxHHDkm+f7jML7G1uNNZ88+j2gUYHf/vaN4pYBJmTMYDgijCG0tW1ubxGnK0uIC3lkcAm0b0g7DEKddE+zejnsBxHFMFEW7yhd4wZivdRZp5W4GF7bJ3zkknjzPyfOcqqp2veS0FSODoDl+bz/mZusWsK2c67pulLaUeOebZTpC4nC7HvPHf/oT/Id//0c8/tjj16y2M/tOMykaK6E2DemauqYuJlSjVczgMmQrUA1xrmR9+Qc8euEit52cJl4wVNbjfEhLgArAG9/46DgsFu0NtdHNKkFTUXuPds2NUuKbaJkGXXmqrGa4vkFVWSqRUBCQOU9eVdS6pNIVus6pqhFlOaIoR9TOc/r17+WBv/0pjh0+hHQO7S1S1gjZ+MoCCV7hiLBeYIUgTue44/Z7WFjoYb3hfR/6FF/549/nqScfvWa1nZ4LKMoKFUZ4PA6DkEFzenACXIxwbaxJMHWLelJy+OBxPv7RD3Hj8YNI36ym2rnGEZJt/wnvBW7b7gqjmDAKGI0Lnr18laTdYnFxL4PRkOFo1Kx7TVParVmGww2KyjAzs4/jxwo2NlbY2OijQkNvOiGKYsqyJI1DvJXIICIOugRSYLVAiJiszAmDhCIv0aVF1x5nJWEYo5Sg256m25kikDGjzZyjB3tcODdiMPzJsrsv+psjZjod5rpd8AGDzZxsUuJcs8VHyoRJIRhlGqsN1frTrD7xFc4//Huce/SrPP7IBR57YsiFlZxNozGRQIQ1UgWIIAEliaIYWypMAd4ZrNfcfPu9JL39dPYfQrTbRGmMc3B5eY2HH3mM/taAuiqJo4AkjpBCooKAIEwwtosXPbSNMDagrpsLM4zaBHGCEwIhHIP+MitXzzHa3KIeCbwPyZlm+vAbcVMHoKWRCrxp40RAb1pw+sYY+aLV+snxfIJ1zr5gwGAnMeC9ZzQYYl1jEURhiFIBcRASqqBJFOyMAIchQRgSBiHOOsqypCzLXaLcUV47R/8dBapU0yjaIdMoatbnBUGwvVAI8jzfTUDsLM8py5qqrqiqiizLqKpmb4MKXrhr12qDrmrMdnTt+XsfiqKg2+vyuS98/gVWxMtFqQ1mOz9c24raZZhqiBuuYDbOYbfOQ7YBFhxdio2rfOvxR/jeuRErKxEbW45+XmOEIVAeJUBtW+AIsM7ipMRZEKbCFiOyyZiismChqmGYGbLcorWkqgPKQU3WH1PkOWVRUpUFZTGhLIYU5YAs3yLLB4zGY2b2n+Itb/9b3HTDIdLII3yJkga8IYkj0jAmplHIxmu0qehnOdP7jnDDqVON3Wck87MH+cRn/gvCndH3a4BoezCmKAqybExd182JylqqokYQE6kporCNKaDKNHffdjvHDh5Csd20FQHeS5xXaO0ZjXOyvKKsajbWtyhqg/GCK1e3mExqkrjZYVFpy9p6n9G4YGpmjqo2XLmyzMrqKoP+BCXb7Nt3jBuOnwaRMBrmWCPpdqawxmB0jUIRqpgoSnFOMZnUDAc5k3FFVVtarTZRHBOFIbp2eCfptudoJbNkY42tYdzPMYXh2P5pftKd7i+qdLudCbPTijgK6XR6WCPJdItw1Ob06Ts4dfJmWvGQycojbKw/w8bGBmtrm2SFJK8tTgpsFOKswlhNEHYQzHJw/yJFsUVdZ2TjAlHHOF9Q24xKDykLg4wCTD1GRiFhGOGtI1IBV565hDSGM7fdSLvdal4Mrsa7ZlQwn2SMhzFlOQLvKKshcQwqqrFBTUiEN55iVNB494IiaDO9742I7gnOPXOZK8+u0pEGY/uYusmZLi0FzM5YNl5mMPr52CFYt20H7Lxvh7B27IDhoA/eo8KAOI6oq2a7l9aGIFAN8dXNvP8OoihGKNHYDcaQZRmTyWRXXQoh6HQ6KKWw2w05h9hVx89/0/651Y47PrEQAmcdeZY3TaXnDVkopUA2TQfv3PaARIMdL3hnM5kQgtXVVU6dOcWdd9/FX339L69JbavKUFpNbnJqk6PLEdVohXLzIvX6OWz/Ir4aIggRyQLOt7h6aYU/e2wZIY7RSQJmejCVQjeticIY52lOVjJoGmGiaAjYGKrJgE0nWB+V7JuNsQbGhWO9nzMoPbmIsUGF845Sa4q6pioy6mxEnQ3IR1vbS8+Xqaqa0zffxk2nbqAbCMqyoKhynLYo0dhJoRSUxmKcBaNxxZhstMnNB+5nerbTmMoInJHcfd97OHvrG/juQ1+5JrWVShHHEXmRoY0gCEKkhyQJkLJFK53D6R6dVg9bZuw/fIJ77rydVhKznTWk0gZTG4IgpKxqqkqTthuSq72iG6dUpWFtfYQkpNudYnV1k61hk1GPogQVBEzyMVuDLdIkJAx7hJFlMhkzN7ePw9WErf7TFEXj27ZbU1RliXMeKQOCwGMrR1VpqtLinEQbaPViknbMKGuGfJRUtFtdrIHly6tM90qscXgH83MJ01Mh/cGPbz++KOmeODHNYLCJ0RlChkTRIkcO38Mdd55itjuhGHyLq1cusrq6wsZ6znBQo51FhyEyBYykyg3a1MzORBw4eopvf2edshTgWyzMTzHoDylGFYKYQI3pb32f1uw7CFp7UdLQikJuOHmYt9x3C+d/+Dj7FhcR3hEmAXfcfpYkVmhTYaxFyYCnn3qKNL6JlZV1Ll56lEpPECIijJslLdbZ5mjjPcgUrWeZ2nM/3Zl7sIR4WzMYl2Q+I1Yt8J44jAiV4Z47F/nzv9xkMnlpXcsfhfcO759rnMFzOdcdYquqivFkwrgoUJ0WcRgitKbIC7b6fdppSpY3SQIxakaGkYK01ULJZktVQ9D6BY2yhjQtURhitvOJO6kGu72HNwiCbVVrEFIRBmr3hrDjDUshEVLsnA53m3ZCNqMn1oF1z+3qreuauq53J+a01ly9epXFxUU+/dnP8MjD32cyeflpEW0MpSmpqgl1MSQbbjDauMTo6gWqjSv4fLXJhIkYYTVSK+TyFb5z7klqlbK3M8MNe1IWOxFzLY8UFuklSoZIKgIPvqpxWpMXJcPBkPHGhHPPrrG00GMmgDhMcMpydbjOYDBAWk3gPbUxlFVJnY8xeUaZ5xSTIZOtFfqbV4mm9nHy7K20p7oY4/BViTAWV2uUhFB6LA5tHFLE1KVmPB5iXM2exWmmUgVOY71iMq7xEh786K/w5OMPkU1e/qJ+j0EGDiH8tlfsscbQ6baJ43ajspHoyrFnYYa3vvl1zC/M46XctQ6clARJgtMOIQJ60ylZVrG5NSaOW+SFZzSsiOIurbRNFCmKoiLPK6ZnppABrKxcpaoqWq0WURQgcKysrFHkYxAh01OLOFdQ1VepK8f87CKTyQjvHVVdNx1qJN5LoijFWodzirzSeJkTBIq5mRmSuEMSRXgnaLVTvLeoAOKuJ52KuEUs8NffWKWqfrxM/4unF6J1Zqd65Lni0JED3HLL3ezppbjs22xc3GB5/Qrra1sMtizaSmTsCGKH1RXVWFJpQ5SG9KZjotCxtf408wttlq8s403C9NQMS0sHOD96HE9EJFKMvkgx+R6tzj46Uym3Hj/GLacO0AoVNyzN8fT5Z3jq/DPkZcV0O+HMTSebgmCw2tBrhySRY90XREGMFCGb6wVaS6SVOAMqEmgZ4OQS00v3EndO422FsAHG540/l9e4xBB5i5IeJSvefP8Ss3N7+Ne/892XfeHCDun6H3nfc7+VQUrJYDRmazRiNBnTwW1vUrKEUURZls3vNgsar7bUNcY3uxFEWTbe7HbD7PkLyL1vfhvEZDTendbZIdud8d66rp83Nrwd5yEgiROCINjd42CMaRp2QaPMy7JEa02apggvdhtvOyT+/FWT1lqeffZZLl++TK/X45Zbb+HtD7yDL/3Bv3vZtc28pqwLXDXClyOUKYmFpxMHhHFKWcR4b3GqA8E8qr2PotuiGK/w3XMJ55IuK1vT7O0eZm+vTZpqrJW42qK8QGhPndWMBxM2tsasbGyxNanoPX6BvfNLHJhvoyuLR6CtZWPUx1Q51DVWG8ChnEFXBUWZkY23GG5cpRj1OXjDzezbuxdnPVmeo+uqSQXYCo/Aek+pGy/f6IrxaJOVjatMjCae6iED0BOBqRvbyXnHiTN3cf9bP8Sf/tFvvezagqfe3hUMYjsJA0Y7wsDhqNGlZmNti8MHbuT4yePNJJ82CCXpD0c47+l2u2yub6FrQ6vdYTic4F3j+Y/GOdo06aP+cEx/a5MgDNi/bx8qkownI7b6W4AjSSPyIqfMC4pcEwTtZl+2y0miDta0mYwGdLoxnc4UZVmQZTlKNkTtvcAYj3Vsx1cboTE/O4eYURR5jak1SgakSUQkFS4wWJcThHD3fUfIK8m3vnH5x6rei5KumbSZm9nH/fcdYmHB44tH2bq6yUa/YHm9z9bWGFtILI6gBS5Q5EWINgFBCtNzLdLo/2XtTX4sy/L7vs8Z7vTGmHOszKwpq7qru5rsborqJimSEihLNEDahAwbgr00ZEML2/wPvDcMr7yyvfFGC4EyFybkCYRAq9kiW80e2NWsrsrMyinmF2+64xm9uC8isyUyW87iAQIxIBAv3nn3/e7vfH/fISW4DqX6i6bIDdZbTBMoS8vNG7d4/vQRdWNQKiG1luriX7Fz/Rvc3n+PD9+9ziSRSBw3ru0wHRYE7/mjb/0JyIQHDx5y994t8lzRuYYiU1ycHyPFQ0T4DvXyAeViRb3qkIDWIFNNG7YZbP8CcfBlupiR+JpgHV5InOsIJpBITZSSCEgZODl5wIcfvMFkLFmt/3r1wS93uv1nSYiCxXLVd/FJStsa6sMjJtMJW9Mptu3fjGmaYDdMbe89fsM2qKqKRClGw+GV0OGq06U/gb7sJHb5+L3/QsQ5u/noO+E06c2iLwdkbdv27mGdJMn6IFDnHF3X0TQNaZL2Pr1wxem9pK71eGCFUorHjx/z4MEDfvM3f5P/+B/+J3z7j/+Y46Pjz7WfjkCuBMNUIdWAOMyJO1PctV3K+V1O5iuWPqAnbzDNblNMr+O2hwyGOdJp5l3Lg9OnfP9pwb0bb3A7UVjnaRpDUzvWa8PFRcn5eYX3GVt7N8kmKZghn312weJ8BcFgvUQj2BrknNcXzC9OccYxSFMSPM36jNX5Y1bHD+jWp6SJ5MattxkPpnTrGtnVgOg9NhAINEFoIiCEZ7U8ZHHxiLp8ThUHeJni8Dg8ISjyQU4Uiihr/v5/+I/41//q/2R2+u9WHP6qFTd5ec73XgUvoDGIUdM2gWpVYTrNzRt3GI+3qduOs4sL9g/2cSFwdn5BZwRSF4xzRVUZimKKVCmLRU3btuRFgXGG89kZTVNz48Z1TNfy9PCIzjQbmKpn8FxczOjalkFRkKUJ84tzLhaLzRxkjLEVbespBgNibFmt1qRpxnA4IMsz6qbpM9i2crRKaeoSk3TkWX9izJI+fy1NIomEneu7VFUPjci04YsfDviLjzTr9c+GH19ZdL/y4fvcfQuEfUB1OmN2UXK+KKnaCmMseTpC5Ald9LRG4zvFaCjRmUQmYLuKGFuk7LO5lMpIlOD997dZzgNKz8nzPW7fvsHDB58RRUuWZDT1MQUP+foX/x6TIiK9I6qIRDAY5rx7/y1klvD89IzDJ59SVl/k4GCLan1BvTqnrT9GJQ8J7gkXs8eU6wXWWC4rTfQeJcYEtmm7QJ4aai/RIRI1BOEJ0tEaS54ookuJCGbzjvn6EbduBFbrz3Xdbi7Sn05miBtXGSn6C9jHQNO1CKWRCOJGLdarwQyr5ZJBYdjZ3cZ7R9P0BtaXXMK4OcqGGEh1dvV4l4+pxIuEB+BFF/zSQO8yjgfAeU9ZVTRN88IQJwS8s7Sm2+RMqasibp0lTVK01P3z2sAJP/zhD3n69ClJkvC1r32NDz74gIODA3Z3d7l27Rr/8D/7T/kf/rv//qrjf521n6aMsxFy4FBiSKJzhND9fEEIotaUyZhRtseeypGpxhNIiTSm43ld8+j0nMOZ4UeP10g/xDvLYlEyW5acnC9Y1ZGbd95hOplSGU9ZB5zz1GXDal7hTQMugIhobyiImERjrEV0K5rqnIuTh8yPP8VVx+RpYLq9xWRnHy9HRK8RIkNIA95AonGd6KGTds3J8SOODz/lYn6EqU9YttscHy+wXqFTiXQCEQQ61egk4fa99/i7v/Wf80/+l/+25wy/5goxkGX99ZSkm9dcCpyTEFMEujeP0QN2d/cRQpPnGuc9J6cz9vf32d/PWC06BoOczgROT1dk2QAhDav1ur92vaOpG4TW7O7tE4G2a+mahigDWZZS1WvMuu1VkXmG0pGL2TllWRODRiQpWuakyRCpHN4JBIrOWJrOUQwG7EwnDAYFh8+eY7sWmWYQI1VZkSX9AD2KDqUDk8mQGD3FUGODAC0xvmR7L+Xnf2GPP/rDY34W8/GVRXf/+ozF+YrVRcd6VVE1Fh8sidLINKftJMYKDm5+wJ1776LVivXylIvFjNoskDGCCygSnAOtMwKRcaGYDsf9kMc67t29w9Hz53RtQ9A10uSo7jO2Bz1GElRHiDmBSNc1dK4/kn3vB99jtVrw+7//e3zwhXfZnnreerNCikNmx2dcLB5RriusDUQhCYCLkSwKRKhpuzXpIOB8H2/jRILtDJ33NE1HQscwMbjQO/mvVxHvAjf2BYfHkeXqta/bq/Vy4b0kzojeXR3rPFXTUjctIuk9bF2MGONYLpY0ddN7LAiQsn8zEiNFUZBl2Qterv/pjLPLTrXbiCqGw+GLwrrh8EI/QHx5cAb9YOwyggchEWIjcY8B78NPYcEAQor+GBf7Lny1WnF8fMz+/j7f/va3+fDDDzk4OGBra6unq6UZv/M7v8P/9c//D374gx++9r7eGQ4YJHoj2LGkMcFTkE932drdoshylNcED1H3PNzgHCZEnE+Y2Jw8Szk5X/HstGYkHDJYzhYl54sFnYvs793g7bu3yZKEi/mKTLZ0ncFvSPh11+K7Fm8sQToSkTNMB9jVBYvZYy6OH7A8+QzXLhhmMBpNKUZTsDXVsmOwJXF0aOGRMoEYKcs5R88ecnL4GWfHn3F28oSL2SnL9ZpgOk6fPGC9/jWGut/zKGI/tAqe2hjuf/XfY+8P/lfODl8/2me6NaZpE0IMvVOfMugkw5n+dCQoyDKNI2F7e5uu61itVlw7uMZnT44QYkWRj3j+7AQpU0bDCU3rMLbuQ1SVRCpJWdd01rI1nRC84/GTx7RNhVZ9JqJzjsV8QYyOosjxrlevrasSkAwGE9ZVSQgGoZKNJF2hswE6yTFdg/cO5yzj0YBbN6+zXCzpupZUa5zzWNcxGo5eeg9EjDUY2zEYDfHliq5uESLy5a/v8vGPF5wcvZpC9sqi+/xZRd3NcV2JdLE/mlNQmozG5HgReP+D23z967+G0Aki1nj7Lk27Yrl6SrU+Y35yzGpR4bUCNHkxxDrJeLxPDGBMzWiUc+1gl+dPDxHaE4uWo6ffY/bsIfmbX6KygYv5BRezE5589pCHDx4QgLqp+Jff/jahWnBy9h32r8PJWUO7WlCuzum6ligkPiiM6zmkInqCFwi3olo8QxbvEqzo+aOpxoeMIDKMN2g/IAZF1IYgevdd4/oB7P13FN/93l+TGU7so4M2URZE0Rer/gKqWZUV460tsizvXcC837jha0LwdJ1hOOwLbdwMrS4VZzH2uGBT1wwHBUqpKwmvtZalkP2wIM+vcN0XJjc9XgcvlG/98KyfWEdeiDh6PLgvyJdeu846rHGIVCHCi4j3s7Mz7t+/z507dzg5OaFpGgbFAD1NUFKzvb3Df/mP/zG/+1/916+9pdvj/lRlXUboJB7FcGubG7d22J3maDQX544LZ5BCkPX5IQQH0Qd08FwfpuRyG3Acns2hW3NROrLxmC++dcDeZMigyOlaQyElKk9pRG/0LqIlZBofUlodcU6QECBRLH3L2eEjLo4f4ruSREnywYisGBK95PTU8PTpUzpbMMoluVKY2nB2esrhs4ecHT9mOTtivTxitThB03Dt4IB9vU1bl5xeVOxPtsgiOO9obMfz8zmfPXrE45/8OVv7b3F+9PC191YninE6om5KnO2IQiBVilSeul4zyEdolSBT1QfLesOnj59y+85bRDSHz88ZjTzFYIK3Ee9ha3sX6zqWqyWD0YggwHpHmvfF/fTslPV6xXCQk2Wa09MTrO9fuyTLkSKyWC1o2xII6ESxXF3QGYcPjmIgWFcVjSu5cf0aB/t7nJ+f0NQlbZEwKjJ2d6YQPYv5AiElWkiapmYw6K9n03UgBEr1cJqQEpBIneBcYDCQ/I1f3ucP/tmr4ZtXFt3Gn4E0KFXgsZQOuu4D3njrl3jz3ps8fvjP0eoQqIEEhCNJE5JsyniiCO4m9tbbrC7OWK1bVusGKQfoZAtixqDQrFZndN2Cd965x3w2o2ktWWZpzSO+9Se/x7tVysmyYr6esZ7VtM05F6sVSggmxYCvfeEa+aDm4HpNMEvm8xn1ssH7gErAdgMWK8NwSzIaDWmrCuM9TQdO15T1GiEzCi0RwVMag7GRrq4JZYMdZMRYg4SgI7VzyCg52NVcO1CvfeFerl7S+FM/IAqxoSIZjLWb7wWJ0oQkJajQ69VlP+RSSpEkKUkSMRss95IaBj2e6pyjrivyTQcMbGLTI+v1+iXf3HjFNAhBXPF2X85bk1r3ne6/saztbwB+wyQJ4ZIS10LoJ9xaa27dusViseA3fuM3egy4Nezt7vfKuE1n/cu/8iv8rV/71dfeVyc9wXZEC9ZqhqMtbu4fcHsnp8gF86XnaNkwN4Kbk4ygA52F1tj+xCBgIANZESiNYb6cU18codOCL394l/fu7iGjwHSe2AWs7qWrIWYE69BKo7ICGwXKSpLQEIQiqIR8MGI0ntIsBgQ8JAleFbROomLHYn3Bw2dnLGpJIQOxranmp8wvnrJYPMWWc7xtEdGxs7PFZOs+6fQ2JTvY9Bo/fnrB6kAwcJGz+ZKjszM+/fQveP74U2bnR8TBNpODe6+9t8Z1pEnCcJhTlp4QIlpLBsWAk8Oa5eqcRCq2tveJKqLzgsFom0efHTIZ7zAa7dC1luFwjNOO4+MTJtMJxnVcLBeY4KmqkrZtyLIM2/Xy9XxQIHXPD+6ajjxPkXmC6WqqtqKp12gNeZbQmhaQtK0j4tGJJ88KnC9xpqXIUibjEU2zxnuDMS2JlkjZy19khLwocNbSdQ1KSTrTIqRkb7JLmqbUbUtWDNjdH6GUZjabceetgjfuvZoT/Wr2gs+IwjJrFPP6K7TJW2zv3mN7/8vsTPeIt+c8fvwH1HXFeDIE2RHReDoiLRJBNhiwxR5S1WRZQMgRSbqNd4rhUJKlhmfPZ9y8eZ1r14Y8ebogCJDK8f0f/z6L7jbkN3HUVPUCHBAltr4A/Ql37j4BFtj6gvW8pFmFviNPBE0zom5vogYZevQTdCEQbYo3Zd+1mkCwLUFbEBp8Sxcj1reU5SOSakm1jlgX8VYSfc6zo5a9ScaggBvXPr9aIvYOKH2BlJsivPEycMEhCFfE89VqdcUMSPO+a/XeECM418fhmM5Slmv8WvEcVQAAIABJREFUxtJxNBpdRfXEDVUsTVMEEHr+Ts/F3VDKLq0e++j25IrNEEK4ElkMBoMrBsPL9DYQOOswnf23fBe0UsSoiCHwpS99ie9///vs7e1x795b/Y3gL4FA/pvf/d3X3tdVWaK86RVSUXNra8rNnYydgcBGwbKB53PTP/9xhifBWE9nLEpHtOrTA5StUKamqxukT/jg/pvcv7fHZCiwjUc4j0sF1kpcFKgNN9aLBESBpM/zMzJggqeJOWGwz9bNdzFdjZ89xrma1jp8FdEK3OwE9fAjjg+HhHaGLc9xzSldd470KwZJynRrn/H2NQbb9xge3Edt3WPuCk5O53zrz49J088IXUs5O8Mvz+jKBYPJlJ/75q8z3t5jcfb3X3tv27YhBr+hD77w7MhyzWSas7joCKIiyEjVtHzy6QOUHCNiwnJZMciHnJ/POD+f9cWrqfrXXgnSLKNp+kie6XSCMR2tqcmLDEHg7PQULQWDIidNE+p2xWo1h+j6MNpMU9drLmZnaC1hU8CdNUymmizJ6LoGrQVaCfIshRio6hKEQyWgtaCu+8dMcwXCY2yHdR1SKkJ0WB+ZL2a0xiIkjIYjrDMYU/FLv77/yv17ZdE9e/KIw8WCkP9txtf+fbLRCJkZnp8+wpsl2+N90uxNVkvPcLSRt4lAEF3/gqiMZr0iuIDWGVJaIgqITHenFEXKcn0G6qvs7u3z5tufMpstWTWglMXac46O/wVbB79F5zu8XyJbSxofkm0/JkmWBLumq5c0a4NtBFluCFFRVgd08gv40T6p8HTtGYxblE7xQaATg1+vCKamGEp8DHTG4oyhnD0hND/g5rVAoiVVCcFpbA3VUrA7AScsWievfeH+W0vSH1c28EIUEIRAJQqd6J9yE0uSpA+glBLT9TlPZbkmUbpPfBMSVF/QL3mMWZZtullQSf97OrKxgQxXdDHgpwosgHP2ihVxafMIvbRYa32lcgOuaGEvD+GSJEFlGRs/Sra3t3n//S+QZT2kobRGinAFeVwaqr97//5rb+d6foYWEh8Sdnb22d4ZsbUt0amlajWnjees6tjOUryFclmxblvGk4StLU2iwDQOIwNd6BhnA27c3OGbv/Amk0lC20SCBKkkSoPOItJ7cB5Ub8YplcQIQQkshaZNhwQ9xOocJ1OMGGF0Qb16jmvXpDYyjpJudcHxk+8x0Dm2qaibM9pugcq3uH7wAZNbb3H9xg0mu2+Q7byJnhxgdEZcrHn+fMGjRw9pbUeiBEV3wd2x5Bd/5Ve59/Z7BKGZryqmkxuvvbd1VZGlKVVV0bbthkXQkGUVaZYyGCdYG+ls2TNc3BpnDFqPmC+XLOSCVGm0TnDOsrU1pesMdVVTjAuc83Rd23eyEqzrgECe9Cm+IfbXarNc9TS6YPpsOgJlucKYhiLtDfmVkAQfiQGKvCBJPZ1Z92keTcVgkPUwmei53XmWMBoPe1On6MiSBOcM1vQeDGmWEoVHSEUIjrapuLiA9XrZX98icnCjeOX+vbLoDrb3KY9nBA4ZyzPStAApcSEwb0/xQVEM3+L4+AnTLUUxjCAsQRpU1NjGgJN4H2mNwTmB1DAYFmSpoC0bTuc3eOfD3yYXR7z51o/57NMHtIeWTniyYDCr75Md/BLboxuo0FEmf04lPwY/x9YlbdXQNaaHNoYB0w1Z2vt0+Qf4mBOjx2PIzJQQDSqh5wIqyyCZU9ZLVu4IZMR2LaY8p11+zL3rloNdQVMbjAsYF3tct0tIM0FAIP6SI/b/n/Wy9+yVuuAluEEgyNKUZONif2laU1UVk8nkasLr2RQsDOPRuPdYIGA3g4VLalfXdWil2N7Z6rvQEPuDQ4g/9b+8zF4IwW+62hey5Mui3HW9SOSysGZZdsUFvsR/L4t5L4ZQRAQxRN544w7ABvaoe0L9RnDRdR1pmm7SPV5vzS+OSGWKFyP2rt2kGKWkaQACxsBqVVKul4z0PuvaMDs+xGvJ3Tu3uH4tJ3pPpTULL1A2kI0jd9/eZW9XI2Nv8GRRvbexDCACOsn6k5iFoCSdhi6T+CRnsrXN9dE2rUw5aw3L2jC8cYx84wt0q2OYPWGwfM60XTHEYt2crmqpyzPOmwYxfJs33/473H3/q1zb32Zre8RgdA2ZDTDBsqrXHFZrDqNknl1DZSnbo8BXb77Dr3/lLQ6296hWNV29pPAdqX79eYQxhqZpaJrmylSpLEu0loSYI/Uuwgqs7fjs0UPefefnabuKblGhswJjeymz957T0zOGwwHGWBbLOcW6wOOp65qmrYjBs1otGA4GiJDhgkFLgXUdVbNCSYjeE0XE2payXiEFECPOtsRoN115/76SUhCcJ0RPUaRMt/tuWqn+Pea8Is8zRuMBTVOSZVOEEjgCKhFXlqp986NJtMZZg9a9Q5pSYnOT+KvXK4vucH+Hg4spFxcP0d2PeOfm11l1NTgLoqb2DtEp6kXKJ59UvPs2ZIMWrRKiaXFNi5QJy+UCHyVKTpFSkWUavGd2oXjjrV8ln+7y4KMn7I7u8cbd65yfPMKFFHSHWy0Yiyfc3h3y4598m1X9ESLO8G1JUxlitKjMEnxCZ2+xkh+id+4jQ0rbdIRgQCU0doyxZySJQ6DQ0qMzg/KnrOukN45pV/j6ITe2L7h9TRBsR90Ygk+QShB8h1AOoURfvD9HUXh5XRW8CIqNaXmMG9PwHLGR06ZpuvE8aDk8OsIHT56l5HmPuXpj0UlCthmi9TSenkpWluWL0EkiW1tTtJRYYwg+kG1oZsCL34u9FWNPgNdXP7tkJlyuS3Xa5Rvw0uPhZUFGXTcopQneI+Dqdy+LrNa98AJ6hy7nHFq9PmZ+dnZIIlNUvocNAZkIovJEp3AWusbiup473PmACYH9rREHOynToaSrBZ3s/5cYFFKPGE4maAXR9I52IbIxmukVYp23NC7QIXFJgguB/f199nanOFI6Lznza0KzQ5oGFvmU9c4tJr6hXS8p6iPGp5+SP/sz2uaMzi851lPc7gfcvf+3uPPhL7N94wZFAdlQI7XGuZJ1Y7goO8qyYSwTdu69yc5kylcOIt98b8pQBapVQxY2vNrCMF+9vnvT5etqjCHPC6ZbO8wX5yyWC4p8jywFJRVFPgDhmC/OEOQgUyQZxMCTp49JVII1m/ewVgyHeU/PCpHJZEQkUlYVSgmEDMwX56xWS4aDDAgIGVBaYmykMRUWg9ISrkQ6DTFYEh3J0v5019Yt3juyIiEf6BfdtDWE4CmrNVmSMZlM8N7TdB1ZUYDUCBkZDgebgXEky1JGoyHOO5y3CKGQWmwk2H/1emXRlXHC/sGbdM0nLE/+kKz9Nb7+wa+yLJecn81Y1TPapmJeTzh8sOL50THX9zt2JpJUtRR55OJiRWc0XhZEX/V5RucVXTfBJ/c52P0SUWpqsUNzvsWtu1/kJz96QD2HmAqCavn+9/4pnz0aIpMVQtZ46/EdCNUiBXTdDpV7Gz36Kkrs4ukd+oPruDg/ZTRRuLhFZxKywkOQRA9ReNqmxPoK27Vod8LBtObtWyk6lKyrFmt6nE1pSdPmKGGIdCRJ/GsxwBEbL9s+RqyXKl8muSqhoFdZIunxLiElbdfhqqrvKL0nzyc9vhrpKTdSoZTEOnMldrhM8Y0x0rYt83lEa4Xr+gmwUpO+u3wpiv2ys+5lw0nfJWwwYO/91cDNe0/TNFfGJ5c4b9+N0yu/QuTKRS32rmWXjwcbO8mNo4yUclPUXt/qcX78FESGmnraxiD8xgvCR6KVeJEjVUKMHhscw+0trt/aZWes0BGaEHEh4ELso9CJvVOal+CTjSd7JEa/UQUEnHe9/aOMZFnC7nDKltYUIfAUj3OSzkVkd8EkJhgRaNMEu5FSd+MxDHY4lQnh6Q9p1U2Wg7fYu/k2d979EpO9faIIvUDCKVrjWBnPbNWxrGoSNO/d2meaK26kDd94d8L2UFG3lkRJWiFonN+8jq/vIRJC6E82ecG6apluS/JsijMdkpRhMWK0ex3BlCxT1PWCroXhcJ+67rA20nY1VgrGowlKSbyzVxixazuEVhRFTpoqgo8QHCEY0lQQhaNt6p4iFiV1t+6lyVfG54YQLAKLszXOtiRqSpb2rCSZ5CAsdVX1roeJJkRHZ3qql1YJRZqztbvLxfyiT9bWmqausM7iXUuMgizLyfOMthM4G/DesSF8vnK9WpG2ahkORmxt3+Ds5JC/+O4/4Y07H3D72m2u7+5TNy2PPnuI5ZTHTx5wdCx5+KxjlLcM0xVJ6sgUjIodHA5EJK/hxz865vRixm//g98kUxrnLF3IeX48Zu8L73P9znc5WzyDoBkMHOXymK7VZML3OVBBIxA4l9HZa8T0y8jii1RyTMx0bzFpAx//+Ud8+tGf8JWvvsv1uzs0tmBUNMhEYl1PifK+wtdztKvYHc5587pEhIqq8RjjkUAxiFhhoRSk2ZC2lPihIdjPRxmTUl5GY754qeLl5/6G6YwlSzNSIQgSMpX1NoyiFxqYzrBeVvhorlRj49G475elQMQXrAOt9dVw68WAzONCpCwrtNIURXHlrXAp1e0VaX5DH+uL9mVET1EUP+XN+0JM0eenpWmG7PlwVwW25w57MiGu8NvLxxFq40DGixPA66zT5w9JpKc1JafLv8Gq9jRdJIkea8E7hQuRpmtYqcBwmJBnbOJcemjWBUEQGhPAughYIhlRa2ISSILAdiC87W+eSiGkJ9GC6dYIcbwg+d//H8r1KTtvvc3O7S9SRMHcnbAaTdgSCXUIzDVUymNDIGSSZPcO426NrQVi92tMb99muj0iV55CKlSAtjKUznBuGpqyIwrNICsY55qJrHj/dsH+Ti88cLbP10tSQYgKkaaozxF03RlDWdfkwyHzRcX52YzJeMKg2EKSYY2BocPZiouLY8ZjAeQsV+dUpSdJBky3pqzWCzpTMhyMmF2c4b1nMBiwXq8RSmKGA8r1ihB6OMI5i1aCECydbTG2QXuxgVI11rQ0dQ3REKIlxJbgG7w3OO8IRNI0xbgOY22fHhJSlE7B9KyddVmCkNiVZzzuoTpjzFWii5ZQVzPquuXG9Zs9SyeNhE1X7p3vxUCvWK+mjNVzxtkOw9E2dV1ycf5tfvSn/xvf+Lv/CJ1lTAZD3nvnfUbbO6is4PRkn+PDz5jN58i4IEsM0ZWYpiRPFNZn1NUzVrXn5t0vUzvFfLGkdpH5usb6Kes65e333+Hhp89Z1xKVBIo8hSiwNgIpAUllEkJ8A9IPScbv4eUQvCQRA2yoaOqW5XJFtVrz8UefMtl5j2gt20NBNpR0i4DGkzHHCMNk0vHWTY+UNXVjMK3EtIrOBLZ2VU+iV45iS7CsDOHIYbr8Vdv3M9dVwX3JYeyy8wVBqpONYU3HYDykblrcphHO8wwpBM5YuqbDuBZE5Myfs16ve7GEfVGIL0ULL3vqKqVIi540HkJgsVpS1zVa95fFpbjisiheJgNfDtbquu45toPBVUFl41QWIzRNuzERCVfdwuXy8d+I84GrNGOt9ca28vUHlYvzHyI9hLrh4fMTDmeG7WlGKj1L59EyIy9GNIZeEIHBudBbPQbonMB6QWcDdWNou466szgfe0GI6LO7JBJCgo2RKAVCObYnKbd2U9qV5mSQcv7DP2P8Z3/A9L373BK7xJNjRh9+nebN9xAK2tEAQ0ZnBEuhSdMpuYJ2fYrebhgWGbmSJMH3/HQnqI3jvKspTcNIp2yPpjgkWgRGQ831vWGf5+YCqRZ0OvRwSujwzv/MbuxVK0sKFoslw+GY7e0tymUFHsajCXmWs1j0doxpukN0Y6wVjEcHlGvHYLiLVhLTNVjbcTE/I08GGx+H3rs4RIfwUJUW7y1aSaxpqao+vdcLiw3tFaba1g3VuiR6gxABKSKdawmhRag+RDXiidHTdg1C9l9rLQnBkSSaqqpIsxzv41UUe1VVCCEoy5I8z/tTXpKSFwNW6/7EnQ967jypJAZwxv3MXveVRbcDxrZjUoxppzfBPefhw3/GnSdf4fY7v0ZtapTs0zKn0y3SfMp8BSK/QWNWLOoS6VtGg8D1G9fJBjuobIxPNVomfPTRJ2g0RmmSYs3XvhC4e72gPPMc7GQ0raO1lqRIIOp+2BUS6rBPXnyTGHc47wyisyRKoFHAikBDPhxx7/57HD/+hPn5muOjJVs7HTf3EpJUEcKKPIlspY5CNlw/KEhZ4m1LdJHOFhyeQz7I2BIWTYOMiiwd4FRFcO5z57P3+vkX378s0Y0RkixhMBng52d0XYc1Fuf7VAdiJE9STGTDfx0SCXhvqaoa6IdgQoCzLyhcIYQrp680TdDDAVr32FpV1aycQ0nJcDhkOBxewQd9IZVXwotLPPZl1kLP8Y0I4a7YC5eMh6IoroqulBK7SQu49PC97JZj7DPYRCZJs9f3gDXlAnxAecuzJ5/w4ydLxoPrjLKExgeygWJnOOFiMedifkIwmqoZ0dmc4BytkdSNZblaM1seU5VLzi92MHcCedKPPSP93MxFiXGa0hik1FzfVgyHBvXOFvY/+Hv8v0ct4vA7fMB1bskWV56SfP8PePq9f0GSZbz57vvoN7/Eo/xtBirg7YKqrWmCY5gr0gRs9JSkCONprGFlOtquZaIT9kdTRsMcFwWd67g2TdkbJYTOY7wj4HC+65krQiCkoo9mfr01GU+YL+aslisO9g4wVW8IE3xAyYAQnnV5znSakKUZVT1DSE3TSqRMCaGh7RzI/uYlVWAyGPXURWcRIjAcDQjeE71BSzDWY63BR4+QsaduhR6m6uqG4A1ShD5cYeNPjKgIvgHpyDNFmgm6yiCiRalezjwYDsiLAqkSmqZlMBgAsL+/z2q1uvKkLsuyZ0zU9cYzOunfoyoh+gjRQ5KjBwlF/jnYC9fvfpPV4R8xGuWMRwW+3adazfnOt/9nJjvvUGzfoqoqRqMtlk3Ds+PnbO/tMV8vyQYj7ry7zwfv3mF/e4rSffRcCBHrDNFY6tkFVpQU41N2RivS7pD6/E85evQZrutZDyFEEpUg04iJI6aDv82Yu8yXKSa0xFAhDeh8RRc6vB8S2MaGlsm1Xd56/10++u53ePrkDJWr3nd2IAlCIomkypCmhpQW6+s+eNAWPD4fszLb7I0cjiMSoUhFoMhWhCgIVuPs5zS96dvcTR7fi4IbYn9ciSpQDHKyNMUYu8Fn1SYpOOIuEyC03tDAYk9tc4besEb0Qwi4Su7VWl99DZHFImEwKBjkOTrpzUMIL+heLzuQAZvY8BcWjy/MyuXmOfx08gXwU/SxlzHcxjY4a6+w3cuhmxSCGMPnYi8o2/aF0TaY4+/w0cNfZlJM2BvnmA1/tO0WnM0+4dnzh6y3p7x9Z5u9nRHCW5ZLw/n5krPDzzg//ITz2TEfX7vFF+/vcmMie4cvoLaBdWepu8jCBG7upEynmiAqTCI5coEfyi0W0/f4/qJgGire2v9Vbg7WVJ99l/j0W2SffYvr3/xtFl/aRxDxFw9x88/wbGOyIZUUrDuH6jQrHzj3DW1Xs5ckTIdj0iLDEbBOEH3LVjHo8xyEwdKLa6ROcN7TdhZvHGXZvPbeSiHJ05xmsaSt+0LlrGcyGjEa5D0PfL5Ga8d4ojg7nRGCIE226boaYyHZeIHkRa8wq6rV1aC4qteEaAjeU63LK7tSmUiyLMG7nl7Wtg1SRLSELOsN8etqhY81KulPWs5XFLlmMEpJU0hMZLlaMd0aYqxhuV5QDAdsb29zenp6xVmv65okSa4gtrZpGI/GNNZRliVdZ/soLR+xXS/LX5RrDq5fYzKavHL/Xll0TfiQbPgY584YZUPsOEH6KavzH/Cj7/9TvvKN/wIbHDEKrPWkWUKIcFMe8JX793jzjW2yNOnvQCISAtjOgIhYVmy9cU6WneHXh1Qn3+f52Q85OjznybMFR7NAB6AiMhEUeYFZ30LGd7AyYJNTkHuIJqUsP8XGMWn+Bt5JnDsluoAmcHD7Go8+HeMYILJrdGFGIo7IU42IAi8tthM0g4gl4rspj89GnLd7eDHEhTMILYlO0AQS2WJ9ROhNlMDnWC8XpcsVNuwFAC00O1s7TCczZhdLvPN4HzHR9Mcq0/VOT2lKqjKUlL0E1Vnkxig8xl7+HEIfO51uZL2XHWzbdnjvSJOUYVH0Bdb1qQur9frKa+EyxqfvctVVkbTWY4yjKF7IhS8712QTjtl1HXVdE2O8igJyzuGsxdJDCpcdxpV5eoRU/TuFVf+lS+N67qb0hPlTHn/8LZTM2dvZQwZDU15wfv6MZ88/5uL0MeXOAQ/vvcFgNEFHy+r0lKPnzzk7+jarJ89YXDzjo1HBV752iyzZIlrBug4s1h3nK8usdRjRsr01Jc00ndHkQvH2rTG/8Fvf5A93PmE9b5nNjnk6e8p4UXHj3V/kzvArqNNzUjVk4I8olzOyw09Ynj1DdjPCO0tO6wTvLbFdM/OGJSXbWvLOzrSXqOpIJxIqFKnb2H+GjUk+qjc79xKlNIvlSe/R+3n2diOKybOM9bqX/Y7ygvGgIATHsMgQaspqVZPlge2djPnFkhBkn+fnIEsnGBOZX5QoLambBiXVRukoWK972pVKNUh6SX9whNABnug7pPQIPNZbGtNhTUuUgeACBIvzhohlNBmQFQKEZzTOWawc3htGoyFHx0coqRiNpuzs7OCcwxjDfD5/cTITkqZuGI8mjEZjmqbD2pqus/iiN/MiRISPdGXNTJz/jGvzFauLN0iSbyDF/42KniIVGC0YZxkPfvx77F7/eW688zc5Oj/HiUghthklgg+/cofrBxlC+D7tU3iImmgN0Z0g5THD0SmhPaI+fsjp8Xc5fPack5OGVdNQdRKTSlzToWWCTPvC7v0Rq+4HBPE23gkQJVp7aAOdyYhyDQEykWKjxYWWdDji2pvvkw53ybd2EcMzOjGjkC0+9HSrTARiZ6jqlKdHirN6QKckUraE2OBEn9skokMBIUqEEuTF56eMRdiYgIueqHCZvL5xHJuMJ0wnW8QoWa5KzLqic5YQA4FNt/vSndk7R2csw2HRT2U3x/e2bQg+oAt9Vewv2QmXw7HRBpsNIeC6Dhctwfkr/Pey2/U+vbJovMSAw4bS9rIf7+W6hA7W6/XmZDTqi/ZLQopLDrCPgSggSVP058B0ZVqQJB1pGvGpQrlz2nJOqzyxW1ItD6lmz/DL59DOqVeSB48e0cQM7Vu68wfMz55QLX9MWJ4Tm8ij53/OD378hNFwTOID6xpmi8jx2nBU1mR5ZKQFwgs8CRq4mcF7NxP+7E7B2Z2b0B2gH21x8dH3KZMp83feY/vnrnGwfsrp8gHz0x+hTx+yOJ/jfU1cXHC+aJh7C25JiDWTJHJvss+NIuP2OGWiOlbSMNOyT5eIEqJExIzoHcaAdZL5bMaqLMkSxezs6Wvv7eXNM8sy1suKrqoZJBlt1/adYnDoNCfPFOvynOHggLK01NUFWRLwRmEXLUKkvZbEK7JMkiQpzl3m9ymsddRNL8TwrqXtarTZQHLRo4Sn7WrqakmMHinA2Y7WlDi3wtqK4QjSTFA3S5xXWFOyNR4ilWA4HHH37j3qumY2O6cohleeJV3bEtLeZGg0GtLULU3TsLOzy2QyZblYsViu2J5sMRlPEMDu3m4/8/gZIaCvZi8oSzr4gCSeEap/zTDJ8cOSJgwo10f86bf+R+7XgS55i+OLmlvDPd56b5fd/ZyAQIYUQqCza6rqCYSHDAclIjynnP0F54dPeHb4mOOThrI2hBjxckTlxqzDiPHkKaoDZ9Z0skHjac0pg8F9onN0fk7wI4TKMO0SGSISSe1WuNjHtZQW9t/+kMn0OtdvbHMw+iFulqPThtI0pCpB4VhV8NnxmItyl7oL6MIifI61kSA1jTGIAJJIIiJSBlTx15Reu/FWuKy4V962wHgwZFAUrNdVHy7ZGZq2x1IviQ6XxdNai1KqtxesaibTMVrrTXFsEBuDmpdhgRj68ElvHefnL+7QlzxatelqLv9+07ZY71BSXXXBlx9FUWwe31158AI/RUO7LLL6pb8rlOyPj0Ihbeypb1qjPkc3duPtX4Y4J5vcY//Nr3Jw+wuMd66RioBdO0pfMzEt20Fyroac6TEPL2qO/GPGqmVKQzreY5h9Az84IbVjyiLnR89qxMRR5IJYNtTtmrO65fHKsLOTYWSGdGClAO1IjOCNrSG/9fX7/PiZ4UcrS7H3PtWdbdJJis40z6TpfUeef0xy8jHV4SPi7BQ5uIlc14zqBdf2x4z0kElM2bYdF0cPeHD4MfGNmyR2zrIzHLzzc4hoKMuKeSbwrcMHSVdbjo+OmS9OWa9mnBw+YTl7/cj7sixJ05SiGKCE5uTwhNa0DP0QnWjquiI2JdPpLovlBWXVsL93j7Jcsq4MebIFzhOxKJ0RYsB5QcTT1H0KjFYaEHjnEDisaVAikmhF19b9Y4gAwiKFxwfXS3VNjXcNnSl7rHi6RZIqfDQYE7DGsDUdopME2zrSokCONIvFiradc/36dbRSrE2vgrtMONna2ma9Llmt1nSdBSE5ny3IVcr+zjbOOfKi6Dn2P4PV9Mqrel2WtHpCFt5jb3QK1SGjQqFigkr2Oal/xHf/9H8infxHUNzl4P4Wu/vj3lLOd1TlEYvZQ0I8ZHu7RsQZ5dkjlrOHnB8tOD1tmHVtTydTKV23ReXew+ZvIS1kw+8wKk65mHmcqhCkuOUnVP4mubyDc5aqWyOEwjYNwvXeoWXTUNlA41OiGkEyYuUi4umPsXyHa0VDdCBdghQKrzKO2h1W+YeIpEDMHuBDBUHjrETrFOlbhJC9A5WSCDxC/vUYmV8WpJfNxC+/11IwGY+ZzZYoYRgWRR+BvimeWml8eEHZUlIxGAxpmzWz2ezKPQzAh4hzPVSQJAly83y86y9aa82VqGE6nb7waHAeH/oONGwosdR5AAAgAElEQVQ8dJXWV9SYS7z2ZVHFJSvh8mt1BXe8CKYMIRB9QEQwnSFJNv4QCPK0h0ted73/i/8AvGN/9wa3777LYLpDFAZXntLYikG6ZphX5KbDiwMu1F3KZEiRZdx/9x1uT0dYKzk+rjg9P2aQaxI5Yu40//Inz7C2huoc7VeIaDgxCZ24w9IFrhFIhCKYnppYiMCNgUbsK4rJDTrjeTJI8Vj00Sld+THi0R8TDn9Cd/gJdnYMTpJMCr58a4e/+fW73Dso6C7mdE3HxelTxmNH5Stc/ZwQ4fS85jw8ZTgYsjcB5zoykaLTnKPTE54cPuXk+CFnR59RrRa4+vV9SWPkigvemYbOduSxwHqLx+FCfwKy1iKV5mJ+xqAYsrc/5viwpGkdWk1oao9UOSrJaTcCGaU0Ukha26GkJE1SvG2xpkUpaJte9t6ahiTRSALBW5xr8b6DaIihIQbD/o1d7ty9zro8YVDkxNirNJ2DwSDHB896ueb6zRskb6asViuCd330jxCs1yWj0RjTlRwcjHtxzybRejwcsTWa0DUNF/Ne6WY2J9Cqrl+5f6+GF9pIoxYIv/3/sfamQZad533f713Odvdep2cGmAFmAAxAiiRAENwkiqtExZIs2mZslaXyomxKPiVV+ZhyufLBn5JSlUq2klQcuRI7UcV22XEqRcvWaomSSFGUCAIECQxmn+nt3tt3O+u75cO53RhINkRh+FZN1dT0TM/t07ef85zn+f9/fxBPcr6fY5sFvSQQRV0a0XBv9jLVcperez9JNzFMD26xGF8nn90kjWp2z0EnXVDPDzkZ32ByfMBkXFEaRy0riAWm6FP69xE6LxInOyASTN5GfnS3/ohquSI3Jah2prpYPqARMRbZwmicxRjPYjlBRDEnK0duIobbu4Ag9jWJe42ev8FG5wjEAqMdImikU5Quw2fvp9t7FteUaDzTB68Rxw5bVbjGE6+D7KJI4n0LowmPONN9+xv5T3S5p/NeAcPhgCROWK0fzRvTQsMBVBq1Vtq8aBdHQuKDRKmIulxhjDmz54YQqJsGAURSI7XChTbDTKmIKNJnSRGn1l4pJU455ENpxdB2wlq1acGnowGl1BlL9y08pDybjb2l+W1lZIRwVtRrV6JEFxEgjWO6nc4jLdJG554CL+j0+qg4Q4oK24wx5V2a/D6unCDrBaVbssou0h9u8r5n3ssHLl3gqXMjghccTStiOSMbbZEmBrwitzBeLDk6OeZg/yZ2/AbZ6h5NiGnKT3Bvdo2LA42xCmsDM2uYOsG4kSykYqnaG9zK1pT5mO7+t9APvk7+4HXs8T389BgspBtP8sm/9Df5Kz/1WeIwID98gGlWCOkZDFJSNUQtcxIlQKWoRHB7uiCuLMmdmnvqkCxKyWLFyeSI6fSIVVkRRzEh7bJ4hBy6VnoYEYJfsxYSgvAs18uwtgtOKMsVcZrR68asVkeMBppeL7CcryjLBh8yCLCazzkenzAabZKmGUmcEGlN8I6qbFU7hJaB0dgapduFmreGVbkC36Ckx5qSusmp6gX9QcqTT+4x3IyYnBQondJJU5rGUAlNt+tJkrTtXucrBqM+dd0wn50gJSRxm0IePFRVw3g8ptvpnSm1JIJIaxj08Wsre71aIaQgL995SfnORdcKYgk1jv3xY6SiYHNrQTGeQJ3QT0bsDAJHsy+zOsj4tRsNwR/x2PYWz17bY7Cxoir2ubf/gOn4iOWioAkCEwUKIVkUuyyqpzE8w2DrWVARXmiE9yRxDvYShn12Lk7J3zgBHRCpoZm/wcGiT1B9jA2EIAkhxekOtdWMFwVRf0BtA4PIMFLfYit6lUHIwTpqPE0ICGcRAqLI0HMjyPoUWYyvA4ibeFvQlDVVfiqFCuhUs1oqtLbIP0ME/WedP1lo/1Q4Je2jea/XYTTqny22ut0uWZZRlCUuONI4wa4Tgh8G02gd4de0sdNC56yjzitM1ZBmWfvnIRDFcUtcWv+frWKhLcY6Uri6fFs3a9YytIcdbw8nAp/Nhq3FGHMmKQshUNU1xhq0avW43rUoREIg0ppup0Oylre921P7lse6OtlnUR0wyATaL7HLA8rFAWZZscwth2ET173CJz70Ip/5wCW2o4S8MhwsKnSo2B1qNrqWyilqK4isQKoeIjpH5XIO9r/J4uY3oFxw4j1v3voMl3ceI7I1ZROxXyr+6M4xBV0ambIylslqxnz/2/gH36C+ex1x+CZ+/CZhMUGbhs7wAl/8mZ/lCz/5N1BIxpMVxgWMC3hriKTECdAhxZoYbMNqsc+CTUxl2RSBeAQqFSxnK4rVjCrPiYKi191BdHboxL13fW2NqZnPG04fv+NE0+t2WS7z9dNSfPY0VRUFSmmcUFi7oNftIIJiMa9ZLBqkrKiqBmOWTE8a4iShk3SIVAt0Uuv3kRCBgEHKFnkavMW6BoLBuzWQxtQYW2FNzfbWNrEOPLh/j8bULJcztra22vDMOKOqWmBV2ukwXyyx3lFVrdPMWU+n02NrawfnWgv7ZHqCD630sWoqiqrA1A1bmxtkvQ6sI+nLqmJ7+xEoY8YFhFUIGYEY8dWvGX7goxfpbJXUxyvwKQk9YvuA66/+Mru7T/PCB6/y+HmF81/n4G7F5HjOqphjg8TojDJo5qtdyuoSjXoan5xDBIFxMcqDtwXeFGhvWNU1R5MN3v/MBe7fv4erIpI40O8sGa9mTOshUkYIoQgiwnjBLK8oZMRWFDNUM873v8FW5wZd6RC1ora69dKbup0VyQgrC6Seo2QHpTX9bY2urzE7+CrBtxzOTHvqpsRUMF5WnNsKWPPdxy7/+85pEYK33FrQxuhAG9fTmiQ0W1tDptMZRVm2MA9riaKIYl6QJOFMJXD6ubwPBP+WkkBAu2GlLUZlVaGjNYh5bS2u6opYS7RaQ4qqCmvdugC3ErNTC3BZlq2qQal2RPEQpex0tHCq07XWkqbpW0xeZ3FeEeloHZz4FsM3S1OyLKNNSX7319a4mtrkGLeirDyLE09HVOhiii1WLJYP2M+XTNMn+eCV5/jUc1e4PBAsS8u0qaldgwyGEASSgPIG6X0rzPWgI01/tMH8/BXsrS9jVndoDr/Njdeu8/TVSyQ2sFw1HKwM88OyjX9Sc8xqzPz6t6n2v0U4fBk9vos4meDLGRGG4WCTv/DFn+Jv/Y2fQiQ97h6sqIxDBEEsNSEYmrqmLHKkhqVpmM6nHKxy/PZlXrh0kY9dPUdX1kwPpkTeEEqNThI6WUa5WFIHR9p59xpoKVs3Z1U3OG/XeWYJaRZR5Kd2cEVV1QihsMYgQoGplygVGPSHdNM+dT1mlRusbYhiR5yAsQWz5Qpp9ZrfkK0joNaqaBkoihUhtM4/8BhTYUyNqZaYegU4ivmCJu9RzWckHY3zgpPZhEFvRK/bx3vPdLlYL34bhmqIFIoArYtSKIRQ1HVNmmZsbQoOj46AQBQpalPT73VpTI21Dc60ySndrMeot/GO1+8di25/OKCpA1EUMGaftNthPHE8//6rlPk3cdSkZKRRnzg95uITfTpZxdHhLcqFpjIFVjbYeIOiHgGXOZ6keHGJ3ceukvUHBB9oqoayrHj9W3/MdHqM1JLB1gZegK9TqnyDvcd2uHPjECkkWRrY6hwzt0+ASAhBtMLw2pBPV2z1+1xM73Bp51V2OhOyEGOKjCbkEHmWMxhkGp0GylIgPRi5IIoCmUpozAlBKqTSSFExm1pqbQlBUS1TVouazS0w9tGK7ul5uymijbVueQySQEAg2NzYYGPjBOc9QiqKctLCy7WmqmriJKbb7Z6xb9vuQOGcRRDaz3XaUdM6wmpjztQTp/rYNO6cGSja+W697prVGXvh9JzGtmupkOuCeprTFkXR2xQPb1HLTuN+FFIrZAAZReuFHcRJTBzr9at891U3iQSD3hAZD1HeE+ocZQt0pmjSjLLxVCeO849f5NMffpLL5zWrumJsNN5LYhROKGpnMdZincc0LTcghAhrHFJodLqNHT6GPzlA2QZ7ckw+c6zqwMl0wnya01+HcGqzolcv2JofI0+OWB49wM+P0NaRxhndbsYLH/okP/Wf/RfE/Q0WxfoaeE/W7bIqy9aVWNeczGd4aTg6OeY7d8bo7Yt88cNP8eJTT1BMj6m9Z3dnk7GpiIZDjBJgHIwi4nqGfYRg1SjWKCVpTE3AE8cS5yoEmk6nSxwnxHG8vnHXpElKrARSBjqJwpsGF2A0jNFRYJk7kNCYJU1j0VHLuC1Ly8nJGIEiSSKE9AhhqZsCKUI7l3UWW1do16Cp6HVj+r2UajHn5ChCZ21h3tgasJwvKZuc8cK2mtu6YnJ8glKyTa8WtEAg2VrYq7r9GWjWDOutrS2MNa1Jw1k8rdvTe89iucAa2NsdkDyKOUIHy/ZOh62dkk40YJh2GCQQqxvQHHH7zTF0LBefGBFNBcv5IdN0QSRqjNLUSrBcXaNuLjMaPcflJz7A4W//ISIolrMZsQLnLK+98h2EkGyPety+c4Ns0EdpiTcli9zyxvUlH/vIFaZH+5SFJNHQz5YMF2NmLsUJSV05JnfG9PWCZy9e57Fzhwwjj3QxZWHweowRksPyReL+RXT6m8TBULgGLQSZnRN0iQ4JtRlj7AnSFexuerTyoANNHbBG45oInH5IUfto52HGwBlx7CHUIwGSOGJvb4fZYoXxnuFwSFEUDIfDtuv07oyZeyrjat/4KXWVv01NcGpc8MG3pc0LcB6pVKs5pM08e5jZ8FaApX/bwkxK2RZPWvXF6ZjhYXjOqVLh9IYgpWxz9tbA9lhrtJQoJeh0k7PP/Sjn+557ik4W4+oVtphRNTGm6RBMDzcaEfU3scNn2H38KnuDHgHDogyUC0tdtSQq59vuxVqPMY6yarAogghYL7BNgy3uYjTsXv0wn/jcZ/nYD38KKSXT3CJrQ180EEPfChqhyX3CxtYuTSK56Q0HTjCMDBup5NKTT/DiZ/86C9Pj3mt3yPOSoqhxVpClXUxwVMFjnMVYz+HhXe7e/zZ1UfMTP/z9/PD7nmA5zlE6pco9UsQMB0OODyrSzg7ON9hqgU5jVv7dd7pCCcqqXN9UA2mWEWlN09h1mkl7w+90ejgHcZxhTE3V1GxtxBTWUJUFcZQxGsXoRKC043hyQl0XRLJPpMBKS1HOmc+X9Lodev2UKA441+ARFIXFVRW2KDi31WN3axstLcEbbBkYH044d2mT4AJ5XlFbiBPJfDkjBE8n6yEklGXNeDxpu+e41UTHaUIWd2ia5iyCqt/vY62hMXVLHQyeOE6IdERTBaxxpN0uZfUIaMcPPw+DwZwsbYhsDfYudX5IUxqSOKLTTVksHb1Owmi0Q7HIEaGg9jHj+S4++SjXnvsMW1u7aBVxeHTESx98D1XpKauCyckxg9GQslxhDPzGb32dD37kJa49e4Xj8T3KIid4w40Hjk/pIY9f3OH6d46QQZOlBb3oiMnqHHWTMtu/x2bnNZ7/gGWrJ+hGEFxJUVlCDCs/YmE+gux/P14UGPXHxO4u1il8LIlNzsWdLmn/HK+8dofBTsLcNPSHGqkS8rwkKAtxTZAQiPCmeafL912d07HC21QL65nqqVOtzSITDIYDNjYGFPvHZwU2hEC/328Zp1XZxvqsC2QLt4nQSrR4zbXe9lTR0BbYgFiPM05lYs5ZnLNnTrTToulcy6N9OFX4bP7swxnD4bSjPbUMn8puTpOC23ihaD12yFBa4b0jyRJ0pHHeIkT0tpvRn/c8cXEL1xSUQFlblHbUAWovCEGTpAk7u5KmXvLqN6+z+9jjGBLmq4K6adChwgeojaWxHuvaUY+xNaWraYqCfPxtmsM3uPbkU/z1L/401557DhsUk3FNzxuiLGXpTcti9Q2ZSoh9Q0VCEbZ47OlPEPd3+NAzQ174vufp772PooE33rjH8mRC05RrYHxLzxJxyiu37rEz7DE9POD2ze8wnz/gwx/9GD/8uU+2Mj4hKOuSThQTGkWnvwc2Y744Io0ktS2IVAfB/F1f21MDgxQSh8M0DoEmjlOkiKgqQ55P6HX7DPoDtG4ttkEYrLekWcTsZNmOloRlOOwxGGakHcFiFiNCTJHXSF3R7QkCEqUaxJr2hzDY2rNa1PTihAsXd9kepKSRx1tDWdUkSlLkDfNZTrbZxRKxzAu204w067DMlyil6XRTlouCo6MxUdSydNNuTNUUaNm+b5umRYA2TYNUkm63R/CObtppjUSmDWpNVExelGsb/n/4vGPRfWzrPiHUiGaOK2aUkxmluUNZQ1EaOr09dKLxYkkn67HZG3H73st88zu3EPocn/n8Z3n22nNo1QJ+T4PfvBc0DqqmpnGGKO1y//4ROxf2+NV/+yu88PxzJHHrOa/yiqNxw5e/csBnf/Ap7t08IlQxabqiNzhC798iL0ueunyDq5ckG702ILOuDfgI0piT+jxG/gghu4aNDBGKOuzSi26jI4dRilods9y/wXJyg7B4ldTd4fylhqqB1TpFQWuJx2OCoagE3nxveLoPnzMrMOskjhAIQqwVBoq9vR3myxWrVYnW+ozcn2UZznuKsv2GC9qFQ/vIFNHv9wHOwB1lWRK8f1uEz+lI4FTDe1p4T2exsI74Ifypm4UL/qw7Pi2w7d9vxwkPW31PM9fw7WtroToCH9obQBDhLPTy3Z7QzBDOEqsGowyhaQgSiFqbc6ShGwdOVlNeffX3uHn/Nv2txyHOsF6SSIfC0BjfIiC9o3EVdbVitVgyPb7Pyc3XuNjd5Kf/45/h+fc8i1CSeV7RicEmFmElptEUTYlQHts0GG9pQqDwjp0LF/jxH/s0H3hqG1PBfJ6DXeJ8zaDXocgtkojFfIZ14F3NZj9iOj3g/v51Tma3SKPAX/7CT5BEPQ5P1o4sKnxdIUhZlo60K1mWgbKqiFSCaypC/e6LrkCQZinBrXm2TUNRlGRpl92dDUwzpVmrXaRU9PsD8rzEOstssUSjsK7GO4fU0M0EXnt6jWQ42EHLlJOTOceTmm4/YdtHKNXGuidxhJaCWGmmRxNC3dDvSERoKPIcgsUZ0z5FCcFikVM6w2h7AxEEy1XZ8o2NYbla0Em7JGnEcl4RHAjRMNros8wXHC2P2BhunO1FWiqgJNEJIe5TlxV5sSJOWlKZlJqqNlj/CDzdb/7hH3L1iS51MccXMcUi4KIRIcoRyTmcu0xvGFHU13FuhZZ9Njc2GAzvM19ch3ofJd7TpgXQ6kSdA+MDeVVTm5rGOvqbu1R396lNzUsffelMFiIkBGdZnCz55X96hx/57Gd5/LEBd26vCMQMejmb/euc2zHsbmmGHYOWOXUtQMbkJCyr57HqU5h0B6sbEt1FNQ7ld5FSk2mBdw2RdrjwOqqRfP8LCc9deoYbr7zKy6/l5NaztSWwTjIJCl/B5KAiSh4truf117/DM89c+1Md3RnzQLzlTJOiLUrDfp/z57a5Y44e4t620JlO1lkXL4c1hqoqEaHl5koh2lgcKVvTRbd7VnwfBpAD6wLZpm48rEg4PVK2iagP/5lap0JI4VsTRxyfWSpPl2+nBopIaZqqbjvy9dhyNpsjhWB7ewsRFAFPCO/+pnbvzVd4/NKT4GogrC3bASFbdrHWGmUtvUSzsgWz45ucLBeEZICOu2RRihYWUERK4smpy5x60XBydJeD298gc56/9lM/yfPvexqpHMFbUq1phCVJY1zZoKOIyDlKArX3rKxlVVec293kJ//CR9nazJicLKiLhmo1R4tAkkiqxhNrcNYzPt5nscjZu3iJ3V6HTrzHeP9NyjLnQy98nKtPfx/TWYktGlxTYBY5rvEQWeKkR1UXKCFRQVA3OZOjNzk+ePVdX9vxYcPOXoJHrKFKgl6vj7OBKE7WMVb12WgmBOhkXeqmwbk2xdu6Nm0hTjx1NUVohVaeSHqgZrQR0R3sUNYFsYqJ44wyr+gkGd40xEqw04+48fpNDg/3GXRTIsU6H1ETa01eNERSIxzUZU0/61LaukUWxAnz+Qy/xvZ5B176tUytItEpxXLBalnQ6bYRQqNBD4XkZDzFWkcUxfggMM6D9Phg0HF8xkT5D513LLp/57//NX7+732GTtLBE2O7I1aFJNhrbO18iMHoabo9wXj8Wxzf/1VcPUNFGZf2rnKrusMrr/5jNs89g9UZs/mC4+MJs1VBZWFV1jTViiA0BI/Es727S/AG51o5lhQROorZ2hyRn8z48u/Neen5Sxwc/hFNFZEqwcawoJMptjYcYFtWqtBMq23m5gO45FOYpIdUgihIqA1aRXj/OEImxKmjXgZ6NGThLpcfe4rHdhQvf+33OT6YM1/FeOnZ2rAsCksSOTqJII4l4hGSDQB+7n/4H/m5n//5s83+6bLp7WGPtHpWIdY6XMHuzjZlZTg8ciDCOv23DVSUEmIVQxyhJSyXS8qiXhdeiRdvgWceJo89HKuj1Gkq71vLt4dnta3udi0RE23nqKRErpcKpwu007yz0+460hGRUDhj24w23dLSlqsVR8fH9LrdVnWxTmwQjzAz/5f/58/zs//130MIhdadNl3Z1AhbIFUEdi2rU5IskbjgmNdTlqs5Qab00gGdpIOKIrRaEGxDufSMD/Z5cOfrNNM7fO5Hv8CPfO5FgnV4J2hs+4qNtQQCOopwvsQj8UFT1g2VsYx6CX/1P3qJS+d7LW1LSXSs6Q26HB0fU3k4zgt2spQ7d66TzybEQHlyQDe7TJb12Ni+yObeMzzz3k+RFxmT6QmmKeh2YpqmTQ1xtsGFFcHWCGeIZMO9g+9w79bL6NW7d6R99beW/Nhf66C0oCxay3eSpOgkIfhAHCdYO2OxWDEaRZjGAZKmtm1xQyCjCGMNs/EBWmk2Rhv0O12McVRVgY4UnY5CxZpEx8RRSjfThKZhtjyhMhWjQZ9Ll3e5c3OfRZGTxppR0iXSCikVWZy2brKtTVSqscLjK3AesrRL1nh844hjT7crUELRTTMUkjTuwDAmz0uc8cRSIp0CCcvlCh88vX47evTeUtU1zlUkcYfmz1iwv2PR/bXfvs2v/M6EF1/8AIezhJuHDecGP8APfujTbDy+SRMEJ7PAaPvTlPl9Zg9eJsQRw80Ru6uGe8e/w7/5lV8gZC8xW1XkRYmMOzgZY3AoCYnyLZZRBiIlUEpT1S36zXuJCAVC3KO3seBr3zzgc596go2N1ykO20TP7a0OStcEDL7xzJeKByePs5IvYbvXSOIOEOiqho6SuEbjlKD0GaXrEqcFcgWJDPjigP07Nd9+5RiJYdWkuM5jdLOCvQuWJ3SfW2++QXfQQngekezIb/z6r/HvfvM3+aHPf/5Pfey0AJ89xq8f6xEQ6Yjz53Yoq5L5whNCh7qqca6Niw7RqdwmRdDyQbXSLa8h+DM+wimeMYqis+Rfte4I/UMut4edcm1RbhcoeA8CpBZn89qHDRSnC7jgPcG1Fs6wHj/Ea7bCYrng/v37OO/WjN32EU4E8UiLype//ju89sof8IGXPoUjwpU1WlgMEiUVQrxFNVNKI7UlAkJdUqzmUC3xnSE6g0Qq6gIOD+9y694fUlYT3vfix/krX/gCG90O5cpQe4mTkOcLhJCkaYrJK5RWmLwEEbPIQRDxuU++j8uXt5FAqAS9rM9JPQMp6faHpCpierKiXDXcu/UmzWpOvz9kY2uHiojag8wyBjuXuPjk+zBB0x0MaOoI05QMNzc4PjpEqgjvGup8gSnm3Lz9GuPDG4T5fYx59xTzG9/JuXOj5uq1DnGS4FzA2UB3kGHXN9s4TiiKiqqsWagl0EY4RToi1pq0l2IaS77KKaucWGliHSFDIBLrRa11ZEqghCW4km4aE3dSmkIgRcr2zpA06xAEHB+PqfOKvKyIBz2SOELIHpWrUUGSRgnj+RSCp6kdsY6JdUJRLfG2lZ8JD92sS5p2mM0WCKFJdEKqMpzx3Lpzp32CWbsyXXCkWYe6KamqgqKoKGRFkr4zZ/sdi25VWX7uF1/mv/xv/zLHqxqk4oMf+yTxzhYHxZjX3jhmNR7ywnNbrKr3EtQhrpyiOim7587TmBV3J18ic5tI9TguBLwVuODxyqHiqPUq02o1XQhYZ3DG4RuPqCaU+eukHcMPvue9/Mjn38/mlmNn+wK3797BU5JkDcFrShSHDxL++NsdFuISg8c2SKIaX8zopgLlUqpas6ymlPWKrhkzHG2j41sg2xniZLKgqJeMdjTOepb+Av3Nj2DKr5CXMy5duojmNlHSmhKCeLROt6oq/sEv/AIvffgjjDY2znSpD9uC4a0CHNYCshAgjVNGgyGTyYxIx8hMYmyN96YNpWwsQUfrrp5WokVLHbPuLf2s9/6MdSvlW66xh3XDp/+/UmqdHuxaza9o5WanRfksxuWhgErbGITQ9Lq99QImtAhJrcjLghs3b5wlFmsh2iBd36azPgppu2kq/p9/+r9w9bkPonSC1lBXds2GaNb4SPHQ16aRPpBIy6Kac7SY0x06OqaPrEqm09vcP/wWTipe+v6/xV/8/I/y/LVtVAhYrXAeGtuyjaHVPzvv6HY7jGdzKusIwfCep4e89MITxCpga0nwGkUgjhQiRMjaUBU1m4Me9+/e4ve+/FUuX77McO8plkYThMP6HNOU+GBIOgmFh0ZE1M6wmOXQTKnzGc4HBv0B+/du8uDut5ivDul4T9TMmDTvvmOwJvDlXx1z/rELaBWTJhIpFU1jKIqa5WKFFJpIt0jS5XJFv9cnSzO8a9+b3U6H7XPnCM5zuH/QSkGTBCUV8+WSytR04wwfLCE4itUEHbqIOCYIy8bONnEnwS7nxP1AUkqMEdRVQ1nVZGlKHEUYbzFlu/yuigoTArGQ0AktcS/NWBQNWdQljRK0iMiXJWVpyDKN1orlckW33wWheLA/Jskko40RiEBZ5igdtWnnyrK1tUWWPULRBbh+/V5MtxEAACAASURBVAb/75e+xHs+/EM89eRVbt2bcnhUYExg5RzInG/cCPhlxmb/A/TFV7ClR8WK3Z3LLOuXmS5+jWj4eVSUQKiQWqOVaH9oaeM2WD9S1mVDk8/J529g6/u897mn+IGPPcW1K7vELNi/9TWO96eUc4GNU9JeC5+4Pz3PzdmT7OdLGlnD7ICRFDgRUzoNTYBQ4X2Oq+YEKzBVRFACFUmC93ilSLp9CmPJGaI2P0IdeqxW8GB/xvLo66jgIWiErEniRyu6AC+//DL//J/9M/72f/KfrotueNus9O0hkLLlWoTAalUwny3XMzO/7lAFSZpibY1xnrJsM59OLcDGtN7wJInJ1m60pmnO1AWnLNxTMPnpOdUDR3GM8O3nCSGsEyPeGj1EUdQaG9ZMheACsYrPCq71vk20cJayWPHmmzfIi5wsS9FCMMg6Z7KzU1fbo5wbb3yT3/71f8knf/ivtuMZeZp43JpHrG2z24RUaKGIvEEGhzUF89mcul6RxxnVbJ/p+E1E1Odjn/3b/NCnf4wnL8StQ9K172OlJFJ6dBQTqZhFXhNpzXi5YuUajmdHCDHnUx9/gVEicEbiQqtdDbZAhAZTl0jpqFxBbiqWteelT3+B7a1NkqxDVSxZHD7AeU8cFBGa3MDhvKEqG5bjB6yObiPrCaOeYj5fcvuNl5ns36QuJyhrWNQ5Mys4Hn3kka7twb2Kb319xYsfHxFHCSFAWTY0tYF1nl+nE1EUbVp3EzVEUURd10gpqKua0HckUcRoNGJjuNFKHH1ARBpvSqQSZ6aDEBzWWUxpma2WiEjTH/XxwlKanMZWRKlGaEVjW41tJ03J4pSmNgitwUuqusAJSFONFpDojPO7PXY3d5iOTziaTCisRWmN9QHhPUhJkmbs7u0RJXfJizbBQqoIW5fgJVIput3OOujyERZpAMF7vvabv8LHP/GXiOIOixIWpUML1YY56IaFUUixickd2ehDqPnXCErT7Y24dOEaxc17xPWrvPdDP0PWGbGqS7728isYI4CIEASN8Zi8oJjdRfjXuXyp4iMfep5nrgxRTcHi8Bu8fvc1vv2d+7x584RVAdZpZBwTR31cMyTefIIn44r7N29TTOYkKkUoS0SCFwu0AUpDk58wY0mmc4Z9TxYn1HVBf6gpKkfptok774V4wGK+ZLZYsNG1BHKs8AQ8CE20ts0+yvHe8Y/+t3/IZz73OS5ffqKFiJ99zK/BYwLBacquY3Iy4+6DfZZ53s7I1gzcsP7h1zpGSY1VLQ3sFC5zCmWO1iOC05HAWwuv9t+fRus8PF6IowgtFdZb4jgmTdN1N2vP/k4UtYGNIYBfg3Sybg+koFpHBwklyfMVN27eYLFY0OlkiBBIk4Ss2/n3ksne/bX1/Jt/9X/w7Ps+yubWHlpr7Dq3rWma1hGHPBulSCzBO0KTU03vkDclOEtTLPHAcx//DB//6Kc4t5XRSVsKlQ9rR+R67p4mMcvcgA1gAk3twCcURc3Tj29z5YnztJiWVpESMDRmgbOO4/E+i7KmM9hBpxtce89F9navUldLsBUHszHVbMHu3nlWTU168TL3JzlpccD08B717D6JnWMXx9xZ7LNYjgm1JdQFdTNh1ZRMG03Z/QCL0Q890rUNAb72uyc8894h27sZIJAyJo7abrfX7dLJOi3jubZrBkhMmiY0TU1RFkwmE2QQbAyHbbT5Gd/DEoKhrtvZblVWFGVBkiZ0uj0ccDQZs7O7jY4S6qZG6PZF+bUFvm4aOllGlMSYylPXre2XWrCYrxDB08sydJYhVMRqaZicVFSNxLeRxBjXxvFkkSYvC+IsYWd3h2EzoLE1dd0QRfFaUhkwNrDK/2yQ0HcFD1iejPnqb/7ffOFn/nNcSBHSIkSMDjH4BkRNZ9CnKWsO62d5/4WK8fErxLpia2PIZSu5e+s6FzPD3pVLfOnX/y3VqkBFmwglqFYLynyMr25ycXfF93/4MteuXECJmsXRKzy4/W3u3j/maLpk2XganRAiiSBnWTq6MtDtJsTcIR48zuMXLnD91hucTFdY36fbHxHyLlFsENUAHBh1xLIqqVfQFR7hFYl2jAvLwu3RGTxFU0VMJg8oFhXNJgjRLj1QYAl/pjTkuz337t3ll/7h/8p/93f+7tk38GzEgGqLWAhYazgaT7m/f0BR1Vi/FpaFgPetMN25t5ZxD/toTxUIQqz1lWs52MOxOm33mj1khHhotLHulIG3GR+8D2vHmm7Tcv36BkDLxGVNX7LO4UNgNp3yxvXXqeqiLdyyfT2dTudt8TyPao44PZPjB/z6l/4vvvjT/w1hrXu2zrZdb5vZAqJVHgRrwBlsuaSa3MHlY2RweKHoX3qJFz/0GXb6I3RwaBTax8gAlfPrlBPIspi89gRlcU2D95Z7dx9w/TvX+cQHP043jpAu4IVDR5JQN8znU+7cPSLrbHHt2jN4Ooynlny5oj/IEH5B7eHSlafJooS6WNARlqrKee33/x3Zxi4Ht79FPrlNT1Qkbk6jC3yhENbSuGMWtmLhH4P+Rwm953HhndMNvpszPzF89bcnfOYvtE9B0XqcpWT7Xmi5IT2qskap1kwkFehIEccRKlJgA9Y76rJBrZNLGpPjQ0PdWDrdEUXhMLZhPBmzo9ol2WQy596DA0bDISpKiDNJ0o04frAgkjFOK1a2YZB2cASM8+gkpt/tIVmRiAjpNFVuGM8XbIwUQqYEKrSKaFyNjiNcCAit8dZweHTE1taQKFXYAooiRynFcDjEB0/TVCRJ0i6I3+F818SW3/2NL/HCR36Ax6+8gDUFV54cEYKlceCDQwtD3E3pJV12rv41ROqYP/gaqYK97QH5asnv/+bPc3X8Re698S1c06cGltUhhOtcPO946RMXef/Tz5Ioy2zyOnfvfZv9+zeZzRyls+TE3FtdZDJ/AlPf4tmL+6zqCUrV9JMp/eVtjN7DjFK2t7o8uHeT2BakVmO6AZ+1gXexmxHrO/STivncEDoCiSYAy7JP6F+g9IY8P2BxPEbbFLxB6hKtJLiAc4r8EdOAHz7/6l/+C37sx/8iL37oQ2eP623hDPggqOqaw8Njjo4mlHXdzsfXxfjUOhx8eKszlq1Ez5jqTIcrpUBrSXAtu5b1Y1Bd12csXinV28wN+uGu+Myt1grFH04YjqQ8sy0HIVqug1AY7/C2VUc82N/njTdepzY1vX4HpeTaKKHZ3NhoUwX822N+vhfnD37nX/Pix36Iy0++B+kVxlV42T5lBGchtEXXOUNwDltX+LpEmBxPQCS7XLv2Md535b3EoaEpLVWVYq2kqwJp5DFOEIWwHhl4qjpnPJ8yna0YDGIuPbHDhQubKAnSteMg07Qux9Wq4alnniHSI+aLwPRk0UaQpzBZrNA6JtsaMD7aZzgaUGtHVQG2Zpclxawiro45nNykmh8T64xiuAnGYaylkluQXYHu85hkDxML0O+eMvbweeWPZly5lnLl6a2z77VS0Rl7QQq5LsgapSV53iaVCBGv1T8e37TBqsFBksTUpkSoNn3ZmJIoBk9FpHuczGZr5kNgldd0OgEhY+qmojfqkg07TCYFw50thPfUwWCwlLVh1O8wSlN0gDRJGPY2uX9/HxEkaZZSLEoaa0jiGB3FWNfumaL1z06eL6lNTW3WypxYURYldROTJMm6ebGk6Tu7/b7ropsvl3zpn/8yf/Nnn6LfUTz/nvN0M4WxrU+5rCrqKufB3fsYd5nzl75InS9pZm/SSTyXHrvAq/Ov8/u/9YBJMWJZgY4rds95Pvz8Fd5/7Rm6sWB1/DrXj15n//g2y2WNMT2mQTOZX+F4coGx6xCyDbIksHm+hxpbKpuTSslQ1OTNEqM6DHoJiyjD1Ya8OiaLc7qiS6YPGcXHRGpC5BRRp+3CknVhGYy2mRExW+xTHh8ilx6ZJNRNSRJF+GApc4dxLY3qe3Xm8zm/+Pd/gZ//+/+ALEvXhaeVINVNw4ODA46PJxjjcb5t0Nql2mnRbV1h4TTQPQSU1Oi0ReR5QZvpvrb+EliPF9qonCzLiOO41dsG395I1wX1lDq2brnfhn6Morgt4CKAEAQEKorb/CjfgnIWizk3b93i/v37CBnodrtEuk2fEAj6vR6bm5uc5iD/Sbzlo54iX/Cv/8Uv8dP/1d+l8a41m4SWlOadIXhHUazIi5zVakGxKlqwTRAEoej0L3H12Y+SDfuU1RH7syUrO2RnNyWJ2iVwkiga59eSMcNXvvL7rIqK/uYuB/tH9PuawbCDUuBsG4leNQatE65eeQ9Cw2LhSJOUnU3BwdEBSiqSKKZ2AW9ty7iIIuJOl7wuGAyHzE/mdENDsjXCs8WD144Y+1189n5Cx6NEFy+3cXKA1xEqteyMUrL00TtdgLryfOXfTdk730dKqKp6baBpkxkiHSGQ66eu9c3GgBBtV+sJrXEkrA1IBHTMmTzxZH5Cp5u2ltskptMZMh6fYHzAONBxxmA44uBwSlQZejtDSmtYVUuyOKUuK6I0pl7mFIsVFy9coBMnHB2OsdUS0ziGG33KumA8PUIlkt6oR6fXY7GYkyQxzjp8cAjlqaoVdh2H1ekkKC3XzYyi3++RFyuct+94zf5cbMJvf/NruOIun/6Rn+DOjde5fPkiG8MRUSfBDlKWfsBkMWZytE9y9QoXrvwIt1/737HljG6ccfnyY8wn1zH1PS5fHPDMU1d477OX2OoplpPb3DrY5yS/Q25qjE+Z1Rs8OOmyf7JH6S4joi2IpjibotUzBPUqexc2uHsvRwhLZzgjOh6j7EWkkPQGEePFFGlTerWmow/Y7dwl1YakY0lEgmgkdVNAB1xjaMo5q2bOyoItHbEMeFNxPF5iraNqwAXFcukov4dFF+B3v/w7/Pqv/lt+9Mf/Yiu/Asqq4u7dB4wnJ1jn8S60c8iH5Fl+3eF6/xAEXZx2pQKpEqRoCym0igPnHN6FNfNgnRIhFYrWEcYakPOwBCyEgAiBKNJnwOkQQgtRb1vrtlOVrXJhtVpx9+5dbt26tV6YZWRxupaSxWipSeKYvXN7dLvdNh04BBTfuy739Lz+6h/w6h9/mWef/zgiCGrfmjaMbViuVkynExbLBZPxAavZId4tQTiETtnc2yMbJBzmOXXRcP9ghbs7Z3Mzo//kEO81hpraxtRNQIiIS5evAoqy8hweTLl381vMT55jsdxAmIAXXdJM0jQGSQxCIHVFtciJo4idrW329/eJo/ax/fbt2+zubDM5PMCLhM5oi9VihkgTNIF6VqPznL6sOMprgtxDRCnepag4Yne3z5XLe+xuD9juDzm+e/97dm3v3a741stTvu/5baIowVmHUrpl964Xv0oqvPN4rwhetLPz4EEEpIbGrhdnQdLtpdRNQ5JlzOZLZrMV1gqmJ0t2zj3GcHPEyaJktlgxWqwYjbYZbsyZTieczxLSjmY5W7JYFmRJQl8nRGnK0cEJwUkuP3GBfr/PbLZivlwh45idvT6dXoahJuAAR5bG9DsdQjAkaYe4dixXM4wtUSHCx5ooUi30Jrh2XLKG5rzT+XMVXWMa/skv/SJ/5Sc+TxonnJwsKQrHpfO7IBXZsuDZiWXlj5h3NTvn9th76knuv/ZHSAzb249x7nxDXt3h2UvP8p6rF3DVA24e5ExOcqqwIm8yprMdJssBs3qTwj6BiS/ScIIwgn58AdkDXzseTDb4/g9cYHI0oWkMvc6KXnyb5TLF2hwVS0KZIUTB5rkJj587ZhAbYj1EaoEtLfOlprM5woiGoiwQYkkwc4S/QBAWF9+lJ+s10MNR1AGHJi8t7nsTHHF2mqbhf/6ffpGPfvwH2Nzcoqgr7j14wHg6xbq2w3Vr9erDcqf2F+tfrX64/b3EB5CqfWO34wrXxl6Ldosv1mMBQquUcMEArbje8xBb4bT7XM+4WnbvWxZgbIDQuubquuHg4JDr169zMp2gdUTWyUjTlDRN1nMvjY5iRqMNzu/ttTPAh2hrD5PXvhfHWsNv/H//hEtPfR9SxlTlisViysnJpI1ZPxkzmx0wHx9Qzw8glCAkKu6SdDP2D2+zshlRtkuuzkMc8+ZEsDvUbKUCKw0nS8Ode1M2d3Y4t3eRO7fvMz/ex02+xd1v/Ba3rz9H/f6rxE6QdTSrxtIbaFZLQZ4btFSMhhmrVYmUgl6vd+YYHA6HFGWFijO8UQgvsLKiu9FjNRvTKIVVAxojkUpjmxopIx57fIcX3v8477t6iX6WUcyXNHlNwfeuYfAO/vgP5lx4LENpz2AwIIoimqblKJdlhVJ6/fXUGNvgXMQqX2BMzWDQJYolRZkTJQoVZbjKkudLNrY2OT6eIFVEnjdMpgs2N7e5d/+Isii4f/+AOO6yt3eB2WzOYrFCiVbPbpxDNAHyhijqgKiYTudEsaLX7xPFEV44Do6OKYxn59wG82LMyfSYJIYsSajrFSribB7d7WYoJWgaS75aYoxjNBy1S2Dr1kvad+50/9yanFe++TK//E/+Mc9du8qgO+D6a7e48eY9gpljbvwhyt4iu5Sjs5uI8B36GzvsPb6FCQu8K7h69TzPPLMHYcbhwZscj09YNo55o3njXp/Xbr6Xe5OPMK1eZGmfwyV76MzRzxK0AGfrNio9GVCWTxHsJhf2NlBSEEvJaDhFuJtQ5ySi4eJowdOXb/LkxSO2epJep4PSJVXd5407m7xxv4/VKVL8/+2dWYxk533df3dfau29p2flcF9EUhwtpCRLcWhLiS1LjhHFduwsBoLESF4TIEDykMBG4IcggQEpdizDimQLdiRIsjbSskiF4ojLcJ3hkJzh7DO91l519/X78nCrmyNakSVySEpBH6DQQHV3NeYO6tR3z/9/zpGQKhhWiuZEGJqBoYNlT3AcD9cQUIKhayiqQiEUpHzjK2OvxSunT/OFv/hzkjhha3OLXr9PXpQUQlLIbcIV04e86rR79XNUdutCVJpemhPFJUkKpdARqBRSViQuNPJCUEzDzAtRIuTU9DD1nFdyQtWKqqr69HUl2fQWOcsLwiSmN+xx6tQrfPfR7/HYk0/S6XbRDQPHsbEsG8MwMU27SmYyDEzTZO/efdQc59VUNdgZ2h1//vg1vbabq+c59ug38cOAbm+LTmcdz/NI85xSCrI0Jwt9KJPqRkHaaGYDoQh6vQ06WxuMFJOivRdPU/nSd47y1KkeXV/ipxZRLugM+tiuRhSHnDl9nOefepBTJx4h7p/jpWNH0RSdWr2JLHN0tcSyVQxDoiHJopSyyFBVCMOQWs3FskyCIJiezMbYrotpaeSlxK7PkAkdgY6hSlA1JmWDsn6Q5swe/t6H7uVf/PL7+aX7bmGl4dLSBcFoSBiN8UZnr+m1HfYyzrwcURRV8pYQkiiKURUD07TI85w8T3BcE8vSEbJAiII0jSiKrHJGUhDFAXmeTauaFEzTYGl5GUXViZOcjY0uplmj2aihqILRaMy5cxfQdYMDBw6SJBlCKDsRk4ZpMxoHhEGM26jRmmkTxSmD0YRciGq1rWbgeR5jb8xMq4Fl6kRhiBAFE29At7dFf9DF8zykVDAMi3qtTt2ubMFpmlIWVb5IvV5n1H8DxZQ/CEII/uAP/gcf+6UPcdNN+7n7bp28OEGumri3xBSaRDHHOGVMWYSURYSrm9Rsi2E/xHYaXHdwD77vk5RjhqOcrc1F+ukhSnuJ2twCxA0mQZWyVNccylxBlCq6KtEMF0dvo+gxUp1ja3SI2w6FdHtb5JFK04VGvUOvW8Nt5Ow/MKLVUGnVDSxdkOYJk8jm1MUm3cmN1E2dtHiBGTshKusYVoGKjUkO6hBL87F0gSJLVAmWVmU1yKtCu68lhBB8/k8/xx133IXl1CgKKGWVw8DOifbqr68+hKwCabaDwQXVc6UQiLxy0aiaRNclplalj+VKjqpJNG16ai0KNE3FkKDurMep6DBNGatIXVUkZSlJsxTPH7PV3WRzawvfi5FSwbYMLMfEtoyd0+12JoOu6xi6xfLiCstLK6iq9n0+iNUrq3z603/Ml770JUbD1++cei2klDz1yNdY3Hcr9cYMtfosqAaoClES4w236F15he76eXrdLaIkp1QSPK+DtdkijiN6hkUtN8i6J+ieepbNAzfQW25i5RppWPXnPfXEU7x88jhrl1+kt/oi/uASMh1z6dTzbG1sYR66AVWCQUkWqsRBjCgltm0SxSlSSmzLIElToiiervxJbLdOXpYkeUlWgqqbZEWIZurIMiYfbVJEAw7cfoCP/9qHeedtizTrIMqMQSqYhClpNuDJv/pjXnjiK/CHv3UNry28fGLC3UdupdlsMh77OHaTNM2p1WooSpUsqGkKM7PVEL4sqyopVVFQUUEqBEGMbUcYhsXc/ByNeoutbo9mu8lwGNPrRBzYC/Va9f8hhWA4HLK6uka73UQKlShOmWnO47oWCiphFDHxPNqtJs32LFke43khWZggpUqr3WBlr0Pf65Gm0Gg0CAIP3/eoN+vkWTpN0hOIEpAqeZFjWxazuk5eVk67yTDjhad9Xjr+w8OEXlffzPr6Bv/tv/8nPvWpf8rcrIKiBCjCRuBhlgX62KMM+oSRT5L6RKlASofZuVkQBS3Tpem2efq5kzz++CpLB+5h7sZ3IswWpqUjBwInGyPSGrZsg6VRyIw5pw2KWmmThkucTlgbrPDud8B8+xnSpEBisTgb4fX7zM/B4oxOzRXoWkhZqGysmzz/ks4oW0S0LRTpEMQNZpsdNFNgqAYNcsayj8EF6naMq5mkcQlKyeZGQbdT8Cbw7Q46nS0++9n/xW/+s98GTUNSTk+4VWdTJS1cHQxebTi8Sr5y2n02/Z54NWyoKBXSWBART5e4q4ocVRNoulFNmUu1kk5UtRrCiRQpE6SEoihJs5zQD4jDiPFkjBeMqz1cVEzLxtINTEPHMg1s06hq7k1r2n1lYGgG7UaL6w4exLYsVE1FQTKZTPjKl/+ST//Rp7ly5cqbcm2DyZBTzz7CR3/936GoKkWRIVFIhcbszBJ7l/cT+e9iazBgvdtlNDzLpOtD+DxinBNtncQwH0IZvEgx7vFce5FUk9hSY7B2is5gg86Vk0yGqyR+n3C4hZYntJstNCl56cVXaC0cxtYEhlai6g55WSAkUCo4jkWSBLRaTcZX1qY5BgrjiYfr1vHDCabjYkuVMArRdQj8CUEwYDAasHzzPXzg5+7jyO1N5mZLRJHjjRUG3TGPPfp5Hv3qJ/EG107PvRq+l3PssS0+/ok2IDBMo1oBy2Icx0TXFfI8pdWuE/gpCgLHNqdNJimW4SJkjO8HVYVWvVUFhE88LNtiZWWRUy9tMhiMmV9YwvOGOLbKcBCwurqB7/tYloUQGmPPx7VhYX6eQ4f2s7G+SSkKhuMxtbqJqitkQU4YZJi6zeysxUyrRRAHGGY1s/B8j5nZFq7rsr62jmkY1Jw6mjFt3I6TaY+fyclnfJ55fIA3/uHSArxO0gX48pcf4zc+cQfvv2+WNE4oUgNTTsjykFzkyFwgs4I4bjIuWoSZwDKbtOsZab6BgmRh70GW93QoxUVmm/czyBXCxMSpCRx/CWMGFEsBVcdRLUxTqTIP9AQln6MsCkaTAafP6dxw3X5Go7OINGO+ppLOq8zNNHGciJKIIHK5cN7izDmHUdIkVBKspEPOLL4/Q7nQwnA8RAmmvEjqCer1MfMNlXAkuLJa0BmWeJ58Uwl3G8eefIx33/tBbrr1DqDSSqVQdv72jpQglR3JYVtq2CbeaqVsSr4SpKoiS3byF0RRWXqlzHeydit7bDGNVwRR5pRlUkkceUmaZaRpRp4XUBbV2pWmY1rVG8zQVUzDwDLMHeK1LAPLNDHNynffcB2uv+4Qc7MzKEjSJOWxo0f55Cc/yYnjJ17jwrv2OH38Ue6576McuuluNG26b5xLNMtCFQ00o4Y9u4/67ID1y3XS4ZNM+udRhyGyXCURxyoXoD3DiTNPcybo4U7WkJMtRBQQRn2i0EdFoWYazC81cYyCuqtx8vQFlg4PmJutMT9rosicmdkmRSbwvJDNjQ620yCMquB53aihGyqaHmKYOqU3naSrgrIISOMJ41GHza01ZvffxpEP/gqH9x3G0VQMKfCDlGePPsoXPvN7rF96bqcz783Cyy8MeMc7B+w74JJlBa5bR4iULE9wHBtJQRIHqErBxJ+gTUtLfd+n0WyyZ7bNaDzG9wI6Wx2GQ48gSDDzEtu2cWs6nW6H5T0zWJaD45pIqTIeh3ieR71hVQ45Srr9HmEQsrQ0z4FDe8mSjOFgSFkYmIaJKFPSpKTXGyHVjEbbRtenGz01FykL+v0+juuiKiq6ZqDrBrqmo5HQbLY4c2rIU9/botfJf2ReeN2k63kJv/NfvsBnPvUBTHMZSQ5JSZA2GBcWL15cp5Q1HPc6YrlAWZQYqsI+xrjCw2bMTKvOre+8meeff4mzpx5h360fAcVCV3PqTYVQpqiqixA6Ts2pSihxMaROHkVoQc4kPMGJUzl3fOwwzdY5wm6KZdjsWSnQdY+01NgazHPm4iz9UZNUz9HqKU6ek49D4ppgEhRkuYtpSErVx3EDXK1kqe7iDXNOnsrp9N7c0+1rkcQR3/jaF/ntQ4cxbbtaX5KvZsxuSwz8oNzZ6VTt+/d4q0c53emtyFoBRds5DQshKUVGWebTR0EpSoQoKg14GuQt0FA1UHQdnSrZrIp7VNB1BdPQMfUqn9cyq5Zh3awqeWzbYv++vazsWUaRklMvvcgf/eH/5OGHHt6p+nmzkSYh333gMywf+F1sp0ZRCChzlDJEygShqahCIuIRud9Do6TIwcgsbEVi1ASN695F+6ZfoG+1GI+6+EGJ4QXURIhlN1G0OkWWM7fYZHlWxzF10vpeTm95rH7xr1hZaPEvf+N+FhsmpSzJFEkvDZmdbaLpFucurtFstun3x1huk9ZMT6YeKAAAFrhJREFUm25vC9t18PwJfugReH380SrD7llarXne8e5fxGnupygK5puSF557ii9+9lM8dfRB0uSHB2tfK2RpydGHV/nEb95IWWakWUyjWWMyGVWZF7IkjWNqjQZqrFeJbLKSvqIkZm5xnrk5Dc8LCOMYo4CJ5+PYLrktsCyYjD0GgyH1epO8iLEsHctUKQpJmuZIoWKaNrW6SpFlDIY9Wo2qAy0vCxTDwlFVJEPcuolbt/DDCMWQtGZqVfi/IqhtlwPECe2ZGXRVr9qB05TuRsorLwace8Uj+zFzLN5Qne0TT3X4/F9EvP/v3IofXSE4f57hpTGL19/N8fUGF0cjjryjxkLTQDMcQtVldZCzUm9S5j5OLWHfyh7i2OPk6aOI4B6c+h6STEU3VZrUqwJFrcTS68hSg1yipwH+8DhGcZ4PvdflfUcOUJMdGvZB1ooOpRpi1BPCyOXclUUu9ffiyTnKRgbxEK0okbJAaArReMzEhayMcKwSNTGwTEGtbnP6rODC5Yw0ewvZ9iqcPf0yzz79OO/9wM9edcKVV5HvdGWBv6nvIkW1OivLatt3KkcIWYXJVL+tTB9VJkJlyGBnR1hRVVQkoFeJWEq1OaxrGoqs9F1FkdWeolaRrqFXBgxDNzBNG0NXMTQNQ9OwDIOlpSUOHTzIaDDg83/2Z3zxf3+BwWDwll/bS+eO8/Lzj3Dnez48TRozSEqDUvNRC0EWBKTjNWS0hVr0UDQfyzaZbxk097SZuekIxaH3kuaC9vx+Zm+7g2U9oqnEaIZFnOaEfheZjdHTjCRW6OYqvbWcYf8pDi5Y/Kt/dB9N0yKRGrEomZmfRQgIprkNCgpFXiDjkCTPKKXAcS2yYYbnDfDH6ww7l5G0uOXO+xH6DF4cYvsBn/uDz/ClP/sTJqP+W35tr1z0OHmiw533zJEkMaap4VhmZUBRIEkzLKdgZWWFTqfDcDxC1TWSNKXXH+DWbHTDIIxS2qaLlApJktJotHCcnDSRbGxscuDgIqWAoiyqTBFTR9MsAj8nDCIWl9oYLQ1ZliiaiqKo1Op1TMPANnU0o3KXNtsuYy8jCGMUtSo1rTerunXHcojCkCytQvCTDF5+wefEMwPi+PWtL70h0s1zwaf/9CkO3PzztJbfh7P/BmbLCYPNkhsPvguaazz8wNd5z13v4KY73oHMFYI049JY5brFFmoa4LqC6/YfxPdOcOXsg1x/xyeoObM4dh3bkNTtBRr1GTrdIee2zpBGmxRKl9uu17jv3kPsnW8R9tc4e/pl+r0BCmkVoCNnGIzadCf7kO4NuHqODAMyYRHmPhKJaVgUYchgfULka8wtFaRRxuXLCsdPZgTBNd4J+zFRlgXffuCr3Hz7XTRbbV4b6r3jRJN8/wmYaa2jst2o++q6lwqUUO2tiGphXQFQdn5qJ/ZQqZYYdkhY01RUKaaWjaoWW90hXRVNBV1Xq4dmYOpVALhp6JiGwdLCPHuXl3nwG9/kT/74j7l48eKbMoz8USDKgse//eccvvkems1F8rJKUbMyyOKQoLdKOFwlCzuIdEzbgZV5h5VZG8dqIvQS1Ym55aYbuG1viyKt2oILv08RBwRZTskK41GXeDyhE+f01Aa9MxF5nOKNPMIkIREFQjMwdYNG2+RK10fVLBTV5My5S8zMLjDxffqjHoapsXVpg273MpPBJSbdS4SB4N4P3I9iNRmMe6ydO8bF4w8y7m/sfCC/5ddWwNOP9bnp1hlsG1RZoKkqhQTdNHBw8YIAu1ZDUdXq9l3XmEw8esMBVmBMg/lL4iTGMjUmk5gwiDBNi1ZLZzwZE8UTXNcmyzJQoFav02rME4ddVlcnCAHz8zVcxyZLUzRFo1lzqNkmlmmysnexyi+hYGl5ls2tLuNJRBArCKmwMDeLokCraVIWcPrkmBPPjJmM/nbd9ofhDZEuwOp6j28++HX+w3/+XRbm342eZ5w/cxlcg9lBg8HmGUTdJipLynQIZUp/krG57vOeO+s0lSFNx+T2G64nTS6gpGf44Af/OU6tSd1ysBWLUX+N88e/Ruk/x/69Oh+67wgHlhdIw0tcOPkUV66c5uLmmE6cUygWpmigqBo1V8cwJbZiohoFoaZgOyZ55pBmAkVm1GsZeRww6DgknsLzz5Zsbsk3nJV7rbC1scbR73yLv//xT7zqUvu+0y7TN9d0gMZVsYjb1jOm3jZlahwDEKCU06GcUv2OMo1rVFVt58SrKAqqFOiSygAhVUCgKiqKKtGmITmapqCpCpqhoWs6uqpNSRdMXafdqDPsdPjD3/99nn/uub+RZPZ2oLd5haf/z1f4mfs/gVQSyCaUYcBka4vh5kWysEcWj3FtleWFPbRnTOpqQakoNFo29x45zIGlJYx4xFbsM8pMbMOmEBmFUlKkJWaZMxwH9IXFZGmObL6B6kFcjrjQLzhwQEWTOUiVLAVZKMSZSqk6qE6DsJR0PY8wiUkGI1Yvv0I8WSPor9LrbXLDHUcolJQnv/eXbJ59mmC4inyTddsfBYNewgtPD/jZjyxh2QZ5XiAyKouwruBHIcPhmCzPQVOwXYc0y/AmXlU0m053fKMIKVV0XWM0rmJMpVQwTYjjmHa7PZ1FlJWdfG6GJAZvklJzbYosY5Ik2IaJbpmYuoOqCtIsolazceouSZogFUGt2cQ2LfIsI5hEGKpHu9Wm3yt58rtbbKyG14QX3jDpAjz4wKPcefPv8E9+89+jt/dQX2lCITC7gnvf/0HCNCfPQ9QiJI4G9L2EzU5MKgzuuTlluVUw16xzyw1znL/8LDL4WVZW3oMoJOP+WY49+llMnuOjH97PDYcPk/k+l185RmfjFQa9kG6ksR7sI0znaRohtn6uEu5dnfnZOSaJyig0MUydNLWwNRuhTJByQLOV4i66vPxiRL+fU779XPA38Ph3H+KuI+9lZd+B75MZtr9u5xELXkPGO5iKCZVTF43KDSQUtcoSFpV5uEo4296M0KcErFQCxLYzTdFQFW16wq1MFhXpqih69ebQVRVdUTB1HUNT8McjvvX1r/H0sWNE0VujLf5okDz35AMcuv56FuZnKZKAQWeL7uYqUdQniYcYWsGeuSbzbRtdE+SFwsyBO3j/h3+FxcVlcm/COPRIocp0UCDXdGquQ1ZGZHWHDBXLmEUv6mhahGIbxGWLE6c2+cBd+zE1MF2NTidGKgqjIGdtEJJg0lndYNi7QjRep79xnrB7iXC4ge+PUGstwizl6AOfYbR+HlFeW4fkG8Uzx7rc9a45brxlBj8IyASVA01Rabdb6LpBMoqqlDBFwTItdK3K4aWs1iRVVZKmBZblYBg2eVZptuhWta0kYWVlT1V0KRSkLGk2Lfas2Ozbu0SW5QSBT8t1sU0T0zIphSBOI/woxLYbCE0lDGNs26bdaFaDYNPk1MvnefKRy2xcycnfQP7wa3FNSDcIcr72lUfZb2vceOSXWL7uLs5dHjLyKjdNEXsYsiBNQrw4JShjzPYB1sYxs90Sx5igGRmLS3XiOODot/+Ircsv0etdxIte5rpDJvfedwdCxqyde5zO5nkmXszIb3B5o8bq4DD15fdi1z0c4wQzrke308GUJa3WJfx4HzK3EEpAkUSUaYCpBWhOQhwKLp6JSJOfkKPtD4DvTXj4wa/y67/121PrbfW8nJ5eK5IV24fa6ntXke+OsUsRKNtasFLJDwCq+iqJq6qyc0BWtoOO2SZkiapWdeuqWg3QKk1XRdEVVE1BVysN11RVkiDgsaeOcezx7zGZvP4ixDcTUTDh2ce/xf0/93FG3Q26W5eZeD2K1KdIY+bbNeZnbCwNslRQW7qTn/nov6Exfz1x6JOXEYlpIuKUBgmZNBBlgSgT8rxkY5RyUdoE7gJpYaOmGSgNlKbD48+e5GN/9zZWWjalquMVNrks6Y2HDKIC3xtz/uzLBIMrDDqXSIcbZIOLJGlEoajoDDn/xLco8+Ttvow/EIFf8J2/XmN5fw3VUBFJQeD7iFJWJhnLwXVs4iRBU6o6KVM3SabRkFKCouRV7XlatTvUanUMw8T3Y6IwYDT0WFicpz3TZjLy6HU2pxp9QZKGSClpNF0MXa/CnlSBUAToCkIoVVh508F1XZgeLPxJwulLAc88GRIG1/6D7JqQLsALr4Qcfe5JNoN1bhn9PKp2CJKMcLhJs+6SZBKv1PHVFlatiVWAptp4cY5mNYmTdcxayZ4Vlc6zL/D1L3+P2+/cx7vftcKsq9LdOMFmd0SUCrZ6Lqcv1NgcLTC/cj8zh/egWAU1w0H4s8zMFvh+j8wvaNoBunwFsj3E8RBRDNGkShh4jHoJcfT234r9KDh5/Bnedeolbr79LmC7ReL7eHY6Fvv+56rn1UrffU0VQ6X5bjcoVAE1KNs/JasgG4BpSaSiVpKDRmXZVVWq59SKuFWt0naVouTFF05w9DsP0dnaett02x8V506fYHF+EZ0EP+gTxzFlUtBwarQbDqYuyfKcsHS4/vAR5vbdRhYFiLSPKAQODoWqUdp1FKmhSUkYjVnr9LnQDUgbB+jpTXI/RksicgQ1K2f1wmlOvLyJdfthxn7Iuc2Esxc3KdKEoR+iioSFdhNHzNCyJflCm2DQ4Nzp5yEaUPwtdtOfBJw6OeLYExe49wMHydKMOIopCoEQVZ2TruuVCDxtN2k323STPnle0mq20DKBouSMhmP6/RG27XD99dcRhSllqTAe+VhWlWIWeB5JkrK0tIiuNzAtnaLIESIjiGNGWYbtOBi2RS4yNEOhyFO8cUKj2WJxaYXuasa3vv4iw/6b90F2zUg3zSWPPOOxZ+8lnnri8xw48F6knGFlbpGkLMB0aFoNGgXYTsZMM2VhboaVxVtZbiVsnn2MXv8sbtPihhsWsU2N225aoohDzo89BqHO2obF5Y0Z1rot7Nat7L/jBgoVDFQMMca0Q5JgjjgrWVxsE8WXsdMas7V1umsapCFpNGDSjQm95O2aM7wuZGnKX3/zKxw8fAOW7e4Q69WJXNvND9vfrMQCddrMoexsMFwd3bhTsS6rAZoitwshq62G6jVVUF7dbNCo6lmqYodqmKZpFQlvXL7E0Ycf4sLZs2/6vu21Qp5nPP/sUW68fj9lXhIHMbZl0m7VcGyDQmZ4mc7Sdfdw8Pb3QZkg4gEizZC5QLcMNNMizKAsKgNAv7fBxcvnGckWUXuWJFFgMiZLvMrmHMTUVQvfT7iwEXDh3Dprw5TucELDNlGyDI2MPMtoOA6TRCVKPLobr5BHvcol81OAIoenHp1w060BCjpSajhOFYCfZRlQ3YllaUKUJzi2Q7vVIooipKRK+CoFrlvDMAqKvKTfG9BstsjSkjxPyNN8J0jJNCXzC7N43gQQzMw0sCybNE0JQp8CBdMxkGqJpisoQiWKMjYuT3j0gQ6dtcrK/GbimpEuwKXVlN5knsP7E7qbTzM7cx2WpjK/7xb27G/QsC0MTcGtpbiWga6kKFpOnkYoe9uo+QyTeEyz5XD4hjkmQYdMCC5vFnQn+wiz2xGNFfbMtFB1EyEL1LzAVFMajoZXhAwTk8ZghnffcQvdzjplJpl3S9T8Ev0rOZ4XIMqfIra9CpcvnOXZY4/xvg/dj0K1g/taVKRZcWwVtVhxcOX5UhG82swgpayqdahyFZTtN7KsdFy5E4Qup+HnCtq0RkdRqmGbqlSW4Mmoz5OPPsLJ48+RvEX7ttcSnuexudHDMEykKJlrNzHNqqwzTiVCb/IzH/kVbj1yH1GUoLh1MkUjigbVgr8CuqKSSthYv8Tli6cJJwMm9RaDpMAc9SjHIRKB4ZrMO03+8cd/lYMre1jvxvQGPmnkMeOoiDyioauMBkN0tWQ83OLsiYforL5EWaRv96X6sbG1lvL0Yx3e84FFam4dt2YTRRFJUp0mVVWlVrMxjTpbm1voho4Q4HsxZaFQFIJSCCzTpubqDAZDam6dZsMiDKu+O8/zsB0Lx7VQFImiCMaTEWE4YXFxCUWTmKZCq95CoGAYCmEQMu5nnHou5vxpn/wtWg29pqRbCnjgoTG/9x/vZGu9g2uXvOvIMnMHa5iqhlZ6lOUQReaIUCeMxkRxyCQbIbIYxXKomXWk4tNuNuj2+zx+9BSnzmmYjZtpryyB2UJHo0wCdDXFdQpM3SaMczYGHnlW55VhyTtv34thzBBMUl5+JeHU6YQo+ukk220IIfjuQw9wyx130Z6Z+39ICaApEkG1VyuvOvVuh4zvpIYJiaJWrbslr7ZQbA/duCrmUZuSbnWiZiovqCRRyIlnnuTY977LZHztchLeDnT6A2r1GeZnm9TcGrpuUBQZeQ4L+w9w8613o0oFHShUg6IMpjvJCiUF3tjjwuU1rlw8RzTsEpUmqbMPO02wdA19aRmtrnBg0eWX332IAzWHztDDH42Zn5vDcS2iMEDRBP54CEXEmZce5sKpR4jD8dt9eV43hIDnnphw8+1tllfaVcuJouD7PoZhUBaCQT/k7jtvol5vcOXyOkWREKcpWVYiJURZgq7rzLTbaIrC1uYGrVZlZJhfmMfzJtNw9ConeXnPMo5rMR6PiZMQgG63z549BmathoLL+Rc9nn2sT+i/tXdk15R0AVbXQx55POHf/utfpNlcwKoZZP0t4jxDFn2yoiCXglzmRJ6Knql0Mo1czJNN5qlZbebnTpMlaxi6xcF9+9na6rI1ehHVMbGKvZTmHiwrwKnpaLJFb9Bn4F0iHmdkpccw7vPY0xnhsMZffLXLVk/8VEkJPwz9boejD3+LX/gHv4qyXdw4DWbYVmwlFTFWw7Ltf7iCtl0CKit9V6rTHV8qGUJeZZeoXkjs1P5sd7ep042Gsig48+JJjn7nr9lcX/2J121/FJRlSZZnOG4dw7QQUiHPBV4qOLh0GMdpUZQpFBmmZpGZJmmq0R906fUHbHYG9Le6ZJMOXnedaOEIhxcXOHLLYaLc5vLGAF33+cjdc9y1bNLpxMSBpOHWCcIY126iCIV+Z51LZ5/g9LN/yah/6W3bt72WmIxKnnlsyM9/zJ4OxrJp+ahGs9nmyuUuZ85e5PbbbkW7zmVzvcPFi6tEUUqr1aBl1SlFSb1u4TqzDIbDKkTJNqnVHOI4JE1jDENnNBqiqiqOUyNNU0zToCwFpmERBRmXzqU8/8SQ7kb0tlzaa066AF/6xml+7R/ew20Nn1HXB1IUJUPIWdL8FkZpySTqEAYWcbGAl6uoRYkoZkBOiGUTs9BAi6nVVa4/rOO/dInLL8ZIY4b5g/tpNOcZ9hto9ohMjJkMOwgvQtX7FLnP5z63xeZaQJ7/dGhfPw6eefIo97z3fezZd/Aqsp1S7nYzJFMH2dQEsT0w06fkWm09bI/MKlTEedW4TVYtwdtZotuyRa+zyXce/AZnT5+iKH6y1pTeKLIkRMqqgTbMq5QvrzRZ3ncjqqZjqDlRmRIGGYPhiF5/ncsXzuOPxiSRT5H2SLwubdvl9lsPctN1Bk074XKpIG3JjQcXObJ/njAUKKaJkH0UVaHZbuL7PsF4ne99879y5eyxn7gVsDeKl4573Hi7zdyiThiG6HplwnEch8XFWbqdDpZpUas1aLVb7FlJGQ5H09D7Kih8Z8irQl6kOKpJUeSVG9LQqNVqhGFcZTk0liqL8bQkNfRVHvv2Fp31grJ4+z7IFPn/wxFlF7vYxS5+SvBjh5jvYhe72MUuXj92SXcXu9jFLt5C7JLuLnaxi128hdgl3V3sYhe7eAuxS7q72MUudvEWYpd0d7GLXeziLcT/BZXcbK6i5zQeAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def pre_proc_for_dali(item: t.Dict[str, np.ndarray]) -> t.List[np.ndarray]:\n", + " \"\"\"Converts a dict to a list of numpy arrays. DALI only accepts list.\"\"\"\n", + " return [np.array(v, dtype=np.float32) for v in item.values()]\n", + "\n", + "\n", + "sq_it = MessagepackDriver(URL).get_iter().map(pre_proc_for_dali)\n", + "dali_it = get_dali_it(it=sq_it, batch_size=num_viz_imgs, already_batched=False)\n", + "\n", + "pipe_out = next(iter(dali_it))\n", + "imgs = pipe_out[0][IMG_KEY] # dali_it returns a list of outputs (one for each pipeline) and we only have one pipeline, hence access first pipeline\n", + "plot_imgs(imgs[:num_viz_imgs])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "1b119db7-a853-46d4-bed2-32cd893fa80f", + "metadata": { + "id": "1b119db7-a853-46d4-bed2-32cd893fa80f" + }, + "source": [ + "We can see how DALI augments the images. If you want to feed your training loop with the DALI iterable, you could do so with the following code: \n", + "\n", + "```python\n", + "model = MyModel(...)\n", + "for pipes_out in dali_it:\n", + " item = pipes_out[0] # unpack your pipelines\n", + " imgs, labels = item[\"image\"], item[\"label\"] \n", + " logits = model(imgs)\n", + " ...\n", + "```\n", + "\n", + "Let's briefly build a typical pipeline based on Torchvision transforms, which we will use later for performance comparisons. The Squirrel pipeline that runs Torchvision transforms returns the same visual output as the DALI pipeline - sanity check complete!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "41328410-4413-48e8-97e8-41c2dc6ae7ef", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 104 + }, + "id": "41328410-4413-48e8-97e8-41c2dc6ae7ef", + "outputId": "31f22c5b-1fd1-4f09-bf4c-0374e09762db" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def pre_proc_torchvision(item: t.Dict[str, np.ndarray], device: torch.device = \"cpu\") -> t.Dict[str, torch.Tensor]:\n", + " img = item[IMG_KEY]\n", + " img = torch.from_numpy(img).to(device)\n", + " img = img.permute((2, 0, 1)) # convert data from HWC to CHW for transforms\n", + " img = F.center_crop(img, AUG_SIZE)\n", + " img = F.rotate(img, AUG_ROT)\n", + "\n", + " item[IMG_KEY] = img.permute((1, 2, 0)) # convert back to HWC\n", + " item[LABEL_KEY] = torch.from_numpy(item[LABEL_KEY]).to(device)\n", + " return item\n", + "\n", + "\n", + "th_it = MessagepackDriver(URL).get_iter().map(pre_proc_torchvision)\n", + "imgs = th_it.take(num_viz_imgs).map(access_img).collect()\n", + "plot_imgs(imgs)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "97121387-0b0f-48ac-bdb6-2d617246a10d", + "metadata": { + "id": "97121387-0b0f-48ac-bdb6-2d617246a10d" + }, + "source": [ + "## Performance Guidelines DALI\n", + "\n", + "Now that we know how to create a Squirrel-based DALI data loader let's see how to utilize it best. The below code builds some utility functions that measure the loading speed of an iterable and plot results." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "50b96326-db5e-48cf-8d0e-676d81596c40", + "metadata": { + "id": "50b96326-db5e-48cf-8d0e-676d81596c40" + }, + "outputs": [], + "source": [ + "def benchmark_it(\n", + " it: t.Callable[[], t.Iterable],\n", + " n_exp: int = 5,\n", + " batch_size: int = BATCH_SIZE,\n", + " ds_len: int = DS_LEN,\n", + " img_h: int = AUG_SIZE,\n", + " img_w: int = AUG_SIZE,\n", + " img_key: str = IMG_KEY,\n", + " device: torch.device = \"cuda:0\",\n", + ") -> float:\n", + " \"\"\"Benchmarks loading speed of an iterable. Checks data format and device.\"\"\"\n", + " print(f\"Conducting {n_exp} experiments ...\")\n", + "\n", + " def _run_experiment(it: t.Iterable) -> float:\n", + " t = time()\n", + " num_samples = 0\n", + " expect_num_batches = ds_len // batch_size\n", + "\n", + " for idx, item in enumerate(it):\n", + " # for DALI pipelines, we get a list of pipeline outputs\n", + " if type(item) == list:\n", + " assert len(item) == 1 # we only have one pipeline, can access its output\n", + " item = item[0]\n", + "\n", + " imgs = item[img_key]\n", + " num_samples += imgs.shape[0]\n", + "\n", + " # check whether data in correct format and on device\n", + " assert type(item) == dict\n", + " assert type(imgs) == torch.Tensor\n", + " assert imgs.shape == torch.Size([batch_size, img_h, img_w, 3]), f\"{imgs.shape}\"\n", + " assert imgs.device == torch.device(device)\n", + "\n", + " actual_num_batches = idx + 1\n", + " assert expect_num_batches == actual_num_batches, f\"{expect_num_batches} != {actual_num_batches}\"\n", + " samples_per_sec = num_samples / (time() - t)\n", + "\n", + " return samples_per_sec\n", + "\n", + " speeds = [_run_experiment(it()) for _ in range(n_exp)]\n", + " print(f\"Samples per second: {speeds}\")\n", + " \n", + " return speeds\n", + "\n", + "\n", + "def plot_results(\n", + " results: t.Dict[str, float], title: str, x_label: str = \"Framework\", y_label: str = \"Samples per Second\"\n", + "):\n", + " sns.set_theme(style=\"darkgrid\")\n", + " sns.set_palette([\"#9E36FF\", \"#11D8C1\", \"#CE3D4A\", \"#1D0693\", \"#007D85\"]) # merantix momentum colors\n", + " ax = sns.barplot(data=pd.DataFrame(data=results))\n", + " ax.set_xlabel(x_label)\n", + " ax.set_ylabel(y_label)\n", + " ax.set_title(title)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "a6007557-2f15-4576-958a-7d329ce10dc0", + "metadata": { + "id": "a6007557-2f15-4576-958a-7d329ce10dc0" + }, + "source": [ + "### Batch in Squirrel or DALI?\n", + "\n", + "Both DALI and Squirrel come with batching functionality. In which part of your pipeline should you batch? The below results show that batching in DALI is slightly faster. By batching in DALI, users also avoid having to write a custom (and potentially slow) collation function." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "657c221d-2ac3-44ce-86a3-82f75fd612ad", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 392 + }, + "id": "657c221d-2ac3-44ce-86a3-82f75fd612ad", + "outputId": "3cbdf8af-d585-4f64-9b85-773f656a04b9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conducting 5 experiments ...\n", + "Samples per second: [142.66392683900443, 135.87426791622548, 136.92802813919857, 137.27695543837837, 132.7664031280724]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [133.4174000995052, 126.06113362880966, 129.01778274101076, 127.36907975615293, 124.90424674473644]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# batch in DALI (uses sq_it from above)\n", + "dali_it = lambda: get_dali_it(it=sq_it, already_batched=False)\n", + "result_batch_in_dali = benchmark_it(dali_it)\n", + "\n", + "# batch in Squirrel\n", + "def collation_fn(items: t.List[t.Dict[str, np.ndarray]]) -> t.List[np.ndarray]:\n", + " batch = defaultdict(list)\n", + " for item in items:\n", + " for k, v in item.items():\n", + " batch[k].append(v)\n", + " return [np.array(v, dtype=np.float32) for v in batch.values()]\n", + "\n", + "\n", + "it_batched = MessagepackDriver(URL).get_iter().batched(BATCH_SIZE, collation_fn)\n", + "dali_it_batch_in_squirrel = lambda: get_dali_it(it=it_batched, already_batched=True)\n", + "result_batch_in_squirrel = benchmark_it(dali_it_batch_in_squirrel)\n", + "\n", + "results = {\"Batched in DALI\": result_batch_in_dali, \"Batched in Squirrel\": result_batch_in_squirrel}\n", + "plot_results(results, \"Iteration speed with different batching strategies\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "EoeuK8nci_qw", + "metadata": { + "id": "EoeuK8nci_qw" + }, + "source": [ + "### Return Cupy or Numpy Arrays?\n", + "\n", + "DALI can read `numpy` arrays (on CPU) or `cupy` arrays (on GPU) from external sources. Which one is faster? The below results suggest that directly creating `cupy` arrays is a bit faster. Be aware of the memory footprint of directly creating arrays on the GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "SoQuGZQgpUFD", + "metadata": { + "id": "SoQuGZQgpUFD" + }, + "outputs": [], + "source": [ + "%%capture\n", + "!pip install cupy-cuda11x" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "xSkt5do_qE43", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 357 + }, + "id": "xSkt5do_qE43", + "outputId": "a56faa77-7306-49ba-a738-9d6e40144f49" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conducting 5 experiments ...\n", + "Samples per second: [142.8188631137334, 142.91088551686136, 140.967459451863, 141.38187142523887, 142.3319960197551]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cupy as cp\n", + "\n", + "\n", + "def pre_proc_for_dali_cupy(item: t.Dict[str, cp.ndarray]) -> t.List[cp.ndarray]:\n", + " \"\"\"Converts a dict to a list of cupy arrays. DALI only accepts lists.\"\"\"\n", + " return [cp.array(v, dtype=cp.float32) for v in item.values()]\n", + "\n", + "\n", + "sq_it_cp = MessagepackDriver(URL).get_iter().map(pre_proc_for_dali_cupy)\n", + "dali_it_cp = lambda: get_dali_it(it=sq_it_cp, already_batched=False)\n", + "result_cp = benchmark_it(dali_it_cp)\n", + "\n", + "results = {\"Numpy arrays on CPU\": result_batch_in_dali, \"Cupy arrays on GPU\": result_cp}\n", + "plot_results(results, \"Iteration speed with different Squirrel return formats\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "eyEfBfmKsrRJ", + "metadata": { + "id": "eyEfBfmKsrRJ" + }, + "source": [ + "### Role of Number of Threads?\n", + "\n", + "DALI pipelines can read external sources in a multi-threaded manner. What's the impact of the number of threads on the data loading throughput? Of course, this will differ for each dataset, machine, and loading setting. However, it's interesting to get a rough feel for the importance of this parameter. The results show only minor differences in this case, which indicates that the number of threads does not bottleneck the code." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "QIUSNUn2t7RW", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 571 + }, + "id": "QIUSNUn2t7RW", + "outputId": "055880ef-c631-4668-e242-2938ca790e59" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conducting 5 experiments ...\n", + "Samples per second: [146.2558350307886, 153.49054923835627, 153.99429080194957, 153.83547090120513, 154.56215522390596]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [154.8344308396196, 154.35314446703015, 154.6798785163675, 152.40237937823622, 154.54069059181336]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [154.3716736065559, 152.71661504235544, 153.8712600654633, 154.51485393720156, 152.8186483199712]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [154.5332575912717, 154.51187448086432, 151.98396958941765, 154.6547050220404, 153.6805946343663]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [151.84645979863532, 154.27101556598618, 154.51604785193177, 152.24865037958293, 154.23921773071734]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [154.5531833008394, 152.72407946534383, 154.1892347954226, 154.71717760354, 152.79373752063805]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [154.80233029200272, 154.49577418765668, 152.5959274195581, 154.23348571528894, 154.48560230582277]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_threads = [1, 2, 3, 4, 8, 16, 32]\n", + "results = {}\n", + "\n", + "for thr in num_threads:\n", + " dali_it_cp = lambda: get_dali_it(it=sq_it_cp, num_threads=thr, already_batched=False)\n", + " results[thr] = benchmark_it(dali_it_cp)\n", + "\n", + "plot_results(results, \"Iteration speed and number of DALI threads\", x_label=\"Number of Threads\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d45888dd-acc0-43c7-966b-e71b618abdb2", + "metadata": { + "id": "d45888dd-acc0-43c7-966b-e71b618abdb2" + }, + "source": [ + "## Benchmarks \n", + "\n", + "Lastly, let's investigate the performance benefit of using DALI instead of Torchvision. Torchvision can do image augmentation both on the CPU and GPU. The plots below show that DALI outperforms both Torchvision frameworks on this simple image augmentation task. We assume the difference is even more significant for more complex image augmentations." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8d1af642-7037-48fc-b444-38bd30d73070", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 403 + }, + "id": "8d1af642-7037-48fc-b444-38bd30d73070", + "outputId": "29fa6d59-ac58-4902-a3d0-3fc7bf17f689" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conducting 5 experiments ...\n", + "Samples per second: [107.93314326438042, 109.1074383127871, 108.02509450856462, 101.88372640135306, 98.974527403659]\n", + "Conducting 5 experiments ...\n", + "Samples per second: [106.90104520371735, 112.1274796145367, 109.03321575887472, 113.43106441237688, 114.89872670642427]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from torch.utils.data import default_collate\n", + "\n", + "to_cuda = lambda x: {k: v.to(\"cuda:0\") for k, v in x.items()}\n", + "th_it_cpu = (\n", + " lambda: MessagepackDriver(URL)\n", + " .get_iter()\n", + " .map(pre_proc_torchvision)\n", + " .batched(BATCH_SIZE, default_collate)\n", + " .map(to_cuda)\n", + ")\n", + "result_th_cpu = benchmark_it(th_it_cpu)\n", + "\n", + "pre_proc_cuda = lambda x: pre_proc_torchvision(x, \"cuda:0\")\n", + "th_it_gpu = lambda: MessagepackDriver(URL).get_iter().map(pre_proc_cuda).batched(BATCH_SIZE, default_collate)\n", + "result_th_gpu = benchmark_it(th_it_gpu)\n", + "\n", + "results = {\n", + " \"Torchvision\\nCPU\": result_th_cpu,\n", + " \"Torchvision\\nGPU\": result_th_gpu,\n", + " \"DALI\\nGPU\": results[1],\n", + "}\n", + "plot_results(results, \"Iteration speed with different frameworks\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "qsUMrV4GZEbD", + "metadata": { + "id": "qsUMrV4GZEbD" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": ".squirrel", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.15 (main, Oct 11 2022, 22:26:39) \n[Clang 13.0.0 (clang-1300.0.29.30)]" + }, + "vscode": { + "interpreter": { + "hash": "19183a9bda56c37481b0a4e5a9356d3f5322eb975c835a8d0e412d3afe7de2fc" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/index.rst b/docs/index.rst index 3e9f1d68..d5d1e27e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -37,6 +37,7 @@ Squirrel Documentation integration/spark.rst integration/dask.rst integration/squirrel_datasets_drivers.rst + examples/squirrel_dali.ipynb .. toctree:: :maxdepth: 1 diff --git a/requirements.doc.in b/requirements.doc.in index 1b6f2267..e99963a1 100644 --- a/requirements.doc.in +++ b/requirements.doc.in @@ -6,5 +6,6 @@ sphinx_versions sphinx_rtd_theme sphinx-autoapi sphinxcontrib-mermaid +myst_nb # to use jupyter notebooks in docs Jinja2<3.1 # remove when sphinx is updated to 4.4, https://github.com/sphinx-doc/sphinx/issues/1029 click<8.1 # remove when update docs, https://github.com/streamlit/streamlit/issues/4555