{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "ca72c15d-7d1b-45af-b6d5-9abec82bd5bb", "metadata": {}, "source": [ "# InstantID: Zero-shot Identity-Preserving Generation using OpenVINO\n", "\n", "Nowadays has been significant progress in personalized image synthesis with methods such as Textual Inversion, DreamBooth, and LoRA.\n", "However, their real-world applicability is hindered by high storage demands, lengthy fine-tuning processes, and the need for multiple reference images. Conversely, existing ID embedding-based methods, while requiring only a single forward inference, face challenges: they either necessitate extensive fine-tuning across numerous model parameters, lack compatibility with community pre-trained models, or fail to maintain high face fidelity. \n", "\n", "[InstantID](https://instantid.github.io/) is a tuning-free method to achieve ID-Preserving generation with only single image, supporting various downstream tasks.\n", "![applications.png](https://github.com/InstantID/InstantID/blob/main/assets/applications.png?raw=true)\n", "\n", "Given only one reference ID image, InstantID aims to generate customized images with various poses or styles from a single reference ID image while ensuring high fidelity. Following figure provides an overview of the method. It incorporates three crucial components: \n", "\n", "1. An ID embedding that captures robust semantic face information; \n", "2. A lightweight adapted module with decoupled cross-attention, facilitating the use of an image as a visual prompt;\n", "3. An IdentityNet that encodes the detailed features from the reference facial image with additional spatial control.\n", "\n", "![instantid-components.png](https://instantid.github.io/static/documents/pipeline.png)\n", "\n", "The difference InstantID from previous works in the following aspects: \n", "1. do not involve UNet training, so it can preserve the generation ability of the original text-to-image model and be compatible with existing pre-trained models and ControlNets in the community;\n", "2. doesn't require test-time tuning, so for a specific character, there is no need to collect multiple images for fine-tuning, only a single image needs to be inferred once;\n", "3. achieve better face fidelity, and retain the editability of text.\n", "\n", "You can find more details about the approach with [project web page](https://instantid.github.io/), [paper](https://arxiv.org/abs/2401.07519) and [original repository](https://github.com/InstantID/InstantID)\n", "\n", "In this tutorial, we consider how to use InstantID with OpenVINO. An additional part demonstrates how to run optimization with [NNCF](https://github.com/openvinotoolkit/nncf/) to speed up pipeline.\n", "#### Table of contents:\n", "- [Prerequisites](#Prerequisites)\n", "- [Convert and prepare Face IdentityNet](#Convert-and-prepare-Face-IdentityNet)\n", " - [Select Inference Device for Face Recognition](#Select-Inference-Device-for-Face-Recognition)\n", " - [Perform Face Identity extraction](#Perform-Face-Identity-extraction)\n", "- [Prepare InstantID pipeline](#Prepare-InstantID-pipeline)\n", "- [Convert InstantID pipeline components to OpenVINO Intermediate Representation format](#Convert-InstantID-pipeline-components-to-OpenVINO-Intermediate-Representation-format)\n", " - [ControlNet](#ControlNet)\n", " - [Unet](#Unet)\n", " - [VAE Decoder](#VAE-Decoder)\n", " - [Text Encoders](#Text-Encoders)\n", " - [Image Projection Model](#Image-Projection-Model)\n", "- [Prepare OpenVINO InstantID Pipeline](#Prepare-OpenVINO-InstantID-Pipeline)\n", "- [Run OpenVINO pipeline inference](#Run-OpenVINO-pipeline-inference)\n", " - [Select inference device for InstantID](#Select-inference-device-for-InstantID)\n", " - [Create pipeline](#Create-pipeline)\n", " - [Run inference](#Run-inference)\n", "- [Quantization](#Quantization)\n", " - [Prepare calibration datasets](#Prepare-calibration-datasets)\n", " - [Run quantization](#Run-quantization)\n", " - [Run ControlNet Quantization](#Run-ControlNet-Quantization)\n", " - [Run UNet Hybrid Quantization](#Run-UNet-Hybrid-Quantization)\n", " - [Run Weights Compression](#Run-Weights-Compression)\n", " - [Compare model file sizes](#Compare-model-file-sizes)\n", " - [Compare inference time of the FP16 and INT8 pipelines](#Compare-inference-time-of-the-FP16-and-INT8-pipelines)\n", "- [Interactive demo](#Interactive-demo)\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a42ecb80-d4e9-4056-a648-fe42090210fd", "metadata": {}, "source": [ "## Prerequisites\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 1, "id": "70df6ac1-94f7-4de3-bf55-49743b79e796", "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "import sys\n", "\n", "repo_dir = Path(\"InstantID\")\n", "\n", "if not repo_dir.exists():\n", " !git clone https://github.com/InstantID/InstantID.git\n", "\n", "sys.path.append(str(repo_dir))" ] }, { "cell_type": "code", "execution_count": null, "id": "6fa0bd47-175f-4433-914b-1d0c241a6743", "metadata": {}, "outputs": [], "source": [ "%pip install -q \"openvino>=2023.3.0\" opencv-python transformers diffusers accelerate gdown \"scikit-image>=0.19.2\" \"gradio>=4.19\" \"nncf>=2.9.0\" \"datasets>=2.14.6\" \"peft==0.6.2\"" ] }, { "attachments": {}, "cell_type": "markdown", "id": "476ffd57-00cf-4f29-b3a0-8c087807a031", "metadata": {}, "source": [ "## Convert and prepare Face IdentityNet\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "For getting face embeddings and pose key points, InstantID uses [InsightFace](https://github.com/deepinsight/insightface) face analytic library. Its models are distributed in ONNX format and can be run with OpenVINO.\n", "For preparing the face image, we need to detect the bounding boxes and keypoints for the face using the RetinaFace model, crop the detected face, align the face location using landmarks, and provide each face into the Arcface face embedding model for getting the person's identity embeddings.\n", "\n", "The code below downloads the InsightFace Antelopev2 model kit and provides a simple interface compatible with InsightFace for getting face recognition results." ] }, { "cell_type": "code", "execution_count": 3, "id": "1fc7104a-52c6-4223-a291-a4546bd0d474", "metadata": {}, "outputs": [], "source": [ "MODELS_DIR = Path(\"models\")\n", "face_detector_path = MODELS_DIR / \"antelopev2\" / \"scrfd_10g_bnkps.onnx\"\n", "face_embeddings_path = MODELS_DIR / \"antelopev2\" / \"glintr100.onnx\"" ] }, { "cell_type": "code", "execution_count": 4, "id": "a46856da-b88c-473e-9745-d1bdc83c8c9d", "metadata": {}, "outputs": [], "source": [ "from zipfile import ZipFile\n", "import gdown\n", "\n", "archive_file = Path(\"antelopev2.zip\")\n", "\n", "if not face_detector_path.exists() or face_embeddings_path.exists():\n", " if not archive_file.exists():\n", " gdown.download(\n", " \"https://drive.google.com/uc?id=18wEUfMNohBJ4K3Ly5wpTejPfDzp-8fI8\",\n", " str(archive_file),\n", " )\n", " with ZipFile(archive_file, \"r\") as zip_face_models:\n", " zip_face_models.extractall(MODELS_DIR)" ] }, { "cell_type": "code", "execution_count": 5, "id": "d6e1580d-2c29-40fb-a086-0f53287f6a1f", "metadata": {}, "outputs": [], "source": [ "import cv2\n", "import numpy as np\n", "from skimage import transform as trans\n", "\n", "\n", "def softmax(z):\n", " assert len(z.shape) == 2\n", " s = np.max(z, axis=1)\n", " s = s[:, np.newaxis] # necessary step to do broadcasting\n", " e_x = np.exp(z - s)\n", " div = np.sum(e_x, axis=1)\n", " div = div[:, np.newaxis] # dito\n", " return e_x / div\n", "\n", "\n", "def distance2bbox(points, distance, max_shape=None):\n", " \"\"\"Decode distance prediction to bounding box.\n", "\n", " Args:\n", " points (Tensor): Shape (n, 2), [x, y].\n", " distance (Tensor): Distance from the given point to 4\n", " boundaries (left, top, right, bottom).\n", " max_shape (tuple): Shape of the image.\n", "\n", " Returns:\n", " Tensor: Decoded bboxes.\n", " \"\"\"\n", " x1 = points[:, 0] - distance[:, 0]\n", " y1 = points[:, 1] - distance[:, 1]\n", " x2 = points[:, 0] + distance[:, 2]\n", " y2 = points[:, 1] + distance[:, 3]\n", " if max_shape is not None:\n", " x1 = x1.clamp(min=0, max=max_shape[1])\n", " y1 = y1.clamp(min=0, max=max_shape[0])\n", " x2 = x2.clamp(min=0, max=max_shape[1])\n", " y2 = y2.clamp(min=0, max=max_shape[0])\n", " return np.stack([x1, y1, x2, y2], axis=-1)\n", "\n", "\n", "def distance2kps(points, distance, max_shape=None):\n", " \"\"\"Decode distance prediction to bounding box.\n", "\n", " Args:\n", " points (Tensor): Shape (n, 2), [x, y].\n", " distance (Tensor): Distance from the given point to 4\n", " boundaries (left, top, right, bottom).\n", " max_shape (tuple): Shape of the image.\n", "\n", " Returns:\n", " Tensor: Decoded bboxes.\n", " \"\"\"\n", " preds = []\n", " for i in range(0, distance.shape[1], 2):\n", " px = points[:, i % 2] + distance[:, i]\n", " py = points[:, i % 2 + 1] + distance[:, i + 1]\n", " if max_shape is not None:\n", " px = px.clamp(min=0, max=max_shape[1])\n", " py = py.clamp(min=0, max=max_shape[0])\n", " preds.append(px)\n", " preds.append(py)\n", " return np.stack(preds, axis=-1)\n", "\n", "\n", "def prepare_input(image, std, mean, reverse_channels=True):\n", " normalized_image = (image.astype(np.float32) - mean) / std\n", " if reverse_channels:\n", " normalized_image = normalized_image[:, :, ::-1]\n", " input_tensor = np.expand_dims(np.transpose(normalized_image, (2, 0, 1)), 0)\n", " return input_tensor\n", "\n", "\n", "class RetinaFace:\n", " def __init__(self, ov_model):\n", " self.taskname = \"detection\"\n", " self.ov_model = ov_model\n", " self.center_cache = {}\n", " self.nms_thresh = 0.4\n", " self.det_thresh = 0.5\n", " self._init_vars()\n", "\n", " def _init_vars(self):\n", " self.input_size = (640, 640)\n", " outputs = self.ov_model.outputs\n", " self.input_mean = 127.5\n", " self.input_std = 128.0\n", " # print(self.output_names)\n", " # assert len(outputs)==10 or len(outputs)==15\n", " self.use_kps = False\n", " self._anchor_ratio = 1.0\n", " self._num_anchors = 1\n", " if len(outputs) == 6:\n", " self.fmc = 3\n", " self._feat_stride_fpn = [8, 16, 32]\n", " self._num_anchors = 2\n", " elif len(outputs) == 9:\n", " self.fmc = 3\n", " self._feat_stride_fpn = [8, 16, 32]\n", " self._num_anchors = 2\n", " self.use_kps = True\n", " elif len(outputs) == 10:\n", " self.fmc = 5\n", " self._feat_stride_fpn = [8, 16, 32, 64, 128]\n", " self._num_anchors = 1\n", " elif len(outputs) == 15:\n", " self.fmc = 5\n", " self._feat_stride_fpn = [8, 16, 32, 64, 128]\n", " self._num_anchors = 1\n", " self.use_kps = True\n", "\n", " def prepare(self, **kwargs):\n", " nms_thresh = kwargs.get(\"nms_thresh\", None)\n", " if nms_thresh is not None:\n", " self.nms_thresh = nms_thresh\n", " det_thresh = kwargs.get(\"det_thresh\", None)\n", " if det_thresh is not None:\n", " self.det_thresh = det_thresh\n", " input_size = kwargs.get(\"input_size\", None)\n", " if input_size is not None:\n", " if self.input_size is not None:\n", " print(\"warning: det_size is already set in detection model, ignore\")\n", " else:\n", " self.input_size = input_size\n", "\n", " def forward(self, img, threshold):\n", " scores_list = []\n", " bboxes_list = []\n", " kpss_list = []\n", " blob = prepare_input(img, self.input_mean, self.input_std, True)\n", " net_outs = self.ov_model(blob)\n", "\n", " input_height = blob.shape[2]\n", " input_width = blob.shape[3]\n", " fmc = self.fmc\n", " for idx, stride in enumerate(self._feat_stride_fpn):\n", " scores = net_outs[idx]\n", " bbox_preds = net_outs[idx + fmc]\n", " bbox_preds = bbox_preds * stride\n", " if self.use_kps:\n", " kps_preds = net_outs[idx + fmc * 2] * stride\n", " height = input_height // stride\n", " width = input_width // stride\n", " key = (height, width, stride)\n", " if key in self.center_cache:\n", " anchor_centers = self.center_cache[key]\n", " else:\n", " anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32)\n", " anchor_centers = (anchor_centers * stride).reshape((-1, 2))\n", " if self._num_anchors > 1:\n", " anchor_centers = np.stack([anchor_centers] * self._num_anchors, axis=1).reshape((-1, 2))\n", " if len(self.center_cache) < 100:\n", " self.center_cache[key] = anchor_centers\n", "\n", " pos_inds = np.where(scores >= threshold)[0]\n", " bboxes = distance2bbox(anchor_centers, bbox_preds)\n", " pos_scores = scores[pos_inds]\n", " pos_bboxes = bboxes[pos_inds]\n", " scores_list.append(pos_scores)\n", " bboxes_list.append(pos_bboxes)\n", " if self.use_kps:\n", " kpss = distance2kps(anchor_centers, kps_preds)\n", " # kpss = kps_preds\n", " kpss = kpss.reshape((kpss.shape[0], -1, 2))\n", " pos_kpss = kpss[pos_inds]\n", " kpss_list.append(pos_kpss)\n", " return scores_list, bboxes_list, kpss_list\n", "\n", " def detect(self, img, input_size=None, max_num=0, metric=\"default\"):\n", " assert input_size is not None or self.input_size is not None\n", " input_size = self.input_size if input_size is None else input_size\n", "\n", " im_ratio = float(img.shape[0]) / img.shape[1]\n", " model_ratio = float(input_size[1]) / input_size[0]\n", " if im_ratio > model_ratio:\n", " new_height = input_size[1]\n", " new_width = int(new_height / im_ratio)\n", " else:\n", " new_width = input_size[0]\n", " new_height = int(new_width * im_ratio)\n", " det_scale = float(new_height) / img.shape[0]\n", " resized_img = cv2.resize(img, (new_width, new_height))\n", " det_img = np.zeros((input_size[1], input_size[0], 3), dtype=np.uint8)\n", " det_img[:new_height, :new_width, :] = resized_img\n", "\n", " scores_list, bboxes_list, kpss_list = self.forward(det_img, self.det_thresh)\n", "\n", " scores = np.vstack(scores_list)\n", " scores_ravel = scores.ravel()\n", " order = scores_ravel.argsort()[::-1]\n", " bboxes = np.vstack(bboxes_list) / det_scale\n", " if self.use_kps:\n", " kpss = np.vstack(kpss_list) / det_scale\n", " pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False)\n", " pre_det = pre_det[order, :]\n", " keep = self.nms(pre_det)\n", " det = pre_det[keep, :]\n", " if self.use_kps:\n", " kpss = kpss[order, :, :]\n", " kpss = kpss[keep, :, :]\n", " else:\n", " kpss = None\n", " if max_num > 0 and det.shape[0] > max_num:\n", " area = (det[:, 2] - det[:, 0]) * (det[:, 3] - det[:, 1])\n", " img_center = img.shape[0] // 2, img.shape[1] // 2\n", " offsets = np.vstack(\n", " [\n", " (det[:, 0] + det[:, 2]) / 2 - img_center[1],\n", " (det[:, 1] + det[:, 3]) / 2 - img_center[0],\n", " ]\n", " )\n", " offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)\n", " if metric == \"max\":\n", " values = area\n", " else:\n", " values = area - offset_dist_squared * 2.0 # some extra weight on the centering\n", " bindex = np.argsort(values)[::-1] # some extra weight on the centering\n", " bindex = bindex[0:max_num]\n", " det = det[bindex, :]\n", " if kpss is not None:\n", " kpss = kpss[bindex, :]\n", " return det, kpss\n", "\n", " def nms(self, dets):\n", " thresh = self.nms_thresh\n", " x1 = dets[:, 0]\n", " y1 = dets[:, 1]\n", " x2 = dets[:, 2]\n", " y2 = dets[:, 3]\n", " scores = dets[:, 4]\n", "\n", " areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n", " order = scores.argsort()[::-1]\n", "\n", " keep = []\n", " while order.size > 0:\n", " i = order[0]\n", " keep.append(i)\n", " xx1 = np.maximum(x1[i], x1[order[1:]])\n", " yy1 = np.maximum(y1[i], y1[order[1:]])\n", " xx2 = np.minimum(x2[i], x2[order[1:]])\n", " yy2 = np.minimum(y2[i], y2[order[1:]])\n", "\n", " w = np.maximum(0.0, xx2 - xx1 + 1)\n", " h = np.maximum(0.0, yy2 - yy1 + 1)\n", " inter = w * h\n", " ovr = inter / (areas[i] + areas[order[1:]] - inter)\n", "\n", " inds = np.where(ovr <= thresh)[0]\n", " order = order[inds + 1]\n", "\n", " return keep\n", "\n", "\n", "arcface_dst = np.array(\n", " [\n", " [38.2946, 51.6963],\n", " [73.5318, 51.5014],\n", " [56.0252, 71.7366],\n", " [41.5493, 92.3655],\n", " [70.7299, 92.2041],\n", " ],\n", " dtype=np.float32,\n", ")\n", "\n", "\n", "def estimate_norm(lmk, image_size=112, mode=\"arcface\"):\n", " assert lmk.shape == (5, 2)\n", " assert image_size % 112 == 0 or image_size % 128 == 0\n", " if image_size % 112 == 0:\n", " ratio = float(image_size) / 112.0\n", " diff_x = 0\n", " else:\n", " ratio = float(image_size) / 128.0\n", " diff_x = 8.0 * ratio\n", " dst = arcface_dst * ratio\n", " dst[:, 0] += diff_x\n", " tform = trans.SimilarityTransform()\n", " tform.estimate(lmk, dst)\n", " M = tform.params[0:2, :]\n", " return M\n", "\n", "\n", "def norm_crop(img, landmark, image_size=112, mode=\"arcface\"):\n", " M = estimate_norm(landmark, image_size, mode)\n", " warped = cv2.warpAffine(img, M, (image_size, image_size), borderValue=0.0)\n", " return warped\n", "\n", "\n", "class FaceEmbeddings:\n", " def __init__(self, ov_model):\n", " self.ov_model = ov_model\n", " self.taskname = \"recognition\"\n", " input_mean = 127.5\n", " input_std = 127.5\n", " self.input_mean = input_mean\n", " self.input_std = input_std\n", " input_shape = self.ov_model.inputs[0].partial_shape\n", " self.input_size = (input_shape[3].get_length(), input_shape[2].get_length())\n", " self.input_shape = input_shape\n", "\n", " def get(self, img, kps):\n", " aimg = norm_crop(img, landmark=kps, image_size=self.input_size[0])\n", " embedding = self.get_feat(aimg).flatten()\n", " return embedding\n", "\n", " def get_feat(self, imgs):\n", " if not isinstance(imgs, list):\n", " imgs = [imgs]\n", " input_size = self.input_size\n", " blob = np.concatenate([prepare_input(cv2.resize(img, input_size), self.input_mean, self.input_std, True) for img in imgs])\n", "\n", " net_out = self.ov_model(blob)[0]\n", " return net_out\n", "\n", " def forward(self, batch_data):\n", " blob = (batch_data - self.input_mean) / self.input_std\n", " net_out = self.ov_model(blob)[0]\n", " return net_out\n", "\n", "\n", "class OVFaceAnalysis:\n", " def __init__(self, detect_model, embedding_model):\n", " self.det_model = RetinaFace(detect_model)\n", " self.embed_model = FaceEmbeddings(embedding_model)\n", "\n", " def get(self, img, max_num=0):\n", " bboxes, kpss = self.det_model.detect(img, max_num=max_num, metric=\"default\")\n", " if bboxes.shape[0] == 0:\n", " return []\n", " ret = []\n", " for i in range(bboxes.shape[0]):\n", " bbox = bboxes[i, 0:4]\n", " det_score = bboxes[i, 4]\n", " kps = None\n", " if kpss is not None:\n", " kps = kpss[i]\n", " embedding = self.embed_model.get(img, kps)\n", " ret.append({\"bbox\": bbox, \"score\": det_score, \"kps\": kps, \"embedding\": embedding})\n", " return ret" ] }, { "attachments": {}, "cell_type": "markdown", "id": "58f01590-d63c-4312-80fb-0ad42c287d47", "metadata": {}, "source": [ "Now, let's see models inference result\n", "\n", "### Select Inference Device for Face Recognition\n", "[back to top ⬆️](#Table-of-contents:)\n", "### Select Inference Device for Face Recognition" ] }, { "cell_type": "code", "execution_count": 6, "id": "d9a6a55f-6e17-443f-a423-3b7d89ad539d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c636605a586a43749aeabe60c391baa7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Device:', index=1, options=('CPU', 'AUTO'), value='AUTO')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import openvino as ov\n", "import ipywidgets as widgets\n", "\n", "core = ov.Core()\n", "\n", "device = widgets.Dropdown(\n", " options=core.available_devices + [\"AUTO\"],\n", " value=\"AUTO\",\n", " description=\"Device:\",\n", " disabled=False,\n", ")\n", "\n", "device" ] }, { "cell_type": "code", "execution_count": 7, "id": "1407dafb-eff9-46a4-9b1c-40fc10cc47cf", "metadata": {}, "outputs": [], "source": [ "core = ov.Core()\n", "face_detector = core.compile_model(face_detector_path, device.value)\n", "face_embedding = core.compile_model(face_embeddings_path, device.value)" ] }, { "cell_type": "code", "execution_count": 8, "id": "99da0cde-cfee-4cbf-a392-62c3e6fc1774", "metadata": {}, "outputs": [], "source": [ "app = OVFaceAnalysis(face_detector, face_embedding)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "95d2b544-5f37-4590-81c1-8316b0000059", "metadata": {}, "source": [ "### Perform Face Identity extraction\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Now, we can apply our `OVFaceAnalysis` pipeline on an image for collection face embeddings and key points for reflection on the generated image" ] }, { "cell_type": "code", "execution_count": null, "id": "207fb678", "metadata": {}, "outputs": [], "source": [ "import PIL.Image\n", "from pipeline_stable_diffusion_xl_instantid import draw_kps\n", "\n", "\n", "def get_face_info(face_image: PIL.Image.Image):\n", " r\"\"\"\n", " Retrieve face information from the input face image.\n", "\n", " Args:\n", " face_image (PIL.Image.Image):\n", " An image containing a face.\n", "\n", " Returns:\n", " face_emb (numpy.ndarray):\n", " Facial embedding extracted from the face image.\n", " face_kps (PIL.Image.Image):\n", " Facial keypoints drawn on the face image.\n", " \"\"\"\n", " face_image = face_image.resize((832, 800))\n", " # prepare face emb\n", " face_info = app.get(cv2.cvtColor(np.array(face_image), cv2.COLOR_RGB2BGR))\n", " if len(face_info) == 0:\n", " raise RuntimeError(\"Couldn't find the face on the image\")\n", " face_info = sorted(\n", " face_info,\n", " key=lambda x: (x[\"bbox\"][2] - x[\"bbox\"][0]) * x[\"bbox\"][3] - x[\"bbox\"][1],\n", " )[\n", " -1\n", " ] # only use the maximum face\n", " face_emb = face_info[\"embedding\"]\n", " face_kps = draw_kps(face_image, face_info[\"kps\"])\n", " return face_emb, face_kps" ] }, { "cell_type": "code", "execution_count": 10, "id": "cb3210b1-83c3-4814-ad7e-0a997619c931", "metadata": {}, "outputs": [], "source": [ "from diffusers.utils import load_image\n", "\n", "face_image = load_image(\"https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/vermeer.jpg\")\n", "\n", "face_emb, face_kps = get_face_info(face_image)" ] }, { "cell_type": "code", "execution_count": 11, "id": "aa87f98c-681e-4668-b91f-f429381a679b", "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAABHGlDQ1BJQ0MgUHJvZmlsZQAAeJxjYGDiyUnOLWYSYGDIzSspCnJ3UoiIjFJgv8PAyCDJwMygyWCZmFxc4BgQ4MOAE3y7BlQNBJd1QWbhVocVcKWkFicD6T9AHJdcUFTCwMAYA2Rzl5cUgNgZQLZIUjaYXQNiFwEdCGRPALHTIewlYDUQ9g6wmpAgZyD7DJDtkI7ETkJiQ+0FAeZkIxJdTQQoSa0oAdFuTgwMoDCFiCLCCiHGLAbExgwMTEsQYvmLGBgsvgLFJyDEkmYyMGxvZWCQuIUQU1nAwMDfwsCw7XxyaVEZ1GopID7NeJI5mXUSRzb3NwF70UBpE8WPmhOMJKwnubEGlse+zS6oYu3cOKtmTeb+2suHXxr8/w8A3kFTfazGM+sAAQAASURBVHgBXP35j2VJdid2+u7Pn+97eOwRWblUZu0sFsmm2CpQItgQRt2QWtPSDAbz8wAz078N5l9qYCBo1NCPoroFtmYoqovdxSrWklmZkZmxh+/r8+erPse+7o8pGTxu2D12dju2XLt27Q2/92j5sqWRkZGxsbGhoaGLliYnO9fX1+Pj4+BnZ2dXV1dKh4eHj457ExMT4PKQ4VxfDyudmpoCcSM/NDSiqHE9HxkaHh5pSMPDo6OjeINHEMwwAZyZmdnd3UUl0+/3O50b6aenp2Sdn5+jityjoyMZHFx7vd75eX9ycjI6w8STtgS5Li4uojo5OXEbWXNzc7EFQ+RYEcRAeSqSiy1MwOPjY3BAzCErohs4TLe0UoptPEAuQjgYBl8RhyglHROENFEUwtevtz7++H2W/uIXv6DS9PT0mzdv4PAGPjjjg2e32z04OACUj1F0mxwfg7m/vw/IaswhzM7ODl1du8UKzt7enlJoyEdHh+kMJ4aDS277/XOY9EHCWNpKF1eX55dD1/QeVolDo8N0GRm+ui7nj4/hIFO1M1EcDg+Pp6enAPGHRhMKFH4LjHgGUAok+QsyLi+ZxkXkouWHeBga86lHMVLguwVUirM8DeVVOnvdcgImvHp4eIghTbrdzvHJ4fj46MREB+YwC4aHe70+rSYmJrGdmZ7jk06nS+67d+9WVpY63cnDo4Pd3b3p6S40nqdPeBLHObTlJXmlaJXis729TSLm+LiV1OPm5ia05CGr06WlJQGws7PHG+vrqw8fPvz888/lmcNMhiBHKEP5+fl5Jh+f9JgWBHJJYQiSsZFRrOArcksQF5EyMj6ClaKwxQ0raarTxQ0tE4KJ2/hEcR4aEiEHjx494H84II3bOWbwXWMFfPnO5BSfyHB1GOIGwS2Jg8QVlR++vrrQuqGP8APXIWEOZNwSachlGPL27bv1jXWsXrx+pamqzcmxCtrTkx5aCGivLysOx5ssukljE9VMIEj6G5zJihqBE3d4tK+aUJPVO+ovLs7KwCGFow4ODpeWFq+GhwAxVNeY4MYbT5482dnZ2ttDPg1fkaq5Or8Qb5zAHJiABKFlHqecXl7Ozs2RxUBRBwFP3NKc9YSoeBiknDIycnp+ClmVyV9X863W4aq+EJ6d9ldWVkQXqunpWZZdDV2fX5yl0h8/fvzs2TNVTNXhax3rMDS0hMpIeGqzIAKAApTkRoZwcu/opkMLq/gK2hiPFFlz8aAscRbWKUUggxdfJKPUrUQHV7RwZAKXT2rdSaFJKXKVlNKY3LgGBFt5kHgnCKhwBofAQY1N8aG6PBz1jTAJrQToigp/18iCgAkOAwgctJhASyhAQEv6gAOIelXlvAlNPj7VLOXxHKiNjzyGqX5F8F1BwJVGT+SicG1tEQQHLUGGOI1fvaoLQIqpMAbiIIMJSMIU8vHhASa4oUqAupZ/Lq/EKPJEXnyFVp3EZNzwAXGrdHx8kqXLy8sEAVKyXDpSNch//kUxRWBk0Q0HCsOcnZ0haGpqkhqoSIeFJ7TkieAieioFJIho5BKLlAqwwBGW8re1D18pZCSQ3SaCRZ08hpJSHau+GC1jyaUVJkjwkRcCJgzQzs8uIVxd9cgiVxej5TTbq9kgd8VWhkUwcaA2o9iuiALwcY4rXOWR7+zs0EeeE6ClLoiQSR4h6fAhG1pmZ6u/QwWOiiDdCkJAaETQIRWt5fdO+4IBH6O4vsDYpn5L1atSmESCKIkPV4DMdedwdit+wLkFZxmyYIZEqXx5cvia6OXlRTp88cXzJ0/um3URTQcuR0gfmKogebf4YJLwA0wphriBu5XcSqhEoQ5o4JZ4gx8wcWUmNIQwG88JJiBXlAx8CKSAUIli5EKmMw4Ia65QVVezTFcjC0wIYYI8bocJAQn/z89PC13IgHi6LizMi4SZ+bngQEOOyeHh1evXr8/OtGsA85ujFirjZprUQwgHn1xRwSKOBvhI0Yo+ErDGKJwyJICgChol3cqDjA5VnEuAJ8c1CVhaXFQjagfk4ACH0fOr84WFBZonGEiJryZvbcSNtvyJoXQ9XH2O2xq6zBfb8MYQznSVFCHBh5L8WdhyoJLMIA8uDYDg0RtTXOhKGMH8grXEI7HQVdtpf6RUXZY7W8LN/xERJdzC4QJUrhDojTP+4K4hjCbhD0eKOJnwgay0GVjPCjgoGuCXVbeRDV9SijO2rm5hylMALVYiGFAR61RGWIGHD2R1EAR5paEKQq5oo2FqVx4+tqTQTa3IqGlXPHFzBYTD5CATjTkgViKYW0QtEr1DOIOLDElrF204xI1K6Ry1MYkISkZ5IiBwVHhi0hr/zVgImf7XQ5eeJ4woN0nu+tJ8n2700cOKG4RSWiaG8mdnN7FFDbfMJEseSdSgA0iRNZ8nTwRMiVgIinKrNLcQBmGADyAleYxoOCDweQA5WnZRBo7k9uSkpnjwjXPMh48bCFocZHS4KgUHOKRI0EB0u/KQ3cYcQAlPJHwbV3M+Wpjg+msu5UwQvTCgDIihRSl9IlomGpoHgMPRdrgU8/Td2jk9mUNKDDTYqHd5XTxMiXTKs11FqHqc5XFIRSiN8nEpSyHIg5dfRkZA6Dk7WzNEcJ6gAhzKKKVVnDM8ZNSpWojrSJTckoUVHw7ciAkqPgR3hQOSRCVUOEMgQhF7XeUZAi6JEGhoU5sshYCPIiKQy8NxReUafVwBXcM2TsOHQyJLkcBAztUw+cQV2uHJ8ejEzTMTQSAEkb66Pn3n7oaAJV93zW5miZTe2fnFtRrRUUBmGkNKRz3t0GgZWzZcGGIrwFgNwhBaSYXXbMGfPvESE0auMaqJOQ0h0K0zNTk3P6sSxZ5qxXFtbYXmUQ8CWvVSHqbY5RXPAMa9MszUZo2+8phELv74wBRaUYBi3E5o/EbDeqyGJNEjKsrjQjfcScVrkJjX6dR8E468DME8AjO0MGN2K6051PCoLr4CQlGu4YZzJMLhkVQzBCmsaExK6gyEGQN9EMYesuQxxE2CgDwK4AmuFBz5ABMEW0UxITiouMaVi2HG0W4ha4duOUQ+AeeWi8FhYkITmFLk4gPTLWUwJ9otcmqg0mXox2Gura2xCIIOPW3YlRMgS0S4oopW8OMHQDjy4PEJKuGiRiHnKgMtLkXIPeWa5m3iKKaUzjMzc5jgFq8CRmcZT50I3cKXrq5rMrW6Ws8KxFU3d3gAggmJuhKyqKQILYe4EidDQwkHyOHGaQOJigJMqSt9sEIoH3L4hA6ApOCsHySUM+Mc/Juc4kZtsyoZuhFkfHfFjz8915uizM7UbBpzfOB4okN7flFjBpwib4uHFAhbV0VSIC0zpBL1yKkCCFqpOtWu8KSwjDYMBwl8QGMGzfXjSokmCK1SFUc9t/KKiOZDyRjAaqWvXr1CyNJgUphpGKoCCBi65QoSMUQILsNd8qMTN90lHJyJUEQf3jORoMbTp0+//vpryKx2ZUiY4z/IpBYCoaoMJtTABwk0tBI05EnjY9UvSyRKcOIEeSSubpW22hk7v6y6Zru2gC3+7BKwFHYLqGeT6dZTXS2tVDAMV/3CxAcwonFWRAFF0DpTNS2AU1TNRelJrdHB4UxCowDl5W+YTJR7sQKMgREqD9477QXoGumu4GxhA1jguIGTomm4uoWDj1KG4Hx+2RadhqqBKKKGDLhSGUnkqFnziVinclUxKaIIDhJVgK2wcUtbHJATavyFBkHty0DjWFTUgAkf8ygJIsHEp6pEwsI9LlIygX8Tgjj0pMpACCNdBCLq3t4W65b/+/EjEFLC1i18CR9Xt5SjpTwEQOQybANBBSJBo0/kRge1jggwtJhEh+DARwWCgzSwRelAUHgqBYQAGUkyIPiHJ3GAIJKMWglbVxxwk/kmOSqYwYEgyYeJqxoV3Lp+PUUICVVD1FBnQif64JDaVcpA/ANHAtnIrabhyEc3kEh0BZeaYtU+EcKJl+QxVAr/7du3iSdAivX6pyNj4/yVqh21iD7C6puJMyoOYft5vzpfuqUXxjacmUmWJIMbNaJ/JILQx3xTKen0cRvP4DwAYhVzXJGAk0guEk7DUP9oeR0JHSggAx5MgXnar2U0bkS4vr6OUMeogxbjQqU73RkZHTo5Pj05OTLPUW+8d9rvBZ9EqlJb+8EQrS4VUOnAS8vL9TyOSivVoWiud+/e9ToBTuxFRR+EVEVLDRZxdfRnskRKWjVfgSOUGALtpHfKQF0zQp01TSh///79zbfvkCBMI9eLcYsRglxS8KEPrSBQQP7yojJ4MkRSRB8rxPJI0JoVKmRut1uDNzha+LiNjVZLlJBgQjelPKCILRSTkkEiwWwWVBM4P6t3cpWpxRoDRk3S2dieMzyaGP/O20yFysTpvy6nJjqeOUeuRZep58XkOEFE6wdMLOqp4uJqyFDhtdTYaPXsZOHfRFCwur+oBAI5lQUuDGB2xmsOgZsizzPIu0OjHaumlydD18MX5/XycmJySqlae/H81flFvaLwRHzcOxkfHpqcUvflH6+uxvTyeghPRkPV3WPOwonxztV1NUAuYia58iWlO9PkVv8OMy6i5+XZ+fD4BP4wsS0NW2L19uaWtU1UWiX+W1tbZc50Ry9hvmh5qh7KL0qEusA2ggj1PgA+P6Blxf6+wNZC65ERMvZq5Gj/gCwk3OIqYY6qIoNybhRjAQSbgF6v3KcIJDEaslgoH3ZKZcqwy+pi5KVgJj/W3iR+k0PgkYUbDvISJopc2QZIMVRMwg0aDRVBA3SNQ2X0NqhiDEyESUjgRxMMYYK7hewau1zjR8jycBRFOuREfDR0izB8YA7cJU+KW1rBkZegDexNJuQcqzGrFYLUro5DZYAQqpKiMCmSYAIUmrjh4BpvyE/O1HLB/v7h4uI86XCIU+rBkK9gUps4OKQIZX2izkhYACYRBP/goNZDoRmHXDGBfHl+oVV4P5aEGyaubuN/hDKubEnEE0qreAkmtYOMMJpTEjI4HF0Y50FLog80CQ5uEHCjlTwm4CCudAOPqyOXRWjx1ITg68t0iCDYjJyNnV1Wk6PkkFfjt8ugMtENvncDR0fWaobmFzpYiSdDGzgOJEY3mcawphcyGILLuEWivtxyhcUlk7W4YqAzNAq7DRxJqoNDkChVHTIDt8PEEwTbicmONX1F9De6sB3yy5cvJwzMbV4ZPWHiI8W3OJddt60Jq8uLWqUEp0MMr9KrmmIbHgANHrOz8xDAgxMPcxS2ybMRLQg0KXBslfJ8bgdAmPBDSO0BPrg8lWQISkWgkhkdqwYYCLY0gSYpBQeBL4+tW2smbkdHqp3CwU28REqVNoYwZfBRShMcNDcO5FJwjYVXEy1IcJMAPfLCxxNnaHhKIGGlZYFzL4aAinQhCCtv00RLaGN4MvJoXRHGXZDlJRkKKJKa/JoVqW5S1KnaodjR4c37D7cURiU8mCbTxs5qC/KomKY77LZ3BhQBMVRkH4Ait9A0ut3dw/ERTbgEUgAriWLy1dL8R92/B7UnehEITlI8ghFMaaJTTxm0ZPzQdbUHRW5ZDtM8RikgTNdkBpwhSHhKYcg8/Q6EaIZKxi13Q2AtfJw5olVKhWAw3WLCZXoz+BJ8Lgh+ahcOOB1ccVYkj0ppgINr5JICR2kaFbl4IgLx3lQRWlfILQhqPBA98pQyp28eEB+1qEJiIgaOPKpookiitupRMRQgNJhcEemtUuuxlBquhMYb8YzpAEG236AFUccQqGHvBPMp7BYcIT3xFOHh4JYOcCiA1qsw13hYBhBtpQsPVeNapmzpyjqP5MMjopY+EhJ7PeIHqkZnASqDD1qCSEQoAwhC/4gWNdZY5ZXiDy1aRQHIgyJwQDiAHIUJpzEHK0MmcWzkOt61IQWcXSC4GgkmamyqmQ1M/pGns8Vc4twSbQY2vzBj9mfxzNvGsfYQiTOheEIjF7nIJDQ6uCbDsYB0g2C+hqHnAJAED3g4KC1BLdGWCXSIvfRhFIUzQYOPimNJ5+SNu/dc7RdyTSSQoui8X8EZQreKWIcKLSExzRWED2ll4IZMB1ciCCVRr6zUKHN6qpYLk+aWswxjcfLVZTVtyIrYK4M5WwCxIksinaC4Sx6aolxRTXYmzi5qEB0x9eON1nDG7CFr9WVCTTdAS+jiFFrJapyxwoc+4o04/KktgwmclF5cX02M1ytZRoHDp0k0hB8lFXEOP6CSl1FBzIaQ6YII4VuC0JrX6/3BsYqUzlR73DynwOTE+OTJ8d7oiN0+Os+aHzDTrhaeHR6tOPcIACIxJAmOhyUllHct63Q+17ogza8MMYh4vawjMfFyB2L+fnRwaP+PCOEc6s1Oz4gZPjs6PvQSmIEHe/vaIFvkMcSc8mRpqCNDN2FGnCIPCiylUmoKT/VOHcMnCHIJORe5xfDGjwRLFSJtOikaaMDRgfCO1Cytvh48ReFInhTx8cI3r9gGGSEO0FBR3VXCPxlqBYg2smgpDwGVq1K0rmRBViTPPH0fCD+6hdk0rd6zPNuCdSARAogrWghcQDFSBuJChbCisDUeToCMirvBJaJ5LW5FGKFwmEl6tCIRfmpLHjw24m/yxbduZcQlfL0M/aMbEoQDk+XD0xV/qsZdbrGVRwsHN3mK4eM25ggjpSRmOom/BA0TGaVS4l5joAZankSCG1bxKim4KcV2oGQCgxX4gPMVt1BJHj4goVLzVrVbTiYoAae6IEhxiAwqCTLdXHFDkkpRCkIuiLkwlYyy/EBhylOskdRzEr9REhopSmkY9XCAyRyJw02OVBzmpAdej18jteADwgRFEj70x5ZilMcTcxzcwklsEC1PmS+//FppnAaHwvJ0hiBRkgjwKNkcU56hGCDOEunRSl6RifmrV1tiA2HciA84hbElkWlRGAI4PtDoTFa8h7m8RGG60RMH+bKr1lXq6RChWxkIdOMxt8GBL88KmARBcAtfXooTMAeBoAiCFA9AwJPTQCimlD8V6exShBwVS3GQiWLyMMkN2zhWKeTgNwnV3vGUj2NlGA5IEyRJZHFClA/C8+fPUcFBlTpF5ZUAHOJS3RyLioa4KYVPbqSoGp4Hp2HYKsJNAjQaGNIQuoWAFpXECZJMtJIhiD6jI+JZe6kZGz4mc8IVISmanlrAE4QgpZbv52ZmPZSbKCR+6KnUVSlu9EToSm7EYUVbyihNoIJImANShiZR0vzEbXCqQyQSX7ziFEgIQCBhDSFGFqaX15OdbmfKgpRtq2f93uLCglmBQPO4Yhuwgd97Q080Hlrh0FX/bMZ6dHTAjWYfeaYHlLFx22qsvG7frSt8Gkc6fSgmnmjCg3TQlUCI+6jKg0p5DRpV4bOftRDiRHygIWEq47kYH7dIgoNEXu8QY3EDZz5BDNfvYOuW4Rqe+j042E/43rlzpy3iHzc/TQgpyKonsY4tWWnSFMAhtStPFp4w1Sv1GEsorciVIUgGPG8CVTDFUDEKT8yta1M45mBb1dsaPxJAVyRsR4Ib2nCAQ2h8Eg/TJ2/GIg6yxEUWOi3x93sn/oauLsdHNQkVa5XcLN7bAP1uTR792bMqUOkgYR7+REjEsV19AdKE2pTnT8rU9NCrhfExjcfCbm08HRm23uranaltGIqmprvjkxPQXJN5t7X55t3byakJc8nD4yOtbn5xYXl1xdUt/OHRke3dA3Am8yGVuKK2RA9VV8W9TLOQIlKEOZXg9M96hgSLqmsrq6ZXm293xXbvuO9ZSoSLYfMys1GBaXG2d3wipE24WJHqwJYP5+Zm+JPrXBkroxSOOhKK1OBeRXGFDPUAlfKSDLegSp+uOpDw1ezsJCq3YQuCYUyI9ESgeKMDnviwTlzByctDkaAKqjbbMyKVJJj8D2JgwgECHWTOz2rdzwzXnh/6JB5oqGuF2b+4nJjqjk12ruww0eSvrm19sTHmcmjY3/XI6IiPCyY7oxOT8hbfiMaBSpTBLYabhXjOcKvBEoq1UrbQkFbRxHV6qnthiby956ewJqBCBQw/xG+AqPBECA2tKjAQah0k8p5q3d7e0UboIK/UKzW9G6tx4OqSNTriXdfJac/0nSY8pohnPA2IPUoiFHtzC/NuW1ztyFj5gO9WQApdIYcbBVy9Mzm/ujw9P5vodKdn541I5kEkta1mFyen/ZHxsem5WTj8QzFaNN09eA5pTaenJ2ZxGqj5vWfriTHLawfcYxjS7th1cnTMXRyrslz7vdN6CTE0LD5BKEsNJmRnkUaqm9UFaqh4usWHiHosHvcS49p1ZrY7vyDGxy8uz2qsoBNvksGYYtSGwYG/+E4pPVJPXA8tsQWiMhCmSugBExCHciLNahsGwmohpOAp1iGEw0Co3hAHIpAYWVPqCogEGh0UyasnNUS6RIoiTVyRjISEMm6JSIZK8pAVgWMY3dwKJiRKZSQiIkWEgZOlqM2RawSmtisqoSaE3OJJE40QW7ISl57WvcBRSYoA4VAAW6XV97WnDZxBIppPsIIDAZ8UhdA1tOkFKAMB2mG/1KOwBg9CkCjHkHpaV0RgKxMS7zjhs1oCkdC22qy3LDhQEjn1ILiVVyqBxw+AikAQ8kDQXIl2bcP2zUMbTIkIcLZQDAdoafaJ4IEywYQMEofwtreplKeYXk+XgUSV0Q0a/IimBj8wH1t5tBJMpdYDvUyT5KWBts2WUSSs4FUPSxjqL5ATRE/uatOsehmo3/GGBhrREia6XxJlqForn22uh4SegKSjAiQxeUCJwlFPRoKAJxxM5BWx1C3O8nSGg+FkZ0pVyuPAqKqJNr5aChB7OKTNw2eU4Jns1uOL26DxFZ2x7Z9Wc5ZJNSGE5tZLRMxJpANtEV6O3nRk4BIqRU3/alASSxEqwsFteIab25DI4GlgPbu0CaeqLIQsogBLlSF0SxOej7akMz8KywgxKkFDKyPF/zWhvO2FkESfRltrABQQOQkbRWZiqo8J4IAX9nC2qI7PyTXVoAxnxiilbklkESkQcI67FOEPCIHb1QsS0cLtMrQKZlsIr3VmaK5xrCsmNdy0LqjktkpPc3Ob6FXF4PKx1BQk+HFv8nFIrA5bcBywcktzQuUlVOOdmlLQRBFCmEq/maKJawhrBhphEZO8a7jIMNIVx+RDj6N6hcM7e3s70T6eglCsKpAqVsKfcioDgghwxSocopm65+hobOkNDtoBJjjpIUdIrsogBaQpVjP0Enbb5PCETyUc4hR5mrQIK92UQg4rDpIPGsXQugVkNTQc1JCtI2pIAkc+N1e7d0KiWcGBTKuzfoUarUBEiQxWMJXqZXCjZ674SOyCoJQIaEgwp5WaTpEYVTQYHdFWkVl5G12ipyuhNEcuIcSZMzGM31DhKY+5BDlwDYSeihiChLYwlUrmeXB8WTw6XF28BM1MOdHpVshAIxoaWoTyUgS5Kk14FLuWoCGESVVJHn4Ib1Gqf8GJQ9SUIl0ui4JMkDTgHFbQuAiCBslRTKCa+bs5DnHYIpGxZMtGY4OdrNvbu+B00XuLCm/RMNF94ExhQ47S1dVV2G4jrtlVEQgTxBwQW2iVv02kxHwZCYJbOMnIq3q4IBJWriB0boCqPhbJE+rKA6oPH/Uo1MnFYWGuQghDZioSCZSUQSKvKjF0m8eFWncaqwAmdOBATEgZCFVa6/AjYxfXRRv1bhX2f3k71yiMOQgmgIRGmUBiBTj+I0PXNiDJS3YTjXTKGxFk+d47BnkrUV7C41ANE8Cug9oXb1JbmP5M6nwYNTZaz/esK+cMDXuDgRX9aYuQPskorXbREvNV38tXz0HgQPAQQj5k5b5YpSqHyLtSwAgo7wM2wcgWNWORRivVbw+NQDBYGjXrScg7zwM6n180EbX7mW5TwyN4NmtVriaDZfGhkkuqJn5TWYBKZcxRCJUJJmDpdl5VwOk09B1+aVrK/v0qKHGekATDIFoUh4PvNn0nKE8icRiqpiJOy62GVh11nABInBgb4FTPiLsCGNRSMOgOMMVIiiRXxBAgw5TnYr7QUGXcBjkygoYnIAhaJFHCNTjJUA6Oq9qFRjlwyKLfVV0SgRsR4OEDn7ggy8OBgIMEjgp/CT6nxC/Q4LimKNeQQMN80Nig8Ymk0450tY5trkq5i5JYoYKGXLTBxEEPEe/RmRrymXjKQ0MFLST4wGGCpKmbFlEJQ7fRitryCF1REYcDF0GjTGY98CG7avMQqEFiPONWUgqfrIQFVpjgDI6nW8gSHILaU2ctYriNDhDQ4i9BA2SCK87w+QFcHhoSCfPwBM8kCzcZEiHHolLrtvoGCnizC8FHKrEL5t27K7hREgeySoObZ8RSDYQ4mebGEz1m0786UPgwaTtgLo8hbuDw4WAL3xVEtcq8fnPgAU5FfPrpp4HTRwVB8BwCHqtDjpWKAHSVx3DAWV6KdArAl5cAcwtCc/rQkyB5LkVOH9wAMZRUZSTKEAQCQcIqDsEQE+RqXOCJH64zS7WmEbSoCoHc+CQkxIUwrFIELYkgGSSuFIApyYBIKcUn9kZETFMUTMAkELJQuSVl0Euw2i2eFBAbbjMGD5ypiNWsICVqRHN+wAoVIIiEj8R2svgh5qOCkyUyuG5VpUYXblQiCHPkzbiKGfgSoCJokiIQVNST0YqpBJOUjY0NMVMNbWTYOk/MKfrWN0alVIE88wPHkJLWuFhHB9zc8gnd6M+uqOEaGxHasgwniUogrnELziEBlIjgEyJck1DJ3BbVPBWhJENhtDi4rTog0k0ERwlAKewUyeOlqBHXugH9xRynKCWpXWFVZCvNNbKVUprNaHmT5cRDgA0CBz5fcATXk0g9pajAUw3hhhYyBLKkEGKimQ9MZRU4fOLgy+CMiTwSDImAgEZeklGajNiSSSl4HKQuVPPZObVNQOplJhz6i63oJuZlzDHr2hbE+LT1gTed+IChUnmqQsCchiBucaOeZoCnjFtA3CjMP1GbISDxj0VDtBLTeAMTCRrHSmGuN4RAVYRkxUAZt5Cp0TI18JMlgSAkwqEFFrtFjsXuqzoOiAMuPBGgChOEkLnQv3DDpEHqVpKnjBRHuYK4Rg0izKSiQ0QnD8G78Eg5ODhfXa2FF61C/4snTEVJOLulbbwhCGEaNthLE/ahUl9RD9tyyGX5J1XGVvgWqAW/N5F4wueu9jpkFzeEHGZ/ALTIgsOxvK1IxpJ0rKMGIPXic2gxEwSCRCUk4DKAAwSZtCyl/IEKcjJYsSIIZOnK6aavgSn2SJSBgEQpnqLl7PIMzqNHj7766ivvpT777DOdID6E4olEBkPmoA05cWbZZtuAisIWt1ZOhHZR1Qcu9S/qYQganq4xCocwBIHp2mgrBpT4eAQJfLRKhbHwnuxOJSzHO9XYfYvrvWcOqAmTODwq4aM9spQCJEqYALq9OG8PBC2i4KBVayrXg7JbipESTAq49RKJDpbvoyQOSkEIoqTFfV6ivHycE3HyMpprUfnXOkBBArh/eOBtwYXV/OkuWj0jKXECzgjjDIM7EUmR2HiMmFHCKUNaj4GQv71eakI8CGFV2VKgNSkZ5B6OqloaHEl0Do62WAW34Tc2XMFWFK3Si/9ttykTtCDQjeYVHOLYDXe7JtDTrhDHADjljta2qQ7uKmGEhaYYY9q1BANGkvikCSaQ1QeETKJxwLCVlsvwSduDJoBAwhwTJEpBwiTMQdL2MPEO2VX9wcQwnN3SQWJUutGq7NZ+mpLlX6zwhBNxFGAIiOh0jU980ENtteNW6/IBkVB++dIG6lnI8Q/pMtAqhjzHli3VbRk58EkXJnQEKE0IVQSfGuTyBnFWHsAlTBSB04q2cGRi6UBhTDR+ReDerTGZAkI/b8/STjChXioUh/AccHArqT1XGtJHEYZusfJqiCakK5KaXjeTi+QxxDJFaN24SsiD4CrPGx5KOIHHaEIElTh5olNrTcGBJhW7NrHCU2Zp6WbpDFziE5Yij4j4DVAmLlKkOjCM7ZxjCQsyW5BD02pguoUAOZiR5VbGJxFeG4K/ebNp2m04oaeHT/WJsFTMQNKejE368ME58DB0xR8EHMNBKYgiSQb/ZCBgm4ABVIPwqa2Uo1SlmAkHtzDh69S8s4PJq1JEg0t6Io41VIixzKJQcTsPoHUlIgl/GXIHRZECDiKvNN1M+AdCRMgHJsAHpAZ4gI0QuPjzRJqhIj6RSJR3ZSPFEMqrF4FhGOBokDiE/pjEZDgxH89AMAGxWkSxpARGntIQsoKjONDqJWTNCnCqU1VvieRWvQp1KTpHE4RSFCaCnkrhgFBYnjiYxmDAiFPE7aiIQ5KQcBu2AytAqpLa6NsYWu1SL4XmVqnQ1XJTs6XhcAUP/CBAsl7EfLeuSOBEmfgEM5oAshGV/ECTYEKWkUxhMAlncgMEuZmkoHQDKkNMI7tZjgCMBlEic15Pz7b0QYOs/kJItnYnD46EGIbhmgw0zCW6QnDL0dwa1dMA6KdSOTQICOOmhAicsHKVsAKx7k2i1HjftDdU8ReV6ABNPckk2ggty5vLwh+yhINbOmDu1hWOjDVl3be88MKKMpTEgZ7Q3SLBE9DGElSChj6QWUEuQmrAxz9S5CEEIiOSkAsskEHCVj7+iTk4M4EstzjLUACEOGyP+xWduEk0CQIcKUDXuChX/qOYfODQiKMnoGh3i8NN6ZCzgK7MLAZAuGGLhEMGnJFQMiZQCRoOIBDgJ4N/8AMEjxStCwKrTWBVE7twMEDyfBgOpISQZ2RIx4HhmOBsRyhaU6JIidCR0ZrlwB/IkgfhNz2O/KNH9225c1bE48d1QKbOlFxHeGLSrCgH4h+H0JC4mIkhIFZugzm4HRgebVM16sUtnNyyMWoDRmH+90TiCkIx1lGSFLcCKT2afhMHVR8qC+ukI6GYBDn4OFPMNbIg51YHZPqfpHQAv63Tqi+YmNzgt1em8t+Eu8UBeWQpwsetxBOlQSOnP5OpCpnyOjtG0QecvajYcrxXLUtewgRhY3ITRYoYC4IPBLXTeFejAzQ/4y55npSJW7Qmm1uisHz/3FE+Vd1hjlwGpu1kpjFeEdONk2lFN+J05rXxzCSi3h7zQ7mIHRcjo7v7B53xia6ZfzYT+xzs9qtG/JOa4eV5bOVdceYMc1RKcq2QIgrPZnEFqlcHkq4fqFXaUJ3FeK3zNzO4th/OII8WSQJDpuqUYg07UgjCUJ6xrHMruYUsQx8iwIPsVgZEabkeX/elyu0kVN66J49A0grgCFri1BFW4FqOj0fakFhtHiO01BInEaxWZIgkS4YINRQVFYmJqoPbhwCEqQN81LRqTgaCPKoEfSyBTKskQtUx5NwKLMzZgr8i5FLUi4bQVJ4+Iva6ssUVHL4u2200b7ZU70ZPY3BZf1XPOjD1UJDjTVcKq6DeqdO1ah4qts18EbIoaEKfUAzpjwPplKnQbBvkISOMr4imAOVlcCYL8tRUPWDxse/Hrf8wRzTgj7l+CjIFVIdbhsjjII8tnsyP01LqSrQUYKQAEpSETxnLGbfxATmW+mwKjtvmz5uFfhBmuhIqycTbrnS2cxSQCbTFWVXGD+GDVfShJE2QsAWVoEqtcREIVSU6KJIwjEpK0ypYXWq3hAmvTnVrcQyJFIVlEEYKHHk8uZ1uiuhDExN/GqosXkXlGzFXCT5ZMomTdpqCgSrP7DdjAxwckmBiLs8KzOXxRwsneXsu3U53Z/YP9iDzCQSYSGQAXalKNwYigaztyMCEz0DIEPC3XfesdzY9O+MzsZBDFgNkNe+WRrjVf9WI64Wr1ZAc+F1vY6WJ8aEivQmMQmwPynFL8WmfBAbuCk4ENdSFDOZwwIt5M5MpUVXd0R8OTJrrLoSKXV4g9+7dQ2JoP7W5dmLce3u3cBIn8Eux2xmYVimvCqpO7TK38bRtscXc9/Dg6TrUHSZpdICiyNVmZhtJo6FSasvzj3x9Atb0h8a9g7bPYVYSWBkP8zZkT1cykQuTaM4Ht8blyieK4BfbcgtPlFvAoZEiHJjQMt4tD50cVrgylm/UssGG2k6qNdHkbi906+W5l+nXoqi2j4tQ1iHBkKp44k8W1LCNIUQLbFtO3bJUER1ydYuWZtVRNicY3qsNw1FPykrl1rypxUHI1KYY8ld7f70iH0FYO0PcyttVqtebnnGanYdNAa1z1OosqHmrxjtiolZaxZLpMjnecYoHIyFRlua8BSGthZDVlSlFlgpknIBqD6y21/pt0vUvdoLqxCuvyJ+214LKW34DSW3go21TuJoZ5VnEofyliEdYxFmAIAYS2vpji1cSOiVDhpbfxmSVpBa5l2d0gOKjug/OOTzgfQ9iinTQ/FwjEIkY0qGWOi9sIpzxkoDaAiWhnFqBSQFyxRndBH1o4YBgtbC0aFVhfeOO7Q9IaK7H92cDfu24t0vDxxM+CrS/pWd1ntPMBUzrysm2Cdvwa9u+nfpYaWMUrpi7uOpMdFSFrQVV8bctih/oHF9xqaWqNnSy1EuaqjKlQtB+9/MLU4kru71dp7ozs3MLtkWb+miutV161OdXqlVI8Dk+dtQYBiq6SB90tQyXiHNGv51UosXqvA7CH4nEESrPFnloki2YUViT0zZaKOscDS3AnrHGNzbWHeIvg9YbC5qwgk3tqYWhtcmvbVIfPTw6cV6jeZKq1xIUxTnY+ljg3saGr0VIVAtffv2yZnUz0wdHh7Pzcz4s2DvY1wbtBOmfOxzJ56z9Xv9karpzetYT9p7z1LWMK0OItg4p2Kpr5rezC7NsbdhUTF9fuztqkZd/Rw72D3sn4nDSVfjYEkM69QjyBe7+4d5EZ9wXoVY5zvqn5l2dSadWOHfeSybheDEh2HRO5327TWR8BGoM8+LaFxs2j4sWvhQwugzGBu303M8+iFd6XahYztGh889Jn/JXNu9bsZcf70wZIajr2MaxSSfujHoDdGEhxe3wiJlH/SaE016vr5pXgK8mfCDSP+UMGRut5K1eTAnU4ZHlhUUzZXMiMeTqqB1T2rXllQM/uuBD287U+WkfWiHYY3ren5iaILHv7Irha7fd6SmjLIHC10exvtNm/cnxkdV/ntQVqnd/3C6e1aAKFRwijdUyxbN/4bW9qxoXjZxhLrKwMAfHLQRxLga96LKwpgIPdg/OT88nxyZ1Mxp/v3c8O92NV2mhffEqE5bmFyJrkoo+0fIlRBNXI2F9dz16eXbhvQG7ahfP5dX8zKyjjGxgooA48RULPCrpDShAeR2jVmO+5QPHejE8bqxS7ePC5+T0zF+nO6N+j48P0Zo2jPH12LBnmk53ysBm8NYTGazaTjH7a2tMYqMAw0dP68/QjHP625m5+YWlldHxiWPRfNq/Hh61HlvP40nV/tqg0TS7acxtNY2m2ueYajejqv6lPd+xAeH5sCeOGvckt0rDx5V3pNbF6BnaNATrltxCDlCVaJ/aD2RUgPKwIOgxeVyeRP2ifPoX+G5hymhCbM4IKfQ1J2iaIi/jhlXzSKmKj9Kjo0OaZ5ALEB84UaZpV+IkEMl4ySsDcyiZDg5/pRSQbvkIvpq7wVEUVnEXNQLBR5LHpDmnZlJIYo4vx1BRHoLhFGemy2vbGrQMB2fY0+HGtNJzxAH9s2T6BIG4Yns9bDMcPiaRZhwzMzVLgo8h/IGNXAe5DGjTNz4p0yZrScfLMZ0F4ZABS4eGmfoFkUA4gevCMEzkGSjP1TLE5RYhoNK+RnK7XB5kzKHR1i0qaEZHGUA6t6ZeYxht4bBUEbnp5szWs2SElv7WbfzuCsUMtAlIVOfX5fzEErVZF/UAPe87TttsARym6RUq0lslltWxN/XrGs3ZwRq3ZurN1goPCoA4LQzzWMTTTKiuuwaJmjEokkxoPACIUlIMFU1z9VOr9oBWGOiAEBwJHHAZMyMZX64xTSmrZeijC3NygCJusabRKEqTqOqTI1NavMqZBhLbMUYn+FAr3W+fTNd0r21g42qjKUFcMZDOEM7ELda5laIYnLgLIVlew5oaeymlw7KGpoKguSqFqeL8kgk0JEppC9kVt6qgFkvUUKfCiTjNWc2CQ8NEZ818iXqpX3lszUL4iotQMT++AgfEPB7wARevYgUikYI/raiXBJ9JSCgzon8bGbXbUu9vuwwpgoEmkjE7XkXFJ3gi1LGaHICLBjy5iVAkrvRhTsPxYq2WvCyIYm7VCT4mriW6+VPe4StUVlGVr1qsd9f+x5Y4moeEjVPTFQ8em/pnfUO6yBmauFnJ0EtzHVkcgjyBVHaZAF2VzmzArU621tbMMs76hVp3Cd+mmTzNXJE55dNE2AJVHfsDdNuvQSgvD4/V2khrwGV/I0/EFO0NN6wKpTEMD9TsrIcMduWbN1f42hULU1sNpwYJ8CKgR1tST08BjamihxoSd4s8FnKHDFmYqAk4yNkYrTAJw1C5bTbVACADU4IQYEpRBB6L5GW4GP9gphQJEZJ4pUa4udITGufghhBEAmEFZBVp1iko93f3DvcPNGE4UZKGOIuDpps6cEhP9bnGLg9MEYoJfOOdHw+y5gOIsw0huzt7R8fHxoB3797qS0ikQNoSEipFh4QpL2HCgdTAn+NS6hqFY2b0pwyddWjUg+DWA5B6Nsdp/VpVOrb4xAq0MD1MOrar8ucJg2r54YAbPvCrnTdH0VA3QR99HJUEBkyZ4tMGzrQ9FqlrhJpZLCLaAXm4uWWs2JAvZdpDGzNxIIVEHBydbEQyW8IH81RZ+FeLaoQY8gAObplDltv2htm0KT1+q9N2FqNOG+d4rDZztCUd32te1S5zNxqh7zzrSdYSr8eL/tmpwUFTnOpOm9f5VTL+rh+B8iRoC1YTJ8ZsJqEAizyFUUORhzp61rTEl/bXNUbKNTe2nkIIODuzPYVUPFRIVAijoAIOWmB9Wntsc5QfJPE8YJpV35rwhoPo6G9ZSdsmFLmHGKczy9dm/eonaytKZKsmVTfm01mfyNLSfH3o+uGTx06dVHf4xI3lsZZw43wjxHvvvadVqjUImEhMYJFK98lrKh2FyoIAU4yRykCJWyCnFIIqdks9cL6CKYNV6ktpVYdOqtVgi5/qW5Xi4BrMQSa3lG8PlEambqdbOiN3noQ6UgRZ0rfj0EKjYoNp3KDUfB8TQimTiCWUVtFQF+yNrgEgJKhkIlQ+irkNJFd8jMrIBQBWjHUlkNM4p4KkugRPj3UNk3Gv62qAqPk3iCSDj+9I+LzXtpBVMb5NgZsuiSrYfTOFEoQ9kgyd4spwTM2B48VIQEwkKpIHDhkcbWnRUuN0MzAEHtdwFnL8AXEIMiaSW6VECIU4gi8g8AURkiLXkEA2aEcH3ERAFACBAwI5Naq26O8WT6Jxw+Gb6iEZ3CKEEykDHXQZODBWkasUEa7Udo1QbAca4gMYQfBjsrgnyPkvAluNoAUxR4Mp4QMTIblsYTsIu9AmwtAioQw0EGhWUXR2eQ+xvLwyNzcbKnJNZOC4heY2VlOPIORu466YgG1EE4FEokZMjgl0IBcQQqojrojO8ElJFYQtNISAMiTKS5BRuao4EpXKl+Vte19UwsSqMTSewVYfMVAJiRRZDDEPTVcOEmBqWV78yGPLKJlIwcckiHqs4DHiKABBU4GDM3gSfKXI23aSGmihxV4ZpWyhQGwMSYMAKhBaHrjZbCCHjvLmQYQITETj/t6BCXr2LOpmsZrqdlg6v1C/82Xxhz5eSeqprYqY4hhalHpQG6hH8xxYJiORKoSVcmdTT6jriqzGXJ8ccvaRpRjJwg4c4iTWGatcWXGTqpf43/RTg1sI7KC/DBImuDXn4CUxRiL11EVuMXcrr/WpCy9aCHXLdkX8T5NkAFHJK2JFObw9vZUeLWI9QADizyFwIAfeyquzkwk5fdC6ug0rVBAAYx1M+dyWy+ptZ83fxVsscoXvlttZSjfcwgSHSEEOJyIYjiQQ3ODII4lRg4iCQ7RrkjxM+JDDPFJceRUO/4QbQYOAgcyT5GILDRM4SGiLW9Bk4OAAIXD8EUZbV+kGFWtlUIHQ4CUDFcStJEMGVdoR8WOulWleUArenHxDCA5ZkvlmCjDXqKLULVn4S9Sga1RUxB6a4C/PTlJcoycLuRstKhB5EMiaLnJ8wJFLiTMcQFzL5nZFksoGwQErcAmaBIib1EwrhIGL5LF1hYYq4kBkkCdK5JW6hjM+Qrzxq56XRdEcTyd76B+QP3hw9969dRlTos3NreDgxiJTfjO4MS9eLNq2F4CYw7QQRAvL1iYXbCEOW7MV8erW8St8B1izvyFH08w5/pezkWgFrvJzcwsyrDHfcdvWxmoUGdhFgaTUEekDS+ng1rZR65yWCv1ZwG0bmct2aErx9Ce8W7srNSRwCUOJfyQZEl2NfNRVy2oHDmDwRQU36Lb04yoaJn8ykyCjGhJMqA0iflmk3rRW4gzTfuGA33z9w11KGWuiff/+w8XlVRADogjSlHLV/NvishfL1hIN8OpaRYvS8hsRRI+PTQp+TzO+MMhHBuXi296k7NGNmnyPVBTV4fEWhr3E0SPU1m4qF4oioYXOey+qqh2vwZx25zRNnFpHfOWUHYrJe8cwPeNBrY6AobAlchCjCHdhQjSGMjfdqB8GsVmlpanO9OSEA5KmJsc7nq4j22+2zM5Mz8/N+ujW2ropv3V2Cvdq0eJm1SLmUFKSRyhV5bUGq2pUkPEYzJtYVggkLvrtbz9TFDVio+AxKvCbjKLvf//71oLEBm3VKebhzIFEGyRQqWJSxH86d3YY8CBLCL2rEask+hNXKkWGaHBX+qgf1apI9bUeux5Vk2ILEQjSvuSJJm5QJC88IEgGKjpAaJaW+fgggcxG3bLeRZ2Iewk+MyHIcA5zEsDwlZag2ll0s2wQtJJxmzBPNlJccSNaW4Aso1RUsy6JlzhECApJECrBIUUit97gtTMwUCmC4JkYK89SdYBoa4PIKUnKzYwMJeyBHthJ0YkGUQJEZsAU68DRyg/IA4zZatptIMm4woyiERfRgEhAJNw4ncby6YCUItQF0IF/IUgIy6o2MkFjJ3GuqKCpPL6IzgZACODsRYWDK3FBwAoaPiGMhm4DgRPNlSaBZ0R1i3AgxS22AxxsAxHEpEMLPh1wcAWhrS7MbX1ncFJftNItPCHHezBjrAagQlG55YqlpfrNWHvYEVpEwgfQFMkrP2zprJTcAZN0oIO5gAwn2wHJD+bOMKnRgq1cQYRwIUtiVPxDEzrgTLd4m2jtwm3YmuIdHZ4EwRUThMgxN5Sj1SvqYQEVoSJIkqmF6dvhVmjGJ/yGOQVIsfjrCoe24CpXPo7iMcCBYiWlhTjDhYdbClgIIlEGE5qDxxszc7VOTVX6S2TB17ybA2oSQL1YoaitzLr933SIkRsz8UlCJWOcRWVjRttyYdQwQxqeGLNuWW2NMqkacsOk+pSzvm3i9bt/uuehC/mZ6cn5OS8qpvRHC8vzMCk8M13vwB4+2Hj76h0RzMdKCHugoS3mFoKM+84kq8Uiq04is80tjGbcxS5MKIAtPeW5FOeoxD/y2LY9fcrLFjwlGXJdlWJClrzgwVOteQu1ND8HgTLcKxhUk27d5h8dlsc4CDxvSKDwbe238bB1W6vLK+DhjElwEFqbIoiqSHCGQGHMRS80qlIsOkelPGfkIVhHGBy0aVnw6QwzhEpZLWFb/1VrrnirFnFxjhWF0Z71a36piFbW9CHKKEqgytABVfgQBDN+BjFVdo1LuUxbooCEBGcKyIQwQBD2KiKCpeTKQJBpdDUpt6CodRtUUu9RIEaFHCZX8j/kwDGUIYtupVVToKpQci/FFzAGPqIh5CbVkOv9ZG25QSjvD4U/IQFnoBwx8LGSGiHzmHoDCTyQhqW71O9XJ4Wz1jcxUasfFMgzozzb6KaUYpoKL2NCHNcARkoqhmhJxbsKDpiChu8k/PEc2N8Uqycj5JjAV4q/jKIoGYcwNtKjABwZCStoikAG+SgDIhM4BJyFgvYQBUDgu0YWVgy0Nqrjdjxi+xCptgzZDaLmnDUbVUulFqPEm3CgMqtkl4yr1vvixRtTfCLkr/3wXFtVJ5ThuBGBT+ZWfBJ30TDOlIEQJ1g2EOS0xrn2HLTQVMRXFXatY7WWLTGROPNHPmsxBlJvs/f3DilbarRVONWUgCl+I5MO/uQeytCBHwDlecPknZ6AKg7byAXEXCnpGiSG9JRAYBoz5OHcBk89rR+d1JQNZ29PcI7tzRTbH2qOnBblyhtusSLLraYOn0MgA+ZWEUGMbcpXD0ITMyqYbbIZ/fWbOtgCmQwMkKlRrcMZwMPjtc27fRWRVRq9s802GqdTdW3gsdvn2B6X/unc/PTlxYmGZe/JWb+6OZWLbaRzi002dCPC44zKffP6hZ/Too/+p/UydabOVKdr4PHUCLOeX6z1e10wPmEhnWMg5Anj4OhEaHh8ZHJT3ZtMx8KJb+//Rz0l1tjRqqnO5qluitb1RYhugluMt3oRhFaSONbjpoy9W9a4ieVY+JTnseqnGonrr371K9N5hsBRa5y5uLSQ5sAbqrL5sFaH2CgRxEzdHD6SuhA/MsY2gylTbIaBgAM7OXiy46WRjQ/DNq3BhGNnDibEhRvR1CgOtwtBiiScXfERtzjI000XlADgf1vfExgVD600rQ+CdoEtzXsXtePZVON8aLg+4Bqu86LJFRzEQYAcA93i5lZpikqJWyWDWYRF4kmx4ywiftfKSJdX5DtqwZ/tv9T3Bwi5qqeZxhb9KZ7RjWIgRd6G2Ory7G0yJMQjaMqwRDGxrRNEQ0NilMq7ystgGnxXqQmu1SGsFLEqiYVShc2t5SHMbWTBlKGTiKGfIrekpMErxcFVM4bD0XqB/MolZIGrC1A6IIQM4izAKMMizRiawKInDkpxliAIgqZeVYwqhxA+GIK4pS0OrfOqiAcEcWVmhAaBwlEynkWIShEgEThHXHpPItxCgAwBKxDIzG9xPOzH/xQZw2q1oD1PhC1kaVIo2M/XeiW2HLRPljjEj4tZKP76603rBMX/4irbKHWme/u7REccQQxnAv6CO4JEPIZcRAddg2Vot6yopD9pvQ/RCKkq42qPqaSIcXasuuLMzwIy7QcyNTAQYGpTvJAVh7MdJ7QyzMdQXim2MkZBasSB6g6CrUwpwj+GZ4QAVAoZf10MfeAjt9oDDSuJS8GpwVg4MPM60awtvlVqZyeGzKdJVIJsbIgOWKWO4Jfhnc7W5nbtD639r5kY3USFUhDhjE/qGqFFcn2UHh43NooL26otCMlzVO37GNXBHVv2WVic393eOTrcvT7vnfR0QENLS52nD+87HNpDrId1ayye1f28JW97EJGfnZrw6sh6ub3YZ6ee+W9W54bMTa8uZ6ZnLYDYmnp5bq+IPSVG8zowmB16T3bRoYUq1WrQtUVVJrv+GQKPFGj803Y8VUiASxyr1FUeE0a69QMGDx48gG/ZJa5QNSKTM/1+J7h+33PA48ePVYrpjoiFgFy9cJeESsuFxskS/kIIsGbipzXkq1w6MDOTbqXGDEEFiD8EV/iqUlECo+lZT8MJMzhiAA7nQ1MqIU+Sh8kcbdYzihjwbP3ixYvEoVKEtJK0AWgyaUSY40C6l7HkepEiL+HjGUJGc/CGHH5xaA6MxIZVsSpTqtz2JLEFsGS1pndxWsuhUU81AGoOrnYxYzU0Wh0IKgLBSIXMh5xTQLOJ9iRBDRzwJMiVQqwYvrvWpRaygRfkm0LVMmUavK5uJRvPyeZiRTgGWSlJ+FY0tZmdPCAcQ7QiGqCFTKSkVHILmKI4V5FhE3OqMyYH87KEedJvf/vbDz74QPX/1V/9lQBCIjgc8q6GIKsMARHOqhkrJDIqktmQKaZUnj5JMRxmwoI+gUNLBoR6+AiXdG1hAs66sIIc59CTvVjltpzVElYgCN1BjkvlMaGARqlhYJ6AE+XymJjQsVSTYJ1GkqGOMrTlduTE0YrVh3v7HKWx5ZeGYHpTyRXkEkd5DAniVWxByEUurygGUk+GhjqaxeUlfa7PYvmMriR2p+pBGz4c3RA9NUjnYZFoPdrWfp0bVzTba1SzkRky6SAZAEzH3aosI7s5kXV2VqgytUwTImB6PyGuAAeVQmjyzPToeefOOuUzQoCn4yANGiaKJHmTX8pgxUu4KdLp85XbjAd0s7Qer+Jjn0t92mKRpPVoIJShksEMiTzvcR1BtsTgTHOOckt5GX42T+ZJ0vEHx0fHQWcbWE/Pzg/3z6bbiGIwmPSjxOb8k36Ea3t2bsYgQrSFHbO0muufDt2/t/Cdb793Z33FK4onTx7pK7Q/C2PLy4s8aT+464sXXxsG2pHxFwLo7eY7nyPtbe9qk1hRIHP/u3fve2FyeHjMCS0CmVI9iJiwRE6an47iFgy5gqUvXr1hqXkRZK9LmDM7M69x2Quse2Csemca8zVHrBgOn4apviaivgr0nlueGzkNvoxKEclqBAlZgPS0n5VigN5zwMSQCPNZPtS0hb0AU1MwK0qH6wdy4VQ9dmreJsP55jGiHR+0rgQlDilJCvxWU3V1y0ZDMDQqBZI9tcVkZg5EkS9pWlRPkvvxxx/rvr/44guysLL1n/7yFRu3O+UMVwd+NMLCVPt1M3N/eepRAEk8Q2F5NuqIldI+ikXJKEy6NT8Qt/ISWyTiELLOsCcfZD+MwSfwFdmPx9tdL+LaJA9mrzUiTSKhSFbEqSxpZ78mWBSLhkRU108tSHwkDTLRPrd68kERJyJDpUgqNVtHD58S8o1N8ZFwpiW4DJENtxBCQnWmIgwEEE7W+1JUbbXtI8IEWro5TcsP5sEUPc1X5QK0ugZahQRDCGpUhlNoIg+N8XGuUrdSfEqKfFP5ZijGcKAnEnkK4I8DNL0Pb+Ip4R/y6hnb7zYM/IlnLAWR/nd5PCU4qlYcu+oiQV68eL2wMOsJRcBhzsz0SjEWGj7ySiGn06HS7u4RHsyBb9FBaFLm1as9XRyfsHdgMlr4aPGJhjJuAZsDa+TQ5sszzY0hpBsT7CQm11Mob9OE+kpFUBjGRuQy8YkXmzK6by2fPvgbnKI/wkh0K8N7IFHDFQdAhudhRZ4VNDdXZRqeQsIVPFQwUcmHkN9Ss0XYft1aqUQ3CZralGR9AlY/X9QOuogIJDDZSzE4rng2zcs/rMBZAlREkE+0AOXp0HxSgyv13Nr0Y5OlPeWXfafRzXta2tp8ezJy+PDB/cur/heffXpweLW8PPa973zyo9/7gS7PL4JMjQ0ttI1b/DwybtZpZB062ts2J/367SuKrSzMfvD0Ef9LljiePL5/dHJMZ7rptqihhXLa1vb244cbflxemu7Wgoygtc9oZnaxHTM2vjA/i4Q3nHi7d3L04N4GY9+92/KRFQfp4/wMjrAUI8xBzl5WN/9V/Yp/5EqZKaFNXLm6ZT5MOKxwa8qPA7eDY0JbcCQ4ewbCjV0RoX41MTUrHvgWEIk+IaOU2OZqpeASWfE8TfBMjWAVu2RwEAiek7DVUox2Jkw4cyZvSDBBPDE3zOr3qcd7ap+sL758hlCiKqroyRwPQaQzEBCHKB9I8vAhw3RrtmRJCltTugsfbDdVUzRwJmQkEggSt9i6TWyz0S/YSJRkOwTkdVyjNHLz2AcZQjmlrdagl0GeYJbhKz6nhl7UTBp/GSR+lVLoiLGa82KNgCfbNQ8yZR57q8ibrJFiqsGyrrnDAFDFSHCkFqkkxSlhaAO4fQg+pGtrg8KoNi03biWlAtwHeLfDZn+opplSmLBKxeOpMuRVlYhRPba6Cyma8EhsI5p5vOMWOYZSU6xc31iWQ6nkFkNJnhQ4weTlgQdAmgduLuAaNs7gREhCB0RxZIWh2wwwMuGJuRS0SHQbZSKdAvbkxS4WSca2hw/vUdX3mSwlZWen53w0A1ZbyTWg1vIobnQkjtUOgPbIb06AOSVxVhOGbF/tzs4XEDf4MgiVRlvA6IlEEXiuPGy9WpEkzCNLkbZhHgdZjZh9cJeXcHt7uyCmqHjHmWXXVY2UbrGyjIBWf2t029/3jfe07xgHykQKETL4yCCMGgMlQThBRfMGnuSaDPJYCWojmQycMJFnOLhaBhEVklZqAqW54FkIru3HyACFOIZedXMYfEXUwE1Sy4oisba+W/ZJV2VKXh+Gmt+VIe03WWvaYcR0LE99/avN94/IwN5q0PGRs4m8y+k4ZvXi/HRlafGkd/jrv/v58cnQT378/k/+4Ed/9Ed/8MG33js42Nt89w7N/s7m6cmh3coTYz5rqG6IMsz56tnvPC1a2cP/vH/i1fjy4lydrOkD8d6+rpaL/Hx16wWGeyf7y4szurnV5dlvPb2v6QktflhYWj449r2YBj3iV9dMNIWBiPJdxOtXX/NAd6oz0zVgnzsywooGHcyLRmqjlFHtzKqx7UTqmhRdJGd6JVB7J7n/erQOxb2+srXOcpBBmus82r7//vsipz0P1XiTqqGqDHHsUvXqCCeeN5+VV0QrRWJbqYpwFXskeofsMwhOPj6y9WCkfi5uvHqA+vWb8rZZZrElCI7aIcgw6QqiH2cpP2g1pIDjCQ7f11+YpEVUnzg25n21OP/82RfRRyl9aEI3qvIGQnxKbZ9aS62bxKq4tRTOVVQzywJ6ShjyZXpL0DAksaxuD0wQZNymiFx5yQSiEPLxR3uGa0OSx0daDF0Mp2nXp4banU/O8UFLeqI3HgYUovQ/2tm7WFyCQAuhhaj6ccWthy+OSYohFTxvf5rSVg61BG+o2l3Jbwg3JPgkJ0O8PDSqD/KQpYhzZXzyQQstZDaD0x5EBKTnpSjtVV4CSyb4GAp9V9rCBFQr6nvgU1LwRwuuanXcKSUIVQyBLLlFHoirPIgkTzpyV7rFj8TFfTEEGkjIsUrmm1e0g9sggMhgXis27d2jXUBWS7UZX8o42nd9/Q7T1N/ISPV3cCQKsAjclVDSyU1cimZzHDwFru6JAxXVmwA9TbMrJuMQBZBHgZhMH9wk/aoOkfUwq/qJqJF9DPPo7Do6WU8h1MB4Z5egen4qeJt3sCrMTRV4qSleg5CwbHCMK+SYFpUgNNqSAi6PeXSOttWDN8PVAn2MBErRwpQBCZW8jLZWmt/ywTPcOESGnvDRhoOBzyFO+IgKboQghSd8dY2VW507eAThLM8cpYpQlcy21OZKN3ZhSFWlyJ2VAlL4p/qssVcv3zLl93/8vT/8ox//Z//kP52Z7jx//tWnv/lbnaaaXlyYW1tZWF6spzfB4DtMUe1XV9+9fc3bWj49jX9OhCK3xO1pCjuYjzvO5LR3dnKc10L31lc4rd87NJ2+f+c9wzBNxL+vRw8cAlBrxKN+wlDnJRp0935x00m3NmguzXX7zqc5PqL87HTnaH9HH+vNAblMdGUa79Fq4HzeiFe5OmFAT87ReL0VIFevbcYmEmDSgbswl2k8q+6kMIEsDxMfHogPZe6s1fZoTUMbef3mLdESzDiBH+AklvCRQHDgFs/83qCqZeLiQEWqQzVF20hEQlv4VFLKOgis0HxwVlqR2bo3upW2zYQEDIYlMuGRvrTFIRK01JDxBIA5Qsy93QeUR+gqj7aKWq/NM25dQVyZSUM4rIsIwFhnEjZACwlB9K8T5NoIilAGIThVecAta1QNx7IXWzjVbf3vEnaNI4up0nou7670/mW4Td3OMDFhrL1B+vzYj4Nm2+aRN/M4cMBSvX42tg3v7Xfd2Ms0atnuEgSuMZnCmaLgcF2Rl7PaqhEmqkT9UZr2MghcwZmkntSKTOpVfyoDDTf4OBTP20kuINMgS0S4JTe3qOgDE1sZ8CRo+CgNXKVKeKIaME9sGV20OphhiFDCBCGh8thKIQy38DGkxmRm0px8+8GPvvxSdcIH5DCy9MTaq71vbNzf28OBP4jDvHS6OK8N3x7oSGwHcslwVGtcVZ+0aPIpU3Uq1CHICD/F8pTV1zlAqLS1BbQODbsxgXoGIXCRxMz8BhJV6ebxTkhYRqgvpESbvvW6mrEga4ZXrFv41vk062qLDluauGo5yfCJfHwiDxi7mnqlBEPUAp7UkMeBz8U0EipB4wB5Faojv6gtauXmxt8mGaHV9jJwTHkmVWEkqKBlGkIJsjalsdYPp95+vJ1NO8FBBo1uOnMIopvBA21jiMm6VS/qWUynkqWgleVFe/YJvbrUO59/55P3/9l/+Z//X/8v/6evv3r29ddfvHn9yilSIsN2fys/c17iD11vbb1j7NLSogCQ2d/f9fbOov/29ibOUluZocK1mTXbjw3Oe3AmLCJNjddbd6JtHD23T0bp/h6DNBOn/O0c73YnBAkbRx13Y7OY82Q8o8/P2Cd+fNU/9uWgR7R3I7W02J0YmelMn3hFcj3k7JnWkw5ZItcb+bxg//hIHZkcqA5DCVVVvvN8Sq36Yd5tK+x2NPzFX/zrublpmHxIc/rwoTwcHpM4ENAtoDYJAkFFq8o8SbiVUdr8WaZpCBgmKix/MRxEPwcnu248+46cOV9JKFd9GfG9VzAO+eTC9Ii+FDOVNODhY+Z0eFADnohi9epqbao+OdnR+ysijoYl/bxWIGWgUR1Gvf26uO44rfN2+gihjG9jj/etZVVLmV5DIyVRFJKyv7VPhDr05BXRMHnXOM2CMJzaplXdbE2nzusn2Pv1HUo7PSI+JI2G2gUqDmyNsTRIxBvVrBJzl3bgK4GF9XXVVB2iRFcsyJPCi7xAXNMR4CIREJ0K3hISHJo4bamYBNO1sa7HK7oW60Fv1GTxPm1K0fa8EwRNSDDxAiCEkAgIHveKRsQLZbXCSKWUTLhDw4o4GZiajUZCLh1w4y5dMwTVDwccfxmlLEASVeXBJTaCgCeDG4luoxJu4LozfEAEDTWU4k8lQLfRRCm4WwnzAF3duoa5X49ERclnz1563UVDDLHSMuX1tkoZi2T0qmZY0RkCQZgopRsngBNnbQLcPjRFbl0pIEX6wNhmZYVjIK74F/P2JOsWbelcJ9RW9eEQhHZm36Q3reDmnjU4td+FV0pW1IMsE4g8M2nLqEjJRj3IbqPerZduIOBRWIYUtLjJZ2iviW1bko6fwZPgSFn/AUm7xT8VF3G4DeQih09JQUYcuARB3nA7uDUABE4otvJOAHOFRTEKYgLORlEByBapVGkBXM+ZI+Z85uUnP/n9T/75P/9/fPzR+89fPPvr//kv/cr94vzsowcbxk4Btjxvdj/hMSGrJXoZGuqzaGixIhGYqONzzOkjI0LM6jfW74hja/AGmd7JkSM2TQUua1PpnHa+f3RwfX61efxWs1+YnTYbpZPKNi/EXLeO1djwjJ7hwcYfssIDweJcndjz5Zdfe/M2PNbtzMyJT4MZe1lHjdN+TeclHpPwKXvbU3Wczzn6XN8kWppScVaBQKDRGbkEH2E5rU7HqPh0lfBPvMXb8AW/Sjfw4+ArB1SaLhxM5OmAKtwGTACbkBqevXLX4PR0HNs+ECuhHKtzR46PWxm0klUmAcN2b90JlbQv3BSV3LaATA1VTs+aYZjstEQHCPFDRUnTkNP4hXstsOvBANnifRlM+G6xpae8DOa5DRwwJnAMOHJ8ECqN4c40o7nFyBLdpnqGKvx99BdWNFQkT6uBIBB1oUjSTyq9GQAIUZYUkWjc6voL2JQmPhq4RgmGWes0vwgc0zQJWnILwTIGm+AT5hYzGaqzh4MSECWo9UECifuMsiAQNAPIMpyuKyQ0t+yEkJ5RJvyhaQ/4yIAQAR9/CJRxpR4FogMECfIAgrNbVxCZQXJLz+DLY6I1NksLWYYUQWN0dSuAlEKWJ1HCx/WbskBy66pIIIozv741PTVW5/qen4u/6ICV1dvedd9EJnMiDoFsImPcxNR5lpysK+NXLkJbG7VbRxyT6WbJNOJAiAaRyIUMU5FbmZsoadHmFkJdW1C0EKq5D6N4PsgMT/1i2/BrBuaZEqEiQJhWUOxcQGiu5Gthx2c6E9Rrn4FuGCqVZCI07nLLpfKSPFXpacqGuTBwZWw5rTWSATd8QKr2zYJz4srVzQAAJ07IromwBZEUNbVrlSYMXQlVb9HKFWfGGmE52/H7SmrZ+Kb3Ea4i0Ty6RhS0DIEp/As6Nvz8q6+ePF79Z//s//BP/+l/trK08LOf/U+W+9//1tPlxVnbrKod+C08430dbVvPcyaeO3u7YWVlxsCp6n3hwauKBAC5ILQV20cHh7NTFuLql5AFifmg6RGgfP+0x3Hib2N91WlxHhDtUel0bzZN8h4lqTo2YR99HX6pm9Y/fv38JUs/+tZTgr78+vnz1+/+5pefnl97CNZd+KrG92haQz3c0FDn6cMBk3sk3Fi1NVwHF3u7qLfN2pR9nzbSeBlBFg7YwgwyKpXlxAvuDRAOD4gc/AGfPn2Kj+bgyQaCnmvtzrrlfq894MDEjRr0Udr0qStCfOiSONw92dWbQ+A08WIkgA9N48IBvDJtmOdSMba5WQgeqP18tO4tMzCN1GYxCJiDOCqViCjp5xIiVNUnwZHKG+lCb3sApaVS+0U/lRin4SOvSEcZfLeDpNTjbm7lY6YvSAZUA5LiUNP4asjySOQlCLjTEFBsqJ2dnf3V1aWaaO7XzsbiBUmCIaGsiVT1XK3zwqc6xmqHgI1nlbJkcEssKlUColOFyVMwZTyaOUyaQyGkX45rWEIbODAlmPKKTPqte1LOrdCnH3s4OtGvk1WLCb4cKa4yMA9/a6MiDyFkFWkJFZ/0FMSJb3kxREqTpfbNIEzW9F9lSmsPfCeadTfcUh1rKgkqnpQUK8hdKc8nLNIIo61S6gnxVEA8FruIc4uDjMQVcUJw9o8PvFep5nVycXSyt7Q0zbRf//rXUzO1bWZmtta7xoY8J41o5A4RY6xG4UQcDp9ty194Mi0B7QmAAvhDA+fD9rVHRQM4iYpaFVc7oZ4rxcBTm57oddNqo34I8lyNV4Ns1YqoRJsestd2PVS6aF0A2igAwQojhkhAUBllKAbTcdA8xhANaW//kFxAmDCQU4ylKEBKTBs+4URbMQDS/FO+xZkCjIVgT6BnJ/XFwfjBV9FwLANpodRIQ8UWlWvJar8V5TbMdeXIIxcwLqI6Pi02CKlEz/qG16acOt3BjMc6TaZ7jg92Pr3HdwaVkzULcj1kW7GxY8rOiz/5D374//zn/7f3njz56qtnv3jxTEtanF/YfPPW15NqZ2NtnYsO2nZGm1P39/Yp9vrVS1fJ/MhiBadt7+3aLiyG5fnKuYHmsCbFxqLe4UHPTy0c1X5K+ot8+0ydSb08v0Zt+PjoRqcdNdGt08iP2luZgyaI0jrks9P2luh84uistzBXi/s6qd2t/fefPrh3/66Dyv+Xv/n5qzdvfXbg3GbbhNi6tLRMbe8SJA+Fxkdtgfkkqi95TtMc0vtTG1zLBRFCqTsZjhISqNQvJcmFpkEByttKq7dirEbNUTIWAN6+fuOdhMWScT9QVD8/byXam+rxoZlu/8QB3SZAllvq0AXnS49bzzzvG7H0EqpYe3HwO2WMTK4YpslQwwHfrdYm+Id0bxpsHPIE88l3P/7Zz34GjUV04y5WyKv9ic5YToXy2E9//CUvYVvklDnwSTQ4yKgm4uwhsGR22qtlA0AuggwztyZqXPHNpBROhWqb8bgtSFuNQUUTVzGbpXnStVRe9Q4gLYghyFUT0/iTJi6aoQVy/hQYZqtCaPjJg0WoGhV1jfBoGt9qPzFbSyDYLUXhOCweQnBieTWHVvf4eH8IMwiu8ifHZ74ukdx6IJXksWoqlU7l2eZAGQ3SsdeehdUEC6mr8uiOhBPxl9GJmwqRqFTdWC6HiZaLsc2YwUK6pbZYBB7PssgaOj6itk5TqS7e12HzJmJtv4oqgV7bWlpvwPflDcyRK8hVhtre14HrmNySleTW0if+FKAq9WKpaoAQk1FJA4bGYc6HpnlAizh+Zl1u+VD/c3x6XK9jRr11rEdaIiLXFTcVjzmgPEEBNsIhh5u7jc9leIloRfBliIvmCCuvQ6mN7U6Bv0GACc2imqcL+2kJ4lUts3Eo/3hqQYKWCfhDlsGTCTKqW5FWrYhE5KovjRyHdLJuIetJ6WCeipbh9ITPMxjKgPCtCSYO1v/cGjVte6gl0MGeJdrU2MVbQrI8jKEEmKjjnygT5jzs/KKjg309pt0NpJivkN4cow9hr06qOs076xsHx0e6YJ2LxXzme+0xP7+4u7fvVw6cI68nJIMs/f6dtVX9wO7Olgr5P/7Tf/z//n/93+2x+d1nn+1s72pymsLe9g6VnDls86nO69XrF9NTHT4TAD0b9w/Mcup76Tv37j597/36zQG/yjs5cXJUW2KOD7yAuXZqJlPN6DVh39htbr2en1tcXlk0NunajBn6Gg0HQy3FfJqv1IXqtWL++t22GbS9n81SDqno5SsvjwyeWr960Yj4ymDvA+eT/vn84vJf/pu/+uWvfmsH0fb+YXdmYWKye9q/nJ6dd6oqrXBAZVAhxWYo3PhWnGgF5u8OgwVPDODsXS6hApITVAfbiSqXglzUTzdrpJQ3TMpQQ1clstWOWvMeXBj4ynd3e29had7Lna2dzfnZBa/M6kXPhJ9cvzRJkveCe7wGgfo4w6dIlNHvk05VwUac6KASbiSq6HQ4rDg5ricDckn05GGgpXwiB+0giS+bRw0/iXBwfrhJ1aqqWSliUYA67tpEVh/n+ja5Jo68xAOsNtOSB3fbmazXs4ttJSrjpUrRCvjTscG+upeB7JsPLyjwp3bbNz/sKk8dUrC6UYCC7QkJFfMZwg+KTAJKVttcV22VEjdatgYMgwwQHldqK4rwSGW4xV0RnKRGWNkYU11CZkyZcFn1m/alaL0DgOMVpaYLgUMjF5AZta20+cvaYv3oQXMmNFVFXO159eWbz1ra+c+qBxXvKEXFtrRn5qlImmMYc4ppY0s6uFL2V3u4Gcxril3vUapvUhm1A1We6a7Vk6R62gwRc1SY0IfykZJb+oSQLD6lZBAwV4QJWgojj5/li/2tq8W3ONNO3r3bmZ+fwgRhftpFHiu3ZY5j/0erZzyuzSQ1xcAtGaxoFRtJJM5tgGJMF9aecm4iLJooRU5/HKRi31Id3Kw916nFxT8ISNo0pz5Ag+w2rq74/sY38QPOMR8OZeBjoohK8PEEdyUFEHmKQCzvap8expFDri6+OTxS+IcfVtdW1KD+AlXNFZjXJoEQwxB4dMRJbTc15TbWEYqPPImYR6WSPlzbeJTmMVdLKM7tnZ2qVISB0jbODDXn1K4430Lqmk5Oj/3QOc2pi7met35wZeSqf3ayt7v5wYfv/Sd//o/+i3/6n/7yF//+1auv8dFPWW8+OfDMOmUTtx9F8esq795tCoDjwwORbmi089I5i14Ff+c7H6+srW/vH5g0Pn34wO6d0ZE909J3vt7yrdaZ78HP5/wI4vnZ/PL07MLTlaVlO22o4UdIfCbMhuWVpfrUa3JqYd7hENOs5tf5y4WpmXkDgGMnQFRmLeBc1Xyl3kCcn+/s+OHGesBSd37kxsCztjL/6vXLxw/W792989d/8+/5eWF5zUjgbPLd7W2/MaLf0eUKP1MfP5he43Tbv8cziRbeVnduZXB2VdKumlt162JcXVRjGaowpgZkbgdkUUHaR4hEu3erK1Bi/PNDJIZDceTcBZjGMvChc49pGqpu6GLosiqUGozFH61OQN7VtB5DU2BSJPqobsooFYcgVe+3KxnqSD6lpUZTzFU+NsoQJBWwDQB6J7c3z4a3D7VKy+HGgoYfcptrYXIjVlGDD5GLqEJrb/is4/AJDakhImkIAbKk6zIFMhhB9hRwfV5TLqzYm2mcPOeUe9uZu/jIA0ogNTVG2VhVHwEaiPyNfoWJ582oUFugb63FSxnqlLrVolLZUULeT9cQz2Olq59EqN6QXH00Wn96Rv1/bcAwo4PvmCx89B6aeHuItqBRPRomaktNCFbM4XAH6RyBCnNA3qEbZHmClAaeTNTGB6E8BJj4BCf5ASYEeaUaThBC7mquZBUAPjMIat40WOpWTKZuelJAWrU4q1UjyJiEw0AltJKnIp/qAE5P1+hl/Aj+QJMQuiUOHyT4JAVYTG6fcshlFxKQXJuXqv/lHJiYo1WUUmgRBEEC1DcxLEKwyMEjNT1XRe3X5kDEXL1utVBUZzdVLeDpGt0wCTdA/CU+l9xCUImqjARw2iLX9dPNQI5Dbbe/XQ0QLfoLsU5jGfj8SX8ZOMf1o1relJe95cWasRYfv6UWTeCUkc3tMVmfDoFubiV8RB2EOmfF/x6u28+zVO3evqmzAgtTZ224gS/ePTgywYeflJ+Z8ysoR+rDuS8XZycHPd9I9+7fW//e9/74v/pn//mH73/w+s2Lvb0dC+eU8Si2tLGh7yGudD3rTXcXePHt61dmk2/fvjK2LS0vfPLhD5nsN5ss1qysrDpx/8WLV7/99HeChP6dsVHftXH88vz848ePGD690F1YWXxw765Phaik1G7ziqL6CL+O7KhmNjpiDmY62iboQyvTcyNji9XW6nflai1l5mTGEMhvo2O1Pu55z6dX4xP142e2+K6urvWcRzs8/h/Ozv/bn/38i69eLM2v2J66t39k3evexh1DF6P8jJpaVo+W4HRhdDDhS1JTnttwtmO//axYdWSTfmi3/ZaUGhF1OvE8t0FGZcZKH7VTbmeYaV/rcAUMKa6KeNEVKySpdMhcHcLQ5gpTPboqEibcoj/Eh6spbJqvlAdEIg7hTAQX4YY/fBGIVkpcRUlUte7UWotrUgYARVI9U/prMxJsq+m0+WVKW2wagKtvrHmA1YwEvB6jfUZnHdv+H2zBBb8M9UxYyp81M67nKnnvfiRMsGUOMxPn2ROBhNrI4eBTVn/zzWgMzjWeJQYjqKk8vHiVO8Ah2MWhlDAJpP1/0zERUJ3j7ZCbUk6EjxwfqXBaQhihuQ0VNKu08KmrFL68DLmUEQTJQ5YHcSvDZpCMBKkhUhAiJx2Em4gDhGP8UyTjFtvAIx1cRpKRmmm1dkxKrFAEqMEQbYoRWQHCkfC0/w8JcjiKXBuz4ox2cAWUD4mvye0Wr5bTJh0simgIkR6G6hU+FwUoDwEfaoCgSryCA0JzLT5tahBxrgkjhsN3DbJrMlhFB5zlA5eXIiIew5WlqU1qywcCLcq4SiW8KQmOrUQrcLcyzAk+NLeaomm+RqgfDC1iRXCI9hQMh0TJrXRbpzSqKQ9bQTRn+9kJCk6kRw0QnGHigD+di6pO6awZQN7AybRUXoWGXMCCJIpkqD4zO2+yXF8w+vxt2Bl2Vmy6fvXQ4/nC/PR5Z/Txw3v/5//qv/jx7/3gl7/826ODHUuF/ZNj4nSwM92pzTebuHF+Z3Ls8y8+293eMqLYmHnSO/r4k49+8L3vavO7+4d3Nu4tra5+8eyrn/38f/76xUvLJtbE+Wd1Zenpk4ff/fhjH2TpNE1yZpZqSfN3X3xutWfatoD5uWeffaZH9gZV36Y+hbohXTc01hrr2voy6wx4drQbVTmtnl1Mhi48cPv9tcW9g6Pu1PxRz0FbC9YK9g4OKOwVglmatwAffvDU8teOtfKzq0cPNw4OT8xQxUJnquakun6Ec9U0q2/yAylozdg43KFGasrAIC9xSD1mVqqHUTNlwLKnTSZ4vpBaUgqpHNhaqzDAEyarZRS5AsJllzoCkQmt/7i6aFscopKB4yrBoRtfec2Ag9/8cpsONP0Dz5BObbKguU0rw1AGOdHmwyRKUaAyzS4M5aMSnWTKEF20uZS9nC3RKwi5lhWTFY2k6359/ZgT38DVVwXkdT0ZR4cYeCPFm+gMAC1WacU6PEkt37alEQwRSsGsZtM+pK1OCiqC5pdqFcEgj4zyU3nq5q1FMIv1TdfPkptZHtZITIY0KiLJwxAaICUkbC9N8ptmOEcQVoqCBr9atZ++bCkdhGzE6QIs+9TzZvtSg/bchJYu8sFxTQZVSknnowBbYYmToR5NyKUJchlsXQOUSd6tmLTa7G0Tqlhknoj/2XlN8LkhL0LhQ2iaVCBSHo4r6ewmNLTyeBIKRwa+okePHsI05bHyI8jKT63HDKZbtNRzS6IV4XgPEJPk4buFiSFMPElXBOJnw5vJGlh50hUm3ArUsr4GD5wJyQhV/VrbKggeZFQIcPb6gbfkG0KVQubFFgMCtPQEKo/Vol59CNN0rPqVYHruphKMjHZWun3j7lbn5RdRLL/Sx62XRjKT9dOmZQLR+ofORHUxlNHL49aY10o93WkAUyS0sCpZ0L55jQkg0JKSB/cjtfrx2tHXkmcaTYEOHnRqXHCUb/u0AmatLdfI6vijUkl3KcjGR4fnZqbV5NzElA99/+D3f/QP/uj3fd712W//7usvf7e+tqz3PzmuI7u9sNjb2Tr1e7Ozs9a4371561Qfb3O8mTw/O/3pP/yTR48feCfh7VS3ft/t4C/+x7/87adfWKwx2Pi12O2tXSPET378e52J+mFIbws2t954SXtweGjnxKMnjznEkvcv/vbfCZLv/uC7zOQaJ7NSdWxqRleiljmwOzd9fib4r+fmu95feOyxtOU1sjNED0+OPaIvr66edHr9t+/sFV9w7M/oiM1IhmcRsne6d2dlxe/9fvrFV18dv9h687IzNesl6P17Gy9evrYAUfHpO4KWBIPAUe3isVaxu/WW0dITN9d3p+Vbv1rrO6F6QBFs9ERSarfJHBL4dK7ab43U1QMjoEYNx1VsiHZXqQX5TV+smgbJqC/MwsGPLqCyHAh/Z+f0ww8fqIu//utfLS8NOQuPLK9/tUTqp9mm68AZvlcFeMLBSpKnmDTa1nOEm1ElQjUI6jHObTOVj2OkV3hXVtXqRWrbOhi1a3+BeDs9b5/ZXhtpIteat1f6JdF8Jl10E0EoQq29itpg491y82QNA/kUAweJJsyRYKZDlqFbEvViS2nTWnV1f6CuZKhLwLKwLbYA4o6pq3zwY3DcEcKwRgLnVlCxxQcJO7GFH7YDPRRxurqRiTJuaUxW2CJkhqsRIlUeBbDCnMvs7oKcXhJzVK74I4GjKBL1O26JUOQKnz6xwq2igUqALY99GasIK/gybgt6m3CO2pGFj0z4pIj0KOAatTEPGkwuZTgI5myUV4S3DHLipCADgvDMgA8pCKMPIITwd4WJ22AYhoaPazQJH1cc6CDJBDjQEDK5FUffeOaIlAhFwnuE4kx5aPFPSjVUSWn4YwWf8hLTFBEUYKSD5HmcCGpTJuZgKyMFDXMQOKzDgQLGA78ATgdsTTChySuC4xorAOWJxhYkKWjg2c7hVopDsGULtNiePCYgxrBap7yqPWBI9exwdeuTE6OOwv/J7//QTv/jw913b16bGxzs7w5dXPqR9OnJjg96fZWtukwzX714+fnnn1mA8uDvZ35++MMffuc73yGL4Usry7979uz/81//N3/1V38tPP1M2IsXL9Xehx9+9Id/8A/MVa3sOwBubnFu/c6aq9WnRb8L35Y4TI827t3F0xtq6wkH7UfWKuZtPrGaY8vWyHXv5FBcUMMRpPEkpx0dHr969cZnhhYNFuaXrHIuLCx5Y/zsy68np7o+6GU7qiWbhOqjq6Hvf/Lh9777kVcZDq9enJs2afRexIlk27vbLR6rO+ZLOjCW94xYqsNPxHOgrsq44O03bzsKG+eG3F6ZtgiHqabUuIzqQJK4gikB6gTQpiplqgIboWvwq04HSdfcZqKDEArJn/3ZH+PDbx98cJeSxhsICUv4BgZCRRRNSudW0QhVkKtBJaGb8ACRoEkUGEiWT1FKwb22iFEMEWMhJ5cgEJmUkm6ZEZBi5gMIqUooEiKiAwWawOquZVyJyzWZNGcGMkFCG90QkhXRSm/eAYQLRspgE4nAFZeYoUimpXg5BpeBaGGGA/Ii0WHWLK486KjSGvJrO40zavS5htPare6JMutFdfBA9bBZpzYRrRHCew1b4GmJldVD9p/266qI0lL0wX9xcRmQ0EQJDyoFiYVxKPVkACV6wkSesKNw4HAAgyDP0sBjlzyqG/ubxykDn1xFMkUyXA+zYR6JbqOAa+QGolRCSElXA5j6XlheEn+6qM5018GBdtETVz+4WhOI+pefXQUMOZ4yUSmQaEKZFAFSb9KroJaIpkMSANHQAHkApmsybearNs19S0PlSvUdZoJeNOlHkIAr9Wdqmi2haPGsqm9+iz4wSeEoQqMnSFzhbaGAThFGdsjAFHKMxdjiBjatn7VGUaO+OsXEDhNXlY5Jfrap2VjduhgzTaaGUpoQ14y+qeVoJbCRk+IqNVqk1X5YFBPIlaGbELUlaXS8ZqbUxhacy22cv8EcGfOrLDoO5zTYB/fw3t0/+4//9MG99Vcvn9sp1D89do7m/Y07fkJPP/jVF1+nc7GYY/pvGXe2Tsc7He4M3b977yc/+UkNDr0T2xT/4r//V7/67W/7p3UGreUgJj948MgE2vqWmZ9tnE+evPfg/rpqOe2XbmamAsK5z+ZA9v/QzVcXu6+eO3eM3ybnpruL86f1HHCuzxUvZdpludeGetHm0cqAMTQ33FlbP36z+fz5y8+f/c5eeAPA8urSRMcXyEc0t0DORfpuad6PSdqWMv2BfUdfPX/96s3m1199/vT9jwwbduOc2kVjgc77h4nxYx9HXJ47rGh7a9PbWr+0rqkYCBwwOuEx0du1qqfazWU7rX7A+VUs0oJYkeYWz9O2Bbum7RXoqANrdYJCsSqiWp/y2o2vFmT85QWVSThI4lnjVsOpAiYgtNn6yy+/XJhf/OjDb/+3/+1/l6gYRA7pAlLFCRL4tEKbZpXuEXAQ0gm2wRWJPASNx1/x1D9UD1isuN0jl5O2/ehCvfGy/ay+47m+Gr1mWv2KQEtG5agUKeZGFOg7zM8s4fBQXRi+SwdRKrUfdiw3mAb1TbBIs/LB4mrdElaKaC6PPXESxSqqY0mukBr+zUqZACKVr3EGZ79bJoU+miFMwg5raG4VhU85qz1Quw0+WlKYEXy38NVh6ht/oaAUKxAKQLs4rim2SYSOUuMB1OqoLuFp5QROWd4eIGCSNbhyTkSDYA6nXmXebk9kEUJX4qhKIrTon6tu37BdD3KtQ3GFH81VABIM0QLKt3XktljZ9tgQxxDMiYMWc2DqywaEGCrK0yXT1FOQYz7lkafvA0eLIRKlqJTG8FxhUj7qRVsS4RtIIUioXMvbzQR5+JhABsQwRaFNKQS3QTMrwaEC4HYshI9/ztqUh4ZJBA1YyTBWwoc+lNQBAfq8zS2jRJemgG0e+R1Qo3697IcJyCHMDyEmxLkaGekgg1zSFtxhqZroINFBakVVWSC4YYLELSsgN8RSWJXSLSlAefxdUblyEbgrxWTEWoZdAaBZTujthoc++eTjP/+zP3v6+P7B/o4tPf3ekXe8Dx7cI/6019/brg9ERK8XuTjbfc003S7r7t7d+OM//hO6dburx18f/9f/zf/3C9/f9p24N1t73FWW56Th6qPnZmbXVlYvLvsrS/ULoPpZG3D1K3XGXFuPqmcR7aLXO9wTSOPqi8K2RYowB1JS1bBmwVv4iAKDu3WDic6MicBVHZG2t7P36Weffj7Rmfrwww+9P/BVjUNDrVlwAmfUNyhjtdeQ5udGmN6h1wprSwsWLbuffmE7wLudd0aM737ysQ+mnGhVr3Mu/Mrb9PLiApP5LXHCaV6A46kisOJenzWZ21WgVo9ZzYE3eAZJqoDrnPKl1kQOS40xbJHBFiYcGXUtTlK5bmXAcZAs1UIDcSWRIEX4//KXv7SkvHHnrkqxZzURAg0recrAF5zwqSQZCLnU45R2KpBwoBI1YEbc4JoMKVJ0gClRTDKT0yQQ4mmQJkURoawzhPvCA2do5BJnuhC7mBy5gJ7zAAVoia4f6eqLQDrn5bAhBCT6m7SRQlvisJWnG5Ug0K2p0w71FCi8DBRKMqgCVQKhoiL2Mz51hsXAcqon4YAjBC2ZNvJocfCGjB/doqpRumUwZCGe1AI3cvMCDvSWEQAI/U91aHOzC9jaAyefujcy48NlrZJqTgofLbYgGDIVN3BoiiRKAuLgPTzF8KEkxSAzH8S1OqPmIEwYiLbVtAOWveqpjiDA6Kz6dCPYAhIEiPaync6qK3aiiNOr1Blv6DSoptQx7nzI80wjjlFVbfWR8zFyi7/EYbW+vuEc9qzFw5Rx/I8uQD0yQY9XFd9e5xItI6HCSpLhHBDOYRRDDAseLHlGCqohzopYBUXDFwiKiNfsKkSGKvjoow3bbDg3O4+PbYqaSg1RTpJpbbWcOT5p10RNuMTDVRlisZVdehc9gg0PHviEYB4UgmNqZkZGDf7nXhNE4vTc3dkZzZ0dnfYReOrXqE5D/O2Anm5tHhOE2q0QNaUzvaQ5Pi5lWsM3narfMcCsNvPUbgo1Bc2HsB6j2QLBtNq1pmAmxa1qPL45Wb1cVCTXNvj7GMo5R/VbGmd9R+EsLsxz5rYjw04urcM4bqE+77ke+uXf/uKj97/1Z//Rn85OTznq2bKPQ/8nxmZXJhZ1u5/++tPzXt+Br3TGfG56Tt15ueD52AOurwo+/s53p7rTv/w76ZemMk6n8fG3dwAcKKlNGzbsQcLqUX2VtXHSs+a/O34+Mjs3pWIrYHx00L8ozpcXe683PQX57pejvOU52Ds8652u3FnXx1g6PNo/mltcuDi72j+qpsGTh9u7FS2jteXG7dz8zHe++316Kr3/wdP5d+8+//zZhdNBrdQY9obaBmh7SHyKcXnhWH7vQnxv/N7Thyvra1++eOV9jr1DRwcn62srkxN10kC1o7Nzy0C+BHZQnaMvKKy67IZxoJXP+Hb390auRvxEAn29OlTUmRy3VEQBe1WR6wr8pJBGILZBRJdW8PXXLwRbmgYIQb5TEQZ6Y41FIDBBhgM9K3pyEsw6zdYSa4YkpBW9pHBtuukZAFrTsfuzjoyenq4Jbr1vX111pYlbzTz9rzzRfIWkRRx+N0sgZUJLMkloWyOrXacgbEdi+g8LFZ5ucbv0uVrrsotVaztN/9rKRU+0Hou9nvHyjwkUzjKgCtWZMBWHaozYZZ38dpdmi58aIyOIrOTJomjJzQKAmbXRnh+pqEswG/UjOGhog2+Jb6ZCkAE36VUkMY+iqKDJwMytfo2wJPj6PjgpkpORlOIGTkvJg8wtvvqrybhbIgZo+IyNdkNLkN5NEXIpauAmIYEYNBbKpAIwhAkBleEWmjy5aEFkUMm4pgics0CgMQdQaMpjgqeMZE4EaogJFeR2y16j+qgGD05PmDJRCY4MtLK5jYXFt7lOBnNCiUYbzysKpjoTDa3x1L4FpuGpiCsYiCQZTKQwcYUQhSN9kJdJPvjJYyLR0K/HhqcolxFwyB882GhENXZSg3Q6QK66Hiknk0VnkMApmUaClhRXfnCNB8LKLYB/UQCCUhUIEs3LoWitC9y+onCbeiHXohkplIk30KLChCugyRf3m0qpeQA0tlAVN2iMxQoHixXQkpBIkKVadRsZ4XaViBA+Kr/QOdmZOtjdMwJZ2Xj2+ReffPThH/+DP3LGgyN9DBi2sL3afP3iuQWfE6scRgjdmSUTWuFMSnm59QuuBwfHf/mXf6ln+eyzz16+eakTt41pemZ2rw6+rg+evZzwBC5iDSq/+91n1sZ9GV5bQStOa7q2vfVudWHJGc7djtZxPTQz4rve2igxMdqd7Hpb2x+1VakeiCVOO9/e8YRtxD08tJBw7LNeu2dXVte/9a1v0cfbBStR9DTZn7jqd6cnvv3t9z///Ktf/O0vNUUrSA6EwBNzT8UGonHLexPjlhzGhi7vrCw5WnRkbHLWePbLX9no7+WwVmWKYPnKXlgPJfUBRAtLPkllkRUPkx4ly7B2eLLeTe3wAxLe4yUk8pa5GKKN6JHSvhIDRXgbOVjJSxye3glE9cHBxCZaJIqQk445HOGqVJBAg6PIlQjAcIOAYbihbezrAs0VGhOCDAcTbEUaTAmOIsq7OqIOQ5CwgomcIBD4MvgoEnJl+FTHkxrVlaKSIEOgDGBxaF+8C1aBrRQHs2w4UkOvflWGFNzgUAAO/XgATilpZq2Y5YqBzEFwT62IsOLYnqnR87ur+YY22U4HqjYSMZEXU/ER5xgWsh8MKdWV8I41sFrQFkz0MPsT3/4aE0rbqVpNUWwY5CGrA9rSjbtKe595Vx9RRnKBvDe7HFI+bdaiTXIrRXOOa1RVYSkFl29K1pBIfzhN1fIsbvABg68IUIoTPBQrdXoiCISGU9YYOL3XRNsYlmjP+/V03M5GBx8ohqE8wmiFD69CCFx9SBowHJDGv7oMeQGhvsWHJ320qDQJjwWpo2gIn564RT1ozKQMgeBSGCZLZ1LATJBBaN6oxKOjwy4tTCqVPz46VHRv5Z5JYn1k1Z0i0SqAVzyqGEQf51GAUCqpcmuaPG31/HK8pt40h0aHOi+hfa4VY0sZp5CKXJP3G0vrQTiGWN5CWApVsopeIxM3axEmdGaBTIOgzKDNWt8jqEacaWJaXZo3BPZKMdwViaCiD9fB4UwSURXzbzTpWkm6PWHRu01O5kZo2gzp5jMnveP1tdWLfs+Bqv/hP/yTb3/4fg7639/dsjril831czs7W2r/7sa672MdhkpoWdQ+stUW+EoTo9vNmSWz8z8c/bHt4M+++sJuepMwulH4+PDE1lJC+Wh/b+vn/94vLDozznfCR4+fPIJmFb13fLo0N++EC4eGkuj3p6rrn5oQpSTaFOtRg/4Li4sT41Na29Hp+ZtXrwx/d+6sfbi05s3i6MycPUm+r6KeCaiR1W/Se4K2vGz3imOC/J6M3j9NRpXZpVqc/ebaue/A57zqsBoyNHl1WOZfLy6vffvDJxB+/vOf+6UqP3NmXLT33wo2b9c8rluzeLarfmZe9I70EhV2rZtQEQkb69dKhUfWeJlmrdzLaiemmptzIEw6pOJcBQOhmMioLClFXhUIBreaj88MSUrbhcyTmJOC2p/6Rd5aT519q4LUWpgkingAEzYAyifGzIWUijIRBF5x3Z74e2fnHmALuV69XAtU3OA5h6EaiEfmNrYp8TDamezYLUZJZgpRzIWop0D+pydBIJhEYkYvwgANAKjqdasJa+sM6wG3zeTIoo9ShBIz8URSddB+OEse1c0bNjdmHFtb2z/96U/VHGzC4DE4boXQzCt5WAO6mnNIIBL8sAZp1VH1AWiMQBidPGjL0AZEKaqGXN904h8c5mi/rbXetGSGw4eAUINFgq1uiHgGACNsKlSRhLNEc0CEcCS0MYFL5CGgUiXQJJlohRzzyAqarWNtrK2Kh2ZWAh9DdxSDH9GuSlWeM6QgBG53o5Ns8ak4aL1SzIwUJIrkKQNBSib48opQqQuYCCNI0IPDIc7Tm8U6YwOgaKYVHKW5MhATHKSQhGEgYYgPe6GFJOqxAi0rXEWkK904nAgJE3mE0dAthAQMzqLT3G3QROFIWCmSIUvTCq1b84goBqLe6QBNHlAqypaQA0ZPeTC3ugD4qVn3CN3CyYuAEA74yDANDnzaukKgKru4ERzCjVzNqCVa2PeiUfAth/hG3bqNlts76unQ+qdHzi/49kfvW/c/c3LBwf5Zb8/LQlMcyFb/33//PaFycLh39/6GXpVQCmBsKcVwPDs/s76+etw7XfAz8LMzd+5uWN5zOMRP/sEfarwWAE0CdM3qlZ7GW4SO+bQGolTe4QG6NTvx/fDvmJ1C9bM0NV3kQ2OnrtZyQdftmHVk51NPehMqmCwob+3sifu19Q0DD/NVbv0OQevQuc6trrkq2ozy8kzn4k2rjUyO4+d2kabu4jpTf9Nye0z96CSSNrcf6YwOe0K6POutriz6MGLz3Wujfo0iFcX1ez4qSPykpnibTyqc2msGk2alUioOjnppJPUCk1BaGQBkvBjXrJDTn0vTOuBDQCsDJ3zggECgPIiAKX1av5/qULkWeQhyhiRCQGjezHOFjDmcIkxuTG77NUB4SSkcRaiEEDXc4iyvKEDfKAJSHoRoeVcJNwhoYz5ammNbsdHgrkIIQoqYWTXeemNFgAISsJzSOn1vfW1VoFXtsmqfPZFIGSmn+aKSiMMHubynABIhwM8U+6ZH5lK9iUQ879BeIEKNDW7R46LUVar3YeWFcpyMa2vG1XO5pTTXO5Cj4VT7tLcnRWQ35LqA6HFhQgOf6s7xo0w4tCtfnFlVxNCthAShZtu8f7MkVXwagqJwABmkMjv9y63+gUDAEGEycMI/LuNitwzUidUOhGLsUal6NA5t05Y2h4Vds2wTz4xJNZqq14HT+TBSOJAIKR4g15y2wqJNkw3R3nJSFBwOlYQVJiD+CmfcL0wdKKKHqwTHlXgkTaUyRD5WNJQqBcw1yG4hyEfDMHGlFWMZInhc81Ebbmz3ioLVtikh8qyGVhVxhTeFEac07hK+muivfvUrVuOfqlSEPxxqEF1Pf8KnLQ82cZzc1hKbqjCbtvygndz0zhXuXiy1nTzYGpXg6Di4lDfsczePMAt2Jhq4YldKkiWFISBXy1druayz2ODkuwor3GV7+30LCLpyuxq9ZtLlmdRb9PBLUxb9/LgjnInxoXebL08Oz7///fdl/GqWwxs8VXsh7O2HT4KPT/xyQ23pNdz48MpykCUjPRFLNTl+W15ZMRh6bqlD2Uauv/v979my+fWXX1ocrx8N1v69fZmb9WKKnn6yhtqdsTn17JMCSZ1PTe2e9a+mHP8wcvny1ZslX4HNdr02pqJtJp7d5ueW/DyUvfy+Vd7fPagJdXfm2xt3fVrsnYofx7VPx8oMW3kDT1uy5Ld2dg0svmw4u3Sgvie58xnHdXZq8Cgf+qbVsawrKxZ/PN1NdM48f3n88omZShp3SOrQpVfSXz17tb56570nDw72fSZ97fcM37zb8hbbPFVc6qZ0mLi1KLbA0M7CaV9WCy326me43cxdxaUe62FRz+E5yHKBb6F9yNDeG9tT79awazca3URCVbaArI6kkrtJG62sBzjB7Lp/g9AmZPLgJgNijET1IsCQkMj/Kisp+rjCT9tpkV9TmQSY2MOn5LYkX/sfvWNvXQdYRWNbR8Fcc/aMBshpYjSNAjx9BR/qZQiiD7aSIi2FStiSKyMBylOyWlNbY4wCbmklH20LLTN0oLbURi5ypXTSNgHpVq9GSTJr44KlpQXTf8FKodjvOUjpQCoWbdm2Jn3VINu0zns8CV+pZnUt4Q5YY0Y7f5E2ZXYboqGVRk08CP5YQaaT51b2Yx6GSJRKSEQ/VVNt8AH5k86aOTQIisrmFlaYR4prMiDQlOoVoA2kJxPaiAOR5F2ZostjBULjIghHyVeDmazAkmBKpFAGjq7fLe/pX6DhoCh+pzMTkABiEmDp15QHp4bhXSkOSl1TqQjlWS3hjBayOvLyxhRGqSpTUwhxcI1WqWOEgQQ4uA3P3IahPBzG4hz1XOnGKFdy47cAQXAQhT7ul9dDUZh6nJAlLJqDQEYVi+Ql+fqvPqotP7g2WD0fyIsShTg3zIp7VQ0t4vBPU4HQCIsbkyXKC1ObTjUZ7zEihQLYhnMhtEDCgY2AVOW3mzlFPbnrOkq36v/byGSrut6fIB0l862Pe8G2v9NbvzP94fuP7m7c+eM//APvQr199atfdsjUT3O3bzJ5wI+6LK+t/uD3fnC0t3N2fjI6NrO6tji+uIz32f6h1/pDfizz/HLt44+GjGl7e/eWlx0/+Ytf/OJw3w+mr5yfzdZ7+vO+FY/1sVros4Ng/c6qz8E2t/e2dmyj/cwLg95x/9sfvefYFGc4+A5PBzkzv2CoPjw5/OWv/s5HZAY224sX5+Ynprr2nOzsHzjRE/7bt6+dHWR1SzUJIe8V93a3VaIXxc5vOBu3L7POPuJIZym/fVtPsTplE35vemvA2NlxXI2MPSfqrH6M0Ah5eX58ctR2OF4eHO56uaKfW5yb3b28mul2bCTkYI8UZrT8qy7UpmpSX6rJr1nyfJvTX3iM0MoO3hwKYCI4U/3yvwFAkJtbWPvyxVaexRNjiZnGrXoAGbWWIq4TPM7bkVihFIQCjIUGIrwxB1TEGz6KEBWWhuC4dYWGA/Jk4NMHfvRXhIlSEiM3EAhMlaAZACAkqjGURBt8SakeQ5G+ghp0UIpKEfPLlrbIUyFeI1A9cBDniiEPTNrPYJrlDKk2h+YutBTAhDLI8ZGBrGPBX6I/HEVJ9SzAxXENpCdPnngCpRZInCITRZsGpgDVVgEDd+VtvOBA0HjQEhkNKGrM5iIm08r8CHJr6dBpVt20fqMermsBt2N7m6/PcaBx46wuOa6GU9/aNI1vHrLiaxJtciULH2lgczQsGd9IpbEIaLUeco4oyO0DHSoKJ7E91a87aoZzlKGbjTVHDolMSWy3ftnYdwCkQeZSysDhWJpji1UERW7pcRs0MOFDkFSPKwXQBgE3CQecobmqPwjyGYoChKDuOU1Yo5Vghht8+ciVwTbcQMgCCbKMhIMnEsMsEVUFSv1n3ALh3jZoFWHrcN1a9HfyMB14MvWuVIdCDYsMTKM8BjJC68aKqY6ehRowXQmVoYOcW7VT2t8uBylNEOIgX2iNRttSByCE6s3NG5xv5j2XN2aXp1ytpBLOUvKks5eqGNxo4kbjcQRNY0tVMyaGG82LariWrSUdsYfr+dk5u3B0zb/3w0981To/OzPZGZ2r97RaXn9upmOb4/2795FbVPFuy34b/ndQxIVtQz6XOj15/fb1XO8YcG9vf/hgV3zVisr+rmGzc+eel6HvXm/6NdDpexvX25uf/vY31iocElrHx9R+pLHzs9GVVSeEPvBt8pt3229eb+7sHr56/Zb6S0tzXodZFtJs7HmxcHR84pOC7l2H5/nJedsZT2xEOtFTO2lRZ31szcEUc3yk75xje5yuL33KMDnqDLkxPydi3cCZRl5+8BLp21tbOhpqX9X7nXpFR3Nfwtmb5wnQj0d61jEae05bderF5dXXW1tLi/NqZHdvS9jacmMJZ2lp0aAlbPERznZwiQqDFhEtvqpTSxVzIKDeUDx77NDETDKgC2PVBKhq1KPgNxiUhi0lktWgOwzhKHJF4otcfxfDFYeAalwoQqOMgNLToBIh4AkDo4sBgGiqQgOUghDRrliJOiTg1I4gefhEeMsso7TwPezQxCjXElZ8olTcup71bz56gJnEL3DksWEU5mYmIFzuWdeOqYrP9rvHSrHstDcQxEa6UhFbKjQFPBjJK6IwJhLOiqTg4F8bses5t4056N1awGV/C/2aThLDZBpr1RYhBAFilBLWkh+eQyjh2xpptVL6QUPlsyb5G5FNMzxR5Yq5Uq+DLBepEkJhykPgdv7X/NoL3eJpzwG/I8RZwoZJeexzi4QODVJrYW6ZnWvc3Qxpfc1t7wMCH5oMHBa54u9KE7fYWu4QMSCCD1DYwaeqiI8m3AINUGq9Rv1eNhIRQI1cEdIkyjcDy3XxgDgT4oYKfhB5Vh6baTdzXjypgUQCl3cKsbVpcyV1weimdhXJ4IlJU6QMZxS5fFKKNXHQksENMDypkchwBdH2MJF3daul0ZA5aDGUEIan0tYIL+0MURqfU0NiEQ5iCRO3nCBDdLyBCUMit+lzE/RxCAhumLdbrenKabBWjISuFQhdFHvSHfA8VuoFWwwZa8I+WSc21JNEO9rNe7EKA8QSqiCrCImGyDUpYYvcF0tCtu01sHW6r+u0ZPzw4UOEBjNtZG56xgAgAGdnp3z3qk2Z/q+urDvlbW1lxSSXoK13m3488cmjhxqR9mvx57TXHRm9wyF+HuvV8xcyJkJeLJH+5eaWzxhJPvviGX2FjenT7u9+O+PMoI4B93pieh7Pg71dc3DfRliD2tvfWnJI0PLSxtrd/tnl1va7/YOtl6/2X756jnMtjm9XJNjLjxvrVIpThjDJ3lCd9e7ujvfohop/97O/QXK4f+RNkgr18ZBfEFuYn+V8juKf/d3dV2/e6OVn52owe/1u0w8QaXLPv37pV2gqVj2PnPQc+DMxPna0v2fU8TOJWBkCfdHmlcbeQb119LmccD09OXJ8NLaW5e0dqE65xafKYTs9RUjFlZOoT/u7e9tVU6bOI2pNixuf8EFjvhq5GP70009VijiBE20ViQFXXnVNNLoSwRv4y3OCDAWoiVbiefiAIieRyfB79za4xU5ImOChIo6G8kgQupV3xZ/kKIOPpBRPELREQ3OLOesass9sq8/BHARP43Fsb09j9lf8/bdaWNU6aXtvOlw9cSUMLR+V5u3FW6c7Vb//c14LNmxkmqLbFTZy6nlCQsUtJMpDiLvIpdLw4/sL7mGUvNbwin0hleOkSHWVL15+x8hXqd7325Q9NeNqRqA0drrFVN/tVr7B6xEeIXmu4KxQJA1wtDTzHMZbMWxTD098jgbbgelVGNsELvX4lKqURYibW62yf1rLJtznFpCv9QuqkFBXEJ2UmpBIxAS3sGp61tgOHvPhoJVnPkLhpRG2iCrfEUoEtkL/mzs1AfWSdIDgy5eaMLYuG2YZ2YTKA7pCTlVheKuqR8A69gSEAsyjmF6Y8tGE/umFAxSjGPtQyHnvGoYgp2G7lsPDgVvoE546w1iHP2Mh3Cozql9DYrBPvbMXCa3g00GSp0/Z0KoerQwTXKOnoUh1YCjFIn4T3K7GNZAU8QfR2BrcrTA41sst/lZmAY9P65nG2EQcPBCJFFSzM93jwz0dojxW1KOD+SdMCY4VfBBTZSRmwSbjp0cH0916ojdp8orVMrGXqBTWE/OzR3s94+RUZdiLpwMavKz1StYs2EmiD2qv/dH3v/ud7nT1pzypK19c8E3slIcA0Xh1fmLPjyUUS4/2UP74Rz/wUayz+Y07/+5v/q0N+08ePnj6rW/pXcxH2k84OACGufXzAttfPbOSg+GzL76y15J/PD46pLN37hdMpzVm5zRM2wk/VuHtsXhj4x4vbW5uzc7MO4LC/oJSmGf8CMC5B4gF29K0aAv6u7v7IAuLS6LLUlIcONe+3fMizq0PFzizouKs3iSzXR+n669NXy2B2GDmFbcpiJAT5N4u0lvcch25HoMMVzYNfv755wYwEE8GGOrYLH5BQ+ht9O5R1ZxuBoJUjyb1W2R+H8aZh8fjNtEeHp/6MmPYFqCKN29BBEyWzsQhEr1MdZZtcia263mxupNae6CPV8qEau+ku9M0yGX1vE8c2gqqwLD3VERxFG7I5ZErTf9TldE6OnIBi2dLMgwXJKi88cYZRHTdhnoNBm5ZGj7CwzGiqOFjgJBERWIGHxDkAg+VvAoli26GSUx4G1BbBiyThy4tplWl12pEdfBw0OLmPZxnGISA0daV5jVNNm6N1af4lolAPOdR1QObUyUNNysry97oY4JnxX/roCDg7JEEN3LpNnxvfRpUDtIgEcwot/EOBCn2OIUIJQe62goIqOnKy1DCFevm8Bp8GkOFNQDQO1IzANADcn0M3UiaRKMdf2nn9cGUUONKii0uzQtR9Y2Pj9tdAeFzt4q3V0oR9eAApntN1bIc0JVoRbpUV3mJUHWQTgRQ3hWmiIy/ECqFaTrbKG76LMBqG00fsshlFHJTeByMXiq1WvvtjBstJ4RnxFGe7a5uq/2c3yxuYMU0CmCYAcwtPiAwMZextVRsMZyBrmIOAhFCh9/kq3abOXyCj7z+ATnmSiU84aM1OiOHb8WGeorwlMFKhs7IKQmCh9JWlRUPOMjHJ9wJxXqC3gqhFE/CUfmQQ677jsn85qWxlYXwMQCQoonypHctxfl2AMAfVX2AVJ1o9QsQxAN8G+tsohP3OndrRnh6qi4DzS2ca7a/7zUqNIky4PqvKKbTdwAAByLXg+g4bNn0a2UWOlaWFnlxaXH2u598e2XZB66L79690ZNy+NLSiq62as0q3/XlnbXFg/1tj3rq0IQNE6v2JiuWXIwihhx7H+2dFSSeB6nuGdgqAMVUkOBzlr2ugGP0g3QTLY7P7M742MeczmduHipqDmv4sseGM3jHHPPx46d2QPLhzu52nR7a6XjHoBYMcsj5wYIMe33Qe3R8cvfufRt5H967z9E+AvZrEz6FIojj+UEwLNQSzZmfUtGFqdyd/b2V1XoQ4eSjdnhcGWUb4vmVIaEeYYyUVZn1JZhvBbz4FbeWJESOr9lOeqcnDnkerXNfTi+uzyz22n7iUL2sE2LaVkrZ67urt5vbDhYdGp148/Yd6fX7YtlJYrOqp9jqnqoh05Z1FTy2KXtY0NmIRGvFILXlus7JoIPA5ArIIpYTIhEhFzKHwvJGuISxvFRmNDhW/MkhgbhC0y5AoCkKgquiXMEZkysd9FEmglaGuRQhcqV0cBtB1fjaQ4YKxVaRjPYDOcyVAtrNgFZlwVlYqEOcGMX/jCJFGSoI4Nhqs6GyC0iH0DEAGODbUd6EcQULGnptzOv7KdZ2LGY4xCclqzrdasjyNTYmUVcaFMRXQYInySutc8VrrbxVRjsSWUugmZDFB0JjUizZJs9B4QkSv7iVaCNxNKCdC0ppbMGLPSCK2M+VEOSxGvSJzX3lSiT4yEgQ5CnpmgoIxBXbYCpKZzrQBGfiJEWinFwpTgBJkQFAJubzAFnVltqYH8wwJwgthq78NMAPw7iRYkhUsww+gBJyV9aBRw38kcMBiR/c0lwpZAktt7jFnNzmZK/L6v2BJHRwkMGzuuP2ewatpObj2OJQrm6/gQUHKwzDjc+RQyAx5lBAUhp9Qus2ugk1Q3IGYEAzQQZZ1cOHazHJ04naRkg6VXX38nhiSAQ+tjdBa89d9ZoBGkOtvEE2FbDsU1FKn+ELv0IidSdt/x+/Em/t4BQOuLyo5ofSKnV3esEk0cLF9aUVIXOTocnxDh4E31nbsIpiqrVUK1RDE4uLRwe7dufMryyur648fe+xT20XlxZMj16/efmdDz7yhMQoShyeb+qFOc3Ltu2rI6+ubLT36bDOfmn23vn5ih6zzut3wr1X1k7h9BufPQtK7fOasWFncaonu33evHi3u7VthwxND0/2NUA2Xl4bvDu+9h26KM8ce1rioyvf3vONTRHCyYbyIQ8uHhGspo1f+uLaltDaEe9XEFeXFj1C+QEy/aN3ufVLdyf1O1wGEjkrP3QTat7tHR4cGNiEhF8Z0/+K1r29g+k6yo2T6uU136sXQg1m88Za6zn23tVhF57UWhfWfqrIk5BTdE56+zV1GLcAYj2nsbBmoMOqhfWxS1Ov+mXJCjmN0lWkmfj0/JBOr79Qh97ObG9v6Tp8N10RVi/hawaAUYlrB7FRbJDatyBatx62llb4zVXViwfR61ZGWxBUMlRmBQSM8VSKTyIQZJAXfhK4azDlaaaHUfUaAs64FcPbx2KYGApvGSKoqkhgyEtsVCoDGM0jOlQgbq1iqxfiqJd2Z2CuOVHrOogmDpPqBHijdTghREsckliEJwgqaaxtbzU2GCS0A5Co5EGMqtEBIZKGXo1Rwgfn8p2UMh4ESplHD3lIbgmWhyO5pWKK6CCjFGHsgcDMcEArQZBkAGWarLqFDzmcFcWPtohl1w0RpnsQDLM2UyPkXFJiAB3xaXnfStTsz2282RSo7ikQUrBKN8c75KICdOViGXJdwdPDopJPwiqGQI7fc0XIrTQHJ8hVQt743DgKHwjIXXGjv0x0ixVqGpxuehZ5pcIiTpDB1j4HPGUIjZLIYbqGIeZhBaK+aRU3igMkmNABvkl0pKOCIMGnsIaJXN5VEQXIYkJSMF3RBg2m/OB6y43nC+4WT2eqUIMycX7gkQiCttxSv59brpNQgZhTsVQePjUilBog5V5z7Qn9Y98JZMxxFoVOcUqldSo+ORBbyFxUtxfXVouZZwxwzha9MDSPEAUm+HWSZR2BQ1c/q3uI6u7q4sN769//7neRm5DWNpvtTUPXD7//PT9VKOlMTZb19Vqp35jteEa6Plv20rVNHcyXl9bXvX4dG7r6gx//yLE/Nu6wxRvgrZ365UXTAesfiyvL3hk8e/a5M0HvPb7/7s1mfVA2ak/Loa9/vd7Y2t3xmL+6usIWmxps8fct13JngXX8aV7/5dcvRl68ml+Yff/p0/sP3/cB8PzCjMiyGuOYCF8mOz6EQ7a2djyZW9jhSg/QjvRxUpB48Lvzxqdvf/QR19t76q3yyvJad37m7ZvXOtvl5VWuozZZkvNutBdnSHgk4ZPt3X3bRnX6Zrtabz00+L37yQmPUK/evvPA4f2g7ruOluMpW5FqX4qqq6lSjYSVWqOrs8RH/EL9s6+eHx/sewtgpUtMqRcBPmYbkOnzeb14EwLpYfnEjk6xKWTUo5xS0ajiGpqKrDk7QeKkQqKlCqH2kpkz8RSzib3EFaBUOrXYCx9Fg/gUCYC84QoNMv5SBWqb/qsU6iGBECZ0CHlaCjicICNXBOIaoSAD0ZjI17pHk0J9fVQ6OuMQKEG2YdjzCksp04iQ5MkoMbUV23cY5WoVXbY3W4iT3CJM04g5Ja41NMpIJTdIuUecBCmKNvzKYxczxicNvLpXxvNiHbKnNNy1X4huJZMwz3bK5dGGf8ErlSsJkgOR95bP3Mk8r39Wq13UVgGKglN7f9uKHntBOOW2kmrPrMWH4tAmxdSIJiDxF7j5qTxCwe1x2FoNINEwow9kt2IITorcykQ3QAgEuQWUl+iAHAnMeAZa07wqoOaklWp4Y1/7k6dAm6jWl24+s6q3qZqfXoaGIacnJdluAiKqIotc0uVjNRxy9e9I0FdbbQ+tnBOTAYMZxQiQkagahgglyuCcInC0NIaD3LXpXyOloqCF3JW48IGpiCaOKsKHwxjeLKq1Zr5q/qmZGnwMTeJKwyGyTKBq8LM5z2/qooVpgQWCqbr5UJ0T39qb53ePApZQbB+0BWTKCTJd0xwnkVUIodLWqGT3T/oa3se2IBUPXi/WC2Qt3TcGtuePdi1Bq2JfoZujXX74/nt/8sd/+Oj+nYO2D9KEY2dv15e2lv11hu8OtrUoTJzdpvu2jO1nW4qn6j3r4WyxfnJk4upo3wLckh9GPtj3nbIh4vjsemJqcvnO6uL1kLGKCc9ffP1282z93kbv4Ojt9tYDP/9gz9LVsB8129zerU/A6lRRr236dvQvzK9a0FpYmK7dmhbKpyaWV+vB0ZPb5tZbQ8XViAX0y0fvPR7qTNx/cPfli7d+NN6PwtsTbHbP/47fsZHdzwyIXFHES65qxPKXWYUq2z+yTlOvDrxasLECc680ekfHyG2x5D2D2NHhgSBxAq+nrDnvJzwJjIlwi0mT/etz44f+hw0vX732dZnYYqapvQDqn5z6GRijLLZYSW12fl6PL8OTWoYvkK3FXfROH92/97tnX9bnrnb61WS3egdU4spM1y/MqMrTSwsyeLd+Q9fSlhxUvSJXE0FXkeaWXciEmRgzGlEe0NVCAXrsa58Zgvrgw8JhDQtoRaOXUtDqixud2lltxNB8aMhSPOEoxTa3OOijXeEoReIKQoeoAVnShJsV1f9CQA4TFSCtXMFVihVFfBBCkEFoCPXyzKJSuCGBL7YdLyWPla5AKNaXQa05I4mgWkFrna9xEPMoYKZVLcuve7ZnDpjYlkrNF7hJIGW/nAIp7GRyvhKpEdyQXap6mvGFnMUmCIB6Lnzky49XNvaU5Z4t3UrFpRkAGKUZFr/gU3zbdNUjvzamI+Juj2CWILkJPrOtOZXI1lkHH8MUMZICYQgBK0YpLcFtZT9tABPzF74oJ7ZAQU7teJ+bkDDNLQQiUlVeN1AGH5yxjc7RKrZgkiKZaAIZmtIkbCW0SvUpkGEqonMQEnOooFHAw77OyKhQU9DWfVcQtDV6bIPjKkUKQnwQgsBkkQwIiyRSILAoTKjBHHBrkjSBCSForm6DHBfJU1VeBlrw5aHFagrghrM2YNBiNDjNYUrBlAEsVjUvG6/vfloF8SGOHAI/CschSk39qnk0A4WkXsOU2fIPR9VmfA2yvWm30FPHAeMi0ESmvt12ydbsrcMYSDD0TY4hxQ8tdbuzxk0f2k93LRaP/P6Pv/ujH/3o/PS4f3q4vrYw0Rnd3ntXfhgfs4l+eXVlYsznTladR21qtKzv4AfRXT/fWhNovwMz0muTtf3tnWoONgNfXo1NdfQz81OTB4cHzsy4dEaC/tXLcLOzerU72u+e+KX2ly9fry6vLy4s+0343/7md9tbew79Vw+ecpyG9+wrPyQwOr93jK3K8okZD5venvaPjJH2/+/u79QP0bcXxd463HvvW35rxSPQm7dvcT6/6o9MjjhUUuR4RbmxvmFgwMftX/zrf2W64HcFHj5+ZEbvzImdre2XL18ocsTQ5pu3PmC21nawt2PsAZSvqrS0NDlhY48aUQu4eWSx+HPUO3Us0vLq+mHPoXzXdsWa+xsD1LAarOGlpQSeq6PWLAIJS5v7bKjd2tzunRz4SsBp0+25vloc/1fctDC2fClbM9x+hTeW6e5LsdtlEJGAhH9g5sMxMgE1NDjy4IlbHLi4vNzCuAm5meRVjLRuFI6UViBDkFhKQ0i7llcp2IJDQzUgBC9tW+yhJYjCAz3dAkaorhmtioDgiQcHDAH1dfgjMUNdnL85iAJDH3Ez0AkfmhgEWol2mXzkFeUxx0SlGO4ZQxAERRLNE0g4uW0qGxFvHm5KSZSSHC6Ko3rybqM0oNToq7OmpeoIjqvaAVHKMFfcbt7r5AV3w4QUVq5w4EPTEZErWQ1r/X6ttIgdOJQmnbWGAZhlsF+I8qDYajeOqwMwPC+3VTM84WCFkKmuqAjlWSRwOEKvykcZwBWlCoPpSigSZmKiVAYJ2rYz/mZ7PikhxxA5fJAgw5Qxumi2aN1iCCLFZBCJDvjTChytDG0TDVEVWxOx2IJPaN1KUVUmfsaBMt/UlvcUQXMFr+Cx0nVS284URQoIQdiqBxySJwgrtzJopfjTFS1URRgm32hr5ABxJU4dOf0UB1JgkssEi9ce3eorEKvxtcSr/298hoe8M4TQtrjVm9WL8wNViZY46mHrJlGuf9fXW8Qy/zRi1dHyvSPdk62g+vex9o2YdkSx6rrrEFneppJGVU9h6kKHbYtFZUaGV1ZXvTveO9j+R//oH33y8bftJnz4YGPtzmr/pPdme9PiycO7d+4/fKS9WXjE03zz+Giv1vQdV+BxotSvxu+TWoYfvdtp88tSTFfrdfH55qa9Pd25WYZqSW3pe/g3f/eZPremuNeXk8Pjc7NLVwun/8P/8K91+nc37t+9o9d9rFvnw5ev3nHS4tK67eHWkvRorWu79vbUc4ytUGt3NizI+djq/OJ8Z/egNOl0e8/fcqY3MV4JfDD9LT8YYBjw8bCRdWP9jt6EV9sK/5VfiLQu9G/+p796/PSJt9+z83N22L3bfKO6p50UvX+gl682Nj7q7Ae1Xp8KWGdrx9GIOvVeZ/Z4lDq/tBz0dmt7ZnZugi/mZm0tmpicmrET1watyXp3ZS3Oa53h9s4mkWMxjfcoY+eYGY5joq1K2a9lauQVoHMeKiJb70wWOlvfzRwmJ6Y84oNUBHJ6S/J0lg2JmhKE3ocLHkBuwSc4ikBc6SDBl88tnqiUpkgGTw7PDvhqOO2DGyRSBgN1ZAqCMxHBx4pRYk/g2dXZws8kXb1U/8MayDD1/xRp08I6aM/RwrWV0k/m3R6kCI0UUWeqcXp9WjOgajJmNdXNFgOLae1Puyh2HgXaZiHKy+MsQz1tiF2S1hS0VlqbXDTPuBe82XQzP4NZy1vwpG/S6EncDiAyIdP3tY47yz7FxYwgnQucOJdClOAmPKc6s3BCnis9+JqDiA4Ozk1+jUBqJUygpU+ECV/fzfssCQkcVK4xFRU4QTLiTwaVvB5Z5ckjtDb6xRdfYKKaqYd5OBPklm6u8mhdo5uYBJdnNWQS3dYg3BSGFjXcwona4gZcAsSKXfIDDlQCjzhwGa7DnDK0ihUQJCYjZ5QMzuRSIP21TAxXJGhM00CQY0gckthCaDFxOk5LuEkDfYQc6QgJRUsH5NiCQJeHjE+u4FJo8YQQE2RI98jy05/+9F/8i3/BM5KuELJjAJTiQB/IGLotcZPVnt1K0MIKFW1BIp1KCImrL/ipMDzUOzqc6vp5rDO/o3Ju76llNFN7nwcI/VqSHrPzByun8J/1T6bGp3X8qoRvnWnjTYpK8Kruzbu3usX/5B//E7Otrf3Df/inf+qr0u23bwTdxuL6g6dP1jfuDftA1/EGWrPXMwwl2+eLTqAamXBq79mpDYhLQ52pk63NvRNn0+/P1d5NPdjl0rANeefdWT+QcDY9P1vPHddXr1+9mp2e9auB50deODnseKq/tW214T/+6Z/ubutFD3Wmj54+dWWCAenzr7+0tVRv5/cj1chk38t8J7/73co6iL837SveioS9vUPVZ1D74vOvbLRUMT735dWV1TUve63O+x15R7YJxfRZhk7OVHGPHj+2I9Ms/quvvvLExuFqh+t8P2FYtenV69Njr0ccHD3r9fCMhxjrb0ZpHqMAQtIdYYTQC4aDwyNexed691DfodZUos9I1bduTlBxQSoUnHr6oKnujKdwnazK+vjjj37+8190u0upa5iUFG8wZXhHZdmwi60WzRuqGtwSKUMwbFQuNxM1aAgVuQon+CDwo0Ay4o3mEcdwaPLwCaUPhUH0TSylJKG4IZQEEnyjKQ7Q4EvguCHPlbdJDEOaIwcPGipwmkD27GVoVwriCsgWvZOuyUcnIOaIlCda34UcT5koiYRuSMq01kDkS4Q6UpVX9d7Umxybo+fmulhFOsW0UCTUaNY4ebs66qg0/OF766BkuKe3PALFeg/0/BIvkARocmk2was6B6UGhWLUPut3ywxoPMUAGV/GA3qjQ7Zb1Y8bEXSN5ZmSczo0OOANrQ65BMGZx3kHXKJhNKGeXg8mBEn1pQ5AoOFDAXCGEKeIrNQuVhGkKBrCZ7VbGZD28U71VlLio7Gqx2drgmICmg3CTICAFbYgrvISoUT4eUp26RZRUQkEf6XymopbfkAOGa2kRommBghWECQk1HaVFEEDlMGEExThz0toreryjHZuizpyCEiwork8QnMNGUkpOCZSw6ntTIbDYPKbKM9yAUw4zaabKMeHUKJprpYVkchAfA4Pjr/97W/bf+IXNigJDhmOV/cQ8EEIEv3h+947+oDoJtiOJ84wGaJ1wYEPoohKBlbn2yi1DO1DQF2VJ2dWH+t+jo64Gi6XImkhNOypwAoknlozDnRo+wivtTph8+d//ud+NNFkQpOQ6OnwL5NY7vdAYSuOidf84jIDTbHqn9cFDoPrTPgZFjtizJSNQ3ubm+ZznG7FfX5mund44PXA7MLc3s4mD88uzg3PdO3od6qzdaf5hY2DzZ252amh6Y7FdduDjnZ22bi/f+yX361+OxOfxON+j9CJ7pTjl22XZBFveLjVn5oV0pxjHz9+7CQortjYWCfI/NLC0kxnzHltJXd29ui4J0pNdIwlNgjxieHf+b6CFdzHwPjY+eORIh7DU9pYX69tvCN+e2DCwZ+bb17fu3vnk0++7RtgaNOz07ypynA42KvHjjpZzvx+smNK6gnAjtFPf/fll199tau11qylIplojVcTrLC5XZysGOtW7+l1H8+rHV8T7ewdm0FaRUokiD07t/jHcxVLJX5YX9ugp8cXVPb7a4xsBDe0k5UW4R2D/U7VA/pt+vZ9CVqyVGE5tnULFQxtRgUi4wpHHEoyhLq2XUw1wODMam2ELdiqCB6WPCdBI1Ssso44GfiQ8URFCgiFQcLTlSxXT3gSZDzRShTzEkK4iiyEnAZBKc+b7HsSgIwthiQixweVWz+vBmJyoNTXJ+DmRGj1XK5YQfO5Kq+SQDKIa/Q8dbxVe8onpRamEShjVTzChqRyx21KESt0DvJMY14GAMET2uDQnn4lcsrhq9o/66ou9ZthixAmVeDAVITElSWK4gW3PELLJqVo6ekWHLeYIYOD9u/6zYS5BJnuJGKeDFopwxsERfiAoJWXoUDgXFaorYgHkVMDmgxu4ak0nKNhxCHXxpDjjFvjUYN2MIUsCBzXGJu6gSxhGyCGTItnYEZuMq78gJuIREs3POEjhxYcGYmqEp7y4PIyRMu4IvE/VbHiEHxkjCi4JeIRhmdY4QASQQkYtJQEl/FJkeaBCZ3VFHt1zRjGAwihQZYhXSkFJBCL7DKAErbQiEAIM3BfdllesC7huUFRLf3VwG9Vxt7987bxsxpwhgEcPEqZcFgE8rGYtklrCxQepPV5uuI/+emfDo11/9W/+XcO0ex0j1++/Gtb+L73/e8fHD+3CHFxZSuwfTrd0/7nlCSOm2r1aXxkaX7eYkUdejFuSerUt2l311bXlpeWZ7vbh3t+G93GVINEv3e4tLrUcyTPzoGP0nzhbcHneGe/jo26uj56+ap/fGB80ifxlb771ctn6xt35+b98LpJqwM4Pb0dLyx2N+6ve73hfe/e9p4zR+2ff/vutRe2DsIUGRxu3ZzHvJ/wftTPYU9PjS8vLPCYtmMIt7Ti0Pz5pWW9ieewJ+893d7esUjlEEhT7zt378+O1XSqfes0d/fuvMUfc7XLc48LdsqudGfnOMEMxzmja+sz/fO+0ZtvkVCbdG81yLJO5cRjEM9FlqC8YVb7h6LRwdSHBypX5Fj3L8yW1Cl1NBOyOAQhE3wTsDA77FnFw61GI3i4/cibhHrzV5vfWp2WC9SyTh8ToYWJ5wMQoaLIQE43e4XgCznARCbR8CHjSRZ9ZCRhpihhJq8IECR5a4W5BZHBASZ9jD1kgWBINInwAV0B3eIfnnTWiAIPEL7biPBGGn75ramKm9iIgdRGWJCstxsIW48EwjTkfnepFtbaywY4mFfbvp07GgwkyFLkYqhSXKkk4yqvlJ7yQa5JsfuoGKaxWbFMEnZuXeOUdq0BreYNsNprdC7AP5gQsNL7MxXndASiM3ml2OqWDZnmrRqbpw3muEXu8dYwa0ZpPI8BgPzFTFpgqxMWHCY3NVeIp1pvRRa2zBuo2pCry5aR8JFkIADmCoLQFS2nyCuKj+gJ7lYRzeGHCa1CEqfJgwdBHm8DGR7sqvlid1oHm48hMhZiLtXUxGyz/dYmQZijjaOwinrkgkfnwTU4qhMVNDoLDr5FDVmiDMLgY5UzlKK50gFP0y/hy5ZYJ4MEc7eQo5JMGLrSmSwME6NoNUUIfp1H+JqYT5sLezib9bb2VN/pR0rchrAZW17Cz9o8QbXt28SvvnKqkU/KQioRnjNt4ucd1vkR7fGRa2eN6IhNPBwT1pmY0bN7CBAk5QE7Tqqv9wMENcouLa2jtK1wefmBH1Ezl9SL1bTLm8zO1M7e5e5Bb3HlPQsRlqk3Hq04GNlhBmOduXt3l7GgBtqD46Plda9VLelopTXEHp3193v2nA/PzI77NRG/Nbf7+Zuf/e3vFrqd+xtr05Pj8zOTz798Y+I+9WZnZm7m8ZOHH3/3Yx3S/va2APDxl2+7FzwsdMffvn5+2jvSA2rN9k+a/I3NT9tEeXpeP/FYuyhHLVtdHh0f+ubgW+898mcb6N/98tdU8xMuZo/Wm87673TEuletQJu+PD4/OD4RBvr98curvbfvpg8OT7wPdPLznXW/NqOLnJuf93u/NqR6gvftmHP8TeRtq+Jwe6vsyxRCNbWrX9+1XuWxtD6v8xNvFia5RcvH38/OaInOHjANRzvmE7Be1YVnke5U21lQ/ZfHmMmx0VY74/XoL4ZUvBZBH5l+LfjXr65bpquOdbpLeUO7SDCvrlDxGyI+4vBhRImtOaKpsCVve7HsNFXpqka4YkVntwiNHG7xVFn07F3UO7YKD41XN1qxU7+sKVdflBg421vK2nnUdEuLbkr6Zd7aacNk5JpDuWV42HSeCDyZ4woCwfWbDVYRkrK3dTWubl2hUcM1CG3/USFScNS7LQciWWdsc3btJfi2SdqvDCgAzXX0B6ywJVypJ2Ik5CotG/1rfZdbW3vkzeCgQeAWi5DaaWYzYR712sbJqhS+raEJMWzEil1BZDCUGaQbeSqk7asF5wKuBJd31dlxfQTo4VVkGAogDo03Bw4ijv7gg44MMiYVam3vvwHAXAY3CIxpI2QxxyHcCOVWiXkIpYiTacrf9JtuU1UysUVGghz8XPERVQhFpHww3cpQFYem8A0VfRSBUAar6ByhbqMeV4DzvqA0W3E7sB3P0uBWHwooAsRBnnSco4DbZIIPAWZYkUJVOkcH1yCHVfKhogaeIAG6xRMax/KqWykNya2i+OGbTg4ObjLg0TwZPPmfSmbopOhNpPjHrdR0uBl05eGHHKtBhr1Cr2KxvWspPdWVPsU+EOvll31bbtovx7RtALVxQDjVxzNEORd4Yry7tnHfz5QT5130hJ+VrN5eNHYcFGEAMKX1s4ueXReWV0wuLYGYhXoF6qdTTn0mfeKXrC56fWvudBj3kerE2Lxf5/b+DdWMl6L1tXbVuIHHWRGXF0ed7qJO/PDk5c7J1XRv9NpiaW944c6TZd8InDtQc29zt39weL2wOjd/Z97e1/nVi50vv3i1uWVNVF+1ODPl+d2LTvta6+OAudmVtVXPFt43He3uTE5M+4xgaXl+Z2vHZvz++aWvt370ez9w7o4TgQx1Pgnmc13D9vb+4uLs5IR+cOykzjAYfvtmUzfw4MEDtaMrhGZRSATOzS9YuHDSnI9+eYCrYb7/4YfPfvdMXtcwt7gEXw+i6613vNbvDv2mW21HtP4mVC1PqDK9lmauQ7PLSAfAb3bpeCXjAA49tP4VmijyKYbdVo6JsDQhHkQtB7a5zs3x4GLMAGYi3VqCBUPTF92r/tmkseYEYuPypD5m9Da9Pd5ZUNoTYiK3Xi23xQCCHE1EH72zq+FKGDNZbONftO1h19cgaRSJt8SkOE8AM0peyMFJTKpoCUNMFIUJtrSCALPC+raL4DRwmK6oCK3obVRugxYR+EslqHXaSJSawWrFaI0u2pCKiBSY0dZV7++2mlX/LNN/DKF5GQ9uYJOglfJYt/MOcJaJJvjTijIgfA6IlV9qpQAIePVi0VVZnBKb8RwowaQkOJZWi117tahSkbfuvQYTDY9KmjnkNgbwbC04xDuYU4VyzZOKqstLMhvCGUChZ0nu9qwKX41CEPQeHAcKQCSFUJn2GrD4x8tIAF3dSsWyVUZuw0Fp07muCGMjBBmyUmcwQx6gW8hKA3eFJuEPTc0pYlrySDg91QkTjgQh4uRlICuSwNWHTBjiIOM2HCDLB4itW1ecQ86Q5LkLH+EEGXNXaMkgyRQGQkTHRW7thzSFVyqIRYPeVpEQyUwBkyRUIXQ7ME3e4zzppEh2NYhqOms2OHMGnW32aJGgOqqmWhdenGpeUWuRNTaQ6EwwvwrAIjoo9URpwUfeyGtbi8+F+sdDjlcDgdzY9j046Tr3D4/W79+fmV0cGR5fWbszM+d4gyt7UkS78/JoYoF5wQ+o3bnrU4O9/UPfJ1lL8Y737oNlmb19X0jVzrLO1KzDz7add1/edtLAtbms891sTKrHkJ7d+vWDMEvLS2be1knsNtHXTE5P3Xs67ydxHQTx7OtnTiD6+IMPLPRPjI70ryafvz159d///73y+d73vmPT/ura0sHF2Nu9vgFgfclXE5Pn107JPRmdmB6dOH7zbvO4f+ahoT56qi7w0nMDe50u54QHH0AYybjFRlJvQayW6NBNkk2P/Pa6T4ntc/XbjdZ/ndRsqcf68/2799SFerFq//rtG3578vQ91eozMbSeSXtnveWVRat2Dhd1tIOwXltaNur2To4t73e60zr0Fy9feUN+Z31V/+sYu+7drozFdw4Qy353gZOFAT3x9LmDcYX1I0N1AIZHqJ2T2hzqkCZVLgA0YYOyQ0rh1x6u+nXJnicUtPrxeplhAY1nPQHVSTNVE8TRnBWmAvoYYeNNuMNnrPtr7t8MTsZqNb5YFkXE4ewkarR6JFez5wq71r+7FUIC1K3wkxLVEIKjSA2ENuQp0lFoJvDdqlZMtB354mAia88rDQ2MTTFqeHxhaZseF0JtVLjtPUz3Sdf946nte4iywJk8Q2qLfj2I3XREmHgtf9vAfSxV7/nKJ60xRrdSo2ZM1dUo8v6BAhiS6Mv0OEczh6DBxgNhIg+/ekD/MQmGlJ6IZoCKQFwHiQyYragwNZimRBFi50pqQ6ieSEaiDcGQE5QgQZYBJAjz0MYAeb5GzvgggOie1GvUAIy/wCWh4xYwpdjKIC+dmlPcfjNDmUDQBh4SeUwIBZeR0jULxgqL1okHX15ptA1VJAZCGRUWEUyuOLiNOSEFji1MQLT0pE+CQ14awOGEiUzybsnlh1KuqeqKG3JFEoYhzxVVFMY2ItwmAxkh0foIDJkMQm0k6gsazgwJeYlvygCCsMgtKuRuxRYSRThkOAE0o4HA3maTgbZK5dGqmAQoEnwgS0LXCr8MDqgas3osECM6X0PbQAH9wejQhXcCi8udT77zg/WN+5s7B/yytLzuWAozz7XV9a61llqhqr0TVvZ7F5eH1ip0Xm3Ro3e6Y4lD/+L1phfQz1+9pJUTDXzqZI3+2JLI2rqf19OYzLS05L3dneOTTs1k2obITmfurG8jTK1GOLnqYmzqcmzm8Ozkr/79bwxX+nUvNpYWFm3kPOn94v/3b389VweITsxMjz+650yhmeOr86FjA9iS50O/1fj0g+9+/rtP9cKrqxsTfup9dpFpFuM5x6Bnj4WVUd1K3vA/fHh/c3vfc4A9l84o0nua/B4e7dWxELOzQ6d10J72+uyrr+ZmZnhbDdqR5c2BkxvSRtQ+T2JuscibG8+mHGXY8KjEIeD27lpUwsRAZxbmVM4/+P0f2xyhSRow/M6XZGr45PFjL/MPj488V7VgE88Hvjo+G71YW10W9kenuvVhX5EJKvtKVaKvpPEXBr7SclCE3gkhfdr1yv4qTwxqy9zU/NbjkCkFnWmrq/X8p4rkcRY83hx4jY8nRGHMhIrqizo+ATeGk0KWlGgXV4BuXQdCW9TdDAzwJciFMFpCSRmwSlgqEvDkmvqEWyJf26JnkMNBaZi7JoFITaP6WAUaEYpCJUhBOBaEGjCV5spqK1ZueZn0DADwYYZD+H/zykUSXBwsrLriTEOO4h9UiuwCYqA8lRSVQmFBoSay3qKU1DbiNUbVq+bW+l09+GXwq05H7ViVN9BSdcyDcy27lW0Y19tnM8FwIAx/qfWl1WeR5Zf2fAMczhBkuJjG0KJ0Y3XzdlQpsMptbG5UgkB/9tAZQsxxizm5FEhSBNNVImiQvy0vj6OVeCqsonb4hJUrQlccXCW3qQ8QanA9DqSDBwc35oQhYOySkYimjAFLBivk0CCQKKUUggyGpXdLyQcTclVn65S96QmCW5nwb7Q3IwTF4A90s4oggskFhw9OVYnaSTgoxSGs4MizJRC0MhJNWO3RAR+L4F7EkgJCBbO9pm3tnNMRWB6Z6yyI/ZjARs+EOFTctOdoD4JT9n23oZG4epLQeXipU1uircUNW8h2uri5qgOKp6bnp2zKHplYXFlbXF5fXbuj8lVt/7K/7YiGsxPvgSXry3qKueVZH7Ea7Syj20yytLwo1l68+NyXAXc3lnRkDn7wWvn04NDoctnfoZXOcW5hyXR4YW7sqn7W1HZMeo6fHBv59GzVLM1ll6fWfTtwuLdrnOgdH3r9vb9n0f6tnfmiY+fLzaF3J36PysT/5bu9eyuzD9Y9nox3Rq9tFajj+Pv7nYnlxflhXzcbsRw/OjZVH0tb+rK/hCvUxZAT4oaG6GPSbbLvdwjO6vTQ+cePH3nf6ysLFVUDQG0dryBSieLM5832Sm1tb5ux8r9dhtSemOpYI+ZtP0nmycapUdiura877cHOHM2Px7zrtlfHl0fq6+Do5F/+y3/5gx9+b215uT4rW1v3gL6/s+stAvNbLVPVLNtv0PssbKLO/zmvn45xZwVK5DDBDJfj9g9PxKoOTe2b6Dvr2ZIFDrpvFa5oqo441TV6SLP0NGHJiwiqVg/bVmOsAh2f3qzQikwpUxYiRItb+OqaUF5IfJZ0P6reehw40YdL5cvS2+cAtzArXDw3eK10O8Vp5NUSJVskuNGAqxtlARuhcXVo8cSNXFd5aiORlwiNXNwkIsxYUaUIE/uOMOR/O3Ghg1el3x5+jI88fFePEpkx4UNY4BCUFkKzglQ8FcGpSGg7R+XxTOuW96TpVlJanQK9cUkCkkBYkXyuBECQhy/P23BKpUw/m5nmK8wzKXAlrFlYQ64nOM08tK7gEm5Vu72bRW23ZYM3OXPTjgTwYCgy3NKSJ5WmVqggH3L4mIuV0EKQN/cUFhJCusHEBGaQ4Tv7Nw5qEEbdTBmayTUnFZSuIgktDZv+f/8whG2EqrN4MGhEg5BLHFZw0lcqhYZn9BkoE92EvsM9FVFJopJ86drmI5gkw58yikAoJp+2J0NuSjF0G3ujgxAph7aRBmGCkpJRDzd1lBctmUNRGBrbIxerKIkDzvJoYbLRLTXUUTyvKLpZJdfdwLfibEgQdXr7VkvlATuMZqbn2iOxILB3WEjBtezjXe2IkwKMmzbb4GahiF1KMfE7g96OEmcM0OoWllZm5uas+Xitaz/z7Pzy/MKKj5sPDi2A7NpN7xna9+Rqg5LwZ3zu1E7LGBs+fvPqhT708eOHal3rd+aN/fZ31pdnpsZsfHQMwFfTE1Zas5bqeAYnU3j3eFXHHw4dGx7qEGM7j5wJeu3b3PmFOxxyYL+TPe8zS6vd+a3Nt/Mr9xaOj14+f84Kh6aUDyemnU7ZH+n++qutv/31F/fuLK1alJ8aW1+cv7+28mpr75OPnt6dWX727LcLfl/mycL5/g5az8yeLzjHMsLQae/t21dWjuy7sU3p6dNHz5+/2NvddAKo40vNltWjH2apnTxWUepFxaTve9XI85cvvILWCOzrf3j/kZ7r7eY7H2R/8MEHv/nNbwyZft9M1KkLZEo9fFjgHfEbwvZiGAtHR23/3x0e+cUvf/OjH3z/7t17Xvk6RW52xvuW6si8MknAeHPvOONZdXRxuds/Xlla9qrf0pa+YGF8QYdg2rzoCFKfO7QHYhlvMoxwYtKcXl0b16e7M4fHJ3sHRxe+gBu3+jVtri2Ara+j8kRlxDKWrNy52zvpe0coDm36MvJ5OtHqva9W4xhS2/6pwD3PTE3N8qeaEmoyycNkYxpLqBLJuWoI0EQsxXBjqTzO/AwuwkECROvgBswHixaZVIGkucEnNw0Ksnx6NhbRHxMiLIrRhGgp/SqgfGhzhUAH+HEgBGeI4yaFraveEJUNb97cwKeJwVwLQgVOB3ZFK9/MeWlnL693PcNPHs4XcZ6ALmsohsrUdJsYNcoaVzGS1/BK/MVFVsH0CHFNG7ts0LTAUqoXYhsVjfkmJoRJsSra4FDGjNZTv2kLv0AgRQwi95whr2ME1CFwqAwl8XQ1voScSdSggEaeSkKVB1sREEEiGz+yGFVDUX0XWqsu+CB3WLy84R0fmCQ033XhU8kVEwn/SFTT0RN5ipAjIReyVO9E2jMaKXCUQkNCuipnLBwQ+IqY46oEUB4QKxDiQuhWUsRGmWZCvdlnnQVZ8YKhWYmejvLQiCYLORF6NOsISpuHK6C1E2xB2IubfJShGKrUIx3QgmPl2T86kwUSK8BhtlqowNIVRmjZUtto2/xFN9wamBAseLOIknXe2FGPPgytR5ah+mhcF8dXfgSFervbuwhteaSOX6NlyfzKnY6fx63F62ltb+P+A+ckL62s2q9Sq+mdHAff1Tt4T2YvtUOo/FICDQm19Ep/mrPd9N+LJV1NfRmha2+/qAdHx+5XUBzMIMYs4lLSU4LZbn3cZf/owT5n+kKHjcjR2S9qPPBRrt5wZKzjLGwvkbmU2r6ouvJ94dHhqe36u7t+v9fc3y+20N9OG2po5ceHJ0tzXh6cWLdfnZl8tDb7/oOlh2sO8TkdH/IjCkO+vzI1f7u5ubSyPDXdebe9xe223HCRIyF86HvRP//sN19UT987W7NPc35JR8mH7zZfm0UuLS+ogt9++qkJlUclb3oW5v5Xsv6EOfIkOxA7cQcigAgE7jORR2VlXd3Nvk+KPT090nA52pmd2dm1WZntB1wzmWmWK7Ox1Y40lMihRDbZJPuqrsysPIHEHUAEIoDAvb/nDwmWSV7If3m4P3/v+fPnz2/3aQbX+aOVxaXdg91Wr+UyIvNCJlsW5+Z/98VTAw76a9OdTX0GYZy82IWCrmKqjo64McIJuJmZqfvrax6jsTbBlIHx5ClgInT/Pitn1Xl378DRABecO6Nh8Xf/oKWYbLE1uR/3RdzEPfsyYkkvlhOKUYZHlTFVRfFiXcpNT8fHZEUZlJoZF9lBxR4eBdE6ajuVU5uwseJYcZS9+LFcn8pJ06hlVLSz22lSvJFJYzLmykQhSpGgVYM0UTyI4kdOkQAAj41nDAjLIFA1EY5PTFpaZ0wdsMgo4YDhl7xk4Zq5wCGEiS3UqTCDKwnBIMdPIYGJlZafvskgZ3uSwCLz2DguBCHIaRs89Fkpu00DUaSlLYmcmY9UzscINAEoHPNSgU/kiEqOruP3soNJ8lEBy3nsGb3hwftr9YTAIrOboizJbi14IX+bSYi0577ymUzwZP4dQaRD7GOGJNNKBBib6ydn6RjfAIKh0m7rPeE1jjLEeYrcYBvz5l4agLaM0rRA0Q0HljkPPsuGUSFZBgSKYbFEBrkc8itjfjB+8oAsMOd6TJqSzIJGLnJ0FRIHA3NcPRY2NEY/jBVJYZvUbKSTETxTIFRMI1BQ8MBKzqJt54EabzD4iWJkuQwzsaGBEZgmGCdC/CzfMMTYkApCSTBc8EQjCiYDASQ2pQuzLJO2EQEP5faVCmRhfsgjTfxIB55yw7YMUhQaIDk/eJCSgMFD4uTP4kNIcn45Baa3JcRPAJkkswYGV+VlJ1YemhENQAS6mu39MEhCBrdkMAYN3qyoVWrqpAv0W639eqO2sryo7YNcwjjde3PjFZTZ6QXzGUz21PxibM73zm1t8tGjx9Z4TcqzJqqN3eJGikoAk4qJOVANTHI4DGzfJtOv+FQqpDHGDzNmqMbqvTWlrJ7YrHLcafdPjk3daBgcOh0yw3Pa1wDYg45bnPdPelpBa8LO4a6uLb/b3Ka7+kCnF9fM2mh10p8TaZ5INCfjngjbey68Zn7h/atO57DlJUgn0yybulrTFm7P47ktaXZmMfqzRwdjN+eTQ6dztYH782Pr87UHq9MrS00z/nV74xuT/YNd80ATjUmdczZQqZsVsYQ4t7jyv/7Z//L8+YvHDx/3Tl2SOul1IOOnXk/fOVq7enPq9Zs3VmFVtc2tHYeKV5aXNQDEq2QqjaqhiapDN8zlssiSGLGxctSSkihxFzAQF9kypYzC4sKcA3FeIHAL3qeffTw/1zTRNzfNfMRVqcSrPxbqd23592S4Um11rLKfuPrfqWNqVy5zvWCytZSlM3dlzUOJGA4yapH88nJldUlJqWh+qmtiKRv8qasKOhXPNOJRt7t+/6HCDOrx5lpfAxC8FssrL/BoACTXesnOveV7QgBHvspxKsilUuAFJmwRoqRRsuxJm1HA8IjN2sojVh2BB0KKQXkk4fFTKl+xvlL5KQoGX04SjAkXmwAh9nIoWqyobBtoJrPhJw8MACSEEwM2keOWhvvaASo2GYYNjJl3HpqPSb1pCYkUOTAkJrlv1EENT5kSBWZUh6jJQziRiH4liMw/Dvx8/41+azKUgX5CXY6rRE9PBoRgwheuFERKWVQmyfxDEnU1dilFwwUeCeIDZp5RCIOPV3mXPBMmTLQdRSgywImCEDJ8A+DxRRd1+QQgBAzTTwrC+TOkpM5ihs5gKiygvJiUAKCxIUQ4+aXyRTQ9/KIAY4wHw8AokBAAHAZSDvx4QxGtTH73hSSzk/ixCptUAOAkjDsAYMkGAH6ofKHlMuTup4ShxPJQNFXVlRBmAMmzLyehuwwEarckwR4YdIX7wh+oi0iTGQAYE86TuRaLkJojuTzCSdqI+glViECzHmfLQ2IcPCTMYxwY+oEdpS2YeGLcdu4RrDPXJA9eL60u2Z4OFeZvhkZNLmsrXIU4N7fANOjn6e9r6B59+MRTgrv7B7iyPmTRc2Z2XvlGI+1a57MLt/B7gOWwdWCve7vTKtwycdrJYYuWfurssOCy4zSB1VSvNlaqNeJibojeGpbbyPYOd9mp+/cfrK0/sFypkxPiHRtzRldeRmJp9OLlm03thNknxwfMhJis6HR77d7+cdcWTH3Sw5AkrXPLiAspPNs1EEtis06tm1a/GT7xaK9R2Vk8beT36Hjdr8Pe1dHx0UGnu3V48u74auXwcqZZG9lsm6eampofAn7a9yiqJvB4f1ej6S0BDdTa+j3G9O3Oli4wZg1+HEU2qO/39CjHlhZXPEbgqlGPBiwODOso7FmfOPM2QM3bSuTSOjxUKjTKHle2gGDVvufPXylcXQTlO9WYxqTDyKj7qXFVtzSHDhe7zFnCmZmmxb5KrL6alY7yllu1mFPUitUtdVAdtDvbu/tRK24kmYHQjFmlUrMEbUlZ3cdPXPtzMehJHQU01WziFnu0AipDHhPjpKomKwV6Yp2BumCY9StVIHow5o6EqJX4Dw6ChzAUjFmBDLVnE8Jqj40aKQq0ZAkhj3nF0M2yjInK5cVlrTIp7a1aFoVPnKhTGBUha1BSDAyl4tP6oFtsDj9PgpUKUKphsXtghECFJX7Jo7qUOtXpx3Qc0qLA+JYsRCWV09Jyec856q+83LEnOQceRQ6kn9L6+qmkIIHfT3h4hFDsZCOpxFg+oSUg5/RDQUUCZclSkQPASK9IfBNMCCxQczoRBCQkf/KgDRKvUc2USckShNKKJcqwWQ4NxQp4rGSGdbiI2Q8wQej22lFcRWYUMEiektvAxu8LMkXvZ0oWGGzoEgcADjlOCA3xuqQQqVAXGP3csTiWIhX47IrqIWa+QEILDLwQjkePW+cUZGZEIADJAQvBjK9UvkK4xJBjT34AOEnzWjiMjj8HiShc8SchEhAIT7ogX9pOtBJerBCS5OHQKiAxCpFEctwiz48c5Go1GD9TOyUEjweO6HwlSRLA1HyEoAXMicq8JAwGAhX24ihgSCCZzK9KAYy2B6uW/EDKipft7NQpU8yqrKP0RNbreCq2fv/BY7fSQzQz67zngqkARp8LllzxFkzFpXL0GX5+GWGLS4HeHHuN1iNKY05jTRwdX5ybbYyNd9E+mdyg7oQgpxi+7J951kVaU+WK+Kjd8SwJM3PvvisWTrf39tyfMzRWNcNjq6KzY9t7B4QQts9W0+rkSftQu7J70HJfxH7rSEJ9VVMJ9cmG+YRgaSRuySdq44aeSRD/DvZ67T3bHG3ud57NfchO0MuB8UA8Y6Fq1IZtkOy4H+/ofKfbqr4+mJuykamx0bp6uL4426g2JsbhPD5wj9Hhhx993VFR0rz3waPTi8tBt3XdDOlBdY6O3x7sPnx0/97qqmr493//D47yosKurd6756Te86e/7520vYh8et675/YIb2x4SPbqysMGhMO+K0pGmWITeLSynajIc3NWyJe2NzfMkklC4Ufr1sCP3f+88fbd+n032S3b6Bl16fqMGkQfbmik28+7wq4aiqPTWZiL7bOU/82bd42paWpiGkfBuZjd4CMKrnTFePCTZpoHAE5K4zSKPWVJnRS9r/AYvcWN4rGhhVbr2goMDSlVGBiPWAbWENBYRAeZg1M4PVdAHH8obdmCEbpRbNqdGmcIcjwwi/WVQSKiUVQUFW0VPEhTErH0DTOJB7m0RRCK8k3+pQLvp5ze6mQxdAmWSDAmKiELcNhhUZwGyjdRAQMjIaIcf2xHfT+JJAmwhBHFJVFMErXihkcq8JHYb9EF7LYB8FP6IFnslygYoeOqtbBfnBDhAORZbjGtPJIqvJkcHkmiKSmLxu8J6RPGPcwExwHmYIANRUj81KvkiuiiV85BhdX0F+MThpWDQZbSbsLAgx8FIwq55JxfoJ8qsxBJmGt/SlQgWpiHpOQ3ikde8YBm4qdwIGUZDMySJ7cgJfENHKU8cIiQVFySFsXjK1WqiCRC4AfJQ1DJW6ISzhUeoj3n4cD4AuAylZ9o+cKcYgEsih8wtOmw4cpMosY5SI7mSYUTfh7AyTl4fnIoUDF2Rov/PaZoQuQ6m2FUpAJA2nYQagcUl0ySm8B49NHWMFe3DzpYFGpKk4wDyN7UMhy1+qRgz4xM1JsPP3wYdmFo+N4HH7W7vbmV9YcffGByJh4O81DW9c1ht72ztw9+eDa6q3jGWxR3rMpGlVMhdfCZGK9ibe9u2foSgxPFTbzsSLl4C1emeFhSuxudh7LPJPa0LC0aJ7B2KE1MTa25ZNlWFJernMRx1r3d/dW19RevXjJ8Dx/er4wPNUquY9FitOJ+BRTYStc1mI/y5KXBuNdRDE2IKARrYspNqPa/OznctXXEjXQj9vZ7avhmpCbcgytalivPzAzWBryFENc62Fl6dbDdbV9dbbVam7snawuNjz9YtQvm7euDpfkl76RdXJ5Y2ThvWwWZ1QBsbWwZDNMOkmnt7TujvLq2RuJvN94trq5pR2XcEvrDxx9YF9nf3ertnhwcHrpTKBbkCdM8p9sSKxVC29ltUYBsL1OXGOhjp+xcwDgRu8W8b6PJ1Lc+7jr5df78xWtF5AlDfXUDOpNgXccIbm5mZ5oBqYEZcAm2Rq7S7tk5dRa3cF/EPaDq0e7uHpOgwaYMnjOjWlSCTm5svcPw4uIKO+uCCp0EsxRsfS5I6KKE1g0Mdo/bhok2GxpgiXcymcCVbzmkGv0wE4BCYk99rGaNaAjxFs14edBbf5I5dF8QQOQ4eFUeuqTjIRAnqhIhCKG9WUGoXGhdMUQ86oKMJDD+g2bpZ2RCmgYGhoRHl2xFES9yfvqiAjkATvVMWvAIFJsVE2lVnMEQUvy3kx+o55kDqCSBQSp+DlcJCYMoCTl+JpVmokJd2SKqCwznt/YCkMQh0eLyp2TpUQY8MoASsGTOT7Do+ZkiCwkV+yvnyRBweSy5DLzIw6NcIVGc+NOt43R8JcGQWF+QSReJkpmYvZGEiyS3zXugEsKi6SNkKmCyRMq4IiOBPJlWQtiI12i0yChm1vTgiEN/R/dNLPPnrcCkgp+S0RCicIHqNuRaAhZBfqEVFdwXh2dyKA1JmRgpgpIKmHixpI8E0tiWnBOuJEqGIuNguMygn7AVhm/NtCjwGVsIRkGkhiEhp6LukosCI5DHFyrlwiMwCQnhvopNOGAh5AYhPgEnQpkSmwWUpDPqjqVyONypxisVjhJRTT+cVJSbqIXRTkSJ86izDr6a0LC5pnJ5dW/90Xe+9/0PH39SbTRcXmADg10+YxOTDhaBt6pjnsu8kalkP5UyQxHhjI1mbygu5uNxQSZ/o15TpScm4xiBW9jwz+N5E+WldpH22GhlIq5PiIIwyaPBAEJqioCc4zyaOfrKWOxh654q6w8eP/n86Rfuifvwo09gaHcOkdZQNcttjkP96Bvanzk75W6c2B3YbNSxYTqILhnzlKow3piZtyjaqexfDo20InzwMg7SO0U5bN6ePsawZvDKRlcPGw0MuRnDNGv91W6rMT62e9TfbXV39jqe+G5OjD58+Emv3Z9oLF5f9U9OelPTdWJYXlsdvrg53N9zEszeIquye7seC7PT6cHe4ZFNNS4JwV7NtZoV15NebG+/kwkrWBZSFN/p6SvFqhbIbzauBEUxDAbjG64/OlKP/aDt7qLLtBnK89hEMD83p1PxZmPbSGhuprlgzNKMYZn7utl0QNPNSWu/6ovd/ZMTMYP64N69fa/GDwxa2VE0h4dHzlJrjF2AWqmOM8A4URZI6Fn7sqHIY6zoT2zLCR2+ucYtjUjNtINDdrCqlPMheJum0FI0oWylogEADBWVoC2+btLIQGBCJPeTAx9qH8oVTipR6Ka2pwchP/UIKRFgopBQFGDJVRw/AfiKxYlw/vzyQCuPciqK/eFHQkJ+g0sJobrDIAq8QAAwBLYy2gYjO3IqKvHEcj9T8/7ornAOAwglS2K5RM4DcyKH9taKZahlnMy59AktfQG+tb/CExHUnKjMNmKKTayfAv1MDJBoIGKOLabacCnyVkaqH1pyLkDRFv+p5Cm195dMBBtMk7RUE2lgXDaJAlFREhkONZZYZ0gEAhNbiEZy/vIz/KwlYB7UpQUfAi1O8YkSyGmtlJ09BWkBbS50KB8AFacH+CxCCmaKozGK5PaKCGwLhDIJYQZCftUs/WLxQ7xxPLU4zPt/0sq0kice38L8LUJ+qMRGF6KoaQoNNlHwMyO+4Ym2wXSHGafbq6DuUMHAD0YStToRljvVIwtKJOtMFFBpigBjT5Sv8pVQiXAOzpAozUxUJStxfsmfPppJcYNs2IQ7zaL1HqtO2hJuiue7P/jRT/7wn6yu39fvNdFtTDxWtdhbs8fcSq9TWrCwlNZa2XE8MPdmGJK0UlZhLM86BbgwN++YvN3o7PrJcce72adx9byHprsXblwweLd5UHfsPKYO3J9j+cta4urqvfOLQ+MMwzz7Sieq5oiPkZhqzkCLnElqtsa78LZOEvLavfvspvLFnpklk+PmEu2z0o+w3qvUTo+PalU3IMy5Cx/+3imCl5oEw5DrSjznWx0at96lIOmEfquDDUMDFzf6AwZINzjteW7bSs6oRm58+nLU9qEDLHU6Z5XBi/nm+N7Rf/7syYOpyZH5uborbZ79+oul5fml+YWj3d0/+ulPXn353Fm3+ZlVKxOuel5ZW1dz7H6xSUnpmxBj6CYfPNDhefXitWki4xP6phMmj3JnN3Ct2pBrjopeXca2AiMr/G5ubZjw9IwO8+a6bJ3j7snLjc3tmZnpdsecfs+pB88GfPTRE18NwPbGWyQdY6YbCkQbPt2Ynm1OP33+4t7qkmssXr/ZcEX8g/X13f19ZwUsJyhWltSykFYZJw4e23cwNz2nAmlUQs+NMks/zIkNdZoOQK4ODg9Za7k99GQYKNyektRqiipf8nh+Ge1QOT7EhqoNt131GCOWWqlEig1gEPRKz12CTQj0J7WdBx6YKZIQwsn2KfVfuMyqI8hxYKQVkpXFF/OSZ1pRYCARItxPyfl5OAjvwHj8BAM4Pb6w6eL4mukpixySsqhhImJDHQfJDZWLhiRJZC7gCVQmYEs11KbChhOx6lFMAyUTMIATCiOI8iu4FJIM+YKM27Xet5xiASe8bANQHjxQgeESoVQJU6R623CJ0gAGZ3o+JSGiJKJ1BGwpDbvwY1RjLAQkl5KKSlNEhnlUlEpCRh+kvBuV4Sm1wkhYzMym5wM9l4FJtKgdzAwPTgBzyhJdUenEygvDwRCoBvgkPmnBkx3MkiRj/IDRTT3gzyhE0wFLThInKlFDSuuVtPyUBDCKCAHjJPFT4B0hHk4IhIk5YyGRRwyIdUlT8oaZ4bEYSZAMWhKpDNAmBh4AkrufyxcGtLTH0kqi26uOJQ94k2sUkzEA/FEE2jCNN4Uz+VNW3nypWoTblFBkfhOcRvc6HrhwNHFk7NGjJ9/+1nf/4A++Y+S/u9vRHV5cXNra2cNVbWJ4YnwCG/afYEAvx/U+tmkql9wKKdCYT1loAOTlqLV/1D7c3XpH8bQTFN/UgeQGdniGRMJ4nOvqxjQEHkwBrd5b1+i2Do8UgfkHd5SRsprP2tpfpEFQvJYBJiZrDn4ZdjiMb71hd3cfe87fMtWmuKgQfXJ5crM+YU+LrffuktNhYFZ08UOdTMGfqpZGJY3eBSUZ1sZahDSDcWKp6/zUFS/wjDMIdk47sHGldVCFhw6POrbxHHR6Y8PVs+uRFztHsxNj7iza2u8+ffnuyUMvKk59/OH6ZH3WiQSV1HrAWecwplbmZrY33xkPrd9b2/LYb6X2yaePd1r7tiPpdLt92ksJSwvLdmrFHtDBIVrtcB4hKFNFf31lPqeplJVa6+BIESv67HvxMHSv3244TOAcrxIhbQ8RO7ClBvz+6RdHhkfleSZ7RiWvOVWnHbbevr9v54e16xiI6JUM3DhQptK1DjpRiFP68vsYsCTTmJpUst68NDrS98cG9kSRJOrI0U/npKI0q8olhuNWlaMEe2b/pug2isqdA+mb1UHWnGgWhSuB4FUQHkUpkFb6wi8yKwL8djfxC+ekAg9MQqgwA62qZCMNj1kUZgEAZuCUik2AGVjWa5wkXTCwZQ0q1TC2rmUSWYM/5F+mrRDyEy3wAvkh9IWK44HKbDowCVHk+DV8wAD4ehRPjvglRz2/wM5OYopFCMzwcOoHQoMfPZ6HVJyI3K1f0MIY/VOISuxtmsA7ZhP37RS2PEgIixBZQowIoFYzhUCIRhR7lA3S0WkVDl4qYuLHc/y7KU2LRZvYtRkDi7LDT3UO+GwABEqV4sg+epK+Q4tPdGEgYkLxE7m7wubhFDc+XcmuzYDZjnJyVJwKVVoJk4qpIIolOXJC5EsWQEoVbebICB2VRO6EKH7kACRvUskgbGIFApYEBrGA8UzJBCaYr6oBg/AsKqhACkEXh0V0ITvMZ37xz0ESsaXXoC6J8hOYXEvioKoQjpC9LiUQ8iKAUH37tQHDcP/+fVVdOIRSZdaSN2AqKr82QG9MpxKVzBG04MkqZMjklaOnzu67AoEGWD1x+aW7kSFE16l9yjUzOxcd5+HR+ZV7P/wnP//JH/3MPgyvCrLptqeaINb10612OUFzthknm0xWjlpzqxLy7LTdI568dUn+GalCa7ePr4VWLB0e7Jm4dDMzWhhxCYRJFWadGGUHq3LKQOB8b//A5s7JyYYN6Ye2k4+NMzHziwsuxiFIBhHO8g6XydIQ5YP7j5x4UUCxgboxvVFujLCz6LjVmmk2Li/Oe959DMWIqVUy1KjYTeRI2/TckrG66ZergZG21mhgFP/jE3bHWwUY8uww9bCKYDus/aY1s04Oylyfh5E7PdZsDNcmYj5dN+3yqu4yOgbt6txzurONysTI1XX/qFG5+vjx6gfrC/eW5pqrs9eH2+bWTwxf9vf6vZP5eS/uGgb0t3YP5NT6ykhl7JOPPrQt5/ef/5YgFRmG377ZsA/XCICgtDcKWq/cTm5CMEKyz5VwrBOwLP1LHZ0re3NPHMM9OXPyQCoVh9XZ29ux2K3ZO2rvK6yf//xnrjczEmImb6eYLMBcXLmLyZ12doq1j3v1xszzly9PeufWZh1k0yK6pWO/1TL20ka6gg5mozSlyToptXxciHgVBK3TdBnPxQ1z5zbG6GhHpXMpRWo1JSfqUqdiWk9gpKrGBhMJfCWBGf/yq1aTA1OU9Q4wKsIXZucwQw4wgA/85c07ulfShhJCxalc2gAwkEMCUrXNKiOE7mUV5odNPRIVpmAsWhc4JZcEDwmZ0zh4EIg0GPDQmtqCARVZ05mj8ypmVgQw7knElUMSENpKD5XtDGqT8xNzczN+Bkyp+9RYAw85Geo/UTcMSHvbdCAcLjZWR86lJHOZJEFfMcIljtiykiAQXrFQZLjMw7izc/DkyaMMZGKwwoDDxogDg0cSGSMaP/k5qDQ8iR/p4KIYPiEREfDAY5lBuJ/Bw/vdIHiI5CUc2q96+EGmgzPRYgNvpGkcB2ecrSnr9cRHIoCTSd/MHXL8HMZ8kQAJDHDJVESBSeTBx/veh7wXmrcrlpIThUDJUVSE8HPYmJoiotseAd6gRQUMzMl8emDzEyRUOAeZzKAuCeGkPgUH75tYCVEkWh5OePKZDDPfMEAluewIxE+oUZEzKlQtk7DCSAuHRBKQfqbEILQ70A1oMW4wAHJPp+n0OPgdudPjZfQbUzNbOwez8wt/+Ed/9J0f/uHk7FL3bOBgd9ss0ORYbejyzE2I8s1iBktuoel0nfyNJu/6qlmPFldmmQMLlWqLiqSB8YUf25J4/dw6j5+DA7XjXke3nVQd28EbeNfAac7fvN2oT03brmoaqlobHxodn5qesfajdZyqRpZlKjTh/NJx4uOzE43t57/97eMnTxy8styqt9s5amNAUStH0zUMFbkNW9Flk12AcaFRdFfZsGvanGnx/pia6fY2jMXctN334yPWg7UB3m/p9S6G7Co9vW5Ojut6ekEIOQfgTXIwi84QmEjX5ut0n14OmpJ3f/7x9fnR1vHidHV+cnaoOrBz0D9qPdtd3P/6+eOFJavfBx5o7/bPl5ZWWGT3BlvsmLs0e7OzufHmyZOPFcqzz5/1jxl0V2tEN4sJKMrWIUP9avJUykRtdsjFQZ997RsE+/LlK81AY2bSl12mYPYF0Yp+/4i4JGSdnSQytGxOzWzvvPv3//5P/6v/8ue1UWYljAuDQEmszWztuLRu9OzCrJ3n2k+07rbltFr9vdPdlXtrzrNRHcMFvUQb2q/qroC1SSH6y9SPApuRU454RtFascJlnsrUgMpImLHA42vfMHJUFG/p4VdG0R2xAF16hH6SAEIQqjb8sVRfLJ6vuoBK1i8/yYdfSAGL+ghz/uTHWBLKVPDjFn6BHAA2GnBW1ayt/DJl1jABAKNyVyuzgmcISLGcwHR3kH5CyyWA8HDRFbx1uBWrWwkzQslnplK+MOf+K5zAEIJNRKDFOSAFTYaw1bfEw2rfGmVgyL2nFRLxExiqApX6p58+SRiDo9/97ndYMT8lJAPB8DAa0NASsXAXutEqFihslF7/+yNjAlEpqaJtfI/hdkyHNN2lAZD4Fp0Oc5b2C85EmxlJv857yOU0VnGFKznwomDg4BfLlGFDRtEVmBkERjK+yRISUvn6WfjKdi5GDBxZwyyhJMSCMSEgmX5ftUustJghBxQlEQ4heH688WRmfYVzsBXeolcLhp/Y+WVcLHhUwIjyM3EmklKkUVKAhfPAnywB5oCJEqlzpKzzJzBMUpGUJ41J4SQ5hgAGgbqFWCGjuBMxVlCiZyDhZPS7L8eAXQ9963s/+Df/t/+7W1629g6WqrNe9pqaXjRLE105i5DlIRpHNpuNmfHK8P7Blf37joibX9fSuxFZtxiwSq6DYr7uctx0y6WnthxNYm3tPqORpuIn4kxU47BzvLJ6z+U2+FeFtaX6/gtLK0w/M61Kka5t+Lam+KXXPjs7paFSTxh5ElA0eqBOCpkzYwqzN6pXRW7kUB0YjTfTR+NBqxQgKkY5czGxdlOdqJtCckdcLFNbBx4emGxUt7aOPFE8fH05Pqz30W9URuyZtBHF5NQpoNjiPFi1IcfmjYtLm1+dmqTvrq+/GnT1tNX04auYOXIOeqp71uluHzYrA8vNyvigJY13W3utxcWJn/7hD559/pvBscmhsZpblN31z5qrF3p8WlZbb6/6527M+PiDD754+vlRr6PlXVxYsGnP8NXChieRbdkaGatZ9lB2JGCLlBZCFVYFDL3mZhdkU+zs7IKrNSyZNJzV6vWMFe4/fPDll19ubu8YedDt//F/+rOf/vj7czPTCuvY4pb9QGPRZTalZlesc21GSTIMgVuG9FK1pO5etRVKe6mtNZhzINwg1jyi/cupcnTEhiLdSJM5SoHRvzmLA1DENabNNbKIh3G8Qu8Ua1yfEedqypfHAhRldpjCBJVV5vPraJmYdPpJ3SmthJQna4GCiCfGbuL0mRB1BDmV1E/ASp/++ymclFS0KPpy8YxY/sJbDBlFgRHIwSNEwqxTojJcCIRSJYxwjXQak0wrCoxYP+2qUMHiWypv5ChucmQzE1l8E3OmoplS+comYFHCNRKaZKN5oxZFDINy0d0JRiO6ZIDNx3GiixTvw1WM9IuqvN8RhEBSRYxE5IfHoflf//rX7Bp47JYhUplZLjcLCcxcRYaLY3gzJBZQS2wyYBh+BykcXcgxLVDa0sjF2IXI0OWU6x0zPHiTcwzwB96CgR9y4Wmd5T/7tvp0dJewAEAFBlrfJKctvUuOYqLNL654pBLOAUs/D9Ji70KSrgoJnkn1RRGwaqYDCAxFP1OxeDIhDwcV5LDxcLjyJQ2BUqWDXxJohfOrzxLyACk4Qu2SQ2D8Aokocj0a05oQluRxub/8Jh51WA0kEDjFkg8MhJbVI1h5324ZY1jhVUX1+HXurkaiDSNkJ1+Hhivf+M63P/r4a683dheWVr/2re9v7Xc83Gs+96B1yAiawHTiKDqGzv23Wwtzs+w4yemnViaZiTija36ZyTAwjwM872fkjGRxboiotZ+ajAth9g+P2GUtij65XBrf2dpv9qbWmLJn39qVa2YPWkdWFomHfYm8j1cY0XyYLCqMo7pVKxCWtD0tsGQqhW5QEpMVTIn8FjmMewyAWPycrE2mqpOknUUjlZpqSosxVo3n7KmLg0WhCTb7SOutkbqXxS4rThpcVgbcrNw/jbrqcgMlpWA8JuwyuaqdzS4cO+sPjmpmYknZXJDZ86GrSaeFep297cOTRmWoMVEZOh169cvnB53+N7/2Sd09azeXa+sf/t0v/3oq7kGJLdF6L0YrF42p8Ubd3l4mjw2264bTs7biTX/MBSnT636sBGASPxIK1I5bm3HZnIaWJkxPz5qqkXFGhAXRUHrP/vPPP/c4sLVuuuERheN266//5u++/c2vT7q1LhZOdqmrIZQWtH9xYdtPmHWt1MX5VH0iTmnYjeqsQ612Mz6gRbFdhCmJLhEVJs+xmCjHiUkq/Ujs4ZbNJc9irGM8zY83UZT2rkbw+CmtpU+9JH0UB7/kS3K1rzoRt5PKCBhlFGDZ6SypSADPAsH48ktFXFSLR6UQoujRTR0gOkn8BAwfTqgoxsSCj0J/3wAkmNhUJABSgcdYpLXXrRg3fpAcD+Bkhj9K09NIxaoIVE/h0dQlaQDpBGIDTvpMVn5CghOBckRRE6dwgrUCDzKqt2hfHGSCkiZ6hUKSwB0ZfGPaz+Qbag4YGQnXdxCuuuo9sW7EDa3WFMJCJYhgu1AhqZBjksa9vg93K4U4WxoyBcnxp7zgyZ8JCRj1OwyiIj/FCLIICSktqpyfnAKDCp6o8KWcBBIo6SQ2UTDIS+ZLFdJ54YfHyxX0HjkbFIsQUta3bVjSLU1PzJInh4nH1wRC9LaKPUVRBYKQFdOS88CPLjBZxkaG4JlHiKgMlDA5hxz/1FzsHYwoDoyNApkWmDlTMKDKn8hoFIFRDrm+GkqBZ5ZD85zylxEezCDBAiZvUAlUymLJTaDkANzXadVX4ZmIzIVZhR4bN8scyPqDD9bvf1Brzt1fWn325auR/fbC/FJcNGbV8+rK/I2yNYNsxsRbYSYhdObsMUe6CrFhpUZ8xDSjV1BOZmfmvZLojK2DSJZtTCt77rHAeJydydCvGzDlrDcd57yqE45OuTTUPL5HgK39jo6MVyamTMPbnDPdiBtA4dT5VdHclUYscqrUTWjoLdYmm86mrqysMWGWScyP402RqT/nJz0l5o0V0ji2PbR7ouNvOssLJmaUbH4lGbPeJEwOXk2s120YMz17I8qRWd1S2/Wsezdqjepyvd09ff32jSkWeqWkZMSWGLsb8aM+WZNWeoRzcXn65ZfPF2anZqasOo9fn3VOL/x31TlzteT8i83TvcNfPb6/XB251j3+wz/+P7ffvtJeLpQbTTbfvi6lc/XsacsCgFxkTaM2tgm5RlWBsgUn/UtrtnRDRciGQU2RF6/TKAN3UNNAUd6H2dnZrlTWnaVQzzwHbeWGhF1N8W5r+9HDdecNfvWb3333W9+2WKgjbnRFgEiYXDKAc4B5wCL4QUtycqY852fGcGDHGxO1a+cg6P7VKVrEG6uHZZ2LbQjF1hW2o+Fc1dONE/+PvUlsl0pflL/YkKwvEooibvc/oULl5AgG3W11B4asLzYZ6ZREpYh5m39sHgDgnKAUB1UPgLL9Twi/WB740p/8AOPhJESOCwaKBcsvDtKTeRQLmF+gJL5C/MwQP2EQ7mfi8ZX9TOJbNlfe2jfWGj9qqHAsMTWJM5l02R6FVHO1ZIYCujWqlbYc8sDOJVLQSYknA4XjKsNFYYhfIIdMSRrMcfSYJgln6VQVHhyASVQhjHK1Q2ayfPVIoOItgi4TUEno/YbUkE4kKy9Psaocvz6CwESObpJQEgmcbAssTAUGOBOtELwTAVnQb3aE0mOVEMBn4YFkVjJVIvQF4AszundoeRAVlchh4PQYgAlMtsH4Kbwsc90ujzOdCkB1cqTQShpyIYL3Cp3wkvNIDpUvEgkAFc4TXgiB8INM5nkkTGAeUfwcDPw+khNn8cdwR1TJQugZbJxAWuKn8YoBnBsalCl4fR/IyQ2MWH6esP1sfazhRCWx+KynfTkab7wMDhnaDyyvrI1UJlZW73/+/NX03MrTZy9cpoZn/ZmTU5Y0LjCInePXwyyRG3JkzcmsZqNpI6WTUW5DYzRTyCZ/0SW3bH7y7ilNnTGEw6WMhdK0lOsKBBvfqaLhfLPp4rVpK65TVQ8Xb1v4xZalSHceejHRo1emYFZWlobLRLDtmWfmGi5dIGB4fuFk8vbOHt25/+gDDMzNL8igCRt5NFLplYdLJ5uzGL64GTLt46gwYeoKmzk2tkoV0nG07dCCoIGYlWEPqZt2dmGd5tKe/Xq9Odecbh8ednod9yiX04fXk7X6cefEPZ/Wq/eM0ON0Us31FZeDlxsbb5wqnpudnms20Dvudtxf7cUcD1I2TpwD3ZuZHFyYrr57ueGMVXNm8PBm7/FHH7gcaWtrM25ws4EyWBjPYxZKUI60B2aYCHZsXE8/GgDKqdljRyiA4nb9WdEHqhgdIKIQaExgpswagDk3GwSsZmu0PN2+u3PQrLuL9J16//jx46kpr/X2UlugdePewea7Tts44NpjwDo8ylcv30KIvBut2DzaP790I6yrX0PtB4YNATXMdNu08dlxV88SY+RsYpLlhJMy4pm0FVmob6ns8sWVX3IZq7h+6hFSiaL/0QzAIzneRAkEBo8k9FzF5BeCEL8ilmU88DMdKgh/4C1OWvqc9R08hAAkBxxsFweG40WX4wcvFQSZJAJLXxcMDBL6YoYHGHg/AfuCz6xJ4meOvdiG/FlMSPSJgSUSaYscouumIudCmhC9c0LTX4+WLfFKIyJz5XvnvwsHxkFEoPDig4MFiwK1jXJlROxL1pYaeBIGKjzBmTmH0E+BiTk9IBOnVOkRm3lGFDyAhCcjAAnDr2zEEjoHFSdVcgWGn5MQpCioEl6uUy0wr1DL+l4YwaSCh1QOSRS/tHKnRBGStWQGWuGZhJ8nHQwww59EBWIGHj9hAAkzcQlhXvEsnBMuJKnzC8H8XbgoTjgHMwdVdOWKA+n/0PoCw56ECY90+v3kST8AmQIvEIDMYhhmgbjFG79AwH6ilWgTWGNJYndsS25qlY12JJ9aUEeppCUu63Wr9+6PjLp6rPZnf/GX47WGW5Ud+xLVqE+aRbF3hbl0J/P6o3uOKZhldArFlk2zKo5sVevNKttdqcGW2qUBUAHVHfcSyw0FMhqQKzt/mEh9Wx1/71Lp3Gy829LT/PDJx6b1ywHI/ubmFpna0U8N9bQcIbb7Zu3e+mdf+7r+aGWi0ZiaZY70MN03x1C3Dts66VZBFYtFbpvJTWhERbm81rsHo5WPYceYVwlmhkVdD3W8Mnbci90Jg95K1NOJs6mTnt4dGOnDMT5VmZxuzq+M16aqtSn9MO/fHHqJ5eR0xsvxjcaI5/CuLmym0hC44tTQh6I6KRCP47rcdPByfXXBzdb9i/677a1nr99ud06GJmbm7j25GG4enYz0zsd2W/0379qbu53/7k//gybl8Li7sb3V7nSefPxkbmHu1auXhjwKWgkqPn1uFierDFvAlCtKbSpRawboBjBdFtX5s0+/TucVuikjzws/e/6Fg8EaWgfBQOr+20umudX6Hh62HZR0IahTz188fe4xMmvhLKWMWD+oe1+zOAYdfoHa8v3dHZc/m6NvH7Yur2Jem7LRbQ5FOwuUvhAdPk4q1/z5KUpGfOknfaPPNPau7gj0E5gQXz+pruQoWlrxpyGMZqc4awBGA/RWCIHYN0zhJeGSNOQcP7YzieompDBzIguihCBxRxRLyZVAnsSWABLyCBGOva/WcXRh4MD4ogUS24Gr5FF4oroLSfx+6iOVox7/mBykWEzCIzR5VrhKCrw6otTIULsWa+tAwYW8ykw8iDvU/JltIeksuwHFPw4lQQkZtkPh+ikbUXKlN62qG/dptHEAD0khyaOPLImfBWFkGCowfjpcUx3POb4UE5TcbWMDBn7IKSsqEvpJV4SI8hMGmOXIT9T5hfADwHJYjcuYvxMuRInSYMAg/ZQRGHhwmD9TJil0URLiGWkeOLPgg7lifxFKoReoaAIBiJVQA+MLLekDJgSxgHl0N4Ah5GfiBwa5n8LTIwSAL4eKJH6Stp+79h56vNDN+OXunTI2jPJOhDxCSrrb9gAamM2BCcxcyw4wpGGWSg0kTy0T/MaJQpQgPsmZX0ZovP3XhIY9fpc6jw8PONUUFhx7qhDtdQJsbFx//1vf/f7jj76ur7qw+vDS27jeMtEP9bT72AgLtL62otDs4reHHVdEZK+nWRezK/p3ShiJ7XdbVUdYB+LsJZZS1GoyBnRnWC75sZlHLsbHZ5y82m8duFmo4Y0hk8ImlD1+6+o357sn7R3qv3j5av3BI5chu8YZLfdlQlurVJ3n6l7GwoyJqZhqNaaYqTx//tw5VaoW55IWFpELnKUDYeAMRjfZDJ4LSI12MEadyI0Yy3SxvnL0HB3kMjPlwgdHTQwNYOjGfWjmmWw+XpARe/O9SWBM77YDHu2H4tAdsS/yMJ789YJNe//oaGFx3iBgbLy6sjKpU8xd3HTcjnE66hV5W1w0uaOd3n77xCto5+sr8/+v//4/zkxNfPTBg+2j9tz1yNLag62t3c2tLfNyriGy8tEctD6spnQtjHs43tZ+74CpDjRTOeJccStIC7x2pq4sr8mvGVoXsrrD1XvCFGZ2evrN63dY/eADPf2pL37/7NNPP37x5TMvMI/Egb+rVy83rKlYDCAltUSFJYlHDx4adR38Wdwvra3vuPLBMwa2SMQNtZYNbCY7sZ3XKnpcTXyj41VttTvkZq3WjbAaAXlnyOiGEZJHBWhm7+TYdls7oICFSMusPf4x6Qsgd5nTXvzImgxScvtxZapaM80YMwoCATNEylEScuChk7AJNVJXuFpEiocK6niQIx45VWSSAKYGWYt5khAAyQFk/QIMAC0eITyifIHleQX+/Aks0covPhO5pksJmtEyEjWRBTOw8jMqeEHo5J8rCEMhsVRCbkkkQqgw5pkMhaKCe1N68NPHC3KFAAh9a1QllkmBQnxZcB0fbPlpmhIkKSstUtNYghQiAyV5jMXkLaYEipP2sN1KhNgFyaECPvMJCqPSpkG3d0B1hQRwSKJscYFQCDB4goevtJwAkhAAHi1RcoJDwBLmT0TJxZyjuqfkiIAGmNywjUFCeYRcecNQaEbx8ICkNDSAzQXgp3CoJIEBw5mjzB2KYMAn5/kVCCzD2Wp+qKRNWwYbnJYHBcoUloQgx59FriwAMFISQog9kyS0WU1KAIEKje4xWXRMlXabJg7RxWQmKWKJBo+TUchhE4grHvJBNCWDeaIQ5Y5GPUfJxfopEG+SqxUz09P490QKxlBxCeXAZc+stO0rh8c9VdSlx52Ts+9+/0f3H3744Sdfe/joQ/bRnivrsQYFZhucuWU6mTZZoMmo7O7uYEYHEy0sMbWzs3PkH+a1Upmbnk4JoI4omXAYk011koLhByr5MkQwYd2cnnm98dZbAuB1OWx/JgpV96jdu//goYvJDg6P5hdXZ+c9iWXtuffuzatp+1HdRlCaZNt3KAnbZJ7EDBLkuNKyicWMnU5uXnZPTTbDDIpYZ4Lxr7OPEBg7lEyJJDaFZtJcTxZ7eLaV3t07LqWQKhSpEm85aInZGQ1tNMmjld1WOw72M1K1OBslHUgBOjKmQZgAfVnhZsuIyN6QmfpsbXT0wYOVs9Ojv//lX3hHeW66Vh8febC2OHjZd1i2OTH29Q8fbbx83nNfqRHsaduxWFmbX1rW2XJfm+v1mSNXh5oj0exxDDqGM+Mq68xc7AJSxfnt+0RdU+F+aWqsa+54/IP1h7/4xV8RArCt7XepWtibNgHXBFbTwZf97//guw7NOVFxdNg1JosTG6cxttCgEt3FdZmK0Au9GWrHMztjxmGnXliesA/VDiK9XHc1exvZdg9bEkIT3rx+Wwy0Fft5ZWF8giWcK3rU5QInzFwIqnTb61MNqVJbaK9AwCRsBwPOFVnEDsf8pyhp2QQhqWkwY5JuyAjM6NKNuDC8f15OGkoUT3ICloKiwitEIyuVn4R2Zw3wk6qCCpgo32JdUUSOQCAHIBfqncyCEQ7GlzNSUY+sn+MEFdGldMKiinVGXSAOVdtWS9s5aIiMATgjbXEKXXakOnIgBmciiimRMDqMIpIn/vwJQGCkZ2TLM36lDHQ8ovMonIOBAy8bmiCsC4QcbYGiQCbHfpK8LKMiUIaTCr9y5YRzGSihEGzDluYYfj99ZUkI6XDgQUJLcDxw+nIgEb0bS5YZ59gyBJ5REJVUTHeinngQKhzGvIoQWUCLhwRgS48oGDI5j7TJoVh+kDDwAOMBoOwJBG8JQAVRSZGyHsCSukB40i82cyoviVwIVXPohyfBlAn8Bgz2yr/PCxzBA5zAeBJn/pQqPb6UmwaTYcjHm7ozM6oK9nTTsv6AoUOoQ4IT2ITIi1Qm+g3GdcGYfxd2IXFw2BqLDtrVzPLSt3/46er9R9/89vcn60239hOgfeLsOCqQmO01m2bZFOeGLwJiYrrq6vPY4o0WQWEfzqmphiRYYhnZemWNmWwMNBIYLqYzyl1zolH58MMPmfQvX7209qvTf2Z5gOjGooMim8a8aq/7xGbmmZthrYvVYP30+emmeZaxoUHXWHb6J7q0Kg/doBI6pLoBWWQkQBrMbueI7ZucndaDJpMouBDLWd+GH0uYKVLBuJU1rxhO1Dw65FUAfX+two3hDiWXEdJ2RQ/WbAOjkC7jpHdvNzfXVlZskRTbaR+qRxN1tw9OaJYEELtjySavFJnqb+erBRiL1d43WRsaWn346O32xu7uRnvz6N7y4u6vXn2wutgdOnv3bse215WF5kx1vLW3ddPXx4rbDG03stfO5hMbrph199NZhl2cm93cDKsapaAhihWIGHhRYLrpJtfxitfAvCdQPe4cYdjTPSweTj799FPW7n/7xV/jkbkKe03tz85r51cjp8Z2p9IoslAAdyhVO8pLb8cqtHqiFSyl7D3QML66tzESGPS++ejlzYV5MPk1Orpx59z7l8iyBhGyOqVbgz2dDGL0M82CQokjGRfR/PNnRUjqSOBNuJ/UzKSsBgCAvnTom83Mpdr6qgi+AvUzyN9EmYLDDHKJUPee5z2eECd08NMNHAaT5akrP5EjUjoPIZiiPP+4hiocZuE8igZ7cCawaY6QSRrYstUCP3cLBuozLAmcXzLBXlbhRqMWtq70aVh8gTBjI3mQEVXstucuG9BiD1XE4AIqJP0CAUjmKz3u78CSS1/VBgFJAEhuDEweCsPcrgxwiQGSTEsiGMVEmmPkEpVwfuHgkxBsIH1FQZioxKLFirEawlN2TBkPhwowyX2h1dNMVHdsSKuuQgJYOSVmflQ4sRjgyfrsJz+cSYg/PcLhThJCAATtgkS4WE64EpVEiHxlWuHAhGAgWRIiihPCJbd4SBg/+VNEKS7wyGkEefCfGplpE4kvuqhLmGmFmMHyRVo4D+Si+C2lZqlBrvp1e6fmamBGV7i3YiVBy1uAZye96Ubd/Ytus3E5rblgemHzpOM2k5WJ+w8fP/7ka4ur9ybr09DbC6D7byMmWiw45CrS3t6+uqQb66fS5CBXtd68fInW1ORk9+x8f2cXY+wF4UiLE51EzEjIj227jSUkEF/WH3KNAattPdq7V+b9xdh+A1ggk/mDH/zgyxdvwEwOj9rHR2fsvFRVPCSgP8mup6BsFtrfb+nWYUnRE6Dqj0oSxYxaSgLMmf05pF02K8egSmvhKtPQqJE4q2nDCu2TSgWzQvH6VWvSlMXEhKuWdNxM5ph1kf1Ou20O2gvycmQ9QNdq2vqHtzHY2dE5+ybPPQJpY9NgTC/EgWuTvdFFiJEZTuy7vRiUU9fbuGDnzcHh7uHxyfCom3xG2t2r2ujEFy+21+abq3NLLza2QN1bmrGsYmqtfXSg6bVwOz0dGfeIsWVOjc3Q+Mja6vLW9qb5nIGrJqJGSytr90zruUAt8ltGQuQg1YOHH7ggr909VlPNBzvv1uv2Htx/+HbzbZkB0P+IbfUu/NFY6s5b+zY2MiKwNqBkrTf89S/+1kBEh5PcuOixhC21nYBqM98q5kjFms3ggNG7EjkfZBbY31BzsgVJhjxqOf13QIRY8EZPCCc9+LRLwZeEhUsira/YxACtKBQFIuqr6gtIAEnA88MQxVq21lA5IUpcWgCIgrcM5m/Aqz8xwRN1k/Ikn75BodBNHlDhknT6ffVOCBwVfjUaCUiEBHJaWE5l3V3xgodECFgsGJCJ0H0n+KTDMGiHWf9EZZZDVv2BS358JY/6LyUfuGwRMxpeNHxFcfzppIYfPY4nYyXBunrop2osn9EE2TstD++7z5kcJJdMA+b3hUqSAC47bWkDJNF+lulpHIoSKNs8iGaWFD/pS4K08AIc7SdU0gpBMWnRF7GctDae4C0nfEAKvONcrCQSchKikhQxgEmQAjn+zAsPSDzcEfKziDHCEx5OyQEIF+KbGsMP5qt4Egn8ojiQhOAnJmWK8QqPfdMz2fdEPBY86HoKyk+07tiDIQuIB+aADsWK8oIZaWlTsACUg0AkIvYmJlhMnmAEZu+DW6PLLDitcxZna+x1GXTfi/c9on99PfTs5Zsf/fi/+Ma3vl2rTy+vrc8sLBujlolx783q5sflmjBiz9Pk1ludMOI3G4AcP9IHB/tKQV4UjRED9mSZ7dbTz8qsvHiwoSOj8w4njzqjRUnOZRy3sUl0b39heUmnUr7QlU3vABs3wOCWUMu5ZsmGJ0ddk+DCUpbW64wwqyekpBNjhr1/bEJ5KfYxxRXwk6lRhAlVfTw2/utXKgvkaJMspITxA14DQC112vqnMXfk8I5jSJjUSlFghwslJwrnivOIWYpFEtjkV7s40vPqpDvaZqYr00rmzcY7mXUrpzIy60AFYsa/1PGiG2eH7Q7++1bmdm90qD0wr5k46Zg8OR24GHuzdQhseWZ6c//w3d7WZ48fVsbrA4O9qeak2Xwz8HNzs7TKJapK33VM09Mzjx7c39naVk8suXvcMZ4hc32vxYPScZZZAlF8RKplHZ+OIlMzFJ/BhI25Rz0XOhyr9OgCdn++vFnql8QsDRPh4Ul5N0pbXFxWvjLOMTNZ9wMs3upypFxtdcZcfbsetm4hWaw2xewoOSAa4i32h1bgzU8SJgoAyiG4urm9Ft7PLCMsEXgWGXJ+cmLlTqAQYNWx6GVCpdSgAk8hhbP41DJUpYweRKmeGKBIuTib2BI/SCwRlMqicP2USggYX6my3P1ENxNmrCiqJRa8KJxo74P5Up0yI6LAoC4cDOS+kvsC8E3kmQuQArGdk42JOXkA0God31KSrHAThg8TnGSc9MgkNwKBmcaEDgqEoSsJI2/AMic8UAuRXJKwLkXK/Mlr/gSQjEIuiVjhyb1waROP8AQrBR/zFTyKByqSlSupkr0kJ5zL5Dxi4blrOYUjwUmCAch9uRRTcgheCJjkJ78JnwkLhci7bPLTvwz3TYr5zSRQ+Vkwx5mOZBLkHbD5YSqk+xA3yscydeili9RizFu280fUkKpgD/TIdWl5cZhM3jEALTORhGAOlS5yy7oBISeWu/PwE2Aqt9l5CBkp28IM+a30+GmXvxO5sIGJCxfi5rUDZmJn6501MXXQ+BcVxzR//Ef/9Gf/9J+ZyFGrbYuxlcZJK0/8Wg3GoQl9SFg3DYYF2oX56MvDv7S4gG2smseanZkR6FyoXNDspcUllqLAzJsRIGrJhfPg3+INlgiKzWWGjB7kBSHDgoOjQ+cBXr586XSSeeqL/tm9ldU3m+/UXnsuzZY40jFdKQORg327+E3mhIhsAzdhpAls1FV784jWvNhimoZzeRSFrkpmDUb3zjNhOMlA4doht9lYhEwVNTySiqBwiG1Xfdjt7paekLwLUS4uXSh97MX2txt2yrn7SF7M24q1EQVas/y4OekcXlXP7JVcWphVEK12XJ4ce4u0czGnHAtLJwNufTgze0Zh9ePw6TkdO3DqFmTc37C3N2pz1OXx252OwlucXx246u53z4bP+pO1aZMDln9tmzo57rq62THbsdHJoZszxzAera/h/+3brYOWXT3V/qU7JmIIS8LKIgy91erzS4d8UVxbWfXTnRNWAlzTZmIQY7FfJ44yjNgyG4ODy0vDI3LeO9hXLk5g6KSZ8nr9+q3xjU6q24piH3FU/zAjBjbIcawn4+buM9Pg6sbo4LWdoSp0SKzcYkRcwJkjCnB02EE629esRHRLM2Avaaq9nxL7SiLE18+M4kfOV5niPZt8IfBjmwNpkUaIbgQAGVey4JGWQQMBSWFmAMDACY/qzM+K+PdVWtJCCLPw5DOpQIVbhOC/Yy9+epWz2CI4QYryk5MrsTy+AjMq0ZKDDjg8foa1jGtZo832ExLOKF+p6fSY+wo+sA4FRGQSuAtnQkqWgnuOP+nBSC2igX0vR6jFqrE8YjNXFEUgGMNXCPm55D45xkeIrzSJOBMLuPAQjQEnxBcYcy+KtUq7D5iZyCRC1FhfuSVWDTYGMiE2MjkMal46UX6qnOAVM0MGFT8DAR57wO6yjwRHmJIIlxaMWGgzR/lNmAQAw2UuxAbpUkhfRSucE56Q/GI5IemwwRFg5rfkKw4W4kTu4JQwYXgkFy65EF+8pcdXrBAAkuTPxJ90BcIGbZaXAlV5oisUb2vU3JcnSao+1bDfn7Uwqcpch5kiRmOy89PaVP3Tj7/+L//NvzVrtLm1/fHXv+0Ar5P8pyenG0+ff/zxJ4yjqkK8iomHrGJHoKvfSsnihMMJJu1M0A9GMYvGl9MmsdrKCwZRsoNPPHOiZEfx0SJTOn6qorDRYIbVUANOWRBo9v+3v/m80TRosAptc855+/xQN9laOoRGZ4eusbIZ2Jsk5aJ57R+0khe92sNeShVyoh4eDA4l5JJzkHLEjxwHjEjFYoxZNEGCPSGxyn09qFmiyQpXMyYXhkGaMcKRL1TC2ZM4VAdv4ZSl8yCBwZYzc/pHvX4s+NMXFJWzaljXJLmCOU4/uw3oqn3cZQcH5kfsoPTk5Mbr50szk2zIP/z+5Xp3em3Z8beTr92/P3Jz0e52Gs35i/7x1ruX+tfR/z4/XVmaZxCOT44ff/DQRtWz86ft4x3skQZOFKVStt2T2GVWUcoXMcqLSUKLupaovWa8f3DI9Nfrob0yCJhqu99ITk3aEf7CwpLXBbwevLZ+/932jtEMMK2G7Mg92RKyVCHJAaeLY97pfMBFIcN+MFyuGiEcJMBQiQTOsqYnZItNCEW5T1D/wHoLtBj2BcbxS6uY8mcUVtwGGE4qplGUqqEEIReb4YndAVwPAAEAAElEQVQZCcmxmhoCpwYADE/4C9vgi3LkSDoMSCoDcjqs8CRk5hQwchJC4guGYHlwgpAoCi25WHjESiuJb/7MJEIyULiSAi+cCyHAVjZDUlHJSQYkrJncexkxMOcEiSYKVHkSBVBYMgFEYPhNzdjkbUyKJWyBTwzWu9AzcScEGCcWHoHpgQqkcIFIqJ5w4gM8GLHpuZvnVX+yGIAmafDJmHAh/LABkyuYxcIAOFn1FSUECWQzg2Hy+rcjrEQCA9JKBVjyGay9d9DyIsSDyQTmodwC4URF8js/YD85Ub7gARf9ls3QvITnKVA5dsEb2RqKEf6tEgDAPGyS+1qbd/+wvpIV2jhE9H60lFmgSQjBDJIHaZUIDD88fmJPLEfw6GamZDYTQpKlwAYhJ4l+gS+/hHZJ12PB9sa8h1l14nSvpCkQ8zGyeH/9wU9++rN323FA92t/8B0He8yNNz2ReNW6f9+TIOdmFdSWcbcZxCPGNnrfbs+FmEZixpgDI8y3Hd6kKgtmxs2De8DWjIlqJko1hoQFUUxpj2RNWn0OawOmEYRDqHaJrdW82R19Ec2AqQYtgX2isY3P8eORUabWPp29/ZajAI7v6hp7wNfeG7uAYubhNCSmPAmNWfaFU0hM74bcoq1igGzyQS7E6P6LYugbzWmGhUjjxolKs9dxx2WP6mOsdbAnRu/eMoki8GCWjrx8WQqemp3L6mo/OfkQCJt32j2ujY9cORjkZKXXyuJedOfXhh2N0I/pxloA5QuLY3rC4zovXx3YE2JoogYQlF4TVGTYMBZz0wOdGamNDumkH73dfPf9b359eLzZae2ODFZHo7kdNvcjj4Z8HlgzWa8ndbDXmpnWWs1+s/LN8drz7f091/rTRjmVQQzbzysjW1uu85vwYjnr6cbWUTdb2Fjr2claTYh1CtnseyvSQKqv3xpHerd2duYXFxl7Xf7psYobSW1QcTohSxN+AreqRIUR0usQYuxL7qyW/Or6MjfkDD61WqFQGA48DRGogDRLVJdWi8U2VsGDERt93gIcZfe+qqKCYbEgOXe23uHngTkrAvwqCNneVbe04O4TsTeLbjC2MIUp9aic3BZCiVbuBYatdEQ+Wpbbnm5y5Se0BAsYY3hGFCcFm2xHHkWFHqYrrIMRKCDCi00wVDIfxdpkrgMtg1K6KZj3U7qY4A1LGVbLT+RuR7J+gMiWI/H6EdHFGaSjlDBnJzHvnKAg8YEDX7ruJ8cDO+nIEtnZ6gAYgEAI4eERohlL7jNj4LGOmgovlkSYA9jEchIqUU6gn9BiJgE0+NJmrJ4KQtElKYfR8AkMKp0IRDlpRUnoG+pbuv+Q8whBFwCuhPBLy+GBX2zqASQA4BSefkn8lEQITiQJSiWzGSh5KZWY0IcnMyWQy4QwC8Q5Jwkw8NAC8DN4K6tjwAJvcRICNq/+VTaEkAP28OALPrPjJzxI62kJTwb8JDqi0PGHktDCGKm6o7et8rgHx21fGdCBsh2iZ83UAMvuY3VQBdaOPvzgw29881tdI6iroUePP7YC/Punz9wBp5MKrdNS+Nf71nnf2dpClLG248XsFEzqEnIKiMmmHbjyEz86mFLxAJBELAPqtjX84xCfuYVUvohICRpPyIixBesp+8RiBZLE3AaqeSAGlj22DM3NT6h0FsjiGaKQoHc/auUOqJvLCyuTKMbi5LRnSGYZRMhzVAE50uYnYCZb5cvU8qQMzfinkNG6PXJRpufVN7UAPwZSmGy1rHjf9iSQZqblV48CgO6O0qFrMJdNcnF9jf62yZ7pqRkl6UQbG6olk8CuYcIxOMmcalfUZzvrWWQ8Y8lwx/rzyQjzM3jQ6rqdn4F2ER1L4LTZ5sbh0y/ftfeOJseGfvyD77T3Np3Fm19a3d18qZkfGLt59uzL6Zk5qzKayY3tvcpoTd7RwrNlW6T17gnKgq5MmXlTRgQl/HXnNflrjVyu9/DR49/85jeHrba05BDz9b0++XkyQZZzNUjfzEq6S+tmZuLuZe9KDg5EL4TTuBApotB6qMj5gbLkQdBRL676sR4mVueEJ0KLZSBDWeZX9HQD/4BplOIjFn7Y+HkCslTqEHgxoAXg1uhHP2wgcpQZxz9gfjhpkXC8KVlpqS42lKMvJxzyrzoiUtASQiIct4AF5igTznTJnoz7CQkYFOXCF1pUTk6jIhSFicrO6UhCCF6OkoG40q4YcORSY7EquWyDjymfOPwVWz+ThJ/AsCRwcH0pVlD9BqpuBIVijBCADmdinWn0Tbk4qiL/pIBkQtqCpfjViizdkjCak8wVewk5B15+hNObohmhWFIJSesjIQeG+UBCEj/xgNHMGHKAk65vMFbGU7TfT6VeOrXx2p+EmBGLBGyWg+QcDMna4g1bEhKLSWjxQ15JC0uSYENU0k0hCEl+8MADG5d8Jp4kEXIv+boTo584tBQJWJLMFzBoExWPtPxI4JC6JocwxPaCImcU4RGusONb9FKhS5sA2IYTcniKkY8WRSpEJRToy/whxJNMwi8tuWV1pR/2ZdvyIdy0tTkZW/1YGX92pZB2MunBLo204xo/+9nPphdWJmbvuWPnwYNHllhtp3GRg0t74PS+CosvicMWCwtzeFYRvaHLSDkDpSIW039tSsSGMWzbHqPg8EP4hhpRYYwGtO6XseMiy1QU3uBUtVgiasOjzRCuj29x2D4T3Xk/3dxAMh5wt+bP2DKUHuy1NM2S6gbq8BGLiWmY+70useNq3JjDfsaTE3kBQ3/kwm53LYEL1IjX3LatLApIXky5hDKUV5YoD2ZMYmDM/A1n7pvAFTDB85s68xKvEA0wWjw4N1kfOL0eWXZ9oGuLvsn95tSEhtZEuXGGK6xN2tAAuinaHtYsAsUnFfm48sjh57KLyenlfTQNgbRGxOu9Afs7By4vCFcv8vri1Hn5k+ODiZHBycrgpx89+sYnHxxsf9k92hq46FXHdJEuZ9394KWtmrv1mgdtTzlqBrYtANjq8+Lla5zbyuPoL+NMbrnV1QRFaFd5zESm9NfDfsc9554gdvkPTYsm0814rhpeW1v5kz/5Y8U0O7ekA6NB/uUvf/n73//OdELW0MQGYVYEGdMAEK9ZGVl2kZwW7+i472Y56kwCM9Ozvvzql2aG5JFWOn4CNwVEaa3uaGZKAcXlUYo49Px920Cdwj8WlUJaOqOTzm4AUzrsNbFDhR8ANMFuV6g0BrpNdCYqBamUnfvA7CpG2k84SSPq9XA8dgaP5GjRc4GhIsPD8PgKkU2aloT8hBN12DAAleZfjviB6TKTBgzAYBOiuYRfcfiqI7KQD9jx03C7B1QuhjKkMRJX2GIDIcKTR2jxEOUVynTbwQ8PIA6B9PMkjEAhptagjrIpnf3CWQzwYYcRTAKD8TPIFJOdBijRSsiDoVJ4YcJgSx5ExTpkmQ2UHDkYBN41LfDcoUJaWUbVfT+tJorIYFYA/OoqZqJ4LsL0Ezd49osHZvgR5XjA8wjMKGmJLJmUERhEJZP8yPlJ4hgAD8xPhNAFnBjwXHBHM84vCQ+0SQ68QMn9lBwDovIrilaIhQpCI+K7KIGAJUHCtyC8zULqRGIDwwGWHFf8wiFPlz+TK3iAgSFwdEUZS840m3SOnwUyqxsZG/d2bjQzLoVveJ1rqtrqdO/dmx2fbKw9eDRcnavUGuVW3ZvmzNx9uwPbbVcBMqOkSmgyQviS68pREmMCbZ+NyhDnDHjMw1D3RgiQ8dK1pBH8HYZsYCBszc2NukeGfsoFYNyy+KnQaqNc6EiKkpG11XWnAbZ3dt02jJ/JxpSSsuW/PlJ58cqzNicAIIdkdDxmciWxr2FucQGJCHT0d3NDC5cihVzIaBksqqXgkcYJVjQjFkIRRR0nJj/xaRqEM3Eh0F2n8r68MO+uf/ZCWmVCA1EBKV94Nr2TtGTNjiOZo89LK4t04+Lae4sdSqqtha1sr4t+H+sQjU/xWOVu1CZvXJ0zeN3vHdKd2WmrBRcqdvtoZ9zOyBtbZ8YoEaI2EYxXpwdc+zl4/T/8pz9/8eL5v/jnf/T48aMXT3/tjrVuu/V2a8+Jja3t3emLAevI07btj8RL9x7OtJ3V3iQjws8++8yDMybWbAVj1+xyxRu1IRZylgunzORINk15Oc+sGzEwVtnde3dvbdW5YgO4J0+ebL7bpfLypawlD+c6IBWwbF7I2qdc/Nb90OE3HWSq3XoDeUZlHDGtertpkBzomMLCgGKlcuRPtgqtc3wEsbqegUTqJ+lJAjLLVyqBopQjBviJ2Fe4vOAknVip5Fd/RaxAFkmh+3rsUxSHN8ihxaEoEvBTDw4nYmFLh1uxApMoVBDiJ6mjywNeLMcPQNlJCzP+fDn8CBGrvZU2GRYOUlo/U8fEBNqSR+yBRNdXLAcDErcTZOCKSyajOEH4phOFZFI1nEQgs1TwQKRXGyb1Lqt4lpFir2LQJGFilxlgaPDIRcJnIJzAIMSTr8AUStoOIiNWCUVBBTiRkCZIzHA8ojIcKsmTrqjRgWjbkeaXNulmbKJKf2YWHkgS1VdpJX4hCZCsSp6QiRkeyJFONnyBgWExyEC4tBxmwCMnrdlSf+GNxxTDBBOQv8AS3QFXopUlaIdyitjP3r/UVuiGKOBJiSVyPBTh37ZAeACQ2SSA9PgC48RymPGFEMVup+1n9CD6liVHPH0l8OrsSuVsNE3veo3P+1aT/+yf/4uPP/usVp91F/G1aWfn6a/iwgZ6pr5J7v1x1duzROw7BpSgXO/uHTHch4ct5aTXQI10ciQ2iMSzOs+xgLKDH0hwKFMqXgpN3aYPqhan6P1klAEnXdM+eu5MtoGVQ60owiaKCbMxiTV+8uHHePBgAGzymCVlL5DVAkj2W4f2sSQ5tkyRqd4qsGocM/ujcW+HVJdxbUCosV2NeQGGZVjwlhGC4oS6Fz1V6Bt1c/fXWpfzqxiEUWyB5IPzVPISwjwdQyaz5C/v9qGevuyjbvwU3cz9fYbRViIvHMiO3M3PzX73O99jif7yL/9ysj7hQunoHo0OmGPxrri29eKs62n05mRVFTw76cc9bYael1eeYKxNVPd2tDrUq/rlxs7/+z/8p3/6R9+bmr+38fKL2tjUXGPOEOb8esgEFAl/43vf+Q//nz/Vljx8+GB/f8/hcO8AzEzHcR/8uE/mzJPLOge0yEa1Us1JwNwegJnmrJGZpQiC1RzinORVYeVFFG/fvLm3ti77aZUsFVNIAObSWRJyYMpM1xmo2ZUj3AS7cxuxBjxoG0LcOag2SeLwASQ8xNW7jJVqDKBYppWiDYiyMxIqU6wgxcpOqrpUHFpRlKUVkZBfBeSRKYG+AIAJFkg3dFDkBQYu9fO01zXWE2XcrnoVmxvVykjCfKm08PgJAxhIhMg1zPypganJAESBBIaoVL6ibKINS8FsFkMPppiF4DMCCzwwqaD1jXPCw54hinVB4wP1Bwy8YWtYBomLFcqbJAxYw0pKlrSL5Qm8nMD03PHEIwTnmAMPoTxwyZOamflJPsgaQDBUTDMY/gSGh0NXkfAkKpjFgqF5FEisELECeRRw+iH3U0KQsq2AwYNBnXrJGwCQPMA4PFAg+9YVGzCYFXdK30+Q2ON4JIdQYPIskAc2GYE8uZVBHnoGHtu+XFIRfvdTVP7EBoTpx4lwwH7CnAl5otijTcpSDrHrW4IR6KvQhHASGiTgSnbyJ4SQ5Dfzy8+JRUcUT5bFVxkr1IINkFCJ8sWkEE5mD+3VcfZyaGDMU7qxVSymqtjoUO4xd1j2RisTH3382dTMwuZ2a7I/UKlO6TuTDAFKjiImTRmzSpKhYsMfK6ykCF9NTgCX85Aqy0vm5v6RNt7FDDzKWnIJBZpwsDYrd4AlFMUBY3C1CgLBoEsf0ILKvMqR2fAw7l4TaDrH5C4gqxEj15Ztrmz1tE4JGBI1OZOTki4/bBRJi+XmH0YWTjKB0MUVMI864TMYC8ISEqCpSTzExlydFZsWy0Zw8HgWYmEzalesO8WdJywJPKJkTSzlASlHQuikIiYuXVh3asJpJ+vIyNrVYJxs0tbpsElC1/CAbpR+sR3NaWcRPCujY39x3Gkf7O/q6lXrlcErF0cbcJ1IpbziMVA3RpQ9PsiZn9Hh8xLOzHhjpNo46baevtwkh+/+wSd/+KOf/OqXf2WTbLNRO+pqjl0u9oZmu0N0YsI1QRdmecq7x9Hort9bZUbpaTSuZfmakqIoX6YKrVlgnoHQesmmUrOJnWJQACopIzyGBcHnef/Bg/Uvv3xm9UfuZJ+DhEzMWpu6ofT+3Ask4WAcAYs5YXJVZfihUnZgkfbTkwMwKkGBBwcdswaOsIg9u461ogBQbQ00ChI8AOMgRFQgFyVbpiLJil4JB+ArXIimK5r59/tKAMg+HgCgi21gsMkpon72Yy4zziFncvCZNZ4UAk9Sh4FU5QI5gX5yIYOSO10QLlnyhSRh+HELEhLA+eXJQFKUUX4T6NihDDiXBGmBsqpmJnAoYqGY+fzHVqiARc7FygOqaOBy0G1S7qTxdM77rjQAYKTgK9UdtkyYP4XLD5cwfpp5gkF+0iU5JEiNnwcwj8LDqMAMkTzFkR4A6iRbQ+eKP/oUMknuAJJcyMsEZ3FCLM9BiCswd6xKm2h9wWSZ+XKZC9gwEKiKWvhJFElCWh5ExcIpOfy+foqSKlnSsvgpuXDwSdoXMCpMFguVzg8hUPkJEHwR/y1pCIUncpVatiABnGgTMxi08MCJzUAAGcIjkL3LENggSbSWCJYW5gmzd+xdxpqKrVdpokPCqndaGDS9KK9WDY3/w+dPp5qzayPVIVXpZnB6LPazwwmPU2UHrb0PH3/EfFtZNYms5iQ/FHH/4IBAMMyWERBaOqfkpBUyRWHSxIKtrfRgFLoNk7agMKA4JBNK7MtP2gipkzrCwHSWWSLTC+6e0Xjor+vvq5/tTtRYbwJ3jnvuQT5qd2SkMl41JiBX11Pqcbs4DgwO5+bnZ2ZnX71+PV7GDWQEv5rJkFXiBeMjI/ne8bFJVceTzP+wdBdnZVvF2KjOoLUT7x4brRm6Vd0Craev39C/NKdvlxmGsa0xa85MVc9sooscKQWzVb5KX4uomJxkNvWiRbFthMTkgj9LUH6NJ6ymyNb/9B//fxoPj2eZL6VttXF3sp72Om2PA2gNJ+JiardT6MqouSqau/DNmTDrnf5Fx1KMczHEfj1UmVuc3t3b+qu//2J2cXnt0aeN2tjOuzc3rbaRkNL8q7/+X5eXHeu+f949M1P0+6fPTf64KMLk3kdPHr97t/2l3f7ev1TrR0cUuqcxWUibg6mBwJ3drZDe5ERpIpW4HIyBWFlaUl6Mil6q4yXKa29vV89A11/hqjmsP/MgC+Wx0Qo1cYvGxXW0vgZXzBA9VvvIkIjI2WZ3wuRnfFHkX1yMDoQVeGrmfU0aHqLWrXSmLI1YMcfI+QmeVoBXHbhs4/0UleHSKj7kxPLfpQIDQNHThOtTSKJNQzFrTWj4Rcw2c1lh4yYnw4tyYkBgohVVQG4ndeVCQiQg940sO+JXam4mkUq3XYiDfoCBEUUEWkvwshtrQURu5wWtd+9i2jK0kkBDEkpIobwvQeFwBVrZ3RErHpjDTGArsfOgUZ5mCAHZaSRWeV+5QKkYMj/VH07yu96NVCoktmK4VBCK5XDgKyHkFiik5XCDQtLlF0WOMICEIYtHOABZzSTwZEL4+SXhgs3303kCJZGWNEOIV2FNYKOadoLxJCHwCPkJuQKGAYmkKBxyTkK5A4CrROsn6kIkTM55ONi4ZD6ZSSbRklBVTGAJgfFzAaBoCh50NS788gJAKl90hCAFEnzx58ggFBTN5DZRZV4S8v/InhCUg2rBIyGPoEyFFiYFWogzutS3REteAPB4kLBSm9g/aE9OzbhJrT49W51srj34QLi1SkJjK7NPDdhBAZWNOYYfk5pnyqBrpiz4FYdwXzsN9f1V2lol7CM6RL27s6MD7gpJIUoEAw464RAbxI49MFiFChi6APiFA0BLiH8Gwe5qNoM8PTNrYorODwyP9M9idwDhMKDYU7J4wBVpd3tekVx1fAxFN4DqjMuOOiBK6VjDPHcjQ1mUppKKQqnbHaFkWKgonNKaw8xpzHDiIUJ+fDozgyty9ROTMiJfxS4P2URNVpgvNuta3x983E5YmVePgOFNj5WfsYYTA3KnNYKEPH2J0bDKWVn3AaofLAcwtDQjCrYWl/Z4IqwXs7P6JybTz4+9uxZbnvpnRhbmRc+uh8brs/2ry//23/9/H99f/d63PxO4fO/+affQ/nvHoS3DnJx87nzcx08+0tiYZLE6/fLF8+9+7wfGUVnKWMVY5oV9cXDJPVPKxRpANIcM4jBxUOB4zEvXAjcKcX39wWE0J5umzVJPYOBIiXpqtHSHZCrOM5i3kcArLmZBh1VPnW4UYyjmWj3CIQqp6BEhYwZFMk9x+Qks/ahbw+fnAAADr4ilhSQ0rSiYcdX/zpEqEtSb9ZBlRSC5HoOlDvKQkB0lgWQjgMuWSPiRlqOiAGWqChCN1bpnxS92DwBIPACDwU+pAOA8/cL9BBDamN3iMm0jOxJSj1LogR+YL0h4SMNXBs1eCoETQj8D1fnFwFhwJRBMWCURsPAQfflGSHIjsZDrYjcwJKsKZpRaO7EIl1euy8AcK34mEmmlQs/PMJ2FjMDMGBwgxYLJ/KiHGStEEj+VEBiZAaxsfDM/mRZwesBwAEBy0uKZE5i04Of4Tar4cn7afph+kJLww4YfP3kA8AgUAs8dIZBBrLhMlfyDxE+yBDjT+pnwhAMh3mADmcmTIhg/+eO0Y2kjJfczi5mfEAqegOFBLuHL0C3yGJoXp1PDJTPvAUJdMkcSYqDgiZxqXsGAz+QJ7ycYJZV4ukdHxgETtarWnjlzsZ8us5Wu0zMPb/U/+caD7/7gJwsr63ZnVMZdpTzhQD+z7oDC7Nw0NZDZlOHh0QGKVswFymAQHfL4bfRz45qIoZilYZY1qkjrO+sf0Wl7EGGz1Kxvzl4LQUQRk8adfGBQ/SBXG1lqyCWBn03XKniYIu4y8qaXF3G1/J6mtcAQPcoBi6rAXEq9NjcvrX1KdrvrkVnBtqudSrZah04vYZgSGqAQo4mhw/0D+3/ki/mbnp6y4hm6EC/3DrsZ3xO3dMebL7fZLFede+AySnxgsFpzDpNVYsG9CBy6qvlRyFi1PxX+6cmm7rALiNyblHRVI3sxZdCoRXvCymDGQMdBPBsqbWyxL3JiZlauD/f2rcrKmdImE+9buoabpcSafdvnUc/YfocVWM6BkYqLgr3DM1it1y46ppf6GjEXRTrPUxuz93rp86ev8fAv/+RnC3Ma5raJrW6n5W0WbdbLl18qC3P6dudaTZH53/321/cfPLLAQ7VYRju45CVLOYrjqK09UkB6Mkw3hkmv1zntnPd1CyQxiW/5WqDyxWUwetvdxnSUs2JSyy/77JqhAQWpnndPnES8qYRuw+ADP4+Ekqs1uQ1UrHANJPm71NbkJHTKuiCMWqnWYAk8l8kFMkZ+yqPY43YHhmTJV6woaJWCAsJKUhSuNFGBpJxVEMx02O8UHEoIFU/py7E/LCgjFFUdNsxw4P3EXuInDXT9zFhRPFj1ZjIqDvbawpOkoRWuHQLDjyX1dMitK8XG6l8zB5a/tA26LiynmmUZBpJ4bHU4eqi68Z6GYnlo/u0kjGi4kIQFExxiGPqqE5i5BUamEAnBPT7UT+KQbQ5zsMkP2r5iBWauJOcRC0aU5IhyQpJ7UqZPSAffhYGUO/zIIZpFi6hsSw6PhBw/VpMx2KQSmLyBEa7K+UkovokTAMayUAVyyacvP+oAZAoA6kjDH7IuKzN4hlPWkqifwsGjJRAzvn7iRDgMsGXGM0QqJEgAV8RDrgVV9AWSDZmVXKCEQsAXgGjA/MQ/lxgIChLhCIFJ4GQmQwS+PwWBryhBnGA4cYIRqM/unJEJXKSYcvpP9rJMCVxCUZ1oDAyNX9wM/+gnP/s//df/en75nsCl5VXWP+sMmwib7BAXTjhE1W3rvXL05s2GziPRsWVo4ZZp1pfbax14MMUSrTe84nzMeM28it07MukIKcbsSfWcLJFKK4mswY9/GIRwKOpvukbNPJVXc2PJ6zJaXO0BYDywm/Bkr5mdlQQPWBUODxge+gZPulRp+7wQ7bipPpqBS8+gT+F8aJCpNgFhidN+GDPUuuYeOzxqtamHnimjZlUAOat/KrKlb5NFeIDT2inq6EJbilVL0LP9lJ32YC+7vjQ/Nz/jbYNLVx04AMysW9B1ZMwmQhqrsMiZMGEgHHZw92Af81bYS6W7nrDhf2ignD7renfFQ69yKpVykAVZc62R9tcuUpzv77VwRYYGSV5SO7scuLge3jpo12eWBoZr/8N//PM//8u/Xb336OHDj5ozS612z5s88wtLr99s0NmlhUXzv0yUfV2HrX3nux88WFtZnjcJb/5jNIzKjQGHdfKiAjdWv73HK8telse7XZKjw2Me4DQJ4SE855aqNilyNv+MRQ9Sh0a+KCE/JlUWjofhFcCiat7UG5zIuJEqySsX+uzwCnXNKTtGX+5k3IS/x5x56D/JO1UHpmCjlTZ2xW2AOvVkVeY1DFJusBtxxeGj6PKtmcY/vSJMqHAlOWwAaZcvaQuUU2CUHP+4yp/wCAEgoc2qpciid8sJTJUGAz4TCuQRCy082BNLNjDzcxkum4whEv+Yi0JUBlkjMKybtSWoOGkhkVncwnDHXnBIU+0ddjmfCKCBXV+l/BGxlT9PXrgG1gEXf2I5xjgOPI7XzGlaETMqtHXB0R1bdpWHpPkcqKG3P2KSGaLEhCldYzdFiCXk8OorioXULhCdpr1sTGJMCRQdc8LqTNQoufO1/cA3A8tuxRhjcilrCJW3Sq4w5MVPRDmZB+PLz8D50zUcr0YBAJMWPABphZRU4GN3iqR3SEhNLGAhUNGApCs8Q0LVzDyWWUhgYJSNKAVf0CoVHW2NgRZRK6hR6bbbh9Z8bSO5vL4w1+Hm1PpUvJLBzOOLKFItNFXKQG7kg6Yx4EXHYhmcgcA8MRJyilQetUHkLcwioHnPKCtvnQ95DteZOA9OeSbdbTCNkIwTOM45XV60WwcMUOf4cHRc0NVh90jfn/Gfml3cOzrt9gfnlx999o3vsRG1iebSyhq7hq7zyTMwTVbbh/uMgmLuHFqFjU3Z6h5bQwVNqtifQzIvnj3Xm7Ynxb0Lrjhm9B0s0ttlYuaWVvWjOj1zEsNOGeFePx2r7qY3xRR/Xdvh3WLflE1ZVsMdFdaHCYvDatgvwlK4983ewTCXEwd7O7vbW3RWdTlw1KAy3oqOvHNEfbfLuNneMVjdebpHwjt7Bxa4F5dX3buw8W7bm5FUwQ1onq3XPpiO7Mos06yLozvaaOrf2xTlvn4bSSmv5ttchWb2zHpFr+vk5qQB1LixL1W5cbLM+OPV2414l6T0NEuFdDDnyCoBTg5dt7a/fXPZn27ULs96leEhb3E5n9x3JFi9G4qepgbAFaSuaTKIcTDCyzA2YqFOejEta37HxILd+JcXGxsvzvqdmZnakyfr3k88PfPspbMRVMutNdYeBk87p1cn5yNGJJGJYUOwUzu4BkZ6l4PHZ4N7ncunr/d+8csvxuvzDx599ujDr7UcP/Bm5kSz07bK0PMosWc2rQ/1T8jDaOZydq4x25wYdyhLR/7Sxh0nPBQu03xDvYzdGATm8Dx2n44c7rZmNYczs/fXls/P7BLu6eFrn6ycx74AywLehownKs89kmO2zcoAW+5lMEJWe2q2WlUnaLO5R3KIq6pHxqz8x0np+qTBnFvmLGDUp5omj+Ii1atro0nb/70ZpwXNY4YxNCwHegk2h5LUgPU3Z0WE9j04FH7aO1WgVW+TDMfN+2YCWSNdNYMwu30UCoG7G1GD4c/ZWHutZqZmx4YrqrKKzwTplDJ3qokxn43UsmbBhPayEpY0mE1fliF+drtqIkjqkbXYrKPm3LhBn50AdQNHGdqxMWogSaxkaPFHDMLj+Lo1NtNKbsGqN6fiViXP6lWHt3e3NL1M5WGnrX2lHN5A9Wfe1RENCaVyL6wyirZU/tGml1j35fChYmCLIVN1Y7GgOPavnEzWVr8PKuGSsHSSpH20VSs9AjU7YkUVEtGHhZbpjNa7NE2+6CZpBeMnl8l5YPBFJD3CJU8kvpxZB1Ec/KWRiFNd+RNwJsSzVBy6QjBTuI5tGAmAelYzNpQHG0L4C3A07Jmk0LntZYMRiyi0gEnMF34/M1xR8eAQnmwbEk+ikinwvn7yaAyk9VMq8Dyc5LCVfMWIUnIuefBNGAA8kIgCk8xImJBOqWAAgINLAjMtD+b1wvy04iZtWYZwpAe3ijXWskyh2LbK0tmtqVLXGs1/9sf/whuKJq6tLBqSX4cx7VRGB5la/VkCsOlCmC2exjWyYCYd5+qhYUxu81ArCNx0B97wWVrQihJSSogwbWJt3TEc0CDJXpYOgegIEE6Iq+wTlyMYjo7M55hmCTGaT5ANHQLnkPecGLA7sja++W57bmFla3PDwVUnkOfmFpCA7X3yo7iq041AlerjMotlPlo3KJ8J+s2vf6fIWApFaw4JOTPysmPqZGFu5uoyFhttJzU+QF0zbxY+ynFoeHV5hfS06+qqOTHDC/fehBwGbeWcOvYYVuz9j5uuPQ1jp095lf6mF/dSTFAslpWh97SmHZYeKRi8GLGLVEv57uwdfmCz18VgQufo+YsvV5dWv/71r//dL/7Ck7UaEQDnA+ZVRj2yZuqONAyhzE4gHYvKWknjkvpMf0igx5htptJRiIbWdQEWJJSm29bGmYKbsf/xL/7m7ebWv/m//Mn04v1J82bXZ07/jlauxsf6XjA2XsShE386jtXGJOHIzuH+YblXP2ou4YSmWZzghmMliQWfmIgFm9jUfHnpCrk3m29OGLnj45jEK/MS2oDg2cBq8MYxbXNTqBBd2MeBQTfoWTdnJAdHLuhxGRO4nCq6buy+r5IlYY7BtT2UpgjZ2joaHadIMQRXTDk4wIaSxaSKwAphGP5g9HYGONbglSY7AFKscLU767tKKSTrlxQsUVSfMtyHSjhFBYlnP9UCzk8wqEMCIZNNZ/AmMI1GKiTOQUKVSHjQJY2Ts8u1tQVykNYcHT0EgDd2NTFDUjBEIB2QSi9T4YaBHRp0h2NUkDIFTTJO3skQ6vTTNgUJxcZIBwEMZTJdTIikEZ55S7OjNGE310Zvkj+sCIFEVEqZB0KDr4ItBAeGE1780UhkPskRflEF8nb/jCjJU+gwo8LlT55MKxw2CXm4HMJLhWcKJJz0TTWSFHg/OUzDnPCwCeeE6KVm8ws5nEGsOCnueCB3fKZ1fh8b5hjFwFzaKmlTgMJBArvLWqF/C4YotELAA/CVXBlnWWZBmpRgKJWQESAALhnALX9mIT3JIT+EYqkaHgBgIHPHr5uAGUUr0xFV9g/cZQ1FXQPhPL7wGAXtbG/QRcWoF65opb334P4PfviT737/e0+fPa9PTs8uzGNSkvnZuY3NN5M1vVTZP3eqS4+c1TZYyUzlGV38u8OIwk3Wazu7u/ax6JXY2uOOEJqKGeP6s37cIcMIMinRcylc6UXLl6kVRUy5DSuOT3RZwuLH21jDQ16RYUAJ0mlfF5fG+YGb2EZs2wcxe5R8Zy9mA2bnFlr6U7YA1PVM42A5DMRFdGxH6ryfIOVLueDE+qcvSBkhzxBUGeMTkTNuogB7uvJ9kzpIz+DEv/dvsnIybVubb6E1qpB372JJC4kQy7ZOSLGiWXaMkS688JBTDEPDxDg5DJs9TfrF+ruw6bgtLy4NLY/QWMM9sTaDmkVxsXKve+NaBQwod6wy6F7f1PSq6rKjC8kEUQMtvKE5U7y9u7Nca8wtrurInvbafacgry4cl+2fGnoO77ePT/qXf/G3v273L37+85989Ok33rz64vWzF1O1ytLCgpGKo7ze93Huwchscfle++h00qhgpv3my5caJ3v5O2X7jVzIMrEztSZ/xu1zC05ibT9Z9dUrf/5mx5p/7Gx5P8tR2nJbbqI7pQtvAkAJ6I4YijFIigxSmGPi3jKSquksQiyGxZ9RA/t91TuWcbdKaITce0rshKzUHNOD009IlWCgLnZP5yJLh5QIUAunyGDI6VJSBcaJVWSkqiSllbWiQrHJ0llim2Xx5r5qZtcNHEYkUWcdPvUaaCEkHUjZT9IochRMLFFQG4SQ4KLulSopqlKLQ2cCGTTNIyMuVbSaZRHCF2OmsFhxFY0WCSEHrYfKCLK0PtHOYVWsda/Z2ak8wOhxQjUp1jeQoWHSmxOTxpIfeWlt4OKEcNLzy3TxhD9NBjEVaxYtYbBS+rzv15JD4yEHCUwmeQmFA6Y8hHP8Kqwv/x25xOMnlzAwFMjoLwuEWTjk8PgKwT9V0wwAUMy+CY/h5Af8bS4KS1IBZlwEAibxbJYRCs3TsyibiDI2qcPAiUJLfgWCQRoMByEkou4YEMJlEqlAJrCEPNgTC9hPXyH55YFWH1YsP0LJDxKSpIMzMSddfh54OEnEAhNy5yfdjC2B0dmheUGotIta8Eyi6W42pidqE51eX4ex17+cW1z+53/8xz/40R968Xzl3truzr6dKrasUKm9nZ0PHjz0vLt3az3sbbO1SSdKjhn1R13U4ZIRMpEvxzLjeSZWshZjXoMOzBlWqxVYkkGpLOEaX/tp4QtOvLG6bvkyfDZHrKCJggNgqG5jSb0eA7jTbm9ibCJuc6t6Gt6tSdCeGl5HZ/DwYHZxSYvCPph0Nm2iAVDTkEtBqbE01NibJuAZ5mzbnF1ASG9dODyEk42QqtucnWFXYKA1YBw9IIrgaiCOwmp+VDO05HHShtEy5FdpzW6qtFzQHShdH7OQ5VCYXGsAStFH84klYCsugen33abAsnjeAG+U11KK99vxLyHGjLGs2szOzjus51We1lHLautxt0cmY93K4qIkofGpJxgO9aZQY1UTbU9fvbk+P/3+d76xMNd8/sUXjfqkTZMWfnGiDVtff7h/sPtXv/nSEefW0cE3P320ODXX3t862t91nQPNtbvXVXOsc8sSiGfg7G2dqFtlHnC73MhoL0aE0evUFKmKzl9EkZWLdEx8MWeEo8GmfuRjmyPe6AkZcvyqlpNVVg8pLRg6o4N+dnzqUmPriqPVipMBZA5/7DEsDzDwE7vqDw8JUw9CgGphoW69BjMES3omeewy0C/59a9/bVoSV4QpCQDf9KiOKhDx5ihaICn6woYZkBzkejylexmEUBQLTB4VjS8YWSPwTCIQBpAcDyURgjrDjQEwXOLnAeMlMxkswWbponNpjCWJkEQuleTEJV+owIPhzL6GWaxhvwmoqN7vO766WdGlmJrALWD8T09HKxK2ElI04sdXVsZDe967ZMUvpkV6TRwukVdCzI5UuAGTLPLra2QSmP2EnMMKo8AjClHhYvmjwMoWWh5SK2ijMQhyxZbxICdKEiSAcYlHOFMfIijFJZZEQBIxPPBLK5V9eb78mVAUv1ic8ySVzJFAMIA5HgBRYcscS4pSYPKc/PDjRFqxPAU+AJDw5cAniUQoBHA6MJIQhQLjZybYOAByARgnYn39BCMJGD9hI3Y/dbD4QRKSNsg0dQnXPkUqnSbMMK8BQ0q3rUMwk0NzB0bveINNeFjV4Vg30zaY0T27GqhOTHzvBz/65ne+Q6lNL9o+7ykrE+sywUYPTTVNj7quQI/JqAWTqryysE9PF5nw4PQEsHzpuQTzF5fTczPPnj2l1NH8x8TlDuPudiYGbtzkW68rCe104mzAcwMuSR2+MQFEm8xU+CMQ4g5RDMZtPEYB+siEZCLDIgFl9AJe97Q7PztzMnH2m9/82v34YdF6R2yTDpSJEN1i1SA7YqSPlnp95sbpMm3IysOgG8uDE6/Z+pK/TNEel2RYTVFYWnJvhylbRsdFdROTnpY5c3ZBO0oNGFCZNdnamKz5aY6+zFBdEK8VWX3hWLco7T3MOr/q7dBY9EZhU5pO8grRBmgAomm5ud7d2iZ8o2qXbsYh6pubh/cfaJx+9+vf/PCH3//4448NpEw1XQ7GRiCTicHh1Y2nuOAhZ4oqF77qvHBv/96MVM01HWxvvHjz9tHairXc48NWt6ycW+MYHKsddC+uK42lD+b+9ncvTrtHp+2jP/4vf2oi/fmz39kms7q+0j01MXZWb0xvb+1bXrLeZDXi3iNv+OyNXoW5tO6sOaGXpH0+eKtp9M0BIk2sLMis3L3e2IhlLSpbJklsjcK8LoEBQ9Fn/X28q4q+9F0ne6g+3jS9ocvPuvmaggdvcduiu1kSglX344iyc3xxvHyQZmqHjg7buukTtcmD/dg9zJ4ipPSjxbOHKu4C0gfVt9ASWNwymRP1Oit7GitFE4pX6jU/rlRQSi0jWfcBC89KqjSzg4VvrR0AYJjh5xGr6KNQiu0VSxQMl3AkgDGL2QCkfZcp4boXqKZ9o59ogS/FSkjRGQUjEGaHTKiSOh2DJbuhWeCrS0cuAEALwM46fmllKFqqqFexwBhkQtcHb3fpCEFDesu/2EoCRhdhEYsBZTzFBsfFmPoKx4q6KW2G+4IRLjl44X5yabUJF7zYFFzy4GfC8HAwpEcsYfEjxAmXipbzK0tJGGcIiT5Vv1AM4PfrFkEFGAy+UJEFGHhIQEhYpffn+gRGRiJHQML5KZBL0uD5E1sGEi4YkAmQsX7CmV8hXOZUQsC+maOMAqbCJDOQ+MkvuST5FZIiSoSJWdoMTJYk5CCPJHGkPjyJX3hIoPRAU61tK4QqczE8GpKxyYV49GBOrs7+2c9+/if/6l9pRdpHR9Ozc5ft2MVfbjbuuhLqcnDIPvFWe39hcQ5+SqmjUyQQqybqNLNOpDZ0ouXlKaS9i+K5dr117ZPaIzwyGBUputu+RSljNhMeuq599DWzp6TgJyusgtHrUJGcooq8j5nYqBy5qlfmBm7UbS0U0lvvdlzl1jvTKg9pyZSzAnOml0l1ghwq5BSZPrqpfxQNeRkLnCMkl6IgJ5yoMOUxSxR1O/UoMWBNUjhg++os1tkUpF8J5+bbN1AtLS8SU2yEV5cHhqE1xa4HakILYyol5JLLi/1LqPCQQ/Ijv8YEqRVWXO1BCn3W6z+7vJicUNDaJ7NtSHsD+YsvvvCIo7PZ1wNdr/poBpSwzjEw7a7STDxyAblcOAN2eWHeb1SX/aLf293bHRm4GtciafhnZne29+bnm9YMvS1Zs1u0f3PUu3jxave0PJFWHbmqTDTOrk5N1S0sLj/94kXn+nhicgpzHgp48Ohh/6JnEG5dVY5S5ai4rKlg2lAqpethor/cG2+C/maqWXdBtKsjtJFT5cUIwPj0ZRzStpTs2LlbdRmRcHvGvF6p48lsKAWESNumhiypUIxSfwlHCCFT3ZPd03/yT3/m8iLyh8EIwLptjM/e9xEJh0uGeRQEp6zJTI8UHiwJSd5gLv7b2QjpzB3iVmmSOQYAJxLhhB8aUkyicB4wQgDTfB6Qpb7cGm7wkIMx7UkNAEDoBDR4rSbN0ROBBzkzNEkUhrAYsSGDPodZ0zWBU/2SfUWjK4ZWt3uqS2G7AO6cuxHF53FW/Z8RW7ALJdseTInaauGJ15hNVnhUQedLZWNEwOCX8UZHsRZ53VpATBTyMauOA2mN4FCVk8wqhjhgxdhGpYIMFOH6QuVXQXj7U3g6gekSLZyZViwPnPAoSEjSjyJIUaHrxcrfEoqna4Nn2ebhYPAzW2mpSNM3kfuy2GKl9aUHQiRJhYMBOVHSik08yPEIVGxGuJgpRKKJ5iTnJAQvnEcgT3KLNG0TJXeQJICfGQJYbMLzwywVD4SAfTNKWoGSSJ6c8IgNyWj9VKP3bRV4HPln1sdiK6mA142CFhIYUFCjzs2hr93/4Y//0GZG+3pMaKLH2OmGHF0cakI0A5f9s5nm1NLybK8f65wKwqiThwHS/6UMgF1U0LSN0lOLrhAy6TQ8YNpXll3SwDSabdWqWgAHjLrCC4s5dNPvlUGPPexDcQAHb7GFxux/WdMOS+mWFVsy+jYf922Z0NiMRIsSywm1CUPvM0cBGEqjk5shdTK2Zlk2tMXI2qDxtRfElSaKWCJek9qEoIIpPgaFcJhgflwhzSNr/KqNi4PMuRvP6zlqSC68eHDuCFIsF8urtV85jY0WRy2/XKpJcbRK/pQFQs41BJbreByGgRbohAOe3QZP8tSNXSNAX3tytWrY1sKGprh5rTlJKYUYT2hyDKri3cprj8JHq+wtNg1ht6fOxw69mP8ujT7cqMThvjyUc3Y9O+MVzcEXz39v9d4eTge+cPLRh4/tztw96JxfDzrk79K4yeZsrHaMTx109o3P/+w//83XP33w+IMnW2+eewHUWnej0do76MxML3bjNoqjmVnXQdfGRld2N3eUj5pDV7Egu4ZHeqJmF+040PzjJ7ddahctuf/qt89car68tESGdPeo7NxXLuVqvFD4qIWDTGEFfttdDCT196kzNEmCYBWIQlFYCkYjbRqNxEAanVycn758+dp7NWJZQ3JQUpIoVn5iD8mrCOXgLDTATEinAaGcYo055UgS5HTbsoqFVO1NikpvE9iQwmIkw06WtxBAKg5TYFwY8aHQNH5E9cnoEo1iG41RkIMQOQj5qV9Ibzg6cDCTnrcAKZVa4CdIMKJg4E+YoHW7zMu+UbPY/1qrxgqW8YD+Dc5tgKfSNnNiJpIb3JeDAkEdbaEFKCygDAfHxcrgGDcC0eZHNX+CQT45gM7Pu/CUqSQ8onzTCZEcEqjA+4kKB0miRVGFBCyWy1Rf9UtSaIaB4yAHH5kpjjQ5yHHCAxJ84kkP/ElRYHKepBMPhMBImZgwmYwJEcvxCIQWKV8kwKe9IDdsgAcmSvn5iRaAuySSC8m8C8dA8imEwwYkPMBYRsUGJvkvxCObKTTf5DyR+HJSQQg/T5YCeGXqK7mvWFHSAhYCEhL+JHGHEKTeunu/mQ8b7GbnF/4f/83/84MPHz9//sJI3p5918wagcMAuaqrgjFGkvuii21deB2rFJ06RhRI3yp0UeXYcFybwEnJd7ydYlrGY5AWSe3uVSUgZ80BSKXCWELwvhV/5hHPkONfKYQdNAWcOyuuHOBq6Vq6qExDZZpjbmEeCcVBy3V8JMk6DxUJp2RS8gpRdjAvC7hlCqFCSCpZE+VrBOOQsPGBJHpbQuBJ5CDF4hNj1reto5qRh78+2WBhHJsCiVVsSIiKrMEpOzQNNskRlXEhfsJjely+YIPEXkls6FWFuS9H4WJtcHTUBgcWQRQRweya8TxnYATAntpiK8ruX0jIE59IwEYIyHW7Hesn12e9xw/Wvvetb6otbpMmo+299lit/vDxpxfXQ44P2QajdKYbTmkcGwSMTi78/e9f/ae//OXf/e754v3H5zfDv/n98ynTeTMz+zu7ugJ2bf393/xiaXF2YWbadbG2AeAZXflKBlDHg6xpI9OjtdeKqwkzzYbWlKmgVKSko6AsZFASnlIKzv9f2nDM2k7VlXPFio5xg8UDqTJrSYiE2RghIeTBAeceIPnO977rShJjFLUMfjjJRy9ElOLw01dyhIgrZUVQQqhKFrSfgEk7S1CUVPIiaywCMLEUCX7JYcOAcqFycEqbupqqq5TVskhYHOBM5Rc/tsVKlWyIgjmVkyc59xNAMiAQM0Kg5ac1CZzagjQnCkxSkRAJF6RIjkO7pUUFLhwnQ/x3Ki6HkokiF3gRSAepjUAGpHEF3tWAnX+uO4yVPBe6lvAyhTfmuIgy007LmOSwIc8hkTKSSaiSOj5Q4RcCBnBwVuazMMYvCQ9Z84CBEG/gM0om78AEJhVIMO+nrEIuMKmgKwoqHoEKJmEEwqwAYBOr2MQilxQBAxOVSWDmz6orIcOnvKFKEtgDBoOfEsLAQ/TC+aXlMOyrqAD4Is3BIBAk5KTNg3kh/KI4MNhIlgSiAhIqmJHwEzY/seQLEowQGg+VEHKMEU0pceHBrQ27OlWFQ7kWZWXP5sDv/eDHC0vLphTmFxc0GtiQWR0oh4wcGdNlRvf+/XW6gBbq1IY5kDxnJ0gjJezyZ8Lf32ezYgszmcgsYJVZ99xgQU02THCwynlRoqJurIkTtqE85QgF5HrTjk1ZbLYThi3Vrim6eKDSOcZhLw7FI7h7B4f7raPj8jqQritrYqXagtjBQWwEwhuG0YXTT9KgP3LNkV8QvdGGaXWs4kY7yI9ZkWTsPpxyJLlKusddd2Ie6dElb3Y0eR/NvBZJ/uxnP5MmbmMfig0bGNBFZMjkemtr0xQEQem/2d6D+b09zeWhI3L6Z7qK+u/m0E106Ergs5S4kj1XOjDrn64sLTiugT3JsI5bzChc8jSCNzCqN6ft8nZdx8q9WJ+XL3JWCjYOxUHDovMYsFv/YPNVZfDs4qTT7+kIh6kyg3TYO/n8+Su3fLvi235Z2/yPD/fNp6wtLT744OPuxfDlcL13Pfa75xv/+Re/NhipNma/fL2h+s/MTl9d9MeGb8ZHhjp7O5XhgbXlFdmnioSMjaBd6g6Jkb+aEtI2g1ZGzLJmC6pN9QYZylcXwfVwqSe4jeRxjNk9VHahjpjZd9DPpMXiwoxLSV0FGaPDYp2QsMOGOdD3h5nYUZ+asuZ/9vrNK7bbiXJCe/78S3MpxKKl19LY+Eu8ypsF8+QyUyZHqJMJ9cj6RXu9Y6zqKRTqrSoBwJgMqlBpIVEkbSWu7Ph9QWJJqkBeGhLYYMCYb2ogzPwKiydFJDuApbqTGEKAsYocYL0TUSSDhBA48Z/8wJOYhYgSiD2ohJM5NlRxqfBppwa2aY4oMNGfkkbXXPq4RzTaIlNsYeBuy6AYSqxwSGM7aSCD9UyewkqGAo836IpNAUOmvuRSvjGu4ZcQeZkBLDwTChfi62f6ZUBsOpCKLfOZlpeUgYmFjYcTwkGCinB+uZDEpDA/tiPDpS31Mzgpj/+BlBYtsYnKlxMuuSEXj7TQfvUr43p/EkJIxL6p3xLyQ07K4IkeWhi45I1qpuhhgFM4YE5CkBw8Sh3vwAoDoTogOZjhBAleFL8Q4QVBYBCCJd8sO5nyE06tdbIqil/xj4fBDYcfd0SJRcV839a7/f/qT/7rH/zwx7v7LRNBzg5eWq69vjk63MHqec/NMR4WOXVMR4Uk+PZJh70mARhUWEgwhi7GdItS+1Wo5NYMrI3xaiCihvzw6vKby3bgS8006ic0fX692puyLXp6qi43+rySgy+mc49Y9OBkmTara2jdDEeOeGZmm7vbm0znaf/AHI0jQVGZq7X9rZ1xdyDUJ8+GYvSA1eRNpxufEhIdM4F58L5ImKWRKXUPq4CBgcGGCVJTECNDUV8QApPFhH+Y7XFSlbIVdFONjUkPHz168eUz3ELiS4bsI1Qkr4zkF87BWoyrjNa1v85zISoKjH6/RWPHdpiGsdFxSwKKVxIFiqg9e9YFgLEL2PvmN7/553/+5yyUR0uePXumvgOLhJG7UAmkp7y009s6ae3Ozs99+Xp77f6D1uHxNsnXpvb3OiOjVdfcnR63h67Pl5ZmjrqHOnObu9vMlqdXjs9PzlsnHnJ1p8d8fXJ59UFr550eh527JtXceff6xQsvPq6sPLSHyn6BVxtvZUrzxrwz+TRBG89KaozJAW+Geba4rq4sGl25hJxYnF4wcad1ZEFVo6gvRXvJSpFpDRkvLY1dt2Ojgx4gs+xvtGrLT9wXXd4sok4mGfpxgWgotkTaVJ0PdYqcjTeVl+s3lJRM0Si9SgIEiR9VVexErWHbGPEqX3zy6O4oO8MIuiGEhDc2NldXVwjnON4DGLcGS7xwAsazAsoMZiFCHhWnTA/waI9RxAyBWLiWUCohigm3mVOWJj2K1XytWFH8OBTOSYUQbAIl5PzkdMYAa3UBcGLBYEa+iv4GHsl9OZAAQsqkwzplBOjQyPc98aAWS8+xIxtGwIQubTFcPBGbwJl5MELiQrr3DUBuR42cB3SwlQ55HuFEI4PgQ11KpwYGPIj1UypEfeGXzxRuhmRNgCd5AI93/nTlZ8gOKoeYU8oSJk4IOZ0rdDl+1OURP4Wx20ZLlCoHoXAIeUrIrUd5KEX4My0NKEYhGudE5YucDKILLQcDtiVJ9RIiSghIgTxUDTPqrdMtySoqEIpNNtgX8scMj2/ihOR2208xMRJmLPVwHDvSlheYYRY1VI3NyDzyImEo6HCMXvU3zWkvra09/OCjMxPX1wOLi0v7h0f6VvWpRrPelIQmmcT09jZz6A4GTRX2zPFbOo7p136Muk5Owr7DZuuFpgUtVV3lQV2fSw1liM3om95xMiAmb8/7+tT9E28KxYwNEp6BNFLwKu9u52i62aA6OmCKgYbbfQej505kzRUogIndfBS5yYIm2QvrxGWLer/bsz3C8gDrYNzA8BjckDMtUup2WMq+CyTivLndOBYwTGXYl33cxaopeB7SsUjLT4C2kEdOSwcwFisMdvvOal2EbanGgznbW05pdZ3dRcL7w/q5gCE8OGjxoJUqpJ0g81Ljho4ODiy3Wz1m6PXfXbPjGh9dehNZ9hSR9tLSiiYKq6RamQy1MeaAwdsAYnf2oy3UWJp6tlb45csX3/72N//qr/7K2sODBw82N97Yr6WNZFLxqdE1lebw6ty0x9oOHcxdmGkSJeN4MzRqM5URCV2Ks6UjAx4OO3co4PBgaW19dbRu7eTs8sxGocnqkONg5xutwbXKVcXLoBNeoZ8YH7Ko3+0eLczObW5smn53EM/Ir92LO9xwqA0zIJXrwfNL03T5LJeiJFJ6NTM/Z9hkco7EUpnpCfjB2McSdc+X9ORXL9x5YScVzPJqPHUWTqPLfmXZ09l+lomB0QUJQtI4+VY6lww9bcwVYOfjvIhAmLDpTQqv1+chd5GBUlPLhWhNVcPDXpzDKJUobppSdgJBGrDSjqWlRd0FLRkFtvs2qlS1Zv2KqsDTmKyDd9mHls8CqkDs0LEYasfYIGocVBycfkqSHgrMBf9Rs29n0akrAE7phzl/P0FEsAQFntDkKOp4WCcdCKtoEaG9FAA8wRjUwP5enumVNqwA7TdJI5/mcIiG8NDjwQoIrPDLAEQcwroqPGJB8iRPIPnh5UG4EEh7H35IEEpPSRg4MS2JKGzw86ALDEI/QxCFCtKihBA92VFlUVCl1MBziUdg8pDkotqUByaFQ6IC4w2wnzwY0Ib7CZuvJMJ9YcAGP8efTCZ+sVyGS05FJASAim96VLkUiJ9iics3XVJPJJIkqswmAGgFymAKAUV4fEX5JtEE4xd1hy0hRRUWYj08UwlBQqCvZSgeQiATF2ZKjhY8rhjDQJ4D4GFP7y2tf/1b34ZkdqHWnJ61xugmHIufg+OWfo3db2x7pJQmIsCYG3GKi5xS1G6JLYzF2ILeB4dlCR1dNpWa7e7vWQbUDTSG0K9Xf/TCWDR1SaeeBm5tbK7dX/e+rE60qZi4UrnbsykiUKWI9GfLLDz1FAInA6deaQYwb8jPTDhiZfOotWwWX922q8Eety9fvtIz1U4oEUximJxZKH4JoUKCTDKWAMUSCKGltIVwatOUZwXPvT2tWXVc+caasHp+FLfIRQXJVPBQNhoCv0CFyqzAtrKyZGKKNGRZbJobnJh1YVBcKOBKIAbKueUkTQj40X7QfCub0OoZON8bQ2F7gspC4svXLxx5w6RBF3jvbT37/RcwU06BOZgwwaLWIGT4Vl+cIQT3dZs1QsiGyunZpd5xZ2aqoXY5IlypV5sTY72uE7+xkrTYnLsZHmu19gdGxgd4OleWBSoj42d1+2e7q/NTnf0tL9I79BDHiseq5t+iAXjw8IlNSk+fOnMkp93jznS9MXB5NjM3t7y8pJlkIrZ3BgyYjrvOR1+aeLOzxPybUyZsFo0lJULIfqsyIkaBCsSKBzt/HAcCh00DsuWWWmwQjSkgF9/HTaJ202rpdWGiw4qQtIrYV2yMM4phIT2Fq3nQwafPxqZ6D9KencUeMK9lN5szypQEOMVnRCjhu3c7ZpMAb2/vSOVx0413b3g4JYUCGI424hnDqQ8KQhQYnsyar5DUQLrH8ROU8Ih6bzCFwEMzIScQOpqiECIKNrTkwvWcMPgp1myqthLPtNU0kHDZoUKawMIGuhgLin6y7q51NoCJlsmfemKSOJi1OYDH9vmy/weMn7Dj5bpsMwKCJz14nJT+enRpxRca7zeKpp0a+selXQGyBwbf6ZFETqQVorbIJHbvajsqhWZYNOIrQ/6okOD5g82YNok2gz8k596bspIsJJnJfCYVX1TuQiQp6AXfNgN+ZyywDCyMxdAnUBeRZQZL2tuugcqp9gJQr/APgJMpJYo9mZIjhURc2WAI8VN2IASjVkslUCy6zKJUMWd9ESMeaMHcMSqh0pUQjNhEixwkvpIHo8UBCD4MhEvH9v2gIaQn3ldlEKV77KeOdYSbt52ofe9HP55ZXPB6n0Udm+v1DBh9k/dlj3YPWswQvlS2jZpytYCr82g6Ag+lm3JZb47FHGs37svtHHVJjjWMa1mur1eW18xqldslhhrTTVVOrnU29096dNRkgp7v09//bmnRpfGLsjM93dze2HSTRAiqDBB7lySGzdj5x+FHI+G6BfzYwo+QNwC8k9dqd21VjF1GY561GfIUTKz7uSZh347WI0Rxa6MNltwXT5KKgMND9hLSXN6VEQ9N4LSUemwn3WNnlxkv7UEcwopuRKwW6E0rAUWptcu0qq9WZ3vnnWZSiGbza48e0o2//du/VXb4N8NNhiaknSegSGFn3ber92pBT9vcj86EOQzZNCBjzQ0OWkeH2Maqr1V6Mnz16sWTJx8bZtFRezJX15YF0kZ5cT8df5iNgeFmY8qNols7B4wg8+khaPcUPX32AuRp98zRC+ODvh1Zg4OL89MSkJAL1J4+/9tPvv7NsqNpWYmcenhytHrYNXnXn6pcH3n9baZ5sLNltarTPa2MN9xH0W4dvvU45dKC1n3kxMMP0ZQywZZ3SF51sERFCwhZj07fuTExbvrd9I4NaNnJM67DsuKllKyhnbYG61Kd2p+ztDg2OnV1fuVu6/5p9GttNqLQEqZNsMndfqNwRc9VKOGaFo+tzc+qoWpfTEBlLWgfdZxtrMA4ZTpIhTUkcg6ma5CgRnQ6liVqSiq5IvOtrR2qqM1woorJdO5BlNJRpoqDhgD2EwxrwSMwQ/jlCF0SoCF+Kh08ZoifUaFKnRUoRxJyAjEvIfz4UfcEAuAXklnwFcKVFGHW0cwurg6LsdSISh4Xa0dDQksBsOcmi0ry0hVSEooHRioaZMoWbOhCbUrbJT+RrLRawACU2hfdUi4JyydPcsOfwFlFS1neAgvJn4kBZqyTQkJigEdaMCkOX4G+DKgvJ1YDi1ZST0Lg71yCJSRZZ0aoHcxoSSUJDrn8CRIJgcrPF4AQ2ZQwZeIr7R1+nkSV3MpCRkEoOZe8gZFQIGwwJxsCk6UsMGmTOkh0Ew9IqXw52Agn/UkUWIb7mZwI4U8phZF6v5zOj0qCZab0ejjhEqY8/eSHECcgveLyr/7tvzX94i5ieHDBCmDYtj8b++1oUfYKErxLF9wFSmPU0syF5BFeusy01h1wScjMPhJCzGbk8XL6DHJt7Z5nx6XSC/PTU1zwmMh2wwStnW1Om881Fs5rPlVxYtXbOT6yIOyMVJ819EWOk3dNJnJq5vHJqRmYuPby8NAyhn2QLheSWffg40FTrcbqwWmcpCJb2VQnBRIFVHACoy1EJ+/qPPYA4FO4mrK7s6XJMQxxmVKuYcY2abdRlLu6gKHFqVBQ6T/ZSAMb9oxU4FGgykJ3EjmeULBREwKhk1IZGeipgWcdyAQDHJ5ZMW2q275waMpoaXVFi+KCMz/X19fMt1itSGXGIWnLlKxBjnk/8Ya09j7ucKw2PF7SMH0x1UBieWneym1tzPsBFsouYs+j2nEz4MboSr3hwrulxYXZuucYww67ddi9UC7a+eLFxtbe4cXgcFuDYcmwOtG1ebQy2Tnp6xCgJSMaWnnEv3KHk4S1NJiXOzk1z84jZH5+bnlp0QGxOJFyfUlKwuWLYFKjMMkjL5zJt5Nux+GV2emmYYSZQ8polcQsU5iqPJYUVyBEz9VttYiSDGNHN0wFYQM21gNCfoVLXJFuYMDquoIwW6jJYUsdDWEeLFOSZDRdxaYrAjdgy5FOgKxZ6RcFoezQRqhgxjmXtVsUP+TIZaHQcD/Foi47An2jaIp18hMkhxyAgqn0EooEBEqbpSlVIkkMcqeIMQaP9U7NR1GGsqxbeqLK4g45T/HfdhChiukdfbfs+ySNxJ58CMH3HUkFwy4QwR2k7MhIaeEiA7Jtah0NybkUQQRGixJ5lpArP2OqBwz8aSzkATOoFxZjiCQWTiEgFVgiJGgFwA+P2MhDkYhFU5BCJCfBBIA5EWYIujzJQNlkEWMxPyUBmSWEDT9VPGhvhxYlSXIVOSnNj9ql4CkBPZNQhYcBNk4uFEmiRZ2HS4+MiAIPTAgPyd/lWr74oVIZRMmCLzZSjJIk9fz6iSV+MPnFgNwxVZKgAo8pKJ5sLhPY7hkeBrUwGf2ITCXw408/8QjtUe/MZXD2ksdljbYzdU/d4eXsvmrmaBXTQ8lshvFELj+LYonZlEtuww8VtCJXqR11uq7Xt7Kp1BjVrNhbuzvwx3nccv0ZJnsnxy5yI4GF+VnrbDE173hnjOhjjdetyGp7PW7FdMO84o7pGr0zpfvo/gNba7QHjGm9FvOzVnq8Mem1k07vxB75qI4n/aN2z0Hj8aqLwNryohOuGnMA5mZnjHwtV8q+0mGM1BMy4TQPZMtD7LqxChpdhsxURrOh01phSGK3uY2M7p4YC4NlwsoAQWVGxXDd9sqizJfu9Z+badpvoF9vF6e9Jp29XXc3Gu56MtlptVb76N69+/rp21s7K0vz1fGZ/pm3bScAb755i6uVlTUNp5V4s1xhhY26vEJ1dYlb8lcQHp1n22OWKS7OMBt5/vr1S4VlecL9GCbrXJRtsEIaFlXn19a393ZrLtasVLbebVpmt5jhwZvJyboTAG7RG62MO0XR7p1X6kNe/mlMju9uvTk6Nv9gOdqZ7amByxMvgHX7B2823339w9UdixzuRqo3O6cXw2MTJg6Ups3/hOzIGO1Syu52YGKwwa9YCfPyKra7UG8LEjyMoaUiU4mqu9wBu9PwUnVCz4GZo3Ifp1uI2fyYS5wavDg8ZgJMXbvpzwylolRq7gIZGvaYnRdxy/T6tSWQtkL0FojlErZH4VJLexB2dg5VBaff1RT9G8qOJT9VQ03C7KzeErJRATXMMK+uLqudrpJS43QtYodSLN2HzUlrY/Rp3Yjw1Tg8W5JI7VI0PBbGWJXQkFgYOwUmIVQwEBS/XKcHDI+8Iw2Yx09GEBVR9I3j54p8wgzyg9E1DhM7SLU9TmD/XsxO41l8sT+l7pfjn4mfIYg/6UXLIY8IhZcYMcTjiw+eJGaHXPKEFalK7D+adSFIylU6sXcOZkkK27fdRqZTwZCx8BQKDyq+HFScnxDqQ0le6n/c5a12QZu8+WIvwaL4i0B9BQLLDgUMkvNLxSNJssHjJyrIgc/YsoclFnJjuqI4yUVl9sHz41kRQgIn7RFFcWUBEg5C4cnYXVqYEglVEJhZ802/KBZLrQbG6OBcclwhxInlUMlA/sQGVZJLWiRDdwVKzoMHfh510o5J+yXs303eWIVzS4+ee7wqu9lc4zM4NLewND0z755hV+laVHPxA05YWOTevnurrtIk/SnGrpiUkKS8N+qxuQ2r2EOITEzuexBmZTWmvOUPjDvuO+1DM7dKXF8JmHGGiWx7BEwOmW91r8PXvv4Hbp20YJtHnOxG16PfP2xZ7WQlScnQ1Vd+caV+QosxKsF6Ftvdxw/Ts723Z34qzh4Nj27v7Tv9r9bliIGy6YRK9ebV682NdwSuZmKY2sAmOTWTCwZXFRBCqn4qaA09lVlaWZ6amQ2i5YJ7eWHZ1ev5hTkmjCo5z7C8uGCDim0q2iyXW8ApOTzEboXDkoaLLU12mFQxxHG3qJ0wz7/4vY7qvfU1y+Mxhz0+4RyRotQOWWCw22rBOeoLq4iX3maRWYbEBNTc7LTe3uHe9qtnz96+eOFbHRs1/WIL0JPHHxKIbvhBq4UBbYYLhLXTtEK+nD3jTNyZFouFSquXzESZwrahy7IqWU1O1N14ZJJdSSk4Jb6yvGAMoRXccnt2pX5yNXo+XP/85V61uXQ5NG7IaGtSszRFKLLQscG327Eio1VmyhBVoNTGgg5sWTGJnVg8y/PJxx95yQB++28JxJEq4eQMFWdDl7MJaoxmj3qYmqZvrnN3qK1W9Wb6wMWZRZkzW0WhlUruQEttN5jJODjdLWpkR572KagUHoWTQeWuG2Ajr9GhKmYhunRWoi6TIUFRs+3tg6xZNhirR6hzeFP021vxkiUkXFoP4XJEqThUhEMlCkssgy/VtTamQoXmlBEeuipyakgqW5KTQVF5JhdOeLKKkYaf7nTL6oZimk0YOFFgzTggTQIcJEqQWGCQFnzMppWmBaFgu7zdYyPAsO2h6glrcaNHFidp44CobGD6bGCwfxLzVqaD9VmNbGQAdgaNrSzXJ0cXXtFiojEVGzkwAjsahRbqYbkKAyERtcWwWyCbUqksMJ0aWDhlJnaG9M5tNtejgTLa29GaxrbTCXOf0seSjJCynxiAllUCCQ8GgHFyrgjlXG6tTZEy20eiummiQk6uAh6P1lWuhcjOqTuZoVZvT4J/HpYeD75aLWwb+MAsV9FeM8FlAoFiiTIrza4ZB02mfmgVyqEw9qPI/BoAKsiZThZFdmSrHugjmLd120kMcJEcCk6iX1wmCtGBXKYIv2QruqVC5EugWAj54+dJWWO4CmulRVcXzCGX2BGnFOqNWbft2zdk23ls/T8/uybYgauxAYb+Il76659/49s/WFh96Hna6nhj/cGk6ZfNnW1dfjcwDo0N3X+4TlBvNl/q1vXPe9Q3KnkMUwa7p6ZwQy/ZI6UgG4RdNf44OR64PHcWfWy0wRi4MswVzTpaZnbJhAU3d6HbddMzaB12AqzdOYmLZYaHm+5vsSY0aZpSI39da8YS1tFJV/1szk2b9B0aHeofna6v3yumjGXxXqBXKEboptfD55fWbUpyMsBUsl4eIWxtbms9la0bB+DXDEyX0duoyajBK08FmCR1etL7JOZzxDVnnOzt7h3sO9jVdr+aA8AT5ugn7PQfq0yeXg127V267hM7OVDUxbl589ReY7eb3XSN4U51ZKDXPeqeHCu1Q1dEDsccY+mJD1+cnA9eDpjsYRlZqe5x22ySJoSmuWFn0mT0oHWtC1lenpuxP/L1qy81WivLS072P3n8SKa6zsseHjJnLoU+OtjV8tr8qNyfXV569zg2al+5v3oexah3V67Wia0v3pw4Oe14A2UoXiwfcF7rtHuiv2TOTYUdqAwz0Db+GjNSVArUOTy0N/+kNvz4o888HdPvd2fn5g/b+y5WOhsYb19MXnUGpqrVl7uX92fd7NQevuhA7DSy1Z2b3tH4ma2f3bGRKef/piamjztHBqVMqt7I/t6WkjWPP1R1+WBdRT46aB11eo2pWd3n/bNjbBMsmZtpjJFBZMMIfdi2LpMstujruQBxA/nSvKtztzwJ4CBHZXSKuPQgKM/29q5WcGSg5rESl6FfnEV34PzU1qO+boSJL+Xy9OnrRrNmkebFi+e27nz/h992SRwl2d3d+/TTTxSrttbtc86uID89rWZPUFr6IyP2qlIiltDymCQYtLjF4wQBU6OuqmO2q1mmME+li22kJVzLZ1T5bmMTvJudaKZA7Yoqj2clqGpDYrBof5O8615JzEjbUQyG6WQzAn+cXLlddPRTKlY+KiALMmqzlftALphTVOA0VajJNBc6aeLSqmQ5vmDDroT2s8ZaJVkATcuCDNELdAgJTzx+8gBAkocBzAwThECObsHAhGUIPBSIsKTVlTAbIDYdRsFAiAo/bPyKX6CfXBiycj/fbWbKxgz4ZS+6D2UU4gsSMwKJAwnJQzrF1CIEJ4CUpiiofEESt0DmKZNjTzg88KMrIbYhEe6rVESxL4A5Ib5gfIX7AuPJfPGoQniIalYEiAcuUSVmbPgpFlHJU4Z+2qaZ+eKHRyq0JPHl/Lzzi+UECoGBhwCFSA5n+8iSWtVPgXIKQBGwdErJdQPRtDOQo9XYzqiq68JURnV+TYLpocvKRKN5qjd27QpPy7cntNd0p/9KQ5fvFl1qDGwMiS5kIdE62G9Oz1UmPJvlXal4fpCKbJbd3/WJamzJ9yxw1X3uV2yZhUclFfOk5zYdjTLlnBO2vvK0e3CgaPAva4YSdE4mZVAPSNfV3fG2DypBu0hJWAcKKl11fvmVxDFiZcfvtFggGY1bdskmBDsQJQWfZWoIjTpU7JGRbZdBxohc6zLhCZHozWCAoKAlOgKELflRBHSYxHSZjQh3D3bnF+cdPYs72oYHmWb3C8mpUTVN1rtfcLh5pmFru7s2XJVhzXZiom5anckmcA/mwM8pHSE66Q8ertu6SkTI6Aq47sae9pnGJOaJSxfBTA5IU0auuzg97LvVgJWU/Df/8PfWeYcaEz2L0uenzckJL7YYW1guMZwZrWndZDAOvklOw2kgaevUzDZjjoWIFASpbu3syqwbjQHY+AESciEGKEe2wzent3f3YjJHvbg+f/jIDNKRfcO2D/U6hzcnV5Pty+rQ5aKjDN7eOdgbGa+bDFQcJqaGuqeq+s3wVX2i4f1PBUFVlZGaRNhWfdbWfmRkE7sCSr2giMrIiAR1HTV+nujPlrsMqbZmwE7lmofNy8kG+dMpp2yH7Y53X9wAQsVO93e8/+PWCu3Em823k+PukFCXnTvsVTyJyCB4cOLm5osvnpn54yEH0qD0bzfenJxeVCvDDx8+EEJue/s7+pTULMsLcpea+ylWCCUsQ7TbDSO4pSpZi8VSGI6nZCGsUCiVTnrY1+iDSw6A/AmcZEAqrDsMPH7iVgeRH0Cg8yJFOV4a9lBQEVeyBxIqjOVPafGDGY71R9r+BngYF2D+T/HA2HgdObmjreDFiShxNcn8RBe7WRjhD0sYNQRJYJhAVXgxJbfbRhNJ5hwHAPjBJCF+gfxCSDnQlfqQqeTST/KS6n1I9LtZogxHN/OWAPzCoUoq8p9+aYUnJIrChUA7Xok+Zibxk6cgDwAejEmeAEldCAcDSN8EzoSYByOQI4dsRTK5CpBRwsXCkNgwmfwnieDZKxxlsigBkh/hyQ9ySdE3EZJ60bRoJyCBnIczC+z0NXIClSMMODEHahIITuODYVdFGmAMWFqsXZ31TDTY7utOR8+8vN7cbR22H3080emeXL7b0X3WnqmB6p1rnHUnGT51+KR75hyPi2ZNRs9MxW0/wdXAjb0mnMbSZI7jtEhcVm4PXpitlffmzKyd5iYlHj35RH/axIIaRETaEnwazyNHCBBilWxjX8dNnP/S6fOi072VVS+17m7HxfEAmDMVz8VE5rLVDmJX0nrpsltvTO63TyojlZ2jA3Mjtp9YfDXi02UzNaQPMe0qgcYUVo1abvpDrE/TyuZQnLcc8RBa78TZBZO4TLhGVndvf3+P2FdX76HoimkSZr+MZnTrFpfmDTuZD7fAMBMaAJzLbBQc5lxSV+7MUGEmqhOGKNXlmLfUd5dr89fOiBktxV1vp2e90z39esNnB4Ltbd+3IDl45SoIr8aRgw2O2nrd/7OLeD7l/sOHRvivXrwkQOelic69ENoGZcd5fkDddNrOQjKB6FdrekF+97vf9T6BVRanf8ncGMXdSawwlqimjrlT34oANQAKwlhHV70ytjzTnPz1r/7Bfl+P7RisjFYnHdoxmrXYrJBk1rDy3c7hyJz3Nqtn16fGnUbQI6M3o564O7f5pz8YT9JVKMXavXuECTn91JYriTBMdZ3i6DLST9sdQJrbCbQGLFw52ZvKzxTRc+9qCbacLZDFNWyLS1LbPRfYDY5WTB5SG6VAT3wdJfEGnB0Blg8UutzpEtknRoW0K8woC2GaTuaEKO5vf/trbspwxd6/+3f/zgrTy1evfvrTn/7pn/73Bo7FLkUdVOLYIEMOJ1iNMipOLCdWdUCd/LHhm5CigqX6VGSrTAdJxCP7PJLIEY/kvvzSRsbLpRo2QRjBuHxIWoFycbC3J0dShUzOo7+i4fQTtkyYqISgDgafwfn7A6rAhITaw5i0efzGbpJHRrI7d8tN8B2TU0pOerGA/ZRWfwrSuzwDkISImZ5EJYpLhiShfH6iKG2GC4FN8YMhKfh9IfFNNviTW2BohXSKlc/whIc5hSsJGGmBgScsVKgXxoRwUglPvyjJRYFPaaS6JBhI2BI+s5x+owRJdNMESiUv/IkQZk44lx5fUahIi1wG4ueqH3m8A+MRK5t6eXcYJJQpXyGKE5OZcZnl53CrUklLXWBDBSTe7H+hIerTwMQo+wFSJdcGGaqbFlPVmfK91uHJ6fl3vv/jf/Wv/6+V2lS1NuU+Z7OhXnw3qrs8MxnoMokFwtQFvuiHevHbFcrOWlszq6BbRNN1VFwKEebFFO3w7cX6+jvOZBnwdE/Pd/YPLQ/PLS7p+zBbsskMYVIumNdOu02GLGmYsbLLSx4d2nTRGDMNhtKnBFAHoGdG4HrcUsHG0R9zwI3JCQvNz3//+XHvpDk1c29txcrHzl4L8Nb2rinc+tTM9UDbrpWw0ZUxW4rseWYuCY1sIYlV7qiNMUrDIdmiqPXSfhgAwcMWGD+BsewoF9ZGo1AuYi5OJVR2HIY9++v5M/Csf1oNQ3u71x2cq7lrwQPrI0PTM9Oxlngdaw9EYVWwe3Jo6dv0omsnLHF7XdLEtzV2jejq7Dzb9GR+kQAP20fekmzWawq6ND9e2d179OC+FjduqLu4RLrhNp/JKcvA+KEehMzGme5DiBpgTDdQLggW59oAJQszscu9E2HGVe32heN+hlxWX8mHLbKt56Y++PbdptEk/Z+saqw97Xi9f+xab0PMGgOqykcDMHa7zEZ6MaVk1qLcgmfDgCsH5Hf/PG7pMCkgC0rW9IRdWtQ86kJMOcSqic38OMQSrz4kOYeSl1ovXKBrQQw1LGZstw7PjnUggEQFoWKw2EMK89HRWbMZk2AS+gmg14ujzn7qG2iP5Z0QWodHDtC9evGKqRBIRC6TIBCG0MZQnXXWjOiSB5mSe3o4XB41whXMyScxJg8Ck0kZFEXItIKHjoGRd7EQUjDhykigkEyVqPgBCPfzjoTcyTj2BCIkFgaBWggw0PoK9C1Ci74pSAAZkgglR0sUDLdDLVyCyK/MUFnJeBKXb3rid3GiAKeTMDS+JIGUrFMcqPJobAtw2msEY8lXoRMiPyESnT4FudE8TJMULmHGAC4B+2r+fblEDksy4Is6SAmRA8AvLTZ8pf1qpqTyLPNdCE/JSrQEUvlZKERTnD/Fwglz4gEgigMmMAnxYCmjhGS4L5zAJPQlnCRxl0qgEA5LYCSElh8eeUdUZeJPmPyC4fiFy5Y//iSU4YEnJg8LXMmOak/SMDeb9etWxzYC3MCPkPXG3d1tw/2Xb99+8rXv/Mt//W+XltccqmfuHAmZasSrh5HTwbi5zNtK+p71++ssCDHTntKHGnb15tDN+JAXLM6iF3lojquseaob8bN9fG6Le69rjbdWbyzfGzXqd82kMwKca4VssTSG0ptLQUGubig4IRxZ0oS5yoyXT9gLDkvKyeY+sQ49MXxMqm66Ipop94/KeS9ux+k4mzq/sO7y4HfvNpyw0gB845vfihIbGLLj/tL6lksUhkZtLzo1xDEPECeZz415ZuejUXcNnTzKPhI8ZIIrou63u14ZjvNSZW+GYlLfLJ5h22onP5W24IgDS8B6nUrKPpwyr1IV6Dl5/bFxNx05slSJPVpfvHixahfk3LxFcouf5ohMFo8cm0C+8HOgHkvcZlTuf/DYGome7OLSyqvXb/W91bWYVTvc10J4f2Z31xU3sfG053rUa08/TmaH0skyMtnf737x+W95sF2fmo7dXadn5fIcq1mDKp7Gwz4BU2EaNjYxlMod16cnx962tC8onlYeM5VMIPj0X7NetynMNWhxnDcWZutuKN05vqiPDTerDlrreXm6Vitio+dor2PK0MvEsdSpoEc9EklEZd858dpBFmoWcx1RC2IuqoySPQpnNqvY/7Bryoh6h1pE5yYmN1gm1UsNYIdMBms7jT8DrfnysbAqChcSpaCRIBN9kbrHZKwVnp3NztStuhMgzFAp8WBsdOjzzz+3O8DFbn/3d79U4rrg//P//L+YaNFrglPHDDn7oPBpIlEXlKyUOP45qDh8cumXEQoMADyHf2A44REFJj2iMnmmvfsplmMHUiCFn5igE0ieSSuRFEAX3Tp3HHMtScvX5I8BAOQh3mJL/ZCEpRMoRMZjVYFMQUAtcRLL6EwJexJL1GjLEj/B4Smx8Ke90EgK4SCUvGT+tsVGKLmXloMzaZEsB95PSfSzkl1pk5YvQkgICe7fW2oeeCQRmEnyK0S4VNAiKpY/wdQQIZmjDIdWLEcW5IBDaAVihhNOa5OTAhXGVUIYxKqEIBGFE0VMSu7LL1Ygx5OE+JMreBBS1yDhlxwAxyMcfDrAXEblVxbAoOgnGMn58SYcthSREKky44kNw/hEKNoMo/e4f8eLEI7tHJtoP7Y1Ynbhpz//+ez84vbuvs4mYav7tQlmbbjeqE3NNCyTtrvt7T0bcvY7vY41WLvGvGZrMkTbUMrZJEXMnmEGUdT1vp+/eGXzheO4KoypmC+ePrdT9MMnHxtZq6UYJshf/epXdwN2DQbpJf94VhxypP8Fp2370NoRJONMhnBysIKqTQImCdm6koJAbHqxO1spA6aQKS6toLOyGgznmaWFEGnWn2e/daDauIbBzlH9VifhKZTRAGYgR47oKACRYli+0KLhBI7D7FMjYS8T9jQQYuEnaqTxIHDRYbTRcX70VlY9hbs2VptUYJ61nZ5foASm28nKiqWZoVbrCMWDvd24PODqwpFaubMvq9Gc2W8d2psvlYuVHz7+0OgBeySAnFU/rQUJWCXefPt6Z+sdq+1ksk0HZqgcrGOqsEq2XKjUzY1LQyWXfZnCf6o0VKISksfPOIroHGh5qkXr+/b1Gw2NM1PafHcAWt7HJ1E4tzYwMnFuWfhs+GJkwmsutiC4pk8BavlMBJW9W8yurcAzMXXvHO9x2+CDfCweoRU7H8qCDAnjh8lTD1R0BcohQSx3Ti5Ue5LRP5BIOLHb9VhMs+WSCWVXtOtaE6zd0asUIjuyaeGH/kAo+2hApc8RWSj3yxroaAhT9wiHXzgSpq8wZrgskEfXJ3s/FAN7qKcAcSIvybAQ/qzIkvBzeC5sx3wjRys4MMmAL0d5EEUIBj8j/8X8JnJIFLQ8SgUSADDwKZxkAz+oiM2fIcrSDvkpEDYYCBlpCfEWiJIecUiZqEEzyPCigeqdRzhJ+AmLhBxcviVVTE6hlxxLxeOnN/6SNsgExiIPWgD4fVM62JB9qJJpUcJxCW18B4JpHAMDgwcekMmeEPB++qZc+MHgDXUw+UUL55nfwvOtmMRmTkFKImGG+LK0ouzISm5pI5OnW48lW48Uhp8lBC3MY5KUEY/MFrpMKpZog3Y0JtAgV6bFbmrqHNcOE4ZQyoEH3qTlizR4jid/pliE+MmVErhtQuQo2bYewCObKjV14rcXwrYVbFkEsJsF5PbOLkOwe9Dy6OP0zIIe3vziNIQsua2Urrqxb2V0XAFdTzYnA8NJ7+okrlln7EcrI3MLsyGA835bB/uib5n0uBUbWEdvBi3YOgQQuy1vwoBWx70eOMUWuJKX3q/eW2OSTOSKctXEw0ePGZp3O9sW7hwpMO1AaCpYrH+Oj7tU8+WrL2NXjifxnB3q9c3qDI2cv9veVSWJQr9AZXZeye5WUz1WCd++29IH1AVWtMzo9u5bG/YbzVmXmxrmY8C6iELWBFri0NC7jk6nUKul/nqBXVPHijATwXl5UJs112D4yUM+DjfoxHauu2wOs6VcyhrmudUIfoXuNQWLloTPQJiVdUuPjF+0O7FRaXgoFluOOxa39WWuL65W1x+1D/bRrY25buGIek/pFMde25iPnZ6dj3IfNk0f418DKdcemKmwFfVgf9cshzrrgV9HOgy5+Hecoriddw4VilfUYkI/5jxTq+Hc2Tuwm8l0kLOh5seVLEg/mWadYrvHqXTM9wxPatB04cWeHMfzlsQy7Q5OgxsTWZduwO3PLy6Pzy8edw/jERridkJoqNY777qQXhXQgBgIXA+F4VNjsrop053dDcyYrN/eOngSWhpjPvrsS/voUtnRF50/LUc0F2yRVtqykH1Dt131qPVKf9QFoDb1D9zYUzvdmDr0bHSnGzN7ZROKhF6ur1bnvZBcmwhTgIqEMqh0aJshmRab3Nz3aFZK0w4nJcEwANNKSpBgVV4KadhHFJCY0lSJGo0J9yGaYoVToWcUP1H7wpN+HlGyJvu+qHcOT+04URBpzYQnjChpM7m06QSiiB854kkMAiWRMAOFR70u65doUeyB/qCtEwkslhPOCeGHWd+csvqyUmFJYfRVNigRB+ycpROBPFLCnt+CLYwmkr6czCcMHdKqqySwEbEvIeLSPukkHCy8t2g86hgYDpL8yo/eAGxSwS9VIucXaHwDTAgeeGCQEGOo8Evr510geCF3s/MZLm2UrlvH3nfShcPAySmiUGWOhMAgMMnxcIgKTB58sYEEoQnkQAqEWVpISBIAj0BgBKIzm36B4H0Tw4grS4r8MYOKQBgk8Z6UEGj9TID0kwbkSZHKgiEPmioWFQmZquw466g3KtQ35jG0BTr+rJG7tNy5QDJUkK1kru49eGCXmeHiUeuIaavW1KrLg/YRBe2VmuBVVq1f3aKB0/a9vkvrV+pOQ42e7O2vrq1b/NepZ3Fx7tIdmyY9k8i4mE6xQMw2WxV88+bVwsISVp3EsTMSHvXfFiB9Lgqjb4hzYwgUbb91F/FUYxrbmlqHufSg0/Ie97om02Xf+EN7YORGKdVMnXd2XzMwt7hQn5559vyFdsXWB9M+y6trC4s1c1q1yTDo9uSZZWZ4YzXERpkykNVfJl4VQR9Vr9keWD1HwLilElgibVsqCda8sCUEZhwSgZ6YZ3fMZigLq4jm6xUgBRClscdnFrSVO/fzGPh7s8xrmRrCI8vgR50XrzeslzgINj8zPdeoawyMBizkjlct1cchVXhk3KyRbYDWAK7b8Qqjp3ddnqxz+vHHnx7svNO/9mKx/YrOcLnCxY7Gt5tbzDq17Hmi0n2ko3GYmbpJgiVNvmVhYwuBXOco7l/BJ2F33Gxp+39ZZlcnY1IvLpyoW23g8ViY9tfWbUZzefWeLTRmV8yEWcTWVhy1W2c24w8OHnQvnaV1uNkJcash+veus7D13iVu5RyDC5mfeuVsbW391avXBOwPaXLGcD8eMqwMW2kPd2U5S9OnSrBNykLViEIz3h0aYpSlDFEPEE5MtZnXWl5Z6jx/TQnPzk+HR4y2IzXRSm0mhL4pvqdPnzo8t76+INcUx3iD1aITeNBfOTi07/PAxq1gpqyv+ip3RwHsMlPKeDB4NY6x310NEoUc3rJiAsC3n74klnUZkzLlZwILLEfvY3EUFRmXFhUeMCkKMIkwpGBfQ9narsoIp5aowBkISyeYXwhUIDnhvkIglBxChe4LIcbEcvSKH1cAwp+/waUgYEwUkiGZ2ePJ7MErJNSy3O3up4QcuUCHS2CZVUikQk942mgJ+YUjIYlYpIWg6yecvgZrXwXAN2yQyKHkWJI20fLTYF8uMYMU6yecHG1mJggaEj8pDcyqAT3gEZI5go2DQaDsSJIY/MxwUSG2UqKiwGCGI0GcZzhswpO6NsZPqYTkF4ySkzsUoSUNALjKn4mhcBFjGj8hByYtxwOMB2kesbxKk8dPMzCIRm0JSdu6ExMmNCaR2yWNkMuEyRa3KpFd+8Yzbv4C7zVoGxL8/eBH/wU77voEpk32Wmbo++cdxVGdcN+jLTs6Vn17cMcnLwzWR8e8HWhfoO3eY+OTb95t7R4c12cWJ6ZnrcedXlw25+ZNQ5sz1xszN9La22dql5cW7LUwuaH/aN6gc9T+zW9+Q1tM1LgI2gRR3Dwx6nBnw/F9V8nadY4LM1QuamfUjAwAOJ/plJv5ONu0X79+o9d/aqLcMkJzRhJLt+bxeUjWZp2ltftXgyMmIWTJ5DVayt0ipG6kZsDM9flJ9+bs1P0H3/rWtz548iGZZ02j2PoxgEnMxhhDGfsj3d6/32qZipE1LaX2xp9dOXHt8OCQSTUmxiSPpkhCGNgdM5kUkobQA8/wEogSNNvTarc/+ewbHlnVUhpo/faLZ89evDo5A262xBEnqziDYx5Ws+G9H3dN41xpUgBlTQfhpEtsvVmgd1s7n//+Cz16MoHNnL51ftNlmlUdfzcCWeF3BMQeLnXC2rgVIJtNxaoLpj7EybUvTbJ90vKDoql5jDcm6I/NmGlCDGtkBxhDacaJNmLg8GDPUMBJtE77QH6pLtIUxFvzbQchrob7124qPe5fDVYnGm6Zsp9dhYNHlXS/KSqo09fZmTlb7F3dB4PKQo3VERWWJqPCb20oFDUeP4gGwASdnnqIsTzphSvDUXMYTFGswJvqGB60aE9ckamwdNGDtBnLrrPF5RWDp8MjI8iagnas3YGgfs9bBs6dRQWREV0uB9ScVfSnO2KEZxnGtlp3PtkvofGx+GRIqkd2sLtnmSretQ/zFlvAsRR1rbwigHkSxl6Ky1ch6uKIzQxigDTUX7VVaWIyIbOOi5JZfh5RyOlT2KLErmEjvzgxSjWladZYF4FFYLW1Ob7SSoQHOAkTCXSh4iFGcoYZq6gDABkWnLD8ECpx2hrf8uv2p/A7JyXshbFYKJY3GGXPl0vUgPMnem79kEQIElhJnph+dDOrAjHAb01Gbd/YfMNMkyAYSGBOxs4t5JQ+fmoDhMKFEPSdX4gkCZBo+bHKwY8B/KiuvqiTiIQw8EvoJ3+ymsz7ybxK62dC5jcNPfyAC+6on2ASEiHYUtBC+IVIIsRPONOTwH5m2rvkmMwQ32QsYeBBHRhPceEXki79JKaNEAu51pGocegCZRMIAKySabVwqtPgHI2rG9u94w8/+lTniN035JuYnKZPrLdKY5rioLVVb+gNTTq133IJQje6hBYDra2Z9nWnA1a56TkZGjnu7fPHu4zXLjKz+GY+/SYWC9DzBPH1QGXEbZLx+InXS1yHnM2kmoN/vXhapDHIjON8eXWVsTD9rg0wf6JEwesgOYA+XR5udBB3Y+td7KiLmR+yHT1qHztLRL06Pa2V9UOT7XWGkpWuDETvSa3D4f5eWEAPzCpqp8rMkcX1kyNjljrFmrOw02llMbY8OQzM5NmhL5x91+fZsPVFb1PPvz59eXVkV7jdp1oU9TNEfRWqyP52DluGRDTZznPjWKahPuRJS7sjh2pun7Ytyn7N0ws3NfT6F6vr9223/+LLlw/vrbEZk41p+2c81WvKhSQpoDUSzcvMnNOqM8YHMNubqzq/fPGll4jnF5fcTAoVVXn99k1jcooMGUHmzD5L6xjuvJd33TDqwqOLoEoDpiHR/boaJo1+ucHGWrbAAhOtTtQ7G3rKMwbKFzCTSYY7O1tEIXf9nt1TAxaK9SSEj5yPs6DXQ1euA9JbHB6MtXLnA/cMIGRzoWk/Gc3EnluUiNew4LhzPrRurixsU/aQYh3du+2SlNnUcq9xmA5OWswoi6GreBFBhcIhuzteGcOPSLtyf/35FxbCTfubHsSzpRDvqZgo488XAqzukj2rDaHMMlqKjCdXsIglw6llECp702W8dKxjD4/mHBuSsFTCOfXLUgLI5M03MljEqNxpMkeTJRSIDQC6FGmaoEozjW4mRDRdspFo5U6sMtUvUYsVTavVtmBvbYoEMLCwMI9hSKSVUCoOJHJIABAuhBUSgg3YOFGAfQM0fb5fdUDTJTpRIPmlgVEByAYAeGUvyQe6bKtLafnJIWbkaB8xQ6rNU/GK1TWQObMGZjpCOHw8YOiBrJIsXmUVUcnlAZ473hJnSsr3qz/57xx42DL/sOETbySObRnhYBaeaFNG0iZasZlrIcDAyC+uEiALXmBKgwc8UcAMP0hgQnwTCZySEJECo+sciQmBGQz4ZJJfCCcETCKBNlGhIgRkwqsLwJMHuYCcidRq6mQUgUWpo0ILISS8aAjCvtlzZo7umh0mc6r84Ycf1aeaOtpaDn0o+Xd6bH5uZbq5NDigM2jR2NybatkcGXZAf8w09unJRaPWXJxfmZ9dMr8xPzMLYfuw5S5PV3QZXvhTLe2EN6/qwonS5bhSI92bb4NjzJUP6P01dSGNt8y0KiZ8sneOJugaW/DUn3UTkc7J1PSs5ktlteXQIWGT+yaT3RZhoGDVwWqtwvGCqxpNz/0ZKOgIuTnAVp+FxSVXz0NoKtlCi0pCIDrFViDdJ6M7bFCy6y4Y513fr+Yx31wsF8elby6h0J0/dytGjE4aU3HNS21iY3vbXQgVT81MNja39w7a3dHxSZv3tVU2YRCpjUlu2Wz32q6B09otLC+6wFmLqyMMuWmZ/+2vf+G1QtO0/vZbncHhinPFv3365a6bKQ/d83xjKGSrEJiJesO65QcPHrrMgKE05UIBFHeMUweGqibi4kacCR1/r6EZoDSmpsnQMMWeUZzIl80/7gWy1VD/WaHbTm4Bhk7JO3WghEVdKUsMUKD1k1Ix6HR1bnaB+qFIhWQKqP1hbnIwsg0lvjixiHF57jB4v6zfVLBkuaJjSu965ORi8N1eW59haWV9ZnbR2YdYEB6tmH1Cwr1DScXCu4478koHMw6dZF2IalAcneeyfmFGhcKOr8ii/MrdmvoNG4QXj5FZw2Bz8W+z39zcvJox1fRQqHkq3bUw4uoCfZPW8UcqGjWt1DVvS6hEwgkNxeynIuSnZXbzkKq2cABF/nNl8krFmMB8sPi+bvLgVkK05FRyaNMva5DAAEBIwmTWIDEKEULsYECShkAh/GnoJeSB34l6oqAYygt+YAhBKDYK1M/yR0CAk1wyj3Ng+IntuqpTVV9uPCYZAMEowpefcKXksgz+d980N8BQhReLEoJBWxKxAn1lTCDuM//UUSAAIUmRRwiKfnKKTSz9MAskXFrZQyW7z6LSCeH404MKNhInfzqxEPJn0YrFJIQ4EahdEUJwvqgLAX8Xy8NBLgobXPKfXxaWlAmRfoSsywVwOOTnIEQxk0AiPBlAQnIhcAoBJiGXfArn4TJHfiYeWcgQ3wQQlfmCkBN+9+VJWnjjhxykVPLAGoLMtK79clDLAVgzkCTwMffZp3ooXGCIk5THbM3l2eXwtS5cZeBy4Kjlya/jsaFhS526Ttrqw73dnXdvdjbfDF9drCzObbx+7v23xdmm42DT9dqj9dW5Zt3qq62hrs6IByfNAblumDRcPBSb/6JuYIl8RNIWUs2pWLMccqGlOjm1kzIsr6VAqxSMvo6zORaQJsLd8cDa6uB3PEfS1r3yHPEh9ANDY3ZDqt694zYJKPQUEb8xZTaQpiDEl4cbreF50dCYXqd7yEwUiZVNTcPuL5JQ11gLsGXy25MuR+xXXEZwdHxsQuzzL77c2tnXOHnJEQ8HJmcc53Pk+OraMqxSNtVOH2TTFEKuHzqEzsb9zd/90hvLrKltpqb1eyem0SZ6xqaDQwY7f/33v3q7vXd8dlFrTFsY9ZCZfiuWlpYXHtxbs/3GxllbZ81x29ky7nXlmwHNz5ATZfUplAYGHbY4MUrY3Ngy1UNWqpJcGwd4fcEAixxMqliz6Z+cUmCKilXKxvTILE+qATkoGvqQihpNWnnBxoCJEYdzcWVVdwgi0/Tadf0GRazPzjybyXLPxVH34vxmbGC4dn49ZE+fJltDxQxGW3tii+0hhNaEaCgqOFEJWSIr1jg0djHnQz+duaO2dD8LEatclqnkdtk6NV0bH5M15ky3ZmPjjXcj2R5qbzoLDKutN2A4eOBRI/uEBoY0jTqdsilTwFQKyqDxgNZPhFQKBUcnOR7aiChBwaZjc1c3gWGVfApTt1sw0kQkkxAqfalAQisQvOQ8MEPoK++SoMtBhRxIIZzkWWGFMzg5QyUtnFjylUQ3xSBVRkDCBsY3WwiYBYLBAFr5MxkTjhPhKVU/I9oPJDmejCscR8svVjhcd0gpQfbNdSWQREARYjQ7EUkmsUvF2TVm+cjiPmyWBuN1RsyVm1sot2V0GXaLhDONNmLboUE/4CQ4TYLcyiEX1N0AUxzkiV8g9/+n6k+eZM2VBbEv58yIjMjIiMg584x1arpVdaf3uh/JVouthUgaTZRMJjMttKSZ/gqtZFr1f9IrbWUmWsva+LpFsd983701nzHPyXmIOXJO/Rx+Kvvxq6zvIPA5HA6HwwE4HIAcMyORWQQZCWQFoBASn4BBq/DGpAASRkIBSNAgHHgLEsACPol0phVs2FKKFnpWYaWDn0CyVRYHIRxPV6jQaNKCN2CSIxh/5gZGYX6ZnIH/hWz4o1tKsjNTOfopbBFNOEpYqiDphBm8t8dXucQQ+JZajlEAyMxdpyZTPwGPDeOZ/ow2w2fFShrDmqMCKOQLdweab0U9zte1IoZgOHGeAuVvY8SqjPx8yNbVMPz2Br0OZ5V2c6m5thJAR2MKruo0zFvrN/OX/bNh2VI7P3W31KjZQFxhrZiMZhBsjv5oinY3/mcJ4RtAdvSh1uRVtOfo+NRZacZuNYpGayWoFrcv7QkwspxhEHcYsS21vdGl+cHsgrPkEMaQql2bYCn9Nd1DouarFWxFj6PuMMdmCTU/unV82xAF+kzOQjyaZOdWAUoNq1mBbVqys4rNl97c/bDL+OPgS1sMiHVY+e84CF3Q/izajAxc4t9Sssen66tt+nf3/R498mR70+KtarIvScukKJfdUM+GfnlrR6nV6f746o//8Ee752yKaq8uWUdx7w1jAv4bO5jNTMyPTwej7j9+99nzJ3zv7Qp2q6MO29ExmG/6YZ+CaRZNoSAWbEyVQkpsoL24Wmy0DvbeO4ru7PzUyI54aEe+6nsJst6RJDgywUTBxOrw5PDp4x2dopYFhu17a2OT8mSaV3CNkwxQJSSkwaZ0DxUb5o3LDLT9i+vLcs+3Sly4UTvzt8zkLjSjxN2pdsZn+m766n5mcX7avuV+/3KuXqHJHU1TRUAtjmJ98njLodLM6DbVEWLSpXQ6CQeg6tcPTzpKp1I8cQgO86UpYxQ4Nt1RSdYBirYJ/x8O2IQ8jopwyJVz7s7C6nJw0qks1M0sLer6qsGWZnJnmffNq58d3S0GD7VND0ZpbtpbNihvvbYcOx1jCGtyChiHzSTP9aYC+m9npeTxYgxZi7VglHrX9NBMDmUHDx7Sk2Jk50GJn8B8Qr+fSZUYhfMTMcBEwkAIESUgZnN9+/27o83tMDrJSC4w+6pfJzlIInuSexvQeJh51bUYaLFL0WSByQY6IjV8vSMw2YmXRXBBKB8QvgXvI9l/0j7ig01lPpJUAiDhVD8xkhO+81OQNnItFn9h8BLCrFTCkoiUpRiSJ4xQ5dHmJSEsPvmpDcMsYfC6DNuBKblmDDk83g/UJir4UyYEHkj1SRZ+eifHEYB4aCH0VcHFQwhAOGsx6fSGCow3UuUoCZjCluhd/Ez6BTw+JYzsJAHgJ4AMCAOARwFxTDywjAx4ofLIzpOpJDRb99MXMH5m2NckTODhCeDSEZIMXyVJUoMnGBgXwpSVZL6PlM+EA1CYSnpEh0UCEvCo0s6pSDJ60T+Pezic7sa6fTvmYzd9dzHsnN9e9Dbai9t0XisG+/15dt57Zidq1NEF9Jx5R/9kfFYIeP7Jp86FZPF3UADTDjVNRaORrzxZ5KOGZvd8xRFp1rTLZkAtze2AlgjcIUVhIc9RAbqrwXCgmzFiYL+Ja2fwsRKe+PIhOYwz6pT2pJ87nXNOLDqPcvfFhN1UzoZTCax+WhQjipUBJ0A0V9clYZSoTU2Prk5Ma+CxTkwX26Rq7Gz8HqqLMcG9xFwPrZw7IOzk+P3uHnW/3N6QHTvS8eE+Dm+srbjP3Vxf13Y3dedgSxOkfrdjBZ6i3Nx59N33PzZay84knV+MVZk/fv9Tfbn9oo2Pa0TEhGa5tRLCf3/79MXnNvc6LPnNuz2zqPFwpr1UbS03T48PSS2G7Lt2Uv9zebWxtf3k8bM4Srp3rumJXLiw4s2sNOPyXlXGbiaeN6dUJOfD/oH+oAwP70YcjRYWLC1oCJqbrBWc6lcjhMdEgTyYrIhh6CdRTCtxirXrHHpdo31g5nas/0QcE/Qu5J9aJgYL4fBqVWf6dpopb8b52e5fZqqbuLpzMvjvvnpxdvS+UvmVusN/xpPDg46dERhMkbHpWZeNdjShCYdM0lPmKySb9clDUGXtfyKkHSHM/UECZMNM0dLM2nrjbmreldXT0/1UNZqOWZSlC+3HiojChta+Gi3OL9Ba1qZkhyehHIpm4xpJTow9ovYvDb1jRuKrJTyLuzJXUjFF9m5BIgkkAnDYk0T6KiCVDkkAnYiREQDw4jP8gAeMTyJ9yichs7xottOO37+sQaoy8aSo6MPobFSTHEWqaMd8Rh9zE90PJNjlU7JCAD3wJ9okKUmNppgZC/iQsURBOEkR4wnuF+2DVgElJx9o8qh00gZGWJJMldmDZPCgOXnX+ari5SVgfCrcCB8yBQtdAyDJgF+xFdJgQfVAq9iSTEQxPz7xszwCUskRwR4/M19v+MX4BCFOZVihxGsA3gmDcpWEofBFOX+xXGUpCkPCOUcAcpTILsPGBXiayH2CH0IZeXvgUTQPPL4C08zM2mQdfXWBV8zMTtaSC4sXllwWMcUuFQmJX8k3n0Am8AN8EYBoJej0Bpw81NBmJmaZF9Rx3BB+fWH2pUNmSmZn+vLzzwixgiPDPVAMt7aSDvvnV1f8XmI8ZT4/7F+ojPrCXG1+9vNnz+31v70c3YyObm5n1pYXGJEnrjvcfdrVOYM1TGLHn5q2ejnVOz024/DTHNwioeIqTMiQK9GbNU4x3YvL2Pc9NZMe2nhCotY2N7hgOthLzob/VLDdWW4pub+8r1Vqtuoa9ZuvcRYy/MMk8wPCore4ipkEV/vBSrvhPE5WjvBLuYjD3w3e+aPjpMIWhPaxAr8xwZmKSY6TRK96vS5bicpdZ/ZeW1F5KuvN7nudje4XhrjbgKHH6cbDo827GZ6UvM457ewfHBL+nY1VMwlrwi4suGrdKAuhcguYi4s5KTmz4de//b1d1v/z3/yt4vsUHj9TU6wuP/380h0v8McOzllr8qO56mL3/PzV+Yf727Xq1hoT0+DMHrHTsCm5Qr3qUsaZvf2D77//Xtl1TlvFfUsfj5lYjc7nTx8fHx68/vHHna2Noj4GGpFOW2fgpEw1wm/JyrDeVLdH09oYqLD0vuKDVAuUiCmaTXz+YR4hVCZVJErHfD3m0KIDdrzU5Ljf067Dwec6vAZmDVgmYzuCC1vdI12vNZdbqxfnB/oeRoqtNocf3umhahibVYB2gRXaS7NZh5wcEl0/NRCbGr3tinCat0jt3jvbBX1m6oMk+59FhjyVRjc/vWDX2/rqij5RDADdpOKQ3isHm7to7/zMsRikWgeg4UQyNzRcXU/VKagrGcnadAv9hFKeimlGQipLW/s4XrZ2j34xsvbGXm0ttZMYakRBPEkSDWasI5Jqjor4ZXAmLC+PMiYlqaNwIJNH0y99ZMLoq6ByFpZ4TEgwmap/NSUSQi4b455mYIvPyPzPRxjoDVQhWNMDQ1CFGXKTb6VcoCaLyawoSrhQIA8ZF5rCbRGEGO8sM9Qrq+vY5EwSIy4/zSxIfCYBCcyTqTIsUmYARKIJKVKpIWySCzUqlyyGGDXkaxxfHBs+3cvR4jjOxm5OIAns2jaCmG894G20wVmBjz9/UeIyVRb4YYYT1+SCBpCoEpn0AFM9MOtINQN0igEpYVKLYLOLRC5VMgRCyOFUFg8YaDMJyKxFuUDlqyRiVJWYVA1gPMkxOZJRaX2N4hT6pQIQO7IKJZLLQhgAGggoMPAeyb3zp4U1kNLmT/glmZ2LJUGLYsxV15ZLrcAXp0B2gBfPn0Pbc2/JwuyHg30LfCqJJ/TWeoMBfvJ+Ub8zN3ldnZnaXG0vVsJW0Go2ZiaXG0uLDsJxgrGFRNmxmhojD10HaCbHaGNwV10yGnW+0N29IyOd7jl9M+NEacuxTnF2dCa6r6kRlUmnKLsbu5zhiGAHmhoh8Nq0/GNU2LMHzTk2Ew4ovnEO6dzdhNGvIstUldmSZlROjdqVRoricq67G6nuby8YEu0Gwq5ao8Yub2SsccNP1cKsWWIcuaXs2LKtS2MUKwT/bjHWnsN35fgY0zvn7sWdJ0DXd5dMCm7u/Yc/ffvHP/zDyurmTLvJckIciahNSHSJDqI6N/Nh/3BjY3M8GmojCm6vw9PHT2wR+HB4eHrMi+PetZEr6ztHxwe8iVx8qdPFAVMWEiiJHkkV6q3toz74sOu0e0d6Lrc3+67osePkLnwoNjbXF867+pVxo76+tnKwZ790Z+PpEwVkdNI5WSXXj+0fnzgPmUl798N758pJTnRa9Zo9dMdHRw69IWP4JlOzgVT9dAR+KjsO52J4c7lhzxradAnL7ZYTJ9yws2aiZoG+Um3Nk44yMJ+con8d229qaB/F2elltzOYXrK5kOgt3ek3CYR7Yxacw/yIzLqkgaXPgpK5pkkeDlAJ3hpImVqEeKs+D6UXdh8X0MXy0622b/WSSdnF1Fw/K63osQg8AG1lrhoi+sOPL41g1ta36Ej7dHT2NvatxPRuPDM5NeifO291tbU0M8FsEi4SZMlSpuZCQ97d9Vdbq9H6Si+CDKywTGmIaPkvjbpyQsnl1eXW5pYJBgKiarjSFg3L4QXV2hLemlhqksij0+DU3CircuBF2F7w3CeV4pNcfEVMijd14RPCIFleqlHbvroiVBJ5ffhwury8oGhgKGGfxCOg0ch+1AQrdAXnabnw0ckOQDh0hQk3PywnwuNx2htiF7Vz4edn4l6hoowQAZ0+8Jtvvm61mlBQeSKjeczOdnuOhzp2Xj+rvemPytD2jC4RQScqDySKJDMxiqRbofZzhoQAfxQaRScG0/0JALDBkpe3fNkitcmjgwMVjDcUjVNKLDVotBxx4I2xrCVyHLScW/YNMeszJVOMgI2SJGQ6ZeiwpcjbEI/JQdg6FYu2R1lUjMpAnnNmVI9uQHyqaUXw4CBxJProX15uIlh3jnI/iYc/1AY/abcb7q2GLSakmGZtTUWaK1CoqtNEjAIx6h8pIK88/u2+Sh5XPsUuvEmLrmZ5dhLFyhVuuIhuHKeDISA5SQ7IVqi80qUFv/TKpgLRAZhXEizCEAdLEA5v5WLL5sTNqhMt6Xayfz4wF1QcoxO8pOMcfL+/d2BFzrlvrBA0+NXdVf+qN+PuP4u/Cwt9R40dHtBhn+1s/avf/+aff/nZr5/sPGku7fDGZ5hldry+Xa65/a+22qqvLVW+eLa9OHO32aw8Xl163K6/2Gw1Zm/nrvuLE+PJ8enM5fnk+KQ6MZy+6k7djBx16dwwl7voSPoOe+t0FJDMGPzyiZybnLW2a+Ct3Uzeq7iV5ebm3v75u/dHLDBM3qwt1pTom9Z6e3oujhfmquPsSGIQnZYT4lqri/aFrW1ioH6CvzaFdXNpMnF1OewvuItiYfbmYuAqREcoOynb4pOE1mmJ8e7bN7yY7FcgTstLVa6QTp7j9N0/P3OA/n/253/266++mLgdnx0dQuqECa7z7rW5nZyt1ts3k7OHzsu7neQ+u7n1mLXfMffMMepive3menfB82+u9vqnM9GtWMbs2VC6WJ2/tSOXlUf7imHpeGdny+6Nk7P+//A//sfL+7nVRy9ma80PJ+fH5x0DIGVwfv6bVz/cXo1uxwOWd54Y7oFR9c60sEbNU2e6WrOb4LjXtaujttzU0eIwqz23D6f9WLy1J4OckHOHMZtO2aagf7awbJIqkvuWyUE48JYJtGSGXcRPQdnQGNn7I8dSLPQv7kYuTZyrmeZpmM4Otbj0/JE7JGsOfULIaedq97B/P1u/nloYjCxr13lN9Qdx6KlG3h117mdowBiTIY9uIaK2YtHXVJMBA0WWetMnlm2ijIeWniuGHaNwpkw946tVArqo0zl78nRnZ3sjDjHU2K07TU7paGNDyu1k02UGvW49rA5xGLVLNk1B8C0GIsMxs54an5+u2KSiGRIYbTCOV7u7N+Sxka0whFPcbdi6uFEszDob1URD7rQEHW15uYz+tTnqhZWYscHaABWnhzPGjfFc8LYMgvW7xhx+4rDiK7jimGNak1OPuJE7NlgUibdL5xg2jZ5unCo+db+yXrNPQRI6Aa90qE5lYe3kr2HrnWU2h7TTLcYWVJaGb1ul/RMfOwC9ET0VM+hYFowVNN0IPnqDoApRmUxngUEH4sQLoM+gKfsGGSPdxITG1MYUSZLUpwkAm4TCCiO5gHJ6C0sri0TrnUhg8PhJyHyVvBxhZK9NECCsizKSI8E6jux4/Nw/+GD4kGzNLkoYfnllLt4ZgMSTX+UIACVok1F0CMXnwU9FwFaQNKmi6cCIiE4YsLQmJfjjq5gwZJe6VCgBkVBhAsxBPPaXxXcJk6UAxHiLgTYh4YQ/ex0cBik+sSXlme8Dcp8QCSbzylzEwIOeLIhIdCqFLi2ziyuYYshsCFPTVWvWvmrtHGaOj09cD+lWEACLNQcUm5wGC2g9veZ/9ud//n/5P/+f/vnvfv3mpx8q9PHFyAUCvDg5eDqw//bi6mIQ/kIXPC9vXJ7Dph/zoHsehxb272+3Wku//9XnTzZW27W5rbXG/OTV4HTfLuO6ffAzdwuTV66ncIxcbWG2NjuzQBon7twNoqVp2+6SosxxxsCOT4uhnMs3VlY5jI6ZgHHA0iCBwe1LZvtLw9yx+buBoOpYW90g7nH8ckyQY4Ohm9YtgoAv+6B5/l04N/+6HGlA06kCnME9I19vzdId64QXMvNuHZJ6UTsmZDoqruWfPnu6vbFhGKKfMKh38LIpkA7J4iCHztpS66fXbzl3NnnHTsx8+vmXBmKQOPfuxSfPFO27b//x/Ozo7sb9aGeNukMTrkf9c3umceB6PHC4m6M/Gf1tznj6yYtXr9/+u7/8nzmb2immqRoeII+7y9tXP4G8v74w4sEr6wSI1ARY2QjffpzpNKkDPDztLESlT1pXN68it8pomcRqMDdP6x4UHLaIUUCSg43K+Obta5CYyVToAl7C5iFmmgQNwHswbIozCyYlzFY0iAVi66IehkRMGw3Od7bXH+88qteWx7FiOntxN6XaOO58ODxmp1hdWY8Vb/CXoz/+8R9VJe8muRPj50+fEUVnVvuqEkUasBJjnzwiNSKzK9VsCmsSoCmBR5tS0C56Ibap0BLl0keRRJ/ZkEH5nIdpt88zOLhU8CwuxXWkqt4AWHs3nyN82KjRBW3FJCVT8AjwiJe7EQWqaPMS7+q0DiF8aJII8JO6F+MtFUrIEjypiMinLNAMBZMDHQua2lEEACsrTQlFyosA0FT6Y8TAYx09XuUBLHmSBKEkYgpt0JoEXFnvsWlOZZnvJkKZKqN8FQBXMFdyZkNSEVoJWnSEugnbT6zqQCdNuo5pIfD6KVc0SYbWZFNmX/gcG88igzJKxZ2sMAEtMOlDCuTyygIAkDWEyi8t5NmFPBQPvJKUZhw5SiiJSG/AMoUZbT7JJTOSO5xRwqKFofIzgSUU9kQJS6+bGfkq4CsG+Zo/JUeMyGKJCu2vvH76KiNvGWWbSZqTJJ/EJyRUCS+gdN5wygK1HqlglgqSzBd7kyrAIMEDQ1j+zIIkQB72CcYjC2/xUGE+hqABKipeQCr16cwGoxDWeOtY1YUa4P6gP8esX1saDa80Ya6hhnguTWKwmZ+aM1M2yPrf/7f/7aPNDbYa9wo6qxKdhQmx+9qinDffdrPQYDhfDh00L+SaZWGcjLOT5OLRSdMpCDSCujGW4QNqSu6q0iuT7StuNm4nY7Xgy8hRheGiN+gOL6+KJ07sWuPUyIxuKbjfPYNtbXMtWEJRGn9MTtHFyr7Ek6e6yFH19pKt04JlTL2TLZhsHcKtlpQQ+wCfGfxxKCSGa3tg+EfpUWI+P2H8GI1f23OcstIcWdc+j8l1q71qCKk+rD/Hgfxxlt7t8+dPceDo+IS3j462bL8yKLREOu0EZxfS/vT6Df40G0ss6ffzzH083LvsD65guzQd6Ex3zk5tUTaEt+gddX0RJyOpr/Fg7IbC6KIcYjNXaS4v7X3Y/fnH7//Zn//ucO9Nt+Mu4VOjUO1z25aCiWmFrbIkkMfreXnZ0nHW71qPVaJFvkqLIWPmvvoFfddKo0k4He9GgCk4Z3+GgBWTIF8pg1ZrovTOyWmYgACYf0ctluEw+bWZAbyBdmiju6JtmRAHfUZFHTcnztFFjEljm0bw8L7qOGWWu7juYXJuZvGW58yCNfzwjFJYMyHqadjX43SgzRyfPds2uzg4PMETRDJT0BdI0CDAJJgZo+yz4RgaqlMjzJqDV12TWZkmNy4429uLwXXoCDdHxn600B7hkjBT7ffObTgyq1Nhp52bjZVYI9TVOB6BdS4E4Bd7vd6F3pY7arERSSANGpXRsjAwOZAdD8J89RCq4FjpEoTFpyhSAAgQlsRwAR4/4Td10E4lTEhfzZx84otF95oE0BKF1YG25BCvRCW5HWFW+mHADYoUcFxZs1RFIRkm/yBDvdjiMBcqFH5zZPBoLs05ShSGckgRl6iR4pFSAhiFS8qCqPhsafFixGOBtIlLAHZISJiYzCNVIeCESV7ADBK85AD8RIq3qkp4FFNrgCFRu1GAokP1BGRFjy2hJN7aXrVSMyzzU3JJYIYEbQKJVtZZOl+FZQQA70QCUHxlzLD276u0CSkyxKcc2ykJhBqbSCTJGnMRJlLgFxZFr5CcgUdeDyySEeRqSHKRwiAhAaPmZCFSjK+eaJnFkQsqlHh89YbT16isMjH3M55ScdIKJp/hhB+v0BmYDYs489xcGqGzA2xuPR10e7Pz5rgT/C5ev347vXtgz5TBgsmBGxxXWkvPd9a+dPHg40dGf2/e7q21mg4GNe7h/n8xCmOlMx7YgTQV00hFM3FGs0NuEGABytCDkxwaVtZW2bLoxNm5mskCFdFq1l2PZTXyesguMp68uBv2R0uN1qJha4P/xuUCNcbkvFixdMA8ouHz+lHhNnMarLmMREnpK1xwJbHJanDYKvJybN8fOWRoBKiPbGeoqdawDt/EbvjFat0+LHcu8tmPGuZCHs7fY+OgOdOWuzmbgVfZOtstZjXbd8ejMVZjqfrFQ6gMcrGU/ZQpmxDqP/jT21dlqqSkYrDdbN1hSCen56srzq0b7O4drm9uI9EstlJbxBwjjfW1VUN4FmX7XZ2q/O6HHxqtlm0H7q51sL4V6LPzk7//6//41ddfKiM6PnvxiUvsbPrtnh2yStnIxbOoapVP7mWsh/9s8Q4D0IVPXoejtFG5NvLy5U/ra2tq9nB/F+WuxjXrtwZCCSoaZe1cBAMTNiG9LPEiAFGVrt9p1C1IGDFoVjpUoqi/supuhZes0mNhgndSyHlHd0KH2tzHREwlUtSsCbZ8QMUQqpYJWbQRQ1eO/bfWY5pX4449dJ88f+wII/JjHOQCA30PPViMJ2EtyKbBtML6YrU8qqGoztIUoi1w6xHGTwRHKyvtQiqdaCxD391RC8hmw9J0sFFjvx1MztSFWXFCQXlba6lVlmrXHUg4HjvfzXSHZzOEHgXU4ODEOvBMuRDake4TgiSBQ5hsaA5+oqp8itadjZTkeB5oziKIAWB0qkeR1iO5t4xSqyiUJAg2URM2yCi2o8BT2BB9IfyZVxy2Zb5TupzMVzw6jTbYWeBFpq90/pV5eqyehAIJCfllZwCvIQCxx+GBxYVC2KI8cCk/raeEalTeaEIua04gKrUCUgBGDwBhwNJmvLAY5ZGNJ5Nk2BsSigN/JZScrGhLwvKVEc3GDLNYdR5hzPIS3nkrD3+IJx+yCJKKcSnxS5uBTJVlkRfMkAAWyJrwE6RP+RU8eiSXJGsFWjWBCWjLEiVmXwXESAgJbIlTKSQR9ikJRp6fwMQI5ChPWk1UYSUU8FPW0gIThsE7EQIQ6S0mkUSmpXfM3LUxGXnAGC+gkzJCsCU7jQqMhHZsEhJhxrJgrDWJSnX2bmZ1de3szJaog7U1I+er0MuXw8rK8p99882TnfWwEdvLbhFSdvcTDOtWQZlBghUsNtWaFVHdLMq51k1NDizwcsXjxOK2MVZ16+5SqWSrx4bMaKMEm/VVJ7boFdYaRocLODhxNbgenZqCsA+gseYOkbnJixsXfBuh3DP348PZSRzeUJl3Zv1BVJ8D/RdjuduI2zkEJxdQhuwxGbmuRQHZQBkJMZYgUVgm0bWl8Go39DHSC+eO2uLZdMc+M6zmhoQzhqIwmG6uNdt+Oi/BQhRbk+xE2knEQXZ+sWNDKX46pIHLEQ8o97mrMd5BFlHlpUQYPDNfOesN3I3Og/Hlu/e/+vyF1bLeGf/7U2ZMacmB7mF6YX6j2eCb2Du6PJll6gw/tE7cQXvIufrtm5+NsA1Lz4+P+X6rnStHKM3NLlaY1m4u4uzNy0nu6qamNJIhnS2gVq6npt2Eo3x8QNWy+Yq+mX/O4ckpO2OzucIv3qTEvSzqEbuUVC8YTJiecs2wqtRIHDBA+sitjpOJxoznahjHGVUWa265r4ZL8T3nmR4znb7kzsX07c75GcEmbxtb60TRfcXN+tLjLQfNnoQwE07me8fIzk27JNn2EhuqXfTpCl/jd65NK401xSE8eEt6qUJWSNwgpVG6WPAK8fZVHVEXIe5F66kdtYzU0YVtgOGvZMWNr5OzPZ1oRCVo8Tqf29j96q75G3x45F776uLR3gcbJiRkiTLfhdmEkkTFaKwMy/RG7CU0qXyxyPxJviTOGxXytYuOOJWJtxYeLnNF7fIWDf54kAqhd1GKMZxN+n0qq01qUO46D9aL0NQ2ssFMDmN2cRHzeI0DpwmVdSlpaZryl9hhiwX8zA5VwPBQn81ZRr4+SSAS/RCSknq9qrpL64hb7UyoIFKiUDxC6PPZo81KI0bNaTMSpM7yKfr/GOasOlwFPPaFFJYHfZgCWMJA8gvCROUnNnh7QEqR71LI6GkkEekNTOm1SJj99IlQJrwkCPBTaT1GGSDFlIShfxMPsEyIC0hCgHgwniRApBpVKG9fxcMjCWIkwTLwHlkk8cDEC2vkFCtI40H5ykgkMCQJQwsMEpQY2iQ2YQDy9RVmtSJ59qnQerQxAEU3xbjMVw+0EKJKKuRB4hEv8uHxU3bxIXrbeFQHDFDl3hBoAYgJjt3dMPLG8XG384eHx5zoDf9pcOYL68d0GXvDzN3FkxdGY1/++W+/qVdn3/38s2OD2pTFzFSvc95qt4Zn56qNstdEGZRdOyKv85i8s3sE5Sy2yLP2LWuSYOhsAM6/CK98NTOwFU7/4wixvnW8SQsVtpTN1eZcgz56t7fngq4FJ75dWJyYbLhDfKlBVdhYwmnNIsWtKYNDCCbvGkv1C3pN5+8oZqu79WVNCP5Yqr2/43RRW+KaeeS80mgDDESxeh+XgZAo64Heiq+RmP0Y25tYOGHUAoLFLNPkHs+a6XPWqun1DafqK0Vw3gVCTkMeXZg3KLhRlxVlbdWglqlrvRw9Zi2dpqK3ZMpfEx7VstxsDLojR+U9f7zedbTq1Y251+H+kcYgr6P3HwgJlwgz0uP9D/okZ2foh3c21zlZmNDNVmat6dmYXWfSnhc+395c0+swyg2v4gB95fJmT+u5kn5nx8XGjtRm9DHGR/nq2gajttNVqHkHRzPLKEKtvmSCYKoEjzUVPbTaVI/EzGKGDp7thuxrQ/ezMY42GVJ9dzNhb4nVVKucBknFhA0zE9yF00ANHKLth9DCgyQarHt+Oje/aI6i/6Hd6EhzjgsDEfNes7E4XvC43Vy0+6xzdnhydGAbcG2p4TRSHmUaCMKItGqFkLbQIoRTyK1Lq3o/qXuS5nOoOWfzGaQ6qydqLKz2FkWOjs9Eu45Yct2VVeDE4Eglm+P4BrjSOS4WvrvXYKsLoeu0FxqBkQ9PlJWWkBY9pkRaK+2sc7ItVKQie8qCaaynasiMi2BkLxftADcQ6Secwp4MlALZaxZ+iSjHf8N8YikXqpXPGAAb1mJ6FF7yDWWUMNVn4gkMZQiogVNjUWvzscVaXhCi+fGTJwY6/GBUJdWP2tisU843LaiCwmBoUdT0RqiJ8jMUt/Er9H56K6sOVitFK7xQwCXAi1qW4sEjAgolR6iviEi8iuQB4AHpE4S+egT89DwkUbConOKZg62yAwYABtiSBXLBEZGAvSERQJJ4iIEJ5BsGn7whkbv4xAa/gCfzhQG8B3AhM2w7wqj1qaCNTeoehVUTqkpa8L7CIEBKkOQtYUYW9FFAePIBJlLYWy6qGcck91MpvPFTjgB8zSSS+5QkPbwz+QOAnyh8+AlMDEmSHfxK6hRIHIDKo4/39tNgHW/tqrA4acDSZ2W2beru4v5msNRascnrqxc72ytLF4Pe4uwMr5GN1jK96rqq4dmpksIsR5PgUhHRuRJyecm95IOhPO5jsUSk7NSOtw30S42KcSL92O/0rbNZUWCluaB7b63+tRbnl2YdGX9z//LNriqPveI305cOEz21H82e2bnWUvVi1KUa2qqhttifnGJuovENE2OOrOPjYsoBPxpwrFFtltUz40hmHvfWttstbn/0fDvMqbEyDJKpFNlsvnEwwGDIcV55NldbvNpHvY5DoXkTKpQiM2i70cxKNSe87ukR/xhxFpzVqg0320+cfLF9ctbl7U5CyFq32zc25Bh7ctpxWsvheb/cq+PAUuu3pzZaGHpPWgMP85Ehe1gCB5djY03KN057rrq6cOZ64pq1xzTCJJiHmE56baXtyGXu/Ktra47wYSHRzdpUrIXaJzx5evL8+Yv57oLzFRyT53TVqBT7zx0Nz/O1vaZDcmSCr6PeedhVsCzsGNdmJ1pAr3NmzGs9s34f15/5bHqFpXgVbfC+bIwaz+gXHMBA1XKDsU3xcjgAyaLV5JNYDnrBWBJocD3u8yPgKMzT0oDGMeOn9UWd/XR3eGHRPHYnTsbhprOTPGqqJydH8IQevD6nSdpcVkoDL6JlE0tpchqHBhRrzcExwzlGPHMjbkGap4cbnGOhySbCzVAdmOFMDueMqj80RYFtH+GmeHltL6RtdEgKlwDKhEsUgu7NGs3qJgY3F+EWEwceBw9lTqJ0AN7CSNJwtALc8xSsLsyJjbsimQ8yHvmk5KHNyhpGADCIN0RSwGz1YtSCjLSUXO+UyjSQVlGo1IRGUdLGfriCAXD5yUJe4RsIOVS0i+YnCQZabRITDlNlASM8aO4nVZMJBwUPPh945BX1m+iQIioLIAaJYgwn0We4DbVAFkl6xcAL9IHPn6naxEdl/KLRIBEDjGSAlCQf+MVDKABnvmVHCHhBgZQQHp+SDG+0qQNJgOEOnFIBBuPBvqQ/WSYXkLIQ6REA4EEqPGJoklA9hcveCEZhir6ECZPAiHn58iW26p/hAWmUB4N5gFykEgkehR5JvFEu4GvGo9NYmA1Ejr6iUI75wKNQ+g9FeMhOODNKmoUDdakO8PnAmfyUCkmY75GdRgUzqhKhTygXNqAgPEjCYTQajlFhDjjo9U56Xe6Mt7/7+pOvOOy0FzvHu05Ittdzc3WFn4odrXu7u7oTDgSkHB8JA8mqlDMyDdzImUUqbpTsLrhr0oUSnPRWLgWXu1VcAhUXNQ5sK7VtiK16esHVAaTWWM+amAs9KvN/8ftf/+bLF+tLi3fDnntonm+sPFlrzjlV9GpkU21rabFend/fe8cdEwoXkjAzK3JsF+j18MoatKpmr8UiKompmsGcckSDgru+BnmYr5nhBn4SHmXBQHcfP97ZonAdHcE1NajsdxYpV53KqD/Je/T8lG0bV275QTGLz1l4sJxuh9Fo2D1z087C3PSzJ4+HpdM1WOYoSQc5sMjR/HFSUJc/5N3p+ZAzvFWB1bV1dcc9/rNPXlCj9CzvVXKJJCaX/fe73e4pW3qjHodxDt3aduuuV732mGNiHIxcbNPq0XnkiMdkA0a1TGtA6ygtsoEtZvL44Dw7I3cTFx2qroMbjJVweks3hm9uQ1OnhiBOyWeSA49XNEJUWeyHit5US1HFMiKH4lV1CqdJjCLEOYCl9fnCMqkifHXQUCAx5OYZNb5ot1qEwcRpZIeHyxSjzmd2th9pUIjvds9lYaohobUQb/MkZFAM/BkNVsOV+ZchGgoB0GsqVDvNR8eQhOkUPaEBnFphq2Phm76K15C88NmjA9Nz2hmgaUCmYNygrJnTTYYrZvizcxPN5pKyo41QyShlRhaoQgDOYwsOa2UIACBM4D2++lmm4qFkEKNGoi7+Cf1wQg4bLZGDP/ICTHYqEUK8CjpLu1ZYkOA9EHrEP2CTvNUKH0Xrxlq9T0dHsS1cvj4xY0pl7ddPSKBKfQIJIlNFCIuM4aHfoENz2WJVegY0iUeNABYUTR4DQCQ6UgYKKQEIwCKteCwQI28xkiSMeMQBgNYjACGaPGgSo/rBMyCKgcHX1K0C4vOnVMkdn8RALndVKC8B7EIYmCRJPLRyV+wk2CdkiFFAn4CpS7lnjuKFvaFFPwDAiRAGMJggI4oj+3lfrQGqsETlJ/zAEJb4xQjAUGiL1qiMwgCE1bctNggAI5V8FROwrL0BYIJ4P7399IAHxpaNEiQZ10giIFJjymJKK+EDE/zMUoARiWCW+jcnb7756munm1HZtMnt9Yhye/Zk7X/1n/+2tTz/m18985Ot+rDfp1MMMK1zUjjOaSMe5Ew3riqtN6qLq5t99OsQbWFw35ShnugySbtiYtc8B44Du7rBsY3VZZYQxVlccF9sNW7tmps949xVXQgfpPCl7qDQNMCUZG25weJhRPbz65fd8VV7ZfXR5vbw6qbv2J+LWHd7tLna77vuY344YHUJ1m06a3PIQHWetWCw5sEKhprNzQ2KmNMk3cfdzjhoubkUp7jEuccsO/1Wa8VQkUKwo63dqB0fcrkerzbNgQYObxYL8u7KKTc3C9N3/WHPUXf8lJhoe+fnn376mT1Qb17/vLK60Vhe4VW9EvegGe/P3wxcOL5hNuAMOZJoVyPHSzuhrlDscoLqkrPpnUnKNcViRh+n1OH1TXWp7nxT/ehydZFfqjE4+xvjkk+kZLmxLjsi+u233z579oxTqKZu78bbvf36xpo9SqhScJWuNIYMsQZ4edXhPnVy8mh7a3N7y0F8LsZxsp5KYUxjslMpXGzxihmBaJEZbedSblyDi3SRQMoOl/q770js2tYGaVT7eu5mczkWlotDC8l0r0R8urx2EwEzoPNXmUx5+rvqkilbs9VVLszO9ztn7m+x76SxOLUwGae52TPAXiRrxCjd9vbmzy/fZktUnDB5xbh5isWtGL1inueYEuTx5NFRaJWIVwQiGefN2YF1c2U/k6VFPXR/0L02i5xze4zpahgKiLHO226QqQlXwi0yfkqr4ZkCGNzxYY0F39jwREhCMbpfWrNl1tNszed++uknBOioHtov5+2t7Q3T3Lfv3ha5+k/O8VQEOjX84FiQMWcayvjuRFwDNUX2AJCLGtnfP+SN7KdIrQwH8pNWhrEqgo5CKtunAYcii9S+vGlfwy0ssp7353/+DXcGPaz+D87Afx+Dae1Rv0MFGoSzZEZLuYiRNE8Eg6FoMaLQIcHDW2RqEHQIy6lkJhgdiLf41JsYJFV+FenxMxECgxOYrxgHMjIvIwvsAGkYogofeggsiwouySWUCg2YlRi8k7yHT4lTF4sk2GCWha/CSRsMSY9In9AjBph3Cpk3yEyVAVlkANMzVfYokiDPV4+weoUHbZQ7+TbDkkqAoAj4iiRoQapClSFgxS/anj07ZYOFogHzVUYPZMvxIQsYwKNQEmghF/ilyFEKP2NeXHq7fIuRXJGTIX7KwoCHynDV9WeffuF8Y40hVg5UyMUUK/+vPn/69NHaYx6W4y7Lz6NHW+fHXaeyqB/EpAzIuloLWSHKfA2jzbhNMPrUMGoVz4t7oz0OO/OT3H9VdAzQuLIhHpRSKiCPm+n5OIsYqTSm4eyYW9Loul5vcnk8OTix4s9GNDk7/2JnY73devP+w+HR6Yefvzu7uFjd2FlZqnWsOVxeuN2v4vzkm7F6H14M3WrAHcI8yBRepg7G1LednpwquDGpAxtEhsOMyztrS6rJETrWAFBIgfL9MIkZdM+djPb65cXh/odHW1smQJcDhx8NcJiVw0lVpgLnJ4f6vzav+/sbe1wZJr7/7ltO5RbJuWbqgexjdSpRq7lUbtO5PNz7sLqxzlzAIhQHpc3N/earr8j1f/z3/yMjIGXG45pq01sMT47dXslwz+00Dh+otQ53X5GwlRab9nxtoaYgPZOC01MbuCxykMYQ3fsJBiUucJ988sne+ZmLaDTsxpJtbcWAfq3zjsaytLg03QjPXb2xOvX0OnGKHD8iKs8Y2QRFMa0HkG2STHKwS8Ko58JPYSbfkL3i4cad2HhZpWtXKR6knUzSa07vcwa1PmC7vXrIvD4/g7eUms1ZBoEcwK6vhnTA+7392fk/o9WZ5fiShR9tvSIXrYoesn0SATDTStqxAGlBVexJKwYQ1FJneiCtRhp0wkkOUbtYj2EWrahRGEa4subutguJqmSJ0pNZxDyw4d9u9nKnmIMxrIhoIdQHfzDGCstLjvSw4EMXqqDM0VsuaMgRGAI05LJ+G617eXkRB6J2wruARzu7Zgw0TciwBcPRGfRzsTOMngq1MHkTtmXFLJxvaNq6pWKNDI8jP6WCQelgBp/7cNV7pJ2IW/+QJEfipLx8k6gTG4RtPJdpqAiz+5iBhbWnlI+FNThppxB9wvVZXfOLg01jhC3G9Z7AHrpDocqkqwxgZYAmSCO2PAnsLR6V4pQToSVtGKYTj7JJpeRiQAKTREwm9xMYGKl8xZpMBZWu1fpS5kgZGqn5BCumwEbP+ysdVnQqJnCUbbI4CRApR2EkZY5y8QhLLv6BDKlCXArxSSGwhBFICpGhjGAAZGWIkUrazAVDBdQfAPH6A8BZRm+Uw4NybxWWZIgEj+8alXiypWqTPG8UPlDrp0zhB0bFyEtawNYtkZFl0T7QDNKDjWjIMCQAPGIg2bWJ9vB4fXWt0nTi43HZT3c7Pze5td7c2Vx59njjkXtFRv3T7sn0hE0z3PVib7CEdDymOCnTUQqt9Q3ZzfSGi47p1uyUmcJddPQm9WLr8m04lsynI6xtXVPTtUWbDlldTZpjIyZ5JW14dTvRWGywDrj+ZDzo19rC0YYXK/x26CVbCe6btN+jnU3rqJc3787PzgZnl4OO4Y6V47v78bA7NAzhDhTXEzO796+oP8dJxvLsHV0wcgz15N2MldX9oyN8ZpGns2h/LcTY/O6+Rjo1QkYG48rVdhPxzlakNM9PTm8vnZzTfD/sOWIT55kybJvS2zPdzivUUp2PKRsCbKdHB5YBHN3sgL35xQX7Bix1Mxax1Ax6Z24eY2TQsEeH47fv9li9VlvL6xs7E3Ei08Tr1y83d7baa6tcEzuDXnhKxqmud8aSFDHyZO2xGYJ2NoE775xSWItmCTbQ9nrrq+v8xIm/Y5p4nS4tN4zlz46O4zAl5/hdXm5ttQ2HG3a6dmP3g/bGXV7AidzDyfszI4e7OyfnsIDYHAst91YxhM3on4xRNHGzrg3FlVp1vkqcCNlsZd76AQ8SSsqegBhJWHmqLTkun8nPOeP29zpR1T5tJibTGSyyoUFbv7xwmMeMIyJgdmEDFc2n6OKmr6STNxemI0pKVhfmqctoPuUqYx5cpS04tCCeUCBFotm+wzisc7WEjgM60aJ5wwCEgQSTv7AbcqzjOk3IStBifZ1FTOVmpVstMLFtr65QrByW2KtMtkwwNB9bax89alhBWaiUBq5aP+YVrdtZHqurTUU4Px9pGqa/khl9ZwtFnnaNEnjwR6SGj28xyCi7ZTVes3DtXVuOHrSoRAWBmdKQ0QMeqH0VqZmH9ghFcmsuqPjkQpinBdFSm1IBtrcXEoLt5HISWGJCJ4Bk+PIpdm2Ufh1hHHBtAoMBbTEWuJtITRqjWgkoEwFPyQwB8QijVmTWAROQQNJXYGM0CibVopiorgIMJjP2EwxS8pP4pB6/kOunR1HllXTDJqFUSiiMMMkxSMBbEpDCgMWrEo8w5ICTGD+FgfkJPqkSFlAHmUumTSaKT2ySPIQLK6OkmWnmmBUmLwTLN3OBRHJVm6V4wJA4JTR8Fva1DDz7clEZ0sLz8EiVFApIgp/ApCIuoa3KrrEkCUA+9B0kDwwRRq0kjoKAChKptrdj6koPooHRVhKTf147tsJSSVtr7Y2VFfPK2CF+GU7lRoquL4Ff7xoFdAjrZHzUcckI2QqrdhgZYHcqgU3qdgbQ4BqAYaZ61umHgbXspOMDqhTUnE7CJRRzlfD2k9x4hPmVlwjDhNEXrxXa2SYjWdw4WsFep8mpdt1O7MnF5arNQcr19t3u6d4APXELbKVW4SRqYjcxVYZs81SoPoGGqxqJN5ZhVv228mJCqFeXjXS7+L//YQ+XbN3CdlxlMVFSY7pOXJNiLNzgw2NRlLsxPwpO8bFP6p5rduWqd8VH0zXo/PYQWd3ZpvG1F4f19HtnS81VBiKrxIrD0Lzx5CkFravQOYZZdXLKGUHONTJ7OXx/ZK382SfPXeZu5/PO40eXr1/1BrrDBWu3jqJkLu/3BgvzdcpXDWA4Ost+MSqyunt8bMuC7vf5i0+ODx0dOl6ohRtCLI+7le3gYH1tY2W5MTjvsiOx8yM12t2kplRluzg5PuID02y4sIG+v7LrTWl0n0SXNQxPUiZpsaJPo4k5iMVAJnp0T9wjZAkmlJHqdsYGMDrDUQumhtHPOziv24/DRqZd3NjFW6cJmRSOhz37Lcg1IXQ49vryHO/S7tHhSqNyOepZLWDBn5utqmUlYllCgDsEQv65FkTbjOZZHhIfFzk8kIoSrLP7UAwC6UNOwDoYExWWENdAKyf+Z4m0AoLH5d/YkpM7aTv88J5FnBI1IeLPw8QXp6OU4W82Z4M99vxCQ0wFZLG8HEpfpRitypRWQqcKwhnc9uAJnoMk51BJ6xNIPwV8DUaWgw/0kRSCVgazEZ54jd0bMDwIiCKHy2YZ+ZahnvLCow2qdGDI8DaglBBVSOCJRQHDD0wMPCiApiC8mq9EPRqNAzDdEkb8RxMQQoVlAFoAoZ6CNEay4hNSGsUQI2Mx8Ap75CcGXjGJxE+oonp+sUvAlsi9VYl3wsMJxlsxCEGG5eIBAzlKEsbPjPEJNpkmBpn6iR4/MVQ4n4Ljf/ECABXGyQUfZYfOUtYQ6yxO5uut+WUMGJBwJm0SijfkR5u1RCShREnFe5ABzBsGVesTksQDTvKEEyEwMMI+ZRKpsoA510MqKxkMyQFfxXh7wD88fmbuqHpgFLQI5sTSaKGxaeFu78MHrtysqP5ePH3KWXtnY5OCG/cv7L9aaW9y8Tf15zcZx/NW+RTOGxv6Se2KcbFH5l4MiUYSHBdJqun+wuqKAxh0w8iw73QmepHYiDtlSGk1kBMEIwzF6hROznnODKAUdNnYYm+rETqBYw67cpLJZYzWuY3GMcyXI6cGtavzzzZav/70ye+++OTTR+1VB0fcDW9GJ7POnRudTlz3lyrT/NxsYxvythzxGb2h920R6Pc6Tx4/Mm9cW19BtlVfZlyVCMZkxdsBSAjQdB89efrlV19RZD/8/JOzYhyUZky93Grqz3isUmtkVXsjDPh5sL93xrFyasIWBysHg86ZU9sOPrxFgONjDMfx1x+3myjosFfnSjc9yxhF93k0yvPu2aNHO4ZVe84yYStb31iuL5Fm5n5l1w7MMHBvNo6/m7Rjyx/PHm5C7rEx1rYG6sYxc3kxEL59+YpFablWaSwubK+tNRYX6UIa0rE/zB02ahECVmNy6NDTRUcGNpaOHUZxfjq+vuI2yg7HXm+/NM9orZpruB7LwciMIzOx0+LKBY3q1JTVIDRFEdPQyV614FLG0VARzAzoNF5MTs8RMoiGjWlr2SV1Jm03FyzqzFPOpMvWZywcgqo7uY/bx2Aj/7psEgubB59Lu6Au6JDw+iVsTBnA4qESuUJOu5zZ2Sbhb6R+I5o6ckZhudRF06BUmI4s9jD6V6JTivaoEturq3qvXndg43TD4RbVRc1eL2iCSiNnQ2MnhFA7LeowRoEO0QoD6C/bd+BHp6aKVDkuN1ob61vCyuLJpgcAHuzCOrvlgPmEUUXV8fyGgbFUB2SWP7m83NKU/HGaUQ7GKON01OoGDAX0Ew9KJgvrYDFMQoZSazUW/IXRiUIIs51ad/JHDUMrU150wthDCigkUsU8G+obCqyRQZwSV5SRGOg8vooX8Pb4CVI5lSphBJQzAbwLy/wb8CDR4Sua/BQWI5W694YKR2SX8uSTMAadGVQWRSkX5RGWMJMDAAZ5IvFTOEkCkFQJeHx6CCRmX5MqitJXgih3MNkPecPpEf+AX0LEi8yEyEC5JH4KEyE6WkciAGGiBY8eYCnoMCgCDMoFQI6ZHQAxwqhKhPkOCgpnZAHeV9gIpZ+4JC/42WT9zMf6NwBgHhhQlV1LFlku2sYRrzJEMvzZHmnWfD+hudgp8/Wvvlprr6yvbDgDbanWrCwuq/9+98ApybEsyZIQ7S1O3Ulzj+u4QrYs4xZRsQZojMxM4HxobXB6xiqihc77wR3Hedbe2McYBOjZKcQFtvoKnxC922jQoX9NyJ3TZxJlTszCa2HQiMwICnJcMmc1UzE45WWuvMNh734811yc3Vp94rBoN9HbUDrsct2zqumKmCsDepNjN5MYKWrwGpWWs7zari8vcwbFt3W3Fsf+3mCjLHAJn8eDYWtrS4BB5tmTR//d/+H/+Ff/0/93991bHvQWwBHPqSbGVotxfp5DcK0iqGhGoRrP1LGrEG8WqtTl3QZ7wvXN6ckBhVKvNBlNLkcDp7pdXwyr9dZ8veb8SfMPJyZji/0B/Pr2jw4fPdo28+AeZsnderXq5kZo2y2L042tZuZcjGWxysJauKTj7J7FOU3mH1yclC5u7HHu9swMt0vY9W2G6p3znpMQW8sNV5hx7bfzC3JMDn3X6/GIhZRmYRwzpuzy/pyegp5XLhMlvymsmDc+KKMxYZog5O3aerubDsJxxeQGA5waogWGAYfDtPsyDd051N1bJ4+l7ok5UumKIqNU7k3mHrEB98ZF81rJ7aXjZgmqx2ynudz+8PbHF0+2DBpVCmwy9UlAMY1XYoJrd0RopJD3ks7X0FceFUTsNSIsEtZHEERg2hinKWA6A7XF2ZPCcmyQxSuXdBoJWRL7y7/8S5vybGkyVzDvHLpK4mxoCcUdFc6yVhekF2YBd5PJCx9gpvDZdRyypv/GT5MJTLCMCSwVAno0/DRvSJW9hU+W5P1URu8siEIpju5BpIyePHkSYl8eQlKS5DiVyi6j+DJWlkpyULQHv6HMKDWAfgIThO2ltyBHzoXhRJKc/Ex2heW0bAD01joJUpAF1JM0CWQMIgB5ZOlBLoBAVx4UgPQTgHKKExADMt8YIUtCo3jY56ufWYWJE4CfPslOwFsYHmACMEPlJ2wo8SSkmISXHN/h9wmwSGj/aRgePzMv+OHJx6AJXzzwS4U1Hu0cJORQAcvySg6/tEmJHMUkkSA93MskhBAGxMAA2NtPkB7TOgASevA6qxaAkZT5I1TiE1UWXwyYLCkArFMKrCaO3iAhQQwKwfuZpCa1fkqYBPgqEnJ5eQ/LFgfAjMIcAwyQGUmY2bV56mDylt6cdeb+3ei+ufbYrefWMw38nSMdh8dio4HJ7DwHc2uACiWXRNtoOo+Lb89cbbFhihmn8lRrRh/eRhadfs8p04zXzo59v/e223dQsfAh7eDavknt+85U794ZBnES0e2N43eGvBOM0UaE2X0AMb3jJNQ9O7J99nrQ3X/9497rHyauh0+2Vh5ttBrV6SUXZUzejrqn/HI0c2sIczYkT4flPfh5cbn75q0doh/e7apuzAx+Tk2HE/3Fpbt0DRBl1Fppu1rdKZUcZP63//V/4yBPNiUcYMN59eYtqtxQHM4bOqjFOq6qaBuidF/mDixFHImcltFaqrcbdYe57e++iWPmbm9Wm8sCThc4PzsBH5Vlr1mPAxF9EbtMoWq1LUc7IvRE63JqtHUIdiubv1RiaP9yXLb+T6U7s9NJn0xtjPN7h0eqQ9U4u4KAMSy1OP8NR6eHxyT+wrmztv4618wm21aTzDKjkAEHHuAncYJEkaBtF0dYUkFEybk6jUlIaXq4ZehJv+CYiDMJOj2bndvtFaXXIMo7ttdZesWc8PS2I9bFluPxWa/LYu8kVKjUAnOO0Tcbo73lKlNZzJuNKoi0sb+smf5k5CnCbHdF2H+wC0keBFNA5N0ftnhMfeI0eeJxR0RHjsJPLQQh4QSPsd56/TSqMOJp1k5+tqUWWirbjEotmBVZBY02Mkkvhe7CAVsQg+Zy/B882mDkWFSztAaimjxOhiRF2wzdyIIgL2kPDk79RIy9UjQA4uFU4xD6CQB5fgqUtGgsJtYyaAaALZJjmoQCIAWwyCfw+CM52fMp+xVvDIZNjE8KIqNS0XWRMZhnDPpFbyPexE7zMp5HmqUm4Xq9YTYAOB6gngwoszBS8pGY/swOWDdRAEOkFBURvgqIVFoUCHsiv4ItKVMGD+RgPEquJHKh1MTL5YHFala1waDMJd9Q3AIyEpn4wQsXTPEJJcKyE/DkV1nI2vNQIjBy9IgB5icY2UkoiZ8pLjB7xISMFaNeNo+MREZKqrTg+TBkPYFUf4iBJ4vmZ04nQcoUwhQIeOQokrwqO4TiBZAkEm1oFvBTPBqIoCQC3vBnd5Kc9DMUNBNGWQcjhTAnDXIURgxqcZKjjl0I5sDMGGsORr++tOv3xfNnjs26GMS2+4CZmnQ8qLmimXXUy0KsStGaqkbXr6kaF/L2M2ZJJiiRrthhzv6RF/uCTE2kqVTuH+i33sAZY2Ntvd1sUbWsOtLGyWlGyFG0mP1AQlYlVytMNMoOyVJz2ZIA9sYC3/y8BHz4EP/40bbj7x2m5uScdr322bNHG826o0bZkZtVjqi96+Hp9K1Db/SgMab5/vsfDbExUF0Y4eJhbGWdj+GFSDMhNfVh15XGr4ygbQC14dbDb8cmERrWttJF3WTdsXcXVIaheu/cKl9sqkydZXxKnZkQ6OTaHFjjAoDYR2qQ2+/aOlAM48P+uNu5u75Yb7U4qYfz/dkZX72WqYmjKKuLmxtrOrn9/aCzbATVlFUoJRuSD94naw/O8jOGM5zX6vGNWc9dY6V+XXzCo+hex4B4B3w6+m1BU6Nh61VrDBXnJSyyp91srK+nrdLJ5CEezCgOXLIzI86RbzoPGSL+BT3756554EflqBfbpozy9A8CFpAHXV6wHytO5WhRDGW6alfWMOvJjnp1C4QNWoyApgtIsgGNfJNYyjoOn5me3jvY15SXG+Tw5vGjJ5ZhqV4VTbaNJwg/iVI0qzxGBqE3ilToD/2ZmCroQzMJyYlLHMPRTutxXrzKNQeik4ob1KT7k6152GcttbmIFQ9J3rqhs96gfllO3CxNYnWHGojprNrBZwKvZoPm4tRuhKxBEk5CyCf7+fPnJCqbMDoRqGtR8Eo1qkAqnbI2IkBagodllxzClAU8ao3xECygeWqwwolQu5MQGygHFeDoEqmc6E10jb4pGTQ4wxES8owApIoB41NBGyZNszpT86wmzAGABg/MuhMBwDKK+PtwOQ2NIypkwre7a4zTSDIQbqQUAq8FRrgYo99o2tS8waMcvLVtrhTW6uLQkalZa3xWXKwlavBpivUVuR4E4Smis9io8cmfNRR/JqR5PknsLSodCXWWpUIeHaQmcEHxcBPLhMV44AHvJ+J9Mhj3UxbYJ0c/vcXIV33AA1LAW0KPXOBXbR4/fYJTLhnvJ1TIoOVxSvvxE+/wysPNUVrwwPxMJFispqhNwwRWHxzTlTA36sWy7AhT6+ChRZu08lUiP2FIUn0VD14M4fD2VTVjoORkniohIuLBAMU/g1Z/zKJZwQgzzGemMEbJ44LPe6edfsf62Xn/VDtpr7Se7mxbDGTIdt7PlXsgO0dzlfvu2R67w8tXb5Q05jfmCAtzxrCuW9CEGNYdReC+X8ss1ButHHtNWWedTVaZ39v74J6pR8+fukfFEJsCdJ4l+5JDWRr1VmmVk44cNVV3tZajQHVeHpMLTjj2/dCkTing2YM/ijkc8fjkYjRZXWowD1sxdvMiM+vG2iadYnDdPz5anJ7YbNX//KsXq/Wp+bvu3WDfQf1YYJXYkegr62vs2J1ul1xyTN3be6/ZqFxiwLaDUaxphuon+++W5qbuLvp38Hb7FacAXd3uuVzehbfVhhsTbPR14E8cT8SOG4fNDfRJbOKIVN2qhrQw3aii9krTYqyC2EfN4ltjTmECHHYuu2cTtxeuz9LFyJe1lxRZrOYfoy43V1YsSPz08ufW6qYTfhiCNrY2XVZ/cnr49MmOFYTrq8HZyR5rvo5Qn8oxP4Z+07N2eNlMPFdtcCh1PrM1A0VzzE6scd5fsk51zw5cXSDZtlWQyQleUETLoNo60II7sMYX1nnqlTqvKqqKHudGc+Oq4V6HKmTnMcPhY8tnxAGsiuTPugpbe7Y+C77Ob3AadlErGu3NqDBhLs7krEU3csfZ6a2+KdrdzbW5gtWwpWbLTNApHzbkLczXBoOL9uqmY4z23NHc7WliBFsr8GjODEHHp0fz7hmouF3uemZuWs+ggzQWikVXqqaMBelrJGlE2cMRqhx72QzSbCzf3F6cnR/HwMbRQ5djHarhv2al5aJcv2usRdQFCJ5iWN3RKug8PqwyclzgQnWWNAu4b/KHn763Uq8TNkwjS9Fyw3A9f3i0r8nAiXLNl1JRQP0d8z33f+slZuy6PX5Ymvbqelu5Or046hglREIkFQuv+0VdUWC/pI2PnbMOQ6tGzuimw7Yk49J0V6y5I8gpfvSG8nrrupxponPl2oQGZbfKrQiaeSbRvGx/Kay65RsWGRlAB0FOFgkTTjyI+KcPQXl4FFLYV25+NI4Rlh5Pxsn0/JTAoY/KyEXbUDfQpuYSSVt5BMRL6CnZhoaVyttXClFC4kLbesRnLlKBz3qVXGebYAijE8EDEMB6TRFTYJYcQj89AlAJ4HWqbwBilAh5kAiACaEr8wCSl2odZl/RYLZoAJiKm6AAk1wASfKFGZgwIkWiMHhVpiDwK5SfYMSjU7zCJmd8zYLIQjwkyBADlcegAEKUKJHRcbJIvNwlByZgUgBJLIKxw5bOTC4e+lJJMUFZCLf+jhucUbweXRv4i7/4Z3au0oZ8LzpnJ5QvzUUhGffPV2blyKCMEkWDXO5bz5/aX6MjYcwx1lNGpFrmJROEXdbQGs82Ww1Dh3G5yFNJ379955J3smsLLFMwH39hskh5GU3o/dkBklrFRB4drYxZiiydYrI+nZyeMVyijI0BT5Bn4Kz3cl7p+kpzWqMZ9Vr1hc+f77Tqsyf7b8+OPxy8f3N+6oSZaee1OUnHAcw8042nHDRv1ysxQF6M9SrzVkS1BjvDnOrDW07R4LeS6BzCGccwWE92FRQH++VlQ0Bq2jKGMUpWHyaYgaIZkyGM2nStyvRH9eFGHf3GtZXhu6vjg3euINB/OKNGvSivAx4MksJPxSFNN1cxai/DQ8sB29s75EFF6wMcDlqGnhQENTrc2FiTHUhWC9XHPIVUOw9cN++OLWv3FDcW6X5Q02ouV+fzrKeBq4bptcc72wjWMhVHKdjhjJ+tA6lrsk1Br6yusrcaEeg1EcDwgDnu/9I16P1tMet3z6kMmMkeTR2DD0bgmUnb+gw6LTjGtGViYndv/6zbQeTm9k5v4K6EW/cem6XTmWakYWEL5z3OZhf1cMcKNwouVfaFUNK21HF7NbzAJcZAkISEdtNA9CnQR+cny1/cDrOhmVDiv1oo897wWWRMwyh9B78CHYTtdLbHLrmii/Gu9C4UJRrMqCQkddZFHurRCNqQV79i7qH9gojmaW665PLF/v6hTVtLWodHh8Hci0LutuBTdaAt2vJMWHJCKspgVMV5misNuWO4DAETJD+VMROiHyvIp1UoA2j0981H3ShZJhYQdTo98kNEJdF7qWsZoVAfkJlyETZEgJYkwyx3lPsE/wMxAgiAAWHG8TF6/aePZB4x4LzzZ8h6iRQjmQdqMdFEywQtY4QTEkcIsa8C8IjP7EWqVwmR5ZMHHsInUtiAXUAqkZQvohEqAB6/ZE2XYSJ4MNgELR7J0VcwAhJiB68GPBIolMaI2yMMBgBK5O6B0E/xAn4KSwUmS5SDO4MFATUdwlQuwNEZgPfGYmRIiE6PSD8lR6EsMjsxwpmR5DSyr/AD8yROacGARH+SkfC+Kq9POKAsAmKyUICxK5MIJHwyCgymZYwskkVJEtOIr6rg8ZPYiI9CWftJ2ki8AHjaQdHUguYBCTXhGLKjt29VDaH3tNtBEhsI85d9ntqPjQV6BeNfDSB88KcmWPUhYuph7CZpuE7SAuA+DrKHVjGT7Xiu1LJGs+Igz1efEOCtsCqOkYsxAW0PfJBcuaRyZqfrBChRIxo7PBmIvvj0ye34ePquczU4OHj7Y+94rzo/zT5TqyyybdQWHFzffPt210GV//j9t7VmY87F33eGdT//6ptvtqzsDQYrG5uMG7FNt1778qtfffLpC9bT73/6kX3MEHu5bfCh1Yz0mopmMGOzqJ9ZQNrHqFP/VOPDySM7TuvV5Y4M/zlbODdtYX7GeZz4oHTkijVWQcx9DVSVv99xMGistCl8uGbyHXEke2MJAVYmsd3EhYkHrwiqvhcGNUIAsn69VaiOlZWcbxXy4qIVCq+0ZRmh2SF3QbbdAKM+gfSk+HljL7YXquZaqyvhTzNje12MaXwFiTACrMrkaIKr3nMIqV8EoFPRexlCTLMyG85ato7jRqZsaObjxUrF/ciIuDhfxdYfOcPErmBpWtGCvKJthDU62alfYAqr6rUt4/RiQPpo0BAJ0pP0xE8LD2XSDI9IMX6SKG9PcLUcr0bMMF/M3GwYGwDLIk3zOh6LGZIA9mCIr1aU0abgFE7qH4Thkk8JKSCmWGbC6Jo/ZZEt3U+R+h6cwDd5KRR4LS4bnVzUpkfuUhF4YCZMXLyofoYSZRRD4YZpeGY6D8yAxyMLNJCBvFIQ5sydud/CjMlH5q7I2UPAjwmKRh8Xs0V0cqFtPaXI/0nLZ0p5C/iUAJleeXBExh4BMGJ8AiMnDzIzIQDJPcmXDHv7mpAZllYWYvzEZcLkJ43jDdJbLooKzCeolFNeyp948A6DZOqT4vkKla/eScZDdmCS5vyUZMMvkLlAKxcYvD2AIReZmcIpIC9ugmRUr+AryRCQXM0lEqVIMPkmf7JoaJMWGPwZFu9RKJBkQkaJwVvYqF9vL1P4kyRowfuapUsJE+mBObNTRmOfjAQZDsSGpUXKwaDNEIMpGUjMEubmeeZpbOCZYvBLiex49CaOaBCQhAqQF+0iC8qRwLGEerKmyJaMfAcPgI2MT71irmyyY7QRjEXwk2aoiikuJCSBxXiUHQaFFY9IwAoIubQYKJ6iFGnVD0ezFogHoTcg1YyY3zfW7BSuMWhtrTZ/99XTzeZMZWrUqk1ZG3B0/ahz7vjeK1uVMH9o89nQOse33//p7e6bta3NRruF9Q7wsZ/2p1evDX75C7FssCDNuy9pfm5za4tCJAS6DYsKCFYd6OR6jdVG/VaVFcfgQvGNsDVpkSgH426v4eBsbvq+d3Zsa5g1YWY3RcBYw1uzEMZ3kmYC4DhQtWieBYnhKJfKDx/27a01kPQTJ3W6Ehr0YZcpGgkUfv9ulxVOq2m123HXm1t6ygP/H//4R5ipKh7x+uIwTA0HnJ24h9qFh4E/vzQd+h6RW1sb6hTzdbt+ooweI6IGSmxoUNGtNI3hmBUchgWnd4SA3lyTGW0kq1INesjqwtTMRmuFLPnJRNve3HSMFFOVYmA/e6DTiA/39mn/u/ur/cO9soobB5xEzd7x/4mDg4goAqgpVOGkBzYlI2bAIqfiPegr8ggbMtQLsDjyu9i0UaUuMFMqqzVaAYEnRUTIW3J4CJg3YZCXBQvbmNnBSiVG+Zx5InNomY/Bm3KpLwG1r0VIiGlMPbQRPlsYgFbVk3YNPbMALDmE8AtIxaRDzwXysqjpUxYNTgCZClUAlMun1VVLR5c+5YM+kFZukwDcRgNgmSa8DS6Gi9AiD6/ESwgtCrO8PonxU0WLx0CnEoanliqPb44K92/kRp6DF3S1FYDYh2G3d8yxQvsH1345NUghxQSe8nz8Wly11Iq4kKRfVmiBCWf7McAQBgBpZFMGgFp7VicSgUXFFJ0hrDwqwE/CQfQVGxnA5IIGWiz1BVQGI8hQ8VkBmalcAAiLBCO5R4x4AewQloWEalF22htdCXl+gl+miUq+XETE+CRJ6i8tTUCmTtmUKtkNIGEK8eeQy8vbz2RXFlMkqjTj/JqFQg9dDI+MVKQWixvqezgellJE5bE6xQhn0rrYNGrl5XAennlWXHHSaLSMwngUdNqtZc43llt++7vff/Xlr7ST5sYGHVpxVpd5wMW11TBHI7pd+OR8MGvm7CKx4Uhz43iOVGS4KX7YH95dRTOTp9WYws6ZiYUwIGApIrUxpxGSxe2dHQN7nExuZyO2jh8CFBVuyB6jMJiS/1h3excn5YGXnbLngyfnTKWxbBw7J8r6HkXHys+vf5FL6Ogimq67AOam7l0CYtpdWzfPcsjt4Lw3mrxjn2LNDoO0G32tR3TGLoSqIYwj+V/9zX+8uVP068++/vrvv/vOoXWWfNl8ltc3V/izT027vsYqMUuVdS2nPlj0YqBQRxSKzqRrF4QZbJRniuKwmDLpOOFQMdg1zfE19Jdz3MbDuYnrw723yyvriGSu4/X/oduVEjYVStIs2Ojf7Nk/PPgwcPRCOdJr5/HT589evP/wjgmFv/FUK67krdbj4EKPDlVvhO04o3jWHsoKbt+JoXbxArAPi/wQSHYVImSepNT2pqmdH374AVc08Yu7+w97u9uPHqlTQquFs4FVHTPZV6FTtnQt8jptNMlP5ZbVe44aZZowO2FT0gwtyto/xYqlEmPEVhbzDGLH/Zvu+ZlamzbBMrix9ddxILckpO6AV90GwWPxszo0urQPYWDNY/jzq2ywal9v1+kNjJKNgk1BYo5k2MdZmQ+bBTALUZhcDocgEiRHYcmnM1JdZo0hJKeMWkP5kjE/XRUUt0WUm7MAKKwxp/WMlXaTjSssVE5rvbl2spMqphtZnOw90JqSJ/AYpbOoqnrjDNkx/MvRz6iF/WMaEU5ghsGlRjjdh4ZBp8cn7/IVyrjXF0kZA0y8txjqRSCQF22mgfBSBWZUgPJMAg1pCUEsZgZdg6anpdPMIPUHlbX1bmQd6w2sIeYtJjfmD4eHR0So0Bm9ixEm/DJS7dECH+gQyLBIn+WaP72FRcomeWqhHq2igelKsUPhVEbCA0uK/dTK/QTmgSGRZIwwaqSFMyCLZSB0QVHNuF+y+Dh1AkDFyAXpEpZajDlB1oSfgMUnzTloBflAcOaYb6gEPOCFEZbEPySXETw4m7loM2KEmUeMvMzEhY18xUOCbFnbiu1YPsT4JOahsJmXetII4aTjEiBLoaQC4BWWsvMVDR4VrLl6BJK38AAGAIkAPSlTvJIQDWAUmc9THnoFg8jgeDxhazIVUMbNx49/85vf6Kucb+wmxdcvf1Y72hV4M2QCrIrcJHXe7zlnC8Gaj5VDWXsklzVIBBM1eA0yQulPRD9K12gMvEvFCygVSEnwEM2SS6LgHmtIWb8AJPQJeVIZVT/E+JnZ8cJXEI8hiMiUIEmUFBmceiBkxTW2JZB2+vBt2dt/u7rSvh5XP7x7O7w8mZpv1BuLQ8uGVrQX7pyGtn+sj+tQsnyi/u2//bccQr64jsM2PnvxOaXvkjBrFLyAeH/qU59XFvm3XLEBGi9y++mcW4100yGSHIjP3R4z1RGv9u7FuSULYWNZdDLjIDM2aM5MubOeK7zTqZ0EZ11ERbuW4Oc3u7ZuMR04zGZuYsqpmU8eP7bq8Pc//mgKYr1d7n/87juDt9UVx71VD/b2beOnJpxNxo0P0wQMS2krYuDoGzarYOaCnV8xJHRDmR6CCAkTFW/juEGvY3jkzV+DgxaxPHCbjYmO7f2468wVd/IYNXNHGV/YrWFkaN1DjEqkcywUMbW51NAIR/ce9VLkYfK2DLQnwvrnEgFialQRfkQzNacxWGzoWKubmGwstSYuWaJimzaGW1M2b7LljhhoAlzy+ZJCqC+xsIGHXLARFU4O9yFLITwxjxnpGAhOtIXSUlKKLELMXlDKdzFijfZtndzuEwPhuHNCEVQNF359h9EPtH7qXfTHNJSxvzV2u46Nay04x8GsMSu1X1Jn5yX1fzLA+mR/jfm/ZQrGAD2s1mezfcliTjNUcWijmogoYPEoR5C3fJn3WXCVV4xCJQ/VpjmoJGoEZ7jbAlZ3Wg3DM56oQaK0ttZGtuyS7YyIX3/99V/+5V8aKJjNsRlIm80NWnnJBRLAaEhlgld+5gNALqVwOej/5YPEHmk84sB5xOT3ZLefGfkAIzOlzXgtHLDieSubT8BE4ogYBchRrU9+KpiSg/GGwVtpIRejtH6CAQ+bliOeClYYqJTWp7TfKXbmDl5GDxxHbdIpBjDM8IhBj0+epB/ZWVveYuQbWqz0Q9BmpjS+eAsMWTo0SCVfOMVkXQqDQbmfwnLMsqtXeaEBpCx8glbAQ4PgA57A5i0vqbw9aBCWSqZ+whBqtHhYJcGS+yovYGfF01HxQykXG0vSqV+WBQAG/T/7/W85UzJZmNTzN9fxcuEx7Hf+AxcY12Yz/XOTMNCLmPHw6OCAGd4OI7oz/AxnYiRSbzZXNzbQhlpNlZbx+fnnny7Vqm/evuJXacHNn23AVtIc7GOkqUDaJAWDbFR5pEWSR7kU3xvN8iEMGOirSMCKJkfwyWSF9QDGdlurQtZdkbgw51Q7Rw5wzrdMad+tE2bqCzOfP3v0yc7a5OVg1NlbmBpP3/QuukfOl566HW8Z+l2NcVxlOE7Guc1cSmLjVIe9u+qeDVVKWxUntQlnElAku+/3X756+/LtOwtxtjtZwaYb9EDWOdhB0aD4jC12ImhSZdXDAakktG8iZFoGyJCTQ6e1Ezsk7DNwa/zUXGXgXMYZp+DEqeA6aSt45gdK3Wy21WPM9B0KwcjLhbRzbpmX5frk+AzzVfSH3bdYQQ4xTQDfqB4BooU2ARLraMw49N944PbGigzy7En99MUnzD5On3ZephNSJcdeCPFc8U9Ozgj1Be++5SbDPacdI2vjcbKnRoiqRRClNAlQwHKqUBHjxVoceHp1bTPIeru9s7WJmDjXAleWGuxYDviAxEoMGD2NM9AQoANT74cHR7KTO3lQ3bim7GTAGNrQyFBVJB2hRCSBAPiJEsCaKqZ5HiLF++oTmhLYhMOjdMBgAyBH8PyR8ByvFNmhlOI3NrZUvK8ejdAoAwZ1AVVwGMLSCcGmQVFaprko8AkZe3v78vUwowHIXARQ4kkJV0HixYn3ZEb59hMSYTCACbaWJSaHFwJo8EY2klSEdqremWElEUM/KKCMlJHmVkxaxLvomehj9PpRScXyA54F2PY3Lp0GjDEDAJFv6WXjp4DCZDgSlJ5AjE/UGOCkBt2QAsZHA8lUc4kNsE8o9gaM0MxCzMe0zLLl6I8svFQyyv5TWjhxQYxBtwIn/lB/Lu7Y3DTelDbBkhH4BVgqAJCoFUmEZaoKIRf2htNbjlkWXz3o8WSkCoAENj9h0OXQSgw+MpXQ2F8x1ZDc5fJQWwL6IW8wxFe1JX5ZwyweEsxBFTKypUHuk9wBawYgPTHJLUUQlgumycXGRVpDvJ+SwOBNqmUhBp2jOHIr3OaEfRJvdVSAjBomkWH+G41qtb25/umnn9IdTgpCJJuGISR7kWP7qT9Po73ScMnUzZ0jo2kN3EbD+va2bRqI54uXrYi4SAIDf8R6s3F9NUb/RtHaJu+ark8GqlVeHCpuHC7SiKcOgOFbcUKzWSx6dI9aw4QQzTgcIgJRFh7XZQR0fq6fvF6YoNSJEMMjISleo3H/Vx1a8k4tXI7jrnaHtTlG9Oo6LqEcj26aS7WNjWUnnTl/jK1j9+BwcXahf/6e7ly2PnB7eeQqkqmZ4/2D9vrmoNsf9EiXiSyvBDsnYnPyQjWE4ez0mAszO/9qawVD9g/3mUTwnk+OaZ86teE2tzXQn5oKC4Iq4ECrdM6x5n8JiWKGGw2H8fYq1UITr6yt7759d9rpxUkItfrLH763Gr+xvWUc98PLV46OoIV9MWLBT1ZJy++6EzVLJDCT/HzxxRcWe89O43xgMEa5bP3hS8M1Ja7JjGHTd999p51vbe6QB5UCzLxNNfnJtR+dzVZLC/KJDz+WUsRS2VEsa4sMU5O3TsUwtnJsNWG7L3ZR8uzUPOMwzQQlnEFDJrlZD0fInrBuWe6Nge2k37Vq7ZSPZrtyN18dnh65dZmEwICTS43Gq5c/GrmBPHB/SxyLFtvE+K8Rr0rFEXWGU5VUI1Jho/GKAIMbfhomMHL6Sqi0UziR4YQ6CoyNjpHbhWBUQoicNjXpcmaTmKqLZHCAJCu14/9NAgw5rGw5JQ0ukNirV4sajJPdePPGSSVog5y1CevkSI2oXP3r3/zN3/CKRgxlSXpFGlOpGjIMJmOUVHKfUCgt5zTM9xNMaa8RRgxsshYp31z0wnCYJRHI0pkZwQat5WhWH/BmHlyOa2GdCm8anFQjgFnL8UTbR7hPUd1lu7K8PFZk4EwyQol4FDgDoLHMT3BigunFGCIsY+Esla8C6AbsDTuBACNvPyHJ8kuOHQmWMcqDHWgli3iaGhbapFIAME0BOUYAVhLKV1E9PokhdgKol4TGpF/AC8OGDIQlfhjAiBTwFkYMYNWhPVpPEjAUMBP1ZhTRD9KYlljUpV2KvNrPz88MSTunZxura5Qm31eKiYgbLOs+xdjbyZ3CjLK9HCfthPnl2raaBhrUkwc9alQg6x4ZWKRcNCO+4RhpFknolasIXAgW+n31IBh/WJZ04CKl9WBd1GWZB2iloWRLX0JxgMFVrABj0y/MYmQhI9h+881X3LoNA3W1cvEVSwF7yI3c2XNpU1/X1mz4nGNVkNHhhw8ArEIiMuGHv+xRNOCg2yz5ahyOUjQMUVhZGvkbDbOQMJWgStHkjjBrFTLFCgxBYcqfqvSIV00gCQkA4aQ8eQhS28RYYCTEJ3ORj6jMmYyJ+l1nSjPWB/JZ+55sS64/3tlZqs9vbzQfbS8vVe631ysTVyf347PZm/7p7uvJ8XC9VnXuvrvJzlB+e2dKpLt6tL1TMWrlvj0cv339zomSbqU2kN3cesQkUFlsfPrZ5wwD9UaT3YAHpmtVKBxr6WEcnzLs0nBYpS2+uLv3hr5Qg3z2VSULOOIV0PqJFY+r24knn3w6X2XXnnn77kOPL+fN9Q8//GQzxNdffanXsOChOJK8fv1GLat6JGn5v/71r92aEuvPNzcGBzgMOY55i8ExT1g/FlwDOdQ3xE5X90wdHnrzkWD01hrUqSMuNrY2LCnRctqJjKx/V+arjrUR5t1bTpmeZQojlCa5NDUyjEV0w9pF7OmrV52JGrsL19Z4HKkgTdWgMnaNlPM7yR4F6q5aVjWzHC2SZ9O3337//v0eLc/8pQflhYVUZyEgnvIiKqoXAX6qYrKBCVm0IpxxLFggL+MkMEQUK04OY4pMG+CSxhJMDpVmmttN5qAcJGxF7Zpb6CNjWKaCtBLL7Py8zzodRFocIsOG+7gha9P4hTlnvIbpyeQUBggRqcn847d/go1vgiluu7liL5QprmXYk6NTgdhXGCcMsStZwBg6CkmMoTeeIE1FGN+ZghmEm/adn/jvDCscGuRt7d3Mz9KOwy3ioJSyA9xePy4JIr05eukLFZzvcq0yQ8NuuBfB6OTDBxzI1q10Hm1HKRQfzdiCYD9JCxjhEBWxvuGIgoGOui/SgF9ihMGJhxe7M0Z68RJ7qy0BAKofgHYOw0MeIBEhLfxgZCRjj1RiBDIGWpAy8giQadUMQOORhQCE0CYZCQMA5Zmd5BBKCOED/agSI15BCuIYlwGASq0L0GgQEhqoqLbkjrDpFap0yNQrsUA/YP0QnYUSOXpSZUOryLIgFhICkAWYJBVyBAh7oxBOYHKXCnJo4ccZ2CDx0xuMVA/ESCVS7t7QJjbJhT2+euBHgAcevIIz/FJKpwveyIbBx3z8m6+/smqXBMvCo0Q4Azmq5JsDCnezm+gadqgZmNEOJwAOKxonhHLxU+6+QWIFT45YjRIc8NV2f5Mhj3YIEn5g5A+ANgMDVYuMLIvio1wWYLy1DaggR49HqXX2YDyyi0U1K5eRNiaIZUtBcMYn3HPeESTqIU4lioPXQxjgbbhz0k1Pk6PW4vSvXmx9+mR1af527m40Me5NX45WqgvrraXJ26u9t691PlYYx/2eM2H0JbWFeZ29nozipq1katU2Tg/W9y8tsxebBekD0K8s5IGxhWGE8ud4GVYpViYdreFjXMq4yjCngRA29Xmwt6cU7/c+vP+wTwk5HvnG4QpWFy+jw9BbW/NmuTHN/eLTzwwpsILy9dNARxltGBYjX/K2+3oXV7EuqxK7bFpGl0Z5fHSCZhMarUm3oZoQib1SmdFycyJSWEndmGNR5SBR5Ss9i06pjP3po/pya3ahRjNWbCmuO496gQzbCIdUG4MfbW03l120cETdaa0q2leVik5VRLsxPNKB2iqpxgsCoe+0/H123qE8TNzICVG0RYPwWLdAJ7dayWN48cvQTQHRFjJBH8cKZzQHbz9JnYomA8puGQCTQ6LKMFwq8ZCEonQHTlFunFmk9UlG3AfoNkNflxxw3TUzIF9Y5KvRoaSyqNc/WiNhhk2O3qlSIuxutdMhhAi2lo9ITNZSKBNCi5niRSJJ6cCbFyZnSCwm45U2Anh5eQkMtB6Zaj7gg4HFDuGtFO/d/VlsQfDgsztkEhVqxYCPoUaxneCJTMWUphQKSkawKVqyURI/Ze1t+TE6BB8kLuRamNUThH6Rkqsx+sx9/BRP2vJ8aqyFhYh74yCiJQev2KjxU5YCkYf1r19aqaqSkZ9SYQEGEQthwJIjNxptOD+tknUBRUq1knoBgIDkcvFGUta9XDRTGPKnLJRIODNKNgEupYvcCZwc5WLQikiFktxX9EMiXxiwDxJgWSWZaeaIcoRBogp9Vd/ykkStoJBwwiAAWKTHV7kkhcQOZkkAi1d8qER6KwVswiKTDO8HJAL5IKngL2pUE44hQsw/pVVT4Uxiz1dZT1ZUp5MZF2gA8D99/GjFvqcY6vbYJbiF9IdGfJw1ava2OBKHy7n2pE6xwvCTbdQRDbwIjRAoMvvT528p68iFB6YS4YNiemurSDVp0M7KPhvRrPza2HwZDl+VQ4fdGjZCC8hrNpkQqssYHhW2q9ZBHOIWHuJitFWFxQrHEMRxY7EV9eO9ESolloAnjNEoCNy1RBcKB7w64oXRH1oY12o1pCu3ZXC6cHL09lqLKr65n2nXp6yQTF6eXsh7arYz7K6210zNJy5H1+NzPk7q1haw0SC621qrRZKUNFpUuDwuWBHp9J2aOc0UQ9xJuu0Q1iFiGG4t153xsdFyIow9lwu8VEnUeS9OY41xov7LZSb3bmzum267u8bSKwfvnUePx/3Gn/7wDywaNJFN9kbQBozt5eXTk+PGUt2mKPqQuJKcoyOHSXTsfiB+KMQ3U2aiZbAf7LoK27Eqc9/95ub2u3dvKnF0z9Tuuw9E7nACtqbTETCOFOGY3c3YZ7pCcxhy0tfRqzkiG0CZbZ93eiRAAS1XxIhl1mAzFJm0Joi776NPpq3e7X4gz85KMsOlE6dvZq7v0RIXkNmIZ/HckUC9TteRcFs721eD46Mzc9/63U3XGyXaB891Wop9R+1rCFAZE1IddBKBhFQfqY0RHk+Mi4vIEeYQtbtrG8rMKrTHre1Q0x66hdsScVIs5xY66aJSjfuL3EwRbZn7l7ulmTE49Lhnk1KyzmxCf3Vjbjk1M0HdKyM2QqVGtUulRlvai02Prnm0xmVHhFx0DKecEgSYYUxChdKRExts15zVFDJhCGLjWJ1YOVBM8QLAUMJuJiHNJpISAkNg/EydoF+x/Tx1BYabOelmZUEqdOe4LhL+oseM8fUlccwi9GVoHc5CqdaCNVpPeDs41z8WvcNiFQ0nxldhKEc6LB4ZiyFPiCPH4kkbEWQvllMm8QkMisVk0wUD2FcFkJOv8CuYR0zGCwcjSowSyhQGPxOVt8dPyKEVJlsPMHAm+x7o9EnW4AV8gkou3pIDTr5HmUsMmIyRxIM2s1djEM5VUqkqX5UdmJLKWsMWQIZ4yD3AFFB23sB8MkvQXQlEayw5AgOPAA8kkoBXUpFyVBxvkFl23U/qbhgkRGdkU6rfG0yyNIuQxQSTYA+BxB+6R39Qdsn5BKGsaeHCTXd5x6Aj49nYHdGspDIblZOHLTOeKMWt0pnVkUW2eHXk8A/5xzhdQhxTItQSa5JncRKZhdLwgPZkXesStB/AqEKAJ8uenASGD2LkTqDVIwCcNyuSiyInY8XAkPxMeYBcwCRAt4Tz6CksjPEagfZTQllDKCwLgsJGzNmJAyivJ9cO1+an3e/Vqs9vri5trzacI1Sdvj3bf1eZulmpu8rxfHH2fnbi+vWPf5p1JfrcNOOCIwGs7LJlKSaCXc7ChYUycgcYQ1DFBZYTU26CJANaigKiX48VtsHxkLpHG6oM7RXEzEz3THdvrLX54bjv15FtWO2ISlwlhIYVHz7sMtHs772nk9ZX2u/fvcVqzPQVNyiLt2/fqg9s0PjVb0jY9bXcVYos5GVgrsNWK/zrOThx6JTaIA/YZ5997s3CAxu0Bv58MBUKWt2orBUh0I4Zr0IbEH7bjqJdzc7X6sirOznZzYvRzRVj5s7WtiaqAlxKo1rVARocNjtZfAuN+l2p5nQ3B9LHvI8RrF618QKbXr56fXreV9X/4l/8S6WADT2Wo9mUVS0kgSdHpcVsgBiMBWYZyjvDYILbZR5AnpWD/Our+PMIG4vqGCQkCcDMGzIhMgiSGG9yZL+bAUUIVJxHzq7VkMQnTNZYImHRJ/LCf5E6fl9Thmk+wDpGMJBrEZhJ99DFxJvOzRad+YoBTD7pbvz3E7fhlNYTbax47IiRqRqBKpNkIwp5LsNB2MRnWGWZFyYYsVe5EsodQpESSuU6pmxiPomRXF4gM1NlAfkRXXIKleAeMgMhfeKSsljMiz1nosh0GcurGmmVDV8Sr0pRMSKjF9HLlKVgZQOgYMlWehBCXPYVp2Qkrbz8VIYUaEwU42syCE7kSY5mb0+KL/2bZZNWwBOlKtZ2aP1Em7TC4KFSOrnTPkyWfuIjVCIlAUb1SEIv+4QS4wSfPGAQgwB0mjroOQBjpXJB5Q1eQpDwyAukx09vhJmVAxYvRrnAaK5QoU1hsxn4qauXETyAQUroEQPeW1i8r+gFnPhBCTjwABnTkzGBoIlAwo9Cruixa2tzU9bu51uYmTIq80kGOkDiZEktdv/HsYX3F9cXTs/XpLntMGDoQaCBPITiMvb632vebMo+2sjDTG3fUDmHVsdjsg9tYC6SJw0Rd8IlBZNNQjHlmAXx9uhZlBG8ssDjnQ8kWA3ewEATjA4ppMlmyFiZx4cocuibskEl1I5ruKIG+bzP8uO+dQ3LHWrCRKoPcz5olXViRNiOTs5dKL+93j7vj09Pzp89Xr39cPTT9/+wub71q2fbe/tHliGatYXL/mml0eyfH9P1qxublYUVLU2RLd7qgFhCuMA7/44dG5/ZfMKpPe7YO6WhFEQj16isq+Ah2gwAsM02CmYlBUSX8ugDHD1N4zA9L8xOWnfpnZ9YW3L4vZPj6LnuaPDpJ8/Y83BDLgSDcjfHImmG0pgjXtgnE1jWZKjsrAW2srIWeu/q2vnVDNn7B0dWKQ7dPVmtEyDk4anxH04aKHH0iQtr4whV3cwSkYLQSr2mai3dolB10R2KbNdO77B+QA2VQcnsDJs4wWSuMdG2EEf34oCt1PqJae65znt20Qvqy3Yfy/cmo6xNP715dTs10VrbdFiUa9vjolAiHQfqhO2Ft4F69xRf4ZjcaTX2xup99Qgul/Am0pGSA3oZNaphJdJ8yDhyiVzcXlGEH3PQ7U1npESZ3SCSVvdTP01gOEfJm6XetDLOU5mojW+4b4WmCsi76PVH93EVhFm1ho1p8nJgBSEkfjKy+m7Ovb2zZRBZhDlaJZIcJXR21lMdNIlmAht2PX/+9N2790gy+dPwLWVB6CdlggmIJx5wkikBjQVPNM+7y3u9y9u3e8Re6SG0Log2HYmAdaBypfCS2tH2JdZaDZ51gfQTMilt4216S/8luRKAEaOD9jOMAwqJ6YqESsVDkAKgTHm0GQ0VO5QBTQkmRlhiRRXwYKgHBsmTRyBRD2FRHqEWCws+6jKR8hUJGHIqQBiezIW+QKKfsMklqcoY8GLEwwBYGB/RH/VRBiBihGWdCIF5xORPAXmlPjLAUZBfjI/Re+sklQKAJDDIUcWDEYlakXJP5CA9WXDVYPQqXtYPeaHZVz894uUOoPA9juKDB4BIfBYP0ltBACiaHDVvbwCSK6YnESYTUJhEZsAbACLBqDvYMsckABIH3bCuauQgYfDm1GGwb94qO3JfWgxH7Cq/izIwiTV2qrOM7qndIN6DRQbtQfZgcHx81O12iBoK4ZQ7+hUNGPwKCAy4eACYqUREgpbJciFVvesIkZrsBUCyw5ZSknurJmNbAY+yeOCU0E8Zervu2D2uyi5TMfRsnPp7ZSh6a+NTOY4+DoXWiVTnaqvtjfOjUzsFNtbXrLDWqrOPdtyE3FlbWfz1l8+GnaOTgzeNivtQbirTt9V5OFiJKMCr0+N9ao6Z0PE5oRti4Gw0z540YxuagbY5mgtVnNBZnGj3TckF3L1DeCyZ0gsClsSdBK1LcEkAf1tXz7te+Pz44OTowKopfd3rd7UAo2AuKNub60cHe/wsna/p/hoHjWIR3iqproXMYAKeJ2O94SeEIgXEUzr4gSdypx2stQa7bid4jNhOhX8YC9ICJbS0fLJXHRmms/X5KexRU/oMJ/65HdK8hwVfqVUFmWFegIGximIyWaFM7bJAvyQuZbPErZswWHYmhMVcJiAq0kxUhbuB0uSJG059aVlwb3cv9GDMOLNEt+7zMvbI0hlSpP5JYpQ0C+6rjMiDbkAxsYUUgSSumEOudFdGLLyqfBX/IITyMtUgh5pJ4gyZYYR3NMOlswgd+zqEyicJFZCulCPJxBOyp5eVUEVw1QVDoaPEz/hUvFpk/fTpRmZXBPsjbZBACAny1I7WAY+fBD5besbQatJ6wEvuUeRsU5KvrIR3iU8eOeoz0LCzswMs5nNlDVKfyJMlw2iTRSEMzfMCmKbuzExkKhfYBEIHodsPmcHrg1iPtuqTBBiBZXkGBdSw+AkymSIbYTHoCNpLgw+1UuKVU7w3ouEHJpWAN8ikL7WAEnp8Aik+4ZUQKvHeclHlCPBGbb4hx1AkJU6Q0oL0E4D+EABKpIJQjijxiFFA8wbKTjE1KpMAwBqGrw9kCOA+VJCgBBLwqBVTpO3jhABtaIAfvALKN4lBhsdPyb2xEZ+TgVlA1Q8SMT6BgcdXP6FSQNQqV2IQA8DbU5wLCupfigk5hEiVChJ9VTJEOClHGBiWQRoZ/sxIpmzT7A9hQ2S3c4mrpZFqhe/TYNhTA7DJ3kADJWGTLE2O5Iqn6mkcGRnWWRpk9aUZ+VHSYo7AB+zIfMsMNJecNXt2Pn/GI6bQGKgUKUUPdOIMUjFfwVIaMVy+Wqx4D0Ypgq9yp7PiSEiW5eK3ZHBjFGegFCNW/LHdltvFqOf04hjY1hrT97O98/6wN97aeGTe4nSjnZ2txvJip3vUbFUb9bmttQa70LB7fLy/e3fRi+sK3Hlye1VfXHC8pyvZnYc0MXljuqLNWxo5Peu8e7/Xted5dOGwM6fboU3XZUK5stLa2lgHpvt0RgVPGbovRvzMQXr52yurFaZXi66eHw3mZ6c5L1H0x0eHTqhguzjmEn940Ot29vc+uEAtJ/hqVk+Ab2oKi7C9Wl9is8YoNWvBgLeJvpQtFcdULq7qgfQBSOXQiYfcbMyNvvjiV+YQqQEx1Go2NuaeBuYg+h6TPTA41dpijTBpcUicVVIOXDbHmfE46iO2YpfzoJBk5kfmPdpONKi+vdmk/MK8n7AtuRnCwIgSsM7gdsaJ+/WtTdr67/7hH97ufqByrEkwKWtNgEOu4srGEA8VLQtoxQtYwjWWt/pIzpXRg7CUhxAhElAWA8RrziSHcEYqC2Pc9tz5VfQdbCl14lELFSSJR9ijvPpEuQPIshvEaiZ+Sovb1muhhd9XDyJ9QjwkJ8eni9UYG+kRRYIxM5CvHCmWnC7L4tWrV2YqtDapGJGconWBwQa7hOo6SJJLGUAnKl+PT08MMjQEX2kbxcSZvb0jub97twsbDlBiktMhJjDYZRYld/Bc/GLuWHop9BvlUsaGZNy4TcK1KGpCx6Jvx99Q09GMyhADTUqCSnQY5ELhJ4zewiChKw90Mbpk4fDV3EdNqEj9h5+OJaDwOcnp9gycRAtbgTO4QyvppAcRCps34YYQu2GThZ/iZYcAqDwCWf1ZqcJaBb5k/UkLHgwhlgr+xCYABkLVCQA7wGgk+AWPAvokd9g8kviZJZUQDOSyBpDwmAO/4TP7OPptjvRz0d13Fqhjym+ipgZj1imJX0l8Op6KhApC/AHjTWIyR0jEq1f4cT4L5VNmnXgQL0YlwZmpZIFdsoaq+G4260s1XUlU5QQ67ZZ0BJv2FDMJZgEJFRlj2a8d/2GaaUT26u2bXr9PF5Ahp1RdxBHOd4a3xIJqoMuktaTJ/8IuJ96N1E23d26wpjhGxzqgdBvlCwizyKRTfymhQuEVYRB5enSc1CYTLC6H+78R38yUIfbHdhIC+fGvYMN5tRPK1x+YsEQ5mSDWsV1UvqD7wbFoG+XWgfHIXrkJG9lUApayv4c7yb0KDTsbK8fyUu3k+IBb39bm2ury0jxGjQefPd16urk6M2GL3NXduL+8ODvqnw06J0wOjJKO6LGD93DvA7Ldnfvk8dann3zSbjW5TjEiuwy93ly5taXG6WnOqnR5Di9QvYLzByamtrc360sV3ZlGynLoyFAN7ODDh5Wlxc7RYdi2rlxjecW67sQCGrkUas4WU3xTWdiFe+r6yaMdx3mqUPqf56UxuLVQtVNxCY96+sW0TSNI5RLEkE9q6zJO3zTcXmo0j07P9g+POPOYxxEnohTSZO+r2f+UZdu4dYHbPqN21BHiVYKLkaMN3sLDZmPD88TkDF7OLFSfPH+xsf34xBaqiTgl33EykvAMDYu/dVUtKIzxFVcqW/Tumms6LMvkaXy5urlzPzv3wfU1c/MGnwSD9BrLs2E6qcp8FJOJDSujUQcjH4WmGaLFJCZ54q3sYFx3GEy4ioPnOKSSAWft2YmHmUTId/whMBwwdQkaL12MLbwqScLx4dHQxmDnfITPG/0Q19vh3rwr4cuuN1StrLZsW6G6NKXScDh/2xl+6RhEuyYZ1tQLt139D556+wk/SBRioQCS0Jm7GWhbrVkTo4UAlLsxapotYlKxmHhIEv1McSJCgPIHJ8tsDJjGDsAjI92Anl2JKAMTX01PvBsd1B0hd3C6mhUjIxjg1Gf0emHP1yPq/zQZZ9OipDBLX+Go57J1k0RgnDfKpKGvV1batMlPP/1oKAcXfeaWBYj94bXTVh0uyN/WjZ0cS0I9XF0KuA4VZ8MnxNvpKNNTRkOc0Lk3sCiQeK3Uio2TPcCQjFAybmibp8iYz+oI0Kg1X28xuGmATo2hTaTm5JB99PgpMuOLEuCAb2pDkzrEv8u4BVjrh1DAH51MZYfoFOcffKSV/EyehpwV45JSYo0RDY53uufGrWfnp5SUY2/DCS3sCmNh7dCY17YgfQAxFSZtNuMMXb5amWcaNvAhx47nLnJG1Kg7bhTE7oarhvDG2qoRd6ulJvr2IugpFaqITgzEEKb+sj0UMYqJF5WpM1J/9DV9wSp961hoWp4m5Gg8cx9u3TN3swtTzp7lqzI3PxVnmk1PxGk2sYq1sNJc4X3hlJ/z/sCmQFsiDSehte/JqcsOl1e9/Yvbs8HohmvzlGtp8d8sYJJ/hFvO7RxzcATK2cxQUW/WYoeWS5f6XeV1/57BLGCij3tErVBuz/A5aUR2PFzmiZmqub0JoXCR99CJoofuUTk52nN9B3QuZ3cA9eHBeyf/a6G0vCTun3m0s609izHzsJGDT7obP3x1fyQCeOkw8mitOnR/YfowmLc/YHGeF7uuU6U4LUcHxQKq9+sfnzTn55Zmpl0PttFuPNpoT9+O7676J3tvV5cWVw1lbm8+f/p03b7ccGd0qM/teNC5GfdH/XNyS184lP/9/ukfvvupf3G3e9S5nbbjqTa4ZD6b3T046blioHeyv/dWZ6SP5D3liTu/bq6bi4vPd9Zb1blmZdbawNu3r61iuJzMrMGqMo8UmDvdodvkTeSMlvSFj3e2TAtoOvrIWNt4ik43J2Xf/+nVy/cfHDJRxUd2Med7Z8es5ZvbXbrJY7G2sr3NYG/Wstxs21FMnesVLAbY5GbIasF69/jIAHuhVid17kWgMrsHh2fHh5hGzdn0YPIVG6Mb7fHt9P1c7aR3MbPQmK3U3u0dkigMd8PBPHZ3e26JIAqj6fuz0WCpUZ24GtoCwOPH5TPuPFh//GLKuvKSpeMYAjocZNQfNurLE90RTaCfj+7cqgMr06DvKCAnY1inXVyijsKiQJA0VeVyuwSDP2Nf/LSidn/rtuN2s1SLupt305/1bcAGsjO7Nk6X8RP1qsdyYr4jnlwMT3HdxUHTNEYHu8wzY1NYpepkveOzYwdEEX45Qu7UCEtNNKWtzvaQ1OarQWRs/ufNFY6YwPAfKiMVKzE8ymDDGaqfTd1bjMumddjOG9fpah00jwaBfk2bo7bSUfdkm48A2daLla+xIEEd0d0aedzSObo8PT6zBmFQZ+TENcze7ZW1FrMLnWYvgU6k2K+shoZzGccOqNyRapDkj/dB9Mp02uSE0SursRpn8KUNLdrHqJlatHSQPY+fssc1yzk6EBLsp7btoZtyrCcGC5TBmG44im1QulysMcrGDjC8b/WkwDxUmqTmeZlRKt9khCT5E1gMrotXQ3IHsOxghkxAXh5UmUBIgnEexZAkp1QPyFUqUjN5DucTA2CYxQt4yzpkqMz+/JS7eJC8YGTnU+Yo4Cs+GDIUUoMYDMx4YZz0FQvRI19IEKD1wi+hJioAudHxixcvKMe//du/dbhjsEXK4j4rU9xj6pCjMJhMK+wBJi+qX6RHQrmIYZE38DHxo2j0ssDUCLlnDKF49TGhc/Uo1zfdqzE6zcmJeAxVi13FeqtSGP/a+UhmTGmdq2NLcCxPxe6h29b66p0zvK5u2HbNZgwv2E1RGLe4aGThfRQDE/OHovGjr/Koi+QSOrElyngX4uQhGLyWFJnsZH+vI2c/oOqdJ2ZIBY+eFZRElnBhc94nmzgdaA8z+cwxijObjKpkRBJg48iG4SY24A1wo3aMo4weWajZmifuLca6x7Fa3eKxZxA3HHHauapX6wzBraVwyXW812V3OD3Be7Vena4qlyqnI65p3PFoccnBndOV2QrNo7wTE2FV085j1LawOLzgenI15/zNRccC9o1a2dO45kdbTvPgna4xRqY///Tjum1Q7pKz6Z/HIkfY2OJ/5E5haKXle6Mgbhs2VadWDJDduEB+BuU0NB41rE9S2a/bajatMbz78B7xWhy7h8GWPQzhHbRYNZ4M7eyWXYdB7Txy88r6xiqJdvB8l7vAeLxiyeHoiNXeJMAtzCyBS/PzDGXthh0RlaP9PZxVd4aDdk/a+2BaYMi04Hi61XW3az1+9szyhpkYBg66Hd5Tm6sr+2edrWdPXr362YAsGoLFm5sYljkh+n5q1rZrnnN/+uHHyfHx06ft5Xp93B10zrpLLNDFUEOUXA3qeA/uSj+9fmXqrQU6z5UoYI4hn3r0Z33CsJ1xytdq7LxSURMu57FajB6Gb4M2vv2Gtj7N3hpnhPmbsU5lnZ2c8B0ypjEAGXPQyp06pgFOdjPIDdP/dO9ynINL+WoCJtr+1Q3YE2FH2+hiwILQHzkUQItmGwwPdVWgsZPM3d33xvjgibraNNH3VYVaGUm1E+2tDM/FA9Cf+amB+6pdKya5Aq+i4eTZpa6BmWmh31fTFwAJTG9HwIT/9uo+bORxpDb5z9wVlmjROVJBGMiZVYqfhWXPAEo9JR1aka7hgUOKBD7JRvUHB0uaovgQGuYFXavWq4WYoRsO03q6I35r9I6fxiA0VRYGcuWEH3IPtMpTWk7Eywi5HgA6UgF2eVUFkkArNqpS9yWp6FEeHb2fD/GwKQtGQKjMkMj64SvxBQAhGAC+JiqEwYaYYFt5JHl40OOBLTEjA370eIOVBBKPAIT4I6GvEMoLD8UrBQDAMCR+kZ7EoLCqCn7Ky+TRW3YEKIkEJi20yPNIjn5ZiE9UGQYjR6mY6QQSJgkGadbuYnQZuYkwBMjDWjEd5YVTKvqCBjdA4GphFq8n16BYt9juwJiXYTUaOCVw/DD3kbXsTdiwF4A1ePMK5fXAbVpOcMx5lSuXTDAtxQ680pFmkEk/zwenY2MFyUd5CJjzsEqH7SfkwJQupRFy13HArndMnOiHUHkZOGhcXQWFDj88qsMjuVRYAZXcczoCGwAyAAkRUkEe/Q1gCFdXrZi33CTTdUdx94zVnqQvmkXNOz7PcPG2e3bMR0I/5KuDkU19LAm6F974EbbldsuA1J5eE0MFYzU30FOBCogNWi9K+F7LTimUESuMRkm7qsdqOktlKxSeIEbZkU0wlJGQALbMIDJpFlNYZNR17WpGD577ysRsYqjLo9bFOE9Uv8JkZOxHvTnaetchcUw62G6eYffWede2dq0C94gB44atAKZ9VZSsEAABAABJREFUeo6sJjN1U/NaNSoOPViKftwTDrLpd8uqVzdLXDlXVg3RGRWX6ss0/eOtbXukVYRaNpY14Yift/d6pkh+c90bDZROcbCCiMIsC588yCPPn3zyia/i5YUJ8k0Yb9UKGIU+qU0/R+NYZhNp4O9NQD8CXMTsPGscZvQYTcuOPMADA7R4juHgM8ZPnDRKweFsUCiUhRZE4igTfEsaWOPZsFPqErhgjnm8HCGUSkCm3nA+CLYY8ERRvj4hw0+RGQ9MFr6K9MgLkShhMczal0oAMb7a0yaXTEuu9BAyAu8NA9qSeAGpgHEydcODhFFMGYPDbm9hOfGOlZNheuTnjJZCd4GOjuGhAOQvmSWV7G3mhg7AP42XpeqRBKQHO2ADLIwU+KH1TrIQIB4wxSHMuG/4CZjJ/gESPBhf4QGpMLwsxBDEJD5bhU9qWuGxQwxgkADEo0Fh/ZTKJzSLhx+pak529B2Y/CQjMZlQKoHMWlqPT4lW2CcPPACSWkg8ALyR7Q0Af0pGY81VGKShgfKKBIkP2X/osSFPtOLhzDcMApF1jIsjd2j9zDpSOtRbUYYZpKG00pUV6Ohvbu4vKUqfLOR6O6zNN91DzH7JVfhQM4GHP8PRwaGBlejCxsGT7Z0Y/sS4KDpLCi4U8+29JY4QI0axsgSnGd7fhTleoXAPzcKSoPOB7PjJ/kXcDcrZrWLe43Y6whb9pQZJauksp+zgCZpnr103Zj/tBXZhkRiQXA6oNjUOWIzs5iqh8ZPJsiuNakGmoXfCfSAGMXiLqoTBMXUtUo9TqegPYzhizK5Dsr9mfXWFt7sTiZ0xdDHsTBgmTtseMJwyi7gZryw3DNZYKgCzRDHoG64qrDuQ2a8Ro3NdWNR0p8eDOPSftQclxnNxykjcPflRgVKI9CwOqAI8Z1HAllBPxQmHLR7lcWZcs0lFxohqZlap9TGW5ZWdOrQaoYNxTL2fWp2pGwOrVVjX1+iTPM5Biup2WtNlHDNlUuAWF5u5Hj3axhjcoFRVqzOAkD1fn7t2+eFUnKZuYIsPVjhYUdwXwQyIq5iGe8HbMl/pXo7dFW9BxSTCJ+W4u7+2W9AC2Pu9vdWN6h//8Menj7crM3OdsN9PGHFAsrW++f7dG0vrhgeV+ufX4zkXrsGJgSFa6pgyo/XisopYs1G/WDTH0WB+scuyMbK8fO+SSJHRIqZjfszwaNudklKO4bY0O80vUJ9CtMz8eCmo3E7/gjEneruh80gnDfIxjUXOLM4WQPacVFPqKZYaotcPKVVe+L3FI9LwJ5mgIGYYMNBGbIzB/7JoJwBS2LDq+fMXP/9sAvTRPEVN+UQ1K6DkmB95FWUo8CCWZNIjHkOk9QYpa5GKDEzf4yuqsu1fXkcvqLCQlCd6aKk84EF6pJIplQJA2OOreP6XkMfoVamyYLKMCuALF08OoGIKo6tBtGUtYY3JN7lSlKFximTIVbERB5tmLBKvgYmHMAPeSgIg6ixchj6qRVn7JF4q9S0sl0TuneVPPBptAmd2ioEMki1eEhg8MGCNjBAgjCpvPxUNfgklybeAR3aeLIXkwYiyvp/wADQUyeWVmJEETBZmQgkpnAkTlU02Zi3gSYP6VVjIlRdCbwjBI4AoeIMxpBVJ7+vtVJK8vBXKhR/wKz7kICX3ZHLvELzSW8PvAclURUEwAWGsDkIu4Bku6AWWFmNnTZFnwtDhIQ6XZ/aJpTO7maIqrbCykJAyhFIUMjUCI37GxKRI6za9VYrCh/DdmrihhRjw72NWHlN7QqLJ3M7GVIGrfmx3iIGw2WQs5OB5cJijJFLZXDz4g36dhULI3CFF7opCnh6NdNBZMATT7CO1yDg756BOY0hsYR/XXTWabcu8cM7PLFxP3xwdxnr+inPNiOHFSHzM44tQRaUI/nKeFesFfpIKbzc97h0cxslsRYypWt3B6OLS5lum1S8+fXp83uXTYlmL/1RjIQ57vl6quLo2TsvQqBS1Wsn7itkhdOQk34AiR6yWiAzRuPbHmGF20tKLRTm7IvgaKr51S+xS0baYqia9HbON1QMbsAkzkmnSuOzg4qLRbCmOY0TpdOt+VtdQK61HQL2bE5g23Q/jfBFLoCpGr+XEmKXp8BTEcEVwlc34YlrAyHdttX3s1lm6eHtbTRG8uCst7sjtW1HxkA1fZa2G0ca8EsMN3dh9GFfnZ+v4b4ENw4HZOOykLIRhxvHJmTMEHz/evtRZTE5XnbzWH61zkJ+asRuPT8j8+PKn7354uvP45PAd4n98/bLl1ueJCV0+VuDe5P4+VigU3YPHqUm0uDOuOCx1t7HDttPr6GhjO21sA4mBkDLiBgLqNbBVhonpqXF0gbU6Y8rNXbhvmLw6JdM9ypATSGUMZTUZ5lnhVCxEztrmov3DV8YZTkW8NhUOPsfMfoK9lJBbodFeXNUpUxzQQ2ERDMAILNkXhkcuKeHefobYF8b6iUJvP9WyN0hJoqkWY1FRjLKLMzkAqIUFK49V+n0aZyS0TvD21esQ4DgQ/uP4VXJJckSFmZAoHQx4IgvFEaPuUI5OaP1ElZ9OAIx2KG9wvhklyyM2WudYLwgtDbscSSGBnBgBQJb8YlDggcGn3d0PwpiilSqwB1oU+ITjkmSx/cyi+lcufiZNGSlMVRvZRXteWVFOtNKn4kXKSBJ4IEz8wkgSn0joUyzzBJ7iZpqVLQwGecRdBfiaZEuO+7JGBoS/8DFEShJgAgA8cCbLMi+fNA0J4UGSyCyjnwj2E0IBkpnthHxrY2JIsIqBFiWSqxV7RagenxQ2CZCXgEwTOVSexCxfj59ZOqmSeDH8dPf237NMqgGDdVlIAolVMnnZMLLe4ngSBh/AKOSRJmCQyJZqiE1ns/kEQ6zkh938Tj0iVXZ7hwePNraYVTS28LuIKb9byKO3UC5GCxwAJt4bBk/J4n8x+xGDGG8nGSggPqBBJ+qtZgKna22K8xiOkXUcEOkb9akg2KsU8Hvqi9bWolOUkUoRJhuQi1Hq4u0T6xDiPfAYTvopRz9NdRK/otUbMSBYqEbb4z4RNhmG7OjvrY3dbqw0fb0Ynhr+WlOvL0yHTl+oLlUXLsJ5/DLMAzSI45VvwsbliDd0qlD4Oe0Z+3PMaK6snh7uX9DkZhDcXabDrVkRvLHCVgz2az/pa5w0HkPnaqvlrHnXkLPVcDTVnplNjNwRxn5uWuw8mcFw5Axpoheb+CoVUwSipnLdkGPY7lwEY1tmFkV214rbbh3pg7dO8AwhtJx4xu+gJZXB+7MnT62sdulu60YTMW5j4ic/qiBaYWxtxZ4YBXowEM6rYnHGWGyno29NgOYX2PtqS7wJLnf3D2MIfzu1ubE9GthfOKCp44yzmzvnFD1urjIxtZfbegu+uPdzVlVjVmGWL2tZqFM8NEklfrJDZJEBc83a5fCi3xsgAIzcPfS/+WGqQtofJObTneolbn+ozA3PelYB1OzZ+ZAWtKHCzUhxv8D9JG8MBk/s1YPGYq+y9K27Rh9zFQtI1FqoL/LucAvb2si+5q7WJCY8VBGJJpOt1ZafiKFYCCGy0aA27dlOOnEPlxj6yKp691MWIfSlk0hB9ZMISe5rEFdsCfmJKic54kXWa3Us8hOvdIfCKMQlGQFwn4+fRFTdJQaUyAsASAcc+urx09fMPZjph89QeFOMiMiMQQD19tMHpGOr9MaDNBswrZezlowV3gjRgNHAkbOHT7gZk8KgL1qFlgxVSfIx4JN8xUjuq0cAcmSYC+OFMYV30FvsuYDxOkkHg5XyEymsSSiGB06iA6ccfcV0bywAoz7KPFoEn7ew+GeOMCgXbNKqWsl9EkZMVhUwowpgRS8EebghC5SAFwAmuyQJHshVj08AJCGoPoEBKSE83nACKzIU/YQHJAAxmoFSo0HxaUuYfSVYmCAhnGI8MDDLenyV0OMTMK3aANBPahw8tO5I4egad0nPL2yub/gkyf7egU+Sy6jUlMNW5oYTQ/YQghHSbPpdNkAYO5MdnBy5zZzU8nuzolqMacn8kjUZIIy8euI+KeRZciC16gvbEaZEZmXgk+cxOkSG66+IiBNyjDYkLuJhisksobB2ZBBxwxLt08hGJdqAJjkw9HtUeqOmu6/LAuY09KGcYWap0ohLl8JAE1aCqOu7mEgF3aWK/UsfObJS2uh6JyZNC2QKv9kKJTs54eh8viHXDEvu8nUK3Lh3EptlumeU01JzLQSIa4qDs+0e5UhtuTx8UWLLiI6E9SKKz/xz4dZiE8Glfjiq319cXjFRKwJLhCIQyI3NTRsmrN5rUGT/0nkw0XVOG3vO8e8sewtevnytjzEY6p6dO3HBSoO9F9qasnBHseSiFL4eHhzQ+K481medlatFeqPYAbAY28PjMltiSSeSfpZ3l0PxB3XuKY45L/rR1iMrKBovjsnfn6taDHhNX5mASneL/lhIt/BBaOQMs3wxjTfLYBgSqybNqAYuA2MbY1ZabFhGmJ6YHnQHzXYLh04OT8inmuz3OlpKmK2nJm0yiKOHppacNQ4nnwFNw1eEje6nnn3+hasu0X92fGQsZlTCJ9VKPB6qdI+G6o1j0Ri0WUumZZxrIWVpoeosv25nyOvBzuGQtetYWXFXPB2rYaosjzrPgLJw0eGuDiMB5czC78tXfrkwy48QGklryyKpEFJU2nJZdHT8LM1gsms1mcPVKJQAI2HoE2ZqDVwDQGVZzWILwmfZpX6D3E+PSifPiiYMOQApcMM7WY0/eh27zRVZvBatdSxUwlCmCEW6P2qDhcWKAd3kDBVNdbM9xNo4h1uecSpSFkpnFmu+Y7ocKtijAMHRolJliXSPSNCwC6jj/Cm/hMcRdEgCwBvdqirLgNEZ+cBfaaEFg2s+eZQQ0QKAU7tBqP80S6VxlDYzxSZgcqdQEpu8BBIh8kCa6lKdqMJ3afELTq1CjnhElkrtGhIEswBQB0UrfSQSmKzRkGQLg8+aziTgE4mfckSP3AFI4pEvDB7x0oIRiRLMURxkm8FgC+RgxCOYwvIJgCR+JgaloBQwBPIsoLx88ghk1UCeX9GDKsAwAFCcP/3pT0jCKGmTQgGZ+qrIhdLrDEgLjKkKKl/h5IbkUlMEaNu6BEYag4hXb14HHtPt0vvCwDxqExBioA0ml30xyRAFV0Zo0eDJSMmzluWSxITraplHKjvgfMCIhDNLnSQpL0pKZLQWlOe0AAPVKQYCE5OtRaMK80hZyVc6kZLLPd+KCT+CsUuqbE6KnLn7hBjSkpXLGMW2FSeI9XtGRw6ycGOKw+hmHKU87PRPj65HPbuFefYvLlgciJsKpswYL8dunudcpE2oWYu6vxDvJDdN7uPWdDOFQTFjGiOz22AUF6BsONlf7jx+9PrdW0Si7e2bXerSlF+RlReFT548ij6+cMZIS/EPHVBhHaJsbQFDDGgGQ1rJ7bHSKHADVzNV/lRMaxgyNUQ1hGMqOdw/wGe71fzBQDZ9NfzXTdLO+IOBWOSNYNxTWvizUUCOHuvFmxtbx+Ypp2f803iaGh8DOD/t2F9kv5y0lqkthzuaIkz34cd8b/WCdQI9akqRSdqiI0iLZwfuGWYSyKwUWcgxqw9tMCNYQAzMoYfKNQkZQwWY0W5srj15/MgnflPiiZASaaN6Ag3VZFcSUgo/9kJSWBeDZWXMLFCldFbs6XQZ4QOqYIjIjy4t17WGm2L7kAPQQGATSAHDc4VK7kmoe5aRtN4iPdGgCvdgk0pplFG8yCyItyfnQPgvnpAr+PJyg9e4GLMTnBFfmkmkgkrrSMpxEjYx0Hp8RY+MwHsUWaSfUR5wWX4pwYn1jeh4/BQpoJBwJRatXUBCZfAVPApEioEHmJz8lESMRwy2ggGczJIETD5i1CiCUvUn5swrs4NB16I8qJKjT6lr5IUwYZFYAyy1AEHHF1/hl0S+AlD5ConRmdwFPCpDPAzSUsSApaJrMiG2wEPZ60a9df0CJju6OwFz7ZjCz82av/vz0yjGZU8wwKOktnGqPGhVVRZQImyRu6/JEPmKRL94wHIkQ3SB8grgCWD0I0NJJYHKJ2+fvJU0McgxOaZQVAaEAOSSXw3nX79++8c/fvtXf/233333g76DRCq1wemHD3va4f7+gV288LsepMWBOdZgWajIpX5dTU1Y7js5cx8ACTbA0xg0p3ANlIvj8o3giZOBvu6hThEu1s36GVzjmlxH4qBJ5JLDL1mutP1JJw4d2nV76HWssHbS9jhLWp7jpV4eZnljaneOmEzIIisXQwz8hTXI8AI0GjJ2dveLk/dL/ZpFAk6hxUmPGYwBb3IDDzFZfVmKAI+xAGAzVLd4zcXJsKjZWrakaFjE7s8a7/5BJjN7d5f5ti1VnRHkmtv93Tf7u2/H/XOfqvMzraVFzuH6gM7JseMVTcz5TXY7Z8bLjveRhfrFNLqvvbq2ub1jOnJ23jXGNLhGPELoAWYu5gHkkROTeLQlzS4gaq+sQqJy0e+edwe5QZjNQSn0NKrYrTCGb+12y08csDlLqR03zTOnudK2AKBlMUGYKCovg97ehwONTvXRxaen51rE65cvyS2BcVyd7MSknjK6EwBs/G8M7dYzK64CnKD0FrocpGov3uZNTgEyRWQKUwXffvut40idg21ga/xi17SCi0cAWENp6oiFgVM8GRYjF7krJBgCL0ZZFP/o8JChRtmzivGBGPiJyNQngc2o/PZqi9yvrbi9R4vjDqQP2Fpfc0ezCUfsN3Izj9sIigqWHABGmRhBYqFQS5CvLDBTd2cpaG1jk1jG6Afn4+Qk1wfMK4vscgJMqGHgwLW+vqJGpEVYUOIA23TXKUr21avXJFzzzPGoFgQY30q+H1cETUMRYLaQxYQnkyijeDghVDvipcVtWSjv8ckRADFISoaA0fdgo0jdtFoj2HSULoFoqVMA5D5sIMXjTkL4lcJwJMzZZC57ofsyGZAfCJ0TFngg9cjJG00+CWRCxUMKDB6QKgAqpKCTpLIzygI2n0oWMV0Co8oxUR2kFkAcRqAsjInFo1EWfiIdWthkrWzS4p0YucOGADWXBMAJxuOrtB7AMPjpnfAiZQTG6Em8hN7JbgEkSYIpssB08XgHrVzQD0C8tMjwJsLeEOYnqBTQ20FdGU8gtXwSD4Nqg0QBIRFm6MAxVMlOBQpLAgAGjzAwTM4KRhW0MvWTghCPQuoDT6z6+plZW6rCCnt9af6kE3LTtmT1WjtGuLGwVk6kMCs3MrIlkl74/PPPobK0o1OmKajI1uqqdVeHlB0en9q+YW+oFoAqbcOisZNzkxiK2D0B/C4wSkWhJOcHWK0UUQGl90KM5UTJWSeiI4yDmkMwxOujIuaf+PKa2AJTR9JiSIi+o5lvY6RT8AW3BchMLglm2TFZjuoUeVOzMTcv424nDM9BQqpTVqHFXPWCfrWAycaYJ2UzDvyowgfEMLIrEcUEYcfNha7gmGYJqaike2Zsd8EzdFTNAFozN5Nv3r/rDsbPPv1ifHv35tXLbm/IFdJRGUrhAGR+9HGmSr0uO2VBJEWgRlQcJyYcwwdvlCDAWQJqEBkrq04WGrGumDGofeVFSVzSeXnpAk4Jub7/+e9+///6f/8PcPLDceQn/EtxT2Ec+k+uqBga25AiME/dS6VoWGFywGyF51BZI7U4wWtAEmRkaxLwU9tCNbsNXyCQPtH7OJOCCrMDDJEqbcXlwrw8ZmbRqU/RnM2jQ2UvFOM+d6n+rQsKHDFidx42mnxY3iXgjrvod+etJwee+7hd3dRJ7cR0w8S0KJm9886Lzz87KEftNlvzF5NsiZgVS1D8frGFr4C5V9T2VRgJrFeSZz/teCY2xm5cE//0/etw/+kOj8+6tcaaG6SHVwZYsU6ppSivWsUlclVUzU2v26vxByv3YRRVMCY8HqM8DHRELIYUrWJLXX/yTIdnLle4UQZ2UHnQ5q2iBaTCfFUv1fr6KpUigFEqmhwC0+jEAEYSYAwhe2RVjLwgJxvCgAUA0P7C2m8U3O7+smkAqSBhg8pXP31lDSF8dpConaimYuDBXsWBWSCBwQdqCUpJY2iPCDGI9vYohkhfhY3+vBhC8i2Rbo+QUP7ZGyWAn9SfzglZ8KBSctSjIymASjNTeGUjWNkMZERGs1UQel/xzifxAhlGOnhIgCmnMnvEyCjVgZ9yBEzQke2RRO7ilTGLKfdkOjy+okSRMV0kIrVPyROt5PiToi8GJZB7y0uOknujUHJVi9GQQAhAEm9hOcIQNRdG5qg8YUi8DbiTqyD99CAMgJ+eDIMUkFEi9FUSOEWCwT0BaPMdpS1DD6SC9CgLfvC6e7+795JF+fVrwifeQP9XX36Ngx/29q7iGBZ7oKptfiM3t6fGkK7lHo3sCRJizDbEcgCOsT8KDYtibvALwWrBmTOY4GEi4lyEYPQwBfgTRmrxA4yDPY2heFDYy4rhOKODInO2I+lp+B9gneG8xdUy94iFN/yMgtidLFcmCi47rLd3E53zLncfJm4O/DWe2EtLzZUVgwWqISikQczPDOCLArUW4Q8qdeSdNUtFugJBFRp2Gi1iGvYyiehXFA2kBUbeUXREsNmaZtnNHhcbTN+vNOvWAN6/fcVPdGutvbbStrmMsNarc19+8SnDkWOQtxwz4aY+N0lpybXaM/7szjVyT+/KiiI/efasWlsy0rTd16odzehxXrdTD4ga+qkAtUy8cRKpKpdkpsBT+vq/v/u7vxOwWZp/jqM+jMl7nXPErrSajBvOOdAlK4gmQOniLTYa6DH0PXn0yAHTBMBX3IjCmmYZw9mxdW8D+TyCA1jJy3HHdB5Hr1j+icWam9ieen1FxXOziqsFSltDmwAiwcQFAKFSb16/ez0zP8OEEpZDJ6/YzeCIoWrFZkJldPIgh2I7E5ymoTjopD6sF0FFRZAN1fHVV19hC/mx3nN+embdg4yhnBCoZZT7JF+QIt1vrLbXV9t2CyZViFxbXbFd3LTTnX3hDlHmUupa/WKsXPBQWgG0h6CWSTZXH46zFnHMXigxeSEjFYjiGOVYJMMrtmA0yMtXOAGAhAfCDCiUjCAXo1xgyJ4kFAXlFm2kmEMBa5LiNRbMx3kIlRQ9mRAGucCGv5RcNn/JAZs5m1JL6FGb+YCUEBL9NOFx+IeZNALAwOmtPIQMxZpEmJthhxTpOf1Eip/iBQpvQ/1JBqmAT0iEKBW32hLjUwJAhVwJ5ZdEk1rAIhEkUlqkI9GSi7e6/+yzz8AjFBIFMCLGJozL8kMOs7SJBwy0whD6BCwLljQk5Q91gFphnyTB5fwpI9oHHsAGO+gXI0dUycVIRHZSyV0SLRCRwpBILq9EiDlWDpVFZJKX1emnhcPMS/UoI/wqO9szPLCBSaZBhYbks0+QowoAtHACEykA2CfY0CAJIoM5tzeYANJPpRAvrSR+qj1H20orUqOyZRES5Fli1f/Ab9grGcfQvn2t9Y8rzJqUHuPYXX31GoNPp+fo3AtJosnFsZcXnEbVeMWCUqEtiZejOUnWeBTkF2O3GNEyRaowX2mPdSflRTZue4K8gsrIUUEMBvXCSsF5w08dMeS892xbN+RULj9l4W3iCIwi99PIF5LEcz/rFAiDZStjJI3tJnQE+Eo1pi8gg41XcdyphGoEEu1HoaauPko1FZPlAols5n35ah9aO6O2iQruNpYWe90zJ+OMHZ4xX5210Z8v0LDvSFV6trEYgz6r7pSTvWNuq+cvxNpuyQFmzNflR7stNxTirUhZIFURirFkIi5qNjevVvePjt1DadY4Hg11Ufy4NtbbjJ5s9BwTDDSIoAn+WRlCOXfTL82HMBv3qX3MN6jVanXiISrhgBR9s/lNs7Gsn1M1wU++N87bub6qTXP4+TgHchgeCg1X9KWxmzZm3rEhIzvI0XVUk9F3bMF13+GFNlgxKdE5Gi7M3HMGnr+YwZ+rw7MjdtHROORcT8G2wtfYhgtnKNjCEEnM14xF1lZtlz54/37jiy/VF0Pf+toaLuHbV7/+Bn+E5yv1qdvYKB41Uhq+CmLec7qMfahECcG2aKMRS/kuaJb2BpujaMJHJ12p6HqkGijy0zFUvXaYrEu/877CCff9pL2aKgxlpWpu7AcoztZEd3jtguhK2XyL4DBxa0mGH3rHlHkF1DylwvaUOjBZubIWVi4ABFuFwq+CVDox0wrJM9r6b14TRclB+gqYtIARTuSwedQRJN40FWDtkq0dgAcnVXQIzHisjwEgOZEoBQ+zBABvxCApVQoZCHNPEo16ugZxk0YD0fEGK6WBWoDoeAvLQ2JKp8CE62Qml1lQUbpEb8UA71EMSGD2Bhn4f9FiUAmLQaU+UBJzVQMlkZkEckXFAo9MRfqENSDRoySe5BGw/Co+H2mRAd5Pyb0Bi8EaAfGIEY+bHjgRk/Ho4VIpxtdkt4CECHjICzYxMKgzMEonRhgqJqBkhXiRmQo2wMICpV4/8s3wHIziiPf2oEFB/PT2JM1+woYMP4URD1WyIolEwEMS1W8IBi1izLtDI3S6m3ZWs6zbrDQ59Yc/fquw3X4Y0+0aXdvcUJZw/itkLN0brVRWVxeOTo9sZzXDNdQZDrrPtx8b+zCgx2lhNetpNuF8NMehBKv86VeUHZG0bYzBVTetFt1QFN+ZRTLi7GjOTB2QN84IujBDH3M5BTG8igN+yxnu4A125GLgFtcXlZP45KF08PvKjT3wl60eRBxaCGmkmbEDAjxhaPIVWtNkFEJB06kjRhi60uorzT7PieL6nkI013R6MIbLMSWWQebutp/mIzufLNo66sZQlvplQdYNzDnBZtCduXPt2mpjpnLeG7roavfNS+Ou8CG6CuVipUXzxhNSh57nLz7BgYWr2HJof4bszjrdEIBiyDUujBWSyckmA85k9HNWDlWijkV3FWd4dLtffv45vUzb+Mo1qqC9MjA3ETLFd1e7C6ulYvowSVIWg+XTwzMn23DSqsxUWPwpRIza3n4kLVWJNmTQ706YMCw865zLS3/jfC4th1MZsoOdc+Guqg+n/ijIcmNxjFWZ7BjYAfOchQoGl2/xUXL7W3ttdW/v/e9/+81wcH54eGDARhiu3GY8NXl0djaeubk4vTh40vr9l3/WPdnTLxqX2BGXCgtm937hDFK9MS1qsOgiQ217T8r2FbthAHJtYaG6UvOkWnL9HL0/CAfNVRpf5PFprMzBw/HFqVDotDB3MU1LfhxUcUig3VImrSg5qcJWNd5Jw36HO0AcWpauGeWQOzmmEFadA9F3PkcMp/CR2UE1+jNawnjuIGQvOtebMuiemTeN1A2TSQJMO4ER6HQGunzqNOpqdpZ9Ur2QUpWoUQMwfapWnNtY7NVO0xuNbACknEx3qDS24ajBj/UYakQeGhpVTQEHF8sV0AKD8WDaESZTMREJ45W6t3hlrU7lRtWWRzl9LpsBjPGjA8C1iCmP8oCyazypF68wWStZQ/CAR1B+8hP3MStqqYxqtVif8qc3hJquOlNU8dBKQrLVOrQYAR4Y5Nkm0eNBg5/eMkrFJzIpxMQUF2/5wglVKdnHF/yw4bIAAIwGiQB0ZhHUhHgAqlYaYDBAmzSLyayR6hgS9MtXDCQZ9jb08hPlkCNAWN9GvwijUy6wCQMACy1MiUQYgE9igEmoanwytJGvnxJmEqU2yBGfkUk5so16hbElGmSZuxkPQctB2DDQpSh1O/VHY2trVD9XPwfFOEds4u9jUZ1gqdkvv/pm7+BnGym1XuM12p/rT2nhbJ0mjpzSYvYNp6yD8riOMbYjMc4i1SdFQCRiLPwKT0znz7LCVM58T7YTBIwF4M1fNEYiwQqn7HyctIkxb9Sqm/Uar3B1lFUZHChrA9gORjE9CHA4WnExiklkcVMJGwJ68NAeZ6n6gz4wCpnI6SGQgUy14OBUxZe7Tgs9UmEsdi03mpYBFUq/yQ2QI7vkAGzQM7OuLS7v7h3svn+79ehpa2V6DJWxeW1xwN/diKf0GI54G/V7WqS8cpZJDOQuO3Klb4JNKZQL5hStuIZ3dLG6VTVvw17mt+9+/OF333yja6SXz89u37/b/fnnH3/92984jZU64ndj9xetGZcVGLTxVDISLOdhWLrkhrC6vtZYWoaf4Ou3nQlhNEDbWpc3VCRsOhVFJqsUSqVRYYMqS6E3rP/IQxXWoRBk8Hky5Bk2ZCOP/Z2pnQGQmQUAC5Hu+j7mJRM1Z526j3Py1l3nyvvh7Rs1rnT2o1tVGnU0scaaC2pu4vCJwIxs06Cy3uanfI0JXDgs4BMC5Lg4F24aMhWTEqhDke+s5YYyjiTpqDUI4eNT9rXRC/e0o7Fwp39IKhwvDWA4OF2sL/HQhMQYmgg4hTOyUby727ZLAAexYBN3RJ7fOOFSDylfclVENL0tYjzqsaOCLr67jMEWSqDIsmQRgifl8dPjp+LorSAX9kjFgErjMYQoAoTkjS6iV+VIeqUy/IHWLknAANAvoLm9f39g7J8aLLsoQsV0wohKBzn1W7lkIQl5zqqEDSqc9BNL5RU0RLmLAg2KymPEgQLxiEcwRJm3BCJNb51jr2WRYG+qyc1z0gE2kqDBCj5tj16g76JUUsEjuVIhIphwfW0dBmXokFCZlRYY1abtZUCMfL0hl0oAnQgDrwxJG+SwlayDNiwQ9oiUBOUiJZS1t8h8CqdC6WQSYOoAMchL7qhsDYPgwi9TZCTZKJFEWIwxjk9QecMgC8i9/fQAgE2NJ4BiggHgp+QAsgjy1SOJEZ+Uy0KmwgKJLZkmObCkBw0QAdCShT2JU0AkX2pjDjGYjCOapVO9eEfYCayf5K3hk2HC6toa4+Cvvo5JN57bF3ZyfPzv/t2/a7fX+WfoAGpLjvkMETSgsNZ3cOzi77jHiNmBRlMExlqbK4smjaGA3LNcxj3mEBmjyCinmsMQXMhzoplyKb4ulqlTv6I9iKEcC4bo9sLoEJbZ8f303d/89V/b4kTQFzc3G82mqoHTwCSzs8xLrSi1NSnx0MZg2Ug1cosHJ/EWMQRAIB/DPTViwcFJatXKkq+yoxAllyTuhL234Bg9NAs1qVYAfQVURNIGU7vtnAzHm36Ze08cy9WdXWB+cE7ydHVuwomqFku652cOLqi4Uns8smKpR7A1TKZ6AiU1wnCZMM6kaBXzKu+DhrrGcmUcDmJwarJijogqjjs0cqjp/oBlXH0x2WPUxtq6K2Wo4TnXetlTwG18Zs781ZK+BxpmAjXInM24JTkvlHD/nsDtc30DzNS1cpn4xOiBJ0/Ze0+6QkgM6mdmKRQtxZF/1ChZMvw3P0AbUgejMPE5jzr5HNiskY/GC/Wqxdgf372x7PuHP/3x18+eKK/bjLFycBmWpVhpMZSs1J0cCRURssqDDDMAIoRF5zrgmXl7FP7X/5t/pV6G3327ur59qXcN/T7vBDI5goREs+G4axHAbXfNBkGJQ5a0CzaUbDJKVBnfYisdjz+OcEM5zpiIEDzlCeEpAzgoJfGTFqJvHGdkhyQh1NT8Y/oqua/BmdgeE49Ziw775i6MHJCgB3JIvMV7B9N+WY8Ej5jJ+TB30/ghWLxjl5cRozjSSphjBfUrL2HwrtIQyK/sXfo2CZFgOapgmCLGZvxgSJdjjzU04hzrZwPnMYfCKUyLMaUwPClymoOyiJnJ7MX6hqeKx4IsrImVCUC0NDkhyJZ98Re3F3LCI2UQMG6SNuSgrO4qLWaJoT1hFs/9NmsLkiwnGI8BPiLEkBu6ALwAgsi1hAAgQQ/qRUIuRgCPUCK+sDjWCUQi+QFSwAMYQsACmanSCniglTViAGSMUggoWpR9elqr8xPrAUgui/yqXH7KV1pZgESVTxAi2BtAxJs3B5eZ5ntghDFKe4BQeTFEYfXEmRZVuk0wAt4we0cBSg8hLDtiCjmtoaTKLjlgtgvYiBdZQWFs0TfE4KoQSwjUq+1UauveyQH2Paqj5jJztMNhGpAcHp387s9+/y//1X/ZWltllFB8qf7Nv/k3f/j2/0lqhzb8OW3cdkpeeq3Gzs6242JMaxZaTYWVPOg0NZAhh79+3z2xuhrx/kc/ViiKCuF5QJKsxBqpxyhPZU64xeUa8wm93UwIs7M21IG1gas7cerLpUvuSqTAFdOQzY2+RkwGmg5B3ttz3HGdGUpyPoKmKcjWbaMKV61eskKxjIdZtmxXTu7hGP2mLOoF7U4uMiv302BE/aoFZ/4cHOzhYbvNYhCrwSLbqyuap+kRk5d5AJ9URQu+GOBEn8q3vcsbFg84RZ0dH9QaLe6w1srvby56yntnfZUP/QXDsbmeDV8W0zkpOo9v913fyoHjCqhRWxvkFb0VFUbjNJoEYXAxMKhZrNeacwsH+0f0vr4ZkzY21uwss8DUGQwRtFStq3qLus4mDwNNNCWbte6PDvefPfvEJzEkB0txUmdGkE5Oz5zaZELApOAivPpSw0ImXWkuSqKtFVMijhFVBRQNi78Kq5UFVaUm2yTKIYEuTOBalt47BgSL7HSz0z1nPlxcTc7GYUqOo7D9kQXD4MYguxpOR7Tq3Tff/AbfQ023lh0venB43Jy6XVpwNsb1zvaj3tl5v3daa69imnUOHkoydZUC/YsShia0MViwq3DOzYfcKqMKUKWO0GCdCzEoKxY+XcUAb2RRp9VeOjjBjRjpaiCa0vNPPnWDvO5d2S2hE2aPjW+4yvLGF5nrFtOck1AYSFDOQFR1nLJTcmNLaUwOCIM2dX0z/+mnn7589QY9xMxbKwBD8AgYMDSzKAiL8dNXMXxykE3SEJlJSAVR5L+QsqfgaTgBIO3HJasV1RRPLMxPTut4yjrpoGqeTjNPhgoiR1yBzWm0TafD2sFHutR+0oYbVFCaOuCRNapQEros9Y53qeY4Y5WZp2yVMAFx63HsRpOeOZcxVkunYuxIjNlJXCzOUGUuE8YmJRUI1RNF1q/KwN2txsNhxLWS5m38aF1IwPn1dlFbHoxDtqfuWZxPO6fWhFCp5N7oxjIsUAzF4xCnL+PAQAkZIcrBZiqKk35Qr/6YK41i/NE1ccH0ZBzYZL4pXokUhC+HMOsH9w8DT0Zq5c8JF9ZnfyBfYWgRQe8gADGavx6Vb4BaJEa4Eew287u4HtIQXTdPzbG2O3TWMKGM47iFUSW6dLe18azZoHCEtQRqxeg46uyXuZ5RE4KNi887p2xzTBQZQ6e7iUEjPD09Cd05wzTR9zatWqwvGikalRn68VTc3t5CJLJ1XWjjr+aYW+oZa502tlhdGo4usZudkCcP3fz8iy/+m//df/fN737/2Zdf3eqw5qoLK5tvHHxzM7Xy5JP/39//wfxhiPz76d33B3/9V3/304+veue9zumZ4/iRinJMCJ/9/hDamHJqgveTRqCqwWDSEqIVYG0V262Ocht3M0Ln/ITs08R0zem5Zebz1Y3VhUW1wEZyPxz3WDNYluMcCgaX27uBCzdcoj6+/OLFi6++/Pxf/ov/wiHDKt0xjFGTFnt7HavKxOP47JRHzfjiyv6jza0d9WL4X9woqs5ioAL0gtwxkcNCYli7bGI3M6tL06nom3Ge4WKpbqmZFwcm98gkjRB6s5zjrbKKf5mmYupp1uggu2kY9IvulbQAbM2id/rheuyGgNHCDCdqp9EOYvnl7urVy59nJq2d8ph0F9hku9Eg1kxDN5cj22pr83ETgKt6bD3Qu/C82nU72/zCu719ouLagKePHqMWH3VIpJxFvLayNu0oJ4bNIr1ujnzy/Mne8f6Hgw+sbVSzgeHxwT6jH+0cCwZX11zat3YeL/HJ33668/ST5so6G/fzF5+GuWBsoXvaBWMO6WY0p9b1HFpEdEsOD7+5efvunYbPamRe5ZNJjJkHjaFxGXwQAx0J1zKt3c1qbvty78eHk7P3R8f0460Dj4bjyuwCX6GL8S0RtgVdYotk2rK97A53O7DT49rhlM17a8eLcbq+b7X5xWFnpI9f31qfdQ6rtdzbO9sOOBvezzCuXurvVP3QzT9xjUnc0uz2Y75qU3PO8V84IQ9lNTUIHrgYjpQi+MZtZlSWO0JCz1uVdFvZ3ML0TPz1+mM2Pc7evCh0hfoS07g4yVXbqNRth4OQSJyfdekZDNH82XV53x4eHFP7NmfwraI0DMKsMJBSLdw+ZGMOZtW6Re+ZWB2x507nyiPW/hVakRM2D+Pyc+CmzGxWRI4STj1MRxNvJ6I7mlcMbkf7mpzW3LjoIc8f+2RsuTEzqOmWnKW0D9JQBQFGHiNWYoqYvr+4WF9dFQk/naYIpJrGE47ZNtRy8giE+vvFqCKQGRvd0CygfQUPi5GXQHZ3PmGQPg3FAPyEB488wspJnmgo2FACQEa4CXNISZmr+yqtSDjFC0soLOANW77RTfgSDAEeqJQEMEo8AmBkIUlmAQMYit4jkEXLLIRzUCd3wEmYyAj4pxgfhdGsw9AP29DbqC9FicrNy/JFDMe0lDYDWzEGp6hCiSInnTJFgwdJ0sor6TGiByaJxRl4hHP4qY+RFnBIW1k28FPCpB+epBCYFmJ8kcxRIm0SqYaT9lthl4Eu6vQTek1aF5E69krVAm71t7/97Rdf/arSMPfsu/J7orr4h7/7B3cm/t/+7/+P/+q/+q//w//n3/5f//v/3j5h9NBWK+3m0c0Jg9TVqN5eXnJdLS3jbhDSs1gPfyoOmiAZeZQLwYbtKKQiGEmQockRCiNyczRDVN0wGKZ+9DOS8Lw1TnTVLIdCWvXwcL+2UDGc65x1eJJ8/eVX9tZyO6SXkV3/5teat8OLKHqlNsA2pDVws2zMQ0YrcNeeNt8/P1uJXQ7hU+8nviEVJb2xux5DBjRf1p0UJF07dYnI4OptHLysggy0SWZvELbmqVnTm8vw+Pso7TNO06Q1fWJloTEpizgIYmrqYH93cak54yqAxUV49LWtlXWNj9GTBRzvPe6igd9hqyTRidMkhC3DYFNLmbiYXlpemZlrO36nTfhprKtrnS6Hptige3P1Zvddo7k87+I5xzZYz3DiRFwWdvJu/53rwwgnETXFoWXOTntyIRvGOqYIJ0Knp6YXe0o6ObUwwzTq9CI+PHM2o+tpjFn5BJ8cHTbaTbJjzHR4coonRoFOeDYD44uF1OLMMcVpWDOjzibnwqZkoKMqjUKN1A6OD+yqY4UxudEQiExPPc7Nr9Rbe8MP9AqTrnmii3yuJ+YWp+ccwuG8O0qWmER/c3elM7QT2xjSMIPtq7EcDSF8fRkbVQDOxySbsjLEDnV0PXGtNzbqMv6gNcjhwdGla3PAGkaq90+ez7/5cMJBtlZZWN9Ye717vLzEyL/C89gEfZmJ06kP5+dE1AI23aQFGS8suOamXuucH8faj5HOzR3HpJWGwWds2mdhJ4YgXW5D+5Mo+lBzxgftlFxhPnjzPJ/Qj07NXFjjJe2UtchQHb8Yw9vtBiklA5QAPvuEfl8lFEnms9WLlDuLg+QIQ4B6pBvk7pMsIAHpUD31AtJPSAB7YPakskWJr1KJ8SlyEso3RLL3OUGTDjHSeHsk0IC9Mz+QfgYhxZzkZ2L39sAJAzokRFlkVn4KqCqpFE8rBSmhTw8kCnukSgzCkOCvQYe3vLLM8IAhajieSMiHT5mRIuAmjmOHGNmB0QjlAgOcIsUIywUwGmDzZBiAeABi4DQKM7OAX3JIktcw4wONDwBhpT1EcWB4wJ8dEiTEEUJkgJepsntDBV6kJGBwSRbCPokv4h6LKPlVccQnYZDgodJ5oNLG/aSOExIqxUk+yBR/pKIgQAqzEcNMNlmE2EFpu//p3/8HGu/rr7+WaQBPh4+w8nOxd3+IVp2XkCimfk6Xh+fJgaxxSSJVUfc0rzAyZIGkLBSykeHNq8SR1GVUPkvrG+Ty76YQby+uGPp9siH3/bsPtNhf/LN/7ix4A89Wq61dqGrrlrI27LJobPey8hk8xMbl9trJydmbV293376/uXKGQd0Aj9u/Wa6JiEUCywP6CTOV3JegRtCG1XojDTYrDm1mA9SousBnVYlgkDimxsUoEX4CDkk2aw1HOSaIGHxkjbsdOY7MtN5+cvT5Zy/+8//iL8xRaHkmWYMBrrwUK/zuydh5bIvsMqk3MDOT/fST51989mlYUjgpLdobZZrrEpB5J/cwvxucEHtsZG1QR8xBMsZqQ2/rKpx5DBAdNfr8aZjygDm/wUic5wkrAa0EmL4zXDVWtjuBf44CVusMM+WalHnrzB1UKb7xBEmzbYx/kp7DEXImOWwLprDCrkX2k7WO1nMyAp1opkV6PQTbmzwY1yMA64Q1FhlBa9pq2q10FLU2zVv/zDlwx5GjBzOx1xuwtMZBmCwe2QJQ4a3CEjOPSCChYosiAiDSG4wYeRJLSYyhjaITWK0x3Si+APk3/MclrNNqjMpNN0xJbdOj4fgpIXVraxMTIARGmaluReOlw4QrEh5f1bi81IUw1pkU+oMcMHp81emCP+ffFa3wo9uItkCWUJXFQXZKDlFEMzBMEJMFz69+YoV8ffWWqRyxSw9oSiSQDFR2aT0W//OoR1kAhiqAy+MnjYEA2SWvIPcoZkAkE+UhZf4Ug2U+A1I3fiLC15J92LmExUuCJnk/lE2MospbPFSQ6Lc9MCRyCEUmTmQB9hVy7JPEz6k4PSkalUcgkXiniEir2OIpGgFJBqPQpwqWqUCSSI9qhlkW8KAQgJ9gkpuKhh5fMx4GFEoLWBZyzawB080aksUlX4F5ZxLJKVx4Ey3KAUOo7Fk6b+R5QyWQWWQk8oigJAiThKJJjskacpCQEws/fYVWAKSMgFHHsAkTQTDSenvOz05A+pR8jiorLqeu8kAAYOrbYWFGiwRUKicWzi/VJ8I+M7m3/+E//OW//9f/+l9z8fz7v/4rvE3mExqD2eV6DMQk4fJ8dup8xx7HbXbdPt+1wmE0Iy+JJAlOWirANKZuNRo5JzY00HeKRruAl6nxSaxL37ghPWZgrl6XnfHtV198+bvf/c5pLR3uAOFAPDeKc8oY9MJVjP9D8LPCMKDv7JjoODms9BMr3Mbd9k42DQPMOTXdMKQMBghDv1SY6U1byA5Vypg1jh58E6mFqxQjbvCYoLeTIzA4vSWJeYIrzcpCOgFSC1O2mzmo2jXKcrmNscJyY0nX41C+z148vbi6M4DtdO16u6YpHzkq+erqxx9/3Nre6HdiOwsRsi1uanqed6nVzN299yZw01Pri7ETiBHyAvtUO+TajJ5Ag1AE1W19UEU7TsMJ+0zwvrtg7o9//BM1i07zITeD8vLiHEXkdDOsdO1mSxW4WhUb2CKVPUWXsUh5HcpwdLBfinnrjDZ9rbLT8wbLuB13Bk/d85015NHzRec0vnB8HSNM8LAMBCl9it7wH4X6ORYzW+TcNsNcsNxsHO0f6P8BsAe7bCja0cXodBDDIN2MJGrB4A5JaCDJiq9GgJWiX+nklFcN+ikqTyyWynwhxsNllEbqzNFJoFm5Y5QghNwBSlevd02pzKXGw2s9a7mMndXeIiqjcNz0xlas8+h1B/S4EbdK6VccKRojcVYavYaLfr59/weeV1az5YJC/SuztFZs1SzKEnuUY7klJUeMPlFZFER1ZKFEesChSkEAK2DKleRifJUcHmUMtpQxqCIKlKTxAu8NIf4QWkisZBByrZLckvmbWBINpZ2poJJE2DvpERaARBakvUwoSkca6ItDVQlEryIxgjxlKhM9rUeZYU99RxDRXQBicJ0aTSqRksOjhASoDBgjS7wzVUC38wOkAum2Bns7W80VLMiL1kQm1wAoiRx9EtadyTd1nAIIq2k402HOVZmAfSWM5KnfG87Phb7giC7eeM2FtlDRF9E8CkPFS57EC4sX9iAg6z7DkFBGwnLUAoGRkmiKxW3L5Ao2ScTDjzDwHgHx+ICkQFrGNX7iAJ6A1wcIR3HiXN94kl3eEkJlmKmOAdApfgZVhfn4r74hQTPtLJL6E4P/GMvZH52AA0lx85pkcea71etb2qJxDGeMr08753gwODt3d7llE93b9ubGy59+UIqfvvse8cZ9RtDDfs/KB3lhcbZYKi+5MATP96pMMZjAAmKacDc6kqlUSmEuwkorzHtUTaJEJEd+1JJDGkWhlsrBv3QpcebJbwWlc+rMhT5N9M0336w0WyAdDWTR4pLVXkH1qtNzMVmdm3Z6DJ50HRzECW3GfpQeWwFitja3jo9YOxgV4+QJuTge30ZcW535RagReZHPexcBX11Y8HQQAU6raAQaLyc/jYfAkDd8MOpSQMvGRnk6rSLnjlXprCw3EVDKpVczXInzQq0fmgYyqhi0UEgurby+vW82W0RlsoeZy29239dbSzap2QH72ecv7OPdtjLkpJpBT+lc0uu0XuWtVYoVlN/ewk3MAdglri6Y7fTiBydHyyttBWGQIbXKLl+jXTN/7rqEBLc/ffH5kcs8T89NAjrnPbMf+PVYiHe2HcVtBmAma6lJpahKdcM05TpM9ZtHWNNrTlQli2edsCNhwqAbekrXqKNiR3KS0FqzbZJg2UBdV6qLwSuWINuDYR5Yi3NV+PRVXHNfYfKbXq5PXDixmRXNqEoVunFhUK/YG+XmiaXFqQrKURJnVtvaXbmgUohx77wTraj0vsgoY9kpO+9wXlloULWmpRAqYky8QeKJmtIJWe/11bSEs4P94RNToShL87mLftwOuGHfDjkOrHO8KJaWTU0cbkQ3sAEaIsqOYlEoAaN2LYvBYakeC5NWkmSk5epyNL3oHi0W1mISj59qSkbI29vbQxvnJY1CFTP/++mTJgkeJVAZ71onF+mRHQ574FFAqASklSqfjCeZTI7wS67gADBQXlANuj0SObkQ/Q0VZ9Bgn7z9Z4HT5sii9/g+GK3F1aRcce8mNSkTOcDRMlEmJ3APDyJgl5mATwLeqJerR51p4apKdhikwahCMT6BAQlham3EhSb6OHr6OJGRIxhJwCu/sOmn0RZIGiqTe0uV76TBJ9IpF1kgwIMjxuawicy3JICxWH8IHoVYAK1IpCZCkIoDxqOavZEqI0hAZu6ZJFMJSygJgiGBkMKVCp6ctSiFeNkBoNOTCXCCSW746oFfYb2hJT0AYFaXckQnbMlJ+D1glE5ySDySeye1IGWk+A9pyb3FH3iiKZYppwDkIVy/iB1s1AHZVRbt1jD4cG/fYlp7a4OWN/RbW1l98fTpp5+8oIKVpeR1LSPZ6b9ZhxzRgdsWr5CHmMDfZJyZ0R9iDmkRL6BJRQuJw39ITmzWT94qkSTeWKSkfdeqmMA5DZ8LyoT7UuZW2yu///3vmacsGnEeJ69caEI8jQ/aq432Sn98cXzeGV3d8gZ0BDG/ExlYELO94frmnuJz2hpRoE9ZbY+Oj1++fHVWztrkgRAVMBFnHsg9OOkIuWIqRIOwUtDUBlP6EuUFKyYhBfBQJMqF+R1kFYPJckWLj1xjbTnOoLc4PxyYVzfqlfPTIyfLu/V+0O+trLQc5nNycsw6LGv2HDihgsThDe5zdHoCf5bHj3bW11Z1nd1O5/z02NIIBloXBYxsqp+WwmoPo5ZenAxYyjbRwj27wFh7CKc7tgwz9TRkzNSX8bJu73Blods5pSm1NWXxwEkYVAomWI/UAG0NMvDHQe4FFor5Dnk7AJazncsKTAtW1jfaK2uxrSz269n7FfNUGFCFBmVBJB5AC7/cyRWglo3Hd5Z+R1z4mblUtwV5Ap2567/oa5oIe8kbdsKjZSEP5/XRNKmfMIv3yM47syjlsKc3Gpq0ZibiyaGqVHx6LsqIkvHIvMMoxyYYqyZY6o5lfNAotB0/4bdBmp5M5MwX5Bwqxh0cNp1KMZYLLqHEJ80cqb76JJUa8UYDmpMYX31KPpMWAW96yRuFWVKQfmJU/oQWE3zF1Syjr6TFW0F88gj4iXISKxVg9Mham/UVqgcWCaABgK8okRcaBMBkEl9hCO2WDziPZElr0gQpOPFy9fiq9YLHMpFwZRm80YQ4qXyVASTSgkeZ+IT0E8sA+ImDSZCv4vUdiFNyXxGNj/JNDDLyUz/pqyQSesCY+4iHyidUJbszC2SgR0ySjTxJMtNEnmT7CrlP0ArIWnL05CMGAQx5ne6ZpmhNjAXT6MlsXVu1ymTixa1Nx2FwbQ+6cYQADFLBDOdHdYOOcgOMnwhOxiaLkCRTkYUD0X2CFCmABgFIYEtqwSipzuP/T9adNemaJPlBz33fl7PX3tU11dXd0zNiRiMhGWC6kGEy42I+BGb6JvoMXGHcYGCAiQswMEBCIBhJM9ODxmbprq7q2s6pc3Lf3sw39+T3d8+T04Knsp4TbzweHh4eHh4eHhsMlKyCgCEfPQ6QY+smwFL5CXOXTozCeRNTqeKTnZ1aWIyCsPjDUmgnqAxPB69fvXSgzZPHjz768APsRxUTmDhI5bgO3KYfm8/MXHk5ugG1ZQpluKpEfiLSI9Bk4G0OkXk7nyFgJRrKrMICD6ZFmQaxRA2/d3b2rHN46uhKR3VSS1wQw+HWwYG/7zVWDcg6Wjaji5mch34y8OdOLmshHGAvQF9mTOMcNdMJl5e6gb/65S+cf2mlBJPRn+N3LBlKg5+bWy6XMQpVlUz9eVCIJPmI18awFx/mZ6cZiMQUQwgqo0g79adkXdGKrGnWYo+7zY2V8+Fg+/XL1cW5iZHbb7/5ygJQs6bO53EghGlYxVJ2eT1+9OT502e01ZtX35swuaRvBiem77O0sQbZ1tphKra76JyKZwmzOR0B/frV9+inwogBHrpOnSXDsGEPPnvnxaPHj83Sc01YjkWp8VCbBV3l/puZNuNNeaY+xnSH2VFBlvS1dKjxh0NWWc16UGeXzi8sWjVgR4hFT4tLqzxaDl0y7ppbyOFFq+sbgCnZ5hh501qzB94WIhMImtXdyMnJkbvJGNpWqVuItabKRrP422FQZIYkWz5GGjU5KTx4aICpavSoOlISi9vVt61ZFWqfth7UND4DD/mAZSohTgojw7g/rTWSZvQVrcpwcSagVunO5TSim8vNR+u6IgaIIRXeMhFNxtjXvbO7xWTJOMtFnhY0mNs3LsyA444jwQMttz6zQytQX7JGm00VSt3EEBKUqLSsIqvVLqSoP3lDLneNQribMyTK3k1A4KGdAhCGzQO5okklO2LDzgBJfyqsSLlgGp64YEc8vgELZBm40sLj8RMSGTVOb8BikJcmzFfRuGRceUc2GrXPAjCKAac9QIcXWdVXG3liMoyOMgx9VR5hut6bFGo2zRoNqddQSwKPvATAeEiAwkBLv1Ar9CkqpYKtqQeDAJFdqkzrlRIn+uKFgSmekZWfkDdnZa3uPX56SwseYQJ+SgUhFqAEAAwe8agS04VtlkHoEY9l4n1FD1RKejYRg1ez1Pwkl6Nl3XC2oFj9JtyoGrNMuyy44RP80AJAVUoXSQ6TZYQhXWRgVhGAhx+daksSkRASa5wXCdIDG7ViOAkSWBhCdOqeKXUGLZtUQuulnb+YEpl7dKdbxrxjcwu0xijb8Pd+52d/8m/+2LbV6ZWJwfERMn748Q9kwc+7MDej3dqA2nVqkkBgfQ3PM0ZhMM4/Kp5kU27qy1SqLtNuKaYWmi3wQZJ4lKMQAeRKgLxuv3ljBZEWlUvqy+1uzpbqZly+3t3miMGPb169JCc0nhavXJubj9FmgY5pTfO937/Zgfbom5c4Kf6K24h7ylVltdzb4T0YvbW9c3l1/fjRQI4qsfmvOjwKaFGyhJomkqACUy4ss4O0QAZ2knhAKoVqUvv4D4mCKL4kYGhUjVNbYypa9bh3sE/V2he29ebVex989Gr78Od//G9+9OPfoaa0OdyzBfLkaMARJ1OTQdZkm1a17iUZZafrJUc2g1R36I4qvdXx92+mRmcu7zKRLQle2YZhwlwRvnjzve0LL7/95p333uXuf7GxQSadA2E8ROo0pfO7cwcW0xGHBxdz01NuvxWpmCSZFrZWWJgiA2zooHSmZz/99FNrocWzbIghk13B9YWWVxrHuE9U4d68fqWdceV5X97o48d5ddUsLm1vubh4IVsvjEs2N03CMLej4Uw7x2GTAYHRsmMZtPrD0fjNNZyq1uMndY0Hk//XGdaQeXah66DXNbfLy6+BcTRpMgQs7rsaZ6BNppLTyBjIF8eShOGXv/rS8gEjMGvDfv3Vd1z9VmTuvdm/HsmtijapmBojWlpX6RO6Pn4Fi7WsZrbATKQjtVwNMTw5UsuOY2Lbk1Xb9xDPj/qrX/3qZz/7Kck010ISiITqQIY3pimaEhMb9YXhKCwis/fIuAS8pg2bsgBDuVS4pyyeVlDg03z4SGrph6IhQ4ws4NQWIG+GQ2Xk18DIACmtd+f7wCWZgvFgo7ThVU203KtjKeUtv6ik8g+2AEmvMHBJo5kJcPcRZSqX5KkbB5iIYdcyiJghwvSteAExhjiyRCiKO2/EwY+/YsSjhsrARx2JjJxVqTBkwqPAHmSofgEJAfiKBvzSDuFBHsJgxhdFUkgIuzJUZ/NCpICfMAADrOK7DQhD0tXWqBQfvEgBqURiU2tqASaeVb20rTBKAGiNZghg5h6REG0I9tMnuUiumM7bgVDdIwyAtJALtH63MIYI2UIJuRULTCcx3tZUsPi8T46OCLvlCHp8dQ+nMsKAJwhrbPLCTCLlp0KBwWEw4L0xUGv3phpk+vLlt/oD7k21aM+rlc+Lc3O//dmPxu9ud9+83nr18vLs1IoR07cfffDe2sqyLsRy/mNzsvvZ1r8wv8T9tpijraPNjcll2kzrulB2atSbt93bpzStGtjyuMXcG7GQ+cS1A4jxNXV6e2NDr+L84stfvXzz2nIlx8X8b//3/+Xzi48++kd/+Icff/aZo1b/1c9//p/95//Ff/8//s//5X/3T/+H/+V//cVXXx+g4Obm3/7iF6414COOy/7gkFLizTA3y2TTDTid4fvXbxxJryfItVwWkOPW8NwyAczBKyvi1VqE7dpypCsnq6gdhDEwOC7MKqETAGWEn9hLOKWSlhxqvcxStZMDcM50QCck295Uhrzl30d7OxsrS8JuKaHWLah3GwvL11nI0c/OTLihENcsRNELZuuGyVj20MmR3tSNkhQo3q467OHMyR3HZjL5mvxRwoxrG0cMAlS9blhZkEQytSD25u/9e7+blaQjtzYImnigwEzbujRRdZSay0QRzCY8GctERRUoCwnZfPL421cvGT48Ytu7++rLDjtr1c0nizRZQq8Y//GnPX76xMZsAIrD5CDB3lqljoSc4B6H7dH+nkNDKX0zBzo/jUm5dA9y1EZMCehU3rzZ/qu/+sW25TQxkS+tGdEecdV3UgQhVORKpAAisb0fdQGJlqUgxMlyJmDETLz5Dz0WeAAGIvbWSE4eM7CID+pW/5pk2YF3p1+Ujh4jycwubASMk+YpV9c2rAmm7hCMGDgXF+csicNzjVokOQGcUUbxk2DInS27vr6qFdIiAAiMgpFTS2etCCBmSiFz8chDsFTAFAr9iuMBoJqoO8jZ/hykqMIKqUSa7GU9ZGPaaFxPR7x0dcq9Xl3hpYUZqm56CIOqI23GxhM/5SvHFuYMmvqRjFXYPPWW3rvKk+NqUzm1f0z/KexpLGhSBmoOg8QIo8ZXyoiekrFxLfyQiy+e3zMFJFLEeIQxCAy9jLkS+qls8MAghlSpJUfFyQhJKBGvkLjmOA75qgxIxAOGRzxULQG+iumMpLVi3U8k+aqNNNOlAgZnswLwA7W2P4KEHOvPT3P/jJpwj8oHH7wvTJfIFLwmpLZANnkIwGI0KKOWgDmygF8ucgQj3NRyG8pUjLdPTaeC9zIMeMQ3MQKScwSbT2s8uEQ3YRe2oBDHLLoALGuf4IQN3wy6GV8//tGnXBnUuvNyLfrWf3Mz82jxiqwtLf6Hf//vzkxP/Yv/8/9YnF+6OHWUm7tNrr/7Kp2ZFXzf8RAd7lEofNMWZiLP3pWZKfsQ7TPIRI68lJQHyxZfnYJdXbR/lwVbulxQCZ8xr+3lmch8uOlNCfWdiolsF5d4239rE/bo1MQf/L1/n4545913XS3y8U9/+h/9w/+YZvnTP/mzn//8z/7oj/61XbKaU7tB1P6WY24cyGyebnKKWrG43l5/nDEbeXC45QgDLhaL+vActWpQ3ck0J/cMYymjEHk4jGYuDK1UWiVCD8Y6D6hFkQY5Mrl6v7eAlyPD8MCM6yPPcEGDsd6UeC0tZK/+ubnS8+GS1Tj723SnnRNWvh8cDlyKa2Exg4kykq8RAPtUjR8cHzhyUvd/6CAst0LO04NpOBSKDoO1QYqYYw5+4MA5GpxQBHZER/Au06oJdq7sdjba9dXv/ux3/uW//JfS0heET79iM7SwFS8WNimv7lahMGF+NgN3kJBXwafJrQBuCBgf6EotmXWll4HOMTGORI4d1CwxgRff50rZy0fzYNezF+/sH+0apxJIDouzg6P3XryD84f7JxM1y60pXZ2eL09nihHNGSjc8jzFsU6eRSrLnoUcdeyHGkGtPGmRkqgoE/M6ZMNUBCukWnMmhzN+yqFPR8ur6x999APjErXDcWiVkIleqeIwOcuA4y6rtjINruBy8YDUAVm8epeN5Lk72mhjcXYGbZoDYXvyaPNieErX698VjfzYwcuPwnYx4GDvqgVMY85SVohpkZaLfJEto5D9VvPKOjmWwe2rtiC5EgLz9qmTCMAjBle98YH0ohYqAcz3dX0lSw3lqAPgfbH6TS4edYeTwMBAi8jf/AmDn3IJZzvUWfZPaWAUL/AACku4XK6Vpt5bTvKQVqMCrxjCKMMg7afEqEse1WY6s8qogRA44lUj9ysTOHF3QEV39QK+rhKGAHqwW0bMBmFImhdqWthjEC07w/EaFWIfGyFOXZq2GB5tK0Cla4ECKNTlIlUdEGi8Uy6NAakCaPD2yEvBBfS0lKt4xVFS+UL46NEm/+/yktNR0tsRaAgBYJc5SQDojzquY5geZBpCAHJs5C3WEnrgVxYx3r7CSTgB+yTS1w775CcjWowHGABUYT4THYwYuZAjeNiVIhiMltvohCyrtwrK1OLS3LTJxuP9PRg4FFyl6jit548e/a3f/ilPNxmy0pMRTZ9w/uSwXa3HoHgml6LLDv+t/RBQKfxy3B3wiNQY8FC8rH3COv+ipTmKNgVnmdgH7iuVzYP73rvvsmKOD0+yaThe2rvjk8Ho5MT7P/h4cW3lxTvvWD5itTtVZAGTkeXUwtI/fPbu3/kP/sHf/wd//k//23/6xRdfjE3O2tZlF6hcVKIDix6tZcqRPrW6iR9Ha8ZFI1SXtdnNQCSxi5sYnaqpJzPIqsW1DsJ88uQZ2g72DzUebnEPofJmm1MPfFO+SigvfwimT9l5HN/+mP0593F0xE4rME5Ljk98fPr07Ng0os3Pjvf5wL1ojJvTc8Z4UF3fmJnEvYOzQ7XmbhUxlkZpq/xKuZHRHp9al4KlbFqH2ttsan+FUeHx6bHxr47hej7Oge++y6AE2amI0zOd6PMnj//u3/59x+kYT7C5d3a27Iu2t1YxDDi1F3wwdnFakSRW0DLsnDbBUlFN3iaKsEW7IiI3NgCbIzHxg6IzB89Nuz3CXD99xmsnX3Uta8zNIrw7TsUFu/otB16dywoY5G1urrOpjVoebWTTk3GSapmcMu6Zse3Aoaljl+ejtvqWTrTElzjIWvExx54nQ2GdItT4gLd4lfOaVEfNPKdZXaX1SeKcP9YqKJCEky52Oxv8+n4bjwl0N3NJINJ36jNuRo5zZmG0oAHOzdLyuhKZhpE1VtDEDmloRZTG9TZeXlZbEW+olOjmhk8//agkBgp4qyxUDTkXSeqkFUOWECYJ5SOcLMsSFwk4DaSMd28YECAtAI9wGpc1niOuMzvDbT9FQoI2d2gzz3UAEnpgk12aWPlakApDpL20h5+QA4M8MZ1AqB9pIBVu7E1uNerQTVZ0VmBIP3IRgRRhppn8AMtJSeRxr4nKBwJeWm84087L4JLWKEFGEMrRJ2GRxBJlGnMTChhm+hQzVKefgBUAjIToWVhyQ2YO/hAvEn55CUOFHg+0UsndW9jNyCj3U1qashGK7wcZkncYNmBQifHIVKEgFJ9BwHdxT0OlLhVZdlIhGzFihDsLATG4JKMiJy9hSDxqBU4w8hXfXJUXAAhhAOATSJF+ike283AlEQMeZvGkv1E1sAaAMDyRFRXPcnn+w4/f/+BdFs2Kk5zH3I1nB4NjKpaxyeJn1aOY68sLf/if/CMdgFnB3Z3c12rvlYUTB7s78TyM3FlI/sG779l97/AA5tVxDueiHVF1P4uuLHE4XAxN1+kPUIgemBUd5eiMaqytPLpe04s2f2nVl1OSO1LNYSxxsv+tv/37FsnMbarrS7sE6ErDc7cZ6NT1JovLa7TWe+9/9J/+43/8T/7JP6G5Njc3FN8oh8Iy2bh9s0ex8RXLUU2uLC9mUtJ2LFel21Iwah9ZvIvYpYfWG5nJNASxDJE09poQg7nYHLWGRBeZmiUpVUdYKiF06rRqXJXFNPOoFzlqnznahNg47DM67s7NkRNXo5dz0zzllxdna5vPzK9SLEYMqtWaQCpLWtLOz2MyfH5pDlPdrDkzv/DGAWoTMeUy8FqJAQ5AV3QzlQ3GmjWtakDmfFHnn6lxP4mi/mNtcdl5avZ8OFh/580WQUW5qdSIxciYkmIm4WFkKzvVz85Vdm4NybNskbrNiUcuyzORm9qx5lcZOcEIIk3GXUOWjk4HptQ5keggDFHqvd3dmekFHaFJfnPJXPB0LvuJplFA8qAtkwOGFq9BxpaT3OXRJ/k6cXU7l6Gwemx+4iK3iQepYiI7wmPjDhn1M5X6Vm9UI4pr2+odnRAZdgsWU0xxYLOc7NHjzdf7xyUUWGBAP7e3fwQbkky23S2OOhcjBy1oG3QuxCMhaXh6hKXu+VEF5sZkZweEvNRXG5EQGMWCpByQRwCwovstko9ISWTRj4z1DfA32X6CkQSRYhQHZm+pBLqwvoKHvL8CI3USKqkYZMAsUkAS8WrWEe7SwuztKSmFMjoQnfIS6Su0At6xLuGCyNvvhwc6yXyVmSGqeCj8pJDC6PLzNMUoaEIhUXhiBLibiuoMW6vyGptPMCMFEtjwUTwBVQYEtN6HUABANzNIwCgJGBn5ComwR47d36rmJslXAajQ1oXqgjTN8MgacmlRaMU4ZQ0YAYAlRFJSFRK5+CR3JzhJjnfb23uaCrpNghlKs2hkpwGvrGZi1phAEg9slIvBoPm09odKjnK5C3hkgQxphWUhU0+Xq8mABNmyRicAacV7qIbGI4xabwnZa2/ebL3/3gvssiwdvOQw44Cs2Gx+fvD+ux+9/963v/7SCbouq9rZepOGcnvJWDNQcHyBdmjvIkez8x603uX4N281b07wg4U5y1IcKfree+8abxn52hk0t7gsawMLswWq5oHtyPNYenh0lB4RDHpIGnpo/AwBr2obeWZoo84uzxylfO5MFQa+c95ZqVYcSajpWBhpz8G6o3vmZrPQZ3qWFcpJOTwfOAr/4x//9Pf/9t/5/JdffP75ryqjsbM3O470Gb3TqVAW6f6JuQ1ECkIAtXDG7NWEhn1puoqvQldkEagb7eRErnmqauIqDPRY/4J4/Fc0aohhS/92FStgxv4aJz2qTmsoxsvENa+YzGTZo0Q/RNFnn8DI3cLs5Onl7fH+jtWT88sb3GtmVlSQk4cdMLq+lkM1ZKSLgsH0OL+LjdFc0k4OcBqMTT+mL1ip5k8JfezusTscPDjcJwZk2MU+Y2cxNSzzPzk6sFTZJrtvv/xq3ZEMF+meydKr198v2e719HmGCFvbJJm2sqbDCIJetrbNMk3nc1B22Jz2E2dpTPpcqVW9GpEBiUIKnX2tL3Lijb1UKLcmIgZ15NwOAUvdWaPXlvyzyzln4dIhOdON3WIZF4HQzHIDgaHllSF4hBk/sR3PkSpMdDUBD+TknAxjtU+0Yc5W8hiYVgfgq4SOx5F7NxnZwSDs9Asr+IVpRuMcZ07p8vVPK4sx5mogaPVTHX13fMavxbdKPJBklIYmK5mtRDCMPrGG1f2d86QrMysQ2gVGIbAwivJ4BQT0l3pf64XQgxjKUI0gD83ctHS7eD8lbz0uLJWiSR5BKpXYMIomgEgA9JVKtJGNDdHcoGHYoFwLTniECn6CCoMkmpRZxLn5OayT1lDRJ+NsXbo/lUXG9PG3OTuuOidpwPXTYQR1NSCokcL18KmLKjG8WCCgPIRGvJ+dlkR2PLS+ejp5Y6P7iDsYDEI9kWpGdEkeGEc6QTYGCRWSrhcjoUgxEkqCRw95gRGJkuYpCkH2V5F+ehRNdh4ZeYP09hVCwMIARHZ8hp3VK8hFfNpGWfTwqBW9DiIl6QJCgr8O4fP1ARUViWYPMjAB2iagckjWnqZK8gbotOIbRkL8ly8AkX56g5HpQ9kdAwsYN2AQCRhO1ZHJruubx5tWzaw/ebxpPbgVIyZ0HV9F6WSWlm//YO+7r35N9eeSE5auSyfc9mNlsY08V0NLtt95/pRv3TynySjqgunK0ZzjWMqPNzO3gO0G0XJHW5ddzaLkgWYE4zaaAeAoPNzlHLJKmEHYxTXrl4RaK7mxtsbXAZ6NoEQLi2TgEngPeFzym4u5chapO2bvjAzUv2N77Yqy4NBed3laA2gBn606tggYeZsMcFAlreJ8f/rdsB1/sI7BS2fxlRMqlUggrURAPLIZfSq3qwMkeRPfPCddANRgPwrYVd+RDwXkarPqzyk6NoXdmB2dvBsfuXQ8nB/fv/p26/XLclDxpDl1Q/2glJpjr5g5cEDxdYyMCStid9S7rPFBVSIbf1j0jzbNh2VEYkbHfOPZ5dCGAJAItkLBalFKys4g3ZLLwrhRrDSVCELV5O0wCXQSXTSrJjEqpYsJQEbE6vj4yP5YIzmDMEsnibQOkG6RqVTuF9SWGMuGZMIOdaHK004csLy4QPvnq1Gms0snmVn3M7eaAO6hU5WFac6c4Mtwzv3AODXGrGIKeDep8FFzHjG4DQCdPikmMjziwXQSAGrQnL+6VQg+nxz+UQ8AprztWjSm5GoTDR4lhZB0sW6NF+kRY2pywngwN94VrdIpdGHMh0cSpZApxPojX1HlE0qaTrQJMP7akyY7aZvybh1duo7BBBg8MCgOYoQBCLd0CQtA4ukwADHqLi0ul9xlxhFV6FEihGECHdUVCi0weXlXSTMlDkwSZelcvNMs/eMpboaI/tmMbrxolbiJaHIbBeyVKk2CCay0ciK4fkKizEgXkLDxd16y8EiLTSCF5fUAI+wB2Vk3s5SQauiS+OoTMrxl0bY/APHNF2ml8gh4xKNWLmiTi0e3LBJtIiWEChO71Ojx6OL99JVQV9uIvSDAOWDcIF9zj9RHA8Nj4o6vOT/JvZnDXEx4RInY9cOexRaESSVrlKAZoLB3U9gBb7l4g/EV/QjuMEqagX7KjowiRlpgXShrqJhjUVsjKaZPAFgddlyxCMQb5gP+7NMfsRPY7DSU9k1NGQHmFhH2zHC4yJNjKfa04xW5GqW7uTgdGgEhic3oNvfdnS3dSjwnDoLOFS6Zj9IHwuyRr0xRGAIstEhrT2up537AXnXho4PWHWw7usAem1/Yvdp96rj3d97ds5BjfOLNqzcvPvjBwKWL5xdrT57kUvOR0YO9Q5myeUcub/7k3/zpf/1f/Te6pH/xL/45l4tapAnc6oVFJEo/Vcp07HbAJDe8oy9SHXrBbIvNPFA20IJEbC4GMfV6cIRmyfUBiqCAfgJTcIGuCGxXPjfEIIc4c5Gzs7JgK+LNYL7hT8cNX8toHuFxMher3llflq+7AGvMZQoTC1cHJ9eOx8wtUawNC050OdcHu7qlG1ZqDjbIGvO1ibmLs61L0wBWShiAwLaxts4MZGMC4As1w0Dt2p4yPjnLQnfcnnlL3h4sItl6Ah0Lu09xqDy73NTJT3/2u7/++huiTqk9fZp1FtiidATSNUggdTwsCXxgWhrXilciTQAf/I8DAgrlqOGrxYuLs1P08A3qhBw8jCrah26fGOf1lu8FiWJQ0JizaxuEX9XLiysq/L+8MrCREflGg9mRMXtUS5t3LoikMlgbEjo+WhHEnAxll8lVjwlf8wCEDdm6NchHbu931KPZT4uCPJ9++ok1wTJCucb7cvt43KHGVzls3CSGka6FWARWH6YbiBKo9Y1GYZz0V1ywN47av+9+rl11UwsxkaQgIT5CYnJClYUM8WQe63Sc/gyp6WKUg8QEXxWNDBt6UlndkWg1LV1QqQ6cwQRKAP0QCkvLTmJJoF9hIWlTO2CczzMZJAH2llYAHrn4KqYaZdxHPkkLv7zkC4O3yP4Z08wjg04gsUfG6PCGFF+ACviJLHlErEu9SiXQ2AEoP9lS8WCExXsaf5cNZgEIsUAANm+V0cUQ6RPipM3sTd3d6ifC4JQ7tYuhKlhC5HmoNhhkIaEHDEj1JEYqucuxiRcQLwnzE36eV40YvK9K4ROaPcA8RXjSCmAMGkCiE3JlZzDS7MtLq81x+kLWiJcjwtglSALmp06ROSkLBYRKvKepkin8EEoiIGtZIK8zlRaAT+LlAoMYYTG0v4BHvHxh05/Ra8SdNvSz08oIc4xIsMLs0O/+9s+sobJ4uS+n/eqrb4IqN9JleRJIJDgW344h5wJZJ8k+3nr9igbHGfvyUZXAScaNaoGSU7QZ84BWkqT7OHUoN/pRhcfQQogD2KngClX0pvdVfQuz8xqYpg8h2thlrhH64MP3fvtv/Y4FgmurKw6QsXTG+vE7jg6tl6tUD8CR744+m5uuTbkf/+nP//Wf/ukfR2xm7Og5htmeVf4i51M4DcJ5cM+fvWOcwMbM/DAfytTMq9cOaJxdX9/osmgG/P5qlv8nHqLmWqk5QY/iYC82YhRSuwq0ImxvDMoFhks68xm1NVSRJVFYAHhTZ8ea8XAw6pmtx2baJ+6uZhTm6uybX//S5Pu14qg5Hg3n50yNzyzOWqVqmc43376018EyLSY/5pvx9eZLpNN2t7YdKayzMf9MgFcXlowwsJKH2oIiPSFSGbzfff9K83kvG/qmf/7znxMztYZdSmFAYGSwu72DZqXzioNuynKXxwBMFiC+b/4wJ8HiV/h0eK6QM3NbK76UMaJ1V16iK5fNHdLgBKllUkeBAEh0Rem670ZWzU8YvvCS5+yKzOuyLQgJr562i2CuVDLCDJdKc2NLaXmO6wCpO5MX/a9DyolLhmxpBG/tM/2e22XgLUsOYavraxx9nDDPnjy1vqsnGNQm7NZi2aFN8pzjTVvjIfQ+MXqCcPSWY0TbcsGD44z8lK/VRAYT5pxm56imHH0qUmdBaJFqkFcyHK2t+XdbpnKw0XprAobDIslJCFtdpSgsl2Od+EnycSBcqhEY1qkpeslbWURW1cQphDYNXCClKJcXnORWl+xOJ1JhpBNhLsOfXFBTIBubhkliEQAzYhDvLdNWqoQBDWMWoVMcWc9g5YwekI+Lo5apw441OrUvLgvLcrdU/zkt3VIqBoiezzqGUzeI3Fyubqw6yt9hSuIB+OTEQW93J7now5n1TFFipEdvx6IOpdsJglRDsw9ZGMqusqiOX9Ggnt0YXwH2LUNypDDYgeieGeWaJzyRzUuHi+WQi7PBiW0q1hnaWC9GrZsVFK9Gvdm2gFkm/GR0EMwsR303KZg1OnZFTHx8No5HfHFNReIs8kieylOFlsSRA55xrV5Hw2rY3HhM+i0gIUZuzpJKueQuL9uxLBI9YdXapJg/om2tty2kkz2Vpyvi8qZQ1JMcqVR8gME2E9XvmGirxPETD+P6nnRJqmtSI/5G3/iGVxq87YsffvBe1mzMxXsgOf60NFv4AczUn0k+9DtV17DVgUAfffzp+x987MLzI35P111dXb3ZshOS33A2XsqRG+7di+tLSxKt/WfoETjWE3OJAePPkQxMAgcfvPzq85FJ9q8zk60PyVhadlWtoy6k3d87MiRjHXJU8PPE9B4doZwUwEUCBlSbG4/0aDL68OP3B+cn//s//59mZifYuIsLUxeDw2uXB1wOebWHDlQ43F3fWJ64uxi9GZI4e7/ee/fpxuOVZy8eu8XPpCvt6XoJ3ly1wI27ubb5wgKj99/vc0w5lR10ozZx1Rss454xv39w+M2rV+xPW6h4DKwlN7fJhsVDTVSL0Bass2RHx5QuT3raZ/3W/CnubpZpTpSmwmP91a2V/hR3CbNlLS7PUXmjS26Lnx6dHLlcdoqys+nHbra+/mJ1Yc45EOSN20STZTe5uGBgoerigtta0LnJUee87uubJ5uPZKvGdSsaYq6g4NEZnXQl25qzlabHZ6n+s5OPPnzfXi1MoAimF+ddK79/dPzk2XML9q3s+urLX9mpnp7j6mZvZ1el0KdW8VPECu6sJ3dY6NoVH6NSX1VrTkW2klUt2u/SDZD6w4fy1WdsvbywqBbNtYzf2hI/p0URS8cv09+mwU1EW3/1xdffsKkZ/kZ8Z0en5pPcsEFUPFguL+2VbYCF6WjHYnUxloe5Mtqay73z6wHNTdT8BNC61SCSeU6fqZos4xkdpyIU3GBXLUOlZzdY4auUytVj7gT56PmTFRMqIzcrM64kHmqJuiU3ekhdSwVvnMtl/e5iHe9jTRuf0sGJ2WHacNIcsRWnejurey2lM9diecWQ3NT8ZVplGXBOoOIC0ZxpP5owGz2I0cSohkxPms3S7Tgq6vL8DEuzCFgTnrHGjIJy1I/WcM7Tmlkch2KzHdzMbMLFhjTaZexuyioG14dMjfs5vBxSCDmR1g0ok2Ni6G4AGGTjKytYkyTGHrWJHFVGw2AFVUARceTSQulX+3MIDly80joQXFbZ3UP62QFvXy1DUFSPsAdkB6BO66rBEWwaAHWmMux5EYkOlS0ViYEZEQCEMU48mfNJKp90U34KoNgldwBAGh0zMeAHLDtKs1H5GnVX9pp4kR4/uzhNGLL9FC87b8RAIqFcxCAbmDcKZUTZgZE1WxUeAOBv7+6nNKBibzIwsaTHIoCJox4CwcpRjMqOXBg8FCbVKQmC2zRuZqJHWYChxGyon+KbJ3p7s6y+mv1rhqMBZJeOfOtiGETW0SNVKcAISGWtg7CMlMvTHChW3Hz43vtGcIPb2w8//AH/qO1I5gJPDtzzdWPwjlumNOOrkHhqfM9pJ657L5exkb++BBIIjetVTRoBWR/LlhYSebKftTeArYj0yBRJChXfvs6A1R7vdiw7X4s5uuAMKz3KdeI8XhtEJ8bthSLQ6xsrtt+TZ1vSVpfmGHZnh/vWzAydBmqOFSJr4FzAd33h0DtDi9W1Jb3Sm61tl5nIgkUFpxUtOPl4YzOKgwVAa9b+Uo4vhJiJZqXzkjC8jQxux++wjvpRRkaPXhuRTGzCZgyq4niJUa58qsDkIQ6oaDHoT3HuKGclpiuZG0FC+XoHoJqSacSbMe2FMaVjGnGNi0W1dBV/AnP2F3/xbx8/f9dhw0sKjyAHXF9fLC0vUz2Qh2OWbOYwMouWTrk7deScRcRcYY0JXAq2vfP90vLskZNFR5i9T1dXNv7yl7/46qvvbJ4ofTX21ddfW4mAfmJsJsBaWi4j63UF6HdGiVrhxbcSBus4lI6Prs33cuDy7ZAZRPjLRZDOJeXcrxPRhZmGBodMqMVZG6OOtR03ohzb2bu3P+cQDqtsbWKwYv1goHWO2+RviDVes+FmejgPHFhGknJHNB/RWbdK+6w2HUF4asSfY7cV3xS92lmeXFG3qJILYdvZ21YFDrBzJAfZXHYWoQEjm8+A+/jItjKTu3pHvZTrAvRzz55uGjYoy93VnaXSbs2w/vjcyWmLWVJoTY2MGOaOrWKlQcWxZBzIZFYFJfZSTJ5nnqI6GeqC5lMcexB0Gi5XyPF39x5mUsGY80a2JoxgVPkaCakHbf5V3hLXCIyvwvJ6iJScbqE9yDvRpV59bSR+Si6VChUWGdXsayFiyUFFRBNfjwAyJAETlVKaUCTMakG8cEYW6Ovs6UkoxDSoyM7PT+FGGqVQhh6M6AAPHR0UrfPWg+EnYOVHpVYkOUi5KJu0Hj/VojcYROi6BZqmlLmmVgBD4g0bGJHwiBEGI1M/faUQRcLpLcbXhoEfmCz8bCKVBdgDDcJiAPgqIWAZicRB3O9cjKfQBUC9yhG4MZe3sgMWubJiWBeHmOSwCVs6Lyy5n+LVJYsAWjzwFg9bxwODYXk1fSFq5YtU5n8XLWskqsj4hrE++UlH8+fKXQdAzXHfA4ZHWmINs+LI4vJiGGKceH5xZ50AqnT+voqkKxUW/GmtSANMpH1CAE+TrXj6PiJgaaKr4JRUSxhbyDpo8xG6YeesPLC0TxPCIo9JAiYOUqGCX44MZDQjz9OslrsY/E9Biu0lMleTM7YHTb7/zgsz1du7exoPd7YTp405bAdz2JmtkMw9Fo3p3BwjbYKXDoqhe+fo0MhVNgSl3nmxXSkTmi2VsV75OuZCquz2xtH8GNVHv1nN4kHFXZaaOIZ2TkeHA9HUcc3nUSlqp8BQy1KcNl/izWUio1v3ppDJ0QxkaVLP5V38hBDnR/V/aeYGg4pfSaykNQSwmgiL3KCmw3U09sHe7rRDdlY3nF94cHgw5Y60qTnDKPu9tAh+pJjsI2ymAV/SvivzJuLu57w03Nze3XIQKJeIGSAqF99cDFUGR64xIJ/4/KMf/Yi7MgW/ujKLpmqMz93xZ54HvCKsbSydb+9ajMSgxUkuLfcB8qpTuOnerrI5RhkJO34TGzDMJ2aBynr17XdOCHKSHbZglxWlrqwhopb5D8+yEZrg8uAor9zRA4xPCG/9TNjlgKT25u7l969+uPgOGTt3jvdcvCW//tWvwSDWRtzn2TsxS2CM9JHBzDJqmFye1D3AjOdIikyWiVmtmyGQmb9ihWNwcyZSJoanZsDrCSHVghbsgMm1lxFIewe0fDnqKowjR91gmg3QUQJ5O/P7MkvprFvTUagOEy5Q6b0YPucDngDjyRiXBA/nI4QLC/ZmT85l33ZrFXUBQ7hnlFXzkZALFD/TQHyF07vj8dxPj5/d4gR8laRjJOyvOC95p3pAKLm69hOMVDAocitknzzK5S0yWknJvYFq5N6S+fCAFBzsHjHCBiDQyZ5UecMuHryALH0S3wGocij/eBoPSIxu6mkueJomusNX8d7I0FsUeh9jj1qlgmjINU7MRUNnJwthYuHR9ET6KbumEDYBNMDwQIkYD7TNuI4XA1jMA+YmUp2lpKXIiLtuURahKTeTxHhXnWCEwfgpOTwePCB8Ij2QA1Mi5ZKFTBRBpAqTC1sGjITaobzEyMIjPn49U821fB1OKWHwSQB/McoiNUmgQoCECGAx2QMMDInNB8g7LRoobhnJHQa9qMG248MfPXoMBrBlYZgch68Jzrcnk3DEwUwIjT+7gix6ih65uc9RKSamQ8zh6TEfLm7QpKYcZIQwD1T5p8RDJPqLZtMAFEvMZs1P32M1ZE5O6JGZzVZ3I4vzszYH8e3yKhmIiXHGNfsx3DHoGJ94/713fvKjH/3Jn/2ZAf7jx0+fPnr8aG2d28oqoEebG7cW4I/cvnHY6etXWrSzEOg703xKms1cWfbobWo5DYl/jSvCgEDLAiAGkfipXAroLc/iak5B71MnLayyUDCtzrS/G1Oq3UrYNQ7Jw8NLTttLHus/B/jEJX6dHUiMaVM5I+ury7sHx7/667949t6HCzbULizRRvS7YRlWD89PDAL1EzwJ29tv3MRi6spuCcWB7/TsaGraTGlGh3oW1cQzvDuyq/92hoQtdYz2mBfLy94EQLmingaW/VzZJWfQw7kbCz9HsZJhZ/PYIZAm7KJEnntzyj4iU9fI2lVBCsLdRHdSfoYmjI945pGXU3T0CmbX4hWx0iyyZLlx6QfuoO+++fbYjJExYxahR1UxhF3UpP5vz0+h//7Vm7X1+Q8+eOrqshdPn7m9TRXoS7hw6QfwHv0W2vjB8AQflJpa0oVjlPbhwGzDFK2G1Kkpu7UJpDvBnIB7eHwkRoe4suYOxZjkHkqGWW42kqmtzSKemGUGOO4G+yzOLBQGFomtJoZIG+Yn7i5NvIAk4j6RdO6ZLhGnqYktbdlEodUtyEYtDC0MqBLGQ0lIvkaqRCLB+AmVGF/FaHQ+Kb5ISUgg3SQemJ/aMkgV0V+9pcKBzguAr2jwU7yfHSM5nGLES9KpfBIIgM+oFBJI316dCQrEdDJv370b0hA+6wxMpIylVUMq3oMOrYdXAYAj9BqhdQqO0gajbvSK0AIjlHZqWFFOIGSnVGQUy5pEYM0+1cYiQCUtD4OaQaefeCQ7AW+8SN5VQjzqEnp7gHl3BSDe1ypIR0SYZNcIferYTgWbGA8ANSijLntjo6BRa8xIcyFJDSkaYEUDIBP9xVtmZpxlEhgM/AQLQmFvZEultihucywi27aCkBkFf0q9MA8PYGAe4aZWXeCb9pCu5TInrmCpIRSmSIUMSVDi8VMzYB7+3u/9Hpds5nL0/FbLXOZ8dsP/8nhl9RRPItc2qpTYH8nU5m2UplZoDdu+7NnWeAxlrGFArYO0LHCIkNzGgznoW0FkXE8LKGHASWR7RMu6ZdJANf1klpBmvKIsVCpFhtTB6bFpOFMjeOhiSE4Xwqg5Hh3s8TwtraxeDS+07LHbsZ/86LOvvvzq9PAlLUe7LS9s5IbIXWvYZyezp+H48y9+iZNsMWagaRInmcWpzd0Ug2+SXaaQCJCpQ/JlnLkZF0TXMjbDC7nb6xrILLY71uTDfne/DM8gJA8ODaCTFFDRqogpThffmzyVO4qeB5MuuSsP7Pio+Sf/jiDidvRa6zjfP7QM990Px9Y2nnDZ444jaDJ1fHFqhS41olWpAQ7fXBLmgo3jQzecbzzayHr1i3Pe47O9vdWVdSJk/zZBU2VK434zDYcx8cknn9AYFq2Z7zECr+owZ2T57PzImbsMd1SpmYOtrR2TFeqU+DH8zSVz7odP0Tv8Vj2rMVSt7N/z4e3wZGCBiqI5dyKVO3ZnV7Mh16kNU5ecMGZwzsgkYeFPM4Gm4aSdlvpjZ2synGZ+Xt7kFjOPVq99G+Y5+tQmm4lTtlrUBSFREC3OvBq/Kfaq1Devd7U1UyVqEFoEeAvLS1lUEPnHK+RZqLr+iD/wyDmmWJRqcuez0YnlQwYKJuVvhWvCPzv1HFhtMBdPpkdeiu8NIWHIcIWPqCpajjVhdrfi4koL028PINflE21/LCVyrdrNjlgmRBu1CGC+4qCtVYpwU67KcL7FqXUaAF+rstJntLrwExkgPSlI+TOaNm9gHdkF95N0NgZsFAADufgG8FPrk0sI8k5p4/+6d7PIqYkDJ4FkDWNkAtLTqDvs7Wuk5u0eYGKkynniurRQIa6zFwBmfSrGKbOfXSq5EJcum3BYXKUCo/y6jU4OIfimU45+yR2wRyQ6ox/LcBMvCSSdi4w86AQpIL6JB/wA3zEwSIgSpgqSCCIMRUwdn/t2ZQ6qoGr8AjAjjFL2hlC8GBKpmAIUB5zAsMXXB0aRmw6LVGolkhwBWZhcj3i5e0trFyBkMGtpPja8nzCbmUAwGMCy89VP3HBRlNEsTe38SN5/a/xpWIsrfIJYEcHPzBn0W9mmFx+qJDEsVjRwDRsfz9iP9LZe7N1VSQRrrI4CljWCoWI6yBqRjHr1oCXjsJ+erimB9CvVjZn2yPmkXOjFEHqZ0xYTWOjqZH9n2wXouXSdS2pklCVr0I8kp47RPmrUevSludnf+clPMMXxQV/96nPk2ZrG8jg5uj3lET+iSI83H28+ffaYu9ZeMy7rnEIzGj7gTEQI78xX2dlf54DCgGmRjzrOBEAzUMCjmMhTUja8B/D4UurXiCSRxXD2tk8K6C0GnhQ5RtwsLw1gWkQk1s1Oj8+Mms3TXq8cwzc+vn50enGcicGLy9vR+fU1l8Rrp/x9OZcme/2XrKSwRJWK5MY5OOQQH9OyzBXxQGoK1jpRVGRV/lZSOdUfpP2Y/H5kQFgloDkiPTy3NZo8u6LAlIaBgqnSrFbIPLYqGzM0u+OnyUMajc3GLFUiMPqOoeP1ajOdUqhxYmwLiXHDo8cboF2pqNQWVrnOAQ/Izvn1BfWPCXS3LYTGcFmNSunMTskTYZYyEHVccWOaG2zMGjMf3QtkxxN2ycKj+Piv7VvLMDy7fvV6y4Vy5kLqoCCe4Qwl1WNxHQ8m9NY6Cw2TaQUHPKfHas7ANd498zpZpnh5d3mTwU4M/6s0VZTbZG5waOFQpuoz7ZpIWSss5UJeiGCkk5Ab1JThXyijnXU87sGTl4rWnCXsBoh4T1j51nqDUJHFAPYAk1wWXTvCDalEHY9LhucA1J1PksAPCbSNBwa5iwfjgVk8AAFJCBuAFK50hYBH2tROTSv6Gk3RDyy+yRtQqqeyEYYXUu9O3Ek6SwklaeKouZgepYKbOGE5oQ8YtCBhEBCjeoQhaQ9JrysAwJKNUVl4gN1Lbek1qNCAC52pAPzepFm/iKV+KayhoTDJgR+p1AUCueIpOMAIU4ka7QOzwAh70I8efCE98hWPVDiFVV+XV3KFRUm0nt6hulN05mCTWgUri/g2qcMyHyARL4wYj3iMRT8MIOHMz7GMCeSrRQmI8aDB+YsK2GXs5LARJW+HxFgaDIkRt+YNRhiMvGQBs/5Cph7Ei2QGOoOXO3/24trNfNZuMgAdIaB0aMDRLLEvSTAqwQrrWHKTGnwOAdTnGBRndofkR5g8+gnGlQE/UvVwONDZyR0xNFc0S+yXjLHQY8RdBbFWgTmUWkCYR+UACPKbW8pFC7bKhRRbqVLqbOQMI210tFdzcvrKlqKxcZeM71ojdD785KMPITXJ+e2rV4x9R1AYq5hUtuPU6tQf/+QzlqBMWbiItIrG4BS8jlO16i20Yeu0LEpFs3k9IocMCy6VjmNDQj/Zn9hSBEeRjUynOZnqwDSpVJbiCYBMTJWUdFZHlzbvU9UFnrqKgMda6XMcN8HVwR4cHd+5od26rMkZe7rcEWB8YcrIBmLdEu2c0X5NPjNZmRnUsVp++f1rI2Or9b9/8wYD5Ws9u7U8Bv7IcQ0CQXLAXXhbVBkg2vJmX7EC6ooMiQxjkKxqDZ7oxXkLcsZHbS9Q5PRRrD3rI6dtubDxwwp0hloecw9GV865m2Zv5WAghm4UApIwRNZgZK31GDlZEUA0R6+nTy4MTnYwQXthYMjXOIuoaKFmSZDk7Gbb9fQZijQ5fn0+OLSoNnsRbrOwUhGc2+oWUvhXVpfW1x9Tf44KJ/yUnDLqH1rACPzQ1goX6RwdsbRkIcfb8rZTym43k9AYUc+8trHOP3R+PLS1mWDoGTV0bTkMrE6HcWrdoaLBrLo0WXqKCXQ5zAqzMSNnMzo0rLlgrpC33ggKw7wvoXB0pLQIwE9k90OnefDWT3Xq7Wck6u3Cep9Iiye1UGDe8JT8hBLsVV6NXTwYn+ABD0BewmLEtwYA35/EN7D4zlEAfHrTUsuwBYt/vH3AcTUKKWiRHd8AvgoAWFha6q+oh90bmBjE0aHSYit2o9gn4wAxwGh8WTYdlL7aPT4+0RsLcJLAHJVXN6WRJ9gAS7Wxuc7wgd+6WnNZnSPM+naUAGhSmx3AHpiLWnk1bSCFPYDFeIPsAHgPsUUzMCyGU+6AO141NXAzgawgnuBak+2ALTAgUc4gF+mnr9Yvi4Gn608BpYXZp+72iCYxFSMJ5FxAkc6adcAuPJQEKvIKSeNBErJThpQ9/cfVSKb1WCpKKokwGMDKVcAxTAQc3+9sl3eePWddfvXXv3i0/ggLqNfFzTXrV2gEilWjvR0aWSe5iTWZCHDCKCyCVbusqxSZZkSnReCIVyji5nATuRAzqRwITEDky9z2iFQ6YKEna0nIcX6TapEZhk9MGtsjj/avs+cyDx91azed5eHOIxvNUm1+Bi4CCTnUHdwDm4bqkGpJfvzpb3322acWsXz33XeOP8M0OTozx/QBmTs8PvDTFVmWtqDHvMO0+wKnXRW5poc4Hp76Wh08wyI2USzum1sLGTUulcXqRE9LS+4ZVFieixIeTFBKJdIzhRV1VWFLlEhPm9AhNTf0tg2oVMp/TQuaAqBq7Xg4PBpYFeiO+f3trRmTAMsrW652GbldWd8wU0B/UY+h/C5OEvSoFx0kJmKxQfvp8Qnz19nb2pGZMisUWwz0voBVH0r4Wh0C+PL7NyVsWZbudAlWv20BVjDu7B1Y4IMPucfYtgQbFmr5iiamjhTf/SYvHq9z7pM/sqSltIBpRVI5K4ebCD3C1ixe3N3YyKFp0adHZ6cuw0HPxTAqRYuwlg5ai6jtNWFUL00vmOw5Pj/EDGvts8Xk4vDuarCy8Hh4mrtXXzP2S+dgo58WR6yubGL36sban/w/P7fEa27WGjBtPOKk+VpgOji1qWVIVtWLerw6v5JQnTmcQ4CVYO42nW/snriXDCzn5rJEAnmanmLiko6aBUACFcpIx4nm+uxayB0ZVgWSK3BXtx9W2nvrwG5uDgCQE2/iEZ50UyoF23xDqhuNg6MeAOIBd8V1ciAdg5iw7u1p2OikN3zFEI/a8RZJ7L3hgUSmEIv3E7c9ybGSqHoIOzvxsvaAjBkuY4k7jYAHFpUNwlcZQEH0mz4x8iaXqJQemOxB+trWKCtDpCRi4ASJuWLgFIkOgWRut97BAVQK6S0SZvDCTaV4ab3VKEgEeOhKSDwK460kDZZ28hv9KpoBi0GbB2ZPZ9G0Nf3C6h6dkCiOnz0OwIEurBIVhYxxuijjDH9M4o2N5cydzk59+93X9spbTE3vG5bSyFDJER4FhEd5oW3KmwxkIw/rFEoYkRSrXHBJEmT4CR6Ax0+Pn97i0YMweB6+0tHCECqdgZTiCLdAQy4hoWGkGwQY/8L/7scfUw20P2v0/PRi0f2BS47PzHjfvnxl1F/zJm2sba4scd/RfCp3WrvqDh7DCaxCIYbX1ptC90YSXWO4wKGPDGBiUGLWzmIkxHftIMDjU5dFJSq4x54pmyapZpiRjX6RLTlOvWcimOKlTFx8v7v1ZknD4ERy2rO9tfX305989nf/4Pd/9lN2/yc//ORDp1qaXzVFSYlubb2GqtkFs4XFbkWHGWc0T9UUg5ek3N44de79d9/T5gwI6CbN3lsJ0h9PZs6C4uUSsYCaxkewycAWYIMJhi3vh2kSxVTdHmVUIx7lRYBU3OnOVIhtxEK2I8S5Ok74uWK5Dt0ZMDXGEj6YnxljgyijORBqxtoqW0nM3zxa33Bwmkn3R5tPVMfOmx1bAewUOx/eH2pk0afz4JCK8+xGZMj0dHCS7RovX777/EVW69eRLTu727TncZn8RAK8uygQJgk7EgaSZ49Lzl6tcaEaUR04RpDgVGqLcNSyRZOGFykqL3zlKK1Se1Qu9pJnwP40hxZgn9xMgCemMpxJbk8On7uxzvLyCuQELN3SqVUhLhZdlIRs891b3EmEZrN49OrF86effPwRavHTtD3idTYohxmR4LU4lUIFVf1agrRkfwMDzx96lEWFogcN4M0V8ZipHBjUi6EG4deQGqCFVvVJYtbTsqCsXB0d1ZrkopkTQzKpK2F+YwOxJ2byjUHAunKfM99TuW5ggCfDJi5N+x5urHaxlk8ijLWEb05YnyQftkj5G4zvY+aisHHCoA+DRDfWJMkInepFWegEDMQEYIovQLAVVqSvHoVFsIRFdhqdhIAF8n+n9Lt7Fz9xRGtBPS7AjoguSaSk1jMBFumtEHB59IFgUPn1119r2L6KxFZ8F/BJ9ihWZ6gRQ1xatpomkVBBKLvuqdCt5SsJYDYODAQLGCRV45mZoNfkiFQ0S4gpTa0YBIgUA39/gkd81F95yuQlCzAwewv7qrxNeWOQfG9v31elqE4+NqAxpmE1IwgM5DiOhia7z5NBITxSeSrHXDmruaJfLkqkpPBgjqxNwMoRSWIg6VTepLlJgsFPMACa4dqMUbCf7YKQCiTOeADIGmaTfhae2L6Gz0HFCK8nynVwaojdixc1bvg1dUJk6r5XdkKip4OWN5sUyhpOlaJcg/19bBcjjHjxuMqcp9MsPmG/WxGkotHWZfeWbf8ELsyFj138vHKBB6m0QDo2HCi1ZeVGcI7HvW7QbXEkjqlxdqvcjo8OyJBpa4ak1qqntdvrzZvzwblFkDNGIYeZddxX/wd7ewx5EwIKYo6XjqYEbUZDHm47OgLn+YK4hkyHKh0irS4/quGUCpJKAUdOztQNjcPf5REjuUIBFtBfK1HzJ0wr77+EXIL9mJbQBYYDd3H3oZ/+DFh4Mrbu5EhT3MdnVtXY9GKNqgWUtlDhPk25YLr+FjPiOrHEihH6enefIbyyuDI1Hj8qfB999PHW7muT83Y4awuaiSJDb/IWgIwc4PrlV782u85GoezUlIrLBiNq+uSY/8UxclOry66ysaNibpJRdScxa9oAVEEMOC6HDo69IkKKaYzCBjdG95yd2Hc9b7Zc46GvyYkrCqbtdrNOq1qxt76DXOEVvpE3xRc2EjKQjSfKsjEnzj5e/eXnX6wuT/y9P/iJunB6x9V5dA6VwUhhV8JjTpixZdmVeSDneuoGvvj8CwhNafhq6tU7YjniFibn3G299867KtR+44O68pfKp4H9GUgRIgvDFNYp4lihXdN20spRNWmnVmNZkOucpo0nT/b3jlfXV6zHOjs5pJ/AmC85txKX/E9mhTeeGI1LNby4W1lJE8YZYOiBDf9bTghDN3k6JDo3ax8iPQD0L3IHJtxyBafww+OnR0PT8aSwhUoMlkolAFJCmTYSVIXbfb96GehgqCkYRIIEz1Bjl/bPNEJP5yfQEH7KzCOAUHaM9MLyoI4EKj8uIOVka8s704lY7Ks5F9IMpZiKT61jB8y4IyxQOWacARXMfoqXnQB2KGTaVvm2VCSVpZ6aTdICYyaQb/aLn4CbHvFharFVvEB/EpCRsNzFC8ulH5FiOkxRqiS5yFFk85fcE2YJZYEGXLMvvcqeCpOwiNF4cgkcEwASuqy6igyAQk3NDXTXJUahxMil881Pm5OKsb6irZELaEbCwDydl5+eVjIMSyB9KgQaiPLFIEMZRaAFLOtmTe9t74g3nuXaNj9ywaFr1zYtXEdw04AUh+2vFDfjVhXPzGcXmPXyRgMXuSbFyBd7rZXP3lmdDtXRxGCRyRxjFprRZYPc96pPGAF0TVXxDdeN0sHiJzYriq8Kbm5DAHvRplwQAmNRCovHUm9hx42aMae594937XUE4zs3CnA2lEWfJkJddGiztY2mHAhWoYwtjpwgZnJyd3/3yCwwDVc3eTn8YGl2nlNFkZ09ZqqK8cjCcnIZ1o27B0dHUj4660zcDMvoR1Vq+yL9NDLULG6z+ETNz87jmxUCql9Vam/EgwogSyjPes/JiZHq/SksVdd9CUgHIKHd9CImkFQKxVdb4ylrtZSz4+4ul+yCPhvkJDtXmS0tjlltNDllH5i7zJ48e2FtyavvvkeqTF0hgCfD028MGcwRmzuwkISBpKnhHjvRLI4+8/DowG5zPSIA5qQd9cwXXAcJTLetcWl8nN1mx7nf9Mc6VPrB0Hhj/dHI1OT+yQFtYWiLH0w49p6K6GrCHJIgLOCBUBuZmV0ke/t7O4f7B082N4no1uvvgcGo4PSv2dbaU261/W0msQZn13eumn+kOR/tvpyam9FHglfM6/OIB42ppLV53sa+Cyuj0M87ZXcWsaKpMQ7nY8ia3K2boFgXZFIqB0D9219+roy+giFY6hH3UIstI9nPf3pzN24sr6d17j+BeTLzmA+NLdbaAKRI62XFWC5FXSGJoags6t2DIdZKjI9dnZ2Y1x9ZW4ubRXvXJRl/oGHghp8JPqIVCbnp2GNwSu7dRQMDj1Q42e8IUj0RG3MN1Uwolm4y2k7rENL7wPxOovhgGpuSmgoQhkmRAZTRkCWzWrSJFvn6lCVW4V2pPK1dlPw8cMlGQH5dxcLyo6K8wfvpDR6YNzax7LQE73vUtSgVDEIBwCOMDpilpa6FxQCun9GDPhkdq7AuhmOWAWAWwVIe8J2pNxokpKB1bpArp+JJriy0sEgxYEB2vmBg8IDp+EblJzyNTUB24mXkAext7ouN73ARNNC6dAHzXyoWBZwiCavDYzEBAb4yvWHzszMC0/hpDeabWhRPR2OUYgKTIxiZestOwCNr9OObsEgIPSA9He5K8rORgxTuoQmcqMIEAbQJIGxz/ZHV39S6OpteXeMwpk0cwDa9n06CpqAdGN0ffPCRwwHsArJEW9YcLag1epApDziyHMEmI5PDvMOKYKOGEbTHYFZdWOotU9KLKo0QpKfL1UVDp+G8SKMBDUpV2BmriFKpZWtoeVGMm3lnr+4ym88WxgoHfWqdxERVcsLoAI7crWg+wDFe7mNmxNn0eef8NYej8ZoMOFxwy4mnBpy6IEcWM3n0Tyi0KIi6VI8sWZyJTfp2OJjyVqeLEjwh8wJtstG4VfvInDy5iy2igAij06XyU7yYlKSsPxa2n9kUPDGCKDurJpmNJj6yukpNWw3pnvRsbrgaubY5OW7zC8d6ns/MLylyRjaO0LcDtZqaW1XQ8+svPl+YXzF7b8imc3Xyh8p1wMDOwb6ZjW+/eWmaFBhuK6ZrEgw+UOhxWMvq2ro64lHf3tvmS3n+7Am1hea5+QX2spkGkyL77nYd5K7EHBKQs1Sj4/a2t3gtQNo6B5Wh54ht4PxXOmybKxzbZVXYpAFulhtpdKZbzRlJaA7Jzt6njx4RDU0SYR5+Pl4FF6ezK/i4zHr7NW3eYH3dEVV6KfVC0rCR54gaOb/aO7/MER0GGwRMH8Uphxo7P/Qx+g/cJkvAWRhqk/FxfHakEuk0FvrhzgEkuHGUu6LPjW7R4KuC0Nuk3Q7EAE/PL6+uCeixlAgB6m5tdc3ZJm4UKKfD2azdcTNz56eHFmrRkSWtBjFMoDNnqyg7nETFhg/EYLWfmEBcfdKnGn1qR34iWIwsZNcZdbvwCXyXJcV/2xkItGg1tk4FlVoWL5c0z7JovaGC09OokEEKQT6AwU8IgYnBIhpbGM6s5WikpYLyGWjnAV19ittafJfBV49PD4GHXJElexqzAxiK6TDIAltFkhLAZIKupBMpQXKMGjD3yMtRAFh2IA18AEglry4MVHiNdGnlRXOB5DcEgG+0A2b6SrE3BjH4UHUPIWs0nZxPHknk249ImXaMwsKM+11bWgtmlQPHeomTrW1dHUVE7HKkOPIgR6ExK8jmJ7FTHPT7BCd5JcWokim0RWpalFx606jcxfcnX/1EVQM/fPIVwu4C0kTqqUT33SH8OExVSWjOfHPNafArfioFXjFIHcvD2Bg5Y9657X1+f3vbAWqrq5Paqu5Yt6Rebmyxt1P/qrpt6wIJsVFDJOmOvCNG5T6ZfeymYkf5ql8E6LYASGs0qPjpGG+ztRiBfhVn0sXSwqLwP6v1a4LE2dD81urg5PRsvi7nYUxp8BoMY4FLamTcku1pCzs3391k0pq3NIuIaQRGJOlNv+lk/Inxk9NjOaoRfNP87aKgEczKqIXlhSXdAisXteiRNWfIpc7GqS463Gt9OffXhPWR9gFY0IdEzA1MhvMTwymnIMSvrV7UJlQ5JqgGQ25px17UMvGydSJVlVc/OkIKP7YXIz/eY1JnVBcx42CJVGysgzCCMUEdx8+dXWDnRiYWUI7ejA0Odydm+GQuZ+aWgDlLzJyyM7139w7MWNiGsrezneOXr28d1bq6vmFMYxLbeX+f/ugTznSu/xfPnukbnOu3dEMPzvEoHxycWHwTn8nbgTJOzirj8IIAOGjNfACv+srKWs5HsiTz5MjMuLJpvoa5pIJoseW5EHm1yFLmu+/if1ccg7vI84iFWDlII6uMrjJdlCEpO2l+hgCYGM4CYLe9X5w6vmvFet75OWcEmUcx3qIYnHWzOLsSB93UFpzaFKp4rvzRrvE1jU9ljmdj9dsaDHFHWR5Fm1tRJnfCZkWA07HaaiF19K8OgBhEnJyYE/sv9WsgeK68F8ODo9N0gUsrT54+X1xeMkFiWerTF+8sLM+7Q0Jl4dDZwDxE1l04lDAcmza7MH+Zqz/lnAZOqISNtr274XczVOk+mSbndzXIQIx+DlUEyScEdwOBQeP19gkGj3y9wVi9KAzSg3iRAiQTsKc/CUjeGFLSQi4SNrmLFwlS3dUdaJmc8EkkdqVHgjc5vX0kaLpFSPPw+Amddi4l7E0fYAEPXUMOdLnVbKKJwEjbJREAKSM/IcdDYGC6VMIIAtAloVLBkBsxYKQFrwX6GYrf2uYokS9ipEUbVIB9lUX35BKK6VJ4e2gxGERKIjnplFxe0uKaRxI0wOCNKiWSNWlWnc0TSWh/xZRQXmoUYbDJsbOGVichYT/gpYUKEu/OBQBskEgiI8kfHiXySTxqvcPZt0/DPMALNEmKI4AS7DX2B9YFESmAje88f0H7U9wUl0ib7iQxXaFoak0ueMJkAzA3v+TWjmaCAnqwAsJGpSNAi70e8VyWnUWAJYeHtgWjsADAw+Bp5otBWJNNC8sryjCxzlOML4J72oNLkvOfGPPaoUnUolite1leYjULWJCF/EyO0XO2y87PW7YR0a3Nw/ozn2ht8mIFiKMfBSREmxKZFfSvPOUeOfgN3lY3EMlUEFXWlS4gBlUql9oS8lURcAMe5WIQME26XCIFlBcHuo5+821M45O0nuKkokxwOnGQuumdZ4M5b6uaRUj2B+gGpt1qZfrMDPvxrpMLHQZYp4Webq4vm4V2SCuninLZ62CVqhw3NjY1CMzSAvTF7777LrvKMBSRpJqkeavZJsl+AqzI0K3u4RCJJ0pEJ9KYWMg4MUjCOm5Dh3AQUcmxC3w3ii4mzlg4kKmC2nslUqeiIpdWltWamRv7vKVyc6SyCXfXayYfHtWE/c5nNA5wg7R6N6T2Jqi+QqX5Ix7D07nE9RLPoRhMVvOueCQ8vqkpwOjXseKDfeB8ZUxDVaNcOIBIPiuCTd6aeBhMYCgpmeDmwmXml75HRweARGmkMiEk6IEEBsXhD8JLANolMrQpeOQuxk8SAj7WxsmJgkSGa9EjEUIVGNxukpRCqhSimkMhTOkElMI7BSw1KFJaeCRBg6/eYiQXIEghrA2tEirxEnpgaFRgUKVEwITFdy7CAiKBeUuYeS0p/ZAfrS7sGwqAqjYQHRYAgAjxAATE9yPtQyrlV4viwUiCCBNBWKYkYnxFirQoi7qZc4hpboGXpGnFNc2jScxbY65jTqXyIKBzBA9JN2kCLSOYW8hQIjtfwTdVyPPT05QjQzzkCt4wAJDnLVKMd8N3cmhFKojsSifQBbGC+dGgkpesTdCRA5v14XH+nYQwdFWBQTYYnltkg4fNp+7kQlItlheQpBN2GY2R/fTA0PQ0bYplPF4idNtbacBAuOxyvsIsuRxpdj+FOUAQ72RPuZ/UPFIyurlleu3vHdAcOAyDlqMBv/z22xdPn5AX4ict+YbKI4llUEYuIzYxHR2RRzy3tgLOZlocPmFqTCFjAUkklwpAnmFcZM1nTga1XGfNsGvDmdqFGy3Z9hmb79pZF7zwjtS/vXSvn+phJqd+HeJ2Yw+A3cFXjrLgviDzxoesSCeU0K/4EIR8JroQM2a1oPZ6aL3sXeyJERMVziedU6CpufQH4X/dus7yxYTTixNvLFe6cNsNl6VN9D+zJVQKpWdSTg8Yqhs0SHhk522A1vWV4nOrp07T5LuTF+GHpmPEuG6zRZ0jRiSy8fncmMBBNJw/Wp9dVHeMFLu7XORuMaalDBdTLI95eVlzy9nlTjeLegmhmW7OrWbv9put58+fnjmdbXLKbmeDAHYNobC5YHvnjcON8cfMas79dC68Xcg1weZIZc7J7e1dyEvOLw3v8Cba34E5GbY4N87oxJmYSjkxubDMlW9y23mXHpWYXOx9LlmFGVqqcHA8yGbjkRFhvSyBhBU+tN2oEndFjNzYmejsI1oHzLtP5vXfq642upl4s72NLVrTOVvOxWRu7pvOBEyfOs7WwV5OHt2CVZsqwjZpkU5vUvtO2VTXOCMT1aRhd6Nj7uludb60iuRWVTGyztLWkztzhfY3FuzDRIno9d0ep386GwUt3w56dHSOwWNCGYQZ/0vsod+9CbDCHh6eUH7r761yU2AOtcTb3jBYJ6Dza1FRFzDjufaBdYC9fWo8wr6GA4P4SPQufsIvXqGEIzYlhHBGKgo5gEbeyaFqeMjF+2o6SVr7AMSQGQsHglSURwBGTyf2WcCDCGEJZKOURCSMqNI2gISIoAHVgY63SelPwMA3icDgEQOVMgNTW7S/GDrIJwCNVqSfnBgCYKASTxwlkYvkYgBweRdVafYeyZtURVAlSiSy1Td44WrVcXbL3VcK3SPJb3JQPMxoxnR+G65/MBISX/EC6agsQYyFrj93M9xpA4tRSWan9Q0yxVmU4xgKVZXcQXZlKwJUyoJIMR3ugqNTTFVC9ItUkiPPV29hKgnBHsnVmPhOLuHu/h6pff78Hfn6KjkojUgq62GMoJ0sFke/fXbzTnAcLK8sLS0vTnO2XLtZYmZp1caGmUcbG69evlSJbg3TWmQKM3Yh3kpSmCmwlPT4WIy7nGh8X+WbexWJ76gdQBEb2YlXFmEPGtSOtwiciUqKPR7Rsp6S85ouyP7KMn1ZuDndRTuensRtzNSeFZPiIGDQYDiFhUtUAwCOFHzwU1uVqaMv5heWZCqMHuc5EzoZwcncwxmcc4aCHktxnB+EUYAVSjV56wjRJgZci64Rr5oV4+xJZx2xzMVTFh59jzZoiKB+AKgfbxSix0MFQ4gwBcdJjYTL3inftC9nOtaAwRYeFaSqHQjtn7LLb3pqbG5qdGl28vZ8cHN+fObCr4vTA6sUD49N6TCXVMz7H35kpLC3v7NsFaFrDg0Zjo7l9fLl9/pqB9dw2luOSGmafvQJzSYm9nd2lUXDwRAndyIqo4qdbUeBLC/OOqPYLoHVlQW8euf5848++kBlpXJdaenoKiybmrb9grPFPI0ScdYZrlHbYxPTulzTv/ZkKBTplt3iyiLFqrfGT6fzkxc9Iuvb8RXMcJGaGOZjl9EbwXDMkTaFQncfmClVHR78YYUSH0uTnUYlBgbjpyzGzXH8Q1NKGoLs3GJGPLqJffXrb5DHvamGXZFmKZQGozUx9h2yaw7G+RDHB4qfc+AtZjVDbg+EZRCXNyPdAag47NJT6LttH85oLx23FUcOh8ezO0tyNa+sprMhjgrO2ugr0zJPnmxqdFqQuoDqnXdeoE2Y/0fAlj1FIJDBX8o64liyF8Gsp6VCQfohUcqFUX763hIlUPIWnUy6hMV38g6I0XCkgk08GE8Yyr6olpjqqNYdQ5bQ+ux3He1EjC30ya286LZRNTaLoXSmW2dxEGrxGo82CZcMLElMeooku1euRybTAEQYFsnGemFPXMnlu5eQPqPnkDV0JPeURWhLRklavRi+UpONrqm10XYxd6LOMMasNjeskFdYWJ0h/LYtHjnnb2z0zU6MBWeVOK/Gd6s3bFVjF5yeX/CEwowRMzXxiBUa4fJiqlMk+cNPssX9Q8VYvYpmK2gpYU0SYe4VkCkHrj2lGE2adULaj3J5DvePFuYz3qQ3js6PsGV9fSXwWcF27sSuCPfoGCPZEWnWsdUsWthi+z4wizEpaD8x08lcKTstVsMjiiNtbGivPGUaZlorgmAwHqNR+wFgEO8HteQ4FXVBIpUFl7MvZ/zWepiL0wlr4U2QEjbstenKipeX33xDaa4urRqAq/mTwcnKustFD+uYict9FybX4neqk9lLVBj6CqseTYhhgkXfatPEZqQl895XrDO9k3birCF20slVMXb87nTEyMlhA1m/yA+gK8cZyp6yQzzm2PDtFF6OELKtBo0vTCqs5AqO9Z2DQwsTXfzLV+IcGjQYqOtu7dWV0Ok9BivG5jiALVMjdo0uO9SeU8swa3p27nBrS02hUDfGF0TkaRa09NSRQvEAWIDocGBHj+n8qJK2GGgZ8qmDt4+VaiPOGfm41WBuQS1N2xIxnX1/g+Epo8gKbppADzo8OzJRakOfrcUWxLlQAHC3Q296JPzRcByuUKYDL7kZHBuv0j1zhLP2yRwhyDPi1posyrEicni6RApnF08uR3assHj8wf7ZlaHL0uZT+NmNDGlbnk7OjnVAYmzcVWoBYqGmOMcHJ0PXaTHtTbqY2x8cHVKitq9kBt7s++SYUzc21pefPVodHO4scHWuzu1ufT87N28d09HRvssjSTMK2foO54DWNgb3Lta+t2vbpm0fszHj4PhkffOxfo1pe+YclFHsdAkJ6+eKpDFbVBSu2rHB9X/ljNsZynDSsfuuylA+fj7LgJ3rNz/zg8vhwcLsEg6vrS++nt21qJfw6MO4rJmcVjW5/4Ah7z7Tjz54T0u0UYFyMGxyyJMehYypLNPFGjg3oDWpnt/+yWeDP/rXX3+7pSyWVF3dDt9s7arihfWlTPPyI07N/uAHH1uve3x6aXqeGnny7PGrl683Hj8aDo6spd59c7i2vKYJWHTkqrDx3HfJ6MktPNyQOiRb+yzzpVqzwHrszICU7JlC+cu//NKBUhSpYSvPkVkrRGrxfJiZ2NB71OgRo0i4fQZclhpM1Cj7wyGJVqlmOQx/1NCCIq2GfBjChWeT1sVwYRlmZN0N5Z+2f8VHwhsc1R/Bqa0A+kB4XAhh3o/20AvSFeVozU5+/tX0JJ7o9RhuebxlFt1dowa5RqpMndcZUTpC8SRbpH4CfIfpU4FovSIUvJ8VE2M/Gqr6c/GN0E8PQsFAJXdSW807871i/ITK02BI9wCTRCSRAiYt9dQ0dE9Lv4CRxFfGuOwQ1sR0ch5S7eTeV1grHCBh6bD30znVeKqyzctPeFCFp0hqDPDjuJ8emMHIGrAyopnK81Zkb3UABnzKxYStmc/WgMJSMUXh9wBuVA9Zd7mY6o2/2Qub5AhWQGxOXlfqLnMYe1v7jn8hVAw623XYNWbnmPwGbNqbXUWGz06JsRbCVnbL45ldydjZCIaidKI7Xhbm4LdwngrQCN0YuPn4KXqwsSn3lWmPVBJqahhK4aWFZc5oik5LsAJHQMemcUbI9E1skDHHbMTXR53CgIc2QBExJ9g4H5NLxuV+7GfzpVwSQ35x93uMT2ab6OBk1tIlY/+zgRlgYwUFt24outKc4TBSvrqyaJ9n5jPm5588emSmHgwLF/+xwq5fhxc5iaFlRr37qkROvuuaVS7WqDDmY4aAhNzOJOH4YIDnrCisdu7vSYrm/IYDxjtswoomCQz6bosOaTXcqPmOe7lV72JCScVKIkYW9D++80DQC2KSYw3tfVJYPDXQ44uYm5rHq6O97dObsamJBYphxakP+JbrWRzoPGlL9Ybb5L/88tyFRcs2ytyQFjfJmBDGEBcNbz5+ApV8dTiGuptrq4cng1hiN+mfCAC7wMU9+npZ68xc/vPi2dPjwan524whGB85JmTCCMDaULqJLbO0usIYsV/BQY05GYJZMWcL7nD98TPL+o0Pbm8Mq45VM83KOyQ32mRZI021qeUJtoK1AtQLGvSXaJCLfSH2IU5RpePhGNMeZ3Cet4q1oRbM6ohHp0pk7PMdYY71JMTb6TyHx/q2Zeud6DGrvAyVXETDQWprgg0zmoyKcIbr6vyCJZ4WCIwdYpW7ChhYzpxzqdDk2PQC0ZqN2iQLztxmz7oXvrals58YYjcjBj8LFnS5o3Fu/nB/Z3ZCuZb2Dg4jvTwH1s458cPUwM2gZIwbdo5ZgE6WqxXX77//9Oj4gNVlsKRo4p0RpUVIS6JwR6o0ydIGCEaGfNk9xNNPYcLW9PkpCYBO66e0HoEMScsdEpp1Cy2R5dyjxGgVbGzmw0AZhqdAvfuRgEb3xrXOwFdPaqvXyZRGlgYAOW46GkYqYMIECq3CwVb4kQKytXZKXo4O+FET+AIDKYlHjHiBLoB4STziJYmZX9PLkIDh8AWgOn0lHAopFwh1vJxI+AUVSAGRwlo1VFhASfEPaMadV2cHiUfYIwBzOcPjVddDNPf7kyoUkBY2b8j9VJ0gZeeJ0i//Emo7Sas/aAE3DPQd9gbmk/hkimlVRoHOxRsADDrSBsZdTBa2ygkNwtLSRJD4ibXS4pXydkG80UkCcgayu1vrkVyhtDf6Xip1aoEFZnZ/w7hQTGEGsiXcSlReGu6e69OzE/SoRjn6ankGAsTkcXuqc5jLt56ClCAqh2UcLe4i5cvOzbvCJTKYrPulEDKQ1GEY4VEf1AmdZYE9RXt8NKBnmTm8kDYiGbdlCXb8L5pqblsTw7us1CpXGe0eQpUCGumnaqAvJsupKU2XX20JGYqvf8FnrnmOGnUnnWWfEqtbVptPpCs+hGwIjyw1/VgEuXDj9O5CCSg7Apr/AGDw4I8HftwWKeAtd008AoOluTbNLgxuNPrj0oLy+eWl43N75RjuTvphZOVwb/Ys/fj83Xf00LwT2GIQcGRPxDD3vgah6knvztGT+Ty6S7/hwAaOYP3+m+0ti091rgbKukz3CSsayl0+7IIyK2HWl5e23nxvG5x4rKBHmeRLyy4BzVpJTKabdEUw806978r18WkbTvjbCDHNFN9CKj/n32nNLFZXHxnjx9RYnNt3loO9tbmONy44XILHxWvGk/iJcoxSxtudHI6bT8sLWiK2eIKqOoPokzHjy6w+Aka27RMUWPjAeq65wcnRwuLy1ps9yXEDk+XCaUbR+7m/fzI9y6yevhu/sgiMyBnS6bMMjeYWllz4apRg/p27oxrKFAE8NfA2kHeSiinfPSfjjukCVTsZx7dUaDbZRPsh3lIZ2cGjNVHu7pYnqOKZ+8qbc4WywD8igzCPSO+G6XD/lCGGiEFzSxTmKDgTFmG4pyLCh7cPMMAPaOWIYySNO1Wkn9CCQZu8YIia6wQ+Q914xDSogAQt0GKQkvZWrfohlSTCSPEIeEACk43KkASAsBgAAhCSJ2DwdKYCCEKNd+clnMZQ2gE2wCA7axg0b+9IXvkoAQgb90nioctkIVIYWFMl0HQqoyrxUyOhL2CW1rvlDIxMpfXuTDujaIoaHIjETT+bVNxHlTIi2Ce8Fu+RqiG7+CiRXCrxknggQedDdp2jnzCgEP0AYJBcWvGdFmaQvvoksosJszCcYBTNshOcVSgYNAMYBKBlEQPLuVQ3ARYJmIpnTBlKWHDjFJ133nsPZrIlU0lUE0icEZAWYU2eN67CoDhZjmI+uCaEAVA7ohEpTAnMOW7t/pQ9EwYZHeaSTj6Ii6wB47Gh6FiSEEIlI9npaCHXPURrXxlkxpdoSau0OqiQ6ihmyEdGDQ9IsTMk3P+1vrTCHeyTA3+MRe5yo6FFpLn6jrxKC7OiobuLgFf4pu6akwj2iEkupToxQdiDKlySCgcwU6P106OA0mICaqUV7qdTPYSl6qfjH96V4X1VAgYDoYcbgVsZ/01XutvPFikcdG2lw9UuBwez4zfLM5Nu3nL7KQGmy7jjzXmg3GCfkW4jKyJ96mtpKfe3455b7nX9IfdDVi9fOifgAE+ePHvqEIu9g32nwulCbCBwdzQCdAxxHsane82ZrrI8iMQNrU+pjcIUoftg9wkbhkqOq4qgL2L+q2LrSGuYaL2TvvxcR4S3WkpJbO43bc4Ur9KhCmi4PNA8TkrhwQd5YVoxOUsAVAMJt/QDfFelr/ohkAwRBVerfWFDTTsfrW9uIFJzkBeCJYGK/LF2iLNOyngmvrhq+L4qAlT2xHMj+1kT+TEXiArJ1KAYfRTiXHxpOZ1N7gb5UkHr6RKJBK+BE12Fki9Rt/ZawYUxAby3cJe6m1LnInePeF/BQ+JrkwctbD4pJgyebjIYBQC1AHyVvAUbBo8kvqqXdIp1nJeq9BO12ubffJb+4fFZSsk8cAkj11cESSwQCSgNLh6izriLJyzgwXQkIugBD1QNyTyHx08ZwdBJGgzajhQvAA9IhAo0QBPWSWDgHOCOoGh0lSwRawonJ8zdj9v64ZB0bnRuROvVDEBpE451dUbue1IX+2TX/OqSNlWQi/c0AQqoIGoCfIujfJtX4LFVfaiDTiWJIgvLxdun5pt4CJUC/f00vDds8IhEAzAxXWoxwh6Zyl1yeWXK0TxY9SjiW7Ilxy54ZOeThLHmxpldpxB6YFYKZYenf0bBjE/YT0SsNSdJlPH8JKNXuT8kQbx8H6QKmK9iPIiFVlXSlciwApWI6OHlom9Se9IiCR/ManDaNOZOHpqKISIhqaoOvEdecqGorZGRE4PUQQCKbFBuebheIUta9/aNollrDqfUE9gqpKd6tLlpEz9IB/qLNDxnB2pJzsG2UIgnDM2yM3VR+DPyQxsKUaJYtAA/LFK5ubhY2Dl0nbJqZTwJ5lh0K7YyBZ5a5P7KSfi2215lY6wpAz4C0yokT0lro5M354ESKWAK/7ZdoNCfeDFIUomqRkBhaWZrW1GlQpPA7GrZFi6H5naeuh3OjlzMmSG6cNf0AbId5MC65G42s2zyQ/O2FH5tdcOMCGmH50EySQWcmrIRFreJiSgVR/Wbg+caN3lL1XHu829wC6jb1cWFva3veQU363h91KKwhRnf6DX9ikYkR9WNEgHvpcVlAq5vaHnGSmzHcAtvZCp/M97ms+xPhrCbEnkgutw8lnLFOLFIybU1tZjSJ/Nzzs7DCHJLWaJBE5A1AlJ89wi/PRwMVeDVLG4Te/BkklHoOHSP+OaztFJh7Vx0X4ah+nI/6SFbwoFxN3ET6UrtHvNdQWS6f3hoChCY83BxUgeTKSi7+xxK4mrfSWa/ORJdYFyIAatl2d76mkyOLy7t7u5FoeWyEDcQxAEAjCx5ZApSGYmJ+EhCGSICHgB41TpWuD/JBTZc8iYhrR4b2CcP5PgAcyMXQxhAalYtCZjjkTymuqfhYPdUqntrSFhib9hBI0UYak/yqZw64xZZyf30tbkgSz+B+dpJ/Oy670AT0am68HKR1tdmkLfCqzwFkBAMdaPW/fQ2z04KMQJ+edUKkwCIkR0Y1ErlgbZxNiUAoAUvHmRnig8oaXiBZgvmwkzgmoMQ4qCvItEGGElKIYBISToXkXA22i54f5WQaModJAzAkAHA0/AdFt8897Pz6rKAaZ43kQgA1mSIF4ZWWqm8UYIw7VO8R1o0COCbT0rRkYOjYyMa/YoxO4WBKhSCBCCtgCYHGzLStNORRG5wFA2sJxXuCzCReOUB45NyweMRQCFsKATWWQvruf0U0D0jWyeoK0nTHQyXF1doeRycHGOajfAy2X5FaTqLhmZHqq7L6Q5GAAY0rH5LYC3uYwa+eP7chP/s5JRrx/3Z7m/FG/rljipjIKTKsbmk+MqDHhR6++mrgAcTwCsRtnskVy7xTBJpheEEjC3ECUAlisR6xHs6RiD5VjU1fjH9856lBQAYVVBJRy27Z4qm4MSnlyMqYyOP1tyifrE4NXJ+uHNzdvhobck0tVWwln5ZisrRYSjgZFLqnAPoaJA1S8enZ1bRO3Tailht2GFrVhaYwkWtCQYZURHqd//ocHf/kPr/1ZdfMmlbP/LIu8NeV7g46xTbQx2hP7KE5kN3AJQQMu2xRXg1B1E4U2+aBWC9b07zxyWq37oXut/MrzUOWW7k0G/3xRNLaIgxlZJ+V/+ItsODYzPf6kB9WORLgmE2VFW/ZIke5/bBQN2Dnz6ZxYFFDL41h5kPGmlXJQD+saPjQZYV7e/bncDEwRO9VATtreeZiZEeR2+OthIACQ1mVUUbUpBjmvpTUtmZYSLP8eDxSLoP6tKUWHw5EKo7M+RSWRimx8MQdEoFHsP1qZxsqhJCeAiAgFRhROklyYlcCliD7C5RxGgk7qaGRKGAOJjVBQxiZNHY/JQcgEgPPI1EGAD8vhYBWefWkeLlnm6zngguILE50KT0hWQaSCiuTgl2eUssgNxQYL6qYqTqXEUKdzHEYIQqgUcSvBDTj3BjazYJy90n+bKX/BSGR8JUSR2dRjShFQ8SzkCWvwV/FbVL2xk98FRCYJIouYCEwTwySQ781HmcjBz1V5+acngkp2VwVliO8vLun1IJI0wko7K1nkgBxICnF2L+1SDAgFTxg60ekfLyiJEdUoVFQsWt2PRDggxEBri6WEmBARYPRkGMN3Q3kKDO/IdPPPrcPUsLK9ZK8e1muqovnqzz1OBPruW+YKBQnVHoDuytLdYM5+7wgWAXAlS+NX8727vIILUoURBCE2u3Ojl1lxZTjzGe9i3IGspi/Ko4K6xlGlRU5EiuZFKZqok0D46PGYIKpTjeSgQsLcgKcyv5M0CMO256JuvKdVQAqP4pJxuzvdhclqOPTY5O5jw+g3iJXEZsm/jC6iI3hSHC5sraq1P3ys5Dwik1NZGrz/kf/OxlFRN3MYvsHEKAlip3vPJVk9bUPcqCeNVtkoOjwA2Y2ceb5Q+4mzXp6ASTJFWV3pCgU//kbfQQ/HKFNe0gmtYvX03Wp25KfqRKTAk5eAX3+IlM4438O54ux7LJiAdF6ZjrpVjSO/vHfM7zS6vXI9e7JxeD86zQ/eEnn+gqnJq5tLimj0v93t66VowocvKbTkcwg/jkbOhedAdWMWDjhCZaKJ0Y3z+w1lNLMdU9ZQhFDPYPdilrc7iy5vfnQlFjqtiIxBQ+b6HaNDjIuq9SFHTkwpK1Lg7Tnjo9fJ12UfflsVHHZ9znbJba2qihs+0yoWJgFAXjjvj0pjiiCDJNI6XdciwVVtAGDDitKXpJV7c0925a9+U4ZG5wAxP+VGutxsudnf1uVLBDM3VsPlH6zpS2lsk99YDdr4YPRjm4bmnAwf6J2U7Voa6JtLKX0WLOn2k/bRrArgNl96jx1XXHXFvqdm2aRbvjg3IzkZ0MqL3O3Bn/17XV7qncHFcVGTDTxi3m5jRth5QhTDdGz5tbRvC91JUGUFhKFxnqWtpoAH6L1Mfk9WiafApevpPGHKaVXShjFfFg4ZGaRuuNkv5JOIVhUBAB8FJJTkhKmcxFan/zifDV0yh8UjdqFNGwIE484oS9O6E8AAjLGHHixXQqkbKR1qOaASgnIoDJxE/xKXD9hFmMn54HnAAgVH8K0Flgk+wk8SgM4XggRm8pJn1+nRVBc8mLHoEQBnjgVxMePz1QQeInN4ivwPwU8G6csHV26FEQb2RL2OzzCXky9VNGXSIwCgInJDot2DxiICy+xrr0iIEcPR2paGJA+oRF0IpHjwBOevoTnFJ12NdGIq0wnnQSWkZb9UDeC3gAIBXZqJKkFv6kXLABS2fC1q7lUmDkyKMgiaGVjPxUtHZ5S9uNBFeo7pTAoQX1wAyMLOK5fCWEHFs8fsqrIzHH09JSxRwfnJzZqS87j3iRkoDnS1IpIs3lMu0lZ/hH1mtikU2OGIqAXwa/8IeepVK/+vLXBgTmA9wAbm8XO9TEgPIihvmf4jgyiHrKZZMhUtgnVYMP8sIHaPsRVjJvAB6RqiapJqKUAePVQ6WjGTb8B+ZT8wQw+9XbT+/+2hwAJqYzEu/peAHFkR0kyASANve35QQCgnl9MTN2M3p9vvfm5dnR3tL8jNtj1IjFDuBVgRly/J9fWrYqejA848XWDfBVMYc/+uEPDYqcoqq9kNZ3X7yzsp6ljbkleHrmxXvvfvjhh5qYMmolatYo26XKzkXgytcR7O/v0l/4z1Qzf7Czs2W12Ldff6NoBgc4byUTvz87TjXpIbh7GBnWILGJed+uLi0StdDI0qCJ2ogztAYMzVQfNuaY5LFxV7WbVmBWi7TgkCRYo2FgB6289N8ZUExNWbmo1nBbeTEKG4mEvLBOEuwiq1YEgfFoCCC1Amxh9vkqU3XdHmB6tQR4xJ2jWE1OlB0SPRmJEqN0BAAxkLRkPnryOGXlxvGP9cgzcwZurPCI0KQppwgASpg3xj8Up1XohOSzzz75q198QxH5Cg+0YEJ5NRM/UUUAfBUQGWz3MyUZoSppE6xE6oj4tXDCgAOK1qpVQslhE//wwAkzJN2RqF/c8BNVe3u5pje6ySOlWAHYZePdacQjxQOLbABADQAFHmEYkasWAUiFPmGk+MlMQ42chMUDE/CTJOGvtGIUAGXwC3vAQ/tAq4wQoHU1bX5CrsCY2Ahhi3FazhxIAHh8FZaLwMNPWaNKplBJIl836iEepEiZAhYAT2sLy8UjazxSAVLJOorm7Rl+gPs89B5PQAi/B7A3eEgEgCmX3GXkJ4QNKUcxwmiQRLyySNIlFe/BB9n5JKGwjGAD4I0SOIUFoMIllAujFrxqIqmWu5kSlLb7IdXXVClX5wihtOAxsBklO2nxlvXUuXh7kApSchn56i0SsL1LFvwYu3cqYIqQobEhug2rmRCOqIj0SQubLx+6ssS3WxPvXXyWfexTM27mAK8jcvDbvqTFu5GYU4iVpP+CTbwBwfabbaRo7o540w2wquxZdb67A+CIlI2sCHr6+IlRDsKat2oBJZJ7FEFrp1Ycw+A6Kna91oev/vSJvNZxb+lgMnN47TwcBMvaaAaSKEHLybPmku2nOWBwpN0jYBqBwYgzcpEF7SkgX1WDyZxsFnoqHQYqPnhdhGF0aKqaDa56fIVQQs2X3rSaxy4tJzS5x2qGkuJIuR7aIzZ2e8lHT4tJxE6XRK9pDWi2HMenf/Py+61Du2iuR06GlzMOmLZENAe0Zaq2a59UezCEXvCm3IlQt1kE2/tlIyuBIY3d5aNcXuSHniWw5pMNbVgCZmUEdNvqxbUKxm0W4Riy0f6Or2A7Z1Epk3j0zrkXLdWYSQGaLtEFYzX9Pj03a4Ov+QDeJLkUx8YYawgjvbQ5mlVEZCl6NqoWDDyK0AzEMQYZMADCqLVn8Mc//rFCQULYOpLr0l4zPgA7tuyXFlhfX3Oxh4KjDRtbLM2jGLZGpKv6WJZmyDNS5PO3ENxktRGhppHfI4+fPAEJv0lJZz2Jp8YpFd0zzqw4kb0aF4DGX/VrGmMeZNV/XuYvOe4EuoJa4JVCwEOSFUSp0alGvEXKtOFbZlpv4J5IMbihLH42bb4KyJEYWxHqfe8CSmtma5fg1uhQkvQn4iHy+BkHClO9vZbVZ7ACwbDCPMqDIFmiqdPiuK/G6TCLh0RtqUgsUDzA/QaMv2Ag9ylZ1CNeWDwwyCX3U6T6FukR41OkpAz8jsQgYLS/9iB3si4JSFwAAJ7cwBayS/+K8TQ22Qqjn3kMCQDMOjw+wkS5kCo0y73R2mEIOTAxWggMXTeNXHOSL2vLT+sx0INhaJAWfsCNB9qU1Ui8uV1aFQ3AzF17ewD3A1BBUEUzFM2xFpGUpTJ1Zn0XVo6wSdKMck/Lu0+fCnukoiXtVyVJi6urdi0jTD/tp7SY74FQpjCErnog5y3lGnKOlZoymTS8SM2KZCXr10T6CblsBWgfNGiTOAYBhEwWwqCQ6s93MZgArc3ITuJlDVJveik5QgVPjt1Ik84kNoteLViHjle4LS3DClrhEKawI5mBkJfqYihx+IgE7KuEiqbBnZnc5krP6vtxNjQeelACj0zhlBEk+jNpd3IwQERRuCGjqOvhntZinUknFfzivHVOIDvsDWf8PSWuhFpATAMrmoTsRD+LXRl0imkAb9TZDVfAWbtJDpw3OnZnQoDXm+8nt6FpRpNOsuBWd/iFo+IsK81o/G5wuE/jzc4vazSYwGRGlK6DSW0IYavU1LT+SbO5dhnJ1vaOUxNZyih3dhticN6OWRecuP5R929nlk+8EJRo8SxOIG1CAXm3eJaeOy5/d5sxrAey1HJxeYW1fXI+JAEMavuZTTcvLS7oIZzKYS7h9vp8kj2f6Qf+vWhYmZJSosybxwdlpOKMD7P2FjXJl0CqF63g5i5WoArlZGf+x3s3Nbl7eCA545s5Hqm1aLboK8bakd5VEyGxOMrOKsAeQsiVR3YIhk8uGnbEnnPnyLIUZvuVlLsDJhULpmvTmEaVIYZYRdJOhrMTo9kAxouFwbHwIvYOI2qp0z/0jIXSPX78SGdGulo5UBRPHlnkFiEn4SQH7cCEbc4QiD1QbIFQwJuObkoULcKD1rIMAItJlZQI+amBi4GcNEDrJ2BF7p9EEEK1rAht/6HWE/kLrkInPejMa9RPb6IKi0DFh4KG9DPAdR8boECWzdtIjQD9lBMw5DaJCOrs/USfcHNB8VqTkokUQIJqTuAh8YjsYgsrT8Xde9JBZogcXYAEj46uRxVGGGqFgcDo6z4snwlbTj0s21mNOl1AGJGyVjcCAXrLCuQhTN3IXbl0A4YOFgOI1LswB5pOqZQUDR5hMoJCYcnpI2GYQTopCGbVKVsBSJSFM1HYyhMvkJJLKDv8oUUEPI3NJ3wQ9ik6xJrOWkUnvtNmm57dozbaWxo8NUFJmdp1UaJImozVjB4Tt7g6wctpSqZOubFMkBFExzhBgZULW9dRy40kIHvul2vKT48OwNGbTafirK5muI029ZhbZm7Tf4tBZ/M5NKvQ8miR39W1ZV4dc48O9bVJ4cjWpPOL5aVF7gC0TbJmMgok+unqQs9lzveevIxtxfdm6GCxEraYQ8ZJAYm8MzPsgOXa0y6eGwG8UnjHEpuOjCGSaKtKrUwq7NSJOZMOpZqE7PYPDsC3Vre2QiFo7IwFqDyHy9YFnNbEGzDgKRNbRyxDBZQk6iBPGm0cBP3fGHn+DY+Qb9VDGApYQo4GdReqaoWuf3Njsp7WJQWjxCBzBpkINU8ZzBmBgVdG07NuqOEMUh2XpwesURuGTZRnuuHGEGPGatkcs+PJtom4y+1rssXUiUMmaZ0fZ/EoLxrrxbQmt8yUFTgL80agOTRizvTDvOROd9DvTswu4J7tyo6Jyxa1aJZxJ1cbdVk25Qjl20V60V14C3s7b2yed6IcDpNWZ3kszs2eD08s/J1fmD3cH4xf6+D5QCboa7sp+HycgjQzNXt+7aiqIwLsrGtbnbGVvNCx7h61Vsdp34oQGdPMcxg4Z2bGxHKZmdOnTNycm26lUm7Mb2Evs4SEo1Pnh6EmEnhrdO1L21vYhcneBmoYDYOfUNHs/gzdpmanjt/Ygh6XI3nW7xN+d0fivOrFRib6xfjYPMfB6LX25XgRcsXCNT/muCrmAJEeHafTs0u/ajv7nzSTTz755PMvf9UFodj5OGHTIokowUOJEbPezvG76AHWT4pzcyrGI4yMfiuC5GShP5XQpsMAUI0mzGH6aICac9uvkZxSMrUwKe1aWglbainZKKD8UxIpWPDpAPp5iOdokDITUphQth5FBIawIU7A1/s0xURTQOIll6V4WdK23hgnUr2Cb2pkKqwYrVgBdwzMzQ4xnYVAxxTajAcFNPtO4i2JLMBgk+ywA0x9veUatYABZk863OIpNilOk6HC6DwYpPIVhXpv3JQcGArhRIbsJGF4gmzrtZW7VOKBNQFw6jO6XOIVTUI/xQvLK5LtvNuqG1l4kArJjHWHVcFi+qu3h7dGJwcVFSStXJiCfgKDtoGhNZIRxmRFCD12q7r49/rOqhjbHalLSBVKRkt2z12ccYiZIlAQxWl+StgVgV3E1BW7siOQiuyTbnfiwjb9eAXTBqpTp6m6rkHCjPNIkta6RyTBJlPABk/GWEbK5UaIEy9O+Yw/0wdIAlIq4aZBPAXNjBLvkZc3MPhFgsFMZfFTFfhpr6w3gVNxGG2A5QGPV1GpVeNhVDFWX85dTlNAy7akE0lxm2wIkDDcKN4Gy/2UjMKx18If2KDySKzsRFgf0DEPn0JMEdCBFjNENlhhzSu8Y99lAGVKOWjhqtnkNCuOcndtGW+ix0LCzF/eDW2IONk/G5mcdqjT9JhLHO4uTw9nF+x/ni1VAavJygsLcnR1KKT1hqdH1kZZhoob5FmNra+uKotSW8OTTI1cd3YsH3IUh/P9H8/FEX+eNbmYZ9LTyVFzdqLxypicyG70qyxdtfgFU8buTPrGoz96yw84ZYzongO4rWqan53JzjDXgalW3ZQZ+LvbnPSBb0qSNfJcRNaAxKrW69Ox1gPhFTrxjdTt7ewQHhsVlRyR2hFW8DLq2IxuhEWCxEPFzomBEtbqYz+ZYnIkVABK9KIuNUw0s5s2nz7HeOU1m+uBgdkDEqmQQKuiFdRw+0bBKGvWgEXAFw7xnh25tjQ0N9GIh1NVl2zcWElBvC1qky/iTXLLXUelabRqTpXWDKiCRKpzisO9QhfoipA14GrOUXEIE++nByukwh/hxiMMQFuXRcvYw1d4WoaViOZHaueOtiiOyi9ZdjjDgXr8LOfEfZdENGTgEd8BUopNkZ3a26XZqE4PpypeyEzG3oUfSGRLwiSpZhPI2oSlDOCxCUAXQxIxgCUvlLnnVtjbT19TpHpad/vpkYUKEw3yIZdkXFl7yxaY1Qwww48RsIHEza4G2LCVxQUMHsQwTJQLcDMdcGRXheVMniyCFg8bDeUn1s/O5bhgdIohYZD0PTDcQaxsP4mFTOkmyMFDRYM38fAAaMq7dsH0T5/AeKQVKcDYzvlknpQp1PokFVK9yTVANcmjyms55Wre6GglvmRHKbzy8k5Sf7igRNYSo5YHmfHKW6YIEBpMBG2WqE2bOS0WXfEaCRhpYpq8cEyLovrZb2oMtYgRwO2lpRm2nDs0nEiDGG5h07lJonm7UsS8kaG1NeNT2cI2ixtZAJj58+nZCZ5vj1Jb3ehOEUWG6owVn35rISvWVXHNFgJTNHTiBk3D9GK3gacr2ejOimG8A9AFGgwxqMvnzqzLiim2Lbd3suD8Hp6yfHmHjdi0OjWr3o1l0aAs5EpA5PhYfG7IzkIVejTebVqa7FWjjd6OocPNQ83514yod3qGtw9SxZjecCSqIoTD5dRWED/TASh7MrjNljZNhlqziyXepDT3kUsWg417TjC4nrNNIWdSXk/cnDrUQun1E+M3Q3bk3CRUJIuYlGa9u0UJ5lxPOlpD84whcj12ZZ2+w+Qs+7HLOvPPxKrWa+irrTXiA0+FiqpHj+RfLl9t0nyng6TqaocJku+cradPNpw0xfvGjmY4m3B32s/4iCPVrKLKXZi0dVjhKdeHQhp/ZQNCaW3UOWrV5NHUmA3c08NjOjw3vBtqa+5ainqhx7kuX379rbBt3sYh1dGntruaWvz8BF/hxDNWNDcCQ8zs2SEZHCEIoalNcvjP6FYdMGQvsz8xlpltIKwiH0g7P2shL43kmp1MAo/pViGJY8146IZksRI0Pb2LBU96juhVFeqmnVJQ43/913+NAJYbOcJDX5HnXXLK85Guqx95EbYS/sAA1mZFRjxKikiLVC0zncRPD0g/O15e4AkPSZZcJJtUucA0pEgwChhbNQT17fDdBbE1Hp7S8H4FexFNbtCtBGjSlmRDEUECb5fHu2n19iBWxiJVCTLkKuwdkqva4PET/u5sBTxy9FPChoGniyGmgaUS9vZQwYA1zi4LAPXdurV1N4RgfMVGb7IIP5yqvLH5CZsYbwB8FA0gd4dNcpLATzGhnAzJUcBb1fKWOoHnyy+/DOT9aUKxQWg32PBXKjSAF/bGgU4uoxSzUEkr3ldZe4TF0DLCAk2JN3gxCqK9hE6OUlvYFcSeyprYBKzU3rJAsMLKGgxlai2mdmt6k4OBcBm8u4QblzRdFFqBCb5vPbOxXkYweIdFLI4cchIlC0a+phzti9cCLedAjAg5elSQJF0KXAUppuZRgwqvsI6x74x4y6LnzVDbtGkbzuDE17TJKz1TpDM1Uqdc0H6oZRsiEveU1FeECaAESd7SEnFsgd9PwomjwVDnxFlGv3uwL5WRjS45Ehgfi+feVITEHLDexgQjKmTUDJQdajsjaGXaP31tBIqJ7cbsmR/JADQMFIlxhT98KOM9jQYAJxIyPE1/vlZrUpgOi8cxwyDdrTDFSDiY0pSNE6tvnIiHCprFhSvcC6Pc3Hfjd5dCZ04ycGnI+dHVyZnLuOaW18dvXdjrXMtJq394VGYVLTcqp89zTqMD71ScAxt4NOlop/ogUEN2WiFtvrW1QxU4CsGZQma+bQ8enmZQZWCiiwvxPI3nptA5QIweSN6ddUTc/eaodag2ebnYBuV0AvDMTqMg1zZc8TCRBzXFojJcwTGLemif4ckptsiCiE6bWL26WMiuvanz0Yss6Fpdy87ky+xz1lOsP36kL7U2ibGCXVitpq9VBYPMSWqqpDSg+NSUphRPTLZqEjx9ye7uPjF2vJqtODJ1rIERjb0v6Vo2HiEfMM3JTrIMV2Hzo5oAodHZR8LtO6E20e2Cz5sRjWB1RYdqX3RUeVdldhSW/4AUoYRMRoQcWL0Yn4xPaBODVF/h91MkgZZcTAtGo/ITGU2D4vRXMZKk+bxtp2IaHv64bEtvyAIBqBKAXwD9wiD99G6E99a0Kmvs/fYZfZ5yThqQpmVKIUbh5EcahGXlnUmDaoHyg7p6vKDtgmF3V5Wf1CJ2oAMYJKihQTxKCP6+JddcH7RSQesB2aIDfzRaUQ8eScAItoD2CexBSXH5IQMMYPg7UKhKU9SqiU4ua/HK66cHBhTaeQSbVNIyAdgdrb98VQTAJIapKUCHiqE40KE4aGbEwMmyRqqveog//dO/WF6eefzoKQA4u1aUqAPYwqCCSo7NB/TA1jHewk2MtB4/5SImRx7UigW/mieoZfnLlB6yW1TPIBeKDxKYKeSF6SzWdIKfLFbX1ratCORPzRR3xqdaJqmCCjBSZYGrKdH5mPZGJxm7MPa16qub2BQykuPx6QnthibA+vfOK2UxLVb+GWH8QaryylfYhlvdkk1M9lLgLTuVKJCA8NZZhnqCkijdVRc2A6SssjOajJ+BphBjxkJ9heAeAt9lx0DxJ5aEUYkqW1lbzqF4eGsBjx1jDOiJDOppLuFrW2rHLWSacX1truOqUSM1QQ6ltb/KSvAwX8O8Y8eUs+JufH9/YN0km0/FKb7488sMfLumYvinYdcIMi2j+odq21qlT/2EpBrSARd4eKhL+l1ymiC71DIEir/SRIALbC3mofiZz2wZbgdeCZu1FqdHbyccs3c+PX5tPdPd5eypixquRpY3nmCpOU9yfOXcM90GD9f8rGqKYrRHxHUL7rqhs625tPTcYbHpv8xmOCvwxCHPR8VPoxLcMCNTZ12HfFUwxZpwU4GjN4c5llk9EjadJzyG/WYjyAn6DS8cgD25MBsN7ckG2vhhEKB1WEaJtaoMNzjErJt4srmY2ndWj9u3zq+c7CpT6QJg90kwZCXVwnKO7G4e6ppcCW1dlglt9/apaDVrzGdxl0bClFVNC4txmzACdACKT/WR5NkZ+yFiWQMw9T23tGJQihjdlXw0AZMl1LPshDuvjHXZI8NTpwNmi7lT4S5vnfZjZgRbpI2DsYZ0qIVWKnNFbnGwL/np00fwkEoSSwLR00kEyrJPe29WCLQp2Koct/t3xQcGzShUKfD46fHJGypssXHP26dUZeaEa5lJ27tvs8AiLbHxRNd4gHag376B8HS8t7BkHrqBSQNMmEj1I4yzMvYz8vF256R4akLL79bVSVDfOeJRx0grLK14JelIP6VqraE8TRjkID1dQsDF1hSSKunFi7gvnuIG0xjQj19kTkZNSfOrc3yoYKX2+Cmht1LQ4zs7e20YygJhxhkeBgUASEitWX5EKqafarePJ1NGkfoJj93KnRHkkCAPfvxs06AZa3gu0LnDDMxbYRHcNQ3hw6MeIfSweFgfhc1SGSWLkwcSMZ0XPJ9//jlUyPM2qhVP/Wn8+3t7MGhvOJqx8My0CWGMZdjzfXirEiWiqdHpIATtxyGqZvPoR2lw2/IhWRpFoVxGyMNnSWShnLITEwALOo8HdtdsrG1wxFDTtAck3EEw8oTItCWHYGP1wUHWGhmywqGh8pRQyjb9Yj59J2trKyWUxAO/avXIBR7ugpOzE6P65dWVeXfA1v2R1B1iEKlCvWHgFhOjuWLUwfEB8ZTcenYKhtfCVYvQuv/AqTdwKppUkNCMHkkQBgkipSoHT0qNPFACIvsJdP1M6t94ICcbItAj4GenFRNW1+0FAvSLhDQ/3I2BFUnP0tJx7JD8arPYaOWpv1VbRu+uHOy8v/Xd+cne+PWZrp5SX8QlFms6A52W+o5k0g3O//Erp1+UD4r/TYnIgA0BSk3wtH614JYII1IzDH3KBf1oa4WZJILAAaouVOXQLrzryxmdk30ht1dHTujCzMsL9h6WKpEyevRBypV6LNOYClUu7CWEtcc2K1CXF5ZBlgCbITOOzHyyXWa8c/Ncf5c3Wh/ZY+HhXjPQO4LEXMjuu6gytUMklBQenj3raMEYTCCVbKp5BZR1i5mS+ipJWfTHzAwUCgN2din5J5Zw2jDvSG20+QoDx6hjn1Uh4chKgAyjMDXeCL4pZOi+9VlmX+CXXKsnNtLKSEVTFIGpky28FapFBXnsOWQD89aCfJWdgDc8yEZDS5O8PGIqVSCFlRrlwoDh7JL6KdCc977/yhUcPU+gXP0xEoejRPJRmC6PhQotHI3L4MugTJ/gjyHqICIy788OHFs+CAgjjesZiN2eDr0jMbPTU1wNh8fHe67QMnFhrToDn/lfsqsBK4A3OtAUZafcLp4eG7X8wDoWZ5UQfps8Y7KMj3MdEFCF1GhID3NAwOyTISfTQz8sU0NmFwwMjo/iSHXltM2iR4cADFzFsLuItqknG0qZGNqDHqdaomEacysc1s8bApsRciYI17DzZ254Y9icI+Msqw64Xb1Pd+KPhoHfQloNlRRml6BZxDOL3mYsaCMlSmW/vsYW42F4xmuogMTFAlOlVuOG1S66Ozs51q4tTLI4Pf3ByG3NrU050ablmxCUyKbZWGzgCBfNRr6yFE+G+K9j+1/zbl+tr6w7PNISCKfEfPX1N1tbb9SqM8GP9nbOByeQx8AZNUk+b1pEy5nSVu+uqU5Vb6z9+OkzZ8twjPjkeliRB0eHhti6I3/qgqrNDv7qZdFp1xVRietzzA0nmXWgMwiELLSINVuQxiYPd49vL0es6zcBQOoY43HyOLTZQJ0InQ8JjHt5LWFi+1hySjUPh7zM83GDOPt+fs4yJkslnCBt0M/AxLHT4yPfOKks9KQXHI1psaCby+09PXHK/MnhANDxIS1gOT/+7B/uuWKenG/v7TpzZmt7m1YlKFnIMjjmEonTZGJs+/tXl2en8fWWqe7KYscS7zk3bzBwTBBkkmjnWaFPh4KLk/++yamd7goSKM8s2TEYMOepDRP1bk00CzGQqpv3fXO1u5QSPY+1S4ocU+zPvgqpZqbGl3WDUyP0rFR00uTCys3ErN1LujOSrHQqYmZyZIPwTtxenuyfH+9OUcc7W8sLi/QaI9fZ4WP8HiPuCJtZXltBQG4nRq/1sotL6ovK0eladf/eixeOA7KsykpLp23abG7FirvR6Ru1oEXoPx06pAvj2tPML6wvPjowb2sA7N6sq/PjONXurphKId5JhY4gHWXYX/KU0l8WZ1gxr1JmHLukkZ4Onzx+MT+37AZMikTvwotkIfT13eWjx+uYc3p8yu/l7lGShg14awshY0vByT8zyOHhWXw4xpXEznMXyDMURsKp4NNj1pRrhDN+Lj+Bnobm0QEdHO5lo8Phvk0h9iHQ4oRcFWkCTlqFgPGBeI2U6WPzMyGx+0ETfrOz43Bs80s7+0dTTlbHylo8ylbJVRbGPo4kmYnemoinNk4I4xJiYGKDcPJMWgQhieEsgXCBNbWjLKVDrAzMLBqBEoBH53qXgzRilRIMRlJ1J1mZKoYwzM0vcLk5vIizlzo9ODgieL5SCxHCidGez9AxbL3ZPR2cU4RmBokYqYgZQvPqH9QK08Rb+cUISNxvjBT2qv4gTiXwMvAVKarHI0vaW3x/RRlgYcWjFQGDQRBykSjGbp0QVy2kkMeG0nKO9o8z3q9ezhseCaUyx6gAElI6Gg29AFx26NcxePcn0iZTMXIU42cjAQCPMA72A6cYRPqJsAfyFEoYvOLgQ1MIGGSH+6sYGkfYDAG09K9S6D8wpDs2n4RRCyFswt5oE49sggV/aqhuFGo+w4+YZuADTwptOOCrRyoqFVsUjRnd/JGj9i9GpbHe9CLiJeGjzHTs+BhSl4gp/utgz53OeGIxoQbP4UuezOsd7dvukI1jEzOLu1vbOmBThwtLiy9ffusQc824lq1mFyIKiZRSCHvjshxxQC5iNHLtUGGXluJ/JNZgRtwDwjk7Nmlnln5a82P42xJF+9dhfROUsNtUJCcOak0pqAlKpmyZG90mjgnjEv+qivAT6+BXcGE5wIlR8h2cD9hOgA1VxEuCFeoRQiX1iCQbJI/ErJgLMQkR+yO7NJjfhgYcLog0F6LBUQQ0QmrEnIy+whxS1gTF8EeGbgByrQIlAmK0knx9OwwgYWohctaB+2DsOM4f8JUkFpwHILOgTspIu4OuI9lA2KsIUiGSHZ3JlviJYnsZDziZUiXjMes29hzMdNPBzvzimkuUeLfIt/EhpGecHawDF6s7XkK/OzVD22mxLiozkmCN880hQ+MyQGRPU2QHRyZRUMLhng5LOWoocLe/u08T6vj0nuZa+tg7w7bXe6/5umwkxiInxVo/p0dRHXzwaiqczfC6ShD1kmkelej0o6i1DDsvLUxh4vKYax+0NCZrXBiYrvOWebdiyioTtll1Y/LGLTypGVUDBltgy7kXJydrq+sWtcXd6GjyG03g/b/8i7/+6ptv7X7p1kGqGc3oMdDnLaITOQz1vUzBkesR66DYHC/eff+Lz39BYJwswoCrGo81KhfGIxtxe3/w7NGyPJTl8eMFHgEMZGC59U19ZXVAKj0igEBDBZG4oRmhX/1Cpa61qQhSnhgPFAUk3PJSIc8bTEREiHSVWiYPAWmPRVJneMG+9gZAlCQMJZ7xaDOQcqQUzV1TlgYYYowxUn5wkuEd49FAUCGjyiqnii7qkxNpyWaKzjXw5SppbuKIJPBUA47KEyN3hIIUSYgFPLLrUoGHqsQi0t9PEZySQ+sT1hh2xMn4dnqnkcAGJ2Coml8ygk2kRo5fKPE0X8R37mJg7gfCt8G0UjCwoRkGqfwELC9v+H0C01kL+ImbdApu+Ak5hS6VSDByF6ahxD+QJEa8r022T43fQjGQvnZeYDy+AgPQhHXWHZY1XmqJWZdW+1lwQC40oFQeTGtspvsAI0zbYF6I1LCXnKH/dgOh8TXlzpZ/YKCB8/H+jlbKZMbGLosq4Mjy1qgg70dJmW+yxkQlwEkEg5GEgaZ9WtnJO6xSwEQv25x5d31oj662fnfNjmZSRTSn62yiuh4y2KqWdRvwIBjO1EtUFQdCblBhQjJdZKcseghmNXNBB2ZCn9uXGGnMGrZSGzZJiyE4IxKT/VS/PgHoDkNMWxICskaAcskX58V0pLcYEpGuoVzSD9VR8eloUevd4iTcATHSQtWPuhDfYGDkhV0AhN+CpOnC2Qgb5wN8/5SkAZoq1G7tbOOtR+3AKQuQqVCK+cq6oMslPpzbayMDhnnuXRNtYdZ5FkS1pIGPzfv20E2YSQhsOCY7VcCAycxiJnfjgMo4Y2qSa4huMzZznxdhodgNXQyGLLnx9tXdAwZ5bSShWS4eBVRYAXTS8nbAEyc/FYQcKqwKam5YkmDmaf/wADoaU0IkqQMlNZCVvPnpjWDJITEQ9BPx3r39yifCrLqVFHOIN0pgIxtKJxIek8wiOQC//PWvID89GbgqR6lJDkqIRweaZmIjUg3Fq1U3b2MdbCIVRGYqEwG6OOIABCVdyz7JRXaEhQEHHkIxiqyyfEVMl12MrxJaq9Iw3lA1tZXFvYYRrtpJ3+ArGAHJHyAhkbYJUF7FB4P3DewTgKikzg9xOj8oeB88IuHy1RuhsHQYr3EwaoX+qJlMJQcvYZcQ9qYDPBifgHWp4PRTWLy8hdWKnw8PFAZP/QlMV5KfTaGfNJGf8At4Kw8MuABVEyl3CbkI1SUCwIBvkoQBd9YSgu/chZUIcjGtCsFA6JEEEhi67OgU46uEAtCS786oiwaD/Rw+NU9IhhjJiSMdJGEAynyQHWww8JMiQBLZARDo7B4oBK9NiWyAnlQH1qULlTWkKGIzn9o/ZSTAgHXvhwEyTz5PvxYw61LsiVycYjKXpHIBLV1dOdCZUW9sy3za/f413yuhsFaEacjpoA3s7++hVoUjxoLJm8sItzJWZHRZyKsbYBBmGC5rlS6eOqI4LHQFHx66+7ekC4C0zD00cOehtreqmUypeLidx6DLJBHpX9ULsnUkYdEk5wA7Y+ZukA6p2cV29pCEYR22BdInbMdnAHKRUAMT0Ax8RYCyMAy5n3Cm2SVJy6pBu3wkZJ/p4oxt9A7VB1iDL2me5NfPW1Md5Tz29TFAfmqOchGn7BX/77wC/+9Klxzj+vl3+5LwrdQEfnrKDMz9OKBIjZbIH6iDxx++PHmSTs5Irg9TPdYDbT5ZPY3cXdDQeH1roigtVYtOTfBe8kXBn5107pXb23vnnXdaExUrdJnz6v0aG0q56NrtS3YIrLkSOTlpzuSIhOYGtg4OTk9unz1/TJky3rGNGXZ1kTG0nkAzkUsdd2Kzxb0+UTQjSwqHoWCgEDRjLpxJ3/NdHUHIvfPdt6/ajJDck+Y2lrUMnshTPQqCdTgwkv0tUZcY1by11tmVAIySo1MHKc6JVO2Kxibh8hFgx9BwjLnXO4cWIdEQBF4ugK31pGcEdEWpmtKBhAQQUmWKUU+fbhpJM5zd5WlrmxgLMXxSlISNIFnZZkfqcTlfMig9gBJxwjNReNEw3hqNGMiVFBIMrBH0vfyAF6/EWKqwfoYJRGs0k50+iUFew8AGD2y4J4bfW0LAIAV80gqSsUGB3MmD5GIRrQ83pNJFdVuVGJ/1/NYlUBP6wKArbwZ0KMDEZrd4MR65egQQin1KgiwxAiK1Un0yOuSOYmmF+ycMYppQWZCbqI9ye8lXQgDe0EolX8DCSiI5AG1bRtIpcyPHJsm9AUsLMxqaDJSA8e5HwQFA1arZJz+bmwJ+yqgTCjcHCYfWQlb8bDcUAISBlyN4gZb7prnL1SqJOeNr800qYWXpx09phUX2JwmF5auYwm3rFRmqKQezKAK0hW3c7RxhXa2tAvzdd6/Q9oCqEdb0WCb9PDJysyv+OFRn+9tvNx5tMMyxihicDI52d3dwGh6sQJXqbtooJQTIV3yocgtYTLkx6wVbsBCA80xFqhKYOQYZiVQ1bhM8O8dncknJpkGyb5oD9JHRsakLQyDHRBsFmxZKg8MB4iQnw76cupVjWEDQuGaqjM3hX1iatzTS0/EcFpbwuku8Z5Vq5GGgb6sRxw31nsXbHjKDJAWEu/gtm6gSxewH8SgH4I17foaHtZ9AXn56I9C7vwYgXd39I17CfoT78VN2GNhAIsV4+8kVZr0TJL4ioynxs5uPVaLavmy11/CDF3xhCSAFWI7GKA72yYjrPzPQOr8YHF5fnNxdnJgTHr0YjFyeOpuNWzkeKL2CYyJsFrAHO0exsjEpNToI/7nHDGrn1ZeOgf8LQQg2AWNl2dnJyc7267mpceOJnE/h2ucRWmx8bWXxyaN1UzKGCJxFsdPrWlbnNXElZWm1xUzxjuQG6Zp2MdthDXF6d4+60PXpyMlPP5YKYwg+aJuki6wKs10IYabJ3o6WVBMAurTUaaxSikMMzaPdedRdG/LO/FFTWeNXo2eMdtCXwSDMFr6aL+Sfd5yU+UJjGsM9DRwlpBEVOYWiVushCXL9rnzV2ubGI12ULLiPqCC5w9aVq+4iDOVPBqxqWqKURUJh7tIeU4JEmKeE/d4c6bTeEvpEAFpCvGWHY2Jk1/EiW0IEOhJOZMhdjLxwAEOEMUShxDdYOsOGkBOyoBYA1GFIPcISiPfASwHprjUbRKCsIdWHB5ifkjQeVSVSktRZTf33pxS+HvAg+6dwTJqKQVL9SquAEJHA8V2RYINTYTwS+uontCAJB5L8FPkALOwTAAgh6a8QylcYBgFlaX756RFuSDXa9IAUKYyAVoLC/Pv4ADkMrYVVLUiPr/L10ydhZe+0ksvaJ3yTRYt1x/jZj+RoaPjOC/GNquO7sMBk7Q2nhCAFFB/NwAQ8aJZwa3fv8NgSF46XBdvcKWsSYA2PJOpJZ49IYTmS+EzvsHGchGzK1zE9ZT4YLDHr2AGA5aVwksgFAYgXECncOfqpg2/KxYNUXrlTtcKERwuRUebD66ACrJBE7h7Z+YpdjROdktDdKazRDfmslXbNIpMNvs7Mz8EDCcOWJULvi5RQ14seBAjLDnOqZPfdGAwpJnxVfUn91huZAjoTRo94cW4mEB4BOIkO4UOkJIC9QcIjRukEPGI6sn8qRTlyUzTxfnoEGkOKU8zx09MAjaRjOlW/UesTmSfY2gYuWctEgSra7p6TNQzX9JIRtihyFzLf2EzLG39t3v9meDI7ej09enGbziB3P/Boe7NVBdSgwy1aRIkxV4xaYDjLUQDC9HbIQ6xGlDkPQ48bfcCVXb4jdsOaws8VNU59OB0cWm+R6V8fyoNvpmdpcR5t+K/sKOxagLBZIV+iQmilASZHvnKqf2Nz08/dnX1gBvQSKil2K74whjNJfdKZSdhPFx9+NGMzc55oWzaytBDdZ+uybsNeB4Na2ojv0WMEr59z1qmGjKV7eztkW7tGj68444GwW7es6X3DegTfZznCEr05Ora4cxGTyN5geN6S3xKCpDbRFB/NSq28cKIcfkiQ6qeAnyKBefxU1/1JACqs8Ejup6fhvfuTgLTguwEKgOy3eGQjCX6YIRET7pVAIm/MiB4rfYZXYdllkAIVqcFrHf5Ae0BLr4ZAQgFMKq0LU8BjX2h8a5gLgGz2SdvFQ6gHHp+8xffPRg4husXon1s04ZSRtLgmLAmEjVMYsFzAq93OV91A5QEPm09g0NZ5dbHFezojAB7wfnpAemTnLQkwFa9SmZBsk4eAMXObk3zT3716aQElreTSCZFtPMIJG5LkGAxvZ3JEimmtlPze9sxqSCSuyrFbncJ2jTapKVIRKTnbzUDeL4aeJJBgiBzBN08orChwp6nobBxMmJO2zjhruU0g17wh0aKsziLrGoO05j2ymntuzlXaR0eHfpIGlwKqenMicQ3Z7G7uuOpUqlrMEO1pAZ/ZUcsbum9FbbC5iMpYG52Wgd/vVs+hERY8MLYpCToeGR79ArSmCvU3eCYjFCoItXx2au3GQNGY88xT+xRzf0xll+U0qoMiHR9FAEtPv8et45grFGodZNCblpBc2ZGEMG2g5VY/ZL5Ru5V+eirTVL5K4g82+hpyZHdhMVNdAGAAgJdxZCm7nPLA/JtPR/Y78W/7AzGqSYSikS45ioGz60u4YEWn4xffGJIKY93PW+qATHZC70aCMGqrzmMsc7IsYu4Uliwb2+pPJ0IszU9N3F3M2QB2dz556895omx2vFF7GBl3U+hQTWMTphAh74Knhx7YjHuahX8KwpWBmTrv4am72djfTzZWN9YWHInDeXRjefH1ubWaFuBZS2ixvIpVobpsc7ARyLMh44EvrEce5g7qRKoM+5ROjgJFRQwFhjY1q2iKbJclPuy4uT4n9cTrYnbJYABJKrSbkoTlsYg5wubBWmBw1kA5M9zEACrinW2bz577KheSx0hQFZipQpn8WbhjVfHJwCBFu+i50yixkOSUae3Fgh5Loq0Y7GvvogDdXG3tN0caobKYhmDKKKUojSyAKmiTqUPp6kAOyZUGE/pTF7/lE0KPmqeWBAiDt8JKDtgj4KcHYbJoDsAv4GvLmK+dVmsS9gmLwqWyw4D56qdUyKt1BW+nI3wQ21UiLANPB0RKWXhujKS4zKgtnzAXW4Vhb3jKl9bzRqtIj1SEtQ1A8Z1QJABJYH4onjCEyJKqI72VARi2KkmXR74AgPmqr5akYUithfmyUHItXxZd9wIwYLRUYqSCqmtFjE+/qR2QChtKBCAB3PR0WmF88Jac+dBM9ImbBR5DELk0kd7yBeBrY1BnJyeDzssnRCK1iw/GA3OnbX4WfOxl5RUDFYBIT9Vfilab0QTE+AQDhP0GLKMGtiErzKe3+WRTG3zr4w7tatrgt85aMQXMEKp1M7SWPOCk4kvIEQQnOmXBKESh7GCGp7mBAJ9gQLBCNZE+IUYkYTAgEIChmYNRkoCEh1KkJ5DakJCrUNn5CsYkheQyciefyqWaQcLD52NxKjyEGphHGIv0EMC0fPXrEa8IAjJSQdDCJouuDlnQMgooUDzJyoXGry/Rr2eHrdm47CaNuSg5FnWR0eBBs6fDSv3/f3yVCnJvXws8LdlPCD3I9iCpIcU3Qp9EdhYAEKZ0EuIwAhCJS6pPAYv+GCjSYq8kgE3Prq8s2z1hUa2Tyxamx2/OB1dnh9NjV6uLc4tz1gaNT1m4yCqopX0wKwzMMLR7dn0tsh2WXg7Z8mYWYGcTDE4OTp2HeXrkEiMnz12cDxypkFXVjnCwDtKwIypYq5xbc8RQ+eitsMT2B74pVxdZXmoKcxzX8VAL1SspSunWwxN8QAaEmr+3QqokcsWt5DZTS89t39W8mBqYqBRsl65uYTmGFX0fwMmhsz83Vtek1SHR9X24IZnWFfCrlbow6+Tyg1EcONrP5fKKj8O4jUiomhLEQ9JVAMCnpSUTgTxFsbJlRziNqcCA9LUs1SwfMDrtHwgDVp+yMERhUeuRlwdbvBUWhmRqarvkRM02mE/C7jiARxb9E0IJiQdswpLAT7AlAcCMaVnySYyC+CQGfEA9YqVvaG9wkjUKeTTF/dUnUyKNGqF+On/coAk6YLJXVdqJnzgCJySqX5YgoWqd4mvHKKROHkwzKwVQIVYqUSVkPTrOkgMCnZ0HbgJ1IJQdOjpk9j9R0FcYzSKWwLnkmpn5/PlTfb4mzz7Q+vRZ1Lh60dEwZgVQhRJlQaSAgiAS2R588PYJMSKNbBAGTDU3lwEI+wSJT8oiRpisSKI/sCRU16hoPonxABYWgznSGnvKgtxrwB6fREoOG550Rrgq046B3CMJPGIETKqSVzyRdWrBNUw1yPBTgNZUAK5hqxvpTJcsEuovfv3Vy1ev4TTFx/MjKeuumQC58r75/ntZa11Wh6ysr+IbppE3M3uHB3sqRWeAZoQZTxweD/Z2D6zCxhMxxjlkDABi1KZCtVQIyIIwwK+A3hCm0icnTs/PnUNNiuhf5cI3wwIjCQMLZYQWqmJ4RN85kb7ywG4+fjQ1YweJBnVvFhnmWGV3PDimvUTy7LeVAJXiG3DY6bG4smQ8Yu+ozuPl6+8Rz1jTmRiLcPKoFI/Fetq8TOWOSwYT6Gz2olC8gphIt0gRl8RLooyREzoaoTXABaO58h0ZQ6h3GLwBi/QIq9+CTev1sxiSGHXaGEQK1CJLt9+cx/yvNggAVR5JIPRGp0Ws0LZICIgXLmGZoXVz5KrF41ianVkXF6dHsxO2/VyOXJ7vvHo5Mzk+a3LNFK4FCHbJ5aTbzJ+hxjXu/iwJXV9ZPdzbtdmC0UqPM94NkGhZ2t2yS9uQM25yLqEtBFBpaNqtuYJy9OkDhJHZRVYp1QS0Pk3SoeLRXIqGmQRGvgIg9/YPWhp9Cu7ySrVUiOEFZMGIV3gCCVKR/fSpRQ737vlMlZ1f2EmjIlWTeDUIWNimSP2GqmAl+GkqRFOzkY4CUc7ql6+t42T2IIniVYketj/DwJyUxf5qAcKWaopaXdgJ9OzZC01AwFILJCnszNwMMSC6kstODJrdM0Iz6x2MfuSOcjLzQCHM6G+OdS1nSHqec1C0EQGYZS1HqaDVRH7rt37LV/EK6N36BIBHdlBB6BNuM8hlREIk9BZWhIqfjzRLAKnK0JCE4RIpfWJuQ70jP8KRQpfBS3VB6qCZ3slpFkaWJE1fE61t6+U7VzgVDAAKkCU5GKTALwZOeHwVA4PckSGmC6D8kICRChkAPL5KCBJMmF6f5NKcxZpGIlMBD3if4Pf2E/HeD9hgkAUmwkDZSc6hJAaYGAEJoZIXPB7Ei5QKbeZ/wPBpKK9P8EOrDhCJb2KwuzPy9vgkUu4QUjHAoOqKVCJhn2TkqweksK+YAxtXiq8iUR+dWpaO3Amxt6xTKWV9WKSMSLoKYarm/PID55cH1Qg+TzZ5WFi6z9DkhPcAZtLx/ZvvFR8l2gkmmC/tLgqdAOD0CWHmbq3Ka8p/s9YawFd5dQVJVUWJwcvng2Zd/NHo8fdvXosfrXvTRCoj+iUH33UkbLrYriWf9F4QtjGBHhu+YMMT/GcmSqL4nAOGOGhGuU8iEWa3REpXQ4RkVx2twD15Y7kgSKSqlItDHLV7Xir+kFjFOdzRjTfIaeZkF5S0sClak4otvnZJlcLj50OAO7PLJYtmoIDHup0GExbwCDykasiOvP9k72AZifo5J0LkFLq2cJnyucMrT7nF4yxRKddDk/NmlONTslfLrKsehRY7Ody2vRsSTccFMwDUOxcN947ei1mt/+DGMf1jvY8tvrhn5zQZsGSfR0kXrFMxhTsxVmPJzBXVNtIy1ZFtRxo6SyCzxl+hEIrVdmZ1DWqnIpmMiJxxcmJdvH4+Fm3uCXyNLJXaz+ItmyE9nEr0rCxOue3AJwC6JfH6Zu/MZkkZHOmCG4+6s5DEJPRr3d7C8ocffvDHP//5p59+6mg2CoAuxjpzAGafL619n5xyifTu3tHKytriwtLltJmRaEI9FhnzkCgDprgra7rRIij0aDQmiqxTdoTq+OiNexF03oyUjbWYg4QKNzRbAuMSNAJjFQOqPOiHXDziq2ajh5EtBme60r0zA/92LEiwUrqSE2NmrYCR+t13Lwkt8uAB2cDCHpAwiPbO3Fk9csEnbxmlRLojdGCeKF0SOQQsQVxUt9SQ1n67vObm5xX1R1t99OHHik19IEV5vJGryQnASIHSHRCKVOsAHmiSa9e95Mg1CSATJCGUThQGkHxDqBPPLbbljU0fAAY2YFB5h3nVl8Cm6ZJUiSzt62Ysa2BimhHSosobeT55QwgJgM5UWGSDIUBGEnZBWrl4yxCwtxwVCjAkILtem/ViVDYutS9IKqrKo4ZYx2Ag90CSItYDj9wNq3UPAsFcoxB5gUQGqIbHA6lEgknAYZjFdmWTL0jJWaXCHmhBJhftQEmnp2wG3js8EB/MZT5bIuEQNAyhKFWZbRaR1HEraobbe9vx19sQUGv/EWAhKWyqVUakBA1yUXbeeaNdwDD75EGGx05m8Nby0y1yFOMnPPZqDo+HOGM0R03zIpGolaVl+4nIT9W7sgSyG3wMRmtZXDd2m9OhccmDk3zESyuL3PHCMk21pivkps7cgAdJBA/zhZWitQJK0CweKvQUtTG4coJZWVhJOTJCwn3M7KrzHUt4oqmraHROlrKo+mK7MDwtXc1w8GLypviURCX4EeG61+xqDUA/lVvI9TNJ6hFArSDyOlUHvE3r4CRemIty9AP/veZqSt+0BSS9rYwyApmONAuugJs5JyHuUo85Ozc5a0Q2erjnolkVwK6/PLubmVtk/urvNDAjKsMKnnGjBzMEpMJcAjkwF6GOzgZX+ztGfgfrTuRcWTJdaNwlx5w4544yZbR5t/zvcm+JbYGwDZrCOTp06pzN6fkDoCpvjEH4M+skZyUQpr51XrYjaVwefFCGKkvcPiSQ7N3MReZZMErazcSbW8iap4h8iaIO+qEPYPK/3nrz6W99dnR6znf9s5/99j/7Z/9c0c4vY2dIi6XeBoQLBvPmh2etrolTSJtT4SGAwVRUHR7bxngTz9rUpAbSJpTlyyRQnzE8O5IvFWE6gQJCNtmQvOuRrDLByTmekECRPnUBgSEALSI9yuVRxg5gi0gwERD+qQrjhisEHeFOvfASQYUYMNGHZ6cCknuk6LdUlcU9erowyErGMgLwzSMqzsh6UJ+d1vUUqjsXS1HcMvaWBHC3RiiVzU+R2phH2i4bTD5pmp1FZ+lrF2kQb3hcqypVPoC1fJ9QLwxYvoAF4JQvNaoBgxRP/wFrtGqCCuM3BklEcCQA1UOgrTGIUcDOl1qRqXi5dHaAhQmcokECsxz9lARCbn2EAZCqEzbyLqmvWE+RRdnzwJS7QFpJoPLTWypU0SyyQ0mXrvngp6KJkZeYCHXVip8dCQA9rCsBAPKa5vdn+bRMlPprmvl+KnVQkTCpkGFYeukUw5v4WKkM22/hoXDgcsyGwb7OUSrdKyTO8KLU7AVsGlpYjB5w3qQxOsFIDr9H526EoRWo4vSwNYWAM8rokAmP5hz+v50AF8YxADCoZy7R8QV96rW1QMfHcV6x1NDsSfOrOQaK3b756YVZJ8/gnuI3SZCoF4tEWyBR5WmqJDRL4SvfF3iRYvQBGgbClAu1fuKMr8K01vyCWkv3TLrYQQrrVhYKTPm0EdoWp7FbOAGnM7wdA8Fg26afDxkJo6Q4HJL8lKMSPcQI9OOTRzhw9XSMYFtBDYaq5FLNQakF/AxVHE11PkSquO4UmubwxOE6dYdnJse6sJIcdV/jVE0VHYANBJwnYVRwfjO0BBcHgtNqAofY5HIkaeiBmEqz05N3Nw5RGNhRbdWu5fxuG6IGV5adHu2aZdsCruSINAWkbYv/1H5ORGntryxdQFkYlGgjagHxkCsFnx5T2hbCkicRqQ7theVnCTrbwsquTB2PpJHCA0k3LpPApOVsSEg601qxAq5YrZbQIyxzBVE9hIGRwRifXVzKqqbyjUCCTLreaXjEnsOTy0MuZoYdGeR6UMXREK3IJbSwkQ0K3Aj8zkgjxGT5kFZkvomvWpvI+qCl5WyyH2pCt3MzU61MiJ+ioZxCUNvUl34DB1Q3OkV6hMXQSwLNNJQgwFvaLhfgfMrRJFmIiCpft3ZO4af7yC3MBJueOXE4SomWtIC9tRv/d6bMfUmIFRiReO5YvnRHsoHU4Fc4u8FusgGk00tpIR5CuRPmZuMrhKLhFawRoQZZ3jBilq8UB6JB6vgkgUokgCoyVvJmxJkDubbtTUYBq2xvYJ6IlKzTQ2WgpIQJ1b4GckqYRMJzfjaQhEwAh1wYDZL72khQKHdfvYU9HS8v9AsLABaPIxAC6woTDlqUgCnDTFmUQqtCuUizjRaF6eHE24yj0xi4brcWIBN3lBACAwIMgUrdQCsLeUEiO2URcNxUSto2e/WOONlfvSEBryaFxQvnYlhjuoyTdIQWr1yM34VjpZ4ULZwmOMgztNdV0LVsxQPO78HZ6syc3j4XjgydnkRHXy0urSAJYSjhOZULYl++eWl0nGWCdRylSX6LAlW9o3fKTR/kZ5H7POSvA1ltcXE9MXplgk0bwDZNUpW7OyrFq1w0BIKu2+BP8CCAbDiImGV05aD92AHkO54uVKWHccbk4PiSOyM3WN333PgmR9PUD6vX0I9RXRAGO7uY14hcKasaVHyqhVTAwJqjI2gpa4acMYWHPBpaFkoiJPEwh1bTAJpPOFV11EYM+cdRuWhMCEhdOHmpEsq967QKqtFGxiD0TjlLAr3BiPQI422H/z/vLoiEUMndWyo/o8T1904Y0ByRUkpEiY4PT6Lc03YzzxTyVIN7g8c54jOCTO4OPCgXwd7ZcGpmyX3CTksqNKODE3eW2d8zbTcFza+pUP2Ap+dnuTL469j4OYvG8qGxEespJ8fnrQI6HRwR6cwMmyDAKSzNOZg5VMhyIRu3FQrN5Sz0LyP7dtYJ7RRkrhTNMLRXFvCtU2qKipkqkS6amxllqelRpAKMvQLwSwKdsqQVTMSDhAA8OT2Inz3joWK4Cq0OzC/yz4aLnxYTHj95ZqREGN578c7Pp/6Mv/rwwAlXo/aq46Hrc9wDD5gEm/eXNEyrvCh6J0ERJO0XPd09K13XDuTbexr4NHX39PGqSQExWgROtqTIGiU50NCEXw4p4vjggaAqTBGTmUhdWNdHwMbhEanAUcq/SnS/nB09ciSQ9TWV7CthwoTikiHISjHwVAwaSA3IwhBhE8DhB3FK+nqwN65/CciWGBCiGk4xOlK+GiQbUCuVmcjWSiGo+NE/VYmf2jPzs7tZnAWMDqm8hbED/vtylG0oL1wF71MDoxUlKV5lhHo/pYJEZy4vhKlIyGWk00sLL1tPEmXpUnhL6Gku+CngZxrt22aJWln49JAvPsAAT5cLJAl7SAgSGb42f2ATZjACNg7wE3nCHmVRGdQZ2pq3uoGmQVqFlRAl8oVfWBbCYsAoJhipfOo660wByAIA/N4eYB7JPX52cl+BKQX+iIzAOYHKCUv19PxkZd3zt9EOwLyVXLxHPWKst8uylU5B5CK1zqynbVHIPdJVWe7m2BRKyqbbWFtDNmyAvT1dLgXsGoQZMF+Blp91EfwvGQ6EpQ2sLDEo61RFOHtGXe4AFMoDTBJIvImlAF5B7lMzUwwJUXABxUGJAAAYlBT+jodHBUkiOaaJFJbQjDH7SnOiHYrVERuC02kVR8BbWs9v/iywlLcD/e6aFSkgIYT9CD8A+JQqfPsAbnjx/fjSmep3S1PEdBAjvlhRO7hqzAqnJLwolrfKiEpmR/sDifPpzvVhOXtK9x8Va/eWe32YUGenA+reaNAfDDlW4uTI+h+rawbHhzoQO36NEh0htb+3Y6WAxZDcRLIAjHUea6Wo8tj/WTiVRwhAkZpeUF2QXPHIVVniY4uU8AMDQNI8moKiAQapdD6pZawG4AFPdEggAwsS7nv9jx4KcPMKjACwzlomCi6CPMP55NFjjZQq8wYWEmyDX5hzYZGE0HoyBMweuiswvGFyWVvbgF+qRqtlQQUtYL2Cx22vxrJKg3LGR/wwZVmiF2cAy4iYSaiAkMAJIZlEg68eZRTfdYoSMQC8O7kYnwALeJoMOsc0AIBG2Ha5sFw8zRA/mxuSy1RaAcQ0YwvZ6P2sLGrCsrprDQHIbrM9vq3aDFIo+HZjtSmMRx6QSiWGIvYPmuSHNUjvQbc8hKVFKMguvxaOAg0ibuIMWsOF5tE9xVmxeK87ZES4YNA4m8iU4W37UVRmiFx8EgasVpoqOGGTaTPugX3NkQfGwaYgIEtQ0kqVt1HB6aEZRYoRhlkYZjlK1X2PmM4XZmjFo0GkwioUssGnPdVkr4ID8BUGABCC8dMbDXUSVFqOcH9Cv3DdFpfmhAar9xo+SChglV2Xn0iFAA/82mBCpSMAWEVPmtWRONgs/LMNhokAgwd5afajWf1mKux4cMTYp52pe2QTA3uGHtbLk8PMwNxEjv2D5Tm1cexuZXEpGVo7bYjqbM7B6fr6qo1KPDy6i7CLlLsTZH7BNSdUkg26NE6TIH/Fn5lZVmSXGsMsX2TLi62hbViC4a1lkjJdAuDd7R27fCVUa7TD1YkVdhnvK7szoHEJb8XDAMC0bTEj5nA7pvz0yE7JWb6ykxA2YwW1b3AjOwDI1mVq2cbe4Vvwx6UrI19Vh7Cq9+7qEwmPN1QCeOuTnx5hGDrsnezebivt+N8EjtAaP1EfBI16q9wRSVDg1v+7XkQWHsVcWVmVFsF+kiM5OqKXDe5mFTHqIrevxLmblTPTetvbG057G6EGg8OF+YXy+106PdXZtaY4EGZ6zuYD22XJyvTc9OTqSnaLuVegtvgWK8hktGeKbz/wtFscsk8EgL48MwKYkOLG8FeAtJa6ZQxyi2slxLRUrUtVLNjTlzDF6qpFAfVuCOGtP8YowALOR4CB4YwBOj3lVZbifHah072UiFM95Ij7hJk9LQxMjZNqUk/+1x491jyVd2Nj/fj46JtvvnX7DjCs0UQoIkMEPSTNJC9pfdKQJ6cvYFDxaIvsXeYEU2ftsYbtd2Z+rKyuq6yQ/XaNlmLCoGq8uxSHzkk1GeBKB8Nfu9arJ4BcBYFRRgH4vRXZ2wNbS4uviPFAKz+RPikXzEx34k0LMaS0U2ijNOK6jL0FIeTC5mAkF/aUWg2jxLcOnMCafKgGQCoLrKtslM4aH68Z3SJLaeUuY/TJgETKo0srFRFEq4rRJcpPxWixYRnSbRmvDkAq8ZIIrC4v25YElU9ipIUkbMoJJ7GVmiqE9k8xrTGVExua4z5Zmqxz9kmp/MQaLgvskIWYxtMFrqKpWr/ST8pRduA7d6zUgSGeCsBHnxqJHgwqP1WY0kEYIqvLURbkyZpuhYRMSGvdvORokAu7A0KfJEGbTL0lkVzuVKuja+hq4Y6fX4AyVSCvphm3/ZQi1HLWxxSKRZ+jAIh79a/QVVnS7XNaw9+zxEbKbEHSSV4pYvMACjI0tTU+4Vpg5yRjPu8n6rqk6FfAj3748Zs/2mHWPHn2/M///M9RYr1kcnT1kpuznLpdIyFqBrYU5OZCH2B1BAZq9vx6ym51B9cTb4wnDkSuIGNLE4uZZoxrESss281Rxllq4TKr05lB6Kdw9RPjPLw29zonIAdYDh1Iubq6XiId5mMvCx1j5UhE3bjZrEYMDMYWFpdZJ06wJXGwl1XmUqFF7qYJjb+NsxFmQk+Xai0ghNjOn2uYwJliDsXCD8NtxqV6MR+Mo2jWlLqaWhRlqhRu+SNC2sLbmkrlIgQ0gH7AP9Q7Cj04n1H+bzyV6r5fEZ3OtMC4PwgxbIqgATBNY9nH87aIUZw9Rq3KpeLAU088WtlsVT2BTOWsaIYCnZUqUx2OsscHNbuynvHT9KS6ueToRwNvhkWUS/N0Lk+n4fmA5+f89ECO1gvx/p+6iVIvMnZHlXehDCyqycaRoXHnoNg41tKEmQgov/JfuYgxKufpoXaO9ZAlFfjAMr6oyZXGRiVKotejT1gWeuxcPVNKIOdq3jDMM9f4+Mnm19+8cvKzGT0dQHNPGbVuwFghprR5DvQl3gwOx6ob7NgJ/MUXX1CaqFuYW7i4jBSYyVZ97Gn02MwgrcDKynxOLbm6XJqdo8cyCXp6XDJzc5VVUlGy8/MLuxcWFR/qwBympyynODZySzhZfFQZhwIOa/RKR5gbs6IhFTcElIUYIxiAJ0Wvp+tLjF8dfoiR0IONSkGMNdvDoxx+HEhHpNTSO2/wKU5pV59UhxhrfipGRLiET/5XbNGmIMY1e5glRhZobw67wmD17iEpkbhMpAE586fxZDrFWoMxa8954tix13ZsXt1eDYYDGzidfE2AXJJyMTwVWFtZ4mGs+aXc9cFRgRDNT+2wLKgCj4FUVpLxrtqUMTHaYT81UvWvmqqY13s7W8wMqxTUHP3L0FYSqDBCy1cEhUe/N5z46CsWgJTJytoaZnCK892rap65yC6lPzVlwxG/gBGcyMdPn2KSSX/jX8PklaUF2SGeg09jYGH5I5FiAPCTghGjvhVKDWEUuUEPQcE3hgkvOVetP5aGunq8uU49MbdXltes7DCr6ZDkGOO3d7UAQ3u2DEqeI9Zlq4be9kWpWXYW29/FAzfZzWjA7tQvB+I44pFxGMesjpaVZ3PO2I1buWtfwZl5MIeYa6ZmHazrxRCc4bvUih49f/r03RcjUxM0unMPPvvxT3/r089cYfbi+Xtzs4swjzssd8jz6yoB9rIGNTw6OHZue5ZCOJHglG/0hl9VM8PDFoDXWzuuFLeIrO5MId+xRIz+0edAij3n8ruMsFbdVEeSdUHEkKrSczBYtTzrQyhrJquldYy13JY4NXN8YmMa7/+4CQmeKNYZO6PLIkxo8UNd+MNHIscWZCtqef4WWbxzbvSl+q1Q4u7QXU0c7u2dHmd8Rlr4seCM7TEyYRpBW1CVsfXKvU4LaQvAEKaf4Ji20ZoytARweWXNO6cIl4bObAjVlQVGhtvMaqIYn6/WXQ1c98DTzX3uPnGC4YhOMuV2srgCSCw+KCvXhtVeip8DxWqlCspwwan0/jI4cDW5ud7Ly4XFJYlc8kNV4GCmFy4JAOYZLlzZaM2Ch/n0hId93tXyVhZSlJsbT7d2DsosnVZ3C3b3OibiaG/i5lwPOHJ+POFu4avTs8M3sxMulkHKmWs26HbCPD+3yI+X9Uo58NgYRXsysMhxEdEvLHCHULjcYn7G9gma4dPPPp0yTW29aV3+4/OMi4NNPFyYBIpHND2Vha32dU9P7u5tYx5fSrp/Qw+9mjULM5pYrm0w16o65KKTsL7TLAVMlBYk+IZp8UQ5zVvh2TowXsS+fuf5C3uY1fsPP/7ITMbdTQaI2kXwpHdJm8FM0xtkiXx7NI3qJ9KHra2vfPSDD5DBL9rKhKqRo46fJBNrFo9uhOPfHLC946vrG9IyeRbnZgdHh+bdIzzucY7L85ztRUxcWCRS+/U2EpJvNYRoZPJhuk9t+tNQoxdZXbED6LF0g3i8u3uAEqxApxXZliM45On4MGKsc229ikjEm8/rXcd+kgerUTUsAVynt1N+JUGXgOrBF9lRXqgR7w0jnxA9CwAKdqV4GTcjCGVjkEqueO2rSA8Ajy5BWLyGQwvIAqTSUWT+lERyIyMACl7Up4eHxM8IU73FQAKy0cqoaw7YQ9in/opIDwPHG1qkggEpiTCDU5crXsOGEDGyQKevwp3Kz9bg4PUZuOErbMSiUYnpfAXEQy6tTohAgMEr8FiHHg1PLpDwT4EJM4sYbwA+yUtygYd44WonmefwFUkSMurpdurCV8jRDB55wniQyf34qYMEy3X26CcHxDoXlKYXvDo8MZjjW4ucpZsZsQJ6cf3RY7dBitH/kWCVRs8aJ/j00ccfP3/x3nffffev/uiPvv7mmxfP3qF5XTBg3JHudpzUZvJG0WvlXOYJZEp+suKB2isBiHmhstgCvTqRKToaqWVw0vjyVX8Kywmts7Rx5uIsXmDwVfALk3vLq8umlWQEJ4Yg21suAPT0IlWlUmORZ3llUS+ra/HWxeprwV87wr8ExlFfbDoVhGMYiO1EVUk1A/2UHz06pNLY0HSTVFpciCxpVJunFs/knImY8HxasUWqBmUtUtjbR8GmKtXxMBIvMfM5aGtILdBh+MUIC8TRwZ/VDyUXSzo/IcQ3W41gIBKqOtMVi7NXtxNsJjvbTGHOU5/j03ppWjW+/rcNim+XJQs5A51A6uMs5HZWiI5HW8gM+/GBoZuOiHmT03gZkoQn8mTbF7+Kfs3lISzk2LDw4IkRTORQR0XgtH09gVUJhHT4N/7e7FisQbMNHxoFSA3h6dOnzt6BR0WkQBOT7qRUH6YWLEvjejKGgJB/2By0rQKTYxka6h9kKp4KYHOod6rT6JR6GWWQc1pl3IO0mL2C8NdYN7JaB42MWgvk6OyFmcVPfutjWwuNdQ4OT3iPLPycHpncuU03SZNjuC3NJjnYoYpDa4Mkcpq5jVc6N/teJ8eX3I9EgADbx0qnk2Ed1ezo+MLismVMfGJZL6PFsWK58gzEse/2jsUZM6UGOapVTMh8W/X442eYGcwZDSi4ZvwAkCQlb1hh8CCsvAhrk1dJ6TStHgf6kRwAsH6EoW0kwhm9Myng0lnJWICZ323MZyjC91oaTzb9RFn02nU6ZI+vrYkKF0lNxYsEWd9TgP5UAYWSRfa2+SlHCkottn5kFVvHxqXGKiMiHL/AHlhT2nDWGzZJkNS0+YkkZPspPsJRylERwIgH0DEIE4BQE7od/s2uMTi7IA9puwiktjOCx7DRT/SgWUbwiGyBYHuqTkgkVxDVoP2dQaYAAQAASURBVPgUGckW03wQCadKYpHJC5jkYhoVevxEGFLFeMPgJ5xUXne6UsHmUz8+4Ts2VMGTkKMa60oXp5rSKuVop6SN8hb2ubJqdubkYGAiWloArFMuf0avEllVgjaNh2pcdmh+VihnOsR22ZnR8ZU1p01m7fz0/Nz+zu7iyiJD2kVm5gnULpVRJwnovt07z9XE2Hcuvxv+LEu7qwOCajGH8iCFMHDTO3HW6TBlPaAcZqRGWm70apllMecUztxldEKU2HH4I94DUkXgv08tHkFcvMU0NEezj8wwhAEoVEp6mTlAgwls71SWIRX/42KmUAkzmyxqLTv1eSqiuOEUBm8ZSdhXCznkJQbNTBU0hOY019SXR4l8FQAGpo2f+nK/VRiw+Abo5JKI8Ujiabm6uYhs0F8VjZZ8Skw1XUm4nECGRUWDr4zH2OHu99HBuMOO8VzGnCRKQVMK4C0kKMz2C9aVEEfBuF0vM6eDM2j15VZFWQwVzFERGUTIIiOobPSlW0NJK4dmjgoHrESK1iR1+Pzt8rCuOFn1Y7Cr1oTBg0SVt2pCIZ+Sg0epXEQixhJea7bkSB0AmJ2aY8l3EjgpRe+qX4aN/myehYuwXsB1T9J11BEpUoObj9bNZnHguCTCJAgRctPAwi9/peM/PjnjowKpGKmOKIxUB0GamDrKQSD1aDX8/vzDP/jBh9bFmn+WREHmEcHnrvVhkm1Pl9aSZgUUvcjtVNeOhtNwoCoz7/UoozFuhI2yqkk/mfoSbpcNoXTt9PPT42sXCiowsHmDJ8BisLQrBSRB9dWnojqvhhfoLATQ6REvBg3yyhJ1XYco6HZ29yFK0hI7kZEhwwKnSRWJLYuSAWvsjctXVEolAHV/EuMnr64XmuEX6MLAw6ABpj7g7yQKgHuoxdZWVQA84sV4S9UxjUd2yFCepkoYYR5MUYVUs3Bwlpg2bRLiFwD40SNfX71BAvAJEipDgMoQI7kYLCJDnZGfkKBHwFdpgUkOvmmjVSl9fAMjI0/rccCt08UgTxZgpCpWhHUPZIiRBRpFAoAHZIPxqkvYmgtM16UAYsSTHAH17o0Y8cqYIswv4L3uSqnhcbOR+NWNNAy3JlEKZM8Y9mJwOrO6QmWywD1KAQm0P/rJj1fW12ye/MXnv9ze3dG9KBGSfF22tu8i2Lq8kOOeeNXaVKFEuRqYXAijxGYsHCAU5SOOd6ilWY6rS6uYSQXRwLQaL1YuOK+20fz31aMgIpt7uCQXOSoptDraflDlQYZMPS3kNY+FM9GhIiMGHJ61lD5tq6xsYyRZ5KRqFFTj7FII2+LAvS4AAHI8fpAKMcAaUgnACMslAl1IHmKQBBj9nv4k0ALAFXFtkW4OYUzrbQyBq5bYAZEKDglxYibzlyk70z9zPai6THWkdBxHtQVXKiopdQol3WS3h/nyMTt7XaBoDnywtLxq2T3FnQM1FCuSwzZ0yWvW0ssObQgt9oRp+Sm+Gjsy+qeASGG0kXCUCEsrXhL0GByrIOxyAYuFN+pajQDriogjifev+l29li1OLltXO8qY4aBP1vPkcNaTkrUrK2+gklZdX14O9PYyajETY9qfVc4ul6PckcQ86NwP9vd0np99+qMvvvg1DFxVVikY5lkCdneWPSIjU/MWNFkzwWfJp+TeIoMAyDUWTVsZF5fmD7Z3ua+pW6zmD5Rvs8UyKwFcEIM28w26MQNsZ5JM8745FKt2kOma4AHQHIO8+dCchKGZFlTFf5AeP1seFFBYkv4qla+tT3CMo6UT+toADcwEAPnwiBSGMMapZLgDb0sz6lEgcdeirwtLKxK01gMmpXdTAKwLgAIw6l4MgM67WqBoMaFYfipDpLA1eN5NdxdYRqPpw+6LLYsusOIJQyhtEw1ewCN5XITuGq1T6XUrLRbuSk/HUyc7Yq9rTKEKHUb3dz3+UOKIIyTIkIXSIYwG8ciI0u/cc6TlpW30jr4aZTtrbDz1ZBQNy4tL+7t7JiEzjD0/dzcAK5snREKEwSwArTDlu7m+0UXwxuHOWrk6O7RBCN4bgDcammNylBy8AFeJN7zgfc3kK/prJIRJcEibhxzSorVKvdHS2rRFLiD1pdLqIJ0qerB/uGSZh0s0v9tdXdu4sJ1d+4kPwi5i5uYMpE4+B+C400dPHpPpr779Bk4iIdKwHT0CzUPF8cmTc8acKJA1M5Y3UPplXKk0buacGJNmicNLubfRYobp9fVNbmUTDDqjGg1YKZCd+roTQgkAe9VOJOStHSrHfqCSrxr06C7pLutUaUaPkVHuBhhhFac/LrAIElVii5l5dCcg0G+IJhWwZS6rKiIiqsJLQXdNwcYxBIML7r09ssNo9ACWSt15KjLS3jH5mWCe1EshFMYi2Ukr7A1MLsIis5nWxE+JQRC9TWV2B36+DploqUqEJKydnV+ktY1ULPzXP/F8n90RMAOhrNhmQOvK/PGfK6jpkAOqLdcJXNK5crMGyumhijAdl7kuOlsB+GD8IUN3NHa/iOheLLsgKalWUPq6RR0xKBU/OzNHa3fpFIoYd3kzu1pSrU6Xl7OmvsyIm8WFtcvxM4W5scXFJJllS6p7aHNWehFvK9CaRfC3AGAXtPKVXfNQDA0BP4Wrz3XIRdES67AmBrLt0a51OSLGOIpPv6TUVi8XlQOOoeMWco3RsrYVEyIzM2awTJuZBWP7E9OtrS3VvbTsevrZl1ERUegiP/joB8D0Z2Y92KI5fYOT/HZueJQV6orj1EVEWtQgRzTIS+f+QHlqvPrI5h7Ih5/CD5H3PCwjW1o/sYIQykIZcUkq8FgHxNdGiy2AIVG/gEW2rIL0iI8cI70/YIGqV5FwNbR4GKXpBHDJSa1LKY/GJdCFEelBlp+Se3vAEMrGL6GYlnUIJQQmicjGJgxGDyaVSDCAG794PxW1kaDQ09iaNlmo3YZREMaFgoBHP0hIvGXnp8lDkGCIqRz7q4zEEM3GIywgLxjmXZK1uyuGTLBivDGdRoZK8n7kC7myS6VyRQo0E0RKyzeHHuV6qCowAJp4uYBXHAEi6BFv3YskHpGQtOyiVpjOsEgjSWzuTVr1fW0CVaD5podI3Yd70yaAhJEt7cH+kTJifTRCmVLtsLKsEIXcry4B3t7d9+lodIK7zsoZuaiRrvcXL55NTv7B2ubGN998o5SIxFhGExqaD4TtYTTZtSNrn9QA4CwWHLk52Mu9S25bdUmTPqBETobZ3AsbnqNTowAf1o3nBA63WzVLWwx88miHrWjkLjkAb8fV7O7vKJ/qkrXG76t5XTgBS17GSURfXpDgqiBAc7YyigFcMxNsNNikYrqopgYGjxvCkitdIfHKIzLZlaVSAJKmCMI6iuCpNumdD/UgrAH8Emg8wiU+4a2YfhfCv5EoMI0NDY7j4HnPAoo4s2o5RlqNPilZx9LMMo/0VTibi3VyBFAmrrn9bWMzycicubq0TMDBF2BdFybBKMPYVBAMGSkQ6arEztTb05WrglAojEWhvKxabeT/ZepPf3xdjvyws/Z9X89+7kp2s0k2u62WQUuGG2q14cG8GAz0D8gvDPhfG4zfuTEDeDAQBhAESSOSvd1L8vIuZ99q3/cqf74RdaqVqPOc/OUTGREZGRkZuT5SqIG30EpX0shNj1qneTUfkTYsNm14pWcyqNM6VbwVKx6T/mmiLhakyAYifBGjtJGj272SGlQJO+NmRFHnqRNAGlQ2vNqREhHp0Uzlg8QDop5YovC8/o2NLfdCHx5/b4SQK0R0q77gODzCKxoamzTukIunT3zHJvIPD+Y0j7qx6smTJ8+fP8vmr+x2W2b6lU7jigYOasIxgIZiZkVxTi1MhLa1IUrtWjvSnaiXDi20lps4zu/q/S4uQkTe3il/Q6KbtlxBwTEgmrKXFwi/XDDjU6LQLQuMonl62xqeaoYLChEOmToDoUhNT05v8d15kOT0RdDVPkHKBQYlz0btlXg/Ox3HfoKE3LNtqOVE8OQV2VXPgVeQAnIwYBEhT3FgMACDARgkHbzys1PoHCMi+Akeni4X/MDQ8pRLIlsAhgqmtqrpghEgZ1ZUmLx+ItdUROQC7AkPySiCOGcfsHTAUrgDGObxyw5GXhTh9Jb+USRvvYIBacXpnygKmk0zLF2Wbh6yQ446bsUJv7NLybf9cmFBz1xlDhcDTFasQape72WXRgSOip+4xQYOLfP4Ory9ItSR/T0+OETRx4Lgd+MC//PB2rq6lEgEMRYReFxLd0S/ePXKbVn/8pe/NPPzm7//jcnQmbl5zJjzN3enXPSUmadgVxfXFhGQNiSTzhL7RyBkjChbtLrsGMvY0uK8dF4Ae22Y5VpdpUAaZfwYiGiEWzY5uLtAEXgVpTAFEIEjjYKi8eiJ6Oo0270VVlxP1mCtxoBJUrqqIjVEu17kFTAWkWlmdfgLWgBu0Dc5xtqTOfPFLrkNnkBUjbdgwMuHTzw0rdYW8Q79U7PWYyDqTy6SjV2XqzoAyAml34ZQBHirdTAjBDb2Ke5L9LlZhUamJq0e6Y89L0rK7UeKlc8Eku8iYDznTg3lJmwONS9CCBCGaAVq7mNdmkPGa+enmb72z51QzhkMOh5szXjUEoqRAM4Feet/7R3xW/Zg03eoaCgVoPQw/mZ+1qbPO3FJbH32JMbm/+rcRUNjPkdnYwJtxIyJHyVVHCkEoqZ6/QwhFS3IrtTSpdBqpZFoPoz7T9iY9Ep27Vn63/7t366vrwFE7tWrtzREGaUz5S9fvXUKhIyyQS07tcbmhsfIa2M798v6vhcZ40eTsdFcwdHl+NuCTOB20UCFlrU0BdTAL1n7rHHaxnDjCu55H4uVc3fPvaRI2M4AA+tPCBmTRXnCqtCC7Urx9IqtxG2JeqA3jyhmZwEgvUQah092okC9dQO3ZaJu9VOWriZESaMJiYvckdO3xmARmQ7bErZ3yqls5RxFy6FgeoAhhmkAUoRmSIrQYFALmBMkgpEFT7JQCxjgYTQBN4xEcel+KiGKsqh+DHS8MQBQYWCaKGziLQj4t7e2dM7INYcqvnmAWSj9iFJKFI/Vm8nFIPSPJQLQ2NjfxkmOEvEMXhwVpNt9MA6wwx28IvjMEBFBAiFWG7mnt1DBXPK8bWziAa7lO9igVUDMyF4qdTufiwEOSNPVmSENMwCl7nT7vcy1A1AHVgPxaaLDUwPXqEW0hIziU7nZv8EFSaQ27FM2nQQM2NMBkJsxs2KqEWF6Ft0xBcyi2fo9Lhd3EZ9Z8Ly8tkvSWGDiaAw641vmiJ/4+OHDqUxJHVuadTk/u4FnJVUuDBM4ikrEBVdMK3Vqpxg+9nUmjWRl2b7+M4Yp+x+vsi9LI8eV8UTVY9wO7LGOprchvFOnxt+aAL8IoqRKRF4lspChjHqBTfHpQy8SkqTaAZOyt2EtFYUZB578TDKzL86Bh5GB7FlkQAlNRlKMCo06T2dTBzOZRisL/BiAsNlQNY0cfiE4q5/wlN6h4b3FiScMd0g6i+0u4DvAIGQGp44+wa84DQ9AvHiLdwVtFS1GxWSRw3f+1KkK5Mb6opnFApaSwO2brMrXmIds4mUNzZWrPiPdnGzKfHeGQegqjVrwaTT4kfOM7iWk1Yh7ixl0CzxjJvL/8z//cxvtKTyJLcwv0Lfm01Zm7chPVaPRy45n8WFu+titMYEhYPcfcK5/9avfZC/BNW/ALRTYNN+LYrwZvJgnRB0J2mJPWWRi1jFfl4jYW9SYBMxY//jHPyaq2YUFSsLV2N3b//TTpa3NPQyA97REYsRzRExnPlwzZq9wrk11JfDJqXlRm27pcHY2lPF9+vTpi++/U1ILy0oR+0YJjchv7A4fyebsUhiwGFUFdp3iZH97CzN2fJNG1WdqLbs3y9B3nUoRARY7+1E5kabhcnWh+olt4xITnvbv2pUklxTMgCQeET8RlQ6PeMJdv/hxfoXoUguAFAYfJKkwqZKaYsOH1wJBwItwODMPk5Eaq2JrybTBtTGX1XaJ9ou48M+EnUSTudJNONiwlV5qmB9xvrN3YAumtXWjXH99biBfxeEhBceNDekmb+GanpvlVNBgAyhDJ3e7O/NiEk2KTSZ2v+0e7ONAhEfASupXzcnobXFIJ4iMckgX8bMNNAkKinl4tM+wUSFjRiZSe3CrzPLKoj3Fpijomb6dtwtmZ3dLImnAQALMOkEhxAVgK8mKbvEjRJAjbuoLUmDOxMlX3havhoo3cQx4BbgbDwAShq1/8tAx2d0MzsVlgU2ltGWkwbIweIhCiASEB3bl1B3unlhS5U2dw2zzqDnZrlOb9O1d29zeimNYUxzYUKGWLuZnZt+8fMHN1540IveI2ZiZi5hd5W04ODo2PzVjf/4SD92xnaPj1cWlx/fvPX34YG1lxQZt3aFSw6YsZE5QnvhUBIkiWr6LGPUQaH3xxReaEHi1hn/AglW7mjC4MEg2oa72feTQJJFAAmoWZng0F3ZXooG8uiBV18vYpwQzKUlXHELTkAknSpuzl+OUpBXJchE0hmgtWMN47cMROeKSQm6yQIkW+yWwJNYGmQxSDa3qjIuL2+GpLIDTKGqyUaGaAdQBw+BJAl3vkChvM+bZNespEYyUrjj4Ian2OOYsgupDwquUK96xWawhTZKEkSMEvn922uY+VPzCdDuA0PkqHbtmQ5fm5rSUbY0nZ5axGHgXSsW2Tk86ejKxsrTqCEKuHcZqHT3Ica7BIZUCCUgM4BMNpt6mqi6souE589lWFKq8OFfLnAw/ZQGg4vCDc1XTQu4TfDinyQolnQkCw9k30sme0NGRtZXVhfn5T5489f0Wvp1BLYTgl5YW1tZWYJZLFl/zxZWf+BGIt2kFW83oEqzI559/bjCUK52PTOxkHJwppqurp5883t/b9fEyd5JZQrcvOjdAcGXPb48QsSNuo1Pq2j53Mjs3s+dWjMFBNpfqtkFgDTAgEQMiWzvKrtfXt0bwqZ2xsYPj3LWOK/aa2QEJXuiKxgk5SPQkMU8BKvhlEQHgLTxUQkPuMorT+e2dfNGIEMTlEiEl6gGlDp9KuqNCP0RrVBzbyfdV6VrEwb5j3jyXETKMT9Ek0WAvxWGHi6TQxgHsrLZE5fETN/0KpLh0GEB2afFHNSV6q9lTWVM9ruyQosyyiwAWV9pO8VMuOL0S4IEBpLcdWtcJEVdED5ICgSQjeZEAzCKII6pKWBmQhCUdZgFwP5URXdn9bLodhwotmGEA0xnRDYnzi5aydOWVEUWVBwZa8OLIiQhhpuYHgcEmHRJBoeAXUQryFCE0pGGWDtUdMyjKSO+3tnYg7LdIQCgu8JfB90RTD2zJmaPB3LCkzRgM8PDTY1udvB+fMO3IRFrChhYzC3VbDsPsLf2emZ71SQNEffPk3evXc7MLM64Cnpocc1nDiI+H2OVJgfzIthz7+WyGM2NjFcCs0dzC0hEVP9xXKAKBkBkhB+0k7NZwUa3hhHZGE2wtN6UjP7swknZrgRLb9AMGZdG8FbzwpCWPDGTrOvlAJp306KXZJ6+k6MxUqMIStQBAO1BTXimviyoImbgUmQAxIMJCwYoQPGAg98Fk911oZFzBS1epuf6eez4ag9KcKBeEKDIQuemspkS8ktgw2Gt9Lvps5e2QpZkEA8ArEVnwIzS3/aprH3DDI6dEZMizpnIEohSdqB5kBNbkZE9Fl6VjcSA31aD7tObCuXXczzSaTfy815yyTEP3W0lG6uIEo8RhTmt4u7xywIcnQSxUK9fk5YPz49tbu9xVtJpb8kFCxaFrqp6UUFeWbhpg8Kzdgcd2lfLWw43+1xZbGeVSk2DgYZG5zjZtGrrKKGT7gRJc33z+6dOv/ub/tXbvvlNLnFymf3Q47jNanqM+54nRMuU0f3xiykYNyBElq+ww82lfX/U6PqUTaJVowwxO8Mz2/ejnf/qLX/zif/+b//fy2kPeldzm0YyW7A3lQI5p3FlKnDK8pDD07culFRQVUHXEhmrI45NWszUf1bO8suR4F41AyAwnAHH7l6y1gXSymugV/No0Vc4dYyRmMEtM5fVjqTXEz7yroYniEGnAqvclUsi9AlMFP5uZTpNJu67eooFLvGkp0Z/qIFssB6d75KZVspCO05ISAPYnVky4JVMNCYGmQXDQNVURMC2CLgyqTZJIiQw6SBtPA3dH7ZU2BiF4T9jkSt1nx2d6TsBS4JRXiir0Vlx2LVbEvrGNDTcSzysJU8JfxgZIWWAGHPWqBi9dlmZbRmKCTS5v/Wy2peBEvAUqHXUS8AQpSG9mQELldntPZp2vo+b40cjBTO7W9DUP6Z6anx3usPHTYIAHmJ8dDwkHLT/upBLBEs6BedUywYMio0WS2qFXYCR6K8jSHErB2G2JWIj0DX4NurDTXhq5CEHTjQdsOKXjGxrkpJuMxc/hybE9PJ8+ebwwPavlNwl3RCzM2ee5xFhrfk5LnQ4fWpMzuWiGVEeX7VS20zhUlanhoRnfEqjL+PDjsMDeER+KF76mpE5gOZ4rsrK07C2nnQ9CCJwsV1GQkG/3XV+e2akyNjkLwAVjOPclNy1/bXW16pHDeE6RDOSYofPDzP/yC+1ygUc79Iq9U+/ETw46jzvtB0M4DhUhZHDN2TFkHLpIMaXLoim2fAwRmBnjHUeAh69TWQROD3QltDHK6Y717KpKkGIvhzEjJCAFnAsi3nb87qfiqCyN1Nu7mio0qXFgHVeWqtX064JXnv3WhJWMKjZ3ZJRmyuItWynZYEBevWkrT2lXfPO0gmyHG4q9I4gyM5psrH65IkYA1n6hAsxih29xO7XsxtYez84zWLajMdvbHGqZVjyuCEjeg1x622ZG9hY465VV5RqkFs5MsXrV5VKEcFhbukleXsqjvryln9V3p+0LSspdnpleuD7f0aaNuRk6Vbj94cPCogucj83pWagwkbe8NP/44X2dgSlcR6+1FBMEvUcIuXLGFCsDDmxwtwlKO1VKvaEvSKpcNVNDDatW7qe4ePLwQe62do7Wh5TrWPK7928mJ+f1KMr+2Y8eLC2vfPvs+YfXr32h/rPPvnj35p3xhMPAhrzoaqf4Z7eUKIKo5oyoxOw4sstuavLkYJ9wFGdunCm7YCVUQrdf8Has4dv7OxvYygAAHunkpmmItHpIVxcN7JUq1HX5CQYeWbxVZJj9lKUjBIUlDQcenRkkYLQ1pjLLllJBQyZCcMFaWqJJhMVW9NjPW+0pXUxHBJG30lUnXJgADwnUImjA5ieTTbXEoQ2WCvKasevSNjmaAVhKB4lauHgTWlhIlwWnn5B7NnIAEkEKEEt3ykMNoSh4BS1U0gWSEhfklZFQPDsRGLSesgiwgVGvzS3SSgoAPLR4J1MA3sIGc5dXRmWXoiDAJIqkoBVgoDEcbYIS0SoMkHvshi4wAABxJeJVc46in553obWtVjecVMrbzFyenMFcTpU7mvZmcmatUdmcEKlCyyIa98HMPAhS8N9F7pLu7+ySxpNPn/rWOw7txMBVuR1OHqhuN/TEE1ReBoINwq2dc6bLzO+Jl1uRm6BaaPKS28rKWglkiKZKD+EqJuFE+7X+UmgM4If0GFVgflI/Fg3nBlQapBZFvC18tORSBZgHHJhSeil4ax0qJid1AKQNhpxFsJRy1XyCksZzrGWYYBgfx6HjslJcj2z8CwMqVZm3ph9dVeHoqbkCcbm6jgosvogsEr3CoH9K2uwB8OoOGGkBzw18h0cieHrVkLgVUeSuKWNskBKhJdguF8y+2OUuiSykZJsVBhDjbftwFVQsMrc/M+b2QovoSjT3LDrXUXCulw9GEnkm+nwDcXDMPQE6DZOH7vtXOaoFZiyhi7cqWsbuOHEUXGKXAp8KKN4SwGELTkShuiC6FomQgCnBRBmiBvRh6MbWi33elNkPRxPOTl2RZYb20f3733zzB5Oxf/rznz5+/Oj4ZH/PBGbu75xhcPAgThSlOedT00x8GNMW4FRTuGWlcEV9eDZG7OaUXISi7bKWent1HY/44MhmISMevOk2bOO0xXl37+D7779/9PjJ+uo9fZaVXVdFGTF8/fXXJhheH0aLSGdnZ295eUUdaYLcDgidq56bneaT0lYwmMGApwUIwsCW6RwSaPm0uMSx7dkR8eLcy5hlGgstGbYkwUhUUqUGyVLBDx6AnxLVRSfKBRgSwDhpU7O5ufv06UOOP/2RgvPbKWn5/YALCgRIVq3DKD2M1F4gT4jgRaO5BOynXIJELDZbcsWlqh5YcTLLXvcNwCxRXrkAa/CooNUpSDFb0pVHveKvy+OnXNLl0mgRajzSZeTYmJg2ZuSq89SsWFpTyHQ2QdsB7vT/4ZGb7nlwUqS30sAPYcsR8xJbWMoo0nHUBdPH/Ft9uCUHjmEfO+BKS/Gn1Vm0yEQEs1onD5Qde3iDCnviLUkRQUq/UooOwITURPVq7AgbqnoaHid3WQowDxlNv/gT8VZQBKsRgK2hEbHiKB1IT6Mpnm/aRuGHmZmzUYQkLcYqINK9vkb5ee6wWQIwy4ETk0LRCt/tsedVwZgkS9lp7OkDzExkwiF1qu9MefFjwG4h0ZNBscSSWxkuNJ49UEYk2rZmAN7yKhIYxhgMimylQ30iCokLoJzXJjwNstVXuYwD8INhAFpFk4OBbujZ2CnqBFiK0N+SBUnaAhiBEnLK/BkFkwwjAg9gvYt+kWTgVF65VBl4jJGGUnODs7Gvhu7SJd6pvSwRS3XhUMkS8h+bNH50YzzyrJPWCBIu6xI8wbuxY0d6HJlNQi7NyLy64wDpsf2xtcQOQy2pj91BGntCbpxkltkB4AxFfSimTmJL1LT0f9Z+/dkHy+hnj5MOwBQWl1tl1fyt4uB/YUFF+zrKiTai5ZZuZK7/Tg9bDkpNPhPOVoxPEqBEeIi3dIC4zHRVdZTcAliuMSEIgIkFOfAirZ+RVO2K8rZWp5MAmM5Y/fjmD7+zgedPf/pTe+9dJmZGnpcDgJLgGenGZj0SA8XG7fwz09H4Wbrc7/RxkqA05/Rwb7/5UUCGm0KaKNAWaovaDGDMsA960alqjHJRGKIwz+x4GiWkrkoHzLemqQrXAUuxp9PxsumhuH1oGpr+h3OH59YudAF4UrwWoCIILUZPOAXwwDqg3o20YaKNdZGlXP1JFQB4BkzagrxSOq+42sSbCBjVura2BAPSYAgH/G1fBB0httRQAuSniCDScXwIXsGlDIA7HXYmhkS8RUykawgMAAIS8QQGG8ICSCzeEVVmaLvk6hhbhKhNYhEt8DL6qQBSmgc1hIqAhCqBHJiI4aGGDbMUoUnAjJyfeG7SfjZaABIBQNivsOotHjqvdJDi3opgDLAyYtgTY9I9m4REoXFC26GrB06VoRSNnEz8ZJKayc4isd8iJNLI1fcdCcBgACPXRBUfgHVjjCEnTgh4aIE3EibGfAI2qB0ZGvextjAoI8x42LQ/7uVL6S9ePHv35qWZFvNAp65mzsVV1mWP+QP2BTEc+kKnw0TMw/gSqaDq0cIMrnT04s2SqsEt5LjChhbRigtAyl0RRDCGmRZsp8OgmNLbEkFl8VBilxEtSFpEMgoIIQG/Eulb/AQpgJSXNOCRiIcmJwKbdmsgIwIbYGBwEpEUeDzx6SlRuKsOKVB1imeTbjYg97P58ZTFT2ixIaI4EIr4KaOnIAvqntDKAlhcxmbGK0zeSVii0LwpLM3Mxd0ucOBLWXP2Wd8j+wAOXK1qTPZxYjWjFrafvhBSbHTtQcQoKmFwgGIPuzzVAoBOmiz9mTrFmyFEF7PVr7Wlmex0xSG3rqnWLmau0KZLAINb5RXvKu5XXXbPakT2HTn6Zbkic3zqxS6MYin2gUdiB45Byf7BLpYsIH391VdGEqhwvXFFCMQlUk0+Em7pSUFU1ePtd7/7nRl5d/pzVi1pqN8wf+3eu+PPPv9EHJKqLDf25NZ0XwSL5tgId3G5v3fY2z1I2qvvvvvO5I85uk8//fTzz7/Qt5MJzdSoiQst2DTqo8MT6fin6TKSkkQ4ESIQHEoREO0gL4bBiwgSCU2QIk5K4jB7JUVohukG5BogGHFlB9PFJ8aWQGs1DCIowgNY6yaZZlWhoouQeg2FMhCcnxLDQmXwUwSAV/L7KShhFxJbTUyiCCT1Prs/C8GdunPbowr9FqNQNX5xRoCtRkLMHB92iazL1izhh+zgbAY80QWm5F6JN4cizRU2pPhJWAIYWSTK0kx2xuYc0S4veFSwAbgj0lWL7ksb07QOOeZmkJQRaNyybCMhEXF/EuWCU8CGJ9Jk7Sne/OCBEMRbUP1E7o4oi6kJywJGwJtXgoiMQq3o5SdJIievgJyFKnO4dJFaYBtmRHv+zRMb4WpyAm33u5EqYUIrL/0Q7LswhnBRFzCXOLoIXn0zFpYuyujnW1rZ81G6gRV21ohHT5BGS3/cQHB+ahC2urQst+Zs7JWBl27elB3Fu7pWDdZ+e5StRzEsODo6VD7zsqxA2IvZzQqhchWh+EqKg0nl6r6kf3bV4x+kQFBgYCA3kYwvqlOBBEzLjePvIgFyI4qWqrcaAEi5OOZWNeFpAwEVtFDJm2qo+hIn2E6X0lVQL28df/AAhE5sdWpUaKXuqhL7rRQAnnJ5CtI7ArJReeKH0yOIMHwEgltz39xeQcVpKWSSg6Z8f+ebTzIzbqyQYYcOCfp/IqEVZFCY+2806KusCyDbG2AODg9cNUoaZIuEUuiBJ6ayDwJj0nHl2b0RZlQWUQDDhukOjqmf4lJEALfk/QSppF1l+IdQvBGKA1NMKZak6+zVgG2phi7TUxNcGa8sHhiYOkdmn4B2RpkVmSTZB3afxJATWpiURARaDBAO5H/3D1+Zc70rhQPnXExWG6trn33+4y++dIMvx4UG0mQbzyzqAgYDA2wS4eEbUZW11XvajrwK7Q446Vub244IiKgauTCjXFhmKNhZZfdTkXGLq647aLvivO0ab87FRST2T0ikCOqCtBu5vBAC8BbRBiBegoKTEFqLGrN0YPKiLrtcUvCpUCC9iiJhzD8/5PG7xBgVwavQxDQYOYHJTAryi0sBDwBqfCDcEQCyA1CjWKSa1I+eIAGhRGUQByNeagCHUjEpbIQ3Q/dW11SwGRs/DJ8UjO1AWqfNCtiuIJt4qtx12yNZQ4a5xQHAMI3ThDcstaQwg4ann7CJyytgWCJagkhrdstOiQDDEBWsOFULc3XXGxjwUKHSdeCVyF3BjSUr5Z9sNFqCymg+QcoOSffV8MDsiRMwSoE9EaXGleBqKdm1hC4CWvJig50286hEgN++e+feLMub6/fura6vsvXmeez8gyQM8xMdxRwZNhvw/M0rXzI1U2yexFU42qxJWD2CBWCHZ3hg46yL9cFM1/i+YybmfAE83xVh9PWEbop3F+NBjrnsbG3bHuq2WFvpeG424Av4UXzVpJj0pIXfdaTRYj6i80USYdJgcUoXemzEYWaWnpharg1LSk2tyMH8jIJAaDHQU8EhJCgCKSFEQ2xcj3zdMlFDKHRRIWriopDegMctSBhEYMAY4PfvP+jDiBF8KaGd8mHMsAeA7OC9csv2qWsKfAWXTtaHrOmGeOZrSk/AtGITtRSMNQ/AxL0CAN6rrEJWFomtorIoprgUwFgVJz1sdy6osIptK3glloxv+Pv7R4fu9rCDyfxP9s7cuDvdN5ado4n7n7ssQ7N6l+yxKrppiGnsWKCvWpYIE8sma+Vw0hPMaEFIuCub4uGh2SM9AZ5u+13AlKjcL5x7ZR6pax+VLqAssgNuTjxbVt6KS7/y4fVcgj5EFRb6nJSrSCnZyfHu5saDtWWXUpj9t1GJkqysrmWmazDfYFAyBWEokEAdFRVH2Oo9i+BVBT5kd+/eA/J49ead9/OLmQCxLZiWujZ8YG//yZNHbmaz8HByeEDAphldSqfJ2DZZHGaq015J89HKBb/saZCmg1bWnJhZWFoU1yVoOSpuYmRic3Mb2OH+EW3UYSgsDacBYFSpiW1obTKyL0OZxTtA3nXd8iQZQYqgiJoUBZACuLUCmFLb0ffu3baSsk5egYGHSJVOXFtjuplrcWwDU6fYkA4Ak1xtvampQB/lOM0+UWep3Vh9mZOfRlvdfuBUU3t2DuXCKR8KzX4eGhAJ1qXKWEwtVi8iEbvkgz8E8CSCb1vv4026O2x2mp/I1fHnuwGz9tefnDMxTL+IK0Elmu01A2xic2p8bMZEoH2HqKZduslkhG/n/gPOKB/TJLwFz/v319Uch4PPjW2GjMnyp7T4wRuWlB+fzQ8rdnmWT17AxopxVDUD1xL4MwHKwPGD8GMvoGVqmsT50kRk1obospYtMjszA7sOTQEJHWYyIYTSEjAmTE7N4haRIVcf2wZjUcK0OAACxBLTjyVMxvien5gQN2NuqpFDQTM4Qfa3uJaWatqoYOmC4581jPGsLbNZRh9uoTrUJs4vHOMyUbOwvMBbHx0fefP+jQs7ndzlSKldVCi03e4axfD4GKuxf3z0bmdzeHJ87/jQJP7i/VWnbRy63N56f368d3V0MHR2vPHy2dnh7sXxwc7W+90Pb67NyF+dW5k1sr06Ph0fGiEu8w772zvXp+7jVX+XZkD1S/YUUU0Ew4y2dHpkylTBc7uLCaj9+OC+xLB3cGgbiSM5blwZcysUWz82vpdPsmSXHIPGYdfPuMJF5dlmenh07K2FDwCcSNbMNnh+kQri05jktqXd7ut8FMGqz9GBeuQfUEXkfDvFMVGfddjddoDk0KqNv8zNn56Tts1CvmyvZWb+xnaRuXlqEyPiLqX4nAMzdGVm0tMMysllOgZ7vHFovonZwq27kpkNdsmfMRPtVDs2z3gipfnZ45ivQPiOUW7EUgLz9Vd6At2tiMTUaTyy+HQ0lgJ6KxfsjIX1B3vkpUP18s1ri1IstZuN9w5ye/LOwf7bdx/eb2zab22t3DeDMz83MZ3dto7sOAHg+occDyYsu1aoHtufj4JlHcmt16fHu1vb5oy0ADXC49ITY956IA5skKd+7lSgv+pOs8MaQnA53lcGh4BvrK2Zw3Gax6oYNXMiNhtN69Y89LQGpefM8FumfBHMGcPhEfdocepnZqeI0OdGfd3Cd0LtKBvP0tLEtU+UnRz/2U9/cna4bwipz9072rczd2BsZu/Yuram6Apbe1p24acd2lT5BN4Mu5yQPNspNl+krufmFlfXfNtjbGNn+8P2JjG2cXME7cnDRxqX4YM8VjZSn7kNN9OkdCvTZdcD5kDhh/Po5HD9/tq7D29dUqVmP/viCxu1vv3+B2DI6aE/vH9vb+gxJXc1QDkQzpBMUK2BARL27TAKqQ9hyHl2iM4Y3fIDyh6SmvPIxhaxK+eXVq/3Do6M2ZnZubkpUmb6M0r1SYx94+abZ8/ePn362BFgCqkJ7GUL74w1Gq3G8gM3hRFQx9S4hixZwjRk55HD08VhzZwwMhYwyjBldmvHWTRXf2vA7d0wnUSsSQsi0dR/GlHGZ+nQdtDTT08EgqcH5mPD2zunooRrDdoSMia0MRVG6XPYxOZim7d8/mmCUZpIL1I+VGwuhOU7wAg4vkQNM8V18fCDzD7cWnVAVF4Bq1XOrIISXDPT/CiCvkHn1L2UDhCAQCiyQAvA0whYrnQhtVYOp7cOuTx79qx92Jcv3z14sAoneE9BLkE/xG/DJDXyISpoGXowxCIRwyXIbHchSblwDjkw6bJ7ggHpFa4iwNKPo+OsT3JmuczpWdMfZTpCHJ+Cn47b6ljYv4Goa4LGz8fHgLEEBeUSOQ6j2bvN4+/+4R9+9MWXC7Y5X10eHWbGyUd5UN3b2j7c3jWTY7prYCQTO9RzYnJqgBGpPTn2y/Nm7d7Ra2rG7lhfml2kLdwIpup0aFizUU10TteiIHTHyiTdImqaXa6DLwpw5OtsvonpfErphtOqq8vysbsHznidNp7StytF9p1xUlJYFpAQCmcWaa2rRj45V0/Z6EcqTqmNy/S15mFVMUG1SGXU7DlEdpvIS+Ygldqq/uFRRujcf/h1Q7G/OZaU2kTUk2xVluCgqS2wIKVHvNlnkhsSZU/9mr32++NsiYiALlMOCRhPFlCi//2pPfCVqLih0q9S5RX31kHRxulVFdf/NxkH1ISDupu4mZSeEZkbzQDn/uTc5WcuCHv+BBiElClDDn1oho9W4r2yeGW1PvSyl+w4/qmv0NgwUzMPk4ZN+3soZ+bF128qKJAitzJ3XXhCCDUk3mo0xKzysErPJRpCqsGoRPVhpKdSpGsqpv8pO//RXUyS8/W4yOpCrzc9s7j9/LXBgUuTDXiGJ3XNi5dTg8+evViaX7D4QV8QdTe5mca5hdm+a8iMy8W43Z8Zxl0cpx29efPuT372cyUgX+781MSYyWb+v8+Tnm5v/PEf/7ETZ19/63boaW0y35O4OjHWpK7njBIRm2Z0HemNDW9HTM38whzZGei6tpXYV9bWORIstZ6AbnEy9na2faDJIgPXxOKngm/bAJ35hsyu+7qcVQ1TTiabaJSRGlkhoZGqMsURb5XwbEEZnEmUN/VVy42KJm5/hi4HDOEvLS1TaRpOEVkqS0HqN7VQx+k1oqqXjCltFpdXsP2JCy+v+TLeB9I1VnXAeiST1yCQhF1OEW+VgVdjrK1eC0ONZ8vwRStLY9Kiyt2GV/EwpBHCZq2Ke26MqUGx+8AEmOHkKdD4ViCQ0imNJ6LYle7Z5ad2pOkV6qWKmWaR2PF+YqO1E5KO4Ly4i8UUIMQVQuAx0NmxKk6CDJnglSwKIi/SAqKe5EgtiNVbuwBQF/HPn2Ya1AUse4urGbijDh4IQs0/cl61EDzFe25NduyhgpaIqSt/APpcFVabLlSKc1dBKAPuwoo3IbnASzT3IJc4gctlHvP7Zz8oafBX4FhojRhQRnfv7B/t+6YTM1pduQ3pZ85MHuzv8VhJxRqdgZcPOmq6Nt2at9EG5EXIUFQdET4jhbeuLPMJPppnVlrnxEcGMD8z59rnhVnrDkq5bAWSjeBw4C1qd3GZMwfmfG1YPO8OzHHCfYVSCoOkD1ubRvHKIqAiKGnEEnOaRuLCA84OV1ScYJW084IXwR4RySKjWpCIz+Qq7YVBQQRTKv6wI4tKYLsNDQUpBZw+3k81RaUhEYfBEwaYPQ2m4fFKXC6hJoFCkCvXbPN+7KxqtKh0XrlabVIi/nqFVifS06aKpWiyglCYmIcqO9R3WocZP/Wp/sys6Wmh6epG7g4MKsVpN0V6Nxwpd60guD+WArD4R24z6yLuCW2X0dsuu5+dgkMYIEQRMIBOhwo/nlDwwSWCLCMYAYorOfPb+AkZlbTcmiaFxJYhYDyVqotUHwBgjZyU/ITfTxc7Iw2h7DJ2xI2QuGqlcpsvKgKJ0Vva0kUGzMKayo+Eq/n3K2CNROThw/u2+2gCsqPVLUhGE9GAtSYwsksRSIaHwzpzzHn5tACHBK7VQGilzX5CSGRpGWKDfKT4KSDhp9DxdFHltmJSBJgCyqKwzXAn6g9klIiBFiPJAEbXU8VBGjJYAQG0aKWLFmkhwtsAd1XYkgUMTJARYfSAKYmMUEtHTxZSpl6CREdBAZNLl7xJYEL2Bm4FJQJg4sAEGXECRqSDOELIiSAExk9BLnigReIjbMy09A4SodXsRWTHcxfZT0ojL9Li0ApdQImanEQFkSg7q8edgRYG6Y3fq47zPaT4SfQCGAEqT+ki+BQHgCUR/JMSnhsDlqQDw0mnqCoRABI7S3PYCJuWdBnF77CRmACSp6xoIrA63GmkT9VMR37zzTdxZq0W8jFOzp2G5ULw38cmRxn0g8M9+6le146gIxtE9neZJx+ce/3yxcuXL7QTc1y25dmXrTOg/BYh4dFavLLf00EEszaMuMKSHsZMT6oGUxTuV6FRgtYiiGgqzLoylhNjrpNNyblCpoNXKEICCkggCiKiRlr7vWokMIj4CRRGOzdkAU9iIt6SVdeOn/hs+aPol5TWupYkfvAsBSEpIEVUUMsQMDyCxP86IASbZ6t0V6jsUtSIpzh4b/3EGADwAlTeetU4GxLRVhK5hNArirLrbOQyUIbEjIu3WJULQl4za8wZASYgdMdhoQkDIhxn8IKfTQhCcfCoyEhtpHhFnHp7kNI97wriJzxgAHec0KSIw6N2PHElpXQwhhgA0fmpRXjb8H56paRSxJGDUwQG6ZabESUhnqQvXblSbXNjw0ypIbj01OPFqTMoBEIaEBKIfSNV6QNsK2Z4AJ4glYVBAIOQ6sf26vqadEKT/csvv1S5lEQBpWS1rw5YibPjK0src7UAYKldilxC7wqlhJ989un6/XsT3HkrCQ4GGATMLzi56E4IJt4gWPsiP+5/e04woN7CxCp+cIg9QzqRFjsYQvCTEOgq+cjSwkealPwkIsAwiJA0dwywdLkUs6mogoZRumoZ0XN4+kkgqMgVB6QEFc2goub1YBHE/cUfMzR2/sWHoFtTy9zLiTwUuMclSt76KYKGguFGkIghHJiC8EpXT9Ayxl2rwiMUOGPXmjTUjCOpUh2vGqGfzbcUee8IIZ128tG/ABZWSxAyioPvnyFRFhZRVc6UNwAXGWM4JA7seYtQowUPxk+Tm3ovePCmIOogqwIVmnlPLMneWcCwqGRSfDLieSs7MAjNExhyQduhKwYyeWV0vZIUkxoMcbY9DA9TQexBYu5eDalab2kVJiEUYJYdttbsRotJAOiqUwPkKxO39ZFCBTeh7SoeV1P96je//vNf/OnM+vrBQT51bbhoW+fO1hZLzb9vzWMAlf3Ize8kXV8dtthgqsFI3UICCbEPzDIYrLoogiM/bfV5dMxGKcsDFi9wRzJkrlPxhpxNYg358DqdUstVcPOuOK1i6jACb+pWaFNi0KpQmmVsvcGzk77lQ6AIUsaQpsTsV2zahHG3KXKCoirkQOast6dNXC0xkJqVP4lIOLkDD3IkxjySJ4CqL8gHTNvXzEqaFuwgzei4HiQ/h9w6b2asuhYLU3UKJJ44SbjbKssaFtMtVKWOBNlx2zx42oJTieaDYpUzgSOVb8hyqPE+P5UpaW0j7citnN731ArOR+J/ZwSk1Vkx0J6aAfP6tUTmkj0FsqaboCeOoAbHbNOXiQxPz3t1N6gVSr1oLwpu0UWHTRrl4hjH337whBGq7kPHEHut6TMUdZQTp7kuZcSG8jTcNKL8V61J1fgpD6OD+ZJw7JS3YV67GLo55fdbdJnPTBRFUokT0zO+bnOVSawc7+C7c7vgyeKcTx2csvXZgd04e4bk+Pxsem5RjUcZqrkpTrKQk8n98Qlr3KEYA5V6p+p2PGBJm6RaTPmRW46PjqfGJ51tjMhublxz4pZbvEElC5loPm4EgtYqDpW2dGpKyZZQnPB7DNfUsbZJ9yzZGJeZ4pcR8o0P73UuUJGN/UVv37/XBuO5mxpdWuJpAYNEeXGkhyMKumxcTrEdhkdRUC5PAPCLaA3qi0jn56cligvanXRrAG09ZNGsSCSJ1Y054COL7AqIIpaikWJtLjvup9eYuKswqAFEKqXHwDog0IHclQGYdCmNUHYtUK0g79nuMAA2FwwJwgam2ypGgUkwR9kSB9kM4BJCbbXxyyW7uIz0QPwuRaQL4m2LzFt4Ol0VCjgR8CA7tM0w5rUBb/0UlB0e1EX0WKZf/JRLEcjRAhF4r4QWpWfHTSqDRJ1ARCSKC4oAbYNJxzYMzXYTbU7AtAb3EwyiCk5WUIE37UjPvBUAS8GkALMUPzsx5awBQbt78pr999b5nT1zmYcnbne2x/nN67fsYC568p16N/TVLPGH7Z2Xr19v7eyoO5uEXCFmb8/Bzt6bV693tjb4/ebsyGTj/fsDX6BWNlbfR2Nzpcvl/PTM+vKKvVusv6cNQpqZgYJA3bGhmJamzYSqbgGTpKFLw3ZXsVIojlVZhkDxtX87r0lAXsDeljjLv6sdaJgU4Kc8FdL1QgWtduVMOFb91HSRkAiYHGCGypPc1Knq8LZChCwdFbmktFSbVT9VhxRKleyjaZDhv/paWeTtIC+Gm0TDyyJ4C745BHBLsmoWmCCleQMMOXhgntL99IQ5dhBjvjpbPuns7LxupvrTG/ZCn9OdLhiMdXbPjlRClLbJNZX+iS4YcQXx1k+sKqNlW4lQ+dlyaFRdUlQUp+PAunQiBAVD848KnCqxq0m6OBLAvFIKYH6yd+5ZgQF+P3ml+kIw8uqTCIMzxDWBuGsBSwLqYGBQs36yoRpIvck9ENo4xVOgpaVFYKQnkVbu7+2xU2T14c0b+I3pZdEj4RB7TDCVYCI4ZJHJAI972iqLkSXOBWi9NQ4wbfzQXYqLi0phF4PmaReCJfR79+/zeLIkbovOwjwnAlr3MaGigLjFFXUVSYWWvlm2FVpWLRA/8SZ0Vfar/kmf2QQpnFFgmBQaswLKTixkKCOxwG+zA+CWm9JJ9NYTEpVEsaiUykirICbZkKkZC6jKIbpONXsLixCPglrWyiAXyLiMGTBpYCFZeciCEXeAmxPmZ1nvtED8WaxqjZFOxMUxB8pAM1VocIyh8pFz9ByMxI4Qepc8DFUnhA2vPLUMJaGaEOKQiBsmHk9pGNFIbAGBN6IigsYWz3p/XyLRcAQ8SROHvBvwGEipR30+YgNOh61YE2AiyAGAP8NwK0Qmi/lKNL6mesx+E2lN9cYoAAMsgg04lXpm5nbAi+KF1bs6ve2JXPMpnQW0BWF7d4dMsGSiztaii2N7fmYQggrbIpB3eZUIcunwgBekwwZG40KUnV1YXLreubJ7ZG11mRv4h++/++Tpkwdrq3oA2+AUwSKz5nVwcupO1NzSaMnnfMnCmRU037VjXG1EB6CXttPKZpaNd+9Vt/3T8GMePTWlj1xbXM6R6XOOW1bf3IhCy9xWj+cUkLiqlvBoGTgrwbVG52kyirx0C6jYk6OI4M0sZdhxebk6kflNJRI0yxSSnXQrXQWQ/teO5ucXAGjMc3Pz2LOwYDTrbDHhKANBaZnJceXDcT6w7KKhdAyyo6hJ4jlMcv8qEKN5+NKmMORn6r2ETOAAM86ylHWTWbhqQCK3fT881Z6iKsmLFU54rr5V6bGzsCmXimrMENJAfJpSodjFhm+7pD02MAAlivGq6aCsA48MZ8eYT0PWaoFGJhdsHRyxQPrqpqZo6lYgtCx9M22omMfztOIS5clm0HP7Pqs7jNdOQthDSOk8oQAskYEwzKq39jKlXpo3bUHHLp3wtT3AVfx8XAYP5OBnJzaHJKL+3T7bLZdU6K92k1uGFMgx2i61kwrsABpj4xsf3tqABwnDr0lEDUzQuWDK1U8qoLpJBfeeMCK0URfJveHbTWd/oP0LblxfNutniGltbWJ2yhYuZ1+cM7DH6dHT5SHbso5v9g72Nr7/3jUZi4sP7EDc3Np7+/6tryGpGlbbs7XL2gpamqetPjUC5ZtHksdZMTvED1G4L2xu5tZJxapEph8GS9NzczkayYLPLy7grcvSAs8ov3oyNaK6JdLPErho1A88Qt762U0PKnEwd+mELCWyyihhntsq18RMJtCApVqHh3UMqXw/IMWBd+Jei0gRgcVTQMbTVja3h5hRgFqQSCOld15PiVi5reDSYAiRxyswpgEAIUpsvenCtDvDLuNVL8IoV3pUmXKwKTp/gyyJLX3pIJWHXNwyHlZqWOCJEOZx0jwgKsiIYpcODA6RAAOzCgAghb2QtwMBINQZNVhZkFNz4FHEeZODtgmJAG6h6ewBAINTLghxQkvA+NniInNOjZ+KLCKj7BLt0YAZJ7J4BUMrXC4zKfy0AXIZhS7UP5W0VhdkBwOV0FI6PT5UFpKPL3z2LnNKw8NvXr9D7NXrt/b8mbtk8LJtcSJDN9d7jttEeHWpSVnc5Vpn/v7q3CZWW2jMvO5u7TIwPt5iYALnh/dvT45nexrHFJ9t/IMu/dZ6LhT2cm5xadjmjesrg+WzCxNNYzmjysurXSi4rWDv0CUtVHDSUHCaxZkazTWXbtPNpSXWjDlcSk2wqlLZrfT6aca7pQcPEQnAlEJGMOYxCGFnb0fFQd66JMWKgWeO0d447JNFPyyRmI2b4pQFBk1Q8JMXbOyHCnJqU2K1GB4Szb81tWgJXqkOAaSMfmof1KLiBVGWME07Chmb5hVamJfimRKVHZdXkAJAB9ChYZRF/4LhZOdU1tuwd5OT0hxVuFP7YYGJjAftyqhgKMMKfwqinRXRLhdIJpeWahf4KTayRY3r49Yzb2vkYy05PGtPmh7DAaXs9TYrZwL52I0mgj14qszpxsAjLy9VBKMulMIPm8tsDaCxelgwat/u3ovD8YujQx4p82RHtWMOc9MZMZjVMrMGTOuH2Z0DDK5S4IFNtuVA/w1Mz8o11ZnTDKQRAmCoCjKKRz3zzLHwDx82XXwrHcytV5dePFfLHOsKkLnmXGS5xT4FO6mXV1eOj04+/+IzCH0UT0UbZa6sPWDfTo+zR+hgbyez2WOjg9fD9jEDsNfYEV2orFg4LkNnrDuQmlGEehFaUJjWlBDyk/TIXxD3dA5NYVHEp7KLA8MwPRfXWMhTpFt9jqzas3F+1qVGV0aGC4xpDF9aRkh3CJiqUC/mJdNDyPQLcKjKo4ZK+ePIeKuvM+505S/anBft3JqMDp+kuA/8X+N9e7NswZbupz9DfR4lGIWEHBJUYcM3JRCXiEoJIZM56BIB5oRmwOqOXBKVnGbgjUBhuGNYsSGJOGZs4TKJe2mRU9xfx61MZiGId5l520sV4wmJvoQoKahADwQU0fKkcyoAe/0TCQx4agzotnzwEJmenPLJ+5WJETudHe6o3SzxBMErWjSgJp3wqUqk4BZ+hHrAQQLiYEigm42IvAK3V8HpFsnIKwKgGYZWLpCYhFM6tLjy7ERPjElHV5AOiafRqAjIpZVlI+7/9F/+/xvbO/alZ0PjUKa7V9YfLK7em5tf/uyzH9m3NTM1M3w9dHpwYpPuwMWN4y2jwz5wMbc8t8S13NvcvT67MlS5th68s+v6eTugbSTd2dj0PNjed0QgrpFVEOeSjk5m1buqHhll/TGjCH1oQ2Gxavfn7sGug2l2mLIzqszox5KDgogrOCEwT8qrHzKMMo7RjAlQvYAhChXNhDFYhvbgoSVu14mQgIaKItUyVWIhwejB4S9N2jyidD2Zj4yrFYe9WntNs9gv6AO7rqChyer6cG+XWeGXGepwPKrLiB8gu+rAFZXAhoC0RPXl2VqkpMTeHFJO3Rnt46mz3oauDDVHlf+um/S0S4QrKy9U8GMej4yZiWzapVBd6UrqyEXjJwREqZ8zBnpieQVEPY3OjdHhwQCdlwiDZy+QakD+8H/XHvVBCvjZJ59SaVN/tj7TFmUJ86anp6ZdpKMi8Ka8GovOCWM7u9sZCdcWFE/A2AaGARHAElkcEaoOT6qp/Gik/Uy/VRMMqtIXHNw0qLyQ2NvuTbGXD+oxWObTwXDaJPa+UiaV8NuLQhHathgEAieKXpEPbKqthYAZkKw/DCRP2aBlSVkfI4NcFjU9qdfn/FABz72P17eYWIdz48Mm+PgWVzcaKZxffv6Z7EjzPAkZLT9Zfmf0CJYQiu0YHKbGW1y1zVEvmJcOiewiUlhIWaSQjAUDxUG0a02iV+KKIJE+k4b43l4mNtWImoX88NBiQ2wjDCKYEcEqErLILq8qQE6nFS8YXj+8IFYRr5GREzpIGikUKIFESZAoBTxIEajhQbL5kw4JDCLO/4jIkoaqqyjMTdFTlqKSThKMFL0uhOJSAAuQAPOUKMDWzIjjj4C0fG87V2OGM95EWVXpEgWih4cRIf0wVltHCAIJb+k6nvUNJEBjVAxh4UEbkVEibMBEIOQv6AhlBEaINMMrAFjCLFEoLBOPlkRokRPXkGTHQw87WobE3hyWwGNKpKOISdjwUPE5T2BweguJn95iT6IUwU95IZHorRRxEQxoYBJN1DB8B8d72raTbI5fOXfzj1/99umjx1NLk5qBbbBYdQP7X/9P6+vLq7/59//+h6++PjTwUjoO+YAe74JRmZiZrqn/8SunY09POKw+VwP/4fABL9wpD4ZJefWOu9XmOe+GBS4Vere9O+62LJ+x5a7lmNTwDYt1fq5v39/d5qEQWiYX+a3DDgBnpMVl2Ns7JE+MKYWUlrmiKSxJtk8kXfEBeGrSI5lWjeNmARnM5uYGYUIrhcaQDOMrSyIVaLaMoiaFBJouDr84RASIVKYrTA85JqlzyiRh7hTxXRPyR1flYlJVgsGq7M0n7VJAiV5FEy6ztUajwU927kfPU1+0TFxliaGodAyreObHamiYwqYx3X5NMK8qELI2XvtT0+CFTIxl4TQ4gCAtaKt+emuh2QSUdGX3T3sUYMMwxvAMhkh7lUtBNCJ9I8vCbcC/jAqisOANJQHIjjcmBm/wyK7igGnwKUQNy5qTlie6IV2M9XPKZNRN5g/390+2t3YMFjhqZnsOLo7HbeZp3vTVZ+fTc5mh842Y7T0qd2DlW/tj8nf3M21FpDbhNBXNQxswx6ZEzr3s7+7eu79e5p7BGNY2tP3s27ErZowrMKHtm9AmOJX44s3W3NyKk6fvPzhaPz87vwLs5OISfvM2jv6Sgw/1GHpqm8Ty+uXz//aX/8LixA/ffYcNjav21AxS+0GXKQ2N2ED94P5DIyxq5Vp7NadXwCdxCan0+iq1ZYaWsEQiIs/QtS5dzij54FwuEcx3rfmpyVjAsJr2/PmHpaV4zABmXJ9d+5qAKZFralQZtODtSwDQeABnG7c+n5DttVIvIqXoWQ9RfTrvmv6jOpmv6y6gmZZZgOsugi2Kop+hNBLR9pZWeQqUgGLRG4XsV+giAT/d7iskc5KmT6mUJkGC0ZYFosof3anQKuVJTI1cnLzEUUEUlCzIoRV1LO0Xl0giYFSen8QEA7DIurYb6n6loNUeHAZE7BmAUEavBM0m52AvL/UWezu72qrGgIpN61wG+yDYt6y+1qkiGJoHuoiumiABrOXqhSuuYr5VAgAYzM2zCG179OSxmVDzg/cfPmDUeIXcdk5iyxY8iuIYg7kLDo+S3hXcq3CVKXDzq4Mm5akL5AqCeblo3m/+/u/eb25wwOA3NFDTTqYur6yY5iAsqmGfi+GdTt6kkP0aWxsfXj17/u1vf2/2zWEWjpCO17mw2ckJOx+Ojw5dDsHsctwwwzDl5+s3W25cUBiD+cPj3Q+bO+83PI9396VcnZy5p9rqsb7AlDQXbG97J13U9Q1/E6vBU7WsXLpH3TjmVVAXU60BMP5j11QiCTO/5kFsBHT2EhjJsMLCmV357uD8uAWilnlyoz2JCQQFmFQF5ARUWrxJr28SkCKiyLkjQVthknNAFy2T3AM3bi7LctCVqyWH56YdHJ7Jx2BrNRg2zdhTXpqoG6YhfSsnuqgzChpMruipswVSQHrVb9VjlxeGWLQy3JD7Kd3Q03l50yE6qZoIiRHXoFnPuum+CwebtRa0dAliEjXwuAhItCSJmgAVmX4ayLkm014XQoitdDbYWYKBa+t8zu6qAWP1Tz/5hA6cmPs4zrEjvb4VUYqNevPfsuoiSGzBiqRUH3smxWxzhvrc3HT8cWfXr50Y3dRCjeSgEjQWQzHzPwImF8yeO1p8cKjdWsLHJDw41A+paKi061Z+6eDfvHkNiVcgq4HrOHJvOf3XHjHgYh8XYeFQcVYWF3QGfB4HsGdtMXV+u/pgNhl1Q8lyu3X/Now6yDJvXuXdm1crS4tqgcCUWl3z8OihDskuChve3r51lVDu+FpeXiQBoetOBKs9cyAjQlKwarIuUy6G1HWJMrrUWFkAKx0dYB90WuBVlp/ia2uzMCisFAUBDA94MBoFcoKfAmxEgRAYnWJKJY+cnd87KSQFIqoWJ0HfyBDfDgUANzrwYBBACaSfsEvpRM9OPN653X8KgBmS2BUGCQ5wj1wRioeCdZz4mcqotu0tMHmbT7Q6OxhB30XcemTA0psxMNBqaVI6I2xewRA51ugSq2BYAbXiFSReeaLlVXyvmmORPyJ29UXN/4SWhaBcCncELG2jFuVwDgkMKHKlycRbr6R36bCBB/DwN/9eCXL5Cdhbr0zfgZfdTx2D6kcRjFdqEWncUlwZxUFKB+mn9JJHHn7CKYi3ElgWMQ9AGOYDsm16MqzywDkdmxvbb9+8X19ag8pMhuGlCXDG9PjdO/MhMeu8wqGBsaGJk4tzZuVgV3U6Gjq2urDEfdBhP3v23db2hqkMi4P0Mltwjq+3d3bsxfQTD0oRGcJ7bAhxiWPdiospjLLxxI8zJzLsPsijSyZrembKNkgt3d/JFd9tz1dB8EYakVIt3sAJISundIQjXQdADuKeJoy0KURbOBq805tcE5pHj1LwiF2XaSEqgs121Aqw5ShtupbUvioTJJanAvHo4NUAu+OyDY2QeFVTa5Ri4gFmaJqlYi+1AADCqqIMVVkq7YuHiD3CLnjangk9VECKcPplbFSIdvsqXsJl2g8Q4NVDKDJzrsWrWfZCh0BEKpoTXoC3Jp4iwFPlyZgAk34K3clUGaP2qg4b2oWtW4pjTOYAiEt57BNTIm8pYWqhBpqcHl9qgkQZpXiyp4I4QkUsFg1yKtmRUPwYsBfxVu+uFLwlmVzdo/NmRBzCM3+yODdvDDuZyfSBA4tG7NLFxd7+DtJaAWYgLMlcY1DEnF2XBcIs3MdupArM15vEMyFMsGrBki+LYypZPdq0SWN1xhkE3Pw9nbTX2CzUxNio1THAU7NLrOSz5y/h4YptbGzZloYBY3E6yQVE57tvfv/zn//czk4GAAM+JpTWOjahp3cKxWn5Yd+QuLl69fKtUX14q24pxa+BrJ+kjaPeylVs364tKSCfXRaQQilnrDxmBJUiYMNcmVxS1J05eG5iVWXqwlt+MTAsCQ7K21tFDoJtU5kC8i41SqliTy291OAzvgxfcMR+DS4tNZbeXbt+HmTXJZ4qol1FZRlVvOquUQUDrbeeOENPgS3N1KskNhJFSlFy3DXusD9DQGi99YRTEBEUCTbp8Ejs7HIqs1fwEyLqMPtZ8duuBbAs4AF3XBZBHEIRuQAIqABjTIm633qSGhWBnzZovQBicXJh7ODi/AIAKRvvP6Qvrb2kqDSfYeks58ileNW+v69d97whVBLxKdJCkEsK/k23mAg+fJ/ZOn4Qb8gXKohvx+XmNdUIM+DmFgZZxC0d4ESARFlaXDAzTyhyQyansppEHTg4RioAWCaO/7MXzx/eu69yXc9iXKyYTODp0b6BuHtgjlS1S6IGB++trQxs5gu647zcq8EzW0M3Pmjanzx5dO/+yo5tpmYUBofebXzwdRUGzuYVN9U4q2lgZCiw8eEDN3luYdFJsIwZNHfLB9m9cm56eNxIPo0uB3iMGU+dZddljozH5yb7kZz28Je+rhSmKjDLHllwGxm+PIlAiMVbbU0xuWC8s729XTI0+UpviEVFCBTeFJPiM/biudRC5grmO+Vt89gKwDJRfUlpV6bo1X6ujqGabihI/61Qfuoa9W1+wqzFuF1DFocT7CUnUmYKeqQVWno5Mzej46XJ7Ec24JU1LDvNiMcQZAYD9prYjBHzKcoYVrwhQiz4jwztrTo7InmF0Cg5/yTj4p9RrcrG3LIUoYhfW61yVjpdRxc2kWpc5ZVlDbY6tky1eUWStsc4PMHU6sutB5AVd4RCWjw3OPvw4b0TJJiEX0Yc6iCijfYBZOyosLcNKnym5cb6sybiiVSiuOwGmooDw6ZbLvYPJ9bmlEKKceTQ9fnsXDoAIfNddTzb2UPH3syPs8LPnr9gV3y2XXZi5AhSYIOwklgqHdtmtOjD6r315lOiUrDOGoW2w1xipr4jezl6M2ZZGk/S5+b5W3vDY1Pzc8vxbC7Tz+m8X7168+TJJ6ZCM5hjLC8v37x8eX9t3ehFy1BKowRaJ4v9zlyqo8PjTx4/8BVVTqk5+/T2Wjpz1L5gdZ9RaxftnDos6TU8OMqpGhRJlWKTmLhXaocoACsmCTAOZCVOjLolT8AgMaZCRWSUKMirdtx5TYXA+8ldZ5RSf16omBaWDN7JKb9IBK/yXMiR/WRXZmnGB7JZVeLHeo3uqi14sELugvK3N60+VABUAsylcrapxIloJIimeB91JZxW++vGjIqiyhbxVJCrM3oFUjyqk7WTf4KRN0Wtcyk48bNZlcVPlxXjCj+t0DJiGLwUYID9nJmZFo8Q0uvkCzvyKh1gcY4oPHRICh6AydURy2JZnCyB4BdOZsgSKXg/cQuDp0YFHiEATJM4/IJ24QmAWERw2GCe5CnF08iFV4siuq3KwGh2XO8ac8gOsoOMKltcIt3NN3JMOvvcoJutrGSeXVg2//0fvnvy6DHOmQfTRHWtb+bluHoW+FYW5658+XLg+jiXyO2bKOIvmPr/wze/X11effTo4Zs3+/PmZRdm55dXltfvWbndOzh2Nenv//AN089U8r6to7JQWD9w7Zw9Qpg5HbX9EHtaAVUKPU6/fd9XN1YHhm+GTjIQvPHlJ581BKabJCuRlLQqSwtUCkUjbVIVb7HbxqmRWNZVcIna4eXNlVU4/bqfIIExmKSXL7KaZaimKF1gqFUKPwEMzMipNRETAkDRpVn2TKgFbBC7V0JrTldQlSgWtjEk+5BZDpNR2engmkvAPllPHxoyRMsgBlF6Asm3ytBqAE+6KPxkhva2A9Az4NJPmywyO6v3dtOfgxf287IR3Cn7L3wlKeJNEAEcRad+MQEf04skmyWlVa6ZodjaSPcEEXiuT4x4OdpeER3eWFX4snZdM6hNRUrPbSsDmA7dg8b9C///pJxV5AyGuKBTk3NaipQsNhFIBJ8hVI6CJaTb481jHB5tzit1gTckCBO3QyOnOuQSeCZF63IpmDJYDGhNVreSYDJgI7GD8lpjVy4W3CrN0ekxVflgd8ONgwvzVlgBw6Av3NmzuzPLh+/fbSgsIRCa0cCeWdH3b12UYrxCwhDW2niWZOdnZzRpt9m++/AhQ7N8c900kV14WSbEVeukF46i1M7hdJmYxmdYr9E8S0ZEKDIaDANZEEXwlNXidwI2VkuRy8ZizGyrTh3bCEnUa4IX8VNwfbgs3iopbK5XtA8hkxUY8sQBXKmDMlU9D0QvSzWjggLani1WTz9hb4ZEvMIEJKFWCP2UiO/mySvA/apvwQQgIN1gIipM+Vur4BSITLqUzlitsbbuFQnNT0ACcqWFrZlsFZRRRKHkVXg/gQGGRB1ALs6bgEFe9Uc0IDGDXDMGgKxhEKQL4RiV3O14+20pc99RxDp9JyMGYGtuO+4n70AuhBCFCjBUXUw/RTwbAIxc1rd9dai7felUgcDxL3grBYbODqGiKZHQ7OHZK1oOrAsrXUReEU8WnwdnIP/tt98iweGCk4N7duHGxRNHf03wOuGl9djBvrgwt7aydH99jbc1Mnyz8eHNqxc/vHn7Cj/GK0Ynr968dnWzJWIOqZ3pUzNzvgpmREOYmg3pYcZHCww6bAqyGHC4sX2wmbvnTvYOztxpfLDvAmqlckesVQd7kmw42dncIhCOpfq6KzKKgtNP1jakKx38IrQLMIF7SmmZK5XCkhvhtFgIyiwT0+8nmMZGi+2gAwyy/YMY1vLNAbRIGR+LAekcGAVTw5awfeZQU7jMiMpMrgkiXptdMXYNutTWkiuiXcWYJ3msYq/ry6SHRKwKKqLnT8Shb4B+Ky4Rkn42V1C1kgN2hb2Rt0YQgN6Lo3I/jtclwmDMl5F9beiQAjOEnndBIgGmaVA/fJL/0LDrggHIjRx4ciAfPTFpKIWf6pTMFYqyk4JErNzh97NDI5Her/yETWjqsoh7hQpd5VcpLSr4kWJPXFyW3l9UnQEm0YUZsFqWHQ9qDVeysBIajmfjLJrtRKrqTGFhOzuMa4uH2VrA4vJCy4yCNw0rRf/+9tVLN6DQXq8A4Fbx0cKb0yoOUvhjlPU53rpfC0UZ6cr8zDze8CxoU07q8YetMSgOPiWaIrHKRWZ4khdaKmfGtfdMIoQiMBEAKAqKJg4SlRaULGT1ySefNG84R5RYvO0qIxkYFFlGueRtGEyKkAMwVFK15IWA+Sz5RUAYMXknJxVtOD/loZytuFADlhe8OBiUiCbSUejaTtPY7ErFE0jF4DtDIgvWUYFfByAvFwaAiIzeVj2ZfE8TFUgNx8Y7xUDkIrFNrX7GnIZ0U7OqybELCsnP6UKSIx4AewoYE+rYS4YdPdXD7gNju1W/RLR4Ip44xDblwhJB8JFStFqUBx/lm0phrUTp6k0goiKLQKtIj97gkH7AiWEIPfkLGxvvlQVpb5FGQrOVV5Glx0/0zZba1eeVUthDRTIABERRlJeIFAcGTxrccmv4rlpPP1tj8OBoxdWpvbxRUBKw/RB7LNT5qDtZp15tbT9/+cJeBW8XF2Yo5MDZKWs6v7x0YZ2NTZ+YWFtbdeUwPWZIDCA+fTB9dnJuAfz51797PT22vL5mbufFm9c/fPf92oOHs4uLX376yfLcguuGCOTR0yeGuxYtNW73SH/3+2/YKfY2esnMpP8ubm+yaGG7x9D2riHhzGyOauvMDfAOTnZ167FvtbuEGrY3QLbKHi2qHeiKRs6mgMiE8XLQRoJCmYshuqiZLdpj445AO9fIdlAcieadstyWk1lWFVJZEj2t/BCFCM+5t/uTA6mmg/x4htn4Aa1oSFntKoscacASW+fZHRGJfZmKGszuz/MzX21qtBqWt4pQHUH+I6trI2434mHGUQf9igaSHiR9RmmUX0Ou0KQey9NTucsdDwPGUgY00Y1pS2iOXdDbUl07LbLDwvFhI0Kn/IocrlgAddF9z5lLPgYHlJr2mu+y512EqQbLQJktInMTgHBubn148viTN+/TZEw1MNQQKjIheMvVTRk+hkimzhyUDUAzQYdkUkHhqjGTN6dAN6OP0dhPfRySy5/BmWFo3NhwzuuAUp+b0mmJx5R/lE2QFwmqAgMzqStR5Hzpxq2g6comrwcOwTj3IKPJKwscZn7InwMhF2dZbeb664kJbv7f/f0/rqyO6Slm5+fwrWAEu7W95TppWoQl19TrHr/7/g8//9kvXGY4fKhyRrVrUzEWKL784tOvv/rt6ckBp5AfyX8imf3D4+mpRZMtCqwIiEqHVisWIo3+DFFaZ4aJXsmlrv0Er73jXAQGcrINSct9/fYNBTZ2ofBv3u49ebwilymgA1bLaZbx3Flg4lci/LKnTstWc6qYHZi9Mreqvly46Esj13pbzonBnA41Y1TTvOXAqj4T4PuHvpBw4wMIZnY+phN73EmIWKKI+JwLwBcw5N/XTPxRRzWqAehO1aLmZK+38WxWY+roY5gbGrVDxYYN+9Brm0IGtdbS9eOOrjqk5G98YspNsHW6wFSs5Qqe5bTI5NQM66BH1McaoqKlabEUqebRCWi1EpVNy3zSwZlPbzMhEzOhDbAFac84p7skIl3T6vZs7m9lZYmCcv4YfTs6dF04Y6/a5ddsyIFZcb6JE90fLaE0FMuIam19pX0uPuXR8QF9hR88a/j06adWurDqa+k+a+cU7YY7squlGXK7cNz+NoI6PDm0U7t1lIK67dZ3KqZtwKixGoaxTUswQIcoh7hKpMsmYhkwkUPXZ9YCNU7MQvi0k0sne5+GUtMbagGzmQ4KsbO/9+u//dXEjO+FXdn249JjPqkL5kfmFpY//XxwfvnwZvRyeNos6ODF6MPlByvjC49ml35y/8lffPHHT+dWTt9vb33//POV9ZmLm50fnp06N/m7byyQzWgzWTfeI5+329uU8WToemp5dmJpcmphenhyxMSir6zsHO4enrln2iJxTKnFg7HJqfnVVdssuJRmA7QLHQOhcS1EfAfDHJ5bN/Z39i3uWZPfePf2w9s3zqG76chnMAjAKILitclWWJNkqntocAyVKX3L/Hy3sX5mNdhAzj1DNQgmGXKos2/5Zqw2KXDNKRCxq0eaoAqSl0hP85Uu9ct+eZnRxZlFjjjUFEMbiaa5l//6mpxpAmZyTGboxpWrDLgZ3uz1NM1zc83YaRG5VejjhIz7/c23j7j6eHzm+OLm6Px6+d6jgZEJxt5uefo/MTlL5faPjpdX11WZ6wRa02I+FMP1f8PZD8v/8oETH9sgQ7OMmI8x0pdonT4J4NiU9WAGgjPOKZ6Z9mrHVcM1nqbAFjq4hbp+yzTmsr/44gul1iI0fGLRexoDWTG6deY0uzrwjJAlB0uYKVPJDW+GSVoSM61lnWW2PZ13Vl6GGOjBFy9eHexjx3GLYW3QcrjzUqb7DdO0GgM0Wn5ox+XutkFAyZ+rnrEC8WY0RgFmMrmK3MzcvLMr7tPBgosOnQPXYtjGSec/Do584QFvhOHPOV6+r4yfO/2guk2T1k50MJTy1Zs3PBhNcnFx3tiXh2ToqK4p3Ozc/KGvhhh1TM0o2v7uptNPK4szZ8cHS64MyumlQ/qWo+Y+1HN6srK+khU4/cqoY0BmN8Fg+1RlKY6L7bDD3LOoNvuQiPsNFIR4qJzKVdGsjRlmkw65Om04K2Nv371fXZ1h47nCvA7JjkK5tnlnd88MJ8nv7KTWoXV4i5Lz3/HgW32Gg0yxZ2bNGCYSFDE3irwMcnK/ousVmAkpdJfqdHU2Z2QtNIsalZJoDHJI0WYANzyc3np2Or0B6SckspOdZxsypH0D1av+eQfALuPQWyx5Jd0TIYk+3qQvBwBJxGfddSRz/Uik160hcHdRUlyDg1z7gyKyywKn7lS8ORHBgMJKF691Hp4U8hmvSSnhpEmDgR9phfUKe0hoKi00cemQgMEPCeiT+ePiGJBLret1EAUPWARkxBt/kVgyJIdTIuQfrUzWGKW0/O8iLUDFRA5mwoG5ha/S7bPGraDfat48g3CEpzCjq7DWt2F2Znt7fmpicWmRT+AyOo3n+PTI17CuNdv5pXsPP3HGfeuDj8Yc58McSBza+Ls9Mz69+HTRpMrFwXG63IHro43NqbnZNx82WJNJPmmukTjTE54fM+Lnx4d7FhKU98r5PEupwhBPP5uDWUyXKboudMtnuwcGltfW3YA2O5/JnEjEtrbxKfJxelMH35WLfwbXgMbJDJv0ldoCSVDVbKliKjUvgQixJp27QGgSCVZQp/1TCioF0I0rFWeAobJQVEWECRu52LfuC1xy+dlKeDWaaUl1ikMp4AuT9bbUqRSizmEys+ru/ajNeekX+7ZL/lCm8WNIO9hbqRfLr6GRe/PLZgviEsV6adfjk7NzXy7EnTTR9Pz5D9bAdSHYttTsGUI15YWfbhHGAYpGi71XRFdw6GZoFY3CG9mDVwsXN9aNh/UHimXWkf/p1NstQ5kuOLcrIiuICjQWUSiLTZChmzV6Xx670p/AZqjC7JNAEY2QxVkVr5TQTyd72Wc/u4PqYvM700Kr+ZgOI2+9dY7aDFlfOZkYtxfB7f/mBR0hvJidjbWFH/Wqo/BpW7aOVxUuLy7oWVKA4Rvn2Q0FusaRtpKNinEMeC03tVl33vlJVmygSbxPnzzlyM86DDaaSbaRk6gNSHHOkxkMvhYXWcaUi+tpd8bp8cb7t/C/e/dmfXVND/HujQP2x+ODMQsK6mbcs0v3qlrhsu5Yhx+RtuB72YP+rFfjQXHoT0c8BWUkaj2c7kfTaJdfV62uoVU0T06JtgXSWzyQrzKO3WQuFH+lFIngXylgU9LUWp1VzIStMlJQe1QVSSRzkTFwBl2Zv6ZPsqWgZdO5XX4WY6Dip8BVrEbjpYDHQ1s9glYiaA0eCbeNnaKqPKoPOXh5u/BI9E8IeUktuOT9uGmylRUwMG8RkqWza/ziID1ThFKLztjMeLbFRxTPess2kaRA+5WogSGHGf6uhn6FBFWSCJi4/RSXRVyKjFIarVydFxviglfNpPSWCXi5lAWfMEj3bAl71Vm6jH7q1BUTMEnCaANcMVPbVz42MClKB7jgs2dACjx+ighI8M/yC3rngfIqYxcA5wP2s2dGDgiZv3nz5re//e3/5a//tVGkDse8Cds6cHZt6LAwnZv7nZcZ+OyzT09Odt77JtI7GyCO9w7O7cDxFUnaOTZO85SFRwmDY1/G5PBP5lj+DYd5Uav2NaibiU2XR2ZQmFlarnC28eSbL+OMu5ZuR+/C2trMwuL2zh4fyeSLcV2LC9tMoHqhS+SpTkUMezc3P0BIW5jFKAZ0tXNOCgmQMHPh6fCXUpc0IpzIzQGJuKI2UOZV5M8W3u3Ep2sWrmenvSJY1D3hVIOe5Mhxx4y3xprewqNEgpQstLNGmTt0nHVPRr0K/N6qe9QttvfPEQKwKhtdrr7f1uz5Ja8OLByfm/3LPB4H893Gxsry2udf/sjSK4/YwZSXz5+71My3eljtoeuwV5qcoQly4cr1OKWEQf1RFfkWII2oFEHEnMm1jjj7Q2JE6ILhCGak0O7eXMGv14NOjDolkJ4GFSQgNAjws11DUzS1v0c3oCPLV4YJvMj2IwKXS7kYGDrof76qsw+0hZ4bb0Wk9YkgEZwAyPSpq9WuLnN97GA8y2s+cCaQVf54/A0buD9+ViG1WctdVEJe/EOCVdUFGOnWDYkUD28i6gVXqJjCBSMLG5qMNakFHkLjFTN+BIUrPePYDYObnU4+xTm3sAKJyZ/djbemwjY33pGrfsV1Cczl6f6hVaFsY8s9aaOG9QZI8EQPT891CfKWEcvwCPMRTLkUAErIcR0AaLfSAdMqrUDEk9YVfFxnmTyVNAJXB9DUNmKQEi0nWpQREWTEufl9T9n99CE2YNFLGPCBP2YcaNOGUXk8U9+l/RhiOpshT4y23DORU9+rkigvOaobqAGoaCsyZtS9AlMpqR5G09YGiTB4Cog3D3HLyirBABv2PqJKxqaIE4xJl9G6rSMo0hVJYufFswh4ACLSxaFCpVu4lKbYOAkFNqFzgZSCuhQCASl4hYQg5b+GFFeu1iF101mglUW8eYCQfSQ9OPGGuicS9BW2hhHBbYtIxFvYkPNWohQAfLbz63TDDebZJODHHjsOWK2hJXInvTsS4IWaSfccYoYWhxd5mqb4pHO9fW3O7mWrW7biWAYeHjHq9DnEGZ+edI2UiYDUolkvXtjw4Kppzif2tx1tfHhngMlHMorQo5n9hw0qU60qz9Ijv523794D3tnsxJQJH+5cl9f1c1BeDd7YpffP/7v/bnNr5+X79/qerGOawRgZ2tyM50ViKp1/Y7Tei3UtHA3VcEXd6g8IvMEgxACBtNCIyCtamkr8OJggMcAAoBWXhaizDajam6cUGeERUVlgIs8MqxMR8G9/JCpp57XsDL7BmAC0akwYfwgks+JtWEpHHD3UBCDnroQTG3gqANB2ZGGYfDzh4PDYVCel11YePXn63/7yl3Tid7/73ddff+0GPt2441FVufE05dLcBC64QplSRUVANxPqFZB2TT1q7GAMaHxbjlrkY54IZDbkq8JcKZr7DVP2ul0OcgySExgzFTSNjiWlzAUwGC5vLnLEzO67kqFyCV0u2MgQUWsMigyHktb22hxd1q/rdXApcGm5aPEJ2DtTeVmRHGX4M0lVYwscQtWTFljVxLUUtk/jNz21vDLDIGStQPvKbXHDjCtbb46eZODHJ85DvYUVgd0uBdMl02rWwwx3cTA5PrS1u/f2+K39bVPTsx+2PmCbRzM55SLorCLsHR64/8bE78z0+LPn31m+2z888HFsRb5zChXVwgn1YpysgR4fRK/YAezRWMf3UNenSEyV0a0yNkQsHasKoYwiZsjI0DwA62o6C2R+ZrIo9gE5CGML3CHmohE36ZWPb0Bm3hGA9Lssym7sB7+5CvGYyCaWKnddVFZg0s+E6kefmgvAmIOGl+A6i1xUS7oaoh9NpsUqsUfBUEkxL5K1HZZmBFq2MoODqGXOamlj0SJPAP7MWmZIXNtgTcw5RmG024l8nyxmRb+0pyga6Rjym9SXky5olLReU+Og+elcoDqnay7m5o0yVf6USxZBKbCNQ6ErTAE7tLBAEjF1AYAQ+UgXPtZNlo8kKmCnk4OIXBIbXhyJrkIiFem8nI620Z4SBUgAAAZgmZp9bLR+kjk2QqIISZeI+SbadeGJSXQFcUFECgZqwjm7eP3lsEetdnbB0WUF8GAUpZH8l1/96u2H977S54an3MihJ7ab+PzSGU9zMj6gen3iJPOBBvrwyy+f/jf/7P6f/Mn0+r2xpcWHP/7RT//5P//iZz+dW15RLcRiA+jnnzydM39iVt0M2/BItnZfD0zYJKMSnfDMPFcm99n6TOOOTvzkT366cP+eduX2t03rVzrc60z3CcpLtgqlRCpIxFNcxKwa/sFkdqTuPLkTCwngP35+BUiEGLj/yoITZnZx2UdsQda599ie7Mw3VmJZ/LBhwzSRqyI9s6s1lRD9bzk735CaMmnsu4mdbhRhBFIeGesEQ/NvxsO5Zmpo/lcgfyUK9XJ3IMx5g4zPct2N6ubps3Fau3VO/fn6g/v/4r//73/5P/zly9dvqdeSbX8Tk77XuLmzrdaV3bfVrIRln6G55HHXt/GoILtllRoILQd04R8fnVA+KSRp8UOngYf6GSjxLo54a7UUEWxDCpW4ctEf6cHAQKBXF1p0YnaOWvWuyQ2oFBm8XN6KGxCRm0BQtAVAx8HHva2NPZhnGKzoWdM0XtBC03/Urm7ksMF5UuM4VJx2feAXMEklLDKznzDLBQZmgmV5WXk+BCrSAeNfOuqtVzbV0DXxbnHS44UdZQcHYInGOgDkzdEIM8DDQw8fP6Xzy0ur6gv8519+AdgspSf/BfMMfar841UCLVt4DByZT3+BLHct3HOmo7G0P60ecfBKBLMIVc1Os5KhRHKgrnRV8cXhkQiVSAdZoCQrEXKWkRzCSh2YACw9hkaQn4gpp1IpYo+MvG5V1jvLDFcDe0r3Vq8v7hURS4GkEuPUoIqMiGJIVBL4QfoJjxqyIkGOGPJTEJEFHjNxcjUqGCQ2BkiASfGzKYZotSUpwJoEGNm7ClWtn9K9VX44lVkcEnmjJSV3T8g7RSkAwE9f4RHUq+l7zLeie/YwCKr04TWilKur2Vv2AC3pcPop4i0eUMePiLcqrEUBoAvecsAJMPDSDeExjy7GpHeivNDiCrxns41hPyFsHjAGWD0CFmF0ZO8sQZs6lSOGyir0zIOHTIabVrjbJtz/069+/cnDxz4NbpkIiMkHVs92kvHJ6X/4zd/de3B/ZW35+nBox9fdz3NV1tHA9b0vPx9bXEhHsbczNjPt/kOcuZLNl/as0DbD2adIb8dHzN0cUJI0fApt/S2b6qinE184/Pv//Kvvnr9YWF8xtM/nnuluDczNn3sbIYzkZo4WhZ9kq59SQRaHEQJDAgAUTzEJxO5lieBbK0RakmRLFAK5aUJMl7i38TxK50VpBGDeGRhvYYj+TLAOZTRLl1pJ0leVyUALmzihWlJUnN+xxfaPGjEwmr1bxvWrNYhEC6uxdP5VXspDmXn3ZtTtzrbk8MOLF0T7P/8v/+u//Ov/8er4+Oe/+NN/9+/+neKq39n5rHxsvnsLeU997OmoErIEbUW9GYC4JhJQozkM8fjR7o66i2aORGKWc5limolnnV8xoynSrngzmYPOB37S+SGUctXNV8oYKVUL9apKmkFPzkM5HFeBK4NoXbqTpieOCrss3fZ7za6EFOucRc2BwaPDXE8m1fiduC4vssbWgbegC0MdwINHD135R1Cm0bNTbIxzxu27WlqYM1+khzFf7wojQwAziN0cukZk74IYRLbC4Kc4j8tLIMa0elyXC507Wjg2wrkfGrWDI056PpRtvdGSjCsgOazDF3P1qTsZc5JgfMwwGloDXxKz9mvhiQyIyN4X1asR+WF1Z9fCmqM5MUKZz1A6EU+yxYksqUAr1Kb/4nRSmZr8+ViFskj3xK0iEJ1cjUG6PYR6JvJHVz1aEoJMBJNk6jkymFlfui2vJWV0Qy+vc8hiiB/lRatjP43/slFHnVbDQImdJmvNSty2OVVvIk8b6PsFhwfG80l7ZronXiKC2CnVkDZQ3UYzh7Eq4W0HiA1gmOObI61gnvAonjpjBzEmIzCvmGA1B0AWXpLGAEYdQyjI0vUtSxMVkQsSJVV43RvMDAcM5CgOQxMCgAQkMHcEUa+aZ+yhC6csIKFVLoro6RVbJldTl9JI/BRQb4ZF/IzVq45NXHm0Od09SSmzgngFG2kRkYiAyYaH82oofbjE4K2OFlFoWzhSRDpIBOmmJQCya9sMXCFH89QtC48eP3Bl1ffff0sgPn7nKMrXv/399l8eLC8umaDTQ5uedbXn6f6RWUtXMmhX7zbssbvQPTqic3J1cXR5vmDAMDGmldshsfjonoUGJ9PPjk+//eH7rd3tcvZGb0YHjy5PHRcYuZq8yU6Q7Oms72rlVFomHifG/v6rr02FLC4vuXhAVzRitmBgyP4o8xFqsztChrp0tYRSsyVTU5mLIFtJROf8F2nWrIX7X9nfaIh0coh6VWMjgWwSzJA5laU2QZBVHC8aXSKNZmXHM9fTCOrSXvtYRIlXaVd02VP/opaDrbZIkjmF4Qx6FKkgR9ciNg5ZRt1C7lwS6nsD3jY/Hym6/kUKbY+J1dk5bWt74ubO/tr9ez/+8Y85LOyHbxm+ePWSzvMcWf+XL56JuzIs3rZsaTRcrkwRKGAYYKrSerPMqOfvdMPobhoa5OnAse2P7sszVWtuUkdWXDkjPaRLtO+BYFlbU+zsL+zeKjVxSaeNvEI49bCimXm4ytaJTGmVC4VQZFJuYhioNgWgr+9XWCl9rZb+XjfEV9zc3CYBpZienbMGwEVwGtFibvbrWIGwN9dXSzm/OZ3iOMLotC0P7gWqfX2aCboqInVa9soUfCuGEZWdwXetUo1gGxjuKI9cbRNywY7ZhZvBpeWF3SM3KlDz9KYU4M3b97bN4MHFS1qKEho0G4DOzbhKev37P3xDReH87ocfsLe3f2jDDR+LnGSXS7AsxOYeHY7jNnz6jE91gAYtIsQS+diFV007usky2+pTnQQ+u2g4N0GgZhUfTn1JngYftaYNp58ZRXycAEhlORWoPzCEVZVT6Tj1OMoORno8DqyL0QlJyHgyiIyUzAj7KXgrf5pNVCFBBMf9s/OCJ0dP2BueRMAAxrG8DdZIQCIB0quUvIKIFBUpiDR+vLH4TREwQD+JNdzXbdd4AI9zMC0XGflESqGSpMiFllzkJWMXqvsDb3EFj3RPzHt2UF6QrRkikNyxBL/gp2AWBRLZOfhd9q4zcSw1KqzaBQhSRIs1IykOM1GAEaR7wibSwU9vTRYB1ld1Kbi3RfMW7C4jKsqOIjmQhoy49VMQF7yFVpGleKVkPJ2tzZ3Dg+P5pWXexsbm1u7unjb8j7//6pDn5WQua6gTGsju1Z2dLdMyHzbfay3tzhMsXZyem9s7Onr1/Pmbd+81/XebW2/evzd9z5PcPz4xDefOraHxUfcI5UYxPrV4em4scHtT76w/W6bk5kc4Pqw2cj56w6h4lS2J1afiXFBMTwVRlaRNhgpbs9a6JC5Czv0y2hLVV2f0FGRUKYTgqbophoKAYaFahl1NxVU6XdIG4NkZSbXxwGAXMQbUghQAuIVNnAJ4tqjhlIWoQZpziNqX8kgUJMoIFfg7imAEpOWCs5rXDY8Tqr/4i7+49+QJj8unk1Xkiorb2nImwzhg/d4D/iZ40xq1HBK0KV3pPEJdOlTQIhZBrZGesrc0VD2318W4YBQWgCJgj4ZEVqc+MZgZti6vFBlVgRSYWzioC8TlLZxZ1a8hODZUkHRgKOZVVZzsALqCvCIQr/gB2adba/JoTTit6gtIVuYwng9s+ISDGzmzhGsxHE5uIjBtSrmMuAw7rGPGfNpDOuLY/KTE3jPds3AKhT1GgFmQ3clHcsC27PB0NeHKsFXdKrm4ioZRWXvjExirYdl9WQ3TMTDckoENB2adKKoxh2G06rDbwDVw2cVe50wNF/QEGjf+dYt2NCkvOZMhKhiAOapY82PignQA/QrnHSQiTUlEyE2WVjkyAVyaH4eHeIHJKxEqkodZXC7WDyr14qdc4mQClemLY2onjyTvDE8cdevTbiBkgBEWVeHPXiBdFto4aLwmcBcXnEeZ5SRJhFoW8GY7GkaB/RRwL94awLQ5fkVFcNY14RUAOAkORdxLvysP25fer/oneWFuhcNzi4Y2KIxSqGColNZP2GAQBw+SmOSFH1iLplnykwRAwolP8JBgQLqSKhHSqIDhdt3hBwAnlgQAXAx0Jfa5sGbAE0VZ5MUDo48iVlHxlF1GWW6Fo7fHcXXD2vNPfvITc4LWV7HakiFY/Nixg7ECjJZQ665I8bSZmo5TlmbbT/PXsgtMauZ+yhjRSbcZurnBsJERdSeEueaNra1vvvvWhmrbDkanxh1W/eTzT+cX59zYMzs3zUfTiR8e5hYg+4JyanNv//vvv7cw8O7d+9/97psP7zf1QW6C0z2YAt53kdHuDptupcn1C6Mzk8du/nF9jf0r2SJuE3JahZuO7HbHGAZcDIcTy2tkAj15qtKp2SlWlhWfmp0x1uS5sZ3WsFg7n0p2w76ZVgDOZZqTrYojznimxKL0JEbOEHYV513NFGtoipN2zlfLKmJu/SQr1sQqooc/5zPjP/uod+RtTWLEBahtTfWlrAM7T85EilAh1v04Q+C+vGxt0lAkqhSZseGJk644/MiCSU97AvNXG3hoiyzqVNMAQ7VovjojClSefPbZv/23//Yv//IvWW1vwYA3ejP/4ASKnVRpg7XYRqdMRNAiuZZWV63kwxB9NslAyVHPzhknY2a//eYPBOAVcfWSTEOqSlqEW3NX3uKKTTDSb0jaizcGQVckoGJEZWNxIO2lr1VNtWyjgZEJvVVM04kOupjmEqB1mAtdTmUGpDU1urA0oWc2qB+pbw2ZcrEZzNlcVAXrHG7Wgp81QxpC3jq/mhuoZt1ySD8N11zII12lKI6CeHorF3FF1BcXzjHwHqSoEY2CqO+qr9upJindhUduUN/YfL/v6OChSyDidCrv8eFJdp3mtGZ5CVf29Vw8ePjY+SONfe3euvkyuwCaTyMwFBUW6YirJt9ZIRKg3noLHbBXGLhlz71b2nwddpMuo66AKyFSCPPMgM/sl88DHh5RLZzArKRW7bQ7aBUZUaWWKOInACVSZbKTjIJ4Ja/0Ww/dbzSwhRXBC0A4kC4RQ37SgP4JKarwSgcJKUgEPCWCRFvcK22kPz4HEgBFQUV2WbxlDW3ja7TSZVQZ6sBb8f6JOpwUvfH7KTQSJLDq2D2Eiu2nV+IiUclyOiCRiBAMrWRSVAASEEos1cmRbrJrxuAEQ/WBURQ/peOBvDyxTYKeRCGvlMagFMAEYI3Bq37btpiP5ie5YU9eDPNimkqnICe7lO5x/YTKTz4LKflJhjKCQasFhRNsIycoHXgBFWBwSsSbXFRTIIdOV3ZBkavfGc0nglPX6QK11W9/+PYP335r746TzlPzMz4JPDXnS+9jm9sZiGxsfjBiMvQ6cn374dH25tbxzuHZ4amZwUufCx7wUYFjczq8civuLAg9YppdisvE+9AHV8jNytrzoYuEfVGL1RgZcm+E7TS+623RzKZPn+siXm1JBUWAk5n9U1OKhm3lEhSKPMmhlVa5tCClYKE8iUgW5YUHgFyUwVP8TgLeko9ExkIEJGwkQOAwCFqLODA8wCYjAHggBw/AT2+FWzzlP3mLCg5VR7cRGSEXkPLWKxnb6IAUOjsqCgjgI8Ls7Nb1KOkvfvELHbsLB70Vuf/48b/5N//mZz/7Ezc48fjYYyTg6QIiJAtUjAcqgreECb90tJqceM0xZiVMnFujI2kOG9ITOVDMrlKDwTn56I2QgBAJSqUsLRwAsjdykCIlxTi5UNmrbtVBkNiQYARs+wlng1F1P0+3tojPOxMm4DNdzsmemrYTxdyguRF04TQMUuWmG3wTyNygrSNOmDn9i4pBQCae7fktf5RIVQftxbm4RDLBv97RT2xrCwrirdZkQmzUlObA9cLCnPOYS0sLNviTHEEpaTYuD+amiiwXBU+2n9Iz97WsrK6Z/T7Y53eSM9aiSJgxFNC4PDPJVQykHj86cBhQdmARRzGGN6W7a84EIh2MZ4sLgOxkhW2i8Apw45Te4U6N8cyeKCl4MBiQpa2QavU2E2FQQO2p3VqexlNTJSNxecqRisluMBEE5M9Vl5epQqwgrBiy4E8rhwOlijMX8R34JiKyOJSLChmRC9U1cheHj7YhhCJHTOW5ZYF+8xEsC1v+l+LPfJaUjNzrvA6i5CIO0oYNvWJWt+xX4cfRAg0op4OyKUVec4VeEZZSYMwTt0rt2R4KVDSbokgkFvJqM+Sn1ijFT5YIUUWWooB+EiIMsPlJyiSj/lomRNR16RUt9wo86TEusresEL31j6rJeUsjaJYIT98Tw5bpfJlID7+/s4s6aSMKJ+RkTmJUDZ4OiiYdgAieLQJzXuK/2EtVk2ae0lEXlBEwnHiDUEndVvTDs+8IL/sU6Pvg9er9taX1ZaoxnS1lrNjZ4cHB2zdvTo6P7M8wU3+0sf3uhxfvnr9yl/SUq3RHxt3pNj8zZ1c/LDb62YDkFLjJErNDzhRMzs7kBNPN9aFtjLlmgI8/40NdZjAdU7Tkm0OI11kFsXmmPWISUxxVQ864bebJwS++I6niXJPzVptjy+MyV4MB7JWnAEOXV6OP/pXaW9fl8nO7zBfHfzQpZT0s2+HMaWS2lIlht2K6MFQTx6JkSG7YQFEyGJj9RAI5uahY5yVGoosmVt8gY/NDl9qmwKPiJNqFxKxU9qH23ENoaOjR/QccIsNK2nuwt29XlvvH/vbXvwFsF6IuVp+anbvjU1YjnPeCiXbjBG9aIv+dhvhJJeiStkTD2EfNQaNQiQ5Ts2bo0gGVS0i0rrPDQOYWNrVZrjwMdFXw1mDIW5xjku6UsAf7inyKFJHVseQ2IN2a5FILUmJiDLq6pzzK4IBYPAnEZP3Wzi6RmOyayFHnKQYJQrzRhG4R+nMp4C/OMh1n3VfdKE75OcqXcrUYq1LT4yoR5gF3lbHgGg7Omx9V4xWmqBn14oKcnJ/Y0R/LNTZkXxVIFVMMm3DPFXE2ONAQ57mKcxtp0ypRMWox7sk4xnk6ws9dRmEGXbSoq9khPVmWkWuu0quWIeq3PEc+ZrMuPCmEQEM8UyNXxqm3c/e3uqe/Lx+ltUgiQbVgKZhEIo2IKpHQIKEDigMhgaRc+ac6qmI60vHGSExCKzdEXZF+YhoZMLD4CZ28yMCOMDKdomWKc2BxxuTBnM6zBuPNgbdQQSs7PNi99HnrGh8ASx9TrplXjbN5a9IwaAMtWdkldkZxwDhpbiViSdUqiBRoYfPEbY8/xMF4K0UEQuUCQ/V7WIBDb4FBq7x+ggEgSFEipEXkDf/Ve4PBuSxe4UQuQVyQTpW1cOlyScEVJLCholAtLnk7i7fGCs2kogGQCwYZcegttpFTjyKQYwMADgUwpvV9WNECLHKCLBqwVzCwYLi10T/PGghrMOKvXr3yhERxXO427XMtC/OrPh6/vpIPWDt8WKMNDONqb2vTVXBH+wc+KKPnwaE1w6WVNduiNQDNfWzC9OiCrw/4W15aYUkuXNviKqWFOR8IM/7fOz40awQtBG3KYVYK9t/CgcVqpWj2cCWOeaVQWEVWXsAERQ4iXAp10pKXCFK6nwqOMTgJCoZoTveF5aj6KShvYdC6b6tSdmCajXqBBAwGpAgtZNgkmtNozIyoVwgJ4AU/MQAGKsvAeMEzKoSPJYRg8KarDxUZobJrOXti8s2ZEc3pt7/9CuPO06I+62aIqck3r15/ePPWd1EerN+DXInQagmoXNj8vFNLghKHGTlPOAFEkj7SWxMAsvCm72DkBSa0vYC/LX4LHPOCtgysOsiAiSsXCwhGm1UQ2LS4Fp2fgjYIj1Kj3mJBQtwr970w8IC9BRZCU5E5nCYSVSN7bivU6zdv37x9G9t6Eb8NgHsMnUdTcH22D+JQB1Pzfqp6liE9QTVnwAjRGYLqysW/CFZBYsMrACriyx//yP4kbpxE97KoBRsfLFbmeNdQPn4pC3FDzjpnqtC8i+3Bdtjk4pax+VqXMksWy1QaVZKZsGc31rsuKieWFhchIIoldQEYq57oSldwPxWQKEQAeDbn8gLzxDPmZffKU0a5uuxdKCmKCZuIKmuzrIzeNjkIkYjCya9RaDzNkBQQchYlbSzdBSyoetoAzGm0kG3Jn8tmhG7CK5N0Wr91G4VBcmRYe5ZoYpcNlREH6Anq2E8RvEKrhCJo4QyMuHr3LNhbfw1Y9LW0XF7AfrZS4kdQJCnRm5rU81McvFdQiaecJQW56JkncoLq9IRTBCR5mfPploMZWaRIB0N8rCFI2DCABFoYo/SygBRQwbapCaTxo5EjJBFykYZvMMj9bD3jrVCsZgNC9Ur+4A1iDH2gAmaxBCF5uyw4UQpZwOOkGcAbWriVCNJTbUIlxRYKjiGne8yFlfw/F4ZNGjHEWMODOofXPSp0EDmD1e/+8P3bV28japKZnTM5wxgPT0xqu24h2TXzqM/2hd6DQy2wypXj6bSVYpij3z7c31YM9c/oDA4d5c4yM8cj/kwGGaXb8mGtw2hwcm7GpREDo4OOhlkK1rb3Dna1NGvOca8vzghTdZAGLVIcZVEiRVa6rgUpeObk2g6kTyUTCoay9salcSI1B6ncT5EtGTlbZqjoj830x6rGeNaRh3LTs6k/37suj55J0nVoPZlLsEaZ26siIV0rcbZgwZBSayMop0bDTx2nxyF/3LCmawExKfU2A3bqdCv8sfEIX//t3ccpViI1xa9mYJbr//N//B/f/8M/sgduKOA3H3748Pvf/tbZ51cvXn7/7Xf4Z1cPDrJDUcE9W3WndeyTU7YnckVTrR/vI+HvZ/64+n7IqYxmre8jCgunSGfJoTwwo0Y2wJZ2rZy0W/lx5S2ESuFJIRVQBWkpeE7RTo4ZAapIY9UdAOVCSESRlagLJc70YD7qVx0kpmoMl84ymM22XfkGhmtKMshGos5GZHEOAxKxiqWF2TlOsSJDoimZAJi1u9FScJlRvgHq4DVG2SERBynQUJxjRptVqC7R4oMHSuFzboOmQKfYkAsn4QmHSsCAiu4TZsDYN043OtIYYTObjxl5OVvAFNzlHwc+lnaYDYqoqHHUmUivsAQYHu0zTTQKVl0yvFwCs0XVUSFxS6j6E+a4YG8fMAhIy2uZysIBmetdiCWyrbxIAJChi9mmiTnCs1KrIPgzMvJDa4FIRFLnaXXsxgadn17F6BT2si0ZzQFGRgQNARgFAka+forvOah1etpUaYlW6omW2gMDJ/4wDQ8kKVP1degaT6tmyLslRKblSoOUglWwUhw+bEEgBy2EeAADXp2hCxI8VPDDhhz2RAB74sFbr4jvjgevgEkU9PYwSMESPlEJk3WgQbos0tUxuoCRnh6K0kvxExg88Pup1Gi1cgNDGm82NdtFCQlWHULxBND2XRb4bYukN+i2DCUCaEIwGxlgGwOwSYdHIk78bBJU6+g0GgmZFAFOAH5D4jlm7sUxuqEBvPG42EOO1PtXb776h3/8/NFTrrtpO4en3cY3s5D1/4WVATMj6tthLh5A5hBOj9yUvrnxwcqYhrLgBrecqxqgVfZtKAMFsT+QTU4n5DaS+WkdwJVrXtz8fpqPvxMXKi4+SxMu79W5BNWn/esGxsbVe7p/ErDypwiKTCDKi2d571q1qiFqOzFElA4GApFRkQkEqsjH75p5kIhWvxWBVpYWIMUjRnXXUpJXm/BEFED9DAoRYCQuUV7xYNDn5X6EZNcBoIIZAH6iZbijFDj3s6mDFAnhqjtxbpw2YtkHvHNCD+7bYviH/+3/+f/4+e9+b2ek7M++/+Hbb7/RTX14987sDM7VS5uhLPJXeWHTZVK52fEMOJoo5ALqiN6WIvNU8SrAY1XgbTAirFXL0FuYcdsq3TqGLZAIgRkYirlhOcS5dSAtwsaIVRXoZKXwygFPzM1R1IO9cIgNT2x4KiwH2WUBx1fn7gNxmPblm9erK3M6M68uTo5z0HZiaujQ9QoH4MN/TQexLY8ePjL0VBZVzqLSBHdJGUBjSX8vHZ/imKcqgg11tEK7k0I4Si0i18rq6tbmJklyl6C18Ds6OeOL1+4NtK/VhYD3H87s7R5mZzRTqcM72DdH5RCEobUUqeqdHuSbBvML+zsHio+QRsmH4lTQWDcQzkyNzM1OuKkRYySAsa50dIO2K6XOOkSMtZiqsIAFAJ40SzpIP8lPCvWBhM6QjIkrTp5V15EY8sxVZGaqVBEtw6wUsGTetg6MiFpTE2El2tF2vYAk+itKSCUiBOLKeDPACIRGBawYg/rTSLyCDWpUhbTkOgPVnbZ0OTx5eAqjqN56wiCXOMMvlxTf4m1I6TS4uw0SkRcVzxYcrjR7BaOp4NVoiw+ARCQav1eN1i2Puj5gXmG14RUEEqrQzKMIWJaQqylUqASYQXorlxvA4cEDrdJmYNPByr7qqFTdNKLgcHrr2WCyQ6IswuHhETxIeCWd58JZxbMUP+mRtVmcS9Er+Kk9o4KEiCwtB4S6F+liQi47gcAgeAtDjto7HONyrOraIZQuroAkpjjyOsoaV9eLXPip7Qw8+/4ZK7C+vMKfpLtwcmxtKScYC/fxIM8uZxczsze/tji2O+XEtq5pd3vn9c5mLcflsn72jlK4nlDc/gxupHOHr9+/tRqhLBLPbdmno/aHxnvz8WEzLRP6CUzSB8iJxRNfuK36itLjgeii2zcZ/OETvAilSKldTPZx9KOYct3qbX3yiJrevW2Vg5mUxFFRfm9pDLMu3W9mWf206IwPoGLLgzCmNlBeRdbj2U9COppl9xPqQlOBpEVtOzlOeOe4pfgYbnV1NjvTJ/m+cJQBG03XWxK3ik6LnMT+6quvvv7qd5Zq+ZgajpbJFf3w4V0ulJ3OSiCWKBWO8OIUs7Pc7B3dYFLhRFrQsogJ/sgOrczCMyUO9USqqfssaRrh6ImpR4ahWFIuWSBkUuCA30CKRtEIRIkOdXMV9hOfnl0trSyeXLoIKocQ8cN5EjSWgFX36X7uauiKG2fFExIwBMKyGg75iQuDWfVOVi6xg3/Cl0KPcwTSS0Nxm4UFOO0rev36Jc690hhdXCpRY4FQdshxK6K9CBKZIIRazriCRGWRjPV6YFIYkcXlBZ28P1u/rEFf7Jusy3b79dXVtJKb+HPBkHXmzP5FaaxcunvOYOj87Oknnzy7fm5TrqMmRHR243Iq1zhEr/B2cHg9XQ46ongWoMIDWQFILaSIUWChmTfsxDN4P12M5S0wGWVB0eq3eCsAnRnPVrpTCzBeycXfAayDUjqjU2B9eb6bTeFxsSihpT0A8pSEm1AuXaS+pCaOb4bfEyVMWGTFDYk06/L6SdvQQxUTjBQwxFDVh5uX8WymVQCEbKJN6HJRbtMXDBzSfgpGQJD4KYi0CsorcJbxg4on9YKqp2usYfkJrVc4hESVkKm8npgEjysWh8js+SNDDaOFC8Y4FVatVVzeO/yNJMy4KaC1ra7cgw0YQhbl2qn3xWdyxIBE3gc88MtOYhgT4JSIAaUgE6R9TZfzrvjAGr84uXGE5aKpKKIi0h+QYfTlImRvzbIqF3gS+PTTT8H4iYSy4UF55fXETLF95tIywF64kfJqOK5uIzd2Zsdtz3BDgf08eqs0g9y/fbq6uOBCN0Lj57veeGZxfvPt28XF5SC/HFhdW6MFViNZDJUyNunTBIcL01M4WX1435S9W3/wtr25Y9GYKiq7/YiaJZu6sfXBtA+zaQuQAo5OOhWW4qhCdk2tsDQKMjuTQSQdo0UKZYbaqU74FUQ6OZjfkJ0lUkxSVU3BFsXQ7s4M220ydes6hqMDujrXF9cMoZGy4guwCS2otiCGCH6Ss3SoZFQ78HsKEh0CYziNaiT66DyZ88jUr0bsrblQtSMFBnikZwqU+lnQvuRJ2AbBAmfNTJdkWItEo0XIgBBOeOSlEQ6U6qNd1oj49taGS0Utc5pb+MPvf7+/vs5JJ979wf0zm04cnNzaNUxUOvWlndobofdMw7YXs3o1+IkRh7pNZiG7F311+cYw2jCRNyAhThL6/IHt7V0nW7zFnrEK/uU1kTXkip5yy/QxRFzIBucWlmr0y03JGI4AyUSnTtm0GaVzJKmLqU57eamGUmqsegb2M6P5qdz8PDTo4+jOGPtwqU9r8R3MxcWNdwtSLg27XeKi2rwTb2mjKXiWxI7+6UnztNfGqOa3LSOOT7hYPibPcWONBVeKRuzKYrFmYtKty1cnhyfykgxB4dneNm9Ni53s7wG+v77+w8tXy+v3FdxtNAPXPvvDirrVxz7GTD/4oFHamfZ9OnRadsb2ZbfyvHv7Wg+9s6NxZOBQa+OGd76klhtQrq+45Gf2suQgOs+HddYH+zRCuSCteNl2UUb4Ttp0tdu1p0Q/iVQkQmScy78xm2oDgVqYm5t3jzcASEhARYMhbCnTNUdaYPGWpDBfQDggjA7pwOsifl5M1J0J4wKQHQ1Dkn5EWeUeyjewtHyuGcOxtLDo1Oimi3/tzSLH9+/nfUF0f5+RJhwMZprP0ZX6WCUF1aTJl74qvE5Kb8MOwm9HMLQY9RbHglqRrpxsnx4CdQVWYZ4pV+0oZVm0hGqwWimjzHNk3cwk2pWfm4oN9Vh85fLW/h0lggHbXFT3l+HMEe79vR3rTBZyWGIqZW2HM8rrF83HOM8zklJ8nOhvfP1chXE0j08OnWfVsx4e7bsCFockFu/MgOP8ypYJ06Z9iNolIbZnOCSRU+A7+2wBv/XN63dxc4bHHLRpDWd5p2fmSNgKKoeM+095Q9cEVzFl0ZSIfIXY3biH+3v5xOjIsA1qPlpkQt+pWndnmkO3Kd2OH0/Wlqba1m2uxtaQugVoSLvkxrrun+dCSRUNb24c42i698paGydhaGx0+2Dnuxc/OAh2euVbGUOnh3uzNR3MS2ertBnS8K3s2ZXFxXvLD54+cj+Er0IuLC/YWbJ8f3318WObKFeePDweuNq7PB2anbwaGzwfvj64PJbFLiCbQQfJ2l1U/OiBge3dbRPveggjBnVKhowd62k433tAiYJa2ozB16xK1Be6wuhYG6ZUxO5wDalGvHx2Rmd8MmJNG4lDzTQQBQ+IT0cfWlVqqGk2OT3w9NSk54TOyoz5zfX84rxL6N0bhU2rXIbHtT5xklu9svZny5r2NmhTzCnNyfyryQDtbMhpIHqrJfOzrIWYF7ZVhJV2rfz2np7xIP2c9fksmLGnxhastR08LPSErsVbSymyW8fI/Tzau/WhkbHr85PdrQ+m0n1iUHUrQnWlW/Ory+w9cdl3q6pdCa+nYFesfOjJHb/Qu66s33NlsWaFMVKwl0zjGrHzyba6rAbHGrmmY4KtHJ1w0GlybJKqOJTg+wHZUk+xrhhQVqlM71AapmC+jik3oOFFKvj7Dx8s3lhtefXqhc14OgDr2EYrmpvWurG1rRbM+PmmUKyb0f6IzskYMXfTb+3vzC7NE7VOgqe4t723s7XDDaFphHByeGCAjP7BvnHwYrrSs+uD7X0GASpl54fpFdos2Fs3MekmJrb3gHl0vjBLs7TBdtKJsY2tDbcwPH/5zPw+E6YL5wu6ys1Mx+j4yOr6Ej9wctUHV3xxZWbwcmB+YhpDPhloBsqORHXEpXeZn1ONtI7O+KK1r6kcbr+f9jH66ytqxkExWeKknrVrEYaO6FQoU2bgokP1PXYnbuaXV/k9zvG5RFXf0LfzExQJcK1IyMqB59bONlFzhnwuTyH2DnKYieEmENNYPUrjdGvkJc9RR+j1BwpLLBS+7acnrrR0lhYnEIoj1FY0Fia9mMu244bEqdHY1JbXlKYD4XoFIP1p7WvEh7gAUvrdbJqfaHtqxggjgw8AzDSvjefS+1tw4G3Z+XjNsHnKhXrziooUMLLAgEu08ABGuowinq0BMOMQDKIwAMM8PEorBQxybAQ2BDVH+b1CwhMOeEgeLSqOF5i7sPU2oyIAPDI/FQ0hCPVJ+EFLATEv3Vt8IieIwyAjiwYGM3KB1/nhCpgiiGAGMDDwmIcEn17Ji6KIchEX2cooEZJmRmfjLdKkihlI2EF52Q52qpF4Kgje5CJDtGDQgRmFoAWPyQQ8EIJ0kNw6ViN3Bgz5Hsgs6/x+48N3P3xrolOnTKh6e7aD4SIixk3HaMHQW3/4XFlfu/fwgflHxt3OTt+CX1hddhh45f76vUcP53zDaH4OTpvapued1fL1BjP1AzTV9AUmGV4FMQt0J/yqFJKL/6Er9ROfhAlMIomZqZa4tLRIsOqUEORVOkqqUzEFAa2ZFTDe4pAEMOynvP1UEXDCpj0RCEdFOnF5kp4UtORqMA2A9nt9EkFjKzNXpB25RYdkzljeSzhFukJVEK6Mfw6daagdotBKgRPbIp4o3vGv89eN0W41pIpRh9zN8rxECgzeplhZbJllc+eWfYPh4v7jRzwawziSKr8qRscfI/v4k6dqnBw4Q8RosKP6NH0upnqniJkSqnkPP4FxHkmYCVYq6kEYfsKADb1gqxZWoXKewzXIFiQUE1eYZEYVXCQcjqV94d9PecWFibqxY2Ep3522U94rjZ649Naov3fC/OLcrSSKCGe2w0745Jzu9dymbB+AMRjkBpEDPvlk9tBZOtYR2sWkCGgxURizl5d/trQ8t7Q0pzlz4CwaAiB2FHm37IeDb8qVe57Lm9S4FKpq7coM0sD5qbfzPvVi74MVu+MT26F5h7xGYyMqor7QglBzyLYen3sz63J04Bs1tpvzILgsnroRXBm+kw+eo1HuC5meOj4xLrzhCthXG3e6LG3Zn+wKieacX2oHeCA0byEhmZS6JjYkYpWINHkw7JJcmAEQLTpVO7FgfkrE6B0SEZCeEKJCGsBaUW9NaopUoV9D0eRl6CBdEIcXsIgn8YHU8CRikXaiIWiQALxCSQU0bT9xCS3LCLhrTnnkEqRDCAYVkQ7iMEAlIouSyyUiRbgrhlydAkAEsNAZ4e+iytUZmU5se4uEFBEp4JsBccyThFcSlYvD66dCoQJ/xxXEz8YDgwIiBGEjkZHRAQBb88wWQMjmAhZvhpUlTbF2BYh41Wx4i66fOBGghRxFqLzykwXx9AqYFK+kNMNwQoJJcgAjbmMyqyLiFWARGfHQhqzlKW/LTRbylc+ehX/4+resslH1sc8/VleKHCdTZ6T9GF0Z1Cy4Lmtmyje/DCl8VtupGX1cfPkLH+6YjWLEOx5gIHjHLUPY3fSgfsCgS2IO0ViHam7BtLYoPpZQtHrBlfdHOfDM9vXGM043nDQyu154jFfnfDoBdcZChcAswOA9bBoMsZBVk1BwczLieFBZwaHYGt/ILTydJFUt3gDQK9n9BE8m6azoixbM1tlbVbVv3ObmBq6fHqg8pRm0iLqfJI8ZJcKhwZz9XSKwpYDFJCQm7KlBjQ+YFmttOplcCcOgeMHK++mYNBPCBD989GRlbfUXf/5n/9f/+//ty5//ZGpx9np0cGFlYXl1aXltWaX4OJoNPj70eGhsd3RigoPpd6zAGEYiLRehZL6BpSnasr+1tVkOUPr79fXVjE7MDeDCNLcq5F6ao5ma8T8x6icoP9ERC4/k0KJoJpZ8rG1L+qKhSm33MHpXjYqo4YIkDXm9Im25uvgU0l06ulDmspX5u+++04YJxKSCiiNAcvOTrAjL0PH48IDa0TqDJH2peoGkT0L05Rl0QNNTELTUHbSkLQXDXrVedW1KlFcbhNtbdPV5stQG/yEeGCaxaqwPG5UGrL46r1e0SLdktkrwCmaJKtEcb3F1JQt4QUEojERxMA5M2F4l0gi9DUBpSKsEVMlWPYSnt50iIgsxkrMUEcKsDiJmFn6JCiIdHlwhIQtl9rPzApAIuKlHBQlIHog0qhQp7S6Tkq21siFOKJeDsYlyqkg/wchCgo2BmMjLW7KWA9OkD9Jg0E/EvTUMARZ7PzHhZGMzF1qGm8WAJ6aVTXbpWiZIpVIepPHj2RHsgUmo1X9EkaaXaMmiFF3O0oPx9sVw2/WEeTCFLSMYyGX3Si5dqIxIeEIlANbfqlTZnQ5HUF6E5GoSMAC7U9NmWMGVDrDVDoS8FS/eU1JBXik0z6tmzBNOqLDBdHpVH7ZN5wqDQJ6AAcgoEc9odUVIMTMKZwODAe+npzgOs3W/BmQtAbS8kstbfMrV6bkW00S28/1TU8+fP0/1TadryWWNbgfS65wclehM9mgwFwyKt9pMmwOeI658shHzWpqhEqJKzXHBjIyK5ifqfsZ2Vq8pBSfwVCRDIrIXF4BxFVpPkFBofPqpRnAODw6VTooaMdTWN5jlp52MNmPvxJOO6vgorWV5IUYBA4SMlginjLXLNYa1aKR0OgCooMUP6tItKPmJFk4ktqBabuEvUyiaRkRt7k6QBrmuTU1Z1HGZ3VwtlSspPr3qigMPJ050hF4hKm5ABUanzUKQhYmGiMikhmN052fG5synHfEmpv+bn/3c6W4LMLtHB+v37s2vLo5MTQy8f//FZ5/v7e0rCANmgUcBGP0UMKsRmfCkQjRFczAnyPegI5rYVTY7zuhHsWGogR984h8z5jEynDJbPRixEKBEypmmzeGt0b8WTZgtGTNtBoe6Ad0lZVDjcTXOzthBEo+sLsYNUE4zg3diCMobsNnGhRVI07H9nW1bB1CxUc/8D97khW1xcUVcOsZImKvODNKuuXQ0MycOo9cJTS4wXXAC4cmTT777/l1qLddWai+Dpm1RpAYtahJqlfOTrkbsVymOlo8E1VWVras2Ui1eWG//8Ojxov5+Z+8QAy48zemE7JsPp3QyU4LZuBgrPDBtE0fGGSAVWSKXgWfw/vBgdWUBfsbEOGFvz37pmAVSkiiQvG0SIhRPaK2DJOnlzkvxVhalploC/fcWsHSWEgBIRP0U0WGK3+pzHY5j26R0gFmIkZLfM+pbI1mmXlYyqvT4LA42lhyDDmTnTHp1UIjho5HIRQRQqbC2C175yVwBkBEeEpEorzh4IU2tDBap2eDsFQaiE2XmRMB02WBAzhO8FDyY2O24nyWFDCY6u3SQyPkJs7fNP0g4ycV78RZQC6XzOsMnl+4ABmuHFMIPYGX7rjW8yKr6QukyinfHRglgpmcpiGZYe5YUFhWoyMRb7adpSQEvwCy9y+gVbsHDqdkgRHFxJUKwWSiuIQv4SLWmpGSJ+ctSdqZ6YWvqEU51ddJj7D5qAwx4aK7UOOl3KQAb7boxVi0xIK9ev/313/7mf/yrf2XHEoSDY5M3V4fcLo089zs6PnOwgzHs95r2u/fvHdTU7K2rszKQaPyKgA13+yBhp1BMcC3aS/TKDDgYe9g1CVlwDkzBzUcRjqALIwxUBD9LiuGW0HjZIq7yt2zIeChj+0GGbfC0xqLSoV5dxliUFeC7o8gpgsGUhREJMK8IQIRs8WAVQSdCVkw36loDsx55Tk3EN9c4Iq8K0UcXVcaCHPqUl3B4olTeaS5YFfEKEpux+NJ+UkVUqoiaXq7rtDyDbUMLJ0VDPcMObtG1L2oGQAkHh+ZyJ+7t0IpRNrlnQ+3fff2PLupYX71nxd4Gdnqo7BYzfHjeUJpcdNLnteaiE9cjbu9uYQAzWUtIa/ZwavrCba9b2VU8ub/LyjlWcOKSpZm52c/+6I9cGHW0f2SDIsZkoHU4/9GPfkR67mz9/NNPqB+GvWXcOXkHR26BOr44O9FRLC0skIDiE8HTp093t7co3myUZBYbZj/s7KUV+rPZuZnxkeHNjbc27GsDpNhoo9tOk9TlE9U0bkxekd7S8iJmaPL7dzvqiEjhsdjpqRvDjEpHQg3SReOZw4vLnKM2Vhy5ZHrM2Li2xGjMzL25JtdlgTFJr1nRk8hqZHRvd+fw9GJubv3CQbSL05mpWdhIzFOhbKwDqeA4zLH5CrITJ+1iNGiUoO1cugxweOAgn12S8VxNa4sYZvmkdEZPpTOPa3YxppGcB3LeSEkFAvdWBEKqTklbmcV1YHgASXX39nZUWfBUFcMpo7dSMtJkujN0jQEv6pnIyZAekCI1tCS9iAqTTTpoVIkQRj+99Yod9BMrXiEs/Y456d4qMz2AEHP7u7uEAsz5UhpDNGjrUVeXV2RPlyLU3m3pyJmmVDZxyVTcU90jql6bdayiCLmfnUKZpGBYWXBCwxqDuDUiRhMDuPU23NaXbXBSJfJIkBfFKjKCJqvTOYGHn46iDpUa1arxjxPPFpe4UvD+mp/+iUpbeVQw7yd4cW8JB04UwTdF2dH1VhEQ8goDsgCDxE+cgME/VAoCLKWoKhOBx/KUnyJCCwS34rAhofjEqCxQNTyEsHkihDSuqHSTZpnmZ+aPfXlr35ejz//Df/qP//Jf/NIGCPE6sBP3gRKxxka+JpbI28YtjMF//949F8NZaWrMSirwW0knMwk3N4qDHw4PrTCmxoNdcoAFPDTPLRkfSfRTWZRLwFsqJZhzaBM8BfOT0Lpc0KMl3UKI+a54fCM6mGmmEIyuwVt4IAEPrGBuqxhFqLy6C2CQNq6XF9tFN15C4mOjmfqvAB6qCNwu2o+Hw9/4HqyVIVtb66qcqcEpkzldFsC31Cs7AOUSJQcfuPcKGGAIeZKq05CBmqiy0Rk3bS9s7exNz7jS6sh5ETA6Ecowu7jw7O0L/ZlasS7iXJ6Zbz2myTIqdbi3a2cXtWYKu4xMM1FYmY5vanE7JzdpWmYE2F3egBUgBsiX0//0z37hQ/N4+/SLL9Qv5rUyWz+MKBRQOoFEJleXRvbdAFOicZflmfcb2fiw5dpqRoBDoLrBawLY1jBT6rqmvxRywiBFF24Cu9Q761IcLLJVOoGRxTmLY5SXyZbxMZbIsqU6ffTokc0jNAEb0JocA+mncRJwg3UVZZzqw5yEzHj2oIFxsDOCEOzrR4XY5dIX6t54m6Q9P7MkHdjKasYXz19/4KtMjZvAZBVjsIgCY+dkfLwHfnxsik7yivSXfhIC023cbxecMbQDAmurKzaaZCKkdtYuLToaRR5pgPAbuuC/OfGEQbptfeK1e/PczTZS7mBkJDf6lpJ+XHH0Vinoj6oRvFVkGIzcpGcjiS6k3BdeoCKXruUVJOlbVEzT0H5KIlDdzgtB4hUFR5XBaEj1rbZYQwVQYFnSpGscAF4FSyRi/HllpQLTxt5wgseZt9RCVywFQgHzyoCTMI0X9jerYVlek0gj7e02N6rtSUyIM2vHXa6STwkrgIQEzgbBMOpY1T8j6q2nQBW6UN7ytqUEXw01FAFgZ4e2JxxevtyBwWgGEZ2HJ/+CmqIFXmFhBkwCnnDShq6PcF5eCeRkRdbySvFWREYcNrd+SkzZSwPgoQcECKAlKV29+knzsAdAPNTre8UIQa5+G4+fBA5GBDBIEYyhpXgsjWkB2OAHL5QcOJ4T/CDScGsb38gcpYtMvvv+2e+++f1P/+gnkDhFQwmgUfMuyLWtUa9IcfLlgKtMozOOjx8/tIFncyNdjnpggjPCuI6pUlncWFMZfC7C3N7etPpmtwkGcCK78au4kuLWfIVq8ocf664MiowKFa+/9lYqL5fKRXU2WYJxZpg8k9dmPV3A7db+KK5c1MTTcSSlNrajhOxsGTXjgAmXFJEM+afeiSj9TY5K2E7g2Uvrsfl1fSlZRQ9Ll4CbEMdurmi5ubQWwPum6LR4sla5DQawZCe/gmuE9Ng0WtcIDjEAK3NGIYZcqGTgbkm5lvHVbJDnXw0X7NblSFpgHXK8kX9qBmHcMfztrd0Xr1+Y6Mfb6dGhjvnc7Uw6T0dJzcgfHe64f9BE0E06/lJOi9iXVhRuLrN2mmUGm2pcomDxeWR02dXSDx4wjoCXVpbdiTY1Ob2xtanqzWLpvElze2NTTZl4YXzdR6RasUomvrenKEhs7+129a2trywuzdsOB8DitfZCFNy+KZ94N310eHRtAWU0WXQAKPIqYd7d2QFJ9yxSeQVyb9uNoZZmufYuNz3OIrninI8AZh/JEFrtUDWPHBz638X9Q/YNjF49ffrk+2/fSYEHDIGLaMj6JFtI1bgAv/Rw6K3vjvEsbwbBWOJ24mJ3f8dakoilXnu45kdNWJkGcMWzC8eWKO3B7pZFXR+wJkyVUvj3Rq5GbW0wkGIQaCmzq3Qwk4+fR/un+pHJCZe2OgZ5rUr1PZoPZvAABqswK6wapwEk7MvMehfqic8GAFyldiY3XhGtJnNykyvwNbgErOKoE9IG/zIKMTLl2t7RgiqupcYjgGB8Rai6IqEBr9DiA5qr3MrtQgZ2BUOyxScX7OJS+hXLa4oKWzoKJRdBCAl5uwkBxhz1hJhngSevQJIIVPBIZzdRhLz7OinNDGCMIYRPAMAoqOzRTrsZPn4TCjk8gESLn0JS4BGVXV7YMklYVtITUYlphbXgoXSKDjlsskNrBPPljz43I9nM4Mpb1dwV7Kfs+Mc5/JCjhSXkPM2NSAGDJXKgeRIBSARMOPKKyAsbWn7iB1dSKATLQp6AFVD2RgveK8wI4TzrLHGl8Q8JeE9ZOCOE0D2Qn9AaUJecs+EBEkEWwSvI3fm1u38wP+1W5z23CP6H//if/9kv/ty8TV/oOLs4Z5ueLwb7Bo/GhkNOn7dEkUv3DCDIf24xTpwvQfp+KUNUHTD8mFR8PKMo7u513P7www/Fgp7EAmW8DUgErJI/MKVo5TGUcQUyQviUkWRwOzubwRkYnDR+AtU/uafafR+289o8amhPgC1ta8qQm5AF3+LKDcaMSnWujARUmPSTqEXK1QhXgiyKoyDSxRmjq8iM0OL3YSnTL8PxOWgFFXDWb7buztQBZJKhDA08suBZLQfJxxvbYQgPtcPS2+x4SY8eN4S5JM+ZmbnVkbXllRW3AB3sHtAlLqfPybMwFkLPDo/fvXrtE/MHtmjbDRoXSsenjBmvhTRE3OjLMTd54HByNnNTIp9+8rmPzKgC+E2FsdHT5SB/2NrUNhdXli1kKJoi4woe/IvjVkUIYWNqnEapHf069ceqtXBNk3MGUt2R4s5eFDgzMwaXHxV4fzfbHGu/bA6ZEyyAw4OtZ8+eMRqcO1VMVpDIQm3iali6yObmKU6HCsJGS9vaok8IkBh4rd1H7FaWFl4MvR91uuXyhDjpuDGA3dt7+zvmS0jedJhqglzpdKvsjXkwSmjhXkG0GnuNyJGLZT5sfnb16HB/cfkehk2OkQM2LE52bZpKOh6Pu6AlsjM2I52e5Hsqjx8/3tveMSGYPVf2C9mBPTPDgEyOZwHvyJUc5vjifw/baByWyjtP6erEuK0WlOS9ywJqPll5U7qP37V3Lhokh0Y6NlSEt+rRdl41pVDqVwqpEgsAWwywzZeu5hZytjXHAmBURXrn6bcMoD0JVyJGPYWGIS+vGBRPwH7KrtqCqPZxqip6DAOLIxc+cKPY+IMBTlm4h8BklKt59VTBUqCVi80VkUUZ5CIFJYHTuSdl7nICgFZV6U4yhzs+pnHaaOXp4jPbRXg6ivvmnW86z/mG3Ks3r5kwviRaMGMSD3CKS8EJ3roUSHgrET+4FcGGasOVLIyvFDyIKzj54BwSMpGLEIDRg8YsIkV2AFLEIVQiuVRAI4kq1BBbRbIgIEmAG9Ly94TZRJbsKCoy/DDAg66MiEpM8ygL6wkh9SX5JscLYwOcQugTBlHxM+e/Lhbcy3bqpB7tiakVmV9ccszv3YcNDpOILeTcw3fvN/7+H74yKcxvIZCDwz2GGnJSsjk6h0KuryXyAR3LwpjC+mmvbQ0Rs19WdZOQ2Rgrr2yjOlIRZro5Xb7yZLO/PYI5LWWhzFU2jowtLGld6slEAVOsUlpcmpZWqvUqO2kQUclKj04JeSR8M67QpRFvVlPrek+mmgHEkpEKTuTCvOUQUoXT9JQ24CfH34XgkNJ9i35sJevOGcKSBpNmOTZhqzX30PjQXg67YghIl2tCxmS3WWWHdf3hfGVl1YjLJTC7+4dTMzZHpkHZ40BtmCry8SstgQfDoau1AVzhRzpvXYUypnoslifXwrv4dojdHrO/fWxweOPd+++/+cY3bV2QcHV2uvX+nb3APk++4fK+w6MHi8ssvX3yx/sHjoy9ev7CgQ+jWI6NIxe24Vrc/7C9s3r/wRd/9Md/9s/+4n/4V3/1l3/1r//sL/7isy++dKh7xpdSlMRSkWO9p2eKbG17c2uHNqricxTP45pQKilaN51UKOdlfDKXGqzYlnp8aFDBLZ2ZZVKGlm3r1LNemyLfdXglI/6a6SV5Gqtp8JKNQigVSzUzPaeumFoiJR4CQYjl8lk08zwqEbxBiWtxI6JaANP21RRHV80aGtITfGoOjnpRATuFXNRfltVkqw9/DhobWcHafP/BcSWbOBlEnbaLarj1MdMWq31zprxYvQQDqV6wauOYYaJS6EWotKd69Aq3/BmHJXRLcmHYMNQrPNA3GSViB6tCVKAmCfcOj6x2mLKzEdQoAQbp5KlRsNbSlVrjUljNnOttLQUAabdF0hz8dRZWKJgHb0gb/mIpnRnqDEXbUrm0U281GbnUl0jzBr+In7drj2XzAyePloAP2WQWkWjfmp9npxlwydYYcaDUmEASdhlRVQ3V3uICt49jO609GwqDpIpSf0w2MGgFYEgoMFTK0FyC6bfNPQGpe6Xig/MvVDxBy4WiAR0GuvC4EvFMEWqoIYIQwyqRsUBLYGQJAqSMqbaafJfCTonTdsDoipOmqSqTFY0ZRYl6AlXLwsLM65Hy5MkTB7u8hRxahgldecUVB4DsZNIsdXNqDkkDD7D5KbsINmQEL4W45AXfdBW/UcEjBXIlIkms3uEEoI2pICmET0mdDnORHCpweusVJr0VIQfpjBEmRXBIzzDArGv8rLN0Pej3z5999duvfTzST90qpw7w8fERb11FDI6N7m7u4Ad+mBlGXaxmmSLYgao1H6Qzxi7M6OJBIupMQN4eZfm32ZPCUmBDYDhgAyxuKtxTXJGJpZiP3yAXWREayXhFLATSieKqQtfsix3aNaVQWSDxKSMkYbWE3GKsaZj4SrCC4eQAgFwVGLDTH7tWYPYKEusZeNADePoFm7FXyxxdKamgWkWDULz613imcHZgDKR7S6TBV3OwMLQ+6H1rcVAfxF226938J7kqBCucJXSDid3t7LjjCWcTp9Wy1MvIoW/VXrmm5vDDu/iMaL398J5372Du8eb+ip3tC/PTc/O//OW/cFQQUQInWNVkwGfCQK+sppQlElAByjAyynHze2by1qnE86JzfFzAnW0NwXWk9ntoKLblTFxPkKnJl7WVVafDDi6yMQSq2pIb78dYBlHFjMRqeU/F+WnYr+BKQcKCzntnc8sq+tL6fLL3vlvNOdd2R3sZGdKDivJCq4eznenggJk5ZPrYIfJxtYYRwD2T7wf5OjzH/+o6Iwzi3NraYDTW1wwLRqmfZgIhluyrpD7OjDgSqt7Tuwz9AJluQ2Uf7+2f67gnbMqYp0O08dhH5500G2p+rnIIoHYeK6cea3TsZm1txWr221dvYLNHlrLrDbUCMt/d2Xhwbx07u7tbSmDKQFugfZShpuzid4ijoryEgHO5FJ+UlF0cHulUFIw4MHFv1bt69CpaURNfLUPxzk5u4uD7CT56XDRi9L0ORH1Ik3C9ZhBD27xhjZXASBf81N5QFSe+wpDxcJtONQqPypMXANr6NzUkBWGvJFqrk1HlJ29tA0XO21L77JRCQt1QI4oioqjeQgUeWnGRWBCbwdPMYm2lIBHk1W/JAl52ZVRm6TjEm0RgYLiNcskuUR2AEWfWObsYMCyVpVUEBlmsLOEHM97iQaLs4HVIRNEkAMAvHTy0qDQ/Lec7DnHScREZZQEGvpsN2apXnONHSRVEEIdEOrmJYwBRzPR+dpaNqpn0aMZ0Udu+r1rXE7lggTkxnd3CkRctSFBhwFBxVNtPEUbBQJUdVLIDG/HOL3/3+29nJv5/tnz8/I9+Yinn5NjWjgwZY/mOjzaebzjqzFgYyEswN+NLspk3r/YJP+ZN5Cid1gUA/3xM6wSzFHtkeHZmDqoMnq4zWNTfKV2Uqs5Paq5qiXDuTolr21BIc7OcWXXOEM2xs50u9TwnnxEXcNo10zVLyGqbanHx8NNXCOmlCMEUBYHjltLVllRaUc5NXdvL3zfHzx7qBdl5VRRrNnRj6cJMsHJFACfmOih/1MZBXEXL7XfOulbbqVpKZ0OYhgWkTgVTnMorEh6qfjVxqK9HtEy6Df2F2WicSzd1wBg7zm2leajW0k8Pz3c3t3wJrJVWlZGYeZE4OnYRMRbnl6ahpyZGdQvixjKffv7lL/7ZL3hRFpuzKbTuqjI9hVm01Hs0obouGu5E6+hJNuGQIrkdbO/mNliG232xmgNffW5u1jF4/Z9jzr686IDLxKRZDnggcbA5t78tLcZdiDscWVVd9FqUpVpjrgG9ERIQGqEaVNlwpSC+aXB6lGl6KvFobc6o1GZeowpnwQwXNIEo/NysKjDrphXaqZWrjHIb8WU8em3EXTJK7gK2CbsSVjlRO66SPZpgVRSHRmEbM1hStEePHmr9aBnK2+igKrWmocFsa24XE3B2X1kK8NkZWyPOTkdmFtSRHcRprS65iktuQJkmPH4xTtWtVxMC7x4Hymiyka3wjQADSgfHtQKDIUfEFXZr6z0eXMdnpEukF/kETm3Vo88ZuYQEnlUNMI3aE2aJBsF6TdxiT5EDM56VSBpr9GNQ0YZFxtp/gLVomp9AxL31EyoYRGIuiUMQ8Tqx2pkEDkSZx4ws/KQEXhK+iJ/NVqOTl8jUXDSgdrxhDmS/VWKtiYX1ijjIwlttGFp9ury9OQlaDKlbmi1OP4gJ09hoTx8JpcWDYkvELcHxguVK8T/uCwIge9tBTIp726VjXh1d8kqQXp1rCo4deoC3aquZd474anOnAdmdudc1dgG5+XSF3mCDKz03G0sHOT4x6RUM0OIWgFcCcgKeJRILip4YE6QDxqpXyg5GwQEI4l4hKtJVKJfiQ4icvPALMpI2DETpLRhZulyET0RFPB6EREEW2DzhAQ+PvLLICBV468UWLq3+udrL2Y3nr16afp6bnqGPPEP5HXIiWjMnbI4sZIVDq0AQisPsM0TQUilGuW4diOgsow0ORbCqHqSMnojKjSsY0hLiZKdcIim+6zVr2AGMVKU0fhPyiiO7IG8ndonAeJWDndfxIeg84aAVcX2cvIbKfI79JzICIB/4KWWol7ak3ZaE4RcHJgvObDlvuoh61XTFYZAOQycWn0b3UUtvBZHG3BH8tLTBiwFAOiHLyFFXIVdR1A102jqPYG52OtNQWq+xzdXlMU7sQezDFvkCbdYb5xeXl9dWd3j1R4c/+8Wf+kzV48+ePnn6STY99okT1tkMT5WXrvIiwkkN0A0WzT5cnJ25EZRBV0cMzIP799zVE06m4nk4iWtRxY6jUC/9TGstnfRW/9GiVo+cDxNZZwOuGxlNt1+jcDaH4rHkfuJBSfGMAbkceXBHBSfm9GDDNiMAXtE0yxkp19xiFtLT4984mqDnYV5hM52Zpexzi3y549OKFIPqcqPx4YHHD9Yurof/4Q9/mLqJUa5uKPMtmXSp+y3YDD5NxlY1D+NhIeQmm4rjTVox0Ze7DkW37sxj36orXc/viXmXTVgc5re0GUGCg25lh1KgpZqURXDolzZb2ebmsGlLuXwsW0UUWdPL7Ttu6h2Jhx3xVsASbKJ0QIQuiasOP4FRG5AiJOmtoI3DqWipsmoUIEX0nUTXDfz843c9CRa2kkOehJ/WK1WAWk7znoJEmXVltMQuQOkmSRBDG0OBKETNioxsFhva3CgbeHHlp1KKjV+tSA2hjSEcswvw4wBkvLmP2yL5XKbJIp3LC36Znz5CAoPS6jkyfeys9pz9cAc8JVM0hqJwVnuLg4wrqPAjomie6EonGhi8wrD4R7bjx2EAS4oJzE+Dawuh8EOCQ8DYhgoJJRIwICW7lUuJlcXElD3OkAOWKMDTATz8MAMDIO4pqDBxAWmYPaUghxBg+FkfePDsJySYEYe/WVIocTyjAhsYTc6rw/1M4wj5hEDdtQez9SJosU2MjYfEOhf7KG922tQyjKd7Gq4Pr2kke+gWlIHJUbfK/Po3f/fpo0/Mh7AI6C4tzNntwLiZyofTF4OHfAaViDhMRmBxMqKjDGbWW6s4WoTD/WbKh8bc5GW+OEumeMPV3OysAiqvVsHgQ+iYTCl0unmuGSkpEYZF4CcW+EFqjDLqKUKvVLeNqokIX4BTFjM6BuYkbo7S5hIkiBIGwLBBF8c/FpYMUvUeJGNoorLHh3OuUBFwODRqAcY8ULYn1IghVay4trmCN7otlvhSUEbrrIyERFkCmDHCFGLeSMUOC7oJBv3kqt4rSaW3oZ6vm6fB89SdkATBnrEyygsPaerurHkY84NZXl70ys0GrovRXqzZjJyeLa2uqIdf/qu/dBRbR+B6yN0Dot0nUlvyeIiomyzTEjijrKXLPg72dqbWV2ccUDZ1xOie+xzFJbs+Np2tnw78uSOI10nBdrY3Of6mJ8zOW96M+rED5eicunPCeexgdv93rgkwiSSbhZDULD81s6a7nng2sWftR3aNmmJbNdHUXB8iu44PoWDOCC83hSgpGMVvBXAZnR6FqnHOjTNwoB5l0SgIPbd72fSxuDA1ubi1e6THsv2ftPUNKjg7WI9yuwZL9+z5c0s+X/zoS5pnWGkhyksXYnXVoKgDGLL/zq7ZEc7BuaGosiJEb+1zVFEYo9ioyyIvl0hVkjNNW1icVlIDcdsceHYamo12bkkx3DEIU1WPHpk6fj58OTg503vcU+mKDwNdRiBq4/aa06Ox3I5qMuZSe4dcInJXN2xsvC5xGSgmxvBA5qTkJ43qt57iXrUMgckNoQBbFDHFiNnMnof8V/4HpEh6xtbspcRWETV+NZpWUGZURjCsFRrKDB1gPznCsIMBkP6j+i5sBXnpvXLa+AaVKoWh515xCUYbkYKcHoXU+BGAQUqBHFpvIUFLSaJAH4OsotGbKhHOhdArijgBAJWIvDATRw8JG1JGyEnCTySgQlShQHpCwmzRbxF0uyYaJ8YaRnrhzNCnMUCSAtWJ30YLAJh0UkKR3AQ4iRQAVDiUt4vmlZ8tbVmQ8wrz4l0oSDSz0VjLUb4heJrdcsCDLSX8cLlgkNFbFFFpAE8/vVVqrwRGATZ3zQyPxS5TU5punIa5X//617OTU//6X/3VH/3ox5gwS7i9s2uuc219VcaWKoSwwWlspyCtbWpDawaDYUwaM7kVBXwLATP4ZIJl7CLz7WCgMHRUfdJPWyVaPmAUHCplgQE52QXpgajuQaK3gplf+kPhvGVcxeWFucHEMcMkCbV5KfKB6pZnjtPHPQLIRf4MWum8cpk+EopgOiShMdvIKBeNS5aP84HeGs0kQ20+BokKDQcDlZ93eKQIALuYTQ77UpJl8Na5kSs9lQGWKXuKlMn64fmFxaOzd1rHvflFY5Tle/d+9LOfzkr0jfIH9/EA2/r6ff7Z27fvzJw406RyT49ZvWX+8urS3LjmeHO9OJfz25laq42nRETPX718HZZcUmY7r+2eC277mFZrmqLOlWVHhdz4HzbfcJssx6JoqMu80BM7fX3GNwyfZCUTz+pCqWFQLhUdne2VSVMk5S1Jx6qCEogOWOefAn8MEWY1ChVuHf9y7wh7yg4Jtdva/DA1NWZLQj4PPDx+PZ87HF+8eUsffCAHy7wpngcOUeHqsQ3ml5RieWXePM/RsU3DuVlay4JWN2YtXjsxMmToZdEuLPsqBf5dyWbHlErU6JxNs6Y/NbXkJ7uxvb1j5sAf6s7zm9DAHrZVvJ++7XZxduTWUgXU7qGSy8XpnkEW1z7uPMlUWbNnxMoaMNTxQNoYUIQowMfVTTbKK2zbAgaDkDLW4AZhYHo42Kg2zNRJCupJ9w+oh4h3choQewedFFXSbQMxtUUo0qMQ1ZxSpBKlXPgDiYOm3emyuB9UHDv8KQCEOz6SLTeWO4puBnpumvcKUSWlLVJEVCoqgrJ5JZHqEC7lgIoUUPdKRvw0w55wUpVQrMZPZDICAIwo5sHD6Sdg055FIQXHP96gpdA8QVreeIx7OPgQKtr+we1nCaAlmSaHhy8+/5E+T2EZOLx51ZKRqyPgpUOoCM2zgmAMBhSRVl68+YkfT6zK2KJOjZTVg1ZcOk4wLAtgiXbnij97/pJCi2ADIQ0SsMEXJMriiW6T4DRhzNwKVC0TCKGinTp2FUlc8DfzZsgxTy3+43/+LzaJz9mFNDu9trK8dv/e21evfa/JORfs0RJNijuUvexl15CDQVwvO3AykI19tkL7ftxNbhfANlZt3mAyXJggHsWYyDQlT9OWO8Jh96Tr3SSylLxOsoJRhHby5eH3FtrbAM49ASeH/ldSwLRBnBwVofUTQsA9DuCRKqbq1rwAy0IC3rL2ZMhEwm8GPfpTboZiAmNz1R0NUUAjEDBxnLJCkGAxQjur2Sy1Uy2FhS6ZpBTdAZR8jHq7C2vmI//K5lKjpNStRIwOs6Id54oLR7T5/rMZ+bEspn19ENg790Uurq7NLq7MW425f//w2LLnqOuVsDRpR26dgzky8Bp0UMC3iiY5irx+a0WzKy6+XNDRriwtP3p4zw6Z7e2TwRpOzS/OXs5OGq7ZmT+nGbIIQ2bubxSSLePP8t3IkzJTM1s8ztyxepXTWCrRSr6vKhOFV66L8Mlh8xw4J+oeVSscSUpRDOpHmIwBwfK/XEtEdeXVWMDAdnGali5FLk+Jxp1aiG1s1mBR3Nq0ROELRXHHYbOisbby1KglKzXnp4t2ti0uwEm4GIBE3JyBPkA5WOf9/QNbtDUQtcPAqQXk5kfHnFbBoQFs15HRl3TZA2AkMTDFflnZsQDpq9YYMy7k93irjA7Q4ZNewYBD26XOjo9RlAiA5i+7q+7qjB1zooIsfVSVkYGnGng6S9YXLdpMRNgWvKJEVFGkE2kI/I6E4Lwy5qClhuygPQyyRGi14c0SGoCZhcXmXzrbKS8YKexgDzpKWWNL4yBDJGKkqJqJNSagDDQayiAoDABCSfMoDsAopFYhixQwKAkAcOwmLeYGZwhzO0X8Y+IpQjWk0ngNNZeqZ4QFG6bpQeBrj7YURtZPOEs6Mfr9EzkR+AV0UQTQQUG6JtBqodDjZhiAvoONQlsWhcU1nNLHpmMQKYohM+Yhlx1dDNBXEQWHGSR4ozwkpGCbBFQ5h8JPVFLMemJMMcGTrSzSpXiiArmMjc1bKV7hBwYSEKRIh6dfJS8H4fjSmW+QcOIQS5TYTw1bilwYdnQYM946oA8hBvyESsSTUoGBTSAZACoXEpNMDJSpNocwx8Yn8kHW0UG3977d2Pr6m2+++PzLmekptwG7D2YQrWtXG5oHYJMzYpNXQTCjjOrfiVF+s3U3rNFc2uuQK63SUEw0EaaG0xVNI3F1dm6+0A0i88rO/SjWlDpdUQmKZ5Ru2/yikhJIp4sISg3GP0XQGikRPWTZw8/gUH0nkYfhZ9xJjFnnvx7NBjvMUk4UCepg79CKOoAS4EwUMfc3GzdQkuDXZ5JbTt7W8p82oy7c2Nz8hElNA0adK7PPfKs7i9Si+lTzzpbLedrZQXhlAAJn16yIUIQop+0l+d6LxT9smDeTAv+pPvYq86gWPY/Pr548WP/iiy9YubUHj8yI9zSIhei19YUsDxwfr99b8nQ22DSpbz88/+EZca2vLp5mu8so0+PYl1lsGnt0sK8WTIywFEOTumofaY6zootCd3qu1uHYivA1YEYCV0pkhdYqiwkNe2yUTaIsJuFZ1Q8b77w1e8wQW2Uxb+tohiu7XSnB7FI2eFAET+yOm+0f7CHUDUFZXIFg2KflZHOw5kMDDEZNJxJ97qI9dww9I8uhUVclj428Z6bT0nKizbD1wvFXJ1Jk48Fbns82JsOk2zs5rvsL2OrdTp/Dw3duZHv85KFtUSdHB6U++bI1BdbLEbVexi3O+iezPIYCvqZpd6llTIMbU6E6IRQ5AJ7D1nKpyuWlu/E/HjQz/TU9cL1LIa1rM/fOSCuCJQ2bjx/cX93Z+pAdO3r90ew0q12hitHNnF5E2rRGQczapX3NzhORFxTV04wfDvlk2pHsXnXTExGokyfkyqIW/aQV6ghOeXUb0m+Oc86RRo4Y6dgCVqTZ1rgz8NL2tNghm+3OzQCaktRRmCwzJ4MSXJqiJ3T0rKu/zEeMEVPS1ayCFcjNYgAEkgLPSNGYvKLaFg8cHbLsPj9vqtrGwEwa191JmlnWT6pJaZbIMb6yiCiPoosgjRloy4Jn8kQQF1KLo6O4bchoSHnNNiwsr6y5kZXH65ZFP43eROxuMAZ1utIMGP1I/2yX21hOmSGHeXVAAc2Dmx8H6QMflq3sYRChvkZ2hs+YAYwuPvGGotrCp56s+YTWK7yVeQoY55YRoRO0Qa8unlqpregagLdUQIqLrjwBmJZUV+ZPXQH87sOm6RhsYIxUs2O6fF7IkabWqIu8f/tua2OTU6OFG3jZUZfJ3upi0cet+sISWWHeV+csfY34gMXU9J7v9A2OXg36NvfQ9Ozy81cf/r///j/84dmLX/3jV1/94dsBl6zb6j7hdmK3ZvpKBt6nfOjXMYxU7MiYD2iYRXW7AB9fQ8ptRSYobZG+ufadYTvT3Sbtunkuvz3Uvp9qYI2x1lpzQRSP6HL+FVPXvvpNFd2xs8/b5mM6BuzJKrMRLGNWR9vjduIgl+f4GH10z5/FTzXuOwkYoOoUXl1TbMcM3FA+Mjbllsyt7aPNnSMXv9gLrsnn2l7b510yrJtxC8jCEm2x098sqO8Xvnv/ga7au+2PTuzsbbvIwFknWoeg/fLWD009D98M+DIDh5FDZ2Ni5kbNEWtXzN/HmVw3cVv1PWP2Ts4cxDLetthgpoDcdvYOLCUMjIzv+LqID3DejBxf3FwM+JDy0qNPv/zij392MzIxOb88ubiysP5gZnHZLduE8OLFC9MRywuL/Mrj/b2F2Zkjd+xvby4szePFBBGfZmk5l4a+ff/m9ds3hoMvX78xbtjZtQlihiJpoMyrr4FycnhI3CDrn6qp/5hgfZj2oYd1aagPRdjvX4u6/NB4td1MXCZBo+xlWpibNzDVBunh7DSrktG2mRYX4+T8tK/+7uy5bpwvd3pxYgV7dMwX0C6+e/Zqc2/n4OTQsrBaczPR1s6u+XiWy9DMohQMepzMfY4Mb29uUAGaPzk9t73jYIceeYY540MM3pyvrMxZBWLX9HA0xLENqvj173776s1L09UGcidHPm0Uq2XCyqYGHyi6HrwanRjbt9d5ZNRnLigDY8UU8Jvt4DyRrm8v509xXK9EKXNn9OnZ1vst17D6uqVJDitG9FLvq9tyhsaV6Vbmbf9h7tvY2m6lIZtR5H8Y1uQiaJ5DbmjNMhjNF1ChY/SQ9uoBaaWVFPxDogOrXjbrK+3YbW/tHOwfkj9rSeDwuGLH5wKMCcwLsSSaPEjpDoZSQ43U7Ub80DgdKOkAyVNB2Uq1roWISNela4uyMYXeqk5VyORBh1hEUDegUm8mT1wWbgXLgpiSsNqsp8Q2jmAUTFchhVk0yiN6mGXUE8Bmvy+6yLFHTKpGBU8M/cdV7BjNMq+Am1sYZG9uFQFjAPwUmroUeMSh1WG6TYX74y3ZQYKTloC3mJQXPIpewQwMAD4BK7sUYA5M9lt0oRUXgOFHkUXAQAJYaJmItDn2ViCTxuwpb1c20tKJV4QRl0W67ALMEAIW23j7lmJh2k8ikq7hgVQdigmSeMVxAhuePRWnZQKsqXiSVXMCuGnh0NCMlUOx7ZJ90CY/MyBwLmpo6D/8x//yw7MXf/3Xf2WS4buXrx+ur41cMdDZhuGQLf+a8vn+jYU2vM0tLEKLN5e5rMxkDdZclVPLGgDeow8Wck5O3X8FTAPj38DVEiATMmTL2CxWFT+U3ugpPkyN4bzlAyqsUugqCM0bPw+O931dTD+pV1MB6lDDefPuPS1iu5mCTEnFlUfTdyqt6JxzzxQcP9phuxru4JSFbDnihOO0l9kqubSL+sSmIbL1MCPdNKqRGU6mC0IW3Sph62y2tKlQkzM4cyvb+JzuS9+MRHaOVA9N7OqIRm3FKZY8qpj2v+VGhKMTK7p6pmwrvc61DjPzC2Y9Hjx+rFWzICg61oeii74fPnzsk0I+Ojvn8gm1cJJtwZbO+N4cJ5pJi9ZWVz/97DNq72qadTsjrU1OxIskZxYScZfd48opSxgO9vduzlMCPYGbwG1SYXZVZTTSzNlgzt6zbnLhkLIpgvkoxojTSUSOSqmIcrni07B96kj2U9eLn2T900S0t6bRVBD3jrjGhsZ8QcYZOGBn5o6M7czLc2VcIs1nc+f86cnKwn0OsjBycsQWuqDCvjIOyuarV5TKnKSPjBbDpKXzH2PLuOeXw+eTJmncm+H8YN0WNeQ4wIUTD04Kx33m5psmqrGiD3BqevmYNXfEKGf9/j0j++cv3jjspbDUz954I0N9iUVyymgMZJ+VUdHUoHXcy2FeUlpo/CpfNnUKVcemrZkfk7dbn6pxOHv3cO/YV6ROFy0cwBw2eTnGEOmknP/WmKg5z90Y2gTDKG9MTWXkdH6igXE4KCpVV4OePVeGhOAYXXzECmqBPOFXX93kbSzVZ0pPw6lJCN2vZfTYTUkd0iZqgQX25eU5ieodCjjJCyTacNCqNKePe4f9pAr6Cdmh7nYID/JsEAwCDN56ioMRlAoknBKbB1lQbBPWWaQL0uUFLJCvjLLgEAPwiAAGJt4RhRSXCzyEXjV1b1suOZhWbjhsmAepdBpD8w9/73eSS9n9bFR0nUUQV65moIUmBZi8jRNXqEgBhg0klEhKCxBL0lOSjO9i17yCrVOaTxhgQ1cQETpdxoijdiuLa9JqAX5C7ixQodVcNQ/ijR+GjqAo3qw2UXE4JQoiJpe1cAMdg1r2iCqy7Nh0PGd8bNXNbr7r9Dd/8zcue/n8889/8Sc/M/cMGqu01qDfqXiWl/u8tZXjEdTBmViqTxScPh/KQIIFb2mL41Al4eRjvadm2Rol8sqVNpMTOR0inrufwnkxmkHxxc2lFcZIT9NVusA7hjozN3h8YFhmJoExUDIjcV3qq1dviEtZTDRBZUqdz6VOdw/22SMldLafKCCxjd9EtplRkJNuRB7USZzkGv+pCZF8/XU8Hz1xIwArJloMmGe1CT3eMevoOD6eU3Ojwzs7232BKCrWuKCn9KTx5u37xDn7VhIsb9hQNJAO7cs/+uNXr1/zOg31vHr85BOni00dPX3yqa7UcBA5HKqmHz9+NO9GTIIaHeFoE7t+mxiNBX1GZWNj01UEDAROeDyUhPWfnZ0ZNxwZy/3G1nHIHTyrbEubqRIulzsVIoFrpseUQWrHU/MmRq0Q+7rj3PDj5NNJ9sgzuxSE6ac7hKwiDCbk4vyoXFqRA2W1rVmfqlEokWYxOcBFU6k3l6NjudbfJ7HHxiws+Y4W9rY33lp1UyOazP72llwQ2hl4uQGl73K6DjoftEj7odUYyqE/+/QP9RkOx9EfHRWE7D5Dr9JR5M3U4HM002X1NWM4BcJkUimP0SvD6I04xC476h56cXltYWFod3dnanbpxBRZdgWd2iyqNzJzkAZ4PWClgxhpg1abyOTlwhRzuKg32B28MU5SHIdYLcDgiilXdkQYAN8VPTk50Nrxb44GP2Tlyfh7VvluLA5fnFwMu6naFbw6jfMLjGGS6gLmaqtfs1H4URbzORKNmSmWdGjbOKQi6ogrAQLzCn5BeuZSyVouEb9B0FvovBZhX3DP8DUB5tKAGgwmAONDlyA7biSCASAxrlPNz8AQtmrplWgkNmZx2SGRC7xE1ayfZDJMzhArPN7iwSsAOAYJFXKwwaNgnUKmqqQTpcPTJZeCsR5bpM5qGIGudVo/GydySICPktX+GblQgVk6YORkxAM5wIaoJ5gGIzF4gMkuHR7xpq50IgjB5i34BhCBE3IZW/LMGnKA/RTAK4WaQ5FUQUoEIIh7i4eWoSxQERoqtI3ENBh08VB6FsMkS/MsgnTzJh31lluneCsjEoh6EhpseJDOIz65OtENGJ4binLxMgROeZzG+taM2Y8//dznIHmdmt/IRLQ4Lczo35qVIxquEa1gHIouITgQiLSZkjB6koqjfC0uzDSfDHJTz/yO7693z63JtOKagvcdxpF0DEYeGCYxojCj6ds1LIWNhXg3aqJlygInSR4dmq2LK9PVAb8I609XTcqACTu56mN8xpU5l5fOPRhin1xZOLH3LrvoULHu6oICgCyidZHIObvU860VX16BhC8PrDy4tCzTQZxCpUZXSTNu0HFRv+sBZw1VstpRWP2Uz63g1meD3/3hO0bNjOiPv/gRRLYX03fDh1TrxLh2iDcjKqrrYNfu/t6f/cWfH52fmm3ndhIPmbgszacVP//8M2uytJdsmQm8uePMzQdW/1lmP3k5ujFodRgIrS0v5fbKUksDL1LFf3bE2vcScH6bpkFQLHBmHR094xnbkCGdbH1DyzYhZ8h9pubD5iYmXYc2a1fS1aWpCVRMnRK4mUw3hWTLTOm5vmfZjb+D1yfntpD6Zvoxn5Tnm8KOjbHCu5sbpoAM0XRm9FxLuxkyhszBIBPy1J7OQ+v6HC68tqD4bL2NO9mQmabqsoT4gs6hXg1mKQJd+KkNbCTjZ6qJ7RqeNGTTJtuJNm4mujsmkeAdQC5kOndqxuqGeSD1rqHqDjGGbzhN94NxRkFvjR+6TxSU0yvHaCBUrv7JYLDXfplQ4jyeXecYfzVTT4AxC6kCe5DrN431U7riwExzmDJPfFYXhs5lthD3Aq3twjUglsVuSk/eTCxqXarhFSQQ0uo43ZCCkIokoXjBEHAHvAJHObz1Sq3I0NzTZvQkAiAs1eCn0mpvjQ0SCJtpwAJsUu6CnzDL1SnNgKd0PEgXwQbRo+un/a3SJbYIIBSRztBk64lZ9frAU9bgYND0dJjcf91yLqTkJ+SUHS2EBFrthw6Jqw9BQfbcJ/Wxd1Fb8kKOf1TEW17iXiENssUCRh3IDqeCkI8UyGUEBr8SyZXGVkEuYC3PfsWVAyDRU5BdLkWGxM+GgV8cG3ACQEUKywUSdcj9lKgg+IRKBLAIeAL0E93OGxr/VZAIEhXAYMR9JRgJP2nBlM+iml5R5Joe3Nje8s0vd49YWtRdMEPPnv361YvX99ZWnjx6/Mn5EzPjjgi5yUhZ19bvKQXT46S+gb/tGQzCoSVNbpSJW7sDanCJAbdvG17zL7NWV/v3WctM9Ko1R8cyQhB0iul6KU3/rK9/jNEGOvt/MnVfP7Yuy2HYJ6cVZk0Oe3Y6+dx7eS+vmCmbpCk/0BJlwbYICxIkGwSpf0CAg2g9CLANQ9aL9ShbNmwDNuAHCzBsSqKoAFI0dXkz7wn7nJ3j5Jk1K6+J/lXX7DG/M/s7vfqrrqqurq7urk7kR59lggOdnvBZe5hvTgwBRUMtjQxc/4clWRMDIetQuiAhcapr8pmPnjubIbOOULvsBhWiQCDOlYrZk4EZjugjOo4YP0gSnrUfNqzYE8COGrpdhcBtN2CO1eeQ5PiIk5S0PeqIEzbcvGl2RHKNSJzUOWIObN4y/f2jY02DJfzL65vLq8uWjiwvrYRwylOdnnJh7/sffaisFbSiJxxy4Jor5xywE6OmbptHJ7JmTyyvh1N6Dvd29CVcxCpJ5FrjZmmWvafRw7O42T6v6KacnDuF89i6fjFu1IK2XCATp7cSi6k458vRPgKwUoU68/lFXmarHCDVesNFAiqbNprA5cfttdoAlp1FJvD9vaP94wMa19puaSdEosj+Ut20LWNxyvD58KJ0lYYXpicUCuX3deXWpru73QCs1GKq1Krx9kRYRKZQdaGi6mHpgJKzyNiaE8NWq79GBr0W5XFehsU1WkdEITGfAC1HH32g2FJRgvwklRZdPSIc8ZoKhxWyrcWOny4tL8qdnjXnmkMuOE9GZ8K1QG42xZFYqdyTljFICzknEoEY8Bg+WIuBKGPNBFkQo+JMTk23Oj3XWFDyleVFgPT/2jLE5ocLFRJOjFH2ZIlSQWIiUjxhYt7PIDoxVa9d76kWD0wcPslXcg94ORNvBttP2IDJo7dPtCicy5j2AQeQikpEPsNFamaNZAkKT+kuxQSmJkgRwiigDKgdXQEskJ0OyYVBCgALVourRIywT8gJoyV5BpQ6EvmJAw5mSVgQkFHMTjkvPUEIcQsJtB5eVOoIRi8PGO0RVmzw+GpcDA/gaLfLBmONNT7ByPhNfpMEtB4JPbIjTDKQwwaY0GXfG5/gfcLPtbqUQQnGsmAkJBww2YkQ6cEM+IQR8FPaZECkwE2pBBOl8YcBGBH5SjKZHCfySCwy5fETDGbAgBTIVCj6hHmpxHj76p1sS3IjBJCQg4EB25bICIBkOtUcqTDT5SKf4tuvWfrBOiy4y2Fq4sX2tqlwAI52MGO5fbDHiNy7d8fhlNqJrY3Nq9MRZloPzFZ9HSvydzoNtVXc9p7Krwcbl0MNxPXAK/OLIj5h9kzYIBreh5APrrQInO9S6fzaXWlxhvJNaesI8EdzMrQ6JzQWhlQMOEnY2FUqas8MkoyKL2yGo9VzdJ3FjVbrGFH5EjUCIUk0CWRDr5B2/AGuYi2q1iKmY+IYS4bgiqcp1luHgaLWBj4Bpo6VofzYpVnemFpzbECscHMWZji4oiV3Ch4rQBQXljyOTd66e9+hUhzxNlnNOhJh2mC6q9sLGweOk9qOdvaVO7qYwRuc8jU7NmuNFhs9MaZJ65ay0uaFFaPwqQmxyyl6m2N6cLL29PFjK3lJRr70YamoK21JpggnNC2K4OLaF6HDpG9btDccR4BHxyonTdJt49lqH7MUr9+8JImd3TeL84sk8nt/+K+q80bNc5o9k41KB+asRNSMvsJPGZlCyosBi01xb8Smf2Z2Q7moei5KZShxqyHc296bi3mUq5XVVWe28cKE/Sgzgo7ugU19pIHsob6/bfhIUJZLUxnObuDmOw/3dZRXOdkFTiMkyhOLe2IsFfIkZCokHPpGXccmsRi3w5uuMKgcjboMxswRcgnPqOklkIyE2n6tERifjD3pg0VcW5u3nr98IfuMBivEijrl1CDgdCQOUnSzEv0xPRVlFDtVrqczo+eL47icINo5IlKDoM0aCgwbmPTTLKAwYOIVSJUwdozKwjoVnc/4QFjMPUir44gCMM59JY2wGn6nacBNaoCfuESYFcCFeGDBTuzZC7c+7fEGADtE9NgnBEQmAXJBw8/E6S1GBtDyTp7glNbPxONnSHM2DDdjQYPFYANaXKn63hJClW9fJUyzHuX69jS6jAR8g1wMYMygrjBi/FgW54gkSmHAvKjiBUTKggdO+TLMpO6ZWcC+evCZ+MHAmWFvD/XFXj5UEyTqEgrghwwlF5BQvCcW/xQTn5IRg7Q8/knglB6cJIOELGiT8OYn+QiIhNkbDFaTOjwC8KAugCI88CPkESN5hsGkcMRoyyATQ9kYKtaABdceloFJDCag1ZgYc9XnG3rO4f04Peu4P2x/1zKP7f09s44s2OHdY5ByrV+u8abu9u2r5cmPYxQ9mEUxAuFuDkdMhMviEPijJpo5txUIe+aZYh2WxvvMrGDmvds/Y7ZTtiBnpixdGle3ZXN9fRNpFly89UXcC+RjSSI3ld0GJpRNt5nZtNBxef0dTQI9t7JFtWdkVWzefBOueJtxZfxs7P1hU8wm9tifGL7o3EyNno3wP2k2xlWgcfI06jzTDpAVqaIbOlM+ypX1JDJiMpmZ05enCuFSm5zZ2KxYH7J1644eIs1R29/ZWNcO6bkzhayGnMZJpedm1Oc5Y8HA7LQ1qsWBZqK1Ml/VrbZnCNF5o7O4ginU1eyIs8sIwfo0TROZUGMyllwhMyO6H6oFC+XyFp+chenNkqpQMVa2UJhXouyQ1+k3wdjtuW7AEKv3+WcPDo8OnONEsI62b9t93lL+L5cXl62OdxDF6ZvXLJMSdiUAhi3WMjuwvLoEG8NN8XjnmFyNnDD9MeI9PetpMJSRkqK/plLisROwnHLDV8L0mECqH9Z3j6I3BpUzMMI5yztr5qkf3VsJVQHmQrqY+LFXzkKyOBLceJ0SsYOExH8YZ2jTQ8LRgRDFB4UiGLoOTzyXcSQcfdSaWHs47PcmxkdbVlWcj5ya0zd9MTZerdU1YGARZbiLHg7xY+BKT5FyU7yCWFpa0TFqFkJKx5htllLxjo4MlYZUuiKQ4K2wVzSHb+n6icOc6UJ6/3WtlFFWZBXfiAfzacqBq242emEGaQh9ClGUt8xGNktdowDCYgiYVlhaF6tKfRPwIXsZvpGOn0oISTqBUdDmjmIoXgwN7MSPj9DFYqOBWSYBj0jJRerIs+PwQ6WO4TI7xSLxITnkSIgUEIkN7hmQdJ3qY0Mn6NGjR77a1SCH8GAj6788CEOCkHjU0c1c4FAMcgylSIFkMtlAWkKQ4uVXZGoDcobYqPukYsiyT6TsJ3hM4hAVDKd8BfxMbNlPTNUUg1VMwuDtJypmnn3FbSaHMIWcZYMT8cI4Bw8tNgTE3wAIS8XOyFRmUN3mI4YTFck1DBgmDUlS5vx4iEooXozHT5CJShllpJ8wgAn8cYxPuFl9Ei8MTN4th6T2AFQcxsAGUHmkmMx23GvR7U+dsqvT1hSGK6bXefzsuUEAv7OkYDg8KLFTPXrD2CBmMAuzNplkGHHrq+MiF5OKp2YR28GYnvjkdMwlxIyZc2/C2Inn7iM3azkNpo9bB6SmLAgKt/XRiXlX1U878rLKLdlsHmEbz+yXuq0+yw5UkHirDVNzumuWYYQvShETowEAM2GEobegE7e9u2P1uskAvpGUsAK1QoqjBCoeEhLgw7F+hJ9aXbEWyTIZ/iI1RDHhk5+I8976dz1lp5ht3b3zEz/509bvG1gQlrUuG+u3yETf4ODo0HmdbJna60J3esNuuebFCkJmLM8cnm80OGSVL1ZVPCccyJQlQSQTV6wYzo/y2MfQjUys6VSJSMaq38b8AmOaqkgaAvo6NMH1LIaS4DmzSECqold6ReE6U9k7vTjKl3GDXN5T8cQX1Y2V1rpPUShXZx9/HO4pw3FrusVkiZj1hFZCmuktUtEXKvGdpsu4hU26oRUri2YmG/PrFM9a+8hL9GSnuG41qKRnRuFqJJbudF68VqxH1jUfHKx95SuWX0IYSn41Ii8GQ2ovKgOG89wcfkzAeCDEVTCmM6L6h2NdVbruUMsOAHjitKHL8HBQMqorXpbNmoflGbdsKTpShnP02QJm/QDQGI6Ebx8xkrs5hy9CrldXVi0WQtHjZ+i8XSAxrp20xIq7UreAvvBHOlIV2x46eREbHZAi9hgciFTvME/CaY3BECxs/ITy7pOfAmAF1BpKItfSohvaXsTOqmixMqcwKGyfYjWnz7JKmUgWLrasxESdQYOyiUy1U11NYXABy4x4YPIvwyG2MlxQ8URiAu20ud4Q4gZ5AfFwFl5D22SJiKNelcWUCOEpzZ+EShSwSDiJALyvYpDDqkDk7WoybyDBW+ukAxiJ/KrjyKPN0SatvqdS15WTX0MaGTLELnmPll+/1ioO2hL7XM5DdjD7Sdyzs3H/F86ZWm+Cw603EuKzLhmoYsYj+2Bwi3m5AIkrb1ylbMHADL+sAcAYyWMjs0wI5EmS6mdmOctPcrQSDwepEZmentZoZWmJgvhKX+y4dvumvOONbwtavRineum0iUEIRQFoSQ82b2FgSGTp40opS4VVucCnZe/2SfAGoaXEef6u8Y7GEM04nWcRkpPWiYuqODliYdyFCzQe6UW7vOXJsxf+jFXfuXfPvkn9IK4ZSyaQxrOBhVXkpl785F6/GLq87/TKagV7cdTGGPn21RN9M41N3K/ebklFo5NtRlnzxtWAE2cTe3/04cfV0XnXpJhfXb+1vrG10beluNXc2lpnzmSfEJxxYEhXzmuIzRmtTmumMkNdw/fjukebiay+tD64fXJ0el6J62Hn8MYWmawzp+2ws0urqstj50hsbuCdcwCc7TL2nS6VTq42nve37HP84uFDRzK4JmBj49bdWHy8pb+/tLo2V5tnewyj9EZ39w+4cdc2Nln5mfm69eSWSzk7SDNjXMarrNyNRi1st5/Lufy6i5HloyNDoupYDSG+rwVnpfGn9U/ntDOVgX7Y6FXfakclzknlWFiKYYRE7cEb7WiMLZ/XuaGfjkekbyC1zTs7b168fK5KEnUR2pGJP7baVzklQNuSFlcW0VJGQdHyv+VCWidsYpTrTwdRs0ejFJPGT3+C+RRgeLBthaokaoHkLJgY1VADQNkksbwn2oeRkRcvXxtyjIwtWW3M+RNLga3SGdq4E+f0SkuB7Xj46kcfwaB00DI+xKQ6jk/Mm7+ZnJhrtdurM9XN9Y0vHj1VwPJuDhvblIGGy448MkFWghKyEVV1oXF81NIFwyF4VCy/lwl6MjKmEJSyLsscq62qYgMhqJAymmIr4G+WqVATMyvrazoB8qJGIORRL/vDDpx23hl9aDoW5usWNEhlv2Eokt1e5XykY+Ri2f6khsYUMZXQHKjDykV5afvglGX5LWLklJ4vg3zryKJGs5RwqsWEg0MuKY0lBuj70sIiJCQgd06IimLFYkpfLOis+Wo7kwu7T5JJLIwkpKb4vVm6WDNwcWFBvfoDgCgZMuTZRD8BC8ApjI9Q4mLmJEHVG2Yw3nIOTCTNEIMHSHAlxjsDAIwAoPJJgaGohDxBaPzagMKfOqok5EIYBvA4F/bGg0usjLck9xO85JBgRlOHNCJ4RjGk9vY8BlyBJC9oBTItzPIrCZxyBxuFkBepwCDqEzxiIAQDHg/CrA9g2DxIi9TnBQbGGwNSiaQlYhQ2GMzwD0gluXJBF8MIkbxI3TFvSRRTysrbVzzAhkoHikIID3iTFmbxGAaAT8kBixfwiXcCCQB+ikRdwEJvtkMzyQgQiISqBqlgibfVLhUFxqGt6yvfJvvkxXGUtj7Sov3DI0sw9efXVtastymeWbPK47V6pVedPz7cZ1vDCXOqG8GhGYPp2GxHXF3HsLcMHWTBG07O0cyXvOzt72F+wtEFV5MOesPk3vGhTYa1yvTqbHhOuF711lzpx6UUt1bFjK2d+pFp0xgqiv7p2HhNh52ccQWzXn9QORvGFGcF83GSjyMFLHqxRpwsqg2nn0aXyka2Maevz8xRbltzjT17p+fW7+vCO9eM/VVS796+87Vv/qmVzXWzvho/C2eChFUfzgUyS2lIFJcKnMXmo2oMQ3nML9otqiPv5nHNVenXyRcFM2HASChibg2YFYGiYViprM1wdLKxtkhvjg6egVeyGt3d3T3lDq2i9AapL25HWK0REwksCIFA5Yas3Z03JG+48GabP/+VY+PISCpCNlswPt3gEKHRYLTLNEWPlGGyWYBgS4A3w9S2TXmcDw6g1tOPGo0TgsInhfSTIWB6eLfoGAb0kN68eg3ASdd6rKqxGSZLS5eWlpuHMXQDplYoxxivasrKQSbqqdzp51loS5gafkMQBoHGzoxqCWLcryRjAsZs+1WYGpRh44o4PInep7528D8+zmfJu2AuSlUj4bAq/dPnT5682dlb37wlJnhjYS8u1L6J6YHJZIitHjJa1L5HexYnRpgNj84DNxfqAh4TProRvupp7u5t3966e/L0GdJIKMHW4aGGxISwPRaGgNUZs7gV+yEMC8AU65cWMnqNxBvu02JAMKMXVcxOGJlUDElImGC9MWCMuH+0LxKAVETkXS5cmDHyIzoq4ausSQIGiRBZlpYfsHgSqSYIDfkBLaU3PROAkfWnLsSKALNICB6dCBjFwINXCQVgFk/6VBZtX8X4GoajGDswyGXJCfgkDBhXqCe7UvmkAcAby051/ARAfb2LGzkSZobxgFVvycVgI/MJyTXOrjnhaJOSCnKJlsHGEoryyIBCKL+Ro+KCAOynnn62837KsoSoJGl4cIVKIhQQ752B5AHmzHWKAg8U2vlVkOAZe4DhBJPh7LMzT/kzy0IYNgyATHicCMCANM6TjZQGGMA+JV1vkACI/Yaonx6fpBWp+6arOzUaDYC7SWJJsp5B8Rplcgzon4rWY2UHnH2DAQsHuX0MCvTGTLwpZl/29g8tAfLVkUHcIK2T7sJSY293hzHRG62ezM3ONg/2dsu6OANLk+3HetOq1OTpJEXnzQ/H/7nzxOxNCkPmjZPoxBGuSelSBBZz2MpEIJocl7bZHb2xscavov0yqq/Wqu6wVOU1V9FVNOPGcTHgJuauZx3iHnlyK0tC4rAzLgWu/NIknNnQo0G04m6qYeJ9tnl8Zv4TmsXV1fCoxD55WyZm+83u/vYOi0NDPtra4rhXrF/5yldoi+Otw046HZRDoiw/12iovrzIGg+dwFazpTYZ3uq76bDEUIOft9OCCp9GDyYtjg8Pnj5+Yiyi7Gyrnq7WmIH6bHhZtYzkZrDjYtxB52RtZVWqZ4+fqN5KU3NN5TjNoiaO6kPzh088fPjQFnfeZC369vbugwefGQdQHLMrTL/WzhQunVH60eWaGB06r9g8UHjlo4MZ/uqyJYORD7Vh8qmtXUb2i8XG7HTe08ZTGEJVSk8CA0qsPj/f7Rky0p3YVu2cnlB7ZWrmrzLJyKffTCpVw04UzSDUcs1ctI6bEzPX2FSfqrvVq7bmxQy8Dj6fBIWXMNTGcSxW2DjJxAZD17dZ0zU3c2tj48snz5k2MESkxOFExbm2cqNPbTWVBcRsy1eXVogJUfO2H3300ePHT/n37NOPnfh0Jw4Fie5XIompoNJntRJUP865H3ZN8imenA073XAXUyTA0Hbr/d0nT6zc3bscUb7mTWamIzskIPtg2J/RKZNhsdWAYvOqUOmYmYjjbKNLB1ITTBy2nITmm0AubUOpvDEaiPWvZUcthEqQCkWVKSbFGxhWBZRLGq5xSxb0HX2QWBr0JEizLqz6ExMjC5GcSEPuwrLkzaxziWArGx/igEe8t5KAF56kJy383kgAy8jkLLmRMcAphcSDloA3YDmRFk5aA0yxgYSQCHxijv2ERwz2JMGSN5xIaG69Jc/2RpjrGXCIuxSbtzyiFbwVL5MYjyTAPLIDADbhJJRp0crFUcknirIMP3iQ4BOJtMmST8bs+mU+qfD40XMnSWKEQVoJZUcqYTDJlbQiISzFES2NrzIOLIsghQN5cig+MlJmIABL6K3/JDsSQuLJJMmVvKAr7J10WVsmQ48sOYEBtqKOfbOgSkHJwMlMQaWHwQLYCsQdr0dpcYuRrLNXmAEdj1Do6GqNGRBE7bh0JEOv+dz+HUfb22zJXrcN0kz98PazjQ4EcbywRL1Tls61oy5Yt3A7nOnwaJZieBs90TBBuir62iIxzEbLCMs1vDxzdYG59aOT1trqht6sJJpy/6SkPPjWQjq4SI2Sax5zGY8SLBdnkLmegSbNYCGUvNxEaIqRZEI+7HexRPOLt47i8ikncdqzOjh6/sL39z74aGllFYmf/dM/r8pIUllaQOO03ZlyYZFt9+rdiBKcGo+55XEnWdjKNTKIAVbodhzNFC5HsnXnjjLClZrlTG9hzS3D8fTp43feeUc35MWzZxbIS0gJDShtQjoJh49lXX3Tv+q7msxtNTPuGkunUVy4lI2aMeG40t83M/n4yRexpnXQf/nyFTkjytDIoOxrZvTrueng0fe0j4ts1VrdA4VJBOxV6dY736nKkmhDCTmKRde7CIrAATAnhEaMdI+uUnhaSj44QY7wCRDzcsFrr5GfuooR9sS4qbIjvkG7hPykQMQCT3Q1yvSkIlioLXSaHR5zx1UbI1r2o2fNs9Hv7XD6hMPG2QEW3MatQabuw3VOmJpkGdEkOWMDEoLGkpaPsAxbWUREiNq5qoqVU+7l622XIN27e9sYOCsI/tlfU7mUU4Y7rZMorMGpzgeEwlGbrAIu1dko26FArmMzPuAOQl31xwmwpZXlTpfmlxUOAXzFw2laWJ0zGdY9CweyZZVW9/BFT9kiPrw2WaEn5cbpo2ZLGCF0EQ3NKYM8y0kIrbEUDhJWDdvBs4Y8thewDNHSWKaR2VHNyRA/Yd1kHro0OqIStRGYmIArvSO4pBSjOun+myEhaDECL1++FACp+WUsFDPVRAwwRrV+fiKBXXxI5ScYMUiDES8VL5WwmJhSKpDC4NH1KC2mAQAqfgLwVd5QpHXpE/eOjCBkWsJhGgTKE6Ix4PkpFlBVIxc7u7gdMZYcwox5DGg0iujDViKESXIQ46c3ulSZ+qILWAzRS+hNPj6JxxhgPHggz58IifRVlqHFMFSEnBJARb9DdqASmRmXPJSprGGVnLQ1NuQGJ02ic9gAT1+BeYyK0FLZwHjwhhBsMEAog34Ke6RKxsRnNgU8knh8FQagTuppmJZT46mUdksvP3rNHk0CRMWAejFtGmgSMNr1oBUL/dV+DVXE68L4aL25zni0FjqJpjq5D9goFSNcK9qnCXMzXOGH5SThsYPDIypgFG1BMVTSGcTJJhlqRbhTlItqEzN4wzhpABJ10kpCVdtF3rC9er37+OlLBx7Y585da7WoGR8eId1/E6fdlpNbxsw0aHicuek4Av07BjT5Z2s4gsyphiOYfWESzF2VmRuazCXN+TNgWq50MIOZpbXNH/uxb/y5P//vTs7Z6B9YTFJZE2nxo4Jm+uZ034xWON9iLTZZaK5itGpgJnfiowC43dpt+PWHfbLQhDvBBKYddpYPabHoyb1771hExNhxuDmrzMk1qzr+1micntSrNQ3wwf728aE5f9tqp/m4jLcIjWJg1nnbdCDczpenb96ory9Dkx07ejnKKYrPKDGnNGlq2E0NeByhFINgqRRinIrvH99JtAcyqTPGBrL47B3rCdg4QCMnekQ2U+Epi0DkrowRJNUw8/bJILTzi0smhAy2Zg0lxrl/Tc/aHjHBvTMbp0zrx3O7X+swFJI40MbBWzKl7tghTB2YMNdS0mmiY5Z8QpQOchP7KpV3rOx5WyMsHgir4QT/4jIlBHdUu3uCVAMDZe31HTVn5p8fSXVQpwhHfbekafTM7cvqD3MpU+EeAMC7EiNIu8HK5c/GPQY0xQGmkoST+fB4b2VtzcZqYTvnuc21EVY31Nc2jg93VK7qHK/s+fjMrD0vvEcxh1YmfnGpAWavrLyKqgtF7BrTgZEdx7Kqofqmk06I01GQHRXfWJAmyfVbsQsqyrDt1MCNQGnQ0i6RlVTEFaZBkYhlxWAheLwqe/YZIpkESlPFeGCUc8BEw5b5CoaMCFqkGEhSpxHz+KobjgQYjMIgAKFCSqMJJi0jSGAI6ekJeOD0FW8CJCXPOMaANx7SQKPFFIuRPAq7jHEg9BMzmAQJQ3SUyp23PMICkEuCeW8YxIBh7CFHMX9G6RZLbf2JMMyYxzbmwQgjh4pc++QNg5/IAfBVEmAIZQDmHEv5RA7S0irA1C7cqkVT5T2RSCVtYsMeQSW34sEQBRKyJlWwXToCScUbjAdmX30C72eCEYufPonBMx5u0uJKWKQ3D2bKVqRjZYiRQIQhwYautJ/eeABP3+gKq6+rrRKoP8xBmYiLhkRaCWVBj1auDVHVNNdhhzqXcrTILxZ34sQiu7hpT6bL0gdqGaXqovkxawyCUGkj/c8pXZjEPJlbGeytPEzfgZHAWkYTu8dHzd/7V3/wZ//sr/B1cGsQdTN2egMZd6zh2dSZ1kKZg1edFYERAKNvKs8R+awcn648KmsdiDCIinIktj7xUFjlYhLfXKTb31fXN37ip37unXfem5ytOsPPGMogxHXtc/Xq1v0PnFURBWS2wHE3TGN5otdQ9CclL0wg8pKFhR/2Fc8lJgxZ6rCkqLNWgBWfCYY79+7D0Dw6ZC581RJbl2m6u16fk7bVbh43DzigyFnH1CmVbh9k9N1M8vjZU6smiV2X33+NxQaTJqEab0jggDVyQMuog0vPOMANPwwAJdYOKwTmPgyQkUXYBOqmBmkQYmMDSSl6SkR5ZAQAxogRjAYgRF0cHZl9xewn3fDTcEFZ9wYd7bSzH+kLfNqD/cNjNYPW6QIThYxXhlOua3ftjHYpmqac6BqJPuVio0EN4KQhKsj5yop6b78HA+b0usBZtuBa/CmAMakVq2n8JavpHURY5vNUNCbXYKNW0ZyoxVN0gxFAMXJh7aeZK8tJLx29EYc60QqlkD1rU7QwWyXhPTEVeccMvbd+F/OWpdowt3/Y1BEYdi0Ws2ws9FXXPBZAR9923OEaxhGSu3RNjnT/5YigcAWVGJ8EyIEer6wuOSDPQ/9L/Yq5Pd0xtcx+WCWCMfW9sEcmYYWkYjQIBzz2mGVrCqKwZNVnUSAE0JDMT4RJH/cZwIpIMahSRPEYIh3qSGOoHSFKHjW4GGJhDxg/kYzKV9oc4dRmkL5CyDJK62fGgBQvjA2kIZEwRnDFC5xfMxIMHYIYCTknI+UqLYQ3ANJiWz7F+yoJWrFbpNhoX2UhARQDgOQzLaCveMhIYvEAhgE8uacERAKTCkLh/CosoSd/yjKYlI+8C4v3JkkwamPGQJISS+b9VEj6/pJjXh7RlU0KrCBhIDqROMGVJAwECcCPOswAJAyAwpi0qCR+mMWTrQeSxANAKt2Z2eqsycf5WsPAwrrypaXFk+OTs/FTXb5wgCo09Vw/R6ddz8JeGKfWFCfVyGl0UlBxxKPlQzsH20ZNzE0MUGbm6o1F1Lv9vt40njGpydA505F3VrO9Obi12BIbThBWpv3TAQeEyVsT7Za0yw5fEMV0UjDCrC2iisy4LW7V4700s2qgkyODy7HdvcP9/cOPPnwXIaN224AtCjcm0PmydF3CybFrbbEAPnTAHFnRNPlCSyLuY3xyYZ2ZA9DAD8+dQdYZDGnM6traL/zCL733/oe1pXUVnaV0bE8AR2/dKqHYZkgZ5GhxZd0FVQQeHWgbnXRigY2Oz8xp6KJAdUBYepmwdNX2IZVQPHi0w9bEEvro/cAWU5HWqrFbF5e8QGV9baz7Wlxbefz5p4zR3Xt3To6O252mw2fMFKgy1k8/evSlXuezF0+VArSMFlqOBdXWCOhH+SM9x4oSgu6EvCt9RoGMg+PYLF3DRjH3fK00J0TPCWL9kqpgFGR2I8rlKnwOchRESmMsoIxwHq2D/tZInH/HFWhWg7PCHDgLRY+GnB06udbPOgmIIWQEy35X7q8zq6y4esqjKwoLkarde3sHCBELS4RozLiuuP53nrMRh4ynXNDq+VrVaM0F9aurUV+U6dWgyJyVYKDLqlaeGSUxNx0LfgxfjIH2d4/NXeHc/jsNAFv3+vX25EyFSNyWp2AdUiprGJA1ixOc1gm5Jyo8QYQTYlReVF4yh8cIfnVlE3VWBf+WNKkUg0F4AhzZ12kezsUZ+NFRSwxFE8Nyyi9zy/MgrQnqxKxyGU+Sp+Twp6UiBDCGU35Oxc7amH+VI0h8smbaT4oXdbN0+3BLkXz1XJs82PMb+RoM0AkKxy1DjhAxDfAkfyBDlFdXjjfizoaUaZMxkKHcpZHAHwCa6nYexDDqK1GK12AoKgGQPkkLrWFHMPq2mUpb6Se+FTNyeIABpEjMKADY5BbPVBk2n+iTAFQgCd0UBXNZsjPF4Q4DY0rdiUcqpFNB2XE4gdmGILlI5CQEhhC0zpyhuDjBlU/wy1q2pRJ65D3fYKSSWXhK9o2GTa0NFRUpeacosiRkH0sSyhIqksADIAUIHi1I5JEE7ErHJwYk4QNTfAbImjFQpd/XKP0yw8xJYx39qt1dbYO/WFgVS01LwWdOUcEJ7SSE4L602WiBQdoBCIeHx9hQsmRIAgqredQkFmzrm2iZYUBO1vRXye3gsAmhSWB9tdlaFRImGfD6+hqGYaBo8Ov+xzI714k7yrKcchG6W2ylMYJhBYCQTNnhSZImFC/HHUgZQ6XYJ1T27OQibszg1mEoIdjoyl5aDJr868DiwzGZC5O1f/2tP7IRzFZ7RzM49v18mp/KRpnoe+paXs7EstSJ6fHzw3OHJ1iGgVsLvomFXGwj6p+19bs0ALNV7uPJJ8+eGqD83L/5C+98+NX60tL9d97L4fUIj8vIpQ3STDxvwWRtWsc5JKnNKOMS/ONN19LBk/TKykAxZJguVuNd9Zyfam6Kj2ioA6W7KgssJyTkxiowD7JMQ3iC9DXu3r792WefzTs82km6I+ePP/+E2VIyL14800gj5Xjqzz///MXLZ48fP1aFla20c4rm4tJZBczH4fGRIqarpmMVh3VQSo8m0OrY0qHz7KTlskXUydjnlwM8p2YWuxdmXXc4AWSNZY6YcskBnhVK/DIkLLWpKFh4lGamZ6zpWllaibXCZdG5m1gkp4/4WVxcODhyQcqiLkgsVY4KEY21fXt64o70ps9KTcvklAtOOzUeFDEaOOKNq60e95Q5vXzEyf6mPZDgnTf+48dbXjfVH11gFqXsOg7P0gkXZDtWSdFwnhzwCh7CO3e2Dg6jNykjC6OjFrC8fLUjzwpFC8Bv1ms7C2jM8VcSEpTssGTEDl5LZCgLufliC7XPKDX7GWuQlrf3Dz7+6sff+td/ZBe7RQrt1jHH3nDQbXV7C415dZPjizRiKGyo4RzQsp7VcD2rgCLw1XJPbSecVjqoemSrUomnV5SB3eetjc5GOfMYGz7pzxClRqWo3Cndk9wni1mjTilFl3uAsEDAb6XtKIA1teXyykxIxI+NG7OrniyLqiGBTpmppFCXaviyVRuWV7yxiJ8xYgtvVMy7akg09IpH19/bigUIHa1l0KSjgAnD8FrN6vLYFM7VERZB37J0IiBhg+gijqXFG1c+/Gyl7Hl8kj0IGU8JlV9CAsCn8a+ArLLX2CMX8Fi1rK2c+RMmW6sSFDVa2pXSI5YHMWiRJqKyAD8/qfV5xCc76hIYdDGg3zFVCV+BsIGmDpGJHH3YYGli3Kkp6pX5sahdejTlih/IF5ciU4ydGVH1TXKciy/1BM0wrySAeUrZap5QMvM2zaNjtXiBR7h4qMyGOoSdocFMzNqV45TLjBzfWpevRYXFo/UbVnSYoaWaHmRJBgbWHzllhJb2GBJZkCniBaOXypBtv3rDwlhKaK7PKQhEpw6TsFbI3eMj5zGolNDafK2CnrxpP1VLdkoW9CWt1Zmcjc7jBV+2UU532I++0siVtR/aSKTZeqpu3GrljzCHcVEM5RwFHSdPlJEl3yWBsAvERSYsGsWQET9Bsh8mUVR4RgHO4icct7RU75m7z6iI319fwW5Q5xSx5raBjs9MMQ0HB/uKb2TiYmtyRT9LH3tpc8PZDHJk+M3mzdYbB8dNw52jgeVIbWz/e7/6q+tbd605rS2thV++z0MSZprojDC008oR58RV1PtiojKpguscW/LBrPvkFhp2zRBHtez2W3Z46olwuZuXMjYiPcWtrz1e1jgqFNorBrfa2narae2OQfGg3fzaV96zpsd4/Ph499nTx7ENrMvDG2rz6vWLJ0+ekLCiVEB1d35dhjdJh9eqGnMlJiGUKMmwE85Gon4IWR2kDlqHFHd49UKlrXmBjTfcnTOpQhTGZG6Wu6GBgefVWCwcoloKPVTIuIAt5k+LcfkItedJD2WP2ctwdhkE2FtnJsJPZ0HXGjJ75vQ8d5lNGhMN3QkxMBLq2/0z7D15+spyYjtb487gaXWcnY0xum131g0x5U66d/zR5tiEzR4q49rq4tHhLtf9Uq1qpidOK5mcG50833pnRSYrDUPQ+ba9BeYqOPEuHeQwe6z7fzZysN/curVhbKbaGr84mmJ1ZWl7Z2/HeeALS2UBNCeSKZlJs6+Ou7CczSIj/OhNspNsgh2MVMtBuYR5sLunyKiuMpken7h3e+PN3v7jJw9rC4tq0Dvvv/ej7/9AbSJGzQ9vfhy9dXHpaskLrUFxoZ80j7n6NTwK0SnWKrLmBCGC0munospla32F6HgtmUV3LDnXmi4VOzBiW7asuaeP5Ludtkqj/tFopUjskgAzSAojU1yg0fGEkYr4rObjDB9iEFCcapqilTE/851qKjKGYMXVIF5kFrOE1K6oezS5tAtmqiMSfm841ZOs5BRFTBiXokDSmg+x/Ovs7ERJJwPUKzH0ogk4Jdms+fiEH4wehITJGxIePyFk2jSS8ok3VJLJqalYUJ+ZSup+QiUMQDjkUh7IRXo67VjAgJ8iljB8vquZqowY8GHLJuK8yQQzOSMttnEi4MGkT8yuOoCE5lqbBAnGoPWARAiARwbFhCEYxvJkyeVaKpFIC6tlMagbi16hrod4X2ErQ1INWRncBErxRks9981IBdinzJ0kKRDxmPfIO+TkrEANEBRQQR7dWGNknoJMi+EcU2aBqjDsiAYYdfCexBPclcsPtKMW6pCS9g8VqWCGBBt4JqIovvEZE2sZA0Pw7WGoIypKhE9GcsCh0O2OAFahsswOV0k6k4vXABwe7avH2gL6af+BLBjLMiSuw717906jMQ8AG+sb6zpb2ksnQFipurmxxsXv5OrFxeX6om755N7h0bTrO6wIqtY//Frjx7/5zbsffcWVHCPjbnxtZpkO+gP5UmQYkFnCMTcFY6VWVVTW7Du0c1CaWwu4ZExxqhG6Y7YJW9BpI/fm5jp3mY3VTIDNdJYHMtOUIXwjsUNqykHEps3xvLl168o4pXXcabdfHj1Rdhb1G4WTuVKAik7q1JISGVIwXo4i8OCIXvOw60UaAZAu35my08P2R8LEyAapnxwaglpUKzmUBVTGAjqIIlm3OEaDO5HHpqiTj9hTHN5hqpgLh7XEHV5xBxyByEV1vmLaXHI/lTvGzNlHB608OEGJxwwtps1MAs2mhPaagTyJ4yV29veOMQESBh0Qs/x7ezv6W4vLcd8ZIWiczePa0jxyWavOTEf3MzrvVT4TJz/TnUMzz8Z5rm8s2zYNGOwoDgMlv+3Y4Ujb9PBUZUWJE9sRDg72rCRZWF5VtmSY1L15Hi0Y0M/T756ai9lXeyLsJiFYjkV9FI29RlQWSMMmmGPrj+0sObWD17g8LnrS/tETbaztLXqBsdY1rqi7IkAHjWib6Dpt50GSO0JC3U1cuYnVUODiKqw/SSjxmJQoxidkecmHGl5fa7WsCFARVDrR1E1Y/yaqSfFtihQjL/iRXHxI1v988I56VfoOuBQPI2mSi09k7S2x+JCFjE6EWVFUcAUPxS1LHUUiXKxfeITFSOgrofggLDLFKpWwrHrD7824wwZMaUmStLKy0TPwYgQSW5ob8GJKPmMYC4mv2EYIAIRkwRaAKd0rR9NYSBt0i7fyepJZGLx3/sVUhkeTUK6xzV9FamGYpI3k4TQznRiOdQsF8CxSSZAtPmUQdQml8jOZASms5sidsID6A0Yg2yrckjYYldmUnFTEknlJSJ9i900ZJMGMBKJgUCeHpBgZsUu9PODVcrT8Eg/4hiuRxCIo4d3IAAEAAElEQVRGPBLkQ84wM8dWBGZBqB4GH5QnRmOGWcXfBYMktJy8uDZSdEE0+r1BVRhv8iUgrXiYEcqAjAj4KiY59xMzHqkk8JOF8tPX8AuPXOlQIEcyfacwlpYskUN1I4QM03KDP9nhDt47PNgsmx4pGCtv35zsVFyl65Yht9Ccnx8eHNU5QMZW0OJzsMeHhWOXCcAwUIydDV/7+oe/+Eu/rP2oLCypKHhTNHaJ4VMRO97ZsNnWIFyx6uFsmZo6ONxnIHDrgOj6+NhMvToZ7jg21oYpp75fGoW4c+Hg4NAJ+C4ut9/J9KpFscamxtmBU7tdZqqmpyzviYW3enGf//EfW9i6u71NKgIoygWx8I0oR1mmANMzscGK6QeDQ3XZuIKy6fExGfw58m6/rlLSBzDUwBWwHLsXsxXaqxeYQiYWBScj8kk9AOu8xziXBS29Q9WEMnCDQAWPdT5E5FgKMAQlUg0Wz8voDa2aOBh0FJmRkNKH0NUCxIJcMhzjBgbHCMg8TZlPKkKeaQ+7+nNx1iuPousTzol6qtdzY+sKzFGbzk69ORiNYFz5oiV2XSXldR2MS2gwo7u2bBJFZ8vmO6POYvTwQ5Gc1WNKmX8IS6HV49Yg2R68KOO4t1nMdAvpMfR6Fcwuz+Fxq8+daLA0W62RjDGOtKHAxcjEKRHFrJmG2Nxam64MWUxlYfy6sbb+qv/ceB8DUVKxwSWWAFhtYfuh46nYE0waPDmUSTUMhk17kbYaoVF6exaZEjeqjhLP6VU6FaPk6Mh6oqTKIky6JJyWBCpyBuatlxUScPuNsRUIHERuVbXi6lL5ZcBDOiI9EsuerwE8En1Yo0KIpAKDG/HgFYYAeJ/Ei5EQDBkpV494MflJGE6VE8fCNEA8N709Hc5uF5PJvfETGIqHDg/wIJQs0Q8AKEqb70QLM5MKJ36EBegHTrihCrkwYTesCoOBEHJhePIRzu4tJt0FgYQcewNDJSkKUxrjVkyyQbY76chxC6IlHhhytBZCdZsS+AlSKtTBeHyiiEQqBpOSyBSK+PETFczLoxL1AFZkuAXmEQ8htAJ+khLMYBiszBH+46D00g5B6ytmEg/8qGAm5YMTGGSBE8+nxCwhEVAbPyEP6uWOTJBQ5btUnmtplCYmCh08csG5A5QdGTIeDQa64uH0SI4unHIt0ldvCZHL3IlnzXUn+f19YrtZcNWY/U1JaghhhkouNFr4l5AXhnltlCNMTPxY97K+sYrt1RXTAQ0tMp6jv1Z0UveL52R1eQVyI2utjivMWAe7jpX2j33jx60BNdPrTsuLE7cGXgw7FjJR+5gwVF7GRsYWeLPFCxu8EDjh0pyPNfYxarSd7qTdHOu20JU5/VcrHXXHrEfjTtRJjyGt/WSO/jZUpZB954zO6lbono51lPtwkuNrvvb66ZN//s9/98nTR8CNDlA0r6scjfQJWWNDbmFNLIDpnNAl3JBnKawQb3QmBjHUk1y7KDlnjbybEicK9hcM+IIqaqiEIEP+RXvtd0s5UzPZLOHrpYBgsihjTU6p18o1xgpl5Kq4ZU2hsAekoWRhLrUvKnvqD2YgsVCd+dOPAxC1u2z+YPEh111jTVIruKdJ3hOj0rcchu9jbKIz7BgHEIK5MeMxR8bameKq4arDoaamzQmpK7iSNlYSxBXNYeuUV6k7m3hg3D3QMvyThm6x9kYjyoxo7KOGpjGli3SfWxKfZ5dji26slHGjruAxjJK3YTKnqvPruHmt3ZZ3l5eNDs8qk1G5Xj595igtwnENrjs7NeI2F5tRcCGAijrugjQd3DDgUS6wOUWWeqZUI7Y0veSGW+SI14NbkBp0AkM5470DVXnAY9hPkYQsCTyGy5Qw6qofzCVxhMDfHqEs3k9kMmO48clT7lN1XHubfvgEjCjFp+pALUCOBTYMFpJg0AaWOLP4YRYDrV4J/aNYUfZlL25kphg7qIheWmBgch6iVLMaGLR88lMAq2I8mYVMgrR64kmbqxlHlLDQ9SCBfXPsmIS/6ATxXdsvHRoNEzxsBMWClkGh0iqSXGBVqiCqP1S6q8K49RUJnyQEA9KDFh4EUMGhnwC8JUlxSSUGk95aU9mECjz+MQmVn7ABBsmz6rGKBYZKdQ6Ytpw+kA8N9EmMUpSd/BnQxW11QxRdYWiLwEJiHmGRKLK3oQln5xaUWEiHtHirTXiihS3I6XX6tlayp+JhlltvWUM3c6fFicVt4+4uPrXSHs8cDjICN0iiACzSm0+Mcs9UZ3LuhOiQAFMyJVtxv4pb5aX1SUINQFAshcgFlIokBl1vuQhuY+Fm7PShkU6fVmq3NjaRRghaRIEZkvOkOXXA1+Nmm3aej3BoTFc4W45PagsVDuMPPvy44nyekbHXjx85st8KQYMv7hrHPqTKmSwhc9pbmXAu08lkZeqoeShfqtLFTPGqXcWJkjpuylmZW+FixprQ+IDs+HT4BGvBP2vyT1GZzjMy1UE92N12Ta2cDo76P/z+D549f+LQG2YH2qODQ7Nxyl1GeOf1SclER1eutTkk4AgUomDZY1r4Iuw40XnYBJ5TZBljEhj2eBdD/agYdnTs+aPDGa2Hfz7gpoHfrWeB1ox61xFocZ6MSLkjyUBo53DZQW2jt3jrGVGn0xRaj8ufbLJgSER+7YMzhzk2aYG7Jjj038Ax9oVEGMMeYHEbok3LpHzRv+DBaZGuOQbC7vM38Fb5zYKHaY2ycCO17bKqRTxUAhLsaV/xw5fl6LFhr4t/ObbzQ1dd7nzq9wZ8XArAGhyTxmyCttwo203JxjkmLdRxJCcnWtUxXc84TgdrqjVPmT6HLZDEEjZk5MLCsyLR6M14or9SNrgZl4mvV+fUZc4l/kB9q8ig6V29k0bDWRcErXqqtnaxqCZuSrCQ4fy0B0pGssobU/qp7+9PTFYfgdRzFBVlUvRJfAzHy5MwUdB9MzJhw1lXraaPJBC8qiGSjoeGRA89awW8Psmb9KAz55oI5Y0ALALSazPpIin46SlFEgUJSaAuSz6y4DHn57XG/In+aVL0icmTCiE4EaLN6Kozmmhpfcp3FFsZ/d3wmSLwTphSzOHxBCkyFKrY2dQY3FIRqPBcWLp2g0gVUit2lmigwpKEYgQSD3g/PSBxyLCJ9xOT8g6tMLrA9LN8MuUbChsD82yNr1XcT7nDCUKmMQkNCbkWTxrCpATPDUtYBZ8Mk7yvIPEgIULgE8DPUgix+ggM5FgCpn6CwRVObF6CSthbJHhpbwJ49lMSj7yI1/nAhsxaBbS2vooutllPkJAjQYNpo3iobEl11I9ISCTHqni0YBAWSZ7ArNZMwcKQ7ZwkmnZ6SVxo4V8XG7y0mVPwmfzcwRRnZ0bi5KZvTVyY8SnFhStCyN63MFZlwcWGtqEhYZ3Jl48eGXfz9W+sLKuB4ZCtW7+x8OTJI5zYR2N7u1o9PjVr7rc2Mb22sbFgcfjqOt//7tPn+smVWkOftnkcozoVlopajOHRlWDyTAVjJpT8PHpRWGW+zdYKEILLWFT+Qfh0hm2XhHDfOTjOXDST52IVFrCIdNDqxO6s569ovpObH3zxGUNpOrcoUiy8JlvfidR2tiwFxuX0LDz4KTQaR2JE4Z2desM2wiy7AUZ4acQDtuJ++80Og65CUz8cpgJ7t1rX43j4b4TP9CjuMp0bnQ+PJAQrp4oJQtIWw7Mv7BHGA2y+pkrTK9bfJwH8EIsk2hE/AbPgafyNSEKMeZSWRmiaYnQMQxoLC62jXccwsKQkTwJ4gwEqzKBi8ZX9aGqIeA9C6gY5m9Y2jrNf1/l94B0Q2J2Ku89OLtosaqks0VOmhIWlkA8wnBMsTsKlZ2XHSHgU4+a1vH5De2kT2aQJ7frlWNwIx1MXonCpe8m7Rl5V0NaGYljTXNokq97UiejIlgXcskDx+G8M3bqx18Qekugca+GcdxyXy7POcVh3POIVBz5lVsBPlUUgnxsYGiKMeW/FSrYlg8QeFlgkQaGbRean7Kl64OU9vMy+qYfy4HeGAUkpJqurMIx+SiPgAaakURLwBpbYiSz5yDc8WdIwo6rYxEiIvIQQivTJk58yJ35KjjHY1HMwUoFXH4RTC4lAGAxInzwCHpDiJRQD3s/kTUBRRRLXROigRl8k3GoOl8+fFq5FH8ZkifNhTJ/y7Z45JDBMHpkqPwhN1OmWIopz+cJJMhbe1MtwZ6FIVqgASHUHLAsebMi48vMmQDHCcIpPYJ0Rj/omF+IhF4ANAwDywQnk4mEgJUMTYYQyUqrMvlQZKS0qWJUcvDcAD4AUnVIDCQBC8cIWffDb+6tVK9wVMUN7ebW8uJTlCwOiWOA0MdxWOzCAIWnRkhyYJ6nDmewpLDH6MyoKYPaUjISZ8qyBARazgHDEA5scSYJnAdwCgE0MVgmBnANhyRQYYQ+6wnp/3KNWPQZjo6NhWF++hJNspQXj7hoL2/jLefztNa0vLnds6K8vWOst2Z3776+s35qsNUbGDdzrMxXL1uZ1kFVL83WxP6e4RGSYVefDsTVJFxJm8pyzIKksgozDi9weVXx9Xac5D6+k5VZuzDtGiM9p1Yl1VtOZjRp1h9jl6Q9/+O0vv/zEGp9uu2nbkfORXr964Qx6owRrQlzUbu6xqE+0l9mQQ26BssLNKqP2Ewc5R0W+GFloLJGtoeRXf+xrFl/JNQ7Nb2OS9LhPrHOljLSMsOmuNRzyRcbMiGGD7haVd6Zi7OUutU+bwaKZtxTwR+EpsBJhb2m9mX2OxajMYi7ckMYNzi3v0Hs9XV1DDYPdDF19XrsKvI2q/dQ/pLHKWDliL1Wdp8X6MU1zs9l+9uyFttb9i4qSCaYVsfSo7EXICQb7SDwKF/P+/ORDhsojy1TSMJGCwYwEhsWrfX5StFQbx08J6ItTv4TEUhooaMnKYHd9bcVskGaVOmvJ9VR0I8zwq2RaKcmhhZMG4tC5fkurqyYFGXQKRmLGPgCiGo5POFkEfNoxAY9iwrmmmcwhgQEe8XgUxgPO8yk5CjOY2fEJZJaOABhhCYWpgTqrtcsKWOQTrgsAohhKMORGIFBNyKTujMzjkn4AEkOPKRaS4Ao3YfrFwCIZMHmQJelFQpfYpRWDnicLRgyOMecnbpI/MAIi1ZwQWdlIDGERPZf0uasnUEE9OC7rZ2Qp962J99AGn5RT4hFGEVoPhN6Qe2cupMUe5BBK66wvXzEjBrAKc8OkeHj8zMdXj11/iVA2LUHCj+LXGyU08SklQ3vSIHTYVu6tM58IpWkDk2Ya9UzlEzDUYcBbysQsq64HbID5JaR1MCw2krR3yLRcOYlz8eSJ26z/UMEJuUDKWdXzFauZBQn9lEpakX4Kewtn8QkAwKF/PMtn43EoLPYMApBQTPpB+GR0cO4nttHCpNkOFKPPlaOx8FtGVxRy8cIRcNbKWZSIJLApOwUn3hs58XiAXCpJdIqzaKTNwuXoBqMvL7lUwgmgh51aJ3mmAo8lqyxrlXlHDFmhuLm2LiOffPapAf7y0sJ8/9RiStWYp951tSwb16n+1lGr+4133mePsFdbXrd67qo/2N3dv/3+h+3jI4PlFWOI3kCzwenPYiqO5BaTLA4VUY3ZRDWXx5ncDP19soBXNdYYMfHc3JTLsXbj0wQyzly5tLDX7vzOb//fVm3aPiZrEiqZN9txdyIpoWIwwYjjKipm6QPJbAi86AMYXiArUBmffpze4/aSmMmXZQWEMTg9JIYZkSCtzr91+46E4uGhdaRKsbWOikOmDJXAK2hhSCSklrFAqZwCKYkAHcAGBwVy9fr1hBZgfPrK4ouHNss0ZSVGwCOyxIc3yU+1noPD9LEy1djEnrJRXZNz53n0ByNfPnr43v0tPFBbqoa6oaUkBUOwJ2CpD1RxPMdp9BtMFF28ea2JsjNj1rk3p2d0WEvpZBN6KNeqVdxqF3mMxc0yAj+PmTcXjz4iUdvvrelqLK/wERkCKhdZg9y726P54yfW/o9NW4HA9+7SyvnGIrNqdBXGogx8DxWfijBeNleydQhHpSO9KQX66IsvrfTHNvkfHO7Zikw3MKNvqN8ns9iWWQ5ZRUOFZBmfMBAjzoWzLpOAnwV31Gg5KKVcher0KtwbkouHKsGEs7iJUJjRkDYcZ6QPyNvjA7HmOEieFbZCpRChbdebkokovOfe0VyH+499x6varoDZbm6QbqdjJKVIRtkLJLACLXqJBCFo4fcpI8UAACwP+g7WPPFd8BsqCUvsDaPIJTclZv9F58XUlr6y5HIFLWxRiqXR8lOe4YQfITCE5Y0NcslAikOhipGlIusYcMmyMGwAQFJ2MoYKTvEko/PkRCfeHnqW8VS5QPa5RJhvsqJ2MCQe+HEla8Qoj8Ji4FFOfiJN+DAkcMbgCucA8CM+S0cADyhKjkkABsXqrTkln0RSlKxjmEkSYhhjHnwtiUosoFcc3RCVh//KcIocudetqNjft3UFz+QmLYqoU30YXGDCwGHbVzEC2CNzQ2M7TYHJmqGNSqyoavN1YAAymxYzZL4MajIX2JYpb6yKdIZ+6qKv2rC9g31I6ECS84l8PHLkkQo2EkBCpK9Sickw4Xh8ygEZHjDmJ1F/+umn8uU8Ui5mFL1D+r2B3ZY//PTB3XfevX333ta9+9bDd9xD50C64enSypql/iqIgyXsA4hLT4wbo78c3jw1CVoM6+mr2pptpLGh+OTL9IDL/5wiyTnueqvqXMP5s/Y1WZ4VNaXfbx4f/l//8P/8X/+X//EH3/92p31oL1lldnx3+/mXDz998vSxzrfZHdese2RWEaQcsEzsHpnKYiJJSqhvznrRCyLCgM5szLrHcdLn3/nOd7SdElK3N7s7BEsmZjh0ls12bO/u2wpgtmhlbYPpabZa2kVXPduhZOLUUgKZYhOtSLa+yfpCh6/Zm8LXbLGKrTv6wca8bJ5G12JZAwQiJRZUCIE0tBQ6+6ZzCU18NJOxROfafScXxrsy6BPOlZeqqnYz1d73728eHTZvbW6paJpWqqJYdd3TqQW/PNpAp65JlUvdTLrmpd8kRtBw+sQf5KeAKkOeqY16VlZPpSdTIXLE+yoJPomXtOk5SO29uqAppXjyDqGNUSQf201McQ1iLlcuwAP2KA7jRVyFn8AJP5P2AF1PWUkFPyqM/t137rMXWgKRxKth5gHzl/PMEJaqEbUpR11WN0Eo7+FmcBqSHhUHhqV6ToQt9yzpelrqY5G0PUPC3kkLS3hW9419nG2iyisakSsrQZr/Sr8sLL4CUBKoaoRB4CyqdOmmySGmicXXFCgYhkyxhfIVN3pqJJKejA+qxXpmAxulVTqJKSlfPdDCIy08CUDbsCUd0tjwFRgMihyhk+PjKOkynsiMIQdeWkx6hMGL9M5MpcEFLCEMCCnIZDKrkPfNI9WfDEsFc8FZ/Dml0wdABsWneQq23/Z2UfRTpnCIZwHaRoEoX/bNZUoqD8zC1B1FP8F7JJd9P9VV8bKjdNNKgvcTAOqZXzFy4atl4IRjSYufCeCdMBmTrKIlXvhGpHIBIAxZ6Th4o45KCoGgIEFODCpEpzjAywsk0oLHg0/agB2XxN3MoBTqEvoKRkK6JEeKX0BzBU8S8ilhUITT24PPFAXXE1GIx4bcgfQVWj19bIj3BowfVDJGXgCrKt1O3+jbUgUXfEywwGVRhByxgCCViPMgmbZB//LWrdXvfPe7m3fub9y+M+riIDffkfmcDaWx5sv6jqm5Wf5lT5zUXIo1c22owrAh3VhahFMjHjpcpruVLDaNW4PnODqfg9SBMOea3oXlhrHJzvPH3//et1+9ePLm1Utz7OurC+Bpy4m7iVtNvt+trU1eI8nJGVFFkKVgFURmliiCpyIEbaLTEhgySIAlwLRxVOnrEAgMOk+VuTBSXJ3dkf7s6KQmAQD9VBbqPtGxd1pV8MQOkmxRx4Pk5C8yP4GUXwBosfrJBjB1BQAhCEXzUGy6rwpNpCR0AAByWimsekSSs4mMkTgAPNwyekb2NPEwcIIhobV+vf2G4eM6G3RarF/M1tixsblpNU9k1uYSK3xsA+v07HKyF4qxxjBsVvzbaIaoyqbKani1Pcyio00sDJueqkR2ysku2g+f8NPXGRsecdDhCpP005F/qqniIxxm2tqHaOotguQqLgqvw8kLbPKWkGJxarE/aLM2UTdfvwCm8dOnefe9DyfatkIOOCehooS6mYjqwjIVpsgxz18WpMstYz7JYIg1LGeM4QS8icUjXolY/QQ/kWIVOeE0p8DgIXaloC8OmHZKReBI++QZnQ0nM3giispMcFQQKNeb9IoZPXjFixTjLX1qmHD+lBAZtOFK5sTjA1JvYVwixmkkP5L7KQDtTR5wIBIwDCiC8cmUJwZ8yjzjQQkliRs8ybOE8Munn/lgwyPSm36LDF7L/Kd3cnU1tJzWHR4Ey1xZEWdE7na0sMXg4+hUc4VkbYqgHHdjZsonRZHU8YMxT3Ie48qo79H5QjeKLTbdxKwpe8fqYQ+kt4xLlXIQkzlSftpaMhQDP7o0EhsCZAseWp8EYBAJf9lfTT4STb/Z2VY9jNCCrBm+4oun28F5uFJCMkYk4pO9FDjxquEEovJDAq23LPgpzGdgNMKIMbc6YsQIHl3jHggFzHGFG/j8ouOwTD3Bt8vR0NKqIKTL5g0VHEnLbJ4hkeS6P+TgAQDeW+4KUcd5hpGSU191XvHMdhKvuMSGYX3zlIk3niGPTJJMmUAmQBhEssXhyNJ6zRq0MRw9LaX71p1H//rNjkJRA11dOVerO219dW3d5txDW63298mnNqJXYbuyiW47sZt8Jhtbt3TlbIFGCH6HZ2rRUXf1FlUXY4W7bT1z0yjajsNEUiFdtOijEY9qbUv0wtKiHRaPP//Rv/hnv/Ps6ReLjdrKUsOqze2d1/ikBlb11Bfqls9YP6W2sFzmnWSZNRHW1UqJZfZJLAOybGFSrPkpCiM2jueJQ8om9LcNo/EZY7wZk1UTVthIxf3l+AFiJ2B0AdA0VBS6SKuJ2m5kNGlaOgRiogAuzkwpG80AhoFJUCEMXX2N2xPKEBYG99z7yrISlLoAg5/qtz1oCoWe0zEJZESWcS4hj5PD1aiC21Zk+/TMfv4ydg9D2Tg6OgbJeXe4+5rL3enNH3zwnpEklTOCnZmcnV9ccE43Qo7EQEnJ2k6FOr6QJgeWS580uCptIQZ89bPA0M+oJNRe0auzZMEVZtWZCSTwHoUruazRxmLrwhdiV4OwfsbYxcjMbE1NnzMjPDtnVKDWaZbUDtPmxkZxbMtMjONpoFxjWz+dtmDYm1lFHYmit0yfsSzHvbgJriJTcYgK00PvUP6yvgZ8yVqYfjilxadykWU/yblgC3MvkL1C3Tpf/fQGCZXaLrMJHFOymjiCRgaQsDdxgIYFMSSTEphEJP8JL14peiDFEEhIRLIvZC3D6HnD452oYADgSWUiHeSIVYyceCej8IDPbOs2opj4RWaGIUxa4ANdSSgGDwCSSo49EaKOPjkQQio4AcBz80grFSZv0koOBmbw4hMgv9684RGGVgBA5lEMyUiFW0hwTjg+JZivyQB+bvD4mqiQwypIbwKREFph+pfx+clbPGCPsOS+KsuMT068Mwu+ZkZ8Ba9Q8kk2gHkyjwmP+eTNTwFvGIhRDw8GjQFaEKbqAD44PhIPQ2Ytqcg7MAlJOFUfFQEx4TF/+0gCQN49AKBVymqjGiXgK8AsI5/AYMYjnD9BpgwTBnJ0y3nILj61XDW2j1JB+TWPrfv/ySefSELbOQqsXHJMxZePnrz3/gfrt7Zs/kq3Xq3eQDSM99tBiRsIxURLUKoGS4FVfgZ/cAuTkndQKZ2klIabTARwe2V5uzuwOs2nDz79/rf+4MFnPxoOOo16xSqtduuIrTQxyQdAsGw0DPLuLArNCQvrLafoeigDegIpNBRvJKOuxYKf8zBqhMDoxx4dPJbVw6oUtKaEvCShMgwxJLBRTtkhamgVJQClBibFiwQwKOM8tuL099NheoAzvwkAWFrseWdADJkkEjHJaqQti/TIRBgVrGKYo+z27Vupk/oxYjQreGZorP85ajafvniOK49PsEmL8/lGDRe4wjNPi0kZ8UrQNgt5h9xPlz1YSuvCYXMVEuqnwyzghG3tNI8WPCA9uIXKTyRk1B+fMwtH12K4Xkwn5gFAS4DiCcFPWdPG0yh58SnsStliYnRfqZk24BOLtcXsMPwIWRhKUJRQB0JLw4FiJQIljYXLseXUlrpwY0CTJSIMrbcnxSggy97iyUR2YPYJPObJVl7UTRaDVkCYhQsShx6HlQDDOQDv4+OWyLBf1E4ZSKPJBc36wCUmkSLgQTKgwy4rwrCJfgIW74EEPbS9PbCjTfICPmVyAUmSV2+pEmFGigkyZehApumD8kkLodsYIiiZF5NgafLw4xNBeCc2eJSWd1S/omepXlKlvCAHnIwBwBVIT8laMO/BGxhvqbxvnmHpvzinDC3YMhdy6m4eCIElvKoFm/YGDD5FwplcCaAlIXjaoMCIXR79FA+tR8BP1ldCP5MxwJmK/vkqjK6SQhQASI+8pBxwD14MSPgFgCEtkjSkRdcnfj+0xEiIB7RA+klE7ihXX0ieJjtFB/NgdPmcz4gEPGDctiEMbSxoLnVAPpMHJDzkwLQpSh0B2ynhnOnM8uSysAh5pE3+ZSG7AgISZnyWlw12NzEGZ5kws0OPMyNc0mIwKYlOWYrdWVVEFP6xcpizA/Xw8+zFSyfhOE75l/7Mn75/7x1r5jlz1HV09cpUJUjMboHEpdtPHS7IzaUq5KE3rhrm6bYBtdlqujDdfgKD+K4DipmDWH8YWYqOv/OylSapO1Kt195+9WL75dO93TevXz7t99rV2gz3VLWcjKTby+I4iSCm+gZ8x063Hu+6jcAG1livMW6uQh5DAoYV5FKuRjFtSkwxdeyY+tCxOFdA3QLPFJRCsUQiyl3vGlvFloU5MzsQA4I4pTHMlpWIFABSha5MqVOWvowUq265xIXLVRA1tMEDIfMjs2hF1Lat6qtmD6noc5myogjaDBN4mMUJwZoSlzDVLE0EJeHXNBqwWpcNMd9uCgFwqoTe52kv1oUfXI2+eP7q/bu3TK5iD6syS8SkLcAb7uBriGiOy6WptdvkHcdtQ0OZLGxZA4lnOMuKWHU2DKVcI6Q2kI2P0MIgO5BQVMNEOAsth++ETnJokZjLnF+/3MGAsmi1+3b1hf/9vPT2eK7OO9OO7uBbjD4BW2zEOHX/vXc/+eEPDOgh1970zvrQ2kXsf9QS/7TXJ9dW2/hgf3K5qCYKNHrLdsCwJ+VU51gVGnoVVTgKtNS4KIhSQlBlLY6cOoV3wh3aARkbThgDCYoNIXwJrZeOjlHIINqk3AIV/scslewfweinfEopw8pPYg+kkoUGlsVb4gnOmyb5Kj4ZkiRZ9IaqMBJMAIbBO8O+EgemFbMwQXsnRTCooxXJigkDmcoEeUaCUUUDfzF/gLNoveHxFTN4Y4J9gtwbsCEkDL7Clni8wXvE5JPZBC8AOOveDRUwPkklyxRXIaGSyaEFhgFvYQGfALOA8kjIWPJJWgXvKxhfIRHjE1o4FJmPLEvuk58++emNkITCqGcAwiw7VMQnHkyKhzyf5MdXyRVxYiMTmJMNqTKt7MCceom05NDSUQGfkJcKJIRgJE9+6CwMUEkixoMlVLAhlUhvGDKhMEhZS9KQAPBkNmEmEMjBJ6oMABDwtcBe1wRSTSSwQYsHSJz6mYyhrg7EXQ6xVGGOJkDIY6ZTefvunb/6H/9HWxbDODer2Qw7VOpk5s7YDQ/K3eJRniJhdRgJxhFOJg0nuolGRR5HO8yYulOT4pznGBvxoQSTsqxvZHzsLsyDnScPP3vy5MHB3ptTJ+yPXXJrWQCkUSEwtpVZ4u0yz+DCce0rP5efxeQ5eYg7IboLKLPy+JS7yFp5cOUx55q6ofwxgM+UDIF4xKTcJJQUa5KIgSADsPlA9/yUtQSQMLUxjvcZi5U/oQZFtwGkChVhRMURk0i8aQE8HvCpSwQIPxgIsxZI7qe84E3AKUYsL4GTM83RizdpwZmISfyI5ByLTrSZgfKU5Pocoxw1KiEt5GtFMV2dfHckkMqmRPTtGTAlCkZj41QlyWkLljIXZCWtLjl7gpws4BxfkcodziG8aLrMDWDe3Sy+sngiJQ+BOsewlAURySkMqgq/JRJyt7iySjpyB62CjrnAqahTOMwGOClqn8ghe0VSiYQSIQ1P1nTkCpF4CQNOBnCeRUO2RCdtylxYTQd2k1MJRdJnJSuJhH6qFCQqHKUFhfT8P1iVN5GyJ8ugIcKTEhIJJrkp1f+aD2kThggEwFj/ZDuieAkNaSSBLXGKwQQqApjAsbACwyu6Hl028dx5Id+ysk1mSI3N8FOkR1pZQguqDPsJf8rlRrcgxwN4jPmEhPI2m68joU3WCYhJRX0wO+hw7JAoBAz/2JrYqhgXHjmKQHZuKCaV4UWs7YUt9Swx+yS1gkqevamUSBkRJujMI1R4ECZPCekBDvGJioykEMicHBQKYIFECBUASTxyKt5bv0+AEIgiY0SC9xNOYRh8Fc7iS1SKVQwesiBIGzwR4cHDQ8JhABJFbGOPDQKArq+Um2NFcmoNwHYm0oOKzz2TYFISYcBy5x0ZKQeW8XMrR5xIx1WqO5oThjDjJLmFKgmh+FYg10UMZ5jLt4+sYQ9+/DNSMDAW1r/z9vAJ0CJUyNNb1iT9zve+K+l/83f+7jd/4k+Jd+8YZJX5BqHWtLXjEzVb/80GWTXU61q/fmtrA+e4iroax5gfoIhtt8HsHxwoDLXcDQHRRpoOjeOLYowVwwg2ftCza9dl604uax0d7O28srDe6nEKS7dmp8ctSeVtJ9TQoss4OzaOXLswwVDtOW2ClMcV7pGvlIGiWm+umDETW8joWJmblvf0BUYvtUwV0pHQ4NJbpIv4KedoEILGJtxApjAlV3xQkRhpE45+iDDbZMguxicPLQVmEGM/DNN5PhUKRoD82holS15nK6GljiqzWSb2PZRaTCEg9DiKBxIBNUg5egwgiZpzVPlyQSOUbChvfVgAV1rwOL5wsNd3gqEpeUOfof1f4JPnZIBM8MaGWj4qVRTlwcHSYoM2C8/YYRHbF2K8Yj6ZSvDM4802vWB+bg4tC59Ql5aiOvpNsWo81FNFydQYOFJ4vOkKhABLB1gq2dEAmJkw93wUZ0l3XP/m7Cdc6aND6Epqx5KgaD855HiQypJin7J1IWRFRmQeEkMXfoTMfdNk/f2RKWb6cmZ2kvrhVsIyZRLG00MOHhgk93O8LBOnooHWYKQ8kaPxOX1/mPFACCVppI3ORpkEEhk8v+1YRDcTChDYdQmDgGLzlmFswcJeMETqLRmJV1KSSO+TB4xPZKcRUgAII2lnCHL8cVZDFSFGeyirmWFhj1LUh4IKIW9sEZkAJDjJtkekALoIaQCKRKLhxaHkgH31xn9iBiYAgwBWIURUFUrMUsGQMIjiAX5gHkjEyFRhLWyxR6S1uNE/LO6UTCISAyA1dN7CJYNGSDE2Kp3vMAQpUknIR1hAUYmnCmTlJ7ebeORQx1jKU5gwQSrIuLWw0EJCLjyAfRUABl6+GOssTvGQhLEoucYbgeJP2UBCVtiQHAN+kkYYtdIrR8tPSATwxtAIQCKJSGjl3Z57qbCEbfO6AtL6mkgMFzHjJ+RaB2zIF4CUpLLjaKY0uhvMpQoGEn4IwVtMBz6zI18wI5fF5yu0+RMAhGKyjfbTo2kmGe4C5OAkVfzrwVjWUQQ+ZrWmvrbKYS3iUXNfNv/7f/A//ey//WcunQR3ccnt8PFXvqKjfV3m5wPYMK0CY9LaKmygbtkfWnu7u/Rp7c4dIm337ehuoKtt7bTbh3u7IldXV3QYXQwwct4/eLP7w+99/9nzp1Z9qNpuOokFReMj7WjyR2yQcgSf7YcWp1MfziJZQ8uHaM7Nz9cWfJUjG6CcfU8Isq1syUKkQVoggcWh3HRHKdiv5ypmw4Yy3iIEGVE0fkor7E05ydbxChoBc9fyVcReqmo5c1T/BxsJbwgkHBK2ypNujF7NVoNVdQ0DFMN61lRdhYhKcHUR3XwlqOZ5T1yNKXQkfC3MVGhOqo0ApVKefkrI9tmUqSmFnMrGdTqDpsOctzZWHNigYWOyTh3xXLrkrZOmG4yLQY/DLzuMzGWsZdLs6UTfvX3XjjmT8LEGrByvTcViiBBdoAteIettrOa6vXWLudcUO5pNvCEC151lAZhRR/SRuf5C7Q3KQ0eHy6trqlWs3bx795MffYpPR2prWzWNF3EAYKxcd4aIx6JmaK070BUduTrfvHX71cvnDD0pKKypKZeLhUC6rU46b1R7kz9GSt1263A36nUsZx03DT7LdJpS5q5h9i0uUGrMt0IhUvKM/JRiVV7YVuK2mKUWCeNaFSZnYAD8jKIs600Ng1Qi2SR81otrzmHzTiOZiNtZpyeOjg+MAo32kIGOLeNKgwUug2xbZNgsD1yKWFNPq/yEXa6KEWEUGE0/tYomms0zyFR0xMyyyLOuqqG2N1X09qdGG033h84et+7OCfJOh49uHQVFF2Z6jLafcsIZSsf1efwRgCjaWeZbahnOT9FgM2FlxwpByD+GBUTLPJzhUBsbtT7dJJsRNjdmLhsXSRnFGDGqitGj45krHQCJSd30kB0r7uCejtWFE6wlSnB566ooFGHutDhvxUox9/441f1ipH3ScUTszJSrSyb0lLzd3G3thJoicnZ6jiB5jXXtooxHLUfribGLD+eokx79S+bFKHi5oG2KUGFzREpl0SQp2uFCHxkdstQnZZXgEaNy8DPGJY6jdsHMHh3suymJIbfeICNdLfD+u++0T5w/2tWR11XQV+XD5qembCQXN6WfWwkeqwvpvrk1jg6dH9nBLVb9UQCMKSOS14woKUNlzen27m5xjUf7YR2em7Jj/3vXkuQztwSkwthKSlUo+oxjEJzKaf7N0QWjcelu2hcWUr51CfVk2Q6jcKKQfc4BAzbrnUyBsm5MKruzur5m/b2DiEcnR+bcc1Wd6p92rVX5+//gf/jZn/+54fGJbr5FQRSMvubhvVbjWXH46MljO4+0Foh0+/YDNLWhjs50CDB7z3tw1Rs6reH4qG0kQyVtGbe1d93+2vlKZ//N+cneztMH//gf/m//x//897/40be7x9uN6vh6ozIzfjHjWsa+4aDtAhV69Xp713GYtKXU0DipxprDqPwWo006x6ZDyDpxTmqkuhTAI7+a4aL/cc2k1t3NwM6dcymM2srbRedpPjW0It8OBsZUm0Fc+lKh86WnaVAuU1wuDK76r0ToFeTGImoiB43aa/UP1xlXNQZUVz4I6+hBOt7Ob8soTQkfHR+yvxzuFEZaf85Wdr2Y0+3xiWf1ynL4GZfqkKxNRR03lcW6KaWJIpPtWGtVacb8uKEABS7n3VvK6Yqs5YXG7a1NBp0hvuBTrzQGdGFyZmVtEwb8QKJeCHrraLpDmNNfD9DWdN6v6BV144AmCmk9T8x3mLIbtcTI4io18/zjjz9kf1hwVoVkLnWOrxw4xkCF5bEFD/NOwQKKhHGMPDKJFH5peVlb668sebVc1UDPRZBjtdna0uIKawAewjdvXhmAyudB89glDDixHNhRr2eXzI3p9FZ9fg7A/ft3NbIaBn5pqkhuWh08UG+HjZOhyMyjT3KgvjgfwgX1cfnwpYpcNbZztlDNQtVo+qfoEpeXblZ4zybi9BFdH3Nv7EW71477PyWIoeCoWT3bBheXFyxW6hiosa3ZeujUaGkoBCuTmkdGAqywYlPfSBwMYUkinlZhTlrZlorEJczkYqJ3g5xJieLcAJxPYvZJDsGr8JCbIXQIaGIDlgWsIyacSgOYEQfvgSHNjZgopHKkjLB4GHCLupaJ7Uw+S2N2TR0A0vkW8EnYN2+ZzRjJ8xEPA2YSLN+opMQQAo8faT2lzx19eRYZtzKV8ZLDnMDCkkuiRsEmazB4ZEFYjHB2aTHgpzckMissYSAvemkJgYCKBLNIaXV5RCYAyMBjqnFmhhwcSq4bjh9sSyUSPNlCDsxPbwYRbyqP/m90ZIujAAC5+CqVMPWCQdaIhZKBT/NNMSTMfMkmlpBL0UmFJRiy1OTCT718aW8yBR6YtxUmSSjBMAyJhKSCbhAt4x4wJW0sSRImSTBaI2G8RdG4lmlmZn9/d3HJJS4MQe/kqPdbf+tv/dRP/3QamsFJU7P+jW984/Xrl4bwCs6SHs2nhY0aD9gwrKN3Us540Nl3a7cG3hmXk9U4vWN+eU3PwOJzrfxkrTLBoXo5dj528ejzP3aQw5ka7lqtWGPjyJGWS8Hckt45sbFsKJViDwzzCzjk9LECRRWp1ydZdEvZFTjWORa0ZzJCpM6HlC8NeaoH3nRRRBOg0tNfIbfioggXn4JQpWAmQG+fSFuSImFx8dioaG+CcRZg8iRgNgi2KCY9Wz7DsDwWyYShJQhswCAK0ZS/QKqEJAoleCzOHwGQqpP+kyvoAQOjOwFfWqAsIOUlVhJDej1xGynYVBvtwITyxD3EegNhNPb29i3K+uNPPh+cns7O1V7svAhUZJEuCmLSSY5bgyrhVXHx1GT0eTULISs1ayJcF3r3DAZp8N/zZ99/773FpfpcZeZg/7jeiDZYAyAjADCve4M3WeVCUyXVRNyaEyYWi1MVHBhNGgZIRxZI2wqF42ZrwiEiHBLjMW42B0s/OfSFTTG50gVXGnT6rJk3cqtPTTiZ9tWL15GR0jFVjOVSI+g9xTq5uo7Kx+FxI0w/SMKRfaWs5kJI+dvNE2yLVKySqYOYV6wYEJkPTqSNYqUGVzG2lsRbgWCGnJR8OARFZUWSQJFDhADxCZAOeuJTS3zFE+xZnPC+pXWtB+IThtpJnuTBiITHVzEeMd5EjAfdWFcmNerz3nqgKCInV/KMN0gyIX4yXv8XM+KVQTIGrZ8iPeiiJUdIAPDJOwOFctgaAL7eMCNeWAyiMORXSTJeJGy4KoIL3wsM6JJYabTD/5BlkJjTcoFPcgIwQ+sNEhK0QPoJABJvhSez4v0keVKVZW9PYvb2Fao0tUadfkqIGTg9iRw/MKDlE9MPDAYrLyGX0CNTYKTSMcEnbQCWDa1UiIqHWXdbQmiTrhhh7xSjSLnwZj5kBFp4AAgYKXPIJtiNGCX8k09i9hWTIGFAGgBuFTEe5CUfAKh4i0x4bzGEj5yEiUoYvE+QRBk5UmtyyuFFxviHB8eK8W/+zf/iL/61v8avqo0E9vDhYwt7jpvNxsKSbUEuUl3bXFtaXnzn3XeNnDScyK2tb23eumto31hYmWssaSOevXz17OVLNbbfazoPeL46qdN83m2ODDs7b54+fPjpi+cPt9+86HRtlHXFvAPobTal8M5PjvuCrPU03DbYM56y/8vICfOynzk1UDMKxL8YGYzsOLCkXPyQAPlJGACB3DzyThoi5ctDQ7IchUX6pHCVjnhhEnvnnXe0AfY1qUQ0jZESsETSmANywAZSxu7wcxcQVzDp4nKLgMvxSqY3tP2IUjPNj6GzIiuUgzS1QEsS3MpFPvhRKJ4429ucqfItRU+DUt/QkgpAZkpyj7Q8OVxh3//+92VEx1YMouxyqhwexONZvBgUPXRbOCPpPFEBo5YpExLQmRAmgeKEiQ4reG8dfPdeCHsglEreEw8mYdanyRXMfvoKiXfyiY3AUBaMiM8wDRSlihEvyLBdvT4RqV/GZPayOaSIdzErJqI+pQRimZYmfTJ8OEko6vnbjhp4D7QMvXXDbL1ikkEcQoIK6sCxJC2EIiPgzpLTOCUFgBilrGL5Y/fDG0JqsioD8KIqvbAYWPwkDkiJPsUNSwZ8EkAYJACPn7BnWPxNTMb75Mky9hUJIoZNQB4ePoyjGemBtxyCBJOWJRmQMAWEnAfP8KeAkmeRUCXzKN6wB4+fHoEMg8lAwXTdSFzLujCWmU3+Ub+RhlTAxAiI9IC5QXKDVjxWUfQJJE7kS5jqSCtTmRGoRKYEwGQqGQ9dedvlB+ATeDLx9kgFEkKFBcxP3IKhEEQH+Y0m4Q1FwGBQYeizoJMxSRhc5HyVhH7jP38iKpW0KQE/JfFVICUgrYxkDBgM4MRbGDYPgNQlSeCEDbBIyaGVC8llQUw+4jNGFlgl/ECVOGEQhiGpgyQKbyzdUCyCCZweCGPKobSsaGHm13/913/tr/7Vozc75Lqyuvp6e+cnfvInlRxXuGUkH3z8gZwcMNzHx06b1MpxIGjguKHLyfK1OBfBlp7BqZMZLBqIw8U6R93Wvnu/HebmPN3+ycHzZw+fPvzcokTXeHC2jzmN++rM22nBhmEKJfag1moaJI5jAsG5XgRPhg6QOodPMZiXNcZEvyKzJiZLXH5lP8WYgpV9P8X7KUxWALK+kMCNcAqhqNdkmFQC8iwaUbRSVYpJmpcKtoQX9gk2zUMWBzFKAg8qAr4SdFbVFH6WDpZQQQsD+Yj30+NT1llF45N4ctBdWKjHvVqoIEGHcYUoeLQ8YLDHJmIMUd8MyISTeahkB0UuctwyrDiHOWLedgFlCodE7k3lpGX67SYDiUrRRA1JsJkjocJe8GwojDFoYZBlaRHFElAwHgyXMgkPARiZMnyJbpJmrvicAfCYuRfMXodo4MsSm/XVVYUuv6SXCa304VOy+BOAkRkXtJ0NGJB3GVHn5FFYjtRiMDKCH+zhR5i5gAdkwovxYAaHJAYeKm8A4iUUn3gSXvh6sIaAR0oJWEtplAQg5SXzkb1oWqOG++SBnTShu6HnU+H4umeNWKoU4cB5IyYw4vOngOQ0Q5PHQnEEaQw21taYN5zG4RXFEQYoMGivSvuUGUYOlxjDdGaVUGAT9o5Wrhh9HGbxZED4Ri7CMgJPoCrGnawJwU8ljaIwWiGXIhloffLOhApAwCeSEYBWKvxo6pWuSBjEe8QrJwwIBLG3PQjUfZUQFRm31IzQcA6MlqgPvgJOzgGTBjxUUa0oxRGrtoBJriwEKBYGSBJOPCi47MgEE6V6w6yeSGv0HaI7PydzaOm6UvCJQqCIlgf/Jt8K9WwDIhzX9umenkVHFV2PnVvqiQC6UmHJWy5SXKgg7Z2BIoRwJWEvJYxVYgesaymhTym3EFMpl1QYCX0114WWXAjLLEhfkXbhOAzyJXnK87x1vnN89Nf/+m/8pb/4l6x/KUnGHj16LBUoRzy/fPmCpjiac7466/RNq15mKnVrWmiQkzptDN7cuodxAtzdO1hoNPj6XfboppbRS1c19UbORoed41fPnr588XR3+/WUo2RjuYMOPltpD/mFQTxjyHF0Pgw3s20E+tFkFifOlivRrR7nNCh3yRBvmMUQbymU7PvLvpkhV94bj5Gh+puSjLd8lgZAEgKh+YCViLYKBuUunjTkmliULLcygZOVs5s0smYmiTZEeq7v6cqeGMClQSFYxaHOgBeW/Wq9orOvCQTjE5ycgShQOQOCHE0Lo85Saakddyu5cRirpwpBgnvc6oQqKR1PMWw6dV1f3zRepNKVnoVEJs8im0UI0Qc1D0Ehp0av7OBbW3KgHmfOlesdVteWZVCu1RXLoQgDhRimZPNT9E2umS9tOXTmvqkyg22aM+anr65c+Wsr2UnbEse4ZRo/KVifyMq8g4BIPQm1QwxJphIi2umawZa/cE3TNEbiNGY34yJ7FVWkuTxzXKfDudrcbNvXHJHEvnqz6XFKwsxcxYpWWSMByEvBhX0jwJyfxIx6b1mahoUj66TZigi6Uea9UEfFZDUmFZmNioa22MMbsfB0eVM2CAGwaziABrNyRP7AFGIuJpubnYtLqqGDVDGowAZ4aJlSiAIrFrCY2Wj0FDtBZ37gkioIlIEYYACeyGTp6/kEAAaaAY34bE5AZm0nO4yCsRCIlFEXsFXn5cuD1bJZVFrZIxR5kwpXAiGjgt8bD1AFt6XDiARskgDDJAYoX8ID9iRv4rEkrUckgISBB0UPAPHYUzYZg09f8eDTzZM/E6ev4iEUmU9iE5OfyB02ogeGN48YX+EnVTAqm5pGOTAjC75SDm/wYEBKkmHAiIqBMCGZWskBg0Q9336SgzdIj7RyAbmvmX3FIR5FhECy2hD6JMyWhryKMZIUuSTNnIn0Ew8ekRD6Ka2fwvKiRLJNSgDwePBO/hM+CyjVI5F4J7miLWEFZK3oW4goYaQVyGwKy6nKDBKAjPiZPEDLY2Sec2Vp4c/96q/8jb/xN8S4lUNRHx4dE97tO/eYYOy6hCvE5aDOs7OVtVXLDeXVakZrb3j/LSfV7dcumjWt16pra6vaX+4d198sVEb7w/brnecPv3jw/MmXTlrh9B6z3Xd4qoNPPLbv4IpBdlGrFoG1Y2yt6LB3qzFfcagcUeMWdX4UZ6MZ48Xmr3L0ZpRWaE2Il6DC6JUMkrMGIAuIrPTlwACARLmKUb5gTISCp2li6DCxJ5if5EkU6jjM1ErJEOD5SGxWd26jTyC9UzHsxqZXYrBaFtJEs+Ur5CiGMTdnU4keaLUaBl25QGrgJ8Z4BjnM5FthwRNPuRgyO5cWUSfzNlugSPn5O7TNGSkJZRQ5Pnb16NX2Z188+PH/4M/3WwedMgeWmqApRSLWqRYdYPKcq52yklP6Y7LdzREdqxKKL6HpLmVuk/AXxYz3xtrq4cEX4Qe3V6DvXsbQohjeDfougo7KUpbAiZRb1UQGzY0ZsRwcHqsZWUgkbLSuvEyc6IpY/G4szLFiKOCZm28YKcdEhbpZ7vg1RM/SYe60uzHFWdb2pIVxPrhZI5vWtJsWpMiF3X7WUqICm4RqVgweizOGrATwRuAkAIb8cUXw5ANYZH71pg8inQcIJmsieAmvS41c/FZaHoWBOWl0SHOtBSknOjDqO4VgFDLGWxJUM4CGB2FJkMEiegDkRLmKzE+AxXsjxHLZ3UHGej6DcuXs0kJsyUtgCSHHHmCYIYSBBsu5QIi1NBJoIOenLHn0hpJooC0m3tsjScook4tBJTnJT95iECpyjCQ3PIsEeQPmkxjUPSJJxlsq2RTjExKZPN/YE5lPFpsk4MUrG/nN2kvjxQuDkWuDAEnghBykt0cG6SSFMPCwVttp5sVQKwiHCUf9IVp+IF5fJWX8xjgoSvGJTclKS7CWOZp1h80nP+kWohjAsI5SsD0ajQeZEYKf8qUwU2LBRyhbCMT/aIVCIX+lWRiIAZlHvghNFqTyFAyRjEETjz2RiRkDUOFQDAwpQzECGLbyHXKQUgFglMXDk7TEJ6QYYOhWZ6vO1wX5l//yX+bF4PyanatYa0Hf7t17hwRHLf7r9riAwKgVsfjGOqLLUSdDfOXjr4f3aroKbedo32jHhbJuiOp3jpzzvnVrbXCy+/zh57tvnj5zZmfrxAqptfUl28D2dneoV1x8UjoVWGUL++r9oK/fTzVdGirb7tM1HDnlCCp9FwyoPyCt/nFg9uTpuD40fxBNjEzltEDorfxCfT3tIZvuzjJ6iLNFHXlfpnPJxJOmX1qlSZ5ERIDiFY23eJFMTGUmPBtOLOLNITeL9MCTD8xUgjIoJDGc0RDy7umISh7NVJxxrzcTbE6weLqsZeGyQpNcGAadat1VhySoS+qTGPGxn8D96TE1XTxXhllllEw9ssnhfVZ2GCE62oecT6sri2eDGM4K57aA0mTHnJAYaDXl+LRcSirrc8ZH5hS3PrjhiRiPXXLLS4vkbGmGl8bJXDuE99+5+/DxE4vkNKtqpzIPqVq7WNbmWn6KAZUOIfGKX4eA6HhKyVMV9JX++8Rly62LkF6nlUbhhDCccluacUE5Ml1Pn9IfHOyrDkusW7TTI/Vq5XVZjqEhjKaiUtOJ11lQqTlT9UkGc7OxrMEUveXCZQynvhAUkZothFktQF0jDSEmp+dmqYH2mVhAqqyWVFgy5KufIhV3LumUR92RrD6QyM61P1ceiLJWDSNoBCCBsgeh7FJ7fMUR2ZEpGPCwZJETnxgAIejyBKpirwHgm1xSmpKLkTbzI2BWyuYD3sDIxvS0k4d1CvyEQaoi6Bi/ZxtIFkjIjweejDTIFC8GPAyS+AkbRsB4o+LBrbcME4p4ePIreMClXKWL5lRR+SlAxGBwkmmFPQhlvHd+kkp80hXJBRSFWhxEyS2E2aXFniTgo169XTQldwwotCQGQEUiHO4gwscq0pDgEAky9BMJGfEJsGMdKSUAn2gAJNhAIun6KSH8HvDCSRo/bhmEB1eQSPjZZ58pJkTB2McvedlFFCZeOGVostBXhAhHHYWKpYTET4T8xFuG4URCpJ/JsBiB5E06OOVRpEyRg7TQKj7wEKYwwQiDOTuP5lMkDDghK/Dla6xckBCY1SCJX1567d6HH73/Mz/zUxvrm4aH6RzQ0/7q175uhUrfbp1yC9BqZc1t7O5p4QJhXFfWt6bnGo+fPr29dbdam3796pW9RX1d4+rc4nLDSp727jO7uj754XfOuodHe2/Y6Xu371hxd7y322HVy02E+JzSnpQ9aFZt6kfL3cjVhAGa1Q0uF8Ieu6v7Ra5669HKXplH7cQRAuFCGLXuUFHLjzyl2L1lzSOnyl08KgKESQiKlYuAQGiL0rGeXW0lfGFJlCmR+pSVXxgkkSl3q21Ijy+aXTPvBrmEuKV+wqoNGJvbbN2o1KuqjU/IoatE1ACsMtZ4gxA/ygpFn2hauYM9mqaEB5lZAEbt6TLO5QJvVMlsvIWi5ng1e0iDCcz96D9l4fJd7O0dPH3+vLG44MBGaeVL19i4RMleDHmZhlztmEfF1KbljxNXUUEkrM831EWM8cnIzvrqGtuDxPzK8mZzE6s+TUyp+1GtUqSyI6cGhq2TY0wKs+AYIyWfxKgdAsApIwzy6BaBfIjHdJjFVLotmI99v9qiKKg42kAMbHKNVY7HL7/8kvDVy5PmaG+6x4bBJgs6DeFLpBkWW59bynlhgRAqOIRH0XD+WJCjiIVFppWGVoBLR+1I/4+9ewD4RJBW7kgDRsIVlN5QifSmPzHy8kOsrGaA9D3ZIZVncHRIeuVEFopZhlVXOSELMbBHaReTKh4riSohcSBtaFWZf/BGCyEufv4p5YEJJ1lbfbG3s7uytKxzKhvkhS78ID2SwAA5fkQKKzy2D62UfmYmMQuLRNQDzE9UJEzSN58yIaH7RD+gBSYycYqUHGmREsLjEZBNMFKRjxjAKQFUfAWfkckDuckIzJKQBp0Qj5a0sgC/JFC9fLmPip6XjJOGWqFtl0SYkBMVSPAhqzIXdO/evSwUNkUqGgAD+ZAAliTxU7dXEi4dTT7FjRV+HNKX1mjPxbHmZk9GLlgctv7O3S2Rwqp2LFG/iqlmjGHVAALOLEoZIRaMYQYn1Kmo5bUjK/kEgx9hcvCGRE4FyE2MtClVTPpJOJCD8dObqmj7cU4nSQAVqSAEiZ+EESOMDWIXjzEIJfRTQrRs0jCD+eu/+Rsr62vn/R5DYNmP1sv2i7Nu37n1am+tWneGD3iLvjvdYbPt9r4pC+vf//BjZXRgM8HK0oxDG6dGFxuV4dHut3//n/4///B//0f/8H+z0r93cri6UP/gnXvzldmFmv7ueGV64s7mxtb62q21VadRGjcw9xbKLzUattFqSIja9J4Lcx36zv3KBexPJx7nMoV58pFZNtNZLgRCSrImpnRMo8eTkfJuz4UZGLISKcsgSYwQCMRbEu4vaOmDUoCZtigpX2GQxKcGl52GRG/e5p5YQ2mZfTQ+IpeXlnxVxo56bZ7EmXQUQBKYk6L+qdWZSi11T4AdxDgqIOUFCSxZOw+/LSmQuqql62oQjQkPeNv5Se24V1Xv9NwlOaFIEmI1i5uR071NJWEHEN3ZOdLLWV5edTeAqu9qBr1d2UmhsTMw2IhgTxNtwqp4yRlW+cUVSD9JgKz8lBGBk8PD27ctBdrkAUXiBptP2GDN4JQq8yIVsYuBEHJrgRQWnRQj+5bqqPH6SBp1MrdZJDNCFua3gckdUcg4aYNXrNtvXkHPdhmHESNTYErGfIN5GpMWnILVesMQiyE3RWHFMPYICzPowgaD+xbiuA8uFtyXUR21F9BsmEDutgaGQESh0drZ3nNItgWWFlta4abvz1rrlcEJAScaHQ/7Drv8RJ2/ivlPGZZ/6WUYr2yQn2jgEgdGAHQOMNYlBJbylfMMS47LlKAwVlKCCIn0RktCTAh/8cWXCsO+eT+3t3fVfFJTEt4eXEIrIIZ6SZ6YIZRhAvWWEAns4RbzcIJX0hoYn8AXNb12xwPAeSaXCkLMeASgUvaSgxGWEGRWKgBifBKDcwmFIb9JKAAnJB4AGMhcEx1sGANv3hWYR168xRRhtjkil5erkqOejXE2rjQPJLrEC6FcyKOHHMSzyzBA7quEpAQDtMLewuABSC5JBpJDjHnwKWviSxEHSyJx6y3fsgZA2FdMQiIGO8I4QSKlKh5MSikFJYyctBhDLhMCBgYDyfjk8clPkZ6Upzd/uyYQSzIuO4oeEjXE6bnwiIdZLaJjwhJCSxRZuPrxeicknHR/8Rd/cevu3ebhPltpMceHH32sB6ZujU2d20Zj35CqEueAj6oGNcjj/kKHY1van6tcnMTjzHfaddr54x998r0/+gNLP+u12eXKxJw1XGNjbHqPw7h5oJ9Vn5tdnJ+30ck2NLdOGX85b7ndadkGhc/37t/nqmUCuKTl2ZENFDGybclHcR+jLoJAoj6Ux25dV5V6CCohM0z4oTaXMRdFzj7BryycA0cHwm8TxRp6RTKKyZs0oASjr62AUAFDtuL99CZSOLu9DpxifIJZWpqQwMQLQGSWGoMLg4SoGOpQDwsIEomYsJVXI9o2c5M+Qcg4gseesHt1soUACZsSx9fR4X7V7ZtlJJH5iqyVSqkWuMTt9u01AcqAq5OTg9tba7Lj4E81BYfWzERLUq6nl1OVAhKB3mAohzrLGg87CjV/0KIoLyw1ychX2dn7AJ9GY8pRb8n0tZXBsmMEYErSYk05YqkxLwvsrU6ShhweKysPD08MQyDU8JHbSbe3qNdQq2hLHcdqGiAuN3CNqJ0iExOaDXJAV5cLF3pOsRWg+0ZM6et0b9253XdP2UW101ZeXc61mC66sGu3z1OHeSqUJSKJB2Nyxw4TXRZHsF2u7456cnqqE6nuYA+3+gRZBAkjlUFnqEGpg9cNAEQKJs+ck8wjBsZSi8MPIBuoyonLQmUGLsUpEjfKJuUuXpIi03C/QAhMY2xQHEsCSjcQpEYA7Uxl6aKuAeeD2luZjYZaAWuytC5c2XYGZPupDCyt5fZUcjawSYuWLoZ6pW+DvcRGFthGFC3rr/xMhAIYwypxoA/eAybDGemNZzAiIYfHA8bjU1KUXzBQeZIiYGAAILyBlzxpoeuTeKnkAHAaLJUZAAHqv0vok04Q5KwbzPgXKSE8nhvkNwGRdN1PSTzJm0hoJUdLpJ/QwuMnSG/Ubx7xwngQULsEoqSKq02dhSfDdkRjUoEmG0QBD2XSG5E8JQNA4IZnmc1PSdpPLIlJipInhxmANuFxyOgoLHJgyokFUTjZNQsyAYP083Q8+rnClASH6EolLd1gJgTA/yf/2X/6K7/yK2YpGqsrBzvb8AOz3Xx5ac0pzUpC7yCs5umwOWxibP8gVlIbmdM0B/YuzddGOWE7zZdPvvjD3/8Xg26zXpmq1GZU7rkZJubAchQnObsK2LbQqbERnfmJ8Yad1Qb7TieoWFVyemZX77DXJXi7wYmY7HneQdhkrWLRROPvUtZs9ijrSDg6bSXe+fsOhgz7bkrh3Bqg0lqTgM23spxyVuTi58vEr71iksujmKBYeut+EmPKnHqkU8VPBc1DMXJh/BeY+xdlnWWx/n5SmyxNpUDCtN58kiYGNkNurn/IFV9M4Z5eWCtg0bF5BI4OacHYvzZla/vstANE2RdVmwMsuNIq6D2UU11pkGIKrY0OQcwqR6nGECSqz2hIYqxsMYhLCaenYuCyuxPHeDARjw53lJcFWkvlsMxQUaBlaGgCwCfKcDro66dW62QTnt6QmF3HZfUtTpBAfdCNmdvbZRTgUkjy84ltEakFBUCU3h5KyOghoT1YWFxWZARoLwTb4j4A/kPHUbQ6UeOMZpQfI269EW+eVtgdCjQK50f7B1LR7Zm5kJ4YJvju3duI2qnYcqzQ8NTOXh2vXvu0TADrZ8w6UZStwL9BpOQpMS1KZspPgsKP8apmXxH7qdQERJIAcjiHx54Po2M+QEZfdrRnKlev3d3augVeZb/24cIbBVCsdmhlcdcgo5pLlgRIJLLx9nwFlQ1VovHGqHjZU5zJruwpXXh8ldCG7JBosYYZDxiMFkUe7ty5A3KuMmf9tSbdxECoU2m0GSMcM1Lwi8SkeIqYNsUyKQmx6ydsSCdyDJOCJGIkAY90fgKf4ssk2AsMJTl4P+XxJoky8CmlDxUSADyJAUJfJYdcJMaSRDIpLeYTQL0CBgNBCXjE+0ll1X0SFsYkpRdfmuhwxWYqGiMsoUz5mmLJtPkJaQwIK5Eo1LeLssADc2ZAloV4gfyaWaAiEHoygzCIx49cSEvsySok8GMmJSNThvqAJQSdBSQJzDKeScT7mZiDwNtOK0IsFeDUE8BBr7QZhOArDhOJskAUaWnlHZgkuZ5auChDfAKAkIX2BfPFf/lf/1e/+G/9ko3NKytL9H55Y9MhDvZq6hDZToujwWnP2DlMW/EXIffVj76CopMRNGgcNCOObbAF6mD7i8++Pz1xUZ23xufKKo9+6/BqOFHVm5kMN0LN3d8L8zYPH+y2j61FYUOdKTJyNTfjYsUT59i4GYud73VaE9Nz0dWKPNqE62AFi4LCZHPKqe1m1vFwGbPWIXYtdZl+D4mlWCJUwpKQg7Cc+ibXAmRCSiL9zOQKDj5hPSoi1cFUxSyvFwZM4MrLVzCmAfRraJ2YlJ4y9fhkLUnpFihT40L6c6HDjR8MACB8VsYwDS0+LfHBUqlBKiFmyUe5oMioYA9Cj7vW6Jv+GyTYUDuIAarjZtRTLaQsKHzw6rq30Yvmx5ENPJNWr64txNyGlQsO6UPORgVNwstXb2ybsMnOMNrFm9ZBWLC6f7DLNHOSlKmUkBitVGVxjiJOSNKONP1LbcCDBw91/9s9SOpx/6JKVK8d7R/KQhoQfGZHOx0exMVfVT2tWxRESlDZY1OpL0zO6AbFcmo75gwBFbYDGxqLDfPMxKspwAb5q+DV6ppS5mvl46rNL37x5RNH9D388hEzFDsArkbKJJvdzRem3xtV61/DciLkcbiFMKNB8rqAGMsSoZRkKB7/upzicYuu4lDWpF3cDzHqkn3lYvgXcwmDgTr+/1c5YtW2g9ATQYyuqvOaQAloA1A0lIHxEK2SH+m9pRIvDDtiBBR4ykoYSGAI5195srbDT/skjDMU+aaLe+TkuMn7j0syqtRiWRicJofJCF0ZY9eQgLloCRzhPUdFXwJL9NgnT2jk2wcnvoMUISyAqFQe7NwERGIbWpEYTvwZBiOVr+ITxlckoPX2yQOmyCogfaX38hWMFfuSqZDwU4EpLTZaEhnEFSWTNXrjq3hhrSnSAr6mBx8hqWBGxSf4ue/5C3QYBUaGsYoRsJ9c+eH6u4obrqmXzhFbY8gpibR4wCEMArDdsA0/FceAT4Rs2Ou4Jr5KwtBtVBbaOJXHhns1TbMFTEbRQgIx5FINMKnsMr/4KZoTrRrSfiZ1b+FSDlEQwuhiAD94g4deiVRJ/ITBJwJhlJNzwKqchJnKeh9JUvi0SKrf+I3f+Omf/mnLxnl4DNL1THmUObKVPgruIlTUVEDWUKEF5GxxiNMslZxMaWWcYL7z6vkPv/eth59/4qCU2amx5YXK/OLS3FTVaQMOq3HP4NwiP7zV93OdtomcQaU6besvNBa+LC2oF5ezMxMWjK5v3mq3umR3opdIDpMWGpGlVaChfnz9HASX7IKzlfTyoqBCPyPMN/72Ue+VmS50ZLOctKzu+MhRnppAdHIog2QFRj4gVxBEFDa621WnFCuZwcwueFrHR2DM3yOpXpdBSawvIHCa4LIGUjUdUnO3rc5/2XxL/laVYA+T1qk4V2bAc+LSvGhQo5RdwGk2RAOnJhEsO6aPjDdsyLV5b6JWeM4sG7O8JToB2WJF+62O441LTX231AcV1ht5/dTKnOWYsZSAf/z2mimVxVo1vDFgaJoG4MRtkL0eO261DMuLW6Jg2gSoRFYoeSexVMjoQFzFIQ3OqTQnxFiE7k2G5I1p+p2BceTY7Iyqat6CAKUCLBckaWkQPGUeNGZ0MeASXoei4IX0nDJiAcBsLby1CsLX2alo+OWCIXacHca0CT45H8IkMCanJvuPnjz3aKgWlpfsQQFpCPzqxVP469HjvV6uQj54UGo6xxYuEyCGNTbgCYoMO1rW01NIlTUh4/zLLx5QknZblz+WloBkSBF9/eLV1tYGa8MvJKEcxVDCEyGMTMYghTSEdQ5EohTqUobbxOEnraAQ8kn0PpXijJUn5VMszIcX6+KTgN0s5KOmwSYhMAECAuntJ7SZxE8KqsbaoC+AS4bSJ5AKADlosepnkpOW+xYAjIXhWF0jt6gofvMb8akYPmlFwu8BeZOvDIDxSAjeI2segcymJCgqAEIQyFxkjHA+IMlNEsCR2dKWZJmJFwAAP+YTDCR3Kpuljqm8igcDIgUkD6tXJkJ9hRBd/MDpwTwzCCbhk4R4acVACD8kkpAYYHVAIDn30wMMjLd4yQF7AxCJCv1+9XIHn8Kk7SucyAEgwzTQhM9jJDtgpCJq1PEgnPxADkYM4XjnIzKLwNuDRD7C8INU3EhkfpGTd2iRYPMBiMe8uSzwPsFmI7NIVkCqZ0/2fv3X/8P//G//7cPtN64JdMl7t3Vcqc+PnA3cTDI2NdNptqpztbjHK86Puwr/rLlaCxl5Q1yXyLU+cF/jl3/8g+989ukPrOlZqM/cur1q8c9So+ZwzP3dbev09FHcGWylDH54J0xVzExP2SNmYD48Nd5o6/zYosTDPOMMsvOBhMNYQH89DiZ6zOvQURZ5p6rOuNQoxx3FbmaHpXTW5JokheXxrfBCklnEolJiKT2dAH1fwJJ4YCO6FL7kbGsm5Er2VW1SmraykaR4sqVNpGf22U/lKMZdVkbk7EgyQAesFZDWIs5MJcYnzEw5RqYMPX0Vo+hLc3Iu73qNFA8tSSJt4Q6wtBz8io8G+USTWaWyxSymSTEAAxim1huYnb8j5/xqXVkmSGo30S9dxqIzNnKzdDhh106ODgWcWihVaOnAUZfahtATMvQuGhWnLtPbhcW5U4fIlY2+quHhAW9+eC98cv4FnzJpYM8nLBFmehfNRSlK2SQlkKp4txeXNyAXh1kOL6p8eWUeXklq7VgiYjw83Adfsjx0mhTM8uhY03KkXMw0yOnh8QkY8+OchJpHmbp0HZy1fIYPbxf1heYUyyk7Ij3qpuxgW4yvwhoA+IkdJLQAyJwhRQW8GOzZRokBpaMBkDseoahRcgsLXFOTYenYKz/hIlM/hGl8xBYrpvjQ8DUASyQdSj6SxVJyMYMHHmFrmuHhDkuE3vQOTmDiTeupFkZE6dTGpYkd/EiL9cjV8rKiwmggeevvFs4KoD1kOLhIaJJIOcQDruBHGtuSwOknfrJ4cAsGw943DwAIMxKHHthgEIkTeECKVE5++uTtp7cHmHC+A6Bsk0FLWPIbzMFnWWYXci5tiWLADG6l9QkqZYNhFRVA6EExlEkCKggLoTiaSSpvwOLxBgNCHjDemXFhjyRgEkCqBBaZ8SQsQHqSEDW2qQXVgYTcEhjDkqMFMmiUB1eBosQIkwmVlRAJP+UrSYMVD4+fwqhgJzGI9DMjIXcPg1xDmKWgXkkIjzV+YDDgk4x4S4iEJJordF+/3tvYqP/Wb/0WSnh2IvyLZ0+ta3L/lhOBXNbKM8vuOGTDCin6rXPIv64BgOHy1PHNu19++qPHT77YfvOSeGpzkw6Rq1bcxDq6devO9qtnj189W19dmV9ZilNXuQgW6mUhqynB2XKuagzD1EFLzS0Yx6Fzgucb1eaJOc/K2fA8Zg7t+Z1yo44jbOPPVjC1h8yzATAzKBfj09G9iORahJJBOZXNCEeOY/BEMsaDEWku0WWNvPLU5jySe0oZRfUmanh8yuoglSS+QqJ0+GgJ8eionR0vX2cnZ40e+R9IO65rK+eHw0M3JNT3t6okha9EILf5VSZhg9MafKMJFp5UIWe/cCIVHYZHqpIptiXWvAnj3VLTofOZi45BGIs3R2NyQgbVEW9NgtyAZxNMs2BcmzQz8zXq4V4D4sA5ZLqECKpEaKHOetaWF7dfvaQCocalsLQbRK3Jc+OHiski0xkDwNQxFqYxv3h02IIHD6yLQ2AJwRwsxth9+kkPJdHG2AImv/iUVryMyMJRU6tfs5+uXMUse6GZbzMueG49mG71jAOPozczYVLaRRialvr8on4HtM2TF1DJxc7rndjSa4DlEvJTw/GOs3t5t/Emv8oa3SJgpjRco+yDIsZk5peo48iSwUCrbzg14xDps+g7SoUPDPN0mYlRrJIAQzHr/vU53cEsz0A5VVw+SzZiyEyUZBG+rYnxtPtRbUomYUEg1Qh5PEGKGwSiXIvNjeLs94h+xFV3xQzJQyoodwLkLnElR8ok0pv0JcElHrRRTJJCQh0hJNAF412kGb4RnQvhWNTsOr3SQRaJkAwrT0jyJ7QSxkR0uWVNEk+Wk+gMEIfaB7nho0hheMgEP7IDAzCs+okTb5/oA2+5txjYqX8oUpyaGV3mRJtv5GAICRcnrOSkJHdynU42YimkwxujnbaO4vCQH8yexqqSieyEaRjR05QWe/CTP2zy6CfMUBG+t4yAVy7gabyYFAgYAUkQgsQjjDH6jTfYFIcJN5kl/4w573UhEV96Q+EMlBZpRoG9iFNl7Awqjj7k4E+pwowoxm5IQAIgyVl1nmxgEoxPsuyrhRMyIqFUAvIiIwBwkpHCmQXwMJjUEkM3lpbqf++/+3uEaXyEPf4SW8rN0a2urGPYmGF6ptJs7o/b9zp67uYtjpxYwur8s7HR7ln30+/94ZMvPm0eHgwHrdtb6yPVyuJ8xR5Uzq29188tGXR2mymCTjuUULNu4Z5dXQrCfKPRqwMwU4FJBXv8GKvrG+qcng32EGrp57D5EEb75QmfKE1UssxGOOpIoJwDjHlwMnu9DqZYT6IQTUqQKxplERoyNcsHzcXEcbG7u8dIaWz0okJEPKwmlmMcEGtFsibyw/kEjw6De8OEqJ/ayurB5gtB8UKkmonnQSd/KkGrKYOEmTwaLTxeRmnqB2dnUxiTSg2MboDJcLbJCktiAYBt53z7KiH1UEdwO30evQf4pSjHe8SliX4qU/aKI3phqVZ6FIPF+gIr+fmDB7/8Cz+na6jgsboysWT8tHuwz0GEPVTsxcMD/XAw0OxYuIVRtxXDCuBYe+XwTkKOZUtDh8VSOMzEDb3aztMea+ysZWtvVGYHjHPBI2RCm+isFYVWrqNOlVG7zVxmoVnSi6u44NruL4OrotjDy/YV31WjtuSsEkPM6pqZCZvpxrVeTvxW4rWp2stXT61iJRB5VV7vvnfvs8+/sC9Mq2IsSzmOjw6aR/tUpjozu7y6MnQ/x+SsUwU9SofzUf2gDFfRIw1fFqG9LanoTolUXzhRLDlQTkZpWkdg1N3mtNGhMYd+yRSY0KJy291Ynv3Nc+RPk0s0ygwuzZmM4YlSVW0GsXrh8sJ6Hsl8VdhhCEotxZAC9hN59IgeBmFg6idv6YJrdAwELq44xaKjWNaW+Qq//R12Fba7LUPh6dkw6KG1g9NZ+x9m5jRizeMTB6rQa2rnqCQBO0O1b1Z3dTsxGFfuyphP0/keTKWF2Zr7Rr1q872aZixmZ1a/0zcH1Wq2LBwiSlmkQP6kZVfzFDXn39Nd24Ji7cHEOP+jmk+n7O03w28bpEgw1jjzBZv988nGTu+V5UWLQOLUfJs+45bRgT4TS0GKlBhyau2n9fo6HCgW/2S01Z6QkhkXphh+x/uNjOr9TLsTaHpmcWk5ZoTciDEal35QSseIlwlMYrOTjmnmNGTxNag6XlGTFZbiUxbW8uso8eazFMrFJ/ECHtWb0BSQbhEraU2kAyD3dg+4cTWiPlExe/GoCN4gJkANp+VYVtvRCI4UFpbzxFJFB5HwD/CEFvfIwmKjTvJzM/TIkpcgBwM9KVVxOi8as4DPBTLFnvAd6RmcWfpl4pQ8DbF19i3cnHRgCxvFm6y3Fz7laKWgwnlkrbiqqdDq8grGTP/+3b/z3/47//5fYJEP37yyZELf3Q4sfXUW0CEoR63O3mF7dGqu048ZNmrsHGDd6HFNwfjwW7/3Tx5+8p3T1v7y/PhPfPX+xsLURmN6ftqm29als+CbR/c21zdXFtXAvZ1tF3fYVrq4EE4hq0JdL870OHD0uNmZmDSnaKLViVVz7a6V7wPVmyqVeyJOZ6sqPV/2adGcaKoJR63BoQZQ+dbmF5zjb3ZNa862Uwatur6fToyBpwPfXZbgXa/NizKDqCVSWHogjSXDlSX7yCw+cZI9V4aV8rwqzRP31sQdVXk0f2oIa6t8a415pxKh6CLi8td59WbHuERFC1bKYpLjwwP3RtBtlajTbpn66HU7CsNqK31/HS6LoHj6deqUsDPvHI3vsnsb3eIwAy1aHBbA3MspEzGrK+XiTKbfhDyLQR9UOgnpsAJlfznT2EprCwxEFLSneXRIY1lY2ZVkd3/fgrT3PvhQk8kvEuNBFnMpBqxONI0JlbL2hFZAyIA4Kui4dRLucjVxdur45MgCH0PI/eOmpfbHuweKwDjhbNhdaMxx5hsfWvmriqnViiBmXcpWJzxoybhgATsvlvWnV0TkDoi6iYTeqZZcOS4u1qn0yuqSu7Lqs5XzwbB5fGQrMG1USU1NW40T25WtCh238cxAxEWkp4356vrq4tbGMm8hBdNMxdKEqerq2u3Vja3+2Xmz3TJ9cnB4aKWZVtsKK/1LafU8KnPR3+LZs1HAGhE9hLS6LBfeXanT1pSWY04sPcorLgSOW033klTqlfGpcSNg0iPbaE9kKeuYtkKsBo9AtUj0W8Gg5AEDUoDlFCAgMcQNBW1mYkw3YQIeBeCrwpNrPVAb6f2EELDKDNI7MRRbTMg5Now3tZCKIuqh+JmWS0K0gAkUXsLtpaDgYWmCjXJugUZ1qbGgDWO8cJLwIAWYRp1zWYuRWpmNkEpqCPGGDWi5U8XonIkJ7bWkQx7Hrz0YsklpoKJk8uKJzf16Q6PhvYkNVsVfNBK+rnB0OJMNKpoDBnKdCF4saQ1ySVXDamQT/dMQhidkCzJGOEwrx98g/JWSSKtNNQbVq2JBUpLUkcLLDvF6g8ceq564wBh8yxp0gSob2kYDsBhNsrxnKiYV8yKVdRJ69913TcRJSxOMwPIwLMLEjEgdIjsYcaKM4Llw5K19K2W7KZnLTskA8jGoSqliRiHGsQNFZ1AR8GAVwsh2ebBEaKlL4k0FJDYxPkErEqBwYoCTSCFxi/dP/dRPnca1B8cbqytmU4kXB9r5+cVK7DKtLTq4gN7BYA/OysJ82Yd7dd46/vyT7z97+Ong5HDNbYAVXZOWOU4rQE90I+ZmVxoNDg9nvGG9XplbXnyXEFwhsLzC7resCyIWhYg3M4IqoaPiqIumN2yNuzh0JJwkeqqHa1GnBux6/CrrJNNq9yam5vRM7UVgq89Hz20RiGtt9AncOAoj54UVk7lGCI3icNPBpoSEwLTESoByAJ/uJCsEQG12XqlFX3ZMutHKPiORuiCkxOqmxPw8PAy3m5/wePTc+E0BsMLiU+BZdpSEBlqGS/EIMM0rjcKDMFajRMaLNY7riMNbwBQ4bUHR4A2kN2BFA6EenSTZ99QBoUKGlXgzPKJRKpuwDq6rmlgWzZu+Av5Nojp/dWtjwba+E/2Ug4PZ2a/p7VE3dcdIlJmjEopmkqwuYmiCqKYeD95Bd2batE+rG2PZSrVmpx1Nk32Xz6wsL9GWnb2D/knPeSHuVcOhUjBjn3ln+lPyKsLegb1aR4Fkdk41hblWbdg03DuPYZY+n87l7NyUBfY2EywvLDabsVCb6JgyJ8uGabUJZWSEF8gWdFn2sAYLFvrM1kYmZnd2jzs9q7bqreZhbAg7P2f6b2+uWcEZWx2iXTI6IqUYbKlWxFV6CESOR46KKFANo4uvfbK9G61YizqiqxFWS0+0Nl/RdZNWGjHKIhRAOyxB4Ff8c7G2uqAONxNxyINmvIwEJAxXw5gWvVirIFBgRGZJYyRL3adkUXnwwN78tGhMPJxiPJJLIoCPDAhD5edgGKenCSghLWMsio5lG3PsTmKwI4ay6itRRTfg2NZj+KdO0jb8h7EuTn6a4ac+vJ2fsAl7GKjMJqIeYZyYvEqeAQgQkLcHKm9pse0NXgCM+KwDkuMEBpFEoaRpmOSRwyKoVEraIzlgpU6opA8SEi4JuBWoT4UK9sJYGCmbvdEpNgQGjAd9pdD1Iu3IRRGyN03wp3UGI2GUkaM1i5D9hBMz4JN57+TKVn7OH0SZWgpB7LJAvFjCmPgcK2RTAQCGx48fSyIjgD1g4AcvcFOUAhbhoF54CW0TjlaxbIbyMwUrVWS25AI/sEElbVZOMXDKiMfAy09IkoTkEipogyoVK1aAFMnfunOHRuO/vrBsKFG/iCMQavM2Vfb1a/W/6ImlKYyzWT7n+/z+v/xdR7kZsRkxOg1IRR0Zv3z33dtcQ08eP9TPZazC063nVWqYtYY6Bip+ZEdXpkxU4gQ/MdRwP09jnrJhW19DbTpqchn1ba20VYlvV4mDsVSI78btZ3yixetDCPpiZWqEQhcPoc5IFhZZSelNa7Mc5ZQfDQOXw+vx3GHz2JoZDYz+Jpj2sMVk4yrC7TbOAgmTHaaZwycerhuENHRELYArMEXsk6WytJU40+yTn8raXWiRqdGYLpZWe0dZcAI5yBhoxu18OohRa9DlJzCWVb4YgFbVsJYMKmGM+emRK3TZaEgYHqXJxMGvFqtTM5UqSIXr/spyfGcAi/EoC6lMxAQz5RBT3WoGCgZoU0vpM5kw2a5+04k56raXHZFRjtiCJrRidlZXxmEPPEJwMsTHreikEo6SNTaTL0hsC3aTGXmixe3TjyllmzY0S8dT04b12r/QbbW7O4j2XifAllsJGwv0NTrHhBBlWHqNwbz7yWKfOrUfX2wsOYFaW/L1r3/9X3/ru3tv9lmaRt0sxtKPjg9UvXfu/vjR4R7toHRUEaHw6pRNmvgkTxsFQhPKQz4ePw2giSIFFXpZ5krB+yqDWNW/EJm1T7FKYhAXKoJdP+DVTyRHoOAgByoMRpGxIWDk0Ce/hX2VEL2kQQ/EZyScyUFiToDCZ7BSNCbU1CM5VCKFAcAvoRgPVKFkb+FxkrQSJz7DLVOIigFMycSlr8BPCRUeAKhkDdvYYCohwV7mIkUjpvBybbBE+gpbpvVVTAIgRMSsM02FHAzIzDLcOAfmJ4pSSe4ntnGFGQmFYUieZU0ZCWPGV48k0noEYAPsE9KUm1i0bbqcMAv7ijTdhV8MHrwBixQjibAAPMglJ6j7Cqf4EEPBk7ypFdgQ1sOSUJga4Ef9F6MqQkKqZMi9Li9gAKuKyQZIFJNQFrp4MUldvAc5PxMyORTjEZM/wWQ42UMiMYhMPGI8sgBSxjFg0epv/uZvalBxaPpbvB6SNeBsvdqM25Dt5Zm2wg4z565V56bOB729p4++9we/98Vnn1j7b2lorTozX68sLdbda8iFyI5x6IHkuNZsmcPzZ5r2pHnEaNbqlabb5Esv2JsElIVcWJGCbW4umwB0z13qTu54mJyedXGHQjC7ZqWgzcatTthl5c7UFB0L5WQuhCFU0DJLAeRF9jPv8f1PiA6hjCFk8CApEiF4+yTLCki84vYUgCDEXcBCKZNMnviz1CRMPLRa249W2gEBMew4VfdA4i0J6jDDAwAPehuS8/QavwLGAAABaHESnZiyklLuYPDVW1pZ85VSQeINBk7kFKvCpee+koN8iZTWURAeMXSS+MTA4J0sWdei08VbCQmEADAGlZbMTxT9lGVhlQPLEpJ/ZgHzUHmKVIvbkZMrHJUhTMJ1gy1nGs/0fGOZZG0rkTWGCWl5UtBGIcSivoknSj9lX3JOERsXgCFNbwVkylFDlthapCQv0QQOulVb5map7aS5TI0ONhuNBc4zXbR2y5wfOxbbSLkT3jIZhkUWPHIKc4oU/whp+eRIPJaQkEQghZBg3ik0YJFlOs37QVUUgWXdUiImGVF6iImtsGEssUdnqaCDUQCYR1YxwRqKBAZ7EhBPECI9wLCbfKcSKBIYPDcA4MtPxotJhYd5HWAMKQKHgBHOPzH+omdfNvtZ840u4dq7ATkkWQDEIRJpJEC6dhhjNz+v05bKRlJSZV68Pb7CSRROGonzmfi8Rx34qr8dy3wUlfGmczb0CLz1g4hIJVdIN01OEsUDzOypALQ8Y6ytgldOWRKlHKNFlH0AgMteQtODjgmMM75TdVQSraE6gCWoIC9v3fCQf/6ESvIsOAE/ZQEVXwVSG2DzExJVLk1kFjfJkJW0vkoImGnzSXYQgoQ2M7gPHjyAKgRURAQsy1RyqTKtTlnUhrfNjEjMgCc4vR44EZLQAxU5B2hRIWC+ivSTHqKblV8g4xOVJMRiuvWv/JW/8s2f/Rk9bkeYvHr45MnjZ+bPwzKEw2f69u17Bwd7lITOGO/Hbq3zYWWh+uzxg+9++/9tVJ3WMnc67DXs9J0cN5niFpfdndcH+9sO3lclY7ubmQxLSGLClitPL48RiQ6Hq/q8SU+ug3+3Lvf7igafHB12lnLKV+YbU3NO0j93/rvLWBmFIjEXHWu5zyxa4NSWyiOnpeCoaHxNTaDdoeBl3JbS8yYxBaEEzc2QJOrKSwa1WOwkKxIXFxs1lFMZmE5SIrHg8ML8GdMbPOhGFNkqhBk4E+E12igTHsXwn3gAR4HarhCdTR3BCjCRPJ6cXSaxtTIwyIJJU1RMELqzBQrargLizQyfSRcAqRuAPah76BVUJGaKzvZP5+6lP10kE69wfUIdXQNiYhE2FNLZF0BCdZABqgIzWrgFbzuRc16pCgClgw3kxDOS4dSZmkUXZCobGC3N0sJi6VpfWjlEgGTL7BvemK774IMPFhYWOaN4ZtwNN1epj0+68N3wJe4rNqyMMh2Lqexit8KO0TweGwEkuLDsLNvd39Pk415hkp5embw8ePDlq5dvFLTFBeYVWu3Drc1VXRCqqA1TcIYdszOuGl6dnavbVKgbYUyDwPBcSxaGrpR7qIfi1k+Rx8ypTKECM7EIUwCfUkoiU+bYy9qawPGZ0D1+EyvW6QxBEJbItBc+YcHeRT9NuxXwGMvjAD0Y0SN3bz8FAKDnjVcIo9hLD9qQWqBI6rrfF5mIliBQ+uSdX/ENlZ8C2PUJQiUtEnwi905syYP4rBKZYaf4yg5JpR7Igq8eIwBcAUYIckiwnXiSVT999ckDktR89QSL5QHgsVYBcg+Z0CqYox2nlLFDqvQIAia2wgHAIWw4ycpggXPSxerESBSeB1EPCvkTPGDCVIpxKn05LdlRXA5IsS2T8MXTckmgYs0RDa5yaX85b/1GLD4J45A9lR04JWEOUgMwj23kpIWTRcKzJBnJ50NQUomRaG/P/sN6YuCbkiPGAV1F400akIAXxlhmRI6k9WRAvDAAX6OKl8YpcyHeT/EZCZUYRAVEJkI8wyP5L//yL//ar/2aCj1vK4DD/o+PuYOYUis2agv8/gNjF1JyULNdjMuNeUcuM4R7j588f/JwxrzlyJmGatMG05kph4n1R0/5gpyEHa6lqFbkBVnoNrmZl8aDx6QoBmRfOHJkQ1wY9/Adq6TM1dWoW8gtLj0fkK/KHmv8TeeUNXwmiCs1q1BM6ek0dPgQVPcR04zuLXGtLNGd9fqxh5a3jPffk1mWW7RQ9FPGU0pZoMqLlNV4OdVhKu1T8EVcikyheGM4VgkUJxvrIwmRgvfIK8hsyVSWNJpI6AsiJ6DVl1kI1BVvRMGLh23/4EAnxjUkwlj1yfFI3nH02OSkT2RyOYiV5vS/YIheCGww3IzPcGKTNoSkTfdlEfzuwSHNb3c7Y25uqcVSorYjJ8qtJoZWqUUQGolQ1Kp5Z6duaOMXF2Pb32l/hDNvYsp6xAm9xotYkUxuC6VmCaO1vrykIdGyC7OnmM9KSiWL2GM5H91Wp9zhG2XghrieDWsbb3b3xqcqy+ubg/NLQ3cSGYslV9GnsfPQ5IF5MO5HFVJFk1njDwtAsvoHGtyXI7UvR+ajhRt1l0ZFTldXXDOw3+5hZto9ojjVWrvzwZKinsPw465m1xbEbCK1yXV3UZpxk4Qd5mVKgGYXXUWU2NVcfVUUVXLi4njKghMG4PFT3s0D0wHTKYxIrC/0OZUAxxIbu2kUBcTTxkjmzCzTClOhBCKh8CY7+VeQHrS9tWB4hdpXn9QZIg4kxSJ450/9wQyX+LfDyfD+R4H1Bxc2Wqsg1lbrg5tlxYALms/L9TKxNEbbcx4uPILFMJaElVnipOWD2IAZzhl8JsPAiAyH3sA8uMIqAGlhQiLx+CTg7RMMCQMYEJh8WzwjEFpedmF4S0L0jbm4zEsq8IkZHpYxSftExXUTGKyET/xv5SMJoxM1Crdka2rOmzr6qUSoVGYq54ESQ4i+zNJnjqJ0yxaSzEIyTPUFyEclT+Qxz1acezpw2MM5JMUWhJQElCPtzLdPuv9M6v37t9VHGJQvcuLZQ/YFeyqbGJ8QEshrZgEQAoQi8UNKGZOsRo+6AGf2vQF4MCNeANu6n/7IWb4UFRWVgkn7+Z//+frKSnN3Nza3WBQ5M+sIsKXllRFnvY2MGgsaTX/84UdX9o31+qNXZ9aNP/jkh7/7T3672zr84P6tVnOf7WqsrJ8Pusy7FQCTU7NMt+6nObfZMj0bi16KJvTcEzkx5iyFkK1lHGcxy6I2qs+yNjUWds36MlmzlZb/19p2UFSe/8dtVxazaRLsdLgaj2NZLV4zL2DIl8cDqcnR9Y/LBKKXQx/4rVLP6UEKLYsS9RSXgBiPBnh6ThtwZYuy8TVzAICg5xrzpk+VBUunBGLTcelRKSaiUnYetIL5twfDCRO4yCJ28nYSsqnEykm7Y42QDBYATMakCIUxK+vcn26na+ijRHxV+Lbd6fZaUwCAjVN8hry4lSl8IYqB0IfSA8tKIRf8ppaJs3pqx8ry+tFJyzTv+GX4WmmsEZ51TccnzUG7BQPNhHZ2pirMoIG5PDutVef85AhyEpGi1/nP7cRWBtprJS/2EhuLqHfZ5uFBK0STpcIAKruHTforF31zP3owlyP7h03TwisbtbHJmde7h72zcSuLzkenKo0VhugiVIbZNzSYsJzUdoheN6wQ3qgx26GymGphr+PwpfMoF+4CoqMJDgeZnFhs2r12MEPItzZWubz2DtovX+2rImpct907dpCw0zvORxzfqZHRpI1aVqZejBlzR18qqkrUrehk+2VKx2w+KkQtdnDexwwQAnemhkjWKMqoHLkh4CuwKFbFo5ijaM4Gs9ValNB5jAaMUWu1QE1GCEF9rZ1FRRK1SFiEwZAavB5gIv0UUKI6OSLBIFm2j4RZ9ESbXh7RqECV5gNPoslRqcgbDGISxtS/+ghM8pKl6OmwYqhjGzkNL3UM5OXGeWEBmDFACQDYJTE8i5lt/OSDNCQRU45kEEBdpCdxSiucePADAH5CEy9SAHu0ED/CcKqTdJTJBqAXCAnScMqI5HpGuCJCTRQVUfCoS+XtQUjYO+cCLBiFnBwkESkgs1YKZ/aJSMHhASHNCb1JfsJAj0axIgqnXGtyNB6AGXTxYiLhSCykgb/RgDgW/ntQMdLHsPikCJvc4dzqBdSTVYQg9wlRfRxf/UyKUvlKGvKITwXjp4fcShbDyZOQ3oA9cIL01adskywuyhgJOWPg7/W7kWokNlLSFAX9ta99jdul4dDg0vzr/qv5+n4qtmVwDsH+eP2j5vGuvVpO5XEg1yff/e7v/ct/tro4v3F/6+qs75gH58zw7DeqFWi7nROH/lhrWVYPX0zMxdEFqgDJKyl20iRwXBcVbvbgVrFimPsQh9RdyyCnNp05utdyzOmZibla9ANcJzlXnbeoV8ffvLGz4HSidKaXVhrbO/tWanJvqNz+kXmR/6iF1tZUGoGTjFqUQsuiRFTBiTE8xxVxaa7MVjrKDrCq0etGM2+LAvVT1gqOc14M5ihJqijllNYn8pQXdCE0vhQPEn5vGfQTOXRZcPVLJEgrgDEJVSEX/ScPbDliQDGEcx4rZAwdFCWK0kbBlekEYbrnzRzAhop4AQhrzkTRg+6dlJ5r2J+F2rzVsj5hqRrDjCBKE7hBIJHQ2m4Om8mZ6ObXuMJG1LUBZZJW2xxT8eWEYAVEW8r644FPUXb2ClD4VmzsuJoLMwW5MM8lV3/pSQzYrFGrePtda4ivxi2r7f7wwbPVtY12/6xnF/mEdb0XzsOwtOdybOq00wdtr4X2Hn76wJderS46lyvlM11RcULPHfKsKlBOGwUsR5xXcBfDtdXFw6MWKx9nh1wN9g+anTbrV+fZbjWPrezSAdefMLzQRpJI9LCKNY68DIki7AYxGovLhbwoO8Wk1vukUJQjeBKjME4iJ38BYrEWRv0NbBKoV9AptlKcsb+AiuCYcngrA4iCbEEkEiXOAWUsBnlUJfdGTAASsvaJ6BEWdroGhJIQt/jUFZh9FQMhtvwUxlnyigeMJYB4D51HNzEjIQZjtr1ZkH46OH/vnfePDzkBB/M1pzNO2lswV53VTtu66cQSdl8gNt6/naZGVBi36GLJG2lv+ire4ycqBO5PQNaYPCyF36MMP294I1CpmC8VSUKYOfqvterthKrsi5eWTIRfvXrDZsmjysne0QZvlog2x+r7uIhqkD9bzZOIMXN1dm7HvHrSOukYf9i04h0aMDrhfFyje2GOTn1JHShKZphrkERieMYhnoUVmbzINYHjFidZ+e07K1lg9/ULeA/NHMbSMc5lxeInRfC2M0/PmtEveqEEYu6H0AiHuMyNyIhsZvmSgIU3SwsLKBJL/Gw0UuCog8cSYG/hNP0SkkmIpZgnSei7nvjR/hEh8DI/fvropN36s7/65z78+CPXlfROWi9evnr+4uXOriUT4TRjsm3aMHvSH7hkonJ0sPvk0YPf/xe/+60//D0r+DfXFq/OBpb6LDXqq4sLM3qXJ9aDtGL+pqgW02mVtx00OrW2WCzaH7VIzx1s0NWk8Y8ZAxj0BF+lxyM7xIvhVEtsi6E7x0c6eE0qISL6AUOjq/4JLwm9dAdj19D+0kyA7Mu4RzOgc6dDQKZyqlyIxRMFp+lwrtEZl3F454kuFc8aEscmhmxLE+R99/ZtJl9G8EPNMMYt7k/pYE8xweZUS80rJ70WyzpEnSOmR4fXmpn6/IJeqi68WYzNrVuVmgh+Fftd4tRPfw7itZxccdENf3TAPpPpOdaEVyHEwujEoEf7FU4SgrC43m7Jq+MTS9Od2eVa3hlbEGwfmZl0W3KsRiIu+yN0UIhic33DuW/qiKqBW5Xo5YtXMOvfyAvnXhaTXMgjgCwCMtEQyqNYi1+dtGyizk8AuFNSGCMNOiaGZATQCntSznOOiWLTQ+aQuQTUsquxSn1xeDHWJqax6TMeWjulpyvrt+8P7Q+54gSarzSWL0fVJTsqHFUSLkGKhxloyVkAFUOM6nxdXhCyrtRsgS6qTi9gX9Wj27dv8XZQtx/7ykevXj61z4pT6s2bl7iiG86ZcAiVNbpchYRmLCQtseq/qUpJBSFykFMxVMhbFjLj7Dm60RcsjkRhRCknaRC4SA/tIlUxMRzwmR3hzhGWGY0uaBj9hNQjwdt3RMKSP2GBnVLeQEIloXiRyqYepwlebm2t4GzKRNrbC2+xLqFHvMYCNkm8DUSgSmxJNH/6GhhKZ5PRAUn10bIeS7v+0UcfYonG6OOLRBoPaURIHGTks2QeGKJY8mQGQxhvu1rQJjlfQQLQC8jWER4xKcRIXO44lVDkzcN6MsRp60HWa7FXCBLgkkNOtvB76zQJgOTkEQ8P9sSEPC9sDx2LbgLBlh3OSjfii5y1eYo/cUpIJplc2mQGpLCnCDaQJOdZLoD9FGl8VUQSYwXy1MNVE1Jf1RYCTOXI/IqHHE5VERgMkCcPZJufYIZQmM9GfnWfk7H8SkSSJLaMl1wkyEzofROWBT+Rw4bTabxJQNGbTzOE4jW2eA4tkfgJdZ2r6qjSIMeq1BYbtvLRqM5Je2Rm/Nvf+oPtl897rWObscwEHO1t1+dmHF3G3X/SPNAUs3zGvCan3ALgsIa+UdFUGGLrJB1OoQvUbMUco7qFAZLHGPbUHtkhUpKUQfQGccl7dF8UJv1SGXUrDUc4eny2SFycaQV3DvP/cOpaUTk2ofG/OLtydWcMFuVXhdMJYjkDS1keg9Zx/0hZaJmyBLEBVJGBVxAKiwQwQ7oaP19NiasIGi3adeXExXLUh+GR+WMxjtYBSv1wLl++QlLgZ/X/9Bj8VDRiFIfOASrwkzZCF5exxkE8OWTGsQcb9mCOAupGxcxyTCMFlXg4VYSb8k0MAGLCbLQ4Mc4vneJpcaRIGz8hhJYp10KbvLR7V3fnstrvnTAO5Rw0i9rr9SO7RCfcyrlCt+iSZqAyEzfcOd3TuiLb12Ajt+OT8B2lojIXUZql00meCGHY46vLUMi8P7SqdnAx3hxrDZzutlRZnK01zidmrbNtLC/M8HF1u19++UADEF6xss80Dty9Ct27aHcbC7J7PUxx5rNcWwjkrTtmryXdIdKdN8/393a67a2D3WOHBL5+dbY4X1taWX71en/NTUSzjW5v2LU+qE/56wZHdpeaYdq8tWV5rQ/2Oeq9264dFSSsukYh+gSkKuhN5qTnq0z5aekzOWitZZM1z8ql+CwX8NXASnd+WjsvgWIG1Bn0nP4IQtePbosPCdFIhoU+l19SkmmWbnx667NWD6kIPm6wYYKUYSZ3W5l94rCp12tZ+XHjk5qFHGyRUOZKUwangActwMQqDBjm4L4MOGDOn8wiH4UxqFSQgMSJT5hEAgZJxHsAJGmRHjD4905Ckc8yNwAGsHAypqHBQKYlTfINL3Cxd4mG8w2h4sEfc/wLupLLO9MJDHLahgq0kMBJL8UbgtkhLB4StIjXSMC5gGJQCZZ0luK5Phew5MJOggUqVa83trdfI1TC9cSAMWiBwYYilpJnKBIhADyI73UHrCdgxk4Ll5YUEp/AYF5vTryuGRgZQQVX2QCIydKHStg7KSLqMYghTSUCiU/MBx4UISn7EwkGFdhk28tXP0FikqWA0DZI4UhVenkqra9gxGBA70lx6CQvxRXBbQ0SM2qRJecJedpr4hBmvhlbz3/wve/ub79sH+8d7m3/2McfVGenOsfDCSOKMCvmyohE14OfdsJInPW04sfmbhw6ihVTPAlR/hfu8p3WicOMTiE10DsTxqEHVzy+pKEACSHbcdzKo44HSei1Scyp4wI24cbismWDmgQzQbZPyRpZcwiogGXzcqiutBpSbFyLrvQeVCulwLPhUUtt1XN8B/23718S9kUtVFhMBtNPQ2zeVo4wkInlnXIKrUcDAIOTNamHuiiewJn7pGUZW8xYnHZE+oQoPYm0Y1qvYEwBaZ1DRy+NaUxQVUAORgYmOGw+OeuGf0bxK1bb3DSrEEhOaMAUn3hIssRL0Y+60FEn8PDkxNZuuqCZsSe5vjDD6y3h2Wmfp3RrdUkDs/umSwO0L9QSFcnpmLxgSbX3NgFgS23qMHJY0JFGLnReX306+sipVPIOuTAwSJRXFGjsPzd6dnin5ffjZtBnmNDhacW4fGyc/+VibCAPTn42KB1zz94Io9+M64blfmxMfVF0Cgc26phy0JrptfPWmWzGqpVX+/u7huYffPC+9thOtDu341z+g4Oj3e03VnPJfrd3arH13u6RzQfrt7aO9l4z+eZ4zk87ZmGJLwxR2Tti9KEGsacm3OSCO5EeIk5PosMRLpPw4pgNJSs/ycG4lkA84uMEYRKgZ6SAOSmln68vDCdjvOCbmGw3CK6Y/qiQxug4ID7AHjB+3hBI1MDEgMnioVvb23vsG2CosuJxF2R5gPHkpxIT5lhMohIW8NWTVPzEcGRGqvNoEpBzqqq0i4uxkkEMmAQQkMojgE9aImsgM0bCDAvILxjPTSA/0TxfYfPWO0FUwJN7hgUwxqClDAn5BjM85AOJ8gCDtBhhYgEjnsWBLUqrjJ9Iaa5S5vqLSZURpHVykcCV91tgJRZmAktcakwVzHDKF2CRsllckDFLJgxSQklogDA8HvyomUw/s67fpDUCCSDlkxyCwQMkKUlIMmtQ+QQVrrxF5s9EKyzgEweCT5k8E8JASvpl3kiEnN+28VJBC0AWpA1P11tHIqOZvGGGrd/ZefPxxx9T9+PdXfHwOEuidXCoHWT7lldW1AjL6EbOOidHR5//6IePHnyq7/+TP/5Vq6A6zaPFRtXWF8dXtNvHTn7nktEx4jJy7IGj5J1jETZlLK5IUxzjY+cKlk3kMnaUiYrKBYRtX+UoBeKnDOONbbkcGzoTQoCU+eJ0bEz3tnotMyFWYGo8mMa2Y2SsGx3T/xo1t8ZDoq74I0h9CL0K2kF9WUpiz2qIFk3Qf2L4zGSKRFpJESNRsztYxYDaHiOZstBTEseUKlDtJQ6hyuRZBH5KUipCVHmRpA2Y9SH/yGYvVu8QhYYhhayopYKKh4nMUfEoMlPLfoLECZzKjqXDfwLE6cXF5ibDePYT21Z8ShWwE9F2mqpAlxHSfw2iTQbxwO4utXy+MmPMd3y49+DBF3OxqmeYXVXZIUUn/8iFCXtdRVloLK80d7ah4u4KtJUpLGnAUY/GqTw8VBotQTOoeJY7XmppwZt+wNVJbzhq6e7krIU49uUKWoFjrqbamNTashNKRX052NvX4ajMUNrRk9axcmRLWUmmEAmW2YnXMqvgvOUULWWEigVm5xcDK++dJvLu/TtWUMxMTdy7d6f1oy+tyL8cmX724stabQkGh6bw/5uTmLmo2J8efQXjGJe22qRFCmcmQELe8Gu5BEwSKyNZUEze4uUrq17kt3SC6Y94kX7aduehrPai6pSpnFPQ+iwxscIoPSSAg+niNqEn8iDsKzBlmWAIKzk5VLEAMGqUiXCDubf7+EkKWiMg8QhL640VVPDnjW+fDGCxxB8aa57KWw3UBWPrVQ8caqW5vL2FwStInbj9/eio0hWoUIGWiqiowikFyCG2QD0CpUhwnrLImJDFWzdXhr090MpvEAq7SeOja0aVM+NFKqjFA1tKhtoRgoSqn/gE9tWj8PDjE8YSTL0lfI+05IYHdUxXKZTWVEZpRCWUiplgI1gBLQceDOrff//DzU23H96VMEq0ZAGw4rjh3M/MoNJJy4Vz7BWWg2eY/cRMiktaDOfhECLTK40i9iTRnUzO4Y/C8nAhxyBSDzS0HEKQAuX4oBhvZRYCsLSj8i7ST5AZCT75SQw35eVncp5Op1QtjH3zm990ZIV2SwxBW5sB80LDeIB6DGPRO9M06P3ev/zdB5/9Me/uRx++y7fj4Jfx0YuV5QXNpZKXR/WJs7rwwkE3aT0GF6hDWmCjpR4wODS60A3OPrL+k1LQD1CxUyWIS0aEU+GzCGy4178hPbM1fBe6ijRW78/MXrj/TaH0unRDrkMTy6IvhKTNt4x74HTAEG8WfkDCj5B17jAjGnm36NBentEJk16mwUwVcPqoVDHlO6ZGxNEFEkLFslTMh7G2JoiLc4AyFCdPtD3woCuzYjzKS3WzC8mDh+p8Va2RCh7KonkAww44dqYSB7XqG0WDRCEtVtYBwq1SA6xY1VVDFiUOPyo0B54sX0mCUCzGr+pLLa8s+qTVMcOEE0llzTvGTPOLb3Zaj58+cewHKpBTVMkJRACTagSchENMqMehUtWY4pZHPaiY8J6tGs/pAqX+Y8YjF2QIDHuymfxYJqSMpsbs0HQymFGFObNpY/ty/YvTfhbWnTeysmKw4hQKs8kSQmXtk1RZTLDhn2bz/DAXPNJ+ousrZ6CGnmx4/y3Hyb3l+shqoD0y5qscmuBOZq1LJ44VuXKE1OvtbTNGqXKV2nxpTkzAXNiWDK2nrMG8tvUokBh+yJk05EiAZEhScWS9EwAAUrxHOKyw3BKCAOEKS+yDJ3gufeeSwORtjAAYegBJ4wYvXAhIC4lHvBjAIBWD99raMovslCHiE4PRJI9iJvETmAce4WQ0yxuMALAblpjR1EgK5CRun1RgbxS9fVJ7NZ7gEYLQIzxgFRwTFJu5Q0c9yCEk4KsneUgkGfYJaTGUDFoBYN7oRkNVHsgRFZSEDdIrjcXIpT5zpBMXYJ9ILMWVeYFNvCLEIYQ+QeJJZmBjaiHhjAGgISykQp6KU0KRzCKBZ6eYSGGAOdlAC35hb7JK/WPKIaT3qiJC9EzAV4QAwCBSCcmOVGFZCjPw+yT7agveaDwMyYYwijgRz12SgsKGr4XzaITMB4gBkJEhlhJOSYLLrzcwaIGRQWwQWj6MjpjV2irjubCwLi3EuX7c5S4cDLxhOgc6aEHo8tTY9p/+43/0O7/92x99cPfenfVhp2V7lwmAlcVF56EpHT0LtmZ3b2dpocG7MTEenQ7r3WC2Bl9ryETDSaEmLifNZ7b0v4Yx8FUD7UHEIUg5whVO+AfQdebomGO5RhxEM3LhejEjbJWwqJbiMNOg+z87MdkbNPE8PjnquB6UzREUgQRCKkCYseUw5Bka62c+KWraIgDSm8TYOzyw8mllBKgnTpQp46iiaQOU2u7etqLng4GfkpZ1QRVocUU54SlT+tEAkHNmSukLZB6BCUMr0wKUQtutrLEnef8sruKhyH76qrxkDk7h1IcM0CjKJgxPfLXKtai9cbTpzXbnxHE1PnFJgaQjSodsObG5dXZ3XiFOSx0FBOd4xdLJhvNzeO6AiYEK8x7eFeds6I5QOES2X79xM8Rgv4k3eSEWPGrO1Rq+Jj8VMyOlr81cHJ50+OtiWBD7et0QOX5rc9ONcpOuKXSKZK+/tXV7fW3TdZK96T6va91JLTv7DKklHHRAiZC5ptnIInw+ceJmXJWhYaCoB/tNlYBwtEzKyMCv3WkO+kt239tZKd56UgpvGEr3dEROzQudWyzrOh3r0/px28DpwFZFnWBVlQOoCCfUA2kZ1+UREClMyOJjbFXaYG9rGUTKOzl4hD3iYwAewxYHXDgDqKwV0d8F4VuoddEA8NoM+STBkjwqJwne/Ex4kakoaSiFs/gVp+OpoKIrJG53KxMjiXjllGnlXH0nBWDigQl4fJWTYLEMdcWEepUaJd5PkOCximEneJoViUsVynoSkTyZwklixPEPk2PTYyEdM/0Z6atcJEyUQWkAkqLkAklOEuoky0hnvAC6BigJTOiQKGwDe2E1jU9XFfI1KypRCMCTOfJOPCnDYKkUlbSQ0FW0xMi1gO4VZVXpgLE5SHPRGsUORuLCIzfnqBjb27vIWQOd/KDlXEjMKxSpMiMiwYvUl0fXp2C4yIfhYHaZNtXJ1+zyi6RqAHRU8Y83eLzZCIxJ6yeimSMxti5ZxcTci0y5UUjUhcGk6JKcYs5AxAuVJ/EAk2Wp7GiFEwNiUKczpKrvP3gV5xfpCcrCdJmmUiWCjfHJ/e09Sy3DgTI++uUPvr335vU3vv41m9zbrWNXtVbnXC5IgOfN42NLL2KMVU5rMNI0or+aUPPPzs+61g45fAmcbDKLVI9ZHxm/GO3pl2j8onZgzxtXGEdaUfLkiCRDHgnuD9aAZjrwWJd/aXr20as3xdF/YdAeywOpLvNYbre2/tNUkRlOjYrKq99tmY2NLzCn6KgZASKhdBSNt3IkIjFRDcvsvRoHv0VKTpBnLzGpp5SlBuzuvduhq9Gox4gT9Vp92gBVFqB6WzoxR+Ur/NCSrZ+ZNZEMnOywJ9LaNKt/o1C4BKAlSY7wPL0VCckj4dxsduVQ95OgFDPjA7NH1iJ52Sken84vd3Y6PJ9t9vf8ysGqS8vrzlI17X7S2tva2lTcx4e28sWs26OnT2oz4VSkhzCHKSxdEDMfbo9Km+NOZgHrxVBRIviXU0+qKw6tU5NrbKg43TiJ4UxxqxpiOAHJu1Kp2/Zl6V21MT/ZOl6pza2uLX5lfcNiMIX1ptV2ILCVh3ZuWD7N1T88n2ibV+8My56Q6Dx5nBgonwdHh+YA5m0H6562Trrb2280HN/4xoebGwubq3Gk4Omi3eZXK6urzVZ3dbVyqzV8/uaIsVX+sknICjfO8XcW+dGBZkMu5IWotVIUFiGiSGWQX098KrVbSyZH5ENQUEkl174y+uI9gM1KBDZYSNm3XWcCz0d3FZliGXy9rquxpbHovZRWYkjMawdSEQJG0kNjvDFUOsTwGVhobE+zo6rbSOKWPCgtATzBkMlhkIfClc5QmF0PVCIRQgVOrLAC2h2VHSfKFYxP0Jqg0YKE0C1Y3o61K5pivRIOVRgkRAU5Fx1aeWZ5pIQwFHJRzfIRmYfBRZ5LTgVSTEWm1hdZDm84mdZtAjPGfTCnUZYkchG90clwiGhBJ6bwQLHAeOrVmrfsYEQksCwbJJBWaSUvvYaePiUGtSNqaZlRiEKVEQIBLBVpsAUwmPROVPovmleYUfRVscKmemRexCtfaflVhaFSDaLy2NdepqNlSg2Xo5zvZTsUGTDIAaAorfUhupkgnz175qu8qGYAkEgqJBBFVsyKsCReGSmcMHLqgSQahNKQR/tQyhqAAFol4nq+V8LIr6tZyqVyFjTKYLXe+Dd+4ZcpwNGbXYMYOVJccm3x2Lohzuj5w+9/68vPfrC8WOu0To0GDvd337l7Z9jvOH1NHvWqKk7LNkrr96y4cIRnreKw8WFMBU9XVA7GFLn5xmKYpMsL9Zy950GuWBukULrhXbSwTRNCyDgkB4MDVc9mTQqnsQbPzusMGthbukRc8mOJyJTaZ31ntR57OxFz0LgFSMNOXBFWLFSsszQujJWj4ZtCiEPCUmCRJKnUBGSB8NEtTZQjRacwTBqUhBCwBAZFcosGqXhWBTgKxCggb6weHLwW8AD2SGgAfXjY4iYSUgQi5QsApwWHHfyY91MhY0DZ0VWNzXAwNEkV6z66WR9jl0QUZSwSjbkBkLDhFnv4h9xXeNzMIMYnB8fSIjPMVQ6uC918w/bw+5aiD1v2+PFDqWTl+bOXf+HP/8r+66dWBnCs1cohP8O+aeEYiCDE/by6smwWxaQ6Es7bcT4zNhyl7iwXQmBw4/DV6MahHjUx5cOSIoeZ4G16wnFNrCKiywvLzn7IJbl34wr1znZcQRxHQGPeMeCqZVdrXfqFChCGOWd6j88axrx5vXP/nbtcRe/cu3++db68uKIonjx6wqTRTOeOWIe2+cFdXfyDvbOXr9/YIo4fGBTE5vyiTYXGnfxFRweHTFYcBcGpNXDfgKPTNW6Xhzs75fij8ElgBueKzFE36rX6JcaWaJnSKZTHQdmpA4Yp5SdESJhG0RbvsZnKjAPMrVqeqRC8/pPbeidmp52meWZNMcEpfvaKkbXT0vGK3E68asqfg8/pV7ScN1AfBnlDJ55kxaktVQd0nJ1jHGbC6VrzddPo9k/r+6gGVN8i47lKVbVhLzO7sWYuZsOuWHAsplrLAF1noRgKHRRfZRVOZQxAHpy9NVedu3v/rq5KGAjndBf/u10RXLFOGXSEvWXddlXYX6cUMcFPE2Nlq/RG7Gbqkjt7pwPij0CVvc6sgs+l90gYDMg0lnZ2jgmR6SQn0oitnBaO2I09OWXwpzvZjsundOdM/V864T3CE1NslpmcxeUVGWcWwzNaWi91m6lg8cMzGxY1xtph/afirEFOWGGEcCXL2MWkrJU+uHaRk8BAhKGwnmHc/lJ2XzdtY3NNwVMCvV1GOPdkqjCGz1ARo0/qsLwAVkboGq+Il0l5J21HfSzMN1zUc3RwrN3SqdZU6+xV5yo0O1q3qxFhPg5HuFhsgJzqh3kDCMcARIy1Hx1S1Tpa0j6mZ8v0+YtAqXhclfa4h61yUVHp1fpghpTZs9nRe31js+uImE6X5h+3Dq24cIg5u2AHzte/8adcvzpXafizYEN32/JVA6Rb68vj0yOtnWff/cPfefbld/qt7X7nwKk+JECWBgez9WrPUr4rZ97FTQ+V6THr1104dXbaxZWKR+yaGw2Bwz2dqW9UbpUEodlESvhmDu0yoV0E1en3mKlOv6O4TGBaq2v21OYvmn9xqePm+GmD+GHP4Qj9lg0oWlZKMlepOBz0xBYKmw96XfbRXLc+p0IX9lhaQ/fo9tLKKl0qPvIJZ1qwGiqU7qmONIbc6Ke8KI9iWtCp4gx0bDj7pSTcTlOdNRjg/2T+mDMFqr8V03uxhFwTGwNTLb4NBEVP1Gs9DN2uU91wh2ILEJFlKsyM5BSVVrAGStxujFgnr+piziDWCQnjzj8wFojdy3RAcWsXlbLtOhtrq3E9hs23szMsSa9jrcGBjo62LeYJHD3ARMgP5SmVhT/H8JGOUxv+yGq9srGxBqEH6cqsPXSxtEb1cdYy7X/y5AmK8mikYB0Rq6EAnMVNmyFkfShkZHySZvaczuwuTybKZSqnvbbegNkfO34JTfNgdwlfuhpRcmog2zb+r87O2Klz/95762u3Xj5/8Ud/9EeaIs0eMbY6g4PDJmdr26yS1cTauDP7K4eOTcVe7OGqzLt8wKVtcSDxxeXO9utbt5a/9tX3f+kXfmZjtWbUR+kW61Wtl5lLmlmtzauNNZWtPleZmx7220ZZlieUiRanUHQrNfdBVHjDWNsYgJyeLa2v4laXlD5Y9WpYFtsteAjCSLASFH4sSqaMIG28UFaMCVunW0lLBGiCEwyNYJSxnmkMzVIEcsIsSpk/yUYgGw21VI9bYfuKvCTCQbC4wJhjxoVBiYRX/F+xCFIgtMWyZZXw7b4wARj0NGEo5kwLEi51ZWYimxsqiv2t80cxo86yl/FAnAOMkOTRj7g++JAVCI+NrefUHU7VA3uIYp7asHfeiwtLw9mhPUTqG3hfAYvPDCKNB2nTlmECBpFQoZ4IQfIL841YfSDMSQcGPGxg8CNSIwe/kwCcYQUbgNBbWqO3WAYWJFas/PWMN+EbQ6nzMgVJTG4X/4NsSgJzIqFY4oWl1XU2lYJcksYkITNMRIQBYD7p7igsCNW6QT/caLDhBLXMPlSyny0o9qyfUVhkIgko8ZJbDmOoAZIAfZWQhBECgJAAMElunswXtBhIJREjAAAD3nhTH/Qk4JQ1kQBERnxp9WGWHUlevHihL6MCw0b4VjotraxNzYQ/gcO9Um/wlRLxs2cvVleWzIjZ+Gme8sH3vv/o8+93Tvbma8YNo8OJuD1DRlxrYkX5q5evb22uzc1M7G6/mlfPJkcP9/aYJHUUVvUQaefp6HzwiNJz7a6R07MXz/G5urGOH1nG6uLyEjlQfL4yddiNKzrO+Ne9oRG2ETnHx09ejpD5gCGvyojtwXp1DBO1gISZqMzG6JZp/v+Y+tMmS29kT+yMfT0RJ/YlVzJJFllVtyR1j9qszWQa6zHTmM2beTsfbl6MvoFkkkySaWlJLZM0uupq3ap7q4pVZJFJ5hL7iXNO7Hvo94dnZt+HkQ9x8AAOh8PhcDgcgCkOzSCUNwDbSHt9NXGffmwWr75K96AYAmopsz2TR3qoSF/JDh5PfN4l0FjQrkbBP0Ydby2lo8HEtEB2qwKyiFQd2fEXWc9rWTdECvSHuLamDAAovZTUoim7Fpr1Bg4Q82hidaxIKWX0FIbOzBBmn8gOh/ZIAKbE8e1pcJQjBvxcsXJ7TWxB2yhLmXK8KtWE7LOTzto1BIoIvFGRSK1tpHBQHzOgCnKfleDwYF+azfUcsygBS5plD+0o0kQMA6CLmcHsytIV08342MqyNds5zQ2BOU6o7ZZAiFndpmLPz0051YT+tbZCyHJjTbnOCFU7Ze3v7rmihjYA5+wZPh1oGwXhbkTmicqBhc5MNBs652c7aPX8+TO33R0evHv/bndjbenJhlurjS8Tzg/TmqTG/v6hO94sFTiV2k5jx0vsH/Y1hPnE3t4+FRbnUDQd0zDP79fBlCyZw1NyOT1HsRwcrsIwaiol4hfDqBGUpEBbNdWPvKEqpbBK4QFZyC8dkjNQFk0bxPRGbeal56qzDABJqtVRTdibHUxqZShMLtTB5RoVArQ9Ek0Z+Xl7G4lJsJr0Ody6dXUQJCCwIKTaiqAfme0e9RhAAlC8NGqiHMgU9yhCGA5VJcn8lN67KobRgVIWVKUxd/FJGA74WxqfYCVGGPL+AEnpH6dRST8+ZXstcreVgjS5ciUwYGbK0GyOcqVGTfQLeFATWNmVJbFAYZtls5z6ki0IpXcXbtJLVmnEQFUd4SYZsFUpXws4aEgByKcsOrb0vvqkdTxq5C0vWw2iQZWjN/aSSzJo6w/kl+ooTkGVxU9+U+JlL+DCIKOkEpUCn8JB+N27d6pgvi8sUvOpBThVXzFKF5ZFoZBXkIoUVr4C6IEwBZCGokTJPLjQA2czC1tvxShCMlkAAc2nT8sSz54+/c2vfskrLSu9I3d2c807vWF20gT0v/sv//P/+P/3//3Ld9+S9eqrxQExcXHAOoRRuPZdM5cwqhJ20sBQfSUrsqOGKlRFoEFi+ikvEqmXyuJwAfMbyqZLAZ1fpnZpyqzafugFYoAFqjg5u4Dbeqm3T1xHqjcCq16B9lFLyFcz62bn0bvMugCBG8iKQKIFm8w5MlzfvH+/Q5JSXa0ha24NUQs2IMDQo32BVZAiBLCByGKqqixOAVCMr4isXZRYXaP4SmRRA5WkkUsa2IqvLGKKZ+qn+Kq4n0VDCTxqXSYEmBQ/ACuxT4rzQNJPU2rcHf5o2pKUEjiPu/hHQcAauoAC3LqXoa6II4FBmjBBN1+BEg8mtKUU8AkoELwBgQ/GQC7vDKVNeiAFTMBRwQz8H7ccgVYl2nJGf5VGAv1IAhgyPwKLXMoyHSRFjRF+QsCk3ITD4M4714E/CjKXYoV79nT71RefWeNlvFVodTTCGwxZYIXT8JXZs2krzPUkO0k96ksHCoWn4qkFAV8hI6BcJjONk+OsxqI6F7lUH01kgY+3siQWKYGASNRA8/QCn1VVrEessHRqyFTi7SfaCSQcD8UYjoVpdBILy0Vz8gYLp0qsDDMvaQTMoDGoOhCFQEkgi4AY5bqWQd0gKlKTfP7ZpjdrU0EDisQRRnQJCrfqSCIFKhKePvkpUqFFF0XLjgOkKW7Qlj6peehOU2gVkVFKjx5CUmNTCaAnxht/tOwz5qQ6JwioDxqEIUZrU4XKoixhtZM9CLQlE5FgFpV8NaWqsLc0HhH15p+pRUOx27gGtY8fXoWMpoJJPcYCVZAY+JY9DQS3wvxTTxMJT/MKhEMZX326uc16YNGK7BODEX0VwN8qpTgpiRVvOEPVW3FqjZiyYNOCrKVSqTbwyOWR2AMl1PO2GAhh8dJ7ClVwqqdb16jqiK8A+MVd0nhAxjlisDjdg+nWECl+tbt4cz6k/W0/f9ZdWbwaHI1Pd/72f/yX/+O//G/++b//f8NiZ733TA7znUVg3QdCvQ1lHtrNGu5pMzDcXrvTca7bYcxtDZr1cGWpDmw1IhLhT2RxNSY5i1xqzdECSrD1E1bnJ0OgYo7FVPZROrWLFhWbhoVSVTP+TTEDAcITjD6tCJeAd6zWzEXM0xD4XVGVcAE9mR3EuOFwOcoG4AQH5NNSTcuBFdyi8GY4H3MsGkwobKnX+JiVKc33j9kbL2kpDoXGCRUECoTiAZafn37OfZ8iDVIxxzqh6OHOEKuNJFOo1le4ElVNSpacar6KEfmplcX4BJS3SG8YOrVJWUBBz+QGbhJICUOloLNP2tFPkbq/GRWY0iSXCZShNNBSfWfj5H7WMYI1nmwiJ1F8JM4IdBTZ2V+0wvJSV9G7798hHVmBOJpPLQpVXM8abJonIL/me/8+l427JKbDlaezfDxw3GQc3ZVoduXeBN0e22oyjyk52+b73fcK4scPPSRl9RJQNRqOxSGlE9a0WEXLoiI+YTzWFIHWjQx4068+e/nuzc9TC9POmk4rX9FQc+wfIjhFSsZJVsQcHNm56J+b3JC7Gt3qDX1PvVRHQXwfdMej/V0b+RVkwJmPipAx0k9W3Ytren0IDsOSSAjup65OtoRnGjNogmqyNJ6cHgH93cv8LdbepkqrEpLVUEnougnTxQ1OdymhLIunVF4DF/sv0ktsukstMhvQ5Dw6WFfA8fhE0MiiOU3iUAdZiyegu7m9pbMrzhhkkoUQOj+8iHg+/XRwnUor+iQsnuVOAgBVRi5gcZWKKAg03UxkCSNYSyayWI1eqnZFiMYlzK3RtuQVD0n2yZgo3S59eSGeWo+UgKsRawnkQRbjrdn8RF8Z/VT9aqfS/RUhnqrpDwJVKD77RH0ZQaA3FChU9an6BjQgDEIBkdcjBpISENbCITU0bpgMMjmTALPq/z5RGSjWkAdTKRq+EtBHhEVKXKCKerBSkE8oJhc4KiJB63jp2xLIq1wdQKHBZnSUHgQHASk9IEjmgYAaifHWHN7AFvyoAoyVRGVsxKZaDoXOlWH+HNtpU27v6NAegoydhNxIphqYhGJjFWFrY90JisNBb3tzZeT+irTnnPKv/sv/9H/+H/7br7/87OK0d7j7nqoAgYytj3eMv8rFljABZH11ORaAlSUnm0JJ1dQXmjjKLhrtzTziIg7ci54WZiIVbh1n4vim+bXlJcOlmS2HUVYa3VLfy+ldD6PODgINkQ3p6hmTQbO9pmiNc2M11dxmjLVaDE1Tf9aAiq4H/autfcVvtb7CZwcLIiywhAXKO1vfioi5qW2i21tPrRr5I7nQR6PIi85q5Kew+nrLixSAFKuI1Hb6guJIfz9h6hMOhEnwb54X4iUAzU/1kgAEzyc+xAw+hchNlFTjSo/BIFDVkcYDVEUaQcGvEgu+5oCMxPCUBrRUoVkaYCWvIjzqThKwk1jCQF7HcojQ8QHRwX0Fx6NHiLTCB6bIbBC7vjVnAhkoeCpIHdV9dWPdmoIEFu080hsEfVJ6MB9PP4WAokNAs/PLC4tDlqYODo5wlo6T6RR3uPNc6aEsmDM6GTF9Ctu7/L3dFpXaTU+gYJQX3MjaPjk+GB65QG2h2/GpVTcrUoYKPcYwAB+YAKhiZCDkzR+fbD+zrztD6eUN939YSaAiWIPi3zwPo5SrI5xLGIad2qliqOTRe30GWRoIkw+AeHjJGGb+7dRV/YGWyDckqCYPGZjj20WmEPIVQbVlJQNdQEYIKUAWBfgq4K0+voopUOCAX/yEXfA0q4I3vMGR3aheirD0rdgPPqBVVmWUUnESyOVdrSuyaCdQZSlIETICiL8llrJw01t8lUwd5RKGvJR6jmQSw9wjgbdhjDjAGFV3fQ9xj47Se+EjvTRVKIT9RFMF+QTspweoSukNKwnEeFcAKEBkUa+KhCeY3sryCRyfPFWivJpZPOQlkx3+Pon3U0WK7AIy+koNVCmV1UkgIIACHgynOKAIccALf+/qMz7JJb5wg7Ys8koPMjiAKw6vC0hTkMVUoTJKVil9qvr6Cqy3GJ8KfyWK9C6hA75yCze8AWfTYUJTvOHh85cvbtRj6Jq/wePF8PHq9L/7r/7z3/7t/7rU4a4x4pzncu/ksNRmP5eq72pWKyJGDp4/xFPpKLzBD/cPFKRcmKiFlOpYGIrHDGIM58pdWV5WHZ9oM9Ui1TQiy7SiIpQVEkZDaVvNgheyDhTj6ge56QZp32kLliUcQWoQMag47qlaLfyrEzSyEKRQKj5RXBFHo1QTR9w7GMONlRZ4+n09SK8hAasiiA8gfAhcRBapLr7KBUKRHVqUOAM8ZRp81ZReGnmlVy5q4CiRfkr86ZHA42dhIiwAVY9CPX6K1GTKwi2o/akWCgJNDJJWSgjIqHzxaCsjlYDUKxoS2rCd5ysTB830KYStoinFZCsMZYE8ONgSBGGJWYok9VPTBP5EeocEvmojg4jDZXPvbvMr6feHb3feS6xB5WJMR64UNeISzQ86pVLgrBRVMKGMz0szMxSDmWfAPv4DkavzOmoryAKewdvBBPx5zhGV+j/fmT49629tueNlml3o4GCPVMEdSochaJqs3McRTZeMTeLuHiejA2yVLsxkgmLDkzNUQmwuJqhnDgFl/Z9eBQccK7EHnb01infRSpuCVp+SsU28si07Ddn6MBDUf+DQmv4lgxHGCCeAqa3Tck3h6iA9LOUvWhgeWEVbjCk20/BNlhMsSztNt9d3OXahohmUCpTs8jq8AVkFvMFhF2Ol1QCKFpkSm7zw0wNpkRAT8FaW7geggK/eikBEMS15xqeKREfkAwrzIU3FC4APjp/AKt1PvW99fY24hJ5WrBgBrIysEGOpNHPkfmBdk0WId47i9BZACltspBRgVZ9qC07G3iYClIKeIe/HSkkGZ281us4W8zSMzuMNjkKBrQccje2fvCqlk9hdomiJaWBwkyXqRgwR0QFberfKLUG+mpmqoizdkrG0SFSl11dlgSAszd7eMeUaBJFiYAIHYAs9ENQUhdW6yBLbyMdFJ2mEC+dAa4pjqNEsh4B4lI7a0ngLI0BjvQyisoAsoHWqTSWrSGJubWXZDU2OfX/2ZNMGnd/9m98eHey6ot1gsLWxMjc1Pjw5dufX0oKN+5FBEPPWs/iusLyjz5zVgpFHghiehIjOyQCgH+aycheDMb2qcltUJOEKk9Si9SKriJDHqA7zpK7Ptz2oqubg0LPzHIjvGls/PfAnOZ0ip9fQiGwMo4pdXZ5bELPVk0JkgwFGZtvVK91Qpl+FI7BhDv3NSH/F3mhDcjOrohKYbAvWJDlwaCaLvjn85+HeEdCkwNLqmpPz1RSqqgBtD5ZQR1iJxwPkCyASeHwl14FtCdOOdAwJVFNzQL6UsApXo8vrq0c7iqmwt7CnmlIaAchjGDwuJT4JqzS+VZywxOCjIUr6KSUW1TdJGmHeRHIBAhQ4hbAYteBK5Lackewx1kM3T/vvxBO5GpElWpiMWugsnp6dLHWXnPurNasTuZ6TA950NOC0i0fRhDsHJMNtDlHKaLc4OpKbmtDKV0Yhe63ZPtCHpqbXdx6XYEWM7O0dOGnj17/+dX/79D/7T/4Li/oUCzsVzoZnqCH94PSExVsYKBU0yyTiCeTzi7PsNHR8+qC/srzkFB96pE1qGoFyI+XB0dH20+ebm+uuIHZD2fXtsXKl1y79k1OmhoU5c/oR5wW51mJtdePBoHJxpqcpFFU1ljciO/7WsW+MN4ac+gQZjU6L9K6pdijQBFSpqhJErNQDFT1cChXGN9KBBa7+k/ytJ8DMV+l9RWWPTyIhIS+koSJSoNpYW0rgq1w+ASIj5LyJ2mpp2RVKfEsgF+AS+FRw/PQVEFmESQfJxPjqXTE+FWRvKZWuOOQTAEcVMLpPEkMSBPHCIIRqzYbjjR2NQD6BAIFKrI8VJlJ6FE2Z2tzcEJYGttCWQAB8JUIJMh4pwQFEADK+emTx+OqTSE8BRG1MU2qvbqwIyYDySCm9nxArmGIkrt6uCopWqfrkpwdu1RYkGlCwstJe5QLY6w2EPdD2yQOaZEpHgfV1h9Od+QQ3cKT306DuJ8gS+0S+qJfbtrGvSmlcGEJPuCouF/S8fSrKqKBHgiIIbD0+fXqklF7TkNQKovKrJqxs6294zoH89S9e8dk/Pxv87//Lv/qf/of/5s1P33Vmxz57vjU/Y3Pc1bB3yP3EWTHwJf21i1qDwJDCWdIGYL3LoVr2WRHHlF/w9/d3YSUNUaJQ9vEXL14Y49GhmMRXWKEMsWUQhQNBoBa4BVYeaEfNn5g87g8uLo0isYFYEgM89quM2+N0o+zgZN5+uHNW5dMnW85mY6HiXcM1QrnlpI/CcmlvudDZT6Wgj5bCvR7IZB+EXVJsfe18BasQ2EsyQDKetUNWZFd3eEJPS1UVNDHKt2Yfp11aTDm/OBWjxYrrVMqjlEqmXvJCo3qlisPHI00FvKX01E+tCXlhhcJZMsxTD9zId2gACGxbYOCzb1fUrkiJURjOKlWlNJLyCXb7xSJt1+nZwNbRdVRGkloC8JUIvoyyFw6y41XNpJq4iOnGV80BMTiYxyuU3mZOALiDQxrv0f2jEnlQDJ5AaXq8yJrlJ+DEVKEKf1nof1LiEG9PU7zY6Dt8NDUEOdRWdMPJIFBQLPla0fGJmDECGu1qcQJJIGwqgBVXVpbBoUaTW/60SHhrIlYHbaqaaqSIxioAR3nlvmnfsnhawwfKj08gpQWYJvzSeVFJlmoyWSRThRQ6iJHQJ80X4kuhmR2JdX0ZjU+RJBU5bCnT0IrQiKglyDFh2cBSG5lBMftgNUM1kWJAd5zFxekZgGLyE1Hu7mnEBhzeF1lpyTaBe8d2mxkcHve4VK+sr/F1pdG8290Bqtq1OAmQqkMI0szoiKIhU/P25CunVa79PF0JazPKOF7w4jIi3TgleG/XqXonEjCiSUCbQmiznJC7OSbposwCMUDfXL99/86iH0srb1E2R2FspIfXzBQX2g5WdFAv1MABICsOK8NE9wzR4aazIWLrUWqESnR/VYAyKkmpLpUF5xGjaC6y+omq1adUrWkTsgiIV5xPisboSm+RBuAPe3Mk0CJYA6+jv2S0OUCkdMY6NKRHz6WlBTFoqO09YorgZK5I+PzTf/pP9RzxHkUDi9uRvdBQBDjAPnmyqjNIX7NUMdgLesUMRIkYcLylb2Ixlg1AyL7aqoYgPnkozYQgOg2H8eMigr0hw6VcepXVQA7jWeC7OT5ytPf+D7//LbnvjxjfWFm8uTgb9g7W15bMD+zmw2wwMQZ89913VCcyHf1tbckeminbkWKQRGqYqz6SkgWEgodw0YLopuhI2jaNoKxR5SzYYncOG7t77/P9ZAgx5KVsVR0RHKF0TmRUujBoiCaT+8WcOudgoPVVGOoCHI5Htjc3V1yV0Jn31Z5OCgOAcJARlfrHA1ukeKbaznM8GO4fHXIvNhOXAObFSIzOxQ8ij/tHziOzYsGGkIXR8ZGDwz0JrXZgTGKcqCR6SGlE1j/haRhgg4K81m9nhbL/WGnL1sXCJLwRv/s8sPIT28DNW5tKI4ySIAhLoMWlJLxECqi7N2JKLFJ28ZFes7Noqxbg+Iq8BD2/SRZ87JYF2zYPBhYEKeFDucMDr18f24JaaGgapUtJfOuboOFVAJUICFnpaGVpDNvFruJl1OIGYba5xaVl5OXeub6xxYxGcICGRdUCEBKZ+6nEDvNRBM9sOx9cUsb9VDKRIBtuJeDOEONPZ54jqVYwXpKY5hWAoEbVF2JMM86n6h/1qLQOq0B5nAOUOkqmNdVRA1nchSdGsnRueWxpedG5CZi5WhytFJGZyuUF1pQSbh6UUccFm92uLo3OVs6ALfKmIRjM2yRSSj+Vy0VhY3VZWC5FQzUDgP954xWZi8TaSSSKeBTmqXBFyolv1A0VqiUUIKOCYVnhwkNnlrHKSwM0XimJo4iCifQSKEJeixqAQw6VvQFEHW/QJPCulAIFVunK1dFAlh6ZxJCnnpps+oqkImEOgmSIKKB0kaA16scc4eHfXcojoaxQFZRSArxoiJYYNBkFqABFhKqCGtUDMbXwSbzEihMGxAO+dyl3JS92dvZAkz62xft7tFIFuZQIN2SRF4tI4CvFAW76PIHrK2gi1VdBaiReDITlVYpPnnBkY31Hp6l+1RfmnxpRXgkUKqNHAvizxamsnygggRjp1U6LaFnpCzFfFeGrn4rGiNCAIfzBgTmwEhTZ6y3eo8py+QQUgGpXP0HwyaOPqaxPIIBjy649tvYTsf4bBg7233XmZ9aXO3fX50sdC7ZnrEBujuXabSpEkupLcNPNntC1lxab5c09SrYyzWUHrwXw+exrU0G04ufDvgR/ih4koafuUPJVo2smfcYDW/GQ+fqrX0TEt8PMc+yE9KYVp2dkgaPwDSCohBORS14j1tKiBT96vyVuU5Gc5X57cxVj7a3rN6hUd8Qywa1oPYC9mMgjbhTkwWZIlPdDjvcqauMHfIJKYpRlodtBOmglo8Qwl7FUSO2iFmirEeGpCJ/0CxXxaC6RYIosXpJXWcIeAfESYDC6ByCKUKniB/EexYGvuTWTBL56i/QUJb3rqfQFVhr4e2sjXwGsPot5/JSXvz/S2bNv8df42ukuWQWz+spt0OZbEnbNcs7MjK6qyRABYsVyAjKKodQUnoe9ngVkZhn7WH1yJByPSYmVCBnDGzQwqeHH2oD6elQccRBTK6MVzIHCmfWVAdTswTC7vNJFAGgYCUJDK1AO9Ih8+kAoGdGf4LNrFJX0REOdY8xNHJjcQWZ6glElQ0ATKPQnstQVIQ1Cc9NTmIdupKU0qAas5QcVVK7hXy3UBQ/DDRwahD3C9BthtdAcHsgLw1BKuFVka6JM6XxNs+r1EPAbIGnCNM2m71BWn+WvFhUgfS0c2BOOR0XePNgK+2EipvEsKTnGCv3V1kq9ri2L4Z1Q8FXZfhZCsNEAXLKqUGHQlKs4uFKoc2wuzh8ZE6DLy8jLFZCo285Pan5E4jlj0c40GKckck1H9Uky0ESicurSbtUoUSLsE7pDQ0C7goyCfqo75xSI5WlKfbY4hr9vKU+Q1zZaCNuhPmiNgTLnBQfO3oCDloD+TWcfH4nzSXy2ZoZXAxAk1mNxjDdbkzMVck67I6VcWtrmntgOBJhAQWJFqB0kSUPG1Ro59BMFEei+2i2laNUxNcHPMEQB/IEChlHeBSnxbKCCELY4BgfTQwDtI7ObFASgPMjugbn0AGLcT/FQhRKAsIKksQGFVUFBmlUY6Uo+SiYXCOCADE7zJIzoEe9rJYADsojMNutQCvlyAxpQ9pDu7Ow+LkUoENCY0Ce29OmZucPDE7eDM+3QZzZX5zdWFliEyVBb5B31s7gwh40ZdvQuBp4jd4Ka27HsMsNnekonyhZ/YslRMy7+pIBnTtZkIuJYI8BtdtVqNejDBP7y5pDZtt0BYSnLSLG8FA+rNs2fI32qvt7M6DRz3nPUSY4o5qJWGhkPwTk9O52Z7pDxpiacWaidozOkTO4fZUxhmNIm0RlJismpcxNZqy8m3I0/TcKpq06jrqUj+i+ADhqEuW7IgmSnFd0Jehodk8BW08KQaMBX4vWCGgxEaj4tC20amqrDQZuS1boqxhMGRK0po2mqtu4ae08Oa5vD1yU0cYLSkUh6ZWlrgWpfYU9yNqEDVCjMivDREIHHdChwJIAJfgYNP0MyCvVFHO3txSaX9dyDo+ORzKVjzOGtagQwDFHVeWcNB0bo2ScvNyHw8+vXEpPyLGN2TjADxIyCPo6VXujSDBV6PXar+tA4PTocsWnSGU3kNY/66cwFOYDB6uj4yBxLYnDU6B7DYHintj3cO+fj4uZCtSlecHYwA87ni2VngBkhymTb1+yiBLgIMWn8EJPm/uFyduaLV58/u73LeGOOx3/M5IyGjzg4XM/A4z6NT0RtJwcWF9cc42+GOfI4bV+xk0ff/LwDK3Tw+vH1DxZsSaEVh1Hvvb8bPYe5TYZ2WQvEdwCVmlKFsFmJavoryIiiI+iS6usnaVDtGHKS+H6QOLqEYsyBkM8jteasPLKZVprmiJHfVwFv1ZBBjOL9hJk36JgvNWzmY++0QRPxlVgCkcGjmctFSixB4QQIqkySCe0R76k0QaONIlWiQmXRTgCKoURT+vyUGCnhENZpCpGUgFRKGIIDAWzt8ROQEnmO3ayC8KgKKkv2EIGZazLmUSl1EmyKLMSBU8KlL1J8Iq6f0vgpma9F8SKCHggH4hInGUgqDThwYyBWlpjqhHLBWQfWPTCTXDhY6eBAWKRPqPrll1/i/j/96U8qIiOXlqqvoqu7AghtXxlPrRp0u4uyA6gXg1bICyhORm+PLOgJVV8lVmLRzU/7iphDpCFEpCniKEgC2GoCOMjikT0EbIwLvgfYIpTsTORoK72UVZy6eNSLv4/E5NHW1hNfU/f7ibPrM4JobZWJdnpjvfvi2Vb/aG94deIi7Uuux2eDQG6b4FPoxAQFkzLOU9NPj6rqbCcufDag3N2sryxrFicoWA9//eNft55sz7t/6pKRc/LMKPp4b45craBekEE9qNYsoXiAfy0bMPsRrUSXttarn6ADpcUdVaur01lBtDfn8cHIxOuDOdqywP0oq2MOybFpgNBhwCUNTC8ZMW7u+ieu7LC3LaeJxKwBbRS2vIewSMRimU5zFw0JWULntk7gElurdEQ8LvIJV0AYq8A8DHB5pSH4jQAggRjyK8uP+zvAaghsryvL4pPsIgE3smh0khwQp/048sXdAJpLAnSAGGiyeEvgp0jZtRSuwxLRutqVGMVd1cqVEtrSeyuonaw1B4iM0KBuNwRoqldGDMe8Y/zQKZtXbeie0nY5QLVW+BrCMtJp8IxKKUsFuc8CPjOXm4tMyxp/Prz5+e3D/YSBvXWE+bjJu1mlLVdIUGhr4h9/eiNMW0UBSNo5585V3lJq6ufzZy8dJEymB8m7O6JGjZR7cZkr1RBZvNFYZYUhY3B8HLnbXFs3mzk8OOrMT1piXonhJeISbW1yNh1Uri6JCOQVXUVLHfWGyMNkZ9bGV4yp/IsvPj87v7JV2HqV2i115y9OBhQ01XG8xvXFqW5kK4GdkGS/f/jEYBHl+aOURjQo+amZvIuGAqrm7ZkwR1ZJeHg4A+lCAihrfBBvmMIJKkz4yayG0pJZcqpw4kkQR7S0AV+DyYscpsLi7fccHOc8mT6ytfEHwKRv66V2LYOD27RE8DBm3GXuZs05ErHB8bMQ1WZisDgIJLtcVH4UIUklwFIooiewhADljSGgV3JTKa2FPjggwQfPyesNE5+sHNh1PT4RK2fVSL9TBI9dqgLu1OczI6GeWwvJ/VAZZnRhOIuEkkdAid4mibIKoEZ+NtmHbqoggWaAW+t7MM08URrKiK9KVynsa5CwgKlSaqSI1g0CEKGkef7sBa7qHUuzoabwV03sSMoLgAl+Fa2OSocM4Cad3o54ARkHA65eEkgsDb70FSgYQqlaREb1EgmmgJN+lF50QyVlSSBxUUwWn6ABstJVU2I4A+sRqEekr2LkVbWUqK80DxZFyAUC+5tpL2hmNvQa26uePt0ktd2Y6hzh/vEBU8rG6qouxORJBL/d2eUrvbG64lTUta3N+NFb18n5OeEZGw7YWKDjQBsqwurKcs/5W1x6lpbO1tchT+XEPIqGGJ63iLW1tYL/c7BPxJzuEHEppXbROkQCKjE0M/5qdj8xk7KqOs7Q4WGSG0LKOhpX0RWza9AMFWdtQqUDGfdz5uMY90En+xiBrkh6PVEp9kUgDkd1y1X+nA9KeTTnZmbDRZEOYw42dwHarfQG2ZNz61IZqJRYbQETMWauGhdiwuiMYzVWBNZcVA1zJmHx0qC8JgZByhJkUU7bSHN6dr2yxJIOo3CRSA1dD7EFprJCw6ZsVpVrO7d4YD1gIpdAsQpSt8isGsrop7Kys2c8m7fdk6AjSYkN+ETJi0vPhgPbchwmBmG5FmZjf+bBaez45ptvICawtrbBOuMhq3COBEHVPOwMZXPwRhR/5/awnLTFDCefcOS3yuF8aNWBRhC+u7Usc37rxLOFx/Ox4fk98bJib83aKshKkdKBFOQI4GYtI33GZ5t+GVrHTT0jUdsqBarmlLOm+EqwtbF6dLi/ML9gHdRS8Hy7ZNtUILOWuVmGqYPbI12BmgoHm6Y4Cju3cGHRqn5ncnr+8KgPlCazxZ1brOOtuAA9Rubl8DFZYGUIwqXC1I7EN11Z6yA1VCn38NfRmvzP2GA1QjIBTZP2Q2h5lCGqsmELt0LKL8XUqH4RlS3hTBWzsO6TSBkrCyRUVRgc7WQ5jbAmI3hh61cgm3qB7Ks0HtkxHCR0PPESpFz3v1lepge1MUka8dIALqOfOEMy5YJQIhWeeEXRpIYhGjfgQmpIKdry+gTJ6uEgQEkyeQERmUJZn27uiNoMoq2fh43a5YK6mTAcNIAs0kgvRhgCxi+f0AT8CqRiMW40mB+VLFlEKkXVwIfAmzfvP//8hbpAL7zirruDXd4LqukQQT8xfQRNexBciQYsY4Owwc9WeLT98svPVe1f/+t/rSKqXCvJcgjv7J69eB4bNMrT1gUgDENoQEbe16/fMAmIkR5iFY904Af/j6ZD8H1VwSIXOD/++KYmQxLDUEqf1EIuFZFSibJAWGWza6np+ApSrq+eipGmYiAgMX3ZI0a8hjOqoRIIGGlpuXN4dHx3M7Ywv/Wb3/x62GOFevt0Y/X9uzdc6s2BHHTwlAZwf4MyNvgcWWpzzo2NWpohFi+M3U6unWK1xKsPuiLkT2IaGRgNmF/CIVeXDFBKJ67MdEkifOWEH4/xGs4KgipxACUmqb3DAyrCNdztELw1nYV7DgEF+eacvqxP2VwSiYw4w35fwerO96Yz55jodpDvJS8pxwV2HCwT69DsnBHPXB2tuHdwxaP160y0OdqRqQv4BARUIROiNWFHqKE/NkY9ZGQFQrpwcmtozNZInlU9KIn0gBBniPbIpYL1FXzZRRMm+FC5soPPAgQhGbU+8giIl0W9qjX9hIOvPiEa+rBdSCBejCxqpCBvvTKkbqIGnlJKo6HZivUFA6lyV5xVp3a3D0xqFlk5UdW9NLb7SWP4ln73/Xenp1+6Ph4oaIODVWDOTKcgNNeCJtn4AYbUnf29ASudBqB3E7uy4HP44DRCfNCPW5HOBb2T/mC6M3c47F/dH45OuYH5xmRQPOCdqQ5Rh6LnQ+NWGFUkIIpACnUtahhpHJHtOEUsYYhaWV1YWmCY7B6HYW7vH2+xkJUeJyCpCCqpgkfVrB0ZCSzNOIlRgzpcVTzHVsd92Be5tLyCqhqE0oMIN9OTBztv1RqHqg7LAlvq7fUl/QHN8Zr2L8p7e4pdYsVp0gxkbQwfSTXBByGuPurgBByf1VPvkTMxTYmTWjwTf4GoeAnSe/9R3yYUKBwcTyhdFBBaYr/fawRiEs+eTxkVhOLqPDeOTBEuYYscthSamtM/jt+zhwKOvj7JLl7pCkont7bWnNBxmzSI6xNSEov/7J/9M1N1kGm4rOci0UiuqqfE2F11vDGKfuLtqyqI8WZshQ/WVwolbsa5sk3MEWYKNcwoEShYKTHpPwpKubAUUEUQb1YsRMfQZ7a2Nn9WoNQUnxl+1tdXlK4WuhzhXPwnGfhgSiaxImBFEvlaHQwdhOFs/YDy1TvKOC8GbjIWu0MPps+eNmP3R8O9LMjoU5Gx7ZRJWC6liIe5KqjRh4o0B3656ikulwZV19eX4cbQ7UQDMcMhYxQ/kzCT7PCBcNEBVpQRMY2kGbM9KKM4OAt/KjSUnJlo5yyGAjJqNfQxIkr27v0b+xKmZ8devfrMetrVOU/nWxbonWGf7sbGzMVTl/j+x9eMHKtr68eDU4uHykVPLqSmY1QIxXPHvjw9gafRXpc2q6CaYDGuXy6cYobQNDgHesjO+0R2P9PoJ1F7IabihlT8Rjc/7R2ZFqtIFPFm+WWjbW0xOxlfnLjTOFQNeW0ANo1yUKM9nJjq5urCGZs6P2Px5YXrr6ccR68DW613DfLl7Y1Nz/OLy6Q+urHrZt7JzuSI0WYS1L9oOMD66olSNxqHLkRDK3xSYgWd4d87pFeGzvBpMv2D4ENeLOkNQnjVY73q5pIOISXZruLUfe3OOUq7mAGYOShUBaVVCsYAH5Gre6KMguDgkaCtTmT1vlq/sFVQtTh5DbJ9zdodQGEzZMgwd0DSCZVAOarTVAVjmhboL9YAHJt7dHTiOmWNqqVAA1x6/KbKGpSio5kUeuWcj6buOG91jBMNoXUfXdOYrBRpwFf0cHAKH7u3HrthWpYIeSUzP8B4DHYP4/OPkwvjM1HkQ8OHDHit6+ciXX/gNLlhrkaskcIcVSYuRm9i5c9s7Gp7fYtbnEKNBIxLegOqoZxFaZi72RRvUw4khv+iNe6xCQY667huN79/vFnsum5gbmf3Pfbe3ds3GLx8+XRv15LJ5YL80YnVy7qOveisi5FItaqK2+l1fobbS4a3Pk4gaymRPkEeKTxpFChGBLeR2TRKl6CFEISS0g/JOnsrNJVseFtKAURpFY7yqy0UI1KgvLiINs1DJIlEIym9FRmA7TQe2CvbsUeKX1teQVlOGsy4PKaFUUOCFNd0B3klKxGmXPQC3LmHJ6dDAVtmuAgaHp2U97vf/52RX15prN7oGDqoPqzopopF3cZ/Whoarbui9XxhpQglYgVvnVwVEEuhVZyw6oAjvcr6qVuqAjjSewvD3CfQYMU5LDfJzs16s6TCQcLQujlZga90nVmXM96ID8zr7LODvEIxPYDw1/YUdg2kRKVLhial8igXMuzdSqfIgOxT67o3bkykVapCdTD0BLNqLQE5ztNdLmV5CixoMEcfMCEmmTA8QVYoBCDjJzgKKukvQLxI6WsjRSxvxJX2AhxYdPBIpoJ+CgClII5z0isOwiKtFQsAokQZcYuALNJoDtoqGfflq8//2b//7w37PZQsi5xk3PaVjmeiKM3MPn+29f7Nm631lZzWEM0/kxJyOURrQxFqcAbl8kgOry0vfvb8GeBbG9YSzy2RGcykIy+Q15nnaUEuxTCzd2x5CTKyhzjc8MnlkbGl5VUVAd96L0Xd8IMLeA/Iztxu7ZMFG5IElW7PZAiC5QhvfK6a6o214JnrXx5H6J8aemN51VErNiJp5qQ3uLSZrrkUgqCYLMvLK1qNJIowMma08868wfRVA6E5UBpd22EwT3UoENIEZGkTneSARtF9MQaRxG5JCLJNtlI6hKCuBH8/OUrxy6I3GJXTp5r2JqB1sCWwIHgXc4ZgrV/46VGWnxUjPZ6EW0kDTamBpIE8zoEkzV0vAzlHQzel6vw0t0BDw5yK8nDYO3ZIOCLbPtcfnABv3YV5DFNBGHz8AGAxvEuTlhYN6lHh2eiAhacSJROGCVQN3uubW3MLS/tH/duRieXNJ+c3I6eueppbuyH+l9bd29A7Hsahol2ZNWvdb8bB1MZ0TRPDmka3Io1xcEXsciNZ/DPHwga7B/s2AKSUu3uzk5PBMZH94sVzY22R68Xzz7746iubCtc3N+GvmpZue71D2gkexjUbG2tPnmw7+EPDQR4OVdza5pbApPPHp6aPhwPL0WQQokEOs6EGIrR2MZ9LJ2B5gS22CQM0JaxixfuaoUwS7aoloGgO4ARzNXF+Tba0jvOgAGOUQZwOKoFC+kcDV6OZTi3MLVgA0B8IMhekUBk4bB33Bo72JHwNwhbuvY0rJgCEcj0KgiWWteDmbmWrJac27R33TQONB20nXhYupCHcKRR6OG0up2reU5poPdnPqW48+UlpboJ2+fupO/3uH37XG/TM620sMGNbXls/cTA9vdMZwguLR8d9JND8qNxdXnT67O7uexoigG6MzTHnEwhk/WNwdHQgnmpGcCOWkRkb/fTzgf5DoBMoeBrd6HSsDQiA+sI42JZFJ7uS+yTIwdEhe6u/+BOhXvsD3+5T3RIR0Fw34Lbm5DIe39l6cc9IxZ19Yeii2/7JzBRhqsdqpHFOILYpKtqSiytIXXDm1Cc01AmdkWDWGckSfffh59dv3BB7cWbYuAPf0QNc4G+uLy2BmloxkVseRDbrh7Igp584b4mbzelQMll0D5BhiI9RTDf25MxZhbpZZZTkyXVFXM5xLQOuxmQ0s0uTwFcFvU6FIZ8lpbYTigGfOMvyftzcXHSXWxFVC2UIR3/av9c//vyLL60eZfVxYpoOyCnyyfbWr7/+4v/1//wX+OP4+ICMc4Q66NJQbt6/fX+wu7cwM/dsa8NFQV8825g0sly5mYtZZsz169Z17cFXSy4bFimba8QlQ8vB/o69Y+TMxenJKrfwztLcJD1Dv3WbxTgr3vkNBr/UoPaCuNcJmdx/WyLGVgHzdEYas2fLpO0sRpNLO5AJAk47nEdGF7vLdGgn69OhLpzZ83g7Nu00upHusqNJO+RUr9ffPzzgeaJbYgN0vjm/Ph+cT1kpyHlyI2QqAISFVTL8jFxcntTauWbu3fCmVw4GJ6zatic4bks/0qAYAMH1INc56HGGq+yHmhg3hOh9dDuNq2loc3Rt47ywJiMTSH/QdP7SVa2iDo6HxJ72InroGd7UkQoYCHEdDtFDPWSKvlAyRb+gxvvDsnxySj+AKtoCjrxEuUJlIQqaEmA39TqbD4awfwV6sqAzvmKUs86WJru5Pz3JfY02Rhh3p6YXBsOLG23Doj8xzcg/O7+gL4FmHuD0gatz8wkjg2MWDKIjRIEm3dl9p6IEGXuo1SAMjENIhu9//rlHA1hcHe+snjus78k3J/fLP7y/OTqf+GGHnHM3BCnv2oORbmex7ec4pQzMTFsO5KlxPzO74OYP9gE85sxVdKbXmJ+bGauy6iBUCsppE9MXjvi/u9raXLXQHqkLxLhr3eLzyMMVD0hm9uMMcX8np/2bh9zVgSC/+Zu/4Rv55uf3E9E3ls4vrr/46pemaarmpFInDJ5cni+urOa4j7ifzOsmqEseMg3p0c3oeO36CitOuQbEQohTL2enzi5YrM6h90FHSxPmOP5YazKKt3XP+up2avNfUzR6iVK63WwRVIe2AuQGj1sdDB97SApLEgLaw2gvsZHFT40qC3YnVrCOsuhuZJNkRMPm+rp37D8RgvfUDRmlkUV6gyqwpThguKZ35CckqQzPnj+x5mYvjOKwab5mPCBDMumzxoE/5NIetAlVe/LsqUqxAEIJEI1U6MFKLqX7iteVSBfGh7oQtk7K+Wj9sMK+PqmxNBLUWJWKcD2cijXW+EDpWF1fB5zR2sApGToQ/Z96i7KAKsWE/igeAkpRI6XoY4DjiWaxiSalFImhqo7CRf8U2tRqdTGJdjOG0q0GI0KpgX6S1x7J1AtkMcKK1nh4S+DTnLq0LSYm2dHHV9UsrGQMMdu6utLlgkbh0BDIiRSOKVYpZ9WIFwnneoQBUa4HwshTmIg0BnjQzShHwVEoSWJ6V5BZzJ9srf36V984+dldouQ15UgDAWtIlgZVAY+fnouJHKs7MWqrsBUoRz7QFTJLG3Vty5UjMzGz6qiFncV4d2nRWYpskg/uIOGbf7C/a3RcYKC/u7mwNthWkkzgKHfOEiC1DW/xV7D8M91x6kCE/h2nCxrWrAVnzXfU62d5MOLULVquEb7HH3x7Ml+gZc+5wmCVnYvYlMqMyNzTUKG7mSi47kNbpF7tXDxLnDQhBENMEyjx1fQIhZ2MvSvdFaQz5DtOsRqFbq651Q6HQL5I7WfRWUB6cLyFSXSy00/4o6QBG3M54swph+agxJLsvmpiwNvX9DWg8BiG9NUnxWHFEL8dDyU9bIWLcxQkr7YGX1heP7WXAFSbTIghS3ZpDPRGIG+Jsw3TKkRrVmfnAUtKAGtI295eM/Y//+zz9c0NbGkwM5cFysjz7t2bo577I5+pncRKoX8hBaO/FVqimdRzmH7uYZubn5iZX1heY2ezVjDUPA/j9xMzC6vbS5vPHqYXe+ePU/Obj1Mr/dO7y5vRi7vR+8eJdzv7P75+S6RpCM4UJhKcVPC/4T96rItMbu5IGyMO4oitGbkq6yiaF5Kkbg6Dch+OrSBnJyCQML/97W+d6rO8sqa+mUA0ibe+umb34sHBPlLETaORF7VtWFQWNcCBEM4RIZSUTs/QYG/evcWreImfrJYledAWRyGvnqcsDm+6J+Shh8iaD2HNySm1bVr4cQCQRyLkkwgptaVHNZAScoDKFizNoxdj09BbiDbcZWjl7043pCEabeSVUrx5g1w0KU42wBYGYgRCncmJnGrVPGHMASXQrjgMOaAoTbGdnwJQ0rTeHkwDMcV7QHPdld16lAgwQbMewxKF+Vv9YySlq+Z2joaY9NQEwyYxV0VDFREp18DCAUw4qLKC8KI0yqJJmccYPKoI1eGT4JMiGha59EbDyy6xjmaYhjOA5gfG28mZiAlMScYp2qGnu/t7dHl6DYciBUUj+igl5SKtDCQaFWKtqWKww3C6r95rJKf7E+ZNhbIqYGmdVepq88mmatrEamRZ31xzLZRw2XAAUXEFFcLC2tpIAyZlv5pGQCk7Owc1+IkkbrSCtpCs0FCpmhz4qTm8SVUPriHbuXRbBRTAJJ5MRnIlUuz+oCkRe+gJjWc+iKRCySyeJhFK5soqdyh2NZkFks7C7Dff/IInHCuEjxb0FGqDDG6poVFTlq4AVaMX5cveCGHs3qDdmJXR8U29SBC7wMzNqMkmFnXgFdZaX12Zmxnb2FweG2dbO54jk8ceL08HfEMpzOBT1cn3y+t7LqIPJsPxjLCyoJ01tHbLJV35GxlzaIEdYZz2XOV5dWsmYtJsiuPsHQP5naOJHEVxcuo2J4PT6Pmlqc/kCR3s/ERzGwRdZunmD7u6KMdaExsgTrRzty3rSE2Skp7azieuf5Rx1EBb9YVMWWzUuhhJMo+vkPQWrobwBhN5vZ1K5gGtNda91jHnkAAQxWlruTQaUpP8OlwxMABtuxu7zTLppmFJxvoLNVpTS6kPyuJnm2TESxCfYAODjYya2yfdAfJavCrLuoVZpCHviAJov3z5Uo+DDFEFHFsHjqIE8Al++eKpXX0uX3O+JpnjdJZrO65Xlhz2aWSmfuaOTue+8RVEksm5hdWtu9HJk8v7vd5wcHl/9Ti5/vyz4fXdOfJMzs4sdMn6S7uIF5f2GZqY8FGBmdqIzSTSbAk7ewfH/RPi3l2fHHsNKowKSkGoEvSIgFU0Chr2ese4Wi1UTQxOUwtVoJuqEdjCaKJB1VcbIXW7eG6s9L8nm9u6zu7O/i9/+UvjLt+hdstFHH6k1yWBFSamTLZwghKLYkrBlUiHZ6RRSuPSSCox9VauT+IFJPhQvN/1QE5AUg3jkU2Mp4AqXmWgi2m8YeATQAr26IQi1Y54MuDrPyCAJi+kwVSwZLKI9OZ1gnw4w0/p0QFYicGpjODjbDDlKgQEwJEeWUGDHshl+tdNSX8sJUYCdStUkaZioia3/V9VC+H0gOZiBLhIxSlLYihBj7ADhwz11mzKgh5oFZbd41OhV0RolcoaA/yJMGtNmgdAaKugryDIDrFSE3i+WoGEQwGBAF6XvvBRok/miCqrOn4CoiBpBKTxtQKQpz4rJbKvrX8oRYKKlFEC2IqR3U9hZigBHq56ODh4kYuCqw3FhC2ayK4KKr1RIJaKwh8cZWk71NbgqiMG2moNgfYpkqWIU+WKBNNTPwsCJVQ/IamIEheNgqB0gp5ly6rQk6cbLiLcef9u5+0bk3mWzMODPRAY+9QLmz178ezLr15RXs1knXDAb4fBlGqDzjRltYAPJFm6LJKZTYunXNOUEJBqyWCiOkaH2WlyytLLIT8Annamzaxpcl1nj7NuBBja0fuypYZEyMKOZSrmHUtiFPwZiiYFM7fDRwKwjrCc5pq7GbdG0T6vbh7dHyohrcZ9oVc39zab6qf0OJos1mZrfdQRjRr3SM0WGA8NwwCiaS9IoKqFqdjr2uqRShky+FgbrREZTaT31qBoKKaILKa+giMBHpO9whJ4xKCJSNwiXqUkQzSBemtZrpbFMAqtAJTE6x3KwgDyitFlZBEjjPLAYoAqQpcRaHWJugO4BFg9vNTuPbUGSp+WXl442yVQRYDGnAIy/cyVxYSjC9rw/tr68p7dDHeXxCIFiMny/e4OB1wrBG/evr++H1lccf3qpOIvru+O3YN4NzLdWVl7+vnK9sul7RdTCytTi6vXY1YJ1hfXtw+H52/2exe0xMkZee/5nzK3dRYYnWxFHvA9vRtZWFzml8mc4PJedh7jFOOeWbmUGr06hR6k1mjPBModCG1jar1xqMEFJldlFUEHVWtcd1WLWKSEaoo37P30w0++riyvvX79s/kNgvNsPjkdSEMketAfJ+inziHXGZUI1OrqOvjoBo5GAUGja8diA1RVdGv6SEsFifdTpAe2H7wYq8Gq08qsnTxgAVrZKlKYGyiGYct1sZJOqMmonPYp1MEjWBEfgGYl1YYMuov21nJMdqZIAIYulzeqge2kpDvThfFQE23R+iWGmeIEpMdqqgoZnfZT3WQsrFT76fMXrL1c/2QBXEpfw9BtsV4yke2LMUwndEBC1soA94n5txbuVFyuUOThbsPlcmtrwpKpvquCuRZ425VqR10uTc6eHbxhKdha37SebjijNNSEq2yvxDoVT3VMPYACp/kgM8Iu2tbx9MmzWP7iizKAnlpgJn9mRWSLxOoCn3SJ5puEOCY7kgmYFVpUZYAyvbDSgIBUSIHjQZ8GZgUBBQx1Na0BH1SgivI+Vd8uFsENHggUr0iJ2o67YTOlVRGp3q4MNIsiW+2DtexJZJucMBRYtT6PA14EB1KV3soqI4Af4BnQNFUKJQ2c8L3/IBRMAqifKqg441ImkPwiJpoXZuseyOzG1hfPt371zRcOz9nffbu2ugxtlSKvcmrQ6MPLl88d3fr55y8tlGlWF6i6npvUd/IOmNgv7DQ6NgtXBl9nqshjq6ONvmpoKa9pUnBwO9nC4qx719dWO8+fbjolwvkNViTNVba3n647dmBta26+ayHDhcpuijseXuZyR4L++uZoMLQfo9dnLT/rDRglHmj3hgorICenl73jE3/94flRz7TgxjSws7DEJGApxGqB3q5x9S3LfTYU0mSdoOzM9dk5bkTUcBaYKF44wRKJu5dVX41IW7xEixYmVQGRmaMd3tnZeWfCRztCUUpnMwFnPNC4mj6kbp1fpxPASIATwdx7lKULgwAfpVh1SOs/OIlPN7RX5sx8C3tULuwkl7xKF4AM4HLV2ABsSNqeUvN9sTJkbCJocD45ZW8Uc7FOwfrlD3r4h6ZId7DcQLQpC7uCo1zGTNI245N1juWFPdtxRkb4+2loM3w9hU++GZeFt9n5jq470+nejVg4GCcP6fuTc92Tq7vtl1+MTS/s9k77F3fDm8fRueWT27HBlQuCOw/TnenFtfnlzbGZjkXgu5EJizjdpVVjgM3kJzZ6jbCoXBMvveEJZ52MDbNu510wtyBECS5WddXHZThPvXRfNTo86CEP4zeCeNJJmE9zHX1UTI1YtZMSqUgu8yHjI/lmOKc+HPd6tvqrkjmBhpZLWxBcFin9lBeJcDHecBGFTmaMTCtMzSKUR9gbZISVzE8QIMldQ1heDwpX6bqqyOjvJQgkVYDGFmk6I1xfJZCtyjaJhgfQ1XhEuQrs78cHuVDxSZPhCaUC6y2ln3DSyIpQIFCwxHOt/sFYLp8kE1NkkpcyWHzmK3EMTjEithGW3ohXuzStsdCUO/MLJoDFl+oAVNpnOgeAYHuWKxwcqfrRC0qlgAW88FEFWaIRz0Zb12wO6oNAjT0ySol2RY0S09CAJ6y8QfOTxwH4sq+vbyCT0ZsvnXh59diCUDhIBjn6i4zivR1/rjiqo7BPJceVyFXAbFSualcISCaNQuEvoIKQl0AYtiYWHhjW6h/xV+ippryQAUdjKYKdUV79GSU9FHBYgYAOIKTo+PL2gdV15fXVI6MwaMKyC4AgBsLeUJKA9Dch80nRIou1gkZGnBDNO5Z0a/HNakdvouE+f/LESgmm/eabL7/48iX/F/N7Y5Cb6yz1u0rV9U+iiPXj0+MZB8AtzF9ezfOPhoZSCDIDK0WdlB/aA2S67jCPiYmNzdXHG3etcHEfY9NUfQggjsLPzgcSZSJya/LHkH1rz9bnr74gC9693z3t8RQ/52k4MsGAgF3PzEX4iCoOe1AAWdRp7DR5JgcE5wIQcU7DPc2dcWJIEJxJaxobH3ob9a3JW+fVeIhjcOLxyHlcJvt6mZf0M19YTxmsVLlN6HNnzt7O7tH+wULbamcWiWGQVNMAoo0wtmoqDhHEeNTRT+Aqvggu8tre2o+zwHaoaAyMrYHi5FZtx0SmCrJgbHzijU+UKGXlVZwEfkoPDaTQ4nqxcCrQ1sywqIxm5+KBYqQlZgptQKTBBf5MAviPYAYwDXdSqhRWLIA20BrPWkeYGFAoXRg044Blt4Rm4Kc8rG89pZ25xNXCsMjRKTu57ocHg+v7cQfEPFzkDvdj17gfHi+cXc+YsjrscqZjodSwQWeijC5vPHWi017v9cX5DeX/7vEq3itjlme5hpMqODZTM0vxjGUcybRgrly/ym0sZEt4Jha79E0XIap+DhU8t2dtiQjlXbayZL0n+8MxS5zLJiNv6aQZ40/vCH3KvsoSFM+evbBkme03E3e7Bz8zafx7/+Trk8EZ5FEbGdefbhzs720+3XKg4FG3e3k2XHQKaQz9E0iE2tCYnowfOYAoiSPgg7ZKjJNtXMzP9Dj92lpUtW+w0Wwev4U1jMdPjeQNqCrKoHrCYuzK081Qn/rPQYj/jHgDksUCgsWfgBilct2BiqmJAUMMLiHfoWgMxDdiFAe/JLZqpwu29QDdUl4xzOX+DPgIV2YQtaJ/gulrlnYMVFOT3//p3VdfPNl+8vSHH35gVbTix1WSVCXHAdTTJCYRqlbm2pmz8yg387++oTjAjbzTBpDBdhBDSpM00klTKQvV2ok+DI6WeR8c+qtcaItHAdVpVDJ3puvqMyijradG3NaARib3DgwYDZzU73Hszbt3hgHi0t4iJ4y7tF0y8jqM0fZSodL9FP0jkVhNQYqovsQGig62OFCiaWrdqUXWXJ+UMDgZOBEQeS1fAKixVAfD6nIV1tdAgw+wGlrYgMGxBtnlMo3A9HMjj+bafIokKKbxFsZ50IjXYxvnMIbqiPGGs/uMlKVG1j2QzkSVv1Ck/z8S+lBCJQ+AZqQCPkIsNxpaprs3EzpxlgvOQX8+LL/61atffvNqoTPNOUhX5ejlONDF+VVZYiG5v97Z4SKVOyQOdnfMLezu5qqHvgT09cMkx3vrhl5p9YdHR3BtrK719t6ZkNCUlC4aArpGf3B6/XidI2h099uH1bnuKMo9TKw+ef7tP/zxzbs9M5cTroT3I0TGOVHk3tepuWvzGv13LsvgYUI9fyaKdus0E87k4pHdXBkjYDu8+xkhGIitD5xfTc9NX57d9k8G1rGhwlKCwmYqbiqfmri0PMAX2gIyZuN2kZHj8ppVSnMTEEcHHwYAWbZqR7cT7ReziqNrFCsiuwYNwTP5nrRKqvO2+mZmDMnLE5pgpnrawkxMO6IqCBgJBD81N6KpFyVAV2WQoWkwlRmhayXAT30CKI2VQ3dbg+L8xixkCH/ziOxim3TDR+f12tYV8WJ7qVykpbJAk4bFI1xxH15C4KRpVy4fPByZvumt8Yp6HDk46ts0Njy52F7dOL+6mb6FIZxjRdjbOYDHN9/8zQ9v95lcCPGxzC1G7g5O+mcWIsZm57svF1YzHk/PkX4sb8OL28fpLA2o3dnl4PCw71YVriPDwTlrpA2XujASQR62bB5OcYwHHV+YmalLC13m3Ab6HKQxYUsfokHD+W5m5fZ4oL/FMIu0dCYa1drKl6ngbXQdxrVMX5zjc5mbrl//9A4ZB039MpCYRmATxomLm4dnT54f9y//9v//v5uJmmrbUYQyjC4aGkIYwGi98/an2clVbaRTiFlcWDTNNV1Ky7YdahATrpVK/R0biKmxQTxtVttlQUBqHzw5eLA9wGkPwdbl8kmMx+RdVaEiRi6rnYbrkzEscm8eR5JiI1TTMWSULLKyLRhIoKriddrObLoN+iriEyiB0GJwwqQrAA4jtapCUS68iKyVHuoC0uAecqcz92E/FGypa8hhsbUQho+OBMLayopq0rNUnjEY5oBE8DXJJQtossMcYgQ0dwcJxMvFfMGNXkaFwkR9CwGlyw6Ut7BS0EcyDhWURlp/WL/tbiuCyAi4QmF1sBvLu4xyXZxemszSVTGEWiMvTKp/1rKnSKMCrEYvmKpjrlUR2cUIofPyipljD63whIrLW8QR5jIx7B2n4drqP8iQ91YKkkoGmK+ktngF+QRDlfJJPJgyqrUwTU2k4qT0/oSnKiCSQkte+AQNMchVdBYjuzdQ8hZwrIFoyuFUQ+l2MColl6GJpHPq85OtDTx9fjGkFw+OB1trq7zZuJrlwBzi4+ZioTOb8/StkcTblGI1ZYMllDjUD87veQeqpYrA/OxkyGGZbWE2a19Zg4GvlFblyd6Do0F3g8vm6HL8vsaZ+swaXNzxv/zP/9vJ2SUvuZWNzbE5RuDRAV2RU8riknFOY2kJrYlMKu+ULGWhAODmIgxqxmJu0Wrt4Uw3vTyf7h2x9xCebIvV3JjtYTJhZWt2vy+vntvlx7HJmcP+6Tjj0dkFMh6yJZycUhKtL1vEXv5y0cSCFmbnMBUIhS3kyo0l1KiYR6SMSE3zUH1C1ieIKb2a3lfT5RqAMx2oIyvarmCISQxnewEl06Aq1Ro8iweyi9R8Op36+qlERKC566rYQKRWVih8BPAndgJEGGSUEAZcLnq4PygRbbjbLZl8bY3LlAkFSSM9sMV7Os72k839o/3uyiqH66PhxcOtA30mzC2oEA88ssZn2aPPnMJ2Nzo3v7pzcMgiu+IonrO7Xv9qrrugb0+NO5DncnVukT100n2/J0NOpYY+Ix42oZ6oiI10U5Nz1vBNN11nRculkeT28/hDOqb0bG3F7bbjma4574TdaXbatryD26FxU93pyUObBqx6juSgSVYEG/P4HHAg4Y+0tragCKRzTqZ6eZCF76Jx/YtXr1APPXk0uHyMhvf963g9SKM1uaq/33mLXeHhef786cHObnd+5vnzl7TZ/uHe4CIHpxNWRg4jN89XoFrX+xDQ1rRPoqlG5damAW6oU27VPJu5tS4UlaEO8nsgIaydNIlH//fVTw0sLIHpIRQpziSIT9J7g8OFm39+4ZH01zkl5qNAZybVahOWMUzopC/MwF9eXaFAF37idVpGQPCxr+IKq+JX2AMLPkZRtHKNtIqQBpzqCWqE3H7CpzYlyAIOc4o+Y7QnPjS8mrsjHnsySGnnI5eeo7vFFtzc1rIgYGPE8HRgZOJxyO82VnpOhNHvXcrMc9a86YHGJ2BcgqEZA0pChru9P0d7M1KXNdyMgwiHlcP0GdI0AOrp/EpRHTX1mK+Yg/vLWWdtnEANlTK8c/EV1pEkVhelGDbE0BbVVwNjRPG+qjVZgyc+UUx7tX6YIRzFhCXmIob+1TNR1UO8N80xfhBgIpqiwdQu0Ja3wvI6gEVB4OOHcHYbd4GFFYBq1KCFF32SUUBkZmntngl5NRkKgKDz+yNFTQvXN1bRl6lnllw3FUeOlpEKI7tdGlzxBKAnL+QZuFAJqoYQfZUQMdHmQto7ZEza3d7aEE9ulsNVesIMA+7Yz29MH47Wt5+PjHcmZld4fP/1x70//Pnn3aNTZoT9YzOJkU2OIlYpOeDe3tiA3mfVmZx69vlXk3OLN4/ji8tr5LW1QBZqj4ZzOsjdzeWMrQ6Pt5Mjd+MPN04in564nxy7nRq/mx5/nBy7d6Dj/PQE25UjrBft5ccxViYmJ9xPttSZd1/J+nJ3a311a315NjtbnMZwzyHy8GC/rQxnLq9lWQ/IhazQtB3IlH07ZrjnxUxsNd0BtO30cg1nHDUr0nCo7Y1iuGV3d6/GjGpi7Ui71wrSaDsVEVYjFvzm/xPNxqfihGIVGYszsYEbF3AasCJbA53gENJfFvSw21ak1tFPIW9V023sQIHz2ctXspuSWtrVxLLjIgjIWCJFEbbFhLb2tNzef/b5l0cDrbNwPTJjFLh+mBpePb47PFlYezY6s7RzdDYy3fVpdHppqrNxeT/zOLk4PrPIb8eRLiUTmr1lR79x/ZYlE87FT7c3sdnWhiufFx27jFyculbd1dCZR86N9dXz05Mc3dpOncqus4e79ZUVu7NNrecjB0a6C+loJIY1J/wMW36JX3zxJeGByBlM27VoBmR7HZxu7eAu9EFhPeWf//N/TqU21KGeRVMKkC7sqOilhUUF2aTlRGimG4JCl7R4KSXilKaIOPt7B7QWRJNdYzE8NfeqLJ9Ihtrio4GwVblOeUCHcXxWrME6owQNjZsoelCRujqqcDEKBa5A6GOaEIhPP3U9reUnQD5VvAQgyOutFSVIozZtXXOKT0PmbI1Y9xppwo584mT0QEh6a2ICEpTQUQWUKskiHkw/JUMRRcsOW81pHK6wWZ6i4SOlT1KCrFxISm94bIad1EUkHLxRQRYxElS4SFOfCK5s9UrGtlLK7tfUWO9CsrqBnx5wRGY/YFtTyYZqJihe3a3z+CQBPLVxd3FJiVYv7ADcP9hTKT0BzlKK91PpAIrxWBlGHTHCIofO6bPVrJ1NZkaojoYKkPUo+Bdh1TcFnZ+xgFNUfC1qaAXwi1YaRd7CTUAk4AJmuBialKmU4gWKK4rmhaRaOPkSqlnN+8gDEYLtMDhZJKuKyAWyeD+D7VXmXiIlcANMuscoXZW379TpsL+81OH6trY8p7XNdGkY3C94GD9/+uwvf/mTLmHTk6Ob+VPPLnf7vcNT18OS+DOTLFd677S9+7ZHmpSO3uoGikM0dZmixjebg81vHmsj891lXoh2pu72bDG+4KEp8dTsoma8HydEMl0/Ojml0dB0mMguXRq1vGTt/bu//gj5hcUlewyPjw6phPqACvLlsaBrs5FjiJxtTYswQHEqGetMxrz5eJ9zKXLc1QkjBaawlZEnQ3RwOyWzOcDhnlnA4F3g3hv6JO50uQ8FQwel/h/s7W1tbJGFR+dn61ub2tTisDopXrshqRhYaALOwwLGAE2M61DAcq5aS4NDDo8PqWL4hAHQ+r6WQuSyD8iCizSTDdLIRWSIFykX0ekTIErB82IE/MQYIChOJ8UGaOhTtXt91ZFJKAlIBTr7+PixoqsvUO2VgpjGM9o0/yxhcFhOgOUoxSYuL+X3L99//+Uvvv793//h81evmH1tWbgdGz86pZhO2is1OtD4fPa6SGdx+OLOUQ3+f0+ET893Z2eUHaHEUk8eUAgYYQbHPar317/6pR5AV7CNDvEoav+Pf/Ef/cv//l8p9IQZ88Ga5bgju91whbJ0vizSTLt+cubqYo7NivvF2gqX5VOLPPRhSnxZXNHZjRGoxGXkZpxVJw2uXSiLaCXQpo6ZTNdDoDsNm6zQnVl5Lfk6Bm6/18fYLLrI/vXXv/jDn/7EpuQAiX/nb/7dmAUplNex7+NP7M1wo5+CQwU42DugWNGFDLrIrpmstCE4+Wo0shAAB5MS40JQ4rzud0ltqT0o5adAtV/JBSWJh65PYjSwzBpPvJ+ekizSgOaNCSQAJCg2uWZVhAnbI1J2tZIljIKF2o6zggldAUDkEvaAAPuSaOJL1igRKJ8UZNKQHS2aPH40wGemIqNhzzyDBqkiYrUK3rJwQMpiNFhKrRQAYaIu0JZMXmHNSYIBVV/55HJq96cqKu1PwD5DLkG5WHts0kHm8zPzfmJ3xUlnUKWwkx1Z985+asfXX9qNwJZNxVhc6BiXh4O+1Vm1I5RoECnSiSgur8hexcwo4AMrTzqG9dgo7AyUFsLYIm1LG3fUlKVL+zZtHsYfzKnUkfgqtY2XNmmzsKsROKiKXFADTUwNySruJ6p6qpkkwDfChIYvNBpcJbHWlFhG75Z8TNMJgFytUHAkQDE1ou65aUtH5SCRJmjuH4wxJ8MLApNK8qGV9aJcPu3GRJIFTAenHJPj29ubRI8mhgdoiiCkyAvtbnYFB/xDfmlTBSEUuqEw1x1tZ6BRf8OJmYQZm5uY4CmlS50429sBawepjaR2aR30Bj/+vPN+V/d3/IUZpWtgx6+cw4L9p2Y4gTy6TmBy0qkDfLPQ3gWw+OL46MBiLFeN0rw0h6Vpm18jtafGp63e2kh/fTExej8zaf8v309nb1FZJrr8F1e6i8w3syz+C8eHu8PekT0HjO5UZRuFCfKpsdFn2xsjzrbrHbhCxuVNm2tLnApZwCiGBhuODEwLTty019SGB9ROU+UeeQpdeiip7ZQU9IRY48T0Wa2THtEeHoTltULOtiluzt+WICuZzuJfWGKy//nntxZU7ZVBZOekAa5p7AfQI/zUHcVgDz9Rm4ncX1PP2Ocu6FGNp4w3HBwyNkcgNq8/5eMQzar5yEfbO9iNMUDhBnmf9CDMhj20u59OXlKhnJ+0sDQ4Od948twhDQeDq+9+3H2z23ucmLsbnT27fpzprPDhObm4HZxe2Gg4bof2lD35s9w2bb8BH1dHnp7aP3249/b13eXpq+fb02MPjqBx9MH2+hqs2Xr/8pc/c34zIMGzac8m5Rf2CbpblYy2TdcJ5K7kov7zyuWc5u4wyygOZaDZWyDTLrgXv1GPPHhRpbCuOQEuMolhA4SMOsInJ/9MTBiHVLr5+XCnntKsSuSJ9+zZU6OUNjUt4MLGGswiwnNUX9Dp6I6alZxWVnVYtNJb/WRBElAuaitIeukQU1lihH3yNkXzhkwsOSB60nfYVbVqmyP4IaDLyaY9xLf2c0ATqaRfRPekmAJnGxBG1KgSKE8MkQ4hAhdIXsVMQDCTpjADFjaZ1N1j0w9aQxUEgoIAgZkAteoT3j6BIL6RNWMPBHxVUMVbrVbBqoL4keuIJ2mswTZQ9AKslrFBekDwJaVUuCiC7cTUT4dfQFgRIqUXULoYYY+w55LDXBPNha28NHFLqTOLM+ZHPmm21kNMUzK6yNIA5uROYeRCDVv2vX2FD70bZZQCeaVIoENXFfyUwFcB34QZgqUU8DiCj4gGs2go3uIwmOC0FswsRx2BEvBURWh2GkguVYaYr7L7arYjl5+S6aUSyAuaSMmEpVcV9a0wieMkx0ojGQyl9OAZeQV8Ag0LBnlz1LZcyXdAjPQkdQaDR8vgI44+coa+6bd49ZKRpVhelBn2B5999hkJiCy2RVIaH28nbCBnE+OCbLeXAUN1+H2zGzFQM+sZt/QNFhGIO3dBcWw0Q9bJk3O7+umKJMvuQX9pbduZZ+xC1AUl0onVNsjjQDrF44gNt6wcf/zjH3feHBGd5C6WI7VJum5n1v5h1sD720vOC9DjkEJBUO0HN/4GAP8lDDh+e2P5/cYZY6ahuqRKmcdAz9yCjLNURFtR+PnVrYnCwuwMKxCzR3yWmBEe7qxyL84vGgRxi4qIJG+QxTldFp2hjc5oq9cjMtGfcDvUXZsiC17AycSBT4omdjWNNIislQXSiM1MjLx+OtdfAhLHDJV40uKSSSyZ7B4wFaqZqonFKNcbGkqUEoaytE7DehlrsH1ebTJho99SYUsPAId5VsIYUMbDh3RLndZqa69/4qIVu395zb766svf/f53Ns06BHpuYc2S/9rWM3Bm5mePhqf8WWhEFAhGYaRll2HOVmX48H10vAFWVi+MfOkwhtvL7fWVZ8+3NTGCmAVKd5GL4uOb8Jdvv717GKX0WHl2NompWyiJgR9iWuS/ox+QmIZAIsKAybQLZRxH+WCRS6dvtw+R/roZTxMuRK9/cqDh2ouX2wjC0kZvK41KcaZEiPyXP31rMFB3g6Uzljg1PH/+bPewt7q27GaLb//wh5evvuCYjlZqhM93shliyWDmZ3M8TU/JeTbtcTQE/ZqmqzXskAUzLqrxFWytY8rYWooexrirpUIm/9MkYXpX0TSFC67wE1mpDQWaUCRyOL7McEBE+CNRnd2Q4sMfUY1xgp9ymZVYIyOBwQeqwPLnsfPF+Iqlov3noJuMK/peuk0TRtUPOdhS4bUcMcblGPxAaNJEMj4WGkKARzEFSI148jWUctYuxuIdjKAf+Cx7/kcpOMrS34qb6xMIEkFPVyTsRFrcRw3zgVShzQxIOpRJy+LQNgLhhjws9TmcKGaoCNzoQyPUu5D31jH0zfpma1s7+gJnOGwHrmwyFgxOhwM4sey5fBgkBFH69uZWlGE+NA8WnM6ARcHqsTDkhKF9NeTcwhyatlnFKMNFrjdgjDg9Q6LjdvhoTEYxXIT8lDs+FCE3odAUG0BURx811Pija2Esb+RVLe1LXqm/0lGLfqfjaIQA/LCBMPJLRWgQgKss3EKWsUykQk+TQl4Oo9yiM1Toh6HmGL6iJ6cFTATTmk4XiY9KlEekoy1aoGXff/58U2eQTD8xqbJKdmc/ZydXVVOfTZ6++/YfyH1kMaPSzbgM65WrzLIe7Tg9w6eC0heLjJMemkw3USQ36W7inQdAy8/2rdh7VlZHZ+2nNzCZhqLbRA6EC0M4skHPQR/avCrQcm/c73ZtdTeGx/T3OTsc76YnXPA0Zsnh4uxG04lBDdouPxSTktsb+1HtRAfm4SYupJfN+2ZOU6SUDKh3pqkC+OLOLoJ01LuHy1HrAbYj/N0//EkfMQZsuyuUdOHdbxjB8I/u9T0HWYtQP3UiXUCLaRRPG6YzLzfdyfvDSBxnAc3h2djYwgBWPhEZ6aQxURPDL8eUQnrj4uryCrO7Zf/5OXvLLw3MqKvFNa4HEOmlTDO1Ib8CxSQqy6AnjQSSpF2aByC+4yDSdAA6TDCxQtCSUBPu6OLO6QOHUPZb1UhJbSJQ1u0n2y+seJses40sj9h/M39s47VrP9o9iBR7mi/haKzV2Y3FlGOU58ExPLumVxj2UZK5v7vi5M05Bwa5uZtI53TgVl9rRRa5dAFsbkNYCNv6vvMvJyazV7F2F7NiYEW2el1dh7XVl/GB9525wWX2XmD70ASvqh33XgPenDmdIT67ShcxpEZynLEbm80p6V2Dkx5vwPPhwMLy2Gi2QDkEQh1d/PLD659QjO5oGPjqqy8Gw5gWOCtubWwTAuh/sH8ESThbYcb6egTSESC6MzMFqXV61h+bxgNwj08N+zQpd3F+qTl0O/NpQgRiERbAVdcloOWXWqelq/kstSrpWhIoTwxp4CvWTNtMxeEkrdiGCqAU7CsWlz6i08D6wUssm5Xra+bsWaWMCqk4LKUUnAT7FNfKAlYaAMUXBOFCRvroFg0fuIHwKQ0/L/6HbffduTYAX7JAboOct8imCyQ7aEqBrVaRBim9Ge3VBUGgKr1CPZ/K8snP1LbdZ/BhzGAC5uHg1Ll2Da/OCOEG+VqVPFQPK5+KBn9sIe6wWAqXCNA8xYGvLNnl0pC6pdILN61HZ4QWOBDWAxwVwrgvC0FTLpsg+wkgtLUxgM5WU3dhXYLoAhPasBKQMkU0X/6qi1yKrtKNE2wpUqahmzMS8urG0qCPt4ww8fbAX2RR1dFOIOCcygUH64q++imZNHIhtYdgogRbDG50JfLcqOfQm8yW/Fn1hfbSwqyY07srKgwNoI29kdGW6cgF3cD18Oa0vI6pm2SlsYSAjpfnjBObF45PzqPSPjwQZN4aeORmZDA8/cUvfsF34uh4sHd0zPJD62EiaPSnOOKuMTvWkEtjdRbnUQBjQPgnd/F995e5yenNpRXOQzPTzPSsKFNjzPMGy4uzsfusv8YYgmOzS2DKaR5opWjmGsdDaFX+BpM2Edlh2llUYr42czCjQGv6OJfzD5GX/YLu7/iFq4uTTmeZdYyx0Y4zPc5VtNC04M7V0JhrSgFU8ZVpqgBqQ9uIFdayi7rtuY0SkAMYugpqKHW0hcaCA+9YbS0sLxsJwiKvFtcENFNag6+4zoMOxZNygWPorXKV6GtxCzi6r3Bo3nRKnCPsyaexmB34yMtrm5gETn5xSYujkDhYGRuwXvFnrKe3jD862+PPP73lxuOMkbXNjdX1LV3BknX8R8YHOhaPDPfPNs6nPQxRwwmvF3fuVrbDtQ2QhtVbJ0OQGNkz1Jk1INMVr3v7u2yJ1GprUk6yAOXYJg3P1f3s3GKv75CeUxs77ke5Yo9TWY77gzmsOXLrXk8HPUVBareHOnv87CpHxTCRMeCE0bIpMpt+qE7YZ7wzv0bNGJ/UNSYYCZ0X3uZ/KCwNbVhgcHQIgUU2qra5+uCwz6XFCcdvdne5Qnz99dedxZXvvv9ftcjnn3/B2V2zoifL0uxUNDNthAJWlHgZaxQdExk18fCkp1CaFEc71VcQ+uiO8kqgETF8urGkfsipnYDzU0CjSqSx/VQAG54GkyzslWuL5fLrw/Be/2dxUgAuMUA1eAEofQrTtZqXGLDy2gpEhaeiKhRaGELGxBvv+ITfRmQX5xUyJUcgIx4Ekc2NOPgAjqweBUFDAl9xoUoItCezCODbQi+MnLAXexSTuuJAaHXka/FgsVShjKeqMLiIlio7rFDFX2mUjPTxsjLlhO2tOw/SY6UMXMTLiRHXmfbotE50ITSzqDXFAmTMI6zV1zetYPGNc0usNn43ClvbZOXgQi5QdfdRwH4hMyPFGQZkh1uEM+/0UZ0t+rXDoew3Dx1sNQxDoIBQXKeuxuy4nuXCpP7y4gY8l7q39TrftWm4sN3khQ7SIOP+wXCxG1dCpXugx9yH7DIiF1DohuF8IiCEZaEqPkyHXEA1rogkSmtG90+b+9eaRpoR5yiwePo6cpsaMZKYdJCeNplubq2zdTIRHx/uX16dPtxdb22tNYAfLHJYZXtz/Wh/f94JoM+eOe592D8OoS5dCRwfXz3NvAkDWEVQugkWl00qmxEUDXVwKwlMj/qt48L6XK5d/80Bn9hNQ2f2RSVMZS3w3drqfObsW9UcuZ28v745G5wtLzqfbrl/jFbZg2JdaO+4d8OsNWdZO1cPMudkybcdDY0giEXPvnHDiamlHUPOlR+eqBFM7GQmphEJeR0ElO012R7UVq1Iz4e7p0+2jFBvd3eNxZzHHm7P3C5vKgISt78QUHG2teTcocyeNbKmF+lRBayC5gKt48QDW6FKtB9EXlzk5/TEqa/w0RDcuTc2NjWrc2zmnGEb03k8Kdq0M3YhMs4WOgmQi/gCWQUlMPo2jtcL9Iv0iBzg2Y78Uwr4mSGDY22lHf7sjWcgzOwjsaIfx+ZG3OLZDFkIQvYwP0fxP7v46quvHL1iEsWbyPkKVi9fMU+51HNl2WAtsdOfXDplDmFfvPryReVWZETW4/l16IVTcwsa1WCtmh4GHG1l1/d33/8Z4strWyMXBGKMYOalUOP0wZDLlYDXqUgVP7tz4tDpL159hiCshc324SD63MOnFJsAZUcExnor6GoaP+3rGy2B5gjCzqNFnAqzstxmWnezFMfV9U1Cn2WSJo4U0VcaYfGwld7F5Y2ffnpNFXPOHWDzCyfff/8XNijEtFVmbanLHPrt739XOjoMVRwPRE4+PCKIUVfYkI+hW/8y+Y/IcvgYTLQg56IoEG7V5rIgqrXoHNR5s6ORANQxEETTu9rd85IxwLevvIgo/lkYwEOaEx4SV0bFkAISAuKrBXQXqgnzhrSZUBs7fFhfJV9gDG8CQEaCjwx2lKsZeITjzMzpYKjLYhwwVu2bB4LrmB5FtNL6if3sEWWMMO9K3QAhh82FsVbo4dTZqGAaVJ+7eXCjdFAaMSVUNRqGUcyOY7LJKF3Ih3viFRv5qLIq7sHl5g8+Ve3EQMRPFHMSC1DiUUl6MpH/Oe6hPsGHmsuFDnFwuLGhcXy6JVcttktZSJfuYvc4nmdmlucba+tOXXfguDTEHOIAAh/I0Bs7nMTbAKy4lOtg0rZzxwRC0Yjpjewhb661W2S6Je4ZMS0PoDdsMUShTR+UDLRKDxlhRs/aCndxfgp3BKEcKF3AQ/d0Que8HVupfnovrLCsNxqCoPQQqxEn/bmNBAoVANxXlUI3j+k5TBwfh4UcigslG3DVlAbNKdLdI6+++Mz7T7vvqVrLG+u66O4+D8iVpYWOhThWGuWqoHvayQKL6jfXt46MXl3usmurmp2/rhEBb3VVTI8EMd5MTHfIfdrZn398d/3nn0Ty0jDjc9In9387C4gzdhWCAzo5WNDtWru7zD6rS8uznZmbi8vn21sO3BBYXe4Mjw/i/Lc4ZxmDYcX0w+y+zG4UovChDXfsn03ypr5T6Ufc3Yh28hfLaS9UFenoN7yFjG5o1y9pIQh2dRbnk1mOMRvrJ+d2gXVs9tBtNzbX8DL4jkw/h9z1OUu3yS4TH9yYWhG8moDOEaeaewfbR/uzQK0pjb0MaExLRJKVApzGW9bwXeYavYY0w3iazDzp+++/hz8JgvGn5ywn3D7YyPjoWs3sctLxfQVTg6JVlasp5YVeHJ+zqONkaQ4IKTojnG77MIrDZWzzAI15qh0vnYBxlasmEMEn/RfpKLFUTfbAza1n11f38Ya6je/c6voayFRvFVScwdrCyOzMxnJu+InqTaLpbjMcRV32N2ZY8jhH3baDzhIzWjS/h9nOLP/qPleotTXMeXzU7yxvHh30sOU4B9O7M6c+kDamag9OZB5w2IthCr0JorOz3vVixxFVDlzh3OQEKmxMd7FXkeLqkLAm+rLyo6E50qkUXUfdq+vJtbf71oZRLEHHJ6k1E5uVXLRDx5J//9fvLPOuMlItL4z+4vP/6r/+b0cnZg/2DucsbDelszqZwYAjkMUzA4+u3Ojv7NJLfAVJTaZTsClpa62joeVCWwLB+eh6K74VY7QVgVB0Q82j7c9ITeeMW+VWWF3nazxhyqTrsHGHtR8zeqiP4R2ba2NdF0M0Lda4R54yOZkBRfWDljZGem4qzp22hEWtssuTskbcM4XHv+3+zoVn5tEmwi4B4kbdFsziiWiGQMhjOHu4lA5f9jvOMXo8T4wYWK+uWbUVoeVy4Gib7eJHe3C4TLBJm2Jx5zXR8CdGTZgaMJ/6Q5gyYfVMn7jOGWF4dNyZ0lyt+dtBsg3d8S1RdBnrM+LkbB+GB8piBBdmyg2i53SoSzFa2txSd0Iii96O+Dejy7lSdnnxfDex538Sr1Br6Ey3Y7b/HPZ6WkjejbVVcCgRuNN9BtQZfxQ9/A152wuGg2MuhqpvR4dCoWSXijpiHNRmTszFR+1P34DPTz/9qC2sMeiiDLjENg52SKbztLa3ttjNrZ26FHeFVddlGjbUUB9wU5uf5bQEVim60+01RQNz9vsD/YqNVffTspiGKnl0ZJ01C61UGIch68wootE1hCzqRQ+iO+uPxBZHtHTInNPyaAO26vFkiwQxoWS1nJgkNJa7C19/9YWegKnoCnbzkaQOY5yemj/uDXu9ITnA94nLE5bQQDDJSf1ZDxm39svj0oU6S2ubfILt8Oofn1DoJqaYy+6GV2O9i8cfdoffv+9fPlpEfH47Qoddshqsw8DO5QumBSQUFrUcaANYd37xmy++drz21dk5P/3Ls1NuAYvd7OtxEpKWcOc6R0AXA1sqMGpz7iFth/2j3ffvTo6PZXFHkW/GjNvcVzFlDxENpLMw49jRc0ac86FzQJ2vv9Tt9u3HvrrZWtvYWF5es9ShbHuF7m8uT4cWxvFwdBc3reuM95x6qQh0tDuTcXeC08+557i4ASdgYNXJ1CQWw1vrDqOP16fDQ6uVWpDKBwABAABJREFULLI8hpYW57vYaMqZ+MwZD7OOzx5xmG6fRgaKIpzDahng8NgW3KnltZUxDqaTE463Y3DP2r2LHzQctrC4cZ8b9Ax7OXvKVnfy15W2aMQ/xnoYieEmzs5C73jg2AaWelZwhhSHGVV6urO/tfVNs1gnzMbcODb59v2e4YbXu2GDLGPMoCI47PPi8pRvDHknEkNiTr5J3GDwAH859kTGe+YEPGzgwx7cz9zyBgHuUFYy6ANsgwcu1To9wSZ3D9x5tN19NPh5G1cvrDO7PYbG8+btW2ssTb1YNjwr6PkzPH/J3MG859CO5QWnDru3jQmXHsvgYe51ye8rsw9rD/biLq04Kcj8XK9fWl3VNQxOhgf9AvK0KKv9z5+9mplbckTS2prNaqtrK8ubG9aHM3ya1J4MD3/19cvbyyP7xv4//+//6NnqksHpT3/8nrzG4vyROEBvba7NzlhBwb1n8TJvxyhwUzZ7jGeK0dNFHfNZQ7VbjZxBeeozGcrFwibHsRFOOmwo11hBvTIvVlW9zlsfRlWi3k/jA23O0KFLizGH1bGjFq2syUIWwJh8lyb6bDOj65OEgimPvn1w0NvYaL7DDn6yyGZa2HZFkYtKyVT0zp0h06PTsYGQyC4qUUpTYR6VJVICE4IIWloB41+WnycoC1BSEGwFIGAMwIhGNjg7Pkl68Vb8YtRtWjPlw6gYL3AzUqc8uspngW6SiTAgBjAZ4aP0glZSTKFMhKpZVfMVWCkVjQ7SS+wtMQpIA5qAxjDsZ9d/2zwFiMrJwpOBYsAe4OwAQJAU0Sqv3iO7lKja0mdbKVChgIexp/nnFHHAh4fuV19BUAXQpHcFIC6xxwti8mkIKDEoOSVNxZvUjpGEJoVEPilOwBVM6gUZueAMEyZ1n0Cmu7MzKqjtzxrX5ZSCcYH69ts/G2lkkTJ6hzldmwuC78FN6NbtZsaq48glUhAdrAQ7KMWsxjKhKfxCVg6uXfRIcqAP3tC+UmpT1+mRrFzuVOTZ022L44TFyUnfOKTKZLdpbFb30Q3cxzEb8h3AdTh4z6LkvDZSiDvhiFWqucUf37KiPFzespx0bx4n9t7vjtzeu/YLnemMoywqbqBp5x4TcCrOgINbeNmTls7GsJjIpO22HPNOai7TOpGCLBhNvXQRjUT+0gSN1ngXqyMyOFakLdjwuze0YuC29mGfNj1d+elQ0gNBPOn/hgrNpEW4ecKKmH4wtklDnLSpCdGoonoy1mUNmJ2bIhOoGgC5RNGY15iF37kITTqqi0dlyxkrzVUCrRTE3aidbxwdQrtMjl1Lya5Ayrczu0jq0YnozgIAAqR9VZbHqHbU5bC3HgTV6hEYyWMICN2aJVYC6bW2buJTGqfNDGgoPoEJTlS0j+cUZV7uTqT5+a2tJ/QHra9beazDcJG0+Lm8ug5ysasuiUV1dj2EtXDXMbGjd1whoBQ/7KmoqdgjMyJ9nsCYGnVOILlBUKJ/kLp5QFTbGogV7tROmHyz07P+0TsxEZyjuWgVUs6Qj11ga3zPRS63s5dn51Pjs2urqxBAG+2omXjNngxO3T9yNkzz/fLXv373/n8aDIcvnj8n/SlnUMXA2R6YnqqvPxyzbZQ7+xi2y/LJwf6+hdwvP3+VUWf03roIlcJ+0+317d///V9nJnWZS/oT29LyYtfwYyno+PA9qlpgtdHTlJ0JUK+kfFOV1dElaZOjzFmZUSKIR8NjGd0KcCViDOOrAwvMUoKWxtMBfFAHb21W0l+8nx4/sYL20z991R7Seyqlt68YSAKFQYWibRpXPV9iReBaLStcXCWAOUAW8GBsNBWAtEdGAMNZLU3FVFgjKVcMmGIUKpewcskjuTAQtJWivfncSCO9XL5SOwzv0iR764/UB6JH2TecYay+N4tKquPYX4NWK53ViD6evSSS2gHI/Yh/94y7O2fiMjyVAwwk4I+Rg1UeYlBSBCAKVZFQv+5pal7t0ENkb2miqLnutcWohRhoV12qg4UgmCXeq1kvKQqLBFMVPJ8IpY6qtrS04JME4iFf7SWmKCZGlopHCwV5NjdXsYXIskWK0ShmeMyFqytdB5dywIZV5W2t7yKO91w0ySMMpizUFlYLwAsxxYEDrIwYDt1Ux1fxKiI9zY3lT+sU/iQFicbrHMUUpKvLCHnpMZ4jf/Eu+Nx+pPTJ5EEyvcVEqru0Yp7mZJXxCR4+1LjpwanzX+73j458pYjpEoom4rWLiQuAEKBqIZfilKK+3G/ATxHtUi1UV69sI8j4M3DgI68MQi93z01H3SHfWaK8PSRKs3QTzbnNbWN9i5AiziAPCGxpVUz2epidnGaQdRdNBhWXz5ydsE9yWTGZM6s1wPga7yOLZObC0ceySESKyo6fta2maF91N8QL/ZBaWZmHNA0cSxP7YrEWHjbVi3OTwgyHjWFUgfGHWuoAIgUrXGeLCa4d7kvP5bdEMBlcIWX2iT76ZrUsuay2CqQOVYMa2Ch2kEJ6bycDoY/WQWTYIzIUpZRRj6hI8WLEI7gw6FrctJuqLpmC8LmmEanJSuK7vElD25pw2OvLiHsVoQmkBxNTKcgpbzQ9Mh0w4pJoJpDCgcw0LvAglXJUchgVD1irk1LRvhJWOZepycA2PGflUkZDRtWXBIeMKx6RWkHQk4AF0jkWYmwRMSG6cPTz3YNT23Rvo4taAKggIzNm8CjXDgLZDQmEbyxI7ZAMdWFWs8fw9//wR/YBx9XtHxwRP/Y7rq5trqxuOhmU0qNQKNGtke7v/+53Jt3gKx010FBxiIDC5KCfIn0VWZ+85UUuertpB1IB0jAc5+Icue+zKDSVtHqpQHaLtXS+Su0tgTIiBZtHihgdUoyfalgyS49iTUYCZDWAIzpUqu0lEMYfrSWsS2S1ABBZwBc2i1ANdamyRHoU6i1NrRyioBgJgJLFDELRdmgoFGWFEV16X3GPquEJNUKpylWgclV4GxgUZ7hTeYmxskbCeZEsj1Hk2elkJNxRQ0pZZPdJY2g2bj/QEO9RXFEZawtII2WYow1FfhZxYCJQcFIRy4wN2wICB4SSsbFXVryDZcNTQQWzwBIO2lhiAL3BFIC84kzGEIqWlvFlZITVdX6RZ2rsjOBLI4ytSS5hwFWE/CKbREqg1v3ekYzooFBKlnJ5waMJrwpAJGvLGIvKbSiZTLZhuG0xBxPyWhBK2LK4Uy62C+WqEWFBc6eUSklCScbuh0/ZfJQiL8SM0yoSyvPC5sw6+ngyHDBQOCmN94tGOWvHw5mpYKTd/R48nTpNKjkYPS0+NmU+srG57UA1N0c7p2Hv4OiLV1/Nzy0a2tSXAvVkY9302Sy+MXWIrOKYxziLkoDQzemAUs5bAY7o58Hp5ursC8UwjO6GChgivcTyqmlVECiUwaGGbYktgjJYCasmPVetjQXMd0vOpHQfAC9GfMKyyjRhJsd83WZ71lmIZ/N2/udU19A5Z9xeRQVJckXESGj4Va4zil0a07SPVARWEpAM6UnmMs1/jG+M7ek8rZCxGiV1wc/8VSb1xIhUNCeWLvhikfsZqZXpy+RRU/5K5QjCDTSaZ/Ob3fhOZIiBVqOHb4X5TcqMAuQmZ3O8hD7eNnh5e/CDjCqFOtIT02BW3hIOPpHU1CEDswtXLKnPMWeDcOE2jnPbE+YXZsN297crqyuGLpMr6RGJU42+6Wae2bkzY4hJDDrR3BRkDZh+yrA0PsL+7Hjwu1OWoIvr0bHp7tL68elFw9mRy+OYTS49AVZtchb87Schr31lY9Da5qucuwgc+5Cp63fnmV0+ffZiZ9fmRGXM9Nwpe32FP2k5JIJmQGHrTBiA/nB2esL7zBwOqyBIIc9arMfkh00QnfFjg85Vr+kwc7/81Xrvf+tBg5ndiOjgkKuzSQeEWLaym+TwcF/TUW1IOl1Y8xu2sRnasr2qhaYRJHC0iEZHXpX1iDQqxBwBDz8qVmqPbISC5hep5hpMzuob0uMDXRcgYY+w7CW/pKFLVjyo2jWXvkb9j7OBLJJ5qzbgvgoUQiBEa3fp7lS0+CrO10ojr/TiW7Kg6idhJBm5YmpqCZD1Me5lfEzbcW/Wn6sUqxXKkRcoglnXUqSOro5okwUJ/X9yyv2UWbFVZUZlzG+KQIe0FaGtbkkjuXJhIqzKxceKQD3iUjyd1/sDVo1umkGhYEqv4j6RMpJxT7RoiT/E4wxAwEQHiZUCyawURAJm6PWQICZxJvn2O0vsEwpLX1/lkl1iRaysZBpX+EhJnk5eZXKmLjFXEyfNmkf4srnB3DDGWg3DpcWuZoWwo1psVbNL05RDhwSZyVURa6sbGAi229sdP2PxaE0wbn859SRLEKkC3IBFbQJdTSnd0GCWbpqsJPfW1GyHtneK/m1zEpVze2OdSg5nGVWy+EGYc6WL9GzUIW8nR2fswjTruhrVyt0+3n4ceb+z/+LFZ25GdfyjjvfH7763bcQKGsePn97txol7ao6C9n//D//F+z3net52V5YtzMHKjcB6pcuXDXkDt3Uz7MymFTxKp8ZaCaCYa2bm1CyiuCPzcI/qSFJubaxzhIve8HCXHhVrKmt7+NkwjYeByKxHk0XxvvUzF71SNnnpaFNCyVYYOooM+Ex95XHUTMQ10eTg02jBsw49zrIG3YIz/Kh14LYnMrqXcs0LKWyKIG1pe2PXY4zXOmSspm1aCR/iORLU5NVxfnG0nXDP2Bmt8zqH3WN48RCwUbfVWniMtc52G6OpzoHxMTvETIu1hcEoXY4VtLElHmNdzOG/bc6qdh69I5I9emdYtJihSApCMYafOg4zPQjC4j06QgA13xW8ZD0SAKzrlk1HdtgasTnfPbb/+ujo2ecvJSOR7MEloBSXKiCl+zCOj6HJ8OjatV5vMEnfzn0eDJLpVucXtlmZtXA20Y0npnmLWfxxfadhfWJqMNjvLi06xeP03FhvQjN2O3vPjAs+u0WdRzRp0+9jnHlOxx9cEK2b6Atsb4qwp+Lw+Nz6CNyyXfjcjHbhauxxqbPEBqriOj50pBeO4nh3Mz+7jP129veoKZQFUywrqu6Jswpow7OKuHz04ub6//g3v7u8mx6bnO4d7lv/2Hn/1kr0U5di9g4zzjcnC5TUUnoW+lsOoWPRemEixj+RHuUaLzWrHo0alF1vHGfbQQYArFD5BXzwaButEhDNCwgIMeQLQNrV45PExD0aCXiMh9rAJ1M1ECRYX18hCDSwsctQ4w1XSqWweKjgKCl1SDgoQkq5REoGoLJ8BbCYpoYf+FRMKzNoY3GDG54A069PyeQVlhjYdLE45KTTaVHHzPokC42qisNtEFBBWEmWdrrIfA1MlYSA7FLCEzSCUs/XReqnQgmvojjuh7zsHoyuHxbdcECKa6erk4zOdocAOihCdnUB1lcB8WKME4qUt2IExCuCeIlkaaO1t7IkLpQKSLWRSCXKAiY6SKZSqgasXKStcwcF1Mi7CCW9ZHBm95fRBHl39+iLL178/PObbnexgNSI5atkxlGWIqYbuRBHs0ANQKRgFVF98z8oifH2oBW+ZDSjhGbrLEcsV/RdXM3OTbjVi7cfm4SKGFkwtsSUGoU6O4cdh28SlxkW+RNLWO0xvzSZdkPIkkMfd2Nx5ufGL3dtnYfGwo+vX88w3ne6tKqDo+O/ukLk7k6VeV46fs0UeGF2LgLUOWttthfTTFNrUINEYVu1NMpL3JkN5lEng97C9PSzp5v8F5xU8f7nnrU19ASHXyZzCsZmc7m55HVjjT9DrKFZE1gJdV3V2XBA9bMYML/YsfRoCfycje3xyrqB6hoCeAVzZ9BSWpI1Uv0oNLoN3nM0Ba0aDW0pzabL5rwfTmbHMQWMOYjbkAWPsAfKGxGIXwjgCTJ8Yp5VKXPExgaW0GMtIeDo3vGSd0lNjviOLunOE6yo4g4Ak0btUCy2S0pezMMT2RHVuKW1dWbtaIVn1FU8VMW3VpviehsysrtY78pEJByIzuw62MYntcAq3h655CUZ4SyyIMjCaeLlZ6/e7eweZrvX2de/+s1nX/6C56Xrd5683OZ24AAH3Gj5uru+ypCXoycJAhZY3jKx+41M2P44EUcZBn1eK5GB7ghzzsfVhd191j9hlrnCvNE1I+5lzlsOhbl+YWC2JmN8Nk+yZT+Os9G7q0Ozun7q4GBHw62srVh31UQUeQqOs0Vf//UNnyw0MSibHjkFg3H+/dvdFmPnRHqfqtFpruw8zpaa9HpH8nQ63dm5nPh7eNR3pVAYfHRiZ+/93k6/f3pupef9zl/ZWe14NwO38PDtt3/s7e+t6pVhzuG4a/XunCjeuk9zzgwDZKOymy3+rQDhZW4Ab+Vmt7+vFClN82FM0BJ+eKBYzUCaE4vQ8hMHiCfCNKS3AnCAhkcvgLw1XohhRt+GemEZ5dLexTEqJSxGGumFBUTW1zR5M1RpsEoAuMiCJhdoslSy4h7MVHkzaR8f501h1kYXM7gRzSSvs/UouZpQjMl4Vr3CYwFCNyOBMAsOz2AIa6cxLy1TkOXVJ9EBGkqsqgEXiJnJictHGYT1XWEB1WXUE/BNChQDRNF+qqNSUUyN4OyYLUfPsHjYEWM2VxTwVS5h1fdWaBhXGY24IGaoN+0ArgH0lsZHSKqOLALIIKYGAD+NesDiOaBS5TbGGLc8kpGG7vCBDzjGM+3F1QeeIPPbMXM366Wh8Lx2J4NDY8TERarbQS27c4VVFi8WwhRNeT+1DppwQdvfH4IfFS03BmcgZ/yQni7Js0Wf1Gl1Hn5vTn/jfyIBCB6oxruDpwC1zYCgfz48cMgxcGJZ3Z6UJZlc/sdC+vrtezscr24ff/u7v+8srQxOL396u/vyi1+4wO+Hn9/8m7/7vWsC19bXbff99a9/zYTaKKrSQbiIiZ89zEF2ABgStB3kuZ00Ew7ZwVXBXdt2ZvWt5H7+8inNzbE/vEEYhpw1RP8/PztxQJB5N0sXkeSnfad0+WmzB16EPBVzJtVIu534mh8XCE7/Z4W3iXTOTZjc2/gKO1fAjtAL+4k4RE6a/+tYuCLHCdAQa3Bo5/KT4Byr6ALZb3BPoc7OQ2yM34xk2SM2xiTkRDQL0tRWB9krPCofs09nbsbqosOLFNpmZeaUvEVi7yb6jc2hgBOHHMuaOUB8/5SkauY04PPaAMn0UQMhIDJSiqyvNdNZ9HAinTTXlDospqLbya5GIiUW1r5YVCsIS+aTviCyOoIsuBGrC5A/A47UY2NLq+tCVlb5WBt6qU0aTulmfrkMnQtDtncM6eFUaVcvWGOCiRHIO5Q8v4q1J0dXZQywlJdVEhMiS8Y5YzndEw4WsrC0Ed2UVCPu235h9vbRRZ6BkXgzbnNjYmmkHjHpGQa00fmZCe3Vuo1qG1vSF4viKOeQRy4tLHLd8RNXqyOtqHQOahbicMQDmZSmwbD3WecYn5zb2TvsmwONzxwNzqytoLaLUTY31v7Pf/Pb46Pek80tTkU0/dx87WIyTTDGrUt7xT5hPgoHtBWvxCIs2UUIOQBV7yOfDC85+sTBhW1DYltBsvbRxnzNRnbIjMQ0ghqZdQlNJQFwRnVhOYkb70+FyWW0ECMxIEU4AblKQdBvoQUgYz25ADlhrIADfGoLI5H4Zg9AVXGgwURBYAqIFJbR4ycWESMMJWEByaAtu4L8ROIawDQUfECTXqOyckhTSMJNPLBwQE+R8JFdAp+0EElXAEEAR0MqS3rNrDh5PVWuvOL5xhbO0qtdoS2LvMJygSCACE5FlaXMZaikUMjXuyAUceDjKeLDXwJvKBXkqj7k4YCqhRsywiTuZ+26kooEweaAwlzVjCCUbEs1vhYBqflgtp98ewhuXrwX1dkU6qdPBg9dRRtZgXTPoeqyn/CehHmxmmqqlJSY58mTFahqgmoUzdHWmQkZttH5ZsNwadrq119/tbW1KRfjvsToBkkyRllkgUYBBN3sEYMeKvJGzI0LzsDoLmsMx4Tp/L3h6fTcAoP/2MTMkxefn13dEhlE1rPnL2y15+cHJS2FUBBjNqXxt+U++5BjVgIZAqiqdQa9o0H/mGMMCUhjcOErWU+2ZyfR461h4Mn2BrsUUw7HJNvziHcyvuPykJP++enACGDzf2fWQivLDU3rhmC1ooDmOEm/jIS1+Do23s12Y4U7lMGNQxFkWlNbRyRlAy0fPuuaK9gT7+M7Qh+/MwoZ/NDBmqN1AF81H1mGyBggs4EcZJ/iPI4a5RvKSYYQIcTNukglg0Yt8BrAuDbxbyd+DUgmFTm2wuZVxzJkyfneH38HuypRRl9AQ2wGQy2iOM3k8ROjVnGqAAdhFdGOeEbKCmMhAZ9A0AQILq/0WkSATKxOCqyANFxLFadQ7cKmJyUBmytWmiS1KEp5crNIdoddUA1HnBvKPc5GSdSzAGqaNbTT4PzCSZxmIpDB0jydQjF29jGmn3H2JTqOZQMrtwk3Ky6TnH5hwCbUKf8GA0YeHQsFMJ61hHfvdtBcgxl3+R1lypWbLbD9lVlp1dcinNFdWK0d36/L+KSOlOe4OV3R0uZbX4u6pspwVhEC7i/f//j23U48h69cqWuv2NPVlU3bBY57h+/f/by+xt/h5ve//zu9I3ontsh5pXZp2O85D89atzA6pGFM4tuD7WHigQw6zNnh14z2lntQWEaKORzKisSWbdgMK+rb5uB00MaW8UNQKylBwV74KUPNg/Nv54hUMVQDOoI3vUHnYh8UkEwMtmP1NMfFSu5PFeDEf3rGPfrq8OCIP/jAxuuh4Zyr/ghnDbSGPT4gDvAHLMkCzUMcqEbNS3yFOuaT8nSg69lSYyP0NS53lje9TMAB3zqblhCjIfVnp/c5WBiPUi2pMDAnlRBIGM5lsvhIpoxzSkELD5QQs7HRhUhPcbMABGCIgsYzWUCTnh6HU9Mh29iDDmjF8BDn4baMhiHSGDSjZvgGQUbpQQAZDmKEleuneIk9fnqLL2b1U8pCRmeDoU+IJpKbg68ecCqjSAwoLOZ3v/sHC61YEDIy9vtDOOtp3qBJJhL+OgAViaxRtcav6QbxN88ZzoRpR2JgUQAfC9gZAAFFGCHa+jkREC3BV0oHaOyhzj3kS/Pu7U8mS7Y1rK0sffH5ZyhfDaFcOmytrhuQzNZtp1aiqQbcjB9U7uZx4RwFpz12CPqB2zZOzgwDo+PTDoz84suv3PhrgZBx9/MvvtTh/8/f/R7HFxHUIq3fZD0MVd9KjMUPqyDU/CjIszPFYI3/J22kiI0ZX5KGDmTIxNomlSFRSbW3r4EkZUyQ1xiwylc9e4NNK3O+ij/9FL0o/+INDLTLWPwJ8rubUxf9nQyQw0TBn86lU3TsWG6ncuICqYiVYxeaRMG/6y4uM6HYy+ZAtM5814Uadje6HVHrkEGaPsbMJvY1R4Awh+qY6YS5WpKkiFdbVrBvuDkakExcXH39dHsLlr5afeAlaqnAnxmDdnbwjjWjrGPngopHtyXHW9QWbgcnzM1oPj/Tw5svkyz+bOUxtOsL8MEP6JzBaSK3FYohsrVvsasWEdYo2lSjCGOStH5LL6NPxVd4CSg1wiGAvHz50rSe/sui4tPhcY/YdzT3cT87OWbNRSammr7PtJ7dNGFg6yBZyyOmVR+Djhk6GW0uLt2tPWWCa0zG8yhmiRWqfLzwOTOpLqAusNIQRH9TdJyceh55NbCLbUlarUOuagUFScaowE7YDAmmX7lTxGDPDmPNnw0QQESQ0aXBmWdPTGa16f7xyy9/8eLFy4XOsrkU+MzqtkT86c/f/fnP3/3442sg9AKzQ/qEg2btzcA8GJKtH6+iXoRwlIE4UyFUdUlTQ9MUX9XFiNv4n0iJ+qgJ8IsxWkurdNjFQ9CguHRg+VltU8xUgkmbSYNGdUKTNEpSgJ4pIBe4BUcyxQjL4qtm87Viqgg0Nd9gbJRGDNLLQprrkNnH3MLeSZT9RPanLIDjp/SSeUPPo/QwR9vlL1JYLgGJZfRT0bCSTKRS6LOfjPLoUjVSO43k6yewVRcFEdMKvbiOlBQJjgEJWFwi3Lz0YtspZFTQJ12XMQsowLWHUQo3mzuDIIGRTLynsMJ2ssgOTwnAVIqf8NcfaqgACgQJKo1PRKywjNrVVx1DYg9XNtST2CcirQgOB9YudQHZJ9RWULcbl3+4FfI8w6poGfVACqJcAJoxULLoL6xbIVezIEsJGjTkRQ1vwsgbSg7fVDVhjwCStob4MPBIDAgZQVXgB/Hq1TPDw4sXz2VEh8qigQj8lZUlRZxfZPgPJXPD1Pne7sHi8lLbrTVq4xMnn73Do9W1jf2D3vxCV/m0MorVGwrU1WV/eIzv7g4ONC4gcAYHMjon5YCfgePxFcoCQ4ggBQUIuRDEtsnBsD8/3bE9x1oel//O1LxJ+Fg2zlxxoSfXCcT0HW6dC3PjJ7br04bo1wJj9tahITpTtNUIqen6xA2DBKVe9Vvfy6STpKBRq7vFyAgdW8E3Njqdhb2D3uT0ol0CBJUdbfYA8NxXF/6BTA24i7ygRtuvZj5C9yS7yTWF+pURJ6YtdsxHrg3GM7oE73d2+KTkWhpdJ2LXYBx+trRuIrIwj19VX0dhkIrDhgs2SNMmJqyW3T84iUEJMdBJVtwuLCoVacqKcosn1VHFGY8wp8RsIwrCVPgBWXzCFRqFbEJ5vV+PSPq2MlzSBokAp01aPxHjp4OqgbJ9i+2RTfey4zKGD1tVnAuEAXuDIXalCRPSzKL0dQPaYnwL+aaO2+XHzMV+QfSzKa2udGwsYKszJPjTH3DI9f3oheMioijY3BXZhUsbPnE2gh5XH+drMfsY6bWCm1iCmGnEydnhwYCr0unJBfdNTWUuFQ8xVoSzE76ta4vrrKnwZ9Da2Np6++Z9rtqY7/QHByxKtsG5g2x/77AGEml2d9+adPz005vpqc7pMOPVoH+QsSx7TTLFp3AgDkXEcloblWMMYHCCfPpXO71YoxAl0NZuiAlVn+xiQ22f2qwuJndNA7GwQrVB2PHjSqwY38RIpwC08EmgxUfAecAtJvDVJzG+esvok/TCCqbAFAZAAag4AZ90Dunl1U+qOBnN+7efrEmmW6qSeN5TmMlkUEoJgJVdmJACVgILLiJlgYNmc0zC4nVXStJkYWbBoC+9g8GVy5PcVyN55EuTgODgS3lJDWaoVDBOGR9MQAXTT+mVpeH1vVSonXuqX4lRFXyGSMLtL4ta0lcdTSxMlUAAqsgtoO4MxTR2RQtT6dVCQIIiWiJ1Cf6R9tfMTKuCXZd6Hh9FaACOMhIL082hrUTP6chpE+7d0pUA8VO84Q0CGEhvxzqYUi4zR+YCJ5SzLTAWqZQGRg0In10YcZd++uknzftP/snfuJRNQTQXsxdUNbGBAD4DUREBfB9LHcx9hZWwrwIGJG2E59SPrI8R23Yap36af52N0Ky/+vLVy+cvoidnD+oKQwg6sIkbcmjHJ47fmo/CaLn3MvuMItOs3Ti+jcZ7eHSMHlH09WGeHqPW90JkXr0TD5OunljuRseEKqyu2zEkcbJpG0dcgkaVBZlcs8sGpzPjoADDPUstyuug5hzWT9lA3OieO+iz/Zu/YeyQ/GeIXZyib/ipsqTM/NT86eAEo0LBEEy2Kp3u5vwf0ldBBBq/lXKbmYnhU6OMYFE2EQOt28kRkCNVTB+OsuGlMzNnrdYxJ4QaHiN/iX4B9A9b2lzZjq2l5+TYIgsAbQSKgmfv+oSviTA0qVCYyrXmFLu4LRiQIqNN7qkfaIr1sK/jYVFVq7EnmP/LZaYOGIclc2h+izBXI8RJuyM9bxGLaqYYGXVQoxG/jQqKa701xBfGS0hnuPWWF/LAahEzsCDfZIJ20RwS+ylgYBDAXQg4M9+1oc8Sy6/+5t/95dffMHJ5nJ0ii5V4LOEwEtZIuyCIGZf9AkKixCZzlWpK1uTvvXbADoPhQG2fbW1QBaiUxk0qsvUAQgtuuhUdwgAQZ1PrqtGc5owm8EQblDdSZ9FmetEqj1JtNTg4OrQhpLu0ZntXO7BzhFbOtLDu/FQLhLe2Qy7Yxm8miQ7qblXGSgqXs4PeIXlk9WdhbXnQv6A96KrfffvdH//4e2sTzqgyb7Rwydfo4mRoX5i6ZIO7OaATxUmazOYe5rtdwx1UHUrMnIV0Th1A3sS0lqqFATHoaRimaqgUwWBfHBljXGHpi1RFJrVM/ymLj6imEPnZ2uODP7s0GhUOHgm8Q5smCJAQiiJlEempGLWyQu6TgK9IXBnrDbhPGAsQ0hBARh0ZhUHwSQysJBPDPCWZGBwATiB/xLYSg6kiUnp70mObJPWmiskIYBMRH9R2CUCQXucvCOATkYUkCMr1WBQuJMHxs8qVshXyb1/gV6VEFSY0C+nRXX9AeoZsXb3AAkhnqZQ4HQIwARN5q4dErLTHT3hCCZ7e8CRSaU/CxIcHKJ8ITTuBwfTIIjuAMkb5MjdvP6WEvEhYKchb2DQAKIk9Yuz8cjwOm0zFOHqQZoqngR0Mydz0T6U37opE0P5sGEUNWQpnSKKAR/qKkVLRKd01qrd3a+ta9uHp0yd6o7r7qul0KfhATHXICxmDqutfo5oRJZM7+wdEsxM1FMS2a4nDcQrUf6bVuzT7Nc8NY6T1TdRYX12FAFoZDvkQUZsoMnQf82VYIYhyTcANv535UFVZqqlQ5qAYP12x0jjZeQ/m8E5/aLWzqkbhiNNLrAnXE4R1zAuP9xBiFya+DVG0SmvY0lt4vHKZ1HSOvPegobtPlG7eioxkTZYx7x8dcUM6sFmrBL+F/om+7fSqTPLMW3AxXxoMKjtq4yVIakrwMVx6h+FGd2+Klyx6oepofELZPmB/mZdmZKCt1Pw4/RQaUhYoYa4mtjZmIbI5FPGVJP4hmU0eDEHDHHw+M54pOBykBwEC3nhYIF5jTQskDtLKzQANjRyg0Cy63gZE2WvaygFfg6la5EnrL5jwExdB2AK1c/okQFt1tMhyOnBo5v7m9qbjcbCHlVgdisqsR5Kr+hf5TkaLxCSMlYxLEFOcgqBJCXQKpzTuZrlZcfmyFrt3aA7Jq7UseQzPnD/qBLfIRNqh7EP3RnSwejRgddEMeyZoRwfbm+zy73hRON7GuaTgj4z+8PbdLuDrm9swiR5+MthYXfr8m6/5+7kzgM5mUjKXI6z7P//0fntrZWaaHkPbDMzf/ut/uDi/+du//T92dt5fXceMlpNYYnFz5CNBY6qQhuPO6hD8OBrYm+qCoDlzrChPmAH1UFgjkzk2KRZ7aB2ZqpnQsLV4Zuq+6n1o2wIj2UEqKcaqdk1JTW6qsybBA9JJ4CkQurk2FqmZxSjYJz+RqSBUoOCIJ4MgGgNZm480dsmMAXwZvYUru06O60q1r5m7MBbRHvCWDExAlC4AThMcWZ1OGzRZA6Q+D2eQ8QGweiw5/wklTeNQn2JKaVRBv5JeKTARj5ZRt3UZrJfTYXgSRu5D4FNBH7kqWgPInqqa4qDhGD0x1kX88SqmbstrT7uAjDvv3ilFg8FEiWrhqxoB7hGvaD3VJ/h7e0TAhMRxjgJjgjQexmsZPerrrejwffOd8FMA0ZBFiSAoRRY/Fc2b2BI0hLULbCWWAD19aghMOkNtdXUFCwD45o09JgPOM2xBUoYsbQxG7NbWaXR50TBot6+SVev8+ONP3AhQOHX4WFOTVLclrix1V7nkOzcpA2psVijML1srwNxOGco2S6+lFMdnTK7k+KpB79AEmAV8d/8AV+i0pCfJSO7Hh/FCTZdsGCDjHOGgr3JzUmv7Lbhd8ekMNdwbbNloKl3FhlG3KhrbGH3OT/rO8GHugy2VUl1YKUxQePksuFFqtmMAiEM8XVzLEOsUs3a+Kds7ZVsM4es6afc3P55lB0BcAJeWVdzkz0ii7ebagj+0sRMJBQ70DGzKsmRAF6bFE77GiYmc2jh56ahOB/2cXoxMzhoJDGm353oKZZ8w0o8mLcPFbGVSE8Rqwp0OYooCc/MD9xE/jt05sgJjmCsaczSKR2KzE7MBiTEALV3TaEpNH7JEVXI1zaj1Uj/b5rLsqCdnSGISI0OPQS6anzN2nIVgz3Us+GQfOPq0KqgRLsXempWlW4nC0CBhtK9GyU9LOLF5PpKzhkuihUcI0YkNYCUBTBDHQZumpNenZ67efPbi+YunT23HXVlb5rC1uuZAlIfeUY8OYbGcDeSzz14RCipMDsquUgpVOrZXqBPN2XCebNOTeFse2+LNF4v0pwlklx3x0oa0Nscj6OAengREu+B2NiuEtdC64+CIvf2j3sGbNz+Zn1itx1pmDn06u8G42ZFMtd0yens+vDhxxekiDlcjrmivf3yjd/zlz39mg11ZXTArg9i7t3uvf3hLkXAAH84xcPMShPb6+jadny3R8eOkZ9YKUE0L4ireutb9p82ochA5yst4zNvYWMFS2bQ9DRV+aAuKqqNc8SolvbeWVTTyZCQgI0SphtqCpWyp0c4wq5FEJkNrZmSVYGI8Y7UwFveW3lfvihT2FOkDbeSDai9GkSBXEd6W0ErsCjeZFgMcd3mFgiYxOIoghqhmTY5kJbZKAa2QlNInSHoEOF5gXNDES1OJgSrmloV8eRgj6D9cNCgLPoMAtiu0ZZEXND9xAFCkOtoJw1YkILIgl5naJ/jSQ7vyCmBrS4uygC+ScEFMRcgrpexo3viGx+ECDyGR9QnO4VeLdB85GBBh8Z5CaXN9g8L47bc/MxqDqUbsM/Zt6SpqWu1SVQDKw+wrDTggqIK8lgoEVEq5MARWwDzaZB2qV/uHCAKUecDLl5myfPfdX7e2NggCj5TRcdqoD4KAXgSN4oSI5uYt1qiUVhAvFyAFk7I2N8Gdf7C09DdwIO6ccm6Hp7lR7zDzDOYtHOfEM/erOKnKqMn8avjBPi8/f2XY4/8Tmpxfuf8yy2XvdpwhMRicoiRxQ/zc9K/VUaFKh6H1VRM98yjXVOZGkcl4MzsSAmIGQu496ytdRFAvSDL9YqF7an1rJmNZY/+YWUSxx5t3U8Yth7D/EkCXXMV5gE/NsmNO2LTAasbYT2F/CM8Qu2iun3gXKQolwKGn0Hhh3dwxUmtxN8bDi5nMSaU5Hcfh4fwqHAX0MG6xwbF1SI160AZM8ktXiHCTy1khmErQxC4TAdhQEpUo3Hq4MqVJCqNjmxBEtCGPNB61loBOb3JijCNBtDH0VISxE/+QNPLqCMX/sgBn4A7A1sVUxKN9q17FyVhOgrlulAw6iiI0kBh8JWXzXjUq+BWOlQWEyg4fhVv5t4HDsQmag3uSM/v/8Pe/N3v75W/+hmmUKpU+/hBPwsIh06lTjJGZoJ4FZulPRAdvMbrcydnw8ODGqYtqYU+WXaIG+5HZNJMhzWCmoLYoijZZm8HSj64IoMqfnJop8QFjSGehgLBrDJyVaSC+yPHEcdgyQHJnMO664xP+erf967yQTgZHr29vODr/+Ncf2FQdCEZM8x3qHx/Y/sL6hCEH/VNLNloA02J4MyPiSekWnLhjj1jYmmGgY3pNk6kXtrYAoJX5k0BG9Q0I0MBCCIIIyCsZgx5MkFQCFEWu1ugYMi2FDXySKymRTKf12w+JxNY3SAAhv/iKUV4Yo6UUKZyCmyZeElYripGlAqBJDD69CwzpAZRSFp9y3OdHvoGG+aLqqC6is1CRmPICJReMZdR1xQgQEzICApQEGALXcsmwacjxnpRKbYz/CCwpIUsF0xfAYqVHJrNZucAp5L1b/4gLXBbrmn1A7UQb/KdG47Zl6KXZjKe7sQOzJYPHc5peSAPDwlQICJmM6785844JDs6FpJpCg4weHB8f+tEWTvCo3q4UD5MLSw58ip4S4MiqHQhwoM9CRht5y0UI0iK73QzS+LvaG9oy6mO6BCaQsZ76CpoACNoUeaXUPeCA5yTztWotI7JjSsbBvd2LX/3qGcR8JQGYDh1/CVuCVBoUxlJwJnO1rwD4qukB0E+4mTcYCIGio9FYTVsdtuRUnJlJbv4qvWo9gPEGTExOAKga45LiIvSzSpodhSzd77Oue/382QuO3qQ/H1DP+509O720IS1eQd2FZaaeqztrcqcWcQxddDGVZYfFCZZ2NRI7RawpTdyszq2ihiHeZn8HjzsgnusRRc3uX+kZl8y0s26RK9uvXPfj/i9npNJx8FIOJ2g7Rahk9/bgjI7ZiMXsu987VmtlOZ6MDwpFlIjB+YxIbNNojmJEKhEwNz1nzYN1RJWtQ8IkanWc4uc4c2iLHNODbVw2Zs3pglJsSQkzW9Vw2VN85GwV492OaNiaWMC3WkQRWY6emNLv9RuU1HV8F9D7MI9ujwDaSJcmK/UFZ1D6o4r5zMyCJdjWfE37jhJ23CijUWoFVwHLqOlzv3p8w7KiA5GIfRNU6+Rj7LduwsESttk6+GgRPzu9SR3xg7ojrADIqGR4wjYUZ3xoKQZkp/NGv22HnCOIXDjEAKGy4YdJZy1QsO7+8Pd//+TFc4MV449krOmqBW2cz4bGSQwCxALLOyFuLQ9busCYgLCjxfXA+sv8bPyCpJeLAhWPeg5IrKAX+sgVhjfz06tt9jYJehg5d+ST4YHHHrdFEkYXJ8XUxfp6VF9X4y1lhdKZwmaE1tusiJEAnTmr3Mt7O+9UTS9wXDGaWFk3i9taH3fK9ODkzgC0eNdBUrtKLMXZmZHt8fbudTJq9o8Ory45X3WY6jP8OHNQoRow7mjkeDqUVRgk1cWsz2XqZvxu0hXRVF/daZLCWgoPoG5YIA8ZHo3E42tuJab3Sa1t2uc2/j88UMp80ooI7asmAdSjxMBoppjWlhH3Eni0H4RESiaBJwVEy55GIxY6N76hnRFSAis52AjGoMlln4dNS02Z3dnYXIgilcOl47APeTgYAACsjlTl+omxFNq+ZsT79Ghdke6ONSy3DT46mJEyQyUioA84MopprBymEcaOLcGHMQw0yLMgY5fCUxbp4aNcAY+YQGxV8FMyP0XqNuQXNIBVZRR2rCU7xMbGmp8wVxY4SiWFabjyfiKXeECq1pen0dOrppABWdHGgPSKtqsObgAqywxAG3kwsZ/KTWtlBeU6mmbbeg0UxFBGcYoAQWIpBXCqNIWtT199tSnv0BWsc3Hc1gqyWLMqQQN5WcRIL6xQk1SYAAJtUwSkA1lZcWJz54ljBG3knZ6yZWppc+U/+A/+Q/7RIGAwwHVBFKCCmdVS/dLQOW/ydmxm4scff9bWLkJCJToU4cvCbiBhbOX3eX42XFlf++Of/+wETdwlDX6fdcC6S11GrRi5rdqcZsmyrU4S9wlqZs5ReNTZPJzmDQnEuPO4iAYLd+piLvXQXTAsXl7czRFm/ssIP+ZUKSoSCGYJWhn5KHTzo4Zhx8IgwKkZNordSGx1wPfMkm/UR72srY0S5Xc3rFVEBkUeHAjEwDvy6D4p5LVTmF5HWbbFyqkAlqmvyOgZ7p4GgCXnMfAIihY1OmI/1NTjBMGBMplusE0A3yaXqtwm5A7sygl0vIDVjmhwzHXjzHtTB0OMHmPdlwynHtHoZKcjaSxhDJaTCfQU/c+uJBqDe2N0JdcnMiPwKWNJd4aos5JIcGZ9w12W6zLnUKO2KGKOGBUhzDAxahijsEqDeG0CkIPpfbRMY17iaFjx9APcgqVB8NUAH2RMQ8kLW+ru7i+uzIiujfS/+s2/M2dunfXwoOqpcllo2miUDh7kGxVoJ3NbnUHvRPPoQYuLXYZ9+zVPhsdPt9e/ePUZ78yDg0Otd392oWky8Rsbd8SUK5wtRaGrIQ3bsiLHDWth4WhvlwkGtRCf0Qm2VEAHD5ujGMiJdXVBMfYx0pZlT1iLYC0rtMxHnAV0bD8b3vC1FK+WOTDRdghqkn9WjpGCoZJHrhnlqe2HEw9sgFnobfo0wzIWMhNFXmoHQpXBbXZ8XhrUMMaXooOqKaiN/VaCHGckpg3VsU7roWqrTfX8eRzJhIpMjXxoFS1DNyYRqjH0aqBh0GTi1HxnDqfqb4oXad6iVGeH4wnJNKSMHqIK20njKCQ/LXDVpE8BfmIRdIQBOFa9SXKywDjBMNA/HjjVJ6ZYpsnrWH4ggLioWQKITIeqytk0wRqmFK4lem+mJHwpbm3PCTPt7x7YPEJ/seeAewM4oRrtrj2yywgZmhrtT3pbZtJmOQ3TKBHPffDYkVUWAlYNAz5bQ7PpwYnslFBVBhMRjPCTbdkgpwiVn9LlGUrXCaP9Qc+oMkOVo4GWNkR3ursjmn/88UfTbUfzK4UmSEuYncimB5QHlikJhulj7bpgGyxQGN3EoCGsvNMEOky3SzkxH+LpRBVCVcSE8Mry6mHvGHF4pJj8xqsk12e7OGWS0oQ1pYl3L/vyyP384rxW06AsJ2QxhV6Njd/GIBNkzNpzuPH0hHPe19a6CKsIPZkqxlUUMuUyi9HbqNm1cXxqwtLX7NFh7+mTleHJ4dpKhxONzY/WR6962XlLSWlOCaOd7qKAfm8HNyuqsx/M+7a2nwPLv3t372DeySqDExeCmH87G8cWLS7/NvoahYhFB6CfXZ5tPdl0Dc5Kd5XjHG+f5uF+2xyfHIo5xs3fWTukuoNzwjAzs+yz6mhDlCHBmgSr08b6Kn5AUuuaHIwa6RwUGJcEncChvFYreQADYlXLBpjMeEfuiIDhCZv7NPFIgUaunMKdi++dHjRnQqC9KIYGEHuemRvC+VPjZ25Lb3IM72nGEReHZZ3/Jl5+3BFzq8TS8ObsZtzUZObsqH9+d2XgcMQpF8A4Pt08LC4v8lOieirOIYrGx9u7S6tWmdzEgXaOtwjrbI5FssDueO3rm1NnWEag8e90bol6jcU/i/3qOkf8m+FZxVZZHrMsNTzZxzDa5enEw8oDxXZqjNKtt652Zo8sGjGezHfUDsObQxBH2MxuDWNzPFst86qGDfOuuZwYHfQGbdjjrmMozHzo8uJc2KijOEq4rRJ4cmV9hcyQy1YsmsHc/CJpYYgIh7eHBOjOzTqoR7fg3UeZc/6/ri0BdR4z8+hDzOXlKNdcdIg5+4ftkAYNTI4DnCrsBXPxy+LK8nlkmnacGp+2gzp7Ng523mssiDfd5cYkS4uwxVHaU7vj3vx0zOa9g32mNutG9pWQCYTJ4kKpj7dtL8XE1EoO1zKizMyTfjFLqKetgiqugRiRJicd96JEjHSjhaj5Zmiw6LjJPXel3OoQzAFc2jKrs7oz4dbCGWs4EofeGFJrzWbyF4TNFHApdjSEc95ygqwd+A4seBznE4qeZgxUAaUT7K5BRg2d1ywnZzOgHY4HFCMiZdqsHYaD4AQcmvrUOkBsBSKVR8p7C9P7jBxIwAaigSUWlkwYEDMjVBMQLz2VRVgprSlNZLJqqkQKskgJGHNtNa2hCIpgSEke+YSbCTsNo8KTUx2lFCbwB0d2j5gCKD3Mc1JLrY/bhDy/CCWJFVflwkSM9IWzn+IRRUFmbY2V+2rHwkcGAQ6UAFpJpqB//JZXiUCJpDzW10pQhPVJXgVBQIwE0JBLLdivBDCrBEpXkARVF4mLmA1slhM8PhUxhcUX/sJVOrC+amM86qFZ2+bmK9JJoDqFlUHLCCFGdRpi0R0MOeIPjw4gkJll85sEUDIPsMVAUDJXQw1VXlqmQ8UkBSvzEiZ4zSe7SrGAZyKiNz46XmIE62+uLtJwmKlsQwcNnQf9vrrDwRtAeJIUPhkLIUwaub3662++QhYHcjnR24LoUa93VHexjTu88pyehRWZRClWUNVwMFUjyibTE9GkXhHc7OaUfUtejr+/hRF2Ndq6aHD6+mLIpq9fyWjZOZS3eDs6xiQiL0dDmtmkoxHcqeQk1OMhlsywMUM5MENVNVYI7iSkv75jD6kxoE3U5rOF17kDZxfXMCHg5jouB7VswpbcFNVYDHWHuGyS4GpN7WCB8cOuKkdIGBuojJAZmYq6Z2PJ9a0jK67wv2OOqLe6NMGNi9GK7U/P45F1yTKTsw1WT21omHP+kgMecqJDzoxr/nXSuy+PsQKpIzTCRTYNRb3ToA73ZI6lYeuD8DFtQhkLoCysuJ6fvfMyiJfre3M7HvR20j5c2I6UW9rVjsbq+P5nHGgeJskQE7l4r3tomW43gm31uKyO5MjriSVHMF1yPLWvcB7/mECI5PIf1up0OeowqZJifloCttiD8mmU5heHJyHvk1kU5LlIXJ0mJfpAHk9i1IjgrCxeRhoyY5ye2EPA1fCod7x3sIvyeiNrlXGCJsHZWAehPGED2bNh9Mw+kuXBxXCE/Yia7H6B7EaKnLQw80HRDoM1+2KziqfDZqE2s3yoormAxoUhCJQMP+EtGYVAL0N11dHSqY5VGG51mf2YZmTDtkgyE+ZyhatHXJgbaBAAofF2VPOCj6sTk/lqxl2Fa9nWF9J5m0oXlVFxkgEICMh4jBCRWgNjppTIEuB/oGA7xcDbWzYPkUTA+UrEFBSAxCtAJOhSenySy7vC0qCehpFGDMgKpplqJ3D0Yai0LG7sWgREXgDFSCC9GKYhKWUXCZrDdcUTGcQ0rqqCwNQTKr3sfhZYYSU29M3Irz4lkAtknySoQkEGUx3JFGUJp7g2nokEMCpVWzwQL4FGldcbcJC9RQJSRfgpSwlxAfNlX/2UUqHqKKVKVemySC8GJsKFlU8FsIrz9lSkeGk8nzCv+pKVIhv7ZtuIihha5CpUlyYXheX1cETxVd9QKShdXNywiApIAKZ5Aime5aKR7A22REyhhjwM5UUZACHPBM++3WZI8UWbc6oN1rzL3UYH7/fdYugoZeztbq6GOCPqrRmDunuA8tbE7CCgUQIgDHkQTm5jmLJ90sNMpEQNTUAYOuEcx5SHB0Z/udAK/miCet6qY4yBifYmuSLWWx8AIbxhBknPaoMZ0qIVYlD0ADdOxUnSJXTzc6aDbKhASXByOmQLZSb2k4abadDN1fOnz/hw2ZuWW2Vm5h07YfaudFhxciWx0DBrqvqzFQBIGgRnZp2tRApze2KDYriRHnPhaNV3oZuA4ukY7NhOLbDpB54aongY9VRqsclmkdUQ6KwEF2+dHR1pVMLRqJbWPDsrHoMPGWLhmxmAkNW55dW9qGo2J6NYBNUNVyu9NWS5T/PKImF6Lh9QUxHjmqODsopmkmjim9URfndm8JFBmJ3ZGo2dYmYqWlMuE3ZEdaszuWU1wShuSYYEkBwFNPrt/QcvNZWyx9YSmqkbnMlOlGNSwAaYKgPVdI7pdsUybLEKG6TseMDpPtK3dSALvxci4amNII1nTECLeojMkIBPHm6tL2ZPu0PDog3f3Xzx+ZfdhaW93V3zV89wcMKciLDm3PuXV4QS3OLraw3po8e2yCwOzUzqO/iTTsIZ1AoWmipODIIIKFRYFRCzYoQrUCmpmqqjpoWkSD9xG+4yFEvsk6VKyBiKQ2RGY0d0NA3ST1/Vl6VITG6LSCtkVJARHGFgpREjUNBE+kTataEkfcFXtfbOcoFEYEG6ALHnSuozEugDPqFgAZVAWJPQTV+8eKqY6JhUOSa8+QVpJJDeA7SHswSw8FS8p+B7ewzOylV6EQ4oskaJVcN6a2NoWBP21uGrPj7JIn3VjbopLMZXb6UAUqWLQURFVCl++go3AVkEvEETkAX3ACgBQaNGlUD1adCggYNqvhYpBAgLeYFSl0JAKQLcQMnLcPPHp+DzxZYAKD89IPiOpzEuCH5CXrng+yosUkBnExbpDTgMoVE/ZZem3j4JSAMfb6q3ZM7T1Ua8ygARrwoQCz3bPEZ6MUUKkdKIkYvZqpD0pv2jTEMjSoDiWG/hrAjxClVN84zWTPF94tqoIphhd7e/sRwDWiEmI8EqozMUa+ZRDaq+UCJD1UhGLKHbC+hyxjAcIUsWpdvWPMqz/T6QsfKpCMDxoe1mauFqeCpCkGd/mc3UBEruGJXGfi6S16ogQxBLaOMNincY0tWY0IOJZIqQXVgbUQBDHHv65Y1KGE3UAywtm0G8AcliNQseh26KvEm6JsJVELCoClosbcaikTFOisNBzyFlMGcpYvv3WXm6p9VUj/5KKSDNrTVmj6fNwRzhWUMau1KN7Vx0hyH+N+cHEOsgFHyUYsZueZN+zWANf8OYUpRBWbd+mN0MFuqt+j5Gr7SFNBq9YqIboi4kIrMEUSNvU5UpMxIWknCgM5TR1u0MC7GFRsQk0yMOj+HLT4yphi5mIEOdtePEAjM4TWbYZXGm2iKGpjQk6iUQME5UF2PvtgxJRmWn1SBuXWqkTY2jCILmqR23i8np4+M+6213eV1b64xLq2tq/X5nR+lUfmXRG5zyTQpF+jeaSAAI9PE2rjbwQHvQO9alFpdilnHjxdJyLsBwyZ23k3bmZhdRj80NATGew6Mgg5Ktu92RbEQx/HWrg/0911xqd4oc1YRWZCBVnCKUrkRZZBSAoacYuzqXBJJBDGAED/yPGnOlr+wgCHhk95ae4u+H7JpD7STw6cO7CfoKAwhs69ThLvNd2dNkTUa1Lq6PpxFlB7ZwjlAGGoj64A03PRMgiXyqp7AptKQxanjLJabeflZKtYUHgsoiTKB4gNLVlQVL/QdbOH9VKR6fpPemwoCHmWSkf2AyHVI3s3MUrQFp8dGUTYEBob5QQvXlkLLRXUAypShdq8BNswmIVx2fhMORH5njU0rxIhWHIaAkO8Zqiq0VxbbpwcoXsnTmRy+zcsBST50rEiuFeqXzeOs5kARWWerujQOQRaRhtXCrWoiX0acJRzE64RmlHQ7MnZLNoQHk0WGG7o8ShwP8ZYPp7R2CCCsLwoHMCySHYWRoIbmcRoB3+bSQy3aK59Sjj4floRvur3aBITjVXvoVCsVPaTAQby2j8PcVwugMH5TBDqhEfKu+T3opgLLwXfZ+8iQ3YTk4Kx1ycVnP7EzPU2IyVtiAPRuB4lBDJ3rqyeAUZWhP4QDya2qKc6p5gwNHpSSsWynxRtUhdVSWUAeJO8PQ3rQw2Njo2sYWrEhUjqQqJexoB3nRAdGs3DiyRimm8cQcgMzopQyiPO0c8pYpiXge91fDCwYiJaIejso6ASnfrne2YIPw/ixagNZ1L/DsNFk8P981leHLRUlEIsueC4td5p2snZLpVE6++BiTOdxyHh4wPNjgal6QRbwg0lhVD4q8Zvy9HMUnD7yOVJna60rIe2vDZ+cGf7sNothabOfNcpYGRUBkRGQtpZu4H9IRF3Cm6atda9loDB6iAjVcKmnmMXpvxXvMJZksdRkbyBFNHF7N3QUyqiAxACZJolIWDAyjRjfqP88ZbBCDktGpSX9sXpco6At0hhAf0KsBNnUQdS3t4F8jEyLLCBNKlxHHUQ0AK8WDkdSFPFQX4CEghvOoVvATj6nfzsGhSJVSQd0T8hYIBZRLqNkVdTU4MeqxwjH53o2pKAuqRalLhqasg7YbLo0srQ860kM3ZHEiQJxR3+MGBSWD/ZPtbTuuACT9dZPu4uLxEce9Y/74uAuqXLMIGdjyRqQaQ4bxNAOYw0WaJGwVSscXUJZ29KgFTvMIiPcGrUl+gjcupKqG8STAn2Xx9rMZZVwJkGObnPqXpft25KI2goNHYNHa0sc9WLJra0UrlwitgHfG2Qy0EdQkYWviDLEMgH5CB2Nm4gwzsdJ5Cm9SUsAnfCDSVyBg36oU0UO+6HgiJZBdem8ppalHxQRghgG9fU3FmqQW1l01ifQNY2A+DJtihKUneap6VTHQULwVkVGxmNXCuHhugWIEABcvvYweAZ0E/JIOquBp1U7zyAKaXJK14jLYFFgBtau6Y0G9XWJ5JSvcfAJfdvGyK7dKFy9gMFULkemQbViVxiNxJag6SidB6NCmLHhOPLZGT2goTvqqjlx+ileoGPH/iErpMEW9Qj7lt06lRJVVhJ6jd8lCcDBiKKJKNB7LKAGw9tNDWIy3yEbnNE1VsADCwVABDQ/guiiYFFVvp9ghMlpZBCasy1lIQYQgIFpha3N5f/edMz0VjbY8XmCraG+cAwFhgt7Pk9N4gxhmFMHajz6GYWkoLmKGBwdwME6AiWMUur+7AwFFczicXuzy7w6ejjG3Ih09xIKYyYodWzq64A3hBCUSz9tn9e2fEbTnG6uZQCgCKTLiNgcB+NCJOWdbl24zklHOJgY0HhPO7RoMT2E+PdvhCkoqMt9bJEiT8gW0ySebCKMmueuXJmsNw6CVMxRZhR74pFG3U/2HC3WPBVbi9pUWemOZ29luzrnk+GN5wCorXcd4c0KFuq0twXfs1xDGC+Ys0DYGIyyycB9qnBOZP037Kt9ud7inT42cnp24vyTuygR5Y0411flk8aAGJYPNnWzCA3QauRCK40BjCcD8vMZOWCuOnjmjxlKyAUJfyjGbTmpzu1Z3dcMQbelOhZ3stLbs1NiBpVqERx+mxeub1N3ookScru6QoF8LqYtCfXUnjznlKpV/zOpLdiSsrmc2jI2pGv3hwEzdRty74QDzUDvO2uEu4GgUPIA4BnU/q8vjEA/ffCP71lbHoGs3MvH97Q8//OY3v3HNw/Tl5cL8Qrb/npwaQlwAADdlEVECqsx29Pann4h+rX90sKfFHEXlOFWERjo4KwsrIlea9YPJJcquyGItAeINbiSukLo4cLZyeYfEFgHQCDkju+l2+OrG4g9pkgZrD2QUJ2+OkWoyVmIUEBaQvRJQGAUM62KkVyjeD9gmVXgMKhGhpGmtP4rIVJN2T66T2pv9Qd8DFGgg5JcZgjKoHij6QxMFscKrvEdiXz2SgSCXRy7FeIuXRhvozAW/UBEPjk9+ipfYi7oCPwA9JbwIhUKgIjOP6/cteZE1iOsRL4EHHNBgBY1CGxqgBbNmWrm6vohgYvC0p7rZW3wVUDqwEmM1nJF+yEdaR219ADRpJIChmEJPcVWu9ycSlUwHjeSiQYCmXPiLl8aDCH4KoC1qKBHAxmoZ/NSl6OOtLmKKMlWQlAhCCBLWIDdyhWhygQOaT1KCBlXTA0X7isK+ioeDBxCPn+Jl0fEoNFV3MQLUTN1GfdVaRliQd63KWV4WY6nTiYZ21YMm2ZMnqzIyjMLKT5DVXZ+HoWrqrvJCyU8AI7vbIpA3UKoplyx+Aq4i6gsH2eFQrcn/zwPycNDPFmK35dhe1D8m/WVRhEhLai42ISgtwXHnX7GKynlobo4rlz9sHkcLFB+fEA9bgs5ymUjzL47eKtLaIjYixCn26C4x8i+hNUyMSWwOO3u7r1+/hiq6QDLUbCtb6qhqUV0YHPTMNhGwLMwqhJHSGxzQMzLh3LY6k9iI4CAwKTmGOzGiOYLi4eir/IvQBB1sMtZRmaTN5Obthz870c4qburgq81M8XabyeIE6iEvrISr4ZAo7D7GMS3d1qdUval0slpZzWBzaw05FwDQTKRRa8k8igAfm+nH3GfY4aOqchjFjGxQ7fRjqBrPrAb7o8DTWGn/YJoeAZYtZQ4XIuz0a+sufGkbX+EKbU0j1GSQ0X28YV7FoacEStfQsLW8JEYP0sTQwyqAaCNzkb/+9Qf12ljf5A/AaLO+ttF8yg15GV4J95sLd67Rqd2Qo4RIJDY62QU0Bwgk3OvXP99cXjPw2ivuvbuzQ+4a81LQxCS1Dw6kHHwU6o22hlgQdDHjjQfZxfgqpaeYIV1LYU1b1Y7F4fIKo623T5XGz6gI7ZQRSOqnACqoshfaKCMZgsjoE4oBaL5lWa3aGj7is3DQ7nD2lkZkxftU/REQ5SI74GJkQnvA4ZxOWBm8heWhHCgPJ5nYSq2kTwkAqmZLQ7aM2qwqD/uqmIDsvha6fgp7e9IaTQoLt4LySWLQMJwYCPkkDDmfELfq4ycCwcd2AvGSKUt6X30qyNV1ISx7dc6qsMTgKLcw9642qPqCI0YdgSWXgZILz0kDjsdPtZYMhMoivYDIT5/EFErSYB2kE4CPd1UHleAvvuoFcyWqNWZShHhFg4mf4C8j4CIlUwTEKjEI0FAQ3ED2+Fr4Fz6FpOyqD6WXL58Dri5VfWFZFCEBmDoe+LCFIYBaQRaFNoYGKfWVAD5FYcncKQFPP8VLUNWPZuVupnayBSkJc8iIAUcyMMUw7+hL1XOAlRgCSoSDSglLo44Q0+0howgFkWIGFW8WXo+MhgEJwFEpuSQT4zx9yCjIWd8sP65AcamT4qyIsn4Qa7kKE7/b6tmWbVSIUXHAuEwYOJoia13Rb1gq1NGRoDQhyBgXlSLg9HnWJ4XSOZa6K3QOPuO4mw2KVDl0CvbwhNrGNTsrpc2RF1wrqP6dnV9N8sJ6hJs7wRnk2KL4V9pJNm7SQAFwFwYLPmiQUR2km3XPmHOFWJfb4nbM0pTZLIM5l8IYZA2SkTDzaVm0jroXATV6PK+W10wXle+oMvRvK9JsUVHjPJpM39YdfVKWJqBnqjX3GzEeDYHOenC2pH7cSiIjiUFo0psQ0qq1NL4aSa0AU6eCRnM+UcOV7hK92FDNodZtmu4w6fd7vF8ck0nsM3QqTl6ErfoCLlDlQkl1kFrtEB+vlslRcRJoIzRxzTXWktLjTnM84xAFswEJUsMmNABXUy3rJ2muXqBpbdmBsrzipnWXiTr5an19E4+R+8YA5bKNqIwk+Ap55cLJCgIKztlo14gGEzgYj7KO46bPxsyIAG2PgGQhddMaZRRQLw/tSNgTRJuwhVsRxFdgiWbpxWgKP3VxiYs3pGwJIvEllt1PpXj8FFmP9LJ7JPD+CC1LgBIgl8TecpHzwujG7I7oQxxWINg5aVLEk4OCgZNa5iobKiV9SBMF+CRB5VISMkmm/gJaDkGRkh1QT4gnMFo5hPLufsbdPSLvbyamJ5zib7GM4wMP9LXNNW5swEIOT2h+K0VWgJUFGUUzL29srONvJSpCG4CfZM26oiEhQ3DAAZKVRQzEYKJ7CPvkIY7B93Bpj4W30UWXa5WKyuYT2gEeSaqF2wk8Mn4kXD4Bq2jkE0BHbz2S+qRoVSgmkF58cQ+A6gVnLCWBuUQ1ElAeHOwrxoV/r3cMAUqlKovxtQpSlp9tIYBZIvOY2AbubwgssxlhNObdVz/psC5JMLFTOj6msMgOt7KYQ8xPZQlAxlPtKEZYdVRWAvMxf3KhjBjqGLMveqCVB2SUFE8yyiUvmoPDWKHWRW1pGIUA9Lj3sequRtU6KgiyNIoAEDJQ9QkoTabWiCCg3wqDIBnCSgY4EvHPWWG2X+wSfM7OwqXyalCqKBe+MqQaBvgCUfz9ce9JPIu2w2SsHboGtp2aAKAm1/kdNiAAH/v1HEmkX+ANyCACm3IzgFhDNa6ny0HA9SDOazQS2mBhiSgHRdzo/IYDugIJG3FJ3jtG9vpWa9k5nGsMLGnePDhvx3Ytw8DIYHjCu3OOz//yCvWfYERMdVENPAVD2j4HRBMBQpYad3i0r/q6rebOUtnDnVVuD96QET0hBm0/W9fMjtZ4JoJ5l73iHuq3OiI+BLhH5yr4NpdlVxEAQQM5qo8JWjL2n8yXTWEmp7hFMvVEc83EOBTQ0LJ4EzjNTjnregOXnnc78xdnp6YFLkQzDGtW3G5It5HFHoQSEcYHebGZpkdkTQxtYHUEj7AxWL0A9yZPsK4wVdAg+v79rl1duIw1nx+UkZjzEn9RmiQhq7GypntpS3BXuU57dZYJ7dlMC/KWEBwG8vLF55jZlSRuKnKZl5py1UXAg/0jTcBSZN0RY6NGa4sofEDhQMQRSP0/2gbSK1sMkurgkPdTWDNhSDEqWE2jFPVCLZ88GE9eW8+UIqB2yhIpmeLEePuJSsr1CS9jg5ItikA0jYPDfRL5ITEvOD5eH0cFkSpGViBIo4zdFRFK8CHVsuUZQtUMAh5ofXoLSO0ttTwqrPLK0pyFUKFbwktfpaZJrCFVW5uhvjJhCZsqUkbw4SQ7nvIVTJRSirdqw0QR3uAAwqdOejGAoBE0/Ky3oqXx8wNp2hn6IEgmXhbhIqjSK1f9dMaARxoPBHz1SF8VNKr7qeGhqtlEwtZX5IaVjGIqvVGNbAIEnvXV1E5iJ3GJFBBZLCKjR9eVFybVrm6vhjkEPn7NiAV5RFtbS8eQndSWXgBAoFBJ0TS/qo63UqQsDH2FMwyllKyqhqoS6Ejv3+98883Xa+srZBbK7O4ebGysEt81iCImCqsmBDScjg24nwsLUa6FxZirvHz57Oz0HEwoiVSioo27tHJjtHiJAVeRUGmUIc71p1ldMBeCWHi9nVhHuVGcotUNtwz6J5AUCJ0f4mgLDVWQIFXLIS3TF1cDEMQYhPoDysoM8eGnggzS+rqi0TMXkmSXbs7rkDEDvOs+6KPDYye5myLgLGaK+1s6zdXdjZ2uM1iKTqjo5HLSf1uagkMVpyXVywAAE0YEJqPVlXUl/v0fvnWKpw2bDqXQMCwSR/2+m0msTF5f3Fqslp130EJ32XXeYzMxRcCPTYQLcyjoEuMJZ3wiANVbJ89sSSvIpTtWy1KSciQ1TXb6wWTTdlD8ZlLDjx178UyScWV11djD4Avh9dUVAyHY6NzprLO9nJ9e2HShvqx6FmNdQcawRg3FhpPNt0CJLjl3+MHknelgOr68Il0riZ7ITiLh+ggItlzACRFHq5D1rVEsIzTZwGqMH8wlYj7ScDYYGNltd1pe7HK4urs7Oj25vJtyXGUWwI0TjY1z9hxsT876xkvbCOCGaaPLP0aG8ALCWl02uLZhBUssrazPzFshtkC7KC8gioNYmKQ9EMZ7YOpE4s1uKUNXN9mexp3Xfoj53Bgzit9UNjP12xtzLfrKi89eou2g12eBw8xWvx/uT1w2YJ0AUzGUBVUr9zg//qxu1nQ2iF1VU9fDPpnkq4bDigrVdgjoLWPFV2vCDbYeshd60ksGIDpDD0c5+woL69D6mlkZGhnvEUTNpAFKXq0sVxWkB4kxB6yW0iOkkaBI4RNklBJOZu5uxoNWeuZe1gMaqMzGoE6kpg4tT7L4J4wP+QjD3oPWSWrTdrOpSSxSksJPWKk0CwHVhorEJYAEVLIoggQiAfdUAqirjAoTOqBJKW+ctx+d3BvLonhFy6hEARml98b6yvcHHzEEAXKoMLASA4KgxQQyKgV6EPPJA0l1bUDC7lAqppdXpEd7SAwf15MVerKYFVDxqsreVRamlBhihqxg0x4QFFqsIKx0Ye+C6ZPi1FRAiSCbSRr3DUGLVhotD3Cgm50dUj0syeIntSM+W0BYKbnpqXmTUCl1eP4b9dPKGut2lgsvXD4165PlLAF115EcsmR4/utf/0q3RZzNzUwv4AsNw4BapMu1EYX2pMW8maZUvyrlE1XbqpQaSakKApp1b29f7VBAAgUJAIWkMqqdB3x1dwGqQLpWW4JWtEd6KTUTyshltCvKaE1w5IInsBCAobJ8NZnALVw/zdCXuou2cYFQfR60OuzBzltdB9MDu8AyntMTHlzXRSD6SYHiF2T9wIWItCd8QJ7q4XRVPTp383JavInHpJMhcEvarpnCoqJdUJnH6JYGas6dpISpoa3UilYWghQnr6ys6QTOqfGmSVBG3VeVK6soBI6ruxuxAciJbxRq/EsrNyoggjFAZcHBvarvDaw3UUVmqYJLZlEl0/Q2Z9WyEqu7XKz5XBiLbvJqVW9NgOb20malQQfndDFtddrpolN81sw8+NRbg9KmDESyUA+Z+OVSkUwYmu2+vIPUi9rHAqIx7VyFoz5p0TtqJ4lOkPHrsePBFnpWkluHKc1Q/HMXsvNI9Wb7CcpL1SF8RmvbU02SPgwrsaV4VNZDFqO5QPUaFZReLYwBeAkPCDO0gPCohS01NEGS8m+ujOUkHlFp0KJDoorZcPgnXknNU641kw10+nm72MsJ7ctGaG6vlg2YJYzHKliShC5VmBjyi5lxrObAqIQSZAox+CCXNz4RCfM0R9Pzqhd84s9PQCSQWBdTVqUMwZtI8bO6JFAFViC79NvGMDzpqQQC8REy2/8oilEsn//tQ0YFMQ9QIAsUdym9ivMzHQ1CUoitt58Mbgr2WcMbnD1VZ2VoA8nQiCJWXb1+gogi+rA06ox2YqqTl28yIMgnuwSyVKHQ8hAo3oqTxSdvXyWDnEGlZA2YKgCrhl74Q0AMsFbGpIS/NLIrBSgppYESaD6BXwmYCnxVV1wiAHgwaAdsAVWlqzXIqgBgSrxh6UrHQARcK6bwVGgVFwjN8cBPQQoSUNArNDC3cBK3k9ZFIkJRBkoe0JRYMcol7IpEgIiEIVVXpDAgEngAUVZRoCpY5NJPKt672Jfu78pc8gVisssCfyRKvRqR1RFkijOspAHNIy+APklTybSRpTPHZyoCArJIID0XzuXlFWJODPpYLARHpSBAikCes5efACsRMoBjG0s5zuJXCz+lURBBZpcN8y5hV5pEwVeWwydAcO6OxAiFx1jkDb06HZgenO+M0TaLi7nHmi0GMgbFJNsuvSOoWKulPzzYIxqePtl6sr1JapIhhDv5pP0AtzZpPAzm7VH0tWN3Lq+5zdj0oSMYSuJk4fqXxYm1lZXd/UMJ3RrMasWs76hqWDkXaMT4cJUZFVM+Y4L6FuZDPp1U/gCPV2RuLLF3Fx2cfTQX+qidlM4bRBNHkmt8S8oZjUnZHOQ53l2cS7vQt+9IdZclZKoUxduI52aFWxbIbN5UKeXaebDcXaAq8E1ifQXBKcrqYhxwuGZOWGHhcozKo8MHJ5SivkQ7mmkXvAcZb53HVTDxC7pDK1OxWS6bjiNzZE1zVmFmI2XaStWDAxOjERY7mXagFj89FCR/ux0d+fbk8pwiBDL5Brgq4zSuodaShRGKdV5AhdVr9H7EZQ/cHXAglJxygA3wycbTFXV0d2V1kMahH5RRQik4t0m5t/UijmS6rLPSLN5QFhlF46LmDHC+WdcXDgt/eDQJ6BD/THnakTmILKQDOO4CQQD3ro3rwpalbIkWc3Xm6KerWvbQnGI8AroYJD1+wsQjRpOJgc+neBRQQSYTktfMQ3PXJ31n3k1gC10E5zytyT2+KhocTysnGpUABLxFSgOgNOJ5c/A5gAmh9qk4Qi/cZWG8ISNsX5a3BXOlB2ZDjvBNbVOmAfoxA4Cf6gCuqKqnQEkKkRJ8khQwKGmLA2Dsq/RSClCIyodEP1MqtIousktJGOnwEqsA0c2SoFBpKjsIJYYqgTQQCF2bmchPj8TgmD9KIy8WkYswKpwhIFKykKCZLP2EiXEa/+MkRAHNWy7V8ZC2xJM+ijrQk8YDjmT6L08toJTlE1DWyuAafm0qQOGpan56K0gykCGjIoUhODJ6BIBVCgooV4xk6iI9OesBRKR3NTYpDE9hYEGTrN4CRVgHmdUwTJhCSWJkARMElTIMGEvQB0oy+imXh6iSmBBXzSKRLB5Ek8ynXOx3m417UiKsAIBSakmXcUOmYiSWS1iMolVffYXBefIkuwdAMgbQrXwFSpXVURZvaDjrTYxZgpRGApiLlB0FSkVAGThD0h1QXE0gACCF3YTJMoBFPC0NGoWAPYGiVs6N0CDijw8P3775CfpfvHplVdDGKBe/mEA4a8yEyXlN/rJEa/JkW9rsDLO71UslVilq2m4gWW27drPb4+37XSo8q70baJfcOt18QlQKwhpUBYtEMOfI2V1e8qdepE6HWW1ulvGB4KZ7S6mCYZuIiEbzLAZTqLNObjjEdzg0BpzZGTUizqgjrCvmI+iDGrELjjlyaspaLJOXT0gfzyW75cNwESOmGow0OeHBkpoRjHI1NWMqYLHCCME4lWNCea/eZxKDLZWQM2/pzuVVoth2/DWt33iUJs2WFzMRfqAyMVblkgCWE+vhtFJQEdNU1RCL2fCMdXh4QkcT8z9SStGneB7RPAaAYh4ISKl2eFUHUUeSXVtrffEoZknjU0aJkR3bgOlrLfbU+bKpqnpFSobOARtSGHxTfzWC7ft3uyyvTvO3Sj83v6BEPQUan3oWPNOd41UZD71PGFaHRQ2F4nBtJ6AI6UtWVFgyT4kCCXySIHi2x8SLaR6byS5eFnh6Ko1kFSmXcLEHQpFAWeVS9kdlCwIS6Gxerdf4En3Oz+IuP6tE3G23hK1tzBtEuMYDPDhVutDo42xAfp/MmLzV3E8PJLQHjBG9KK6Bme00npjY75pck0xiYW+jK5hi0BQoAcV5fNKiYhjjOFqY3es5EJDM2yOXVoe6MKKomFzChaqfJXH0akCEKwGwkilF3sJBuMoVKDjihVFNvFK8gVUFAcVF7hMhbeVz1vCf+WnKVYSKyyVNqtac3MWA6WcVmhIppA1bRVTFpReGnrzSS6wg6T1akfzi2G6BS1g8dinCVi6li5cXnX0lFnUnT+EPSTDh5vGVbAVcQ1AuYCIGAjbii1c7b7oAOCgDrNLB+RiOpAaELNYfBMD3VbJgfpd+K4HxQ3EKhY94Py2UIRfgunfGmLlFeQk3pYw/jjuobWFxIbpM6xXIAoiLXOzgp0hKb1UQwltb6zpe8Q+A4MPfY4wzpD19tu0r7Qw+5CnIhYDmAA2/w4TkF4yi+pAFDxo9vdLqMFlPpbi/Jj/pg5ZYxxfdB3l14Ur2d8c9o5mlYPgwqhCTrWOqWdQFjypHto2r+yyLDKU7ZwSSaNMzBhlWfnq37V7QMHDADd0QHAEh2Q75McBH5LlOPtuAXR9P08xlL056yADGTkLOeijKbZ4dwjZCjUEbWTS49I8aytXhhnADZ6ZBrmAOqv7wF96YW8jyL6mL8iBgHnnRRJhE1tenddWB66+sYUxRLowClkznF6aN6zayWdvluTQV6264MYsTHwdvtoxIkciR+KuTAdbPEGiJnXKSEHCRPUtgo/+oczH5zzzY4GZkJWxJxdyJeBcVkImFxMbPZgSgwZCxCGshjp9ra+tHj8eGJylhjpKsRtIoSi1gBZS8zuDHq08//9wbNaq3SqDWmQM1XZgFiSuwBPjKJ50FIUcuHYQ5G5+sm1h3yWoJ2IsiwW7OrW8T/W6V+On1D6YpGRX6PQm0PmJAT30NcFoZeqS/dkQfHVuJJRQZhn0VqTrYxhtKAiIhLywGMvVTjPPj8LBhUYzrYqHRdlbnLgHWJZygn+JkHCsxOAx30JBWWKH1AAgfb2k8SlcQysI2k7KI81LlJYkUkhdJQ9XpaHIGRCQFVt4PI5IU/xdbd9ZkWXLkhz33/eZeWVlbd3WjATQwBDCUxoY0kWN60IO+rkx6pdk88W1o1JAcDNAAeq0195uZN/dFv797Vs6YpGNZp+LG8fDw8PDw8PDYwDH6KVioO0tIQeAFCRMpDEwNYVCzI7z4NHHf1BC7LnBTAI/yiNRIkaECwtB6fNIBoClXesaLbsRwDeB8FD0oOeS+CssUcsSkWJ8cQXAINyqp6AgIm0hZgI++K6+ceGl9EmBDiZTQTxVMOGEwEBbZqla3qryRwoftr1dx/Rv9f1rR5SuBwArYwDQ29SnA4+ndkYhPs/wE1tQiAwBgP7toaKDp8IeNIwtUGQ3AoL59QifgFkeoqFrxmpy0kAMTqSK9gYH3RhVHTZcFmBzlxT4STzdZQAIneG1DRogURlK3BxlxsNQoOBLjqywk1AHALCGWiocTlwzsaDqTChjSbBcPmEBbaxGqJiK4vvISk7mXz5+iCtmJ0RfeZvDLNJJWTyAGcsSoyjQJpx9nZmieZXB8PATJYuX3Vy9gUNXASMJvuWBLx8PDweYSvtih40t2eOoA9GZwmgY4G53g8+7ORyvrt7c21ZcxFFnjpoATeRqNMI5ZIOH8AydbmMLMtrXbcTftaci85GZ9qX6UjE5Hzg1mNiJA2aladM456pSmqEP9XC55cn7myEk3x8qL/uW8ObXKaXjkeDVTDiMTSxRK3Yupb5avByrNjkI0wK4p4poVLJ1iIqdsbarcnQGLjtgxu0PJEgmtQX0pvtwZyJisNevYcN7l1WRYZM9jqQLDDZag88+IwfLKatepRVB4iAmyxw1vcyExNo0cGPw54YIdNufMUq0GwnRBFAJQowx8sdx1aYpVCAlUJkFY/UfO85EyI5coQVKEnmieOzJ8Pr8wb6oJ2R7bsTVhueOAEVvzQbugllSuc0ToRABK50hd52v3QhcTvCCtpvZH6c/OLcfpxJMW+U2n7gQ6E6rsZW0FCWqK6HrrR80y0s/Pnr/QuYkxtB/VGUQQ4k8aS60qjCSbySg1KkxyFJDHDLpybseJmBsESizxX2pFRrM3arERJQLKqDjie6it0bN1dLcwa+hmNcB7EO+8PX0nqlKEQgsGhb7Clqfm/H0CIFKOVDONGdVQBETZlQp1Hq0+GxgM0glU+hgKEDJQAobFfnhXfvKo1GU8Qt0iJYHW7g0RAQIhCSHTrjBFY/Bu200VduEVGInoI8RERRKS5A1nU0Ma8AKwE9sN+UH28kFUkTXqjK8TMDD5SthvaSXxgPcJASgkGR45Uh8oQSGSwCOmyfD2SEtYFTNGySw6Y4+IAYlUrVdCIDSyoglbHy4XC2TtyEeJMEi7irxhA4MquZNpX8GLJ/Y9bwbYXC92I9UbfsDo8eAksiUXIGfULnUGjOkqEiScyGjuwYwV4pENUhJlhESMBwdQAr931WhMeNgwFj3dL+plfXL1KIQgpYUcMSiMiVSiCV4ksJZOCZuBHdm1AB4NBBR+TJajWkNPT+12L4UVTVhgslN/zrIRlgUwCCl6AdgEmCnPtre/+uorM7pctLKGE4ysw2eaznKIm5u3H94zKre2n4tvPuOGgSYWgedDVygHHbDLXHxm4pFXxwWQjNDnT7dY1o5TX5id2txY4dI4Otw7GR641mVt3ebxQfcTBJwTCQf5Ucg6T2EzBJGKgBL1zA9k/EFD0HKOjHeXC3e/A7FJDinS4ng4a93hJUUbub2+JkIIVky14PqzWph0f8bNcH6+urbx7OUr50ZQ5UYD/PsUa1wxTCSzeg57ztxsqlVN5Y0yRExNW0dPLXD8WRpkf5ZpYVPdzrZUAk1EfdrHQKvGI6Ru2Y+uMk4TG5qot4aT/bu3fzoxxfMzTyOLybSu4zldI25TQi3J0yuRH9mZmlYjGcfwE82YiI45afy0smod5zwXmvMPMIeKwwTKo84NzEULNJ6D7bJOaCwzYfoPCdGivsjhxtYTIpRJbHNFOSCEcXDhPk77pk3YikGwfNWpBmI23Bnj8rA6Ex5evvWVlez1s8rz1AqJU/Kg59fP95/NXzcX14Ol5a3NJ7KTEZwUPUOH4LNsCKpI6ghjBciPs0vh+cMfvnEaKAC5m7pnEzhQmviZAPJVJTpaTg3CacQUttTQs+Z6jeyj2VLGMk+hJTnor4zSGQhoMtIqCBhiLgZaSMRrLC3wuDJjBQcXnEPfyryARCoqpc994csSBt/ZfaIhHQAwqAheZ0Tli0GSt8kVzafdjWJUFrSSkDdVHCS8fNUPRMboE1WHWSReYPvpc/KoDDQjZqHefHScIYQ1U/2a3xifKfpS3Y5/Yjvoha4uNULTqqYYcoKRClheMpqz6t/hKudsCsqQzaW963VpN/8rfR1Ra72EuT4U6DpzuCvPCYIhnZp0ujhvlKszUIJlKhVhRAo3U572DN7e0l+UiEdkyldbCjEO17TnZmjs/Zt7u1j181Zs5mq3U35856I4N3FOcawWtwJbYzQOj+GWc01oGOezX5kcUWQmERcnrcEJRaPhHQAmJ2JUgzfD02h3xaE9zkKprafbT+gjS7pzWsqP33/PLjWm2N/dZSqaMvzjn/5kj6PA3sHRBz6QDP4ZWaYep9iLagavxGAUfeoGQevPTIK5ZgiXvbmPzQcuLg8ELAq0kygLO+bnfPLOFNBdbgg5OIyDDotQiGbc0BIITezr6VkTl0SXRtMMxB856KAmiPw0afbTmx9ILTYqrxG804Zt8XeHNRrfv3lr75X2Q+moGnu+MFwFaU2yg0SSiNCt2ba4sw73dy3XoXYxg31jUxfp5exeXXeWzrkbQhhLmpuBORL42cmy5myqmUlpBWj2kdQcBgNOTS3MTG4/WXMsvI0ANxdnR7vvlmdnVhecDHxotf/6YM4FB7DOT4+Pjg/m56aWFtxtMu/QfMf5rm2s6nucXqCWqVHYbFmNDrCAx8HO0/MX5076Gf/p/QcbWFndDAdeeb4Ue7mWV9fAWuHixHoOe6fn057WsrfWJqWaG1+3bslM68bK8mp6J/bElH2/jM2xqdnh6NyyU1sA3HJphpb+1iVgPyGPzE9OW60YTXF5hb1zU9MLtr/c3NG4ffnd/PTk2sqiOXZ8rl7sUkfoBKF3b398+9O31ooZuOoPVBkFfXiAk0vLKwaCU/amOTtqx81kp5cz81rQtHVkCs3OPRpa9n5aVt/tmS1yTpthHV6Pn58aqdgFsnew995Q8I7n5OpMdmYoluaX7mqtAKXAK6YxccUphaZHdeoa2cBaB0j6Gn6bE3/3b3/7bPsJ8i5Oj5x4dzbi/zmzKpi2PDo60H8QYNrGAEK7NhJ2BvXZ8dAqyVzKdnN9uH+4Olil68+OXYIwMoWzvry2vfnUvLCF//YsnAxP7KDmX2vXyqJJVWe/LSyhx+CParIAzEVv2jU7bm9nn7/XPdiuGMsEPrPjzqrVod+0o5T6G6rVrmx/1LlVwgOzyHFq3dluSKGzQFQB3Vg2lVOGMiJEOSnV0ISpo+p1LMY9YToyUqz129n54KsHoxj92qMikxnvqrIocZEeW0BoHyf/8Bmi3P0zOmf6xiXDmhB1rqxqIPZp2dzyNdNTHhfansG3+OXnX9o1xM6gceN+u9E3Z90Tjcp5Gu+5tBlXqMPqweSKCBOJ3eAVhiCqv4bMEq7uRqp/81X79JYW0f6HB0IPjphy0Rh8Li9tAMQDECkgI6gKQ+IFOl5AwbQl8NYw4AC2sjEBK543Sjyowl9Ui0GqVCKR4ecjfrXOqBGJs9JCorvxYKwc40etR0YA0NMVQGs7hB0ek3XUvatbQAUDd+anPQ2sOWjlSN+ZJNN/NhkkGCSEfkqFEoEGplXLrx496BPJoBmRraTol2pjI0MKaNHWb/EgwT/GNNOaTp8AhM4aJUDV+Qp4xHuwCPDLl9u8HzJqPvvahMGAcpToCfBTNwnGyGB7+ynL0Z8NQZBT4npNJYXKblyZgnHpnceVD7SEjZYWDbuRwzDOV8S/ebPz8tWmi68Lp9FUnKqyUJW4LMz2/6d/+icEf/75523dN37Js0rlOoOMnCLvLH5mzicHKEjdc3pWHYXz3mZ5Kox0deF37OCt9XUrmo6H+7S5xoa9Y3eL+mfnKNjtC5yuVnDqgbQy1jc21pk0RLr7ePOTrL9s3FlaZo5QyxobZ4uxpOo018na9DYZoN6xrtZJPBgpLBnjHJEytTsJ2+OS1nPYtZtT1TKMm16aZdawqznuGblvfvoOnRMW+J+OzPFq5xqdHHMA9XRktUZm7B9KgTvUtYB1uZielm6sk77ouOHHHSM7si0Ly4gdt6pycRX9KiuNKKdBGAAda5xGjupRiSlY26CICH3ATsQBfnv81/JpJHqQ2WFR/PU9QdWQ499XbguvLi5PaDXjj+nJiLG9XmRMx//2/Ts8YWWboohHdyxeZr0XSnKZlauE9o/4WBzPMHdDAy4uzWfPrZl7Z/K5GMcs8sKiSelpXanHOik2LROeuWh6giK1g8/Ybsll8OPccccKTgxYXUwx89G279mf8eP3P6VH50GcXTLNwZtv+5/tnq6sWMjNjIfoRKEKUju2gisR/e42eSss//Ef//H1689//8c/sC5Ho29ahhWNXjs+PFp89kwvm32C5xc7Z6dWEEUr6xvr7Fc6vRRn6bpSNTgpCwzRslSHMG7gBDULc7dNVWYmCYweWkZMdfc84h4blIVtabJNqtTS0tysY04uxshzLKo0/7Ju4WldJK2KJnjQxhDJrQVR4GL4YXmeKH2JvEHKNMTUTmyN1M8oGpWEDiT6Jhk4b08w6tpqMaXMWsfR6YTv8S8/gVLB5kLR8clmJ7YJf3JUSe5RBlkSSg/kYvxEvYKhuIlWSfChCowJNSZUZKgGhl1OYgceGJp9CqE15YU8geZRByDxEw1KIesuqfcjvBzh9HSVgBT2fkQCWAw6uTX9CUsLoEn1lhBw1unVro3Hr2jzyUOaEU/mEExQuvgQQuJNC4CBR0E8xEUppPUIwOxTFwFm4aYNB5oh3pB4HkmCrWnot0+AfeXQpKzpI1lA/ihMcunid5GFFZnqQdjKCndN/EJ+KgXKJaehINQCLdoRyRsDEkJZ0OzS+gQGWrt0q7uNkEFrXZ23Ok0HwMKYmXPgkICuRSeNWk+XVxEsPKRCEAk5vhn6Yo5cUpf4H7tbd2tOb55h5GgE/QBbWwWxsvl2MAoBEpo2kCnm2x6hm4GNytCMedvwgSlkE2z2FtBik+x6C/1t/NHfZEKbx5yhSGsYXRHsbh2P7EVI0RJh6ABuILLtJEzzKLhPEqJEQgH8yczq1ZWFDxgFJqzIRFScBoZfHERsVRLqWhJNDDEwKLgkXUHgOyBeciVVEPkyoxhW2Cte2VuQsDSfSqrhR5tySQUbepzE2kP8ljFJIBcviYTgVbQkNv3qEUX6Cr94ImknAJPY0DC6vpaEwUmRKQg8ksMJE2D8h9P76dYmz5tzO6gbXh11Uaim1viVamoHHgmpFj1Q9pG5wc3tuLRIrSVBNo4xYrj7DW1ZZh92Ph4dDw3jFge2+J3vHTgue8xyLKx7//HD+eXZYGXp17/+teT6T/Wrlikl8zFcl8gbrCwjV4ApYxeytUrG09Y1aCnxB7qHMsP0+9XBMkPH5WUfP7xHIY1v6t4mjMGCCw9Moj9YxopPySASx6rsMb8UXO7eHj87HieB+YknwhI2H7w9OBAmlAoSEIOMrhFIGt5bWhmJIRvA5AJSe1FHYhpPcq0Ckn9Z+wptSylRYYTBo4rzAREeiFod9Ac15HO4UOq1K9InmUEk0iPs4UrxdJGM9/oRUz6e9H4IBwwDyvwU8IAHI0bA8xgjDBgYWrN9toSy8SMVWIgufzoWkMjSDJmj9xU2DwLAeyOeCqg+7ExrFFBAllRIr+5NLgIgO5Uc/Qw1tqJVPXFfwmusRN6bJPz1XRI5NrB4Md6sSDFau6+dl58eRfBVFmiQhTCtB0BrpA0zN1LGQpjyaRgoRnHAIKMxyEKhJJev+C4gYuT1CNCENRJhT6HMPISj4ShDgyGYmd4WHalfqLquiQg8mIk/Nfd13wAtGyIRj+2EBBjixUiLBo9m6QxnN/lZseMGAmN57V5XoWGrQA0YgIEHYhTWm0LJCe2TOXDp9evX6kiH4dPauinBTAagFtqua0VrVggou3EEidCS7N46PrJldPaec8KNjPwsE67lslzqemlgT8+ScZuOghPaITf2xym4XKBlUsBsvspAS3nFMAlhVjQ00HR8UOcXx5yS8wOLiO6PTuyztSTdWDGWOD3i5hBMCHPLuEEY5nhEqpdwI16y7CBVNPw3eOarBAwSjLeH28TmMBuRjCaMdggsXyB94vg54wa9TpcaKkikhadNHZLpvAlWsT6S1uM7oiWpXkQ0AapJnYJXOmELmrlr2fIcmdo8OmH2xNlb4qqGWB0272oE6L+ZGOd7IRtsKz0Qaw0j9YhnV9FrfDuX7h83hW3vglskqfIFV3pdDk+Y5Lz2C9g4M5l1XwiQl8ZEVMw08KTaSExvZrrgNrLtK4VmQbo1P04u4A5WUmt1OPrMERgxjRwnF1G/5OKwCtONMU+3Xzr2DDNN7Z+OhopCOxeHT5cGudKHHeYCTXgMW7GOMPz004/JOlNWGaAL4JLSOT7ot7/9rWoymXF/v20tg27gP/7df2Dgm6C7WVt3TJDb3jm4hofHbBD5GbUwNQgbPjobnFFiFGJihi9TheI5/MwV0ksD4CTCPJ2jwiJbP442wLok+kOS3KGTFUQx9QDbMEGO01txMOn5WB6MS6eM1OeIUBlk2hfOkDTSK9LHdCnla6JqTkZRNTw+xeF0vZoVMBUBRonlKCFIegExMSoBNbSwR7gQxr7wqSPlB7p/Sk91C8s7X2vSHd6UjYlV+hSShnd+IGwR0LIFmB/MAzD+yYaibfzCAtoHt3i1NPfKnpyWewTp4K3L1ozZF3iqGJDLwk+dMHZLi1pkycs7lFQ3IC1lhFLkhdLS+z4JA+u3mvAIazA+gbnNjHr6AGyKDZIlBHnEwA8yeRUG+BHzUOXZ6J/VOwDUNHio/JRE7iYmBDwd7xP6IdQrtAncBPipULitmIABgJeLgEcqJi+cmK+Fp80UQgDgIXxE3gFJQCrF6upcCw1BpOn+9KdvRTZt3pIaRUgCg+ZhkzlTCytQQnpASsvv4Q2b3kKSLiNUnLGe1Tvq3rodrXXuZjK9hc2W6hkBIFnfuT7w4spRTqa5nL6JbGkV3OOSABjkIkdPl1oqOs4I/J7ntzip7FV73vhgZ/IyEbq/dn+e7eyTdktz3bM1DcWs9rGkT6LD3BOZg71MMDL84dHQWP2OkzAhZqW7GH4AxeQYOXQhycTM+pMtun7v8ADXsuB/2lmY6XvAZc17HEhZUo3apgbBeIIzYJTCz6I2piWxFOYOIoxkzQw31yvO+ERgFE0NXjltQNPgj+Y0uM7uLYJr+pGugdBgnvSa85Kdkc112dT4Y763CDgXYSJZdyjSAxgerJM155i6oE8Ma4ifyV/rjtBjPaQxDYOEqrXqUY2DRyGWkiLn5dUa1Aly3KsJ6xaBcWXP2dKTCfDyl++Uyj7Vym0uk678GCYqVaK9caZ541+tZZ8ReGM6+fJi+0pvIpJDXCo8NJ9oivt2Zvxy+vI0YXpwkq2k80ET2tQBVrTAv9s73Hz1pcq1DdltXPNb88YzyCDj5yO+uxzopkeHWV1wuZH2t28/uHm09oPf7+/ufP311//ub//2P/2n//TtX/6EDEm0tQ8f3jFf/q//4//84x//+Ozpds6RtvJV0eyZiE8mXj9Unx4PWYYo3N/bOT9bNAZSLBWBRkUMqZ+M45T400ybAJlR6dVCWTZRuVQDPS5A9ujCBlBedgyWYItPHhmrRMVvAKeCwMNn1O1admHgp3FDtzVl79zFYxokBENJuTfpZq1DJHkQCUB8BBfSQJT32TdIAXV6uJoa8aTW0z1PNUUfU+x+IIFBzOMbeSI9IiH0NGYxkjS5AiI7VeMRX4licT9SotmgBwAyFNsnYN7VuUXX+1n8jUr1iJEd5urYJUQ2DKSBfCirWgeQ8k/FNscBP+XlERDDzJIXqnDTXvLGDKHKaEb51MBIlUQ8mC6Fdo4AWYCEpDELc4BplpSrMEjYIE9MbdDtIjcSSdCmpGTLgx5JlFQqGfkJP3iRYODxlpEC+iStr5IDFolIbwWUl09HR6cGuYbAVg/B0AWniB/pFINyn/S1tAkkCEAVsk3yywhylAjYjiseTvC7u3smTSExlveVwYjV9JWW6VCZrc117ma0oRBpwAS6LEYbcodBLo1W1j6hX6AZ7qfGLK/YnYhhsrGMxtJf8ZlqoJYgWPl5f8OXnpXzrDMGjPlPSl+tSqI28Zn0Y0Ln8uL5K+FHMozlccrFUpynbp/nCmBi33J/cz/nfOAxu3ZNb2iXZbGF24qDCUiAB6n43AXEKDJmJCFHpZBdDwiExYxfRcyUC9+odUariX6uGLgGjnxeWzs5PpIEQpX72NFKq5vUy9AM3JDW9ZnVwDScOb1wsqmrUcJVWSMJfvBcYuQX9VqCDasUmdEdtjCosdWEsyU+DD+6tQbQFkq6X/ich9I2IScmmX3mAUPF9d2YUyvon+wHytnS1EeEKmV3vLYZCNf/XmsXljBcWUvzZH0lLuHYkNE+LBymfddpRCW3nI3ZtoYSGMQoAlXLxnJnr6VNZiglN9tqimB/Zx8GuoGeBcTzI5XO6ftv//zV17+yqPfd2x+YuRBZTbS366ynFWsj/vLhzzytV9MmYxcNrU6O7xxOZwURkSKcVMY3f/zj2mCZD+qHb7/jFDUZSwifPX+Ke3/4/T/bkXO4t4+Gp0+2TBLAbje1k88PD/ZI1NHBPoXpMCaeERfb8BRpI9q7giivN0EVIKvaqQKSDe1FQEFEelqqiYomihXW9ahHrWo4PLSZkHAwptPf5F2aPTuwMzFpEwp4tewh0q1DtFbI5ahlwAytMG+1jADL2lu4G5RPHpWDTg+cGmNIAuSB9zEgXKxPRGeAO7KkT7172wUM0ginScNJpJlshgKWBMFE+kyG+mc5Qh2khYgmC1Nkj3TkdssXL5eUrHQuYc34nUNzNr7jJKx5ITwFgOOSF2yI1Kho4GY0POI7CRj4JdGKvEWKgQpanOrqwSDT+ZJICAOSxHvUIqlqFkNC+JAnISQtysLivTsttH7C3xwHDKGfAt4NLC0Y8E2GT352pHzVaINB5VPjAYwqYGIESntG75vn8UldSggeweDFdHYAoPJVDPwCvlqkSM/y6qyvL/PaI0+FildSwDAA7lT42WyktlAFf1ko4fDHDx9hU2V6U1TpSKgq/SvxZN3LFz3WloF3xHl0620wa/OU15//fPb5Z8/RY4/CyzqkWlheUMHDpMBtSRShWYFLYsB4IxJmmmRCJ2MWdH6O3ido3BaEY3Fukel/aWvV+O2CO5tyANyCOVqLtYaHRxy1dZqmMxLSncNGH8pIC3dieG16mjw6OVY6+Zqhtr7BcWM2fDuek5PKmQRsLoJ+fnXCzlV7RMBiOYThACFmMEjbP5ntVtkZVOTwNjsVYrkvahmuFsEHpp1SULiOfsQrfRJ68DPNMV7Nc2TM38xzkNTp1hPWYcqRhFl0mpV82a+gi+Xld5RN7Edl4X7BcPAnu3tmCxRBpBqpozpT9TSmcovMJ44LpjV9mvnfxTNDjRJgQCRBr4DNFvZQ6+hMqY1WXC2J7gkeD8eYanRILteB4yfdpXGbs0Vt4LU+tjRP5sZ1MDcDJq4T4+RrlZR9Z/cW5BAqwzKzKjHFmIjRE5rAHdvfwjiR5qAjMjdXs/cYHn1qR53s+HVMl5uz4fHPiXELg4nb8e++/bOl1G6ey8mjx8N5Fp2TSp1WyGS5vXEW9fTE3Y+7H/b2dhXtZz/7an9nj9HD80l6/9s//t//8J//M8yawPnJMcPflLvTJ06ujp6sb+y+/2BWKVJNpVpuf325s7vn/ESCx/uoIOxbBcFMSki1erjZcLKZT9fhtpEli+fs/gw7ed6U3bJgYowYX6lHoyganhjgQ1ZitnevqgOXdQC6AZ0eKUKn5N0QNFIPwUuPWcZ0TIpq+Byj5FDF+ZlaL3c0KcmaxrNzrmkjxfvsg86+jlZKcmcZqPdoQx+k8RaZAhQKJwCw4/wkfPCiUiDZl3tdgQX8BEw2IJU9AALXTQI2KXz1SRYwRynUpIRPgP2kLMQLh+LSXHLRLLrMjVMh0YCDZbxHuym8SJi73Vqnj06YsRgSkWAQDD8MHmEIxes8UOKnSDHgjQAkhEpCOFu7SaiQYMQrkRPXOlMJ0SnGIxXVLhUl2Fk3Q2BQashlBBgSMF06gqK8gCUh8WAUlqHtNgC0YYKngZsemQJAJMI0AD8lQVtn1J+85Qhn59XZiUQqVCCFJbH2TtnByAg8PABkLaGySOUtBp8l8aaRASNS1hJiODKqtWfSEpLvvntLrctCKiVFMOJhZgEoI7lHLUhJnJrC3LHnASWWXT/9+Wt0gYEQjIAOSelMitqRBEYknHKEHFqkIrJ29E+z9myDtR5OqxkND6amFzldpk0AOPLT/Yuqw/A5hkc47NhhWt0UVuOUC+OOX4vKhhxPFLML6BZeoqUdxibLqTgWrVmST33Nn1hIYx3qzZ356pk5breM9qT1Bl3VmkFe09mihQ+vXr2y5AblisDGtA8KPdbjeuQijHUwWO5PyXJnMhLW1zes73PNgH27FvIyh/tST/zHRji98UHpaB5uAX0lAs1vNNtxXrW0eCPGKKFrTU3JFAfY+3Ql3phjcIcwwiJOulvrZ5yVPR1JpgetldIudWPE5GpksnVkFcnk9QR5sOTFCAAhDL8uO1UYGZieWxmsvPuwrxHzMeEGzNocPWHBOO2vMfxLEe5uHYqhIOfFQ+eA3k06zXhsdXWF2jvgTXeMx9qaCjo+Sa+gdCrdwrmXL5//8c9/sUjt5eYTeHUmP+3v/PrXv3rz/fcuHYjvP+uyclYVVrgrantj+R//8AdVZJz68e27v//7v3//5sPPv/5qZWlVq1qaW7AjEnHvT44spd65f9fNh+9Ir/CXN+9oTNMwvWqO1sMcbDFNYvzf+9Ha158ZizJT1LUKRTY16a2KFbnb0dx49KeDRX/44bvUYOl0XPKdbiBs11en1Ld8gWVDCAdYHTfUB8BRNIZpEqIQThUqI9ve/NR+hUWmfkt/wqC6AXuQ4SuTvD+BaSlCleoT9lYuTW/8qxdLgLqdYF+VNj0Ju0N+EPnUGFGvuzI2lCtDkJBBl6JO5/wcwGFEzQFAQnaNwmBmfkrY01mAZdxtRgVr9l1y8NqVXCA8GZozjItGs6TZxSMAoV0GPyWBVnZikGcVm+TQSi5VB8T7CYAOQpuwVF0xm1tP5Ys8wuHCdJDY4Q0hsKaQv9LPpsEiemnBwObpET0C1Ia8PFXSeGllFNV2fop+RW6O+9qkWkgHxidJMErYA4YYSSVecmgVmXIUL3eRmCx3j4AKFumBAQ9hlgsYZPupCBLSOLhBfH0SAyEAnJSqS4rD6AGJpdQiYIXySbnwNvyvM66RhDwkyUu+CGC6sozUGnUAGD14C8mf/vhHsuhqB/FrG+uQ2GNBfa7l1PWRResO1X+6Zb2lRZjTr794acD4dHsbYV01skazLJgRiFEoWSDPVz816fZaMovYjJZgc2TfXp4v0Hg6ckf7MT6IOQ+1RXN4wsh0GuVgYMG0LNg7PEmOD0YVJdjsouh1EpwkbA0wrCBf7TT21v70Ak4GOj494wRWN7zkdtZYi6zfEg/eQmwZoQ1nNEkBCb3VQteaQDvBEB9uT8XvZA+UMgJQuoaHpERgcnR2whCmrSR0UKkdoLShYQdNQN2CwSLVd3xsL4VbzKatHzIkfvJ0W+TO3uHc4tqbt+9gVq0sUKLFf4VO1VoykORIxVj5chY5CWJxec1eKrfpqib9zfbmBqNllvd+8u5keGRIoRc15Y2ZgC2R3dk70FttPV2/PDs2/sH/LIZx/PjwlME4PTWf0/Cu+SrsVLh8vrlkh5o9ZO4/eL+beTtF4Ljb3917tk0Q1nHDfKBdL27QQe2MQzJcdLMw2Dsa7uweXt7ePXv2XHGQ7YyNFOrWeaizH/eOrCmdWxrYMhXm5zbKLLF3zuovfvE1D5W1/NqBIlt7imc2+J2f88XN/+lP36Ve7HybnZ63xMtEyN2Ydbn2+bi0ku7CRqkw30POzTBzzz9Wa60ndhbQ/e7HHavOzMDt7e08fbIpa04haYkVcWU5axTDoxPVCg/pFdB8lMJ2EBP7uhNUyYhEqQuzPjAYB5CKEE0ksxaZc89x5JqIg5gc02cW0HK41H6tTs7pIzg2qG2VVq9BHt5aZrawoHLlqKIZNGnRdqswcOswEqNhtUAU0YCwko2cimHHiYwzH+U/PEJW2sMnb0CXBC5IQ2E9hhUcalZfsfi1W1/pGmv6MA4dQOSK6Y1HjLSo97N1EI6gA4PAyBGXJZGvYoiHTXJfO2sxAKQlzJILi1cAYK2AQHpk4emw9wOdNTICL0cJq4aSVxMDnmDB08Soic5Rcpk1hkec6PT1ERijPVivdG1ewQ9GFrVMxlnq6fMhES8Xn2QqbHmbYsLjJ3aBUXDxLESZyq6TCEOOP80KYVS17gDTOXZBfBJAW5MKlQG4yQLMkRHk8gLfZAD2yFqRPRLC7ycKheGn0JVIKknQ7FIa3gYB2OCRhVL76S0GGKr0VboEAQB2SjTlYBRFAWF2DD1j+s2bva0n6ywGe0J++OntVz//EjZkyw4Bcg9D3bm4skyWmj9QiYFZdcuL/4fxPT03YxaRvX81fm39gKYSdWdSjstp2kadCa5CRz2rPyoGXuUlDc09xDjiVl4CsjBt4CvT3mOPUrK/dCimXmD67PRseHpg4nR986nl8tGYEaoIgKI1NmSroJKZNF78xHAeNmxE8CNXtbqU9C5XHYgEJomiqREBCAXknE2Tlw9LRXUy9p9mOkU3r0fJtqU0Kw/1zC5xYrWjeM4VR873lpzNc3woC7QQstwV0DY6eUmIKqKXQqav0g3M6KOodjVmiX7WbadfvbeYUbcqr7kcKJDZfsMkayftjTPkJwYUtIU6OiR4zLfzPbFYuk05wOLi5sJJ0LxnnCKsoqrTmIy4y2liPthqIdaP3eWmT7PC13TDfTyWdhojMvfrVGFQJaDY/HscMBzDOXPI9Xy7B3omG0JcKGDFETebFgnSHQ/6bXX9lz/+gSbV+ZmQ4EDGAeY7P78Ol/CYCtlY30x215cajNGDUvAoWBXGOaB5YHbRkmPV8cP2h8yIkx+OrGs+NEdJWIzAuGS4PHn//i38arYPPkC6RqMhaMEYAhXWKJS6gIGGZGMtL6/88MMPBlgc/Wq8FpNHMmVqLypiNEtKV8CYifdMD5Kt4QLx7E9aKQQVzP2GQaYeMR4Z9RvbYQBDSsXYe6EKxAAQTcwEpGqtQprE4C2YnEaJaHgVTMqqvxDHIGuMoaxygh0Wnyy5tlhAZ6B7NFwiGUwt/DKCNjkiBhiEmmfS1sogzhZM10iIphxvJnMapeSGfcHGgFLx2Y1iVsyO3KwScejCyrK5xJQH6ZbxdhNCgELiskg0E1zF+P8+zaNIWHUkTRJUWACDhAJKJCMqT/IuI4IlZC2L6YL7ij/CDYM/qJUQB5vp4iGR3PqaNLzrLJcUKRUWN9MkCdpyPclap8teVgoAHrTB3xSiCjBI8NI2VbA9Pp1XY2sAaQXEGHJJSJVDRUMJQ96aXQCAgjceSADICGQjQQzixTcZpd/i3kFA5wWAItPePLx9n332EgatiJTLiM8SZAOvrS1Z3/n2p7cQWgjy5MkyyFpePTE1m85PvAeXsEJaYZTgZ5OEM0gyN0BOEEz7OO2G+5XM8X/wYtNbNhKTwEmCk/MTxrO48PzKEkkEQ2cXcYRRu8oeogx44TeXJoxCyAUyz8+j1DUyM099VXeQWmZXra0u0k+UGoYYpusx+Gpc/I6LMOEAMHgoHczpp8uuLLJjdhhlknAwFIcOwrShKlBQXythvKmx+2oMhxV6gXSrt1eYbFFr3OgewxYWA5X44Kjkhcr5FxISM+rDPBtltWzEUyaI3lyJjNm6mMJyl5GSclvDwsnO/WzlTBj7sJY3TsK52YERv+lZtU0EDBINNdgwrGyCmZnWsVa7Su8Oe+ErnnrDG70XE1guBFCzcEscFa5Yulh8szCU14s2gcQCXNWN8Zo5LofCzKl4xq3i1fh5qNSyKW6lM9JTSItYEW+9gr6Z4HJ/6fwsLmjinfqt/DY/n54c2su2sbYld/hNBZ2NJtwJ7XpslyjjnnJxT10ZWuUIg1jK8orDUE7RZ/FUG76QpFJi2l3G6JYxocoWE1VAXGhwTUm9IN9dxNLihYTB5qjUHESo38omHnWhrn0F7xuRIAm+UiTCzKjskap5jhxGUDUrR+IaDZHMowp4620hrI8REhUJlQB4+Psn3qVyywSUI5pDSs0uXN5mRlMdAUihUtJbAwXDQBhIuLc5c+8HTzFagcLiaQ3FY9vZdAYKANobpA5QRuT1IexUk7LiQSohshReGcB7lpcHmAKVsOQC2rnHz5DFTCiDVKlS7CohSrQxMIokLU0KGHJf/QTPVPQGBkCkT42tk8PpEQkAJWCggrDxEPcGE6+HlxAYeJCdi4BqFtlkt+sGbVq1N93tOySNTWErt4c+MkjGotA9TZKvUIXIbMVOdsIdkDbxn1SSSIWS8PHdwGKgVS/oAQ/h41sATIN1uXxt+QAfIso/CKwhOy/wakEuOIAtwoARw3ptnSusmLoifIMBpJi11cz6tlJTdkLihhmHtakD8dd3Gd/Qeshw8hj7yIMYZwC5WcVZOk4fuZi4/+v/+a9dm0URyVRxdAYwC8vFYTWeZLS2hlo4PXY1Wn53cX/tuGM+otur82srf8ZNWnJOUyAOxTCEuuP2kcSk6LKJU5e6uNqpOqTaHBad27KEw8jz0O0KFZ4ko/Pl1XUdwPmJTfZaj33dMWUO944se6fIivllo4xlbYlW9PHje5xEqupSasXESWQrsh5Rw+MuwyJZ6PY2ysGlgShvlHst6AIv0G/4UUKkLUaigUx+UlqRyDSHuIkU1C/JlUKWZt4tV5+bWOAcI1WS2za8VqMNBcRMhEHY8i+gqyuj0SKi+5uZqRyX4BpR/YjzTsygfxpBCmRkFNfNDdeT5fqZDnmYkHNIXG3ByEGlk6YT7Lignpw8zRpiFk44+5X7zGCqFhOnpzH/e3NLe+bu0tucoEBg0nvV+g55IVuboe+y0HpygtEkkVyMFgQUwbozB/Bhs8sy3XhweWI6B3NWDi4OdPkyMIkCSdx4VPLt9d7OB1moa+tCfXcp6NHBLqqW5mcPnD6SApjVd/Fn3CbDw33HOejjHXjHlozOyxrZnHHkqzaqaqpX4yrIfBXmW5g0PB4xzRBP72kgTFufXBHqKwHGeQKMYzCoCG+tiYQLe3O/qHHuewDORKGCBSg1bxVNSTifjIKDQQv3X3iYjuBBYygp/KnN2homRyzyCPgkXnagBaxBqXfaI85DKCEwiMQIK5oOBYxzj2GILvOfUvHnIlHZxMBFYYn0SRo/Zdw/UQcFZsnYIwNU+lQsi/AJkH4Sz+oF0Jpdq+AukCt2iIRQRipMQjFgRMrIrhmWAol3eNDF3dlxNtfEMpWLAQfDxaDSg7OApRVwVICv/cAv0icPMtAMLfy+evcnR7Q8IPzUc3bRmn2NQSn8lCrk6YMurzJ3X86ZRoKVIJFNDgA3QqeJ8NcxtTxwNtMQIIkwkwDCTohsyXEpMLXAS0CMr2AIK90n4IFZ5cHgq6ex9Sdv8f3uLFSctPS4n6jFAbxCjFSdUNin0JetucNOJSxfZcE0qUDC2QRA+EDknXNajrq/79yNbXd2DiQ8yubMy4VB9vS66UUP4RgAVrx7tw34NnLif/YSv3zxlJveKmzZOZCR/wtyDQM2aAHQ6ZiJD4qMe2K0VeVjCuUoKd7vNL57bTujM6tZMmo2OrfkvJVghoPKtru3b+LciDPW683t4viilRZXY8krmpTRKDbb4lMOzFDq8KFGfvYBOOrnZGii9ICvdjZCnoaqGVZLjFFgu4CTqfDZ9kDOAsy1ZD6GFV+QSVfb13PA30WaiR0PcfvEZKOs1CP7M6y+is9Td6WN2POzu79DAXHIaiPsfrVmmb3Wb1VNXACMtUcbIkRziOu81ZIV3c6Bmb08OEOWaoLfEXUwY6PwQxO4jYIwblF0y1qouUvylg00c/wUYGgV0ygoZHRbmgNnTnyoA8FOT875M608YJgzqPGBC9BFavwkymX4Pl6nrWlGNDtt2MeE4VaW8WTbhP7V0FAvZWmWk46ivLRDYhyxp235V2iZ8i3xC5nctipy+jJNQPn1Ldb7U4ZGJIx+67RslzZNjSWSOaDAlKyKOzo61+8wH/RKzDOFRbBi2tZNQAwnbp1TcnrsmCkLh5QL61wA6naULFC1zZP/kP1jeekU38CFlq75YJQ/nMlKpasLtabD0bXTkFqBsSmu6exNEEXBfvLZqjgiTf6d8cg2cmqilb6oVSN7+zvET8ExAas1AZSX+KUCcMM7YmYsRYPRWpyP404nZLZbkRxlDR4AtxBIQigtJBGC+hqGVd/jLQaw0TA2UV1+isB0qrkVgkumCL4adMgdcyabfYprsbU96JOfz8iiDjwChT8vn5RHZOqy1JmvngZrQiHxSSQStRPKDk4kyZ5ogvEJp8A0rWBA9k8uXkv3tGQC6itg1eynBwaYkSqtpuKrloZ4lHg6a5HNF2BpY+XlkFYSP71l3TCyk6SBBUQ22eK7LF0oP+UlRgDxdFzlFvtRJMx+CshODGUrxs8mBgap5CsSgLw8fkqi5XuLbGxyb8K8O0YAu4Sl9VUAed6NRExn4d2BjgeMWjHNKASjSiox3k0PkgTEwC/8yPwmG3n4DImEvYkaTFMribYhHgD9DuHr1y99VQsc/uS7USkUSACIUTtM4BxGeH/PDWodjk9WizdPkIcSyL3lKBISqUiLmlKiWCSWaXGDpHmPjOcZMPS+r7aCUpGG9pQwbuSYvdqCR9hgMOdmRYcDq6GVNQClAyAjxMtIPDBl4bwXRhVNoQ4hNteq86N+azTuS5ipN0KneN2e7krZoW06vf2EqWsztNWeFbkIMDF99chF1jCIRIav0CJMMekU+K29cQgapxXMMvUpx3uCqxpBv+TSyo6DtFlHBUsOWA/nKxr6p6R+osfbVwj1kxigmfqpbik83Q+SxHQSUyAo1aw5OP3V1KjkFl4uOsVOEkVQp6YTERCjJasJaSh9E7VcztsZ27M10pjAetm8WCFkLy719ChRYpa5VHXggAxlqlwKaKW1zkONIMmAx7BAEUDSb/4E1L/iOKELfMYZ2WCoc8Ue5FupBNz52CQnC/lqa7TpUzfCD8pv6Bb4ATCTLRLqyvXX5jAoTERBog56bQuqdAOQFFVRr7ALY2wP3VSTABWfUoxP2cPnVG0s7RpHvySQCEgIpmovliJuqG4MkRwMcjvG2wNSZFeW5P3oDhkqUvnqjQy5aLPAIEdSw3eOkPgExluMHDsXqFp+5IgzfvrUCSFRLb5mjZoPjbf5DkgMFJ237P0Ulo084jYpjz/TmH3mJynTvFQyyTIfoF7EZybAFMpdJtbVq7REp0sujJpUfJWtm6KwryRbOT2hLNSM5TDYogcNjQfBviBYDHiB/9+nq0FGMAOAEDz6BRAgBrPwUQwAb5GYIi/l9aSknwYB+ckRXEsFlcIjLWAL/hoDW49VCDNImCGBs9/QNgGwSQKt5OjvjMQ08RJiOLQUDTmTCowkjQSYRySAjoHT86+zgEESYDAcHAxB+omTjb+BC01sXoGWIQEJOyPY/JSLGLWGt37C4A2JGGFOHslhUxA/zev4KgaAIQWeSyssAFKAuofHozNwMIs3AD8NeN3HDYmfqpVVpSOBAdmqzFpPJphcRNLN5Cp6wXQe9c8usgnA6MCS/5p9RXbT35TPUenTD7KuEVkHLQsstfXUH+b4mUnJqGbsTe1ILi1iEKBQitNVmRbnqLv4uHMABiLRL9yVDpgoqk0I0dCGjrLIwkNdQqgPa853xWmh9AunNuteWM6+yos68aBBIKr4OsRACzl6PBBaiFKuoHTnBgGsdTg5MLp2QEKljmATDZVHGKngE6MxRmCs3ol7Wnara8tSAVB8adHvBD4L0M2nSBKCajCtCvQWNHvpXOVboPscvUqbY6RcwIKvvKL+xHjLUaTuArv8dHqPEnVGYrTIZgtveP2MBtTNEDSpOGDVvk4EkyRxxhMYCcQQAxVlr58fGiQ0g5VBOhcn0Q4GCwOXSk5ywPmZ9Vkz0w4pSTfq1DVT0E6fHjOvrVdmktxk5GGCBLFkmcg7MXfi3lRBVW6UqUdpsVcM8giAOqXxXaSTBc1Pn2XCvBq1sqgs7OrabwXFWsIKycmJepEWt1kPFLiiQN7c8JYWpDJ2VXYMBoIRD7kH8g7gD4B+OpWwtP0GI5WMGoxsiiE/nR29VQQEFRipfMoifY8E6EYlavxMk63rzjvXFgUwsvTOWKkKjC9QoBXpIP30VQP2FgPMn/guWOOEiqhVgxwJQ4gmWYOJ7HIZ1r4X4U7lLa/OhSx2Lk2GQZmGIVMPMOWRLwBfPTgCrU/wq0KfvOUIsYZXaDMeh1wS739dAc0vScCzcjIujjSHj5Lgj+R7e869iQej81JSGOQFQCrwHp8wx4MYWYjBdw+qOmzo+YhBQmEtyBsP6VABqWSK8q4jfEjZ6umEgpB7kCQjmDmjFxfnhDG5s/YVEs9Dyk/Jm6vogQrxAjiG+J2d+GSwV75SYTu0gL3FIAltttVwW4tBdjYXOHnm6pLQW1LCdStfFhS0a+urljlyF/1Pv/ut2nazuYttqaDjI7fenwCTnQdOxzNoKqw8azfYPrZ6MlWFaXzbU5ctlNWkDYytBFucf/n8BYbAzzRHmIteldqqAYqDO9j4YH/n4/npidUJ3B9SasIMN+TR4IhXCo9RACQekTnht4aMxj1Q4ZiCwc925p3wR/+yTBFMG4JXcAwXIAPCIHUPmCBGWEa+WsvP+2yWWuPFWOIAEp8lgR8wSMQL0O04gOdo0BtbCulCLNb2yZmNvpaqX9EQ1K6lq1Q6nUBNL9g5XKMKgoSB+ggY5AtbCwPkSgpGs1DhMVkxNxRwL0SbL+fgGuOJ2EMKM3LAmryz6+3aVWI29dHamqpeEzTfP48/nPQnr+x5vOK3Wqq+CgHGT6Wx7dk0vjFnTOyj1FikSZKjqKA3fXtzYQ/sfTwnNciJbgWuL1SE1qdMLXfAmEHgX7ERTWv1iTww9CtQq4ZcgemCTHvcpiddx0nD47bslnLzcORBk2UmWJRpeSg9SlC1SDu8VF/2J85YwkQvxbsrb4oHl/BKSQDoF5UIEqigFUY/xUg4mTtQcf7gs+PQEc/K8ZVowdDtCJGKY4iaPjt8jrcDgKsvjICTy6enivwwFICELd1ViWNAOHD0fNAqnD5MQmJLPMhP+FXdg0B48slyTeXmCUy2YM5Y0BQjCWdVfL3DpYWyxuQFOQwTpMKcjwomhdYsryytcJSOjtV7zn2l+bx1mcjTBGxglOX29pYmQ4agI3CbmxtMMcaK7dp+UoLG0ehYXV1DdRb2sDumLQq6PNzfM5h3qsD21hOtkhYQb+ke8874kVgRT81Dd228ZhmHP8PJqqRJy/aJETPcmjQCAa1VucYZeIHLyoNxAh4BLNAUaS7VgGu4guxmX4ymCTOSDkuZdlYBAmkHZWnjQp2RW9cEWo2g6WoDdJ4ujjVh6OWPPPWAiKvwH/7hHxRQ7ZKkrc2NDEYnsxyeKIgkPR6ygiRFWFtfoUEsQKbgMduMnzdIAMxTuhoNflp1B17DQ7OiIVtxcscWj2nN7/uJS/6K5gffvUjAiszlIjmjlbKgFiXHmYbvN6PR1jl2qIqlGiBRfHwQ9qllYvvpqppVj3AWGXodRbyg+7QBV4ZpztqP2nDfiH4bGD8GTp6MjmWbcxZrRxhXDKUmoyebq6+/eDHuxsDzI0v73r/7KUcP1Mp3AmOFKGz03ObahmZ34x727GBxBdTQvJjFP/z22V16fzM3xYmQfb57ux+ZtGyP2s1LyGeEzOARqhunUk+PvXr5zLSx07fsaVUuK/D293dxQMtEDxb1Q5CkIiTKi3gGoB90h1Kri7PLjBs0tzYari5GDCxCiFQcxl681bzlzjyEFK+ZIdbkZH5yMh0VYZYjsdjY2siBpWWEEi2bD4iEXHiw+FiebW9ZIH98eGCOdGZ+sLS+cesAHMPomfnL27HR5c3q2pPjU0c+GDlkNoL21Ju7pljX1P2Txkvacbv0Tsxlf36Ozs8Yy7yTjBhDFa5wg5pch6AqN9aerK/hy+vPXyFmebBq38PO/hHijk7O3WXGj6ZJWYhqAoFz3Ppv+kFl5QIsNjoTepLrb9UOgOVF83YTlAYkIu0AsBXWcUYs5xzdUSP1Z68+y5KlmdmRscgUmBwjqJJ1ZChkA9oyfbh3qCvW099cj65uRzZLES1zC456xmdzgK58cLj2zITz8bHYwt8z8+Fp9i7NtNro4npxbnB94SqOVaovtDnyaHLaXALydj/scDX5eWW24MLNZk6CcRH0hVrJpSBO/SsTVsu1N8KgYbC6QvmYffKn+ySmWiW96iaJt+9+sgiVGtSodb+mdjMY19hcD3l7tX+4Zz2x2Yej40MqeOPJuub905s36kZj1+mqQkqMrlBZxIwe8JDAmprlTuS7jieZ7FE54KGyotqQl5JTfSuWCZRlQ7O268UyYgLgLRVV4IIKPjWbqAcra+49NkmuD9GpGnM7J1Hfob+RI8joRiwWCvH/ar5XcRBEQD3RQXGZRBNJJkYSX/0UoAH1ihGg5WU/1RM8pZ6sFYuJrXPNqO3TNC8wMCDZWcqvOXVGMBgY8CRbcS73zkumwnKULwAV3fk2wb76qfl1YUB2QGR61OoPGgBJAh4BPW36C71cSqRDiV0sqpnSSKq/zEgfEjrRJ0CNsLOQ1leEKYuwyDbfAMMMXgG9ofUJZGfhnfmmcnb7hBjZqWDWpGFDGY9BJSFI5YXNTwHqVe4eHCOIxMLjK7AmTxala2jBGJIgYWOzSC4sIz+b7X4aikko4OtD/Zbow4nsMutOLc1FJ/LkToXpVTUMNDN5yD0DCqQDn7Vh9Wi1TPo2LU951f5shvPoObFfxJb2ifHXrz/berK2ND8xNbqxk97R7riytMyenSMriKGI6S+r2i18Z6MhjCHPj0DdWbZOrAi4DkCfpT1azEeo8ES5PAriYTFZFKOt2iNmqlGHZSNqHztjDKHrqrZnBVH4SWj1lA6ntO5ez8qyd0V2OHljdHvJ1Kfcpm6mWCFIwwdiSEbIS8GksXtkqryweYeN5QZBD5GmxzXI8PP8YmllSdfkTxJgDS+Jr8jARjE0i+Qu2dHpzlP98Z2aHXXnz6WZD5Yf3WCwIRXDVC/lNkfsMluBUUYebjKRqat1MAcBONG5UCnpCThkUeNhQ2frbxZYn47O/vKnb/D32fbmwcG+VkmnW8cTW8dj3aoVlLxuUvD3Jn3Ww9f4PyINWQl4FiblyrzcPSC12z2zC9JFLbf3k1ZxX9tOsbrqjiDGlgElVz6pMMWQoUENShWfDtBrGqtohMx3MwpkTw3QZq5Hu7aCaWImqzmz5mvKsT+4QdJsKNDHEhsWAzfe5vrG2TmfZ4YUVWV2d2rRNBtS06ZQhWYZaVxWkDlGnBqUF0cW0wYA6y0SXzM3jYTKEi+mG7K3iSVItCOyhP9KJC/bslSfitPEwIAHQzbi6ytXgfU/2CgMm+ZjsOWzhHLhBpWELahjZurwEVjgfG8MFA9fVDm1JK16p/FBUtOQiJGWKlDX3qrLJwX0Jt6m3NQ0GsgADIY1mrp+xrSetInP0t2H5ctiot8VNYnr8VNKP4F6QKCV+Hj7JEsxqk1YQIQaVSrFa3hvMJyN3ugGQzQBSyIGmvgQ029F4QKgWYxWKJdSbXPuVBJAdyEPJfKVEFthEBbfMSLRK70OU6YCchEjDHNVQDwb4tHmLR424WqwAYYTKp+k0hQbQ8PrLwQaoHMHD6YzlcpPAIghDeJhoHZFRnSIZj0Iji4o3SpfkMJgmkhhMajSj8DjgbABpAamFCK9u+yyhkTvBQZ7AfRXYqf6fJWdANtBjeiwsfHo6OTlq6dEs/kmGWyQ6wD0DciQo08en2AT492KnkIHCcAj3n2r3sm4Hrl7aH82fsZG8cIGrJlsl5GvtOtP3+8Z/VlA8rMvXls+wjVgTfC79x8ktBdiyXKv7MZi16HrmoETFt0Z20XMorhQMBuNz01hXYd1hRSDwS0zOEuGFuKIQzzdysAY8IksLFnx7CYz8ktMF5cWkIFfKlkJ7CriVKHCzMaSa+arbhfNK2urdiRhMs+xlYvGWtgh3i6O27N4VDuXiJ/pfT39+ZXrb3UeqY5Ps0dk2WIF2lP3Sb9YmYQMwqcjhKpOuY4fr9y8D+5KRcbtNr0UXEHUi47CUIby5f7iqNK3YKlSEKT15UHqyLAml20dassWT1lT654UsowYnQRIU6iuroBNxaX45W0RFkF4xLO+TGTeDE+0+3jHZ+cPjoaK79DeWEcWC2U7AOE0HDcMuraOMvu2biKHq+ur3gQFPQdHh8D2Dw8doudEna2tzVyhg9rJaUts9NAGKujHIis1M1GMq/pomq0KBbmGQ4j5hdQdRmV/QlRcUmBjFidFJrkP2HnU0Z1164YXkoODf2N5lWG2v3doMlafoe7aToXZkOv28t48D/0XS0qXf5tVJFiJBZoaYbu3DUvvPhOLsLqH7KHFVQ3ZT9UtI5RoXwItAzBoVh4IRWpZYsA3JOD4MEvPVs1GeAAnF0PI0ocgHz+J5/nrtFhhhRBsnrRGna5HpxdZDcegFd2SCa14kbjdQqhdkgoABWO5V1InXMqT1v/X+QaytjonL1Y+LD6Ha6VuhDtZYUsZElNGWbAW3v4kPU75mnZa4wDUKKoMWAekGcJGLhJ+YY+0wODBYhioG58EiBQkIagUU0N2qZp9AICBESkADxjwHfAW2Tk2i8VA1fTLCxKkesQ0MLIl9wkxwtBKCKAJEN/Iu759AuargBhvjxw9sEnemEWSpyZYMQkHJAUbb494NMMsXqouHcY3nu6Gm2x5SQjAQwRdNoNsya2Toz196hw7IfzgmSEi4RdwBLFuAJhDaaxfxieRMHTC5oli+ik7STqmyJtYcDglFvU0ZTUDvp2ybsI6OaJfAELJq7MZc67A/cSt1RcRg6N9azgN23/84bvFhZmn66/SQYzdDBZn+Q8t5iEYXA2uMqQaZR3mRONonJZ03jB9ssI/NYujnkg/9yCHtw6EZBMWS+OwBeUSSc17b4jKVro412LTaEsubrmB2XTCpFCvyxolhTQLv0wGLqvrMrXSxpHLHO2n9HqOPEsnpwGQ+isLBau8GGWIJqPE3o9tDVaz/u8qe6eRAYlSe1QfUjsGMDyS9d59jALmEfBJ6Ty+4iR4MapPGAamJS953JJO3sk2MX9p21d3nDZzJhXMWPqp1eA8Q12XRm8sLM0xX+lB+Cxrz0ryavmVp+KEh8JRzmU2KRe0vHlOvDBh42QB6t4SWErapooSyIcRs6HM3uERFVS2H/GjJdLKTNVR2UZayF5cfEJyBOz2WFlddZBWPES55yvWjyN1eGD01ks2ll9lwb5Rt66XkdO29eQER6Xi47a6M9SiI2JimqJRCj0rzQgPymMq3brZ+JjXK6fGRTvPXy1bzj4yRqRjzIMI6M7nTPDWA0ajUHbJO4zU9P89FAjSTGzoa3E1i4qvb06tLqtV0RD45Ola0wTIvITdrjVhmP3k3qEGgWGyTySh2duGlBxg84Zfcqpjc2MDQuMbScx0ow2eOMBr9UH2wZrv0GcQdOfB1aGBKGm0pBw8OZFvP2uba8ayCDAglrus1XAwfyJeAKRUyGBnIECMyYRmCMgoXxA++9AKSxhN6sBnD4Cy+8NTpGdwWqtZAFjxamGcjNFEoEEqpyToqMpLGEH0DCH3CWYmDnKF9RowyNzoz6kpaDAUgEfLlzaNp7wf8hIWA7gjkeGBQWQ/XUKR6kCOLe4CsgMg3rthpPITnR4xYDxZJJfl0uFAl0KkMNvUxzLZY7WJVK7OopMLd1mgMiTkCgPDypELTvrUqeTuZyP39lVZMO0TkqgA+UqLYDi7aMIAOjvhoid6uZifzh+Y4RQAX6VtDCLVnazpOAEEEx1JVJO3fMiDhmoGtIsCppUXyWDuoeR6KiwyjvFIUlnnCDNJ1I6BKZ+D6mXs/PznP4fkXLOzKDDs0nLCbWraovLTo4Ptrc211aXV5fn11cXnTzdPj/flQulSXhZwoplEyjFHDdOG8SDdOHTeo+BMWY5yoqsIVzaM18RllntmbZxTlW0WrYHdfWZrbRGjnTnT9CJGAmZQ8YGvCVr4DDFm5yfd/00vERAFsb2elpIRV5HhtizMTdKe3E2pC+iijFIdCFEi4pDZV539zW3uk6rJ45yBVYt04ZEKQ1KuyZwjRn3TF35SlCljCTPWMO2DM+vHb03SkAomPz7zwBA4bXh1Y53Dnb4kkqbSVALGAqAOsI7573hNGNQaQ5EKPhoO59zsWJLZdY1wDiRhlIv3hJdhKdeQ2RQ1OmfiRAyl79wqp5G5hgzz7bI2y+RghuqhbL22amZuYmn56ODjxuqKXyik06tEtYrGQIfxNzft+tztZ884OozpnBLhfsfZhSXtHwf5VZw5sbWxagBn1qe0cm7fdBZQRiMOibiwWChHIBMtAzlua7a525YXFE905mkd3WpAlRMUTIdmB0cuOuZDuHREM2MC79MVXaQGCYG5MuziqSc/MBgCmBhQOzpFh/yYYQ5bQJaiUK22lpd/N0c+2J8h7fVV/KUACI+qV31I66aUiqi2pmbVHd4SM52HalI7ktgtrGlr3nKha9PGtQs6p6xekTQxzoOBFiprBqTiAtI3UDE8M05+S+uL+cPrY7+31QfRhJ6SQ3WqAD7luATsLTvpxinhAGBOddfhZgiDJMJTkiAvIiFfAMpig1ZLiPicBaTy+hsSFR6Qn/LzVNZGYdGVMPa7uQBGQE6SgNTjsYkwghUjRjbdvJUQBwFIiyPechEDMwxwciOQqy+++ExYcgCAcR+YmA5gdwekCh/LESSgzP2AbMwdgEG+ALrmUubqRVBL9sR7OqNO3uyQpIvmU8P72pQLoNYb/i6dIgRblUJCkZI0sHdTDgBmYc5N1goAmOERjxXAxEQga9TlzaYDgAZo0+DrwcalxWWREgpXwtJZVbXI8Mm7aRZWWGnfvn0nR1nLq8vok1LLRb40DnUj8PjI0VP0hDPAPPLSl8iWgOrs5W7dPYR6O+9AsGWuc3oBDaOBUWiEMie2cdwuzDjp0Llhr77+7OnmWjbs3qJk3D3e2b2VW9x5OzK9dmfeJGPzWNw45OIZKyE1f7rAg3iH/hpJadHmgt1IhWFaIMLQk4pjtBotZ3WLx5lLWbIiIetckUWZVDDh5l63k2Ntkm4Zs5jPPbEElZKyMp+RYmiFFkfaKBdtY/CNFYxP+PG2yTB5zDu/vf28432idHwCKRf0YKA6whXqBG1iNByNnn5WI+pCCs2EqCCMusJ8wLgmspshsFBy7hDVLEhdsXp2bpY7mB7Rva2vP4VBXoy+tIjZDPj09PNsfBydnrBaxJggHK3VqHIsPRxLk0hqgrdjjh7LyIOQWM1igGJtlCUAujm3XVGjimJ9RB0aLZ9sCOdd44FLXZffAH9kZIxiga9c9Ac3o5u18Sc6FqzQJrjJdAAxSPUfjqC4ixXC0cKUMDEee4yqLYGPabIwa0bduirHeozPjZ9d3DCEKWedf+YvqmPTVWcGoBosFtKE5A0D8QpnzOKY4DGSOx6OgNRf7GrEK5SsM6s8P28FWEu1NyFJYcpNjS+52EzDd4xNjTNMCPsJzCdIIg/VagRoKioOw00G4GGYWxoDJYQEsCTsAJEmxgQAFBkhBkIPfqo4qEB6BOBBpLUw1KtAq3l4DRDMc2hkmS2eyJIBaIttD3uD/IBQJcoFAZokGKRqxHBWbimCALFEABiQ+KbqzZ2AEfZYVzGhyFKCVouOe1cYywDB4aO/5BPlH1knMej0W0r5EX2yKwPAkYZyavspXwACHvWXM6C4OO1zKaM7ZohxPqZMZXV51qelPRDlU0rEIiXATbocSYk3bmZ0XG50ucu3qA3HVbl3P10KAH7KKwytrgJ5+NUwYhCo7rSo6oxSPaKsMhG1OLOoVhAgXzySkQprFYCDJKlLDaYrQECm3r4qMshyoUaHehjOwIoVoP5lSsMnyDtJcxLagsymB8TI3VdgHZCvrygJ7fX18PAI1ej0NGYAGoavMrVO2d1bPu3s7Fu0QGrlApviyEhNebdQgoG2ifS1CYNEQGQXXI3LopNb+sLCpRFUHM/v+sYmHlrUz0BXXAPYLCizRtuCoqnxJ2tr20/WOIKuLac55WK11JjhwxWQAVkq5e5hyCi8wDBnfeVMKFOdl7oLWt0RNJRlDmcmeNZiUii6BRwau3c7B6qUC8MzXL5xJWT2F2sAvAfEi8+ElR0G2fudCT5n+RpKm6/OWg3F191qUcV4HqysjLYGH/dkx1jWOeGApoHU5gz/0/xUxtE2NxkvOuFZZYHBTFmro4yhTMctOhHfdOhwanRGC+Vur1rsII1m7Y/KE8b2YGHt5qo4Td4q/mWNEUL1xW8OIQC5655kMeY+2/09a6KUBPPFKBnz0wGmYErlITQSSKXoRRQQecaMLKOoAR1A1Aq9KiKrJPUfKllSNnU1ATCO1iF4J9rK5FjO8pI/acEJeg+kJDCoC3OruTsmB8/d2I28e7CPKvn6OVh/4vxOd8g77Z4ZeH7jXOlLl92wwZijpkk0WQSrO8nVrdXayEKnCQlLUoh9TqPTyVuqby5eK6aAjPlkX+eAugbS8iqcIQhoq26UjuMNn62NxzoGu7Kj0GwykGWL8TmXBh6WymZb44w5lqI5BxjTb5IPT+Jo4niR1oPDAEASTlJBw3Yn7aev4lubw482TU98Kq7WcEsIXhuHRDxqhckG/B4xWgwMluuIHyy5vPrJ+3fv2ES6aENAn1Ruxmsx4W91cljkl1YoXmpvcvgvRDpFzTLLOgQiBGd12ZQpR2DNakR27p0ETmSEtzQk404aItV6gQD5SfgaQnmklJl3UNdcRJdZegHmjK9yAinsESbcUPv6qMVwxCc/uwuVC1IAyJdCwaAehaBBLjDIDmsESAliwrLKGloPGA8CEOlnAwtAiAyPgBwDWgMfeBApkpYXLxUY+Ku1pGKaHpG+Jn0FOgskybrfKJGpr+BhgwfmjoRfKfwECQAHGqevBEWkT48lUih4xMhOLuD9lFxG0ErbDhxhXzEqLe3KJg4KJdUGm3YE2FcYPOJlROkoC/Ok8wL5d3/3v0iLNgA+QQWPMBMSjICnc4dTWAUBllB3292JUoD0FUkwyAKYMx4sgUCwukOk5qFaKSHLS2zkjsl7fbG8MDcYzG4/XX/+bJOZ8fHdO2bq9pMnJkuRgXLJO/eEaxpAvh4/kVSqJ6foE1ZoERPHkH2Fiwoah7tSo0pC9c8jTx2YmC3x6zpP2/MoTioi1R1jkHKh/livqkWLsumJriQ3WfluDsAkcyykqDaovGWGFWoQtfI3wyoSkY0ZcjxpBuJPV2hSsWJqVzPmeJrziuBROosm9J3aHSQy41ID0yYOAMBgLHp2oJ7AwdGR8ZDcZcqsRhXxkArDJZeXJGScP6ROzrH8NxR6wso8kkau9NxeekG9NdbpqsiJTkQN0sNkHAMJlxEH3SEZrZXuz3KmBxdETC50Gg4KwGA5jnVHApBrxT6trqz1KsP9g0MYFJCHHbVETg2iVkXgmOSSqHolPT0e0W4C1uw7fwM9+mX8M1BjBKZDs6SsOK9LkNfi/Kw1BSSN/8osFSQMOQt5LStSR63EVJO8aD/loOUpTlKNGLmEF5+G6X6qOFWGVCSJl0oX6ad4T7dW2HxCubzwSi13ffkqnuQLKLtUfvqqgoglj6uSKmanlYsxgS4BmLCMPLLwE1oPnpsh98mDGJ/027JWI1QasKbQyoVOVRURM5/9LRc5KqNIfYBySeh5zAUY+iHpSISJkUS+aidNXa7kzxuLUeIbIOjg8gYtpXhfwWgd6LUripeNaFrCwXzR2faGqQ5rrweHh1nRW9nIXgFgU0lyFdCuVAkzlqT6iYkqT2Hki1DDUjYTo8O6QNLp2jZ1ya6t0y7L/NNR2tTn7Pc6XCUcLO858loO4Jejnz4pgnDToCByFJapqsLYWhGfsR5gqfQQhqg4gH3eKlg8SPyBRKvDbp8gSWuu5tqchdMI0V4PF8gZ03DamG+kYrwtNLQs2uIrPwm0Rf1xel5cg1FtktNR3irCT7l4ZBqRqLGFcJ+iip0YpaQ0yMLCQwcuBpFIggHBMBA+hIkBKYbWEFZelGOvMvqpRAhugcB5VeyTfAWkJRaYhieSgATmk4yUWnIAv/rVrxwDJ0ysMbDzAmaf19HhAS/M8mDh9evnK4szVu6/eLppethSd5KPPFkoKYQEwEZZXm/OTEQiQMddo417pw/DKYZdZubPxi6WnIUx5Pt8ZIZ53EJ7Vp4tZpiDSIQJNB+USy7Kjk48kREAX2WhfRoy449Jcq4SK1icQ69+dArGCvgA2FtaRCIAB7wVnD7ypzUI+0QYxMMJoRgFFxaQkdx9jdi4l4Y/x8xnGsjYytqGyckPuzt04mB1jYHMXW6yVO5WnfN9z3GbuCHlYIj5sLWdpFxqEE6RalCJGAEsHwUkHr4i1cVnALQdkOihZXBVOA225lExARhm2mIZCZx2xBGvWm5wBNb6Jc3f5LOj4i5GsOKa4ZcbzzEZO9EDUnZNBtq6WalH+RIVWchO7nJpnlvJpN/5p3/6Z/ltPX1mFxg1xYxFiYIcHx5ZtE7HddXEw+9rPTwBHInnZ9E/WA2tGqAOaSN+RcnxWfG7msp5lfEEAc+6tdkp27iEdTQgmypv3YAkqPVAy2kZjWsLUbW7ljTSWH7CzDVkyDiZk4iyIsec04VpjM3dDx/dPfDFZ5+Pjk/OT0cGdm9//KkWg9Hy6Th1wN7+0vFMTzrUD8sRj58UF4XmJxMeYR7lUmveHtLiLuLolkxzZD0xI6kKlY7fA1LPqeDYiyTJfcUc9YI2f9qtP0VLvdjlMTrLdIKRVkZSdyreT4tLVTHM9nM4jY7eprGXlgcZq8IoJaT8kuoYcx1yYPUuZdp0ZMxY/QE5kBId9IIkqhx9wvhLFOipbjYWgeA1ifnxxzfyA6OmtRNEd5WH9OvrL754DYNWR3XCqYTk/PnzwbNnT9+//+BUJYRprrJueG8YJBQDZze81mg6Z1n7hFfIFpYRzoLUbEAixhsiioAmhcpDf6l4wJAogtLBgx6Tjl0oSDDEVzjFQwgMKoWVl/Iyo6hjMeyC3//+n3/zm3/TR+jAiQOykJ0kAmIUB/3efgogVQPDRvIAGwDhf/3GfDEo4YnDHwnNbkGo7J5Ckh4OYYrpQZ7cBbjdPN988w4GAQkVRHbCMvKWRC2D7OIA8CiFkoLssgdjiRTpgKeZowPDMYDo39nZZXKvbWxmb+S8W6evVta33r3dv1uYfP35y9Oj/SevX/zN3/zG9h7O3+XBhmmr9zt7N1O87SGYJWHKrsVPRTgCw1DLzOrDjY9mqqzkzxqzmKKkHA0meG9vDDejfNGJZpHoObAIhMy5cHx27vnLFyVLkVIdLXXJkOJTsEfJgViWgNP3Fs4LO7NT87Gk8/LujJtSw3XKCZLIF6Uia0VemKT3r/HcT3lZ2/7T2/diMCr0mGZ5uBjgnkiAx2S2kXX54NXR+AWaMyLEcDWF5+qX+UE2JIQHfHOeFAmoGmDSgpmbvubeMhLj78IBR3fN18XLCg4J5NJytjCSJi6vaA7LWllk2oZobhMuhxiTtW/fOWgCOjmSgRhiRQD1AXUsKKPSYrw1piexwTRHzLn2xIEHtdg03kjcZpN0jmWYZwCkf8EBAdTatget3dS65T2HDE5SxGtW/RIPAsaNNj23zC2Uec3Y2pNL9uJe3Z6dOHPpamWwpMhysfPSEJ2iirvDyW85mDq9L8qLhszT0oEyja7M9eihvPjsULyFczzPYeET2ghSY0zUnfQm42GIWsycQWxBnPdEJ5bZ1AxXF4oAW+lSwYwAunQYDqEqAwNJwQQAEvHD0yH15adP6pc8q0TagGaThPbwE82+ensQ4BHZ8WL0yiZmaHaUsCU09jpFjxWInnteIh0YDkilIjp3YVSBR613o235cY8MYF/D0tKWGd7F2KeFUqiQnn0t0RHhHhKBKqriERGxYjqbR3KVU5YAgBE75YRRkSiChscL7ZAlu76+JpXeBRiYjY01PV+T0nUJlSSy11qErakQRm63hPX1XDuFYgaHGJkqlUxhoJoRALknRSi9hk75aocwYLpIFSDS1RDb208RIEmTCgA2Uii5AiZc4265Ix5tMvIWKYkaFTb9onYkFNMcEG5qO1/VQxaRJy2c6OUYYYJRxKNRsgDsod1wDBJFBozIzg4ltoI8Zi1AWymavHyShXdjyMb8ElZMqK7owXFPQckaZnlBizwAcqGmxXz22br+AEPgoflsi1VSeGD21trlxeDyRxdYRMhiNjtKE6WYtZ4SJQhAGEjNQV6DpTQDCFVTHPN1YOf8wszB4f62FWkf37PT7eRcdgjv9OzivM7JWS6ZGdBJ6ImXVpbf7R3PD1YtloK8eQJbqsNKFAzTqm9ZNDe5+2XaKY/06TlBYRi591WrPzo8GbeIRNYtSGWqK5GjXgwLFJBThoVrsRqFxrIM8oyhs0HG+Jjn3nKY/eEph752NTwa4jonESVmGSiRxhfGPW6qXD9z/kO1VmU3KCdsAtjOYk1VWk3h4AKoS90Lc2jwsagLXAap58P/ksMYMaXUYgqQZ06PtAs61yxoTQvjD666XmlyIgcygy8ZYNvlHC3AimOwTFvopGLluEvDRZkT4xS5AlIcBAFywDoA/KHMvElmSxGqjDvNtbebC8+dBga5uXHYpDLl74x9rog5V0LmmGTjxUViolODx2gEPYbIWj3NrB8hJ/Ilb6aQW/wMdlScHWoHe/ExKlHM8asbx5SuLqnAiKVKVwrrRXhg19asL0okAYNcEoHCOXN5Gt+jsKy9a/gVh5sO24gJS1k1jsErWzuuOSvJddws4Tr1Mwv2Mb/Oekhf5Q+Fdf4TmTeSPOF5T3EcMltCrqtBhhxFgGx6xKhEefmZyioiyVgTLAa3DRSMZjx8OBku1Ib80+Exc/3p5pMcRWVfrvrgdrdsJ1MxsQbKfE/9yjGFZxkno0xOCgPw+IQO5BEJb/Fy1KmQg/PbkexqX0fga9wcqlUebAx/1acHpOg1d0WQkeaBWsDCtWMk3ZI0EwaMkALyTVGJgjc9Qiixm0WQCisNKHvllKYxihSGDoy0lhXrePDdYzkUnJHmsj2BSSg+olmPVLLnCVVOSsobJDBl9t2q0GixT/ZdlTCdRGeNDBRK7gEPJwIgFJBLx2t6dDAwmDWALhpgYOQDZrWIp+DBwAxMcWCQnLIGWf2Zwy1OZeenr3IBiT8SdjfDVQUDKZdc6T77bOv9+12sg9PB5YogX8CS87nL1KMIsuh42DAZSeDlIgsPeNj8RICEHsAg9Um8LiAbrfbwGIah8cAPg3i5YKPILvgjY8VIjgBfO7nieOAXI68WbgRIojtvfvopXoUa7iim7GTkXZcBWG15TOhyBoM1draDTd5/8dnz/b0Pq8sLX7x+NTzcRY5UkBtjZM9OWe4wkwaZwowSP5FBcKN9qV7AbqZl41hHqGnV2nNkY4432jyqFYvUslljBiCPCkOU6X0yOqOX9RWUl7xoWG2ApU87n2cNo31emuG460pE6VOsKw1PJqfVNTpxHiWGrEZJsta25SUSnQLMOqofGSgnLQqFD97Nf8wHozjqDIDkzsdGGwmB06dmrCKg3BsbJYRNNaGhcZIfahoaf2zhGN9Z2keFxYMnC2ASSuVBGAKq5Wfjhhz97FzAyLHYzoTyP28nCbcqkq1nsewSrZ2JkFyIZk+DuZ9kigz0s5NYvQbKWpU/ukimMMsRTskZYDlVGWSWcamUdsxmoZdzGgwHc//MWCbeDLZORxeTs3MOtEjv4RAL8+01Vke2vSMsLmAexNNOcDb96kIAPcqIPz33oBaA4QarxXkt6h9VklABPgFm9TOlGRNQxXCvflRy3FAFYASgVRxqFjNh8xOABx5s8lY1Ir3Jj9wVGTEgpWqqgHW3KkaYVJRgZC5EhWop0uIVCZFWQqm6yqqyxOXpTCUXkF0XXPgxJg6o+iR5LMpaA6IIkFCtPjX93jJqwfBWTDQjTBbFPYVI685/NZRBW+UfRZRnYWlRR6En9Ede/cUw4A7Mluucg8+/z+3jq62WeisUUH9ygg5ZAmK8lVwhBdQlEoWVHNEO5DNY5OtgS/mziSPN8PLM6hTt3TalFy+fue/NlgfioSQSNk+pG3j2988UQwCPPIrd1INRKtk1vLd8JVf4FKqmppt93qxy8I1cEhtTwPipqpRCa8R9rjr2iIQc3MiGR3aKpoyQ+9k5FhXlwahJacmbKjDKq77oEZCqH04PAAQMh4ZHab3CYXpJGPolERYA6RMkSBIQD0MB5vVYYQDgF6MbazkD2dmBF1ZSyRUN00AKyJcAeczGtRghA81KJFOMlRxaj4BPEsKv4KWv0jGDgRw2jJIFAM+ngnA0Wq95P6fd58rvZac8MV1M1VqrseakxpxBb5dpJvM52/Vbc4tLvN57B65dPKdUzkw712BRphotraEByrGVu1wcS4oThNxMszrXhTH/0Unv0D7EgUZmuhpHQ+6mgTK27q1G90fFa6A12FAP6bwJMFc4kda+HfRuWQtH+cLiIM4ey5QyQTpbGi08R7MkvL1MfHY6/mDLgwDoWHJxXBiIJ4D90G0qUbkWoheyhakkVhnFm0MDo9nJTl/FD8tZhB5tTedka9Tx6Wh5dQ0ZsHVCX1WPXkAuimyZXJDejQ+WVix6pdNJjibRwgagm15LS7cOzvQ0T1Z/t2JKIY4g7d2pD9an6yCnFxfW3OZorOual6mxKeWlQC3YscHO1VgWVJmJ071gKOe449zOT89to3XqqrdTDMLo05EldJbQZ83f2K0D2mwA2XrypAoyka1tc4sn5zqDixPW+018FE7NtzXM2l00n12MrL+ldnTb2IJatyOwYaPN2SK4aJbRANekRhZTGNG5rjm6G1sYKUoqkAqOgosZbRRHEzuFQtdLrnT/JiEIgz6I04xyBimJ1spXkS3S1JwujQQmMhpGKlUABvLG76e24Kua7UcpNLdudFS/r7SHn0RX24TEwhYEqx36RI5iJGzk8BMeXU3+6ukaRwC7PsZ7qf50mFRnFRAxYHVJkCh0Y9OyNEAxvhajHsJigqGNnRIn4iFGvhI2cjl6ssGE0SEKiTinPgSQJB4WBZBGfsmgpoL9VHIpJVFgkRiknTjwXeFxHIbvvvtOgOTBAxIeb6j8pJKASSWGb0RfovP0k7J6+lTflQ1ofkorwEHkCF45AkaAHL2FO7lwfxKDkv4pCxWgtKpEDNpUjKf7TxVGlQirdTBdwEciUaKk3VtIK5WyME0glzVgj7J3Rt7yxSVgAOhHN4UoorpvliLSAx7+His0BvlK28UU9lVHAJWAUnfBHY359GnM7S6srs18g4yQUUkioPXV/6lRVAoAwF4BagI2BfHuHqVazsOAWhYgcQlt+KNX6EoBDLmncGaQJDsP/MDg8YmfTaALwlkkPFhdGB4dXp+5HHRsZmXhyaajr4b/+//2d0/WF50Ss7Icyzf8ObkYnV5sPH35Zn9fj8Hs0DA8vnoo6tOTkSXZDkxzPpomqb8yFJpbXpipiwl5Bc9MMFswxgNSvOI9o9SoS8ykIR1Yw+ynrY9HDqIZ1+P6ltailpz6W8tXTLTe2eHLfz1rH2q24V9fmT/nFzc1nWUOrNl0mTlVJoPLzLGWHc21jtv6L7qD/IAsH3SyB4Y5qYvSGhJ6mrF0NQElVFQc/msjEgI2nBDGzFBea4WNjbUFCTHKMCjV4RjqOEDKMOQUu7zYXAWQQsHQsiht733QKrSQpiS8sNg0+xhiuoIxFrIBDeVGufS+PPn3KVF+Z1O1lvwPcl/VHmSmhW/m56hN7YwzY3bCsGquLuKJloiUulw9jKrRya2FA+kUZaJGrNbQrJCXmQHdbnwOC2trG3OLaW4f9g7dFKkNWSDAClAEkEZ4Ckhps8L9RHeSR8ij3IURjxXGQwIREg7Bk6v02Vbt3l1xV/LWgPQVP5O2hmLUg0S1lTpGPWG/sVO9nqjJ6LFYGPxsFB1SfAnJpTGzArVsf9mJgdxbrXWFgvf4iUhgAtrI7e1AcVScJNpU6xkEiPTm3gCDe00AeiCUXS31jB6rJwtjA9CbngFgaRUZJBHxroyicJrOoiKuBa5dGBgdTbZEaBCZhOUUIWaTdm588g2IT46VsyRJhWKfUeYhheayUCKZh9SCEGgthh0glaq7OyVEFhjwAq3HfQ3+WiQrFRLFFNOTrwcFMsI76gNCkIYz4nWQwiCby9wL3Ca86vICgIOdEEL5FqbAA4ZNpNzFQ0hHNIDcEeZBoeTeKgl+BQRm8S9rTwCqrjzwwnC6zcfgQ5hUdX37BFJaNKAcQwQ6dwa0r8CKGxkoyLG/wiCg+Do5SlZCdErVmQqLQXwXGRgk0oKUL1kQL1IMPNDivCxwQxgBas1XMTD0J32AWoDcT5gVWRbff/89GDg9svYWT0Swy1eosKWrQ/iRGJGwoUcSGenLIfzd737HswcbDpuZ90kYJYwGPmJaw6Tf5voqBfvrr3/58sUzyyk0VZOkVigiFVW0jwAK5UXSeDUYv/5k1wWRI44hQzG7pCDBW5pi+G5yT3L0N23C2Em/22vL8yMy9NhFZnMqAwWaLOiw+vvaiZgeX9mVBh9sahVjmQuNhBrD3Fq3bk9CmjRuP9agKpAdAsIZ2zJNH9d6OWMWmsKAhv2I/KXFAS2ZoUe8Cpp9juNSN3VEWM4I62U5VY/GysEJj1xUNCcMNYo8NSK7GtrnWEcwCoi9IlsAMMdCx67r4dFxtsfa/FW1D8aDjfCRKVWD4H50VHGo1YO3wBQHkUwKS3isKWofjmmAHHd9H23g6fUwLGkblCwc1VFCTrqQBLmWhDrFxxBUpWYf1kqyV+6cIX3ucFktqQ+ccezS1Ew8cCxV7cusSXEVRRHqyaw51LsLiVFH2N89StPfYtY14n12zuUQx33GebYa1MZJXPJJZWCaZpmN3LW+PjrhMssL62SUZWRbC2vmX37gdbFZGmtYhvpq+AYBHlxqdiFA0bxbJglYsTmtUgxRgd8jwDjzFakIgFyOjzCfOJYcATSvOhdIxIiXHczCyb4oaWBhMJFqC3YKTC5dQeDFeJo2gabZ2zhUL6FemoFp1+MTFv+gE3DjF/BIhXWZUqcT1a4AckGIFUArAZWTUhFiABJAhyCQsMNIF4AUSafASNDBSCggEhgY5e5BToaP5VdOgWtsoSmzKHkAlMoiXnk1AQAEvL/88gVdA7PcvYOtvKuY5RHuGGGYsR4Y4kV65A4hMro+epGG9evywh0NuGfSINHTdHujlSCRkYQoVbv5WcvLsAVOJDVzoBXWXPWAcscHpfYg++PHPW0MPCQeXyHsT2F3KTh0tmBxp4okmnRZXOS1iNNX7ld8loXkXSJVIGAJKYI1YAhRC04WYtCpmMLeEgrQ2rAJg2yywSDbI9J53ZiASGHJVTT++Kkg0soLmD74yZMNxiAM+rD//t//OyY3TrxFTOf4049vOA1Y7r/69c8N/y0A/evf/vrs9OjizI2+ca/Fo8JjPBXl/nFv13Ex6IGKX0XWjSr0ryzTVljHNYQ5iuar7OgNVSaG/Y5OLgLxHo0maz6oayfl1E2zdJIacUUlr7Ny5YbaTEHNLS2vPXn6fOPpc6rDsfTSalJ8yoYaPJBWMmcFkc7A2cmfhlxUr+rmOwrPTUOzQqvuVnLXQh6YFYGEiFdHNjVXy3Rfr9MZssZRT7I4N7e+sooSQzH8hFzWgJvnKakFj7V9BEIcLl+/gloJH9czJzsRyEH6587QmeQ7MbevQAjDIhaMA3HIW9cvtLT/2oqp1iyIsINY1yYjjT+LAq2suXSS0nQWOM44hSmzAjh8NDxhq5uQxzqOteW1VTyToxZr3ED6gGUa5jqH0yES0+gGIqHJOItYcTTK6tJM9JJkooLwtEGO3tHp0P4PKwIGVu7bA2ypsd7YWoZpB8EOnmytry4v8jiYNmAP274wEw+ZwWH0r3ztsq4bq2q2o/Ye6yfs5ECDtzIqnVIrDrmSo76ESFg7lq9WINQiJSIa2TC4cKbE+UjHqjlz+mFyimyS3pRb6VmoyD9mesOmXsRoCB4x+KxBkdIO+wSym56AYbBPfio8AJ4f8GKkJSFQCUvSbR884r3RUF2A4uYhydL2AzjwtWMOMLDupUxpAAAcGa6nkqbjJE74j/Ks8a1NZ2jwVS4+oUGOCJCwk1dvSyGfTbjs2+rjaBYmkCUNl1c4KCfbyoeHxyNHNLvvtVQAUigImzPIh8OzLHiwDXt0xr9Jrm4Xl1wGcp7pNWc+Tdy/+/huUQWbGEfq/c384rzuVrUapZNAq06c5b7+ZJ0ZMb9k7+TiuH19VtEuLRqukkgLtFkNH3Z2F9zy4dQgedSITBkIIkZjt4IppJ+YpQ7wWitKu61JGzJoGY+ZBid3E4acuXrJsz/DkTpYWjbfRVJZENU9TW9ubunvDw4MNWJI0kpcz5il0TpG0vrvyRmL42aubi/Hp8YWBvOXN66BzfSGfJFhO4g/wLLO/UUWWS7M1R6GSbsWLYgxu28FQBbl2l5gjc21jtrJ9uz8eD7394ZGbZq3KqArLZhxfcTu7tBAhAwpOAFScE+XbmHB5ZSrNL96pbixosUC5eBFbj5Z93d8cqQtIE9/DAlSjQBAqkd9gXjF9JPQqNYWFCNWnHHiP0OJUO0f7GmQtBtlAQw8Ghiti4MFKtMMKVvMXOLS4hojy0mYg8WZX/zipeG4vcB8QRHicYrDAMJKqhyl2c2JzSsXg0c44ypcTN+GEr0FSVO5EiKYfuyCb25sDU9Hlu3MLCzyXntOjoaTHDLU+PGhQ4FXeCpgnLSxnOd3hQrZWFmV1hyWnbY0ydHp+c7BkOiurq3rOKlmw+aL06OPb75fnJ120Pz7d2/4jqmtpgE9lKOz0mhH0kgfGYmhqg0d2xTcdZQpgzmO+2MyjBsOOjXkWF1Z5iCx79nqFyurdDWmQ3SbdJN7Ak6PT2ofnJZv8fSSt8GEk5ktSVpxeca8tYyU5BWRYzbTyPZC5YjNcUJ79v13b0ydDY9ZaVeuFtg72B2dH09OhySsI/nEwEMm6bg0bC3RtKHO6ezSOf66w+vzG06g4/1DCtIlCNaeswv5312E4AqHn969XXTi/5wFmi6EMTdj5ECl5oIwV6nQobZez85MUJ7GOV9++dnZ5SnrxYSKSR3nC7kYcGnwxLGqo9PcEpNBwN31+M3FwrSVRleX7lroDcwmn4zlXP5+eWLSyuk+1ojN6uqu6B/msxGnaXbbm11gsGgli03jZEyX43DZ3ElxfelqIFu/4ifMPed8xdrZgo5puEcS7haNKeO0Mvzj6M+OshykkTOmMImdlEE20eKd23q2/fpnX1oUZTI5G95Md9xeGxcaI5ojWLAr28lRDiNyzYDzo6wyMO7JQAb9i3ZsqBqn7auj7K6Ymjy/uuCP47w3v+i8fl0m/aDtyDVt586JI5cm2rnmiBYa7GCglmtoZdGXvoctCxkl4RQuG9fzhE7nNjMfq/+Ei3t0Y30t/Vz5AyBXcMv8NZq6f5j3LA2HziQqWGCMa3CMgeoXD42fnUfHfaSbNMliAa6pj/gKKru8KAhvDYyyoCWoEurVT82enAlb6nN0PNRERYa+XCKaXgWk5qHJecR7qGaoQAKQhWG4pn47n22u8MDvK5mghqSFjfJKN1c3g4sXaXAAJzw+QaL9AZOXJGIEOmsMJfcBqEfY/2TIrHI/PjUekE22a0zEeGg0kLQSCn3qcgn4pAiNii0BDEBlF3oQgP7xQUw5y1qAKaVMm3XKI17VQiKJTOWP6SoJHhKMReoJHxQzPEm5bMQ7WVqKq0Hav/3bv/Wenv4n5mSThxs4z+ySSvMGpvg6PMkRIyxGRmiDXCQbpIkBb5zrZ0MyiCAE6assRH78eMirL16vIwskuU5ye/sJyq3FgpBT0Ok3HA5v3rzTOWkehIQFhz8ra8t8Kk5ZySmVg9nRycH2r1598fmLi7PhYGneeRSIsY1xd+/AZVO58HZyenh6urG4nBPYp3Kega3wNJcWYkrQiAFXzTuaVRy7mXSsv+pgJ2Q4Zrr3ZsIaI6fc4HOqSTO+4opcdCp0Rgw6z8UF86EInswV4Y4TcCaaMR67btry8EyqsadIckZUGVrpl3UYKHTGgsYZg91CnYlLYZqPilpayVJua4rwBLsICY6pV0RioKfjBUiawy5VhMVlOhGsc5obq/+EAcVF4GCkT2sBBBIzk23GLclZqhebLrLEW+1saoJOO4hXkJrxi6udgYUwRx+bX9U9GMxfjZtLWLq80T0YXDlDIY51pp9zYzFMwvvp8bkLU52W/+e8HUXmsNLrzMyNgbUq0dEsih+HmstyZ2eMwI5OjjETQXomi3ccwGwHk6trep2rU4lY1sHjwLWp2DFypFYUXI4ZB5xd0Tc5pIxKIPsc2XfxtboSjbdHj+iYECqbKafD02A45yRjD+uNVIxhZ+Zfar4kw9q7MUfD2BZlWaqJAw4YK14h1wnYWkCMu7Wqce2MibP3fscccaZPs4E5CjiLMm0URY2lyQtzNBjm6/7Rts7xcHHx5u1bE87sD3XR7df4XNZdIpX12LiUtG2XhvRJLfvK8I4bK96VeA4h8aY8yr6PBymuwtxoP0NsKASMAtBvGBoP5cAjGTDH/nA2lt6wO/v8JmeIWV7RJWXB3s9M2fcHkqzqNLRu8DBrGXQLhaVNffh4QCIaM80jrUetYRQ6nYghuYphZRmZ6ajiXfHB56ZMSqVVNr4XXKYjJKCJoAagufpEG3p3MaAWULZmkLS4ICF4b19ByqIpEBYgdlD1p84UL/onzI3WDIEYhLUu9vb4iacCYOQSZn2a6Gga4BHvrcxyF6maZap0MEOIEvFgGsAbE0mGcnk38fCjCnJfkUqyDYo1CbbGgBPWkpebMf5t7kztindAnbOwZgyZxhla6fA88oIHEtwz0CcbaJCvByWoAmOsb6zWGWXFYy3bspdYGf/+7//eQtICz4jPaADlaa7nge+imX4QRjPMYBSzmemrgEhJ5IIAQu+r/mNnJyqpZ7lRgULWMIWOUVChSlfx6tVzCSX3REdfXh8eHEkuIbSIlwqkJLQy9wKT0Gr089MjZu/a6mB9bZkhY0MmnYASqNQaMkzZGbW09mRTSw0V4uXLm1Ndo25JPHrlHA845w/zIBsLGDwPJ8nnakAIPRKiHGFdTNikJPrEwnZXOsaiw+xQcgROzHeav64ed92KI4GcVVeWCsLoSxVNepEEG+aLDAUlinLR2GDG4RS5GjAOACM5+CAh042LSIxSSKiMwgSYnaHFAVBM0oVaqLpGpDXqgkf7YuggAP7OhXCY3MZ5xMiOamO3CiimVFAB64wWl+N5QKe0qka8N5wi1TjKudTi3yCE5ldjD8YtmSJXI5UKsCTQCqABKpQLiATZwISQuW3xFRcTVlIFR8NDtCk7T5c/ATh1D25c8Kj0rncEwCB5/2zyYJZ7Obu4czMnUAs1HiauUNKZAvNIwlSHX0D10beGyA3TMoDsyoJr2kKMSDvCuvhRxbYJ6O3zPOAHLCFPAPcA8ki7JOBBaY7CeJLiw2pVkpaXiYZcQ+8nR4I1RA6ey9lzudrP+eFpBZLAqZgC3k25IiNbPIaI13YIRlMriU9dud7iU8ySK2nRqoAexKhxwgimEyKym08TKaFPwv0VTg9UWoa0eiDaH1okeVpIBJAEntvPgYWSy1FMtL+M4RLGF2ExOAKCmNIX1oaSSMWAGoPEAxOj5yHW8JJjZSaXfmJoT+0AljEifAKPOI/svWUhAI93kyXr5h0RFIMYbcbid2WGBCoXRjaFACRvYAFsghweD7BmIgyZUi/k9SW5NIASOWhFmEJUNPDokTvkigasyesqAcZJ6q0IYiw5ByBTxQQmO40zaZ2yWEUD2eVN/p8chRqyJPCjs5OT4y6vorn/8qef9nTICnJ4uA/Pf/kv/0V2kuAPbJKoS/EYDidxDDfi+8rABbcBQK4g6G9XAEUDQLwcLfvDSWBOb7aqCpg5K8Z+E6ziIBEpiUKBR4bbE7vIy4OVDx/fExfkw+MOQow3Fbyzt5Pdj3cuC4kv5fWrp1YJ/tUvX3z+6lnGtuejPx/uORRIvpwDrM7xqXluQ83XaT2Ho4cFHkrHEiw+uCv4xCwCi/328jxdN9Wv0o0z7QaJCanE6RtynGWtAlJeYgA/LtknfWFRII+QXcTOtByf4ja4s0AkK+hUqxrUjlOJhtocDsh2NSMbjo7mCEbbzCwPJBtaz3M9PU/+Mxd1NYpJRG9qwyRfjh5INDPjVA8GAlApAuCn43hfYB/gp0e5/FQFionUoj9ok2o8Z4dBpb68AVNtOA+bFmQD/PD40H5Yku+gFUQqhm7g3ds39HiW0tRj8CShcsGsZMpoDay9bNyVJ6cj6+DNGfiNZuqF+VJq7vpkpLfgB1cts+4hJV1Mqj4eF1bEmEGM0//qimvRJqb9g92VwRynFjAZgbXXGtkugbGCSLnMwiiTViGp/tu5fXZZMcNoZGYJgvXiEcKZuF5r2W6amwbH2MWcmP9X6YCNYXiVmYXkENrMW91maQk8B86qq5MFLs6OEYb/g+X1NJbjIUSEhf8G3yTUtMn/xuaWw5vUbGzF9HaxNVWRt14KhhxD62LF5TVF5o0nQvgAYeb0cwNX2hGwKlEmgQQUAQwOCHRVipTcT2jFaH8BKyXWkMUuB7RG7904raHs18ck0SNlqgJ+QJV6fFBTSPJQIWCC7a670pyYoIxyxAQA6pRpBD9eoZmWIWC6anIqlbRgmkLF8ROkN0gY3BZKqgFkTxNaW2XYcEOqQHhoD1j8lMyD0XikZnBWPPluujsbMfIWIyFIPZg80AezdsiZKtJ5VGOz6YusYei20RgwUgHiuItf2JXFi4wMGfF7FmdTWmiFw5RSahJ2Cf2UC7bKrpnbYMK6cYWXEKSvwiiM4r5yUs0qVMfDd/d3Q02R/0C8HDnig4f6UClZJ5fmYCnJYMGcwbgOQ77IswK6Dxk3rSEe/vSnxXRzAeUrVnPhHiqg7dxRouxEEgZZEFlZiUTAzs6BOT804Fve78a2t6NWMBnZ3vbYccgomgdl8AjgKGDFpynk1XyAoWtBDNqwjt+GkjL7/Ytf/ALOb7/9lnkod29IyBMCkEFEVIpIK1CBieQLgQ0S9d6VKztg7KaDvX3nFx6fusP9buBYiGtN9PrnX31uHGT9eM6QuWH4cE+Pxi/v55cG9k65rYRTxgYThLFNw+0yNYrCGj7eOzqJPTKRG3Unxs7HXPtl6TcHxEW6PB+c7p5GZzpR9cd1YMYo2irt9t700fj05DHB02dnLTXCs4TOJVOWemO4fHPcpN7aalNtPu5d3ynzKdxQQD4FVCk7C0mRZ+4nxeMACqVSawIGJthrtthctDU5whYL8AID4AwkVFiaRjWZpWUo0SaRK2xGFpEcLFnnbjK62iFIvnKE5TjcDCnMKh+xiGV0eXmUfn5sAqlmLahdxgqe8XoZ7NFCWQVTJ1/d3Y5Kc0dZQBI/6njGRibZ9GI819QD7png7t5DDXJwIRj/5aDqKTG6BpMhdDUOQVIRJOHs5PR4eDBY3OZSYY1gPUcNp5CAT9Kaz+AoPr6PZud1EU9Byl4RrJBULL2Rn7hEDUDe/DEdxmvGsa4y4962EJXYGFaPRfsTa8WvcQvykEkETCNZU8qmiTWJPDQD1hfYNJ3lEmPlDHGTSumr3d2PfMw6HqqQH58RJYmsP5wMzcvyMikapXc6Os4G4YkciIYVGpFlxkhU6Wq/bGsT5uww3LWoxqroQcmD1XRUTYxFRqxCURLeHiVNjflc5yUD0E45snxSL7LAH2QAE9PMFwAvBkJuG2FZuxAhC1So9RzaTGizgId8Qi6AOZCUJolHRJKwq86nxWhlcVIbRrHYcEYuRU9oS4+acyNiIiuX26qMw6jcWL7gmkdMpMhHKW7SE2qmpthZYFBAKRAslIFXpCgFh3bU4nRhqcR7iDv3qyTqI492Vr1cNa2Y0rJoXigSMG9lEFAqXPOpLVYjAZ+EeeCh1TqVHCqRYMRAJZVH8ZTTp4B90vhaPUhJMAUM8gAIECYdjLTr64tyVKnALDSt5a/pSDzwiIS2i0+BilQjPdJQwB4MiYQzDBkPMfKypJ6XVdr+1NUGG/KEAaNU8SnltNU6dF6/wuKVEV3cbp+NzXgYqFlTslAx2O1WUgq+ApQbgcKjqUCIQkVgrAEWoyzIEKmawCAbo1pzGS4YWECLD/KSSgCYr+jxKJTk0goQY+1HEcRbw0eh2LxnzpxeMg6Qr9YClS1CroRaW+aaOPrtr7/65VefWctnyeXHj0cU8MuXnzHouanSNUPhJthq8n6oIxlhl9ItLrC8LOO5sizTxCesHBUcNvwJmb7L1tCcqF8jKv5gJ1Skf6ahMtzTAHCeJNAvuTWNw8DxapmZol7ilVUSspptX+Onx6dT905NuDPNavcSvUMvZROWGqzxgcao05+ZdO+mkZOZg9S+2QN0CqhBzASjzls85F8VGhcHGJ4ldYR7GGvyLnI1lr4TmMK28DtoQaUQE/UIp+RwalaaCAweaSVh75uSIQ+sCmDiv3nzp8+eP4uys5glU8pxvsvCQlqc5TBTFlRbtJlLY+4nXLrg6HYlcMS09sRDRWJVAlLNpSOGCkaqBIoEP5y6P19lp2YdxkZFIluvE6pyS0wGneSBVFAuQhjCp8dEp0T9iaYNcqEVWyCDgAwIJvzPEWNS2KiruORSX41FY0Vw+vJSoDWNEGGIs+t+4gCpfKrTMVRlih48KVbRNgxMezvi4fSVaGCghA5l442028bDRYU2pSMCKoXt//TpsxD/5z9jL1Ei8zh/8vEDOexqlYWA0kW9ZnVptGI/4ltcVRkACWUnEnMen65H8ZJ4Ew9ME5CpDsBPRLSKA9nAuIxyYJBgLl3vp6ECRSahvl3TUTrjLmIKpotJGXpQ62EZhAll5zFiZE2GtDX4i7zgkTWaP5GNexFjUooPMDRhGRuKRZ+3bJQ2PEuHM0XCROIpq1b55QFAMqhVJ7x6HnWDPp/gIUbS+ukrPCKh1RxVRugr3vkqiZJ3kcQjhSaCVqTmgT5hT/tngJkdgtzUf2OQBFViZCFHWTSDZA2DT8jzNrsG3sO/5afOAhi0trhQl+pY8oaU0B4dCOUFvsGEGyGHYVYyuZ1ackusnGg/mDFqt0QaZOVwVxN9ahR+Q7AF5kyzSKtohiBAEhUgHpHcdJigZivrRV/JNQJgOzw8cVofpcBiUzRMKDHKQEdFVGEzCsE0YdjQCaEHKuEUsIrgE0bJRUnR6UmDr0lIARWEz/Llz3EgB0jIwWj24OGJ/poYN98Y1AbIiwuX51dqNcO08dybpd/j6ye2i7OTd9f3X33xygIysMz3xbnoLH4vysTphwxPLhq14tBnTvkSy0z+I4DTZN7BhBd3Bj4UOf8Fc4eKsy7ESNBAnSnNx5abnejO3Ptl14F6NIU86UiH1LGZQae+175FqyzuJoxQ67ZX1g37OV5mlSLsn7PechIk0ZB7Di3IPiBNT+vKgE8kHlrtYcUZ+i35wIqBec/SDkQUAOHCXgdI4FhzHp8pbcpa77Cx9WRjNaMr3srNzQ2fOMTYL8uTy6t8JvXAI6EHWvi5riDUa2K+4zSWljdsuLZYlppPfVUlwmw9mNx1LpLoHhwwS1ezYckAn7QrOdHDJW1hFyWPK+KtNiQn4DHg6ubC0FrplNAgWyA1VTuEoWVeWG3i7BjVYYgBFdp0GJtr66bijw925mcW9A5l+FKPab/L43EIl7lP4SvLxPkZ7FnW5pAJK+4UB5JJ40/rWthit+Ma8eFx7r2ywTgrgJ1Q5qSm1J99a+nmqTyNebCyQcqGRhhkfKZUipM8ckqfWopTBFfpJ4pVwPBBPTIYcMPCK6dXWL2mRDl0aHpylLk3q7juGDMqnbR7NMmdnY/Ysji/AJ3z4ugB3KDfsAXZCFYSws/qN1wAySzzdX9/T1gzVG+yYNj6A40ICbUs5MADpgWG/sRJ2t0n9MuavIGnsoS7A0AeeO1I5ykSHuJ9nwsvr/STCNCgmY1kDnJsly+ci/NLEcIarXaHoQOISMVHl8ZOi4KEUBxISZJjjfmEy5DF7PhsvKMmwJGYpgC5nUBhIBKGEWUUxKPWUAaPxB7NmEwLSO4tYwk9fkLlgQSt8OOdMghAiOkQElAFAykV+vzk5MJrGUEFjD6StYTI0K7gFg+5nzBLKyGwiFopPj+VShYeYWnB8Nk4i0XWYAB703qKvLt7AAB5YNADZ2NGibaHGI/A9vaWMSOSYPCWBIYylUypx0EMShKEecraC7vgL1nJfIanyFhQUmEFlyngLjXuYaYkzYeXL7d9shnNli8dFZL0AfADMxQAqYCSgxcpFwSAQb8YFCoFSJTjCU6CacmmQTqMw/JFQ5GUMRA6IWFyglEiTmerEXpuoziWuW4WMaUBUu4Suuj1ZHhEMS0tuPTq0uE/v/3N10uLs8tLc5a92j2gCOFSbXm1Fg/Ts3OH9V6ij1QAVSMTDpA2u7O2PKChrRbkQbaKg0rm8WHC6+WVCLwxcSqfQJf61xCtLJqZX3I747GLDR00w+rndOJGyXZ/S/dyuNuZ4wdGp4d86odDfQevOF2pZZrPd+YA/aI43FFmrqyWy7lv45MsLAsCDCXUFI5hI1KFMRm3xWC1VD0ExArc7nrUTzoK0CwLQUUzGJ+QIwwYjPo1VlNq3FYiP7EITgDYrpblZY2HNz6rC1+Jsdwlt4zu7dufvv/h2x9++G5v36BxVyoATRUY2DpTzV3tq19z0OI5grRQxEAoEkJJJFQQxDcZehSESd7EoB8GJIFH9qNQdVrkQutBJI8Q148S0Du09uzcpOl6AezywJ9l6zSbDqBYhxLIrTgn8jpjn4EgRM+3XAM+3aUTIra3nioO2mQBQL44SWRKCDmlR0hFP58VtB4/FYqpbArNldSyqDPZnKB4blhjiyKvf1UKvZF5tR9/+t5bI/L2qFDJ1bu8VI0HQsVXcPHyaeaoIJAKLgmALqOAVKj19oAXI4lKFKlx0WDeGC47mAWASYtseBRN1XSgOZZylaYGKS+nI4uHyk/VAa0HhpSx6lG8HEEm+zIXAKMc/QDwUEbi/fT2EyQEkOgG5BtsYv0HAqHyBidLcFCDQLQYNQeGahAp70d0AjIAL1IlgQQgLZo6+6ZPIZFFznwSkMpbWJKmr5afp41RQ4ABwOmR6eeffw4YbSjJ8SE14OiaQI9PkMjFW71IIgwnYPxqPGLQryYaIdokBO/uEjmiXC5qQmHB4wAA0oAMR8cLgGQjK1pVoaaxVHowNr6EdJJJMGWRHCdhgIqHpwtOvA1a9fECYETGmTO6+PhRMVkZ3D5DSV68eMHkR7Y3GBnx9vipmE22Yjqg2yN7yzpp5Iyqs8JvwZt/mV8EZnMY/l48f+UueLmwxXzFOhoEN3QnhBgZCqh0yu4p0zWTClYfKayM7JkQT9/yIZu4A6DiJAnnx/D5hCd8a2s9u4kmx3/+s9eXZyf/63/89yOrgE6Hmpw1giTCtIo1i/zQx6PR/tGQquV4cUgDvVyctgA8CwFNMyqmVXBWEFmsbWBiwnHZeZJuj7L0ezq3rSJm1SkIDqhh9Nm3MWWFz/QwqzXHHCn8cffo7cf9g+Hp3tHxviudxqf5gRjv6kSjcRy/jcFS+cMKAqA3Iqk5+PPyiplpYTcOK5oHJfLCf49KxHydh9rxExNwICqvVKevWrqqp5L8qQ6Y8daeUyKIszbE2A0Dg+T9bvFI9xQVkfEW+VEXjFpjDMlVgUohUeLNn+u2W2BkyvBHmHl7cmKDiOogISqLCx4qYE0YAlgqhBB5LUveql6X38pL2Fe5KLIGAufz7WeQmNHR+zq2/ejg0Ak8TpmCHCVo9vZoPmaD+bqlCpcM9Uyklkee/8yYrxw7OUuHToYceSHDEDOydsdpqVcQQ7zZ/so+WF5Ni7BAn5sG3lyZOXIGtUX0iNTi8A0f9KbYS7atW3XhMBHCfyJKf+YS46lYWtGX025mPylfrNI52TR7Wmu0c0W0lJ3ZQBna2AiSEYghBNVIC724h/l2zzFPTOuwUHAPWsVUfIwV/sMf/kAA8IGQNN/Q0KKickH6CazrSzzuqU0BpVAj8CMb2xXNGxh+YotIXUtLFOT4pigoB9OycXpq/BE9CZXbgb744os3b940KphRAkwSBHh3diJ1rnoWPR8bztsfdik169lIoGjJbJNehl4SE5WtAEqr2mBEip9dTj9Rbz2ommu+APaps8QduYqXBIAiiQffSNAk3EwR8BNfumzNvkbiDQl+gYHcm3jgJs7iCH2HazICJpfGKQBMEpEA/ASpVWxshJvgxTej4VEuNOAXSG9hkQiQC2yK7C2V8YyAskgoOeQQvnz5vI7JSZ355JG24Y0q1GIDSy7SI6HsNHkkYQKGKJpHcg8ABfGI78pDT5MBRp8EIdEXgKRLIQlgmcIsRkX4SUQ8iGmcclccYdIJRhLmoVzQL+H+/lADIGdYpFNBGJqllZes/bTqv2ie6VW/UFE0zShFwDRpCQr8wHZ2P6hobhmeaFezMPmd+vkf/v2/Y/Vbxc+8oxZAKo45DlaovoqPxVlhUuXwn/SFU8GAVw4HzExIpv4NgbNb6mzEW8xJxrcmxnytsIq2gGXkADLHzujeZubvJ2brhELr3GdOzjh0JucWV0wjWjdvInN0llFixg5j4why5DKyFRNzsA4bFZCV4t3TwjVLYZicPXm+IoyL3CJRYbt/8VCv2S1TEtJi1aNGyCjRX3YV4JLy6on9bI5hmoB8sYIYU+Byx1I4xagv9IQDlZ141YQ2SQCnvOPjxn9qEKPUhdar4dg168BE7cOJW4wk1mQn5Ablw4KN/csJDidzkXhACKByibohGJBATvBEEgkA7AljSvmSdgByR7Of3Vu0NKINwVI1AwFAAkNzw4mR8PD2hRU5KC6PbB056tgeozcJFRl+8UqNMKYeq4Lj1iSwdZQc/XSxSR29SKXNkngYhCXsTA3X9JoML3Lo1jBZe+LVqyaGpC4sOnvYmhNAzO1m+MELz98QQ0rvwvhm/xM8e6ylVRBZ4HOXCKlK4SHwYrqJKb6ALETibT9y/xTM/5CAh7DD3ihpFhVzHnzdYPxsatVsh2UnocKSGWzHImkbm57DbB1Pihg4rd34r//1vzLbZCeVytWQPS08sIn3SIs88apPXhKiBDAOeMMvRnYdCTJhsQ0qMcJhh8i3hm66EQFGMukhkky8MJ+isBgU+NnvTg6DsnXxxKtLNAlAhWi5wOCrNwweJDZBMsIOeWETMI94WagJkb6qM/XRZPsqsLcXO9rizj7GR0ay0I49RULGaMCEmxIBMZq2htkZGWuiv8GgMkKw6kYum5smwaKvoWJmN6NYZyQY7kw31mBwyu3GNfMBMRi10NzQKsTLQo7iBfBB9aiR7g6Rujq/Kl8Aqlzt0zgY6G4F28sh0SUYK1CJWCRhN0Xwwl12CdEGMwYiRloBDwBMMGDQ5OTFO0GdaYriMVAS9MBm9K+8UslIlwAbW0m+1JR4BoMKlgqwJPK1SNFhLwxA432nfNrf/fUvf84VwEc8O7OiBSqvwQdqWScm6Zz+aIv4Dz+9nV1cwkkIEYkwvYixkZcTXMTz7tNxc7Nm82avLs/slHZYF0h1wqA+58/h6r+bGB0zRTMXZUZ6wu0WF7GyFYcTDU5z6vT4hO2qtc8Atb5iOO4bzzBOTT0iT7w972rTNK8nTEtDSOPBB+4KDIeNlRpPRVl2/Ce0P0tZfem2GFAO+FRMBpjkEMrFBkkyhkve5soJE1SEhBGsFyzM6Vmak/LCVeRJq3a41/FXJRrZHZ9ca6zPnz1L1cvk5JSMwmlIRLP5ZPBEvGCcIjXWDlhTtxj3AgvPfICZ4A8f7d+2YH/oc1htWeydpRDpFVL2evhfj/bNth7rY1iXxKMpR6dIi3zACTvcbMrhzrxSNlRHLaT5o5PsYXtLtTZm2GexjlIoQyrKOZ5ZPFOrUDJWzXSN7fdqQPFJoAEiJJZ1IU++Lj9XLTz12SSfBpXyOmHJKM+SVjCqj+Q6RVVQVZVJ23YPTXJvdgFRE3cZNMiNK4/Za1vO4vh85C13C5uBmBnWyXExM11RX3MIKLk1PZKrm8uuLcsMYanBelokoBUp31YRIj042T+LHm08appAQQXeV/8riwBgyfO1NCS+aem7ZcyBxE8rwYzlK1X0pFu+zk+OnZQBFa0D3nA8PIhiNAMxfZv575ymAyH8MEirdpAs4G5f76YWgHiP5GghwxKSK189CCOB6cxbFgn3+uoaSxAR0shYjPyQK4AWQpY8MnaIYEFkQklYJHS+pohlBZv0AY8yyXlTkQ4nS0peiENEilFk9U/A3TC8YUAZnJKTRRmBgdzRPi9frsKAmHb+SAWJT3QlNYfggwObY+Pmg1+hHlkPG7SdaRrPg32UHgjC5gV4REri69OnK372MFyddicEg+x8NUNfHWq8PWJSxmpXsBFEJ8cIwANevDAWecTICNOQxznspx6+08qrMQPwOOfSBIDkICUMJ6dTqcAkxxBF7jryFtkskpARAYClLxJtGKgrNY4G4MpFPk+RwGQNgLpXFBLQtfzZZ59JG0uwrp0Cg3jwPDY501IHduGs6RXCenUxmhg3JLd9/+yv/uZvOCjMYdbNK5qNTYZZS8PD7jiP45NLm6TsHvhvv//nZ6qpNhVmo6YVI7mv2wysW9+jHW5N5JVTiGITz3izwllT1sPyb2EPu949w2dXl7s1ZIE2Bv+Em9/HdTcoVy7uHb4mBmfWMHF9qgLtTsMog0MRMNlv3LDsUTi1Y1tfDQgEuZiMSCRMpdTRmAL0o1rwEDknjaytrW9tL3zc3SMH2sXVbcSV4JFtwMItt2LwVlhCCzfR1mB4KsZPVYPDHpDAqM6OhOTkLmdzyU48j54aXBksDo8O2K1mw12iB/Lk+IhUUDFWZ2W5FPFzqs5Z9qvbAWAcxnOe/RKmZ7NEJ8aBUnswiqNDDH/In//8ZzYW/L6yrtS7eL2RsHyFYWPz3Fj7XRZMhKC3DFRPSTJQixhFsBAXEg3X+Gl0GZ3OBAKArtr0ayYzrYzc/vTTG8fcMjJ0ruurSzyKGyszzpuxEIBLUY2fuYHSTPJCJswQE3U+Ob2wMre3e7C6xrOk28sysNDiEi3B0oO8HQyCcO96ZO2tqtcXT80sqoDo+vH45fUBPFHxBDr3bmLs9PwU/+WCWtXhTe/QHS4ZYFP4if9SUZpERRsBrBKTbxnpna+3r8DE+wqXMKxYzb4R2VnIxSPsQSTMUvmKaQ2DV1yqTn0yBoS/us8kaYNydHbJvwi/0yZgloWqoTtEQAgJWwYwDvv02DEIQyW+SWXiiAEj69JMkIeeckQWF/wAir4mC6jMvGFpRNI3DKJ9ghp3wKOjB5W+gnlkjVR+OpQjgzEikVNVzHZbzjG2vDLIQo7sDjdav+M1sXI0GmAiE2WQKyFBVDGQo0eMW8i6MNhH6cmL5KXw1c0iw9kmxqYSUosgEVmEp0N+oKSKFpfjmIWG9w4CI0PaPDvdCJFwkw9nB52cDsH46SAdYPwW9jsy9o2uZQqzahisLjOK6BgFJKzW3lnynNs5HUxWEumN0TXTkuEOqvzU/DzIoxk0vCSsMwUJOvolUcxmIO2M5v6JA1yQ1ZyiPsy4i0dJVWSWKglD5RMk6ssYQliNiIQZGFS6NJg98kWAGDB+tgyhqnnr3bXf9BMVOC0WxGrlFsm9qGTMf72X87x+99e/UbSgMgKYX8jxnjOmIpyM4ezPaU52a5v2jw6dMqbWZA1YnSKgSTX8N3rIYS4u6cxthhl8oAoN3s50NAVjm9G73cM///D2m+/evNs9urybOL24/7A/3HfA/O348Oxq9+DYSQduXLb/iQpUFqcSIVaLvDwfWdzNPnWWKBcTgxqpGKIf1xDq0IS4tqKTPx0PjgAUYh0KEdyc0S+ykWl8fGMh4apt2cD0jtSTgh8cDRGMe1xV/tIHjk2ainC4AmB1p/gCOfq8tp3T78TbL36bTJPWkA4d8DupxcEpux93shZXdRi5us/SkSHUkG0fNJ3TLdxn6RguerNmnuAhBt0qvQm2Nx5CmwZfC35QW8fjL5ufctAQjYZg86iWLe1+/EiB8W75iefsdG1QdgfDI6pQlWq3ptCzXJHJVVIKLQwKRfbk1dKic9WRCctXQVpEQervcVWgBY9sEycWPTq4x4ARMV/1M5J3KSRPJRUq2OA1n5RJoFIpvkKvgpQgeoVSiXLO/VnGSVo3Sqpbjw82s03omcraGINgNEDowcCt3GEVP5U3BkbU6f0L3SfFxc9MQTLpjGPozUe9qrxhhKwQ6E+SLl2VFMl5HsMhqzgGv4DCYhonntIpqZ9ahNwFEKY2fUVbiX+bjKnBFKvMQeGu6MdSNJdgRgZuQEXfKnE4U/PDEkLu7RNg2dHcOMeGJLokHxmxr6HwjiFQvOicCI3ExJfoF9My1AXfJREG3KgZFAIeuQKIaNUDkqDApmywYbFohRRDCEBCK0bCTiWhT50FKYSts1Bs9bezs88q99Uwh537iEEuzj3e2T0XY4ZHQeTl3Xhk0VQBa+SdXX9tDsoFQkQqlGYvsiGFgQkDgBz9KMFETQ5+MeIBgJeLgDfkSiTsXaV76Daa9Wgo8uJggQpzZKrU3ZV2tYnxSVoPemRqCQkafPXTtIV8IQcGmwcNeOUrOxTBHBQA/FRxwAQ8+gMY0CBVl87tBdiCWhxDrYGC+FZ5cMIgLwR06XR+Pp2PTiiXxSWbQWc4f37zV7+2kAtO7TSFtqye1WPCwMrz0dne3r4+Ek47pJwDwS9PA9L0KVrNSuFWcanKeZscKSC9MzWSLTDWEmYjEq/v1eHJ6PD4/OP+4c7BscPh76bmJmcXXXp46XTPM/uwbsenuCiWxyZyJIMiR+PQ6KQxm/nSa7YQKtcjQwQA+JoJgHqIJdq89PXILv97ZJXIAeNgVBHCOmM/8TYj2lowqpNQEFk0YxsPmJZeyoLKo8HVuIeYYbjqVl6pmtXi1ZHkSEIthG0BFM5rK1toKw2aTOEh2evsTPZo7lkCdXGGYkOBZWhnp01pxgIn7BbCRJZ4BjJLhH6mKpJhcOO3ikOkLBSqxYMUeUQiAzAKs6MqZ+HRO6GNOPgqdwSTOjCEBOVdEG+5dBh7ffdJPcpCjYCn9PFBEVzraJjrIBV9AF+m7p8uAYxjCg5SLthoabSs1UgdquH7zMpKVsR1c9ZxZuxYjgTF1C+iEGFVzMDAYJceUYLNY4hDjxFjYN1qdOKSy0Jy3CiaZZ65EI+fwDrQJEnogcrbJ2m90eNnpciLCIls6fL2gBfjEWjmyLGJhIEgiUS2SMDIhk0AlyoQKdJj+sqx3XKC1K6dpgpmmQJDiXgFVHECkouXBWzCTYa8ymGRIkgSMvwHBTjYnerlgzBo2LxlLJuO6QLoDJUTMFwtQwC6DXTaoHLCYj2SA0aZymhOoQaASKnECCPCV2qxP+ntFQBVGgn8TR5kkCuFhRCSEH19VZhaFUBo/Nx6En8InDIVw7psvkDbFYPgODS4Dsoc0AyUQgXA661lehNWaSFRIk1de9A8bIewaEJamHFUnZ6eXa3mko0Mai6ysMLwJQNJAIqjaPLymI/yU7xSWJljHwYA1h85sckUYeHtWNQuyhGJ92g2KAGmmMh46GZmoouVEU4BCaH1iUCDlz1SMQ03fCLWsiNAitN+f7l4WvRhhgQYXaGMwOBRTGE5QnVh53363fT9YrwlSaZlI6sWIwL3qKyuPfniy1dWX8Bs8bHkLmfk5AbPD29FuJU2A1e9X1wvLM1y/s/PGo+fLwyWTg6OHc+Z20CYKhMzTuI0qvCenpyltq3mI61d3VSPE2dPzRc6BWxx2QH8cWbrZmxvXZw+56s4v3Z4nLGz4wRYEAYh1ovjh4X+7nnHPcdYmgXAopPjId2hdeKb6lZAT3ppbW9+VrxGh3s8GAxW9gtffAsGDqsvqCQ82D/w/7NnLwz0rJuXlvqz5p+HH2+xDhh1pDxQC3swR+74LXlyLHWgdD7hLUirbqSVNapwUIR1xaHKOVHn7uTS0S6cXl+ZkaotEQsc1vGhjU2ZhVDjmKiKzcjrJ61jM5HhsAe7oJnr6b/dq268nSmQq73dj4APHE/kal+zBeWFl7WRjdyJlnoDiWBkkEaf9Naq/uLOgZRRSS14lIZyqCHYJGSS62QEFAc9xBaeLqhIsbSfrlB/nK0GXB9ZrHnIKbA84BM+cTbAQgYVctZ5XGfdVxbgz5hBoPFUFHoUS0PhyEGXQQIymPOYKSBTz5gb56I605tKq+5cCY3DkYRqNZbDCXioFJMEZ5r8XaY6cFukrHUa+oG0r3IH6ZkSWQWEE6quO9x4rEH1JQwMhg77KZBSW/1fetxPXxsMZAMI0DBi+xOmRUKMyZxIqIvj3jkdyoh54VTm7PdKzxE8SqywcBJRFcQgfcxdfEsUDtuqCCF4D2BiQPYIs34UWoUSWaosk6l+xnUFHeJgAe2nDx6sVxS4nFBI4YoHY2kELCKV0BuViPD85S9/QQGYiDRHszZLpmsbNKaH79UToA81NI6MhCGRKSKgEiMskkADlhehRwbaWA0ww4/b0iqYIYRPXUPi1Vxjw1kaHIDcYYMfPFGWKYTgLSQ14PPT4/4jwIZEwj4Z2mvtkmjwVkcgycTBL3/xK5HO4HGgTRWBQyz1x+6xlBNtCJOR7CDBBzHApMUHD6q8xTAqmT/FqsBgAH5wV5AZP+UORkHs21Qu9jIMckGz0aKZbW1SGR10D0ykr0U50ztP/0QGoxWYIoD3E1qf0OCndi4glTAy1IiMhMG0OwIeFafS1zee8ORYrH1yzNnknMsIkGJaFbrgFs+xiAdXwevPXzzf2mS0O8bdjKI6cv2TraGO/DRQ1zScEszfgQwFRJL6kNfh3j5bT6m53ZChC8hwOtdGWqo5bg0ohW1FEEVAym3kcaPsyem5EYCOJPump+cNypk1mGqPARheZ9PVh+4ks+ydwNsPTJvnUvicu+AMWnOLyKuxv3GLM+XSinJ8OfFII89YSuk8xEYVKCxqS8YyW04qACgdUadZ8N9kb5dIcTBNwnkzHuRjIb41DgfDF/EthIiBDTzm+9rqlUnR8V2V3vKVhewEwOuPzfZyS9qIF0UQmb/TrvSgxkU6Tsh58r788kv0eBxmJEd4nEJa9GdMj72wIdLYC0EEkXZDA0gtglhCQlokty1G7pIrLJFQjqIkpymZgwbJ0wkPwwYMtBLinrdPikaTtjRCJcYnXTJIqHyVyjoo/FBkNhY8kINXUPhzH0PtOiR7gCvVCSe+/cLPn29Dw7jgKhNPBckoSqgKpphcUuKxC07+fT+Lqh7PXRlKEjneZ7Pf8ei2NpyZtpiqRu4s5bAChijHYg5diz9dtMwmxZLCwoxvVF8LRhdf2SUsQmJukgFgXb/i9Snogifmt6fUN/ESZGqAp24U1k9ZUC/h22VGrsqCS8Wc5KvpOftKvpYfKqNzeVEKxtEgfrpKEaSEunMESN5pFaqFGZH9wD8aWfeZiVsV1MBdEOrBXRA3WtGrz187jEmYSZv9MrWDxqyasT8jEaEC9vF4CLGiQh2hdwD8bKZziaxsfEJHGOeYmtMzGsHuHWAiFViWZJf8OEqGQGv8rCXC5l1FvTvcP1gZLJcUXfCvqHhhyOhY8PoUHsMf37xF58Bls5NT/AynDmC5u9V5mprW5tWTcqJHdkuLy5wPZJfytX13Y3XDIhD+gl4vz1dgYZ27VR3gbh23BYuR8mmnoOT0tF5B7zpDYmfR8/LSikPT+RXWV9c31zcdKmD+Uka1LjQeOkX2U30I4IOBp3rywMntbO2zemdTM/z1vdU4+RZUCdXgsg6iYd7rnmO3nLDE5HQS8F4AAGEZSURBVPbyzGHyTtqY2PloxnVqY3PNuOvFy7WslV4elIBNOCTYlMPTZ9uqiZte2VUwzd6C1cKNBhXHjavu9g8PKHFpqTBSw4qeIWE5S+dWIzVTZtOC/TyLS2scm0uLK+pZB8BE1QhTXy5XWFkeXV3s7O988dln/+brX7z74S8358O1lUUnxgBQy7oNYwYDgZXVTS5ZHQldTBgQpiqdAs2e9VPlEoajw31Vr6i2C69S/ON3y44cuL+2KISY8vdeWCc+7orHS+zJMQdZHWo/qtPnWBbjjmNSFmavsmCpN/0lI0LmgkQjjOX1NZd1YVF3A3zvZZxw1LD16LX0zbhEkjU9taYGvdOhuxK97HW6g0PQgG544oinSWfEz7sB0+SKM4h46qtH39rYtArF4cPmrjkk+F0kHZ0MbTmyT8KkaRbMxgdlTmukAfcAWptSX8jWcLx1+uJtIxBgpO/bAFgH+IDpMZwWV32YVbBmGnHDlohxVwIIqG5gAJSFBLIbyAClpp174xlDnklrSwTbxP46OSp4rHsaMrcdmKvIalgrDfQ6mEBm1Mvxwf7F6dDOPvsDsEik+pVQdn4CE5CpXPBcRRBCfKatkCGyAmNLgxX9u356bmFAvTpDyRpQX3/966+dF2s6w9lHuRhZF5UDmu4wiTvIyRPOBBwd7zpl1lXNSwPd243jxHf3j/YOT1Y3nzLldo8y0SUvm79iSDnyWb84YarAIVerGGrJlmalW9Al5yDraftMyMJFJpA5NrKybqp77rTZmpmccheCE6sQr6u06uHcGTuBhMf1Mib4jGNaTmSdllX2bi4n0NBr8K79LDqTihFQrYnkGBOTXBxREbAK6wloKk1Sj2WjSfEqoy65EGz6kSVR0z8OLzlmriJAn8IzbcCkhngTiatc9KQ47R4Objp41SElJge1gy34r6EpmobGYKJ8vCkfn1ScQbtjM1g+YDO6ozn0rhKAJjQSA4KrESkzcVTN2gpTB1iLArEDAMxPIDLutyLp+3X7TEufHKAFp2YDntx7hAF3/fmk8BKSXQYsS+Snn94TL0aKd3EnxLRcooF8N53esrZNV6+jM0czhLLzEzDClEguZFQSkXLXK0iieQDrTGFu5AgAKZIS4XAUCUYWHW9lRNEZIwVJWXlWgxgmHRiTYUdHRhLxOBnncTX6CgPI4okxZnaiocpPdYlOkCmRc9Ln3J42gBw87QCgbTFr5iSH3PZD7FIEwyokeRDJalDAmi7KABZCbzEfP+5CpbAW9rVG+PBhHzBUyPOJQMApFz+NCQRwA9sR3JyxAPJwGG+CjkHnpwtHmFlly8O6UPpvE/i//Ppnqyt2xE27X/nbv3wzOz+DKppON5MF+KeXwVBHnGOgkkYdxOZOPdr8bxWpdsjI0gjV1rz7niYnLD4yQiFD/N2UlD4pg00K1J77upWFRZs/TapWXEBVZZnIgW017FNwGWUenkzXcn4FpNrwhyo3K8gJkToaz7iY1kZPiwFUYmCT3IPJVZXx8OCPgjMv9KPeslCpCPBgODbKGnvRnOZQM1tSQSgeEjh1hOwMNQheDAweJSPhLSHMcLLK0ochrVYznMpJxZ5Qfn6q0nhqc8+V1Y1lJOrJoKJz/KEWNpULWBZw5mfOinBCeTyxABgNrgRhsnJe0cKIlxywdq1cHnzAjTjlsmuSfWOvONts5tjqsQu7dtNZshZ9xR+lUwQZiUwVlXHd4QwyyuultwPpa0i8i78oh8LWWIebZG93105yAGkv8fhnCRbkHmh1TJaSGiXihDXBNa9L0R/2+aZg0E/rgYBhc32DRyrkOeG5XEMauqJZWeBwUtoGHss68Me4RHZsYP20DoE2B5aVKRoiM9+Os1yIxQ9Wa22JQZWLMY9X8ABu8oRhE5Y7plUpMioK5cX8lJoVUYsm2CUdVnbdJLCO7+TgbUEHn06oGoiwJ7Rxm0aOMzpsPS7gk1kxcoLxFAUNL8ZPWeAJ4FAQk+aBmGT9aUCgCmBoCikDUqdmAege5wgueVUSXYKNeM4TZaxtrK0Dgl35md4SQ69zQXqTkrzae8cwK9cSCtAqew1jc/OJJRyUlzywTCuSSmfRmt0oWPHCDlIYr3QmowxFJVRBaXLRa/HKCatdP4FB3oUkr7ARHTS7A7ApsULSxVAiu568G7lAt0lIYEsx6y4FP5sAkfI1PoUWcClJ1nrUNCWoZVnJJ75sRlYb9URkc4q6vDY21hULftPg5lGVC1pZWCSOKkSqNWTDL94juUw9YKx5EBAJFeVDqhAgHrCF52Y3YZAFFAYBbHccwEzYvIFZ0UBxdBI/1R3vBUrgxHBIVMraWsZ9MEsiI+oMzq4jBoXakdA+Z9OS6oXGefHy1cHwGJi8SJisCcDW1jYpyFWjzuCcyBHQz589pcGzNckpnLWI4ujs5MPu3uaTZ+fXl2s4mV5ff8BW5WM0WiYhDoSwlWsqd+leWD1yrz+04jmex2xXHlmAYjXGyuoqI5PDx0GR5hI0BGXXJgFF0PVLpXlTsz47loi/3oRD3PoRbsMm41OiCqwmwLIGPKsiLNsYs1CQCPtEDq3+zHoVpo2ZcQuY4kDIZUxRQ9LiIQYCyGbJMpoQgCdXMYIRSPWQNNYu8MAjwwMGG73Za5KzrPI1g10g6adRiF1zMyumN602UX3gk4tbcw3EHJh8R/irk44JEuDLi1PGu8wl14TrpkMGZKxJ2CI/2Tdn2YcFsLd4ZYGtMZGvepSot/tMAKAcMLEnTq684ZYxuwm58opUcLoJ/cpNNjheDMJCsR66xvd1DWUaLxh9D+GCECThgUqXhArovWlUJZYXxWMEGbWro8VAx2fWqjkyaXZZPGZbBurYCIIbj3HVILLD7josXSvbOTgiNtvbg+9/eCv22fOXxgma5MT9pSV0w2Mrri/wpNwqWayIvOmlTCATHNTIC08UEJUG9wSSwmJf36ze7e0Zs6ooNZlzpkK59Usl4gmVU0UNSii5JzTVQp2puxiF2Kh1EEiVokPMItw6flbBQ34Bs+IVKsTAngVd44ZcnpYTkUUwbKEwzVbjZnclSZgJ0gFBRk/qgYTJSELKIpyv+bmuUG8xygHM0BDOkFsPDOmGUs68m7YqGq3LDGWtZiQX2VSXPqs0P/XKXbsKSYb0jKk8PllrtT95qSTxlWaRMWBiAgNplr0HpqagRdakIngPU5TzRxKMI3wmnGUHj7QwIZFY+PTsWRa0QK6NQS7hJ0aPGwVTbWoFEn0DnYtCkJB4ZAcVAiQBQ6vCI22xIBrTJzEwNNmSINXXJr7n+lCOts63OHhr870ALWmlPMyc8mAIR7MVpPOT7SKkQ+Xl5I+lhQdzoOtM9yA7GYH0kH/xYiBhs3jzUIk3Rms6UShSWEAuAgiW3Nw9/vhptNtFUHAPYPrapzhYak035PYNahWukFEW/nGpWjEpiCRkV9ndf8ksNQ6AAZhyaTAwFzEu8YvTk9lFND3mYzLcmXY+c6bvuFyZKGSHQW7dgUEDJWSlCxv1hht+cnrv4D1/vSOajXkNDMZqPwsla7w8Y7mtKuplKtdXvOYG0Fg3rSWWV11FWNo/Ob9ofvXcokReuVqqEM4wn2oKV4kUM9qrLFz6y/ru6zHe/3s38mERw8v5QZwl85NmLPQ10vU0UjoHg5UWDEUz6lfkrBuiJbWUeJYzP4wbflvylX6rBtQA1AjhUoMZOxcMocJSMWDgbJkhUQJalBi8rXByh4Hc6gUBsBU8dJSymJHxlaLWndtpw7MqlclePb97bB2QpJx1COlCljSW7pC7JDB/EjP3F95rP0b5zHzqJjOZM7OceEYplvCATL83N32fw50fmkPW0VS7Q48uJi5mk+o5fc+0wbVuW6FGp8eSlQjjTLikvFLhP+5FuRVzUzulKEm6MNNMtE8wsPQ0xvuxmjSOi8NwU+q4oKoCo7boXjUZRmUuOk4unZKiOSxQLYtXHQhzYZjZMB5EFayMnoCW60IYP4kBOFa96tZfS+ggtoUcXJgawWFCSXxllv7bsCGHVVLu7ANFae1JP6YHhSe1QKeXWkexgttC6KnKQt2V3JHRRr0a8QkZWczmGPNe1SPMCxQdDnukUAAeAW+5pAyFFE7e4Eh14c8lyty+FKDzcesE+HC1ttNqvBEkO+ezSjiTunB6w+RTxO4u3gIxjQ1TQZJYMcI0Un+VOQJyZzQtz36kkQm+S69kvLa8Yr6OWgEhMhdcumjb9VW1byD1VPkJKAZHseYGaYDLCYV3BF2WMCCO9vG1NbKEGAdAOgHvJpQwkX4FY4lLK6DDID0S9gOz8shRrVB5PuGIYklIYAzvjJG5yPXoFKvpMv52U0ysVEtxUOIvCmtqQp8hlbTQQuiNa34i1VuLRRIvEAK6jMPhodPNPvvsJYlx1Dhb1ei4Dp5lsJodRdIYvf/u3RvG0brzE2s3GeNaGdHsJ5yY8PhUeZUjGkQpipjMEwqgBLy0iAGAPDC4RCc6uUiToYuwEVpILK/VI1LiiiCtMPqxrtmop/FTPGDN2wNMoZQOAGNfLt98840cPbR/B2IrTxgFHqkynQEMTnV2QplD3/ht+DpNon/+4sVgyX2CFs+cWaFooSZzv2YjnhuPmJJ98+4d7798JUewRqHeKB1iwo7NGCJXu2P6pDH5igmWpVwB8OLFc0N4F7SS1hxdSfqNn+/uD45YeiwEzuqUSCmQiDkoFFCcLhSnBxsFz1VgXYeuVWp64Bk0ToW7pFooNPMsUTS5J1zb5STg+HVZTVoLgrVE3FZf+KYiOjthmaKKoaWk1AcpQgAwtaY6VJawypK2H9hQQkXH1LqwStMRSbQ57k7z85bhxAtsif0c9aUDQh5fCaYRbWRoazzCkHvQoJgEPsyslY5y7E9ylJGajRS1ewFZJVdqs1wENX4pj7BWQ4FqHeDRtryyFvbWLh/EK6B8IRS2FE5jYTtASxKAI4H24xoiEgoLGDbwCvuYVjdtHRxpjACVJJf0gnlQRtqd3g7BiO9UwsSxaUAStJLIuhQTm8DqD16j+729nWpxK4wVqssYiBbim6Ihe3UsJYjDNlnYAafgEDJGNQTVv76RZkjgMc0nYV+Rh04/w9KSUoHHMAYSKm+MYpxq3qgVI23K667kOv6AbYQVhBA29eKJnJSo4AA54zZTwODvLQm6mdq62BVkzMfq6BqUFn6n58rIIxVikNec9Paz37JonuOhtMm1Hrl4fPV0DCSex58iu/gCDSwAZ+pI3uDSa9RQwmckSoxlbDIzIfmqk9FequERCwDNR5RBhCYESdhUAsA7MLjcwMA8xm4tlMD01QjyVYHxMXRUJ0awJLSLHVVi5AIAZk5hFZDRX7FDDITUFp0rL2Aen5prMCBe3fy/8EuCVARDBVKgH9gAa2PdzICZVAAgHiqK8ve//71tk3ACoGcRH+7WvQU0qZqi8wkcmqWSXCpZSN7UKl1H+inHyiszHH52LSpCVxXy4IG5W7gAJB4sanhhLGpKfvazV1BJIl+RPbnXCREJOWDZQe4NgxjkSYK8zkUqTRqX5K4g6ksS/i7TtVqZCwXhlBcMdAC3wOLs1Gcvnv3sy8+suIuVGC/t1DyvlmH17f2uWzxR7gi5kxP3ZXOZZ1eUmbR61CM67WMyGWrUY1GIQ9AhyfmRTv6pWXQERO26VsaJu8aj07M5qb/sMqVUNMQoCGqVBUMgFsBqRcCrqHXLB+ncLPPJ7khKPv6HHO2ZbkDBMbx53gIAm3aIhyKhggfOSH8VBHwrVixGv58yRQYCQAon0084hbsSvQETSO+GlBfk8hIjFYKRT2OaG/CTGueO6yllA/Cfffkl8VMCxx8wu7QSIzkroyhLecHjUU0hsXKnl+m7Hrr5JNJUFRFFAEsOnS0A0T41GaOwkqMBMY0KeV00b8X3E9mK2ZBSNZ8bOfwdgBaAQlHrDmEG41leXmlbW117QMIjYEbQ6IrsocdPkbR4rQeLdf/INwGT3PDQNsKUUjoDe8qnZ5ggGQVhlmPGU+3qnZc/wy9x9c6IhNUYc758p7SNnzLtvpytpjvJ5ro8cY/pquBXk7wDEKYA8bmHhxDiDzo9KKwqS0pgzVKU4HA3MSzy+CqSrgz23lGbya9IFEi8gtC7saEKKmGfWt6CwUDWTEHLNt9hIbTZWS647d2ZpmargCDxH4UgfRUfamP35+maEu8B6S0Lqh3Y41cJlXfcrBw8mnktQ7/mUTweHkbmsgRotKj150IcgjFrJZzSMQcKozJHR8sJIoMAV62ZnoZdwYqZqSi6hg6lOvXD4lHsjRQrf7CV3pGW0sFx+ghYcTxC0JDwQwIyLrzqG0GCQYyfHiwG0FKukH5CLq139/xgSBWqmkEgwYuswqdLACY7aKUSkJA/p6kFYzyhCydshhQiEYnFwunMZqMOOBwYEjUKmTLycI4NUrXJbmAKW/1pLLXOgjiiU75mVKwjMmQAgWx5iSQPwDzcvWKQJGE4Xw6uvBfmP348sDKWlnc0WFen5Lw0coQZvAfb0YBv1hvADxX1quDgPfgsCz8FZKEsMLCwnKfOQvATKmklhHZjzQkQo7WcxTr3+uWz7Sdrbl23fsFYCzfYruzoxZkFi7JW1jYdMGPCEaOIFp6zS/iE8B+/KRI9ycnxhYsaKU5DAaw2LLYIzjEEDD39DbFlwTvkzRmi2opDPykXag9jyARlGzyleXUGKiIFdC9NNuufWqUp0rIRilHvSjsod7yLnNe2nZeXRv0GSdlrzXCWDwcJVnis34DQ78hDzis2XRAtH3VRmlEj4jpTJDWC1f1goJJqH3LHWxjkJa23uib8lBl+0tHsXSiZmBfn/N6BxD09nFSWYPEbFIYciE37ZzjLQYyPExkggjG2nbPapizZllW6g/NCaQxuKETzHBNTTEi6LZcD8P1O2YznysyTzPFqxR6FxXMIsZF+ZMkiw9c6b+fcghmUc/sY6dK5dALLnd503I4i+6TI2AS+TMn47+DUiaMOTti0fmDKG6nLRnreY9fsgHNUX6a1yO3xcJf4MZP5qkiBGQAqE4chVyl0lCIRLxsBZ3Uui/OWAlOT6DQimedQmFu2KgEk63FuPM3ZpIviUCZGjGTPeiqT3qpeRwg/BwxicEzjynSL9dDnp/MLy1M04cPMJj8PA4H97LLo9H+IwXCpkCRfWag+WfgZTho81sWZmMM9yQyyYJTPwZ4ekHoS4o4tgJUXPGkXoyqjdB7mSxJqbGCYK1bdcYyIpI4j5bJHQIameqN01SFG7zqPl5kpyBxBeppoczRimKWEYFAuPskApRzJtosPSX/yU6BxJiocObvSmLvYeicqTA2ZN4cEohzjXRPCcSmOsrxBKsACLf2RrHLNV34xH/orMA1ASayuwT7wxMgnYepJPImHwU9VpSTCHoNaxEhLPaWRXPZx3nf0slzQA1LAcYatyEBC663uIVQwCCEHCQ+fEt0nxiOVr8jwNLMgJ7UIllyLlQQBIBGMQvEqyU97dGQhOXiHmZgYeP9+z882aqQChlRT69q8eTzI/aSIoW2N7/xIot/Ei0SGtEtLWb8kR9TKRXGMdn0FJi0YZxEqLEgAyoJCmJ8+XRcwABL5y1/+EqQAruKPTOFBuUwFFFxytPlJrSs1kcUlP32SUWmldKhyVFP8FZZMvHzxDACqELC2Mtj58N5Jbc+ebliWt2InsGWhE4Z9WUjgtACnIFCP9NdgZXVnd5+JYK1splprsJIDM2rxHLWh9XAxOM/a38LM9Mpg3kLb2VzNdU2rLS3M6WvTzJytsDhwtJljYCxLdY09GVFAtRplUculgKkINKNQ6bx99VM/EWvap7RkR33M0IKMa5PDPgHAJaiUFyu6FpKyjFyYPV3djRlAR3aDESnQkoY52NjwLerwIAlm2NSIylKzArRSC5g1fCwcXw1JavSfIfx5XRjQNQWYYfHNN3/AVProxfbTjfWsaOTG5LRiBcsCAZHdepAnYbxaGFPlQhVlgcK19RXLN33NwUp1dARiKEJlV7OAS0vm1HHyIJI4QSkh+WnmEEXiCWGXV76Kr7wy9QAG5pNiwuZj4/zuL99qgJAA9khF6rBUQrn0jhZSqqRqECR9gjBfIYQBwVL56c3wZxAYBFCky0alFmtfnPspIX7ChjZKyCiKaxTn+VBoYNgsGOX8US74kScvyAH7pB3RmK7Oqv1Ac3q7sI/qzNFqcdHgsFRyB4zsJkZJaSc/lReFUMkdgGJKZbDZPAHsl7CCeDdXESYArbTV3pf0b7LQdvBcvEd5kd+lbiSSZAjL0CjxhiT6t3bpKg7kYqr4mfAQg5hIQm3MRmcT8EgVzEFYHK7hTgYl5ZXNIDWiIxt3DQ1dRjU8bnPDsAm54rV8TIQUPzBCfslY2xwbNzFgOBaToTotdYmD/K8as8oT+eHdB+u+iRrKuhq8ISGC2AEVlw4585OP27wazEqJiZpny5afCib3Low3bDCYI5CQKAgrGDpxk0aTyiMeHy2kUXKfFFAM5H5C3rxDknIBo/WUVHI/LUMShsF6Hlv/ESZ3+Ancq1fbUEmLBlmbZd3e3pAcPeClgl9Gr149G/BWKWYf0s+AnJ1583HIjvmw6yCLQ9LpClmTkJwbQ9PROtfzOoerjiTS7PnBTV04koj9YokFpwjDiNVpjxXpElYEwt3i8uGDw28suNpEGH6iEEktWKgyQY4kIy3VocqOj4baj7XP2Wxxde1nTCOLE66u16iLpYEaZBIyI3787lvLq7VErYVCefnq+bPtjZur0ZevX3z5xYvzs2NjAhnlkH0NXxEterm6NALovQV8LzQ43ZCl5az/uHpNb9nkq43ZfnV/Nhpa68+wubmwt5Mr6Hp0lhLhoR5F1WQcN2s6Z4J/nG0rF0aRjV2MKOUizZaQ0voINLawyUOlyEUS1NhGx7vCgrH+GHOgxRlJVCUGkiXhZpQa98jKJ5ENiWOYCZt611BhgFymYERiPoGhNbhodFfqzphPEZGjvT5/9tLblm8ttzeXUBySUBVOsmSAw+Dh4LL0gTDu7h8wYpxjuLqxaiaElYhUDgtLVBVweHRkjZkfslFTEUUrHflGbu8c5BnFxfmchTfRiWQV5m4OCBbp3U1YDRqqhmYnJ9pl6LAIjXlqHPG//8M/M3gZqDZ72nRmdEFQJV1djaWiQb148Up5qWxvWWAXMrBIGKlywbfH5qldaODiqXCRykUUbQ0x4tL7QmufIwxMK9f+ZIfXyRDz0amyBeQIG+TSUh/9x7C1gcP4Y2XVJok5DQSYaRuTZQIePRe6cFtTsunTTwMUbYditG2FY50Tm5DYT0gUzRlIok/S87VC1HfqfWBGBqlQ0eKbgSDxE8HK1V8x0KPsrUxE4gYmiEQ5JDB0/yEGx6DCQ8nxgVA9PmKkUlLxUMlZjEokNg7JMAhVI22f0STtxfLTUYzgZSojD1Jthcc3ig5mn2QKbWukJsxbKVBlvQyuystPVKkjnVSXNwVopntTB12dIhVeHn5SEA+1UhTLUsp+UOOTR6B5hw4AJA+Jyt5k4Q6EGIdECUV65IUO1DDQukog0SWQXvNVzipBKyZKC1hgf/9QRpLDs729CphtpbRbW5v2x9PRSmucKhUwufeYQ1oYJBGpRPAY3+MXdovBVtT6qZjqQOWxnVU5TvGHyIvoNxPBQKKMCqIUwg0muZ/OdWAbgZeFVT8iVVuT5yr28fG3jVZhdWdog1Pf1nXApmchSSI5VAgWRg99gXIB8OKVVI4IHp5kqIRUnwyT8FCYe3lsJQyBWaqvv/4aJbpVCqjrRWEbrTcAuWtCApBD68FPMGa86Qjr+m1/03kfDQ9o7c21Jet/Ti5PXr96rm9nZGq6Mpqa5g0bzxVeGQLwQXBizmapPfps5pxf8B8PpdbukGdLD5z8TN1bR+R4AX53l/bFcXp3zadIOxiEI1UBLdtw04tmbGmOgSm3n7lcZg1BcAYoOq0XQjl/BpIFkstFrDAM0WDEYJ3rSjR4x+MYLdMnVA8PpWKCIZzhknpkZeXJ+j+PT3FKaNXmfnQnPEj+r6MUYkQ8jDMyfSVN8xkzWyRInXVHoMSrka5KlKTLe7j5NjWVMDdBRDRbaihpcmgrpYTQUnYmWtBjIShVzHRRirOTY523atITMHUQ2UIrI7PiEk5bBZD7xCHLnmdX4mDmYS5CuDAG8qgOMeAvbh2WN6rBKtu2zL7FeKs85CH7sWfn3WB5dHxi0+nPfvbFzvsPJjKYc+kuHONYChp9cTjlpJ0MlHFAvDuETfaoAtl5U8d6RBarwRW5dQMbGmym0QvKRSvQmja2VvQ46s7J3NV9l3dE92ZNjW1+5aMnKvcL7IDMlmGLcY66W6hlina14DQynGZCgWIPiyunt9mIHlUeaj14Pj+dc4gRBokGovsU1rr5RnEvFpi1yPf2DFsHfAuSitDjFpJ4t1CIWpIjoE0pPv73UF6V2Vgf1pdOkF2qo8xwydV+v1NTFe9N0OzJEEC5N5JwQ3LnI9r0bkWcJLLjqMUC3jE5YqAKAimJr3LxFrbqwVmukCDDV5zR1nwiKr527g38UL+1XK261egZkKqMOkoX4QehhwWtwgQu1VzSrOlRXmA82ivicBmIn95dBkOlJg4GGStS5GD83mo2m1UfcNayXKqqKZPQVuYnTza1n77pUI64rBhleGZeTkn67f4NFSZHmJHurQ6aQqtxcFz/gVOQM5QgpL4xRXJhqUDinhwRKfLo+JSul0o8AAjlImB8St1T3M1B8DLCfdsJu6QKolxdH5L37TyA0QzSAyGVa2gjklMSBjHgddH/43/8SQfUfGte+WpyD4ArB6RtfmKgmDCZx3k+tfj4s3LIujFlNzoxRvH1q69MGC5aorq19USpW0zxQVn0f8wcgwPzBCiHuZ9WT4B91ewbP0c/DgCTi6xVIX1Mw05NuhTWptqJjx9+/Nt/+1e//PlrtzA92960ambXRtHTkeVQMzlRiyUYN0Bdw4zj7LhsZYKTFrMkEIZETowZT54eHG09WTMQcaUtJaVD5+xmp9n3Uo05Sg1V3ABXl7c23+7sDd35C5VqsosfD9FJyoCpVn0HnoDHdp9QTH5YstYsdVkgMjrBGTAE21xyt1aCbQEKFwA9woFFDOIa4B2yR9w6+uJYKKkRVfkkIkiyMHxDjHA/qJIKb5lvAl3FshYGIJ5+Ceb0DiyP+CJwSjxtEclh3pSHV3rLbB21fTfm7J2YxJLTVlDF/J9wmNLcVa3BU4MIICTW67OHKQLKQqUj25ms5t11ZMiQHRrYhUWMysn9t+KxyyeLCOFfWV7jMlSElKWUgqZxfGLblKymjFPN2VQLyixIcFL9NaROYYz3MTS79KNQ8K91n+GOxqiOlBSpR6cjq/Pwg8p2xYIOQD/CWWOgkx2/5M1JQU7njVLJ84C3nO/EKrmMY8IlMki+0cvJcM/cPpeeTsnRG8aI+JT1eDmkZMZaJOWVh06IW0WDdfKLXWNYIR4AvlGqmKDGVHKmEMzNXMXqR60WryRG51mEr//Q89XaJAz3U6FSTicrVMNh1fuqD/BJH4yezHYRmE/NGc5UUxbCpr+VUIxRMp3ADoBN2YiNowLGLR5nOVp23IfulVpGJHYgO/gxAq9LWcHWkWkU1pjVYiRhGlARrOBoSHkRMwm9O6GwNq26AejnLPfKV9n4DZoM+O0t7IHLTwGZJb5WPigMdCIjMeUWlLYfRfUppSqdq5AwyJiUy0JYPBjZo9VDP/tKVmDzU5gQgwFACpsq8WLA+Moh2Fkzmtj7POBKXkPLNBKpYm8VSYgkK+pe2s5avsIivWk92Fpxi/dTvpJLW4p7XhjCBpCF7JABp7CEqO23EoHxU70qNQAxa2umT7MmCjClg+ZvvvkBZj0OMHiaP8JNJHrgN5JhTKBEvsoITPV0qcUAaIKlFVYKMCiv4l8ZKrkPx6f+2ZSz/dGmXCCbWgBIBRPhq75WnwpAGCW41Mkp7kyflnm4v7/L5uJNdvQ/u+s3/+aXd9ejo4OPrDMzr6xCe33nM8xbJZ9Zy+j6WUtHHKbmEq/ySy44Wai8SzG2VcGtQ9kONRF6nI+LIqINLPWwEIiAobyFAXPS0Y+5JfzeVScmcLN+py7totp8VRDwWOdp+pVOjgorRvVhjgYWGN3DmGUtJs5MA0cyRdKklivQrWz8kPDJ0U+bEXddAkeBmXkkg/HZUJUK7vpVxbUsJw6QfiBEg/AjSXJXED8lQVi/wYhXxhZIkerFVz+B6whVgnUEzmIw0+5rSK3jDXJ4RtwUeeDsaoINH7wVFv1dy1BJSOWLJ0IakYBCWXfvZ9xlExPLi0tyAUmPRcDqRKYmUlrSRVeuLFMNV99++72u0XAGVnhQLkcJofIWo11/kq47M5N+1id792KuokppEYwzDS8XihUeX8XD5hEp3I8kHlVKA+u5KH2y6qxTvjwdRtZ4GT6V/tU9U4JuGKXkkecPtyxXMRI22dNZyMUjd8VszvsZw7Sm+uzvpjM4lAy2MAq9WKFQ8GuGUgmrApSDD+WlhbFIGZHNuGFgQQsSGOCiPAHJxKsmQfPegJXOV+8mXpVpd+Lh9HS8AMw+oRadhFmYC5QOASBGLpJ7Swi/r7L2FhaJsMo5hgUAT6fyVgT0I8AnGIB1oWTnK/zmsB0F7gyge10HKcRhIx8z1VajiAedrtKCK+aWk79qF4xhN0QeeCFFfYVlL79YH2gSKa14fbACIxdZKkCMvIkasiKCVSp0+CoVmjiQwIOk6RSPEIBn4wMEgzUwtBYT3wDYLS83H3IBCatxs+WEAyWUuYykRayKINlsfKlkLQsBhCkaapn/fqp+NMjIYLA5ZYqJBvEWAxUNwKhNjhPTFqh0YHmwSiDcWQGVji28+tTnESHqmLmt00KPB5Lmj4z8pFBw2IhBuWBrvilv1ys8wDwKqyrBoNMlpcq4ubnOY4Zmx8l4Y5dxj0JhKd+10yAsXRWWsBmLKj89xEVzJRtiyBCcuCpeLvZ/ODbSKaNWOVwyEm+us8Tm5vLf/u5Xz7ZWz44PnI91uL9DS2QJ4+yAo4q6N5cfPRkrMQWHh0vIYJ3SIbdZ7H1xkZtj56ZOjg6ebwxGx0OeDfrZZgJmiOPztfb8NOe/MHi/d3QyoiYichhCNhzWBSe+iVE1dnkKYx3K4VZA8Z5wNd1DCqWMcgwz2VxlXqSHyKh0mfMuRndZs67gcCi9/hpWrvl04hk+20sVw80YnEhqOnLnoYp6qBeahZQUjEybdU0AwtCMNmUBo14YeSoYa/ijobIRSdEQpgMkhKbQdDk3t+5QHHfdsrHRsu3sVv7Rdm440W+5asLhiprYbQwILLXuQy49Jyx3Ji43lflP3ECDYurEz6IIW9tmo3CWxlZF085xDWW3Sdp/CX8Kh5fmTgg/s6BafJwPSwub1FStKlDL0EcnKmxCJTPeyoiY0jNp7Aqu8eIMggHLjIuRO0PzIeG+ipQfGYGZP5+4RKslOjao7/5VPtF6fpq6WJjmIFmavLi2P3z/eM/AlE0Q+yAaSpbhrXTZOFY5QW5cJ5Mgrf19mp5Whk4NJJwfLKli+JkZ3i65y6TR7p4iI94MmdYBMnLlkM7TU2dwSKUsKakhlH6l7osPF+g3c87VkMFkEVF1eAYEGEU8Eklf9IDS9JcEBoO5OSbk+QXGutYgr9GDiV+kg3ceumIRS4vnqmOK6cn7ErZQsxZZTzEdnH5hEecYebYijpwqQecVUpkmaYAPVYb/tbKXaRuFoK4t69G4IEzLKb6nm0JT1VAKIHtP1mVXT2iwiVAx3grWkICDoiTPu9N6Y4Q3zCA9UoHHWY+8jo6yBkAgXVC1GTB4gekSCgMT31qYNhTuTBszerqHaM0FCZNZJBgxPlXxuLkzVBcJp+LwZbXel68soPJIK69UttVv5W5DBgw+AfOGQUBBBHyCv9kn4KdSkBVZNJiESBXvoQh8+vzzF/xCMFDQfCYifQKj8tq3VszJpBkawPScj7BH7t6mpn3FQEUoagdFSXzZ4AF4I2l3dw9mn8RbwSFrAe1ZEsnFKyDgBwGtJosMhHkjGwza9GJiTJpZ62VimPbBANs/v/rZa/tDuZo5rFgJsjPTq0NyFp8DrWiboj8rmmCzUQYnFZAFQVZMNvqbGLuxfWxzfdmGYr6ODDRiJtIXIDNgUgo7CpAXxk45/jf8T+8S24x1wlnMupSz58G47h+YL9AFhBQBNIC5SNaA8bUP/DjWOFKdSALMQMBM4SCqkQfi5e6QADD5yiHA8ace7W0i3egopYf/bFOtt6tbXiJIFGHD7XwsowcB0HoqFzPJGXUB0wKyIaEsQV0Igi2bjinvKqG0ZA3Jilk9TJtvETmfIBHovATUIPweNCPDVxKoReKbnyjpQkFuejGKfSzrFNhb8lU7KJQjlwvFqh6pNZzvLNC/ubFFYOj07KGbNCBwQxyUo1KXKZQA4EaFZtjhRJtMhcXXqCXmRclDlqUCkETJWzZYZjLqVN7CIfFTcqm6dBQm8hSyf4I0LCM5IONiuswBYzSxbsBBkAquJo226Q/EoJwUQAu5sssdPYQKo9D8iZO3Ghq0xCGDpCx5WjSu1VhwuJpkhjuyE5ZEfBcTY0V6wuEy2AFA66dHpsB4IgA0V3n/gBXrwrdK+rDEqBFKou4g8SBSSxQDUsGRh+ZG2wkl8XQuHY8wwMAkB0/A/fQIN/3AmlpEKhzHW29bhITOw59Yox5rpXUrlm3orDslLDJLjzQZzxcXFRRKlcj0nAnYFQFYHt7gOyAMzM9+Iw6cT1KRNvECtKsmh2jh5F6uSQGSqh2xXqn+b7/9TueMI1oXHlUNRY9D5ZG2W52JLz/Rdnh4xCH5+vUrouCTsuGC6kyO/09T99bcZXKdCxwkEBIIAUIgaU54xtneYye1Y1fFF/ng8WVucpHKpWPnVK6J4zGzB9AM6HxCoPye9UhKGtVL/7tXr1OvXn18+53xCCTiLBo5tJQSgUfZioxPei8JERRVXuugDEiU0izpSklXByAlFhWcMACDVn2gQj7MOBTh5OiNyBgQx6F5NpZwIQV9HLqnWoqDNLyGn6zT1dNy28Ss+SgFv3moLOSm+Hu6ku72N6UoiSxM3OQDA/jxEwbYWhf44SFVEGBxEfzbMHirMcw5aJ3T6uXKxjM3iF1++eLzJ+sPd3a+N25z7yqpAe85lLbgHdpIrbj9RkMwdQM/BUj0jRZHuBdUlKVSHyx0OfPRwaP72v9p9madRDzewxr+6dBhDcssBkdQaQa+VuRyIa0JLRwaKBLBqRcKBU8iwUCMRAAUITiKPAITxjmEvBx4fcAseNjGeKCXMaqe76nws1lxMgRgHsd7R1ngSdErRybRV804bVSqdfjv942eSzdW+kBB2ggEPJsIEwUAGHtqxM8x6tg5RenvuD+u8N6KvZCsU32YVhqGZ1HOwj49IGo2oBnpW43vvP/ET+t49F45eG+knMPlhttZLksf7UurLmp1g8id2+Yr9x88Qtddfoo7KVYesp7sJNWM1eAX4o/yLkXsAR7tkVGpT1ls1XKTGyWJ4OZLHeHHWftxH+b7+XI4xStFt9ggbBsCEdJhGJTGu+keMiFI4nRa/DglCPTjXQsR+0HqvG4LpPrW26SfzjZAunwhy3KZNEiJzVugZ+EGKpSAT89eO2oOpKMy85mznPFjRh6QuNHOU9P3N5VyonnyKoS12yTFspJNdtRxZevYTGlWujKfk6b7B4kQbtWRRBFSo0v8tKUZGcuCSrrvQ4fc3O4JRlzLTy6pXFE8p2kMfl3fJ5etSuRqAWAAz1KMh2xZybXTY8rCJyqlgiHXtSc+KwqAIfdTJUpRkK5K0U8IF13l++C+rjGoBjkAEbUzbHjd5yEGXdvYsRe1aPvJg7o0SKuwOEqpiRGAJPnGwnU6tgpW2orTCPJCxJugJfjJRPwSp00IgfFZlKuIzVtGEBJzYgcq8ABwwg0xQQWNyYz90WplsGl9hnQMcPG4V1yiDt/nWo1WeEASshXbAwilPcwKD0jL/JRnM9bwEkLX+SKEIu0gnTqY+sZAcudoIOa5Hk/FwTRw+jDjwaF++AkCCYr8rAgkUIH05FehwtLLl9+vrWWByxwFs5iHc4AzmYAkw6NUZNYxgU1dxCdKBBb3N1NpKehKsTQvpeITcBT1sOLwfV99lf7PuOr51qat4BmAcO5Z6EQLhwLGIEeL+LRteQoScVkMwkqFtdEnj1aX7nx88dnmyp1bX//0xfsjp0Rubz17rvVm3OniHa5bd5U2uWKO7gpFvoYoBMEq0eK8Lj96pej9ma+/Gv1r+afLSxytxbR3e+9+1OjdeeMeUEeD8EaN1i4w5v1hHg1LNEkiERd0R/x8rSUrPGxrRjH+T0tQC0rRat3lWFTWcCnHsJoLyTtiFHvbUjVrybXhpNbJqG7FNzefmZDontxArHkZ+Fupdh56lj7CjwPmjNZ5W3/W1qwzw4y0Rw3s6fqz9ScbwTxtlSy4xQY9O9yp3rmqHk+gYQitI6HriIS27K0LVemooBexrFm5ZklcRSlrkK5SBMDqF361j4QQB5nvriw6ruNEADZwpgi1k9SwXQqnwxeQsTUunYr8hFb7d8Go08a2HNCZD3LRTL4HsPb4EVlc4kTAB6tratPtci6x3ndHh7NZ9kRyd8VHd9HrmBiK94XYQ0xhFgNx6B6Lt281yL2aLk6IbN8FUScyTed0zDaBdBacvgrSrbE3jOGQYWWiy91oTUv5RoJ1zscP17Ll5DPR7ug3q5tAn0ka76HB0hK1j7bSoqkouHKA54RarNhToKM7JJcFwAqqey1M7ww2AJgE4A3nRgkAFDR48iQCtBFqPvcmIlFxVaaVzZw1h0RpGGl8oYIlAQxaDYrIovzBrO9ELc6nkHKVzZm/GcQgFP8whxGUgtwER8GiUgQJ6X6mEx6lodV6h4qM/AnkxJcPUi784FmleafqyHt0a74zkVlpmpW77+0DnB6d2az3trkFq7kN2P23i0zfyqBBAQC7fLj0p52vuI36nht4skjKmi2eak4WS60qa2bOIdh14xxmmJKD5ybO/mZCfefk6NTnQw7t4Bwe075WxHRwjFGyWeCW/vvf/2suv77rJPuBPxY2ms8hLQLQUW1LxfspbvHAG5Iq9c3OQS4WzAVMPurkwOfC/uHBs83nWhg+31p4OjqkakcgHBSRot8W16SJYFiBf4mcJt3RtSqhII2fBrUN+kWR7+Al+VYwghRalgIGMyqMTces5+iCUwc+J6M/9fftt3+ymLO/r3+27pSD7BqJUm5f9uaTwZobb3C8uf3p0cktJ+tb0+xvjsZaQtW236tgwzReTUvQFlGsTcThzp3sL778iVdiPn/xCVl4Ot9vtKPpsIGGyh3sHe5aSt354TUj02m9evXaloZRz+eff8GafSfgycaTjefPXGXiexCfbq8v3zm7f+f8q0+f+uQ2D+EjtBzR46dbd5a9+ZvPEjA0bzRYUPUdYPsrcYvns5S3bEqw5KYgQxaXxzkF9Gj1nmuZRKwjuWjDVNMxfnrSAfiMpIsnuEHnZY5Ozt/uHrxV0Szm43sfZNbSCEI5jBiF+fjKms9GuZvZejr7MWyLfZyfwcZTuK2IvWcwO526UsYx6hRtDPvTIFyQxz2oFaOU3bc7ZjYW3rF0l9+Os/WR6ozOlGWWad7WEo2481Ix/+I1hXuOG5rxqCZ1ZoXqwLV1rqZZe2Ri5DrV3YPdE+OH82xxOVPoq+6PVh+k3Y8f1zCtpn778s+qT+/ra2WP1x5+trW9//ZdxqV2qvIRCUe2FWCHmQdlyMApMEUu26bR4m2XcuvKdZCvX71idQwACG1otqrAF3T4DR91yJuRRxkSak1ySaQ3ojGncbzoawGZxry7kyP52qFvYnNnK8taDekygcg7C6uXd1cPz2/v7J38uJs/R0yPz31e4vDHt4dzSb6ufEFtOcjImVj385KHjX0Nyj6c00RqVptVR9rWuc+zXJzZDTIE9wa41mx1mSP3Zu90k3eNMPKahFGFup9BCfelw2NojuboTQ1OXVLAX3K3xydHjlFZgjzSKxtFu9Hgwpb6mTGFK9no32cP7F967fD4/Pjg5MCbK74mZ6Ss1UCe1mqzaoXrODErfb6xrnNSRxodV6Ndd5XCYqSFEBqmRiNWfyqGj1Apuz4TlG41J+sx7eOAe4fOtmVnPsuJjpNeeq3aDbm+FcF5OwNtvyceX0N2yMorQQ/WHnKk+OGyfTqbq9NCaN3SlmmKP+NzXpxK1Ki5ATtwpZkdD1bovHY+CXJ6/vXPvvZnVOTP+QXO0GvB/cgMcSxzea/LvrfnjNXPPO2IoUiidFztAxkr1hXg19QMWxGHf8EXFGYfIzNnw455J2W8X3oYrHsq2/YmPcLP1IacCJx+OPOEWX8OTOAupcCPChiVSt0AWAl/WrqeqkEi/4uEdHHPohKXKCB6eJD3WgU/LYb7+cWLz9WWeYBEFeOMI3h+pEL96c//380UV6hO6SLzO0dRFccM/jUkET8pyLAUKgxXWbLAg/EkY1nl1vloKdVG7raZBYH2UlMwmwrVhpE9NjQS+A2+bDhZ+PZC2yefPCIpJP/8z//+6acbYOCHR0EyQkI57FWi0Qd+rPgr6LUekKRTkERmJ3/3m394up59P2dDPVFRQ1w81+fzOcDUPd71/zonH5fI22m7MVnM8Eqs5J1XKI8OtrY3tjc33u38+W//5q+cAFh1nHph8dAnunTM55d3VrL9q/GwcuMDn+aNf7RAbIg4q20WshdvO2pl5WTh/HifieRmkfenu+9+uGPe/nHBcJSLNrW0KWEM6aQ/y/aBoTuXi7d+OOSaSb2gclh05hy5yNfUhPjENUi3s8od6+OuHHZGe/yD63RHYEMwe2pWUtgwGK3v+lz2uNQcfTMOplUSmH/AZ7yChCV4I6u8hOpLPqdm8RkQqGn7IO85sAwNbnH0AgNhDFybJ5tUI2qfIQnQChKxpHY++ODJh/fUlRHvxXHm0+ZY8fJnP3nxGU+y+ey5dxS+/dMfv/zsC8tbLstW74ob2NnlJFDEnwUBEeTENUTI3bNLbi2brH6yN9vMlnCWzc/yFZ0w6ug9HrRZAGzJB9YMmXjcrA1N0EaNxWE2b8A80pZhjcxoyIehYDiLE3cE/O7DZUch3uezDzmnd3/jyUNjCNcmQuN1ceanu6QhBmsB1mBwc+u5my9e//Du1uWhKUXGtVTh60SruVzGJqcLwb2n6202y/iMHwb3lnopxIDPAHzn7Y86A1NTGyHOlOuxEnTkd61FXxydReGMRNBFapK4is70adFYmpJE0w4jPMnA/KSigOjqYnWYtf/ho3K3jvYz8WXJGsXBUSYBBG8onpjV1e0MWXhpW/aU6yU1nVMAZmAOP5uEHy2a4aaliMDmGTCvGzCMizgZRQier927vGTFi12HnOTej29GGyu+4ETPRaWILB6AblWogtwmq2MPpjp8HQDIOVJtp5XI4wFAnQeTjpyIrDSp6YRYKSavDi1w8el8eqJ5WgvCOAaEmAG+8g4iNAUlOoIFOuniYEhYYLniOJMFQBERKexPETDYki6ulD6WtLwbv+anWpSuCOpVnAi+YSCDUoqPzHkipF4L70kj7Ib5omXADiGY4qQ7GCC3u2DkBSeinuQ3nbAKApWCYKSrBp0l6uKCLB8ipmKjLSTAgMQJKgQHDI+AZzygqDaVFceqVVQR6iHCRGwjZ946e7H5FqPqtDfgUD/rB4MEtmHDNtLw45mMUuAkhZ4m8/c5CtWhMU4Khp8vv/xSb0fPSFMsJN9//2bjaboTQz4MoGJl456rcfmI9zGphdvHnlYD7FmYUJhbYNB86rN5dRCSX/3qV17gMkbxVSwCcYbsHFd5V8vBSkP/xVgI6uTCZIwh6y6WRx1fMDB3jD07Rakv02e3sylMBzMW9sI7BPsHJmRuoDt9sBx/GkhtaEbfBGfkxHH2lOuj5Za2jmq04yZ23GRKPLPPDFgN6r23mBYnJ3YYt55Zc3iDdibQCmQjASELrtl70OBbPdPwM6iZ9ly5VGAmdNdOQQQ/1N522HLhcMSPP0qItWMefWvuIGd17I5xmfEdE2IpppLMzzvVGOOv1KZ0Xw873N9bdYBq9OP91Vq4rFZrzQwBETxgVfW9/O47V257idTJxlwL5wXRew84QVAG4OFzap/Z0F6aYaRPfcEgcB1gOBfy0glT9+F6VS+if4LfHj4vgyVTLjfzOFSDujYLC3OF1k8fzGbr8DOEwWlNy0sVXf2Pp3OW5jKjU24o3czlRYaTeHAQi3SQ0yGc2LPFgg2JdlMVVFcRJA4WhTjfVgHNK07JOgDwN1Ug0u6NYpUxRunCL20rCD4L/WC8ZZH1HHfSZpyEAaYdbMcZewmEQssTEul5H3t+Am6lg0FC8F5gF1wATwhdnSh48wIpTKMSKcsq5xl5AIhj3ShExIjNVlkTNQ0egRNQXGVZ3gBQxaIrwh/CoEXTeRZ7Z/Ms3Iyj46kYQquG4LTK68Icwey5XIdwqzx54GpABpLaMTJ+AgYmF1gL0uONCqRLRJ4NFU9hFBSkKIswnFWBsiISPZHGGR8KDDBjatWirsh452OQstqVKcJECgmgpUymIGGUlCXXT5zwGgD8BEMKoT0nNiAsFdgQMo72U+I4x7RYxasThFg/0SqjWyekFxhYl6c1G/wr4okHuYIiIBWXqyGxHokAcIhVRFWMp8aioyImnv/t3/4TEvACtqFShRSCYQBQSXRCQ61zHLBhQLoUpZBrlf3Hf3xTVUj0BjKYr7/+vzyL4vSQ14vmLTniwFyc4hajoIXNCMNoS1VvbT9fe7S68+bVX/+/v8I/0sQJpL3UNfeF54ImyMPGLZeuHNgU4GIIJRiC0Xwu+mM8WcFwDh1TLrPMXZ0YoGqoaNsoO2uGYzxQ1UJotarzxDN4dadEa00L0dKMyrPMx/3PIF+HxB0iqgEbSsnltspeYKdnUhx+MEJRQY6oIFJTFMcYtbQsugWWKChFavw0USkRTCorTnAROpQCD1qQKAWb+jKGgVsK718kANQLk0CFeiG3q+Sue1UJrVICtMDAMwn1BTkSgnRgnmCQQDH6ndMjckUwCdgTJ3KBiXjCZvwBv58gGYlc1MXhgVBdu+TKiETtSMFw6J6aLC73KFrUuJALptyPYJwOp8OFcvHDtuFHVCnTDhVSs/HFLsc05DqoCS1ZlAJDLkFBcSkCfsQhqWIBs6JUl71I5zS13PToqTVU8FCRsY1VuUUCoSAOBh5xEQBkVLDIUSE45dMSxyLLpRGw3di5XFltWfADkCICITBVBq1cKbWlak8cgCfqNyoVAQxSEIFHbpGIY0kRgeniqsDwg+FrcU5FCPEWui2bt9wFJNIFCBXHJ2AY1IJnJXLascqEkICKgCnbUvAIUiK21W8ahmxPxEqbDAi0MqTIAuqnJ0jWbMXWRaqmy/pm80crXPa4/TS09CfRaRwDTXEH8nCJGJza9ughFQYbVC5Eqr6M3MuxxKhjaqh1gGNZFUNBzAi4IjBghiUiaE5yLQiuzPdm3QKrFPFcoUM4VYu0nxZJ7BjDrwgLkMiSQAJQHJ+okx0JbMPPCwsO3sja3HwKkmsGICIdG4pDYmLhtg3wqtZPPFuuYLQVB07IFSFsm5ZlwcODY8nD4Rrq29vrtosV1+UQClqswlNb8ROqV692UdzYeG7mrfm53oB0jx490aw2N7ctR/hugUOH6+sbNPSP//hPlprozVp6V59hwFsM2zjTZHyCZQkw2KMQHwH0JWJXnluXsj5LDjfVkJfbctJ8dS3fsSIXv2EqIDErrdOYaTj2lM9hzrzNoPzDhS93sIZ8dnnN0U+jPvc43MlW0ASOAFFREyaGR+F2lTzhqdLkOsas6aUV5DUUCemn/UcKYC6xYcjYsD4roE7pZrEZ4U07BCkka9w3cbv+k1RrOgtpYNgAjGJhcNKfVY50LAnoSm8EzwpKYQDAwKgm9UiBfuINKjA41MJlwQGmATOFAcb8OlipVbAB1DHGQhCCDRI7BAwAOfBQgRTkIiEFziKUoix4P8ETCj8SwVyhHQ3gp4kiVQs8zBJLyooYJGmk2p2bWV+//r57hvgEbyxLELwpCAkYFDFgi8G3IERgMLux5WDHnq7wr0l63U8fnV0Bi1zW1N7HqGz5+kMaKiEN8HpcxaCJyWHwSSDlwmzDo4dWs7U2U7eZE0R2Ssa2Dca+qQxYqIbligCojNqUCO1Vk7JIQbHARHzrSRMmHWbonAJlCZTZiiCRgsXsiQpUpQWpP4lQqRy2JSvUOfT/sYG4NUGRilAkjRt1QU6B/DuisigcaaJp4/QhaziJK6Z2T3g8JcIgKAU5eDwa+f3lX/7MwgZBgJmn2Vit2SgCzLPMY1LIKo3/YEE4i7gzDupPbAEVGglhQy+te7ZJpUtRttwM4BWw4gG+llY1iOOPNnFQikAdygDJmCq29DG1rLGAlygAEFc3ildgEQF+umAurFYENhEHyMxbFWeI674JPp0EYGDiNKLU969fRezxERgT/FTxSonjAa3ur2KmGJRCGjOUU0sqpAorD4pLt5jnpwvwqYuUgPlWSLqdBTMmFcRMNaOdwg9JpVazeLAuhAE6KU7+F942aXz+4he/0ERxIoVmFFTcnF8Fzlj5rmsz4LfXjRwkUO3tHkxVsEtkMynBpN1+EWYMmGhbW5vOaPq4prVIt25Z7bQs8+Inn/OH+PVegaulFxdMQvOOsEXgrMtfXN5d9jKwniDjFzt+2IPKq1k27Xg+k9pcYX9+exHYBx+d3lu5a53T1p/vtsfRk8tpF7rCT2UxyLZGEi7HodD33rvDxWzB3rPaDQawfMu1APgdm4r2gq3esDZvB3ErZFRZcjMJyEU+vK+5PrNWWjtN8wuSaa5Xu1m54dzhhZiuoB0QhD55b0jBw5YeAzFr95pIsMb74MpdZ+JkkV5L8FOgfIkiEO7MqxV8mCL6Mwp3el2undO1p485RmAxM1sPVy3TfbRZqgbjqMDYUoZENUV2K64DxFhseM4p7pqEffho3K0Ik+MyWOuJW1pzBQXfvbY4nFM4KXLCNI4g9hkvlbYfX2mmwrQ61sES5NpLNJI2eosd4oRcWpNc8HpsqxwskETmSlQi3dDAGxwKjW1kRKULolGcqhVV/+E8n0OD3FoXOUiMgRCZFVdDL5oWhxM2axWG/YDdnWHpRE/FoxoPmAQZACHdznVEiPvCngmosugS1lOC3OpQruGLUnpzHaTvGBku6CDNI++tpDUpEqK2f+bdDvWLMWUjxSyfIiEOYQjNvmZ811z9C6308aPp/sWoGDCEo+3UmggM0NIhzNomomAElQtAQXGNKB7E3QcubTQkvZcNVD8VTE1MqwefKpihsAiRPfk5ewZ8iFym/vLlzi9/+fM//OEP5vfIka5OozWoLLN1LCatl0umbBnlEg2EK7z2JhEHIaba7MVz/9MZVgviIMs6SHGQxMaQIEW88NiCWTu5yeLjEBVUA7DKBqA4pcDW0Nzip4iyByHjiL9eyO2vztrBDBsAAbaObeWatcBgscIqOaI1L+fn8qmmuWa5FJXFPHg/Fa/gRkDGMsC4ZhoEQJVyBVUlMAL3Ainr+KiTpnOM+DRbowlRAD6VIhceVCX746zFbe1TrIVoo3KYDX/QghZ7hJIV08/lz5vUK10j/OMf/4gQEfw0RQCA2+3tLdikK+LmH+NKVFs7eEMdOYfcPC17OthkaqIhmbw7J0AWbuLHnddyuQGrQJvPnriSxIji6/+TRSSazNED21bnthAylNf/Oz3NmJG21WgyoYczXiMjp+8bjg6M8suuNLjlg3vv7d8uOaJjynNn9cHDXPuTnf+OK00Vce5EjS7awX2ej+xy86mEmR3DSfMWY7y5y6b1PTwEd56lWu9hLJhoZhCUBpqPDCCdJiTFUhD2/B/8U5UapBRufBaKJPFLyl2N3bKZMH1DMHVx9nzWWMZ9GPBkN1jvpAu/7gCIoB0M+rz+Svl4BgCDFoCNMkDD3I2SAOjT1KNgrvyMzSwvnZ8YJZy6j9NHOKx+m2BjADDZAYT/GQxVrlLhkyCXjpYqBqk78T6zxr/xYM2GhnPPclW95mfApnKxgavFBQOUTHYFPOtJoVVc3EFPRuigkZmNRG2HCWEVHin9qQlIYX4kEvEm/OXevosP8AnYG+nr68tOU7JwHfHewb5uKQe8so7x3raNl1z9zHcgnB7MPCbDTYwpW1moFA+0ZNIQ5ufYydQAyJtRdr4HyRUTZ5QAfCZ5TvCQdYb5sAkjZfoPnYrZZ84s5OYiPMR9c3t2uTU07BEfEkWod/l+/H5UOvbTdBzOAlRo0TnIAhQGIYIkr8vrY2GmJxKpwog62yNCvk5hc86xWmzMV8Ps/c77RnhAWvuwA/nwyZqTyMcHuZauF3lpFIzLIAEBVeMnt6MKsJ1hikp1510cUab1v/+XP/tOOSews/NjrzT+7W9/CwAbYeHaJ1c5GE4PTLxIOGLTuyCOs0jUSWuuirhy5ZUWIhGJI1naTDmjGjoVKKhFpACWCy1gmJkLGaT4adChyuNlPuSUJ0iR8gOAcXhSDTDpXB5z546Jd4OHUSIBkvPFBuTiUkRgQxQzxjKs1oq5FkJT8EMrlwbxaYoEv8TyiRxaCiJEy+CBYRgAiRSkTTib23SJWY55/DhHNt3uNMOiyqJIuRKBgVarWIJI1xYQ0m8TLRbg2O8sLongASFPYNACwCpCpEMaXRqwMisFKkEEAxLhAYwWrcI2o/i0Z0brDzacILq/dwA/pYG0C7219fznP//62dMnbNm9Yc82XAL8lFvHgIO5qw/W4uU/3nK+0E9WZADImugzvez4GjiNFvl66z8ua3b/2/P1J8+ePsoZ+IVbeUnjwSpPR3yMkQInpHD6klx0RWRLA/bQHSC1t0znqYV7airviJELmJSMBc0v7ePFl9rWcP+Xd6YcnslCLSWACRjnYbTh8E2OukftirMKASopZJcoXuBmtbKkkwWTwKRgspjFW1xEqZorDCAByIJTHHtCqXjWhOTqt+gQZmACDLglOGzU6NJjCdRy49zZWGHkqV84ASMkiEBYuVBUBSqaVVhKlQ4hZWNbEVIrLk6f0tPrOX3rRNdi7EQXiJ8eNaEPpaCCnM1DW4X7CQYS3EIiS8rOmx/YGB9gaMUX+fwKiaR7h8P67Nwsk1V+COPrM2DXSZzU9cODERRWHVC+HhdjhqKipazqnDjFGyXmpg/t2bLkaaYyKs4A34LSNCUcUm9rBwnawAA8cmW1mRdShYqABFAzAC8lrSPL6/kUtp5PFpjahifkwNSIIJ2LAC9FXIo4blGBByQS8CgFiZ8SK6afEuUKxRz4GW5AolqVUnE0DHPVqyA+Le46+mwlx09l9VPsofjRFaQLeYH9viv3c3TFyAe2589InwNFWvRvfvP3cAKwSEDh0CoCSVWHWR6uo2OXizr0Zhv6niU9LRwP/rLPc0kLZnBZwrXcRxxYkIECx8hgjtI9ySORKi3FIENNRqwgqyASkpbRKAWMzDwyaxMU9ATmflCVLp0jg7DKBQmbdKUaYIAK6SKXhagikCgChiXJUg2egHGCJaR1Oko54WAqoF/QDW1vf2pw+/q1zxKscY6s2Z/FdLmu4NegnG03PGfiNOBPRYOnQMvur15Za8K8Ibyjbw+oy0E6ntRQ0XlB4+Js7DhXsOzrHE81/r39g/2DQ0ctrZZYorEpaBHDgXQsEbAWgFUzcawKqs3PGhAliJPOT0LpyYhJcEYJTKI4DPpCEYE2CA4tQ5EODBs59Zbxfr6xjkkOl4pcYDTnj5Ys+lq6McQ/Otx1cP9nf/GVnQI1CwkwPDtHo+Hy0Yt3lx0Jmdn0BW7hb2Ng1ge7e1y2GYB7hA5tLB8f7r57C9R10NqFPT0zCPZHZKUI5bLPtz/uOtJqA8BwDC1yqUd0cU4cVuE6ObdSG70xPIkAnOtHEf9UQZ+6HyITjR6gBZNvw9ranrkaPUhRJSwSXH+CR8KGhIVp/KALYQ3bT7m0LSKldogQ5QuyBLQwjwEwAJRFy1MpTzyXGT9pXl/ANnqepcokAhjIlcrM1YZW3saIg+C9RTBcJ1LMqjgiTKiMUmoAdZrieNMoPLWFqGVufs9WTI4bLhr1u3Ta9hiWWhBmZVHEEmCNDmZ9g28/0DYwdVQpwBh/SMGDl/xUE0YYmOuUUbTrpzc20vc9rO9evaZVLQLzpPBUJLxpVbaLSGwp8OLMG14Yw4CKZhLoYptCKJZcMKhEcQajYoHpn5io/slPnTiEOgNdV/iZRW3AMOCq9oOuCOQiiZ95KSF9OVQglfKeM3iWoH+CoVUAEs/eGyAswdUv10nqaglL1RswRTzB8CqxotmrdzrK8FoT07gcsbPZT27OhAfIyy854JNFG8CKYCNd70qWBKRYtdaioUULRfy4CaDssS/AEpW12EsExalDQXFc0ZsIkwHvqLlag4dfmicvd4tHIqw3ZGtX9AAD5QAQ1GBGQ/5TXqUqj97gyrnPQhtCFbTNACuo4omWBcDUoSB46a0Vz9KDGX+eqEqh1tTftDfpKgBOCCVCyFLFlYVHOuqe0vsTvKE64Zk4JjW/UlREXH2oOXFZyCkCZwvKEmB78uQxxwoh+NauJzB4bOGqToIQByHiIC2ObWWhhRNdnOMZKkjoJPJfT8ZFkNNzQEKTFbMcQkJwCGVJUc2kUNzPa1u/2tZ+82ZH3UBFCnYwCJcxgHTLeuJKOs8CUhfLS0oRB49oeVOcGrGNKEhx6YII6cCzTjgJJREGR9Hp+5tv/uD4gzvYv/hs68UXnxq2O8Dzdved49Gra49ThZavF3IBby3b7quPn/BuRsjQsmnTbCO+Zes/D5b1AV6/N/z3go43dRzSZ/VsUesVyrBSUrymRxu4cmbRKIT44lKI40nVRo5e9687IxQpDPldycDpuLzZeFOr5AJxlVrIBwajoijBawDyrkf9KTgTSgxUyfCrCzzIQoiqPZFQvE+RBiwJEmkMY+Iw419BgZ5VOjwS/ZRLt3LxAN6mhRD938n6Ievyk+3BVhnB659MdGybKiJRAMNULACav+IBY54lKi4oDpt9FsA9cSCFfbIxfhYbgGVBgjFo8YMrslcKG5xk54Zk6bnAo1jzww9ukRMRYCCdViMMcFoQ03XQkxXhBLAhkZpcuKs5m6nweqkL5FgFd4cFCypPn/jyzSOqdTjYUMCHJ/CPHzipDfzE04S5SvD+ckfqfBY4Ez9DiUxJr0ZFppuykG4rw63aFESEppOUXNC2puihThNjmqRcdeGNWBGK0pkRFhvUohQ2BKgUAY9VyKkUOWFIZXUeZkham3LBQ6IgDEJ/wilIR0gkup1dKeuZMDAekCJlW2cMm1VWvUK5Ra4IVQS6FK4I/pGDTUpt2E9g8FALhuFESETw0WhgZUCieBiaxYwFczmaRjvjxKWlObXm/7g/rMAYHc3E0Arby2+/yzVglpO8JqiVGUleeHt+6djXDO6tZB9Ilze5zmdI95YazOiRHN+0TKQbviEnG/smsESkcU/RyFVxZGhrEQEJhjDFQ+9cnhplELTKZowU6mdxDgMR+EeYUbEiadnQ94ot5crqeEeuQAvg4YSfakSkIAczThTXojyRo2VlaUlg92CipnHrGCPaNJB0LRJNF3hGOBVUkRJVnnSqEHBk3lBCChLWohaEfBFmNDacYAA5gU5kCWSnRmzSotatATmT5xjzk8fr3v0z3XCRr0ZtZd/9JiT1JDgGIKQEonFAWUJZ8Crsng9ToIIlbNj41fpUpxnAxtNHX335hQNy1ioUUdZaS4axNnTt/H68nfeDYtnpYOjBMlRW2LxK4JI3nYZRjvvNLz/k5aB86NFLCTlUB7iGZCdQ+6YxEtEPtYi/28sr3CL4BFmbSZs0Htdd5d2FvIY+a1hXllDmKROwUrBRlF68cU/pEm8iA5YaGSM0vEhjlkvDdE4P0qfict5DfVGLUGakiHtWCoQAKEs/nhJLnaqBQYurEmI8DsgKABqwAV6QmLgtaJ86GYcCQHFWx7DhRwUM9mivpNEitbj0xj0VQa6JN/wAgw0SCjFyZOfjv26v+8bkrCQoJVdABTPwNCiodZiQmKrZzTrKZNVnfDLDqGhYVVNsAA8Knp3mtTbzm2obDEj84MSMiEVFpXdBktENAvf8ZSne9QETYMA50k5z5T3C+dg4zkHoEWFL67adM76e0O4RoeT4nTkGTTnogNFSi0dZOOVCXw7F+1P9IoSx/gRfiUBSQvUgRSsWZ9icCVVo7KO6eEzI1UX1hg26QkJ7rNsz9qcoK8DDNgeZzz6jIpSlAc7OMFXgBBvZYP84I4MZmZUQDbf6kHg4vZSC4PGp7ugTG7yoJ8xlW644zHCKyyVlwaRL7FxKFuSwyfKEMCnkJFJfOnAMjIQW4F6+fKWPN15GIE3U1zNmeuvukVkWjkhYQVIoN34ChlEW1v2kcaWQZBOyuM0bDqoRZUU0ErmeGFVK2Rb3BE8AGPBKKVKqI9wrIgs819lKpR2J4qoN5qkndZZejYGSWQBgwAuhyQRI303VNiR+8803nkgI2ICmizAgScdzeRfMBjIwNiexvBEQJwjBTEZx2lO80mG+CPNq0vQWAAyf0RVGrllnvMh+gzaPT8gt4yIHnkJYITBxqASyixMNdRHITQjLMIodHciVpVQ1hiKDBr/2eA0JG0+q+83rH6gIjHRLCZ9sbUHuzg2u3w7er3/5K324t5fUly/Aw6wF+0qU5XRXIDPqwR/zMrGlgXBo78uRTTej2WTOS/h6GR8ZXYLGHpNdX0u3a/kmV2buBHQ7AaVRArpcSxbql7yue/W6J87z/u64b66ACMBolcfWdIw+TP2jyZNjns/QKLuq3q/kJa6bfd5/msMLmMxk+9KYyMxJwavDGFoBRSkKc5sBQ+SxaM6umPrN+1OxL0yMu6IFHax/c48utIKCArOBStUAwZXqkKURwCxMdcQZuZw416ul287JBWNxQoPPS/bTERZY1T9ay9IWMAhhg9nTT7YBm6wSGszhgWUzMIzBABUMrsxhDK64pmFxRPIV0gnWKFAnyzWrytlxzeCMJhRXoWhBC4wxw0l1ehFabBHwGJCVXdQJfsLtadDBOWPIejEAKUaBXL/pZjo5JzuNTRY+zqA+0xHvRFddIIeQ4UO0AZM5HH/mL8eNDTUwbDJgGzefTFiaSpmh4cx+uLLKXt4a9xTKs1MMIuFQX3HTAcyN0JwGG50jZlmAMtzZfXdAfIGJQth2TatkxZvqhlaE/rUsIyrpeIRfEScLZImDQUvET6FFwo8Wkk8bTC1cpJGWsQCZ3BtkOTp4emJFWne4uvqIMnJI7VbaO2awUQZ4BuwBhkE6ZaYZjiHpPYbu/3hO6ZykC9Lcesx+IIGxcimYz6QR5vvvX6mzx4/XjLBBbG1tmPRQFiGRkQULMBWGnggUaPs5ppM+BwcC2tIVASYiKOinZxrjnIxUhNYgkStl3jx8Ktudl7wenLj0lOUJM2sGH17n7JSCumW1ZeB50yoAgDd/MN6ECoyUn/70842nzwz8mbWqlQIhXbDXDhXJBS1U3CKNKFVtoigRaTjp2tMw6ne/+91//dd3yoIBQFhKiFTT5/lJLtUjC06opBuAG5VzeZDLVTBnEnPHSro6+PGDK3KJ0APe6hlhUAsA6B9mYsIGRkHAVYUUWXRIG5CLcPHYg1ncU1nAOCE+bJw+NlCBtruF8MCA/s7OGw3V4Y7t7c0vPv/Ea/paqeG8ssHwMVcxc17aE5/oeigNluCYMY0wmQUTyS585tMHVVy9adnTFSzGOfqJdBWYWVld6WtfKApkwQwHhgSAfM7Xe8VeK/HxQudgxq70KWTURKzgW7wARq4oliu3zDMfokKXc3BpFQGrFsxUpYX3U8RTWcBuTrGpyB+qKjWm6ppbMABlzxMSRZoORpaAH/WLPbk4AYBoMVeQxoGVB/Ui3fMmFIxCmDoNgFe5h/u7ntAyAADSVRnMNTZ0xSHEldxhJCmCFD89UfRTKT9xC0wtixBQiyApCcpVh8/A/CSdIsixdtRZL4oahQjGMCkXnxkknV044A8hWk3nzNSaa5x4azteWf6eo6Xmu2QGpqxqOtzbz96v5S0no+bAO8wCpwxGBDbcamLiilSxfkrPRNrpG3240zuOhy7cZpYEUS3pUieA9z/GyAKhINI4GeXSg6mFavcEBhhyMoIRoTQtTlCQBlyXIx0/OFFlVelgzShNWQi1I0H8RtWhN6UUDIm8onhlco6lkZ6qITFXglNB1E1A1QuKdReKw0/VWAJp6tCq16KtnimijpBm5ADopUNDKfhUFn6JMHjiCht6AbTUI3481e8MFeKKK46IUtEbm4PF9Nc6OG6++uoL0K9f/2C5jFuEdI7e5BoyQPxghcETFMp7okQSyhKXPvUWd4wSAIEw0rlgiiv5ikQRBJOCIi5VJZEEIhGjAaQIkQCXBHJaC7SIqjn3KeATb6PWtExgsAl4oDL4YVCE0xfX4fkpF2mQuIKKieNBWTjhl+In2QGYgkvHAFrb2xvSM5SeIBcw0lBVm3wuYVWPdLTERdDCBgzlBPIGP2HwREgReDDpaV5OUZhXBAbAuIIfG9WbnyKe6Koy8Zt+GjnpqkCiIqXuJzz0gxPYkCMCQg7OChSCveyvrCz/+td/k88u3uZfDEMcCsx0x+a/IfaxQwk8SY4KLJJEL6bNU0Muw7aQnG8rRnsz8s6VDwY7Bv7WbbLYspixMIk05f3DzKmxVOuSYgwtpQB8B7YFP1UTD+JEqVY/rxe4UiK2Xu2RnQhoygc5F0peTRdwFZiFy7gdo/npXylEKJPhs53WjF5pyU/YBOXUCOrigKU3lKgntWC+JkSgVt+NAUiBTfHy6YloU5SCUBUoAl6NqxEpmr2zWI5zUJpEasEeDKoJLZAY8FTRUjAg11MiWvBDWDbYJ1og5bJnJwhtALJ5usWtLDjZ2wgVf4S6IjUJibY5AUDl6acAD84FcSMGtKCiFk0GdWwAlgJARIos1W7xU73py5UicsVHd1SRwTpggwXpgvotFfxgEhJVF4A5xVuYSQw5FV5HARsY6rSghIqCfsKAc0EES+TyRFQvKrGoRP63ulgHnuGX+G7f3msGUvQMP0iYBZjFCSKIQ4icZ9kWKXsicgXpjSvlp/j/DtnGnopQCp/w96engkgDNvznB1DBzHV9RXwwEGIDGGABDCrwyJJeVE3pz5KGR7APDB7ClhUhNbS+iJkXBwTOnd/xIplijF81q10LJnY0P9l6ZgABuu4SJXEoYKz6RG6El1JeEYDKT7lSRAQFKR1DUgDgxtI/QoozMsKISJeirJ/kEfeEhMmKKwgDGOYLIVY9/cSPoIg2oLuiAn5NESTYDQzUTUxo/cSAXKWQE4e8PhpmMPaTBSmQmBXBoKyCAhLIIdGCfsIsQAWPCH3KIiacEg3P6bBsVxzp8MiSqLi45iqRcMhh2CIBSBQ98UBeLMEMphgwQHZc4VZxP8H4iSulUJcCEn5FCOuqO7qFSoqXHl0yhTqiYJSCwWqnxT1UAIPRgiD0zV5VEwaWNHUMp0uDedZ2wwmYYftEd0JMa0B562pufnW4zv5stOKi8ziFeJMluwSzzi5OV0QQyCW3gosLVSOuih9FpYohwuqApi6qvapdCtPtmJr4wDwbqdJunrChJRShdFJLRLQ1IuInPRQJMcFgWCJ+BBxKAayKJbai0dIsy1gLYo90nhCa9sm6IRopFjLwUhaMdkd70Ko+3l+EPk3URoKMVVtTSkGCtLKycEgtMDS9VSkdh55gvMWt0kUghxBaxVu/kChbDIojAQYk52a8ydWArJhQcUZlHpijX8azaBFKolzxqVNzZZ4xtsRFUA6NleIMI1xuGpddeGN/YADGg0FwNZMGL+AfJ/KQAA9SMJW0vCKrOpQCgLroXIp0elB2YK8GPdASEwZsi+BWLh/BvMDjWdNTFnuQsAGQUkqRCLIgxIOIShGBkFyQlDFFIsF4BlkSUYFZCq7nDzI9WRp7NtGyXwdZttwJqAhI8NVVFc51yJUowJ+Cw79WRAreQgpClUjx6KvjpBm1yPJTEdjkwlCpPVUiomHoeoyOBN6wEZ+o+r3a8c03r7INkzGyYcjVOBeiKosXc55LGW9ySKRx7JIHdoShkyJXgAGjfSqLsCxFDEZIq9qkGHVSt0aLNEuFHAw84McBXQ3BqgJSIaSUXAJAVTuWK0U3qbXAzFvJ5bBIpAh4zEALISZFlNIS1DcYkDh5+sm6gRJO1LFcN6nx+zeGhZBATLZkbYQSsS3XwQwYwCMBD9LI0YB4WwurcigCWsXxIMv4GhsgJZLFagpg6eJIt316dRmTUuiE9kBiFRgMqhwJuSJ6KBFHThXXUnkQAFVdGtv0ke7vlqgIJt0qRUsm5l52t4nmVU8UqejUNdTzMXS5ZntU5Doaz51XrzfWvZ2fGQDqRPAUPzs/yFX/C3ffHUTDbNplpKjEAKb/Zt8Yc+u00/xLiw/v29Shm+moKIpEMVAf482Xr+M+lJVu4qCUd4noZ+VOKi767Mq4Vj3ftDPwtySRoYH3UXKoJ4N0T34g22yUn4/Wxfzo//5SfKI4mA8LH+wtaMcZafkmmSHwada1KRkPvAg24BEs6rBgPuf07MjllL4uuHTvPk5mNz2ViFX6Buny4da7/kaVwkbnlQiDfk61hAeBbl1PqxbIiDoAFAHA7AZpZ6UgubyIH1fdR07bugusJx1nMQFaWeAVrI+WQiyOTUFsaPGxdlOx43Pu0BSNQ2Ay7M2CR/gfv+8ax9T4WKCIOZwS1SF+TLwJiD1PDLff8kSXqThnRasaL3J+ag77B5lzyxU0B5wAZsN4ox8rnIdHB6ur26dnjk54pTF0acA1qhTlYOr9B9nGRE7lufJZBVa3NOByPiMEHGVTKbaXF6uIQ+Lbt967RNb0iVbJJRESs1xSsBdx6XSlZkWUxdvoPFeJaD2Qk04gvrUrubi9zPjj8N3evrUlgn9guqNYXTKReSdotXTNkJhh/nrpvG0fjINwBHGfvIISca4I3uAHHNXOVYMxx5jQcDkj6Yg/gXICZmBxK7cYPHuSBeqgMpjKgP3CJNAd6rApjg2C4AR8tHRtlnJbfTGkOW8JhqQA6Af/N+K3FDDy4pm3+G8aggzp1KcZwgAAAABJRU5ErkJggg==", "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "face_image" ] }, { "cell_type": "code", "execution_count": 12, "id": "ae341903-8410-4d2e-aee5-263f469f3cc2", "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "face_kps" ] }, { "attachments": {}, "cell_type": "markdown", "id": "e9882719-5f14-47e6-b537-38322d4ef66e", "metadata": {}, "source": [ "## Prepare InstantID pipeline \n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "The code below downloads InstantID pipeline parts - ControlNet for face pose and IP-Adapter for adding face embeddings to prompt" ] }, { "cell_type": "code", "execution_count": 13, "id": "bd206ec7-7dfb-4927-8985-346853bd7f46", "metadata": {}, "outputs": [], "source": [ "from huggingface_hub import hf_hub_download\n", "\n", "hf_hub_download(\n", " repo_id=\"InstantX/InstantID\",\n", " filename=\"ControlNetModel/config.json\",\n", " local_dir=\"./checkpoints\",\n", ")\n", "hf_hub_download(\n", " repo_id=\"InstantX/InstantID\",\n", " filename=\"ControlNetModel/diffusion_pytorch_model.safetensors\",\n", " local_dir=\"./checkpoints\",\n", ")\n", "hf_hub_download(repo_id=\"InstantX/InstantID\", filename=\"ip-adapter.bin\", local_dir=\"./checkpoints\");" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a2e06e46-8a28-443f-a52c-c5d8f280c89d", "metadata": {}, "source": [ "As it was discussed in model description, InstantID does not required diffusion model fine-tuning and can be applied on existing Stable Diffusion pipeline. We will use [`stable-diffusion-xl-bas-1-0`](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) as basic text-to-image diffusion pipeline. We also apply [LCM LoRA](https://huggingface.co/latent-consistency/lcm-lora-sdxl) to speedup the generation process. Previously, we already considered how to convert and run SDXL model for Text-to-Image and Image-to-Image generation using Optimum-Intel library (please check out this notebook for [details](../stable-diffusion-xl/stable-diffusion-xl.ipynb)), now we will use it in combination with ControlNet and convert it using OpenVINO Model Conversion API. " ] }, { "cell_type": "code", "execution_count": 14, "id": "9be23b0d-b8f5-4717-800f-f2151719bf0f", "metadata": {}, "outputs": [], "source": [ "from diffusers.models import ControlNetModel\n", "from diffusers import LCMScheduler\n", "from pipeline_stable_diffusion_xl_instantid import StableDiffusionXLInstantIDPipeline\n", "\n", "import torch\n", "from PIL import Image\n", "import gc\n", "\n", "\n", "ov_controlnet_path = MODELS_DIR / \"controlnet.xml\"\n", "ov_unet_path = MODELS_DIR / \"unet.xml\"\n", "ov_vae_decoder_path = MODELS_DIR / \"vae_decoder.xml\"\n", "ov_text_encoder_path = MODELS_DIR / \"text_encoder.xml\"\n", "ov_text_encoder_2_path = MODELS_DIR / \"text_encoder_2.xml\"\n", "ov_image_proj_encoder_path = MODELS_DIR / \"image_proj_model.xml\"\n", "\n", "required_pipeline_parts = [\n", " ov_controlnet_path,\n", " ov_unet_path,\n", " ov_vae_decoder_path,\n", " ov_text_encoder_path,\n", " ov_text_encoder_2_path,\n", " ov_image_proj_encoder_path,\n", "]\n", "\n", "\n", "def load_pytorch_pipeline(sdxl_id=\"stabilityai/stable-diffusion-xl-base-1.0\"):\n", " # prepare models under ./checkpoints\n", " face_adapter = Path(\"checkpoints/ip-adapter.bin\")\n", " controlnet_path = Path(\"checkpoints/ControlNetModel\")\n", "\n", " # load IdentityNet\n", " controlnet = ControlNetModel.from_pretrained(controlnet_path)\n", "\n", " pipe = StableDiffusionXLInstantIDPipeline.from_pretrained(sdxl_id, controlnet=controlnet)\n", "\n", " # load adapter\n", " pipe.load_ip_adapter_instantid(face_adapter)\n", " # load lcm lora\n", " pipe.load_lora_weights(\"latent-consistency/lcm-lora-sdxl\")\n", " pipe.fuse_lora()\n", " scheduler = LCMScheduler.from_config(pipe.scheduler.config)\n", " pipe.set_ip_adapter_scale(0.8)\n", "\n", " controlnet, unet, vae = pipe.controlnet, pipe.unet, pipe.vae\n", " text_encoder, text_encoder_2, tokenizer, tokenizer_2 = (\n", " pipe.text_encoder,\n", " pipe.text_encoder_2,\n", " pipe.tokenizer,\n", " pipe.tokenizer_2,\n", " )\n", " image_proj_model = pipe.image_proj_model\n", " return (\n", " controlnet,\n", " unet,\n", " vae,\n", " text_encoder,\n", " text_encoder_2,\n", " tokenizer,\n", " tokenizer_2,\n", " image_proj_model,\n", " scheduler,\n", " )\n", "\n", "\n", "load_torch_models = any([not path.exists() for path in required_pipeline_parts])\n", "\n", "if load_torch_models:\n", " (\n", " controlnet,\n", " unet,\n", " vae,\n", " text_encoder,\n", " text_encoder_2,\n", " tokenizer,\n", " tokenizer_2,\n", " image_proj_model,\n", " scheduler,\n", " ) = load_pytorch_pipeline()\n", " tokenizer.save_pretrained(MODELS_DIR / \"tokenizer\")\n", " tokenizer_2.save_pretrained(MODELS_DIR / \"tokenizer_2\")\n", " scheduler.save_pretrained(MODELS_DIR / \"scheduler\")\n", "else:\n", " (\n", " controlnet,\n", " unet,\n", " vae,\n", " text_encoder,\n", " text_encoder_2,\n", " tokenizer,\n", " tokenizer_2,\n", " image_proj_model,\n", " scheduler,\n", " ) = (None, None, None, None, None, None, None, None, None)\n", "\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d3fc5252-df17-45cc-8733-51e759e76cc3", "metadata": {}, "source": [ "## Convert InstantID pipeline components to OpenVINO Intermediate Representation format\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Starting from 2023.0 release, OpenVINO supports PyTorch models conversion directly. We need to provide a model object, input data for model tracing to `ov.convert_model` function to obtain OpenVINO `ov.Model` object instance. Model can be saved on disk for next deployment using `ov.save_model` function.\n", "\n", "The pipeline consists of the following list of important parts:\n", "\n", "* Image Projection model for getting image prompt embeddings. It is similar with IP-Adapter approach described in [this tutorial](../stable-diffusion-ip-adapter/stable-diffusion-ip-adapter.ipynb), but instead of image, it uses face embeddings as input for image prompt encoding.\n", "* Text Encoders for creating text embeddings to generate an image from a text prompt.\n", "* ControlNet for conditioning by face keypoints image for translation face pose on generated image.\n", "* Unet for step-by-step denoising latent image representation.\n", "* Autoencoder (VAE) for decoding latent space to image.\n", "\n", "\n", "### ControlNet\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "ControlNet was introduced in [Adding Conditional Control to Text-to-Image Diffusion Models](https://arxiv.org/abs/2302.05543) paper. It provides a framework that enables support for various spatial contexts such as a depth map, a segmentation map, a scribble, and key points that can serve as additional conditionings to Diffusion models such as Stable Diffusion. In this [tutorial](../controlnet-stable-diffusion/controlnet-stable-diffusion.ipynb) we already considered how to convert and use ControlNet with Stable Diffusion pipeline. The process of usage ControlNet for Stable Diffusion XL remains without changes." ] }, { "cell_type": "code", "execution_count": 15, "id": "1c91dce2-7c75-405d-a32c-63eb400929e9", "metadata": {}, "outputs": [], "source": [ "import openvino as ov\n", "from functools import partial\n", "\n", "\n", "def cleanup_torchscript_cache():\n", " \"\"\"\n", " Helper for removing cached model representation\n", " \"\"\"\n", " torch._C._jit_clear_class_registry()\n", " torch.jit._recursive.concrete_type_store = torch.jit._recursive.ConcreteTypeStore()\n", " torch.jit._state._clear_class_state()\n", "\n", "\n", "controlnet_example_input = {\n", " \"sample\": torch.ones((2, 4, 100, 100)),\n", " \"timestep\": torch.tensor(1, dtype=torch.float32),\n", " \"encoder_hidden_states\": torch.randn((2, 77, 2048)),\n", " \"controlnet_cond\": torch.randn((2, 3, 800, 800)),\n", " \"conditioning_scale\": torch.tensor(0.8, dtype=torch.float32),\n", " \"added_cond_kwargs\": {\n", " \"text_embeds\": torch.zeros((2, 1280)),\n", " \"time_ids\": torch.ones((2, 6), dtype=torch.int32),\n", " },\n", "}\n", "\n", "\n", "if not ov_controlnet_path.exists():\n", " controlnet.forward = partial(controlnet.forward, return_dict=False)\n", " with torch.no_grad():\n", " ov_controlnet = ov.convert_model(controlnet, example_input=controlnet_example_input)\n", " ov_controlnet.inputs[-1].get_node().set_element_type(ov.Type.f32)\n", " ov_controlnet.inputs[-1].get_node().set_partial_shape(ov.PartialShape([-1, 6]))\n", " ov_controlnet.validate_nodes_and_infer_types()\n", " ov.save_model(ov_controlnet, ov_controlnet_path)\n", " cleanup_torchscript_cache()\n", " del ov_controlnet\n", " gc.collect()\n", "\n", "if not ov_unet_path.exists():\n", " down_block_res_samples, mid_block_res_sample = controlnet(**controlnet_example_input)\n", "else:\n", " down_block_res_samples, mid_block_res_sample = None, None\n", "\n", "del controlnet\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "eca3fd12-4e06-4652-958f-577e95fed879", "metadata": {}, "source": [ "### Unet\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Compared with Stable Diffusion, Stable Diffusion XL Unet has an additional input for the `time_ids` condition. As we use ControlNet and Image Projection Model, these models' outputs also contribute to preparing model input for Unet." ] }, { "cell_type": "code", "execution_count": 16, "id": "06c921e5-05f1-4ec8-b712-c3dcd417e390", "metadata": {}, "outputs": [], "source": [ "from typing import Tuple\n", "\n", "\n", "class UnetWrapper(torch.nn.Module):\n", " def __init__(\n", " self,\n", " unet,\n", " sample_dtype=torch.float32,\n", " timestep_dtype=torch.int64,\n", " encoder_hidden_states_dtype=torch.float32,\n", " down_block_additional_residuals_dtype=torch.float32,\n", " mid_block_additional_residual_dtype=torch.float32,\n", " text_embeds_dtype=torch.float32,\n", " time_ids_dtype=torch.int32,\n", " ):\n", " super().__init__()\n", " self.unet = unet\n", " self.sample_dtype = sample_dtype\n", " self.timestep_dtype = timestep_dtype\n", " self.encoder_hidden_states_dtype = encoder_hidden_states_dtype\n", " self.down_block_additional_residuals_dtype = down_block_additional_residuals_dtype\n", " self.mid_block_additional_residual_dtype = mid_block_additional_residual_dtype\n", " self.text_embeds_dtype = text_embeds_dtype\n", " self.time_ids_dtype = time_ids_dtype\n", "\n", " def forward(\n", " self,\n", " sample: torch.Tensor,\n", " timestep: torch.Tensor,\n", " encoder_hidden_states: torch.Tensor,\n", " down_block_additional_residuals: Tuple[torch.Tensor],\n", " mid_block_additional_residual: torch.Tensor,\n", " text_embeds: torch.Tensor,\n", " time_ids: torch.Tensor,\n", " ):\n", " sample.to(self.sample_dtype)\n", " timestep.to(self.timestep_dtype)\n", " encoder_hidden_states.to(self.encoder_hidden_states_dtype)\n", " down_block_additional_residuals = [res.to(self.down_block_additional_residuals_dtype) for res in down_block_additional_residuals]\n", " mid_block_additional_residual.to(self.mid_block_additional_residual_dtype)\n", " added_cond_kwargs = {\n", " \"text_embeds\": text_embeds.to(self.text_embeds_dtype),\n", " \"time_ids\": time_ids.to(self.time_ids_dtype),\n", " }\n", "\n", " return self.unet(\n", " sample,\n", " timestep,\n", " encoder_hidden_states,\n", " down_block_additional_residuals=down_block_additional_residuals,\n", " mid_block_additional_residual=mid_block_additional_residual,\n", " added_cond_kwargs=added_cond_kwargs,\n", " )\n", "\n", "\n", "if not ov_unet_path.exists():\n", " unet_example_input = {\n", " \"sample\": torch.ones((2, 4, 100, 100)),\n", " \"timestep\": torch.tensor(1, dtype=torch.float32),\n", " \"encoder_hidden_states\": torch.randn((2, 77, 2048)),\n", " \"down_block_additional_residuals\": down_block_res_samples,\n", " \"mid_block_additional_residual\": mid_block_res_sample,\n", " \"text_embeds\": torch.zeros((2, 1280)),\n", " \"time_ids\": torch.ones((2, 6), dtype=torch.int32),\n", " }\n", " unet = UnetWrapper(unet)\n", " with torch.no_grad():\n", " ov_unet = ov.convert_model(unet, example_input=unet_example_input)\n", " for i in range(3, len(ov_unet.inputs) - 2):\n", " ov_unet.inputs[i].get_node().set_element_type(ov.Type.f32)\n", "\n", " ov_unet.validate_nodes_and_infer_types()\n", " ov.save_model(ov_unet, ov_unet_path)\n", " del ov_unet\n", " cleanup_torchscript_cache()\n", " gc.collect()\n", "\n", "del unet\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "93de1676-05da-44c3-ab09-12fb6b82ea79", "metadata": {}, "source": [ "### VAE Decoder\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "The VAE model has two parts, an encoder and a decoder. The encoder is used to convert the image into a low dimensional latent representation, which will serve as the input to the U-Net model. The decoder, conversely, transforms the latent representation back into an image.\n", "For InstantID pipeline we will use VAE only for decoding Unet generated image, it means that we can skip VAE encoder part conversion. " ] }, { "cell_type": "code", "execution_count": 17, "id": "0a2f91f9-4f96-4511-be0b-e565dc91ae4d", "metadata": {}, "outputs": [], "source": [ "class VAEDecoderWrapper(torch.nn.Module):\n", " def __init__(self, vae_decoder):\n", " super().__init__()\n", " self.vae = vae_decoder\n", "\n", " def forward(self, latents):\n", " return self.vae.decode(latents)\n", "\n", "\n", "if not ov_vae_decoder_path.exists():\n", " vae_decoder = VAEDecoderWrapper(vae)\n", "\n", " with torch.no_grad():\n", " ov_vae_decoder = ov.convert_model(vae_decoder, example_input=torch.zeros((1, 4, 64, 64)))\n", " ov.save_model(ov_vae_decoder, ov_vae_decoder_path)\n", " del ov_vae_decoder\n", " cleanup_torchscript_cache()\n", " del vae_decoder\n", " gc.collect()\n", "\n", "del vae\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3ef98554-f6fa-44d5-b776-24199386b2ef", "metadata": {}, "source": [ "### Text Encoders\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "The text-encoder is responsible for transforming the input prompt, for example, \"a photo of an astronaut riding a horse\" into an embedding space that can be understood by the U-Net. It is usually a simple transformer-based encoder that maps a sequence of input tokens to a sequence of latent text embeddings." ] }, { "cell_type": "code", "execution_count": 18, "id": "7ce333c8-5d72-40f3-9a13-ef183e2fa44b", "metadata": {}, "outputs": [], "source": [ "inputs = {\"input_ids\": torch.ones((1, 77), dtype=torch.long)}\n", "\n", "if not ov_text_encoder_path.exists():\n", " text_encoder.eval()\n", " text_encoder.config.output_hidden_states = True\n", " text_encoder.config.return_dict = False\n", " with torch.no_grad():\n", " ov_text_encoder = ov.convert_model(text_encoder, example_input=inputs)\n", " ov.save_model(ov_text_encoder, ov_text_encoder_path)\n", " del ov_text_encoder\n", " cleanup_torchscript_cache()\n", " gc.collect()\n", "\n", "del text_encoder\n", "gc.collect()\n", "\n", "if not ov_text_encoder_2_path.exists():\n", " text_encoder_2.eval()\n", " text_encoder_2.config.output_hidden_states = True\n", " text_encoder_2.config.return_dict = False\n", " with torch.no_grad():\n", " ov_text_encoder = ov.convert_model(text_encoder_2, example_input=inputs)\n", " ov.save_model(ov_text_encoder, ov_text_encoder_2_path)\n", " del ov_text_encoder\n", " cleanup_torchscript_cache()\n", "del text_encoder_2\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "32eeb488-9af2-4f2a-9371-7750b666864a", "metadata": {}, "source": [ "### Image Projection Model\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Image projection model is responsible to transforming face embeddings to image prompt embeddings" ] }, { "cell_type": "code", "execution_count": 19, "id": "3b9c12be-3322-4c81-85e7-434e204fe28d", "metadata": {}, "outputs": [], "source": [ "if not ov_image_proj_encoder_path.exists():\n", " with torch.no_grad():\n", " ov_image_encoder = ov.convert_model(image_proj_model, example_input=torch.zeros((2, 1, 512)))\n", " ov.save_model(ov_image_encoder, ov_image_proj_encoder_path)\n", " del ov_image_encoder\n", " cleanup_torchscript_cache()\n", "del image_proj_model\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "19b7133c-c4b5-4dfe-a05d-79139d8ae2a0", "metadata": {}, "source": [ "## Prepare OpenVINO InstantID Pipeline\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 20, "id": "0da019c6-2010-4cfe-884b-ca247b798208", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from diffusers import StableDiffusionXLControlNetPipeline\n", "from diffusers.pipelines.stable_diffusion_xl import StableDiffusionXLPipelineOutput\n", "from typing import Any, Callable, Dict, List, Optional, Tuple, Union\n", "\n", "import numpy as np\n", "import torch\n", "\n", "from diffusers.image_processor import PipelineImageInput, VaeImageProcessor\n", "\n", "\n", "class OVStableDiffusionXLInstantIDPipeline(StableDiffusionXLControlNetPipeline):\n", " def __init__(\n", " self,\n", " text_encoder,\n", " text_encoder_2,\n", " image_proj_model,\n", " controlnet,\n", " unet,\n", " vae_decoder,\n", " tokenizer,\n", " tokenizer_2,\n", " scheduler,\n", " ):\n", " self.text_encoder = text_encoder\n", " self.text_encoder_2 = text_encoder_2\n", " self.tokenizer = tokenizer\n", " self.tokenizer_2 = tokenizer_2\n", " self.image_proj_model = image_proj_model\n", " self.controlnet = controlnet\n", " self.unet = unet\n", " self.vae_decoder = vae_decoder\n", " self.scheduler = scheduler\n", " self.image_proj_model_in_features = 512\n", " self.vae_scale_factor = 8\n", " self.vae_scaling_factor = 0.13025\n", " self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor, do_convert_rgb=True)\n", " self.control_image_processor = VaeImageProcessor(\n", " vae_scale_factor=self.vae_scale_factor,\n", " do_convert_rgb=True,\n", " do_normalize=False,\n", " )\n", " self._internal_dict = {}\n", " self._progress_bar_config = {}\n", "\n", " def _encode_prompt_image_emb(self, prompt_image_emb, num_images_per_prompt, do_classifier_free_guidance):\n", " if isinstance(prompt_image_emb, torch.Tensor):\n", " prompt_image_emb = prompt_image_emb.clone().detach()\n", " else:\n", " prompt_image_emb = torch.tensor(prompt_image_emb)\n", "\n", " prompt_image_emb = prompt_image_emb.reshape([1, -1, self.image_proj_model_in_features])\n", "\n", " if do_classifier_free_guidance:\n", " prompt_image_emb = torch.cat([torch.zeros_like(prompt_image_emb), prompt_image_emb], dim=0)\n", " else:\n", " prompt_image_emb = torch.cat([prompt_image_emb], dim=0)\n", " prompt_image_emb = self.image_proj_model(prompt_image_emb)[0]\n", "\n", " bs_embed, seq_len, _ = prompt_image_emb.shape\n", " prompt_image_emb = np.tile(prompt_image_emb, (1, num_images_per_prompt, 1))\n", " prompt_image_emb = prompt_image_emb.reshape(bs_embed * num_images_per_prompt, seq_len, -1)\n", "\n", " return prompt_image_emb\n", "\n", " def __call__(\n", " self,\n", " prompt: Union[str, List[str]] = None,\n", " prompt_2: Optional[Union[str, List[str]]] = None,\n", " image: PipelineImageInput = None,\n", " height: Optional[int] = None,\n", " width: Optional[int] = None,\n", " num_inference_steps: int = 50,\n", " guidance_scale: float = 5.0,\n", " negative_prompt: Optional[Union[str, List[str]]] = None,\n", " negative_prompt_2: Optional[Union[str, List[str]]] = None,\n", " num_images_per_prompt: Optional[int] = 1,\n", " eta: float = 0.0,\n", " generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,\n", " latents: Optional[torch.FloatTensor] = None,\n", " prompt_embeds: Optional[torch.FloatTensor] = None,\n", " negative_prompt_embeds: Optional[torch.FloatTensor] = None,\n", " pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n", " negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n", " image_embeds: Optional[torch.FloatTensor] = None,\n", " output_type: Optional[str] = \"pil\",\n", " return_dict: bool = True,\n", " cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n", " controlnet_conditioning_scale: Union[float, List[float]] = 1.0,\n", " guess_mode: bool = False,\n", " control_guidance_start: Union[float, List[float]] = 0.0,\n", " control_guidance_end: Union[float, List[float]] = 1.0,\n", " original_size: Tuple[int, int] = None,\n", " crops_coords_top_left: Tuple[int, int] = (0, 0),\n", " target_size: Tuple[int, int] = None,\n", " negative_original_size: Optional[Tuple[int, int]] = None,\n", " negative_crops_coords_top_left: Tuple[int, int] = (0, 0),\n", " negative_target_size: Optional[Tuple[int, int]] = None,\n", " clip_skip: Optional[int] = None,\n", " callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,\n", " callback_on_step_end_tensor_inputs: List[str] = [\"latents\"],\n", " # IP adapter\n", " ip_adapter_scale=None,\n", " **kwargs,\n", " ):\n", " r\"\"\"\n", " The call function to the pipeline for generation.\n", "\n", " Args:\n", " prompt (`str` or `List[str]`, *optional*):\n", " The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.\n", " prompt_2 (`str` or `List[str]`, *optional*):\n", " The prompt or prompts to be sent to `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is\n", " used in both text-encoders.\n", " image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, `List[np.ndarray]`,:\n", " `List[List[torch.FloatTensor]]`, `List[List[np.ndarray]]` or `List[List[PIL.Image.Image]]`):\n", " The ControlNet input condition to provide guidance to the `unet` for generation. If the type is\n", " specified as `torch.FloatTensor`, it is passed to ControlNet as is. `PIL.Image.Image` can also be\n", " accepted as an image. The dimensions of the output image defaults to `image`'s dimensions. If height__module.unet.up_blocks.0.upsamplers.0.conv.base_layer/aten::_convolu\n", " and/or width are passed, `image` is resized accordingly. If multiple ControlNets are specified in\n", " `init`, images must be passed as a list such that each element of the list can be correctly batched for\n", " input to a single ControlNet.\n", " height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):\n", " The height in pixels of the generated image. Anything below 512 pixels won't work well for\n", " [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0)\n", " and checkpoints that are not specifically fine-tuned on low resolutions.\n", " width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):\n", " The width in pixels of the generated image. Anything below 512 pixels won't work well for\n", " [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0)\n", " and checkpoints that are not specifically fine-tuned on low resolutions.\n", " num_inference_steps (`int`, *optional*, defaults to 50):\n", " The number of denoising steps. More denoising steps usually lead to a higher quality image at the\n", " expense of slower inference.\n", " guidance_scale (`float`, *optional*, defaults to 5.0):\n", " A higher guidance scale value encourages the model to generate images closely linked to the text\n", " `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.\n", " negative_prompt (`str` or `List[str]`, *optional*):\n", " The prompt or prompts to guide what to not include in image generation. If not defined, you need to\n", " pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).\n", " negative_prompt_2 (`str` or `List[str]`, *optional*):\n", " The prompt or prompts to guide what to not include in image generation. This is sent to `tokenizer_2`\n", " and `text_encoder_2`. If not defined, `negative_prompt` is used in both text-encoders.\n", " num_images_per_prompt (`int`, *optional*, defaults to 1):\n", " The number of images to generate per prompt.\n", " eta (`float`, *optional*, defaults to 0.0):\n", " Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies\n", " to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.\n", " generator (`torch.Generator` or `List[torch.Generator]`, *optional*):\n", " A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make\n", " generation deterministic.\n", " latents (`torch.FloatTensor`, *optional*):\n", " Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image\n", " generation. Can be used to tweak the same generation with different prompts. If not provided, a latents\n", " tensor is generated by sampling using the supplied random `generator`.\n", " prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not\n", " provided, text embeddings are generated from the `prompt` input argument.\n", " negative_prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If\n", " not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.\n", " pooled_prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated pooled text embeddings. Can be used to easily tweak text inputs (prompt weighting). If\n", " not provided, pooled text embeddings are generated from `prompt` input argument.\n", " negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs (prompt\n", " weighting). If not provided, pooled `negative_prompt_embeds` are generated from `negative_prompt` input\n", " argument.\n", " image_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated image embeddings.\n", " output_type (`str`, *optional*, defaults to `\"pil\"`):\n", " The output format of the generated image. Choose between `PIL.Image` or `np.array`.\n", " return_dict (`bool`, *optional*, defaults to `True`):\n", " Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a\n", " plain tuple.\n", " controlnet_conditioning_scale (`float` or `List[float]`, *optional*, defaults to 1.0):\n", " The outputs of the ControlNet are multiplied by `controlnet_conditioning_scale` before they are added\n", " to the residual in the original `unet`. If multiple ControlNets are specified in `init`, you can set\n", " the corresponding scale as a list.\n", " control_guidance_start (`float` or `List[float]`, *optional*, defaults to 0.0):\n", " The percentage of total steps at which the ControlNet starts applying.\n", " control_guidance_end (`float` or `List[float]`, *optional*, defaults to 1.0):\n", " The percentage of total steps at which the ControlNet stops applying.\n", " original_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):\n", " If `original_size` is not the same as `target_size` the image will appear to be down- or upsampled.\n", " `original_size` defaults to `(height, width)` if not specified. Part of SDXL's micro-conditioning as\n", " explained in section 2.2 of\n", " [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).\n", " crops_coords_top_left (`Tuple[int]`, *optional*, defaults to (0, 0)):\n", " `crops_coords_top_left` can be used to generate an image that appears to be \"cropped\" from the position\n", " `crops_coords_top_left` downwards. Favorable, well-centered images are usually achieved by setting\n", " `crops_coords_top_left` to (0, 0). Part of SDXL's micro-conditioning as explained in section 2.2 of\n", " [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).\n", " target_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):\n", " For most cases, `target_size` should be set to the desired height and width of the generated image. If\n", " not specified it will default to `(height, width)`. Part of SDXL's micro-conditioning as explained in\n", " section 2.2 of [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).\n", " negative_original_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):\n", " To negatively condition the generation process based on a specific image resolution. Part of SDXL's\n", " micro-conditioning as explained in section 2.2 of\n", " [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). For more\n", " information, refer toencode_pro this issue thread: https://github.com/huggingface/diffusers/issues/4208.\n", " negative_crops_coords_top_left (`Tuple[int]`, *optional*, defaults to (0, 0)):\n", " To negatively condition the generation process based on a specific crop coordinates. Part of SDXL's\n", " micro-conditioning as explained in section 2.2 of\n", " [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). For more\n", " information, refer to this issue thread: https://github.com/huggingface/diffusers/issues/4208.\n", " negative_target_size (`Tuple[int]`, *optional*, defaults to (1024, 1024)):\n", " To negatively condition the generation process based on a target image resolution. It should be as same\n", " as the `target_size` for most cases. Part of SDXL's micro-conditioning as explained in section 2.2 of\n", " [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). For more\n", " information, refer to this issue thread: https://github.com/huggingface/diffusers/issues/4208.\n", " clip_skip (`int`, *optional*):\n", " Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that\n", " the output of the pre-final layer will be used for computing the prompt embeddings.\n", "\n", " Examples:\n", "\n", " Returns:\n", " [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:\n", " If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,\n", " otherwise a `tuple` is returned containing the output images.\n", " \"\"\"\n", "\n", " do_classifier_free_guidance = guidance_scale >= 1.0\n", " # align format for control guidance\n", " if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list):\n", " control_guidance_start = len(control_guidance_end) * [control_guidance_start]\n", " elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list):\n", " control_guidance_end = len(control_guidance_start) * [control_guidance_end]\n", " elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list):\n", " control_guidance_start, control_guidance_end = (\n", " [control_guidance_start],\n", " [control_guidance_end],\n", " )\n", "\n", " # 2. Define call parameters\n", " if prompt is not None and isinstance(prompt, str):\n", " batch_size = 1\n", " elif prompt is not None and isinstance(prompt, list):\n", " batch_size = len(prompt)\n", " else:\n", " batch_size = prompt_embeds.shape[0]\n", "\n", " (\n", " prompt_embeds,\n", " negative_prompt_embeds,\n", " pooled_prompt_embeds,\n", " negative_pooled_prompt_embeds,\n", " ) = self.encode_prompt(\n", " prompt,\n", " prompt_2,\n", " num_images_per_prompt,\n", " do_classifier_free_guidance,\n", " negative_prompt,\n", " negative_prompt_2,\n", " prompt_embeds=prompt_embeds,\n", " negative_prompt_embeds=negative_prompt_embeds,\n", " pooled_prompt_embeds=pooled_prompt_embeds,\n", " negative_pooled_prompt_embeds=negative_pooled_prompt_embeds,\n", " lora_scale=None,\n", " clip_skip=clip_skip,\n", " )\n", "\n", " # 3.2 Encode image prompt\n", " prompt_image_emb = self._encode_prompt_image_emb(image_embeds, num_images_per_prompt, do_classifier_free_guidance)\n", "\n", " # 4. Prepare image\n", " image = self.prepare_image(\n", " image=image,\n", " width=width,\n", " height=height,\n", " batch_size=batch_size * num_images_per_prompt,\n", " num_images_per_prompt=num_images_per_prompt,\n", " do_classifier_free_guidance=do_classifier_free_guidance,\n", " guess_mode=guess_mode,\n", " )\n", " height, width = image.shape[-2:]\n", "\n", " # 5. Prepare timesteps\n", " self.scheduler.set_timesteps(num_inference_steps)\n", " timesteps = self.scheduler.timesteps\n", "\n", " # 6. Prepare latent variables\n", " num_channels_latents = 4\n", " latents = self.prepare_latents(\n", " int(batch_size) * int(num_images_per_prompt),\n", " int(num_channels_latents),\n", " int(height),\n", " int(width),\n", " dtype=torch.float32,\n", " device=torch.device(\"cpu\"),\n", " generator=generator,\n", " latents=latents,\n", " )\n", "\n", " # 7. Prepare extra step kwargs.\n", " extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)\n", " # 7.1 Create tensor stating which controlnets to keep\n", " controlnet_keep = []\n", " for i in range(len(timesteps)):\n", " keeps = [1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e) for s, e in zip(control_guidance_start, control_guidance_end)]\n", " controlnet_keep.append(keeps)\n", "\n", " # 7.2 Prepare added time ids & embeddings\n", " if isinstance(image, list):\n", " original_size = original_size or image[0].shape[-2:]\n", " else:\n", " original_size = original_size or image.shape[-2:]\n", " target_size = target_size or (height, width)\n", "\n", " add_text_embeds = pooled_prompt_embeds\n", " if self.text_encoder_2 is None:\n", " text_encoder_projection_dim = pooled_prompt_embeds.shape[-1]\n", " else:\n", " text_encoder_projection_dim = 1280\n", "\n", " add_time_ids = self._get_add_time_ids(\n", " original_size,\n", " crops_coords_top_left,\n", " target_size,\n", " text_encoder_projection_dim=text_encoder_projection_dim,\n", " )\n", "\n", " if negative_original_size is not None and negative_target_size is not None:\n", " negative_add_time_ids = self._get_add_time_ids(\n", " negative_original_size,\n", " negative_crops_coords_top_left,\n", " negative_target_size,\n", " text_encoder_projection_dim=text_encoder_projection_dim,\n", " )\n", " else:\n", " negative_add_time_ids = add_time_ids\n", "\n", " if do_classifier_free_guidance:\n", " prompt_embeds = np.concatenate([negative_prompt_embeds, prompt_embeds], axis=0)\n", " add_text_embeds = np.concatenate([negative_pooled_prompt_embeds, add_text_embeds], axis=0)\n", " add_time_ids = np.concatenate([negative_add_time_ids, add_time_ids], axis=0)\n", "\n", " add_time_ids = np.tile(add_time_ids, (batch_size * num_images_per_prompt, 1))\n", " encoder_hidden_states = np.concatenate([prompt_embeds, prompt_image_emb], axis=1)\n", "\n", " # 8. Denoising loop\n", " with self.progress_bar(total=num_inference_steps) as progress_bar:\n", " for i, t in enumerate(timesteps):\n", " # expand the latents if we are doing classifier free guidance\n", " latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents\n", " latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n", "\n", " # controlnet(s) inference\n", " control_model_input = latent_model_input\n", "\n", " cond_scale = controlnet_conditioning_scale\n", "\n", " controlnet_outputs = self.controlnet(\n", " [\n", " control_model_input,\n", " t,\n", " prompt_image_emb,\n", " image,\n", " cond_scale,\n", " add_text_embeds,\n", " add_time_ids,\n", " ]\n", " )\n", "\n", " controlnet_additional_blocks = list(controlnet_outputs.values())\n", "\n", " # predict the noise residual\n", " noise_pred = self.unet(\n", " [\n", " latent_model_input,\n", " t,\n", " encoder_hidden_states,\n", " *controlnet_additional_blocks,\n", " add_text_embeds,\n", " add_time_ids,\n", " ]\n", " )[0]\n", "\n", " # perform guidance\n", " if do_classifier_free_guidance:\n", " noise_pred_uncond, noise_pred_text = noise_pred[0], noise_pred[1]\n", " noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n", "\n", " # compute the previous noisy sample x_t -> x_t-1\n", " latents = self.scheduler.step(\n", " torch.from_numpy(noise_pred),\n", " t,\n", " latents,\n", " **extra_step_kwargs,\n", " return_dict=False,\n", " )[0]\n", " progress_bar.update()\n", "\n", " if not output_type == \"latent\":\n", " image = self.vae_decoder(latents / self.vae_scaling_factor)[0]\n", " else:\n", " image = latents\n", "\n", " if not output_type == \"latent\":\n", " image = self.image_processor.postprocess(torch.from_numpy(image), output_type=output_type)\n", "\n", " if not return_dict:\n", " return (image,)\n", "\n", " return StableDiffusionXLPipelineOutput(images=image)\n", "\n", " def encode_prompt(\n", " self,\n", " prompt: str,\n", " prompt_2: Optional[str] = None,\n", " num_images_per_prompt: int = 1,\n", " do_classifier_free_guidance: bool = True,\n", " negative_prompt: Optional[str] = None,\n", " negative_prompt_2: Optional[str] = None,\n", " prompt_embeds: Optional[torch.FloatTensor] = None,\n", " negative_prompt_embeds: Optional[torch.FloatTensor] = None,\n", " pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n", " negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None,\n", " lora_scale: Optional[float] = None,\n", " clip_skip: Optional[int] = None,\n", " ):\n", " r\"\"\"\n", " Encodes the prompt into text encoder hidden states.\n", "\n", " Args:\n", " prompt (`str` or `List[str]`, *optional*):\n", " prompt to be encoded\n", " prompt_2 (`str` or `List[str]`, *optional*):\n", " The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is\n", " used in both text-encoders\n", " num_images_per_prompt (`int`):\n", " number of images that should be generated per prompt\n", " do_classifier_free_guidance (`bool`):\n", " whether to use classifier free guidance or not\n", " negative_prompt (`str` or `List[str]`, *optional*):\n", " The prompt or prompts not to guide the image generation. If not defined, one has to pass\n", " `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is\n", " less than `1`).\n", " negative_prompt_2 (`str` or `List[str]`, *optional*):\n", " The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and\n", " `text_encoder_2`. If not defined, `negative_prompt` is used in both text-encoders\n", " prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not\n", " provided, text embeddings will be generated from `prompt` input argument.\n", " negative_prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt\n", " weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input\n", " argument.\n", " pooled_prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting.\n", " If not provided, pooled text embeddings will be generated from `prompt` input argument.\n", " negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*):\n", " Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt\n", " weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt`\n", " input argument.\n", " lora_scale (`float`, *optional*):\n", " A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.\n", " clip_skip (`int`, *optional*):\n", " Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that\n", " the output of the pre-final layer will be used for computing the prompt embeddings.\n", " \"\"\"\n", " prompt = [prompt] if isinstance(prompt, str) else prompt\n", "\n", " if prompt is not None:\n", " batch_size = len(prompt)\n", " else:\n", " batch_size = prompt_embeds.shape[0]\n", "\n", " # Define tokenizers and text encoders\n", " tokenizers = [self.tokenizer, self.tokenizer_2] if self.tokenizer is not None else [self.tokenizer_2]\n", " text_encoders = [self.text_encoder, self.text_encoder_2] if self.text_encoder is not None else [self.text_encoder_2]\n", "\n", " if prompt_embeds is None:\n", " prompt_2 = prompt_2 or prompt\n", " prompt_2 = [prompt_2] if isinstance(prompt_2, str) else prompt_2\n", "\n", " # textual inversion: procecss multi-vector tokens if necessary\n", " prompt_embeds_list = []\n", " prompts = [prompt, prompt_2]\n", " for prompt, tokenizer, text_encoder in zip(prompts, tokenizers, text_encoders):\n", " text_inputs = tokenizer(\n", " prompt,\n", " padding=\"max_length\",\n", " max_length=tokenizer.model_max_length,\n", " truncation=True,\n", " return_tensors=\"pt\",\n", " )\n", "\n", " text_input_ids = text_inputs.input_ids\n", "\n", " prompt_embeds = text_encoder(text_input_ids)\n", "\n", " # We are only ALWAYS interested in the pooled output of the final text encoder\n", " pooled_prompt_embeds = prompt_embeds[0]\n", " hidden_states = list(prompt_embeds.values())[1:]\n", " if clip_skip is None:\n", " prompt_embeds = hidden_states[-2]\n", " else:\n", " # \"2\" because SDXL always indexes from the penultimate layer.\n", " prompt_embeds = hidden_states[-(clip_skip + 2)]\n", "\n", " prompt_embeds_list.append(prompt_embeds)\n", "\n", " prompt_embeds = np.concatenate(prompt_embeds_list, axis=-1)\n", "\n", " # get unconditional embeddings for classifier free guidance\n", " zero_out_negative_prompt = negative_prompt is None\n", " if do_classifier_free_guidance and negative_prompt_embeds is None and zero_out_negative_prompt:\n", " negative_prompt_embeds = np.zeros_like(prompt_embeds)\n", " negative_pooled_prompt_embeds = np.zeros_like(pooled_prompt_embeds)\n", " elif do_classifier_free_guidance and negative_prompt_embeds is None:\n", " negative_prompt = negative_prompt or \"\"\n", " negative_prompt_2 = negative_prompt_2 or negative_prompt\n", "\n", " # normalize str to list\n", " negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt\n", " negative_prompt_2 = batch_size * [negative_prompt_2] if isinstance(negative_prompt_2, str) else negative_prompt_2\n", "\n", " uncond_tokens: List[str]\n", " if prompt is not None and type(prompt) is not type(negative_prompt):\n", " raise TypeError(f\"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !=\" f\" {type(prompt)}.\")\n", " elif batch_size != len(negative_prompt):\n", " raise ValueError(\n", " f\"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:\"\n", " f\" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches\"\n", " \" the batch size of `prompt`.\"\n", " )\n", " else:\n", " uncond_tokens = [negative_prompt, negative_prompt_2]\n", "\n", " negative_prompt_embeds_list = []\n", " for negative_prompt, tokenizer, text_encoder in zip(uncond_tokens, tokenizers, text_encoders):\n", " max_length = prompt_embeds.shape[1]\n", " uncond_input = tokenizer(\n", " negative_prompt,\n", " padding=\"max_length\",\n", " max_length=max_length,\n", " truncation=True,\n", " return_tensors=\"pt\",\n", " )\n", "\n", " negative_prompt_embeds = text_encoder(uncond_input.input_ids)\n", " # We are only ALWAYS interested in the pooled output of the final text encoder\n", " negative_pooled_prompt_embeds = negative_prompt_embeds[0]\n", " hidden_states = list(negative_prompt_embeds.values())[1:]\n", " negative_prompt_embeds = hidden_states[-2]\n", "\n", " negative_prompt_embeds_list.append(negative_prompt_embeds)\n", "\n", " negative_prompt_embeds = np.concatenate(negative_prompt_embeds_list, axis=-1)\n", "\n", " bs_embed, seq_len, _ = prompt_embeds.shape\n", " # duplicate text embeddings for each generation per prompt, using mps friendly method\n", " prompt_embeds = np.tile(prompt_embeds, (1, num_images_per_prompt, 1))\n", " prompt_embeds = prompt_embeds.reshape(bs_embed * num_images_per_prompt, seq_len, -1)\n", "\n", " if do_classifier_free_guidance:\n", " # duplicate unconditional embeddings for each generation per prompt, using mps friendly method\n", " seq_len = negative_prompt_embeds.shape[1]\n", " negative_prompt_embeds = np.tile(negative_prompt_embeds, (1, num_images_per_prompt, 1))\n", " negative_prompt_embeds = negative_prompt_embeds.reshape(batch_size * num_images_per_prompt, seq_len, -1)\n", "\n", " pooled_prompt_embeds = np.tile(pooled_prompt_embeds, (1, num_images_per_prompt)).reshape(bs_embed * num_images_per_prompt, -1)\n", " if do_classifier_free_guidance:\n", " negative_pooled_prompt_embeds = np.tile(negative_pooled_prompt_embeds, (1, num_images_per_prompt)).reshape(bs_embed * num_images_per_prompt, -1)\n", "\n", " return (\n", " prompt_embeds,\n", " negative_prompt_embeds,\n", " pooled_prompt_embeds,\n", " negative_pooled_prompt_embeds,\n", " )\n", "\n", " def prepare_image(\n", " self,\n", " image,\n", " width,\n", " height,\n", " batch_size,\n", " num_images_per_prompt,\n", " do_classifier_free_guidance=False,\n", " guess_mode=False,\n", " ):\n", " image = self.control_image_processor.preprocess(image, height=height, width=width).to(dtype=torch.float32)\n", " image_batch_size = image.shape[0]\n", "\n", " if image_batch_size == 1:\n", " repeat_by = batch_size\n", " else:\n", " # image batch size is the same as prompt batch size\n", " repeat_by = num_images_per_prompt\n", "\n", " image = image.repeat_interleave(repeat_by, dim=0)\n", "\n", " if do_classifier_free_guidance and not guess_mode:\n", " image = torch.cat([image] * 2)\n", "\n", " return image\n", "\n", " def _get_add_time_ids(\n", " self,\n", " original_size,\n", " crops_coords_top_left,\n", " target_size,\n", " text_encoder_projection_dim,\n", " ):\n", " add_time_ids = list(original_size + crops_coords_top_left + target_size)\n", " add_time_ids = torch.tensor([add_time_ids])\n", " return add_time_ids" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f8764e2d-b1ae-4d5a-9541-a170a9003de1", "metadata": {}, "source": [ "## Run OpenVINO pipeline inference\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "### Select inference device for InstantID\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 21, "id": "e33bf6f4-71b5-47a2-9e32-0479df8be454", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c636605a586a43749aeabe60c391baa7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Device:', index=1, options=('CPU', 'AUTO'), value='AUTO')" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "device" ] }, { "cell_type": "code", "execution_count": 22, "id": "e111bc7e-fac9-4881-a3d2-f39057f369b6", "metadata": {}, "outputs": [], "source": [ "text_encoder = core.compile_model(ov_text_encoder_path, device.value)\n", "text_encoder_2 = core.compile_model(ov_text_encoder_2_path, device.value)\n", "vae_decoder = core.compile_model(ov_vae_decoder_path, device.value)\n", "unet = core.compile_model(ov_unet_path, device.value)\n", "controlnet = core.compile_model(ov_controlnet_path, device.value)\n", "image_proj_model = core.compile_model(ov_image_proj_encoder_path, device.value)" ] }, { "cell_type": "code", "execution_count": 23, "id": "652b2d05-bd26-46c1-ba09-96f27db970e8", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "The config attributes {'interpolation_type': 'linear', 'skip_prk_steps': True, 'use_karras_sigmas': False} were passed to LCMScheduler, but are not expected and will be ignored. Please verify your scheduler_config.json configuration file.\n" ] } ], "source": [ "from transformers import AutoTokenizer\n", "\n", "tokenizer = AutoTokenizer.from_pretrained(MODELS_DIR / \"tokenizer\")\n", "tokenizer_2 = AutoTokenizer.from_pretrained(MODELS_DIR / \"tokenizer_2\")\n", "scheduler = LCMScheduler.from_pretrained(MODELS_DIR / \"scheduler\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3772ef85-8419-4f4a-bef7-7fd0061f3e09", "metadata": {}, "source": [ "### Create pipeline\n", "[back to top ⬆️](#Table-of-contents:)\n", "### Create pipeline" ] }, { "cell_type": "code", "execution_count": 24, "id": "15b05064-d917-41c5-b7f9-82fd1ff67fce", "metadata": {}, "outputs": [], "source": [ "ov_pipe = OVStableDiffusionXLInstantIDPipeline(\n", " text_encoder,\n", " text_encoder_2,\n", " image_proj_model,\n", " controlnet,\n", " unet,\n", " vae_decoder,\n", " tokenizer,\n", " tokenizer_2,\n", " scheduler,\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d35af81c-3bc9-4276-ad15-d6359ff1fcb0", "metadata": {}, "source": [ "### Run inference\n", "[back to top ⬆️](#Table-of-contents:)\n", "### Run inference" ] }, { "cell_type": "code", "execution_count": 25, "id": "95dd4b51-fe34-4aa8-99a7-fd995cf4b6bc", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2b36efcb22eb4b0790f8b02b1f727969", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/4 [00:00" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "image" ] }, { "attachments": {}, "cell_type": "markdown", "id": "0e23a7fc", "metadata": {}, "source": [ "## Quantization\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "[NNCF](https://github.com/openvinotoolkit/nncf/) enables post-training quantization by adding quantization layers into model graph and then using a subset of the training dataset to initialize the parameters of these additional quantization layers. Quantized operations are executed in `INT8` instead of `FP32`/`FP16` making model inference faster.\n", "\n", "According to `OVStableDiffusionXLInstantIDPipeline` structure, ControlNet and UNet models are used in the cycle repeating inference on each diffusion step, while other parts of pipeline take part only once. Now we will show you how to optimize pipeline using [NNCF](https://github.com/openvinotoolkit/nncf/) to reduce memory and computation cost.\n", "\n", "Please select below whether you would like to run quantization to improve model inference speed.\n", "\n", "> **NOTE**: Quantization is time and memory consuming operation. Running quantization code below may take some time." ] }, { "cell_type": "code", "execution_count": 27, "id": "6a68873d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3685d51e85d244169d53564472e30d9f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Checkbox(value=True, description='Quantization')" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "skip_for_device = \"GPU\" in device.value\n", "to_quantize = widgets.Checkbox(value=not skip_for_device, description=\"Quantization\", disabled=skip_for_device)\n", "to_quantize" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f47efa7d", "metadata": {}, "source": [ "Let's load `skip magic` extension to skip quantization if `to_quantize` is not selected" ] }, { "cell_type": "code", "execution_count": 28, "id": "d077d0a4", "metadata": {}, "outputs": [], "source": [ "# Fetch `skip_kernel_extension` module\n", "import requests\n", "\n", "r = requests.get(\n", " url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/skip_kernel_extension.py\",\n", ")\n", "open(\"skip_kernel_extension.py\", \"w\").write(r.text)\n", "\n", "int8_pipe = None\n", "\n", "%load_ext skip_kernel_extension" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c333ceb2", "metadata": {}, "source": [ "### Prepare calibration datasets\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "We use a portion of [`wider_face`](https://huggingface.co/datasets/wider_face) dataset from Hugging Face as calibration data. We use prompts below to guide image generation and to determine what not to include in the resulting image." ] }, { "cell_type": "code", "execution_count": 29, "id": "bfd90b7c", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "negative_prompts = [\n", " \"blurry unreal occluded\",\n", " \"low contrast disfigured uncentered mangled\",\n", " \"amateur out of frame low quality nsfw\",\n", " \"ugly underexposed jpeg artifacts\",\n", " \"low saturation disturbing content\",\n", " \"overexposed severe distortion\",\n", " \"amateur NSFW\",\n", " \"ugly mutilated out of frame disfigured\",\n", "]\n", "prompts = [\n", " \"a Naruto-style image of a young boy, incorporating dynamic action lines, intense energy effects, and a sense of movement and power\",\n", " \"an anime-style girl, with vibrant, otherworldly colors, fantastical elements, and a sense of awe\",\n", " \"analog film photo of a man. faded film, desaturated, 35mm photo, grainy, vignette, vintage, Kodachrome, Lomography, stained, highly detailed, found footage, masterpiece, best quality\",\n", " \"Apply a staining filter to give the impression of aged, worn-out film while maintaining sharp detail on a portrait of a woman\",\n", " \"a modern picture of a boy an antique feel through selective desaturation, grain addition, and a warm tone, mimicking the style of old photographs\",\n", " \"a dreamy, ethereal portrait of a young girl, featuring soft, pastel colors, a blurred background, and a touch of bokeh\",\n", " \"a dynamic, action-packed image of a boy in motion, using motion blur, panning, and other techniques to convey a sense of speed and energy\",\n", " \"a dramatic, cinematic image of a boy, using color grading, contrast adjustments, and a widescreen aspect ratio, to create a sense of epic scale and grandeur\",\n", " \"a portrait of a woman in the style of Picasso's cubism, featuring fragmented shapes, bold lines, and a vibrant color palette\",\n", " \"an artwork in the style of Picasso's Blue Period, featuring a somber, melancholic portrait of a person, with muted colors, elongated forms, and a sense of introspection and contemplation\",\n", "]" ] }, { "cell_type": "code", "execution_count": 32, "id": "79e974fe", "metadata": { "test_replace": { "subset_size = 200": "subset_size = 4" } }, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import datasets\n", "\n", "num_inference_steps = 4\n", "subset_size = 200\n", "\n", "ov_int8_unet_path = MODELS_DIR / 'unet_optimized.xml'\n", "ov_int8_controlnet_path = MODELS_DIR / 'controlnet_optimized.xml'\n", "\n", "num_samples = int(np.ceil(subset_size / num_inference_steps))\n", "dataset = datasets.load_dataset(\"wider_face\", split=\"train\", streaming=True).shuffle(seed=42)\n", "face_info = []\n", "for batch in dataset:\n", " try:\n", " face_info.append(get_face_info(batch[\"image\"]))\n", " except RuntimeError:\n", " continue\n", " if len(face_info) > num_samples:\n", " break" ] }, { "attachments": {}, "cell_type": "markdown", "id": "dd99e88a", "metadata": {}, "source": [ "\n", "To collect intermediate model inputs for calibration we should customize `CompiledModel`." ] }, { "cell_type": "code", "execution_count": 33, "id": "1052ff23", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "from tqdm.notebook import tqdm\n", "from transformers import set_seed\n", "\n", "set_seed(42)\n", "\n", "class CompiledModelDecorator(ov.CompiledModel):\n", " def __init__(self, compiled_model: ov.CompiledModel, keep_prob: float = 1.0):\n", " super().__init__(compiled_model)\n", " self.data_cache = []\n", " self.keep_prob = np.clip(keep_prob, 0, 1)\n", "\n", " def __call__(self, *args, **kwargs):\n", " if np.random.rand() <= self.keep_prob:\n", " self.data_cache.append(*args)\n", " return super().__call__(*args, **kwargs)\n", "\n", "\n", "def collect_calibration_data(pipeline, face_info, subset_size):\n", " original_unet = pipeline.unet\n", " pipeline.unet = CompiledModelDecorator(original_unet)\n", " pipeline.set_progress_bar_config(disable=True)\n", "\n", " pbar = tqdm(total=subset_size)\n", " for face_emb, face_kps in face_info:\n", " negative_prompt = np.random.choice(negative_prompts)\n", " prompt = np.random.choice(prompts)\n", " _ = pipeline(\n", " prompt,\n", " image_embeds=face_emb,\n", " image=face_kps,\n", " num_inference_steps=num_inference_steps,\n", " negative_prompt=negative_prompt,\n", " guidance_scale=0.5,\n", " generator=torch.Generator(device=\"cpu\").manual_seed(1749781188)\n", " )\n", " collected_subset_size = len(pipeline.unet.data_cache)\n", " pbar.update(collected_subset_size - pbar.n)\n", "\n", " calibration_dataset = pipeline.unet.data_cache[:subset_size]\n", " pipeline.set_progress_bar_config(disable=False)\n", " pipeline.unet = original_unet\n", " return calibration_dataset\n" ] }, { "cell_type": "code", "execution_count": null, "id": "8d032211", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "if not (ov_int8_unet_path.exists() and ov_int8_controlnet_path.exists()):\n", " unet_calibration_data = collect_calibration_data(ov_pipe, face_info, subset_size=subset_size)" ] }, { "cell_type": "code", "execution_count": 35, "id": "fa997281", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "def prepare_controlnet_dataset(pipeline, face_info, unet_calibration_data):\n", " controlnet_calibration_data = []\n", " i = 0\n", " for face_emb, face_kps in face_info:\n", " prompt_image_emb = pipeline._encode_prompt_image_emb(\n", " face_emb, num_images_per_prompt=1, do_classifier_free_guidance=False\n", " )\n", " image = pipeline.prepare_image(\n", " image=face_kps,\n", " width=None,\n", " height=None,\n", " batch_size=1,\n", " num_images_per_prompt=1,\n", " do_classifier_free_guidance=False,\n", " guess_mode=False,\n", " )\n", " for data in unet_calibration_data[i:i+num_inference_steps]:\n", " controlnet_inputs = [data[0], data[1], prompt_image_emb, image, 1.0, data[-2], data[-1]]\n", " controlnet_calibration_data.append(controlnet_inputs)\n", " i += num_inference_steps\n", " return controlnet_calibration_data\n" ] }, { "cell_type": "code", "execution_count": 36, "id": "0f69732b", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "if not ov_int8_controlnet_path.exists():\n", " controlnet_calibration_data = prepare_controlnet_dataset(ov_pipe, face_info, unet_calibration_data)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6b262146", "metadata": {}, "source": [ "### Run Quantization\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f49bb083", "metadata": {}, "source": [ "#### Run ControlNet Quantization\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Quantization of the first `Convolution` layer impacts the generation results. We recommend using `IgnoredScope` to keep accuracy sensitive layers in FP16 precision." ] }, { "cell_type": "code", "execution_count": null, "id": "e8a4f0ac", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import nncf\n", "\n", "if not ov_int8_controlnet_path.exists():\n", " controlnet = core.read_model(ov_controlnet_path)\n", " quantized_controlnet = nncf.quantize(\n", " model=controlnet,\n", " calibration_dataset=nncf.Dataset(controlnet_calibration_data),\n", " subset_size=subset_size,\n", " ignored_scope=nncf.IgnoredScope(names=[\"__module.model.conv_in/aten::_convolution/Convolution\"]),\n", " model_type=nncf.ModelType.TRANSFORMER,\n", " )\n", " ov.save_model(quantized_controlnet, ov_int8_controlnet_path)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "b3ce79be", "metadata": {}, "source": [ "#### Run UNet Hybrid Quantization\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "On the one hand, post-training quantization of the UNet model requires more than ~100Gb and leads to accuracy drop. On the other hand, the weight compression doesn't improve performance when applying to Stable Diffusion models, because the size of activations is comparable to weights. That is why the proposal is to apply quantization in hybrid mode which means that we quantize: (1) weights of MatMul and Embedding layers and (2) activations of other layers. The steps are the following:\n", "\n", "1. Create a calibration dataset for quantization.\n", "2. Collect operations with weights.\n", "3. Run `nncf.compress_model()` to compress only the model weights.\n", "4. Run `nncf.quantize()` on the compressed model with weighted operations ignored by providing `ignored_scope` parameter.\n", "5. Save the `INT8` model using `openvino.save_model()` function." ] }, { "cell_type": "code", "execution_count": 38, "id": "977a1fc0", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "from collections import deque\n", "\n", "def get_operation_const_op(operation, const_port_id: int):\n", " node = operation.input_value(const_port_id).get_node()\n", " queue = deque([node])\n", " constant_node = None\n", " allowed_propagation_types_list = [\"Convert\", \"FakeQuantize\", \"Reshape\"]\n", "\n", " while len(queue) != 0:\n", " curr_node = queue.popleft()\n", " if curr_node.get_type_name() == \"Constant\":\n", " constant_node = curr_node\n", " break\n", " if len(curr_node.inputs()) == 0:\n", " break\n", " if curr_node.get_type_name() in allowed_propagation_types_list:\n", " queue.append(curr_node.input_value(0).get_node())\n", "\n", " return constant_node\n", "\n", "\n", "def is_embedding(node) -> bool:\n", " allowed_types_list = [\"f16\", \"f32\", \"f64\"]\n", " const_port_id = 0\n", " input_tensor = node.input_value(const_port_id)\n", " if input_tensor.get_element_type().get_type_name() in allowed_types_list:\n", " const_node = get_operation_const_op(node, const_port_id)\n", " if const_node is not None:\n", " return True\n", "\n", " return False\n", "\n", "\n", "def collect_ops_with_weights(model):\n", " ops_with_weights = []\n", " for op in model.get_ops():\n", " if op.get_type_name() == \"MatMul\":\n", " constant_node_0 = get_operation_const_op(op, const_port_id=0)\n", " constant_node_1 = get_operation_const_op(op, const_port_id=1)\n", " if constant_node_0 or constant_node_1:\n", " ops_with_weights.append(op.get_friendly_name())\n", " if op.get_type_name() == \"Gather\" and is_embedding(op):\n", " ops_with_weights.append(op.get_friendly_name())\n", "\n", " return ops_with_weights" ] }, { "cell_type": "code", "execution_count": null, "id": "48720e95", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "if not ov_int8_unet_path.exists():\n", " unet = core.read_model(ov_unet_path)\n", " unet_ignored_scope = collect_ops_with_weights(unet)\n", " compressed_unet = nncf.compress_weights(unet, ignored_scope=nncf.IgnoredScope(types=['Convolution']))\n", " quantized_unet = nncf.quantize(\n", " model=compressed_unet,\n", " calibration_dataset=nncf.Dataset(unet_calibration_data),\n", " subset_size=subset_size,\n", " model_type=nncf.ModelType.TRANSFORMER,\n", " ignored_scope=nncf.IgnoredScope(names=unet_ignored_scope),\n", " advanced_parameters=nncf.AdvancedQuantizationParameters(smooth_quant_alpha=-1)\n", " )\n", " ov.save_model(quantized_unet, ov_int8_unet_path)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "44c4fc1b", "metadata": {}, "source": [ "#### Run Weights Compression\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Quantizing of the `Text Encoders` and `VAE Decoder` does not significantly improve inference performance but can lead to a substantial degradation of accuracy. The weight compression will be applied to footprint reduction." ] }, { "cell_type": "code", "execution_count": 40, "id": "eef92c31", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "ov_int8_text_encoder_path = MODELS_DIR / 'text_encoder_optimized.xml'\n", "ov_int8_text_encoder_2_path = MODELS_DIR / 'text_encoder_2_optimized.xml'\n", "ov_int8_vae_decoder_path = MODELS_DIR / 'vae_decoder_optimized.xml'\n", "\n", "if not ov_int8_text_encoder_path.exists():\n", " text_encoder = core.read_model(ov_text_encoder_path)\n", " compressed_text_encoder = nncf.compress_weights(text_encoder)\n", " ov.save_model(compressed_text_encoder, ov_int8_text_encoder_path)\n", "\n", "if not ov_int8_text_encoder_2_path.exists():\n", " text_encoder_2 = core.read_model(ov_text_encoder_2_path)\n", " compressed_text_encoder_2 = nncf.compress_weights(text_encoder_2)\n", " ov.save_model(compressed_text_encoder_2, ov_int8_text_encoder_2_path)\n", "\n", "if not ov_int8_vae_decoder_path.exists():\n", " vae_decoder = core.read_model(ov_vae_decoder_path)\n", " compressed_vae_decoder = nncf.compress_weights(vae_decoder)\n", " ov.save_model(compressed_vae_decoder, ov_int8_vae_decoder_path)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "9d61a276", "metadata": {}, "source": [ "Let's compare the images generated by the original and optimized pipelines." ] }, { "cell_type": "code", "execution_count": 41, "id": "a6b6b594", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "optimized_controlnet = core.compile_model(ov_int8_controlnet_path, device.value)\n", "optimized_unet = core.compile_model(ov_int8_unet_path, device.value)\n", "optimized_text_encoder = core.compile_model(ov_int8_text_encoder_path, device.value)\n", "optimized_text_encoder_2 = core.compile_model(ov_int8_text_encoder_2_path, device.value)\n", "optimized_vae_decoder = core.compile_model(ov_int8_vae_decoder_path, device.value)\n", "\n", "int8_pipe = OVStableDiffusionXLInstantIDPipeline(\n", " optimized_text_encoder,\n", " optimized_text_encoder_2,\n", " image_proj_model,\n", " optimized_controlnet,\n", " optimized_unet,\n", " optimized_vae_decoder,\n", " tokenizer,\n", " tokenizer_2,\n", " scheduler,\n", ")" ] }, { "cell_type": "code", "execution_count": 42, "id": "9b24c888", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "50f32fa601ab45369e73f446b72e72ac", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/4 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "visualize_results(image, int8_image)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a73d5698", "metadata": {}, "source": [ "### Compare model file sizes\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": null, "id": "e4b014e2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "unet compression rate: 1.996\n", "controlnet compression rate: 1.995\n", "text_encoder compression rate: 1.992\n", "text_encoder_2 compression rate: 1.995\n", "vae_decoder compression rate: 1.997\n" ] } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "fp16_model_paths = [ov_unet_path, ov_controlnet_path, ov_text_encoder_path, ov_text_encoder_2_path, ov_vae_decoder_path]\n", "int8_model_paths = [ov_int8_unet_path, ov_int8_controlnet_path, ov_int8_text_encoder_path, ov_int8_text_encoder_2_path, ov_int8_vae_decoder_path]\n", "\n", "for fp16_path, int8_path in zip(fp16_model_paths, int8_model_paths):\n", " fp16_ir_model_size = fp16_path.with_suffix(\".bin\").stat().st_size\n", " int8_model_size = int8_path.with_suffix(\".bin\").stat().st_size\n", " print(f\"{fp16_path.stem} compression rate: {fp16_ir_model_size / int8_model_size:.3f}\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "8f1298f2", "metadata": {}, "source": [ "### Compare inference time of the FP16 and INT8 pipelines\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "To measure the inference performance of the `FP16` and `INT8` pipelines, we use mean inference time on 5 samples.\n", "\n", "> **NOTE**: For the most accurate performance estimation, it is recommended to run `benchmark_app` in a terminal/command prompt after closing other applications." ] }, { "cell_type": "code", "execution_count": null, "id": "752130d7", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import time\n", "\n", "def calculate_inference_time(pipeline, face_info):\n", " inference_time = []\n", " pipeline.set_progress_bar_config(disable=True)\n", " for i in range(5):\n", " face_emb, face_kps = face_info[i]\n", " prompt = np.random.choice(prompts)\n", " negative_prompt = np.random.choice(negative_prompts)\n", " start = time.perf_counter()\n", " _ = pipeline(\n", " prompt,\n", " image_embeds=face_emb,\n", " image=face_kps,\n", " num_inference_steps=4,\n", " negative_prompt=negative_prompt,\n", " guidance_scale=0.5,\n", " generator=torch.Generator(device=\"cpu\").manual_seed(1749781188)\n", " )\n", " end = time.perf_counter()\n", " delta = end - start\n", " inference_time.append(delta)\n", " pipeline.set_progress_bar_config(disable=False)\n", " return np.mean(inference_time)" ] }, { "cell_type": "code", "execution_count": null, "id": "1ce11624", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "FP16 pipeline: 17.595 seconds\n", "INT8 pipeline: 15.258 seconds\n", "Performance speed-up: 1.153\n" ] } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "fp_latency = calculate_inference_time(ov_pipe, face_info)\n", "print(f\"FP16 pipeline: {fp_latency:.3f} seconds\")\n", "int8_latency = calculate_inference_time(int8_pipe, face_info)\n", "print(f\"INT8 pipeline: {int8_latency:.3f} seconds\")\n", "print(f\"Performance speed-up: {fp_latency / int8_latency:.3f}\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "29c60b3d-c990-494c-89c3-9e0beaeabc33", "metadata": {}, "source": [ "## Interactive demo\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Please select below whether you would like to use the quantized models to launch the interactive demo." ] }, { "cell_type": "code", "execution_count": null, "id": "ef7d4415", "metadata": {}, "outputs": [], "source": [ "quantized_models_present = int8_pipe is not None\n", "\n", "use_quantized_models = widgets.Checkbox(\n", " value=quantized_models_present,\n", " description=\"Use quantized models\",\n", " disabled=not quantized_models_present,\n", ")\n", "\n", "use_quantized_models" ] }, { "cell_type": "code", "execution_count": null, "id": "63adc8fe-1965-4458-aa5d-a9a6ac676801", "metadata": {}, "outputs": [], "source": [ "import gradio as gr\n", "from typing import Tuple\n", "import random\n", "import PIL\n", "import sys\n", "\n", "sys.path.append(\"./InstantID/gradio_demo\")\n", "\n", "from style_template import styles\n", "\n", "# global variable\n", "MAX_SEED = np.iinfo(np.int32).max\n", "STYLE_NAMES = list(styles.keys())\n", "DEFAULT_STYLE_NAME = \"Watercolor\"\n", "\n", "\n", "example_image_urls = [\n", " \"https://huggingface.co/datasets/EnD-Diffusers/AI_Faces/resolve/main/00002-3104853212.png\",\n", " \"https://huggingface.co/datasets/EnD-Diffusers/AI_Faces/resolve/main/images%207/00171-2728008415.png\",\n", " \"https://huggingface.co/datasets/EnD-Diffusers/AI_Faces/resolve/main/00003-3962843561.png\",\n", " \"https://huggingface.co/datasets/EnD-Diffusers/AI_Faces/resolve/main/00005-3104853215.png\",\n", " \"https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/ai_face2.png\",\n", "]\n", "\n", "examples_dir = Path(\"examples\")\n", "\n", "examples = [\n", " [examples_dir / \"face_0.png\", \"A woman in red dress\", \"Film Noir\", \"\"],\n", " [examples_dir / \"face_1.png\", \"photo of a business lady\", \"Vibrant Color\", \"\"],\n", " [examples_dir / \"face_2.png\", \"famous rock star poster\", \"(No style)\", \"\"],\n", " [examples_dir / \"face_3.png\", \"a person\", \"Neon\", \"\"],\n", " [examples_dir / \"face_4.png\", \"a girl\", \"Snow\", \"\"],\n", "]\n", "\n", "pipeline = int8_pipe if use_quantized_models.value else ov_pipe\n", "\n", "\n", "if not examples_dir.exists():\n", " examples_dir.mkdir()\n", " for img_id, img_url in enumerate(example_image_urls):\n", " load_image(img_url).save(examples_dir / f\"face_{img_id}.png\")\n", "\n", "\n", "def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:\n", " if randomize_seed:\n", " seed = random.randint(0, MAX_SEED)\n", " return seed\n", "\n", "\n", "def convert_from_cv2_to_image(img: np.ndarray) -> PIL.Image:\n", " return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))\n", "\n", "\n", "def convert_from_image_to_cv2(img: PIL.Image) -> np.ndarray:\n", " return cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)\n", "\n", "\n", "def resize_img(\n", " input_image,\n", " max_side=1024,\n", " min_side=800,\n", " size=None,\n", " pad_to_max_side=False,\n", " mode=PIL.Image.BILINEAR,\n", " base_pixel_number=64,\n", "):\n", " w, h = input_image.size\n", " if size is not None:\n", " w_resize_new, h_resize_new = size\n", " else:\n", " ratio = min_side / min(h, w)\n", " w, h = round(ratio * w), round(ratio * h)\n", " ratio = max_side / max(h, w)\n", " input_image = input_image.resize([round(ratio * w), round(ratio * h)], mode)\n", " w_resize_new = (round(ratio * w) // base_pixel_number) * base_pixel_number\n", " h_resize_new = (round(ratio * h) // base_pixel_number) * base_pixel_number\n", " input_image = input_image.resize([w_resize_new, h_resize_new], mode)\n", "\n", " if pad_to_max_side:\n", " res = np.ones([max_side, max_side, 3], dtype=np.uint8) * 255\n", " offset_x = (max_side - w_resize_new) // 2\n", " offset_y = (max_side - h_resize_new) // 2\n", " res[offset_y : offset_y + h_resize_new, offset_x : offset_x + w_resize_new] = np.array(input_image)\n", " input_image = Image.fromarray(res)\n", " return input_image\n", "\n", "\n", "def apply_style(style_name: str, positive: str, negative: str = \"\") -> Tuple[str, str]:\n", " p, n = styles.get(style_name, styles[DEFAULT_STYLE_NAME])\n", " return p.replace(\"{prompt}\", positive), n + \" \" + negative\n", "\n", "\n", "def generate_image(\n", " face_image,\n", " pose_image,\n", " prompt,\n", " negative_prompt,\n", " style_name,\n", " num_steps,\n", " identitynet_strength_ratio,\n", " guidance_scale,\n", " seed,\n", " progress=gr.Progress(track_tqdm=True),\n", "):\n", " if prompt is None:\n", " prompt = \"a person\"\n", "\n", " # apply the style template\n", " prompt, negative_prompt = apply_style(style_name, prompt, negative_prompt)\n", "\n", " # face_image = load_image(face_image_path)\n", " face_image = resize_img(face_image)\n", " face_image_cv2 = convert_from_image_to_cv2(face_image)\n", " height, width, _ = face_image_cv2.shape\n", "\n", " # Extract face features\n", " face_info = app.get(face_image_cv2)\n", "\n", " if len(face_info) == 0:\n", " raise gr.Error(\"Cannot find any face in the image! Please upload another person image\")\n", "\n", " face_info = sorted(\n", " face_info,\n", " key=lambda x: (x[\"bbox\"][2] - x[\"bbox\"][0]) * x[\"bbox\"][3] - x[\"bbox\"][1],\n", " )[\n", " -1\n", " ] # only use the maximum face\n", " face_emb = face_info[\"embedding\"]\n", " face_kps = draw_kps(convert_from_cv2_to_image(face_image_cv2), face_info[\"kps\"])\n", "\n", " if pose_image is not None:\n", " # pose_image = load_image(pose_image_path)\n", " pose_image = resize_img(pose_image)\n", " pose_image_cv2 = convert_from_image_to_cv2(pose_image)\n", "\n", " face_info = app.get(pose_image_cv2)\n", "\n", " if len(face_info) == 0:\n", " raise gr.Error(\"Cannot find any face in the reference image! Please upload another person image\")\n", "\n", " face_info = face_info[-1]\n", " face_kps = draw_kps(pose_image, face_info[\"kps\"])\n", "\n", " width, height = face_kps.size\n", "\n", " generator = torch.Generator(device=\"cpu\").manual_seed(seed)\n", "\n", " print(\"Start inference...\")\n", " print(f\"[Debug] Prompt: {prompt}, \\n[Debug] Neg Prompt: {negative_prompt}\")\n", " images = pipeline(\n", " prompt=prompt,\n", " negative_prompt=negative_prompt,\n", " image_embeds=face_emb,\n", " image=face_kps,\n", " controlnet_conditioning_scale=float(identitynet_strength_ratio),\n", " num_inference_steps=num_steps,\n", " guidance_scale=guidance_scale,\n", " height=height,\n", " width=width,\n", " generator=generator,\n", " ).images\n", "\n", " return images[0]\n", "\n", "\n", "### Description\n", "title = r\"\"\"\n", "

InstantID: Zero-shot Identity-Preserving Generation

\n", "\"\"\"\n", "\n", "description = r\"\"\"\n", "\n", " How to use:
\n", " 1. Upload an image with a face. For images with multiple faces, we will only detect the largest face. Ensure the face is not too small and is clearly visible without significant obstructions or blurring.\n", " 2. (Optional) You can upload another image as a reference for the face pose. If you don't, we will use the first detected face image to extract facial landmarks. If you use a cropped face at step 1, it is recommended to upload it to define a new face pose.\n", " 3. Enter a text prompt, as done in normal text-to-image models.\n", " 4. Click the Submit button to begin customization.\n", " 5. Share your customized photo with your friends and enjoy! 😊\n", " \"\"\"\n", "\n", "\n", "css = \"\"\"\n", " .gradio-container {width: 85% !important}\n", " \"\"\"\n", "with gr.Blocks(css=css) as demo:\n", " # description\n", " gr.Markdown(title)\n", " gr.Markdown(description)\n", "\n", " with gr.Row():\n", " with gr.Column():\n", " # upload face image\n", " face_file = gr.Image(label=\"Upload a photo of your face\", type=\"pil\")\n", "\n", " # optional: upload a reference pose image\n", " pose_file = gr.Image(label=\"Upload a reference pose image (optional)\", type=\"pil\")\n", "\n", " # prompt\n", " prompt = gr.Textbox(\n", " label=\"Prompt\",\n", " info=\"Give simple prompt is enough to achieve good face fidelity\",\n", " placeholder=\"A photo of a person\",\n", " value=\"\",\n", " )\n", "\n", " submit = gr.Button(\"Submit\", variant=\"primary\")\n", " style = gr.Dropdown(label=\"Style template\", choices=STYLE_NAMES, value=DEFAULT_STYLE_NAME)\n", "\n", " # strength\n", " identitynet_strength_ratio = gr.Slider(\n", " label=\"IdentityNet strength (for fidelity)\",\n", " minimum=0,\n", " maximum=1.5,\n", " step=0.05,\n", " value=0.80,\n", " )\n", "\n", " with gr.Accordion(open=False, label=\"Advanced Options\"):\n", " negative_prompt = gr.Textbox(\n", " label=\"Negative Prompt\",\n", " placeholder=\"low quality\",\n", " value=\"(lowres, low quality, worst quality:1.2), (text:1.2), watermark, (frame:1.2), deformed, ugly, deformed eyes, blur, out of focus, blurry, deformed cat, deformed, photo, anthropomorphic cat, monochrome, pet collar, gun, weapon, blue, 3d, drones, drone, buildings in background, green\",\n", " )\n", " num_steps = gr.Slider(\n", " label=\"Number of sample steps\",\n", " minimum=1,\n", " maximum=10,\n", " step=1,\n", " value=4,\n", " )\n", " guidance_scale = gr.Slider(label=\"Guidance scale\", minimum=0.1, maximum=10.0, step=0.1, value=0)\n", " seed = gr.Slider(\n", " label=\"Seed\",\n", " minimum=0,\n", " maximum=MAX_SEED,\n", " step=1,\n", " value=42,\n", " )\n", " randomize_seed = gr.Checkbox(label=\"Randomize seed\", value=True)\n", " gr.Examples(\n", " examples=examples,\n", " inputs=[face_file, prompt, style, negative_prompt],\n", " )\n", "\n", " with gr.Column():\n", " gallery = gr.Image(label=\"Generated Image\")\n", "\n", " submit.click(\n", " fn=randomize_seed_fn,\n", " inputs=[seed, randomize_seed],\n", " outputs=seed,\n", " api_name=False,\n", " ).then(\n", " fn=generate_image,\n", " inputs=[\n", " face_file,\n", " pose_file,\n", " prompt,\n", " negative_prompt,\n", " style,\n", " num_steps,\n", " identitynet_strength_ratio,\n", " guidance_scale,\n", " seed,\n", " ],\n", " outputs=[gallery],\n", " )" ] }, { "cell_type": "code", "execution_count": null, "id": "89d169ba-369d-49d5-b89e-6eb38079ae1a", "metadata": {}, "outputs": [], "source": [ "if __name__ == \"__main__\":\n", " try:\n", " demo.launch(debug=True)\n", " except Exception:\n", " demo.launch(share=True, debug=True)\n", "# if you are launching remotely, specify server_name and server_port\n", "# demo.launch(server_name='your server name', server_port='server port in int')\n", "# Read more in the docs: https://gradio.app/docs/" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" }, "openvino_notebooks": { "imageUrl": "https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/79d9d244-8c65-4564-9baa-80a73c4674bf", "tags": { "categories": [ "Model Demos", "AI Trends" ], "libraries": [], "other": [ "Stable Diffusion" ], "tasks": [ "Image-to-Image", "Text-to-Image" ] } }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }