diff --git a/DINOv2_ResNet18_hypeRGB_colab.ipynb b/DINOv2_ResNet18_hypeRGB_colab.ipynb new file mode 100644 index 0000000..2b1b848 --- /dev/null +++ b/DINOv2_ResNet18_hypeRGB_colab.ipynb @@ -0,0 +1,9014 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "3SE7Jme6V2J-" + }, + "source": [ + "# Introduction\n", + "\n", + "In this notebook we first evaluate the performance of unimodal MLPs trained using [DINOv2](https://github.com/facebookresearch/dinov2) and [ResNet-18](https://pytorch.org/hub/pytorch_vision_resnet/) embeddings derived from multiple [LeafMachine 3](https://www.leafmachine.org/) products. We then select the best performing ResNet-18 CNNs to test multimodal performance using a late fusion two-tower approach." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IhvFYMIKV2J_" + }, + "source": [ + "# Set up colab environment\n", + "\n", + "This notebook was designed to run on [Google Colab](https://colab.research.google.com/) and run using a T4 Python 3 runtime" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QW1ppDq_V2KA" + }, + "source": [ + "The code in this notebook is written with the expectation that files are found in a Google Drive folder called called `hypeRGB/` Running the following cell should request permissions to mount a google drive account, and this folder should then be visible to the colab notebook as: `/content/drive/MyDrive/hypeRGB`\n", + "\n", + "**Note**: this notebook was written for data exploration as part of our hackathon, and it does not run efficiently on colab, due to file I/O limitations from Google Drive, as well as resource limitations on the free tier. It is presented here as-is, in the spirit of reproducibility from our hackathon." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Zsz4hqAnV2KA", + "outputId": "739d20c0-5ad8-4675-ec73-ed33ddc8e77b" + }, + "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": "markdown", + "metadata": { + "id": "Nsg8ftN_V2KB" + }, + "source": [ + "This folder `/content/drive/MyDrive/hypeRGB` should contain the following folders containing products from LeafMachine 3 processing of herbarium sheet RGB images, as well as a set of metadata CSV files used for sample processing.\n", + "\n", + "| Name | Description |\n", + "| ---- | ----------- |\n", + "| Lamina_RGB/ | Oriented, segmented leaf images from LeafMachine |\n", + "| Lamina_RGB__dinov2embeddings/ | DINOv2 embeddings from above |\n", + "| Leaf_BBox/ | Leaf bounding box images from LeafMachine |\n", + "| Leaf_BBox__dinov2embeddings/ | DINOv2 embeddings from above |\n", + "| Oriented_Leaf_ECT/ | Euler Characteristic Transform images from LeafMachine |\n", + "| Oriented_Leaf_ECT__dinov2embeddings/ | DINOv2 embeddings from above |\n", + "| RGB_Masks_Specimen/ | Full specimen segmented images from LeafMachine |\n", + "| RGB_Masks_Specimen__dinov2embeddings/ | DINOv2 embeddings from above |\n", + "| metadata_v2.csv | Metadata for all samples |\n", + "| metadata_test_v2.csv | Test split for samples |\n", + "| metadata_train_v2.csv | Training split for samples |\n", + "| metadata_grasses_test_v2.csv | Samples to optionally censor from test split |\n", + "| metadata_grasses_train_v2.csv | Samples to optionally censor from training split |\n", + "\n", + "Additionally, the code below will cache the DINOv2 embeddings in, for example, `Lamina_RGB__dinov2embeddings/` to avoid having to re-generate the embeddings each time.\n", + "\n", + "**Note**: the `*_grasses_*` files are used optionally to remove samples from the test/train splits in several sections below, with parameters named, for e.g. `EXCLUDE_GRASSES`. Despite the name, this also includes several species of ferns. The rationale for exclusion is that grasses and ferns have large fundamental differences from many of the other species present. Based on the tests below, using just the RGB images there does not appear to be a substantial impact on accuracy from the inclusion of these species in the testing and training of the classifiers." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tTaPsmU_jcJ7", + "outputId": "984a5d8d-df4e-4d87-cb9b-d9133766c061" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: torch in /usr/local/lib/python3.13/dist-packages (2.11.0+cu128)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.13/dist-packages (0.26.0+cu128)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.13/dist-packages (from torch) (3.32.3)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.13/dist-packages (from torch) (4.16.0)\n", + "Requirement already satisfied: setuptools<82 in /usr/local/lib/python3.13/dist-packages (from torch) (75.2.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.13/dist-packages (from torch) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.13/dist-packages (from torch) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.13/dist-packages (from torch) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.13/dist-packages (from torch) (2025.3.0)\n", + "Requirement already satisfied: cuda-toolkit==12.8.1 in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.1)\n", + "Requirement already satisfied: cuda-bindings<13,>=12.9.4 in /usr/local/lib/python3.13/dist-packages (from torch) (12.9.7)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.19.0.56 in /usr/local/lib/python3.13/dist-packages (from torch) (9.19.0.56)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.13/dist-packages (from torch) (0.7.1)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.28.9 in /usr/local/lib/python3.13/dist-packages (from torch) (2.28.9)\n", + "Requirement already satisfied: nvidia-nvshmem-cu12==3.4.5 in /usr/local/lib/python3.13/dist-packages (from torch) (3.4.5)\n", + "Requirement already satisfied: triton==3.6.0 in /usr/local/lib/python3.13/dist-packages (from torch) (3.6.0)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.4.1)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.90)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (11.3.3.83)\n", + "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (1.13.1.3)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.90)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (10.3.9.90)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (11.7.3.90)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.5.8.93)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.93)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.93)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90.* in /usr/local/lib/python3.13/dist-packages (from cuda-toolkit[cublas,cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==12.8.1; platform_system == \"Linux\"->torch) (12.8.90)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.13/dist-packages (from torchvision) (2.1.3)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.13/dist-packages (from torchvision) (11.3.0)\n", + "Requirement already satisfied: cuda-pathfinder~=1.1 in /usr/local/lib/python3.13/dist-packages (from cuda-bindings<13,>=12.9.4->torch) (1.6.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.13/dist-packages (from sympy>=1.13.3->torch) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.13/dist-packages (from jinja2->torch) (3.0.3)\n", + "Requirement already satisfied: umap-learn in /usr/local/lib/python3.13/dist-packages (0.5.12)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.13/dist-packages (1.6.1)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.13/dist-packages (3.10.0)\n", + "Requirement already satisfied: pillow in /usr/local/lib/python3.13/dist-packages (11.3.0)\n", + "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.13/dist-packages (from umap-learn) (2.1.3)\n", + "Requirement already satisfied: scipy>=1.3.1 in /usr/local/lib/python3.13/dist-packages (from umap-learn) (1.16.3)\n", + "Requirement already satisfied: numba>=0.51.2 in /usr/local/lib/python3.13/dist-packages (from umap-learn) (0.61.2)\n", + "Requirement already satisfied: pynndescent>=0.5 in /usr/local/lib/python3.13/dist-packages (from umap-learn) (0.6.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.13/dist-packages (from umap-learn) (4.67.3)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.13/dist-packages (from scikit-learn) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.13/dist-packages (from scikit-learn) (3.6.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (4.63.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (26.3)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.13/dist-packages (from matplotlib) (2.9.0.post0)\n", + "Requirement already satisfied: llvmlite<0.45,>=0.44.0dev0 in /usr/local/lib/python3.13/dist-packages (from numba>=0.51.2->umap-learn) (0.44.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.13/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n" + ] + } + ], + "source": [ + "# ======================================================================\n", + "# SETUP — Colab environment (uncomment to run in Colab)\n", + "# ======================================================================\n", + "!pip install torch torchvision\n", + "!pip install umap-learn scikit-learn matplotlib pillow\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sGxCygu5jntk", + "outputId": "7fb12609-bf3f-4749-a8f5-9ee9d7e9af4c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using: cuda\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import umap\n", + "from PIL import Image\n", + "from pathlib import Path\n", + "from sklearn.manifold import TSNE\n", + "from torchvision import transforms\n", + "from sklearn.decomposition import PCA\n", + "from tqdm.auto import tqdm # note: if running with Jupyter Lab (not colab) use \"from tqdm.autonotebook import tqdm as notebook_tqdm\"\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import models\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from collections import defaultdict\n", + "from torch.utils.data import Dataset, DataLoader\n", + "\n", + "# Use GPU if available\n", + "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(\"Using:\", DEVICE)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-Ss6Hmj8jth9", + "outputId": "802e2a8d-33f6-42fc-ea12-2cf2c9ee3507" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "fagales_myricaceae_myrica_gale\n" + ] + } + ], + "source": [ + "# ======================================================================\n", + "# SECTION 0 — Map image file names to species names\n", + "# ======================================================================\n", + "# Images are named by the \"specimenId\" column.\n", + "# The species label is built as: order_family_genus_species\n", + "# (all lowercase, spaces in species replaced with underscores).\n", + "\n", + "meta = pd.read_csv(\"/content/drive/MyDrive/hypeRGB/metadata_v2.csv\")\n", + "\n", + "def make_label(row):\n", + " # \"species\" column holds \"Genus species\"; keep just the species epithet\n", + " epithet = str(row[\"species\"]).strip().split(\" \")[1]\n", + " parts = [row[\"order\"], row[\"family\"], row[\"genus\"], epithet]\n", + " return \"_\".join(str(p).strip() for p in parts).lower()\n", + "\n", + "meta[\"label\"] = meta.apply(make_label, axis=1)\n", + "name_to_species = dict(zip(meta[\"specimenId\"].astype(str), meta[\"label\"]))\n", + "\n", + "# Helper: get species from an image file path\n", + "def species_of(image_path):\n", + " stem = Path(image_path).stem # file name without extension\n", + " if \"__\" in stem: # take the specimenId before the \"__\"\n", + " stem = stem.split(\"__\")[0]\n", + " stem = stem.lstrip(\"0\")\n", + " return name_to_species.get(stem, \"unknown\").lstrip(\"0\")\n", + "\n", + "def image_key(p):\n", + " stem = Path(p).stem\n", + " stem = stem.split(\"__\")[0] if \"__\" in stem else stem\n", + " return stem.lstrip(\"0\")\n", + "\n", + "print(name_to_species['289421'])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2-fJqpQYV2KC" + }, + "source": [ + "# DINOv2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UyKPWv9oj6kM", + "outputId": "3993e131-8890-41d4-b288-67f9f85f11e1" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading: \"https://github.com/facebookresearch/dinov2/zipball/main\" to /root/.cache/torch/hub/main.zip\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/root/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/swiglu_ffn.py:51: UserWarning: xFormers is not available (SwiGLU)\n", + " warnings.warn(\"xFormers is not available (SwiGLU)\")\n", + "/root/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/attention.py:33: UserWarning: xFormers is not available (Attention)\n", + " warnings.warn(\"xFormers is not available (Attention)\")\n", + "/root/.cache/torch/hub/facebookresearch_dinov2_main/dinov2/layers/block.py:40: UserWarning: xFormers is not available (Block)\n", + " warnings.warn(\"xFormers is not available (Block)\")\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading: \"https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_pretrain.pth\" to /root/.cache/torch/hub/checkpoints/dinov2_vits14_pretrain.pth\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 84.2M/84.2M [00:00<00:00, 262MB/s]\n" + ] + } + ], + "source": [ + "# ======================================================================\n", + "# SECTION 1 — Load DINOv2\n", + "# ======================================================================\n", + "# Load a pretrained DINOv2 model from torch hub.\n", + "# Options: dinov2_vits14 (small), dinov2_vitb14 (base), dinov2_vitl14 (large)\n", + "\n", + "model = torch.hub.load(\"facebookresearch/dinov2\", \"dinov2_vits14\")\n", + "model = model.to(DEVICE).eval()\n", + "\n", + "PATCH = 14 # DINOv2 patch size\n", + "IMG_SIZE = 224 # must be a multiple of PATCH\n", + "EMBED_DIM = 384 # output dim for vits14 (base=768, large=1024)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "IxhfL9D9kDG3" + }, + "outputs": [], + "source": [ + "# ======================================================================\n", + "# SECTION 2 — Preprocess helper\n", + "# ======================================================================\n", + "# Turn an image file into a normalized tensor DINOv2 expects.\n", + "\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize((IMG_SIZE, IMG_SIZE)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "def load_tensor(image_path):\n", + " img = Image.open(image_path).convert(\"RGB\")\n", + " return preprocess(img).unsqueeze(0).to(DEVICE) # shape [1, 3, 224, 224]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 341 + }, + "id": "kZPrdb-KkFm5", + "outputId": "830113a5-8082-4f59-9bf7-bec0cfcf32c2" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# ======================================================================\n", + "# SECTION 3 — Run one image and visualize its patch embeddings with PCA\n", + "# ======================================================================\n", + "# DINOv2 splits the image into a grid of patches and gives each an embedding.\n", + "# We reduce each patch embedding to 3 values (PCA) and show them as RGB.\n", + "\n", + "\n", + "\n", + "#image_path = \"/content/drive/MyDrive/hypeRGB/RGB_Masks_Specimen/00289421__MaskRGBFull-specimen.jpg\" # <-- set to one of your image files\n", + "image_path = \"/content/drive/MyDrive/hypeRGB/Oriented_Leaf_ECT/00289421__ECT__520_1450_926_1793.png\" # <-- set to one of your image files\n", + "#image_path = \"/content/drive/MyDrive/hypeRGB/Lamina_RGB/00289421__or-RGB-lamina__520_1450_926_1793.jpg\"\n", + "x = load_tensor(image_path)\n", + "\n", + "with torch.no_grad():\n", + " out = model.forward_features(x)\n", + " patch_tokens = out[\"x_norm_patchtokens\"][0] # shape [num_patches, EMBED_DIM]\n", + "\n", + "patches = patch_tokens.cpu().numpy()\n", + "grid = IMG_SIZE // PATCH # 16 patches per side\n", + "\n", + "# PCA the patch embeddings down to 3 channels\n", + "pca = PCA(n_components=3)\n", + "rgb = pca.fit_transform(patches)\n", + "rgb = (rgb - rgb.min()) / (rgb.max() - rgb.min()) # scale to 0..1\n", + "rgb = rgb.reshape(grid, grid, 3)\n", + "\n", + "# Show original next to the PCA \"activation\" image\n", + "fig, ax = plt.subplots(1, 2, figsize=(8, 4))\n", + "ax[0].imshow(Image.open(image_path).convert(\"RGB\").resize((IMG_SIZE, IMG_SIZE)))\n", + "ax[0].set_title(\"image\"); ax[0].axis(\"off\")\n", + "ax[1].imshow(rgb); ax[1].set_title(\"DINOv2 patches (PCA)\"); ax[1].axis(\"off\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ibKocJWakK5L", + "outputId": "ee5022d1-52db-48f6-a938-12e39ba0b584" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "embedding shape: (384,)\n" + ] + } + ], + "source": [ + "# ======================================================================\n", + "# SECTION 4 — Store one image embedding as a variable\n", + "# ======================================================================\n", + "# The CLS token is a single vector summarizing the whole image.\n", + "\n", + "def embed(image_path):\n", + " x = load_tensor(image_path)\n", + " with torch.no_grad():\n", + " vec = model(x) # calling model directly returns the CLS embedding\n", + " return vec[0].cpu().numpy() # shape [EMBED_DIM]\n", + "\n", + "single_embedding = embed(image_path)\n", + "print(\"embedding shape:\", single_embedding.shape)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "y01PLSj3w4Jm", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f1a70be8-5c10-4537-9653-e0bbb3c144a0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Lamina_RGB: 8942 images\n", + "Leaf_BBox: 9042 images\n", + "Oriented_Leaf_ECT: 8942 images\n", + "RGB_Masks_Specimen: 452 images\n" + ] + } + ], + "source": [ + "# ======================================================================\n", + "# SECTION 5 — Embed image folders (cached) and plot a 2D UMAP\n", + "# ======================================================================\n", + "# Embeds several image folders with DINOv2. Each embedding is cached as a\n", + "# per-image .npy in a sibling \"__dinov2embeddings\" dir, so a Colab\n", + "# restart just reloads them instead of recomputing.\n", + "\n", + "\n", + "SOURCE_DIRS = [\n", + " \"/content/drive/MyDrive/hypeRGB/Lamina_RGB\",\n", + " \"/content/drive/MyDrive/hypeRGB/Leaf_BBox\",\n", + " \"/content/drive/MyDrive/hypeRGB/Oriented_Leaf_ECT\",\n", + " \"/content/drive/MyDrive/hypeRGB/RGB_Masks_Specimen\",\n", + "]\n", + "\n", + "# Dataset: loads + preprocesses one image (workers do this in parallel)\n", + "class ImageDataset(Dataset):\n", + " def __init__(self, paths):\n", + " self.paths = paths\n", + " def __len__(self):\n", + " return len(self.paths)\n", + " def __getitem__(self, i):\n", + " img = Image.open(self.paths[i]).convert(\"RGB\")\n", + " return preprocess(img) # [3, 224, 224]\n", + "\n", + "# Embed a whole batch on the GPU at once (fp16 on CUDA for speed)\n", + "@torch.inference_mode()\n", + "def embed_batch(batch):\n", + " batch = batch.to(DEVICE, non_blocking=True)\n", + " if DEVICE == \"cuda\":\n", + " with torch.autocast(\"cuda\", dtype=torch.float16):\n", + " out = model(batch) # CLS embedding per image\n", + " else:\n", + " out = model(batch)\n", + " return out.float().cpu().numpy()\n", + "\n", + "# Embed one folder, using cached .npy files when present\n", + "def embed_dir(image_dir, batch_size=64, num_workers=0):\n", + " image_dir = Path(image_dir)\n", + " out_dir = image_dir.parent / (image_dir.name + \"__dinov2embeddings\")\n", + " out_dir.mkdir(exist_ok=True)\n", + "\n", + " paths = sorted([p for p in image_dir.rglob(\"*\")\n", + " if p.suffix.lower() in [\".jpg\", \".jpeg\", \".png\"]])\n", + " assert len(paths) > 0, f\"No images found under {image_dir} — check the path\"\n", + "\n", + " # Only compute the ones we haven't cached yet\n", + " todo = [p for p in paths if not (out_dir / (p.stem + \".npy\")).exists()]\n", + " if todo:\n", + " loader = DataLoader(ImageDataset(todo), batch_size=batch_size,\n", + " num_workers=num_workers, pin_memory=(DEVICE == \"cuda\"))\n", + " k = 0\n", + " for batch in tqdm(loader, desc=image_dir.name):\n", + " for v in embed_batch(batch):\n", + " np.save(out_dir / (todo[k].stem + \".npy\"), v) # cache to Drive\n", + " k += 1\n", + "\n", + " # Load everything (cached + just-computed) in path order\n", + " embeddings = np.array([np.load(out_dir / (p.stem + \".npy\")) for p in paths])\n", + " labels = [species_of(p) for p in paths]\n", + " return paths, embeddings, labels\n", + "\n", + "# Embed (or load) every folder\n", + "datasets = {}\n", + "for d in SOURCE_DIRS:\n", + " ps, embs, labs = embed_dir(d)\n", + " datasets[Path(d).name] = (ps, embs, labs)\n", + " print(f\"{Path(d).name}: {len(ps)} images\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "BiaX3eGh4MVB", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 751 + }, + "outputId": "a96d6f3f-1182-4950-e4bc-67f64f3c5180" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "active dataset: Oriented_Leaf_ECT (8942, 384)\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.13/dist-packages/umap/umap_.py:1952: UserWarning: n_jobs value 1 overridden to 1 by setting random_state. Use no seed for parallelism.\n", + " warn(\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQcAAAKqCAYAAACHGOiIAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd8VMXawPHf2Wx6hQQIPaFDCpsQqghSJDQBAQFBqg0VlQv4ooiIYkFBQEFFrwpSFQUDdgHh0qsEqaElVEMq6ckm2Xn/WLJkyW5IkKrP935yZc+ZmTNn9qQ9mWdGU0ophBBCCCGEEEIIIYQQ/zq6290BIYQQQgghhBBCCCHE7SHBQSGEEEIIIYQQQggh/qUkOCiEEEIIIYQQQgghxL+UBAeFEEIIIYQQQgghhPiXkuCgEEIIIYQQQgghhBD/UhIcFEIIIYQQQgghhBDiX0qCg0IIIYQQQgghhBBC/EtJcFAIIYQQQgghhBBCiH8pCQ4KIYQQQgghhBBCCPEvJcFBIYQQQlwXTdMYM2bMTb/Oxo0b0TSNjRs3XrPsfffdx3333Wd5HRcXh6ZpLFy48Kb179/g6nG929xN/d+9ezdt2rTB3d0dTdOIjo6+3V36W0wmE8HBwbz55pu3uyt3tRdffJGWLVve7m4IIYT4h5LgoBBCiLvWwoUL0TTN8uHi4kK1atWIjIzkgw8+ICMjo0SdqVOnomkaSUlJlmMjRoxA0zRCQ0NRSpWoYy8IlpyczAsvvEDDhg1xcXGhYsWKREZG8sMPP1z3PR09epT/+7//w2Aw4OnpSdWqVenRowd79uy57jbFv9cPP/xA165d8fX1xcXFhQYNGjBhwgSSk5Nvd9dK2LZtG1OnTuXSpUu3uyuAOaAYHBx8S6+Zn5/PQw89REpKCrNnz2bx4sXUrl37mvWKguD2PqZPn16iznfffUe3bt3w8/PDycmJatWqMWDAAH7//XcAAgICSm2z6ONagffly5dz9uxZq6+htr4OFxccHGwzyK9pGm+88YbNOkOGDEHTNDw8POz2pUWLFmiaxscff2zzvK3vKQ0aNGDMmDFcvHix1PtMTk5mxowZtGvXjkqVKuHj40OrVq34+uuvy3Sda33vGjt2LPv372fNmjWl9kMIIYS4Hvrb3QEhhBDi73r99dcJDAwkPz+f+Ph4Nm7cyNixY5k1axZr1qwhNDS0TO0cOHCAVatW0a9fv2uWjYmJoVOnTiQmJjJy5EgiIiK4dOkSS5cu5YEHHmDChAnMmDGj3Pfy2Wef8fnnn9OvXz+efvpp0tLS+OSTT2jVqhW//PILnTt3Lneb/2a1a9cmJycHR0fH292VW27ChAm89957NG3alIkTJ1KxYkX++OMP5s2bx1dffcX69etp2LBhmdr67bffbnJvzcHB1157jREjRuDj43PTr3cnOnnyJKdPn+a///0vjz32WLnrP/zww3Tv3r3E8bCwMMu/lVKMGjWKhQsXEhYWxrhx4/D39+evv/7iu+++o1OnTmzdupU5c+aQmZlpqffTTz+xfPlyZs+ejZ+fn+V4mzZtSu3TjBkzGDRoEN7e3uW+n6u5uLiwfPlyJk+ebHU8KyuL1atX4+LiYrfu8ePH2b17NwEBASxdupSnnnrKbtmi7ym5ubls2bKFjz/+mJ9++omDBw/i5uZms8727dt5+eWX6d69O5MnT0av17Ny5UoGDRrE4cOHee211+xepyzfu/z9/enduzczZ86kV69e1xoqIYQQonyUEEIIcZdasGCBAtTu3btLnFu/fr1ydXVVtWvXVtnZ2Zbjr776qgJUYmKi5djw4cOVq6uratCggQoNDVUmk8mqLUA988wzltdGo1EFBwcrNzc3tWPHDquyBQUFauDAgQpQX331Vbnvac+ePSojI8PqWFJSkqpUqZK65557yt3ezXT1uNwsGzZsUIDasGHDNcu2b99etW/f/qb36U63bNkyBaiBAweqgoICq3M7d+5Ubm5uKiQkROXn55faTlZW1s3sppUZM2YoQMXGxt7wtq/nuWjfvr0KCgq64X0pzf/+9z8FqG+++aZc9WJjYxWgZsyYcc2yReM8duzYEl/rlFJq0aJFaufOnXbrlef9+eOPPxSg1q1bZ3Xc1tfh4oKCgqzer6L769u3rwJUdHS0VfmlS5cqR0dH9cADDyh3d3ebbU6ZMkVVrlxZrVy5UmmaZvM+7H1PGTdunALUsmXL7N7rqVOnVFxcnNUxk8mkOnbsqJydnVVmZuY1r6OU/e9dSin17bffKk3T1MmTJ+32QwghhLgeklYshBDiH6ljx4688sornD59miVLllyzvE6nY/Lkyfz555989913pZZduXIlBw8etLkGlIODA5988gk+Pj5MnToVgIsXL6LX623OHImJiUHTNObNmwdAs2bNSqTF+fr6cu+993LkyJFr3gfA+fPnGTVqFFWqVMHZ2ZmgoCC++OILqzJF6/itWLGC1157jerVq+Pp6Un//v1JS0sjLy+PsWPHUrlyZTw8PBg5ciR5eXk2r7d06VJLanWzZs3YtGnTdfUJ4Ny5c/Tp0wd3d3cqV67Mf/7zH7vX/fTTT6lbty6urq60aNGCzZs3lyhja83BESNG4OHhwfnz5+nTpw8eHh5UqlSJCRMmUFhYaFU/OTmZoUOH4uXlhY+PD8OHD2f//v0l2oyPj2fkyJHUqFEDZ2dnqlatSu/evYmLi7PZ95vttddeo0KFCnz66ac4ODhYnWvRogUTJ07kwIEDfPvtt5bjRWm0e/fupV27dri5uTFp0iTLuavX7MvLy+PVV1+lXr16ODs7U7NmTf7v//6vxPtVlJYfFRVFcHCw5f3/5ZdfLGWmTp3KCy+8AEBgYKAl3bL4+C1ZsoRmzZrh6upKxYoVGTRoEGfPni1x72V5Lm6kn3/+mXvvvRd3d3c8PT3p0aMHhw4dsirz559/MmLECOrUqYOLiwv+/v6MGjXKKr17xIgRtG/fHoCHHnoITdNu+DqJOTk5vP322zRq1IiZM2eiaVqJMkOHDqVFixY35HpRUVE4OTnRrl27G9Je69atCQwMZNmyZVbHly5dSteuXalYsaLdusuWLaN///707NkTb2/vEm2UpmPHjgDExsbaLRMYGFgiBVzTNPr06UNeXh6nTp0q87Xsfe8qmjm+evXqMvddCCGEKAsJDgohhPjHGjp0KFD2lMjBgwdTv359Xn/9dZtrDxb5/vvvARg2bJjN897e3vTu3ZujR49y4sQJqlSpQvv27VmxYkWJsl9//TUODg489NBDpfYtPj7eKpXPnosXL9KqVSvWrVvHmDFjeP/996lXrx6PPvooc+bMKVH+7bff5tdff+XFF19k1KhRrFq1itGjRzNq1CiOHTvG1KlT6du3LwsXLuSdd94pUf9///sfY8eO5ZFHHuH1118nOTmZrl27cvDgwXL3KScnh06dOvHrr78yZswYXn75ZTZv3sz//d//lbju559/zpNPPom/vz/vvvsu99xzD7169bIZLLKlsLCQyMhIfH19mTlzJu3bt+e9997j008/tZQxmUw88MADLF++nOHDh/Pmm2/y119/MXz48BLt9evXj++++46RI0fy0Ucf8dxzz5GRkcGZM2fK1J8b6fjx48TExNC7d2+8vLxslil6dq9eHzM5OZlu3bphMBiYM2cOHTp0sFnfZDLRq1cvZs6cyQMPPMDcuXPp06cPs2fPZuDAgSXKb9myhaeffppBgwbx7rvvkpubS79+/SzBsb59+/Lwww8DWNbaW7x4MZUqVQLgzTffZNiwYdSvX59Zs2YxduxY1q9fT7t27azWKPy7z0V5LV68mB49euDh4cE777zDK6+8wuHDh2nbtq1VYHPt2rWcOnWKkSNHMnfuXAYNGsRXX31F9+7dLV9rnnzySUsw9rnnnmPx4sW8/PLL5epPdnY2SUlJJT4KCgoA8/uQkpLC4MGDSwSNb4Zt27YRHBx8Q9P6H374Yb766ivLuCUlJfHbb78xePBgu3V27tzJiRMnePjhh3FycqJv374sXbq0zNc8efIkYP5DTXnFx8cDlOnrdxF737u8vb2pW7cuW7duLXc/hBBCiFLd5pmLQgghxHUrLTWriLe3twoLC7O8tpdWXJSK9uWXXypArVq1ynKeq9JnDQaD8vb2LrVvs2bNUoBas2aNUkqpTz75RAHqwIEDVuWaNGmiOnbsWGpbmzZtUpqmqVdeeaXUckop9eijj6qqVauqpKQkq+ODBg1S3t7eljS1olTd4OBgZTQaLeUefvhhpWma6tatm1X91q1bq9q1a1sdAxSg9uzZYzl2+vRp5eLioh588MFy92nOnDkKUCtWrLCUycrKUvXq1bNKKzYajapy5crKYDCovLw8S9lPP/1UATbTERcsWGA5Nnz4cAWo119/3ao/YWFhqlmzZpbXK1euVICaM2eO5VhhYaHq2LGjVZupqallTum8FaKiohSgZs+eXWo5Ly8vFR4ebnndvn17Baj58+eXKHt1Wu7ixYuVTqdTmzdvtio3f/58BaitW7dajgHKyclJnThxwnJs//79ClBz5861HLOXthoXF6ccHBzUm2++aXX8wIEDSq/XW46X57koi2ulFWdkZCgfHx/1+OOPWx2Pj49X3t7eVsevTg9VSqnly5crQG3atMlyrOjz8nrTiu19bN++XSml1Pvvv68A9d1335WrfaWuL624Ro0aql+/fiWOX29a8YwZM9TBgwcVYHn2PvzwQ+Xh4aGysrKsvpYXN2bMGFWzZk1LGvVvv/2mALVv3z6rckXfU9atW6cSExPV2bNn1VdffaV8fX2Vq6urOnfuXJnvXSmlkpOTVeXKldW9995r8zrl+d5VpEuXLqpx48bl6ocQQghxLTJzUAghxD+ah4eHzZ0f7RkyZMg1Zw9mZGTg6elZajtF59PT0wHzzCi9Xm+1c+XBgwc5fPiwzZlWRRISEhg8eDCBgYE2Z9AVp5Ri5cqVPPDAAyilrGYORUZGkpaWxh9//GFVZ9iwYVazelq2bGnZsKC4li1bcvbsWcsMpCKtW7emWbNmlte1atWid+/e/PrrrxQWFparTz/99BNVq1alf//+lvbc3Nx44oknrK65Z88eEhISGD16NE5OTpbjI0aMKNemB6NHj7Z6fe+991ql/v3yyy84Ojry+OOPW47pdDqeeeYZq3qurq44OTmxceNGUlNTy3z9m6XoeS/LM1r0fBZxdnZm5MiR17zGN998Q+PGjWnUqJHVe1qUfrlhwwar8p07d6Zu3bqW16GhoXh5eZUp1XLVqlWYTCYGDBhgdS1/f3/q169vudaNei7Kau3atVy6dImHH37Yql8ODg60bNnSagxcXV0t/87NzSUpKYlWrVoBlPic/DueeOIJ1q5dW+KjSZMmwJWvR9d6Nm6U5ORkKlSocEPbDAoKIjQ0lOXLlwPmdOHevXvb3SikoKCAr7/+moEDB1rSqDt27EjlypXtzh7s3LkzlSpVombNmgwaNAgPDw++++47qlevXuZ+mkwmhgwZwqVLl5g7d24579L+964KFSrY3eVZCCGEuF6yW7EQQoh/tMzMTCpXrlzm8g4ODkyePJnhw4cTFRXFgw8+WKKMp6fnNX85uzpA4+fnR6dOnVixYgXTpk0DzCnFer2evn372mwjKyuLnj17kpGRwZYtW0qsRXi1xMRELl26xKeffmqVHltcQkKC1etatWpZvS4KotSsWbPEcZPJRFpamlVqXf369Utco0GDBmRnZ5OYmIhOpytzn06fPk29evVKrIN29Y66p0+ftnltR0dH6tSpY/MaV3NxcbGkrBapUKGCVXDv9OnTVK1atUTQoV69elavnZ2deeeddxg/fjxVqlShVatW9OzZk2HDhuHv72+3Dzk5OaSlpZWpv1dzdXW1G/AqeuauFRTPyMgo8blRvXp1q8CaPcePH+fIkSMlxrDItZ4zKDnepV1LKWXzWQMswe0b8VyUx/Hjx4Er69FdrXhKd0pKCq+99hpfffVVibG53mfAlvr165e6o3lRn8rzB5O/y94fWa7F1nqIRQYPHsx7773Hf/7zH7Zt22ZJx7blt99+IzExkRYtWnDixAnL8Q4dOrB8+XLeeecddDrr+RIffvghDRo0QK/XU6VKFRo2bFiizLU8++yz/PLLLyxatIimTZuWqy7Y/96llCp1bIQQQojrIcFBIYQQ/1jnzp0jLS2tRDDnWoYMGcK0adN4/fXX6dOnT4nzjRs3Jjo6mjNnztgMeoB5AwLAMmMHYNCgQYwcOZLo6GgMBgMrVqygU6dONteiMhqN9O3blz///JNff/2V4ODga/bbZDIB8Mgjj9hcFw/MM7aKs7fumL3j5f1F/3r6dCvc6PXWxo4dywMPPEBUVBS//vorr7zyCm+//Ta///47YWFhNut8/fXXZZqlZ8vw4cOtNkQprnHjxsCVZ9CW06dPk56ebvV8gvUMt9KYTCZCQkKYNWuWzfNXB5f/zvNkMpnQNI2ff/7ZZjvXCprfLEXP9uLFi20GgfX6Kz9mDxgwgG3btvHCCy9gMBjw8PDAZDLRtWtXSzu3QqNGjQA4cOCAza9tN5qvr6/NALCLiwtgDpDbkp2dbSljy8MPP8xLL73E448/jq+vL126dLFbtmh24IABA2ye/9///ldibc0WLVoQERFht81ree211/joo4+YPn26Zf3A8ijte1dqamq51i8UQgghykKCg0IIIf6xFi9eDEBkZGS56hXNHhwxYoTNXSF79uzJ8uXLWbRoEZMnTy5xPj09ndWrV9OoUSOrX+769OnDk08+aUktPnbsGC+99FKJ+iaTiWHDhrF+/XpWrFhh2cH0WipVqoSnpyeFhYWlzh66kYpmTxV37Ngx3NzcLLPKytqn2rVrc/DgwRIzY2JiYkqUK7p28Vlb+fn5xMbGXtcsHXv92bBhA9nZ2VazB4vPPiqubt26jB8/nvHjx3P8+HEMBgPvvfee3d2yIyMjWbt27XX1rVq1anbPNWjQgAYNGhAVFcX7779vM4V00aJFgPlZvh5169Zl//79dOrU6YbNYrLXTt26dVFKERgYSIMGDezWv1XPRfF+AVSuXLnUZzs1NZX169fz2muvMWXKFMtxW587N1vbtm2pUKECy5cvZ9KkSTd9U5JGjRrZ3OG36L2KiYkpEUjOzs7m7NmzpQb8atWqxT333MPGjRt56qmnrAKxxWVlZbF69WoGDhxotVxBkeeee46lS5fa3Xjnenz44YdMnTqVsWPHMnHixOtqo7TvXTfjWRZCCCFkzUEhhBD/SL///jvTpk0jMDCQIUOGlLv+I488Qr169XjttddKnOvfvz9NmjRh+vTp7Nmzx+qcyWTiqaeeIjU1lVdffdXqnI+PD5GRkaxYsYKvvvoKJycnm7N3nn32Wb7++ms++ugjuynHtjg4ONCvXz9WrlxptVtwkcTExDK3VVbbt2+3WjPt7NmzrF69mi5duuDg4FCuPnXv3p0LFy7w7bffWo5lZ2eXSEeOiIigUqVKzJ8/H6PRaDm+cOFCq51r/67IyEjy8/P573//azlmMpn48MMPrcplZ2eTm5trdaxu3bp4enqSl5dnt/2qVavSuXPn6/q4esbf1aZMmUJqaiqjR4+msLDQ6tzevXt55513CA4Opl+/fmUdDisDBgzg/PnzVmNTJCcnh6ysrHK36e7uDlDiPezbty8ODg689tprJWYaKqUsOx7fqueiSGRkJF5eXrz11lvk5+eXOF/0bBcF4K7uu63dw282Nzc3Jk6cyJEjR5g4caLNmZtLlixh165dN+R6rVu35uDBgyU+Dzp16oSTkxMff/xxiZmTn376KQUFBXTr1q3Utt944w1effVVnn32WbtlvvvuO7KysnjmmWfo379/iY+ePXuycuXKUj9Py+Prr7/mueeeY8iQIXZn1V5Lad+70tLSOHnyJG3atLkR3RVCCCEsZOagEEKIu97PP//M0aNHKSgo4OLFi/z++++sXbuW2rVrs2bNmlLT0+xxcHDg5Zdftpn26eTkxLfffkunTp1o27YtI0eOJCIigkuXLrFs2TL++OMPxo8fz6BBg0rUHThwII888ggfffQRkZGR+Pj4WJ2fM2cOH330Ea1bt8bNza3ErLMHH3zQEkSxZfr06WzYsIGWLVvy+OOP06RJE1JSUvjjjz9Yt24dKSkp5R6L0gQHBxMZGclzzz2Hs7MzH330EYBVULWsfXr88ceZN28ew4YNY+/evVStWpXFixeXWPPP0dGRN954gyeffJKOHTsycOBAYmNjWbBgwQ1dW65Pnz60aNGC8ePHc+LECRo1asSaNWss/S2a6Xbs2DE6derEgAEDaNKkCXq9nu+++46LFy/afAZuhSFDhrB7927ef/99Dh8+zJAhQ6hQoQJ//PEHX3zxBb6+vnz77bdWm9GUx9ChQ1mxYgWjR49mw4YN3HPPPRQWFnL06FFWrFjBr7/+Wu60zKKNbV5++WUGDRqEo6MjDzzwAHXr1uWNN97gpZdeIi4ujj59+uDp6UlsbCzfffcdTzzxBBMmTLgpz0ViYiJvvPFGieNFgZuPP/6YoUOHEh4ezqBBg6hUqRJnzpzhxx9/5J577mHevHl4eXnRrl073n33XfLz86levTq//fabzRl1f9cff/xhc6Zq3bp1ad26NQAvvPAChw4d4r333mPDhg30798ff39/4uPjiYqKYteuXWzbtu2G9Kd3795MmzaN//3vf1YzAStXrsyUKVOYPHky7dq1o1evXri5ubFt2zaWL19Oly5deOCBB0ptu3379tecVb106VJ8fX3tBtN69erFf//7X3788cdy/SHGll27djFs2DB8fX3p1KlTic1O2rRpU+I5LO/3rnXr1qGUonfv3n+rr0IIIUQJt3p7ZCGEEOJGWbBggQIsH05OTsrf31/df//96v3331fp6ekl6rz66qsKUImJiZZjw4cPV+7u7iXK5ufnq7p16ypAPfPMMyXOJyQkqHHjxql69eopZ2dn5ePjozp37qzWrFljt8/p6enK1dVVAWrJkiUlzg8fPtzqnq7+iI2Nvea4XLx4UT3zzDOqZs2aytHRUfn7+6tOnTqpTz/91FJmw4YNClDffPONVd2iMd29e7fVcVvjVjQuS5YsUfXr11fOzs4qLCxMbdiw4br6pJRSp0+fVr169VJubm7Kz89PPf/88+qXX35RQIl2P/roIxUYGKicnZ1VRESE2rRpk2rfvr1q3769pUxsbKwC1IIFC6zG2Nb7XXSPxSUmJqrBgwcrT09P5e3trUaMGKG2bt2qAPXVV18ppZRKSkpSzzzzjGrUqJFyd3dX3t7eqmXLlmrFihUlrnGrRUVFqfvvv19VqFBBOTs7q3r16qnx48dbvY9F2rdvr4KCgmy2c/W4KqWU0WhU77zzjgoKClLOzs6qQoUKqlmzZuq1115TaWlplnL2Pn9q166thg8fbnVs2rRpqnr16kqn05V43leuXKnatm2r3N3dlbu7u2rUqJF65plnVExMjFUbZXkuyqJ9+/Z2Pw87depkKbdhwwYVGRmpvL29lYuLi6pbt64aMWKE2rNnj6XMuXPn1IMPPqh8fHyUt7e3euihh9SFCxcUoF599VWrtmx9Xl5L0XNu7+PqcVZKqW+//VZ16dJFVaxYUen1elW1alU1cOBAtXHjRpvXmDFjRpm/BhUXGhqqHn30UZvnlixZolq1aqXc3d2Vs7OzatSokXrttddUbm6uzfubMWNGqdcq/rl98eJFpdfr1dChQ+2Wz87OVm5uburBBx9UStn/+lcWV38/uvqj+Neg6/nepZRSAwcOVG3bti1334QQQohr0ZS6zi3EhBBCCCH+hYp2sd6yZQv33HPP7e6OEHe0xYsX88wzz3DmzJkSM6VF2cXHxxMYGMhXX30lMweFEELccLLmoBBCCCGEHVfvplpYWMjcuXPx8vIiPDz8NvVKiLvHkCFDqFWrVom1OkX5zJkzh5CQEAkMCiGEuClk5qAQQgghhB2PPfYYOTk5tG7dmry8PFatWsW2bdt46623bO40Le58iYmJJTZpKc7JyYmKFSvewh7ZZzQar7lOqLe3N66urreoR0IIIYT4J5LgoBBCCCGEHcuWLeO9997jxIkT5ObmUq9ePZ566inGjBlzu7smrlNAQACnT5+2e759+/Zs3Ljx1nWoFBs3bqRDhw6lllmwYAEjRoy4NR0SQgghxD+SBAeFEEIIIcS/xtatW0ukixdXoUIFy87Jt1tqaip79+4ttUxQUBBVq1a9RT0SQgghxD+RBAeFEEIIIYQQQgghhPiXkg1JhBBCCCGEEEIIIYT4l9Lf7g5czWQyceHCBTw9PdE07XZ3RwghhBBCCCGEEEKIu4pSioyMDKpVq4ZOV/rcwDsuOHjhwgVq1qx5u7shhBBCCCGEEEIIIcRd7ezZs9SoUaPUMndccNDT0xMwd97Ly+s290YIIYQQQgghhBBCiLtLeno6NWvWtMTZSnPHBQeLUom9vLwkOCiEEEIIIYQQQgghxHUqy5J9siGJEEIIIYQQQgghhBD/UuUODm7atIkHHniAatWqoWkaUVFRdsuOHj0aTdOYM2fO3+iiEEIIIYQQQgghhBDiZih3WnFWVhZNmzZl1KhR9O3b12657777jh07dlCtWrW/1UEhhBBCCCGEEHc3pRQFBQUUFhbe7q4IIcQ/jqOjIw4ODtddv9zBwW7dutGtW7dSy5w/f55nn32WX3/9lR49elx354QQQgghhBBC3N2MRiN//fUX2dnZt7srQgjxj6RpGjVq1MDDw+O66t/wDUlMJhNDhw7lhRdeICgo6EY3L4QQQgghhBDiLmEymYiNjcXBwYFq1arh5ORUpsXxhRBClI1SisTERM6dO0f9+vWvawbhDQ8OvvPOO+j1ep577rkylc/LyyMvL8/yOj09/UZ3SQghhBBCCCHEbWA0GjGZTNSsWRM3N7fb3R0hhPhHqlSpEnFxceTn519XcPCG7la8d+9e3n//fRYuXFjmvwa9/fbbeHt7Wz5q1qx5I7skhBBCCCGEEOI20+lu6K+eQgghivm7M7Jv6MzBzZs3k5CQQK1atSzHCgsLGT9+PHPmzCEuLq5EnZdeeolx48ZZXqenp0uAUAghhBBCCCH+pWKTssjKK7B73t1ZT6Cf+y3skRBC/LPd0ODg0KFD6dy5s9WxyMhIhg4dysiRI23WcXZ2xtnZ+UZ2QwghhBBCCCHEXSg2KYsOMzdes9yGCffd0gBhdHQ0R48eZdCgQTe87REjRmAwGBg7duwNb7s8oqKi8Pf3p1WrVre1HzfD1KlTuXTpEnPmzLnuemvWrGHDhg3Mnj37uvsRFxfHL7/8wujRoy3HAgICiIqKwmAwXHe75XXw4EF69uxJXFwcFy5cYODAgWzevPmGXqN79+7Mnj2bhg0bXlf9hQsX0qpVKxo1anRD+yVsK3dwMDMzkxMnTlhex8bGEh0dTcWKFalVqxa+vr5W5R0dHfH397/uB0IIIYQQQgghxL9DaTMGr6fcjRIdHU1UVNR1BQcLCgrQ62/4cv83XFGA6nqCg4WFhde1ztndpFevXvTq1etvtREXF8f8+fOtgoO3W7Vq1W5oYNBkMgHw008//a12Fi5ciI+PjwQHb5FyL/ywZ88ewsLCCAsLA2DcuHGEhYUxZcqUG945IYQQQgghhBDiZhgyZAgRERGEhobSo0cP4uPjSUxMpEuXLoSEhBAaGsrIkSNJSEhgypQpbNiwAYPBYAns7N69m44dOxIREUFYWBjffPMNYA4A+fj4MHHiRMLDw5k3bx7r16+ndevWhIWFERQUxOeff26zT/n5+bz44ou0aNECg8HAgAEDSE1NBeCzzz6jSZMmGAwGQkJC2Llzp917i4+Pp0OHDjRr1oygoCDGjBljCdrs2LGDZs2aYTAYCA4O5uOPP+ann35izZo1zJgxA4PBwGeffQbA4sWLadmyJeHh4bRr1479+/cD5sBNhw4d6NevHyEhIezatYtZs2bRvHlzDAYDzZs3Z/v27Zb+HDlyhMjISEJDQwkNDWX+/PmWfg4YMIAWLVoQEhLC5MmTLXUmTJhgaa9du3bExMRYztkb+9L89ddfPPDAAzRp0oSOHTuSkpJiOTdz5kxatGhBeHg4Xbt25fTp0yXqL1y4kD59+lxzfBcuXEjnzp15+OGHCQkJISIiglOnTgEwevRoYmJiMBgMVoHGVatW0bp1awIDA3njjTcsx++77z6ioqIsr/v378/ChQuB8j0PYJ4FWb9+fZo1a8ZXX31lOV70vAK8+eabjBkzxnIuMzOTihUrkpiYyIEDB2jbti3h4eE0adLEqp9Tp06lX79+REZGEhwczF9//UVAQADR0dEAnD9/nv79+1s+r1555RUAli1bRsuWLQkLC6Np06Z8//33lnvbs2cP//nPfzAYDPz0009W4w/www8/cN999wFw/Phx7rnnHpo2bVriORJlpO4waWlpClBpaWm3uytCCCGEEEIIIf6GnJwcdfjwYZWTk1Om8gfOXVK1J/5wzY8D5y797b4lJCRY/v3222+rJ598Us2aNUs98cQTluPJyclKKaUWLFigevfubTmempqqDAaDunDhglJKqcTERFWzZk117tw5FRsbqwD15ZdfWsqnpKSogoICS5u1atVSZ8+eVUopNXz4cDV79myllFJvvvmmev311y31Xn/9dfX0008rpZTy8vKyXM9oNKqMjAy795aTk2M5X1BQoHr06KGWL1+ulFKqV69eatmyZVZ9u7ofSim1ZcsW1a1bN5Wbm6uUUmrTpk2qSZMmlvFwdXVVR48etTme27dvVw0bNlRKKZWfn6/q169vdc3ExESllFJdunRRGzdutJSLjIxUK1asKNHe8uXLVWRkpFKq9LG359VXX1W1a9dWSUlJSimlBg4cqN566y2llFJLly5Vjz32mOX9WbRokerevbul3vPPP2+556JnoLTxXbBggfLy8lKnTp1SSik1ceJEyzO1YcMG1bRpU6u+1a5dWz377LOWe/Hy8rLcS/v27dV3331nKduvXz+1YMECpVT5nocffvhBNWnSRKWlpSmTyaSGDBmiateurZRSKjY2Vnl7eyullDpz5oyqVKmS5T3/4osvVN++fZVSSqWnp1uOZ2dnK4PBoLZv324Zp6pVq6r4+Hir+9q3b59SSqn77rvPMt5KXXlvk5KSlMlksvSjSpUqlmtcfe9Xfw5+//33qn379koppZ577jmr9os+b/9NbH2tLU987c6f2yyEEEIIIYQQQtxgy5YtY/HixeTm5pKbm4ufnx/Dhw9n9uzZjB8/nnbt2tG1a1ebdbdt28apU6fo1q2b1fGYmBjq1KmDo6MjjzzyiOV4cnIyjz76KMeOHUOv15OcnMzBgwepUaOGVf2oqCjS0tJYuXIlAEajkYCAAAA6derE0KFDeeCBB+jWrRsNGjSwe28mk4mJEyeyZcsWlFIkJCQQHBzMoEGD6NChA9OmTeP48eN07NiRtm3b2mxj9erV7N+/n5YtW1qOpaSkkJOTA0CbNm2slg/bt28fb775JsnJyej1emJiYsjJyeHUqVPk5uby8MMPW8r6+fmRlZXF+vXruXjxouV4ZmamZYbg2rVrmTt3LhkZGZhMJstMv9LGvnr16nbHpGvXrpZl0Fq3bs2BAwcsY757926aNWsGmFOkr6W08S1qPzAw0PLvuXPnltre4MGDLeNSp04dYmNjS70XKN/zsH79egYMGICXlxcATz75JFu2bClRrmbNmoSFhbFmzRoeeughFi5cyAsvvABATk4OTz/9NNHR0eh0Os6ePUt0dLQlDb179+5UqVKlRJuZmZls2bKFX3/91XKsUqVKgHmZuiFDhnDu3Dn0ej0pKSnExsaWO5W4Xbt2vPDCC2RmZtK+ffsSe2GIa5PgoBBCCCGEEEKIf5UtW7bwwQcfsH37dipXrsyaNWuYMmUKrVu3Jjo6mnXr1rFq1SpeeeUV9u3bV6K+UoqgoCC2bdtW4lxcXBxubm7odFdW8Ro9ejTdu3dn5cqVaJpGeHg4ubm5NtudO3cuXbp0KXFu5cqV7N27l40bN9K9e3feeOMNu2sgzpo1i4SEBHbu3ImLiwvjxo2zXG/s2LH07t2bdevWMWnSJIKDg/noo49s9mX48OG89dZbNq/h4eFh+bfRaKRv375s2LCB5s2bk56ejre3N3l5eTbrFrUP5jRnFxcXq3NnzpxhzJgx7N69m7p16/Lnn3/Srl07Sz17Y1+a4tdwcHCgoKDA0t5LL73EE088Uea2Shvf0q5V3r7p9XqrYGXxa5Tnebiapml2z40aNYoFCxbQrFkzTpw4YQmQT5o0CT8/P/bt24der6dv375W/Sn+PJTVoEGDmD59Ov379wegYsWKNj8voPSx6NevH23atGHt2rXMmzePOXPm/O01D/9tyr3moBBCCCGEEEIIcTdLTU3F09MTX19fjEYjn3zyCWCeyeTh4cGAAQOYO3cux44dIzMzEy8vL9LS0iz127RpQ2xsLOvWrbMci46Oxmg02r1e7dq10TSNTZs2Wdbuu1qfPn2YPXs22dnZAGRnZ3Po0CEKCgo4efIkERERTJgwgf79+7Nr165S78/f3x8XFxfi4+Ot1uSLiYkhMDCQxx9/nEmTJrFjxw6AEvfYq1cvlixZwpkzZwDzbLk9e/bYvF5ubi5Go5FatWoBWM2Ua9iwIW5ubixfvtxyLCkpCQ8PDzp06MD06dMtxy9cuMC5c+dIS0vD0dGRqlWropRi3rx5ljLlHftr6dOnD/Pnz7fMTMzPz7cZEC6utPEtzdVjfC316tWzrCUYGxtrme1X3uehc+fOfPPNN2RkZKCU4tNPP7Vbtk+fPuzevZu3336bRx55xLKZTmpqKjVq1LDMCl27dm2Z7sHDw4N27drx3nvvWY4lJiZa2iyaYblkyRLL+ppQcqzq1avHn3/+SU5ODgUFBSxbtsxy7vjx41SpUoVhw4bx7rvvWp5pUXYSHBRCCCGEEEII8a/StWtXGjZsSMOGDbn33nsxGAwAbNy40bJZR5s2bZgxYwbe3t506tSJvLw8QkNDGT16NBUqVODHH3/krbfeomnTpjRp0oQXX3zRsinF1aZPn86LL76IwWDgiy++sErVLW7ixIk0b96cli1bEhoaSqtWrYiOjqawsJBRo0YRHByMwWBg7969jBs3zu79Pf/88+zcuZOgoCCGDh1qlWY5b948goKCCAsLY/LkyZagzdChQ1mxYgVhYWF89tln3Hvvvbz77rs8+OCDNG3alKCgIKuNLIrz8vLijTfeoEWLFjRr1gwnJyfLOb1ez+rVq1mwYAEhISE0bdrUkja9dOlSTpw4QXBwMCEhIfTt25fk5GRCQkIYNGgQQUFBNG/e3BJ0BMo99tcyZMgQRowYQYcOHWjatCkGg4Hff/+91DqljW9pQkNDCQoKIjg4uEw7H//f//0fGzZsICQkhJdeesny3JT3eejevTv9+/cnPDyciIgIq/G8mrOzMwMGDOCzzz5j5MiRluOTJ09mwYIFhIaG8uKLL9KxY8cy3TOYN7bZs2cPQUFBGAwGS7D3/fffp3///oSFhbFv3z6rfj3xxBO89dZblg1JWrVqRffu3QkODua+++6jfv36lrLffvstISEhhIWFMXDgQMuGN6LsNFU0l/cOUTT9OC0tzZIPL4QQQgghhBDi7pObm0tsbCyBgYElUkdtiU3KosPMjdcst2HCfQT6ud+AHgohxN3P1tfa8sTXZM1BIYQQQgghhBB3hEA/dzZMuI+sPPtrtLk76yUwKIQQN5AEB4UQQgghhBBC3DEk8Fd2ERERJTa7CAoKYunSpbepR7dPdHQ0I0aMKHF8+PDh/Oc//7n1HboN5HkQ10uCg0IIIYQQQgghxF3I3gYh/0YGg4Ho6Ojb3Y3bSp4Hcb1kQxIhhBDiLlVgLGTPz3EUGAtvd1eEEEIIIYQQdykJDgohhBB3mKKgX2ZqDqvf30dmag57fo4jN9NoCQYWGAtZt/AwO1ef4tjuixIkFEIIIYQQQlwXSSsWQgghbpECYyHR689i6FQTvZOD3TK/fXGI2OgkTv+ZyJHTacR9FE3G+SzSLmZzdEc87l5OKODkH4kAHPzfORLPZOJZ0YWGLf3LfK2/0/cCYyF//HYagPAuta95jRvdHyGEEEIIIcSNIcFBIYQQ4hY5uS+RnatPlRrEO7b7IrHRSQAcOZ3GZ155kJEHXsCeC1RAx7bvTlBgNFnaTTyTSarOxKqoGBqeSqFrj3rEHUhi5+pTuHk50eSealb9KC1QZ+tc0SzFk38kWvp+cl8iu3+IA8C7kpvlfspz70IIIYQQQojbT4KDQgghxC1yYu9FAE7+kWAJkBUFzS6eSsPZ3ZFju+It5Y2adX2jMv83N9N6F7pUnckcRFR5sD+T7HQjecczAPhzw7kSwcGrA3XFA4K2gngn9yVaZikW9b3oXq6+n/Lc+9VkdqEQQggAkk9CXob9886e4Fv31vVHCCH+4SQ4KIQQQtwk2elG9q8/Q2GhOap35lAKAKcPJrPl2+MAnNpnDrrFHUi21EvVmTBqkKwzWbVX9NpJQQXTlWWDrw4iHvsziSqF5vPJ5zLZ9HUMOgcdGqDT60g6Z/6Fa+/PcdQNq2QJCCadzSD/8rqFx3bGk3Ihk8JCRWx0oqXt2P1JfPHCZnIy8i3H4v5MYsVbu9A0jSqB3kR0DwCw3LsqVJy+fH/F793BQSO4XXVidl3E0Kkmx3ZftDvbUQghxL9E8kmYG37tcs/+cUsDhNHR0Rw9epRBgwbd8LZHjBiBwWBg7NixN7zt8oiKisLf359WrVrd1n7cKTRNIzU1FR8fH7p3787s2bNp2LBhiXL9+/enZ8+ejBgx4tZ30oaFCxcSFRVFVFQUcXFx/PLLL4wePdpyvrR7Kc2ePXuYMWMGX3/99Y3usrgDSHBQCCGEuEmy0vLYv/4shQUKNPMPmQCmQsX+dWdt1rHMArThR/crAbnH0p0ByhREPLDhvO1rxWfzw4f7STxjDhae/CORy13kzOEUzhxOsVmveGAQQClzajNA0rlMGt9TFeDKvV9Vdv/6s6DAQa/h6Kxn5xrzTMUDG88B5jUUGzSvIrMIhRDi36i0GYPXU+4GiY6OJioq6rqCgwUFBej1d/6v3lFRURgMhusKDhYWFuLg8M/9fv3TTz/d7i5cl7i4OObPn28VHLzee4mIiJDA4D+Y7FYshBBC3CSVanry0KTm+Pi7oQHKpEqU0a5OHdZKFLEp6XIQcZFnnlXQEMxBxEWeeXzmlUfqVYHDq52PuYQx58oux6pkF8vMy8+FAS83p1JNT6t7L06ZFCjw8XfjgecMHN3+FwC7vj9F0llzgDHxTCY/f3KAnatP8et/D5KenGNzN+aiXZ1ll2YhhBDXY8iQIURERBAaGkqPHj2Ij48nMTGRLl26EBISQmhoKCNHjiQhIYEpU6awYcMGDAaDJdCye/duOnbsSEREBGFhYXzzzTeAOSDj4+PDxIkTCQ8PZ968eaxfv57WrVsTFhZGUFAQn3/+uc0+5efn8+KLL9KiRQsMBgMDBgwgNTUVgM8++4wmTZpgMBgICQlh586ddu8tPj6eDh060KxZM4KCghgzZgwmk/lngh07dtCsWTMMBgPBwcF8/PHH/PTTT6xZs4YZM2ZgMBj47LPPAFi8eDEtW7YkPDycdu3asX//fsA8O61Dhw7069ePkJAQdu3axaxZs2jevDkGg4HmzZuzfft2S3+OHDlCZGQkoaGhhIaGMn/+fEs/BwwYQIsWLQgJCWHy5MmWOhMmTLC0165dO2JiYizn7I29Pd9//z2hoaGWe169ejUAJ06coHPnzpZzUVFRNusHBAQQHR0NwNGjR2nTpg1BQUH06dOH9PR0S7lly5bRsmVLwsLCaNq0Kd9//73l3NGjR2ndujVBQUH07duXLl26sHDhQgASEhLo27cvISEhBAcH88knn5R6P6W9v8WNHj2amJgYDAYDvXr1KnEvb7zxBo0bN8ZgMGAwGDh9+jQ5OTkMHDiQJk2a0LRpU7p06QLAxo0bMRgMwJVn/JVXXiE8PJz69euzdetW/vOf/1jG+ODBg+Xqq7i97vw/XwghhBB3Md9qHvR7oRmfT9hc8qRWMhjn9DeCc7aUNdj4t2nw0EvNcXF3tEqnrt6wApfis0sU1+t1/LH2DGmJOQCkJ+VanS9KwY47kEzFauf549czJTYzkU1OhBBC/B1z5syhUqVKAEyfPp2pU6fSsGFDAgMD+e233wBISUmhYsWKvP7665ZUTYBLly7xxBNP8NNPP1G1alWSkpIIDw+nTZs2AKSlpREUFMQ777wDQGpqKlu2bMHBwYGUlBTCwsKIjIykRo0aVn2aMWMG7u7u7Nq1C4Bp06YxefJkPvzwQ8aPH8/Ro0epWrUq+fn55OXZzjQA8PHx4fvvv8fDw4PCwkJ69+7NihUrGDRoEG+//TYTJkzg4YcftvStQoUK9OrVyyq9eevWrSxfvpxNmzbh7OzM5s2bGTx4MIcOHQJg586d7Nu3z5KeWq9ePcaNGweYA5AjRozg6NGjFBQU0Lt3b1577TXLNZOSzJuvDR8+nEmTJtG+fXsKCgro2bMn33zzDQ899BATJ05k5syZAHz11Vc8//zz/PLLL6WOffXq1W2Ox+TJk/nkk09o3bo1JpPJEtAbMmQIo0aN4sknn+T48eO0atWKsLAwateubXdshw4dyujRo3n00Uc5cOAAERERDB48GIDIyEgefvhhNE0jLi6OVq1acfr0aZydnRk6dChPP/00I0eO5MiRI4SFhVnqPfvsszRs2JBVq1aRkJBAs2bNaNq0qd1ZnKW9v8XNnz+fsWPHWoKBxaWmpjJz5kz++usvXF1dyc7ORqfT8fPPP3Pp0iUOHz4MmD8HbElLS6NZs2ZMmzaNzz//nMjISL7//ntmz57NjBkzeO211/jmm2/K3Fdxe0lwUAghhLjJLhy/BLaCfjaOVTDpeCzd2ZIuXHxWYI8sR3xNunIFEG90sNEuBeeOplCvWRXrdGo7ks5lwrnMMjUds9O8Scvmr49RtZ43Xr6uQNk2ORFCCCHsWbZsGYsXLyY3N5fc3Fz8/PwYPnw4s2fPZvz48bRr146uXbvarLtt2zZOnTpFt27drI7HxMRQp04dHB0deeSRRyzHk5OTefTRRzl27Bh6vZ7k5GQOHjxYIjgYFRVFWloaK1euBMBoNBIQEABAp06dGDp0KA888ADdunWjQYMGdu/NZDIxceJEtmzZglKKhIQEgoODGTRoEB06dGDatGkcP36cjh070rZtW5ttrF69mv3799OyZUvLsZSUFHJyzH/Ya9OmjdW6dfv27ePNN98kOTkZvV5PTEwMOTk5nDp1itzcXEtgEMDPz4+srCzWr1/PxYtXNjnLzMy0zBBcu3Ytc+fOJSMjA5PJZAlSlTb29oKDnTp14vnnn6d///506dIFg8FARkYGf/zxB1u3bgWgfv36tG3bls2bN9sNDqanpxMdHW1ZXzAkJMRq/GJjYxkyZAjnzp1Dr9eTkpJCbGws1apVIzo6mmHDhgHQuHFjq3rr1q1j7969AFSuXJm+ffuybt06u8HB0t7fsvLy8qJ+/fo88sgjdOnShR49elCjRg2aNm3KkSNHePrpp2nfvj3du3e3Wd/FxYU+ffoA5pRjDw8POnToAECLFi1YunTpDeuruPkkOCiEEELcZEWbjlSt602bfvXYuvIE8SfT7JYvvtlIcb4mnWWjEaBMQURbbSkKyXY/j1tWdTRu3PpAW745QbX6FSwpxT9+9CcZV80ILKLpQJUxoyTrkhGAvOwCVs3Yi5uXE5qmmQOMlNzkpGmnWrh5OQFXdkBu1KoK6xcdJfLRIFw8nP7mnQohhLjbbdmyhQ8++IDt27dTuXJl1qxZw5QpU2jdujXR0dGsW7eOVatW8corr7Bv374S9ZVSBAUFsW3bthLn4uLicHNzQ6e78j149OjRdO/enZUrV6JpGuHh4eTmlvweqZRi7ty5llTO4lauXMnevXvZuHEj3bt354033rAbYJk1axYJCQns3LkTFxcXxo0bZ7ne2LFj6d27N+vWrWPSpEkEBwfz0Ucf2ezL8OHDeeutt2xew8PDw/Jvo9FI37592bBhA82bNyc9PR1vb+9SZzeqy+kTO3bswMXFxercmTNnGDNmDLt376Zu3br8+eeftGvXzlLP3tjbM2vWLA4dOsSGDRsYPnw4Q4YM4amnnipRTrt6vZcyKF5n0KBBTJ8+nf79+wNQsWJFm+/zta51rX6U9v6WlYODAzt27GDbtm1s3LiRVq1asXz5cu69914OHz7M77//zrp16/i///s/mzMPnZ2drdoq/h46ODhQUFBww/oqbj5Zc1AIIYS4ySrV9qT1g3XpMz4c/zrePDg+HL+a5h+oq9b1pt//NUPvbP6WrHfSUbW+N3oHU4lZf1e/rnA5WOh7VQCwKIhoL8iY55JEtmcceS5Jdvvs7KonVWfiooPJ7rqF3g4X8NOfxNvhAgBZl/JISzKvD+jt50qD5lVsN66VPTB4taxLRhLPZJJwOsOyhmPRJif7151l//qzZKVd+UWkKPV43cIjnDuSyo41sRQYC9m+5hhLP4li+5pjsmahEEL8C6WmpuLp6Ymvry9Go9GyxltsbCweHh4MGDCAuXPncuzYMTIzM/Hy8iIt7cof9tq0aUNsbCzr1q2zHIuOjsZoNNq9Xu3atdE0jU2bNlnW7rtanz59mD17NtnZ5iU5srOzOXToEAUFBZw8eZKIiAgmTJhA//79LanH9q7n7++Pi4sL8fHxVmvyxcTEEBgYyOOPP86kSZPYsWMHQIl77NWrF0uWLOHMmTOAeQbYnj17bF4vNzcXo9FIrVq1AJg7d67lXMOGDXFzc2P58uWWY0lJSZaZZtOnT7ccv3DhAufOnSMtLQ1HR0eqVq2KUop58+ZZypR37MG83l/RendPPfUUO3bswNPTk/DwcBYsWACY1x/csmWLJQhpi5eXF2FhYSxatAiAQ4cOsWXLFsv51NRUAgMDAViyZIllvUgvLy+aNm3KkiVLAPN7ULxe586d+e9//wtAYmIiq1at4v7777fbj9Le36v7W/w9LS4jI4OLFy9y77338sorr9C2bVv27dvHuXPn0DSNXr16MXPmTJRSnD1reyO9sihrX8XtJTMHhRBCiJusaceaVq91Oo1GratSGGHCcH8tdDqNlg/U4eyRFGo28cXQqSZnRj9N9BkfnghoR66mt5oFmKozYdSu7EZ8rSDi1fJcEi//NwmXXNsBvPg8o9WuyY+lO1sFG70dLvBIpWcsr5ckfkiaqRp7fozlzKEULp5KIyPVzmyBv5nqrF1eq7FovUZlUmgaePu70fWJYHyrXZnJUJR6fP7YJQBioxOoWtebbb/vJcMnhvgjOVSs4iVpyUII8S/TtWtXlixZQsOGDfH19aVz586cP3+ejRs3MmvWLMvMpxkzZuDt7U2nTp2YOXMmoaGhtGnThvnz5/Pjjz8yYcIExo8fT35+PrVq1bK7ocX06dN5+umnmTZtGgaDwSpVt7iJEyeSl5dHy5YtLbPHJk6cSL169Rg1ahQpKSno9XoqVapkCWrZUpRCGxQURLVq1ejcubPl3Lx58/j9999xcnLCwcGB9957DzCvpTdixAiioqJ45plneOyxx3j33Xd58MEHKSgowGg00qNHDyIiIkpcz8vLizfeeIMWLVrg5+dnNaNRr9ezevVqnn32Wd566y10Oh1PP/00Tz75JEuXLmXcuHEEBwejaRru7u588sknNG3alEGDBhEUFISvr68lfRWgQoUK5Rp7gEmTJhETE4OTkxNubm58/PHHACxdupTRo0czb948NE3js88+swQ47Vm0aBEjR47kvffeo379+lbBxPfff5/+/fvj4+NDx44drdpatGgRo0aNYsaMGdSrV4/mzZvj4+MDwAcffMBTTz1FSEgISilefvllu88IlP7+FhcaGkpQUBDBwcHUqVOHNWvWWM6lpaXRv39/srKy0DSN+vXrM3z4cLZt28ZLL72EUoqCggKGDh1KaGgoGzduLHVc/m5fxe2lKfV39iW88YqmH6elpeHl5XW7uyOEEELcEgVJSaR8+SUq35yCkbp0KSo/nwIXLza1egsw/4KQenmX4iJFQbtUnYlu48LY+NlBXC5dmQkX0SOA3b8eJ8vlHGjm6Xo5bhdAU6A0XLOrmQsqHW7Z1dGZzCm3Fx1MLPK8cp1hGc5WKc1++pMM9Jtgef110kySCupa35TG3w4Elsej792LqVCxf/0ZstKMnDmUTE5GfolyOgeNVM8DGF1ScMr1JcClOQMmNUfv5ADJJyEvA5w9wbeujasIIYQoj9zcXGJjYwkMDCyROmpT8kmYG37tcs/+IV+nxV0lMzMTd3d3NE0jNjaW1q1bs3v3bmrWrHntykJcg62vteWJr8nMQSGEEOIOUJCYSMqXi1BGI+g0jE7enKnZnmw3fyzbGmtaid2Hi7/e9UMsORn5uBRbNeTYznh0rgXkuJ27HBAsXluR43b+chBPwyW3EmnowVVPsrHA6jrJl1OLq+gu4KfyqKg/Z3W+6HW+ciWtsCjgeP3j4VnRBU8/Fy5cnvFXFn+duIRHRRebm6GYdEay3c5bAqRG59TL/03hbNYB5kw5hIdrLo+oaXhgXmhdfvEUQojbwLeu+etvXob9MvIHHHEX2rZtGy+88AIAhYWFzJ49WwKD4o4hwUEhhBDiDuDSuDGBK7/l3PNjMcbFkaf34GyNDiidI3A5lVinWYJ0RTyaVuD4n8lEeeRD/EXwtE4BTk/KBVypkBNOus9hCh1yiiYhWmb2ORS44nWpCRkm18uzEvPA0bp/P7rnE6D9xUbn8Tb7f7/PHMu/lyR+eCVAWIyDo44OQxtx4PdzXIxLtzsWDVv503FYY37/8khpQ4abtxM5GUbL+oXbo05SK8iXOmGVOHMohbzsKwFOk85IjnvpAdIsE2RoHleCg6X9YiqEEOLmkcBfmUVERFg2figSFBRk2Sn236T4LsLFDR8+nP/85z+3vkNX6dKli82NZkoj76+4VSQ4KIQQQtwhnOvXJ2D5Mo61ao1n5jma73mHfYbnSHB25zNv24tsf3QqHjysj109uxBAX+COT7KB5MrbS5zzTQ+n87AQfl4fB2n2dxV0p2w7yzlqOTaPD3urDW6eTuj1On759GCJ8xX83UiNNy/ArtNpVKrtCUDMznib7WWnGdF0lyOcGqT+lU3qX9k2y+oLPKiQbD9A6lSgJyg7n6peiVcqJR0z/1dmqAghhLhD2dsg5N/IYDDY3FX3bibvr7hVZLdiIYQQ4g6SvWePZacNj+y/aLXrdYxa+fJzk4vtMqwoJMv9DE4eOqqGOVivA6gADdqOqkqDFv50Htiw1HazKMNaUZhTi23ZuOQo2787wfE95k1CvHxd8PS90mbRrs6VapmDgsU3cina1dm/rjcAji4O5o1JTEW7kly7X0UB0qtpmon/6D+gt9cc6xOrHodP25vXvko+ee0LCCGEEEIIcReSmYNCCCHEHST9t7UAuDYLp8oLL7B/1tc4lfNveT+6X9mEY1ReGibPOKpXrMxfyX8BoM/3wiOjDpmepyhwSud/v+wiK9aFitXdeSzDGSPmAGPxdnpkOeJrCuBD3VzLmoPFU4nXXhpLSkEN6zUHrxK7P4nThzT8anhQtZ43lWt7cWCjea1CTYPM1DxcPZ3QMKcIN+8eQKXanlSs5o7h/lqYCkzUCqpI7aCKaDqNHVGnSlyjyb3VOH8slbSLtmcv5julXQmQXv6v0nScpjqNKNlekYKsNKJ3xWHoVNO8cYkQQgghhBD/EBIcFEIIIe4grkFBuNSvR8WRI9EcHMi4T0+FXQm8UKgR9FBTfvstlmWZaWVur9AlCQ04feEkjkYf3LVAXLNqoKHhk9KUHPdz5Kbr2H/uLI3vqUqFQtuBSF+TzrxbcWENkmycTymoUXK34qvonXS0HdiAzctjKCxQ/HUyjeIZ0BeOX+LCsUtoOg1lUlSs6m41e/D4vkR2rYml88gm6Bxs5E4DhzdfoP3ghvxvWYzN83ku5t4XBUhzPY+S65TLEeqVGhw8c8LIztWn8KzoQsOW/qXepxBCCCGEEHcTCQ4KIYQQd5CKw4Zava4c4I1vdU8M99dCp9OoWNWdZR9utVvfhXyC9PFol/NsNYcru/LqTa4opcjyiMMtuzo6kxNuWTVxctPjWcWZYzsvWtpxuipN18lkfSDfZJ1ibC+VuLjCAhO+Vd15aFJzfvnkAJcu5lzJcDZvxoy3vxtuXo5cOJbGyT8SrAJxRWsP7vr+FAX51huzOLk6YMwptJy3R5/vib7A3RIg1ac0x93jMPG0YW1BkxKzIdNUTTo+3pwjmwCyS/RJCCHEjXc6/TRZ+Vl2z7s7ulPbq/Yt7JEQQvyzSXBQCCGEuIMVnzkH4OlqvY3wmFpViD2awo9u5hRgNy2fYIeLaDZ25c12PXc5lVbDJbcSOpMTAI5OOpLPW/8SVsGk47F0Z4yaOVBYQRWbUagUaabqLEn8EEctp9RUYqsemCDxTAaZqbl4VHDm0lWpv0qBg17jr+PmmZFxB5JY8fZuUApN00g8mwkU7cBsrSgwCJCTkV/ifBG37OpWrzU0tMwgTECK3npdwUzH2vgEteLwUUfOHDKnP58+mMyWb48D4OCg0bRTLdy8nK5570IIIcrmdPppen7X85rlfnjwh1saIIyOjubo0aMMGjTohrc9YsQIDAYDY8eOveFtl0dUVBT+/v60atXqtvbjTqFpGqmpqfj4+NC9e3dmz55Nw4Yl12fu378/PXv2tLlT8u1w4cIFBg4cyObNm2/aNebMmcOgQYPw95c/mP5TSHBQCCGEuIsE+rmzckhzvv/vAfQFCtc/0/F1uBK4S1FuqFQDeq+jNnfldShwxetSE/QF7pY6WZeKdkIuWojPrILpcrtKXa5vAk2Ho8ojX3MhrbAaeicdBUbrWXylOfFHAhdPpVFYYHsHkeRzV4KUSkHi6Ywyt/13XT37MTvHiQs74kEz/4JQ1Kf968+ax1KvUS+iigQHhRDiBiptxuD1lLtRoqOjiYqKuq7gYEFBAXr9nf+rd1RUFAaD4bqCg4WFhTg4/HPX5P3pp59udxfKrFq1ajc1MAjm4OB9990nwcF/ENmtWAghhLjLNAupzLMvtiSwsgeaZiMF2M6uvAA+yQarwCBg2R0ZNMvuxorCEnXRzD825OtcKJqWWJ7AIMCFY5fKvqHH5W7ZW1/whijWdFphNZYkfsjXSTNZkvghlwquzIYs2hVZmRQa4OPvxkOTmlOppufN65sQQoibasiQIURERBAaGkqPHj2Ij48nMTGRLl26EBISQmhoKCNHjiQhIYEpU6awYcMGDAYDo0ePBmD37t107NiRiIgIwsLC+OabbwCIi4vDx8eHiRMnEh4ezrx581i/fj2tW7cmLCyMoKAgPv/8c5t9ys/P58UXX6RFixYYDAYGDBhAaqp5iZDPPvuMJk2aYDAYCAkJYefOnXbvLT4+ng4dOtCsWTOCgoIYM2YMJpP5e/aOHTto1qwZBoOB4OBgPv74Y3766SfWrFnDjBkzMBgMfPbZZwAsXryYli1bEh4eTrt27di/fz8ACxcupEOHDvTr14+QkBB27drFrFmzaN68OQaDgebNm7N9+3ZLf44cOUJkZCShoaGEhoYyf/58Sz8HDBhAixYtCAkJYfLkyZY6EyZMsLTXrl07YmKurCdsb+zt+f777wkNDbXc8+rVqwE4ceIEnTt3tpyLioqyWT8gIIDo6GgAjh49Sps2bQgKCqJPnz6kp6dbyi1btoyWLVsSFhZG06ZN+f777y3njh49SuvWrQkKCqJv37506dKFhQsXApCQkEDfvn0JCQkhODiYTz75pNT7AXj11VepV68ezZs3Z/LkyQQEBABXnr8iq1evpnHjxjRt2pSJEyfi5+dHXFzcNcdY0zTeeustWrRoQWBgIAsWLADg9ddft8xONBgMREdHl/rcljYm4s5x5//5QgghhBAl+FbzoN8Lzfh8wuaSKcAmHXnOKSV25UWDfKd0nPN8rRvTrkTI8lySyPaMw6HQGZfcKiXOF6t03X3Pyy4oV/nBU1uyZMqOq9Kkb4x7B9Rne9RJCvLMvzAVT492dHHggWebsmrmH1Z1FNDvhWa4uFuneAshhLi7zJkzh0qVKgEwffp0pk6dSsOGDQkMDOS3334DICUlhYoVK/L6668TFRVlCR5dunSJJ554gp9++omqVauSlJREeHg4bdq0ASAtLY2goCDeeecdAFJTU9myZQsODg6kpKQQFhZGZGQkNWrUsOrTjBkzcHd3Z9euXQBMmzaNyZMn8+GHHzJ+/HiOHj1K1apVyc/PJy8vz+69+fj48P333+Ph4UFhYSG9e/dmxYoVDBo0iLfffpsJEybw8MMPW/pWoUIFevXqZZXevHXrVpYvX86mTZtwdnZm8+bNDB48mEOHDgGwc+dO9u3bZ0m1rVevHuPGjQPMAcgRI0Zw9OhRCgoK6N27N6+99prlmklJ5g3Chg8fzqRJk2jfvj0FBQX07NmTb775hoceeoiJEycyc+ZMAL766iuef/55fvnll1LHvnp16+VDikyePJlPPvmE1q1bYzKZLAG9IUOGMGrUKJ588kmOHz9Oq1atCAsLo3Zt+ynrQ4cOZfTo0Tz66KMcOHCAiIgIBg8eDEBkZCQPP/wwmqYRFxdHq1atOH36NM7OzgwdOpSnn36akSNHcuTIEcLCwiz1nn32WRo2bMiqVatISEigWbNmNG3a1O4szh9//JGVK1eyb98+PDw8GDVqlM1yCQkJjBo1iq1bt9KoUSMWLFhAcnKy5by9MS7i7OzMrl27OHr0KM2bN2fo0KFMmTKFL774gq+//hqDwQDAW2+9Zfe5LW1MxJ1DgoNCCCHEXerC8UuWgJklBfiyol15nQq9cUsLJNPzFAVO6eS5JJYMDhZRijyXREv9K8HBy/HFmxCcK4sjW/+64YFBnV7DVKBIOJ1BRLcAdkSV3MQk7P6a5vULr762gr9OXCKwaaUb2ykhhBC31LJly1i8eDG5ubnk5ubi5+fH8OHDmT17NuPHj6ddu3Z07drVZt1t27Zx6tQpunXrZnU8JiaGOnXq4OjoyCOPPGI5npyczKOPPsqxY8fQ6/UkJydz8ODBEsHBqKgo0tLSWLlyJQBGo9EyI6xTp04MHTqUBx54gG7dutGgQQO792YymZg4cSJbtmxBKUVCQgLBwcEMGjSIDh06MG3aNI4fP07Hjh1p27atzTZWr17N/v37admypeVYSkoKOTnmNYPbtGljtQbfvn37ePPNN0lOTkav1xMTE0NOTg6nTp0iNzfXEhgE8PPzIysri/Xr13Px4pUN0TIzMy2z19auXcvcuXPJyMjAZDKRkpJyzbG3Fxzs1KkTzz//PP3796dLly4YDAYyMjL4448/2LrVvNFb/fr1adu2LZs3b7YbHExPTyc6OtqyvmBISIjV+MXGxjJkyBDOnTuHXq8nJSWF2NhYqlWrRnR0NMOGDQOgcePGVvXWrVvH3r17AahcuTJ9+/Zl3bp1doOD69ev56GHHsLT05zB8Oijj7Jhw4YS5Xbs2EFoaCiNGjUCzMHYopmvpY1xkSFDhgDQqFEj9Ho98fHxJZ5ZKP25tTcmRX0SdwYJDgohhBB3qVP7zIG8qnW9cXRx4Mwh8w903lVc0TtVIj3FnaZBzfCp5MauHz3JcT8HyjqIaNIZyXY7D5p55pzR+cruxpme5g06dJoOl8zq6JT9tfU0B1A2MpHLIlVnspr16OrpSE7mlaDc/t9OAQ64+zhRK9iXI1v+Kt8FNPMYZabm4enrYk7FdnXEP9ALB0cdnhVdbFbLyy6wGuM2/eqxdeUJ4k+mcXxvAskXsjB0qln2NGkhhBB3jC1btvDBBx+wfft2KleuzJo1a5gyZQqtW7cmOjqadevWsWrVKl555RX27dtXor5SiqCgILZt21biXFxcHG5ubuh0V77njh49mu7du7Ny5Uo0TSM8PJzc3JIbbCmlmDt3Ll26dClxbuXKlezdu5eNGzfSvXt33njjDbtrIM6aNYuEhAR27tyJi4sL48aNs1xv7Nix9O7dm3Xr1jFp0iSCg4P56KOPbPZl+PDhvPXWWzav4eHhYfm30Wikb9++bNiwgebNm5Oeno63t3epsxvV5b867tixAxcX6+/FZ86cYcyYMezevZu6devy559/0q5dO0s9e2Nvz6xZszh06BAbNmxg+PDhDBkyhKeeeqpEOc1mtkTpitcZNGgQ06dPp3///gBUrFjR5vt8rWuVtx/X0+/SxrhI8ffFwcGBggLb2R+lPbflGRNx+8iag0IIIcRdqlJtT1o/WJc+48OpFeRLqz51aNWnDiHta/D4S/3p1OU+qgR44+nnioaGW1bNErv1mnRGctzPkeN+nhy381yZJqfIcTtPjvt5slzPYdIZLXVSdSYuOphI1V1Zb/DvBAY/88pjkWcen3nlkaozXbXbsKKg0PwDb06Gkew0o+2GbCn2c/JfJ9LISM7l4qk07ulfn+6jQwiPrE3TjjWtAoD9/q8Zzm7mv52e+CPRaoz963jz4PhwWj9YF02DnatPcfJyXSGEEHeX1NRUPD098fX1xWg0WtZ4i42NxcPDgwEDBjB37lyOHTtGZmYmXl5epKWlWeq3adOG2NhY1q1bZzkWHR2N0Wj7+1Rqaiq1a9dG0zQ2bdpkWbvvan369GH27NlkZ2cDkJ2dzaFDhygoKODkyZNEREQwYcIE+vfvb0nhtHc9f39/XFxciI+Pt1qTLyYmhsDAQB5//HEmTZrEjh07AErcY69evViyZAlnzpwBzLMR9+zZY/N6ubm5GI1GatWqBcDcuXMt5xo2bIibmxvLly+3HEtKSsLDw4MOHTowffp0y/ELFy5w7tw50tLScHR0pGrVqiilmDdvnqVMeccezOv9Fa29+NRTT7Fjxw48PT0JDw+3rKV34sQJtmzZUiJAVpyXlxdhYWEsWrQIgEOHDrFlyxbL+dTUVAIDAwFYsmSJZd09Ly8vmjZtypIlSwDze1C8XufOnfnvf/8LQGJiIqtWreL++++324+OHTuycuVKMjMzUUrxxRdf2CzXqlUr/vzzT8tszCVLlljGqbQxvparnxV7z21pYyLuLDJzUAghhLhLNe1Y0+a/i4RHmlNifvjQ9i8gAPoCDyokh5Puc7hMuxsXBfOKPJbuXCKluTyMmp3XllRec0c8SKfny505dzQVvxoeXDh+ib9OpHE1v5oeZCTnmtc1VNZtuXk70et5A77Vrsx0KDAWkpWWR9V63lSu7cWJPxLIzzNHOrPT8shIMf9le+fqkzTtVAs3LyfCI2vz40fmMT35RwINW8pOfUIIcbfp2rUrS5YsoWHDhvj6+tK5c2fOnz/Pxo0bmTVrlmWW1IwZM/D29qZTp07MnDmT0NBQ2rRpw/z58/nxxx+ZMGEC48ePJz8/n1q1atnd0GL69Ok8/fTTTJs2DYPBYJWqW9zEiRPJy8ujZcuWltlgEydOpF69eowaNYqUlBT0ej2VKlWyBLVsKUqhDQoKolq1anTu3Nlybt68efz+++84OTnh4ODAe++9B5jX0hsxYgRRUVE888wzPPbYY7z77rs8+OCDFBQUYDQa6dGjBxERESWu5+XlxRtvvEGLFi3w8/OzmtGo1+tZvXo1zz77LG+99RY6nY6nn36aJ598kqVLlzJu3DiCg4PRNA13d3c++eQTmjZtyqBBgwgKCsLX15c+ffpY2qtQoUK5xh5g0qRJxMTE4OTkhJubGx9//DEAS5cuZfTo0cybNw9N0/jss88sAU57Fi1axMiRI3nvvfeoX7++VTDx/fffp3///vj4+NCxY0erthYtWsSoUaOYMWOGZSORoo1DPvjgA5566ilCQkJQSvHyyy/bfUYAevbsyc6dOzEYDPj4+NC+fXurTUiKVK5cmc8++4w+ffrg7OzM/fffj4eHBz4+PgQEBNgd42t57rnnePzxx3Fzc2PhwoV2n9ugoKBSx0TcOTSlbtcKQrYVTT9OS0vDy8vrdndHCCGEuOvt//0sGcm5nPptH+ryX3RLcCwktvZZ631GFPgmtEanrmy8cdHBxCLPK8HBYRnOVCksf3CwKJU4WWfiR/crMwV7ZDnia9JwUtqVoKNSVP9rCx6N6lHfO548zZX15xphKt9GyXhVcqFhS3/Cu9S2pALH7Ixn3YLDaDrNvCOxZk7NUSaFpgN1+RqaDuo3r4KLmyMJZzJIiEvHVKjQOWiEdDCvvePgoFkCiEIIIcxyc3OJjY0lMDCwROqoLafTT9Pzu57XLPfDgz9Q28v+phFC3GkyMzNxd3dH0zRiY2Np3bo1u3fvpmbNkn/gLYuMjAw8PT1RSjF+/HhycnIsQU9b5cC8NuBLL73EkSNH/ta9iDuPra+15YmvycxBIYQQ4h+uaceaGOPi8H3lVbtlzlevRmzAvXZ3Ny4ezCuu6HXReoFlkaor5DMv26k/xQOFj6U7U6FQA03jfLV7Ic2E28avqJh7hupDPuRsbDlSjIH0xFx2/xDH0e3xBIT4EtE9kBN7zYugV6vvTVaakbSL2eYgIVcCg06ueow5BRzfnWA5V0Qp2L/+rHmWpV6jXkQVCQ4KIcTfUNurNj88+ANZ+Vl2y7g7uktgUNx1tm3bxgsvvABAYWEhs2fPvu7AIMCwYcOIi4sjNzeXoKAg5s+fb7Pc3Llz+frrryksLMTLy4ulS5de9zXFP5fMHBRCCCH+BXIOHSKuX3+753e0bMHpwECcc5xxzW5s2d3YOacyhRkNrFKJ7SlrivFFXSGL7AQHiys+K9Et6wI6UwH+2TG0fqI9cRedMOYUcGjrBVBQ6OBCjlvla7ZZXIOWVTixJ8EyA7BRa38O29jsxMVTT25GAdUb+pAQl05+nnWAVNPAu4obXZ8ItkpZFkIIUf6Zg6J8IiIiSmwSERQU9K8MABXfRbi44cOH85///OfWd+gGkPdXlJXMHBRCCCHE31YxJRXvtHTS3XuR5emFT0pTy+7GOWXcAO/q9QPtcaJsBZ0u//nSNesirXa/aTl+/j9ROAKOQIti5be3eLVcAcJjOy9a/q0UNgODALkZ5h/Kz8dcsnleKeg+OpQK/m5lvrYQQghxI9jbIOTfyGAwEB0dfbu7cUPJ+ytuFdmtWAghhBA0OH6cxkePol0O3BXf3dipjDkGjqqQLPczKErfuriCScdj6c4My3CmR5aj1bkeWY4My3C2moXoYLr2rEUAh8LcsnXUhqJ0YVs7MZfF/5YfJTvdSH5+Pps2bSI/P//alYQQQgghhLgDyMxBIYQQQlhx9XQkJ+NKcKsomGd/AxEdTgpcnRLJ8IzDodAZP9daZKbaD+pdnX5cLTMR14I86mU5UdF0eWbh5XUP3bLjb+j92XO9OzErCjl27k8i4muzZ2c00Sc34+PjQ2ho6M3srhBCCCGEEDeEBAeFEEIIYRHaoQZJDhU5tvMirg5G8godMKGzBMm8NI0GxWYGNsCBOpXM6bRH8g4DoCqk4uvXmMzUPJw99ORlFpS80OUlj52UOTD4+bp3bvKdXdvVadFlTZM2+aSS7RLHoYOHOHzoELjAoUOHJDgohBBCCCHuChIcFEIIIYRFo9ZVOXbRC299Np4zHiffpGPzPe+CpuGug94eTgzCvBtvNnkc9D5DXoE50JfrlApAlkrk8Ok9KE9FFjpcddXRma7awVcz/18Fk8bgjNu7N9rf2YnZpDNi8v8LLsHegzswOucAcOLECX799VcAdDodrVu3xsNDNisRQgghhBB3HgkOCiGEEMJK0441gZrktfqGvS/OBU0HSqHXrKfS5WhGDjqcwaQpUFjWK1RKke16zhwAVBrOOZXQmZzQOUCFqh4kn8uEYpuSeJrKOEXvb/Kp4opOryPlfBYAfjU9qN87gL5LdtssXzx9uniKsUlnJNvtPGgmTLp88i6Zg6LGwmxL+cLCQrZv3w6Ag4MDwcHB/9zgYOIxOPYztHoaHByhMB92fAQNukGlBjevrhDiX8GUm0vKwi+pOGI4OtntWAghbgrZkEQIIYT4F3Bwdy93Oef69cmKHAWAd9pJGh9ZZFXWV3nyoLEF3iZzWrHSLs8AvBzrcyhwpUJyOPoCD7yruDLg5RYMmNSchi39/+bdlF9EjwAefrUVA19uQas+dajZuCIu7o4c2nvx2pWxTjE26Yzkepwnx/08eS4J5rURixSPcyrzGDzU+xGqVq16Q+7jjpNwFL7oAmunwLePQn6O+b9rp5iPJxy1Wc2Um0v6u0MxfdjCXPabkZCVDLOamF9/1sluXSHEv0vGb7+ROGcOGWvX3tB2V69eTePGjTEYDBw4cOCGth0XF4ePj88NbRPgvvvuIyoqqtz15syZQ3x82dbvXbhwIX369Cn3NW4HTdO4dOlSuepcunSJ6dOnl7n8iBEjmDNnTvk6dgfp3r07MTExAJw8eZLw8HDCwsJYsGDBbe6ZuNPIzEEhhBDiX8ApIIC6v/xMYVaW3TIO7u44BQRYHfM2JVP3ZBS1zq7HwbtmiToVlAe9jBEsdt5U4pxPsgGdcgQN+v9fBC7u1jsTe/m5oOk0CjOu757Ko3ItT3Q6c+SuWdcAagVlsPKdPSSZCsHLumyA9hfu5JKFC3HKHNQrvmOzvsADn6Qw0n0OU+iQcyUgaGMCZIu6XakVUP0m3NEtdvUMv4uH4acJEH8AjJefqSOrYfYWyE4xv865ZA7yhQ83B1DzLkGFQNA5kLt/D0kZezmj1cadXAKPfg9HfwQup3bnpcPn98Pjv4Nf/Vt/v0KIO0b6z79Y/uv9wAM3rN358+czZcoUHn744RvW5p1qzpw53Hffffj73/o/zt1pioKDL7744u3uyk1lMpm/n/7000+WY99++y3Nmzfnk08+KVdbBQUF6PUSOvqnk5mDQgghxL+EU0AArkFBdj+uDgwCVI9dS+2z63BrFka1t9+y2W687tLlFOLLBy7vMpzvlG55/deJS5bylWp70vrBugx5vTUh99Ug5L4aN+T+Ch2s081aP1gX/7reAJzcl2h1rlJNTx6a1JzAyh48lu7MsAxnemQ5EqD9xUbn8fzo/DIbncczNjvZ5q7F+gJ3AvStS3biqjE4vP8YW1ceZ/t3J8hON96Q+7wlEo/Bb5Nh8yz466A5yLd2CsyoDwdXwif3wumt5iCeurJBDdnJWA2CMRN2fAg7P4TopbDhDVj/GvEX99IxfxY9jW/RwTiLWJM/lsBgkbx0+MN6tqoQ4p+vICmJhPfe4+L0d7g4/R2ytmwBIGvzZsuxhPfeoyA5+bqv8dxzz7F582YmTZpEmzZtGDJkCBEREYSGhtKjRw+rWXaffPIJDRo0IDw8nGnTpqEVW2KjtHrF7d69m44dOxIREUFYWBjffPMNAImJiXTp0oWQkBBCQ0MZOXLkNfu+fv16mjdvTr169Rg/fjzq8gZf8fHxDBgwgBYtWhASEsLkyZMBeP3117lw4QIDBw7EYDAQHR3N1KlTGTt2rKXNefPmMWLEiBLXio+Pp0OHDjRr1oygoCDGjBljCToBvPPOO4SEhNC0aVNatWpFdrZ5eY3FixfTsmVLwsPDadeuHfv37wfgwIEDtG3blvDwcJo0acIbb7xhaSs/P58XX3yRFi1aYDAYGDBgAKmpqdccj5kzZxIWFkaDBg1YunTpNcd89OjRZGRkYDAYiIiIAErOyOzfvz8LFy60OfatW7cmLCyMoKAgPv/882v2T9M0Jk+ebLOP9p6fopmnEyZMIDQ0lKCgINatWwfAmDFjeOutKz+PxcTEULNmTQoKCpg6dSr9+vUjMjKS4OBg/vrrLwICAoiOjmbRokXMnj2bVatWYTAYOHz4sN1nBiAgIICJEyfSokULhg8ffs1nQdz9JPwrhBBCCLtcg4JwqV+PiiNHkh+fA7/tK1Em1iEBgCrKm5bG+vymHSPXKR3/ZiacL3oTfzKNk/sSCWxaCSha0xDLv3OqpBP33rX7cqjJCLLcqpjTdR00Oo1ogk8VN3atieXkkUx8QurTIMCLk/sSyUzJJeWvLB4cH0702jM4OFoH9wqMhcTuT6L3WANfvrjNctydXKtyVU15JNnYjMS7iisJl86CD5ZAIJj/654eSJ5LMgVO6eQ6J3Js50Uc9Br1Iqrg5uVUoq3bqviMwD+WwI55EHAf7F8GBZfXUFz/OpaAX24qfDvqb182W7MO5GZhZx0x1wp/+1pCiLtLQWIiKV8uQhmNoNPM694CymQiZdGXYFJoTk54de+O3tf3uq7xwQcf8OeffzJ27Fj69OlDYmIilSqZv0dNnz6dqVOnMn/+fA4ePMjUqVPZt28f/v7+vPrqq1btzJkzx2a94i5dusQTTzzBTz/9RNWqVUlKSiI8PJw2bdqwYsUKAgMD+e233wBISUm5Zt8PHz7Mtm3byM/Pp127dixfvpzBgwczfPhwJk2aRPv27SkoKKBnz5588803TJkyhS+++IKvv/4ag8EAUObUZB8fH77//ns8PDwoLCykd+/erFixgkGDBvHll1+ycuVKtmzZgre3N6mpqTg7O7N161aWL1/Opk2bcHZ2ZvPmzQwePJhDhw4REBDA+vXrcXZ2JicnhzZt2tC5c2datWrFjBkzcHd3Z9euXQBMmzaNyZMn8+GHH5baR03T2LdvH6dOnSIiIoJ77rkHHx8fu2M+f/58S5C0vMLDw9myZQsODg6kpKQQFhZGZGQkNWqU/kdOW30MCAgo9flJS0ujcePGzJw5kx07dtCrVy9OnjzJs88+S2RkJBMnTsTBwYGPPvqIJ554wjKzb/v27ezbt48qVapY9WHYsGGcOnWKS5cuWdKkIyMjbT4zDz30EADJycns3LkTTdPIzc21+yyIfwYJDgohhBDCrorDhl6zjJ/JiwomD0IKa6FDo1t4D9L9E3F01NPiEdvBueuR5VqFLM9aeFdxo+sTwfhWM2/w4XPRC0O4CcP9tdDpNNr0q2e5pk6nER5Zu0RbJ/clsnP1KXIyzLP5vB0u4OyQTZp23vr+9ecAyFeupBVWsxxPu5hDnncSAPp8L/T5nhidkzDp8yhwzMInpSk57ufQlA4ff+v+3jLX2uwj5hdYMQwK82DvIkg5Ya6XfOKqhm7cbtKxJn+ycOGEsk61PqGqg8kcnA3UXZ5506ArtHn2hl1bCHF3cGncmMCV33Lu+bEY4+Kg8PLs5MJC0OlwqhNIjffn4Fz/xi05sGzZMhYvXkxubi65ubn4+fkB8Pvvv9O1a1dLOu7jjz/O66+/fs16xW3bto1Tp07RrVs3q+MxMTG0atWK2bNnM378eNq1a0fXrl2v2ddhw4bh6OiIo6MjjzzyCOvWraN3796sX7+eixevrKObmZlpWWvueplMJiZOnMiWLVtQSpGQkEBwcDCDBg3ihx9+YPTo0Xh7m2foV6hg/mPO6tWr2b9/Py1btrS0k5KSQk5ODjk5OTz99NNER0ej0+k4e/Ys0dHRtGrViqioKNLS0li5ciUARqORABsZDVd77LHHAKhTpw7t2rVj06ZN+Pn52R3zOnXqXPd4JCcn8+ijj3Ls2DH0ej3JyckcPHjwmsFBW30MCAgo9fnR6/WW2ZytWrWiWrVq7Nu3j3bt2tGkSRNWr15NZGQky5cvt1ozs3v37iUCg7ZkZWVd85kZMWKEZaZsac+C+GeQ4KAQQggh/pbgQuu1CBu3qY5T9YaW17aCc8WVdbOUQgcXFNDvhWZW6xcWn4kI2A0IFnfi8kYkJ/cl4u1wgUcqPWOz3P0+cyz/XpL4oVWAUJ/vib7AHdesGmhoqIw65LifA6VDQ8Mty9yv3lMMHN0ej7efK3onhzLd69+WcBQWdIWcVDi3F/p+Al8NhpO/w8Z3wKcWJB65Uj7l6oDgjRdr8qeDcRYOmGjiEI8DJgovr3AzNv/K+G9wGmcOEGryY6oQ/1bO9esTsHwZx1pdtXyDUgQsX4bD5YDUjbBlyxY++OADtm/fTuXKlVmzZg1TpkyxWbZ4SnFZ6ymlCAoKYtu2bSXOAURHR7Nu3TpWrVrFK6+8wr59+3BwKPv3Ck3TLKnFO3bswKUMOzrr9XoKC68sCZGbm2uz3KxZs0hISGDnzp24uLgwbtw4u2WLKKUYPny4VeprkWeffRY/Pz/27duHXq+nb9++lvaUUsydO5cuXbpcs/+lKRoPe2MeFxdX4lhZx2P06NF0796dlStXomka4eHh1xwPe30sz3NXvB7A888/zzvvvENiYiL333+/VTDQw6Nsf4gsyzNTvK3reRbE3UXWHBRCCCFEmWjOZftlpazlihRtlhKw8lurD8e3/8uuZhPZ1Wwi21u8So5b5RLrF5ZVdrqR7d+dYMu3x9ny7XHOHDKnbmWn5VGtVtn666jlFHulcMuujltWTbTLOcVFAUG3bOtZcdFrz7Bz9akS6x7eNInHzIHB3MtrPh5ZA+/WMQcGAfKzrAODt0hR6nBtXQrNHM9TW2d7LSlLinHMD7Bt7q3qnhDiDpO9Zw+oq2YuK0X23r039Dqpqal4enri6+uL0Wi02qyhQ4cO/PrrryQkmJfPKL7GXGn1imvTpg2xsbGWNePAHBA0Go3Exsbi4eHBgAEDmDt3LseOHSMzM7PU/i5ZsoT8/HxycnJYtmwZnTt3xsPDgw4dOljtwnvhwgXOnTPPfvfy8iItLc1yrl69euzZs4fCwkKys7Mts/VsjY2/vz8uLi7Ex8db1u0D6NWrF/Pnz7e0e+nSJQoLC+nVqxdLlizhzJkzgHnG2Z49eyzt1ahRA71eT0xMDGuL7UDdp08fZs+ebVm3MDs7m0OHDpU6FoBl1924uDg2b97MvffeW+qYe3l5kZOTg9F4ZR3gevXqsXPnTgBiY2PZcnmdS1vjUbt2bTRNY9OmTZa1FK+nj9d6fgoKCli8eDEAu3bt4sKFC5a08C5duhAfH88bb7zBmDFjytSHq13rmblaac+C+GeQP8kKIYQQokwc/VypMiEClVdot4zm7ICjn2u527a1GUrcrsNketaial1v2vSrx9aVJ0qsX1jEGBdHYVYWhfkmju26SIMWVaxSmdPTYf/6BAoLFGjFZ39oXDhbCCUzwUrIV0X3VbTIYPHFBu07sNGcqrz7h1hqNq5489cd3LfIPGPQQkF+9s29ZhkUrecY4JBi+e8pU8n1wqzWfcy59mL0Qoh/pvTfzIEj12bhVHnhBS6+O4OcP/4g/be1eHbseMOu07VrV5YsWULDhg3x9fWlc+fOnD9v/rpdtEnDPffcg6enJ127drWk0ZZWr7gKFSrw448/MmHCBMaPH09+fj61atUiKiqKjRs3MmvWLBwcHCgoKGDGjBmW9u1p3Lgx99xzDykpKfTu3duS1rl06VLGjRtHcHAwmqbh7u7OJ598Qo0aNXjuued4/PHHcXNzY+HChfTt25dvvvmGxo0bU6NGDcLCwixBueKef/55+vfvT1BQENWqVaNz586Wc0OHDuXChQu0adMGvV6Pu7s769at49577+Xdd9/lwQcfpKCgAKPRSI8ePYiIiGDy5MkMHTqUL7/8krp169Kx2Ps4ceJE8vLyaNmypeV79MSJEwkKCip1PAoLCwkLCyMrK4sPPvjAkopsb8wrVqzIsGHDCA0NxcPDgz179vB///d/DBw4kJCQEIKCgqxSooubPn06Tz/9NNOmTcNgMNgtV5Y+Vq9evdTnx9vbm4MHD9K0aVMKCgpYtmwZnp6egPlnmEcffZRly5bRurWNzdHKqLRn5mqlPQvin0FT6uo/x9xe6enpeHt7k5aWhpeX1+3ujhBCCCFuktikLLLyCnB31hPoVzK1eP/vZynMv7KWoMmkLGsJFk8lNsbFcbJrtxL1r1Zx0UrW/ZRO2sVsq8komgY1qqTSrm81YtdtISz9yu6J9P0v27fqOXkwG9dajbjnofp8/+5WjLigJw/Xit5kpJQ9raZByyq4ejrh4KDRtFOt6w8U2ltP0K8hRI2+o4JqmbixnXBM6EhT7hylPibNgUKlcaSwMgAddftowT58Sb+y5qDeFUZvBr8bt66YEOLWy83NJTY2lsDAwDKlvBZJWbQYZcyj4siRaA4OqMJCUhYsQHNyLtN6uDdKRkaGJSjz/vvv88svv/Dzzz/fsuuLu5umaaSmpuLj41PmOnFxcRgMBi5dumS3TM+ePRk4cCBDh966zwVxZ7P1tbY88TWZOSiEEEKIWy42KYsOMzdaXm+YcF+JAGFZ1xIszMoq0zW93BX9XmjG5xM2Wx1XCrwaBnPwmI6/TlcgrNgGufv2uxJ7oSJphXk0SN+HtmI9tU+dJdm7Ab5px2hcM4A1KWGUZQahpsGxXRfNuy3/nd2Lba0nuOpJOLLa3A/t+leNOeWo539urjySloEjkA8s8fakfXYOdfILrqvNDNzZQRiF6NE0k+W4hiLI4SKaBkmqCtW1VKpyOfVa7wZPbJDAoBD/YlcHADUHB3wvb+xwK7344ots3bqV/Px8qlWrZjd9WIhbYc+ePQwaNIgmTZowePDg290d8Q8iwUEhhBBC3HJZeQWlvi6r7HQjBzecxbOM5S8cv2Rz891D/zsPGvjorVOiD+1II63QHLSMjcnE8/CX1NR01DyzHhwciP0lCILCzRFGrfQAYdFsRWd3Pd2eDKFSzbL2upgS6wmuhhnrwVi0RpUCZT/tuzQnHfUMr1qFNAcHDjg58VZSCpP8KvKrUy0+dnZkRvJ52heaU57yTdVQ2E8f18jBUXcBgKok8iTLWEEPkqmAurzktU4zj8klkwvDWElV7XJg0MERBiyEyo2u6z6EEOJG+vDDD2/p9T777DPmzZtX4vjcuXO59957b2lf7gSjR49mx44dJY5v374dV9fyL2NyM5TWx+tJ1AwICLA7azAiIoITJ27+JmLi30eCg0IIIYS4ZYpSiU8kWC+4XvTaXoqxPVlpeRzbdZFmZSx/6vKmIFevY+jo4kBBXiGX8quyJPFDHLUc8pUruc610OUVYipUJPsGc7xOX1AKTRVS6+x6Ev0MAFSp4UyLfo35/oNrL06en1uAk6v1j2AFxkKi15/F0KnmlR2NbaUO/zC2ZMqwsfTF68vi1OXAYKbOHLhb5+7GPhcXEgorkXXyBbKA4cBi9xdola+4aPz0mm1WcXrCEiCsTDKP8jXv8pRVGQ3FaJbQSHfWciy/UGP7inm0fqwWjv6N//a9CSHE3eSxxx7jsdswQ/JONX/+/NvdhWu6G/ooxLVIcFAIIYQQt8TVqcTFjf062vJvWynG9lSq6UnnUUGk7ipbHyrV9qRiNXfLOoYPjg8neu0ZlFLsWH0KgLTCalcq5BRc2bzEwYGz1e8DTYdmyqdKwl48M85Qe0Rfwh9oQNyfSWXqwz3965eYNXhyXyI7V5/Cs6ILDVv6204dXj4YTm8t242W0//cXElzuLJrs9I0kh10qHzr9cE2OXkTnp9PtEMcwYU10WN/p+erZxaepjrKaiOXy7MtNUercoepw+8FzfDZ8j2h/SU4KIQQQghxs13/ojRCCCGEEOVQ1tTh8qYYe1cqe1pR0441CY+sjU5nDvgVrWNYwd/dZroxgDKpy/81v3bL+ovme97BM/McNc9tpKHneXQ6zTIr0dPXhR5jQu32IeF0RoljJ/ZeBODkHwklUofVkTWY3qqLOvV7me+zvB5Jy+D+zCy0y+lPJqMvBbnVMRkrW5VrmFmBTaoJexxPEqdLLNc1jmBeP7AWF3iU5dTkwuXj9azKHaKB+b/GkrslCiGEEEKIG09mDgohhBDilnB3LtuPHWUtdyPZSze2FTC8p+A3PB9oR25MDLnR0aT/thbPjh2tZiXam0XYsJU/lWp5kp1uZP/6MxQWmi9w5lAKAKcPJhPL7wQWSx3WUGDKutaShtdNKXDU4K2klCupxKdesFl2Qv4z9HI8TkUuccrhIvVM/mW+RlXtIr6mfFpwGh3uDGEvO7U0CpWOX7WeFKJDo4CTWgAAJ06e5NdffwVAp9PRunVrPDw8bsg9CyGEEEKIKyQ4KIQQQohbItDPnQ0T7rOsOVg8lXjOQAP1KnuUe83BG6VSbU98qriiAL8aHjw4PpzfvzxCzM54LGmwSoGmw9jhIS7NeoGq70ynsHMnNCdnwHp3ZbvBxsvlEs9msH/9WQoLlHmD4cuRP6Vg+6E6eHrXwld/Fk0zBw9vVmCwqO18YJJfRZupxC7kE6SPNwcpAR+d+T7O6ZLZoT8OgA6NkIJauFJy92V1+RrNTAlcNL5B8bBpXSBZy2C1025MmjJnGisTaGAymdixYwdKKRwcHAgODpbgoBD/QjbXZBVCCHFDSVqxEEIIIW6ZQD93gqt7U6+ydZCnXmUPgqt7X1dg0MG9bHVKK9e0Y008fV3ZtSaW45tOkTR7FjkHDwLgnXaKgNgfLRG64xtPApD+/Q/4PvYYFYcNLdFejUqJ9G6xiT5jQ/Cv482DY0Po3WITNfzMQcNKNT15aFJzfPzdzKvvXU5d9tHO0LfiZPwcz6A0h8tr9F2hsJv9XGZKgVE5sEk1J//ymoFLvD1Z6+GOphxonF0FB0yW8m5aPk0cLhKsv0iQw0VLDxRw0OEMB/VnOOhwhmwtz+o6qVmVACx3YG93Y1/lyYPGFnib3MzlNN3lfpqv4+fnx5NPPknVqlX/5p0LIe5GRWuyntxXvqUMrmX16tU0btwYg8HAgQMHbmjbcXFx+Pj43NA2Ae677z6ioqLKXW/OnDnEx8eXqezChQvp06dPua9xO2iaZndXX3suXbrE9OnTy1x+xIgRzJkzp3wdu02ufu4MBgMZGealTHbs2EFISAhhYWGWWfnlbUP8s8nMQSGEEELcclenDv+dVGKngADq/vIzhVlZdss4uLvjFBBQajtF6/6d+CMBbckinCu1oa6DI7XO/c6fTcw7R7plXcD94lEAsnbs4OL0dwDQHPVUHDECva8vJByl0aHh5s1EVp2Cvp+g+2owNc78DokLocUv4FsX39jP6T/qfma8k4kR8NXi6VtxEk6a+T40VVBixuCNmECoaXBE1ed3rS0+ZBDKUdpn5/C5txc+2TUJSa9Dtv9i0hxTSS2oQspfD/O9MYj7HE/go8tBu9wLdXmmn7fJjc75IVRQ1gHfHcaRRJoO4qRlo9NMXNDp7f7gWUF50MsYwWLnTSXOPfroo7i6ln1dSSHEP0vxNVkbtizbUgZlMX/+fKZMmcLDDz98w9q8U82ZM4f77rsPf/8bN353q6Lg4Isvvni7u3LTRUdHW/795ZdfMnjwYF566aXrbkP8s8nMQSGEEELcckUpxj8827ZcuxPb4xQQgGtQkNWHY/1GHDrjjmP9RjYDg9npRrZ/d4It3x5ny7fHLev+nTtt5PzoT7hYqy0JfmHE1O1PSsUmAOS4VibXpSLH6/blRO2exC9fScrChaR8uYiChJKbiXBkDcwOgpOXNxPJuWQ+v3QArJ3C2S+H8ZlnHos885jtUYG/8EB3C1KJD2mXN/24vElIzXzFhHM1qZ1p3gQkPNuD35N208p0BoBLypWfjI1tTlvsZYwoERgEwKcWq5LfxKjMMwJPF9YvtU/xukuXo59XLqKU4vTp0+W7OSHEXc3e1+bTB5Mtx7Z/d4LsdON1X+O5555j8+bNTJo0iTZt2jBkyBAiIiIIDQ2lR48eVrPsPvnkExo0aEB4eDjTpk27soM9lFqvuN27d9OxY0ciIiIICwvjm2++ASAxMZEuXboQEhJCaGgoI0eOvGbf169fT/PmzalXrx7jx4+3zLKOj49nwIABtGjRgpCQECZPngzA66+/zoULFxg4cCAGg4Ho6GimTp3K2LFjLW3OmzePESNGlLhWfHw8HTp0oFmzZgQFBTFmzBhMpiszy9955x1CQkJo2rQprVq1Ijs7G4DFixfTsmVLwsPDadeuHfv37wfgwIEDtG3blvDwcJo0acIbb7xhaSs/P58XX3yRFi1aYDAYGDBgAKmpqVzLzJkzCQsLo0GDBixduvSaYz569GgyMjIwGAxEREQAJWdk9u/fn4ULF9oc+9atWxMWFkZQUBCff/75NfunaRqTJ0+22cdff/2V8PBwQkNDad++PYcPHwZg48aNBAcHM2zYMIKDg2nWrJklSLdx40YMBoOljYMHDxJg54+fRTMrp0+fztdff828efMwGAxcunSJPXv20KZNG0JDQ2nRogVbt24ttQ2ACRMm0Lx5cwwGA+3atSMmJuaa9y/uHjJzUAghhBC3xc1eW7AoFc2zoovN2SZZaXl21/07+mc2OFcFZ8jwrGnZxRc0ztboAJoOzZRPlYS9eFSvRI335+Bcvz5sfd88Y9BCQXay5VU+Orbn1KP1qf/hCGTnF1r16ZSuDQFqlSUwmI8D2wmnNX+gV4V2A4ZF3bN3PhM3thOO6fLfhU8QAMBxAvmUh8lSrqSZvKmUa/6lz8VYnf9xL5GX3EnXn+VQgT+VdJnmCyh1+b+AZg7q1TZVKnHNzo8Hs/DtXP6b+X9Uct1HLOHUtd09AGIdEgCo4VeJukFB/O9//wPgyJEjNGrUqJSaQoh/ktK+Nu9ffxYUOOg16kVUwc2r5DqnZfHBBx/w559/MnbsWPr06UNiYiKVKpm/jk2fPp2pU6cyf/58Dh48yNSpU9m3bx/+/v68+uqrVu3MmTPHZr3iLl26xBNPPMFPP/1E1apVSUpKIjw8nDZt2rBixQoCAwP57bffAEhJSblm3w8fPsy2bdvIz8+nXbt2LF++nMGDBzN8+HAmTZpE+/btKSgooGfPnnzzzTdMmTKFL774gq+//toSVCprarKPjw/ff/89Hh4eFBYW0rt3b1asWMGgQYP48ssvWblyJVu2bMHb25vU1FScnZ3ZunUry5cvZ9OmTTg7O7N582YGDx7MoUOHCAgIYP369Tg7O5OTk0ObNm3o3LkzrVq1YsaMGbi7u7Nr1y4Apk2bxuTJk/nwww9L7aOmaezbt49Tp04RERHBPffcg4+Pj90xnz9/viVIWl7h4eFs2bIFBwcHUlJSCAsLIzIykho1apS7j25ubgwePJiNGzcSEhLC0qVL6d+/P4cOHQLg0KFDvP/++yxatMgy5keOHCl3nwFefPFFjh49isFgYOzYsRiNRvr27ct///tfIiMj2bJlC/369ePEiROltjNx4kRmzpwJwFdffcXzzz/PL7/8cl19EnceCQ4KIYQQ4h/pWqloRev+/fLpQdIuZlvW/VMmhaaBm6uiMDmZXJeKKJ15bT6lcwBlwi3rL4IPfY5HTjwB67bj4O1tbrTV03Bur3nGoI1pdoepz++0Jd+kowoXOaWs19HbX+spKp47hXdBPHV08Zby3iqDENNRtMtr8Rt1NdCbktCRC0ChUSMprxb+XqctsbviMnBnB2EUogdMmDCnjxSicYEqlgrqctKwCY0dhKE0HU0dzvMf3TJOaYGcIpBa2gU6mo6wTgvjHL7EO/5AcxUNaODsAX0+RqsSyNlzmVxyTuCrpp8BUDcngaFxYXbfLz+TFxVMHvh5GNizb4f5mJ+frDUoxL/Mtb42e/u70fWJYHyr3bgNipYtW8bixYvJzc0lNzcXPz8/AH7//Xe6du1qScd9/PHHef31169Zr7ht27Zx6tQpunXrZnU8JiaGVq1aMXv2bMaPH0+7du3o2rXrNfs6bNgwHB0dcXR05JFHHmHdunX07t2b9evXc/HiRUu5zMzMvz2zy2QyMXHiRLZs2YJSioSEBIKDgxk0aBA//PADo0ePxvvy978KFSoA5rUc9+/fT8uWLS3tpKSkkJOTQ05ODk8//TTR0dHodDrOnj1LdHQ0rVq1IioqirS0NFauXAmA0Wi0OyOuuMceMy/7UadOHdq1a8emTZvw8/OzO+Z16tS57vFITk7m0Ucf5dixY+j1epKTkzl48OA1g4O2+lihQgVCQkIICQkBzLNQn3nmGc6fPw9AQEAAnTp1AmDAgAE88cQTnD179rr7XlxMTAw6nY7IyEgA2rZtS5UqVYiOji71XtauXcvcuXPJyMjAZDKVKZgt7h4SHBRCCCHEP0J2upH9689QWGj+RfLqVDQABweNpp1qWWab+FbzoN8Lzfh8wmarthTQXr+BjL0/sfmeGSWu1WzfezgW5Jivu3cvnh07mk84OELfT+D9HZCZwNUBwkOY03mXqu78nl8yzfaDY4l8wP8BsMFpHId05vKHtfqE6o5izNBR6OTL6Z91ODp64VHDEbdKRlKPuZEbUAF/r9M2Zw9WJZEnWcYSepJGBXSX1w3U0KEub3OiXf6f+f51gKIiqQzSvqeylowejTqcow170ekUozjINpqh1wpw0k6CszcFwxYR/acbhvpOnNqXSL5DXsnO2JBNHtlaHiYU2w9v55LrBdAgNTWVtLQ0fv31V3Q6Ha1bt5Ydi4X4Fyjta3O/F5rh4u54w661ZcsWPvjgA7Zv307lypVZs2YNU6ZMsVm2eEpxWesppQgKCmLbtm0224yOjmbdunWsWrWKV155hX379uHgUPZdmTVNs6QW79ixAxcXl2vUAL1eT2HhlZnrubm5NsvNmjWLhIQEdu7ciYuLC+PGjbNbtohSiuHDh/PWW2+VOPfss8/i5+fHvn370Ov19O3b19KeUoq5c+fSpUuXa/a/NEXjYW/M4+LiShwr63iMHj2a7t27s3LlSjRNIzw8/JrjYa+P11NH07Qy9/VG9+nMmTOMGTOG3bt3U7duXf7880/atWt3Q64t7gyy5qAQQggh/hGKUtH2rzvL/vVnLam2RaloRcez0qwDVucPJ5ac5Kcgo1pT1PAJ1tPwlMJHfwH/5zriGm4AIP23X2Dr+5jOHyDp449Q3z5mCQxm4sZa2vLr/7N33vFR1Okff8/29B7SIUBoAelVaYoeRSlWFCm207MgB3goP9spetgAwVO5AwFpKqKggii9J7SEIhACJJT0umnbd35/bHazm2ySDUTFc968eCU7820zO7vZ/czneR4G8RODuFAdzhst09JLcZleisv0VFxBgwkADSZ6Kq7QS3GZA0IvR/vzxPOzMIidfrewT92eqKfbE3iTBp9wI35RBqL6l6K5dAmLUXAcd23CKcLf/we3+8R6aiCPZivh2MKi+5HKLRyhLKAflsEvI+twJ7dwhH6aTOj/LDyxnQtXQxxVRcNa+tHn1obzDNrRCUZH5eNSryyqCxZjtVpJSkri4MGDJCUlSRUTJST+RGSnl7p9b845X9qs85SUlODn50dISAhGo5HFixc79g0dOpSffvqJ/Hxb2gPnHHMN9XNmwIABZGRksG3bNse21NRUjEYjGRkZ+Pr6cv/997No0SLOnTtHRUVFg+tdtWoVJpMJnU7HmjVrGDZsGL6+vgwdOtSlCm92djZXr14FwN/fH61W69jXtm1bjhw5gsVioaqqyuHWc3duIiIi0Gg05ObmOvL2AYwePZpPP/3UMW5paSkWi4XRo0ezatUqLl+25ay1Wq0cOXLEMV5MTAwKhYK0tDS2bt3qGG/s2LHMnz/fkbewqqrKEWLbEMuWLQNsot/evXsZOHBgg+fc398fnU6H0ViTs7Jt27YkJycDkJGRwb59++o9Hy1btkQQBPbs2ePIpXgta+zXrx8nT57k1KlTgC1MNzo6mujoaEfbnTt3AvD111/TokULYmJiaN26NZcuXaKgwFa9e+XKlR6twZn27dtjtVod5//AgQPk5ua65DKsjVarRalUEhkZiSiKfPTRR02eV+LGRnIOSkhISEhISPxP4HEomjIb9n9mCwGWKzn3Ywrdvbeg1fSk++Pj2L/+PLkXtOQHJtq+mF7IJbJNAJ2907mQqWWo1xtosisQx4ymeOhUfEu/gK2pIH8X4ZSI0LGmarJzOK9ATRJ3AZFEeR6CABZRIMMSgl5U4i2Y6CTPQy6IpIttEaq/GTvCfJEhx0zn7C+IjC1wCIFypUhUv1KyDgYR3b8Euar62GuFGPcrC+AqAmK1U1Cs5Rh0UN1Rj82BYhUFzIKG8viH+OrgcG4dcBPt75sGSR9D+5EQahMBc9Z8R3fvrVw8GsiIp3vQ1RJB4p77qIztw9VyK2S6f+5CRD/GGfuwTXkSrVDlcMGIooggCISGhnL//fcTHh7e9AtDQkLiD8nFFJv4EdkmgAH3tHW8N19IKSC+a908p9fK8OHDWbVqFe3btyckJIRhw4Y5QjvthT1uvvlm/Pz8GD58uCOMtqF+zgQFBbFp0yZmzpzJjBkzMJlMxMXFsWHDBnbt2sW8efOQy+WYzWbee+89x/j10bFjR26++WaKi4sZM2YM48ePB2D16tVMnz6dzp07IwgCPj4+LF68mJiYGKZOncoTTzyBt7c3y5cv5+6772bdunV07NiRmJgYunfv7hDlnHn++ee59957SUxMJCoqimHDhjn2TZw4kezsbAYMGIBCocDHx4dt27YxcOBA3n33XcaNG4fZbMZoNDJq1Ch69erFyy+/zMSJE1mxYgVt2rThVrvrHls+O4PBQN++fR0utlmzZpGYmNjg+bBYLHTv3p3KykoWLlzoCEWu75wHBwczadIkbrrpJnx9fTly5Aj/+Mc/eOCBB+jSpQuJiYkuIdHOzJ07l6effpo333yTbt261dvO0zWuXr2aSZMmYTabCQoKYt26dY5jT0xMZPny5UydOhWVSsXatWsRBIGoqCj+8Y9/0KdPH1q0aFEndNoTVCoV33zzDVOnTmXGjBloNBq+/vprfH19KSwsdNunS5cujB8/nsTEREJCQhg7dmyT55W4sRFEsb77y78PZWVlBAQEoNVq8ff3/72XIyEhISEhIfEHQ19psoWiOX/CEeCx9weiqbxgqxasK4GOY+DuxeS/PJRwrzNYrCrkz+7FGtqe1K2XkStt9jWLyUq32+OQFaUjfnYH6MoQsNgG9Q1HrMi3yWyigMUkIlPKkQk1IT/5hPAVoygiqDpctxpRRI2eL429KRW9ALhfV85IvyWkyLugxd9F2ROwEkIJ97PJ4earTV6qPxVZGgJbV2IxywhOqESutjqG+Za/cJxOlKoKSAk+yU3FXQkxhtQaRSTEUk6R3J+2FPIwK9FbfdlQ+i9M/m0pK9QTEObF3S/0BHCEcnvpL5J47jE0snIu6PuT1+M9Eq6+RljZdkRNEGfu+Zi/73ofL4tNcHwp6CWiU1xnNmBipXoPzlqlgMA/Zv0DLy+vhp94CQmJGxK9Xk9GRgbx8fEehbzaOb7jSs37r0zAahUd781db439FVfsSnl5OX5+fgB8+OGHbNmyhR9//PE3m1/ij40gCJSUlBAYGOhxn127djFt2rRrKpoi8efF3XttU/Q1yTkoISEhISEh8YfBqtdTvHwFwVMmI6vnS2Z9oWiFKUeJ2T8eUV+GAIinN2I9s40wjc3pJ8OI9eMhFKsmEaNuQfCUKShCnISzcz8i1KpEbBcGAQRBRKGConNeBLercjgFwyniMb7kXf7msiRBELlD3MlisSZnj8YcSlbJZHpoDrPTr27+n8f4Ei/q5vETgcocFSBirJCTf8Kf6AElLsIgQAvy0Pvo2BGagSgTSAtIY0DBgDpOwo7mLFKrupAnxnMAgQxDH0ot0VCoR8RCdlUae9b5IJfJST+UR4DsKveEvIRKsDlPWquTiDh5F96yUpvQZyjDZ+MzZIfV5AvMKzYRjWvesFx7++pKyIggCiKXLl2SKhZLSPzJqC0AymQCPf7S8jdfx4svvsj+/fsxmUxERUXVGz4sISEh8UdGEgclJCQkJCQkbnjsoqAiLJSCBQtQRkcRcNddbttcUAwA6oai6Y5+B7oShylNEEAmVjrEM0EGAjosh9ZScjEY/5EjXcVBp0rEJmskIq5ONlGEqjwV2gJffFpmoVZlO8a+RDRiLdVLREaFIgxnrU8lQqk1mjyLGjjtPDoiMi4RTQcuus4LiAo/NMHl+EYa8Qo2oS9R4h/rmqRcFCEt8AKbgoOwW/Oiq2y5jYrURZwMPkmX4i6EGkJJ8ZVzc9ExUqrGkYLrF3SDppAqv0x+OaUmqEjATzTQMWAPYqkBA3LAlkhfECswqWSo/CwIooWWFcX80PMRKm+6Fx+lD+U7THApx2XsDLktr1cLMYC+xgSSlenkCVrOnDkjiYMSEhK/C//+979/0/mWLFniNp/bokWLGDhw4G+6lhuBp556iqSkpDrbDx48eMM4yhta47UEag4ZMkRyDUr85khhxRISEhISEhI3PNrvviP7H7NQd+yI4cwZfG+9ldiP/+22TdnT81C271QnFE1mNdAx9VFUhlMOt58zogjlV70oyO1OzIKFqBPcFNMw6TC9P4w87dy6+2rRQvVXlLJsoCacN44sbmcPPzOIK0TTKUBDRK8JbPsiDZUIQVZb2HFZwFkMXvnExcVx+62D+PnzeVyxhtOVXxjHz27XDjbBU0TAYhCQq2pcg6IIJpOKq95WJkW1oEImwyIItNW2wccqcDwgHWQCcqtIojaBTgYjfvm3I6+8qe5zEXgKo6YYr0pfRn+/tM7+2rQZlYfKzwodR8O9S20VnQFjVgX5i1zjik/Jr2DBShdLHDIErIhkDDKjDvamX79+bsc3FeoQDRa3+wAEtRxl6I3xBVJC4s/ItYYVS0hISEh4jhRWLCEhISHxP89F7UV2X9nNw50eRilTYrKaWHV6FYNjB9M6oPV1j/XhsQ8REJjaY+p1j38j0Zzn7ffCXFhI8YoVlG35CQDD2bMAVOzZQ+ZDE9B06oTMS0PwlCmU/bgFgMhfNuKtugzGyViB4uUr6HzXneS9+S8y9hbSdqwSucJYuwgxZr2M7KRAEg58gdxdQniLCb55EqtOX3efG5ydhZHkEUYRAziKDJFHWMfP2QOQVcZjSXmX3Ba+3O41loHj2pDz5b9YYxaIC0xkysSHkH3zBI9Yv+MAPVFgdjuX4JKjT0SuERBE1/0XtD1QWURW5BxlcmQLtHI5YcpT/KJWgczm9vMVrXipTvNFkAp1yFqGnI7A2+iP3CsbTbWgalTbQqv13hWk9rW5WGRWkQ6Z2WiMNesTzXrEynwsZjn4hsLdix3CYH10ttQKI0Sgf9c+qKJ93bY3FerIe/9Ig2MChEzvyhf56/9Q176EhISEhISExG+F5ByUkJCQkLih2X1lNzN3z0Rv0ZMQmMBnf/mMR396lPTSdDRyDe8Pfp/BsYPr9HMrAh79kPXp66kwVXB7y9t5+5a3mbpjKgdzDgLQP7I/C29dyOx9s9l6aSsBqgBWjFhBm8A2v/VhXzcXSi8w+cfJaI1ax7H+kY7LLgqa8vIo+2ETWK31N5bJ8B81ivItWxBNJpDLwWLBZ+BABLmMil278R7Qn6qDB4juX4JfrN5FTLMjilB+RYPw0Er8ht1Rt8H+D2Hrqxitbcg3ftjoMYSpnkctu1B3HsBqkJGVFIBuUCWPtQxDK5czUB/L+16+vFx+hK2+PvgK3qyKHUGb3fMbnctTLum7Eqc+TqZKwXpfH77186Wy2kWIKBJgEdDKAQGshjAqL84gWKhilOo0ckGsyeUogCDachQigEwUGGPsTYjo5zJfxdaXieiShtrfDPGDYdirILPdm7ZWKSlZn9fomgt7tKDz2DYoVPI6+9y5D92xqv8OVpd+/Ye49iUk/teQnIMSEhISvz7X6xyUxEEJCQkJiRuWXVd2MXXHVJsAUY29aILz45d6v8Te7L1M6zmNdkHtSCtOY8LmCRgsBm6Lu425A+fy3I7nSMpJcukXqA6kxOBcYAIC1YFoDVpEROSCHF+lLytHriQ+IP5XP96G8KQQh52L2otM2jyJClMFFtEWbhnqFUqRrshRcMJX6cvqUaub5biu1aHYUL+obAOZD4xHNBqrY2Ub+bgiE7ApWvWLiMEdKmjRrcxlmyhSRyjUmvoT8NaWugMUnIPP7sBYFUq+oXHBLkz5PGq5G3FQhKpCJdmhIo+0rAnxFUSREIuVIrkMURCQiyK+Sh9W5uQTX6kFsf7QWdT+NleergTEmnNgFatPjRuWBfgxLzjIZZsgiojVJ8Sii6IqcyoAgYKOMfILCHKdSyVhRAgQvRlm6kKQWNfdV7lzDlbtZbfzywLi8Bn6cv3HVM2uchO9J3Wifd+IOvs8FQefazWX816Xb6jXtITEnwVJHJSQkJD49blecVDW1An37NnDXXfdRVRUFIIgsGHDBsc+k8nErFmz6NKlCz4+PkRFRTFp0iSys7ObOo2EhISExJ+ci9qLvLD7BRchEHD7+O3Db7M3ay/jfxjP1ktbGf/DeAwWW5WH7Ze3M3z9cBdh0N6v1FBaZ95SQ6ljDotoQWvUsuvKrmY7riZTcA72f0j5T5tJ/XwBi7/7P0z75kPBOUxWE8tOLWPP1T0sO7UMk9UEwI7LO9AatQ5hEKBQV+g4LhGRclM568+tv+7lXSi9wKTNk5h3dB6z9sxCb9Yza88s5h2dx6TNk7hQWlcc86RfVqSKlmvWIA8KqqveOaNQIPj62lSwhtyFQEWWGrNBcGhn9lBiu+4oWsFiUmCNvNn9AGHt4JEtoPJp7LQAtZYtyFy2+4SZ2BfohVYut7n2AFEQHMIggEUQ0Jqr2HXLU6Cp/kDX+la49RXoUF2MRRMIfZ+G6F5QVewiDEJdYdBoVWMVbRsnaCsYprMgOAmvoiBgNYZg0UVhNYQ7tpeKXggVYQhCXZF2tLGXW2GwMUSzZ+HZZhEuHMtv8vguc91Ir2kJCQkJCQkJiRuMJuccrKyspGvXrjz66KPcfffdLvuqqqo4duwYr7zyCl27dqWkpITnn3+e0aNHc+RI4/lgJCQkJCQk7Oy+shu9xTPxwI7JamL6rul1thfpi9y2ry00uiMhMIGbo+sRi35t8s/CsuGgK+GKNZZXJsmp0P1M+vFK3t7/IbO73s7WvCSHm/Jk4UnevuVtThWe8mj4b9O/5Z5299TroGrMEXhRe5HJP06mwlQBwLZL20jJT6FIZzvfFaYKJv84uY5Ly5N+kzY8wMeqR1CVlNQrDmYFw9F2VkYeqkABmGWwubdAz3SR6GLXtma5nNOxHTHv/IU2Q/NQqEXKr2jITg4iqm8J/nF6LCaBSzuCiV5+b/0nLbwDjP0EVrq/plxwCIIC+IRBRT4gVouQAuPOGjh5UyXbfLwdgmCkKRwvi8bei76RfXgg+kmMd94FmfsQeo1H2cLflv8w6WNoPxLSNkPyx42vB1DJakojy1sN4V8PLGPEV7dSJJocwmDlhRfc9k33KSHBueJy9Y9cWSktrWEeze+MWJlPeuQ5br73Acc2faWJc4dysVpE5EYLl04WohCg9HQRh1bYqjfL5ALt+kTgFdx0B5KAwLCWw3i408ONtm2o0IkpO9uWU7EiH4teV2e/TOOFMioSuY8PqlatmrxOCQmJGkxGA8c2baTHqDEoVerfezkSEhIS/5M0WRwcMWIEI0aMcLsvICCArVu3umz76KOP6NOnD5cvXyYuLu7aVikhISEh8afj4U4Pc7LwJFsvbW288a+EQlCQXprOo1sebbY8ZZ6G4JrTk5GtHoOAngylgqcirehkNrFpm483KRorhbkHQagJs956aSsp+SkU6go9WkuZqYz3Dr/Hh7d+WGctoig6chbaRUd7zsKlJ5eyYsQK9lzdg9aodYwnIjpCl8HVpeUsDu6+srvRfmWChZ/2f85d4Dak+GoIvPqwnApvgfQIeO4HK4vulJHcUcaGfiJvrLIQ46TfXY2J4eRNN+FdWYVimxXfaD3FaT4gCmQdDEJXXElFlgajToN243doN36HoFQQPGUKipAQ18kD4wAPxEGVD5iwVem9ezF88ySc2WgTIbeHYqpU8M+gPFISNBTJZUSawll64Z+uY2RC8cGT1Q86wt7jtJjZy1Z99+bnq0/gCNg3H/RlIFrsml2j7LvQmf8u+Tv5mgBkKtvxiJa6X7xbCTn4oCdOVgrIiRUL6W4cQbIynTxBS6Y8/5rEQQAufEGl+i6CQsPBYsK45WPOH45Eb4pmmL+SFt5OH1XP1JzzslOFlAHBEzt6NE1omYiohQC1P691n4j5zDnMQFZFFkfzjnJn5/vwad225jXgczOqxY3nQ6zY+iZiZcOuxjZbfpQEQgmJ6yA9+QD7vvgc/9AwOg4c2mzjbty4kRdffBG1Ws3KlSvp0qVLs42dmZlJt27dKC0tbbYxAYYMGcK0adMYO3Zsk/otWLCA8ePHExFRNz1DbZYvX86GDRtcIgT/V9i1axd6vZ7hw4f/3kvh8ccfZ8KECQwd2rRrOjs7mwceeIC9e/c22nbkyJHMnz+f9u3bX+syJf5E/OrVirVaLYIgEBgY6Ha/wWDAYKi5i11WVua2nYSEhITEnwulTMk/B/yT3Vd2Y7Qaf5c1mEVb5dX6HHBNxblISH2Cm12AFE99hwybI2m3ty381I49/NSdo85TYRBAjpy9WXuZtWeWy1o+SvkIlUyFzmKbf+ulrRzOPYzWoHU5H/8d9l9GMYot1i1YZDaHVe18kO5cWnbhd9ulbS6hzo5+IvQ5a2XETvefCbKCbcJgVbVx7FAHgWdj5Wiro32rNLb9c1ZaiKp2EF6Jja3+GUOrS5coPusUBisKNY8FC8XLl9t+VanwHzmyrjjoKWM/gdKt0O9pWz7Ae5dSPPUcJYeKEENb0/JxFf9nMjpCie2Owcao42azhztXu0z1hgi81LmNjvOauRWZWf0B8GnzHjJVEYLc4NKmlZDDLvUMAJLohhkFvcQSCsXxjDL25KT8MvKmZ6lx0I8Uyr+cDH/9Br55Et8zG7k/IogdunlgbFxwFI0Nh5LbeWG9FavWDBSR/elDLvtuAi7zOTGbNvDalcVsvbSV7eYfmctzjY4rKDSN+o/zP11MwG23oYiKdGz7IzkKS3KyMOpc3ZFlhQWYDDZnt1KtwT/U9blSeXkRFBn9m61R4n+btIM2ESQtaV+zioOffvopr776Kg8++GCzjXmjsmDBAoYMGeKROPi/zK5duygtLa1XHDSbzSgUv7pEAsCSJUuuaQ1RUVEeCYMAmzdvvqa1Sfw5+VWvfL1ez6xZs3jwwQfrTX74r3/9i3/+859u90lISEhI/HkxWU1M/nFyswiDVmMIokWNIDc4HFK1kVllJJQlkO6fjlXmKjjU54BrCk0JwRUR2d0mngeLb0V9eQcPaMv53seHdJXSIQiKDeXh8xArVpe1FOoKkVllxJfG1zkPzvkZ7edj26FtaDI0tI9uzxnVmTrCYIhXCG/f8jZKmdJlXqVMydu3vO04fpd+VpGAKpsTUFGP7nM0QaDCu+b4RUFA611TSMMqEzCp1Rzs04bWuTbhKjcyovpnJCndugEgs1ppn5aGxukmpd2lqIiOJu7TT1AnJNSZX1DXrZrrDqFFPCQ+7+IWLbkcTlWllr33lFKly2FrYIBHYzWEubCQ4pWbkFnuR61IJ+ub8yhU4ci9ZbQY5Iu34ryjbdbBQAxlSg7F/oXM1jVild0xKFcV49PmPUSLGqsxHJ+cvo42/UgFwIhNwJYh0NXS8rrWbihT4Jd2GN0rXW05E1GCUEU/74WU8uZ1jd1Unvn+MVKDbIK0zlzVbOOWb9hAuRsHzh/BUViSk8Vn0568pr6PLlgsCYQS10RlaQlHN2/EarbdoMs8fgyAjNSj7PrcJqjIFAp6jRqLd0DgNc0xdepU9u7dy9mzZ1m0aBHx8fGkpaVhNBqJjY1l6dKlDiFt8eLFfPDBB/j6+jJu3DheffVV7DU9J0yYUG8/Zw4fPsysWbMoKyvDYrEwe/Zs7rvvPgoKCpgwYQI5OTkIgkDPnj1ZtmxZg2vfvn07b731FiUlJYwZM4b3338fQRDIzc1l6tSpZGZmotPpGDNmDHPmzOGNN95wuM28vLwczsDS0lIWLFgA2KL9jhw5wvLqm2N2cnNzefDBBykrK0Ov1zN06FAWLlyIrDqS4Z133mHVqlXIZDK8vLzYsWMH3t7erFy5ko8++giTyYSvry+LFi2ia9eunDx5kr/97W9UVVWh1+t56KGHePllW2Eqk8nEK6+8wo4dOzAajbRr147FixcTFORaOMuZn376iZdeegmz2UxQUBCffPIJnTp1Ij09nSlTplBRUYHVamXMmDHce++9fPrpp1gsFnbt2sXdd9/NpEmT6NatG08++SRbt27l/vvvZ8GCBRw+fJjY6puKs2fPxmKx8M477zBz5kx2796NyWTC39+f//73vw268tq1a8eaNWvo1asXYHNlbty4kW+//dbFBTplyhRkMhnnz58nPz+fs2fP8tprr7F69WqCgoL4y1/+wqpVq8jMzKzjShUEgbfeeosNGzZQUFDAq6++yiOPPAJAq1at2LBhA926dWPevHmsXbsWk8mEUqlk4cKF9O/f39Fu0qRJbN26ldzcXB577DHH89JQP4n/LX41cdBkMnH//fcjiiKffPJJve1eeuklpk+vyQ9VVlbmeCFKSEhISPx5WXV6Feml6dc9Tu0canaHVG2iq6LpXNKZKkUVV3yv1Nl/W9xtPNzpYY8r8dbGk1BarVHL+nPr2XB+A1qjlqSYvvTUR3IaI+lqlU24clde9xpxdu3ZHYeNnQeocQQGZgVSRBEBJQGILeoWiinSFfHi3hfpHNqZW+NupXVAa6x6PXlL/sMczXaKlK7CIIAoE9D6iCy6U8bz37kXCEceFkmPtHKog+AQBEWnyhuCKNI7XYXVrx3nAuUgio6iG6IgcK59OxAEZBYLcZcvu4qD1fjddivy4GC3x68M9aLFzF715qMDm4CoDPUiLeMIj+56ijKZgcP7vubJq5dZNFpGcmQVbXVt6FKpxiATsCAQ61QApCGKV64k9In7HY5Gc0EBxSs+t1V2lgkgyDBVKDDp5OTt0BJ/R03fq6ZQ8q1BFJWUAhCDDG9AVdERmSECQW5CUNj2WUUZXqKfR2u6VnKSnL/01bjPZAFqfDwwCAkqz1yLnhQ/0Rq0+FYqUJpl+Bo9E4Cvh6qTJ7FUVgI3rpOw8Ir7StOeUNttKCHhKZWlJRzbtBGL2YQgCDU3xaxWjm3eiCiKyBVKOgwYdM3i4MKFCzlx4oRDnCkoKCAszPYeNHfuXF5//XU+/fRTTp06xeuvv05KSgoRERG89tprLuMsWLDAbT9nSktL+etf/8rmzZuJjIyksLCQHj16MGDAAL766ivi4+P5+eefASgurpUw1w2nT5/mwIEDmEwmBg0axNq1a3nooYeYPHkys2fPZvDgwZjNZu68807WrVvHq6++ymeffcaXX35Jt+qbY56GDAcGBvL999/j6+uLxWJhzJgxfPXVV4wfP54VK1awfv169u3bR0BAACUlJajVavbv38/atWvZs2cParWavXv38tBDD/HLL7/QqlUrtm/fjlqtRqfTMWDAAIYNG0a/fv1477338PHx4dChQwC8+eabvPzyy/z73/92u7b8/Hweeughdu3aRZcuXVi9ejX33nsvv/zyCx999BF33nknL730kuO8BgcH89RTT7mIopmZmWi1WhITE3nnnXcAKC8v55NPPuHtt9/GYDCwbNkykpJsRe1mzZrF+++/D8AXX3zB888/z5YtW+o9f1OmTGH58uUOcXDZsmXMnDnTbdujR4+yb98+/Pz82LRpE+vXryclJQVfX18effTRBp8ntVrNoUOHOHv2LL1792bixIl13IcTJ0506C5JSUlMmTKFs2fPOvaXlpZy8OBBCgsLadOmDY888gjR0dGN9pP43+FXEQftwuClS5fYsWNHgyWT1Wo1arWUWFZCQkJCwpXBsYNZenIpZUatB2VD6qd2DjV3OdUAYipibD8rY9yKYqIoYrFa6g0DboxGQ2kR6B/Vn2/Tv6XSbBMMDuQmc8BXCaLTn+tmEgbro6HzoLaoSdAm4C335jbdbRw+fxiAFlURdCmy5WoSBZH0gHQMcgMiItsvb2f75e0sP7WcFSNWELrnFz4//Cl7bnUVX+xFVWxjCCR3FNicIzI6ue6zr7DanIXPxsptjkFnYbDaefjU9yXovH9m/80DKPf3R6x2OYgyGYgiflotbU8dYG/7ckYeto15ORRWD5Xx0E4rrFmL75i7WJfznVshWBnq5fjdqtdTvHwFwVMmI9PUhAZf1F7ksf3PUYFNfNynucTJx0HrIxBlDGNR5rVFTpT98AOBY4Y4xEFNx47Er/+aq89Pw5iZCZZq0dJiwaqMwGit+Rz2SZ9pZBMKwC3ImIu3bUfhPfXO94B+IRVCOZ+0vkpcVv03fN3haUXia0URqKkj1F4tv8KCza/wzJfljjU0lhcQIKJAxqBjNqdbkCoUfmXTW84L/3B5XMdJWHAOzv1YE5ZuL0LTboQtlBwoKSnhxIkTVFZW4uPjw0033dSgy8YdDY1hDx2WkPgtCW/VmofnLuD7ef+iJCcLsboSvWi1IggCwVEx3DX9JUJjr8+57MyaNWtYuXIler0evV5PaKjtfXLHjh0MHz7c4QZ84okneOONNxrt58yBAwe4ePFinbz9aWlp9OvXj/nz5zNjxgwGDRrkUS68SZMmoVQqUSqVPPzww2zbto0xY8awfft28vJqcqVWVFSQlpZ2TefDjtVqZdasWezbtw9RFMnPz6dz586MHz+eH374gaeeeoqAAJsD3v6+sXHjRo4fP07fvjXO8+LiYnQ6HTqdjqeffprU1FRkMhlXrlwhNTWVfv36sWHDBrRaLevXrwfAaDTSqoGbJsnJyXTp0sWRK3LChAk888wzZGVlMWjQIF544QUqKioYPHgww4YNq3cc+3m08/TTT9OnTx9ee+011q1bR58+fWjZ0natbd26lUWLFlFeXo7Vam1UzJ00aRLdu3fngw8+ICsri3PnztVbv+G+++7Dz892Q2779u0ujx977DF27txZ7zwTJkwAoEOHDigUCnJzc4mJiXFpk5KSwltvvUVRUREKhYK0tDR0Oh1eXrbPMw89ZEu5ERoaSuvWrcnIyCA6OrrRfhL/OzS7OGgXBtPT09m5cych15qnR0JCQkLiT03rgNasGLHCkaPP4yoL1dhDia3G8FrbbY81WGmvC0UQbYO20LWw/axq4Vbo2nFlB8PXD6dYb/sg2NQ8hA2G0laH4PZs0ZMD2QfqdrYLgs7C4DU4CJWCEpNoctlmF/w8OQ8as4a22rbIkXMo+RCiKNiMaqItJFtAwIKFKz5XMNTKXWc/X+8dakvPdJEN/USqNAJWWfXxa4Jt50UAmVXEWw+90t3LwmYZLLpThtanbni1q/OwjGHbtvPt3ePqnM/OV0/x+t2VVHjLSY+0Mu6Alf+bLMeiEDjZSuCD0935b8Eyj4Tg8p9/pmDBApTRUQTcdZdtY8E5die/g9ZSgT0ln3P4s6f5Bd0hvPY2mo41hTiMmZlY884TeV8il969CIBFJkfRrS3quBnkO0Xmz7mG+Z6tzMJw4EdUN0eDezOlW6qS/u2RKHe92IVaY2YmlspKIoHnokdi1r7XpHEifmcdzO4iBFwqlXP1qEtBG/bNxzJ5E5sOXeDYMVu4pSAIiKLIzp076dGjB6NGjUIub9j9aLFY2LRpE8eOHUMQBLdjVJaW/JqHLCFRL6GxLXnwzff5+PG6+QAffPN9NL6+bnpdG/v27WPhwoUcPHiQ8PBwvvvuO1599VW3bQWnvzme9hNFkcTERA4ccPP3HUhNTWXbtm188803vPLKK6SkpDT6+q29JnuYc1JSEhpN439fFAoFFkvNTRW93v0b4Lx588jPzyc5ORmNRsP06dPrbWtHFEUmT57M22+/XWffc889R2hoKCkpKSgUCu6++27HeKIosmjRIu644446/ZrKPffcw4ABA9i6dSsfffQRCxYsqDf/nre3tyNMGiA6OppBgwbx5Zdf8sknnzjE4MuXL/Pss89y+PBh2rRpw4kTJxg0aFCD64iJiaFXr15s3LiRX375hYcffrjefIK+DVzTQiOf95yfc7lcjrk6JN+O0Wjk7rvvZufOnfTu3ZuysjICAgIwGAwOkc/dGJ70k/jfockZpCsqKkhNTSU1NRWAjIwMUlNTuXz5MiaTiXvvvZcjR46wevVqLBYLubm55ObmYjT+PsnkJSQkJCT+uLQJbMOy4ctICEzwSBiUWWW0L20PhjAqL7xAVeZU9NnjXdros8dTlTkVLv2VttoE2pW1cwhbYBOqEsps29tq26Ix13xYKtK7r8TrCSaridn7ZtcRBqEmBPd00Wlui7vNo/EQBLdVfBtcg2iqk//PLvh5ch60ai3bo7dTprTlZbMb9uw/y5RlbI/ejlatpTb287Wn+DDRxfDGKgveetv6+2f7snhrPH3O2twh3nrb/qh6bshv7i2Q3FHmIgwKTqfC5jyUsbm3QEF4mNtz9fFghaOgSXIHgZcekWOp/i5mlgtMuynFUSnbLmxmaDPcrueXnd/wXV+B4i22Lx6m3FMs+2IUNx/fwO2yQMc5Bdfw52vFog50/G7MzOTC8BFkPj6dyx8lI/OPQxYQh9IvGnne9eczBAhN3QfA6TM5Teon6twLS6ldEjndqSPmBr78Cl5Nc785zsM995J5z72YX2uaMAgwsay8yX1+FQrO2YRBfXVBnjPfwYddbT8B9GVY/ns7l45tc3QRna7vY8eO8cMPPzQ6jV0YtPe3Wq2OcY4dO8amTZswS5/fJX5Hrp455XJtg+1avXr2l2adp6SkBD8/P0JCQjAajSxevNixb+jQofz000/k59tudCxdutSjfs4MGDCAjIwMtm2rec2mpqZiNBrJyMjA19eX+++/n0WLFnHu3DkqKioaXO+qVaswmUzodDrWrFnDsGHD8PX1ZejQocydO9fRLjs7m6tXrwLg7++PVlvzt7lt27YcOXIEi8VCVVWVw63n7txERESg0WjIzc1l3bp1jn2jR4/m008/dYxbWlqKxWJh9OjRrFq1isuXbWkJrFYrR44ccYwXExPjcKBt3brVMd7YsWOZP38+VVW2nK9VVVX88kv9z3W/fv04efIkp06dAmxhvtHR0URHR5Oenk6LFi2YNGkS7777riMsuPZ5qI/nn3+e//u//6O0tNThOtRqtSiVSiIjIxFFkY8++qjRcQAeeeQRPvvsMz7//PNGw4Pt3Hrrraxfv56KigpEUeSzzz7zqF996PV6jEYjcXFxACxatOhX7Sfxx6TJzsEjR464lNu2x59PnjyZ119/ne++s31wseczsLNz506GDBly7SuVkJCQkPhTsi9rn8e5B+358iqs6TSWDaVY9GZryAkGlLXGz+SHrPp+mQwZIiJlyjKSwpMoV7kXDOqrxFsfq06vcohNzmM4hxhvv7ydqd2nkpqfSpHefeEUW2ORW/VmjvuHUmRq/EOuMyarq3PQLvj1y+/n0XnQomJncDqj83rUGlmgtIMP5UVetC+NqlPQRBBF+pwVGXnYti2mCOastHAkQWDk4RIs1iSel8HmHJFeVzREFdWfr6zXZSXfCWoqLDqb81AEf1lbSqp0INejUBQ6nIeXE2xhNZEqFSMnTeLnn3/mypUrBOlacNHvavXiBERnzU7ARb6tXZDGnJ6M/ut3qaQnl5TlzGh/lAovORcv7OHVt6fzfsD3bPPXsNSnBf+5cpaUiBYUyaglZl57sLzv5sucUJnxaxtBxNUztvF8wvG9/Vp8gY3zZZ9EliuHANDKkMO8k98T3vnax1OFaDgZ0RbvyipaXbpUZ7/gE453v2c8GsuUnY0qup2r6+6PzrkfbY5BByJUFuC4KkULKksl7bnIgXqsnCkpKQwaNKjeEOPi4mKHMFgfx44dY1BCq6avX0KimUg/ZHPaRXfoxKAJj7J71VKy086Qnryftr36NtLbc4YPH86qVato3749ISEhDBs2jKysLAC6dOnCyy+/zM0334yfnx/Dhw93hNE21M+ZoKAgNm3axMyZM5kxYwYmk4m4uDg2bNjArl27mDdvnsOp9d577znGr4+OHTty8803U1xczJgxYxg/3nYTdPXq1UyfPp3OnTsjCAI+Pj4sXryYmJgYpk6dyhNPPIG3tzfLly/n7rvvZt26dXTs2JGYmBi6d+/uEOWcef7557n33ntJTEwkKirKJTx34sSJZGdnM2DAABQKBT4+Pmzbto2BAwfy7rvvMm7cOIf7bNSoUfTq1YuXX36ZiRMnsmLFCtq0acOtt97qGG/WrFkYDAb69u3rcMrNmjWLxMREt+chLCyM1atXM2nSJEdBknXr1iEIAl9//TWrVq1CpVJhtVodeSDHjRvHypUr6datm6MgiTv69etHQEAATz75pGMtXbp0Yfz48SQmJhISEsLYsWMbfJ7sjBkzhr/97W8kJCTQ0cn13xB33nknycnJdOvWjcDAQAYPHkxgYKBHfd3h7+/PnDlz6NOnD6GhoY5r5tfqJ/HHRBBr3475nbFbVbVabYO5CiUkJCQk/hxc1F5k0uZJlBm0rgKOE/ZKw8G6YKL0UWRpCtla6j6nizN+rT+gU2UYHbQdXN1diHwf9z0mucltP3sY8I93/4hG4Vl4qP04KkwVWESLYwy7k1AuyPFV+pIYmsjB7IN13IXOBMrUTEq4h75tRjFx80RH1eHrQWlRctfluxo8D/biLrGyEm5TnXdENtt/bje2RYmFQaoMDoUdcuQsFBAIqBD56BMzKrO7yZVgNtsGksnw6tkT/ZnTiBXuBZ+EA/u5JCth0ncPUibq6F7UgT35Uxz7w6Le5e0v84kpgnMJCVjkcm577lkCbrsNq9XKvv372HxpM5vNm+q9ppyxC8HvDHoHZeEFxCW3IxjLOFngw1+7BFOltlVIFkSRIINIidpWKEUuisgAE9QJAW+ji+WjzJcan7weXqeKy1j5OPok5uWbEBQafIa+fM3jNcRKQy6L1d6Ox0szt9C+1f2N9qvY+rLbsOItI+9D6y8j6upVBu7bX2e/LCDO42Op2PoyUXNfwarX1cnh11SUfQxsNHQCwFcRxKjYv3o0f3OFTrda/zVeiYm23IJfP1btFKz7PiAicJq2rGcEVup3X/bv35+//OUvbvft3r2bXbt21XFlOSMIAgm+anIO7WvysQA8/K8FtGjd9pr6SvxvodfrycjIID4+3qOQVzvHfvwOs9FIr7vGIZPJsVotHPn+WxQqFT1GjP4VV+xKeXm5I/fbhx9+yJYtW/jxxx9/s/klfnuysrLo1asX586dczz3vzX2604URWbMmIFOp2uw0KuEhLv32qboa79atWIJCQkJCYnmwJ57cNLG8ZThmufGni/P3+BPpD7SIZJF6IPoH/oNWOVYrF6cKB2KHls4rSbqC2SqfAS5gVijNx21tru4IqLDyScgEKoPJcfHfRilvbrvQ5seYu6gubQLaufxcdhzKA5rOYy3b3nbUeDEV+nL2LZjWXF6RaNjlVoNLExbw226PFaMWMHEHyc22qcxQvWhLsdf+zzIBTleshAqgZZym6spX/TliDGWXsortBAqaCkvQYVN/XMuaCIi1qlAbJbLOde+He3SzkGgEatGRKYXUBSB5dxBgmL0FKf5gCiAIBLcvpKKLDXGciW61FTa3Hor76d0Yk/xIbr5t2aPT82x/O0HJQmtetDi3y/g9e576I4do2LrNgJuuw2ZTMaggYPo078PB1fvokSsQnSJScYlhN0u4r59y9soizJg2XAEk020PNxGRoWXk5gqCJSoaxyCFkGgdj1jQRTr5Em8Fl63FxLJ6g+396cqyX01x+agxeVUSBjgeKx9bioXyrQsPXcVUW1zmk4svUKg1UzO0cMIJjNytS9h99xtW+KVcrLV3oiCHKNMRpmvzRWbGxlJSnWkicxqpX1aGhqDweOQYl3qKsTKfLKee67JxyT4hCPUEvblaj1Boi3npslqZNOV/6CUqer07XopF1+D2eNCJ01GrrTlGPwwyeYYFJ3Ef0GGTvDhW+vwBoVBwBHS547KykpHnjLBqEew1K28LZPJ0FnqOokkJH4raguAMpmcPmPu/c3X8eKLL7J//35MJhNRUVH1hg9L/G9gr+48d+7c300YBFsxk8zMTPR6PYmJiXWqYEtINDeSOCghISEhccPTJrANq8Z+xa4ru2jp35JZe2aht+hp59WODlc7YK2uZOicL69dRUx1gQwr5wUTetEmDspU+ci9sgGIKa4R9YrURZwMPkmX4i6EGkKJqoyqVxy0k16azoRNE/jizi88qlrcJrANK0euZNeVXTzc6WGUMiXvDHqHLqe7MCR2CCIiG85voMxY1qBz0M72y9vZe3Vvo+08IbrSVpq1RFPC8aDjDKwciKJMQS+hF9/zPb5KX966ZQ6T0y9SZPWh1OrFL5YI1JjJt/oiiuCDkXCZLVdSi6oW3FTYBVGoKWiS3NHgqEB8NSaGkzfdhEZWiebp8zXreM9Ey25FKNQiPi30XN0XQvTgKvzCywjtJCdzWzD5H8yj6tBhqg5cohNRXAjMge41x6K49SHKHxqL6K2m1crPKV62DEFVU6Xanv+xhFrCINTJbWnPBzl732zeUcSidAr3nFhWzim1im0+3g7Br3bosFwUsQoCVsHmLAwxWylSNDnlc6MIcvdVuJuDLxJuASd36vtr97N02zu48z364RTiXJ0yTx1YzknVYayCCGJNOL0oyDjXvh0IAjKLlZYFFWhyLiLzDvNoXYIb4c6jfg2EYDunwd905T+UGPPqtDGVX8Wq+xVz8VlMtuIjFfnUcQ6KVrzEcsaxpVHnYEP4+Pg4hEHfC6fqbVd6TaPbUEnJ6iX+R/j3v3+9my/uWLJkidt8dosWLWLgwIG/6VpuBJ566ilHzkBnDh48+KsUxXjjjTdcKlI3Rn5+vtsiKrfffjvvvdf0/Ld2vv3222vuKyFxLUjioISEhITEH4L4gHhHVeAVt65gy+4ttAtsx4GwAyjzlAjV/6AmX165opwDwWcovmzLTaTBRNeKaEJKEihRlTgq81qxUqwuJroymiJ1EfmafIxyz778G63GJlUtdj4OsFUxfqTzI47HK0as4OHND1NhqklIHqqwohFAL0Kh2VVYMlqbR6Qw+ZoY0ncIsV1i2ZO1h4c6PMThpMPI5DIS/BIYEjuE+IB4dg7dSeX+xZwXo5lmeQZvwUQneR5yQcT+D2QICLQtr6lgnOV9GaVB76hAfCU2FoCsmGjaUCMOthhYitxga+MTYaTtXXnI1TZhSqaw0PK2Ii5tS+Pk+jIev22W22N5tbQFfHwQgJ0zhxD/+OMu+93lf2wIEZGtl7bSpfvzPNJxjCPcUwm8XVhMikZDkbx2gRSREIuVf+fm8dfIFmjlcoZVVvFWQTH/8A3jSvMV2vzN8TIbGtxf25EXIvoxztiHbcqTaIUaQVaU2ZI7Bli9GWbuQlDf26nY+rLNOecJnrZrZH314c412Bhhzz6Kwt8Lc5kOUW57ks0lpZR+/rnngyR9bKtK7IwgczgIBSCRdLKI4AC96h0mtvo15o4uXbqwc+dOZG4cg83BrY8+RVBk9K8ytoTE/zqPP/44j9f6u/Vn5kZ3zIWHhzuKtUpI/JGRxEEJCQkJiT8cQUIQlecrOWI5ghKlIwS2NkdDj1LhVYRPm/cQLWoCLUoSCnogQ0aIIcSlrb1SrwULO6N2uq246w6raHUpVnE9mEwmsk5k8flfPmfjxY1sOL8BpbWElyNrwqnn5GjqCITNwQnvE3xn/Y53At7hkSCbWHnLLbcAMIABWPV6Cj9dTMuJE5GVJsEvxwFbYZdNxo7cq0rBKCgRnAqaCFgxUcaO6GSUBgOPHk4kL05GXhzkRkUAkBsYjXChJwCCzEpr/8PI9eUozCLeeitytdWRrk+QgUJtJbCLN7ozngk8lYa6SQ4Hxw5m6cmlLvkfARe3pnOxGHs+yCEtb4OOE+DDJExlckx4sTAogECThgCT6/Wnk+vJUeazJDCAz7Lz2O/jxcPacpTAvIp8Ps8L5xpNX24RvEMab3SNNEdgaZDoy2hjL1aq99TZN9rYC3V12L88sBWCyqdOmxsJhcXVzRf53ruoW7dG7uODqlWrOu2NmZkeiYNyn+rjbjcC9s23VSsWLYAAPmFQYXMxisjQoSKN1g2O17dv/QUbgoOD6dGjB6n7m8d5XJuohA6/yrjXQklJCSdOnKCyshIfHx9uuukmR6GWhvZJSEhISEj8mZDEQQkJCQmJPxyRkZE8+eSTrFq7Cm2J1lFh145dLFRZbc4fmcqW46wcKCyLI9wQDlDHaVi7Mm9CYALPdHuGf6f+m/Ol592G+ja1anFDnD59mh07dnB34N3M7D2Te9rdw/6La6FkqaPN5I4P8Nm5bZQaSj0KPfYUhzvudBcXJ6Od8p9/pmDBApTRUfj1fQ6v04869gUKOoyCmtohkKIoMG7jNvy6WuiQG8DxPu2wyuXVFUxsba0IZGV1BAQEwcKJ7pn4+to+nvQ/VIy33rnYigAdRxM4dR5ed9zt0XH5VJkxZlW4bIshnM+7/5dX979GgbWQxIRuPN7lcSZsmoBZNKOUKVk1chVLTi5x5INcMWIF8b4x8PVjmMrk5Bn/A8DDeVDfM/9Ym9fY6ltAZ1Q8kp9jK95iBcEkMGR3PmFftkdQVecOTF0DyZ9issZQYn7Bo2NzRpM4rsl97LxIJfn1XEtVwNVaBW/Mbf1hV9PnyZWV2mxv9ryO1T9zZaW0tNpCib16/7pumdAHhiLLSqH+Wtg1dL2Ui6n8qss2hUXEx+haqEjdurWtkEhzEdYOHtkCy4bbqhZ3HA1DZsEntryPAlaOt36Goov1FyLq3r17oyLXqFGj0BcXciXzTPOt/QbCYrGwadMmjh07hiAIjhyLO3fupHt3Wx6ClJSUOvt69OjBqFGjkMubUb2XkJCQkJC4wZHEQQkJCQmJPyTh4eH87a9/45133nHZLiJSrComxBhCVGUUxZpiErQJCKJAoDqQUGNovWPuityFSW5yFKFYM2oNGoWGm6NvZsQ3IxyVhe24FKuQXVuIozO//PKL42d0tBaNqZiBweGcr05zZ7HIyT6Rg5+iBLnCet0OwgBVgCO/ocMdFzvEbduyH7cAoF3+Pv5dTtJGsLBTNZ1KNCQJvblKDC6KT3UJ45LgcEYnZwOltCj5mf03D6Dc3x8cgq4MEPHy0tKx0258fGocm2aFc+VkAcE3HO5eTNWeA0RXFLBk61x0CjWX/cJ5r9cER9u3E6z4/edD4p/5O8qlp3FXMkIFzMVWyCJkTFe8Qvz56q6vmH90Pn/v+XcSghJc8kHGmvyoeHc8voZtiDSeXxLA16ImQIR+kY9SfvQD/OP0WEwCl7aHYixTYMw4hd+tt1YvaAicehuxSgbuKjo3E/Yqx3bciX/OxCCjXS3xPUKhRhYQB9CkohwZclu7FmIAfY0JJCvTyRO0ZMrzHeLgr01AxRcQ1QpPUgb6K0OxqlwLjwg+4Qherq5Va5XSIUALajnKUNccWJZK91W3a+PSLrwDPLYV09HtiB3HQ84FsNZcd907j6BCkc/Js6cok+kIpgQ1RgyoaNXjNkaNGtXofHK5nMGDBrHqx288Wt8fDbswCCCKoktl5pSUFMfvtfcdO3aMK1eu0LlzZ8lJKCEhISHxp0ESByUkJCQk/rBcunTJ5bHdMZgWmIafyQ+LYEFj1tBW2xY58jrCXu1+PQp7kBqaikFucBShmHPLHF7e93IdYdDez1GsYtA7TRYIKyoqOHjwoKOgyoULFwBITz9HRYUtEbUgsxIdrUGl0lNUGIcxswUPJURiNHmxSn6R/Pp1nUaZnDiZM8VnXN1x1aHR5sJCilesQDTZlKrKfftQ+ZmI6ZhKJd4cpAdWmU00yiHSMaYfFbQki0tEU44fV2NjiM62FYAJKCtj2LbtfHt3XZdb125bUCpdFRuF2fn5Em0FGr55krJjtlyRbTvE0eKFF9g7f4lLv/Bj+4nWZuF76CD4/qXR8yA32Y4jISiBj4d97NjunA9Sf+YM+d+fRjNYQPTQUOSFwIqsbFplvE/mL36YveLxHj8b+aUv4dgxyn7eWiMOVrvFZEsmQ8Mp/a6L7heS2damp+PxC0dWozEbebNfXbdoDDK+wE1yxFxfGPqy42HF1pc9EghDrf4EWX3pYolDhsAoY09Oyi8j59pEbtHiXuE71XEyQd06cPO9CbYNBefgmyeQK62o/CwYPXzNOLsYq5L+zdZ+GsbwWJ12JevzgJrCJcETO6IIrBEQzUVmBJ/wJlc2NhFD3s5E2HmyesuHNTu/0tMRfzoygMIuBXRLd3r+bp4Kv7PrzbkYSUlOFkZd/V5NlZdXs+cnLC4udgiD7lBrygkPz0Cl1GM0acjPj8egr6lKWlBQwM6dOyUn4Q2AuVhPVUo+lgojcl8V3t3DUQR7llZCQkJCQsJzJHFQQkJCQuIPy5kztnC4uLg4QrqGsGvbLgJ0AURVRnE0/Kij3fbo7QzIG4CP2adObkJnwS+qKoqz5rMY5AZHmK3erGdvlmteLud8dI2F4zZEeXk5SUlJWCwWBKdiFqIouoTahoVlolLpKShoCUB2dnsqK0OIbGEk3+tqnQq7jSEg4K/yZ1jLYUzpPMXhjnPOmWguKKB4xeeIRmP1+AK+0QZkCijHhyS6Y0GB4OQ6E7BSgQ+n6IBcMNOXYyiUrkpXQXgYtvham7PQ7jQsKwsnJOQqiWfL8a4yO3IO2iNQq88MnNlIUPRYNDNnEPzIIwhyOfEvvQDLayquCkeSAbhy/hhx3RoXBxvCVKhDNFiQ+ccS/sF6shfOIailZ06wN/MLibeaEQUr8aOqEJ5cjtCiAy3bJVC1Zg6G4Pa2hhaTrQhFuxEo/7oK9Y/fszWpC1bkWBUWbvW6/i/CpwuyyFaHY5b5uWzP8wrkwfSdPJ26no+73eOyz9vDsQWFxqMA984W1wIZMgS6WmzXtBkLp+RX6GyJReFpMkZDudvNVd4RFOYHoDljSyvgYw6ge3BNKLCpUgZNNPp693uGMR62LV5ZN0zX9/Y5HouodsT8TI/ahZ4MI1dsg0CubcP5NNDanpHmEt5Gz/g//ENt7s6ywgJMBr3LfqVa49jvPGdJThafTXuy0fEfXbC43nVei7h48uRJt20FwUqbtslERJwHBMfbUMuWx8nNbcuF830RRVex+tixY4iiyJgxnl4BntOcOQ+dx5LJZAiCgMVi+cPmUhQtVko2XKDqcK7tj0D1342yrZfw7h1B0Ng2CPLrc89v3LiRF198EbVazcqVK+nSpUvzLB7IzMykW7dulJaWNtuYYLuJeN999yGKIlOnTuWRR5r2ueOPgNFo5O677+bSpUsMGjToN68WfaNw6tQp7rzzTjIzM8nOzuaBBx5g717b51FPr91du3Yxbdo0UlNT64whIVEbSRyUkJCQkPjDEhkZSVhYGAMGDGDF6RVsa7GNdtp2WARbBU67iFeuKmdH1A7uunxXnTHsbfQyPZl+mY5CJHJBjo/Ch1CvUHyVvujMOkfxihCvEIeTsLFw3MbW/+STT/LVV19RVFTkCG2zR7hpNGUEBOSRn9ea/DwoKYkCoLIyGID4vE4ovAI4FZqOQeHkonJV1ByoZCqMViP+Kn8Xl6A7UVPTsSOxS/7L1eemYtVqAZHiNB+8go1ExBbwpLCGrxhFEUGI1c4vERmCaCVUKOI+6yaCTSVcOh6KyenjxpWYGABCCwsZWHKQ5A69yLZGkZndAbPGQO+qEvwraiqouhyGIAeNP5p7XqDq+/2IJhOCXE6sWMWSne+jQ46XxUCUroScIFg4Fj7K9PjpqIOpUEfe+0dctsla/g3PStVAtNkMMptoKlir4PxPIICwfAQ+uhJ8ouRgegDTmhewnD9I1vc/Ef3gvzhbMQwrhQCIntoUGyHu1DKs/u2QKdVAO8f2zxNH0bI8H596XHi/FRmyfI4oL+AramhrjfCoj2hxb7G0yDWIIhzffgVEkCsEWj61h+BgEePJg1x9dQM+Q5tz9Z7hqYjqwOh5KZjN2d0pMVa7F+d97LKvIeHNU/xDw2jRui2A46cnNCTqedLuWsXF3MyLyHR1RfzYuBP4K65iLFOiDjDhdE+mWjCE8+n96/RLSUlh0KBBzSawOedDdGbnzp107tyZkJAQdDqdQ9gD6hUR6xur9rgqlQpvb28iIiKIjIy84QXDkg0XqDpSLXiL1PxhBMf24HsSrmuOTz/9lFdffZUHH3zwusb5Lfn666/p3bs3ixcv/r2X8quRkpJCeno6aWlpv/dSmozZbEahaH6JJSoqykXUu5Zrt/YYEhK1kcRBCQkJCYkbGpPRwLFNG+kxagxKldplX79+/Ry/2yvQXgi64FbECzeEO4RAd5WNf475GZO8xl3ko/AhMTSRb89/i5/SDy+FFxWmCoa1HMbbt7zN7H2z3YbjNpXw8HAee+wx3n33nTr7Etod5NTJYdUCkbOsYFu/HD/idO0Qir3QK/SkB6RjkBvqdRIarUYSAm259NoE2vKXWfV6ipevIHjKZADH7zKNBrmfH2KVk0AhCmQnB9EmLI8wTRGPCV/yLn9zmUNE4DG+RGkykrk9FGOlysVdGFxcQoC2jPZpaWh8jfRrt4/ZpulY8uM4kzOabmFv0ImzNQNqAiG6J1zYDhp/eGQL5UnnHMVRAu66C03HjnR77EEK5s13uEt0Ko+fgnoRDZbGG3mErZAKbW63FZnQl9k2n/kO07yL5JX8C3gANVC4tox4IN7P1dq2C5GLOgP7vGoSEs68vT0tEfDZ6lo0wx1Xg/2IztxOS1HkZf1l5vSZ7NjnLqT4ehDN+sYb1cKej/CiPM9jcfCdO/IoqA717KW9jVaXu2OWadB5h4NVRBAgIMKb4X/tTHCULyaTiX25SYRbf18h1I7gE47MLxJBbntfM1w0YDXWOAstec0jDDfmuvOE2u2MmZkN5lKsr3JzU7kWcbEkJ4urm9fjruZ1caaSYmzv1a3uuILKt+b1JFdZiIg4z5UrnV1CjO0cOnSIv/zl+pzIdn744QeXvIfOnDplc0E7F0mxP3ZXOKWhsZwxGo0YjUZKS0s5e/bsDR0ybS7S2RyD9SFC1eFc/IfGXnOI8dSpU9m7dy9nz55l0aJFxMfHk5aWhtFoJDY2lqVLlxIRYXsvWrx4MR988AG+vr6MGzeOV1991XEzb8KECfX2c+bw4cPMmjWLsrIyLBYLs2fP5r777qOgoIAJEyaQk5ODIAj07NmTZcuWuV3z559/zvz587FYLCQnJ7NmzRq2bNnC2rVrMZlMKJVKFi5cSP/+NoH7wIEDPP3001gsFnr37s3Ro0f58MMPGTJkCPPmzau335kzZ5g2bRo5OTkAPP300zz11FPk5uYydepUMjMz0el0jBkzhjlz5gAwc+ZMdu/ejclkwt/fn//+97+0b9++wWN3x+nTp5kwYQJZWVl069aN6dOnEx0dzcsvv4xer8doNDJ9+nQee8yW4iEnJ4fJkydz9epVYmJiCA4OpkOHDrz++uu8/vrrlJaWsmDBAgA++ugjjhw5wvLly0lKSuKZZ57BYrFgNpt55pln+Nvf/uZ2TVDj1FOpVAwfPpylS5dy5MgRWrVqRatWrXjggQfYuXMnCQkJfPDBBzz44IOUlZWh1+sZOnQoCxcuRCaTsXz5clatWkVYWBinTp1CrVbz1Vdf0bq1rfr866+/zurVq/H392fEiBGO+Z2dqLWv3QMHDvDTTz/x0ksvYTabCQoK4pNPPqFTp04ux1DbzerptSvx50ESByUkJCQkbmjSkw+w74vP8Q8No+PA+u0+rQNas2LECib/OBmtUVtHxIvT2QooBAYFoi1x9X4JCESYIshSZGEVbUKWXCYnKScJgCpzFd4Kb6YkTmFqj6koZUqXYhXXKgzauXTpUrUpwrWMq8WionuPTfxyaigGgy+1VT+70NmysiUWLFzxvmwTB2sdm3PodHppOvuy9pEQZHNcOFchRhRrKhLffjsVu/cQ+ve/U/Duu9WDiUT1LUGhsSIIcIloRDdFSBbrRtMz6STBZeXIahW7aJee7vjdWK4ka084p/rU5CwsND2INXYbsit7bcLgoz9BSBtb2G37kRCaQNmPCwFbkZSAu2xuUF1KKgA5gTZhMCu0ibHWvxaCDHzC4O7FcOg/tuqz1WRYW1BZHkSgB8Pc+0x3vk/O4rMjFxzbojqEEI+cfA/EwcuhARSH9MMr/TJC567XcCD188lILy6q5TZXpCigsFQyPWkpLRPr5uezU4WBU4orWKuvzauyIsfPJEU65pxUBKOODpnZFAwNoK/W5uqSKax8GuPHBZWZXHUBV5QqhrUcxvSec1jxjyQXDV0E7nmhJxofm9B6+vRp9mTk0jdYjWLrywgKDTLfiF+9QrIzgk84gkKD4BWEd79nXPZV7K8Ers0p46cMdnlsshqpMJfU07qGoMhoHl2wuElhu8bMTC4MH1Fv+0qVErNcIOajjyizXl91nbLCAo/bqby8MOp0FGVd8ahP5s+xdbZ1eOAC4eEZXLl8U519ly9f9mjcxiguLvZIzHMukmJ/XLtwSmluNpkXLtSbtVOUyxFV9Ytnx44dIycnh9jY2Bsq/LgqtaDmT2F9CFCVko//bXHXNMfChQs5ceIE06ZNY+zYsRQUFBAWZguNnzt3Lq+//jqffvopp06d4vXXXyclJYWIiAhee+01l3EWLFjgtp8zpaWl/PWvf2Xz5s1ERkZSWFhIjx49GDBgAF999RXx8fH8/PPPgO36qI9JkyZx8eJFF8ErLCyM6dOnA5CUlMSUKVM4e/YsRqORBx54gM8//5yhQ4eyc+dOF9Fx4sSJbvuZzWbGjBnDP//5T4crrbDQ5mSfPHkys2fPZvDgwZjNZu68807WrVvHfffdx6xZs3j//fcB+OKLL3j++efZsmVLg8ceHV3X0dypUyeWLFniCIUFW8j8vn37kMvlFBcX0717d/7yl78QExPD1KlT6d+/P//85z/Jzc2lW7dudOjQoZFnH/71r38xc+ZMxzGWlNT/fpmfn8+jjz7K/v376dChA8uWLaOoqMilTVFREcnJyQiCgF6v5/vvv8fX1xeLxcKYMWP46quvGD9+PGATS1NTU4mPj+fFF1/knXfeYfHixWzatIl169Zx9OhR/Pz8mDhxotv11L528/Pzeeihh9i1axddunRh9erV3HvvvY4id/XhybUr8edCEgclJCQkJG5o0g7aQiDSkvY1KA4CtAlsw8qRK9l1ZRcPd3rYRcRrUdgCf4U/+fn5nCg5QWxsLBEREaSnp1NaWkp4WThXNDVfKksNpQ5RzSJaKDeVE6wJdhQdcS5Wcb3Ycyf6++cT3/oYGRd7UlYWTmFBHO07HKB7j80kHby/Tj+78FemLCM5LAnRXEZtATFQHeg4Fnch0PYqxGU/bnGEbdl/L1iwAK+ePRxtg9tX4h9X4wo7g01gDBGL6Cse46QskStEo1WH8LeeM/ly82tYBIGMsADiC7TInb7YZvmE2ioNy8Jd1ntq1zF8Zv+T4Jhk4nveDqEJtuIoSWbEvbaqqpX79gFQsWsXGffcC9gKhuQEwfNP1Xy0aeOZ6QiKMyC6+XJNuSBaHYVUGPcpXD0KZ74jw9qCocZ5tEPGZx4MI5MJRHQNASdx0EetICuvyqP0eeVyX96IuANi6u6LQeaSXzAcGRog0sNklpktjGR4Obc1kBxwgZBqAc6O4BWEzC8KTeI4dIKRU/LLWAURxJoCQSJwSn4ZYoORWSzEpp/i5tJkvKpzBpqsUTxXYhOcTZW+fBQSw+1ld5Bz6SiRulzMoojObGtrkWvIOV9KfFfblx/7F6UrsTG0urS/aSG+zYDgFYRPLUGwuegfPrrOtr256ykzFblp7UpTQ44bcgxWqpTs7lgt1iys64ZuKrVzG9ZHaV4O333w1nXPZzbKUCmb7nxtCocOHWqWcQSjnoLtP7h1SDpT0aZzgwJhTk4Oubk2l96N4ia0VBhrctPWhyDY2jUTa9asYeXKlej1evR6PaGhoQDs2LGD4cOHOxxVTzzxBG+88Uaj/Zw5cOAAFy9edHGCAaSlpdGvXz/mz5/PjBkzGDRoEMOHD2/SulNSUnjrrbcoKipCoVCQlpaGTqcjPT0dhULB0KG2z01Dhw6lTZs2jfa7ePEier3eJVw1NDSUyspKtm/fTl5eTfGliooKR+jv1q1bWbRoEeXl5VitVofI2dCxuxMH3VFUVMRjjz3GuXPnUCgUFBUVcerUKWJiYti+fbtDlIyIiODOO+/0aMyhQ4fy5ptvkp6ezq233sott9xSb9ukpCRuuukmh+g4efJknnrqKZc2U6ZMceSOtlqtzJo1i3379iGKIvn5+XTu3NkhDvbv35/4+HjH74sWLQJg+/bt3H///fj7+wPw5JNPsq/6805DJCcn06VLF0fewQkTJvDMM8+QlZXVYD9Prl2JPxeSOCghISEhcUNRWVrC0c0bsZptjpPM47Y8ShmpR9n1ua0qrUyhoNeosXgHBNbpHx8Q7+Lkqy3iJSUlER4ezoABA5DJZFitVvbt38fmS5sRLK6FRuwICAxrOYyHOz3cpGPJKKyk0mDGR60gPtT1K5xzOK89d2K3bpFYRR0Vfc7z89alyGQ2EcTb+2mg/i/5uyJ30bvAm6dXWpj3twiO+dru8veP7M/CWxe6hEAv7bcAnyXfkGcyY9XpqNi9G7AJbXYqdu6kMsnmmtSlHq/ZnqUmpKOAXCkiyEBl1XHEEsMvll6IjOBn5UwuyVqxwnoHnYsuIkPkaoAv5yJD8DKaiS6tQJmQQGZ2CY/f/qLbY3m32wOwORdoycrWgQwMrVUcRSbY3HgAVit6pzvj1xpKbPzyn5Ru6I5VGUzgvWPQtI26toFqIWBXJ22FVIjpaXMQfphEWZmn5T5sZJXqmLjSJirEIOODMZ2JNohcLNJ5JA5W1iOF1VuR+FoRoXVRVxIKQxArf3adVXsZa3kOJI4jRPRjnLEP25Qn0QpViEL1665aLPQvr2TA3j0ElJU5upusUeQZ/1MznhImlAFlQBb0ibA5weyFP/RqNTs2VRCTa9turwaeGxlJSrduAMiVvvTAiBc1F881FUfxAHv48G/FwAhbgRlRe33uvaZgljevY7eiASHSmfJmKvogCGA0uRfSYmPrOg2bQklJCampqRw5cqTxxh4gWDxLeyBYLI0K4bUdiQCjR9cVnH8r5L6qhoVBAFG0tWsG9u3bx8KFCzl48CDh4eF89913vPrqq27bOhcP87SfKIokJiZy4MABt2Ompqaybds2vvnmG1555RVSUlI8EmfthTt27txJ7969KSsrIyAgAIPBfT5W+9qb2s9+DGD7DKXRuL5GLl++zLPPPsvhw4dp06YNJ06cYNCgQR4duyc89dRTjBw5kvXr1yMIAj169ECvdy/iOz8/CoUCi9PrxLnPtGnTGDNmDNu2bWP27Nl07tyZjz92zdfaFHx9a/6Ozps3j/z8fJKTk9FoNEyfPt1lbufzJ5fLMZvdv0c7H0tz05RrXuLPgyQOSkhISEjcUFSWlnBs00YsZpPtg1H1hyPRauXY5o2IoohcoaTDgEFuxcHGcM5TCCCTyRg0cBB9+vch+ZtkR45CO/bchW/f8rbDNegJGYWVDH1/l+PxzplDXARC53DefnfVLZQSG3va8XtOjg9QRGhoqCO8x3l9j8U8xhMTH6M8ZBXvKRWsTLQJie5CoCOz9WQ6qhA7OTOsTuG/oliTa9Dpg7WxXMml7aG0vK0QhVokJDeXU8E1IcFaqy/zDHdyRtaKGdlrAciNiwIs5LeMJro0DWtxMTpF/S4WZyYuPWQ7bx07Er/+a64+Pw1jZqbLmpzxqmUi0ck9dB2Zn4fqz+aFSy7QYmYQylDPcrEBmE4tJrJbOjK5BUQrZjEMNAGIBm+M1jY2MVPlA35DyVo6h4rSVqwrjgN/j6dAb7Qt0CHmbcwkn8x6Zb2f8jcjmPJBFDFbjegE91+0myZRNowgCvhXCTy+1Z92/kdqBZTbECvzqah2FKqAYQo564f1xtXxKnLbzz+hMplc++LZcyIPbIVVocHg502WMYsrB69WF9yufi8RBM61bweCgMxipYPZgJdYIzJcS3EUTwh79H4q3BfR/VURS2q+eNqrb9eHoJY36dr/tblyxbMQ4ZOp9RfjaCr5+e7TRPTt2/eaxvOkYMiNxrFjxxg4cODvFmLs3S2Msq2XGm4kgnf38IbbeEhJSQl+fn6EhIRgNBpdin0MHTqUuXPnkp+fT3h4OEuXLvWonzMDBgwgIyODbdu2MWzYMMAmCHbq1ImsrCyio6O5//77GT58OOHh4VRUVBAQENDouu05+OLibG5duwMNoH379phMJnbv3s3gwYPZvXs358+f96ift7c3a9eudQkrDg0NdZyL119/HYDs7GysVitarRalUklkZCSiKPLRRx95dOwqlWfibklJCS1btkQQBPbs2cPx4zU3LW+99VaWL1/Oa6+9Rl5eHj/88ANPPmkrYtS2bVs2bdqExWLBYDCwfv16Rx7EtLQ02rdvzxNPPEFsbCyzZ8+ud/5+/fpx4sQJR59Vq1ZhNNbvWi0pKSEiIgKNRkNubi7r1q3jnnvuafQ4hw0bxj/+8Q+mT5+Or68v//nPfxrtY1/fyZMnOXXqFJ07d+aLL74gOjqa6Ohox3Pubo2eXLsSfy4kcVBCQkJC4oYivFVrHp67gO/n/YuSnCzEatFKtFoRBIHgqBjumv4SobEtm21Ok9XE7H2z6wiDYHMQFumKmL1vNu8MesdjgbDSYG7wsXM4b0AtcVAhd3UZRkVGEB3Vjvz8fAoLCwnx96Ms8zyqqDgq9QaiKqNQKTWEPG7LnTaj1lpc3JMBuAptjbkzamEsU7J/f0eIUXCqMA6cUp0dO96Gx8LTKfK+SGhiEGcTh1GYfxkskCdYSO/WCXNBPoVKzxPI28+bOiGBVmvXcK5f3UqiCAIGuQytJoCp660YVHC2pTe7b8rnsTav4WXR8FxJKbGGFnjrpzc6Z1MLkRgLCsjeoaXVHaVYxCCKTS+DqVYjA7BGi5LhBDGcXf4V4FY+c0/exRLaISOu3uxirnwZPogh55ehllWCIBAITLyyBpNchSGsNd8qezQ2hMfYRVhRECnztrKx225e2Gmg5e0ltnDhat3vvKoD0ypqcijF+K5iYoqqRqR2+lkQFkZ0djYAHwcHMYP8OvPWhz2HoA8wzlDhcCfaE5iJMhmIIn5aLbccO0tI/9td+l9LcRRPUHbqDSd/++qblp9LqGpRiKCSU7T0VKPtW8zs9bsKhCU5WY4ciBVFnuUcrNRqaQ5fZlFhjNtiJEFBQfUKZc7rdcfeAwc5df5CvftvRARB4MSJEwwePPh3mV8R4oV37whbVWJ3f6IE8O4Vcc3FSGozfPhwVq1aRfv27QkJCWHYsGGOkMwuXbrw8ssvc/PNN+Pn58fw4cMdwl1D/ZwJCgpi06ZNzJw5kxkzZmAymYiLi2PDhg3s2rWLefPmORxk7733nkfCIIC/vz9z5syhT58+hIaGOsJWAdRqNV988QXPPPMMVquVnj170r59ewIDAxvsp1Ao2LhxI8899xxvv/02MpmMp59+mieffJLVq1czffp0OnfujCAI+Pj4sHjxYrp27cr48eNJTEwkJCSEsWPHenTsnjJ37lyefvpp3nzzTbp16+Yi1H/44YdMnjyZTp06ERUVRd++fQkMDATg7rvvZt26dXTs2JGYmBi6d+9OVfWNz48++ogdO3agUqmQy+V88MEH9c4fHh7OkiVLGDt2LGq1mttvvx1fX1/HPLV5/vnnuffee0lMTCQqKsohijbGyJEjOXToED169KhTkKQhwsLCWL16NZMmTXIUJFm3bl2DzkNPr12JPxeCWDvb7e+M3das1Wod8fYSEhISEn8+9BUVfPz4gy7hToIg8PSStWh8mzEMElh2ahnzjs5z2Va7kAfA9J7TG80zaA8lPp9fwbQvUx3bPxjZhrAD2/CymIiTGylZvRrRZEJQKgmaMME2p1JB8JQpKEJCqKrKwGypRCH3wdvb5mRJSkrCbDaTv387GccO07pnH8IG3IpCoajjiGwMi1ZrE9qa+DEgyye03pBgZyZeWUOQxZYDURStCGL12RQEZFYr8Vl65BYZl/3Cea/XBEe/Cd0jWJ1SU6VywQPdaBvui49aQejxJK4+86zb+co0Kg4kRGOtFn6KAk18f3OOY//ySwUkmqIoNH3Y6NrDn+uOKtoXY1YF+YsaLxxQuXMO1oosVL4GfFpFYI5/u9E+j1LBOazVOQeb93q2j/+3PfO5GKN0OObA9hoa/OZ/uGepzcV0rfPPjfyMq+o8dHI92cqCOhWyH95h4d4zRofLlI5jOKV+gDuTatp09nmLe84ncCk+ntCCArqmHud4t64UhoXRKiODvsm2MOpPJ1j50JKL0dqGfGPjz19tDJhYqd5Ty5woMu6bb1GZTBiCoklrG49VZmuQ3jICq0yGzGqlk7UVADIEupjjXMKP7ehSV+HVrfGUA17ty9Gl1RWebjTs13996H75hczqXJ+10Xqp2N+u6eG3j77+fwR17E9JThafTXuyyf1NGm+U+qrGGzaCvkUspuAWdbYPHjyYbh3a1REBywoLPMp12Fjev2tBpqvEJ/NMo+10ka2wqm1ib2MFShxjy2T06tWLkSNHXvc6weZUy8jIID4+vk5Ian2IFislGy7YqhYL1Nw8EMG7dwRBY9sgyD27WXK9lJeX4+dne+1++OGHbNmyhR9//PE3mft6cF734cOHGT16NBcuXMDbuzk9478vOp0OpVLpyEXYr18/Vq1adc1O3/pwPpcbNmzgpZdecuSLlpC4UXD3XtsUfU1yDkpISEhI3JBcPXPKbbXGq2d/oW2v5v3QNzh2MEtPLqXCVIFFtDhCie1OQneFPNxRO5TYmRmbLwA2kW/J9neIdnJEFn++AqwigkqF/8iRKEJCHIIg1M3DeOmETbDKPH6MoIgozMCei2fpMWwE+m82EDxlMrLqDwXOuQ1lTl/Kqo4cabIwCKBTeObPUYjy6ufPnkvO9sXOR2+kR2Yufoba1jobzsIg4CKwfiEeJgDw6tmDFi+8QN6776GrDtVrkdiZ+6dMYtOSf1OOBaXJVa0KEUzImpi+R1B7lm9ONOvBYsFYrkIwJ7iRj34ffJ96DDatrHHlYXsNlV/NuO6xr6rzuODlFPJZXbBaZhXxMSvoNfEdLqzczNX9R+k2MICAe5cSNPsVlmzfh1f/UHxHTOLdo5UEF5cQoC2jfVoaMlFk6I6dpLVvj9wpdLzCEAuK3LqL8JBcWalzEXDH+SjucDMxxVWUeUFaq0iscpuwLIj2vKPVxVEEkIkCbSwtXMKP7VgKzjpCpWvjXJX4jyAM/laMiDxDiNomtKnkFoK+HA7PHcOY61kYcW2aQxgE0ORdwewbUEdAi4+MuCbR0o4nef9+LbxyMl0eeyJUWq1WfHwaK3Xy6yLIZQTfk4D/0FiqUvKxVBiR+6nw7hbebI5BT3nxxRfZv38/JpOJqKioP0wI5vr165k/fz6iKKJQKFi5cuX/lDAIkJ6ezqRJkxBFEaPRyNNPP93swiDYQq+//PJLLBYL/v7+rF69utnnkJD4vZHEQQkJCQmJG5L0Q7bk1dEdOjFowqPsXrWU7LQzpCfvb3ZxsHVAa1aMWMHkHyejNWoZ1nIYb9/ytkshjxUjVrgUOnFH7dDh+tApNDV58ywWkMlQtY4n5sMFqBMS6o7rYR7GGKMVQ3UeQ3uosnNuQ+fw5bKftwIgCwjAqtU6tgu+vogVFXXWoIiOQu7rh9fVxqufAvQ9f4lfWvlSqgzEKFOispoINJUy4HwWSktNOG1g21YejQdgad2O8JkzCH7kEQS5nJYrP+fqc8+BCDEfLUKQy5nYpx8f/3UC/lVK7t4VRUJwLgODrtLSYqapdS2VoV60mNnLbZixtaKcS5OnIJr0iJXVIa+iSNTbb1G4zH2OH2eGlh3jnH83mkfSqMvih7pzdu8aAMKDQujdqTspRdlkp51BdzqJnTOf5FxeOZoiPWy+NkEGABF89SLR+hjSgrLwFbx4a+gypiy5BJEjIHIEG1qV0k2uxCsxke4JbfGb/DAv7p9NhcpKu/R0l+FkokjHs2cRfMIRAmz5sMSSh5jiN5lWCDx+DUu0hwm3EAPoa0wgWZlOnqAlu0NXEkyJRAPjzBVsE6qLo1SryLbwYwiwejPM1IUg0b2bTlBosGovuxV/fhtf0x+PELWOFl61io2c+Aq2LAKaL+T9Wqgt5PXo0QMvlef5Zj2ex6hvsKiIpy6/Js/roVDZsmXzpe64HhTBGvxvi/td1/Dvf//7N51vyZIlLnn77CxatIiBAwd6PM6UKVOYMmVKM66s+UhNTXW7tsmTJ/P3v//d43FuuukmUlNTm2VNTz31FElJSXW2Hzx4kNmzZzeYl1BC4n8BSRyUkJCQkLghadG6LSExcfS6axwymZwHXp/Lke+/ReFhAuum0iawDStHrmTXlV083OnhOoU8GhMGAXzUnv1Z9TLVKpQhirRauwZ5PXmGPM3DqHv7HQzU5DGsqsog/+BXmMNExzZzYSHFK1ZgzsnBq2dPdE4fquXh4Vjya3K7KePaI/i0Q1D6IPNREvnmU/hvXs/fd6whTRPE5gjXfDgvHFlNXHk+XmYDCnkVpcoYVsY+5Ng/8coain00tCirkcS6ThnPylZdmbj0UKPnLeqeMYQ4FXUR5HJia1UXzDpXE+bjX6XEZA4h3OsqovLaZJr6cq+Vb0/GWnrZdaMooj9zBjyoH+wt7wMYuYqV8VQwNn8bwabSmgaCQEzHzrTtPwbVlqtNXnd0iC8ltV5D7awWl9fQkyuPXnNYcSdjKBe8ruCrhzdWWoisyGLH490ZoI+h6utd2F2yAIqRdwIQPMmWb3DZqWVsvbSVCJV7iULwCcf39jmOx280eXWuhFr9CbL60sUShwyBUcaenJRfRu4k3QWJvow29rKFH9ditLEXao9qQv8xaWp1Zvmv5Si7sOPXGbeJyGQyREFAFEV69OjBqFGjKLx0/W5bO4JRj8ygw/tq43kIq2LaICpsr1e7WCg3axBEBYL52ryIMkP9+RGdBclLly7RqlWra5pD4vp4/PHHefzxa7kV8sehW7duzSbqNReffvrp770ECYnfFUkclJCQkJC4IekxYrTLY5lMTp8x7vNcNRfxAfEuIqBLIQ9P+of6sHPmELc5B+258zh6CPmGWkn2RZGqo0fxu/XWescOjW3Jg2++z8ePP1irq8htITFYVn9B5b59AFTs2sW5R+/kysNn4HbgdhDm7EY19x3MxUWU/bDJVp1YJuCciM0hDApy1F0fQtnyFhCtgAiCjPyPTlEWGIEoVuBnqSuWRFQV0lZrS2h9PDYcY63iLUaZkoLWcfR98TVHSHDBz1sQu19lbhsRvVXg4JGT/BRS9zz8d3wnl2rP9eHOcfpFhsiEts2bG8juvKwd4lyRlAzc0mh/pVgjTF3FitaQi2CudnAKAm169uW2vz+LJU9P/jWIg9Dwa+hUltZdF495eG0eAe2t9LogEFUEyEU6fZ5JjiybK0FR0K3mdXQ+3+ZE9VEriA/1cYTxF4RUMPVJUFcGortaU6ikpVxz3YKgM50trjnwZAh0tdR1RdWEH7sWR8mVldLSGlbv+GH9qthV/Cjl1jC63xlB0vavGbhvfzMewa9LU6ozmwp1oAwlbuVGrM7590ouwY45BFis7PeghohKXtcxZzxzFEOVZ0L1gNAMDhQ2fsPmWogLDiCsdVvatk3A38+PwksZlBV6VhilMQSjHt8LjReFsVNbQNRHJRKoGwSA1VKCkaNNXkPtMOPa2MOOKysrG2wnISEhIfG/hSQOSkhISEhINCP1CVhtw33pHB1A1sLtlFFXVCr7eWuD4iC4z8MIcPG7b2lRoQOhWnCyWtFdcQ3XtChrchuiVKKIjMSck2MTCWuhvulBlC1vRhAErghQhYA3IrHI0Jb4ERQ+ktOVZ+v0y/YNJqDalaKVBaGpdBUHA2K7QNc25MYk0Grl5xQvW0axrsolZDpI7V6EUZvqBuCajAaObdpIj1FjUKpsuRDrc5ymW4pIUAuw1+3wDWKf56bbh3Ni6xZ6jBqDV2Ii+S3bY75zDKK32nE82Xp/gjzQ8vxFgcfL1fxl6k2kfruCsswy245qYfCuv7+IXKGgaXWTPcfucr3WsGZNizBGH7oKVtsKszRBPH7bLLdtnUXynTOH0Dq0Jow/N1hLr9a3sbMixtFG/jsF49rDj0NLyul69BDHe/ahMNifTHl+g+KgEgMJYekcywvjzKlzKBoIFb0R8bQ6s6lQR977R+rZGwRetmqfD/J3zJYaB7JMIaL0rjknKrmFIJWre9pYLufCphZovVTQrvE1exs9S+FwLRQcOUDBkQOc/hXGbiiM2BM02b9g9e+DTB6ETB6Eyv8REG0JE6yWYsxV118kwx52/HvnHJSQkJCQ+G2RxEEJCQkJCYlfgdohxvbHXomJaBLauuTNK162DEHVeKEPuysuql0HQuPiKbh0kZz0NPJjImhxNhMsFsxhIlaNiDnCVUQ0h5tBlKMOjSH+nx+jCA+3VSuuheAdirLVQJswiIUHqXGPTEfNPMEAPjG2/7X4oMfEOtuc+Y+1A6QAKbvYOXMI8Y8/Tgjw8NgxjpBpXT3lPIoVgZzK0jrcZwDpyQfY98Xn+IeG0XHgUMDmlssorOR0ToWjrd0tZyrUwd76xA2nc1CrEIl9nrKiQk5s3Yx/aBiakXcz7v1d8PFBAMfx5KfkwJeN5xwECLLICNULPDrz73w/38CFI0kuwuD10FgxlfhQH1Y+1oeiCiNrzxaw9XhNZechGi8CSs2Eh3kzcmRbBJUMRaAGq8FA2fc/UDHsDsoV71Aw4UGiK2yOKk8L1djzcrYJbMO/+i3h+zNH6RTQj53UFZsb40NdLkXmGnkzUqbib26uS0+xhx+3Tl4J2iJuS/6Fi8MmNipWZicFodDupQ97uQYj129OFQZOKa5grc48d1VW5PiZpEhHs6MQpa+avj37EBgX6ujnLvemO8oPh2DVurrO2ozKQ+VXf3+LqWmCcMFJP7gxUuJ5RIeOHTmdebnxhp4g1mRPlcmDAJuLsLm5UXIOSkhISEj8NkjioISEhISExK+Ac4ixs6Blz7tmR5DLCfEwt5DdFecTGMSWj+cz/Jm/07Z3f2QWC/zfPzGHieT/030V4NJHLIAFuEhctALjQffVipUxfWyhxIK8jqtsHgaP1ukJlQYzGYWVtvPjFcqDb77P2089xcbIu9y2r+0+iw/1Ie2gzQaYlrTPIQ7Wrhi99fkBJETavkA3VGDEjqCWowz1qlmbWuGY53y1OJuWtI+2rV2LJpy5WkylwcyVcgNdPDj+wFg/tJnlXEgpIL5rGHf9/UUyUo8S363nNQmDQQ+0Rxnu7XIM9ZFRWMm5vHKeXOleyTqnrwQNUG5A+KWACI0KuVygtfkMJz9fwuM51YLRsFks2TqX6MpCvMyeXRt2kTyjsJKJiy8AgXANwiDAcS9fzlFTeTMGGX+7ppFs2MOPKwErtmIi7sKP/+joBCOn5JexCqItY0B1agFHdeYLl5GJAhGHwGfG0AavJU+xiX8WSowajJa6wrXBpEDrpUKn/N/8atK9U0dUSiWnDic3+9hWSwnGsmXNPq6Uc1BCQkLiz8X/5l9gCQkJCQmJGwBPcuQ1BXsOuW/ftWVkS08+wNgXXqF8+3auijbHoCeYLZWUO+XMA9AdPQaALCCcqzKowsIl6oYcNxclVUbuXLTP8Xj5HYEYBM8+luxev45LXmYyj9vWnJF6lF2fLwHgslEDBDnanj16jIQ7b3M89kToOH0xm5H/SXE8nnT1HAFAlbaUUkUAB09eZN9HnwKdHW2e/uKE4/cYZE6SVQ2zOsdx8+A45F4KRgZrSN16GXl1oRS5QuG2CndjDkA7qlg/j46ttnjaGMcPZJBn9UauEPAzH6jjELR26UqraY+jfvd9XsjMIC+kPUUykU0+NSL1lJBgxj3QAX9vleM14a6yt/28xV1jWLG9uIvzuY9Dxutun40/LyGiH+OMfdimrK7OLNjeN8RqsdC5OrOnbkFPyC/2YWVeA5WIPQgntiO3Xlsxjt+L7z54C4Drl1ndIDa1Drtn3Cg5B0tKSjhx4gSVlZX4+Phw0003ERQU1HhHD9i4cSMvvvgiarWalStX0qWLJ7d2PCMzM5Nu3bpRWlrabGMCXLhwgfvuuw9RFJk6dSqPPOJ5XmSJG5spU6bQrVs3pk2b9nsvReJPiiQOSkhISEhI3OBUlpZwdPNGrGaboFJbFKvYuxdTZDAJbcKBEw2MVE2ZEXN+Pl49e6Lp3JnSNWts2wWB7AAfJtD4l8L7w7z4qqCmIIG94IrdGeauKMuzbfQMu30QAb7edcShtOOpqKzuXY+1ubBnK8WWMlvRCGxVm3f8vAuDoECrCYWQoY62Px69gCo+kXYt/FzEWmdnYG0Rt7DINUTPLlqWKgJqqi83oE1crUdUNXcP4bzMig9W4mUCPf7SuCvNnduxYvduCj5cSNi05/EdNAhBLecqViprhV27w50o1+D85kr81AKxIZfI2JrCZb9wl/05bbtwRh7E8b7T4IyWFhaBMsF1jtJL5RRsyKT92DZk/FKA3mgmu1hHOycR0B+BBTRNTH/h8Bq2RnXkq+iujm0tfDUcrajxvD7aJQZOljZp3Ig35yHTmCnLqkI83vj5EryC3MqZolmPaNa72fP781tXZ67MU3HxXJhHAmCHrALUZtv1LreKeJlcnwOFpenC4IjIM1gGz+bnL75tct/rYcD9D6NQqdiz6rPfdN7mQCb7fXJ/2rFYLGzatIljx44hCAJCdQXpnTt3OqpIy+We3Typj08//ZRXX32VBx98sPHGNwhff/01vXv3ZvHixb/3Uv7QWCyW675+fq85zWYziutMPSIh4Q7pqpKQkJCQkLjBqSwtcSna4SyKHdu8EVEUkbUIYcAL79I6UoHZWM6VT14lt+9JxxidOryPedsvyBW+qCK90B09img0oks55ihkkhUqY4v5Z+DJRtfkLAwCDmHQLrh1jg6o06dgz/cUxgaSF5vIudxyl31VQXFEdTNz+4Wv6Dl8KGdPX2VDWXfHfrv4aCzO4/hnfpTklCFWF1MpkfmxMsb9l7vNumg2V4fPvtu+mDvvvos8k9LFPWcPU7YLhsWKQJcxSpQ2l0quqkWj56UhnMN4Vz7WhyBvVaNiHtR1O1bu3YRVe5nKvZsIfnBkHTeg/XicC7ZcLTM7BFtnhprOoKsoIymoxrV4R/52gi0WvDW3ECKEEH5oLo8M/TsMfK7O2l6riIHVtuqrj8vUBFmFOm0CBYEO2RUUfnwcJaAEOgGf4Vll2voQENFos8FJHAwP1ICTOCgWNd1VVb6juMH9Kt18So+r8O73DIDjpzt+0m8Bw0+0EBV009xWbztPeZ0qZjxwE23C/QAwl9rER7GqGMPlMkRjjXBmNVgBAZlaQFCpUEaFoY7zB8CUX0Xqun3V1Zlx+dlYdeZroeB4gMe2ubPRrnMPPnMZH2PdGweDz1ymXKPkWHxko2NGelcQNGgImuhODhffb8GBr1b9ZnM1F3KzN4JZY/tb8ztiFwYBRFF0KcZl3z569Gi3fT1h6tSp7N27l7Nnz7Jo0SLi4+NJS0vDaDQSGxvL0qVLiYiwFehZvHgxH3zwAb6+vowbN45XX33VsZ4JEybU28+Zw4cPM2vWLMrKyrBYLMyePZv77ruPgoICJkyYQE5ODoIg0LNnT5Ytcx8m/vnnnzN//nwsFgvJycmsWbOGLVu2sHbtWkwmE0qlkoULF9K/vy2f8IEDB3j66aexWCz07t2bo0eP8uGHHzJkyBDmzZtXb78zZ84wbdo0cnJsuWiffvppnnrqKXJzc5k6dSqZmZnodDrGjBnDnDlzAJg5cya7d+/GZDLh7+/Pf//7X9q3b9/gsddHeXk5jz/+OKmpqYSFhZGYmIjBYGD58uUsX76cDRs2sGHDBgB++OEH3n//fXbt2gXAypUr+eijjzCZTPj6+rJo0SK6du3K8uXLWbFiBcHBwZw7d47//Oc/ALzwwguUl5cjiiJvvvkmY8aMoVWrVmzYsIFu3boB0KtXL95//32GDBnCnDlzWL16NWq1zUW/cePGevNzupvzpZdeYtq0aYwdOxaAe++9lzvvvJMpU6YAcOLECQYMGEBhYSH9+/fn008/xcvLiylTpiCTyTh//jz5+fmcPXvW42tPQsJTJHFQQkJCQkLid6KqKoMLBaUYzGpCAlrWKxKFt2rNw3MXOIp22EUx0WpFEASCo2K4a/pLhMZWf0D1hthn55B7eIxjDB+/BLzGj+TYpo2EtWlN/Pqvufr8NIyZmWCxcDUEXn0IyhRlcKHpx1I7THjnzCF1irLoZRoe36XHXdWGD8/KEJSB+PY/RpL2GESDoItFNNny2yV/uYxzgpGYVnGMeeEVlk9/ytHXKPPM5ZS6ezdDht5MpTLEZbs9/2F94bY/hw/zaHx32EXNrFKdizg4cekhx+92Ma8+zIWFFK9YgVjtoKrcZzvPlXv3cvit+Zw2ewGxLscDNYVUCvHmmWT3X/R3Kjs6R2EDoLAaiVGPRBA0ABS3cQ13FpSFCHIDokXteH4ACmVWjAKYak31axmQXu89oY5L88errsKeMcKL8dn5jsDiF0jmS1wL8egRyUf0OAT5gHYsHXWrPVpj1z53UC7X4eXtjSo8Fl9fXxSBmjrtjLnllK5rvJDNZaxoYv1RVV8vqmi7wBqKT2+PluTAXqW4hRhAX2MCycp08gRto9WZf2vMcvfXro/RhI/RxOAzl+u00SkVWGQCYX+diHdUGMYWM8nTipgMN6aT80bCX9sBWWUL9NrmyzHbVIqLix0CYH0cO3aMgQMHXnOI8cKFCzlx4oRDqCkoKCAszHbdz507l9dff51PP/2UU6dO8frrr5OSkkJERASvvfaayzgLFixw28+Z0tJS/vrXv7J582YiIyMpLCykR48eDBgwgK+++or4+Hh+/vlnx7HXx6RJk7h48SKlpaUsWLAAgLCwMKZPnw5AUlISU6ZM4ezZsxiNRh544AE+//xzhg4dys6dO11Ex4kTJ7rtZzabGTNmDP/85z8djsrCwkIAJk+ezOzZsxk8eDBms5k777yTdevWcd999zFr1izef/99AL744guef/55tmzZ0uCxR0dHuz3ON954A7VazdmzZykrK6Nfv3707Vs37UZt9u/fz9q1a9mzZw9qtZq9e/fy0EMP8csvvwCQnJxMSkoK7du3p7i4mI4dO/L1118zcOBArFZroyHgJSUlvP/+++Tk5ODl5UVVVVWjDlvnOT0hOTmZpKQkvL29GTt2LPPnz2f27NkAHD16lH379uHnZ7s55Mm1JyHRFCRxUEJCQkJC4negqiqDDdsfZPb+V6q3ZNRxsDm7ykJjW/Lgm+/z8eN1HXIPvvk+Gl+bSGB3i3W8tatLG4Xcp05131Zr13CuX3+yguHVh+VUaUAmK8Ir9r/orjzh0XH838iODOvUok64amFhMbpj25nbRkRvFbh4YAcGa8MfogW5oc5jsdowtJbuNmdTBvgdOOziIvE0HDn2/r9xNFdB6flMl+213XTXwh352wg2l2INi+MrZR/Hdi+VLYRIZ6w/d9u5vPJ6Q5wBzAUFFK/4HNFoBJngcHoeDW7N/5XXjdO0H8+BfTYBMi01Fehep11D9But4dKZAHIvaLHePA6u5AE2YdC37fuOdhXnZzoEwg2+7p+HfV5mHm3S7PWT8ct6DFWFboXB2iye2JPoQC9eO5bh2LahcgDbfDy7XurD2oSPzxEnZERUh0sbuUIx0GJmrzpuUE9zSy69L5LY6mvEmJmJpYG8cHIfH1QNFJSwV2fuYolDhsAoY09Oyi+7VGc2XLgApgCXccxYOCW/QmdLLAp+27A8d9R2FVaqlBxrV+0m/Gnr77CiPziCrWK8WvmrZEj0iJMnTzrCiOtDEAROnDjB4MGDm2XONWvWsHLlSvR6PXq9ntBQ2/vajh07GD58uMOR9cQTT/DGG2802s+ZAwcOcPHiRUaMGOGyPS0tjX79+jF//nxmzJjBoEGDGD58eJPWnZKSwltvvUVRUREKhYK0tDR0Oh3p6ekoFAqGDrWl2Rg6dCht2rRptN/FixfR6/UuodahoaFUVlayfft28vLyHNsrKipIS0sDYOvWrSxatIjy8nKsVqtD5Gzo2OsTB7dv3878+fMRBIGAgAAeeughLlxo/K7lxo0bOX78uIuQWFxcjE5ni3QYMGCAQ6Q7ePAg7du3Z+DAgYAtjD44OLjB8f39/UlISODhhx/mjjvuYNSoUcTExDTYx3lOT7j//vsd4t9jjz3GwoULHeLgfffd59gHnl17EhJNQRIHJSQkJCQkfgcuFJSSURbnss2dg23nzCHE+Cs4/N16irOu1vmyJIoil06lUpqTTY9RY5wEwBn077cNs6UShdwHb+940g6uBGqq+1YdsVUsPpogUOFd47wR5K4hww2R4CO6DVc9c7mQsz/vQ27SEWQpA2UA5XJ/t2PYnWgyVb7L9kHlG9DofDGIvuwMuMex/WRuIaWhkUT6+dP35+0curkNI3N/pCq+F7t09Tue3tmTC+TW2e6cF/FaUVhNhBsLGfn8O3z18WHH9voqAjvj3Madi1DTsaOL09NitZIcF8+bPdwLuDXH05mJihMImecgsmFx0NkNWKQKZuuZdO6fPAFtShFXzp2raVdLwB0drCbgvJoywVqvONicXBKsGCz6RoVBO7Wvy0rh+gtZBPhqkPlee+iWuyIf9tySlioDe1Yv5+rpk8R06sKgCVOQVeRgWjoR0WxAviIHnWE1pko5Wc/VDfOuTezSJfjefLPbffbqzHZkCHWqM2e/8A+s2suEfvUlGeklhCOyW3GaDEU+vqKGtlY350HVvIWYKtQ2Z7DCIroNL65NfU7D/xmqxbvmROE9Apk8GAQVMrnNiZeQkNDs83hKZWWlR+JgcxVN2bdvHwsXLuTgwYOEh4fz3Xff8eqrr9Y7b1P7iaJIYmIiBw4ccDtmamoq27Zt45tvvuGVV14hJSXFo9x0RqORu+++m507d9K7d2/KysoICAjAYHDv+rSvvan97McANpehRuPqfr58+TLPPvsshw8fpk2bNpw4cYJBgwZ5dOye4HzOFQoFFkvNe6heX+MGFkWRyZMn8/bbb7sdx9fXs1QW9c0hl8tJSkriwIED7Nq1i379+rF27VqHwOjJnA2t3x3Ox+48VlOuWQkJT5HEQQkJCQkJiQaoqspwEdiaY7y96YU8uTYfmOyy7+TlM8hlrtVgtRVV6M6c4uC6NY5t0R06MWjCo+xetZTstDMc+/E7ss+exj80jLSDewGbABjXpRupm3c3WshklDkWbRAkF+ags6opNroWnajNpNOb6Z2XRrmXH1N43G2bV3dkQ8Q4AMbmfs+GiLvctqvtRHPm6E1XatqdH+xwqH0U1AnxjptALuO9oxdZ4HMH+ACea5r1suCBbkDTBcNKuTeiKKLItzlAKw3mOqHEnnAur9yte1CdkPiRH9MAAQAASURBVID476Wcf3AiFwODOBUV5dF4RpmSFsZiJl1di0FQUKIMqhMmXfs5OMRMkotCWTxvNztnDqF0x+cIqji3Am7QTUa8lFoMF42Ae/G3Ofm80wjOVQuD/5e0jLSIML5udafbtu7O/S7vGofr3cZsvlF5dh6dae8bBr3dX/fXgzLUCyVe3PbCs2SkHiW+W0/kCgXGQwe5vMkugoTBz9M8HvPKY4/TZsuPDToIPWHNkiXIg1qSKIslQ2G7Bi7K89yLg8bmrXJ7vGXNHPXlH7wWRjw7A5VXGD9+ehKrtQxE27UhCApE0Yy56sdmmed6GfHsDEKiYynJrWLrsnSHeNecyBQRdcb19//1X8/14ePj06AwCDYhyMeneYTokpIS/Pz8CAkJwWg0uhT7GDp0KHPnziU/P5/w8HCWLl3qUT9nBgwYQEZGBtu2bWPYMNv7b2pqKp06dSIrK4vo6Gjuv/9+hg8fTnh4OBUVFQQE1M3bWxu9Xo/RaCQuznajcdGiRY597du3x2QysXv3bgYPHszu3bs5f/68R/28vb1Zu3atS1hxaGio41y8/vrrAGRnZ2O1WtFqtSiVSiIjIxFFkY8++sijY1ep3Avdw4YNY9myZQwaNIjy8nLWrl1L7962vAlt27blxIkT6HQ6lEola9bUfDYaPXo0EyZM4KmnniIuLg6r1cqxY8fo1auX2+ckPT2dvXv3uoQVBwcH07ZtW5KTk+nZsyeHDh1yuCPLy8spLy9n4MCBDBw4kF9++YWUlJQGxcHa2Me+5557yMjIYN++fdx7772O/V9//TUzZszAy8uLZcuWOc5ZbTy99iQkmoIkDkpISEhISNRDVVUGB5NqPpj177etQYGwoQq4GYWVFGkvceDoTOYdc1/A4KWNRXW27U9KxXIxlVJFAIFmLV7+AYx76XXUGm8eeH0uB9at4fhW25fY/etWU15kyw2UkXqU3as+4+y+3YiiTUwRqnPjWC0Wjm7aAICsRQg9X3mKzukvsubcK3Xmd0fLsjzaarPQvjAfjtQfLmunSl5/eFptJ1pD7ewhxqqTNdWEMwIaL0bQFLrGBtZb0be+XHsAsZHBkA7pyfsZ0csW0lQ756InnMsrJzrQq841lFFYybDFR2HItCaNp7KaEK1WAkUtPkHBXKwoqdOmoXDu41dKuRwXiq+vewF3/dX3wA/oCg8cn43aEMZlucVFhPu1ONcilCrNtSc0NJjiQPXrr7M2xcuWIygqEZQKgqdMQRHimgNTtAqUFrRALLwI1ios2WnXNd+VrCLa1BIHPQ1jFs169Go1VV5eCOg5prjo2HdVVkSSIh2wuQ67mOPwovldbc40tyvQbLS9N8pkTkKYoEIQm17I5tfi1IUM7hkwCLWPAZm8sG6Da3ASKjQDQeaLICgQ5KG/iuB4PXTp0oWdO3c22EYURW666aZmmW/48OGsWrWK9u3bExISwrBhw8jKynKs5eWXX+bmm2/Gz8+P4cOHO4S7hvo5ExQUxKZNm5g5cyYzZszAZDIRFxfHhg0b2LVrF/PmzUMul2M2m3nvvfc8EgbBJuDOmTOHPn36EBoayvjx4x371Go1X3zxBc888wxWq5WePXvSvn17AgMDG+ynUCjYuHEjzz33HG+//TYymYynn36aJ598ktWrVzN9+nQ6d+6MIAj4+PiwePFiunbtyvjx40lMTCQkJMRRbKOxY6+PV155hccff5wOHToQFhbGLbfc4nA19uvXj5EjR9K5c2ciIyO5+eabSU5OBmDgwIG8++67jBs3DrPZjNFoZNSoUW7FwaCgIL799ltmzJhBeXk5MpmMN998k7vuuos5c+YwefJkFi9eTP/+/UlMTARAq9Vy7733OpytCQkJTJ48uc7YDfGPf/yDBx54gC5dupCYmFgnl2Lv3r35y1/+QkFBAf3792fatGlux/H02pOQaAqC2Nhtmd8Yu61Zq9X+rnesJCQkJCQkyspPcdipqEfv3hvx9+vstm19FWPd7btWJl5ZQ6BZi29IKFaLBZ/AIIIiIjmXtP+axrMXMpH5l7Bh5/O8kfQPj/ot2TqXAUsWkhfbzqPjGpPzPRsjm+4cdMY5t50zdxUe5PvQ/m56uPK0qCRGUAAiegTecLIZvooXLZERPiCaLqMT6jxfKx/rg548ph+oycFUez3z7r8Jw6mDKNJ+4Z5XXkJWHXZlF4wPXCji7c1nGl2nM/ZrqLK0hPVfb+LV855/gb+jYBst9PkEmrWALTSpXb9bSD58gpWxD9m2OYVze0V/6eiry3oAqzHcIYLKNFn4xC9yO48zU3VzyDvpwxI/V7GxHbLrrkxs51EqHM7B6+W+CiXrnEKhm3OdDVG5ew7WkssIKhWtvvwCTceOLvvTknM5/Pk2Hg6z3UTQFSvJ/PnaC4Q8O2QaS+Y8XOeGhalQh/70ObJfcP+6F816dGYtx2+6iczW8bYq6fbKxmD7HdtjmSgwxtibENGPyp1zsP4/e+cZHkWhtuF7e5JN752EFjqhSBUERUSR5mdHBBV7Q+Qodo7YUUBRj9hAUOxKkSId6T10AoEEkkB632Szbb4fm53sbMsGsO99XVxketnZMs887/tUnnU+brWKTe2TncY3h/4ncgmpcy/c1fpHUenvz/4k70KK3KHSjsCoW3ZR67hU6FLak95/ACNHjqSisJaiM1Ws+fyoZB6LuRwaBE2bC1IXmINFqUdmVhFUk4bMJoDalQ574uZnLyMqOajJ+bxBr9eTnZ1NamqqU0mqO5YuXeoxlKR79+4XlVbcHKqrq8Veb++++y6rVq1i5cq/hrPUE/b7vXv3bkaOHMmpU6cICGg6eOmvxPvvv8+ePXuYP3/+n70rPnz8pXH1Wdscfc3nHPThw4cPH/9a3JUM28bX6qQNsG3DrkqMHd1m9sPunGjNxZbKW9PgDqytKKf4TDYyuVxMMHZEqzdw5cib+GXNUqcyrdHPPYpCU83KzAX4eengm3R8Bwm6Eszl5aR204oltFlFNZJSXFtK797vF1CSncc9pYup0Rup9o9iRfggcb6W5RWczprilUjlih9sDgWzhVGl37DqxFUu5+uGgvZYz18mUrdjC+SkyZVoBavqkRrZeFw2B9/R0mLJMvbuOoDJ3x3EWtvci7Sla+hy8whxXReKrQdlbvY5tu3MgIjBXi9rLwyC1WWj9vdnxM1jmNB3AKcrzzJ521SXy9q/BjVZUxDMGpfzOZI8KJXimloo+f1STm87tJSjgQLfp7oWm5tiuE5FhEWOWoAwi5yJVXIMMgsWzSl6++8H87hLvMeukKFu2ZLEd2ejcdHXLWtvISrZJaiRbyCxugjdocMYUmMk5cWqSH9MEUqXQp6NutBQzqa0aBAG7ZVBJCLhYGNHIgTPQpJjsnBRkD8n4y6ugX6tfxRmhfUGSK8J41Dn+7GYCqHauzRpdwjCpXeUXvvIkwCsfP+dZi8rJvPGhGF00bPSXuyTEwOAJbgOk6oGpSkQhcF6ndlERIup0GkdgNfC4R/B8OHDAeuxy2QysQehIAh0795dnP5HMHXqVLZu3YrRaCQ+Pv5vU8L5448/MmvWLGvLC6WShQsX/u2EQR8+fPxx+MRBHz58+PDxr8RdybDjeHuOHJ3sNL/NGeYYfJBVVEN+hfUG31NSbXOwT+VVajQIFgtmo9Fjb6Ye2QXs27jaaR51sIF9B62ui0gALbzWfzp6s4bzulg+OXSnOK9/3DdoFCXcvdrE1SfyAKhavYagK690K34l+Fso2/Qz/pXnSGjXkXMnjxNgNuNYFHgqsDUYkQhtNu5JjmDE4FtYf7aUmUsaXXeGzmEIgUpQyBG0jT9lNDXuRakAuwRWx1ujAABBQBHYWJ5nO64zVWc4WnqGrNIsyTK23nuuhMui37bBzVLxqsyNeOuJfWfLeXHJEetAM4TBxyLPImRXOvWmNJtM9Bpl7W1Ur/CuHFemqMeiT6DGCwH3/mO5LtcR7PSqu+YVajntwRVYC1wnq6VS6zlRsilswiDY/pdDbRql6tqLWq/XCAIpXy9C0VA6WFtl4MC6s5jN1vfo2SNlBHHpkmKfOb4W2dQtZAOq194mNjYOoaGc1phXjyK2K0JdY7m5YNIj6KzXd1hFBUN/Xc3W/v2oDg7G6aUUYIShBzFCqGS0SaHgRFpb2maeQGk2o1OrnEqCFZaLK14qDU3jQPpjF7WOP5K41m0x1F2Y6HtRybwNp9liLsdQNa/J2dXBd/0lBEKFQsHIkSMZMGAABw8eRKfTERgYSOfOnQkL+2P374MPPvhDt/fpp59K+vbZmDNnTrP6202YMIEJEyZcwj27dGRkZLjct/Hjx/PEE09Ixj3yyCN/0F41n6KiIoYOHeo0/uqrr2bGjBl/wh758HHh+MRBHz58+PDxr8Rk1rkcdhzvaXlP5cIXmoDbteIAB0K7isN9ynbSou4saotR4gQzeUgVtOdwYiRl9bVW5w/We3sBUKidBcsYbbHTOACNvIQR+83UBsWQGQrhKUnEdOggmcexv55Mr2Pf8iWYTUZxuwBqs/uSQEeHWs/eA+iUEEKeXrqMEKhECG4U8mQ6E5gt1OvdO9zsE/+SUPA1WmqxCoNJKECAgG7SIJYzVWe4/mfXYRdO7jo7gVC2eweFb7xp/VulpOK2sdycVYDs8hhkNQbUGc59/1whCoNeMvuWdLomhVK+ex2mNhPoOWIMcrmCW6a9wZ5lP6O0a/6uVXnnaLS9JoIx0qWAazFEY9EnSMY9t2sBNdpE3u14JQBVeCcCncbSZMnwx51u9mpd7liutR7ExCqNKBCCgKA5T46mhunGE2RbpCEld7a2cPO1V5B/qhzVipyL2n7D5qj4+WcCLrsMhVaLThHBgXW5mE0CyKzXaqUlnq9KP0RJLTE1h4hhDTJtNDKl+5JMe1HPhkwbTeDVrzSOWFNBGRWSeQL6OPdArVnzvLiukKoqhqxdx883jHE6DmSglxmxf4n1mjBOx0ZwqEtb5GY/wotK2JN8aXsR1vpH/SWEQVvKr8VShQwaS3ftGHhbWwJDgzAZgykvcO4r6w22ZN6KwlrKC7z7jlLVh6Ew+SM3N1wz3vZRbJhP5WVfyt+bsLCwCxNF/8ZMnDiRiRMvfejRX4n09HQyMjL+7N24aKKjo/8Rx+HDB/jEQR8+fPjw8S+jqZJho8E74Uap0F6ycmEbVxT/hl4hFbgu2FsjCCCTURYUAIKA0mjCpFQgNIhkZoP7Gz/HEuMrD4eCXs5HSbdBknXcW+Yyrq+sICAkFHBdipvyxmyWvPFfKooLxe2GmKsYdW4pS+Kde0UJxkjRoSaYNbQebi3dTgtx8PrZud7G1nzKj1uvBWAVrkuKAc63Cib5tE48oUnYHb8MAnrGogyXCi86o3c34TJFPVN2LCJZV4x/fR3x+nLKFnwBFgGZWk3N1cOsx6dVImiVfPRgW2Q1Jk4UVvPO6hOSdc2+JR1/taLZKcdgDVNJjdSSeq303MrlCtExaKNFcAt+GfMLOqOOnXnHmJkxTZxmcwM+Nyyd3kPSJA5GRwHXVclxauU56nSl0CAOXgquku1hneDcVN4bRtUoMMnkojAIUCK3WMVBGaR0jsQUr+P0PjVFchMnHFyeAd26sKGiBj/MtLqoo7AimPQUNYjHAK1WreSmZy9j1ceHqSysRWhw1FUY45DJICKowlnkc4O9qAd4FBM9IVP6ST57iqOjxAcM1oNAVPxzFEW0sDT2RDzU+T7OBh0GyjjWvi9BUZEXXeZro9Y/FrlCQK9pdI5p5aC02zULAZjUMeKw0WKgxuTd57qIzLtbJFvKr62U1xVbvq8EKoE89+W8HhAUCutnuCWAr17a4fVygTXuw7Oa4tr7OxMa4ys/9eHDh49/Ez5x0IcPH/8ajIZ69i1fQvfho1Cpveuh5eOfhbclw+ld56NSh1GrOyUZ37HDTAK0rcSeg375eZdkvwbWbOK3wCvYFDXQadrO8N7sxJpmZwskcUQjk2NSKESXHiD2CFObzPQ+dQ4/s8CaDo1hAIYqNce+acWt01/FJJyTHGePlHu4b+0X1NarkNfICDXrKFRKSzkzNm1i0OD+BISEioJrTICWgMjGG9LIpBaMffM9Pph4W0O/MivJ+jxe3PsBhaFyTOHRfB59hei8e6xVOFdfPVCS1msvPOaZjEw43XjeQ81lXp3j/FQtZzQq5EdLSZIpGnuoCVZhMGy0VPaprTJwYoOLZFAXCGYNyTXFtC63K6uVyyns3pPA557lTEQ0lDb2ddNp5LQJD0bwcxZo/dUKpzL0J4e2BQHeWdMoJD5yWTjsX01u7nk6pHdm6LgJXvc3NBnMZKzLJf2qJJTBDfuQ0Tjd5gaMrzbSPkbLvrN2JacOAq69Y/J/N7RH9eB4EnQl5GsvrpecIxcqDALIZM4l1IsDjYzWQXqbCIbd35mf9ofz0w7Xgvnk7w8C3geWVHeOpNWgJOpPnXIK+3Dl7jPrdESkpPB//+nBZ1M2S+cHel8dzrmd3ol8jqLepSI3MRGAQIsfg40d2aXKolBWSYQlkAhLMLXUc1iZiwWBIq0Zg8Z6zRg0ZehCLJj9E5EJAqqyQuTmC3+ocqTDBOTKRiFOK4chwY7hI+EQOkEyZnVZATqLCYu5DFNt00EScnkw6uC7PLvtLqQ/n5fJwgq/gegDK7AozCjrNVBvgWITFnPlH1LyGxRxYaKyDx8+fPj4++ITB3348PG34mIEvpM7t7HlmwUER0bRfoD3/bt8/HPwtmRYpQ5zmUocoG0lGZ9oquazje9QK8g5GxzDjB63i9P+s3cRfsZ6kMvRq/yY0e0WcVr/0q1sjegvDgfW1OJNSKotkESCIFAvmEFwXY55RWYuKrOFwhCt1PkD1Feqqci1EJ0mFcbiUvoy7v4+LH3nNQoEOYXKcMpV0htSTYferFq7jc6Xl1N2rrHU09aL0UbescMgCMgEgaiqWoqD/BHkcgI5z6zrjcAZAtktluZeffVAOiWEOB2HTfgKqK2H043je3d6ns92ZLs8dntmrm3sGbisb1sSBRmKIDUB6dFOjkEAXWU9BRvN3Kp8DqOinoqAQta1Xti43aw7WK8IEwUyf6NesnxeZAzj7p0MRXookgY+PHzMOizTmXD8FHPlGHR0FwK8v7uMdZOfoHT7apRqdbOCT07tL2bnktMEhfuR1jvWqcTY5gZc9eVCsvbsQOgpLa12V2Icnn+KYJ13guofyWKti51tGL/4XAF+v2Uy9dfTLuexx9uOhK2vSUEV6Y+5wnPYhyPnTlY4WYVD5OfQbPwPcJnX6/k9CC8rJ6Syina5ZSiUGxgEHE+NR2GxkHpmDWVBARzu2xmLQg4SjVVAH1gOsliwWFBWlcFFiIOO4ppS5mY+B9SqCOqa2fr19xDh5Iowt6KjxVKFqSEh2az/DZX0I4VDedbPhr9KT0AfPnz48PHPwicO+vDh4y+DN8LfxQh8mdutjozMHVt84uC/FKXCOwHFNp/j/I7Dfu3b0/fDDyh67ydUJulNa3JNMR3CVIS/Op3FG7aDnVkoUX+OcbmLMMhVkpCRplBbjChMZswKeaPQ1+CA0xiM1KtVYjmxWFas9SOmqpaCYOu+20IqNs6fi3lfBpmbNxLfQdrHLa9CSX5xFSfMISxJcp0KO68sHsqArAJe6x8l9it0FGBP7tqGTBDoW1BBaFEZZQEadrZOID/cD2g8dlv6r2PvQkdaBmjY1rs9NWYzgQoFLQM0bJjSgsKy43z726f8nOW6R6A9sh7RhLkQIO2JSgqSlHo60t4/hYdHD0YVooG9u1AslvZrrNU0/fDCWmLcm0SlivyKumaXEtfWGWkfFE5gEw3qz1SdQWfUoVVpaRHcgqy91tLGU/uKSOsdKykxLqmwcODcr2RlbmdJ3AhrNeS6LI/rt5Hz9Y90afi7TvP3KUk8etY7QTMPC7dS4xRoE08JfhjQo+apcdeQGHlhYSKn91uvobhWIfT7v9Zs/TEL05lTqIPMxKRXUNPE8r8nbU+eFP+2PYZol3FWHA6phKG/nmPzgCvQBQY0NhltaHIqq6/DP+8UCoOD4uUFKu0Iay+/v1CS7sXg9hi81Uy97R3ow4cPHz58NAOfOOjDh4+/DMe3bmLLNwvQhobSabBz8pdtHoDj235rUuDTVZSzd8USLCbrL+6cA/sAyM7Yy8YFnwIgVyrpOXy02DfNxz+bgIBU+vZZK/Yc9FQy7Di//XgAwWyhfPEpaneXoIwbSLDZADTe+Pqb6kn5+ntKy0vJObAL4lLEaQa/GhRU4meSE1yrokIZQv+SrWyNbHQT2hjT+hfitefhkAVtaC1mgxxzlXP5Y1htPQVqFXEpLelYL2Nv1hHKA/2pGXEdKcdOE3L2FJFhbbjypdeRmS2knzqHLKcA3eoN+D8yWTzOvAol133Q0I8x1rUw6Ijeru+crXej7XzFtEglwaRGVWQt/63X1NNSpSczWgtUi8s9dX0YrcNikatLAM8ibssAqfCWGqklJiCczdrzXu1vUwKkjYj4QLHUU+XQW2/E3T1pHRpM2fwv0GdlUQ349+hOzH/+Q+FbM6gurkVWZXBKVHakbVQQLQM0Xu+TPTvf+Yi9h7fTpsNK+s16DZnK2VnqGKryX//3KTxilXfOHC5lyw9W0UehkNHpihRO/DQTw4Gd+Kkimr0/NcWlZIUm4m/U429qvgjkSCJyJyHOnlqsgt3FsuBYldfzOm4vRXae+ZonxeFczRYgmuZQf9rqWoyWFRLR00JaHz9kdXkM/79wTh1MgwxQBV6axPPfg7g+5WiCTUAxkQY5X3KN0zzanOPILJ6PoeuZAgLrjZSGdeB0y4a+mZdaEPSyrNfr+Xz87tTV5VJQsASDsQS1KpLY2FH4+yf92bvlw4cPH/84fOKgDx8+fhccXYDeuAL3r/rF+v+vy0Vx8GIEPl1FuSQt1ea0EiwW9q1YgiAIKJQq2vUb6BMH/0XYC3yS8Q4lw57mNxrqyZ69kYCyBulCgGS5mq9RUAv4CwKxLYdSu3cv0VdeyaOvvIz2tTcora7F4K9j7eWZ4rr6bOvGmrBbnLZhw+aEe63/dNGdd/TrVhgqVRKH4PmAcBKG3USv4cMJW7WE+E6dyY4KRSGXo42Ip6dsAAqtFkFXS/Ytt0KDIBGQfYa8SU+QOHsWJqWFA5uWAc1zPtkHmNgLrn16rkK/ajul52rw10YiV5fw+ANKJDbKBj448rL49y9jfqFFcItm7UNAQCrDL3+DDw5Ig2ZkqhJkinpruEZSmqSXoTfYSj1D9dHcut9aYqwya1ClB1O9azXFs2cTPHIk0VOeJPyuu5ApFFhm/Y/nZ21Gs936ek0dn860gkZn4Qftk2mj9ROdjyDtq5hVVONV2vUrAenQKx2Ar5541qVA6BiqcnBnDtGCtfekIMCBdbkggFxhIffQl+Qe3WvtVdkMR6uN6b0niH9/uuYNPl33FsbkFIRbHoF9zRMLE5HzjRe19rdSc0kEQm/pXbaDneF9xGEt0uNKCmi+iHe+oS+hquHfGbtpyXPmUDf0OyzF9bD9Anb4D0DpZ8Y/3Hq95BmSGyPR7f43BwSirHHul2pPYL2RkDoDdUFKSV/BS4mnsl6Rf4hD8e+OxWIk88RLnDv3HSBHJpMhCAKns2cTH38zaW3/i9xVq41msGTJEqZOnYpGo2HhwoV07tz50uw8kJOTQ3p6OhUVFZdsnQCnTp3ipptuQhAEHnvsMe66665Lun4ffz4pKSksXryY9PR0j/MtXryY2NhY+vSxfift2bOHGTNm8O233/4Be+njn4hPHPThw8fvgmP5r70rMK3/FexbvoR2/a/gwNqVovBXnGMVK4qyT4nCn15Xw/EtGzGbpPU23gh80SktueON2Syb+Tpl5/LEQATBYkEmkxEen8iIyc8QmdQ8EcLHP4OmSobBdam7YLaQ+78d+Jf6N5bONSAm4MpASBlA5eqNBF15JZFJLbhJG8hPpWcp9ZfelK6Luxy80E3s3XkKtZkwnZl250vZnRpHiV84C1Nvh0wgczMbptxAaqSWKKBy6VLOvfceoS9P41h9DdrRI/HPL5BU/VWvW8eK2yZwKr0Lh08XQHRjaMuYoAJqTh2iVqFla0Q/cfy9nRcQpy3AT1EvipaO7HpjJncFXg+DrgDgpYxXwIviSG9Tgh3pkNSODVOS0NWbyK+o44FvfiWw9dsAzM6EXzo0X3S0L/X8v//rwdYfsyg4Vcmp/cUod64CwFJTQ8TEieIytSZp47gYhfTnVhutH12CnD1xzREtHdmaf5bExyeR/O5sZCoVZ6rOcLK4hKxyaS+9Cv9CqmQWsPihMETgL8gJD1eToF7P2SN7xc/JUFOlWPqe45/MzvDezdqfM0Ex9Cs8iurtbzmZqwdym1zGvnjb26JkV/MpsNBBUcBRcyxmnMNILobYeuv1kCI7jxY9rWX50hlKGvpDaoIuyfbyHn0UAHlIMtrBz1+SdV5qcjdG0mp4IeogMzlya2qx0hhMYHVLaoJOY1JXYQwKa1IcVP/fOBT+4cirtND8UF+v+dcKf81wTao07tPs/ygahUEBMNtnWjWMh/btXruobXz00Ue8+OKL3HbbbRe1nj+SH374gcsuu4y5c+f+2bvyt8ZsNqNQ/PnX+cVgExBt4mDPnj19wqCPi8InDvrw4UOCJ4dfc8JA7Pv7te7djy3fWBv57/91OQKw5ZsF6Guq2bt8CYKLIIW9yxcDIJPJSO7anfOZxzDUSft+CYKAnzaQ1r36EhgW7rQOsKal3jb9bT6451anabdNfxu/QC9SIHz8I/FUMmzDVY/L8sWnUJ2XIXMI93BEJgNVVLo4fDxORWmlgUqH8kC52uqic0x+dcTenecv+BNcW0FJ25ZY5GanoJLNi38m5qbrCQgJ5civv1EakoBq7Vb8DmzHv7LGUdPknDaSh1vfbtXtoqXuyZ+rYyE61ml/4rQFtAj2nNZcsf8EdLUbYdHgjTjoGJDRHGwCm1ajRGZ3zuDCRMeoFkGEx2tJvzoZS1kpl8s2khkWifzEGXRbtljXu3kzhW+8yVmzmjqFiuL+V0vWkXm2EnmhDtQKLJFWx6A7skt05FfUNXs/q/0VbD59lAGPT0KYPpkRv4x2Od+6No2hKrYQGIz1jMvOIlRwnXPrZeaDhDPB1mtm+lxrH8U/qkT4jt7JbNu9jx6qfHSChq59lazMWYzFFISh8IYLWmfXigMk6M8RYSwn1FTJxOJFPJ/0i+uZf7pX/PNsj/kXtL1LiXCB5d0y/zCJrKrXhGESwFznOh28zKAg9oYXidgnUHxIj78uERkyQsu6Uut/ErO+6WCWrWdS/73C3R+At67J4Q8NJDTmz+0ZWld31k4YdIXAuXPfkdLiwQsuMX7sscfYvHkzx48fZ86cOaSmppKZmYnBYCApKYnPPvuM2Fjr59jcuXN55513CAwMZMyYMbz44osIDZ+XY8eOdbucPbt37+bpp5+mqqoKs9nMs88+y0033URxcTFjx47l/PnzyGQyevTowbx581zu84IFC5g1axZms5mdO3eyaNEiVq1axddff43RaESlUvHee+/Rt29fALZt28ZDDz2E2WzmsssuY+/evbz77rsMGjSImTNnul3u2LFjTJo0ifPnra06HnroIR544AEKCgp47LHHyMnJoa6ujlGjRvHKK68AMGXKFDZt2oTRaCQ4OJhPPvmEtLQ0j8fujurqaiZOnEhGRgZRUVF07NiR+vp65s+fz/z581m8eDGLFy8G4JdffuHtt99m48aNACxcuJD3338fo9FIYGAgc+bMoWvXrsyfP58vvviC8PBwTpw4wccffwzAf/7zH6qrqxEEgenTpzNq1Cgn517Pnj15++23GTRoEK+88gpfffUVmoa+wkuWLKFFC9cPHdu2bcuiRYvo2bMnAPPnz2fJkiX8/PPPHs+lPYMGDWLSpEmMHj0agBtvvJHrr7+e6Oholi5dypo1a5g/fz6PPPIIrVu3ZtKkSWRkZIjO1ccff5xffvmFyspK3nvvPa677jrA++vWx78Lnzjow8e/HKOhnt1LfwQBLhv1f05iiL0gaJtWlHOaYQ8/IREIncp/M6zlv6f37mb+5AeprSgHrK7AzYu+AODwxjXI5DIED1VYMrmc3EMHsLhJN9Trajj62wbkCiXa0DC6XXs9B9esot3lV3BgjdWVWFHg3IdMEAR+nfseV098yFdS/C/GXYmxDZvIfXTzBopzzyCvldEiKxWZN3KJXI66dQfA2vftqchlcLnzbP4JjU95RbHGgcndPyBxSQ2Fra6g4HQexbUh1CdGUq/ww08wUK6Qhmts3b6PsJxcBE0QjwUNhsFWYfMT035kLsS5OmXzkr8BdAe6URORTun5fbS46pw4vnXKyxx8awmmnFLOmaSlgbWWeCZ/BcjrMWormTOyUSR7ve8rtIxoI4ZmSJarzfYo4jpypuoMdTIdL4yJYGZG4/jTlVYXnattuKPrlY03nobiYsoXLCDKYAC5DEFmlU8Ei4VDPy5n4lVPW2dcLg3w+GjtSWyenbfGdnPqmWgju0TH4Lc3isNzx/WgbYzVgbbsow+o3nmMTzreKE4fWrQWpaWxbUJhcACbTx8l7vX/ghfVcbYQGACDTPqTsEIZwsKk252W8VbkW9DhWsl4T8LfxFZm/GUmcgJSWHbQu76R7vhy51muVFkFrBRFGePTxyEL2sPaM2uRK6vR549v9joPhHblAF0Zl7sIgBam/CaWsPLa6iNMbfbWXOOtyOc4n6ArombN8yhCU/C/bKKbpZwJ6POwZNgm16+tMqJz8VLuNsJYWQgduyZzdschcbwMGdq6tljMURDUKEr1vzaUhESB+vOlFM34AmNAPKciXQuDJgGX2xwQ+ANhRhMwzuvj+rfjjfgaHn/hD2cuFQUFSwE54KlMX05BwRJSUx+5oG289957HDx4UBReiouLiYqyOl/feOMNpk2bxkcffcThw4eZNm0a+/fvJzY2lpdeekmyntmzZ7tczp6Kigruu+8+VqxYQVxcHCUlJXTv3p1+/frx3XffkZqayurVqwEoK3MtwAPceeednD59moqKCmbPng1AVFQUkydb23ns2LGDCRMmcPz4cQwGA7fccgsLFixg8ODBbNiwQSI6jhs3zuVyJpOJUaNG8d///ld0VJaUWEObxo8fz7PPPssVV1yByWTi+uuv5/vvv+emm27i6aef5u23rU79b775hscff5xVq1Z5PPaEhASXx/nyyy+j0Wg4fvw4VVVV9OnTh969m3avb926la+//prffvsNjUbD5s2buf322zly5AgAO3fuZP/+/aSlpVFWVkb79u354YcfGDBgABaLpckS8PLyct5++23Onz+Pv78/tbW1yOXu3ekTJkxg/vz5ojg4b948pkyZ0uS59IbrrruOkSNHkp6ezqRJkwBEgdRGZWUlXbp04b///S+rVq3i8ccfF8VBb65bH/8+fOKgDx//cJpy+53cuY3t31tveMJi40Qx5Ni236gqKSYgNFQUC23TTuzYQuuevSWBIPb9/ayOqob+foKFqmJpf7G6Kmtpkb6mhuROXSk8nUV9rbOjxxTTkvBWHVALRkq2/+ry+FQaP6JTW3Jw7UoAaivLObBmJSaTiT3LfkKwSO8oZHK5OO7U7u30/b9bL7k4aNHrKZv/BeETxiP38/N6ueY4M/9tXOg5bS7uelyePXyAMwczaB/SGyE0pUnXIACCgCLQKgl561izF2sAxrReRmrwWTpGZhJyRknXW29nY2ol72R4Pge/Rl3Fryac0i/1bkRAf1O9y/GOfHJLe87t3UL1mVNEy/w5vf0YmlBpqdq6OSt5OXQ8pDsvP6PnWPFvxxLj2kNl+F/RghbB0hvT2tpstu9oLHPu22etR4HQMYDDnmc2PyP+fSF9Df3atyf1xx/Ie3wShpwcMDfcuJrN1Cm9uy7VJndOGNDVm8QeiYJZQ+H2tWjUejCb6bzse3bFSY+7XqZidWzjuRmXu4iK8BCOF1R5JQ4KdqXqeX7x1v2zGAk1VTq5UeH36wP46SkFoAAuTBj0w0hHZQGyBpdRgryq4f9KTuzdzlWaq6ioqiBDledNBb9bbOfEYPauFO1MYCwvXn03C2RvOk2rr1Jyfof3LjmbyCezu85UL75CfXwiuWV1fPPTZp7a8TmCzrmfp6ArwuLl9dkUSg8ffUbBn6AI19txFKWSLruMqOQgarYfRD7AKrZ48n85ipJaOYQrb/P6TsbD285HAwNvbUtS+/A/3TUIYDCWNPQYdD+PTCbDYPQuadwbFi1axMKFC9Hr9ej1eiIjrQ/q1q9fz7Bhw0RX1b333svLL7/c5HL2bNu2jdOnT3PttdKHJpmZmfTp04dZs2bx5JNPMnDgQIYNG9as/d6/fz+vvvoqpaWlKJVKMjMzqaur4+TJkyiVSgY3PBwcPHgwrVq1anK506dPo9frJaXWkZGR6HQ61q1bR2FhY81/TU0NmZnWHspr1qxhzpw5VFdXY7FYRJHT07G7EwfXrVvHrFmzkMlkhISEcPvtt3Pq1CmX89qzZMkSDhw4IBESy8rKqKuzuvH79esnuhm3b99OWloaAwYMAEAulxMe7roKyUZwcDBt2rThjjvuYOjQoQwfPpzExES38995551069aNd955h/z8fE6cOMG1117b5Lm8VPj5+XHDDVbHfN++fSXn0Jvr1se/D5846MPHPxxXZZH2HP1tvfj3unlzRZEuJ2Mv2ft2o2gQqbZ8s5CaisanmVu//4rC7FPIlUrSr76O7P17uHX6W6yc8w7l5/Ndlgq74uzhAy7HVyhDWBhwjXivOE4ZQqjJuV+RsV5P/vGjjce7y9qx/fTenQgWC9qwcHTljftt6zfoFxRM58FXE53SUrq+SyDQVa+2hhSoEuIJGeFd2is0/Vr9m7nQc9pcnERuW4iNICAg4CfX4r7MyQEBArpZU0u9LZMVHBJxf86yHutr/acTra+gZu06Wj06FTK2eLcPDpwNsu6Pv6meBF3jTVWCroRP17xBnVLD2aBoiYhn31uwXeBbHNnwM2aTkbyG82M2SIWS7DoLePPWcSgxfjpDjrB7IxumDJL03jOZpcKq47Aj3gqxF9rXUNOmDSlfL+JEn76S8f5G72Sn4up6DudXSoJRNp8sprTGwImybLFHIsC6PZcTW1FHXFUVkaFaagKkP9s2RV0hGS5VhbEi1noDJsuyioxydZHEnVqXfwsWQ7RTGfvWiMak7HG5i1wGklxoH8C543pQZzBLQlZm35JO6+hA8ivquH/hXi/X7GZ7MiMdFIUoZAKC0PgOlSFwNGMvIJBAAsejnIWz5mA7JxVGfz7L6olaYSZcU8vweOkN3Y7L3mPqFiM5Qhw52jh+G/Yz5VuXoMjdw02x+y94+4KuSPLpE5cSgH/HOMz5ldRWn3cpDP6hhDa/vFMwevd56ihKehIp7dmjM1Jhdu08TD29lKT770CTlEhVSR07l2Z7t9Lfiz8xSXnwne3o0C/+kq/3QlGrIsWyXXcIggW16tIIGlu2bOG9995j+/btYrnmiy++6HJe+4eD3i4nCAIdO3Zk27ZtLteZkZHB2rVr+emnn3jhhRfYv3+/V/3wDAYDN9xwAxs2bOCyyy6jqqqKkJAQ6utdP/Cz7Xtzl7MdA1hdhn4OD2nPnj3LI488wu7du2nVqhUHDx5k4MCBXh27N9ifc6VSidnc6CjV6xu/ewVBYPz48bz2mutelIFethJytw2FQsGOHTvYtm0bGzdupE+fPnz99deiwOhIYmIiPXv2ZMmSJRw5coQ77rgDpVIprs/VufR2X7xBo9GI506hUIjrac717uPfhU8c9OHjH45977/2Awajqyhnx0/fcj4rE8FiEUNAAOp1jTfqNned2WD9oVBVIr3pqCwsYO/yxchkcs5lHiP/+BGCI6Os/f0mXnxjZ0fXiisXiytqKysAa/kygNHNl+jds+a67Dd4KQS6qpWrxP+bI2Q5vlY+GrnQc9pc7ENsys/nI1gsVChDMMhVaAQTBCjwtgNbwGWxKMOtP/paBLfglzG/cH7NcU6cOMKM+MbSnv/kTyDZEEuFWcUko2sRsU3aZ5hu20WOQkNxUdM9+9xhL/p9uuYNJ4EQnKVP+96CwWGBDO/en825J6koOIdgsWCoUnP061Yo1GarUFgrg9Cm9yWp1My7c82cGTCIl9W9RaFKV2+1O9pKiWt1UreAbdhdibG3QuzF9DWs3bMHR0tLQk0xv/TXQPfL2HaqlNdWHHO57Kt24zdMGUReeS3jPtsFgNwvH63dIW2O6IZFmwAJVsEu1FTJdQUrRQHQkXy/OPFvwRgpcaHasBiisehduzVsGOQqog0ljCmdR51Kjk4WxuagkR6XccQm/tlE0MP50oc7raMD6ZQQglZz8T9Fy4QAlhk6MkiVRahcL75D5TIAgSpVFTuid1Bhbn5IyNCitYQZy0VHpY0Koz+YZCS27wx6qTg4fUs1OULjC3n/qipgMB3DUriJCxcH3eFfdI6Xdn3hcZ4L7T3YHPIr6kgIbV7S+e9NjcW1MAiQ3XIk2WuqgKOuZ/iD+bOSlEc81pXkDhGXdJ0XS2zsSE5nz25iLoHY2FGXZHvl5eUEBQURERGBwWCQhH0MHjyYN954g6KiIqKjo/nss8+8Ws6efv36kZ2dzdq1axkyxOr2zsjIoEOHDuTn55OQkMDNN9/MsGHDiI6OpqamhpCQEJfrskev12MwGEhOtibQz5kzR5yWlpaG0Whk06ZNXHHFFWzatImsrCyvlgsICODrr7+WlBVHRkaK52LatGkAnDt3DovFQmVlJSqViri4OARB4P333/fq2NVq10L3kCFDmDdvHgMHDqS6upqvv/6ayy67DIDWrVtz8OBB6urqUKlULFq0SFxu5MiRjB07lgceeIDk5GQsFgv79u0Ty3odX5OTJ0+yefNmSVlxeHg4rVu3ZufOnfTo0YNdu3aJjr7q6mqqq6sZMGAAAwYM4MiRI+zfv9+tOAhw11138fnnn5OZmcmKFSsAq0jp7lw6OhFt+/J///d/ZGdns2XLFm680dpeJDg4mMpKz0FPrvD2uvXx78MnDvrw8Q/DsSwyO8PqyDi9fw8bF3xKTXkZmds247X7qQkEwSI69zJ3bEHl5+9009wcbEJMuUr649c27HiD1hSOISbWfRbIO36E1j2tZQf2bsELEehMJSWUffEFgtF6zh1DCgBkKiXhEyagjGj8Ae6uhDU7Y6+Y1ixXKuk5fPS/ri/ihZ5TG9klOnT1Jok7y1tsITYfTrzNqe/agB4qZHuaFgf9ukQSNrqVZFyL4BaEqOvQ10uTfZMNsbTWW3+gz8RIBQKlCHxA4xP8jAJ/Xj0b3XBwGc06Hne46jMoADo/6fHZB6HkfjQN86ZMrhx/Hz/+0thn0FDV+AM/FGvKrVGmJLhSzsd2PfL+s+crkquLrGXMMhmWbiNQRHRAKGt0f2QV1aDX53Pi6N0uU5CPHJ0s/u2qxNgmxOqMOk5XnpaUEr8+4HVahrRsVs9BV1StXgNAae8r8Bt/N/r5nxOxaxNhW9eRMGIIWV4KuLp6E6U1BrGU2BZOY8M+rOa8Mp5SZSiVKvc3jAdC053GObpRHYddobYYqQowsvbyM+I4WVY/MEY3uayN1tGBpGnUCPVmDPk1aCsMtLWLuNBWGDBq6kiN1LJhyiB09SaPompTVAj+rDC05za//U7y/Y7oXKrxdwqo8YYwUwXRBhelizIZXbq1ZeDwgfDDAskkW4KxDj9yhEbBVsfv1BKhVvo9Z1IoOJHWlraZJ1A2OEXsy5LjZ7yFppX086nuyBmq17vvdeYN9y3Yw8d3Ot+E+/CeixX+Uk8vxV9fSqF/GPM7XIvWIgMZPDSsLakxQU5l3yqN4i9RRuyIv38y8fE3ewglkREff/MFh5E4MmzYML788kvS0tKIiIhgyJAh5Odb38edO3fm+eefp3///gQFBTFs2DBRuPO0nD1hYWEsX76cKVOm8OSTT2I0GklOTmbx4sVs3LiRmTNnolAoMJlMzJgxwythEKzi0CuvvEKvXr2IjIzk1lsbw/c0Gg3ffPMNDz/8MBaLhR49epCWlkZoaKjH5ZRKJUuWLOHRRx/ltddeQy6X89BDD3H//ffz1VdfMXnyZDp16oRMJkOr1TJ37ly6du3KrbfeSseOHYmIiBDDM5o6dne88MILTJw4kXbt2hEVFcXll18uuhr79OnDddddR6dOnYiLi6N///7s3LkTgAEDBvDWW28xZswYTCYTBoOB4cOHuxQHw8LC+Pnnn3nyySeprq5GLpczffp0RowYwSuvvML48eOZO3cuffv2pWPHjoC1h9+NN96ITqdDJpPRpk0bxo/33Md21KhRPPjgg7Rp04b27duL492dS0dx8KmnnuKWW26hc+fOdOzYUVIyPW7cOCZMmMDixYt5+OGHad26tcd9seHtdevj34dMaMqz/QdjszVXVlYSHBz8Z++ODx9/O4pyTrPouSfFskgBrGKdzBqhYHvLqwMCMNQ6C2fNxU8biEFfh8VsRiaXExobR/m5fALDI2h1WV8O/CpNdLSJf65EPncN8B2xOWi8Xa89/sHB1FVVEZHUgptfeFUMJsnet5sWXbpx9vABBIsFuVJJt2usfcuaEuj0x46Rc8utCA0hBcjk1l5kCgUIFrAIyNRqUr79Bj+7HwaOrxUymbXsWS4HQUAQBBRKFbe/+o5T+fM/nQs9p+Ac6uBYpuoNWbt3sOTtVyhSR/JtQmNz6IfrNtDL2IKWwV3dhpL4d4kk4vb2Lqfpdh3m0LLj3Nv6v+K4T7OmYTFGkI2ZZy+qI1rzcHQOCkBlTCQW/xrOPKxBb9bgp6h3KdAV6qI4urwVsmo8vt+KVRF8k3izODxnwyz8TfXkBMXwSp+7mtzH1/pPl2y/2ChDL4CfDKJUApddtoTgoE5ulz9aepRbfrlFHP72+m/pENFBHL5QEblswULO1JgYc7ZRLPsgrpRQPyXx/zdK4gb0xNxxPThYkMWCvAebnNddWI07Jl/VmpnrrC4RmaqEq+Um1liUbtfRv3Qrifpz4mdoaXA9yy4vEKfrsh+ltT6Jz73oOXg3Ncy9pxeqz5p2ZMVM6Ykq0uo2O5xfyfVzrA8CLqS/YZK8nKvUWbavPPH/dYbW5FrC0LaaQf/4/tzf+XFe3zKPPQcbrx2b07G81iB57Z4LPUpVxm/Sh14NwuDVdZ82uX+D6t+RCIQpsvNo0RNQU8fLaz53u5xMGy3pL+iIYNLTYsGHFMSkMPH5L3l/42xxWk6LFuzs24fe23eQcuaM07IJc+agio+TjDOVmqhcUdXk8WysNlLpJiPii0A979/Zg90fHmlyPWP/24fQmACqfztwQdsNUcCgoKYrCjztrzt6j0zFoDexf3Vu8xb8C9Bn5zQC6orJ10Yy8erGOJz1k/rTMjb0T9svvV5PdnY2qampTZZR2rBYjGSeeKlBIJQ39CC0AALx8TeT1va/yL2sKrlYqqurCQqyOo/fffddVq1axcqVK/+QbV8M9vu9e/duRo4cyalTpwgI+OsJwp54//332bNnD/Pnz/+zd8WHj780rj5rm6Ov+ZyDPnz8gzAa6p16/4k3NA13SSqNH8Z6PRGJLTh/wjuHRlWAEaPSgsokJ7hW+kNMX6sT+1kIFgvl5xocExUV5B7OkMzrKP45inzelg47ztfUeu2pq7LehJTl51LT0Iswe98eAM4cbCz3EiwW9q1YIgp07foNdCsOegopQC5H3TKVxHdno2nTRlwmu0SHThXBwKlvcuDzmWIJq23bMpmM8PhERkx+hsikC3c4/V25kHNqw1aW6m7YG7Zu3U2ROhJadJKEepzTwflB8YQQRuThCpCBgLXJmQwZAZfFOjkG7dH26oTfkRyez70PGdCiPh6LMYLbuLD+d+5YeE8vzqxcx/PnpGWUz1fvJqHoLKrsLKkwKANT+3b0+vprKrLWoy981O26C3VRPLv1BWvpcCjcW/MbfsWuxQCVID33VeoAHh38hNfHobdzuRUbZbxa0Fiy+FxsHUpFo6Dnql+oY+mw/bCjiLzwnl6EBai9EgrD7xzHufxKmNPY+/Hh8w0O1retfRMX3tOL0hoDxdX1klLi2bek469WcP/Cvdy/cK9TKbE7HMNqmiI0sPHcCcZIqnS5CNpYt/Mn6s8RbSihKsBITlAA5UFS8VuuLkJu8QND04Ldc9e1B4N3fWeFejO1VQYOrDtLvq7R2ZeHhVupIQC4PTESE/BdXuM1O+XqNCotZvLWnRDHtVCUA1AkBLLHkERPVS4xshpaKMrJtYQxtu09/GfArajkKp4fMJHRB3eIy9rKnAHRyajVKEkOvYZls+o5tXen+D3aqkdvrrz1WvisaXFQ6yD4J5ScJsBcS61Cyz1DnhbDgPqW7STIVI1aEUmqvCM9U7s2fe6Mapefb7lJSQ3/J7oUB/MfdX5/y0OS0Q5+vsltNsU5s4nLHuqIGpnbEuO/qlvNRnN7D159dwdMJgu1FfV/WN/CFmShzDqAxlCFwmzAr74chVlPQJ31YYp9H1l/swFVdReE2bOQqf4YMe1SIJeraN/uNVJaPEhBwRIMxhLU6ihiY0ZeMsegt0ydOpWtW7diNBqJj4//25Rh/vjjj8yaNQtBEFAqlSxcuPBvJwz68OHjj8MnDvrw8Q/i+NZNbPlmAXnHj5DUqStl5/Ik0wVBwNjQQ/D8Se8SsaoCjPw0qLF88IaN8U4CoWMiMEB8mzTyM6Wukab6CLpqgO8Kx/kupD9hQloHMYxFrpBjMUutBbZj8lags4UUHOvbj+zoUFKLK1EIAggCKV8vQmFXIuIoSqx64mWW/+cep3XeNv1tl30R/0mpxp6OxV3wg6tzCo0uMMeSTtuwt+6w7BIdLxW0hISWTmm/P0cO5ufDAGf5PuQsbToPRjArUQSpCUiPFnsMunOknak6wzj5M2Is5ydZL9Fc/+6z17WXlF4+eXVb2sYGEaBWEBagprzWQFiAmtIBA8AuAAIgcuK9pMVpUU1/npr160WxI+jKK0lsuHH0T20PDQF6hbooJweh3qEs9ZPAgYwrzyPUWCEGuNgINTWWGHfNPUegoXnFCmGJbxGkLaD6/GT0Dou27fSRpKR44/otrP1pBdX+EQwZdhUAFkMkM/t9jUxeT5uoSCyGSDEMxFFUsXeLeXKburvO7NHVmxjQJgrAZa89e7wp823OfO7YofV8M62X+zl93tvjn/AtfnVJkPOMy+n22MRQb1yGALrKeg6sy8VsErhJqaJWLsMsWIgWlKgFAd3hag74mTjh1/hdI8QGoDJIP7dLLVoqLP4cMcciIGOVoR0dFQWYG8qZb+t4A6qG74cQf6l7yb73oeNrP+KJqSyb9Qan9uygVY/ejHhiKopKZ9HN5bE5lBLbB7/Y01O3A7U6nuTOY+k9OAnzT1lNrvuMEEhWUQ0quZkDXbpgkVuPsyAutuH/OPanpwMgt1hIy8zEz0PgwMVgMZcTZqjh1QVrxHFzx/UQBUK1vz9hcc69LuX+/kDTzsG/MmGxWqKSgyg+W/2HiYNxO78UhUB32D8Aqlm3jprNmwm68srfe9cuOf7+SaSmPvKn7sMHH3zwh27v008/lfTtszFnzhyP/e0cmTBhAhMmTLiEe3bpyMjIcLlv48eP54knpA8RH3nkz339PVFUVMTQoUOdxl999dXMmDHjT9gjHz4uHJ846MPH3xibsNLl6mEcXLNK7JeXk7EPtz0FRSehd64Oo9JhviA/+lx7Ezt+/Ea6PjuqAoyUnt+PKsDqNPS2j6BNSLDNuzp6iDivq6bwF9OfMP/4EfKOHbYOyFyXhwKkdO1OQLB3vV9q9+yhIDiAE3ER+BtMJFTUgCBQtXMHJ3SVogDmKEpkHz+B4+vl2BfRnn9SqnFTx+Iq+AFBoHbvXslNjqPgao99Qqo3JcbeOg0Lli+l8+hB+LWX9njxVNbsmJB7TKZDIFwy7t6GqN9P7HoO2oc7OO7fO2tOiNsBxLJMV9jOxdqnXkSdnY3h9GkC7YRBgICAVLoI09kz6wOe7fSsuOzk7h8Qt0pPtS4GHJxuBZooEARCzXY3+Q3CY6ipkgplCAeS4jGZrefB1mNv9ImdBNb4s6BDY8DGUxnfkjTpMR7dWMgTP5QgU1XwaPdwjErpe/lcvR6/0qNoVVoshkju3aiHhJv4dqOeDT2t51nqDExm3GeNw89e57r0G9xfA56uM3u2nyoFrIKTY+CG47BgjKQmawoyRT0K/1P4xa4Qp+kLrsNc18opWdgbXlzSdGmnPbUKPyzqP8dREpUUxE3PXsaXHx3ge0OdOH5ilQJkUBBfxWqHh1I7T5dSUiMNbjhmjpEMC8g4bI7jueva0y7O6qK1T4q2dwh6+lxQKJWMeGIq2Rl7SU3vgUKphIhW8Og+qK+GkhPw073i/Ic7z+b93Rb0qFETSVuH9dWCWAptIzauJQMGj6X7NamYzuvwJnf48W8zOIGFLnILJ9LaYlEoQBCQNXxmCjIZJ9LagkyG3Gwm+exZt+Kgt4ElJhc/LSzmcgxV8xjqoPFtePMHyfDds+c6CYSq+HjEpxH/Ilp1i+TUfhe9LF3Qe2QqLTo1vv+VCoGa17o0PuBpCpmMwCuvJLAZopKPP5eJEycyceLEP3s3flfS09PJyMj4s3fjoomOjv5HHIcPH+ATB334+FtzeP0atnyzgOPbfqPkbI7dFAGZXO7S0ecttlLiikCpSy9yUHcycvZSFWB0chDalrN3ngzZksbPEa77CNqLf7ZSYHdiXpixXNIU3lN/QlfrdUQQBORKpTUMxMOP64zVy+k4aIikpNid261q9RrOh1qdMpVDrqD16fPU7dvH0aU/s6M4j2r/CGI793RyHK1evRG1OhK1xUiYUENAcAi68jK2fLOA+DZpTuXM/6RU46aOxRb84N+jOzH/+Q+Fb82gbt8+qlavkYiD3gp63sznbXpq29lvO/U7dLUNXb2JM1VnxIAMe171y8Uir0dmJ/7Yi4I27Eses0tclyA3p3y6ZOsOQk6fJnzCeKKffNKp1Myw+iCmYmlJ4Mx9D4ObPIo10VcDMOr8MpL1DY7lBtHd8b0qU5UQ2Ppt63Kp1l562H3M9HnpP6iTk2FjoTjvvCoAqXPOPmjk7vq7wU6C2fTj9w1/RTUec7n0fecp+MJe3LMXjbw9x46JxK5EqLnjenD/QmtglC1Z2DGQRDAHNZksbM/NbX6m/Z5cDqlT+cm/eanea6Kvtp5v3nY7T53COwGpFmiuzBgRH8jld7Zj1qeNpb4lcguLA43g4rvm8605Xq/7VRevtU20tzlBs0t0TQqETg9rIpxbCBgt8YTubk1TBbq3UkOP80vwE+pp3aEDd095xio6XgA6k4qhv65ma/9+VAcHIzQ4CIWG/rVBlZX037qNkCr3Dj3HwJKSiHj0BhO5ZXW8vSaTILMMkyAwdnRbwlRyXl3eeE7DDDVOwqArDHV1TuNkGoVXx+goSroSKb1Z7q9C215xXouDwZH+RCVLW0SEzp5F3qQnmhYIG4TBxL9ZSbEPHz58+Pjj8YmDPnz8TTEa6tm91PpUXioMWvFWGFT7+zv9YPdUWvZx9Q8QAQxyXWLs6DSsU8nxhqZKjJsqJfZ2vfbYUoI9kZLewykMxN7tltw5XUwc1ssMlIQGgWDhbHYWEdcMR58QydmSQiqUIUzcqIeNzq6un5XdIKEbAHfmf43Q0AvR1hdREIR/TKpxcxOa/Tt2xK9Na8LvuguZQkGLhQsomzcPmUMJsreCnjfz2TuKTuQUMXlZY0+ziUd/pDrEwlX/dxNpPTtKlnNXbrozN5PZmc5l42At1bThKXDCcb/njuvBicJq3lnduG9ZRTX4q7270c7ftpsQwHA21+mGMbtEx7mWXaiI7dRsQ8+SuBFN9hJ1TIx17KVXHBxFXcM59DZddveRI+DfKA6u2pdtDV8KbxQHt289DHj3eeQo7tlEI2+vM3t09SZR2IXG66TOriTW5qSUKaoly8oU1cj98r12DkYFlCBcoydCVw6Hmr2rEhejXF0kuT7r8m/hpCGa25Rn8TeFu12HzRXX1stzDY3nZO9hqTh6UtnMJIlmsPlkMScKq0WBFi4svAgATaNwI+C6z54jjwaeJk+fR6uefRjxxBMSYdBcUe71puNrikmsLiKkqooha9fx8w1jnOYZsnYdamPTbTsEXRECUKQwcdVCh0Cdho+WA+uPW/9QWj+H6gxmSSlxc1FF+hMzpSdCvfW1Li/QseZzqevVJIDO4SeNzgJrq4woPYTHu1ru90DVIHCqvBQ6AYIi/Bh8Zzs2LDje5Lx+gc6/Y2QqFYlNCYQ+YdCHDx8+fDQDnzjow8ffCJuwUq/TcebgPqpLvXvq7AlXT/KdSondYFQ2/hh15zTU+9d4dXPrKP7ZlxjbyoMVSiXmBlHpQvsTNofQuARadE53Gm/vdotIasG+5Uswmxq20+CWsphM7F2xRFzGoPauJLAeJTKZjLC4BLHXYVHOaXEbtlRjaF5oyl8FXUV5s44l/M5xGA317Fr6o+jUjHBRamMT9E69NJ3MzLPM6DlWnGZfktvUjb/UFapFt0t6g6xS6Ig26KjathpGDxfHeyo3fXVVxgUHTsy9vRtt40PE/fa2fLopngzsw6fajSRu3kzhG29at69SUjXqFoZ8egDwrpTeFe3yytG3i6Siwipy296DNgHM0R1nG7798Ea+bD1WItZ422dve/AAiftwR1gvp3m+K/RerLLH3i2YGqmVOP68wV5QdPX62TspHbEvMfYmrfiDA/d6nO4N1m04f7dYDNG0LKkjKzABGkpiO1ceJsBcw87wPhe8vfyKOgY7ClENHPH7/ZQdV2XXFxJeBEhLjCs0sKDp7+ZRd44lr6hnY5myHebyCq82+3YHOarX3hSHi6OjpDHNDf8XR0WRcM71Az9X1Bm8Ow/uAkeaiy2tGkBuFrxOF/4jhD97HMt7QRquEhoTwIjHurLsvQNNrkulUdChXzyBoRr0Ne5/p/gFqkjuEOFymkeB0CcM+vDhw4ePZuITB334+BthL6z8nqhM3t1E1/gZUZms4o47p+HeLrlomQNA+q5+bA4aKU67WX4UZeFJFHodcQHQts91ZG7bjL7G6p5xLAe+4433WDrzVcrP5Te7P6FXONxQVZ7Pp2DVSn7NOklJwTliUluiVGskbrfQmDjS+g3g5M5tGOv1Lp/ey+Ryr0VKvdzavN4+jCQ6pSW3Tn+Ln15/CX119V8u1dhd+IaradEpLbnjjdksm/m6JKG5XB6EUaEmMjKcO554THIsJzZbg3YCQ0LpeKW06bOppISyL75AMJoIABJ/W0FdgLT2NfzXn2l3720oI1wLXvb7WHdsF1u+WYCwazepIZFU7joIbRtLYnX+CkLMkJtzivUfv4/czw+5UklAjyEu1w3ND5x4vXMi7bvFERKtdTqfFyxeuKBOqUHQWyhb8AVYBGRqNbreV130emNqqjlpTqZILSciLJgHH3kIzTcf820L1+4imzttSSrIskokAlhTTjaLIfqC+vE1B0e3YNuYIDdzSpk7rgcBaoWkZNXV6+etO7KptOJrU1azMmeoKMJe6HlxJ1YKZk2DMNjIoZBOzV6/I3ovhag/guaGF0mwlRgLNbgSVx2RK1yUKTcg03j3mZGkVVJgN5ybmAhAZEkJXTMOcCC9KyVRUeQlJTZLHPRXe3d7kF9RR4CXbuV/Aq7Kex1J7hDB2P/2wVjvXuG0FxTdCX/e4lIg9AmDPnz48OHjAvCJgz58/E3QVZRzfNtvpPUbwOm9u9Dr3CdlXgxKjQaJBceBARkRKE0yNvQsYUNP6w3Q4D3e3YC2So1ks909050P30f9gQ3kHNhPSpdu9Bg+mivvup9f//eumCRsz5mD+9HpsvGPNGM2KAit8q4/oUdsgiA0CoPiJIFj589CQS4ABVmZbt1u7pDJZAgWC6GWhtRWhZrS6PasUTaWpPYv3cbWiH5AY1mmYxhJWX4edVVVgHMN1Z+ZauwpfMPdtMikFtw2/W0+nHgb4NyT7v/8I7G/oo4uXyL+7yQOFhdT9sUCBIMB5DKQyfE3ScUW4+KfMI26CmWE802Y4z4+G2INqck6sJeQ0+cJ8ddwp9+X1Cs0qM0GQk2VCDIZAgL71/8KDU7Hyzu4d07ZC1wvjIlgZsY0cdpE/9G0aD+MJ77LEoWczoNSJGWo9lxIWas7/E31YDaDXI66ZSqJ787mXFg8/JJ/wet8dlgaFbH38WZBY9npTeFJjHnwbr5d0XTpoSsBzNaPzxGLIbpZ/fiaw7PXtadfqwiXIpHNpepYkmrPmFo11ftLuf9wjjhuw5RBrl8/uXd51U2JzEq50UnY88Zt6IijWJlwoieZ8kHierwVH71N4fYLVDdr/35P3IUXeXoAcqHsP1tO7wTXac7Gs7lA0+elJCdXMhxeVk5IZRVpmZnIBYHB6zeQmZbG+WB/trRJxM9gpOeZpnsFxIf6ia0VsopqJOdluE5FQotgPi4p5f6Fe0mRneftwYHs+arJ1f5rsAl/fxQSgXDdun+kMKgzm1l0rozb48PRKi6dIL1kyRKmTp2KRqNh4cKFdO7c+ZKtOycnh/T0dCoqKi7ZOn9PXnzxRdLS0hg7dmzTM/sAYOPGjUyaNImMjIy/3evtit/7GJYuXcqGDRuYNWvW77J+HxePTxz04eNvwh/lGkxs14nC7G1up4fWXPiPTUtJmWRYq1HS6brR9LhutDhOLm/80ZfQrgOXjbqJtZ+8T01ZKUd3/EiHW0+J049+3QpDlbrJ/oQAav8ADHW1KDUaNGY/WgR2wE+uJVddwJn6TEz1tQTrlNLkYplMLPG9/PbxbFn0hcTtZvvfTxtIfV2tyz6P9sJhqKmSSlmoRBgECDBLAyYMchUnd26ViIO2Uua/Wqqxq/ANb6blHTssnhvHnnQlJWXk/foN8aXrKQ3oQF7+GesyeWec+xK2b0/qjz+Q9/gkDDk5YDaToCvh0zVvUKf2Jzgmkj4L56Jp08bl/pc4XJPZmSeIBIpDg8hs74+lsoqORXmUaf2p1agQbMKwTIYMCLNzbW5ITHJ5M/1aGwtdho22OhNlZ6BxEoVrdtAxeJBEZPEkANr3Q3Tcjn35tO18bztVKgnemDmiLaonH8LfqCdB1yCgCwIpXy9CERJCKrhd/zvXtSJq21pO1Ct5pS7J5f69tioTHNKXdfUmgoK8c9tNGhrPzKWuBShHccyTWNanbCfBFoHVke5F2wevaMX/Np1yOe21Fcc89p9LjbS6Omdc24H/rDzqNF0pwIad+WC3uE1ccsLiXkhojjuyzuTfZD9HT7gr+06ICOJEVT02N5y34mMeFm6lxm0wydxxPUmMCUQV6c/Ce3ox7jPXpcV/FgdyK8S/3T0AuRheWHKYFyL9GNAmymmaxazHG3HQWF8reVzU9uRJyXS5IND++HFK2yRSFaDBpPDQoM8OhdZ6fddWGTi4QSpARljk1J/RgRZSZOfZqHmSwq1a9tDdq3U3RXP69jVFh6PzADja4a5Lsj7lX9glaRMIazZvJnDAgH+UMAjwWV4Jr50+j95i4dEWMU0v4CUfffQRL774IrfddtslW+ffEZPJxMsvv/xn78ZfDkvD73q5/MLakviQMnLkSEaOHNn0jD7+NHzioA8ffxPsyzHLzuX9LtuoCjCyN2e7U99Ae2r8TJiUUoHKrJIxeE8kmgAtOkMNm9NLxWkDMiIIrVGhMskJrs1lvN93XPXIUySlpri9wYpp2ZqIxGR6jhhDydkzDY45qC6TOpoUamvZjqv+hFEtUolPay+WKYfFJdC2V39amTtRu6cIQRDIVxcyo/Vn4vpu2JBAcK1CKhDS6MxLat9ZdLvZo6/VOfX6cZceWC9z/tiN7XkFnG0cjr5iFBUaI9/NW0h0w82+rZQZQBsWTmL7TuQdO4yuvIzM7Ztp3bM3Fr2esvlfED5hPHI/P69TjZvrijEa6ln+41JS+g4ip9wgmXYiv5z8Cmsfy7OlUu+QfcneyV3bqFCGENoyjY7pPWB343xHjmYRtW8BidoCOltWcVTVhVKj1hrMsnwxAHKZjDYduhCQ3h1NmzakfL2IE336iutI0JVArYy2q75HEeLswrMd87GzUodpqTIEi9qMBhOCphIhKgS5xUKv0+fZ0SqeCmWIeJ2Fmaskrk135y56/zY63WNNjj1TJZ1HZZJTc2gbG6ZM9vo1cDfdPtHYHQlFOQRXSD8/8gMiqNqwm+jL+4qiF4BeL32/pcj1aBd9wsnwNtDH+5vtrKIaWhPKtG4LqNDXsO3sUXbp3nc5b4R/GDJVlksByt6B2ZRYNvqKrpTVCazO8rxvNiG0vNbgJE65K+G2f7/07BgNduLg6BoVepnA91qD03KOQTXuxDh7LIZorj2aw/KW/T0eh0xVwvqiNLf9HO3P172dF6CW10v6E3rqe7grYgPaiA0A1OaOk263CfExD+kDE3f9P8MCXAthj1wRwvubmtEa4hJiE8bnjushGX8pS/tLa5yvEwC5v0VMDnaHYNJTMnw4ztKie2o1aja2S0Jptn4/VSsDMcqUqAQz7dumMHDsBFTBwahTUgDQVdaTs7NQInJXySwYG74jtXiXXt0cQmMCmizLrS7Ts/KjphN3tLXNTFRqgqBw96/HXwGZSkXQlVf+2btxyakxmZnT4Hidc7aQuxIiCVRevFD72GOPsXnzZo4fP86cOXNITU0lMzMTg8FAUlISn332GbGxsQDMnTuXd955h8DAQMaMGcOLL74oPuAcO3as2+Xs2b17N08//TRVVVWYzWaeffZZbrrpJoqLixk7diznz59HJpPRo0cP5s2b53a/Bw0aRI8ePdi9ezc5OTmMHz+evn378tprr5GXl8djjz3G5MmT+eGHH/j4449ZvXo1AGazmZYtW7Jy5UqKiop4+OGH6dOnD3v37uW5555j+fLlpKenM2nSJAwGA8899xwrV65EoVAQFxfHqlWrOHToEA8++CC1tbXo9Xpuv/12nn/ems3ubhmAt99+m++++w6TyUR0dDRz586lRYsWrFu3jueffx69Xo/BYGDy5Mncc481wK26uprJkydz4MAB9Ho9ffr04f3330etdv19YXO9Pfrooyxfvpzq6mrmz5/PDz/8wIYNGzCZTHzzzTd06mRthzFjxgzmz5+PXC6nS5cufPjhh4SEhDBt2jQOHTpETU0Nubm5rFmzhsOHDzN9+nTq6upQKBS8+eabDB7s+aG7t9eFDdt2y8vLOXfuHG3atGH+/PlERERgNBp54YUXWL9+PQaDgbZt2zJ37lzCwsKYMGECGo2GrKwscnNz6dSpE9988w1qtZply5bx3HPPIZfLMZlMvPrqqyQkJHDHHXdw7NgxazUU0K9fP1544QXat28v7s+rr77K+fPnef996++1mpoakpOTyczMpKCgwO11MG3aNI4dO0ZtbS2nTp0iNjaWH374gfDwcObPn8/ixYtZvHgxAPPmzePdd99FEARUKhU//PADiYmJDB8+nNLSUurq6ujatSuffPIJWu2lce378IxPHPTh42+ErRzzg3tuveTr9pRQbI+tlNie37oWN/xV4lRiHFqjIqLK6vCJbhPGTePvIDIhgIAA9x/y3a9tfKoUndKSm16ewoaFH2AwVUnm8wu13ljZlxgHBIfQfsBoBt5xF3K5givvup89y35GqVaTUtue2r0FyLA6AusV0rvaNpG9KMzdJ5Ya24SgTb9tx78in7K8XNclxA7jbI4yZNZy4IR2HUi9/g42L/mZ8nMVTosvPCv9oTMnS43VNaJlXO4iwsxVktJnXXkZmdt+Q9bwJFPeMK1wyWJ2fLuAgIIzaFq29CrV2FNZsDs2rt/CpAMBcMDZ6TP5J+cm/zbsXWgvdm7NwqQ0awX7bul803bVguopMMA61WRuSTnI12e6Um4IAEFAW2+kR34pYZrGJva1e/Y4C7KCQO3evU43S55CPVZHNvbcuzPva+Kri4grMnIyJIGz/oksiRshTrcv/84u0VFZWILplyUIJjPQmJwr272DwjfepM5o4HjpeZ7reCtGtYxTW7YQVCu39q5c8TUAZUolMV6mTju60Fy50hzHCTu2AuDfozsx//kPe2d+xMT4EbCjHnZsFF//2tpsThy9G3hBXDa8XRvif/yBnS/MbnLf7HEMSpH7ydwGtLy0cgMPD2nBFzmN42wC1JNXt6W0Jon523OdlrszuIoFVcHicEKvgUxtwon2v02nSE8OJUCtIEQhMCmsnNnlYeJ0V/3nXL1fNkwZRFmFnpWz9oMAnwa77iFofx48iXES5LUEJMR7nMXTulylYVu0CuKDSxhfsIQvYkdZ1+Fl30O5Riq2uBIfPeEoYLtL+LYRE5oI/DnioI0TBdIEafvrAriocuMINyXVxdX1YnKwJ345dJ7meuJqNdZtOrZzWDvpcrSx0ocLUUlB3P9Mb7QfHSC7XMdirZHFgUZSZOfpiJ7WMusDBLXCuwQRtb93ASZNleV66y5MfncGALsXljYxp4+/Mp/nl1Bjtj5oqDZZmJdfckncg++99x4HDx5k0qRJjB49muLiYqKirHL7G2+8wbRp0/joo484fPgw06ZNY//+/cTGxvLSSy9J1jN79myXy9lTUVHBfffdx4oVK4iLi6OkpITu3bvTr18/vvvuO1JTU0URr6xMWtHgijNnzrBhwwaqqqpISUmhvLyczZs3c+7cOdLS0rj77rsZM2YMU6ZMITMzk7S0NJYuXUrr1q3p0KEDRUVFHDt2jA8//JDPPrM+JF++fLm4/tdff50TJ06wd+9eNBoNxcXW3/kpKSmsW7cOjUZDXV0d/fr1Y8iQIfTp08ftMosWLSIzM5Pt27ejUChYuHAhDz30EMuXL6d79+5s2bIFhUJBWVkZ3bp145prriExMZEnn3ySAQMG8MknnyAIAvfeey/vvvsu//nPf9yel8rKSnr06MH06dP57LPPuOaaa1i2bBmzZs1ixowZ/Pe//+X7779n5cqVfP7552zfvp3Q0FDuu+8+pk6dyv/+9z8Atm/fzv79+4mJieH06dNMmzaNX3/9leDgYLKyshgwYAA5OTkeXyNvrgtHNm/ezMGDB4mNjeWhhx7imWee4eOPP2bGjBlotVp2NYTkTZ8+neeff54PPvgAgIyMDDZs2IBGo2HgwIH8+OOP3HbbbTz//PPMnTuXvn37YrFYqKqqIjQ0lIiICNasWcPQoUPZv38/xcXFDBs2jDNnzoj7cuedd9KjRw/eeecdNBoN33//PYMHDyYqKgo/Pz+31wHAzp072bt3LxEREdx6663MnTuXZ555RnKsGzdu5OWXX2bbtm3ExcVRW2s1FCgUChYtWkRERASCIPDQQw8xZ84cpk6d6vHc+bg0+MRBHz7+ZuQdO3xhC3pws4H3CcXNxRZuog42EH/lNk7mbuNkLvTts5aAgKYjXGtrszl+5k7iBjpPa3FVo5hpKzG+a9ZcSf89uVxBr1E3Yiqto2DGHgDyVUXUKfScVRdI1mcJC6a2RoWpvhahPkK8cfr2NwPjz28AeQHGYEuDC9Jzyc5t09/m6Ob1mAwGIvoO5aqZm4GeEO1xMScUoZFQWtVYsiwIYqlzQGgoeUcPU19n/UItXruWnMgQLMcOIjt+yKtUY0+lv+44tm8f0KF5B+KANiUNDjVh6wLqZH74K0y0CixjT5n1hvEKo4qWX38jKRWuWm3tZ2cTvQrfmkHdvn1UrV7jJA566/yplylJOV/PA1c+5XJ6qSqMkzu3okjpZCcYteLTNW/wqVxGncoP//o64vXllC34giq1imNtErGcP4tMJiNYpkTAcsGp0/Ylxu7ECcd5QlaUIbR5kvC77kKmUBDyymvw4Xanc2My64jRFvNa/+nozRou6zYbgJMB0QQ9OgmWnfDqHLrEQ489/4RvJcIgNApQyj2HmF/uuh+UvTC48J5ebp1ojkh7BoZJprnqP+fq/dIpIQQhrxYEOK/w7nPUWzEOSwDfazz3VWxuoMmHyskIMiWxbY5Bg+7lbWiOX/RqybAr8dGe6aM68oJdKnBTyc2OvOCQKHx18nrWnu9yUYErzeWdNdJr3V0quO0akXkpXL00piP9XZQUA9QbzfzeBayO7Rz0bvS9iPhA7n+6F689tQloLCW2J0yt5+5WuzGY7fb61kUQkigOqv39CYu7ND1CvXEX2od+jG1d63HeuhqD1wnDPv5YbK5B269XgUvrHrRn0aJFLFy4EL1ej16vJzLS+vmyfv16hg0bJrq+7r33XkkJrrvl7Nm2bRunT5/m2muvlYzPzMykT58+zJo1iyeffJKBAwcybNiwJvf1xhtvRKFQEBYWRsuWLbn++uuRyWQkJCQQFRUluugeeughPvjgA9577z0++OADHnnkEXEdLVu25IorrnC5/l9++YU333wTTUM4kk3kqqur46GHHiIjIwO5XE5ubi4ZGRn06dPH7TKLFy9m9+7d9OhhdWGbzY3vxdLSUu655x5OnDiBUqmktLSUw4cPk5iYyOLFi9m+fTszZ84Ut61oot+kn58fo0ePBqBnz54EBgaKDr9evXrx1VfW5qhr167llltuITQ0FIAHH3yQm266SVzPddddR0yMVYBetWoVWVlZDBzYeCMil8s5e9au5McF3lwXjgwfPly8zu677z5uuOEGwHoOKysr+fHHHwGrSzOlweENMGbMGAICAsTjPHXK2jLlqquu4vHHH+fGG29k6NChpKenA/D444/z/vvvM3ToUD744AMeeugh0UVoIykpiW7durF06VJuuukm5s+fLwqznq4DgGHDhhHR0Oe7b9++HDrk7PRevnw548aNIy4uDkDcf4vFwqxZs1i+fDkmk4nKykr69evX5LnzcWnwiYM+fPzNOLnL2g8woV0HBo69m6UzX0NX3vRTRk/CIHifUNwUYToNd+zvQKWuTCKi2UqAbZgc+uy5w9v5bOt313+vNqMYZJCvLGJi62ku1zEj8QtouJcZlZEsmdb1gQm8dOIxcfiGjfFuBUJBEFj1v9mEJyTSc/hoTtc05f9wT3RsNPrS007rT+rUhUPrrDfq2Xt3seKR+9FnnyAegbLAAGo1KvE1d0w1rvaP5NcjVmG0ziB9XWyuGI3cQtmONXQfPgpDbS17VyzBYrIKIyWZhyDu4sTBAIt3gkaAoCezMoJ1Ve2pV6lRCyZkT44n4/B+urdIFoNW/Dt2xK9Na1H0arFwAWXz5iFzEcTibaiH2mKkZsQIcHMJroi9lk5BZuSFUmeRMaUlKcf2gMWCWSYjKyqE1NJqIuMTueXxp/n1x0VOvSsvNHXa3tF2OL/SbYCGyJ3jxPl19SZOldZJ5j2Sl02NzozcbC09jtFan/zX1Z5lxP+8Tzv1iIcee66wCVAfArKapgM2wgLUlzS4BeBEYbVLh5tteN2WM24dg65oboK1jSuKf2NT1ECP87jjxs6/slDzDILWem7KLOHIsb6nPaVC64uuxi/6wsJkLm8T5VbArqzxLrJk7rgeRPiVoVHWs+fcUHZop4jTLiRw5fdi+6ps8v2sr8WpGgMW3W8Ipjyy/ZPYGd74ndS7bCeJtaeJ+a0t5h5TUSilgqmu3kRhVT2e/aIXjs0RX66SiuGekppzjxYhrzsAQe3clhKHqR3Gx4RCfOtLtt+ONCf0w37eikJnodA/UM21D3TGZDCjVCkIinAuH7YXG338cdi7Bm1cSvegjS1btvDee++xfft2oqOjWbp0KS+++KLLee1FFG+XEwSBjh07sm2b657eGRkZrF27lp9++okXXniB/fv3exTC/Pwar1GFQuE0bGr4vXbvvffSoUMH7rzzTrKysiT93gJdBNk1xbPPPktkZCT79+9HqVRyww03oNd7bi8gCALPPPMM9913n9O0Bx54gOuuu44ff/wRmUxG9+7dxfUJgsCPP/5I27ZtnZZzh8Yu6d3TeXHEURizPzeCIHD11VezaNEip+Xy810HuDXnevKEbb8EQWDOnDkMHTrU5XzujnPmzJkcOXKEDRs2MH78eMaOHctTTz3FDTfcwFNPPcX+/ftZunQpb7/tuvrg7rvvZt68efTo0YOsrCxRuG7qOvD2vLti0aJFrF+/nk2bNhEcHMx7773H+vXOIZU+fh984qAPH38z7PvxyeUK7vtwHpsWfs7xrZuoray44PUG16q4YWM8RqWFikCjU99ARV0Yy+OvAEuA082jpGm+YQ0dUzqTuX0zCe060Ofma9i9/GuqKzMl26vVWZ9qKRVajw5CpcK7Uq3IxLbkluQ6BXnYMNcYQCajTuFdj6TsBj3P1hdszf48Sd+lQv8QLAYVoSbXJW+n9uwgJ8PqAtMGNu8H7H0J5VTtWY/KVE+ducqlsHtg9QpkMqugK1gsHCvKg4hga3+8nEJ2pMa67J14Xi/z6Naxd8WMy11CcGQUEUktxDCcSlUoBoWaUeeX4W+uo0wdxuroq5t1fAvv6cWANlHUW2DKSucS0SeV39JWlkcb8om2lPLxmQEsaHuHOD1i6UrMBSclQSvhdzr2QlMQMXGiy+17CvUAeP3KGE7+9is6uYrtysaEY1chGW8dVcBRaWJt3eTnyWoI/UCl50RcBP5GM4MbQj9uS+/usnelu9Tppmhuabgnx9bTP9t+6Cp5rX+UKA4ezpwJuHZQ2jOyaxxLD5yXjHtyaFvaxgQRoFZQazCzOzeQby+wFZg3ARt18z8n2s/C2om3sOhYJZ9vzbmwjdnhLpXYnYvMHf1LthJpLGNJ3Ai3YpynEJJkfR53nv+Wlv2u5GC1mp9KQjwKe3X5tyBY1Fzbfh1CoApB3fizTwhWYQGeu7oNR1avYWltoutU6Hr3PZLssRcp547rQduYII/XYfHxg16t17oe6z4czP5WMi1BkU+eC3Fw+qiOdEsOcwrk+T3Zvuc8x40yVIKFwKrlWIzW77gquYoTdr0X29cXUGMso2bvTpbNeoMRT1gFQvv35RW5Z/CmgMog9+5nfLk6GAX1TqXE9rhLagbIWL2BCMWvvNb/e3RlwZDd9DZzaxW4ji26xBSfgBMroc9DoFCB2Qg7PoS210KUVFSoKKzlq5d2NLnKsf/t4xMC/wI4ugZt/B7uwfLycoKCgoiIiMBgMDB37lxx2uDBg3njjTcoKioiOjpaLMNtajl7+vXrR3Z2NmvXrmXIkCGAVRDs0KED+fn5JCQkcPPNNzNs2DCio6OpqakhxEW/5OYSFhbGqFGjGDNmDA899FCTzjsbI0eO5N1336V///5iiXBUVBTl5eW0b98epVJJZmYma9asER117pYZPXo077zzDjfeeCPh4eEYjUYOHz5Mt27dKC8vp0WLFshkMn777TcOHGh08I4ePZo333yTuXPnolQqKS8vp7S0lNatL/6hw5AhQ3jyySeZPHkywcHBzJ07163wds011/Df//6XgwcP0qVLFwB27dpFr1693K7f2+vCkRUrVlBYWEhMTAyffvqpeK2MHj2aWbNmcfnllxMQEEBtbS3Z2dl07NjR4/qOHz9Ox44d6dixI0qlUixdVyqVPPDAA4wcOZIxY8aIDkpHRo8ezSOPPMLrr7/OHXfcgbLhYZan68BbRowYwYQJE3jwwQclZcXl5eVERkYSHBws9o1MTk5uYm0+LhU+cdCHj78Z9v34wFo2O3j8vfT9v9t49f77JaEczSW4VoWfNpBrxt3J5kNPi+NDa1SY9SFYal0nvloM0Vj01nKhepkSlX8AA26fQIerurFz11DCezrml8KRo5PFvz2VGAcEpNK3z1oO/7YCo/kcev9vxGm6rP7EJPai86Dh+A1KFnsLukIRqAZBwN/sXUPxbUGXI6Oxl9cWh+lrE7tgiY5mVP5qEqucBceAkFBueuFV0QXmKWEWpDdmVbvXEVVfjCNyhYKQmDjKGwJpBKHBedZQMq7VG+ieU2B1DdrKyO2eOuYdP4I+rp1Xxw/WsrPMHVsYPWAwd7wxm3kz32WBprEn37jcRYQZyr1en41ag5nD+ZUogyMAZ3HwHdMtAGxQT0arNHJ5aiXv2U2vqtKhpemgFXvOVJ1BZ9ShVWlpEdzCo2gRnpDI56Z0SEgX25059nXz5FiavOwEDJoEwKSjnwJGzocEiP0P7ZOabXhKnW6K5paGe1tWrbcTe/y8LF11FAYB3lltLcu0CQ4Jof58ttW1mNUUTbnkXt32MYFFJzgUGkdo76uICwn2OL+NiYeX8WmnEZJxT2V8S+/nJ3PM38SLy/ZdkjLWEFMVyfo8MUApzy+e7Qkpknk6FBdxUNNNHB5atJYwYzlqwWT9XDfLKN3wI/V+yRB7HWB1/vWK2M3uCqnfbEDyHvaYT7GpBqg5hyKuALPKKrQZu1g/lV+qq2LM+aNiCajjOX5AU02X3l9xqrSMmZu2SF6vhzu+SOuwlrSJisRiiGxW/72ag1sZl5tJdKduJA27TfIZ+Nx17enbKkJcl+39a1FIry+lphA5+U6vzeVtoi5JonBzWOZngIavl1G6epIbhNZkfR6jzi+jVuFHgFlPsr4hEEgQOGUnENq/L+sV3iXNFmgjuGfI0/ib3L8/65QaBlRuJNpQ71RK7A7Hz4jayqMo1GZitMWcMWsYVP8O2oaeg++qPxTne9zwEFlCAjr8eN8/+fcXB4uOw7xhUFcOeXvhhrnw0/1wbAlsmQV3rYLoxu88T6XF9ng7n4/fF1euQRuX2j04bNgwvvzyS9LS0oiIiGDIkCGiK6xz5848//zz9O/fn6CgIIYNGyYKd56WsycsLIzly5czZcoUnnzySYxGI8nJySxevJiNGzcyc+ZM0WE1Y8aMSyIM2rj33nuZP38+9957b9MzN/D000/z3HPP0b17d1QqFfHx8axYsYLnn3+ecePG8cUXX9CqVSuutGvb4m6ZsWPHUlpaKpb3mkwm7r77brp168Ybb7zBQw89xPTp00lPT6d378bfQLNmzWLq1Kmkp6cjl8tRKpW89dZbl0QcvPbaazl8+DB9+/aVBJK4onXr1ixatIj777+f2tpaDAYD3bp1c+kktOHtdeHIgAEDuP3228nPzxcDScB6buvr6+ndu7foJnz66aebFAefffZZMjMzUavVBAQEiD0VAe655x6effZZSam5IxqNhptvvpkPP/yQY8caH7R5ug68ZeDAgbz00ktcc801yGQy1Go1P/zwA3feeSdLliwhLS2NqKgoBgwYIOmF6OP3RSa47K7/51FVVUVISAiVlZUEB3v3o96HDx+wcf1WJqyuEIfH5S5yKRCq/Pwx6uucxgMkd06nZbeehPbpyOhfbhDH37AxHoshUnQceBJKxuUuol+/Hlz78GSqqg+ze/eoJvf9ssuWEBzUqcn5HNfn7XKA256DMxLmi/PckTeOucZQ8UZTEXiEgKSFTa578J5IwmrUYplxVYCRES9OIyoinhbB0hLRNScPc/9X26x91ywBzB3bj9ZhqRInl6vXThOgpU3vfvS/ZRzrPvsfWbu3S6YjCFx9JAeV2cKBpGjyw4OIb53GFePvZdOXn3H01DkSe/YjZtBor91Oo84vo4XxPN2HWUWTjJxiZtd2Eaffkv89eoUfS2JHuFzeldOuOcxVvkOCvJQsIYFJxofF8dcUryPUUIZGbuHKqwZSJJRjUFroOeg62iVIe9Jll+jIKs9m8rZGp94vY36hRXALskt0nCisdnKFPTm0rSho2ZD75aNNnSMO67IfFQVxT9x2/kci9UXILAJtQ6MIHHA5OQf2UZp3VmwNsOnLzziXeYwOA6/k2ocnN7lO+2NzJzi7SoS1X66pXm8Ar/WfLjoHAQp1UejNGrRx79o5DGHioEA+35HZ5Ov83HXtGdLBeiNn277jea3LtwrD3jrpQHqdvbf2K4JjIhnfbmyTxze+Yygtly/CVFSMXq5kRk/pMjOuiCW+QwAPbLxZHNfcMlbH94Dje7tIHcl3KYMln6c9d1zGhpD/E4dvyf+eaINDEJRMRrA6ilfjG+cbkryedee7SNZVmztO8hlWHjsdkzrFaT/H/DiflYGNDuAxpfPwp9LaGqJOTasevUm95SHGfP6D5PX69vpv6RDhXYsBXUW5pD3B/l9/wWIyIVcqCRs4mmnZ0v57NjH5TNUZrv/5+ibXPyntM3onpXkMkLkQ1JG/Yii5ptnLufsOtmGffD7+icckvUvja4r5bO2bTW7jniFPcy6w6bxi2754cg7a88kt7dEc+w2LyYSgLCNzxzrUQbW0uOochboont1qDSrqKMtmueY5cbnh9a9yRLA+6PMm3OqiKD4Bnw8FfRUIZkAGgdFQUwQIIFOAXzDcswYirQ82i89W891ruz2uFuDmZy8jKjno99v3fyF6vZ7s7GxSU1MlJYfuqDGZ6bbtCNVuxEGAYKWcfX07XvLeg66orq4mKMh6Tbz77rusWrWKlStX/u7bvRS8/fbbHDt2TOJ49PHXY9q0aVRUVDB79uw/ZHs//PAD//vf/1i3bt0fsj0ffwyuPmubo6/5nIM+fPxDyDyQAaSIw5roeDjnfGPS+rI+yGQyjv7m3L+h27ARtOiSzqoPZnHDQWuJcWJyW4Y9OoE1n7zPuNxF+McmcqbUxGqmiDe9tykrMOdsYOCYG4nqO0Z073lbEmybz2ioZ9/yJXQfPkrsJedqPnfDHrcR4U/AZbHU7ikgwRhtTcl1IC25HZYjCmSqEuR++U7JnO6wJTjfsNHq2vlp0Dl++s3aW2X2oNn4q/wJ1YRSUV/B5G33S5JaJ2+bwy9jfuGHW1vx0+y3URjrXN5Q1tfqOLZ5I92GjaC6zDkxGpmMMq0fMVW1hNTVE3jOwIB7ryWkbTt6PfICz8zcDIVAM8og/Sx6yuVBfL/hAIIgYJKrJIEqeX7xbI3o73JZRwF5RPi7LNpaJ05zJRo6jr/f9KTTegF+jWp0L9Zsmc+a/sfBBKz9UhT+oFEYsApQjcvrjDqPooG9MGjbJ1sohg1vUlplqhJ02grUciMhdWoyq0pg+WJkcjndrx3JFXfeg1yu4JZpb3h0vbrC0/57Kg8Ez2XVb45JoEWYtedg9flGYbBjh5lcpm2FUqHldHk4kC8e47eFU8Xz60k8e3XFMV5dcYwNUwax8J5ebMsq5WS5jJ1270VzXZJTwIa9M9kRx+ss80BL2j31EixtOuwmIDKCl1Kus//YlPCfTQXId0qvnTv7xfDFpkZX0XPXtedVN2Wrjvs2MKO/03tbbTFKyoIFswb/ut0QIp3HCUHghukvopr6BtNaWMX5tWetT+5rsqaIn10yuUGymMJofd0EmZ/oIASIMJSLbkar81wP2D6DrQ63YrMGwSxNVNKqvP8M1lWUi+0JZDKZJDDp9Oa1kCgttbe513QlmU7rckWC4hydEqRlXvbXeklVHRO+cF0e7gm534XVwHty6Z31kyafj09s5/S+vAdER+CUoWloVHJeXd54rdUpNR6FwTsCczCe2IPabBCvu1BTpfV1VqhRte3JlzUpLpfVmOrYt3wJigAdHW47RZvRjdNsQUX5NbEYKrTW75UGJl3XjbiWnS44vblZnFhpdQyKCKArtv4PVsGwrhwyV0Dk47/vvvi45HxTUEa12YICpw4pgLUwospk4ZuCMiYmNi2QXyxTp05l69atGI1G4uPjvS4T/bPp2LEjMpmMVatW/dm74uMvxLBhwzhx4gQ///zzn70rPv5i+MRBHz7+5tjcQ7VhyZIf6dWBsVSri51KjHOPHkLt5y8OyxQKAoJD0JWXseWbBdSUFnNixxaCURGekMT4596j5OwZaisrCTWbIK+SML9oBGOk2J/KnLOBaEMJNYe2Mvyl18V120qCTWYdtbpTklLigOi3kKlTCPZv7Dl4cuc2tnyzQNJLzh779TXVq9AVYaNbAVC7uwABAX/BXzI9/frOvBW9n+kFrhvzNkWZJoAgszSwYNLGSU0upzPq6JnegZTpL/Djay9S4yJfRuXnT5tefTn623oKTzcKH2169ydvz07qzCYKUpPo/cw0/N+aQVbmWfau3UFqel/qjBdmEPck/gEepzkKPCbBWnotDziJtkXj0+uaLGu4gFxTKHE4eevQqlNJ7xp0xsb0kKzybKvI6yDsna48jVBfg0xV4nEbjuKOPZ5SWqcPSeTo2k/4pfUmNjRUv1yxtSPhtUpSowKdQkdsidrusL3H7W+4vS0Ndjefuxt3jTqKmPBQIjQadttVcAZoW4ku3criY8j9rKWcjq+zY0/AJ69u65T2mpF9mCd+bBS4ZaopDmKxVPx2LHNtV3WU48EdxO3Z82H34Vi8EAYB4kPdu1fcicJf7d+D3M+9i1GyDod9WxnSnbFF1eLnsc051r90K1sj+ovnzSRXcV2B1ZESYSx36z5bO+8jMlWuy0ndOZ6DSz8S/+6ScyUJRbWojQbCKktdzi8iCFTt38S8B57FmPg1Mnk9baIinZzRnohOackdb8xm2czXJYE85fIgjHIVV5uOsEbZWCJlC8iorfAuuMSid30uUiO1mE0mli2aw7i84xhkStSCCVW73nxe09JpfnX0LxiKGp2KCk0h2lYzaGtpw8tDXiIwJMylsH5H72S+3NmYXlmuspZtO34HVyhDJMIgNCYF296X52tzKYg0IJj9EIyRJPXuRqeEEFL79nC57Zk3dqb4TDav7278/rnpztvI/racU3t3SrYVaq6iVXpvUm+5jS8/dHCgN1CmDKXnk6+zZ/Es4JTLeSL8yykFBp21lhjr8OP9lp3olHDpyiE90uchaynxsaU0CoL2LjMZtB9pnc/H347eIVrGx0d4Nd8fwQcffPCHbMfGp59+yvvvv+80fs6cOQwYMMDr9Rw5cqTpmf5mjBw50ikpOCwsjA0bNvxJe+Q9GRkZTJgwwWn8+PHjmTZt2h+2Hz6x2Ic7fOKgDx9/Y6TuIWna8LfGdpBg7bXz7f8lcfy7jyk5m0NNacONt60nnSCIaceluWfZufh7cR0Vhef57ct5AHQYOJiCM7uorSokwCQVwGzOlnMnjrFxwafWvVEq6Tl8NAEhqRgN9RxevwYaqnQKdVE8+6UfYE3M3TAlidRILZnbNwPue8lZRZJwtJroC3IlyBRywv+vDYWBeeT8tI209Mv5JvZjLG38CY4MI9ISTPbmxeC6tWKT5EfpUMprmp7RgV0FuwDQhmhJSOsgngewligblRZUJiPG39Y7Jaqd3LnVemzIiLt+BP7p6dS+/jwT/9eQcPz2Rj4Y1TwR1YYn8c8d7kSVnw7vQxGodhItFIFH8Y9d4byeJoInbNvRm6RRwqcrT3Ouoo4iXRmv758scX3ZeGbzMwAEtvYsQjqKO+6YODCeT9Y1OrS6tU+hc9pd/LJ+kzhuRfyVWPQJzLmxA9X+kXhbmOoubMTbNN6m5nOcbhMcVjzcSjLe5tLddm4bD2xsdL/e1f5R5tkZ5xwdlYVVeidH6NKdPwGNjavtHzTYhu2ddI6vT1JlDZkRnh2dVxTuoHtyB5e97KKCNEQEqkkMcx040BxR2LB+LSB1NXpym+bFyfC3VGPSxbAwzHV55+roIeLf43Ld9zTKO3YYpdJZiPH2uk1WqYgsLWgyyd66UhmtevRmwIBeknTd5hKZ1ILbpr8tBvJ4E5CRIivhF+05dHIZp1UqnoluvB5eLyqhpdGI1iIw/ng17dvrnL4bzCYTy2a9wam9OwkVBFGULczOhihncVCuKkXbaoYofsvVpUQqLehlxWzL/4j7W73icn/thUGA1dHS/qy2st4CjbPLacPxIvIr6mgbE4RcXcLkbbdJ3LjltQYxjdyV+Ja/5nuKDu8Du3NZVW9mxBNTxWO39aBt1aM3I56YyrZs9/1iG98zI3lNd8CpvYCtrNiRS50S7hGFytpj8N0dVsegvTAok4M2yjrdy/6NPv5adA4K4M20f28ozMSJE5noJlTt387SpUv/7F24YNLT08nIyPizd+NPRbBYsNTUIA8MRCaXI1gsmKurEerqUEZFIfMyNMfH74NPHPTh42+Mt+4hbXwLxr35rphqXFdVKQYi2NwbVgRqyhodJBaTib3LFwPgH24m7SarA6gt2fAt6GoDUFuMhFmqERrWtW/FEgRBQKG0JvUGhIRycuc2Dm1cQusGs4TewQm06cfvOeNvIufAPgBO79vN+nlzkSsUoshYaFQ1K5HVE8cPbOZ0xS7qayyMvqbxJqco5zSFRXUXLA6ebO0cxuAN7+x5R/x7imq0+HdVgJGfBp0Th+862h3OlDndzIfHJ4putNrabHbsfwD7ZNmMb+cxqryaWoUfBZo4DoV416exuXgrqkjGuxAGoVHksfVmtBeJehm+5Vj7/QDscVjOJvx5y3u3t8esT3DZsy+j4CRvHm56HS3Cw7DZdmWqEgr0WZzJ3iyZx3Y8jy2xuhW9vX7dhY14Kg1uquegPbb1HMitkKzDIo9zcumeqTrD/Wvulyw/79gcybCjePbVPuf+pBvymk60cxQM7VnbsmWT19meVAjcUU/RxjggVJyeHBHANR1jsej1lM3/gp9T/NCZBM51689Ty6yfb96KazJFPeV79vFCzWpKtWGo7pzAe4ezPO7bngTrNTtapQUvwnqbCpBIjQpk1tBYVn25EIMhmA2JvZsMbbExoN11GFShjcKRO+wEJZsw6MrN6i32gTzeBGTkCHGcuGIps1fsJ8bvKND43vqpdgyF+g7o8CNHiHN6v9gLgzQIg0313NPnj0fbcgaBsgLqVBYilRaej2sInTJ9TW3tPQQEpDZLCDPIVU6lxPbYu2tfvSVUMu2VG1oz7rNd4vDCe3pRa5AGZhQd2U+oqZJRBcvEHrDjPtvFhimDGgXCPTskr2NYgHdtDI4ub0WFQotfqIEWV51z+v6ec3MiqTEpf0wpMXbXnlIgdeNjjT0G7REs1vE/3Q83fuYTCH348OHjEuEo7jU1TbBYsFRXg0yGXKvFmJePuboKeVAQytBQTOXlWGqsxgpzRQWaNm1EgdDTtnz8PvjEQR8+/sY0xz1kn2psc200h4Hj7qBQ/6I4HKksRWuwlnvZfpYLFgsymUwiVukqytn2/SLMZoUYaHBeFytZ97adBzhmLEcjDySECgSLhf2rlgEgk8tpfVkfdAFxEgeSt8IoODfCt4mQ2Rl7JU7HyL7X8FP4BGRZ1u1cVruKox1PNvtcXQx5hkL8gIR2Heg5ahA/2aVGR7ZvQ3HODqdlkjp15fCGNRSZNcR2T3E6v0d1arY23JTKVCXIFc7pnhfCU0Na8tba0+Kwt6KKN7gSE20lyDZh8FLQJSGG6upAybjW0YF0SghBq2lPzWLXqbr2IRn9h7dnw5T2DcEnU3nCMdoaZ9HsRGG1xxtp+7ARe2zDnm7EbfvvDbbtOJJVVEN+hT/gb3Uzmc6w7oTztecJV9eDoyP02uRaVp6VukN6Ru/DYFFysKQLrvD2OlsecwWWwlCX06pXr6Z49mxazniLkBEjWLm68UXzVlwTzBppwvH+CuR+3u3bVydGezWfy36DdiQPu4WJqwsgujFMxN556e66naoKo1+vVIoG+ll7/u3f7VogdCMMevugxhb6A9A2JojUSC0nd20DrJ9xl19/B9/+6JxY7ohfbFuOCBUYzdIS6zxzAieERnuw/XeiTRjce+A4BlUEaovR67Te2KIQhh4JYHPXUszJ0vfgqeIKZMpKymsNbpZ2xlNwkw3b99tLK/fjb2dGPVudg9xP1xhqYycU3h14CuPxXYQaKwDwM+sl69TVm1AotYx4YirZGXtJTe8hvo7e/n6QVUN46x7EXTOQU0UznL5fzLKL+x7xlorCWnIKa7hvQeMjoY9V50iQW19/layOUFWhnYNQsKYW7+gB/f/4noOC0UjN5s0EDhiATOUTJ3348PH3RBTotFosNTWYKiqwVFcjDwpCnZQkEQENubmSaYA4DkCmVCI03ItZqqsxNIwXt2UyUX/yJJo2bUAmw5ibZxUS/f1Rp6T4RMM/AJ846MPH3xhv3UOJwUp2/vwd3YePkrg27AkMj5C4Bm2ogw3EtW1BZMtACo82jh98740cXLWbolN5GKqkDoRRU57n8Ka1WEwm6upyMJhPowvR8tZW10msjmV0tv5M2tAw8mss7M3MpyiySuLI2ZnbHkjzyq3gqRG+vdOxe5vLrOMbXEthNX/8R2R0SiqxLXrQckB/sqtzJNN2HVpPcLDCmiBa23izcWDNCnQh/nweNh4yq4A7JcttjegHuE6ZBrxKFHYVIhKgKxavv+UHz/PRNhdBKZeQ5oqPujP3gCXApUDy0S3Xij3Tsg3S0uSs31aT9n8jSY3Usv7xGzmQW8HkJcsl8/RLas/VrXtweZso8fqrk3n3A0WmqOf+hXuZO66HKJjY09ywEcebfHG49BTUV4MmCCKkZcLN2Y5jn0hvkSkrnAIxHMuOgzSrgBsk8yQFn0MlM7gVB5sj3jlSZzBzOL+Sql9/IwyoWrmKkBEjOHbwEJBsXc4YyS1nriavII+1iV2alZzcnH27llVE6UoosUSyImiYOG1o0VrCjOVOvepcUS9z/Rnlznn5vKEFafokEupg/c75ZB/aS8v0nrTsdpmzQOhCGAT3blZHXF1fG6YMIqZlayISk+k5YgxyuYJ1LVLYvWYN541q3j3e+B5ydMBumDIIY1ECmp9mopPLrKXExhiXTll7YXChXdDJqPPLXO6rI32OawkILGFYbiClfiaItYpuhboo7vnfOeCc0zKO/TVt++WngJXzjoOHl9KT63pR9htuA390J/YTbawQS6XLVWGSZY/nl5N79DBtOneidc/ekmne/H7I2bGJ6L5jiOg7lKtmbsbekW6jqQCkS0FFYS1fvWR9ODGexl6hW3lWMt/Y5BcJNRxGklacdp04XaXxrlzN2/ncIRiN5E16gpp16wi86ioSZ8/yCYQ+fPj42yFYLBhzczFXV0uEPWgQ93JzrSKgIGDIycFSV9c47exZBJMZQV/XuD5T08YOm0Ao8/cXRUVLXZ1L0VARFIwqKdErB6MP7/CJgz58/M3xxj10dPMGMegj56DVdZXQrgMDx97Npi8/41zmMaded2AVBjvcdgo4xZGj0nTjc2VvE9kLInvB0a9biQKhIAhkZ+yVJB2mtYEzVYnghfHI3tlRqQ5jYdI1LNyiR+53StI/7tVVGVj01j5ITd2QuGqEX6EMoVQVhkwmIywshGF33EGJLEiyXJmf+8CC34uaZD+ePfw+rHBuRL2pS2Pfpxs2xosCoTqonrBrq5o8v47imrchIK5ERcEYyfkTx0gdZS0RzSqq8ehYuhSksZwsrbPIZc/rA17HT4hDsGjQdQmT3Lja+OiWaxnSqoc4bH+TfP7QHg7O+x9ZiZH4te/FicJqcstqnUSfzSdq+O3IERbe00u89rxNbrWt6/6F1uRUx+u3uWEj9vsvCiSlp2BO98aZH93nJBB6sx2ZqqRZwmBd/i0IFmtvSVehGI4Oyu9O3uA0z89Z1zuNs2dQzDFiFK1QrJPzbZvuzRLvxOshaDCfBu4gcfNmdr/yNu/VtBfnWXhPL/q3Gsay7xaz+rj0gYmn5GSwinK9VW+y/kSeR7epYIykZddcuscc4kxVIit2NIqDYcZyog1Sod0m/lidhDIIDIaaSkqOHQCc++aJ++Nw3bY3BxArCOw0/MrZQ9aa+dMZe2jZo5dUIPRQSuytm9XV9aWrN9H92pGSca2ig2k19v84nF/Ju8cbHZx1R7aT1nGEmFyfGqmFyHROsI7/LNwilhK7cspmZ+zl1J4dGNTSa8DPohdTmctVYZIHU0OL1tIuOYLyk8fo0jmE8F7SIA9wbokhwSFRNTG4kk4J1mvl2rsm8s5sF5Zi26LNKGW3F33zNHFUy7WsiL2W+Jpi/E31tKrIE6f/7/OGv388zEcT+9GmZ2fJ+pr6/dDp/6yv1eF8zyK1DW8+Uy6kJD2n0LtevsZbf4bdT1odg37BcNcqiGzsExIaE8DY//bBWG92uw6VRkFozIX3uhOFwfXW30w169eTN+kJn0Dow4ePvyyu+gBaamowl5djbhDoXAl7lupq6k+fRjAawSz9XLWVCl/Q/phMCG5chfaiobm6CqFBoLR3MDYlHvpwj08c9OHjH4Jb9xBIgj6SO3WVuDZumfYGe5b9THmBsxNCoXb/A9qeuLYt6DfqSVFoLMo5xR1vzGbVZ89gSzr08/Lmx76MrqyiClmo5+ABb0uM7Rvhu+o79eV30kRGmapEUr7ab08qadpwSsrOcS5Iyd4uTZfCXQifH/7cq/mMSosoGARpqolQVLmd121AgqZQOp+bEBB3ibSdW8ZxpuoMOqMOc8M8nnrFXSx5qafx47THeVqGtKRDhDXJ1nZD6yiQtIlyFo1sN6knv7IGvGzZuptXl9unpLoOybD19UqN1NIiuAW/jPmFjOUreDK71GvRyvH6vZCwEaeb7PpqziiVosMqqbqUsu/XEj5hPPIG0dubssjmujUthmiv520qdMYdG/IGQN4AiIFXrgnhzcON57kp8c6ewO71CNtNmHO/hbBp4viwADWWsnL65ufwnn819l0svXEGrj0o4BhS4mrfNArr+Xf8bGzdsQNVGZtFF5/bPnlh8HS4mYXDe1GeeZBffvpFInbdF6jg45rG63amOZRYQzhbKn+moCJbsqrT+3bTsvtlVoFw364mS4ntcXSOAZworBbLie2xD95wvGYdr/ujK38mq0UE7QcMlghKqug2HBHy3S4HQGI71OmDKc/Kl4wuV4WJrswwozSQo3ObRPp2aYWlWzvSBrVlz97V4jRbS4zjZe4b0r6zWprKfeLo3XSI+5qAgFRax4aIAv6GzCKneS/UDWsLjYqvKeaztW96XNa0cTZ1y3/Bv5XzAxZPvx9cDbujqfmaU5Juv8x9C/ZIHIPuqNMrrD0Gd/SwOgYjnV+vixH+mkIiDNpcuILgEwgvAbUGE9/syuXWXkkEqH23rz58XCqcxLTEBAx5eaIA1+Tyen3TM10iXImGEgcjiMcCVvGQ3DyfQNgMfJ+uPnz8Q7B3D8nrdeSu/p4zLnrshcbEAbDlm4UNacKh9Bp1Iys/mAmANiwcuUJBdUkxZoN3pTXDHpxKYGArUWhUqtVEJrVg+CPPse+g1XkQoy3mtf7TxZ6DnxxqLH0dF3oUw5EjYhmdTfQq0wpeBVxUmnoBTfdYs5VUe9N3ykkQM/shZJcQKdOAoGevi2Vqc8chV5Xi5yZk41JSRwg/2wkGrzHd5fn1VK7mF71aMjwgZSldQwoRLBpU5mDOGdR8l3Wdk6j41PVhtA6LJcC/nut/bnR5vXP7AhTmaIqq63l9jdT59Eedm/M159GqrEKd7UbV5mj8ZEInsZTYhrt+lKePZ0JsR8m63QmfB3IrAESBUP7bIZ7L3s9Mu9aenkQrR5GuOWEjNnHWdsy2UuIzedu5PileXO77jQvQfLESTYScoJvuBfAqkMBb0eJC5m/uul0RRNkFr9MQrab+OhPnVVFgp89mncqiXq6g4vvltKo4z7sRMjYnpjG/7ehm9el03BfH4Zn7Hua1/tOJ0RbzXNQOet30BMEBGpJDr2HZLIMYouHp8+rNowo4uotnQw47iV0j7+rLzXVmSg4V41dvJjlAYM0v71BQWeS8IkHg9N5dJIZEMPzeR2gzaIjHUmJ3rD1ayKsrjrmdbl92ay8M2cS/hff0IixAzbYFH1GdXUnmji0c9m/Nf344KFnOySlrR3aJjiGztwDtIKqdZJq9eOpYYnztXRNpHWv9HqmtbRRPPaXzuuPhrp8Qoy3GZG5sWWDbz/yKOqf5vekT6an1g7/JOxF/48cfMPTVt5wSp126j91Mv5gAJG9L0ps7jw19jcEaPvIn9Rh0EgbFiT6B8GKZtzWHGb9mojeZeWhQ60u23iVLljB16lQ0Gg0LFy6kc+fOTS/kJTk5OaSnp1NRUXHJ1vl78uKLL5KWlsbYsWP/7F35y5Gens7mzZsJCgpqeubfmY0bNzJp0qRLknpsLwyCVUyznKz1qvz3r4RNIJSB6HS04RMIm4dPHPTh4x+E7Yd5UU4pq73osdeu30BU/v7sW76EyOQU+t18BzIZdBx8NR8/OAFDlZqjX7dCoTbjF2akxZWNLoyOHWYSoG0lJpkCyOUKeo26UZynNLu6cfmGpENXdGmZRnyreHb8+I3EJSP3y0fLviaPOyzQQ9KmHVu37uaUfwrGhHbgxhTp1mUXq6TUZEBllKEySb9canPHYamPsd64BR7xal+84cmeT0qSjF8f8DrnVmwhf+9+AhM6SQSN6pzR3Dbhemp1p1ixY2bj8TTD+bVPdoZ9VQB6HowsZHmdH9rUOU7zfXDkZZfLt0/Q0CEigcP5lQgrGm927+8Yxv9qAhD88l0udymZtHESAL+M+YXUyBYeb3jBfT9KlbnxvLnqtyjZZsON8vdBJ0hWGNBt2YJflDTkxFEYeu669qKIMu6zXax4uBUdkhqFDG/aBZypOiMRZ38Z9CEt5lmHdWoVJMSJ0yznviH1GiMcmUJutz5U+iez7ZRzj1FHmioVr8u/BYspUJIo/b+x3Th3qJ6wQDOVLaKZmTFNnH+EVkPbwAr8ZJC1eynVlUGUq8NZHXWVOM+9nRegltfzwYF7m9w/3bnXeC62jvLC+3nrZLTT6zM0xsTqwsafOrNVH9Balk+5EMg447PWUlCH38CTVhQAILt6PI+dW01ddSUyXUyzA3zsz527a+f46lS0bQZw9+MvSQSbEU9M5fO3Z5F19CjlytAmt3Ug6xzhDuElm375hd6DriBmQCLJoRqWvPwceRWF4jXuiryKElS/baDNoCGS8d46xzwJg47YRB9HN9kbrYrQHd4OwMZj51lcKo11Xnu0kCEdYtyG7ngrJhllSq4rXEVsq7bcPvFOURgECAhIFdO692Wfgq1eHxYACYHWa6hWZ3Wk239Pto1xfXPp7uFDc9ywTZF37BDLZr3h1EcS3H/mNDXdmwCkiwlYak4qdFjs75+W7AqPwqA4k08gvFBq6k18tMn6Xvpo4ynu7JtCYDOuC0989NFHvPjii9x2W/OD+v5JmEwmXn7Z9W+7fzMmkwmlUnlJhLjfkwvpsecoDIrj/2bCoA1PTkefQOg9PnHQh49/IK567IHrNGFbP8LrHnkSAVj5/jvoq6vFH7iOYSM2ArStCA7qZP3RX14p+XFvczPt2b0SQ5WahHYdiE4LQmA+4FxG1/PKqzBnH3JyyXjrAnLs9WY01LNv+RK6Dx8l9qvKLtHxUkFLiG3pURh057Lb3OIQNBjObtgYzw0b4zEqLVi08Xzj19HlMhfCgIwIOiV3Z/g9j6MzSoMyWoa0pMR4Gr2pgOgO/eBg451kbVBHzlYlIZiMkvN7oe6s6JQnoeSDZi1zutJa8ltpahCjG252VWfOAskX7RTTFw1FpqxCE95080rbuWvqhtfdeyXEUMENZfMpjQ9hX2pj7zF3fRkBCpYuJ7D6HPmBUTzT6ykx9dqVMBQVJD0XO/beT0rEfFFAsOGpvM/x+tDVlYqlxKcdbjxtw1qLwEOfbeKIIN2OJzyVipvrkiTH9uFtXbi2czx0vo/sEh1Xvf+VpFdo28AKktTWz5bi+mr8Dc7idZy2gBbBebzWfzqJqf9l84HPJU7jezsvIE5bgJ+inhhtMYW6KN482sHl/tkLgwB1dSo6anM4QorHY7Z9FnzeYFCpyboJvCyBfmJIa2atzQKaLrO/8oZHGTCgl5NQc7ainlcrOkC86+NyZHnUUK4rWMnogmX4Weqpk2mYwQjIPgDAc6FHqTpx1KMwqA42oFCbyS/Y7yQgNeUcA1z29/REea2Bw/mVTk66jM2/Ed3QF7ZAFeW03KsrjvHqimMsvKcXA9o4T/dWTFoRe631jxoYp3RexvZejAgx4iqAxJGb2/xMu4iT4nUJcORoYwhX3z5rCQhIJTVSy9xxPcSeo444fk7e3TeNTzdYRTRbX0EbrWuyyApsTWK1Czeoy5XDqb073QqE3tDckuPmBiwB1FYZOLDuLGaz9bPihjrvvzuMJXUIHnoKyjQKVJH+Xq+vKbwSBsWZfQLhhfDFthxqGkT/6noTC7bnXBL34GOPPcbmzZs5fvw4c+bMITU1lczMTAwGA0lJSXz22WfExlrTuefOncs777xDYGAgY8aM4cUXXxTD/caOHet2OXt2797N008/TVVVFWazmWeffZabbrqJ4uJixo4dy/nz55HJZPTo0YN58+a53e9BgwbRo0cPdu/eTU5ODuPHj6dv37689tpr5OXl8dhjjzF58mR++OEHPv74Y1avtlaJmM1mWrZsycqVKykqKuLhhx+mT58+7N27l+eee47ly5eTnp7OpEmTMBgMPPfcc6xcuRKFQkFcXByrVq3i0KFDPPjgg9TW1qLX67n99tt5/vnnAdwuA/D222/z3XffYTKZiI6OZu7cubRo0YJ169bx/PPPo9frMRgMTJ48mXvuucf6WldXM3nyZA4cOIBer6dPnz68//77qNWu70tsTs1HH32U5cuXU11dzfz58/nhhx/YsGEDJpOJb775hk6dOnH99ddz++23c/vtVjPC6tWreeGFF9i5cycTJkxALpeTlZVFUVERx48fRyaTUV5eTmhoKMeOHWPSpEmcP38egIceeogHHniAmTNn8vXXX2M0GlGpVLz33nv07dvX4zX40ksv8dVXXxEWFsY111zDl19+SU5ODiaTieHDh1NaWkpdXR1du3blk08+Qat1/k27auVKpr/4IrU6HUqVijffeYcrevXyKBS6Ewb/yYgCYWICFp0OBAF50P+zd97hTdXtG/9kdqR7T9rSsgpI2RVEhiCICqgoLhQZDtRXFHxVcOPAxRAX4kBB3MqWl43svcFCoZTSSXebNs38/ZEmOSerKaDoz3yuy0uS8z3nfHNykvTc57mfO1DUY9EbYOIVB714+X+LsMeePSNffJ3jm9YTHB0j6kdo+UMna6e5cbowtKS08JBoG3KZymn/IKmy1FbNpII3Rj3GjSPGo9GcY8fOBdaxc+9IQOkTbe099dWiPZQoI9BG2prrm3QRZOzuhcpUQUWAnuPtT1mXPZXxMj0T2tnslAJO7dpuDWBp16c/4Fk1iX0PPlfo5EbCqxsvVqrLeKbDQcrKKjlXrWetIsOjbbgipFZBw94z5ISvpcQktglW1Ep4pTwYSWovTCcKAZsoM+cPqbWZ/xu9sVqMQxtGc9WgX9m/8TeKKOfT2p88mkdcqPOkWHc8t8XWne2bR34gWB6HykdOxZ71pFZp8OvcmTLdDCIDlBzasYEF2hXN2n73vEp2RbUBD8RBT8NBwPlnpdpfx9reuQ5j3fXJC4qNgppCasJsdmaTzmwxBESVcCU1YlGsUB3D4fPlRIdFiQRNe7sfwNpTR5FIG9BICkXb2F19mvcEVmIhz0XZzpWQ0/XQdLtBB+xFC3XuOAfRU1l4EjqZ+76oG/QO60jzhpF18BCRia257ekn2LzocypPi4WXzK7zSAjRI5eZj0N2dpFouUU8tOA2JMKO0yej0beT4q903yPHVZ9NT/hj2++A7X0Y1imWZYds75VF3MzsOk9ULSqkOVZKCxax677z3xIUJe79mH3sGFEC4UIYcBKirxKET5k5/i3kHBwkSrhtTgqt/Wu255G+qYz+fLfTZeWKUE77tmBPWA+3+xD2+xTiTsi8/sJ6QrXl1MgDWRVtC4Fxd7xlUs+EpLbhp0TnpT16g9paQVevdS1eWSpOnx6SRJBvAMfOKoBaj/oKeoTJdFECoUGvJ+fgPlIyujZZkS2kuQFLAOqqBg6tz8OgN4EEAu3TXlxgrGyg+KODTY6LntLtsgmEtVu2ULt+vecrmEzUrl9P7ZYtBA4YcFnm8P8ZS9WgoIXjZasefP/99zl8+DCTJk1ixIgRXLhwgchI8w2HGTNm8PLLL/PJJ59w9OhRXn75ZQ4cOEBMTAwvvfSSaDuzZ892up6QyspKHnzwQVatWkVsbCylpaV06dKFXr168cMPP5CSkmIV8crLxe0ynJGbm8vGjRuprq4mOTmZiooKtmzZQkFBAW3atGHs2LHccsstTJkyhaysLNq0acOyZctIS0sjPT2dkpISTpw4wUcffcTnn5tDx1auXGnd/ptvvsnJkyfZt28fPj4+XLhgvuGRnJzM+vXr8fHxob6+nl69ejFw4EAyMzNdrrN48WKysrLYsWMHMpmMhQsXMnHiRFauXEmXLl3YunUrMpmM8vJyOnfuzODBg0lISGDy5Mn06dOH+fPnYzKZmDBhAnPmzOHpp592eVyqqqro2rUr06dP5/PPP2fw4MEsX76cWbNm8c477/DKK6/w448/8sQTT/DSSy9ZxcEPP/yQxx57zLqdffv2sXXrVgcbsV6vZ/jw4bzyyivWatPSUnMbndGjR/PUU+YbQjt37mTMmDH88ccfLue6cuVKfv75Zw4cOEBAQABjx461LpPJZCxevJjw8HBMJhMTJ05k7ty5PPvss6JtnM7O5uVp01j60UcEBQRw+tw5Bt51F3/873/4h0e4TPK1JBD/27C3TcsCA1EkJKA7n+8NMGmk2d+qv//+O++88w779u2jsLCQX3/9lREjRliXm0wmXnrpJebPn09lZSW9e/fm448/plUr102cvXjx8udg6bEnxGQysfTt6RSfyebckYPkHW9MrNy3BxPmsbXlZcSktSG6ZSuy9+7k5ief4/jvG5Boq2jTu6fVIqWuECcYqhv0SCXiaqbUvn2QSmVWm9bpC5WM+7gAOA+cZ+OUfraqvnjH1M0tgeaehWaLsU0c7JnQzho8YY9Q8LSIg82xJjXFLY9NJfvnVRRkmS10dUd3cPOEx1j81Xdu19MUDcVkCMSoD8CkC2Vw2UpUlLGmp63qQ6GXiuzfI4MSie/ahSC/YHb/bzUBabbAEldVbK3Tv6B1lFFkZUu97XGOlx3n0xU2cfCxzo/xwQFbKvLwYC2BMiM92r9Fr7herLhlBWqdmjNVZ0TCnyeEBphIDzdbzVJuGEa4nQX2JflIV6u6RGqQYWyI9mhs1bpcqoMl+HeOQh7WdCN7+89KRYBz9UwYhGPSRYj6bRlqunLg8QmcvMsfjtjW0Rp9UErFYtMbdvbL+UfuY/6RIqDIpcU4p1TNgDk/uaxufe/EgiZfJ0C+tOn+nM5wZ5PtprhAcP4Rcg5G879EcyVtvdYgWmfakAz8zhUR3Kc3N98xQhSI1FNvIDmzr1OxIbPrPNhpE64slbEhC+TIi2XojQboSpNI0NM27Tx5yihayorYKHkKNb5km+KZpHvUPEZRyu2xpUgUJQi7Y9q/7+74rV4s0NqLZNd1/y9XJYQ5VIkKuZTvqyKfSAbd/iAstV2UKNp0p+TkXpQG83ktDDgZXricYN8qitXV1oq3pE7ppGQ4P6j2c3NWMehOGAQ4XuA6/VZoMW8Ki8XYmUDojISUFNRZ5YSltgWBw9WdvdUojcUSrOWOpkK3zlfKGfrhpia3A+bP2tvL1YDt99TTvoKe7cDE6b07yTm4zyoAC8U/e8HQoNezfNYMTu/dSWq3zEZR0TOx+GLCTCITA7l9andWf3qUquK6JgvyrOg8C1FzV1nYXAL69CHguus8qxwEkEgIGDCAgD59Ltsc/j8jrBq0cDmrB4UsXryYhQsXotFo0Gg0RESYv+s3bNjAkCFDrNWAEyZMEFlwXa0nZPv27Zw5c4YbbrhB9HxWVhaZmZnMmjWLyZMnc+211zJkyBCH9e0ZOXIkMpmM0NBQWrZsyU033YREIiE+Pp7IyEhrFd3EiRP58MMPef/99x0EsJYtW9K3b1+n21+xYgVvvfUWPj7mm28W8bO+vp6JEydy8OBBpFIpeXl5HDx4kMzMTJfrLFmyhD179tC1q/k3xSBItS0rK2PcuHGcPHkSuVxOWVkZR48eJSEhgSVLlrBjxw5mzpxp3bdM5r4Xuq+vr1WX6NatGwEBAfTvb74O6NGjB9988w0AgwYNYtKkSRw4cICwsDB2797NDz/8YN3O7bff7rS/YFZWFhqNRmRDt7zfBw4c4PXXX6esrAy5XE5WVhb19fX4+Tm/EbF+/XrRfsaNG8fGjRsB87XarFmzWLlyJXqtlqqaGnr16iVa32Q0svK77zh99iyDxoyxPi+VSskrLCRNqbQm+YLZdmsCjJWV/0ph0ILQNm2oqcF46pT1Oa/9+CLEQbVaTadOnRg7diy33nqrw/K3336b999/n6+++oqUlBReeOEFBg8ezPHjx/H1bfoCzYsXL5ePU7u3A+IKwIKsExSfMVvezh2z9XIymYyidYuysyjKzrL2JhT2ErRYiYX9gySKUn4/ewCpzwXRdixWU3OFXwoSeRVCi1ZpaTkntm4GQt2+FvsKJGFlmKtQiZyD+9j09WcASOVyfrn7atZv3MHRsyVs9rFZgS095dr47sdVBvGtqoFEagOINoaiPnSaqJRUCk7+Yb0Y2P7DNyiNRrc9/gz1qaLeUUZNPHKdPwO3huJHFQq9lKA6BSYE9u9Ro1k1912q9Dpyw5SQadueq2qm8OAkggIbwyrKjtsCOuyq6dKCxX9YL60yWzUWbXmJFRFdHSoym4P9vuwtsFWHD4EHjsm6/JGYtLGYDD5sDYwAHVax6a6IP1gWuNbpeuVHzhOmkVC9Nhf/7jGEjkhFInP9Q2/5rPh1SCJyYE8WnHzH6Thhz73a7ClU7l5LeSBIrx7M0Hn7ocPDImEQEFliPWHl1mdJHj7LQTxSN+ibnR7sDIm8kuGd4imtDWebB30Hhbiyye7VRULUANZXAnZ2Scs605dcAGSAjKsGakiJUDn0KXVGemJbNk5JpLj8D85kPWoVsORFUpTnTLSgjM/KZ1Cv9KMgJZ03WwyyrmsRb/efq+DFpceYonwUdLBR8hQp0iIMJltFksVK/JuTOdi/783tPygkOqwt/v5N93dbN+kaFn/2FcfzytgZ6r6KTsiayIGsWSquVlhUmwxxyQAMLRK/wqWxN5v/sQ3ea/0ykdIKOrdPpeLAKmRSP3x9bWKnTKUiJTmZjVP6cSivstlWYgubT5U2PcgDLBZjV6m39sLUF7WNN6HEre+c2ltd9ckT7X/bPIK0dSiDNMTsq0AfI6PyAduFb3qbd1AFtUYuU3GmIgxPRMa/BImE1K49rQKwc/FPLl62z9xeoblVhxcbZhIeF8BtT3fl8ylbPH5ZcoXMU/f/ZUOiUJAwe5Zn1uJGYdBrKfYM+6pBC5ezetDC1q1bef/999mxYwdRUVEsW7aMF1980elYiaA9g6frmUwm2rdvz/bt251u8+DBg6xbt45ffvmFF154gQMHDrgVwoTX1DKZzOGxvvHv4QkTJpCens59991HdnY2w4YNs44LCBD3RvaEqVOnEhERwYEDB5DL5dx6661omkirNZlMPPfcczz44IMOyx5++GGGDh3Kzz//jEQioUuXLtbtmUwmfv75Z1q3bu3x/CzCJLg/LmC2lc+dO5fo6GjGjh0rWre5x0ar1XLrrbeyceNGunfvTnV1NcHBwTQ0NLgUB+0RnleLFy9mw/r1rPnySwLkcj7+6Wd+PyDuwa7Ly8NQX8+AzEwWvP22020aa2rQnjsHegNGjWMYlhfHHov/doGw2d+oN9xwg8NdDwsmk4nZs2fz/PPPM3z4cAC+/vproqOjWbJkCXfeeeelzdaLFy/NIrplGuEJLWjXpz8HVi8nJrU1EomU/KzjTd7hlkgkhMbGW3sTWnDWP8hyUf1xtuN2hBVnM3t9i7pWLAKeOFfK7h17IPJ6t/Mx6SL4pN8PhAaYHKzErkIl7ANYhiS3RL5rCTGyEIhvL5o74FIYBPhFvQ6A27YkEljj+GNRpCvB4G+kS/1asly9BoOPKNzCkpwpUZRyU+lSwvRiAe2u6e/iGxBAXaiE1V99hEEjDvQQVjPNunWgQ4qtKKzilhUkBSVZqwGbst0KxTz7sY9EaPCXmSjWSVlUbvtj6t6wBqIVRrp3+tj6/lj6T2afF9vSjTmneOi0hDPRoWiUErZkOIpU6txxGOscq86f6ZRErL4MhaoDy8qdi4PnFIVgMuFn8CV+r/m5sNtcV7BHt0xDH6tias0HcPJ3l+OESGQNnP59M5XU0aVVd4/Wcbu9xnOj2qQVpZwKRQpP+zb6F19DXfRW6+OAgsGUGKLwT1yIf+JCNmih9twUhNb0Pxvhud8c22xudS71EjUhwRqrMAgg1Zig0W4Yry6FOgktXvoSvjxoHWMJS7AXeNT4YjRJKCMYP5P5QsRT4bU5FmN7Xh3e3mN77vkTx/iiNhVCU5sce33JOkyYWBs1qMmxZcowp8/H1V4g/e1aQEEtH9nrZ1ZSV/+GwTeUynN/E6EL19ZVoTCVX1nvss+f/bbc9ckTEl1XYT73qgCkgPgmmySriqABHQBQ1akd1r8iNAqDFnHPnfgH2JYJfJ0XIxA6o6kwk4JTleDkT5XeI9OIby3+W0LhI8Nfb+RKXP56JBB6hcFm46xq0MLlrh6sqKggMDCQ8PBwtFot8+bNsy7r378/M2bMoKSkhKioKKsNt6n1hPTq1YucnBzWrVvHwIHmv/0OHjxIeno6+fn5xMfHc8cddzBkyBCioqKora0lOPjiqvyFhIaGMnz4cG655RYmTpzYZOWdhWHDhjFnzhx69+5ttQhHRkZSUVFBu3btrJVxa9eu5dprr3W7zogRI3jvvfcYOXIkYWFh6HQ6jh49SufOnamoqCApKQmJRMLvv//OoUO2vxVHjBjBW2+9xbx585DL5VRUVFBWVkZa2uV5z0ePHs2rr76KwWBgz549Hq3Tpk0b/P39+fbbb0W2YqVSiVarpUWLFgDMnesY5mfPgAEDmDp1KpMnT0alUvHFFzZnUHlZGWF+fgTI5dSo1Xz9w/e0SEjAZDSa/9NqMdTUMKh3b9785BOOZGXRsU0bAPYcOUJ3Qeq2sdb1DS4vzvk3C4SXtedgTk4ORUVF1i89gODgYHr27MmOHTucioMNDQ00NNj+IK+u/vc0xvTi5c+myw3D0Gkb+H3RlxxetxqjQY9EIkEikTjYjZ1hEaeEOLsI8/Si+qFvtjukLr64ocAqDN5YvBqdRG4VzQBu0e3ntntuJ75FossLjKYCWEJiYklo14Gi7JO07X0tZ3efbPbcLWTeey/HPl4seq7aX8cv/SzVkEWOK1n2pahAlWT7o7I2ewoAAWnvsqnxb51bN8WZqwdNJs7/cQxF6xhG73wI2jhuT1jNpAroSof4eHKrczlelkuhWmzrs4h99tWA8wbNo1xTTml9qSgZWVzxaRYVy2pOcfLow0QqLOeO+EI4WmEkUWkipbEi0V6gFPL+jWC+6iun/15HgcqVMAjgd/4IGWOHkV2RDZucDuGd+AXWf3+W/TLxeyCof6JLi3F4704UlErB8yIVRhSspWVUODc/9QY1fhHAWc9XtkMoUi/RQc/cYtrHpHC+os6uN5vr9OD6/FEYtVFm8U3WgAqbOFjc4Hjn/VJEruZiH/ZTpe8BNH3hY38Ovd/nHbpGtqZh92FKS6Zbn1cG6giIb+BC1lHR+hUFZzhKS/Iq6kTPZ5vi2WJsz0z97cxWfMRG5VMclIbgvE5EzKUE61TV6fjfsSJrr1V3hKa2BXZ4tN1QXQVKk2eC666wnk6f99S2mnuumEGrbKnsH9+dwfnKhmYlFbsjVQunnfebd4k766rlODfH3uqpeF0vt50L+aoIamRK6tVqq4gd2O0a0Tw2TulHaWk569dv5ZO8II/2cTnRy6WuhUE78W/Ze2+ABM7s3yMSuyz9KisP/QHN7FvY3DCTMwfMxzE2NZhet6Wx7edsik5XUXq+loyBLRzGa/Mv/SLYWFdH6aefEvHgg0j9/T1ez61A6BUGm42rqkELl7t6cMiQISxatIg2bdoQHh7OwIEDyc8335Dt2LEjzz//PL179yYwMJAhQ4ZYhTt36wkJDQ1l5cqVTJkyhcmTJ6PT6WjRogVLlixh06ZNzJw501rZ9s4771wWYdDChAkTWLBgARMmTGh6cCPPPPMM06ZNo0uXLigUCuLi4li1ahXPP/88o0eP5quvviI1NZUBgr6Zrta55557KCsrs9p79Xo9Y8eOpXPnzsyYMYOJEycyffp0MjIy6NnT9vs0a9Ysnn32WTIyMpBKpcjlct5+++3LJg76+/tz6623UlBQQGKj9bYp5HI5S5cu5fHHH+eNN95AKpUyceJEHnroIV577TV69OhBRESERwVRN910E7t27SIjI4OQkBD69u1LSEgIJoOBUb168ct333HVzTcTERpG7y5dOFdQQENODrqSEut1TmqLFnw5YwaPv/oq9RoNWp2OTm3buqwk9OI5/1aBUGLyRCFwtbJEIuo5uH37dnr37k1BQQGxsbHWcXfccQcSiYTvv//eYRsvv/wyr7zyisPzVVVVBAX99X84efHy/43jWzby2wfv0efu+zm2ab1ZPPPwYz/86RdEDenBfeVgUzRlx7uz4CdMJhPfx99ufe7ncV3o2irW5TpCNLW1fDT+LtHrk0gk3P7im/z8+gsY9DqqFCF8nWDrFSL1PyUS7JriBe7Dv9JI1nabilQW1MDya1yLghbq80eJxBx1zuMAqFJsdxhfav00ut+OUJB1gvRrB5B05xBGrRjV5LZnXbOAVpERLsW4N/u8ScvglqKqyxPnD3PH+nua3PaPAxfTNt58F7KuLge9QU2d+jSbDk3m9SKbXeK762eSEpxmtcMeLzvu0dz7741gYzebzVCdO46r8y6wLdzWX2X2qAxaRviRs20jClUVz5TPanK7FubmPEtaQwuq+sqRdA92qDx1J2I6I+l4d5Ir6girkzP1k0+sArqlwu/Y+Rye+dXx4sAdUt980XmgznncQUgH82fNEpwjkVfjF7vUuqwubzSGWseKWMsyiVTrUky8FJusJ9i/vu9v+t5lz1Ah607v48mtY0TPzez1LbWfLUe+aT2hbdPoNm4IirXjkcl01BlaUvzoOtS/vUrFmb3cx4MuE6MtyNAzTvYb64xdmf7wNYQGmNhxYA2z823fC30OhiOrDyU4uiWS08XWZPUKRajoZsb1JetQS/3YFtG7ydfmygq75dQFymq1lNQ0iHpT9izfRbi2HIVJj04it6XtAqPPf0vXTm3pMPpxNAYc7JuekFp5ng82zW5y3K6bRvCy3CZ6jQ04Y7br/sUM6xTLjVfFeSS0WrAc271ny1m065z1+Xt7tqBbchjhAUr6tIr0uHLws7UziFeXkq+KYPwgW6P42SXzGTT7HVRBrazfC5aq7pKzZ5j98hssjrmlWa/X0/enYowOvSAo9ez6WBoqfdHLpcT26uNeGGyCSnmwqF+l5bxrjkAoPB4JQXL2r1xKlxuHo1A6iu6HNuRh0BnJGNQCqVSC0Wji4NpzyBRSOg1wvJjX5tdSMvdAk3OIerwzynhH26Cxro7s6wdjKC1FFhFB2pr/NUsgBCfpxV5hEACNRkNOTg4pKSketZlasC2Hl5cfRyaROA1ZN5nAYDLx8s3pjOntun/r5aKmpsbaG27OnDmsXr2a335z1oTi78e7777LiRMnRBWPXsy9D7t27crcuXPpcwV6gJqMRqoKCwmOjQWJhMmTJ1NXV8fsSZPQGuFskO2LPLm6CIWx+UFlXi6df1pIibPvWovN3RN97YqnFT/33HPWZB8wT95T9d6Ll38z+nINdQdKMNRqkQUoXQYvWMI5Ck7+4TK9uEWHTpw7ai7lT87oira+joKsE5zatc1BHHTWP0iYrij1ucCHx2yNmt/s8ya+plgmLDjapAChMDiGQNSczwEPxUFXASwNdWprZeGFMlt1jERR6pEwqCnti6HmKvqUHWBf5TFzwqdw3nrPfjD6tfNll6A4elhmFaEqBT+dsT33ysl3mDV2JgH704j2i/U4dddP7m+upHOB0N5tsRiXVXiWzlxaXgSN4qC/fwq51bmUaM2veVpMPRoTdO/0Me1jxZZGT+ceWquk77b2rIobYBVx/A1nRWMs9rOr7ryN42XHoRlBx34GX/KVFxhf/JJ1PcsxAMd+iG/2eZMLNQ3MPPiyw7bqi4ZyVHItR8OAMBiw5zD9+ptFTJtAkQJ4Jg5arLYWi7gFZwEYnorwYAsPkfoUW63E9lzOPnqucPX67CtTLViEgyp9AaEBJrIrzmDPIz8uwaBMxNT/SQA2bn2ZZLkRTOAnO0PKoqup05eyNqgFAVG24+XqNb43qhtpUf24S9D3bNupRSDQBFqFt8Z4pIB27WPRBoSaBRW9o6ASqqtALvOsHNNZddqWUxdcpvgKK/76XtjM8MLl+Bo1aGS+RLXvTIfR40mLMVeb5Ff+eebK7LwS8yneyLG8CxDaPHEwWFeJ0uj6OGmlCqoUIW630TE+hMHtY9yOEZJTqnZ5bBftOmcVCy2ireV3bvvpMpFI+2DuXjqe2YqfXmO2FCOuIATQXT8GVVArh/dz45R+pCS3ZOTk/7L4G1vAVu+y7aKbIQAjuyTw037X6ceu0MeAroXt3Kzy9UOr8rFWDAKc3LWdY5vXOVQFNoVWKha3tBL5JVmMj2/ZyNbvviYoItIaHibEXgCUSiV0GXzxvXDdIRQGAQylpWRfP7jZAqGognD9eq8weJF0Sw7j3kzH6lBn4/4Knn32WbZt24ZOpyMuLs6lffjvRvv27ZFIJKxevfpKT+VvxbJly/jPf/7DDTfc8JcKgyajEWNtLVKVCt35fO4b+wDniopoMBppn57O7ClTMOn1GGXi7wujM4Xcy1+CoaYaWW0tsn9J0dplFQctKU7FxcWiysHi4mIyMjKcruPj4yNqAOrFixf3mAxGKpacpm5PkbndlkQCJpM1eEHZL5z9/1vmNJxj9UeznFYNBkXFcM2dnUAiQeHjQ8bgG9m7/FfkSufeLmdVGiZdBNcmd0bqm8+HNscZLYNbkh6ezoYn2rptSL7vx68pzakivm0639+UyJalv1KVc5L6412hfy+H/TnDVQDLqV3buOHRp7hr+ru88fDD1vGeWopNDTEYNfFsVsVD40sfnbeYEL05cTOoTsGtm+KoCNCKKuDAnFDsG2POPd1V/ZVo2frir53u78nN5hsmKwba+gTu27SKY/Wn+EFj67E3ZGsYP8ffg0RZyP3f/MwdTRcrATYxLDGpNexvYjAQEWW7MBJX2fkxLaZeZCUWIuxxaJ94/PgyA/GlJk6FJaA3BFEYEYtRE2+ujPPNp0IltiyrfOTW/oUWYcnChKDRNGRX8nXUcutzT+ePoYU2xtxzUBdFtu850Tpqndrl9gCKay84PAfmj5zUN98q2mUdPGAVB4VzFfJop/lojT6iYJInOwUw+/hZl2KfM+GuqfNVItWK5mbSRWD6C/roudymGzHTmVhtqdZqSgS1HBuL9Vyt0SKRmkMgJECdoYwdPULZXyGHWls4hKvX2CkxxOE7LT4hDcptj0c89iwXNu9HrlTSadBQa8WVvcClNOoIN1W6nLuQ/Mp6hyCGslrnKdn2bI40J0wOL1zO0piboQrem72VjVP6AXjUW+9i2WEXjrIr1LlN2RXBukruO/9tk+O+TrjLrUDYNtYxSdIdnlqFLeMs74t9v8roxF60KTyBoegw+aoI6uU+nAuMEo1RtOnO/44VObwPlm136dia1RNDWPD8MygMWgfRDbgoYdBC+/SZ+Poks3nhIrTVJ0jtZhMGl733Bmf22wRLi01YadRZf9PssYypUIj7/FkeVx48QQdB8rGnWG5eZu3c6lQc/KuwFwYtXKpAWLtlCwF9+niFwYugQ3wwr8V3bHrgX8SHH374l+7vs88+44MPPnB4vrlVbseOHWt60D+MYcOGce6c+G+60NBQa9Kvp9sQhrNcKlbRLyDAocKsW7du1iAUk1aHyWggvVUrvnzzTb6fMwcAaWAgpvp6tEZokEgcb8Q0PpaaTN4Kwr8YWWAQ0osI7/mnclnFwZSUFGJiYli/fr1VDKyurmbXrl088sgjl3NXXrz8a6lYcpq6vY0WVhOiu/51e4vQ1Fazf43zcA5Lw3EkEoY8MonD61dTkHUCo15Hz1vuEO2nqQRRcN4/SGpXLWapHnNl+6o/toM27W9G2yYJfcoYut18C1KpjO5d27sVKJ1hCWCxbGPUyzNE2zh/4ijBukpG5y1GK1VQEOTDQQ/cKEa944+C/Q93UJ0CndzoMG7qkB7MPLjK49cgJLsym6SgJJKCktB3upqXNn0kWp5aACTW4R//EwDLz3q2Xct7YhHvKqpKmT9rCr93sl0YWcJFfCUQ52/rfWNfZZfabhbtIzo4JOtaSApKIrc61+H5lpFtiJ80jUdX2qoXhaJQVgpIsrti0kWwcFwPCrWHeGjlQ073Mb96IYivzWmhjSFN04J8RQnZvuc4pxTbvncX7Rb1WBQiFK7ssQi9YBbtFFGOle7CqqOiPzYikRwhtzpBNKZ1hJyPrg/nv466pANSn2LwKbbaiV3hTFD0tD+es3HvjLwKhUzK4bxKvth+1vr82F7JKBVSThRUu02d9VR8t5xTFuHE0/VUSZ9Tmz2FX4LuI79qFa0l50mRFpGjlHK4TsovteLtuAvwsWfozWNpX32dNbwnKSiJlOG26ribn3zWKhBavk+URh0hhmpSu/bk/tHXcLrMfQCGZZlF0FM36LlQ07weqHUycbV4c4JerhTuKgabGtc9OZRuSWH0SgunT6vIZu23OT0HwVbFav+elEslnOs5gZITy5ma7jwAxpWl2yI0qnzkyIvPENlgvglRKW+6v5h9daIrjL4m/FWpBAV24KaJ7cnptc+aSrx81gwHYVBkExbc9HI1RojQUn9/Qtsm56aurGDfqqVOb15u+voz/LXFRGj+IObumfiHRYJBBzs/gtY3QGTTiaUSH8/CFoTjXAmDFi5FIAwU9GPz4qU5jB8/nvHjx1/pafwtWbZs2ZWeggiT0Ygu77y5wsyJBXXv3r2iMc4w1tSgk8pFVmIhRSpbhazXYvzX8U+zFF8Omi0O1tbWkp1ts67l5ORw8OBBwsLCaNGiBZMmTeK1116jVatWpKSk8MILLxAXF2ftS+jFi5eLR19Wb64YdIUJjCfquHvqu6z87B2HcA6Q4BcUxMjnXyMqKYV2ffo1W4ATIhRBbBfZKlEirn0Ahv0F2vHffiU7KZwuN4jv4EmlMo8ESiFNbcNSWdg+LZ6Um+7l5yX/Y2t2L6fhDg0X+mLUxmDUBzgNxlAadVT769DJjTQojLTt0BN5hAzql4jG+flcfDnWpI2TrFVVNRccbaplygikcs8asD+W8Rh9Evo4vCdJQUnosgoJrhG/L5ZwEYA69WnyagtpMEooaNCIxhXrJajq61Hpcx3ea3Ddzy/tzfeorQsHBOKgnShkqfTSUMxTa50Lg67wM/iSryhhfNrLTpe7Egabg0TWQI9+fd2OyT+SR/WxVOSp4v56Jcf202/sMPBAHHRmCfZkbiadzV7cVICJ0G47bWg72sYGurRg9kwNZ3D7GP53rMitOOipMFlRK+GopsoqnDQn8EMia+CL0rZ8gVmY+DRiCpPD5OAYfu00wAdw6Alnwdn5LBwrFAjRmxxSYDUGh9WdcrK4xqNKv1RDMadl0eL52Iny2SW1+Ck9E0j+iYzv07LZVmLL+wUwfXh7NDojR/IrWXbIFto0rFMsA9pGEx6gJCVC5bbn4Ic0mEtUXQiD7hCKhq/EmD/88W3TueuesUQtXMyJvHJRL0khBQGRjBv4DH76Bj4d3Y24EJswrNEUcOTIIxh9TRiiQC5T2V57sjktWZhIbMFVdUpTzznDk/NdXVnB/pXOb16eXbeYUS0O4SfXo1laB/cugl8eghNLYesseGA1RJk/564+s4oIP6KndMPU4HoyEh8Zighzr9ymhEELFysQevHi5f839qKfsxCLpoRBC55ah70W478GaWDgv04YhIsQB/fu3WtNGwKs/QLvv/9+FixYwH//+1/UajUPPvgglZWVXHPNNaxevdqj5rNevHhxT93BC+aLEnctgiTgW6Rw2l9QIoGxs+ZZAxQuRoCzx1nVjbOLauF4ay+nrz+hJqfqL7MUWSoLw6++nutmbgHSwYBTq6G+9irGpiTz2QnbwgfjK6jesx6FQYvUp4xf+hZYl61hOThp8/X6rtcvac7ZFdmodWrOh4nf9IYLffmyewwSn6aDUADSQtNcBkCc2r0df1/xxZSv4G8P++ARIc7soUKc9fPrGNHRbCM1mJc11XevtBnFVC/kPUiSNo54QzTZSseKxcuJyeDjtBpJLCy0ZNbAOxgwpAd9q5XoiSJn20YSg80VoTODnuOhQ7UuhTuJvPKixEGhwGa2GDuOMWqjRFZui0gYGejj1t7aOtps52wZ5l7EcydMWgJyKmol3PPxGYQqqUkXgTp3nEf9QO2FxE0tQqC+acFcIjWfVPYikKuQEFdjrQLh3p0iYRA8r1TzFHthECA7QGznF4pPYwNOcz7nLGsir7us87iSWM49T/A0VARg2aFCq1ho+X36s1GHJdHnblu1/KOvvMTe5b8yVG8gObOvyxYczqpd/WhPt3Zr0RvUyGUqiuuiRK99bMAZdH/8AbIgtFIFGqkvvkaNS5uw0GLsaaWnJ+d7VHJLa/9f4c3LUHkto1ocwkdm/h3yzV0PczpBbeNvgqYavhwC49aSQ5zTz6xJpxPYeJ3/XgnxVBi04BUIvXjxIsSV6CcUCAGPhEEwW4Y9wdNxXi6Nf6sE2+y/XPv16+c26VQikfDqq6/y6quvuhzjxYuXi8NQq7X2GHSJRIKhVusynOP8H8ea3RfocmFvKVIf3QHYLEUAUrmcbjeOwD845LLv31JZeDTfsa+SvchgMvhQfy4LsFkJq/esJ0pbislkoizgr/lxnrRpktPnfSI3N2s7vqY4l8uiW6ZxXYvhpCnnojGZhcFIhe31aTx8qdkV2VZxcHvBdso15ZTWO154Wfr9pUQk8c0jLXl407MOY8BW6fWGXVHVHW3u4IesH6yPLUJTZUMlgRp/io+f5XyDGr2vCjy47ru33b0sOrHI6bKB8bewLv9X6+P6/FE80L0nPZJjSbsxxamQlF+yR/S4wmche/e9CcDVmeu46s7brMtkO09jlHRx2IZNuPO8im5syFUMvvoZVL7BGOuDUe/9juzAbkxaZa7OdHaO2/f3q82e4tQSOXVoO6ICfayVVQC67IOMzltM8ogxlAYk8vHm0w7ruRImLb1Ij2qqcFY+aaxrRW32FGR+eSJREVxXPEoUpSz3QBgEc4DP0fwqh+AOd6KQ/TJ1gx6ZXMXNTz5LzkGzdVMYyJASoWLhuB78UVhDYVU9X2w7a10mFHr+LNQnDxDajIsIT22r9uPSarLJDrSJlB1rzhEuacGmS2zRM290Vy74RFJSrSEqyLfJVGKdtkGUfHuxAp+w0tAThhb9hl6qEFlsPSG1aw96CKogm7pZZwllcoWwtYO6Qvwb90VtS0hoOjRG+BpG5y0mTiUhJTUNjnyLViJ3SOd+bnBrokP8Rd8LTRGRmORw87JlQDl+cuH7ZQL1Bax3Qk0GqK+ArFWok8eItqdu0NsSgtevJ+C66zwKACn99FOPhUELhtJSSj/9lKhJk5q1nhcvXv5/0VQ1oFkgzMOE2TLsCQqjnuTqIoyNPQeFVuIYdTlKo87bc/AvxFBTA3l5KBIT/1XVg1c8rdiLFy+eIwtQNp0saDIhC1C6Dee4kuKgvaWoUh6MTu7DhjWbCNZVIpMraNvr2j9FHLTg7MJPWOVkER3U53dCtO2CSmHQUuWnRSc3Uul/mdMbBHQ+GULCBT9qfXQOASfNYWy7x5m7yiwC3XPiDBuntHB6AdflhmHU1eVQt/N9p9vx9fT2WeO47QXbeciFDdi+0jD0IkRWoTAIZqFJpVAxasUo8cBamDdoHiE+IW57DLpDKAyCWbQbnt7D6UW6xeqWXVIN2KydhWqzAOAra0BvUGPUaChf8BVhY+4nLK0lnHYu3IE4dXhMX19+ODPf5VxbnVxPukYGt86D38x2vHxZX+Ah0baE57jUV2xXdxXaIUxrtVTqZO3YQoi+ivCzO0kY6r5xvP3rq6iVQLj7aiOTLgJn5kCLcGqPp70K6/JGO1QrWrBYmyvqtIT6K63zs4QpORur8pGT1q1n4/uvtlZ2uUvH9VPKrOfQ8bMVPNUqjnPqBn4qcOKHvkiUTtLfnQlZmeW7KFOEciqwtdW26op6uQ8FAeJef0JhEOBIYNMJo57iykLszFZ6atd2tn73NTV+4cR07ObwfnlKRZ2WDvHB1gpC+wq+zIrd7BSEsgQaanF6ojZBXb2W/x0zV347Ez6d9fRtCtt30MW9diFaqYK66jIkEildOqZxZv9ehzFv/u+k9d/zRndtUsC1YH/zcn95HDF+NbQOKkNiFQSFPXwl5KTcjTrxXofXdqqwiqIZb8Guw8QDtRs2cH7Sk00KhBEPPkjlTz83SyCURUQQ8eCDHo/3chm4cBJO/gaZE0GmaHYfSi9eLjee2oQNHoqCQlwJf0qjDh/Dn3fd4cU5hpoaZDU1yIKb7gv8/wWvOOjFyxXGVe8cZ/hnRFK9tgmrpAn8O0cRrXUfznElsLcUVUgDRY3OH9Nu4N4n/0NEomtbsqe4O65Ca7Pwws+ki2Bw0UaCNaXWcIHReYvRyX1Q6BuQKkv5pV+Bk71dXmR6UOilJIe2wKPSNxdE+6Zg1NgEAneVNP7+KVyduQ69QU2d+jTHjj9lXdav03t0vMrf2nPQVWBHvb6e42XHOVlx0ulyeyx9KS8VlULlYF+2EOITgkqhcisMuqoadIZnVmJxzzdhSnFa2mkSTm+m7Ju5KOLjyJhwDxsbz9Vdee14ffVBq3A3cVAwn2w5jsngg6G2PVfHxbgVB0tlMo6f/g3VBxkkVRWTY4zhIY1YpLVU8lmsxK6s3JY5WCzfwiq9zT//SK6fXhQmEBuSgEMqjN1+hcJkbTezfdHVZ9HC7cm/85OdxdhVT0JPexUaGxztuRZcBUk0NXbhuB4iIbApa+pDC/dZg0iGfrK9yX111MqIjNGwodx9NdTk61uTFuHP+VWLqT5bDSaTODBFX0WJMkK0TpImj/QWkZyqxUH4aw7OzpVLQaNzrri5soJn7dhCpTyY8Zs0sGnrRe831N/8G+nq99i+Iv+8b7zTm3bXnD/I1oQMl/t58qcjosf2lnZnPX1d/a7V1eVw+kIlN398+X6flEYdmEyc2bebXoGRqKvUVIa7vkASBuw09beMs5uXq0+aSAo5jK+pTiwMSqTk+Laj/4kb4cROh209+dMRUPWGgb35bO0M4tWlHgmEUn9/0tb8z2NrsSwiwmsp/qsp+cNsJ6+vgPP7zDe+XPShvJJs2rSJSZMmcfDgQbfjCgoKGDVqFFu2bGlym8nJySxZssQa8Clk/Pjx3HPPPaI2X87o168fkyZNuuJ9/4XzePHFF2nTpg333HPPFZ3TxeKpMHipWKzDe3Zs5Z2Xn2P3jz/+qfv7q+g9ahRvTpnCtd2788hLL3HnjTfSt0cPh3HPvfsuKn9/np848aL39fuePWgaGrj+mmuaHJubn8+abduYcMcdjgv/ZT0eveKgFy9XkOb0uwKQh/vh3z3GnFbsrOBKAv7dYpCH+V6WgI8/A6GlyL7Ref9HphCRGHvJ+7A/rrM71XHjbcNQKG3igavjfO8j49k/+3l0enPwRoi+imqlDp2/kSrfv6aUf296JXup5OfrZ3Gbyh+1Ts2ZqjMiUe7etnez6I/FDuuO7TCWBq2cAFk4/oZ04KB1mbDSydnrd5U47K9KJSbQ3NS+Ine9y3m7S/l1hiUcxRJgs+v8CWYefLlZ23ii8xMcKT3CqYpTTpfvLtpNhN+lCxUAz3WeydU39iLav4TqGnNvL8sxs7cSO0OiKGX98U9JCSgm8hUT/qt/JvjmmwXvRRuMmgvWsQvPP4uq8S35pN8PJIS6vyh9L9xmQVmhlqHWOu/1a28lFiK08Nr3/bMkIO/esZcz+kpCBGFHBet/YbhPPA0KFVEDR/L1wXKHbQstxg8t3CeqNMopdS7uBvvW8kirTVSbEpFItSw8Ntql8OSuxyGYKwaNDdGXRbiyx75H46G8SocxY3sni6zFzbG9HlEaoAlhEOC9NWZhft2kBzm6sIHT+3Y5pM/a95BLS0+n/5j7+GL2xQtqzuzpJl0E007/j/rxjzBzowfJO3b4KpwHq9gfN6FYrZWGNHs/9uRX1ou+I33tprErTFx5vy28l9PtuBMGneHsfBB+T7v6e6GuLocdOwc2JqL/t1n7tOf6knWE6ipsPQclEuIUvgRt20Vnk4mE8mpan5tHjU8AtR268JFvO4dtnCyuaVIctPT/td68fGE6FR8OxadSjcMfNyYjanWdR/O3Wt5NpssqEHqFwSvAhZNmYVDTKMKcWAZzdjrtQ0mEY2jc35G4uDiPhMGm+Oyzzy7DbK4M//S2Y8ba2j9dGASbxfhcXTlKg/6KWYmNjX/nSZtpq5UFBmKsr8ekdz3vj1955ZLm1hS/79lDVU2NZ+JgQQGf/fCDgzgoDQxEGnCJPVL+YXjFQS9eriDOelg1ReiIVABzarEEWw9Ck1kYtCz/O7Nz9yGKFeEOzdD3HjmJj7+/R1WU7rA/jjtWraRNQoTT0BP7KrDz+3ZgEPyYVfvr/pJqQWfsPrGJewc8AkBhbaF4ocT5D/UXR7+w/rs2WwfYhBBhpZM7IVouU7l+fJluoM0bNM/an1AUYmKbIrP7zyZWFesgjFp6DGaVZ/Hi9hfd7qe5VuKxHcaKjuHkbpPpEdPDKmRaLsQtXJ25Dn//FJSSKtz9pFrEk8W1QK0f02LqiTyyh+IZbzUul+M73GaLtrfIhgaYSApKYmrXGbyxz3mPRiFqqQQVGqfLPLXf2idhTxwQz4f/a7CmqY7OW0yIsQqT0UiVIoSlsTebBzoRBp1hqTSyr7oTIqy6fKP3dJ7s+D0z9z/qdKylj9/Bs9m8tFEsYtcXDsdQ296jeV0MJTXiY+qsAlEoDMKfmyysMSBOUxZUtoXoq8zVhDIlaenpjJ3yJDK5nHmju3qUmiykV9k2JEjYES+u9rbY0yUXCqn+bTX42ux/nqbfpsSGiR67ssyu3XsSlbEef0UMgbrm27jscaiAO/8HQ4t+c5kifLlo6uaNq78X9I3BTr4efq7dEaqrIErbKJI1CoNX7T1mrWLRG/x5obfzlhHJkkJUaHhzUSHce5Nbi7HDzcvd8wivtDv3JFJrBaHKWdqXE0SW+MskEHqFwSvEyd/MFYNWXPehJOKJi96NRCLhtddeY9myZRQXFzN79mxOnDjBzz//TFVVFfPnz6dfv37o9XpuvPFGysrKqK+vp1OnTsyfPx+VSnyOnz17loyMDMaPH8+aNWswGAzMmTOHgQMHWpdVVlYCsHTpUp599lmUSiVDhgzh888/Z+/evSQnJwPwyy+/8Mgjj1BUVMS4ceN4/vnnAXEl3uLFi5kzZw5arRaj0chrr73GzTff7PA6a2pqeOqppzh06BAajYbMzEw++OADlEolr732Gt988w0+Pj7WeSUlOXfw7Ny5k0cffRSDwYBer+fRRx/lkUce8XgeY8aMISMjg0mTJqHVapk2bRq//fYbMpmM2NhYVq9ezZEjR3jkkUeoq6tDo9Fw9913W1+7q3UA3n33XX744Qf0ej1RUVHMmzePpKQk1q9fz/PPP49Go0Gr1fLUU08xbty4Jo+LM86VltK5V2/G3HoL67dvx2A08s4zzzDg6qsBWLx8ObO//BKA+JgYPnjpJeKjo1m4ZAmLly9H5e/PmXPnCA8J4bM33iApPp6FS5awfMMGfnjf3Npn1ebNzFmwgP99+SUKowHLOZ+bn0/m7bdTuN1ceV1bV0dUz57UHTlCvUbDg88/z7FTp1DI5USFh7P800+dvgaAwgsXeHDaNPKLi4mPjiY0OJjWKSk8P3Eir330EcdOnUJdV8f5oiKWf/opHyxcyJa9e9Hp9QSpVHz48su0TjHfvfbv2JGX//Mflm/YQGlFBdOemMT4yU+BycSmH37giVdewWAw0KV9e/QGmyNg8AMP8Oi99zLsuusovHCBh55/nvNFRcRGRhIeGmrdvk6n49UPP2TTrl1odTpaJSUx98UXCQ0O5sFp01AqlZzJy+N8URHpaWl8/c47nDh9ms9++AGj0cjve/Yw/Lrr+O+ECdz66KOUVVaiaWigY+vWfPjyy6j8/fnPq69yrrCQniNHkhgby09z5zL1/ffZeuAAOp2OoKAg5s+fT5s2bVwe0/8veMVBL16uAK4uco6dzwFS3IpjEpmUsNtaEdQ/kboDJRhqtcgClfhnRCEP+/ungueUqhmzphLib3dY9ubuWthtrl7xxJrkbNvOjmuFIpR1W/fh266HU4vxT3em8svsd5Hp6ik4K74jqJMbRY9n9Z1JXGA8pyuymbptmm3uglAMi5U1vzafck05B0oOOPTJ84S38j6iT/VQs3hmJ8p5YoV11j/OYv3LrsghJaKDwzq51bmodfXEt/+aOP9gUXVcbnWu+6TsZlCvd7zYs7cYp4WkOU2+toRZnKlqfjWSMx5fZqTXzC8JDI3mSKnY6hfhFyFKebZciNs/9vHX85+er2Ey+qDRxItErQkdv0bqe94sDDaiMYGk3kT511+B0YREqSR56FC+eaQl5XU1lGo1zDxoG3+m6gwFlfVM++UUKg9c9yqjiSRZCRtDX0d95xKyy3U2+7yH9luJTCy01JkKkfrWW22jQpHHU8HHGWeX/gaENzlOY/AhQOm8whCEgQ1pgFgcNOmDLnp+rpg2tB2vN/ZiFPZk9BShgDhtaDtO51Tw3QnP0sebQuUjRyaXuxYIDdWkZvTk5ieftIaoNCcJ2MKOmDZuk8Zf73OTQ6VmlSKErxPucpmC27d1JD1ax3K0VkmfxufcJQ9vC+9t/ffwwuXmVhAyJQ2RLflV4Rj24ykW8S0loytt4paxytjECpeIq5s37v5eqFUbkBrOAxCtusAbvacjDX2OZ1dc3J/3lvekQh6En0xJ+PEzSE0mjMCFIH/UEuffHcmSQjb5TLY+7rcIzppiPf8db32D2SaqqTaLPkhAFdlYJWYiRXaBjUEvox7+Bafqg0WW7Kf3fkOLmhL89A3Eq+3EvUsUCL3C4BUkc6LZSnxiGbjoQ0m7YeZxl0hAQAC7du1i/fr1DB8+nA8++IC9e/fy448/8vTTT7Nnzx5kMhmLFy8mPDwck8nExIkTmTt3Ls8+63izrqqqinbt2vHuu++yc+dOhg0bxunT4sCukpISxo4dy7Zt22jbti1ffvklZWXinrOVlZXs2LGD0tJSUlNTeeCBB4iPF/fbHTx4MHfddRcSiYSzZ8+SmZlJbm6uVeizMHnyZPr06cP8+fMxmUxMmDCBOXPmMH78eN59910KCwvx8/Ojrq7ObZXYm2++yZQpU7jrLnOgUEVFRbPmYb+tkydPsm/fPnx8fLhwweycSE5OZv369fj4+FBfX0+vXr0YOHAgmZmZLtdZvHgxWVlZ7NixA5lMxsKFC5k4cSIrV66kS5cubN26FZlMRnl5OZ07d2bw4MEkJCS4PC5PP/200zlLpFKqaqppl57Om1OmsPvQIW7/z384umoV5woKmPree2z7/nvio6N569NPeXT6dJZ99RUAOw4cYOdPP9G2ZUtmfvEFj73yilsBrzms2baNqpoa9i9dCkB5lWPwopApb75Jj06deOHRRykqLSVz5EirGAew69AhdvzwA9ER5t/vp8aO5c0pUwD48bffmPLWWyz75BPreB+lki3ffsup4hJ6jxjOA09Owmg0ct9//8u8V16hf48erNu+nUWN83M2n64dOrBs3jzyi4u5+vbbrfOZvWgRQYmJ7Hz3XfQlJbzx/vu8MncusxsF48NZWfzvq69QSqUMGjOGJWvXcsfQoYy/4w6qamp455lnAHNLkC/feovwkBBMJhNPvPYaHy9ezJTx43n/xRd5+q232PXTT4C5YvC56dOJija3ofnuu+944oknrEL0/2e84qAXL38x7i5ynvk1HzAHBDRpMQ7zJei6y9f4/a/CUytdc5Mm3R3XNVEDWVMF7727iRmpJcSpJKJE5G4ZbUme/gLL3nuDikLzD2q1v84cPBIonofGaK5M8LcTsiyClRChsGUvDs4bNI96fT3ZFdl8cPAD6/OPdX6MDw7YHu8o2IFap3YqpjWFs/5xFuvfU9vnsiJ6BSDu/XfTrzdZ119xywqS/M2vIbc6V7TsUpm0cRKz+88WCYBCi7GlUg8cRcPKhkqOlx13moR8McSXGpH+cQZ1twCHbZ6qOMWKMytQoaVrZGvq1OY/8IvVkWgMPgSeP40qpJB7N73cuIaGp1pcC0ca+/r5FFOrzCVEWQ7Y/kiu/07BOZMJv1ApScEpJMyZTVG0koddHGNL5aQqyWz3xejPf28K5cNjNovOmyWltNTpzMJgY/VrSv1x2DkFrp5lHefOfqspGopvzCoA6/8t/JT3ttXmXJs9hQpFKDUys91CbycO3tYlnp/3i8NOXFG4+Tdof2+T48rqQ9EaXV9oVNRpWXvqKKdKSpFIxTZfiVSL1Df/svXDA4gM9DxJuileb0JctE83dtajUTjG8tvhVCCUSEjt2pObn3zWIV1545R+/FFQyRc/rWOP1v1x8tSebrEYC6lShLjc7k+58FNuIVDIwnE96NMq0uPfgzqZLy0056n20dP93gdY8kuOR+/3tKHtMCEWeYWVfI+8+AK1k56kWl3vkNh7Kcgwki4r4rghBgO2C3LL62367wUAOW/0jiRadYFo1QXQPsWjnTry4aEJHs9jUMlaYhouEKKvokIexKJEcz+w+XHw6doZlETIKA4JQFbv/LLBvkrZ8tjj3/HI1ub+cZb+cu2GifvL+QaR8sBCiGqLesk60aotakpIq3LzXWMyUbt+PbVbthA4YIDLYfYCoVcYvMLIFOZzYM5Oc8WgXR9KVJHm5bKLvzFlYdQoc9V+t27dUKvV3HnnnQD06NGDU6fMLUtMJhOzZs1i5cqV6PV6qqqq6NXLeUsBuVzOmDFjAMjMzCQuLo4DBw7QooXtb/adO3dy1VVX0batuWfi/fffz8MPPyzazt13m3tyR0RE0LJlS3JychzEwZycHO655x7Onz+PXC6nvLycnJwc63YtLFmyhB07djBz5kwA6uvrkclkBAUF0apVK+69916uv/56brzxRhISElweq/79+zN9+nROnTrFgAEDuKbRsunpPISsWLGCt956yyogRkZGWuc2ceJEDh48iFQqJS8vj4MHD5KZmelynSVLlrBnzx66du0KgEFQoVZWVsa4ceM4efIkcrmcsrIyjh49SkJCgsvj4g65XM64J5/EWFBIj06diImM5NCJExzJyuL63r2JbxSUHhk/gTe7d0MWF4fU14/MjAzatjSHHI4dOZJX5s61zfMS03Cvat2aP86c4YnXXqNPt24M7tPH5ViJXM6mXbusYl9MRAQ39O0rGjO4Tx+rMAiwYccOPl68mNq6OoxGo4P4OOrGG5EFBtExPR25XE5RURHl5eXI5XJuuP9+tGfPMrBXL1KcnFuW+cx46SVkgYHEAzc29tOUBQaxYssWqqqq+OVXc0Bgg1pNi5gYkJl/j4bfcAOhV12F7nw+3Tp04ExentPXbTKZmPv116zesgWDwUBVTQ2ZTnp6SgMDUSYmsu6775g7dy41NTXm11zumSvmn45XHPTi5S/mzxLHhNTV5aA3iHuiuaM5oSiXiieJi80ZZ8HT43Xg980UGascEpEjEpPoeuMI1n32oVsrsau+eu6CNcJ8xfa4V3u9Sq848x+VsapYkThYUieuwHl91+tuX4877C/Qnx6SxMfZtuXZldlM2jjJ+nh2v9mi9YUhH64CPy4Fy75X3LLCucW4EaFoWNlQ6TIJ+WKp8YNRRa/DCsdlQovxIxEa2vgZKVZHMnXbC+Ynd8J/ek4VrRMQmCgSTlbUAXViIemj/nJodLkvHfgWPvGtUJcd92zCRn+MmnjqT4grr1rqdKRrdXaWcxOcWIoqJBOwHdsH0tPIPnKQrXYhIiaDZ9VjElmDW4HEU2HwmYpN1PnX8G75Ktq+9IaD4HV9yTrkRh2rYm5oUuy47+tV1mPuZxdmLPwsTGrzOdOXXPBofu4ID/jrwp1sVZHNHyMSCPfudCoMWkgOVhJxOIvYMTcw4lP3fTQ9tae7SsD2BEsvR09/D+pkKnKCA9jc+xi/HH6UgDTn4qQ9zsRZ+0q+2194nW9eexl5/eVLjEySltNVkY/a5MMZo616VigCe4LGrho4PqB5FajRDSWE6KsxYaLGrr3SwcRYZI0VuwZfHZOOz0dVLef1zAesVuI0ifjzbnkcXN8CcJ9kbiWqrbl/XNYqWzLtyM9hZ1doM9TaVy4ysxvs3GZdzV26NgASCQEDBhDg5mLZgkUgLP30UyIefNArDF5JDDqzONxYPSrCZDQ//8tD5nPkEgVCX1+z68YiCgkf6xtvtC1evJgNGzawefNmgoKCeP/999mwYYPH+5BcRKiBZR72cxFy5513MmPGDEaONPcUDwsLQ6NxbCliMpn4+eefad3aMeF5586dbN++nU2bNpGZmcm3335LHxefl0mTJjF8+HDWrVvH1KlT6dChAx999JHH8/CEqVOnEhERwYEDB5DL5dx6661NbstkMvHcc8/xoJM08YcffpihQ4fy888/I5FI6NKli3V77o6LOyRSKYrEBMgzV27bv7+ywCCUgQHWsbKwUCT2omPjOsqAAPD1RRYYhKGmmoYG8XeaRCpFkZCAvLRUJHo2CP6dkpjI/qVL2bx3Lxu2bWPa7NnsXrmS4MZ9SmQyTAYDssAgFAnxDiEb9vMPEHz35RUW8tQbb7Dlu+9omZhoFkEfeEA0XhUWjiIxwfxa7c5ViUyGMiUFXd55JBIJUj8/pIHmvzWlfv74tGoFUinKuDgUiYnIamuRhYQgCw5GkZhgFvXmzuX6668HzH2ujbW1SFUqpAEBqGJikMhkKBITkPv5iazLEoUCaWAgxpoaftywgd8PHWLTmjWExMUxa/p0Nv7+u+h1WITBvPPneeyxx9izZw+pqakcPnyYa6+9ln8DXnHQi5e/GE8vcqTGQqD50emueqK5ormhKJeKu3RSZ5UvnuLpcY2MDOfeJ19xmoh8ZOMawNFK7ApLTzxhlZszesX1Yt6geZRrygnzDbMKg+AoKl6M/dgTZH55NJwRVx9mV2SLH1eJH+8u2k2huhBMkFfr/E7c5SC7Mtvt8QObaHjcUwGtEU3JIHyj1oqeq88fxas3ZhAd6kdqYAqFuu+Ab5vcVk3jaWG5ELdYtAt14j/4DIo67ur0Gcs91FPLj+yjZXwHj5ObLbbg909WEZBme15lNGFvx0MiM1fddB3EB7UnqNXo6D5oEKlRQRy+ph1bPl0u2rZR71njZU+tya54xS+PdHk9fxzaR12QP5q8E0Qu/IQyvS9mW7CZNvGhdLlhOKuWnW9ym56KVZEBjim4/93zDcFaNdEZ7am6dwKTf7WdZ8KQBsDaq69XymC332UgFpgmX9/aGhhieYwJ3lsreO66EKpL5qA3yPjyuK2a0tn3m/1z7r4Dz1U2kDJqIiHdBtCnTw+nwqBJp+P8pCepXb+euoE3Q0BfJ1sSjPfwHLiUc8UiwAp/N3acLnNZabktvBdS3yRUHLM+dynipIUtpy7w4tJjEDz4Yn6WnTJ5UGsObDK/98mycs4Yw5k9KoNOiSHW3z9Pf9fs+w1aLMaB8fN4/AfXn522DVs4G3+BLI2KuIogKkIq2Zcsg2LbmOywOEJ1ldaQkrIAf2qU8NwfC3goY43T7c5RfmT+xyLg8f0Q7mEv5IhW4v5xMgX0FveTaxkTwoZJvTnz+tuwY6ujlVhIozDozlJsj9Tfn6hJkzybr5c/j50fmatGhQj6UFpufLGzq8M58mdQUVFBREQEQUFB1NTUsGDBAlEloBC9Xs/ChQsZM2YMu3fvpqCggIyMDJFtODMzk8OHD5OVlUWbNm1YtGgRWq3W6faamldKo/1y0aJFVpuvPSNGjOCtt95i3rx5yOVyKioqKCsrIzo6mpqaGvr06UOfPn04duwYBw4ccCkOWuY7YcIEEhMTmTp1arPmIWTYsGHMmTOH3r17Wy3CkZGRVFRU0K5dO+RyOVlZWaxdu9YqzLhaZ8SIEbz33nuMHDmSsLAwdDodR48epXPnzlRUVJCUlIREIuH333/n0KFDTR6XtLQ0V9MWvb8HCgsoKi3lqrZtCQkK4q358ymuqycpPZ15b7/Nddddh0wmQyKVsvPAAU4Vl9AqOoqvVq6kf79++KWk0Eat5vCsWegjwkGv5/tVNteG1M8fiVKJPCSEpKuvxgScOH2a9h068H2jxVUWGETuqZNExCdw20MPceMdd7CiSxeKTSYiW7QAkwlpQABGtRppQAASqZQB113H4o0bmfrwwxTm5LD699958OGHkfr5ObzeqpoaFAoFMRERIJPxybffNu43EEONuf2MIiEeiV31Y9u2bdHr9WzcuJH+/fuzOesPzuTlIY+KQpmYiMTXF3lEOBKZjIGDBvHlggW88sorlKjVLF++nIkTJyKRShkxYgSzZs3immuuwd/fn3qNhpy8PNq3b49EobAKmxKp1BwgYjB/RwSHh1OQl4cyMRFjbS3VUimR0dGEJiZSU1PDomXLSIyLQxoYSKBKRbVabZ6XVEpVVRUKhYLY2FhMJhMffPAB/xa84qAXL38Cwso9QFTFlxKhYtWjqezc9xCF6hiH3mSxqiJ8ZQ0UnrpAcrh7Yc8ZrnqiueJiQlEuFVfCnyfVMe626epC3XJx72PS89gnn+DbmDylrqxg36qlGBvvcBWfMYtjCr1n5f2ueuI5QygICkkKSmJ2/9miCr4/A7/47/nCTvMUViwCIjszND/M42KZtHGSqHrQHZ4KaFaMzi8II/2Tua6FuediwdB+sLZpcTC/PhCj1o+q+lBRZeBqO8f36wcXNG+K2/bCkPtFFZL2ISz1+aMwaqNEtliLPVjqU8w0xY/mgXZ2vFxVMOrhH6JSKrnp2rbmJu/h5j/+ApVSkcXYsm1XlmNnc/CEV4e3NwsrAjQ7VpKnreBCuPnzXhLgx7Y1y7mgDIUM2x/lIx6fhFQqA5oWBz0VoXK/+gVk/cTrSiBIq8a4Yys56jKIsgUmiEIaAPRQffB3ls9qaKzAczwnhRZgC/Y9/YRCofW59ZXA/QA81eVDrmr7EOHBLYj2LwFS0Gkb2L9yKV1uHG79LamuVxPkp3L5vepwA6hjAykR4rlZhMGsXYepD47Hb+dOvsk0cbLfEHYcPc0ajV0pJu7t6Rd7rgAM7xRH/7ZRhAco6dMq0vq85fXZ996zYBHrXfU/FM5lQNtINvxxQbSeu7nan78Xiy862suLkGCi4ayaeKm5x228tIpu8nPkH9VQf9aH+q49SG8R5fZ3Tfj3QrTKVgnbPn0m/qpU698cGmMYT/902Ol8/vDpA6WwxxeIbXyyWDxmTdQg67+vK9nA+iizNbe9JIeHcC4Oimi49JAYe1rGhJAy8xWzmL1hg6ifppWLEAa9/I1oog+l5cYXbYb+JdO57777WLp0KW3atCEyMpI+ffqQm5vrdGxwcDBHjx6lU6dO6PV6Fi9eTGBgoEgcjIqK4rPPPmPEiBH4+PgwaNAgAgICCAkJada85syZw8iRIwkJCWHAgAEuBctZs2bx7LPPkpGRgVQqRS6X8/bbb+Pr68vIkSNRq9VIJBJatWrF/fff73J/H3zwARs2bECpVCKTyXjvvfeaNQ8hzzzzDNOmTaNLly4oFAri4uJYtWoVzz//PKNHj+arr74iNTWVAYJ2AK7WueeeeygrK6N/ox1Vr9czduxYOnfuzIwZM5g4cSLTp08nIyODnj1tifOujos7cdD+/f1m8WJCYmIJVKmYMe15ho03h50kJiYyf/5863q9evXihTmzyT51ivDISL7++mtkQUFc3asXQ4cOpeNVVxEbG0tmh47s3rcXWWAQ8ijbb6DCx4f333+fkU88QXhkpLVKU5GYQNbePdw+ZQomkwm9Xs/o0aPpZGeZlQXZei/Pef997r//fjovXUpsVBQ9r76a0LAwlCkpSJU+gO17u1PXboy6+266jRxJeGQkw264Adats1b5AQ7CIIBSqeT7779n4sSJGAwGunfvTqdOnZBIpeb/GkVTMJ8/Y8aMIT09nfj4eIf3vKGhgZ49e1qFwGeeeYb27R1D5iQSCdLgIJQtWjByzBhuGzmSzl26cOutt/LEE0+wbNkyh8+wMjGRroGBdLjqKjpedRUtW7Zk2bJl3HnnnbRv357w8HBGjBjh8nz4/4bEZHL2i3rlqK6uJjg4mKqqKoIEJ7EXL39n7MVAYeWeEEsVX3XNUfbsGU5udQKv7vyvdfmLmW+TFGS7CO7efSlBgY6hEe7mUKc+zbHjT1mft79QsCBscn65qveay59VtXg0v4qb5m61Ph6V/6P14n740y+Q1s38h0HJ2TMsnjYZg16HRCIxG1cae3IVhNdTr9Cj8TWyp53tDqgleKSpakFPya3OJbsim0mbJl3ytux53ucJCs5U8EX815d925eb2f1mc13SdR6NNYemOApoYzuMpUEr5/Ntx/GN3OpmC2ZW3GL2EQt7KdqnFbuiLm80/okLPZqvMyziybuRavoFRhB232jR8uNlxxm1wpZerM55HKOdQGPpaSicx4phS0AmR62povLgQh4qtDVPXnGhlqTacmg33Cog5hzbxUlFG052epb3ttvO87G9komPKWf2CVuzd/s5zB6VQbVGR4POSG6ZmkW7zlmX3duzBd2SwwgPUJIQ6i/6nN9SvJKEunNgMiEBTBIJEpPJ/PmTSKj2CeO6x58hMSVZFMpQXdfAj19/y6LaZOu2RFV9Egl1kT4UGmB3TIpIrHqw7fOEymJ5YWnTPeiGFyxjaZxNHBydt5gQvZPm3oLefecqG5x+lwlbNgAu+8c5w/734OrMdZzdd5bfPniPoY9NJqlrskdV4vbfhysev0Z0E0YoDI4f+Iz1+UnH52Pw09MyoysX8GfzmWq2hTu/ySH1zUeVMtf62Nn56imzR2UworPrdbecuuCQbu2u/6EQe4ux/XrC5bNHZeCnlHHwXAUfbz7jkYhoz8N9kvlky1nr4zeGJHLq96WYjAZMJrNZUioBo8mcOSWRgMEkYaU2nZ8nDxX9Htq/j/bnhwX7vxt+2XeOp3484jDuUrEPIXFJcyoHm4m12tVeIPQKg387NBoNOTk5pKSkiOyybin5Q9CHcri4D6VfqLlPZZTrnnZXAvtEYnfU1NQQ2GivXLJkCc899xwnTjQ/3MrLX4er99dqdW2szLNnwYIFLFmyhCVLljS5j6a2dTmor69HoVBYezBmZmayaNEievbsicloRJd3HkNNtdmG3GgX9vLPwNl3bXP0NW/loBcvl4i9jbdjx49djrVU8VlERHsrkP1jy7jmzkGIUCi0XDy6a3LuKjHxz0BYFXE5xUj7ip1b//MUZ5YvpCDrBKd2bbOKg1HJLbl3xmyWz3yTisJ868VFtZ+WNT2KHbYLzoNHLpbLHfJhT/QffiQbQmla6ro81BcOx6hpgczvtEOYRVNM2uR59aCrMRZRzzfS6WIHnPVR9Ff8RT2mpBqMmnikvTLYF1CB5PQ+WkVGuAxhecMQQh1+vIq5TNGVGJJdfdal0KzW1Zn/cWKZucl7bQkpUhMpxgvEH3mG97ClLt7aNYHAwABmC65T7Cvz/JQy0feFkEW7zlnFwo1T+ok+54H1HVj27utUFOZjarwLbJJIqPbT4hsTwS0PPExGG/Ed4RYhPiz/cha6k6chLtn6vH1VX0gByJUR7AwT91K8UORDu3WrMal60xS+pgZG5y1GK1VYrZROMZk4vW8Xy2fN4OYnnxW9xuggH77YmsOdPRLxV9rey41T+nGyuIaHFu5reh52vwd6g5qsHVsAyNq5lfiMSGswjq+sAb1B7SBGniyu4WSxuHJLGLSRHKy0iiv1QXGicYVBwUTpyjhzYC8tO3ejb8sgtgkOxcJxPQj1V7L9VDFvrhdbOy3nyvjDy4itK6NQFc5nHYfhCeEBSoc+uMLHfVpFsnBcD8pqtRScPsfbe8svuv+h/XrC5dUaW8K3OxHRHUJhEOCqVkkkhd/Njz/+SLBEg7SxzZNUYv75qTT6skmXRqXJz6GK39xqxIb9+WHh0MbjdO3XmmKtjuq6Bjav/A1wHTBwsZw1xfJ8wW0k+DRw7Q19SN9tE5a5dT5EtAafwD9NGARzP6mE2bPEAqFXGPz/g4d9KP+pzJ07l++//x6DwUBQUBDffPPNlZ6Sl4tEIpWKKvP+LttyxalTp7jvvvswmUxotVomTpxorai09FOU/ckCpZe/J15x0IuXS8TetquuPeVyrCXpVC5TcXXmOvQGNWlppzmaNdNqDXJV6decObiiVn0Kf/+UvyQUxVP+DPExJULFB90Nov5q3bvOYO/yX5ErxSECEYlJ3DX9XT4af5f1OXc9B5tta3XD5Qj56BnTk11Fu5wu8zP6Eq+L4rPsl6mXaTinLOKd+AWXvE9XGNTmP9SbKwxaaO7xuNT3orC2kHqD2BNcZxHQmsBkvMQwColZgXjyl3Ui0cEikAotxvrNpYQZpGRh+zxKfZyL1/Z9I4WckUvBpDCnGasvYG3ybjKgahBbMVU+cpKCkvik3w+U19VQUgXTT4hDPM6VeXasThbXMLh9jHDrDBs8nK8WfGR9xhwCZE6oXbzzIVbE2oRig15vTdtVysR/MFv6ANo/Zy9knlyzj2t3boFBTYuDbgVBe+wEQovF+MON2bzzvyw0egMT+9nsSSkRqouyigLsWbqSnAP7UAZpKcrbysol9Uw99oJ1uSrqNE/86tzmJkS4v8W1m6nbdZj6oDjOBYoF1QplGDVyc1VL5ZFTdOnYii8HBRHWqj1B/j6i727Takd7OkBm8XHi1aVsj3VdAX+H7DhlhUW0aNuWAbeMcKg0XTiuh6hScOOUfla78dGoAN7eu7XZ/Q89sSALrcTuRMTmoPKRo4qNYZW2HXf5HHBYvkrbDm3jn+b2N7kSQvS80Xu6VQy2Pz8sZO+uwz+lktu+sQTKXH5h0MKisNsAWL4lh5XCtyCiNcRl/Gn7FSISCNev9wqD/9/woA/l34nk5GSPqgbBHLxh6dn3d6KkpMQa/iBk0KBBvPPOO1dgRn89w4YN49y5c6LnQkND2bhxo8fvr5AxY8ZYE6z/KlatWuX0/HruuecYNWoUBw8edLnuXyFQevl74hUHvXi5SIQ2XiFncma6XMe+ii8osANtE6Cm0GYN8lelemwltuBpheGRI49wdeY6VD5RTQ+m+YnBfyduuk1cpSKVyugxfKTTsedPHMVkMlHtr0MnN1IZIL7qm9xtMhF+EYT5hl0WK7GFyyE0uhIGAYoV5dRLNfgZfEnTtKBEXn7J+3PGC3kPomyIZpJOhdTXs5RaZ2w5v4VCdaHHvRyTgpKYN2geJytOUqwuZtGJRdZlD7R7nIZ6FV/sPCwSK0cm/pcWoSHMPDzVaYWd0FLsymJ8jTSB/xkvrcLQ2GBu8GUvOggFUssxqA4+R7UpF39A6n8KmU+hSwHWvm+kkOeibJVOK/IKSNJbRHAJKe17srFfb9R6iaha656Pz7jcnqtQCHseWrhPVIWcU6pm5/+2UKkIsYpw9oK88DjkHNzH6b07AQjRVzVZ1Reir+LeM2s4VjWAg6HpmIy+7A0IZWJaHp+te4t6mZJzgVG80+0e6zpT9n5DXYCeGn85IYZqj16XFZOJ03t3knNwH2ndelLboOeTzebfhU82nea+q5MJEHyXqisryFtj7nVaWS8HbKWucfrWtAjaa32cEPksG+f/hK7ehLZmK8rABtLvMm87t1oD2MTObUeXAbc2a+onjuUwXWAlFuKQRn3kG7pKpFzb92pRoInld8KkixAJZq9vm0e8upT8gEim9xzjcg4PPfEQZTvWIFcq6dIqkqP54vd04wmxgHeyuMYhsMPS//DFPZ9QEmZk0WCbcG3f/9CdBdk+4R3wuI+hK94ZeRXtYoNE1fGvXtXAH4KWk40FbzzUJYgO7dvROjrQ4caZXKZyKQgKGTy+O+WKSwsMai5q7GyiPp6lnl8uLAJh7ZYtBPTp4xUGvXi5BKKiotwKR/8Gli1bdqWncMkMHTqUoUP/mp6cXv7/8M+98vfi5QrizsbrKfYWYwueCn1C/P1TrJWI9j0HW7Z8kjNnZon2+2clBv9TObV7e2PlUoHT5cJgjh8HLqZtfEePt23pj+esR6G7AAohd7S+gx9ONj/FeFqL963//iz75Wav747Xcx8nyKjCz2CuTsxXljC7g4mitqF8eJG9+4UBKbP7z25SJMytzuWhtQ85XfblCXP/M98Y8fNf/V4P1KPyoCg31CfU6fMGRRky1R8u13u116uU1Jc4CHXa8p4Y6pMx6gMw6UKR+uY7iA5nqsxinPB88c+IpHptLhf8T6JK+rzpiXuA2uJnlEjNTd5vnUeKQpxS52nl8LSh7dDoDU4DNuy3ZW1p4NcHEmG8/3r63DSQNWu/AYqs44XHISWjKy279uDMPnP1mCdVfUH6Ko773IKxwfya9BJ4os0d/BK2As2mTQ7jA4zV9P3jNIeSoikOVpmVGjdYbiQo9FKC6pWkdu1JSkZXAL7afpbaxtdb06Dn6x1nRdWD6soK9q9cikGvI88vAWJuti47vjefFom2/cQmX83Ip69n+cw3Ka/OR6Y0WK3EhWrxyX2munnhVYDzIAcXaGVKTu/fw/KZb3DzU1OtAqHw96S8ug7tR3PNKbK1F8zH8eprRNuZN7orraMDRbbh1OEjySlVczS/yiFw5IvtZ0WPTxbVEB/iZ11345R+lGzZTs1rnxGvrsQcym7789aojRL1P/TUgmzfz1OIvYjoTiB8+qfDDi06ik+b07DlEilLNW3opsgjWlLLgSNHmbu/jo1T+jlsR/g7X1l+klOnn7YuK9g5joaaWG6bcg2h4a1oKL30qvTmcNYUy6zc/mS0SeTasY8h+xOtxK6QKBQECprYe/HixYsXL16ah1cc9OLlIvDUxusOiwgo/IO/OVZie1yuZxJf5FoqHaP9VfhHOK5zKYnB/1SiW6aRqqoDvm9ybGl5EXgoDtr3FHTWU8+TCrlWoZfeVyfXpwBf46VVk8wb8AnSHTVIjqiJ10eZL/xNJvIVJYxPfRkMwOUJ9bSmN88bNM9l0vPF2LI9tR8CvLfPeVrzjoZ6fKPWulyvS3QXwLGK78k+g4mR9XKwEgsRCsSW80Ue7od/9xiqsnY7XediUBktlmKjOf3xl4fMvZxktoobTyuHPakg3H7anNKYX2mzcUsUpXyftJbvj6wFOxFXeByW3rzE6oD2lCpZEFqJuHqoUmdi9cj/cJNUit8ucXrr6dhg5Ipo2tcX4dMulSK1Fm21c+u4/Y2ESWVDufk/zyKTy61VgxbNzWRyrB4U9jq9UCYWqnz04sdHNpRh0vmQ0v0Rypc+T6k+nLe3PYUz9hZ3bvrANPLJ3Z0I+vR96mpLmh7cSIXCLJZXHsoCJwIhAPHBmBpTZLN2HoJefai5/2H4yRaIUa81iPoiHs2voqJOy+jPd1vtvhKF64q899ae5L21ZiHaIropd66nWl2KX9cupP1nNPxhE87sP/PN+Q7wBGcWY/vwktLScvYs/4U6rQFfqYn6wvMoTaCp03IhtiurtW1pLyvCgLm3kyth3vI7n59lDg+yCMWl1TGoKpOoPB9CaLj5/bC3Y/+ZDC36DWO9nv0Hckg8V0maZ+YEL168ePHixcvfCK846MXLRXAx1X3gOjn4YgVBZ9jPzd7mbG9ttrcY/5OtxE1h3+TeQpcbhhFe3Yl3fm1aHExMau3x/uzFK3dilr3FeN6geYT4hKBSqMivvXirroXpiZ96NM5dWm+Ifyjpd/RGP1BD3YESDLVaZIFKKpIDYcslT9EpD619yEFUza3OJbsymwvqpi12AOrccWD0F1kAa7On8OLIAGYefFk01mIhr9XW8vqu1y9qztkV2cQGxPJE5yeYc2CO9fmr4uIJMgV4XLlkOV9yq3Op7aMlT61vtkgmZHJZOT00DeaegwahjddkTn/c2VXUy8mTCuP8ynqX4RpCgeQNJwKip8fh1LF9nNnfPJEj1FBNUn0eOYISUZMJPt6Sy71vvUObZ57m03VvcTAhxmolrmihoPwuHWH8gU4dyc7fMtDXyQnXVYiqFe0t0D3vvdcqkgmrBi04qx6s8YvgqokvsWOGuH9TSUM0W1e+QnIrFdcNasXymUXo6jdhwgCYUNf5g/OC1maREB5I+1mvc37Sk8zYMZsDLeKpUIQ6WokFiJYdWkyHvbtIy3Ts4ShRKNC98BrjZ28zP/GTOCnXVYjNxYR+WCzGfu3b49sqjbAHHkAik7G8dWsKf/6OU9pgXrTbhkkXQdtjz7DPvw6pskRUBShMo//+k0/xJI/cXmx09jqKLlTw36ww63P31WgI1laiUYZwY/FqShWh7ArraV0uDI1xVsGff6KBkpBIpm6z9ZwcLzVy+sAFUjqZbeqh/hfXF/WRwGzKsw5yyi+F/aFdPVpHL1VQ4hNJWnq6tYLWixcvXrx48fLP4v+vCuDFy59Ic2y8ovUuop/gxcytY8ePOXLkkSbH2luM/z9bie0Tmu1tXhaLb0VVKfNnTeH3Trb0zWsPRTDhyXcJDY7wqNLPYiW2WCMtOLOM2u/fmQX5cgSXeEppfanLZWeqzlBYWwgSSOueRlKQWewIqm6+YjWt5zSPxbcjpWZxISkoqdkJz3cnvci8E7b+gC+MiETqU4yvIoJAf8d5Cy3kF4uwl+GrvV5FIVMQ5htGr7he5JSqPa5cKlQXUtlQ6dI67Yx7290r6r0opEeDnnStDpBAQJS5YhATSGTgG2ROf7TD1feBpcLY1c0ET4QeT49Dq/Zdqe92ktP7dnlog5Vwxj+JXP8WDktqGvQs3JvPg+++w9YH70PWoCbEYK6ulinNol+xulF0CcL8HzA6bzFSZanTnqRna3ORymRITD6iqkHr62ysHuzbOhKTCWuVHACR14nGrolqfHwW/LYZkUvXUtBwHq0sGKU8GB/JZVAGAV+ZrU9b93vuQV9yliORnn+OA9U6ImtcB9LUGdzbsp1xKaEfYfeNFj1ODm2JacQT3CX4zheyRxoKGsdjWbnjGCUGs71dcegYtyrjOBsUx7boVJGIaN/HEKBv6wg2nyx1eB3P39wSpSoKyLM+14CcSnkwC+PvwhlCAdX+twogMr4NZeVvATYLdpsBCUSG2cZdzI2+u1S5yI+sI8pkApPJY3HQKhxXwsDKBqTKfJftNLx48eLFixcvf0+84qAXLxeJq2o/lcp1ZdnFVhx6iiUkRSb1a3qwYD7/XwVBIfY2LWe2raSgJHRZhQTXiL8ag2vkBBTrSUr0TBh0JV45s4za798ZlzMhuSmWnXbdhNm+J6LF8isUNrfkb3EbimFBY9B4PCfLfi3VlM0hNACkvvlWIWp21rMerzu732xiA2Id+kEODdJiAn4T2E4tFUeF6kKrJRqgTVgb0sPTrY9TIlRseGIk2RVdkUgb0EgKXfaaFG7HU7rFdHMpDqoU/tCggXbD4NZ5ZivxiaVmYfCB1eZUSBfYCw2Wx8KbCztOl1ktxp4IPZYQCUvgg6sKrqSgJJKefNaaWOxWIJRIyFUl81vEIIwSmcNikwnmbTxJ1K7FFOg0IJGgDNIiUxrwDdECoHEiWtZF+bEmw3lPUuH7pzZOARyr3ao1em58f6vreTvhwMYfkGvPszDxbutzYytljK+W04CRCuUxVvh6Xsk8qMUGWoeeJj6giGPfX0PKozOQKRSkLFiA7vrBlPp4mNAM9E5IIqhfP5fLmyNMWSpMb+khZ42gGNiT0I/W0a6DLzzpmWkvUJ/e9DvF1RIkEglIJATVKUjS69gSKq6wt+9jCPB7zh9IfR3DS95ctxmj9oTIKl2hCMXkYRnwyeIa6827KLmWlb+uoE5roEArR1hGeqpwL+oyPVm5Mm669WZSIkKsn83tp8ucVu/a8606idGyIEL0VU6TwD0huyKHp7bbRE9nv3VevHjKmaozbM7bzL3p96KQKtAZdSw6voi+iX1pGdzySk/PixcvXv5f4RUHvXi5ROwFvwBVK1EPQeCS+wl6gn1ISkanBRiM9Q4VhK6szf9fsViJ7Zvcu7Jtndq9HYVeKhqr0Es5tWsbad160hSeVvk1pxrQXXDJY50f80iM+zMQWn4tF3+FtYUerXsxFXoPrX2Iyd0mN2udD4+9ag0fqS8c3qx16w3m/nh+crHYPqrHhxgM9fy2car1OT+ZeUy9vl401lm1aEqEipQIcwXx+tz1zZqTKx5qP4WbW/dzsKDXFw7HpA/i69E3k6SSQ9YqyJxo7i048nOzlbjNULfCoGXOriqMhf+2CD2eprvaJ9xaaBncUiSqyuRybm5KIJRIUKR0ZIUxE4lUjryxeM0kGCs1Gel97n8cIRtdoAF/XwMZt+QC5orB/cUdKVDHOmxa2W8gVLpOBrftwDOrtCfItTlopeK+ifUNW4lX9kUikSPRdQRf5/tLlhSiQoMaX86azK8nOTiPLtHmKtyskwdYNvMNhj01FZm/P4pvfyV1/MMMOb+B1QnOQx2uL1lLWkUhveNb0GvWG24TYd1Z0oUIK0zX2HUJaCr0Y97orm5vbHkiUJp0EXx07Q9cOFZArV5By0ei2LloPpKCk5iM5krSYG0lA4u3sUPwc9mUlbip1+HOvm2P0LY/98ZEkT1ZyKf5NqGwZU4R3TJCLurGn1amBL04GbxUEc76KM/CPiR2n4G/svLdy/8vTlee5v7f7qdKW8WR0iO8cc0bTN06lbW5a/n8yOd8dcNXpIb89eE39mzatIlJkyY1mfBbUFDAqFGj2LKl6T4sycnJLFmyhIyMDIdl48eP55577qF///5ut9GvXz8mTZrEiBEjmtzfn4lwHi+++CJt2rThnnvuuaJz+qfg6bnVXJYsWUJMTAyZmZmXdbvNRSKRUFFRQUhIiMsxTX1uIiIi2Lt3L8nJyX/OJP9leMVBL/96LNV2FyuWXa5AkUvFPiTFYKzHYKh3GPdXWJv/LthbiYW4sm1Ft0zjhkR/bu/aEi1SQlUtuRCyH7nSs/5Nnlb5Nbca0FXlRbDyyobHCC2/AGmhaS7H2guZdXlmK6DM/zQ+4ds92t+l2H79Ypc2a7yrir7wQEchTWgldrUNZ70TXa0nRFfdFkWQ63RkgDbBZvufvQXZ8prrtEMhqR11/sPQ12XZvqsEPQaboimhoUpf0CyBRIi92OLs8+FWIJRISO3ak5ajHqFkv63Cr7pex7JDNsH6du1elJwSBYqk6SQYtRGi/m32fLe3gQDXp7ZtGgYf5FKbpdYiTBpN4nbQ/8d3AAEAAElEQVSR04a2IzLQh+KqOt5cbUt5vr5kHaG6CjRSX7RShTUExMI5uYlq+QH86ESIybEyEszC4CYfm4jer+E9zppi0Rtk5FYn4CtrQB2s4kDeCVQbl9Oq8/Vc9+Eu6PyA29cWUVvLqNgIWjQhDFrwRJjytO+ks8pTd1WDAOcrXNuehSQEtiAhs4X5t2JnDSgHcJ+8mGBdpXWMQhNkrXJ1Vsl4Ka9jUMlaott0YFGFTZR+YUQkUcFQVSfl+R+Lrc8XmQI82g+B4r6YzankTEtPp/rg72AyIVWWIpMbSdAXMjqviLLG81EvVYgEztmjMlAFVFiroYW4a6fhxYsrzlSd4f7f7qdWZ76Ruy53HQdKDlBWbw63qtXVcv9v97Nw6EJSgv8ZN7rj4uI8Egab4rPPPrsMs7kyvPrqq1d6Cl7AKjy7Egf1ej1y+d9DJrpcnxsvnvH3eNe9eLlC2FfbXZ257qIFwiuFRdy0pBBbcNVzUKMp+NdUDXpiK7Mf17ZvR3bsfBJ1VuPjzHWkDB/p8T7dVfnZWyU9xdLDUKVQOYgmFxuacbkQWn7jA+LJrsh22ffuTKW4B6NEqsWojcJQlwoeioNXCovFWPjeWd5neyuxK5oTUCOkKWEQzNU6ap3U5fJTJaUE1h3izLmHiFaZS7S6t1tFUGwbj+bgCaEBntkkXVmMZ/b6lvgwqdvPh1OBsFEYHPLokxz630peunE4CqVZbDyaXyUSB00XctH7ioUTjQmMTfQ/FFqg/3tTKB8es13gPJXxMtN/LbOKRgPaRuCjkNGgM7DhD+ehOa4SnkN1FSiNOr6Pv93p8m3hluRuPSNr4LmgUFpGlbG7MJCCs1tYGdkFFWLL/ui0nzivCOXL4/eKN6aCr9fD7JCTeEJ6dCItZk71SBi0/C6dr5STXx3icpynfSeF4+aN7krr6EC34uOWUxc8Tup19jvRIBH/eWwymVxWudrPzx3OxsVGN5Djr0VSW4pJF4FEUSpqfyBR2MR0T5LBAU4eH0t67LfW33lLJefJ4hqKqzVU1emsic8WJl/fmtbRgaSGX8PRhQ0cOLGVX/raRPRbN0Fqndl6XqIUi6OqgAqRlVhIU+00vHhxxua8zVRpba0OTJgoqy+z2vENJgNV2io25W26JHFQIpHw2muvsWzZMoqLi5k9ezYnTpzg559/pqqqivnz59OvXz/0ej033ngjZWVl1NfX06lTJ+bPn49KJf4eOnv2LBkZGYwfP541a9ZgMBiYM2cOAwcOtC6rrKwEYOnSpTz77LMolUqGDBnC559/LqqA+uWXX3jkkUcoKipi3LhxPP/884C4Em/x4sXMmTMHrVaL0Wjktdde4+abb3Z4nTU1NTz11FMcOnQIjUZDZmYmH3zwAUqlktdee41vvvkGHx8f67ySkpx/Tnfu3Mmjjz6KwWBAr9fz6KOP8sgjj3g8jzFjxpCRkcGkSZPQarVMmzaN3377DZlMRmxsLKtXr+bIkSM88sgj1NXVodFouPvuu62v3dU6AO+++y4//PADer2eqKgo5s2bR1JSEuvXr+f5559Ho9Gg1Wp56qmnGDduXJPHxRnu3l+AhQsX8s475qCxxMREPv30U+Lj41mwYAFff/01AQEBZGdnExERwddff01ycjILFixgyZIlLFmyBIAVK1bw7rvvsmnTJqf7tpw/tbW1BAYGYjKZqK+vZ8yYMRw5cgSFQkF0dDRr1qxx+hpWrVrFsmXLWLt2LQsWLOCxxx4jLS2NRx99lMzMTPbt28e0adOs71NJSQkNDQ08+OCDPPbYY4Dnnxt3c7Zn7969/Oc//6G2thZfX19mzZpF7969HbaxbNkynnnmGRQKBUOGDBFt49SpU07n3Jzj82/HKw56+VdjX21n//jvjr246QkW0fBihdB/Ep5WSwjHXY5zwtXFj71V0h0WQdA+kGLFLSuYN2ge5ZpyahtqeX33lRUHLXgSmrEqZ5XosbCa7O9OWmiayx6RF1stejl7SZ5W72Vfidbl8pmbtzYGKDzC6z0+Jlp1gZIvdqNvKyV0RCoSmWth0VM8fT2uhJRY/0TSw5uuhBUJhHt3ktq1Jzc/+SxZO7aw9buvCYqIxLddD4d2AhJFKeoOyVSWlou2t//3WOT6ACQ+pW7TcS3iUFpojOj5CGUiRo2v9bErQdATlEadg5XYFUa/owzJO03d1xtpO2AA59NjSMhaRFFEsmhcT/8jRJjiSJYUWi3GQi6c/QNr8oobek17wqkwaNDryTm4j5SMrsjkcuvvkjXYpRGLqAeI7MYW0fX+a/34Ke9t63h70RXg1eHtGdzefPx12gb2r1xKF4EYDOaKcU+FQYD95yoI8hW/rgpFKFHJLel10zD2fTqDcE2F22246585KPwJluw1il6HpUJU61vLr9dkAVsJCMK6DSGeBrP002yiVfdcAhW1RKsuOPx2WcRUV+ni762xiYXrJj1OwbflgK1NgU5uBImElp2706Vbf75fW22bo4d2eq/F2Iun3Jt+L0dKj7Aud51VEBT26ZQgYWDSQO5Nv9fVJjwmICCAXbt2sX79eoYPH84HH3zA3r17+fHHH3n66afZs2cPMpmMxYsXEx4ejslkYuLEicydO5dnn3XsY1xVVUW7du1499132blzJ8OGDeP0afEN/JKSEsaOHcu2bdto27YtX375JWVlZaIxlZWV7Nixg9LSUlJTU3nggQeIjxf3Oh08eDB33XUXEomEs2fPkpmZSW5urlXoszB58mT69OnD/PnzMZlMTJgwgTlz5jB+/HjeffddCgsL8fPzo66uDqnU9d8Db775JlOmTOGuu8w3AyoqKpo1D/ttnTx5kn379uHj48OFC+bfzuTkZNavX4+Pjw/19fX06tWLgQMHkpmZ6XKdxYsXk5WVxY4dO5DJZCxcuJCJEyeycuVKunTpwtatW5HJZJSXl9O5c2cGDx5MQkKCy+Py9NNPu5y3q/c3NzeXp59+mn379hEfH8/rr7/O+PHj+e233wDYtm0bBw8epF27drz99ts8+OCDl02gWr16NZWVlRw/fhyA8vJyl2OHDh3KsGHDrOIfmO3LJ06c4KOPPuLzzz/HYDDQs2dPFi1aRNu2bamrqyMzM5OePXvSvXt3wLPPjadotVpuvfVW5s+fz+DBg9m6dSu33XYb2dnZonElJSU88MADbNmyhfT0dD799FPr58ZgMHDXXXc5nfP58+c9Pj7/drzioJd/Ja6q7SyPnVXWnalroNZgIEAmo6W/Z1UCzvZ5Oav2LkXM/KcJoRdDtH8Jb/SejsbgQ6E6hvlH7rMumz0qg7SoAGv/tIs5J5riYsUgd6Em2RXZHllR/2nUFw5HIqvDN2rtlZ6KA7P7z3Zb7XKx1aLC9XYX7b4ky3RTfSeFYkWhNphoFWhVBZRn7USzLJ+4W/pd9L4tuDsOmvO3c3XRaZJrizBp19AgVVDsE8WW8GucBoc0hUUgFIpSWTvMtpOt2/bw+kqxpdTSE24zgFjbY2ObSqCSAN5lhCKR2rokfs12/PxNG9qOgenRSJXiRO8Sz3M8nDK8cDm+Rg1Ko44QfRWVcs9aBRRXlbHhTB6JqgiS96zl6qhiro5zHNchq5YOnGS4z2SrxViIZukGXjhfgSHIRL2fklkptovtCR2/pn1OIKl3PUxMUAUQIlrXoNfbRNpumdz85LPW3xb7YJf4ED+n1X4W0bVLbCQ/2QJ96ZnQjlcG+/PC0mPW56KDbCLsqV3brWJwuz7m3ls5pWoO5VW6O2wOvCjYvoU1UQNZo4O5v+YzukEOHoSHuKosXLLX6BBeYsKERupLg0J8nsr8cukQH4LwV8iTYBaATb792GTu8sAbvac7/e3ypJpeoijlREUWCTf1g+227+PKQD0J6a3odP89tAxLZWMntbUHqf1nwhV/ZbiWl382CqmCN655w2olthcGw/3CeeOaN1B4eDPFHaNGjQKgW7duqNVq7rzzTgB69OjBqVOnAHP18KxZs1i5ciV6vZ6qqip69erldHtyuZwxY8YAkJmZSVxcHAcOHKBFixbWMTt37uSqq66ibdu2ANx///08/PDDou3cfbc5jCoiIoKWLVuSk5PjIA7m5ORwzz33cP78eeRyOeXl5eTk5Fi3a2HJkiXs2LGDmTNnAlBfX49MJiMoKIhWrVpx7733cv3113PjjTeSkJDg8lj179+f6dOnc+rUKQYMGMA111zTrHkIWbFiBW+99ZZVQIyMjLTObeLEiRw8eBCpVEpeXh4HDx4kMzPT5TpLlixhz549dO1qbrFiMBis+ykrK2PcuHGcPHkSuVxOWVkZR48eJSEhweVxcYer9/fQoUMMGTLE+h5NnDiRV1991TqXXr160a5dOwAefPBBnn/+edE8L4VOnTpx4sQJJk6cSN++fRk6dGizt9GyZUv69u0LQFZWFseOHbN+FsBcZXn8+HGrOOjJ58ZTsrKykEqlDB48GIBrrrmG6OhoDh48KDofLZ+b9HRzocW4ceN4/PHHm5xznz59Lvn4/FvwioNe/nW4q7Y7dvwp67+FlXVn6hrotctm59nes12zBMLLZV+251LSj//s5OS/A3qD2mqhtCctKoAO8eaL8Is5JzxBKJY0x0rsrrpib/Fep89P7jb5ksSlK01z+wH+leTV5HG87LjL91BfWorfVz/hq9NTLi+DSNuykF9+J1x/DIlCjn7MGOTh4aJ1PTkneqt0bFNf+gWQBUuVT+FVn1qfCyi8PBZjV6/n6qLTXFVShgQFYFbTorSlqAx1rI66/qIEQk1tDQUnT3D++BFMRiM5B8yfjdMn/oDY9qKxnvaESw07yQWJcztRZKCPWQwhgk/6/cDoL7dgMvgw/YTrSsFH+qbSJiaQkpoGUVqspXLMIggKEQZBnPeNF1iJxWwL78228N4AfL/7RdIodjpOiL3lGOC9hBHQ+Lf3o53mwyHbslhVEYG99lKSu5GSXPF3oFUY3GcOask79TsrPyklun9fcqsTKFSLVdhj53OAFOsNGV+7tzxY6S96nF9uRKMTW8DrtQaO5leh8rGJwVk7t9KuT3+3PWYvBa1EDpKmx1kwGXwIro9E0SiO+msCMOnFG9gb3Z0qH7W5yhDbeeEX/yPi21NN9+t0hsbg4/S3q6lqeouIPtVJ4eWWTqVsYS0fL1/LiltWkBIh/KyrLns7DS//bnRGHVO3TnUQBsFmMZ66dSpvXfvWJQuEvr7mmw4WUUj4WK83C+qLFy9mw4YNbN68maCgIN5//302bNjg8T4kkmZ8idjNy34uQu68805mzJjByJHm9jdhYWFoNI7f8yaTiZ9//pnWrR0T7nfu3Mn27dvZtGkTmZmZfPvtt/Tp08fpnCZNmsTw4cNZt24dU6dOpUOHDnz00Ucez8MTpk6dSkREBAcOHEAul3Prrbc2uS2TycRzzz3Hgw8+6LDs4YcfZujQofz8889IJBK6dOli3Z6749IcnL2/nr7ncrlcJBK6eq3uxrVs2ZLjx4+zYcMG1q1bx3//+18OHjxIaGios005JSDA1tPWZDIRFhbmNgjFk8+Np6/NGZ4cP+GYpuZ8qcfn34JXHPTyr8PTijnhuFq7Ozv2j5u7z8tVtScMQykr28SZM7OaXCc9fSbBQVddFnHyz6iGvBw4qwL0tRMH3FmJXXE5LcbOsFiJdxe5tsQ56+UHUNGE7e3P5N4wDcN7LMDPL4Hsimz2Fu91mOcdre9AKVOKnrdcNB4qzOGNfY7WnL8LQtHVWc+sM3mHyf7tK3zVOpBK4EGb6pG3ehvh58uRKJUEDR3qIA5acFdRk+JjuKziYJy/47miPp53WfsP2r+e5NqiRmHQhgRoWXeWISVrWB11fbP3oa6sYP/KpRj04nIthd5RCPS0J9yx3zrwo98Ep8uEIUbzRnd1qAZzxseb7aUeMx1bJaA9lO08dRmsgmG5IqTJfQCc84miJ9lNjlPj2+QYIfbfm5bvQJEwaDKhDNKSfudpitXV/GfhIOC/Dtt65td8LDbVdZOu4ejCuYw+/wdaiRylSU/5L21ZOm4JZyoqmbDgKBNO5DpsQ/ge3FeYTTCQc3Afm77+jLP1ckTK/GWiRhaAvhniQ7AmkrsOPt/EqFi+zXiNKr/mWdBlfnkYoEmB0CLM+soaRBZjdynSs0dlIPPNdyoM2uPsBtblaKfhxYuFRccXsTZX7CSQIBFZjNfmrqXj8Y480MF9mNLloKKigoiICIKCgqipqWHBggWiSkAher2ehQsXMmbMGHbv3k1BQQEZGRki23BmZiaHDx8mKyuLNm3asGjRIrRa161B3M0rJcX89/eiRYusNl97RowYwVtvvcW8efOQy+VUVFRQVlZGdHQ0NTU19OnThz59+nDs2DEOHDjgUhy0zHfChAkkJiYyderUZs1DyLBhw5gzZw69e/e2WoQjIyOpqKigXbt2yOVysrKyWLt2Lddee63bdUaMGMF7773HyJEjCQsLQ6fTcfToUTp37kxFRQVJSUlIJBJ+//13Dh2y3QFzdVzS0lwnkLl6f0NDQ3n99dcpKCggLi6OTz75hOuuu84qnu3YsYM//viDtm3b8tlnn9G/f39kMhlpaWkcPnyY+vp6FAoFixcvdrrfmJgYTCYTx48fJz09na+//tq67Pz584SGhjJs2DCGDBnCkiVLyMvLcyl+BQUFUVXl2vbQpk0bgoKC+PLLL3ngAfPnKzs7m7CwMMLCwlyu15w52+/PaDSydu1aBg0axPbt2ykqKiIjI4PSUltl+tVXX80DDzxgPY5ffPGF9XPjbs51dXXNOj7/ZrzioJd/HZ5WzMllKquV+JRafKfD8rgpi/GfYVW1x7K+RlPQxEgzl1MY/DOqIS8VV1WA0aoLVouxr6yBaP90wDzf5pwTfxburMSe8MXRLy7jbJpHq7SpGOXmH9i00DSntude8b2IVcWKxEE/uR8Agf6eBVlYeLXXq7y4/cWLn/AlYH9RnFudy22Hn4DRAHLmfGpk6leBTLt2DCaDD891i+CrgG/IfOcVfFo5phxbSApK4schn7DzwP3UGSR8XGoTcQLt2v+8dfVUjPJAsW23ZBAgwTfKef+a+vxRTGy3lDj/CiIVTo73ZRQfwfx6lt68hNVffUjxkeME1Tn/c0MoEBoNvZu1j6jkltz9+nt89+J/0TXYvqMtlXdG3wDajHqYFzcUWHvCPT0kCRTFfHziNev4PgfDCalVoNBL0ehDoGnN75K54YHxHF1Y75i6bIe/wbO77E93eowPG25DhYY0ST5zlB9Zlz2hnUi2KR41vk57DgqJDygSf0/aVV7LZSoHYRBApjTfMLO3Ervity8/Q3toFyGC126pQEwZNRGTrqjJbWgb/4Q1GY3sX7WUClkQJN7t0f4tzBvdlfgQPweh7PoL65EbtKyKuYFVMTc0a5tKD7/OFB4eKyGWKsKmKgiFLTTe6D1d9NvlKsglLSqAwMBoj+bh7mbGn9lb1cu/h76Jffn8yOfU6moxmAxWK7GlklAmkRGgCKBfYr+/ZD733XcfS5cupU2bNkRGRtKnTx9ycx1vYAAEBwdz9OhROnXqhF6vZ/HixQQGBorEwaioKD777DNGjBiBj48PgwYNIiAggJCQkGbNa86cOYwcOZKQkBAGDBjgUrCcNWsWzz77LBkZGUilUuRyOW+//Ta+vr6MHDkStVqNRCKhVatW3H///S7398EHH7BhwwaUSiUymYz33nuvWfMQ8swzzzBt2jS6dOmCQqEgLi6OVatW8fzzzzN69Gi++uorUlNTGTBgQJPr3HPPPZSVldG/v7nFhF6vZ+zYsXTu3JkZM2YwceJEpk+fTkZGBj179mzyuLgTB129vx06dOCdd96xhmQkJiYyf/5863q9evXimWeeITs7m/DwcKtQlpmZydChQ+nQoQOxsbH07t2bXbt2OexXLpczd+5cbrrpJsLDw61VmgBHjhzhueeew2QyodfrGT16NFdddZXL1zB69GjGjBnDkiVLePTRRx1er1wuZ8WKFUyaNIlZs2ZhMBiIiIhwKVy6wt2chSiVSn755Rf+85//MHnyZHx9ffnpp58ICAgQiYORkZF88cUX3HLLLdYgn/DGm+7u5tzc4/NvRmJyFhdzBamuriY4OJiqqiqCgppukO3Fy8UgFO2E1pv26TPxV6Uil6koIk5kJXaFK4uxp2Ehl0tUKyj4kRN/iKuvioilHl/8Gq1kLVq9RXx4t4vqmWhPdc1R9uwZbn3cvftSggI7XPJ2LxX7eblCON+6uhxq1eb+GPU1pWSftTXRP7cpgfoyOSajkvZX3waAVC6n240j8A8OuWzzPl52nFErRl227V0ppvWY5jQkZXa/2aSFpl20AKopGsqT19xAq6gI0kJTkCpLrXbtv7IPo33loP37NuNLA8b6OB7v/6T1uaUPZNCpTdOKk/DcvaCToDGBrwQiFSbR46G9lnBeKxXtV51j7rmiSpnrdNvqnMeZrapH1fV963Oxhx9EqY5DavQloldPgq5r+o95T3EmILnDBER36Mrdz72ATO7ZfUthvzunSCQoO/XjvSpbz6MVj19D/pn/MeXMdOtz/Xak4a8ORmk0VyAu9EBg2jilHwAni2tcBjzYs3BcD0L9lVZbbZPzb+ScbwJ1Ml/qZP5WGzHAlL3fkFRTQolfCNMzbZUz7SU5rPSZZn18Y8PrHDO5/o25vmQtaeUFdFQXEMcF9DEmKh+wVceHLPQh9Y0vUAZHI5fG8uP0qRRli5NulUFa0u867RBC4orR578lRFfpuEAiQd9xIB/XuL4ws24jb7G1wlIikRAaG0/H+yex47eVHMnOZ03kdU1uY+bIjrSODSa/sl70Po7K/xHAZWq0O6L0Eu6vbbpC86eO71AacL7JcfX55s+50F6sznnco8pVgJ8mpNAt1bFyz96GvXFKP1IiVNYK9kuxB1u24bUSe7Gg0WjIyckhJSVFZJd1x+nK09z/2/1UaasYlDSIN655g6lbp7I2dy3BymC+uuErUkNS/+SZNw/7ZFV31NTUEBhoDmlasmQJzz33HCdOeJZI7uXK0Jz3V4h9IrEXL38Wzr5rm6OveSsHvfyrENpgnQlZ/qpU6/O1NXUOy53hymL8Z1pVLVheT23NCafC4GSJXUhBNpB9otk9E53t88+shrwUmlsFaC/ixoY/JhqnKVdSX+qDRCpl/6qlmEwmZHIFbXtde1nFwf8v1RWu0pPzavOIDYhl3qB5hPiEUFhb2CxBz1CfytvL1YAayGXjlH6kR3h20Tlv0DzOVZ/j9V0Xl+zs7KJYeAEtZH9CKAZtIBKFLfn2+N5jyAJs4TeuEJ679tV9wsdymQqVQlxO2JRt1mTwIUijQvhtpVTH4VuTDIB/5yi36zeXnIP7mhS9hEiAkqP7yDm4j7RuPZsc75GwZjJRcuwAJNjEQZWPnFbtu4LgbVsROQJTiPm9Gl643OXmLEKS8H30JOBheMdVjL9mPB2TxJZXS6jKdy/9l6Lsk1TKg9FKFQ59CFtozAJSiVJcKaYyVpNWlY+fnY3a3jrclJU4VFeJTKmmrF5Oi1wpIO7zJz9voHTMyyT+9COfT5pAXZWjXUxbreT4t6nIlAYeDZ5HeI8q/ihrxQ+nbrGOefLkNzSYDNT4yx36LFqolAWx0ANhcETRcodt3PHSDNbO/wDtoV2EKpzb9+156qcjTp+3CMV/JvUFd1KvyhOJfs6EwHu7BxIe4MunAj3W05ASgPBg59+TQoux8Jy+HPZgryDo5XKQGpLKwqEL2ZS3iXvT70UhVfDWtW/R8XhH+iX2IyX4yrtVLoW5c+fy/fffYzAYCAoK4ptvvrnSU/Lixcu/HK846OVfgzMbrL2QJHwc0ERaVVPj/myrqrvKxCJiOY3ru6nN7Zlooboqiz37nCc8XUpwx+VE2IfRXWWoZX724mxhmVhQ1TeYm92ajEYkEglhcQnc/NRzRCT+My5+hMIWmG2xlQ2V1Ovr2Vvk2Bvwz8K+b19aaNMCgAipWKwXijLC4JfKhkoeWvuQddm8QfPoFdeL+ICL94raXxRvL9gu2oeQHwZVA9UE8K7V+vfcER0c2QrYqnOc4e7cbdfmHSrOa2mR3g1//xSSQBR2Y9RGoG7QsyuvHa+vPmgVCx+UQYrBjyRdFNGKC+QI9ic1mEUj/+4x5MuLUZddvkqflIyupHbL9LhyEImE1K49Scno6naYQa/n9L7dHNu0jjP7m26OFqKrZPT5b4lq35kbHhjfeOxTrZbn438UsiLUJq7UyVwLaa1jg60hRjmlamvftqaoJJy9xYXkN5i4NiFU9N0ok8u57ekXeXfSkyyMsdltRueZrTtCsdBesKoKkGMEYuvKmXL2NOd9iymX1rEmaiD9Gt5DhYbOZftJ1x7kbIxrO7HSqAOJhOJgFQeSoulYJ7b0SjUSGi7ksvih+6kzuO6Jpa02B7moUOMraxAJgwDnFUH4yqpdCoOW1+sJPnZ2a5PJxP7Vy6xi8cWIex/fnUH2yu8oOXbAOkdLMEyFIpQ1Ubbf2y4V+9gf6v5cbQpjQyRGhVjYNWqjHIT+nws+c1hXKB7O7PUt6tpQkS16QsevGZz5EuHBSW5vSLhb5rUHe/k7kBKcIhIBFVLFX9Jj8GJJTk72uKps6tSp1p59fydKSkq4/nrHPsCDBg3inXfeuQIz+usZNmwY586dEz0XGhrKxo0bm101CDBmzBhrwvFfxapVq5yeX88995w1adiLF3u84qCXfzSby2so1eqIUCroGxbodqyzUJCgwA7Wi3H7ireW/j5s79nO2nPw0RO2H4kP27WglcrXbc/B5opU7nAW/OGs4rCIWA7Tka8kzoULC572TLQn59AOj8ZdrsCVi8XVMRVWhrqqgBQSu/8x5Ao5+1iLqbGa5q7p7+IrSPS6XLhLKL4U3FV72PcABLOY6Cf3Y9LGSX/KfMD8WtPD01lxywqOlB4RWddcYhQnmdqnbgoFLWcJ0Z4e3zf7vEmYb5hI/BNeFOdW57oUBu2RyBow2WkUTVWauTp39/76O6e2ZJPaLZubn3wWmVzuQsRrg1Fj6xPXQ6eiDY03MOpiSNk6A6NMg9Tgi7IuBkV8ANUD5NwssHs7C11pLpaquGXvvdko4rkRCBuFQcvrcoVBr2fZzDc4s8+DxAQBIbpKtIc2cXRhPcmPTaZ+xw5I70Lv256n4OtvQaDvFfm4FtEs59yZokoGzN7m8f43H+nJ5iMmoJAne7/EhOveF73PDb//TvTZGhCE+54MCWVP5FXWyrDReYuJ8r/A+Nov0Oh9kdSAwVfH/uQY5Kqh6GTZRNafwdRYXWjpLdihfi+BiAXMoUW/Ea6rcKxSbBQIIYaOLxWBrwmpRoL0goQDSdGU6xvAg/RAg1bmtPfgjyk3A2I7sD2einqBwTW0SEik961PsHnR5xRknaDmQolVkBYmPmukviyNvbnJbbaNC+H6p59gzbtzKDx+AkwmLK3Ky5FyFnO1bh0Qrr88AVD2QqDl/a7NnoLMT1xV6IpwHwOx/uLfpMGZLzm1EjcH4U0Xrz3Yi5d/D1FRUW5Tav8NLFu27EpP4ZIZOnQoQ4c6L+jw4sUVXnHQyz+WzeU1jDpkE3a+75TqVCD0xAbrqleeK+GslcqXqwL9nS4T4olI1RT2FYIZnRagUIZSUS620zm1EbtAKHQ6sxhbgljsxcOzB44S0LHp7f+ZwR3NwVVlqKf9IPWqC8TFtUUaeDW1lUZ8pSoKfz1M4o1dkIc1L/XTFa7sqZeLQnWhyws7Z5UgHSM8eIMvEct+m3OxaTL4MHtUBmlRTdtzPX2tzugY0dHtRXGzRFypY2sCe1HTFfbnbu7h44CS0/t2sXzWDJdCmv327b+llHUxosfh97TjpFF87h3OL8aojSDav+SS0shlcjlt+zzA2SOlGHVncCoQNkMYXD5rRrOFQSsmE6f37mTv449Se+AU4wdZ2jAki4YdCXb/vWzS6Tjz+tugal54ioVqQ6Do5klOqZrta/fzuqBnoERRyvEem1GxGWgMnwiE9Dtsv2HHv01FW62kJFiFRJaFSW+u9rMX15wl7eqlCsoUZtkr3GgnckkkFIcEkFChIvpCHUZgbes2FAYFozTp3Vb9AWZrtEZBzdoAcHG/zlId6MxGbRX1ZEoUrbuxqDbZut7Uoe3oEq/h5PGx1qCUkIT/MurlGexd/itypZJOg4Zae10K5+qqAtDeKq4rradjZQ86xvVwmPedgn/PT+gIjqHYzcYiBEpkDSKLsEkXgaf1/ZJ6Bapw8WfHlZW4uXgFQS9evHjx4uXfg1cc9PKPpVSrc/sY3ItAzbHB2luHPbUcW3BnX24K+yq8g4fGOB2XR0Kz5mTB3mJ8pq5BFMQyp+Q40Q1mkePM7mzkR1NR+Elo3acdpnBbf67mVkP+FQirN5uqunTGhTa2qo3WW99EoY5CckxP0bE9+HePIXREKhKZ1Om6njRkv9SEYk+wVAA6qwaziGDZldlgMicNW8ZYxDH7pvSXwpt93rSKb8I5zBs0z2k13qPtX+TtFRXWi+a0qACrrbO5CAU/V432KxsqUevU5FbnOhwrVyLuHW3u4IesH6yPb066h+W55r5BqqTPqc2ewqxbB3okagr3o1Ko6NH9f2z86gNyDx9HW2W2bGIyuRUIhX3E9JvOE3G03HnRngTKuxipNp1xeE1P/roGo/YgT2V8Rrsgc7rixbYKOHOwDIXqJhSyNdSW/yG2GDsRBk06HbVbthDQpw8ShVlEEoWbXCwSCXEKXwK37eRCUNxFbaJWreH8S8/ArsMw8OLEwSBZDVRrKfn0PXI1Um6vaQ2q7uKpyhocHlf4hLC/2CzcxwcUmdOBTSaUegNaUxFIzKEgscoixlZ8RVFDlMukXaE4BnaVfCYT0VVqIqttwuDs9AnOx9pRKQ/2KMzlvG8cNbIA0dyE2w0xVJOa0ZOUUXex6CNbtXqv1HBaBOVRlWurjNUb1EilMnoMt1myb37yWYcwHFdzFlrFAc4X1+KJsXlHQyz2vRkvFpMuwqHC2PL804mPUn64nrzaUtYk/h975x0YRZm/8c9sy2Z303sCCaH3Lk1AEMUuKnoqKufdqYcdBX8KNjwbniCcYMHuCXqKeqiIpxRRivTeQwihpffN7mbb/P7Y7OzMtmwAvVP3+SeZmXfemXlndnfmmef5Pj4ly5iCW2hryOOC63rTp1M3gKD1A6OI4reCYL8NUUQRRRRRnF1EycEofnXwWok31SkJHu90qk5LW73OQ3rZWq4HBS2TRXKLcWutuKAkqRz2Go+S0VIU9mE7EtsreBSDx2nDXOGRsO1CocahJAf9ycLt69aQVnYcQRBAELDX63CYVRxcvYfO433tWqOG/CXhP8aiy415RSW0kmMS1U2oBB8pbNniUeokj+8U0Naf9Atl04xUhTZ39FyyjFl8VfjVadcIDLWtULbbn0sxEox8G5Y9LChB2DGpPW6bZ5wFbSWltsPE1aee9r6FK7Rv1BoV6b/ycxaOxJUTg4BEDHohqJsiJjX9tzO56lJqNxWCqFM2jIAgBBBviKNmSSGWzR7yCEHwkCWihxi8yXIPLA3cD6+VcUEdPBorkKYVFd+RTruLHSuP03dMWzQ65YsSS72dnSuP4XJ5SJlje6sRBDUuLiIxS03tqb2ACIJAXm57Lr9nioIYPDH5AcwrV2IaM4Y2c+fgFoRWpR6HQrJKS+8te1GJYkCAR6RoePEFNKtWkSOKvLV8Jo2aGJZ17su3OaMjWv8icTntirqiztdR/f4/2ZXcCYZ0lpYL2koEdZMUNuGFSlfON0l9EPcNkpRlf4j/jExVA9jqoN6XFgzQhaN8/8mQiI9LqvPXTAz2Ky4DYFteBiXxCcHbhuunBcgTlwPWlRHGx2qV50l0HsHSqKwBFSwIy2tpD3bd6ESlrV+utC2qbOSvH2zhHc6sbIS9Zed1xO36dRhMp8E9mfnEh9DWNz/RmsHd065Bb/SNeZQQjOK3imC/DVGCMIooooji7CNKDkbxPw95vb3NtlSFlViO909V8f6pqoD5s8kik5Kw24hEyXe66b5eGAz5WCxFbN45TpoXSo0Tqe21NVbiUEjSeh7uvVZibz1CL7pOeoATn/wT26njJNV5xld0u3E5lIq5/xUrcUuoWVKIe4ua/FhP7TVL0n4qurZc18kb3iBBBMvmUuJHtw2wGPsTbaGIuYgLvIuccc0nrzrMv5+WiMyzWYRertbz305iTGJA+05pqXw/tSuHa4p4cP0jPLA2+Lr+aEm1GazQfrhzdib1IFW68ohJTf/tFB7YToo/MehFCwQhgKBWkTy+E/Gj22LZXo7LbEcdp8PQN5391oOwouX9LzJn4Na5FCTM8d2xbPziCHHJeroMVtqUG+ua2LnyOC6nCAKelwoAqLFax6DSWnE7CslUxdDty+8oaXTRZu4cAM/D36pVANSvWsVPk+6grFM7juzYckbEYIygYuD2A6ia+8hprOSt5TOxamI4Fp/BiwN8arcLHRaWa31m7GfaZ9L7glzML71I0sql0n7kNFayM6ONRAxmmyuIdTbRq25PgDV5VMd1xO2rxtUIh49Cj2GNCO98yNOfHpXaCNpKTB1nBd1/ed05b8jNJ+J4MMJzY5+m6ss41Dqlik2vsfl3ExI12iQQRbLq6+hXXIYK2JHRhj3pOZ5l/m0hIFHZO+904elXICUtj7T219FkcUsq2Kq6Yg7t+zPlhRWU+60XygEQiiDsmpfOd3cNxY46QGEXSfJ0JKhVi+x0/MiOpEBrshd2wdNuwS0DOFZl4dllPrX+Hzr/m67JBejVTXRI+4hTh2rR+tUm1LpiKDlcS36fNP+uo4jiNwWJGGz+bTCvWsWJyQ9ECcIooogiip8BUXIwiv9pWCxF/HvDLVjRE4sNVce3W91Hp17v0VVvO+NQkLOBYKEokbQrJUsaAznRaeXM694VNNo4abPzpz1Hgy5/pMwC53ksW7d9NEciCO31MfTv/SXqGDFgDIMFqPjjiKWJysbj6LHS0WiK+BzI+9bZsnykh0mHoV962FqAziqrR0WFr/aaQx9IKHuRtesOdI3ZUnhDAASwbC8nfkwuENp6GoqYk9t6wwWATF7tWfbo4EdDtmkJoYi5lojMcEnAcjw/4vmA7YSDdzuhxmzKwCkegk8HOcmqoOsGQySqTf9jaumcnQlBGpvzMQ+s/Tjkvnj3Odg+1BrtIIponSriLUEegiIgCAE0yXrpGpVWLYnsZccbO+5AdKTyHE9Ldd6aCucDMRRuKw8gB9PaxnHd9HP4zxt7qCuzILo9pIzoFlEJatLyr6HdsXdI2rQZFc0Pevfdjwg0rl4Noif6Z1tuOuXmCthewZkgRlBx3s7DaJr7rYg3kFZvIaexMmj7QeYGlif5yMHMwlpM38xDe2BTAEEZa/NMZ5sreHvFC7Ilfqzr6uY/3XLJGjYCVftU9p0qR9BWSkpAfytxKPiH3Jw0Z9Kug5OGBiVRl51Qzm11nvCScnt6gJVYDvmynidn4gamDZ3cYlt/i3G2UcU3d53DioXvs6GolnUpwyI6Jv9+natP0HFAOqcObSe/7wBSYtwKK3Eo+P9uKgjCLRswJCRRevgQ+z58VfF5aU3ydMTHk3YOYUN4mpFt0pKTmKKY94fzHqRzulv6/TyyfR+JtnTuq5pJ1wvS2L+iAoctlsNbS3E5jpDfd0DYep1RRPFrhYIY9H7/iuLvjiBcunQps2bNYvXq1WHbvffeeyxZsoQlS5b8Ivv1v4RIx+h/Ge3atWPJkiX07dv3tNY/evQo//nPf5g0adLZ3bGfGXv27OHyyy/n6NGjZ7XfGTNmUFtby9y5c0+7j7lz53LDDTeQmRnkGbAVeOKJJ+jSpQs33XTTGfXzSyB6NxHF/zQON5oVyrjnnZGrIbw47kpGjx7Uyhv1X9IGG0koipwck6vw/NWBs8V7JIIwltaPhz/k4SQtwa71qZhEUaTqqJmOAwcr2virHrub38FozFcQd/51DWeLt3D1kA8AwpKK/n3nr52Jzpop2SXrlxeHrQVo2VHhsVdGKELSNWajb2gXuoEg4DLbgfDW03CKubz4vIiVaWmxZ0cl4rX2Rkpkev/uq9oXsk+vNTdSGLXGsGM2e8ts6f8pA6e0uI9eRKrazIvPo7i+WGEllsP/nJ2NGozB9iXcGKzp6yOur1mdHZog3LKBoh1bAz6LweBVCDcI6VRnvYjQ0ID+4EGFOs168nrc9nRFQII8fbb0aBmQS/GeKtZ+WgCAWi3QZ0wuhngdKdkmxj80gLenrkFwu0ip3ktVcg8QYET5p1g2bVY+6H3/vdS3G9iel0F5wpkrVmMQFMTg9rwMyhJNZNSaJYWcv8XYsG8JnOsjwNU7/0XTUWXa8kljKlZNDCfi0iFIH6HQrnMPuvzlRsZ9dRUApo4+JaB/am0o+Ld7Zeft3N3nTXJMStVe3phT5HEKoFUWY3HocHacjCwcSW4FzuzQiWum/Y1vX5uLfddG2mhTwq8cBsNu6cQ3r7xI1bFddBg4hDGTbgjZtqwxDZsrBr26Kah6Xa3RcOm9U1n89HRKCz3XqpxQP3iigUtfXy+170zwGrI/FxpefIHMx6Yr5qUk5BEf5wvPSsorYVC2ngEXjkalEji3p8i2b4vY9/3b7Pp2Jx0GDmkx0CeKKH5tCEoMSgt/fwRhFFG0hKNHj/L666//6sjB/2XMnTuXUaNGnTE5+Le//e0s7dHPj+idRBT/cyiuL6aqoYAYlUiVzQlkScvaCad4t1MOte4YfmyI4d/ltS32Jye/5Bbj07HBRqKIC7ZOa0NR5DUKt1Yeh6O+dazo6dXrNZpsZVAwg9niPWdUc7A1aNs2l/H3T+GHhW9z6uB+CjauCyAknHal+qJx73Fc9SoFcedf17CQDuytPkL9oTukecEs1/7KELfa5nlml904hqsF6DLbJSLRbijFrbYhhlHsBFiJ/SGKqE0ewjRSgi9Yu9qm2ojW7ZjUUSKp1pxYw/wdp2cpr22qjYgUW3DhAhJjEqltqiUxJpFNpaGTYksaS+iY6Nm/wzWHQQCr0xo0+MNL6oUjG+WQE4X+++glW1ur2oTWnbPuKd0jahsOwcjTSPfBoQkRftBcoy2/74AW+/An5dFmIsSk4rYrE2vd9nTcthzFPL3sc+JyeD4Xogg7Vx4HEdQagY4DMzDEez4PpwpqEVwueu59C7vtFE31B9C57BSZd5EmikEpGInASzB6PqdnAH2Mno57yzgan02Ms4myVLVEOJYlGNmel0G/4jKFxTjW2UROYyVvLH+B0rbdyEvsSfrRtYp+TxpTZUnHrcPwG25h/d6tinlXidVoO63hk4KrpdRala68RbJWjld2egJDnjvXp+5UjEUrLMZHcxJpqIns1tBrI27f/xwuu+//WDZvlmThPROL8Y5//xPXsV2Ah8jjdRgz6VtElA6AssY0pq97XFpv6NB08v3iuV1OJ8vmzfIQgzJCunDrRj6Y9gS51/x8D1HjSr5C77Lichr4tJ3vBcBDWxaR21BOrLOJJEsVWtHCqsefweISFFZnxb2DFmw2z2+i6HZxYs+HVMjGqCX1cBRR/JoQlhiUGp09gvDbb79l2rRpOJ1OkpKSeO2119Bqtdx6662YzWbcbjfjxo3jmWeeYcaMGezbtw+r1crBgwfp3LkzM2fOZMqUKRQVFTFgwAAWLVqESqXi1ltvpW/fvkyePBmAqVOnYjKZmDFjBjNmzGD//v1YLBYKCwvJzMzk008/JTk5GYfDwf3338/y5ctJSkpixIgR0r6WlpZy4403Ul9fj81mY/To0bz88suoVIG/qh988AHz58/H4XBgMpmYN28effr0YcOGDdx99924XC6cTid33303d955Z6vGp3v37hQUFPwqx+iFF15g4cKFqFQqYmNjWbVqFQaDIeR47d69mzvvvBOLxYLNZmPChAk89thjADgcDh5//HFWrVqF3W6nc+fOLFiwgKSkpIBx9OKnn37ioYceoqGhAVEUefrppxk3bpyizUsvvcRHH32Ew+FAq9Xy8ssvM3ToUD799FPeeOMNvvvuOwBcLhft27fnm2++YdKkSRQXF9O3b19yc3P58ssv2bJlC/fddx9msxm9Xs+cOXM499xzqaio4KabbqKkpARBEBgwYADvvvsu7733HgsXLiQtLY2dO3eSmJjIW2+9xaOPPsqBAwdo27Ytn3/+uXSO5Mq8+fPns2XLFt577z1FP3v27CEmJoZPPvmE9u3bAx5V36JFi4iPj+eSS3zhZE6nk8suu4yqqiqsVit9+vThzTffxGgM/cxeV1fHlClT2LBhA2q1mgEDBvDOO+8o2oQ6hzabjXbt2rF582batvUU9p0+fToulwuj0cipU6e4/vrriY2N5b333qNjx47cd999bNrkeR667rrrePLJJwEYNWoUAwcOZOPGjZw6dYoLL7yQ119/HUBxna9cuVLatt1u58EHH+Qvf/mL1C4mJobDhw9z/Phxevbsyb/+9S90Ol3Y9c4moncRUfxPwV9Fc3FmD9D5HsQ+L1pFDsdpywny277Z6v69FuPTsRL7k3yRpndGmowbaCXOxoyLk4IbeSriKdqwx+zCqE4GIJOSs2IvBnhAnEkTel4VJkvzXumWi2vHRnQOO1f+33RUKjXXz5jJl0s+wGLVseGrNXQ35EF3K5gclK9ZD7LvcHvsSXCLqFx6ju0TsGpLKemtLHL/qvAArxbAI/QmjQqs6ElrNNO7+UEvlPLSbvQoYxS23zC1ANUmnUQMFg0/C2SqCIZ+HvVQpKo5/3bF9cUKq+7N3W5WhI74E2rF9cWeBX7cyZUdruTLwi9pCV7CLxKEshAHgzwVeUzeGCBQadg+ob2CZDsb9Qy9KsjTUW2ezjlr7T5PGTiFQZmDIq5/GApaZxA6LUjabzj4k/IAolFDU79sjLWyec3qtNt7/ZMsYyl6dRPndHyAbV+7qS8De4PnmhfdIoIACZkGLvpzV2IKNiNmepIkj2wpoefet2iylXC7jEy75XgTXSpPSso9L86IGBRFxTrp+R0ZdOd0Lnpts2+7xxaR6Kr3TAiCgiDMslRTldyDlPq9uIHyVBUVMSdR1ZSSntELyvbgVQ5aNadfe/bfi+ezwVoIfX3z1IYSkhL3I2hHhEytDUbWBoMthPowoamBW2o+pKq5XqBTpVXYeB8eaGDYoD7UFB5g6+trSMRjGbartNRokxRtx5avIMlRo6g52G34aAUxCJ504FuOf0hpTBrL0y9scd+HWzXkOyAteQuOgg2+Bc1EHq97UojDHW+9pQn5j48i5TqI8qjq2C5qv/wn0K/F/WstLi39hlzrcTLqGomr1fBpO9+y3IZyOtadlKbNq1Zh4jF6+BEcwcqQBD2mCMsLRBHFrwEREYNS4zMnCMvLy5kwYQKrV6+mV69eLFq0iGuvvZYLL7yQyy+/nGnTPPcQ1dXV0jpbtmxh69atJCYmMmrUKG677TaWL19ObGwsAwcO5JtvvuGyyy5rcdsbN25k69atpKSkcMMNN7BgwQKmTZvGG2+8wcGDB9m7dy8AF110kbROYmIiX331FSaTCZfLxbhx4/jkk0+44QalwnrdunV89NFH/Pjjj8TExLBmzRomTJjA3r17ef7555k6dSo33ngjADU1yheEkYzP3r17mT9//q9ujN5//30+++wz1q5dS0JCAjU1NcTExIQdr3bt2rFy5UpiYmKwWq0MGzaMCy64gCFDhvDiiy9iNBolsujpp5/mscce45VXXgl6PNXV1Vx11VV8+umnjBgxArfbTW1tbUC7W265hQcf9LwI27BhA7feeisHDhzg6quvZurUqRw8eJAuXbrw5Zdf0rFjR7p3787rr7/O5MmT2bFjBwB2u51rrrmGN998k4suuoi1a9cyfvx4Dh8+zMKFC8nPz5dIRvm527x5M7t37yY3N5dbbrmFK664gvXr15ORkcHll1/O+++/z913393iudu8eTM7duwgPz+fRx55hBdeeIEFCxbw9ddfs3jxYrZu3UpcXBy33HKLtI5arebDDz8kJSUFURS56667mDdvHo88EvqZbfLkycTGxrJr1y5UKhUVFYEvScOdw7/85S+89tprPPfcczQ1NfHuu++yYcMG8vLyeOedd/j4448lq/fDDz9MU1MTu3btwmq1Mnz4cLp27cr113sEF4WFhXz//fc4HA66d+/OTz/9xNChQxX70r9/f9auXYtaraa6upp+/fpx0UUX0aZNGwB27NjB999/T0xMDCNHjuSzzz7jxhtvbHG9s4XoHUQUvzi8trZgqb/+KpqPUP7YLRZ8Xv0/WFufOJlqbEt8BMEizmpbQC07pzayeoH+iFShqFEbKaps5GCdhTKXk4dPlgVt96owmVePev5/hN6YaOAUgV8MQ8Uf+Ek4T5qeIL5HIjXEZPyROeXJQftuw4kAorGTUU/vi31vdUSXm01L1zEpqS80vxhbtHslCM94JvwOt6T3G4CfPboouApqpvCkb2KPi+967iZHVcuOnbcGbe/tG5otxl6C0K8WIHjOqdviALFZcRgBtF31sJ3gNmQBDAMzJQJSXsfO33rqT/DJ4X/N90jtoZiWE2rhSDA5MThl4JQAtd3zI56nV2ovJcH4M0B+PMGCP+QIN2bBjiEYgoWJRLJvLW1/xI4Ueub257K/3B+0TqS3XmFiTGJYq/GgzEFhVYfh9uHausE07TmG1iEEWopbSQwCmNTqoPNd8W2ojvVYjLU7LJI6LctYSl78CQAy2vRg3J1deHvqGsW6InDN5N5UPvp/VDQnSea8+HeyvvsHQvVuCuOzFe3tKq2CmFNxZsRgTUIKdo0OndPuqYcqigy4/BqOHrEot6vWgZwbbSYIt7XLRGu8nKq0fqRUbMfRuJTyeM9bibIYJ1sToV+NCZW9AYjcQhwMnyZspKiL8vi+zfkGzGDqOCukxficil1sjFOSg95kY7maUK7uLF6Zja1Wh8uuptySJhGDKY6agFTho1+8T+aR9lx23/9Ru2UIhVs3BoSNeJHkqCHd3lyvURTJUMew5avPKCsqDHiQD9VHMGTrNSRXfYmjKkjgmChSuGUjS158jgsmXS9ZiUsalTafxf/8CCbeSLwhhtzEmBZTrms1CdhPHGZcpzS+sHh+Qy1BWwaipXYp9mop+bnEqFR7BlxDfgSH1XEi6Mswc/0hVr//FscL9rU6wTyKKH4tMK9Zg3nlyshXEEXMK1diXrOGuPPPb/X2Nm7cSK9evejVqxcAN910E3fffTf9+/fnqaeewmw2c95553HBBbKXJGPHSsqw/v37ExMTQ1xcHAD9+vWjoKAgom1ffPHFpKR4SjAMHTqU3bt3A7By5UomTpyITuf5nP/5z3/m7bc9NdfdbjcPP/wwa9euRRRFysvL6dmzZwA5+MUXX7Bz504GD/a5e6qrq7FarYwePZqnn36agoICzj//fIYPH97q8Tl58iQjR47koYce+lWN0dKlS5k0aRIJCR6Rgncfw42X1WrlrrvuYseOHahUKo4fP86OHTsYMmQIS5Ysoa6ujs8++wzwEHLt2rULeTw//fQTXbp0kZSOKpWK5OTAZ7Lt27fz7LPPUlVVhUaj4eDBg1itVmJjY7nrrrt45ZVXePnll3nllVe45557gm7r4MGDqFQqiTgdPnw4GRkZ0r7PmTOHKVOmMHLkSC6++GJpvaFDh5Kb63l+GjhwIA6Hg4yMDADOOeeciM/d0KFDyc/Pl/6fN28e4Dl3f/jDH4iPjwfgr3/9K2vXelwaoigyZ84cvv76a5xOJ3V1dQwbFr5+8dKlS9m4caOkDE1LCyzBFO4c3nXXXQwaNIgnn3ySxYsXM2jQIPLyggcIrlixgtmzZ6NSqTAajUycOJHly5dL5OD111+PRqNBo9HQt29fCgsLA8jBqqoq/vKXv3Do0CE0Gg1VVVXs2bNHIvmuvvpqDAbPfeigQYMoLCyMaL2zhejdQxS/KPxtbesHd6O9ISakJVDt8LxdFwU9Lq3yQeCT0DkSCrzUIZaeSW2DkpH+EF1uapYUekIrBEAQsMeW4N5gg94WBfEVql6gP+QW4XChKGWWdEbPWi0tE4ZnIBrDf0QVZJof5MQgwIfCrZ5//OMeZThOG39BGmrHKaCjNF2zpJCqE2XQO16aVx9jJZ7wOB1146bdD5BPUURtFYSfrBag/JzajaW442y4tJEVnk++pAdNapfiekAUPYrBgR6LtByh0mj9FXMQOoSi0qoMSpATapGSYKmxgdbDXqmeG7uVxStBCE2+/bnnn+mU1IlKa2VE5Jw/5PsrJ75CKedCjdmgzEFhSbPxN9xPnD6evPg81p9aH7SPcPsm335jbQ3bfvpKMT/RrKVpyxGKUpZTBKg0GgZedhWGhMRWpUZHogwM1d/4G+7n8PtfeAgOOUN9GsQgeBLX1w/uJqWSy0suvNx7EMYmN5M2b5TmyckmjdrIqUO1iG4XbsdRVNp2CIIaweXi2D334966DvCooA6PvYgSK1jjsylursvnhTfttjbFc2Peq7iMzR2yqTPqwxKDung7ap0Ll12Nvd7zMFCTkMJbNz4gtbntozkIZgeL3ltGjX4kmJTbbYy1IaiaSG6yeMhWQaA83ohKW4zG3YMSfTFutdGnyhUEymKcbM8y0K+4AXeaSJq+nHmlz1JxlZaSxkze3D0x4vFvCXf0fQOjKwGTrhELsVSsNkKdjnjLUVIav2FZpucljX+y8XnrepCpcygsxbZaHdbKWGo1CXzQdoJiO+NKlNe6zu3gyNZNfP3y31u0B0vTokhqXSM1Bhf2I4dDHpNXQWhXaanRJfNd2pig7eyVa3E7ghCDEkSO7tjE/GklvJn4eNAWC83tWPjqT7RBxb2mIzQeOkqSNj2gncNt5wRu37jImL4TuLkBM1538tMjOtGvbybbj9Xw+Bd7pOYnCGHzB86tWkecxUl6pQsVBLWuBx6ehyAsuOtajt+4J2i/+w8+hLE7dO8O+z7qIH0O5H1ECcIofu0wjRiBacyYyJSDAIKA6fzzMclspWcDY8aMYezYsSxfvpz58+czd+5cli1bBoBe77ufVavVAdNOpyf5XKPR4JIp9m02GyaT74cp1Hr+EGS/jS+99BLl5eVs3LgRvV7Pgw8+iM0W+MJbFEX++Mc/8txzzwUsmzx5MuPGjWPFihVMnz6dnj178uqrr7Y4Jv4YP348w4YN+9WOkRzhxuvee+8lNTWV7du3o9FouOaaa6T+RFFk3rx5jB07Nmz/rYFX8ff9999zzjnnUF9fT0JCAk1NTcTGxnL77bfTvXt3Jk6cyOHDh7nyyisj7ts7TkOHDmXHjh2sWLGCzz//nMcff5zt27cDZ3bu5Didc/fhhx+yatUqfvjhB+Lj43n55ZdZ1ZxUfiaYPn16yHOYk5PDyJEj+fjjj3nttddaVR9Q8LtvjeSYJ02axKWXXspnn32GIAj0799fMXah+mhpvbOF6J1DFL8o/G1tZpcrrBoqvup16f/qrBcDCMJIkK+z0zvO0HJDPMSXt2YdIthjSyg6N7iUOVS9wGAItUweitJY46eycIV++Pi5IK9bOFmcSVtO0FbrOwe7ju7j+PG9FCZaFesdNamIIz8gTVmO0wlP8Soiw/XrhaI+oFtEZfSoY7zn1G4oVZzLNlumonaYsJtOUdLLp0Ds3nUWxrhOEulrHA/xo9v6lKRxOgx9w6cit6SYizSIY8GFC07LBpusV76FXHDhAoCQ25TjnT3vtNjGH+Gss97p4vpiiZjsmNgxoF2wMfO2cft9bzTtOcbh97+QbIbhbNLhVJteNNbWULj6R5C9PNc6VYhuN9uWfYEoiqg1WroOG4khIXBb/vvutW6H22Yw+PcTp4/3pa16FVCnSQx6EeoFSSejnt6ZBr6fOooqcxPfHyhn7Dnv4dz5E3EDh2Mw5FO4dTeOxqW4HYW06T4AdcxFpH/1D1xVuxG85KUocsxKyLp8irRbFlFlisWpCa5o9EIXb6f7jT7iyEuMyAOSAKp0SXyT67WwKh8ql+f0xdTRlyIsBbwI4HYewV73NmANsOt7FYa7+iaTfofnt8FAGZGf1ciRbyojTVsqTasccVibFaMpDp/tyz/ZOF6sIqFJueMuu2dM/VWCAA5BIxF2cnvwka2bWDZvFpfeO5VlL/+dwq2bFOSe1FYUSatrxK5RY9e1fA2GUhD+bVwPnvjCYwlbkjaQW2yHWlQb1jdaITH08jao+BcmMPeG7N4h2/2zdHHIZXLib8/xBgZf1pHBOSYWdErmuz2neP4/h8Lu47qUc1mXci50hbeWzySnsTJkOrYCooj16IGW2wFqXWCJAG8fUYIwil8zBK2WNnPnRGYtbiYGz6Tm4JAhQ9i9ezd79uyR6nvl5ORgtVrp0KEDEydOZNCgQS2ql4KhY8eOkt20qqqKZcuWMXFiyy+ULrjgAhYuXMiECRMQRZF3331XWlZTU0NmZiZ6vZ7S0lIWL17M+PHjA/q48soruemmm5g0aRK5ubm43W62bdvGwIEDJUvq7bffTtu2bZk+fXrA+i2NT05ODgUFBb+6MbryyiuZN28e48ePJyEhgdraWuLi4sKOV01NDd26dZMUfMuXL2fkyJEAXHXVVcyZM4fhw4djMBiwWCwUFRXRo0ePoPs9bNgwCgoKWLNmjcJWLFcPemvKedV7XsWdF0lJSYwbN46rr76au+66C3WzKyQ+Pp66Ot9vaJcuXXC73SxfvpwLL7yQ9evXU1paSt++fSkqKiInJ4c//OEPXHzxxaSnp2M2Ryac8KJjx458/fXXuFwumpqa+Oyzz+jSpUuL611wwQX83//9Hw8++CAmk4k33vA9g9XU1JCamkp8fDwNDQ2899570jiEwpVXXsmsWbOYP3++ZCv2Vw+GO4cA999/P9dddx0mk0mhgPUf0wsuuIC3336b8847D4vFwgcffMDDDz/c4jH770teXh6CIPDjjz+yc+fOn3W91iJ61xDFLwKvlbigUUkQFTTa0NgjkwAK4umx4/G62IjaOausHoWYDJHaT1tjMS4lCyt6YrEprMSHyhsUbQWz503BMNWPrDMFDzT5OSHgqWfotUXvrT7M2CI79AkM+nghewjgScT8x9HFpOb9S1r2QaUOiy2OSlUNScJUDPp8Tia3XKsCUNQ+XJBXQ7xg41TRsxJRmLXrDnSN2cqag81wlFsU59T/XKodpqBJxMa4TgEp1ppkvcKi3BJaUsxFqgD0J73y4vN47eLPqWpqoKrxGHM2BSpo5o6ay7DsYQHbjzT843TQknU2GBkaLLVZbtf11hJsY8hh48KFIAs/1ToECrdu5L2XH2XwzTdz1BzaJh1MtemP9HbtufuJV4mb/wSVNSWSjVfEjSAIJGe34YoHp5HaNjQlNHfU3JDEZ6QIdd1IBOGWDWdEDMrhbzH2TuenGlm2u4TXVx1i8Lufk7ZzI44xW4mZ9SIlB/+F2+FRup7Yv41szT6Sq/f6iMFmRFqXz67W4fSmivvVDZTDnwipTU6iQRdPVZJSFVabnhLS7+lPqAUGvFgJCUGgJlmPvwZNHybMKBhG7kihTaagSKG+ObmJDK0bvQBpWuU4egk+L0bXfUaJIZnD8YmK+ccS9TQ0aKj7dx7JbsFnJY5NoloXaFdalnkJ51X8QK7tZAAZV7h1I8te/jt9ikox1zVSFm9QthFF0us83191xtapwXWi8g16Rrxy/WBEZkAfLQSdRPYaEIwBLHBwZOfESf/npxpplxYXpnUg/D8L3qTrUApClS2y/fK/NhRoZYJ5FFH8ryEigvAsEIPgsSAuWrSIiRMnSoEbixcv5tNPP2XhwoXodDrcbrcULNAa3HHHHVx77bV069aN9u3bM2RIZMnxt99+O3v27KF79+5S2MbWrZ4wq/vvv59rr72WHj16kJ2drSAy5BgxYgR///vfufrqq3E6ndjtdi677DIGDhzI/PnzWbVqFTqdDrVazezZoV0iocZHEIRf5RjdcsstnDp1imHDhqHRaDAajaxYsSLseD322GPccsstvP/++3To0IHzZfZ1bw26wYMHSyqyhx9+OCQ5mJSUxL///W+mTJlCQ0MDKpWKp59+miuuuEJqEx8fzzPPPMOgQYNITU0NsIx7j/+9997j9ttvl+b17t2bHj160LNnT9q3b8+XX37J559/zn333ceUKVPQ6/V8+umnmEwmFi9ezEsvvSQp01588UXJah0prrnmGhYvXky3bt1o06YN/fr1w2JpuTjHpZdeyqZNm+jfv39AIMnEiRP54osv6NKlC2lpaYwYMYLi4vClkObMmcMDDzxAr1690Gq1nHPOObz5pjKXINw5BA8JnpCQwF//+leFGvC+++7j9ttvx2Aw8N577/H4449z3333STb76667jj/84Q8tHrMcM2fO5K677uLpp5+mb9++Civ7z7FeayGIYiSa7V8OXulsXV2d5EWP4tcJLyFY43Bx/c7QdiG1o5Tkkoda7K8l5eBd4lyyOUEsNjp2nIZbl0u8LpYeyR1DriNH/cpj1K8oVghO5MEVclLPX8UWaTiJv636k455THylZUtkUwiL8QTxXdIpw+4XIvJwfiaNjQXML/c9yHjHp4pU5kSQbDw5W+Bcgxm9YCMvxsU+q4YbCoPXKpTjnuMfMLTNEml6Vqmek3Y1oiDi1GTg1OTQkP5A6A4iwGzxHjIpIe+nGUEJPi9Mw3Oo3r4Vt8qG3XhKUaPQSyy6dGZODPBZ9OTn0mv9ba0CrCWEUw7K4U+gya8fnWULCZX/CFgnWIBJMGvu2cS/xr5EfkJHDIb8oDVF91XtC0hHnjtqrhRcIof/2EyuupRje3by+Xm+Av7XrPbUsft81KkW923BhQsYlh3Z22yb2cyrt92I/GdREATueusj9DKbS7j99T9nZwsup5OiHVvJ7zsAtUYTMH068J4ro+gmfcsmTCNG0OgWGP7sd9z74zsMKd2HChG3ILBzQHdKHH4vS0RRqqsmDxc5bkzljggSfW85/mEA8SQnCL1WYn2inbwxnnOtqF3qB6HRScxaZa1Wb20+/wTgETtSSDRr0TpVgfUcg8BfvehFWWMalKnpN6s6yFpKrO7aluNpIl8N972EmlBsYtBwX60Hea1Ar220VpPAwvZjFVbiULhmdTZue2qAlTgUAs5BMzJqzfQpLmOnvBakjBgsb219yGbFa89b7qWg3ExZUSHxOe148NPdUpNgYSdy1GoSsKu02FR69G5bQFgKwDV1e3kwYWjAuv747uR7FLlt2FVaavVd+DYlUGX4wV8GMaKTR31QVNlIY5OTw+VmJn+8I+LD9ioHITDpWr5MDmeaiFsvohnTndJBu6T5xatysNVoFddGUJyhujiKKH4O2Gw2ioqKyM/PV9jmwiFkOMlZIgajiOLXilmzZrF//36pzmIUZ4aTJ08ycOBADh06JNXG/LUi2Hdta/i16F1DFD8L/EmwcHBpM6nOepFXu6ajdp5SEBj1KZNwaXOC1hz0RzYnpPp03ZLyFOovb9ptuPqALrPdV1OuGTpLJvlrZ1JsdDOlv08qPVu8hzHdH5LqBUaafFzZeFwxfaIkwmCIEBbjD4U/AfBHcYFi/hB9BTbRzHx8X3De8emS+0fmKHcjKOaeEpmLETAyW2wudhvioVyOc2q6g4wctIlIxGBNdssPt5HAW79QYSX2hwD1pw6EtIXLicIOjc+TPKq74lz+nKTP6YaXeG35akdpUGIQlOm8Cy5cEHHisHe7oUI2/JfXNtWiFy0c2jOJ0v2TKAXSOixl7BGfmupfbbW4tKUcrgusSTZ59WQeHfwoQ7OHKo7TX1VZeGA72nilWihQ9RUaLSUzywlgx8ES/N+XiaLIiQN7Qypw/Pc3UlVoa6HWaKR9kBJLt2ygw8AhZ2Qx9j58nWgOE1l65STuXSMjBoFtuemU262BZJBf6q+XINSpLa1Ku5X35yUIQ5Fx4WqXikYNTcMzwOXmD+Z/8uWBc0ISanL1nmQxDgN7vY59H3VArXPR1VGOeIPn7XiGsYLEHzWox/Ym7ea/oDe2ZeuO1WxY+gkapwqjzXNenGoBS4wOrVN5LYu1SpLHWytQsW2VNkD5GAoOjRuXM/KH5SptUlAirizRxE5BoM/RUg9BmGg6Y2LwigceoaiykTs/3NG8YLeimcJy7kdaHtO34Yssn7JiXMlXiEGSovYk9Ip4txKddSAY0Jr6QpAagkkGz7kpqmxU1AOOFA9s/UhB/vmrCEMpbDUVAiBgX7UfBvnmp2b2p+BwYPCLAlFiMIrfEIIqCKPEYBS/c/To0QNBEPjPf/7z396V3wSeeOIJ3nnnHWbOnPmrJwbPBqJ3DlH8LPCvLdgSXNpMEk0dqDX7z8/BqWsXUR/ymnbyhGCLpYifNvgeOkKp/NQmHbgDb7p1lkxcapVinhW9ol5gS/AqdA41KuXWRzYdB1TBV1LsXPg27wtKAujIvjs9/8jIPO/42I/NYEG7t9h59D2O0IH/CC0XsvUqJv92eDfHtWm8mackaq8VF9GW47ThBJ3q7se+7mmeyJtLpcpCpUvAqcnAoY2MQJXDm7BcS5IvUAVwNt2Lfb+KUpLIDRolDAgCbnUYq6AMMYbkgHP5c5M+rQkv8bflR2qxr7a1rGbyIuOggc6D26PJDk6+BNuv+oY91MiskMf/vUeynasdpdy7Lrwi+NmNzwIe4tVqPUFDUzXH/ZQ0JTkNpPWuBplSptbkQOOMjJwIV6fRnwB+qPEaAHK6dmfkTX/mh4Vvc+rgfgo2rgsgB0MFyninz7ba1AuJGNzqCQ45k/piClUGnjCRPus2k2Crl1KEt+VlhCeDghCEafUWulSe9CjO/KBIuw3RH6IYsqZaS7VLvQrrHLGkVYRaJLDX6+jQ7xxy6gs4wU/S/Pi2g+g44x0ErZYjNUXcueV1aA7+kxOPNQkp2LU6xmxNxGCtRutUEacJbyUGj5XWP8E4FLROFeoWrLdyLMu8JKR6sCzBSFWCkX7FZZTXNHAiKS7ktRAsMAZQkFUA37z7FtC1xf2SW4xrNQkKYhAImD5tiBbM9k3AwIBFh8s9NyQnayP7HfHHnAE30qPa8wLQqonhmF84j3c6pMXYb7Oj/3gPbuu/QicwR4nBKH6DUBCEK1dGicGfCZMmTWLDhg0B83/66SdiYyMrzxSFDz/neO7du/eM1v81YtmyZUFrY06bNk1KCj5d/O1vf2tVCMlvHdG7hyjOKrwkxp4apTRtWtsYdLpkSpocvHHCdxP8SrdcOhn1kvVY7ShHblwVhcisB691iuXcmCcAMBk7Kcg//3qAweoDii43jrLA+ccMAha1QJFJSc7toycHbHpS1U0BBf79bZXhVJTze7RFaOcElxvB7ES321d03t4rCdGkAbWqxdRigCc7ZJFOGbbDd0m259niPQFW6FKymFKcBELk1l4zcTwmzJKHFivwqXCTtD2H2sI/4ldywG1FFIUzUgzKCUE5ZujzoJ/n/8/XmMm1BHlQEkX0GYFx9sFg7N5W+r+4vpjDNYcD1G4/F+nTUnhJsOsn0s+FfzBJOBzeVYtj8xa69sgg6aoOVPupj+TTXiWuN7Hba7m3yIJqWlMj9IejS3lxe/BaNVvamRXEIChVXxcdikeIc/KfLB/xfkfqUIb0uoK4mOSw58qf8DW1yaTrhFvpd8kVFO/awbWPPcP2b75Co1NuP5wtXK62PNsWYwUx6CUHTjOAIKhdSxRJtNUjECEx6EUQgrBfcRnb8zKkVGIvvDXjQpJJzf257MFfiGRSIn2vnaKNopyCvLSEoHa2ilBrEaJIRr2FfsfKSXn6UU7s9J3/7IefQNBqcbncrPx4F8ju+73EY7Bk5XhLFXaQFImh7KKJzjpuPvIdNWU9qNYb2ZSZr7BI99nTjqQGjS+FWaxl8r43qXdl8E6vll/+BK31Jwh06H8O+UklWFavRgDKE4Nb60MFxgBkdugkEYNfzZlJ+d4D0KZlctB7ndRqEiiNiex7/HRQq0lgSVogMQi0yj4cChsyuvNW7+Dn4MWBN0n/B7MYayoE0p/U4o4FU7+hmEbkBQYUeRElBqP4DcNLEJrXrME0YkSUGPwZcDr1AqMIjeh4nl1ceumlXHrppf/t3fhdIHoHEcUZQU6EASFJsOePN0GQtNlORj294wzsavA82HstxoJoi8hK7IXl0F/Y3dx/Zt9vcbksqB2naKu1SQSGFw1lB2jcVAqNWozGfAz90qn//jjW3cob82MGgWtGBH8Y+lC4lQ/3mIH9rB/cTSII/Ymc9YO7BViJ/RGK+BNNGsT4MHWF/PBUYTMhKJuXSQkul5qTJ7vhyilHrXaFteXJcZ24iByO05YTEa9jRc9PGSs4athGigiVTlUAkWWqeAVBUNGQeqc07+F2meRr6xHsJ/lrcVJAv0Kjh0ANRpRa1AL+yaTgmZU6bBDdfngby/7j2A1Bag5asjF0a0t8lscy/t8gfVoKLwmmwpV/TtSOk4pUb39bcij78kOnbkXv0lERI/Bcn448kOv5rH2+toyuQPzYHMVnMd6QAwQqcRU14GS7HimBCYQkBiNBzxGeGnP/KfMxMnHqVdQfXkk9kBsXqBQOpfrT9WyLwZTHP+c/Qe3GvSEtu5GqSM+m2jQoMehFEIIwXE3CkHWc8IX1lscbQpJBQSEIlCWaqKhpIKPeIhGE4Ekltqt1kpU4HJnkhb0+xkOaaV0Y46y0uchXS9C53kn+sKKAXZCXlsAIzw56jRJ7AoKqiaOb9XzfpVZq26qag7LaipbiMlRPCAz+21LMOzcQN3A4xvhOHKkpYuXHu9hz4iDIMptqTR6Sq86k/BzLk5bD1o9rRqKzjoQ6UDUl4E5WKtBya21kIaA2uHBp3CQdc9CvuIwSY1VE5GBAyIeMaFKJIifuux/399+TUWv21R+UwV/l6Z02JCRx3ePPAUjXbqIohrScv3RtLzqkm9j04dvUF9UFWIl/DtjVkf3GLrhlADmJsRSU1PGArE7ibbu/5K0wYxyKGPRHeIsx2I9twHzRGuLOP/+sJ5hHEcWvAYJWS5xfiEAUUUQRRRRnF9G7iCgCECxQwH/ZPrOVGoeTv+06LpE27wyOLPhDDi+pKE/OjJQQBI9iMMt9mMbDPlXcTTvNwCHAF1whx4FjD3uegE2Qv24muuXBt+chnVpGWf0hMjFhMOQHEDlmlwt9uBRMOfytwy1YiUOhU6/36Kr3kKJ79z1IVWUuxUf7kZA3nuQObVA3qeFEy/0slqkBW7LyeVFFKm3aFzEVG6VkMa8ygWohR9FGJaiJcWmRZzOfazLTsNuTVjW7WYVmJo6ZwpMBIQP+4SwGVzB7FRgGZqJJ1pN15Uhq3IVUH1DK+3WN2SR3HULSlR2kef8N0gdCW4whMFXWi1CfE3/7b6i+c5sy6WjL5YCgwiVTKxYaVFgOlFPdN16xDSlp3Kb0/suJY7WjVEHsV2e9iNa6nbjaD0Me35nCbEumyaUDfLZIveyju3npvzjnojsxJCQCERLAKXCNITukIi+cVVmOUO1Eh6NVCoiwxKDUqY8gvPTeqSybNytoTcJwxKAXbuBEUlzYBOFg28+oaySt3uJJZNXqMZli6VdcAKAglUKRSf4IRZoZKz3t/b+XqtfHky/LnrFt0BJbq8NlN2BCBF/ZWBLNWlLqI1AW+oeuiKJkw/Za247UFDHuyys9ikG/MHefyrUUtaNU+kx5k5Z1DjtJdVWKdUKpKhtVsRwTOgUoIg16J92vPiZNpz6pRYVATmMlz65bwKPnBtYdHVuxkiR7dWDtxyBEU87sWVjHXiSpQb3nUh4YI4c+sYl4tZbLH38YtUYTcO0GszADnPj2Y3pecC4333MnL00t5IvEn5cYRBBI7tIXxY9RCHTOiEN0Oqj+4AOI7SvNT7ZFsHIEiHWGt8CbRo/GNGIE4Kk/+nMkmEcRRRRRRBFFFL9vRO8kolAgmPItlCrOn7TZlBW5yu3BNjH0SswCPEokc6OZZ5I3s6PqkGRR9cKrYBMgIGW36tDdxONTkPgr3OTTwdKG3arQpFdQ0ikINu57giNU0D7/TQqPaBQlBAsabbRVx/KI+BAmGoLa4GKwIQJ6QxP2c9VscQ1gjebCiKzEwWBVZxAvK6haUeEhh77YY+FbIreZSv2hJ5+isFY+HTbmCo9I5+cR8SlmCk9Cmocw0tiPSoRRfeqkgG3osUrPZ3Iyd7Z4D0ecubyN7JpwuXmlWy4d9Tpc358k3dLgIXu9YQaihxhMuspD+glqFcnjO6EpcVMsE7am/3kQ8Vm+J/ni+mJKGgPVrcHgT/qcaapxOEK+vSGGtX3bc2rJF5RfMJZ7Dvv28ZVuucSJeqb4wk9DElL+82t0sRzQqgIs8w/1N3j+OaYci7v3+8iH2WRJ58lL0PinjvvSxftBBOTgnak2DGqRMoeKhdXhSZubk5vI0Lox25KZteFJwJNKe2//+WQbakiT1UHc+/0aug26XiIHIyV2HRp3SMvu6QbKgIycaw4Aaal2UkTEoNS5SOGWDbx93+1Y6msBZU1ClShGRAxuj9ROLNtuejOBVuKfyFozk37FZfzUIRtrtjoEmeSZDmWrdTmUBLmqWYXntRgf2dQGakSSUKq/5eEeWoNSHReplTg9SBozooh55UrMa9ZgOG9UgJU4FORW+6/HXCf9f9tHcySCMJSqUlBrWJRzIy5Bw52bl5CyMRWVykbbuloqO/kRS3oRrwa0f+VhPjT/wN7xt/HstwVSk14dc7DvLIjImtq4YQOuykqFXbwmV0v3G5XKWy/yxni+G7buHod5zzUUbj0Q9HrzVyxW7NvBV7t+QGcwUu+MhcSg3YeFpeUmADhEB/F9R/Jsre+l5vRLu/HcMt+PxNzr+9Ix3YQxRoPodHD+3HUKYhAgwe5XKDkMJu5bxj+7+2xRD21ZRG5Deciag3L4j56XIDzTxPIoovi1wOVyc2xPFbk9U1Cf5svzKKKIIooowiN6N/E7RrAE3x+qlW/BDzZaJbIiwN7ol6D7+gkbxOsYIa5kjTAm7LZfOtEEJ44CMiKJc0A4J6CtV8Hmn8gLcIo2VJJKLUkkUoPdjxw8RRvPvjer0LzwKgod+ipULj06S6ZUX9DgEoPXsAsBqd+jTaBSPqRJhIrwJLPFe8j2k+zFYFMQnrON95DMSn4ULpHmXSx+GVFoiBe3bt7L3921xLrqKSkZQE1NNgC51eUMLfTYodyCip1tOmLTtayc8ZI/mZSQeGw0yc4e4BPbBRwTQD2emPTQhJEH89pmMSA7kUxOUeHXR1ljGk0uNapG5XUnmJ04Kk8Rn5lP/tVdcJ6Xh2V7OS6zHXWcDkPfdDTJgZbW+KwuDE1YETS1OpyaTI65o+bSMamjgvQ501TjcIS8F2lrVuN44Tk06Wlg8I2fx5bfNawt2QsvoVWy/AAlBY3cObR9xPvoj9Q2d8GJxwEfQVPsVvORrI0g2nh6l5V8cxxHtffxj4yXA/rxknx6ARmh13I4RIbWTVudyIGDo6V5oiOVRMFAmraa4pXZNNXGYErK4g/TnyG1rW9MIlX9SeRRGIIwGIIFt/j2MTAA5MTkB8IShEU7tlK4JbCoNUC9wYFD4w6wxlrqfLVL5fs/uu9gzCtXhj3uingDZa2xEwMIAm1qzagAq9bvBY0mBhUwoP4k1VOCB2XkjTkl/R/cYqzj8Fdt6XiFp0RDwvk+5VkmJWQOCk7qy8M94i1arlmdHXS8AtCsmEyva6R/MzHoxjM2afUWVIKAcdQoXHYn/1mwi/ICK/QN3Z3UbQirvdxiHEpVKbpcXFC5iv+kj2VB76uYvumf9HftAZNIoliJXIvnzBQBN0KTQFKvMXSd8yxZdXYFOXhe914cUTdSuG2zdLyZHTpx6b1TA4gm04gRmMaMka6dnJoGNBmR1XM8eXAbiMGZ00RnnWQxlisY7ZZGdKdJdp3AzQ2YMcjmXVb2LXFO372NQ3SQkp1Exz/8Ed7YLM1Pj1MeU8d0Ez1zEhAdDj6cMhsMA6Rl/7d5EQl2M/F2C9cdWsnizuHveQDy6ssU07kN5XSsOxnRcTWuXh3wXSFPMI8iit8yXC43376xh6KdleT3SeWiO3pGCcIooogiip8BUXLwdwr/umGZfb/lmCuVaQVKoudAow2oBWBrveedvLf+m2B2Ktp6p9eqz4PInr8BOEZuRO38E3kBhYItGEIttxz5K7Sfwal+8wDQbJnN9ee0k5Z/vsZMnbEaaOVDchgcbyYq5TCdGgIy160VPdlHR4KsRFpriEEAg93Gvh2bEV0uBKE7HgWJiCCK9D5RiAA4BRWH03NCkoPywv5yJV9t7vdYOQD4SJkqUmnyI2WFo9dDfmAohf/0gOzEZiIsn6FDVkghF6s2P8/0dY8H3Tfd7hoe2V0DFPP91FHkpxqJHxPZNRQspRoiV5PFCxbS/JJNzzTVOJgV3R/13/wHAPGHH+ASXyqX13IcKRmZF59HUqKA2R2+DmZLqDzxKl6KssIh4BBLUTtUgO96UjtOommyEmfTcXFDV0bf8Blr6tcze6uvKqaX5JNDH4FYbcsPHTGnDCV71J9AVv+rpNGzV6fqUjFU2fnTC6+hNyk/w+FUfyHr0PkRhE324xLJ3FKgjNRFiACQUASh13qcN3Ag2bpYTjVZFEq+eoODz0f5SDV5Km7gxj2KQlwu+p1/Ppbvvw+pHEyptxBjd9KkVUemHBRBZ4hHM7Arh7fsoHzwaMVibyKrJsGKjtJgPSgQymIcLMU3GOqWXUK1ui9NDT9h9yNjpPERRc+OBzu+ZrVgm5oG0ptrJ3rVlGWJJjLqGhnerisCsOvptzjaaxIJYgrj1w1BSDiIfmSpQvlanzIJlzYnbA1dncMexqLrU1V2qD9KnuUYRcZ83hp1Ce1Gbg/aX+2ffGPYod/dCJteJb/zJXw/dRTmRhsNL76A9uGv6Hf++dD/HAq3bsIQn0jp4UMsmzcrQDnoDQM4dv9k1hzZR1mCkSx7TbBNB6Cl8xbKYpzorGNcyVenVXPwhN8Lhis6t6Vm52qJBNXp09D+sJetTW9BbB+pXUWD8uWeMUbDkdJafnruZR6VEYMA1fo4/n6O0uUQDLft/pI+lYVBbcMtWYkVCPNdEUUUv2VIxOAuj7q2aFcl376xJ0oQRhFFFFH8DIiSg79TyBN7fXX6Au0xLxQpH+b8rcRyyJN2/evChcOHwp8ianc2cUyThkC+RH6ZdUpFy954NaXxZ/fjMVemELxVXEAiNVRl64FR0vxTtCERPQ/ajvCS/vSUXVWmRHpeN4GSFd9QVVWF2EwCqBBBAG28iY87DaLG6FH33SXOJfH4aJ7L9T0kKQr7+8GrFDtOG4WVWI7X26jQ2I+idihVEWrHSe4ssNEtK4M+Fw1RKOTkxJ0twpTRxiZny40igH8ybygU7n+Aeq3I0CErqHCqgoZaRJpq7LUSS7X8mlHQaMNVW4vziyXkmj1ql8a1awFI+eZrvszKxqJWY1RBbu+2YIhsrLww9E3DsO5Yyw39MCtfhe3IgwrCuMIh8GxpcFVQfNXrvJQBZMAiw3x653ZGUx+jIAdzjdM48K8P0SfaFeqxlvBD15N8fbgdoowYBHhz90TPPya4peZDThzYG1RZ4z0vbj8iNmwdumaCcOmr0zD1/FyaPXTIirDKzeL6YszWOhpemEvCqg1Bw0QKtq/i8PTbyH/kCdqldFBYj9WpqfSuqsKVm66o2+fwI6n9p4OhcPtm6HcO/UaPDkoQliTBySQ9h9smoHPFB62HFwAByh0Ct8SNhtGjAxbLE1mfa3yaDKO/RliJUGRSpORgh00rsafl05gwiBhxPU1UKknAZvIPCGqdjlGp6XusHI0oUpIEFh0cSUvFofKQvmUJRn4yV9J7616SBDVxdUVY0itIdx5BrxNRaZXnYfzmb9FbUyjTZSusxJetXEx+XQ22pkYyxBKFlVgO+ediy8fdOR7recmUr4tMcWb/ZjLGQxtg7Rza3bKUE39/HU2zctXy/ff0GTWKxg6dKC30qApD1dl0CwLb22VQVlUMQIk7Ed4AlU7E0lat2M+uHWey9ct1FO/aF1HYSijo3ZEnnofDJX+6jT0fWCncsgGdPo3ZmeMhCE/7rMxS/MFfBvmsxH7EIBA2hESOZFsDsc4mrJoYYp1NvLV8pvR/S1biAEQJwih+Z1AQg96fK/H3RxAuXbqUWbNmsXr16rDt3nvvPZYsWcKSJUt+kf36X0KkYxRFZPg1jOeMGTOora1l7ty5fPnll3z//ffMmTPnv71bv3pEycHfOPxrmXmtxPIE3930irxDV8sPoJG08yrTqkgNSi55ca24CBNm3guiGjwTvJmXCcwCYLI4E0OiMjTk8T6xRFREqgWEqpcY6nheFSYrVIOni365bbj0L3/h73//u2K+IAqM6HYZ82J8igUdNnpVxyIXcHqtxBm7/4JLa8apr6G23XfS8kxKOBFECQmBVmI54qte519xgBmWupeiiLdthkZtRK+OTFFha9yAxdI5pCIwEhyxNHHtvkbUzcm8E+3P8VW173q4NN5OptZNllaUrK9FdYe54bsHg/YXSaqxv5VYDsmK3mMYHzzxAG2qykDw3PyKbjdxb75GnFtE0OlwjhmNJiWlVcerSYmla48MPl9bhkUlUGRS8Xhv37X+9C4r3fKSqByoYlKBr4JXnroBux9hbIvQfa8+L9XTh18ycxtDDvUbSjh1dHWr+xTUTYjBXaoA2FVaCjauC2u7K9l/WDHdYh06UeTkwW106emb5XQ1khffM2hzheW8D/zjJ5EsP8FVSRLc/1c1sA2WXsWXFy9G87f5koXTv9ZbQZYOh1aUUnC9OJkWQ1ViPLFNLtqWhVavhiIIS5Lg/kkawAnsk0oAyOvhhRoTuyoykkL/ipEUdx1bhpyDZth6yU5evDIbW60uZM1B8FiL933UQVLXycko4V8GUorsqGwCqgpwGJbi1BhJqm9EEEUfCSgLFwEU4RpeNIlu9gzsQVrhXh74q5eQrOWa1QZJeXjKbsGZl4HWeDm2HAOdLn1TWr/CoSQbBw3bR5pWZOV/RirmdzpWzCWbt7GmT0dUKcHVkv5waHUMrtnE+uQhDHAXBG1T4RCwiUhjqzu2CQDRUs+JW6/BfFwjnXO3KLKuaD9l1TK1a4jk66/mzPRYkKVBFyhxJ5Je1ki7+hpEmat265frKFhbCOLpE4O1mgQa1JEp9x/d8C4VcXG80eNaad7j1p0MevCvmIx68lONtLtnClvuvZuyPceDEoP+SNSp+Om5l4MSg62BQ6VS1uBcPjNiK3FQyOpdRpNbo/gtIygx6MXvkCCMIopfK5xOJ5qfuS7ulVdeyZVXts5pF0VwRMnB3zD8CYiVfUyU7rhI0aaUrNYRb5H+ALfQTtdMPvnbUf0hAIaIS4yfHuYKjwTjqM4KvPUSJ4jvtXrdyeJMUqkMCACZ1LQHlW45R+igsBw/2CaGizPzJCL4wIEDkmrQCxGR6k0HYISPTJsrPMIi9XY+X2PGohbQaivIcfwVl9bMiYGzgu5bKVkhSV1/63AohLLfGgz5XDXmIzp3OcSufc9R0pjpU4QBt/f6J1nGUvTqJupOVPDTCY9663QJQq+N12v5M4mxIEuY7hbrCrC+NrkjC2oIdYzBrMPB4OjQEarKwdve5QKVCl37fNr8Yy4xnTqF7yAEkq7qQFfAsrnUm1sgoVteEude0Znd1XsV8xP08XSUWb/37nswIgswgEnve8j3J0uveOARlr5aB83EY6R9+ie2+mPYZVeQkRCetDro6M45G88hw3EcXQt16Dy2Tze5/XOBo9J874sW/zqWAGar0jJpCcKVWP3mHbj9T7QrCLRaqoDM+jJemBD8Z3tbl2Lp/zFbu7dIEPa47/8wCYJkc/bfN+/nWF4PLwBem6Y7DEsrwzFdPKWJw3mtw+dQ5iGkH820eoJDKmKhWd0cCqGIw+QiO7rjKl+YSryn4lxFvIH0ukbS6xopb7YEy8NF+hSX8UO3PJp0yjE95bBR2qcD8vOsUGYKAuXxRlTaYuI0iYp107Si55hkBB1ArKD8HetTdJKauFiaRDe6CFSRZY1pvGX6s1Tp4lXztczbcJxztbuxxKrZ1z0uQMn7SXkpRpsb0Q0n1sVjPqnC+5QtWaXjDYEbC5Z8HSwQRxAoTzCiUTtJlzkPinftO2Ni8IO2E1psd2npN6TYq2lKMlPnVz4gfeP3JP79FG3mzkF0OCiZ+hAJ6zZgNkT2MuXUxq0BVuJQGHV8K6vbDlBM59aXkWKro3290n1h1bRO6R0AQcB0/vlScnEUUfwWEZYY9OIsEoTffvst06ZNw+l0kpSUxGuvvYZWq+XWW2/FbDbjdrsZN24czzzzDDNmzGDfvn1YrVYOHjxI586dmTlzJlOmTKGoqIgBAwawaNEiVCoVt956K3379mXy5MkATJ06FZPJxIwZM5gxYwb79+/HYrFQWFhIZmYmn376KcnJyTgcDu6//36WL19OUlISI2Sf99LSUm688Ubq6+ux2WyMHj2al19+GZUq8Pg/+OAD5s+fj8PhwGQyMW/ePPr06cOGDRu4++67cblcOJ1O7r77bu68885WjU/37t0pKCj4VY7RCy+8wMKFC1GpVMTGxrJq1SoMBkPI8dq9ezd33nknFosFm83GhAkTeOyxxwBwOBw8/vjjrFq1CrvdTufOnVmwYAFJSUm/m/EMhlGjRtG7d282b94sjfGsWbP45JNPcDqdpKens2DBAvLy8mhoaOC2225j586dpKWl0b17d5qamnjvvffCjr0cctVsqHGMIjJEycHfGORKQX8Cot5uDWjvn+4bDjdnJbOwpJqm4RlSzUG5ldjeKwnRpAG1qkVL8dwwakE5Fgst1/T5NeBD4dZWr9OWE4p6f170K7Jh6rKWGJr4Dz5ysJsmld5xvge9/fs9xHBubi6DxE6sKd5CmaqORkcZz+0XmN6tndTW5jbRxdJch4sUIAVb3NGQ++Z/3VwrLpJSpkMV3fdHuGAIgyGfzlmN1J0IDDvJMpaSF6+cL7fJR4pQtt74dk9B2b3StJes6tH9JQzGDmjURioiSTol9DF6awW2hE4vPI9zlFJxhCjS7qMPUSckRNRHMHgTnONHt6V6ewnI4gySRmposOwj3XWE2eKLUsK3vf5P7LWmExeTTLbRk0jjJUI6dJvD8cZKntz0ktTPU4MepGv64Bbt1WqNhsvvep6lr8LJg9tx2VVc4xRwaNzUmhys6etTrT077Fk6JnekxiygH5bIgpkv8l2aT7I0tmIlf33kIZKT4slPDV/41NzkZMHaozTGXcXF5d/R3nI0ZFtlgqxSPbl3n09B6iWpvenV+zf9R9F2XddEoBZDc1k5qw5OpirZsOPaOtzpIrF2AlSGTRHyLdaYMNdXs3pO+8FH5Lw0m02P3UPltg38p38bkH3feEsCnEyLBbKCW4ybFXdSsISgweU08Gk7X0DPtUeXotZY0IlOXHoHJ2KLFV3YxGbLsKBC507ETlWLtQ79LcZqm+Aju+RKwGbyKr2ukf5FJVINQfCQYzvzMjy1FWXwhrzU6pWEp1epKdWjFMDtPEJTfeB3jzwt24vE6hpu+/Al7LoYdPYmqgwifSqtnnqS9YRURXpVladcmYr0XhcaHqi/nzUxk4ltJub8VbeiQ2wmBpMwn9TjZV7dwPLOXSiJT0AnOoPX/fNPvg6VlC0InHInYtg1CDQuju3aj73u9IlBIGIlapzLTKKrniatOoCgjnXYMK9cScPq1dQt+UIiwXMaKyVr77G4dIXtXa42NDfaYFvwICB/yIlB/+nbdn+pWFYcl06VUU92XR1tW2srbiYGo5biKH7LiIgY9OIsEITl5eVMmDCB1atX06tXLxYtWsS1117LhRdeyOWXX860aR43SHV1tbTOli1b2Lp1K4mJiYwaNYrbbruN5cuXExsby8CBA/nmm2+47LLLWtz2xo0b2bp1KykpKdxwww0sWLCAadOm8cYbb3Dw4EH27vW8pL3oIp+wIzExka+++gqTyYTL5WLcuHF88skn3HDDDYq+161bx0cffcSPP/5ITEwMa9asYcKECezdu5fnn3+eqVOncuONNwJQUxO6hmyo8dm7dy/z58//1Y3R+++/z2effcbatWtJSEigpqaGmJiYsOPVrl07Vq5cSUxMDFarlWHDhnHBBRcwZMgQXnzxRYxGI5s2eVT6Tz/9NI899hivvPLK72I8w+HQoUP8+OOPaLVaPvzwQw4ePMhPP/2EWq3mgw8+4K677uLrr7/mb3/7G7Gxsezfvx+z2cywYcMYMMDzOxpu7EMh3DhG0TKi5OCvFHISEDxKpH1mK5MP+IIGnuyQpVinyK7DQj5m4jDRQCw2zMRFtL3nO+WQSDULISTxJ5o0iPHKhwJveEkkhGEUHrt1f/P56E7Uoe7qeVD3Wny9SGxIxQm08UsJTvngINU9aokbmYN1VyWJlVqG5w2kF3k4DtVyGQNYHbefplgRs6FesW5hohUoxWTX0qHao6xQuQJJvlKysKKXUqC9kD/Ku7SZPJUwj7Z6NyXZdTy6/Qlp2fMjnqd9QvsWCSPwKLGAAItxMMuxt22kCGfrfaYkUbIY386bmLVNuLBxjrED8XEe+2gehAy1iOQY2xtiWD+4m0ROSlZi4JVuuXQy6jGp1aT9tJYTQWrUWbZuPSuWMk2ynt5j8lnf/H2idpyidMdFUmyEPHTkT2vnSustHDVD+j9NK9IjtSewR9F3W2NqyNRef3gJwq/mzKRw60biQxARHZM7evpMgcObN5BkV/7gJ9mrSag7Rn6nlhM8319/FHOTE1FQ813aBdxyfBFGtzWocE2ti6ycgtPVGDb5eukwM0uHhf8enHelj6z6x+tOBUEYaw+yQhCYTWmUpRoDCT2ZrdZaXMamx+7h9j6boY8a/F5ExFe9DsCufFg9rGWLsZdgKvfjLNQaC+mOKuoNDqoMbmoNRxXLt/2YhQkRraGJeIuNGHdqYJ1AP9jrtJS/kUm3qkrUNgFVhRDUIgxIBKEApDeHagUlEgkMeZFDTlLLw19sVWUc+HQUMfHD0MWdImfoe1I7hV26TkuS4LteyxKM7BnYg2tefYdvXv9HyETqU3XpNNTHUaNLVsxX4WKyZjENbj0OLBy3C5Q5lA/GRzRayvbHI1p0ZPkRg3O73y61G1fyFXq3TZEY7IUi+ToMDv90iFpNAnZVNjpNYD+tQaRKVKmdICgI6qz6OrIsVRhHj6bu839jXr1aQW6GqvUnVxsePe29V8K/NuEsGRn5xvKZCoJQSE5GrKkJTsRGicEofic4tqeKop2tIM5FKNpZybE9VeT3SWv19jZu3EivXr3o1ctTYummm27i7rvvpn///jz11FOYzWbOO+88LrjAF+I4duxYSRnWv39/YmJiiIvzPE/169ePgoLgZR/8cfHFF5PSXBpm6NCh7N7tqaO8cuVKJk6ciE7neab685//zNtvvw2A2+3m4YcfZu3atYiiSHl5OT179gwgar744gt27tzJ4MG++6Hq6mqsViujR4/m6aefpqCggPPPP5/hw4e3enxOnjzJyJEjeeihh35VY7R06VImTZpEQvMLdu8+hhsvq9XKXXfdxY4dO1CpVBw/fpwdO3YwZMgQlixZQl1dHZ999hkAdruddu3a/W7GMxxuvvlmtM2/V0uWLGHz5s0S6eeSCZhWrlzJnDlzEASBuLg4rr/+eg4f9pT9CTf2oRBuHKNoGVG25n8IP1Q3UGl3kKrT0lavU9QK9CcDQxEbcjxVqHzYe7DQCoLSJnq5+FlE+zatIEiNHP83dH7T/uElrQkpORP8ociGTtWIJvdTMinFRAM76RdUhXi9+E9SqCIm44/MKU8O0tvp42Lxy1YnDWdzgu47Y3GrBLz6mkxK+GjbQVy2NhhcIrmWFOxrZ5KntvGx9igOR1rzfBHL5lLJKtpJSAS3iKM5bboouZr/Oyc4afJcXm/JWr1o13a6lHREZ8kkf+1M3GobduMptvf+iinC/KDr+49t37FDaW+IYV/VPpAFarZPaE+72FicrgYslqKgVmDftZ7N0CErMDcW0LbtEQqOfoRe3SQFGrTPfxCjqRMmYydFPy6nk6IdW8nvO0BRUF+Olmy9XovxazzrOyaHnh6yNnnxeRyxNOHyUx62T2gfESnWPkSQSCejXlKAnvxuOQDq0d1I+svN1Ly1ENfq/dR/t/ys1pvy7kt9gy1onqy/Isku6KR0aYe9BqerEcFRrmgjOMqpb9gT1G4bDGqNhiseeEQiCBFFtC6lqkuuxCzYtD6ARNC5HS3WGQSPavD1HwoRRVCJLsZWrAhJDALkdOmHv2IwGDRqI43W1qtYQ8HfcpxV4yEMrTrYlZ/Ih6N9Vk55Ku7KXF9RNYnQkxGD3m/qym0bmonB8IjIYtwMnegMmA5Hun3fpRa6eP6/ZjXEW1AShKJfqnDzcfQurgZUlMcbOJEXFzRcxHcAgidIpGMO5xw+ye4QRGIkoS7B2tmqynBanTitylARW40Oa1Vs4DE079Mph41vXv8Hl947la//8XeObNukUEX6W4nlcKPmBedN/F17Eab0WRAkJ2xaRio089Reorki3kBJQqKinTwR+JbjH54WsedvBT7dfkCmRFVpqdEm8V268sb+3Mp1tLcWB/TvnXbpRXYN7MEl466gZHLw2rAQmBbsVRua16yB3i2/YDhT7GibRc6BSjTx8WQ8+QTxo0dz8qH/UyaaQ5QYjOJ3hdyeKeT3SY1MOQggQH7vVHJ7tq7+cksYM2YMY8eOZfny5cyfP5+5c+eybNkyAPR638tztVodMO10en4HNRqNggSx2WyYZCUQQq3nD0H2+/HSSy9RXl7Oxo0b0ev1PPjgg9hsgeV8RFHkj3/8I88991zAssmTJzNu3DhWrFjB9OnT6dmzJ6+++mqLY+KP8ePHM2zYsF/tGMkRbrzuvfdeUlNT2b59OxqNhmuuuUbqTxRF5s2bx9ixY8P2Hwl+S+MJKLYriiLTpk3jjjvuaHE9+banT58ecuxDIdw4RtEyouTg/wj+VVKlUP3J8VajntuMvg/Cuz3bnbXtLhXGt6q9tw7eMfJIrRxJadsU3m2THlQZ2Nu5hYO0labvOFxB296zJSWcfd90pvXIPvOD8MMn+XpAD3hqKc4W78EQJIkZ4GOhuZZdedDFZ4Su7OOOhsEYR57L3vqTHnK2BXTacg+6xhTsBg9F41XqdXLF0KnB90Cqs3ge/j3mziAPtCIB6gP/ROZQKOq1iPy6v6KzZErbgcgt6O/2bCeRTf62WpWzhp82+B5E/WsF+iv61g/uRvu0fPT6PdirX1T0lZJ6nqTk80IqnL9lAx0GDglI3PQiUluvom+t8lr17qvaUY6cVg5nlw4G/32RT8f26IHQLZn9uQs4Xr8T/gDdhvwVvSrLv5uzAn8FpjfcwF+RdLyxEqPRispZx8m9t0rzH830hSHUFT/H5maGO9KakAqCcMsG+nUbzh+vuBGb2BSgxMxo35Er2uRy69ARWB0isVqBqp+saHQtE1ifbjlOg82JFjcXlX9HO8vRkMSgISGJS+54Gqf7LkW9RS/kdnODIR+jszhET61HMKWgV0l4LNOAPGHepc3BqWsX0N6u1QUlBt3AkdQUaH55EA7eUgE6R8vSRbmCy2tZrTK0hnSz0KSCeKuK+liRGIfLY/0NEiiyLS+D8kRTcPLNH4JAnVHP6u7tcGqDf/5bDKQJ0U7QtMdl34vD4keANqmlbQdFc22/r//xd+lmXh684m8lDgYhwvAmqw5OGlNpFGJwOUKHbUVq6W1pvYj7CXHuEp111GoSEIOwA0a3FbtKS60mITgB2Uy8rt61mX7nnx80mRtQWIxjnU3kWKowjRmDacQIjpQ0RLT7F5Z9h9YlsizbZ8Gafmk3nlvW8gvcBoOG7Z1zuX7hYrTx8QC0mTvHk1TuJQijxGAUvzOo1SouuqNnZNbiZmLwTGoODhkyhN27d7Nnzx569uzJv/71L3JycrBarXTo0IGJEycyaNAghg0b1uq+O3bsKNlNq6qqWLZsGRMnTmxhLbjgggtYuHAhEyZMQBRF3n33XWlZTU0NmZmZ6PV6SktLWbx4MePHBz7LXXnlldx0001MmjSJ3Nxc3G4327ZtY+DAgRw8eJAuXbpw++2307ZtW6ZPn97q8cnJyaGgoOBXN0ZXXnkl8+bNY/z48SQkJFBbW0tcXFzY8aqpqaFbt25oNBoOHjzI8uXLGTnSU/LnqquuYs6cOQwfPhyDwYDFYqGoqIgePXoE3e/f2nhGiquuuorZs2dz7bXXSjUO9+zZQ79+/Tj//PN5//33GTlyJI2NjXzyySf069dP2naosQ+FszGOv2dEycH/Ao5YmjjY6CGKuhg9N+mhiEGAksIakKWJrq+J7Kb154C3Dl4+RZC7Gje9EYUnFW28VuLdjb3R4bMkaWv1tPlxEnp1E7miDp0lDm2Than9gxREP4uwog9X4/5nQ1tO0PeCzhgMJgR1W+BQ0HYTxPfoWHA+6XUpkqVXZ8lEs2U2U85p52l0Dny+xkyuJcIo1yAw2SN7sIjFhlutfCtzUhtHJakRre+9piEwnTZJaECuQfWvFeiv6PNOB7UNm7XUbzqGy2xHbdIR0zuZb96b61GdQUDipheiy03iN8f4fK8Zi0agyKTm8V4+4vOJ/Ewy9DrK7U6eKvQ97HtrE3rVvPIgk+qsF3m1azp9E1NatEv7Q24x9vbtRfLEW6hv2AObF0jzTOMvDSBFzxYMhnxJEXiofCOTZVZiOeS1BR/NFKQaa8FqrUHrakJ6CcKW1J/9LwlU5XYYd22QloEY2C6ZmwflYFz7IdowxCCApb6WZfNmccUDj2AIsi8Gmd0coI0hh8lVl1J4YDu1RrvCjjpiRwqJZq2HXBJFTDYLVQkuvh7mI/nu/dJFTmXwmoNyJJiVZH+oWp86e1NQYnB7XgYOlZFrVhtwaNycTNezrfNRaT2vEvG8Dd+Ts+mz4DUHQ8CfsGk16SZasGmc9CuqIK3ews68DMpkgSI07395QvP3QkvEoAxOrRqVy407yINkvEXLNauzg9a79I7HuG8/Jd5SK80XNO09u+w8oiD2XHY1dnMEtfdEkSPbNilmeYNXBA0tkoMtBfNI+69OZJosNTcUTuhzACSLsSEhKWzNwVpNAna1Dm3HAcizw2q0SYp+vLUctQ6huWajry6k50CUJGG4UBK5kjCkQlEUPenK/QOTueWQLMYyEs4tCGz68G2gZQV4pr0ygAgd1iGF76eOorHJyaGSOh78dLe0bGz5CpIcNZ5xcdVTZtDx9YKXpd8pQav1EYQrV0aJwSh+l4iIIDwLxCBAWloaixYtYuLEiVJAxOLFi/n0009ZuHAhOp0Ot9vN66+/3uq+77jjDq699lq6detG+/btw1oh5bj99tvZs2cP3bt3l8Ihtm7dCsD999/PtddeS48ePcjOzg5pmRwxYgR///vfufrqq3E6ndjtdi677DIGDhzI/PnzWbVqFTqdDrVazezZs1s9PoIg/CrH6JZbbuHUqVMMGzYMjUaD0WhkxYoVYcfrscce45ZbbuH999+nQ4cOnC9z7jz88MM0NTUxePBgSfH28MMPhyQHf2vjGSluuukmqqqqGD16NOBJMP7zn/9Mv379eOKJJ/jLX/5Ct27dSE1NpU+fPiQmJgKEHftQOBvj+HuGIPrHmf6XUV9fT0JCAnV1dcQ3v0n9LSFYrbPbUhJ5q6o25DoXnbLzbfaZFfg+U0wWZwYNyCgin8dkVmV/K3EoPIeefNSIBg3XjAjimTqLGCr+wE/CeT/rNvwxp20t47LzJLXUD9UNXL+zsIW1lATggTgVNw/zkWIL1zfStSEyBU4oFCZXYdY5KEy0eqzEQTBbvId+u65A15iNyqWnlCzFOXqtUyyOpkTuO+a7Fu4S53Jxr8dINbYNape1WIrCqq6OO/S4tNlh6+9lcgpzYwG4RJw/xeDeqPYUOxQE3G4n68u+4KTlMIq7SEGgw4DBCoKw+rMCLFtKpWb+4xwJ3u3ZDovLHXJfQ1mGW4OWxixSu+7pYvOxr/jz96HfJnsxJcMakObsjzNJk/45IClMgyWwBoPsOmqyH+enDb4bI/mx+fdbFd/EV8N9Ru0r1maSUi+7NkSRqng7X43wtXn+HScdWv4KBWB7hzTqTFoqE7J45cap0vxp78zHKtgw69V0LS5WEIMAZfEGtuYr1af++1qT+TROXTsmfvoKGZWBwUithRT04Ue6yQlT/7ToDmXVdCmtwY3HDpvWXDMwZH3BSOE952HWL8qO5Ye+B6Rp73hctnIxKTXlzWSpFdQZ4GrZcn668NTxC7TXzr2+Lx3TTRgtJ1Cd+IzyDpfx7MLPKczxBWA4T47nAfdqxoq7ObCpF5N6PNSqbT+auI8/Tr6Xpf+YSdG2LUH3LZJU4aur3mXF8IPStLxmYyiU61L5OOe6Fvu+/uRi0u2B9ckkMtKp4pa/PkHMBx8F2nW98FPnHd6ykS9efDrk2CsIvmaFo3wcvp86ivxUIy6nk1df/Aez67qG398gv1Oiw4F5zRpMI0ZEicEofhOw2WwUFRWRn5+vsDaGQ8hwkrNEDEYRRRT/fTgcDlwuF3q9nsbGRi666CLuvfderr/++v/2rv0qEey7tjX8WlQ5+AvDqxiUIxwxCPzXiUEvgiXn+odl4IqMvJrevN5s9+kRg60h/H5pYhCgR4Ky9klSCBubPyxqgWMGz98ik/KGxzvtrS94OvAqE6FUqjHoDyt6Snq/IU3bt8/BW/RK7SjFutGNcNgGg9pLbbI5Qfa6Q+Rc0d6/OyyWIgWZIsfefQ9SSlZzLcNAZaWcfPNajKs/K8C+pZnEEPEQg+VfcNISpBhvs23PqyAU6xyemowyGFytH8s/7Tna8r6eAUHY0ph58XOSbnExkdXgHNLvfbINCf81EtObDBxJyI0XRTu2hgyACIrm5NaiHVvpOHCwpK70Pzb/fv0VcwEKOkFA6/ILkUhLJb+skkged/oVeupvHmqr/I3ILT1JQl05dYYYOpbWBPSVVm8hvdasqNPnv2/hrMRe0iRYgIVn5UCraCgyKNGsVRKmzevrHC46lHqkkyogo94SMkik1Wi2KOvsTuxey7IMNQkp/PuSG0ku8ZFp3vH4eoyPsPLUc/z5iEEIVGF6UbtpOZWxTqo1GvpffC/fvHaQvtWdKczxtXE6cnip6UGOCD/yQ49erd72wD/8EYCywsNBl0dqHbZqlddWJLUdWx1KIoN/jctbOqQF2nW9CGLbze87gPYDBnFk6yb/rgFIctQoCD55jcSOPXqQm3iR9KKgfO8BaOMjB4Mel9/vlFdBeDbrykYRxa8RQRWEUWIwiih+U6ipqeGSSy7B5XJhs9kYN24cf/jDH/7bu/W7RZQc/IXgtRKvrv7vWYLPBHOFR3gh4zCa0rkKkjCTEt4tXEaJvTtH9SbeTE9sVb8H481AQqv3x3DUBL+wEEntKEUQbYiCHpc2kx7iDvYKfaXlE8T36M4eYrFRsbuECqDLsVc85EGKjkie9mu1cPOw4ITp4zJr+elYjI8ZBCxqAYNLpEEIXXPKm0TsTbW2mzwPzmpHKcklD/E8QCaoHS9KwR2x2Kgv3g1fQfLYbgrCxGsp9dZPjMWmuIYirWVY2XicXGuOgtxzi67QxKAXsgevUX1v8qgNZUOXaxH5fI0Zi1qgVgv3nNM6FWEwtBR40hIiteG2xq7bWnTNOJfFF79OQ1M1O6oKeHmXr/5IJInM/nbbnwP+ycBLr14aEUGY33cAHQYOabVyMKNLihSyEuzY/EkFuU01mDIuWBuHSsP2PHWA2i8cDH7FmYtSjIjJHmWgOUZH/1B9eUmyBAcZOhfXb0nDYlNjiU1G5wpiJRZFarWJkkpK0FZyecUSkpssvmMTRQSxuVJcEAKvRcK0GQkWm2Kfzxox6IUgYNeqlTUNm2HX6qRyAfLvfH9EEtBytuBPKh3fvgyLugrcsVSVdMF13IpWryRZL+uZh9ueyr92jpbmPVa3iYNlZhZ3bpl42rjwTTac2I+lrjaiffKHoK1EUDdhcyjve2pNnvVCfSZASbgdjc1lY7IvIGRw9UbaWY+FJKf9ycfvFr7OX+/9e1CCMKZ79+C2XdnXQrDgo2D7C1C//QeKdnjqIRVu2UAiSMcRkkyHgBcQUUQRhQcKgnBnZZQY/JkwadIkNmwIfGn6008/ERsb+pkhiuD4PYznW2+9xfz5gUGV8+bNY8SIERH3k56eLlmYo/jvI0oO/gIIZiX+pTG3a1u6m2JZWVnPC0d95EobsYgTQmQs28NlHUGYz2zxHgW5U91+GdOFS6XppuEZ4HIjmJ3odvuKZl3Q8QfiaODfh30P8/MzkhDq7UEDTfxxZ4GNOLubv/cwsDJ/QET7fLbgJca8qM56kT6a7eylrzSvO3s8tRhlsJ2sgAYjycC8hEpezfsAiz6F4qS7pTZ3iXPZV13D8IqrqTBlAC2TU0eMKnItkRNQxwyCn307tGLzVWGyckZnzx9vYqkXgmjjAXEmbZrt5iW93vBcFRuUijaN2ihTB3ogv4YC1KchULD7VtqJf5fIvYiIQS+aCUJHaSODdRej8qNKPESr52nw83WNuPukUnZOWoBt2KBWBVUN+uN0Ak/kCFpj8QzanS66ZpxLcX0xL/vZi4MlMvvvy8+9bwCNjsaw06EQLBk5JJqJwTGTbmDTZl/oQEjVpl9XLdkn/dvUJKZQlppNRVIqY3fsjYggbFNRygdPPIBZr/cQg26rRHaVJxjZlpchEYRutZpdfbpQ7vR87nQJdrrfeETqa99HHbCXNQJ+Y9ms5rPHePZV0FZi6jiL1R09i69ZnU18o4YYh4sR+4tDJgJHQpgiCFQkmqioaTi7isEg22nSqj1kpqz2nc7uCfkIRgjKEUlAy9mCjywzYTTUMOx634304WWFuOxWEsR23LD9URzqJtp3yuKmmy9gf2kDX+70/V63ufN2nvlwZ8jtyC2zjS2kDStShXXJfJc2Rlr26BXJvHzYU+PQ/5ZfbiuPxGLsf8ZDXQFy67oce45vZ8G8/+PiP95NvqyeH4AmLU1BDHoVf0e2bw56nGEJvubvivy+nvsT7wuIiFKb/daNIooofPAShMf2VJHbMyVKDP4MiNZlO7v4PYznbbfdxm233fbf3o0ozjKi5OAvgGBW4l8SH/fpQFu9zqNm8rurbssxTrRSguev9PKfDkXyrTgcaO+Vk4dNwzPCEoS59mqczqTW7CoAV5+swZq9hv8IgQEGkSIYMZbLMcW8YCSXyuUZm+O6Ut7PfoHHMms8dRoVrUSGJKt4JqVvxPsztb/Bpx70U8IFg0V9+g/UXsWk2nHSb/5JXGIJaqEU/J7tvIo2Z7UN53Y1WdbnFZyn95rp0f0lzjF2oK9DzwF7soKMA5iVr8J25EFJbeiw1IEQB6JIieVIZMSgF6LIsRO7yc3oRI6hU8hmuY1u4g2xbBDL0diPSqqhTkY9veMMUnjIupoGnir0PXSfzZqD8mCQ/5Zd14tghFuwRGb5Pv9SVuIjdUcU873TkViMvQThl7OfCwiEkCCrBdZoPaBY5K/aDEYqgLL2WUskSE1CCm/d+IBvxoJnIiYIsytK2ZaXgehWKQk0QZAIwt7FZWzOz6TO1SS1UeuUKiu1LshLB1FEbdPSpqyJhnQBcgJTcqt1BtJqrZy3vxgN0K+4zJMmHIIgDIdadTxxFid2lwGwUBFv4GBqTsvkTCuhPDeeUdY5XHQ+dozbPnwJuy6GqqR0hZX4shWf0OHEcZzaZIwNkQW0BIUgYEzqgqW+CdEZmTU50a0H5yli4y2K+aJjBY7GSlTaDiRwOYKg5thuN2/O20bCYOWLioLK8PcjmcZS0mxVUihKi/sU4lxkJkf2giSUxThcPcMNyYPZgEddd2npN6Q4alDpKhVWYjnW9KlkDct57avlvFt2OW1yckCtBpcLy7p1lM18AQBRreInewNHdm8PeGHQ4jUXpG5ga19A+IdnRRFFFD6o1Sry+6T9t3cjiiiiiOI3jehdyO8AFpcrpHLxdOrx+ZNgIZVfrX2z10K9Ql3356g7Mhno2Kpu+9tOIPAj/6F15OCVPy7n66G9ghJjE+3PkShW86hwJ7FaY4BVNnv7vcQ05qCzeJQnG027cWk9D2X+4/Wq8AD+eHqnFQSllfjOAhuvdfIRsR7CTwxKDNoNpbjVNk5q43A40gLqF0YKf8WkHPFVr/MRALE8mmlVJNWqMVD9WQEH9pY1JwJrQVbyymtdTlO3x6TuhAsX2AOvI7utTDG2dsMpXCYdKqeeLLE9OYZOkROEgkD7XgPJqg+si6iACBWdbEz57jq8VHR11ouY1N0AT7rwEUuTghgEJPLwbCEUudaSXfd0avCF68efgJsycApVDQWYGw+Rn9BRsZ+/BFnpbyWWY9qaadL/kVqMQ8qQZIrBRusBLI3KQCHvtJcIDVbH0L/2WUsqKX+baklKEhXxBjLqLSHW8MANIYk477GUJxhZ2SsfUdVMgsXbUetc6BOV6jdjlmdbLrvaQxCJIhZMvN19InT3KAZV6pOodOWK9b7JG0Df4q+pSPJLWW62Lkt/vfNC4FhMDl9kN39Xd4W3ls/E7UJBFIVMqG0FQp0bu1aNAHQ5dsyXhixDp+PHuGLTVtyCih96DqRJ1TJBKE809iJFk8iNLz7FivcPcfCndxEdR0Kt7oEqA53pePM587O5mgpxp+pw2ffjaARz3GW8HeeA0jL4QtnN7O+UtV0vafcd3xwdK013HVtEhrHCoyCNkCCEQKttsiEuovVC2cojrWe4LPMSAK6ofSui9v/Zt5crtxRL77NEt5vqf76P2y2yPT+LsngjLb5t80cIci8ihXKUGIwiiojgcjop2rGV/L4Dop+VKKKIIoqfCdFv118AXYz/3doCtqbIoi//WOghZ97vEFgD7pVuubRVV6PHSrrrIYWSaUz3h1hmdlK5toZt1jjmdvWsLxo1NA3PQDDb0e2oCegzAH5k4mRxJnqaMNHgqeNHGjM7tI4YBKhq/zVt/Qi5VzqoONlYy3OloRN7cmq3k1zyz6DLvqq2ArGAmUczKxTEGIDW5gn+sMUdReXSc1X1+ZxM2A+Z28ikhNniPRTSISgxCARXA/pNhwoosRtKKRr+SICVN1LcJc5lWOnNFCdk86QmMsuvTYSsXXegs2QTP7gDTd+5OLCvLGQStWRd3uMCQlvup5ekKazsR4TnYIhnWf7amQxLHxeZtVj2AFb3RZEirVjZDgwDM6k3Kh903+uRpVADBqspeDpWYme1Dcv2clxmO2qTDkO/dDTJys9fpHbdospGDtcU8eD6G6V5ERNkfghHwM3eMlv6/9FMK1eOWP6LJhFHah1uqZ2k9Nu2Oejy9v3OCbASy+EfDBOsjqG/KiqUSqomIQW7VkdVUrpivlMXT01COo4YG20qSoOu2yIx6IUgSJe8Lt5O9xuDp6e3GeYj/bwEkVnruSa9VuJgiM35mLk3AmiY87qT0viMAHItta6ReoMeu1ZNrTYxQAlYq473EYPNsGoCVbiREkfhEPLcCAIHc3MxNrmJsdski7EX/YpOepScopv4hmNUxBtDE8x4iEGd6QrPNhqX4nYUonenMmDbFsoffpiLZs8G/hSWINTo26LSFYY8Z3ljTlHWmIbNFcOJb0qw2n6EhKGRDIOCGHyw/ytkGD0hN0EVpGHgH8oxJOcivrp8CYXPP8WKhgKWDjNLbcMlVHsRaSCJF6I7MrW2Q2hiU4f2DD14wHMeXS5QqajplE+ZIQIZfhCEI/fUGg2X3juVt++7HUtd4H2QIT6RS++dGiU7oogiDLy/14VbNtBh4JAomR5FFFFE8TMh+s36C6C9IUayIn5aWs0bJypbXuks4RHxKSyHKiACkuicahfWEPZTjyrKQ8zVNyjbxDjbkvONgK0mlrkjAi3GHpJQF7QO4XRdEx3syRzJKuJxoy9m8Y/iAlKplFRjpWQxU3gy4uOWw44eK3oeEZ/CRANm4qg53MAuhoIwPuR6VRe5IQJe1RbkWcKlNVM8dIY0nb92JpOOTmJKzHTq9UYSdDHkJ4a2SMsVg1681lkfso08oMSt9hB6kQZ9+KPf/vPplusgfpAOcXtkfegF0DVmo29oR3y77lS+uRtL3NmrCRPsWNxqGypBHQFBqFRmJF3VAcATbCLgUzSJUN3fTd0IOwfLlTbTpqbj7KvSUu3UEm/IoaBRSZo+2SEbs8vFEUtTRJZi0eWmZklhwD7ULy/GcE4mSVd1QGgmyyOx6xZVNjJ61mpU+pMYZYsjJdL8Eel6NvHnDUUJhmCW5ta2kx40wtn9BHA5Iw+GiRVFRvcdDKKb7QfW41C7AmqfSUEMDoF4q0eVFWAlluHDK2/hw2au7IMnHgggCEMRg15VoKT+k47JayWOjPjxttOJTs/qflbiUNiRl4Lglu1T8/UtAN1PVrCuXccAJSCiiM0V+LJmc0YX/Nm3Gp0nSTvAYiwIGOITg5IwXoSqS+edtsQm86+rfcTv/y14hts+moPJ5qJf0UlyK0qlGogV8YawxKAcgqBGa7gUU/UPDNj7BRrRjXnVKkqmTAlLEBqTu9L/0uG4KMbCy0H7LmtMY/q6xz0TSTC+7vPIdsoPJp3venfZW/eyo97gwKUpR+9UUb+jiq9estKnqJSSouMIbUyAjxwMmlDtB0U9Q20S36X70tsHV29EwGMv9sLuzOK8dSComnDF1ijqGvqTkXUxDrbnZfhCf0SRQe/9k8p3XmtdijnQfsCgsESFy+lk2bxZIa9JS10Ny+bNipIdUUQRAorfawhI9o4iiiiiiOLsIfqt+gvBSxictNl/UXLQRAOZlPDRtoNYNCq29vpaETjx9C4r+WZ3QErr/+218vcePvJJroryVy7VvFOIzpJJYVroh4lQtQSNqhS6oELTpCTK3hf+Kv3/dtGXWNv9GP5Aw0B+vI+IT0VMMn6mupVkgltq5dA3PxymFlyDzpxDTGOORNB54VBbmJv9FYc0cVRneJQ3P0W2+xHBohawG0pwq23YjR6rXKRBH/6o7/YGByihdHcWLu18KbFT7ThJfJWvwG59yiRc2hwe5gXStBZUbj2GczKxH633KPBcrVdghEK4eo4tEYTt+wxU3EQKahXJ4zsRP7qtT7UXp6Oio42bvh8P3wRuX25Xrc56MSCo4KlCnz1x/eBuLRKENUsKPepF8AhVZASVd37yeF9dxJaUeYdrilDpA62eranBJ0ekBJxeCLTX/tzIi89j6dVLJcuz/NxEkqIcETEIHNm2GdUHDZgiCFxWizFSyEH6JUP5/LyTQdspghi+zyLeqos48daiDyTIK+INlCcq1bn+qsBg9tBIiR8vOZjorGPisYVUm9z8EMEpbtAbiLf6sWaCQEWCkYpEE9om5bgf02fzQ9qooH39s/ulAfPkwReSxbhZHXzpvVNZNm9W0PPrbyWWw3duSlE7SqXPeJNOz5gde0ivt3gCXWhdOIroPIKjcSlaw6WkVe2j574vUInNKkVRlAjCsTNnYt01kGNmUapBaEzuyp/nPocuRkdDw2E2bQ5ODtpcyu+bHhcdZoD6aWyuGEoaM3lz98QW9xNg394unKzPJLG6plWW4mAW7cKtm6hotFGfYETrUhKxoazE/ghlHZcnF3shJw89FmPfZ83dlI7aoiXe258AZYkmdsb0JM5pIvf4Spp27gyr8AuG/P4DufLB6dJvi39JB39SIxSiZEcUUQRH0N/r5oC539NnZunSpcyaNYvVq1eHbffee++xZMkSlixZ8ovs1/8SIh2jKCLDr2U8Z8yYwSOPPII+yD2yP0aNGsXkyZO56qqrApbddttt3HTTTYwePZpbb72Vvn37MnnyZF5//XUaGhp46KGW+YDfCn7736j/Y/ilLcZeUiXJtIVkoIQTiuXZnKC9C46QrZjfu87N52vMWLQqUnqmKsgOgyGfIecsp+yfW6BKQGfJ5JhB4KH+EdRb869D2KxU7FCdwsebj+LoauS4uoFpBl9dOKtKc9pElz/qCW0j9odLmxkxMQZgrOyNyqVXEHRe/JSxgqOGbcRr2lF9Vo5EiUpTDUKvRxTzvPZlK3pO0SYwhbgZd4lzySwcg7YphXZNDbj7lUjrf9dTDfqRrKtp4Nn9Sjpzxv5k2iOQ47gLlVNPYo++JF3VgdqlR0AQyLWInmtILVBkUimUjk/vttEtP4nsMe0Aj023oNGmCCSZla8iRzzJqaJnpZqD8jAOXd8sqhbtx3HSHJIgzM3uyZX/92jQm0dNsp74MbnS9ImqfRGMdGA4jT8ONloxu1whg0mcVVaPYjAURI+qMX502wCLsT/kVmJjENLmtGrw4SPgDtcc5nDdYeZvVyqPL423k6n1EBz+9tpfiiAMhmApynJESgwCIIocXn+AjlzDebfcjK3pqOJYMzf1pu1fn0StNlI97R+YV60CoGb7BujbMvkWZ7OAqI048dZgs4FOB3Y7+p49sZ06RWp1NWm1ZipkRJW/KjCYStBer+PwV23peMXxsNvseMVx9n3UHnt9DAnOehLqBFjXg2XZ56PSlROb87HUVlJnyVSR/vBaiWuMiYr5oYjBSGBXaQPqtgWt8yaKIW3d/pB/xg/n5pFZ34gzppY2FaVUxBsoSwyd9h4MbkchpuoflMSgF6JI/apVFF19BV1OluPs/mfKEnqSJFZz/Yv3oYvR4XI6Wfn6vzh+qAPGZCNoq8g7/6RkJd69sauiy5LGTLKMpejVTWQZw3zX+GFRnzsQjRpu+2gOSUQetuI/rmWxCbjtWjB4xj6+URMyodprqdc57AiNzqChM2dqMf425TLE+FRFrUqVpgPVWZdTB2SUb6X22+/YunU9lvraiLcjCL77Gf9SDK8M/4jqz5dE/F3zeyM7ooiiJYT9vY5+ZqKIIgrgqaeeYvLkyRGRg+Hw1lvB6xZPmjTpjPr9NSL6bfobxBXi5wxmvSLIoaqTx2YUS5aibUGvDymhAcfBqcjjZItMKvLNbgxONx0MgR8421dN6I77+oo0Dfe62hoWD8/whI+oVVgKHRxQuUntm05W/z7YTBrKq45DkS9RcV/uIbKbbcH1xIeu0xcBnK285P0VYr75OTh17YgVfWOm6amjMO6RoO3btl/PVKCUOqY0zxMandI4+CsrLzth5+s2ygfs69xWFqt8BNsE8T0+FG4FYHLvNswWsxShKEDAdDBkc4L8DjMASDl4PRWyZemuIxgQsMXqEQXldTCoVzuym9JQx+kw9PXVylObdNKNnMfqHPhglG920dsQS3wYhV3vlI60Q4W7yHcMijAOA6Tf1Uey56pUaoZlXsX60iWctBSQm92Tq2f+LeKbRpUzMrWI/zj44097jkr/B1MRWnZUtJwwLYBle7mCvPRHKCtxKJyOxXjy6slB5y+TqYrkYTT/bYtxS4rHYKEhYSGKHF63nx7DbKR3UBKSzlX7qS1+AwEwr14tXfOxTZEpZttWWbCrPNfmbR/Nwa7R4YyJ58Mrb5HaTH9nPnmlJzHYfDUH9b16oUpORty7FzWgtWkpT0/DaLCQqqkKCBjxTvtbjCNXD/pq8QEkNapx23IC2rVkFQ2XPnsm0LkdtO9/DpffMwXLjz9iGjECFTC672BEp4MjO7Z62jlcESvW5J/xr8dcx9fNQsX3m63dGbXmiJWDgKfG4N4gxCDNSsTcdMoSjWSnJtKl+i2y7J1ILTxC+cMnyZr1Ikvnz25+QNZhr3cQm6pVWon9IFcKPtj/lYj2EZBCwVpSs3pt69UqEYtNHWDRXtGmN+70dMad/I429TZACFpbsDgpj8WX/FF6aRiz1lfHQ07keS3GVdokKYAkHJIa1VyzOpuy2AQPMehI9RxXc61KlbYDOtPlJGbGcfFfuuP+5jpW79nKsa17WybyZDiybbNETjTY6hXLbv1gPbeW7MIYaX+iSOGWDRTt2ErHgYHKyCii+D0hohd5Z5Eg/Pbbb5k2bRpOp5OkpCRee+01tFott956K2azGbfbzbhx43jmmWeYMWMG+/btw2q1cvDgQTp37szMmTOZMmUKRUVFDBgwgEWLFqFSqRQKJICpU6diMpmYMWMGM2bMYP/+/VgsFgoLC8nMzOTTTz8lOTkZh8PB/fffz/Lly0lKSmLEiBHSvpaWlnLjjTdSX1+PzWZj9OjRvPzyy6hUgb9vH3zwAfPnz8fhcGAymZg3bx59+vRhw4YN3H333bhcLpxOJ3fffTd33nlnq8ane/fuFBQU/CrH6IUXXmDhwoWoVCpiY2NZtWoVBoMh5Hjt3r2bO++8E4vFgs1mY8KECTz22GMAOBwOHn/8cVatWoXdbqdz584sWLCApKTQpaN+a+MZDM888wyLFi0iJsZzX/jFF1+Ql5eHIAg8+uijfP311zQ2NvLkk09y0003AbB582Yefvhh6uvrcblcTJ8+neuuuw6Ar7/+mhkzZmC32xEEgQULFvDuu+8CMGLECNRqNd999x0rVqzgH//4B3a7HbfbzTPPPMMVV1wh7dfKlSt59tlnqampYdy4ccyaNQtBEEKqCmfMmEFtbS1z585t9efm14ooOfgLI1iQwdnGYNaTT1HQZXI1mZk4n8VWKTxQqLx+7BSv0Ns5q6xYdymt0ZFaSD/JSfPbjvcSbIQDwYux+9uCW4u7xLlkc4JYbBHX4ZsgvsuHwp+kaX9CyDvdacs9dOisI2lMV1yuRgq3he/XO/4nGzN5dZ2v/6bhGQqC0J8YBBTEIEAiSjIr3LGFU17Kl1V0+VixzKuUKkVpMf5X3x70yOhEMBj6plG/vFg5z+/6MDhFDP2U4Qv+gR4mtRoNSrLH39IezCJ8seE+yjUn6DBiaMQ3ixZLESf3TuTRTAGbCGUOFQurfUTHzclNZGjdtOn+DulJAwNUjq90y6WTUc9Jm11BDgb7vLvMdmVyazAIgqddGDQ2eerAia7ICvFHahWW+m9F3UEvQoWl/FyQW4zlVmKLpQinq5ETtRrcqiyMMRryU41BQ0PColmR1q5Hb4pn3AWybBKVFRq//z5glawa+MfrTqw6OJEqMP9K33V980oXPYpFjqSlciI5gfRaM+l1jSAIZNSaMbpjpRqDAHmlJ+l8/Kiif9vu3Z5dA04aU5k2dLK07Llzn5YCJaQ+xvhUzHKLcaTkoH87L1FTY3QpLMYtEW9nI0REjgvLl5PZVOEhkFwuTk6ZimXVKoyjRyMA9d9/T2PnXNBrQBCwa9W0rWhi1utOduelcCRTw5p+PnWcVw0uCvqQL4V29skg4+ApellKgcyICEK9O5WRezajCUUMNluUdfF20m8sbf5W34v7SS31q1ax9o6JnHLYFNery64OsBKHgknXyIP9X+GlbXe33LiZpPMG4+gcdpLqlApCr229wiHwWmlwJ4RXUboiP3RCd60mgS8TLyXmJ8/1au+brFjuf70kOuvC1iEcW76CJEeNpDK0ObNw25IkYhCgRpuEStMGg34kyagZ/9AAtDECX9WVc6z8VKuIQQBEke3713Ly5YeoUNdDom+RSleOduxJrD/EEFsWgaui+bsmv++A1u1DFFH8xtBahf+ZEoTl5eVMmDCB1atX06tXLxYtWsS1117LhRdeyOWXX860aR4HRnW1z/ezZcsWtm7dSmJiIqNGjeK2225j+fLlxMbGMnDgQL755hsuu+yyFre9ceNGtm7dSkpKCjfccAMLFixg2rRpvPHGGxw8eJC9e/cCcNFFvpuPxMREvvrqK0wmEy6Xi3HjxvHJJ59www03KPpet24dH330ET/++CMxMTGsWbOGCRMmsHfvXp5//nmmTp3KjTd6AuxqakK/HA81Pnv37mX+/Pm/ujF6//33+eyzz1i7di0JCQnU1NQQExMTdrzatWvHypUriYmJwWq1MmzYMC644AKGDBnCiy++iNFoZNMmT63yp59+mscee4xXXgn+Yu63Np7BUFNTw6xZsygpKSE2NhaLxaIgEgVBYPv27Rw5coSBAwdy7rnnkpiYyB133MGyZcvIysqisrKS/v37M2zYMBobG/nTn/7Ejz/+SNeuXXE4HFgsFl5//XUWLFjAmjVrSExMlPb7xhtvRBAEjh49ypAhQyguLpZIyn379rF+/XocDgcjR47ko48+YsKEyF5ct+Zz82tGlBz8hXE6iaathZm4sMu9arIiIrP/7dx2ikZAfbCGtmYXznJLQJtwFtKzCRMNraobCBCDTSJLS/2Uk6EwgK0MELf6LLnayRIx9qCoYlBTPvEaHd1vu1hSzFkswQlZf2RSQpPL7zpwRWZ3k6MW5Vspy9E/Y6vXotWVou46N2CbXlLYSwZ6/49EXSi3GIeyy3qhSYnFcE6mIhFYfn0Y3CJde2QEWGblwT2+bbQcxgGBFuHECK9tL7yKN1/qtPJ8ZGjdtNWJnJOUTHxc4IOeofmh2uJ3Hr3BJfIxkysrQ0IUPe3CwBjj+foWHamYD09FUDcFWD2tJ6/n9esvoVNaaqtTiyMlE3t2mkbn9MG/WM1Bf/gfl8VSxE8bLpApqzz1976fOor8VKPPctqSgrD5Yf3ye6ZQMvUh7Ks2kr5ei1svorIJaCpCk0JZ0v2C8jwvHKNm4jcpqNyesS1PMJJe10j/ohLS6y2cSlOSUgabDTee2oJpzTXv5L36J/m2RBjJLcb2eh37PuqAPqkJY1YjGX18NznFK7Ow1cYEBpo0I9FZR2IdpISwigZDa62hXlzu+A9mp57VsaMU8wUE7CottZoEjmzfSmN9I/3wELYS6dZMDHpWEKgzxKB3ZHDRjjK+7ZvCGll/XjV4OORcc4IqPKR8rydLUaf3CiDufDsokKJJZMC2LS0SgwhCgP3boRfZl5tOWZNFQUDWahKw27Q4v1VDQtjdBUCvbiIv9QTPneupQbh3e2c+a7pKWm7vHA8xKtCppRdUX4+5Tlp+2+JPSara4dmuSktcTAMQPIgrGLwWY7lNuCYhhbIY5YtCway8Pmq0nt83f4txqDqESY4a0u2VYRWqPjLRwW31Ko7vK2XTkjmUHj4U2cH4od7g4PPzTgGBNUZjcz7mQzMwAC5Y15U2ddaANhL8bPFRRPF7xuko/M9Edbtx40Z69epFr169ALjpppu4++676d+/P0899RRms5nzzjuPCy6QvYwYO1ZShvXv35+YmBji4jzPXv369aOgIFRAnhIXX3wxKSkpAAwdOpTdzS//Vq5cycSJE9HpPL+/f/7zn3n77bcBcLvdPPzww6xduxZRFCkvL6dnz54BRM0XX3zBzp07GTzYNybV1dVYrVZGjx7N008/TUFBAeeffz7Dhw9v9ficPHmSkSNH8tBDD/2qxmjp0qVMmjSJhATPD6h3H8ONl9Vq5a677mLHjh2oVCqOHz/Ojh07GDJkCEuWLKGuro7PPvsMALvdTrt27X434xkM8fHxdOrUiZtvvpmxY8dy2WWX0aZNG2n5bbfdBkD79u0ZOXIkP/74I6mpqRw5coRLLlG6Aw4ePMj+/fu5+OKL6drVo2TSarXS+fNHUVERN910EydOnECj0VBdXU1RUZG07sSJE9FqtWi1Wm6++WZWrFgRMTnYms/NrxnRu5BfGHICxF99dHNyIyer1mDEQ1QsDZOkGw6ddk0giyGU9H5DmpdScA0CUNnJl2KYe2AcdGu5v3vj7FBwFFTw+e5Gcs3BiaxQFtKH91p5ocfZIQtjm4m+2eI9bGAoi4WbWlxHvkdykmwfPSVbrhyPiE8FJcy8apILBnamdzCCSJYqa2ksVNQnSy+agKrBxHFVE6dyV1LSqCQBBLOTa8SP+VxzY8jwFn/47/tz+d5aa52YLX4sHUPmrjs8gZqy6+F00NFowmCIQAEBQROBc60iiKKUxhspfgnCyV/xZnEpiR9v6Iy3nT/JL1cLyiH/fHstxsGUlQEQCVBW+iM/1cj3U0fR2OTkcLmZyR/vCGjz+vWXMCwrGaerAYulqFVjGS74w6uk1AvQOX2wz+r9PwAv0etPlFVWVnP8u8W4nU4S0sKPrT8xaF61CkSxmRCMMJ4WiA0i/qyJ05JS7yOsyhOMCEB6vYU2FaV88MQDWPR6DDYb2RWlHgIp0URGrVlKVz1lTMWiieF4nPI4vN8renVTgIIQgqsF2198ImCerTYGa2XL39ktEYJyhFN9XdrwDQMv3E2VNYlXdt6uWG+p9mIIshn5+rcc/xDiRbbnZdCnuIydoQJDBIGyBCM78zLoXVyG/Bbo2q8/QueKpyopXUGOXbZyMXpLMTFx9aiHlUr7Ej/haq69aRpfL3g5UOES4vrxQqEYTHCg1rkC7OB7+qdgblCjczgkgtaf+Bpf9zlGjYUGUzz/Fn2S0/ExS+jR75DiOpCuh37wmey5W3fIZ4dtGp6BSleJINokBWX2gPGUrnHxQabvJrh949PodZEFq/nX+/NaiQWzE91uHyGtPdygWM///PqTgv5ks3c6UoVqEy6Wv/kc1rrwdTfDIdIall9kX8itqhUYawJfrEaJwSiiUOJ0Ff5nW3U7ZswYxo4dy/Lly5k/fz5z585l2bJlAIr6Zmq1OmDa6fS8RNJoNLhkDhKbzYbJ5KtZG2o9fwiy37KXXnqJ8vJyNm7ciF6v58EHH8RmC3QHiaLIH//4R5577rmAZZMnT2bcuHGsWLGC6dOn07NnT1599dUWx8Qf48ePZ9iwYb/aMZIj3Hjde++9pKamsn37djQaDddcc43UnyiKzJs3j7Fjx4btPxL8VsZTrVazYcMG1q9fz+rVqxkyZAgfffSRwqrsvy1RFOnRowfr168PWL5///6Q2/LHDTfcwMyZM7n22msBSE5ODruvQgvuDznO1ufmfx3RO5H/AkKpria270dS8hEOFcygiHyWEpwcnJWvInX3EQ6WqhC0NRzN3a4giopj9bhjs6jHV4POVNkbUJKDWmvoB2RvinGJXhk0UhdbBebgdRTshlLcahtabRzy+oWDq12hgyl2Wek3tgO6U40ctNq419gU0O8Th46j6/QPhcotkxI6cDjk/svRVhbC0jbtNqgIXnT0LnEOHSgMIAb9Lbnh1J+hyJfy/A99SqZTgTcwut01fM35xFAWYDE+HcgtxrEN7XGrTi/QRR4A0hpiKVQisLw2oT+OWJoYttH3AxBJ6i/4LKRnolyTE7uHyjfy2tq50rLnB/yRkXkXK/qXk/z+VuJQ8FqMgykrFRDAMDCzxTAS8BCEcvhbjNuYbPy0wfeQ3drAkFBqQ6+SEn55K3EoeK+DAycKKa5vE0DA7yo6ROF3a1E7rCS56sNYu8MTO5GiJAmsOrhlpYsPxvi+M7z12SS1XTNhtT0vgz7HKohxp5F9Yi+Ibp+yDKQ26ZUu7rgweG1Tea05r8W4eGU2thodLkegCjBYWAlEbjluLUKpvlJVVeTFn0CvVn7/39T1YxYduL7Ffr2hJGUJRn7olkeTVh3a7tvcDjKY/XoZu/JSmtOVG4FAK72RI3zfZw8Ay0tjpRqbWw+twD7zOOdP9dQdkj/IxsYl0PXc8xC0WtrMncPxu+6mcY1Hp+hPDMqTpeXIuchXf89rBxf9TAE9LjpMXvwJiuvb8O8NPnKwR79D5MUHkr5AwBjLobKXkFw1XZquznqRC68/j5WW4QpxnM0VQ55W5NFMK0XmDN4+eEmAYtltT0d0xSjq/flbiSNFMMJPTjbL1YWRKlSTjBuxHgs+RpEi4hqWrhjaXFxG47IY7HWyz2CUGIwiigCEDJUKhrPwGRoyZAi7d+9mz5499OzZk3/961/k5ORgtVrp0KEDEydOZNCgQQwbNqzVfXfs2FGym1ZVVbFs2TImTmw5Pf6CCy5g4cKFTJgwAVEUpdpq4LEyZmZmotfrKS0tZfHixYwfH/i8eOWVV3LTTTcxadIkcnNzcbvdbNu2jYEDB3Lw4EG6dOnC7bffTtu2bZk+fXrA+i2NT05ODgUFBb+6MbryyiuZN28e48ePJyEhgdraWuLi4sKOV01NDd26dUOj0XDw4EGWL1/OyJEjAbjqqquYM2cOw4cPx2AwYLFYKCoqokePHr+L8QyGhoYGGhoaGDFiBCNGjGDv3r1s375dIgffffddZsyYwdGjR1mzZg1z584lISGBoqIiVqxYISkmd+zYQffu3bnooov429/+xoEDBxS24oSEBOLi4qirq5NsxTU1NeTne55zFi5cGGD99R6j0+nkww//n73zjo+izt/4e7Yl2d30TmhJ6BBq6EXA3uBU7hQV26mn2LAinmc5PbuC5ez3U8/CeZ4eKnoqVUHpvUhNoYT0stmWbfP7Y7OzM9uyCUHwbp/XixeZ/v1+d3Z25pnn+Twfceed0ecYtOd782tG7G7kJCKQZFI7K9i3/xEgco04e8ld1BnsPNnrFaA7MESx/M99ugHdgFd4XryVHI6hcocIFSG8MiTB5f0xtmuUD1gbhn0GWy4m2ZLWqhT0wqGvpHSC/4H14w3P41Rnk9Y1iSyb2EqCBP/AF2q0OD7ZR6NGoNGohqLgdtar48mXEYNdttyGqG6BwW9KISVx2Vczv1pZs+jlZh15W+vJEe7Ao2nBrWnm8Ijn/H0MGONAYjB3+43oLF3Id8fzmcqCZ0gGXU7vGRVhFYowibZGVEcsxoHovfFW8pzNqNzxGFJ7YaNj6ghFAEgHEGj3jYTA+nzR1Of0WUh9OJ60XN92YoPSHp6d1DfkGPjOg2hLBcjXC6WsRPR+T/TF7VNWQrDF+K1rBtE7M4NUoVlheOtoYEigxXjMsPfook8+aVbiQARbie8LWuex7+2QcxEAv298j3R1XbBtVvagYf3hB8zLlnWoPcdS4Y6bQv+8rhrqr+Em1WNrJax+GNQTMe0KMmq347QspjpJr7DFViUbqEiIjoz1XW/sDTpsdcprvS9QIlCtdmx9BraGKK9Tx4FAAkfj8L65zjbUSPbXSCRW2P0JAi26KG5rZATh2duq2T48m0q8xwtMj+4xoQz8PJ1kp029sJ4jrOHI1vPpNfovVOzbg6016dZmauSrF5+mYNhIpo4YR8bsm7GsXo1HFCNaicOhKS6RZl0i5jjlZ+8jwM0O5fxIY5dtqAlLuqqsyuvD011TaGlykDg8HY76z1u5QrWHzo3HoXzR6HFkBYXW6DzODtedDEf4hSKb26pLmKNzkdc9D/P2DUROhWobSVYtZ6zuy+d5Z4Us6SAnSOPVLaQXDeXAjyXea32MGIwhhrCIiiDspO9QZmYmH374IVdddZUUEPHJJ5/wr3/9iw8++ACdTofH4+H1119v975vvPFGZsyYQf/+/SkoKGDMmDFRbXfDDTewc+dOBgwYIIVDbNrkDde64447mDFjBgMHDqRLly4K66kcEydO5JlnnuGiiy7C5XLhcDg4//zzKS4u5pVXXmH58uXodDrUajXPP/98u8dHEIRf5RjNmjWLiooKxo0bh0ajwWAwsHTp0ojj9eCDDzJr1izee+89CgsLmTp1qrS/uXPn0tLSwujRoyUV2ty5c8OSg/9t4xkKTU1NzJgxA4vFgiAI9O7dm6uvvlpa7na7GTZsGBaLhZdeekmyYX/11Vfcc8893H333TidTrp3786iRYvo1asX77zzDldeeSVOpxO1Ws3rr7/OqFGjuPvuuznzzDPR6/V89913vPjii8yYMYOUlBSmTp1K9+7KZ9D+/fszfvx46uvrmT59elhrdCi053vza4Ygih2QRJxAmEwmkpOTaWpqIikpqe0NfuUosbZINdYy3PvZsGG6tKyS3ODgEOB58VaO0JX5Qmj1iBx/27af/ibQWb038w59JeUGD3YSOKLJPK7agJ+tMksE4f7MCg4Oe0tS9/VY8wiZoyaRNLWblCaLAIcMKi4e73+QeWWDhVtHRvewu3DzXnpYVOisOdgTyygf+4i0TD9gERf9rHzQ+mCNhX4mP9EW2Ebwj3Go2ns5228kwVTgHTsBks7oEUR0lZvKwwY3uFoqiBNE4jY2cNAwL2K6pBxtKQevEd/AgjHIUn3zPjsFZg+FFo/0uRzVVmNT20nKTielphmP2o7KHU+L4SgVw14O2nd6wwXUpS6Wpo+HbIsWvu9AuJCPSDUOTc07Fd+ZkSM/7zCZ6fss91Sv4+H1L0jzHx11F/2yRisCLzqrD656e9TKyrZQWmvB0uLCEKchW18d0t7eUSUo+Mcn0jicLPjOg3JTV/68NpgYDMRDY56RlFXykI7C4jHSg4bodHJkzp0dUg6WZMP917X9sHLh6pyghF9BUwCiiOgqDelgblQn8X73tssp+JSD8v6BP1CiLQRu19nw1bDTeZykOBsZ2nyUmkw91m4qepzuvxZvXjqQ5mYDtZ4Mvk48R5ovD6AIp0iMBn3iEjkSr8LapKyJ12B0E5doIrt4T8hwonjBX6N076c9w9qwsxrNTCocSNbNN7F+9h/Y2MX/EiuazyLa3427hv8Vo84SZCn/eO90Lu37ubSvPfvy+XvNlYptBW1t2JqlgQrAQDwx/jHq3R7ekNXUMx+4B9GZwfm2r0ltaURo9pJ27UmsPp7P13duNauNinTjS49+QpYjOjt0e2BJ0aM96ygfmf0WbUvpbfy+9zJyDZXSZ5KT8Cz7V+/m4Ma1imtNDDH8L8But1NaWkp+fr7C2hgJYcNJYuR6DDH8KiEIAg0NDZLSL4bOR6hrbXv4tdgV9SSjQB8n2eGsFuVDwoRe16DTZSJ6HEzVqqkzH6Gi9C/kcIzDdA2zRyVSTbnoZAq/SnKZOdwYYYvo0WSox0EL5QYPM4f3BbyqvPvFR8k1VODpX4etxaOwl/Y3O/hOVOPI1eP4ZD9WdfRef7e9Kzqrl+yTKyEryUXv0gHKgt+lBhWI0KgFm1rgXlkbfYrKSGEcla01+vJXP4XOmhNUA67cVM4F/76gzXZ/lfkh+aufoofazlsZ+zjcaxHHLDkKC+ANRX8n11BJszoJg97GVnEY/5KRfzNLWxjR4Oae4XreFf4Q8jiv9fGOyWerzICXGLy+1yPS8redj+AmH6taQNCYQ+5Dn9+dLt1eA8Bo6P2LEINyK7Ecoer1+RDuO+Obbi/5FemzlBOFiy9aHJIYC0de9jbEh6xP6UN7lJVtwWcxDlRTyiEnCjvLYnwqwKfUjVZtJl/Pp94addHvGDfjculBw2cJ7QhBGKrWYCiEsiWKrtbU9jCXxhS3iVmHPgSPmip9Ot9lnSkt8xEqBr2Fxv8YqHMmRW0lDoRaG916HYWC8BEESlXp2OJU6AOu44YmC6paDy26OORZW74ACgmiiCCKiILQZoKwb32doGJfSzMEnDZqZyU/DGlNea5XfrflRKHPYhzJhl2dbOCHkt1Meu11Rn/8CYevvUJSDvpCYXwqTnmytM8OXhOfDlFwtEadRSK8k3IfR6PLR1AZuLmHhfryz/nZlM4LW68LKj0gaGsx9nou1C4VRKGP8AtE6ZqupDY1cI6mC5+mnqcgEkdM2UmPpCMS0ZziauK8yv8oCDsfnL0SFXUHgz7fKBGJgOxoKE5bMDRasa2Mg2L/PNEdR66hEjZ4aGw0Yug7kX6zp9Fv5DRKt24if+iIGKkRQwxtIKSCMEYMxhBDDDGcMHT6VdXtdvPII4/wwQcfUFlZSZcuXbjmmmt48MEH21X08X8FkR7kDxx4MsTcXErJx0H4t24P7TtMvlkMsv4C7SLj2sLeYe9wlGbqyAD8KsanhIfJHHwrx/Z5ybWxY5aiT8uXSJBUwLTsECabyKF2CBdLjd4Hab1bpLs1h/wfn6J6XDp3q9Jgf3ASYCRVpGH/5dDbLwfOXHYaCQmT8egsuHQmiRgEvHUU84w0rzriTZAdYAOjkyZzZVTttvQVSPzBq9zMB1QhakHlGioVNaK8Y+rH8AY3OVHGQ1rVAodxsVetLH5eliNyxwAfMTyM58XcIHL0cOOrHG70/j12zNKojnc8iMY6HLjeiSC/wqk/27teoMX4l0gnD0S01uGOWoxPRchrRvbqdZCde18IIuAfOz+B3tnJ7PvhQ4WyKqd/BpU/12I2HQh60FAQhO2wGGc3wA1fplCZEk9jolNhJZ64NZ0UszaqhN9wSHGbQBRxOJXnl0SoOMAWpmxEtPUE1dZfzlSgc7iwdVExYGZJ0DJfe8MFUEgQBETwEoSt0xEhCDjC2EqjDZrYu6QLNU3xkRWWgkB1kp4fSnYzbs6dDCuvUliLw21rb9Rhq41HneWOihyUE96F2f1ISxsGeK+XXxwQeKPJhiHfqxaXE31ClIS6oG5BDMGtiSYRW20CKl0KngSlldjXJrXOLan5XNq84J0AolZJlHeUyAu0Lp9X+R8S3WZJgahQrB6H4jQQCdV6yWIstxI3Nhrp0nMyF8z2ExkdSVSNIYb/VSgIwo1rY8TgCcJNN93E2rXBKdFr1qwhIaFzQiX/l/C/MJ5vv/02r7zyStD8l19+OWz4yClmWI0hBDr9yvr000/z2muv8d577zFw4EA2btzItddeS3JyMrfffntnH+5Xj2ge0MPZi8Mh0ZxOUY2bUPV09O7ovpTP7t9KS68PqKArrwpzFMtmi/NJwhSxLQfx1kzL4VjIPrrNDm+CrVXkuc1W7hnedgqunOz7bJWZ7pYc4voWeZOU24kKuqIjX7ITaxtTUeniEZxwSGXnsKmrZAVyGCpobgbV9gRApFRm587QxFMboSh5tiMd7c8tqAxaPBanpHgMVDgFTndFSSAWWqKvQ1giVvBUfIPXIiabf2CYA01zmZRCaYtAMMMvQx51pF7fiSC/AmvqdXQ9eVBJJDv0iUS0ASGnSpBIZ8FHBPfrCs3Hggl4Z92jWJxHyCtQzk8esJHkAQBlWK3XBhHKglZL3rPPcOCss3HXRqdkqknS41Qnk95MkAIwxawl3RRHQ3I6VRk6dE4HqU11IfcDYNI7cWo8wWSiILRNmLVCQYiYmiKq1XrsMlEdb8TsSfC2XRSlRN2gGo2dgDiHixatmgSdsu1ly3KxVuul44ULoFBAELzKweNEtEETnroEHNEQvK0E4U9N1QwHxqblsrWwK2X7/arpQNLW7fCGqiS3mLhr0l95YfMtQbv1Kc4DrcRHd+4lbZKXHNTr8+nR+1GofMrfHBnRF6gkDAf5evLjHljcnYMJPanXKWv+/q73v7G746iyZGJJNvB+YmQ7se7nJt7//ShS9Tpqft7G5rc6ZiVu0CoD0+p0aeCAdE9DkKowVAry8aCryc41qqV0PbdK+kwMfScqiMEYYoih/fARhDHV7YlDR+rbxRAe/wvjef3113P99def7GbE0Mno9KvrTz/9xPTp0zn//PMB6NmzJwsXLpSSc2JQoq0H9EpyuVsIZuUjIfDRSCMcJl61HrN7Ot2tGj7ecJA1xZ+wIKBm4WxxAV044iXMeh2jklzCxakeIrIV8lXBm/5zv/goY0P0UW3UcSgerGoVNk37H+asGgH9yGyS0zr29uXPfbojtxjndS+kbKSsLmCtt27ZE+MfA5mKsMuW2xT7iQ/TdLWoYnblZZzbOB5KbHhaH1h11hzJYvxG5s8cLfwy6MEOvKTq8+Kt2Iin98Zb6W5NB4iY+pxv9tAsVPFQtz8T6qz6x/4n8T021ec+S4XGa00PVW8RfhnySE6mRVuv70SQXz2SerD4osVYnBZKmkqYt2qetOzJiU9SkFwQda29k0EIyiFX0TXUr+XAQb8CuVfhPFLTxpwyQSInAhXWJg47BKwB9tRoLMdyQll0OjGvWoVhzBiO3nsf7rrwBF4gMk1WshvNVCUbgogmrUtFQ3I6b8/0J6Rdv3A+qU02UGeD2x+IY9I7+Wyyn7yTAkxaEQ1hFpIQMYUmRBIOu6mwpVKtM0jKu8BE3c6sRahPTsElVpGgcwaFowh4Azt0SQ4FQRgRrZaz40WSVcvFK7vg1HhoNCqVn76ag0e+6k5Ce5SfgkB1a+J0D08cZ977EMtef4GSzRsAFBZjOQnrMMXRsDwJUoJ3Ob7ocobnF0rXuiX/t4BD236muc9+iib564TWkazYbmzhN6w5eA6orODRYyn/PXj0FPVaTYl7i7TeX4b9mV55fTla7+GGn8ul+bZVGuxqDUdc2fxf6tWEwj/3XwT7vX/fMuQt2Nb2EKXqdQzKS+Y/izYCEG9MxG5ubmOryFbidWl+ld55lf9RLGtPQEq0ikNDoxXLV3HYddpWYvDJGJERQwydALVGE1PdxhBDDDGcYHT6Hcu4ceN488032bdvH3369GHbtm2sXr2aF154IeT6LS0ttLT4H9pMJlPI9f5bodfnM3TIuzic9TQ1beLo0Q+lZXl5V1CpmgDBIpiI6OauBrxkkkY4RKZuLmqhGZ1qH/XOu+gv/pX9BCsjunCEfLwPppFIyUAlYSQ8JTzMNLoQINahsn8yF6s6XvswrX8GcWd4Q1w+LzzKjgPzQ6ocAyFYXN40YLVKCv1I23Ifmtab/cBE4cBph/GoYrqPoAetFbuIQkE4u/Iyzmkch4Dg5VdlMmpfOMzA5p70dBs4Uhxc72nggBfoIsazsWon/Qv64mioxSW6WR+/nNHmIvLpolg/3+LB0OzkSHx0ajlBtCvGyleDUepXn0ej2k9nINp6fb46gxq1QSK/OjNwIxzxV5BcwID0Ae3a18mGr++WgJqMurjM40qfPtVRbirnt9/cBCQANv52rZ5s43BUnmMc21/T1uYSySKFkSxbhjojw0sMtsMKoQLJPgoGiWjyqf+qMpTkmkOXhC55JoKgxmlZjMfp/dwC7a3StIwEi0iYiWIQASKfDlSriQ4vgSUn2AJrFEZbs1DeBiCItMvp1Yf66p0hrcSAQtEYFSHZScSgD+Es3/bvc2huiiehIwSpIFCVYiSvdCebb7wVhiuvUYF9lNRwDqUazodmawpbv9yIx+VNey5ZU47HpaN06yb++d6zPMbfQ2633bMfQ/5+xTzzgXvYZJxGapOfHMw9msyAwQNIEC2AnxwUmgVsrgQsOj2EblqH4Etdzy7oRXrX7gw790IWL3iakk2RXy5HS/KZUhIV0z6VoYLwEwSyC3qTkGikbOtmIAzBHuF75zDpKBgxigtmPxAjBmOIIYYYYoghhl8NOv2u5f7778dkMtGvXz/UajVut5u//OUvXHFF6HTFJ598kkcf/eWIiFMNVmspW7ddI03LLcSlR39iKzaQBVOcI35BAQdpJJWPBP92ctVfnvMPQDoa4TCZurmo8BJGCaqfsKU0cDTBQwX9g9pSR4akImvLctoehKorZ3FHb5OV4znRwKj+2XRNrlPUnYuGBhIsLuJWV0nTvlTgZEsaFR4H5aauHLPkKLbxTfvUfbW9P1Msn5ZdL/39+DGvxTjHkc65jeO9xGDEBoHaFZogrffEceP3j9HkaGJL9yPcO+L3/OXYM6xO2sI/M77jzuq5il7b85O4ftshBLeHaChX0a5R1LEK/Lz37fNaxn+JtGIfItXrC6wzWFT0mjcwxVCo2EZvKDxu8ivQOhzJSiwnLE8lJZ6vXQ6HkhBzOGowNe885drbWQisCZmbkc2A9GQgmZ7p4QnlhlYiXhvfFdHp5PAdd2BevgIBorYSByKQIEQQJCtxXaoy3Kgp9xJ0ZgGdUySNC6gV/4lDLKPRqLTaNhqdIILWJZBki0xOhbNZKgiRVotxnODAYHJS6UnxKwaTHJL1WA7fdFQWY1FE53STbLVT4yMdW4vJn3fbPXzz5n1A28nJbRKSnUwMyhGo/IzaShwKokh2k4Usk4Vd9TvYeqACrT507clokn1vW2Tm6mMrSLLXeWs6t46B6PGw9cclMD76pjlHGBD1RpBxXnE27y1ifoaBFfdMxmR1sPmzAzQeSadeI9Ksju4FX56xkifGP4bdHUdC9nzmfe5/EfXCjCISGg7Tu2iQFKo0/Nxp0vLzb7+Pv93+e0WadCCirU+4On6CYvq7LP9vyqzDH5HiNqFPSqHq4D4KRowif1gxpVs2RiTYwyJWVimGGGKIIYYYYviVodPJwX/+8598+OGHfPTRRwwcOJCtW7cyZ84cunTpwtVXB9tP5s2bx113+R/UTCYT3bp16+xmnbKQ29iisRB/I0wLOV+u+nMYKxCBRPF71C6/JadU34WJo14Lu+/5rTbjhZv30tsdByOj7UVkqJ0VmJrtCkJCva+REOLFNjFuTHcK9HGYmg8FLTOTGGILGQIIyVsPHGGKKQPB6uIqEmDtfUGbyAMNnhj/WJD9Vw6fxXiyaSQePKjxk1uH9AJWtdAapiLi0FeiylOhzg8da/rUTw9idnrVIEsPLWNLwlbqkrzWNovaxoK8Z1nY7W3Ss3tiVKuxNthh2yFEZwbmA/cgqFu8NQdlaZO2o5ficWQhuuPwFCvJiQTsIdthtuz/xUgkn8W41nKYeGwk29ZjcqeiURuC6gfu2HEzAEOHvKuY3xlWaLnFOJKVOJCw/CWJ1EiINuToVGlvZ8BnnyxpUqrQfNPezzF0X+VE/Na6w9z+aQuW5SvbovYjwoO37mCmySoRhHu6d5esxGpnJRqHv/7n5+NSpG1nLdnHN32Di1gDCntroMVYjkjEUhAhYmrCIWppBgUxKLcSyxFS0RdGHYgg4NCqEYCsJgvVKUYKioZx4Z33oxJF+h8xcSgKLr/NEJUTGHaWo83k9uqBlO7bgd4mkuDQhE2SjohWYnBYeRXHUgUeu9IJeEOtQn2W0arhzrxjHvvfX0DDsaOIHu9vnOjxRF030Qe1pgq3qKEx8z5EdSLzd9XRs2tPaXn31AS+/eQg1r3NmBPP5/3ktgm5W4a8RZ6xEvs6HRk5w7nw6lspN2WCTKV+dMknOLauoKV4DN1vu4dDO7dJNcXcLhdfvfhMRGIQ/Pb6Om1qyCTkaOBQ69AbkrE2NQBQsmk9luSuWHQZkQn2MArCks3rKd26KWaDjCGGGGKIIYYYfjXodHLw3nvv5f777+eyyy4DoKioiPLycp588smQ5GBcXBxxcSe3RtfJhJzMOB61npzcOVbkr5FXu3Y4A1u2IAgiZnXboR8AbntXejd7vPXtNAKlBlXE5N9wuFN8ijP73Url1kvw5fr6CIluZjef7bBgFQiqnzfjkIN/dQ9WpHw8pFCyoIYigYyErk3ksxILZpdifoqtkiasVOviwNH22AdajIOWtz4fp7qS8CBK1OAhvcDFE/0Ki483lOEqvj94BzJcndbA4y1eJaKISJ2tjtYMTjx4MHmaKbOvY0qi1+5aavX3TXRmhEyV9Diy8NhbkyLVKn4rfsgQtoStOQheEu6XJJFyqKB0x9k0A3IaNiUuNNFhtZZJFuPOVMNFU1swkLA8VdJ//9fSistN5Vzw7wtCLpPXjlx80WJ6JPUIunbcv/oRzE47arfI4AXfYd4vduS9hQQPeNNoU4xkN5oZVl7FsPIqjmR7a3yqnZWkHbtXWr8+91ncWr9i2aYL/cIgEJESdaMllqT1Asi1aK3DvvUaNck41LrQZElrrb2sJgvDS4+RtevfiDfdwZGHHsaxfD1Vh3JoTIsnPjU4HMXeqDshISjRIjmnC1f85QWOmt3kbtjI/vfewKNq+3vjU11KbRdFslqJQRDY0KUAuU3XqQ2WmUWrhktOt/GbP97GO7cqf1OSLBpurzqLipoNxE+q5IP6yL9fSXX+4uk35hgZZpuNfpj3JZKjxcG/n/k3NUfTEFDjVEf3DUlPaCDbUIMl50LOv+k51BoNhhbl+FXv2kIKcHDTOv52+w1YmxooLB7Debfdw1cvPkPJ5ujqVae4mtpVQzAQSfo4rA3+X51GTTLvp10Yct0ggj3EOV84YjT5Q0d0uD0xxPC/DsdRM5YNlW2uZxiZgy6v42WKYoghhhhi8KPTyUGr1YpKpbxxVKvVeDwds5H+t0Ovzydn6LeYHDaEpiqoaHsbH64R36AX+yOSO3PEi/mIEtLFJoxua1T7zRrbhZyhueQA5p+Owra2f5xDoW+fP9Mr0cEG2TwfIaE26uhu8YS03nQNSOZ9rqeKYcl6Bqb5lYE22xF69ZqH3V7JkSPvAKHVb4FWYjmebWqfQlU4cBtu/THU/RZI85bVJnMUG80ef83BBo0JlUxaYlUrH7zNOmdUNHCCbDNRNlACAmf0OIMrB1wpzfPZviwtLn46WMcTX/8clEI5oqg7qzVpUr3F7KzpULWFGjKxER/2PPolSaRwx2ps+Sjk/H37H6EPj5CePuEXIzB9ll1rQD0/3/TJtuz+r6UVB1qJ21pPHtjy+cFvKT38Lmq3yJ3/dlO8v0OCZgkSMZjsHduq1gCKYeVVDCv11isVROV1KnA6wREdEaZ1hpevRUsshVuvTaWetJ4qunpsrQShAGSZqtg/6TQ8brd3rDwGqBOC1Hj2Rh222uheSumTU7A2NUa1brQWZH1yCk2VFXzwymv8pbG15mivqzm9ejkZzrqwqrFA1eXuhYU4mryk1dFUgU1dCnhn+CjiZOSgLVNLndiiSKSWh81o+xTzgcV/TbnSWMaFvzuNg3uvp/pgDdWANlFZl1GX5MBZvpVuKSIqbfvuvxLFGhhsxao9gNio4x8PvIW57mdU2kK0hgvQidFJJ30hQFOuvlWqvZefYWDpnAn85523vcSgs9G7sihKqr2DG9fyzz/Po+rgfqkv0aRlR3ve+3BD0d+xrdKQQCLxDcrizu0m2GUoHDGaC++MJRTHEMPxwFHWhGXtMe9vQ6hrtih6y2xkJpxS5OC7777LokWLWLRo0cluyq8agiDQ0NBASkrKL7LdF198wYoVK5g/f367tjtZMJvNJCYmIrY6N4YOHcqqVatITGzDRRdDDG2g0+9cLrzwQv7yl7/QvXt3Bg4cyJYtW3jhhRe47rrrOvtQ/xUosbZw+jZz61RGu7YtYkdYUtCHu4RPyaAJlSBSYDvKT+svx6zWs1/fg1v6/0la76H9h8k3iySb0+g60IA6WYegVqFK0KL3dKx4zh6LjWRnBZXkSu2UCJX+Glji/VPvVu5/QX8ldSaUzqaSY+S3Ktjq6lYp6jT6IE/4lcJJoqxt+HDSHnJcuZRoTQrS8K70fSS6u/LAoHzmGTRAL54XP5b6c3qG/+Hw8WMqal0qRp4+GdU/1JKVuNSopBsOxSWiJT8iqQsQr0tFcJqCiMH0hHSemPAE2oCHEl+9Jh/kFmPRHcfq4jTEJP+D1SvVRhCUYSiBwSTwy5BIPsKtoSG0nVKOGqeAXfTauDO1Ivv2PwL7vRbj9PSJJ7yd4Sy78jp2J9OyKye/OjOwBfwJvsaJExG0HVfpdCYi1YQMt56v75cN7svWusMMXvBd5xKDvgcZQZAIwhxTJX958Tb2do3jP7KSDWrnUa794p8I2mFo1CNIt2Rw2eYHMDTvJKFpEa9M87fqti/c5NWKaB2wL0dFSxieRE4sNWhTFUqns6qXkupsCEtuNSSn49DqqF+cQWZLFfEp4RR9KhymOBy6KO2wrWEcNQ3NZJqsbCnoQpUxXhorOSFZ4xSo0npA7wxrnZYju6AXgihSsmVjZOKvtQaiQ6uOuJ4+OQVra6Lzgd27oYs/kGhZ1lTpbx8RKievQga4CDoOdInjmcvVQLmCGARY2ucQ9PH+LbcYp7iaKBwxih4zfscHb/pfszn3baTqu/1kD/Ar3dQ6N3n9BjDhsqv56o0/0mvaz9KymghEcijEC1BueIby1kM6nIWADo/zIE7LYlIMF3C9KQ6HALUqF18b/H2+84xeNK39Dg6vwlg+hlFX30piYi9pudvlYuf7L+PYto6UCCE/cmIw2rRsub3YlJKoqDF4Ua/FaAUH/9x/sTQv11CJJiuXmr3BqW8dJdgLi8fEiMEYYugE6IuzaVpSjmh3hw0EE+LV6Iuzf+GWxfDfBpfLxbRp05g2LXTprs48juYE/TZs3br1hOw3hv89dPoZ+vLLL/OnP/2J2bNnU11dTZcuXfjDH/7AQw891NmH+q9AqLCOSIjGCupD+b7ezNCtx64S0Ld6XntYK1ALwT+yfWrS6NfsAUSsG71KwbRLenPQaseqUTG43sn2tPaRAQsqRCAXhFck0klOVPQf/Tc869V0t4peC7Na4Fi8wL3D/fbnO8WnpH76VGUOZz3hEDQmUdqf4oo+QWeoIcHUVVF70Nh7Ee4kLaKMRAtn//bVHOzaLZ+a0WouTrGFXO/RfjmAd3+fFx7FfOB2adnAAS+gS+jBC5tf5YBlrYIYBCSL8QOrH+DpSU+jVWmDQjF8iY8QYDGOYix8fXt/zzU8fek0EhOSTgjJ5Xa5KN26ifyhI2hxHA5LuAWixinwl0q/muiPOTYyWy15W7ddc8JJuV+LZTfcGBxPYIs8wdd4+ul0XTD/lCAI5TUiS5pKFFbiJyc+SUFyQdjakVqVlgc851C9/9vjakNIYtAHQWB/ro6nL9cAjUHbJtW9zqJRADuYvcyCRz+JXkcqGbR7EWVZHuSUZV6tSM8q77FatK1kWhglXLhaaKnOBrIcoUNWGpLTeXvmnaidlQiinRlfLaRPo3Jde6MOW008jdoUHLo2Ak/kbWituZdusnrHSkYMgjfhdffCQpoTW1g4pB6GeY8bqbaiD6VbN5HjEbx1DUN9Bq3Hz2qyMLS8im3hPitRROdyY21q9Ae6aFLCHteh0gaRV0d+UtZzjU9xgAjH4qMjm+R2cX1yKmfPvosPXnkN8BOUiUkmaisPYpCFqA85bwyDJlxKxZ79uJ3KEhuZWpE/5tiwi2B1C+jVIlVOlcJqfGFaAn209dJLFznkhKecIBQENd7bSP/yyX2yGDT5Zkq3jpJqB/rgdrn4cv5THNy0Lur072jTsvOHFSOoVJRs3kCKq4mG+GRWy36q/30guPRAvLqFkoZqrElqhWoTOkawx4jBGGLoPKjiNCSe1g3Td2WhA34ESJzcDVXc8X3fBEHgj3/8I1999RUWi4WHH35YCtH89ttvmTdvHi6Xi9TUVF577TUGDBhAZWUlM2fOxGQyYbfbmTJlCi+99FKQcw7g/fff55VXXsHpdGI0Gnn55ZcZMmQIa9eu5ZZbbsHtduNyubjlllu4+eabf9F2Pv3003zwwQeoVCoSEhJYvnw5er0+bJt37NjBzTffjNVqxW63c/nll/Pggw8C4HQ6+dOf/sTy5ctxOBz06dOHN954g9TU8JH2kfoE8Oqrr7Jo0SJqamp46KGHuPbaawG45557+P7773E6nSQlJfHWW2/Rt2/foP1HWk8QBB566CG+/vprJk+ezMCBAyXF5/79+7nmmmswm814PB6mT5/O448/HrYfHT0OwOLFi3nuuedYuXIlK1eu5NZbb2XSpEn8+OOPuFwu3nvvPYqLiwF44403eO655zAajVx88cWKNsgVkz179uSqq65iyZIlVFZW8vvf/176nF544QUWLlyI0+lEq9Xy0ksvMXbsWAB+/vln5syZw7Fj3mfp2bNnc9NNN1FZWcntt99OWVkZNptNMR7RfhYx/HrQ6XcwiYmJLFiwgAULFnT2rv8rEZjQ2hbyOCwFj7SFHn32swHvRXns+nribSJ1JJMRwmKsUO+JYN1QSe24bM41WmFMdLUKIyEUoWacko7LE491Q6XXNqASsGuUD2stxFPaqrI7+v1iLMMP0NC4IWhfgfBZjEWDhpYJ2dzpehKnRaMIGHkk/Q36uQ+jiXPQZPCu77NB+VCrzsQekP9rL/kDJncNWnU9CQXvSPOzW61brpYK1FPGwJYDbbbTo+uumNYbCvm0fAOfH1qjmC8gSEShiMiS8iUU7S7i0oLJQaEY+Rn5ksV4R62Ju8qOSVbitlCBty7aXns3Pt1hYPbkE0MMfjn/KQ5uXEth8RgmXx+6rlMo2ANuEEvEPNy4JVL4RAeo/Nosu4Ht6Gi7JGJw+XIAzMuXc2TOnacUQRgKBckFDEgfEHIZgNPj5AnVNwzuLVDc3lqDgoA6PR1nbW14YtB3nBA15UKh26FPSHLuJr1+FyrRQ0JA+cE4R2h1YiSrbKCyKZIiyqHVKWoiLhsBGRszFeu4HWoatSnRB564mhRhHDVJeqpSlNdUk96JU+MN0XA2K1VhkWorShBFKvGQBUqC0DcusuPLU6SrAtbzqQqjSQoG2K8vxJBiocqSKYVVdR1XrVinx+kV1DgFXquMziItDxKxNjWw4IHraLY3cpG4DoM6jgHnHwwZjGVP+AcbN/3D24ais4AyxXI/4ef7XzmufbT1dNOFPk8DbeY+gjCUxdh0yIy6eyqFQ4Zj/uEHSWXcXmKwvWnZAyadTu9RY6VjCM1ASvB+bxnyFo4dGkSTSMl3ej4u9o9lIBHdHoI9RgzGEEPnwzgul+bvD3vVgwEQ4tQYx+Z2ynEEQWDLli2UlJRQXFzM+PHj0ev1XH755axcuZKioiI+/PBDZsyYwa5du0hJSeHLL7/EaDTidruZPn06//znP6V6+z78+OOPLFy4kB9++IG4uDhWrVrF5Zdfzq5du3jyySe55557mDlzJgANDQ2/aDvfe+89Pv30U1avXk1ycjINDQ3ExcVFbHPPnj1ZtmwZcXFx2Gw2xo0bxxlnnMGYMWN49tlnMRgMrF/vrRP72GOP8eCDD/LXv/613X3q2bMn4M0lWL9+PXv27GHkyJHMmjULjUbD3Llzee45r8jiH//4B3fccQfffPNN0L7bWk+tVrNhg/eZ8t1335Xmv/LKK1xwwQXMm+d92VxfH16UcjzHCYU9e/bwt7/9jVdffZXXX3+dP/7xj3z77bfs3LmThx9+mC1btpCbm8sDDzwQcT+NjY2sWbOG2tpaCgsLufbaa8nLy2PWrFlSEOzatWu55ppr2LNnDy6Xi+nTp/Poo49K52Rtrfd37uqrr+aBBx7gtNNOw+VyccEFF/DJJ5/w29/+NurPIoZfD2J3MScZvoRWs9vNfoudW372p/A+mllCY/U/pRRhgG4E21+igUsj8B9PMXc5Z/OZ9nUG2tayat2NHPHMJc6VTXdrwM26AHW7a4/PZyeDmUSJ5PMRORqdkaRL8qkdl83Fe0pCbveqMEf6+3n9reTseSvicTL3XorWmgXDXpYsxgl67zHLW4kvHxJ0TvRONSpU+B4Bsg01PDH+MY6485ivmccLhgeDjvF4YW+gt7dN4jdSf2alex9aavb8gZyh0SmRknQJyGlajdrAad1O4287/obZacYtuiUrsS+URC2oMWqNTO42OWwoRn6GAbfLxcFPH2f20cOQKiCOilOMZyhIy4fBK+vKuGpsT4zH+VZWDsUDIt4i9EJcE8Y2xGw+K/EBu/Ih9Q3X73ALeczlaQZoq7GY92OK73LC6v6dSMvuiYC8vcdjJZaIQd9DvSiecgQhBFuM27Icf7D7A747soyV0wRefl0kxRJlEK0gYJw6lZwnn+Bft/yeqhZrRJtqtMmx+hYPmQ07pOncBnjxdRc2nZcYrEwKr04MB7kCqi0rcV1qVlANxMNxOaj+nUGKuw6300vIBFqJw8Gh0gYRc5kmK9mNZqkfJr2Tzyb7bcvFu1MU+2g0esnMQGVXEASB6hQjw0uPIQBVKUY0bg8ujVpxfEBJEKYYyWyy4NBqaNLHeROWo6w3tzl1OJsZDj8q0+yrLJnY3XHEq1vINtQEvdSwV59JfNYSaXri1nRSzNqgPpr0Tj4b4bMHH2PmtrSQxGAgJl16E9+/b+To3s1BtvBNPw2h2WbE5rZA/33S/Lq1WXSb5K/P21YgTCiLcUHfVMaNzQupMi7dtpmDG9suGwEdSMsGfl69gt6jxnLhnffz5fyn2LRtD+dV/od6XSpr08ZI2zg8cbQ0qxAbVLj1yt+TcER0KIJdBOISk3E0N8WIwRhiOEEIqx7sJNWgD9dffz0ABQUFTJo0iR9++IHU1FSKioooKioC4IorruCWW27h6NGjpKWlMXfuXFavXo0oilRXVzNo0KAgcvDzzz9n27ZtjB7tTy2vr6/HZrMxZcoUHnvsMfbv38/UqVOZMGECbaEz27l48WJuuukmkpOTASSFX6Q222w2Zs+ezdatW1GpVBw+fJitW7cyZswYFi1aRFNTE59++ikADodDIvna2yffdj4VYb9+/dBoNFRWVtK1a1eWLFnCyy+/THNzMx6PJyx519Z64UqeTZo0iXvvvRez2cxpp53GGWdEdjd19Dih0KtXL2nsx44dKxFvy5cv59xzzyU310uI33zzzTz55JNh93P55d4XnBkZGRQUFFBaWkpeXh5btmzhL3/5C3V1dWg0Gvbu3YvNZqOkpAS73S4Rg75tLRYLy5Yto6rKf39gNpvZu3dvVH2P4deH2J3MKQBfAm8g1NWvUkypn+SKwkocDm/Zz+c15wxcaFjmvItcz39IbBlNbzGLkHp9QSDe6iJANNcuPJevIk88yrbSN3lKeFia/90gNb0MRomosBujOw2jSXNWtyRLfweOVaAqcE7hY5Ka7uMN++nitOE0HIPBb2LFiCi03a5wbeqmtYclff/avzu9DfEY1WoK9HHkB5A3BcB7577H1f+5miZHE2f0OIMnJjzBA6sfYEn5EoxaI29PeYJ0VfhQDIF4lr/zBsZBnzGulXgrpX3EkNnl4V8bD3PN+OMnukSnE9PKlazYsoaDmzcoSKYDP+2hFxcz8fKZrPnqaeK7bVRsG2gllsOXsPkm8MccAUpfoKT0BcCroqykC2a3WxrrzsCJsOyeSBwPURmSGJQWnnoEodxiHM5KLMdp3U7j3a1v8/svG0iOghhUZ2Tgrq3FOHUqXRfM5+C2zVQ4bG0GXCRZtVy8sgtOjYdGo5NVQ+ukZbd94SbOEV5JldvQhm05CoRTQEGwlVjtPKpY/s3k8bi1ecz4aiHd6rwvH9pTjy3O6WZIOGIu2RBEyGwc0KiYlo9VRItxq204y2Qlw2RlnUZNkzGBZLNNcXwffO2obmjmSGqiRAy2p39y+NLsqyyZPPCjt56voK3ltuGv4NQEjr/yM0wxa0k3BV+fAsemxRMdyayLS+KC2U/y5fynqKnxk5CV5PLCeH+Jl8v+/SRuhwPRE4dN5wT8N//RBMJIBKHxAgqGZHP2jYNQedwhVcY9n3uWwuIxURGE7U3LBijZtIEvXniSaXfNY9DMm5lTF/o4b+24CiGlFiG9hUnNixTLwhHRinCYVoK9JKEHN/zxIYx1ZUH26RhiiKHzEEo92JmqwVAQ2vidfeGFF6iurmbdunXEx8dz1113YbcHhyKKosjVV1/NE088EbRszpw5TJ8+naVLl/LAAw8waNAgXn311ZPSzmjbfNttt5GRkcGWLVvQaDRcfPHF0v5EUeTll1/mrLPOalcfAiHvU3y8/xlLrVbjcrk4dOgQt956Kxs2bKCwsJDt27czadKkoP1Es57RGPoh95JLLmHcuHEsWbKEV155hQULFvD111+HXLe9x9FoNLhlJcUCP49QfQ6Ftj77UPtxOBxcfPHFrFixgpEjR2IymUhOTqalpSXsfnyBJ2vXrlXsE6Lrewy/PnSSLiyGzkCgxdhnjc3hGPmUtpsYfHP7LB5dcy/zVj/Iy+bLcLVywXWoaHZfjEvsGn5jUaRQH89N3TLDr9MGBqf3YkRGN4wo6x8RX6ggLKK1VodKIw6EKIR/qPCpAh8a8wyzx7+jsNkmiN8S19wVraVL1MeKtJ59vYmMpjJ6UkI3tfItSm9DPIMT9RJZpdfnk5Q4SDEmhSmFvH/e+9w14i6envQ08Zp4np70NHeNuIv/m/okR3dfy4YN0xXKNfCGYmzYMJ31G86m+uj6qNoaDtOLcijumdaubUJBdDo5dMccvnzuLxzctD4kyXTgpz38Z/4HlK8ProUWqLoJhxIxj0r8N4sHLGbGrfuZszbuY9y6nymxhv/x6wg6y7J7qiIiMSit5CcIRWf7CZXjbV/z8uVBx+2R1IMB6QPCEoPy7fL13Xjjhz6M2NeGpVgQMJ5+Or2++5aur/5VIkPzh46gsHhMVIRdklVLepOOgmPKG704h8hzMzQ8N0PDHTdpOBZQnud4icG2ILcSp1b+SSLcpXbXvU5q5Z9YNmI3Jr13rH1kyaVHP+Gs6qWK9c+qXsqlRz9h1qEPSXE10aJVs61HtsLEqgJyTFWIqiYaDdGfN3KyzKR3UpfUIrXJBw+wrUc2TQbvTWyTIZ6dQ9No6ebBlSkq1qtJ8pbMqE4xKsY2xdXE9GNfRt0u8L988pGEgrYWY6/neMdkV9T2A4jP+k4xHags9fXNR1b5UCOI/PBFd9Yt7kr5si7++U6B9auzELV3S3VX1RoNF955Pzm9ekvrlDvUqJ2V0nYtnly+TLmexWmzeNt4HVUW/+99tInVHudBMvPqg4nBAJXxsXvu5dyb7kCfHL7+VHuPrVxPpGTTOr544Ukqflofdhvf52LIf5lNgw8rlq0aWseXEyr5bHJF0HmV4moiy1FLqqvJ+zpVFFGpNfQqHh0jBmOI4QTCpx6U3ql0smoQ4J13vCWCysrKWLVqFRMnTmTMmDHs2LGDnTt3Al7LZF5eHnl5eTQ0NJCTk0N8fDyVlZV88sknIfc7bdo0PvjgAw4d8goEPB4PGzd6X4Dv3buX/Px8brjhBh544AHWrm37xUlntnPatGm8/vrrNDV5X141NjbidrsjtrmhoYGuXbtKirMlS/wvn37zm98wf/58rFavH8pqtbJr164O9SkSmpqa0Gq15ObmIooir7zyynGtFwr79+8nOzubq666imeeeSbiZ9Pe4/Tq1Yvt27djs9lwuVx89NFHUbVp6tSpfPPNN1RWen/DX3/99Ta2CIbdbsfhcNC9u7ek1csvvywt69u3L3q9noULF0rzamtrMRqNTJkyhaeeekqaX1FRwZEjR45rjGM4dRG7ozmFILcYq50VVG6NngzsVTgPXVwmu2Vk0TFLDoeauwWtuwQn19OGikoEz+B0Pvw5tLUnGjQ43djd8VIdOx/2W7wklU/N5et3xbIyfi5t4E9FbSsEw0EQ1Yjq8CRQYaUdj0OkVCeAP0CRw4kNOMTV2PsWI+BPPk7bch9HNJn8abBfQfHwnkq6tjSzM3U5Od38n1HO9hvRWHLQePSYOcoOYRbgVWsg+C+Y0ZKh+cn55Cf7CUOtSsu1g67F1LyTwxG280NJ6MjTnM0kYqTZn+rciufyVQxO79VpSjsfMbiqZLeX3Ai7okjlwf0kd0klsFaW1R0dIfJX1TzcQo4UfmMnATBLy9sb/tMWOsOye6oiKmJQWvmXVxB2NBxFdDo5cvsdmFeswDj5NERBhbhqXZtvydTp6eQ9+wwqvZ7Eqf60Wh8BE1UttVZ7bY6pjvci/PRadVCVpCfTZEUFIWv0dSYMcZYgK3E4yMm5qOuxyRKbfdbeY6lw500aILyiMRR8JFqgFdmnKKxONvB9/x7esBafCjDZSdbMSnz6w6yHtahqBMlSnNVoJrPRTE0A+drdfoSL6t6hKiGJNcmnITozgtrzu97/pl/6fokYLDd15Zglx9vtCL9DclgPz8Lj2CaNRWDf5JCrKGduS6MHMmV1DzMflbzGa33OJMltRe2soJvWzojzz+PTnbt4s9IM1JPGvdTnPotbm0NtcpY8S4T6PWejPbKRSqsjbCJwIIzp/bnovotCE4M+iCKm5ctZdfO1WJ1tn2u+cBpfzcHQadmh7c4lm9axpcYF6lEh9x3t5xKp1qUAFNgPYdq3DbpPDbteDDHE0DmQqwdPhGrQ7XYzbNgwLBYLL730kmRr/fDDD7nqqqukoI9PPvkEQRC44447mDFjBgMHDqRLly5hbacTJ07kmWee4aKLLpKUW+effz7FxcW88sorLF++HJ1Oh1qt5vnnn/9F2zlr1iwqKioYN24cGo0Gg8HA0qVLI7b5wQcfZNasWbz33nsUFhYyVXY/NHfuXFpaWhg9erSkaps7dy4DBw7sUJ/CoaioiMsuu4yBAweSnp7Ob37zm+NaLxT+9a9/8cEHH6DT6fB4PBGJuPYeZ8yYMZx33nkMGjSI3Nxcxo8fz7p169ps06BBg3jkkUeYOHFiyECSaJCUlMTjjz/OqFGjyMjIUNjgNRoNn3/+ObfddhtPPPEEKpWK2bNn84c//IEPP/yQu+66i0GDBiEIAgaDgTfeeIMhQ4Z0eIxjOHUhiGJbT36/LHwS16amJpKSkk52c04qqmu+Y8eO8MlVchQWziMr83RFOEV6/iI0AYEXPiR+fxT1jrqwCWD64hw+KE7iyZJjiECKWEujEPxwFIiPhxSSqlXT4HRz6ba2icWfRveXSCjTskOsX3eYK8eGJpEeF++JOowlFCrJ5W6h7bcaX6dD0pc7ULnj0Vlz2JOo4spx/jZ98JOFvs1u7u9/P9d189uweqx5hPjmngDYE8soH/uItCyzaBHEF3YK6Wa1lkaV7rt7YSFAyAesIz9l4bJpaBk4nD/nXivNX9jzGCMyunUK2aUgBpP0UamedMkOkrtoaLGZ8ThU1AmiN7m0DTRm3oczwVtvZY74FON730a1tn9YO7faVRm19fRUhTzxubOVK83Ll3Nk9i3t3q7rq39VkGcnAkHEZWv9v7xnn8Gydq0UgBAIl83GxltuIvGn9R2SzEciId0uF1++8IRXGRuy0cq6e8dS4XDr5bRFJ/DyNP8Lgwt+MiJ4jOQ02Dl9p5dkO5HKwYQMG+5p1lbyKDJC2XoDwzukEJJAiCJddHrGGjPYted77r82upckoerx1SW18OUEvwLuwtU5IW254O1f30vKpOnUJzWsTs6iMiUerVtFkkUjBZHIxzeQpDMfuCeIIHxozDP0SDqisBL74FOotQXzgXv4XdkKiVAN7Fs4XLwlg0nTDnHYIfB8lf/lVUPOY7h0PQF4XrwVgLnOe0it9LevIflh3EJ3BLML3Q5/EfwHrVvJXL+S0iwD7nhnm+ebMb0/187/C1qVEPFlggfY3CObxu5a1DpPWGIvFBKy0uh70Y+A9zd8z7ICxBqB1Ka6sNuIwAHjCDxCHMe0anYk+8s99Gv5iaNDv2jzuNGkZF941wP0GT0uqn7EEMP/Oux2O6WlpeTn5wfZE6OBacVhTN+WkXROT5ImBwsfOgp5yuupjF9LO9uD/8Y+xRDDyUaoa217+LWYcvAUhNVaisttweO2Rb3NwYNPkpV5etRKJvHSRBriDvqTgn2JjaKXGNRe0JOX1/2MCGSLFbzAbewQB2MiiUZS+Ui4Jmifr/fWc1paIgDbm61By0NBrubSD81E/+OhsOvaS/6A3Qwq4350BX+T5mfuvRR1SzKVg9+MeKxoahYC1H9pITeuP+467/grkpyBBLeIc3A8cyf/mZo9f5Dmq9zxOPSVeNR2HAal8iO9aS+J8QIaDNDO2n+B8CnWzJb9WCz7KCmZLy1rS1Xhgy9RsxIR8JODFaV/wVPqVUP67GkdgY/AKd20jqqeOVFto0tyMOAyP6G8+x+FmKN8dyGqE6W/Fwj3s+AAgPJc8hGF8jRWgMUXLf7VEYSBic+dXQzfOHEixtNPj045CBJBZ2zDDtJRiE4n5lWrMIwZw9F77wtpWzxw1tneeoABJJ7b7aF0cwUbXpxDhdNOtkzB1h6Yly3DvGpVEPkpOp1YVqxgyIGjmGVBG/4VxKBADIDnZoT+vBaPM+NXvGZw+s7a4HTdToA8DbaHtpo/5giUiHm84fqdwlocLizDh2gCTwAQBCpcdrYW5JKVMAZoO3UeYFD34djWeoMzfKnGgXZbqVacUyDJpgvqnxyrxqTydq9GafrilV1IsmiCxjVQOSaoWxADHNCBVuJAWA971eOCykFC3sfSfNvRS/E4shDdcYjODEWNw2jDa8wOFT980R1TihHyy6T5vpqRohBPhajBKYqoXco6kvG79+Bx1HuPj5/wfFw/FCYPBWDO7rciEoQJ2jyueeaRdhGDA2b6g8fkYSLeBgcnbguaAjwub51L6eVe63ux6xfOD0sQNmmS+SYztHJwT9w4hAN9ENTemoNya/HpB5NINumgSdcmMVgwfBSFI0IfI4YYYuh8GMd3QdCqMIyK7p4yhhhiiCGG9iNGDp5iiFYVFgoutyXqQARBrSLtkt4kTemGdUs1brMDdaIO/dAsNGnxvH2khma3BzWgb61VV8R2ADYyMuQ+zS4725utGNXqqK2z8vU06QnUDUkHQtt+vCnBAL15XvxaqsGor++Pyt028RdtzT29W8Rda0OdkYC71kZ3m8hnP1qwqkDvEuk3MJvU3xQiqFVU//w+pnUHUbm8xy+dcH/Ife45NFfiqo6HdJMjlKo0I3cE+w8eDHpIC1fDSW41Dgy8CUxCjhZyZVemKCqSSSMhsAh9j8EDqN28J6pjzuQf9BVrqSNDke4dCoEWSouzY/08WQiV+Pzl/Kc6lSAUtFq6LpgfnbW4lRg8UZZiuYXYFwgSvJIozTcvWyZZnD0qNf95bQv71/4dj8MOAkEW16gQhvyU25QBhhGg8gtDDNqiE01RmRIvtTUagtBHiLX1ciBUGmymVsSNG7eQp5gfLixDsU6EwBMFRNEbSDR8JG9shYYtazmajkI5eV15Pv/Xw68QTzOmU+VyU5/o5rPJoUttBIaWZGjEsGm3yeNrQaa0c2o8QYrBUATkpOZF5LSk0kOXiaX2EPYkgaSqflBQExR2Faga9JGEPngcWZxx6GdSnQ3oRBddDCqsrUMYKbzGR9S2aD18N7q6da7y+yAndv/um4fSEiUnKkMpIgHyq8w0p7hCkt0pdjWjtq/GsX4dDrzfuVDwEYPVyQYSdMrrblDoSAhiEKClvordCwupzsqRiEHw1soMh7bSpkVnBqIT4m1Ku/7QcVV004le4jLC9vrkFM6/475YrcEYYvgFodKpSZyQ1/aK7cSpZKC76aabQta3W7NmzSnVzvbgv6VPf/7zn/nss8+C5n/66acUFhaehBbFEMOJQezO5hRDRwkZ6FgggiYtnqTTg63Ho5MNXN0lHadH5IfKY5L9uJLcsOTLPaUeKPUqPH4a3T/qtF4fSqwt3JAUXT0guQrQZ//NX/0ULYajVAx7WbFu5t5L0df3J98dz2eYsaoFSo0qRR3Bx7bbyDd70LtFulu9nXXX2si4cTCO0ib6B5CnPmjNWcSbPeARsSeWRdX24/mM29rHlKtvxWP7R1D9M3kNJ7XOTa8L/WqJcEE3HTmfAi2fgcmkoUgNSeGTqnwYL77Im3il3eTAalPTmOhi1RD/g7A55TKc8QMRhXj6ap4jn9KIBHC4NNaSJq+aRW4xtjpc/GP9YS4b1Q297tS5TCqIQZly7qQRhL8UMdiafBqSGAwB87JlHLrjLnb0u5r969/H4zwoK2YeXAOvLehPO42WWTPxCAIquYrx7nskYhACknhTjCGJQYCESMyDDFq3StHWYeVVEtkS+F0KJPyClFkyhEuDzeEYc3kauQZbH+8GU3TtjQqiyMFN6xl05zy6OfSwa7li8Vl/eJzT6kx89tJfUNvdmGtX4NLH4dSGTuwLhFPjQa0LrhdX4xSwi1DlVH4a8oRaIGy9P6/CzHvdvHhlF5JqtBza0kTfAn/Y1YFV3TlSm8fS7v0jtlHQNKLTHCPLYkafnMo1L7zGN399gZLN6xEhrGrNR9TWRfk7GQ1CKSIBDK4WepXXhia7D1WTJCPLw6mMq5P0NHbXkaCzByk4fdMhiWxVNgCiq4SG5HQcWh11QpZilbpU77TO6QhSEMapo6tHluBUnifxrV+pttKSrU2NHNq5jV7Fo6M6TgwxxBBDNOhIyMSpjv+WPj300EM89NBDJ7sZMcRwwnHqPPXGALSfkBk44AX0hsJOD0QoStTzdF89bx+p4aPKXO7lZRIEO0k0RrW92e1mcKI+5DJfWm+obaKFcccc7KINo0OLzpoOgM6ag0cdTA7V9P2Y/NXelKUsdalXZWjuolgn3+yhX3PAA6UAjtImqnsYqd1RQ3y1mYItoB/mJwjVRp30QBSNehGOL9XWZzm3WpSqmIL8uzAYe6NWq8MGJEgPYIKAeefFnDbrSuwtZYrE4+M9n8yrVgWpSCIRhKEUTD78vPdeDANg7AAv0dG12zBW4U9Gc8YPlGprJYh2bKWTaNp8mJvjnsHiMKIeNpZ3CoYBwVZiOeatmif97bMYv/NjGc9+uxe7y83syb1CbvdLIyQx6MPJIAh/SWKwnW+XPYKKNVU9Odb0Ph5XiPOrHQShB/jJXEvF/CcpHDGKYWVVWJcvD6ti9J3vNQ3NUqhIIHIb4MXXXTRli/w4MJVv+/jr/QXZeAPUjsPLq9jUIzsoQCOQ0IhEcERKgx3QajG2i16ypN4tEH2Bi+jQY9hIvm/J5rJnniX9T7cgtxgbE5IZOGAwefe8yFd330qDPg4EIWq7rdalwo2SOJVCO0JArsybsrHturrgtxy7Hf42ZRtqKLHpUcWDSpeuWF9QOei/fQCbM3uTkPs5+m7v8303SF/ZBZoaOLxrO25RRARFywP77JuOdiyigSizRD9o3UL2+u9JcNrJs3jP7SCyu5UYlH/vQ10jPMCxgviw13d5DVwFkd1KAvqIwbdn3hly+69O/630t9xirNIWkhU3letNAg4BalUuvjb4vwtnVS/1KjY9TrL0JmZuS0NIcZA/uoZMrbftEYlLQaBwxGjyh44IP6gxxBBDDDHEEEMMv0LEyMFTDPIEVKvlYBBx0+Ko4cCBJ/3rGwqjthJ3BD4FIXgfdty2A2xpiLwNKO3CgRbjwOkSa4ukMJRj/J49/NivnzTtU/c1auHWkf4E5M9WmXHG12LWOdHqGgn12GtJ20X1gPelae3G5wE/SRdYVxAAQWDPpmP8bomfAFiIgW5LytGPzCH1N4Xoh2ZiWlIOIKkXfTUHj8lqIPbr/jSJ2f0UpJuP6IuWiItkOS8pfUH6e+yYpeETVFsfbC6Y7SWQTM3K0Tre8ylcrbpwBGFbCg0fpl5/HQm9R/Lal35y8P/66jlUco9kh967OR5bbTxGTBgxUbVlDbSSg9GmsVqcFswtLl7/3vtA+/rKg1w1tifGuJN7qYxIDPrwSxKE7SAG23uew/ETgzsGXMex+HI8Lq8qtFGTHFwTLwqC0EOrTdhhBUHg4Kb1mBvNDAOIoGJUAdmmyHVXUzUi4u1OBjlq+FZmcw1p421t6+Ye2eQ1NEvzAHRJLah1nhDKrBYQwe1U42jSKojESGmwtTtTyBzUKE1bUx0ghCFKOoiK9AG8+NVujFvX8dvHX+HjVV8gDh2AMSGZHkk9cNlsLH/0jzTE+dsdyW578xduLNo0zPF6kmxaHKDon2piaHV0R+Ej5+TjWK8S+bi4BqghgZ8V6yfkfczPeZDAbsV8p8ZDwfBR/LD635Qc3IZWLyhUgx5HBuYDl3vVfe44PI7vgCaSrFpmbkujy1lH2WTuxkqL/1xsNt6Iy9gNUfC+rPKppeV2Y1P6Tbi1eYgWNVqZknLQaSPJc1dKSl0IILubbUHEIARfIzyiyJYe2ZjS1GRHMZ7S74CqJ3iqQfR+dyJZh+XwrafSFqI1XIAgqEn1gIiIy3kMDH7VoS9NO9KLqbDEJVA4YnSn13iNIYYYYoghhhhiOBUQBZcjqwABAABJREFUu7s5BRHuAVpvKCQpabCCHDweFVo08CkIfbBaXQxbOwsb8VTQlVeFOdKycHbhAn2cZDEOZSUet075IOWDnBgE6GF20a8Z9iQqH+P3ppmYN7Bn61Rvnhc/DrLKyolBgDxnM5+t8lqM5VZiBTwiB+qV9t1SPHRDjXVjJXbVUYxnZKAa7cazXg2ilyAMhcTsfgrSLZDoi6YOYbR2ZJfbgl6jCSYIW4lB+YNN4PlzvOfTIVsF5odupDnOSvJ/1rZJEEZSMMmRXzQavT6fxRctllKGjc5DqGXp1XIVD4DO4bfe+R6U24JBa+C9n8owt3gtjM0tLv6+puykqgejIgZ9+CUIwmXL2kUMtvc8PxHEYNg0XRnp1rWhmSyZ0k8iBgMUeh2qWRjYTmBH70zyqJCsjD6EVYUJAtUpRqpTjNK46JJaFCEPcvQ43X8NPPD3HpitCUEEYShkyIhB737CEyXthiiSZbLiWfgxf/SIDK7cTfmeH+n/0ov+ABmXi0UP309FizXIOh3ObmvRppHdoEGVrJWkd/J2pkWZ4aK2p2M+cA2CugWVrlpRm0+u6ARvqrDWpSKp9TjWDlh944p6YB6QzotHP4EJ3nnylFyHSivVx/NN+8owpCZ46KYTOSYoSWEXOZKi+vxln9DFcxhxUg2fy9Zxa/Nw6XoiOF1AlTS/ZcQwuk6bGvT9UwEejY3qC0ZiuP9Oxfdenpruu0Yc3LiWqhQjOmd0/nnpd0BsALzEYENyOhVZ0SWS6pwOBTEIXmLwgMaDmRy837jWdVvDX6J9MSVfr2DEqBgxGEMMMcQQQwwx/NcidodzCiMUcSNXFna2lTga6PX5XDTmfVxuC3vs8by602+HC2cXBhSEoBztsRKvMf8EieMoNyofnrekKB8Yo0kldhgqSHXXkQrEWfIAJal3GDdWvGSgHKV4yMaNNq4WZ/JcrxsuGfqP+huedWop+VnlUbZBozbgqrdL4S92Y5nCP+Yj/nwqykAS1bePaOBbTy0nCDeuDal46MzzqdxUzgX/vsA7MQTeYkx4grBnDlXJBrr1nsCoka8iYg+plA20OEs1Aa2lrNl4jbTugS+7BZEWqU11XL9wPg5dHIV9+nPmlYuwiy2UNJUorMRPTnySguQCDFoD6XF5vP79Mnk5v5OuHizduomDG4OLOYeFKHJw41pKt27q1JpYPoLQvGoVxokTo7ISBxLabRHcx0sM7hxwPdXJejwWP2HmCycQtLUI6hYaDG5S5PkZMtItu9HMsHIvWRK2TmYHahbK4cgU+Tk/DVeut3+ZWpE/5tgoXZeJ2KgjUSOGDkPwjYcgyJS3wbX1QmHk0aPsUuWGrFUYLUHvPV701+tQSLK2MLysEoFKAFyZIqaDyyl58EbyH/4rlrVrqdLHUV5+MGKAUSCBak4woPIEJw4D1LrSibe5+EOyDWN8PZt/yGVF30ZpuZz0s7uMCjJODp+i06R3KuoS+si8jlh9/5W8Do6uU8xzajyS0rVBm6pY1pyUiOHMFikApdzUlSZbKoqikDYNgskBahXpDdVkOSqxBxCIvpclokFDy4RscHtArSI13RhSKXwsTeCOP6iBzbD4N1L5hVCp6V0XzMdzxxyOlOymStSHVaiWL+uCvVEnKVLjVHpaPN4vZig78YitP7Jp6HhpesK6JRQc3ofO6SDNkozWGEwMfpXoRADObIY005fo3M3Si4Foz3vfegUjRjHtrgdixGAMMfxCqKioYPPmzW2uN2LECHJzo6szGkMMMcQQQ2TE7nJOYYQjbn5pQjBUuwAy1C0gs09Fm1AsR7TbnLP8U1476xJeC7Hsn3mZiukKvJbjwPRdOeSWX4D81U9Jqr/DuJlJaBLjLVp4ixawJ/CEJZNsQ423H2dkoD+tl0T+JSV2J6P/12B0okaP/T8u6jdswGGoxKNpwaE/CkX+/VotBymzi5y10//w/dPo/gqCUK/Pp6jotZApxeFqBfoIQp+yI9SDTaTzSa4KaeuhKDD1N3HuHIwtbwZbjAWBiQUDcF51OfnFo8PuN5LF2dGiTEgI96Dnq0Nlrj3G9hYLF94ZHKZTkFzAgPQBAPx1xQFJNejDyVYP5g8dQWHxmOiUg3BCa2IJWi2JU6e2uV642pi+6XBEdKialdGiLm0gtZlDUIluVNpC6sVaiWCRp8d+nw/8OJBUi9pLFIgAokJFCIQk0iR0gCBUpafjUNVS+6iTTJlaC7wEYeaEamk6rEKvg8Se2i6Q19LsVR0GwGHSceDLboqQonBoD5EYBI/IqANHpbFyZYpUP+pl4Wr5Aftlp6Pa14h+6lQKR4zyphqHOd/lFmOtUyDJGpoYbNQk837q5dDKrf++/h2MYhP09a+TYtaitmZhDyDj5LX4AExCOmqNGremWjHfV38wyarljNV9+TzvrCDVYXtQkimwXncaojsuKEX468Rz+HrtOUHb+Ihv0R2HxqlDg/d3ye7W4TDpcK5Kon7S/QiiHVGIx631vwwTDf7rr+/3OFApLIwfCfgf0i1OS8TU9O4vLmDiHXNYdXAXVULwOQdgb9Rhq/Xa6eNUBlo8/t+PUHZiUa/8fEUB7Jo8EjQ90Ql5QcTgFwYH5wzKIc2gA49I6ubfwQG/tTqStT6QuIwRgzHE8Mvj8OHDbNy4EUEQEEJc30VRRBRFMjMzTyly8N1332XRokUsWrToZDflVw1BEGhoaCAlJeVkNwWAL774ghUrVjB//nzKysr45ptvuOmmm052s9rEggULuOyyy8jJCe1sawvyz+G8885j/vz59O3bt+0NY/jVInanc4rjZBOBkRDJLtzefZgcDj7+9F9SgAR4LVHpDdXonI6oaw8BCqvz8+KtYQlCOeRBJoFqwXA4as6RyEGr5SAYQDPWQJJeSSLVf7of68ZKHPpKSseHTnretfsuSskH4TlpnlxV6SNbPO7Q0QAqdUJYIk2t0XRIQRZKFRLq4ajcVI7FaZFSf30otRwiP9BiHKFWXTQWZ984lO1ZqpgfsYA8KNR0hj7KH0iD1nscX63BEFkfJ1U9qA5lEQ+HENbxXxqRamPKlaGhLMbhalZGg/T6XWTUbKM2owhz4vm8n+yXf6nUyoTqr7tMxWPPY9ahj0hxNfqJJUHwkoKtf0dElAShkJaGWF9PwsABCOlWYE2bfVEo9OSKwQAoCY4WhZU4+R01B4QMauKMpOgdiHqk72AgzBXGqIgSgIQMW/vqD/qOKcB2mX3bE6/8fJ22euJQYV2+nGFTp8LwkW0ShJHGBvyqUamfVgPx2mbFPBvJ/FtmO5ea7czAfOAeiXT7Ktub7DupeZFiPXnacVcTXGH9nppkJz/mhR2RiNjV9xgGXva298A9QQRhKIRTOyZYvIRbSkMDz2ge95cDYY60zit98uiTZAj6DRe0Wtx/vhPLhSOxFKTAGj85eKD+ACv//jZVP+8mSWy9zgSUNOj+4gIuXLmSFVvWcHDzhiBi2TctJwaP9OlBbVoWTfFKxSTA5j7jFNM/jjpT+nv2Vw2km0UFMegRYPbkXgzKS8ZRVoazt4qje25i3WevYDe3ngNWABWCVfntlROXMWIwhhhODoYOHcry5ctpaWlBDPM7EBcXx9ChQ3/ZhsVwSsHlcqH5Ba7P06ZNY9q0aQCUlZXx+uuv/2rIwcmTJ4ckBz0e7/OuShWd8+Hrr7/u1LbFcGqi8yLvYvifRIE+jsGJ+g4Rgz700Kkpe+tF3FuUD83pDdVk1x4jtaku6tpFgYjGYgxem7E9sQyHvpJWKVG7sGv3XWzYMJ01a8/AavXXwXPV2bBuqASRkEnKAJXkUkq+pHj0Yb/FzvZmK7vqD7Bm7Rls2DBdQa7IsWPHzYrjHi/CqULcLqWqzmclvnTxpQqrLnhTgC/75gpuGLKBpnPHAESsVedTyo4c+XlI4shHOm3YMJ0626uKZT1Or6DvJWUMmHkQXZL3XNElOUjIsHmnBYHC4jHeulj6PP7a6y8sPPcjyR4HKGoNBsKnHjxZ8BGEhSNGR1SznWxiENpRG7OlieblyxGdflZD0GrJe/YZ1OnpEbYMDZXoYdDut8mo3YHTx/Vpa1HFH0WlU6q9VLpqVPFHaTC6QtqG2yQGZetWpRipSQpdTgGtFrG+HoCmn3/AGRfd2CiIlDba4zB5iQx7o/IafEDI4Kg9FYdJR3WyISjd2IeG5HSqMnKpEnJb96Mk/eREyYCZB4O+ZxEhJyNbidedQ9LZMSoVZ47yOntgUBIt3Ty4MkUvQVhWRcGwCOpXiXQMrRis1mUE2XIbdGnYXbmcsbovF67O4eKVXdDZQyvbwEu6eexels/Y6zkM+S+zabBSYblqaB1fTqjks8kVmPTewJtsW5NiHUv57xm/rj8Tt7TvvBbU7a9jKIdBbyUhw0Z8ioMcjpFPKV04olinT5KBwYl68rUqxfex3FTOhYt/w7VVzzFvzYOKbf740x95LW0Jn512FJNexkrKCEKPIJB85plceNcDFI4YjaM5jt0LC9n7aU9JGasT9ApicOHUG1gydDrr+01qVz8PtP7My4lBHxxlZRw851wO/fa3uP90C8VbfmbC/iOKf2PWVKOWXSLcDjX5w0dy4V0PxIjBGGI4SYiLi2PChAkhVYPgVTRNmDCBuLiOP3/49vPggw8ybNgw+vTpw4cffigt+/bbbxk+fDiDBw/mtNNOY/dub6hUZWUlU6ZMYcSIEQwcOJBbb71VIloC8f777zN69GiGDx/OpEmT2LZtGwBr165lxIgRDB06lEGDBvHaa6G8USe2nU8//TRFRUUMGTKEMWPGYLVaI7Z5x44dTJgwgeHDhzNgwAAef/xxaV9Op5P777+fUaNGMXToUH73u9/R0BA5wTJSnwBeffVVRo0aRX5+Pu+88440v2fPnsydO5dRo0Zx9dVXR+yn0+lk9uzZ9OnThzFjxnD33XczefJkAFauXMmgQYO4+eabGTx4MEVFRWzfvp1rrrmGoqIiRo8ezdGj3pfL7777Lr/5zW8AuOmmm9i7dy9Dhw6VCMP9+/dz/vnnM3LkSAYPHswrr7wCgM1m49JLL2XAgAEMGTKEs846K+KYfPTRR4wePZphw4YxZMgQvvzyS2nZ5MmTFYrUGTNm8O677wLw9ttvM2DAAIYOHUpRURHr1q3jz3/+MxUVFVx66aUMHTqUrVu38sgjj3DJJZdw9tlnM2jQII4dO8Y999zDyJEjGTp0KJMmTWLv3r0h29azZ0+2bt0KwOOPP07//v0ZOnQoQ4cOpby8PGK/Yvj1IHbHE8NJh6+mmi5Z+eAkJwRTm+r47Zfv8MmF17Zr3wl4CbmCgjspKZkfdj25zbjrD0+DPSHsuj7kGStDzpeTI9atNd7agiKo3MFEZSW53C28EnI/t/x8SPr7eXLbVEBGS8q0hZABGGGCLgKtxOGQOHcOXS+4ss1adZGUstH2Lz7NTnyanYKz/Wox886LuWC2V7UZqIaE8KpBH6JRD0aqF9kZiKggPEWIQYi+NmbNE/NxfLke4+mnS4Sx6HRy9N77cEdIAo4EH0FYq70ZIT1RshIHwmf5/D4f0mUBEO2GKJLdZCEzXDJxK9Hit9BuB6Dk2zxSHTZSL6yXVg20MrYXgcqsmjgDtPiJuVAIrO12/cL56BzK64xvv4H1BtU6d5vKvcD5umSnlBDbFLBq6oX11F3o/TvrYS3m5cuxF4dJThdFspq814NA+3dgAI0c32X5Fa2zDn9EkqsJjyaE5C6wG1GSdKEsxj57cGbjepI8LlZFtScvik2rWa+7VJo+q3opqc4GdB4ncal2upxRyzFLDm/tuEpa54aiv9OyVoXG4Wb8pZuC9un7TZT6Zj+KGN/THzbU+n2M9tru67OEEL8VF955P188/wQlm9crVnWI/u+N3dD2b244/KBt4ahBpFTjURCDAG5LdP0oX1yMNS0el+0YLlt/4ozTKCweglode4ceQwwnC6NGjWL16tW0tARfg3U6HaNGjeqU4wiCwJYtWygpKaG4uJjx48ej1+u5/PLLWblyJUVFRXz44YfMmDGDXbt2kZKSwpdffonRaMTtdjN9+nT++c9/ctlllyn2++OPP7Jw4UJ++OEH4uLiWLVqFZdffjm7du3iySef5J577mHmzJkAbRJpnd3O9957j08//ZTVq1eTnJxMQ0MDcXFxEdvcs2dPli1bRlxcHDabjXHjxnHGGWcwZswYnn32WQwGA+vXe6/zjz32GA8++CB//etf292nnj17Al6CeP369ezZs4eRI0cya9YsSSVYV1fHunXrEAQBu90etp9vvvkm+/fvZ9euXQCcd955iuPv2bOH9957j9dee40//elPTJ06ldWrV9OvXz9uueUWFixYwLPPPqvY5vXXX2fOnDkSUeZ2u5k5cyYffPAB/fr1w2q1MmbMGEaPHs2RI0dobGyUCNv6+noi4eyzz2bmzJkIgkBZWRljxoyhvLy8TRL87rvvZs+ePeTm5uJ0OmlpaWH06NH83//9Hx9//LGksF20aBFr1qxhy5YtZGd7y+jMnTuX557z3i//4x//4I477uCbb74Je6yGhgaee+45jh07RkJCAlarNWr1YQynPmLkYAwnHfKaatcvnI9Dq0PndEj14nxIaAnzAB6AGeKHDGWLouagwdAn6vZ00dpYaM9gXZLAFo+b781+K6+zVyIjMzZTqN5PtSGX7NbaTnLIyRG32ataQxTRWXPIX/0UHrUdh6GCY4PfjFrZGM16nZFcHTEZN8RDn8+S2xaMCckkTh18XG2Ltn9yUtCH0b/z1skLVyPrXxsP02x3oRaEkDyHKILJ7uJfGw9zzfhgAjMwdfun0f0BOp0sDEkQnkLEIChrpVpM+9i9915pWco7ajSVAiq7gKPGewNpXr6cI3PuJO/ZZzhy9z1YVqw4ruOrRA+Tt71GTdIMPo2iTGQQuREtWonBaGoOBllozVqqRS2p+G8S5Qq9jkBuMY6WYAws1+DQ6nDUKvcDoqQ+kyM+pYW0Zhseh8AxT4qSCAxjX4420MQZL7K7Rw5VjuDEYkSRLLuL4WGCYwKtxOHgWy/F1cSswx9J9SnlBKJ0SHd03195KElXk50rrN97E4bdDrJt9fSprKM9t11pdjvIPqJUZwNZDi9xrmtx0CPpSNA2uYZKSPIghlHA53CM58VbsRFPAnYOf3EXSZtewrpiOeD/Pur/fGfI7QMRMogl4LcCUARwyXE0Lw97fDz1xmArccTjbq9HMLu8YSo2Nwc7yO9L8JyNu6UborsMraEnZTsb+PbNnZx946AYQRhDDCcJPvXg8uXLFdbizlIN+nD99dcDUFBQwKRJk/jhhx9ITU2lqKiIoiJvgfArrriCW265haNHj5KWlsbcuXNZvXo1oihSXV3NoEGDgsjBzz//nG3btjF6tL+0T319PTabjSlTpvDYY4+xf/9+pk6dyoQJE37Rdi5evJibbrqJ5ORkAFJTU9tss81mY/bs2WzduhWVSsXhw4fZunUrY8aMYdGiRTQ1NfHpp58C4HA4JJKvvX3ybXfFFVcA0K9fPzQaDZWVlXTt6nVZXXPNNZKq1OPxhO3nsmXLuPLKK9G2ChOuvvpq3n77ben4vXr1YsQIr0uhuLiYXr160a9fP8BLTv/73/9usw979+5l165dis+/ubmZ3bt3M3HiRH7++Wdmz57NaaedFkROBqK0tJQrrriCI0eOoNFoqK+vp7S0VGpTOJx++unMmjWLCy+8kHPPPZc+fcI/95533nkSMQiwZMkSXn75ZZqbm/F4PG0SmElJSfTu3Zsrr7ySs846i/PPP1/6XGL49ePkP0nG8D+PaGuqRWst7sZh8vFabAcMeIHkpPaRUip3PEfTtDw10oCqyoZuq58cFI1a1iZPZi2TAbhffJQitocPBDHqFP3xhZ74EKjiCIexQ1+nmza6RN+OIiIx6EPAQ1+PpB4svmixVHMwXAqwz7p7PJCTTmbTPn6WkU7Wkokc3nKEhEwr3SdVBW27a/etWA9M4fD+QyDqgvoy/NKbuXJM9zbbUNwzLeT8wNTtvRYb1+4sk6YDw2XkcLs9HNpZR/dB6VE9hEaTQn2yodfnIzqdVD31NJzun6+pFNAdDuijKGJevpyyq6+hZceO4z62OiMDw8CBTNj5KZ+Ob9se3JGUWUTIMlnDEoMeoCZJT2qcBeLFIAttfIoDt1O55XGFfbQiWsVhQ3I6Dq2OutQsxXzftM7pILW2Dl2SgwEzS0LtQlHfUHgTKuQEYRglYbR93JCXh9maEHo/goBx7BiMXXthXbGCIeVVfN+/By1aNQgCOk/bSkBAsZ4vwTYcfPUHVXFVqOIqic9aoljet8xISnMwOyXfb4tWTXVSNvNfr+JoBjw3o+3va4JTSVzL25zTuz9wUEou9iFe3UL26cEvreSQq9AP/mynubqAQSxHhSh9H43Al39eRJ3DyrV//xwxxx+wcmVaC/YfcvDUJgSpbn1JyzqPk4Mb13Jw03pWrFvHwUNH0CWne8uEJDlQ69yUp/TgM/c07xfmCAg9XYqAFDlOF79mmeB/qBLMLlTN3vHI0lcTr27B7o6j2uo/pw3tqRErqBAENWpdoXdahNJttRzaWUf+kMzI28YQQwwnDKHUg52pGgyFcFZmH1544QWqq6tZt24d8fHx3HXXXdjtwffzoihy9dVX88QTTwQtmzNnDtOnT2fp0qU88MADDBo0iFdffTVovV+indG2+bbbbiMjI4MtW7ag0Wi4+OKLpf2JosjLL7/cpm22Lcj7FB/vF0ao1WpcstJGRqO/JEh7+hk4ZoHHiHTMcBBFkbS0NElJGIjdu3ezfPlyli5dyn333cfWrVslMjYQl112GU899RQzZswAIC0tTeqLRqPBLXvekPfx008/ZdOmTaxcuZLzzjuPxx9/PIis9kE+docOHeLWW29lw4YNFBYWsn37diZNilzaQ61Ws3btWn766SdWrlzJmDFjWLhwIRMnToy4XQy/Dpw6T5Mx/E8jGoIw1VTPoztWMPqq61ljsvHowYoQe4KusppKAkhpzwPM/0fjga0giojqFoWVOHf7jegsXVC549FZc2hI8j64i0blg0/gtIkkIHSyrtVairtPPY4fK4NIQZ/F2KfiKMh/i4qEbIWV+K/9u9PbEB9ReRYp0bc9iIoY9CEEQRgK8hTgzoJen4/b5WLle29jkO1adKvpOqQHhl4rw2/bawUDegUkwbb2BeDRDhBsPivxfovyJmRPwHQgeeiD2+3h2zd3UrqtlvwhGVGrVKJJoT6ZEJ1Ojsy5E/uODQpyUGUPcyMriiGJwaOGDGyaOHRJdnKoAbtAQ4uBTJMVFV4i0F1XJynV4ouK6PHuOwhaLcKcO5n/xgpWD5rBBz21ivTYiVvSSbFo0bpUkS3FYWyzKm0BWkMPEP4PRCWB48GrZmvormPAzMaQu5UHfpR8k4e9Ia5DVuKOINBKLMdXp/9W+vuyfz9JapyJGqdApjbyNaF/XS0WXTxNxsjKx6gTYq3aiHUWS7ZtRhg+kqLTTuPHI/slYhAiKwHlttxQhGBbxKK+2/sh5+/taW79q4GLW23qJr3Tm6bsO8daA2wgm+H7q7jhyxQqU+NpMDazeqjf+jpwTw4pTakkOD10NdmZZf1IItvkba6trSINyDbU8MT4x7C747zEoEFJDJYty0VAUIx1xdrf02LKxe3U0tJgoSW1LxsGTmfErs/RiB4FQbhl2jRmHVzJ32U/YdlaDx6diF3vwq0RpXM30NL9QPJOVqxZw8NDToeiKQDc/OUzTLjAe82tM2VLSdKAVwUYBjnbj8IQ2WehErDjJQafnOCve/XYuod55rLzyUyMJz/DgC34XVF0ECB/cAbdB7W//mkMMcTQeQhUD3a2ahDgnXfe4ZFHHqGsrIxVq1axYMECDAYDO3bsYOfOnQwaNIh//OMf5OXlkZeXR0NDAzk5OcTHx1NZWcknn3zCJZdcErTfadOmccUVV3DTTTfRvXt3PB4Pmzdvpri4mL1799K3b19uuOEGunXrxgMPPPCLtnPatGm8/PLLXHLJJSQnJ9PY2EhiYmLENjc0NNC/f380Gg179+5lyZIlEpH0m9/8hvnz5zNhwgT0ej1Wq5XS0lIGDhzY7j61F5H6OXXqVD766CMuv9z72/T3v/+93fsPRFJSEk1N/t/jvn37kpSUxDvvvMO113rLXx04cIC0tDSsViupqalMmzaNc845h0WLFnH48OGw5GBDQwP5+V6xxwcffKCwm/fq1Yt169ZxySWXUFpayurVq5kxYwYul4uysjKKi4spLi6mtraW9evXc9lllwW1NRBNTU1otVpyc3MRRVGqlRgJzc3NNDc3M3HiRCZOnMiuXbvYsmVLjBz8L8Gp9UQZw/80oqqpNvs21BoNKrVSgTJHfIoMahVWYlCmoxYZ3iexZjiIYE8sU2yvs3QhvrknAHG9kik4Mw9KDiMaNLRMyPY+tKhVQaqGJExAsOVVkdg6AfJ/fAqdxf90JVmMNXb69+9Gl/z+bG9W2qZ7G+IZnKgMOogm0bcj8NV9jBqy9F9fEnKgxVjlasDUvLNTVI0++EjMw/t3M0BGDhp6r4x6H/GpLUoiRkZ2Dv79TOxiS1Rqx0ArsRxPlyrrUfrIQznRKxGD2702wdLtte2ysak1GvKHjjjlCEIfMWhevhyNKJD1sBZPvIjKLqCpiTLoAy8xeP2Z/nTvJ8Y/Rrahht0L00k9nMTEggF0e+5Zjt57n7dWWkDYTd6zz2A762x+u+pfpDYU8bYsPbag0oXgCR3Q4e+IiM7pJtnWQk2SQbJFqrSFaA0XUGcU2DngegbtfhtVK0HoIwarkg0k6KJTBTstWhxNOiC0FbezEU3yu9pZybIR3vo4VCbwxxxbRIJQbRcYfbiCdb3yaNLHtRmgEgoKW3VbwyCKHNy8gVK1Go8huORCOCWg3JYbCnJi0a6KJ95jlwjG9tQdNOmdfDbZT8b5CEMfQfh9/x44VWrSTUJr/pWfHFwf91s8Sd6TdZb1o7B9cTX4bT+BhKAc1mp9kJ27xZSLvaErTstiPM6DIOipU1v5YdBIJu3cIBGEjduXkn/JfzBeIkCln/iNFyBTRjb6XrgEWrrtHhVHDuyFIf43BK4EDVWWTOzuOEyWRMX6grlVoRHitzblWC3X755P1pARNPY9k3dMXidBoHJSFK1sLG9g9uQoagqEQysxGLMUxxDDqQG5evBEqAbdbjfDhg3DYrHw0ksvSbbWDz/8kKuuugqXy0VqaiqffPIJgiBwxx13MGPGDAYOHEiXLl0444zgchQAEydO5JlnnuGiiy7C5XLhcDg4//zzKS4u5pVXXmH58uXodDrUajXPP//8L9rOWbNmUVFRwbhx49BoNBgMBpYuXRqxzQ8++CCzZs3ivffeo7CwkKlTp0r7mzt3rlTnzqfOmzt3bpvkYLg+tQeR+vmHP/yBHTt2MGDAAFJTUykuLqaiIrS4JFoMHjyYgQMHMmjQIAoKCvjiiy9YvHgxc+bMYf78+bjdbjIyMvjoo4/YsWMH8+bNQxRFXC4Xs2bNYvDg8I62F198kRkzZpCSksLUqVPp3t3varrvvvu49NJLKSoqYuDAgZL12+12c91111FfX49GoyEzM1MKcLn99tu54YYb0Ov1UniJHEVFRVx22WUMHDiQ9PR0KXQlEpqampgxYwYWiwVBEOjduzdXX311+wYxhlMWghguH/4kwWQykZycTFNTE0lJSSe7OTGcBASp2ELUVAskZp4Xb20zsGN4739i+auXgHPoKymd4Cce8lc/Jan7cu4biSYtnu/rm6l1OFnfZOG9Cn/9w6u7pDMq2YBRrGWs0RGS/DI172TDhunSdF/Ty7A20fvQ21qDEBH0I3NI/U0hgloVsm5dKMWg1VoqqSE7m3SLSjkIYevclZvKsTgtqFwNHN3lL5IfKn34eNvos6ZpDS4KzgmuvRUJCvVgK0wGF5+d5q9XKE8yDoXtzVbO2rivfZ3A+7n2iNP6iUH5cLfjoVQaD1m4yqlAEDYvX86R2bd0eHufJbdJSOWOKX6F20NjnqFH0hH2ftoTW20ChSNGceFdD6ASRcyrVinCbuQEJaLIsVS44yb/2Dz/uot9OT0UijMffOeV26HG0aQlTszAoUtCdJVKxKAgtL6cED1k1O5g0O63QfQo6t95LbkH2+yvdC5GCvdoK/ijHYikHPRB4ygjtfJP0vSMnal003kUVmJ5/UhNjYAH2Nwjm+oUY9iag3IEjk+o7+TxIlDJNutweLIt3PaVcZksyToTQVsbNuBGjikbMwBYUewnIS9cnUO6SXYtl41PIJFoPnAPotO7j0uPfhKRzPSdq4EqzKZVw6isbpBqT8anZ9Nvxkpp+YHFD2Ot3uQlBlGe86rGLhJB6OjmoXael7CrcQrYxVZiMIAoXvPZUJqbEoOUmqNtG/EYtawee5ZE9p239Z8srxrf5jieNf5HjAYLOhwUsYP6hXrv+SEIlBt6sr77UHQaJ7mGSm4c7Fd0/mPPdI5a+/P366eQkdIL265dlF0yo83jrR8xF3Ni9xgxGEMMJwh2u53S0lLy8/MV1s1osWrVKpYtW8bpp5/eqQolQRBoaGggJSWl0/Z5IvBraWd78Ev1qbm5mcTERJxOJ1dccQUjRoxg7ty5J/SYMcRwshDqWtsefu3kP0nGEEMAoqmpVqCP46fR/TG73aidFVRujUwMAsSlpyGOTMK6sVIRDuKzEiOAvjgHTZr3i3Raml/VICcHRyUbuCQnDQiuP+cj7qwWJSmgGeMkrtiAc68drTkLdaIO/dAs6ViBfYpoJe4kQlCOaOs+AhEDMHxkmql5J/JYkONNUg5FXvqIBLcjulqUcoQKRnCqlfPaSus0qjtWI87kcPLte3uDiUHw1rmKQkGoGA8ImSQNUFprwdISvl6KIU5DfkbnqE99ME6ciPH00yVirj3wAEv69OVYcgqiTkkUHWtV3lqSDRiwcPjAaqnPibK314HEIEBuA7z4ugubDuIcUJmUHZYYDCSsWkx1CCSjMVyIWlvgJwYBBBW1GUXsGHAdTstiqpP0/mCMaC20PkLM15ZAYs2XzKtSUZ2Y4H+50EGiMLWpTgp+qkvNUliJT//hHYzmGuy6ZjbLallXOVUkWVsUFuM4eyrqw17ltE8xWZ0sO5faaGNHAlTaC7kSMJyVOBxCpR5bD89C0JhIyP087HZyUlDal9FrV5ZbjH3wJRvbtCosQiqrEjOkZc1JiWAibNvDjZmzwUCqpSsVtgOotIWI7gs48NUURNdSnNYKHM2LoTUpOPich/W9Cxmzb7+iDEA45WiVJZO3jdeBMXjZuoRicEPc6ipaJmQjGjT8p+A3xFVFrokI0M1dxji817ejP2Wh1rnRJTlwmHT0Vu1l+sSvQ253Wb/Pgc/Ztvkpxo5Z2qYIVYEYMRhDDKcsRo8ejVarZfjw4Se7KTH8ynDGGWfQ0tKC3W5nwoQJ3H777Se7STHEcMoiRg7GcEoimppqfvKsF/mtQRVtBXYk/MZr/7NuqERny/E/aOMlBlN/Uxh0nAydNuK0DworcQCkNgkw9syl6PWhwy86K9U2sF3RKA2jIgjbSMYNR476pjuidmxL1SgnGQy5VrqOq257n7JgBF9tsMZEJYlW0uQNYghnMZaTufstdkW9yEjY8q+DWLfXBRODPrRBEIYcjxBJ0qW1FqY8t7LN9qy4Z3KHCELR6QxS7AEIWi1dF8z3EnTLlkW9Px8xuGDADSGXv7XDr0R94pxWi/E/4Mv5SH0ORQz6kNtatqUqSU9VSggmg2DS2DctukoQ4oqUxGArRESOxZfjUfutxz5EZaGVdtRKAoKXZGu9NvkSkT3A90N70yJ6jltBmNpUFzQ+amcl23suD7n+qmF1rAKFxVisbAIEhZVaEUgiilERhCFxHORnINpDCMoht8hGqxoMh1VD/S+XJItxKxo1yfw7/fJQm/F14jnQ+o4qkuoxMOil2nKMNE8yk8dcQ6WukNIdtVirNuBx1uKNP/aXsAh1zjfGu9nSI5th5VVkPqxFjBdx5Yg0XutfN/kdNQeEDHbre0JK22Mg1ROMknRLUjcDXvLRNUhHyhBLa1mBwqhTr11uC/GG0N/1oOZp4mPEYAwxnMLQ6XSMGTOm0/d7KhnobrrpJtauDS7xs2bNmlOqne3BqdCndevW/SLHiRZff/11yBqT8+bN49JLLz0JLYohBj9i5GAMpyzUGo1Uz64thCOcAgM7BLWKtEt6kzSlG9Yt1bjNjpAqPjlOS0vk4yGF1DqcZOi0CkWhHNGq445XRdceBBKWbdl7o6r7GIEYbJMcjaINgYimHmI0qqNQaq1AS58c8uTlcBbjcGTu3J45PF3mrzv41/7dKYzXeYnBTRGIQR/CEIQRidIAgjCSYlCOaNdTHMpHwi1bhvH00xW1/sBLEOY9+wwHzjobd214W6QPPoLpWFJyVMe3u73jrta6pT5fcOvdHLvn3jYVi5kmK9mNZgWZJbdnyuGbFsWeiO6eQfsSRbe3bpurJGKdvEDyJii1V0YCQivZlmIku8nCkPIqqpP0HM1Jp8Xjjo40C2VDls8TRTKbLDi1JmmxIEZXIzH+/zRkVYCmRsAFrCvsQpMhPrhdURKEodquc7pxhFB2/pKQh5NEW28wGjg1ytCNwDp94RBpvVAqzEpKGDHyEs4cOZB37vwjLU7lC5u2zvmGZC2byaZHpZX0mma831I/tJUCRYcbqOyTFR052HoNk9fxPdf8b5bvmCCtMrVoNfmGcpLUzQwy7KbKkskDP/rt7U+Mf0zqYzRwOhpI6jmIwm/+g9sS/Lvr8Yis+ewAhw7ayRkzIEYMxhBDDCcVr7/++sluQqfjv7FPx4vzzjuP884772Q3I4YYQiJGDsbwX4VoAzs0afEknR5avRcK4QjBaI7V0fU6A4FEZDTEZEiCsA1iMNp9t2c9H/KHjqCweExU9RAjPTTaG+Ow1SoJ4MAH9XBor8W4n1F5nN6GeBJLLFg31hE1RCjdVsuhnXXkD8mMri6kjCAsuPTm6I/VDnisVsqvuRb79u0AmJcv58icOxUEoeh0cvTe+7xJwm3tD7/yTCdGR1T6QgjcDrXU509uvIrBG3ehauMcUQHDyqv8x0x2hq0N6LcCl3Hw6zNwmrOVbXeWSXXbIiGihVYUiXO6GVJehY+WGFZeRU1DM+kmK1vbUcfPtz+d002y1U6NTIEoqRJbScdh5VWMKK+iR/084l1g0Vl4+ndt7z7pkICmAVzA9/170KKLcBshU2aHsktL68jmZTVZEMHb9pOIFFcTF9W9g02rogoVB2TLuh/ohd5twxFnp6RnO77TeK3FcrSVkOyDQW+FCBUUQr0gWf7em+z+cSXm+j3KY0aoh9kjIGhkXc4AhpZXMdK+S7Geyi6gAs7ct5cu7rfpM/+vlFlE5ny81d+molR0iVpaVIJUc3C2uIA4vR0RqBBzFPs0GmzkJlWTgJeo9r0E8MHujkOtc2OrTeDAl93odeHh8AMCbN12jfdlVM/wL6OmDBjAoZ11dB+UHiMGY4ghhhhiiCGG/2nEyMEY/qug1+czttVi3JmBHe09dlv25hON47X3RlP3MRAnihxtTz1ER3Mc5p0Xc9qsK3F7TGzddo20LK/vMA7U7VFsr3VHp0AJTGIORGC9yEAY1Wq6D0onf0hG6FqDodBa/6r7oPT2Bca0kmXNdicqcQSeEFbYjsJjtQarAUVRQRACYa29QftDaUmV14hrTkr02ipbcUPR38k1VFK3PpnGbwzUOZL8hIgoUuGwkZuYQLbJGvpgMsgJQlNGdOOj0gQr61Tanqg0BXickZWDEEHdKgi06DTUJemltqvwKhwVdfyiVdEJAg6dhm5Hm1GBpED0qRJrGprJNFklInJoaZm06V3/ghdmBH/Hb/vCTV6tSILDa8+WiEFtFGPXShAq1IBhLNS+eTXJbSRJtxcdCHQx6Z0snVAectmhXgdCzp+yMQOjXUOj0amwEk/cmk6KWeuvOShDiquJPzjeIntSA8csOQr7vO+cj1e3SJba9tRmtJmaKN28IWh+tLZctc5NvukQHw88g36rD5P5sAkxIHlcBRQd3IPxxSdQ3/eoYnvRqMGeqOxvHHbmC94wMEHjIo4qadknmiv5xAqC2cE14lsYPMrv8jFLDrmnVWL5j54Ehy2qPrT1MkqtVpE/JDOqfcUQQwwxxBBDDDH8NyNGDsbwX4dfkhCM9tiB9uYTic6y90ZT91GOE0mOtqce4gWz/SSmnCiOm9SNL1uUashh/Sdw9YUzsYstlDSVKKzET058koLkgrA1BwMRaDEOFS5z9o2DQqcUB/VFWRj/wMYNbVqrFRBFqnduIj8znYPG4DqaHUFIYlB2PB9BmDx9WlS1BkPWqkNWI86EVG8NINdQSY+kI9ibNMH1+gSBLtp4MpujIwzATxBuSw0OFgoFtzPY1ikgkGvvgdOyQxFG0i60WoozZaRmuLFpz/6yTFayTFaJDARvCrScGPThWCrYdODUhT5WnEOkoMrftnW98qhJEXFqHCEJryC0EpbJFjtNhviQFuogsrATkNmzgJqyEjI7QDpGqyqWo1daH5x7jgbNTzFrlWnFAchKqKVHUnColu+c98GS4sFES3RjHgHR2nLdDjWl+h5ctns1qS3NqGoEwrHg5uXLaRb0YDxNmpeuqiFOdHNU8Kv05Zc9ucXYZzuOW+09Lz4iOGFYIk5T4bqG9+hLWZt9UIudX8c3hhhiiCGGGGKI4b8RMXIwhhhOAKK1N58IdKa9tz11H+HEkqMdqYcY2J72qCELkgsYkD6gw+0NVY9QrVa1TRCGSMxsj7Xah+xGMzOrvufJUT1xq45PPRiRGPShlSAUPR6MU6ZgXrkyYltrIgSDQLDdUmEllsNHCkdZczAQ7gYtuxcWoNZ5IqYKu6zr0RovRBDUiKIbj7OErCYzRbv/D0RPx8i8VrVcXkOzNKsziMFhMotytsnq32eKkexGs2L5sVS446bItwLPzdDw4usushu8+zmcoVLU6gwM2QjXriHlVTR0zaFbQV/sh6pBFCULtQhszs9tX38joOfQYbTs2tP2irI2ysc70P4bDm+c+QYpcSkYtAa66vP44vknMO35UbFOuH356v5pE9xUWTKps6UqlsfLah3WOAU+HORX2bU55hEQbZK2vSWNC8xNdD+2u+3UX1EkdemX/LXLbjwWO3uHdmeY4XsAKsVcbMRLdmHFZgb/uSeYok+ed+nUHPiyG26HOiiIqnxZF+wNOlIbWqj91wL0Ly5Q1ESNIYYYYoghhhhiiCEYMXIwhhhOAE6mvflUqH14osjRjtZDDNw+lBoy0DrclpW4w32IRBCGIAbl7Y7WWuxXZlXzwPq/88SoqzpMEEZFDPogilhWrsQweTLG0yZhXvl92FUDg0F8RImvJp/cYmzQW4OtxBD02XckBKU62QCm0NSHIlVYLMFp/hKN4Txclq/xuEpwWiwgeoLqGAbV1gtF8slstJvzc8luNDOkvIptnUgMyvtZ1WpPrko2SEm0KryKwWhg1fn349QqSZyIKjt5u3Q6xn+6CJVeL1nPVaIoEZiBQTEdhY8YPOawgiD46xeG22+IEJQkq5aLV3bxJpkbnKwa5rcJ31txDX0KB5J7Tv8gVfH5d9xHxW2/5+KV3nEJp/KT1/0LDN64Zchb5BkryTbUcOSnLCzH9FRpPTDMf153RNkoRzRJ2irM1FrMdENsmxxsRUGFt0/dSo/gG7EclKrI+8VHMZHEPvqxVDgXweICt4ci8yb2EV0t4H5nlUpWa8sxfXAf6hKwifGsOriLC1euJPnMM6PsQQwxxHAqwlcu55e+p44hhhhi+F9CjByMIYYThJN183Iq1D48keRoR+ohBm4fSg3ZI6kHiy9ajMVpidpK3FGEJAjDEIPydkdDEGY3WRhWVtlKEImMqdzdYYJQdDopv+ba6IhBaSMRy4oVxBUVRVxNTqg1dNcyYGaJtMxXW02yGLeI2IgPIt266BK44Na7UWs0/hCUKNsaSrkYMVVYwEsImv+F6KoEAaqT9GzukU3XhmayTNZgglAUEUTRy/+GCN4ApJqCVckGfx2/DhKDY5IyiZsyQFJthlQhCoKCIEyIUqxVkplBnVGHU+ug0ahUdfqmg4iwQMLS4aDigT/SdcF8ui6YLyVeQ3BQTMQxaP2+hEL+sGLcdXUSMejrc/h9iSRbWxh54CjbfWSxIFCe2gObNoEEh5WCyu2skm3Sp3Agoy85C0H2PXW7PZRtq2L70rexm0wkEVmpJq/7Fxi8kZ7QQLahBoAaF9Q7VDQG1AkMO+YSEhA0OYiu0ojtaCtJuyrFyBZBkF1TwkP+sQhhHP6V5PKU8LA0LVhckpW4LWIwsAYjIL1QqMSvTpT6IAhUpRipSdQTXQ56DDHEcCoisFxOW2VxThWsXLmSOXPmsHXr1pPdlBj+ByAIAg0NDaSkpHT6vjdu3Mizzz7Lxx9/3On7juHUQowcjCGG/0KcCrUPT+SNW3vrIUaLE0kIgpdsM69ahXHiRNRarZ8g3FYbkRj0oS2CUEkMeqEKQRCqdNWojT/jrJ+AIU6D0+Pkg90fcFq30yhILpDaemTOndh37Gh3P9UZGbQEbOfKFPGECDMYVl7FjmylnTJUYEJgoEV2k4XBh0o5ds+9dF0wH/OqVVHVOvQhULkIbacK61xuHGKljAERqE42UJ1iJKvRzPDyKj/BlWIkzukOJvtaVWpSIq+MwApM/g1UU4ZE61iMaLCR/8+3vaq82+/AtHIlW7pnhSbaAgjCF193YdPB0QyBl6f5ySFfEIlFl8CurnqFlVgOefiG3O6abLEHKRnl4TUdJggFFV5NpBL5w4pBEDh0qLRdBGuTIZ7tPbIZWl7F1h7ZbOg5gC9SzvMuNMB11gNAk7R+zum9FcSgy97CV0//QMn+xVGlV4OXhKuyZGJ3x3HMokzt9U1bsfFevhnyzUHbhxtzAH1yCt2K5lC2qwGnOXKbIp7zrahKNrClZ06bBKFvxD3ADn0ODQu1QXZ9G8okd9zRKyADazBC6zgKufxFuFOad70wn9RW3WLB8GLy21EaI4YYYjj1EFgGJ9ryOe0+jsuFppPuJ38p/Brb3Fn4X+77L43i4uIYMfg/guiK6sQQQwy/SpzM2ocnGj4FYGcRgycaPrLtyOxbODLnTkSnU1IQnndzUZvEoA8+grBwxGgFARKKGPRBhcjYqt18WfcVr8/KJrvf28Rn/4ezpywlN0XN3B/m8sKmF7jq66s42OglEiSyrR31+wC0PXrQItTg6ObBlend1pUpUv2ok9p5LqofdVKZH4endb6rm4deolLtF5/iICHDhi6pVdYmCDi0auKcbn9fy6tQyYJQDGPGYDz99KhJIR8Rld1kUfTRYfLaKgOJwTinG4dGHaxYaz1edbKBzT2yARhSXkWy2RZaBdjal7DhGK1t8dlO+15SxoCZB/1jEbBeVpOF4dUmMJmoeOCPiE4nblEMTwzK2uEjCLMboKAK8mqVn3VerTeIpP9hG3FRpsM6NR7veDlcjD5YEXw+yj4zgK4L5ns/N0CVnh72c/Fu62u7SGKmoDhHfMRgqHTeiAj4/OwaNTad36YqaGv55Ay/LfaPC92oH5qP6PQq91z2Fv59xz8o2fdl1MQgQLXVayX+89r7FAnF4A3e+PPa+3hh6/VR7SvQYjzlmj9w7uzhFAzJRmu8AJU2TCiR4O2nozkh+JxvhS7J+11s6KZlS8+cEJSsEnK1qsMUh602AXujf79BdQejuOb5IK/BWPJtnqQwdmiV7ZZPD5x81q/mNyKGGGJQwmotxdS8E6tFeW21Wg5651sjK6OjgSAIPPzww4wcOZJ58+ZRXV3NxRdfTFFREYMGDeKNN94AwOPxcOutt9K/f3+GDBnCiBEjsNvtuFwuzj77bIqLixk4cCCXX345Fkto8vLbb79lwoQJjBgxglGjRrFixQoA9u/fz/jx4xkyZAhFRUU8+OCDEdvcs2dP5s6dy6hRo7j66qsxm81cd911DBo0iEGDBvHoo/7k+Mcff5z+/fszdOhQhg4dSnl5OQBXXHEFxcXFDB48mPPPP5/Kykppm6+++oqRI0cyZMgQhg4dyrp16wDYsGEDU6dOpbi4mGHDhvHJJ58AtDkG77//PqNHj2b48OFMmjSJbdu2Rezf5MmTue222xg5ciS9evXi7rvvRmy9H5g8eTK33347Y8eO5ayzzqKsrEyhlDObzQiy+x5BEHjiiScYNWoU+fn5vPPOO4pxlKs6i4uLWblyZcRxC4V3332XqVOnMm3aNAYMGMCkSZMoKyuTlj/33HOMGjWK4cOHc84550j7euSRR7j00ku58MILGTBgAFOnTqW+vh6AtWvXMmLECIYOHcqgQYN47bXXqKioIDs7G6vVH2B3+eWX89prryna8+GHH3LBBRdI06IoUlBQwLZt26isrGTKlCmMGDGCgQMHcuutt+LxeKR+nHHGGcycOZOioiKKi4spKfG6elauXMnQoUOlfYY7RyKdVzH8OhC7Y4ohhv9inMzahzH44SMGzcuXA0r1lFqrJX9IZrv2JykIX3iCg5vWRyQGfRBEEX5aRX3tGhy/EUAFaypXcu5n51Jn86pszE4zV//nat4/7316TpyIYcoULK03r1G1KyOD7L8/y/pdv5HmZT2sxROvJHl+LkinMtlO1o2hbxrkAQk+AgBBoEWrJtliZ4hcjdZKNh299z66PPEXDp5/QdTW4qiUaq3EYJt231YV4aYe2Qh41WiRiLlI+0EUg9STimlRJLPJQreGZrLsLgSHlyAzL1/OvrPOZqNBHV3tvjYsxgkOL9mzrUc2nrToSBytS0Wc081pP5eHvcFwZXio37eE+FX/InPqTEn5aRgzhiN334NlxYoQFm0kYlaX2ELhxf6HxeZt0/E4OkAMyiEIbOo5AJtOT0ViniRMFGSEFECiTcS8bBnmVatIGDeef9/xD46YN+FxlYTYaXg4VG0HZIju6JJ25YEn+cOK6T1qrKx0AZRsuyBIQajSFqLWn4Xasxh78+GQ+5XXRQTvd3EL4RWE4cJ05FblHI5x85fPYGkxUJeaxVen/1ZKLB6+7kd2efpI655VvRSNx4kuycGoM7dLVmIAp1lLlZCLI0NHXWqWoh2+6cI+/SgcMSry4MUQQwynJAKtxHLIy+V0hsVYrVazYYP39+PSSy+lb9++fPbZZ1RXVzNixAiGDBlCXFwcy5YtY9euXahUKpqamtDpdAiCwEcffUR6ejqiKDJ79mxefvll7r//fsUxSkpKeOSRR/j2229JSkriwIEDTJw4kbKyMl555RUuuOAC5s2bByARRJFQV1fHunXrEASBuXPn0tLSwvbt27HZbEyYMIF+/fpx1lln8dxzz3Hs2DESEhKwWq2oVN6r94IFC8jM9N57PvXUUzzyyCO8/vrr7Nu3j2uvvZYffviBfv364XQ6sVqtNDY2cuONN/L111+Tm5tLbW0tw4cPZ9y4cXTp0iXsGPz4448sXLiQH374gbi4OFatWsXll1/Orl27IvZv9+7d/PTTTzidTiZNmsTChQu5/PLLAdi3bx8//PADWq1WQcKFQ1xcHOvXr2fPnj2MHDmSWbNmRVQcNjQ0hB23cPjxxx/ZunUr/fv355lnnuHGG2/ku+++46OPPmLv3r2sWbMGtVrN+++/z+zZs/nqq68AWLduHZs2bSI9PZ3LLruMN954g3nz5vHkk09yzz33MHPmTKlNqampnHHGGXzwwQfceOONVFVVsXTpUt58801FWy6++GLuuOMOKisrycnJYeXKlaSmpjJkyBDsdjtffvklRqMRt9vN9OnT+ec//8lll10GeAngrVu3kp+fz/3338/TTz8tEeQ+hDtHIPx5FcOvBzFyMIYY/ssRIwRPLhTEoE8JJVNPdV0wv0NJmmqNhinDxpLyr8/JNFmjk4GLIsP2Oik6qGJTbxUiInW2OlRuD0NLRLYWiDSJTaw8vJJr+l4ZdQgBeInBXt99i9mtJEkcPTxBajtzbjK1XTPxIASFFQTtV06KCQJN+ji2yQI1fP0yL1tG6e8OtK8+Il6CcEh5Veh6f9ESg7L2tRl+0QZ8VuL4FCUpFZ/iZe7cDjWOJi0CkGV3oXLIGD1RpNJhpSqvHam/vrpsDc3kNlgli3GCAymduKG7lrEXldDLKWAXocqp4oN6P3E1cWs6KWYtWqdAt1o3ow8cVdxcHDVkYNPEkeBqIVtfQ/WjXtVdLQ8y1joGvT6fxKlTAej20oscvv0OLCtWMKS8ipX9e+DQaRTnUCBx2nPoIJa9/ln0fQ6B8tQefiuxx6sYFNQtqHTVivVW981DPyoPde9M1s6eT4OY3G5iEILTuENBdGZwxuq+JNBEo9GpsBJLYy6rOdhz6HCm3/OgpJQLRxCqtIVojReQmVfPkZ2hiUEIHme1zk1VsoGaZINX2RmAcAnkgdZlo8mEEZO/n62JxUluk/JzjvPQ37WP+PgWBTEI3mvI2+PvJBS+Ov230t9nOtwUxJSDMcTwq0O01uHOsBhfd9110t9Lly5l06ZNAGRlZXHxxRezdOlSbrvtNlwuF9dddx1Tpkzh/PPPR6VS4fF4mD9/Pl999RUul4umpibGjRsXdIxvvvmGAwcOMGnSJGmeSqXi0KFDTJo0iXvvvRez2cxpp53GGWeEJkXluOaaaySF3NKlS3n++edRqVQYDAauuuoqlixZwowZM+jduzdXXnklZ511Fueffz5du3YF4KOPPuL999/Hbrdjt9vJyMgAYMmSJZxzzjn069cPAK1WS3JyMl9//TUlJSWce+65inbs3buX3NzcsGPw+eefs23bNkaP9pd3qK+vx2azkZCQELZ/V111FVqtFq1Wy5VXXsnSpUslcvDKK69E24775iuuuAKAfv36odFoqKyslMYhFJKSksKOWziMGzeO/v37A3DjjTfy4IMP4na7WbRoERs2bGDEiBEAuN3K39VzzjmH9PR0AMaOHcuO1pI8U6ZM4bHHHmP//v1MnTqVCRMmAHDHHXdwww03cOONN/LWW28xc+ZMjEbl725CQgKXXHIJ77//Pvfeey/vvvsu1157LeBVwM6dO5fVq1cjiiLV1dUMGjRIIgfHjh1Lfn6+9PfLL78c1Ndw5wiEP69i+PUgdscUQwwxxHCCEJIYlBZ2jCD01S1MGDuWmkQ9+cVjsK5YEZ39VxAoG5zJtgL/W2mV28Od/3Yzaj+s7y2wfc5ZXNH7Um+7W+0VbUGdkUGXz9/E7C4Jsv80Xqe8EaoklxfGPyRNPy/eGpEgDAxICFS7+QhCVVISzgi2j3DwKeNCEYPNqkSqjfHoPE4pHKXNOoDHkbQbqNSSI1BNWY2BLRBU0y9ULcWIaK1ZmGnyvvXNbfDOlqvAEnReK2im1neOKc2lKWYt6U26kGnJRw0ZXH+mX0Hx2s4n0OFXjAY+2AlaLd1eepFDd8xh1cFdOLT+2xQ/caqUOG5b+i4JGdrItRnbgE3rf0gRtLUYez0Xcr3F46tYTBUsv5yLxS4kO/oiaPLbDP4IhDyNu0GbyndZ/ofBs6qXkupsaD3v7ECwgjDFrCXdpJzfcOwY1qZGEtP9N+OBBKHHUYZK15OCIdmccd1pfP3S/qD6peHGOT7VSbfB+WRUx+H6bhdxYibuujpp20jnXkjLslO5fw0uxbQ60cOAc0J/H9LGmULOD4TZHVy/NIYYYjj1EW0ZnM4olxNIrsjhI+CSk5PZuXMn33//PStWrGDevHn88MMPrF27luXLl/P999+TlJTESy+9xPJWl4gcoihy5pln8tFHHwUt6927N+PGjWPJkiW88sorLFiwgK+//vq426xWq1m7di0//fQTK1euZMyYMSxcuBBBEHjppZdYs2YNWVlZfPHFFzz00ENh9+dr/8CBA/npp5+Cln3wwQdhx0AURa6++mqeeOKJiPtvC3KrsLzvGo1GQbjZ7QGlK4D4eH+tW7VajcvlirhtuHGbOHFiu9stiiLz5s3jxhtvDLk8XNvmzJnD9OnTWbp06f+zd+bhTVX5/3/dbF1JW7pRtrZQZCu0pWURKAJiUcGNwXFDUAbcRVEcxHEfBx1EcYAZUfGnIwhfR8UVFCm7Ivs2gKylZe1Km7ZJ22z390eaNDe5SZNSdNT7eh6ep/fec88959ybkLzzeX8+PPXUU6Snp/Ovf/2LAQMGEB4ezvr163n77bfJz8+X7Xfy5Mncfffd3H///Xz99dfMmzcPgNdff53S0lK2bdtGaGgojz32mGTNfI0nEL7//vugnyuF/z2UnIMKCgoKlwC/wqCrUZNA6MxhFkifpx54kI/vmcgX815mT0oi4SNGBGQhjRw5kuHvf010ZBwCAmqbyPTPbOQcczTJOSby0EdGSh6d4X/cbjiFwW37xrJjxw0Su48cngUJTmzrSOkqqa26aG17jnya0mQplplLSXQkZfpw1xjs1YGJBe74skECVGmjeT/lTj7qcDNLOt1OlSaq+TyAF4lcIRaf7dxEUnepzm/OPg+q1Hps5ggSym2SDwPOdansrCUsvp7IJJPkvFCPRy081CorDALUaaQCVm2CdFsud5RdENiT4ijq4rISu629u1AK0PHKsxd9T8IsTTkVPa3EvrBo7IjWAkS7SfZ4ZVQsJXFJVEbFyh6PthpIMJcTY6mU7I+xVJJgLm+q1o3UOiy3DWAoOc83C1/D5vFh3ikQdslIRKVNIb7DBUZN7oEuROeVv9TfOiePPEt4t/WUDNlL6QsW2n/xNpEjR7rODebZA4gxVDBl+Txu/PZDbvx2KTqtnYahiTRcHk/D0ERsbUM5SSrFeEfCeuUu9EGkOrgK7QoKCv8bONPi9O//Bb17vS451rvX6/Tv/8UlqVo8atQo3nnnHQDKyspYsWIFV111FWVlZRiNRvLy8pg9ezYpKSkcOnSIyspK4uLi0Ov11NTU8P7778v2O3r0aPLz89m/f79r3/bt2wFHzsHExEQmTpzInDlz2Lp1a9BjfvfddxFFEaPRyJIlS8jLy6OmpoaSkhJyc3N55plnGDp0KHv27KGyspI2bdoQGxuL2WyW2EZHjx7N6tWrOXz4MAAWi8UVCXjy5EmJGLV3717MZrPfNbj++utZunQpp06dAhyRazt37mx2TkuXLsVisVBXV8eyZct8RlO2a9cOURQ5dOgQAB988EHA65aWlubKlbd9+3aOHDkC4HPd/PHjjz+61mzx4sWMGDECtVrNjTfeyKJFi1xWcYvF0mxf4IjITE1NZerUqTz11FOSZ+KRRx5h4sSJ9OzZk8suu0z2fGek5owZMxg1ahRt27YFHPbkdu3aERoaSnFxsStvZDD4ekb8PVcKvx6UyEEFBQWFViYgYdDVOLAIQmef1evWOQStBhMIAid2bYes/mSNGOE7grBRGEx8fQ5P/vi0y0rsFAZd0XdA3abvA7YTh/TpQ8q/3/eyEstRTBJ1hHIOqTXjrD0Zi06HHY0rgrC+ylEUxCdu0W7quLigrcTgXxgE75xwZkHjPw9gK+AVJdlcOzdLcGJ1k0AVSC7FKrWeJZ0dVht6wOI1r9DBWC4RBnvdJn9f47Uif2lXR73oEArjbzpF3HNaVG5PjtNKfKqNNB/c0SvjSaq2Eap2WEXlcked3LvL8Vy7EZRw2gKSK4u4nlXUacMoColsxuzuwCXQ2UuAMKBJYKyMimXxbW4VdJfPI8ZQgRyeFmM5y7HepOUP33fFjFFiJfbk9E8H+GreK1w3/UlJIQ61WsWoyT345KWPOXNgD6vmH3O1ca+AHsz62XU2Or4xz2UDhyab/rr0rlgD1OU+v/oO2f2fDbyDz3Ac84wwbsd5XhMfoo5QdvyYzReDb3Md+2fPznSLCCVSraZLeGB5GxUUFP738CX8hUd0Rd8m/ZJcc/78+dx///306dMHURT5y1/+wsCBA9m9ezdTp07FYrFgs9kYMmQI11xzDSaTiS+++ILu3bsTHx9Pbm6ubPGKtLQ0li1bxr333ovJZMJsNpOVlcWyZcv45JNPWLp0KTqdDrvdHnSOtmeeeYZp06bRp08fAG6++Wb++Mc/cubMGcaPH4/RaEQQBLp168akSZMIDw9n6dKldO/endjYWEaNGsXZs2dd43zvvfeYMGECFosFtVrNokWLGDBgACtXrmTGjBk8/vjjWCwWOnfuzOeff87EiRN9rkFubi5z5szhpptuwmq1YjabGTNmDDk5OX7n1LNnT4YMGcKFCxe44YYbXLZXTzQaDQsWLGDs2LHExsYyfvz4gNftpZdeYtKkSbz11ltcfvnl9O7dGwCDwSC7bv4YPHgwM2fO5Pjx48TGxrpEyjvuuIOKigpGjBgB4LKmZ2Vl+e1v4cKFrFu3Dp1Oh1qt5rXXXnMdGz9+PPfffz8PPfSQ3z7uvvtu/vznP/PNN9+49j3yyCOMHz+e3r170759+4As7J74ekauvvpqn8+Vwq8HQRQD8aL9fFRXVxMVFYXBYECv1//Sw1FQUFAImpp16zjzwINBnxd7373EP/igl0AoEQZ9VKHtmtWfrFOl3gJhozDY8Y15vH9kKa/vel0SMXgx4eORI0bQcf4/qLOc8Zk4HBzC4OPCwmb7cwoAPiMGwSUMZhWVoG2hMGgFtnVtL1s0pEoTJWv1vKH2axL0paReftaV/6xobXvqq3TydlbnPfBTkVjumE7fgFprJzTGLInckr2W21oEUyACUcRmjuBfPZo+7C5YP48uhrNNVuL4err/oVCmV3niXtagO+0YhaeV2Bezh/xVkkuuf/8v0LdJx2a1usQqz+rNzdHcsxOI1fpwQg/yo/u4cg6GdfjIdSx3TyzRRq0Pga5JIDyW0oPPr57gOjLxk3+SWO5bcnQ+d+4W9hYjCHTNHigRCL3W1KON8/jpY5vodWtgVZd793qd8Iiu1P+4l4ppfwOaF909KYlL4oPxzb9XPrjt7wwe0CQYu78eTuuSJX18l3MZfduEy3WjoKDwC1FfX8/JkydJTU2VWBcDwbM4yaWIGFT432H48OE8+uij3Hjjjb/0UALi/fff5/PPP+fzzz//Wa63c+dObr/9dg4fPtxsoRSF3x9y77XB6GtK5KCCgoJCKxOZm0vklVcGbM0FsF8WzfmVb1Jzfh9dXnrbJRAGIgwCnNizwzuC0E0YBBh6MoQPaMPdn1eRfZHCIEDt+vXUbt5Mm5EjHVWxGwycfusFigc02WaK1rbnTJsOMNBPR40cXtsFS6EKs0XrVcQEaBVh0A5sS+vgEAY9qNJEsaTT7bLnfRE51nHyD02ilmxV5cZxJjQWbCiVEeb8HYs+5Ygaq+kqFbi8oimbEQZBPoKwSq2njclKeK30v//tKb05YmmPIcxGtNUQcBSj61r1TfPwtBL7ot6jGq8zd5RKFBmRORBrWSlFhSdAECRFLUKjpcJp5Vdt6XKgmiOxcZjtvp8drcWGRadpViQMs9QhWuIQZZz+0UbvXH9N1FEZlUR5TJREGISmCro6i1kmglDlEgRjdIl0iW2+wu6Jmn1UmUvlD4oiJ3Zu5eTeXaTlDJQVWxFFTuzaJokydEQQwqHlyK6zJ66oTw2kXDeU+q+2ByUMgnfeQZ9UNpnni0niJKnYLQJVlkj2xmZImipWYgWF3xZOi7HVZkSjjlCEQYXfLVOmTOG7775j8eLFijCocElQxEEFBQWFi6CougijxUiENoJkfTLgKKrQ8Y15AVuL7ZdFU/yo44t+OZvg6Xvo8tLbiBYLRXfdhem/B/wKg04kAuG6dRJh8Myj07GuXcu/YmOwV4gXn3C2UXiMbEzQHKbtyJknXsN67Cdw0zbqK3WIdYFdre0JE9l7y9iXrJKNdmsNYXBPciIGp9XQQyTytBL7wlPUAjc7q9s4wSOKKoBjGUUllOvDOV8ptVV7inUhVhsZfoRBJ+4C4ZG4Dj7FzyWpea6/7zz1IdHV1S4xLjLJRIfB3kLUmS3xhBxV0fPkBTRlTesYZg0sZ1+ousEVfeb8wuey5K9dS//hw7HowjlnNrkEQjnSDlQTclpF3zOVkNOec5Z6r9dcQr2VzKOnKNeHczqmjaOqtI/XUnJlESNVG1inH47oca/lcv05cViJ5aPg3CvoeluMm4SvuNAOpOn7YRftgNz7hoBKUFFtqfAtDjZGBaZmZssLg05kBMJrH57Bu9OOYCqvJDRSD/gWB91p++dpfHv+FUoa71WgOPMOmrU6KmISJOs0Zu3HxFaW0r5dO9QXHHkZXVHIjUFEoZvOQZ2IbnMxqFVEalQkDFbEQQWF3xq/N0HwxRdfZMWKFV77P/30U7p27foLjKh1Wbx4MQsXejtKFixYwIYAi+H9nJSWlpKXl+e1/6qrruLVV1/lrrvu+lnGsXjx4p/lOgq/XxRxUEFBQaGFFFUXMfazsa7tr2/6OmiBUB0Xh7m+TLKvds+PnHrgQer27sVWUxNUNM6J3TsQM7MZuWA++uHDAZrGAFBR2WrCoDNHonuORVWctKnaJBJZbuD+r+ZgDdNQGp4kyQ82Zu3HxF4oJelCJXl7D8rny3MT1XTJyVhbWJXYax0b+3YVY5DJ9SZHqEzBCptZDaJIiEUq2rnmEh3pFenneSyjqIR9jdsJRgu1e6/n7In/YjOrvISxBq2GfSntyCosbl4gFAQuj0rAet4AnZqfXxuTFXRis5V/LadC6be9BI1HqF4HYzmL17ziyjn4ak5TTrknhR/RDdzsyjnonjtKkqsTMG3cyOArrmBLbblLIARvoVTdGLWoHz6cm19/ja8XviYRw5K0oWTsL0AFtKs2kVBtYndyIkdj22NW62StvPE1ZaAH0RJH7fEZjK5YSWKdwWeuP4DymHifx9wxa32v68maA6TH5KJT+bbdmW31nKw54PN4l379uW66w9btUxh04iYQXvvwDFYtmIupugoAY6VR/hwZigtOc85SB4JAZVQsZq3OR5SkN77axF4oZXDnjlz76ExWLZjLoeVwKjEZrmxqI+i0qBssUG9HFO2YRJFPdp7mriG/LyFBQUHht8Wzzz77m670OmXKFKZMmfJLDyNgEhIS2Lt37y89DAWFS44iDiooKCi0EKPF6He7OYHQflk05voyrIl2yX5rop2qwo2oQgUqhAgqO+sI09XL57bzRICCfbvoPeQK9BB4YZQgUMfG0uHVOQhaLcbqY5z7+4vU/3cHGlFAUyaQ8JwWW6jIT7Fx1NrDHGLiWUc14YY4aSRW7IVS+p44JhHNJAKhh6hmLSoCnQ7MzdsR7UCZPpzYapNDdJMTWN0EwmirgTtPL5PNOTjGtIr2kSWkXn7Gd85BARq0avYlJ7rG65xLWWUN8dUmiZDnfkwyRqA0VINq5ynQtcVcJ18NtyQqgj3NCYSNQm6HV+dQ8ufnm10zgCiripKYaCJMDsHMl8W4TtRK5upOB6N8ZGf23bdQfWa5a9tpJZYt4iOKsgKh2aCl9O129KwoR10vuKIWRZAW2Ni5leTkrvT88juvdU8st/FMVpNoeefpZURbDZKck05ESxz2+g7UW8Oxa+RzAlZGxXpZiX3hz0prFc0crtpGn5hcBMH7roqinZ8MW7GKfp5/0ZFjcNWCuf6FwaZOObFrG+9Om4rJ0FQ52WzQcej/upKS05n+1/0BBLOkgIx71GeIrhNHcg6w89ixgAuxeOK5Ll27dee6hx9FrdHQ+77pVPyYyxFzG0mbgX0TiLYJaIEou+M5yElpG9D1FBQUFBQUFBQUmlDEQQUFBYUgcVqJCwzSaq7ObX8WY7soOgSrRC2lj8rbAqvubqoYGvOPWnrdVuXa9ltwAVw57c4+OQtdel/qvv+hVYVBAFt5OWef+DMxLz7Itn1jHZE8V0LCc1o0ZQKqMoF9ye0osXuLcZ4CQNKFSllxyZ+oFqgw6BQXQ8xWGrRq35GXHgIh4LVmkZVGYmyVkgIaslWVZSoIq0BSTdhznvHVJtmoxmJrvaN6ip+I0ZKoCHantKNfYTEqQUAdG9tkufaI8Lx83t9YNv0vHDpximcnTEP3XzchqE8MYqQG1CqeG+2IOnMKO+75/tQ6Gzaz2iUYVndVsz+mLX33XgAcYqz7/QrxsBjHte1C747S3FF+q3u7C4Q1ZZyz1pNoMNK36AIqj6fGuGGDq+r3ddOf5OTeXaT07st5o82r79NtEiXnmgWN35yT7kKxU0iUnO8nGtCdG7/9sFmx7Fj1bnpED0QneEcPWkQr59W1fs8v2L2d/7wwi5KCYwGNCXCss5sw6MRs0HF0XQk2wy6GT7lOcsyzYuh105/k1Fv/kp7vY13U2khsFuk8XBZjjY6u3bozpVEYLDA1kLvzGGijwCNwc0O4iNN+vWVgT6U6sYKCgoKCgoJCC1HEQQUFBYUg8LQSuzNr8yzX33IW41OPPMrmEwcpiY6kQ8gFAjEhim2kYokrt51s46ZiF7s7x3P21DGyxJblFzwfA3U6CDNDkrdmQO26dRjFQhjftM8eKmJH8GuDdhcAIk0mRjVaieXwJ6r5Q2IhBv/CoBN3i7EoklQtFX90NrNXBJ1sRF2jBTo+wHH7re4aYO620qgIdicnMqxrbzrNfZWzT/yZ2rVrCe3TxxXhCY7ncMCrL3Dy2ecRIzUI2nIEdQOiLQQxMh5RLxVy3IUdT0Has3pwyattOGePdkR6VtW68iqWxqm58/QyEnpncs3ke0iNi6CoWoXRoiJCq6KzP2HQSaNAmBUbS5LZ5C0Wu7WrXbfOJRCm5Tiq4LiL82fDYylqk8hfB90tOdWgicamCmy95XJT6syB5VmMq/SRJ9ANX9GDoihSHh1O29hwDBf891FScIzwqGhM1YaL/3GgMbJQFXGGiB5Nu2trfnKJgwWmBmptNpJuuh2OnHG18SrEIggkdcvk+idm8sWcVyg+tldyqRhDBV2zB7giBgFqbX7e89wItJ2CgoKCgoKCgoI3ijiooKCgEASe1uFA29kFgT0piZRUOPLllYVEBCQO2qKkX+xDox0ihJfF2LMKLo22Ux+2Tzms8SL2UJESncDjf2wSQP6xyCoRCB3t7FhrpZFJlnYiPyXFUBmihWrfQosrckoUfdpSW4rP3IKB0NguyljP5ScKSD/7CkZNCCcTI7GFWiQRdLIW7wAqCDc71hZSGh1Jwx23oAoPp93Ls9k+5W6i9+/n7BN/dkUO2qxWvl74Gj8ZilFRSmTaXNf5Zl7GRkdJn/7sr54idUl8OCX1Tc/d7mRHZF5pVATRVgPmfRvZtuA8PHofN636g+u8d/b1J2rd1oCsr2J5OYkyh5z28fhqEyo3gbDdnLns21RM5pWdsDzzErvV8/lLeLZs99+280407ot6z3yAokiPU6f497PTEYYOpfqhaTx09KykyY3ffkhcZWnAFlu56EGraOGcahMn9+wMqA+ToapVBcIzB4/R3U0c/Onwk0RH51BMewZv+0n2NM9CLNlpXRnzyJOsWXyQkpPVXu279BvAdY895RIGASotgYl+SpViBYXfLs4fICLVaiVCWEFBQeESodTAVlBQUAiCCG1E0O1cFUN373DtM1eHcGh5F8reTyTqPemXWv0nTds1f5DmI0y+8jzd/1BIr9tOoNM3ijeewqCbKOYUCKW9eGONFyl9wUL5LCvnHrZKjtXp5NtV3SVtZ7jbRvxdJfS6raBpbP5wWnD14c23DYCLFttEkShjPQNPnEMFJBnLqYm2Ygu1uPozVzusxL+0MFgdbqFC30B1eFMRlYM/bKD+wgU+nnInW4UG9iQnUt0olFnr6lzFKWIMFdy04d+S/oRQx70cs/Zjpn7zAc/vyyem+gI6vZmwuDrX/XRuh0ZL729dJxVh8fWOdoJAaVSE9FkEio8fZdnsJyXnVez60TsXJ1CiD2/2mXW23ZOcyK7UpKbnXBSpXbuWEx+sZNsXBWzafJqRb/zgUxgMhIyqfa6/v0i6jipNlGs7Rq0jo6iEyPadGfL0U1yml75HLO7ZidGx+oCFQWiKHhRFxyqIop1DVVs4sScAIdUNk6GKxC7dLkp89nXPAcou7OH/dgYmVpq1OkRR5Lu393P0x/cRrQXejTyGWWBq4JZ9J7zbefBGj07U2mwUmAKL4FRQUPj1UGBqYPC2n8jbeZTB23761bzON2zYQGZm5i89DIVfOZ9//jlbt251be/cuZNbbrnlFxyRwm8ZJXJQQUFBIQiS9cl8fdPXrpyD7lbil3NfpktUF0nOQZcwKFMYwFwdwllRB6EQT4lrv8o7oEYWtc7mWxh04iYQ+hOu7KEiZRaBehFKLNJWZ+MEQCTMDLGhgQkTfu3PToK04PqjNYRBd3EvqP4a70EwEZBl+nBKoiODHycOYXDF8HOu7XEb2qM3aSnYvYPF90ygQSUAjfe9cwIZ69bx/T0TOWeppzrMjEVjx44035va4oh0CzUVEX22CntlKV0GdEOf+YWrzfGvOpF23WnZMSVfed71t1xezOpwCxaNnSqP61ZckY646SAmbSi9T9cBTbkinfZkn88sUvu46zk/VYp+5Ejy6ztSoq7BsKfY51oGyr7oDMl2fK8MLPs3AVBpt7Dxilz+ob+W6TvOcvUAaUnoXvpIkh+bxZevv0zBrm0BX9MZPaglBIvdzPHqPS0ae5i+DV369adg9w7pe5AgEK6Pls016MTLPm6Mp94W4qo2ffzoEySTBMLCZsehs5g5uXsHCAdBlH/NF+zazvJn/8wfn52NLjSUanNgFcQfPdz0XCq5BxUUflt4pgy4VCkErFYrGs2v66vxr3HMrcVvZe7NzePzzz8nMzOTQYMGAZCTk8NHH330cw1P4XeGEjmooKCgECTJ+mR6xfYiNaKzZH+XqC70iu0VkDDoQhAoC5FGGqlqAhO3bGa1f2HQ7Rq+Igit8SLmTnbOpMLfisN4rSSMpRekX6wXXK/myckaHrlPQ4ku0LE1899LkJF2/vhFhcEWEl9tIrGqtkV2T4vGLr8tig5h0CNydGOPzpxrMFEdZmbF8HN8NbSYzZnSKDZ9xSJiip9hU8Y+qsMt1FVXUXzygKSNJlwaKeoLT2HYKWbKXffVroeZdbeav06wkJ8ex24Zsc/eOBd1XJzrPF/28ZKoCHb07s6P/f/ECyXlfNCmgbfLA4/YC5QSWxilujhXBGF91TmuKlvDW+uPkqBWs2VgT77LucwlVKk1Gq5/bBap/QYEfA1n9KAgCM1XKPZD4Z5diKKdLv36S9aqa/ZA/jT/HbrmDPL5nLvfyxJjPE/98Awvbv0zT/3wDCVGR2KEdpznNfEhFrZXMaudNFnCA+IbTP7mH9KqxT6EQdd1Thzl3WlTqDOa2PNJ81GDnii5BxUUfhsUmBrYX2PimLFesv+YsZ79NaZWiSAUBIHnnnuO/v37M2vWLEpLSxk3bhx9+vQhPT2dt956CwC73c5DDz1Ez549ycjIIDs7m/r6eqxWK6NHjyYnJ4fevXtz++23YzTKp59ZvXo1Q4cOJTs7mwEDBrB+/XrHfI4dY8iQIWRkZNCnTx+efvppv2NOSUlh5syZDBgwgEmTJlFbW8vkyZNJT08nPT2dF154wdX2pZdeomfPnmRmZpKZmUlRkSO1zR133EFOTg59+/ZlzJgxFBc3/Yi2cuVK+vfvT0ZGBpmZmWzb5vhRa8eOHYwcOZKcnByysrL4+OOPAZpdgyVLljBw4ED69evHsGHD2LevKRJfjuHDh/Pwww/Tv39/0tLSePzxxxEbPysNHz6cadOmcfnll5OXl0dhYSHR0dGuc2traxHc/j8TBIHZs2czYMAAUlNTee+99yTruHfvXtd2Tk4OGzZs8LtucmzdupXs7GwyMzNJT0/nzTffBKCmpoapU6cyYMAA+vbtyz333IO5saCe5zxsNhtPPPGE6x4+/PDDmM1mVq1axZdffsmrr75KZmYmixcvlkSkOuf/3HPPkZ2dTVpaGqtWrXKNzd99VlCQ49cvtysoKCj8AogWCzV/fwPcAooitBGIFgu1mzcTdvnlfL3wNf/CYCNOi3F8g5GeJy+gKxNIeE6LPVTE2k6UVC+Ofk+NpliAeoH0hgrOxLTxLww6kYkgdFqEAcrMAm7Biz6x1Aok+Rhbu219sK77CeoFYsItlETp5MfVisIgXFwUntxYgu5PECj1qFDcHM5qzAGJkI3PT3WE1RF9FymNpnJua60q9CaPYhmC4CrI4ikq+iTKTFi4lRAPa7g2LDDRxbNQS6DXLYkOxarSeYl9e1LakdulF53mvsqxRx7DvHkT+5ITfBZxqVBb2Pn9SojLCui6LeFDUxfo0AVoql7cpa4IoWgl//6+Kw9e2V32vGCl5qPVu7CKFgpq/H+ZchLeYEZj836/qfj+Bzr06En3rj04cvwnumYP5LrpT6LWaLhu+pOOHzF2bvU6z/1e1tukPxq4b7fjPC98soVCusDgBNf+9pzBbBSpM3hU9W4Gk6GKt+6djDriLh44HIpZK3C8nZYNfZtSEAyuhNsGdaTcaueFE02RtE4hQclNpqDw68VpJZbjwZ9Ouf5ujUhhtVrNjh2OtC+33HIL3bt3Z8WKFZSWlpKdnU1GRgYhISGsXbuWgwcPolKpMBgM6HQ6BEFg2bJlxMbGIooiDzzwAAsWLODJJ6UpNAoKCnj++edZvXo1er2e48ePk5ubS2FhIQsXLmTs2LHMmuVwoly40EzFKaCiooJt2xw/Hs2cOZOGhgb2799PXV0dQ4cOpUePHuTl5TF37lzOnz9PWFgYJpMJlcrxSeeNN94gPt7xY84rr7zC888/z6JFizh69Ch33303mzZtokePHlgsFkwmE1VVVdxzzz2sWrWKpKQkysvL6devH4MHD6Z9+/Y+1+CHH35g+fLlbNq0iZCQEDZv3sztt9/OwYMH/c7v0KFDbNmyBYvFwrBhw1i+fDm33347AEePHmXTpk1otVoKCwubXauQkBC2b9/O4cOH6d+/P3feeaffSL3Kykqf6ybHyy+/zIwZM7jttttc5wM8/vjj5Obm8s477yCKIlOnTuUf//gHTzzxhNc83nzzTXbs2MGuXbtQq9Vcf/31zJs3j5kzZ3L99deTmZnJo48+CuASMJ0YDAb69u3LCy+8wLfffssjjzzCtddeC/i+zwoKvlDEQQUFBYUgERsrrEat28o/fhSpCxGI7TeITjfHO6qirl2LYejlnKhpvjKpE3N1CGcJoV1DA4mY0JQ5rKF4xPppigV0px0fUgS9oxBFwDhz/DWKWHY3i3BogKpFmBk0lfJj63DXk5xfdg9YLGRRwv7MtlS2DcVmcSve0crCIDRF4QUc6edWlVhuLC3pryX26IAEQjdh0N1K7I57NJ7TYiyhsV+tNbAV73nNaeK13gJTh8FNz/OZLQl0dNsuWtue+iqdbKGWQK+rtal82+JTEumo09Ew6wXWl07FGmKTXa8qTRRmlZZyVcui7FqCs3qxAKTWFXHkwwUYBs0lKqKpmIjNamXLJ8so2L3db186vVlS8MYmWjhWvSugcYQ3mBl+WN72DcAxRxXh7nNfocvVY1xFP9QaDdc+PIN3p031shibq3Vs/7oPicMqOW9sJznm3HZajPVqA+215yikSRwMox5VtOM+yRbx8YPNUout+mOIvAPwLjayJQa2uFVGdtLawoGCgsLPz89ZpXzy5Mmuv/Pz89m1y/Gem5CQwLhx48jPz+fhhx/GarUyefJkRowYwZgxY1CpVNjtdubNm8fKlSuxWq0YDAYGDx7sdY1vv/2W48ePM2zYMNc+lUrFqVOnGDZsGE888QS1tbVcccUVjBo1qtkx33XXXa4Iufz8fF577TVUKhURERFMnDiRNWvWMH78eLp168aECRPIy8tjzJgxdOzoKDy2bNkylixZQn19PfX19cQ1RuavWbOGq6++mh49HNWntFotUVFRrFq1ioKCAq655hrJOI4cOUJSUpLPNfjiiy/Yt28fAwcOdJ1z4cIF6urqCAvz/aPRxIkT0Wq1aLVaJkyYQH5+vkscnDBhAlqt1ue5ntxxxx0A9OjRA41GQ3FxsWsd5NDr9T7XTY4RI0bw17/+lWPHjjFy5EiGDh0KOOzAP/74I6+//joAdXV1qN0KZ7nPIz8/n7vuuouQEMf/V1OnTuWf//wnM2fObHZ+oaGhjBs3DoDLL7+cEyeaIu593WcFBV8o4qCCgoJCEDiFwdp160AUG6v4ivDNVo5ty8Ne4RBq2vywlfbZvTlnqQuwY3mBSVUv+Nz2J2J5igxy15D0pRX5S7s6V85Bd2vxA+utdD7pEAYTKx3FIuKrTV5j2zttBmKYlgSLBXu8SMI9xS6Z4NDyrpgN2osSBiVVad3XhOCi8EIsNhp0Gp9jaUl/GS2ck99rOSNOg4j689dOb9IybkN7V/Shu6iYuzeW6FotkW3MxHfyFlw8sdZJxZr6KkehlpZeVzbq0Y0Tu3fw5euzqam3Ygm1I8jE4FVpoljS6fZmx97a6OxNkZwC0NlYyLsvPM8js1/iVFUD1aYGti97l+o9GwmPisFUXSUbTeyZ308ud6M/5CIG5WjfOVVSDdhmtbJqwVzHuDyo0kSxRHc7eAcV8s5/J7r+vtf8DtPHvg1AsZhEHaGEUU87zsOVTecEO6fKNlYWj20bcHtPyo2n6RKe1uLzFRQUfhkCrT7eGlXKIyN9/8jqFOCioqI4cOAAGzduZP369cyaNYtNmzaxdetW1q1bx8aNG9Hr9cyfP59169Z59SOKIldddRXLli3zOtatWzcGDx7MmjVrWLhwIW+88YbEGtrSMavVarZu3cqWLVvYsGEDgwYNYvny5QiCwPz58/nxxx9JSEjgyy+/5Nlnn/V7PVEU6d27N1u2bPE6tnTpUp9rIIoikyZNYvbs2X77bw53q7D73DUaDTY3gbi+XmpBB4d45kStVmO1Wv2e62vdcnNzZcf26KOPcsMNN5Cfn89TTz1Feno6//rXvxBFkU8//ZTLLrtM9rxA7mEghISESO65c07ff/990PdZQUHJOaigoKAQIJ7CoPSg6BIGAVSiSN+dBwLLK+cnmk7TaDGOe1lDwnPaxojCxmvgEJYSDUbJNZwig6Sqscw13PuOfk9NvFakk04kUSsVmDqfhC4lDmHQvTKsqvH87qbHKH2/M7tU0exOTWJ3ciI2j8Ilap3tooVBr6q0bvhaCwmNa3DFT0VknzzvdywB9Qcu2+6+ACpC+0L2Wm7CIAQRfRdgO41V+sEzulZLbHUIbWoCi7KymqS/LXpaiT3Rmxz9R9dKBUDndf0JgwCIIgW7tlN2cLdPa64zgq8lXFWWT15pvuyxK8o2eh3LK83nlrMfuyzF7giAvegAb/39VUbM3cAN//qRv1X1okoT5YjME9TIPVGeuRoDKurTAnYdPOTI41Vj5Oi2LXz5+myf6Q8CXdM6S5Mw3I7zpHLSIQx6EOyczNrAhUQ5jv33LkymkxfVh4KCws9Pl/AQV+7Wf/aU5nf+Z8/OkpyurcmoUaN45513ACgrK2PFihVcddVVlJWVYTQaycvLY/bs2aSkpHDo0CEqKyuJi4tDr9dTU1PD+++/L9vv6NGjyc/PZ//+/a5927c7IsmPHTtGYmIiEydOZM6cOZLKtIGO+d1330UURYxGI0uWLCEvL4+amhpKSkrIzc3lmWeeYejQoezZs4fKykratGlDbGwsZrPZlVfROc7Vq1dz+PBhACwWiysS8OTJk+TnN/1fuHfvXsxms981uP7661m6dCmnTjkiuu12OzsDqHC/dOlSLBYLdXV1LFu2zGc0Zbt27RBFkUOHDgHwwQcfBLxuaWlprnyK27dv58iRIwA+180XR44cITU1lalTp/LUU0+57t+NN97I3//+d5cYWVlZyfHjx2X7GDVqFB988AFmsxmr1crixYvJy8sDHJGMBoNB9jx/+LvPCgq+UCIHFRQUFALArzDog0Bto82JZk0WY/lrZBSVsLFnsiu3nJfIoLWRaDD7FB89LcKeFuMws+/KsBlFJWxY9Dkl4eEgOITJmlg1x0P0xNCUN6eHpZS2djP2eAFVWeC/iIKfqrQe82kuCs99nQPJDejsb81l3Tmvj0InWr2EICDgitCBXGt3cmKTVdxt/K0RfedZ5dgdp6hortZxaHlX1DobodFmkq9sau9pHXa2C8Yu6ileBipmuiMi/2pwj+ALlnb1pbJC2LXF39C1rpBSndSKE2OpJMFc7rM/ASg6fAQ69HXtc/Yv2q2S8TujfEOjpVZo53awdtzm+Is5hGM7jwIwZflbTYVCZAh0TTXmluWjbA6dJXh7+NxUFfUFj7kiF602+eIACgoK/9v4Ev66RYTSt0247LGLZf78+dx///306dMHURT5y1/+wsCBA9m9ezdTp07FYrFgs9kYMmQI11xzDSaTiS+++ILu3bsTHx9Pbm6ubPGKtLQ0li1bxr333ovJZMJsNpOVlcWyZcv45JNPWLp0KTqdDrvdHnROuGeeeYZp06bRp08fAG6++Wb++Mc/cubMGcaPH4/RaEQQBLp168akSZMIDw9n6dKldO/endjYWEaNGsXZs2dd43zvvfeYMGECFosFtVrNokWLGDBgACtXrmTGjBk8/vjjWCwWOnfuzOeff87EiRN9rkFubi5z5szhpptuwmq1YjabGTNmDDk5OX7n1LNnT4YMGcKFCxe44YYbuPXWW2XbaTQaFixYwNixY4mNjWX8+PEBr9tLL73EpEmTeOutt7j88svp3bs34MjhJ7duvli4cCHr1q1Dp9OhVqt57bXXAJg3bx5PPvkkmZmZqFQqNBoNc+bMIS3NO5r9nnvu4cSJE/Tr1w9wFCxx5hi88847ueuuu/j888958MEHZc+X4+qrr/Z5nxUUfCGIYoDfcn8mqquriYqKwmAwoNfrf+nhKCgoKLRIGHTHZ/XbVsi/5963LsoiK+pUftWWtAPVqOsFSeShO+7FSQAOL40n+YSBcHNTxKDc+HUWG+ZGUdLTFukLzwjIQOcX6Np5nSOKJBiMdKysIcHDktwcZyPimHJVU2JxuUixQMbka26eNulifTi7U5P8nlehb+CroU0V5677vh2xBh/FX9zGVhFllpw3YmcckfUan6JiWFwd3f9Q6No+8mmKT+twMFSHW7Bo7M2KmXLE9cpk28lKR/EPmeOHIrqzNmFkUH1eWbqO9g3FVGhjWNVOmk8przSfGEsl9apQvki6zrXf33NQpYmiQaWlJCSRjXFN+aWcfensFte5gb5mArHj6k0NDD3WvCX8nlmzOdY5FYCJn/yTxHLvCD93nHkcK7UxfJfQFL1xbc23tKmucc3HXeT0JyoHirO/spBEjA0RVMQksPLKm13Hb9xaS0ZiGzpf24k/ueUZXJ5yHvvJh1zbvXu9TnhEVzTqCMLDUwO+voKCQutRX1/PyZMnSU1Nldg8A8GzOImSS/S3jVMYu/HGG3/poSgo/OqQe68NRl9TIgcVFBQUmqF282Zq165t8fmyEW0eQpLQti1iABXq3PEUBn2JDDHXXaCiUdfwJcypygRK327XVECkVktVaCjJJX4iHwXBJQxC4JZBRyEUAWu8iD1UROVDtPQpDDZeO6AIwuhIEgyOyKHdqUkkVtUGJcYaNdIvIH5tlkFEELrmFh1JYlUtCeU2GjQhhFgbmi2G4hV9ZxG8bMjuVIeZsahFryrHVo1/odszyivYqC9fBCsIuiMIKr5LuIq8sny6mAolAmGVJio4YVC00b9yF0kNxT5zFbqLYTec/4pQe71E3PPEX95D976c4mKgr5lLZTGuiHFkBdVZzD4jCH3NtU11jSR60in8aSOsknb+8lH6wl007U4hh5Z3BWmtFDIS23DPpD4UNUif63Mn/4Z76ZSDhx5z/X35oHxFIFRQ+JXhtBjX2mxKFXIFBQWFS4giDiooKCg0Q2RuLpFXXtniyEHwFqw8I8wuRhiUsxL7PC/U25Tp6sseARWNxwSHfffLnA4YQwW0Nqu8qOMmRgUqHqnqBa9IRU/R0q8w6Hbt5gTC0soazsS0obQZS7InZyPiqNOEcDChk2R/pTYGwLdA5FERWg5Pm/SR2PY8nXWH6/jba14BjD7n7m4x1lpVxBoEcn86yQ9u1nInDiuxfGSYvyrHImCqDuX5DU+Qa/yBpOqSVrW2tpSyQ3vIC7vAd/GjyCtdI4kgDDrnoKBmV0w2OjEw62yovd6vlRigIcAxOMca6GumtYRZT9wj8aYsnxeUxVjOcqzTm+lytTR60Tl22SJJPpDLv+hpMR45rgtqtYou4SF81a2CfUdfbiqC4gPFYqyg8Ovk9yYIvvjii6xYscJr/6effkrXrl1/gRG1LosXL2bhwoVe+xcsWMCGDRt+/gE1Q2lpqSsHoDtXXXUVr7766i8wIgWFS4MiDiooKCg0g6DV0vGNeRdlLYYmwaqsssar4q4v1LFtsVVIhUM54SwYYa65vpxUR1hZMbzEte0pIHniL1/dmdWJ9NldgbYxStDcSVq+w1209ByTX1HBj0BoB04kxGAID2maWwDRfZ5WYnfkor8k+Kg67T4mz/U2q6VzatCEkFV01q846roPokiUyciB5EQvYRD8Vy/2186Ginc734XZHML/aW7mGut3dKHQUW3XUOmjlyARRa/xOi2sPsVXUaSLqZC80jWOiFugKLQjdepQjGppDqr7r+jKmxt9W3ZVIqRatWyNGRTQcJ1iWHhUNCZDlWybMG1gManOvoLJ8Xipaa74R7TVwJ2nl/m9P2qdjWKaqhWbVqswV+sCrsTsL/9i+6oz3P/VHIwNEegsZn7a2Y206U+i1mhIDrFRTfOFRzTqiGbbKCgoKPzSPPvss7/pyrJTpkxhypQpv/QwAiYhIYG9e/f+0sNQULjkKOKggoKCQgBIBMKLtBgHUgwDQUAVGeklDIIjT12Js2hFI4GIDD0LKtCUNbj2Nxed5ykYBSI0+RIxjLVh7A7pRP/6M5g72bG2kwqsjm07qnqBioYI1/wCEhVkovWs4CjSopP5b64ZgbBOE1iEglekWjM5Bz3X2z2XmztFbRIIy8mhs91CVclBGjTeop/7XMobIxDl2rSkyrEIvN9xAma1Yx3sgppvEvLoaT3L+zNvZsmjUxBtVh89BRghJoqYdDHUChqX0ORpyZ1S+/+Iaqjx6kMAutY5kp2fCu3Il265AN1pThi83qijm1XNMY2GvCk9OfHNR/z3+Fm+i7/S1U6SJ9BWTdecQVz78AxWzp9Dwa7tXv3qjWWMO/spGuxUeeTok8s5CL5fM8Haca3qwPJ4mnzk+wqk+Icvi7HzntcmRfGi0PSF9rE2LxIZZ/CyGstFOvvLv+h8P3NajM3VOk7srODwji9BZSamo29hU8k5qKCgoKCgoKDQPIo4qKCgoBAgToHw9LRHMK5ff2kvJorYa2pkD8VXm2Tz0vkUGSp16E/YSChqEgatwLau7TFEhHpHDDYWjPDMUefcDqSQhFy+urokkfLH5C2cVXc3iQVxzxld85OzF3rRWHAk3lMY1PqJpvQjEIZZG3ye5o7EVtkCYdBXbrq5OU0W4zuri30XQHGbixzO+5hzKJqdvaq8jucciibpQqjX/RSAsaXf8mn7G7ELjjW0C2oOazvwwYvPQjPCYLNiriiiC09kQbs/NM3z9DKvCMr2o8pJ1p9x5JsDWcHRpA4usT00CYNpjYJomlVF9boSpky7nwV/+zvfuWng6Wnt6aSOoWD3dlL6DaCszx+4sKmYYd1uwVpWx6lT//XoXaS9uRSjylvUa67C8cXmeDSF6NjQoxMam3dkc3VkFFaNltK2CZxNaCp4M2btx8RWlvrNOdgc7vf8JFLxre3galIp9DpHrhJzUPkXBYG0y7tTXPcEAMVHfLdXqcPQt0kPqG8FBQUFBQUFhd8rijiooKCgEASCVkun+f/g9EMPY9y48RcbR4fKGkRw5NLzEIc8RYWYC/X0LbrgEq3swLa0Dg5h0ANHjrpzXvvBf446T9wjGZ0CQFhcXUBzI1Skj6kYTWJbTNFSqU1OVHBHIgz6q94LPgXCDsZyFq95BaMmhM2p3fgkZazrlGvPraaN3YBOtDaJdkEKgxB4fryg8+g14u8+OtnZq8rnfUw0l3J16Xd8m5CHXVCjEm2MLlmNWHdKtkqwEzkxVxupx2KscdmIE9onEzdxJnzUJKwVh8ST2KUb1Dade97oKCthahtGzugDrv2Hlnel1BSPWaXFFKRN1F0YFBpnIiBQfuQCHzzxHDWGc9BpgKv91ZP+BGcO03vYSL7crmLhhgLKCeEOQYu1TP55FoAIex31dmkEqlyOPnfkXjPBYgrxcY69Ho25HrVVGnEcW1nabLXi5nC3Ep+jo+SYc9szF6B7ZLNTQA44/6JFTZd+/UHVMjFTQUFBQUFBQUHBG0UcVFBQUGgJqkDr3bYu7lVuE6pqSTAYvQRCl8igtTmEwb1SYXBPcqIjDx945X0LOkedTN4493G4E+iXf3s4XJhlIZ4Sr2NyogKCQGlUBLuTE2nQqOWtxL7wUUAkyVjOnuRE1BqpBbyN3UAnY0mT+NiMMAjyNvDmhKJg23nS0lyDTgSgq6mQLvWnORXembyS70hxK/7hNU4/ueLWCql0qD5HYkkZ+yN7skk3FPEjacTdmoSrJMIgwDv/negazGzjX0mMKAPAENKGJbHyUZfuPDGyG1f0TuTfPxbyyc4zCDLCIIAo2rAYv6bBcoJo4M4zy2nTuSvX3fcgh5b9ixM7t9I+KZ33QwaDoGaZaKJTyTpK6o77vLYAxFmrms3R58mlzi3oaR0OxErcHGUhibwo/Fn22L+ER11/vyY+JFssxCkoB5R/0aKmY9pQEOHUf3+iV+/mxxcZ0S24CSkoKCgoKCgo/A5RxEEFBYVfBNFioXbzZiJzcxG0LYuO+jlxjjdi0CDOPvHnS28rlsGzym1pVAQJBqO8QGjQkmgwe0UMeuUYbBS4nNtB5agTRXQWG+ZAovRwfvnvQnyDkTSxHIOblTj6PTWaYgFVvYAtNLCCL5IoNUGgNDoy+GIxjZZkR8ZDR05I93XSiVILrU600qBVE2Kx0aDTNCsMAsRWmwgxWyXRjO7FHSq9ctOtIcZSFbCg5D4XAAShRbkGPbGHtmHQkP5cufUTtKZCv8Jgr9tOUGKMp94WQokx3iXkJV95jsn8HwCvfXcvhwhAzZGh3tYUhSfoBcdNaoZIRFLiIvj2QHGzwqDd0mSFjrZUQcFuNrz0uKv4ytnzB7givJbV8aMYVpZPsZ/1cCfKagionZPwqCgSu3bj5J5dss+yc08wfboTY6hgyvJ5mLW6i7ISu2NsCCx6sw55C7j7jwZ+8y9WhDsiBkUo2LMDRN9iYvduc9BHd1fyDCoo/EY4WW7E2GAlIkRDatyvo7DQhg0bePTRR5VCFpcYQRCorKwkOjr6kl1j0aJF1NTU8MQTT3gd+/rrr5k7d+7/ZJVlBYVgUcRBBQWFnx3RYnEV9oi88ko6vjHPr0BYYGqg1mYjUq2mS3hgxSJaE/fxquPisFX8/HY2iWAVZXFZD0uREQhlotn8Fh9xEwj1Ji3jNrR35Rx0txKP3RKJYItEa1OhNzqEsYyiEvYkJ1Lmo6iJBFEk5pSFPkWVWDtJ22qKBXSnVdiBA5mxJFDc7JpIIhHdhLGAEUXiDUYAdqcmkVhVS0ZRCfvc1km2Qqsg0KBVE1VbR0YzwiBAhT5cNprRl/AXY6nym5vO11wSGudSGhUhvY8RFjZnNd3H3L2xRNdqm80dqaqvoUP+AkzVVX4vrdbZKDHG89QPz7j2zR7SFOnn5EJ4LARQi0eOUHVTHsjUy8/AD82fo6n/iU926jDWWbnBpKNrAMKg20FJVWYBSDUVcuP5L0kylwY87mBEPEGt5q7X30IXGspX817hxK5tEoFQBIyqMEq1caQ2nL4ogVCO1KwcTNUGSk4cC6q/QKMPw6h3/d1cJWav/ItOK7FLGHSsiy8xMf/Nb7j9uevQ+bJZKygo/Go4WW5kxNwNru31M4ZfEoHQarWi0fy6vhr/GsccDP8r87vvvvt+6SEoKPws/DK+OAUFhd8tLqFt3ToAatet48yj0xEt8vbJAlMDg7f9RN7Oowze9hMFpsCKRbQW7sIggK28PPjotIvEUxjsddsJuv+hkF63nUAXZXGIguASh3wJg8eSdFREmakOl1lrp0AI6E1aYqtDiK6RCkdDDlfR67QFvUnruoYGyC4qcYlsPvEQLFX1UmlDVS+4xnnOHs2h5V058mkKRWvbS9oVrW3PkU9TvAtdCEJwwmAjhvBQ1/qVREWwsWeyl4AqRmgQ9VrECLcPqIKAISKUfcmJPoPYrMCRdjHENBaQ8fXceFqHdbbgrZ6JBiP9ikroV1RCosEIoui4jwYdsVXS/+qjax33t7miMoBDIGvmebeZ1ZLIPsBrG8BsDy5CeGqfD3h20BwvoTExoozZQ/7Ks4PmMKZuleScP3b7jKl9/s1j/f7JNYM7k5PSlru7JpJmUYNox2Y+gSja/AuDPhCAduZSalVhXIp3ANFmY/WbbwBw3fQnUSWnS65jVIWxpNMdfJN0DSfDklv12uFRMYx99Elue/FVuuYMCuq15IxGnPjJP7lhy3LJsRu2LGfiJ//kwW9flliKnZWYfYl75modtftvovbQWA4t7+qyErsLg+54iok1Zad4b/pfMDdcvG1aQUHhl8XYYPW7fTEIgsBzzz1H//79mTVrFqWlpYwbN44+ffqQnp7OW2+9BYDdbuehhx6iZ8+eZGRkkJ2dTX19PVarldGjR5OTk0Pv3r25/fbbMRrlPw+tXr2aoUOHkp2dzYABA1jf6EA5duwYQ4YMISMjgz59+vD000/7HXNKSgozZ85kwIABTJo0idraWiZPnkx6ejrp6em88MILrrYvvfQSPXv2JDMzk8zMTIqKigC44447yMnJoW/fvowZM4bi4qYfZFeuXEn//v3JyMggMzOTbdu2AbBjxw5GjhxJTk4OWVlZfPzxxwDNrsGSJUsYOHAg/fr1Y9iwYezbt8/v/IYPH860adO4/PLLycvLo7CwUBIVWFtbi+Dxf9TcuXPJysrisssu48MPP3TtFwSBqqoq13ZcXByFhYU+76cvnn/+eR599FEALBYLDzzwAN26dZPcR4Di4mJGjBhBdnY2vXv35qGHHsJub/qUOHfuXAYMGEC/fv24+uqrXffDvX+AhQsXctdddwGwdetWsrOzyczMJD09nTfffNPv+ikoXAy/vBSvoKDwu0EiDDq/4ImiSyCUiyCstdn8brv3HaxNublzRIvl56lM7AfPiD/Z6r2CzmUx7nfyPAnVJllhcMWIpi/nsoUo3C3GokhilfSDUrgZUktKKKusId7tGiocAmFxZQ0FCTFUh4dIxQWZSEZNmUDCc1rsoSKqegFVmSCZp197Ybl3JdgWIQhSS7QgeEX4VUbFsvi26a7tKcvnNUVe+chXCG6FUXQazsToyf2pCHxEbkqiE21mEusuNFtQxZnjz2ZWE3PKLFnbrMZozpLoSDQWGyqP/+oDtRwHQpUmCnO9lpo1baBN035nMZGK7VHsVmVwQteFqrporqn/lnh7OeX2OFa1udrVPq80H3WYhW/aXOPalxRRTLL+jOx1nWJhQUNHcHscesQec52z5YsFDB33KI/e1pZNFjWFBxei0RRit6dgro5AtBYEPV9nsRGjKowIe12Lo/d8cWLXNr6a9wojHpjBe6G5DA2voaupkGJdAp8lXY+1sUDN6oSrmHTmQ8JtARb5aQaToZKV8+dw/WNPcd30J2UjF/3hKxox6twFEsvPozNLRTpf+Ud1YeGY60x0zRnE2IeeBODk3l3YbTa+en22z+vLFXMx8xOfzfmM8U/djFqt/BauoPBrw2klPl4qTUjr3G4ti7FarWbHjh0A3HLLLXTv3p0VK1ZQWlpKdnY2GRkZhISEsHbtWg4ePIhKpcJgMKDT6RAEgWXLlhEbG4soijzwwAMsWLCAJ598UnKNgoICnn/+eVavXo1er+f48ePk5uZSWFjIwoULGTt2LLNmzQLgwoULzY65oqKCbdu2IQgCM2fOpKGhgf3791NXV8fQoUPp0aMHeXl5zJ07l/PnzxMWFobJZELVmC/7jTfeID4+HoBXXnmF559/nkWLFnH06FHuvvtuNm3aRI8ePbBYLJhMJqqqqrjnnntYtWoVSUlJlJeX069fPwYPHkz79u19rsEPP/zA8uXL2bRpEyEhIWzevJnbb7+dgwcP+p3f0aNH2bRpE1qtlsLCwmbXQxAE9uzZQ0FBATk5OQwZMoSUlBSf7fft2yd7PwPh7bff5siRI645jB492nUsOjqar776isjISGw2GzfccAP/+c9/uPXWW1m2bBlHjhzhxx9/RK1Ws2TJEh544AFWrlzp93ovv/wyM2bM4LbbbgOgsrLSb3sFhYtBEQcVFBR+FmSFQddBb4HQaSU+ZpQKVM5td4uxP5uyLwGwOWvzzyUMqtq2xe7jg6CclViu4APgshgLQIKbUOUshmHRSiMufRascBPK2taombfISoMOwsyQ1Ph5xFMIA4dA2L7aRLtqk9S+7MPiXKYPJ77MhAZB1vLsFL88xdBAi5p44i6meUUceuKWg9GslX5YlGw3WnnjfQmDWsdYG7RqNvdM9ikQVodbsGlKCbUIdCs1e1mb5ebS67amiLfO3+ZiPVXqel2pgIyiErZpNRjCQ9DXaVwW4+asxMFQpYliSSf5wiCuYiKA2mpBtKgYX/cZo2/cBEBRdUdWbW0SB2MslegaLBKBsdYcQVF1R6oPhtPn8qOu/U5Lqlpno02U9Euju/04LHUTu/Y4rmdT5dFj/IbGI4XekadB4BQIbahQY/cjEDozWAaBKHJi51ZKV3xHdYOaNYmjOVp3ilPhnVEBaaZCToV3plP92VYTBp0U7NrOl6/PlgqEO7cSHhXTZLEWBML10RLLtTu+Cp4EUok5sUs3/vCXv3L28EFSM7NRN1rJ0nIGYrNa6ZozyK9g6dmnStuVsrNtWf32AUbfk64IhAoKvyI8rcTuPPrRXtffrWExnjx5suvv/Px8du3aBUBCQgLjxo0jPz+fhx9+GKvVyuTJkxkxYgRjxoxBpVJht9uZN28eK1euxGq1YjAYGDx4sNc1vv32W44fP86wYcNc+1QqFadOnWLYsGE88cQT1NbWcsUVVzBq1Civ8z256667XNFz+fn5vPbaa6hUKiIiIpg4cSJr1qxh/PjxdOvWjQkTJpCXl8eYMWPo2NFRQX7ZsmUsWbKE+vp66uvriYuLA2DNmjVcffXV9OjRAwCtVktUVBSrVq2ioKCAa665RjKOI0eOkJSU5HMNvvjiC/bt28fAgQNd51y4cIG6ujrCwnz/0DthwgS0QeQjnzJlCgBdunRh2LBhbNq0ya842KVLF9n7GQhr165l4sSJLjFx8uTJvPvuu4AjwnTmzJl8//33iKJIaWkp6enp3HrrrXz++efs2LGD7OxsAGw+gh08GTFiBH/96185duwYI0eOZOjQoQGdp6DQEhRxUEFB4ZLjVxh0NWoSCM0vv8KQXfKVQB/86ZTr7y0De5KCjaK77qb+v47qp+4iIyArAHoKf85zkua+SuHB/aT07su5xx7/WSIGfQmD0CTseYpB7nhW7y0RpJFsVrUJUaiiKkL6dl8V6bCyeolFbrn7SqMiEEhstuCGOyqkkWs+cx9GR8rm+ANv8ev4V52wmdU+RYXm8OyvWWFIEKjUt8WsC6EiJkFyyLmts5iJqfLOCygRBt0jEn0IhNXhFlYMb7qH8xZZ0QAZRaWs656GJdRTfBKIaCv9IpQ461EMxsWu15cV2JbWwVGRunEMrSUIumNWBdZnYkMpIXYzKfam1667iAe48jneeXoZYhtIGFnJ67sfdB13r1bszFXX/Q+FwGlmG/9KvS2EUHWDV55DJ2Vn/ktE96ZtT9FZjipNlM9KwwKgaVb4C1IYbKRrziC6XDGECW2cz0UKg6xm2qxdjObCaSxtO1E74m5MP5wkrPhwq0YvegqEJ/fuonN6BqsWzOXEzq10zR7ItQ/PcGzLCHUxhgr+tHwe1uTeTH7gPn7a2Y0Tuy6AKPp9zXXJHsD1jz2FWqMhLWeg13G1RsN105/koxde4PzRPc3OQ6XtijZiLAJqTu4r59SBClIz4oNfEAUFhV+EQK3DrWExjoyM9HnMKcBFRUVx4MABNm7cyPr165k1axabNm1i69atrFu3jo0bN6LX65k/fz7rGtPmuCOKIldddRXLli3zOtatWzcGDx7MmjVrWLhwIW+88QarVq3yahfsmNVqNVu3bmXLli1s2LCBQYMGsXz5cgRBYP78+fz4448kJCTw5Zdf8uyzz/q9niiK9O7dmy1btngdW7p0qc81EEWRSZMmMXu278jv5uan0WgkQpo/+68T9zWQO9fX/UxLSwtqnO7XAnj99dcpLS1l27ZthIaG8thjj7muKYois2bN4p577vHqw98cH330UW644Qby8/N56qmnSE9P51//+lfQ41RQCATlZ1QFBYVLSkDCoKuxQyAs+PurAfVdbTRyPG809fv3e9mUT097hDPTHnHlCqxdu5Yzj07HbjJ5RwSKItXr1vHxPRP54tW/8vHUidT8glZiJ/GNuerU2sB+XVRrbSRW1boi2c7HwPT7NPz7GoOkIAXA5swKvhpazIrh55pyEHoW9RAESqIi2OMnr54cToEw++R530VRcOT425bWgZLoSEmEnFy0oL/8ZF54PGeyVmw/VEbFsvj2x/hg/IOsvPJmybGVV97MB+MfZPFt06mMjqM0KoLdjesjKww6cRMI+7jlBfSM4GzQgR2Bbe168lXHKykIS3blndPpzVR1iuGKe2+VnGNqKCLqpSnorh+IVRDY2DMZQ0Roi3IwBoNnrkRfmKN1iIkChkS9a19iRBkPqt5ionEpkyv/7RLfoq0GYioNlK6PkfThnsPQZlZL7mFiRBnJ+jM+hUEAbZj0nodGmwmLq0Onl89J54yK/KjDzSzpdDtVmijJ8UuVdbRL9gCum/4kfTvH8tKNfXjpxj48e3U3Onz3BpoLpwHQXjhNh/wFjHl4OgXhKa0+loJd2/lw9oscPGegPqkHRysa6HLL/Qy69wmum/4kutBQrpv+JF2zB3o9Yzq9GbGNnZ3qBDqEh/ts5zlnpzDoD7VGw/innyEytqffdi5hUFCDAKkZcXROjw18ARQUFH5xIkICi18JtF2gjBo1infeeQeAsrIyVqxYwVVXXUVZWRlGo5G8vDxmz55NSkoKhw4dorKykri4OPR6PTU1Nbz//vuy/Y4ePZr8/Hz279/v2rd9+3bAkXMwMTGRiRMnMmfOHLZu3Rr0mN99911EUcRoNLJkyRLy8vKoqamhpKSE3NxcnnnmGYYOHcqePXuorKykTZs2xMbGYjabXXkVneNcvXo1hw8fBhz59ZyRgCdPniQ/P9/Vdu/evZjNZr9rcP3117N06VJOnXL8OGi329m5c2dQ82vXrh2iKHLo0CEAPvjgA6827733HgCFhYVs3ryZ3NxcANLS0lw5E1esWOHKhejrfgbCqFGjWLp0KRaLBbPZ7Lo2OCy/7dq1IzQ0lOLiYldeRoAbb7yRRYsWuWzjFouFPXv2uMa5c+dObDYbJpOJTz/91HXekSNHSE1NZerUqTz11FNBPx8KCsGgRA4qKChcUmo3b3YJdAEhirBpE4y6qdmmFX+aQki5TFVXUZSN+qtdu5bjeaMdRUXcsAN7OidQ0mACQeCc2YQtObiIORduhT0uFqfItj+mbUDtYy7U07fogmvMdQFqaRaN3Xe1XzeBMKOohAp9uCTfoL+xu9uPZaslCwKG8BBCzFYatOqArNMBCYQe1uRg+/O0EvvCrNW5Iix3JidSHR4qzWEoMy6nQNituIjimFiqIqX/DZ+JU7E/LpVjiVFcU76Gk+HJFIYl0117jF63naAXJygslJbqPXjoMccfo+F4ZRoNVS2zXgeLe67ESm0M3yU0WaHySvOJtlRSExPJ+LxvZM/vN6op55AzmrNKE4VZrUPbIQfcHMM71/SlUNWeOlUdWoyEq4J7jXUYLK0w7Blx6/kceEZFum+LBFeFOFDkRDJzfT3vTpvqZeM1GSr54ZU/kx/3B0aVr6OLqbBVx1R2cDePvvohBRFdJfvX920gNU7jiuRzz03ojNDtxQmuZAvLt6QydcQVfnMYBioMOtGF6Lh73t94b/pfqK34yeu4lzDYN06xFCso/ApJjYtg/YzhrpyD7lbiN27JJC0hstVyDrozf/587r//fvr06YMoivzlL39h4MCB7N69m6lTp2KxWLDZbAwZMoRrrrkGk8nEF198Qffu3YmPjyc3N9dVZMKdtLQ0li1bxr333ovJZMJsNpOVlcWyZcv45JNPWLp0KTqdDrvdzqJFi4Ia8zPPPMO0adPo06cPADfffDN//OMfOXPmDOPHj8doNCIIAt26dWPSpEmEh4ezdOlSunfvTmxsLKNGjeLs2bOucb733ntMmDABi8WCWq1m0aJFDBgwgJUrVzJjxgwef/xxLBYLnTt35vPPP2fixIk+1yA3N5c5c+Zw0003YbVaMZvNjBkzhpycnIDnp9FoWLBgAWPHjiU2Npbx48d7tbHZbGRlZWE0Gpk/f77LUjxv3jymTZvG008/zZgxY4iNdfxQdPr0adn7GQhTp07lwIED9OrVi5iYGHJzc11W9EceeYTx48fTu3dv2rdvL7GI33HHHVRUVDBixAgAl605KyuLcePG8fHHH9OzZ086duxIVlYWJpPjM/TChQtZt24dOp0OtVrNa6+9FvDaKSgEiyCKP3PZzWaorq4mKioKg8GAXq9v/gQFBYX/aYKKHAQQBCJHjsT88isYBRXHjPUSK/E/e3amq9ohDLY/6v3lMFhkRSuQzZX3S2EH9me2pbJtKKExZomwUbS2PfWVOocwuPeCZKznY+CR+5r/0j1uQ3v0Ro3/SDNRJMRio0GnIbGqNqh18bnGbn1HhteRNtH7A7UngeaK82fFbq4/zyIkvpAUJ/ElrspQHWaWFIfxxbgN7Wlj0mLp0BNtj3ZkpTVvIznyaYpswRafORdbiVJdHB91aIqyvOXsxySYywmLq6f7H042e/6RT1M4X9XOZw5DAEFbTmTa3KZr7IynrV0gNFr6mggW9zVzWonlxM4YS6Wsxbg1CI+K4k/z30UXGuraV3mhiv/36FRo8J1bsFYVxocdb2t1gVAECsKS+TZxNHahSWz++uGhpHdoiqK0Wa18/tpsCndvp6pTW4Zf2yRcv7b7Sf7z8N1EhmiwWa1SgVAQ6Jo9kOumPxmwMOiOucHsJRAqwqCCwv8u9fX1nDx5ktTUVELd3ucC4cBZA2MXfO/a9nwfUlBQUFBwIPdeG4y+pkQOKigoXFIErZaOb8wLTCBsFAblqhY76aqG8JtukI8YDBK/opVbxNwvLRCqgL57L7AnOZHqrlJhp75Sh/6ETRIx6CSpEv6xyEqdDs7ECSy8vulLfu7eWKJrtU05B5tTFRqj3oCg1qVZYbCxb1t4YLJGILniLrZdjKGCKcvnYdbqqIhJkFiLx6z9mNjKUkfOQfcKrUFYeC3awH6Ts2gc+QZ15w6TlhJY33IFWwLJuZickUXR/r2yr0/nHn8z9LQYO7dt5sBeOTazmoZmchgKHnkKTfVqwqpDfLQOHOea+Suw4i4U3nl6WasLhCaDgZX/mMP1jzui6Opqa/l/D94Fdv/5tCLsddxxZjkfdryNq8rWklpX1CoCoQB0qSvi6tLv+DYhTyIQuqPWaCjPHsrOGgvEqRhOkzio157loy1ruG1gD8LDUyVFTi5GGATvCEJFGFRQ+O3iaR1ubSuxgoKCgoID5d1VQUHhkhOQQOhDGIxUS7+UVj/11KUXBt3G9L8kEMpZjD2txJ4kVTrm+lNSW6BJ0Iiu1RIbrLAik4vQ37oEtMaN2CyBWWGDEZsupp1E+HMjtrKUxHJH1J+/ghX+0FoDm4OrnShyfMth0hjHFXdOoL6hsMlKDNSdHMap3aexmVWyUYHN5lwUBNQaLV2y+lOwZ4fk9emMIBPAr/DkbjF2Xw/3KrUh0WZSPKNeG4uLmKt16DTyOQwFbTmCugGVTmoNdhbViYqUzxvoD89rQ+AFVgJtFywFu7dzYtd2OvXuy6J7JyDarc1r9jgEwglnllOsad28egLQ1VRIsukUJyNSZduUVx0nTTWVtJHex6b2WQLiEn7cCpcPyncJhCf37pJUI24pToHwszmfUXa2LQKKMKig8FvE3WJ8KazE/4u8+OKLrFixwmv/p59+SteuXWXO+HWxePFiFi5c6LV/wYIFrnyBPzd79+7lrrvu8to/adIkpk9v3k2ioPBbQLEVKygo/Gz4tBg3EzFYYGqgpqGB2ldeoe0Xn130OJoTrbxEn/8Bi7EdR/Xi2GoTBzLbUhkbSniVhexdZX5/5XHO9ViSTmJlHbeh/cVXsG1mXUr04exKTQq4O/ccge420cqv2tLlQDWHE9px3trmovuTE4Z84WkxdlqJPaPMgo0mqw63YNHYqYq0sDmzSYj0iuh0p9GKOXzKdezaM861+8inqdSVe9u0gpq/INClX38QcRMIBQrCk/kmIQ+Aq0u/c1lXW5J3LyyurrHCsHPc3hboKm00Cb2z0HTrx993mrysxL74S7s64gOMyPR5bT+Rg+5cishBJ8mZ/Tj702GsDabmG3vQ2rkQRaAgPEUSOehp51u87htSeajZvvr3/wJ9m/RWHF0TNpud1W8f4OS+clIzFGFQQeF/kYuxFSsoKCgoBIZiK1ZQUPjVIBtBGICVuEt4CIYfNrFn/WrsXHyZ9TJ9uKNCrgy+RJ+S6EjKKmskRTZ+LlxiZnQkiVW19Nlbwo60DlRE6NmXrPIrWjrnqq9zCIIWjV1eeGoJzUQQOqstBxI5CGA2aEHwFuu6HKim2hDJ+baBC4OAS/jSRkitmfVVOtm8fHK4W4zdrcT+ClYEgq/19xvRKYqc2LUNIcRApJvOIhdN6S/nomwxDlGkYNd2rnvsKQSVihM7t1IUmcI3cVe5hKFvE/K4uvQ7upoKORmWjEYFnY3N54lsGqejnzKLwDlTDKe0MbTRhEiEtmhLFea96x1CJd5WYl/UB/kzp1zEaHMFVi5lzkEnRXt3t/hcX6+wluSbdOUc9GMprm2w8uH2Mp4e0Hx/ZtulEwPUahWj70nn1IEKOqfHKsKggoKCgoKCgkILUMRBBQWFnxWJQLh2bbPCIDiS3q/f8yMnUpMckWqFxRclEHqKVpVRsS7xx1In/YptVmldEXLxv6QwGOWw0ZRERVDVMzng/H+SuV4K/AiETit0QNbiRqEYvIWbI7FxpJ++QEJVLaUBCo1OdHozXa4+I9kXqOXYibvF2L1ghTvO7Yu1GDdrORZFjv/wE9cOfI2ky1LZuGQp5prDNGUGdBBszkVnxJ4quTfXTR/Au8tX8fUBEFQaNK7l1pDfbjRHTac4E9KBGduXEBJqpFQf7rPQjM5qw6x1fNQwV+v48bNkPsopA+oh6wi1x2cwoeC7pjVrjI7snpEB679HtAVmfT+zsjMmmeIk7lGSzvnazGpKTfGYdd6WcF/3LsZSSYK55ekMWmpBv1j85Zt0f99zf8Z9FSPx5N9bCjlZFcus758mVN1AUkQx9/Rd4jr+7oGJnK9th9Gq44EQNXcNaf35OVGrVaRmxF+6CygoKCgoKCgo/MZRxEEFBYWfHadAWLt5M5G5uc0Kg1/Ne4UTu3cAjWJYSruLEgjdRavDnTuz+LbpCEYr2OyMXPOVpG2lNprYGhMJ5dV+c+uV6cOJrzahktluKbL2Z2dhkADz/znnuiojgRXDL7j2t4qt2Ikg+IysDEggdBMGQZqnzmZWY7ZrsSZrCTg4zK0/T5GsYHWHFlfrDbRgxeTKfxOnqQgoUktv0koiOu3mOEplRCsXjeLZZdljUWs0jH2gN181uFWBbSSYnItV2miWdLwNDPDaG9+zfsZwBo+8gtvbnJI9R7B1JPfDeXQs/gkR0We1b53FhlkrHYepXrotqBtcUZcikJSe5SpUsX7GcA6drmD1Z4cpN5SxPTGFsA4fuc7NOJBCTI2Gtg0mwkxa5Gr6ykWJBmIJ91VgpSVcrAX9YvCVb9KXXV4ETCod+Z17g6rxPVZlAnu4RKitbbCyaKNDdCw1Jcheu29KBl3sjtxYOSltZdsoKCgoKCgoKCj8b3BJxMGzZ88yc+ZMvvnmG0wmE2lpabz33nvk5ORcisspKCj8ChG0WtqMlMli74ZLGPQQPlpTIDyd2BHBaCXk+xIAfogcJGn3XcJVfJcA9IDFa16hg1EaPeRp+c0oKmGf23ZL8xQ2V0nZc7s5gbB7cSnub/kWjb0Fo/KBKBJisRErE1lpjRexh4r0MRUD7WRFJDnBUCKqCTgiBqH5qMHG58Q93547ao1IWFxdUBZL15gCtA53vKaEZL0jWlGuMrAnTpE2EBGpa7/+kiqvao2mqQqs2+vEXWD1m3OwJoSEjCz3WjUYG6ykd4jipQ59ZMdbs24dZw45xHoBGfFXFIky1mOIbBLlqsMtXAgJp7KN9P6pdKWcjlFjrI8kxqhm7MirXHOzWa08+NF/gaEQBirzWcm5WyKuw67uwJ2nl+GcgKcoKieSBmIJ91VgpSVcrAW9Jfh6/p3bFRHSdwmz1vGMOgqcmEmLfJ/Tid5yq8E6AIji31sKqW3wsOt7RHlOG5VBeLh8IRMFBQUFBQUFBYX/LVpdHKysrGTIkCGMGDGCb775hvj4eI4dO0ZMTEzzJysoKPwmsFmtF12R0pcw6MSXQKiKjSW8Tzq1GzfJV0Vu5Ex8O2pDQymNTQRbYEJZnUb65VfO8ruhZ7IrWqqllY6DqfLrwodAeD4G6nRQHCftx1nptVXyDzZGM+7zuLY1XqT0haaIqz7PyQiEQcwvUHRRloDy7Z38OhPD2cBy2qVk5hAphkB1821D3fLkBWrvhWZEJFEksdpEVmEJKo/nWiIQ7tzadL4PUdIZTVeliSK+byaabv1gZ5Owe7y0tnEewJnDqLrEUS82EKGNIFmfTGRuLpFXXunKGyqJDo2OJNFgpH1lDXsaxcHqcAsrhp+TGQmEdfiI/3Zw/F17fAYj66AHjtf/N+8txrHVuAQe4pNz232dvKJO3dYgWEt4UIKgIJCalcOFs2cwlEirWbeWBT1Q/OWbDLlSxI5AqEccbkWMI/pPa2mgJvQMZ+Ll4jAhJlJ0RQ16vr2WmhJcFmONOoIvh3S6+MkoKCgoAFScgIYaCGkDsb/+ar0KCgoK/4u0ujj497//nU6dOvHee++59qWmKr8cKyj8XnCJeju30jVnkCTKKeg+fAiDTjwFwtC+fUl+/z0ErdZnVWR1bCxFgoY7X5zXtNto9e5chjBrk+jjy/JrDsLyK2c/bpEw6DY/9+uVxMAj98mvvXuF3FaxGMvM1R7qce9CRYmIFGK2Si3SrYEgBCzImRuq6H/DnZSfLuTk7p1+26pUKiY++DDlM2ZQbaz3Klhxbc23xKnKadPGSGJEmWu/M1LLX6Rik4gULdnvEpFsZrpXnCOrqARTYTG1mzd7Rd2qNRqufXgG706bgslQJTkmF03nilKsRiIMAjz60V7X3zdVvEf+0COu7a9v+ppkfbJXYSGnQFhWWePKzenMERlolKqgbiA6tbvr9V968DB0dBMHLXHUHp+BoG5AtIUgWuIc6+Nh+ZVb50At4QFbfj3yKXbJ6k/v4aP46vXZl+Z6QeDr+S8miceFhbLHVl55s+vvtmdmoPZxywoMBXy19xy1tmLUQrzXS/dCfSKiCDZR5JOdp7lriPL5T0FB4SKpOAEL+jVtP7z7VyEQbtiwgUcffZS9e/f+0kP5TSMIApWVlURHR//SQwFg/PjxjB07lrvuuqvV+ty7dy+HDx/m1ltvbbU+FRTkaHVx8Msvv2T06NHcfPPNbNy4kQ4dOvDAAw8wderU1r6UgoLC/xgSUQ84sWsbX817JSiBMFBh0EmJ3iFI5XbtTed/vOHKX+hVFRlAq8VWXk5tpxRJH2KEhoahjghCodaK7r+VrmN5pfnEmC+QVG0gqdFS3BqWX087svOYv0rKAeGW/69OF1gBldayGOuiLFTHqylpqyW2vAFrO+n9c2zb6WMqpmNlBLHVJocFO5BiJRCwiBhovr0O3fsx5I8TAPjy9dkU7Nrus23Bnh28/9j9hBoqkau7mnPVfpeV2B3ZysBuBCoivX3kFVSNlb0jc3MBKKouwmgxEqGNoGN4B1bNn+MlDIJ8NJ1ZF5gYXKeVStqlVfuJ19gJD0+VFQjdc072O1XKvuxeVFsDE99FWwg7PnqPQlUDBXt2EC2KXtWDRUscoqX56sHhUVGYDE37A7XyBtROFBFEEbNGLdmXktGPrjmDOLFza+teL0h8Pf91sk+uN3aV2qc4OGvzLAAi0+DKyNeIVCf57EfJM6igoNAqNNT4324lrFYrmha6XX4pfo1jDobf+vycNDfPvXv38vnnnyvioMIl52Jy5ctSUFDAm2++Sbdu3Vi9ejX3338/06ZN49///rds+4aGBqqrqyX/FBQUfn3Iinqi6BIIbQEIBKLFwqEP3nNYIwMQBgEQoCQ6EvMdt3gVNtGPHYM6NrZph9kRxVUv8/+vGKFB1OsQI6UHYyyVJFgqsIVZKdOHX7Tl1w6Y40X+OyCGys6O8bofc1YXDnj+XhMRSayqJb7aRJi5+eYQQIXcAHBaGbv/oRBxqpHyWVaq7pZGMFXdbaN8lpXyFyzEhhjRABlFJYRYbL7nK4okGIzEG4wBr4lTDDvyaQpFa9tLjhWtbc+RT1OpPTCOsQ+8jFqjQa3RcP1jT5Haz09eXFHEZGgSjT2j1dytxL6Qi+gKVBxq0IZKKnsXVRcx9rOx3PL1LYz9bCw/bPmSE37ETXO1w0rsFCebK7AhaMtRhZ6lPqxWsn/dvsf5z6arOFzyg6uwUOTIkbKiuH7kSMYsfI9KoRs3bWjP8B/TyDiQImlWd/YW+uwawBU/9GZCwXfU7N1Mwe7trnsdbTWQYC4nxlIpOc9ZPVhOGEzJyiaxazfJvkALiujsluafM0FAFATJnAv27GDVgrlc+/AMuuYMCu56rYyv5z+M+oDOF8TA2t0zvCMv3djH57/0DlE+zzWZrfy/709iMgcmHCsoKPwOqTgB5/ZC+VHp/vKjjv0V8ukTgkEQBJ577jn69+/PrFmzKC0tZdy4cfTp04f09HTeeustAOx2Ow899BA9e/YkIyOD7Oxs6uvrsVqtjB49mpycHHr37s3tt9+O0WiUvdbq1asZOnQo2dnZDBgwgPXr1wNw7NgxhgwZQkZGBn369OHpp5/2O+aUlBRmzpzJgAEDmDRpErW1tUyePJn09HTS09N54YUXXG1feuklevbsSWZmJpmZmRQVFQFwxx13kJOTQ9++fRkzZgzFxcWuc1auXEn//v3JyMggMzOTbdscP/jv2LGDkSNHkpOTQ1ZWFh9//DFAs2uwZMkSBg4cSL9+/Rg2bBj79u3zO7/hw4czbdo0Lr/8cvLy8igsLJREBdbW1iJ4fOaYO3cuWVlZXHbZZXz44Yeu/YIgUFVV5dqOi4ujsLDQ5/30hb81Pnz4MIMHD6Z3797ceOONEi3D1/ME3vexuLiYESNGkJ2dTe/evXnooYew2+2Ulpby7LPPsn79ejIzM7nvvvtadW4KCu60uhRvt9vJyclh9myHtSYrK4sDBw6waNEiJk2a5NX+5ZdflrzAFBQUfn34jfZzEwj9RRCKFgtnHp2Oau1a2vdP55ylPjAxSBRJNBjRLlmOOOByBK3W0de0R6ht/ODlSd+Thcx86yXOt42hom2CxFI3fPtqfqTJvuIUCxINRmKrTRdt+d2X2ZbEe4qJp4R4mqLJ3KMLm63u28xaOKMQkyrhH4usmHTwQ49ovh7cJPTk7o0lulbbOjkHAbU28Nx64LAc2xHYl5zo21rsNp8SfThlQURU+s63F0L7lOGMfcD7WRSEwEVS94IVEeEmiZXYF3IRXYGKQ7E5WXSc9zeXAG60SL98mL/4nBCLlQZNYDZt9/F7WqRza75k74AtAOzyOG/phca8f9/e59NiTGOEY8c35vHv7Wf4Oj6Pa0pEUiuLaGNrwP1rgd2cQKfK4ySYa/FHMNWDSwtOYKqWiob+5usVhehcPx/FcgDZ/Sd2bmXl/Dlc/cBjnH/s/sCvJ0s4EFjkrxxyz387zvPAty9TZkzAFK2XvO/py95EZT2LINajsV3wOleOCG1Ei8f33g+FvLr6CPVWGw8MT2txPwoKCr9RPK3E7qxwc6O1gsVYrVazY4ejyNYtt9xC9+7dWbFiBaWlpWRnZ5ORkUFISAhr167l4MGDqFQqDAYDOp0OQRBYtmwZsbGxiKLIAw88wIIFC3jyyScl1ygoKOD5559n9erV6PV6jh8/Tm5uLoWFhSxcuJCxY8cya5YjMvvChebfgysqKti2bRuCIDBz5kwaGhrYv38/dXV1DB06lB49epCXl8fcuXM5f/48YWFhmEwmVCrH55w33niD+Ph4AF555RWef/55Fi1axNGjR7n77rvZtGkTPXr0wGKxYDKZqKqq4p577mHVqlUkJSVRXl5Ov379GDx4MO3bt/e5Bj/88APLly9n06ZNhISEsHnzZm6//XYOHjzod35Hjx5l06ZNaLVaCgsLm10PQRDYs2cPBQUF5OTkMGTIEFJSUny237dvn+z99MVf//pX2TW+5ZZbuPPOO7nvvvv405/+xH//+19ycnK4/XaHI+Thhx+WfZ4GDRrkdR/r6+v56quviIyMxGazccMNN/Cf//yHW2+9lRdffJHPP/+czz//vNm1CHZuCgrutLo4mJSURK9evST7evbsyaeffirbftasWTz22GOu7erqajp1UpJYKyj8WgjIBtyMQOgUBmvXrUMF9N15EHJ6Ny8QuolHdUUlnJ72CB1fm8vZx2f4FAbBETKdt/cge5IT2e9xrFPVKdKqDjdVKbVUua7RGpbfqthQEt12uaLJPOzHGUUlbOyZHHhOPg9h0ElSJZTowxHskUCTABNdqyW2OsSrm2DR6c2otTYi28gXMPBJveBfABVFdBYbGY3zaWlWQk9BrkP3LC9h0PkMF+zeEVTfLmHHTGCVgWUEm/YRKr57+HIarCLbX3+Lv4ZluI49sfNDOteWEZuTxeWNwqDTSlxgKJD0s7b2GELbSLQ2MWCx15cwFSFWyu73RNZivHatJMIxJ6Utt1+eCtbJiF++isYqFfVEW0hAAmkw1YPlrNXOPuRwRiG6xgQIIi3KhVmwazvvP3YfJkMV0T7aeF7Pm3BQJ4CtMOjre+L5/MdcqCS82sgpQZoLUGU9i9ZS1Gx/L+e+TJeoLq7iNC3BWdAEYNGGE0y8PIXIkN++bUxBQSEIArUOt4LFePLkya6/8/Pz2bXL8bNYQkIC48aNIz8/n4cffhir1crkyZMZMWIEY8aMQaVSYbfbmTdvHitXrsRqtWIwGBg8eLDXNb799luOHz/OsGHDXPtUKhWnTp1i2LBhPPHEE9TW1nLFFVcwatQor/M9ueuuu1zRc/n5+bz22muoVCoiIiKYOHEia9asYfz48XTr1o0JEyaQl5fHmDFj6NixIwDLli1jyZIl1NfXU19fT1ycI4fvmjVruPrqq+nRw5HvV6vVEhUVxapVqygoKOCaa66RjOPIkSMkJSX5XIMvvviCffv2MXDgQNc5Fy5coK6ujrCwMJ/zmzBhAlpt4D9cT5kyBYAuXbowbNgwNm3a5Fcc7NKli+z99IWvNb7mmmvYu3evK79gnz59GDp0qOQ8uefJKQ6630e73c7MmTP5/vvvEUWR0tJS0tPTg7YSBzs3BQV3Wv3T2JAhQzhy5Ihk39GjR0lOlv8QGRISQkjIxX9BVVBQ+PkJKj+gD4HQXRh09qESRfruOIDtss6UhGqajSpz/pdnXL+eY6Ouwh7Ar66uAgoxcZL9Oou5SUTwuIbT8tuSyEGniBYaLbWfehasKImKYHeyQz70F1En2e9DGHQSX22iXWW4ZF9rWokDpWhtEuGn7XQ/eYH/hrfzv46NxV32JifSr6iEhGqTq8BFoGKpzmLDbNA2Cnf2RmHwZS9x+uTeXZIqvy2hucrAcujCI7jr9TcJi2wUnB+7F95sGkfn2jIys7u7IgadVmI5HFGhDvE32AIznuJcmCWwHJQnfppOtVbk8kH5LoGwdvNmInNzXRGO6R2ieKlDH47v3MYXDbVEoWXchvZcCAlHtIcQY/wu4IIcrVW4w18UokijEH0RNXI8xUlf13Ndy7uHVhEGQT7fpADoG6QpXAK1EneJ6kKv2F7NN/TDv7cUUtvgsBPXNFj54MdCJXpQQUFBSkib1m3nh8hI3z/6OoWbqKgoDhw4wMaNG1m/fj2zZs1i06ZNbN26lXXr1rFx40b0ej3z589n3bp1Xv2IoshVV13FsmXLvI5169aNwYMHs2bNGhYuXMgbb7zBqlWrLnrMarWarVu3smXLFjZs2MCgQYNYvnw5giAwf/58fvzxRxISEvjyyy959tln/V5PFEV69+7Nli1bvI4tXbrU5xqIosikSZNcjsJAcZ+fRqPBZmtypwRikXVfA7lzfd3PtLTA/i/ytDW39Jj7PF9//XVKS0vZtm0boaGhPPbYY37neqnmpvD7ptVl5OnTp7N161Zmz57N8ePHWbZsGW+//TYPPvhga19KQUHhF8JmtXJ85zZO7NoeXH5AUeTEzq2c3Ov4FU1OGHSiArKOniJRLtecHzEsEGHQ/Rp5ew9y35JnuWHlHG797GViDBU+r+EUFGXH5AdXPr7xhSRfeV5yLPnKc3T/QyG9bjuBTm8GQaA0KsK/CCYIkryO/oRB57ivPFDO1K+iuW5zu9apTozvqqi+qK8K4Wx9DD/EpQQmsDauhVMs7VdUQkIga9+Yp3D4T0UkGoyYq3UkRPSWFQZNppPEdQ0lbUjPVqmaLFcZ2BfmOhOr33zDlY8zMkJaMCI2J8sVgQfeVmJfBFtgxhmVd8vZj7nz9DI6VtczbkN7xh+IYUJbqZg9oW0DjyfW8Zd2dcRrHffBanOMS9BqaTNypFfuT4DUzGy65jh+KdebtKRUWkg11LZ6pd5A8Jyv+xh0kXriemX+LNdrxRrdfvHMNykCFyxtiN1WwltdI4g5NwONtSSgvi7GSgxNUYNub18s2nDCJRYqKCgoAA6r8MO74Z6NMO4d6bFx7zj2X4KqxaNGjeKddxzXKysrY8WKFVx11VWUlZVhNBrJy8tj9uzZpKSkcOjQISorK4mLi0Ov11NTU8P7778v2+/o0aPJz89n//4mv8r27Y48wceOHSMxMZGJEycyZ84ctm4N7sfKUaNG8e677yKKIkajkSVLlpCXl0dNTQ0lJSXk5ubyzDPPMHToUPbs2UNlZSVt2rQhNjYWs9ksyYM3evRoVq9ezeHDhwGwWCyuSMCTJ0+Sn5/vart3717MZrPfNbj++utZunQpp06dAhzRcTt37gxqfu3atUMURQ4dOgTABx984NXmvffeA6CwsJDNmzeT21i4LS0tzZUzccWKFa5ciL7uZ7BrrNfrycrKco3p4MGDfP/995Lz5J4nOSorK2nXrh2hoaEUFxe7cjoC6PV6DAbp56XWmpuCgjutHjnYv39/PvvsM2bNmsWLL75Iamoqb7zxBnfccUdrX0pBQeEXwBUtuHMrqf1yCI+K9mnj80IQ6Jo9kNTMbL/CoBOnGCexnwYghgVDSQx8esVJ1/a4De3RGzU+r+Ec049pHTBEBFb9M1ARzd1i3CyNbULcrLeenI2Io04TQpi1gQ7Gcq48UM7u5MRG4TGgIfkl0KrAkvaCQIMuiP96BIHS6EhKK2toV22iX1GJ2xzkoyoTDEb6Na5J1qlSajp1IeeFV2SFwR+3Ouw7kemQxjiObznsX3wUBLpk9UdE5KSMDVkuUssnHtG0qXERrJ8xnFpjPcL+PfS++m8SoS1QYaYlUaGeIp3epEVXJdJGKxUaE7V2Oumk66NRNz8utUbDddOfDKoS+aXElyhpqa0mMkRNpTYSm8V/HsTWuN7PjQjYUJEfNxKLwcrZAoFvr3vXr/Bc1VBFdEi0TyuxyWzl/7af5tYBnQhv5rXtHjXoRIkeVFBQkMWX8Bd3GbTPvCSXnD9/Pvfffz99+vRBFEX+8pe/MHDgQHbv3s3UqVOxWCzYbDaGDBnCNddcg8lk4osvvqB79+7Ex8eTm5vrKvrhTlpaGsuWLePee+/FZDJhNpvJyspi2bJlfPLJJyxduhSdTofdbmfRokVBjfmZZ55h2rRp9OnTB4Cbb76ZP/7xj5w5c4bx48djNBoRBIFu3boxadIkwsPDWbp0Kd27dyc2NpZRo0Zx9uxZ1zjfe+89JkyYgMViQa1Ws2jRIgYMGMDKlSuZMWMGjz/+OBaLhc6dO/P5558zceJEn2uQm5vLnDlzuOmmm7BarZjNZsaMGUNOjp8CcB5oNBoWLFjA2LFjiY2NZfz48V5tbDYbWVlZGI1G5s+f77IUz5s3j2nTpvH0008zZswYYhuLFJ4+fVr2fga7xuAQK++++25ee+01unXrJrGO+3qe5HjkkUcYP348vXv3pn379hJ7+ZVXXsncuXPp27cvgwcPZtGiRa02NwUFdwRR/IU/oXtQXV1NVFQUBoMBvV7/Sw9HQUHBjaBsxJ40CoPXTX8SlSg2Kwy646oQHB1JYlVtqwmDAAWJ8OTkpi+0133fjl6nLM1ewwps6JmMOYCcgIHab53FSYIl++R5EqulxQvORsQx5aqmhNiL17xCB2M5dvAvrgWJTm/2m2vPKZJ5CWX+ij144iH4+ZyDRzv3whhy0WzVNQfYseMG13Z21go2LP7K9/Pt9gwDfPn6bAr8VAgOGLd+fRXsceKec3DW5lmu/a1dYMZJXYKJj3Kaiq04IwZ7dn+VSP1laNQRhIdL89fZrFZO7t1Fama2V27HE7u2c3BjviO/4//Wx4/fDSJgVIWxpNMdhIeHsWXWlReV8++f64/z6uoj/Pnq7n4FvtoGK5e/vJaaeu8oQX2o5qLHoaCg8L9LfX09J0+eJDU1ldDQwH5YdeFZnOQSRAwqKCgo/BaQe68NRl9TslMqKCgERGsIg2MfehzTpk3UbNhA7dq1AffjjNbLPnm+1YTB8zEOYfBsnFSgiqkrI7q+hJIY/+drgOE/FaGz2Jqdh9mgpfjtdhT8XyeK1iZJjhWtbc+RT1NaJgyKIolVtcRXe1c1rdOEyG6rCNCeK4oB3R+nZbG+Sjp2Z6692nOREkuji2CEyUZ78Z7kROyAHYE2UYkkacMk9upAhUGT6STVNQcwGaWCbX1DIcOnXEfa4B6u8VWHW6jQN1AdYZUIeGqNhusfe4ou2QMCn4cv3CIInRZjXyTrk+kV24suUV0k+50FZlpTGAQIKw13WYzdrcSR+svQt0mXFQa/mvcKX7z6V8l8nPu/en02iNClX/9WEaed6PRmwuLqHNb8/3GCefdMjaggJaIiyLP8IwAR9jomnv4Qk6mOT3aebnFfnsVF/NmD5aIGnTijBxUUFBS8cLcYK8KggoKCwiVD+YlWQUGhWVpLGDw/4wlHNdMRI4gYMQLjhg1BCYSe0XEt5XwMPHKf/NvfB1fZcL41PrNUS+/TdT7FSKdAuKFnMmZfdrpG0ap9ZT27U2MI00qr+vorWOEXH/Zqp5X4VJsESXPnttNi3K+ohF3JiZRFR/qM4tNZbI55BRDlF0yuPef4gxUIj8R1wGxpQ2FcFFFCFZ17Z5N06BDnLXVBCYNOK7EnBw89BjRZjHfv/S8rrmiKhpx03W0AHN+5zRUVd/1jT7ls9uFRMZiqq1oWEddMRW9PPC3GWnUk0HzV30DwTBWgN2nRGUSXMAjyVmLJ+wS45nPtwzNYtWCua3/Bnh10yepPl379WyWC0DMyt6URuD8HvouQ+GhvFxFUQuNZwZ7tGwEIt9cxtXg5MRFJHKrwrjYeSEXiQIuLeOYa9MSZe1CpXKygoCDL70wQfPHFF1mxYoXX/k8//ZSuXX/9a7F48WIWLlzotX/BggWufIE/N+5Vh92ZNGkS06dP//kHpKDwC6DYihUUfmcEkx8KLlIYBLrmDGoSBp02YkEgcvhwh70tCIGwtfC0EvsiGIvxtq7tHTkIfdhcwWGFreqspddtBa4mLY4Y9CEMuluJfbF4zSskGRvzD0ZHojNb5e3RokiUqQGdxUpZADZkZ0Vmm0WFudpPFfrGdREhoH4BqtR6lnRuyl3rLOzQpV8O7Y4Vof9hGyrnsxWEldgX2VkrWPb+v3mz7RrXvuXXLOP4v7/gxM6tdM0Z5BLxnDbazukZTSLYRTzT1z32FCq1mtTMbABZiy44LMY19dV8PP9t2hw72XoFLgSBcH00JkOlazslqz+1A6/gmr7RRIbqfUYMes3dsy+3/f5yNwZDWFwd3f9Q6No+8mlK8IJ743gQaFXL88XLec5xCJI9rVnMpDSqgW8uL0aUeZP7+qavfQqEcjZhX/bg9384yfNfHUItCD4LsNtEkeev68VdQ1K9GygoKPyquShbsYKCgoJCQFysrVj5eVZB4XfGez8U8urqI9Rbbc0mgL9YYTA8KoaeE25k2z1/pO3OExILaO2GDUReMQxV27bYKypaMpUWExag81BrVVHSaGf1JxBqgMtPnJPmwZPJkwdgNgRRsEIOUfRZhMTTSuwLoyaEPc6xgkMYlEMQMISHkGCwkmAwNpun0GzQkmAwAzZKo3Q+C4Yk1lsY2rkbxs3fB5z/0KyWrpNZ5RD+CnbvRMgeQHtdOKZ163wKg04BL7F7rN/rAJRZBApMZXQcOxy2NImDn/7fP2g4dgptuOAV5ZeW40gw7Sq6sTO4aoOAS6A6uDGfgl3bHZZlEQp2b5eIkU46hnfgszf/3brCIIAoYqquckRCGirpmj2QM1k3M/fb4xjpwAPDAxQGnX15CoON+wv27CCxS8uLULjnu3THuR3M66td126MeeTPALw7bar8mJsZh+f1ROBkWDLZKW2p/GkPVlSosQd5r7xbt3aV4wRDCB3Lwjid6B096K9QSTDFRXJS2jJhUOdmx5KT0jbAUSsoKCgoKCgoKLQmSuSggsLvCPdIj0ASwB/fuY0vXv3rRV0zxlzGwJ+qW5YnsFFkuxScj4E6nSPn4ILrm8SxsVsiEWyRaG1uhR0CrJDsKpQRHUlCVW2TzRUo0YezKzXJz9lBcJGRg48eegdbqCXogiB+I/3cxgSw57LOlITrpPdPFGmHmpyHptO1/yDOPfY4hvXr/RZ2qdJEYVZpqdTG8F1Ckx04rzSfGEslOruFaKuBrtkDGJF1Ofrhw2WFQadg1zVnEFfedysi9ZiMJ1xWYoDevV6nQgzn1u8eoznGbWiPvk4nW0jEXF8ftMAEkNAljfCoKAr37PI+2GjPT7/rj5w4vJeuPTI58P5/OLFzG62Zj87zmu26duPaP7/IsHk/yL5vXOwPCD4jC/2g0mjRhBtbrchPmD6auuoqiRgbKL4szU5h8KfI7lyVdwX7vv6U/obdAffrj9aPHKznm8tLZCMHPxr7Eb1ie7m2bTY7pw5UENOlDRP+tolDogW7x2CU4iIKCgqeKJGDCgoKCpceJXJQQUEhYALND+UkNTObrjmDWpxrMMRqpH9LhUG4pHbjJJcWIb2GYIsktsYjAk8QAoogdBb7KKusIb7aJGkXX20isaqWktaoEiwIlERHUlZZI8nD2MFYzuI1r7hyDr6a02TDfWLnh3SsKeVkYmRwwmDj9UqjIhzFV9xx5g30ECvVcXHcsvRjVr41v+nZEUWSdGGEpffh63++5rCbv/4a5x66H3NtuexlqzRRLOl0u+wxd6HwztPLOLFrOwgqrhsxAvc4SLk8eCzCVXHYnfCIrpTXBfbMWTR2n3kCTx3YF7QwCFBacNz3QVFkz6HNPLPqI8d2AYw71B49rVuAxPOaxSeO8f7sv2ESLgfUkveNixYGG6/hjFIstpRi0dj9VlwOj4rhrtff5Lv3/gI0Lw6qdTa/x8P00dTVGABaVHnas3+1zoYImAhBFEXGlH1H+LZievbqiX33UYSG2osW9lpLGBQRqQux8e1AqTAo2KFjWRhn4qWRhDabndVvH+DkvnIIVXFNvYY0jcCXEWaJQBjI/y0KCgoKCgoKCgr/WyjVihUUfid4JoR3JoCXqx4pWizUrFuHShS5bvqTdM0eGLSYFIPIFQfOt/gXCDuOaDt7sy0vDk+Lsdbm423RTSD0NyZn4RTPXpwVlxObqxIcCH6qFHcwlpNmOEvnmlLJ/o41pdREW4MXBp0IgqM4icy5CW7CoNCmDUmf/otzO99h4G2ZpA3uQXW4BW33BEwZKRTs3Qk4RLqvF75G1hsLaO9eddgNp3W4OZztTuzcKlshVyJeuQl6AtLoBYFQti1dGtA1tVaVV3/O6zpF9dasxguNgqSf7UuCKGIr/C+jS75DJdok7xsn9+5y2Kdb4XkutpSyYvg5vhpazIrh56gO9y6uEh4Vw5/mv4MuNBTsgT0bvgrjhOmjSOiS5hAGWzB+Z3VkT0tzRJKJmLQqEttX0KX+FACm4/uJ/PEjVK0gDLYmdTobn1xxFrvbm7Rgh+F74rlyVwLD98RjtznET5cwuN8h5Iv1jv1pVhXXG3WopAHCzVYuVlBQUFBQUFBQ+N9CEQcVFH4n+MsP5Y5osXDm0emceeBBzjw6PXiBUBBI7tyFgXtPXJQwuCc5kV2pSc2KcRdLYiVM/Sqa6za3c1hFfUQsAQELhL4ISCBsTqgI0OIcZm2QbJ9MjLy4qEW5cQkCOn0D2kQz1njHcWs7ge0Hb+Q4/+LQ0Ueo6/4ZK4af4520nfwjYTXVTjW2UVT7ZtE/GPfm/yM52bv6ns4eWPVd93Yndm7l5N5dzebBO7FrG2sX/R8D+q+mf/8vGNB/NWsX/R9V2w8xbkN7rvu+Hbl7pfkJc/fGct33Ms+Jh0Co1mhaJqr7oDrcQoW+gapI6XpURTr2ywlprYkAdDUVkmxyiF3O941WE0EFAU2stOiFRPgUBNqlXcaf5r8DwP8992eO/3iEQ8u7cuTTFIrWtpecW7S2PUc+TfFrKa6rNjgiNVsoDPa67QTd/1BI8pXnJMc6Di4l5crzpF13mjbta4Pu++dCDA3n42GlssJg5xJHMZfOJWHseWcp5gZzkzDYuFxCo8wpIJBmVXGDSYdOENCoBNSCQHW9lU92nv65p6WgoPAbpai6iEMVhyiqLvqlhxIwGzZsIDMz85cexu+CzMxMampqfulh+KSwsJDo6GjXtiAIVFVV/WLjUVDwhWIrVlD4HeAZNejEGeEx8fIUIkM0LmGwdt06zsS3w3SsgFNPP8fgl15oKrTgz0LYmBdt7EOPc95oa6pOHAROYbCksVhGIHbei6FMH45FHUVsoJ8pfFh6A8UpELrm6FHdOMRio8FH/r1AhUGQWoyNoQJn24VwUYZEmfE4RBJH5eVyIO45LdRXSdrUe9x+iejjFAjfnEdWjYVii5UGTdPco60G7jy9LKCcg04Su3ajc3pG889q47VZBNc+PIN/v7GA44dOoFPriTYZZE+JrtUS66sKsyi6hMm0nIEugfBibbfV4RZWDD8ne2xzZlMhn2aF7YtABIyqME6HdXRsu71vXPvwjBblV3RiCLegjU2mPLQL8KNrv1MI1drUZPUc6rKB/99zf6b4+FEAn8JffZUu+GrFQdCcVdmJJvyXiZyrjIrFrNWhs5iJMcgUewqNZFHiraiq8wmJ2whIhUF34a/0vwdZ+swj2FU5aCPCsdQmenUnINDVouZebRiVmXpQOc5XiosoKCi0BkXVRYz9bKxr218V9YvBarWi0fy6vhr/Gsd8Kdi7d6/sfmV9FBSCQ4kcVFD4HSAXNejEGQVkratj2/33Ur1uHWfiErnzxXncO2s2f7j6j/zw1DPNRxA2CoPXTX8STVgYia/PobBvfFARdhJh0HmNi4zWaw5nLsCAxRs/lt5AkY0gbBT+rvipSD6yMAhh0InTYtyn5ExwcwwQT5HkxLBw6ns77lKZReC0WaDEIh2tV7SbKHJi13ZWlZ6UCINOoq0GEszlxFik4lOMpZIEc7lEGAQIaxPFyn/MCUyQaxQIX310On+r6sVH7cezpNPtVGmiADfrcCOe2xIEga45g0jNzHbtao0IwkCtw5fSYiwAkfY6OtWdce1zvm+0NL8iOITBz4af4z99fmRdtw8lxzZnVjgsxlecJf3uWwH4at4rLmHQHU/rsC8rcWsRaP/aMBthcXXo9AGWR28FKqNiWXzbdD4Y/yCLb5tOZZQ0+jVUr+eD5DuwqrSYK4Yj2nSywqATXRszyVd/R2rebLpe+zTayBLZ6wpAaKmZwSXwwnW9eenGPqR3iLpU01RQUPgd4Vk13V8V9WARBIHnnnuO/v37M2vWLEpLSxk3bhx9+vQhPT2dt956CwC73c5DDz1Ez549ycjIIDs7m/r6eqxWK6NHjyYnJ4fevXtz++23YzTKj2/16tUMHTqU7OxsBgwYwPr16wE4duwYQ4YMISMjgz59+vD000/7HXNKSgozZ85kwIABTJo0idraWiZPnkx6ejrp6em88MILrrYvvfQSPXv2JDMzk8zMTIqKHJGXd9xxBzk5OfTt25cxY8ZQXFzsOmflypX079+fjIwMMjMz2bbNkbN5x44djBw5kpycHLKysvj4448Bml2DJUuWMHDgQPr168ewYcPYt2+f3/n5GrMgCDz99NNkZWVx2WWX8eGHTZ8b3CPxPNenuLiYESNGkJ2dTe/evXnooYew25s+M82dO5cBAwbQr18/rr76atf11q5dy+WXX05WVha9e/fm3Xff9Tvu5tbVk7lz58rOJZg+FBRaG0VKV1D4jeMratCJKMLitT8RvXgW5y11JHZOIMIuzcVWsXcfp6c9Qqf5/3BEQ70+mxO7tpNQVYsmPp5zljqvqq0fHvuIf4yuYLoJco7J/xLhHJKAD2HQSYAFQVqC30g+rwEHL9AFdN3oSEm/8SaBM4kx1IaoiKm+ENR17YKKira9ib1wEJVol1xrbXocxdGh0krMLUCnN6PW2bzyrUVdaaAWhzD4t2L5yC1f0W5mrf//jjwtxr4sx4WNOQ0DRhSpNtZBdNMuZw5DvUnLuA3tmy2S4S6Mqz1+ob7YCEK/gmQL2rUEESgIT6EovHPTvsbowTueuMJRtGjn1qD7rNf6ryLsZMUnG+hWfZ4zxzcTFmej3BqL0RTuiho1V+s4tLwrap0Nm1ndbHXii8X9ehFJJjoOLpVt18FtfyBVk1tlbB5r6r6dkJpG1ch7qF5/0rHDHoKtbCBjThwl3hDiJQyC9w8AKo3/H0VO7itn9dsHGH1POmq18vuzgoJCyymqLsJoMVJgKJDsd25HaCNaJYJQrVazY8cOAG655Ra6d+/OihUrKC0tJTs7m4yMDEJCQli7di0HDx5EpVJhMBjQ6XQIgsCyZcuIjY1FFEUeeOABFixYwJNPSoueFRQU8Pzzz7N69Wr0ej3Hjx8nNzeXwsJCFi5cyNixY5k1axYAFy5caHbMFRUVbNu2DUEQmDlzJg0NDezfv5+6ujqGDh1Kjx49yMvLY+7cuZw/f56wsDBMJhMqleN9+Y033iA+Ph6AV155heeff55FixZx9OhR7r77bjZt2kSPHj2wWCyYTCaqqqq45557WLVqFUlJSZSXl9OvXz8GDx5M+/btfa7BDz/8wPLly9m0aRMhISFs3ryZ22+/nYMHD8rOq7Ky0ueYwSEC7tmzh4KCAnJychgyZAgpKSl+16e+vp6vvvqKyMhIbDYbN9xwA//5z3+49dZbWbZsGUeOHOHHH39ErVazZMkSHnjgAVauXEm/fv34/vvvUavVXLhwgaysLEaPHk3Hjh193hdf6yqHr7kE04eCQmujiIMKCr9xPtl5mpp6K2pBQBBAbbeRXfwTu9r1xKZSo7GambT//3E+xEZldBwlsUlYQqRlzgvbdYDjJzn11DMMfuFZsgpLiC4sJt5ghFOlpA4ZRM5Dj0uEkSs6XcH7exfzfZ9qBNFK9nGpQGgH9l+mJSshC9sPO9jTOcG/OPdLC4StKAx6Xte9uvGZ+HZMenGeq82U5fPoUVQUsDB4oNcUyuMziCvbR/qhxS6BsCQG3rmuytW2pTZUZ741f3haiX0RTLSbu8XY00rcUqo0US7LsjvObZ3d4tNi7MKPMOhEIhAGKaK5C5RVkRaJuJq7N5boWq1/4fIiEQGTKox1iaNQqTSuZ1AUobreymd7z3NnC+YmAGGWwCLqzh5ZR1htOb1uO0GJMZ45PzwGjbfsztPLXALhz4nzeiHRDc20dBCoFbmlOK3EFTEJkv0VMQlowiMZecMf6J+Vw9BXN7r0aY3dxu37ygm3hXr15+sHAJVuFSHR12K3yluMwSEQnjpQQWpGfOtMTkFB4XeHp5XYnVmbZ7n+bg2L8eTJk11/5+fns2vXLgASEhIYN24c+fn5PPzww1itViZPnsyIESMYM2YMKpUKu93OvHnzWLlyJVarFYPBwODBg72u8e2333L8+HGGDRvm2qdSqTh16hTDhg3jiSeeoLa2liuuuIJRo0Z5ne/JXXfdhdD4WTU/P5/XXnsNlUpFREQEEydOZM2aNYwfP55u3boxYcIE8vLyGDNmjEvYWrZsGUuWLKG+vp76+nri4uIAWLNmDVdffTU9evQAQKvVEhUVxapVqygoKOCaa66RjOPIkSMkJSX5XIMvvviCffv2MXDgQNc5Fy5coK6ujrAw7x+R9Xq9zzEDTJkyBYAuXbowbNgwNm3aJCsOuq+P3W5n5syZfP/994iiSGlpKenp6dx66618/vnn7Nixg+xsh+vDZmv6v7qiooI//elPHD16FI1GQ0VFBQcOHPArDvpaVzl8zSWYPhQUWhtFHFRQ+I2Tk9KWCYMcET+CzUruh/PodGgHp3v15/s/PkCnT/9OdaMwuPi26bJ9vDz5IdffH956B+2PHsb1tVAUifphK+dnPEHHN+YhaB0iRWp4J97adBnipq3sSINTfeNJ+W85iCJ2YF93LQPe/ZiUiM58PHUiJWZT89ZLD4EQHDkD42WqAweLP4FQp28gvsFIz/MXULVyvVFndWMnplDpF/WupdXBCYNxfQAoj+vDgV5TXAJhnYd2YlG3zIYaiMgRGuASBRvt1hqCoJMqTRRLOt0ue8w9t6FTfJJFRhi0mm3sXXuazCs7odE12U+dAuGx7T+y/v23MBmqAh6rL+HPbw7EVkIAwu11TDJvwTj0dlBJLbU5KW1bLH66hE+tjqqIGonw6Y6Fc1yItlNmEai3SecbaEXrS4XVFNjHqEtpdXZaieVYeeXNAPw/Czyw/ZQrvYRKtHHj+S8Jt3lHAvr7ASB5+F5gLwAnVr0kKxCmZsTROT3Wa7+CgoJCoARqHW4Ni3FkZKTPY06BKSoqigMHDrBx40bWr1/PrFmz2LRpE1u3bmXdunVs3LgRvV7P/PnzWbdunVc/oihy1VVXsWzZMq9j3bp1Y/DgwaxZs4aFCxfyxhtvsGrVqoses1qtZuvWrWzZsoUNGzYwaNAgli9fjiAIzJ8/nx9//JGEhAS+/PJLnn32Wb/XE0WR3r17s2XLFq9jS5cu9bkGoigyadIkZs+e7bd/J77GnJub63eunrivz+uvv05paSnbtm0jNDSUxx57jPr6etf4Zs2axT333OPVx3333ce1117Lp59+iiAI9OvXz3WeHN9//33Q6+o5l4vtQ0HhYlE8HwoKv3HSO0Tx0o19+OuYHtyz7l06/eSwXXb4aSc9VrxMtWAGQfCyo/mitk7mP0ZRpHrdOrbdfy/WujpXYRNxsyNPSc4J6BXbi4jhwwGo6p/GoP/3KWlx3Snct5tzlrrAc7I1FgQp1Ye3ekVjuVyAOn0DvW4rIP6uEspfsLiq8rY2Z+LbcbRTCkXtOkj217SJ5XinFM7Et/N5rkQYFBrf1gUV5XF92NT/Zk60U3E2Trq+tWENVLQJsNKtKLrWIxCRI14r8pd2dTyeWMeEttLIKp8Vf39mzOrAnnd38Sk8KrrpgI+IwRN7ytj2RQEn9pTJ9nf4h42YqlsmcgaVA7EVEQDduZ/IOfE1L4ztyUs39nH9c+aVcwqE7dIuC6pvvUlLrEFEY/X9+t+cWcEn6ZX8rTiMo7XSKM8afRtKdXGuPJE/N7XnIjn+VScK1yZxdos0ai+QqsmtQaDv3ct2nUYUHcLg1aXf0c4sb4cONMpRpfH+vyA1I06xFCsoKFw0EdqIVm0XKKNGjeKdd94BoKysjBUrVnDVVVdRVlaG0WgkLy+P2bNnk5KSwqFDh6isrCQuLg69Xk9NTQ3vv/++bL+jR48mPz+f/fv3u/Zt374dcOQcTExMZOLEicyZM4etW4NzGIwaNYp3330XURQxGo0sWbKEvLw8ampqKCkpITc3l2eeeYahQ4eyZ88eKisradOmDbGxsZjNZldeRec4V69ezeHDhwGwWCyuSMCTJ0+Sn5/vart3717MZrPfNbj++utZunQpp06dAhxRfDt3+k7/4mvMTt577z3AUf138+bNPkVDdyorK2nXrh2hoaEUFxe7ciUC3HjjjSxatMhl5bZYLK7rVVZWkpycjCAIbNq0qdlcif7WVQ65uQTbh4JCa6NEDioo/A5wr0LsjNzb0zmBEqwuUU4XoMUvVOZXM1d/NaWcnDqRwZFxmDZudAlKggimDZuIHD6cDgvm02P4cAStFtFiQfvBMhINRkr04YEJhKJIgsHImZg2lF6CisaeuQDjG6S/SttDRS6q6q8MZ+Lbcaebldid2W5Rm/9+djohDdWSSEl3YVBExG4+gUqbgiCoqQor5/8Gf4rc70Drc5qKSPgV6kSReIMRASiNipDkWwuNbiD5yvOuppVftSWlzIBhso14rVNElcq2P0e0W7MIAh1Vgd1D99yGiV3SEFQqCnZt92klPr7LEdF6Yncp3Qc2Cbo2q/WiKxcHnAPxUuBRjVkOtUbDzc/MZvHDU6irrrokw/jP8Wsl26vaXA1tHH/7jfK8hNSei6Q63IIqrg6dRXA9+5e6arKTQN+76+osqBuFwS6mQp/vYoFGOdosTc+fiEjcZdGKMKigoNAqJOuT+fqmr105B92txC/nvkyXqC6tlnPQnfnz53P//ffTp08fRFHk/7P33vFR1fn3//NOSzKpkEYJpIFIEkgCoa4gIAKCoOui6FdZUVl3l48NxIa66uoqP0FRURddFVZd7K4KuoA0BekQmvQ0airpk8m0+/tjcm9mJlPuhGK7z8fDh5m5977v+5YZZs6c1+s8+uijDBo0iF27dvGnP/0Jq9WK3W7nd7/7HVdddRUmk4kvv/ySXr16ER8fz7Bhw+RAC1d69OjB0qVL+fOf/4zJZMJisZCbm8vSpUv59NNPef/99zEYDDgcjqD7yz3++OPcc8899OnjrBy5/vrrueGGGzh58iSTJ0+msbERQRDo2bMnt956K0ajkffff59evXoRGxvL6NGjOXXqlDzPxYsXc8stt2C1WtFqtSxatIiBAwfy9ddfM3v2bO6//36sVivdu3fniy++4I9//KPPczBs2DCef/55fv/732Oz2bBYLEyYMIG8vDyvx1JbW+t1zhJ2u53c3FwaGxt55ZVXvJYUe3LvvfcyefJkMjMz6dKli1vZ9s0330xVVRUjR44EkEvHc3NzmTt3LjNmzODpp58mJyfHrTTaG+PGjfN5Xr3h7Vi6du0a1BgqKucbQRTPc3zlOVJXV0d0dDS1tbVERUUF3kBFRcUvXoVBH731XPtWSeVoABPWfEJsdTkGSzOXHj/uJsK1Gc9fbz5BIGLUKJJecgph0rwcoqg4ECSh1inWlXuue557AlriRc7GhhAZ2UTtba1OmpjFWnSlAhqzgK7i/IiER7ql8Oc5zwVc777F89E315BY0+Asq24RBitiM7DbirE3/4hoK0SjT0cffjWVEaf5rO/8gONO3NjJt2DXIg7mlpSxx+M6h8WZ6TW5WF718KcpdDhrJuHO1mQ1z3CS9joGQyOjMDfUn5fE5RBBQ++iM6zvcYncc9C1lHhM+Wo6WKu99jacOGsOGq2W1Jz+aHU6THUW9qw5jt3unNe+dSdx2EU0WoHMyztTW3qQmM69KD/2KcV7tgc9f2N0DKbaGozRHTDV1QR//KLY7qRkNwSBHkMv5fKpt2AIicJoTPW6mt1m48sX/kHRru2Bp0arzF5ntPL5iNMBt2k4NhvR6r3/zpRTn5BgqQw4hoTUc/Jce1h6zv3RTk3E68WLFkICcDY6luMR3RmTfowHMh6Sn3+td3e66vXc9tZWms+aAgqD4CwrDu1oBlFAq3eQfEXrsZWs6YK5xoDdosXW1Bt9+NUgaDimc3D7gwPo2z3mwh2kiorKLxaz2UxRURGpqamEhrbtc+qPA1UHmLJ8ivz4o6s/IiM243xPUeVnjiAIVFdXExMT81NPRUXlZ4u399pg9DXVOaii8ivGUxgEZ4++shjvvUo61Hrv+RVbXU5ipdMh5tnzr42o5y84RBRpWLuWk/fNJPraa2hYswZQHgjiUxgMtF8/2OJFHKGim9hnixepfMoKWPGUDGpchMKEJ/TnRSA0+ulh4kpDiIYOzc5rsCulk1MAjM3A0vg1oq01zc9hLcDauBx9qP9fOSX8lqcKAhXR4exJTiS7pIzdyYmUt9w/dqu7w8hu1XLaEQNvQg9HJcXx0VRYornOpjlnt1tUfAJdel5K4a5t7drelWaHnUPdM+kgRiJaitos72Ct9ioypecNJr3/QDe3YGNtM3vWnMBuE0Fo7X/jcNjZ+dU/cVgLQDCC2ERrPndg6oxWEvpkcOXUv0JJNd2zsvlm4fxW56EgIHTP5Fh5PelNx32PfR6EQREITdATkfU5O/M/B2DI4NVtBELJHVmUrywx2nVm/oJXJoaH8OH+OxHtIT6FQWibYF1ntPq8746HJvFl54ny43NxHXoG6xxe3YWKmlA3YVAK+LhQacqWJi0/dMgjpcHd6dwzPJRde8toPmviqvJVpCoQBl37DRaucG+87u6GLMBuLaLImMpX4Rama8+vo1pFRUUF2pYOn+9SYhUVFRUVJ6o4qKLyK0UWBlsEOIn4OhOJNQ1+XXqeZWpuj6Wef9X1nOoQ6X0cBQIhDgfGyy93lh8TQCAMJAwq2a8XbPEi5U+1CgqS2OcsHQ7M+SoxTqoo5b2/zcQUGkpJp65upcSPvPMqTYLZKQzWOXuiIAiUR4Uj6EugsRjR1lbgclgLiLE28Mdjt9IsaqkQm1l7yX/k5UEl3bZc88rqeufjFnHKtcRYEj0M0Raq9aHsMnWloSIMBIHz4QEvLzxGRP+BpPUbeO4CoSBgFirRhQ7BYdFgcLgLgZ4iE0BavzyvZcTx3SK5fs4AVry5n9oyE6JDRBTtWBuWO4VBALFt6IMvNDo9NQZTixPtNIu+Wc3y3y9Hq9Nx6e8up6H6LGUFR0jOHcDfTXk0JNq4uvJbkhuLz4ur0hsCoLG7C2c2u7sIdb7Kpr1xSUQNz/R/B7M9hDONnfjXvj/Ky/7U5106h5dy8n+JhNtaz7Onm8/VsVqji3YTBqF9wSaS+FgT4X6/lNk0NCOiN1qJ04mEdjSTNra1LCiQozA+JZ2KkkLF57FBE8Z/O0/CIej4tHm427IIrZa8lI7c2q2JiOLigGO16TcouM/BteRYo0+nKKw7X4VbcKi6oIqKygXCtcT4QpQS/xz5+9//zueff97m+c8++4z09PSfYEbnl7feeotXX321zfMLFy702Ufw51Ls+Je//MVrX8jNmzd7TWBWUfkloYqDKiq/Uho2bGgjDIIyl16H2iqmf7AAi96AwWpxdxR69vxrj1AnijSsW0doS38Uz7ntSk5sHbulrBUCCINK9uuBpwgoiX0as7JvukrXU0JSRanX55sEM3pzNR2aPQVYEK2FPrVJQ5SFSyevB9YDsOHrAW7Lg+r9J4rorHZOdIikwuMaeLqjXF1H57ussnDXdtL6DZAFwnaX2uIUNrT6NLT6NDo2LmfqiaX+S0wF9zvJbrNRtHsnqTn9ie0SwR8e6M/bszcginYqxY+xhBWj1wfvlHTYrPQcNwIcrYmG9eY6vlr0bwp3OkXRxLSenMmdTP26IkRBy//iruAv9o+gqT7o8xAIyfEWGuP+g4Gp0XmdBUIpO1yFw24PKqnYH55O1lAB4sO9B7x0Di8lOeokZp2OJlo/lHu6+aTHNbpoSkPi24xTrXcGnSgtMfZXBu3qepRKjF0JFPgR0bEDkR0HULhrO/7cpiJQakjgi86TsLWIm2aTjv/b9BbX3DSdiE69STOGgDGE3n/5A8uajvoUb31dZ61OpHBlVxAFzNUh8utZ0KdTGXUVy8PtqjCooqJywfktCIKu/O1vf/tVp9ROnz6d6dOn/9TTaBfB9oRUUfkloYqDKiq/UsIHD0YTG4ujqm2psFKBsA1KHXwSvoQ6QUAbG4t53z5Fx9Ks01IX0fbXOJ+lei1Ot4rqehLr2rq2pFJiWyf3L8nOxw40ZoGEJ/TyOjUXuOegK54lxs5SYl8CrO9xPAUIg+OM2+Ogkm4FAZteS4WPcnRwXgtjgvu5Vpp6qhhRlAXCibPmkJLdz73UViFST0ZBcLqg9OFX07FxOQ5Lgc9tCndtZ9mCuUyc+TCA0yW3YwvpeYOZOPNhTh+tQXQ4hcHPftcqkgXTY1Fyop04uBF6tT7/6YcvYTl6HL3RKTaWFR6lpOx1hPgxCMCY0lVOYfA8346eYq8rPx6YJf994IN0knpcRlr/gRTu2k5dmCVgGbm/kl+pxJgYCykZXYnXb5aXhWrd06+lx/pwG3aLhUqb4NXNVxNhpdSQyLqOV3otTXbtOamkxNhTfPSF2cttKQlwvkqMi3btYMK9D1FVWUXN8QKvl1UECo0prEgYg0PQujwv8En9cGZqHEQYW8V/KU3am7vT33V27Td44IMWt4pgRG+8is4OPVebtKpzUEVFRUVFRUXlV4AqDqqo/AoRrVZO3j/bqzAooajPn9ugzsCPrtX17ErtrHwyPoQ6e2Xbnm5SuEm5Rw/DuvBQQiw2mvXa1nRlfy61lrnG+xAGXUuJXfHsJ2g4ocEzbVdXKrQ8f2FIqijl33+bSX5qV/dSYoX4cgB1Mjq4aU9Hmh0aqDUE3/uvxcUp/+1CRJcGekw80WaTQCIIgEanw2GzKZ9Hi0AoCBrS+w/0Knj4E54kYfBspB6LXsBgFYltcAqEloZlbr0bPfdbsHMrX734LIhQmO8M3CjYuZVlC+ZijLkaa+NyLGHFbpspFZFqjVb+68OJ9ln0NrjM+bckNnZvLGacYyWHI3qSZj5+3oVBUC7uag12CvO3k5Y7gOgBl7IkboW8zJs46q/kVyJOL5Ix8ThwHIAe6X/jWMHfSQyv4NnfPY3ZHkKotpnEFkdh2riTVFgF3iz1XtLjdPNVEcEev6EmoKzEWKm4HurlungKbp4/bKT1G8DBDeuoPV5AeHQHTLXVbtuLQJExmdUJV6ARnD9oONCgwYGASB3hfHrQxLQU9/36EgiDuc7OCZgQbSfQGNLpadOSatNQoHdwrLyB8BAdqXFqPzAVFRUVFRUVlV8aqjioovIrQ7RaOXHPvTSuWxdwXa8Cobd0U5fEWiBgz0LPbdsIdV5cXv5SlBEEmvVaQqx2WSD0/ELb+sXVf2pxsP0EPUuHz2cpsS9CmuvQN4fToTnwuq4EcgBJRTkHPkjH4nWtALgKhC779CYMSvuU8FVi7LDZCAkPp7mxsc0yn4giBTu2ULR7Jz3yBrUKHju2EJ13KUsSVsqrysKTIBDR8VKsjjGcjdDz+oQYeZ0ZX9fQsV6BQCKKcmmv51yaOuZjCqv36lgDvAqVUlqu3mHFritXdOiS2CgAaU0lGG1BnLcgce0vF3A9UaQwfzuhA3q4LWsjjgoC2pjwgOsk980AWu9lQ0iM/HeijxJjby49bwjaZkTvvw849+Wl56Qn/gJUbunYTKLe4SyH1vuflOv7mAik5OS5ic+mupakaheB0BoeTodOOm7ge3SWTnyg7UWzIKDFznWaDegFO3md/5/3/XkRCIO6zjgFdo0+BRGRYzoHRS3X776PdgOwbvYIVSBUUVFRUVFRUfmFoYqDKiq/IoIRBiU0QHZJGd/1TqbZoPMp+NUaQ3HgfNPILilja3oXasND/QuEAYQ6CRsEHq9FIIwwNmE3Cm2ccaExFhChw1kzfUvO+txfsP0EdRWtJcYXqpTYEyWhMd4I2gHUHlzm462UuD37bDaZELQ6RLtCB6EgkN5/EKk5/Z1jtwgeRTu2UvLpG5DQuqpV55DXH3/Pg6x+5xClx92dWM06EWvjct+uwQDUGa18PrjE6zJX0cgzFOO9bq0Czu+rFgPe+0664upYE4BO1koahFDCRfN5Nw+6Bs6ExljcxN6SNV0w1xhkV6gcznFqN7iY8lzFUQQBbXQ4pbg7ml3XidOLJPfNIO/3wzl4eFnrXCzeBUFXvLn0vCHaneW2gr7SKRS6pCBfc2aZ4tRiX+7bRL2DbgZlSqUkuIlAUWh3xIpGNKcOtorwooiprgZDZDSW+lrS+/ZhouWfgIaVNQ9Q1DyAq3Q2vgq3YhO0JGvKmKFbBt3ubt2HS3/M4zXNNDbbSJvyV+qaLFT8uCuo6yw5bxE0HNM5vJYUNzYH4QRWUVFRUVFRUVH5WaCKgyoqvxKkdOJghEFwOvb2JCc6HXm+EAQsei3f9U5m2MES9iUnUhsR1qbU131CyoVBWZgMgCHaSo+bvIswrl9oHU/o0fgQ8VzFPqX9BJ1/exlPp4NgSmIVEnTJdwvBOoDOBX8uxaD3KYqIdhsNGiPhDlNAkcsYFcP4u2e7JQefqC3hxGdvUlC0E/q03nE1EVbi9aH0ufV6TtpFutyUhvB1Aa5BDxXhZ7FGmzBYY7332gzA2RCjovUkh5xI29JVgznCpxOt/95udKmzenUfCkC4aMaMnjACO96CxVc5uLnGQFOls4RXaTiHLzwDPML1BW7CIMCxY8/Jf5ft6UBidqvA6ypgXefSc9B13GG7Y9E2dUB0hGCx7ebbrjlE9JgvL8/eNoTUmkbFwqAr3gJUAlG4Iskt4AMgwVKBcPJ425VFkeb6WsoMCUy6bTbo7mDlf85QVOa83j1sWiY1Ciw3NvG1aQg3z3qU6Fhnf0A5RXrHFjr3zeOxun44BC0a0c64siqkzMvD1p44rJDJIbddu15nJcKgioqKyvnCUlyM3U9VgTY8HENKysWbkIqKisqvHFUcVFH5leArndgffkt5PagLt2HVOvh8cBJRJucXWs9SXxmFwqAD2NqjqyJhEJQ73qSSYF+0in3n1k9Q37Mn9vJyt96OUtjJuboM2yMQ+nMAxSzWoi0VOBgbh8WhP+cedUqvRfGazpjKjf5TiwUBQ0QUEfW1NGjCCHc0+Z2eqbaabxbOZ+LMh9HqdBRXFTBx+bWQBWS5X78NOVVsoIp3/jeZs53nYdd3gi7u4311WTrwfwBM/2BBUAJhjS6a5fFjiGB+wHX1No1cSiyl40pU6zvQwQoGi5UY3EuMv4+8lptLvyPKh3AlAGFYMQsGQkSL13Mn7VdpGq8nnuKu62OlfRWVoKQ0uKky1H0bFwErEmgUQonG/Rid6dxWwEq5oRrBI9ikg72CGFv7xFXXEmO9TUOFTuSsl9egROGKJOpKIt2eE8DvfS8AiZZyNr/1Ckdir6X4iNVlmUC6VeTW099itBbx9isnuPfZZwBay4eBM/t2Mi6sklXxoxlb/i2pTc4fWpxdC2FVwpVEmE1cSrE8tmspsT78akRETtmPsTyqs1sQioqKisr5xFJcTMG4qwKul77ifz8bgfCrr75i3bp1LFiwIKjtGhoaiIyMRAwQrFZcXExOTg41NTXnMMsLy+nTp5kyZQobNmwIetu8vDzmz5/PiBEjzv/EfoNMmzaNnJwc7rvvvp96Kiq/IFRxUEXlV0LEsGFEXHEFDWvXKk5urYgyUuYngVbCZ4CAl16AwQiD+cmJ1LokagZCqeMt2NLhYLeTsB486PbYM+wk4Qn9uZUhCxqSGuIRhUrKo4yKBULA1RgHtAqfWSfOUpkRiUWnOyeBUOm1UCIMGqNi5J5q4Y4mGhUIhAU7tvDhEw8y+eGnKJr7d6cwGABBNAdcx2JQfj+C0wEoWuNoODYbQdvM0MZl7MkqlpcP2x1LTIMevU2DwxLnVkrsimtarmeJsWgP8RuSIQLWLr1pGnI9huUvIDS7Oy08S5h9pvEKAqm5eZQeO0pTXY37cboIz54BM0ElXwdAievOZnL/6OJ5L0aIZhwec5LmWGe0YgqpRWNwF2DtYdVU2fV+E5b94bpNoH6e5mrv91igQxeAih93UqWvcUvbFkU71oblGG1FADhK9vPZvL+j1+oo3LXdrUQ5zVTM1BP/cXt9Sf0rx1Ss5vP4a8jZGUNN8T7sFo17KTFQY1pOvKWQMba2SckqKioq5wt/jsH2rHcxmDRpEpMmTfqpp/GT0qVLl3YJgypObDYbOp0yecZut6PVnvu/wcHsU+XXz4WL3FRRUbmoCHo9SS8tIGLUKMVlqFJvu0BioqczyO2xi0AIBCUMBttTz1Krp/zNTsQ+pyNmsfs/iDGLtcQ9pwtKkJNKjIPdzheeYSdKw0+8jiVo2J8xnf1Zd2KLGEyUKbh0ErvV/fxIwmdldAQWvW9h0BBlISyuCUOUf4lDEosOf5ZCyZouXtc5tqxbUMIgtDqo7Gg89c02lB47wpvT/x/WH7YHWNOJKIQGXCf9kt6K7skaXTTlhjjZASha43CYu+JoTnBbTxIGrToH1eHK3JYN9iRytg2lsehuOVm3Wt+BckMcNbroNusbo2K4/7mneeq6fqRnZrRZ7iksehUaW1JyBQSa6r07Cy11Toee5zWVnHMTN3Zi2O5Yt2V/qBnIxB86c936LozZmsCw/FjyDsS4rTNsdywTN3biuvVdqPg0jcOfpVC8pgsVVoETFoEKq0DJmi4c/iyFAx+k03A6Qr73PINupCvnOifpxwzpR471Q44R1vUjtzlsyKli2WWlfD7iNHXG81Oe7SlaFq5I8hnMEwwOawEOazHgFAY9U7YF4MTuXc7wHI/3dl8ORQFIMxUzpmI1GZMfpkvKCCx1BtL6D+KSIdNa1llJmMW5nzRTMePKV6ERz6F/qYqKispPTFNTE1OmTCEjI4Ps7GzGjBlDaWkpI0eOpH///mRmZnLXXXfhcDg/9y5ZsoRRo0YxadIkMjIyGD58OMXFxfKya6+9FoD169eTlZXFjBkzyM7OJjMzkx07dsj7feONN+jZsye5ubltnIY333wzeXl59O3blwkTJlBa6r0f8fbt2xk1ahR5eXnk5ubyySefAFBRUcGYMWPo06cPffv25bbbbvN7Dp555hl69+5NTk4OOTk5lJSU+J1HcXExMTExzJ49m759+5KZmcnq1avdlkkIgsCzzz7LwIEDSU1NZfHixfKyTZs2kZOTQ1ZWFrfddhs2lzY9L774IgMGDCAnJ4cBAwawefNmednBgwcZO3Ysffv2pW/fvixatAiA0tJSbrjhBgYOHEifPn147LHH5G1mz54tjzd8+HAOHz4c8Dz6Ys2aNQwZMoTc3FwyMzN5++235WW1tbVMnz6drKwssrOzuf322wGwWq08/PDDDBw4kJycHG644Qaqq52ffadNm8btt9/O8OHDycry/Uv3kiVLGDlyJH/4wx/o06cP27ZtY8SIEXzxxRfyOpMnT2bJkiXy47179zJ06FAuueQSbr31VpqamnzuUxAEN1dqXFycfG+npKTw2GOPMXToULp168aiRYtYvHgxQ4YMISUlhQ8//NDvOVP55aDKxCoqvyIkgfDkfTMVOQil0tXNPbo6w0A8kEMGAiWwtgiE0Y1msi+QMCg5Ep1hIxos51ASHDHickRBQ+P69egq4FxrbKVSYlsn9/PtfOwIusTYodGyv/cdVMRmYG1czlltASFhXdFby7Dqlb1tS0Jq76pKtC37dwgaypJuRKMrweElfMOzj2AgIcPXMqWlxCFGo5swKC8CtDgUXRWL6OBwYndeWFSC1QCn4gQWTmoVZe7+yk7XSpEwC9h1/x+m0FDqH3mU2UKrY/bJ8A4MviSWKIOe5GFZLGtulJNcJaTXQiAH4Obo4UTQmmjcrHew7DLpg30pwrFKOfzCF98mXOn8w8Xo6Oos9HT+NdXVcHz/HgCKdrUKpf5KmAG3EuP0/oPIGD6KZS8+67auIcri1S3oiS+3nWX/cWLrQqgzWlk1yHsis7Pk1+mmkyTpmhAbH5SGyevc1KQhpLL1sa+5uDYU8JyT0vLn81Um7c9teS7IacFehEEl+CtdTjMVs+/915nywCMc37+H1Jz+2O0OPn3mac4cPezuNmwRCFUHoYqKyi+VFStWUFNTw4EDBwA4e/YsRqORZcuWERERgd1u55prruHjjz/mxhtvBOCHH35g9+7d9O7dm+eff54777yTVatWtRn70KFDvP3227z++ussWrSIRx99lJUrV7J//36eeOIJ8vPz6dy5M3PmzHHb7qWXXiI+Ph6AuXPn8uSTT8oCmERNTQ133nkn33zzDZ07d6ayspJ+/foxdOhQPv74Y1JTU+U5nT171ufxV1dXM3/+fM6cOUNYWBgmkwmNRhNwHrW1tfTu3Zv58+ezZcsWJk2aREGB9z7UISEhbNu2jUOHDjFgwACmTp2Kw+FgypQpLF68mNGjR7Nq1So3UWvq1KnMmjULgC1btjBt2jQOHTqEzWbjmmuu4amnnuKmm24CoLKyEoBbb72VOXPmcPnll2Oz2bj66qv55JNPuP7663nooYeYP9/Z/uXDDz/k3nvvla+9r/PYtWtXr8fTr18/Nm7ciFar5ezZs+Tm5jJ27FiSkpK47777CAsLY+/evWg0GioqnGFq8+bNIzw8nG3bnJ8Pn376aR577DFee+01AHbu3MnGjRuJjIz0uk+JrVu3kp+fT69evfyu57r+li1bMBqNXHvttSxYsEC+35TuU6KxsZFNmzZx7Ngx+vTpw6OPPsrmzZvZvn0748ePl18fKr9sVHFQReVXRnsEwkHHTjlDQVx6ByoNGXAtMa41hrAnOdGnc/BchUHXcdtbEhwxciRJr7wM4DxHa9aAwQCWQMWA3vEsJXbFNexEqTPROGIE+fHXUFEmYDV9g8Pq/LDVrKkihESiGk9RZwxRlBItCanQ6kSsiuuDnr5YG5fLY0t49hFU2lfQ0yHlTRgMETQ0O+zOeQsCGq2OZj/lQIrvDkHAYtBREtuVocdO4VlP3bVSJK1MWreMiFGjOJvbF3a3CipDe8fTN7I1VGTizIdbe7WJInXhNj6/vPW1cPkPTnHNNe0WkP+WSozHn15LiOjevzCnfiv5oRPaHMbvqjZhtDe2CoN+8HT+depxiZzcnJ43mIKdW6nRRikqYZ56Yin9+vZi4syH3bZHFIMWiwH0do8S36w06vaUYNX6Fty8lSU3OzRtHisp+PZ33ygtfz6fZdLnSxCUcC3xbY8wGAgBKP9xl9zTE+CbV57nzNHdXl2IqkCooqLySyY7O5uDBw8yY8YMLr/8csaPH4/D4eChhx5i48aNiKJIeXk5WVlZsvgxdOhQevfuDcCdd97JY489ht3e9vNSjx49GDRoEABDhgyRxam1a9dy1VVX0blzZwD++te/8txzraFbS5cu5b333sNsNmM2m4mLa/uD4qZNmygsLOSqq9z7Mh4+fJjBgwezYMEC7r//foYPH864ceN8Hn9UVBQ9e/bklltuYcyYMUyYMIGkpKSA89DpdEybNg2AwYMH06VLF/Lz8+nevXubfdx8880AXHrppeh0OkpLSzl79iw6nY7Ro52fR8aMGUNaWpq8TX5+Pv/4xz+oqqpCp9Nx+PBhmpqaKCwsxGw2y8IgOB1ujY2NrFmzhrKyMvn5hoYG2SH47bffsnDhQurr63E4HLJg6u88+hIHq6qquOOOOzhy5Ag6nY6qqir2799PUlISy5cvZ+vWrbLAKomrX3zxBbW1tXz22WcAWCwWUlx6ZV5//fWKRLqhQ4cqFgYBbrjhBnncO+64g1deeUUWB5XuU2LKlCmA874ODQ1l8uTJgLNX5NmzZ6mpqXFzjar8MlHFQRWVXyEBBUKPlF0dMOxgCWv6pDqlFUFon8tGECiLieBos4WepdVtBEKlPQ49iW40txEcXVOHlTrztHFxdH1hPoLeKa4kvbSAitdeo2rRG0HPSUJp6XCgkBRwCnhbajOpcLgLgxLNmiqEsCTi60qo8NWD0IuQKgmDlXF9QNAgAPrwq2WBUHKHhca4C6TS40CuJyUOqWaHHZ3dgU2nRRBFHO0Mf/BFnTGEXcmJdK4rc3s+TDokQSBi1CiSXlqA1ep+b0d49GzR6nStAuGOLUSlJAGn5OWCphlBX+mWdutKw7HZiPYQBE0zNWHux7kvoQsayylEe4ibg/CH2KFcc2aZ51BeMThaxwyLiub6x5+Vk5uleW/epyxJOj4jh0n3z2yzfcHOrcGLxYJA96xsXM/VBzGb4HLIO+juXsw7EENYs5Ywi9bN4Se7lQX311WFIGKNam53T0BwDw7xlmYslYC3d3xfVEfHYtEbMFgt7UrDBqfkfaGFwdadiRTs2ELBzm0c+H5tGxetK94EwvAQ9aOliorKL4O0tDQOHDjA2rVrWb16NQ8++CDTp0+nvLycrVu3EhoayqxZszCbA/cs9iQ0tLUiR6vVupXNuiK4fJbbuHEjr7zyCps3byYhIYGvvvqKv/3tb222EUWRzMxMNm3a5HXM3bt3s3r1aj7//HMef/xx8vPzvfan02q1bNmyhU2bNrF+/XoGDx7MBx98gCAIiubh6zjO5TxYLBauu+461q1bx4ABA6irqyM6OprmZt/tdaQwly1btrjtD+D48ePcddddbN++nfT0dPbu3cvw4cPl7fydR2/85S9/Yfz48Xz22WcIgkC/fv0C3h+iKLJw4ULGjBnjdXlEhLLvRp7r6XQ6N2E60Dxcr5HnWFqt1u9YntdReiwIAoIg+LyuKr8s1J6DKiq/Utx6EAKaWGcvMKFjRzdhUKI6yoio0ciCU7tcNqJIiMVGQWJH8pMT8ZQXlfY4dCXEYmNQwWmvb1a6CmcpsdKSXXtlJY1btsiPBb2euDvvROvlV1lwOh3LooxtjsNtDmEdFe07kLNREvAqInt6FQYlzJpK6iOTia8ztT2PHsKgLV6kuTscGDJZFgYlBEGLNmwMhigrGTcV0OsPxW2SVZOvOE2vPxSTcVOBoh6E3vrRuewQm04LDjFgL8F2IQiUR4dzJiqRBYtszH3HxsuLbHSuxk0YFPR60owhbBrUm1V5l7BpUG/SvITiaHU6+t5xE1l3/ZH0G9ydfvawai43+e6vMrzxv0T0mM/6IcfcBCiAsK4fEZ66kIge8xH0lW7LrIKOqSeWMuXUJ4wpX+22bEz5aqac+sStpDgsKprpC9/G4PqBrUXY7JHRtvegN8bfcacsDErbX/GXG+nxuzSvYnFYXBOGaAtp/QaS1n9gq0AtCKT3H0T3a6/wup8dvd3Lx3dk1LAht4pVg8rlHn+SW3nZZaVtzlugnoDV0bGUxXWmOjq2zTJXokzOEuaYBncBUCptvhDC4Fs3zeTdyf/HWzfNDDg/b4iASRPG8agxCIIWu6XwwgmDLaT2G8CP61f7FQYlBCC9qYSnInayZuZlpMaFn9O+7TYbx3Zsxa5+0VBRUbnAnDx5EkEQmDRpEvPnz0cURXbt2kWnTp0IDQ2ltLS0TQ+6zZs3c+jQIQDeeustRo4cGVQwxKhRo1ixYoXcw8+1ZLi6uprIyEhiY2OxWCy88Yb3H6+HDh1KUVGR3OsPnIKgxWKhqKiIiIgIbrjhBhYuXMiRI0doaGjwOk59fT1lZWUMGzaMxx9/nMsuu4z8/PyA87DZbLz33nsAbNu2jdOnT5OTk6P4HFx66aXYbDbWrVsHwOrVq+WyZLPZjMVikV2ICxculLfr1asXRqORDz74QH6usrKSiIgIRo4cydy5c+XnT58+zcmTJ6mtrUWv19O5c2dEUeTVV19VdB59UV1dTXJyMoIg8P3337Nnzx55mXQfST0qpbJiqaTXZDIBYDKZ+PHHHxWfL1/06NGDrVu3AlBUVMTGjRvdln/66ac0NDRgt9vlEm4lY33++ec0/ozCflQuHurPuyoqv2IkgbBhwwaM/ftTMv1PNO/b53VdSbiTSn6DdtmIYmtqMVAWHU6+R4mxBsguKWNrehdnj8MApbHRpmYGHTt1ft6oWgSiiGHDWndhtXLqgQexV1a2WV0ugY6JILGmwWeptOZoLYnzOmC31WPrJLqVEscs1qIrFQI6G2VhMDbDrzAoYdZUQmSyu4PQizAolTt35H2qv7kUa0Ni67GLdmyN/yW0g7Iv4EpLjAOiObf+jn5pEQghkX7S9fIQBiW8CYKulNSVcM2ya50PPHQYT+HKk5i0wMEn0FKG7KFzeU0RBjpYq0mwtN6noZFRbYRBCa1Ox+2zZ8L8BRw7cIBqXYxbKfEtEcVc/8ebiDKGtBFyTKYitm0fS0QmRGS6j+sqHg8c8Doh+iQ+eXoOpceOEDMwg/DfD+Tb4+6iphIk93F7ewJKApzE9A8WBHToef74cT5LiV2x6A1+HytBChFZry1icM8hlO27IPK6G7Hdktnx5afKNxBFyvfvRDxxCBIHtXu/dptNduym5w1m4syH3cRrFRUVlfPJvn37eOSRRxBFEZvNxtSpU/nzn//M5MmTyczMpEuXLm0ElaFDh/LQQw9x7NgxYmNjeffdd4PaZ1ZWFk8++STDhg0jIiKC6667Tl42btw43n//fXr16kVsbCyjR4/m1KlTbcbo0KEDX3/9NbNnz+b+++/HarXSvXt3vvjiC9avX8+LL74ou/TmzZtHdHTbMDNw9g6cPHkyjY2NCIJAz549ufXWWzEajX7nER0dzf79+8nOzsZms7F06VIiIyOpqlLmjjcYDHz00UfMmDEDu93OgAEDyM7OBpylzs888wwDBw4kLi7OrZedTqfjyy+/5O677+bZZ59Fo9EwY8YM/vznP/Of//yHWbNmkZWVhSAIhIeH88Ybb5Cdnc2NN95IZmYmsbGxcmhMoPPoi7lz5zJjxgyefvppcnJy5NJxgAULFjBz5kz69OmDXq9nwIAB/Otf/+Khhx6iubmZQYMGye69hx56iMzMTF+7UcSDDz7IlClT6NOnD5mZmW5zARgwYABjx46loqKCIUOGcN999/kca8GCBdxzzz089thjTJgwgdjY4H/MVPnlI4hiEBaei4BkHa6trSUqKuqnno6Kyq8C0WrlxD330tjyC50vfPUErIpqdglVgIkbO8kBAs4duAiDroKfh2DlKriFWGxt11AopooAAQAASURBVPex3TnjRSASrdbWnoMetDkPCudj6eag8pFWsS3uOZ2ikJSK2D7szfqT1z6A/ohu0hDSXEe5FwHTcy5Fqx6juSYZcAqDriXFrn3lfHE+Ulbbgz7MiLXJFPR2uUVn6Fzf5FUYVMKBqgNMWT4l6P0Gg5RELDGmfDUdrNVy2bBrz0DPEJIJ9z7EpUNbhW5vSELL5n0FfNRlsvz8lzOGkN3du+O1pnoPO/Ov87rMldy+n/D94m8o2LEFQ++uvJmqvCTHE880YaXrS5TFdebdyf8nP/7jp6+RWHnG7xg1umiqw+0ImmY6NpsuWClxVYcEvr7ievn5CWs+Iba6POgS44Ss/gy9cxYr9pdz9L8FdK/+5oK4B0VA6J7JNQ/ewar3F1G27wBRjcrEOWN0B+545V9eBWslyMKg5FZscaOqAqGKyi8fs9lMUVERqampbco+vWEpLqZg3FUB10tf8T8MLr3bLjRLlizhiy++8Cse/dopLi4mJyfHLdlWRUXl54G399pg9DX105aKym+A+vXrAwqD0Jpe7CkQ+nXZ+BIGwdmDsMVBmF1Sxh5pXKBZr1UkKJ4PzkkY9DiONvMSBCJGjMBhs2E79L3bWEpDUmLP/khE1TqqtMqFQYDaMAf9SuvpVl1PfJ1Jdgx6S04O77QPnfEslroumM82yCKka7/A0BiLmzusZE0XzDWG85q0qhQRSMjsh2CqobwoeBGkMD6G9LzB7RIGAcL151YaKZF7OJr8Xq2iXq8Dl7Ir7Mo2PQehbVDI1BNLsWj0bqnC4Cz57DlwSMB9SyXG5fNeBBdDYniI9/Nht9n47r33icgKfFyfP/sstaed/X+Onj0KqYG38ST3cDQx9a1z8edWvqVjM4l6B6dXdSWkRchzFeBckR77EuBqdNFthFe3E3SOeDoZXXEVCpU4HAHS+g9k0qw5NNlh0YZCGsPtTBLH073m/AqEUlfUg6YKlnzzB+gIXA7XfddVkUBoqquRg0yCFfMsZrPsQm2dkEjBzq0sWzBXFQhVVH5jGFJSSF/xP+x+Shu14eEXVRhUUVFR+bWjftJSUfkNIAbRu0kq/XVNL3b90u5ZSiyIom8HIMjCmmcaMoLQViC8AMKgNi6OrvOeB6B+7Voihg2jYcMG5cKgx3G4CYQujkSA4zP+D574PqiQFACN6CD3xy9Z26cXDkFhanLLuUpoEQXBf3JyQt8v5b+Pff0Udks6NfpDrde0LqzNNuYaZx/Bn4IyQzwJ0C5hEKA2Ioz8lESSBIH2ZKgmRyWz/PfLabQ2UlhbyCMbHmnXPFzFLwBjoxGH4D0BzxWLRu9WRiyR2m8A19z/qHKhRNDQNepKbivKx6brSoig5cjnRaTemYVW2/oqa3VtHcKwT4lY7GxUXWe0Uh/WvnAZV9FUcgNK7y36cPf3rES9g24GEUeYA3NcExUhibw1sX0CnGfas+fjc0Vp6bDnelIwkKsYb4yOYcI9D6LV6fhk0zHiqo5iDk/mmyiBCcJ4ulV/g8NW6DPqyBgdg6m2RtF8pDHiLSfcno/JSMOx40TgXrHtFPMsZjNv3/MnTLXVbReqAqGKym+Wn6PwN23aNDml95fEW2+95dZrT2LhwoUMG+a/CsGTlJSUX71rcPfu3V6v86233srMmd4/e5wPysvLvYaWXHnllcybN++C7VdFRUL9lKWi8itHtFqp/e8Xitd3AHuSE9sIfl7L7gRBTjf2S4sQ6E1wkwVCg+68C4MA9qoqTt4/G0F00LD+OyJGjqTrC/OJuOIKN4HQrzDoMl9XgTByxAjZmSZarWh0uhZB0Pf50MTG4vDoyeIA9nWPx0Gz321lXERUcIamxNeZFCcna/VWTLGD+LzfWvm569Z3wWBxl9HslvbIaueGCDRqwtgVlU2nH4PvX+dKwa7t5yQqJEcle33+2aH/YN+RrXxQ+ZXX5bd0bMb8fSccXoTV2OZGUBBK55pILCE5yJQei93uYOWb+yneX02cJgUpWadobyUr39zPWBeBsGj3Tgp2OMN6fLlEPcVipWXASnDtI2iIstD7qhNQ2rqv0JaXhSRWGpS8TnAX4Gp00Vg0eqr17snJ0mNPh6Z3BIrCupMaIUKld8HMYFUm8Luu51neL5Xxm2prOL5/D6k5/dF99x5Xl+/EFteL+pG3gEZLY/nN6A5/gv70oTZnJDl3ADUDbyR52weU5O8IOB8pKbo2wv3eeyd2A7fnDaPmQGFgB2GQYp5fYbCdY6qoqKiouDN9+nSmT5/+U0/jF0NOTg67d+++6PtNSEj4SfaroiKhfsJSUfkVI1qtnLznXhq//z7wyi1URBkpi1GgXkgEEgYDrdciEEY3msk+z8IgAKLoVlLdsG4dJ2fOImnBi5x64EEa1qxRJgy6zFcSCH/ncFCwcxsp2f04M/sBGtavb7O6A+c5ja8zEXn55QA0fved23LF+245nsTaRrJLyiiPMnKyQ6Tcc7CPqTTw9oDOeBZR536mrToHlroQucT4pyglBmgWwvhP0s3YNBoSOvWn/MddQaVbu3GeRAXPEuP933zDobL90Mv7+ol6Bw6DiNlow27RerhuzUw1LZVFKtdS4puNBSTqmqk4sMddpGpH7zW73cGqxas4ffwM+vBQtzAaxLYCYWpOf9LzBrul03qKw56PlQaIKEFqVWCIstAhWSBeL/JopybMolMYjNe73wNhmBWNKwlwnqXErniWc/sTCEvCk/kmfgyRoToe77aDkvztIIqysKa3aehQW8X0DxYE1XPQM/BHehzdNZTobhqWv/4I5T860zF1lYfptnYpty34B4YQA3Zbf7568VkKd26Tt0/rP5BT/abw4srD3OUI3LPTr9CrgXfiNzhLjD36PXpF4etOkTAY5JgqKioqKioqKirtQw0kUVH5lSIJgw0Keg260h6xSrFAGGCcC+Ec9EX45ZfLAmHB9s3sTO3sttxbiZ8n0Y1masND6awLoe/OA23KV10DWOLNNoZ27IJ1yxZZfDkXYXB3ciLlMRGt518U0Tvq6G6rwBAjEvJH76XkFVYBswhlVg3vn20NlRmWH0tMo0cC9UVGBARtChXGTD7t2JXP7/odhR/9002wahdBimsmUxE2eyM6bThGo7OZXkldCUeqDjPr+/sDbv/XODO9wlqFM19hLuWGOD7q2iocfTljCFldonyGMhyvaaax2f26Ouw2Kg/uoeMlmTQWHWLw8N+BoGHV4lUY0lpDOgq+ecZdIAQQILVvnCwQtgmEwP/rIFjn4MzcmSzIXyA/9kw9VxqOI7Hmm2HYmvQUxaez4fJx8vPeBDjPc+2LW2qW0kVb6vN1XxjWnf8ljkPUaJk9ugedt3/AnsOb3c6Dq4AWKCxFOr/eSrjtVg1p407Kz3neRxGxvV0EQpssEKb1H8io/3uQYc+vZVjJ16Q2lQT0WXqGTvni+t2XEN7SazIgfl53dpuND5940L3HoEKueeBxeuS1PxFZRUXl4hNsIImKioqKSvCogSQqKiptaK8wCL5DSbzvyE8YSbAIAmUxEVRU15NYF3w6bbA0fved7CC03T+b/aWFNBucb4m+SvxkWo671ugU185YzTg8wkrchD+gIkTLltOF5Iqie3Jze4XBlnGlbevCbXw+ogZwihKPWu1t3FYVVoF/lHrvIbght9XFpMgddAEQAOzFxNcXc2tzGmG6YUyc+XAbwSpognAdmUxFbN7S6iQbMng1RmMqScaufP32y86QhgAYte7z9HSFSXiWDtc12+UQkWUL5lKwY4ubMDhy/nq39TWinXHlq0g3FdOgCSPC0UTxpnXEdLiGMyfPkJrmsq7Oi9PO00Houu+W8+3PPerai/RMRzM7MmrarDMpfRKjuo+iR0wPGq2NkN+6LKZBT2xdCNLZKo1MIIPW190be/+IgMidfd+Tn9u2sS+rNFdwdWctn2g7010oJrnGXaDM7pyI9dhet/vFW5m2NzImFJAYXgF4F3VTm44zrnwVKxLG8Ob3BdzfXNvGQelWIu1RYuyvlNgVV6FQwvM+aqg6yOKZj8oC4aRZcyjavZPUnP4s2lBM/NljpDWVKDjqtqFTvrDXNCC9xwREFCnYsYWi3TvdxDxJhC4tOKpsHBfS8waTmtM/6O1UVFRUVFRUVFT8czEMOioqKhcROYnXS4mrUiSBMLG20bcg0yJWXX6wxP96ShFFEmsaiL8IwqBE43ffcfy+mc4eiy3CIKLos8RPWt5GEHUpNXYQOPHY5m15AEKsdvq0iLblXrbzFCjMXi6Ht+e8EUy5qCHKQlhcE4YohUEqCjFaCln7zLPY7Q4mznyY9P6Dzk2AdhEq/GFprnN7bLM3ymJG2d4fFe0q1GOavno3RttqGVGxHkF03l9T395GUWWjLNJd88Djspjp6RiUhME0UzEA4Y4mAM6WbOLEkZcxRJ5yWz8k6gwhMSXoI8rcJyFC0Z5Kju93isPSvpWe7yiTU+DrfNa7E+Tm3jdzRfcrSI5KblOeLQlS5fGx7OyZQ2H3dLflAiKih+dtpWY0RQ2pvF2SiijC8Kof6GJyP6ax/29am/nH2GqZemIpU059wphy916WY8pXM+XUJ0xveEcWBsG7qCsA6aZikk3HiWncyaGq/dR49OiribBSFdVMndEqlxj/8dPX2oSj+BKNfREa0/a1JgmElmYLWp2O1Jz+HNy+jTfXHaRX/WGUvitLQu/EjZ3ov7eb27L+e7sxcWMnXuj+JLGJ/YNqJeEp5nlzpypBRMQQFcn4u2cHXVJssth4Z2MRJovyYC4VFZWfnpoyExXH633+V1N28T4vqqioqPwWUJ2DKiq/Mnwl8QaLXwehRwmwYqehLy5ySTE4BbzyKCMnSw5TXusUUlpL/NzL5kJjnF/G7RYNQqXWZ7hKWXQ4u5KdpZveBDxpna09ulIbHlxZTbNBx9YeXak3hriNK/U68xQojq7qSGRdLfpYkfCxThHCU7TyhVIXUUCH5Tni6ozy5iA0GMOxmBoVj5fabwAOux27zdZGYDCZirA017Hx85cIS3WZQ90R1v/7LU4cOUCUySA75WoirGzIaRV6xp0xkplTJffHc0/2dZ4Tkda4GREoCkvm+7hhiIIWjWgn2XScetNgIBytTuezdNJVGJTGE3C9HgXABrdtugx+W/7brcS4pbS4e1asvNybgxDAGN0BU12NV1HH1z3jKggmRyXz8YQvuOHN9ZiaBDZENNAhoZoZY9/1uq2rY1DC5DCiEe10rjrK5Wd/wOhoQqhtknv8GawWDu7oydi/3sfnz/3NrWzVVy/BBEM5XcJKCY12F7hbX/fu17DUkMDpqBAMl3zMMi/jud4X163v0iYtWSLYwB9XN6Hra62h6iD/+r97uPWF51n95isU7NjCHzRhznMTxPiSW/is3uj2fEhTOL07x3PEnsVLop67k0UcJfv9i3s+Sopdg2+CQUDAUl/PNwvnB91zcPEPxcxbeRizzc6MET2C3reKisrFp6bMxH+eCPxecfNTg4lJNAZc72Lw1VdfsW7dOhYsWBB4ZRcaGhqIjIwkUKev4uJicnJyftZJwadPn2bKlCls2LAh8Moe5OXlMX/+fEaMGHH+J6aiiCeffJKamhpeeumlcx5r/PjxLFiwgF69fDToVvlZooqDKiq/MiKGDXMm8a5de85uPq/CnxchT1pvlw9Xm19EkYRghUG9HqzKygS94QDnXKWefSgv8TvwQRrU+XjrFIQ25b7e1qk1hhBisSkvxxZF9Fa7V2HQV8+3r7Kb+AqnePCotYl4vUi8XuSmPR1pqDe0Ebfa03PQr8Oy5VjDIqNoqqttd29KT4Hwqxefo3DnVtL6D2LCPQ/wzcL5il1IpceOUrRrO+l5g90EBtdSYldhEODg4QcIz4CMDKcgE+VD/IyoCqGboXUOnsm+4J5DXRyWzP8Sx+JoEQal8uA9/64g85HHfYof3oRBCaVONLnE2KPnoNtYnuXNeYMZf/dsn+dbLjHWG7BHjybMEUNaz84khbu70LYe1lBf1wmtIHA8EsTIE4rm/MbeP1Jc153KxljGla4g3XzcTWx1FeAKdlSxZNZfMdVWOwVNj8ALzxJj11JiVzzFuOY6A82Cgc6WcsZXfsXqSwLP258L11IfIwcAefYcDITntTbXn+Rff70dh8P5w4bkJA0GKc25UQhxe75R6MAJexT/+e4YDkHLkpBhPJ4bJoextMFPr0FvwTeKEfFapuyPhmYbi75zvq8vWl/AH4ekEBGifvRVUfm5Y21W9u+Z0vUuBpMmTWLSpEk/9TR+Urp06dIuYVDFic1mQ/cLD9xyOJyfe7755pufeCYq7UEtK1ZR+ZUh6PUkvbSAiFGjzktQiFuJMfh0+GmApOr64PcpCCRV1wf3ZuQiDAYrf9qAzeld2oh4SoUVrSFAya0gKEo8btZrCbHaA39BFkUMVjtWL0Ki0vJf13LiyPoQYutCiGlwFwBTS23E1hr8C4OiSHxtIxEtpcSSs0rCrexREEjvN4CrdNH0Ky4lvuX+aY9gLZdOWmwYwq9GH34NhvCr0eoNQZXANtXVAE6BYdmCudhtzjJDz1JiX7jeI55OOa3ZI3DBjytMxClQQ9vy4PIfd7nNzRV/wmCgfbrisIX6FQYlPMubDaGhfs93lElPbK1IpzOFxDV0oX63jk9ezmfv8Rr2n6pl/6lausSEccvg7tw0qBs3DuzG6MwURXN2FQbTzMcB/LriJEHQVFeDMboDAKm5eRijY9xKjD1LiX2hNdgRgFDRec9HWpSV0ftyVGr06egjb8XS0I2myjDMNcE5br1da4fd3O4fhKQ054+6Xs+GyEk0HJtNY9HdNBybzcbIa3jTPoxGKwiinTqLSFneFO/3QYDwn2YHVA28keScvOAn6aVMORD/3lRMQ0tJfn2zjXc3Fwe/XxUVlV8tTU1NTJkyhYyMDLKzsxkzZgylpaWMHDmS/v37k5mZyV133SULHkuWLGHUqFFMmjSJjIwMhg8fTnFxsbzs2muvBWD9+vVkZWUxY8YMsrOzyczMZMeOHfJ+33jjDXr27Elubm4bp+HNN99MXl4effv2ZcKECZSWeg+L2r59O6NGjSIvL4/c3Fw++eQTACoqKhgzZgx9+vShb9++3HbbbX7PwTPPPEPv3r3JyckhJyeHkpISv/MoLi4mJiaG2bNn07dvXzIzM1m9erXbMglBEHj22WcZOHAgqampLF68WF62adMmcnJyyMrK4rbbbsPm8rnnxRdfZMCAAeTk5DBgwAA2b94sLzt48CBjx46lb9++9O3bl0WLFgFQWlrKDTfcwMCBA+nTpw+PPfaYvM3s2bPl8YYPH87hw4cDnkdfrFmzhiFDhpCbm0tmZiZvv91amVFbW8v06dPJysoiOzub22+/HQCr1crDDz/MwIEDycnJ4YYbbqC62vk5Zdq0adx+++0MHz6crKwsn/vdsmUL/fv3l8/ZP//5TwCWLl3KoEGDyM3NJTs7m2XLWmsaTp06xeTJk+V74fHHH/c7T4AzZ84wceJEMjIyGDVqFGfPngVg3759XHbZZfTr14+MjAyeeeYZeZsnn3ySP/zhD4wdO5asrCzOnDlDSkoKu3fvBmDEiBHMnj2bYcOGkZ6ezl/+8hd522nTprk5FWfPns2TTz4pj3vDDTcwceJELrnkEq6++mr279/P2LFjueSSS7jpppvk16bK+eGXLU2rqKh4RRIIT94387w6CCuq64mvM/kU8hLqTCTUNCh3D7aITQkXqc+gDVjfOxmLoe1bn1JhJdhSQJ8IAs0GHdENTc4SY2/nSxSJajRTF+E9RERp+e/Jr7tjcghu5ZGe2xpsAh3rG9tcu9a0Wg0xx61oO1jpcdNxr/txdT417L2WnCNlmNavp1OLO7S8up6THSIpj47wr+x4oaHqIIvvexSHZhxaQzrF+6vlII32hJZIAuH4u2fz3XvvE+H785iM67V3DePQ2zSEmfSyC8xfwjU4Dz2tqYSrylYitvwtn46W3ogfPvEg1z/+LIaWpDGH3eZXGASw1Bl8OtFObr4Va303HLZQrI2JfoVBu80mB1t4ljdrdTrG3z2bt+65g6Za72W6DmsB1sbl6MOvpvJIDe+88D3LY0pxCCDaQ1h772RS46Ry4z6YTKs5fKaMuctWtAkfWakZjclhdAqDZ/5HWvMJt+MPmCouipjqaojp3IWr7poNwKI/T5VLjA3NykQ+u0Xr5lSMdrn+bVy4HinMnmj06eiMV2Ft/AYcZfL4rhzf8CdE2zaSR+6Rn/NWqn6+sGjc5yla4xC9mLM7m0s5HdaVV9YV8t399wEveU3W9uV8XfxDMS+sOMBdYnDORhGRxD6ZXPGXG2lsOuSWJO4LyTUovSWIouoeVFFRcWfFihXU1NRw4MABAM6ePYvRaGTZsmVERERgt9u55ppr+Pjjj7nxxhsB+OGHH9i9eze9e/fm+eef584772TVqlVtxj506BBvv/02r7/+OosWLeLRRx9l5cqV7N+/nyeeeIL8/Hw6d+7MnDlz3LZ76aWXiI+PB2Du3Lk8+eSTsgAmUVNTw5133sk333xD586dqayspF+/fgwdOpSPP/6Y1NRUeU6SuOON6upq5s+fz5kzZwgLC8NkMqHRaALOo7a2lt69ezN//ny2bNnCpEmTKCjwXn0TEhLCtm3bOHToEAMGDGDq1Kk4HA6mTJnC4sWLGT16NKtWrWLJkiXyNlOnTmXWrFmAUxSbNm0ahw4dwmazcc011/DUU09x0003AVBZWQnArbfeypw5c7j88sux2WxcffXVfPLJJ1x//fU89NBDzJ8/H4APP/yQe++9V772vs5j165dvR5Pv3792LhxI1qtlrNnz5Kbm8vYsWNJSkrivvvuIywsjL1796LRaKiocP74OG/ePMLDw9m2bRsATz/9NI899hivvfYaADt37mTjxo1ERkb6vFbPPfccs2fPlo9bEhfHjh3LTTfdhCAIFBcXM3jwYEpKSggJCeGWW25hzJgxfPrppwDyfHzNE2Dr1q3s3LmT2NhYbrzxRt544w0eeeQRUlJSWLNmDSEhITQ1NTF06FBGjx7N4MGDAdi8eTP5+fkkJiZ6nX9BQQHr1q3DarWSkZHB5s2bGTJkiM/jldixYwc7d+4kJiaGESNGMH36dL799lvCwsLIy8vjf//7HxMmTAg4jooy1E9HKiq/UhQJhB06QHV12+e9oIGAKcIaoJ9UhhwToWCSAsI5uhuVbm0DvuudjEXvXdzzJ6yUrOmC7rRIrS4MS51B7vMXTAluG1zSh/f46OuYUNvodEb6KMmNUihQhJn0eH4V9xS3bFo9SdVnEECei2epddmbnajpGIr3f/bdcZQm0LD+PTQt950G6FRnIqHOxK4Ul/LrIGiqPYw+/FK0hvQ2SbvtFQjfvudPmGqrMezzfu13rc6kvj4cncVOuMf973ntgxFsJIHQVXBypfTYEd6+50/c8cq/MISGUnlwD+kt7kJ/+JqDqfRH7JYhCBptQGHQtZTYU+ix22wse+k5n8KghKtA2KPZyLUWE99eshiHxsGx6v6kxrWqsUZjKvrQjpQ1uIfFRJXVkWE6yKr40YwrW+FVGAzU87I6OhaL3kC1qZkls/5C594JhMTUyQJboNe9JMY11xnkvo6SGOmrxFxKYW6DIKBLySKl83UUbH8P0VYoL3Kdh9aYgCDEIAgNbpt7K1U/XyhNcz4T2gmAZpuDB//7I4u9JGv7EgYbmm28sf4I48pX4fAjcnsiInI8sYnRfxzFtu1j5eelJHFvmCw27v73DhrM7g7c+mYb93yQz6v/Lxejlx+JVFRUfltkZ2dz8OBBZsyYweWXX8748eNxOBw89NBDbNy4EVEUKS8vJysrSxYHhw4dSu/evQG48847eeyxx7Db21af9OjRg0GDnD+uDRkyRBan1q5dy1VXXUXnzp0B+Otf/8pzzz0nb7d06VLee+89zGYzZrOZuLi4NmNv2rSJwsJCrrrqKrfnDx8+zODBg1mwYAH3338/w4cPZ9y4cT6PPyoqip49e8oi0oQJE0hKSgo4D51Ox7Rp0wAYPHgwXbp0IT8/n+7du7fZx8033wzApZdeik6no7S0lLNnz6LT6Rg92tnSZcyYMaSlpcnb5Ofn849//IOqqip0Oh2HDx+mqamJwsJCzGazLJABxMXF0djYyJo1aygraw0oa2hokB2C3377LQsXLqS+vh6HwyELpv7Ooy9xsKqqijvuuIMjR46g0+moqqpi//79JCUlsXz5crZu3SoLrJK4+sUXX1BbW8tnn30GgMViISUlRR7z+uuv9ysMAowcOZKnn36ao0ePMmrUKC677DIAioqKuPnmmzl58iQ6nY6zZ89SVFREUlISGzduZOXKlfIY0nx8zRNg3LhxxMY6+1APGTKEffv2AU6X7YwZM9i9ezcajYYTJ06we/duWRwcP368T2EQYMqUKeh0OnQ6HTk5ORQUFCgSB8eMGUOHDs4KkH79+hESEiKfq9zcXI4ePRpwDBXlqJ+MVFR+xfgTCMNHjiTphfmcvH82jevWnbd9agSBYemZ5KckUrDLR08qF8qjw8lP6URucen573PQ0ptQEgYD9fjzJaxE1jRzyeZ6tqd3oTLewucjzsjLrlvfxV0kko7Xn+jZknicXVKGDu99HRNaynArArgwfYmTmUnZmLcX+j3/8raiSGJtg9P5WWeS5+JZal3TMRS7VZlzssKahKX3HWQdeAuN2Gr51wD9ikspi47gYPdMzJpKReMBCLo0NPqU1ie8CIRfvvAPinZtVzymVH7q7dqXNcbzmuPPEA6Ew9SGpT5DLZTgKipHtpz7QKWxkkAY1zubAmOKX+egK55ONF1YKQ77h6Rk3hVYGNy5FYCCnVtZtmCuLPjYbTa+nP8Mxfn+E58lXAXC1Oq+dKvJoKTjfsy2tj8yOOw2BpbvcH/OoiXNVMzU4+8TLpoD9lj0fFwdHctbN82UH/912fNckv0lvbKdjyUx0dfr3lWMcw98cd/e04Xr09EbGsk/bf3509HFYG3rvrXUGTBEWej1h23AtjbLz5tr2QtSqbVFo6da34FVCaPlZVeWr8akDWNTx8GIQuscvj9SSaXJxsSZD7s5TX2xZEMBw45/Q6qfe9iZTy24PT6e2MT63AruwD0oymb3HkYk2h289M/trDvT1i0jirD2UDlvfF/IzNEKmkaqqKj8qklLS+PAgQOsXbuW1atX8+CDDzJ9+nTKy8vZunUroaGhzJo1C7PZHPTYoaGtwXNardatbNYV1x/JN27cyCuvvMLmzZtJSEjgq6++4m9/+1ubbURRJDMzk02bNnkdc/fu3axevZrPP/+cxx9/nPz8fLTatv+GaLVatmzZwqZNm1i/fj2DBw/mgw8+QBAERfPwdRznch4sFgvXXXcd69atY8CAAdTV1REdHU1zc7PX7QA5zGXLli1u+wM4fvw4d911F9u3byc9PZ29e/cyfPhweTt/59Ebf/nLXxg/fjyfffYZgiDQr1+/gPeHKIosXLiQMWPGeF0eERHYUHHfffdxzTXXsHr1aubMmUNWVhavv/46N954I3PnzmXy5MkAdOzYsV33q4Sv6zVnzhzi4uLIz89Hp9Nx3XXXue0n0DH4Glen07mJ62az2W0sz+2U3k8q7UPtOaii8ivHrQchEDFyJF0XvkK3V15GYzTS7ZWXibjiivO2v4hRo+j+8ktMnDWHtNwBirYpaxEIz3vXiCCEQVc8v4R3/EMVB3I6UhsRhtOD6LIL175/LaJeQm1jwCTPZr2WPcmJOPDe1zGput4ZmKJwzp6CxFW33aO4F19inUnuI6kB+phK6Rpa3banYAena+rYsm4c/iyFkjVd3JaXrOnC4c9SOPTpCCwNCVTG9WF/xnQcgvvcNEDn2gaG799OqKPtL+JB4SIQWpotlB47t18QXa+92e7u/vIsvQwGKTxm2WWlfD7iNHVGqyKRTxIIw3SwImEMhcYURX02JSda4UrnL99p405y6eT12GxLQWz7SnMTBl3qMCWB0G6zcXTbZoryd7TZ1h8OawE2yzGKOuzlRMwBr+vYbTb2v7eQhLIKDnyQzuHPUmThTYA2wqBBSc9LwKJ3F/1sYe7ClaeY6Pm693zsS4yUXLgTN3Zq+2OBK011TD25FCq8l+V720fhiiS383G+kM6hdK7AKRAmWCrpYHV3k0fYGtjaYaCbMCjxwKd75NJzf8JgbaOZIx+86lcYlBBb7nBJGNw/oIyuIQ60NvfekKbGAurq92MyFbk9f/Kzoyz2Igy6smh9gdyLUEVF5bfLyZMnEQSBSZMmMX/+fERRZNeuXXTq1InQ0FBKS0vb9KDbvHkzhw4dAuCtt95i5MiRXoU3X4waNYoVK1bIPfxcS4arq6uJjIwkNjYWi8XCG2+84XWMoUOHUlRUJPf6A6cgaLFYKCoqIiIightuuIGFCxdy5MgRGhoavI5TX19PWVkZw4YN4/HHH+eyyy4jPz8/4DxsNhvvvedsA7Jt2zZOnz5NTk6O4nNw6aWXYrPZWNdiTli9erVclmw2m7FYLLILceHChfJ2vXr1wmg08sEHH8jPVVZWEhERwciRI5k7d678/OnTpzl58iS1tbXo9Xo6d+6MKIq8+uqris6jL6qrq0lOTkYQBL7//nv27Glt/yHdR1IfPKlc99prr2XBggWYTM4fR00mEz/++KPi8wVON2Nqaip/+tOfmDNnDlu2bJHnk5rqdNG///77crlxREQEw4cP54UXXpDHkObja57+qK6uJikpSXZyfvvtt0HN3xc9evSQy62rqqrUIJOfGNU5qKLyG0ASCBs2bCBi2DAEvb7NspP3zaRhzRo0sbE4qqr8jOab8JEjSXppgXN8my2ovnJlF8BB6AC29uhKc5DlY5Y6A4Uru5I29pT8XFFnHQ0NzdSEuwsrNRHOcjy9VaDnGQu5Jc6ShnxvpcKuCILzmJMTZWHOta8jQGJNg/8xXJAECk2MkZvn/H+kdUwnOVCprSCQnpPHpctXy4KTLV6k8ikr8ZS1Wd0zvdUzRKHVaVWGRt/Sc65FIPR0EALoRAfD92/n+6wBihyEoq1QdqIJrkKFCIV7yii693XM9TUBx/GHpc7ADx/1x2bQUumIA5cqj2q9s6zB4LAG7SD0DI+xKQyTAadAuO21f/DtrCdobP4de/79CuU/7groyrXUGdqITaeO5LdxAxbs3MaP61dT6C19tkUg/HL+M5QVHlM8Z1ca2crqHvk4NL5FyTP7diLg3cHpr5TYFen+LKUzP67oSpUhwW15badYikglDDOdOCOLi95KjF37+kmlxN7ESGl7XyXGrtjQECJ6/8Lhax9avYP257J7J1A5tmeJcbjdxNjy1fwvcQwOD4Hw+yOVlNWZSYxyd2q4YrfZeOfvT9G9oSjgPwmursGEPpmMvvUKqo7OAKCs6Fm3dX88MEv+WyoxtlU18c6u4wHPWbPNwb82qO5BFZXfOvv27eORRx5BFEVsNhtTp07lz3/+M5MnTyYzM5MuXbrIpa8SQ4cO5aGHHuLYsWPExsby7rvvBrXPrKwsnnzySYYNG0ZERATXXXedvGzcuHG8//779OrVi9jYWEaPHs2pU6fajNGhQwe+/vprZs+ezf3334/VaqV79+588cUXrF+/nhdffFF2Vc2bN4/o6Givc6mtrWXy5Mk0NjYiCAI9e/bk1ltvxWg0+p1HdHQ0+/fvJzs7G5vNxtKlS4mMjKRK4fcHg8HARx99xIwZM7Db7QwYMIDsbKetPyoqimeeeYaBAwcSFxcnl3OD02X25Zdfcvfdd/Pss8+i0WiYMWMGf/7zn/nPf/7DrFmzyMrKQhAEwsPDeeONN8jOzubGG28kMzOT2NhYOTQm0Hn0xdy5c5kxYwZPP/00OTk5cuk4wIIFC5g5cyZ9+vRBr9czYMAA/vWvf/HQQw/R3NzMoEGDZIfkQw89RGZmpqLzBfDqq6+ydu1aDAYDWq1WFv1efvllJk+eTExMDKNGjXIr7X7vvfe4++67yczMRK/Xy/0afc3TH4899hhTp07l3//+N+np6YxqMZ2cK3feeSeTJ0+md+/epKWlyWXKKj8NgigqbM50kZCsw7W1tURFRf3U01FR+U0gWq3Ur1sHgkDE737Hqftn0xBkqXH4yJF0e+VlWXg8tmMrX857Oui59C8ulR1054ID2JWcqDwcpQVDlIXQDs2EdjTTZaBTsKqwCvyjNHCvrwWLbHRtMd0odiy29B70lgDtAPJTOjkFwiAwRsdwxytvYQgN9e4IayGtXx79SiowrV0rP2fp5qDykcCOmsIVSSCIbgKqp8ig0afLQl6ffYuIr9rndSyboFEsEHqOCyCKdqyNy3FYvYtGwSCltgZi6gllJcZSKXGwoRVtEARiBmYw6JZbMOqM7H37A7/9FV3FprZ99ELo3DOHCX95hq9feZ7CnW1LWM8nrqWhogaeHfg2E3sPpKCslk1vvqhI6JQIi2ui1x+KfS4vpTP3C6/6XC7xgngXnWhtD+DLmedPjHRFibPPV3/J87kPJXiew8OfpbTpZViji8ai0ctCuAgUGVNYGT+abk0nKTF2l4XCKy5N4O1p3l3iRZWNHNq6iQPvvhz0PCfOmkOnjCi2b78m4LoDBnxJVGQWZ1YWcfm6A3hKsFrAsyNYqE7DjsevVMNJVFQuAmazmaKiIlJTU9uUfXqjpszEf57YEnC9m58aTEyi8XxMURFLlizhiy++8Cse/dopLi4mJyeHmpqan3oqKioqHnh7rw1GX1M/Eamo/MYRrVbZNRhxxRVEjhhB0isvc/KeexULhJ7CIEBqTn/S8wYrD4gQBNL7DSA1tgzT2rWEjxyJADSsX9+utOXyKKOzLDcIfH1JNyvcfXPL93YHsCc5UVkpsxcHoYQGyC0udQqEUUbFIqeptoa375kuC4S+wjrM+36kYeeP7qKkWdk+0sadlP8uXJGEuTqkjXDhsBZgbVhGZ3MysWe9l084gKrIUC7bv52NCgVC1152gqDFYS0+L8IgKC8d9lxPo9Ph8Oh7IpUSe8NVKPRbiiqNFWZhSew38D9nucWXd3wB4PX1pcRdB0V8Nq+W0/vPeF3vfCIg0LNJS3RhFD9cUuPce2Uj0595j6vLlfUvlAjUd6+JwF86va3n6bAM9Hx71vP1yjqf+/CHEgek9Br2FL4FINVUzNQT/yHC0USBMYUVCU4n4aaCCg5WFNI7Ps1tm6LKRkbOX49GtDMuiH6ZUupxev+BNFtOKDo2ndb5A8p/CsrbCIMAsQiUexTkm20O3t1czIwRPfyObbLY+HDbCW4c2E0NMVFRuUjEJBq5+anBWJt9v+/pQ7QXVRhUUVFR+bWjfspRUfkNIwuDLc6xhrVrOXnfTJJeWuAmEGrj4rBXehdtvAmDAFqdzilKvfgsBYGcSS1fBifOfBiNKMrlz4BbmIoDqIgyEl9nClh6nFBnCqosF3x/+Q5VaDwMa/lWWhFlVJbWLCEIlMVEUFFd3yYRWgNkF5eyXkpaPgeB8KsXnqVwV+u1OG0xYe+eIIuSDmCfsRPVH+jRGhw+01v1EVY3x6C1UefT0eSwFZJ4cjMa0dF6/eqbiBwxAlEU2VB8iLLocBJqGoioL8EcFa6oHN1VINQYUogI7U1D1UFF58YfSlNbPddz2Gxo9AbsVos8fc9SYl8oWc9zncLqGtKm/JV6s5Xy/TsRtDpEu1OcVCoiVZcWAhcm/dYVp1hZSAYwAjA1n6KxuRclxu5BhaxA4FTxM7ZY8B3MKBOGe7NuX6Kj0hCQcwkLuRj7UCYY+3cnCkC4w5l7nmYqZlz5KlYkjKHJKnDNuy/y7Z8eIDkqWV6/saWnn0PQsiJhDOPKVwW+1i7/Fmh1Ooy6VAp4h/c3H6RzeCl39n1PXjUz40WM4enotOEYjak0NNtYctp7r0FPYVBi0foC/jgkxa97cPEPxcxbeRizzR5QSFRRUTl//ByFv2nTpskpvb8k3nrrLbdeexILFy5kWMvnbaWkpKT86l2Du3fv9nqdb731VmbOnNl2g/NEeXm519CSK6+8knnz5l2w/aqoSKjioIrKbxQ3YdAlgMBVIOz6wnwq33yT2Ntu4/ScR1vXFQQiRowg+rrfEzliRBthUEIjiuQWl9FQ2+jX+Zbeb4D8ZRAg0qWPhdQPsW7NGvIv6U5ZmJ7EmgavZbhu+8ZLCrAfDFEW9BHehaF4vcijnZowi1Bm1fD+2dagimH5saSV2sgpqaJzS0lxfLDCZEtpcbyHMChRFWXE0g7Hiqm2hk+ensONTz3vfMJzKi6uxeySMvZI56rO+5ztVucZ1+rcv2h7cx5JpOXk0fnUGuw0OK9FTARdDGFc9/z/x//+uYCyaqczKNjyb3AKhA5bMT3yBjHyj0+x+L47aaqrCWoMT/ylto4pX00Ha7XPnoMOqwU7GrQ4EACdr9RaD/yt51qW7MpfPvofDksCgj2Z7gnxnArtwjWly0i0VFwUsSkYPMXKs6u/JvmG4cGJRi74Sxc2VjYy/YMFWPQGqjok8PUV18vLb9j/b/pm7pN7Dkpit7f71nVf/sTIQNsrPZ4LvY/z5U4UXP7vKhBaqkZQ0VhPso9qFUXX2kMYBGhotvHKd2Yamru1Wd0Ynk5UZJb8+N+bimm0BRdrVd9sa+MeNJmKsNkb0WnDcWi7seg7p6i6aH0Bk/snsXzPGdVFqKKi8oti+vTpTJ8+/aeexi+GnJwcdu/efdH3m5CQ8JPsV0VFQv1ko6LyK0a0Wr2GkHgVBuWFToHwxD33Ost6162jcdNmuv/rTadAuGYNEaNGtQaP+Nn3yftmYlq3jlxR9C7SiaIzKbe4DI2P0mFBr6fz/HlsfeJhyo4Xgii6leHqYmOxVVV5dRQqFQiV9PyK14sUrkjCZNFAbquLMqZRjyBGoLM3oY0zYq+qcoqix8vZm5fJaavZf1l0S8KxP7Ezvs5EQk1DuwS00mNHKNi5jQPfr6Vw1/a2K7QIhN76I3qKR66lxK74ch6l9RtAv5JyGiorW68BcNpq5p37Z2CqdUlFFYTW86TwGDX6dNL75TH69kv5+qW55ywMSvjqJdjBWk2CxX/ZsxYHdgR0iES3hMT47DnYaKBcn4TWXI9IUxvBxF9ZcljXj+S/i4/NRrDoaNQ6XRYXQ2xSgq8yVnv1YQ58+gSdwnIpberULoEQvKcLi0CH2iqvPrHo0ipSM1uTbVsDdHyTkpNHyb7dWOra9uFUsr1S/Ame7dqHJgFBE45ocx7vhRCMJYHwqrKV/C9xLKv315PX2ff6fgVCQSAldwBVA2+k2QGSX+jfm4rlVGHP9HCplBicIuKi7woUJXm7Iorw5roCRkRE0is3nubmEjZvaf1BoIB35P3XN9uY/fEevj9aqboIVVRUVFRUVH51nK9QUBUVlZ8Zkjh3csb/cfK+mYhWq9vzXoVBeWORxnXr5J6D5r17KZhwNV2e/QdJr7+mWBiU9iGJdIm1jW4uxcTaRnKLSzGtXUvxzbfgMLV1ztltNpYvnEdJSYGbeFQWHc7evCwMmRnkJyeyM7Uz+cmJePpGNEB2SRkhVrvP41XqqrE26qDW/Uu83iqQWNtIat5geqxaSUSL6zFq1Ciuf/Nd0nLyFI3tDw3Qr6SMeNfzp5C0fgP58bvV/ns/CoLX/oiSyHT4sxQKV3ZVtD/pXMrC4Lp1bcVZUXQXBl3moRjBSM9BU7lyeiabP1vqVi59vvAsHVZSciwAOheJIsqkJ7YuhJgG99dLTIOe2FoDl1aWU66Pw+7ln2OlZcmCtplk03HSm0pkwcVS5xSVfCVKByUMCgJp/QaS1n+g4mskCe69/lDsJk6CU0yOz/kf/xj2LAnGclk0KjSmBCXuuN6fkijt6mwzWN1FSV2Tu8AXSAhLyclDo9HI5drexEhf1BmtVEU1U2cMLms4mH20RaR7aBWhunBwlAMCgs7ZB9D1XJWs6eK21clDd3D4v3nyOTREWQiLa8IQ5T1Z2RUBSG0qYXz1h2R0Ctyv0/u1djoGz/SfwtP/O8ySTcWAU/D75/rWH23KTQk8svExntr8AM9sexKHttVN+OmOE9SbbWgFAZ1GQIfz1+9AH3I1Ioyo0rDurR9Z+eZ+LJYGt+X/3XXE9Z8svj/q/HFg0foCWTRUUVFRUVFRUfk1oDoHVVQuMr7cfOdzW1+9BLvOe55TDzzoXxj0gb2ykoIJV9Nj1cqA827YsIGGNWvcnnNz8cVEtEnoNe/dS8m020j5z/vy+HabzXfPQkHgtLWJryvqaW5xpHkL9lASDhKMqybKxQ2mtwr0LLUyLC2D7i+/hKDXk/TSAvka2W02mvbvk0uxvSIIlPsIJHFFOn9reydjU9h7MLVfHgg4HYOBrreP8SQRKZhzlJqT1yoMdk8Iqu+j4vVEExbT1yxb8BXF+buUbRMkriXGvkqJlaL3KB2WHgtAarP30AXPbXwh2kMoMXby2r/v3MQmJ1KpJ+Az+doTpYJ7qLYZ8O4q85Xu64o/kbNDbZVcYmywWoiorZMdlUqck2WFx2iqb73mro5Mf9t7Oj6VBM4Euw9vJIdWodFpMJudae+irRC0qTh9eCafYx0rPES9/Y8kN63CEHXQzUWtJCFZAFJqa6n96mPsvXPkkmBfuF7rdFMx1qTejJwxm8vmfQe09gF0dQ1KlJsS5L9dy4HzUjpyy+Du7vsx26k4Xc/Os42ctbW9HzUiTGo00MOmRR9RxunjJWxZ3oDeRTuN1p+ie6Qdsz2ECqsGQduMaA+hvjlOUZiJioqKioqKisovBUEU2xEDegEJJmpZReWXhmcycNd5z9O4ZYsiodBzW1/uPZ/OQEEgtE8fzHv3ntMxaOPi6LFqJRqj70bR/tyJfkNFBEEuWXYIgrIwE0/hTXIktghtZVFGdqb6qXVrwbUE0tXpdGZbHE3VIZjPhrb5khxisTGhUxopXgJZbE1NfHLnHzndbAqq76AvgdAB7EpODKq0ODGtB2WFxxStqwTnOXLQLTcJY9oG+XnPUtXO+lD67DzAnmCFwZ8I6dpf6FJbqX+g3qZRLBa59hx0LUtuOjUFhyUB0R6CaI0DcKbCeinZPJfjS+s3kEn3z5EFH7vNxlcvPkthgNelklJ9gEc3zKG0qZP8WDqGdFNxUPNUSohgpFn03tvzfFEV1cyyy0rlxxM3diK2LsTPFucDEaPWiske+Pp6XpsDH6RzyHoJRzpcyUDhU0ZdvUledvizlKDKmifOmsMlg4YCsP9ULVcv3OhzXY1oJ9l0nIqYVO4Y3pNX1h6V387vuaInb28o8uvOiwzVsfmRK/yGiTQ02xj87GoaPBJPW4VBDYaIctLHP+b3uCqsAv8obT0PDcdmE6ntxKYA+1dRUXFiNpspKioiNTWV0FBlqfIqKioqKsHh7b02GH1N/USjonIOBOMCbOPmW7OGY2PGYq+s9Cv2ed3WJTQkmF6C5r170cTG4qiqor3YKys5NmasX4FQctB5m4sG2iTyus6xYe1ajt97H/ndEyjI99Ijr83OhDaPXR2ESsNBZNHE47TpDmipM0d63bbZoGNPaie6CwKefqyDH7zPaUtTUI65spgIKmoanOXXHpRHGSkPJgEZp/OpU3pPSguPKXOK+nM4Apb6ENL7D+J3144nf2+rOOjZF+2MpYmKjGRsWs0vQhgM1inVXpQKgkq2cVgScJjdS7199XRr7/F4CoMSohi43Flp38Ow0CZobR0nH0NKYzG9Gw6T1lTSrrn7olPGJZQVFGA215/XccF3eIz0OBhROHgERcIgeHcnXhp1hGhNLcVJyUCrOOgvbMgbP65fTXr/gQHdg+C81kXhqWCFf35X4Fa++8b6AswBwkXqzTY+3XGCab9L9bnOpztO+BUGBQQ0OrOPrVsxe7x9Ctpmr2EmKioq54/qM6ewNDX5XG4IC6NDZ2UtT1RUVFRUAqP2HFRRaSe+evr5W9dTKLNXOvsXSWKftzECpQo7TCbq167FYTIF7iUI5yQMus772JixXnsESgh6PV3nPY82Nja4wUWRop1blQmDPnfeKhCCl36Hfvbd4az7F8VeRWf99iss2LWdZQvmYre5O1wunTyFTqJGefm2KNJFH0Zq7oA2gpoDONkhMrhS8BYn4uCzZoxR0cq2cQ0F8bIsvf8gxt89mw1LP3Bb1KZUVRCw6ZSVPv/UeJa/Ki2Hvdh4lhiLdu9ONNeebu06/4JAWv+BTJw1x6swWLR7J0W7digaKlDfw7MN0ZwIS/J6DIUR6fwvcSyd+557z05XSn7cfUGEwaYEE5+POM2yy0rdHJ4AG3KqWHZZKZ+POB10D0LlBFcEIl0bqcdgxk0FXDFhE7dnu7+2k684Ta8/FJNxU4GiHoSF+a3vh+FBOOosHkKg2eZAE+D21WsFMrv6f2/L6BKFXts6kKcwCOCw+XYxVVgFTlgEyqzurz+NoRwh5BT/3LhF7T2oonIBqD5zinfu+zPvP3Kfz//eue/PVJ859VNPVearr75i5syZQW/X0NCAoODf6+LiYmJiYtoxs4vH6dOnGTZsWLu2zcvLY/369ed3QipB8eSTT3Lffff91NNQ+QlRnYMqKu1AqZOvzbp+AkC8jREwVdjFfaiNi5PFxouBvbKyTY9At+lZrZy8f3a75hRf26jI7ecXDwdhwNTiFjGtb8lZHE/ocYSKYBbYZ+zkt18hokjBzq0sWzCXiTMfRqvTIVqtnH74ERy1dRAd7n07jzG6hBi5/s130ep0btfcAeQHWU7sWqJ8oroeU0qnwNtIeNuHizD4zcL5FOw8hGGfgr5oAZyInniWvwZThhts6ayvJN1gnVIXi6gmA/dVjWfQLbdwplbgTwd9O+okgfDJ8B1U/BhcP0ZjVAwT7nkQg4+yr9Sc/qT1HxiwrNgVX30PIxxNPBGZT/at96DRun8ccdht1B/bz4ChDzvvuR1bgjqOi4khykLshONQFrj8VmnITHAo6c7oG6WCuKL1PN4P180eQaOHePbxjhO8t7kkoJzpEJ2/YGu8qISiCFa7yI+nahmQ0tHnGNuLq7E5nHvyJgwCWBsSKfjmGTQ6MyFRZ+gy+G2gbSmxK65p4S+uSyIpIpkbB3bDaFA/VquonA/8OQbbs97FYNKkSUyaNOmnnsZPSpcuXdiwYUPgFVW8YrPZ0Clw3v+ccTicn3M0GtWD9ktEvWoqKkESyMnn6v5TJAzKK7uPoXRbSXy7mMKghHnvXhp8fAho2LCBxpa042Dxmm7cHqRS3Sij/zE9+v3pKgR0JzTsM3ZSJlC6fCG2NTVx/N772FB4QJmg5yIM6sLC5JLsiFGjnMLgJd2DE0lFkQSXY4mvbfRapuwPY3SH1v21CIMTZz7M8f17nCKNKLo5j3wSpDAopdtm3FTg5sQK5Ljy3DaQwylQkm4wTqmLRVq/AUy75x9kJfShRwffZZQSDkFL2tARQe/HVFvN8f175McldSUcqDpASZ1TjNTqdEyaNceZXKwQb6nCEuX7d2IsP0ZW12j5v96J4RR+9E+2vDGPbxbOZ/zds0nPGxz0sVwstAY7oQpvdaUhM8Fxbg7dYMKGFCGKFOzYQtHunaTGhbtd25S4cP6bf0qxz7Fvt2huHNitzX83DerGLYO7k+dHGGxotrHIpVw51aahp03rJgxKWBsSaa5JprmutT+tZymxL5ZuP8rflx/gze8LeWdjESaL6iRUUfml0NTUxJQpU8jIyCA7O5sxY8ZQWlrKyJEj6d+/P5mZmdx1112y4LFkyRJGjRrFpEmTyMjIYPjw4RQXF8vLrr32WgDWr19PVlYWM2bMIDs7m8zMTHbsaHXdv/HGG/Ts2ZPc3FwWLFjgNqebb76ZvLw8+vbty4QJEygtLcUb27dvZ9SoUeTl5ZGbm8snn3wCQEVFBWPGjKFPnz707duX2267ze85eOaZZ+jduzc5OTnk5ORQUlLidx6Sg3H27Nn07duXzMxMVq9e7bZMQhAEnn32WQYOHEhqaiqLFy+Wl23atImcnByysrK47bbbsLlU4Lz44osMGDCAnJwcBgwYwObNm+VlBw8eZOzYsfTt25e+ffuyaNEiAEpLS7nhhhsYOHAgffr04bHHWnvJzp49Wx5v+PDhHD58OOB59MWaNWsYMmQIubm5ZGZm8vbbb8vLamtrmT59OllZWWRnZ3P77bcDYLVaefjhhxk4cCA5OTnccMMNVFdXAzBt2jRuv/12hg8fTlZWls/9btmyhf79+8vn7J///CcAS5cuZdCgQeTm5pKdnc2yZcvkbU6dOsXkyZPle+Hxxx/3O0+AM2fOMHHiRDIyMhg1ahRnz54FYN++fVx22WX069ePjIwMnnnmGXmbJ598kj/84Q+MHTuWrKwszpw5Q0pKCrt375bXcXWGjhgxgvvvv5/hw4fTvXt3Hn/8cb755hsuu+wyUlJSePHFF/1eA5ULxy9bmlZRucgEdPK5uP8AOUBE+Q5axrjnXkSgcf36cxPHLjDauDjCB3v/0h4+ePA59Td0Szdur4OwRfSLb+lx6HVMH0EgFVFGyoLp8dfyhXjbXTMoOFVMeZQxaGFQQhII97+3hLKVXyqfA4Ag0KW6Xj4WDZBbXCqnRAfa1s0huGOLLAxqdTpSc/qTnjdYUVptsHi6kuyh7l+wfTmuDFEWjAnu5e2eYyVn96e8qICmuhqvy5XOyZW4lDTqysuwmIITXtuNy+lOjQv36shyJTxER/eYECp2bQzK5ZeeN5jUnP6AUxi8+r9Xy8uW/345yVHJskCoJJhEwquI3HK/SfuDloRyKREZKNi5VRYIf24OQlf3abxe5NFOTZhF+HF3LCs6t96Tw3bHEtOgb1fPwUCeQKO2uaXXYPsEQhE42xDNys8vI1k8SZif/pCKnbRerquEtwRifxRWNPL+9MHtCv34dMcJGpuaSW86wXFjN0r0cExvJ92q8SoQgnuJsVLBt9niPC//XF9As82B2WZX+xCqqPxCWLFiBTU1NRw4cACAs2fPYjQaWbZsGREREdjtdq655ho+/vhjbrzxRgB++OEHdu/eTe/evXn++ee58847WbVqVZuxDx06xNtvv83rr7/OokWLePTRR1m5ciX79+/niSeeID8/n86dOzNnzhy37V566SXi4+MBmDt3Lk8++aQsgEnU1NRw55138s0339C5c2cqKyvp168fQ4cO5eOPPyY1NVWekyTueKO6upr58+dz5swZwsLCMJlMsuPL3zxqa2vp3bs38+fPZ8uWLUyaNImCAu8hZCEhIWzbto1Dhw4xYMAApk6disPhYMqUKSxevJjRo0ezatUqlixZIm8zdepUZs2aBThFsWnTpnHo0CFsNhvXXHMNTz31FDfddBMAlS3miFtvvZU5c+Zw+eWXY7PZuPrqq/nkk0+4/vrreeihh5g/fz4AH374Iffee6987X2dx65dvfez7NevHxs3bkSr1XL27Flyc3MZO3YsSUlJ3HfffYSFhbF37140Gg0VFRUAzJs3j/DwcLZtc35mevrpp3nsscd47bXXANi5cycbN24kMjLS57V67rnnmD17tnzckrg4duxYbrrpJgRBoLi4mMGDB1NSUkJISAi33HILY8aM4dNPPwWQ5+NrngBbt25l586dxMbGcuONN/LGG2/wyCOPkJKSwpo1awgJCaGpqYmhQ4cyevRoBrd8D9y8eTP5+fkkJib6PAZXSkpKWLduHXV1daSkpFBdXc2GDRs4ffo0vXr14vbbb//Zl9H/GlHFQRWVAEihI+GDB3PqgQcVlwdHXzMpOGHQdYyfuSgoYa+s5NQDD3otp27csuWc+xv6FQgDlaz6EP3cxoyJ8JkQrDTIxHV/CWYbx2qLqVAoDHY2hLURBiUEvZ6MP95GQVVZcGKcKHKqQyQaIKElEVojCAxLzyQ/JdF3+rMo0sUQxtV33Y8uNJSJMx92On9y+st957Q6HRNnPtwq3pyHe9SzvLfCKmAWoSG22W09b6EOEV0a6DHxRJsxPUuDXYVB6Xkl+FovNDKayuJCRWOcL6RebrJQG6egXB2YNGuO4uuVnjdYHh+g0eoufDZaGyk0NdNgtxOh1QYtELrh4kh1TUJuM9cWV66nQGiMjsFUW3OOBbW+MUbHYKqr9XnOvKUxx+tb1s2pYoVLiXFMg759acWCQHhUDKbaaq/L0jMvZbz1Lb48mUFJY4d2nQcBCHc0EV7RhJmwNmN4hg0FQgRScge4XVcJTyefL3QtZcSiCHVmG0u3lKDTaoIu2+3XLYo/WTdiKDtAZWxPPoocSXGvUJLKBULKLV7Pl1xirDej79aJv/aN4b+7C+kUV8fu5tfl9Synb2RkehbHK+0csDqvbXNL38RF6wv445AUNcVYReUXQHZ2NgcPHmTGjBlcfvnljB8/HofDwUMPPcTGjRsRRZHy8nKysrJkcXDo0KH07t0bgDvvvJPHHnsMu73tj4k9evRg0KBBAAwZMkQWp9auXctVV11F585Op/Jf//pXnnvuOXm7pUuX8t5772E2mzGbzcTFxbUZe9OmTRQWFnLVVVe5PX/48GEGDx7MggULZGfWuHHjfB5/VFQUPXv2lEWkCRMmkJSUFHAeOp2OadOmATB48GC6dOlCfn4+3bt3b7OPm2++GYBLL70UnU5HaWkpZ8+eRafTMXr0aADGjBlDWlqavE1+fj7/+Mc/qKqqQqfTcfjwYZqamigsLMRsNssCGUBcXByNjY2sWbOGsrIy+fmGhgbZIfjtt9+ycOFC6uvrcTgcsmDq7zz6Egerqqq44447OHLkCDqdjqqqKvbv309SUhLLly9n69atssAqiatffPEFtbW1fPbZZwBYLBZSUlLkMa+//nq/wiDAyJEjefrppzl69CijRo3isssuA6CoqIibb76ZkydPotPpOHv2LEVFRSQlJbFx40ZWrlwpjyHNx9c8AcaNG0dsS7/4IUOGsG/fPsDpsp0xYwa7d+9Go9Fw4sQJdu/eLYuD48ePVywMAkyePBmtVkuHDh1IS0vj6quvRhAEunbtSnx8PMXFxeTk5CgeT+X8oH5yUVHxg+wUXLNGeU+/FoHQYbO1vw/gL0AYlGhYs4aGDRuIHDXK7fmIYcOIuOIKZSXVfvDl9gux2n33AvQhDHqOWVFdT3yLgKZov75oKeUVgQqlYqIgEJbVx2/KtSzGvfisb1HPy7gV0eFUxESQUNNAv+PlRI0aRdJLC+jS1MRHt1xPWaiujdCaWNtI3+NFnJn9AEkvLUCr19Mjb5DvOZ0HgdBTYHHr8dXZ3Q3oGvJw3fouxOlEr8Ig4OZ8OvBBupswCP6TdA+vTUGsBocPp1RoZDTm+lqfxySdDc874JxFLC+9LZWg6Hp5CHUldSVOIbDWXQDdUn6Evx0/giiEYtd3YtOg3j4FQkGrQ7T7cIgpFQY9jl0SCI/v30P3rGy+X7eBzz/6grSmknafW0GXCgiIttZj1ejTScr8f5z8cSGm2hqv2/lzlXo6ztpVSuzFxZvWbyAIULhzm/P83XgVvPUvTojxQPtLWV2n66s/pBJEoMiYQljeFK/356c7TlBvtqEVhJa3cRGH56UGcrrFcGnn1i9JJ2uaeHdzSVCOPLvNRuFH/8Rw+iAAsVVHGddk5YfQ8fz74dFs/PchivZWes1xsTYmEt47mieOl8Lxs0AMfbpFg8vvFdbmeC7t2JsfDhThee6lFONpA7XY7I3otOEYjYFbAaioqFx80tLSOHDgAGvXrmX16tU8+OCDTJ8+nfLycrZu3UpoaCizZs3CbA6cau5JqEvvXq1W61Y264prGMnGjRt55ZVX2Lx5MwkJCXz11Vf87W9/a7ONKIpkZmayadOmNssAdu/ezerVq/n88895/PHHyc/PR6tt+36u1WrZsmULmzZtYv369QwePJgPPvgAQRAUzcPXcZzLebBYLFx33XWsW7eOAQMGUFdXR3R0NM3NzV63A+f5AKfLMNSjZ/Lx48e566672L59O+np6ezdu5fhw4fL2/k7j974y1/+wvjx4/nss88QBIF+/foFvD9EUWThwoWMGTPG6/KIiMCVSvfddx/XXHMNq1evZs6cOWRlZfH6669z4403MnfuXCZPngxAx44d23W/Svi6XnPmzCEuLo78/Hx0Oh3XXXed2348j0Gn07mJ5p5z8tyP0vtE5cKi9hxUUfGBZ+hIUCKfKGL67jvs7XXOCQIRI0cSPnJk+7a/iPgqLXbtnRd0SbAguG3j1i8QSKxt5PKDJYr6B/pCAyT6EAa97tePWzSxtpEu1fVUxEQEdayF+dsp2r3T7zoaUSS3uIzEmgblQlzLHMqjw9nbP5PO8+chWq0UjZ9A7pHj7scjikQ3mskuKUPjo3emJ5Lg1Cm9p7L5+BrHQ2BR2uOL6LalxEr3IeErSVesBrOPXoqBhEFoFVpEl//XhHeiPDotyDxZL7gIhJ7p2P6Qrld6/0Ft708vwuDV/72aKcun8MiGR9xWXbDtcTqUPk7HMw+gtZbSYLej1emYcM+DJKa53wui3ebsXemJy/5KLHb21ps4Wt8YWGxuOfZPnp5D96xsDKGhdOo7kBWJYyk0pridb9f/B0ZAZxyLoHWG9mj06eiMV3Fs+1KfwiD4F82kEuP7E5uYsiM+uFJijXPctNwBZAwfJV+7ax54nEn3z2HSrDlc88DjTJz5MAD/PZmJw2Q7b+5Jf/0hJRLTe7a5j0Sg0JjC/xLG8MYG76XDeSkduWVwd24aJPUN7M7Ng93/u2Vwd56clMkz1/bhmWv78PBVvflvvjONdNH6AkUlyd6EZgFIMxVz2fFveG9zEWPvzCK1b1xbxV6A1L5x5F6b5vb0ir3u7k3RHsLr645Rb247H1GET7dsZvOW0Wzffg2bt4zGZCoKOG8VFZWLz8mTJxEEgUmTJjF//nxEUWTXrl106tSJ0NBQSktL2/Sg27x5M4cOHQLgrbfeYuTIkV6FN1+MGjWKFStWyD38XEuGq6uriYyMJDY2FovFwhtvvOF1jKFDh1JUVCT3+gOnIGixWCgqKiIiIoIbbriBhQsXcuTIERoaGryOU19fT1lZGcOGDePxxx/nsssuIz8/P+A8bDYb7733HgDbtm3j9OnTQbm8Lr30Umw2G+taepOvXr1aLks2m81YLBbZhbhw4UJ5u169emE0Gvnggw/k5yorK4mIiGDkyJHMnTtXfv706dOcPHmS2tpa9Ho9nTt3RhRFXn31VUXn0RfV1dUkJycjCALff/89e/a09mmW7iOpR6VUrnvttdeyYMECTCbnZ1eTycSPP/6o+HyB082YmprKn/70J+bMmcOWLVvk+aSmOn+Aev/99+Vy44iICIYPH84LL7wgjyHNx9c8/VFdXU1SUpLs5Pz222/9rt+jRw+2bnW2iNm2bZtbn0eVny+qOKii4oWggkT8DtS+bSMuH07SKy+T9MJ8tF7KCX5OSKXF3sSkdgmEgoA2NrbNuZOEuv5FZ8gtKUOHF+FOoTAYDEqCTLJLyjjdITLo6+3a380b0n1oWru2fQEtgsBpaxPLXprLoTFjOW1xfihxFVpDrHZqI8LYk5yIDSiLDKNOoUB43SN/JyRcWXmrNzwFFqU9vnpfdYKUK860ax+Bljt8rC9odQGFQXldWjWHtH55TP3z7TzzyvP0yBvc/vRtCZewB0/sNhsHt35BTfUeWYyw22wc2+H8cNZGIPTi4PMsJfaFIJo52mhmd009i994jbLCo23WMdVWO+8PL/srsdgZuvUgY3YcYdiOo+w4elRRaFPpsSO8fc+fsLT8Ai0lMxcaU5zzF5y/PDdqwhQJhKKtEGv9vxHtpQjaTmhCr8Da8CkOq/feSRKuIlrJmi5uy0rWdOHsV8nUf5ZGWLlRwSxccNjRGgzY7TaWvfgsyxY4v+j0yBuEVqdDq9PJjt5lSz6kpKF95cT+8Bc2lNZvIDf87Tk0yVluQmyhMYUVCWNwCFrZOedJVtdoWfTz919W12h5G9cehb7GdcWfA1UAUk3FHF76Kg1mS1uBUIDw3tHEje3Ckk3uaeCmxo40HJtNY9HdNBybjWiNw2L3ExTmcH8d2ewXqTepiopKUOzbt4/f/e53ZGdnk5uby9SpU3n55ZfZunUrmZmZTJ06VS59lRg6dCgPPfQQmZmZfPXVVz4FPF9kZWXx5JNPMmzYMHJzcwkJaW07MW7cOHr16kWvXr0YNmyYT8GtQ4cOfP311zz77LNkZ2eTkZHBww8/jMPhYP369XJwxdChQ5k3bx7R0dFex6mtreW6666TAyusViu33nprwHlER0ezf/9+srOzue2221i6dGnAslhXDAYDH330ETNnzqRPnz4sXbqU7OxswFnq/MwzzzBw4ED69++PwdD6b5FOp+PLL79k8eLF9OnTh+zsbLlU9z//+Q/Hjh0jKyuLPn36cN1111FVVUWfPn248cYbyczMZMCAAW6lz/7Ooy/mzp3Lww8/TE5ODu+8845cOg6wYMECmpub6dOnDzk5OXI/yYceeogBAwYwaNAg+vbty+DBg93COpTw6quvkpmZSW5uLo899pgs+r388stMnjyZ3NzcNqXd7733Hjt27CAzM5OcnBxZGPU1T3889thjLF68mL59+/Lwww8zyqNizJNnnnmG1157jezsbN555x0yMzODOl6VnwZBFM9F+Tj/SNbh2tpaoqKifurpqPwGOW/C4DmgiY2lxzdfc+rhR9qd+HuxibjiCq+9ByGIc9oiDAbj0nRAa//AmgbFwqADZ+iIr7Jin/vxCDLJLiljTztCU9L7D2TirDk+y0O9nTMHsCs5UVkKsttgYLDasBh08jlyAFt7dKXWGOJequ2yTrdXXkbQ6YgYNky+rnabjaLdO+melc3XrzxP4c5taHQ6HO20/7v2HEy+4rTcc/DE6Qw+1ra6bS7fl0Gs/UrC9KsZMG57wHGL13TGVG5UFKJgiLKgMdh9lhKfC4lpPSkrPEp63uDWEtFzKcf2IuiB87osf/0RIrI+l58bOGAlaxZ96AyWaeknCDjFE5fnXMfxDCHxxdnO87DrO8mPp3+wgA613p3SUomx6/721psYs+OIvM4fP32NxEplgi9Apx6XMPieJ7hiwUYAdA4rvz/zFYmWcgScgpVJE4bR0RSkeKbB+UpTTlhcE73+UCw/PvxZSlB9+vzi43of27GVL+c9fX72EeQ8muww9NlVXHb8G9JNxRS4CIMSkSFaNs8ZfU599xqabQx5bo2bOy8qVMemR67wOq7f0nQXRECb0od7/vE0CBpWvrmfoj2VhGdE8+Rp76mgSkkwlhOqbaZzeCl39n1Pfj4z40WM4elqibHKbxaz2UxRURGpqaltyj69UX3mFO/c9+eA693+0ht06Oy9N9yFYMmSJXzxxRd88cUXF22fPzekXnA1NTU/9VRUVFQ88PZeG4y+pvYcVFFx4ecgDAI4qqo4OvpKxPr6n2wOwdKwZg0Vr71G/P/9XxuBUHIQeju34ZdfjqDR0LBuXdDCICjrH+iJEkHRM2nZW5BJe4XBtNwBQQuD0hySquspDyZFGUAAi975xb0sOpxN6V0IsdlbhUEAQXD2cGxZZ29eFuGf/5em9etl4dchCLKwJAVCAO0WBqFtiq0U6tB75O18/P3j8vOxjnEkNCWj01wNBBYHlQqDAM11hgsSaqHR6WVHndQzb+xf72PJrL96D5kIhB9hcNmCuZwuzqdXVuvqa5cspGBnobx/qV+ht7AZieSoZL6c+AVHf9xJc6dQHt30qLysLvYv2PVd5Z6Drlj0vs+1aLehDzMy9q/3UWKx09Bk4Wije++Zqg4JABisFp8ioyulx46w792FrJl5N43NNvb8+xXKj7eWxUhBG8ETnDAI59anLyAtTtGvXniWSfe3vmek5vRHk9QT+8mjF+TedcPjvvt0axF1zSLfJo7lSNNxjhu7oxG0Tlm1pY9gfbOdT3ecYNrv2i+EeUs2ltyDnr0HlQqD4Lw37MX7+O8Lz/L7++cw9s4sju+voq6DDl5vvziYYCznucue8brsxwOz5L9z+q8kNlpNM1ZR8UeHzl25/aU3sDT5fh83hIVdVGFQRUVF5deOKg6qqLTwcxEG5fn8goRBcPYerFr0Bs1Hj3l1ELoJhGvWED5yJNGTJiJotYQPGkTJ9D/R3JKIFSxS/0AluDkAcQph+cmJbgJh+OWXk7TgRWc69Zo1hPbpQ4db/0jd19+Qu369LERWRBkpC1aoA3q39BLzRqD7MKHOREJNQ/DuQRcRsC4izHvas8s6p61NbCw+RC7QsHYtx++9z5l2vMspzPnrx9YePAWVaGO822NdcyWimIStsYszTVRnRh95gqQh/24z1rFl3YJyAF4occVhcynLbumZ125hkBZRuUWgcXVw/u/NxzldnE9ojHuz7qrSXYTFGuTUZleB0FvYDDhFlr1vf0DBji2EDb4EOros03fFZkjxup3B6rs/D4C1ycT8vz3MaxOne13+9RXXy3/7cyG6UrBzK6LDAQKU/7jrJ3vfdg24sV8A9ylA4a5tbgJhkx0WG6/gMqOVNFPxOd3DIiIhUVF07dGLovyd7ufRiyAt9Q50koLUcdZqd/D5rlM47CJ6rUBGl/ZXf/hKNhZF72nARbt3UrBji+LxBaBk1zaKdu+kR94gUrPjKao8t9LfUK3vZvmufLHrKHeMVMVBFZVA/ByFv2nTpskpvb8k3nrrLbdeexILFy5k2LBhQY2VkpLyq3cN7t692+t1vvXWW5k5c+YF2295ebnX0JIrr7ySefPmXbD9qqhIqOKgikoLDRs20LBmzU89jV8mgiCHr0iBFv4EwoYNGwgfPLhVfOvbp93CYDC0KQ1umburQBh5+eV0e3Wh21ylstrosWM5ed9MNC0hNfH1TXQxhHHaag5KmDi4YR09Bw7xKhAGug81QD+lKcr+ULBdWZSR/OREskvK2FB4gLKqkoDbtBdJYOnetzejpt1NZGQPvpz0Fas/3M3p/G8w1n6HVX8SffjVWBsSEUU7tqbv3MYIppRYokETRnjQpaftRBTbLQwCsoopu6R2bCG6ayipV7s7BiU8U5slgXD5649w+dRbMIREuZU4urmvgLJ9B+Dy1vEeS0vhyZOtjyes+YTY6nLFbr96P0mDrvhzIbohihTuUpjifYG5EIKgJ64C4ac7TlBnFfg2cQxjy1aR4kcg9JWgLS1rMjgY8/eHyIzPcnff+XCqZnWN5pmufdqM9dq6Y9ha4odtDpEdJdUMTI1t17F6cw1KeHMPpub0Jz1vsOKSfRE4HpFKfO9s+bmIEC16rYDVLiKIDkQhuM61zY6QwCsB/9layZShtnMquVZRUVEJhunTpzN9uvcf51TakpOTE3RPwPNBQkLCT7JfFRUJNZBERaWFiGHDiPgFpAP/LBFFt1AQf4m3gl5PxLBhTmGwRWQz79vfvv1qlL+FeRUG5Uk5BcK9/TPp4iJqCno9kaNGuT2WA1aAqFGjuP7Nd72nwPqhMH+7z8TZiGHDiLjiCr/jaYDskjIMVvuFdUu1nJfveidTFhVksEIADFEWwuKaMES1Os4sdQaObSyg7LBTaEqO7EZ8/X4ia5296BzWAqyNy3E4LFgalmE1nXYbMxhhUAQKQrtTbogPuO75wNvxBkvhzm0U7NwmC4MAlmZlYqOU2myIbCYi63N25l/nlqLqrSwzqlHHdeu7cP3uS7hufReaV7qLsbHV5SRWnlEkDEJgd2Gw6/0WkQTCft2iuGVwd6YMTiVm4nSsXTO8BrCIQHFoNzmoxXNZoyaMpVmp6AwG91Rr8CoM+sLT6Sc5/JSkCwcaq828vYztN5Hbc3ugyJjC8rgr+e/u1j6Xsz7eg9UuohHtDD27WfF8BWBMRiJX9sljydH/j6c2P8Cbe6e6rXOah/j7lgd4ZONjFNV2DBisoqKioqKioqJysVHFQRUVF/ylU/3WEDp0gIjgS2YBvwKh17LZdghc2thYem74npA+bR0snvgVBiUEgdP2Zpa/+oJX0U5erUUgTHr9NZJeWoAuLIzxd8/GGBWjfPItJabeBEIlCc8OYE9yorOP4Lmm3wZC6kV4HvdjiLKQcVMBvf5QTMZNBa2CmSDICc6SWOXpDHNYC7DUf4JoK3RLjJWcccHQyVJBqvn4BXcN+jzeIEntN4Af1692K59U2t9OWk8SCSUszXV++7VFmfSEn24myqSnYu8ut2WREXVBHUuH2iqmf7CAP376GhPWfOK2bMKaT/jjp68pLin+LVO4axtnv/+Sp67u7Uz4vS6HB59/lsSs/m4JwgDl8bFExdbTMbLO7XlwCoPvdbuZptpRCA6neCiJbNc88LhiYRD89wcMlk93nKDebEMrCOg0bf/TCgJ1Zhuf7jjhtp0SgVAErF0z6DBxOv9vSCpZSdG8s7GI4spGNhytRCPaGVe+ilSTu0taEO1ex5PGHJoey8NX9WbriXCO13ejrMH9R4eluwRK6rpRbko4J+FURUVFRUVFReVCodY0qKjgFKzKX3kF03ffBV75N4JY7XQknQqPo0kXQpitma6NQYSFuAiEUonx+errGJqVSfK776IxGkld+h9O3HMvjevWOUNEzp51G1uRMOgyZ9e+bL6+GEuOQnA6rr5ZOD/4clE/+/IX4BLU8ZwvzvN+PAUq6bHkVAL8hws4yuQ/21vOKUA7kmzbh6/jDRZTbQ1lhcfcnnPtdyclPkuUrOmCucYgC4NhcU2ExriLeUUHVnF81zucOHIQRP/nUhL3HDEaMscdpdNYp+sqGGHWl/AnuRBVlLFz2eecPXWca+5/DK1Oh1an4/898rjsKj0RkYw5SssNE7+Wt3G9Tk2Cgf8k3YRNo0cQ9az70UHvEc71tDqdz56U3gi2P2Ag3Hsa+l/PE0kg9Pr+IQj08HBDvrbuGPNWHubdzcWyMCj1cJx6YikWjR69w8pZQ4c2icwSGgEyukTxr+8LsdgcaEQ7A8t3uK1TZXI/fl/BKioqKioqKioqPxWqOKjym0e0WmVx6ZeCLV7EESqiMQvoKi6cvHEqPI7pVz4sP37r27ntFgi7znu+tZT4HEthY//8ZzRGZ5mroNfT7ZWX3fsYuuwj6NCQlnRQqVF9IIJthN9mX0EIhD+JMHgeMURZZBHLldAYC6ERUYyc7gylCJQ6Ko1zruEPF8Mx6Ot4gaDmHxYVQ1nBUa/LfI1hrjHQVBkmOxe9cbZ5ERGZkJHpFI8Av+e2Q20VYfomOtEq5LVH7PQsHb6gpcSCQFq/ASDys+lReD4o2rWDL194xk0gnDjzYV7995fYNqwh2/Kj2/qu1ylUtDC6cq1T8EIblIhntTSz6+sv6TfhGvSGkDauQYdRC1oN2B3UN9l4e0MhkaF6bhzYDaMh8Pi+ehoqxatA6KV/oiRqAhyvrHcTBgFibLXymDG2WsaVr/IqEDpEWH+4grc2FskCY4KpggMfpKMx2CnRdqcyLNbtDUcU4fV1x9he28jzYy4lPkxZv0IVld8S1somxGbf/74IIVr0cWEXcUYqKioqv25UcVDlN41otXL8rrt/do7BMx2gyQBhFujsYUizxYuUP9VaqpvwhP6CCYRNuhC/jxUhijSsWUPJtNsw79t3zsJgSJ8+RI4Y4facq5PPU1CLrzORWNOgXFBr+RKZmtNf0XyCbYTfBj9ipKdAWBEZ1q505HPCW6pxO/AnUDndbqfZkT+ehn2/p2DnYb/CoOs47SknvhgEPl4nSuYfFhVDU11NwH16lhj7KiX2RWiHZtLGtSaOeM7tfIqdkgvRojcoDjTxhjE6JmBydlruACbNmgMgO+uM0R3OLRzmZ0LRrh189eKzTJrlTDFuaLZRum85GeHHA16nNFOxLHjVN6PYyXZ06yY2fvguUXHxdBs4zM016DBqsQzrJK9r2FDK6+sLaLY5MNvsF8QpZ7LY+HDbCTfx0U0g3LHFa/9ESdT0dAx6QwC38+UpEL7xfSGi3eY2jvRaSKCCcca22zU021m3+SQzHSLv/z7H57GoqPwWsVY2UTZ/R8D1Emfn/WwEwq+++op169axYMGCoLZraGggMjISMcBnyOLiYnJycn7WScGnT59mypQpbNiwIeht8/LymD9/PiM8PuOrtJ+//e1v9OrVi5tvvrld269fvx6z2cy4cePO88xUfq6onzxUfrOIVislM/6Ppnb8A3YhOdMB7v1L60vz5UU2N4HQEer+4cH5+PyKg1Ip8fHIBLfnpcdBlRgLAqF9+mDeu/ec5yVERpL81r/apCC7raPX03Xe8xwbMxZ7ZSUaIFdpuq+PdE5/+C1jU3RQ/sVIV4HQtmYNIYKGZvEi98Y8DwKhUoHq1JF8EH1/0D9fJboXGqXzCrReTEp3aoqPKxrLtcTYVahT2pcQwf3edZ3b+RQ7Jc6lt6AICGGRAYVBQH57lF6rRbt30vXSTJbM+uuvQiAs3LmNr158lgn3PMh78+5n9KTvva7n7Tq5Cl5K3YOHNzv/zTy8ZSNbNSlyf0BBALve/V7T6DQ0m5w/ZrWnxNgfkpBW1djMa+sKqDdbuXf0JfJy1+udmtPf7T1dcg0KjsDCoIQ/gdBTGFS8HbBx52nKxvQmMTyExT8UM2/l4QsmpKqo/FLw5xhsz3oXg0mTJjFp0qSfeho/KV26dGmXMKjixGazoVP4/UMJf//7389p+/Xr11NTU6OKg78h1EASld8kP1dhEJyOQW+PbfEilm4ObJ3cv8ALA7s5n48/P6m1Uinx3SNnMi/P/ZemeXk3c/fImUy/8mFOhccFHkwQiBg1iuQliwMm8AZEr0esr+f0nEe9piBLiFYrpx54EHtlq3gpCYSJtY2+xbt2CIMS0pfQtNwBQW2ndJ+SQMiDsy6+MCgIzv/O0fGpVKDSG6K9Pi+l/XpzQ51rCrASgj36YINCvGGIjOTVtA2YQmyICmdgqXOWErsKdK7BLSVruritX7KmC4Urkihc2RWtzn0frudWsfuwo1nReueCCJg0YYhN9YrWL9zVmg6u1elIzenPyn++hEmBG/OXQuHObbzx11sRKg4pWl+6ngKQbiomtemE15APgMaaar5fuoT1777F+nffoniPM5imaPdOhP3fMapDI3mdrYzsn8igvu4/KCV1i8IRqcdh1LY7oMQXi38o5u/LD7Dou0IAXvcS8iH1T/R8f5Vcg8mm46QrEAYlpPOVbGoV7INxHl5VvgqD4HC+pbY8L9pE7l91kIZmG/9c7+wp+s91x9TAEhWVi0BTUxNTpkwhIyOD7OxsxowZQ2lpKSNHjvz/2Tvz+Cjqu4+/Z48cm5AEEsKRkBMPINzhFkVBxANsrVqt9arW1qtVi61an+fpYcVWFBUVtN7Wo/UWtYogCMh9qcgh5CKcCSHXZrPnzPPHZiZ7zO7O5gDU3/tVanbmNzO/mexOdj/7+X4/jB49miFDhnDLLbdogYUvvPACZ511FrNmzWLw4MGcfvrpVFZWaut+9KMfAX5RpaSkhJtuuonhw4czZMgQNm5sd0I+9dRTnHTSSYwcOTLMaXjFFVdQWlrKsGHDOP/88zl06JDu3Dds2MBZZ51FaWkpI0eO5I03/EFftbW1TJ8+naFDhzJs2DCuvfbaqNfgvvvuY9CgQYwYMYIRI0ZQVVUVdR6VlZVkZGQwe/Zshg0bxpAhQ1iyZEnQOhVJkrj//vsZO3YshYWFPP/889q61atXM2LECEpKSrj22mvxBgT0Pfzww4wZM4YRI0YwZswY1qxpT5DfsWMH55xzDsOGDWPYsGEsXLgQgEOHDnHppZcyduxYhg4dyr333qttM3v2bG1/p59+Ort27Yp5HSOxdOlSJkyYwMiRIxkyZAjPPvustq6xsZHrr7+ekpIShg8fzi9+8QsAPB4Pd911F2PHjmXEiBFceuml1Lf1dr/mmmv4xS9+wemnn05JSUnE465du5bRo0dr12zBggVB20+cOJGTTz6Zq6++mtbWVm3dI488AoDb7ebOO+/U5qYKfl9//TWnnXYao0aNYvDgwdx3330AbN26lYULF/LKK68wYsQI/vKXv4T9fu12O1LAZztJkvjb3/7GuHHjKCgo4N1332XOnDmUlpZy0kknsXz58qjXVnD8Ec5BwQ+OE1UYVEuJ92cFf7zYnyXh6ynjuNFLb2u4QFA7tQKm+n/uihJjo6XDMce1CYNqGEmkgA1DWK3Q9qYhNOQkkKDAkxCiOgg7IQwGEc+lj3FMn9cb5HiRrFYGX3UtZXWH4+pxWDiylMPle4w5rGLMtzPECs7olT0CZCtNB74N27Y7XGvxEu/ZGw0KiTZfd3MzF63KIdltRoowg/r0zPDSXEmicGQph/Z8S2tTozYfPXweU1ApcSCBc96zaEDU89VQjk0vzBS51fjggNL9whGjO+7yPcFxO1pIsMQnSqvpvRNOm8QEk5mc3i62120PGttUfYBNH76L7PWCJGkfBBRZpm7ZW/RP68Uzl9/eNjr4mu7JTYJcfxJywspDXeYeDOwX6JP9x3R5ZZ5ZWc5tAe7BUBxuLy+urmTBcn8pdJUtjzJbgSHnIPjPrsJWwN6UPCTJLwyeE4fzsNBRyVXOFTyXOBkJs7Z81aYDPGFLwt7mgmp2+URgiUBwDPj4449paGhg+3b/fe/o0aPYbDYWLVpEamoqPp+PCy+8kP/85z9cdtllAHzxxRds3bqVQYMG8Y9//IMbbriBxYsXh+17586dPPvsszz55JMsXLiQP/7xj3zyySds27aN//u//2PLli3069ePe+65J2i7Rx55hN69/YnnDzzwAH/60580AUyloaGBG264gY8++oh+/fpx5MgRRo0axcSJE/nPf/5DYWGhNqejR49GPP/6+nrmzp3LwYMHSU5OxuFwYDKZYs6jsbGRQYMGMXfuXNauXcusWbMoK9N/n5aYmMj69evZuXMnY8aM4corr0SWZX7605/y/PPPM23aNBYvXswLL7ygbXPllVdyxx13AH5R7JprrmHnzp14vV4uvPBC/vznP3P55ZcDcKTNDHD11Vdzzz33cMYZZ+D1erngggt44403uOSSS/jDH/7A3LlzAXj99df57W9/q/3uI13HnJwc3fMZNWoUq1atwmw2c/ToUUaOHMk555xDbm4ut912G8nJyXz11VeYTCZqa2sBePDBB0lJSWH9en/f47/+9a/ce++9PPHEEwBs2rSJVatW0aNHj4i/qzlz5jB79mztvFVxEWDdunWsXbsWm83Gj370I+bNmxf2vJozZw7ffvstmzZtIjExUZtbQUEBS5cuJTExkdbWViZOnMi0adMYP348v/71r2loaNAERlUIj0Zqairr1q1j6dKlXHjhhTz++ONs3LiRN954gzvvvJMNGzbE3Ifg+NHt4uADDzzA3XffzW9/+1vtiSUQHC/UHoMnojAYWEocyPxZZsAMh6z8sW+rrkCo0hUlxsleV+fHhQiDED2BNyoJCeDxtI/XSUFWsa9ciX3p0oi70hUIFYX8/OJOCYM+r5dF8x6gfLPBP3gGhEGtV1bpeG2c2WLhvFtn8+xvfmmoHFLd1uf18uxvru+8QGiQJpsHj0XG6jWR5mj//UQLzmiWzdSUhwuD0HUluvGguXoAHybMyB0SCPVQg0KMEEsYbBdl4OZFz2DbX0nRqDEoiqwJg4GEORUlY69Dn9scUewMxGyVSc5q7XRYTDTU34vh30fb6y2vZDj//vt9HPx6U9j9p6tCbjpDV8whLlE6JL23qqmKC965QHe/GROsTNmcRXqLVROAFVlGkiSS+hsTjnulNNB4pEeXiF4vrq6k2RnurFuwvIzrJxdFFB/Vsl0VWTLzcfZ0Q6XFqpDa87SfcbnJ/zqy7ttOakWl4XlLQPKBHeRl51OZUti+b6/CU20OSO1clu3p0jJsgUAQzvDhw9mxYwc33XQTZ5xxBueddx6yLPOHP/yBVatWoSgKNTU1lJSUaOLgxIkTGTRoEAA33HAD9957Lz5f+PuPgQMHMm6cv5f0hAkTNHHqs88+49xzz6Vfv34A3HjjjcyZM0fb7tVXX+Xll1/G6XTidDrJygqv1Fm9ejXl5eWce+65Qct37drF+PHjmTdvHr/73e84/fTTo5aEpqWlcdJJJ/Hzn/+c6dOnc/7555ObmxtzHhaLhWuuuQaA8ePH079/f7Zs2UJeXnjSvNrv7tRTT8VisXDo0CGOHj2KxWJh2rRpAEyfPp2ioiJtmy1btvC3v/2Nuro6LBYLu3btorW1lfLycpxOpyaQAWRlZdHS0sLSpUs5fPiwttxut2sOwU8//ZT58+fT3NyMLMuaYBrtOkYSB+vq6rjuuuv49ttvsVgs1NXVsW3bNnJzc/nggw9Yt26dJrCq4uq7775LY2Mjb731FuB38RUUFGj7vOSSS6IKgwBnnnkmf/3rX9m9ezdnnXUWp512mrbu0ksv1ba/7rrreOyxx8LEwQ8++IC///3vJCYmBs2ttbWVm266ia1bt2Iymaiurmbr1q2MHz8+6nwi8dOf/hTw95BsaWnRXjdjx45l9279YD3BiUO3vuPYsGEDTz31FMOGDevOwwgEhmlauvSECx+B8FLiSDhjfI43OTvv2uljq+X+SX/F6UvkYEtf/vn1Vdq6Xw59iX4ph0gyu+jzRQO06BxPRxjUVkUTCCUJc2ZmUDlwmDCoEkEgTJ08mdSpU6OKj0ECYUYq/RNt/OjPD3RIGPR5vZRtWs83ny/xC4MGBU9DwuCmdQBBacYAH82fa6gcMlRUPPOaX/Hho383fnIdpMnm4e0p7YLERcv7BwmEEC5QWRLSqSnfE3GfXVGiGy/qM9spJZCsdK5kOVJQSCCRhKFIwiCA2xp840jNL2bkqFHU7aukcstm/W1C+hLGcw7qvKypkcv6TzgnZ5sweN6ts3nzoQc48NXGsG1PhJCbrpyDUVHalpbBebfO1u5DLZ6WiPts6OHho4mHufzTXDyShW96DGJI8w4S8PGTW+7g8a9j98W8c+TjPLrqOhYut3RK9KppdvLYUv0PGNHcg4Flu4EYEghDhFQVn3cQi1p3BzlRI305ou6nzJbPXlvwB2gJkOXgvx/CPSgQdD9FRUVs376dzz77jCVLlvD73/+e66+/npqaGtatW0dSUhJ33HEHTmf8LTOSkpK0n81mc1DZbCCBZZmrVq3iscceY82aNWRnZ/P+++/zv//7v2HbKIrCkCFDWL16te4+t27dypIlS3j77bf5n//5H7Zs2YLZHP4332w2s3btWlavXs3y5csZP348r732GpIkGZpHpPPozHVwu91cdNFFLFu2jDFjxtDU1ER6ejouV2RTghrmsnbt2qDjAezdu5dbbrmFDRs2UFxczFdffcXpp5+ubRftOurx61//mvPOO4+33noLSZIYNWpUzOeHoijMnz+f6dOn665PTY0dNnjbbbdx4YUXsmTJEu655x5KSkp48skndcdG+l3occ8995CVlcWWLVuwWCxcdNFFEc/HYrEECeF649Trrz7fAh9H+t0LThy6reeg3W7niiuu4J///Cc9e/bsrsMIBIaRHQ4O3/e34z0NXZINag/9njaT8XzwH/c+a0vIWzyO7D91TWqxnKTQJ6WW/LR99EsJ7nPSL+UQ+Wn76JNSS+JppUGlpua2bxQjCYMqqkCYetZZ7du3CYoDF3/i700ImNLS9IVBlQCBUO1BqLtvHUzAyL01TOqRzSVPv4QlOf6kO5/Xy/sP3c+ih++nfNN6w8KgLb1n0Afy0H2GlTwqCmWb1vH+w/fz/kP3GyqHDBQGVU4aO4GiUWONnyB+p0y8hZceixz1MQT3wNv9/nCaD0R/AcTqmbfrrYIOiSlqH8No/QqTFTeHErPjvg6BBM5fb56qMHTKTyoZfHlZzP6J9emZHM7qR13P4P5u22qP8NGaNWwpr4o5H7UvYYeurcHS4RMhLMaWlsE5N97GR/PncvDrTbrCz4kQctMdc4glSjsa6/lo/lx8Bt+s9zmaiITEl2lDWZl5Gl+mDUVRFKyVu1k9bhCLS0/miUHBolffb3dznzKbh5Rb6MtBksyuqL0HHW4vz62qwOGOPKff/edLXN7IvVcX6PQeBLXPYPt1NUn+f9AuEJbbCsJf61Gc3mq/2eLR40CStC9HFp12iLenHKDJ5gnaT0P/U/lv7/C044jnInoPCgTdyr59+5AkiVmzZjF37lwURWHz5s307duXpKQkDh06FNaDbs2aNezc6e/v+swzz3DmmWfqCm+ROOuss/j444+1Hn6BJcP19fX06NGDzMxM3G43Tz31lO4+Jk6cSEVFhdbrD/yCoNvtpqKigtTUVC699FLmz5/Pt99+i91u191Pc3Mzhw8fZvLkyfzP//wPp512Glu2bIk5D6/Xy8svvwzA+vXrOXDgACNGjDB8DU499VS8Xi/Lli0DYMmSJVpZstPpxO12ay7E+fPna9udcsop2Gw2XnvtNW3ZkSNHSE1N5cwzz+SBBx7Qlh84cIB9+/bR2NiI1WqlX79+KIrC448/bug6RqK+vp78/HwkSWLFihV8+eWX2jr1eaT2qFRLd9VSX4fDAYDD4eCbb74xfL3A72YsLCzkl7/8Jffccw9r17a3GHrzzTex2+34fD6tVDuUWbNm8eijj2oiqzq3+vp6cnNzNYfmp59+qm2TlpZGY2N7FUrfvn1RFEUrw3/ppZfiOgfBiU+3iYM333wz559/vu6TUyA41igeD1XXXBvsSjuB6FfvTyV+4Dkvt74f/KHw1vd9PPCcl0cXesnbbsJyKPjjrXvrThybNsWv4kQg0H2YZA7+li7wcc7d/+cX4YDUqVMZuPgTcp98IqowqBIk4tEuKJpsNnIe/AdJw4YhNzfHFtw6KhBKEmlnncW4BU9FFQZ9Xi97Nq4L+/DcXka8Pvr8dHA01rN325dhy3WFQRVFoXzTev/xYlyTSOKj2WJh1u/uMSwQqkcxKjc32TzUpbloCHGVNaT6lwd9SAZcbQKV/aAxZVwVtJwNwcKa6obqiDAYS5BTAGf/QSTOuhlvr9y49h+KXlCISjzCkFpK/NLFN/Ph1EuC1n049RJeuvhmnrn8durTM+Oem9Fr66w31pc0sK/d8cLRWM/bc/7X36cz5LVjz0mjYWAv7P2CQ3BCQ25UMTaea2qU7g7aKf8kh/KPcyOK56oz2YhAmH/IhluysrmXP1l9S6/RuCUru9d9QZEtkWE9bJyUEuzY6M8+CqmgLwcB/xdMA1KrefWLL6htDnccqCEjT68oZ+HyMp76vCxIKDzc5GTl7uh/x1X3YCCBPQpVzJKEKeBvhJ5AqAD5I8cw8/a7cMmECZcOt5cX11Yz9ebZFI8ehyek7Yf25YgkkTuilFeST0cxKAxCu3tQIBB0D19//TWTJk1i+PDhjBw5kiuvvJJHH32UdevWMWTIEK688sqwz7ITJ07kD3/4A0OGDOH999+PKOBFoqSkhD/96U9MnjyZkSNHamWeADNmzOCUU07hlFNOYfLkyREFt549e/Lhhx9y//33M3z4cAYPHsxdd92FLMssX75cC66YOHEiDz74IOnp+mFvjY2NXHTRRVp4icfj4eqrr445j/T0dLZt28bw4cO59tprefXVV2OWxQaSkJDAv//9b26//XaGDh3Kq6++yvDhwwG/IHXfffcxduxYRo8eTUJC+98ui8XCe++9x/PPP8/QoUMZPny4Vqr7yiuvsGfPHkpKShg6dCgXXXQRdXV1DB06lMsuu4whQ4YwZsyYoNLnaNcxEg888AB33XUXI0aM4LnnntNKxwHmzZuHy+Vi6NChjBgxQivt/cMf/sCYMWMYN24cw4YNY/z48WzdutXw9QJ4/PHHGTJkCCNHjuTee+/loYce0taNGTOGc845h0GDBpGRkcFtt90Wtv0f/vAHTj75ZEaNGsWIESO4+uqrAbj33nt5/vnnGTZsGHfddRdntX02A/jxj3/M1q1btUASi8XC/PnzueCCCxgzZgyeKAGRgu8mkqIYbfxlnNdff52//e1vbNiwgaSkJKZMmcKIESN0ew66XK4gm3BTUxMDBgygsbGRtLS0rp6a4AdK82efse+mm4/3NAxR3gfu+kW7sPPAc16K2lto4O2tUPNn/ZtxVwSSqMeQkxS8fRV2XdoLpy+RJLOLYdv6kvfrP2FJTMdmK0TxeLCvXEnq5MkxBUE99Lbv6O8q98kn6BHwBy0onCSkfDmWuxH0+/4B/jLi5Us6JAxGcqBEFQa76BjxHKsjwmBgKXEk1BLjePcfSFeVXyZntXLKTyq1x7veKggquVQTcXv94s/ceObJvDf3Piq2bAzfUSdQS4njCSw5nNWPly6O/fq46s0n6HPkYNzzMXptjcx9ryuXvq4aWkzJ2OTWTnZD7Rx9B57MoT3tPS3tOWksmPl77bHqbAtl1QfjgsZd/9q89uCXThItaCeQjrpiDb9O2u4ZA6++kMv/+7OI+xxU2YND7olU+87093yU4PIBHi4uNDHq3FkAlDtcTFy3Q9sm0nUFWHRwHo9cMUt7bHd5mTBnKc1OL4kWk+YO/P2MU7TS2iufXRdTHARItJi4bdpJXD2xAFuChXmffsujEUqRzZIU9D2SSfEx/dAnFDoqKbMVMOba27j29IE8sWwPD36yK2g+6rIbpvZg1vCevPX6o7yZvk7b1+StmWS0JFB86kjWn3Q5n3yx33//C3wxKNHvhT0Szay5Z5pWhu1we3l9fTWXjR2ALUH0IxR8N3A6nVRUVFBYWBhW9qmH50grh+fG/pvbZ3Yp1qz4qz86ygsvvMC7777Lu+++e8yOeaJRWVnJiBEjaGhoON5TEeBPJB4xYoSuICj44aF3r1VL843oa13+rqK6uprf/va3fPrpp4Zu/nPmzOHPf/5zV09DIAhC60UXJaziRCG0xDj0saVWIvv/rMhJCr6eCvW/bncZdUUgiXqMti5I9Emp1ZYPuP5x0nqO0B5LVmuQIBcvetsb6RsYvBO/2Jc6eXLYvsP6G8YrDAb0/Xv/4ftRFJmKzR0UiI6FMAhaMuvOjesZMn5i2Gq1DO79h+6PKHAafQYpgGQy47EYC7HxWOROCYMQ3jOvI6KJKmoFoj5W9ykBNrmVb197knc29aZq66YOzjjyPDqSwJzgMeYkMzoukHiubdS+dnU23P0HkXjOT7Ef2oOn70Csq1/Hun/HsRcI215359x4G8/c9ivczf7yGG9y8NufVvTfr4SOC+3z2Bm6M2gnrjLlttYFze5mpP6gRKgp2T7AhX3P+MDN+KAmmXuu87eC8LhdVH/0Htcn2yhIfoRknBGFQYAd+w9hd3k10ctf9ut35QWWDS9oSzhucXkNCYPq9n//eBcur0yixcyTOr0GAaxmiVnD+1NV52BgdioWs1pnfD32A7vo1f8UxhT3DnIeqonLAAs/L0OyHuG1A3fx2gEgxJyzcoQqJB/ktvxL2VMX7D5tPNrKkRpH1HNpdvl4c2M110zyB5iooSpOr0/0IxR8b7FmJdNndimKK/K9S0o0H1NhUCAQCL7vdLk4uGnTJmpqahg1apS2zOfzsWLFCh5//HFcLldQX4a7775biyqHduegQNCVBAlFJ7hAqJYYtyb4hcF+UUJplZDqPm9fBZAxOaUucRCGBpwcmfsEafc93SGXoFHiSjWOIfaF/t7jFgYD+v6Vb+qAUzBgnpHcfBVbN/lLHrsQuymZZc0ZDIk6p84fRwKQfVi9xjpUqOM6e+iOBjXEK8hJQF5LJVVbKjt0vGh0VBjq2VjH9a/Nw21NoK5ndlBp8flL3yCzvoYEj7tj7jZJomfvEmxpaVRs3YSRgmC9vnZFI8cw63f3gGRi77Y8ck5N54OyD6jYH/+UOkVAGMlH8+fibm6iPj0TlzWBJluvoKEH8JeNq4LWIfrRShI1tn5B49Q+jx2+xgF0R9COUfE7DEWh5uvtTDncm+Uja3UFQnf9RJCD/+io/QNvmjKQ3etWs3Dx15TlFjHntIqYc21wWbVtVfFN73bf7PQfY1Nl7IT2UBZ8sRaP4kQxJYIvPPHT41PYureBsiMtnDUoO0RsG6H99KcPN2jpyM1OL3OXrkdRwO70IiUZ+3JkQk4y1w0bHbRsfUUdVzyzDo8v8mvNapYY3N//Tb+eSCnSjAXfV05E4e+aa67RUnq/SzzzzDNBvfZU5s+fz+SQL9djUVBQ8L13DW7dulX393z11Vdz++23d9txa2pqdENLzj77bB588EHdbV544YVum4/gh0eXlxU3NzdTVRXcDP3aa6/l1FNP5Q9/+AMlJSVRt4/H9igQxItWanqCC4TRiFZWHEhXlxirgmNo+W53EbEsWMWgC1Ddl5Hy5y538bXNs7NlvvGiAHtTC/nrYw+SHtIDrCuPF+hTVRM6G1I9AW6ZtrI6uxW3L5m+LfJxLS0NLSWORGiJcXfQFSWloSXGHSkl7lN8Erb0DCo2b8CWnoGjsYHCUWOQkAyXzocmLc+84x6KS8fzydPbqPjyCJn9a9j/zb+CtqlPz0TOMJEsOch2H8bnNnfICRoZiaLRYzn/N3fy0fy5lG1aR31aL565PPab+ms3Pc7zo2+JOa4rSow7UloebV9dUaa8dHQN1X1ag5YpvgTse+4GOfx1kZZkYfXdU1n0yAP8X91g3KYEsm21JJld9Es5xA3DXtbGvrzzGsrre+P0JVLjyNa2fXF1JXMX74p4S0pNNCMr4HCHi+omCYqyUjCZ2u8u3x62I1mPkDpwrrbMvmc2iidcIAw9j1CxbUdtOec+/BUoAX87TK1tiU3JYceJxH/Of5dBWcVBy174ooI/LdoeVNqsKAqhWuGfZg7mmkmFQeXRkgR3nnOKcA8KvhPEW1YsEAgEgvg54cqKe/ToESYApqSkkJmZGVMYFAi6m5gOQkkKEkykXr1Qjh49hjOMjb902Oi4LiwxliRSp4aX73YXUR2EBoRBn9dLxdZNFI4YjdlA+XO3CINAco+0iOnE0F7ma/TYRn6rEpBnr+C5v/yZm//8f+zd9qX/OlgsXepUDJxHmkP/95Bht5LZlAhEbu58rOgOp1ZH2eU5iVdW/pREq4frx0F/qf0b4arPcnDWW2MKQ6Glw5FKievTM3FbE8LcbpLJzOGy3RSOKiW7aCA15f7Sy4rNGygYEbwsGoFzLBo9loIRpX5h8Ct/CWjtvgyQbKA4tPkEinT+vnTVQMd7SIZishZhTT6XDx97UAvyMVoS3ODNMDSuK0qMo5ZnxylQd7pMWZKoym5hX+/WsFV6rkGVZqeHPz3xBgcqPLjTEwCJGkdv9O5UFQ292dvcXh3S7PLyz5XlPLeqIuqtzx6ltFABLhqdqzkQJ8zx/22XQgK1JLMLJeB7NRPBd6UmZ7sLMpCX1xwEJeT+LSehOmsVTxb2PbMxJR7ClHiYpOxPg4Y6a85GcfXljY3V5KaagnoFlhb04ufjgxOet+1vZGt1ezrkiAHplBb0wu7ysiAgVEVRhHtQIBAIBAJB1yHeTQh+cEQSCM1ZWRS99y7VN96E86uvSJ06lZwH/0H17Xfg+Pzz4zjjYEJLfTs7zhBxuPS6ko72DdQLE4kkzgWN72JhEKC1qZHdWzfr9v9TMSQQShLSgMG0VJdhU5yGBEJf5dc885vraW1soLh0PFN/fRlZxUkMnDSIPat3dvhcFcCHCTPhTsDQEmOjJcfHgsCeel3h1OoMvWx1JJmdOLw2/ru9husCasB9HgwJQ4ElxpHKXEOFuEC3myL7BRe9PpqVW/3LehcOpKXuMI6m5hizUSgaNpTzf3sXS57b6RcGFVAUH17HfzVhEMJFtcB+fx3pr6eiiqCJSl+yvZPYve5lZE+7mGK0D2NSS7g4pkdH+jpGQq88u7P7iGtcm8P5out+xq+V4BRhh1vmqgV7cUcoM1eQeP9QIkra8ICEeP9/nb5gQbHVG/xYUWDBsj1Ry2pjESiSPbOynBbfIUxJLkwJNUHj1MeKLxHFk0XvtEQONwULiKFim93l5Y11DYQLnVLYMtuAf6GHKha+cfhl7F/MxumdpAmQJTnp3JczVBsbKG6qlNe2UJCVwj9XlOP2Bn/JEljWLRAIBAKBQNAZjok4uHz58mNxGIHAMKECYdKwYeS/8Dwmm42CV/4VVIKa9/h89t5y63EXCM1ZWfiOHAkKJPH2VWi4tv3DdMbzZiyHpC7rOQgcN2FQO3ycfQN1w0Qeup8hU6ZRPHqsrkjYHX3/VFqkpNj9/4ghEEoS+SNKWfFtLXkGhEFtM6C1sQGA6t0rWL/heQBSS2Cg8mO/QNgBJMAcwQmY5rBy0fL+eCwyVq9JcxQqQGJI+enxoCudWh0lIc3NGRdv4Aw2APDy9ouDByjGX7uxylpDhbh43W61FYHOwci+VZvZzYzLfqwJg4rsw+cpx+f6BsVbDrSXEjf3ygjaNrDfX2o/v4gYVzltcgrewaN4Zsw52rJfvvEWGZ7gEtto/RovXP0a2Y6DWFq9pO5v4vrD3dTXMQLRw2ASgdh97aKJ3wfXnETTAS8+tyn8usZoffDCFxU43EpYqq8fBZ9Pxm1K1P2yocaRzd2r7iXJ7NJKicPm7ZMx6nI3SWAKmYSi+F1/r6ytYsEXa0mJUOKbnPNv7Wf7ntkcbgovMQ51Dz65bA8eA3p1qEsx2rhobr/AUBaVZpeXZ1aWs0AnVEW4BwUCgUAgEHQV4p2E4AeLKjqF9qILTdDVEwjNmZkklpTgWLGiy51m0FbOXF8f5JTLefAf7P/dbOzLlgWlCQdiOSSRUN2FTq3jLAxq04jwuwolYpjI5vWUb15P0eixzLrjnrAPwHklw7Gl98TRGH/D+1jYFCffvr6Axonh/f9C0RUIJYmiUWOoOOIgr6Wyw4XiZmvIJ1xT7L6V0Yg2D70S48SQfmhdVT7aUbrCqdVRTCHuOJs1OK3UbJVJzmrtlIiquujUAA2VWIEaof0Dg5EIFwj9jx2+BF568HU8nAcKuO2LNFFQnU+kfn9PSrdpPz808RZOoRIw9hxJTElh6v8+wpx/fhO03CUd0h0fSdBLP3CUjCNHY47LrK+Ju6+jUXTPVcoHs4TiNfbaj3S9zvvV/ax4/qO2L02Cv3iIJgyCfulrIE6nm7e37EeW9F9DeoJgMOrzSv05MmaTxEWjcrGaw8dV1rXgUZwYecWElhgHEphG/NSKcv1BISg+/ZJrvXFNHn23X6RQFkWBJ5eX4Y7grhTuQYFAIBAIBF2BEAcFP2hChcBo4/Ien0/T0qU4v/mG3jfeiGS1am422xln4PrmG3xHjnRiMhKpU6aQftGPSZ00if13/j7MKZd+0Y+xL1umbRJaOtypUmJJwtSjB3JTU/t8TgBhUCXW78pIaXD5pvW8//D9YQLh3m1fdoswCMH9/37zt79GLW+GEIFw41qKRo3BK8vIVds6JAxGSi+tO7SZ5KxjV0bb+9STgHZxsDPlo5HQ87VJZguKz4vJYkX2tqsB0Z1afgpGjqKmvBxHm/uys0T6XfzkpI+CHuslJ8dDNCEu0AUXGqgRGmihf+xwYVBdbq/fjWRZ5F/jDRZVjDoW4ykxNlmsTL7vMd56eRXJKcEusLpMv1c3oghqsF9jSmKLoXHdhtQK3pq4X/uhYneSrafuFw+xhEEIL30N5S8vL0Mm8pdSgdIfBLv/ZEVBVmQI2l7v/u0f7/EpDOrbg2smFQattbu8jPrrpyiScZEuEqp70OdT8MmRvvwLvtuofQcls7+cOdCl2Lr/p8jubK2cGfTdfnquQZXQcuKgmQj3oOAHgMfjYc2aNUyYMAHrCfCedMqUKdx222386Ec/Ot5TEQgEgi5DvIsQCAwiWa2kz5hB+owZ2rJAN5vi8bBn+jnGBcI2MVABWpYtCxPi9JxyPaZMIeXMM2lpEwgDS4w7VUoc6E7UESVPdOLpGagnEBaOGE1x6fhuKy1W+/+9M/dvzLrtD0EBIYFUHGmhpe3DYdFPbyS1ZBwHNqyk5pvNHRYGI6WXdlaAAmNeH1UQU0zBTi5VIOtKcVJvHorPizU5BU+rI2yddlxTaDSButjCNQ8v5MlbbkBpbepUvI/RJNlQOiKiGhXiQseFHiv2scOvSKgoqGJUVEumvd9dLDdnXUoa5+w6CGOLw9Z9eOYUYAqgnypspF9jQpqb0y5Yx0DlFlpJYv8H2fRWJIx1JOwaFNnfJy/e5567KQH7tos448qfk5CYhs3mF9MCv3gwIgzGwu7y8ur2ZojgGgS/7JeDhBkJS2YyJ/XvQa8U/3Ov3lnP4srFKF4bipyM4tVP0cvtMYAkSyIDs1MpLegVtv6VtVVtAlp8Il0kFi4voyArJfYFCEDxZOm6EWV3NrIzJ2hZaPlyJNegUZqcXt7cWB0mmgoE3xe2b9/OZ599RkZGBsOGDTve0xEIBILvJUIcFAg6QaCbTbJaGbj4E6quuRbnV19hzszEVxehJ1WAKw/QLZfVc8pJVisDHnuU6t/8Nkgg7FQqcYhD0Ej57olER8JEQgXCULdedyABVVs2aAEhBaPH8aM77tY+mFccaeHMucuDtilsqeCCmujCYLQy0E6nl0ZBATw5g0BWsB7cqTvH7hYnQ2mwpOM2WUmQPWR429M+3a0tEf1uMmCS9V055Zs38OETD/PygEv58Z5XSJFbO17W3UGnZEfKnY0Kceq4SI7GrhRwVTFOzjBR3yuLd8Zdoa27SXmE/uwjGSe+1T52HSwwdMyOiqCBc4qG+jvri7+M2O1S6DtwMihQsSU8xKU7iPf5lmhLweVoobh0PBfcFC78qfe6sk3ru2R+b26sxqlEfo5KgA+4iEQulhJIG5VP2tT2EuWlVUtZ4Xov5nEWXvBvBmcObl9QVwau9pCc/fsbtJ/jEeki0eT08tW+xigjIv9mQl2JkVyKgW6/NzdW0+z0Ypb8Pkv1HiVJEj5ZiRAF086IARm6oqlA8H3hm2++0f7bleKgJEnU19eTkZEBQFZWFhs3bqSgoICCggKuuuoqPv30Uw4dOsR1113HvffeG7aPt956i7/85S+8/fbbVFdXc8stt3D66afzxRdf4PV6efHFFyktLQXg5Zdf5sEHHwRgwIABPP300+Tk5DBx4kTmzp3LxIkT+f3vf88rr7zC/v37ASgqKmL58uWUl5dH3bdAIBB0lhMnRlIg+B6gBprkPvkEAz9dTP95D2PKzAweFCLGqSKgUSFOFQhTp05Fpzt8RMxZWeHjdUqH453P8cDn9bJn4zp8Xm97mEiclovyTetZNO8BfF6/U0/90FxcOr47pqyhlqhWtgWlqMdv0Sknq07OxW6KHJKhim+n/KSSwZeXkZAWLO50Kr00GpLEwNLx/O7+v3Jq/7SIH5PjESebbB7q0lw02TrWC7HBks7LA37Gv3Mu4eUBP6PBkt4+3dDpt/03ZgyColC1eQMT9y3htQGX45Ci94yMRjzX+OD6LHa9VdBh0VQV4q568wnOX/pG0Lrzl77BVW8+obnpAp9DgYIt+AXcSM+tSCSkuUnOatUd37OxjsyqWnpUN4SsUUjGSV8OYj9oo/VIsqHzjlcENYp6Dnpi6aG9q2iV6rGk9Ihrn8cKl6OFvgNP5rxbZ0d1BG5f8RmLHr4/6B4YDYfby3OrKnC4g8cOyUnHEuWdpBk4HwvDMKNI4LO7tX3tPFLBbctvM3hmAdSVwfxR8PQZ8PQZ2J86h3e+qg0bZlSkU5Gk9vtBerLR787D/+6oJcYtFbdi3zM7oktRdQ9Ce1/Hy8cNYGhuOrICQ3PT+cnoXEN/5stqmuN2OgoEJzJ2u51PP/2UTz75hE8++YSyMv8XjXv27NGWffrpp9jt9m6dR0NDA2vWrGHDhg08+OCDmmCn8vDDD/PII4/w2WefUVzsd7Hv3LmTq6++mi+//JJbb72VP/7xjwBs27aNO++8k//+97989dVXTJw4keuvvx6AadOmsWTJEgA+++wzcnNz2b59O2VlZVgsFvLy8qLuWyAQCLoC4RwUCLqYQMdf+rnn0uOMM6hdsAD37t3Yl3/eJeW6QQm+n30WlmybMmUK6bNm0vT+IuzLlpE6dWp7ybA6/gTrKWgUzSm4cS3FpeM579bZ/pLgOJyDKmWb1rFo3gNBpXWDTz8LRZYp39w1zppQAj/nlW9ez/sP3c+s390TNs6k+Jheu4QU2V/EqADNNk9QCnCsMtBo6aVVS/vjbIjSc1CSsKVlhPdiDOhTVrF1E+VRHEhGBbGjJoW3p7TP7aLl/XVDTaLhNlmjPtbDmOdWochRyQDPGuibBwe/1Vw9xiIU2uYT5XfhrOxHUkF7yIXxZ7F+OTQYD9ToSnepsZ6F4WLdk5K/P+JDyi1xOSyjpQ+fv/QN+rgPkCw5yFDqcevEVOi5bo25XSs4uqcYDEVfHHsOle3mo/lzdUuG9dLcQ++Bejz/RSUPfrILp9cXFHyxvuIoUdrh4QNyMXMyZnyyj2arg1fb9nVNU8+OnWCAY9ChJPIbzy00Ey7cB/YBjFRK3Ds1kZ4pVgZmp2qlzh6fwntb9oeNjYdI7sVQVPeg2tfR7vIyYc5SAMprWzjr1Gwitj0MoNnlE2XFgu8Vzc3NrF27Fp/PhxSgkMuyzNq1a1EUBbPZTElJCampqd02j5/97GeA31FYVFRERUUFOTl+B/J9991Hnz59+PTTT0lKar8HDRw4kHHjxgEwYcIE5s71J6gvW7aMGTNmaNvfdNNN/OUvf8Hn8zFt2jTuvfdebrrpJiwWC5dccglLliwhMTGRqVOnxty3QCAQdAXCOSgQdDMmm40+v/sdufPnk/vkE10mxqkCYepZZ7U7AtsEvwGPPUr6ueeS+9ij2jFNNlv7ePhuC4MBH2w/mj/XLxCOHhf/DhWFso1rqdi6Sdv3oofvBwmKRo0NGlo0aixFo/3LbOk943JtRkMVCGVfuyPHpPiYUbOYIkd7QmmzzcPbUw6w6LRDvD3lAK6c5jBnU2JGuGvL3ZRA65FknA3BQoazISGqQ6to1Biue+yffidlwPMrsE+Z2qsx0rVQBbFdbxVQtbR/0Lqqpf01d5zDGSwieixR1IYQGizp1CRkUW8NFhrqrT2pScgKchCGYvQ3KAEJB3aQcPDboO3iLeiP9LsIFAYB+o89YsCxF1kYDCRW8EZXukuN9ixURb1ZX7watLyVJAbOrDbsUlT31efIQTLra4KW93EfYOqMFUw8Z6PudYzkuu3OUvxjhqJool+gKzBSmrve2EDUfnjgF7PU0Ay7y8uC5XuiTwV4BRcOFEyYqC1UtH29sa4Rxdc5gfUp7/l8Jo8i0ttZxZOF7MzRFQYH9Exmwc9Hsfj2M3jyitHc96Oh3PejoeT1suHyGb0Hde7vgNorUCUwlKTZ5WXZrnBHZCCZKVZO7pPKeUP7irJiwfeKfv368atf/YqsLP9rV2m7Z6n/zcrK4le/+hX9+vXr1HHMZjM+X/v93Ol0Bq0PFP3MZjPegPvkuHHj+PbbbykvLze8TSCBoueECRPYtm0b7733HmeddZbmJFyyZEmQOGh03wKBQNARhDgoEBwjuqNcN0ggJFzwCz2mOr4rRcpjRbQPtqpAGCroxUSSKC4dT17J8CDRsXzzhiCBsLh0PLN+dw+z7riHC+/8H79oNnpclwqEW55/hKKWMiyyJ0wYhHDBrP/0/WFloAVRykBDxZ2YYo8SUGrdJrwGCoMVR1rYcbiFop/eSPaQUVEFwkji5GGHhYMoNKQGW2waUo2VGAeWEi/Onha0bnH2NN0S4xOBeEqMI4tQxsSLwBJjvWAOowJutDLfaGW4eiXG9emZuK0J+JzB958D5FJBIQ294neUhYqeyVJwAE0s4VJ93G2l+MeaENEvam/WGAJhqGCllsL6l0cWSSX8bzLtwIe4+G/GF7xf3qLty+GScddPaJ+GbMV9dBKKbA36GSDFGl4ya1eSWOibpW6NhBe/HKn+CybRYiI92cKkgZmMGJBBdX0r6yuPBu+zk8Eg0ZCkgH9ty0oLemqiniq2Bvx5Y8vehqj7tLt8vH3TJJ68YjQlOSfWfU4g6CzZ2dlcd911uuuuu+46srOzO32MgQMHsm6d/73f22+/TUtLS4wt2jn77LN57rnnmDlzJps3b445/swzz+Tjjz/mwAH/e7eFCxcydepUzGYzVquV8ePH89e//pVp06YxbNgwtm/fzvLlyzkrpP+4QCAQdBeirFgg+I4Tb4iIXtDJiY6RD7YfzZ/L+b/9PR8++g9jJcFtLrjzbp3NR/PnhomO5Zs3UDRqDDPvuIfi0WO1kruBpX6hbObtd/H+w/dHLauNhyPbt3A+0GJKxhYQfNHUVkocKqAd9vidY0kS9LaGf5KNVmJsJOyhfMsGrdzwvFtns+7d/zDuR5dqwmBgeIpJGc2M5LowQVNFIVxMCS0lDmTliHYBK1qJsZHS4XjGHSvcTQnsWTSAgTOrY47tChEqVvBGpOeC6i6NRryhM/XpmTxz+e2645+UbvP/MANu/ngOGUfrDfdcDAw8SZYc5FiCn1uqcKk+/6OFr3S4FP9Eo+3e+P7D94Pif01HVL0CBMLAEuNQsUxR/O7Bn4zK1RyAkZCAc7FgRaI5dRsv9H4bz7rh7fsC3HVTSOi5Bsnsxn10Eu7aGSiyBZC0n++ZUUqLp4Wqpiry0/K1/b/om4474G3scKkCgK3KQFT5bVhuOjsONuHxKSRaTHxxl9+Bo5buPrpkNxePziW7h9+NExgMon7fISuKodLeSJgkmDaoD9lp/p6HXp/Cnho7A7NT+fn4fE3UiyW26uHyyryytopfnRGc2O1we3l9fTWXjR2ALUG81Rd8d6mqqtLcgiqKolBVVcWpp57a6f3PmzeP3/zmN9x7772cf/75ZIb2CY/B5MmTef3117n44ot5+eWXo44tKSnhwQcfZMaMGYA/kOSf//yntn7atGksX76cSZMmIUkSY8eOZdeuXfTqJVzBAoHg2CDeMQgE3wO+i4KfUQylEccrEEYTBgP2Wb55A5Jkonh0BEdiN7hLQoXBSALav462N9f/Y9/WMIFQT1SKS9BoK7ku27Se7Ss+o2zjWuqq9zLz9rvCwlNkyczH2dN1HY8KfsGTJoLESYfBixetxDhBNhZeYnTcscR+IDUuESpaKnVnMVms/PKJ51n6wn1Apbbc5zbH7KsYbxmu0YThfufUUUgFexYNwH7AWD+pPspBBs+ILVTGWr/9tWJdUdSIWHrCoSjGv8DQEQgDXYMqzS4v97z9dZCIpqDgk9Xngr8oRUaiNmUnR/u+w+GEOlxHpuBxh7zu5UTc9RNI6LkGd90ZgIL7yJQ2J7KCu24Kc9fNQTL7xdsPfvwB+bS5Br2zULQCGIkyJafNT9v+bN15qBmPT9Hm/dKaShQF7ZxcXpnZb3zJS7/wf+mjBoOoeHwyb2/ej+zr+M1eAUbkZWi9Gp9YtofXN1Rz1qBsTRg0UqIdiaqjLTy3qiJICAzsEXnNxAIhFAq+s+zYsQOAvLw8zj77bBYvXkx1dTU7duzoEnHw3HPPZffu3drjv/71r9rPlZWVQWM3bmxPqV++fLn285gxY4JKi7du3ar9XFJSErSfK6+8kiuvvFJ3LnfccQd33HGH9vjVV4Nbb0yZMiXqvgUCgaCziHcJAoHghMWQMKhiVCA0IgyG7DPUTaPOq3zLhk6eoc70An422nvPGTD9yqX9cNTYOi8gSRJFI8fwzedL/GXWoLmQXIMGYklsxCfbtF5eegKhApQn5yMpCoXOvUFzshpMJbZ6I3e/yPA2cmX1q7hNVuqtPYNKi6fXLKGnp54E2UOGtzH+8z8GGHXsGQ366AiJthSum/8syampXHDLA3y76TRWNZrY/cE79GmqpSI5H0WWKXZVa0EsgcRbhms0OTgZf9+ngTOrDZ9vV/UBjFRifKxKibtTCI5JQB/WvkNH65bYKgqsLa/jp2NysZr9r896Zz2LKxfjc/ZHduahRvZsSThMUkIdii+hTfwLxYS7borfLSgn+rdTEkFp6+jZJh4mZn0OQIvHX/L3om869pAQkmbChVt3QFqKosCC5WUoihJ0Tiu+PULFETuFWalaMIjKE8v24O2MbZB2t+VVEwoAgvo3XjWhgNRES4dcgypvbtyH26doYTGhPSJdHplHl+4OC5MRCL4L9OvXj969ezNx4kRMJhPXXnstq1evxhIlQEkgEAgEHUPcWQUCwQmH4vFgX7mSw7ZEyjaujWND/wfbvdu+ZNbv7qFs0/p2castodmwMBi4zxCBsGLrpvjmFSdqKbHLakwcTApQbCQkzAk+EtLcHRcW2oRBJNqvHYCisHXHF7zd5w2Si/yL7Htm6wqExY5KvzAIFDr3holKaQ4rFy3vr5VMB5YST96aSYbdqqUyRyOS8NfTU0+2+4h/2hDmZuyabpFdg88TXYQyGvQRL+bkJE0YBH+PyQEjLuCxOUtpSf4x+dl7qU7O5ZyaTyNes3gTsQPLf5NmKO2lxMBNyiP0Zx/JOOlL/InKXSXeqfuJtxS/K+hOIdgQbffIwhGjWbgy3DWo4vD4yM9M0cSm7XXb+fy9/2LfczeBkT2exlEk9v4Ed/3ENvFPBzkRz9EptLfBDvxCwBRUegxgd8shrkFt8jFPr9mpfz7XPL+BWSPTOHNIIkkJ/v063DJPLNsb9ifCLEG8RkI916K67KoJBR12DQK42yazYHkZF4/O5a63vtbOs8npZYGOGCkQfFcYP3580GOTycRpp512nGYjEAgE32/EOwSBQHBCoXg87LvtduxLl2I76yyKR4+lbHOUXlmBBHywNVssnDxuIsWjx/rdhxvXaoEacYt7AW6agaXjtJReQ+JinISWEk9fl02ixxQmoP28l4s+1vCeg3p93uIikjDYRqib0WxyEPhxWxUI8x17ufGMQqrfWBDxUJGEvwy7lcymCEJCBEJLh9XHCuAw20jxtaLWgUsmM8hdI7B1BRb6sP01wkQo1UEWrT9eZ4QjX6uTTxY8wszb7wKgYusmPm7IwO7yokhmqmx5zKhZTGFrVVTZJd6ehT0b66AR6j7uDee2L+/PPgqp4Mi2DChpX56U4UYB5BjnG02o3L86G0+rGUlScNYnGe4n2GlhzpQHcg3gjDkU4hOCk9PSaW2K4YqVJIpGjYndc7BtrHqPbPURNZgj0A2nik26AqCciKvuNDz1k4mcgWdqcwpGIMQ9+OI33jDXYGepqnMwf4mDhVsXYzK7sGas9/dAdE8Pm3dWj0QON7ni2r+ea1G9hmZJ6rBrMJBmp5fbXt/K6rKQ0KE296QqRgr3oEAgEAgEAj2EOCgQCE4YNGHws88AcCxbxsgzz4RRY2ILhAEfbM0B5SZq4m7F1k2aaBi3uBcgOgbu03DJcxyEim+JHpOuUNbHKjMgIfpx43aYRREGIwWjjHAuZWvS1LAS44qUQk4dOx5T2SYqN6+PKi6Flg5HKyWORGCJsTWglNiHiVf7X8pZdcspdlRSlpyPCYWC1nA34/HAZLHiaKwHgkWoeIM+OkpoX8mq1EKkrLORQLeHZDTiLcM1NQQ/19VS4qyShqDlkYJN3NYEEjzuoMCVSNciZ2JN0D700rO7pZ+gXIspaTKy89OowzoiBMe87UgS1oKhTLvl99gSLNHvVyH3zzfXVYQFcwQcGVnxu9IeX7GBWaPSKT96oK1sOPS1a/K7ApUEINL9yER011+7e9Dhllm4oV7HNdgVKHjqzgTFisd+MnJrPnqCZrzCIPjPTs+12OzyUnW0BatZ0nojdoZQYTAQRQkPYBEIjjWybKwiQiAQCATxExrgFC+S0tk9dDFNTU2kp6fT2NhIWlra8Z6OQCA4RgQJg4G3JUnCduaZbCnoE1kgVBT6J9q45OmXsCQb+4BvuJ9hBNExrn0YIFB80yuxdVllFo9rFzj0QkhCiUs4iiEMRgpGCSSwxBjgg1tPY/mOQ+x4ZT6FMUQm9fyNlBLHgxqI8kru5eS27mOQfVdMJ9yJQHJWK6f8pDLmuF1vFXRK1CoYMQqT2aL9zhWg0pYPChR04DrF2y+vPj0TOcPEkBm7g0qJI7HrrQIOeHKDEo+vf21eWCJzNHF111sF+Nzm41u+24aCQmKaJ+JcA4n39WzKL2E+E5h97mBumjIw8v1K5x63bX8jr2/YG7bbZredj8o/1B5be27AnHQA15EpuGvDXXZ+ZExJ1ZiTwu8hPmcOsnMAsUuCZRJ6f8Ivhl3BwqVHY59/hwmM4Om6BgRWk4QCuv0LEy0m3D65q03oEZk0MJNXrh8fe6BA0IXIsszu3bsxm8307t2bhIQEpPBvHgQCgUDQQRRFoba2FofDwUknnYTZ7P+SPh59TTgHBQLBcSeiMAigKNEdhIpCn8YWhu2t4ODsO8l9ZB6SNba4ZMj9F0UYDNzH+w/fbzwRVIdo4lugUHjJZz0YVVmPzQ29LRbkJAVPX4XGa9sdObrlkXqlhYFi4Kb1FI8ex+DTz2LRw/eHzcFoMEpoibHD7eWpVZW09p7GVdWvBCUxh9KVgmAgEpAit3LFvtdYmXkaRa1V3XKcribeoI94UVCQkNi77Stkb/tvTQIKHB0XT+MV2NQSY/siC8yMPd7nNuNOCD6GXgKyuymBPYsGYLF5sST7yA1wDiZluHE2+Nf73ObjE/zRhoSEKc7EZyPkjyjlL61jkF1KUPlv2D0vwj0uMJijqqlKCwIpb6zjs9b3go7VHjYSuWxYdmdjy3tW6xuobhfcozAafvdgUXYiQ3PS+Xp/d4UMqXPp2s6kniihJi7vsXVSfbGnjsNNTvqkCfeg4NhhMpkoLCzk4MGDHDgQ+8tGgUAgEMSPJEnk5uZqwmC8CHFQIBAcV6IKg9qgCAJhmzA4suowJsD+2Wfsu+32rhEIYwiDwfMzfr56GBXfkl0mCg+rH8ElZCR29OtJbw4DUOuRqHZLyA5LkNhWNGoMs+64ByCs/yKglVwDuuXWRst8J9du4PMeOciS/w/S4u2Hsbu8FLbuJUVuNbSP7kAVCCcfWUlFcn6HHHHHmniDPuJBCXjCBgqDKt0jj0THfiA15vnWJvahJSGFup7ZQduqjwNLjBPS3AycWa17rK4sy+4K5G4QgvcebaXF5AXMQb3mgu55AfeBSPe4qqYqLnjngqjH8jSWgpxMe9mwhAkZCfCpzyA5GU9jKQm9VkfYTsJ/Zwu9mUqA7F8uJ7PzgJNdh5sNXwd1DwpgSzDhcBsV4tSt1H/qsu4oZ/bTkaCTjnL7f7byqnAPCo4xCQkJ5OXl4fV68flOnL6/AoFA8H3BarV2WBgEIQ4KBILjiCFhUBvcJhCecQatliQOeFqDhEF1TJcIhAaFQbVMr3zLBuMnrYNR8c2eZGNLvoWRVX4xcEt+H+oTrfTGLwz+7VAylNQD9Vy0vH+7QNh2afX6LwIMLB2nHSNQOFAxnixcw5UXppJdMhpJgsueXuv/tZ4AzSskIEVxgvMwlV0kEHa3eBZv0IcRVGFQ6uTM4y0fNrovvfNyNiT4S4kvvl1na/hw6iXaz2qJsVGXXVclP3eGQCHY1a+FYRNrtXWVS/vhakiM+zrLVds4x2bn4+zpyJiD3IOR7gN6qI7BaJhtlVgz1gDgc/ZHduZzkqmcgeYqFqfYgsZF2k7x2pDdfXT3b0qsQTL751HbeJ4WsGGU4QMyOKVvKm9v3h/XdqowaUnfBIC3cRRdJQ7KNjOYTeCTMTn8z8HstCQONhoLruksq4V7UHCckCQJq9WK1cD7M4FAIBAcW4Q4KBAIjhv2lSuxL11qfANFwbF8OcOAfmk2ejc5wj+qdVYgNOCmUYk79VgHW3pPaKw3Jr61WjmcbmXNwBwSPF5q01OgSWL7a8UczXC2CYN+At2I5Vs2sGjeA9o5BYqBoextcJH/kxuoPOrAV/6VtjxmsrAkUVw6jjOmno7ZYuGFL9oDDfb1KKTCfvwdexKQqjixex1UJOd/J3oPQrhjzJrixed2d1iUMyoMRhoV2s+vM+670H2t+2wk9qR00nFpPQj1SokjoZYYd3dZdiziFU9dTVaOpMt8ld/MsMDlDYkdEoIloNhRSb5jLxUphX734NLN3DQiAYdH5vVvHFw2xIa5Zlv7Rok9ILM47mOZEmoxJR7BkraVlrLZgMI+uR9/S3mQFf16RtzOnHQAc7/3dNfNKbmRooIpweckJ/GjR3bGPb/yWjtnnNy7g4EfJiRLAyaLE29j5L8H8XxRINvMuCf31R4nrfkas7uVI84kILMDc+wYf3jzS174ReS/BQKBQCAQCH5YCHFQIBAcN1InTyZ16lRjzsEATECfJkfkAZ0QCI24aVTiTj0OpM2deN6ts/lo/tyIIqMmvgVs15jS7vZosnnwoNAQ4j5UU4XVgI+yjWup2LopqjBYcaSFM+cub3s0iV/2PEpS/b6gMbrJwjpOy9KCXvx8fF77QPmXeBYvIKE+XvdO19PXU8uHGdNRJCmuNN5QjpWwqDrLkno5KTpnP0Uz/L+T7a8V47Eno8jG3W+ddQxCuNuuM+67wG0P0Y/Hpt6rPb5txV9J2deMuymBhHS33uZhJHj847qzLDvmHEIEz1UfjKPFlRKWrByIhMTXxU20hnzb4XN3zKmmAOW2Aqps/tegosDCFZWcuel2XveezYuuS9i77p9cmvhh0HYpV7xDfv5k7bHTLeM+OglrxnokU3BSuYr76CTctTNw148FORGQcJDMa96zgY0dmn9Rz4EMzhyMw+3l9fXVXDZ2AM9/uhm3z0c87j0T/lTlhZ/HDnzRR8Jz9EyScp5HstSjePXFzrheVeb2+Zs9h+iR8w/tsTck1Kk7+aKsDrvLS2qi+CggEAgEAoFAiIMCgeA4Ilmt5D4yz1hpsSTFJ8ApCvalS7GvXEmPs84ytEksV53e+JihJio6ASCqmHberbN59je/xNFYry++6aEobUEm+gmvge7Diz7PYeSg07S+gpFocrjCHvdKz8DR2KAtCywx9rsZE6IGGgR+uH+95x1UP/VHUhTncXPsqaJJZUoBe215XFn9CilRglJOFNxNCbqinDsOYbCzqG64pIxgoU59HI/Ypu4rMWBfrQSXOLa4U7A2+Z+TPRvruP61ebitCdT1zA4qJT5/6Rtk1teEiW/dUZZthFDBc8HM32uP9ZKVFRT29m6lOrsVxWvivoNJJEng8kFJso/85vjufepz/OPs6Vr/T4BmkpmVdDGe+smAwguembyZvy0oJITlN/HBjz8gPy0fgPc2N+E6PBNFtpCY9Xn4sbQwEgUloCxYwcRbrvNJ9X0VvH+jpOcC8PwXlTz4yS4anR6eW3cERVcYVJDayuUVTf72LxmSayPRksjGynqd7QyiWHDVnRlRGDSKWkqspLbfJyUluIxYMrtQ9DXYLsfjU3hmZTm3TTv52BxQIBAIBALBCY0QBwUCwXHFkEAoSaROmYICtCxfbuyDsiSRetZZpE6eHHtsJ4g39RgIcif6vF4+mj8XR1MDoCO+RUrxlSQ8FmOCQVpBLufdOlvXDelwe3nisz2cflIvFr32BlCgrau3ZICzgbSeuSTV79NK59Q5KUD+qDFBwqDDUYHX14LFnILNVqh9uHd6fZx+cl/Kf/Q7eOf+trTcriMwMiDaGFU0AZheu+Q7IQx2pSjXmTkEuuECiTfgI3Rfh+hHK0kcIDdoXHNeBgCWVi+p+5siuu4y62voc0RfJIfw0uHuLiVOiiJ46iUrh3Ik4AuB5SNrufPAGGq+3m7ovhdJGPSvM+E5eiYoZkACORF3/YQw0W9Z9TLOHHAmmYk5vLGuAVBw100hoeeaMKHPXT9RcwuGFdfKibQeuJzknFcjug6jYXe1O/4e/2wPcpTEXympGpBQnHlISVWYk/zPyTLrBv4+aR6bq+rR29xikvBG2W/b3lFaT4q41khJcWgpsdlzCElxYvYEO6mlHkf8sSy+xGPiIFywvIzrJxcJ96BAIBAIBAIhDgoEguNPVIGwTeTLfWQegGGXobqNkZLizhJv6nGgO1Gvb2FEQTAEq89YeV1TRTUfzZ+r20fx4cXf8syqCp5YXkagMAiwOHua9vOV1mUcbXJQ6NyryQAVtgKSS38aJAyuWdu+zfBRn2gf7hcuL+PykX3J+exJHF2YUKJ+MG/pPRDL0QMk+hy6H9RV0WR5zgxevWYMu197kpqqqi6bR3fRlaJcZ+jKgI9QZ93vpMd1x71+8i+gzdR046J/kLq/CWgvHVYJfRxKYInxsSoljiR4Nvbvpc1ZFTslJPJqk5myuTfLR9WiBLysFROcduOv+PLZV8PuLaGiVKgwaDYFFpEr+GQfihJ4bzHpin4PbXyIhzY+xGV9nqfV3XYUHSGx3TWoTjj0lWfCZx+E68hkkrI/i34BdXhxdSV2lz9N2xdVwJOQ3dlt3xAoyO5sbHnPaue0plxfGARIMEsMzU1ny96GsNkbuUsZ7jUYUkrc6+CdusNsWa9BmyZoPwYlxi6vzCtrq/jVGfH3mhQIBAKBQPD9QoiDAoHghEBXINQR+Qy5DI+hMKjS0dTjzvQtjJUi3FvuCc2tpDkslG1aFxRKAn5nzmvrKgwdy9VwBMwplCfnU9xapYkQK1dW8vPx+dTu+JKs4mCX1Lubd2N3+YNRWpwunr/3DyiNnSjvC0WSKB45hiFTplE8eiwvriyj+ul7w9yAClBpK+DTPufg8Up8tWYdzds2dd08upETJXW3swEfgQEdgWNCnXWR8Ca3v34CS4yj9fELpLOCYIMlHbfJSoLsIcPbGLY+pVd7Km80wfO9iZdrPweWGEtI5NfYmL1/BrnjS8keNhiT2UyKNYX8tHzybr+L9x+6n/LN6wH/c7rFlKw91/Ucg+cM6UOvlLbzbqlj1favqPQVEeru03MPKr4EXlldEyCQhQuJ7a7BaCh4jp5JYuaquMqLJTmJhZ/vDrslmvHi05Pj5GRAJlTIVHwJbe5HfRweGYtJ4rIxuVgCBDyPT+btzftjhpjoCYq6YqGvPSAqtJQ44r67ucRYfd4cbXHFGioQCAQCgeAHgBAHBQLBCUOQQLh0qa7IZ9RleCyFQQDF48GxciUX3PI7Pnj8IcOpx3H1LSRcpIjkMkywp5DW7AWl7diKEiYQPvfpLsYc/JzlWWfEPL9E2UO2u4qK5Hw+7D2dypQCZMlMi9PFv+bORqrZQd6oPJIL27dZtXMjA1J74/ZaGVW5BdnRtenARaPGMOuOe7TrO/bkvpT/5C6URXORnM3+0wY8OYPJOO1n/NTkF03GDs9mzco3cHSlUNlJknqk42wOF52Od+puV6CXbqw6+VoLbRC9FSbgLy0OxIgg2FU0WNJ5ecDPtMdXVr8aJBAm2lL40Z3/y5avZgHGBU+9EuPar3dQ+/UOikvHh987Ql48NQm9/b1MA8T6wFLim6YMpCQnHQB75WZKt/UL30kE96C7fiIed8i9KER0C3YNRkJq69l3WkT3oCJb8TSMxZrhFz4vyJrDJ196NddgID2lBhrTdwdvr5jxNo6i/S1t+zm5j07GE0M331BZz6SBWUG9955YtsdAubFx56DJ4SNh5SEwm5DSnJAWexvFF0t47Rw/HpWDLcHMzOE53XocgUAgEAgE3w2EOCgQCE4oVPHPvnIlqZMn64p8Rl2GxwrF42kXNKdO5YK5D1L5zVeGU4+NCoTRRIrQ4JI0rxeUkOugCoQPz2Fk3k/46ItlnN28nQGt+3GbrNRbewaVEk+vWUJPT32QW6qotYrtPQYhS2ZMio+ftL7DqdNXtG1RGXS4K099Qft5+75i3HRtOeeQM6bhkuH1VRVcNnaAPwTl4tG4L3ieN/56D4f2fMvAEJHF5/WyaN4DJ5QwCOBsbsSabMPTGpzCHU/qbqA7r6tLZzvjYNQLUlEDQZJp4aFRt2gluE9Kt2njLt32IumH6rSeg8cLt8ka9bGr1cGK59/hzOs/4vNXFnC0YS9Mir3faOXQZRvXakI+wKJ5D1C+eYO2XgIKnXspT87nw+zpVNoKwnoMBvLily24lAiiZYh7sF34C8WEufFclJ5rDLgGA2UzCc/RKRHdg2rasSJbAInXd3lJsJTp3gaPKJmkZC3EZLVry1xHphAmUsqJuI9Oxl03Jcoc21mwvIxEi4mrJxYgK7Dwc/3jhxIqDEYTCk0OH+BDphdHT3lQ6zmYVrdQG9O6/6fI7uxj0nOw0eHh4UtHdOsxBAKBQCAQfHcQ4qBAIDjhkKzWmAnDRlyGxwJNGPzM74qxf/YZB2ffSfEj85AiCINVTVW0eFq0kkH18bDr/CWHkQTCaCKF4SATRaFs03p276ilrPdZFNkKKHJU6n6o7empJ9t9pH1T/KWLVbY8TIqPc2sWk2/bG+XqtNPVZa9Fo8ZSPHosC1e2B57cNGUgAAlJSVz2538EBb9AuzBYtmmd4eMkkAwSuJXWLp2/HqHCoIqR1F09d15XCoQdcTDGClIxJ/gwWRX6oh8mktlYQ+qecDflsUJ16dZbg1Nq1ceaaK4olG1cS8mZZ3P+r+fCwtk8pOgLnpGSlfUo27SO9x+6359wvnlD2D1Bwi/WI0lU2grCtk9JbG8fsHBTc4SkXwh1D0YT/pxuBevRybiPnkZs12AAiiWsfFn22nAeuBhfSyGg4D4yxZ9KD7i9sv5+AOfBS0jO/ReehrFYemyN4GD0n1PYFyQRcHll/v7xLhT8l1nPtRh0OhjsNaiHT8Zn7au7SnZnIzuPjZNvbXkddpdXhJEIBAKBQCAAhDgoEAi+wxhxGXYnQcJg2wd3b5bM0d1LcN97A0X3PR02p6qmKi545wLt8VNnP8WvPv2V9njBT58EggVCoyKF0SATUJAc5ZxdK7Mk6yyu2PcaKXIrCXJwg6vAxwpQl3kSH/c4E4AZNYspdFQiWzpW9hrJ5WbkQ3fRqLHM+t092F1ePvzgU0yWHBYuL+OqCQXaB12zxULhiNFBAqFe+Ess3LSSkzSQmtb9eOh+gTAa0VJ39dx5XUk8DkYwHqQSSDLBvdgGTqziaJWt25OYQ1GAxhCXbiBBQT3Vr5Lha6J49DjteXbm1bewfsM5utvGSlYOnoii9RiMhAQUt1bx59RNDL/6N5jM/ud/SqKFwqwUAN7cWE2zW8GED33JTQI5GU9jKdb0jVHLhRWkANEt2qs1dvmy88Bl+FpORusVqCSCEuvVL+FrORlX7Zl4jp6F135yZAejYkGy1KN4e+qv1+HJz3aDZIrpGuxMe4TAEmOT1AwBWmBXlBKbTRJWs4TTI/vnGTBZk+QPqVEUaHH7eHNjNddMKoywJ4FAIBAIBD8khDgoEAi+0xhxGXYHusJgb4WaP/sFtSOsAB2BsMXTErSfo86jQY9vXHYT7133LuAvLWzNyOXlnjN15xAmUugEJURCAoodlaQc+kALNcjwNnJl9avhwQuSRMHIMbzkKAWnlxk1izW3YbyiEUR3ualN8nU/fAcEvAA895c/M3Xf1xTYCvikz3ReWlOpuQebHU6e/8tf8FR8pfVvyysZji29Z1wlxSbM7G/dQ6LJRoapDw3ew4a37Wr0UndjufO6ssTYiINRpSPiZF8Oao67ZJz05SCNCQUdmWqnkAh36UbCbU6geERwb9EePQYydswnLHvxcfaX10DAyzdWsnKHUBRqvtlM+b8X6PY4LS3oxc/H57Hv6G6+qNkctM7nzEF25mFKqsJsq8TTWNoW7hHl96dYkax1KJ5M/K9W9RUbXEocRkD5suxJxddyUts2qhBp1Iko4Tl6BqC0iYuRBUrFm2Fwn37sbhkiSKhdidnhQ8EH9KLFORtMri4rJfbJCs9fM4bF2w/FHFta0KvTxxMIBAKBQPD9QIiDAoFAECd6wiCAnBRsN7FvWcO+224n95F57G09QIunhfLG8qAxW2q2hO1/e8MOhl13OSVnnk1zr0KeeXpD2JhQjIoZ2jkADlMyfdw1QR+t9QTGomGllPc8h5ajh4OEQe3YEUSj1jbRKPSjeyyXm65A2CYMnnfrbMo2refLZYvxVX7tL610VHLO4cU8tczCVRMKSDbDM3/+s7a+bNM65v/tT+QmWXE0NWjnH839419vRm4TSVyyA0WBBCn5mJQYRyKayBpIoEjb3SXGeiXHHQ1ICS0xjnc/XdV3MdRFG4n+uf11BbkePQZy/q/nUvnyBySvPIBiljj98AoyuitIpa20ecXmzWQOKiHVbKbI5nehleSkc1/OUKqa0rjgnf9r38SXgH3P3YCC7M7GZD0CNrBmrIl5OLOtEp+jAAgUGPchO/sDkX5nJiy1p3NxUxObvUP4snP+O9pfwTLtImNoTnlXRiB1D4o7i9REM82xklNCsJgkZEVBLzflxdWVPHvNmC6aoUAgEAgEgh8CQhwUCASCOIjkGJSTFLx9FWo9Ek4FkiTI6OMvMa78y1XcNHCb7v7+s+s/YcvuXnk34C857peQYmheRsUMaP/IbGtzDEYjObEHpzRM4t6mI+Q59lLsqIw4NlTIkd3mIKEvHpdbJGHww8f+Qfmm9UFjVIFQ2vsRL6wooO/mNzVh0H/CCt7tW6kK3CWRpQO/zGBuc/a041b0ewIeLzoTEtIZ9ByMEC7MlX+cS9GMfWHbq45SdaxRx2ksurLvYqCLNlJQT1pKMjc+Mi9i6FCrD/5ZlYzi9AIKq5In0CO5icLWrk3thrZS6METuLwlATZ+C8DqcYM0gRAgPy2fDyY+yJ63r+G2vr0DegtKQa4+c7/3DB3Tmv5lsMDo7ItfGIz8ynKQwvOun7aNiR8TIIftX0ZKPIjiyg0Z3fGrbJL8W/s6Ns2YKCE/N7vif40O6pfGzkNNyDqTFP0EBQKBQCAQxIt41yAQCARxYF+5EvvSpdrjwFLiWo/E3w61l1f+8eet9Lb6qHZvgMPJYfuKxa8+/RUf/PgDPrttEmX3/Z1P6hp5M/98bf30mk/p6WkILgGOQeDHSCMfnVtdzXxY+z7O7GlU2fIoixJgEiYaNVrpn5BM0tAh7NuzOi6XmwK0mJJJlVsx5ZeECYOhSECho5L65/+EyxcueurNV08gVAAfJqRoZZUnCB0JCekqQkW3UGGu/ONczFb98kyfVworQw5Er0zZCF3ddzHSa6qnp56+ciO/fOAR9m77kryS4ezd9mVYOvmLqyuDgi1kycx/+5zDuYc/0QTCrvC2qUFBy21jg5bb66qgIVjQzm9tIr+1lf/sPcpPWk7HHVDSa6k9nbNa7Cwd8BWSydiXDUECI5aYZ+TvexhHkEkIfdITOdjoClomYcHiHUCkGVtM/vkoimJY7DNJMDQ3gy17G7Tf04nGt4eb8erZBgGHxxfUZkEgEAgEAoEgFkIcFAgEgjhInTyZ1KlTNedgYCmxM+Rzmvo4qROf/ls8LQzYXoZrybtMTs8JEgd7uY7S21OnJXzGQp2eOloNOoklLpoc5eQ59lKRUsjH2dN1S4tVNNFIUejT2MKwvRWkpmVjHj4I0BcHAzEn+DSxY3HvaQxo3Ud9Yj4DHvk7VVuil1dLQLIvPndfqDCIyYxZPvGFQehYv0fonmLLUCFOzzGorTtnP9tfS9LmZaRMORrd3XdRL6hH9np4+fe34misJzktg9amBi0ox2yx+BOCPy8LC7ZQBcIZNYspdlTSYkrWen5GJvSV2zaPNDfmBJmv0obycep0fAnB1233ortxeqtJkloZ2LIPm7NdrP3MdRatJAWNd5DMe45LSDiaSmLW5yiyFU/DWKwZ63XFQsWXEBJeEjtMRI5YcmyMUGEQ/FcnWkVuSU46JTlpbNvfyNZqY1+ieGW/qHjZmAF8c6CJr/cfv9TsSLiiJDorCmEhTQKBQCAQCATREO8YBAKBIA7UhGS1tNjklLRS4sOeYEeM/7FMkgRvzFiIbOlJeWO5VjZshBRriiZIpqz7KmidVfEaFga1+bf9tyEkjTVaoEmZrYBqW57/D4ZkZkn2dKbXLKYggkCoCoMjqw5jAhzLljEodSx7B8een89tpsWUzOLe0/CarOxLyWP63o+paq2KvTGdE70kgO+IMKgST0iIig8TzSYbPWV7p48fSZiLRaCYGKlM2ejxu7vvYqSgHjXYprWtj2X55vW8/9D9zPrdPWGuwUBkyczH2dPJd+xlf1J/fr7vtSgl/gpFKf4vAMrtvVCf4ep5H6If70pX625586D/0X5+SLmFH6//BptTxq4ksdA7CyXMwWcCFC1V2F0/EXftDBTZQmLW52H7b3cNRiIwrEQl+is021ZDktmF05dIjSM76lijlNfaeerK0Ux7OPwcorGhsp4xBb3Ydbi5S+ZhFKtZ4sxTelNZ5/+io87upq5F//VlkvwJxKEoCjQ5vSKNWCAQCAQCgWGEOCgQCARxEigQ7t7yWVApcSD/Otr+wfmD5Fzy0/LDxtwy8hYe3/J40LLW/T9FdmeTYrGRmZiDZLWQ+8g8uO12nl7yd7bm9qXZZiHD1xTfvAN+Dg0wiRRokm4bSEL2OVwgBTh+JCtkn09rzX9JdpQHf9wPEQbVZd5F68ljMjvy0jlycHNUl1sKrUyvXcLi3tO42P45mRGEwSabB49Fxuo1keaIL5Dlu0qkwA2j7jsfEs8PuAqvycKV1a+QKnc8XCWaMBeL0Pl1VLg7Vn0XjZbtl29ez9tz7+Op1rFhrsFAZMlMlS2PGTWLowqDNrOb83N3YZYU/nNgMAea/Omy5gS/ayzU/ReJVpLwWvxHedE3HXvE7SSQk3AfnYz76GkEioWSuV2gCncNRthXUPF09OLcbFsNc067T3t896p7OywQqqKZKpL96f1vaHZ6MUvx9RF86vOybus7GAmPT2FEXk+evmoMdpeXCXOW6o6zmiUuGpWL1RxZcC3JTee5VRVcNnYAtgTxll8gEAgEAkFkxDsFgUAg6ACqQLjnnuuBzTHHt3haAL8TMJChWUPDxsrubGRnDnYJrW+Uerz9N/4Kc3MNGR3UOtRS4nprz6Dl6uNAZ1S/5GJOy/4RMyQdoUkCT9b5fFj1OC5kv4NRUUjw+BgeKAzizxKt7ZFM70XrGTplCuvzBgLt4mCoy00NGLmy+pWIJZdNNg9vT2nfx0XL+3/vBcJogRtG3XdmFHI9h6lMKeS1/CuYeeB9+rhqOuS4jFdw62jQSDSOZ9/FSOzdspHTkmv5tO8MFFNISE9buqxJ8UUtz/cj4fAl8NH+UxhesIc5E5s5/1szA5oSsOf57yfJOA3NKRkn9elWWpVE3mydiOKNLuq566aAYiY0rEQltmtQJdA5GP1ZlmR2RX0ciCb+AbKshMmOZlOwcDamoBeZqQl8c6CJLXsbDMzbz7EWBlUWtJUER3OgemWF/Exb1L6CTyzbw4Of7MLp9Yn+gwKBQCAQCKIixEGBQCDoIJLVSuFd/wsf/Cjm2FBRUCUnNYdHpzzJb5ffpC1TfP4P3aF9oySrldL5T1Bxw1UccDniLikOLSUOJDCNVS0xPuo8iKz4MOmIg7LiY3X1a+3CIIAk4baa2Zrfh1FtAqEMbMnvw+GMVLIb7FC+nQZvAlnj2velJ9xIENXV5rHIuo+7o5/eiUKswI1YgpsCKEk9GD95POMtbWPl3+BZ9QoJ+3fEPZ94BbeOBo1Eo6N9F7ubotYqfuFaQcvkK6BNIPT4ZN7evB+8XgPCoIpEmT2T5r0msgoamXb2gaC1fTnIQ8ottJLEAXJ5UrpNW3eT8gj92UcyTvpykD3FqQDcy1zuXXUPtY4sAGSktpCQgNkoloDHpiD3oDHXYPv8Y6GWEvdLORS0XH2slhibJCjKSsFkkhiYnUqvFP/vdNv+JrZWNwRtqyecXTgih7988M0JHTKi0uz08szKcp5dVRHRgRqrr6Da9xJE/0GBQCAQCASxEe8SBAKBoBMUZBaz6IJ3qXjgL+wu38D8We2Cyd8m/o3EQ05OGjJaKylWHYQqLZ4WdpT3o6VsNphcKL5EFE+Wtr7Z5Q1KnbQkJ3PRk8/xz19egUv2xSUQRiodjjTOpTj4sPppzh9wAxZTu7giKz5WHX6HQ8qR8ONLEjXpKWzO78OIqsN8md+Hw+l+YbQmPcU/vokO95hTS4kbUoMDEhpSPSiAV7bRx+77XgmEXRW4IQGSs5nSiv8y8/a7tGRd93mn8s9bfoGzOb4y9VjCnM8rUXTOfm1Zd7n3jPZdDCzJNpOt9QrsDiQg4cAOTt39vhZS8sSyPXhlhQLHXoodlXHtraapF3mNTsgJdwr25aDuVv3ZRyEVuuvOSvyCBk8GXsXMUu9pyLHyvdvcgwm9VtN68BKQkwFf2zh/r8Ko20cgtJQ4kBuGvaz9fO8X/8PBlt78fHx+UA+9SGW3kYQzb5sVsG96EgcbjbkuIXZRdDxiowSYTf7Qk2gsWF6GyytjliTd23ysvoKBrsPQvyMCgUAgEAgEoQhxUCAQCDpJQWYx+fc/Q4+lr8LhudryfR8sp3Xtt7SWfgvXXY5TcVHeWB607Y4je1i4phZFsaA4c8L2Hfoh1+f18t+Fj+JS5Lidg6Gpq0bGOeUWv0CYdwMWcyKy7GXV4Xc42Bql11ybQLh8UD5uqznIWahiVBC0pffUgh9CS4kDWTmiTvt5yraJ5O/dH5ZE/F0UDLsjcKNs0zoWzXtAEwgrv9wctzCoEkuY2/5aUodE4I4Qre9iQpqLwZe3v/aavxqKz1lE5ZbYLQE6Q/nm9ZRtWk//EWO19OIqWx5ltgKDzkFAksgeOpi96fpCn0poiXG0kuMd+WvY7bLgOjIFb60RB6CprdTYgq95KKakKsxJB1C8NmR3n6CRsi8FfKnEesVJRC8dDuTC4RnY5TxKC3oFLY9WdhsqiNldXt7Z4her4xEGIbbwZ6yrYvtYrwyS9QiSOfwLIRWXV6a0oCen9u0RdX+h1wQIS8sW6cUCgUAgEAhiId4hCAQCQRR8Xi8VWzdROGK05rTSQ7Ja6T1xCrzTLg4e/no7aVjYsmMV/7Po37rb/WntHyEHUgFn+Z1hHxID3SFXjhvAonkPULZpXYfOJTB1td7aM6iUeHrNEnp66oN6Dqo45RY+OvwsPzn/blasfzW6MKjSVmIcr4AZuH3x6HGcc+NtvHDHjTga68NKiSNuetoFlL/7iSa+KICvZxaW+iMdm8txpFsCNxRFEwjPu3U233y+pIOzayeSMHcsy3mj9V1UAzxUDuz+EsnT95jN7c2N1W2BGBKSycKSvucw/dAnkRO/VdpeBwOvvpB//Pcj7juYhNWTRW/PAH5RvCZoaF8O8suKeeQX7NdKiSPRKpviLA/G7x6smwIoyO5sbHnPBoWUgD+oxL77bmIJg/4wjRwO1RkLxPnNtOHYbMHuuFABLJRQQSxUSPQ7+Pzz9On0LYyXeLY3px/F1r/9b4V9z+ywe3+y1cSfZg6hJCfd8H4dbi+vr6+msdUTJpoK96BAIBAIBIJoCHFQIBAIIuDzev1i3Ma1FJeODyrF1CM/LZ/3Zr7Lxy8+4RcGW/xjPWZjws05wzLIMA/QXTdqQFq7MBgtBjUGkVJXe3rqyXZHFs9aW5tYW/Uee/d+bfxgnRQGz7t1Nh/Nn4ujrfzTGjVEoZ1lXzfSkj2dGTWLKXZUsje1kP/721/5910309pkLHX2RKHbAjcUhbKNa3njr/dwaM+3HZhZMEYDUbqb0ONGLsl24Ww4SEJa5LlGSoaOh6LRYykuzMJ9oJafDw3pOzr4x3g2LsJ6aI++lNb2Oph5+13savT/jo54TSAdJTOtRvd4M6VPaSZ2X0en14qnsTSgPNgfVuOjLYREFxMobQnEOiEl0BZUokQKKlEABZNkwuNTKMpK5cOvUtlx6F6t52BgKfHTX13JwZa+WMwpvD8p/L4YJLjGKLu9uHRAmJBoaUv73X6gia/3H7v7gmwz4x3VA1tAi0XJ7EIJMXa3emRsCZFf16oQeNlY/7VRRcFHl+4mwWIK+zMh3IMCgUAgEAiiId4dCAQCgQ6aMNjm0gstxYy0zVfPvkbrpt2kKe1jjIpad549XOtNGMqejeso27g2zrOITGiJcaySY1t6Bo1Harvs+NEIFAYDxdA0h5WLlvfXeg4GlhJP3ppJSd4o6gfN4pmdLSgSfJw9nXzHXvam5HHq10e4fv6zPHPrL2ht6lgJ7fGg2wI3JIm+xSd1iTAYONcTic6UZEdLhjZK0eixzLrmMsxPjqEE0Ous58uQWGQ/lbKW3sGif4AwGHq/ybLIXN/bjR7N+e3CYN7eFvbmtQuSr++8kF31J+P0JdCQshlL6m6sGe3uw5Oae7HddwoS7S5LJeD/CQotCQ4pAQw4ESXAx9klafRO6cX+hlbsLh92snVHH3b0Zb99AD4F3b56pQW9+Pn4PO2x16ewp8bOwOxULGYpaJxe+bFXVuibnqSVGofSZipE7sLkEsl6BFOSD8kT7Jg0JfjF3tAS4+te2MCyO8/U3dfzX1RqScSKAg9+sosEi//auyM0NBTuQYFAIBAIBJEQ4qBAIBCEECQMBjRtiiYQ6m7TRpCo1cPLyuHtDr05k+dQlF5EijUlojAIUDhiNMWl4zvtHFQJLDHWKyVWUfALg32KBlKxZWOnjxuL5LQMzrnxtjBhUCXNoR+qkmG30rpuN4e3vYWUdTaKZEaWzFSk+AWFhcvLuGJMLn0HnkzF5u4/j67EaOCGYYJKtn+No7GhcxM8QelMSXa0ZGhXURatJhlLq5fU/fpCc9Hoscy64x7MNduiH1tSmJm7k0WWyZR9s9P/fG/rMTjw6gs1x2Bgr9Ikg4Zcqz1YpNtVfzJ7m9sceE6/sJfU7z1t/Y0eK+ucp2uP600mFqfYAPA5+yM784L2F+oeDHUi6mPhlL49uOG0QWFBIk5fsOPQ4U1kaG4GJTlpun31SnLSuS9nqPb4iWV7eH1DNWcNyg4Sv+wuL5f/c62uk27Bsj24ffr3U7NJ4sxTsimvtVNW29LpsmMp7SipOW2lxHXB65Jz2ttOBJYYV9Q5ONzkpE9aUtD4wCTiBcv2oLSJtpFEQRXhHhQIBAKBQBAJ8c5AIBAIAogm8kUSCKNu00YkUasovYjBmYNjzstssTDz9ru6pLRYJZIgqKIALaZkUidcRMXHz4Wt74qyy1Bamxp46/7/5XD57qjnGOrGtHpNoCjk2Ss41/cJ/+1zDrLUXpLX4nTx3F/+jFwVXawxQoMlPaao2h1EC9yIh6KRYzjv1tl8+Ng/vrfCIHSsJDtWMrQjJ5fHJtymLb9x0T+CBML69Ex6DxtFydXXR21BEIhZUph5zWX8519vcWDrV1Rlt/Bi/49Q/vuR7ninwZf+svz/IY/2vnZB4ltA+rCnYSzWjPUUm/cy0/q8NqTKYmFFv/7+PoJ79PoIBrsHzbbKICeiHpOyRzH91GJdJ1+NI5u7V/lLjJ2+RGoc2ThlO/+6fhwmCZ5bVcFlYwdgSwi/roFiWaj4FS20JJIwCH5n4Yi8DEbn92TOf3dGPa9YyDYz8ugecCj22NAS49v/s4VXr58QNCY4iTiyGGuWQAqouY6VcCwQCAQCgeCHixAHBQKBoA0jIp+eQFixdZPhkt9QUSvFmhJhZDhGBUKTxYLs1f8wrBKa3qv3WEnqgWfmbCaOLaD8yPagY3ZF2WUkDpfFLnUNdGNavSZNfJWAwtYqzj3cLhCaFB/n1CzGZzQdNgoNlnReHvAz7fGV1a8eM4Gwq/r6ybLMB48+8J1zUMZLPCXZ9emZyBkmhszYrRvkoW5bEfIM8ia3v42qT8/kmctvB2DOxt2sHjeIIoNzNZvNDL3ucl5+YQn7ereiROlEUOtK4u4vbiXJpNCvxz5uKHldW/dyXQK3j/87OT0Gc9sjZSSbgsW2dvzCniJb8NSdjSJbgL3t18diocUk8cihGt51nc8iOUIfwQD3oDnpAOYAJ6Iev7/gZ+Slpug6+YCQObaXwbq9Mo8s2U2z08Nvp50c1G/PlmAJEcvaS2djhZZEQ3XZnT+sX/wbh2I2oUhJscfhLy0OZPWeozyy5FtuOL0IW4IlrnMampuuG2ii58QUCAQCgUDww0aIgwKBQIBBYVAlRCCMp+Q3zWHlos9z6DN0MDOuvjlqKbEeqkD4/sP3U75pve4Y2evFlp4R1RWmpvhqab6YMCNr0kdKek+ue+yfJCT5P9AOuf0u3n/ofso3+48ZrewyqUc6fYtPonJr94pPkdyYqkB4Xs0nfNz7bKbXLtGSizuL22SN+ri76QoBtrt/LycSRkqyA0U9gIeUW8IEwkP0o5UkDpAbtDzjnLOxFpRTv2MXvYtGBa2z++JIkAZMZjN7e3vxNEzCmrEeyaTfB9RdPxF7Sw7+3n7B95vDHhNWTxIffGOm2enFIfUBZHyKTFi5r5yM5+gZgIK7bgqOlHcBDzvNNi5MuRBrxnpQJOx7ziNyH8Hw3oMqimzVXImB5xIaJOKN0tRPLf11ef1jnlxexnWTi3hxdXu/vasmFASJZYGls5FCS2RZIVoBrr9loaS57DqLVVFwW/tytN+DSIoTs2c/aXULtfVNmb/GZ83BsqkZPOHC3SNLdgNw27STozohQymvbeFf148XJcQCgUAgEAhiIt4tCAQCAcTl/gO0tNeKrZsYWDourpLfEadOZNat9xguO9Q9vBy9t5SjsQGTxYrsjRw0on5WbjEl81rOT/nZ/n+TIrdiCxEGAzeIVXapyAlcPecJPn3qsbjPqSuRgAJHFVdVv4JNbu0Sx6DbZKXe2jNo+dG2x8e6xFjgJ7C03dUmBOr9rqOVZLutwQJiK8HP+0P043fS47rHf9A3FAYOhYFwV24C7Gt/XexucYITUpNzKGrVD70IxX10Eu7aGSiyJSwJGMJDP5y+4J6TTgVwO4LCOpobqvnoUPi9zefMQXbmoqYPL3ZNpdT0Lk/7ZuA6PBNFtvhFvVh9BOVkPI2lJPRabehcAue2bX8TW6sbol6TwLJZl1fmyWV7eHltFeAXAV0eOUwsU92Dp5/UOyi0RGXpjsMcbHRFPKbquDMyPyPBJXKLl5uxceGE09nd4uS3X64IWi9tT8bkTIIIX3gAPLlsD5ePzWPB8j2GnZAigEQgEAgEAoFRJEXpgsZVXUhTUxPp6ek0NjaSlpZ2vKcjEAh+IMTlHATdNFGj+ygaNZZZv+uYOOjzeoMcfF2BApTbCliSdRYTWr7ikTmz6ZmeGnTMRfMeoHr3CgZfpp/+GkjFByNp3O+MeKyucPAdS0JLiSNxLEuMBfGXtof2yKxPz8RtTaCuZzYfTr1EG/fjda/Qn30Uja2mLwepoJB7pbkR92uE1et/FiQQOpREXvedyWXmZdgkF9zwORslCxfP3wlyEpicpA6cE+bGcx2Zgrt2OoFOvmzbYXpkLUNO38wRr4l/j/srg0/9UftGdWVULRhLi6n9ledQkriqeR4ObNqyNFr4NOFOzvDMxakkg8lJ8oAX8DaOiHl+1p4bMCe1l21rfQpDzuXfF/xb67Fqd3mZMGcpzU5jLjgVs0nC16bESRJYzSbdII60JAur754a5po73ORk3P1Lw8aHbvvpHWdw1txltLijfxFjabuu0RyQgfMpd7s5d80Keh28U1sXGEISjYnFvVhddjTmOL3jCvegQCAQCAQ/POLR18Q7BYFAICDOwA8dYTCefZRv2aCVJIPftZhXMpy9276kcMRozBYLPq+Xiq2btMfQPcIg+MW6Ykcl9Y1bWdmzlPe21XLNpFR8Xi9lm9bzzedLKN+8geRMY2WSblc9oJ+iG1jO3FHi2V79DXTmeEZLh491ifEPnWil7XoECoehpcSBvDPuCu3nh5RbSEZf6I4Hu9kW9Ph53zk86L0MJ1ZusiwCYNHmJpATUZ18rqOnYTK7tLLcUNegSo2jDzX7LiQ1aXuYmAhAZjH5N64HVzM07oN/X8ET3nPDHJLNJHOn91e4lCRtDj5HQVCisVHc9RODziUw1VgltORXVpSo7jsVX8AgRYmc0BvJNXfP21/rjjdJYJIkLbTjnre/jikMQmRRUNViTZKELCs0Ob28uraKaWNy8QWUGEcqJe6VkkB9izuocDxeYdCECCARCAQCgUBgDCEOCgQCQRuGxL0IwmBc+2grSX7vofuQJBPlm9aTmJKCq6WF4tLxnHfrbD6aP5eyjWspLh2viYiL5j3Q5cIgtIePlDZuZliqk1EDJukKkR1Jf9Wjs8Kgw5RsuFRYFSM7I0gmyJFLszsyTtA5YpW2GwlrCS0ljkQrSRRSwW+W3kerYqOxbyb/KblaW3979lHm1cQOd0j1ObSf7UoSC72zAIWF3llcZf4UJBtvrDtAu/BnwlN3JihWrSy3XXDTIYIAp5FZHHZ8JURkVDCxQh5G+yulvZ8gkqLbP1CPcBHTvx9QMCntXxoElhd7fApvb96HHCU9OF4Cew+qrrnaZicrdtfqjpeAC0f0IznBgsen8P5WY6Xg0ZAVGJabDihsrW5kf0MrRbZElow8iYufqcPhIGIpsd3poaNXQ73vjSroyal9e4gAEoFAIBAIBDER4qBAIBAEEFXciyEMhu4jWmgIEJQW62ppAaBs41qe/c0vcTTW+x9vWsf7D92PKamJA5VbSUgzdVkqMACSREpahna8hP3b2fPqfPZIhKXZxpP+2l20mJJZ2WsC5x75zPA28YqCoUJihreRK6tf1XoOLs6epq2bXrOEnp560XPwGBFaShxI4PMxZomxR8dhp8PBTzJpPWoisclJouogLGlff1pGLy4pHITd52N3i5Obd7Qn/v6YRG4szSe1eT9Fp7yqLX9xQzP2NU0ANJPCS+MWUf9lE61umaBnnmJBDQuxpm/SdQ22EyDkxeBF33TsGEvOVUVHkKL2QgxEV8SUk3HXnsfHWz2c2vbyKclJ576coQC88EUFHp8SFBzik5W4xDGzBFJA6ojqAAx0zd3xny/xRBAgfQrU2t289IuRvPBFBf/2xHYNRkM1FO4+1IizzdT6zpb93DnjVDZ+U4PziBMLBAWlaCFRCrg7IZQOH5BBSU4al43J000rFggEAoFAIAhFiIMCgUAQgq5AaFAYDKKDn+1Uoc6/D4V9e1Yx+PIyTvF/jo4pfGhIElJyDxRHU8T1tgBhUKViS+Q0WyPpr91JitzKyfY9lCflUejca0j4i9c1qDc2kvDX01NPtvtIHHsXdIZYpcNGx/VsrOP61+bp9hw8f+kbZNbXkOBxY2tswU37c97SGtwfz165l6KcEbrHWLZxPw9OPInU/ie1j3d5WbhlqXZrUIDH1x7B4XEQXoqvJl0k4jx0keFgkBRzgPBXVwY1O8Djdy7aa6t1XYNhx9Qw4T4ypU3BUiImE6tEKn1WeXLZHq6fXBTW/y7QRQjg8cn8Z8O+yOeqgxoiEkpJTjrPrargzFN7s3J39Nfqim+PcLjJyeD+aVjNUkQhMR5aPO37CAxKmTW8H+9/eVD7OzGobyo7DtkZMSAdn6zw9f4I920DlNfa+df140SfQYFAIBAIBIYR7xoEAoFAhyCBcOPauIRBNcCjfMuGrplLnL3VVKS8ITzJeG6W1iFXbQtzQeoJg0aJlv7anUhAkXMvlUl5VCbnUdAaWyDsygCU0NJhUUp8bOmq0nbwC4R6ZNbX0OfIQd11qfubuHHRP/AmW7C0enH0PRXfuPMAqNuxDQKEREerlwc/3sklpQO0Zf/ZWI09JIDD4VaACOXCAJjwOYqZUNhMyv4NJEbph/qjpg3kt06FA1u1/oKBvOmdTjOnYsaHFPDthYyEjAndV4uSCIpEtP6BKlFLn/G74f65spzbp50ctDzQRQgwf+nuuL9bKa9t4V/Xjw8TxJ5YtocHP9nFK+tSgpZHShm+552vmTwwq83J6HcUGkHtWQiR+xAGljpfNaHALw62UXW0FYCy2hacHmP3eBWLKbpjUiAQCAQCgSAWQhwUCASCCKgCYWgwSCwqtm6ibOPaTh+/s73VlnoHIFtNLPXkcs2IJKq2btRckJ0RBiG4xDjeUmJbejqOxo6X4EpAgXMvnj4ng9OMovh0BcCO9BmMtU1gibEoJT72dEdpe2iJcayS49T9Tdprc9+eI7z/8P2gQPnm9ZzbbzjLep+G7JMwOXy8uKaKF9dUGZhFJCdfG7KVU3on86eDz0QfpwBv/zLi6lLTLn5u/jRomUcx87Y8GZlIgqop6OdI7sFYrkGVBcv28Esd92AgKyP0BdRDwi/K6QlidpeXhZ/7y9DLaluCtjNJIOtUDq8tq+NXpxfx8/F5bNvfxNbqBsNzuXBEf8pqW6Ju0+T08o+Pd3K4KTjoxuH2C4LxpjeDX1wtyQlOIBR9BgUCgUAgEMSDEAcFAoEgCmaLhYGl4+LapnDEaIpLx8dOPY5CZ3urSfklfCvlMKNmMcWOSvZaSigaNYbyTes7LQyqxN1bUJIoHDGaQ2W7O31sCUg4/G3MMfGQXTSQ1J69ovaJhMglxoJjQ1eXtgeWGCd43BEdhSqhr83tr7XPacjBL0lubOTj7OnIUrvYppgl5FQLpkZPhOelEvBPz8Fn4o0vYfavN5CqOMK21nMJ6lFiquI+0/NBy17wTscjW4PchF7t+FLAvzYiuAc9jaVhpc+SZA67BQa6Bx1uL6+vr+aysQOwJfjfktpdXrYdMF5SqwAXjuyPLcEcJoi9uLoSu0tfbIsQcozD42NjVT13nTuICXOWRjxuoFvPJ/uTlr+sbuBgY2vMOb9kSDDWqrljuihFGbFAIBAIBILOEuOraoFAIBDEi+o4LBo1puP76ERvtbyRpbyYNImza5ZQ5KgEQK7ahleWGXPhxV0iDBrBZAlI4ZQkikaOwdHURGvTiSeu2dLT+en/PcCsO+6haPTY4z0dgQG6srS9Z2MdfY4cjCkMQvQyfwkoclQyo2YxJqV9eVZ+EwVSBX1sNRH2KgEypsQDEdaDwyXz0i4T9B8B/UfgyCrhufJ0HFklkJ4bc96RUN2El5s/4zLzMi4zL+PCUy2cMzQdi0lfqHTXTUHxBYu0Zlsl1ow1TB5s4vwRGZw/PDOiQL9weRl2l5fnv6jkLx9s54XVldq6F1dXai46oxyxu7jvR0ODeg6qrsF4v59RS3//uaI8qotvUL80Lhs7gJ+MzsFi9p/pntoWWtydCzJRGTEgnSvG5TEiL0N3vQm/QGkOcE0KBAKBQCAQdBQhDgoEAkE3YLZYGHLGtNgDI9DR3mpFo8ZyaNSlnFb9CUWOyiD/z94tm6jbt5fCkaUdnpdRbGkZ/PqplykuHe+f18gxIMHh8s67BruD1MzemC0WzBaLEAi/I6glxrveKjAe0tMJEtLcJGe16pb5J2e1kpDmXx4qEPa21fCPgX/kT2P/wZzT7qO3rkCoABZkd18ieV4V2kU1QFdY6wglpirusz4f9O/RmacwrH9O5H57WopxO+akAyT1e4/7fjSUJy47nYFZvcP6+am4vDJPLNujlfyq52V3eVmwfE/c56AGiahUHGnhHx/vDOvvaJRml5cFn+s7t1W+PdzMXecOIq9XSsQeg52hvLaFu84dxNAIacPDBqRz2dgBXD5uAD8fnyfKiAUCgUAgEHQKUX8gEAgE3UTx6LEUjRpL+eboZap6ROuttnd5Lq11lrDeagWjxnJg1MXsfn0BhQHCYDsK5Zs3kF1Y3LETMkhyYg+m/flRyhp9FP30RnqUjGP/hpXUbt/S4TLr7qamfA+L5j3AzNvvAuCUiadTsXUTii8+B5MgMh3pARmL7hYEFRQkpLjL/AMFwu3Fg4LGJ5ldOnuRAB8oViIlEpsks+YQu7h0QJCwdlVBb1I7cH4aF/0TstpCQhJ7YE/NZ+HnS6O8XMN7D86ZPIehWUPJT8v3i3wxxLWnV5Qjtx1ATfFVFLC7Ovaau+ftr3n2mjFUHGnhzLnLO7QPFUUBd6S64zZcXpnnVpXzz5UV3XJba3Z5eWZlOe9s2a+7PlIAi0AgEAgEAkFHEO8oBAKBoJswWyzM+t09vDf3Piq2bIx7+0jCR2udldYjSUHLbOk92T/8x+x89ckgx2AYikJNefzOHKOYJDNT/zKPsx/zB7KYFB8zahZHn9MJQtmmdbz/0P3Iskzl1vh/X4LvF6owCB0r809MczMkYQcD5GBxp3/KISTA6UukxpEdsEbClFSFOUm/tHh8//GkJaSR09sV1Euv2eXlpa9auMn4qYWTdbK/XLmNN7+ooNnpxSxJICn4ZJ3zl5PxNJaS0Gs1AEXpReSn5QPwytrKmOKaL8Btpyj+oJLOGPDWltdhd3lpidBj0CiRUoz1WLarNmJPw86iKLBgeRmuCNdRFVRvmjKwW44vEAgEAoHgh4UQBwUCgaAbMVssDD59akxxUE0/1UtaDe+tFt4RwtHUgPPF/6NIdh9XEU5WfKx/eQEmZTSyZCbfsZfitr6HJzyK0iGXp8AYJ7o4HEigMAjxl/lHcxreMOxl7ee7V90bIBCakN3Z2PKeDUsCBtiqvAcu+HxVAkrVfZpbTVFg4cZmrpKSSJWcYdt1hNKCXvx8fB4A9c56Flcu1h1ntlXqLj/a4gHafuc6v3g9p11zHI5Bk+RPKA7cX4vbx5sbqxncPy3Klsb2PWtEDou+PIAnYl21ny17Gzp1rFAkwNymTiqKElEY9K9vc41OKBDuQYFAIBAIBJ1GvJsQCASCbsZkji4shKefBvdPU0uMTQk+ZB3xEABFIUkJFxSOBzXbNpGf3ZuKlEKqbHmU2Qq+E85BgUBFCnm2Rivzr1raH2dDQpCwb9RpmGJ1t6Xe+tNu5RA3nh7u+ol4XMGiUbNb4SXL2dxkWWTwDENI7BH0sCQnnftyhgKwvW47Kz54L67dzRzenxa3vqPO45N5e/P+mMIb+IW6wqwUPD6Zxla/4JiebKUkJ51eKeH3wdKCXiz6MnKoixG8MjQ6PN3SRzAWkgQ/GZ2L1Syx82AzG6vqMQEmk06TCAWtzPyaSYXHfK4CgUAgEAi+XwhxUCAQCLqZ4tFjKRo9lvJN+q60aOmnKkZ7q8XT161wVCkosLm8Arc1gQSPWzet1ZaegaOp0Vi/QEkie8goqux+15Esmfk4e7rh0mKTxYrs9Rg8g8jY0jPILiqicsvmTu9LIIDIr0FnQwKtR5KBdgewUXFw2pACWuX+2uN6Zz3LGisjjld8CbjrzghfDiz0zuIq86ex3YPjb4L+I/0/W22QPQgyu7YPaaC4GMoTy/YYFt4U/GJZPKWzZbV2w2P1sJolVpcdOS7tUWUFirJs/OqMgWzb38jrG/bG3EYEkQgEAoFAIOgKhDgoEAgE3YyagPva//6ew2XfastVIUEv/RTQLTGORbzuvFOv/w03fd3+AfT61+ZpAmFSj3SczY30KRqIZDJFFDcDKR49jqKf3oj85FptmSGBUJLoW3wSF939Fz5Z8Ahlm9Z1OLzElp7BdY89g9li6XC/x86QnJaOJIGjsfGYHve7TLSy+hON8DJ//VLiz9dP5NPSWfQzHeRmHtWWP8FvOUAuZouNT86bRqqlfX9+l15k55u7fiLIibrrmknmJZ8B9+CY6zslBiqyFU/DWKwZ65FM8Qn5dpeXhZ+XGX5pd6R0trh3p6JZ8PgUPD4Fv5+z81jNEheNyuHrfY1sP9gctE7vGGpJdjSBVSAQCAQCgaCrEeKgQCAQHAPMFguX/u/9PH3j1bgcLXGnn3YHFZs3svXo32DGldoyt9V/LMlswdnsF7cqtm6icMRov4OwsSHi/mzpPTnv1tl8WxeexhpVIJQkikeP47xbZ7N325ecd+tsPpo/t8MCYZ/igZgt/j9vkqm9P6M1ORlPa2vc+4uXHlmZ1JSXd/txvi/EKqs/0QgsMfa5zbja0olD3YJubyLVFCERLCYeJpdqqQifD14/dJTrc3sbOm67azC85yiAgomF0mVcNXMWqVadAV3kEnQfnYS7dgaKbCEx6/O4tn1zY7UWdBLQMhBZUSIGgBzr4I2irBQGZqfw2c4aYmSqGMLrU8jPTOHK8QXc++42tlY3aOtKctPZebAJj09pExFzmTm8f+SdCQQCgUAgEHQTQhwUCASCY0RCUhLXzX+WBTf8HFOCMZHKaHlivNSnZ+K2JlBnDU49ruvpD0cIKjFWFEPuO0dTAx/Nn0vRT2/UXa8rEEoSRaPGcOqkM/jwsX9Qvmk9xaXjOe/W2Xz46D86FBBSsWUTrzxwD5IENV/v0JZnDCwAJGq37eiwK9EINeXl9Ck+OcglKoiMkbL6UGeh+ts7Xn0s3U0J2nNXSmjgwO4vwxzAJ7V+y++2PIN72lSob18+vU8/HJZMAMalpxg+pqexFORkwIfZZA7ri6go0OSBN51juGZ01/WgS7G2z7FdoFRw100hoecaLTwlcFwkAoNOVDw+hbc370OO0IOwu4I3zhval14pCXh9Mntq7AzMTsViNnHZmDw+/7aWxdtrdLdTw1AU/KIm/v8xMi+Dbfsbw3opKvjn/5NRuWElz98eatZKrL2yQn6mjZKc9C47R4FAIBAIBAKjCHFQIBAIjiHJqalM+csTrPj7LwyNN5qSGg/16Zk8c/ntuus+nHqJ9nNgibEhFIWyTetoanVTZM+iMqUAWQqef6BAWOyopGjUGBRZ5sNH/66NKdu0jg8eeYCWhoa4zitwHrVfbw9LnK35ejt7s1shC/JrbR3bt0ESU2wgmUDpAuvR9xSjZfXRnIVuzCTQPQJ6LGxpGZzxi5+w5atZnDIsfH3B1P3AfqhfzLChz5GYlInFnMJUW8eEO7OtEmvGGgCm9xlLz4Q0MFshKTidV68HXVVTFS2eloj7VoW9SGMeOfMRUGDFtmRe+rbe39tUTubivvO5dFwGKdYU8tPyY56DXqnsC19U4PEpEd2EEvEFb6QYFBDvPOdUCrNSeGLZHl7fsI+05AQe/9lIZAUue3pNxO0UBS4c2Z/khOB7m0mSglyBgTS7vNz5xpfYXcEhLYFpxCJ9WCAQCAQCwfFEvPsQCASCY0xCcipPZvyKm157ioQEr6H0065ELR3uqnFBKAq132zmfKCspYCPs6dHFAhfOjuVmo0rwl2JBp2KEafQJgqGOqskJPJqkmntJjdmIHu/2trtx/guE09ZfTRnoRUflpQeeFuCe7kdCxyN9Xz6zENkjY09ds2/3+H8X8/FbLHgcHt5fX01l40dgC3B+Nswc9IBzP38qcE371/IYHdbv79bN0ctFa5qquKCdy4wfJxIKL4ElKr7NNemAry9vpnZU8d2SszSdxP6E41ln4LFLDFreD/2N7TicHtjXrPCrBSWzZ7C819U8NKaKq6ekM/5w/pxxTPrtPLdd2+eRGFWitYDEeCznTU8vaIcq9mE3RX5HqEAh5qcvHL9eG2Z3eVlwpylEQ3JigIrdh+JeS2OdQm1QCAQCAQCgYoQBwUCgeA44DYnsjD9l/yi+sWwhvSB6afdQYLHHXtQHOMiUdxaxZ9TNzH86t9gMgf/uUm2wFcvPHrMw0IkJJK7wY0piA+j5fK2bEeYyJvSzwG0OwuPhzAIkJyWQU35PkPiYNVX21k07wFm3n4Xz39RyYOf7MLp9YWJQEZKcwFSAhv0uaKffzTHYDy46yficQU7YZudXp5dWc5vp53c4f3quQkDE429skJts5u3Nh+gZ0qCIeEsNdHMvzdUA/DOlv3YEi1aua/Hp/Dp9sMM6Z/OMyvLaXa2u/kWLC/Dot/SMYgv9tRxuMlJnzR/W4ZIvRRVfLJiKNxEuAcFAoFAIBAcL8Q7D4FAIDhO9HMdwoyCHCH9tLvo2VjH9a/N8/cc7JkdVEp8/tI3yKyvCe452FEUhZpvNlP+7wXMvP0uLSTE5/Xy/kP3d6ifoBFCxaR41wu6H6PP8YKpB8OW5U5s7wV3PMNLWpsagPZwklgO4LKNa9mxYT0LP/eLeXoiUH5aPh/8+AO/oFf7Lbx9fdhxU2SFfK83bHl30t5rMGQ58OTyMq6bXNRlYlZoonGg625B2zUzSUR1X97xny+1kt0mp5enPg92qS5YXsblY/N4cnnwcpdXJjxOSZ8/vPkVL/zCrwzruR9V1J6Kob0IIyHcgwKBQCAQCI4HQhwUCASC40SVLY8yWwFFTZVB6afHQuzwC3/hH1Yz62vocyRckOkwbX0IVdcU0K3CYHej4O+Bpv5X0DECE3/1RDUFRVcYDKW7AnviIdLrNcgB3JbIvbwlE7vLn04SSQTSeve53KCWDh9n3PUTQU7UXefyyjyzspzbOuEeDOTF1ZVhvflUmp3+a6YoRHRfHm5ysjKkhDc0CdnllfnNa1tw68QRq6/vWHxRdgS7y0tqokXX/agS2lNRURSi6YTCPSgQCAQCgeB4IN51CAQCwTFGbZgflN7bVHkcxCaJBE+wT6YjpcQxhbI2gfD9h+8Hhe+sMBiIEAY7TzRRzaiz8LiJg21JxShQvmUDKErYnLXHbcLgmTfN5rQHPw9yxHVGBKqyWGgxSdBUCYnh19JoSEgs2l2DkettFywv4/oucA+Gugb1eHTJbq30V+/6zX7jS0PHWldxVHe50Rxzj08xJIqGugp3HmpmY2V9W1p7+ziT5Pc0K0p8ASwCgUAgEAgEXYEQBwUCgeAYozbMb2lzx3jd41j5tztwNzce87n0bDyqlRh3pJTY6AdpFIXyTUIUFISjJ6q5mxLYs2gAA2dWR9124MzqY19aLEHx6HGaE3bRvAco27QuyA2pOYDbhMGZt9/FwpXhjriOlpBWWSxcMKC//8G6/4k47oMffxDfuengaSwFORmCUqFNBL4aXF6ZV9ZW8aszIgejGCGaazDwWOpXGqHXT8812J0YEUVDXYXb9jfy+oa9MfetlzotEAgEAoFA0F0IcVAgEAiOA4VZ/uABn9fLonnzcdubjtNMFPq0HMTttdIR6euHJpapYugP7by7E11RDeN9CY+te1CheMjgoB6aM2+/K0gg1AgQBlt96DriOuoebDEZewa2HNkF6bnhZyFb8TSMxZqxHskUvXTZbKvEmrFGe+xz5iA7B4SNO9DYamhOkTDiGgwl9PoZdQ12FS6vHLe4G60EWSAQCAQCgeB4YSCTTSAQCATdRcXWTZRtXEtcn4i7CAWFqj6tPDvlII7E49+77URHCIPdh7vJ358vUFwzKg52d4BPOwrFqXXMvOYyTRgEMFsszLz9LopHj0OLqg0QBs0WS/Q+em3ut27B7dBffHQSrsMzcR+dGHMX5qQDJPV7j6R+75GY/V9kd2/0XgXvbN4f0/UXDTXxN17U63esXYMqC5eXdeq8BQKBQCAQCE4EhDgoEAgEx5HCEaMpLh3fLiocIxQU3BaZFUNr6V+fjM3VcSO5Qhzlxd9hJIQweCxRHYW73ipg/+rsoHVVS/uz662CbiwpVrCZXbQ/s9uEwdydmM3hYmSQQAhBwmAsR5zqfgsTmBJ7dMmZpFhTgo+n9RBUcNdNQfEZv37Rgkk6K3KWFvRixICMuLdTr9/v3/yqw8c2gqTzz4S/P+AdS3ZQ2+riuVUVONxCKBQIBAKBQPDdQ5QVCwQCwXFEFRXUssRj5SCUkEj0mvnJihzeOn0/VX0c5B1ORupgabEqEArxTNCVGEoC7nIUilKPcn7OTj7afwpl9qx2YVCK/PpUX8sVWzdROGK05i5UHXFqWm3Y0SIFUGQWw62bwdUcvtHez2HXM4bOJj8tnw9+/AEtnhYA/r22gZe+rfe/XuUk3PUTSMz6POZ+YgWTdDZgpSArhbJae9zbgf/6fbGne12DwwdkUJKTFrb86+ZWFnlbcXy8g1Xr9usmKAsEAoFAIBCc6AhxUCAQCI4zqqjw/kP3H/Mk32R3u0B4Or07JRCCEAi7g4Q0d1g/vh8aEZOAO4AiSbh79SHh6GGkMDHeLwzOyt2BWVKYmbuTCntPClProwqD2rwOO8ncl0nTvkpt2eQWN0/1yQoatz07gbqU4LdgugEUmcEBH1VNVbR4Wii3WmPOJRA1tdju8vL2hqUBfkgJd90UEnquQTJHTyrXDyYBs8mMhIQsKzQ5vby6toobOhBMYiSMJBpeuXu/WCmraeZf14/ThM8Wn4/n9x3h9cpDKG4fqz4/AHROIBUIBAKBQCA4XnT5O5c5c+bw9ttvs3PnTpKTk5k4cSJ///vfOeWUU7r6UAKBQPC9wWyxMGTKtGMuDkpIOgKhrUMCnxAGu56ENDeDLy/THh/zZN4ThEihJUapT8/UErlTFQV3di4mjxtr09GgcYHCIIBZUhjY46jeLvXnWdlIy9qDbXWn/ldDIjBEHaAooMCksbmkTsrR30ldma5bsKrlEBesvtPwXPTQFeDkREPuwdBgEpXpBdPpmdSTbfsb2VrdyP6G+INJOhJGcqxpdvmC3J0LKw7z8IoyUMAsKyheBYmOJ1ALBAKBQCAQHE+6XBz8/PPPufnmmxkzZgxer5d77rmH6dOns337dlJSUmLvQCAQCH6gDBgyDJPFguw9tj2rAgXCNyfVMqn5VIoce+MW+r4PwmCgiNSzse54TycsiffYJvN2HV1xXTsqitanZ/LM5bdrj2/4+BVMgHVAIWyv10r5i4aVMMu9MLZDMEovQFtpHxo/rUJx+iK2CJCSzNhK++jvoK4M5o/SXdWSYIWcftHnFoXIApzJkHvQnHQAc7/3wpbffPbPyEs9mQlzlgLwzpb93Dnj1Licc6Gl1wogtwmpRvRCtbWBEeIZG4hZkhjc319WbPf6eGJFOdZv/SnziinAPd3J8mqBQCAQCASC40GXv2v5+OOPgx6/8MILZGdns2nTJk4//fSuPpxAIBB8L/B5vbw953+PuTCoIiFhc1s4Z10e72adxRXVr5OiOL8Xgp9RQkWk61+bd9wEQrWUOCkjWKxRH5/IJcahZdBH0zN59jheV3dCEuPKv8GkyABISTYAHJKFXiWlNBw+SM++/Zh6y22Yvb/U7/GnktgjrNQ3EFOihR5nDKBpcaW+AiVBjykDMEUSjaIduwOkmJO0n6OW7Rp0D+oew5oStO+OOOdKC3rx8/F5Yct3HmxmY1V9TEHPqNjXNy2RvulJbK1uNDw38At/PkVh+4EmxhZmsrDiML6ygH3IweOFe1AgEAgEAsF3jW7/SrOx0f/mqVcvnV46AoFAIACgYusmDu35tmMbmyToon5b2Q7PD1IYBHBbE6I+PlaElhIHkj/1gPbziVhirFcG7YnzunZVj0XVrdiUkcXQfWVYFNlf+m4ygaIgyzJHACWzL3WyiRaHg7R+8ffK02grB04tVGi2gqJjwpMSzaRO6Lj7L172uOpoqduOwy3zxLK9Ucp2TbiPTMOasRGTpSXmfudMnkNRehEp1hQyE3NY+PlSbd8dcc6V5KRzX87QsOXb9jfy+oa9eHwyb2/ej8cX+T5nkqAwK4UGh4e6lvCLn5mSwB3TT+GvH2w3NKdA1DCS0oJe2L0+nlxZDr7IbmnhHhQIBAKBQPBdo1vfsciyzG233cakSZMoKSnRHeNyuXC5XNrjpqam7pySQCAQnJAUjhhNcen4uBKLFZS2xFGlQyEiekhAquLskn19V1BFpLqe2UHL1cfHusTYaOnwiVhiHDinQ/SjJrsvdVLwdT0S5bp2VY/FUBdoz5Ympn+znvRWuxZCoigKSBJZWVlceumlZGdnR9pdbALKgU1AD/kSmriS4GRfmR5je0R2DXYDt216AAD30Ym43LMIDRNpRwLFivPgT7ANeCnmfovSixicORiAJ5btCXMkdpVzThUNX/iiAo9vX9TEZ5+icGlpLo8v0xfWPT6Z/fWtuu7JWN+vlNfatTCSubsP4CtrjHnHFe5BgUAgEAgE3yW69R3qzTffzLZt21i1alXEMXPmzOHPf/5zd05DIBAITnjUxOJF8x4wLBBKbcV2XSUM/hAJFZEC+XDqJdrPx7IU1mgSrzruROiTGFoGfYh+/E56HKaFj/0oynXtXI/F9kicUHdifUoa74w8nWtXfxS21XXXXUdycnIcx9EhpBw41fwBzd6LUWjvtSzhIDW3GQ6EbtxG4z44WtG5eUQgUpgIgKKY8TaOAiR8LUUovoSYycUqkfoYdrVzLlLZMYDXp7Cnxs7A7FT2Nzgjlk43Ob0siBB6IitglkDSUR4Vxb/tmxuruXhcnuYajIVwDwoEAoFAIPgu0W3vVm655RY++OADVqxYQW5ubsRxd999N3fccYf2uKmpiQEDBnTXtAQCgeCERRUI33/ofsOpxUIY7BxGS4ePZYlxYDJvUoY7qJS4aml/nA0J/9/encdHVd/7H3+d2ZLMZCEkJBCWkAQUFypLBKu1pVXRXoVqF3erVm3vreJ1qfeit+qvrXWpG5VW3Je2oHW5VqV1K1es1h3UisqWkBCWEBJDJskkme38/hhmMpOZSSaQZIC8nz54kDlz5sx3hozGN5/P9xNpuU3XPomhGM4BlhIc2evj2qA7yEz8wB7C7+vA7LEY3pnOwOHriru3pKUp6ozdv5smtbW1TJkyJaX1pspidJBjewa3P1w9GCTH9gyW/31mQJ8nVcmGiQB0Nc4htEYDTEe/9h7sbR/DgaycS9Z2DKHKxSc/qOOYyYU88tamXv9exesPJr1v6rgRHDwmhw2eLiY7M7BbYv/dWjlxZGSvwaTtxOEvjNA7Gg4VwxOORURERPZVAx4OmqbJggULeO6551i5ciVlZb3/QJSRkUFGRsZAL0NEZL9ktdk4bM7xKYeDsnccvtQqpFI9b6AkC8I6dznoaOyuchuUfRINg7JpM9n0xVrMzraEQcju+jwINmDNHA3EhoNZpNaa7vB5B3iPxdDKDumq4Y13z2WjtxhPYT4LDv05ZTtD13KNHsOsbx7HZ/9Yyc6tW/jiiy8GPByE6OpBZ6hq0PrXAX+OvWUGHHibvkF3+3Nqk4tddlcv0493X3uQK+c8Xj+Pv13DkpWh7537V1bR6Q/GtR77U9yPtXpnG1+bW8bjWxr4ZnkxC0pjJ0q3+QPc+4dP+6waHFmYxchCJwc5Myhw2KicqD23RUREZN834D+tXXrppSxbtoznn3+enJwc6uvrAcjLy9v7th0RkWGgYuYsymfOonrVwAWEMdVSA3bV/V9+SxMXP3F3ZM/B6Fbik1c8TUFzQ1rbdXu2GPdsJR7wfRINg/LpRxI0A5AkGIzlIdDZEXd0NNu507yMDjLZxjjuNa6I3NfzfbUWDuQeiyajM1v5QemnOI6+joPzS/mXPwNaYGfOCJpdudx26rc5Ii+br08u5+2338ZmG5wmiu7qwfNDVYNG/PvUH64BGjoUzdt8NAR7/AVtH5OLF81ZRGluKY/9cxOtnf5e9wEc6Mo5j9fPk+/Xceas8Tz6zxpuf2Vd5L5Of5BpuweHhK3Z6ubjul0x17Ba4uutw2u9951NMN7F4s07uHBsIdm27s/f45t39rnXoAF43F7eXPB1tRKLiIjIfmXAf3JZsmQJAHPmzIk5/uijj3LBBRcM9NOJiBxwrDYb86+6jiduuIYdVRv2+nqG1comWwllXXUDsLoDTzhEs7li2yMLmhsobtyejiVFRLcYd7cSF/LQWVckPH9v90ksLp9E0AxQ89GqfqzRTNgGPZrt1K4owUcwZu/Bnu9rqvsK9r0Xo0lFdhPzxq3Fapgw+QQomUa2pwve+4I140KTiHPsdgAsFgtf+9rXUn6deyLb+gIGXbisrwzq8+yJ+KrBsN6rB8dkh6Yt97YPYLSBrJwLB4LuTh8PvVkdd3/04JDKP+gAAAA1wklEQVS2Lj9fvWVFzP12q8F3Z4zDbo2P+D5t7eCD3bliqz/Io1sbY6oHW2rcGCl8q3Z5A2olFhERkf3OoLQVi4jI3rHabJx+wy08fPnFeFp27dW1zECA6WPt7NqsqsFkHLleDjspNogd6lbiZHq20np3h1t9Pq6fLcajJlaQlZvbr2Aw8ly9tEGbvtjvup7va2+hX889FpPrEQxGKXdm8PbsQ2gLBMi2Wil3Dt1WJhajixzbCwNyrXbLwH56E1YNhvVRPQi97wM4GMJtzABLVlbRlWD/wOh9DhPth+gPmpQWOOP2QWzzB5j+9mcEA6FrmhBXPTj/4GK2bG9lY0Nbr+ucVJStVmIRERHZ76jnQURkH+XIzOSiex7i4csvwdPSvIdXMXHm5LBrc3yVjXSzOgIxrbDbXynA2dKe7mUlNFj7JLZ92cjOmsR7/6UqURt0vru7dTu63TnZEJJoPfdYTCx5MBg2lIHg/iB51WBYansPDqXosC9RMAjd+xx+b8a4fk1RfmRrI22B2Gv2rB48fGwe954zcwBfkYiIiMi+Q+GgiMg+LBQQPsgDl/+IzpaWPZpO7GntvdJlOOsZUI0m1O5qsXXRWZhKxdrQG6x9EjvcLXu9tkRt0OE1R+ttCEm05C3H3bto9gwGPWYGf/SfgLmqlR8W+nE6kv+oU+uupd0XHwJ3eoO8/Gkr350xmimFKbSHZuT0fc4Qubryau788M5ez/G1VEIwi16nawSz8LVU4hj59sAucA/0NfwkWmuXn2ue/iTlKcpt/gCLa3fQ89KJqgdFREREDlQKB0VE9nGOzEx+fM8jPHD5j+hqcffz0WokTmZgp+QOrWTBX2/7JIaHmKQaHIaD0/4GpInO7Xmtvdln0IeFg7J3sqmtIGHF4KOBE7k9cCb8000wpyauhTSs1l3LKc+dkvC+rsY5eHeexGOfLuW1S66hNLe094UWVMCC1dDVmvj+Da/B6zf1fo3wumy2hC3E1fbUfmSbNXoWy09bTruvneqWaq5989q4c6zOGuwj3unzWlZnTUrPOdgStQgnY5rwjw2Nvd4fXT2YqGowLNHegyIiIiIHIoWDIiL7gXBA+MeFl7Nr+7a+HyB9SjWgSvW8dOjZOpyslbg5r4CHzroycruvYSU9g9O9CUgTXavv4SIhseeZFGe08r3SNdS1j+DwvHoqcpqxnvknyBsHQJs3yJJH6mF3HdiS1zfGtZCGJaoYhOiWWxNv0xx2trdSmpvw1FgFFcnva1yfwgVCweAp40tSOrc3pT4/dHnBmzhQs2Zuwzrm+b1+nqHQn6pBixEK/0zAMMCaYIxy9BTl78+ekLBqMHIuqh4UERGR4UHhoIjIfsKRmcl5t97Dw5ddoFbhAbBnAdW+JbrFuLeKwJ7DSXre7quyb28C0kTX6mjMSjjhGJINITHJsnj5XukaXtl2EFVthVRkN1KR0xwKBkumAfD46xtp83ZXTrZ2BWJaSFPRPajDgGAGyz9yUzlmT199/wzI0JGWLdQuO4t2ixGqNiwatffXjOKyuwb0en3pT9Wg1WLwzYOLqGlqp2yUi52YTHZmYE/wvlZOHMmT9V/SGghiJRQm9mSa4PYHebL+Sy4eN7Dvo4iIiMi+ROGgiMh+xJGZyUU/v4qnb/wZ9Z05qG14z0Xvj5daQLVv6q0CMNxK3JRfFHM8fNvh81Jsbo+p7Kt+ZSxWW2wtVXhPxv68H8kGjkRfK9GwkcRDSAw6gg4eq5qJJxB6/qq2Al7cMoV5gQBWQhVmS1bGt4n3Vj3YU/ygDgtPv9fCz47zp/T4fcH27R9xxQBUHyZy/wn3991iPYBSrRq0GgAGvoDJ0RUFPPDDSu6p3cHN1dv5Znlx0rZgs9XD+SUFfa5jdt7QBqIiIiIiQ23/+ElXREQiHA4HZ078Fy9umUJVWwEKCPdcsqArtSm5+7aercTRooeYXPryLTH3lZ+4Ne78/u7B2J/9HBNNOE7MwBPIiLld1VbAi489ybxrj0haYdaf6sHuqsFunq5gv6sP49ide/7Y/nrrbhg9cFVutxx7C+V55bjsriENBgGe+bCO1k5/qD3YgGDc+OFQ6+/00nymjA4NhamcODIyZAR6bwuemuPktoOH8M9GREREZB+lcFBEZD9kNUzmjVvLC3VTqG5XQLi3Ug+o9h89W4eTyrf0fU6UVFqM+7OfY3SLce+VieEJxdEMqj77gufuvJn72iuTPk8q1YPxVYPdzxo9wALA4/Xz5Pt1nDlrfK/TkCN274k4UMKBXdj2tu10BDrIaqmno+HnA/pc5XnlHFpw6IBeM1WVE0dy7lET+jzvzCMncPjYvMjte2p3RIaMaKiIiIiISN8UDoqI7Keshsn88QoIB0J0i/H+0EqcimTDSXoqn1XXr+umEpz2dz/Hvt/vRMFg9121qz/gWGcDLxfNJWjEP3df1YNGEEZXH0FVwEYwwdO0dvljHv/oP2u4/ZV1dPoDfVYUbmpsJ7CzjVTrDv22YkwjE8PsxObfkfCc6MCu1l3LFSuv6L5zgPcYTKfDx+Zx09ip/XpMuGowXGOooSIiIiIifVM4KCKyH4sNCAvpNURJoGxGJYZhoXr1B6Hd9w0DZ+4IPC3NvT6uf8+yfzgQAsFo0cNK2styeXbmeZH7fmouooQtZNHJaLb3cpWQ2hVj6NyVkXJwmtp+jhb8bit9fzel8t1mUu6p4aSGV5MGhMmqB40gzFldTGlDA1XOvyd8vGl2Vw8C3PdGqGW6Z0VhT5sa27nwzieYbGzhwRS+vbZkjqW55I7I7fxtP0saEIYlm7o8UIZ6AMneemRrY6RqMEzVgyIiIiK9UzgoIrK/yciJuRkOCKta8/msZTTVbSOJCVMMg/LpR2Jismn1B5HD5TNnMf+q6wB48e5bqfrwXSpmzubfFvyMvy2+g6pV75FwEoBh4MrNw9OyaxBenAyk/JYmskvasM6w8Szd4WAJWyhjU8rX6dyV0e89GPvazzHfUUx5wVewGQH8ZvKKrqrWT9jlbejz+QygwlNDqWczm1xlcfe3dgW4/40qrp57MBAKvYwgzPloFBMaMgF2B4yv8HLRCQSNUHuxzWLFNA3cnX6e+bCOdm8gsrdhz4rCnnwNG1iZcXWfaw/zWGPfY9PITPmx/XVZxffJyA/tIViYVQhAli2LMa7u0czp2Gdwb/SsGgxT9aCIiIhI7xQOiojsbwoqYMFq6GqNHLICBwEVgQAvPvYkVZ+tjVQCVsyczbwrFwLwwl03U73q/UgwaLWF/jMw78qFbPp4FWXTZmK12Zh35cJQYNgzINx9vSnHfIO//va2IXzRkkx4IrHD542bXGwCNqefTGIHdWTRmfR6tStKCPgslJ+0JXIs4O3fvoTh5zZIvp9jYeZYJuXOIGgGd5/dk4HFsOD2NaUUDppAtXMitc7ke9Qt/r+NfHfGOMoKXYxzjuXauuPZtmND1DNCuaeWCzyvsWPaCdgcTsjIwR/0AeDMbuY3z9ZHPhKmCfe+viFp9aDF19bnugGqs8bSZnWyIzN27QH72NC6erQYb28LVXvuTVXfsYVHcOiUUwFoDwRYtu1Lzi4Zicu6/4ZniaoGw1Q9KCIiIpKcwkERkf1RQUXCw1Zg3rVHxFQCzrtyYSQEnH/VdTEhYORxNhuTKmfH3I4LCHsEjRWVR1H14buD9xqlTz0nEl/8xN3ktzRhAs3WHEYGWvF7bIymjjvNy+ggs89W4nBlX/wejMnbewOZTnwjChNfD/j472Ow2AJYmlrwu0PJ2qbWNRyefywOS/LqOL/pZVPrmr7eBsDANfkrvOybnbClOFp7l5+A38+Lt13Pts/Wx70mA3A11HDC27dyxMSNzJ/QXUn32t/n4PXOJXpoSVuXn3te/5jrTko+EKU31VljOXrWsoT3tRb+R+Tr6Bbj6D0GF81ZtEfPi6N7Su/DWxq5uXo7ncHgfhueJasaDFP1oIiIiEhy/S8FEBGRfVo42PvONdfHBIPh+yZVzo451td1KmaGQsPooDFyX+VRKa/LJHF92IEiHa+t50Rir90RqqDLnECLYyQm0LYtm40vjqdzBeSsaY4JBhvXjGDL20Ux14geEtLRmBXVHpx8379AVja+/CJ8I0bhG1EY96vVPpEWyyQ8ge5hGX7Ty9pd72GaiSu9TDPIZ81v4zd7H6xiAlXOUm5PIRgECAb8odD70097eU0GVW0FvLX5IIzdy0s2zRgsLH1nZ6TVuL/arM6+TyJ5i3FHoGOPntdVGGqvbvMH+G1NPQCLautp86c2aXpf82T9l7QGglgBmxH/ywq4/UGerP8y3UsVERER2eeoclBE5ADUsxJwb67Ts+W4533hKsXemMCmrFJMoLyjFoMDb6jJUL6WcCtxU35ssFc94SDc2XmYbQHKGzdE1tS2LTtyTuHhuyJft+3IYtfGEbhrc1Kc1OwEPHFH7S2NdI0qAauNpO9EwI+9pTHm0Ab3aqaMmI0jQfDlC3rZ6P6ol7V0f19FDxEJOq2U2L7EFfCQ6Qm1T+8082hgJMVmI58+eBP1GzamkOYaNLjzmfNRJiun76Sr+WgIZiQ809MV7HXvwd5kB+Lfz4SrMZO3gqfiloadlPtCAabrnOciewneUVNPezD0ZrQHTO6sqefGSWP36rnSYXaei/NLClI6T0RERERiKRwUEZFe9RY0phIQhveCe7loLgAnNbxKhacGjyULZ7DjgAoIB5YFiK+q69lKHO2tWSdEvg63GEfze2wJb/c9gdgkO6MAb+aZ+NpfxvRXx9xrBIM4murxjhoLRoI/UdPE0VSPEYx9PaHqwXeZmv91DMMSdXqQL1re7bNqMLSybkGnFe+xo6lhNABvv382RZ4mvtr1O8Ck0NNIfc2GhNdJzKB0h5OxO3L4wp2oarB7DX1NLg5rt2SybMzJnL39r7iCnZR3bOXt98/mX5m5XFNyREwrcU7jEqy+rXF7Du6J8nn3cWjuxNBAo93bErT5A/xha2xg+4dtjVw9cTSWoMmT79dx5qzxOB2xr2kg9ygcqGtNzXFy28GpVWGKiIiISCyFgyIisld6DQgNg+oelV0vF82l1LOZuqxxnNjwGuUdtWlY9dDrT6WkxV6BNWsuvtbHwYytLOvZSpxMovPCLcY2px+/xxZTUZiMCTQ6i1lZNI3vZNqh/hR8bcvjAkJHcwPegtG7qwd7CAZwNMcPFTGBd/x1TDJMomOdVKoGYfeE4o7a3ROKS8Fqj329VicvBWbSRiZgsNZZwfGuNwm2+0jlT8PEZHNxB5vsh0MwC0jccmsxrJFpxhccEz8pOdrDY7/HzeU/ptOSwYK60F6D5R1b6Qw0YPXF7tto9W3F7uv985FlS22KtKtkOkRNHq72dPHQlp14grEllO0Bk5urt5O51cMjr2yg0x+Iq4hMukdhU1XMoKRqL7QFQ5HqOx1wdlE2rlGT8H/ZieejBgJtXn6b7eM+SxeNXh/XVpSk9FpEREREZGApHBQRkb3WMyB05uXjaWmm6LAZ/L5tZsxecEHDyiZXKEB5qfhEJnpqOL9wJ42f9x0G7c+SR1GxrboWewV21ykYhhUj90d43Y9EAkITcPj6rqYDcGePSDjBOJVAMMyE3eHuiQQNK591eplvd1CRfQpB3yYCXZ9FQkIjGCSjuYuuAmts9WCSqsFwS/BLo07ExMePsWDBIGia/aoarHZOZFNhOUGbBTMnNrz7NGsSi7t+QCBgx+IJEDDsPDbqTK43FlPblt/HtUPB4MrpO7F47dh97yQ995iiGYwbOZnKiSNjjmfZYyvh2qxZLJ5wNpgmiyeczYXbniM7as/Anq3DqbQSj3GNYflpy2n3tSc9x2V3RdqIIRQMHv3eF0nPf2R3NaHDaY2riAwP/oBQS/IZo0dSlGEPBYOLZ3Q/R4JBKy3vLeZHmT/E8y8PGLAux8IDs52Awe9qG7hs3ChyMmIDXhEREREZfAoHRURkQETvTzjh8CPYvOYTPEWTCN6bfD/CoGGl2lXB9AvPoeqJ31O9+v0hXPHQMoEu7GTgi+y52GGfSLZtCsGON4AOMJzYnN/G2B2mWiwOWksuZpf//8ju3E6Wu5URLU1c/MTdNOaP4i8nnZv0+f5y0jlA4vbiVBnA2pyDu/fzM+AFl5f57Q4mGZOw2svxtS8n6KvCsJVhNG2G/Mmx1YNJqgbD7wnAs3g5lwxcmLRj8pq/ifGRdymxcDD4t4n/RufXE1ecXX3owsjXjjfrsXgCuA0XO0ZPpMKSS9X6zSSKbaODQdMC1sxtWMc8n3Qtq3ieX3xrOaW5eTHHx2bEhnuPlHw3NIDEMGi1uni05LRI9SCAzb+D/G0/wzQy+9VKHB38paItkOLQEauF1g5fzH6KP9+whdZAKOjtCpr859rNPHFERUzFICQetPLbCedx/BseXptgZ+aXfs75avf+fwFMfvP3dfzq5MP79VpEREREZO9pWrGIiAyY8P6EjsxMJlXOJseZeMJqTznOTOZffR3lM2aFDiTat24/ZgLtliwy8eGxhNpAazIn0GYxCXa8DOyuHjM9+D0vYZqh8KYp2+C+eUU8edqZPHTWlXTk5gCQ39JEbltLSs+dahtyojVXZ5VS45wYczwcEG60BcGwYHedgs11Cp1mO/ZgO46mejB3h3pJqgYhtiW4A/gTXRgYLDW8vDDqW1Q5S5NGg9H7WAZTmLwNgNWy+7EW7g98h29Od1GR3UTPALJnMJiqhJV7Wd3VieGqQXP33oqmYWHxhLNps8a2Bdv8O7D7avd6j8HepPyyAkFMM7SfYluXn5d37uLJ+uaYU17/spX3mruDwTXOcn5R/u/8M/eIuMv5LFaumZbFnYdk8sz4Ht+XhsEjmT527UxeASkiIiIig0OVgyIiMmjKCl28/rM5tHf5k57jyrBRVhiqIJp/9XVs+ngVoycdzAM/PR8z1QqnfZgJBLDgCoYCQGewA7/DQVnAB77tcecHfVX42pdjc53MxszYFkuv3RGpc0u1vTjV83qqySrlpeITY1rCI2uMriD0gdv3OVmBUHVgZO9Bi7XPqkH/2EOotU8A4Bm8dAEv4CVoWHm5aC4nNbxKuacmprYvJhg0rBCIDx4TijqvlSyWrq7nJ+PW8uKWKVS1FQDGHgeDqYhUDUaJVA8e+U1wOOC96/t9XZe9/9N3320JBXDhlxj9DlobOrBsbMUIBLF4Qp+/1i4/f3inhrdGJA7tv/NxFW+XAVljOf7IR5M/sWHw6UgbmCbPj4tvHw4Y8P/+Vcui4w7t92sSERERkT2ncFBERAZVOPhLRfRk5P94YCkPXfYjvB2ePh61bzMAW1T8YgA2rxeIDwbDmpy7cGe9w5sFR8cezy8CiOwlePETd7Nr7Eg41sYzxjmR805e8TQFzQ0J9xyE3oejhO/LxsOhRg1thpMac0zceUEDljs7OG3HaxR7N0WuF5lcXDQuadVg2JZmD4ReEp3A03QHmYkCwu5g8HiCBkAAiyeA481tYDUws+34vtI91MP+ry8x2vwQFXSFXqOF+/zz+aH1NeaNW8uybYfS4B45aMFgz6rByDp2Vw9eODIHslKr8Lzl2FsozysH4vcSTNXsPBfnlxQA0OT1s7yxuwo1o6aNYKsv5nx/voO7PttCxyEjkn7j1Pogyz4y8Z09GQaBRNcxDJ40vFzc6uHwHE0eFhERERkqCgdFRGSflJWdzU/u+wMPLbiIDndqLbT7ov5MKQZozivgobOuTHjfX4/7QeTr/3jxN5R0baHUswkDB8/QHQ4WNDdQ1Lg94fOG24XtVoMJ7bXdLcDENtiO6mjg4p3LmDduLcd574gLCC1mgLk7X6W4sybueRxfNmAEg9h3NSZ9nQYw0VPLSQ2vxkyzjhYOCL/d+ALlbfXUFgZZMS4Pq/Eh8WdDwBiBj+O7n6OtC3urN259JgZuXDwT+DoX2F5l+sQN/Je9jC2jOvY8GNz0JnRFVWlm5ES+jKka9AexbvUQGOsEmyVUPdgM83NTC9GnFk7do0Aw5ho5Tm47OLSeak9XTDgY8AZi3q/ASAe+I0fho3f/VQ+zxszbq3WFPbSlgUWHTByQa4mIiIhI3xQOiojIPsuRmcnFix/mqV9ey46qDelezh7p7+6Jqe4ROPaUBsqoAaCe2OAuO9tNht+Pd1fsf+ajW3INAy4b8TrBLesJtdT2XK9BVVsBy2qm4S22xGxUZzEDCVt+I480g0nbiWPOA8o9NX0GhK+Mq+Qg1yNsGdWBw1KX9Hp+WzGeqHDQ7vyEkzobyE9SvVhpWRd6PYZJXXFHwnNS9ur/gNdHrc1Gu2X3uzL313gyc/ltVNWgdXM79g1uCJgEynNC1YNfwoWHjOv31OGBUO7M4O3Zh9DQ4eXCh96joz22lT+Yndr04Do/1I0+cUDW9FT9Lm6aHCDbligCFhEREZGBpnBQRET2aY7MTM765e28cOfNUdOM46OsA0WqewRm0T0JdzTbudO8jA4yyaKT0SeGWpY3LZ9Oy9bQeXF79QGPOb/FD5014PEleScNGjqzObHuJf44/hz8llBQVOrZTIWnZs9eYNwzpBIQWlIK7+Km/Y7cwaUd2znU23vdmyuYfCpyf9TabJwyPmpy8me/o2PyD2i3ZYMZAH8A26ZWTMC2qRVjnAPTbsUdtPFk/ZdcPG5gg79UlTsz+MdH2+ho7sJqGDHzgIKmyVDv/BkEHqxr4Mqy+HZ2ERERERl4CgdFRGSfZ7XZmH/1dbxw80KqP1tLmbMJT8DBjq7cdC9twIX3EvTaHdROruCNI06K3Pd9cynT+AjvZgujJ8TuWTg6wR6G373uOh77xcOYDbVxwSCApytAe4cVJ8nCwRBXsIPz6pZGAsJa5wSqnBOp8NTSc9rvnjCACk8NpZ7NbHKVxd1vBjJSvtaeTPkt9ftZXreNTzPsXFs0qt+PD4tUDEavp2s9ma1/D93YUgD+UYAB/iAzPv+IQ0bVw2GnMjuv/4NFBlLlxJGce9SEuOMtFpOnSXHoy97o0X//z13tJG6uFxEREZGBpnBQRET2C1abjfkXnsWmRd+nLLuZgGnw8MZKPAEHB2IFoc3lp+grscNEwq8yb0JqQ1qCtlweG3kyBVRT65wQEwzagj7OrVuK0+zs890zCAWEP9nxZ074f4uwOTLJsn2Dtx+4ix1rVu31ux+uaqx1xodTAKavkLaNP8OwdgHw2zOmYWQ0cO2b1+7lM3cr9fsThnupcgXNhI+3+2qxNz+OGXDQtuVauv8UDWp2jGTZrhvJ/vZ5kOYBHIePzeOmsVMT3nelp4s/bWvk3rqdg/b8pZl2Mq3dvevnlKQ43ERERERE9prCQRER2W9YnSOYlPNl6GvD5KJJHx5wAWFvA0meNs7h6d2DR+40L0tYLRjtpU+24u4yac8ux2J0bxtoMQOcuv0FsoOp77NnAEZnK58+cBtn/+o3WG022s+/nPtuvDHp3oOpNH8nandOeJ6vEHN3d3BZ7sFYMrNTXvtAu+zLZsb6/WQFTcYEAriCJqV+P587ku/P520+GoKxFZCtuPjD7Bf5aUHFYC95r5Q7MzitOJ9VLe285x6Y6eEG3d8XQeCSCUVcPG7PqzZFREREZM8pHBQRkf1HQQUsWA1drQA4gIu8Xh6+6S48rW3pXdsASXUgSQeZfZ5j+/Bpzp11MViiQrdgANdby7B7+x4YksiO6vUsu+VXHP3jq2jpCvJy0dyEw0lGOIopzD8GA8jxtyYND//h28nLI2f1GgzuKyxBC5Pdk7l3xAaCllCr7fK6bZT6/b0+zgw48DZ9g5ipLoRe/33vN/PD4/xkZ+zbP5JNzXFy9yGlHP3eFwnvtwCJCi+DZij8m5Xn4hBX8u/ZdLdVi4iIiAxn+/ZPoiIiIj31qLJyABf97jEevvxiPC279uCCPTY7SzNXRvJptdGiB5Ik07h2PTMDLzD/quuw2mwE/H5evPtWqrYlDnhSYQA71qzizoX/w/wrFxI0rHEBoQkYOV9hpnMyftPEwIyah9x9JYth4a+mh6DRe7jWkyvDhsWeWpg0UMNGAMZ6xnJ48+F4bB7qskNTk1NpRU5UNRjW2uXnD+/U8NM5kwZsnYMlPNm4LRAg2xoKcz92t/Nak5vcPiYLn1tSwNQ0t06LiIiISGKGaZoD91PzAHC73eTl5dHS0kJu7oG30byIiAwOb2cnT/3iWnZUb+jX45w52ftU1WFWYQd53+uig0y2MY57jSsi9/3UXEQJW0ITiZO0FNeuKKFzl4OA14rXHapCLJ4wltMvvYjN66t4/uGlA7bW0d/7Kf+zOvRjhMUMcFLDq1R4aqhyTuSNork8a4wgu5fgtdUM8l2jjdSbm+H+82Zy4mGjAajd8DLtT5+b9Nxwu2+qPnfYOWNs8gm5X63/KiUdJWxzbuOd4neo6BjPXVunkR8MVRE2Wyy86ooNLU3Twv+6D2GDmbzlODfTxtvXHrfPVw+KiIiIyP6jP/mafgoVEZEDgiMzk7N+dTsv3Hkz1avfp2x6JYbFQvXqDyDR34MZBhUzZ/NvC35G9eoP+L9H76fDvWvI191TwGtNGvyVsIUyNvX6+M5dDjoas2KO7di8ladu+BnfK12D0zpzr/doDO8TOLUom8OMf4UOGrC5+CDaPSNpchYy0djMm7TwbXMCPdtpAYKmyVLDuzsYTL1686DinMjXpa7R4PXt8euI+O6DUHgQrvZ6ePuayOGMQAaTWyZjmKG1FXcUh373FDO1aSoVneP52JzM1MBYsrBjD8BJu7ova2BgxcpGOtjQo9LTiolhsWGaBu5OP898WMcFx8RPahYRERERGWwKB0VE5IBhtdmYf/V1bPp4FWXTZgKE2mhXvRcbEO4OBudduRCrzcaUo4+lfMaRPHz5JXhamtO0+hCv28HnT1RgdQRoG5MLx3Tf5/4ki+rtY+lsDu3dZnUEsDoCTJpXFzkn4E3c3rmjK4dHN86kIzgwweB7RUdx78p5zO3ZLRu1rVzQzGJ712OYxLcAtxvwLN7dtxKv5/7zZjJ2RHfQ6cqwUVY4CHvTFR4EJdMoBZYXH0K7r53qlmpu/futTGqZhBUr5u5/Qqs1mOyejIHBGutmKgLFZJlZGMT/YNVm6eS1nH9iNwIxx4/q6KT0oFPAVQBA5URN5xURERGR9FA4KCIiBxSrzcakytmR2/OuXBgbEPYIBsMcmZlcdM+DPLTgIjrcLelYekS4HTibFu40L6ODTLLopGVjBu7G+JaAcJgY3Uocz6Ajyb53qTKBdksWr446nglG3wNNLEYHObZncPvPI7p6MIjJUrpi2okN4NTpY7noa6HquUELAhPJiKpGzC2NfN2S0cKKsSs4quEocnw5WHa/BgsWTEzcdjdnezspMBOvM0iQpwpexix8NW58zBkNOznlm+dCydQBfzkiIiIiIv2hcFBERA5oVputOyD88N2EwWA0Y9+ZTRLXYvyltyLheckDwUT2fACLAbiCHczd+Xc2Fx+U0mOyrctp9X8/pnqwneiqwe5VrfhsG7+aHSTbYQEvsC3qhIycuGE0KdvdNpxQH9dtdbSycsxK5m2eF3ffyjErmd7kZpR3PtYEAaHH0sny/Df2bM0iIiIiIkNE4aCIiBzwwgFhuN04UTAY8Pt5+lfX4WlJb9VgtOgW496rAvsjMk94jx9d4amh3TOSuHK4BMLVgy3+H2JgEMTkCTrw4e/+IcSwYppB3F4rzzx0CxfYXk18sQWrY4O8qIq/XtmTTMlNMXAs7CzEwMDEjPm9sLOQ3xT5qLH8nfN3zotUFkK4avBVOqxdCa+ZNYBTlEVERERE9obCQRERGRZ6thtHC/j9vHj3rdRvXD/Eq+pbdCDoyPUOUFC45wFheM/BJmdhyo/Jti6nxX86Jpn48GG1vMaZRtQU4bEzYesqACot65JfqKs19nZBRSgw7HkcoGUL/Pmc0Nfh3xPpGTgCNFXh+nJz9/Lax4YOZzTx6chPmfrlVAq7CilpL2G7azsv5q/k9Ka5uILd+yP2VTU4yZf6FGURERERkcGkcFBERIa9TR+vourDd9O9jF45cr0celZV5PbnT1QMQEAYq6+4MBwMvlw0l0OMzb2cGctidJBnewq3/3xG2ZZxo+2Z2BMaHgV7ypeLtaetxmHhYLGpKvT17lCxFFhus7HRbmNxVjNuh5v1eevBgDfGvMFBLQcR2D1kpMPaxVMFr0aqB3tWDd7SsJPyqDDQFTQp9SscFBEREZF9g8JBEREZ9sqmzaSi8qj4qcb7EKsj0Ovt/jPJsnjxBDMY6SimLOcr+A0bdjMAJHoPDJqLvMz90YWc1rUd+y4Pn7+WONFLFH5lW1/AoAuX9ZW9XHcfwiFfY4pVoI3rYcuH8Ler4+6y+0eyLfgVcmyhtuRpTdPizpnWOI1NOZsi1YPOYGZc1WC5z8+hXl/8c6faFi0iIiIiMogUDoqIyLAXM7RkHwsIw63EmSNiB3iEb+9Zi7FJuauJk8et429bD8ZimcHk3BkETBPDMBO8fgOLYSH3uIk0j2jjnOfOCh0eOybpMyyv2xYTEFqMLnJsL/RznbFq2+tpr34VvJ6E9+/atYkR//fr7gOO2PAyYcXe/16S9PnqKKEqOJWy1mDScyxYaLW3UpVXxVMFr3Lhzu/0utdgxHl/2fuqRxERERGRAaBwUEREhNQDQmfeCCbPOppPXvvboK+pZytxtNLjukf5xrcY99YgHAoG549fi9UwmTduLZvaWjA4GqvhCj0uwUONTCvZs8awpS21irx2y+6LnPcXyMpPfFLj+l7DuWi1NhunvH1N3yf2ElhCd2jpDVbQHpjb67kTAbvdh6+XnmevxUttTi0Az498nS6Ll5dHvJX45DOWQt64vZu8LCIiIiIywBQOioiI7NZXQOjMy+eiex7EkZnJUd8/m/t/cu7grifF1uH485IHg1kWLyePW4fVCL02q2EyKWcbbv8z7PL/EEvCZBBy5ozHkmGDthQX/92HYNTUAQvBwmHjiK4RTGyd2Of5m3I20ZIRP3k6fB1v8BDaAycDyduowcqh9qf5mHyMhHs0mqzLW4ffEqpG7LJ4eX7k64kXdMZSOOSUPtctIiIiIjLULOlegIiIyL4kHBBWzJwNRncgNHrSQZFgECB7xAh+cv+fsDkyBm0tAa91QM8Dg46gg79tPZiAGRt2ZVuX00ni9lkjw0r2V3uvyIsz6qBBqY4r6CygorWCstaypL8qWiso7Ox9mrLTugKDdsBK6O9Ke/6yYtBGue1F/Ebi4SE+i4/q3OrUFl50SMqvUURERERkKCkcFBER6SEmIAQqKo/izF/8JhIMhmWPGMF/PLiUorJJA/K8E6dVUlwxOXLb63bw+RMVrHt2IrUrSmLOrV1RwrpnJ+7B1GKDqrYCXtwyJSYgtBgdvEJDfA1ddNXgPqA2pxaf4cPSyz/Rrb7JWIwOcmzPQJJAFILk2J7Bbmll3Yh1mD3emZ5Vg71xzf+92ohFREREZJ+lcFBERCSBcED4nWuuZ96VC7HaEodjjsxMzr7pDiZOq9yr5yufOYtTr/k5Z/3ydioqj4pULXrdDjoas+jcFRsAdu4KHe//MBIIBYSFbGqL3QvwdRox7bE/GuxR1eBA++6DcOYyAPwWf8KwLqw/oV22dTkGHQnvM/CQbf0rAFW5VXHVg6lUDS6adC7L59xL6eFn9LkWEREREZF02TfKAERERPZBVpuNSZWzUzrv1Gt+zrp33+LvD/0eX0fiwCmZ8pmzmH/VdZEAct6VC3nq9hvY+vEnkb3uerYOB7w9/34vHJYl228w9tyK7CbKsptjjv78tEMY4ZmA+9WayEyTQa0azMhJ7byxM4Hu6b9VuVUcvOtg7Gb8oJD+tPqGqwfd/vOI/fvSUNWgxejAFbRFAsnDmg/DwEgYQC6qb2DMcb+E7GIAXFkFlJYem9rrExERERFJI4WDIiIiA8Bqs3Ho1+YwqfIonvrlteyo2tD3gwyDipmz4yoTrTYbp1/zS566/Qa2ffIpmGakxdjqCJIxtpy1gQBl7MAglONVuJrAMKhuG0nvAWEoGJw3bm1kKEnYjPH5BAvG0PpGHWZnYPCrBgsqYMFq6GpNfk54sm/T55FDPcO6sP5UDYZlW5fT6v8+Jq7IseiqwVK/n+V129hlNLLccii+oIHDZuGGb52N3R4KbF3WTEpHTlbrsIiIiIjslxQOioiIDCBHZiZn/fJ2qla9z2dv/J3qVe/jzMvH0xJbpZcsGAwLB4TRk5O9rRlUzJzN1B8u4Nd3vcFJ5qtUeGpodBZx5fi3AHhxyxSq2gpIHBAmDwYByMjBkmEj5xvjcb9Sk7Bq0GV3xT8ugVTP29NALVH1YL8GhOwWXz3YXTUYVur3U4of91dnsOKdj/n6N77FEVNVFSgiIiIiBwbDNM3Em/akidvtJi8vj5aWFnJzc9O9HBERkT0W8PvZ9PEqJhx+BH9bfAdVH75LhstFV3s7FZVH9bqXYfQ1Xrz7Vqo+fDfmMZsa22n1dNL4xSeUlOQx5dlvhc43jSQBoUmrcwQfFs/GNEIttD+dU8HJU3dXBoYr9ICgN0D7+/W4Zo3G4oifhFzrrqXd1550zS67i9Lc0tTfqBTUums55blTYo4dvOvgmFbfNflrWD9ifa/XWV63jVJ/VGXhGUsJ+mD7U9mYfguG3WTMqQ1Y7FE/HtmdUHQI3pzxrF69mhkzZuBw7MlejyIiIiIiQ6M/+ZrCQRERkSEQHRRuXvMJZdNm9hkM9nxsr49pqoq059Y1tfH7ux6h0NMQaTuud47mf4vmEzS6w77XfzaHssIUK/z2AbXuWtob14HXA4DPF2D5C5/h8wWx2y0ce1IphfljIG9c6AEtWyLnwu72X9fo7gtGBaLu1+twv1JD7kkTyZ0zfshek4iIiIjIYFA4KCIiMsxV7Wjh7QfuomHNKooOn8kR51+OxdodLLoybPtVMJjMm2++yYoVKzjuuOM49tg9b/Xtq1pSRERERGR/onBQREREUqs43M95vV61+oqIiIiI9NCffO3A/D8FERERwWqzMalydrqXMagcDgdHHXVUupchIiIiIrLfsqR7ASIiIiIiIiIiIpIeCgdFRERERERERESGKYWDIiIiIiIiIiIiw5TCQRERERERERERkWFK4aCIiIiIiIiIiMgwpXBQRERERERERERkmFI4KCIiIiIiIiIiMkwpHBQRERERERERERmmFA6KiIiIiIiIiIgMUwoHRUREREREREREhimFgyIiIiIiIiIiIsOUwkEREREREREREZFhSuGgiIiIiIiIiIjIMKVwUEREREREREREZJhSOCgiIiIiIiIiIjJMKRwUEREREREREREZphQOioiIiIiIiIiIDFMKB0VERERERERERIYphYMiIiIiIiIiIiLDlMJBERERERERERGRYcqW7gX0ZJomAG63O80rERERERERERER2f+Ec7VwztabfS4cbG1tBWD8+PFpXomIiIiIiIiIiMj+q7W1lby8vF7PMcxUIsQhFAwG2bZtGzk5ORiGkZY1uN1uxo8fT11dHbm5uWlZg0g66TMgw5m+/2W402dAhjt9BmS402dAhrsD5TNgmiatra2UlJRgsfS+q+A+VzlosVgYN25cupcBQG5u7n79jSCyt/QZkOFM3/8y3OkzIMOdPgMy3OkzIMPdgfAZ6KtiMEwDSURERERERERERIYphYMiIiIiIiIiIiLDlMLBBDIyMrjxxhvJyMhI91JE0kKfARnO9P0vw50+AzLc6TMgw50+AzLcDcfPwD43kERERERERERERESGhioHRUREREREREREhimFgyIiIiIiIiIiIsOUwkEREREREREREZFhSuGgiIiIiIiIiIjIMKVwMEVdXV1MmzYNwzD4+OOP070ckSFRU1PDRRddRFlZGVlZWVRUVHDjjTfi9XrTvTSRQfP73/+eiRMnkpmZyezZs3n//ffTvSSRIXHLLbdw5JFHkpOTQ1FREaeeeirr1q1L97JE0uLWW2/FMAyuuOKKdC9FZMhs3bqVc889l4KCArKyspg6dSoffvhhupclMiQCgQDXX399zP/7/upXv2K4zPBVOJii//qv/6KkpCTdyxAZUmvXriUYDHL//ffz2Wefcffdd3Pfffdx3XXXpXtpIoPiz3/+M1dddRU33ngjq1ev5ogjjuDEE0+koaEh3UsTGXRvvPEGl156Ke+++y6vvfYaPp+PuXPn0t7enu6liQypDz74gPvvv5+vfOUr6V6KyJBpbm7mmGOOwW6389JLL/H5559z5513kp+fn+6liQyJ2267jSVLlvC73/2OL774gttuu43f/OY3LF68ON1LGxKGOVxi0L3w0ksvcdVVV/Hss89y2GGH8dFHHzFt2rR0L0skLW6//XaWLFlCdXV1upciMuBmz57NkUceye9+9zsAgsEg48ePZ8GCBSxcuDDNqxMZWjt37qSoqIg33niDr3/96+lejsiQaGtrY8aMGdx7773cdNNNTJs2jUWLFqV7WSKDbuHChfzzn//kzTffTPdSRNLilFNOobi4mIcffjhy7Hvf+x5ZWVn86U9/SuPKhoYqB/uwY8cOLrnkEv74xz/idDrTvRyRtGtpaWHkyJHpXobIgPN6vaxatYrjjz8+csxisXD88cfzzjvvpHFlIunR0tICoH/ny7By6aWXcvLJJ8f8t0BkOHjhhReorKzkBz/4AUVFRUyfPp0HH3ww3csSGTJHH300K1asYP369QB88sknvPXWW3z7299O88qGhi3dC9iXmabJBRdcwL//+79TWVlJTU1NupckklYbN25k8eLF3HHHHeleisiAa2xsJBAIUFxcHHO8uLiYtWvXpmlVIukRDAa54oorOOaYYzj88MPTvRyRIfHkk0+yevVqPvjgg3QvRWTIVVdXs2TJEq666iquu+46PvjgAy6//HIcDgfnn39+upcnMugWLlyI2+1mypQpWK1WAoEAv/71rznnnHPSvbQhMSwrBxcuXIhhGL3+Wrt2LYsXL6a1tZVrr7023UsWGVCpfgaibd26lZNOOokf/OAHXHLJJWlauYiIDIVLL72UNWvW8OSTT6Z7KSJDoq6ujv/8z/9k6dKlZGZmpns5IkMuGAwyY8YMbr75ZqZPn86Pf/xjLrnkEu677750L01kSDz11FMsXbqUZcuWsXr1ah5//HHuuOMOHn/88XQvbUgMyz0Hd+7cSVNTU6/nlJeXc/rpp/Piiy9iGEbkeCAQwGq1cs455wybbxI58KT6GXA4HABs27aNOXPmcNRRR/HYY49hsQzLv1eQA5zX68XpdPLMM89w6qmnRo6ff/757Nq1i+effz59ixMZQpdddhnPP/88//jHPygrK0v3ckSGxF/+8hdOO+00rFZr5FggEMAwDCwWC11dXTH3iRxoSktLOeGEE3jooYcix5YsWcJNN93E1q1b07gykaExfvx4Fi5cyKWXXho5dtNNN/GnP/1pWHQRDcu24lGjRjFq1Kg+z7vnnnu46aabIre3bdvGiSeeyJ///Gdmz549mEsUGVSpfgYgVDH4zW9+k5kzZ/Loo48qGJQDlsPhYObMmaxYsSISDgaDQVasWMFll12W3sWJDAHTNFmwYAHPPfccK1euVDAow8pxxx3Hp59+GnPswgsvZMqUKfz3f/+3gkE54B1zzDGsW7cu5tj69espLS1N04pEhpbH44n7f12r1UowGEzTiobWsAwHUzVhwoSY29nZ2QBUVFQwbty4dCxJZEht3bqVOXPmUFpayh133MHOnTsj940ePTqNKxMZHFdddRXnn38+lZWVzJo1i0WLFtHe3s6FF16Y7qWJDLpLL72UZcuW8fzzz5OTk0N9fT0AeXl5ZGVlpXl1IoMrJycnbn9Nl8tFQUGB9t2UYeHKK6/k6KOP5uabb+b000/n/fff54EHHuCBBx5I99JEhsS8efP49a9/zYQJEzjssMP46KOPuOuuu/jRj36U7qUNCYWDIpLUa6+9xsaNG9m4cWNcID4MdySQYeCMM85g586d3HDDDdTX1zNt2jRefvnluCElIgeiJUuWADBnzpyY448++igXXHDB0C9IRESGzJFHHslzzz3Htddeyy9/+UvKyspYtGjRsBnGILJ48WKuv/56fvrTn9LQ0EBJSQk/+clPuOGGG9K9tCExLPccFBERERERERERkWE6rVhEREREREREREQUDoqIiIiIiIiIiAxbCgdFRERERERERESGKYWDIiIiIiIiIiIiw5TCQRERERERERERkWFK4aCIiIiIiIiIiMgwpXBQRERERERERERkmFI4KCIiIiIiIiIiMkwpHBQRERERERERERmmFA6KiIiIiIiIiIgMUwoHRUREREREREREhimFgyIiIiIiIiIiIsPU/wekrgVAFPGI4QAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ], + "source": [ + "# Pick which folder to use downstream (Section 6)\n", + "# RGB_Masks_Specimen ~ 450\n", + "# Oriented_Leaf_ECT ~ 9,000\n", + "# Leaf_BBox ~ 9,000\n", + "# Lamina_RGB ~ 9,000\n", + "ACTIVE = \"Oriented_Leaf_ECT\"\n", + "paths, embeddings, labels = datasets[ACTIVE]\n", + "print(\"active dataset:\", ACTIVE, embeddings.shape)\n", + "\n", + "# Reduce embeddings to 2D\n", + "coords = umap.UMAP(n_components=2, random_state=42).fit_transform(embeddings)\n", + "\n", + "# Family is the 2nd part of the label (order_family_genus_species)\n", + "def family_of(label):\n", + " return label.split(\"_\")[1] if label != \"unknown\" else \"unknown\"\n", + "\n", + "# Assign a marker shape per family\n", + "markers = [\"s\", \"*\", \"o\", \"^\", \"D\", \"v\", \"P\", \"X\"] # square, asterisk, circle...\n", + "families = sorted(set(family_of(l) for l in labels))\n", + "family_marker = {f: markers[i % len(markers)] for i, f in enumerate(families)}\n", + "\n", + "# Plot: color by species, marker shape by family\n", + "plt.figure(figsize=(16, 8))\n", + "for sp in sorted(set(labels)):\n", + " idx = [i for i, l in enumerate(labels) if l == sp]\n", + " plt.scatter(coords[idx, 0], coords[idx, 1], label=sp, s=40,\n", + " marker=family_marker[family_of(sp)])\n", + "plt.legend(fontsize=8); plt.title(f\"DINOv2 embeddings — {ACTIVE} (UMAP 2D)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "3wEBtY5Gpw4J" + }, + "outputs": [], + "source": [ + "BASE = \"/content/drive/MyDrive/hypeRGB/\"\n", + "train_csv = pd.read_csv(BASE + \"metadata_train_v2.csv\")\n", + "test_csv = pd.read_csv(BASE + \"metadata_test_v2.csv\")\n", + "grass_train = pd.read_csv(BASE + \"metadata_train_grasses_v2.csv\")\n", + "grass_test = pd.read_csv(BASE + \"metadata_test_grasses_v2.csv\")\n", + "\n", + "# Images are named by specimenId, so we split at the specimenId level.\n", + "# specimenId as str(int) has no leading zeros -> matches image_key() below.\n", + "def id_set(df):\n", + " return set(df[\"specimenId\"].astype(str))\n", + "\n", + "train_ids = id_set(train_csv)\n", + "test_ids = id_set(test_csv)\n", + "grass_ids = id_set(grass_train) | id_set(grass_test)\n", + "\n", + "# A specimenId can appear in both CSVs (split is per-measurement); test wins,\n", + "# so no specimen leaks across train and test.\n", + "train_ids = train_ids - test_ids" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tAX90lIFkPDy", + "outputId": "a0c2906c-42d2-47f6-df85-e787cc3eab0a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "ALL species: 4907 train / 1811 test, 23 classes, test accuracy 67.09%\n", + "NO grasses: 2995 train / 997 test, 20 classes, test accuracy 65.10%\n" + ] + } + ], + "source": [ + "# ======================================================================\n", + "# SECTION 6 — Train an MLP classifier using the predefined train/test split\n", + "# ======================================================================\n", + "# The split is given by CSV files. We build two dataset variants:\n", + "# (A) ALL species\n", + "# (B) ALL species EXCEPT grasses (the grasses CSVs are used only to exclude)\n", + "\n", + "\n", + "# Get the specimenId key from an image path (matches species_of)\n", + "def image_key(p):\n", + " stem = Path(p).stem\n", + " stem = stem.split(\"__\")[0] if \"__\" in stem else stem\n", + " return stem.lstrip(\"0\") # image files keep leading zeros; the ids do not\n", + "\n", + "# Assign each embedded image to train/test using the CSV specimenId splits.\n", + "# Labels reuse `labels` (species_of) computed in Section 5.\n", + "def build_split(exclude_grasses):\n", + " Xtr, ytr, Xte, yte = [], [], [], []\n", + " for emb, p, lab in zip(embeddings, paths, labels):\n", + " key = image_key(p)\n", + " if lab == \"unknown\":\n", + " continue\n", + " if exclude_grasses and key in grass_ids:\n", + " continue\n", + " if key in test_ids:\n", + " Xte.append(emb); yte.append(lab)\n", + " elif key in train_ids:\n", + " Xtr.append(emb); ytr.append(lab)\n", + " return np.array(Xtr), ytr, np.array(Xte), yte\n", + "\n", + "# Train a small MLP on one variant and print test accuracy\n", + "def train_eval(X_train, y_train_lab, X_test, y_test_lab, title):\n", + " le = LabelEncoder().fit(y_train_lab + y_test_lab)\n", + " y_train = le.transform(y_train_lab)\n", + " y_test = le.transform(y_test_lab)\n", + "\n", + " X_train_t = torch.tensor(X_train, dtype=torch.float32).to(DEVICE)\n", + " y_train_t = torch.tensor(y_train, dtype=torch.long).to(DEVICE)\n", + " X_test_t = torch.tensor(X_test, dtype=torch.float32).to(DEVICE)\n", + " y_test_t = torch.tensor(y_test, dtype=torch.long).to(DEVICE)\n", + "\n", + " clf = nn.Sequential(\n", + " nn.Linear(EMBED_DIM, 256),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.2),\n", + " nn.Linear(256, len(le.classes_)),\n", + " ).to(DEVICE)\n", + "\n", + " optimizer = torch.optim.Adam(clf.parameters(), lr=1e-3)\n", + " loss_fn = nn.CrossEntropyLoss()\n", + "\n", + " for epoch in range(100):\n", + " clf.train()\n", + " optimizer.zero_grad()\n", + " loss = loss_fn(clf(X_train_t), y_train_t)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " clf.eval()\n", + " with torch.no_grad():\n", + " logits = clf(X_test_t)\n", + " y_pred_t = logits.argmax(1)\n", + "\n", + " acc = (y_pred_t == y_test_t).float().mean().item()\n", + "\n", + "\n", + " print(f\"{title}: {len(y_train_lab)} train / {len(y_test_lab)} test, \"\n", + " f\"{len(le.classes_)} classes, test accuracy {acc:.2%}\")\n", + "\n", + "# Variant A: everything\n", + "Xtr, ytr, Xte, yte = build_split(exclude_grasses=False)\n", + "train_eval(Xtr, ytr, Xte, yte, \"ALL species\")\n", + "\n", + "# Variant B: everything except grasses\n", + "Xtr, ytr, Xte, yte = build_split(exclude_grasses=True)\n", + "train_eval(Xtr, ytr, Xte, yte, \"NO grasses\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PZVdbplHV2KF" + }, + "source": [ + "# ResNet-18" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "-GqBXTOOl4ag", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 580, + "referenced_widgets": [ + "c8337913d5cd4a348dcb64134cf4463b", + "5deb1d9f2c32442ab84a303de2db0e91", + "e817ca6bb2b64a7aa83567c56dd85bf2", + "312d628b41534e9c9683bc154418c226", + "e41e6f0c084d4d6ba3eee885d9f19301", + "accd65e00e294658a74b780d58f5b6ee", + "d3958081187d4b32aa884987fb454884", + "0b4f508f26aa421ab31bf7317776042f", + "3881a665c8d84818b9e0788801611ee2", + "16062234c42a43909b835adf99f8aaf9", + "9799895b34284de2b3613dd431563e1a", + "dde04a65e535469eb127a071e1b426b0", + "5197b8be57974d18aa317dc54b4e962c", + "907f398bc7de4acea237537006d5dce3", + "df792e8833954b4db74c97d959d7d027", + "b88212ca959b4e5081f58e2ee86954dd", + "e0b0adf4a9a24f0797a2386611898263", + "42449ff17894463ca01efe4ebadbb79a", + "7e91b8cbbc504e49beba06c7516698e3", + "65e21733c9354860a46d9394beafffdd", + "f5d12f58856d47b1b070d4c3c530b0b5", + "2ab73d3e1fc1484b9fa7a5ed461bed13", + "c1918393b6d34b76a3df2a5919bba8bb", + "6d8473f41ae04c3598d84bdc3d36a2a4", + "3621a1c2e9764d518b0613c77fd08052", + "464c1847c0fc46c4aef2b8590c45336e", + "56b158724d2a4fa19392e847cb638c6d", + "3bf8345d46774c83b93a86060049d26f", + "239f6447548248efbe3b7cc5dbea3341", + "a19532305d514a338977f1b6123d12cc", + "f7d4bc80c439448a8e9dd4e83ea54ddf", + "c4dfe577090d4cb698b769031e19cded", + "778941484dbe4ff59aad3fbe7148aa70", + "a19dd3bf98974e8c917a5c9fa9163e07", + "82b412242d5844c59ba935b6c367df5d", + "ec9ecb479e96483ca145c3d7797b2342", + "44245a53c96e49d9942206bee55088d8", + "d58accfa18474597a4e846273d751816", + "e0e4a70c9e91442e8f7256fa0df0a532", + "836a2ae6d7f242fb80f2609efb9b6de7", + "538e829cf32248cb8e980eef9c1e5e7f", + "9586a61cda224a709046a9679bebe19b", + "913b7f2471c84ca0b2913255ca8dd89a", + "1ca706a861614ae0a9c260a41f2a052f", + "d79a2ac7b2614c99a5fdddb7936ca300", + "c09c762961724f67ad4b13d418313ba4", + "b7376f298a1846d28fb8ebe473697700", + "799899d000874a6f82f0e58ecf44065a", + "03d9bab668f848d59c68877996bda1c2", + "e7b3fe60b945430c88ff1bfafcabaafd", + "b1bc5ae5153343a4918b788fa83a3897", + "678926e1ac9941d9b219ae164d9ef486", + "1835a503ae4e45cfac89c61fc7c357c5", + "74507f9b15c34d80836d6e11503c5bea", + "7624734ca32442ee8ba6365a66f7e27c", + "ba63a7490f0b4d8aa83ce961813a1bc2", + "18028624fece48029948a7e3ae32e7f6", + "9cab190bd9ae4997892a1b617a4b2d6f", + "a04e660c28f8469ca880b3bd000a7125", + "47408834924d4905899347b7486d5a54", + "2ea5578d7f464256bf0d2eec25dacf87", + "edcea5cad63947d09e0c61af54c6829c", + "161813c374f94d3db816ed7be3b71a3d", + "73da3183ee8f49a0a8ff153abbb37efd", + "8017819fb3f5485397105ea05066f3cd", + "2de2707f83da4f69b8e0417d5059328b", + "4e0e8de5af734cec92fd3949246480e8", + "516929c2ef214a8c92ed72cf5e18ee08", + "73665398b89144a997133bdb1cf65d65", + "908cad5a4aac4f5889199a1fa7db2f56", + "ed461ba131544dbc83eae09af0be6c59", + "3eef4956cf964d85813683a13e0e9306", + "62340b17fd4a46bbbb617a30581681ba", + "5ee763ccbc9e4abc9d8a7bc06e7bca26", + "76511f3b70874fd5b76106218f724a04", + "85e9d3bdc6ee43f3adb7e6f55c54c329", + "f9d41898b2064244b720a347c58d7959", + "93f2d3aa72b8488aad7e071b4bed6144", + "e33c262e77144684b00c47d3531ea0fb", + "ad97b543b79642d49f0ccd96fcdf5c69", + "f299aea953134404a375a85490a1fdb3", + "97af0699123c4282a809bc7c75886e1f", + "3d2fb4b8eff84803b387e9bac8c353a0", + "c4b8e9f39f27487a88d6b0673068d1b2", + "63f4d865aa2e40b88abf2918eec5a1f2", + "4f4eeee51349488b929b3b66a6af5e6d", + "646da2ced58a4788acf87cee87a4941f", + "05357cb07ca54be7a56a000a304fafa2", + "5346f146ce014bfaa2d9bf587c180629", + "877a03fca38a45d3b904b58377ff3451", + "00f994033ca24dda9a5ad4b6c68f7189", + "96c8b27730a448be996f46a7b2e9e327", + "b9a50b29b145443dbb51b72ca437f0a4", + "e689222307084a42a1c1948e19b3f1dc", + "4e81c7d2758c4650afbde0b0c26fe5ac", + "f28baa3a548f436f9e0153051dbb4744", + "c28066bd1a31444dbfb2432840a128cb", + "80796619778846c69143bcaa3a205fe9", + "5a262a172f4547c59c0a55fe3ae0fc30", + "da5f326645bb4fa9943c624bd8d0c7e0", + "a1967898e529488f932e7e5571d39148", + "b9baa8f7c4084b399460ad67a25cf3e6", + "b90e84cd41f24e22b5f8ae25d54794ea", + "cb98de6828d9409aa6b6a8e40179f120", + "27c28817c83542f6803e2269bc224391", + "7983248be50c4491921c030ac7efe391", + "95967a17e0d2450c9f3570d999426e5c", + "a20460dfe8b14178bc4745fbe867ae75", + "94251e158de54e6bb26fbfbf25062873", + "568ce191c1e545419325c4f00c0cc2b4" + ] + }, + "outputId": "b543da5e-53d4-45be-f27c-0b949677852a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Oriented_Leaf_ECT: 4907 train / 1811 test images\n", + "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 44.7M/44.7M [00:00<00:00, 179MB/s]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "epoch 1/10: 0%| | 0/154 [00:00 outputs a feature vector\n", + "class Tower(nn.Module):\n", + " def __init__(self, pretrained):\n", + " super().__init__()\n", + " weights = models.ResNet18_Weights.DEFAULT if pretrained else None\n", + " backbone = models.resnet18(weights=weights)\n", + " self.out_dim = backbone.fc.in_features # 512 for resnet18\n", + " backbone.fc = nn.Identity() # swap the head for a pass-through\n", + " self.backbone = backbone\n", + " def forward(self, x):\n", + " return self.backbone(x) # [B, 512]\n", + "\n", + "# Two towers + an MLP over the concatenated features\n", + "class TwoTowerNet(nn.Module):\n", + " def __init__(self, n_classes, pretrained):\n", + " super().__init__()\n", + " self.tower_a = Tower(pretrained) # CNN A\n", + " self.tower_b = Tower(pretrained) # CNN B (separate weights)\n", + " fused_dim = self.tower_a.out_dim + self.tower_b.out_dim # 512 + 512\n", + " # New layers: an MLP head that takes the fused vector\n", + " self.classifier = nn.Sequential(\n", + " nn.Linear(fused_dim, 256),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.2),\n", + " nn.Linear(256, n_classes),\n", + " )\n", + " def forward(self, xa, xb):\n", + " za = self.tower_a(xa) # feature vector from image A\n", + " zb = self.tower_b(xb) # feature vector from image B\n", + " z = torch.cat([za, zb], dim=1) # late fusion = concatenate\n", + " return self.classifier(z)\n", + "\n", + "# --- Train/test split + labels, read straight from the CSVs (standalone) ---\n", + "BASE = HYPERGB + \"/\"\n", + "train_csv = pd.read_csv(BASE + \"metadata_train_v2.csv\")\n", + "test_csv = pd.read_csv(BASE + \"metadata_test_v2.csv\")\n", + "grass_train = pd.read_csv(BASE + \"metadata_train_grasses_v2.csv\")\n", + "grass_test = pd.read_csv(BASE + \"metadata_test_grasses_v2.csv\")\n", + "\n", + "# specimenId sets for each split (str(int) has no leading zeros)\n", + "def id_set(df):\n", + " return set(df[\"specimenId\"].astype(str))\n", + "\n", + "test_ids = id_set(test_csv)\n", + "train_ids = id_set(train_csv) - test_ids # test wins if a specimen is in both\n", + "grass_ids = id_set(grass_train) | id_set(grass_test)\n", + "\n", + "# Build specimenId -> species label (order_family_genus_species) from the CSVs\n", + "def make_label(row):\n", + " epithet = str(row[\"species\"]).strip().split(\" \")[1] # \"Genus species\" -> species\n", + " parts = [row[\"order\"], row[\"family\"], row[\"genus\"], epithet]\n", + " return \"_\".join(str(x).strip() for x in parts).lower()\n", + "\n", + "label_of = {}\n", + "for df in (train_csv, test_csv, grass_train, grass_test):\n", + " for _, r in df.iterrows():\n", + " label_of[str(r[\"specimenId\"])] = make_label(r)\n", + "\n", + "# path -> specimenId key (leading zeros stripped to match the ids above)\n", + "def image_key(p):\n", + " stem = Path(p).stem\n", + " stem = stem.split(\"__\")[0] if \"__\" in stem else stem\n", + " return stem.lstrip(\"0\")\n", + "\n", + "# Gather image paths straight from a folder (no embeddings needed here)\n", + "def list_images(dataset_name):\n", + " folder = Path(HYPERGB) / dataset_name\n", + " paths = sorted([p for p in folder.rglob(\"*\")\n", + " if p.suffix.lower() in [\".jpg\", \".jpeg\", \".png\"]])\n", + " assert len(paths) > 0, f\"No images found under {folder} — check the path\"\n", + " return paths\n", + "\n", + "# Group each folder's images by specimenId so we can pair A with B\n", + "def paths_by_key(dataset_name):\n", + " grouped = defaultdict(list)\n", + " for p in list_images(dataset_name):\n", + " grouped[image_key(p)].append(p)\n", + " return grouped\n", + "\n", + "a_by_key = paths_by_key(TOWER_A_DATASET)\n", + "b_by_key = paths_by_key(TOWER_B_DATASET)\n", + "\n", + "# Build (imageA, imageB) pairs for specimens present in BOTH folders\n", + "def build_pairs(exclude_grasses):\n", + " tr_pairs, tr_y, te_pairs, te_y = [], [], [], []\n", + " for key in sorted(a_by_key.keys() & b_by_key.keys()):\n", + " lab = label_of.get(key, \"unknown\")\n", + " if lab == \"unknown\":\n", + " continue\n", + " if exclude_grasses and key in grass_ids:\n", + " continue\n", + " # pair the i-th image of A with the i-th image of B for this specimen\n", + " for pa, pb in zip(sorted(a_by_key[key]), sorted(b_by_key[key])):\n", + " if key in test_ids:\n", + " te_pairs.append((pa, pb)); te_y.append(lab)\n", + " elif key in train_ids:\n", + " tr_pairs.append((pa, pb)); tr_y.append(lab)\n", + " return tr_pairs, tr_y, te_pairs, te_y\n", + "\n", + "tr_pairs, tr_y, te_pairs, te_y = build_pairs(EXCLUDE_GRASSES)\n", + "print(f\"{TOWER_A_DATASET} + {TOWER_B_DATASET}: \"\n", + " f\"{len(tr_pairs)} train / {len(te_pairs)} test pairs\")\n", + "\n", + "# Encode species names to integers\n", + "le = LabelEncoder().fit(tr_y + te_y)\n", + "\n", + "# Dataset: returns both images plus the label\n", + "class PairDataset(Dataset):\n", + " def __init__(self, pairs, labs):\n", + " self.pairs = pairs\n", + " self.y = le.transform(labs)\n", + " def __len__(self):\n", + " return len(self.pairs)\n", + " def __getitem__(self, i):\n", + " pa, pb = self.pairs[i]\n", + " xa = preprocess(Image.open(pa).convert(\"RGB\"))\n", + " xb = preprocess(Image.open(pb).convert(\"RGB\"))\n", + " return xa, xb, int(self.y[i])\n", + "\n", + "train_loader = DataLoader(PairDataset(tr_pairs, tr_y), batch_size=BATCH, shuffle=True,\n", + " num_workers=0, pin_memory=(DEVICE == \"cuda\"))\n", + "test_loader = DataLoader(PairDataset(te_pairs, te_y), batch_size=BATCH, shuffle=False,\n", + " num_workers=0, pin_memory=(DEVICE == \"cuda\"))\n", + "\n", + "# Build the model\n", + "net = TwoTowerNet(n_classes=len(le.classes_), pretrained=PRETRAINED).to(DEVICE)\n", + "\n", + "optimizer = torch.optim.Adam(net.parameters(), lr=1e-4)\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "scaler = torch.amp.GradScaler(\"cuda\", enabled=(DEVICE == \"cuda\"))\n", + "\n", + "# Train\n", + "for epoch in range(EPOCHS):\n", + " net.train()\n", + " running = 0.0\n", + " for xa, xb, yb in tqdm(train_loader, desc=f\"epoch {epoch+1}/{EPOCHS}\"):\n", + " xa = xa.to(DEVICE, non_blocking=True)\n", + " xb = xb.to(DEVICE, non_blocking=True)\n", + " yb = yb.to(DEVICE, non_blocking=True)\n", + " optimizer.zero_grad()\n", + " with torch.autocast(\"cuda\", dtype=torch.float16, enabled=(DEVICE == \"cuda\")):\n", + " loss = loss_fn(net(xa, xb), yb)\n", + " scaler.scale(loss).backward()\n", + " scaler.step(optimizer)\n", + " scaler.update()\n", + " running += loss.item() * xa.size(0)\n", + " print(f\" train loss {running/len(tr_pairs):.3f}\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "FqJ-j19ZxrEK", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 66, + "referenced_widgets": [ + "0fbe1a8f8be74500b9b6e18c05f12c4d", + "3f9fa70baba1471fa14ac4a3f040a984", + "eb6c13a0fc43400db158a84251595e89", + "99d54fc754de41a0a7dacc9ec8e4afd4", + "17c1f306a5f94d2595868277b13c4566", + "b5a1e46cacb042d99623145e056dd8a3", + "ca4d8e8afe3f42558a3ab9322e46e7a0", + "c52c5851fb604df28fe8369fab6a94fb", + "a0bf17169aed4a0380af5b9e907b97a5", + "34903d34a93f4f57b06a91af5290a9c6", + "c8fcd6ff456d4a9e95bca8904a19a7ff" + ] + }, + "outputId": "7ce26ef4-bb1e-4d30-e731-b430f6e4b94b" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "evaluating: 0%| | 0/57 [00:00